drivers/thunderbolt/tb.c

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