2 * bus.c - bus driver management
4 * Copyright (c) 2002-3 Patrick Mochel
5 * Copyright (c) 2002-3 Open Source Development Labs
7 * This file is released under the GPLv2
11 #include <linux/config.h>
12 #include <linux/device.h>
13 #include <linux/module.h>
14 #include <linux/errno.h>
15 #include <linux/init.h>
16 #include <linux/string.h>
18 #include "power/power.h"
20 #define to_bus_attr(_attr) container_of(_attr, struct bus_attribute, attr)
21 #define to_bus(obj) container_of(obj, struct bus_type, subsys.kset.kobj)
24 * sysfs bindings for drivers
27 #define to_drv_attr(_attr) container_of(_attr, struct driver_attribute, attr)
28 #define to_driver(obj) container_of(obj, struct device_driver, kobj)
32 drv_attr_show(struct kobject
* kobj
, struct attribute
* attr
, char * buf
)
34 struct driver_attribute
* drv_attr
= to_drv_attr(attr
);
35 struct device_driver
* drv
= to_driver(kobj
);
39 ret
= drv_attr
->show(drv
, buf
);
44 drv_attr_store(struct kobject
* kobj
, struct attribute
* attr
,
45 const char * buf
, size_t count
)
47 struct driver_attribute
* drv_attr
= to_drv_attr(attr
);
48 struct device_driver
* drv
= to_driver(kobj
);
52 ret
= drv_attr
->store(drv
, buf
, count
);
56 static struct sysfs_ops driver_sysfs_ops
= {
57 .show
= drv_attr_show
,
58 .store
= drv_attr_store
,
62 static void driver_release(struct kobject
* kobj
)
64 struct device_driver
* drv
= to_driver(kobj
);
65 complete(&drv
->unloaded
);
68 static struct kobj_type ktype_driver
= {
69 .sysfs_ops
= &driver_sysfs_ops
,
70 .release
= driver_release
,
75 * sysfs bindings for buses
80 bus_attr_show(struct kobject
* kobj
, struct attribute
* attr
, char * buf
)
82 struct bus_attribute
* bus_attr
= to_bus_attr(attr
);
83 struct bus_type
* bus
= to_bus(kobj
);
87 ret
= bus_attr
->show(bus
, buf
);
92 bus_attr_store(struct kobject
* kobj
, struct attribute
* attr
,
93 const char * buf
, size_t count
)
95 struct bus_attribute
* bus_attr
= to_bus_attr(attr
);
96 struct bus_type
* bus
= to_bus(kobj
);
100 ret
= bus_attr
->store(bus
, buf
, count
);
104 static struct sysfs_ops bus_sysfs_ops
= {
105 .show
= bus_attr_show
,
106 .store
= bus_attr_store
,
109 int bus_create_file(struct bus_type
* bus
, struct bus_attribute
* attr
)
113 error
= sysfs_create_file(&bus
->subsys
.kset
.kobj
, &attr
->attr
);
120 void bus_remove_file(struct bus_type
* bus
, struct bus_attribute
* attr
)
123 sysfs_remove_file(&bus
->subsys
.kset
.kobj
, &attr
->attr
);
128 static struct kobj_type ktype_bus
= {
129 .sysfs_ops
= &bus_sysfs_ops
,
133 decl_subsys(bus
, &ktype_bus
, NULL
);
136 #ifdef CONFIG_HOTPLUG
138 /* Manually detach a device from its associated driver. */
139 static int driver_helper(struct device
*dev
, void *data
)
141 const char *name
= data
;
143 if (strcmp(name
, dev
->bus_id
) == 0)
148 static ssize_t
driver_unbind(struct device_driver
*drv
,
149 const char *buf
, size_t count
)
151 struct bus_type
*bus
= get_bus(drv
->bus
);
155 dev
= bus_find_device(bus
, NULL
, (void *)buf
, driver_helper
);
156 if (dev
&& dev
->driver
== drv
) {
157 if (dev
->parent
) /* Needed for USB */
158 down(&dev
->parent
->sem
);
159 device_release_driver(dev
);
161 up(&dev
->parent
->sem
);
168 static DRIVER_ATTR(unbind
, S_IWUSR
, NULL
, driver_unbind
);
171 * Manually attach a device to a driver.
172 * Note: the driver must want to bind to the device,
173 * it is not possible to override the driver's id table.
175 static ssize_t
driver_bind(struct device_driver
*drv
,
176 const char *buf
, size_t count
)
178 struct bus_type
*bus
= get_bus(drv
->bus
);
182 dev
= bus_find_device(bus
, NULL
, (void *)buf
, driver_helper
);
183 if (dev
&& dev
->driver
== NULL
) {
184 if (dev
->parent
) /* Needed for USB */
185 down(&dev
->parent
->sem
);
187 err
= driver_probe_device(drv
, dev
);
190 up(&dev
->parent
->sem
);
192 if (err
> 0) /* success */
194 else if (err
== 0) /* driver didn't accept device */
201 static DRIVER_ATTR(bind
, S_IWUSR
, NULL
, driver_bind
);
205 static struct device
* next_device(struct klist_iter
* i
)
207 struct klist_node
* n
= klist_next(i
);
208 return n
? container_of(n
, struct device
, knode_bus
) : NULL
;
212 * bus_for_each_dev - device iterator.
214 * @start: device to start iterating from.
215 * @data: data for the callback.
216 * @fn: function to be called for each device.
218 * Iterate over @bus's list of devices, and call @fn for each,
219 * passing it @data. If @start is not NULL, we use that device to
220 * begin iterating from.
222 * We check the return of @fn each time. If it returns anything
223 * other than 0, we break out and return that value.
225 * NOTE: The device that returns a non-zero value is not retained
226 * in any way, nor is its refcount incremented. If the caller needs
227 * to retain this data, it should do, and increment the reference
228 * count in the supplied callback.
231 int bus_for_each_dev(struct bus_type
* bus
, struct device
* start
,
232 void * data
, int (*fn
)(struct device
*, void *))
241 klist_iter_init_node(&bus
->klist_devices
, &i
,
242 (start
? &start
->knode_bus
: NULL
));
243 while ((dev
= next_device(&i
)) && !error
)
244 error
= fn(dev
, data
);
250 * bus_find_device - device iterator for locating a particular device.
252 * @start: Device to begin with
253 * @data: Data to pass to match function
254 * @match: Callback function to check device
256 * This is similar to the bus_for_each_dev() function above, but it
257 * returns a reference to a device that is 'found' for later use, as
258 * determined by the @match callback.
260 * The callback should return 0 if the device doesn't match and non-zero
261 * if it does. If the callback returns non-zero, this function will
262 * return to the caller and not iterate over any more devices.
264 struct device
* bus_find_device(struct bus_type
*bus
,
265 struct device
*start
, void *data
,
266 int (*match
)(struct device
*, void *))
274 klist_iter_init_node(&bus
->klist_devices
, &i
,
275 (start
? &start
->knode_bus
: NULL
));
276 while ((dev
= next_device(&i
)))
277 if (match(dev
, data
) && get_device(dev
))
284 static struct device_driver
* next_driver(struct klist_iter
* i
)
286 struct klist_node
* n
= klist_next(i
);
287 return n
? container_of(n
, struct device_driver
, knode_bus
) : NULL
;
291 * bus_for_each_drv - driver iterator
292 * @bus: bus we're dealing with.
293 * @start: driver to start iterating on.
294 * @data: data to pass to the callback.
295 * @fn: function to call for each driver.
297 * This is nearly identical to the device iterator above.
298 * We iterate over each driver that belongs to @bus, and call
299 * @fn for each. If @fn returns anything but 0, we break out
300 * and return it. If @start is not NULL, we use it as the head
303 * NOTE: we don't return the driver that returns a non-zero
304 * value, nor do we leave the reference count incremented for that
305 * driver. If the caller needs to know that info, it must set it
306 * in the callback. It must also be sure to increment the refcount
307 * so it doesn't disappear before returning to the caller.
310 int bus_for_each_drv(struct bus_type
* bus
, struct device_driver
* start
,
311 void * data
, int (*fn
)(struct device_driver
*, void *))
314 struct device_driver
* drv
;
320 klist_iter_init_node(&bus
->klist_drivers
, &i
,
321 start
? &start
->knode_bus
: NULL
);
322 while ((drv
= next_driver(&i
)) && !error
)
323 error
= fn(drv
, data
);
328 static int device_add_attrs(struct bus_type
* bus
, struct device
* dev
)
333 if (bus
->dev_attrs
) {
334 for (i
= 0; attr_name(bus
->dev_attrs
[i
]); i
++) {
335 error
= device_create_file(dev
,&bus
->dev_attrs
[i
]);
344 device_remove_file(dev
,&bus
->dev_attrs
[i
]);
349 static void device_remove_attrs(struct bus_type
* bus
, struct device
* dev
)
353 if (bus
->dev_attrs
) {
354 for (i
= 0; attr_name(bus
->dev_attrs
[i
]); i
++)
355 device_remove_file(dev
,&bus
->dev_attrs
[i
]);
361 * bus_add_device - add device to bus
362 * @dev: device being added
364 * - Add the device to its bus's list of devices.
365 * - Create link to device's bus.
367 int bus_add_device(struct device
* dev
)
369 struct bus_type
* bus
= get_bus(dev
->bus
);
373 pr_debug("bus %s: add device %s\n", bus
->name
, dev
->bus_id
);
374 error
= device_add_attrs(bus
, dev
);
376 sysfs_create_link(&bus
->devices
.kobj
, &dev
->kobj
, dev
->bus_id
);
377 sysfs_create_link(&dev
->kobj
, &dev
->bus
->subsys
.kset
.kobj
, "bus");
384 * bus_attach_device - add device to bus
385 * @dev: device tried to attach to a driver
387 * - Try to attach to driver.
389 void bus_attach_device(struct device
* dev
)
391 struct bus_type
* bus
= dev
->bus
;
395 klist_add_tail(&dev
->knode_bus
, &bus
->klist_devices
);
400 * bus_remove_device - remove device from bus
401 * @dev: device to be removed
403 * - Remove symlink from bus's directory.
404 * - Delete device from bus's list.
405 * - Detach from its driver.
406 * - Drop reference taken in bus_add_device().
408 void bus_remove_device(struct device
* dev
)
411 sysfs_remove_link(&dev
->kobj
, "bus");
412 sysfs_remove_link(&dev
->bus
->devices
.kobj
, dev
->bus_id
);
413 device_remove_attrs(dev
->bus
, dev
);
414 klist_remove(&dev
->knode_bus
);
415 pr_debug("bus %s: remove device %s\n", dev
->bus
->name
, dev
->bus_id
);
416 device_release_driver(dev
);
421 static int driver_add_attrs(struct bus_type
* bus
, struct device_driver
* drv
)
426 if (bus
->drv_attrs
) {
427 for (i
= 0; attr_name(bus
->drv_attrs
[i
]); i
++) {
428 error
= driver_create_file(drv
, &bus
->drv_attrs
[i
]);
437 driver_remove_file(drv
, &bus
->drv_attrs
[i
]);
442 static void driver_remove_attrs(struct bus_type
* bus
, struct device_driver
* drv
)
446 if (bus
->drv_attrs
) {
447 for (i
= 0; attr_name(bus
->drv_attrs
[i
]); i
++)
448 driver_remove_file(drv
, &bus
->drv_attrs
[i
]);
452 #ifdef CONFIG_HOTPLUG
454 * Thanks to drivers making their tables __devinit, we can't allow manual
455 * bind and unbind from userspace unless CONFIG_HOTPLUG is enabled.
457 static void add_bind_files(struct device_driver
*drv
)
459 driver_create_file(drv
, &driver_attr_unbind
);
460 driver_create_file(drv
, &driver_attr_bind
);
463 static void remove_bind_files(struct device_driver
*drv
)
465 driver_remove_file(drv
, &driver_attr_bind
);
466 driver_remove_file(drv
, &driver_attr_unbind
);
469 static inline void add_bind_files(struct device_driver
*drv
) {}
470 static inline void remove_bind_files(struct device_driver
*drv
) {}
474 * bus_add_driver - Add a driver to the bus.
478 int bus_add_driver(struct device_driver
* drv
)
480 struct bus_type
* bus
= get_bus(drv
->bus
);
484 pr_debug("bus %s: add driver %s\n", bus
->name
, drv
->name
);
485 error
= kobject_set_name(&drv
->kobj
, "%s", drv
->name
);
490 drv
->kobj
.kset
= &bus
->drivers
;
491 if ((error
= kobject_register(&drv
->kobj
))) {
497 klist_add_tail(&drv
->knode_bus
, &bus
->klist_drivers
);
498 module_add_driver(drv
->owner
, drv
);
500 driver_add_attrs(bus
, drv
);
508 * bus_remove_driver - delete driver from bus's knowledge.
511 * Detach the driver from the devices it controls, and remove
512 * it from its bus's list of drivers. Finally, we drop the reference
513 * to the bus we took in bus_add_driver().
516 void bus_remove_driver(struct device_driver
* drv
)
519 remove_bind_files(drv
);
520 driver_remove_attrs(drv
->bus
, drv
);
521 klist_remove(&drv
->knode_bus
);
522 pr_debug("bus %s: remove driver %s\n", drv
->bus
->name
, drv
->name
);
524 module_remove_driver(drv
);
525 kobject_unregister(&drv
->kobj
);
531 /* Helper for bus_rescan_devices's iter */
532 static int bus_rescan_devices_helper(struct device
*dev
, void *data
)
535 if (dev
->parent
) /* Needed for USB */
536 down(&dev
->parent
->sem
);
539 up(&dev
->parent
->sem
);
545 * bus_rescan_devices - rescan devices on the bus for possible drivers
546 * @bus: the bus to scan.
548 * This function will look for devices on the bus with no driver
549 * attached and rescan it against existing drivers to see if it matches
550 * any by calling device_attach() for the unbound devices.
552 void bus_rescan_devices(struct bus_type
* bus
)
554 bus_for_each_dev(bus
, NULL
, NULL
, bus_rescan_devices_helper
);
558 * device_reprobe - remove driver for a device and probe for a new driver
559 * @dev: the device to reprobe
561 * This function detaches the attached driver (if any) for the given
562 * device and restarts the driver probing process. It is intended
563 * to use if probing criteria changed during a devices lifetime and
564 * driver attachment should change accordingly.
566 void device_reprobe(struct device
*dev
)
569 if (dev
->parent
) /* Needed for USB */
570 down(&dev
->parent
->sem
);
571 device_release_driver(dev
);
573 up(&dev
->parent
->sem
);
576 bus_rescan_devices_helper(dev
, NULL
);
578 EXPORT_SYMBOL_GPL(device_reprobe
);
580 struct bus_type
* get_bus(struct bus_type
* bus
)
582 return bus
? container_of(subsys_get(&bus
->subsys
), struct bus_type
, subsys
) : NULL
;
585 void put_bus(struct bus_type
* bus
)
587 subsys_put(&bus
->subsys
);
592 * find_bus - locate bus by name.
593 * @name: name of bus.
595 * Call kset_find_obj() to iterate over list of buses to
596 * find a bus by name. Return bus if found.
598 * Note that kset_find_obj increments bus' reference count.
601 struct bus_type
* find_bus(char * name
)
603 struct kobject
* k
= kset_find_obj(&bus_subsys
.kset
, name
);
604 return k
? to_bus(k
) : NULL
;
609 * bus_add_attrs - Add default attributes for this bus.
610 * @bus: Bus that has just been registered.
613 static int bus_add_attrs(struct bus_type
* bus
)
618 if (bus
->bus_attrs
) {
619 for (i
= 0; attr_name(bus
->bus_attrs
[i
]); i
++) {
620 if ((error
= bus_create_file(bus
,&bus
->bus_attrs
[i
])))
628 bus_remove_file(bus
,&bus
->bus_attrs
[i
]);
632 static void bus_remove_attrs(struct bus_type
* bus
)
636 if (bus
->bus_attrs
) {
637 for (i
= 0; attr_name(bus
->bus_attrs
[i
]); i
++)
638 bus_remove_file(bus
,&bus
->bus_attrs
[i
]);
642 static void klist_devices_get(struct klist_node
*n
)
644 struct device
*dev
= container_of(n
, struct device
, knode_bus
);
649 static void klist_devices_put(struct klist_node
*n
)
651 struct device
*dev
= container_of(n
, struct device
, knode_bus
);
656 static void klist_drivers_get(struct klist_node
*n
)
658 struct device_driver
*drv
= container_of(n
, struct device_driver
,
664 static void klist_drivers_put(struct klist_node
*n
)
666 struct device_driver
*drv
= container_of(n
, struct device_driver
,
673 * bus_register - register a bus with the system.
676 * Once we have that, we registered the bus with the kobject
677 * infrastructure, then register the children subsystems it has:
678 * the devices and drivers that belong to the bus.
680 int bus_register(struct bus_type
* bus
)
684 retval
= kobject_set_name(&bus
->subsys
.kset
.kobj
, "%s", bus
->name
);
688 subsys_set_kset(bus
, bus_subsys
);
689 retval
= subsystem_register(&bus
->subsys
);
693 kobject_set_name(&bus
->devices
.kobj
, "devices");
694 bus
->devices
.subsys
= &bus
->subsys
;
695 retval
= kset_register(&bus
->devices
);
697 goto bus_devices_fail
;
699 kobject_set_name(&bus
->drivers
.kobj
, "drivers");
700 bus
->drivers
.subsys
= &bus
->subsys
;
701 bus
->drivers
.ktype
= &ktype_driver
;
702 retval
= kset_register(&bus
->drivers
);
704 goto bus_drivers_fail
;
706 klist_init(&bus
->klist_devices
, klist_devices_get
, klist_devices_put
);
707 klist_init(&bus
->klist_drivers
, klist_drivers_get
, klist_drivers_put
);
710 pr_debug("bus type '%s' registered\n", bus
->name
);
714 kset_unregister(&bus
->devices
);
716 subsystem_unregister(&bus
->subsys
);
723 * bus_unregister - remove a bus from the system
726 * Unregister the child subsystems and the bus itself.
727 * Finally, we call put_bus() to release the refcount
729 void bus_unregister(struct bus_type
* bus
)
731 pr_debug("bus %s: unregistering\n", bus
->name
);
732 bus_remove_attrs(bus
);
733 kset_unregister(&bus
->drivers
);
734 kset_unregister(&bus
->devices
);
735 subsystem_unregister(&bus
->subsys
);
738 int __init
buses_init(void)
740 return subsystem_register(&bus_subsys
);
744 EXPORT_SYMBOL_GPL(bus_for_each_dev
);
745 EXPORT_SYMBOL_GPL(bus_find_device
);
746 EXPORT_SYMBOL_GPL(bus_for_each_drv
);
748 EXPORT_SYMBOL_GPL(bus_add_device
);
749 EXPORT_SYMBOL_GPL(bus_attach_device
);
750 EXPORT_SYMBOL_GPL(bus_remove_device
);
751 EXPORT_SYMBOL_GPL(bus_register
);
752 EXPORT_SYMBOL_GPL(bus_unregister
);
753 EXPORT_SYMBOL_GPL(bus_rescan_devices
);
754 EXPORT_SYMBOL_GPL(get_bus
);
755 EXPORT_SYMBOL_GPL(put_bus
);
756 EXPORT_SYMBOL_GPL(find_bus
);
758 EXPORT_SYMBOL_GPL(bus_create_file
);
759 EXPORT_SYMBOL_GPL(bus_remove_file
);