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