Kobject: convert drivers/* from kobject_unregister() to kobject_put()
[linux-2.6.git] / 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/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);