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
);
196 static DRIVER_ATTR(bind
, S_IWUSR
, NULL
, driver_bind
);
200 static struct device
* next_device(struct klist_iter
* i
)
202 struct klist_node
* n
= klist_next(i
);
203 return n
? container_of(n
, struct device
, knode_bus
) : NULL
;
207 * bus_for_each_dev - device iterator.
209 * @start: device to start iterating from.
210 * @data: data for the callback.
211 * @fn: function to be called for each device.
213 * Iterate over @bus's list of devices, and call @fn for each,
214 * passing it @data. If @start is not NULL, we use that device to
215 * begin iterating from.
217 * We check the return of @fn each time. If it returns anything
218 * other than 0, we break out and return that value.
220 * NOTE: The device that returns a non-zero value is not retained
221 * in any way, nor is its refcount incremented. If the caller needs
222 * to retain this data, it should do, and increment the reference
223 * count in the supplied callback.
226 int bus_for_each_dev(struct bus_type
* bus
, struct device
* start
,
227 void * data
, int (*fn
)(struct device
*, void *))
236 klist_iter_init_node(&bus
->klist_devices
, &i
,
237 (start
? &start
->knode_bus
: NULL
));
238 while ((dev
= next_device(&i
)) && !error
)
239 error
= fn(dev
, data
);
245 * bus_find_device - device iterator for locating a particular device.
247 * @start: Device to begin with
248 * @data: Data to pass to match function
249 * @match: Callback function to check device
251 * This is similar to the bus_for_each_dev() function above, but it
252 * returns a reference to a device that is 'found' for later use, as
253 * determined by the @match callback.
255 * The callback should return 0 if the device doesn't match and non-zero
256 * if it does. If the callback returns non-zero, this function will
257 * return to the caller and not iterate over any more devices.
259 struct device
* bus_find_device(struct bus_type
*bus
,
260 struct device
*start
, void *data
,
261 int (*match
)(struct device
*, void *))
269 klist_iter_init_node(&bus
->klist_devices
, &i
,
270 (start
? &start
->knode_bus
: NULL
));
271 while ((dev
= next_device(&i
)))
272 if (match(dev
, data
) && get_device(dev
))
279 static struct device_driver
* next_driver(struct klist_iter
* i
)
281 struct klist_node
* n
= klist_next(i
);
282 return n
? container_of(n
, struct device_driver
, knode_bus
) : NULL
;
286 * bus_for_each_drv - driver iterator
287 * @bus: bus we're dealing with.
288 * @start: driver to start iterating on.
289 * @data: data to pass to the callback.
290 * @fn: function to call for each driver.
292 * This is nearly identical to the device iterator above.
293 * We iterate over each driver that belongs to @bus, and call
294 * @fn for each. If @fn returns anything but 0, we break out
295 * and return it. If @start is not NULL, we use it as the head
298 * NOTE: we don't return the driver that returns a non-zero
299 * value, nor do we leave the reference count incremented for that
300 * driver. If the caller needs to know that info, it must set it
301 * in the callback. It must also be sure to increment the refcount
302 * so it doesn't disappear before returning to the caller.
305 int bus_for_each_drv(struct bus_type
* bus
, struct device_driver
* start
,
306 void * data
, int (*fn
)(struct device_driver
*, void *))
309 struct device_driver
* drv
;
315 klist_iter_init_node(&bus
->klist_drivers
, &i
,
316 start
? &start
->knode_bus
: NULL
);
317 while ((drv
= next_driver(&i
)) && !error
)
318 error
= fn(drv
, data
);
323 static int device_add_attrs(struct bus_type
* bus
, struct device
* dev
)
328 if (bus
->dev_attrs
) {
329 for (i
= 0; attr_name(bus
->dev_attrs
[i
]); i
++) {
330 error
= device_create_file(dev
,&bus
->dev_attrs
[i
]);
339 device_remove_file(dev
,&bus
->dev_attrs
[i
]);
344 static void device_remove_attrs(struct bus_type
* bus
, struct device
* dev
)
348 if (bus
->dev_attrs
) {
349 for (i
= 0; attr_name(bus
->dev_attrs
[i
]); i
++)
350 device_remove_file(dev
,&bus
->dev_attrs
[i
]);
356 * bus_add_device - add device to bus
357 * @dev: device being added
359 * - Add the device to its bus's list of devices.
360 * - Try to attach to driver.
361 * - Create link to device's physical location.
363 int bus_add_device(struct device
* dev
)
365 struct bus_type
* bus
= get_bus(dev
->bus
);
369 pr_debug("bus %s: add device %s\n", bus
->name
, dev
->bus_id
);
371 klist_add_tail(&dev
->knode_bus
, &bus
->klist_devices
);
372 error
= device_add_attrs(bus
, dev
);
374 sysfs_create_link(&bus
->devices
.kobj
, &dev
->kobj
, dev
->bus_id
);
375 sysfs_create_link(&dev
->kobj
, &dev
->bus
->subsys
.kset
.kobj
, "bus");
382 * bus_remove_device - remove device from bus
383 * @dev: device to be removed
385 * - Remove symlink from bus's directory.
386 * - Delete device from bus's list.
387 * - Detach from its driver.
388 * - Drop reference taken in bus_add_device().
390 void bus_remove_device(struct device
* dev
)
393 sysfs_remove_link(&dev
->kobj
, "bus");
394 sysfs_remove_link(&dev
->bus
->devices
.kobj
, dev
->bus_id
);
395 device_remove_attrs(dev
->bus
, dev
);
396 klist_remove(&dev
->knode_bus
);
397 pr_debug("bus %s: remove device %s\n", dev
->bus
->name
, dev
->bus_id
);
398 device_release_driver(dev
);
403 static int driver_add_attrs(struct bus_type
* bus
, struct device_driver
* drv
)
408 if (bus
->drv_attrs
) {
409 for (i
= 0; attr_name(bus
->drv_attrs
[i
]); i
++) {
410 error
= driver_create_file(drv
, &bus
->drv_attrs
[i
]);
419 driver_remove_file(drv
, &bus
->drv_attrs
[i
]);
424 static void driver_remove_attrs(struct bus_type
* bus
, struct device_driver
* drv
)
428 if (bus
->drv_attrs
) {
429 for (i
= 0; attr_name(bus
->drv_attrs
[i
]); i
++)
430 driver_remove_file(drv
, &bus
->drv_attrs
[i
]);
434 #ifdef CONFIG_HOTPLUG
436 * Thanks to drivers making their tables __devinit, we can't allow manual
437 * bind and unbind from userspace unless CONFIG_HOTPLUG is enabled.
439 static void add_bind_files(struct device_driver
*drv
)
441 driver_create_file(drv
, &driver_attr_unbind
);
442 driver_create_file(drv
, &driver_attr_bind
);
445 static void remove_bind_files(struct device_driver
*drv
)
447 driver_remove_file(drv
, &driver_attr_bind
);
448 driver_remove_file(drv
, &driver_attr_unbind
);
451 static inline void add_bind_files(struct device_driver
*drv
) {}
452 static inline void remove_bind_files(struct device_driver
*drv
) {}
456 * bus_add_driver - Add a driver to the bus.
460 int bus_add_driver(struct device_driver
* drv
)
462 struct bus_type
* bus
= get_bus(drv
->bus
);
466 pr_debug("bus %s: add driver %s\n", bus
->name
, drv
->name
);
467 error
= kobject_set_name(&drv
->kobj
, "%s", drv
->name
);
472 drv
->kobj
.kset
= &bus
->drivers
;
473 if ((error
= kobject_register(&drv
->kobj
))) {
479 klist_add_tail(&drv
->knode_bus
, &bus
->klist_drivers
);
480 module_add_driver(drv
->owner
, drv
);
482 driver_add_attrs(bus
, drv
);
490 * bus_remove_driver - delete driver from bus's knowledge.
493 * Detach the driver from the devices it controls, and remove
494 * it from its bus's list of drivers. Finally, we drop the reference
495 * to the bus we took in bus_add_driver().
498 void bus_remove_driver(struct device_driver
* drv
)
501 remove_bind_files(drv
);
502 driver_remove_attrs(drv
->bus
, drv
);
503 klist_remove(&drv
->knode_bus
);
504 pr_debug("bus %s: remove driver %s\n", drv
->bus
->name
, drv
->name
);
506 module_remove_driver(drv
);
507 kobject_unregister(&drv
->kobj
);
513 /* Helper for bus_rescan_devices's iter */
514 static int bus_rescan_devices_helper(struct device
*dev
, void *data
)
517 if (dev
->parent
) /* Needed for USB */
518 down(&dev
->parent
->sem
);
521 up(&dev
->parent
->sem
);
527 * bus_rescan_devices - rescan devices on the bus for possible drivers
528 * @bus: the bus to scan.
530 * This function will look for devices on the bus with no driver
531 * attached and rescan it against existing drivers to see if it matches
532 * any by calling device_attach() for the unbound devices.
534 void bus_rescan_devices(struct bus_type
* bus
)
536 bus_for_each_dev(bus
, NULL
, NULL
, bus_rescan_devices_helper
);
540 struct bus_type
* get_bus(struct bus_type
* bus
)
542 return bus
? container_of(subsys_get(&bus
->subsys
), struct bus_type
, subsys
) : NULL
;
545 void put_bus(struct bus_type
* bus
)
547 subsys_put(&bus
->subsys
);
552 * find_bus - locate bus by name.
553 * @name: name of bus.
555 * Call kset_find_obj() to iterate over list of buses to
556 * find a bus by name. Return bus if found.
558 * Note that kset_find_obj increments bus' reference count.
561 struct bus_type
* find_bus(char * name
)
563 struct kobject
* k
= kset_find_obj(&bus_subsys
.kset
, name
);
564 return k
? to_bus(k
) : NULL
;
569 * bus_add_attrs - Add default attributes for this bus.
570 * @bus: Bus that has just been registered.
573 static int bus_add_attrs(struct bus_type
* bus
)
578 if (bus
->bus_attrs
) {
579 for (i
= 0; attr_name(bus
->bus_attrs
[i
]); i
++) {
580 if ((error
= bus_create_file(bus
,&bus
->bus_attrs
[i
])))
588 bus_remove_file(bus
,&bus
->bus_attrs
[i
]);
592 static void bus_remove_attrs(struct bus_type
* bus
)
596 if (bus
->bus_attrs
) {
597 for (i
= 0; attr_name(bus
->bus_attrs
[i
]); i
++)
598 bus_remove_file(bus
,&bus
->bus_attrs
[i
]);
602 static void klist_devices_get(struct klist_node
*n
)
604 struct device
*dev
= container_of(n
, struct device
, knode_bus
);
609 static void klist_devices_put(struct klist_node
*n
)
611 struct device
*dev
= container_of(n
, struct device
, knode_bus
);
616 static void klist_drivers_get(struct klist_node
*n
)
618 struct device_driver
*drv
= container_of(n
, struct device_driver
,
624 static void klist_drivers_put(struct klist_node
*n
)
626 struct device_driver
*drv
= container_of(n
, struct device_driver
,
633 * bus_register - register a bus with the system.
636 * Once we have that, we registered the bus with the kobject
637 * infrastructure, then register the children subsystems it has:
638 * the devices and drivers that belong to the bus.
640 int bus_register(struct bus_type
* bus
)
644 retval
= kobject_set_name(&bus
->subsys
.kset
.kobj
, "%s", bus
->name
);
648 subsys_set_kset(bus
, bus_subsys
);
649 retval
= subsystem_register(&bus
->subsys
);
653 kobject_set_name(&bus
->devices
.kobj
, "devices");
654 bus
->devices
.subsys
= &bus
->subsys
;
655 retval
= kset_register(&bus
->devices
);
657 goto bus_devices_fail
;
659 kobject_set_name(&bus
->drivers
.kobj
, "drivers");
660 bus
->drivers
.subsys
= &bus
->subsys
;
661 bus
->drivers
.ktype
= &ktype_driver
;
662 retval
= kset_register(&bus
->drivers
);
664 goto bus_drivers_fail
;
666 klist_init(&bus
->klist_devices
, klist_devices_get
, klist_devices_put
);
667 klist_init(&bus
->klist_drivers
, klist_drivers_get
, klist_drivers_put
);
670 pr_debug("bus type '%s' registered\n", bus
->name
);
674 kset_unregister(&bus
->devices
);
676 subsystem_unregister(&bus
->subsys
);
683 * bus_unregister - remove a bus from the system
686 * Unregister the child subsystems and the bus itself.
687 * Finally, we call put_bus() to release the refcount
689 void bus_unregister(struct bus_type
* bus
)
691 pr_debug("bus %s: unregistering\n", bus
->name
);
692 bus_remove_attrs(bus
);
693 kset_unregister(&bus
->drivers
);
694 kset_unregister(&bus
->devices
);
695 subsystem_unregister(&bus
->subsys
);
698 int __init
buses_init(void)
700 return subsystem_register(&bus_subsys
);
704 EXPORT_SYMBOL_GPL(bus_for_each_dev
);
705 EXPORT_SYMBOL_GPL(bus_find_device
);
706 EXPORT_SYMBOL_GPL(bus_for_each_drv
);
708 EXPORT_SYMBOL_GPL(bus_add_device
);
709 EXPORT_SYMBOL_GPL(bus_remove_device
);
710 EXPORT_SYMBOL_GPL(bus_register
);
711 EXPORT_SYMBOL_GPL(bus_unregister
);
712 EXPORT_SYMBOL_GPL(bus_rescan_devices
);
713 EXPORT_SYMBOL_GPL(get_bus
);
714 EXPORT_SYMBOL_GPL(put_bus
);
715 EXPORT_SYMBOL_GPL(find_bus
);
717 EXPORT_SYMBOL_GPL(bus_create_file
);
718 EXPORT_SYMBOL_GPL(bus_remove_file
);