linux/drivers/pci/hotplug/sgi_hotplug.c
<<
>>
Prefs
   1/*
   2 * This file is subject to the terms and conditions of the GNU General Public
   3 * License.  See the file "COPYING" in the main directory of this archive
   4 * for more details.
   5 *
   6 * Copyright (C) 2005-2006 Silicon Graphics, Inc. All rights reserved.
   7 *
   8 * This work was based on the 2.4/2.6 kernel development by Dick Reigner.
   9 * Work to add BIOS PROM support was completed by Mike Habeck.
  10 */
  11
  12#include <linux/init.h>
  13#include <linux/kernel.h>
  14#include <linux/module.h>
  15#include <linux/pci.h>
  16#include <linux/pci_hotplug.h>
  17#include <linux/proc_fs.h>
  18#include <linux/slab.h>
  19#include <linux/types.h>
  20#include <linux/mutex.h>
  21
  22#include <asm/sn/addrs.h>
  23#include <asm/sn/geo.h>
  24#include <asm/sn/l1.h>
  25#include <asm/sn/module.h>
  26#include <asm/sn/pcibr_provider.h>
  27#include <asm/sn/pcibus_provider_defs.h>
  28#include <asm/sn/pcidev.h>
  29#include <asm/sn/sn_feature_sets.h>
  30#include <asm/sn/sn_sal.h>
  31#include <asm/sn/types.h>
  32#include <linux/acpi.h>
  33#include <asm/sn/acpi.h>
  34
  35#include "../pci.h"
  36
  37MODULE_LICENSE("GPL");
  38MODULE_AUTHOR("SGI (prarit@sgi.com, dickie@sgi.com, habeck@sgi.com)");
  39MODULE_DESCRIPTION("SGI Altix Hot Plug PCI Controller Driver");
  40
  41
  42/* SAL call error codes. Keep in sync with prom header io/include/pcibr.h */
  43#define PCI_SLOT_ALREADY_UP             2       /* slot already up */
  44#define PCI_SLOT_ALREADY_DOWN           3       /* slot already down */
  45#define PCI_L1_ERR                      7       /* L1 console command error */
  46#define PCI_EMPTY_33MHZ                 15      /* empty 33 MHz bus */
  47
  48
  49#define PCIIO_ASIC_TYPE_TIOCA           4
  50#define PCI_L1_QSIZE                    128     /* our L1 message buffer size */
  51#define SN_MAX_HP_SLOTS                 32      /* max hotplug slots */
  52#define SN_SLOT_NAME_SIZE               33      /* size of name string */
  53
  54/* internal list head */
  55static struct list_head sn_hp_list;
  56
  57/* hotplug_slot struct's private pointer */
  58struct slot {
  59        int device_num;
  60        struct pci_bus *pci_bus;
  61        /* this struct for glue internal only */
  62        struct hotplug_slot *hotplug_slot;
  63        struct list_head hp_list;
  64        char physical_path[SN_SLOT_NAME_SIZE];
  65};
  66
  67struct pcibr_slot_enable_resp {
  68        int resp_sub_errno;
  69        char resp_l1_msg[PCI_L1_QSIZE + 1];
  70};
  71
  72struct pcibr_slot_disable_resp {
  73        int resp_sub_errno;
  74        char resp_l1_msg[PCI_L1_QSIZE + 1];
  75};
  76
  77enum sn_pci_req_e {
  78        PCI_REQ_SLOT_ELIGIBLE,
  79        PCI_REQ_SLOT_DISABLE
  80};
  81
  82static int enable_slot(struct hotplug_slot *slot);
  83static int disable_slot(struct hotplug_slot *slot);
  84static inline int get_power_status(struct hotplug_slot *slot, u8 *value);
  85
  86static struct hotplug_slot_ops sn_hotplug_slot_ops = {
  87        .enable_slot            = enable_slot,
  88        .disable_slot           = disable_slot,
  89        .get_power_status       = get_power_status,
  90};
  91
  92static DEFINE_MUTEX(sn_hotplug_mutex);
  93
  94static ssize_t path_show(struct pci_slot *pci_slot, char *buf)
  95{
  96        int retval = -ENOENT;
  97        struct slot *slot = pci_slot->hotplug->private;
  98
  99        if (!slot)
 100                return retval;
 101
 102        retval = sprintf (buf, "%s\n", slot->physical_path);
 103        return retval;
 104}
 105
 106static struct pci_slot_attribute sn_slot_path_attr = __ATTR_RO(path);
 107
 108static int sn_pci_slot_valid(struct pci_bus *pci_bus, int device)
 109{
 110        struct pcibus_info *pcibus_info;
 111        u16 busnum, segment, ioboard_type;
 112
 113        pcibus_info = SN_PCIBUS_BUSSOFT_INFO(pci_bus);
 114
 115        /* Check to see if this is a valid slot on 'pci_bus' */
 116        if (!(pcibus_info->pbi_valid_devices & (1 << device)))
 117                return -EPERM;
 118
 119        ioboard_type = sn_ioboard_to_pci_bus(pci_bus);
 120        busnum = pcibus_info->pbi_buscommon.bs_persist_busnum;
 121        segment = pci_domain_nr(pci_bus) & 0xf;
 122
 123        /* Do not allow hotplug operations on base I/O cards */
 124        if ((ioboard_type == L1_BRICKTYPE_IX ||
 125             ioboard_type == L1_BRICKTYPE_IA) &&
 126            (segment == 1 && busnum == 0 && device != 1))
 127                return -EPERM;
 128
 129        return 1;
 130}
 131
 132static int sn_pci_bus_valid(struct pci_bus *pci_bus)
 133{
 134        struct pcibus_info *pcibus_info;
 135        u32 asic_type;
 136        u16 ioboard_type;
 137
 138        /* Don't register slots hanging off the TIOCA bus */
 139        pcibus_info = SN_PCIBUS_BUSSOFT_INFO(pci_bus);
 140        asic_type = pcibus_info->pbi_buscommon.bs_asic_type;
 141        if (asic_type == PCIIO_ASIC_TYPE_TIOCA)
 142                return -EPERM;
 143
 144        /* Only register slots in I/O Bricks that support hotplug */
 145        ioboard_type = sn_ioboard_to_pci_bus(pci_bus);
 146        switch (ioboard_type) {
 147                case L1_BRICKTYPE_IX:
 148                case L1_BRICKTYPE_PX:
 149                case L1_BRICKTYPE_IA:
 150                case L1_BRICKTYPE_PA:
 151                case L1_BOARDTYPE_PCIX3SLOT:
 152                        return 1;
 153                        break;
 154                default:
 155                        return -EPERM;
 156                        break;
 157        }
 158
 159        return -EIO;
 160}
 161
 162static int sn_hp_slot_private_alloc(struct hotplug_slot *bss_hotplug_slot,
 163                                    struct pci_bus *pci_bus, int device,
 164                                    char *name)
 165{
 166        struct pcibus_info *pcibus_info;
 167        struct slot *slot;
 168
 169        pcibus_info = SN_PCIBUS_BUSSOFT_INFO(pci_bus);
 170
 171        slot = kzalloc(sizeof(*slot), GFP_KERNEL);
 172        if (!slot)
 173                return -ENOMEM;
 174        bss_hotplug_slot->private = slot;
 175
 176        slot->device_num = device;
 177        slot->pci_bus = pci_bus;
 178        sprintf(name, "%04x:%02x:%02x",
 179                pci_domain_nr(pci_bus),
 180                ((u16)pcibus_info->pbi_buscommon.bs_persist_busnum),
 181                device + 1);
 182
 183        sn_generate_path(pci_bus, slot->physical_path);
 184
 185        slot->hotplug_slot = bss_hotplug_slot;
 186        list_add(&slot->hp_list, &sn_hp_list);
 187
 188        return 0;
 189}
 190
 191static struct hotplug_slot * sn_hp_destroy(void)
 192{
 193        struct slot *slot;
 194        struct pci_slot *pci_slot;
 195        struct hotplug_slot *bss_hotplug_slot = NULL;
 196
 197        list_for_each_entry(slot, &sn_hp_list, hp_list) {
 198                bss_hotplug_slot = slot->hotplug_slot;
 199                pci_slot = bss_hotplug_slot->pci_slot;
 200                list_del(&((struct slot *)bss_hotplug_slot->private)->
 201                         hp_list);
 202                sysfs_remove_file(&pci_slot->kobj,
 203                                  &sn_slot_path_attr.attr);
 204                break;
 205        }
 206        return bss_hotplug_slot;
 207}
 208
 209static void sn_bus_free_data(struct pci_dev *dev)
 210{
 211        struct pci_bus *subordinate_bus;
 212        struct pci_dev *child;
 213
 214        /* Recursively clean up sn_irq_info structs */
 215        if (dev->subordinate) {
 216                subordinate_bus = dev->subordinate;
 217                list_for_each_entry(child, &subordinate_bus->devices, bus_list)
 218                        sn_bus_free_data(child);
 219        }
 220        /*
 221         * Some drivers may use dma accesses during the
 222         * driver remove function. We release the sysdata
 223         * areas after the driver remove functions have
 224         * been called.
 225         */
 226        sn_bus_store_sysdata(dev);
 227        sn_pci_unfixup_slot(dev);
 228}
 229
 230static int sn_slot_enable(struct hotplug_slot *bss_hotplug_slot,
 231                          int device_num, char **ssdt)
 232{
 233        struct slot *slot = bss_hotplug_slot->private;
 234        struct pcibus_info *pcibus_info;
 235        struct pcibr_slot_enable_resp resp;
 236        int rc;
 237
 238        pcibus_info = SN_PCIBUS_BUSSOFT_INFO(slot->pci_bus);
 239
 240        /*
 241         * Power-on and initialize the slot in the SN
 242         * PCI infrastructure.
 243         */
 244        rc = sal_pcibr_slot_enable(pcibus_info, device_num, &resp, ssdt);
 245
 246
 247        if (rc == PCI_SLOT_ALREADY_UP) {
 248                dev_dbg(&slot->pci_bus->self->dev, "is already active\n");
 249                return 1; /* return 1 to user */
 250        }
 251
 252        if (rc == PCI_L1_ERR) {
 253                dev_dbg(&slot->pci_bus->self->dev,
 254                        "L1 failure %d with message: %s",
 255                        resp.resp_sub_errno, resp.resp_l1_msg);
 256                return -EPERM;
 257        }
 258
 259        if (rc) {
 260                dev_dbg(&slot->pci_bus->self->dev,
 261                        "insert failed with error %d sub-error %d\n",
 262                        rc, resp.resp_sub_errno);
 263                return -EIO;
 264        }
 265
 266        pcibus_info = SN_PCIBUS_BUSSOFT_INFO(slot->pci_bus);
 267        pcibus_info->pbi_enabled_devices |= (1 << device_num);
 268
 269        return 0;
 270}
 271
 272static int sn_slot_disable(struct hotplug_slot *bss_hotplug_slot,
 273                           int device_num, int action)
 274{
 275        struct slot *slot = bss_hotplug_slot->private;
 276        struct pcibus_info *pcibus_info;
 277        struct pcibr_slot_disable_resp resp;
 278        int rc;
 279
 280        pcibus_info = SN_PCIBUS_BUSSOFT_INFO(slot->pci_bus);
 281
 282        rc = sal_pcibr_slot_disable(pcibus_info, device_num, action, &resp);
 283
 284        if ((action == PCI_REQ_SLOT_ELIGIBLE) &&
 285            (rc == PCI_SLOT_ALREADY_DOWN)) {
 286                dev_dbg(&slot->pci_bus->self->dev, "Slot %s already inactive\n", slot->physical_path);
 287                return 1; /* return 1 to user */
 288        }
 289
 290        if ((action == PCI_REQ_SLOT_ELIGIBLE) && (rc == PCI_EMPTY_33MHZ)) {
 291                dev_dbg(&slot->pci_bus->self->dev,
 292                        "Cannot remove last 33MHz card\n");
 293                return -EPERM;
 294        }
 295
 296        if ((action == PCI_REQ_SLOT_ELIGIBLE) && (rc == PCI_L1_ERR)) {
 297                dev_dbg(&slot->pci_bus->self->dev,
 298                        "L1 failure %d with message \n%s\n",
 299                        resp.resp_sub_errno, resp.resp_l1_msg);
 300                return -EPERM;
 301        }
 302
 303        if ((action == PCI_REQ_SLOT_ELIGIBLE) && rc) {
 304                dev_dbg(&slot->pci_bus->self->dev,
 305                        "remove failed with error %d sub-error %d\n",
 306                        rc, resp.resp_sub_errno);
 307                return -EIO;
 308        }
 309
 310        if ((action == PCI_REQ_SLOT_ELIGIBLE) && !rc)
 311                return 0;
 312
 313        if ((action == PCI_REQ_SLOT_DISABLE) && !rc) {
 314                pcibus_info = SN_PCIBUS_BUSSOFT_INFO(slot->pci_bus);
 315                pcibus_info->pbi_enabled_devices &= ~(1 << device_num);
 316                dev_dbg(&slot->pci_bus->self->dev, "remove successful\n");
 317                return 0;
 318        }
 319
 320        if ((action == PCI_REQ_SLOT_DISABLE) && rc) {
 321                dev_dbg(&slot->pci_bus->self->dev,"remove failed rc = %d\n", rc);
 322        }
 323
 324        return rc;
 325}
 326
 327/*
 328 * Power up and configure the slot via a SAL call to PROM.
 329 * Scan slot (and any children), do any platform specific fixup,
 330 * and find device driver.
 331 */
 332static int enable_slot(struct hotplug_slot *bss_hotplug_slot)
 333{
 334        struct slot *slot = bss_hotplug_slot->private;
 335        struct pci_bus *new_bus = NULL;
 336        struct pci_dev *dev;
 337        int func, num_funcs;
 338        int new_ppb = 0;
 339        int rc;
 340        char *ssdt = NULL;
 341        void pcibios_fixup_device_resources(struct pci_dev *);
 342
 343        /* Serialize the Linux PCI infrastructure */
 344        mutex_lock(&sn_hotplug_mutex);
 345
 346        /*
 347         * Power-on and initialize the slot in the SN
 348         * PCI infrastructure. Also, retrieve the ACPI SSDT
 349         * table for the slot (if ACPI capable PROM).
 350         */
 351        rc = sn_slot_enable(bss_hotplug_slot, slot->device_num, &ssdt);
 352        if (rc) {
 353                mutex_unlock(&sn_hotplug_mutex);
 354                return rc;
 355        }
 356
 357        if (ssdt)
 358                ssdt = __va(ssdt);
 359        /* Add the new SSDT for the slot to the ACPI namespace */
 360        if (SN_ACPI_BASE_SUPPORT() && ssdt) {
 361                acpi_status ret;
 362
 363                ret = acpi_load_table((struct acpi_table_header *)ssdt);
 364                if (ACPI_FAILURE(ret)) {
 365                        printk(KERN_ERR "%s: acpi_load_table failed (0x%x)\n",
 366                               __func__, ret);
 367                        /* try to continue on */
 368                }
 369        }
 370
 371        num_funcs = pci_scan_slot(slot->pci_bus,
 372                                  PCI_DEVFN(slot->device_num + 1, 0));
 373        if (!num_funcs) {
 374                dev_dbg(&slot->pci_bus->self->dev, "no device in slot\n");
 375                mutex_unlock(&sn_hotplug_mutex);
 376                return -ENODEV;
 377        }
 378
 379        /*
 380         * Map SN resources for all functions on the card
 381         * to the Linux PCI interface and tell the drivers
 382         * about them.
 383         */
 384        for (func = 0; func < num_funcs;  func++) {
 385                dev = pci_get_slot(slot->pci_bus,
 386                                   PCI_DEVFN(slot->device_num + 1,
 387                                             PCI_FUNC(func)));
 388                if (dev) {
 389                        /* Need to do slot fixup on PPB before fixup of children
 390                         * (PPB's pcidev_info needs to be in pcidev_info list
 391                         * before child's SN_PCIDEV_INFO() call to setup
 392                         * pdi_host_pcidev_info).
 393                         */
 394                        pcibios_fixup_device_resources(dev);
 395                        if (SN_ACPI_BASE_SUPPORT())
 396                                sn_acpi_slot_fixup(dev);
 397                        else
 398                                sn_io_slot_fixup(dev);
 399                        if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE) {
 400                                unsigned char sec_bus;
 401                                pci_read_config_byte(dev, PCI_SECONDARY_BUS,
 402                                                     &sec_bus);
 403                                new_bus = pci_add_new_bus(dev->bus, dev,
 404                                                          sec_bus);
 405                                pci_scan_child_bus(new_bus);
 406                                new_ppb = 1;
 407                        }
 408                        pci_dev_put(dev);
 409                }
 410        }
 411
 412        /*
 413         * Add the slot's devices to the ACPI infrastructure */
 414        if (SN_ACPI_BASE_SUPPORT() && ssdt) {
 415                unsigned long long adr;
 416                struct acpi_device *pdevice;
 417                struct acpi_device *device;
 418                acpi_handle phandle;
 419                acpi_handle chandle = NULL;
 420                acpi_handle rethandle;
 421                acpi_status ret;
 422
 423                phandle = PCI_CONTROLLER(slot->pci_bus)->acpi_handle;
 424
 425                if (acpi_bus_get_device(phandle, &pdevice)) {
 426                        dev_dbg(&slot->pci_bus->self->dev,
 427                                "no parent device, assuming NULL\n");
 428                        pdevice = NULL;
 429                }
 430
 431                /*
 432                 * Walk the rootbus node's immediate children looking for
 433                 * the slot's device node(s). There can be more than
 434                 * one for multifunction devices.
 435                 */
 436                for (;;) {
 437                        rethandle = NULL;
 438                        ret = acpi_get_next_object(ACPI_TYPE_DEVICE,
 439                                                   phandle, chandle,
 440                                                   &rethandle);
 441
 442                        if (ret == AE_NOT_FOUND || rethandle == NULL)
 443                                break;
 444
 445                        chandle = rethandle;
 446
 447                        ret = acpi_evaluate_integer(chandle, METHOD_NAME__ADR,
 448                                                    NULL, &adr);
 449
 450                        if (ACPI_SUCCESS(ret) &&
 451                            (adr>>16) == (slot->device_num + 1)) {
 452
 453                                ret = acpi_bus_add(&device, pdevice, chandle,
 454                                                   ACPI_BUS_TYPE_DEVICE);
 455                                if (ACPI_FAILURE(ret)) {
 456                                        printk(KERN_ERR "%s: acpi_bus_add "
 457                                               "failed (0x%x) for slot %d "
 458                                               "func %d\n", __func__,
 459                                               ret, (int)(adr>>16),
 460                                               (int)(adr&0xffff));
 461                                        /* try to continue on */
 462                                } else {
 463                                        acpi_bus_start(device);
 464                                }
 465                        }
 466                }
 467        }
 468
 469        /* Call the driver for the new device */
 470        pci_bus_add_devices(slot->pci_bus);
 471        /* Call the drivers for the new devices subordinate to PPB */
 472        if (new_ppb)
 473                pci_bus_add_devices(new_bus);
 474
 475        mutex_unlock(&sn_hotplug_mutex);
 476
 477        if (rc == 0)
 478                dev_dbg(&slot->pci_bus->self->dev,
 479                        "insert operation successful\n");
 480        else
 481                dev_dbg(&slot->pci_bus->self->dev,
 482                        "insert operation failed rc = %d\n", rc);
 483
 484        return rc;
 485}
 486
 487static int disable_slot(struct hotplug_slot *bss_hotplug_slot)
 488{
 489        struct slot *slot = bss_hotplug_slot->private;
 490        struct pci_dev *dev;
 491        int func;
 492        int rc;
 493        acpi_owner_id ssdt_id = 0;
 494
 495        /* Acquire update access to the bus */
 496        mutex_lock(&sn_hotplug_mutex);
 497
 498        /* is it okay to bring this slot down? */
 499        rc = sn_slot_disable(bss_hotplug_slot, slot->device_num,
 500                             PCI_REQ_SLOT_ELIGIBLE);
 501        if (rc)
 502                goto leaving;
 503
 504        /* free the ACPI resources for the slot */
 505        if (SN_ACPI_BASE_SUPPORT() &&
 506            PCI_CONTROLLER(slot->pci_bus)->acpi_handle) {
 507                unsigned long long adr;
 508                struct acpi_device *device;
 509                acpi_handle phandle;
 510                acpi_handle chandle = NULL;
 511                acpi_handle rethandle;
 512                acpi_status ret;
 513
 514                /* Get the rootbus node pointer */
 515                phandle = PCI_CONTROLLER(slot->pci_bus)->acpi_handle;
 516
 517                /*
 518                 * Walk the rootbus node's immediate children looking for
 519                 * the slot's device node(s). There can be more than
 520                 * one for multifunction devices.
 521                 */
 522                for (;;) {
 523                        rethandle = NULL;
 524                        ret = acpi_get_next_object(ACPI_TYPE_DEVICE,
 525                                                   phandle, chandle,
 526                                                   &rethandle);
 527
 528                        if (ret == AE_NOT_FOUND || rethandle == NULL)
 529                                break;
 530
 531                        chandle = rethandle;
 532
 533                        ret = acpi_evaluate_integer(chandle,
 534                                                    METHOD_NAME__ADR,
 535                                                    NULL, &adr);
 536                        if (ACPI_SUCCESS(ret) &&
 537                            (adr>>16) == (slot->device_num + 1)) {
 538                                /* retain the owner id */
 539                                acpi_get_id(chandle, &ssdt_id);
 540
 541                                ret = acpi_bus_get_device(chandle,
 542                                                          &device);
 543                                if (ACPI_SUCCESS(ret))
 544                                        acpi_bus_trim(device, 1);
 545                        }
 546                }
 547
 548        }
 549
 550        /* Free the SN resources assigned to the Linux device.*/
 551        for (func = 0; func < 8;  func++) {
 552                dev = pci_get_slot(slot->pci_bus,
 553                                   PCI_DEVFN(slot->device_num + 1,
 554                                             PCI_FUNC(func)));
 555                if (dev) {
 556                        sn_bus_free_data(dev);
 557                        pci_remove_bus_device(dev);
 558                        pci_dev_put(dev);
 559                }
 560        }
 561
 562        /* Remove the SSDT for the slot from the ACPI namespace */
 563        if (SN_ACPI_BASE_SUPPORT() && ssdt_id) {
 564                acpi_status ret;
 565                ret = acpi_unload_table_id(ssdt_id);
 566                if (ACPI_FAILURE(ret)) {
 567                        printk(KERN_ERR "%s: acpi_unload_table_id "
 568                               "failed (0x%x) for id %d\n",
 569                               __func__, ret, ssdt_id);
 570                        /* try to continue on */
 571                }
 572        }
 573
 574        /* free the collected sysdata pointers */
 575        sn_bus_free_sysdata();
 576
 577        /* Deactivate slot */
 578        rc = sn_slot_disable(bss_hotplug_slot, slot->device_num,
 579                             PCI_REQ_SLOT_DISABLE);
 580 leaving:
 581        /* Release the bus lock */
 582        mutex_unlock(&sn_hotplug_mutex);
 583
 584        return rc;
 585}
 586
 587static inline int get_power_status(struct hotplug_slot *bss_hotplug_slot,
 588                                   u8 *value)
 589{
 590        struct slot *slot = bss_hotplug_slot->private;
 591        struct pcibus_info *pcibus_info;
 592        u32 power;
 593
 594        pcibus_info = SN_PCIBUS_BUSSOFT_INFO(slot->pci_bus);
 595        mutex_lock(&sn_hotplug_mutex);
 596        power = pcibus_info->pbi_enabled_devices & (1 << slot->device_num);
 597        *value = power ? 1 : 0;
 598        mutex_unlock(&sn_hotplug_mutex);
 599        return 0;
 600}
 601
 602static void sn_release_slot(struct hotplug_slot *bss_hotplug_slot)
 603{
 604        kfree(bss_hotplug_slot->info);
 605        kfree(bss_hotplug_slot->private);
 606        kfree(bss_hotplug_slot);
 607}
 608
 609static int sn_hotplug_slot_register(struct pci_bus *pci_bus)
 610{
 611        int device;
 612        struct pci_slot *pci_slot;
 613        struct hotplug_slot *bss_hotplug_slot;
 614        char name[SN_SLOT_NAME_SIZE];
 615        int rc = 0;
 616
 617        /*
 618         * Currently only four devices are supported,
 619         * in the future there maybe more -- up to 32.
 620         */
 621
 622        for (device = 0; device < SN_MAX_HP_SLOTS ; device++) {
 623                if (sn_pci_slot_valid(pci_bus, device) != 1)
 624                        continue;
 625
 626                bss_hotplug_slot = kzalloc(sizeof(*bss_hotplug_slot),
 627                                           GFP_KERNEL);
 628                if (!bss_hotplug_slot) {
 629                        rc = -ENOMEM;
 630                        goto alloc_err;
 631                }
 632
 633                bss_hotplug_slot->info =
 634                        kzalloc(sizeof(struct hotplug_slot_info),
 635                                GFP_KERNEL);
 636                if (!bss_hotplug_slot->info) {
 637                        rc = -ENOMEM;
 638                        goto alloc_err;
 639                }
 640
 641                if (sn_hp_slot_private_alloc(bss_hotplug_slot,
 642                                             pci_bus, device, name)) {
 643                        rc = -ENOMEM;
 644                        goto alloc_err;
 645                }
 646                bss_hotplug_slot->ops = &sn_hotplug_slot_ops;
 647                bss_hotplug_slot->release = &sn_release_slot;
 648
 649                rc = pci_hp_register(bss_hotplug_slot, pci_bus, device, name);
 650                if (rc)
 651                        goto register_err;
 652
 653                pci_slot = bss_hotplug_slot->pci_slot;
 654                rc = sysfs_create_file(&pci_slot->kobj,
 655                                       &sn_slot_path_attr.attr);
 656                if (rc)
 657                        goto register_err;
 658        }
 659        dev_dbg(&pci_bus->self->dev, "Registered bus with hotplug\n");
 660        return rc;
 661
 662register_err:
 663        dev_dbg(&pci_bus->self->dev, "bus failed to register with err = %d\n",
 664                rc);
 665
 666alloc_err:
 667        if (rc == -ENOMEM)
 668                dev_dbg(&pci_bus->self->dev, "Memory allocation error\n");
 669
 670        /* destroy THIS element */
 671        if (bss_hotplug_slot)
 672                sn_release_slot(bss_hotplug_slot);
 673
 674        /* destroy anything else on the list */
 675        while ((bss_hotplug_slot = sn_hp_destroy()))
 676                pci_hp_deregister(bss_hotplug_slot);
 677
 678        return rc;
 679}
 680
 681static int __init sn_pci_hotplug_init(void)
 682{
 683        struct pci_bus *pci_bus = NULL;
 684        int rc;
 685        int registered = 0;
 686
 687        if (!sn_prom_feature_available(PRF_HOTPLUG_SUPPORT)) {
 688                printk(KERN_ERR "%s: PROM version does not support hotplug.\n",
 689                       __func__);
 690                return -EPERM;
 691        }
 692
 693        INIT_LIST_HEAD(&sn_hp_list);
 694
 695        while ((pci_bus = pci_find_next_bus(pci_bus))) {
 696                if (!pci_bus->sysdata)
 697                        continue;
 698
 699                rc = sn_pci_bus_valid(pci_bus);
 700                if (rc != 1) {
 701                        dev_dbg(&pci_bus->self->dev, "not a valid hotplug bus\n");
 702                        continue;
 703                }
 704                dev_dbg(&pci_bus->self->dev, "valid hotplug bus\n");
 705
 706                rc = sn_hotplug_slot_register(pci_bus);
 707                if (!rc) {
 708                        registered = 1;
 709                } else {
 710                        registered = 0;
 711                        break;
 712                }
 713        }
 714
 715        return registered == 1 ? 0 : -ENODEV;
 716}
 717
 718static void __exit sn_pci_hotplug_exit(void)
 719{
 720        struct hotplug_slot *bss_hotplug_slot;
 721
 722        while ((bss_hotplug_slot = sn_hp_destroy()))
 723                pci_hp_deregister(bss_hotplug_slot);
 724
 725        if (!list_empty(&sn_hp_list))
 726                printk(KERN_ERR "%s: internal list is not empty\n", __FILE__);
 727}
 728
 729module_init(sn_pci_hotplug_init);
 730module_exit(sn_pci_hotplug_exit);
 731