[mirror_ubuntu-bionic-kernel.git] / drivers / thunderbolt / tb.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Thunderbolt Cactus Ridge driver - bus logic (NHI independent)
 *
 * Copyright (c) 2014 Andreas Noever <andreas.noever@gmail.com>
 */

#include <linux/slab.h>
#include <linux/errno.h>
#include <linux/delay.h>
#include <linux/platform_data/x86/apple.h>

#include "tb.h"
#include "tb_regs.h"
#include "tunnel_pci.h"

/**
 * struct tb_cm - Simple Thunderbolt connection manager
 * @tunnel_list: List of active tunnels
 * @hotplug_active: tb_handle_hotplug will stop progressing plug
 *		    events and exit if this is not set (it needs to
 *		    acquire the lock one more time). Used to drain wq
 *		    after cfg has been paused.
 */
struct tb_cm {
	struct list_head tunnel_list;
	bool hotplug_active;
};

/* enumeration & hot plug handling */


static void tb_scan_port(struct tb_port *port);

/**
 * tb_scan_switch() - scan for and initialize downstream switches
 */
static void tb_scan_switch(struct tb_switch *sw)
{
	int i;
	for (i = 1; i <= sw->config.max_port_number; i++)
		tb_scan_port(&sw->ports[i]);
}

/**
 * tb_scan_port() - check for and initialize switches below port
 */
static void tb_scan_port(struct tb_port *port)
{
	struct tb_switch *sw;
	if (tb_is_upstream_port(port))
		return;
	if (port->config.type != TB_TYPE_PORT)
		return;
	if (port->dual_link_port && port->link_nr)
		return; /*
			 * Downstream switch is reachable through two ports.
			 * Only scan on the primary port (link_nr == 0).
			 */
	if (tb_wait_for_port(port, false) <= 0)
		return;
	if (port->remote) {
		tb_port_WARN(port, "port already has a remote!\n");
		return;
	}
	sw = tb_switch_alloc(port->sw->tb, &port->sw->dev,
			     tb_downstream_route(port));
	if (!sw)
		return;

	if (tb_switch_configure(sw)) {
		tb_switch_put(sw);
		return;
	}

	sw->authorized = true;

	if (tb_switch_add(sw)) {
		tb_switch_put(sw);
		return;
	}

	port->remote = tb_upstream_port(sw);
	tb_upstream_port(sw)->remote = port;
	tb_scan_switch(sw);
}

/**
 * tb_free_invalid_tunnels() - destroy tunnels of devices that have gone away
 */
static void tb_free_invalid_tunnels(struct tb *tb)
{
	struct tb_cm *tcm = tb_priv(tb);
	struct tb_pci_tunnel *tunnel;
	struct tb_pci_tunnel *n;

	list_for_each_entry_safe(tunnel, n, &tcm->tunnel_list, list) {
		if (tb_pci_is_invalid(tunnel)) {
			tb_pci_deactivate(tunnel);
			list_del(&tunnel->list);
			tb_pci_free(tunnel);
		}
	}
}

/**
 * tb_free_unplugged_children() - traverse hierarchy and free unplugged switches
 */
static void tb_free_unplugged_children(struct tb_switch *sw)
{
	int i;
	for (i = 1; i <= sw->config.max_port_number; i++) {
		struct tb_port *port = &sw->ports[i];
		if (tb_is_upstream_port(port))
			continue;
		if (!port->remote)
			continue;
		if (port->remote->sw->is_unplugged) {
			tb_switch_remove(port->remote->sw);
			port->remote = NULL;
		} else {
			tb_free_unplugged_children(port->remote->sw);
		}
	}
}


/**
 * find_pci_up_port() - return the first PCIe up port on @sw or NULL
 */
static struct tb_port *tb_find_pci_up_port(struct tb_switch *sw)
{
	int i;
	for (i = 1; i <= sw->config.max_port_number; i++)
		if (sw->ports[i].config.type == TB_TYPE_PCIE_UP)
			return &sw->ports[i];
	return NULL;
}

/**
 * find_unused_down_port() - return the first inactive PCIe down port on @sw
 */
