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_dev(node) container_of(node, struct device, bus_list)
21 #define to_drv(node) container_of(node, struct device_driver, kobj.entry)
23 #define to_bus_attr(_attr) container_of(_attr, struct bus_attribute, attr)
24 #define to_bus(obj) container_of(obj, struct bus_type, subsys.kset.kobj)
27 * sysfs bindings for drivers
30 #define to_drv_attr(_attr) container_of(_attr, struct driver_attribute, attr)
31 #define to_driver(obj) container_of(obj, struct device_driver, kobj)
35 drv_attr_show(struct kobject
* kobj
, struct attribute
* attr
, char * buf
)
37 struct driver_attribute
* drv_attr
= to_drv_attr(attr
);
38 struct device_driver
* drv
= to_driver(kobj
);
42 ret
= drv_attr
->show(drv
, buf
);
47 drv_attr_store(struct kobject
* kobj
, struct attribute
* attr
,
48 const char * buf
, size_t count
)
50 struct driver_attribute
* drv_attr
= to_drv_attr(attr
);
51 struct device_driver
* drv
= to_driver(kobj
);
55 ret
= drv_attr
->store(drv
, buf
, count
);
59 static struct sysfs_ops driver_sysfs_ops
= {
60 .show
= drv_attr_show
,
61 .store
= drv_attr_store
,
65 static void driver_release(struct kobject
* kobj
)
67 struct device_driver
* drv
= to_driver(kobj
);
71 static struct kobj_type ktype_driver
= {
72 .sysfs_ops
= &driver_sysfs_ops
,
73 .release
= driver_release
,
78 * sysfs bindings for buses
83 bus_attr_show(struct kobject
* kobj
, struct attribute
* attr
, char * buf
)
85 struct bus_attribute
* bus_attr
= to_bus_attr(attr
);
86 struct bus_type
* bus
= to_bus(kobj
);
90 ret
= bus_attr
->show(bus
, buf
);
95 bus_attr_store(struct kobject
* kobj
, struct attribute
* attr
,
96 const char * buf
, size_t count
)
98 struct bus_attribute
* bus_attr
= to_bus_attr(attr
);
99 struct bus_type
* bus
= to_bus(kobj
);
103 ret
= bus_attr
->store(bus
, buf
, count
);
107 static struct sysfs_ops bus_sysfs_ops
= {
108 .show
= bus_attr_show
,
109 .store
= bus_attr_store
,
112 int bus_create_file(struct bus_type
* bus
, struct bus_attribute
* attr
)
116 error
= sysfs_create_file(&bus
->subsys
.kset
.kobj
, &attr
->attr
);
123 void bus_remove_file(struct bus_type
* bus
, struct bus_attribute
* attr
)
126 sysfs_remove_file(&bus
->subsys
.kset
.kobj
, &attr
->attr
);
131 static struct kobj_type ktype_bus
= {
132 .sysfs_ops
= &bus_sysfs_ops
,
136 decl_subsys(bus
, &ktype_bus
, NULL
);
139 * bus_for_each_dev - device iterator.
141 * @start: device to start iterating from.
142 * @data: data for the callback.
143 * @fn: function to be called for each device.
145 * Iterate over @bus's list of devices, and call @fn for each,
146 * passing it @data. If @start is not NULL, we use that device to
147 * begin iterating from.
149 * We check the return of @fn each time. If it returns anything
150 * other than 0, we break out and return that value.
152 * NOTE: The device that returns a non-zero value is not retained
153 * in any way, nor is its refcount incremented. If the caller needs
154 * to retain this data, it should do, and increment the reference
155 * count in the supplied callback.
157 int bus_for_each_dev(struct bus_type
* bus
, struct device
* start
,
158 void * data
, int (*fn
)(struct device
*, void *))
161 struct list_head
* head
;
164 if (!(bus
= get_bus(bus
)))
167 head
= &bus
->devices
.list
;
168 dev
= list_prepare_entry(start
, head
, bus_list
);
170 down_read(&bus
->subsys
.rwsem
);
171 list_for_each_entry_continue(dev
, head
, bus_list
) {
173 error
= fn(dev
, data
);
178 up_read(&bus
->subsys
.rwsem
);
184 * bus_for_each_drv - driver iterator
185 * @bus: bus we're dealing with.
186 * @start: driver to start iterating on.
187 * @data: data to pass to the callback.
188 * @fn: function to call for each driver.
190 * This is nearly identical to the device iterator above.
191 * We iterate over each driver that belongs to @bus, and call
192 * @fn for each. If @fn returns anything but 0, we break out
193 * and return it. If @start is not NULL, we use it as the head
196 * NOTE: we don't return the driver that returns a non-zero
197 * value, nor do we leave the reference count incremented for that
198 * driver. If the caller needs to know that info, it must set it
199 * in the callback. It must also be sure to increment the refcount
200 * so it doesn't disappear before returning to the caller.
203 int bus_for_each_drv(struct bus_type
* bus
, struct device_driver
* start
,
204 void * data
, int (*fn
)(struct device_driver
*, void *))
206 struct list_head
* head
;
207 struct device_driver
*drv
;
210 if(!(bus
= get_bus(bus
)))
213 head
= &bus
->drivers
.list
;
214 drv
= list_prepare_entry(start
, head
, kobj
.entry
);
216 down_read(&bus
->subsys
.rwsem
);
217 list_for_each_entry_continue(drv
, head
, kobj
.entry
) {
219 error
= fn(drv
, data
);
224 up_read(&bus
->subsys
.rwsem
);
230 * device_bind_driver - bind a driver to one device.
233 * Allow manual attachment of a driver to a deivce.
234 * Caller must have already set @dev->driver.
236 * Note that this does not modify the bus reference count
237 * nor take the bus's rwsem. Please verify those are accounted
238 * for before calling this. (It is ok to call with no other effort
239 * from a driver's probe() method.)
242 void device_bind_driver(struct device
* dev
)
244 pr_debug("bound device '%s' to driver '%s'\n",
245 dev
->bus_id
, dev
->driver
->name
);
246 list_add_tail(&dev
->driver_list
, &dev
->driver
->devices
);
247 sysfs_create_link(&dev
->driver
->kobj
, &dev
->kobj
,
248 kobject_name(&dev
->kobj
));
253 * bus_match - check compatibility between device & driver.
257 * First, we call the bus's match function, which should compare
258 * the device IDs the driver supports with the device IDs of the
259 * device. Note we don't do this ourselves because we don't know
260 * the format of the ID structures, nor what is to be considered
261 * a match and what is not.
263 * If we find a match, we call @drv->probe(@dev) if it exists, and
264 * call attach() above.
266 static int bus_match(struct device
* dev
, struct device_driver
* drv
)
269 if (dev
->bus
->match(dev
, drv
)) {
272 if ((error
= drv
->probe(dev
))) {
277 device_bind_driver(dev
);
285 * device_attach - try to attach device to a driver.
288 * Walk the list of drivers that the bus has and call bus_match()
289 * for each pair. If a compatible pair is found, break out and return.
291 static int device_attach(struct device
* dev
)
293 struct bus_type
* bus
= dev
->bus
;
294 struct list_head
* entry
;
298 device_bind_driver(dev
);
303 list_for_each(entry
, &bus
->drivers
.list
) {
304 struct device_driver
* drv
= to_drv(entry
);
305 error
= bus_match(dev
, drv
);
307 /* success, driver matched */
309 if (error
!= -ENODEV
)
310 /* driver matched but the probe failed */
312 "%s: probe of %s failed with error %d\n",
313 drv
->name
, dev
->bus_id
, error
);
322 * driver_attach - try to bind driver to devices.
325 * Walk the list of devices that the bus has on it and try to match
326 * the driver with each one.
327 * If bus_match() returns 0 and the @dev->driver is set, we've found
330 * Note that we ignore the -ENODEV error from bus_match(), since it's
331 * perfectly valid for a driver not to bind to any devices.
333 void driver_attach(struct device_driver
* drv
)
335 struct bus_type
* bus
= drv
->bus
;
336 struct list_head
* entry
;
342 list_for_each(entry
, &bus
->devices
.list
) {
343 struct device
* dev
= container_of(entry
, struct device
, bus_list
);
345 error
= bus_match(dev
, drv
);
346 if (error
&& (error
!= -ENODEV
))
347 /* driver matched but the probe failed */
349 "%s: probe of %s failed with error %d\n",
350 drv
->name
, dev
->bus_id
, error
);
357 * device_release_driver - manually detach device from driver.
360 * Manually detach device from driver.
361 * Note that this is called without incrementing the bus
362 * reference count nor taking the bus's rwsem. Be sure that
363 * those are accounted for before calling this function.
366 void device_release_driver(struct device
* dev
)
368 struct device_driver
* drv
= dev
->driver
;
370 sysfs_remove_link(&drv
->kobj
, kobject_name(&dev
->kobj
));
371 list_del_init(&dev
->driver_list
);
372 device_detach_shutdown(dev
);
381 * driver_detach - detach driver from all devices it controls.
385 static void driver_detach(struct device_driver
* drv
)
387 struct list_head
* entry
, * next
;
388 list_for_each_safe(entry
, next
, &drv
->devices
) {
389 struct device
* dev
= container_of(entry
, struct device
, driver_list
);
390 device_release_driver(dev
);
394 static int device_add_attrs(struct bus_type
* bus
, struct device
* dev
)
399 if (bus
->dev_attrs
) {
400 for (i
= 0; attr_name(bus
->dev_attrs
[i
]); i
++) {
401 error
= device_create_file(dev
,&bus
->dev_attrs
[i
]);
410 device_remove_file(dev
,&bus
->dev_attrs
[i
]);
415 static void device_remove_attrs(struct bus_type
* bus
, struct device
* dev
)
419 if (bus
->dev_attrs
) {
420 for (i
= 0; attr_name(bus
->dev_attrs
[i
]); i
++)
421 device_remove_file(dev
,&bus
->dev_attrs
[i
]);
427 * bus_add_device - add device to bus
428 * @dev: device being added
430 * - Add the device to its bus's list of devices.
431 * - Try to attach to driver.
432 * - Create link to device's physical location.
434 int bus_add_device(struct device
* dev
)
436 struct bus_type
* bus
= get_bus(dev
->bus
);
440 down_write(&dev
->bus
->subsys
.rwsem
);
441 pr_debug("bus %s: add device %s\n", bus
->name
, dev
->bus_id
);
442 list_add_tail(&dev
->bus_list
, &dev
->bus
->devices
.list
);
444 up_write(&dev
->bus
->subsys
.rwsem
);
445 device_add_attrs(bus
, dev
);
446 sysfs_create_link(&bus
->devices
.kobj
, &dev
->kobj
, dev
->bus_id
);
452 * bus_remove_device - remove device from bus
453 * @dev: device to be removed
455 * - Remove symlink from bus's directory.
456 * - Delete device from bus's list.
457 * - Detach from its driver.
458 * - Drop reference taken in bus_add_device().
460 void bus_remove_device(struct device
* dev
)
463 sysfs_remove_link(&dev
->bus
->devices
.kobj
, dev
->bus_id
);
464 device_remove_attrs(dev
->bus
, dev
);
465 down_write(&dev
->bus
->subsys
.rwsem
);
466 pr_debug("bus %s: remove device %s\n", dev
->bus
->name
, dev
->bus_id
);
467 device_release_driver(dev
);
468 list_del_init(&dev
->bus_list
);
469 up_write(&dev
->bus
->subsys
.rwsem
);
474 static int driver_add_attrs(struct bus_type
* bus
, struct device_driver
* drv
)
479 if (bus
->drv_attrs
) {
480 for (i
= 0; attr_name(bus
->drv_attrs
[i
]); i
++) {
481 error
= driver_create_file(drv
, &bus
->drv_attrs
[i
]);
490 driver_remove_file(drv
, &bus
->drv_attrs
[i
]);
495 static void driver_remove_attrs(struct bus_type
* bus
, struct device_driver
* drv
)
499 if (bus
->drv_attrs
) {
500 for (i
= 0; attr_name(bus
->drv_attrs
[i
]); i
++)
501 driver_remove_file(drv
, &bus
->drv_attrs
[i
]);
507 * bus_add_driver - Add a driver to the bus.
511 int bus_add_driver(struct device_driver
* drv
)
513 struct bus_type
* bus
= get_bus(drv
->bus
);
517 pr_debug("bus %s: add driver %s\n", bus
->name
, drv
->name
);
518 error
= kobject_set_name(&drv
->kobj
, drv
->name
);
523 drv
->kobj
.kset
= &bus
->drivers
;
524 if ((error
= kobject_register(&drv
->kobj
))) {
529 down_write(&bus
->subsys
.rwsem
);
531 up_write(&bus
->subsys
.rwsem
);
533 driver_add_attrs(bus
, drv
);
540 * bus_remove_driver - delete driver from bus's knowledge.
543 * Detach the driver from the devices it controls, and remove
544 * it from its bus's list of drivers. Finally, we drop the reference
545 * to the bus we took in bus_add_driver().
548 void bus_remove_driver(struct device_driver
* drv
)
551 driver_remove_attrs(drv
->bus
, drv
);
552 down_write(&drv
->bus
->subsys
.rwsem
);
553 pr_debug("bus %s: remove driver %s\n", drv
->bus
->name
, drv
->name
);
555 up_write(&drv
->bus
->subsys
.rwsem
);
556 kobject_unregister(&drv
->kobj
);
562 /* Helper for bus_rescan_devices's iter */
563 static int bus_rescan_devices_helper(struct device
*dev
, void *data
)
567 if (!dev
->driver
&& device_attach(dev
))
575 * bus_rescan_devices - rescan devices on the bus for possible drivers
576 * @bus: the bus to scan.
578 * This function will look for devices on the bus with no driver
579 * attached and rescan it against existing drivers to see if it
580 * matches any. Calls device_attach(). Returns the number of devices
581 * that were sucessfully bound to a driver.
583 int bus_rescan_devices(struct bus_type
* bus
)
587 bus_for_each_dev(bus
, NULL
, &count
, bus_rescan_devices_helper
);
593 struct bus_type
* get_bus(struct bus_type
* bus
)
595 return bus
? container_of(subsys_get(&bus
->subsys
), struct bus_type
, subsys
) : NULL
;
598 void put_bus(struct bus_type
* bus
)
600 subsys_put(&bus
->subsys
);
605 * find_bus - locate bus by name.
606 * @name: name of bus.
608 * Call kset_find_obj() to iterate over list of buses to
609 * find a bus by name. Return bus if found.
611 * Note that kset_find_obj increments bus' reference count.
614 struct bus_type
* find_bus(char * name
)
616 struct kobject
* k
= kset_find_obj(&bus_subsys
.kset
, name
);
617 return k
? to_bus(k
) : NULL
;
622 * bus_add_attrs - Add default attributes for this bus.
623 * @bus: Bus that has just been registered.
626 static int bus_add_attrs(struct bus_type
* bus
)
631 if (bus
->bus_attrs
) {
632 for (i
= 0; attr_name(bus
->bus_attrs
[i
]); i
++) {
633 if ((error
= bus_create_file(bus
,&bus
->bus_attrs
[i
])))
641 bus_remove_file(bus
,&bus
->bus_attrs
[i
]);
645 static void bus_remove_attrs(struct bus_type
* bus
)
649 if (bus
->bus_attrs
) {
650 for (i
= 0; attr_name(bus
->bus_attrs
[i
]); i
++)
651 bus_remove_file(bus
,&bus
->bus_attrs
[i
]);
656 * bus_register - register a bus with the system.
659 * Once we have that, we registered the bus with the kobject
660 * infrastructure, then register the children subsystems it has:
661 * the devices and drivers that belong to the bus.
663 int bus_register(struct bus_type
* bus
)
667 retval
= kobject_set_name(&bus
->subsys
.kset
.kobj
, bus
->name
);
671 subsys_set_kset(bus
, bus_subsys
);
672 retval
= subsystem_register(&bus
->subsys
);
676 kobject_set_name(&bus
->devices
.kobj
, "devices");
677 bus
->devices
.subsys
= &bus
->subsys
;
678 retval
= kset_register(&bus
->devices
);
680 goto bus_devices_fail
;
682 kobject_set_name(&bus
->drivers
.kobj
, "drivers");
683 bus
->drivers
.subsys
= &bus
->subsys
;
684 bus
->drivers
.ktype
= &ktype_driver
;
685 retval
= kset_register(&bus
->drivers
);
687 goto bus_drivers_fail
;
690 pr_debug("bus type '%s' registered\n", bus
->name
);
694 kset_unregister(&bus
->devices
);
696 subsystem_unregister(&bus
->subsys
);
703 * bus_unregister - remove a bus from the system
706 * Unregister the child subsystems and the bus itself.
707 * Finally, we call put_bus() to release the refcount
709 void bus_unregister(struct bus_type
* bus
)
711 pr_debug("bus %s: unregistering\n", bus
->name
);
712 bus_remove_attrs(bus
);
713 kset_unregister(&bus
->drivers
);
714 kset_unregister(&bus
->devices
);
715 subsystem_unregister(&bus
->subsys
);
718 int __init
buses_init(void)
720 return subsystem_register(&bus_subsys
);
724 EXPORT_SYMBOL(bus_for_each_dev
);
725 EXPORT_SYMBOL(bus_for_each_drv
);
727 EXPORT_SYMBOL(device_bind_driver
);
728 EXPORT_SYMBOL(device_release_driver
);
730 EXPORT_SYMBOL(bus_add_device
);
731 EXPORT_SYMBOL(bus_remove_device
);
732 EXPORT_SYMBOL(bus_register
);
733 EXPORT_SYMBOL(bus_unregister
);
734 EXPORT_SYMBOL(bus_rescan_devices
);
735 EXPORT_SYMBOL(get_bus
);
736 EXPORT_SYMBOL(put_bus
);
737 EXPORT_SYMBOL(find_bus
);
739 EXPORT_SYMBOL(bus_create_file
);
740 EXPORT_SYMBOL(bus_remove_file
);