[linux-block.git] / drivers / thunderbolt / tunnel.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Thunderbolt driver - Tunneling support
 *
 * Copyright (c) 2014 Andreas Noever <andreas.noever@gmail.com>
 * Copyright (C) 2019, Intel Corporation
 */

#include <linux/slab.h>
#include <linux/list.h>

#include "tunnel.h"
#include "tb.h"

/* PCIe adapters use always HopID of 8 for both directions */
#define TB_PCI_HOPID			8

#define TB_PCI_PATH_DOWN		0
#define TB_PCI_PATH_UP			1

/* DP adapters use HopID 8 for AUX and 9 for Video */
#define TB_DP_AUX_TX_HOPID		8
#define TB_DP_AUX_RX_HOPID		8
#define TB_DP_VIDEO_HOPID		9

#define TB_DP_VIDEO_PATH_OUT		0
#define TB_DP_AUX_PATH_OUT		1
#define TB_DP_AUX_PATH_IN		2

#define TB_DMA_PATH_OUT			0
#define TB_DMA_PATH_IN			1

static const char * const tb_tunnel_names[] = { "PCI", "DP", "DMA" };

#define __TB_TUNNEL_PRINT(level, tunnel, fmt, arg...)                   \
	do {                                                            \
		struct tb_tunnel *__tunnel = (tunnel);                  \
		level(__tunnel->tb, "%llx:%x <-> %llx:%x (%s): " fmt,   \
		      tb_route(__tunnel->src_port->sw),                 \
		      __tunnel->src_port->port,                         \
		      tb_route(__tunnel->dst_port->sw),                 \
		      __tunnel->dst_port->port,                         \
		      tb_tunnel_names[__tunnel->type],			\
		      ## arg);                                          \
	} while (0)

#define tb_tunnel_WARN(tunnel, fmt, arg...) \
	__TB_TUNNEL_PRINT(tb_WARN, tunnel, fmt, ##arg)
#define tb_tunnel_warn(tunnel, fmt, arg...) \
	__TB_TUNNEL_PRINT(tb_warn, tunnel, fmt, ##arg)
#define tb_tunnel_info(tunnel, fmt, arg...) \
	__TB_TUNNEL_PRINT(tb_info, tunnel, fmt, ##arg)
#define tb_tunnel_dbg(tunnel, fmt, arg...) \
	__TB_TUNNEL_PRINT(tb_dbg, tunnel, fmt, ##arg)

static struct tb_tunnel *tb_tunnel_alloc(struct tb *tb, size_t npaths,
					 enum tb_tunnel_type type)
{
	struct tb_tunnel *tunnel;

	tunnel = kzalloc(sizeof(*tunnel), GFP_KERNEL);
	if (!tunnel)
		return NULL;

	tunnel->paths = kcalloc(npaths, sizeof(tunnel->paths[0]), GFP_KERNEL);
	if (!tunnel->paths) {
		tb_tunnel_free(tunnel);
		return NULL;
	}

	INIT_LIST_HEAD(&tunnel->list);
	tunnel->tb = tb;
	tunnel->npaths = npaths;
	tunnel->type = type;

	return tunnel;
}

static int tb_pci_activate(struct tb_tunnel *tunnel, bool activate)
{
	int res;

	res = tb_pci_port_enable(tunnel->src_port, activate);
	if (res)
		return res;

	if (tb_port_is_pcie_up(tunnel->dst_port))
		return tb_pci_port_enable(tunnel->dst_port, activate);

	return 0;
}

static void tb_pci_init_path(struct tb_path *path)
{
	path->egress_fc_enable = TB_PATH_SOURCE | TB_PATH_INTERNAL;
	path->egress_shared_buffer = TB_PATH_NONE;
	path->ingress_fc_enable = TB_PATH_ALL;
	path->ingress_shared_buffer = TB_PATH_NONE;
	path->priority = 3;
	path->weight = 1;
	path->drop_packages = 0;
	path->nfc_credits = 0;
	path->hops[0].initial_credits = 7;
	path->hops[1].initial_credits = 16;
}

/**
 * tb_tunnel_discover_pci() - Discover existing PCIe tunnels
 * @tb: Pointer to the domain structure
 * @down: PCIe downstream adapter
 *
 * If @down adapter is active, follows the tunnel to the PCIe upstream
 * adapter and back. Returns the discovered tunnel or %NULL if there was
 * no tunnel.
 */
struct tb_tunnel *tb_tunnel_discover_pci(struct tb *tb, struct tb_port *down)
{
	struct tb_tunnel *tunnel;
	struct tb_path *path;

	if (!tb_pci_port_is_enabled(down))
		return NULL;

	tunnel = tb_tunnel_alloc(tb, 2, TB_TUNNEL_PCI);
	if (!tunnel)
		return NULL;

	tunnel->activate = tb_pci_activate;
	tunnel->src_port = down;

	/*
	 * Discover both paths even if they are not complete. We will
	 * clean them up by calling tb_tunnel_deactivate() below in that
	 * case.
	 */
	path = tb_path_discover(down, TB_PCI_HOPID, NULL, -1,
				&tunnel->dst_port, "PCIe Up");
	if (!path) {
		/* Just disable the downstream port */
		tb_pci_port_enable(down, false);
		goto err_free;
	}
	tunnel->paths[TB_PCI_PATH_UP] = path;
	tb_pci_init_path(tunnel->paths[TB_PCI_PATH_UP]);

	path = tb_path_discover(tunnel->dst_port, -1, down, TB_PCI_HOPID, NULL,
				"PCIe Down");
	if (!path)
		goto err_deactivate;
	tunnel->paths[TB_PCI_PATH_DOWN] = path;
	tb_pci_init_path(tunnel->paths[TB_PCI_PATH_DOWN]);

	/* Validate that the tunnel is complete */
	if (!tb_port_is_pcie_up(tunnel->dst_port)) {
		tb_port_warn(tunnel->dst_port,
			     "path does not end on a PCIe adapter, cleaning up\n");
		goto err_deactivate;
	}

	if (down != tunnel->src_port) {
		tb_tunnel_warn(tunnel, "path is not complete, cleaning up\n");
		goto err_deactivate;
	}

	if (!tb_pci_port_is_enabled(tunnel->dst_port)) {
		tb_tunnel_warn(tunnel,
			       "tunnel is not fully activated, cleaning up\n");
		goto err_deactivate;
	}

	tb_tunnel_dbg(tunnel, "discovered\n");
	return tunnel;

err_deactivate:
	tb_tunnel_deactivate(tunnel);
err_free:
	tb_tunnel_free(tunnel);

	return NULL;
}

/**
 * tb_tunnel_alloc_pci() - allocate a pci tunnel
 * @tb: Pointer to the domain structure
 * @up: PCIe upstream adapter port
 * @down: PCIe downstream adapter port
 *
 * Allocate a PCI tunnel. The ports must be of type TB_TYPE_PCIE_UP and
 * TB_TYPE_PCIE_DOWN.
 *
 * Return: Returns a tb_tunnel on success or NULL on failure.
 */
struct tb_tunnel *tb_tunnel_alloc_pci(struct tb *tb, struct tb_port *up,
				      struct tb_port *down)
{
	struct tb_tunnel *tunnel;
	struct tb_path *path;

	tunnel = tb_tunnel_alloc(tb, 2, TB_TUNNEL_PCI);
	if (!tunnel)
		return NULL;

	tunnel->activate = tb_pci_activate;
	tunnel->src_port = down;
	tunnel->dst_port = up;

	path = tb_path_alloc(tb, down, TB_PCI_HOPID, up, TB_PCI_HOPID, 0,
			     "PCIe Down");
	if (!path) {
		tb_tunnel_free(tunnel);
		return NULL;
	}
	tb_pci_init_path(path);
	tunnel->paths[TB_PCI_PATH_UP] = path;

	path = tb_path_alloc(tb, up, TB_PCI_HOPID, down, TB_PCI_HOPID, 0,
			     "PCIe Up");
	if (!path) {
		tb_tunnel_free(tunnel);
		return NULL;
	}
	tb_pci_init_path(path);
	tunnel->paths[TB_PCI_PATH_DOWN] = path;

	return tunnel;
}

static int tb_dp_xchg_caps(struct tb_tunnel *tunnel)
{
	struct tb_port *out = tunnel->dst_port;
	struct tb_port *in = tunnel->src_port;
	u32 in_dp_cap, out_dp_cap;
	int ret;

	/*
	 * Copy DP_LOCAL_CAP register to DP_REMOTE_CAP register for
	 * newer generation hardware.
	 */
	if (in->sw->generation < 2 || out->sw->generation < 2)
		return 0;

	/* Read both DP_LOCAL_CAP registers */
	ret = tb_port_read(in, &in_dp_cap, TB_CFG_PORT,
			   in->cap_adap + TB_DP_LOCAL_CAP, 1);
	if (ret)
		return ret;

	ret = tb_port_read(out, &out_dp_cap, TB_CFG_PORT,
			   out->cap_adap + TB_DP_LOCAL_CAP, 1);
	if (ret)
		return ret;

	/* Write IN local caps to OUT remote caps */
	ret = tb_port_write(out, &in_dp_cap, TB_CFG_PORT,
			    out->cap_adap + TB_DP_REMOTE_CAP, 1);
	if (ret)
		return ret;

	return tb_port_write(in, &out_dp_cap, TB_CFG_PORT,
			     in->cap_adap + TB_DP_REMOTE_CAP, 1);
}

static int tb_dp_activate(struct tb_tunnel *tunnel, bool active)
{
	int ret;

	if (active) {
		struct tb_path **paths;
		int last;

		paths = tunnel->paths;
		last = paths[TB_DP_VIDEO_PATH_OUT]->path_length - 1;

		tb_dp_port_set_hops(tunnel->src_port,
			paths[TB_DP_VIDEO_PATH_OUT]->hops[0].in_hop_index,
			paths[TB_DP_AUX_PATH_OUT]->hops[0].in_hop_index,
			paths[TB_DP_AUX_PATH_IN]->hops[last].next_hop_index);

		tb_dp_port_set_hops(tunnel->dst_port,
			paths[TB_DP_VIDEO_PATH_OUT]->hops[last].next_hop_index,
			paths[TB_DP_AUX_PATH_IN]->hops[0].in_hop_index,
			paths[TB_DP_AUX_PATH_OUT]->hops[last].next_hop_index);
	} else {
		tb_dp_port_hpd_clear(tunnel->src_port);
		tb_dp_port_set_hops(tunnel->src_port, 0, 0, 0);
		if (tb_port_is_dpout(tunnel->dst_port))
			tb_dp_port_set_hops(tunnel->dst_port, 0, 0, 0);
	}

	ret = tb_dp_port_enable(tunnel->src_port, active);
	if (ret)
		return ret;

	if (tb_port_is_dpout(tunnel->dst_port))
		return tb_dp_port_enable(tunnel->dst_port, active);

	return 0;
}

static void tb_dp_init_aux_path(struct tb_path *path)
{
	int i;

	path->egress_fc_enable = TB_PATH_SOURCE | TB_PATH_INTERNAL;
	path->egress_shared_buffer = TB_PATH_NONE;
	path->ingress_fc_enable = TB_PATH_ALL;
	path->ingress_shared_buffer = TB_PATH_NONE;
	path->priority = 2;
	path->weight = 1;

	for (i = 0; i < path->path_length; i++)
		path->hops[i].initial_credits = 1;
}

static void tb_dp_init_video_path(struct tb_path *path, bool discover)
{
	u32 nfc_credits = path->hops[0].in_port->config.nfc_credits;

	path->egress_fc_enable = TB_PATH_NONE;
	path->egress_shared_buffer = TB_PATH_NONE;
	path->ingress_fc_enable = TB_PATH_NONE;
	path->ingress_shared_buffer = TB_PATH_NONE;
	path->priority = 1;
	path->weight = 1;

	if (discover) {
		path->nfc_credits = nfc_credits & TB_PORT_NFC_CREDITS_MASK;
	} else {
		u32 max_credits;

		max_credits = (nfc_credits & TB_PORT_MAX_CREDITS_MASK) >>
			TB_PORT_MAX_CREDITS_SHIFT;
		/* Leave some credits for AUX path */
		path->nfc_credits = min(max_credits - 2, 12U);
	}
}

/**
 * tb_tunnel_discover_dp() - Discover existing Display Port tunnels
 * @tb: Pointer to the domain structure
 * @in: DP in adapter
 *
 * If @in adapter is active, follows the tunnel to the DP out adapter
 * and back. Returns the discovered tunnel or %NULL if there was no
 * tunnel.
 *
 * Return: DP tunnel or %NULL if no tunnel found.
 */
struct tb_tunnel *tb_tunnel_discover_dp(struct tb *tb, struct tb_port *in)
{
	struct tb_tunnel *tunnel;
	struct tb_port *port;
	struct tb_path *path;

	if (!tb_dp_port_is_enabled(in))
		return NULL;

	tunnel = tb_tunnel_alloc(tb, 3, TB_TUNNEL_DP);
	if (!tunnel)
		return NULL;

	tunnel->init = tb_dp_xchg_caps;
	tunnel->activate = tb_dp_activate;
	tunnel->src_port = in;

	path = tb_path_discover(in, TB_DP_VIDEO_HOPID, NULL, -1,
				&tunnel->dst_port, "Video");
	if (!path) {
		/* Just disable the DP IN port */
		tb_dp_port_enable(in, false);
		goto err_free;
	}
	tunnel->paths[TB_DP_VIDEO_PATH_OUT] = path;
	tb_dp_init_video_path(tunnel->paths[TB_DP_VIDEO_PATH_OUT], true);

	path = tb_path_discover(in, TB_DP_AUX_TX_HOPID, NULL, -1, NULL, "AUX TX");
	if (!path)
		goto err_deactivate;
	tunnel->paths[TB_DP_AUX_PATH_OUT] = path;
	tb_dp_init_aux_path(tunnel->paths[TB_DP_AUX_PATH_OUT]);

	path = tb_path_discover(tunnel->dst_port, -1, in, TB_DP_AUX_RX_HOPID,
				&port, "AUX RX");
	if (!path)
		goto err_deactivate;
	tunnel->paths[TB_DP_AUX_PATH_IN] = path;
	tb_dp_init_aux_path(tunnel->paths[TB_DP_AUX_PATH_IN]);

	/* Validate that the tunnel is complete */
	if (!tb_port_is_dpout(tunnel->dst_port)) {
		tb_port_warn(in, "path does not end on a DP adapter, cleaning up\n");
		goto err_deactivate;
	}

	if (!tb_dp_port_is_enabled(tunnel->dst_port))
		goto err_deactivate;

	if (!tb_dp_port_hpd_is_active(tunnel->dst_port))
		goto err_deactivate;

	if (port != tunnel->src_port) {
		tb_tunnel_warn(tunnel, "path is not complete, cleaning up\n");
		goto err_deactivate;
	}

	tb_tunnel_dbg(tunnel, "discovered\n");
	return tunnel;

err_deactivate:
	tb_tunnel_deactivate(tunnel);
err_free:
	tb_tunnel_free(tunnel);

	return NULL;
}

/**
 * tb_tunnel_alloc_dp() - allocate a Display Port tunnel
 * @tb: Pointer to the domain structure
 * @in: DP in adapter port
 * @out: DP out adapter port
 *
 * Allocates a tunnel between @in and @out that is capable of tunneling
 * Display Port traffic.
 *
 * Return: Returns a tb_tunnel on success or NULL on failure.
 */
struct tb_tunnel *tb_tunnel_alloc_dp(struct tb *tb, struct tb_port *in,
				     struct tb_port *out)
{
	struct tb_tunnel *tunnel;
	struct tb_path **paths;
	struct tb_path *path;

	if (WARN_ON(!in->cap_adap || !out->cap_adap))
		return NULL;

	tunnel = tb_tunnel_alloc(tb, 3, TB_TUNNEL_DP);
	if (!tunnel)
		return NULL;

	tunnel->init = tb_dp_xchg_caps;
	tunnel->activate = tb_dp_activate;
	tunnel->src_port = in;
	tunnel->dst_port = out;

	paths = tunnel->paths;

	path = tb_path_alloc(tb, in, TB_DP_VIDEO_HOPID, out, TB_DP_VIDEO_HOPID,
			     1, "Video");
	if (!path)
		goto err_free;
	tb_dp_init_video_path(path, false);
	paths[TB_DP_VIDEO_PATH_OUT] = path;

	path = tb_path_alloc(tb, in, TB_DP_AUX_TX_HOPID, out,
			     TB_DP_AUX_TX_HOPID, 1, "AUX TX");
	if (!path)
		goto err_free;
	tb_dp_init_aux_path(path);
	paths[TB_DP_AUX_PATH_OUT] = path;

	path = tb_path_alloc(tb, out, TB_DP_AUX_RX_HOPID, in,
			     TB_DP_AUX_RX_HOPID, 1, "AUX RX");
	if (!path)
		goto err_free;
	tb_dp_init_aux_path(path);
	paths[TB_DP_AUX_PATH_IN] = path;

	return tunnel;

err_free:
	tb_tunnel_free(tunnel);
	return NULL;
}

static u32 tb_dma_credits(struct tb_port *nhi)
{
	u32 max_credits;

	max_credits = (nhi->config.nfc_credits & TB_PORT_MAX_CREDITS_MASK) >>
		TB_PORT_MAX_CREDITS_SHIFT;
	return min(max_credits, 13U);
}

static int tb_dma_activate(struct tb_tunnel *tunnel, bool active)
{
	struct tb_port *nhi = tunnel->src_port;
	u32 credits;

	credits = active ? tb_dma_credits(nhi) : 0;
	return tb_port_set_initial_credits(nhi, credits);
}

static void tb_dma_init_path(struct tb_path *path, unsigned int isb,
			     unsigned int efc, u32 credits)
{
	int i;

	path->egress_fc_enable = efc;
	path->ingress_fc_enable = TB_PATH_ALL;
	path->egress_shared_buffer = TB_PATH_NONE;
	path->ingress_shared_buffer = isb;
	path->priority = 5;
	path->weight = 1;
	path->clear_fc = true;

	for (i = 0; i < path->path_length; i++)
		path->hops[i].initial_credits = credits;
}

/**
 * tb_tunnel_alloc_dma() - allocate a DMA tunnel
 * @tb: Pointer to the domain structure
 * @nhi: Host controller port
 * @dst: Destination null port which the other domain is connected to
 * @transmit_ring: NHI ring number used to send packets towards the
 *		   other domain
 * @transmit_path: HopID used for transmitting packets
 * @receive_ring: NHI ring number used to receive packets from the
 *		  other domain
 * @reveive_path: HopID used for receiving packets
 *
 * Return: Returns a tb_tunnel on success or NULL on failure.
 */
struct tb_tunnel *tb_tunnel_alloc_dma(struct tb *tb, struct tb_port *nhi,
				      struct tb_port *dst, int transmit_ring,
				      int transmit_path, int receive_ring,
				      int receive_path)
{
	struct tb_tunnel *tunnel;
	struct tb_path *path;
	u32 credits;

	tunnel = tb_tunnel_alloc(tb, 2, TB_TUNNEL_DMA);
	if (!tunnel)
		return NULL;

	tunnel->activate = tb_dma_activate;
	tunnel->src_port = nhi;
	tunnel->dst_port = dst;

	credits = tb_dma_credits(nhi);

	path = tb_path_alloc(tb, dst, receive_path, nhi, receive_ring, 0, "DMA RX");
	if (!path) {
		tb_tunnel_free(tunnel);
		return NULL;
	}
	tb_dma_init_path(path, TB_PATH_NONE, TB_PATH_SOURCE | TB_PATH_INTERNAL,
			 credits);
	tunnel->paths[TB_DMA_PATH_IN] = path;

	path = tb_path_alloc(tb, nhi, transmit_ring, dst, transmit_path, 0, "DMA TX");
	if (!path) {
		tb_tunnel_free(tunnel);
		return NULL;
	}
	tb_dma_init_path(path, TB_PATH_SOURCE, TB_PATH_ALL, credits);
	tunnel->paths[TB_DMA_PATH_OUT] = path;

	return tunnel;
}

/**
 * tb_tunnel_free() - free a tunnel
 * @tunnel: Tunnel to be freed
 *
 * Frees a tunnel. The tunnel does not need to be deactivated.
 */
void tb_tunnel_free(struct tb_tunnel *tunnel)
{
	int i;

	if (!tunnel)
		return;

	for (i = 0; i < tunnel->npaths; i++) {
		if (tunnel->paths[i])
			tb_path_free(tunnel->paths[i]);
	}

	kfree(tunnel->paths);
	kfree(tunnel);
}

/**
 * tb_tunnel_is_invalid - check whether an activated path is still valid
 * @tunnel: Tunnel to check
 */
bool tb_tunnel_is_invalid(struct tb_tunnel *tunnel)
{
	int i;

	for (i = 0; i < tunnel->npaths; i++) {
		WARN_ON(!tunnel->paths[i]->activated);
		if (tb_path_is_invalid(tunnel->paths[i]))
			return true;
	}

	return false;
}

/**
 * tb_tunnel_restart() - activate a tunnel after a hardware reset
 * @tunnel: Tunnel to restart
 *
 * Return: 0 on success and negative errno in case if failure
 */
int tb_tunnel_restart(struct tb_tunnel *tunnel)
{
	int res, i;

	tb_tunnel_dbg(tunnel, "activating\n");

	/*
	 * Make sure all paths are properly disabled before enabling
	 * them again.
	 */
	for (i = 0; i < tunnel->npaths; i++) {
		if (tunnel->paths[i]->activated) {
			tb_path_deactivate(tunnel->paths[i]);
			tunnel->paths[i]->activated = false;
		}
	}

	if (tunnel->init) {
		res = tunnel->init(tunnel);
		if (res)
			return res;
	}

	for (i = 0; i < tunnel->npaths; i++) {
		res = tb_path_activate(tunnel->paths[i]);
		if (res)
			goto err;
	}

	if (tunnel->activate) {
		res = tunnel->activate(tunnel, true);
		if (res)
			goto err;
	}

	return 0;

err:
	tb_tunnel_warn(tunnel, "activation failed\n");
	tb_tunnel_deactivate(tunnel);
	return res;
}

/**
 * tb_tunnel_activate() - activate a tunnel
 * @tunnel: Tunnel to activate
 *
 * Return: Returns 0 on success or an error code on failure.
 */
int tb_tunnel_activate(struct tb_tunnel *tunnel)
{
	int i;

	for (i = 0; i < tunnel->npaths; i++) {
		if (tunnel->paths[i]->activated) {
			tb_tunnel_WARN(tunnel,
				       "trying to activate an already activated tunnel\n");
			return -EINVAL;
		}
	}

	return tb_tunnel_restart(tunnel);
}

/**
 * tb_tunnel_deactivate() - deactivate a tunnel
 * @tunnel: Tunnel to deactivate
 */
void tb_tunnel_deactivate(struct tb_tunnel *tunnel)
{
	int i;

	tb_tunnel_dbg(tunnel, "deactivating\n");

	if (tunnel->activate)
		tunnel->activate(tunnel, false);

	for (i = 0; i < tunnel->npaths; i++) {
		if (tunnel->paths[i] && tunnel->paths[i]->activated)
			tb_path_deactivate(tunnel->paths[i]);
	}
}
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
3364f0c1	2	/*
93f36ade	3	* Thunderbolt driver - Tunneling support
3364f0c1 AN	4	*
3364f0c1 AN	5	* Copyright (c) 2014 Andreas Noever <andreas.noever@gmail.com>
93f36ade	6	* Copyright (C) 2019, Intel Corporation
3364f0c1 AN	7	*/
	8
	9	#include <linux/slab.h>
	10	#include <linux/list.h>
	11
1752b9f7	12	#include "tunnel.h"
3364f0c1 AN	13	#include "tb.h"
3364f0c1 AN	14
8c7acaaf MW	15	/* PCIe adapters use always HopID of 8 for both directions */
	16	#define TB_PCI_HOPID 8
	17
93f36ade MW	18	#define TB_PCI_PATH_DOWN 0
	19	#define TB_PCI_PATH_UP 1
	20
4f807e47 MW	21	/* DP adapters use HopID 8 for AUX and 9 for Video */
	22	#define TB_DP_AUX_TX_HOPID 8
	23	#define TB_DP_AUX_RX_HOPID 8
	24	#define TB_DP_VIDEO_HOPID 9
	25
	26	#define TB_DP_VIDEO_PATH_OUT 0
	27	#define TB_DP_AUX_PATH_OUT 1
	28	#define TB_DP_AUX_PATH_IN 2
	29
44242d6c MW	30	#define TB_DMA_PATH_OUT 0
	31	#define TB_DMA_PATH_IN 1
	32
	33	static const char * const tb_tunnel_names[] = { "PCI", "DP", "DMA" };
4f807e47	34
3364f0c1 AN	35	#define __TB_TUNNEL_PRINT(level, tunnel, fmt, arg...) \
3364f0c1 AN	36	do { \
93f36ade	37	struct tb_tunnel *__tunnel = (tunnel); \
4f807e47	38	level(__tunnel->tb, "%llx:%x <-> %llx:%x (%s): " fmt, \
93f36ade MW	39	tb_route(__tunnel->src_port->sw), \
	40	__tunnel->src_port->port, \
	41	tb_route(__tunnel->dst_port->sw), \
	42	__tunnel->dst_port->port, \
4f807e47	43	tb_tunnel_names[__tunnel->type], \
3364f0c1 AN	44	## arg); \
	45	} while (0)
	46
	47	#define tb_tunnel_WARN(tunnel, fmt, arg...) \
	48	__TB_TUNNEL_PRINT(tb_WARN, tunnel, fmt, ##arg)
	49	#define tb_tunnel_warn(tunnel, fmt, arg...) \
	50	__TB_TUNNEL_PRINT(tb_warn, tunnel, fmt, ##arg)
	51	#define tb_tunnel_info(tunnel, fmt, arg...) \
	52	__TB_TUNNEL_PRINT(tb_info, tunnel, fmt, ##arg)
0414bec5 MW	53	#define tb_tunnel_dbg(tunnel, fmt, arg...) \
0414bec5 MW	54	__TB_TUNNEL_PRINT(tb_dbg, tunnel, fmt, ##arg)
3364f0c1	55
4f807e47 MW	56	static struct tb_tunnel tb_tunnel_alloc(struct tb tb, size_t npaths,
4f807e47 MW	57	enum tb_tunnel_type type)
93f36ade MW	58	{
	59	struct tb_tunnel *tunnel;
	60
	61	tunnel = kzalloc(sizeof(*tunnel), GFP_KERNEL);
	62	if (!tunnel)
	63	return NULL;
	64
	65	tunnel->paths = kcalloc(npaths, sizeof(tunnel->paths[0]), GFP_KERNEL);
	66	if (!tunnel->paths) {
	67	tb_tunnel_free(tunnel);
	68	return NULL;
	69	}
	70
	71	INIT_LIST_HEAD(&tunnel->list);
	72	tunnel->tb = tb;
	73	tunnel->npaths = npaths;
4f807e47	74	tunnel->type = type;
93f36ade MW	75
	76	return tunnel;
	77	}
	78
	79	static int tb_pci_activate(struct tb_tunnel *tunnel, bool activate)
	80	{
	81	int res;
	82
	83	res = tb_pci_port_enable(tunnel->src_port, activate);
	84	if (res)
	85	return res;
	86
0414bec5 MW	87	if (tb_port_is_pcie_up(tunnel->dst_port))
	88	return tb_pci_port_enable(tunnel->dst_port, activate);
	89
	90	return 0;
93f36ade MW	91	}
93f36ade MW	92
3364f0c1 AN	93	static void tb_pci_init_path(struct tb_path *path)
	94	{
	95	path->egress_fc_enable = TB_PATH_SOURCE \| TB_PATH_INTERNAL;
	96	path->egress_shared_buffer = TB_PATH_NONE;
	97	path->ingress_fc_enable = TB_PATH_ALL;
	98	path->ingress_shared_buffer = TB_PATH_NONE;
	99	path->priority = 3;
	100	path->weight = 1;
	101	path->drop_packages = 0;
	102	path->nfc_credits = 0;
0414bec5 MW	103	path->hops[0].initial_credits = 7;
	104	path->hops[1].initial_credits = 16;
	105	}
	106
	107	/**
	108	* tb_tunnel_discover_pci() - Discover existing PCIe tunnels
	109	* @tb: Pointer to the domain structure
	110	* @down: PCIe downstream adapter
	111	*
	112	* If @down adapter is active, follows the tunnel to the PCIe upstream
	113	* adapter and back. Returns the discovered tunnel or %NULL if there was
	114	* no tunnel.
	115	*/
	116	struct tb_tunnel tb_tunnel_discover_pci(struct tb tb, struct tb_port *down)
	117	{
	118	struct tb_tunnel *tunnel;
	119	struct tb_path *path;
	120
	121	if (!tb_pci_port_is_enabled(down))
	122	return NULL;
	123
4f807e47	124	tunnel = tb_tunnel_alloc(tb, 2, TB_TUNNEL_PCI);
0414bec5 MW	125	if (!tunnel)
	126	return NULL;
	127
	128	tunnel->activate = tb_pci_activate;
	129	tunnel->src_port = down;
	130
	131	/*
	132	* Discover both paths even if they are not complete. We will
	133	* clean them up by calling tb_tunnel_deactivate() below in that
	134	* case.
	135	*/
	136	path = tb_path_discover(down, TB_PCI_HOPID, NULL, -1,
	137	&tunnel->dst_port, "PCIe Up");
	138	if (!path) {
	139	/* Just disable the downstream port */
	140	tb_pci_port_enable(down, false);
	141	goto err_free;
	142	}
	143	tunnel->paths[TB_PCI_PATH_UP] = path;
	144	tb_pci_init_path(tunnel->paths[TB_PCI_PATH_UP]);
	145
	146	path = tb_path_discover(tunnel->dst_port, -1, down, TB_PCI_HOPID, NULL,
	147	"PCIe Down");
	148	if (!path)
	149	goto err_deactivate;
	150	tunnel->paths[TB_PCI_PATH_DOWN] = path;
	151	tb_pci_init_path(tunnel->paths[TB_PCI_PATH_DOWN]);
	152
	153	/* Validate that the tunnel is complete */
	154	if (!tb_port_is_pcie_up(tunnel->dst_port)) {
	155	tb_port_warn(tunnel->dst_port,
	156	"path does not end on a PCIe adapter, cleaning up\n");
	157	goto err_deactivate;
	158	}
	159
	160	if (down != tunnel->src_port) {
	161	tb_tunnel_warn(tunnel, "path is not complete, cleaning up\n");
	162	goto err_deactivate;
	163	}
	164
	165	if (!tb_pci_port_is_enabled(tunnel->dst_port)) {
	166	tb_tunnel_warn(tunnel,
	167	"tunnel is not fully activated, cleaning up\n");
	168	goto err_deactivate;
	169	}
	170
	171	tb_tunnel_dbg(tunnel, "discovered\n");
	172	return tunnel;
	173
	174	err_deactivate:
	175	tb_tunnel_deactivate(tunnel);
	176	err_free:
	177	tb_tunnel_free(tunnel);
	178
	179	return NULL;
3364f0c1 AN	180	}
	181
	182	/**
93f36ade MW	183	* tb_tunnel_alloc_pci() - allocate a pci tunnel
	184	* @tb: Pointer to the domain structure
	185	* @up: PCIe upstream adapter port
	186	* @down: PCIe downstream adapter port
3364f0c1 AN	187	*
	188	* Allocate a PCI tunnel. The ports must be of type TB_TYPE_PCIE_UP and
	189	* TB_TYPE_PCIE_DOWN.
	190	*
93f36ade	191	* Return: Returns a tb_tunnel on success or NULL on failure.
3364f0c1	192	*/
93f36ade MW	193	struct tb_tunnel tb_tunnel_alloc_pci(struct tb tb, struct tb_port *up,
93f36ade MW	194	struct tb_port *down)
3364f0c1	195	{
93f36ade	196	struct tb_tunnel *tunnel;
8c7acaaf	197	struct tb_path *path;
93f36ade	198
4f807e47	199	tunnel = tb_tunnel_alloc(tb, 2, TB_TUNNEL_PCI);
3364f0c1	200	if (!tunnel)
93f36ade	201	return NULL;
3364f0c1	202
93f36ade MW	203	tunnel->activate = tb_pci_activate;
	204	tunnel->src_port = down;
	205	tunnel->dst_port = up;
	206
8c7acaaf MW	207	path = tb_path_alloc(tb, down, TB_PCI_HOPID, up, TB_PCI_HOPID, 0,
	208	"PCIe Down");
	209	if (!path) {
93f36ade MW	210	tb_tunnel_free(tunnel);
93f36ade MW	211	return NULL;
3364f0c1	212	}
8c7acaaf MW	213	tb_pci_init_path(path);
8c7acaaf MW	214	tunnel->paths[TB_PCI_PATH_UP] = path;
93f36ade	215
8c7acaaf MW	216	path = tb_path_alloc(tb, up, TB_PCI_HOPID, down, TB_PCI_HOPID, 0,
	217	"PCIe Up");
	218	if (!path) {
93f36ade MW	219	tb_tunnel_free(tunnel);
	220	return NULL;
	221	}
8c7acaaf MW	222	tb_pci_init_path(path);
8c7acaaf MW	223	tunnel->paths[TB_PCI_PATH_DOWN] = path;
93f36ade MW	224
93f36ade MW	225	return tunnel;
3364f0c1 AN	226	}
3364f0c1 AN	227
4f807e47 MW	228	static int tb_dp_xchg_caps(struct tb_tunnel *tunnel)
	229	{
	230	struct tb_port *out = tunnel->dst_port;
	231	struct tb_port *in = tunnel->src_port;
	232	u32 in_dp_cap, out_dp_cap;
	233	int ret;
	234
	235	/*
	236	* Copy DP_LOCAL_CAP register to DP_REMOTE_CAP register for
	237	* newer generation hardware.
	238	*/
	239	if (in->sw->generation < 2 \|\| out->sw->generation < 2)
	240	return 0;
	241
	242	/* Read both DP_LOCAL_CAP registers */
	243	ret = tb_port_read(in, &in_dp_cap, TB_CFG_PORT,
	244	in->cap_adap + TB_DP_LOCAL_CAP, 1);
	245	if (ret)
	246	return ret;
	247
	248	ret = tb_port_read(out, &out_dp_cap, TB_CFG_PORT,
	249	out->cap_adap + TB_DP_LOCAL_CAP, 1);
	250	if (ret)
	251	return ret;
	252
	253	/* Write IN local caps to OUT remote caps */
	254	ret = tb_port_write(out, &in_dp_cap, TB_CFG_PORT,
	255	out->cap_adap + TB_DP_REMOTE_CAP, 1);
	256	if (ret)
	257	return ret;
	258
	259	return tb_port_write(in, &out_dp_cap, TB_CFG_PORT,
	260	in->cap_adap + TB_DP_REMOTE_CAP, 1);
	261	}
	262
	263	static int tb_dp_activate(struct tb_tunnel *tunnel, bool active)
	264	{
	265	int ret;
	266
	267	if (active) {
	268	struct tb_path **paths;
	269	int last;
	270
	271	paths = tunnel->paths;
	272	last = paths[TB_DP_VIDEO_PATH_OUT]->path_length - 1;
	273
	274	tb_dp_port_set_hops(tunnel->src_port,
	275	paths[TB_DP_VIDEO_PATH_OUT]->hops[0].in_hop_index,
	276	paths[TB_DP_AUX_PATH_OUT]->hops[0].in_hop_index,
	277	paths[TB_DP_AUX_PATH_IN]->hops[last].next_hop_index);
	278
	279	tb_dp_port_set_hops(tunnel->dst_port,
	280	paths[TB_DP_VIDEO_PATH_OUT]->hops[last].next_hop_index,
	281	paths[TB_DP_AUX_PATH_IN]->hops[0].in_hop_index,
	282	paths[TB_DP_AUX_PATH_OUT]->hops[last].next_hop_index);
	283	} else {
	284	tb_dp_port_hpd_clear(tunnel->src_port);
	285	tb_dp_port_set_hops(tunnel->src_port, 0, 0, 0);
	286	if (tb_port_is_dpout(tunnel->dst_port))
	287	tb_dp_port_set_hops(tunnel->dst_port, 0, 0, 0);
	288	}
	289
	290	ret = tb_dp_port_enable(tunnel->src_port, active);
	291	if (ret)
292	return ret;
293
294	if (tb_port_is_dpout(tunnel->dst_port))
295	return tb_dp_port_enable(tunnel->dst_port, active);
296
297	return 0;
298	}
299
300	static void tb_dp_init_aux_path(struct tb_path *path)
301	{
302	int i;
303
304	path->egress_fc_enable = TB_PATH_SOURCE \| TB_PATH_INTERNAL;
305	path->egress_shared_buffer = TB_PATH_NONE;
306	path->ingress_fc_enable = TB_PATH_ALL;
307	path->ingress_shared_buffer = TB_PATH_NONE;
308	path->priority = 2;
309	path->weight = 1;
310
311	for (i = 0; i < path->path_length; i++)
312	path->hops[i].initial_credits = 1;
313	}
314
315	static void tb_dp_init_video_path(struct tb_path *path, bool discover)
316	{
317	u32 nfc_credits = path->hops[0].in_port->config.nfc_credits;
318
319	path->egress_fc_enable = TB_PATH_NONE;
320	path->egress_shared_buffer = TB_PATH_NONE;
321	path->ingress_fc_enable = TB_PATH_NONE;
322	path->ingress_shared_buffer = TB_PATH_NONE;
323	path->priority = 1;
324	path->weight = 1;
325
326	if (discover) {
327	path->nfc_credits = nfc_credits & TB_PORT_NFC_CREDITS_MASK;
328	} else {
329	u32 max_credits;
330
331	max_credits = (nfc_credits & TB_PORT_MAX_CREDITS_MASK) >>
332	TB_PORT_MAX_CREDITS_SHIFT;
333	/* Leave some credits for AUX path */
334	path->nfc_credits = min(max_credits - 2, 12U);
335	}
336	}
337
338	/**
339	* tb_tunnel_discover_dp() - Discover existing Display Port tunnels
340	* @tb: Pointer to the domain structure
341	* @in: DP in adapter
342	*
343	* If @in adapter is active, follows the tunnel to the DP out adapter
344	* and back. Returns the discovered tunnel or %NULL if there was no
345	* tunnel.
346	*
347	* Return: DP tunnel or %NULL if no tunnel found.
348	*/
349	struct tb_tunnel tb_tunnel_discover_dp(struct tb tb, struct tb_port *in)
350	{
351	struct tb_tunnel *tunnel;
352	struct tb_port *port;
353	struct tb_path *path;
354
355	if (!tb_dp_port_is_enabled(in))
356	return NULL;
357
358	tunnel = tb_tunnel_alloc(tb, 3, TB_TUNNEL_DP);
359	if (!tunnel)
360	return NULL;
361
362	tunnel->init = tb_dp_xchg_caps;
363	tunnel->activate = tb_dp_activate;
364	tunnel->src_port = in;
365
366	path = tb_path_discover(in, TB_DP_VIDEO_HOPID, NULL, -1,
367	&tunnel->dst_port, "Video");
368	if (!path) {
369	/* Just disable the DP IN port */
370	tb_dp_port_enable(in, false);
371	goto err_free;
372	}
373	tunnel->paths[TB_DP_VIDEO_PATH_OUT] = path;
374	tb_dp_init_video_path(tunnel->paths[TB_DP_VIDEO_PATH_OUT], true);
375
376	path = tb_path_discover(in, TB_DP_AUX_TX_HOPID, NULL, -1, NULL, "AUX TX");
377	if (!path)
378	goto err_deactivate;
379	tunnel->paths[TB_DP_AUX_PATH_OUT] = path;
380	tb_dp_init_aux_path(tunnel->paths[TB_DP_AUX_PATH_OUT]);
381
382	path = tb_path_discover(tunnel->dst_port, -1, in, TB_DP_AUX_RX_HOPID,
383	&port, "AUX RX");
384	if (!path)
385	goto err_deactivate;
386	tunnel->paths[TB_DP_AUX_PATH_IN] = path;
387	tb_dp_init_aux_path(tunnel->paths[TB_DP_AUX_PATH_IN]);
388
389	/* Validate that the tunnel is complete */
390	if (!tb_port_is_dpout(tunnel->dst_port)) {
391	tb_port_warn(in, "path does not end on a DP adapter, cleaning up\n");
392	goto err_deactivate;
393	}
394
395	if (!tb_dp_port_is_enabled(tunnel->dst_port))
396	goto err_deactivate;
397
398	if (!tb_dp_port_hpd_is_active(tunnel->dst_port))
399	goto err_deactivate;
400
401	if (port != tunnel->src_port) {
402	tb_tunnel_warn(tunnel, "path is not complete, cleaning up\n");
403	goto err_deactivate;
404	}
405
406	tb_tunnel_dbg(tunnel, "discovered\n");
407	return tunnel;
408
409	err_deactivate:
410	tb_tunnel_deactivate(tunnel);
411	err_free:
412	tb_tunnel_free(tunnel);
413
414	return NULL;
415	}
416
417	/**
418	* tb_tunnel_alloc_dp() - allocate a Display Port tunnel
419	* @tb: Pointer to the domain structure
420	* @in: DP in adapter port
421	* @out: DP out adapter port
422	*
423	* Allocates a tunnel between @in and @out that is capable of tunneling
424	* Display Port traffic.
425	*
426	* Return: Returns a tb_tunnel on success or NULL on failure.
427	*/
428	struct tb_tunnel tb_tunnel_alloc_dp(struct tb tb, struct tb_port *in,
429	struct tb_port *out)
430	{
431	struct tb_tunnel *tunnel;
432	struct tb_path **paths;
433	struct tb_path *path;
434
435	if (WARN_ON(!in->cap_adap \|\| !out->cap_adap))
436	return NULL;
437
438	tunnel = tb_tunnel_alloc(tb, 3, TB_TUNNEL_DP);
439	if (!tunnel)
440	return NULL;
441
442	tunnel->init = tb_dp_xchg_caps;
443	tunnel->activate = tb_dp_activate;
444	tunnel->src_port = in;
445	tunnel->dst_port = out;
446
447	paths = tunnel->paths;
448
449	path = tb_path_alloc(tb, in, TB_DP_VIDEO_HOPID, out, TB_DP_VIDEO_HOPID,
450	1, "Video");
451	if (!path)
452	goto err_free;
453	tb_dp_init_video_path(path, false);
454	paths[TB_DP_VIDEO_PATH_OUT] = path;
455
456	path = tb_path_alloc(tb, in, TB_DP_AUX_TX_HOPID, out,
457	TB_DP_AUX_TX_HOPID, 1, "AUX TX");
458	if (!path)
459	goto err_free;
460	tb_dp_init_aux_path(path);
461	paths[TB_DP_AUX_PATH_OUT] = path;
462
463	path = tb_path_alloc(tb, out, TB_DP_AUX_RX_HOPID, in,
464	TB_DP_AUX_RX_HOPID, 1, "AUX RX");
465	if (!path)
466	goto err_free;
467	tb_dp_init_aux_path(path);
468	paths[TB_DP_AUX_PATH_IN] = path;
469
470	return tunnel;
471
472	err_free:
473	tb_tunnel_free(tunnel);
474	return NULL;
475	}
476
44242d6c MW	477	static u32 tb_dma_credits(struct tb_port *nhi)
	478	{
	479	u32 max_credits;
	480
	481	max_credits = (nhi->config.nfc_credits & TB_PORT_MAX_CREDITS_MASK) >>
	482	TB_PORT_MAX_CREDITS_SHIFT;
	483	return min(max_credits, 13U);
	484	}
	485
	486	static int tb_dma_activate(struct tb_tunnel *tunnel, bool active)
	487	{
	488	struct tb_port *nhi = tunnel->src_port;
	489	u32 credits;
	490
	491	credits = active ? tb_dma_credits(nhi) : 0;
	492	return tb_port_set_initial_credits(nhi, credits);
	493	}
	494
	495	static void tb_dma_init_path(struct tb_path *path, unsigned int isb,
	496	unsigned int efc, u32 credits)
	497	{
	498	int i;
	499
	500	path->egress_fc_enable = efc;
	501	path->ingress_fc_enable = TB_PATH_ALL;
	502	path->egress_shared_buffer = TB_PATH_NONE;
	503	path->ingress_shared_buffer = isb;
	504	path->priority = 5;
	505	path->weight = 1;
	506	path->clear_fc = true;
	507
	508	for (i = 0; i < path->path_length; i++)
	509	path->hops[i].initial_credits = credits;
	510	}
	511
	512	/**
	513	* tb_tunnel_alloc_dma() - allocate a DMA tunnel
	514	* @tb: Pointer to the domain structure
	515	* @nhi: Host controller port
	516	* @dst: Destination null port which the other domain is connected to
	517	* @transmit_ring: NHI ring number used to send packets towards the
	518	* other domain
	519	* @transmit_path: HopID used for transmitting packets
	520	* @receive_ring: NHI ring number used to receive packets from the
	521	* other domain
	522	* @reveive_path: HopID used for receiving packets
	523	*
	524	* Return: Returns a tb_tunnel on success or NULL on failure.
	525	*/
	526	struct tb_tunnel tb_tunnel_alloc_dma(struct tb tb, struct tb_port *nhi,
	527	struct tb_port *dst, int transmit_ring,
	528	int transmit_path, int receive_ring,
	529	int receive_path)
	530	{
	531	struct tb_tunnel *tunnel;
	532	struct tb_path *path;
	533	u32 credits;
	534
	535	tunnel = tb_tunnel_alloc(tb, 2, TB_TUNNEL_DMA);
	536	if (!tunnel)
	537	return NULL;
	538
	539	tunnel->activate = tb_dma_activate;
	540	tunnel->src_port = nhi;
541	tunnel->dst_port = dst;
542
543	credits = tb_dma_credits(nhi);
544
545	path = tb_path_alloc(tb, dst, receive_path, nhi, receive_ring, 0, "DMA RX");
546	if (!path) {
547	tb_tunnel_free(tunnel);
548	return NULL;
549	}
550	tb_dma_init_path(path, TB_PATH_NONE, TB_PATH_SOURCE \| TB_PATH_INTERNAL,
551	credits);
552	tunnel->paths[TB_DMA_PATH_IN] = path;
553
554	path = tb_path_alloc(tb, nhi, transmit_ring, dst, transmit_path, 0, "DMA TX");
555	if (!path) {
556	tb_tunnel_free(tunnel);
557	return NULL;
558	}
559	tb_dma_init_path(path, TB_PATH_SOURCE, TB_PATH_ALL, credits);
560	tunnel->paths[TB_DMA_PATH_OUT] = path;
561
562	return tunnel;
563	}
564
3364f0c1	565	/**
93f36ade MW	566	* tb_tunnel_free() - free a tunnel
93f36ade MW	567	* @tunnel: Tunnel to be freed
3364f0c1	568	*
ab9f31cf	569	* Frees a tunnel. The tunnel does not need to be deactivated.
3364f0c1	570	*/
93f36ade	571	void tb_tunnel_free(struct tb_tunnel *tunnel)
3364f0c1	572	{
93f36ade MW	573	int i;
	574
	575	if (!tunnel)
3364f0c1	576	return;
93f36ade	577
93f36ade MW	578	for (i = 0; i < tunnel->npaths; i++) {
	579	if (tunnel->paths[i])
	580	tb_path_free(tunnel->paths[i]);
	581	}
	582
	583	kfree(tunnel->paths);
3364f0c1 AN	584	kfree(tunnel);
	585	}
	586
	587	/**
93f36ade MW	588	* tb_tunnel_is_invalid - check whether an activated path is still valid
93f36ade MW	589	* @tunnel: Tunnel to check
3364f0c1	590	*/
93f36ade	591	bool tb_tunnel_is_invalid(struct tb_tunnel *tunnel)
3364f0c1	592	{
93f36ade	593	int i;
3364f0c1	594
93f36ade MW	595	for (i = 0; i < tunnel->npaths; i++) {
	596	WARN_ON(!tunnel->paths[i]->activated);
	597	if (tb_path_is_invalid(tunnel->paths[i]))
	598	return true;
	599	}
3364f0c1	600
93f36ade	601	return false;
3364f0c1 AN	602	}
	603
	604	/**
93f36ade MW	605	* tb_tunnel_restart() - activate a tunnel after a hardware reset
	606	* @tunnel: Tunnel to restart
	607	*
	608	* Return: 0 on success and negative errno in case if failure
3364f0c1	609	*/
93f36ade	610	int tb_tunnel_restart(struct tb_tunnel *tunnel)
3364f0c1	611	{
93f36ade	612	int res, i;
3364f0c1	613
62efe699	614	tb_tunnel_dbg(tunnel, "activating\n");
3364f0c1	615
aae9e27f MW	616	/*
	617	* Make sure all paths are properly disabled before enabling
	618	* them again.
	619	*/
	620	for (i = 0; i < tunnel->npaths; i++) {
	621	if (tunnel->paths[i]->activated) {
	622	tb_path_deactivate(tunnel->paths[i]);
	623	tunnel->paths[i]->activated = false;
	624	}
	625	}
	626
4f807e47 MW	627	if (tunnel->init) {
	628	res = tunnel->init(tunnel);
	629	if (res)
	630	return res;
	631	}
	632
93f36ade	633	for (i = 0; i < tunnel->npaths; i++) {
93f36ade MW	634	res = tb_path_activate(tunnel->paths[i]);
	635	if (res)
	636	goto err;
	637	}
3364f0c1	638
93f36ade MW	639	if (tunnel->activate) {
	640	res = tunnel->activate(tunnel, true);
	641	if (res)
	642	goto err;
	643	}
3364f0c1	644
3364f0c1	645	return 0;
93f36ade	646
3364f0c1 AN	647	err:
3364f0c1 AN	648	tb_tunnel_warn(tunnel, "activation failed\n");
93f36ade	649	tb_tunnel_deactivate(tunnel);
3364f0c1 AN	650	return res;
	651	}
	652
	653	/**
93f36ade MW	654	* tb_tunnel_activate() - activate a tunnel
93f36ade MW	655	* @tunnel: Tunnel to activate
3364f0c1 AN	656	*
	657	* Return: Returns 0 on success or an error code on failure.
	658	*/
93f36ade	659	int tb_tunnel_activate(struct tb_tunnel *tunnel)
3364f0c1	660	{
93f36ade	661	int i;
3364f0c1	662
93f36ade MW	663	for (i = 0; i < tunnel->npaths; i++) {
	664	if (tunnel->paths[i]->activated) {
	665	tb_tunnel_WARN(tunnel,
	666	"trying to activate an already activated tunnel\n");
	667	return -EINVAL;
	668	}
	669	}
3364f0c1	670
93f36ade MW	671	return tb_tunnel_restart(tunnel);
93f36ade MW	672	}
3364f0c1 AN	673
3364f0c1 AN	674	/**
93f36ade MW	675	* tb_tunnel_deactivate() - deactivate a tunnel
93f36ade MW	676	* @tunnel: Tunnel to deactivate
3364f0c1	677	*/
93f36ade	678	void tb_tunnel_deactivate(struct tb_tunnel *tunnel)
3364f0c1	679	{
93f36ade MW	680	int i;
93f36ade MW	681
62efe699	682	tb_tunnel_dbg(tunnel, "deactivating\n");
3364f0c1	683
93f36ade MW	684	if (tunnel->activate)
	685	tunnel->activate(tunnel, false);
	686
	687	for (i = 0; i < tunnel->npaths; i++) {
0414bec5	688	if (tunnel->paths[i] && tunnel->paths[i]->activated)
93f36ade MW	689	tb_path_deactivate(tunnel->paths[i]);
	690	}
	691	}