static struct tb_port *tb_find_unused_down_port(struct tb_switch *sw)
{
	int i;
	int cap;
	int res;
	int data;
	for (i = 1; i <= sw->config.max_port_number; i++) {
		if (tb_is_upstream_port(&sw->ports[i]))
			continue;
		if (sw->ports[i].config.type != TB_TYPE_PCIE_DOWN)
			continue;
		cap = tb_port_find_cap(&sw->ports[i], TB_PORT_CAP_ADAP);
		if (cap < 0)
			continue;
		res = tb_port_read(&sw->ports[i], &data, TB_CFG_PORT, cap, 1);
		if (res < 0)
			continue;
		if (data & 0x80000000)
			continue;
		return &sw->ports[i];
	}
	return NULL;
}

/**
 * tb_activate_pcie_devices() - scan for and activate PCIe devices
 *
 * This method is somewhat ad hoc. For now it only supports one device
 * per port and only devices at depth 1.
 */
static void tb_activate_pcie_devices(struct tb *tb)
{
	int i;
	int cap;
	u32 data;
	struct tb_switch *sw;
	struct tb_port *up_port;
	struct tb_port *down_port;
	struct tb_pci_tunnel *tunnel;
	struct tb_cm *tcm = tb_priv(tb);

	/* scan for pcie devices at depth 1*/
	for (i = 1; i <= tb->root_switch->config.max_port_number; i++) {
		if (tb_is_upstream_port(&tb->root_switch->ports[i]))
			continue;
		if (tb->root_switch->ports[i].config.type != TB_TYPE_PORT)
			continue;
		if (!tb->root_switch->ports[i].remote)
			continue;
		sw = tb->root_switch->ports[i].remote->sw;
		up_port = tb_find_pci_up_port(sw);
		if (!up_port) {
			tb_sw_info(sw, "no PCIe devices found, aborting\n");
			continue;
		}

		/* check whether port is already activated */
		cap = tb_port_find_cap(up_port, TB_PORT_CAP_ADAP);
		if (cap < 0)
			continue;
		if (tb_port_read(up_port, &data, TB_CFG_PORT, cap, 1))
			continue;
		if (data & 0x80000000) {
			tb_port_info(up_port,
				     "PCIe port already activated, aborting\n");
			continue;
		}

		down_port = tb_find_unused_down_port(tb->root_switch);
		if (!down_port) {
			tb_port_info(up_port,
				     "All PCIe down ports are occupied, aborting\n");
			continue;
		}
		tunnel = tb_pci_alloc(tb, up_port, down_port);
		if (!tunnel) {
			tb_port_info(up_port,
				     "PCIe tunnel allocation failed, aborting\n");
			continue;
		}

		if (tb_pci_activate(tunnel)) {
			tb_port_info(up_port,
				     "PCIe tunnel activation failed, aborting\n");
			tb_pci_free(tunnel);
			continue;
		}

		list_add(&tunnel->list, &tcm->tunnel_list);
	}
}

/* hotplug handling */

struct tb_hotplug_event {
	struct work_struct work;
	struct tb *tb;
	u64 route;
	u8 port;
	bool unplug;
};

/**
 * tb_handle_hotplug() - handle hotplug event
 *
 * Executes on tb->wq.
 */
static void tb_handle_hotplug(struct work_struct *work)
{
	struct tb_hotplug_event *ev = container_of(work, typeof(*ev), work);
	struct tb *tb = ev->tb;
	struct tb_cm *tcm = tb_priv(tb);
	struct tb_switch *sw;
	struct tb_port *port;
	mutex_lock(&tb->lock);
	if (!tcm->hotplug_active)
		goto out; /* during init, suspend or shutdown */

	sw = get_switch_at_route(tb->root_switch, ev->route);
	if (!sw) {
		tb_warn(tb,
			"hotplug event from non existent switch %llx:%x (unplug: %d)\n",
			ev->route, ev->port, ev->unplug);
		goto out;
	}
	if (ev->port > sw->config.max_port_number) {
		tb_warn(tb,
			"hotplug event from non existent port %llx:%x (unplug: %d)\n",
			ev->route, ev->port, ev->unplug);
		goto out;
	}
	port = &sw->ports[ev->port];
	if (tb_is_upstream_port(port)) {
		tb_warn(tb,
			"hotplug event for upstream port %llx:%x (unplug: %d)\n",
			ev->route, ev->port, ev->unplug);
		goto out;
	}
	if (ev->unplug) {
		if (port->remote) {
			tb_port_info(port, "unplugged\n");
			tb_sw_set_unplugged(port->remote->sw);
			tb_free_invalid_tunnels(tb);
			tb_switch_remove(port->remote->sw);
			port->remote = NULL;
		} else {
			tb_port_info(port,
				     "got unplug event for disconnected port, ignoring\n");
		}
	} else if (port->remote) {
		tb_port_info(port,
			     "got plug event for connected port, ignoring\n");
	} else {
		tb_port_info(port, "hotplug: scanning\n");
		tb_scan_port(port);
		if (!port->remote) {
			tb_port_info(port, "hotplug: no switch found\n");
		} else if (port->remote->sw->config.depth > 1) {
			tb_sw_warn(port->remote->sw,
				   "hotplug: chaining not supported\n");
		} else {
			tb_sw_info(port->remote->sw,
				   "hotplug: activating pcie devices\n");
			tb_activate_pcie_devices(tb);
		}
	}
out:
	mutex_unlock(&tb->lock);
	kfree(ev);
}

