blob: 96fe2f956754a38a2bfcde9299fe9b5223109466 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * bus.c - bus driver management
3 *
4 * Copyright (c) 2002-3 Patrick Mochel
5 * Copyright (c) 2002-3 Open Source Development Labs
6 *
7 * This file is released under the GPLv2
8 *
9 */
10
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>
17#include "base.h"
18#include "power/power.h"
19
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#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)
22
23/*
24 * sysfs bindings for drivers
25 */
26
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)
29
30
31static ssize_t
32drv_attr_show(struct kobject * kobj, struct attribute * attr, char * buf)
33{
34 struct driver_attribute * drv_attr = to_drv_attr(attr);
35 struct device_driver * drv = to_driver(kobj);
Dmitry Torokhov4a0c20b2005-04-29 01:23:47 -050036 ssize_t ret = -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -070037
38 if (drv_attr->show)
39 ret = drv_attr->show(drv, buf);
40 return ret;
41}
42
43static ssize_t
44drv_attr_store(struct kobject * kobj, struct attribute * attr,
45 const char * buf, size_t count)
46{
47 struct driver_attribute * drv_attr = to_drv_attr(attr);
48 struct device_driver * drv = to_driver(kobj);
Dmitry Torokhov4a0c20b2005-04-29 01:23:47 -050049 ssize_t ret = -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -070050
51 if (drv_attr->store)
52 ret = drv_attr->store(drv, buf, count);
53 return ret;
54}
55
56static struct sysfs_ops driver_sysfs_ops = {
57 .show = drv_attr_show,
58 .store = drv_attr_store,
59};
60
61
62static void driver_release(struct kobject * kobj)
63{
64 struct device_driver * drv = to_driver(kobj);
65 complete(&drv->unloaded);
66}
67
68static struct kobj_type ktype_driver = {
69 .sysfs_ops = &driver_sysfs_ops,
70 .release = driver_release,
71};
72
73
74/*
75 * sysfs bindings for buses
76 */
77
78
79static ssize_t
80bus_attr_show(struct kobject * kobj, struct attribute * attr, char * buf)
81{
82 struct bus_attribute * bus_attr = to_bus_attr(attr);
83 struct bus_type * bus = to_bus(kobj);
84 ssize_t ret = 0;
85
86 if (bus_attr->show)
87 ret = bus_attr->show(bus, buf);
88 return ret;
89}
90
91static ssize_t
92bus_attr_store(struct kobject * kobj, struct attribute * attr,
93 const char * buf, size_t count)
94{
95 struct bus_attribute * bus_attr = to_bus_attr(attr);
96 struct bus_type * bus = to_bus(kobj);
97 ssize_t ret = 0;
98
99 if (bus_attr->store)
100 ret = bus_attr->store(bus, buf, count);
101 return ret;
102}
103
104static struct sysfs_ops bus_sysfs_ops = {
105 .show = bus_attr_show,
106 .store = bus_attr_store,
107};
108
109int bus_create_file(struct bus_type * bus, struct bus_attribute * attr)
110{
111 int error;
112 if (get_bus(bus)) {
113 error = sysfs_create_file(&bus->subsys.kset.kobj, &attr->attr);
114 put_bus(bus);
115 } else
116 error = -EINVAL;
117 return error;
118}
119
120void bus_remove_file(struct bus_type * bus, struct bus_attribute * attr)
121{
122 if (get_bus(bus)) {
123 sysfs_remove_file(&bus->subsys.kset.kobj, &attr->attr);
124 put_bus(bus);
125 }
126}
127
128static struct kobj_type ktype_bus = {
129 .sysfs_ops = &bus_sysfs_ops,
130
131};
132
133decl_subsys(bus, &ktype_bus, NULL);
134
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135
Greg Kroah-Hartman151ef382005-06-22 16:09:05 -0700136/* Manually detach a device from it's associated driver. */
137static int driver_helper(struct device *dev, void *data)
138{
139 const char *name = data;
140
141 if (strcmp(name, dev->bus_id) == 0)
142 return 1;
143 return 0;
144}
145
146static ssize_t driver_unbind(struct device_driver *drv,
147 const char *buf, size_t count)
148{
149 struct bus_type *bus = get_bus(drv->bus);
150 struct device *dev;
151 int err = -ENODEV;
152
153 dev = bus_find_device(bus, NULL, (void *)buf, driver_helper);
154 if ((dev) &&
155 (dev->driver == drv)) {
156 device_release_driver(dev);
157 err = count;
158 }
159 return err;
160}
161static DRIVER_ATTR(unbind, S_IWUSR, NULL, driver_unbind);
162
Greg Kroah-Hartmanafdce752005-06-22 16:09:05 -0700163/*
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.
167 */
168static ssize_t driver_bind(struct device_driver *drv,
169 const char *buf, size_t count)
170{
171 struct bus_type *bus = get_bus(drv->bus);
172 struct device *dev;
173 int err = -ENODEV;
174
175 dev = bus_find_device(bus, NULL, (void *)buf, driver_helper);
176 if ((dev) &&
177 (dev->driver == NULL)) {
178 down(&dev->sem);
179 err = driver_probe_device(drv, dev);
180 up(&dev->sem);
181 put_device(dev);
182 }
183 return err;
184}
185static DRIVER_ATTR(bind, S_IWUSR, NULL, driver_bind);
186
Greg Kroah-Hartman151ef382005-06-22 16:09:05 -0700187
mochel@digitalimplant.org465c7a32005-03-21 11:49:14 -0800188static struct device * next_device(struct klist_iter * i)
189{
190 struct klist_node * n = klist_next(i);
191 return n ? container_of(n, struct device, knode_bus) : NULL;
192}
193
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194/**
195 * bus_for_each_dev - device iterator.
196 * @bus: bus type.
197 * @start: device to start iterating from.
198 * @data: data for the callback.
199 * @fn: function to be called for each device.
200 *
201 * Iterate over @bus's list of devices, and call @fn for each,
202 * passing it @data. If @start is not NULL, we use that device to
203 * begin iterating from.
204 *
205 * We check the return of @fn each time. If it returns anything
206 * other than 0, we break out and return that value.
207 *
208 * NOTE: The device that returns a non-zero value is not retained
209 * in any way, nor is its refcount incremented. If the caller needs
210 * to retain this data, it should do, and increment the reference
211 * count in the supplied callback.
212 */
213
214int bus_for_each_dev(struct bus_type * bus, struct device * start,
215 void * data, int (*fn)(struct device *, void *))
216{
mochel@digitalimplant.org465c7a32005-03-21 11:49:14 -0800217 struct klist_iter i;
218 struct device * dev;
219 int error = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220
mochel@digitalimplant.org465c7a32005-03-21 11:49:14 -0800221 if (!bus)
222 return -EINVAL;
223
224 klist_iter_init_node(&bus->klist_devices, &i,
225 (start ? &start->knode_bus : NULL));
226 while ((dev = next_device(&i)) && !error)
227 error = fn(dev, data);
228 klist_iter_exit(&i);
229 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230}
231
Cornelia Huck0edb5862005-06-22 16:59:51 +0200232/**
233 * bus_find_device - device iterator for locating a particular device.
234 * @bus: bus type
235 * @start: Device to begin with
236 * @data: Data to pass to match function
237 * @match: Callback function to check device
238 *
239 * This is similar to the bus_for_each_dev() function above, but it
240 * returns a reference to a device that is 'found' for later use, as
241 * determined by the @match callback.
242 *
243 * The callback should return 0 if the device doesn't match and non-zero
244 * if it does. If the callback returns non-zero, this function will
245 * return to the caller and not iterate over any more devices.
246 */
247struct device * bus_find_device(struct bus_type *bus,
248 struct device *start, void *data,
249 int (*match)(struct device *, void *))
250{
251 struct klist_iter i;
252 struct device *dev;
253
254 if (!bus)
255 return NULL;
256
257 klist_iter_init_node(&bus->klist_devices, &i,
258 (start ? &start->knode_bus : NULL));
259 while ((dev = next_device(&i)))
260 if (match(dev, data) && get_device(dev))
261 break;
262 klist_iter_exit(&i);
263 return dev;
264}
mochel@digitalimplant.org38fdac32005-03-21 12:00:18 -0800265
266
267static struct device_driver * next_driver(struct klist_iter * i)
268{
269 struct klist_node * n = klist_next(i);
270 return n ? container_of(n, struct device_driver, knode_bus) : NULL;
271}
272
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273/**
274 * bus_for_each_drv - driver iterator
275 * @bus: bus we're dealing with.
276 * @start: driver to start iterating on.
277 * @data: data to pass to the callback.
278 * @fn: function to call for each driver.
279 *
280 * This is nearly identical to the device iterator above.
281 * We iterate over each driver that belongs to @bus, and call
282 * @fn for each. If @fn returns anything but 0, we break out
283 * and return it. If @start is not NULL, we use it as the head
284 * of the list.
285 *
286 * NOTE: we don't return the driver that returns a non-zero
287 * value, nor do we leave the reference count incremented for that
288 * driver. If the caller needs to know that info, it must set it
289 * in the callback. It must also be sure to increment the refcount
290 * so it doesn't disappear before returning to the caller.
291 */
292
293int bus_for_each_drv(struct bus_type * bus, struct device_driver * start,
294 void * data, int (*fn)(struct device_driver *, void *))
295{
mochel@digitalimplant.org38fdac32005-03-21 12:00:18 -0800296 struct klist_iter i;
297 struct device_driver * drv;
298 int error = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299
mochel@digitalimplant.org38fdac32005-03-21 12:00:18 -0800300 if (!bus)
301 return -EINVAL;
302
303 klist_iter_init_node(&bus->klist_drivers, &i,
304 start ? &start->knode_bus : NULL);
305 while ((drv = next_driver(&i)) && !error)
306 error = fn(drv, data);
307 klist_iter_exit(&i);
308 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309}
310
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311static int device_add_attrs(struct bus_type * bus, struct device * dev)
312{
313 int error = 0;
314 int i;
315
316 if (bus->dev_attrs) {
317 for (i = 0; attr_name(bus->dev_attrs[i]); i++) {
318 error = device_create_file(dev,&bus->dev_attrs[i]);
319 if (error)
320 goto Err;
321 }
322 }
323 Done:
324 return error;
325 Err:
326 while (--i >= 0)
327 device_remove_file(dev,&bus->dev_attrs[i]);
328 goto Done;
329}
330
331
332static void device_remove_attrs(struct bus_type * bus, struct device * dev)
333{
334 int i;
335
336 if (bus->dev_attrs) {
337 for (i = 0; attr_name(bus->dev_attrs[i]); i++)
338 device_remove_file(dev,&bus->dev_attrs[i]);
339 }
340}
341
342
343/**
344 * bus_add_device - add device to bus
345 * @dev: device being added
346 *
347 * - Add the device to its bus's list of devices.
348 * - Try to attach to driver.
349 * - Create link to device's physical location.
350 */
351int bus_add_device(struct device * dev)
352{
353 struct bus_type * bus = get_bus(dev->bus);
354 int error = 0;
355
356 if (bus) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357 pr_debug("bus %s: add device %s\n", bus->name, dev->bus_id);
Greg Kroah-Hartmand377e852005-06-22 16:09:05 -0700358 device_attach(dev);
mochel@digitalimplant.org465c7a32005-03-21 11:49:14 -0800359 klist_add_tail(&bus->klist_devices, &dev->knode_bus);
Greg Kroah-Hartmand377e852005-06-22 16:09:05 -0700360 error = device_add_attrs(bus, dev);
Hannes Reineckeca2b94b2005-05-18 10:42:23 +0200361 if (!error) {
362 sysfs_create_link(&bus->devices.kobj, &dev->kobj, dev->bus_id);
363 sysfs_create_link(&dev->kobj, &dev->bus->subsys.kset.kobj, "bus");
364 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 }
366 return error;
367}
368
369/**
370 * bus_remove_device - remove device from bus
371 * @dev: device to be removed
372 *
373 * - Remove symlink from bus's directory.
374 * - Delete device from bus's list.
375 * - Detach from its driver.
376 * - Drop reference taken in bus_add_device().
377 */
378void bus_remove_device(struct device * dev)
379{
380 if (dev->bus) {
381 sysfs_remove_link(&dev->kobj, "bus");
382 sysfs_remove_link(&dev->bus->devices.kobj, dev->bus_id);
383 device_remove_attrs(dev->bus, dev);
mochel@digitalimplant.org465c7a32005-03-21 11:49:14 -0800384 klist_remove(&dev->knode_bus);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385 pr_debug("bus %s: remove device %s\n", dev->bus->name, dev->bus_id);
386 device_release_driver(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 put_bus(dev->bus);
388 }
389}
390
391static int driver_add_attrs(struct bus_type * bus, struct device_driver * drv)
392{
393 int error = 0;
394 int i;
395
396 if (bus->drv_attrs) {
397 for (i = 0; attr_name(bus->drv_attrs[i]); i++) {
398 error = driver_create_file(drv, &bus->drv_attrs[i]);
399 if (error)
400 goto Err;
401 }
402 }
403 Done:
404 return error;
405 Err:
406 while (--i >= 0)
407 driver_remove_file(drv, &bus->drv_attrs[i]);
408 goto Done;
409}
410
411
412static void driver_remove_attrs(struct bus_type * bus, struct device_driver * drv)
413{
414 int i;
415
416 if (bus->drv_attrs) {
417 for (i = 0; attr_name(bus->drv_attrs[i]); i++)
418 driver_remove_file(drv, &bus->drv_attrs[i]);
419 }
420}
421
422
423/**
424 * bus_add_driver - Add a driver to the bus.
425 * @drv: driver.
426 *
427 */
428int bus_add_driver(struct device_driver * drv)
429{
430 struct bus_type * bus = get_bus(drv->bus);
431 int error = 0;
432
433 if (bus) {
434 pr_debug("bus %s: add driver %s\n", bus->name, drv->name);
435 error = kobject_set_name(&drv->kobj, "%s", drv->name);
436 if (error) {
437 put_bus(bus);
438 return error;
439 }
440 drv->kobj.kset = &bus->drivers;
441 if ((error = kobject_register(&drv->kobj))) {
442 put_bus(bus);
443 return error;
444 }
445
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446 driver_attach(drv);
mochel@digitalimplant.org38fdac32005-03-21 12:00:18 -0800447 klist_add_tail(&bus->klist_drivers, &drv->knode_bus);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 module_add_driver(drv->owner, drv);
449
450 driver_add_attrs(bus, drv);
Greg Kroah-Hartman151ef382005-06-22 16:09:05 -0700451 driver_create_file(drv, &driver_attr_unbind);
Greg Kroah-Hartmanafdce752005-06-22 16:09:05 -0700452 driver_create_file(drv, &driver_attr_bind);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 }
454 return error;
455}
456
457
458/**
459 * bus_remove_driver - delete driver from bus's knowledge.
460 * @drv: driver.
461 *
462 * Detach the driver from the devices it controls, and remove
463 * it from its bus's list of drivers. Finally, we drop the reference
464 * to the bus we took in bus_add_driver().
465 */
466
467void bus_remove_driver(struct device_driver * drv)
468{
469 if (drv->bus) {
Greg Kroah-Hartmanafdce752005-06-22 16:09:05 -0700470 driver_remove_file(drv, &driver_attr_bind);
Greg Kroah-Hartman151ef382005-06-22 16:09:05 -0700471 driver_remove_file(drv, &driver_attr_unbind);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472 driver_remove_attrs(drv->bus, drv);
mochel@digitalimplant.org38fdac32005-03-21 12:00:18 -0800473 klist_remove(&drv->knode_bus);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 pr_debug("bus %s: remove driver %s\n", drv->bus->name, drv->name);
475 driver_detach(drv);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 module_remove_driver(drv);
477 kobject_unregister(&drv->kobj);
478 put_bus(drv->bus);
479 }
480}
481
482
483/* Helper for bus_rescan_devices's iter */
484static int bus_rescan_devices_helper(struct device *dev, void *data)
485{
Greg Kroah-Hartman23d3d602005-06-22 16:09:05 -0700486 if (!dev->driver)
487 device_attach(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488 return 0;
489}
490
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491/**
Greg Kroah-Hartman23d3d602005-06-22 16:09:05 -0700492 * bus_rescan_devices - rescan devices on the bus for possible drivers
493 * @bus: the bus to scan.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 *
Greg Kroah-Hartman23d3d602005-06-22 16:09:05 -0700495 * This function will look for devices on the bus with no driver
496 * attached and rescan it against existing drivers to see if it matches
497 * any by calling device_attach() for the unbound devices.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498 */
Greg Kroah-Hartman23d3d602005-06-22 16:09:05 -0700499void bus_rescan_devices(struct bus_type * bus)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500{
Greg Kroah-Hartman23d3d602005-06-22 16:09:05 -0700501 bus_for_each_dev(bus, NULL, NULL, bus_rescan_devices_helper);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502}
503
504
505struct bus_type * get_bus(struct bus_type * bus)
506{
507 return bus ? container_of(subsys_get(&bus->subsys), struct bus_type, subsys) : NULL;
508}
509
510void put_bus(struct bus_type * bus)
511{
512 subsys_put(&bus->subsys);
513}
514
515
516/**
517 * find_bus - locate bus by name.
518 * @name: name of bus.
519 *
520 * Call kset_find_obj() to iterate over list of buses to
521 * find a bus by name. Return bus if found.
522 *
523 * Note that kset_find_obj increments bus' reference count.
524 */
525
526struct bus_type * find_bus(char * name)
527{
528 struct kobject * k = kset_find_obj(&bus_subsys.kset, name);
529 return k ? to_bus(k) : NULL;
530}
531
532
533/**
534 * bus_add_attrs - Add default attributes for this bus.
535 * @bus: Bus that has just been registered.
536 */
537
538static int bus_add_attrs(struct bus_type * bus)
539{
540 int error = 0;
541 int i;
542
543 if (bus->bus_attrs) {
544 for (i = 0; attr_name(bus->bus_attrs[i]); i++) {
545 if ((error = bus_create_file(bus,&bus->bus_attrs[i])))
546 goto Err;
547 }
548 }
549 Done:
550 return error;
551 Err:
552 while (--i >= 0)
553 bus_remove_file(bus,&bus->bus_attrs[i]);
554 goto Done;
555}
556
557static void bus_remove_attrs(struct bus_type * bus)
558{
559 int i;
560
561 if (bus->bus_attrs) {
562 for (i = 0; attr_name(bus->bus_attrs[i]); i++)
563 bus_remove_file(bus,&bus->bus_attrs[i]);
564 }
565}
566
567/**
568 * bus_register - register a bus with the system.
569 * @bus: bus.
570 *
571 * Once we have that, we registered the bus with the kobject
572 * infrastructure, then register the children subsystems it has:
573 * the devices and drivers that belong to the bus.
574 */
575int bus_register(struct bus_type * bus)
576{
577 int retval;
578
579 retval = kobject_set_name(&bus->subsys.kset.kobj, "%s", bus->name);
580 if (retval)
581 goto out;
582
583 subsys_set_kset(bus, bus_subsys);
584 retval = subsystem_register(&bus->subsys);
585 if (retval)
586 goto out;
587
588 kobject_set_name(&bus->devices.kobj, "devices");
589 bus->devices.subsys = &bus->subsys;
590 retval = kset_register(&bus->devices);
591 if (retval)
592 goto bus_devices_fail;
593
594 kobject_set_name(&bus->drivers.kobj, "drivers");
595 bus->drivers.subsys = &bus->subsys;
596 bus->drivers.ktype = &ktype_driver;
597 retval = kset_register(&bus->drivers);
598 if (retval)
599 goto bus_drivers_fail;
mochel@digitalimplant.org465c7a32005-03-21 11:49:14 -0800600
601 klist_init(&bus->klist_devices);
mochel@digitalimplant.org38fdac32005-03-21 12:00:18 -0800602 klist_init(&bus->klist_drivers);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603 bus_add_attrs(bus);
604
605 pr_debug("bus type '%s' registered\n", bus->name);
606 return 0;
607
608bus_drivers_fail:
609 kset_unregister(&bus->devices);
610bus_devices_fail:
611 subsystem_unregister(&bus->subsys);
612out:
613 return retval;
614}
615
616
617/**
618 * bus_unregister - remove a bus from the system
619 * @bus: bus.
620 *
621 * Unregister the child subsystems and the bus itself.
622 * Finally, we call put_bus() to release the refcount
623 */
624void bus_unregister(struct bus_type * bus)
625{
626 pr_debug("bus %s: unregistering\n", bus->name);
627 bus_remove_attrs(bus);
628 kset_unregister(&bus->drivers);
629 kset_unregister(&bus->devices);
630 subsystem_unregister(&bus->subsys);
631}
632
633int __init buses_init(void)
634{
635 return subsystem_register(&bus_subsys);
636}
637
638
639EXPORT_SYMBOL_GPL(bus_for_each_dev);
Cornelia Huck0edb5862005-06-22 16:59:51 +0200640EXPORT_SYMBOL_GPL(bus_find_device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641EXPORT_SYMBOL_GPL(bus_for_each_drv);
642
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643EXPORT_SYMBOL_GPL(bus_add_device);
644EXPORT_SYMBOL_GPL(bus_remove_device);
645EXPORT_SYMBOL_GPL(bus_register);
646EXPORT_SYMBOL_GPL(bus_unregister);
647EXPORT_SYMBOL_GPL(bus_rescan_devices);
648EXPORT_SYMBOL_GPL(get_bus);
649EXPORT_SYMBOL_GPL(put_bus);
650EXPORT_SYMBOL_GPL(find_bus);
651
652EXPORT_SYMBOL_GPL(bus_create_file);
653EXPORT_SYMBOL_GPL(bus_remove_file);