blob: 770e1d6ee3063a5556fede263b5ca6ea0e3ca03c [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
Greg Kroah-Hartmane5dd1272007-11-28 15:59:15 -08006 * Copyright (c) 2007 Greg Kroah-Hartman <gregkh@suse.de>
7 * Copyright (c) 2007 Novell Inc.
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 *
9 * This file is released under the GPLv2
10 *
11 */
12
Linus Torvalds1da177e2005-04-16 15:20:36 -070013#include <linux/device.h>
14#include <linux/module.h>
15#include <linux/errno.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090016#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#include <linux/init.h>
18#include <linux/string.h>
Kay Sieversca22e562011-12-14 14:29:38 -080019#include <linux/mutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include "base.h"
21#include "power/power.h"
22
Kay Sieversca22e562011-12-14 14:29:38 -080023/* /sys/devices/system */
24/* FIXME: make static after drivers/base/sys.c is deleted */
25struct kset *system_kset;
26
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#define to_bus_attr(_attr) container_of(_attr, struct bus_attribute, attr)
Linus Torvalds1da177e2005-04-16 15:20:36 -070028
29/*
30 * sysfs bindings for drivers
31 */
32
33#define to_drv_attr(_attr) container_of(_attr, struct driver_attribute, attr)
Linus Torvalds1da177e2005-04-16 15:20:36 -070034
35
Kay Sieversb8c5cec2007-02-16 17:33:36 +010036static int __must_check bus_rescan_devices_helper(struct device *dev,
37 void *data);
38
Greg Kroah-Hartman5901d012007-09-13 02:53:13 -070039static struct bus_type *bus_get(struct bus_type *bus)
40{
Greg Kroah-Hartmanc6f7e722007-11-01 19:41:16 -070041 if (bus) {
42 kset_get(&bus->p->subsys);
43 return bus;
44 }
45 return NULL;
Greg Kroah-Hartman5901d012007-09-13 02:53:13 -070046}
47
Greg Kroah-Hartmanfc1ede52007-09-13 02:53:13 -070048static void bus_put(struct bus_type *bus)
49{
Greg Kroah-Hartmanc6f7e722007-11-01 19:41:16 -070050 if (bus)
51 kset_put(&bus->p->subsys);
Greg Kroah-Hartmanfc1ede52007-09-13 02:53:13 -070052}
53
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -080054static ssize_t drv_attr_show(struct kobject *kobj, struct attribute *attr,
55 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -070056{
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -080057 struct driver_attribute *drv_attr = to_drv_attr(attr);
Greg Kroah-Hartmane5dd1272007-11-28 15:59:15 -080058 struct driver_private *drv_priv = to_driver(kobj);
Dmitry Torokhov4a0c20b2005-04-29 01:23:47 -050059 ssize_t ret = -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -070060
61 if (drv_attr->show)
Greg Kroah-Hartmane5dd1272007-11-28 15:59:15 -080062 ret = drv_attr->show(drv_priv->driver, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -070063 return ret;
64}
65
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -080066static ssize_t drv_attr_store(struct kobject *kobj, struct attribute *attr,
67 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -070068{
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -080069 struct driver_attribute *drv_attr = to_drv_attr(attr);
Greg Kroah-Hartmane5dd1272007-11-28 15:59:15 -080070 struct driver_private *drv_priv = to_driver(kobj);
Dmitry Torokhov4a0c20b2005-04-29 01:23:47 -050071 ssize_t ret = -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -070072
73 if (drv_attr->store)
Greg Kroah-Hartmane5dd1272007-11-28 15:59:15 -080074 ret = drv_attr->store(drv_priv->driver, buf, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -070075 return ret;
76}
77
Emese Revfy52cf25d2010-01-19 02:58:23 +010078static const struct sysfs_ops driver_sysfs_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070079 .show = drv_attr_show,
80 .store = drv_attr_store,
81};
82
Greg Kroah-Hartmane5dd1272007-11-28 15:59:15 -080083static void driver_release(struct kobject *kobj)
Linus Torvalds1da177e2005-04-16 15:20:36 -070084{
Greg Kroah-Hartmane5dd1272007-11-28 15:59:15 -080085 struct driver_private *drv_priv = to_driver(kobj);
86
Harvey Harrison2b3a3022008-03-04 16:41:05 -080087 pr_debug("driver: '%s': %s\n", kobject_name(kobj), __func__);
Greg Kroah-Hartmane5dd1272007-11-28 15:59:15 -080088 kfree(drv_priv);
Linus Torvalds1da177e2005-04-16 15:20:36 -070089}
90
Greg Kroah-Hartmana1148fb2007-10-11 10:47:49 -060091static struct kobj_type driver_ktype = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070092 .sysfs_ops = &driver_sysfs_ops,
93 .release = driver_release,
94};
95
Linus Torvalds1da177e2005-04-16 15:20:36 -070096/*
97 * sysfs bindings for buses
98 */
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -080099static ssize_t bus_attr_show(struct kobject *kobj, struct attribute *attr,
100 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101{
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800102 struct bus_attribute *bus_attr = to_bus_attr(attr);
Kay Sievers6b6e39a2010-11-15 23:13:18 +0100103 struct subsys_private *subsys_priv = to_subsys_private(kobj);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104 ssize_t ret = 0;
105
106 if (bus_attr->show)
Kay Sievers6b6e39a2010-11-15 23:13:18 +0100107 ret = bus_attr->show(subsys_priv->bus, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108 return ret;
109}
110
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800111static ssize_t bus_attr_store(struct kobject *kobj, struct attribute *attr,
112 const char *buf, size_t count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113{
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800114 struct bus_attribute *bus_attr = to_bus_attr(attr);
Kay Sievers6b6e39a2010-11-15 23:13:18 +0100115 struct subsys_private *subsys_priv = to_subsys_private(kobj);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116 ssize_t ret = 0;
117
118 if (bus_attr->store)
Kay Sievers6b6e39a2010-11-15 23:13:18 +0100119 ret = bus_attr->store(subsys_priv->bus, buf, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120 return ret;
121}
122
Emese Revfy52cf25d2010-01-19 02:58:23 +0100123static const struct sysfs_ops bus_sysfs_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124 .show = bus_attr_show,
125 .store = bus_attr_store,
126};
127
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800128int bus_create_file(struct bus_type *bus, struct bus_attribute *attr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129{
130 int error;
Greg Kroah-Hartman5901d012007-09-13 02:53:13 -0700131 if (bus_get(bus)) {
Greg Kroah-Hartmanc6f7e722007-11-01 19:41:16 -0700132 error = sysfs_create_file(&bus->p->subsys.kobj, &attr->attr);
Greg Kroah-Hartmanfc1ede52007-09-13 02:53:13 -0700133 bus_put(bus);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134 } else
135 error = -EINVAL;
136 return error;
137}
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800138EXPORT_SYMBOL_GPL(bus_create_file);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800140void bus_remove_file(struct bus_type *bus, struct bus_attribute *attr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141{
Greg Kroah-Hartman5901d012007-09-13 02:53:13 -0700142 if (bus_get(bus)) {
Greg Kroah-Hartmanc6f7e722007-11-01 19:41:16 -0700143 sysfs_remove_file(&bus->p->subsys.kobj, &attr->attr);
Greg Kroah-Hartmanfc1ede52007-09-13 02:53:13 -0700144 bus_put(bus);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145 }
146}
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800147EXPORT_SYMBOL_GPL(bus_remove_file);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148
Kay Sievers80f03e32007-05-26 11:21:36 +0200149static struct kobj_type bus_ktype = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 .sysfs_ops = &bus_sysfs_ops,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151};
152
Kay Sievers80f03e32007-05-26 11:21:36 +0200153static int bus_uevent_filter(struct kset *kset, struct kobject *kobj)
154{
155 struct kobj_type *ktype = get_ktype(kobj);
156
157 if (ktype == &bus_ktype)
158 return 1;
159 return 0;
160}
161
Emese Revfy9cd43612009-12-31 14:52:51 +0100162static const struct kset_uevent_ops bus_uevent_ops = {
Kay Sievers80f03e32007-05-26 11:21:36 +0200163 .filter = bus_uevent_filter,
164};
165
Greg Kroah-Hartman59a54832007-10-29 23:22:26 -0500166static struct kset *bus_kset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168
Russell King2139bdd2006-02-07 12:58:20 -0800169#ifdef CONFIG_HOTPLUG
Alan Stern2b08c8d2005-11-23 15:43:50 -0800170/* Manually detach a device from its associated driver. */
Greg Kroah-Hartman151ef382005-06-22 16:09:05 -0700171static ssize_t driver_unbind(struct device_driver *drv,
172 const char *buf, size_t count)
173{
Greg Kroah-Hartman5901d012007-09-13 02:53:13 -0700174 struct bus_type *bus = bus_get(drv->bus);
Greg Kroah-Hartman151ef382005-06-22 16:09:05 -0700175 struct device *dev;
176 int err = -ENODEV;
177
Greg Kroah-Hartman1f9ffc02008-01-27 10:29:20 -0800178 dev = bus_find_device_by_name(bus, NULL, buf);
Alan Stern2b08c8d2005-11-23 15:43:50 -0800179 if (dev && dev->driver == drv) {
Alan Sternbf74ad52005-11-17 16:54:12 -0500180 if (dev->parent) /* Needed for USB */
Greg Kroah-Hartman8e9394c2010-02-17 10:57:05 -0800181 device_lock(dev->parent);
Greg Kroah-Hartman151ef382005-06-22 16:09:05 -0700182 device_release_driver(dev);
Alan Sternbf74ad52005-11-17 16:54:12 -0500183 if (dev->parent)
Greg Kroah-Hartman8e9394c2010-02-17 10:57:05 -0800184 device_unlock(dev->parent);
Greg Kroah-Hartman151ef382005-06-22 16:09:05 -0700185 err = count;
186 }
Alan Stern2b08c8d2005-11-23 15:43:50 -0800187 put_device(dev);
Greg Kroah-Hartmanfc1ede52007-09-13 02:53:13 -0700188 bus_put(bus);
Alan Stern2b08c8d2005-11-23 15:43:50 -0800189 return err;
Greg Kroah-Hartman151ef382005-06-22 16:09:05 -0700190}
191static DRIVER_ATTR(unbind, S_IWUSR, NULL, driver_unbind);
192
Greg Kroah-Hartmanafdce752005-06-22 16:09:05 -0700193/*
194 * Manually attach a device to a driver.
195 * Note: the driver must want to bind to the device,
196 * it is not possible to override the driver's id table.
197 */
198static ssize_t driver_bind(struct device_driver *drv,
199 const char *buf, size_t count)
200{
Greg Kroah-Hartman5901d012007-09-13 02:53:13 -0700201 struct bus_type *bus = bus_get(drv->bus);
Greg Kroah-Hartmanafdce752005-06-22 16:09:05 -0700202 struct device *dev;
203 int err = -ENODEV;
204
Greg Kroah-Hartman1f9ffc02008-01-27 10:29:20 -0800205 dev = bus_find_device_by_name(bus, NULL, buf);
Ming Lei49b420a2009-01-21 23:27:47 +0800206 if (dev && dev->driver == NULL && driver_match_device(drv, dev)) {
Alan Sternbf74ad52005-11-17 16:54:12 -0500207 if (dev->parent) /* Needed for USB */
Greg Kroah-Hartman8e9394c2010-02-17 10:57:05 -0800208 device_lock(dev->parent);
209 device_lock(dev);
Greg Kroah-Hartmanafdce752005-06-22 16:09:05 -0700210 err = driver_probe_device(drv, dev);
Greg Kroah-Hartman8e9394c2010-02-17 10:57:05 -0800211 device_unlock(dev);
Alan Sternbf74ad52005-11-17 16:54:12 -0500212 if (dev->parent)
Greg Kroah-Hartman8e9394c2010-02-17 10:57:05 -0800213 device_unlock(dev->parent);
Ryan Wilson37225402006-03-22 16:26:25 -0500214
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800215 if (err > 0) {
216 /* success */
Ryan Wilson37225402006-03-22 16:26:25 -0500217 err = count;
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800218 } else if (err == 0) {
219 /* driver didn't accept device */
Ryan Wilson37225402006-03-22 16:26:25 -0500220 err = -ENODEV;
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800221 }
Greg Kroah-Hartmanafdce752005-06-22 16:09:05 -0700222 }
Alan Stern2b08c8d2005-11-23 15:43:50 -0800223 put_device(dev);
Greg Kroah-Hartmanfc1ede52007-09-13 02:53:13 -0700224 bus_put(bus);
Alan Stern2b08c8d2005-11-23 15:43:50 -0800225 return err;
Greg Kroah-Hartmanafdce752005-06-22 16:09:05 -0700226}
227static DRIVER_ATTR(bind, S_IWUSR, NULL, driver_bind);
228
Kay Sieversb8c5cec2007-02-16 17:33:36 +0100229static ssize_t show_drivers_autoprobe(struct bus_type *bus, char *buf)
230{
Greg Kroah-Hartmanc6f7e722007-11-01 19:41:16 -0700231 return sprintf(buf, "%d\n", bus->p->drivers_autoprobe);
Kay Sieversb8c5cec2007-02-16 17:33:36 +0100232}
233
234static ssize_t store_drivers_autoprobe(struct bus_type *bus,
235 const char *buf, size_t count)
236{
237 if (buf[0] == '0')
Greg Kroah-Hartmanc6f7e722007-11-01 19:41:16 -0700238 bus->p->drivers_autoprobe = 0;
Kay Sieversb8c5cec2007-02-16 17:33:36 +0100239 else
Greg Kroah-Hartmanc6f7e722007-11-01 19:41:16 -0700240 bus->p->drivers_autoprobe = 1;
Kay Sieversb8c5cec2007-02-16 17:33:36 +0100241 return count;
242}
243
244static ssize_t store_drivers_probe(struct bus_type *bus,
245 const char *buf, size_t count)
246{
247 struct device *dev;
248
Greg Kroah-Hartman1f9ffc02008-01-27 10:29:20 -0800249 dev = bus_find_device_by_name(bus, NULL, buf);
Kay Sieversb8c5cec2007-02-16 17:33:36 +0100250 if (!dev)
251 return -ENODEV;
252 if (bus_rescan_devices_helper(dev, NULL) != 0)
253 return -EINVAL;
254 return count;
255}
Russell King2139bdd2006-02-07 12:58:20 -0800256#endif
Greg Kroah-Hartman151ef382005-06-22 16:09:05 -0700257
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800258static struct device *next_device(struct klist_iter *i)
mochel@digitalimplant.org465c7a32005-03-21 11:49:14 -0800259{
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800260 struct klist_node *n = klist_next(i);
Greg Kroah-Hartmanae1b4172008-12-16 12:26:21 -0800261 struct device *dev = NULL;
262 struct device_private *dev_prv;
263
264 if (n) {
265 dev_prv = to_device_private_bus(n);
266 dev = dev_prv->device;
267 }
268 return dev;
mochel@digitalimplant.org465c7a32005-03-21 11:49:14 -0800269}
270
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271/**
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800272 * bus_for_each_dev - device iterator.
273 * @bus: bus type.
274 * @start: device to start iterating from.
275 * @data: data for the callback.
276 * @fn: function to be called for each device.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277 *
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800278 * Iterate over @bus's list of devices, and call @fn for each,
279 * passing it @data. If @start is not NULL, we use that device to
280 * begin iterating from.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 *
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800282 * We check the return of @fn each time. If it returns anything
283 * other than 0, we break out and return that value.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 *
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800285 * NOTE: The device that returns a non-zero value is not retained
286 * in any way, nor is its refcount incremented. If the caller needs
Alex Chiang0fa1b0a2009-05-14 23:15:22 +0200287 * to retain this data, it should do so, and increment the reference
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800288 * count in the supplied callback.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289 */
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800290int bus_for_each_dev(struct bus_type *bus, struct device *start,
291 void *data, int (*fn)(struct device *, void *))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292{
mochel@digitalimplant.org465c7a32005-03-21 11:49:14 -0800293 struct klist_iter i;
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800294 struct device *dev;
mochel@digitalimplant.org465c7a32005-03-21 11:49:14 -0800295 int error = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296
mochel@digitalimplant.org465c7a32005-03-21 11:49:14 -0800297 if (!bus)
298 return -EINVAL;
299
Greg Kroah-Hartmanc6f7e722007-11-01 19:41:16 -0700300 klist_iter_init_node(&bus->p->klist_devices, &i,
Greg Kroah-Hartmanae1b4172008-12-16 12:26:21 -0800301 (start ? &start->p->knode_bus : NULL));
mochel@digitalimplant.org465c7a32005-03-21 11:49:14 -0800302 while ((dev = next_device(&i)) && !error)
303 error = fn(dev, data);
304 klist_iter_exit(&i);
305 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306}
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800307EXPORT_SYMBOL_GPL(bus_for_each_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308
Cornelia Huck0edb5862005-06-22 16:59:51 +0200309/**
310 * bus_find_device - device iterator for locating a particular device.
311 * @bus: bus type
312 * @start: Device to begin with
313 * @data: Data to pass to match function
314 * @match: Callback function to check device
315 *
316 * This is similar to the bus_for_each_dev() function above, but it
317 * returns a reference to a device that is 'found' for later use, as
318 * determined by the @match callback.
319 *
320 * The callback should return 0 if the device doesn't match and non-zero
321 * if it does. If the callback returns non-zero, this function will
322 * return to the caller and not iterate over any more devices.
323 */
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800324struct device *bus_find_device(struct bus_type *bus,
325 struct device *start, void *data,
326 int (*match)(struct device *dev, void *data))
Cornelia Huck0edb5862005-06-22 16:59:51 +0200327{
328 struct klist_iter i;
329 struct device *dev;
330
331 if (!bus)
332 return NULL;
333
Greg Kroah-Hartmanc6f7e722007-11-01 19:41:16 -0700334 klist_iter_init_node(&bus->p->klist_devices, &i,
Greg Kroah-Hartmanae1b4172008-12-16 12:26:21 -0800335 (start ? &start->p->knode_bus : NULL));
Cornelia Huck0edb5862005-06-22 16:59:51 +0200336 while ((dev = next_device(&i)))
337 if (match(dev, data) && get_device(dev))
338 break;
339 klist_iter_exit(&i);
340 return dev;
341}
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800342EXPORT_SYMBOL_GPL(bus_find_device);
mochel@digitalimplant.org38fdac32005-03-21 12:00:18 -0800343
Greg Kroah-Hartman1f9ffc02008-01-27 10:29:20 -0800344static int match_name(struct device *dev, void *data)
345{
346 const char *name = data;
347
Kay Sievers1e0b2cf2008-10-30 01:36:48 +0100348 return sysfs_streq(name, dev_name(dev));
Greg Kroah-Hartman1f9ffc02008-01-27 10:29:20 -0800349}
350
351/**
352 * bus_find_device_by_name - device iterator for locating a particular device of a specific name
353 * @bus: bus type
354 * @start: Device to begin with
355 * @name: name of the device to match
356 *
357 * This is similar to the bus_find_device() function above, but it handles
358 * searching by a name automatically, no need to write another strcmp matching
359 * function.
360 */
361struct device *bus_find_device_by_name(struct bus_type *bus,
362 struct device *start, const char *name)
363{
364 return bus_find_device(bus, start, (void *)name, match_name);
365}
366EXPORT_SYMBOL_GPL(bus_find_device_by_name);
367
Kay Sieversca22e562011-12-14 14:29:38 -0800368/**
369 * subsys_find_device_by_id - find a device with a specific enumeration number
370 * @subsys: subsystem
371 * @id: index 'id' in struct device
372 * @hint: device to check first
373 *
374 * Check the hint's next object and if it is a match return it directly,
375 * otherwise, fall back to a full list search. Either way a reference for
376 * the returned object is taken.
377 */
378struct device *subsys_find_device_by_id(struct bus_type *subsys, unsigned int id,
379 struct device *hint)
380{
381 struct klist_iter i;
382 struct device *dev;
383
384 if (!subsys)
385 return NULL;
386
387 if (hint) {
388 klist_iter_init_node(&subsys->p->klist_devices, &i, &hint->p->knode_bus);
389 dev = next_device(&i);
390 if (dev && dev->id == id && get_device(dev)) {
391 klist_iter_exit(&i);
392 return dev;
393 }
394 klist_iter_exit(&i);
395 }
396
397 klist_iter_init_node(&subsys->p->klist_devices, &i, NULL);
398 while ((dev = next_device(&i))) {
399 if (dev->id == id && get_device(dev)) {
400 klist_iter_exit(&i);
401 return dev;
402 }
403 }
404 klist_iter_exit(&i);
405 return NULL;
406}
407EXPORT_SYMBOL_GPL(subsys_find_device_by_id);
408
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800409static struct device_driver *next_driver(struct klist_iter *i)
mochel@digitalimplant.org38fdac32005-03-21 12:00:18 -0800410{
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800411 struct klist_node *n = klist_next(i);
Greg Kroah-Hartmane5dd1272007-11-28 15:59:15 -0800412 struct driver_private *drv_priv;
413
414 if (n) {
415 drv_priv = container_of(n, struct driver_private, knode_bus);
416 return drv_priv->driver;
417 }
418 return NULL;
mochel@digitalimplant.org38fdac32005-03-21 12:00:18 -0800419}
420
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421/**
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800422 * bus_for_each_drv - driver iterator
423 * @bus: bus we're dealing with.
424 * @start: driver to start iterating on.
425 * @data: data to pass to the callback.
426 * @fn: function to call for each driver.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 *
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800428 * This is nearly identical to the device iterator above.
429 * We iterate over each driver that belongs to @bus, and call
430 * @fn for each. If @fn returns anything but 0, we break out
431 * and return it. If @start is not NULL, we use it as the head
432 * of the list.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 *
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800434 * NOTE: we don't return the driver that returns a non-zero
435 * value, nor do we leave the reference count incremented for that
436 * driver. If the caller needs to know that info, it must set it
437 * in the callback. It must also be sure to increment the refcount
438 * so it doesn't disappear before returning to the caller.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 */
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800440int bus_for_each_drv(struct bus_type *bus, struct device_driver *start,
441 void *data, int (*fn)(struct device_driver *, void *))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442{
mochel@digitalimplant.org38fdac32005-03-21 12:00:18 -0800443 struct klist_iter i;
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800444 struct device_driver *drv;
mochel@digitalimplant.org38fdac32005-03-21 12:00:18 -0800445 int error = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446
mochel@digitalimplant.org38fdac32005-03-21 12:00:18 -0800447 if (!bus)
448 return -EINVAL;
449
Greg Kroah-Hartmanc6f7e722007-11-01 19:41:16 -0700450 klist_iter_init_node(&bus->p->klist_drivers, &i,
Greg Kroah-Hartmane5dd1272007-11-28 15:59:15 -0800451 start ? &start->p->knode_bus : NULL);
mochel@digitalimplant.org38fdac32005-03-21 12:00:18 -0800452 while ((drv = next_driver(&i)) && !error)
453 error = fn(drv, data);
454 klist_iter_exit(&i);
455 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456}
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800457EXPORT_SYMBOL_GPL(bus_for_each_drv);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458
Andrew Morton4aca67e2007-02-13 22:39:26 -0800459static int device_add_attrs(struct bus_type *bus, struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460{
461 int error = 0;
462 int i;
463
Andrew Morton4aca67e2007-02-13 22:39:26 -0800464 if (!bus->dev_attrs)
465 return 0;
466
467 for (i = 0; attr_name(bus->dev_attrs[i]); i++) {
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800468 error = device_create_file(dev, &bus->dev_attrs[i]);
Andrew Morton4aca67e2007-02-13 22:39:26 -0800469 if (error) {
470 while (--i >= 0)
471 device_remove_file(dev, &bus->dev_attrs[i]);
472 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473 }
474 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476}
477
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800478static void device_remove_attrs(struct bus_type *bus, struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479{
480 int i;
481
482 if (bus->dev_attrs) {
483 for (i = 0; attr_name(bus->dev_attrs[i]); i++)
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800484 device_remove_file(dev, &bus->dev_attrs[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485 }
486}
487
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488/**
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800489 * bus_add_device - add device to bus
490 * @dev: device being added
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491 *
Alan Stern2023c612009-07-30 15:27:18 -0400492 * - Add device's bus attributes.
493 * - Create links to device's bus.
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800494 * - Add the device to its bus's list of devices.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495 */
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800496int bus_add_device(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497{
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800498 struct bus_type *bus = bus_get(dev->bus);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499 int error = 0;
500
501 if (bus) {
Kay Sievers1e0b2cf2008-10-30 01:36:48 +0100502 pr_debug("bus: '%s': add device %s\n", bus->name, dev_name(dev));
Greg Kroah-Hartmand377e852005-06-22 16:09:05 -0700503 error = device_add_attrs(bus, dev);
Andrew Mortonf86db392006-08-14 22:43:20 -0700504 if (error)
Cornelia Huck513e7332006-09-22 11:37:08 +0200505 goto out_put;
Greg Kroah-Hartmanc6f7e722007-11-01 19:41:16 -0700506 error = sysfs_create_link(&bus->p->devices_kset->kobj,
Kay Sievers1e0b2cf2008-10-30 01:36:48 +0100507 &dev->kobj, dev_name(dev));
Andrew Mortonf86db392006-08-14 22:43:20 -0700508 if (error)
Cornelia Huck513e7332006-09-22 11:37:08 +0200509 goto out_id;
Andrew Mortonf86db392006-08-14 22:43:20 -0700510 error = sysfs_create_link(&dev->kobj,
Greg Kroah-Hartmanc6f7e722007-11-01 19:41:16 -0700511 &dev->bus->p->subsys.kobj, "subsystem");
Andrew Mortonf86db392006-08-14 22:43:20 -0700512 if (error)
Cornelia Huck513e7332006-09-22 11:37:08 +0200513 goto out_subsys;
Alan Stern2023c612009-07-30 15:27:18 -0400514 klist_add_tail(&dev->p->knode_bus, &bus->p->klist_devices);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515 }
Cornelia Huck513e7332006-09-22 11:37:08 +0200516 return 0;
517
Cornelia Huck513e7332006-09-22 11:37:08 +0200518out_subsys:
Kay Sievers1e0b2cf2008-10-30 01:36:48 +0100519 sysfs_remove_link(&bus->p->devices_kset->kobj, dev_name(dev));
Cornelia Huck513e7332006-09-22 11:37:08 +0200520out_id:
521 device_remove_attrs(bus, dev);
522out_put:
Greg Kroah-Hartmanfc1ede52007-09-13 02:53:13 -0700523 bus_put(dev->bus);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524 return error;
525}
526
527/**
Alan Stern2023c612009-07-30 15:27:18 -0400528 * bus_probe_device - probe drivers for a new device
529 * @dev: device to probe
Kay Sievers53877d02006-04-04 20:42:26 +0200530 *
Alan Stern2023c612009-07-30 15:27:18 -0400531 * - Automatically probe for a driver if the bus allows it.
Kay Sievers53877d02006-04-04 20:42:26 +0200532 */
Alan Stern2023c612009-07-30 15:27:18 -0400533void bus_probe_device(struct device *dev)
Kay Sievers53877d02006-04-04 20:42:26 +0200534{
Andrew Mortonf86db392006-08-14 22:43:20 -0700535 struct bus_type *bus = dev->bus;
Kay Sieversca22e562011-12-14 14:29:38 -0800536 struct subsys_interface *sif;
Alan Stern2023c612009-07-30 15:27:18 -0400537 int ret;
Kay Sievers53877d02006-04-04 20:42:26 +0200538
Kay Sieversca22e562011-12-14 14:29:38 -0800539 if (!bus)
540 return;
541
542 if (bus->p->drivers_autoprobe) {
Alan Stern2023c612009-07-30 15:27:18 -0400543 ret = device_attach(dev);
Cornelia Huckc6a46692007-02-05 16:15:26 -0800544 WARN_ON(ret < 0);
Kay Sievers53877d02006-04-04 20:42:26 +0200545 }
Kay Sieversca22e562011-12-14 14:29:38 -0800546
547 mutex_lock(&bus->p->mutex);
548 list_for_each_entry(sif, &bus->p->interfaces, node)
549 if (sif->add_dev)
550 sif->add_dev(dev, sif);
551 mutex_unlock(&bus->p->mutex);
Kay Sievers53877d02006-04-04 20:42:26 +0200552}
553
554/**
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800555 * bus_remove_device - remove device from bus
556 * @dev: device to be removed
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 *
Kay Sieversca22e562011-12-14 14:29:38 -0800558 * - Remove device from all interfaces.
559 * - Remove symlink from bus' directory.
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800560 * - Delete device from bus's list.
561 * - Detach from its driver.
562 * - Drop reference taken in bus_add_device().
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563 */
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800564void bus_remove_device(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565{
Kay Sieversca22e562011-12-14 14:29:38 -0800566 struct bus_type *bus = dev->bus;
567 struct subsys_interface *sif;
Greg Kroah-Hartman3f62e572008-03-13 17:07:03 -0400568
Kay Sieversca22e562011-12-14 14:29:38 -0800569 if (!bus)
570 return;
571
572 mutex_lock(&bus->p->mutex);
573 list_for_each_entry(sif, &bus->p->interfaces, node)
574 if (sif->remove_dev)
575 sif->remove_dev(dev, sif);
576 mutex_unlock(&bus->p->mutex);
577
578 sysfs_remove_link(&dev->kobj, "subsystem");
579 sysfs_remove_link(&dev->bus->p->devices_kset->kobj,
580 dev_name(dev));
581 device_remove_attrs(dev->bus, dev);
582 if (klist_node_attached(&dev->p->knode_bus))
583 klist_del(&dev->p->knode_bus);
584
585 pr_debug("bus: '%s': remove device %s\n",
586 dev->bus->name, dev_name(dev));
587 device_release_driver(dev);
588 bus_put(dev->bus);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589}
590
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800591static int driver_add_attrs(struct bus_type *bus, struct device_driver *drv)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592{
593 int error = 0;
594 int i;
595
596 if (bus->drv_attrs) {
597 for (i = 0; attr_name(bus->drv_attrs[i]); i++) {
598 error = driver_create_file(drv, &bus->drv_attrs[i]);
599 if (error)
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800600 goto err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601 }
602 }
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800603done:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604 return error;
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800605err:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 while (--i >= 0)
607 driver_remove_file(drv, &bus->drv_attrs[i]);
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800608 goto done;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609}
610
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800611static void driver_remove_attrs(struct bus_type *bus,
612 struct device_driver *drv)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613{
614 int i;
615
616 if (bus->drv_attrs) {
617 for (i = 0; attr_name(bus->drv_attrs[i]); i++)
618 driver_remove_file(drv, &bus->drv_attrs[i]);
619 }
620}
621
Greg Kroah-Hartman874c6242005-12-13 15:17:34 -0800622#ifdef CONFIG_HOTPLUG
623/*
624 * Thanks to drivers making their tables __devinit, we can't allow manual
625 * bind and unbind from userspace unless CONFIG_HOTPLUG is enabled.
626 */
Andrew Mortonf86db392006-08-14 22:43:20 -0700627static int __must_check add_bind_files(struct device_driver *drv)
Greg Kroah-Hartman874c6242005-12-13 15:17:34 -0800628{
Andrew Mortonf86db392006-08-14 22:43:20 -0700629 int ret;
630
631 ret = driver_create_file(drv, &driver_attr_unbind);
632 if (ret == 0) {
633 ret = driver_create_file(drv, &driver_attr_bind);
634 if (ret)
635 driver_remove_file(drv, &driver_attr_unbind);
636 }
637 return ret;
Greg Kroah-Hartman874c6242005-12-13 15:17:34 -0800638}
639
640static void remove_bind_files(struct device_driver *drv)
641{
642 driver_remove_file(drv, &driver_attr_bind);
643 driver_remove_file(drv, &driver_attr_unbind);
644}
Kay Sieversb8c5cec2007-02-16 17:33:36 +0100645
Kay Sievers83807702007-07-30 02:28:56 +0200646static BUS_ATTR(drivers_probe, S_IWUSR, NULL, store_drivers_probe);
647static BUS_ATTR(drivers_autoprobe, S_IWUSR | S_IRUGO,
648 show_drivers_autoprobe, store_drivers_autoprobe);
649
Kay Sieversb8c5cec2007-02-16 17:33:36 +0100650static int add_probe_files(struct bus_type *bus)
651{
652 int retval;
653
Kay Sievers83807702007-07-30 02:28:56 +0200654 retval = bus_create_file(bus, &bus_attr_drivers_probe);
Kay Sieversb8c5cec2007-02-16 17:33:36 +0100655 if (retval)
656 goto out;
657
Kay Sievers83807702007-07-30 02:28:56 +0200658 retval = bus_create_file(bus, &bus_attr_drivers_autoprobe);
Kay Sieversb8c5cec2007-02-16 17:33:36 +0100659 if (retval)
Kay Sievers83807702007-07-30 02:28:56 +0200660 bus_remove_file(bus, &bus_attr_drivers_probe);
Kay Sieversb8c5cec2007-02-16 17:33:36 +0100661out:
662 return retval;
663}
664
665static void remove_probe_files(struct bus_type *bus)
666{
Kay Sievers83807702007-07-30 02:28:56 +0200667 bus_remove_file(bus, &bus_attr_drivers_autoprobe);
668 bus_remove_file(bus, &bus_attr_drivers_probe);
Kay Sieversb8c5cec2007-02-16 17:33:36 +0100669}
Greg Kroah-Hartman874c6242005-12-13 15:17:34 -0800670#else
Yoichi Yuasa35acfdd2006-07-15 01:30:11 +0900671static inline int add_bind_files(struct device_driver *drv) { return 0; }
Greg Kroah-Hartman874c6242005-12-13 15:17:34 -0800672static inline void remove_bind_files(struct device_driver *drv) {}
Kay Sieversb8c5cec2007-02-16 17:33:36 +0100673static inline int add_probe_files(struct bus_type *bus) { return 0; }
674static inline void remove_probe_files(struct bus_type *bus) {}
Greg Kroah-Hartman874c6242005-12-13 15:17:34 -0800675#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676
Kay Sievers7ac1cf42007-08-12 20:43:55 +0200677static ssize_t driver_uevent_store(struct device_driver *drv,
678 const char *buf, size_t count)
679{
680 enum kobject_action action;
681
682 if (kobject_action_type(buf, count, &action) == 0)
Greg Kroah-Hartmane5dd1272007-11-28 15:59:15 -0800683 kobject_uevent(&drv->p->kobj, action);
Kay Sievers7ac1cf42007-08-12 20:43:55 +0200684 return count;
685}
686static DRIVER_ATTR(uevent, S_IWUSR, NULL, driver_uevent_store);
687
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688/**
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800689 * bus_add_driver - Add a driver to the bus.
690 * @drv: driver.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691 */
Andrew Mortonf86db392006-08-14 22:43:20 -0700692int bus_add_driver(struct device_driver *drv)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693{
Greg Kroah-Hartmane5dd1272007-11-28 15:59:15 -0800694 struct bus_type *bus;
695 struct driver_private *priv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696 int error = 0;
697
Greg Kroah-Hartmane5dd1272007-11-28 15:59:15 -0800698 bus = bus_get(drv->bus);
Jeff Garzikd9fd4d3b32006-10-04 07:48:03 -0400699 if (!bus)
Greg Kroah-Hartman4f6e1942007-04-20 11:29:52 -0700700 return -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701
Greg Kroah-Hartman7dc72b22007-11-28 23:49:41 -0800702 pr_debug("bus: '%s': add driver %s\n", bus->name, drv->name);
Greg Kroah-Hartmane5dd1272007-11-28 15:59:15 -0800703
704 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
Cornelia Huck07634462008-02-18 17:04:25 +0100705 if (!priv) {
706 error = -ENOMEM;
707 goto out_put_bus;
708 }
Greg Kroah-Hartmane5dd1272007-11-28 15:59:15 -0800709 klist_init(&priv->klist_devices, NULL, NULL);
710 priv->driver = drv;
711 drv->p = priv;
Greg Kroah-Hartmanc8e90d82007-12-17 15:54:39 -0400712 priv->kobj.kset = bus->p->drivers_kset;
713 error = kobject_init_and_add(&priv->kobj, &driver_ktype, NULL,
714 "%s", drv->name);
Cornelia Huckdc0afa82007-07-09 11:39:18 -0700715 if (error)
Cornelia Huck07634462008-02-18 17:04:25 +0100716 goto out_unregister;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717
Sagar Dharia1672c642013-06-07 13:11:54 -0600718 klist_add_tail(&priv->knode_bus, &bus->p->klist_drivers);
Greg Kroah-Hartmanc6f7e722007-11-01 19:41:16 -0700719 if (drv->bus->p->drivers_autoprobe) {
Kay Sieversb8c5cec2007-02-16 17:33:36 +0100720 error = driver_attach(drv);
721 if (error)
722 goto out_unregister;
723 }
Jeff Garzikd9fd4d3b32006-10-04 07:48:03 -0400724 module_add_driver(drv->owner, drv);
725
Kay Sievers7ac1cf42007-08-12 20:43:55 +0200726 error = driver_create_file(drv, &driver_attr_uevent);
727 if (error) {
728 printk(KERN_ERR "%s: uevent attr (%s) failed\n",
Harvey Harrison2b3a3022008-03-04 16:41:05 -0800729 __func__, drv->name);
Kay Sievers7ac1cf42007-08-12 20:43:55 +0200730 }
Jeff Garzikd9fd4d3b32006-10-04 07:48:03 -0400731 error = driver_add_attrs(bus, drv);
732 if (error) {
733 /* How the hell do we get out of this pickle? Give up */
734 printk(KERN_ERR "%s: driver_add_attrs(%s) failed\n",
Harvey Harrison2b3a3022008-03-04 16:41:05 -0800735 __func__, drv->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 }
Dmitry Torokhov1a6f2a72009-10-12 20:17:41 -0700737
738 if (!drv->suppress_bind_attrs) {
739 error = add_bind_files(drv);
740 if (error) {
741 /* Ditto */
742 printk(KERN_ERR "%s: add_bind_files(%s) failed\n",
743 __func__, drv->name);
744 }
Jeff Garzikd9fd4d3b32006-10-04 07:48:03 -0400745 }
746
Greg Kroah-Hartmanc8e90d82007-12-17 15:54:39 -0400747 kobject_uevent(&priv->kobj, KOBJ_ADD);
Kay Sievers5c8563d2009-05-28 14:24:07 -0700748 return 0;
Dmitry Torokhov1a6f2a72009-10-12 20:17:41 -0700749
Andrew Mortonf86db392006-08-14 22:43:20 -0700750out_unregister:
Phil Carmody99b28f12009-12-14 20:28:12 +0200751 kobject_put(&priv->kobj);
Kay Sievers5c8563d2009-05-28 14:24:07 -0700752 kfree(drv->p);
753 drv->p = NULL;
Andrew Mortonf86db392006-08-14 22:43:20 -0700754out_put_bus:
Greg Kroah-Hartmanfc1ede52007-09-13 02:53:13 -0700755 bus_put(bus);
Andrew Mortonf86db392006-08-14 22:43:20 -0700756 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757}
758
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759/**
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800760 * bus_remove_driver - delete driver from bus's knowledge.
761 * @drv: driver.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762 *
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800763 * Detach the driver from the devices it controls, and remove
764 * it from its bus's list of drivers. Finally, we drop the reference
765 * to the bus we took in bus_add_driver().
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766 */
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800767void bus_remove_driver(struct device_driver *drv)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768{
Jeff Garzikd9fd4d3b32006-10-04 07:48:03 -0400769 if (!drv->bus)
770 return;
771
Dmitry Torokhov1a6f2a72009-10-12 20:17:41 -0700772 if (!drv->suppress_bind_attrs)
773 remove_bind_files(drv);
Jeff Garzikd9fd4d3b32006-10-04 07:48:03 -0400774 driver_remove_attrs(drv->bus, drv);
Kay Sievers7ac1cf42007-08-12 20:43:55 +0200775 driver_remove_file(drv, &driver_attr_uevent);
Greg Kroah-Hartmane5dd1272007-11-28 15:59:15 -0800776 klist_remove(&drv->p->knode_bus);
Greg Kroah-Hartman7dc72b22007-11-28 23:49:41 -0800777 pr_debug("bus: '%s': remove driver %s\n", drv->bus->name, drv->name);
Jeff Garzikd9fd4d3b32006-10-04 07:48:03 -0400778 driver_detach(drv);
779 module_remove_driver(drv);
Greg Kroah-Hartmanc10997f2007-12-20 08:13:05 -0800780 kobject_put(&drv->p->kobj);
Greg Kroah-Hartmanfc1ede52007-09-13 02:53:13 -0700781 bus_put(drv->bus);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782}
783
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784/* Helper for bus_rescan_devices's iter */
Andrew Mortonf86db392006-08-14 22:43:20 -0700785static int __must_check bus_rescan_devices_helper(struct device *dev,
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800786 void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787{
Andrew Mortonf86db392006-08-14 22:43:20 -0700788 int ret = 0;
789
Alan Sternbf74ad52005-11-17 16:54:12 -0500790 if (!dev->driver) {
791 if (dev->parent) /* Needed for USB */
Greg Kroah-Hartman8e9394c2010-02-17 10:57:05 -0800792 device_lock(dev->parent);
Andrew Mortonf86db392006-08-14 22:43:20 -0700793 ret = device_attach(dev);
Alan Sternbf74ad52005-11-17 16:54:12 -0500794 if (dev->parent)
Greg Kroah-Hartman8e9394c2010-02-17 10:57:05 -0800795 device_unlock(dev->parent);
Alan Sternbf74ad52005-11-17 16:54:12 -0500796 }
Andrew Mortonf86db392006-08-14 22:43:20 -0700797 return ret < 0 ? ret : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798}
799
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800/**
Greg Kroah-Hartman23d3d602005-06-22 16:09:05 -0700801 * bus_rescan_devices - rescan devices on the bus for possible drivers
802 * @bus: the bus to scan.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 *
Greg Kroah-Hartman23d3d602005-06-22 16:09:05 -0700804 * This function will look for devices on the bus with no driver
805 * attached and rescan it against existing drivers to see if it matches
806 * any by calling device_attach() for the unbound devices.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807 */
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800808int bus_rescan_devices(struct bus_type *bus)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809{
Andrew Mortonf86db392006-08-14 22:43:20 -0700810 return bus_for_each_dev(bus, NULL, NULL, bus_rescan_devices_helper);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811}
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800812EXPORT_SYMBOL_GPL(bus_rescan_devices);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813
Moore, Erice935d5d2006-03-14 09:18:18 -0700814/**
815 * device_reprobe - remove driver for a device and probe for a new driver
816 * @dev: the device to reprobe
817 *
818 * This function detaches the attached driver (if any) for the given
819 * device and restarts the driver probing process. It is intended
820 * to use if probing criteria changed during a devices lifetime and
821 * driver attachment should change accordingly.
822 */
Andrew Mortonf86db392006-08-14 22:43:20 -0700823int device_reprobe(struct device *dev)
Moore, Erice935d5d2006-03-14 09:18:18 -0700824{
825 if (dev->driver) {
826 if (dev->parent) /* Needed for USB */
Greg Kroah-Hartman8e9394c2010-02-17 10:57:05 -0800827 device_lock(dev->parent);
Moore, Erice935d5d2006-03-14 09:18:18 -0700828 device_release_driver(dev);
829 if (dev->parent)
Greg Kroah-Hartman8e9394c2010-02-17 10:57:05 -0800830 device_unlock(dev->parent);
Moore, Erice935d5d2006-03-14 09:18:18 -0700831 }
Andrew Mortonf86db392006-08-14 22:43:20 -0700832 return bus_rescan_devices_helper(dev, NULL);
Moore, Erice935d5d2006-03-14 09:18:18 -0700833}
834EXPORT_SYMBOL_GPL(device_reprobe);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836/**
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800837 * find_bus - locate bus by name.
838 * @name: name of bus.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839 *
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800840 * Call kset_find_obj() to iterate over list of buses to
841 * find a bus by name. Return bus if found.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842 *
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800843 * Note that kset_find_obj increments bus' reference count.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844 */
Adrian Bunk7e4ef082006-06-26 22:26:56 +0200845#if 0
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800846struct bus_type *find_bus(char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847{
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800848 struct kobject *k = kset_find_obj(bus_kset, name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849 return k ? to_bus(k) : NULL;
850}
Adrian Bunk7e4ef082006-06-26 22:26:56 +0200851#endif /* 0 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852
853
854/**
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800855 * bus_add_attrs - Add default attributes for this bus.
856 * @bus: Bus that has just been registered.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857 */
858
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800859static int bus_add_attrs(struct bus_type *bus)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860{
861 int error = 0;
862 int i;
863
864 if (bus->bus_attrs) {
865 for (i = 0; attr_name(bus->bus_attrs[i]); i++) {
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800866 error = bus_create_file(bus, &bus->bus_attrs[i]);
Cornelia Huckdc0afa82007-07-09 11:39:18 -0700867 if (error)
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800868 goto err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869 }
870 }
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800871done:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872 return error;
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800873err:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874 while (--i >= 0)
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800875 bus_remove_file(bus, &bus->bus_attrs[i]);
876 goto done;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877}
878
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800879static void bus_remove_attrs(struct bus_type *bus)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880{
881 int i;
882
883 if (bus->bus_attrs) {
884 for (i = 0; attr_name(bus->bus_attrs[i]); i++)
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800885 bus_remove_file(bus, &bus->bus_attrs[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886 }
887}
888
James Bottomley34bb61f2005-09-06 16:56:51 -0700889static void klist_devices_get(struct klist_node *n)
890{
Greg Kroah-Hartmanae1b4172008-12-16 12:26:21 -0800891 struct device_private *dev_prv = to_device_private_bus(n);
892 struct device *dev = dev_prv->device;
James Bottomley34bb61f2005-09-06 16:56:51 -0700893
894 get_device(dev);
895}
896
897static void klist_devices_put(struct klist_node *n)
898{
Greg Kroah-Hartmanae1b4172008-12-16 12:26:21 -0800899 struct device_private *dev_prv = to_device_private_bus(n);
900 struct device *dev = dev_prv->device;
James Bottomley34bb61f2005-09-06 16:56:51 -0700901
902 put_device(dev);
903}
904
Kay Sievers7ac1cf42007-08-12 20:43:55 +0200905static ssize_t bus_uevent_store(struct bus_type *bus,
906 const char *buf, size_t count)
907{
908 enum kobject_action action;
909
910 if (kobject_action_type(buf, count, &action) == 0)
Greg Kroah-Hartmanc6f7e722007-11-01 19:41:16 -0700911 kobject_uevent(&bus->p->subsys.kobj, action);
Kay Sievers7ac1cf42007-08-12 20:43:55 +0200912 return count;
913}
914static BUS_ATTR(uevent, S_IWUSR, NULL, bus_uevent_store);
915
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916/**
Kay Sieversca22e562011-12-14 14:29:38 -0800917 * __bus_register - register a driver-core subsystem
Randy Dunlap78d79552012-01-21 11:02:28 -0800918 * @bus: bus to register
919 * @key: lockdep class key
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920 *
Randy Dunlap78d79552012-01-21 11:02:28 -0800921 * Once we have that, we register the bus with the kobject
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -0800922 * infrastructure, then register the children subsystems it has:
Kay Sieversca22e562011-12-14 14:29:38 -0800923 * the devices and drivers that belong to the subsystem.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924 */
Kay Sieversca22e562011-12-14 14:29:38 -0800925int __bus_register(struct bus_type *bus, struct lock_class_key *key)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926{
927 int retval;
Kay Sievers6b6e39a2010-11-15 23:13:18 +0100928 struct subsys_private *priv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929
Kay Sievers6b6e39a2010-11-15 23:13:18 +0100930 priv = kzalloc(sizeof(struct subsys_private), GFP_KERNEL);
Greg Kroah-Hartmanc6f7e722007-11-01 19:41:16 -0700931 if (!priv)
932 return -ENOMEM;
Benjamin Herrenschmidt116af372006-10-25 13:44:59 +1000933
Greg Kroah-Hartmanc6f7e722007-11-01 19:41:16 -0700934 priv->bus = bus;
935 bus->p = priv;
936
937 BLOCKING_INIT_NOTIFIER_HEAD(&priv->bus_notifier);
938
939 retval = kobject_set_name(&priv->subsys.kobj, "%s", bus->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700940 if (retval)
941 goto out;
942
Greg Kroah-Hartmanc6f7e722007-11-01 19:41:16 -0700943 priv->subsys.kobj.kset = bus_kset;
944 priv->subsys.kobj.ktype = &bus_ktype;
945 priv->drivers_autoprobe = 1;
Greg Kroah-Hartmand6b05b82007-09-12 15:06:57 -0700946
Greg Kroah-Hartmanc6f7e722007-11-01 19:41:16 -0700947 retval = kset_register(&priv->subsys);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700948 if (retval)
949 goto out;
950
Kay Sievers7ac1cf42007-08-12 20:43:55 +0200951 retval = bus_create_file(bus, &bus_attr_uevent);
952 if (retval)
953 goto bus_uevent_fail;
954
Greg Kroah-Hartmanc6f7e722007-11-01 19:41:16 -0700955 priv->devices_kset = kset_create_and_add("devices", NULL,
956 &priv->subsys.kobj);
957 if (!priv->devices_kset) {
Greg Kroah-Hartman3d899592007-11-01 13:31:26 -0700958 retval = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959 goto bus_devices_fail;
Greg Kroah-Hartman3d899592007-11-01 13:31:26 -0700960 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700961
Greg Kroah-Hartmanc6f7e722007-11-01 19:41:16 -0700962 priv->drivers_kset = kset_create_and_add("drivers", NULL,
963 &priv->subsys.kobj);
964 if (!priv->drivers_kset) {
Greg Kroah-Hartman6dcec252007-11-01 13:31:26 -0700965 retval = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966 goto bus_drivers_fail;
Greg Kroah-Hartman6dcec252007-11-01 13:31:26 -0700967 }
mochel@digitalimplant.org465c7a32005-03-21 11:49:14 -0800968
Kay Sieversca22e562011-12-14 14:29:38 -0800969 INIT_LIST_HEAD(&priv->interfaces);
970 __mutex_init(&priv->mutex, "subsys mutex", key);
Greg Kroah-Hartmanc6f7e722007-11-01 19:41:16 -0700971 klist_init(&priv->klist_devices, klist_devices_get, klist_devices_put);
972 klist_init(&priv->klist_drivers, NULL, NULL);
Kay Sieversb8c5cec2007-02-16 17:33:36 +0100973
Kay Sieversb8c5cec2007-02-16 17:33:36 +0100974 retval = add_probe_files(bus);
975 if (retval)
976 goto bus_probe_files_fail;
977
Cornelia Huck1bb68812006-09-22 11:37:04 +0200978 retval = bus_add_attrs(bus);
979 if (retval)
980 goto bus_attrs_fail;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981
Greg Kroah-Hartman7dc72b22007-11-28 23:49:41 -0800982 pr_debug("bus: '%s': registered\n", bus->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983 return 0;
984
Cornelia Huck1bb68812006-09-22 11:37:04 +0200985bus_attrs_fail:
Kay Sieversb8c5cec2007-02-16 17:33:36 +0100986 remove_probe_files(bus);
987bus_probe_files_fail:
Greg Kroah-Hartmanc6f7e722007-11-01 19:41:16 -0700988 kset_unregister(bus->p->drivers_kset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989bus_drivers_fail:
Greg Kroah-Hartmanc6f7e722007-11-01 19:41:16 -0700990 kset_unregister(bus->p->devices_kset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991bus_devices_fail:
Kay Sievers7ac1cf42007-08-12 20:43:55 +0200992 bus_remove_file(bus, &bus_attr_uevent);
993bus_uevent_fail:
Greg Kroah-Hartmanc6f7e722007-11-01 19:41:16 -0700994 kset_unregister(&bus->p->subsys);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995out:
Jike Song600c20f2010-07-15 17:43:54 +0800996 kfree(bus->p);
Dave Youngf48f3fe2009-02-14 21:23:22 +0800997 bus->p = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998 return retval;
999}
Kay Sieversca22e562011-12-14 14:29:38 -08001000EXPORT_SYMBOL_GPL(__bus_register);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001
Linus Torvalds1da177e2005-04-16 15:20:36 -07001002/**
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -08001003 * bus_unregister - remove a bus from the system
1004 * @bus: bus.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005 *
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -08001006 * Unregister the child subsystems and the bus itself.
1007 * Finally, we call bus_put() to release the refcount
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008 */
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -08001009void bus_unregister(struct bus_type *bus)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010{
Greg Kroah-Hartman7dc72b22007-11-28 23:49:41 -08001011 pr_debug("bus: '%s': unregistering\n", bus->name);
Kay Sieversca22e562011-12-14 14:29:38 -08001012 if (bus->dev_root)
1013 device_unregister(bus->dev_root);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014 bus_remove_attrs(bus);
Kay Sieversb8c5cec2007-02-16 17:33:36 +01001015 remove_probe_files(bus);
Greg Kroah-Hartmanc6f7e722007-11-01 19:41:16 -07001016 kset_unregister(bus->p->drivers_kset);
1017 kset_unregister(bus->p->devices_kset);
Kay Sievers7ac1cf42007-08-12 20:43:55 +02001018 bus_remove_file(bus, &bus_attr_uevent);
Greg Kroah-Hartmanc6f7e722007-11-01 19:41:16 -07001019 kset_unregister(&bus->p->subsys);
1020 kfree(bus->p);
Dave Youngf48f3fe2009-02-14 21:23:22 +08001021 bus->p = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022}
Greg Kroah-Hartman4a3ad202008-01-24 22:50:12 -08001023EXPORT_SYMBOL_GPL(bus_unregister);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024
Benjamin Herrenschmidt116af372006-10-25 13:44:59 +10001025int bus_register_notifier(struct bus_type *bus, struct notifier_block *nb)
1026{
Greg Kroah-Hartmanc6f7e722007-11-01 19:41:16 -07001027 return blocking_notifier_chain_register(&bus->p->bus_notifier, nb);
Benjamin Herrenschmidt116af372006-10-25 13:44:59 +10001028}
1029EXPORT_SYMBOL_GPL(bus_register_notifier);
1030
1031int bus_unregister_notifier(struct bus_type *bus, struct notifier_block *nb)
1032{
Greg Kroah-Hartmanc6f7e722007-11-01 19:41:16 -07001033 return blocking_notifier_chain_unregister(&bus->p->bus_notifier, nb);
Benjamin Herrenschmidt116af372006-10-25 13:44:59 +10001034}
1035EXPORT_SYMBOL_GPL(bus_unregister_notifier);
1036
Greg Kroah-Hartman0fed80f2007-11-01 19:41:16 -07001037struct kset *bus_get_kset(struct bus_type *bus)
1038{
Greg Kroah-Hartmanc6f7e722007-11-01 19:41:16 -07001039 return &bus->p->subsys;
Greg Kroah-Hartman0fed80f2007-11-01 19:41:16 -07001040}
1041EXPORT_SYMBOL_GPL(bus_get_kset);
1042
Greg Kroah-Hartmanb2490722007-11-01 19:41:16 -07001043struct klist *bus_get_device_klist(struct bus_type *bus)
1044{
Greg Kroah-Hartmanc6f7e722007-11-01 19:41:16 -07001045 return &bus->p->klist_devices;
Greg Kroah-Hartmanb2490722007-11-01 19:41:16 -07001046}
1047EXPORT_SYMBOL_GPL(bus_get_device_klist);
1048
Greg Kroah-Hartman99178b02008-08-26 11:00:57 -05001049/*
Robert P. J. Daydca25eb2010-11-21 08:15:01 -05001050 * Yes, this forcibly breaks the klist abstraction temporarily. It
Greg Kroah-Hartman99178b02008-08-26 11:00:57 -05001051 * just wants to sort the klist, not change reference counts and
1052 * take/drop locks rapidly in the process. It does all this while
1053 * holding the lock for the list, so objects can't otherwise be
1054 * added/removed while we're swizzling.
1055 */
1056static void device_insertion_sort_klist(struct device *a, struct list_head *list,
1057 int (*compare)(const struct device *a,
1058 const struct device *b))
1059{
1060 struct list_head *pos;
1061 struct klist_node *n;
Greg Kroah-Hartmanae1b4172008-12-16 12:26:21 -08001062 struct device_private *dev_prv;
Greg Kroah-Hartman99178b02008-08-26 11:00:57 -05001063 struct device *b;
1064
1065 list_for_each(pos, list) {
1066 n = container_of(pos, struct klist_node, n_node);
Greg Kroah-Hartmanae1b4172008-12-16 12:26:21 -08001067 dev_prv = to_device_private_bus(n);
1068 b = dev_prv->device;
Greg Kroah-Hartman99178b02008-08-26 11:00:57 -05001069 if (compare(a, b) <= 0) {
Greg Kroah-Hartmanae1b4172008-12-16 12:26:21 -08001070 list_move_tail(&a->p->knode_bus.n_node,
1071 &b->p->knode_bus.n_node);
Greg Kroah-Hartman99178b02008-08-26 11:00:57 -05001072 return;
1073 }
1074 }
Greg Kroah-Hartmanae1b4172008-12-16 12:26:21 -08001075 list_move_tail(&a->p->knode_bus.n_node, list);
Greg Kroah-Hartman99178b02008-08-26 11:00:57 -05001076}
1077
1078void bus_sort_breadthfirst(struct bus_type *bus,
1079 int (*compare)(const struct device *a,
1080 const struct device *b))
1081{
1082 LIST_HEAD(sorted_devices);
1083 struct list_head *pos, *tmp;
1084 struct klist_node *n;
Greg Kroah-Hartmanae1b4172008-12-16 12:26:21 -08001085 struct device_private *dev_prv;
Greg Kroah-Hartman99178b02008-08-26 11:00:57 -05001086 struct device *dev;
1087 struct klist *device_klist;
1088
1089 device_klist = bus_get_device_klist(bus);
1090
1091 spin_lock(&device_klist->k_lock);
1092 list_for_each_safe(pos, tmp, &device_klist->k_list) {
1093 n = container_of(pos, struct klist_node, n_node);
Greg Kroah-Hartmanae1b4172008-12-16 12:26:21 -08001094 dev_prv = to_device_private_bus(n);
1095 dev = dev_prv->device;
Greg Kroah-Hartman99178b02008-08-26 11:00:57 -05001096 device_insertion_sort_klist(dev, &sorted_devices, compare);
1097 }
1098 list_splice(&sorted_devices, &device_klist->k_list);
1099 spin_unlock(&device_klist->k_lock);
1100}
1101EXPORT_SYMBOL_GPL(bus_sort_breadthfirst);
1102
Kay Sieversca22e562011-12-14 14:29:38 -08001103/**
1104 * subsys_dev_iter_init - initialize subsys device iterator
1105 * @iter: subsys iterator to initialize
1106 * @subsys: the subsys we wanna iterate over
1107 * @start: the device to start iterating from, if any
1108 * @type: device_type of the devices to iterate over, NULL for all
1109 *
1110 * Initialize subsys iterator @iter such that it iterates over devices
1111 * of @subsys. If @start is set, the list iteration will start there,
1112 * otherwise if it is NULL, the iteration starts at the beginning of
1113 * the list.
1114 */
1115void subsys_dev_iter_init(struct subsys_dev_iter *iter, struct bus_type *subsys,
1116 struct device *start, const struct device_type *type)
1117{
1118 struct klist_node *start_knode = NULL;
1119
1120 if (start)
1121 start_knode = &start->p->knode_bus;
1122 klist_iter_init_node(&subsys->p->klist_devices, &iter->ki, start_knode);
1123 iter->type = type;
1124}
1125EXPORT_SYMBOL_GPL(subsys_dev_iter_init);
1126
1127/**
1128 * subsys_dev_iter_next - iterate to the next device
1129 * @iter: subsys iterator to proceed
1130 *
1131 * Proceed @iter to the next device and return it. Returns NULL if
1132 * iteration is complete.
1133 *
1134 * The returned device is referenced and won't be released till
1135 * iterator is proceed to the next device or exited. The caller is
1136 * free to do whatever it wants to do with the device including
1137 * calling back into subsys code.
1138 */
1139struct device *subsys_dev_iter_next(struct subsys_dev_iter *iter)
1140{
1141 struct klist_node *knode;
1142 struct device *dev;
1143
1144 for (;;) {
1145 knode = klist_next(&iter->ki);
1146 if (!knode)
1147 return NULL;
1148 dev = container_of(knode, struct device_private, knode_bus)->device;
1149 if (!iter->type || iter->type == dev->type)
1150 return dev;
1151 }
1152}
1153EXPORT_SYMBOL_GPL(subsys_dev_iter_next);
1154
1155/**
1156 * subsys_dev_iter_exit - finish iteration
1157 * @iter: subsys iterator to finish
1158 *
1159 * Finish an iteration. Always call this function after iteration is
1160 * complete whether the iteration ran till the end or not.
1161 */
1162void subsys_dev_iter_exit(struct subsys_dev_iter *iter)
1163{
1164 klist_iter_exit(&iter->ki);
1165}
1166EXPORT_SYMBOL_GPL(subsys_dev_iter_exit);
1167
1168int subsys_interface_register(struct subsys_interface *sif)
1169{
1170 struct bus_type *subsys;
1171 struct subsys_dev_iter iter;
1172 struct device *dev;
1173
1174 if (!sif || !sif->subsys)
1175 return -ENODEV;
1176
1177 subsys = bus_get(sif->subsys);
1178 if (!subsys)
1179 return -EINVAL;
1180
1181 mutex_lock(&subsys->p->mutex);
1182 list_add_tail(&sif->node, &subsys->p->interfaces);
1183 if (sif->add_dev) {
1184 subsys_dev_iter_init(&iter, subsys, NULL, NULL);
1185 while ((dev = subsys_dev_iter_next(&iter)))
1186 sif->add_dev(dev, sif);
1187 subsys_dev_iter_exit(&iter);
1188 }
1189 mutex_unlock(&subsys->p->mutex);
1190
1191 return 0;
1192}
1193EXPORT_SYMBOL_GPL(subsys_interface_register);
1194
1195void subsys_interface_unregister(struct subsys_interface *sif)
1196{
Jonghwan Choi2b315942012-01-14 11:06:03 +09001197 struct bus_type *subsys;
Kay Sieversca22e562011-12-14 14:29:38 -08001198 struct subsys_dev_iter iter;
1199 struct device *dev;
1200
Jonghwan Choi2b315942012-01-14 11:06:03 +09001201 if (!sif || !sif->subsys)
Kay Sieversca22e562011-12-14 14:29:38 -08001202 return;
1203
Jonghwan Choi2b315942012-01-14 11:06:03 +09001204 subsys = sif->subsys;
1205
Kay Sieversca22e562011-12-14 14:29:38 -08001206 mutex_lock(&subsys->p->mutex);
1207 list_del_init(&sif->node);
1208 if (sif->remove_dev) {
1209 subsys_dev_iter_init(&iter, subsys, NULL, NULL);
1210 while ((dev = subsys_dev_iter_next(&iter)))
1211 sif->remove_dev(dev, sif);
1212 subsys_dev_iter_exit(&iter);
1213 }
1214 mutex_unlock(&subsys->p->mutex);
1215
1216 bus_put(subsys);
1217}
1218EXPORT_SYMBOL_GPL(subsys_interface_unregister);
1219
1220static void system_root_device_release(struct device *dev)
1221{
1222 kfree(dev);
1223}
1224/**
1225 * subsys_system_register - register a subsystem at /sys/devices/system/
Randy Dunlap78d79552012-01-21 11:02:28 -08001226 * @subsys: system subsystem
1227 * @groups: default attributes for the root device
Kay Sieversca22e562011-12-14 14:29:38 -08001228 *
1229 * All 'system' subsystems have a /sys/devices/system/<name> root device
1230 * with the name of the subsystem. The root device can carry subsystem-
1231 * wide attributes. All registered devices are below this single root
1232 * device and are named after the subsystem with a simple enumeration
1233 * number appended. The registered devices are not explicitely named;
1234 * only 'id' in the device needs to be set.
1235 *
1236 * Do not use this interface for anything new, it exists for compatibility
1237 * with bad ideas only. New subsystems should use plain subsystems; and
1238 * add the subsystem-wide attributes should be added to the subsystem
1239 * directory itself and not some create fake root-device placed in
1240 * /sys/devices/system/<name>.
1241 */
1242int subsys_system_register(struct bus_type *subsys,
1243 const struct attribute_group **groups)
1244{
1245 struct device *dev;
1246 int err;
1247
1248 err = bus_register(subsys);
1249 if (err < 0)
1250 return err;
1251
1252 dev = kzalloc(sizeof(struct device), GFP_KERNEL);
1253 if (!dev) {
1254 err = -ENOMEM;
1255 goto err_dev;
1256 }
1257
1258 err = dev_set_name(dev, "%s", subsys->name);
1259 if (err < 0)
1260 goto err_name;
1261
1262 dev->kobj.parent = &system_kset->kobj;
1263 dev->groups = groups;
1264 dev->release = system_root_device_release;
1265
1266 err = device_register(dev);
1267 if (err < 0)
1268 goto err_dev_reg;
1269
1270 subsys->dev_root = dev;
1271 return 0;
1272
1273err_dev_reg:
1274 put_device(dev);
1275 dev = NULL;
1276err_name:
1277 kfree(dev);
1278err_dev:
1279 bus_unregister(subsys);
1280 return err;
1281}
1282EXPORT_SYMBOL_GPL(subsys_system_register);
1283
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284int __init buses_init(void)
1285{
Greg Kroah-Hartman59a54832007-10-29 23:22:26 -05001286 bus_kset = kset_create_and_add("bus", &bus_uevent_ops, NULL);
1287 if (!bus_kset)
1288 return -ENOMEM;
Kay Sieversca22e562011-12-14 14:29:38 -08001289
1290 system_kset = kset_create_and_add("system", NULL, &devices_kset->kobj);
1291 if (!system_kset)
1292 return -ENOMEM;
1293
Greg Kroah-Hartman59a54832007-10-29 23:22:26 -05001294 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001295}