drivers/pci/hotplug/pnv_php.c

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