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