/**
 * tb_schedule_hotplug_handler() - callback function for the control channel
 *
 * Delegates to tb_handle_hotplug.
 */
static void tb_handle_event(struct tb *tb, enum tb_cfg_pkg_type type,
			    const void *buf, size_t size)
{
	const struct cfg_event_pkg *pkg = buf;
	struct tb_hotplug_event *ev;
	u64 route;

	if (type != TB_CFG_PKG_EVENT) {
		tb_warn(tb, "unexpected event %#x, ignoring\n", type);
		return;
	}

	route = tb_cfg_get_route(&pkg->header);

	if (tb_cfg_error(tb->ctl, route, pkg->port,
			 TB_CFG_ERROR_ACK_PLUG_EVENT)) {
		tb_warn(tb, "could not ack plug event on %llx:%x\n", route,
			pkg->port);
	}

	ev = kmalloc(sizeof(*ev), GFP_KERNEL);
	if (!ev)
		return;
	INIT_WORK(&ev->work, tb_handle_hotplug);
	ev->tb = tb;
	ev->route = route;
	ev->port = pkg->port;
	ev->unplug = pkg->unplug;
	queue_work(tb->wq, &ev->work);
}

static void tb_stop(struct tb *tb)
{
	struct tb_cm *tcm = tb_priv(tb);
	struct tb_pci_tunnel *tunnel;
	struct tb_pci_tunnel *n;

	/* tunnels are only present after everything has been initialized */
	list_for_each_entry_safe(tunnel, n, &tcm->tunnel_list, list) {
		tb_pci_deactivate(tunnel);
		tb_pci_free(tunnel);
	}
	tb_switch_remove(tb->root_switch);
	tcm->hotplug_active = false; /* signal tb_handle_hotplug to quit */
}

static int tb_start(struct tb *tb)
{
	struct tb_cm *tcm = tb_priv(tb);
	int ret;

	tb->root_switch = tb_switch_alloc(tb, &tb->dev, 0);
	if (!tb->root_switch)
		return -ENOMEM;

	/*
	 * ICM firmware upgrade needs running firmware and in native
	 * mode that is not available so disable firmware upgrade of the
	 * root switch.
	 */
	tb->root_switch->no_nvm_upgrade = true;

	ret = tb_switch_configure(tb->root_switch);
	if (ret) {
		tb_switch_put(tb->root_switch);
		return ret;
	}

	/* Announce the switch to the world */
	ret = tb_switch_add(tb->root_switch);
	if (ret) {
		tb_switch_put(tb->root_switch);
		return ret;
	}

	/* Full scan to discover devices added before the driver was loaded. */
	tb_scan_switch(tb->root_switch);
	tb_activate_pcie_devices(tb);

	/* Allow tb_handle_hotplug to progress events */
	tcm->hotplug_active = true;
	return 0;
}

static int tb_suspend_noirq(struct tb *tb)
{
	struct tb_cm *tcm = tb_priv(tb);

	tb_info(tb, "suspending...\n");
	tb_switch_suspend(tb->root_switch);
	tcm->hotplug_active = false; /* signal tb_handle_hotplug to quit */
	tb_info(tb, "suspend finished\n");

	return 0;
}

