drivers/thunderbolt/switch.c

   1 /*
   2  * Thunderbolt Cactus Ridge driver - switch/port utility functions
   3  *
   4  * Copyright (c) 2014 Andreas Noever <andreas.noever@gmail.com>
   5  */
   6
   7 #include <linux/delay.h>
   8
   9 #include "tb.h"
  10
  11 /* port utility functions */
  12
  13 static const char *tb_port_type(struct tb_regs_port_header *port)
  14 {
  15         switch (port->type >> 16) {
  16         case 0:
  17                 switch ((u8) port->type) {
  18                 case 0:
  19                         return "Inactive";
  20                 case 1:
  21                         return "Port";
  22                 case 2:
  23                         return "NHI";
  24                 default:
  25                         return "unknown";
  26                 }
  27         case 0x2:
  28                 return "Ethernet";
  29         case 0x8:
  30                 return "SATA";
  31         case 0xe:
  32                 return "DP/HDMI";
  33         case 0x10:
  34                 return "PCIe";
  35         case 0x20:
  36                 return "USB";
  37         default:
  38                 return "unknown";
  39         }
  40 }
  41
  42 static void tb_dump_port(struct tb *tb, struct tb_regs_port_header *port)
  43 {
  44         tb_info(tb,
  45                 " Port %d: %x:%x (Revision: %d, TB Version: %d, Type: %s (%#x))\n",
  46                 port->port_number, port->vendor_id, port->device_id,
  47                 port->revision, port->thunderbolt_version, tb_port_type(port),
  48                 port->type);
  49         tb_info(tb, "  Max hop id (in/out): %d/%d\n",
  50                 port->max_in_hop_id, port->max_out_hop_id);
  51         tb_info(tb, "  Max counters: %d\n", port->max_counters);
  52         tb_info(tb, "  NFC Credits: %#x\n", port->nfc_credits);
  53 }
  54
  55 /**
  56  * tb_port_state() - get connectedness state of a port
  57  *
  58  * The port must have a TB_CAP_PHY (i.e. it should be a real port).
  59  *
  60  * Return: Returns an enum tb_port_state on success or an error code on failure.
  61  */
  62 static int tb_port_state(struct tb_port *port)
  63 {
  64         struct tb_cap_phy phy;
  65         int res;
  66         if (port->cap_phy == 0) {
  67                 tb_port_WARN(port, "does not have a PHY\n");
  68                 return -EINVAL;
  69         }
  70         res = tb_port_read(port, &phy, TB_CFG_PORT, port->cap_phy, 2);
  71         if (res)
  72                 return res;
  73         return phy.state;
  74 }
  75
  76 /**
  77  * tb_wait_for_port() - wait for a port to become ready
  78  *
  79  * Wait up to 1 second for a port to reach state TB_PORT_UP. If
  80  * wait_if_unplugged is set then we also wait if the port is in state
  81  * TB_PORT_UNPLUGGED (it takes a while for the device to be registered after
  82  * switch resume). Otherwise we only wait if a device is registered but the link
  83  * has not yet been established.
  84  *
  85  * Return: Returns an error code on failure. Returns 0 if the port is not
  86  * connected or failed to reach state TB_PORT_UP within one second. Returns 1
  87  * if the port is connected and in state TB_PORT_UP.
  88  */
  89 int tb_wait_for_port(struct tb_port *port, bool wait_if_unplugged)
  90 {
  91         int retries = 10;
  92         int state;
  93         if (!port->cap_phy) {
  94                 tb_port_WARN(port, "does not have PHY\n");
  95                 return -EINVAL;
  96         }
  97         if (tb_is_upstream_port(port)) {
  98                 tb_port_WARN(port, "is the upstream port\n");
  99                 return -EINVAL;
 100         }
 101
 102         while (retries--) {
 103                 state = tb_port_state(port);
 104                 if (state < 0)
 105                         return state;
 106                 if (state == TB_PORT_DISABLED) {
 107                         tb_port_info(port, "is disabled (state: 0)\n");
 108                         return 0;
 109                 }
 110                 if (state == TB_PORT_UNPLUGGED) {
 111                         if (wait_if_unplugged) {
 112                                 /* used during resume */
 113                                 tb_port_info(port,
 114                                              "is unplugged (state: 7), retrying...\n");
 115                                 msleep(100);
 116                                 continue;
 117                         }
 118                         tb_port_info(port, "is unplugged (state: 7)\n");
 119                         return 0;
 120                 }
 121                 if (state == TB_PORT_UP) {
 122                         tb_port_info(port,
 123                                      "is connected, link is up (state: 2)\n");
 124                         return 1;
 125                 }
 126
 127                 /*
 128                  * After plug-in the state is TB_PORT_CONNECTING. Give it some
 129                  * time.
 130                  */
 131                 tb_port_info(port,
 132                              "is connected, link is not up (state: %d), retrying...\n",
 133                              state);
 134                 msleep(100);
 135         }
 136         tb_port_warn(port,
 137                      "failed to reach state TB_PORT_UP. Ignoring port...\n");
 138         return 0;
 139 }
 140
 141 /**
 142  * tb_port_add_nfc_credits() - add/remove non flow controlled credits to port
 143  *
 144  * Change the number of NFC credits allocated to @port by @credits. To remove
 145  * NFC credits pass a negative amount of credits.
 146  *
 147  * Return: Returns 0 on success or an error code on failure.
 148  */
 149 int tb_port_add_nfc_credits(struct tb_port *port, int credits)
 150 {
 151         if (credits == 0)
 152                 return 0;
 153         tb_port_info(port,
 154                      "adding %#x NFC credits (%#x -> %#x)",
 155                      credits,
 156                      port->config.nfc_credits,
 157                      port->config.nfc_credits + credits);
 158         port->config.nfc_credits += credits;
 159         return tb_port_write(port, &port->config.nfc_credits,
 160                              TB_CFG_PORT, 4, 1);
 161 }
 162
 163 /**
 164  * tb_port_clear_counter() - clear a counter in TB_CFG_COUNTER
 165  *
 166  * Return: Returns 0 on success or an error code on failure.
 167  */
 168 int tb_port_clear_counter(struct tb_port *port, int counter)
 169 {
 170         u32 zero[3] = { 0, 0, 0 };
 171         tb_port_info(port, "clearing counter %d\n", counter);
 172         return tb_port_write(port, zero, TB_CFG_COUNTERS, 3 * counter, 3);
 173 }
 174
 175 /**
 176  * tb_init_port() - initialize a port
 177  *
 178  * This is a helper method for tb_switch_alloc. Does not check or initialize
 179  * any downstream switches.
 180  *
 181  * Return: Returns 0 on success or an error code on failure.
 182  */
 183 static int tb_init_port(struct tb_switch *sw, u8 port_nr)
 184 {
 185         int res;
 186         int cap;
 187         struct tb_port *port = &sw->ports[port_nr];
 188         port->sw = sw;
 189         port->port = port_nr;
 190         port->remote = NULL;
 191         res = tb_port_read(port, &port->config, TB_CFG_PORT, 0, 8);
 192         if (res)
 193                 return res;
 194
 195         /* Port 0 is the switch itself and has no PHY. */
 196         if (port->config.type == TB_TYPE_PORT && port_nr != 0) {
 197                 cap = tb_find_cap(port, TB_CFG_PORT, TB_CAP_PHY);
 198
 199                 if (cap > 0)
 200                         port->cap_phy = cap;
 201                 else
 202                         tb_port_WARN(port, "non switch port without a PHY\n");
 203         }
 204
 205         tb_dump_port(sw->tb, &port->config);
 206
 207         /* TODO: Read dual link port, DP port and more from EEPROM. */
 208         return 0;
 209
 210 }
 211
 212 /* switch utility functions */
 213
 214 static void tb_dump_switch(struct tb *tb, struct tb_regs_switch_header *sw)
 215 {
 216         tb_info(tb,
 217                 " Switch: %x:%x (Revision: %d, TB Version: %d)\n",
 218                 sw->vendor_id, sw->device_id, sw->revision,
 219                 sw->thunderbolt_version);
 220         tb_info(tb, "  Max Port Number: %d\n", sw->max_port_number);
 221         tb_info(tb, "  Config:\n");
 222         tb_info(tb,
 223                 "   Upstream Port Number: %d Depth: %d Route String: %#llx Enabled: %d, PlugEventsDelay: %dms\n",
 224                 sw->upstream_port_number, sw->depth,
 225                 (((u64) sw->route_hi) << 32) | sw->route_lo,
 226                 sw->enabled, sw->plug_events_delay);
 227         tb_info(tb,
 228                 "   unknown1: %#x unknown4: %#x\n",
 229                 sw->__unknown1, sw->__unknown4);
 230 }
 231
 232 /**
 233  * reset_switch() - reconfigure route, enable and send TB_CFG_PKG_RESET
 234  *
 235  * Return: Returns 0 on success or an error code on failure.
 236  */
 237 int tb_switch_reset(struct tb *tb, u64 route)
 238 {
 239         struct tb_cfg_result res;
 240         struct tb_regs_switch_header header = {
 241                 header.route_hi = route >> 32,
 242                 header.route_lo = route,
 243                 header.enabled = true,
 244         };
 245         tb_info(tb, "resetting switch at %llx\n", route);
 246         res.err = tb_cfg_write(tb->ctl, ((u32 *) &header) + 2, route,
 247                         0, 2, 2, 2);
 248         if (res.err)
 249                 return res.err;
 250         res = tb_cfg_reset(tb->ctl, route, TB_CFG_DEFAULT_TIMEOUT);
 251         if (res.err > 0)
 252                 return -EIO;
 253         return res.err;
 254 }
 255
 256 struct tb_switch *get_switch_at_route(struct tb_switch *sw, u64 route)
 257 {
 258         u8 next_port = route; /*
 259                                * Routes use a stride of 8 bits,
 260                                * eventhough a port index has 6 bits at most.
 261                                * */
 262         if (route == 0)
 263                 return sw;
 264         if (next_port > sw->config.max_port_number)
 265                 return 0;
 266         if (tb_is_upstream_port(&sw->ports[next_port]))
 267                 return 0;
 268         if (!sw->ports[next_port].remote)
 269                 return 0;
 270         return get_switch_at_route(sw->ports[next_port].remote->sw,
 271                                    route >> TB_ROUTE_SHIFT);
 272 }
 273
 274 /**
 275  * tb_plug_events_active() - enable/disable plug events on a switch
 276  *
 277  * Also configures a sane plug_events_delay of 255ms.
 278  *
 279  * Return: Returns 0 on success or an error code on failure.
 280  */
 281 static int tb_plug_events_active(struct tb_switch *sw, bool active)
 282 {
 283         u32 data;
 284         int res;
 285
 286         sw->config.plug_events_delay = 0xff;
 287         res = tb_sw_write(sw, ((u32 *) &sw->config) + 4, TB_CFG_SWITCH, 4, 1);
 288         if (res)
 289                 return res;
 290
 291         res = tb_sw_read(sw, &data, TB_CFG_SWITCH, sw->cap_plug_events + 1, 1);
 292         if (res)
 293                 return res;
 294
 295         if (active) {
 296                 data = data & 0xFFFFFF83;
 297                 switch (sw->config.device_id) {
 298                 case 0x1513:
 299                 case 0x151a:
 300                 case 0x1549:
 301                         break;
 302                 default:
 303                         data |= 4;
 304                 }
 305         } else {
 306                 data = data | 0x7c;
 307         }
 308         return tb_sw_write(sw, &data, TB_CFG_SWITCH,
 309                            sw->cap_plug_events + 1, 1);
 310 }
 311
 312
 313 /**
 314  * tb_switch_free() - free a tb_switch and all downstream switches
 315  */
 316 void tb_switch_free(struct tb_switch *sw)
 317 {
 318         int i;
 319         /* port 0 is the switch itself and never has a remote */
 320         for (i = 1; i <= sw->config.max_port_number; i++) {
 321                 if (tb_is_upstream_port(&sw->ports[i]))
 322                         continue;
 323                 if (sw->ports[i].remote)
 324                         tb_switch_free(sw->ports[i].remote->sw);
 325                 sw->ports[i].remote = NULL;
 326         }
 327
 328         if (!sw->is_unplugged)
 329                 tb_plug_events_active(sw, false);
 330
 331         kfree(sw->ports);
 332         kfree(sw);
 333 }
 334
 335 /**
 336  * tb_switch_alloc() - allocate and initialize a switch
 337  *
 338  * Return: Returns a NULL on failure.
 339  */
 340 struct tb_switch *tb_switch_alloc(struct tb *tb, u64 route)
 341 {
 342         int i;
 343         int cap;
 344         struct tb_switch *sw;
 345         int upstream_port = tb_cfg_get_upstream_port(tb->ctl, route);
 346         if (upstream_port < 0)
 347                 return NULL;
 348
 349         sw = kzalloc(sizeof(*sw), GFP_KERNEL);
 350         if (!sw)
 351                 return NULL;
 352
 353         sw->tb = tb;
 354         if (tb_cfg_read(tb->ctl, &sw->config, route, 0, 2, 0, 5))
 355                 goto err;
 356         tb_info(tb,
 357                 "initializing Switch at %#llx (depth: %d, up port: %d)\n",
 358                 route, tb_route_length(route), upstream_port);
 359         tb_info(tb, "old switch config:\n");
 360         tb_dump_switch(tb, &sw->config);
 361
 362         /* configure switch */
 363         sw->config.upstream_port_number = upstream_port;
 364         sw->config.depth = tb_route_length(route);
 365         sw->config.route_lo = route;
 366         sw->config.route_hi = route >> 32;
 367         sw->config.enabled = 1;
 368         /* from here on we may use the tb_sw_* functions & macros */
 369
 370         if (sw->config.vendor_id != 0x8086)
 371                 tb_sw_warn(sw, "unknown switch vendor id %#x\n",
 372                            sw->config.vendor_id);
 373
 374         if (sw->config.device_id != 0x1547 && sw->config.device_id != 0x1549)
 375                 tb_sw_warn(sw, "unsupported switch device id %#x\n",
 376                            sw->config.device_id);
 377
 378         /* upload configuration */
 379         if (tb_sw_write(sw, 1 + (u32 *) &sw->config, TB_CFG_SWITCH, 1, 3))
 380                 goto err;
 381
 382         /* initialize ports */
 383         sw->ports = kcalloc(sw->config.max_port_number + 1, sizeof(*sw->ports),
 384         GFP_KERNEL);
 385         if (!sw->ports)
 386                 goto err;
 387
 388         for (i = 0; i <= sw->config.max_port_number; i++) {
 389                 if (tb_init_port(sw, i))
 390                         goto err;
 391                 /* TODO: check if port is disabled (EEPROM) */
 392         }
 393
 394         /* TODO: I2C, IECS, EEPROM, link controller */
 395
 396         cap = tb_find_cap(&sw->ports[0], TB_CFG_SWITCH, TB_CAP_PLUG_EVENTS);
 397         if (cap < 0) {
 398                 tb_sw_warn(sw, "cannot find TB_CAP_PLUG_EVENTS aborting\n");
 399                 goto err;
 400         }
 401         sw->cap_plug_events = cap;
 402
 403         if (tb_eeprom_read_uid(sw, &sw->uid))
 404                 tb_sw_warn(sw, "could not read uid from eeprom\n");
 405         else
 406                 tb_sw_info(sw, "uid: %#llx\n", sw->uid);
 407
 408         if (tb_plug_events_active(sw, true))
 409                 goto err;
 410
 411         return sw;
 412 err:
 413         kfree(sw->ports);
 414         kfree(sw);
 415         return NULL;
 416 }
 417
 418 /**
 419  * tb_sw_set_unpplugged() - set is_unplugged on switch and downstream switches
 420  */
 421 void tb_sw_set_unpplugged(struct tb_switch *sw)
 422 {
 423         int i;
 424         if (sw == sw->tb->root_switch) {
 425                 tb_sw_WARN(sw, "cannot unplug root switch\n");
 426                 return;
 427         }
 428         if (sw->is_unplugged) {
 429                 tb_sw_WARN(sw, "is_unplugged already set\n");
 430                 return;
 431         }
 432         sw->is_unplugged = true;
 433         for (i = 0; i <= sw->config.max_port_number; i++) {
 434                 if (!tb_is_upstream_port(&sw->ports[i]) && sw->ports[i].remote)
 435                         tb_sw_set_unpplugged(sw->ports[i].remote->sw);
 436         }
 437 }
 438
 439 int tb_switch_resume(struct tb_switch *sw)
 440 {
 441         int i, err;
 442         u64 uid;
 443         tb_sw_info(sw, "resuming switch\n");
 444
 445         err = tb_eeprom_read_uid(sw, &uid);
 446         if (err) {
 447                 tb_sw_warn(sw, "uid read failed\n");
 448                 return err;
 449         }
 450         if (sw->uid != uid) {
 451                 tb_sw_info(sw,
 452                         "changed while suspended (uid %#llx -> %#llx)\n",
 453                         sw->uid, uid);
 454                 return -ENODEV;
 455         }
 456
 457         /* upload configuration */
 458         err = tb_sw_write(sw, 1 + (u32 *) &sw->config, TB_CFG_SWITCH, 1, 3);
 459         if (err)
 460                 return err;
 461
 462         err = tb_plug_events_active(sw, true);
 463         if (err)
 464                 return err;
 465
 466         /* check for surviving downstream switches */
 467         for (i = 1; i <= sw->config.max_port_number; i++) {
 468                 struct tb_port *port = &sw->ports[i];
 469                 if (tb_is_upstream_port(port))
 470                         continue;
 471                 if (!port->remote)
 472                         continue;
 473                 if (tb_wait_for_port(port, true) <= 0
 474                         || tb_switch_resume(port->remote->sw)) {
 475                         tb_port_warn(port,
 476                                      "lost during suspend, disconnecting\n");
 477                         tb_sw_set_unpplugged(port->remote->sw);
 478                 }
 479         }
 480         return 0;
 481 }
 482
 483 void tb_switch_suspend(struct tb_switch *sw)
 484 {
 485         int i, err;
 486         err = tb_plug_events_active(sw, false);
 487         if (err)
 488                 return;
 489
 490         for (i = 1; i <= sw->config.max_port_number; i++) {
 491                 if (!tb_is_upstream_port(&sw->ports[i]) && sw->ports[i].remote)
 492                         tb_switch_suspend(sw->ports[i].remote->sw);
 493         }
 494         /*
 495          * TODO: invoke tb_cfg_prepare_to_sleep here? does not seem to have any
 496          * effect?
 497          */
 498 }