1b2441318SGreg Kroah-Hartman // SPDX-License-Identifier: GPL-2.0 2d6cc51cdSAndreas Noever /* 399cabbb0SMika Westerberg * Thunderbolt driver - bus logic (NHI independent) 4d6cc51cdSAndreas Noever * 5d6cc51cdSAndreas Noever * Copyright (c) 2014 Andreas Noever <andreas.noever@gmail.com> 699cabbb0SMika Westerberg * Copyright (C) 2019, Intel Corporation 7d6cc51cdSAndreas Noever */ 8d6cc51cdSAndreas Noever 9d6cc51cdSAndreas Noever #include <linux/slab.h> 10d6cc51cdSAndreas Noever #include <linux/errno.h> 11d6cc51cdSAndreas Noever #include <linux/delay.h> 126ac6faeeSMika Westerberg #include <linux/pm_runtime.h> 13d6cc51cdSAndreas Noever 14d6cc51cdSAndreas Noever #include "tb.h" 157adf6097SAndreas Noever #include "tb_regs.h" 161752b9f7SMika Westerberg #include "tunnel.h" 17d6cc51cdSAndreas Noever 189d3cce0bSMika Westerberg /** 199d3cce0bSMika Westerberg * struct tb_cm - Simple Thunderbolt connection manager 209d3cce0bSMika Westerberg * @tunnel_list: List of active tunnels 218afe909bSMika Westerberg * @dp_resources: List of available DP resources for DP tunneling 229d3cce0bSMika Westerberg * @hotplug_active: tb_handle_hotplug will stop progressing plug 239d3cce0bSMika Westerberg * events and exit if this is not set (it needs to 249d3cce0bSMika Westerberg * acquire the lock one more time). Used to drain wq 259d3cce0bSMika Westerberg * after cfg has been paused. 266ac6faeeSMika Westerberg * @remove_work: Work used to remove any unplugged routers after 276ac6faeeSMika Westerberg * runtime resume 289d3cce0bSMika Westerberg */ 299d3cce0bSMika Westerberg struct tb_cm { 309d3cce0bSMika Westerberg struct list_head tunnel_list; 318afe909bSMika Westerberg struct list_head dp_resources; 329d3cce0bSMika Westerberg bool hotplug_active; 336ac6faeeSMika Westerberg struct delayed_work remove_work; 349d3cce0bSMika Westerberg }; 359da672a4SAndreas Noever 366ac6faeeSMika Westerberg static inline struct tb *tcm_to_tb(struct tb_cm *tcm) 376ac6faeeSMika Westerberg { 386ac6faeeSMika Westerberg return ((void *)tcm - sizeof(struct tb)); 396ac6faeeSMika Westerberg } 406ac6faeeSMika Westerberg 414f807e47SMika Westerberg struct tb_hotplug_event { 424f807e47SMika Westerberg struct work_struct work; 434f807e47SMika Westerberg struct tb *tb; 444f807e47SMika Westerberg u64 route; 454f807e47SMika Westerberg u8 port; 464f807e47SMika Westerberg bool unplug; 474f807e47SMika Westerberg }; 484f807e47SMika Westerberg 494f807e47SMika Westerberg static void tb_handle_hotplug(struct work_struct *work); 504f807e47SMika Westerberg 514f807e47SMika Westerberg static void tb_queue_hotplug(struct tb *tb, u64 route, u8 port, bool unplug) 524f807e47SMika Westerberg { 534f807e47SMika Westerberg struct tb_hotplug_event *ev; 544f807e47SMika Westerberg 554f807e47SMika Westerberg ev = kmalloc(sizeof(*ev), GFP_KERNEL); 564f807e47SMika Westerberg if (!ev) 574f807e47SMika Westerberg return; 584f807e47SMika Westerberg 594f807e47SMika Westerberg ev->tb = tb; 604f807e47SMika Westerberg ev->route = route; 614f807e47SMika Westerberg ev->port = port; 624f807e47SMika Westerberg ev->unplug = unplug; 634f807e47SMika Westerberg INIT_WORK(&ev->work, tb_handle_hotplug); 644f807e47SMika Westerberg queue_work(tb->wq, &ev->work); 654f807e47SMika Westerberg } 664f807e47SMika Westerberg 679da672a4SAndreas Noever /* enumeration & hot plug handling */ 689da672a4SAndreas Noever 698afe909bSMika Westerberg static void tb_add_dp_resources(struct tb_switch *sw) 708afe909bSMika Westerberg { 718afe909bSMika Westerberg struct tb_cm *tcm = tb_priv(sw->tb); 728afe909bSMika Westerberg struct tb_port *port; 738afe909bSMika Westerberg 748afe909bSMika Westerberg tb_switch_for_each_port(sw, port) { 758afe909bSMika Westerberg if (!tb_port_is_dpin(port)) 768afe909bSMika Westerberg continue; 778afe909bSMika Westerberg 788afe909bSMika Westerberg if (!tb_switch_query_dp_resource(sw, port)) 798afe909bSMika Westerberg continue; 808afe909bSMika Westerberg 818afe909bSMika Westerberg list_add_tail(&port->list, &tcm->dp_resources); 828afe909bSMika Westerberg tb_port_dbg(port, "DP IN resource available\n"); 838afe909bSMika Westerberg } 848afe909bSMika Westerberg } 858afe909bSMika Westerberg 868afe909bSMika Westerberg static void tb_remove_dp_resources(struct tb_switch *sw) 878afe909bSMika Westerberg { 888afe909bSMika Westerberg struct tb_cm *tcm = tb_priv(sw->tb); 898afe909bSMika Westerberg struct tb_port *port, *tmp; 908afe909bSMika Westerberg 918afe909bSMika Westerberg /* Clear children resources first */ 928afe909bSMika Westerberg tb_switch_for_each_port(sw, port) { 938afe909bSMika Westerberg if (tb_port_has_remote(port)) 948afe909bSMika Westerberg tb_remove_dp_resources(port->remote->sw); 958afe909bSMika Westerberg } 968afe909bSMika Westerberg 978afe909bSMika Westerberg list_for_each_entry_safe(port, tmp, &tcm->dp_resources, list) { 988afe909bSMika Westerberg if (port->sw == sw) { 998afe909bSMika Westerberg tb_port_dbg(port, "DP OUT resource unavailable\n"); 1008afe909bSMika Westerberg list_del_init(&port->list); 1018afe909bSMika Westerberg } 1028afe909bSMika Westerberg } 1038afe909bSMika Westerberg } 1048afe909bSMika Westerberg 1050414bec5SMika Westerberg static void tb_discover_tunnels(struct tb_switch *sw) 1060414bec5SMika Westerberg { 1070414bec5SMika Westerberg struct tb *tb = sw->tb; 1080414bec5SMika Westerberg struct tb_cm *tcm = tb_priv(tb); 1090414bec5SMika Westerberg struct tb_port *port; 1100414bec5SMika Westerberg 111b433d010SMika Westerberg tb_switch_for_each_port(sw, port) { 1120414bec5SMika Westerberg struct tb_tunnel *tunnel = NULL; 1130414bec5SMika Westerberg 1140414bec5SMika Westerberg switch (port->config.type) { 1154f807e47SMika Westerberg case TB_TYPE_DP_HDMI_IN: 1164f807e47SMika Westerberg tunnel = tb_tunnel_discover_dp(tb, port); 1174f807e47SMika Westerberg break; 1184f807e47SMika Westerberg 1190414bec5SMika Westerberg case TB_TYPE_PCIE_DOWN: 1200414bec5SMika Westerberg tunnel = tb_tunnel_discover_pci(tb, port); 1210414bec5SMika Westerberg break; 1220414bec5SMika Westerberg 123e6f81858SRajmohan Mani case TB_TYPE_USB3_DOWN: 124e6f81858SRajmohan Mani tunnel = tb_tunnel_discover_usb3(tb, port); 125e6f81858SRajmohan Mani break; 126e6f81858SRajmohan Mani 1270414bec5SMika Westerberg default: 1280414bec5SMika Westerberg break; 1290414bec5SMika Westerberg } 1300414bec5SMika Westerberg 1314f807e47SMika Westerberg if (!tunnel) 1324f807e47SMika Westerberg continue; 1334f807e47SMika Westerberg 1344f807e47SMika Westerberg if (tb_tunnel_is_pci(tunnel)) { 1350414bec5SMika Westerberg struct tb_switch *parent = tunnel->dst_port->sw; 1360414bec5SMika Westerberg 1370414bec5SMika Westerberg while (parent != tunnel->src_port->sw) { 1380414bec5SMika Westerberg parent->boot = true; 1390414bec5SMika Westerberg parent = tb_switch_parent(parent); 1400414bec5SMika Westerberg } 1414f807e47SMika Westerberg } 1420414bec5SMika Westerberg 1430414bec5SMika Westerberg list_add_tail(&tunnel->list, &tcm->tunnel_list); 1440414bec5SMika Westerberg } 1450414bec5SMika Westerberg 146b433d010SMika Westerberg tb_switch_for_each_port(sw, port) { 147b433d010SMika Westerberg if (tb_port_has_remote(port)) 148b433d010SMika Westerberg tb_discover_tunnels(port->remote->sw); 1490414bec5SMika Westerberg } 1500414bec5SMika Westerberg } 1519da672a4SAndreas Noever 152284652a4SMika Westerberg static int tb_port_configure_xdomain(struct tb_port *port) 153284652a4SMika Westerberg { 154341d4518SMika Westerberg /* 155341d4518SMika Westerberg * XDomain paths currently only support single lane so we must 156341d4518SMika Westerberg * disable the other lane according to USB4 spec. 157341d4518SMika Westerberg */ 158341d4518SMika Westerberg tb_port_disable(port->dual_link_port); 159341d4518SMika Westerberg 160284652a4SMika Westerberg if (tb_switch_is_usb4(port->sw)) 161284652a4SMika Westerberg return usb4_port_configure_xdomain(port); 162284652a4SMika Westerberg return tb_lc_configure_xdomain(port); 163284652a4SMika Westerberg } 164284652a4SMika Westerberg 165284652a4SMika Westerberg static void tb_port_unconfigure_xdomain(struct tb_port *port) 166284652a4SMika Westerberg { 167284652a4SMika Westerberg if (tb_switch_is_usb4(port->sw)) 168284652a4SMika Westerberg usb4_port_unconfigure_xdomain(port); 169284652a4SMika Westerberg else 170284652a4SMika Westerberg tb_lc_unconfigure_xdomain(port); 171341d4518SMika Westerberg 172341d4518SMika Westerberg tb_port_enable(port->dual_link_port); 173284652a4SMika Westerberg } 174284652a4SMika Westerberg 1757ea4cd6bSMika Westerberg static void tb_scan_xdomain(struct tb_port *port) 1767ea4cd6bSMika Westerberg { 1777ea4cd6bSMika Westerberg struct tb_switch *sw = port->sw; 1787ea4cd6bSMika Westerberg struct tb *tb = sw->tb; 1797ea4cd6bSMika Westerberg struct tb_xdomain *xd; 1807ea4cd6bSMika Westerberg u64 route; 1817ea4cd6bSMika Westerberg 1827ea4cd6bSMika Westerberg route = tb_downstream_route(port); 1837ea4cd6bSMika Westerberg xd = tb_xdomain_find_by_route(tb, route); 1847ea4cd6bSMika Westerberg if (xd) { 1857ea4cd6bSMika Westerberg tb_xdomain_put(xd); 1867ea4cd6bSMika Westerberg return; 1877ea4cd6bSMika Westerberg } 1887ea4cd6bSMika Westerberg 1897ea4cd6bSMika Westerberg xd = tb_xdomain_alloc(tb, &sw->dev, route, tb->root_switch->uuid, 1907ea4cd6bSMika Westerberg NULL); 1917ea4cd6bSMika Westerberg if (xd) { 1927ea4cd6bSMika Westerberg tb_port_at(route, sw)->xdomain = xd; 193284652a4SMika Westerberg tb_port_configure_xdomain(port); 1947ea4cd6bSMika Westerberg tb_xdomain_add(xd); 1957ea4cd6bSMika Westerberg } 1967ea4cd6bSMika Westerberg } 1977ea4cd6bSMika Westerberg 198cf29b9afSRajmohan Mani static int tb_enable_tmu(struct tb_switch *sw) 199cf29b9afSRajmohan Mani { 200cf29b9afSRajmohan Mani int ret; 201cf29b9afSRajmohan Mani 202cf29b9afSRajmohan Mani /* If it is already enabled in correct mode, don't touch it */ 203cf29b9afSRajmohan Mani if (tb_switch_tmu_is_enabled(sw)) 204cf29b9afSRajmohan Mani return 0; 205cf29b9afSRajmohan Mani 206cf29b9afSRajmohan Mani ret = tb_switch_tmu_disable(sw); 207cf29b9afSRajmohan Mani if (ret) 208cf29b9afSRajmohan Mani return ret; 209cf29b9afSRajmohan Mani 210cf29b9afSRajmohan Mani ret = tb_switch_tmu_post_time(sw); 211cf29b9afSRajmohan Mani if (ret) 212cf29b9afSRajmohan Mani return ret; 213cf29b9afSRajmohan Mani 214cf29b9afSRajmohan Mani return tb_switch_tmu_enable(sw); 215cf29b9afSRajmohan Mani } 216cf29b9afSRajmohan Mani 217e6f81858SRajmohan Mani /** 218e6f81858SRajmohan Mani * tb_find_unused_port() - return the first inactive port on @sw 219e6f81858SRajmohan Mani * @sw: Switch to find the port on 220e6f81858SRajmohan Mani * @type: Port type to look for 221e6f81858SRajmohan Mani */ 222e6f81858SRajmohan Mani static struct tb_port *tb_find_unused_port(struct tb_switch *sw, 223e6f81858SRajmohan Mani enum tb_port_type type) 224e6f81858SRajmohan Mani { 225e6f81858SRajmohan Mani struct tb_port *port; 226e6f81858SRajmohan Mani 227e6f81858SRajmohan Mani tb_switch_for_each_port(sw, port) { 228e6f81858SRajmohan Mani if (tb_is_upstream_port(port)) 229e6f81858SRajmohan Mani continue; 230e6f81858SRajmohan Mani if (port->config.type != type) 231e6f81858SRajmohan Mani continue; 232e6f81858SRajmohan Mani if (!port->cap_adap) 233e6f81858SRajmohan Mani continue; 234e6f81858SRajmohan Mani if (tb_port_is_enabled(port)) 235e6f81858SRajmohan Mani continue; 236e6f81858SRajmohan Mani return port; 237e6f81858SRajmohan Mani } 238e6f81858SRajmohan Mani return NULL; 239e6f81858SRajmohan Mani } 240e6f81858SRajmohan Mani 241e6f81858SRajmohan Mani static struct tb_port *tb_find_usb3_down(struct tb_switch *sw, 242e6f81858SRajmohan Mani const struct tb_port *port) 243e6f81858SRajmohan Mani { 244e6f81858SRajmohan Mani struct tb_port *down; 245e6f81858SRajmohan Mani 246e6f81858SRajmohan Mani down = usb4_switch_map_usb3_down(sw, port); 24777cfa40fSMika Westerberg if (down && !tb_usb3_port_is_enabled(down)) 248e6f81858SRajmohan Mani return down; 24977cfa40fSMika Westerberg return NULL; 250e6f81858SRajmohan Mani } 251e6f81858SRajmohan Mani 2520bd680cdSMika Westerberg static struct tb_tunnel *tb_find_tunnel(struct tb *tb, enum tb_tunnel_type type, 2530bd680cdSMika Westerberg struct tb_port *src_port, 2540bd680cdSMika Westerberg struct tb_port *dst_port) 2550bd680cdSMika Westerberg { 2560bd680cdSMika Westerberg struct tb_cm *tcm = tb_priv(tb); 2570bd680cdSMika Westerberg struct tb_tunnel *tunnel; 2580bd680cdSMika Westerberg 2590bd680cdSMika Westerberg list_for_each_entry(tunnel, &tcm->tunnel_list, list) { 2600bd680cdSMika Westerberg if (tunnel->type == type && 2610bd680cdSMika Westerberg ((src_port && src_port == tunnel->src_port) || 2620bd680cdSMika Westerberg (dst_port && dst_port == tunnel->dst_port))) { 2630bd680cdSMika Westerberg return tunnel; 2640bd680cdSMika Westerberg } 2650bd680cdSMika Westerberg } 2660bd680cdSMika Westerberg 2670bd680cdSMika Westerberg return NULL; 2680bd680cdSMika Westerberg } 2690bd680cdSMika Westerberg 2700bd680cdSMika Westerberg static struct tb_tunnel *tb_find_first_usb3_tunnel(struct tb *tb, 2710bd680cdSMika Westerberg struct tb_port *src_port, 2720bd680cdSMika Westerberg struct tb_port *dst_port) 2730bd680cdSMika Westerberg { 2740bd680cdSMika Westerberg struct tb_port *port, *usb3_down; 2750bd680cdSMika Westerberg struct tb_switch *sw; 2760bd680cdSMika Westerberg 2770bd680cdSMika Westerberg /* Pick the router that is deepest in the topology */ 2780bd680cdSMika Westerberg if (dst_port->sw->config.depth > src_port->sw->config.depth) 2790bd680cdSMika Westerberg sw = dst_port->sw; 2800bd680cdSMika Westerberg else 2810bd680cdSMika Westerberg sw = src_port->sw; 2820bd680cdSMika Westerberg 2830bd680cdSMika Westerberg /* Can't be the host router */ 2840bd680cdSMika Westerberg if (sw == tb->root_switch) 2850bd680cdSMika Westerberg return NULL; 2860bd680cdSMika Westerberg 2870bd680cdSMika Westerberg /* Find the downstream USB4 port that leads to this router */ 2880bd680cdSMika Westerberg port = tb_port_at(tb_route(sw), tb->root_switch); 2890bd680cdSMika Westerberg /* Find the corresponding host router USB3 downstream port */ 2900bd680cdSMika Westerberg usb3_down = usb4_switch_map_usb3_down(tb->root_switch, port); 2910bd680cdSMika Westerberg if (!usb3_down) 2920bd680cdSMika Westerberg return NULL; 2930bd680cdSMika Westerberg 2940bd680cdSMika Westerberg return tb_find_tunnel(tb, TB_TUNNEL_USB3, usb3_down, NULL); 2950bd680cdSMika Westerberg } 2960bd680cdSMika Westerberg 2970bd680cdSMika Westerberg static int tb_available_bandwidth(struct tb *tb, struct tb_port *src_port, 2980bd680cdSMika Westerberg struct tb_port *dst_port, int *available_up, int *available_down) 2990bd680cdSMika Westerberg { 3000bd680cdSMika Westerberg int usb3_consumed_up, usb3_consumed_down, ret; 3010bd680cdSMika Westerberg struct tb_cm *tcm = tb_priv(tb); 3020bd680cdSMika Westerberg struct tb_tunnel *tunnel; 3030bd680cdSMika Westerberg struct tb_port *port; 3040bd680cdSMika Westerberg 3050bd680cdSMika Westerberg tb_port_dbg(dst_port, "calculating available bandwidth\n"); 3060bd680cdSMika Westerberg 3070bd680cdSMika Westerberg tunnel = tb_find_first_usb3_tunnel(tb, src_port, dst_port); 3080bd680cdSMika Westerberg if (tunnel) { 3090bd680cdSMika Westerberg ret = tb_tunnel_consumed_bandwidth(tunnel, &usb3_consumed_up, 3100bd680cdSMika Westerberg &usb3_consumed_down); 3110bd680cdSMika Westerberg if (ret) 3120bd680cdSMika Westerberg return ret; 3130bd680cdSMika Westerberg } else { 3140bd680cdSMika Westerberg usb3_consumed_up = 0; 3150bd680cdSMika Westerberg usb3_consumed_down = 0; 3160bd680cdSMika Westerberg } 3170bd680cdSMika Westerberg 3180bd680cdSMika Westerberg *available_up = *available_down = 40000; 3190bd680cdSMika Westerberg 3200bd680cdSMika Westerberg /* Find the minimum available bandwidth over all links */ 3210bd680cdSMika Westerberg tb_for_each_port_on_path(src_port, dst_port, port) { 3220bd680cdSMika Westerberg int link_speed, link_width, up_bw, down_bw; 3230bd680cdSMika Westerberg 3240bd680cdSMika Westerberg if (!tb_port_is_null(port)) 3250bd680cdSMika Westerberg continue; 3260bd680cdSMika Westerberg 3270bd680cdSMika Westerberg if (tb_is_upstream_port(port)) { 3280bd680cdSMika Westerberg link_speed = port->sw->link_speed; 3290bd680cdSMika Westerberg } else { 3300bd680cdSMika Westerberg link_speed = tb_port_get_link_speed(port); 3310bd680cdSMika Westerberg if (link_speed < 0) 3320bd680cdSMika Westerberg return link_speed; 3330bd680cdSMika Westerberg } 3340bd680cdSMika Westerberg 3350bd680cdSMika Westerberg link_width = port->bonded ? 2 : 1; 3360bd680cdSMika Westerberg 3370bd680cdSMika Westerberg up_bw = link_speed * link_width * 1000; /* Mb/s */ 3380bd680cdSMika Westerberg /* Leave 10% guard band */ 3390bd680cdSMika Westerberg up_bw -= up_bw / 10; 3400bd680cdSMika Westerberg down_bw = up_bw; 3410bd680cdSMika Westerberg 3420bd680cdSMika Westerberg tb_port_dbg(port, "link total bandwidth %d Mb/s\n", up_bw); 3430bd680cdSMika Westerberg 3440bd680cdSMika Westerberg /* 3450bd680cdSMika Westerberg * Find all DP tunnels that cross the port and reduce 3460bd680cdSMika Westerberg * their consumed bandwidth from the available. 3470bd680cdSMika Westerberg */ 3480bd680cdSMika Westerberg list_for_each_entry(tunnel, &tcm->tunnel_list, list) { 3490bd680cdSMika Westerberg int dp_consumed_up, dp_consumed_down; 3500bd680cdSMika Westerberg 3510bd680cdSMika Westerberg if (!tb_tunnel_is_dp(tunnel)) 3520bd680cdSMika Westerberg continue; 3530bd680cdSMika Westerberg 3540bd680cdSMika Westerberg if (!tb_tunnel_port_on_path(tunnel, port)) 3550bd680cdSMika Westerberg continue; 3560bd680cdSMika Westerberg 3570bd680cdSMika Westerberg ret = tb_tunnel_consumed_bandwidth(tunnel, 3580bd680cdSMika Westerberg &dp_consumed_up, 3590bd680cdSMika Westerberg &dp_consumed_down); 3600bd680cdSMika Westerberg if (ret) 3610bd680cdSMika Westerberg return ret; 3620bd680cdSMika Westerberg 3630bd680cdSMika Westerberg up_bw -= dp_consumed_up; 3640bd680cdSMika Westerberg down_bw -= dp_consumed_down; 3650bd680cdSMika Westerberg } 3660bd680cdSMika Westerberg 3670bd680cdSMika Westerberg /* 3680bd680cdSMika Westerberg * If USB3 is tunneled from the host router down to the 3690bd680cdSMika Westerberg * branch leading to port we need to take USB3 consumed 3700bd680cdSMika Westerberg * bandwidth into account regardless whether it actually 3710bd680cdSMika Westerberg * crosses the port. 3720bd680cdSMika Westerberg */ 3730bd680cdSMika Westerberg up_bw -= usb3_consumed_up; 3740bd680cdSMika Westerberg down_bw -= usb3_consumed_down; 3750bd680cdSMika Westerberg 3760bd680cdSMika Westerberg if (up_bw < *available_up) 3770bd680cdSMika Westerberg *available_up = up_bw; 3780bd680cdSMika Westerberg if (down_bw < *available_down) 3790bd680cdSMika Westerberg *available_down = down_bw; 3800bd680cdSMika Westerberg } 3810bd680cdSMika Westerberg 3820bd680cdSMika Westerberg if (*available_up < 0) 3830bd680cdSMika Westerberg *available_up = 0; 3840bd680cdSMika Westerberg if (*available_down < 0) 3850bd680cdSMika Westerberg *available_down = 0; 3860bd680cdSMika Westerberg 3870bd680cdSMika Westerberg return 0; 3880bd680cdSMika Westerberg } 3890bd680cdSMika Westerberg 3900bd680cdSMika Westerberg static int tb_release_unused_usb3_bandwidth(struct tb *tb, 3910bd680cdSMika Westerberg struct tb_port *src_port, 3920bd680cdSMika Westerberg struct tb_port *dst_port) 3930bd680cdSMika Westerberg { 3940bd680cdSMika Westerberg struct tb_tunnel *tunnel; 3950bd680cdSMika Westerberg 3960bd680cdSMika Westerberg tunnel = tb_find_first_usb3_tunnel(tb, src_port, dst_port); 3970bd680cdSMika Westerberg return tunnel ? tb_tunnel_release_unused_bandwidth(tunnel) : 0; 3980bd680cdSMika Westerberg } 3990bd680cdSMika Westerberg 4000bd680cdSMika Westerberg static void tb_reclaim_usb3_bandwidth(struct tb *tb, struct tb_port *src_port, 4010bd680cdSMika Westerberg struct tb_port *dst_port) 4020bd680cdSMika Westerberg { 4030bd680cdSMika Westerberg int ret, available_up, available_down; 4040bd680cdSMika Westerberg struct tb_tunnel *tunnel; 4050bd680cdSMika Westerberg 4060bd680cdSMika Westerberg tunnel = tb_find_first_usb3_tunnel(tb, src_port, dst_port); 4070bd680cdSMika Westerberg if (!tunnel) 4080bd680cdSMika Westerberg return; 4090bd680cdSMika Westerberg 4100bd680cdSMika Westerberg tb_dbg(tb, "reclaiming unused bandwidth for USB3\n"); 4110bd680cdSMika Westerberg 4120bd680cdSMika Westerberg /* 4130bd680cdSMika Westerberg * Calculate available bandwidth for the first hop USB3 tunnel. 4140bd680cdSMika Westerberg * That determines the whole USB3 bandwidth for this branch. 4150bd680cdSMika Westerberg */ 4160bd680cdSMika Westerberg ret = tb_available_bandwidth(tb, tunnel->src_port, tunnel->dst_port, 4170bd680cdSMika Westerberg &available_up, &available_down); 4180bd680cdSMika Westerberg if (ret) { 4190bd680cdSMika Westerberg tb_warn(tb, "failed to calculate available bandwidth\n"); 4200bd680cdSMika Westerberg return; 4210bd680cdSMika Westerberg } 4220bd680cdSMika Westerberg 4230bd680cdSMika Westerberg tb_dbg(tb, "available bandwidth for USB3 %d/%d Mb/s\n", 4240bd680cdSMika Westerberg available_up, available_down); 4250bd680cdSMika Westerberg 4260bd680cdSMika Westerberg tb_tunnel_reclaim_available_bandwidth(tunnel, &available_up, &available_down); 4270bd680cdSMika Westerberg } 4280bd680cdSMika Westerberg 429e6f81858SRajmohan Mani static int tb_tunnel_usb3(struct tb *tb, struct tb_switch *sw) 430e6f81858SRajmohan Mani { 431e6f81858SRajmohan Mani struct tb_switch *parent = tb_switch_parent(sw); 4320bd680cdSMika Westerberg int ret, available_up, available_down; 433e6f81858SRajmohan Mani struct tb_port *up, *down, *port; 434e6f81858SRajmohan Mani struct tb_cm *tcm = tb_priv(tb); 435e6f81858SRajmohan Mani struct tb_tunnel *tunnel; 436e6f81858SRajmohan Mani 437e6f81858SRajmohan Mani up = tb_switch_find_port(sw, TB_TYPE_USB3_UP); 438e6f81858SRajmohan Mani if (!up) 439e6f81858SRajmohan Mani return 0; 440e6f81858SRajmohan Mani 441bbcf40b3SMika Westerberg if (!sw->link_usb4) 442bbcf40b3SMika Westerberg return 0; 443bbcf40b3SMika Westerberg 444e6f81858SRajmohan Mani /* 445e6f81858SRajmohan Mani * Look up available down port. Since we are chaining it should 446e6f81858SRajmohan Mani * be found right above this switch. 447e6f81858SRajmohan Mani */ 448e6f81858SRajmohan Mani port = tb_port_at(tb_route(sw), parent); 449e6f81858SRajmohan Mani down = tb_find_usb3_down(parent, port); 450e6f81858SRajmohan Mani if (!down) 451e6f81858SRajmohan Mani return 0; 452e6f81858SRajmohan Mani 453e6f81858SRajmohan Mani if (tb_route(parent)) { 454e6f81858SRajmohan Mani struct tb_port *parent_up; 455e6f81858SRajmohan Mani /* 456e6f81858SRajmohan Mani * Check first that the parent switch has its upstream USB3 457e6f81858SRajmohan Mani * port enabled. Otherwise the chain is not complete and 458e6f81858SRajmohan Mani * there is no point setting up a new tunnel. 459e6f81858SRajmohan Mani */ 460e6f81858SRajmohan Mani parent_up = tb_switch_find_port(parent, TB_TYPE_USB3_UP); 461e6f81858SRajmohan Mani if (!parent_up || !tb_port_is_enabled(parent_up)) 462e6f81858SRajmohan Mani return 0; 4630bd680cdSMika Westerberg 4640bd680cdSMika Westerberg /* Make all unused bandwidth available for the new tunnel */ 4650bd680cdSMika Westerberg ret = tb_release_unused_usb3_bandwidth(tb, down, up); 4660bd680cdSMika Westerberg if (ret) 4670bd680cdSMika Westerberg return ret; 468e6f81858SRajmohan Mani } 469e6f81858SRajmohan Mani 4700bd680cdSMika Westerberg ret = tb_available_bandwidth(tb, down, up, &available_up, 4710bd680cdSMika Westerberg &available_down); 4720bd680cdSMika Westerberg if (ret) 4730bd680cdSMika Westerberg goto err_reclaim; 4740bd680cdSMika Westerberg 4750bd680cdSMika Westerberg tb_port_dbg(up, "available bandwidth for new USB3 tunnel %d/%d Mb/s\n", 4760bd680cdSMika Westerberg available_up, available_down); 4770bd680cdSMika Westerberg 4780bd680cdSMika Westerberg tunnel = tb_tunnel_alloc_usb3(tb, up, down, available_up, 4790bd680cdSMika Westerberg available_down); 4800bd680cdSMika Westerberg if (!tunnel) { 4810bd680cdSMika Westerberg ret = -ENOMEM; 4820bd680cdSMika Westerberg goto err_reclaim; 4830bd680cdSMika Westerberg } 484e6f81858SRajmohan Mani 485e6f81858SRajmohan Mani if (tb_tunnel_activate(tunnel)) { 486e6f81858SRajmohan Mani tb_port_info(up, 487e6f81858SRajmohan Mani "USB3 tunnel activation failed, aborting\n"); 4880bd680cdSMika Westerberg ret = -EIO; 4890bd680cdSMika Westerberg goto err_free; 490e6f81858SRajmohan Mani } 491e6f81858SRajmohan Mani 492e6f81858SRajmohan Mani list_add_tail(&tunnel->list, &tcm->tunnel_list); 4930bd680cdSMika Westerberg if (tb_route(parent)) 4940bd680cdSMika Westerberg tb_reclaim_usb3_bandwidth(tb, down, up); 4950bd680cdSMika Westerberg 496e6f81858SRajmohan Mani return 0; 4970bd680cdSMika Westerberg 4980bd680cdSMika Westerberg err_free: 4990bd680cdSMika Westerberg tb_tunnel_free(tunnel); 5000bd680cdSMika Westerberg err_reclaim: 5010bd680cdSMika Westerberg if (tb_route(parent)) 5020bd680cdSMika Westerberg tb_reclaim_usb3_bandwidth(tb, down, up); 5030bd680cdSMika Westerberg 5040bd680cdSMika Westerberg return ret; 505e6f81858SRajmohan Mani } 506e6f81858SRajmohan Mani 507e6f81858SRajmohan Mani static int tb_create_usb3_tunnels(struct tb_switch *sw) 508e6f81858SRajmohan Mani { 509e6f81858SRajmohan Mani struct tb_port *port; 510e6f81858SRajmohan Mani int ret; 511e6f81858SRajmohan Mani 512e6f81858SRajmohan Mani if (tb_route(sw)) { 513e6f81858SRajmohan Mani ret = tb_tunnel_usb3(sw->tb, sw); 514e6f81858SRajmohan Mani if (ret) 515e6f81858SRajmohan Mani return ret; 516e6f81858SRajmohan Mani } 517e6f81858SRajmohan Mani 518e6f81858SRajmohan Mani tb_switch_for_each_port(sw, port) { 519e6f81858SRajmohan Mani if (!tb_port_has_remote(port)) 520e6f81858SRajmohan Mani continue; 521e6f81858SRajmohan Mani ret = tb_create_usb3_tunnels(port->remote->sw); 522e6f81858SRajmohan Mani if (ret) 523e6f81858SRajmohan Mani return ret; 524e6f81858SRajmohan Mani } 525e6f81858SRajmohan Mani 526e6f81858SRajmohan Mani return 0; 527e6f81858SRajmohan Mani } 528e6f81858SRajmohan Mani 5299da672a4SAndreas Noever static void tb_scan_port(struct tb_port *port); 5309da672a4SAndreas Noever 5319da672a4SAndreas Noever /** 5329da672a4SAndreas Noever * tb_scan_switch() - scan for and initialize downstream switches 5339da672a4SAndreas Noever */ 5349da672a4SAndreas Noever static void tb_scan_switch(struct tb_switch *sw) 5359da672a4SAndreas Noever { 536b433d010SMika Westerberg struct tb_port *port; 537b433d010SMika Westerberg 5386ac6faeeSMika Westerberg pm_runtime_get_sync(&sw->dev); 5396ac6faeeSMika Westerberg 540b433d010SMika Westerberg tb_switch_for_each_port(sw, port) 541b433d010SMika Westerberg tb_scan_port(port); 5426ac6faeeSMika Westerberg 5436ac6faeeSMika Westerberg pm_runtime_mark_last_busy(&sw->dev); 5446ac6faeeSMika Westerberg pm_runtime_put_autosuspend(&sw->dev); 5459da672a4SAndreas Noever } 5469da672a4SAndreas Noever 5479da672a4SAndreas Noever /** 5489da672a4SAndreas Noever * tb_scan_port() - check for and initialize switches below port 5499da672a4SAndreas Noever */ 5509da672a4SAndreas Noever static void tb_scan_port(struct tb_port *port) 5519da672a4SAndreas Noever { 55299cabbb0SMika Westerberg struct tb_cm *tcm = tb_priv(port->sw->tb); 553dfe40ca4SMika Westerberg struct tb_port *upstream_port; 5549da672a4SAndreas Noever struct tb_switch *sw; 555dfe40ca4SMika Westerberg 5569da672a4SAndreas Noever if (tb_is_upstream_port(port)) 5579da672a4SAndreas Noever return; 5584f807e47SMika Westerberg 5594f807e47SMika Westerberg if (tb_port_is_dpout(port) && tb_dp_port_hpd_is_active(port) == 1 && 5604f807e47SMika Westerberg !tb_dp_port_is_enabled(port)) { 5614f807e47SMika Westerberg tb_port_dbg(port, "DP adapter HPD set, queuing hotplug\n"); 5624f807e47SMika Westerberg tb_queue_hotplug(port->sw->tb, tb_route(port->sw), port->port, 5634f807e47SMika Westerberg false); 5644f807e47SMika Westerberg return; 5654f807e47SMika Westerberg } 5664f807e47SMika Westerberg 5679da672a4SAndreas Noever if (port->config.type != TB_TYPE_PORT) 5689da672a4SAndreas Noever return; 569343fcb8cSAndreas Noever if (port->dual_link_port && port->link_nr) 570343fcb8cSAndreas Noever return; /* 571343fcb8cSAndreas Noever * Downstream switch is reachable through two ports. 572343fcb8cSAndreas Noever * Only scan on the primary port (link_nr == 0). 573343fcb8cSAndreas Noever */ 5749da672a4SAndreas Noever if (tb_wait_for_port(port, false) <= 0) 5759da672a4SAndreas Noever return; 5769da672a4SAndreas Noever if (port->remote) { 5777ea4cd6bSMika Westerberg tb_port_dbg(port, "port already has a remote\n"); 5789da672a4SAndreas Noever return; 5799da672a4SAndreas Noever } 580dacb1287SKranthi Kuntala 581dacb1287SKranthi Kuntala tb_retimer_scan(port); 582dacb1287SKranthi Kuntala 583bfe778acSMika Westerberg sw = tb_switch_alloc(port->sw->tb, &port->sw->dev, 584bfe778acSMika Westerberg tb_downstream_route(port)); 5857ea4cd6bSMika Westerberg if (IS_ERR(sw)) { 5867ea4cd6bSMika Westerberg /* 5877ea4cd6bSMika Westerberg * If there is an error accessing the connected switch 5887ea4cd6bSMika Westerberg * it may be connected to another domain. Also we allow 5897ea4cd6bSMika Westerberg * the other domain to be connected to a max depth switch. 5907ea4cd6bSMika Westerberg */ 5917ea4cd6bSMika Westerberg if (PTR_ERR(sw) == -EIO || PTR_ERR(sw) == -EADDRNOTAVAIL) 5927ea4cd6bSMika Westerberg tb_scan_xdomain(port); 5939da672a4SAndreas Noever return; 5947ea4cd6bSMika Westerberg } 595bfe778acSMika Westerberg 596bfe778acSMika Westerberg if (tb_switch_configure(sw)) { 597bfe778acSMika Westerberg tb_switch_put(sw); 598bfe778acSMika Westerberg return; 599bfe778acSMika Westerberg } 600bfe778acSMika Westerberg 60199cabbb0SMika Westerberg /* 6027ea4cd6bSMika Westerberg * If there was previously another domain connected remove it 6037ea4cd6bSMika Westerberg * first. 6047ea4cd6bSMika Westerberg */ 6057ea4cd6bSMika Westerberg if (port->xdomain) { 6067ea4cd6bSMika Westerberg tb_xdomain_remove(port->xdomain); 607284652a4SMika Westerberg tb_port_unconfigure_xdomain(port); 6087ea4cd6bSMika Westerberg port->xdomain = NULL; 6097ea4cd6bSMika Westerberg } 6107ea4cd6bSMika Westerberg 6117ea4cd6bSMika Westerberg /* 61299cabbb0SMika Westerberg * Do not send uevents until we have discovered all existing 61399cabbb0SMika Westerberg * tunnels and know which switches were authorized already by 61499cabbb0SMika Westerberg * the boot firmware. 61599cabbb0SMika Westerberg */ 61699cabbb0SMika Westerberg if (!tcm->hotplug_active) 61799cabbb0SMika Westerberg dev_set_uevent_suppress(&sw->dev, true); 618f67cf491SMika Westerberg 6196ac6faeeSMika Westerberg /* 6206ac6faeeSMika Westerberg * At the moment Thunderbolt 2 and beyond (devices with LC) we 6216ac6faeeSMika Westerberg * can support runtime PM. 6226ac6faeeSMika Westerberg */ 6236ac6faeeSMika Westerberg sw->rpm = sw->generation > 1; 6246ac6faeeSMika Westerberg 625bfe778acSMika Westerberg if (tb_switch_add(sw)) { 626bfe778acSMika Westerberg tb_switch_put(sw); 627bfe778acSMika Westerberg return; 628bfe778acSMika Westerberg } 629bfe778acSMika Westerberg 630dfe40ca4SMika Westerberg /* Link the switches using both links if available */ 631dfe40ca4SMika Westerberg upstream_port = tb_upstream_port(sw); 632dfe40ca4SMika Westerberg port->remote = upstream_port; 633dfe40ca4SMika Westerberg upstream_port->remote = port; 634dfe40ca4SMika Westerberg if (port->dual_link_port && upstream_port->dual_link_port) { 635dfe40ca4SMika Westerberg port->dual_link_port->remote = upstream_port->dual_link_port; 636dfe40ca4SMika Westerberg upstream_port->dual_link_port->remote = port->dual_link_port; 637dfe40ca4SMika Westerberg } 638dfe40ca4SMika Westerberg 63991c0c120SMika Westerberg /* Enable lane bonding if supported */ 6402ca3263aSMika Westerberg tb_switch_lane_bonding_enable(sw); 641de462039SMika Westerberg /* Set the link configured */ 642de462039SMika Westerberg tb_switch_configure_link(sw); 64391c0c120SMika Westerberg 644cf29b9afSRajmohan Mani if (tb_enable_tmu(sw)) 645cf29b9afSRajmohan Mani tb_sw_warn(sw, "failed to enable TMU\n"); 646cf29b9afSRajmohan Mani 647dacb1287SKranthi Kuntala /* Scan upstream retimers */ 648dacb1287SKranthi Kuntala tb_retimer_scan(upstream_port); 649dacb1287SKranthi Kuntala 650e6f81858SRajmohan Mani /* 651e6f81858SRajmohan Mani * Create USB 3.x tunnels only when the switch is plugged to the 652e6f81858SRajmohan Mani * domain. This is because we scan the domain also during discovery 653e6f81858SRajmohan Mani * and want to discover existing USB 3.x tunnels before we create 654e6f81858SRajmohan Mani * any new. 655e6f81858SRajmohan Mani */ 656e6f81858SRajmohan Mani if (tcm->hotplug_active && tb_tunnel_usb3(sw->tb, sw)) 657e6f81858SRajmohan Mani tb_sw_warn(sw, "USB3 tunnel creation failed\n"); 658e6f81858SRajmohan Mani 659e876f34aSMika Westerberg tb_add_dp_resources(sw); 6609da672a4SAndreas Noever tb_scan_switch(sw); 6619da672a4SAndreas Noever } 6629da672a4SAndreas Noever 6638afe909bSMika Westerberg static void tb_deactivate_and_free_tunnel(struct tb_tunnel *tunnel) 6648afe909bSMika Westerberg { 6650bd680cdSMika Westerberg struct tb_port *src_port, *dst_port; 6660bd680cdSMika Westerberg struct tb *tb; 6670bd680cdSMika Westerberg 6688afe909bSMika Westerberg if (!tunnel) 6698afe909bSMika Westerberg return; 6708afe909bSMika Westerberg 6718afe909bSMika Westerberg tb_tunnel_deactivate(tunnel); 6728afe909bSMika Westerberg list_del(&tunnel->list); 6738afe909bSMika Westerberg 6740bd680cdSMika Westerberg tb = tunnel->tb; 6750bd680cdSMika Westerberg src_port = tunnel->src_port; 6760bd680cdSMika Westerberg dst_port = tunnel->dst_port; 6778afe909bSMika Westerberg 6780bd680cdSMika Westerberg switch (tunnel->type) { 6790bd680cdSMika Westerberg case TB_TUNNEL_DP: 6800bd680cdSMika Westerberg /* 6810bd680cdSMika Westerberg * In case of DP tunnel make sure the DP IN resource is 6820bd680cdSMika Westerberg * deallocated properly. 6830bd680cdSMika Westerberg */ 6840bd680cdSMika Westerberg tb_switch_dealloc_dp_resource(src_port->sw, src_port); 6856ac6faeeSMika Westerberg /* Now we can allow the domain to runtime suspend again */ 6866ac6faeeSMika Westerberg pm_runtime_mark_last_busy(&dst_port->sw->dev); 6876ac6faeeSMika Westerberg pm_runtime_put_autosuspend(&dst_port->sw->dev); 6886ac6faeeSMika Westerberg pm_runtime_mark_last_busy(&src_port->sw->dev); 6896ac6faeeSMika Westerberg pm_runtime_put_autosuspend(&src_port->sw->dev); 6900bd680cdSMika Westerberg fallthrough; 6910bd680cdSMika Westerberg 6920bd680cdSMika Westerberg case TB_TUNNEL_USB3: 6930bd680cdSMika Westerberg tb_reclaim_usb3_bandwidth(tb, src_port, dst_port); 6940bd680cdSMika Westerberg break; 6950bd680cdSMika Westerberg 6960bd680cdSMika Westerberg default: 6970bd680cdSMika Westerberg /* 6980bd680cdSMika Westerberg * PCIe and DMA tunnels do not consume guaranteed 6990bd680cdSMika Westerberg * bandwidth. 7000bd680cdSMika Westerberg */ 7010bd680cdSMika Westerberg break; 7028afe909bSMika Westerberg } 7038afe909bSMika Westerberg 7048afe909bSMika Westerberg tb_tunnel_free(tunnel); 7054f807e47SMika Westerberg } 7064f807e47SMika Westerberg 7073364f0c1SAndreas Noever /** 7083364f0c1SAndreas Noever * tb_free_invalid_tunnels() - destroy tunnels of devices that have gone away 7093364f0c1SAndreas Noever */ 7103364f0c1SAndreas Noever static void tb_free_invalid_tunnels(struct tb *tb) 7113364f0c1SAndreas Noever { 7129d3cce0bSMika Westerberg struct tb_cm *tcm = tb_priv(tb); 71393f36adeSMika Westerberg struct tb_tunnel *tunnel; 71493f36adeSMika Westerberg struct tb_tunnel *n; 7159d3cce0bSMika Westerberg 7169d3cce0bSMika Westerberg list_for_each_entry_safe(tunnel, n, &tcm->tunnel_list, list) { 7178afe909bSMika Westerberg if (tb_tunnel_is_invalid(tunnel)) 7188afe909bSMika Westerberg tb_deactivate_and_free_tunnel(tunnel); 7193364f0c1SAndreas Noever } 7203364f0c1SAndreas Noever } 7213364f0c1SAndreas Noever 7223364f0c1SAndreas Noever /** 72323dd5bb4SAndreas Noever * tb_free_unplugged_children() - traverse hierarchy and free unplugged switches 72423dd5bb4SAndreas Noever */ 72523dd5bb4SAndreas Noever static void tb_free_unplugged_children(struct tb_switch *sw) 72623dd5bb4SAndreas Noever { 727b433d010SMika Westerberg struct tb_port *port; 728dfe40ca4SMika Westerberg 729b433d010SMika Westerberg tb_switch_for_each_port(sw, port) { 730dfe40ca4SMika Westerberg if (!tb_port_has_remote(port)) 73123dd5bb4SAndreas Noever continue; 732dfe40ca4SMika Westerberg 73323dd5bb4SAndreas Noever if (port->remote->sw->is_unplugged) { 734dacb1287SKranthi Kuntala tb_retimer_remove_all(port); 7358afe909bSMika Westerberg tb_remove_dp_resources(port->remote->sw); 736de462039SMika Westerberg tb_switch_unconfigure_link(port->remote->sw); 73791c0c120SMika Westerberg tb_switch_lane_bonding_disable(port->remote->sw); 738bfe778acSMika Westerberg tb_switch_remove(port->remote->sw); 73923dd5bb4SAndreas Noever port->remote = NULL; 740dfe40ca4SMika Westerberg if (port->dual_link_port) 741dfe40ca4SMika Westerberg port->dual_link_port->remote = NULL; 74223dd5bb4SAndreas Noever } else { 74323dd5bb4SAndreas Noever tb_free_unplugged_children(port->remote->sw); 74423dd5bb4SAndreas Noever } 74523dd5bb4SAndreas Noever } 74623dd5bb4SAndreas Noever } 74723dd5bb4SAndreas Noever 74899cabbb0SMika Westerberg static struct tb_port *tb_find_pcie_down(struct tb_switch *sw, 74999cabbb0SMika Westerberg const struct tb_port *port) 7503364f0c1SAndreas Noever { 751b0407983SMika Westerberg struct tb_port *down = NULL; 752b0407983SMika Westerberg 75399cabbb0SMika Westerberg /* 75499cabbb0SMika Westerberg * To keep plugging devices consistently in the same PCIe 755b0407983SMika Westerberg * hierarchy, do mapping here for switch downstream PCIe ports. 75699cabbb0SMika Westerberg */ 757b0407983SMika Westerberg if (tb_switch_is_usb4(sw)) { 758b0407983SMika Westerberg down = usb4_switch_map_pcie_down(sw, port); 759b0407983SMika Westerberg } else if (!tb_route(sw)) { 76099cabbb0SMika Westerberg int phy_port = tb_phy_port_from_link(port->port); 76199cabbb0SMika Westerberg int index; 76299cabbb0SMika Westerberg 76399cabbb0SMika Westerberg /* 76499cabbb0SMika Westerberg * Hard-coded Thunderbolt port to PCIe down port mapping 76599cabbb0SMika Westerberg * per controller. 76699cabbb0SMika Westerberg */ 7677bffd97eSMika Westerberg if (tb_switch_is_cactus_ridge(sw) || 7687bffd97eSMika Westerberg tb_switch_is_alpine_ridge(sw)) 76999cabbb0SMika Westerberg index = !phy_port ? 6 : 7; 77017a8f815SMika Westerberg else if (tb_switch_is_falcon_ridge(sw)) 77199cabbb0SMika Westerberg index = !phy_port ? 6 : 8; 7727bffd97eSMika Westerberg else if (tb_switch_is_titan_ridge(sw)) 7737bffd97eSMika Westerberg index = !phy_port ? 8 : 9; 77499cabbb0SMika Westerberg else 77599cabbb0SMika Westerberg goto out; 77699cabbb0SMika Westerberg 77799cabbb0SMika Westerberg /* Validate the hard-coding */ 77899cabbb0SMika Westerberg if (WARN_ON(index > sw->config.max_port_number)) 77999cabbb0SMika Westerberg goto out; 780b0407983SMika Westerberg 781b0407983SMika Westerberg down = &sw->ports[index]; 782b0407983SMika Westerberg } 783b0407983SMika Westerberg 784b0407983SMika Westerberg if (down) { 785b0407983SMika Westerberg if (WARN_ON(!tb_port_is_pcie_down(down))) 78699cabbb0SMika Westerberg goto out; 7879cac51a0SMika Westerberg if (tb_pci_port_is_enabled(down)) 78899cabbb0SMika Westerberg goto out; 78999cabbb0SMika Westerberg 790b0407983SMika Westerberg return down; 79199cabbb0SMika Westerberg } 79299cabbb0SMika Westerberg 79399cabbb0SMika Westerberg out: 794e78db6f0SMika Westerberg return tb_find_unused_port(sw, TB_TYPE_PCIE_DOWN); 79599cabbb0SMika Westerberg } 79699cabbb0SMika Westerberg 797e876f34aSMika Westerberg static struct tb_port *tb_find_dp_out(struct tb *tb, struct tb_port *in) 798e876f34aSMika Westerberg { 799e876f34aSMika Westerberg struct tb_port *host_port, *port; 800e876f34aSMika Westerberg struct tb_cm *tcm = tb_priv(tb); 801e876f34aSMika Westerberg 802e876f34aSMika Westerberg host_port = tb_route(in->sw) ? 803e876f34aSMika Westerberg tb_port_at(tb_route(in->sw), tb->root_switch) : NULL; 804e876f34aSMika Westerberg 805e876f34aSMika Westerberg list_for_each_entry(port, &tcm->dp_resources, list) { 806e876f34aSMika Westerberg if (!tb_port_is_dpout(port)) 807e876f34aSMika Westerberg continue; 808e876f34aSMika Westerberg 809e876f34aSMika Westerberg if (tb_port_is_enabled(port)) { 810e876f34aSMika Westerberg tb_port_dbg(port, "in use\n"); 811e876f34aSMika Westerberg continue; 812e876f34aSMika Westerberg } 813e876f34aSMika Westerberg 814e876f34aSMika Westerberg tb_port_dbg(port, "DP OUT available\n"); 815e876f34aSMika Westerberg 816e876f34aSMika Westerberg /* 817e876f34aSMika Westerberg * Keep the DP tunnel under the topology starting from 818e876f34aSMika Westerberg * the same host router downstream port. 819e876f34aSMika Westerberg */ 820e876f34aSMika Westerberg if (host_port && tb_route(port->sw)) { 821e876f34aSMika Westerberg struct tb_port *p; 822e876f34aSMika Westerberg 823e876f34aSMika Westerberg p = tb_port_at(tb_route(port->sw), tb->root_switch); 824e876f34aSMika Westerberg if (p != host_port) 825e876f34aSMika Westerberg continue; 826e876f34aSMika Westerberg } 827e876f34aSMika Westerberg 828e876f34aSMika Westerberg return port; 829e876f34aSMika Westerberg } 830e876f34aSMika Westerberg 831e876f34aSMika Westerberg return NULL; 832e876f34aSMika Westerberg } 833e876f34aSMika Westerberg 8348afe909bSMika Westerberg static void tb_tunnel_dp(struct tb *tb) 8354f807e47SMika Westerberg { 8360bd680cdSMika Westerberg int available_up, available_down, ret; 8374f807e47SMika Westerberg struct tb_cm *tcm = tb_priv(tb); 8388afe909bSMika Westerberg struct tb_port *port, *in, *out; 8394f807e47SMika Westerberg struct tb_tunnel *tunnel; 8404f807e47SMika Westerberg 8418afe909bSMika Westerberg /* 8428afe909bSMika Westerberg * Find pair of inactive DP IN and DP OUT adapters and then 8438afe909bSMika Westerberg * establish a DP tunnel between them. 8448afe909bSMika Westerberg */ 8458afe909bSMika Westerberg tb_dbg(tb, "looking for DP IN <-> DP OUT pairs:\n"); 8464f807e47SMika Westerberg 8478afe909bSMika Westerberg in = NULL; 8488afe909bSMika Westerberg out = NULL; 8498afe909bSMika Westerberg list_for_each_entry(port, &tcm->dp_resources, list) { 850e876f34aSMika Westerberg if (!tb_port_is_dpin(port)) 851e876f34aSMika Westerberg continue; 852e876f34aSMika Westerberg 8538afe909bSMika Westerberg if (tb_port_is_enabled(port)) { 8548afe909bSMika Westerberg tb_port_dbg(port, "in use\n"); 8558afe909bSMika Westerberg continue; 8568afe909bSMika Westerberg } 8578afe909bSMika Westerberg 858e876f34aSMika Westerberg tb_port_dbg(port, "DP IN available\n"); 8598afe909bSMika Westerberg 860e876f34aSMika Westerberg out = tb_find_dp_out(tb, port); 861e876f34aSMika Westerberg if (out) { 8628afe909bSMika Westerberg in = port; 863e876f34aSMika Westerberg break; 864e876f34aSMika Westerberg } 8658afe909bSMika Westerberg } 8668afe909bSMika Westerberg 8678afe909bSMika Westerberg if (!in) { 8688afe909bSMika Westerberg tb_dbg(tb, "no suitable DP IN adapter available, not tunneling\n"); 8698afe909bSMika Westerberg return; 8708afe909bSMika Westerberg } 8718afe909bSMika Westerberg if (!out) { 8728afe909bSMika Westerberg tb_dbg(tb, "no suitable DP OUT adapter available, not tunneling\n"); 8738afe909bSMika Westerberg return; 8748afe909bSMika Westerberg } 8758afe909bSMika Westerberg 8766ac6faeeSMika Westerberg /* 8776ac6faeeSMika Westerberg * DP stream needs the domain to be active so runtime resume 8786ac6faeeSMika Westerberg * both ends of the tunnel. 8796ac6faeeSMika Westerberg * 8806ac6faeeSMika Westerberg * This should bring the routers in the middle active as well 8816ac6faeeSMika Westerberg * and keeps the domain from runtime suspending while the DP 8826ac6faeeSMika Westerberg * tunnel is active. 8836ac6faeeSMika Westerberg */ 8846ac6faeeSMika Westerberg pm_runtime_get_sync(&in->sw->dev); 8856ac6faeeSMika Westerberg pm_runtime_get_sync(&out->sw->dev); 8866ac6faeeSMika Westerberg 8878afe909bSMika Westerberg if (tb_switch_alloc_dp_resource(in->sw, in)) { 8888afe909bSMika Westerberg tb_port_dbg(in, "no resource available for DP IN, not tunneling\n"); 8896ac6faeeSMika Westerberg goto err_rpm_put; 8908afe909bSMika Westerberg } 8914f807e47SMika Westerberg 8920bd680cdSMika Westerberg /* Make all unused USB3 bandwidth available for the new DP tunnel */ 8930bd680cdSMika Westerberg ret = tb_release_unused_usb3_bandwidth(tb, in, out); 8940bd680cdSMika Westerberg if (ret) { 8950bd680cdSMika Westerberg tb_warn(tb, "failed to release unused bandwidth\n"); 8960bd680cdSMika Westerberg goto err_dealloc_dp; 897a11b88adSMika Westerberg } 898a11b88adSMika Westerberg 8990bd680cdSMika Westerberg ret = tb_available_bandwidth(tb, in, out, &available_up, 9000bd680cdSMika Westerberg &available_down); 9010bd680cdSMika Westerberg if (ret) 9020bd680cdSMika Westerberg goto err_reclaim; 903a11b88adSMika Westerberg 9040bd680cdSMika Westerberg tb_dbg(tb, "available bandwidth for new DP tunnel %u/%u Mb/s\n", 9050bd680cdSMika Westerberg available_up, available_down); 9060bd680cdSMika Westerberg 9070bd680cdSMika Westerberg tunnel = tb_tunnel_alloc_dp(tb, in, out, available_up, available_down); 9084f807e47SMika Westerberg if (!tunnel) { 9098afe909bSMika Westerberg tb_port_dbg(out, "could not allocate DP tunnel\n"); 9100bd680cdSMika Westerberg goto err_reclaim; 9114f807e47SMika Westerberg } 9124f807e47SMika Westerberg 9134f807e47SMika Westerberg if (tb_tunnel_activate(tunnel)) { 9144f807e47SMika Westerberg tb_port_info(out, "DP tunnel activation failed, aborting\n"); 9150bd680cdSMika Westerberg goto err_free; 9164f807e47SMika Westerberg } 9174f807e47SMika Westerberg 9184f807e47SMika Westerberg list_add_tail(&tunnel->list, &tcm->tunnel_list); 9190bd680cdSMika Westerberg tb_reclaim_usb3_bandwidth(tb, in, out); 9208afe909bSMika Westerberg return; 9218afe909bSMika Westerberg 9220bd680cdSMika Westerberg err_free: 9230bd680cdSMika Westerberg tb_tunnel_free(tunnel); 9240bd680cdSMika Westerberg err_reclaim: 9250bd680cdSMika Westerberg tb_reclaim_usb3_bandwidth(tb, in, out); 9260bd680cdSMika Westerberg err_dealloc_dp: 9278afe909bSMika Westerberg tb_switch_dealloc_dp_resource(in->sw, in); 9286ac6faeeSMika Westerberg err_rpm_put: 9296ac6faeeSMika Westerberg pm_runtime_mark_last_busy(&out->sw->dev); 9306ac6faeeSMika Westerberg pm_runtime_put_autosuspend(&out->sw->dev); 9316ac6faeeSMika Westerberg pm_runtime_mark_last_busy(&in->sw->dev); 9326ac6faeeSMika Westerberg pm_runtime_put_autosuspend(&in->sw->dev); 9334f807e47SMika Westerberg } 9344f807e47SMika Westerberg 9358afe909bSMika Westerberg static void tb_dp_resource_unavailable(struct tb *tb, struct tb_port *port) 9364f807e47SMika Westerberg { 9378afe909bSMika Westerberg struct tb_port *in, *out; 9388afe909bSMika Westerberg struct tb_tunnel *tunnel; 9398afe909bSMika Westerberg 9408afe909bSMika Westerberg if (tb_port_is_dpin(port)) { 9418afe909bSMika Westerberg tb_port_dbg(port, "DP IN resource unavailable\n"); 9428afe909bSMika Westerberg in = port; 9438afe909bSMika Westerberg out = NULL; 9448afe909bSMika Westerberg } else { 9458afe909bSMika Westerberg tb_port_dbg(port, "DP OUT resource unavailable\n"); 9468afe909bSMika Westerberg in = NULL; 9478afe909bSMika Westerberg out = port; 9488afe909bSMika Westerberg } 9498afe909bSMika Westerberg 9508afe909bSMika Westerberg tunnel = tb_find_tunnel(tb, TB_TUNNEL_DP, in, out); 9518afe909bSMika Westerberg tb_deactivate_and_free_tunnel(tunnel); 9528afe909bSMika Westerberg list_del_init(&port->list); 9538afe909bSMika Westerberg 9548afe909bSMika Westerberg /* 9558afe909bSMika Westerberg * See if there is another DP OUT port that can be used for 9568afe909bSMika Westerberg * to create another tunnel. 9578afe909bSMika Westerberg */ 9588afe909bSMika Westerberg tb_tunnel_dp(tb); 9598afe909bSMika Westerberg } 9608afe909bSMika Westerberg 9618afe909bSMika Westerberg static void tb_dp_resource_available(struct tb *tb, struct tb_port *port) 9628afe909bSMika Westerberg { 9638afe909bSMika Westerberg struct tb_cm *tcm = tb_priv(tb); 9648afe909bSMika Westerberg struct tb_port *p; 9658afe909bSMika Westerberg 9668afe909bSMika Westerberg if (tb_port_is_enabled(port)) 9678afe909bSMika Westerberg return; 9688afe909bSMika Westerberg 9698afe909bSMika Westerberg list_for_each_entry(p, &tcm->dp_resources, list) { 9708afe909bSMika Westerberg if (p == port) 9718afe909bSMika Westerberg return; 9728afe909bSMika Westerberg } 9738afe909bSMika Westerberg 9748afe909bSMika Westerberg tb_port_dbg(port, "DP %s resource available\n", 9758afe909bSMika Westerberg tb_port_is_dpin(port) ? "IN" : "OUT"); 9768afe909bSMika Westerberg list_add_tail(&port->list, &tcm->dp_resources); 9778afe909bSMika Westerberg 9788afe909bSMika Westerberg /* Look for suitable DP IN <-> DP OUT pairs now */ 9798afe909bSMika Westerberg tb_tunnel_dp(tb); 9804f807e47SMika Westerberg } 9814f807e47SMika Westerberg 98281a2e3e4SMika Westerberg static void tb_disconnect_and_release_dp(struct tb *tb) 98381a2e3e4SMika Westerberg { 98481a2e3e4SMika Westerberg struct tb_cm *tcm = tb_priv(tb); 98581a2e3e4SMika Westerberg struct tb_tunnel *tunnel, *n; 98681a2e3e4SMika Westerberg 98781a2e3e4SMika Westerberg /* 98881a2e3e4SMika Westerberg * Tear down all DP tunnels and release their resources. They 98981a2e3e4SMika Westerberg * will be re-established after resume based on plug events. 99081a2e3e4SMika Westerberg */ 99181a2e3e4SMika Westerberg list_for_each_entry_safe_reverse(tunnel, n, &tcm->tunnel_list, list) { 99281a2e3e4SMika Westerberg if (tb_tunnel_is_dp(tunnel)) 99381a2e3e4SMika Westerberg tb_deactivate_and_free_tunnel(tunnel); 99481a2e3e4SMika Westerberg } 99581a2e3e4SMika Westerberg 99681a2e3e4SMika Westerberg while (!list_empty(&tcm->dp_resources)) { 99781a2e3e4SMika Westerberg struct tb_port *port; 99881a2e3e4SMika Westerberg 99981a2e3e4SMika Westerberg port = list_first_entry(&tcm->dp_resources, 100081a2e3e4SMika Westerberg struct tb_port, list); 100181a2e3e4SMika Westerberg list_del_init(&port->list); 100281a2e3e4SMika Westerberg } 100381a2e3e4SMika Westerberg } 100481a2e3e4SMika Westerberg 100599cabbb0SMika Westerberg static int tb_tunnel_pci(struct tb *tb, struct tb_switch *sw) 100699cabbb0SMika Westerberg { 100799cabbb0SMika Westerberg struct tb_port *up, *down, *port; 10089d3cce0bSMika Westerberg struct tb_cm *tcm = tb_priv(tb); 100999cabbb0SMika Westerberg struct tb_switch *parent_sw; 101099cabbb0SMika Westerberg struct tb_tunnel *tunnel; 10119d3cce0bSMika Westerberg 1012386e5e29SMika Westerberg up = tb_switch_find_port(sw, TB_TYPE_PCIE_UP); 101399cabbb0SMika Westerberg if (!up) 101499cabbb0SMika Westerberg return 0; 10153364f0c1SAndreas Noever 101699cabbb0SMika Westerberg /* 101799cabbb0SMika Westerberg * Look up available down port. Since we are chaining it should 101899cabbb0SMika Westerberg * be found right above this switch. 101999cabbb0SMika Westerberg */ 102099cabbb0SMika Westerberg parent_sw = tb_to_switch(sw->dev.parent); 102199cabbb0SMika Westerberg port = tb_port_at(tb_route(sw), parent_sw); 102299cabbb0SMika Westerberg down = tb_find_pcie_down(parent_sw, port); 102399cabbb0SMika Westerberg if (!down) 102499cabbb0SMika Westerberg return 0; 10253364f0c1SAndreas Noever 102699cabbb0SMika Westerberg tunnel = tb_tunnel_alloc_pci(tb, up, down); 102799cabbb0SMika Westerberg if (!tunnel) 102899cabbb0SMika Westerberg return -ENOMEM; 10293364f0c1SAndreas Noever 103093f36adeSMika Westerberg if (tb_tunnel_activate(tunnel)) { 103199cabbb0SMika Westerberg tb_port_info(up, 10323364f0c1SAndreas Noever "PCIe tunnel activation failed, aborting\n"); 103393f36adeSMika Westerberg tb_tunnel_free(tunnel); 103499cabbb0SMika Westerberg return -EIO; 10353364f0c1SAndreas Noever } 10363364f0c1SAndreas Noever 103799cabbb0SMika Westerberg list_add_tail(&tunnel->list, &tcm->tunnel_list); 103899cabbb0SMika Westerberg return 0; 10393364f0c1SAndreas Noever } 10409da672a4SAndreas Noever 10417ea4cd6bSMika Westerberg static int tb_approve_xdomain_paths(struct tb *tb, struct tb_xdomain *xd) 10427ea4cd6bSMika Westerberg { 10437ea4cd6bSMika Westerberg struct tb_cm *tcm = tb_priv(tb); 10447ea4cd6bSMika Westerberg struct tb_port *nhi_port, *dst_port; 10457ea4cd6bSMika Westerberg struct tb_tunnel *tunnel; 10467ea4cd6bSMika Westerberg struct tb_switch *sw; 10477ea4cd6bSMika Westerberg 10487ea4cd6bSMika Westerberg sw = tb_to_switch(xd->dev.parent); 10497ea4cd6bSMika Westerberg dst_port = tb_port_at(xd->route, sw); 1050386e5e29SMika Westerberg nhi_port = tb_switch_find_port(tb->root_switch, TB_TYPE_NHI); 10517ea4cd6bSMika Westerberg 10527ea4cd6bSMika Westerberg mutex_lock(&tb->lock); 10537ea4cd6bSMika Westerberg tunnel = tb_tunnel_alloc_dma(tb, nhi_port, dst_port, xd->transmit_ring, 10547ea4cd6bSMika Westerberg xd->transmit_path, xd->receive_ring, 10557ea4cd6bSMika Westerberg xd->receive_path); 10567ea4cd6bSMika Westerberg if (!tunnel) { 10577ea4cd6bSMika Westerberg mutex_unlock(&tb->lock); 10587ea4cd6bSMika Westerberg return -ENOMEM; 10597ea4cd6bSMika Westerberg } 10607ea4cd6bSMika Westerberg 10617ea4cd6bSMika Westerberg if (tb_tunnel_activate(tunnel)) { 10627ea4cd6bSMika Westerberg tb_port_info(nhi_port, 10637ea4cd6bSMika Westerberg "DMA tunnel activation failed, aborting\n"); 10647ea4cd6bSMika Westerberg tb_tunnel_free(tunnel); 10657ea4cd6bSMika Westerberg mutex_unlock(&tb->lock); 10667ea4cd6bSMika Westerberg return -EIO; 10677ea4cd6bSMika Westerberg } 10687ea4cd6bSMika Westerberg 10697ea4cd6bSMika Westerberg list_add_tail(&tunnel->list, &tcm->tunnel_list); 10707ea4cd6bSMika Westerberg mutex_unlock(&tb->lock); 10717ea4cd6bSMika Westerberg return 0; 10727ea4cd6bSMika Westerberg } 10737ea4cd6bSMika Westerberg 10747ea4cd6bSMika Westerberg static void __tb_disconnect_xdomain_paths(struct tb *tb, struct tb_xdomain *xd) 10757ea4cd6bSMika Westerberg { 10767ea4cd6bSMika Westerberg struct tb_port *dst_port; 10778afe909bSMika Westerberg struct tb_tunnel *tunnel; 10787ea4cd6bSMika Westerberg struct tb_switch *sw; 10797ea4cd6bSMika Westerberg 10807ea4cd6bSMika Westerberg sw = tb_to_switch(xd->dev.parent); 10817ea4cd6bSMika Westerberg dst_port = tb_port_at(xd->route, sw); 10827ea4cd6bSMika Westerberg 10837ea4cd6bSMika Westerberg /* 10847ea4cd6bSMika Westerberg * It is possible that the tunnel was already teared down (in 10857ea4cd6bSMika Westerberg * case of cable disconnect) so it is fine if we cannot find it 10867ea4cd6bSMika Westerberg * here anymore. 10877ea4cd6bSMika Westerberg */ 10888afe909bSMika Westerberg tunnel = tb_find_tunnel(tb, TB_TUNNEL_DMA, NULL, dst_port); 10898afe909bSMika Westerberg tb_deactivate_and_free_tunnel(tunnel); 10907ea4cd6bSMika Westerberg } 10917ea4cd6bSMika Westerberg 10927ea4cd6bSMika Westerberg static int tb_disconnect_xdomain_paths(struct tb *tb, struct tb_xdomain *xd) 10937ea4cd6bSMika Westerberg { 10947ea4cd6bSMika Westerberg if (!xd->is_unplugged) { 10957ea4cd6bSMika Westerberg mutex_lock(&tb->lock); 10967ea4cd6bSMika Westerberg __tb_disconnect_xdomain_paths(tb, xd); 10977ea4cd6bSMika Westerberg mutex_unlock(&tb->lock); 10987ea4cd6bSMika Westerberg } 10997ea4cd6bSMika Westerberg return 0; 11007ea4cd6bSMika Westerberg } 11017ea4cd6bSMika Westerberg 1102d6cc51cdSAndreas Noever /* hotplug handling */ 1103d6cc51cdSAndreas Noever 1104d6cc51cdSAndreas Noever /** 1105d6cc51cdSAndreas Noever * tb_handle_hotplug() - handle hotplug event 1106d6cc51cdSAndreas Noever * 1107d6cc51cdSAndreas Noever * Executes on tb->wq. 1108d6cc51cdSAndreas Noever */ 1109d6cc51cdSAndreas Noever static void tb_handle_hotplug(struct work_struct *work) 1110d6cc51cdSAndreas Noever { 1111d6cc51cdSAndreas Noever struct tb_hotplug_event *ev = container_of(work, typeof(*ev), work); 1112d6cc51cdSAndreas Noever struct tb *tb = ev->tb; 11139d3cce0bSMika Westerberg struct tb_cm *tcm = tb_priv(tb); 1114053596d9SAndreas Noever struct tb_switch *sw; 1115053596d9SAndreas Noever struct tb_port *port; 1116284652a4SMika Westerberg 11176ac6faeeSMika Westerberg /* Bring the domain back from sleep if it was suspended */ 11186ac6faeeSMika Westerberg pm_runtime_get_sync(&tb->dev); 11196ac6faeeSMika Westerberg 1120d6cc51cdSAndreas Noever mutex_lock(&tb->lock); 11219d3cce0bSMika Westerberg if (!tcm->hotplug_active) 1122d6cc51cdSAndreas Noever goto out; /* during init, suspend or shutdown */ 1123d6cc51cdSAndreas Noever 11248f965efdSMika Westerberg sw = tb_switch_find_by_route(tb, ev->route); 1125053596d9SAndreas Noever if (!sw) { 1126053596d9SAndreas Noever tb_warn(tb, 1127053596d9SAndreas Noever "hotplug event from non existent switch %llx:%x (unplug: %d)\n", 1128053596d9SAndreas Noever ev->route, ev->port, ev->unplug); 1129053596d9SAndreas Noever goto out; 1130053596d9SAndreas Noever } 1131053596d9SAndreas Noever if (ev->port > sw->config.max_port_number) { 1132053596d9SAndreas Noever tb_warn(tb, 1133053596d9SAndreas Noever "hotplug event from non existent port %llx:%x (unplug: %d)\n", 1134053596d9SAndreas Noever ev->route, ev->port, ev->unplug); 11358f965efdSMika Westerberg goto put_sw; 1136053596d9SAndreas Noever } 1137053596d9SAndreas Noever port = &sw->ports[ev->port]; 1138053596d9SAndreas Noever if (tb_is_upstream_port(port)) { 1139dfe40ca4SMika Westerberg tb_dbg(tb, "hotplug event for upstream port %llx:%x (unplug: %d)\n", 1140053596d9SAndreas Noever ev->route, ev->port, ev->unplug); 11418f965efdSMika Westerberg goto put_sw; 1142053596d9SAndreas Noever } 11436ac6faeeSMika Westerberg 11446ac6faeeSMika Westerberg pm_runtime_get_sync(&sw->dev); 11456ac6faeeSMika Westerberg 1146053596d9SAndreas Noever if (ev->unplug) { 1147dacb1287SKranthi Kuntala tb_retimer_remove_all(port); 1148dacb1287SKranthi Kuntala 1149dfe40ca4SMika Westerberg if (tb_port_has_remote(port)) { 11507ea4cd6bSMika Westerberg tb_port_dbg(port, "switch unplugged\n"); 1151aae20bb6SLukas Wunner tb_sw_set_unplugged(port->remote->sw); 11523364f0c1SAndreas Noever tb_free_invalid_tunnels(tb); 11538afe909bSMika Westerberg tb_remove_dp_resources(port->remote->sw); 1154cf29b9afSRajmohan Mani tb_switch_tmu_disable(port->remote->sw); 1155de462039SMika Westerberg tb_switch_unconfigure_link(port->remote->sw); 115691c0c120SMika Westerberg tb_switch_lane_bonding_disable(port->remote->sw); 1157bfe778acSMika Westerberg tb_switch_remove(port->remote->sw); 1158053596d9SAndreas Noever port->remote = NULL; 1159dfe40ca4SMika Westerberg if (port->dual_link_port) 1160dfe40ca4SMika Westerberg port->dual_link_port->remote = NULL; 11618afe909bSMika Westerberg /* Maybe we can create another DP tunnel */ 11628afe909bSMika Westerberg tb_tunnel_dp(tb); 11637ea4cd6bSMika Westerberg } else if (port->xdomain) { 11647ea4cd6bSMika Westerberg struct tb_xdomain *xd = tb_xdomain_get(port->xdomain); 11657ea4cd6bSMika Westerberg 11667ea4cd6bSMika Westerberg tb_port_dbg(port, "xdomain unplugged\n"); 11677ea4cd6bSMika Westerberg /* 11687ea4cd6bSMika Westerberg * Service drivers are unbound during 11697ea4cd6bSMika Westerberg * tb_xdomain_remove() so setting XDomain as 11707ea4cd6bSMika Westerberg * unplugged here prevents deadlock if they call 11717ea4cd6bSMika Westerberg * tb_xdomain_disable_paths(). We will tear down 11727ea4cd6bSMika Westerberg * the path below. 11737ea4cd6bSMika Westerberg */ 11747ea4cd6bSMika Westerberg xd->is_unplugged = true; 11757ea4cd6bSMika Westerberg tb_xdomain_remove(xd); 11767ea4cd6bSMika Westerberg port->xdomain = NULL; 11777ea4cd6bSMika Westerberg __tb_disconnect_xdomain_paths(tb, xd); 11787ea4cd6bSMika Westerberg tb_xdomain_put(xd); 1179284652a4SMika Westerberg tb_port_unconfigure_xdomain(port); 11808afe909bSMika Westerberg } else if (tb_port_is_dpout(port) || tb_port_is_dpin(port)) { 11818afe909bSMika Westerberg tb_dp_resource_unavailable(tb, port); 1182053596d9SAndreas Noever } else { 118362efe699SMika Westerberg tb_port_dbg(port, 1184053596d9SAndreas Noever "got unplug event for disconnected port, ignoring\n"); 1185053596d9SAndreas Noever } 1186053596d9SAndreas Noever } else if (port->remote) { 118762efe699SMika Westerberg tb_port_dbg(port, "got plug event for connected port, ignoring\n"); 1188053596d9SAndreas Noever } else { 1189344e0643SMika Westerberg if (tb_port_is_null(port)) { 119062efe699SMika Westerberg tb_port_dbg(port, "hotplug: scanning\n"); 1191053596d9SAndreas Noever tb_scan_port(port); 119299cabbb0SMika Westerberg if (!port->remote) 119362efe699SMika Westerberg tb_port_dbg(port, "hotplug: no switch found\n"); 11948afe909bSMika Westerberg } else if (tb_port_is_dpout(port) || tb_port_is_dpin(port)) { 11958afe909bSMika Westerberg tb_dp_resource_available(tb, port); 1196053596d9SAndreas Noever } 1197344e0643SMika Westerberg } 11988f965efdSMika Westerberg 11996ac6faeeSMika Westerberg pm_runtime_mark_last_busy(&sw->dev); 12006ac6faeeSMika Westerberg pm_runtime_put_autosuspend(&sw->dev); 12016ac6faeeSMika Westerberg 12028f965efdSMika Westerberg put_sw: 12038f965efdSMika Westerberg tb_switch_put(sw); 1204d6cc51cdSAndreas Noever out: 1205d6cc51cdSAndreas Noever mutex_unlock(&tb->lock); 12066ac6faeeSMika Westerberg 12076ac6faeeSMika Westerberg pm_runtime_mark_last_busy(&tb->dev); 12086ac6faeeSMika Westerberg pm_runtime_put_autosuspend(&tb->dev); 12096ac6faeeSMika Westerberg 1210d6cc51cdSAndreas Noever kfree(ev); 1211d6cc51cdSAndreas Noever } 1212d6cc51cdSAndreas Noever 1213d6cc51cdSAndreas Noever /** 1214d6cc51cdSAndreas Noever * tb_schedule_hotplug_handler() - callback function for the control channel 1215d6cc51cdSAndreas Noever * 1216d6cc51cdSAndreas Noever * Delegates to tb_handle_hotplug. 1217d6cc51cdSAndreas Noever */ 121881a54b5eSMika Westerberg static void tb_handle_event(struct tb *tb, enum tb_cfg_pkg_type type, 121981a54b5eSMika Westerberg const void *buf, size_t size) 1220d6cc51cdSAndreas Noever { 122181a54b5eSMika Westerberg const struct cfg_event_pkg *pkg = buf; 122281a54b5eSMika Westerberg u64 route; 122381a54b5eSMika Westerberg 122481a54b5eSMika Westerberg if (type != TB_CFG_PKG_EVENT) { 122581a54b5eSMika Westerberg tb_warn(tb, "unexpected event %#x, ignoring\n", type); 122681a54b5eSMika Westerberg return; 122781a54b5eSMika Westerberg } 122881a54b5eSMika Westerberg 122981a54b5eSMika Westerberg route = tb_cfg_get_route(&pkg->header); 123081a54b5eSMika Westerberg 1231210e9f56SMika Westerberg if (tb_cfg_ack_plug(tb->ctl, route, pkg->port, pkg->unplug)) { 123281a54b5eSMika Westerberg tb_warn(tb, "could not ack plug event on %llx:%x\n", route, 123381a54b5eSMika Westerberg pkg->port); 123481a54b5eSMika Westerberg } 123581a54b5eSMika Westerberg 12364f807e47SMika Westerberg tb_queue_hotplug(tb, route, pkg->port, pkg->unplug); 1237d6cc51cdSAndreas Noever } 1238d6cc51cdSAndreas Noever 12399d3cce0bSMika Westerberg static void tb_stop(struct tb *tb) 1240d6cc51cdSAndreas Noever { 12419d3cce0bSMika Westerberg struct tb_cm *tcm = tb_priv(tb); 124293f36adeSMika Westerberg struct tb_tunnel *tunnel; 124393f36adeSMika Westerberg struct tb_tunnel *n; 12443364f0c1SAndreas Noever 12456ac6faeeSMika Westerberg cancel_delayed_work(&tcm->remove_work); 12463364f0c1SAndreas Noever /* tunnels are only present after everything has been initialized */ 12477ea4cd6bSMika Westerberg list_for_each_entry_safe(tunnel, n, &tcm->tunnel_list, list) { 12487ea4cd6bSMika Westerberg /* 12497ea4cd6bSMika Westerberg * DMA tunnels require the driver to be functional so we 12507ea4cd6bSMika Westerberg * tear them down. Other protocol tunnels can be left 12517ea4cd6bSMika Westerberg * intact. 12527ea4cd6bSMika Westerberg */ 12537ea4cd6bSMika Westerberg if (tb_tunnel_is_dma(tunnel)) 12547ea4cd6bSMika Westerberg tb_tunnel_deactivate(tunnel); 125593f36adeSMika Westerberg tb_tunnel_free(tunnel); 12567ea4cd6bSMika Westerberg } 1257bfe778acSMika Westerberg tb_switch_remove(tb->root_switch); 12589d3cce0bSMika Westerberg tcm->hotplug_active = false; /* signal tb_handle_hotplug to quit */ 1259d6cc51cdSAndreas Noever } 1260d6cc51cdSAndreas Noever 126199cabbb0SMika Westerberg static int tb_scan_finalize_switch(struct device *dev, void *data) 126299cabbb0SMika Westerberg { 126399cabbb0SMika Westerberg if (tb_is_switch(dev)) { 126499cabbb0SMika Westerberg struct tb_switch *sw = tb_to_switch(dev); 126599cabbb0SMika Westerberg 126699cabbb0SMika Westerberg /* 126799cabbb0SMika Westerberg * If we found that the switch was already setup by the 126899cabbb0SMika Westerberg * boot firmware, mark it as authorized now before we 126999cabbb0SMika Westerberg * send uevent to userspace. 127099cabbb0SMika Westerberg */ 127199cabbb0SMika Westerberg if (sw->boot) 127299cabbb0SMika Westerberg sw->authorized = 1; 127399cabbb0SMika Westerberg 127499cabbb0SMika Westerberg dev_set_uevent_suppress(dev, false); 127599cabbb0SMika Westerberg kobject_uevent(&dev->kobj, KOBJ_ADD); 127699cabbb0SMika Westerberg device_for_each_child(dev, NULL, tb_scan_finalize_switch); 127799cabbb0SMika Westerberg } 127899cabbb0SMika Westerberg 127999cabbb0SMika Westerberg return 0; 128099cabbb0SMika Westerberg } 128199cabbb0SMika Westerberg 12829d3cce0bSMika Westerberg static int tb_start(struct tb *tb) 1283d6cc51cdSAndreas Noever { 12849d3cce0bSMika Westerberg struct tb_cm *tcm = tb_priv(tb); 1285bfe778acSMika Westerberg int ret; 1286d6cc51cdSAndreas Noever 1287bfe778acSMika Westerberg tb->root_switch = tb_switch_alloc(tb, &tb->dev, 0); 1288444ac384SMika Westerberg if (IS_ERR(tb->root_switch)) 1289444ac384SMika Westerberg return PTR_ERR(tb->root_switch); 1290a25c8b2fSAndreas Noever 1291e6b245ccSMika Westerberg /* 1292e6b245ccSMika Westerberg * ICM firmware upgrade needs running firmware and in native 1293e6b245ccSMika Westerberg * mode that is not available so disable firmware upgrade of the 1294e6b245ccSMika Westerberg * root switch. 1295e6b245ccSMika Westerberg */ 1296e6b245ccSMika Westerberg tb->root_switch->no_nvm_upgrade = true; 12976ac6faeeSMika Westerberg /* All USB4 routers support runtime PM */ 12986ac6faeeSMika Westerberg tb->root_switch->rpm = tb_switch_is_usb4(tb->root_switch); 1299e6b245ccSMika Westerberg 1300bfe778acSMika Westerberg ret = tb_switch_configure(tb->root_switch); 1301bfe778acSMika Westerberg if (ret) { 1302bfe778acSMika Westerberg tb_switch_put(tb->root_switch); 1303bfe778acSMika Westerberg return ret; 1304bfe778acSMika Westerberg } 1305bfe778acSMika Westerberg 1306bfe778acSMika Westerberg /* Announce the switch to the world */ 1307bfe778acSMika Westerberg ret = tb_switch_add(tb->root_switch); 1308bfe778acSMika Westerberg if (ret) { 1309bfe778acSMika Westerberg tb_switch_put(tb->root_switch); 1310bfe778acSMika Westerberg return ret; 1311bfe778acSMika Westerberg } 1312bfe778acSMika Westerberg 1313cf29b9afSRajmohan Mani /* Enable TMU if it is off */ 1314cf29b9afSRajmohan Mani tb_switch_tmu_enable(tb->root_switch); 13159da672a4SAndreas Noever /* Full scan to discover devices added before the driver was loaded. */ 13169da672a4SAndreas Noever tb_scan_switch(tb->root_switch); 13170414bec5SMika Westerberg /* Find out tunnels created by the boot firmware */ 13180414bec5SMika Westerberg tb_discover_tunnels(tb->root_switch); 1319e6f81858SRajmohan Mani /* 1320e6f81858SRajmohan Mani * If the boot firmware did not create USB 3.x tunnels create them 1321e6f81858SRajmohan Mani * now for the whole topology. 1322e6f81858SRajmohan Mani */ 1323e6f81858SRajmohan Mani tb_create_usb3_tunnels(tb->root_switch); 13248afe909bSMika Westerberg /* Add DP IN resources for the root switch */ 13258afe909bSMika Westerberg tb_add_dp_resources(tb->root_switch); 132699cabbb0SMika Westerberg /* Make the discovered switches available to the userspace */ 132799cabbb0SMika Westerberg device_for_each_child(&tb->root_switch->dev, NULL, 132899cabbb0SMika Westerberg tb_scan_finalize_switch); 13299da672a4SAndreas Noever 1330d6cc51cdSAndreas Noever /* Allow tb_handle_hotplug to progress events */ 13319d3cce0bSMika Westerberg tcm->hotplug_active = true; 13329d3cce0bSMika Westerberg return 0; 1333d6cc51cdSAndreas Noever } 1334d6cc51cdSAndreas Noever 13359d3cce0bSMika Westerberg static int tb_suspend_noirq(struct tb *tb) 133623dd5bb4SAndreas Noever { 13379d3cce0bSMika Westerberg struct tb_cm *tcm = tb_priv(tb); 13389d3cce0bSMika Westerberg 1339daa5140fSMika Westerberg tb_dbg(tb, "suspending...\n"); 134081a2e3e4SMika Westerberg tb_disconnect_and_release_dp(tb); 13416ac6faeeSMika Westerberg tb_switch_suspend(tb->root_switch, false); 13429d3cce0bSMika Westerberg tcm->hotplug_active = false; /* signal tb_handle_hotplug to quit */ 1343daa5140fSMika Westerberg tb_dbg(tb, "suspend finished\n"); 13449d3cce0bSMika Westerberg 13459d3cce0bSMika Westerberg return 0; 134623dd5bb4SAndreas Noever } 134723dd5bb4SAndreas Noever 134891c0c120SMika Westerberg static void tb_restore_children(struct tb_switch *sw) 134991c0c120SMika Westerberg { 135091c0c120SMika Westerberg struct tb_port *port; 135191c0c120SMika Westerberg 13526ac6faeeSMika Westerberg /* No need to restore if the router is already unplugged */ 13536ac6faeeSMika Westerberg if (sw->is_unplugged) 13546ac6faeeSMika Westerberg return; 13556ac6faeeSMika Westerberg 1356cf29b9afSRajmohan Mani if (tb_enable_tmu(sw)) 1357cf29b9afSRajmohan Mani tb_sw_warn(sw, "failed to restore TMU configuration\n"); 1358cf29b9afSRajmohan Mani 135991c0c120SMika Westerberg tb_switch_for_each_port(sw, port) { 1360284652a4SMika Westerberg if (!tb_port_has_remote(port) && !port->xdomain) 136191c0c120SMika Westerberg continue; 136291c0c120SMika Westerberg 1363284652a4SMika Westerberg if (port->remote) { 13642ca3263aSMika Westerberg tb_switch_lane_bonding_enable(port->remote->sw); 1365de462039SMika Westerberg tb_switch_configure_link(port->remote->sw); 136691c0c120SMika Westerberg 136791c0c120SMika Westerberg tb_restore_children(port->remote->sw); 1368284652a4SMika Westerberg } else if (port->xdomain) { 1369284652a4SMika Westerberg tb_port_configure_xdomain(port); 1370284652a4SMika Westerberg } 137191c0c120SMika Westerberg } 137291c0c120SMika Westerberg } 137391c0c120SMika Westerberg 13749d3cce0bSMika Westerberg static int tb_resume_noirq(struct tb *tb) 137523dd5bb4SAndreas Noever { 13769d3cce0bSMika Westerberg struct tb_cm *tcm = tb_priv(tb); 137793f36adeSMika Westerberg struct tb_tunnel *tunnel, *n; 13789d3cce0bSMika Westerberg 1379daa5140fSMika Westerberg tb_dbg(tb, "resuming...\n"); 138023dd5bb4SAndreas Noever 138123dd5bb4SAndreas Noever /* remove any pci devices the firmware might have setup */ 1382356b6c4eSMika Westerberg tb_switch_reset(tb->root_switch); 138323dd5bb4SAndreas Noever 138423dd5bb4SAndreas Noever tb_switch_resume(tb->root_switch); 138523dd5bb4SAndreas Noever tb_free_invalid_tunnels(tb); 138623dd5bb4SAndreas Noever tb_free_unplugged_children(tb->root_switch); 138791c0c120SMika Westerberg tb_restore_children(tb->root_switch); 13889d3cce0bSMika Westerberg list_for_each_entry_safe(tunnel, n, &tcm->tunnel_list, list) 138993f36adeSMika Westerberg tb_tunnel_restart(tunnel); 13909d3cce0bSMika Westerberg if (!list_empty(&tcm->tunnel_list)) { 139123dd5bb4SAndreas Noever /* 139223dd5bb4SAndreas Noever * the pcie links need some time to get going. 139323dd5bb4SAndreas Noever * 100ms works for me... 139423dd5bb4SAndreas Noever */ 1395daa5140fSMika Westerberg tb_dbg(tb, "tunnels restarted, sleeping for 100ms\n"); 139623dd5bb4SAndreas Noever msleep(100); 139723dd5bb4SAndreas Noever } 139823dd5bb4SAndreas Noever /* Allow tb_handle_hotplug to progress events */ 13999d3cce0bSMika Westerberg tcm->hotplug_active = true; 1400daa5140fSMika Westerberg tb_dbg(tb, "resume finished\n"); 14019d3cce0bSMika Westerberg 14029d3cce0bSMika Westerberg return 0; 14039d3cce0bSMika Westerberg } 14049d3cce0bSMika Westerberg 14057ea4cd6bSMika Westerberg static int tb_free_unplugged_xdomains(struct tb_switch *sw) 14067ea4cd6bSMika Westerberg { 1407b433d010SMika Westerberg struct tb_port *port; 1408b433d010SMika Westerberg int ret = 0; 14097ea4cd6bSMika Westerberg 1410b433d010SMika Westerberg tb_switch_for_each_port(sw, port) { 14117ea4cd6bSMika Westerberg if (tb_is_upstream_port(port)) 14127ea4cd6bSMika Westerberg continue; 14137ea4cd6bSMika Westerberg if (port->xdomain && port->xdomain->is_unplugged) { 1414dacb1287SKranthi Kuntala tb_retimer_remove_all(port); 14157ea4cd6bSMika Westerberg tb_xdomain_remove(port->xdomain); 1416284652a4SMika Westerberg tb_port_unconfigure_xdomain(port); 14177ea4cd6bSMika Westerberg port->xdomain = NULL; 14187ea4cd6bSMika Westerberg ret++; 14197ea4cd6bSMika Westerberg } else if (port->remote) { 14207ea4cd6bSMika Westerberg ret += tb_free_unplugged_xdomains(port->remote->sw); 14217ea4cd6bSMika Westerberg } 14227ea4cd6bSMika Westerberg } 14237ea4cd6bSMika Westerberg 14247ea4cd6bSMika Westerberg return ret; 14257ea4cd6bSMika Westerberg } 14267ea4cd6bSMika Westerberg 14277ea4cd6bSMika Westerberg static void tb_complete(struct tb *tb) 14287ea4cd6bSMika Westerberg { 14297ea4cd6bSMika Westerberg /* 14307ea4cd6bSMika Westerberg * Release any unplugged XDomains and if there is a case where 14317ea4cd6bSMika Westerberg * another domain is swapped in place of unplugged XDomain we 14327ea4cd6bSMika Westerberg * need to run another rescan. 14337ea4cd6bSMika Westerberg */ 14347ea4cd6bSMika Westerberg mutex_lock(&tb->lock); 14357ea4cd6bSMika Westerberg if (tb_free_unplugged_xdomains(tb->root_switch)) 14367ea4cd6bSMika Westerberg tb_scan_switch(tb->root_switch); 14377ea4cd6bSMika Westerberg mutex_unlock(&tb->lock); 14387ea4cd6bSMika Westerberg } 14397ea4cd6bSMika Westerberg 14406ac6faeeSMika Westerberg static int tb_runtime_suspend(struct tb *tb) 14416ac6faeeSMika Westerberg { 14426ac6faeeSMika Westerberg struct tb_cm *tcm = tb_priv(tb); 14436ac6faeeSMika Westerberg 14446ac6faeeSMika Westerberg mutex_lock(&tb->lock); 14456ac6faeeSMika Westerberg tb_switch_suspend(tb->root_switch, true); 14466ac6faeeSMika Westerberg tcm->hotplug_active = false; 14476ac6faeeSMika Westerberg mutex_unlock(&tb->lock); 14486ac6faeeSMika Westerberg 14496ac6faeeSMika Westerberg return 0; 14506ac6faeeSMika Westerberg } 14516ac6faeeSMika Westerberg 14526ac6faeeSMika Westerberg static void tb_remove_work(struct work_struct *work) 14536ac6faeeSMika Westerberg { 14546ac6faeeSMika Westerberg struct tb_cm *tcm = container_of(work, struct tb_cm, remove_work.work); 14556ac6faeeSMika Westerberg struct tb *tb = tcm_to_tb(tcm); 14566ac6faeeSMika Westerberg 14576ac6faeeSMika Westerberg mutex_lock(&tb->lock); 14586ac6faeeSMika Westerberg if (tb->root_switch) { 14596ac6faeeSMika Westerberg tb_free_unplugged_children(tb->root_switch); 14606ac6faeeSMika Westerberg tb_free_unplugged_xdomains(tb->root_switch); 14616ac6faeeSMika Westerberg } 14626ac6faeeSMika Westerberg mutex_unlock(&tb->lock); 14636ac6faeeSMika Westerberg } 14646ac6faeeSMika Westerberg 14656ac6faeeSMika Westerberg static int tb_runtime_resume(struct tb *tb) 14666ac6faeeSMika Westerberg { 14676ac6faeeSMika Westerberg struct tb_cm *tcm = tb_priv(tb); 14686ac6faeeSMika Westerberg struct tb_tunnel *tunnel, *n; 14696ac6faeeSMika Westerberg 14706ac6faeeSMika Westerberg mutex_lock(&tb->lock); 14716ac6faeeSMika Westerberg tb_switch_resume(tb->root_switch); 14726ac6faeeSMika Westerberg tb_free_invalid_tunnels(tb); 14736ac6faeeSMika Westerberg tb_restore_children(tb->root_switch); 14746ac6faeeSMika Westerberg list_for_each_entry_safe(tunnel, n, &tcm->tunnel_list, list) 14756ac6faeeSMika Westerberg tb_tunnel_restart(tunnel); 14766ac6faeeSMika Westerberg tcm->hotplug_active = true; 14776ac6faeeSMika Westerberg mutex_unlock(&tb->lock); 14786ac6faeeSMika Westerberg 14796ac6faeeSMika Westerberg /* 14806ac6faeeSMika Westerberg * Schedule cleanup of any unplugged devices. Run this in a 14816ac6faeeSMika Westerberg * separate thread to avoid possible deadlock if the device 14826ac6faeeSMika Westerberg * removal runtime resumes the unplugged device. 14836ac6faeeSMika Westerberg */ 14846ac6faeeSMika Westerberg queue_delayed_work(tb->wq, &tcm->remove_work, msecs_to_jiffies(50)); 14856ac6faeeSMika Westerberg return 0; 14866ac6faeeSMika Westerberg } 14876ac6faeeSMika Westerberg 14889d3cce0bSMika Westerberg static const struct tb_cm_ops tb_cm_ops = { 14899d3cce0bSMika Westerberg .start = tb_start, 14909d3cce0bSMika Westerberg .stop = tb_stop, 14919d3cce0bSMika Westerberg .suspend_noirq = tb_suspend_noirq, 14929d3cce0bSMika Westerberg .resume_noirq = tb_resume_noirq, 14937ea4cd6bSMika Westerberg .complete = tb_complete, 14946ac6faeeSMika Westerberg .runtime_suspend = tb_runtime_suspend, 14956ac6faeeSMika Westerberg .runtime_resume = tb_runtime_resume, 149681a54b5eSMika Westerberg .handle_event = tb_handle_event, 149799cabbb0SMika Westerberg .approve_switch = tb_tunnel_pci, 14987ea4cd6bSMika Westerberg .approve_xdomain_paths = tb_approve_xdomain_paths, 14997ea4cd6bSMika Westerberg .disconnect_xdomain_paths = tb_disconnect_xdomain_paths, 15009d3cce0bSMika Westerberg }; 15019d3cce0bSMika Westerberg 15029d3cce0bSMika Westerberg struct tb *tb_probe(struct tb_nhi *nhi) 15039d3cce0bSMika Westerberg { 15049d3cce0bSMika Westerberg struct tb_cm *tcm; 15059d3cce0bSMika Westerberg struct tb *tb; 15069d3cce0bSMika Westerberg 15079d3cce0bSMika Westerberg tb = tb_domain_alloc(nhi, sizeof(*tcm)); 15089d3cce0bSMika Westerberg if (!tb) 15099d3cce0bSMika Westerberg return NULL; 15109d3cce0bSMika Westerberg 151199cabbb0SMika Westerberg tb->security_level = TB_SECURITY_USER; 15129d3cce0bSMika Westerberg tb->cm_ops = &tb_cm_ops; 15139d3cce0bSMika Westerberg 15149d3cce0bSMika Westerberg tcm = tb_priv(tb); 15159d3cce0bSMika Westerberg INIT_LIST_HEAD(&tcm->tunnel_list); 15168afe909bSMika Westerberg INIT_LIST_HEAD(&tcm->dp_resources); 15176ac6faeeSMika Westerberg INIT_DELAYED_WORK(&tcm->remove_work, tb_remove_work); 15189d3cce0bSMika Westerberg 15199d3cce0bSMika Westerberg return tb; 152023dd5bb4SAndreas Noever } 1521