git.oblomov.eu Git - linux-2.6/blob - drivers/pci/hotplug/pci_hotplug_core.c

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