1 /* 2 * PCI HotPlug Controller Core 3 * 4 * Copyright (C) 2001-2002 Greg Kroah-Hartman (greg@kroah.com) 5 * Copyright (C) 2001-2002 IBM Corp. 6 * 7 * All rights reserved. 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License as published by 11 * the Free Software Foundation; either version 2 of the License, or (at 12 * your option) any later version. 13 * 14 * This program is distributed in the hope that it will be useful, but 15 * WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or 17 * NON INFRINGEMENT. See the GNU General Public License for more 18 * details. 19 * 20 * You should have received a copy of the GNU General Public License 21 * along with this program; if not, write to the Free Software 22 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 23 * 24 * Send feedback to <kristen.c.accardi@intel.com> 25 * 26 */ 27 28 #include <linux/module.h> 29 #include <linux/moduleparam.h> 30 #include <linux/kernel.h> 31 #include <linux/types.h> 32 #include <linux/list.h> 33 #include <linux/kobject.h> 34 #include <linux/sysfs.h> 35 #include <linux/pagemap.h> 36 #include <linux/slab.h> 37 #include <linux/init.h> 38 #include <linux/mount.h> 39 #include <linux/namei.h> 40 #include <linux/pci.h> 41 #include <linux/pci_hotplug.h> 42 #include <asm/uaccess.h> 43 44 #define MY_NAME "pci_hotplug" 45 46 #define dbg(fmt, arg...) do { if (debug) printk(KERN_DEBUG "%s: %s: " fmt , MY_NAME , __FUNCTION__ , ## arg); } while (0) 47 #define err(format, arg...) printk(KERN_ERR "%s: " format , MY_NAME , ## arg) 48 #define info(format, arg...) printk(KERN_INFO "%s: " format , MY_NAME , ## arg) 49 #define warn(format, arg...) printk(KERN_WARNING "%s: " format , MY_NAME , ## arg) 50 51 52 /* local variables */ 53 static int debug; 54 55 #define DRIVER_VERSION "0.5" 56 #define DRIVER_AUTHOR "Greg Kroah-Hartman <greg@kroah.com>, Scott Murray <scottm@somanetworks.com>" 57 #define DRIVER_DESC "PCI Hot Plug PCI Core" 58 59 60 ////////////////////////////////////////////////////////////////// 61 62 static LIST_HEAD(pci_hotplug_slot_list); 63 64 struct kset *pci_hotplug_slots_kset; 65 66 static ssize_t hotplug_slot_attr_show(struct kobject *kobj, 67 struct attribute *attr, char *buf) 68 { 69 struct hotplug_slot *slot = to_hotplug_slot(kobj); 70 struct hotplug_slot_attribute *attribute = to_hotplug_attr(attr); 71 return attribute->show ? attribute->show(slot, buf) : -EIO; 72 } 73 74 static ssize_t hotplug_slot_attr_store(struct kobject *kobj, 75 struct attribute *attr, const char *buf, size_t len) 76 { 77 struct hotplug_slot *slot = to_hotplug_slot(kobj); 78 struct hotplug_slot_attribute *attribute = to_hotplug_attr(attr); 79 return attribute->store ? attribute->store(slot, buf, len) : -EIO; 80 } 81 82 static struct sysfs_ops hotplug_slot_sysfs_ops = { 83 .show = hotplug_slot_attr_show, 84 .store = hotplug_slot_attr_store, 85 }; 86 87 static void hotplug_slot_release(struct kobject *kobj) 88 { 89 struct hotplug_slot *slot = to_hotplug_slot(kobj); 90 if (slot->release) 91 slot->release(slot); 92 } 93 94 static struct kobj_type hotplug_slot_ktype = { 95 .sysfs_ops = &hotplug_slot_sysfs_ops, 96 .release = &hotplug_slot_release, 97 }; 98 99 /* these strings match up with the values in pci_bus_speed */ 100 static char *pci_bus_speed_strings[] = { 101 "33 MHz PCI", /* 0x00 */ 102 "66 MHz PCI", /* 0x01 */ 103 "66 MHz PCIX", /* 0x02 */ 104 "100 MHz PCIX", /* 0x03 */ 105 "133 MHz PCIX", /* 0x04 */ 106 NULL, /* 0x05 */ 107 NULL, /* 0x06 */ 108 NULL, /* 0x07 */ 109 NULL, /* 0x08 */ 110 "66 MHz PCIX 266", /* 0x09 */ 111 "100 MHz PCIX 266", /* 0x0a */ 112 "133 MHz PCIX 266", /* 0x0b */ 113 NULL, /* 0x0c */ 114 NULL, /* 0x0d */ 115 NULL, /* 0x0e */ 116 NULL, /* 0x0f */ 117 NULL, /* 0x10 */ 118 "66 MHz PCIX 533", /* 0x11 */ 119 "100 MHz PCIX 533", /* 0x12 */ 120 "133 MHz PCIX 533", /* 0x13 */ 121 "25 GBps PCI-E", /* 0x14 */ 122 }; 123 124 #ifdef CONFIG_HOTPLUG_PCI_CPCI 125 extern int cpci_hotplug_init(int debug); 126 extern void cpci_hotplug_exit(void); 127 #else 128 static inline int cpci_hotplug_init(int debug) { return 0; } 129 static inline void cpci_hotplug_exit(void) { } 130 #endif 131 132 /* Weee, fun with macros... */ 133 #define GET_STATUS(name,type) \ 134 static int get_##name (struct hotplug_slot *slot, type *value) \ 135 { \ 136 struct hotplug_slot_ops *ops = slot->ops; \ 137 int retval = 0; \ 138 if (try_module_get(ops->owner)) { \ 139 if (ops->get_##name) \ 140 retval = ops->get_##name(slot, value); \ 141 else \ 142 *value = slot->info->name; \ 143 module_put(ops->owner); \ 144 } \ 145 return retval; \ 146 } 147 148 GET_STATUS(power_status, u8) 149 GET_STATUS(attention_status, u8) 150 GET_STATUS(latch_status, u8) 151 GET_STATUS(adapter_status, u8) 152 GET_STATUS(address, u32) 153 GET_STATUS(max_bus_speed, enum pci_bus_speed) 154 GET_STATUS(cur_bus_speed, enum pci_bus_speed) 155 156 static ssize_t power_read_file (struct hotplug_slot *slot, char *buf) 157 { 158 int retval; 159 u8 value; 160 161 retval = get_power_status (slot, &value); 162 if (retval) 163 goto exit; 164 retval = sprintf (buf, "%d\n", value); 165 exit: 166 return retval; 167 } 168 169 static ssize_t power_write_file (struct hotplug_slot *slot, const char *buf, 170 size_t count) 171 { 172 unsigned long lpower; 173 u8 power; 174 int retval = 0; 175 176 lpower = simple_strtoul (buf, NULL, 10); 177 power = (u8)(lpower & 0xff); 178 dbg ("power = %d\n", power); 179 180 if (!try_module_get(slot->ops->owner)) { 181 retval = -ENODEV; 182 goto exit; 183 } 184 switch (power) { 185 case 0: 186 if (slot->ops->disable_slot) 187 retval = slot->ops->disable_slot(slot); 188 break; 189 190 case 1: 191 if (slot->ops->enable_slot) 192 retval = slot->ops->enable_slot(slot); 193 break; 194 195 default: 196 err ("Illegal value specified for power\n"); 197 retval = -EINVAL; 198 } 199 module_put(slot->ops->owner); 200 201 exit: 202 if (retval) 203 return retval; 204 return count; 205 } 206 207 static struct hotplug_slot_attribute hotplug_slot_attr_power = { 208 .attr = {.name = "power", .mode = S_IFREG | S_IRUGO | S_IWUSR}, 209 .show = power_read_file, 210 .store = power_write_file 211 }; 212 213 static ssize_t attention_read_file (struct hotplug_slot *slot, char *buf) 214 { 215 int retval; 216 u8 value; 217 218 retval = get_attention_status (slot, &value); 219 if (retval) 220 goto exit; 221 retval = sprintf (buf, "%d\n", value); 222 223 exit: 224 return retval; 225 } 226 227 static ssize_t attention_write_file (struct hotplug_slot *slot, const char *buf, 228 size_t count) 229 { 230 unsigned long lattention; 231 u8 attention; 232 int retval = 0; 233 234 lattention = simple_strtoul (buf, NULL, 10); 235 attention = (u8)(lattention & 0xff); 236 dbg (" - attention = %d\n", attention); 237 238 if (!try_module_get(slot->ops->owner)) { 239 retval = -ENODEV; 240 goto exit; 241 } 242 if (slot->ops->set_attention_status) 243 retval = slot->ops->set_attention_status(slot, attention); 244 module_put(slot->ops->owner); 245 246 exit: 247 if (retval) 248 return retval; 249 return count; 250 } 251 252 static struct hotplug_slot_attribute hotplug_slot_attr_attention = { 253 .attr = {.name = "attention", .mode = S_IFREG | S_IRUGO | S_IWUSR}, 254 .show = attention_read_file, 255 .store = attention_write_file 256 }; 257 258 static ssize_t latch_read_file (struct hotplug_slot *slot, char *buf) 259 { 260 int retval; 261 u8 value; 262 263 retval = get_latch_status (slot, &value); 264 if (retval) 265 goto exit; 266 retval = sprintf (buf, "%d\n", value); 267 268 exit: 269 return retval; 270 } 271 272 static struct hotplug_slot_attribute hotplug_slot_attr_latch = { 273 .attr = {.name = "latch", .mode = S_IFREG | S_IRUGO}, 274 .show = latch_read_file, 275 }; 276 277 static ssize_t presence_read_file (struct hotplug_slot *slot, char *buf) 278 { 279 int retval; 280 u8 value; 281 282 retval = get_adapter_status (slot, &value); 283 if (retval) 284 goto exit; 285 retval = sprintf (buf, "%d\n", value); 286 287 exit: 288 return retval; 289 } 290 291 static struct hotplug_slot_attribute hotplug_slot_attr_presence = { 292 .attr = {.name = "adapter", .mode = S_IFREG | S_IRUGO}, 293 .show = presence_read_file, 294 }; 295 296 static ssize_t address_read_file (struct hotplug_slot *slot, char *buf) 297 { 298 int retval; 299 u32 address; 300 301 retval = get_address (slot, &address); 302 if (retval) 303 goto exit; 304 retval = sprintf (buf, "%04x:%02x:%02x\n", 305 (address >> 16) & 0xffff, 306 (address >> 8) & 0xff, 307 address & 0xff); 308 309 exit: 310 return retval; 311 } 312 313 static struct hotplug_slot_attribute hotplug_slot_attr_address = { 314 .attr = {.name = "address", .mode = S_IFREG | S_IRUGO}, 315 .show = address_read_file, 316 }; 317 318 static char *unknown_speed = "Unknown bus speed"; 319 320 static ssize_t max_bus_speed_read_file (struct hotplug_slot *slot, char *buf) 321 { 322 char *speed_string; 323 int retval; 324 enum pci_bus_speed value; 325 326 retval = get_max_bus_speed (slot, &value); 327 if (retval) 328 goto exit; 329 330 if (value == PCI_SPEED_UNKNOWN) 331 speed_string = unknown_speed; 332 else 333 speed_string = pci_bus_speed_strings[value]; 334 335 retval = sprintf (buf, "%s\n", speed_string); 336 337 exit: 338 return retval; 339 } 340 341 static struct hotplug_slot_attribute hotplug_slot_attr_max_bus_speed = { 342 .attr = {.name = "max_bus_speed", .mode = S_IFREG | S_IRUGO}, 343 .show = max_bus_speed_read_file, 344 }; 345 346 static ssize_t cur_bus_speed_read_file (struct hotplug_slot *slot, char *buf) 347 { 348 char *speed_string; 349 int retval; 350 enum pci_bus_speed value; 351 352 retval = get_cur_bus_speed (slot, &value); 353 if (retval) 354 goto exit; 355 356 if (value == PCI_SPEED_UNKNOWN) 357 speed_string = unknown_speed; 358 else 359 speed_string = pci_bus_speed_strings[value]; 360 361 retval = sprintf (buf, "%s\n", speed_string); 362 363 exit: 364 return retval; 365 } 366 367 static struct hotplug_slot_attribute hotplug_slot_attr_cur_bus_speed = { 368 .attr = {.name = "cur_bus_speed", .mode = S_IFREG | S_IRUGO}, 369 .show = cur_bus_speed_read_file, 370 }; 371 372 static ssize_t test_write_file (struct hotplug_slot *slot, const char *buf, 373 size_t count) 374 { 375 unsigned long ltest; 376 u32 test; 377 int retval = 0; 378 379 ltest = simple_strtoul (buf, NULL, 10); 380 test = (u32)(ltest & 0xffffffff); 381 dbg ("test = %d\n", test); 382 383 if (!try_module_get(slot->ops->owner)) { 384 retval = -ENODEV; 385 goto exit; 386 } 387 if (slot->ops->hardware_test) 388 retval = slot->ops->hardware_test(slot, test); 389 module_put(slot->ops->owner); 390 391 exit: 392 if (retval) 393 return retval; 394 return count; 395 } 396 397 static struct hotplug_slot_attribute hotplug_slot_attr_test = { 398 .attr = {.name = "test", .mode = S_IFREG | S_IRUGO | S_IWUSR}, 399 .store = test_write_file 400 }; 401 402 static int has_power_file (struct hotplug_slot *slot) 403 { 404 if ((!slot) || (!slot->ops)) 405 return -ENODEV; 406 if ((slot->ops->enable_slot) || 407 (slot->ops->disable_slot) || 408 (slot->ops->get_power_status)) 409 return 0; 410 return -ENOENT; 411 } 412 413 static int has_attention_file (struct hotplug_slot *slot) 414 { 415 if ((!slot) || (!slot->ops)) 416 return -ENODEV; 417 if ((slot->ops->set_attention_status) || 418 (slot->ops->get_attention_status)) 419 return 0; 420 return -ENOENT; 421 } 422 423 static int has_latch_file (struct hotplug_slot *slot) 424 { 425 if ((!slot) || (!slot->ops)) 426 return -ENODEV; 427 if (slot->ops->get_latch_status) 428 return 0; 429 return -ENOENT; 430 } 431 432 static int has_adapter_file (struct hotplug_slot *slot) 433 { 434 if ((!slot) || (!slot->ops)) 435 return -ENODEV; 436 if (slot->ops->get_adapter_status) 437 return 0; 438 return -ENOENT; 439 } 440 441 static int has_address_file (struct hotplug_slot *slot) 442 { 443 if ((!slot) || (!slot->ops)) 444 return -ENODEV; 445 if (slot->ops->get_address) 446 return 0; 447 return -ENOENT; 448 } 449 450 static int has_max_bus_speed_file (struct hotplug_slot *slot) 451 { 452 if ((!slot) || (!slot->ops)) 453 return -ENODEV; 454 if (slot->ops->get_max_bus_speed) 455 return 0; 456 return -ENOENT; 457 } 458 459 static int has_cur_bus_speed_file (struct hotplug_slot *slot) 460 { 461 if ((!slot) || (!slot->ops)) 462 return -ENODEV; 463 if (slot->ops->get_cur_bus_speed) 464 return 0; 465 return -ENOENT; 466 } 467 468 static int has_test_file (struct hotplug_slot *slot) 469 { 470 if ((!slot) || (!slot->ops)) 471 return -ENODEV; 472 if (slot->ops->hardware_test) 473 return 0; 474 return -ENOENT; 475 } 476 477 static int fs_add_slot (struct hotplug_slot *slot) 478 { 479 int retval = 0; 480 481 if (has_power_file(slot) == 0) { 482 retval = sysfs_create_file(&slot->kobj, &hotplug_slot_attr_power.attr); 483 if (retval) 484 goto exit_power; 485 } 486 487 if (has_attention_file(slot) == 0) { 488 retval = sysfs_create_file(&slot->kobj, 489 &hotplug_slot_attr_attention.attr); 490 if (retval) 491 goto exit_attention; 492 } 493 494 if (has_latch_file(slot) == 0) { 495 retval = sysfs_create_file(&slot->kobj, 496 &hotplug_slot_attr_latch.attr); 497 if (retval) 498 goto exit_latch; 499 } 500 501 if (has_adapter_file(slot) == 0) { 502 retval = sysfs_create_file(&slot->kobj, 503 &hotplug_slot_attr_presence.attr); 504 if (retval) 505 goto exit_adapter; 506 } 507 508 if (has_address_file(slot) == 0) { 509 retval = sysfs_create_file(&slot->kobj, 510 &hotplug_slot_attr_address.attr); 511 if (retval) 512 goto exit_address; 513 } 514 515 if (has_max_bus_speed_file(slot) == 0) { 516 retval = sysfs_create_file(&slot->kobj, 517 &hotplug_slot_attr_max_bus_speed.attr); 518 if (retval) 519 goto exit_max_speed; 520 } 521 522 if (has_cur_bus_speed_file(slot) == 0) { 523 retval = sysfs_create_file(&slot->kobj, 524 &hotplug_slot_attr_cur_bus_speed.attr); 525 if (retval) 526 goto exit_cur_speed; 527 } 528 529 if (has_test_file(slot) == 0) { 530 retval = sysfs_create_file(&slot->kobj, 531 &hotplug_slot_attr_test.attr); 532 if (retval) 533 goto exit_test; 534 } 535 536 goto exit; 537 538 exit_test: 539 if (has_cur_bus_speed_file(slot) == 0) 540 sysfs_remove_file(&slot->kobj, &hotplug_slot_attr_cur_bus_speed.attr); 541 542 exit_cur_speed: 543 if (has_max_bus_speed_file(slot) == 0) 544 sysfs_remove_file(&slot->kobj, &hotplug_slot_attr_max_bus_speed.attr); 545 546 exit_max_speed: 547 if (has_address_file(slot) == 0) 548 sysfs_remove_file(&slot->kobj, &hotplug_slot_attr_address.attr); 549 550 exit_address: 551 if (has_adapter_file(slot) == 0) 552 sysfs_remove_file(&slot->kobj, &hotplug_slot_attr_presence.attr); 553 554 exit_adapter: 555 if (has_latch_file(slot) == 0) 556 sysfs_remove_file(&slot->kobj, &hotplug_slot_attr_latch.attr); 557 558 exit_latch: 559 if (has_attention_file(slot) == 0) 560 sysfs_remove_file(&slot->kobj, &hotplug_slot_attr_attention.attr); 561 562 exit_attention: 563 if (has_power_file(slot) == 0) 564 sysfs_remove_file(&slot->kobj, &hotplug_slot_attr_power.attr); 565 exit_power: 566 exit: 567 return retval; 568 } 569 570 static void fs_remove_slot (struct hotplug_slot *slot) 571 { 572 if (has_power_file(slot) == 0) 573 sysfs_remove_file(&slot->kobj, &hotplug_slot_attr_power.attr); 574 575 if (has_attention_file(slot) == 0) 576 sysfs_remove_file(&slot->kobj, &hotplug_slot_attr_attention.attr); 577 578 if (has_latch_file(slot) == 0) 579 sysfs_remove_file(&slot->kobj, &hotplug_slot_attr_latch.attr); 580 581 if (has_adapter_file(slot) == 0) 582 sysfs_remove_file(&slot->kobj, &hotplug_slot_attr_presence.attr); 583 584 if (has_address_file(slot) == 0) 585 sysfs_remove_file(&slot->kobj, &hotplug_slot_attr_address.attr); 586 587 if (has_max_bus_speed_file(slot) == 0) 588 sysfs_remove_file(&slot->kobj, &hotplug_slot_attr_max_bus_speed.attr); 589 590 if (has_cur_bus_speed_file(slot) == 0) 591 sysfs_remove_file(&slot->kobj, &hotplug_slot_attr_cur_bus_speed.attr); 592 593 if (has_test_file(slot) == 0) 594 sysfs_remove_file(&slot->kobj, &hotplug_slot_attr_test.attr); 595 } 596 597 static struct hotplug_slot *get_slot_from_name (const char *name) 598 { 599 struct hotplug_slot *slot; 600 struct list_head *tmp; 601 602 list_for_each (tmp, &pci_hotplug_slot_list) { 603 slot = list_entry (tmp, struct hotplug_slot, slot_list); 604 if (strcmp(slot->name, name) == 0) 605 return slot; 606 } 607 return NULL; 608 } 609 610 /** 611 * pci_hp_register - register a hotplug_slot with the PCI hotplug subsystem 612 * @slot: pointer to the &struct hotplug_slot to register 613 * 614 * Registers a hotplug slot with the pci hotplug subsystem, which will allow 615 * userspace interaction to the slot. 616 * 617 * Returns 0 if successful, anything else for an error. 618 */ 619 int pci_hp_register (struct hotplug_slot *slot) 620 { 621 int result; 622 623 if (slot == NULL) 624 return -ENODEV; 625 if ((slot->info == NULL) || (slot->ops == NULL)) 626 return -EINVAL; 627 if (slot->release == NULL) { 628 dbg("Why are you trying to register a hotplug slot " 629 "without a proper release function?\n"); 630 return -EINVAL; 631 } 632 633 /* this can fail if we have already registered a slot with the same name */ 634 slot->kobj.kset = pci_hotplug_slots_kset; 635 result = kobject_init_and_add(&slot->kobj, &hotplug_slot_ktype, NULL, 636 "%s", slot->name); 637 if (result) { 638 err("Unable to register kobject '%s'", slot->name); 639 return -EINVAL; 640 } 641 642 list_add (&slot->slot_list, &pci_hotplug_slot_list); 643 644 result = fs_add_slot (slot); 645 kobject_uevent(&slot->kobj, KOBJ_ADD); 646 dbg ("Added slot %s to the list\n", slot->name); 647 return result; 648 } 649 650 /** 651 * pci_hp_deregister - deregister a hotplug_slot with the PCI hotplug subsystem 652 * @slot: pointer to the &struct hotplug_slot to deregister 653 * 654 * The @slot must have been registered with the pci hotplug subsystem 655 * previously with a call to pci_hp_register(). 656 * 657 * Returns 0 if successful, anything else for an error. 658 */ 659 int pci_hp_deregister (struct hotplug_slot *slot) 660 { 661 struct hotplug_slot *temp; 662 663 if (slot == NULL) 664 return -ENODEV; 665 666 temp = get_slot_from_name (slot->name); 667 if (temp != slot) { 668 return -ENODEV; 669 } 670 list_del (&slot->slot_list); 671 672 fs_remove_slot (slot); 673 dbg ("Removed slot %s from the list\n", slot->name); 674 kobject_put(&slot->kobj); 675 return 0; 676 } 677 678 /** 679 * pci_hp_change_slot_info - changes the slot's information structure in the core 680 * @slot: pointer to the slot whose info has changed 681 * @info: pointer to the info copy into the slot's info structure 682 * 683 * @slot must have been registered with the pci 684 * hotplug subsystem previously with a call to pci_hp_register(). 685 * 686 * Returns 0 if successful, anything else for an error. 687 */ 688 int __must_check pci_hp_change_slot_info(struct hotplug_slot *slot, 689 struct hotplug_slot_info *info) 690 { 691 if ((slot == NULL) || (info == NULL)) 692 return -ENODEV; 693 694 memcpy (slot->info, info, sizeof (struct hotplug_slot_info)); 695 696 return 0; 697 } 698 699 static int __init pci_hotplug_init (void) 700 { 701 int result; 702 struct kset *pci_bus_kset; 703 704 pci_bus_kset = bus_get_kset(&pci_bus_type); 705 706 pci_hotplug_slots_kset = kset_create_and_add("slots", NULL, 707 &pci_bus_kset->kobj); 708 if (!pci_hotplug_slots_kset) { 709 result = -ENOMEM; 710 err("Register subsys error\n"); 711 goto exit; 712 } 713 result = cpci_hotplug_init(debug); 714 if (result) { 715 err ("cpci_hotplug_init with error %d\n", result); 716 goto err_subsys; 717 } 718 719 info (DRIVER_DESC " version: " DRIVER_VERSION "\n"); 720 goto exit; 721 722 err_subsys: 723 kset_unregister(pci_hotplug_slots_kset); 724 exit: 725 return result; 726 } 727 728 static void __exit pci_hotplug_exit (void) 729 { 730 cpci_hotplug_exit(); 731 kset_unregister(pci_hotplug_slots_kset); 732 } 733 734 module_init(pci_hotplug_init); 735 module_exit(pci_hotplug_exit); 736 737 MODULE_AUTHOR(DRIVER_AUTHOR); 738 MODULE_DESCRIPTION(DRIVER_DESC); 739 MODULE_LICENSE("GPL"); 740 module_param(debug, bool, 0644); 741 MODULE_PARM_DESC(debug, "Debugging mode enabled or not"); 742 743 EXPORT_SYMBOL_GPL(pci_hotplug_slots_kset); 744 EXPORT_SYMBOL_GPL(pci_hp_register); 745 EXPORT_SYMBOL_GPL(pci_hp_deregister); 746 EXPORT_SYMBOL_GPL(pci_hp_change_slot_info); 747