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 it's 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
);
155 (dev
->driver
== drv
)) {
156 device_release_driver(dev
);
161 static DRIVER_ATTR(unbind
, S_IWUSR
, NULL
, driver_unbind
);
164 * Manually attach a device to a driver.
165 * Note: the driver must want to bind to the device,
166 * it is not possible to override the driver's id table.
168 static ssize_t
driver_bind(struct device_driver
*drv
,
169 const char *buf
, size_t count
)
171 struct bus_type
*bus
= get_bus(drv
->bus
);
175 dev
= bus_find_device(bus
, NULL
, (void *)buf
, driver_helper
);
177 (dev
->driver
== NULL
)) {
179 err
= driver_probe_device(drv
, dev
);
187 static DRIVER_ATTR(bind
, S_IWUSR
, NULL
, driver_bind
);
190 static struct device
* next_device(struct klist_iter
* i
)
192 struct klist_node
* n
= klist_next(i
);
193 return n
? container_of(n
, struct device
, knode_bus
) : NULL
;
197 * bus_for_each_dev - device iterator.
199 * @start: device to start iterating from.
200 * @data: data for the callback.
201 * @fn: function to be called for each device.
203 * Iterate over @bus's list of devices, and call @fn for each,
204 * passing it @data. If @start is not NULL, we use that device to
205 * begin iterating from.
207 * We check the return of @fn each time. If it returns anything
208 * other than 0, we break out and return that value.
210 * NOTE: The device that returns a non-zero value is not retained
211 * in any way, nor is its refcount incremented. If the caller needs
212 * to retain this data, it should do, and increment the reference
213 * count in the supplied callback.
216 int bus_for_each_dev(struct bus_type
* bus
, struct device
* start
,
217 void * data
, int (*fn
)(struct device
*, void *))
226 klist_iter_init_node(&bus
->klist_devices
, &i
,
227 (start
? &start
->knode_bus
: NULL
));
228 while ((dev
= next_device(&i
)) && !error
)
229 error
= fn(dev
, data
);
235 * bus_find_device - device iterator for locating a particular device.
237 * @start: Device to begin with
238 * @data: Data to pass to match function
239 * @match: Callback function to check device
241 * This is similar to the bus_for_each_dev() function above, but it
242 * returns a reference to a device that is 'found' for later use, as
243 * determined by the @match callback.
245 * The callback should return 0 if the device doesn't match and non-zero
246 * if it does. If the callback returns non-zero, this function will
247 * return to the caller and not iterate over any more devices.
249 struct device
* bus_find_device(struct bus_type
*bus
,
250 struct device
*start
, void *data
,
251 int (*match
)(struct device
*, void *))
259 klist_iter_init_node(&bus
->klist_devices
, &i
,
260 (start
? &start
->knode_bus
: NULL
));
261 while ((dev
= next_device(&i
)))
262 if (match(dev
, data
) && get_device(dev
))
269 static struct device_driver
* next_driver(struct klist_iter
* i
)
271 struct klist_node
* n
= klist_next(i
);
272 return n
? container_of(n
, struct device_driver
, knode_bus
) : NULL
;
276 * bus_for_each_drv - driver iterator
277 * @bus: bus we're dealing with.
278 * @start: driver to start iterating on.
279 * @data: data to pass to the callback.
280 * @fn: function to call for each driver.
282 * This is nearly identical to the device iterator above.
283 * We iterate over each driver that belongs to @bus, and call
284 * @fn for each. If @fn returns anything but 0, we break out
285 * and return it. If @start is not NULL, we use it as the head
288 * NOTE: we don't return the driver that returns a non-zero
289 * value, nor do we leave the reference count incremented for that
290 * driver. If the caller needs to know that info, it must set it
291 * in the callback. It must also be sure to increment the refcount
292 * so it doesn't disappear before returning to the caller.
295 int bus_for_each_drv(struct bus_type
* bus
, struct device_driver
* start
,
296 void * data
, int (*fn
)(struct device_driver
*, void *))
299 struct device_driver
* drv
;
305 klist_iter_init_node(&bus
->klist_drivers
, &i
,
306 start
? &start
->knode_bus
: NULL
);
307 while ((drv
= next_driver(&i
)) && !error
)
308 error
= fn(drv
, data
);
313 static int device_add_attrs(struct bus_type
* bus
, struct device
* dev
)
318 if (bus
->dev_attrs
) {
319 for (i
= 0; attr_name(bus
->dev_attrs
[i
]); i
++) {
320 error
= device_create_file(dev
,&bus
->dev_attrs
[i
]);
329 device_remove_file(dev
,&bus
->dev_attrs
[i
]);
334 static void device_remove_attrs(struct bus_type
* bus
, struct device
* dev
)
338 if (bus
->dev_attrs
) {
339 for (i
= 0; attr_name(bus
->dev_attrs
[i
]); i
++)
340 device_remove_file(dev
,&bus
->dev_attrs
[i
]);
346 * bus_add_device - add device to bus
347 * @dev: device being added
349 * - Add the device to its bus's list of devices.
350 * - Try to attach to driver.
351 * - Create link to device's physical location.
353 int bus_add_device(struct device
* dev
)
355 struct bus_type
* bus
= get_bus(dev
->bus
);
359 pr_debug("bus %s: add device %s\n", bus
->name
, dev
->bus_id
);
361 klist_add_tail(&bus
->klist_devices
, &dev
->knode_bus
);
362 error
= device_add_attrs(bus
, dev
);
364 sysfs_create_link(&bus
->devices
.kobj
, &dev
->kobj
, dev
->bus_id
);
365 sysfs_create_link(&dev
->kobj
, &dev
->bus
->subsys
.kset
.kobj
, "bus");
372 * bus_remove_device - remove device from bus
373 * @dev: device to be removed
375 * - Remove symlink from bus's directory.
376 * - Delete device from bus's list.
377 * - Detach from its driver.
378 * - Drop reference taken in bus_add_device().
380 void bus_remove_device(struct device
* dev
)
383 sysfs_remove_link(&dev
->kobj
, "bus");
384 sysfs_remove_link(&dev
->bus
->devices
.kobj
, dev
->bus_id
);
385 device_remove_attrs(dev
->bus
, dev
);
386 klist_remove(&dev
->knode_bus
);
387 pr_debug("bus %s: remove device %s\n", dev
->bus
->name
, dev
->bus_id
);
388 device_release_driver(dev
);
393 static int driver_add_attrs(struct bus_type
* bus
, struct device_driver
* drv
)
398 if (bus
->drv_attrs
) {
399 for (i
= 0; attr_name(bus
->drv_attrs
[i
]); i
++) {
400 error
= driver_create_file(drv
, &bus
->drv_attrs
[i
]);
409 driver_remove_file(drv
, &bus
->drv_attrs
[i
]);
414 static void driver_remove_attrs(struct bus_type
* bus
, struct device_driver
* drv
)
418 if (bus
->drv_attrs
) {
419 for (i
= 0; attr_name(bus
->drv_attrs
[i
]); i
++)
420 driver_remove_file(drv
, &bus
->drv_attrs
[i
]);
426 * bus_add_driver - Add a driver to the bus.
430 int bus_add_driver(struct device_driver
* drv
)
432 struct bus_type
* bus
= get_bus(drv
->bus
);
436 pr_debug("bus %s: add driver %s\n", bus
->name
, drv
->name
);
437 error
= kobject_set_name(&drv
->kobj
, "%s", drv
->name
);
442 drv
->kobj
.kset
= &bus
->drivers
;
443 if ((error
= kobject_register(&drv
->kobj
))) {
449 klist_add_tail(&bus
->klist_drivers
, &drv
->knode_bus
);
450 module_add_driver(drv
->owner
, drv
);
452 driver_add_attrs(bus
, drv
);
453 driver_create_file(drv
, &driver_attr_unbind
);
454 driver_create_file(drv
, &driver_attr_bind
);
461 * bus_remove_driver - delete driver from bus's knowledge.
464 * Detach the driver from the devices it controls, and remove
465 * it from its bus's list of drivers. Finally, we drop the reference
466 * to the bus we took in bus_add_driver().
469 void bus_remove_driver(struct device_driver
* drv
)
472 driver_remove_file(drv
, &driver_attr_bind
);
473 driver_remove_file(drv
, &driver_attr_unbind
);
474 driver_remove_attrs(drv
->bus
, drv
);
475 klist_remove(&drv
->knode_bus
);
476 pr_debug("bus %s: remove driver %s\n", drv
->bus
->name
, drv
->name
);
478 module_remove_driver(drv
);
479 kobject_unregister(&drv
->kobj
);
485 /* Helper for bus_rescan_devices's iter */
486 static int bus_rescan_devices_helper(struct device
*dev
, void *data
)
494 * bus_rescan_devices - rescan devices on the bus for possible drivers
495 * @bus: the bus to scan.
497 * This function will look for devices on the bus with no driver
498 * attached and rescan it against existing drivers to see if it matches
499 * any by calling device_attach() for the unbound devices.
501 void bus_rescan_devices(struct bus_type
* bus
)
503 bus_for_each_dev(bus
, NULL
, NULL
, bus_rescan_devices_helper
);
507 struct bus_type
* get_bus(struct bus_type
* bus
)
509 return bus
? container_of(subsys_get(&bus
->subsys
), struct bus_type
, subsys
) : NULL
;
512 void put_bus(struct bus_type
* bus
)
514 subsys_put(&bus
->subsys
);
519 * find_bus - locate bus by name.
520 * @name: name of bus.
522 * Call kset_find_obj() to iterate over list of buses to
523 * find a bus by name. Return bus if found.
525 * Note that kset_find_obj increments bus' reference count.
528 struct bus_type
* find_bus(char * name
)
530 struct kobject
* k
= kset_find_obj(&bus_subsys
.kset
, name
);
531 return k
? to_bus(k
) : NULL
;
536 * bus_add_attrs - Add default attributes for this bus.
537 * @bus: Bus that has just been registered.
540 static int bus_add_attrs(struct bus_type
* bus
)
545 if (bus
->bus_attrs
) {
546 for (i
= 0; attr_name(bus
->bus_attrs
[i
]); i
++) {
547 if ((error
= bus_create_file(bus
,&bus
->bus_attrs
[i
])))
555 bus_remove_file(bus
,&bus
->bus_attrs
[i
]);
559 static void bus_remove_attrs(struct bus_type
* bus
)
563 if (bus
->bus_attrs
) {
564 for (i
= 0; attr_name(bus
->bus_attrs
[i
]); i
++)
565 bus_remove_file(bus
,&bus
->bus_attrs
[i
]);
570 * bus_register - register a bus with the system.
573 * Once we have that, we registered the bus with the kobject
574 * infrastructure, then register the children subsystems it has:
575 * the devices and drivers that belong to the bus.
577 int bus_register(struct bus_type
* bus
)
581 retval
= kobject_set_name(&bus
->subsys
.kset
.kobj
, "%s", bus
->name
);
585 subsys_set_kset(bus
, bus_subsys
);
586 retval
= subsystem_register(&bus
->subsys
);
590 kobject_set_name(&bus
->devices
.kobj
, "devices");
591 bus
->devices
.subsys
= &bus
->subsys
;
592 retval
= kset_register(&bus
->devices
);
594 goto bus_devices_fail
;
596 kobject_set_name(&bus
->drivers
.kobj
, "drivers");
597 bus
->drivers
.subsys
= &bus
->subsys
;
598 bus
->drivers
.ktype
= &ktype_driver
;
599 retval
= kset_register(&bus
->drivers
);
601 goto bus_drivers_fail
;
603 klist_init(&bus
->klist_devices
);
604 klist_init(&bus
->klist_drivers
);
607 pr_debug("bus type '%s' registered\n", bus
->name
);
611 kset_unregister(&bus
->devices
);
613 subsystem_unregister(&bus
->subsys
);
620 * bus_unregister - remove a bus from the system
623 * Unregister the child subsystems and the bus itself.
624 * Finally, we call put_bus() to release the refcount
626 void bus_unregister(struct bus_type
* bus
)
628 pr_debug("bus %s: unregistering\n", bus
->name
);
629 bus_remove_attrs(bus
);
630 kset_unregister(&bus
->drivers
);
631 kset_unregister(&bus
->devices
);
632 subsystem_unregister(&bus
->subsys
);
635 int __init
buses_init(void)
637 return subsystem_register(&bus_subsys
);
641 EXPORT_SYMBOL_GPL(bus_for_each_dev
);
642 EXPORT_SYMBOL_GPL(bus_find_device
);
643 EXPORT_SYMBOL_GPL(bus_for_each_drv
);
645 EXPORT_SYMBOL_GPL(bus_add_device
);
646 EXPORT_SYMBOL_GPL(bus_remove_device
);
647 EXPORT_SYMBOL_GPL(bus_register
);
648 EXPORT_SYMBOL_GPL(bus_unregister
);
649 EXPORT_SYMBOL_GPL(bus_rescan_devices
);
650 EXPORT_SYMBOL_GPL(get_bus
);
651 EXPORT_SYMBOL_GPL(put_bus
);
652 EXPORT_SYMBOL_GPL(find_bus
);
654 EXPORT_SYMBOL_GPL(bus_create_file
);
655 EXPORT_SYMBOL_GPL(bus_remove_file
);