drivers/pci/hotplug/rpadlpar_core.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Interface for Dynamic Logical Partitioning of I/O Slots on
   4  * RPA-compliant PPC64 platform.
   5  *
   6  * John Rose <johnrose@austin.ibm.com>
   7  * Linda Xie <lxie@us.ibm.com>
   8  *
   9  * October 2003
  10  *
  11  * Copyright (C) 2003 IBM.
  12  */
  13
  14 #undef DEBUG
  15
  16 #include <linux/init.h>
  17 #include <linux/module.h>
  18 #include <linux/of.h>
  19 #include <linux/pci.h>
  20 #include <linux/string.h>
  21 #include <linux/vmalloc.h>
  22
  23 #include <asm/pci-bridge.h>
  24 #include <linux/mutex.h>
  25 #include <asm/rtas.h>
  26 #include <asm/vio.h>
  27 #include <linux/firmware.h>
  28
  29 #include "../pci.h"
  30 #include "rpaphp.h"
  31 #include "rpadlpar.h"
  32
  33 static DEFINE_MUTEX(rpadlpar_mutex);
  34
  35 #define DLPAR_MODULE_NAME "rpadlpar_io"
  36
  37 #define NODE_TYPE_VIO  1
  38 #define NODE_TYPE_SLOT 2
  39 #define NODE_TYPE_PHB  3
  40
  41 static struct device_node *find_vio_slot_node(char *drc_name)
  42 {
  43         struct device_node *parent = of_find_node_by_name(NULL, "vdevice");
  44         struct device_node *dn;
  45         int rc;
  46
  47         if (!parent)
  48                 return NULL;
  49
  50         for_each_child_of_node(parent, dn) {
  51                 rc = rpaphp_check_drc_props(dn, drc_name, NULL);
  52                 if (rc == 0)
  53                         break;
  54         }
  55         of_node_put(parent);
  56
  57         return dn;
  58 }
  59
  60 /* Find dlpar-capable pci node that contains the specified name and type */
  61 static struct device_node *find_php_slot_pci_node(char *drc_name,
  62                                                   char *drc_type)
  63 {
  64         struct device_node *np;
  65         int rc;
  66
  67         for_each_node_by_name(np, "pci") {
  68                 rc = rpaphp_check_drc_props(np, drc_name, drc_type);
  69                 if (rc == 0)
  70                         break;
  71         }
  72
  73         return np;
  74 }
  75
  76 /* Returns a device_node with its reference count incremented */
  77 static struct device_node *find_dlpar_node(char *drc_name, int *node_type)
  78 {
  79         struct device_node *dn;
  80
  81         dn = find_php_slot_pci_node(drc_name, "SLOT");
  82         if (dn) {
  83                 *node_type = NODE_TYPE_SLOT;
  84                 return dn;
  85         }
  86
  87         dn = find_php_slot_pci_node(drc_name, "PHB");
  88         if (dn) {
  89                 *node_type = NODE_TYPE_PHB;
  90                 return dn;
  91         }
  92
  93         dn = find_vio_slot_node(drc_name);
  94         if (dn) {
  95                 *node_type = NODE_TYPE_VIO;
  96                 return dn;
  97         }
  98
  99         return NULL;
 100 }
 101
 102 /**
 103  * find_php_slot - return hotplug slot structure for device node
 104  * @dn: target &device_node
 105  *
 106  * This routine will return the hotplug slot structure
 107  * for a given device node. Note that built-in PCI slots
 108  * may be dlpar-able, but not hot-pluggable, so this routine
 109  * will return NULL for built-in PCI slots.
 110  */
 111 static struct slot *find_php_slot(struct device_node *dn)
 112 {
 113         struct slot *slot, *next;
 114
 115         list_for_each_entry_safe(slot, next, &rpaphp_slot_head,
 116                                  rpaphp_slot_list) {
 117                 if (slot->dn == dn)
 118                         return slot;
 119         }
 120
 121         return NULL;
 122 }
 123
 124 static struct pci_dev *dlpar_find_new_dev(struct pci_bus *parent,
 125                                         struct device_node *dev_dn)
 126 {
 127         struct pci_dev *tmp = NULL;
 128         struct device_node *child_dn;
 129
 130         list_for_each_entry(tmp, &parent->devices, bus_list) {
 131                 child_dn = pci_device_to_OF_node(tmp);
 132                 if (child_dn == dev_dn)
 133                         return tmp;
 134         }
 135         return NULL;
 136 }
 137
 138 static void dlpar_pci_add_bus(struct device_node *dn)
 139 {
 140         struct pci_dn *pdn = PCI_DN(dn);
 141         struct pci_controller *phb = pdn->phb;
 142         struct pci_dev *dev = NULL;
 143
 144         pseries_eeh_init_edev_recursive(pdn);
 145
 146         /* Add EADS device to PHB bus, adding new entry to bus->devices */
 147         dev = of_create_pci_dev(dn, phb->bus, pdn->devfn);
 148         if (!dev) {
 149                 printk(KERN_ERR "%s: failed to create pci dev for %pOF\n",
 150                                 __func__, dn);
 151                 return;
 152         }
 153
 154         /* Scan below the new bridge */
 155         if (pci_is_bridge(dev))
 156                 of_scan_pci_bridge(dev);
 157
 158         /* Map IO space for child bus, which may or may not succeed */
 159         pcibios_map_io_space(dev->subordinate);
 160
 161         /* Finish adding it : resource allocation, adding devices, etc...
 162          * Note that we need to perform the finish pass on the -parent-
 163          * bus of the EADS bridge so the bridge device itself gets
 164          * properly added
 165          */
 166         pcibios_finish_adding_to_bus(phb->bus);
 167 }
 168
 169 static int dlpar_add_pci_slot(char *drc_name, struct device_node *dn)
 170 {
 171         struct pci_dev *dev;
 172         struct pci_controller *phb;
 173
 174         if (pci_find_bus_by_node(dn))
 175                 return -EINVAL;
 176
 177         /* Add pci bus */
 178         dlpar_pci_add_bus(dn);
 179
 180         /* Confirm new bridge dev was created */
 181         phb = PCI_DN(dn)->phb;
 182         dev = dlpar_find_new_dev(phb->bus, dn);
 183
 184         if (!dev) {
 185                 printk(KERN_ERR "%s: unable to add bus %s\n", __func__,
 186                         drc_name);
 187                 return -EIO;
 188         }
 189
 190         if (dev->hdr_type != PCI_HEADER_TYPE_BRIDGE) {
 191                 printk(KERN_ERR "%s: unexpected header type %d, unable to add bus %s\n",
 192                         __func__, dev->hdr_type, drc_name);
 193                 return -EIO;
 194         }
 195
 196         /* Add hotplug slot */
 197         if (rpaphp_add_slot(dn)) {
 198                 printk(KERN_ERR "%s: unable to add hotplug slot %s\n",
 199                         __func__, drc_name);
 200                 return -EIO;
 201         }
 202         return 0;
 203 }
 204
 205 static int dlpar_remove_phb(char *drc_name, struct device_node *dn)
 206 {
 207         struct slot *slot;
 208         struct pci_dn *pdn;
 209         int rc = 0;
 210
 211         if (!pci_find_bus_by_node(dn))
 212                 return -EINVAL;
 213
 214         /* If pci slot is hotpluggable, use hotplug to remove it */
 215         slot = find_php_slot(dn);
 216         if (slot && rpaphp_deregister_slot(slot)) {
 217                 printk(KERN_ERR "%s: unable to remove hotplug slot %s\n",
 218                        __func__, drc_name);
 219                 return -EIO;
 220         }
 221
 222         pdn = dn->data;
 223         BUG_ON(!pdn || !pdn->phb);
 224         rc = remove_phb_dynamic(pdn->phb);
 225         if (rc < 0)
 226                 return rc;
 227
 228         pdn->phb = NULL;
 229
 230         return 0;
 231 }
 232
 233 static int dlpar_add_phb(char *drc_name, struct device_node *dn)
 234 {
 235         struct pci_controller *phb;
 236
 237         if (PCI_DN(dn) && PCI_DN(dn)->phb) {
 238                 /* PHB already exists */
 239                 return -EINVAL;
 240         }
 241
 242         phb = init_phb_dynamic(dn);
 243         if (!phb)
 244                 return -EIO;
 245
 246         if (rpaphp_add_slot(dn)) {
 247                 printk(KERN_ERR "%s: unable to add hotplug slot %s\n",
 248                         __func__, drc_name);
 249                 return -EIO;
 250         }
 251         return 0;
 252 }
 253
 254 static int dlpar_add_vio_slot(char *drc_name, struct device_node *dn)
 255 {
 256         struct vio_dev *vio_dev;
 257
 258         vio_dev = vio_find_node(dn);
 259         if (vio_dev) {
 260                 put_device(&vio_dev->dev);
 261                 return -EINVAL;
 262         }
 263
 264         if (!vio_register_device_node(dn)) {
 265                 printk(KERN_ERR
 266                         "%s: failed to register vio node %s\n",
 267                         __func__, drc_name);
 268                 return -EIO;
 269         }
 270         return 0;
 271 }
 272
 273 /**
 274  * dlpar_add_slot - DLPAR add an I/O Slot
 275  * @drc_name: drc-name of newly added slot
 276  *
 277  * Make the hotplug module and the kernel aware of a newly added I/O Slot.
 278  * Return Codes:
 279  * 0                    Success
 280  * -ENODEV              Not a valid drc_name
 281  * -EINVAL              Slot already added
 282  * -ERESTARTSYS         Signalled before obtaining lock
 283  * -EIO                 Internal PCI Error
 284  */
 285 int dlpar_add_slot(char *drc_name)
 286 {
 287         struct device_node *dn = NULL;
 288         int node_type;
 289         int rc = -EIO;
 290
 291         if (mutex_lock_interruptible(&rpadlpar_mutex))
 292                 return -ERESTARTSYS;
 293
 294         /* Find newly added node */
 295         dn = find_dlpar_node(drc_name, &node_type);
 296         if (!dn) {
 297                 rc = -ENODEV;
 298                 goto exit;
 299         }
 300
 301         switch (node_type) {
 302                 case NODE_TYPE_VIO:
 303                         rc = dlpar_add_vio_slot(drc_name, dn);
 304                         break;
 305                 case NODE_TYPE_SLOT:
 306                         rc = dlpar_add_pci_slot(drc_name, dn);
 307                         break;
 308                 case NODE_TYPE_PHB:
 309                         rc = dlpar_add_phb(drc_name, dn);
 310                         break;
 311         }
 312         of_node_put(dn);
 313
 314         printk(KERN_INFO "%s: slot %s added\n", DLPAR_MODULE_NAME, drc_name);
 315 exit:
 316         mutex_unlock(&rpadlpar_mutex);
 317         return rc;
 318 }
 319
 320 /**
 321  * dlpar_remove_vio_slot - DLPAR remove a virtual I/O Slot
 322  * @drc_name: drc-name of newly added slot
 323  * @dn: &device_node
 324  *
 325  * Remove the kernel and hotplug representations of an I/O Slot.
 326  * Return Codes:
 327  * 0                    Success
 328  * -EINVAL              Vio dev doesn't exist
 329  */
 330 static int dlpar_remove_vio_slot(char *drc_name, struct device_node *dn)
 331 {
 332         struct vio_dev *vio_dev;
 333
 334         vio_dev = vio_find_node(dn);
 335         if (!vio_dev)
 336                 return -EINVAL;
 337
 338         vio_unregister_device(vio_dev);
 339
 340         put_device(&vio_dev->dev);
 341
 342         return 0;
 343 }
 344
 345 /**
 346  * dlpar_remove_pci_slot - DLPAR remove a PCI I/O Slot
 347  * @drc_name: drc-name of newly added slot
 348  * @dn: &device_node
 349  *
 350  * Remove the kernel and hotplug representations of a PCI I/O Slot.
 351  * Return Codes:
 352  * 0                    Success
 353  * -ENODEV              Not a valid drc_name
 354  * -EIO                 Internal PCI Error
 355  */
 356 static int dlpar_remove_pci_slot(char *drc_name, struct device_node *dn)
 357 {
 358         struct pci_bus *bus;
 359         struct slot *slot;
 360         int ret = 0;
 361
 362         pci_lock_rescan_remove();
 363
 364         bus = pci_find_bus_by_node(dn);
 365         if (!bus) {
 366                 ret = -EINVAL;
 367                 goto out;
 368         }
 369
 370         pr_debug("PCI: Removing PCI slot below EADS bridge %s\n",
 371                  bus->self ? pci_name(bus->self) : "<!PHB!>");
 372
 373         slot = find_php_slot(dn);
 374         if (slot) {
 375                 pr_debug("PCI: Removing hotplug slot for %04x:%02x...\n",
 376                          pci_domain_nr(bus), bus->number);
 377
 378                 if (rpaphp_deregister_slot(slot)) {
 379                         printk(KERN_ERR
 380                                 "%s: unable to remove hotplug slot %s\n",
 381                                 __func__, drc_name);
 382                         ret = -EIO;
 383                         goto out;
 384                 }
 385         }
 386
 387         /* Remove all devices below slot */
 388         pci_hp_remove_devices(bus);
 389
 390         /* Unmap PCI IO space */
 391         if (pcibios_unmap_io_space(bus)) {
 392                 printk(KERN_ERR "%s: failed to unmap bus range\n",
 393                         __func__);
 394                 ret = -ERANGE;
 395                 goto out;
 396         }
 397
 398         /* Remove the EADS bridge device itself */
 399         BUG_ON(!bus->self);
 400         pr_debug("PCI: Now removing bridge device %s\n", pci_name(bus->self));
 401         pci_stop_and_remove_bus_device(bus->self);
 402
 403  out:
 404         pci_unlock_rescan_remove();
 405         return ret;
 406 }
 407
 408 /**
 409  * dlpar_remove_slot - DLPAR remove an I/O Slot
 410  * @drc_name: drc-name of newly added slot
 411  *
 412  * Remove the kernel and hotplug representations of an I/O Slot.
 413  * Return Codes:
 414  * 0                    Success
 415  * -ENODEV              Not a valid drc_name
 416  * -EINVAL              Slot already removed
 417  * -ERESTARTSYS         Signalled before obtaining lock
 418  * -EIO                 Internal Error
 419  */
 420 int dlpar_remove_slot(char *drc_name)
 421 {
 422         struct device_node *dn;
 423         int node_type;
 424         int rc = 0;
 425
 426         if (mutex_lock_interruptible(&rpadlpar_mutex))
 427                 return -ERESTARTSYS;
 428
 429         dn = find_dlpar_node(drc_name, &node_type);
 430         if (!dn) {
 431                 rc = -ENODEV;
 432                 goto exit;
 433         }
 434
 435         switch (node_type) {
 436                 case NODE_TYPE_VIO:
 437                         rc = dlpar_remove_vio_slot(drc_name, dn);
 438                         break;
 439                 case NODE_TYPE_PHB:
 440                         rc = dlpar_remove_phb(drc_name, dn);
 441                         break;
 442                 case NODE_TYPE_SLOT:
 443                         rc = dlpar_remove_pci_slot(drc_name, dn);
 444                         break;
 445         }
 446         of_node_put(dn);
 447         vm_unmap_aliases();
 448
 449         printk(KERN_INFO "%s: slot %s removed\n", DLPAR_MODULE_NAME, drc_name);
 450 exit:
 451         mutex_unlock(&rpadlpar_mutex);
 452         return rc;
 453 }
 454
 455 static inline int is_dlpar_capable(void)
 456 {
 457         int rc = rtas_token("ibm,configure-connector");
 458
 459         return (int) (rc != RTAS_UNKNOWN_SERVICE);
 460 }
 461
 462 static int __init rpadlpar_io_init(void)
 463 {
 464
 465         if (!is_dlpar_capable()) {
 466                 printk(KERN_WARNING "%s: partition not DLPAR capable\n",
 467                         __func__);
 468                 return -EPERM;
 469         }
 470
 471         return dlpar_sysfs_init();
 472 }
 473
 474 static void __exit rpadlpar_io_exit(void)
 475 {
 476         dlpar_sysfs_exit();
 477 }
 478
 479 module_init(rpadlpar_io_init);
 480 module_exit(rpadlpar_io_exit);
 481 MODULE_LICENSE("GPL");
 482 MODULE_DESCRIPTION("RPA Dynamic Logical Partitioning driver for I/O slots");