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         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                         break;
 225
 226                 ret = pnv_php_populate_changeset(ocs, child);
 227                 if (ret)
 228                         break;
 229         }
 230
 231         return ret;
 232 }
 233
 234 static void *pnv_php_add_one_pdn(struct device_node *dn, void *data)
 235 {
 236         struct pci_controller *hose = (struct pci_controller *)data;
 237         struct pci_dn *pdn;
 238
 239         pdn = pci_add_device_node_info(hose, dn);
 240         if (!pdn)
 241                 return ERR_PTR(-ENOMEM);
 242
 243         return NULL;
 244 }
 245
 246 static void pnv_php_add_pdns(struct pnv_php_slot *slot)
 247 {
 248         struct pci_controller *hose = pci_bus_to_host(slot->bus);
 249
 250         pci_traverse_device_nodes(slot->dn, pnv_php_add_one_pdn, hose);
 251 }
 252
 253 static int pnv_php_add_devtree(struct pnv_php_slot *php_slot)
 254 {
 255         void *fdt, *fdt1, *dt;
 256         int ret;
 257
 258         /* We don't know the FDT blob size. We try to get it through
 259          * maximal memory chunk and then copy it to another chunk that
 260          * fits the real size.
 261          */
 262         fdt1 = kzalloc(0x10000, GFP_KERNEL);
 263         if (!fdt1) {
 264                 ret = -ENOMEM;
 265                 goto out;
 266         }
 267
 268         ret = pnv_pci_get_device_tree(php_slot->dn->phandle, fdt1, 0x10000);
 269         if (ret) {
 270                 pci_warn(php_slot->pdev, "Error %d getting FDT blob\n", ret);
 271                 goto free_fdt1;
 272         }
 273
 274         fdt = kzalloc(fdt_totalsize(fdt1), GFP_KERNEL);
 275         if (!fdt) {
 276                 ret = -ENOMEM;
 277                 goto free_fdt1;
 278         }
 279
 280         /* Unflatten device tree blob */
 281         memcpy(fdt, fdt1, fdt_totalsize(fdt1));
 282         dt = of_fdt_unflatten_tree(fdt, php_slot->dn, NULL);
 283         if (!dt) {
 284                 ret = -EINVAL;
 285                 pci_warn(php_slot->pdev, "Cannot unflatten FDT\n");
 286                 goto free_fdt;
 287         }
 288
 289         /* Initialize and apply the changeset */
 290         of_changeset_init(&php_slot->ocs);
 291         pnv_php_reverse_nodes(php_slot->dn);
 292         ret = pnv_php_populate_changeset(&php_slot->ocs, php_slot->dn);
 293         if (ret) {
 294                 pnv_php_reverse_nodes(php_slot->dn);
 295                 pci_warn(php_slot->pdev, "Error %d populating changeset\n",
 296                          ret);
 297                 goto free_dt;
 298         }
 299
 300         php_slot->dn->child = NULL;
 301         ret = of_changeset_apply(&php_slot->ocs);
 302         if (ret) {
 303                 pci_warn(php_slot->pdev, "Error %d applying changeset\n", ret);
 304                 goto destroy_changeset;
 305         }
 306
 307         /* Add device node firmware data */
 308         pnv_php_add_pdns(php_slot);
 309         php_slot->fdt = fdt;
 310         php_slot->dt  = dt;
 311         kfree(fdt1);
 312         goto out;
 313
 314 destroy_changeset:
 315         of_changeset_destroy(&php_slot->ocs);
 316 free_dt:
 317         kfree(dt);
 318         php_slot->dn->child = NULL;
 319 free_fdt:
 320         kfree(fdt);
 321 free_fdt1:
 322         kfree(fdt1);
 323 out:
 324         return ret;
 325 }
 326
 327 int pnv_php_set_slot_power_state(struct hotplug_slot *slot,
 328                                  uint8_t state)
 329 {
 330         struct pnv_php_slot *php_slot = slot->private;
 331         struct opal_msg msg;
 332         int ret;
 333
 334         ret = pnv_pci_set_power_state(php_slot->id, state, &msg);
 335         if (ret > 0) {
 336                 if (be64_to_cpu(msg.params[1]) != php_slot->dn->phandle ||
 337                     be64_to_cpu(msg.params[2]) != state                 ||
 338                     be64_to_cpu(msg.params[3]) != OPAL_SUCCESS) {
 339                         pci_warn(php_slot->pdev, "Wrong msg (%lld, %lld, %lld)\n",
 340                                  be64_to_cpu(msg.params[1]),
 341                                  be64_to_cpu(msg.params[2]),
 342                                  be64_to_cpu(msg.params[3]));
 343                         return -ENOMSG;
 344                 }
 345         } else if (ret < 0) {
 346                 pci_warn(php_slot->pdev, "Error %d powering %s\n",
 347                          ret, (state == OPAL_PCI_SLOT_POWER_ON) ? "on" : "off");
 348                 return ret;
 349         }
 350
 351         if (state == OPAL_PCI_SLOT_POWER_OFF || state == OPAL_PCI_SLOT_OFFLINE)
 352                 pnv_php_rmv_devtree(php_slot);
 353         else
 354                 ret = pnv_php_add_devtree(php_slot);
 355
 356         return ret;
 357 }
 358 EXPORT_SYMBOL_GPL(pnv_php_set_slot_power_state);
 359
 360 static int pnv_php_get_power_state(struct hotplug_slot *slot, u8 *state)
 361 {
 362         struct pnv_php_slot *php_slot = slot->private;
 363         uint8_t power_state = OPAL_PCI_SLOT_POWER_ON;
 364         int ret;
 365
 366         /*
 367          * Retrieve power status from firmware. If we fail
 368          * getting that, the power status fails back to
 369          * be on.
 370          */
 371         ret = pnv_pci_get_power_state(php_slot->id, &power_state);
 372         if (ret) {
 373                 pci_warn(php_slot->pdev, "Error %d getting power status\n",
 374                          ret);
 375         } else {
 376                 *state = power_state;
 377                 slot->info->power_status = power_state;
 378         }
 379
 380         return 0;
 381 }
 382
 383 static int pnv_php_get_adapter_state(struct hotplug_slot *slot, u8 *state)
 384 {
 385         struct pnv_php_slot *php_slot = slot->private;
 386         uint8_t presence = OPAL_PCI_SLOT_EMPTY;
 387         int ret;
 388
 389         /*
 390          * Retrieve presence status from firmware. If we can't
 391          * get that, it will fail back to be empty.
 392          */
 393         ret = pnv_pci_get_presence_state(php_slot->id, &presence);
 394         if (ret >= 0) {
 395                 *state = presence;
 396                 slot->info->adapter_status = presence;
 397                 ret = 0;
 398         } else {
 399                 pci_warn(php_slot->pdev, "Error %d getting presence\n", ret);
 400         }
 401
 402         return ret;
 403 }
 404
 405 static int pnv_php_set_attention_state(struct hotplug_slot *slot, u8 state)
 406 {
 407         /* FIXME: Make it real once firmware supports it */
 408         slot->info->attention_status = state;
 409
 410         return 0;
 411 }
 412
 413 static int pnv_php_enable(struct pnv_php_slot *php_slot, bool rescan)
 414 {
 415         struct hotplug_slot *slot = &php_slot->slot;
 416         uint8_t presence = OPAL_PCI_SLOT_EMPTY;
 417         uint8_t power_status = OPAL_PCI_SLOT_POWER_ON;
 418         int ret;
 419
 420         /* Check if the slot has been configured */
 421         if (php_slot->state != PNV_PHP_STATE_REGISTERED)
 422                 return 0;
 423
 424         /* Retrieve slot presence status */
 425         ret = pnv_php_get_adapter_state(slot, &presence);
 426         if (ret)
 427                 return ret;
 428
 429         /*
 430          * Proceed if there have nothing behind the slot. However,
 431          * we should leave the slot in registered state at the
 432          * beginning. Otherwise, the PCI devices inserted afterwards
 433          * won't be probed and populated.
 434          */
 435         if (presence == OPAL_PCI_SLOT_EMPTY) {
 436                 if (!php_slot->power_state_check) {
 437                         php_slot->power_state_check = true;
 438
 439                         return 0;
 440                 }
 441
 442                 goto scan;
 443         }
 444
 445         /*
 446          * If the power supply to the slot is off, we can't detect
 447          * adapter presence state. That means we have to turn the
 448          * slot on before going to probe slot's presence state.
 449          *
 450          * On the first time, we don't change the power status to
 451          * boost system boot with assumption that the firmware
 452          * supplies consistent slot power status: empty slot always
 453          * has its power off and non-empty slot has its power on.
 454          */
 455         if (!php_slot->power_state_check) {
 456                 php_slot->power_state_check = true;
 457
 458                 ret = pnv_php_get_power_state(slot, &power_status);
 459                 if (ret)
 460                         return ret;
 461
 462                 if (power_status != OPAL_PCI_SLOT_POWER_ON)
 463                         return 0;
 464         }
 465
 466         /* Check the power status. Scan the slot if it is already on */
 467         ret = pnv_php_get_power_state(slot, &power_status);
 468         if (ret)
 469                 return ret;
 470
 471         if (power_status == OPAL_PCI_SLOT_POWER_ON)
 472                 goto scan;
 473
 474         /* Power is off, turn it on and then scan the slot */
 475         ret = pnv_php_set_slot_power_state(slot, OPAL_PCI_SLOT_POWER_ON);
 476         if (ret)
 477                 return ret;
 478
 479 scan:
 480         if (presence == OPAL_PCI_SLOT_PRESENT) {
 481                 if (rescan) {
 482                         pci_lock_rescan_remove();
 483                         pci_hp_add_devices(php_slot->bus);
 484                         pci_unlock_rescan_remove();
 485                 }
 486
 487                 /* Rescan for child hotpluggable slots */
 488                 php_slot->state = PNV_PHP_STATE_POPULATED;
 489                 if (rescan)
 490                         pnv_php_register(php_slot->dn);
 491         } else {
 492                 php_slot->state = PNV_PHP_STATE_POPULATED;
 493         }
 494
 495         return 0;
 496 }
 497
 498 static int pnv_php_enable_slot(struct hotplug_slot *slot)
 499 {
 500         struct pnv_php_slot *php_slot = container_of(slot,
 501                                                      struct pnv_php_slot, slot);
 502
 503         return pnv_php_enable(php_slot, true);
 504 }
 505
 506 static int pnv_php_disable_slot(struct hotplug_slot *slot)
 507 {
 508         struct pnv_php_slot *php_slot = slot->private;
 509         int ret;
 510
 511         if (php_slot->state != PNV_PHP_STATE_POPULATED)
 512                 return 0;
 513
 514         /* Remove all devices behind the slot */
 515         pci_lock_rescan_remove();
 516         pci_hp_remove_devices(php_slot->bus);
 517         pci_unlock_rescan_remove();
 518
 519         /* Detach the child hotpluggable slots */
 520         pnv_php_unregister(php_slot->dn);
 521
 522         /* Notify firmware and remove device nodes */
 523         ret = pnv_php_set_slot_power_state(slot, OPAL_PCI_SLOT_POWER_OFF);
 524
 525         php_slot->state = PNV_PHP_STATE_REGISTERED;
 526         return ret;
 527 }
 528
 529 static struct hotplug_slot_ops php_slot_ops = {
 530         .get_power_status       = pnv_php_get_power_state,
 531         .get_adapter_status     = pnv_php_get_adapter_state,
 532         .set_attention_status   = pnv_php_set_attention_state,
 533         .enable_slot            = pnv_php_enable_slot,
 534         .disable_slot           = pnv_php_disable_slot,
 535 };
 536
 537 static void pnv_php_release(struct hotplug_slot *slot)
 538 {
 539         struct pnv_php_slot *php_slot = slot->private;
 540         unsigned long flags;
 541
 542         /* Remove from global or child list */
 543         spin_lock_irqsave(&pnv_php_lock, flags);
 544         list_del(&php_slot->link);
 545         spin_unlock_irqrestore(&pnv_php_lock, flags);
 546
 547         /* Detach from parent */
 548         pnv_php_put_slot(php_slot);
 549         pnv_php_put_slot(php_slot->parent);
 550 }
 551
 552 static struct pnv_php_slot *pnv_php_alloc_slot(struct device_node *dn)
 553 {
 554         struct pnv_php_slot *php_slot;
 555         struct pci_bus *bus;
 556         const char *label;
 557         uint64_t id;
 558         int ret;
 559
 560         ret = of_property_read_string(dn, "ibm,slot-label", &label);
 561         if (ret)
 562                 return NULL;
 563
 564         if (pnv_pci_get_slot_id(dn, &id))
 565                 return NULL;
 566
 567         bus = pci_find_bus_by_node(dn);
 568         if (!bus)
 569                 return NULL;
 570
 571         php_slot = kzalloc(sizeof(*php_slot), GFP_KERNEL);
 572         if (!php_slot)
 573                 return NULL;
 574
 575         php_slot->name = kstrdup(label, GFP_KERNEL);
 576         if (!php_slot->name) {
 577                 kfree(php_slot);
 578                 return NULL;
 579         }
 580
 581         if (dn->child && PCI_DN(dn->child))
 582                 php_slot->slot_no = PCI_SLOT(PCI_DN(dn->child)->devfn);
 583         else
 584                 php_slot->slot_no = -1;   /* Placeholder slot */
 585
 586         kref_init(&php_slot->kref);
 587         php_slot->state                 = PNV_PHP_STATE_INITIALIZED;
 588         php_slot->dn                    = dn;
 589         php_slot->pdev                  = bus->self;
 590         php_slot->bus                   = bus;
 591         php_slot->id                    = id;
 592         php_slot->power_state_check     = false;
 593         php_slot->slot.ops              = &php_slot_ops;
 594         php_slot->slot.info             = &php_slot->slot_info;
 595         php_slot->slot.release          = pnv_php_release;
 596         php_slot->slot.private          = php_slot;
 597
 598         INIT_LIST_HEAD(&php_slot->children);
 599         INIT_LIST_HEAD(&php_slot->link);
 600
 601         return php_slot;
 602 }
 603
 604 static int pnv_php_register_slot(struct pnv_php_slot *php_slot)
 605 {
 606         struct pnv_php_slot *parent;
 607         struct device_node *dn = php_slot->dn;
 608         unsigned long flags;
 609         int ret;
 610
 611         /* Check if the slot is registered or not */
 612         parent = pnv_php_find_slot(php_slot->dn);
 613         if (parent) {
 614                 pnv_php_put_slot(parent);
 615                 return -EEXIST;
 616         }
 617
 618         /* Register PCI slot */
 619         ret = pci_hp_register(&php_slot->slot, php_slot->bus,
 620                               php_slot->slot_no, php_slot->name);
 621         if (ret) {
 622                 pci_warn(php_slot->pdev, "Error %d registering slot\n", ret);
 623                 return ret;
 624         }
 625
 626         /* Attach to the parent's child list or global list */
 627         while ((dn = of_get_parent(dn))) {
 628                 if (!PCI_DN(dn)) {
 629                         of_node_put(dn);
 630                         break;
 631                 }
 632
 633                 parent = pnv_php_find_slot(dn);
 634                 if (parent) {
 635                         of_node_put(dn);
 636                         break;
 637                 }
 638
 639                 of_node_put(dn);
 640         }
 641
 642         spin_lock_irqsave(&pnv_php_lock, flags);
 643         php_slot->parent = parent;
 644         if (parent)
 645                 list_add_tail(&php_slot->link, &parent->children);
 646         else
 647                 list_add_tail(&php_slot->link, &pnv_php_slot_list);
 648         spin_unlock_irqrestore(&pnv_php_lock, flags);
 649
 650         php_slot->state = PNV_PHP_STATE_REGISTERED;
 651         return 0;
 652 }
 653
 654 static int pnv_php_enable_msix(struct pnv_php_slot *php_slot)
 655 {
 656         struct pci_dev *pdev = php_slot->pdev;
 657         struct msix_entry entry;
 658         int nr_entries, ret;
 659         u16 pcie_flag;
 660
 661         /* Get total number of MSIx entries */
 662         nr_entries = pci_msix_vec_count(pdev);
 663         if (nr_entries < 0)
 664                 return nr_entries;
 665
 666         /* Check hotplug MSIx entry is in range */
 667         pcie_capability_read_word(pdev, PCI_EXP_FLAGS, &pcie_flag);
 668         entry.entry = (pcie_flag & PCI_EXP_FLAGS_IRQ) >> 9;
 669         if (entry.entry >= nr_entries)
 670                 return -ERANGE;
 671
 672         /* Enable MSIx */
 673         ret = pci_enable_msix_exact(pdev, &entry, 1);
 674         if (ret) {
 675                 pci_warn(pdev, "Error %d enabling MSIx\n", ret);
 676                 return ret;
 677         }
 678
 679         return entry.vector;
 680 }
 681
 682 static void pnv_php_event_handler(struct work_struct *work)
 683 {
 684         struct pnv_php_event *event =
 685                 container_of(work, struct pnv_php_event, work);
 686         struct pnv_php_slot *php_slot = event->php_slot;
 687
 688         if (event->added)
 689                 pnv_php_enable_slot(&php_slot->slot);
 690         else
 691                 pnv_php_disable_slot(&php_slot->slot);
 692
 693         kfree(event);
 694 }
 695
 696 static irqreturn_t pnv_php_interrupt(int irq, void *data)
 697 {
 698         struct pnv_php_slot *php_slot = data;
 699         struct pci_dev *pchild, *pdev = php_slot->pdev;
 700         struct eeh_dev *edev;
 701         struct eeh_pe *pe;
 702         struct pnv_php_event *event;
 703         u16 sts, lsts;
 704         u8 presence;
 705         bool added;
 706         unsigned long flags;
 707         int ret;
 708
 709         pcie_capability_read_word(pdev, PCI_EXP_SLTSTA, &sts);
 710         sts &= (PCI_EXP_SLTSTA_PDC | PCI_EXP_SLTSTA_DLLSC);
 711         pcie_capability_write_word(pdev, PCI_EXP_SLTSTA, sts);
 712         if (sts & PCI_EXP_SLTSTA_DLLSC) {
 713                 pcie_capability_read_word(pdev, PCI_EXP_LNKSTA, &lsts);
 714                 added = !!(lsts & PCI_EXP_LNKSTA_DLLLA);
 715         } else if (!(php_slot->flags & PNV_PHP_FLAG_BROKEN_PDC) &&
 716                    (sts & PCI_EXP_SLTSTA_PDC)) {
 717                 ret = pnv_pci_get_presence_state(php_slot->id, &presence);
 718                 if (ret) {
 719                         pci_warn(pdev, "PCI slot [%s] error %d getting presence (0x%04x), to retry the operation.\n",
 720                                  php_slot->name, ret, sts);
 721                         return IRQ_HANDLED;
 722                 }
 723
 724                 added = !!(presence == OPAL_PCI_SLOT_PRESENT);
 725         } else {
 726                 return IRQ_NONE;
 727         }
 728
 729         /* Freeze the removed PE to avoid unexpected error reporting */
 730         if (!added) {
 731                 pchild = list_first_entry_or_null(&php_slot->bus->devices,
 732                                                   struct pci_dev, bus_list);
 733                 edev = pchild ? pci_dev_to_eeh_dev(pchild) : NULL;
 734                 pe = edev ? edev->pe : NULL;
 735                 if (pe) {
 736                         eeh_serialize_lock(&flags);
 737                         eeh_pe_state_mark(pe, EEH_PE_ISOLATED);
 738                         eeh_serialize_unlock(flags);
 739                         eeh_pe_set_option(pe, EEH_OPT_FREEZE_PE);
 740                 }
 741         }
 742
 743         /*
 744          * The PE is left in frozen state if the event is missed. It's
 745          * fine as the PCI devices (PE) aren't functional any more.
 746          */
 747         event = kzalloc(sizeof(*event), GFP_ATOMIC);
 748         if (!event) {
 749                 pci_warn(pdev, "PCI slot [%s] missed hotplug event 0x%04x\n",
 750                          php_slot->name, sts);
 751                 return IRQ_HANDLED;
 752         }
 753
 754         pci_info(pdev, "PCI slot [%s] %s (IRQ: %d)\n",
 755                  php_slot->name, added ? "added" : "removed", irq);
 756         INIT_WORK(&event->work, pnv_php_event_handler);
 757         event->added = added;
 758         event->php_slot = php_slot;
 759         queue_work(php_slot->wq, &event->work);
 760
 761         return IRQ_HANDLED;
 762 }
 763
 764 static void pnv_php_init_irq(struct pnv_php_slot *php_slot, int irq)
 765 {
 766         struct pci_dev *pdev = php_slot->pdev;
 767         u32 broken_pdc = 0;
 768         u16 sts, ctrl;
 769         int ret;
 770
 771         /* Allocate workqueue */
 772         php_slot->wq = alloc_workqueue("pciehp-%s", 0, 0, php_slot->name);
 773         if (!php_slot->wq) {
 774                 pci_warn(pdev, "Cannot alloc workqueue\n");
 775                 pnv_php_disable_irq(php_slot, true);
 776                 return;
 777         }
 778
 779         /* Check PDC (Presence Detection Change) is broken or not */
 780         ret = of_property_read_u32(php_slot->dn, "ibm,slot-broken-pdc",
 781                                    &broken_pdc);
 782         if (!ret && broken_pdc)
 783                 php_slot->flags |= PNV_PHP_FLAG_BROKEN_PDC;
 784
 785         /* Clear pending interrupts */
 786         pcie_capability_read_word(pdev, PCI_EXP_SLTSTA, &sts);
 787         if (php_slot->flags & PNV_PHP_FLAG_BROKEN_PDC)
 788                 sts |= PCI_EXP_SLTSTA_DLLSC;
 789         else
 790                 sts |= (PCI_EXP_SLTSTA_PDC | PCI_EXP_SLTSTA_DLLSC);
 791         pcie_capability_write_word(pdev, PCI_EXP_SLTSTA, sts);
 792
 793         /* Request the interrupt */
 794         ret = request_irq(irq, pnv_php_interrupt, IRQF_SHARED,
 795                           php_slot->name, php_slot);
 796         if (ret) {
 797                 pnv_php_disable_irq(php_slot, true);
 798                 pci_warn(pdev, "Error %d enabling IRQ %d\n", ret, irq);
 799                 return;
 800         }
 801
 802         /* Enable the interrupts */
 803         pcie_capability_read_word(pdev, PCI_EXP_SLTCTL, &ctrl);
 804         if (php_slot->flags & PNV_PHP_FLAG_BROKEN_PDC) {
 805                 ctrl &= ~PCI_EXP_SLTCTL_PDCE;
 806                 ctrl |= (PCI_EXP_SLTCTL_HPIE |
 807                          PCI_EXP_SLTCTL_DLLSCE);
 808         } else {
 809                 ctrl |= (PCI_EXP_SLTCTL_HPIE |
 810                          PCI_EXP_SLTCTL_PDCE |
 811                          PCI_EXP_SLTCTL_DLLSCE);
 812         }
 813         pcie_capability_write_word(pdev, PCI_EXP_SLTCTL, ctrl);
 814
 815         /* The interrupt is initialized successfully when @irq is valid */
 816         php_slot->irq = irq;
 817 }
 818
 819 static void pnv_php_enable_irq(struct pnv_php_slot *php_slot)
 820 {
 821         struct pci_dev *pdev = php_slot->pdev;
 822         int irq, ret;
 823
 824         /*
 825          * The MSI/MSIx interrupt might have been occupied by other
 826          * drivers. Don't populate the surprise hotplug capability
 827          * in that case.
 828          */
 829         if (pci_dev_msi_enabled(pdev))
 830                 return;
 831
 832         ret = pci_enable_device(pdev);
 833         if (ret) {
 834                 pci_warn(pdev, "Error %d enabling device\n", ret);
 835                 return;
 836         }
 837
 838         pci_set_master(pdev);
 839
 840         /* Enable MSIx interrupt */
 841         irq = pnv_php_enable_msix(php_slot);
 842         if (irq > 0) {
 843                 pnv_php_init_irq(php_slot, irq);
 844                 return;
 845         }
 846
 847         /*
 848          * Use MSI if MSIx doesn't work. Fail back to legacy INTx
 849          * if MSI doesn't work either
 850          */
 851         ret = pci_enable_msi(pdev);
 852         if (!ret || pdev->irq) {
 853                 irq = pdev->irq;
 854                 pnv_php_init_irq(php_slot, irq);
 855         }
 856 }
 857
 858 static int pnv_php_register_one(struct device_node *dn)
 859 {
 860         struct pnv_php_slot *php_slot;
 861         u32 prop32;
 862         int ret;
 863
 864         /* Check if it's hotpluggable slot */
 865         ret = of_property_read_u32(dn, "ibm,slot-pluggable", &prop32);
 866         if (ret || !prop32)
 867                 return -ENXIO;
 868
 869         ret = of_property_read_u32(dn, "ibm,reset-by-firmware", &prop32);
 870         if (ret || !prop32)
 871                 return -ENXIO;
 872
 873         php_slot = pnv_php_alloc_slot(dn);
 874         if (!php_slot)
 875                 return -ENODEV;
 876
 877         ret = pnv_php_register_slot(php_slot);
 878         if (ret)
 879                 goto free_slot;
 880
 881         ret = pnv_php_enable(php_slot, false);
 882         if (ret)
 883                 goto unregister_slot;
 884
 885         /* Enable interrupt if the slot supports surprise hotplug */
 886         ret = of_property_read_u32(dn, "ibm,slot-surprise-pluggable", &prop32);
 887         if (!ret && prop32)
 888                 pnv_php_enable_irq(php_slot);
 889
 890         return 0;
 891
 892 unregister_slot:
 893         pnv_php_unregister_one(php_slot->dn);
 894 free_slot:
 895         pnv_php_put_slot(php_slot);
 896         return ret;
 897 }
 898
 899 static void pnv_php_register(struct device_node *dn)
 900 {
 901         struct device_node *child;
 902
 903         /*
 904          * The parent slots should be registered before their
 905          * child slots.
 906          */
 907         for_each_child_of_node(dn, child) {
 908                 pnv_php_register_one(child);
 909                 pnv_php_register(child);
 910         }
 911 }
 912
 913 static void pnv_php_unregister_one(struct device_node *dn)
 914 {
 915         struct pnv_php_slot *php_slot;
 916
 917         php_slot = pnv_php_find_slot(dn);
 918         if (!php_slot)
 919                 return;
 920
 921         php_slot->state = PNV_PHP_STATE_OFFLINE;
 922         pnv_php_put_slot(php_slot);
 923         pci_hp_deregister(&php_slot->slot);
 924 }
 925
 926 static void pnv_php_unregister(struct device_node *dn)
 927 {
 928         struct device_node *child;
 929
 930         /* The child slots should go before their parent slots */
 931         for_each_child_of_node(dn, child) {
 932                 pnv_php_unregister(child);
 933                 pnv_php_unregister_one(child);
 934         }
 935 }
 936
 937 static int __init pnv_php_init(void)
 938 {
 939         struct device_node *dn;
 940
 941         pr_info(DRIVER_DESC " version: " DRIVER_VERSION "\n");
 942         for_each_compatible_node(dn, NULL, "ibm,ioda2-phb")
 943                 pnv_php_register(dn);
 944
 945         return 0;
 946 }
 947
 948 static void __exit pnv_php_exit(void)
 949 {
 950         struct device_node *dn;
 951
 952         for_each_compatible_node(dn, NULL, "ibm,ioda2-phb")
 953                 pnv_php_unregister(dn);
 954 }
 955
 956 module_init(pnv_php_init);
 957 module_exit(pnv_php_exit);
 958
 959 MODULE_VERSION(DRIVER_VERSION);
 960 MODULE_LICENSE("GPL v2");
 961 MODULE_AUTHOR(DRIVER_AUTHOR);
 962 MODULE_DESCRIPTION(DRIVER_DESC);