1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Thunderbolt driver - switch/port utility functions 4 * 5 * Copyright (c) 2014 Andreas Noever <andreas.noever@gmail.com> 6 * Copyright (C) 2018, Intel Corporation 7 */ 8 9 #include <linux/delay.h> 10 #include <linux/idr.h> 11 #include <linux/nvmem-provider.h> 12 #include <linux/pm_runtime.h> 13 #include <linux/sched/signal.h> 14 #include <linux/sizes.h> 15 #include <linux/slab.h> 16 #include <linux/vmalloc.h> 17 18 #include "tb.h" 19 20 /* Switch NVM support */ 21 22 #define NVM_DEVID 0x05 23 #define NVM_VERSION 0x08 24 #define NVM_CSS 0x10 25 #define NVM_FLASH_SIZE 0x45 26 27 #define NVM_MIN_SIZE SZ_32K 28 #define NVM_MAX_SIZE SZ_512K 29 30 static DEFINE_IDA(nvm_ida); 31 32 struct nvm_auth_status { 33 struct list_head list; 34 uuid_t uuid; 35 u32 status; 36 }; 37 38 /* 39 * Hold NVM authentication failure status per switch This information 40 * needs to stay around even when the switch gets power cycled so we 41 * keep it separately. 42 */ 43 static LIST_HEAD(nvm_auth_status_cache); 44 static DEFINE_MUTEX(nvm_auth_status_lock); 45 46 static struct nvm_auth_status *__nvm_get_auth_status(const struct tb_switch *sw) 47 { 48 struct nvm_auth_status *st; 49 50 list_for_each_entry(st, &nvm_auth_status_cache, list) { 51 if (uuid_equal(&st->uuid, sw->uuid)) 52 return st; 53 } 54 55 return NULL; 56 } 57 58 static void nvm_get_auth_status(const struct tb_switch *sw, u32 *status) 59 { 60 struct nvm_auth_status *st; 61 62 mutex_lock(&nvm_auth_status_lock); 63 st = __nvm_get_auth_status(sw); 64 mutex_unlock(&nvm_auth_status_lock); 65 66 *status = st ? st->status : 0; 67 } 68 69 static void nvm_set_auth_status(const struct tb_switch *sw, u32 status) 70 { 71 struct nvm_auth_status *st; 72 73 if (WARN_ON(!sw->uuid)) 74 return; 75 76 mutex_lock(&nvm_auth_status_lock); 77 st = __nvm_get_auth_status(sw); 78 79 if (!st) { 80 st = kzalloc(sizeof(*st), GFP_KERNEL); 81 if (!st) 82 goto unlock; 83 84 memcpy(&st->uuid, sw->uuid, sizeof(st->uuid)); 85 INIT_LIST_HEAD(&st->list); 86 list_add_tail(&st->list, &nvm_auth_status_cache); 87 } 88 89 st->status = status; 90 unlock: 91 mutex_unlock(&nvm_auth_status_lock); 92 } 93 94 static void nvm_clear_auth_status(const struct tb_switch *sw) 95 { 96 struct nvm_auth_status *st; 97 98 mutex_lock(&nvm_auth_status_lock); 99 st = __nvm_get_auth_status(sw); 100 if (st) { 101 list_del(&st->list); 102 kfree(st); 103 } 104 mutex_unlock(&nvm_auth_status_lock); 105 } 106 107 static int nvm_validate_and_write(struct tb_switch *sw) 108 { 109 unsigned int image_size, hdr_size; 110 const u8 *buf = sw->nvm->buf; 111 u16 ds_size; 112 int ret; 113 114 if (!buf) 115 return -EINVAL; 116 117 image_size = sw->nvm->buf_data_size; 118 if (image_size < NVM_MIN_SIZE || image_size > NVM_MAX_SIZE) 119 return -EINVAL; 120 121 /* 122 * FARB pointer must point inside the image and must at least 123 * contain parts of the digital section we will be reading here. 124 */ 125 hdr_size = (*(u32 *)buf) & 0xffffff; 126 if (hdr_size + NVM_DEVID + 2 >= image_size) 127 return -EINVAL; 128 129 /* Digital section start should be aligned to 4k page */ 130 if (!IS_ALIGNED(hdr_size, SZ_4K)) 131 return -EINVAL; 132 133 /* 134 * Read digital section size and check that it also fits inside 135 * the image. 136 */ 137 ds_size = *(u16 *)(buf + hdr_size); 138 if (ds_size >= image_size) 139 return -EINVAL; 140 141 if (!sw->safe_mode) { 142 u16 device_id; 143 144 /* 145 * Make sure the device ID in the image matches the one 146 * we read from the switch config space. 147 */ 148 device_id = *(u16 *)(buf + hdr_size + NVM_DEVID); 149 if (device_id != sw->config.device_id) 150 return -EINVAL; 151 152 if (sw->generation < 3) { 153 /* Write CSS headers first */ 154 ret = dma_port_flash_write(sw->dma_port, 155 DMA_PORT_CSS_ADDRESS, buf + NVM_CSS, 156 DMA_PORT_CSS_MAX_SIZE); 157 if (ret) 158 return ret; 159 } 160 161 /* Skip headers in the image */ 162 buf += hdr_size; 163 image_size -= hdr_size; 164 } 165 166 if (tb_switch_is_usb4(sw)) 167 return usb4_switch_nvm_write(sw, 0, buf, image_size); 168 return dma_port_flash_write(sw->dma_port, 0, buf, image_size); 169 } 170 171 static int nvm_authenticate_host_dma_port(struct tb_switch *sw) 172 { 173 int ret = 0; 174 175 /* 176 * Root switch NVM upgrade requires that we disconnect the 177 * existing paths first (in case it is not in safe mode 178 * already). 179 */ 180 if (!sw->safe_mode) { 181 u32 status; 182 183 ret = tb_domain_disconnect_all_paths(sw->tb); 184 if (ret) 185 return ret; 186 /* 187 * The host controller goes away pretty soon after this if 188 * everything goes well so getting timeout is expected. 189 */ 190 ret = dma_port_flash_update_auth(sw->dma_port); 191 if (!ret || ret == -ETIMEDOUT) 192 return 0; 193 194 /* 195 * Any error from update auth operation requires power 196 * cycling of the host router. 197 */ 198 tb_sw_warn(sw, "failed to authenticate NVM, power cycling\n"); 199 if (dma_port_flash_update_auth_status(sw->dma_port, &status) > 0) 200 nvm_set_auth_status(sw, status); 201 } 202 203 /* 204 * From safe mode we can get out by just power cycling the 205 * switch. 206 */ 207 dma_port_power_cycle(sw->dma_port); 208 return ret; 209 } 210 211 static int nvm_authenticate_device_dma_port(struct tb_switch *sw) 212 { 213 int ret, retries = 10; 214 215 ret = dma_port_flash_update_auth(sw->dma_port); 216 switch (ret) { 217 case 0: 218 case -ETIMEDOUT: 219 case -EACCES: 220 case -EINVAL: 221 /* Power cycle is required */ 222 break; 223 default: 224 return ret; 225 } 226 227 /* 228 * Poll here for the authentication status. It takes some time 229 * for the device to respond (we get timeout for a while). Once 230 * we get response the device needs to be power cycled in order 231 * to the new NVM to be taken into use. 232 */ 233 do { 234 u32 status; 235 236 ret = dma_port_flash_update_auth_status(sw->dma_port, &status); 237 if (ret < 0 && ret != -ETIMEDOUT) 238 return ret; 239 if (ret > 0) { 240 if (status) { 241 tb_sw_warn(sw, "failed to authenticate NVM\n"); 242 nvm_set_auth_status(sw, status); 243 } 244 245 tb_sw_info(sw, "power cycling the switch now\n"); 246 dma_port_power_cycle(sw->dma_port); 247 return 0; 248 } 249 250 msleep(500); 251 } while (--retries); 252 253 return -ETIMEDOUT; 254 } 255 256 static void nvm_authenticate_start_dma_port(struct tb_switch *sw) 257 { 258 struct pci_dev *root_port; 259 260 /* 261 * During host router NVM upgrade we should not allow root port to 262 * go into D3cold because some root ports cannot trigger PME 263 * itself. To be on the safe side keep the root port in D0 during 264 * the whole upgrade process. 265 */ 266 root_port = pcie_find_root_port(sw->tb->nhi->pdev); 267 if (root_port) 268 pm_runtime_get_noresume(&root_port->dev); 269 } 270 271 static void nvm_authenticate_complete_dma_port(struct tb_switch *sw) 272 { 273 struct pci_dev *root_port; 274 275 root_port = pcie_find_root_port(sw->tb->nhi->pdev); 276 if (root_port) 277 pm_runtime_put(&root_port->dev); 278 } 279 280 static inline bool nvm_readable(struct tb_switch *sw) 281 { 282 if (tb_switch_is_usb4(sw)) { 283 /* 284 * USB4 devices must support NVM operations but it is 285 * optional for hosts. Therefore we query the NVM sector 286 * size here and if it is supported assume NVM 287 * operations are implemented. 288 */ 289 return usb4_switch_nvm_sector_size(sw) > 0; 290 } 291 292 /* Thunderbolt 2 and 3 devices support NVM through DMA port */ 293 return !!sw->dma_port; 294 } 295 296 static inline bool nvm_upgradeable(struct tb_switch *sw) 297 { 298 if (sw->no_nvm_upgrade) 299 return false; 300 return nvm_readable(sw); 301 } 302 303 static inline int nvm_read(struct tb_switch *sw, unsigned int address, 304 void *buf, size_t size) 305 { 306 if (tb_switch_is_usb4(sw)) 307 return usb4_switch_nvm_read(sw, address, buf, size); 308 return dma_port_flash_read(sw->dma_port, address, buf, size); 309 } 310 311 static int nvm_authenticate(struct tb_switch *sw) 312 { 313 int ret; 314 315 if (tb_switch_is_usb4(sw)) 316 return usb4_switch_nvm_authenticate(sw); 317 318 if (!tb_route(sw)) { 319 nvm_authenticate_start_dma_port(sw); 320 ret = nvm_authenticate_host_dma_port(sw); 321 } else { 322 ret = nvm_authenticate_device_dma_port(sw); 323 } 324 325 return ret; 326 } 327 328 static int tb_switch_nvm_read(void *priv, unsigned int offset, void *val, 329 size_t bytes) 330 { 331 struct tb_switch *sw = priv; 332 int ret; 333 334 pm_runtime_get_sync(&sw->dev); 335 336 if (!mutex_trylock(&sw->tb->lock)) { 337 ret = restart_syscall(); 338 goto out; 339 } 340 341 ret = nvm_read(sw, offset, val, bytes); 342 mutex_unlock(&sw->tb->lock); 343 344 out: 345 pm_runtime_mark_last_busy(&sw->dev); 346 pm_runtime_put_autosuspend(&sw->dev); 347 348 return ret; 349 } 350 351 static int tb_switch_nvm_write(void *priv, unsigned int offset, void *val, 352 size_t bytes) 353 { 354 struct tb_switch *sw = priv; 355 int ret = 0; 356 357 if (!mutex_trylock(&sw->tb->lock)) 358 return restart_syscall(); 359 360 /* 361 * Since writing the NVM image might require some special steps, 362 * for example when CSS headers are written, we cache the image 363 * locally here and handle the special cases when the user asks 364 * us to authenticate the image. 365 */ 366 if (!sw->nvm->buf) { 367 sw->nvm->buf = vmalloc(NVM_MAX_SIZE); 368 if (!sw->nvm->buf) { 369 ret = -ENOMEM; 370 goto unlock; 371 } 372 } 373 374 sw->nvm->buf_data_size = offset + bytes; 375 memcpy(sw->nvm->buf + offset, val, bytes); 376 377 unlock: 378 mutex_unlock(&sw->tb->lock); 379 380 return ret; 381 } 382 383 static struct nvmem_device *register_nvmem(struct tb_switch *sw, int id, 384 size_t size, bool active) 385 { 386 struct nvmem_config config; 387 388 memset(&config, 0, sizeof(config)); 389 390 if (active) { 391 config.name = "nvm_active"; 392 config.reg_read = tb_switch_nvm_read; 393 config.read_only = true; 394 } else { 395 config.name = "nvm_non_active"; 396 config.reg_write = tb_switch_nvm_write; 397 config.root_only = true; 398 } 399 400 config.id = id; 401 config.stride = 4; 402 config.word_size = 4; 403 config.size = size; 404 config.dev = &sw->dev; 405 config.owner = THIS_MODULE; 406 config.priv = sw; 407 408 return nvmem_register(&config); 409 } 410 411 static int tb_switch_nvm_add(struct tb_switch *sw) 412 { 413 struct nvmem_device *nvm_dev; 414 struct tb_switch_nvm *nvm; 415 u32 val; 416 int ret; 417 418 if (!nvm_readable(sw)) 419 return 0; 420 421 /* 422 * The NVM format of non-Intel hardware is not known so 423 * currently restrict NVM upgrade for Intel hardware. We may 424 * relax this in the future when we learn other NVM formats. 425 */ 426 if (sw->config.vendor_id != PCI_VENDOR_ID_INTEL) { 427 dev_info(&sw->dev, 428 "NVM format of vendor %#x is not known, disabling NVM upgrade\n", 429 sw->config.vendor_id); 430 return 0; 431 } 432 433 nvm = kzalloc(sizeof(*nvm), GFP_KERNEL); 434 if (!nvm) 435 return -ENOMEM; 436 437 nvm->id = ida_simple_get(&nvm_ida, 0, 0, GFP_KERNEL); 438 439 /* 440 * If the switch is in safe-mode the only accessible portion of 441 * the NVM is the non-active one where userspace is expected to 442 * write new functional NVM. 443 */ 444 if (!sw->safe_mode) { 445 u32 nvm_size, hdr_size; 446 447 ret = nvm_read(sw, NVM_FLASH_SIZE, &val, sizeof(val)); 448 if (ret) 449 goto err_ida; 450 451 hdr_size = sw->generation < 3 ? SZ_8K : SZ_16K; 452 nvm_size = (SZ_1M << (val & 7)) / 8; 453 nvm_size = (nvm_size - hdr_size) / 2; 454 455 ret = nvm_read(sw, NVM_VERSION, &val, sizeof(val)); 456 if (ret) 457 goto err_ida; 458 459 nvm->major = val >> 16; 460 nvm->minor = val >> 8; 461 462 nvm_dev = register_nvmem(sw, nvm->id, nvm_size, true); 463 if (IS_ERR(nvm_dev)) { 464 ret = PTR_ERR(nvm_dev); 465 goto err_ida; 466 } 467 nvm->active = nvm_dev; 468 } 469 470 if (!sw->no_nvm_upgrade) { 471 nvm_dev = register_nvmem(sw, nvm->id, NVM_MAX_SIZE, false); 472 if (IS_ERR(nvm_dev)) { 473 ret = PTR_ERR(nvm_dev); 474 goto err_nvm_active; 475 } 476 nvm->non_active = nvm_dev; 477 } 478 479 sw->nvm = nvm; 480 return 0; 481 482 err_nvm_active: 483 if (nvm->active) 484 nvmem_unregister(nvm->active); 485 err_ida: 486 ida_simple_remove(&nvm_ida, nvm->id); 487 kfree(nvm); 488 489 return ret; 490 } 491 492 static void tb_switch_nvm_remove(struct tb_switch *sw) 493 { 494 struct tb_switch_nvm *nvm; 495 496 nvm = sw->nvm; 497 sw->nvm = NULL; 498 499 if (!nvm) 500 return; 501 502 /* Remove authentication status in case the switch is unplugged */ 503 if (!nvm->authenticating) 504 nvm_clear_auth_status(sw); 505 506 if (nvm->non_active) 507 nvmem_unregister(nvm->non_active); 508 if (nvm->active) 509 nvmem_unregister(nvm->active); 510 ida_simple_remove(&nvm_ida, nvm->id); 511 vfree(nvm->buf); 512 kfree(nvm); 513 } 514 515 /* port utility functions */ 516 517 static const char *tb_port_type(struct tb_regs_port_header *port) 518 { 519 switch (port->type >> 16) { 520 case 0: 521 switch ((u8) port->type) { 522 case 0: 523 return "Inactive"; 524 case 1: 525 return "Port"; 526 case 2: 527 return "NHI"; 528 default: 529 return "unknown"; 530 } 531 case 0x2: 532 return "Ethernet"; 533 case 0x8: 534 return "SATA"; 535 case 0xe: 536 return "DP/HDMI"; 537 case 0x10: 538 return "PCIe"; 539 case 0x20: 540 return "USB"; 541 default: 542 return "unknown"; 543 } 544 } 545 546 static void tb_dump_port(struct tb *tb, struct tb_regs_port_header *port) 547 { 548 tb_dbg(tb, 549 " Port %d: %x:%x (Revision: %d, TB Version: %d, Type: %s (%#x))\n", 550 port->port_number, port->vendor_id, port->device_id, 551 port->revision, port->thunderbolt_version, tb_port_type(port), 552 port->type); 553 tb_dbg(tb, " Max hop id (in/out): %d/%d\n", 554 port->max_in_hop_id, port->max_out_hop_id); 555 tb_dbg(tb, " Max counters: %d\n", port->max_counters); 556 tb_dbg(tb, " NFC Credits: %#x\n", port->nfc_credits); 557 } 558 559 /** 560 * tb_port_state() - get connectedness state of a port 561 * 562 * The port must have a TB_CAP_PHY (i.e. it should be a real port). 563 * 564 * Return: Returns an enum tb_port_state on success or an error code on failure. 565 */ 566 static int tb_port_state(struct tb_port *port) 567 { 568 struct tb_cap_phy phy; 569 int res; 570 if (port->cap_phy == 0) { 571 tb_port_WARN(port, "does not have a PHY\n"); 572 return -EINVAL; 573 } 574 res = tb_port_read(port, &phy, TB_CFG_PORT, port->cap_phy, 2); 575 if (res) 576 return res; 577 return phy.state; 578 } 579 580 /** 581 * tb_wait_for_port() - wait for a port to become ready 582 * 583 * Wait up to 1 second for a port to reach state TB_PORT_UP. If 584 * wait_if_unplugged is set then we also wait if the port is in state 585 * TB_PORT_UNPLUGGED (it takes a while for the device to be registered after 586 * switch resume). Otherwise we only wait if a device is registered but the link 587 * has not yet been established. 588 * 589 * Return: Returns an error code on failure. Returns 0 if the port is not 590 * connected or failed to reach state TB_PORT_UP within one second. Returns 1 591 * if the port is connected and in state TB_PORT_UP. 592 */ 593 int tb_wait_for_port(struct tb_port *port, bool wait_if_unplugged) 594 { 595 int retries = 10; 596 int state; 597 if (!port->cap_phy) { 598 tb_port_WARN(port, "does not have PHY\n"); 599 return -EINVAL; 600 } 601 if (tb_is_upstream_port(port)) { 602 tb_port_WARN(port, "is the upstream port\n"); 603 return -EINVAL; 604 } 605 606 while (retries--) { 607 state = tb_port_state(port); 608 if (state < 0) 609 return state; 610 if (state == TB_PORT_DISABLED) { 611 tb_port_dbg(port, "is disabled (state: 0)\n"); 612 return 0; 613 } 614 if (state == TB_PORT_UNPLUGGED) { 615 if (wait_if_unplugged) { 616 /* used during resume */ 617 tb_port_dbg(port, 618 "is unplugged (state: 7), retrying...\n"); 619 msleep(100); 620 continue; 621 } 622 tb_port_dbg(port, "is unplugged (state: 7)\n"); 623 return 0; 624 } 625 if (state == TB_PORT_UP) { 626 tb_port_dbg(port, "is connected, link is up (state: 2)\n"); 627 return 1; 628 } 629 630 /* 631 * After plug-in the state is TB_PORT_CONNECTING. Give it some 632 * time. 633 */ 634 tb_port_dbg(port, 635 "is connected, link is not up (state: %d), retrying...\n", 636 state); 637 msleep(100); 638 } 639 tb_port_warn(port, 640 "failed to reach state TB_PORT_UP. Ignoring port...\n"); 641 return 0; 642 } 643 644 /** 645 * tb_port_add_nfc_credits() - add/remove non flow controlled credits to port 646 * 647 * Change the number of NFC credits allocated to @port by @credits. To remove 648 * NFC credits pass a negative amount of credits. 649 * 650 * Return: Returns 0 on success or an error code on failure. 651 */ 652 int tb_port_add_nfc_credits(struct tb_port *port, int credits) 653 { 654 u32 nfc_credits; 655 656 if (credits == 0 || port->sw->is_unplugged) 657 return 0; 658 659 nfc_credits = port->config.nfc_credits & ADP_CS_4_NFC_BUFFERS_MASK; 660 nfc_credits += credits; 661 662 tb_port_dbg(port, "adding %d NFC credits to %lu", credits, 663 port->config.nfc_credits & ADP_CS_4_NFC_BUFFERS_MASK); 664 665 port->config.nfc_credits &= ~ADP_CS_4_NFC_BUFFERS_MASK; 666 port->config.nfc_credits |= nfc_credits; 667 668 return tb_port_write(port, &port->config.nfc_credits, 669 TB_CFG_PORT, ADP_CS_4, 1); 670 } 671 672 /** 673 * tb_port_set_initial_credits() - Set initial port link credits allocated 674 * @port: Port to set the initial credits 675 * @credits: Number of credits to to allocate 676 * 677 * Set initial credits value to be used for ingress shared buffering. 678 */ 679 int tb_port_set_initial_credits(struct tb_port *port, u32 credits) 680 { 681 u32 data; 682 int ret; 683 684 ret = tb_port_read(port, &data, TB_CFG_PORT, ADP_CS_5, 1); 685 if (ret) 686 return ret; 687 688 data &= ~ADP_CS_5_LCA_MASK; 689 data |= (credits << ADP_CS_5_LCA_SHIFT) & ADP_CS_5_LCA_MASK; 690 691 return tb_port_write(port, &data, TB_CFG_PORT, ADP_CS_5, 1); 692 } 693 694 /** 695 * tb_port_clear_counter() - clear a counter in TB_CFG_COUNTER 696 * 697 * Return: Returns 0 on success or an error code on failure. 698 */ 699 int tb_port_clear_counter(struct tb_port *port, int counter) 700 { 701 u32 zero[3] = { 0, 0, 0 }; 702 tb_port_dbg(port, "clearing counter %d\n", counter); 703 return tb_port_write(port, zero, TB_CFG_COUNTERS, 3 * counter, 3); 704 } 705 706 /** 707 * tb_port_unlock() - Unlock downstream port 708 * @port: Port to unlock 709 * 710 * Needed for USB4 but can be called for any CIO/USB4 ports. Makes the 711 * downstream router accessible for CM. 712 */ 713 int tb_port_unlock(struct tb_port *port) 714 { 715 if (tb_switch_is_icm(port->sw)) 716 return 0; 717 if (!tb_port_is_null(port)) 718 return -EINVAL; 719 if (tb_switch_is_usb4(port->sw)) 720 return usb4_port_unlock(port); 721 return 0; 722 } 723 724 /** 725 * tb_init_port() - initialize a port 726 * 727 * This is a helper method for tb_switch_alloc. Does not check or initialize 728 * any downstream switches. 729 * 730 * Return: Returns 0 on success or an error code on failure. 731 */ 732 static int tb_init_port(struct tb_port *port) 733 { 734 int res; 735 int cap; 736 737 res = tb_port_read(port, &port->config, TB_CFG_PORT, 0, 8); 738 if (res) { 739 if (res == -ENODEV) { 740 tb_dbg(port->sw->tb, " Port %d: not implemented\n", 741 port->port); 742 return 0; 743 } 744 return res; 745 } 746 747 /* Port 0 is the switch itself and has no PHY. */ 748 if (port->config.type == TB_TYPE_PORT && port->port != 0) { 749 cap = tb_port_find_cap(port, TB_PORT_CAP_PHY); 750 751 if (cap > 0) 752 port->cap_phy = cap; 753 else 754 tb_port_WARN(port, "non switch port without a PHY\n"); 755 756 cap = tb_port_find_cap(port, TB_PORT_CAP_USB4); 757 if (cap > 0) 758 port->cap_usb4 = cap; 759 } else if (port->port != 0) { 760 cap = tb_port_find_cap(port, TB_PORT_CAP_ADAP); 761 if (cap > 0) 762 port->cap_adap = cap; 763 } 764 765 tb_dump_port(port->sw->tb, &port->config); 766 767 /* Control port does not need HopID allocation */ 768 if (port->port) { 769 ida_init(&port->in_hopids); 770 ida_init(&port->out_hopids); 771 } 772 773 INIT_LIST_HEAD(&port->list); 774 return 0; 775 776 } 777 778 static int tb_port_alloc_hopid(struct tb_port *port, bool in, int min_hopid, 779 int max_hopid) 780 { 781 int port_max_hopid; 782 struct ida *ida; 783 784 if (in) { 785 port_max_hopid = port->config.max_in_hop_id; 786 ida = &port->in_hopids; 787 } else { 788 port_max_hopid = port->config.max_out_hop_id; 789 ida = &port->out_hopids; 790 } 791 792 /* 793 * NHI can use HopIDs 1-max for other adapters HopIDs 0-7 are 794 * reserved. 795 */ 796 if (port->config.type != TB_TYPE_NHI && min_hopid < TB_PATH_MIN_HOPID) 797 min_hopid = TB_PATH_MIN_HOPID; 798 799 if (max_hopid < 0 || max_hopid > port_max_hopid) 800 max_hopid = port_max_hopid; 801 802 return ida_simple_get(ida, min_hopid, max_hopid + 1, GFP_KERNEL); 803 } 804 805 /** 806 * tb_port_alloc_in_hopid() - Allocate input HopID from port 807 * @port: Port to allocate HopID for 808 * @min_hopid: Minimum acceptable input HopID 809 * @max_hopid: Maximum acceptable input HopID 810 * 811 * Return: HopID between @min_hopid and @max_hopid or negative errno in 812 * case of error. 813 */ 814 int tb_port_alloc_in_hopid(struct tb_port *port, int min_hopid, int max_hopid) 815 { 816 return tb_port_alloc_hopid(port, true, min_hopid, max_hopid); 817 } 818 819 /** 820 * tb_port_alloc_out_hopid() - Allocate output HopID from port 821 * @port: Port to allocate HopID for 822 * @min_hopid: Minimum acceptable output HopID 823 * @max_hopid: Maximum acceptable output HopID 824 * 825 * Return: HopID between @min_hopid and @max_hopid or negative errno in 826 * case of error. 827 */ 828 int tb_port_alloc_out_hopid(struct tb_port *port, int min_hopid, int max_hopid) 829 { 830 return tb_port_alloc_hopid(port, false, min_hopid, max_hopid); 831 } 832 833 /** 834 * tb_port_release_in_hopid() - Release allocated input HopID from port 835 * @port: Port whose HopID to release 836 * @hopid: HopID to release 837 */ 838 void tb_port_release_in_hopid(struct tb_port *port, int hopid) 839 { 840 ida_simple_remove(&port->in_hopids, hopid); 841 } 842 843 /** 844 * tb_port_release_out_hopid() - Release allocated output HopID from port 845 * @port: Port whose HopID to release 846 * @hopid: HopID to release 847 */ 848 void tb_port_release_out_hopid(struct tb_port *port, int hopid) 849 { 850 ida_simple_remove(&port->out_hopids, hopid); 851 } 852 853 static inline bool tb_switch_is_reachable(const struct tb_switch *parent, 854 const struct tb_switch *sw) 855 { 856 u64 mask = (1ULL << parent->config.depth * 8) - 1; 857 return (tb_route(parent) & mask) == (tb_route(sw) & mask); 858 } 859 860 /** 861 * tb_next_port_on_path() - Return next port for given port on a path 862 * @start: Start port of the walk 863 * @end: End port of the walk 864 * @prev: Previous port (%NULL if this is the first) 865 * 866 * This function can be used to walk from one port to another if they 867 * are connected through zero or more switches. If the @prev is dual 868 * link port, the function follows that link and returns another end on 869 * that same link. 870 * 871 * If the @end port has been reached, return %NULL. 872 * 873 * Domain tb->lock must be held when this function is called. 874 */ 875 struct tb_port *tb_next_port_on_path(struct tb_port *start, struct tb_port *end, 876 struct tb_port *prev) 877 { 878 struct tb_port *next; 879 880 if (!prev) 881 return start; 882 883 if (prev->sw == end->sw) { 884 if (prev == end) 885 return NULL; 886 return end; 887 } 888 889 if (tb_switch_is_reachable(prev->sw, end->sw)) { 890 next = tb_port_at(tb_route(end->sw), prev->sw); 891 /* Walk down the topology if next == prev */ 892 if (prev->remote && 893 (next == prev || next->dual_link_port == prev)) 894 next = prev->remote; 895 } else { 896 if (tb_is_upstream_port(prev)) { 897 next = prev->remote; 898 } else { 899 next = tb_upstream_port(prev->sw); 900 /* 901 * Keep the same link if prev and next are both 902 * dual link ports. 903 */ 904 if (next->dual_link_port && 905 next->link_nr != prev->link_nr) { 906 next = next->dual_link_port; 907 } 908 } 909 } 910 911 return next != prev ? next : NULL; 912 } 913 914 /** 915 * tb_port_get_link_speed() - Get current link speed 916 * @port: Port to check (USB4 or CIO) 917 * 918 * Returns link speed in Gb/s or negative errno in case of failure. 919 */ 920 int tb_port_get_link_speed(struct tb_port *port) 921 { 922 u32 val, speed; 923 int ret; 924 925 if (!port->cap_phy) 926 return -EINVAL; 927 928 ret = tb_port_read(port, &val, TB_CFG_PORT, 929 port->cap_phy + LANE_ADP_CS_1, 1); 930 if (ret) 931 return ret; 932 933 speed = (val & LANE_ADP_CS_1_CURRENT_SPEED_MASK) >> 934 LANE_ADP_CS_1_CURRENT_SPEED_SHIFT; 935 return speed == LANE_ADP_CS_1_CURRENT_SPEED_GEN3 ? 20 : 10; 936 } 937 938 static int tb_port_get_link_width(struct tb_port *port) 939 { 940 u32 val; 941 int ret; 942 943 if (!port->cap_phy) 944 return -EINVAL; 945 946 ret = tb_port_read(port, &val, TB_CFG_PORT, 947 port->cap_phy + LANE_ADP_CS_1, 1); 948 if (ret) 949 return ret; 950 951 return (val & LANE_ADP_CS_1_CURRENT_WIDTH_MASK) >> 952 LANE_ADP_CS_1_CURRENT_WIDTH_SHIFT; 953 } 954 955 static bool tb_port_is_width_supported(struct tb_port *port, int width) 956 { 957 u32 phy, widths; 958 int ret; 959 960 if (!port->cap_phy) 961 return false; 962 963 ret = tb_port_read(port, &phy, TB_CFG_PORT, 964 port->cap_phy + LANE_ADP_CS_0, 1); 965 if (ret) 966 return false; 967 968 widths = (phy & LANE_ADP_CS_0_SUPPORTED_WIDTH_MASK) >> 969 LANE_ADP_CS_0_SUPPORTED_WIDTH_SHIFT; 970 971 return !!(widths & width); 972 } 973 974 static int tb_port_set_link_width(struct tb_port *port, unsigned int width) 975 { 976 u32 val; 977 int ret; 978 979 if (!port->cap_phy) 980 return -EINVAL; 981 982 ret = tb_port_read(port, &val, TB_CFG_PORT, 983 port->cap_phy + LANE_ADP_CS_1, 1); 984 if (ret) 985 return ret; 986 987 val &= ~LANE_ADP_CS_1_TARGET_WIDTH_MASK; 988 switch (width) { 989 case 1: 990 val |= LANE_ADP_CS_1_TARGET_WIDTH_SINGLE << 991 LANE_ADP_CS_1_TARGET_WIDTH_SHIFT; 992 break; 993 case 2: 994 val |= LANE_ADP_CS_1_TARGET_WIDTH_DUAL << 995 LANE_ADP_CS_1_TARGET_WIDTH_SHIFT; 996 break; 997 default: 998 return -EINVAL; 999 } 1000 1001 val |= LANE_ADP_CS_1_LB; 1002 1003 return tb_port_write(port, &val, TB_CFG_PORT, 1004 port->cap_phy + LANE_ADP_CS_1, 1); 1005 } 1006 1007 static int tb_port_lane_bonding_enable(struct tb_port *port) 1008 { 1009 int ret; 1010 1011 /* 1012 * Enable lane bonding for both links if not already enabled by 1013 * for example the boot firmware. 1014 */ 1015 ret = tb_port_get_link_width(port); 1016 if (ret == 1) { 1017 ret = tb_port_set_link_width(port, 2); 1018 if (ret) 1019 return ret; 1020 } 1021 1022 ret = tb_port_get_link_width(port->dual_link_port); 1023 if (ret == 1) { 1024 ret = tb_port_set_link_width(port->dual_link_port, 2); 1025 if (ret) { 1026 tb_port_set_link_width(port, 1); 1027 return ret; 1028 } 1029 } 1030 1031 port->bonded = true; 1032 port->dual_link_port->bonded = true; 1033 1034 return 0; 1035 } 1036 1037 static void tb_port_lane_bonding_disable(struct tb_port *port) 1038 { 1039 port->dual_link_port->bonded = false; 1040 port->bonded = false; 1041 1042 tb_port_set_link_width(port->dual_link_port, 1); 1043 tb_port_set_link_width(port, 1); 1044 } 1045 1046 /** 1047 * tb_port_is_enabled() - Is the adapter port enabled 1048 * @port: Port to check 1049 */ 1050 bool tb_port_is_enabled(struct tb_port *port) 1051 { 1052 switch (port->config.type) { 1053 case TB_TYPE_PCIE_UP: 1054 case TB_TYPE_PCIE_DOWN: 1055 return tb_pci_port_is_enabled(port); 1056 1057 case TB_TYPE_DP_HDMI_IN: 1058 case TB_TYPE_DP_HDMI_OUT: 1059 return tb_dp_port_is_enabled(port); 1060 1061 case TB_TYPE_USB3_UP: 1062 case TB_TYPE_USB3_DOWN: 1063 return tb_usb3_port_is_enabled(port); 1064 1065 default: 1066 return false; 1067 } 1068 } 1069 1070 /** 1071 * tb_usb3_port_is_enabled() - Is the USB3 adapter port enabled 1072 * @port: USB3 adapter port to check 1073 */ 1074 bool tb_usb3_port_is_enabled(struct tb_port *port) 1075 { 1076 u32 data; 1077 1078 if (tb_port_read(port, &data, TB_CFG_PORT, 1079 port->cap_adap + ADP_USB3_CS_0, 1)) 1080 return false; 1081 1082 return !!(data & ADP_USB3_CS_0_PE); 1083 } 1084 1085 /** 1086 * tb_usb3_port_enable() - Enable USB3 adapter port 1087 * @port: USB3 adapter port to enable 1088 * @enable: Enable/disable the USB3 adapter 1089 */ 1090 int tb_usb3_port_enable(struct tb_port *port, bool enable) 1091 { 1092 u32 word = enable ? (ADP_USB3_CS_0_PE | ADP_USB3_CS_0_V) 1093 : ADP_USB3_CS_0_V; 1094 1095 if (!port->cap_adap) 1096 return -ENXIO; 1097 return tb_port_write(port, &word, TB_CFG_PORT, 1098 port->cap_adap + ADP_USB3_CS_0, 1); 1099 } 1100 1101 /** 1102 * tb_pci_port_is_enabled() - Is the PCIe adapter port enabled 1103 * @port: PCIe port to check 1104 */ 1105 bool tb_pci_port_is_enabled(struct tb_port *port) 1106 { 1107 u32 data; 1108 1109 if (tb_port_read(port, &data, TB_CFG_PORT, 1110 port->cap_adap + ADP_PCIE_CS_0, 1)) 1111 return false; 1112 1113 return !!(data & ADP_PCIE_CS_0_PE); 1114 } 1115 1116 /** 1117 * tb_pci_port_enable() - Enable PCIe adapter port 1118 * @port: PCIe port to enable 1119 * @enable: Enable/disable the PCIe adapter 1120 */ 1121 int tb_pci_port_enable(struct tb_port *port, bool enable) 1122 { 1123 u32 word = enable ? ADP_PCIE_CS_0_PE : 0x0; 1124 if (!port->cap_adap) 1125 return -ENXIO; 1126 return tb_port_write(port, &word, TB_CFG_PORT, 1127 port->cap_adap + ADP_PCIE_CS_0, 1); 1128 } 1129 1130 /** 1131 * tb_dp_port_hpd_is_active() - Is HPD already active 1132 * @port: DP out port to check 1133 * 1134 * Checks if the DP OUT adapter port has HDP bit already set. 1135 */ 1136 int tb_dp_port_hpd_is_active(struct tb_port *port) 1137 { 1138 u32 data; 1139 int ret; 1140 1141 ret = tb_port_read(port, &data, TB_CFG_PORT, 1142 port->cap_adap + ADP_DP_CS_2, 1); 1143 if (ret) 1144 return ret; 1145 1146 return !!(data & ADP_DP_CS_2_HDP); 1147 } 1148 1149 /** 1150 * tb_dp_port_hpd_clear() - Clear HPD from DP IN port 1151 * @port: Port to clear HPD 1152 * 1153 * If the DP IN port has HDP set, this function can be used to clear it. 1154 */ 1155 int tb_dp_port_hpd_clear(struct tb_port *port) 1156 { 1157 u32 data; 1158 int ret; 1159 1160 ret = tb_port_read(port, &data, TB_CFG_PORT, 1161 port->cap_adap + ADP_DP_CS_3, 1); 1162 if (ret) 1163 return ret; 1164 1165 data |= ADP_DP_CS_3_HDPC; 1166 return tb_port_write(port, &data, TB_CFG_PORT, 1167 port->cap_adap + ADP_DP_CS_3, 1); 1168 } 1169 1170 /** 1171 * tb_dp_port_set_hops() - Set video/aux Hop IDs for DP port 1172 * @port: DP IN/OUT port to set hops 1173 * @video: Video Hop ID 1174 * @aux_tx: AUX TX Hop ID 1175 * @aux_rx: AUX RX Hop ID 1176 * 1177 * Programs specified Hop IDs for DP IN/OUT port. 1178 */ 1179 int tb_dp_port_set_hops(struct tb_port *port, unsigned int video, 1180 unsigned int aux_tx, unsigned int aux_rx) 1181 { 1182 u32 data[2]; 1183 int ret; 1184 1185 ret = tb_port_read(port, data, TB_CFG_PORT, 1186 port->cap_adap + ADP_DP_CS_0, ARRAY_SIZE(data)); 1187 if (ret) 1188 return ret; 1189 1190 data[0] &= ~ADP_DP_CS_0_VIDEO_HOPID_MASK; 1191 data[1] &= ~ADP_DP_CS_1_AUX_RX_HOPID_MASK; 1192 data[1] &= ~ADP_DP_CS_1_AUX_RX_HOPID_MASK; 1193 1194 data[0] |= (video << ADP_DP_CS_0_VIDEO_HOPID_SHIFT) & 1195 ADP_DP_CS_0_VIDEO_HOPID_MASK; 1196 data[1] |= aux_tx & ADP_DP_CS_1_AUX_TX_HOPID_MASK; 1197 data[1] |= (aux_rx << ADP_DP_CS_1_AUX_RX_HOPID_SHIFT) & 1198 ADP_DP_CS_1_AUX_RX_HOPID_MASK; 1199 1200 return tb_port_write(port, data, TB_CFG_PORT, 1201 port->cap_adap + ADP_DP_CS_0, ARRAY_SIZE(data)); 1202 } 1203 1204 /** 1205 * tb_dp_port_is_enabled() - Is DP adapter port enabled 1206 * @port: DP adapter port to check 1207 */ 1208 bool tb_dp_port_is_enabled(struct tb_port *port) 1209 { 1210 u32 data[2]; 1211 1212 if (tb_port_read(port, data, TB_CFG_PORT, port->cap_adap + ADP_DP_CS_0, 1213 ARRAY_SIZE(data))) 1214 return false; 1215 1216 return !!(data[0] & (ADP_DP_CS_0_VE | ADP_DP_CS_0_AE)); 1217 } 1218 1219 /** 1220 * tb_dp_port_enable() - Enables/disables DP paths of a port 1221 * @port: DP IN/OUT port 1222 * @enable: Enable/disable DP path 1223 * 1224 * Once Hop IDs are programmed DP paths can be enabled or disabled by 1225 * calling this function. 1226 */ 1227 int tb_dp_port_enable(struct tb_port *port, bool enable) 1228 { 1229 u32 data[2]; 1230 int ret; 1231 1232 ret = tb_port_read(port, data, TB_CFG_PORT, 1233 port->cap_adap + ADP_DP_CS_0, ARRAY_SIZE(data)); 1234 if (ret) 1235 return ret; 1236 1237 if (enable) 1238 data[0] |= ADP_DP_CS_0_VE | ADP_DP_CS_0_AE; 1239 else 1240 data[0] &= ~(ADP_DP_CS_0_VE | ADP_DP_CS_0_AE); 1241 1242 return tb_port_write(port, data, TB_CFG_PORT, 1243 port->cap_adap + ADP_DP_CS_0, ARRAY_SIZE(data)); 1244 } 1245 1246 /* switch utility functions */ 1247 1248 static const char *tb_switch_generation_name(const struct tb_switch *sw) 1249 { 1250 switch (sw->generation) { 1251 case 1: 1252 return "Thunderbolt 1"; 1253 case 2: 1254 return "Thunderbolt 2"; 1255 case 3: 1256 return "Thunderbolt 3"; 1257 case 4: 1258 return "USB4"; 1259 default: 1260 return "Unknown"; 1261 } 1262 } 1263 1264 static void tb_dump_switch(const struct tb *tb, const struct tb_switch *sw) 1265 { 1266 const struct tb_regs_switch_header *regs = &sw->config; 1267 1268 tb_dbg(tb, " %s Switch: %x:%x (Revision: %d, TB Version: %d)\n", 1269 tb_switch_generation_name(sw), regs->vendor_id, regs->device_id, 1270 regs->revision, regs->thunderbolt_version); 1271 tb_dbg(tb, " Max Port Number: %d\n", regs->max_port_number); 1272 tb_dbg(tb, " Config:\n"); 1273 tb_dbg(tb, 1274 " Upstream Port Number: %d Depth: %d Route String: %#llx Enabled: %d, PlugEventsDelay: %dms\n", 1275 regs->upstream_port_number, regs->depth, 1276 (((u64) regs->route_hi) << 32) | regs->route_lo, 1277 regs->enabled, regs->plug_events_delay); 1278 tb_dbg(tb, " unknown1: %#x unknown4: %#x\n", 1279 regs->__unknown1, regs->__unknown4); 1280 } 1281 1282 /** 1283 * reset_switch() - reconfigure route, enable and send TB_CFG_PKG_RESET 1284 * 1285 * Return: Returns 0 on success or an error code on failure. 1286 */ 1287 int tb_switch_reset(struct tb *tb, u64 route) 1288 { 1289 struct tb_cfg_result res; 1290 struct tb_regs_switch_header header = { 1291 header.route_hi = route >> 32, 1292 header.route_lo = route, 1293 header.enabled = true, 1294 }; 1295 tb_dbg(tb, "resetting switch at %llx\n", route); 1296 res.err = tb_cfg_write(tb->ctl, ((u32 *) &header) + 2, route, 1297 0, 2, 2, 2); 1298 if (res.err) 1299 return res.err; 1300 res = tb_cfg_reset(tb->ctl, route, TB_CFG_DEFAULT_TIMEOUT); 1301 if (res.err > 0) 1302 return -EIO; 1303 return res.err; 1304 } 1305 1306 /** 1307 * tb_plug_events_active() - enable/disable plug events on a switch 1308 * 1309 * Also configures a sane plug_events_delay of 255ms. 1310 * 1311 * Return: Returns 0 on success or an error code on failure. 1312 */ 1313 static int tb_plug_events_active(struct tb_switch *sw, bool active) 1314 { 1315 u32 data; 1316 int res; 1317 1318 if (tb_switch_is_icm(sw)) 1319 return 0; 1320 1321 sw->config.plug_events_delay = 0xff; 1322 res = tb_sw_write(sw, ((u32 *) &sw->config) + 4, TB_CFG_SWITCH, 4, 1); 1323 if (res) 1324 return res; 1325 1326 /* Plug events are always enabled in USB4 */ 1327 if (tb_switch_is_usb4(sw)) 1328 return 0; 1329 1330 res = tb_sw_read(sw, &data, TB_CFG_SWITCH, sw->cap_plug_events + 1, 1); 1331 if (res) 1332 return res; 1333 1334 if (active) { 1335 data = data & 0xFFFFFF83; 1336 switch (sw->config.device_id) { 1337 case PCI_DEVICE_ID_INTEL_LIGHT_RIDGE: 1338 case PCI_DEVICE_ID_INTEL_EAGLE_RIDGE: 1339 case PCI_DEVICE_ID_INTEL_PORT_RIDGE: 1340 break; 1341 default: 1342 data |= 4; 1343 } 1344 } else { 1345 data = data | 0x7c; 1346 } 1347 return tb_sw_write(sw, &data, TB_CFG_SWITCH, 1348 sw->cap_plug_events + 1, 1); 1349 } 1350 1351 static ssize_t authorized_show(struct device *dev, 1352 struct device_attribute *attr, 1353 char *buf) 1354 { 1355 struct tb_switch *sw = tb_to_switch(dev); 1356 1357 return sprintf(buf, "%u\n", sw->authorized); 1358 } 1359 1360 static int tb_switch_set_authorized(struct tb_switch *sw, unsigned int val) 1361 { 1362 int ret = -EINVAL; 1363 1364 if (!mutex_trylock(&sw->tb->lock)) 1365 return restart_syscall(); 1366 1367 if (sw->authorized) 1368 goto unlock; 1369 1370 switch (val) { 1371 /* Approve switch */ 1372 case 1: 1373 if (sw->key) 1374 ret = tb_domain_approve_switch_key(sw->tb, sw); 1375 else 1376 ret = tb_domain_approve_switch(sw->tb, sw); 1377 break; 1378 1379 /* Challenge switch */ 1380 case 2: 1381 if (sw->key) 1382 ret = tb_domain_challenge_switch_key(sw->tb, sw); 1383 break; 1384 1385 default: 1386 break; 1387 } 1388 1389 if (!ret) { 1390 sw->authorized = val; 1391 /* Notify status change to the userspace */ 1392 kobject_uevent(&sw->dev.kobj, KOBJ_CHANGE); 1393 } 1394 1395 unlock: 1396 mutex_unlock(&sw->tb->lock); 1397 return ret; 1398 } 1399 1400 static ssize_t authorized_store(struct device *dev, 1401 struct device_attribute *attr, 1402 const char *buf, size_t count) 1403 { 1404 struct tb_switch *sw = tb_to_switch(dev); 1405 unsigned int val; 1406 ssize_t ret; 1407 1408 ret = kstrtouint(buf, 0, &val); 1409 if (ret) 1410 return ret; 1411 if (val > 2) 1412 return -EINVAL; 1413 1414 pm_runtime_get_sync(&sw->dev); 1415 ret = tb_switch_set_authorized(sw, val); 1416 pm_runtime_mark_last_busy(&sw->dev); 1417 pm_runtime_put_autosuspend(&sw->dev); 1418 1419 return ret ? ret : count; 1420 } 1421 static DEVICE_ATTR_RW(authorized); 1422 1423 static ssize_t boot_show(struct device *dev, struct device_attribute *attr, 1424 char *buf) 1425 { 1426 struct tb_switch *sw = tb_to_switch(dev); 1427 1428 return sprintf(buf, "%u\n", sw->boot); 1429 } 1430 static DEVICE_ATTR_RO(boot); 1431 1432 static ssize_t device_show(struct device *dev, struct device_attribute *attr, 1433 char *buf) 1434 { 1435 struct tb_switch *sw = tb_to_switch(dev); 1436 1437 return sprintf(buf, "%#x\n", sw->device); 1438 } 1439 static DEVICE_ATTR_RO(device); 1440 1441 static ssize_t 1442 device_name_show(struct device *dev, struct device_attribute *attr, char *buf) 1443 { 1444 struct tb_switch *sw = tb_to_switch(dev); 1445 1446 return sprintf(buf, "%s\n", sw->device_name ? sw->device_name : ""); 1447 } 1448 static DEVICE_ATTR_RO(device_name); 1449 1450 static ssize_t 1451 generation_show(struct device *dev, struct device_attribute *attr, char *buf) 1452 { 1453 struct tb_switch *sw = tb_to_switch(dev); 1454 1455 return sprintf(buf, "%u\n", sw->generation); 1456 } 1457 static DEVICE_ATTR_RO(generation); 1458 1459 static ssize_t key_show(struct device *dev, struct device_attribute *attr, 1460 char *buf) 1461 { 1462 struct tb_switch *sw = tb_to_switch(dev); 1463 ssize_t ret; 1464 1465 if (!mutex_trylock(&sw->tb->lock)) 1466 return restart_syscall(); 1467 1468 if (sw->key) 1469 ret = sprintf(buf, "%*phN\n", TB_SWITCH_KEY_SIZE, sw->key); 1470 else 1471 ret = sprintf(buf, "\n"); 1472 1473 mutex_unlock(&sw->tb->lock); 1474 return ret; 1475 } 1476 1477 static ssize_t key_store(struct device *dev, struct device_attribute *attr, 1478 const char *buf, size_t count) 1479 { 1480 struct tb_switch *sw = tb_to_switch(dev); 1481 u8 key[TB_SWITCH_KEY_SIZE]; 1482 ssize_t ret = count; 1483 bool clear = false; 1484 1485 if (!strcmp(buf, "\n")) 1486 clear = true; 1487 else if (hex2bin(key, buf, sizeof(key))) 1488 return -EINVAL; 1489 1490 if (!mutex_trylock(&sw->tb->lock)) 1491 return restart_syscall(); 1492 1493 if (sw->authorized) { 1494 ret = -EBUSY; 1495 } else { 1496 kfree(sw->key); 1497 if (clear) { 1498 sw->key = NULL; 1499 } else { 1500 sw->key = kmemdup(key, sizeof(key), GFP_KERNEL); 1501 if (!sw->key) 1502 ret = -ENOMEM; 1503 } 1504 } 1505 1506 mutex_unlock(&sw->tb->lock); 1507 return ret; 1508 } 1509 static DEVICE_ATTR(key, 0600, key_show, key_store); 1510 1511 static ssize_t speed_show(struct device *dev, struct device_attribute *attr, 1512 char *buf) 1513 { 1514 struct tb_switch *sw = tb_to_switch(dev); 1515 1516 return sprintf(buf, "%u.0 Gb/s\n", sw->link_speed); 1517 } 1518 1519 /* 1520 * Currently all lanes must run at the same speed but we expose here 1521 * both directions to allow possible asymmetric links in the future. 1522 */ 1523 static DEVICE_ATTR(rx_speed, 0444, speed_show, NULL); 1524 static DEVICE_ATTR(tx_speed, 0444, speed_show, NULL); 1525 1526 static ssize_t lanes_show(struct device *dev, struct device_attribute *attr, 1527 char *buf) 1528 { 1529 struct tb_switch *sw = tb_to_switch(dev); 1530 1531 return sprintf(buf, "%u\n", sw->link_width); 1532 } 1533 1534 /* 1535 * Currently link has same amount of lanes both directions (1 or 2) but 1536 * expose them separately to allow possible asymmetric links in the future. 1537 */ 1538 static DEVICE_ATTR(rx_lanes, 0444, lanes_show, NULL); 1539 static DEVICE_ATTR(tx_lanes, 0444, lanes_show, NULL); 1540 1541 static ssize_t nvm_authenticate_show(struct device *dev, 1542 struct device_attribute *attr, char *buf) 1543 { 1544 struct tb_switch *sw = tb_to_switch(dev); 1545 u32 status; 1546 1547 nvm_get_auth_status(sw, &status); 1548 return sprintf(buf, "%#x\n", status); 1549 } 1550 1551 static ssize_t nvm_authenticate_store(struct device *dev, 1552 struct device_attribute *attr, const char *buf, size_t count) 1553 { 1554 struct tb_switch *sw = tb_to_switch(dev); 1555 bool val; 1556 int ret; 1557 1558 pm_runtime_get_sync(&sw->dev); 1559 1560 if (!mutex_trylock(&sw->tb->lock)) { 1561 ret = restart_syscall(); 1562 goto exit_rpm; 1563 } 1564 1565 /* If NVMem devices are not yet added */ 1566 if (!sw->nvm) { 1567 ret = -EAGAIN; 1568 goto exit_unlock; 1569 } 1570 1571 ret = kstrtobool(buf, &val); 1572 if (ret) 1573 goto exit_unlock; 1574 1575 /* Always clear the authentication status */ 1576 nvm_clear_auth_status(sw); 1577 1578 if (val) { 1579 if (!sw->nvm->buf) { 1580 ret = -EINVAL; 1581 goto exit_unlock; 1582 } 1583 1584 ret = nvm_validate_and_write(sw); 1585 if (ret) 1586 goto exit_unlock; 1587 1588 sw->nvm->authenticating = true; 1589 ret = nvm_authenticate(sw); 1590 } 1591 1592 exit_unlock: 1593 mutex_unlock(&sw->tb->lock); 1594 exit_rpm: 1595 pm_runtime_mark_last_busy(&sw->dev); 1596 pm_runtime_put_autosuspend(&sw->dev); 1597 1598 if (ret) 1599 return ret; 1600 return count; 1601 } 1602 static DEVICE_ATTR_RW(nvm_authenticate); 1603 1604 static ssize_t nvm_version_show(struct device *dev, 1605 struct device_attribute *attr, char *buf) 1606 { 1607 struct tb_switch *sw = tb_to_switch(dev); 1608 int ret; 1609 1610 if (!mutex_trylock(&sw->tb->lock)) 1611 return restart_syscall(); 1612 1613 if (sw->safe_mode) 1614 ret = -ENODATA; 1615 else if (!sw->nvm) 1616 ret = -EAGAIN; 1617 else 1618 ret = sprintf(buf, "%x.%x\n", sw->nvm->major, sw->nvm->minor); 1619 1620 mutex_unlock(&sw->tb->lock); 1621 1622 return ret; 1623 } 1624 static DEVICE_ATTR_RO(nvm_version); 1625 1626 static ssize_t vendor_show(struct device *dev, struct device_attribute *attr, 1627 char *buf) 1628 { 1629 struct tb_switch *sw = tb_to_switch(dev); 1630 1631 return sprintf(buf, "%#x\n", sw->vendor); 1632 } 1633 static DEVICE_ATTR_RO(vendor); 1634 1635 static ssize_t 1636 vendor_name_show(struct device *dev, struct device_attribute *attr, char *buf) 1637 { 1638 struct tb_switch *sw = tb_to_switch(dev); 1639 1640 return sprintf(buf, "%s\n", sw->vendor_name ? sw->vendor_name : ""); 1641 } 1642 static DEVICE_ATTR_RO(vendor_name); 1643 1644 static ssize_t unique_id_show(struct device *dev, struct device_attribute *attr, 1645 char *buf) 1646 { 1647 struct tb_switch *sw = tb_to_switch(dev); 1648 1649 return sprintf(buf, "%pUb\n", sw->uuid); 1650 } 1651 static DEVICE_ATTR_RO(unique_id); 1652 1653 static struct attribute *switch_attrs[] = { 1654 &dev_attr_authorized.attr, 1655 &dev_attr_boot.attr, 1656 &dev_attr_device.attr, 1657 &dev_attr_device_name.attr, 1658 &dev_attr_generation.attr, 1659 &dev_attr_key.attr, 1660 &dev_attr_nvm_authenticate.attr, 1661 &dev_attr_nvm_version.attr, 1662 &dev_attr_rx_speed.attr, 1663 &dev_attr_rx_lanes.attr, 1664 &dev_attr_tx_speed.attr, 1665 &dev_attr_tx_lanes.attr, 1666 &dev_attr_vendor.attr, 1667 &dev_attr_vendor_name.attr, 1668 &dev_attr_unique_id.attr, 1669 NULL, 1670 }; 1671 1672 static umode_t switch_attr_is_visible(struct kobject *kobj, 1673 struct attribute *attr, int n) 1674 { 1675 struct device *dev = container_of(kobj, struct device, kobj); 1676 struct tb_switch *sw = tb_to_switch(dev); 1677 1678 if (attr == &dev_attr_device.attr) { 1679 if (!sw->device) 1680 return 0; 1681 } else if (attr == &dev_attr_device_name.attr) { 1682 if (!sw->device_name) 1683 return 0; 1684 } else if (attr == &dev_attr_vendor.attr) { 1685 if (!sw->vendor) 1686 return 0; 1687 } else if (attr == &dev_attr_vendor_name.attr) { 1688 if (!sw->vendor_name) 1689 return 0; 1690 } else if (attr == &dev_attr_key.attr) { 1691 if (tb_route(sw) && 1692 sw->tb->security_level == TB_SECURITY_SECURE && 1693 sw->security_level == TB_SECURITY_SECURE) 1694 return attr->mode; 1695 return 0; 1696 } else if (attr == &dev_attr_rx_speed.attr || 1697 attr == &dev_attr_rx_lanes.attr || 1698 attr == &dev_attr_tx_speed.attr || 1699 attr == &dev_attr_tx_lanes.attr) { 1700 if (tb_route(sw)) 1701 return attr->mode; 1702 return 0; 1703 } else if (attr == &dev_attr_nvm_authenticate.attr) { 1704 if (nvm_upgradeable(sw)) 1705 return attr->mode; 1706 return 0; 1707 } else if (attr == &dev_attr_nvm_version.attr) { 1708 if (nvm_readable(sw)) 1709 return attr->mode; 1710 return 0; 1711 } else if (attr == &dev_attr_boot.attr) { 1712 if (tb_route(sw)) 1713 return attr->mode; 1714 return 0; 1715 } 1716 1717 return sw->safe_mode ? 0 : attr->mode; 1718 } 1719 1720 static struct attribute_group switch_group = { 1721 .is_visible = switch_attr_is_visible, 1722 .attrs = switch_attrs, 1723 }; 1724 1725 static const struct attribute_group *switch_groups[] = { 1726 &switch_group, 1727 NULL, 1728 }; 1729 1730 static void tb_switch_release(struct device *dev) 1731 { 1732 struct tb_switch *sw = tb_to_switch(dev); 1733 struct tb_port *port; 1734 1735 dma_port_free(sw->dma_port); 1736 1737 tb_switch_for_each_port(sw, port) { 1738 if (!port->disabled) { 1739 ida_destroy(&port->in_hopids); 1740 ida_destroy(&port->out_hopids); 1741 } 1742 } 1743 1744 kfree(sw->uuid); 1745 kfree(sw->device_name); 1746 kfree(sw->vendor_name); 1747 kfree(sw->ports); 1748 kfree(sw->drom); 1749 kfree(sw->key); 1750 kfree(sw); 1751 } 1752 1753 /* 1754 * Currently only need to provide the callbacks. Everything else is handled 1755 * in the connection manager. 1756 */ 1757 static int __maybe_unused tb_switch_runtime_suspend(struct device *dev) 1758 { 1759 struct tb_switch *sw = tb_to_switch(dev); 1760 const struct tb_cm_ops *cm_ops = sw->tb->cm_ops; 1761 1762 if (cm_ops->runtime_suspend_switch) 1763 return cm_ops->runtime_suspend_switch(sw); 1764 1765 return 0; 1766 } 1767 1768 static int __maybe_unused tb_switch_runtime_resume(struct device *dev) 1769 { 1770 struct tb_switch *sw = tb_to_switch(dev); 1771 const struct tb_cm_ops *cm_ops = sw->tb->cm_ops; 1772 1773 if (cm_ops->runtime_resume_switch) 1774 return cm_ops->runtime_resume_switch(sw); 1775 return 0; 1776 } 1777 1778 static const struct dev_pm_ops tb_switch_pm_ops = { 1779 SET_RUNTIME_PM_OPS(tb_switch_runtime_suspend, tb_switch_runtime_resume, 1780 NULL) 1781 }; 1782 1783 struct device_type tb_switch_type = { 1784 .name = "thunderbolt_device", 1785 .release = tb_switch_release, 1786 .pm = &tb_switch_pm_ops, 1787 }; 1788 1789 static int tb_switch_get_generation(struct tb_switch *sw) 1790 { 1791 switch (sw->config.device_id) { 1792 case PCI_DEVICE_ID_INTEL_LIGHT_RIDGE: 1793 case PCI_DEVICE_ID_INTEL_EAGLE_RIDGE: 1794 case PCI_DEVICE_ID_INTEL_LIGHT_PEAK: 1795 case PCI_DEVICE_ID_INTEL_CACTUS_RIDGE_2C: 1796 case PCI_DEVICE_ID_INTEL_CACTUS_RIDGE_4C: 1797 case PCI_DEVICE_ID_INTEL_PORT_RIDGE: 1798 case PCI_DEVICE_ID_INTEL_REDWOOD_RIDGE_2C_BRIDGE: 1799 case PCI_DEVICE_ID_INTEL_REDWOOD_RIDGE_4C_BRIDGE: 1800 return 1; 1801 1802 case PCI_DEVICE_ID_INTEL_WIN_RIDGE_2C_BRIDGE: 1803 case PCI_DEVICE_ID_INTEL_FALCON_RIDGE_2C_BRIDGE: 1804 case PCI_DEVICE_ID_INTEL_FALCON_RIDGE_4C_BRIDGE: 1805 return 2; 1806 1807 case PCI_DEVICE_ID_INTEL_ALPINE_RIDGE_LP_BRIDGE: 1808 case PCI_DEVICE_ID_INTEL_ALPINE_RIDGE_2C_BRIDGE: 1809 case PCI_DEVICE_ID_INTEL_ALPINE_RIDGE_4C_BRIDGE: 1810 case PCI_DEVICE_ID_INTEL_ALPINE_RIDGE_C_2C_BRIDGE: 1811 case PCI_DEVICE_ID_INTEL_ALPINE_RIDGE_C_4C_BRIDGE: 1812 case PCI_DEVICE_ID_INTEL_TITAN_RIDGE_2C_BRIDGE: 1813 case PCI_DEVICE_ID_INTEL_TITAN_RIDGE_4C_BRIDGE: 1814 case PCI_DEVICE_ID_INTEL_TITAN_RIDGE_DD_BRIDGE: 1815 case PCI_DEVICE_ID_INTEL_ICL_NHI0: 1816 case PCI_DEVICE_ID_INTEL_ICL_NHI1: 1817 return 3; 1818 1819 default: 1820 if (tb_switch_is_usb4(sw)) 1821 return 4; 1822 1823 /* 1824 * For unknown switches assume generation to be 1 to be 1825 * on the safe side. 1826 */ 1827 tb_sw_warn(sw, "unsupported switch device id %#x\n", 1828 sw->config.device_id); 1829 return 1; 1830 } 1831 } 1832 1833 static bool tb_switch_exceeds_max_depth(const struct tb_switch *sw, int depth) 1834 { 1835 int max_depth; 1836 1837 if (tb_switch_is_usb4(sw) || 1838 (sw->tb->root_switch && tb_switch_is_usb4(sw->tb->root_switch))) 1839 max_depth = USB4_SWITCH_MAX_DEPTH; 1840 else 1841 max_depth = TB_SWITCH_MAX_DEPTH; 1842 1843 return depth > max_depth; 1844 } 1845 1846 /** 1847 * tb_switch_alloc() - allocate a switch 1848 * @tb: Pointer to the owning domain 1849 * @parent: Parent device for this switch 1850 * @route: Route string for this switch 1851 * 1852 * Allocates and initializes a switch. Will not upload configuration to 1853 * the switch. For that you need to call tb_switch_configure() 1854 * separately. The returned switch should be released by calling 1855 * tb_switch_put(). 1856 * 1857 * Return: Pointer to the allocated switch or ERR_PTR() in case of 1858 * failure. 1859 */ 1860 struct tb_switch *tb_switch_alloc(struct tb *tb, struct device *parent, 1861 u64 route) 1862 { 1863 struct tb_switch *sw; 1864 int upstream_port; 1865 int i, ret, depth; 1866 1867 /* Unlock the downstream port so we can access the switch below */ 1868 if (route) { 1869 struct tb_switch *parent_sw = tb_to_switch(parent); 1870 struct tb_port *down; 1871 1872 down = tb_port_at(route, parent_sw); 1873 tb_port_unlock(down); 1874 } 1875 1876 depth = tb_route_length(route); 1877 1878 upstream_port = tb_cfg_get_upstream_port(tb->ctl, route); 1879 if (upstream_port < 0) 1880 return ERR_PTR(upstream_port); 1881 1882 sw = kzalloc(sizeof(*sw), GFP_KERNEL); 1883 if (!sw) 1884 return ERR_PTR(-ENOMEM); 1885 1886 sw->tb = tb; 1887 ret = tb_cfg_read(tb->ctl, &sw->config, route, 0, TB_CFG_SWITCH, 0, 5); 1888 if (ret) 1889 goto err_free_sw_ports; 1890 1891 sw->generation = tb_switch_get_generation(sw); 1892 1893 tb_dbg(tb, "current switch config:\n"); 1894 tb_dump_switch(tb, sw); 1895 1896 /* configure switch */ 1897 sw->config.upstream_port_number = upstream_port; 1898 sw->config.depth = depth; 1899 sw->config.route_hi = upper_32_bits(route); 1900 sw->config.route_lo = lower_32_bits(route); 1901 sw->config.enabled = 0; 1902 1903 /* Make sure we do not exceed maximum topology limit */ 1904 if (tb_switch_exceeds_max_depth(sw, depth)) { 1905 ret = -EADDRNOTAVAIL; 1906 goto err_free_sw_ports; 1907 } 1908 1909 /* initialize ports */ 1910 sw->ports = kcalloc(sw->config.max_port_number + 1, sizeof(*sw->ports), 1911 GFP_KERNEL); 1912 if (!sw->ports) { 1913 ret = -ENOMEM; 1914 goto err_free_sw_ports; 1915 } 1916 1917 for (i = 0; i <= sw->config.max_port_number; i++) { 1918 /* minimum setup for tb_find_cap and tb_drom_read to work */ 1919 sw->ports[i].sw = sw; 1920 sw->ports[i].port = i; 1921 } 1922 1923 ret = tb_switch_find_vse_cap(sw, TB_VSE_CAP_PLUG_EVENTS); 1924 if (ret > 0) 1925 sw->cap_plug_events = ret; 1926 1927 ret = tb_switch_find_vse_cap(sw, TB_VSE_CAP_LINK_CONTROLLER); 1928 if (ret > 0) 1929 sw->cap_lc = ret; 1930 1931 /* Root switch is always authorized */ 1932 if (!route) 1933 sw->authorized = true; 1934 1935 device_initialize(&sw->dev); 1936 sw->dev.parent = parent; 1937 sw->dev.bus = &tb_bus_type; 1938 sw->dev.type = &tb_switch_type; 1939 sw->dev.groups = switch_groups; 1940 dev_set_name(&sw->dev, "%u-%llx", tb->index, tb_route(sw)); 1941 1942 return sw; 1943 1944 err_free_sw_ports: 1945 kfree(sw->ports); 1946 kfree(sw); 1947 1948 return ERR_PTR(ret); 1949 } 1950 1951 /** 1952 * tb_switch_alloc_safe_mode() - allocate a switch that is in safe mode 1953 * @tb: Pointer to the owning domain 1954 * @parent: Parent device for this switch 1955 * @route: Route string for this switch 1956 * 1957 * This creates a switch in safe mode. This means the switch pretty much 1958 * lacks all capabilities except DMA configuration port before it is 1959 * flashed with a valid NVM firmware. 1960 * 1961 * The returned switch must be released by calling tb_switch_put(). 1962 * 1963 * Return: Pointer to the allocated switch or ERR_PTR() in case of failure 1964 */ 1965 struct tb_switch * 1966 tb_switch_alloc_safe_mode(struct tb *tb, struct device *parent, u64 route) 1967 { 1968 struct tb_switch *sw; 1969 1970 sw = kzalloc(sizeof(*sw), GFP_KERNEL); 1971 if (!sw) 1972 return ERR_PTR(-ENOMEM); 1973 1974 sw->tb = tb; 1975 sw->config.depth = tb_route_length(route); 1976 sw->config.route_hi = upper_32_bits(route); 1977 sw->config.route_lo = lower_32_bits(route); 1978 sw->safe_mode = true; 1979 1980 device_initialize(&sw->dev); 1981 sw->dev.parent = parent; 1982 sw->dev.bus = &tb_bus_type; 1983 sw->dev.type = &tb_switch_type; 1984 sw->dev.groups = switch_groups; 1985 dev_set_name(&sw->dev, "%u-%llx", tb->index, tb_route(sw)); 1986 1987 return sw; 1988 } 1989 1990 /** 1991 * tb_switch_configure() - Uploads configuration to the switch 1992 * @sw: Switch to configure 1993 * 1994 * Call this function before the switch is added to the system. It will 1995 * upload configuration to the switch and makes it available for the 1996 * connection manager to use. Can be called to the switch again after 1997 * resume from low power states to re-initialize it. 1998 * 1999 * Return: %0 in case of success and negative errno in case of failure 2000 */ 2001 int tb_switch_configure(struct tb_switch *sw) 2002 { 2003 struct tb *tb = sw->tb; 2004 u64 route; 2005 int ret; 2006 2007 route = tb_route(sw); 2008 2009 tb_dbg(tb, "%s Switch at %#llx (depth: %d, up port: %d)\n", 2010 sw->config.enabled ? "restoring " : "initializing", route, 2011 tb_route_length(route), sw->config.upstream_port_number); 2012 2013 sw->config.enabled = 1; 2014 2015 if (tb_switch_is_usb4(sw)) { 2016 /* 2017 * For USB4 devices, we need to program the CM version 2018 * accordingly so that it knows to expose all the 2019 * additional capabilities. 2020 */ 2021 sw->config.cmuv = USB4_VERSION_1_0; 2022 2023 /* Enumerate the switch */ 2024 ret = tb_sw_write(sw, (u32 *)&sw->config + 1, TB_CFG_SWITCH, 2025 ROUTER_CS_1, 4); 2026 if (ret) 2027 return ret; 2028 2029 ret = usb4_switch_setup(sw); 2030 if (ret) 2031 return ret; 2032 2033 ret = usb4_switch_configure_link(sw); 2034 } else { 2035 if (sw->config.vendor_id != PCI_VENDOR_ID_INTEL) 2036 tb_sw_warn(sw, "unknown switch vendor id %#x\n", 2037 sw->config.vendor_id); 2038 2039 if (!sw->cap_plug_events) { 2040 tb_sw_warn(sw, "cannot find TB_VSE_CAP_PLUG_EVENTS aborting\n"); 2041 return -ENODEV; 2042 } 2043 2044 /* Enumerate the switch */ 2045 ret = tb_sw_write(sw, (u32 *)&sw->config + 1, TB_CFG_SWITCH, 2046 ROUTER_CS_1, 3); 2047 if (ret) 2048 return ret; 2049 2050 ret = tb_lc_configure_link(sw); 2051 } 2052 if (ret) 2053 return ret; 2054 2055 return tb_plug_events_active(sw, true); 2056 } 2057 2058 static int tb_switch_set_uuid(struct tb_switch *sw) 2059 { 2060 bool uid = false; 2061 u32 uuid[4]; 2062 int ret; 2063 2064 if (sw->uuid) 2065 return 0; 2066 2067 if (tb_switch_is_usb4(sw)) { 2068 ret = usb4_switch_read_uid(sw, &sw->uid); 2069 if (ret) 2070 return ret; 2071 uid = true; 2072 } else { 2073 /* 2074 * The newer controllers include fused UUID as part of 2075 * link controller specific registers 2076 */ 2077 ret = tb_lc_read_uuid(sw, uuid); 2078 if (ret) { 2079 if (ret != -EINVAL) 2080 return ret; 2081 uid = true; 2082 } 2083 } 2084 2085 if (uid) { 2086 /* 2087 * ICM generates UUID based on UID and fills the upper 2088 * two words with ones. This is not strictly following 2089 * UUID format but we want to be compatible with it so 2090 * we do the same here. 2091 */ 2092 uuid[0] = sw->uid & 0xffffffff; 2093 uuid[1] = (sw->uid >> 32) & 0xffffffff; 2094 uuid[2] = 0xffffffff; 2095 uuid[3] = 0xffffffff; 2096 } 2097 2098 sw->uuid = kmemdup(uuid, sizeof(uuid), GFP_KERNEL); 2099 if (!sw->uuid) 2100 return -ENOMEM; 2101 return 0; 2102 } 2103 2104 static int tb_switch_add_dma_port(struct tb_switch *sw) 2105 { 2106 u32 status; 2107 int ret; 2108 2109 switch (sw->generation) { 2110 case 2: 2111 /* Only root switch can be upgraded */ 2112 if (tb_route(sw)) 2113 return 0; 2114 2115 /* fallthrough */ 2116 case 3: 2117 ret = tb_switch_set_uuid(sw); 2118 if (ret) 2119 return ret; 2120 break; 2121 2122 default: 2123 /* 2124 * DMA port is the only thing available when the switch 2125 * is in safe mode. 2126 */ 2127 if (!sw->safe_mode) 2128 return 0; 2129 break; 2130 } 2131 2132 /* Root switch DMA port requires running firmware */ 2133 if (!tb_route(sw) && !tb_switch_is_icm(sw)) 2134 return 0; 2135 2136 sw->dma_port = dma_port_alloc(sw); 2137 if (!sw->dma_port) 2138 return 0; 2139 2140 if (sw->no_nvm_upgrade) 2141 return 0; 2142 2143 /* 2144 * If there is status already set then authentication failed 2145 * when the dma_port_flash_update_auth() returned. Power cycling 2146 * is not needed (it was done already) so only thing we do here 2147 * is to unblock runtime PM of the root port. 2148 */ 2149 nvm_get_auth_status(sw, &status); 2150 if (status) { 2151 if (!tb_route(sw)) 2152 nvm_authenticate_complete_dma_port(sw); 2153 return 0; 2154 } 2155 2156 /* 2157 * Check status of the previous flash authentication. If there 2158 * is one we need to power cycle the switch in any case to make 2159 * it functional again. 2160 */ 2161 ret = dma_port_flash_update_auth_status(sw->dma_port, &status); 2162 if (ret <= 0) 2163 return ret; 2164 2165 /* Now we can allow root port to suspend again */ 2166 if (!tb_route(sw)) 2167 nvm_authenticate_complete_dma_port(sw); 2168 2169 if (status) { 2170 tb_sw_info(sw, "switch flash authentication failed\n"); 2171 nvm_set_auth_status(sw, status); 2172 } 2173 2174 tb_sw_info(sw, "power cycling the switch now\n"); 2175 dma_port_power_cycle(sw->dma_port); 2176 2177 /* 2178 * We return error here which causes the switch adding failure. 2179 * It should appear back after power cycle is complete. 2180 */ 2181 return -ESHUTDOWN; 2182 } 2183 2184 static void tb_switch_default_link_ports(struct tb_switch *sw) 2185 { 2186 int i; 2187 2188 for (i = 1; i <= sw->config.max_port_number; i += 2) { 2189 struct tb_port *port = &sw->ports[i]; 2190 struct tb_port *subordinate; 2191 2192 if (!tb_port_is_null(port)) 2193 continue; 2194 2195 /* Check for the subordinate port */ 2196 if (i == sw->config.max_port_number || 2197 !tb_port_is_null(&sw->ports[i + 1])) 2198 continue; 2199 2200 /* Link them if not already done so (by DROM) */ 2201 subordinate = &sw->ports[i + 1]; 2202 if (!port->dual_link_port && !subordinate->dual_link_port) { 2203 port->link_nr = 0; 2204 port->dual_link_port = subordinate; 2205 subordinate->link_nr = 1; 2206 subordinate->dual_link_port = port; 2207 2208 tb_sw_dbg(sw, "linked ports %d <-> %d\n", 2209 port->port, subordinate->port); 2210 } 2211 } 2212 } 2213 2214 static bool tb_switch_lane_bonding_possible(struct tb_switch *sw) 2215 { 2216 const struct tb_port *up = tb_upstream_port(sw); 2217 2218 if (!up->dual_link_port || !up->dual_link_port->remote) 2219 return false; 2220 2221 if (tb_switch_is_usb4(sw)) 2222 return usb4_switch_lane_bonding_possible(sw); 2223 return tb_lc_lane_bonding_possible(sw); 2224 } 2225 2226 static int tb_switch_update_link_attributes(struct tb_switch *sw) 2227 { 2228 struct tb_port *up; 2229 bool change = false; 2230 int ret; 2231 2232 if (!tb_route(sw) || tb_switch_is_icm(sw)) 2233 return 0; 2234 2235 up = tb_upstream_port(sw); 2236 2237 ret = tb_port_get_link_speed(up); 2238 if (ret < 0) 2239 return ret; 2240 if (sw->link_speed != ret) 2241 change = true; 2242 sw->link_speed = ret; 2243 2244 ret = tb_port_get_link_width(up); 2245 if (ret < 0) 2246 return ret; 2247 if (sw->link_width != ret) 2248 change = true; 2249 sw->link_width = ret; 2250 2251 /* Notify userspace that there is possible link attribute change */ 2252 if (device_is_registered(&sw->dev) && change) 2253 kobject_uevent(&sw->dev.kobj, KOBJ_CHANGE); 2254 2255 return 0; 2256 } 2257 2258 /** 2259 * tb_switch_lane_bonding_enable() - Enable lane bonding 2260 * @sw: Switch to enable lane bonding 2261 * 2262 * Connection manager can call this function to enable lane bonding of a 2263 * switch. If conditions are correct and both switches support the feature, 2264 * lanes are bonded. It is safe to call this to any switch. 2265 */ 2266 int tb_switch_lane_bonding_enable(struct tb_switch *sw) 2267 { 2268 struct tb_switch *parent = tb_to_switch(sw->dev.parent); 2269 struct tb_port *up, *down; 2270 u64 route = tb_route(sw); 2271 int ret; 2272 2273 if (!route) 2274 return 0; 2275 2276 if (!tb_switch_lane_bonding_possible(sw)) 2277 return 0; 2278 2279 up = tb_upstream_port(sw); 2280 down = tb_port_at(route, parent); 2281 2282 if (!tb_port_is_width_supported(up, 2) || 2283 !tb_port_is_width_supported(down, 2)) 2284 return 0; 2285 2286 ret = tb_port_lane_bonding_enable(up); 2287 if (ret) { 2288 tb_port_warn(up, "failed to enable lane bonding\n"); 2289 return ret; 2290 } 2291 2292 ret = tb_port_lane_bonding_enable(down); 2293 if (ret) { 2294 tb_port_warn(down, "failed to enable lane bonding\n"); 2295 tb_port_lane_bonding_disable(up); 2296 return ret; 2297 } 2298 2299 tb_switch_update_link_attributes(sw); 2300 2301 tb_sw_dbg(sw, "lane bonding enabled\n"); 2302 return ret; 2303 } 2304 2305 /** 2306 * tb_switch_lane_bonding_disable() - Disable lane bonding 2307 * @sw: Switch whose lane bonding to disable 2308 * 2309 * Disables lane bonding between @sw and parent. This can be called even 2310 * if lanes were not bonded originally. 2311 */ 2312 void tb_switch_lane_bonding_disable(struct tb_switch *sw) 2313 { 2314 struct tb_switch *parent = tb_to_switch(sw->dev.parent); 2315 struct tb_port *up, *down; 2316 2317 if (!tb_route(sw)) 2318 return; 2319 2320 up = tb_upstream_port(sw); 2321 if (!up->bonded) 2322 return; 2323 2324 down = tb_port_at(tb_route(sw), parent); 2325 2326 tb_port_lane_bonding_disable(up); 2327 tb_port_lane_bonding_disable(down); 2328 2329 tb_switch_update_link_attributes(sw); 2330 tb_sw_dbg(sw, "lane bonding disabled\n"); 2331 } 2332 2333 /** 2334 * tb_switch_add() - Add a switch to the domain 2335 * @sw: Switch to add 2336 * 2337 * This is the last step in adding switch to the domain. It will read 2338 * identification information from DROM and initializes ports so that 2339 * they can be used to connect other switches. The switch will be 2340 * exposed to the userspace when this function successfully returns. To 2341 * remove and release the switch, call tb_switch_remove(). 2342 * 2343 * Return: %0 in case of success and negative errno in case of failure 2344 */ 2345 int tb_switch_add(struct tb_switch *sw) 2346 { 2347 int i, ret; 2348 2349 /* 2350 * Initialize DMA control port now before we read DROM. Recent 2351 * host controllers have more complete DROM on NVM that includes 2352 * vendor and model identification strings which we then expose 2353 * to the userspace. NVM can be accessed through DMA 2354 * configuration based mailbox. 2355 */ 2356 ret = tb_switch_add_dma_port(sw); 2357 if (ret) { 2358 dev_err(&sw->dev, "failed to add DMA port\n"); 2359 return ret; 2360 } 2361 2362 if (!sw->safe_mode) { 2363 /* read drom */ 2364 ret = tb_drom_read(sw); 2365 if (ret) { 2366 dev_err(&sw->dev, "reading DROM failed\n"); 2367 return ret; 2368 } 2369 tb_sw_dbg(sw, "uid: %#llx\n", sw->uid); 2370 2371 ret = tb_switch_set_uuid(sw); 2372 if (ret) { 2373 dev_err(&sw->dev, "failed to set UUID\n"); 2374 return ret; 2375 } 2376 2377 for (i = 0; i <= sw->config.max_port_number; i++) { 2378 if (sw->ports[i].disabled) { 2379 tb_port_dbg(&sw->ports[i], "disabled by eeprom\n"); 2380 continue; 2381 } 2382 ret = tb_init_port(&sw->ports[i]); 2383 if (ret) { 2384 dev_err(&sw->dev, "failed to initialize port %d\n", i); 2385 return ret; 2386 } 2387 } 2388 2389 tb_switch_default_link_ports(sw); 2390 2391 ret = tb_switch_update_link_attributes(sw); 2392 if (ret) 2393 return ret; 2394 2395 ret = tb_switch_tmu_init(sw); 2396 if (ret) 2397 return ret; 2398 } 2399 2400 ret = device_add(&sw->dev); 2401 if (ret) { 2402 dev_err(&sw->dev, "failed to add device: %d\n", ret); 2403 return ret; 2404 } 2405 2406 if (tb_route(sw)) { 2407 dev_info(&sw->dev, "new device found, vendor=%#x device=%#x\n", 2408 sw->vendor, sw->device); 2409 if (sw->vendor_name && sw->device_name) 2410 dev_info(&sw->dev, "%s %s\n", sw->vendor_name, 2411 sw->device_name); 2412 } 2413 2414 ret = tb_switch_nvm_add(sw); 2415 if (ret) { 2416 dev_err(&sw->dev, "failed to add NVM devices\n"); 2417 device_del(&sw->dev); 2418 return ret; 2419 } 2420 2421 pm_runtime_set_active(&sw->dev); 2422 if (sw->rpm) { 2423 pm_runtime_set_autosuspend_delay(&sw->dev, TB_AUTOSUSPEND_DELAY); 2424 pm_runtime_use_autosuspend(&sw->dev); 2425 pm_runtime_mark_last_busy(&sw->dev); 2426 pm_runtime_enable(&sw->dev); 2427 pm_request_autosuspend(&sw->dev); 2428 } 2429 2430 return 0; 2431 } 2432 2433 /** 2434 * tb_switch_remove() - Remove and release a switch 2435 * @sw: Switch to remove 2436 * 2437 * This will remove the switch from the domain and release it after last 2438 * reference count drops to zero. If there are switches connected below 2439 * this switch, they will be removed as well. 2440 */ 2441 void tb_switch_remove(struct tb_switch *sw) 2442 { 2443 struct tb_port *port; 2444 2445 if (sw->rpm) { 2446 pm_runtime_get_sync(&sw->dev); 2447 pm_runtime_disable(&sw->dev); 2448 } 2449 2450 /* port 0 is the switch itself and never has a remote */ 2451 tb_switch_for_each_port(sw, port) { 2452 if (tb_port_has_remote(port)) { 2453 tb_switch_remove(port->remote->sw); 2454 port->remote = NULL; 2455 } else if (port->xdomain) { 2456 tb_xdomain_remove(port->xdomain); 2457 port->xdomain = NULL; 2458 } 2459 } 2460 2461 if (!sw->is_unplugged) 2462 tb_plug_events_active(sw, false); 2463 2464 if (tb_switch_is_usb4(sw)) 2465 usb4_switch_unconfigure_link(sw); 2466 else 2467 tb_lc_unconfigure_link(sw); 2468 2469 tb_switch_nvm_remove(sw); 2470 2471 if (tb_route(sw)) 2472 dev_info(&sw->dev, "device disconnected\n"); 2473 device_unregister(&sw->dev); 2474 } 2475 2476 /** 2477 * tb_sw_set_unplugged() - set is_unplugged on switch and downstream switches 2478 */ 2479 void tb_sw_set_unplugged(struct tb_switch *sw) 2480 { 2481 struct tb_port *port; 2482 2483 if (sw == sw->tb->root_switch) { 2484 tb_sw_WARN(sw, "cannot unplug root switch\n"); 2485 return; 2486 } 2487 if (sw->is_unplugged) { 2488 tb_sw_WARN(sw, "is_unplugged already set\n"); 2489 return; 2490 } 2491 sw->is_unplugged = true; 2492 tb_switch_for_each_port(sw, port) { 2493 if (tb_port_has_remote(port)) 2494 tb_sw_set_unplugged(port->remote->sw); 2495 else if (port->xdomain) 2496 port->xdomain->is_unplugged = true; 2497 } 2498 } 2499 2500 int tb_switch_resume(struct tb_switch *sw) 2501 { 2502 struct tb_port *port; 2503 int err; 2504 2505 tb_sw_dbg(sw, "resuming switch\n"); 2506 2507 /* 2508 * Check for UID of the connected switches except for root 2509 * switch which we assume cannot be removed. 2510 */ 2511 if (tb_route(sw)) { 2512 u64 uid; 2513 2514 /* 2515 * Check first that we can still read the switch config 2516 * space. It may be that there is now another domain 2517 * connected. 2518 */ 2519 err = tb_cfg_get_upstream_port(sw->tb->ctl, tb_route(sw)); 2520 if (err < 0) { 2521 tb_sw_info(sw, "switch not present anymore\n"); 2522 return err; 2523 } 2524 2525 if (tb_switch_is_usb4(sw)) 2526 err = usb4_switch_read_uid(sw, &uid); 2527 else 2528 err = tb_drom_read_uid_only(sw, &uid); 2529 if (err) { 2530 tb_sw_warn(sw, "uid read failed\n"); 2531 return err; 2532 } 2533 if (sw->uid != uid) { 2534 tb_sw_info(sw, 2535 "changed while suspended (uid %#llx -> %#llx)\n", 2536 sw->uid, uid); 2537 return -ENODEV; 2538 } 2539 } 2540 2541 err = tb_switch_configure(sw); 2542 if (err) 2543 return err; 2544 2545 /* check for surviving downstream switches */ 2546 tb_switch_for_each_port(sw, port) { 2547 if (!tb_port_has_remote(port) && !port->xdomain) 2548 continue; 2549 2550 if (tb_wait_for_port(port, true) <= 0) { 2551 tb_port_warn(port, 2552 "lost during suspend, disconnecting\n"); 2553 if (tb_port_has_remote(port)) 2554 tb_sw_set_unplugged(port->remote->sw); 2555 else if (port->xdomain) 2556 port->xdomain->is_unplugged = true; 2557 } else if (tb_port_has_remote(port) || port->xdomain) { 2558 /* 2559 * Always unlock the port so the downstream 2560 * switch/domain is accessible. 2561 */ 2562 if (tb_port_unlock(port)) 2563 tb_port_warn(port, "failed to unlock port\n"); 2564 if (port->remote && tb_switch_resume(port->remote->sw)) { 2565 tb_port_warn(port, 2566 "lost during suspend, disconnecting\n"); 2567 tb_sw_set_unplugged(port->remote->sw); 2568 } 2569 } 2570 } 2571 return 0; 2572 } 2573 2574 void tb_switch_suspend(struct tb_switch *sw) 2575 { 2576 struct tb_port *port; 2577 int err; 2578 2579 err = tb_plug_events_active(sw, false); 2580 if (err) 2581 return; 2582 2583 tb_switch_for_each_port(sw, port) { 2584 if (tb_port_has_remote(port)) 2585 tb_switch_suspend(port->remote->sw); 2586 } 2587 2588 if (tb_switch_is_usb4(sw)) 2589 usb4_switch_set_sleep(sw); 2590 else 2591 tb_lc_set_sleep(sw); 2592 } 2593 2594 /** 2595 * tb_switch_query_dp_resource() - Query availability of DP resource 2596 * @sw: Switch whose DP resource is queried 2597 * @in: DP IN port 2598 * 2599 * Queries availability of DP resource for DP tunneling using switch 2600 * specific means. Returns %true if resource is available. 2601 */ 2602 bool tb_switch_query_dp_resource(struct tb_switch *sw, struct tb_port *in) 2603 { 2604 if (tb_switch_is_usb4(sw)) 2605 return usb4_switch_query_dp_resource(sw, in); 2606 return tb_lc_dp_sink_query(sw, in); 2607 } 2608 2609 /** 2610 * tb_switch_alloc_dp_resource() - Allocate available DP resource 2611 * @sw: Switch whose DP resource is allocated 2612 * @in: DP IN port 2613 * 2614 * Allocates DP resource for DP tunneling. The resource must be 2615 * available for this to succeed (see tb_switch_query_dp_resource()). 2616 * Returns %0 in success and negative errno otherwise. 2617 */ 2618 int tb_switch_alloc_dp_resource(struct tb_switch *sw, struct tb_port *in) 2619 { 2620 if (tb_switch_is_usb4(sw)) 2621 return usb4_switch_alloc_dp_resource(sw, in); 2622 return tb_lc_dp_sink_alloc(sw, in); 2623 } 2624 2625 /** 2626 * tb_switch_dealloc_dp_resource() - De-allocate DP resource 2627 * @sw: Switch whose DP resource is de-allocated 2628 * @in: DP IN port 2629 * 2630 * De-allocates DP resource that was previously allocated for DP 2631 * tunneling. 2632 */ 2633 void tb_switch_dealloc_dp_resource(struct tb_switch *sw, struct tb_port *in) 2634 { 2635 int ret; 2636 2637 if (tb_switch_is_usb4(sw)) 2638 ret = usb4_switch_dealloc_dp_resource(sw, in); 2639 else 2640 ret = tb_lc_dp_sink_dealloc(sw, in); 2641 2642 if (ret) 2643 tb_sw_warn(sw, "failed to de-allocate DP resource for port %d\n", 2644 in->port); 2645 } 2646 2647 struct tb_sw_lookup { 2648 struct tb *tb; 2649 u8 link; 2650 u8 depth; 2651 const uuid_t *uuid; 2652 u64 route; 2653 }; 2654 2655 static int tb_switch_match(struct device *dev, const void *data) 2656 { 2657 struct tb_switch *sw = tb_to_switch(dev); 2658 const struct tb_sw_lookup *lookup = data; 2659 2660 if (!sw) 2661 return 0; 2662 if (sw->tb != lookup->tb) 2663 return 0; 2664 2665 if (lookup->uuid) 2666 return !memcmp(sw->uuid, lookup->uuid, sizeof(*lookup->uuid)); 2667 2668 if (lookup->route) { 2669 return sw->config.route_lo == lower_32_bits(lookup->route) && 2670 sw->config.route_hi == upper_32_bits(lookup->route); 2671 } 2672 2673 /* Root switch is matched only by depth */ 2674 if (!lookup->depth) 2675 return !sw->depth; 2676 2677 return sw->link == lookup->link && sw->depth == lookup->depth; 2678 } 2679 2680 /** 2681 * tb_switch_find_by_link_depth() - Find switch by link and depth 2682 * @tb: Domain the switch belongs 2683 * @link: Link number the switch is connected 2684 * @depth: Depth of the switch in link 2685 * 2686 * Returned switch has reference count increased so the caller needs to 2687 * call tb_switch_put() when done with the switch. 2688 */ 2689 struct tb_switch *tb_switch_find_by_link_depth(struct tb *tb, u8 link, u8 depth) 2690 { 2691 struct tb_sw_lookup lookup; 2692 struct device *dev; 2693 2694 memset(&lookup, 0, sizeof(lookup)); 2695 lookup.tb = tb; 2696 lookup.link = link; 2697 lookup.depth = depth; 2698 2699 dev = bus_find_device(&tb_bus_type, NULL, &lookup, tb_switch_match); 2700 if (dev) 2701 return tb_to_switch(dev); 2702 2703 return NULL; 2704 } 2705 2706 /** 2707 * tb_switch_find_by_uuid() - Find switch by UUID 2708 * @tb: Domain the switch belongs 2709 * @uuid: UUID to look for 2710 * 2711 * Returned switch has reference count increased so the caller needs to 2712 * call tb_switch_put() when done with the switch. 2713 */ 2714 struct tb_switch *tb_switch_find_by_uuid(struct tb *tb, const uuid_t *uuid) 2715 { 2716 struct tb_sw_lookup lookup; 2717 struct device *dev; 2718 2719 memset(&lookup, 0, sizeof(lookup)); 2720 lookup.tb = tb; 2721 lookup.uuid = uuid; 2722 2723 dev = bus_find_device(&tb_bus_type, NULL, &lookup, tb_switch_match); 2724 if (dev) 2725 return tb_to_switch(dev); 2726 2727 return NULL; 2728 } 2729 2730 /** 2731 * tb_switch_find_by_route() - Find switch by route string 2732 * @tb: Domain the switch belongs 2733 * @route: Route string to look for 2734 * 2735 * Returned switch has reference count increased so the caller needs to 2736 * call tb_switch_put() when done with the switch. 2737 */ 2738 struct tb_switch *tb_switch_find_by_route(struct tb *tb, u64 route) 2739 { 2740 struct tb_sw_lookup lookup; 2741 struct device *dev; 2742 2743 if (!route) 2744 return tb_switch_get(tb->root_switch); 2745 2746 memset(&lookup, 0, sizeof(lookup)); 2747 lookup.tb = tb; 2748 lookup.route = route; 2749 2750 dev = bus_find_device(&tb_bus_type, NULL, &lookup, tb_switch_match); 2751 if (dev) 2752 return tb_to_switch(dev); 2753 2754 return NULL; 2755 } 2756 2757 /** 2758 * tb_switch_find_port() - return the first port of @type on @sw or NULL 2759 * @sw: Switch to find the port from 2760 * @type: Port type to look for 2761 */ 2762 struct tb_port *tb_switch_find_port(struct tb_switch *sw, 2763 enum tb_port_type type) 2764 { 2765 struct tb_port *port; 2766 2767 tb_switch_for_each_port(sw, port) { 2768 if (port->config.type == type) 2769 return port; 2770 } 2771 2772 return NULL; 2773 } 2774 2775 void tb_switch_exit(void) 2776 { 2777 ida_destroy(&nvm_ida); 2778 } 2779