static int tb_resume_noirq(struct tb *tb)
{
	struct tb_cm *tcm = tb_priv(tb);
	struct tb_pci_tunnel *tunnel, *n;

	tb_info(tb, "resuming...\n");

	/* remove any pci devices the firmware might have setup */
	tb_switch_reset(tb, 0);

	tb_switch_resume(tb->root_switch);
	tb_free_invalid_tunnels(tb);
	tb_free_unplugged_children(tb->root_switch);
	list_for_each_entry_safe(tunnel, n, &tcm->tunnel_list, list)
		tb_pci_restart(tunnel);
	if (!list_empty(&tcm->tunnel_list)) {
		/*
		 * the pcie links need some time to get going.
		 * 100ms works for me...
		 */
		tb_info(tb, "tunnels restarted, sleeping for 100ms\n");
		msleep(100);
	}
	 /* Allow tb_handle_hotplug to progress events */
	tcm->hotplug_active = true;
	tb_info(tb, "resume finished\n");

	return 0;
}

static const struct tb_cm_ops tb_cm_ops = {
	.start = tb_start,
	.stop = tb_stop,
	.suspend_noirq = tb_suspend_noirq,
	.resume_noirq = tb_resume_noirq,
	.handle_event = tb_handle_event,
};

struct tb *tb_probe(struct tb_nhi *nhi)
{
	struct tb_cm *tcm;
	struct tb *tb;

	if (!x86_apple_machine)
		return NULL;

	tb = tb_domain_alloc(nhi, sizeof(*tcm));
	if (!tb)
		return NULL;

	tb->security_level = TB_SECURITY_NONE;
	tb->cm_ops = &tb_cm_ops;

	tcm = tb_priv(tb);
	INIT_LIST_HEAD(&tcm->tunnel_list);

	return tb;
}
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
d6cc51cd AN	2	/*
	3	* Thunderbolt Cactus Ridge driver - bus logic (NHI independent)
	4	*
	5	* Copyright (c) 2014 Andreas Noever <andreas.noever@gmail.com>
	6	*/
	7
	8	#include <linux/slab.h>
	9	#include <linux/errno.h>
	10	#include <linux/delay.h>
630b3aff	11	#include <linux/platform_data/x86/apple.h>
d6cc51cd AN	12
d6cc51cd AN	13	#include "tb.h"
7adf6097	14	#include "tb_regs.h"
3364f0c1	15	#include "tunnel_pci.h"
d6cc51cd	16
9d3cce0b MW	17	/**
	18	* struct tb_cm - Simple Thunderbolt connection manager
	19	* @tunnel_list: List of active tunnels
	20	* @hotplug_active: tb_handle_hotplug will stop progressing plug
	21	* events and exit if this is not set (it needs to
	22	* acquire the lock one more time). Used to drain wq
	23	* after cfg has been paused.
	24	*/
	25	struct tb_cm {
	26	struct list_head tunnel_list;
	27	bool hotplug_active;
	28	};
9da672a4 AN	29
	30	/* enumeration & hot plug handling */
	31
	32
	33	static void tb_scan_port(struct tb_port *port);
	34
	35	/**
	36	* tb_scan_switch() - scan for and initialize downstream switches
	37	*/
	38	static void tb_scan_switch(struct tb_switch *sw)
	39	{
	40	int i;
	41	for (i = 1; i <= sw->config.max_port_number; i++)
	42	tb_scan_port(&sw->ports[i]);
	43	}
	44
	45	/**
	46	* tb_scan_port() - check for and initialize switches below port
	47	*/
	48	static void tb_scan_port(struct tb_port *port)
	49	{
	50	struct tb_switch *sw;
	51	if (tb_is_upstream_port(port))
	52	return;
	53	if (port->config.type != TB_TYPE_PORT)
	54	return;
343fcb8c AN	55	if (port->dual_link_port && port->link_nr)
	56	return; /*
	57	* Downstream switch is reachable through two ports.
	58	* Only scan on the primary port (link_nr == 0).
	59	*/
9da672a4 AN	60	if (tb_wait_for_port(port, false) <= 0)
	61	return;
	62	if (port->remote) {
	63	tb_port_WARN(port, "port already has a remote!\n");
	64	return;
	65	}
bfe778ac MW	66	sw = tb_switch_alloc(port->sw->tb, &port->sw->dev,
bfe778ac MW	67	tb_downstream_route(port));
9da672a4 AN	68	if (!sw)
9da672a4 AN	69	return;
bfe778ac MW	70
	71	if (tb_switch_configure(sw)) {
	72	tb_switch_put(sw);
	73	return;
	74	}
	75
f67cf491 MW	76	sw->authorized = true;
f67cf491 MW	77
bfe778ac MW	78	if (tb_switch_add(sw)) {
	79	tb_switch_put(sw);
	80	return;
	81	}
	82
9da672a4 AN	83	port->remote = tb_upstream_port(sw);
	84	tb_upstream_port(sw)->remote = port;
	85	tb_scan_switch(sw);
	86	}
	87
