1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * PCI Hotplug Driver for PowerPC PowerNV platform. 4 * 5 * Copyright Gavin Shan, IBM Corporation 2016. 6 */ 7 8 #include <linux/libfdt.h> 9 #include <linux/module.h> 10 #include <linux/pci.h> 11 #include <linux/pci_hotplug.h> 12 13 #include <asm/opal.h> 14 #include <asm/pnv-pci.h> 15 #include <asm/ppc-pci.h> 16 17 #define DRIVER_VERSION "0.1" 18 #define DRIVER_AUTHOR "Gavin Shan, IBM Corporation" 19 #define DRIVER_DESC "PowerPC PowerNV PCI Hotplug Driver" 20 21 #define SLOT_WARN(sl, x...) \ 22 ((sl)->pdev ? pci_warn((sl)->pdev, x) : dev_warn(&(sl)->bus->dev, x)) 23 24 struct pnv_php_event { 25 bool added; 26 struct pnv_php_slot *php_slot; 27 struct work_struct work; 28 }; 29 30 static LIST_HEAD(pnv_php_slot_list); 31 static DEFINE_SPINLOCK(pnv_php_lock); 32 33 static void pnv_php_register(struct device_node *dn); 34 static void pnv_php_unregister_one(struct device_node *dn); 35 static void pnv_php_unregister(struct device_node *dn); 36 37 static void pnv_php_disable_irq(struct pnv_php_slot *php_slot, 38 bool disable_device) 39 { 40 struct pci_dev *pdev = php_slot->pdev; 41 int irq = php_slot->irq; 42 u16 ctrl; 43 44 if (php_slot->irq > 0) { 45 pcie_capability_read_word(pdev, PCI_EXP_SLTCTL, &ctrl); 46 ctrl &= ~(PCI_EXP_SLTCTL_HPIE | 47 PCI_EXP_SLTCTL_PDCE | 48 PCI_EXP_SLTCTL_DLLSCE); 49 pcie_capability_write_word(pdev, PCI_EXP_SLTCTL, ctrl); 50 51 free_irq(php_slot->irq, php_slot); 52 php_slot->irq = 0; 53 } 54 55 if (php_slot->wq) { 56 destroy_workqueue(php_slot->wq); 57 php_slot->wq = NULL; 58 } 59 60 if (disable_device || irq > 0) { 61 if (pdev->msix_enabled) 62 pci_disable_msix(pdev); 63 else if (pdev->msi_enabled) 64 pci_disable_msi(pdev); 65 66 pci_disable_device(pdev); 67 } 68 } 69 70 static void pnv_php_free_slot(struct kref *kref) 71 { 72 struct pnv_php_slot *php_slot = container_of(kref, 73 struct pnv_php_slot, kref); 74 75 WARN_ON(!list_empty(&php_slot->children)); 76 pnv_php_disable_irq(php_slot, false); 77 kfree(php_slot->name); 78 kfree(php_slot); 79 } 80 81 static inline void pnv_php_put_slot(struct pnv_php_slot *php_slot) 82 { 83 84 if (!php_slot) 85 return; 86 87 kref_put(&php_slot->kref, pnv_php_free_slot); 88 } 89 90 static struct pnv_php_slot *pnv_php_match(struct device_node *dn, 91 struct pnv_php_slot *php_slot) 92 { 93 struct pnv_php_slot *target, *tmp; 94 95 if (php_slot->dn == dn) { 96 kref_get(&php_slot->kref); 97 return php_slot; 98 } 99 100 list_for_each_entry(tmp, &php_slot->children, link) { 101 target = pnv_php_match(dn, tmp); 102 if (target) 103 return target; 104 } 105 106 return NULL; 107 } 108 109 struct pnv_php_slot *pnv_php_find_slot(struct device_node *dn) 110 { 111 struct pnv_php_slot *php_slot, *tmp; 112 unsigned long flags; 113 114 spin_lock_irqsave(&pnv_php_lock, flags); 115 list_for_each_entry(tmp, &pnv_php_slot_list, link) { 116 php_slot = pnv_php_match(dn, tmp); 117 if (php_slot) { 118 spin_unlock_irqrestore(&pnv_php_lock, flags); 119 return php_slot; 120 } 121 } 122 spin_unlock_irqrestore(&pnv_php_lock, flags); 123 124 return NULL; 125 } 126 EXPORT_SYMBOL_GPL(pnv_php_find_slot); 127 128 /* 129 * Remove pdn for all children of the indicated device node. 130 * The function should remove pdn in a depth-first manner. 131 */ 132 static void pnv_php_rmv_pdns(struct device_node *dn) 133 { 134 struct device_node *child; 135 136 for_each_child_of_node(dn, child) { 137 pnv_php_rmv_pdns(child); 138 139 pci_remove_device_node_info(child); 140 } 141 } 142 143 /* 144 * Detach all child nodes of the indicated device nodes. The 145 * function should handle device nodes in depth-first manner. 146 * 147 * We should not invoke of_node_release() as the memory for 148 * individual device node is part of large memory block. The 149 * large block is allocated from memblock (system bootup) or 150 * kmalloc() when unflattening the device tree by OF changeset. 151 * We can not free the large block allocated from memblock. For 152 * later case, it should be released at once. 153 */ 154 static void pnv_php_detach_device_nodes(struct device_node *parent) 155 { 156 struct device_node *dn; 157 158 for_each_child_of_node(parent, dn) { 159 pnv_php_detach_device_nodes(dn); 160 161 of_node_put(dn); 162 of_detach_node(dn); 163 } 164 } 165 166 static void pnv_php_rmv_devtree(struct pnv_php_slot *php_slot) 167 { 168 pnv_php_rmv_pdns(php_slot->dn); 169 170 /* 171 * Decrease the refcount if the device nodes were created 172 * through OF changeset before detaching them. 173 */ 174 if (php_slot->fdt) 175 of_changeset_destroy(&php_slot->ocs); 176 pnv_php_detach_device_nodes(php_slot->dn); 177 178 if (php_slot->fdt) { 179 kfree(php_slot->dt); 180 kfree(php_slot->fdt); 181 php_slot->dt = NULL; 182 php_slot->dn->child = NULL; 183 php_slot->fdt = NULL; 184 } 185 } 186 187 /* 188 * As the nodes in OF changeset are applied in reverse order, we 189 * need revert the nodes in advance so that we have correct node 190 * order after the changeset is applied. 191 */ 192 static void pnv_php_reverse_nodes(struct device_node *parent) 193 { 194 struct device_node *child, *next; 195 196 /* In-depth first */ 197 for_each_child_of_node(parent, child) 198 pnv_php_reverse_nodes(child); 199 200 /* Reverse the nodes in the child list */ 201 child = parent->child; 202 parent->child = NULL; 203 while (child) { 204 next = child->sibling; 205 206 child->sibling = parent->child; 207 parent->child = child; 208 child = next; 209 } 210 } 211 212 static int pnv_php_populate_changeset(struct of_changeset *ocs, 213 struct device_node *dn) 214 { 215 struct device_node *child; 216 int ret = 0; 217 218 for_each_child_of_node(dn, child) { 219 ret = of_changeset_attach_node(ocs, child); 220 if (ret) { 221 of_node_put(child); 222 break; 223 } 224 225 ret = pnv_php_populate_changeset(ocs, child); 226 if (ret) { 227 of_node_put(child); 228 break; 229 } 230 } 231 232 return ret; 233 } 234 235 static void *pnv_php_add_one_pdn(struct device_node *dn, void *data) 236 { 237 struct pci_controller *hose = (struct pci_controller *)data; 238 struct pci_dn *pdn; 239 240 pdn = pci_add_device_node_info(hose, dn); 241 if (!pdn) 242 return ERR_PTR(-ENOMEM); 243 244 return NULL; 245 } 246 247 static void pnv_php_add_pdns(struct pnv_php_slot *slot) 248 { 249 struct pci_controller *hose = pci_bus_to_host(slot->bus); 250 251 pci_traverse_device_nodes(slot->dn, pnv_php_add_one_pdn, hose); 252 } 253 254 static int pnv_php_add_devtree(struct pnv_php_slot *php_slot) 255 { 256 void *fdt, *fdt1, *dt; 257 int ret; 258 259 /* We don't know the FDT blob size. We try to get it through 260 * maximal memory chunk and then copy it to another chunk that 261 * fits the real size. 262 */ 263 fdt1 = kzalloc(0x10000, GFP_KERNEL); 264 if (!fdt1) { 265 ret = -ENOMEM; 266 goto out; 267 } 268 269 ret = pnv_pci_get_device_tree(php_slot->dn->phandle, fdt1, 0x10000); 270 if (ret) { 271 SLOT_WARN(php_slot, "Error %d getting FDT blob\n", ret); 272 goto free_fdt1; 273 } 274 275 fdt = kmemdup(fdt1, fdt_totalsize(fdt1), GFP_KERNEL); 276 if (!fdt) { 277 ret = -ENOMEM; 278 goto free_fdt1; 279 } 280 281 /* Unflatten device tree blob */ 282 dt = of_fdt_unflatten_tree(fdt, php_slot->dn, NULL); 283 if (!dt) { 284 ret = -EINVAL; 285 SLOT_WARN(php_slot, "Cannot unflatten FDT\n"); 286 goto free_fdt; 287 } 288 289 /* Initialize and apply the changeset */ 290 of_changeset_init(&php_slot->ocs); 291 pnv_php_reverse_nodes(php_slot->dn); 292 ret = pnv_php_populate_changeset(&php_slot->ocs, php_slot->dn); 293 if (ret) { 294 pnv_php_reverse_nodes(php_slot->dn); 295 SLOT_WARN(php_slot, "Error %d populating changeset\n", 296 ret); 297 goto free_dt; 298 } 299 300 php_slot->dn->child = NULL; 301 ret = of_changeset_apply(&php_slot->ocs); 302 if (ret) { 303 SLOT_WARN(php_slot, "Error %d applying changeset\n", ret); 304 goto destroy_changeset; 305 } 306 307 /* Add device node firmware data */ 308 pnv_php_add_pdns(php_slot); 309 php_slot->fdt = fdt; 310 php_slot->dt = dt; 311 kfree(fdt1); 312 goto out; 313 314 destroy_changeset: 315 of_changeset_destroy(&php_slot->ocs); 316 free_dt: 317 kfree(dt); 318 php_slot->dn->child = NULL; 319 free_fdt: 320 kfree(fdt); 321 free_fdt1: 322 kfree(fdt1); 323 out: 324 return ret; 325 } 326 327 static inline struct pnv_php_slot *to_pnv_php_slot(struct hotplug_slot *slot) 328 { 329 return container_of(slot, struct pnv_php_slot, slot); 330 } 331 332 int pnv_php_set_slot_power_state(struct hotplug_slot *slot, 333 uint8_t state) 334 { 335 struct pnv_php_slot *php_slot = to_pnv_php_slot(slot); 336 struct opal_msg msg; 337 int ret; 338 339 ret = pnv_pci_set_power_state(php_slot->id, state, &msg); 340 if (ret > 0) { 341 if (be64_to_cpu(msg.params[1]) != php_slot->dn->phandle || 342 be64_to_cpu(msg.params[2]) != state) { 343 SLOT_WARN(php_slot, "Wrong msg (%lld, %lld, %lld)\n", 344 be64_to_cpu(msg.params[1]), 345 be64_to_cpu(msg.params[2]), 346 be64_to_cpu(msg.params[3])); 347 return -ENOMSG; 348 } 349 if (be64_to_cpu(msg.params[3]) != OPAL_SUCCESS) { 350 ret = -ENODEV; 351 goto error; 352 } 353 } else if (ret < 0) { 354 goto error; 355 } 356 357 if (state == OPAL_PCI_SLOT_POWER_OFF || state == OPAL_PCI_SLOT_OFFLINE) 358 pnv_php_rmv_devtree(php_slot); 359 else 360 ret = pnv_php_add_devtree(php_slot); 361 362 return ret; 363 364 error: 365 SLOT_WARN(php_slot, "Error %d powering %s\n", 366 ret, (state == OPAL_PCI_SLOT_POWER_ON) ? "on" : "off"); 367 return ret; 368 } 369 EXPORT_SYMBOL_GPL(pnv_php_set_slot_power_state); 370 371 static int pnv_php_get_power_state(struct hotplug_slot *slot, u8 *state) 372 { 373 struct pnv_php_slot *php_slot = to_pnv_php_slot(slot); 374 uint8_t power_state = OPAL_PCI_SLOT_POWER_ON; 375 int ret; 376 377 /* 378 * Retrieve power status from firmware. If we fail 379 * getting that, the power status fails back to 380 * be on. 381 */ 382 ret = pnv_pci_get_power_state(php_slot->id, &power_state); 383 if (ret) { 384 SLOT_WARN(php_slot, "Error %d getting power status\n", 385 ret); 386 } else { 387 *state = power_state; 388 } 389 390 return 0; 391 } 392 393 static int pnv_php_get_adapter_state(struct hotplug_slot *slot, u8 *state) 394 { 395 struct pnv_php_slot *php_slot = to_pnv_php_slot(slot); 396 uint8_t presence = OPAL_PCI_SLOT_EMPTY; 397 int ret; 398 399 /* 400 * Retrieve presence status from firmware. If we can't 401 * get that, it will fail back to be empty. 402 */ 403 ret = pnv_pci_get_presence_state(php_slot->id, &presence); 404 if (ret >= 0) { 405 *state = presence; 406 ret = 0; 407 } else { 408 SLOT_WARN(php_slot, "Error %d getting presence\n", ret); 409 } 410 411 return ret; 412 } 413 414 static int pnv_php_get_attention_state(struct hotplug_slot *slot, u8 *state) 415 { 416 struct pnv_php_slot *php_slot = to_pnv_php_slot(slot); 417 418 *state = php_slot->attention_state; 419 return 0; 420 } 421 422 static int pnv_php_set_attention_state(struct hotplug_slot *slot, u8 state) 423 { 424 struct pnv_php_slot *php_slot = to_pnv_php_slot(slot); 425 struct pci_dev *bridge = php_slot->pdev; 426 u16 new, mask; 427 428 php_slot->attention_state = state; 429 if (!bridge) 430 return 0; 431 432 mask = PCI_EXP_SLTCTL_AIC; 433 434 if (state) 435 new = PCI_EXP_SLTCTL_ATTN_IND_ON; 436 else 437 new = PCI_EXP_SLTCTL_ATTN_IND_OFF; 438 439 pcie_capability_clear_and_set_word(bridge, PCI_EXP_SLTCTL, mask, new); 440 441 return 0; 442 } 443 444 static int pnv_php_enable(struct pnv_php_slot *php_slot, bool rescan) 445 { 446 struct hotplug_slot *slot = &php_slot->slot; 447 uint8_t presence = OPAL_PCI_SLOT_EMPTY; 448 uint8_t power_status = OPAL_PCI_SLOT_POWER_ON; 449 int ret; 450 451 /* Check if the slot has been configured */ 452 if (php_slot->state != PNV_PHP_STATE_REGISTERED) 453 return 0; 454 455 /* Retrieve slot presence status */ 456 ret = pnv_php_get_adapter_state(slot, &presence); 457 if (ret) 458 return ret; 459 460 /* 461 * Proceed if there have nothing behind the slot. However, 462 * we should leave the slot in registered state at the 463 * beginning. Otherwise, the PCI devices inserted afterwards 464 * won't be probed and populated. 465 */ 466 if (presence == OPAL_PCI_SLOT_EMPTY) { 467 if (!php_slot->power_state_check) { 468 php_slot->power_state_check = true; 469 470 return 0; 471 } 472 473 goto scan; 474 } 475 476 /* 477 * If the power supply to the slot is off, we can't detect 478 * adapter presence state. That means we have to turn the 479 * slot on before going to probe slot's presence state. 480 * 481 * On the first time, we don't change the power status to 482 * boost system boot with assumption that the firmware 483 * supplies consistent slot power status: empty slot always 484 * has its power off and non-empty slot has its power on. 485 */ 486 if (!php_slot->power_state_check) { 487 php_slot->power_state_check = true; 488 489 ret = pnv_php_get_power_state(slot, &power_status); 490 if (ret) 491 return ret; 492 493 if (power_status != OPAL_PCI_SLOT_POWER_ON) 494 return 0; 495 } 496 497 /* Check the power status. Scan the slot if it is already on */ 498 ret = pnv_php_get_power_state(slot, &power_status); 499 if (ret) 500 return ret; 501 502 if (power_status == OPAL_PCI_SLOT_POWER_ON) 503 goto scan; 504 505 /* Power is off, turn it on and then scan the slot */ 506 ret = pnv_php_set_slot_power_state(slot, OPAL_PCI_SLOT_POWER_ON); 507 if (ret) 508 return ret; 509 510 scan: 511 if (presence == OPAL_PCI_SLOT_PRESENT) { 512 if (rescan) { 513 pci_lock_rescan_remove(); 514 pci_hp_add_devices(php_slot->bus); 515 pci_unlock_rescan_remove(); 516 } 517 518 /* Rescan for child hotpluggable slots */ 519 php_slot->state = PNV_PHP_STATE_POPULATED; 520 if (rescan) 521 pnv_php_register(php_slot->dn); 522 } else { 523 php_slot->state = PNV_PHP_STATE_POPULATED; 524 } 525 526 return 0; 527 } 528 529 static int pnv_php_reset_slot(struct hotplug_slot *slot, bool probe) 530 { 531 struct pnv_php_slot *php_slot = to_pnv_php_slot(slot); 532 struct pci_dev *bridge = php_slot->pdev; 533 uint16_t sts; 534 535 /* 536 * The CAPI folks want pnv_php to drive OpenCAPI slots 537 * which don't have a bridge. Only claim to support 538 * reset_slot() if we have a bridge device (for now...) 539 */ 540 if (probe) 541 return !bridge; 542 543 /* mask our interrupt while resetting the bridge */ 544 if (php_slot->irq > 0) 545 disable_irq(php_slot->irq); 546 547 pci_bridge_secondary_bus_reset(bridge); 548 549 /* clear any state changes that happened due to the reset */ 550 pcie_capability_read_word(php_slot->pdev, PCI_EXP_SLTSTA, &sts); 551 sts &= (PCI_EXP_SLTSTA_PDC | PCI_EXP_SLTSTA_DLLSC); 552 pcie_capability_write_word(php_slot->pdev, PCI_EXP_SLTSTA, sts); 553 554 if (php_slot->irq > 0) 555 enable_irq(php_slot->irq); 556 557 return 0; 558 } 559 560 static int pnv_php_enable_slot(struct hotplug_slot *slot) 561 { 562 struct pnv_php_slot *php_slot = to_pnv_php_slot(slot); 563 564 return pnv_php_enable(php_slot, true); 565 } 566 567 static int pnv_php_disable_slot(struct hotplug_slot *slot) 568 { 569 struct pnv_php_slot *php_slot = to_pnv_php_slot(slot); 570 int ret; 571 572 /* 573 * Allow to disable a slot already in the registered state to 574 * cover cases where the slot couldn't be enabled and never 575 * reached the populated state 576 */ 577 if (php_slot->state != PNV_PHP_STATE_POPULATED && 578 php_slot->state != PNV_PHP_STATE_REGISTERED) 579 return 0; 580 581 /* Remove all devices behind the slot */ 582 pci_lock_rescan_remove(); 583 pci_hp_remove_devices(php_slot->bus); 584 pci_unlock_rescan_remove(); 585 586 /* Detach the child hotpluggable slots */ 587 pnv_php_unregister(php_slot->dn); 588 589 /* Notify firmware and remove device nodes */ 590 ret = pnv_php_set_slot_power_state(slot, OPAL_PCI_SLOT_POWER_OFF); 591 592 php_slot->state = PNV_PHP_STATE_REGISTERED; 593 return ret; 594 } 595 596 static const struct hotplug_slot_ops php_slot_ops = { 597 .get_power_status = pnv_php_get_power_state, 598 .get_adapter_status = pnv_php_get_adapter_state, 599 .get_attention_status = pnv_php_get_attention_state, 600 .set_attention_status = pnv_php_set_attention_state, 601 .enable_slot = pnv_php_enable_slot, 602 .disable_slot = pnv_php_disable_slot, 603 .reset_slot = pnv_php_reset_slot, 604 }; 605 606 static void pnv_php_release(struct pnv_php_slot *php_slot) 607 { 608 unsigned long flags; 609 610 /* Remove from global or child list */ 611 spin_lock_irqsave(&pnv_php_lock, flags); 612 list_del(&php_slot->link); 613 spin_unlock_irqrestore(&pnv_php_lock, flags); 614 615 /* Detach from parent */ 616 pnv_php_put_slot(php_slot); 617 pnv_php_put_slot(php_slot->parent); 618 } 619 620 static struct pnv_php_slot *pnv_php_alloc_slot(struct device_node *dn) 621 { 622 struct pnv_php_slot *php_slot; 623 struct pci_bus *bus; 624 const char *label; 625 uint64_t id; 626 int ret; 627 628 ret = of_property_read_string(dn, "ibm,slot-label", &label); 629 if (ret) 630 return NULL; 631 632 if (pnv_pci_get_slot_id(dn, &id)) 633 return NULL; 634 635 bus = pci_find_bus_by_node(dn); 636 if (!bus) 637 return NULL; 638 639 php_slot = kzalloc(sizeof(*php_slot), GFP_KERNEL); 640 if (!php_slot) 641 return NULL; 642 643 php_slot->name = kstrdup(label, GFP_KERNEL); 644 if (!php_slot->name) { 645 kfree(php_slot); 646 return NULL; 647 } 648 649 if (dn->child && PCI_DN(dn->child)) 650 php_slot->slot_no = PCI_SLOT(PCI_DN(dn->child)->devfn); 651 else 652 php_slot->slot_no = -1; /* Placeholder slot */ 653 654 kref_init(&php_slot->kref); 655 php_slot->state = PNV_PHP_STATE_INITIALIZED; 656 php_slot->dn = dn; 657 php_slot->pdev = bus->self; 658 php_slot->bus = bus; 659 php_slot->id = id; 660 php_slot->power_state_check = false; 661 php_slot->slot.ops = &php_slot_ops; 662 663 INIT_LIST_HEAD(&php_slot->children); 664 INIT_LIST_HEAD(&php_slot->link); 665 666 return php_slot; 667 } 668 669 static int pnv_php_register_slot(struct pnv_php_slot *php_slot) 670 { 671 struct pnv_php_slot *parent; 672 struct device_node *dn = php_slot->dn; 673 unsigned long flags; 674 int ret; 675 676 /* Check if the slot is registered or not */ 677 parent = pnv_php_find_slot(php_slot->dn); 678 if (parent) { 679 pnv_php_put_slot(parent); 680 return -EEXIST; 681 } 682 683 /* Register PCI slot */ 684 ret = pci_hp_register(&php_slot->slot, php_slot->bus, 685 php_slot->slot_no, php_slot->name); 686 if (ret) { 687 SLOT_WARN(php_slot, "Error %d registering slot\n", ret); 688 return ret; 689 } 690 691 /* Attach to the parent's child list or global list */ 692 while ((dn = of_get_parent(dn))) { 693 if (!PCI_DN(dn)) { 694 of_node_put(dn); 695 break; 696 } 697 698 parent = pnv_php_find_slot(dn); 699 if (parent) { 700 of_node_put(dn); 701 break; 702 } 703 704 of_node_put(dn); 705 } 706 707 spin_lock_irqsave(&pnv_php_lock, flags); 708 php_slot->parent = parent; 709 if (parent) 710 list_add_tail(&php_slot->link, &parent->children); 711 else 712 list_add_tail(&php_slot->link, &pnv_php_slot_list); 713 spin_unlock_irqrestore(&pnv_php_lock, flags); 714 715 php_slot->state = PNV_PHP_STATE_REGISTERED; 716 return 0; 717 } 718 719 static int pnv_php_enable_msix(struct pnv_php_slot *php_slot) 720 { 721 struct pci_dev *pdev = php_slot->pdev; 722 struct msix_entry entry; 723 int nr_entries, ret; 724 u16 pcie_flag; 725 726 /* Get total number of MSIx entries */ 727 nr_entries = pci_msix_vec_count(pdev); 728 if (nr_entries < 0) 729 return nr_entries; 730 731 /* Check hotplug MSIx entry is in range */ 732 pcie_capability_read_word(pdev, PCI_EXP_FLAGS, &pcie_flag); 733 entry.entry = (pcie_flag & PCI_EXP_FLAGS_IRQ) >> 9; 734 if (entry.entry >= nr_entries) 735 return -ERANGE; 736 737 /* Enable MSIx */ 738 ret = pci_enable_msix_exact(pdev, &entry, 1); 739 if (ret) { 740 SLOT_WARN(php_slot, "Error %d enabling MSIx\n", ret); 741 return ret; 742 } 743 744 return entry.vector; 745 } 746 747 static void pnv_php_event_handler(struct work_struct *work) 748 { 749 struct pnv_php_event *event = 750 container_of(work, struct pnv_php_event, work); 751 struct pnv_php_slot *php_slot = event->php_slot; 752 753 if (event->added) 754 pnv_php_enable_slot(&php_slot->slot); 755 else 756 pnv_php_disable_slot(&php_slot->slot); 757 758 kfree(event); 759 } 760 761 static irqreturn_t pnv_php_interrupt(int irq, void *data) 762 { 763 struct pnv_php_slot *php_slot = data; 764 struct pci_dev *pchild, *pdev = php_slot->pdev; 765 struct eeh_dev *edev; 766 struct eeh_pe *pe; 767 struct pnv_php_event *event; 768 u16 sts, lsts; 769 u8 presence; 770 bool added; 771 unsigned long flags; 772 int ret; 773 774 pcie_capability_read_word(pdev, PCI_EXP_SLTSTA, &sts); 775 sts &= (PCI_EXP_SLTSTA_PDC | PCI_EXP_SLTSTA_DLLSC); 776 pcie_capability_write_word(pdev, PCI_EXP_SLTSTA, sts); 777 778 pci_dbg(pdev, "PCI slot [%s]: HP int! DLAct: %d, PresDet: %d\n", 779 php_slot->name, 780 !!(sts & PCI_EXP_SLTSTA_DLLSC), 781 !!(sts & PCI_EXP_SLTSTA_PDC)); 782 783 if (sts & PCI_EXP_SLTSTA_DLLSC) { 784 pcie_capability_read_word(pdev, PCI_EXP_LNKSTA, &lsts); 785 added = !!(lsts & PCI_EXP_LNKSTA_DLLLA); 786 } else if (!(php_slot->flags & PNV_PHP_FLAG_BROKEN_PDC) && 787 (sts & PCI_EXP_SLTSTA_PDC)) { 788 ret = pnv_pci_get_presence_state(php_slot->id, &presence); 789 if (ret) { 790 SLOT_WARN(php_slot, 791 "PCI slot [%s] error %d getting presence (0x%04x), to retry the operation.\n", 792 php_slot->name, ret, sts); 793 return IRQ_HANDLED; 794 } 795 796 added = !!(presence == OPAL_PCI_SLOT_PRESENT); 797 } else { 798 pci_dbg(pdev, "PCI slot [%s]: Spurious IRQ?\n", php_slot->name); 799 return IRQ_NONE; 800 } 801 802 /* Freeze the removed PE to avoid unexpected error reporting */ 803 if (!added) { 804 pchild = list_first_entry_or_null(&php_slot->bus->devices, 805 struct pci_dev, bus_list); 806 edev = pchild ? pci_dev_to_eeh_dev(pchild) : NULL; 807 pe = edev ? edev->pe : NULL; 808 if (pe) { 809 eeh_serialize_lock(&flags); 810 eeh_pe_mark_isolated(pe); 811 eeh_serialize_unlock(flags); 812 eeh_pe_set_option(pe, EEH_OPT_FREEZE_PE); 813 } 814 } 815 816 /* 817 * The PE is left in frozen state if the event is missed. It's 818 * fine as the PCI devices (PE) aren't functional any more. 819 */ 820 event = kzalloc(sizeof(*event), GFP_ATOMIC); 821 if (!event) { 822 SLOT_WARN(php_slot, 823 "PCI slot [%s] missed hotplug event 0x%04x\n", 824 php_slot->name, sts); 825 return IRQ_HANDLED; 826 } 827 828 pci_info(pdev, "PCI slot [%s] %s (IRQ: %d)\n", 829 php_slot->name, added ? "added" : "removed", irq); 830 INIT_WORK(&event->work, pnv_php_event_handler); 831 event->added = added; 832 event->php_slot = php_slot; 833 queue_work(php_slot->wq, &event->work); 834 835 return IRQ_HANDLED; 836 } 837 838 static void pnv_php_init_irq(struct pnv_php_slot *php_slot, int irq) 839 { 840 struct pci_dev *pdev = php_slot->pdev; 841 u32 broken_pdc = 0; 842 u16 sts, ctrl; 843 int ret; 844 845 /* Allocate workqueue */ 846 php_slot->wq = alloc_workqueue("pciehp-%s", 0, 0, php_slot->name); 847 if (!php_slot->wq) { 848 SLOT_WARN(php_slot, "Cannot alloc workqueue\n"); 849 pnv_php_disable_irq(php_slot, true); 850 return; 851 } 852 853 /* Check PDC (Presence Detection Change) is broken or not */ 854 ret = of_property_read_u32(php_slot->dn, "ibm,slot-broken-pdc", 855 &broken_pdc); 856 if (!ret && broken_pdc) 857 php_slot->flags |= PNV_PHP_FLAG_BROKEN_PDC; 858 859 /* Clear pending interrupts */ 860 pcie_capability_read_word(pdev, PCI_EXP_SLTSTA, &sts); 861 if (php_slot->flags & PNV_PHP_FLAG_BROKEN_PDC) 862 sts |= PCI_EXP_SLTSTA_DLLSC; 863 else 864 sts |= (PCI_EXP_SLTSTA_PDC | PCI_EXP_SLTSTA_DLLSC); 865 pcie_capability_write_word(pdev, PCI_EXP_SLTSTA, sts); 866 867 /* Request the interrupt */ 868 ret = request_irq(irq, pnv_php_interrupt, IRQF_SHARED, 869 php_slot->name, php_slot); 870 if (ret) { 871 pnv_php_disable_irq(php_slot, true); 872 SLOT_WARN(php_slot, "Error %d enabling IRQ %d\n", ret, irq); 873 return; 874 } 875 876 /* Enable the interrupts */ 877 pcie_capability_read_word(pdev, PCI_EXP_SLTCTL, &ctrl); 878 if (php_slot->flags & PNV_PHP_FLAG_BROKEN_PDC) { 879 ctrl &= ~PCI_EXP_SLTCTL_PDCE; 880 ctrl |= (PCI_EXP_SLTCTL_HPIE | 881 PCI_EXP_SLTCTL_DLLSCE); 882 } else { 883 ctrl |= (PCI_EXP_SLTCTL_HPIE | 884 PCI_EXP_SLTCTL_PDCE | 885 PCI_EXP_SLTCTL_DLLSCE); 886 } 887 pcie_capability_write_word(pdev, PCI_EXP_SLTCTL, ctrl); 888 889 /* The interrupt is initialized successfully when @irq is valid */ 890 php_slot->irq = irq; 891 } 892 893 static void pnv_php_enable_irq(struct pnv_php_slot *php_slot) 894 { 895 struct pci_dev *pdev = php_slot->pdev; 896 int irq, ret; 897 898 /* 899 * The MSI/MSIx interrupt might have been occupied by other 900 * drivers. Don't populate the surprise hotplug capability 901 * in that case. 902 */ 903 if (pci_dev_msi_enabled(pdev)) 904 return; 905 906 ret = pci_enable_device(pdev); 907 if (ret) { 908 SLOT_WARN(php_slot, "Error %d enabling device\n", ret); 909 return; 910 } 911 912 pci_set_master(pdev); 913 914 /* Enable MSIx interrupt */ 915 irq = pnv_php_enable_msix(php_slot); 916 if (irq > 0) { 917 pnv_php_init_irq(php_slot, irq); 918 return; 919 } 920 921 /* 922 * Use MSI if MSIx doesn't work. Fail back to legacy INTx 923 * if MSI doesn't work either 924 */ 925 ret = pci_enable_msi(pdev); 926 if (!ret || pdev->irq) { 927 irq = pdev->irq; 928 pnv_php_init_irq(php_slot, irq); 929 } 930 } 931 932 static int pnv_php_register_one(struct device_node *dn) 933 { 934 struct pnv_php_slot *php_slot; 935 u32 prop32; 936 int ret; 937 938 /* Check if it's hotpluggable slot */ 939 ret = of_property_read_u32(dn, "ibm,slot-pluggable", &prop32); 940 if (ret || !prop32) 941 return -ENXIO; 942 943 ret = of_property_read_u32(dn, "ibm,reset-by-firmware", &prop32); 944 if (ret || !prop32) 945 return -ENXIO; 946 947 php_slot = pnv_php_alloc_slot(dn); 948 if (!php_slot) 949 return -ENODEV; 950 951 ret = pnv_php_register_slot(php_slot); 952 if (ret) 953 goto free_slot; 954 955 ret = pnv_php_enable(php_slot, false); 956 if (ret) 957 goto unregister_slot; 958 959 /* Enable interrupt if the slot supports surprise hotplug */ 960 ret = of_property_read_u32(dn, "ibm,slot-surprise-pluggable", &prop32); 961 if (!ret && prop32) 962 pnv_php_enable_irq(php_slot); 963 964 return 0; 965 966 unregister_slot: 967 pnv_php_unregister_one(php_slot->dn); 968 free_slot: 969 pnv_php_put_slot(php_slot); 970 return ret; 971 } 972 973 static void pnv_php_register(struct device_node *dn) 974 { 975 struct device_node *child; 976 977 /* 978 * The parent slots should be registered before their 979 * child slots. 980 */ 981 for_each_child_of_node(dn, child) { 982 pnv_php_register_one(child); 983 pnv_php_register(child); 984 } 985 } 986 987 static void pnv_php_unregister_one(struct device_node *dn) 988 { 989 struct pnv_php_slot *php_slot; 990 991 php_slot = pnv_php_find_slot(dn); 992 if (!php_slot) 993 return; 994 995 php_slot->state = PNV_PHP_STATE_OFFLINE; 996 pci_hp_deregister(&php_slot->slot); 997 pnv_php_release(php_slot); 998 pnv_php_put_slot(php_slot); 999 } 1000 1001 static void pnv_php_unregister(struct device_node *dn) 1002 { 1003 struct device_node *child; 1004 1005 /* The child slots should go before their parent slots */ 1006 for_each_child_of_node(dn, child) { 1007 pnv_php_unregister(child); 1008 pnv_php_unregister_one(child); 1009 } 1010 } 1011 1012 static int __init pnv_php_init(void) 1013 { 1014 struct device_node *dn; 1015 1016 pr_info(DRIVER_DESC " version: " DRIVER_VERSION "\n"); 1017 for_each_compatible_node(dn, NULL, "ibm,ioda2-phb") 1018 pnv_php_register(dn); 1019 1020 for_each_compatible_node(dn, NULL, "ibm,ioda3-phb") 1021 pnv_php_register(dn); 1022 1023 for_each_compatible_node(dn, NULL, "ibm,ioda2-npu2-opencapi-phb") 1024 pnv_php_register_one(dn); /* slot directly under the PHB */ 1025 return 0; 1026 } 1027 1028 static void __exit pnv_php_exit(void) 1029 { 1030 struct device_node *dn; 1031 1032 for_each_compatible_node(dn, NULL, "ibm,ioda2-phb") 1033 pnv_php_unregister(dn); 1034 1035 for_each_compatible_node(dn, NULL, "ibm,ioda3-phb") 1036 pnv_php_unregister(dn); 1037 1038 for_each_compatible_node(dn, NULL, "ibm,ioda2-npu2-opencapi-phb") 1039 pnv_php_unregister_one(dn); /* slot directly under the PHB */ 1040 } 1041 1042 module_init(pnv_php_init); 1043 module_exit(pnv_php_exit); 1044 1045 MODULE_VERSION(DRIVER_VERSION); 1046 MODULE_LICENSE("GPL v2"); 1047 MODULE_AUTHOR(DRIVER_AUTHOR); 1048 MODULE_DESCRIPTION(DRIVER_DESC); 1049