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