3364f0c1 AN	88	/**
	89	* tb_free_invalid_tunnels() - destroy tunnels of devices that have gone away
	90	*/
	91	static void tb_free_invalid_tunnels(struct tb *tb)
	92	{
9d3cce0b	93	struct tb_cm *tcm = tb_priv(tb);
3364f0c1 AN	94	struct tb_pci_tunnel *tunnel;
3364f0c1 AN	95	struct tb_pci_tunnel *n;
9d3cce0b MW	96
9d3cce0b MW	97	list_for_each_entry_safe(tunnel, n, &tcm->tunnel_list, list) {
3364f0c1 AN	98	if (tb_pci_is_invalid(tunnel)) {
3364f0c1 AN	99	tb_pci_deactivate(tunnel);
9d3cce0b	100	list_del(&tunnel->list);
3364f0c1 AN	101	tb_pci_free(tunnel);
	102	}
	103	}
	104	}
	105
23dd5bb4 AN	106	/**
	107	* tb_free_unplugged_children() - traverse hierarchy and free unplugged switches
	108	*/
	109	static void tb_free_unplugged_children(struct tb_switch *sw)
	110	{
	111	int i;
	112	for (i = 1; i <= sw->config.max_port_number; i++) {
	113	struct tb_port *port = &sw->ports[i];
	114	if (tb_is_upstream_port(port))
	115	continue;
	116	if (!port->remote)
	117	continue;
	118	if (port->remote->sw->is_unplugged) {
bfe778ac	119	tb_switch_remove(port->remote->sw);
23dd5bb4 AN	120	port->remote = NULL;
	121	} else {
	122	tb_free_unplugged_children(port->remote->sw);
	123	}
	124	}
	125	}
	126
	127
