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);
396 * bus_add_device - add device to bus
397 * @dev: device being added
399 * - Add the device to its bus's list of devices.
400 * - Try to attach to driver.
401 * - Create link to device's physical location.
403 int bus_add_device(struct device * dev)
405 struct bus_type * bus = get_bus(dev->bus);
409 down_write(&dev->bus->subsys.rwsem);
410 pr_debug("bus %s: add device %s\n",bus->name,dev->bus_id);
411 list_add_tail(&dev->bus_list,&dev->bus->devices.list);
413 up_write(&dev->bus->subsys.rwsem);
414 sysfs_create_link(&bus->devices.kobj,&dev->kobj,dev->bus_id);
420 * bus_remove_device - remove device from bus
421 * @dev: device to be removed
423 * - Remove symlink from bus's directory.
424 * - Delete device from bus's list.
425 * - Detach from its driver.
426 * - Drop reference taken in bus_add_device().
428 void bus_remove_device(struct device * dev)
431 sysfs_remove_link(&dev->bus->devices.kobj,dev->bus_id);
432 down_write(&dev->bus->subsys.rwsem);
433 pr_debug("bus %s: remove device %s\n",dev->bus->name,dev->bus_id);
434 device_release_driver(dev);
435 list_del_init(&dev->bus_list);
436 up_write(&dev->bus->subsys.rwsem);
443 * bus_add_driver - Add a driver to the bus.
447 int bus_add_driver(struct device_driver * drv)
449 struct bus_type * bus = get_bus(drv->bus);
453 pr_debug("bus %s: add driver %s\n",bus->name,drv->name);
454 kobject_set_name(&drv->kobj,drv->name);
455 drv->kobj.kset = &bus->drivers;
456 if ((error = kobject_register(&drv->kobj))) {
461 down_write(&bus->subsys.rwsem);
463 up_write(&bus->subsys.rwsem);
471 * bus_remove_driver - delete driver from bus's knowledge.
474 * Detach the driver from the devices it controls, and remove
475 * it from its bus's list of drivers. Finally, we drop the reference
476 * to the bus we took in bus_add_driver().
479 void bus_remove_driver(struct device_driver * drv)
482 down_write(&drv->bus->subsys.rwsem);
483 pr_debug("bus %s: remove driver %s\n",drv->bus->name,drv->name);
485 up_write(&drv->bus->subsys.rwsem);
486 kobject_unregister(&drv->kobj);
492 /* Helper for bus_rescan_devices's iter */
493 static int bus_rescan_devices_helper(struct device *dev, void *data)
497 if (!dev->driver && device_attach(dev))
505 * bus_rescan_devices - rescan devices on the bus for possible drivers
506 * @bus: the bus to scan.
508 * This function will look for devices on the bus with no driver
509 * attached and rescan it against existing drivers to see if it
510 * matches any. Calls device_attach(). Returns the number of devices
511 * that were sucessfully bound to a driver.
513 int bus_rescan_devices(struct bus_type * bus)
517 bus_for_each_dev(bus, NULL, &count, bus_rescan_devices_helper);
523 struct bus_type * get_bus(struct bus_type * bus)
525 return bus ? container_of(subsys_get(&bus->subsys),struct bus_type,subsys) : NULL;
528 void put_bus(struct bus_type * bus)
530 subsys_put(&bus->subsys);
535 * find_bus - locate bus by name.
536 * @name: name of bus.
538 * Call kset_find_obj() to iterate over list of buses to
539 * find a bus by name. Return bus if found.
542 struct bus_type * find_bus(char * name)
544 struct kobject * k = kset_find_obj(&bus_subsys.kset,name);
545 return k ? to_bus(k) : NULL;
549 * bus_register - register a bus with the system.
552 * Once we have that, we registered the bus with the kobject
553 * infrastructure, then register the children subsystems it has:
554 * the devices and drivers that belong to the bus.
556 int bus_register(struct bus_type * bus)
558 kobject_set_name(&bus->subsys.kset.kobj,bus->name);
559 subsys_set_kset(bus,bus_subsys);
560 subsystem_register(&bus->subsys);
562 kobject_set_name(&bus->devices.kobj, "devices");
563 bus->devices.subsys = &bus->subsys;
564 kset_register(&bus->devices);
566 kobject_set_name(&bus->drivers.kobj, "drivers");
567 bus->drivers.subsys = &bus->subsys;
568 bus->drivers.ktype = &ktype_driver;
569 kset_register(&bus->drivers);
571 pr_debug("bus type '%s' registered\n",bus->name);
577 * bus_unregister - remove a bus from the system
580 * Unregister the child subsystems and the bus itself.
581 * Finally, we call put_bus() to release the refcount
583 void bus_unregister(struct bus_type * bus)
585 pr_debug("bus %s: unregistering\n",bus->name);
586 kset_unregister(&bus->drivers);
587 kset_unregister(&bus->devices);
588 subsystem_unregister(&bus->subsys);
591 int __init buses_init(void)
593 return subsystem_register(&bus_subsys);
597 EXPORT_SYMBOL(bus_for_each_dev);
598 EXPORT_SYMBOL(bus_for_each_drv);
600 EXPORT_SYMBOL(device_bind_driver);
601 EXPORT_SYMBOL(device_release_driver);
603 EXPORT_SYMBOL(bus_add_device);
604 EXPORT_SYMBOL(bus_remove_device);
605 EXPORT_SYMBOL(bus_register);
606 EXPORT_SYMBOL(bus_unregister);
607 EXPORT_SYMBOL(bus_rescan_devices);
608 EXPORT_SYMBOL(get_bus);
609 EXPORT_SYMBOL(put_bus);
610 EXPORT_SYMBOL(find_bus);
612 EXPORT_SYMBOL(bus_create_file);
613 EXPORT_SYMBOL(bus_remove_file);