blob: 0a8d075f3e6c3f785e36e1fad5020363f8f66052 [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
Linus Torvalds1da177e2005-04-16 15:20:36 -070011#include <linux/device.h>
12#include <linux/module.h>
13#include <linux/errno.h>
14#include <linux/init.h>
15#include <linux/string.h>
16#include "base.h"
17#include "power/power.h"
18
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#define to_bus_attr(_attr) container_of(_attr, struct bus_attribute, attr)
Greg Kroah-Hartman823bccf2007-04-13 13:15:19 -070020#define to_bus(obj) container_of(obj, struct bus_type, subsys.kobj)
Linus Torvalds1da177e2005-04-16 15:20:36 -070021
22/*
23 * sysfs bindings for drivers
24 */
25
26#define to_drv_attr(_attr) container_of(_attr, struct driver_attribute, attr)
27#define to_driver(obj) container_of(obj, struct device_driver, kobj)
28
29
Kay Sieversb8c5cec2007-02-16 17:33:36 +010030static int __must_check bus_rescan_devices_helper(struct device *dev,
31 void *data);
32
Greg Kroah-Hartman5901d012007-09-13 02:53:13 -070033static struct bus_type *bus_get(struct bus_type *bus)
34{
35 return bus ? container_of(kset_get(&bus->subsys),
36 struct bus_type, subsys) : NULL;
37}
38
Greg Kroah-Hartmanfc1ede52007-09-13 02:53:13 -070039static void bus_put(struct bus_type *bus)
40{
41 kset_put(&bus->subsys);
42}
43
Linus Torvalds1da177e2005-04-16 15:20:36 -070044static ssize_t
45drv_attr_show(struct kobject * kobj, struct attribute * attr, char * buf)
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->show)
52 ret = drv_attr->show(drv, buf);
53 return ret;
54}
55
56static ssize_t
57drv_attr_store(struct kobject * kobj, struct attribute * attr,
58 const char * buf, size_t count)
59{
60 struct driver_attribute * drv_attr = to_drv_attr(attr);
61 struct device_driver * drv = to_driver(kobj);
Dmitry Torokhov4a0c20b2005-04-29 01:23:47 -050062 ssize_t ret = -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -070063
64 if (drv_attr->store)
65 ret = drv_attr->store(drv, buf, count);
66 return ret;
67}
68
69static struct sysfs_ops driver_sysfs_ops = {
70 .show = drv_attr_show,
71 .store = drv_attr_store,
72};
73
74
75static void driver_release(struct kobject * kobj)
76{
Greg Kroah-Hartman74e9f5f2002-04-09 12:14:34 -070077 /*
78 * Yes this is an empty release function, it is this way because struct
79 * device is always a static object, not a dynamic one. Yes, this is
80 * not nice and bad, but remember, drivers are code, reference counted
81 * by the module count, not a device, which is really data. And yes,
82 * in the future I do want to have all drivers be created dynamically,
83 * and am working toward that goal, but it will take a bit longer...
84 *
85 * But do not let this example give _anyone_ the idea that they can
86 * create a release function without any code in it at all, to do that
87 * is almost always wrong. If you have any questions about this,
88 * please send an email to <greg@kroah.com>
89 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070090}
91
92static struct kobj_type ktype_driver = {
93 .sysfs_ops = &driver_sysfs_ops,
94 .release = driver_release,
95};
96
97
98/*
99 * sysfs bindings for buses
100 */
101
102
103static ssize_t
104bus_attr_show(struct kobject * kobj, struct attribute * attr, char * buf)
105{
106 struct bus_attribute * bus_attr = to_bus_attr(attr);
107 struct bus_type * bus = to_bus(kobj);
108 ssize_t ret = 0;
109
110 if (bus_attr->show)
111 ret = bus_attr->show(bus, buf);
112 return ret;
113}
114
115static ssize_t
116bus_attr_store(struct kobject * kobj, struct attribute * attr,
117 const char * buf, size_t count)
118{
119 struct bus_attribute * bus_attr = to_bus_attr(attr);
120 struct bus_type * bus = to_bus(kobj);
121 ssize_t ret = 0;
122
123 if (bus_attr->store)
124 ret = bus_attr->store(bus, buf, count);
125 return ret;
126}
127
128static struct sysfs_ops bus_sysfs_ops = {
129 .show = bus_attr_show,
130 .store = bus_attr_store,
131};
132
133int bus_create_file(struct bus_type * bus, struct bus_attribute * attr)
134{
135 int error;
Greg Kroah-Hartman5901d012007-09-13 02:53:13 -0700136 if (bus_get(bus)) {
Greg Kroah-Hartman823bccf2007-04-13 13:15:19 -0700137 error = sysfs_create_file(&bus->subsys.kobj, &attr->attr);
Greg Kroah-Hartmanfc1ede52007-09-13 02:53:13 -0700138 bus_put(bus);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 } else
140 error = -EINVAL;
141 return error;
142}
143
144void bus_remove_file(struct bus_type * bus, struct bus_attribute * attr)
145{
Greg Kroah-Hartman5901d012007-09-13 02:53:13 -0700146 if (bus_get(bus)) {
Greg Kroah-Hartman823bccf2007-04-13 13:15:19 -0700147 sysfs_remove_file(&bus->subsys.kobj, &attr->attr);
Greg Kroah-Hartmanfc1ede52007-09-13 02:53:13 -0700148 bus_put(bus);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 }
150}
151
Kay Sievers80f03e32007-05-26 11:21:36 +0200152static struct kobj_type bus_ktype = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 .sysfs_ops = &bus_sysfs_ops,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154};
155
Kay Sievers80f03e32007-05-26 11:21:36 +0200156static int bus_uevent_filter(struct kset *kset, struct kobject *kobj)
157{
158 struct kobj_type *ktype = get_ktype(kobj);
159
160 if (ktype == &bus_ktype)
161 return 1;
162 return 0;
163}
164
165static struct kset_uevent_ops bus_uevent_ops = {
166 .filter = bus_uevent_filter,
167};
168
169static decl_subsys(bus, &bus_ktype, &bus_uevent_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171
Russell King2139bdd2006-02-07 12:58:20 -0800172#ifdef CONFIG_HOTPLUG
Alan Stern2b08c8d2005-11-23 15:43:50 -0800173/* Manually detach a device from its associated driver. */
Greg Kroah-Hartman151ef382005-06-22 16:09:05 -0700174static int driver_helper(struct device *dev, void *data)
175{
176 const char *name = data;
177
178 if (strcmp(name, dev->bus_id) == 0)
179 return 1;
180 return 0;
181}
182
183static ssize_t driver_unbind(struct device_driver *drv,
184 const char *buf, size_t count)
185{
Greg Kroah-Hartman5901d012007-09-13 02:53:13 -0700186 struct bus_type *bus = bus_get(drv->bus);
Greg Kroah-Hartman151ef382005-06-22 16:09:05 -0700187 struct device *dev;
188 int err = -ENODEV;
189
190 dev = bus_find_device(bus, NULL, (void *)buf, driver_helper);
Alan Stern2b08c8d2005-11-23 15:43:50 -0800191 if (dev && dev->driver == drv) {
Alan Sternbf74ad52005-11-17 16:54:12 -0500192 if (dev->parent) /* Needed for USB */
193 down(&dev->parent->sem);
Greg Kroah-Hartman151ef382005-06-22 16:09:05 -0700194 device_release_driver(dev);
Alan Sternbf74ad52005-11-17 16:54:12 -0500195 if (dev->parent)
196 up(&dev->parent->sem);
Greg Kroah-Hartman151ef382005-06-22 16:09:05 -0700197 err = count;
198 }
Alan Stern2b08c8d2005-11-23 15:43:50 -0800199 put_device(dev);
Greg Kroah-Hartmanfc1ede52007-09-13 02:53:13 -0700200 bus_put(bus);
Alan Stern2b08c8d2005-11-23 15:43:50 -0800201 return err;
Greg Kroah-Hartman151ef382005-06-22 16:09:05 -0700202}
203static DRIVER_ATTR(unbind, S_IWUSR, NULL, driver_unbind);
204
Greg Kroah-Hartmanafdce752005-06-22 16:09:05 -0700205/*
206 * Manually attach a device to a driver.
207 * Note: the driver must want to bind to the device,
208 * it is not possible to override the driver's id table.
209 */
210static ssize_t driver_bind(struct device_driver *drv,
211 const char *buf, size_t count)
212{
Greg Kroah-Hartman5901d012007-09-13 02:53:13 -0700213 struct bus_type *bus = bus_get(drv->bus);
Greg Kroah-Hartmanafdce752005-06-22 16:09:05 -0700214 struct device *dev;
215 int err = -ENODEV;
216
217 dev = bus_find_device(bus, NULL, (void *)buf, driver_helper);
Alan Stern2b08c8d2005-11-23 15:43:50 -0800218 if (dev && dev->driver == NULL) {
Alan Sternbf74ad52005-11-17 16:54:12 -0500219 if (dev->parent) /* Needed for USB */
220 down(&dev->parent->sem);
Greg Kroah-Hartmanafdce752005-06-22 16:09:05 -0700221 down(&dev->sem);
222 err = driver_probe_device(drv, dev);
223 up(&dev->sem);
Alan Sternbf74ad52005-11-17 16:54:12 -0500224 if (dev->parent)
225 up(&dev->parent->sem);
Ryan Wilson37225402006-03-22 16:26:25 -0500226
227 if (err > 0) /* success */
228 err = count;
229 else if (err == 0) /* driver didn't accept device */
230 err = -ENODEV;
Greg Kroah-Hartmanafdce752005-06-22 16:09:05 -0700231 }
Alan Stern2b08c8d2005-11-23 15:43:50 -0800232 put_device(dev);
Greg Kroah-Hartmanfc1ede52007-09-13 02:53:13 -0700233 bus_put(bus);
Alan Stern2b08c8d2005-11-23 15:43:50 -0800234 return err;
Greg Kroah-Hartmanafdce752005-06-22 16:09:05 -0700235}
236static DRIVER_ATTR(bind, S_IWUSR, NULL, driver_bind);
237
Kay Sieversb8c5cec2007-02-16 17:33:36 +0100238static ssize_t show_drivers_autoprobe(struct bus_type *bus, char *buf)
239{
240 return sprintf(buf, "%d\n", bus->drivers_autoprobe);
241}
242
243static ssize_t store_drivers_autoprobe(struct bus_type *bus,
244 const char *buf, size_t count)
245{
246 if (buf[0] == '0')
247 bus->drivers_autoprobe = 0;
248 else
249 bus->drivers_autoprobe = 1;
250 return count;
251}
252
253static ssize_t store_drivers_probe(struct bus_type *bus,
254 const char *buf, size_t count)
255{
256 struct device *dev;
257
258 dev = bus_find_device(bus, NULL, (void *)buf, driver_helper);
259 if (!dev)
260 return -ENODEV;
261 if (bus_rescan_devices_helper(dev, NULL) != 0)
262 return -EINVAL;
263 return count;
264}
Russell King2139bdd2006-02-07 12:58:20 -0800265#endif
Greg Kroah-Hartman151ef382005-06-22 16:09:05 -0700266
mochel@digitalimplant.org465c7a32005-03-21 11:49:14 -0800267static struct device * next_device(struct klist_iter * i)
268{
269 struct klist_node * n = klist_next(i);
270 return n ? container_of(n, struct device, knode_bus) : NULL;
271}
272
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273/**
274 * bus_for_each_dev - device iterator.
275 * @bus: bus type.
276 * @start: device to start iterating from.
277 * @data: data for the callback.
278 * @fn: function to be called for each device.
279 *
280 * Iterate over @bus's list of devices, and call @fn for each,
281 * passing it @data. If @start is not NULL, we use that device to
282 * begin iterating from.
283 *
284 * We check the return of @fn each time. If it returns anything
285 * other than 0, we break out and return that value.
286 *
287 * NOTE: The device that returns a non-zero value is not retained
288 * in any way, nor is its refcount incremented. If the caller needs
289 * to retain this data, it should do, and increment the reference
290 * count in the supplied callback.
291 */
292
293int bus_for_each_dev(struct bus_type * bus, struct device * start,
294 void * data, int (*fn)(struct device *, void *))
295{
mochel@digitalimplant.org465c7a32005-03-21 11:49:14 -0800296 struct klist_iter i;
297 struct device * dev;
298 int error = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299
mochel@digitalimplant.org465c7a32005-03-21 11:49:14 -0800300 if (!bus)
301 return -EINVAL;
302
303 klist_iter_init_node(&bus->klist_devices, &i,
304 (start ? &start->knode_bus : NULL));
305 while ((dev = next_device(&i)) && !error)
306 error = fn(dev, data);
307 klist_iter_exit(&i);
308 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309}
310
Cornelia Huck0edb5862005-06-22 16:59:51 +0200311/**
312 * bus_find_device - device iterator for locating a particular device.
313 * @bus: bus type
314 * @start: Device to begin with
315 * @data: Data to pass to match function
316 * @match: Callback function to check device
317 *
318 * This is similar to the bus_for_each_dev() function above, but it
319 * returns a reference to a device that is 'found' for later use, as
320 * determined by the @match callback.
321 *
322 * The callback should return 0 if the device doesn't match and non-zero
323 * if it does. If the callback returns non-zero, this function will
324 * return to the caller and not iterate over any more devices.
325 */
326struct device * bus_find_device(struct bus_type *bus,
327 struct device *start, void *data,
328 int (*match)(struct device *, void *))
329{
330 struct klist_iter i;
331 struct device *dev;
332
333 if (!bus)
334 return NULL;
335
336 klist_iter_init_node(&bus->klist_devices, &i,
337 (start ? &start->knode_bus : NULL));
338 while ((dev = next_device(&i)))
339 if (match(dev, data) && get_device(dev))
340 break;
341 klist_iter_exit(&i);
342 return dev;
343}
mochel@digitalimplant.org38fdac32005-03-21 12:00:18 -0800344
345
346static struct device_driver * next_driver(struct klist_iter * i)
347{
348 struct klist_node * n = klist_next(i);
349 return n ? container_of(n, struct device_driver, knode_bus) : NULL;
350}
351
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352/**
353 * bus_for_each_drv - driver iterator
354 * @bus: bus we're dealing with.
355 * @start: driver to start iterating on.
356 * @data: data to pass to the callback.
357 * @fn: function to call for each driver.
358 *
359 * This is nearly identical to the device iterator above.
360 * We iterate over each driver that belongs to @bus, and call
361 * @fn for each. If @fn returns anything but 0, we break out
362 * and return it. If @start is not NULL, we use it as the head
363 * of the list.
364 *
365 * NOTE: we don't return the driver that returns a non-zero
366 * value, nor do we leave the reference count incremented for that
367 * driver. If the caller needs to know that info, it must set it
368 * in the callback. It must also be sure to increment the refcount
369 * so it doesn't disappear before returning to the caller.
370 */
371
372int bus_for_each_drv(struct bus_type * bus, struct device_driver * start,
373 void * data, int (*fn)(struct device_driver *, void *))
374{
mochel@digitalimplant.org38fdac32005-03-21 12:00:18 -0800375 struct klist_iter i;
376 struct device_driver * drv;
377 int error = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378
mochel@digitalimplant.org38fdac32005-03-21 12:00:18 -0800379 if (!bus)
380 return -EINVAL;
381
382 klist_iter_init_node(&bus->klist_drivers, &i,
383 start ? &start->knode_bus : NULL);
384 while ((drv = next_driver(&i)) && !error)
385 error = fn(drv, data);
386 klist_iter_exit(&i);
387 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388}
389
Andrew Morton4aca67e2007-02-13 22:39:26 -0800390static int device_add_attrs(struct bus_type *bus, struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391{
392 int error = 0;
393 int i;
394
Andrew Morton4aca67e2007-02-13 22:39:26 -0800395 if (!bus->dev_attrs)
396 return 0;
397
398 for (i = 0; attr_name(bus->dev_attrs[i]); i++) {
399 error = device_create_file(dev,&bus->dev_attrs[i]);
400 if (error) {
401 while (--i >= 0)
402 device_remove_file(dev, &bus->dev_attrs[i]);
403 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404 }
405 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407}
408
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409static void device_remove_attrs(struct bus_type * bus, struct device * dev)
410{
411 int i;
412
413 if (bus->dev_attrs) {
414 for (i = 0; attr_name(bus->dev_attrs[i]); i++)
415 device_remove_file(dev,&bus->dev_attrs[i]);
416 }
417}
418
Kay Sieversb9cafc72006-09-14 11:23:28 +0200419#ifdef CONFIG_SYSFS_DEPRECATED
420static int make_deprecated_bus_links(struct device *dev)
421{
422 return sysfs_create_link(&dev->kobj,
Greg Kroah-Hartman823bccf2007-04-13 13:15:19 -0700423 &dev->bus->subsys.kobj, "bus");
Kay Sieversb9cafc72006-09-14 11:23:28 +0200424}
425
426static void remove_deprecated_bus_links(struct device *dev)
427{
428 sysfs_remove_link(&dev->kobj, "bus");
429}
430#else
431static inline int make_deprecated_bus_links(struct device *dev) { return 0; }
432static inline void remove_deprecated_bus_links(struct device *dev) { }
433#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434
435/**
436 * bus_add_device - add device to bus
437 * @dev: device being added
438 *
439 * - Add the device to its bus's list of devices.
Kay Sievers53877d02006-04-04 20:42:26 +0200440 * - Create link to device's bus.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 */
442int bus_add_device(struct device * dev)
443{
Greg Kroah-Hartman5901d012007-09-13 02:53:13 -0700444 struct bus_type * bus = bus_get(dev->bus);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 int error = 0;
446
447 if (bus) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 pr_debug("bus %s: add device %s\n", bus->name, dev->bus_id);
Greg Kroah-Hartmand377e852005-06-22 16:09:05 -0700449 error = device_add_attrs(bus, dev);
Andrew Mortonf86db392006-08-14 22:43:20 -0700450 if (error)
Cornelia Huck513e7332006-09-22 11:37:08 +0200451 goto out_put;
Andrew Mortonf86db392006-08-14 22:43:20 -0700452 error = sysfs_create_link(&bus->devices.kobj,
453 &dev->kobj, dev->bus_id);
454 if (error)
Cornelia Huck513e7332006-09-22 11:37:08 +0200455 goto out_id;
Andrew Mortonf86db392006-08-14 22:43:20 -0700456 error = sysfs_create_link(&dev->kobj,
Greg Kroah-Hartman823bccf2007-04-13 13:15:19 -0700457 &dev->bus->subsys.kobj, "subsystem");
Andrew Mortonf86db392006-08-14 22:43:20 -0700458 if (error)
Cornelia Huck513e7332006-09-22 11:37:08 +0200459 goto out_subsys;
Kay Sieversb9cafc72006-09-14 11:23:28 +0200460 error = make_deprecated_bus_links(dev);
Cornelia Huck513e7332006-09-22 11:37:08 +0200461 if (error)
462 goto out_deprecated;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 }
Cornelia Huck513e7332006-09-22 11:37:08 +0200464 return 0;
465
466out_deprecated:
467 sysfs_remove_link(&dev->kobj, "subsystem");
468out_subsys:
469 sysfs_remove_link(&bus->devices.kobj, dev->bus_id);
470out_id:
471 device_remove_attrs(bus, dev);
472out_put:
Greg Kroah-Hartmanfc1ede52007-09-13 02:53:13 -0700473 bus_put(dev->bus);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 return error;
475}
476
477/**
Kay Sievers53877d02006-04-04 20:42:26 +0200478 * bus_attach_device - add device to bus
479 * @dev: device tried to attach to a driver
480 *
Alan Sternf2eaae12006-09-18 16:22:34 -0400481 * - Add device to bus's list of devices.
Kay Sievers53877d02006-04-04 20:42:26 +0200482 * - Try to attach to driver.
483 */
Cornelia Huckc6a46692007-02-05 16:15:26 -0800484void bus_attach_device(struct device * dev)
Kay Sievers53877d02006-04-04 20:42:26 +0200485{
Andrew Mortonf86db392006-08-14 22:43:20 -0700486 struct bus_type *bus = dev->bus;
487 int ret = 0;
Kay Sievers53877d02006-04-04 20:42:26 +0200488
489 if (bus) {
Alan Sternf2eaae12006-09-18 16:22:34 -0400490 dev->is_registered = 1;
Kay Sieversb8c5cec2007-02-16 17:33:36 +0100491 if (bus->drivers_autoprobe)
492 ret = device_attach(dev);
Cornelia Huckc6a46692007-02-05 16:15:26 -0800493 WARN_ON(ret < 0);
494 if (ret >= 0)
Andrew Mortonf86db392006-08-14 22:43:20 -0700495 klist_add_tail(&dev->knode_bus, &bus->klist_devices);
Cornelia Huckc6a46692007-02-05 16:15:26 -0800496 else
Alan Sternf2eaae12006-09-18 16:22:34 -0400497 dev->is_registered = 0;
Kay Sievers53877d02006-04-04 20:42:26 +0200498 }
499}
500
501/**
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502 * bus_remove_device - remove device from bus
503 * @dev: device to be removed
504 *
505 * - Remove symlink from bus's directory.
506 * - Delete device from bus's list.
507 * - Detach from its driver.
508 * - Drop reference taken in bus_add_device().
509 */
510void bus_remove_device(struct device * dev)
511{
512 if (dev->bus) {
Kay Sieversb9d9c822006-06-15 15:31:56 +0200513 sysfs_remove_link(&dev->kobj, "subsystem");
Kay Sieversb9cafc72006-09-14 11:23:28 +0200514 remove_deprecated_bus_links(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515 sysfs_remove_link(&dev->bus->devices.kobj, dev->bus_id);
516 device_remove_attrs(dev->bus, dev);
Alan Sternf70fa622006-10-05 17:03:24 -0400517 if (dev->is_registered) {
518 dev->is_registered = 0;
519 klist_del(&dev->knode_bus);
520 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 pr_debug("bus %s: remove device %s\n", dev->bus->name, dev->bus_id);
522 device_release_driver(dev);
Greg Kroah-Hartmanfc1ede52007-09-13 02:53:13 -0700523 bus_put(dev->bus);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524 }
525}
526
527static int driver_add_attrs(struct bus_type * bus, struct device_driver * drv)
528{
529 int error = 0;
530 int i;
531
532 if (bus->drv_attrs) {
533 for (i = 0; attr_name(bus->drv_attrs[i]); i++) {
534 error = driver_create_file(drv, &bus->drv_attrs[i]);
535 if (error)
536 goto Err;
537 }
538 }
539 Done:
540 return error;
541 Err:
542 while (--i >= 0)
543 driver_remove_file(drv, &bus->drv_attrs[i]);
544 goto Done;
545}
546
547
548static void driver_remove_attrs(struct bus_type * bus, struct device_driver * drv)
549{
550 int i;
551
552 if (bus->drv_attrs) {
553 for (i = 0; attr_name(bus->drv_attrs[i]); i++)
554 driver_remove_file(drv, &bus->drv_attrs[i]);
555 }
556}
557
Greg Kroah-Hartman874c6242005-12-13 15:17:34 -0800558#ifdef CONFIG_HOTPLUG
559/*
560 * Thanks to drivers making their tables __devinit, we can't allow manual
561 * bind and unbind from userspace unless CONFIG_HOTPLUG is enabled.
562 */
Andrew Mortonf86db392006-08-14 22:43:20 -0700563static int __must_check add_bind_files(struct device_driver *drv)
Greg Kroah-Hartman874c6242005-12-13 15:17:34 -0800564{
Andrew Mortonf86db392006-08-14 22:43:20 -0700565 int ret;
566
567 ret = driver_create_file(drv, &driver_attr_unbind);
568 if (ret == 0) {
569 ret = driver_create_file(drv, &driver_attr_bind);
570 if (ret)
571 driver_remove_file(drv, &driver_attr_unbind);
572 }
573 return ret;
Greg Kroah-Hartman874c6242005-12-13 15:17:34 -0800574}
575
576static void remove_bind_files(struct device_driver *drv)
577{
578 driver_remove_file(drv, &driver_attr_bind);
579 driver_remove_file(drv, &driver_attr_unbind);
580}
Kay Sieversb8c5cec2007-02-16 17:33:36 +0100581
Kay Sievers83807702007-07-30 02:28:56 +0200582static BUS_ATTR(drivers_probe, S_IWUSR, NULL, store_drivers_probe);
583static BUS_ATTR(drivers_autoprobe, S_IWUSR | S_IRUGO,
584 show_drivers_autoprobe, store_drivers_autoprobe);
585
Kay Sieversb8c5cec2007-02-16 17:33:36 +0100586static int add_probe_files(struct bus_type *bus)
587{
588 int retval;
589
Kay Sievers83807702007-07-30 02:28:56 +0200590 retval = bus_create_file(bus, &bus_attr_drivers_probe);
Kay Sieversb8c5cec2007-02-16 17:33:36 +0100591 if (retval)
592 goto out;
593
Kay Sievers83807702007-07-30 02:28:56 +0200594 retval = bus_create_file(bus, &bus_attr_drivers_autoprobe);
Kay Sieversb8c5cec2007-02-16 17:33:36 +0100595 if (retval)
Kay Sievers83807702007-07-30 02:28:56 +0200596 bus_remove_file(bus, &bus_attr_drivers_probe);
Kay Sieversb8c5cec2007-02-16 17:33:36 +0100597out:
598 return retval;
599}
600
601static void remove_probe_files(struct bus_type *bus)
602{
Kay Sievers83807702007-07-30 02:28:56 +0200603 bus_remove_file(bus, &bus_attr_drivers_autoprobe);
604 bus_remove_file(bus, &bus_attr_drivers_probe);
Kay Sieversb8c5cec2007-02-16 17:33:36 +0100605}
Greg Kroah-Hartman874c6242005-12-13 15:17:34 -0800606#else
Yoichi Yuasa35acfdd2006-07-15 01:30:11 +0900607static inline int add_bind_files(struct device_driver *drv) { return 0; }
Greg Kroah-Hartman874c6242005-12-13 15:17:34 -0800608static inline void remove_bind_files(struct device_driver *drv) {}
Kay Sieversb8c5cec2007-02-16 17:33:36 +0100609static inline int add_probe_files(struct bus_type *bus) { return 0; }
610static inline void remove_probe_files(struct bus_type *bus) {}
Greg Kroah-Hartman874c6242005-12-13 15:17:34 -0800611#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612
613/**
614 * bus_add_driver - Add a driver to the bus.
615 * @drv: driver.
616 *
617 */
Andrew Mortonf86db392006-08-14 22:43:20 -0700618int bus_add_driver(struct device_driver *drv)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619{
Greg Kroah-Hartman5901d012007-09-13 02:53:13 -0700620 struct bus_type * bus = bus_get(drv->bus);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 int error = 0;
622
Jeff Garzikd9fd4d3b32006-10-04 07:48:03 -0400623 if (!bus)
Greg Kroah-Hartman4f6e1942007-04-20 11:29:52 -0700624 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625
Jeff Garzikd9fd4d3b32006-10-04 07:48:03 -0400626 pr_debug("bus %s: add driver %s\n", bus->name, drv->name);
627 error = kobject_set_name(&drv->kobj, "%s", drv->name);
628 if (error)
629 goto out_put_bus;
630 drv->kobj.kset = &bus->drivers;
Cornelia Huckdc0afa82007-07-09 11:39:18 -0700631 error = kobject_register(&drv->kobj);
632 if (error)
Jeff Garzikd9fd4d3b32006-10-04 07:48:03 -0400633 goto out_put_bus;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634
Kay Sieversb8c5cec2007-02-16 17:33:36 +0100635 if (drv->bus->drivers_autoprobe) {
636 error = driver_attach(drv);
637 if (error)
638 goto out_unregister;
639 }
Jeff Garzikd9fd4d3b32006-10-04 07:48:03 -0400640 klist_add_tail(&drv->knode_bus, &bus->klist_drivers);
641 module_add_driver(drv->owner, drv);
642
643 error = driver_add_attrs(bus, drv);
644 if (error) {
645 /* How the hell do we get out of this pickle? Give up */
646 printk(KERN_ERR "%s: driver_add_attrs(%s) failed\n",
647 __FUNCTION__, drv->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648 }
Jeff Garzikd9fd4d3b32006-10-04 07:48:03 -0400649 error = add_bind_files(drv);
650 if (error) {
651 /* Ditto */
652 printk(KERN_ERR "%s: add_bind_files(%s) failed\n",
653 __FUNCTION__, drv->name);
654 }
655
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 return error;
Andrew Mortonf86db392006-08-14 22:43:20 -0700657out_unregister:
658 kobject_unregister(&drv->kobj);
659out_put_bus:
Greg Kroah-Hartmanfc1ede52007-09-13 02:53:13 -0700660 bus_put(bus);
Andrew Mortonf86db392006-08-14 22:43:20 -0700661 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662}
663
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664/**
665 * bus_remove_driver - delete driver from bus's knowledge.
666 * @drv: driver.
667 *
668 * Detach the driver from the devices it controls, and remove
669 * it from its bus's list of drivers. Finally, we drop the reference
670 * to the bus we took in bus_add_driver().
671 */
672
673void bus_remove_driver(struct device_driver * drv)
674{
Jeff Garzikd9fd4d3b32006-10-04 07:48:03 -0400675 if (!drv->bus)
676 return;
677
678 remove_bind_files(drv);
679 driver_remove_attrs(drv->bus, drv);
680 klist_remove(&drv->knode_bus);
681 pr_debug("bus %s: remove driver %s\n", drv->bus->name, drv->name);
682 driver_detach(drv);
683 module_remove_driver(drv);
684 kobject_unregister(&drv->kobj);
Greg Kroah-Hartmanfc1ede52007-09-13 02:53:13 -0700685 bus_put(drv->bus);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686}
687
688
689/* Helper for bus_rescan_devices's iter */
Andrew Mortonf86db392006-08-14 22:43:20 -0700690static int __must_check bus_rescan_devices_helper(struct device *dev,
691 void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692{
Andrew Mortonf86db392006-08-14 22:43:20 -0700693 int ret = 0;
694
Alan Sternbf74ad52005-11-17 16:54:12 -0500695 if (!dev->driver) {
696 if (dev->parent) /* Needed for USB */
697 down(&dev->parent->sem);
Andrew Mortonf86db392006-08-14 22:43:20 -0700698 ret = device_attach(dev);
Alan Sternbf74ad52005-11-17 16:54:12 -0500699 if (dev->parent)
700 up(&dev->parent->sem);
701 }
Andrew Mortonf86db392006-08-14 22:43:20 -0700702 return ret < 0 ? ret : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703}
704
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705/**
Greg Kroah-Hartman23d3d602005-06-22 16:09:05 -0700706 * bus_rescan_devices - rescan devices on the bus for possible drivers
707 * @bus: the bus to scan.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708 *
Greg Kroah-Hartman23d3d602005-06-22 16:09:05 -0700709 * This function will look for devices on the bus with no driver
710 * attached and rescan it against existing drivers to see if it matches
711 * any by calling device_attach() for the unbound devices.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712 */
Andrew Mortonf86db392006-08-14 22:43:20 -0700713int bus_rescan_devices(struct bus_type * bus)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714{
Andrew Mortonf86db392006-08-14 22:43:20 -0700715 return bus_for_each_dev(bus, NULL, NULL, bus_rescan_devices_helper);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716}
717
Moore, Erice935d5d2006-03-14 09:18:18 -0700718/**
719 * device_reprobe - remove driver for a device and probe for a new driver
720 * @dev: the device to reprobe
721 *
722 * This function detaches the attached driver (if any) for the given
723 * device and restarts the driver probing process. It is intended
724 * to use if probing criteria changed during a devices lifetime and
725 * driver attachment should change accordingly.
726 */
Andrew Mortonf86db392006-08-14 22:43:20 -0700727int device_reprobe(struct device *dev)
Moore, Erice935d5d2006-03-14 09:18:18 -0700728{
729 if (dev->driver) {
730 if (dev->parent) /* Needed for USB */
731 down(&dev->parent->sem);
732 device_release_driver(dev);
733 if (dev->parent)
734 up(&dev->parent->sem);
735 }
Andrew Mortonf86db392006-08-14 22:43:20 -0700736 return bus_rescan_devices_helper(dev, NULL);
Moore, Erice935d5d2006-03-14 09:18:18 -0700737}
738EXPORT_SYMBOL_GPL(device_reprobe);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740/**
741 * find_bus - locate bus by name.
742 * @name: name of bus.
743 *
744 * Call kset_find_obj() to iterate over list of buses to
745 * find a bus by name. Return bus if found.
746 *
747 * Note that kset_find_obj increments bus' reference count.
748 */
Adrian Bunk7e4ef082006-06-26 22:26:56 +0200749#if 0
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750struct bus_type * find_bus(char * name)
751{
752 struct kobject * k = kset_find_obj(&bus_subsys.kset, name);
753 return k ? to_bus(k) : NULL;
754}
Adrian Bunk7e4ef082006-06-26 22:26:56 +0200755#endif /* 0 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756
757
758/**
759 * bus_add_attrs - Add default attributes for this bus.
760 * @bus: Bus that has just been registered.
761 */
762
763static int bus_add_attrs(struct bus_type * bus)
764{
765 int error = 0;
766 int i;
767
768 if (bus->bus_attrs) {
769 for (i = 0; attr_name(bus->bus_attrs[i]); i++) {
Cornelia Huckdc0afa82007-07-09 11:39:18 -0700770 error = bus_create_file(bus,&bus->bus_attrs[i]);
771 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772 goto Err;
773 }
774 }
775 Done:
776 return error;
777 Err:
778 while (--i >= 0)
779 bus_remove_file(bus,&bus->bus_attrs[i]);
780 goto Done;
781}
782
783static void bus_remove_attrs(struct bus_type * bus)
784{
785 int i;
786
787 if (bus->bus_attrs) {
788 for (i = 0; attr_name(bus->bus_attrs[i]); i++)
789 bus_remove_file(bus,&bus->bus_attrs[i]);
790 }
791}
792
James Bottomley34bb61f2005-09-06 16:56:51 -0700793static void klist_devices_get(struct klist_node *n)
794{
795 struct device *dev = container_of(n, struct device, knode_bus);
796
797 get_device(dev);
798}
799
800static void klist_devices_put(struct klist_node *n)
801{
802 struct device *dev = container_of(n, struct device, knode_bus);
803
804 put_device(dev);
805}
806
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807/**
808 * bus_register - register a bus with the system.
809 * @bus: bus.
810 *
811 * Once we have that, we registered the bus with the kobject
812 * infrastructure, then register the children subsystems it has:
813 * the devices and drivers that belong to the bus.
814 */
815int bus_register(struct bus_type * bus)
816{
817 int retval;
818
Benjamin Herrenschmidt116af372006-10-25 13:44:59 +1000819 BLOCKING_INIT_NOTIFIER_HEAD(&bus->bus_notifier);
820
Greg Kroah-Hartman823bccf2007-04-13 13:15:19 -0700821 retval = kobject_set_name(&bus->subsys.kobj, "%s", bus->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822 if (retval)
823 goto out;
824
Greg Kroah-Hartmand6b05b82007-09-12 15:06:57 -0700825 bus->subsys.kobj.kset = &bus_subsys;
826
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827 retval = subsystem_register(&bus->subsys);
828 if (retval)
829 goto out;
830
831 kobject_set_name(&bus->devices.kobj, "devices");
Greg Kroah-Hartman823bccf2007-04-13 13:15:19 -0700832 bus->devices.kobj.parent = &bus->subsys.kobj;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833 retval = kset_register(&bus->devices);
834 if (retval)
835 goto bus_devices_fail;
836
837 kobject_set_name(&bus->drivers.kobj, "drivers");
Greg Kroah-Hartman823bccf2007-04-13 13:15:19 -0700838 bus->drivers.kobj.parent = &bus->subsys.kobj;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839 bus->drivers.ktype = &ktype_driver;
840 retval = kset_register(&bus->drivers);
841 if (retval)
842 goto bus_drivers_fail;
mochel@digitalimplant.org465c7a32005-03-21 11:49:14 -0800843
James Bottomley34bb61f2005-09-06 16:56:51 -0700844 klist_init(&bus->klist_devices, klist_devices_get, klist_devices_put);
Alan Stern81107bf2006-09-18 16:24:28 -0400845 klist_init(&bus->klist_drivers, NULL, NULL);
Kay Sieversb8c5cec2007-02-16 17:33:36 +0100846
847 bus->drivers_autoprobe = 1;
848 retval = add_probe_files(bus);
849 if (retval)
850 goto bus_probe_files_fail;
851
Cornelia Huck1bb68812006-09-22 11:37:04 +0200852 retval = bus_add_attrs(bus);
853 if (retval)
854 goto bus_attrs_fail;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855
856 pr_debug("bus type '%s' registered\n", bus->name);
857 return 0;
858
Cornelia Huck1bb68812006-09-22 11:37:04 +0200859bus_attrs_fail:
Kay Sieversb8c5cec2007-02-16 17:33:36 +0100860 remove_probe_files(bus);
861bus_probe_files_fail:
Cornelia Huck1bb68812006-09-22 11:37:04 +0200862 kset_unregister(&bus->drivers);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863bus_drivers_fail:
864 kset_unregister(&bus->devices);
865bus_devices_fail:
866 subsystem_unregister(&bus->subsys);
867out:
868 return retval;
869}
870
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871/**
872 * bus_unregister - remove a bus from the system
873 * @bus: bus.
874 *
875 * Unregister the child subsystems and the bus itself.
Greg Kroah-Hartmanfc1ede52007-09-13 02:53:13 -0700876 * Finally, we call bus_put() to release the refcount
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877 */
878void bus_unregister(struct bus_type * bus)
879{
880 pr_debug("bus %s: unregistering\n", bus->name);
881 bus_remove_attrs(bus);
Kay Sieversb8c5cec2007-02-16 17:33:36 +0100882 remove_probe_files(bus);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883 kset_unregister(&bus->drivers);
884 kset_unregister(&bus->devices);
885 subsystem_unregister(&bus->subsys);
886}
887
Benjamin Herrenschmidt116af372006-10-25 13:44:59 +1000888int bus_register_notifier(struct bus_type *bus, struct notifier_block *nb)
889{
890 return blocking_notifier_chain_register(&bus->bus_notifier, nb);
891}
892EXPORT_SYMBOL_GPL(bus_register_notifier);
893
894int bus_unregister_notifier(struct bus_type *bus, struct notifier_block *nb)
895{
896 return blocking_notifier_chain_unregister(&bus->bus_notifier, nb);
897}
898EXPORT_SYMBOL_GPL(bus_unregister_notifier);
899
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900int __init buses_init(void)
901{
902 return subsystem_register(&bus_subsys);
903}
904
905
906EXPORT_SYMBOL_GPL(bus_for_each_dev);
Cornelia Huck0edb5862005-06-22 16:59:51 +0200907EXPORT_SYMBOL_GPL(bus_find_device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908EXPORT_SYMBOL_GPL(bus_for_each_drv);
909
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910EXPORT_SYMBOL_GPL(bus_register);
911EXPORT_SYMBOL_GPL(bus_unregister);
912EXPORT_SYMBOL_GPL(bus_rescan_devices);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913
914EXPORT_SYMBOL_GPL(bus_create_file);
915EXPORT_SYMBOL_GPL(bus_remove_file);