3364f0c1 AN	128	/**
	129	* find_pci_up_port() - return the first PCIe up port on @sw or NULL
	130	*/
	131	static struct tb_port tb_find_pci_up_port(struct tb_switch sw)
	132	{
	133	int i;
	134	for (i = 1; i <= sw->config.max_port_number; i++)
	135	if (sw->ports[i].config.type == TB_TYPE_PCIE_UP)
	136	return &sw->ports[i];
	137	return NULL;
	138	}
	139
	140	/**
	141	* find_unused_down_port() - return the first inactive PCIe down port on @sw
	142	*/
	143	static struct tb_port tb_find_unused_down_port(struct tb_switch sw)
	144	{
	145	int i;
	146	int cap;
	147	int res;
	148	int data;
	149	for (i = 1; i <= sw->config.max_port_number; i++) {
	150	if (tb_is_upstream_port(&sw->ports[i]))
	151	continue;
	152	if (sw->ports[i].config.type != TB_TYPE_PCIE_DOWN)
	153	continue;
da2da04b MW	154	cap = tb_port_find_cap(&sw->ports[i], TB_PORT_CAP_ADAP);
da2da04b MW	155	if (cap < 0)
3364f0c1 AN	156	continue;
	157	res = tb_port_read(&sw->ports[i], &data, TB_CFG_PORT, cap, 1);
	158	if (res < 0)
	159	continue;
	160	if (data & 0x80000000)
	161	continue;
	162	return &sw->ports[i];
	163	}
	164	return NULL;
	165	}
	166
	167	/**
	168	* tb_activate_pcie_devices() - scan for and activate PCIe devices
	169	*
	170	* This method is somewhat ad hoc. For now it only supports one device
	171	* per port and only devices at depth 1.
	172	*/
	173	static void tb_activate_pcie_devices(struct tb *tb)
	174	{
	175	int i;
	176	int cap;
	177	u32 data;
	178	struct tb_switch *sw;
	179	struct tb_port *up_port;
	180	struct tb_port *down_port;
	181	struct tb_pci_tunnel *tunnel;
9d3cce0b MW	182	struct tb_cm *tcm = tb_priv(tb);
9d3cce0b MW	183
3364f0c1 AN	184	/* scan for pcie devices at depth 1*/
	185	for (i = 1; i <= tb->root_switch->config.max_port_number; i++) {
	186	if (tb_is_upstream_port(&tb->root_switch->ports[i]))
	187	continue;
	188	if (tb->root_switch->ports[i].config.type != TB_TYPE_PORT)
	189	continue;
	190	if (!tb->root_switch->ports[i].remote)
	191	continue;
	192	sw = tb->root_switch->ports[i].remote->sw;
	193	up_port = tb_find_pci_up_port(sw);
	194	if (!up_port) {
	195	tb_sw_info(sw, "no PCIe devices found, aborting\n");
	196	continue;
	197	}
	198
	199	/* check whether port is already activated */
da2da04b MW	200	cap = tb_port_find_cap(up_port, TB_PORT_CAP_ADAP);
da2da04b MW	201	if (cap < 0)
3364f0c1 AN	202	continue;
	203	if (tb_port_read(up_port, &data, TB_CFG_PORT, cap, 1))
	204	continue;
	205	if (data & 0x80000000) {
	206	tb_port_info(up_port,
	207	"PCIe port already activated, aborting\n");
	208	continue;
	209	}
	210
	211	down_port = tb_find_unused_down_port(tb->root_switch);
	212	if (!down_port) {
	213	tb_port_info(up_port,
	214	"All PCIe down ports are occupied, aborting\n");
	215	continue;
	216	}
	217	tunnel = tb_pci_alloc(tb, up_port, down_port);
	218	if (!tunnel) {
	219	tb_port_info(up_port,
	220	"PCIe tunnel allocation failed, aborting\n");
	221	continue;
	222	}
	223
	224	if (tb_pci_activate(tunnel)) {
	225	tb_port_info(up_port,
	226	"PCIe tunnel activation failed, aborting\n");
	227	tb_pci_free(tunnel);
a2e37343	228	continue;
3364f0c1 AN	229	}
3364f0c1 AN	230
9d3cce0b	231	list_add(&tunnel->list, &tcm->tunnel_list);
3364f0c1 AN	232	}
3364f0c1 AN	233	}
9da672a4	234
d6cc51cd AN	235	/* hotplug handling */
	236
	237	struct tb_hotplug_event {
	238	struct work_struct work;
	239	struct tb *tb;
	240	u64 route;
	241	u8 port;
	242	bool unplug;
	243	};
	244
	245	/**
	246	* tb_handle_hotplug() - handle hotplug event
	247	*
	248	* Executes on tb->wq.
	249	*/
	250	static void tb_handle_hotplug(struct work_struct *work)
	251	{
	252	struct tb_hotplug_event ev = container_of(work, typeof(ev), work);
	253	struct tb *tb = ev->tb;
9d3cce0b	254	struct tb_cm *tcm = tb_priv(tb);
053596d9 AN	255	struct tb_switch *sw;
053596d9 AN	256	struct tb_port *port;
d6cc51cd	257	mutex_lock(&tb->lock);
9d3cce0b	258	if (!tcm->hotplug_active)
d6cc51cd AN	259	goto out; /* during init, suspend or shutdown */
d6cc51cd AN	260
053596d9 AN	261	sw = get_switch_at_route(tb->root_switch, ev->route);
	262	if (!sw) {
	263	tb_warn(tb,
	264	"hotplug event from non existent switch %llx:%x (unplug: %d)\n",
	265	ev->route, ev->port, ev->unplug);
	266	goto out;
	267	}
	268	if (ev->port > sw->config.max_port_number) {
	269	tb_warn(tb,
	270	"hotplug event from non existent port %llx:%x (unplug: %d)\n",
	271	ev->route, ev->port, ev->unplug);
	272	goto out;
	273	}
	274	port = &sw->ports[ev->port];
	275	if (tb_is_upstream_port(port)) {
	276	tb_warn(tb,
	277	"hotplug event for upstream port %llx:%x (unplug: %d)\n",
	278	ev->route, ev->port, ev->unplug);
	279	goto out;
	280	}
	281	if (ev->unplug) {
	282	if (port->remote) {
	283	tb_port_info(port, "unplugged\n");
aae20bb6	284	tb_sw_set_unplugged(port->remote->sw);
3364f0c1	285	tb_free_invalid_tunnels(tb);
bfe778ac	286	tb_switch_remove(port->remote->sw);
053596d9 AN	287	port->remote = NULL;
	288	} else {
	289	tb_port_info(port,
	290	"got unplug event for disconnected port, ignoring\n");
	291	}
	292	} else if (port->remote) {
	293	tb_port_info(port,
	294	"got plug event for connected port, ignoring\n");
	295	} else {
	296	tb_port_info(port, "hotplug: scanning\n");
	297	tb_scan_port(port);
	298	if (!port->remote) {
	299	tb_port_info(port, "hotplug: no switch found\n");
	300	} else if (port->remote->sw->config.depth > 1) {
	301	tb_sw_warn(port->remote->sw,
	302	"hotplug: chaining not supported\n");
3364f0c1 AN	303	} else {
	304	tb_sw_info(port->remote->sw,
	305	"hotplug: activating pcie devices\n");
	306	tb_activate_pcie_devices(tb);
053596d9 AN	307	}
053596d9 AN	308	}
d6cc51cd AN	309	out:
	310	mutex_unlock(&tb->lock);
	311	kfree(ev);
	312	}
	313
	314	/**
	315	* tb_schedule_hotplug_handler() - callback function for the control channel
	316	*
	317	* Delegates to tb_handle_hotplug.
	318	*/
