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_stop_and_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