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