81a54b5e MW	319	static void tb_handle_event(struct tb *tb, enum tb_cfg_pkg_type type,
81a54b5e MW	320	const void *buf, size_t size)
d6cc51cd	321	{
81a54b5e MW	322	const struct cfg_event_pkg *pkg = buf;
	323	struct tb_hotplug_event *ev;
	324	u64 route;
	325
	326	if (type != TB_CFG_PKG_EVENT) {
	327	tb_warn(tb, "unexpected event %#x, ignoring\n", type);
	328	return;
	329	}
	330
	331	route = tb_cfg_get_route(&pkg->header);
	332
	333	if (tb_cfg_error(tb->ctl, route, pkg->port,
	334	TB_CFG_ERROR_ACK_PLUG_EVENT)) {
	335	tb_warn(tb, "could not ack plug event on %llx:%x\n", route,
	336	pkg->port);
	337	}
	338
	339	ev = kmalloc(sizeof(*ev), GFP_KERNEL);
d6cc51cd AN	340	if (!ev)
	341	return;
	342	INIT_WORK(&ev->work, tb_handle_hotplug);
	343	ev->tb = tb;
	344	ev->route = route;
81a54b5e MW	345	ev->port = pkg->port;
81a54b5e MW	346	ev->unplug = pkg->unplug;
d6cc51cd AN	347	queue_work(tb->wq, &ev->work);
	348	}
	349
