drivers/pci/hotplug/pnv

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
pnv_php_disable_irq
pnv_php_free_slot
pnv_php_put_slot
pnv_php_match
pnv_php_find_slot
pnv_php_rmv_pdns
pnv_php_detach_device_nodes
pnv_php_rmv_devtree
pnv_php_reverse_nodes
pnv_php_populate_changeset
pnv_php_add_one_pdn
pnv_php_add_pdns
pnv_php_add_devtree
to_pnv_php_slot
pnv_php_set_slot_power_state
pnv_php_get_power_state
pnv_php_get_adapter_state
pnv_php_get_attention_state
pnv_php_set_attention_state
pnv_php_enable
pnv_php_reset_slot
pnv_php_enable_slot
pnv_php_disable_slot
pnv_php_release
pnv_php_alloc_slot
pnv_php_register_slot
pnv_php_enable_msix
pnv_php_event_handler
pnv_php_interrupt
pnv_php_init_irq
pnv_php_enable_irq
pnv_php_register_one
pnv_php_register
pnv_php_unregister_one
pnv_php_unregister
pnv_php_init
pnv_php_exit
   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);
/* [<][>][^][v][top][bottom][index][help] */
root/drivers/pci/hotplug/pnv_php.c

DEFINITIONS
