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/acpi.h> 13#include <linux/init.h> 14#include <linux/kernel.h> 15#include <linux/module.h> 16#include <linux/pci.h> 17#include <linux/pci_hotplug.h> 18#include <linux/proc_fs.h> 19#include <linux/slab.h> 20#include <linux/types.h> 21#include <linux/mutex.h> 22 23#include <asm/sn/addrs.h> 24#include <asm/sn/geo.h> 25#include <asm/sn/l1.h> 26#include <asm/sn/module.h> 27#include <asm/sn/pcibr_provider.h> 28#include <asm/sn/pcibus_provider_defs.h> 29#include <asm/sn/pcidev.h> 30#include <asm/sn/sn_feature_sets.h> 31#include <asm/sn/sn_sal.h> 32#include <asm/sn/types.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, "L1 failure %d with message: %s", 254 resp.resp_sub_errno, resp.resp_l1_msg); 255 return -EPERM; 256 } 257 258 if (rc) { 259 dev_dbg(&slot->pci_bus->self->dev, "insert failed with error %d sub-error %d\n", 260 rc, resp.resp_sub_errno); 261 return -EIO; 262 } 263 264 pcibus_info = SN_PCIBUS_BUSSOFT_INFO(slot->pci_bus); 265 pcibus_info->pbi_enabled_devices |= (1 << device_num); 266 267 return 0; 268} 269 270static int sn_slot_disable(struct hotplug_slot *bss_hotplug_slot, 271 int device_num, int action) 272{ 273 struct slot *slot = bss_hotplug_slot->private; 274 struct pcibus_info *pcibus_info; 275 struct pcibr_slot_disable_resp resp; 276 int rc; 277 278 pcibus_info = SN_PCIBUS_BUSSOFT_INFO(slot->pci_bus); 279 280 rc = sal_pcibr_slot_disable(pcibus_info, device_num, action, &resp); 281 282 if ((action == PCI_REQ_SLOT_ELIGIBLE) && 283 (rc == PCI_SLOT_ALREADY_DOWN)) { 284 dev_dbg(&slot->pci_bus->self->dev, "Slot %s already inactive\n", slot->physical_path); 285 return 1; /* return 1 to user */ 286 } 287 288 if ((action == PCI_REQ_SLOT_ELIGIBLE) && (rc == PCI_EMPTY_33MHZ)) { 289 dev_dbg(&slot->pci_bus->self->dev, "Cannot remove last 33MHz card\n"); 290 return -EPERM; 291 } 292 293 if ((action == PCI_REQ_SLOT_ELIGIBLE) && (rc == PCI_L1_ERR)) { 294 dev_dbg(&slot->pci_bus->self->dev, "L1 failure %d with message \n%s\n", 295 resp.resp_sub_errno, resp.resp_l1_msg); 296 return -EPERM; 297 } 298 299 if ((action == PCI_REQ_SLOT_ELIGIBLE) && rc) { 300 dev_dbg(&slot->pci_bus->self->dev, "remove failed with error %d sub-error %d\n", 301 rc, resp.resp_sub_errno); 302 return -EIO; 303 } 304 305 if ((action == PCI_REQ_SLOT_ELIGIBLE) && !rc) 306 return 0; 307 308 if ((action == PCI_REQ_SLOT_DISABLE) && !rc) { 309 pcibus_info = SN_PCIBUS_BUSSOFT_INFO(slot->pci_bus); 310 pcibus_info->pbi_enabled_devices &= ~(1 << device_num); 311 dev_dbg(&slot->pci_bus->self->dev, "remove successful\n"); 312 return 0; 313 } 314 315 if ((action == PCI_REQ_SLOT_DISABLE) && rc) { 316 dev_dbg(&slot->pci_bus->self->dev,"remove failed rc = %d\n", rc); 317 } 318 319 return rc; 320} 321 322/* 323 * Power up and configure the slot via a SAL call to PROM. 324 * Scan slot (and any children), do any platform specific fixup, 325 * and find device driver. 326 */ 327static int enable_slot(struct hotplug_slot *bss_hotplug_slot) 328{ 329 struct slot *slot = bss_hotplug_slot->private; 330 struct pci_bus *new_bus = NULL; 331 struct pci_dev *dev; 332 int num_funcs; 333 int new_ppb = 0; 334 int rc; 335 char *ssdt = NULL; 336 void pcibios_fixup_device_resources(struct pci_dev *); 337 338 /* Serialize the Linux PCI infrastructure */ 339 mutex_lock(&sn_hotplug_mutex); 340 341 /* 342 * Power-on and initialize the slot in the SN 343 * PCI infrastructure. Also, retrieve the ACPI SSDT 344 * table for the slot (if ACPI capable PROM). 345 */ 346 rc = sn_slot_enable(bss_hotplug_slot, slot->device_num, &ssdt); 347 if (rc) { 348 mutex_unlock(&sn_hotplug_mutex); 349 return rc; 350 } 351 352 if (ssdt) 353 ssdt = __va(ssdt); 354 /* Add the new SSDT for the slot to the ACPI namespace */ 355 if (SN_ACPI_BASE_SUPPORT() && ssdt) { 356 acpi_status ret; 357 358 ret = acpi_load_table((struct acpi_table_header *)ssdt); 359 if (ACPI_FAILURE(ret)) { 360 printk(KERN_ERR "%s: acpi_load_table failed (0x%x)\n", 361 __func__, ret); 362 /* try to continue on */ 363 } 364 } 365 366 num_funcs = pci_scan_slot(slot->pci_bus, 367 PCI_DEVFN(slot->device_num + 1, 0)); 368 if (!num_funcs) { 369 dev_dbg(&slot->pci_bus->self->dev, "no device in slot\n"); 370 mutex_unlock(&sn_hotplug_mutex); 371 return -ENODEV; 372 } 373 374 /* 375 * Map SN resources for all functions on the card 376 * to the Linux PCI interface and tell the drivers 377 * about them. 378 */ 379 list_for_each_entry(dev, &slot->pci_bus->devices, bus_list) { 380 if (PCI_SLOT(dev->devfn) != slot->device_num + 1) 381 continue; 382 383 /* Need to do slot fixup on PPB before fixup of children 384 * (PPB's pcidev_info needs to be in pcidev_info list 385 * before child's SN_PCIDEV_INFO() call to setup 386 * pdi_host_pcidev_info). 387 */ 388 pcibios_fixup_device_resources(dev); 389 if (SN_ACPI_BASE_SUPPORT()) 390 sn_acpi_slot_fixup(dev); 391 else 392 sn_io_slot_fixup(dev); 393 if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE) { 394 pci_hp_add_bridge(dev); 395 if (dev->subordinate) { 396 new_bus = dev->subordinate; 397 new_ppb = 1; 398 } 399 } 400 } 401 402 /* 403 * Add the slot's devices to the ACPI infrastructure */ 404 if (SN_ACPI_BASE_SUPPORT() && ssdt) { 405 unsigned long long adr; 406 struct acpi_device *pdevice; 407 acpi_handle phandle; 408 acpi_handle chandle = NULL; 409 acpi_handle rethandle; 410 acpi_status ret; 411 412 phandle = acpi_device_handle(PCI_CONTROLLER(slot->pci_bus)->companion); 413 414 if (acpi_bus_get_device(phandle, &pdevice)) { 415 dev_dbg(&slot->pci_bus->self->dev, "no parent device, assuming NULL\n"); 416 pdevice = NULL; 417 } 418 419 acpi_scan_lock_acquire(); 420 /* 421 * Walk the rootbus node's immediate children looking for 422 * the slot's device node(s). There can be more than 423 * one for multifunction devices. 424 */ 425 for (;;) { 426 rethandle = NULL; 427 ret = acpi_get_next_object(ACPI_TYPE_DEVICE, 428 phandle, chandle, 429 &rethandle); 430 431 if (ret == AE_NOT_FOUND || rethandle == NULL) 432 break; 433 434 chandle = rethandle; 435 436 ret = acpi_evaluate_integer(chandle, METHOD_NAME__ADR, 437 NULL, &adr); 438 439 if (ACPI_SUCCESS(ret) && 440 (adr>>16) == (slot->device_num + 1)) { 441 442 ret = acpi_bus_scan(chandle); 443 if (ACPI_FAILURE(ret)) { 444 printk(KERN_ERR "%s: acpi_bus_scan failed (0x%x) for slot %d func %d\n", 445 __func__, ret, (int)(adr>>16), 446 (int)(adr&0xffff)); 447 /* try to continue on */ 448 } 449 } 450 } 451 acpi_scan_lock_release(); 452 } 453 454 pci_lock_rescan_remove(); 455 456 /* Call the driver for the new device */ 457 pci_bus_add_devices(slot->pci_bus); 458 /* Call the drivers for the new devices subordinate to PPB */ 459 if (new_ppb) 460 pci_bus_add_devices(new_bus); 461 462 pci_unlock_rescan_remove(); 463 mutex_unlock(&sn_hotplug_mutex); 464 465 if (rc == 0) 466 dev_dbg(&slot->pci_bus->self->dev, "insert operation successful\n"); 467 else 468 dev_dbg(&slot->pci_bus->self->dev, "insert operation failed rc = %d\n", rc); 469 470 return rc; 471} 472 473static int disable_slot(struct hotplug_slot *bss_hotplug_slot) 474{ 475 struct slot *slot = bss_hotplug_slot->private; 476 struct pci_dev *dev, *temp; 477 int rc; 478 acpi_owner_id ssdt_id = 0; 479 480 /* Acquire update access to the bus */ 481 mutex_lock(&sn_hotplug_mutex); 482 483 /* is it okay to bring this slot down? */ 484 rc = sn_slot_disable(bss_hotplug_slot, slot->device_num, 485 PCI_REQ_SLOT_ELIGIBLE); 486 if (rc) 487 goto leaving; 488 489 /* free the ACPI resources for the slot */ 490 if (SN_ACPI_BASE_SUPPORT() && 491 PCI_CONTROLLER(slot->pci_bus)->companion) { 492 unsigned long long adr; 493 struct acpi_device *device; 494 acpi_handle phandle; 495 acpi_handle chandle = NULL; 496 acpi_handle rethandle; 497 acpi_status ret; 498 499 /* Get the rootbus node pointer */ 500 phandle = acpi_device_handle(PCI_CONTROLLER(slot->pci_bus)->companion); 501 502 acpi_scan_lock_acquire(); 503 /* 504 * Walk the rootbus node's immediate children looking for 505 * the slot's device node(s). There can be more than 506 * one for multifunction devices. 507 */ 508 for (;;) { 509 rethandle = NULL; 510 ret = acpi_get_next_object(ACPI_TYPE_DEVICE, 511 phandle, chandle, 512 &rethandle); 513 514 if (ret == AE_NOT_FOUND || rethandle == NULL) 515 break; 516 517 chandle = rethandle; 518 519 ret = acpi_evaluate_integer(chandle, 520 METHOD_NAME__ADR, 521 NULL, &adr); 522 if (ACPI_SUCCESS(ret) && 523 (adr>>16) == (slot->device_num + 1)) { 524 /* retain the owner id */ 525 acpi_get_id(chandle, &ssdt_id); 526 527 ret = acpi_bus_get_device(chandle, 528 &device); 529 if (ACPI_SUCCESS(ret)) 530 acpi_bus_trim(device); 531 } 532 } 533 acpi_scan_lock_release(); 534 } 535 536 pci_lock_rescan_remove(); 537 /* Free the SN resources assigned to the Linux device.*/ 538 list_for_each_entry_safe(dev, temp, &slot->pci_bus->devices, bus_list) { 539 if (PCI_SLOT(dev->devfn) != slot->device_num + 1) 540 continue; 541 542 pci_dev_get(dev); 543 sn_bus_free_data(dev); 544 pci_stop_and_remove_bus_device(dev); 545 pci_dev_put(dev); 546 } 547 pci_unlock_rescan_remove(); 548 549 /* Remove the SSDT for the slot from the ACPI namespace */ 550 if (SN_ACPI_BASE_SUPPORT() && ssdt_id) { 551 acpi_status ret; 552 ret = acpi_unload_table_id(ssdt_id); 553 if (ACPI_FAILURE(ret)) { 554 printk(KERN_ERR "%s: acpi_unload_table_id failed (0x%x) for id %d\n", 555 __func__, ret, ssdt_id); 556 /* try to continue on */ 557 } 558 } 559 560 /* free the collected sysdata pointers */ 561 sn_bus_free_sysdata(); 562 563 /* Deactivate slot */ 564 rc = sn_slot_disable(bss_hotplug_slot, slot->device_num, 565 PCI_REQ_SLOT_DISABLE); 566 leaving: 567 /* Release the bus lock */ 568 mutex_unlock(&sn_hotplug_mutex); 569 570 return rc; 571} 572 573static inline int get_power_status(struct hotplug_slot *bss_hotplug_slot, 574 u8 *value) 575{ 576 struct slot *slot = bss_hotplug_slot->private; 577 struct pcibus_info *pcibus_info; 578 u32 power; 579 580 pcibus_info = SN_PCIBUS_BUSSOFT_INFO(slot->pci_bus); 581 mutex_lock(&sn_hotplug_mutex); 582 power = pcibus_info->pbi_enabled_devices & (1 << slot->device_num); 583 *value = power ? 1 : 0; 584 mutex_unlock(&sn_hotplug_mutex); 585 return 0; 586} 587 588static void sn_release_slot(struct hotplug_slot *bss_hotplug_slot) 589{ 590 kfree(bss_hotplug_slot->info); 591 kfree(bss_hotplug_slot->private); 592 kfree(bss_hotplug_slot); 593} 594 595static int sn_hotplug_slot_register(struct pci_bus *pci_bus) 596{ 597 int device; 598 struct pci_slot *pci_slot; 599 struct hotplug_slot *bss_hotplug_slot; 600 char name[SN_SLOT_NAME_SIZE]; 601 int rc = 0; 602 603 /* 604 * Currently only four devices are supported, 605 * in the future there maybe more -- up to 32. 606 */ 607 608 for (device = 0; device < SN_MAX_HP_SLOTS ; device++) { 609 if (sn_pci_slot_valid(pci_bus, device) != 1) 610 continue; 611 612 bss_hotplug_slot = kzalloc(sizeof(*bss_hotplug_slot), 613 GFP_KERNEL); 614 if (!bss_hotplug_slot) { 615 rc = -ENOMEM; 616 goto alloc_err; 617 } 618 619 bss_hotplug_slot->info = 620 kzalloc(sizeof(struct hotplug_slot_info), 621 GFP_KERNEL); 622 if (!bss_hotplug_slot->info) { 623 rc = -ENOMEM; 624 goto alloc_err; 625 } 626 627 if (sn_hp_slot_private_alloc(bss_hotplug_slot, 628 pci_bus, device, name)) { 629 rc = -ENOMEM; 630 goto alloc_err; 631 } 632 bss_hotplug_slot->ops = &sn_hotplug_slot_ops; 633 bss_hotplug_slot->release = &sn_release_slot; 634 635 rc = pci_hp_register(bss_hotplug_slot, pci_bus, device, name); 636 if (rc) 637 goto register_err; 638 639 pci_slot = bss_hotplug_slot->pci_slot; 640 rc = sysfs_create_file(&pci_slot->kobj, 641 &sn_slot_path_attr.attr); 642 if (rc) 643 goto register_err; 644 } 645 dev_dbg(&pci_bus->self->dev, "Registered bus with hotplug\n"); 646 return rc; 647 648register_err: 649 dev_dbg(&pci_bus->self->dev, "bus failed to register with err = %d\n", 650 rc); 651 652alloc_err: 653 if (rc == -ENOMEM) 654 dev_dbg(&pci_bus->self->dev, "Memory allocation error\n"); 655 656 /* destroy THIS element */ 657 if (bss_hotplug_slot) 658 sn_release_slot(bss_hotplug_slot); 659 660 /* destroy anything else on the list */ 661 while ((bss_hotplug_slot = sn_hp_destroy())) 662 pci_hp_deregister(bss_hotplug_slot); 663 664 return rc; 665} 666 667static int __init sn_pci_hotplug_init(void) 668{ 669 struct pci_bus *pci_bus = NULL; 670 int rc; 671 int registered = 0; 672 673 if (!sn_prom_feature_available(PRF_HOTPLUG_SUPPORT)) { 674 printk(KERN_ERR "%s: PROM version does not support hotplug.\n", 675 __func__); 676 return -EPERM; 677 } 678 679 INIT_LIST_HEAD(&sn_hp_list); 680 681 while ((pci_bus = pci_find_next_bus(pci_bus))) { 682 if (!pci_bus->sysdata) 683 continue; 684 685 rc = sn_pci_bus_valid(pci_bus); 686 if (rc != 1) { 687 dev_dbg(&pci_bus->self->dev, "not a valid hotplug bus\n"); 688 continue; 689 } 690 dev_dbg(&pci_bus->self->dev, "valid hotplug bus\n"); 691 692 rc = sn_hotplug_slot_register(pci_bus); 693 if (!rc) { 694 registered = 1; 695 } else { 696 registered = 0; 697 break; 698 } 699 } 700 701 return registered == 1 ? 0 : -ENODEV; 702} 703 704static void __exit sn_pci_hotplug_exit(void) 705{ 706 struct hotplug_slot *bss_hotplug_slot; 707 708 while ((bss_hotplug_slot = sn_hp_destroy())) 709 pci_hp_deregister(bss_hotplug_slot); 710 711 if (!list_empty(&sn_hp_list)) 712 printk(KERN_ERR "%s: internal list is not empty\n", __FILE__); 713} 714 715module_init(sn_pci_hotplug_init); 716module_exit(sn_pci_hotplug_exit); 717