1d6cc51cdSAndreas Noever /* 2d6cc51cdSAndreas Noever * Thunderbolt Cactus Ridge driver - bus logic (NHI independent) 3d6cc51cdSAndreas Noever * 4d6cc51cdSAndreas Noever * Copyright (c) 2014 Andreas Noever <andreas.noever@gmail.com> 5d6cc51cdSAndreas Noever */ 6d6cc51cdSAndreas Noever 7d6cc51cdSAndreas Noever #include <linux/slab.h> 8d6cc51cdSAndreas Noever #include <linux/errno.h> 9d6cc51cdSAndreas Noever #include <linux/delay.h> 10d6cc51cdSAndreas Noever 11d6cc51cdSAndreas Noever #include "tb.h" 127adf6097SAndreas Noever #include "tb_regs.h" 133364f0c1SAndreas Noever #include "tunnel_pci.h" 14d6cc51cdSAndreas Noever 159d3cce0bSMika Westerberg /** 169d3cce0bSMika Westerberg * struct tb_cm - Simple Thunderbolt connection manager 179d3cce0bSMika Westerberg * @tunnel_list: List of active tunnels 189d3cce0bSMika Westerberg * @hotplug_active: tb_handle_hotplug will stop progressing plug 199d3cce0bSMika Westerberg * events and exit if this is not set (it needs to 209d3cce0bSMika Westerberg * acquire the lock one more time). Used to drain wq 219d3cce0bSMika Westerberg * after cfg has been paused. 229d3cce0bSMika Westerberg */ 239d3cce0bSMika Westerberg struct tb_cm { 249d3cce0bSMika Westerberg struct list_head tunnel_list; 259d3cce0bSMika Westerberg bool hotplug_active; 269d3cce0bSMika Westerberg }; 279da672a4SAndreas Noever 289da672a4SAndreas Noever /* enumeration & hot plug handling */ 299da672a4SAndreas Noever 309da672a4SAndreas Noever 319da672a4SAndreas Noever static void tb_scan_port(struct tb_port *port); 329da672a4SAndreas Noever 339da672a4SAndreas Noever /** 349da672a4SAndreas Noever * tb_scan_switch() - scan for and initialize downstream switches 359da672a4SAndreas Noever */ 369da672a4SAndreas Noever static void tb_scan_switch(struct tb_switch *sw) 379da672a4SAndreas Noever { 389da672a4SAndreas Noever int i; 399da672a4SAndreas Noever for (i = 1; i <= sw->config.max_port_number; i++) 409da672a4SAndreas Noever tb_scan_port(&sw->ports[i]); 419da672a4SAndreas Noever } 429da672a4SAndreas Noever 439da672a4SAndreas Noever /** 449da672a4SAndreas Noever * tb_scan_port() - check for and initialize switches below port 459da672a4SAndreas Noever */ 469da672a4SAndreas Noever static void tb_scan_port(struct tb_port *port) 479da672a4SAndreas Noever { 489da672a4SAndreas Noever struct tb_switch *sw; 499da672a4SAndreas Noever if (tb_is_upstream_port(port)) 509da672a4SAndreas Noever return; 519da672a4SAndreas Noever if (port->config.type != TB_TYPE_PORT) 529da672a4SAndreas Noever return; 53343fcb8cSAndreas Noever if (port->dual_link_port && port->link_nr) 54343fcb8cSAndreas Noever return; /* 55343fcb8cSAndreas Noever * Downstream switch is reachable through two ports. 56343fcb8cSAndreas Noever * Only scan on the primary port (link_nr == 0). 57343fcb8cSAndreas Noever */ 589da672a4SAndreas Noever if (tb_wait_for_port(port, false) <= 0) 599da672a4SAndreas Noever return; 609da672a4SAndreas Noever if (port->remote) { 619da672a4SAndreas Noever tb_port_WARN(port, "port already has a remote!\n"); 629da672a4SAndreas Noever return; 639da672a4SAndreas Noever } 64bfe778acSMika Westerberg sw = tb_switch_alloc(port->sw->tb, &port->sw->dev, 65bfe778acSMika Westerberg tb_downstream_route(port)); 669da672a4SAndreas Noever if (!sw) 679da672a4SAndreas Noever return; 68bfe778acSMika Westerberg 69bfe778acSMika Westerberg if (tb_switch_configure(sw)) { 70bfe778acSMika Westerberg tb_switch_put(sw); 71bfe778acSMika Westerberg return; 72bfe778acSMika Westerberg } 73bfe778acSMika Westerberg 74bfe778acSMika Westerberg if (tb_switch_add(sw)) { 75bfe778acSMika Westerberg tb_switch_put(sw); 76bfe778acSMika Westerberg return; 77bfe778acSMika Westerberg } 78bfe778acSMika Westerberg 799da672a4SAndreas Noever port->remote = tb_upstream_port(sw); 809da672a4SAndreas Noever tb_upstream_port(sw)->remote = port; 819da672a4SAndreas Noever tb_scan_switch(sw); 829da672a4SAndreas Noever } 839da672a4SAndreas Noever 843364f0c1SAndreas Noever /** 853364f0c1SAndreas Noever * tb_free_invalid_tunnels() - destroy tunnels of devices that have gone away 863364f0c1SAndreas Noever */ 873364f0c1SAndreas Noever static void tb_free_invalid_tunnels(struct tb *tb) 883364f0c1SAndreas Noever { 899d3cce0bSMika Westerberg struct tb_cm *tcm = tb_priv(tb); 903364f0c1SAndreas Noever struct tb_pci_tunnel *tunnel; 913364f0c1SAndreas Noever struct tb_pci_tunnel *n; 929d3cce0bSMika Westerberg 939d3cce0bSMika Westerberg list_for_each_entry_safe(tunnel, n, &tcm->tunnel_list, list) { 943364f0c1SAndreas Noever if (tb_pci_is_invalid(tunnel)) { 953364f0c1SAndreas Noever tb_pci_deactivate(tunnel); 969d3cce0bSMika Westerberg list_del(&tunnel->list); 973364f0c1SAndreas Noever tb_pci_free(tunnel); 983364f0c1SAndreas Noever } 993364f0c1SAndreas Noever } 1003364f0c1SAndreas Noever } 1013364f0c1SAndreas Noever 1023364f0c1SAndreas Noever /** 10323dd5bb4SAndreas Noever * tb_free_unplugged_children() - traverse hierarchy and free unplugged switches 10423dd5bb4SAndreas Noever */ 10523dd5bb4SAndreas Noever static void tb_free_unplugged_children(struct tb_switch *sw) 10623dd5bb4SAndreas Noever { 10723dd5bb4SAndreas Noever int i; 10823dd5bb4SAndreas Noever for (i = 1; i <= sw->config.max_port_number; i++) { 10923dd5bb4SAndreas Noever struct tb_port *port = &sw->ports[i]; 11023dd5bb4SAndreas Noever if (tb_is_upstream_port(port)) 11123dd5bb4SAndreas Noever continue; 11223dd5bb4SAndreas Noever if (!port->remote) 11323dd5bb4SAndreas Noever continue; 11423dd5bb4SAndreas Noever if (port->remote->sw->is_unplugged) { 115bfe778acSMika Westerberg tb_switch_remove(port->remote->sw); 11623dd5bb4SAndreas Noever port->remote = NULL; 11723dd5bb4SAndreas Noever } else { 11823dd5bb4SAndreas Noever tb_free_unplugged_children(port->remote->sw); 11923dd5bb4SAndreas Noever } 12023dd5bb4SAndreas Noever } 12123dd5bb4SAndreas Noever } 12223dd5bb4SAndreas Noever 12323dd5bb4SAndreas Noever 12423dd5bb4SAndreas Noever /** 1253364f0c1SAndreas Noever * find_pci_up_port() - return the first PCIe up port on @sw or NULL 1263364f0c1SAndreas Noever */ 1273364f0c1SAndreas Noever static struct tb_port *tb_find_pci_up_port(struct tb_switch *sw) 1283364f0c1SAndreas Noever { 1293364f0c1SAndreas Noever int i; 1303364f0c1SAndreas Noever for (i = 1; i <= sw->config.max_port_number; i++) 1313364f0c1SAndreas Noever if (sw->ports[i].config.type == TB_TYPE_PCIE_UP) 1323364f0c1SAndreas Noever return &sw->ports[i]; 1333364f0c1SAndreas Noever return NULL; 1343364f0c1SAndreas Noever } 1353364f0c1SAndreas Noever 1363364f0c1SAndreas Noever /** 1373364f0c1SAndreas Noever * find_unused_down_port() - return the first inactive PCIe down port on @sw 1383364f0c1SAndreas Noever */ 1393364f0c1SAndreas Noever static struct tb_port *tb_find_unused_down_port(struct tb_switch *sw) 1403364f0c1SAndreas Noever { 1413364f0c1SAndreas Noever int i; 1423364f0c1SAndreas Noever int cap; 1433364f0c1SAndreas Noever int res; 1443364f0c1SAndreas Noever int data; 1453364f0c1SAndreas Noever for (i = 1; i <= sw->config.max_port_number; i++) { 1463364f0c1SAndreas Noever if (tb_is_upstream_port(&sw->ports[i])) 1473364f0c1SAndreas Noever continue; 1483364f0c1SAndreas Noever if (sw->ports[i].config.type != TB_TYPE_PCIE_DOWN) 1493364f0c1SAndreas Noever continue; 150da2da04bSMika Westerberg cap = tb_port_find_cap(&sw->ports[i], TB_PORT_CAP_ADAP); 151da2da04bSMika Westerberg if (cap < 0) 1523364f0c1SAndreas Noever continue; 1533364f0c1SAndreas Noever res = tb_port_read(&sw->ports[i], &data, TB_CFG_PORT, cap, 1); 1543364f0c1SAndreas Noever if (res < 0) 1553364f0c1SAndreas Noever continue; 1563364f0c1SAndreas Noever if (data & 0x80000000) 1573364f0c1SAndreas Noever continue; 1583364f0c1SAndreas Noever return &sw->ports[i]; 1593364f0c1SAndreas Noever } 1603364f0c1SAndreas Noever return NULL; 1613364f0c1SAndreas Noever } 1623364f0c1SAndreas Noever 1633364f0c1SAndreas Noever /** 1643364f0c1SAndreas Noever * tb_activate_pcie_devices() - scan for and activate PCIe devices 1653364f0c1SAndreas Noever * 1663364f0c1SAndreas Noever * This method is somewhat ad hoc. For now it only supports one device 1673364f0c1SAndreas Noever * per port and only devices at depth 1. 1683364f0c1SAndreas Noever */ 1693364f0c1SAndreas Noever static void tb_activate_pcie_devices(struct tb *tb) 1703364f0c1SAndreas Noever { 1713364f0c1SAndreas Noever int i; 1723364f0c1SAndreas Noever int cap; 1733364f0c1SAndreas Noever u32 data; 1743364f0c1SAndreas Noever struct tb_switch *sw; 1753364f0c1SAndreas Noever struct tb_port *up_port; 1763364f0c1SAndreas Noever struct tb_port *down_port; 1773364f0c1SAndreas Noever struct tb_pci_tunnel *tunnel; 1789d3cce0bSMika Westerberg struct tb_cm *tcm = tb_priv(tb); 1799d3cce0bSMika Westerberg 1803364f0c1SAndreas Noever /* scan for pcie devices at depth 1*/ 1813364f0c1SAndreas Noever for (i = 1; i <= tb->root_switch->config.max_port_number; i++) { 1823364f0c1SAndreas Noever if (tb_is_upstream_port(&tb->root_switch->ports[i])) 1833364f0c1SAndreas Noever continue; 1843364f0c1SAndreas Noever if (tb->root_switch->ports[i].config.type != TB_TYPE_PORT) 1853364f0c1SAndreas Noever continue; 1863364f0c1SAndreas Noever if (!tb->root_switch->ports[i].remote) 1873364f0c1SAndreas Noever continue; 1883364f0c1SAndreas Noever sw = tb->root_switch->ports[i].remote->sw; 1893364f0c1SAndreas Noever up_port = tb_find_pci_up_port(sw); 1903364f0c1SAndreas Noever if (!up_port) { 1913364f0c1SAndreas Noever tb_sw_info(sw, "no PCIe devices found, aborting\n"); 1923364f0c1SAndreas Noever continue; 1933364f0c1SAndreas Noever } 1943364f0c1SAndreas Noever 1953364f0c1SAndreas Noever /* check whether port is already activated */ 196da2da04bSMika Westerberg cap = tb_port_find_cap(up_port, TB_PORT_CAP_ADAP); 197da2da04bSMika Westerberg if (cap < 0) 1983364f0c1SAndreas Noever continue; 1993364f0c1SAndreas Noever if (tb_port_read(up_port, &data, TB_CFG_PORT, cap, 1)) 2003364f0c1SAndreas Noever continue; 2013364f0c1SAndreas Noever if (data & 0x80000000) { 2023364f0c1SAndreas Noever tb_port_info(up_port, 2033364f0c1SAndreas Noever "PCIe port already activated, aborting\n"); 2043364f0c1SAndreas Noever continue; 2053364f0c1SAndreas Noever } 2063364f0c1SAndreas Noever 2073364f0c1SAndreas Noever down_port = tb_find_unused_down_port(tb->root_switch); 2083364f0c1SAndreas Noever if (!down_port) { 2093364f0c1SAndreas Noever tb_port_info(up_port, 2103364f0c1SAndreas Noever "All PCIe down ports are occupied, aborting\n"); 2113364f0c1SAndreas Noever continue; 2123364f0c1SAndreas Noever } 2133364f0c1SAndreas Noever tunnel = tb_pci_alloc(tb, up_port, down_port); 2143364f0c1SAndreas Noever if (!tunnel) { 2153364f0c1SAndreas Noever tb_port_info(up_port, 2163364f0c1SAndreas Noever "PCIe tunnel allocation failed, aborting\n"); 2173364f0c1SAndreas Noever continue; 2183364f0c1SAndreas Noever } 2193364f0c1SAndreas Noever 2203364f0c1SAndreas Noever if (tb_pci_activate(tunnel)) { 2213364f0c1SAndreas Noever tb_port_info(up_port, 2223364f0c1SAndreas Noever "PCIe tunnel activation failed, aborting\n"); 2233364f0c1SAndreas Noever tb_pci_free(tunnel); 2243364f0c1SAndreas Noever } 2253364f0c1SAndreas Noever 2269d3cce0bSMika Westerberg list_add(&tunnel->list, &tcm->tunnel_list); 2273364f0c1SAndreas Noever } 2283364f0c1SAndreas Noever } 2299da672a4SAndreas Noever 230d6cc51cdSAndreas Noever /* hotplug handling */ 231d6cc51cdSAndreas Noever 232d6cc51cdSAndreas Noever struct tb_hotplug_event { 233d6cc51cdSAndreas Noever struct work_struct work; 234d6cc51cdSAndreas Noever struct tb *tb; 235d6cc51cdSAndreas Noever u64 route; 236d6cc51cdSAndreas Noever u8 port; 237d6cc51cdSAndreas Noever bool unplug; 238d6cc51cdSAndreas Noever }; 239d6cc51cdSAndreas Noever 240d6cc51cdSAndreas Noever /** 241d6cc51cdSAndreas Noever * tb_handle_hotplug() - handle hotplug event 242d6cc51cdSAndreas Noever * 243d6cc51cdSAndreas Noever * Executes on tb->wq. 244d6cc51cdSAndreas Noever */ 245d6cc51cdSAndreas Noever static void tb_handle_hotplug(struct work_struct *work) 246d6cc51cdSAndreas Noever { 247d6cc51cdSAndreas Noever struct tb_hotplug_event *ev = container_of(work, typeof(*ev), work); 248d6cc51cdSAndreas Noever struct tb *tb = ev->tb; 2499d3cce0bSMika Westerberg struct tb_cm *tcm = tb_priv(tb); 250053596d9SAndreas Noever struct tb_switch *sw; 251053596d9SAndreas Noever struct tb_port *port; 252d6cc51cdSAndreas Noever mutex_lock(&tb->lock); 2539d3cce0bSMika Westerberg if (!tcm->hotplug_active) 254d6cc51cdSAndreas Noever goto out; /* during init, suspend or shutdown */ 255d6cc51cdSAndreas Noever 256053596d9SAndreas Noever sw = get_switch_at_route(tb->root_switch, ev->route); 257053596d9SAndreas Noever if (!sw) { 258053596d9SAndreas Noever tb_warn(tb, 259053596d9SAndreas Noever "hotplug event from non existent switch %llx:%x (unplug: %d)\n", 260053596d9SAndreas Noever ev->route, ev->port, ev->unplug); 261053596d9SAndreas Noever goto out; 262053596d9SAndreas Noever } 263053596d9SAndreas Noever if (ev->port > sw->config.max_port_number) { 264053596d9SAndreas Noever tb_warn(tb, 265053596d9SAndreas Noever "hotplug event from non existent port %llx:%x (unplug: %d)\n", 266053596d9SAndreas Noever ev->route, ev->port, ev->unplug); 267053596d9SAndreas Noever goto out; 268053596d9SAndreas Noever } 269053596d9SAndreas Noever port = &sw->ports[ev->port]; 270053596d9SAndreas Noever if (tb_is_upstream_port(port)) { 271053596d9SAndreas Noever tb_warn(tb, 272053596d9SAndreas Noever "hotplug event for upstream port %llx:%x (unplug: %d)\n", 273053596d9SAndreas Noever ev->route, ev->port, ev->unplug); 274053596d9SAndreas Noever goto out; 275053596d9SAndreas Noever } 276053596d9SAndreas Noever if (ev->unplug) { 277053596d9SAndreas Noever if (port->remote) { 278053596d9SAndreas Noever tb_port_info(port, "unplugged\n"); 279aae20bb6SLukas Wunner tb_sw_set_unplugged(port->remote->sw); 2803364f0c1SAndreas Noever tb_free_invalid_tunnels(tb); 281bfe778acSMika Westerberg tb_switch_remove(port->remote->sw); 282053596d9SAndreas Noever port->remote = NULL; 283053596d9SAndreas Noever } else { 284053596d9SAndreas Noever tb_port_info(port, 285053596d9SAndreas Noever "got unplug event for disconnected port, ignoring\n"); 286053596d9SAndreas Noever } 287053596d9SAndreas Noever } else if (port->remote) { 288053596d9SAndreas Noever tb_port_info(port, 289053596d9SAndreas Noever "got plug event for connected port, ignoring\n"); 290053596d9SAndreas Noever } else { 291053596d9SAndreas Noever tb_port_info(port, "hotplug: scanning\n"); 292053596d9SAndreas Noever tb_scan_port(port); 293053596d9SAndreas Noever if (!port->remote) { 294053596d9SAndreas Noever tb_port_info(port, "hotplug: no switch found\n"); 295053596d9SAndreas Noever } else if (port->remote->sw->config.depth > 1) { 296053596d9SAndreas Noever tb_sw_warn(port->remote->sw, 297053596d9SAndreas Noever "hotplug: chaining not supported\n"); 2983364f0c1SAndreas Noever } else { 2993364f0c1SAndreas Noever tb_sw_info(port->remote->sw, 3003364f0c1SAndreas Noever "hotplug: activating pcie devices\n"); 3013364f0c1SAndreas Noever tb_activate_pcie_devices(tb); 302053596d9SAndreas Noever } 303053596d9SAndreas Noever } 304d6cc51cdSAndreas Noever out: 305d6cc51cdSAndreas Noever mutex_unlock(&tb->lock); 306d6cc51cdSAndreas Noever kfree(ev); 307d6cc51cdSAndreas Noever } 308d6cc51cdSAndreas Noever 309d6cc51cdSAndreas Noever /** 310d6cc51cdSAndreas Noever * tb_schedule_hotplug_handler() - callback function for the control channel 311d6cc51cdSAndreas Noever * 312d6cc51cdSAndreas Noever * Delegates to tb_handle_hotplug. 313d6cc51cdSAndreas Noever */ 314d6cc51cdSAndreas Noever static void tb_schedule_hotplug_handler(void *data, u64 route, u8 port, 315d6cc51cdSAndreas Noever bool unplug) 316d6cc51cdSAndreas Noever { 317d6cc51cdSAndreas Noever struct tb *tb = data; 318d6cc51cdSAndreas Noever struct tb_hotplug_event *ev = kmalloc(sizeof(*ev), GFP_KERNEL); 319d6cc51cdSAndreas Noever if (!ev) 320d6cc51cdSAndreas Noever return; 321d6cc51cdSAndreas Noever INIT_WORK(&ev->work, tb_handle_hotplug); 322d6cc51cdSAndreas Noever ev->tb = tb; 323d6cc51cdSAndreas Noever ev->route = route; 324d6cc51cdSAndreas Noever ev->port = port; 325d6cc51cdSAndreas Noever ev->unplug = unplug; 326d6cc51cdSAndreas Noever queue_work(tb->wq, &ev->work); 327d6cc51cdSAndreas Noever } 328d6cc51cdSAndreas Noever 3299d3cce0bSMika Westerberg static void tb_stop(struct tb *tb) 330d6cc51cdSAndreas Noever { 3319d3cce0bSMika Westerberg struct tb_cm *tcm = tb_priv(tb); 3323364f0c1SAndreas Noever struct tb_pci_tunnel *tunnel; 3333364f0c1SAndreas Noever struct tb_pci_tunnel *n; 3343364f0c1SAndreas Noever 3353364f0c1SAndreas Noever /* tunnels are only present after everything has been initialized */ 3369d3cce0bSMika Westerberg list_for_each_entry_safe(tunnel, n, &tcm->tunnel_list, list) { 3373364f0c1SAndreas Noever tb_pci_deactivate(tunnel); 3383364f0c1SAndreas Noever tb_pci_free(tunnel); 3393364f0c1SAndreas Noever } 340bfe778acSMika Westerberg tb_switch_remove(tb->root_switch); 3419d3cce0bSMika Westerberg tcm->hotplug_active = false; /* signal tb_handle_hotplug to quit */ 342d6cc51cdSAndreas Noever } 343d6cc51cdSAndreas Noever 3449d3cce0bSMika Westerberg static int tb_start(struct tb *tb) 345d6cc51cdSAndreas Noever { 3469d3cce0bSMika Westerberg struct tb_cm *tcm = tb_priv(tb); 347bfe778acSMika Westerberg int ret; 348d6cc51cdSAndreas Noever 349bfe778acSMika Westerberg tb->root_switch = tb_switch_alloc(tb, &tb->dev, 0); 350a25c8b2fSAndreas Noever if (!tb->root_switch) 3519d3cce0bSMika Westerberg return -ENOMEM; 352a25c8b2fSAndreas Noever 353bfe778acSMika Westerberg ret = tb_switch_configure(tb->root_switch); 354bfe778acSMika Westerberg if (ret) { 355bfe778acSMika Westerberg tb_switch_put(tb->root_switch); 356bfe778acSMika Westerberg return ret; 357bfe778acSMika Westerberg } 358bfe778acSMika Westerberg 359bfe778acSMika Westerberg /* Announce the switch to the world */ 360bfe778acSMika Westerberg ret = tb_switch_add(tb->root_switch); 361bfe778acSMika Westerberg if (ret) { 362bfe778acSMika Westerberg tb_switch_put(tb->root_switch); 363bfe778acSMika Westerberg return ret; 364bfe778acSMika Westerberg } 365bfe778acSMika Westerberg 3669da672a4SAndreas Noever /* Full scan to discover devices added before the driver was loaded. */ 3679da672a4SAndreas Noever tb_scan_switch(tb->root_switch); 3683364f0c1SAndreas Noever tb_activate_pcie_devices(tb); 3699da672a4SAndreas Noever 370d6cc51cdSAndreas Noever /* Allow tb_handle_hotplug to progress events */ 3719d3cce0bSMika Westerberg tcm->hotplug_active = true; 3729d3cce0bSMika Westerberg return 0; 373d6cc51cdSAndreas Noever } 374d6cc51cdSAndreas Noever 3759d3cce0bSMika Westerberg static int tb_suspend_noirq(struct tb *tb) 37623dd5bb4SAndreas Noever { 3779d3cce0bSMika Westerberg struct tb_cm *tcm = tb_priv(tb); 3789d3cce0bSMika Westerberg 37923dd5bb4SAndreas Noever tb_info(tb, "suspending...\n"); 38023dd5bb4SAndreas Noever tb_switch_suspend(tb->root_switch); 3819d3cce0bSMika Westerberg tcm->hotplug_active = false; /* signal tb_handle_hotplug to quit */ 38223dd5bb4SAndreas Noever tb_info(tb, "suspend finished\n"); 3839d3cce0bSMika Westerberg 3849d3cce0bSMika Westerberg return 0; 38523dd5bb4SAndreas Noever } 38623dd5bb4SAndreas Noever 3879d3cce0bSMika Westerberg static int tb_resume_noirq(struct tb *tb) 38823dd5bb4SAndreas Noever { 3899d3cce0bSMika Westerberg struct tb_cm *tcm = tb_priv(tb); 39023dd5bb4SAndreas Noever struct tb_pci_tunnel *tunnel, *n; 3919d3cce0bSMika Westerberg 39223dd5bb4SAndreas Noever tb_info(tb, "resuming...\n"); 39323dd5bb4SAndreas Noever 39423dd5bb4SAndreas Noever /* remove any pci devices the firmware might have setup */ 39523dd5bb4SAndreas Noever tb_switch_reset(tb, 0); 39623dd5bb4SAndreas Noever 39723dd5bb4SAndreas Noever tb_switch_resume(tb->root_switch); 39823dd5bb4SAndreas Noever tb_free_invalid_tunnels(tb); 39923dd5bb4SAndreas Noever tb_free_unplugged_children(tb->root_switch); 4009d3cce0bSMika Westerberg list_for_each_entry_safe(tunnel, n, &tcm->tunnel_list, list) 40123dd5bb4SAndreas Noever tb_pci_restart(tunnel); 4029d3cce0bSMika Westerberg if (!list_empty(&tcm->tunnel_list)) { 40323dd5bb4SAndreas Noever /* 40423dd5bb4SAndreas Noever * the pcie links need some time to get going. 40523dd5bb4SAndreas Noever * 100ms works for me... 40623dd5bb4SAndreas Noever */ 40723dd5bb4SAndreas Noever tb_info(tb, "tunnels restarted, sleeping for 100ms\n"); 40823dd5bb4SAndreas Noever msleep(100); 40923dd5bb4SAndreas Noever } 41023dd5bb4SAndreas Noever /* Allow tb_handle_hotplug to progress events */ 4119d3cce0bSMika Westerberg tcm->hotplug_active = true; 41223dd5bb4SAndreas Noever tb_info(tb, "resume finished\n"); 4139d3cce0bSMika Westerberg 4149d3cce0bSMika Westerberg return 0; 4159d3cce0bSMika Westerberg } 4169d3cce0bSMika Westerberg 4179d3cce0bSMika Westerberg static const struct tb_cm_ops tb_cm_ops = { 4189d3cce0bSMika Westerberg .start = tb_start, 4199d3cce0bSMika Westerberg .stop = tb_stop, 4209d3cce0bSMika Westerberg .suspend_noirq = tb_suspend_noirq, 4219d3cce0bSMika Westerberg .resume_noirq = tb_resume_noirq, 4229d3cce0bSMika Westerberg .hotplug = tb_schedule_hotplug_handler, 4239d3cce0bSMika Westerberg }; 4249d3cce0bSMika Westerberg 4259d3cce0bSMika Westerberg struct tb *tb_probe(struct tb_nhi *nhi) 4269d3cce0bSMika Westerberg { 4279d3cce0bSMika Westerberg struct tb_cm *tcm; 4289d3cce0bSMika Westerberg struct tb *tb; 4299d3cce0bSMika Westerberg 4309d3cce0bSMika Westerberg tb = tb_domain_alloc(nhi, sizeof(*tcm)); 4319d3cce0bSMika Westerberg if (!tb) 4329d3cce0bSMika Westerberg return NULL; 4339d3cce0bSMika Westerberg 4349d3cce0bSMika Westerberg tb->cm_ops = &tb_cm_ops; 4359d3cce0bSMika Westerberg 4369d3cce0bSMika Westerberg tcm = tb_priv(tb); 4379d3cce0bSMika Westerberg INIT_LIST_HEAD(&tcm->tunnel_list); 4389d3cce0bSMika Westerberg 4399d3cce0bSMika Westerberg return tb; 44023dd5bb4SAndreas Noever } 441