9d3cce0b	350	static void tb_stop(struct tb *tb)
d6cc51cd	351	{
9d3cce0b	352	struct tb_cm *tcm = tb_priv(tb);
3364f0c1 AN	353	struct tb_pci_tunnel *tunnel;
	354	struct tb_pci_tunnel *n;
	355
3364f0c1	356	/* tunnels are only present after everything has been initialized */
9d3cce0b	357	list_for_each_entry_safe(tunnel, n, &tcm->tunnel_list, list) {
3364f0c1 AN	358	tb_pci_deactivate(tunnel);
	359	tb_pci_free(tunnel);
	360	}
bfe778ac	361	tb_switch_remove(tb->root_switch);
9d3cce0b	362	tcm->hotplug_active = false; /* signal tb_handle_hotplug to quit */
d6cc51cd AN	363	}
d6cc51cd AN	364
9d3cce0b	365	static int tb_start(struct tb *tb)
d6cc51cd	366	{
9d3cce0b	367	struct tb_cm *tcm = tb_priv(tb);
bfe778ac	368	int ret;
d6cc51cd	369
bfe778ac	370	tb->root_switch = tb_switch_alloc(tb, &tb->dev, 0);
a25c8b2f	371	if (!tb->root_switch)
9d3cce0b	372	return -ENOMEM;
a25c8b2f	373
e6b245cc MW	374	/*
	375	* ICM firmware upgrade needs running firmware and in native
	376	* mode that is not available so disable firmware upgrade of the
	377	* root switch.
	378	*/
	379	tb->root_switch->no_nvm_upgrade = true;
	380
bfe778ac MW	381	ret = tb_switch_configure(tb->root_switch);
	382	if (ret) {
	383	tb_switch_put(tb->root_switch);
	384	return ret;
	385	}
	386
	387	/* Announce the switch to the world */
	388	ret = tb_switch_add(tb->root_switch);
	389	if (ret) {
	390	tb_switch_put(tb->root_switch);
	391	return ret;
	392	}
	393
9da672a4 AN	394	/* Full scan to discover devices added before the driver was loaded. */
9da672a4 AN	395	tb_scan_switch(tb->root_switch);
3364f0c1	396	tb_activate_pcie_devices(tb);
9da672a4	397
d6cc51cd	398	/* Allow tb_handle_hotplug to progress events */
9d3cce0b MW	399	tcm->hotplug_active = true;
9d3cce0b MW	400	return 0;
d6cc51cd AN	401	}
d6cc51cd AN	402
9d3cce0b	403	static int tb_suspend_noirq(struct tb *tb)
23dd5bb4	404	{
9d3cce0b MW	405	struct tb_cm *tcm = tb_priv(tb);
9d3cce0b MW	406
23dd5bb4	407	tb_info(tb, "suspending...\n");
23dd5bb4	408	tb_switch_suspend(tb->root_switch);
9d3cce0b	409	tcm->hotplug_active = false; /* signal tb_handle_hotplug to quit */
23dd5bb4	410	tb_info(tb, "suspend finished\n");
9d3cce0b MW	411
9d3cce0b MW	412	return 0;
23dd5bb4 AN	413	}
23dd5bb4 AN	414
9d3cce0b	415	static int tb_resume_noirq(struct tb *tb)
23dd5bb4	416	{
9d3cce0b	417	struct tb_cm *tcm = tb_priv(tb);
23dd5bb4	418	struct tb_pci_tunnel tunnel, n;
9d3cce0b	419
23dd5bb4	420	tb_info(tb, "resuming...\n");
23dd5bb4 AN	421
	422	/* remove any pci devices the firmware might have setup */
	423	tb_switch_reset(tb, 0);
	424
	425	tb_switch_resume(tb->root_switch);
	426	tb_free_invalid_tunnels(tb);
	427	tb_free_unplugged_children(tb->root_switch);
9d3cce0b	428	list_for_each_entry_safe(tunnel, n, &tcm->tunnel_list, list)
23dd5bb4	429	tb_pci_restart(tunnel);
9d3cce0b	430	if (!list_empty(&tcm->tunnel_list)) {
23dd5bb4 AN	431	/*
	432	* the pcie links need some time to get going.
	433	* 100ms works for me...
	434	*/
	435	tb_info(tb, "tunnels restarted, sleeping for 100ms\n");
	436	msleep(100);
	437	}
	438	/* Allow tb_handle_hotplug to progress events */
9d3cce0b	439	tcm->hotplug_active = true;
23dd5bb4	440	tb_info(tb, "resume finished\n");
9d3cce0b MW	441
	442	return 0;
	443	}
	444
	445	static const struct tb_cm_ops tb_cm_ops = {
	446	.start = tb_start,
	447	.stop = tb_stop,
	448	.suspend_noirq = tb_suspend_noirq,
	449	.resume_noirq = tb_resume_noirq,
81a54b5e	450	.handle_event = tb_handle_event,
9d3cce0b MW	451	};
	452
	453	struct tb tb_probe(struct tb_nhi nhi)
	454	{
	455	struct tb_cm *tcm;
	456	struct tb *tb;
	457
630b3aff	458	if (!x86_apple_machine)
f67cf491 MW	459	return NULL;
f67cf491 MW	460
9d3cce0b MW	461	tb = tb_domain_alloc(nhi, sizeof(*tcm));
	462	if (!tb)
	463	return NULL;
	464
f67cf491	465	tb->security_level = TB_SECURITY_NONE;
9d3cce0b MW	466	tb->cm_ops = &tb_cm_ops;
	467
	468	tcm = tb_priv(tb);
	469	INIT_LIST_HEAD(&tcm->tunnel_list);
	470
	471	return tb;
23dd5bb4	472	}