drivers/pci/hotplug/pnv_php.c

   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
 155         for_each_child_of_node(parent, dn) {
 156                 pnv_php_detach_device_nodes(dn);
 157
 158                 of_node_put(dn);
 159                 of_detach_node(dn);
 160         }
 161 }
 162
 163 static void pnv_php_rmv_devtree(struct pnv_php_slot *php_slot)
 164 {
 165         pnv_php_rmv_pdns(php_slot->dn);
 166
 167         /*
 168          * Decrease the refcount if the device nodes were created
 169          * through OF changeset before detaching them.
 170          */
 171         if (php_slot->fdt)
 172                 of_changeset_destroy(&php_slot->ocs);
 173         pnv_php_detach_device_nodes(php_slot->dn);
 174
 175         if (php_slot->fdt) {
 176                 kfree(php_slot->dt);
 177                 kfree(php_slot->fdt);
 178                 php_slot->dt        = NULL;
 179                 php_slot->dn->child = NULL;
 180                 php_slot->fdt       = NULL;
 181         }
 182 }
 183
 184 /*
 185  * As the nodes in OF changeset are applied in reverse order, we
 186  * need revert the nodes in advance so that we have correct node
 187  * order after the changeset is applied.
 188  */
 189 static void pnv_php_reverse_nodes(struct device_node *parent)
 190 {
 191         struct device_node *child, *next;
 192
 193         /* In-depth first */
 194         for_each_child_of_node(parent, child)
 195                 pnv_php_reverse_nodes(child);
 196
 197         /* Reverse the nodes in the child list */
 198         child = parent->child;
 199         parent->child = NULL;
 200         while (child) {
 201                 next = child->sibling;
 202
 203                 child->sibling = parent->child;
 204                 parent->child = child;
 205                 child = next;
 206         }
 207 }
 208
 209 static int pnv_php_populate_changeset(struct of_changeset *ocs,
 210                                       struct device_node *dn)
 211 {
 212         struct device_node *child;
 213         int ret = 0;
 214
 215         for_each_child_of_node(dn, child) {
 216                 ret = of_changeset_attach_node(ocs, child);
 217                 if (ret) {
 218                         of_node_put(child);
 219                         break;
 220                 }
 221
 222                 ret = pnv_php_populate_changeset(ocs, child);
 223                 if (ret) {
 224                         of_node_put(child);
 225                         break;
 226                 }
 227         }
 228
 229         return ret;
 230 }
 231
 232 static void *pnv_php_add_one_pdn(struct device_node *dn, void *data)
 233 {
 234         struct pci_controller *hose = (struct pci_controller *)data;
 235         struct pci_dn *pdn;
 236
 237         pdn = pci_add_device_node_info(hose, dn);
 238         if (!pdn)
 239                 return ERR_PTR(-ENOMEM);
 240
 241         return NULL;
 242 }
 243
 244 static void pnv_php_add_pdns(struct pnv_php_slot *slot)
 245 {
 246         struct pci_controller *hose = pci_bus_to_host(slot->bus);
 247
 248         pci_traverse_device_nodes(slot->dn, pnv_php_add_one_pdn, hose);
 249 }
 250
 251 static int pnv_php_add_devtree(struct pnv_php_slot *php_slot)
 252 {
 253         void *fdt, *fdt1, *dt;
 254         int ret;
 255
 256         /* We don't know the FDT blob size. We try to get it through
 257          * maximal memory chunk and then copy it to another chunk that
 258          * fits the real size.
 259          */
 260         fdt1 = kzalloc(0x10000, GFP_KERNEL);
 261         if (!fdt1) {
 262                 ret = -ENOMEM;
 263                 goto out;
 264         }
 265
 266         ret = pnv_pci_get_device_tree(php_slot->dn->phandle, fdt1, 0x10000);
 267         if (ret) {
 268                 pci_warn(php_slot->pdev, "Error %d getting FDT blob\n", ret);
 269                 goto free_fdt1;
 270         }
 271
 272         fdt = kmemdup(fdt1, fdt_totalsize(fdt1), GFP_KERNEL);
 273         if (!fdt) {
 274                 ret = -ENOMEM;
 275                 goto free_fdt1;
 276         }
 277
 278         /* Unflatten device tree blob */
 279         dt = of_fdt_unflatten_tree(fdt, php_slot->dn, NULL);
 280         if (!dt) {
 281                 ret = -EINVAL;
 282                 pci_warn(php_slot->pdev, "Cannot unflatten FDT\n");
 283                 goto free_fdt;
 284         }
 285
 286         /* Initialize and apply the changeset */
 287         of_changeset_init(&php_slot->ocs);
 288         pnv_php_reverse_nodes(php_slot->dn);
 289         ret = pnv_php_populate_changeset(&php_slot->ocs, php_slot->dn);
 290         if (ret) {
 291                 pnv_php_reverse_nodes(php_slot->dn);
 292                 pci_warn(php_slot->pdev, "Error %d populating changeset\n",
 293                          ret);
 294                 goto free_dt;
 295         }
 296
 297         php_slot->dn->child = NULL;
 298         ret = of_changeset_apply(&php_slot->ocs);
 299         if (ret) {
 300                 pci_warn(php_slot->pdev, "Error %d applying changeset\n", ret);
 301                 goto destroy_changeset;
 302         }
 303
 304         /* Add device node firmware data */
 305         pnv_php_add_pdns(php_slot);
 306         php_slot->fdt = fdt;
 307         php_slot->dt  = dt;
 308         kfree(fdt1);
 309         goto out;
 310
 311 destroy_changeset:
 312         of_changeset_destroy(&php_slot->ocs);
 313 free_dt:
 314         kfree(dt);
 315         php_slot->dn->child = NULL;
 316 free_fdt:
 317         kfree(fdt);
 318 free_fdt1:
 319         kfree(fdt1);
 320 out:
 321         return ret;
 322 }
 323
 324 static inline struct pnv_php_slot *to_pnv_php_slot(struct hotplug_slot *slot)
 325 {
 326         return container_of(slot, struct pnv_php_slot, slot);
 327 }
 328
 329 int pnv_php_set_slot_power_state(struct hotplug_slot *slot,
 330                                  uint8_t state)
 331 {
 332         struct pnv_php_slot *php_slot = to_pnv_php_slot(slot);
 333         struct opal_msg msg;
 334         int ret;
 335
 336         ret = pnv_pci_set_power_state(php_slot->id, state, &msg);
 337         if (ret > 0) {
 338                 if (be64_to_cpu(msg.params[1]) != php_slot->dn->phandle ||
 339                     be64_to_cpu(msg.params[2]) != state) {
 340                         pci_warn(php_slot->pdev, "Wrong msg (%lld, %lld, %lld)\n",
 341                                  be64_to_cpu(msg.params[1]),
 342                                  be64_to_cpu(msg.params[2]),
 343                                  be64_to_cpu(msg.params[3]));
 344                         return -ENOMSG;
 345                 }
 346                 if (be64_to_cpu(msg.params[3]) != OPAL_SUCCESS) {
 347                         ret = -ENODEV;
 348                         goto error;
 349                 }
 350         } else if (ret < 0) {
 351                 goto error;
 352         }
 353
 354         if (state == OPAL_PCI_SLOT_POWER_OFF || state == OPAL_PCI_SLOT_OFFLINE)
 355                 pnv_php_rmv_devtree(php_slot);
 356         else
 357                 ret = pnv_php_add_devtree(php_slot);
 358
 359         return ret;
 360
 361 error:
 362         pci_warn(php_slot->pdev, "Error %d powering %s\n",
 363                  ret, (state == OPAL_PCI_SLOT_POWER_ON) ? "on" : "off");
 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         for_each_compatible_node(dn, NULL, "ibm,ioda2-npu2-opencapi-phb")
1013                 pnv_php_register_one(dn); /* slot directly under the PHB */
1014         return 0;
1015 }
1016
1017 static void __exit pnv_php_exit(void)
1018 {
1019         struct device_node *dn;
1020
1021         for_each_compatible_node(dn, NULL, "ibm,ioda2-phb")
1022                 pnv_php_unregister(dn);
1023
1024         for_each_compatible_node(dn, NULL, "ibm,ioda3-phb")
1025                 pnv_php_unregister(dn);
1026
1027         for_each_compatible_node(dn, NULL, "ibm,ioda2-npu2-opencapi-phb")
1028                 pnv_php_unregister_one(dn); /* slot directly under the PHB */
1029 }
1030
1031 module_init(pnv_php_init);
1032 module_exit(pnv_php_exit);
1033
1034 MODULE_VERSION(DRIVER_VERSION);
1035 MODULE_LICENSE("GPL v2");
1036 MODULE_AUTHOR(DRIVER_AUTHOR);
1037 MODULE_DESCRIPTION(DRIVER_DESC);