1 /* 2 * Thunderbolt Cactus Ridge driver - bus logic (NHI independent) 3 * 4 * Copyright (c) 2014 Andreas Noever <andreas.noever@gmail.com> 5 */ 6 7 #include <linux/slab.h> 8 #include <linux/errno.h> 9 #include <linux/delay.h> 10 11 #include "tb.h" 12 #include "tb_regs.h" 13 #include "tunnel_pci.h" 14 15 16 /* enumeration & hot plug handling */ 17 18 19 static void tb_scan_port(struct tb_port *port); 20 21 /** 22 * tb_scan_switch() - scan for and initialize downstream switches 23 */ 24 static void tb_scan_switch(struct tb_switch *sw) 25 { 26 int i; 27 for (i = 1; i <= sw->config.max_port_number; i++) 28 tb_scan_port(&sw->ports[i]); 29 } 30 31 /** 32 * tb_scan_port() - check for and initialize switches below port 33 */ 34 static void tb_scan_port(struct tb_port *port) 35 { 36 struct tb_switch *sw; 37 if (tb_is_upstream_port(port)) 38 return; 39 if (port->config.type != TB_TYPE_PORT) 40 return; 41 if (port->dual_link_port && port->link_nr) 42 return; /* 43 * Downstream switch is reachable through two ports. 44 * Only scan on the primary port (link_nr == 0). 45 */ 46 if (tb_wait_for_port(port, false) <= 0) 47 return; 48 if (port->remote) { 49 tb_port_WARN(port, "port already has a remote!\n"); 50 return; 51 } 52 sw = tb_switch_alloc(port->sw->tb, tb_downstream_route(port)); 53 if (!sw) 54 return; 55 port->remote = tb_upstream_port(sw); 56 tb_upstream_port(sw)->remote = port; 57 tb_scan_switch(sw); 58 } 59 60 /** 61 * tb_free_invalid_tunnels() - destroy tunnels of devices that have gone away 62 */ 63 static void tb_free_invalid_tunnels(struct tb *tb) 64 { 65 struct tb_pci_tunnel *tunnel; 66 struct tb_pci_tunnel *n; 67 list_for_each_entry_safe(tunnel, n, &tb->tunnel_list, list) 68 { 69 if (tb_pci_is_invalid(tunnel)) { 70 tb_pci_deactivate(tunnel); 71 tb_pci_free(tunnel); 72 } 73 } 74 } 75 76 /** 77 * tb_free_unplugged_children() - traverse hierarchy and free unplugged switches 78 */ 79 static void tb_free_unplugged_children(struct tb_switch *sw) 80 { 81 int i; 82 for (i = 1; i <= sw->config.max_port_number; i++) { 83 struct tb_port *port = &sw->ports[i]; 84 if (tb_is_upstream_port(port)) 85 continue; 86 if (!port->remote) 87 continue; 88 if (port->remote->sw->is_unplugged) { 89 tb_switch_free(port->remote->sw); 90 port->remote = NULL; 91 } else { 92 tb_free_unplugged_children(port->remote->sw); 93 } 94 } 95 } 96 97 98 /** 99 * find_pci_up_port() - return the first PCIe up port on @sw or NULL 100 */ 101 static struct tb_port *tb_find_pci_up_port(struct tb_switch *sw) 102 { 103 int i; 104 for (i = 1; i <= sw->config.max_port_number; i++) 105 if (sw->ports[i].config.type == TB_TYPE_PCIE_UP) 106 return &sw->ports[i]; 107 return NULL; 108 } 109 110 /** 111 * find_unused_down_port() - return the first inactive PCIe down port on @sw 112 */ 113 static struct tb_port *tb_find_unused_down_port(struct tb_switch *sw) 114 { 115 int i; 116 int cap; 117 int res; 118 int data; 119 for (i = 1; i <= sw->config.max_port_number; i++) { 120 if (tb_is_upstream_port(&sw->ports[i])) 121 continue; 122 if (sw->ports[i].config.type != TB_TYPE_PCIE_DOWN) 123 continue; 124 cap = tb_find_cap(&sw->ports[i], TB_CFG_PORT, TB_CAP_PCIE); 125 if (cap <= 0) 126 continue; 127 res = tb_port_read(&sw->ports[i], &data, TB_CFG_PORT, cap, 1); 128 if (res < 0) 129 continue; 130 if (data & 0x80000000) 131 continue; 132 return &sw->ports[i]; 133 } 134 return NULL; 135 } 136 137 /** 138 * tb_activate_pcie_devices() - scan for and activate PCIe devices 139 * 140 * This method is somewhat ad hoc. For now it only supports one device 141 * per port and only devices at depth 1. 142 */ 143 static void tb_activate_pcie_devices(struct tb *tb) 144 { 145 int i; 146 int cap; 147 u32 data; 148 struct tb_switch *sw; 149 struct tb_port *up_port; 150 struct tb_port *down_port; 151 struct tb_pci_tunnel *tunnel; 152 /* scan for pcie devices at depth 1*/ 153 for (i = 1; i <= tb->root_switch->config.max_port_number; i++) { 154 if (tb_is_upstream_port(&tb->root_switch->ports[i])) 155 continue; 156 if (tb->root_switch->ports[i].config.type != TB_TYPE_PORT) 157 continue; 158 if (!tb->root_switch->ports[i].remote) 159 continue; 160 sw = tb->root_switch->ports[i].remote->sw; 161 up_port = tb_find_pci_up_port(sw); 162 if (!up_port) { 163 tb_sw_info(sw, "no PCIe devices found, aborting\n"); 164 continue; 165 } 166 167 /* check whether port is already activated */ 168 cap = tb_find_cap(up_port, TB_CFG_PORT, TB_CAP_PCIE); 169 if (cap <= 0) 170 continue; 171 if (tb_port_read(up_port, &data, TB_CFG_PORT, cap, 1)) 172 continue; 173 if (data & 0x80000000) { 174 tb_port_info(up_port, 175 "PCIe port already activated, aborting\n"); 176 continue; 177 } 178 179 down_port = tb_find_unused_down_port(tb->root_switch); 180 if (!down_port) { 181 tb_port_info(up_port, 182 "All PCIe down ports are occupied, aborting\n"); 183 continue; 184 } 185 tunnel = tb_pci_alloc(tb, up_port, down_port); 186 if (!tunnel) { 187 tb_port_info(up_port, 188 "PCIe tunnel allocation failed, aborting\n"); 189 continue; 190 } 191 192 if (tb_pci_activate(tunnel)) { 193 tb_port_info(up_port, 194 "PCIe tunnel activation failed, aborting\n"); 195 tb_pci_free(tunnel); 196 } 197 198 } 199 } 200 201 /* hotplug handling */ 202 203 struct tb_hotplug_event { 204 struct work_struct work; 205 struct tb *tb; 206 u64 route; 207 u8 port; 208 bool unplug; 209 }; 210 211 /** 212 * tb_handle_hotplug() - handle hotplug event 213 * 214 * Executes on tb->wq. 215 */ 216 static void tb_handle_hotplug(struct work_struct *work) 217 { 218 struct tb_hotplug_event *ev = container_of(work, typeof(*ev), work); 219 struct tb *tb = ev->tb; 220 struct tb_switch *sw; 221 struct tb_port *port; 222 mutex_lock(&tb->lock); 223 if (!tb->hotplug_active) 224 goto out; /* during init, suspend or shutdown */ 225 226 sw = get_switch_at_route(tb->root_switch, ev->route); 227 if (!sw) { 228 tb_warn(tb, 229 "hotplug event from non existent switch %llx:%x (unplug: %d)\n", 230 ev->route, ev->port, ev->unplug); 231 goto out; 232 } 233 if (ev->port > sw->config.max_port_number) { 234 tb_warn(tb, 235 "hotplug event from non existent port %llx:%x (unplug: %d)\n", 236 ev->route, ev->port, ev->unplug); 237 goto out; 238 } 239 port = &sw->ports[ev->port]; 240 if (tb_is_upstream_port(port)) { 241 tb_warn(tb, 242 "hotplug event for upstream port %llx:%x (unplug: %d)\n", 243 ev->route, ev->port, ev->unplug); 244 goto out; 245 } 246 if (ev->unplug) { 247 if (port->remote) { 248 tb_port_info(port, "unplugged\n"); 249 tb_sw_set_unplugged(port->remote->sw); 250 tb_free_invalid_tunnels(tb); 251 tb_switch_free(port->remote->sw); 252 port->remote = NULL; 253 } else { 254 tb_port_info(port, 255 "got unplug event for disconnected port, ignoring\n"); 256 } 257 } else if (port->remote) { 258 tb_port_info(port, 259 "got plug event for connected port, ignoring\n"); 260 } else { 261 tb_port_info(port, "hotplug: scanning\n"); 262 tb_scan_port(port); 263 if (!port->remote) { 264 tb_port_info(port, "hotplug: no switch found\n"); 265 } else if (port->remote->sw->config.depth > 1) { 266 tb_sw_warn(port->remote->sw, 267 "hotplug: chaining not supported\n"); 268 } else { 269 tb_sw_info(port->remote->sw, 270 "hotplug: activating pcie devices\n"); 271 tb_activate_pcie_devices(tb); 272 } 273 } 274 out: 275 mutex_unlock(&tb->lock); 276 kfree(ev); 277 } 278 279 /** 280 * tb_schedule_hotplug_handler() - callback function for the control channel 281 * 282 * Delegates to tb_handle_hotplug. 283 */ 284 static void tb_schedule_hotplug_handler(void *data, u64 route, u8 port, 285 bool unplug) 286 { 287 struct tb *tb = data; 288 struct tb_hotplug_event *ev = kmalloc(sizeof(*ev), GFP_KERNEL); 289 if (!ev) 290 return; 291 INIT_WORK(&ev->work, tb_handle_hotplug); 292 ev->tb = tb; 293 ev->route = route; 294 ev->port = port; 295 ev->unplug = unplug; 296 queue_work(tb->wq, &ev->work); 297 } 298 299 /** 300 * thunderbolt_shutdown_and_free() - shutdown everything 301 * 302 * Free all switches and the config channel. 303 * 304 * Used in the error path of thunderbolt_alloc_and_start. 305 */ 306 void thunderbolt_shutdown_and_free(struct tb *tb) 307 { 308 struct tb_pci_tunnel *tunnel; 309 struct tb_pci_tunnel *n; 310 311 mutex_lock(&tb->lock); 312 313 /* tunnels are only present after everything has been initialized */ 314 list_for_each_entry_safe(tunnel, n, &tb->tunnel_list, list) { 315 tb_pci_deactivate(tunnel); 316 tb_pci_free(tunnel); 317 } 318 319 if (tb->root_switch) 320 tb_switch_free(tb->root_switch); 321 tb->root_switch = NULL; 322 323 if (tb->ctl) { 324 tb_ctl_stop(tb->ctl); 325 tb_ctl_free(tb->ctl); 326 } 327 tb->ctl = NULL; 328 tb->hotplug_active = false; /* signal tb_handle_hotplug to quit */ 329 330 /* allow tb_handle_hotplug to acquire the lock */ 331 mutex_unlock(&tb->lock); 332 if (tb->wq) { 333 flush_workqueue(tb->wq); 334 destroy_workqueue(tb->wq); 335 tb->wq = NULL; 336 } 337 mutex_destroy(&tb->lock); 338 kfree(tb); 339 } 340 341 /** 342 * thunderbolt_alloc_and_start() - setup the thunderbolt bus 343 * 344 * Allocates a tb_cfg control channel, initializes the root switch, enables 345 * plug events and activates pci devices. 346 * 347 * Return: Returns NULL on error. 348 */ 349 struct tb *thunderbolt_alloc_and_start(struct tb_nhi *nhi) 350 { 351 struct tb *tb; 352 353 BUILD_BUG_ON(sizeof(struct tb_regs_switch_header) != 5 * 4); 354 BUILD_BUG_ON(sizeof(struct tb_regs_port_header) != 8 * 4); 355 BUILD_BUG_ON(sizeof(struct tb_regs_hop) != 2 * 4); 356 357 tb = kzalloc(sizeof(*tb), GFP_KERNEL); 358 if (!tb) 359 return NULL; 360 361 tb->nhi = nhi; 362 mutex_init(&tb->lock); 363 mutex_lock(&tb->lock); 364 INIT_LIST_HEAD(&tb->tunnel_list); 365 366 tb->wq = alloc_ordered_workqueue("thunderbolt", 0); 367 if (!tb->wq) 368 goto err_locked; 369 370 tb->ctl = tb_ctl_alloc(tb->nhi, tb_schedule_hotplug_handler, tb); 371 if (!tb->ctl) 372 goto err_locked; 373 /* 374 * tb_schedule_hotplug_handler may be called as soon as the config 375 * channel is started. Thats why we have to hold the lock here. 376 */ 377 tb_ctl_start(tb->ctl); 378 379 tb->root_switch = tb_switch_alloc(tb, 0); 380 if (!tb->root_switch) 381 goto err_locked; 382 383 /* Full scan to discover devices added before the driver was loaded. */ 384 tb_scan_switch(tb->root_switch); 385 tb_activate_pcie_devices(tb); 386 387 /* Allow tb_handle_hotplug to progress events */ 388 tb->hotplug_active = true; 389 mutex_unlock(&tb->lock); 390 return tb; 391 392 err_locked: 393 mutex_unlock(&tb->lock); 394 thunderbolt_shutdown_and_free(tb); 395 return NULL; 396 } 397 398 void thunderbolt_suspend(struct tb *tb) 399 { 400 tb_info(tb, "suspending...\n"); 401 mutex_lock(&tb->lock); 402 tb_switch_suspend(tb->root_switch); 403 tb_ctl_stop(tb->ctl); 404 tb->hotplug_active = false; /* signal tb_handle_hotplug to quit */ 405 mutex_unlock(&tb->lock); 406 tb_info(tb, "suspend finished\n"); 407 } 408 409 void thunderbolt_resume(struct tb *tb) 410 { 411 struct tb_pci_tunnel *tunnel, *n; 412 tb_info(tb, "resuming...\n"); 413 mutex_lock(&tb->lock); 414 tb_ctl_start(tb->ctl); 415 416 /* remove any pci devices the firmware might have setup */ 417 tb_switch_reset(tb, 0); 418 419 tb_switch_resume(tb->root_switch); 420 tb_free_invalid_tunnels(tb); 421 tb_free_unplugged_children(tb->root_switch); 422 list_for_each_entry_safe(tunnel, n, &tb->tunnel_list, list) 423 tb_pci_restart(tunnel); 424 if (!list_empty(&tb->tunnel_list)) { 425 /* 426 * the pcie links need some time to get going. 427 * 100ms works for me... 428 */ 429 tb_info(tb, "tunnels restarted, sleeping for 100ms\n"); 430 msleep(100); 431 } 432 /* Allow tb_handle_hotplug to progress events */ 433 tb->hotplug_active = true; 434 mutex_unlock(&tb->lock); 435 tb_info(tb, "resume finished\n"); 436 } 437