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 /* Manually detach a device from its associated driver. */
137 static int driver_helper(struct device
*dev
, void *data
)
139 const char *name
= data
;
141 if (strcmp(name
, dev
->bus_id
) == 0)
146 static ssize_t
driver_unbind(struct device_driver
*drv
,
147 const char *buf
, size_t count
)
149 struct bus_type
*bus
= get_bus(drv
->bus
);
153 dev
= bus_find_device(bus
, NULL
, (void *)buf
, driver_helper
);
154 if (dev
&& dev
->driver
== drv
) {
155 if (dev
->parent
) /* Needed for USB */
156 down(&dev
->parent
->sem
);
157 device_release_driver(dev
);
159 up(&dev
->parent
->sem
);
166 static DRIVER_ATTR(unbind
, S_IWUSR
, NULL
, driver_unbind
);
169 * Manually attach a device to a driver.
170 * Note: the driver must want to bind to the device,
171 * it is not possible to override the driver's id table.
173 static ssize_t
driver_bind(struct device_driver
*drv
,
174 const char *buf
, size_t count
)
176 struct bus_type
*bus
= get_bus(drv
->bus
);
180 dev
= bus_find_device(bus
, NULL
, (void *)buf
, driver_helper
);
181 if (dev
&& dev
->driver
== NULL
) {
182 if (dev
->parent
) /* Needed for USB */
183 down(&dev
->parent
->sem
);
185 err
= driver_probe_device(drv
, dev
);
188 up(&dev
->parent
->sem
);
194 static DRIVER_ATTR(bind
, S_IWUSR
, NULL
, driver_bind
);
197 static struct device
* next_device(struct klist_iter
* i
)
199 struct klist_node
* n
= klist_next(i
);
200 return n
? container_of(n
, struct device
, knode_bus
) : NULL
;
204 * bus_for_each_dev - device iterator.
206 * @start: device to start iterating from.
207 * @data: data for the callback.
208 * @fn: function to be called for each device.
210 * Iterate over @bus's list of devices, and call @fn for each,
211 * passing it @data. If @start is not NULL, we use that device to
212 * begin iterating from.
214 * We check the return of @fn each time. If it returns anything
215 * other than 0, we break out and return that value.
217 * NOTE: The device that returns a non-zero value is not retained
218 * in any way, nor is its refcount incremented. If the caller needs
219 * to retain this data, it should do, and increment the reference
220 * count in the supplied callback.
223 int bus_for_each_dev(struct bus_type
* bus
, struct device
* start
,
224 void * data
, int (*fn
)(struct device
*, void *))
233 klist_iter_init_node(&bus
->klist_devices
, &i
,
234 (start
? &start
->knode_bus
: NULL
));
235 while ((dev
= next_device(&i
)) && !error
)
236 error
= fn(dev
, data
);
242 * bus_find_device - device iterator for locating a particular device.
244 * @start: Device to begin with
245 * @data: Data to pass to match function
246 * @match: Callback function to check device
248 * This is similar to the bus_for_each_dev() function above, but it
249 * returns a reference to a device that is 'found' for later use, as
250 * determined by the @match callback.
252 * The callback should return 0 if the device doesn't match and non-zero
253 * if it does. If the callback returns non-zero, this function will
254 * return to the caller and not iterate over any more devices.
256 struct device
* bus_find_device(struct bus_type
*bus
,
257 struct device
*start
, void *data
,
258 int (*match
)(struct device
*, void *))
266 klist_iter_init_node(&bus
->klist_devices
, &i
,
267 (start
? &start
->knode_bus
: NULL
));
268 while ((dev
= next_device(&i
)))
269 if (match(dev
, data
) && get_device(dev
))
276 static struct device_driver
* next_driver(struct klist_iter
* i
)
278 struct klist_node
* n
= klist_next(i
);
279 return n
? container_of(n
, struct device_driver
, knode_bus
) : NULL
;
283 * bus_for_each_drv - driver iterator
284 * @bus: bus we're dealing with.
285 * @start: driver to start iterating on.
286 * @data: data to pass to the callback.
287 * @fn: function to call for each driver.
289 * This is nearly identical to the device iterator above.
290 * We iterate over each driver that belongs to @bus, and call
291 * @fn for each. If @fn returns anything but 0, we break out
292 * and return it. If @start is not NULL, we use it as the head
295 * NOTE: we don't return the driver that returns a non-zero
296 * value, nor do we leave the reference count incremented for that
297 * driver. If the caller needs to know that info, it must set it
298 * in the callback. It must also be sure to increment the refcount
299 * so it doesn't disappear before returning to the caller.
302 int bus_for_each_drv(struct bus_type
* bus
, struct device_driver
* start
,
303 void * data
, int (*fn
)(struct device_driver
*, void *))
306 struct device_driver
* drv
;
312 klist_iter_init_node(&bus
->klist_drivers
, &i
,
313 start
? &start
->knode_bus
: NULL
);
314 while ((drv
= next_driver(&i
)) && !error
)
315 error
= fn(drv
, data
);
320 static int device_add_attrs(struct bus_type
* bus
, struct device
* dev
)
325 if (bus
->dev_attrs
) {
326 for (i
= 0; attr_name(bus
->dev_attrs
[i
]); i
++) {
327 error
= device_create_file(dev
,&bus
->dev_attrs
[i
]);
336 device_remove_file(dev
,&bus
->dev_attrs
[i
]);
341 static void device_remove_attrs(struct bus_type
* bus
, struct device
* dev
)
345 if (bus
->dev_attrs
) {
346 for (i
= 0; attr_name(bus
->dev_attrs
[i
]); i
++)
347 device_remove_file(dev
,&bus
->dev_attrs
[i
]);
353 * bus_add_device - add device to bus
354 * @dev: device being added
356 * - Add the device to its bus's list of devices.
357 * - Try to attach to driver.
358 * - Create link to device's physical location.
360 int bus_add_device(struct device
* dev
)
362 struct bus_type
* bus
= get_bus(dev
->bus
);
366 pr_debug("bus %s: add device %s\n", bus
->name
, dev
->bus_id
);
368 klist_add_tail(&dev
->knode_bus
, &bus
->klist_devices
);
369 error
= device_add_attrs(bus
, dev
);
371 sysfs_create_link(&bus
->devices
.kobj
, &dev
->kobj
, dev
->bus_id
);
372 sysfs_create_link(&dev
->kobj
, &dev
->bus
->subsys
.kset
.kobj
, "bus");
379 * bus_remove_device - remove device from bus
380 * @dev: device to be removed
382 * - Remove symlink from bus's directory.
383 * - Delete device from bus's list.
384 * - Detach from its driver.
385 * - Drop reference taken in bus_add_device().
387 void bus_remove_device(struct device
* dev
)
390 sysfs_remove_link(&dev
->kobj
, "bus");
391 sysfs_remove_link(&dev
->bus
->devices
.kobj
, dev
->bus_id
);
392 device_remove_attrs(dev
->bus
, dev
);
393 klist_remove(&dev
->knode_bus
);
394 pr_debug("bus %s: remove device %s\n", dev
->bus
->name
, dev
->bus_id
);
395 device_release_driver(dev
);
400 static int driver_add_attrs(struct bus_type
* bus
, struct device_driver
* drv
)
405 if (bus
->drv_attrs
) {
406 for (i
= 0; attr_name(bus
->drv_attrs
[i
]); i
++) {
407 error
= driver_create_file(drv
, &bus
->drv_attrs
[i
]);
416 driver_remove_file(drv
, &bus
->drv_attrs
[i
]);
421 static void driver_remove_attrs(struct bus_type
* bus
, struct device_driver
* drv
)
425 if (bus
->drv_attrs
) {
426 for (i
= 0; attr_name(bus
->drv_attrs
[i
]); i
++)
427 driver_remove_file(drv
, &bus
->drv_attrs
[i
]);
431 #ifdef CONFIG_HOTPLUG
433 * Thanks to drivers making their tables __devinit, we can't allow manual
434 * bind and unbind from userspace unless CONFIG_HOTPLUG is enabled.
436 static void add_bind_files(struct device_driver
*drv
)
438 driver_create_file(drv
, &driver_attr_unbind
);
439 driver_create_file(drv
, &driver_attr_bind
);
442 static void remove_bind_files(struct device_driver
*drv
)
444 driver_remove_file(drv
, &driver_attr_bind
);
445 driver_remove_file(drv
, &driver_attr_unbind
);
448 static inline void add_bind_files(struct device_driver
*drv
) {}
449 static inline void remove_bind_files(struct device_driver
*drv
) {}
453 * bus_add_driver - Add a driver to the bus.
457 int bus_add_driver(struct device_driver
* drv
)
459 struct bus_type
* bus
= get_bus(drv
->bus
);
463 pr_debug("bus %s: add driver %s\n", bus
->name
, drv
->name
);
464 error
= kobject_set_name(&drv
->kobj
, "%s", drv
->name
);
469 drv
->kobj
.kset
= &bus
->drivers
;
470 if ((error
= kobject_register(&drv
->kobj
))) {
476 klist_add_tail(&drv
->knode_bus
, &bus
->klist_drivers
);
477 module_add_driver(drv
->owner
, drv
);
479 driver_add_attrs(bus
, drv
);
487 * bus_remove_driver - delete driver from bus's knowledge.
490 * Detach the driver from the devices it controls, and remove
491 * it from its bus's list of drivers. Finally, we drop the reference
492 * to the bus we took in bus_add_driver().
495 void bus_remove_driver(struct device_driver
* drv
)
498 remove_bind_files(drv
);
499 driver_remove_attrs(drv
->bus
, drv
);
500 klist_remove(&drv
->knode_bus
);
501 pr_debug("bus %s: remove driver %s\n", drv
->bus
->name
, drv
->name
);
503 module_remove_driver(drv
);
504 kobject_unregister(&drv
->kobj
);
510 /* Helper for bus_rescan_devices's iter */
511 static int bus_rescan_devices_helper(struct device
*dev
, void *data
)
514 if (dev
->parent
) /* Needed for USB */
515 down(&dev
->parent
->sem
);
518 up(&dev
->parent
->sem
);
524 * bus_rescan_devices - rescan devices on the bus for possible drivers
525 * @bus: the bus to scan.
527 * This function will look for devices on the bus with no driver
528 * attached and rescan it against existing drivers to see if it matches
529 * any by calling device_attach() for the unbound devices.
531 void bus_rescan_devices(struct bus_type
* bus
)
533 bus_for_each_dev(bus
, NULL
, NULL
, bus_rescan_devices_helper
);
537 struct bus_type
* get_bus(struct bus_type
* bus
)
539 return bus
? container_of(subsys_get(&bus
->subsys
), struct bus_type
, subsys
) : NULL
;
542 void put_bus(struct bus_type
* bus
)
544 subsys_put(&bus
->subsys
);
549 * find_bus - locate bus by name.
550 * @name: name of bus.
552 * Call kset_find_obj() to iterate over list of buses to
553 * find a bus by name. Return bus if found.
555 * Note that kset_find_obj increments bus' reference count.
558 struct bus_type
* find_bus(char * name
)
560 struct kobject
* k
= kset_find_obj(&bus_subsys
.kset
, name
);
561 return k
? to_bus(k
) : NULL
;
566 * bus_add_attrs - Add default attributes for this bus.
567 * @bus: Bus that has just been registered.
570 static int bus_add_attrs(struct bus_type
* bus
)
575 if (bus
->bus_attrs
) {
576 for (i
= 0; attr_name(bus
->bus_attrs
[i
]); i
++) {
577 if ((error
= bus_create_file(bus
,&bus
->bus_attrs
[i
])))
585 bus_remove_file(bus
,&bus
->bus_attrs
[i
]);
589 static void bus_remove_attrs(struct bus_type
* bus
)
593 if (bus
->bus_attrs
) {
594 for (i
= 0; attr_name(bus
->bus_attrs
[i
]); i
++)
595 bus_remove_file(bus
,&bus
->bus_attrs
[i
]);
599 static void klist_devices_get(struct klist_node
*n
)
601 struct device
*dev
= container_of(n
, struct device
, knode_bus
);
606 static void klist_devices_put(struct klist_node
*n
)
608 struct device
*dev
= container_of(n
, struct device
, knode_bus
);
613 static void klist_drivers_get(struct klist_node
*n
)
615 struct device_driver
*drv
= container_of(n
, struct device_driver
,
621 static void klist_drivers_put(struct klist_node
*n
)
623 struct device_driver
*drv
= container_of(n
, struct device_driver
,
630 * bus_register - register a bus with the system.
633 * Once we have that, we registered the bus with the kobject
634 * infrastructure, then register the children subsystems it has:
635 * the devices and drivers that belong to the bus.
637 int bus_register(struct bus_type
* bus
)
641 retval
= kobject_set_name(&bus
->subsys
.kset
.kobj
, "%s", bus
->name
);
645 subsys_set_kset(bus
, bus_subsys
);
646 retval
= subsystem_register(&bus
->subsys
);
650 kobject_set_name(&bus
->devices
.kobj
, "devices");
651 bus
->devices
.subsys
= &bus
->subsys
;
652 retval
= kset_register(&bus
->devices
);
654 goto bus_devices_fail
;
656 kobject_set_name(&bus
->drivers
.kobj
, "drivers");
657 bus
->drivers
.subsys
= &bus
->subsys
;
658 bus
->drivers
.ktype
= &ktype_driver
;
659 retval
= kset_register(&bus
->drivers
);
661 goto bus_drivers_fail
;
663 klist_init(&bus
->klist_devices
, klist_devices_get
, klist_devices_put
);
664 klist_init(&bus
->klist_drivers
, klist_drivers_get
, klist_drivers_put
);
667 pr_debug("bus type '%s' registered\n", bus
->name
);
671 kset_unregister(&bus
->devices
);
673 subsystem_unregister(&bus
->subsys
);
680 * bus_unregister - remove a bus from the system
683 * Unregister the child subsystems and the bus itself.
684 * Finally, we call put_bus() to release the refcount
686 void bus_unregister(struct bus_type
* bus
)
688 pr_debug("bus %s: unregistering\n", bus
->name
);
689 bus_remove_attrs(bus
);
690 kset_unregister(&bus
->drivers
);
691 kset_unregister(&bus
->devices
);
692 subsystem_unregister(&bus
->subsys
);
695 int __init
buses_init(void)
697 return subsystem_register(&bus_subsys
);
701 EXPORT_SYMBOL_GPL(bus_for_each_dev
);
702 EXPORT_SYMBOL_GPL(bus_find_device
);
703 EXPORT_SYMBOL_GPL(bus_for_each_drv
);
705 EXPORT_SYMBOL_GPL(bus_add_device
);
706 EXPORT_SYMBOL_GPL(bus_remove_device
);
707 EXPORT_SYMBOL_GPL(bus_register
);
708 EXPORT_SYMBOL_GPL(bus_unregister
);
709 EXPORT_SYMBOL_GPL(bus_rescan_devices
);
710 EXPORT_SYMBOL_GPL(get_bus
);
711 EXPORT_SYMBOL_GPL(put_bus
);
712 EXPORT_SYMBOL_GPL(find_bus
);
714 EXPORT_SYMBOL_GPL(bus_create_file
);
715 EXPORT_SYMBOL_GPL(bus_remove_file
);