linux-next/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"

#define TB_PCI_PATH_DOWN		0
#define TB_PCI_PATH_UP			1

#define __TB_TUNNEL_PRINT(level, tunnel, fmt, arg...)                   \
	do {                                                            \
		struct tb_tunnel *__tunnel = (tunnel);                  \
		level(__tunnel->tb, "%llx:%x <-> %llx:%x (PCI): " fmt,  \
		      tb_route(__tunnel->src_port->sw),                 \
		      __tunnel->src_port->port,                         \
		      tb_route(__tunnel->dst_port->sw),                 \
		      __tunnel->dst_port->port,                         \
		      ## 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)

static struct tb_tunnel *tb_tunnel_alloc(struct tb *tb, size_t npaths)
{
	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;

	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;

	return tb_pci_port_enable(tunnel->dst_port, activate);
}

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;
}

/**
 * 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.
 *
 * Currently only paths consisting of two hops are supported (that is the
 * ports must be on "adjacent" switches).
 *
 * The paths are hard-coded to use hop 8 (the only working hop id available on
 * my thunderbolt devices). Therefore at most ONE path per device may be
 * activated.
 *
 * 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_path *path_to_up;
	struct tb_path *path_to_down;
	struct tb_tunnel *tunnel;

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

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

	path_to_up = tb_path_alloc(tb, 2);
	if (!path_to_up) {
		tb_tunnel_free(tunnel);
		return NULL;
	}
	tunnel->paths[TB_PCI_PATH_UP] = path_to_up;

	path_to_down = tb_path_alloc(tb, 2);
	if (!path_to_down) {
		tb_tunnel_free(tunnel);
		return NULL;
	}
	tunnel->paths[TB_PCI_PATH_DOWN] = path_to_down;

	tb_pci_init_path(path_to_up);
	tb_pci_init_path(path_to_down);

	path_to_up->hops[0].in_port = down;
	path_to_up->hops[0].in_hop_index = 8;
	path_to_up->hops[0].in_counter_index = -1;
	path_to_up->hops[0].out_port = tb_upstream_port(up->sw)->remote;
	path_to_up->hops[0].next_hop_index = 8;

	path_to_up->hops[1].in_port = tb_upstream_port(up->sw);
	path_to_up->hops[1].in_hop_index = 8;
	path_to_up->hops[1].in_counter_index = -1;
	path_to_up->hops[1].out_port = up;
	path_to_up->hops[1].next_hop_index = 8;

	path_to_down->hops[0].in_port = up;
	path_to_down->hops[0].in_hop_index = 8;
	path_to_down->hops[0].in_counter_index = -1;
	path_to_down->hops[0].out_port = tb_upstream_port(up->sw);
	path_to_down->hops[0].next_hop_index = 8;

	path_to_down->hops[1].in_port = tb_upstream_port(up->sw)->remote;
	path_to_down->hops[1].in_hop_index = 8;
	path_to_down->hops[1].in_counter_index = -1;
	path_to_down->hops[1].out_port = down;
	path_to_down->hops[1].next_hop_index = 8;

	return tunnel;
}

/**
 * tb_tunnel_free() - free a tunnel
 * @tunnel: Tunnel to be freed
 *
 * The tunnel must have been 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] && tunnel->paths[i]->activated) {
			tb_tunnel_WARN(tunnel,
				       "trying to free an activated tunnel\n");
			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_info(tunnel, "activating\n");

	for (i = 0; i < tunnel->npaths; i++) {
		tunnel->paths[i]->activated = false;
		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;

	tb_tunnel_info(tunnel, "activating\n");

	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_info(tunnel, "deactivating\n");

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

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