2 * bus.c - bus driver management
4 * Copyright (c) 2002-3 Patrick Mochel
5 * Copyright (c) 2002-3 Open Source Development Labs
6 * Copyright (c) 2007 Greg Kroah-Hartman <gregkh@suse.de>
7 * Copyright (c) 2007 Novell Inc.
9 * This file is released under the GPLv2
13 #include <linux/device.h>
14 #include <linux/module.h>
15 #include <linux/errno.h>
16 #include <linux/init.h>
17 #include <linux/string.h>
19 #include "power/power.h"
21 #define to_bus_attr(_attr) container_of(_attr, struct bus_attribute, attr)
22 #define to_bus(obj) container_of(obj, struct bus_type_private, subsys.kobj)
25 * sysfs bindings for drivers
28 #define to_drv_attr(_attr) container_of(_attr, struct driver_attribute, attr)
31 static int __must_check
bus_rescan_devices_helper(struct device
*dev
,
34 static struct bus_type
*bus_get(struct bus_type
*bus
)
37 kset_get(&bus
->p
->subsys
);
43 static void bus_put(struct bus_type
*bus
)
46 kset_put(&bus
->p
->subsys
);
50 drv_attr_show(struct kobject
* kobj
, struct attribute
* attr
, char * buf
)
52 struct driver_attribute
* drv_attr
= to_drv_attr(attr
);
53 struct driver_private
*drv_priv
= to_driver(kobj
);
57 ret
= drv_attr
->show(drv_priv
->driver
, buf
);
62 drv_attr_store(struct kobject
* kobj
, struct attribute
* attr
,
63 const char * buf
, size_t count
)
65 struct driver_attribute
* drv_attr
= to_drv_attr(attr
);
66 struct driver_private
*drv_priv
= to_driver(kobj
);
70 ret
= drv_attr
->store(drv_priv
->driver
, buf
, count
);
74 static struct sysfs_ops driver_sysfs_ops
= {
75 .show
= drv_attr_show
,
76 .store
= drv_attr_store
,
79 static void driver_release(struct kobject
*kobj
)
81 struct driver_private
*drv_priv
= to_driver(kobj
);
83 pr_debug("driver: '%s': %s\n", kobject_name(kobj
), __FUNCTION__
);
87 static struct kobj_type driver_ktype
= {
88 .sysfs_ops
= &driver_sysfs_ops
,
89 .release
= driver_release
,
94 * sysfs bindings for buses
99 bus_attr_show(struct kobject
* kobj
, struct attribute
* attr
, char * buf
)
101 struct bus_attribute
* bus_attr
= to_bus_attr(attr
);
102 struct bus_type_private
*bus_priv
= to_bus(kobj
);
106 ret
= bus_attr
->show(bus_priv
->bus
, buf
);
111 bus_attr_store(struct kobject
* kobj
, struct attribute
* attr
,
112 const char * buf
, size_t count
)
114 struct bus_attribute
* bus_attr
= to_bus_attr(attr
);
115 struct bus_type_private
*bus_priv
= to_bus(kobj
);
119 ret
= bus_attr
->store(bus_priv
->bus
, buf
, count
);
123 static struct sysfs_ops bus_sysfs_ops
= {
124 .show
= bus_attr_show
,
125 .store
= bus_attr_store
,
128 int bus_create_file(struct bus_type
* bus
, struct bus_attribute
* attr
)
132 error
= sysfs_create_file(&bus
->p
->subsys
.kobj
, &attr
->attr
);
139 void bus_remove_file(struct bus_type
* bus
, struct bus_attribute
* attr
)
142 sysfs_remove_file(&bus
->p
->subsys
.kobj
, &attr
->attr
);
147 static struct kobj_type bus_ktype
= {
148 .sysfs_ops
= &bus_sysfs_ops
,
151 static int bus_uevent_filter(struct kset
*kset
, struct kobject
*kobj
)
153 struct kobj_type
*ktype
= get_ktype(kobj
);
155 if (ktype
== &bus_ktype
)
160 static struct kset_uevent_ops bus_uevent_ops
= {
161 .filter
= bus_uevent_filter
,
164 static struct kset
*bus_kset
;
167 #ifdef CONFIG_HOTPLUG
168 /* Manually detach a device from its associated driver. */
169 static int driver_helper(struct device
*dev
, void *data
)
171 const char *name
= data
;
173 if (strcmp(name
, dev
->bus_id
) == 0)
178 static ssize_t
driver_unbind(struct device_driver
*drv
,
179 const char *buf
, size_t count
)
181 struct bus_type
*bus
= bus_get(drv
->bus
);
185 dev
= bus_find_device(bus
, NULL
, (void *)buf
, driver_helper
);
186 if (dev
&& dev
->driver
== drv
) {
187 if (dev
->parent
) /* Needed for USB */
188 down(&dev
->parent
->sem
);
189 device_release_driver(dev
);
191 up(&dev
->parent
->sem
);
198 static DRIVER_ATTR(unbind
, S_IWUSR
, NULL
, driver_unbind
);
201 * Manually attach a device to a driver.
202 * Note: the driver must want to bind to the device,
203 * it is not possible to override the driver's id table.
205 static ssize_t
driver_bind(struct device_driver
*drv
,
206 const char *buf
, size_t count
)
208 struct bus_type
*bus
= bus_get(drv
->bus
);
212 dev
= bus_find_device(bus
, NULL
, (void *)buf
, driver_helper
);
213 if (dev
&& dev
->driver
== NULL
) {
214 if (dev
->parent
) /* Needed for USB */
215 down(&dev
->parent
->sem
);
217 err
= driver_probe_device(drv
, dev
);
220 up(&dev
->parent
->sem
);
222 if (err
> 0) /* success */
224 else if (err
== 0) /* driver didn't accept device */
231 static DRIVER_ATTR(bind
, S_IWUSR
, NULL
, driver_bind
);
233 static ssize_t
show_drivers_autoprobe(struct bus_type
*bus
, char *buf
)
235 return sprintf(buf
, "%d\n", bus
->p
->drivers_autoprobe
);
238 static ssize_t
store_drivers_autoprobe(struct bus_type
*bus
,
239 const char *buf
, size_t count
)
242 bus
->p
->drivers_autoprobe
= 0;
244 bus
->p
->drivers_autoprobe
= 1;
248 static ssize_t
store_drivers_probe(struct bus_type
*bus
,
249 const char *buf
, size_t count
)
253 dev
= bus_find_device(bus
, NULL
, (void *)buf
, driver_helper
);
256 if (bus_rescan_devices_helper(dev
, NULL
) != 0)
262 static struct device
* next_device(struct klist_iter
* i
)
264 struct klist_node
* n
= klist_next(i
);
265 return n
? container_of(n
, struct device
, knode_bus
) : NULL
;
269 * bus_for_each_dev - device iterator.
271 * @start: device to start iterating from.
272 * @data: data for the callback.
273 * @fn: function to be called for each device.
275 * Iterate over @bus's list of devices, and call @fn for each,
276 * passing it @data. If @start is not NULL, we use that device to
277 * begin iterating from.
279 * We check the return of @fn each time. If it returns anything
280 * other than 0, we break out and return that value.
282 * NOTE: The device that returns a non-zero value is not retained
283 * in any way, nor is its refcount incremented. If the caller needs
284 * to retain this data, it should do, and increment the reference
285 * count in the supplied callback.
288 int bus_for_each_dev(struct bus_type
* bus
, struct device
* start
,
289 void * data
, int (*fn
)(struct device
*, void *))
298 klist_iter_init_node(&bus
->p
->klist_devices
, &i
,
299 (start
? &start
->knode_bus
: NULL
));
300 while ((dev
= next_device(&i
)) && !error
)
301 error
= fn(dev
, data
);
307 * bus_find_device - device iterator for locating a particular device.
309 * @start: Device to begin with
310 * @data: Data to pass to match function
311 * @match: Callback function to check device
313 * This is similar to the bus_for_each_dev() function above, but it
314 * returns a reference to a device that is 'found' for later use, as
315 * determined by the @match callback.
317 * The callback should return 0 if the device doesn't match and non-zero
318 * if it does. If the callback returns non-zero, this function will
319 * return to the caller and not iterate over any more devices.
321 struct device
* bus_find_device(struct bus_type
*bus
,
322 struct device
*start
, void *data
,
323 int (*match
)(struct device
*, void *))
331 klist_iter_init_node(&bus
->p
->klist_devices
, &i
,
332 (start
? &start
->knode_bus
: NULL
));
333 while ((dev
= next_device(&i
)))
334 if (match(dev
, data
) && get_device(dev
))
341 static struct device_driver
* next_driver(struct klist_iter
* i
)
343 struct klist_node
* n
= klist_next(i
);
344 struct driver_private
*drv_priv
;
347 drv_priv
= container_of(n
, struct driver_private
, knode_bus
);
348 return drv_priv
->driver
;
354 * bus_for_each_drv - driver iterator
355 * @bus: bus we're dealing with.
356 * @start: driver to start iterating on.
357 * @data: data to pass to the callback.
358 * @fn: function to call for each driver.
360 * This is nearly identical to the device iterator above.
361 * We iterate over each driver that belongs to @bus, and call
362 * @fn for each. If @fn returns anything but 0, we break out
363 * and return it. If @start is not NULL, we use it as the head
366 * NOTE: we don't return the driver that returns a non-zero
367 * value, nor do we leave the reference count incremented for that
368 * driver. If the caller needs to know that info, it must set it
369 * in the callback. It must also be sure to increment the refcount
370 * so it doesn't disappear before returning to the caller.
373 int bus_for_each_drv(struct bus_type
* bus
, struct device_driver
* start
,
374 void * data
, int (*fn
)(struct device_driver
*, void *))
377 struct device_driver
* drv
;
383 klist_iter_init_node(&bus
->p
->klist_drivers
, &i
,
384 start
? &start
->p
->knode_bus
: NULL
);
385 while ((drv
= next_driver(&i
)) && !error
)
386 error
= fn(drv
, data
);
391 static int device_add_attrs(struct bus_type
*bus
, struct device
*dev
)
399 for (i
= 0; attr_name(bus
->dev_attrs
[i
]); i
++) {
400 error
= device_create_file(dev
,&bus
->dev_attrs
[i
]);
403 device_remove_file(dev
, &bus
->dev_attrs
[i
]);
410 static void device_remove_attrs(struct bus_type
* bus
, struct device
* dev
)
414 if (bus
->dev_attrs
) {
415 for (i
= 0; attr_name(bus
->dev_attrs
[i
]); i
++)
416 device_remove_file(dev
,&bus
->dev_attrs
[i
]);
420 #ifdef CONFIG_SYSFS_DEPRECATED
421 static int make_deprecated_bus_links(struct device
*dev
)
423 return sysfs_create_link(&dev
->kobj
,
424 &dev
->bus
->p
->subsys
.kobj
, "bus");
427 static void remove_deprecated_bus_links(struct device
*dev
)
429 sysfs_remove_link(&dev
->kobj
, "bus");
432 static inline int make_deprecated_bus_links(struct device
*dev
) { return 0; }
433 static inline void remove_deprecated_bus_links(struct device
*dev
) { }
437 * bus_add_device - add device to bus
438 * @dev: device being added
440 * - Add the device to its bus's list of devices.
441 * - Create link to device's bus.
443 int bus_add_device(struct device
* dev
)
445 struct bus_type
* bus
= bus_get(dev
->bus
);
449 pr_debug("bus: '%s': add device %s\n", bus
->name
, dev
->bus_id
);
450 error
= device_add_attrs(bus
, dev
);
453 error
= sysfs_create_link(&bus
->p
->devices_kset
->kobj
,
454 &dev
->kobj
, dev
->bus_id
);
457 error
= sysfs_create_link(&dev
->kobj
,
458 &dev
->bus
->p
->subsys
.kobj
, "subsystem");
461 error
= make_deprecated_bus_links(dev
);
468 sysfs_remove_link(&dev
->kobj
, "subsystem");
470 sysfs_remove_link(&bus
->p
->devices_kset
->kobj
, dev
->bus_id
);
472 device_remove_attrs(bus
, dev
);
479 * bus_attach_device - add device to bus
480 * @dev: device tried to attach to a driver
482 * - Add device to bus's list of devices.
483 * - Try to attach to driver.
485 void bus_attach_device(struct device
* dev
)
487 struct bus_type
*bus
= dev
->bus
;
491 dev
->is_registered
= 1;
492 if (bus
->p
->drivers_autoprobe
)
493 ret
= device_attach(dev
);
496 klist_add_tail(&dev
->knode_bus
, &bus
->p
->klist_devices
);
498 dev
->is_registered
= 0;
503 * bus_remove_device - remove device from bus
504 * @dev: device to be removed
506 * - Remove symlink from bus's directory.
507 * - Delete device from bus's list.
508 * - Detach from its driver.
509 * - Drop reference taken in bus_add_device().
511 void bus_remove_device(struct device
* dev
)
514 sysfs_remove_link(&dev
->kobj
, "subsystem");
515 remove_deprecated_bus_links(dev
);
516 sysfs_remove_link(&dev
->bus
->p
->devices_kset
->kobj
, dev
->bus_id
);
517 device_remove_attrs(dev
->bus
, dev
);
518 if (dev
->is_registered
) {
519 dev
->is_registered
= 0;
520 klist_del(&dev
->knode_bus
);
522 pr_debug("bus: '%s': remove device %s\n", dev
->bus
->name
, dev
->bus_id
);
523 device_release_driver(dev
);
528 static int driver_add_attrs(struct bus_type
* bus
, struct device_driver
* drv
)
533 if (bus
->drv_attrs
) {
534 for (i
= 0; attr_name(bus
->drv_attrs
[i
]); i
++) {
535 error
= driver_create_file(drv
, &bus
->drv_attrs
[i
]);
544 driver_remove_file(drv
, &bus
->drv_attrs
[i
]);
549 static void driver_remove_attrs(struct bus_type
* bus
, struct device_driver
* drv
)
553 if (bus
->drv_attrs
) {
554 for (i
= 0; attr_name(bus
->drv_attrs
[i
]); i
++)
555 driver_remove_file(drv
, &bus
->drv_attrs
[i
]);
559 #ifdef CONFIG_HOTPLUG
561 * Thanks to drivers making their tables __devinit, we can't allow manual
562 * bind and unbind from userspace unless CONFIG_HOTPLUG is enabled.
564 static int __must_check
add_bind_files(struct device_driver
*drv
)
568 ret
= driver_create_file(drv
, &driver_attr_unbind
);
570 ret
= driver_create_file(drv
, &driver_attr_bind
);
572 driver_remove_file(drv
, &driver_attr_unbind
);
577 static void remove_bind_files(struct device_driver
*drv
)
579 driver_remove_file(drv
, &driver_attr_bind
);
580 driver_remove_file(drv
, &driver_attr_unbind
);
583 static BUS_ATTR(drivers_probe
, S_IWUSR
, NULL
, store_drivers_probe
);
584 static BUS_ATTR(drivers_autoprobe
, S_IWUSR
| S_IRUGO
,
585 show_drivers_autoprobe
, store_drivers_autoprobe
);
587 static int add_probe_files(struct bus_type
*bus
)
591 retval
= bus_create_file(bus
, &bus_attr_drivers_probe
);
595 retval
= bus_create_file(bus
, &bus_attr_drivers_autoprobe
);
597 bus_remove_file(bus
, &bus_attr_drivers_probe
);
602 static void remove_probe_files(struct bus_type
*bus
)
604 bus_remove_file(bus
, &bus_attr_drivers_autoprobe
);
605 bus_remove_file(bus
, &bus_attr_drivers_probe
);
608 static inline int add_bind_files(struct device_driver
*drv
) { return 0; }
609 static inline void remove_bind_files(struct device_driver
*drv
) {}
610 static inline int add_probe_files(struct bus_type
*bus
) { return 0; }
611 static inline void remove_probe_files(struct bus_type
*bus
) {}
614 static ssize_t
driver_uevent_store(struct device_driver
*drv
,
615 const char *buf
, size_t count
)
617 enum kobject_action action
;
619 if (kobject_action_type(buf
, count
, &action
) == 0)
620 kobject_uevent(&drv
->p
->kobj
, action
);
623 static DRIVER_ATTR(uevent
, S_IWUSR
, NULL
, driver_uevent_store
);
626 * bus_add_driver - Add a driver to the bus.
630 int bus_add_driver(struct device_driver
*drv
)
632 struct bus_type
*bus
;
633 struct driver_private
*priv
;
636 bus
= bus_get(drv
->bus
);
640 pr_debug("bus: '%s': add driver %s\n", bus
->name
, drv
->name
);
642 priv
= kzalloc(sizeof(*priv
), GFP_KERNEL
);
646 klist_init(&priv
->klist_devices
, NULL
, NULL
);
649 priv
->kobj
.kset
= bus
->p
->drivers_kset
;
650 error
= kobject_init_and_add(&priv
->kobj
, &driver_ktype
, NULL
,
655 if (drv
->bus
->p
->drivers_autoprobe
) {
656 error
= driver_attach(drv
);
660 klist_add_tail(&priv
->knode_bus
, &bus
->p
->klist_drivers
);
661 module_add_driver(drv
->owner
, drv
);
663 error
= driver_create_file(drv
, &driver_attr_uevent
);
665 printk(KERN_ERR
"%s: uevent attr (%s) failed\n",
666 __FUNCTION__
, drv
->name
);
668 error
= driver_add_attrs(bus
, drv
);
670 /* How the hell do we get out of this pickle? Give up */
671 printk(KERN_ERR
"%s: driver_add_attrs(%s) failed\n",
672 __FUNCTION__
, drv
->name
);
674 error
= add_bind_files(drv
);
677 printk(KERN_ERR
"%s: add_bind_files(%s) failed\n",
678 __FUNCTION__
, drv
->name
);
681 kobject_uevent(&priv
->kobj
, KOBJ_ADD
);
684 kobject_put(&priv
->kobj
);
691 * bus_remove_driver - delete driver from bus's knowledge.
694 * Detach the driver from the devices it controls, and remove
695 * it from its bus's list of drivers. Finally, we drop the reference
696 * to the bus we took in bus_add_driver().
699 void bus_remove_driver(struct device_driver
* drv
)
704 remove_bind_files(drv
);
705 driver_remove_attrs(drv
->bus
, drv
);
706 driver_remove_file(drv
, &driver_attr_uevent
);
707 klist_remove(&drv
->p
->knode_bus
);
708 pr_debug("bus: '%s': remove driver %s\n", drv
->bus
->name
, drv
->name
);
710 module_remove_driver(drv
);
711 kobject_put(&drv
->p
->kobj
);
716 /* Helper for bus_rescan_devices's iter */
717 static int __must_check
bus_rescan_devices_helper(struct device
*dev
,
723 if (dev
->parent
) /* Needed for USB */
724 down(&dev
->parent
->sem
);
725 ret
= device_attach(dev
);
727 up(&dev
->parent
->sem
);
729 return ret
< 0 ? ret
: 0;
733 * bus_rescan_devices - rescan devices on the bus for possible drivers
734 * @bus: the bus to scan.
736 * This function will look for devices on the bus with no driver
737 * attached and rescan it against existing drivers to see if it matches
738 * any by calling device_attach() for the unbound devices.
740 int bus_rescan_devices(struct bus_type
* bus
)
742 return bus_for_each_dev(bus
, NULL
, NULL
, bus_rescan_devices_helper
);
746 * device_reprobe - remove driver for a device and probe for a new driver
747 * @dev: the device to reprobe
749 * This function detaches the attached driver (if any) for the given
750 * device and restarts the driver probing process. It is intended
751 * to use if probing criteria changed during a devices lifetime and
752 * driver attachment should change accordingly.
754 int device_reprobe(struct device
*dev
)
757 if (dev
->parent
) /* Needed for USB */
758 down(&dev
->parent
->sem
);
759 device_release_driver(dev
);
761 up(&dev
->parent
->sem
);
763 return bus_rescan_devices_helper(dev
, NULL
);
765 EXPORT_SYMBOL_GPL(device_reprobe
);
768 * find_bus - locate bus by name.
769 * @name: name of bus.
771 * Call kset_find_obj() to iterate over list of buses to
772 * find a bus by name. Return bus if found.
774 * Note that kset_find_obj increments bus' reference count.
777 struct bus_type
* find_bus(char * name
)
779 struct kobject
* k
= kset_find_obj(bus_kset
, name
);
780 return k
? to_bus(k
) : NULL
;
786 * bus_add_attrs - Add default attributes for this bus.
787 * @bus: Bus that has just been registered.
790 static int bus_add_attrs(struct bus_type
* bus
)
795 if (bus
->bus_attrs
) {
796 for (i
= 0; attr_name(bus
->bus_attrs
[i
]); i
++) {
797 error
= bus_create_file(bus
,&bus
->bus_attrs
[i
]);
806 bus_remove_file(bus
,&bus
->bus_attrs
[i
]);
810 static void bus_remove_attrs(struct bus_type
* bus
)
814 if (bus
->bus_attrs
) {
815 for (i
= 0; attr_name(bus
->bus_attrs
[i
]); i
++)
816 bus_remove_file(bus
,&bus
->bus_attrs
[i
]);
820 static void klist_devices_get(struct klist_node
*n
)
822 struct device
*dev
= container_of(n
, struct device
, knode_bus
);
827 static void klist_devices_put(struct klist_node
*n
)
829 struct device
*dev
= container_of(n
, struct device
, knode_bus
);
834 static ssize_t
bus_uevent_store(struct bus_type
*bus
,
835 const char *buf
, size_t count
)
837 enum kobject_action action
;
839 if (kobject_action_type(buf
, count
, &action
) == 0)
840 kobject_uevent(&bus
->p
->subsys
.kobj
, action
);
843 static BUS_ATTR(uevent
, S_IWUSR
, NULL
, bus_uevent_store
);
846 * bus_register - register a bus with the system.
849 * Once we have that, we registered the bus with the kobject
850 * infrastructure, then register the children subsystems it has:
851 * the devices and drivers that belong to the bus.
853 int bus_register(struct bus_type
* bus
)
856 struct bus_type_private
*priv
;
858 priv
= kzalloc(sizeof(struct bus_type_private
), GFP_KERNEL
);
865 BLOCKING_INIT_NOTIFIER_HEAD(&priv
->bus_notifier
);
867 retval
= kobject_set_name(&priv
->subsys
.kobj
, "%s", bus
->name
);
871 priv
->subsys
.kobj
.kset
= bus_kset
;
872 priv
->subsys
.kobj
.ktype
= &bus_ktype
;
873 priv
->drivers_autoprobe
= 1;
875 retval
= kset_register(&priv
->subsys
);
879 retval
= bus_create_file(bus
, &bus_attr_uevent
);
881 goto bus_uevent_fail
;
883 priv
->devices_kset
= kset_create_and_add("devices", NULL
,
885 if (!priv
->devices_kset
) {
887 goto bus_devices_fail
;
890 priv
->drivers_kset
= kset_create_and_add("drivers", NULL
,
892 if (!priv
->drivers_kset
) {
894 goto bus_drivers_fail
;
897 klist_init(&priv
->klist_devices
, klist_devices_get
, klist_devices_put
);
898 klist_init(&priv
->klist_drivers
, NULL
, NULL
);
900 retval
= add_probe_files(bus
);
902 goto bus_probe_files_fail
;
904 retval
= bus_add_attrs(bus
);
908 pr_debug("bus: '%s': registered\n", bus
->name
);
912 remove_probe_files(bus
);
913 bus_probe_files_fail
:
914 kset_unregister(bus
->p
->drivers_kset
);
916 kset_unregister(bus
->p
->devices_kset
);
918 bus_remove_file(bus
, &bus_attr_uevent
);
920 kset_unregister(&bus
->p
->subsys
);
927 * bus_unregister - remove a bus from the system
930 * Unregister the child subsystems and the bus itself.
931 * Finally, we call bus_put() to release the refcount
933 void bus_unregister(struct bus_type
* bus
)
935 pr_debug("bus: '%s': unregistering\n", bus
->name
);
936 bus_remove_attrs(bus
);
937 remove_probe_files(bus
);
938 kset_unregister(bus
->p
->drivers_kset
);
939 kset_unregister(bus
->p
->devices_kset
);
940 bus_remove_file(bus
, &bus_attr_uevent
);
941 kset_unregister(&bus
->p
->subsys
);
945 int bus_register_notifier(struct bus_type
*bus
, struct notifier_block
*nb
)
947 return blocking_notifier_chain_register(&bus
->p
->bus_notifier
, nb
);
949 EXPORT_SYMBOL_GPL(bus_register_notifier
);
951 int bus_unregister_notifier(struct bus_type
*bus
, struct notifier_block
*nb
)
953 return blocking_notifier_chain_unregister(&bus
->p
->bus_notifier
, nb
);
955 EXPORT_SYMBOL_GPL(bus_unregister_notifier
);
957 struct kset
*bus_get_kset(struct bus_type
*bus
)
959 return &bus
->p
->subsys
;
961 EXPORT_SYMBOL_GPL(bus_get_kset
);
963 struct klist
*bus_get_device_klist(struct bus_type
*bus
)
965 return &bus
->p
->klist_devices
;
967 EXPORT_SYMBOL_GPL(bus_get_device_klist
);
969 int __init
buses_init(void)
971 bus_kset
= kset_create_and_add("bus", &bus_uevent_ops
, NULL
);
978 EXPORT_SYMBOL_GPL(bus_for_each_dev
);
979 EXPORT_SYMBOL_GPL(bus_find_device
);
980 EXPORT_SYMBOL_GPL(bus_for_each_drv
);
982 EXPORT_SYMBOL_GPL(bus_register
);
983 EXPORT_SYMBOL_GPL(bus_unregister
);
984 EXPORT_SYMBOL_GPL(bus_rescan_devices
);
986 EXPORT_SYMBOL_GPL(bus_create_file
);
987 EXPORT_SYMBOL_GPL(bus_remove_file
);