Branch data Line data Source code
1 : : /*
2 : : * bus.c - bus driver management
3 : : *
4 : : * Copyright (c) 2002-3 Patrick Mochel
5 : : * Copyright (c) 2002-3 Open Source Development Labs
6 : : * Copyright (c) 2007 Greg Kroah-Hartman <gregkh@suse.de>
7 : : * Copyright (c) 2007 Novell Inc.
8 : : *
9 : : * This file is released under the GPLv2
10 : : *
11 : : */
12 : :
13 : : #include <linux/device.h>
14 : : #include <linux/module.h>
15 : : #include <linux/errno.h>
16 : : #include <linux/slab.h>
17 : : #include <linux/init.h>
18 : : #include <linux/string.h>
19 : : #include <linux/mutex.h>
20 : : #include <linux/sysfs.h>
21 : : #include "base.h"
22 : : #include "power/power.h"
23 : :
24 : : /* /sys/devices/system */
25 : : static struct kset *system_kset;
26 : :
27 : : #define to_bus_attr(_attr) container_of(_attr, struct bus_attribute, attr)
28 : :
29 : : /*
30 : : * sysfs bindings for drivers
31 : : */
32 : :
33 : : #define to_drv_attr(_attr) container_of(_attr, struct driver_attribute, attr)
34 : :
35 : :
36 : : static int __must_check bus_rescan_devices_helper(struct device *dev,
37 : : void *data);
38 : :
39 : : static struct bus_type *bus_get(struct bus_type *bus)
40 : : {
41 [ # # ][ # # ]: 112 : if (bus) {
[ - + ][ # # ]
[ # # ][ # # ]
[ # # ]
42 : 0 : kset_get(&bus->p->subsys);
43 : : return bus;
44 : : }
45 : : return NULL;
46 : : }
47 : :
48 : : static void bus_put(struct bus_type *bus)
49 : : {
50 [ # # # # ]: 112 : if (bus)
[ # # # # ]
[ # # # #
# # # # #
# ]
51 : 0 : kset_put(&bus->p->subsys);
52 : : }
53 : :
54 : 0 : static ssize_t drv_attr_show(struct kobject *kobj, struct attribute *attr,
55 : : char *buf)
56 : : {
57 : : struct driver_attribute *drv_attr = to_drv_attr(attr);
58 : : struct driver_private *drv_priv = to_driver(kobj);
59 : : ssize_t ret = -EIO;
60 : :
61 [ # # ]: 0 : if (drv_attr->show)
62 : 0 : ret = drv_attr->show(drv_priv->driver, buf);
63 : 0 : return ret;
64 : : }
65 : :
66 : 0 : static ssize_t drv_attr_store(struct kobject *kobj, struct attribute *attr,
67 : : const char *buf, size_t count)
68 : : {
69 : : struct driver_attribute *drv_attr = to_drv_attr(attr);
70 : : struct driver_private *drv_priv = to_driver(kobj);
71 : : ssize_t ret = -EIO;
72 : :
73 [ # # ]: 0 : if (drv_attr->store)
74 : 0 : ret = drv_attr->store(drv_priv->driver, buf, count);
75 : 0 : return ret;
76 : : }
77 : :
78 : : static const struct sysfs_ops driver_sysfs_ops = {
79 : : .show = drv_attr_show,
80 : : .store = drv_attr_store,
81 : : };
82 : :
83 : 0 : static void driver_release(struct kobject *kobj)
84 : : {
85 : : struct driver_private *drv_priv = to_driver(kobj);
86 : :
87 : : pr_debug("driver: '%s': %s\n", kobject_name(kobj), __func__);
88 : 0 : kfree(drv_priv);
89 : 0 : }
90 : :
91 : : static struct kobj_type driver_ktype = {
92 : : .sysfs_ops = &driver_sysfs_ops,
93 : : .release = driver_release,
94 : : };
95 : :
96 : : /*
97 : : * sysfs bindings for buses
98 : : */
99 : 0 : static ssize_t bus_attr_show(struct kobject *kobj, struct attribute *attr,
100 : : char *buf)
101 : : {
102 : : struct bus_attribute *bus_attr = to_bus_attr(attr);
103 : : struct subsys_private *subsys_priv = to_subsys_private(kobj);
104 : : ssize_t ret = 0;
105 : :
106 [ # # ]: 0 : if (bus_attr->show)
107 : 0 : ret = bus_attr->show(subsys_priv->bus, buf);
108 : 0 : return ret;
109 : : }
110 : :
111 : 0 : static ssize_t bus_attr_store(struct kobject *kobj, struct attribute *attr,
112 : : const char *buf, size_t count)
113 : : {
114 : : struct bus_attribute *bus_attr = to_bus_attr(attr);
115 : : struct subsys_private *subsys_priv = to_subsys_private(kobj);
116 : : ssize_t ret = 0;
117 : :
118 [ # # ]: 0 : if (bus_attr->store)
119 : 0 : ret = bus_attr->store(subsys_priv->bus, buf, count);
120 : 0 : return ret;
121 : : }
122 : :
123 : : static const struct sysfs_ops bus_sysfs_ops = {
124 : : .show = bus_attr_show,
125 : : .store = bus_attr_store,
126 : : };
127 : :
128 : 0 : int bus_create_file(struct bus_type *bus, struct bus_attribute *attr)
129 : : {
130 : : int error;
131 [ # # ]: 0 : if (bus_get(bus)) {
132 : 0 : error = sysfs_create_file(&bus->p->subsys.kobj, &attr->attr);
133 : : bus_put(bus);
134 : : } else
135 : : error = -EINVAL;
136 : 0 : return error;
137 : : }
138 : : EXPORT_SYMBOL_GPL(bus_create_file);
139 : :
140 : 0 : void bus_remove_file(struct bus_type *bus, struct bus_attribute *attr)
141 : : {
142 [ # # ]: 0 : if (bus_get(bus)) {
143 : 0 : sysfs_remove_file(&bus->p->subsys.kobj, &attr->attr);
144 : : bus_put(bus);
145 : : }
146 : 0 : }
147 : : EXPORT_SYMBOL_GPL(bus_remove_file);
148 : :
149 : : static struct kobj_type bus_ktype = {
150 : : .sysfs_ops = &bus_sysfs_ops,
151 : : };
152 : :
153 : 0 : static int bus_uevent_filter(struct kset *kset, struct kobject *kobj)
154 : : {
155 : : struct kobj_type *ktype = get_ktype(kobj);
156 : :
157 [ # # ]: 0 : if (ktype == &bus_ktype)
158 : : return 1;
159 : 0 : return 0;
160 : : }
161 : :
162 : : static const struct kset_uevent_ops bus_uevent_ops = {
163 : : .filter = bus_uevent_filter,
164 : : };
165 : :
166 : : static struct kset *bus_kset;
167 : :
168 : : /* Manually detach a device from its associated driver. */
169 : 0 : static ssize_t unbind_store(struct device_driver *drv, const char *buf,
170 : : size_t count)
171 : : {
172 : 0 : struct bus_type *bus = bus_get(drv->bus);
173 : : struct device *dev;
174 : : int err = -ENODEV;
175 : :
176 : : dev = bus_find_device_by_name(bus, NULL, buf);
177 [ # # ][ # # ]: 0 : if (dev && dev->driver == drv) {
178 [ # # ]: 0 : if (dev->parent) /* Needed for USB */
179 : : device_lock(dev->parent);
180 : 0 : device_release_driver(dev);
181 [ # # ]: 0 : if (dev->parent)
182 : : device_unlock(dev->parent);
183 : 0 : err = count;
184 : : }
185 : 0 : put_device(dev);
186 : : bus_put(bus);
187 : 0 : return err;
188 : : }
189 : : static DRIVER_ATTR_WO(unbind);
190 : :
191 : : /*
192 : : * Manually attach a device to a driver.
193 : : * Note: the driver must want to bind to the device,
194 : : * it is not possible to override the driver's id table.
195 : : */
196 : 0 : static ssize_t bind_store(struct device_driver *drv, const char *buf,
197 : : size_t count)
198 : : {
199 : 0 : struct bus_type *bus = bus_get(drv->bus);
200 : : struct device *dev;
201 : : int err = -ENODEV;
202 : :
203 : : dev = bus_find_device_by_name(bus, NULL, buf);
204 [ # # ][ # # ]: 0 : if (dev && dev->driver == NULL && driver_match_device(drv, dev)) {
[ # # ]
205 [ # # ]: 0 : if (dev->parent) /* Needed for USB */
206 : : device_lock(dev->parent);
207 : : device_lock(dev);
208 : 0 : err = driver_probe_device(drv, dev);
209 : : device_unlock(dev);
210 [ # # ]: 0 : if (dev->parent)
211 : : device_unlock(dev->parent);
212 : :
213 [ # # ]: 0 : if (err > 0) {
214 : : /* success */
215 : 0 : err = count;
216 [ # # ]: 0 : } else if (err == 0) {
217 : : /* driver didn't accept device */
218 : : err = -ENODEV;
219 : : }
220 : : }
221 : 0 : put_device(dev);
222 : : bus_put(bus);
223 : 0 : return err;
224 : : }
225 : : static DRIVER_ATTR_WO(bind);
226 : :
227 : 0 : static ssize_t show_drivers_autoprobe(struct bus_type *bus, char *buf)
228 : : {
229 : 0 : return sprintf(buf, "%d\n", bus->p->drivers_autoprobe);
230 : : }
231 : :
232 : 0 : static ssize_t store_drivers_autoprobe(struct bus_type *bus,
233 : : const char *buf, size_t count)
234 : : {
235 [ # # ]: 0 : if (buf[0] == '0')
236 : 0 : bus->p->drivers_autoprobe = 0;
237 : : else
238 : 0 : bus->p->drivers_autoprobe = 1;
239 : 0 : return count;
240 : : }
241 : :
242 : 0 : static ssize_t store_drivers_probe(struct bus_type *bus,
243 : : const char *buf, size_t count)
244 : : {
245 : : struct device *dev;
246 : :
247 : : dev = bus_find_device_by_name(bus, NULL, buf);
248 [ # # ]: 0 : if (!dev)
249 : : return -ENODEV;
250 [ # # ]: 0 : if (bus_rescan_devices_helper(dev, NULL) != 0)
251 : : return -EINVAL;
252 : 0 : return count;
253 : : }
254 : :
255 : : static struct device *next_device(struct klist_iter *i)
256 : : {
257 : 8 : struct klist_node *n = klist_next(i);
258 : : struct device *dev = NULL;
259 : : struct device_private *dev_prv;
260 : :
261 [ # # # # : 8 : if (n) {
+ + # # ]
262 : : dev_prv = to_device_private_bus(n);
263 : 6 : dev = dev_prv->device;
264 : : }
265 : : return dev;
266 : : }
267 : :
268 : : /**
269 : : * bus_for_each_dev - device iterator.
270 : : * @bus: bus type.
271 : : * @start: device to start iterating from.
272 : : * @data: data for the callback.
273 : : * @fn: function to be called for each device.
274 : : *
275 : : * Iterate over @bus's list of devices, and call @fn for each,
276 : : * passing it @data. If @start is not NULL, we use that device to
277 : : * begin iterating from.
278 : : *
279 : : * We check the return of @fn each time. If it returns anything
280 : : * other than 0, we break out and return that value.
281 : : *
282 : : * NOTE: The device that returns a non-zero value is not retained
283 : : * in any way, nor is its refcount incremented. If the caller needs
284 : : * to retain this data, it should do so, and increment the reference
285 : : * count in the supplied callback.
286 : : */
287 : 0 : int bus_for_each_dev(struct bus_type *bus, struct device *start,
288 : : void *data, int (*fn)(struct device *, void *))
289 : : {
290 : : struct klist_iter i;
291 : : struct device *dev;
292 : : int error = 0;
293 : :
294 [ # # ][ # # ]: 0 : if (!bus || !bus->p)
295 : : return -EINVAL;
296 : :
297 [ # # ]: 0 : klist_iter_init_node(&bus->p->klist_devices, &i,
298 : 0 : (start ? &start->p->knode_bus : NULL));
299 [ # # ][ # # ]: 0 : while ((dev = next_device(&i)) && !error)
300 : 0 : error = fn(dev, data);
301 : 0 : klist_iter_exit(&i);
302 : 0 : return error;
303 : : }
304 : : EXPORT_SYMBOL_GPL(bus_for_each_dev);
305 : :
306 : : /**
307 : : * bus_find_device - device iterator for locating a particular device.
308 : : * @bus: bus type
309 : : * @start: Device to begin with
310 : : * @data: Data to pass to match function
311 : : * @match: Callback function to check device
312 : : *
313 : : * This is similar to the bus_for_each_dev() function above, but it
314 : : * returns a reference to a device that is 'found' for later use, as
315 : : * determined by the @match callback.
316 : : *
317 : : * The callback should return 0 if the device doesn't match and non-zero
318 : : * if it does. If the callback returns non-zero, this function will
319 : : * return to the caller and not iterate over any more devices.
320 : : */
321 : 0 : struct device *bus_find_device(struct bus_type *bus,
322 : : struct device *start, void *data,
323 : : int (*match)(struct device *dev, void *data))
324 : : {
325 : : struct klist_iter i;
326 : : struct device *dev;
327 : :
328 [ + - ][ + - ]: 8 : if (!bus || !bus->p)
329 : : return NULL;
330 : :
331 [ + + ]: 8 : klist_iter_init_node(&bus->p->klist_devices, &i,
332 : 6 : (start ? &start->p->knode_bus : NULL));
333 [ + + ]: 16 : while ((dev = next_device(&i)))
334 [ - + ][ - + ]: 14 : if (match(dev, data) && get_device(dev))
335 : : break;
336 : 8 : klist_iter_exit(&i);
337 : 8 : return dev;
338 : : }
339 : : EXPORT_SYMBOL_GPL(bus_find_device);
340 : :
341 : 0 : static int match_name(struct device *dev, void *data)
342 : : {
343 : : const char *name = data;
344 : :
345 : 0 : return sysfs_streq(name, dev_name(dev));
346 : : }
347 : :
348 : : /**
349 : : * bus_find_device_by_name - device iterator for locating a particular device of a specific name
350 : : * @bus: bus type
351 : : * @start: Device to begin with
352 : : * @name: name of the device to match
353 : : *
354 : : * This is similar to the bus_find_device() function above, but it handles
355 : : * searching by a name automatically, no need to write another strcmp matching
356 : : * function.
357 : : */
358 : 0 : struct device *bus_find_device_by_name(struct bus_type *bus,
359 : : struct device *start, const char *name)
360 : : {
361 : 0 : return bus_find_device(bus, start, (void *)name, match_name);
362 : : }
363 : : EXPORT_SYMBOL_GPL(bus_find_device_by_name);
364 : :
365 : : /**
366 : : * subsys_find_device_by_id - find a device with a specific enumeration number
367 : : * @subsys: subsystem
368 : : * @id: index 'id' in struct device
369 : : * @hint: device to check first
370 : : *
371 : : * Check the hint's next object and if it is a match return it directly,
372 : : * otherwise, fall back to a full list search. Either way a reference for
373 : : * the returned object is taken.
374 : : */
375 : 0 : struct device *subsys_find_device_by_id(struct bus_type *subsys, unsigned int id,
376 : : struct device *hint)
377 : : {
378 : : struct klist_iter i;
379 : : struct device *dev;
380 : :
381 [ # # ]: 0 : if (!subsys)
382 : : return NULL;
383 : :
384 [ # # ]: 0 : if (hint) {
385 : 0 : klist_iter_init_node(&subsys->p->klist_devices, &i, &hint->p->knode_bus);
386 : : dev = next_device(&i);
387 [ # # ][ # # ]: 0 : if (dev && dev->id == id && get_device(dev)) {
[ # # ]
388 : 0 : klist_iter_exit(&i);
389 : 0 : return dev;
390 : : }
391 : 0 : klist_iter_exit(&i);
392 : : }
393 : :
394 : 0 : klist_iter_init_node(&subsys->p->klist_devices, &i, NULL);
395 [ # # ]: 0 : while ((dev = next_device(&i))) {
396 [ # # ][ # # ]: 0 : if (dev->id == id && get_device(dev)) {
397 : 0 : klist_iter_exit(&i);
398 : 0 : return dev;
399 : : }
400 : : }
401 : 0 : klist_iter_exit(&i);
402 : 0 : return NULL;
403 : : }
404 : : EXPORT_SYMBOL_GPL(subsys_find_device_by_id);
405 : :
406 : : static struct device_driver *next_driver(struct klist_iter *i)
407 : : {
408 : 0 : struct klist_node *n = klist_next(i);
409 : : struct driver_private *drv_priv;
410 : :
411 [ # # ]: 0 : if (n) {
412 : : drv_priv = container_of(n, struct driver_private, knode_bus);
413 : 0 : return drv_priv->driver;
414 : : }
415 : : return NULL;
416 : : }
417 : :
418 : : /**
419 : : * bus_for_each_drv - driver iterator
420 : : * @bus: bus we're dealing with.
421 : : * @start: driver to start iterating on.
422 : : * @data: data to pass to the callback.
423 : : * @fn: function to call for each driver.
424 : : *
425 : : * This is nearly identical to the device iterator above.
426 : : * We iterate over each driver that belongs to @bus, and call
427 : : * @fn for each. If @fn returns anything but 0, we break out
428 : : * and return it. If @start is not NULL, we use it as the head
429 : : * of the list.
430 : : *
431 : : * NOTE: we don't return the driver that returns a non-zero
432 : : * value, nor do we leave the reference count incremented for that
433 : : * driver. If the caller needs to know that info, it must set it
434 : : * in the callback. It must also be sure to increment the refcount
435 : : * so it doesn't disappear before returning to the caller.
436 : : */
437 : 0 : int bus_for_each_drv(struct bus_type *bus, struct device_driver *start,
438 : : void *data, int (*fn)(struct device_driver *, void *))
439 : : {
440 : : struct klist_iter i;
441 : : struct device_driver *drv;
442 : : int error = 0;
443 : :
444 [ # # ]: 0 : if (!bus)
445 : : return -EINVAL;
446 : :
447 [ # # ]: 0 : klist_iter_init_node(&bus->p->klist_drivers, &i,
448 : 0 : start ? &start->p->knode_bus : NULL);
449 [ # # ][ # # ]: 0 : while ((drv = next_driver(&i)) && !error)
450 : 0 : error = fn(drv, data);
451 : 0 : klist_iter_exit(&i);
452 : 0 : return error;
453 : : }
454 : : EXPORT_SYMBOL_GPL(bus_for_each_drv);
455 : :
456 : 0 : static int device_add_attrs(struct bus_type *bus, struct device *dev)
457 : : {
458 : : int error = 0;
459 : : int i;
460 : :
461 [ # # ]: 0 : if (!bus->dev_attrs)
462 : : return 0;
463 : :
464 [ # # ]: 0 : for (i = 0; bus->dev_attrs[i].attr.name; i++) {
465 : 0 : error = device_create_file(dev, &bus->dev_attrs[i]);
466 [ # # ]: 0 : if (error) {
467 [ # # ]: 0 : while (--i >= 0)
468 : 0 : device_remove_file(dev, &bus->dev_attrs[i]);
469 : : break;
470 : : }
471 : : }
472 : : return error;
473 : : }
474 : :
475 : 0 : static void device_remove_attrs(struct bus_type *bus, struct device *dev)
476 : : {
477 : : int i;
478 : :
479 [ # # ]: 0 : if (bus->dev_attrs) {
480 [ # # ]: 0 : for (i = 0; bus->dev_attrs[i].attr.name; i++)
481 : 0 : device_remove_file(dev, &bus->dev_attrs[i]);
482 : : }
483 : 0 : }
484 : :
485 : : /**
486 : : * bus_add_device - add device to bus
487 : : * @dev: device being added
488 : : *
489 : : * - Add device's bus attributes.
490 : : * - Create links to device's bus.
491 : : * - Add the device to its bus's list of devices.
492 : : */
493 : 0 : int bus_add_device(struct device *dev)
494 : : {
495 : 112 : struct bus_type *bus = bus_get(dev->bus);
496 : : int error = 0;
497 : :
498 [ - + ]: 112 : if (bus) {
499 : : pr_debug("bus: '%s': add device %s\n", bus->name, dev_name(dev));
500 : 0 : error = device_add_attrs(bus, dev);
501 [ # # ]: 0 : if (error)
502 : : goto out_put;
503 : 0 : error = device_add_groups(dev, bus->dev_groups);
504 [ # # ]: 0 : if (error)
505 : : goto out_groups;
506 : 0 : error = sysfs_create_link(&bus->p->devices_kset->kobj,
507 : : &dev->kobj, dev_name(dev));
508 [ # # ]: 0 : if (error)
509 : : goto out_id;
510 : 0 : error = sysfs_create_link(&dev->kobj,
511 : 0 : &dev->bus->p->subsys.kobj, "subsystem");
512 [ # # ]: 0 : if (error)
513 : : goto out_subsys;
514 : 0 : klist_add_tail(&dev->p->knode_bus, &bus->p->klist_devices);
515 : : }
516 : : return 0;
517 : :
518 : : out_subsys:
519 : 0 : sysfs_remove_link(&bus->p->devices_kset->kobj, dev_name(dev));
520 : : out_groups:
521 : 0 : device_remove_groups(dev, bus->dev_groups);
522 : : out_id:
523 : 0 : device_remove_attrs(bus, dev);
524 : : out_put:
525 : 0 : bus_put(dev->bus);
526 : 0 : return error;
527 : : }
528 : :
529 : : /**
530 : : * bus_probe_device - probe drivers for a new device
531 : : * @dev: device to probe
532 : : *
533 : : * - Automatically probe for a driver if the bus allows it.
534 : : */
535 : 0 : void bus_probe_device(struct device *dev)
536 : : {
537 : 112 : struct bus_type *bus = dev->bus;
538 : : struct subsys_interface *sif;
539 : : int ret;
540 : :
541 [ - + ]: 112 : if (!bus)
542 : 112 : return;
543 : :
544 [ # # ]: 0 : if (bus->p->drivers_autoprobe) {
545 : 0 : ret = device_attach(dev);
546 [ # # ]: 0 : WARN_ON(ret < 0);
547 : : }
548 : :
549 : 0 : mutex_lock(&bus->p->mutex);
550 [ # # ]: 112 : list_for_each_entry(sif, &bus->p->interfaces, node)
551 [ # # ]: 0 : if (sif->add_dev)
552 : 0 : sif->add_dev(dev, sif);
553 : 0 : mutex_unlock(&bus->p->mutex);
554 : : }
555 : :
556 : : /**
557 : : * bus_remove_device - remove device from bus
558 : : * @dev: device to be removed
559 : : *
560 : : * - Remove device from all interfaces.
561 : : * - Remove symlink from bus' directory.
562 : : * - Delete device from bus's list.
563 : : * - Detach from its driver.
564 : : * - Drop reference taken in bus_add_device().
565 : : */
566 : 0 : void bus_remove_device(struct device *dev)
567 : : {
568 : 0 : struct bus_type *bus = dev->bus;
569 : : struct subsys_interface *sif;
570 : :
571 [ # # ]: 0 : if (!bus)
572 : 0 : return;
573 : :
574 : 0 : mutex_lock(&bus->p->mutex);
575 [ # # ]: 0 : list_for_each_entry(sif, &bus->p->interfaces, node)
576 [ # # ]: 0 : if (sif->remove_dev)
577 : 0 : sif->remove_dev(dev, sif);
578 : 0 : mutex_unlock(&bus->p->mutex);
579 : :
580 : 0 : sysfs_remove_link(&dev->kobj, "subsystem");
581 : 0 : sysfs_remove_link(&dev->bus->p->devices_kset->kobj,
582 : : dev_name(dev));
583 : 0 : device_remove_attrs(dev->bus, dev);
584 : 0 : device_remove_groups(dev, dev->bus->dev_groups);
585 [ # # ]: 0 : if (klist_node_attached(&dev->p->knode_bus))
586 : 0 : klist_del(&dev->p->knode_bus);
587 : :
588 : : pr_debug("bus: '%s': remove device %s\n",
589 : : dev->bus->name, dev_name(dev));
590 : 0 : device_release_driver(dev);
591 : 0 : bus_put(dev->bus);
592 : : }
593 : :
594 : 0 : static int __must_check add_bind_files(struct device_driver *drv)
595 : : {
596 : : int ret;
597 : :
598 : 0 : ret = driver_create_file(drv, &driver_attr_unbind);
599 [ # # ]: 0 : if (ret == 0) {
600 : 0 : ret = driver_create_file(drv, &driver_attr_bind);
601 [ # # ]: 0 : if (ret)
602 : 0 : driver_remove_file(drv, &driver_attr_unbind);
603 : : }
604 : 0 : return ret;
605 : : }
606 : :
607 : 0 : static void remove_bind_files(struct device_driver *drv)
608 : : {
609 : 0 : driver_remove_file(drv, &driver_attr_bind);
610 : 0 : driver_remove_file(drv, &driver_attr_unbind);
611 : 0 : }
612 : :
613 : : static BUS_ATTR(drivers_probe, S_IWUSR, NULL, store_drivers_probe);
614 : : static BUS_ATTR(drivers_autoprobe, S_IWUSR | S_IRUGO,
615 : : show_drivers_autoprobe, store_drivers_autoprobe);
616 : :
617 : 0 : static int add_probe_files(struct bus_type *bus)
618 : : {
619 : : int retval;
620 : :
621 : 0 : retval = bus_create_file(bus, &bus_attr_drivers_probe);
622 [ # # ]: 0 : if (retval)
623 : : goto out;
624 : :
625 : 0 : retval = bus_create_file(bus, &bus_attr_drivers_autoprobe);
626 [ # # ]: 0 : if (retval)
627 : 0 : bus_remove_file(bus, &bus_attr_drivers_probe);
628 : : out:
629 : 0 : return retval;
630 : : }
631 : :
632 : 0 : static void remove_probe_files(struct bus_type *bus)
633 : : {
634 : 0 : bus_remove_file(bus, &bus_attr_drivers_autoprobe);
635 : 0 : bus_remove_file(bus, &bus_attr_drivers_probe);
636 : 0 : }
637 : :
638 : 0 : static ssize_t uevent_store(struct device_driver *drv, const char *buf,
639 : : size_t count)
640 : : {
641 : : enum kobject_action action;
642 : :
643 [ # # ]: 0 : if (kobject_action_type(buf, count, &action) == 0)
644 : 0 : kobject_uevent(&drv->p->kobj, action);
645 : 0 : return count;
646 : : }
647 : : static DRIVER_ATTR_WO(uevent);
648 : :
649 : : /**
650 : : * bus_add_driver - Add a driver to the bus.
651 : : * @drv: driver.
652 : : */
653 : 0 : int bus_add_driver(struct device_driver *drv)
654 : : {
655 : : struct bus_type *bus;
656 : : struct driver_private *priv;
657 : : int error = 0;
658 : :
659 : 0 : bus = bus_get(drv->bus);
660 [ # # ]: 0 : if (!bus)
661 : : return -EINVAL;
662 : :
663 : : pr_debug("bus: '%s': add driver %s\n", bus->name, drv->name);
664 : :
665 : : priv = kzalloc(sizeof(*priv), GFP_KERNEL);
666 [ # # ]: 0 : if (!priv) {
667 : : error = -ENOMEM;
668 : : goto out_put_bus;
669 : : }
670 : 0 : klist_init(&priv->klist_devices, NULL, NULL);
671 : 0 : priv->driver = drv;
672 : 0 : drv->p = priv;
673 : 0 : priv->kobj.kset = bus->p->drivers_kset;
674 : 0 : error = kobject_init_and_add(&priv->kobj, &driver_ktype, NULL,
675 : : "%s", drv->name);
676 [ # # ]: 0 : if (error)
677 : : goto out_unregister;
678 : :
679 : 0 : klist_add_tail(&priv->knode_bus, &bus->p->klist_drivers);
680 [ # # ]: 0 : if (drv->bus->p->drivers_autoprobe) {
681 : 0 : error = driver_attach(drv);
682 [ # # ]: 0 : if (error)
683 : : goto out_unregister;
684 : : }
685 : 0 : module_add_driver(drv->owner, drv);
686 : :
687 : 0 : error = driver_create_file(drv, &driver_attr_uevent);
688 [ # # ]: 0 : if (error) {
689 : 0 : printk(KERN_ERR "%s: uevent attr (%s) failed\n",
690 : : __func__, drv->name);
691 : : }
692 : 0 : error = driver_add_groups(drv, bus->drv_groups);
693 [ # # ]: 0 : if (error) {
694 : : /* How the hell do we get out of this pickle? Give up */
695 : 0 : printk(KERN_ERR "%s: driver_create_groups(%s) failed\n",
696 : : __func__, drv->name);
697 : : }
698 : :
699 [ # # ]: 0 : if (!drv->suppress_bind_attrs) {
700 : 0 : error = add_bind_files(drv);
701 [ # # ]: 0 : if (error) {
702 : : /* Ditto */
703 : 0 : printk(KERN_ERR "%s: add_bind_files(%s) failed\n",
704 : : __func__, drv->name);
705 : : }
706 : : }
707 : :
708 : : return 0;
709 : :
710 : : out_unregister:
711 : 0 : kobject_put(&priv->kobj);
712 : 0 : kfree(drv->p);
713 : 0 : drv->p = NULL;
714 : : out_put_bus:
715 : : bus_put(bus);
716 : 0 : return error;
717 : : }
718 : :
719 : : /**
720 : : * bus_remove_driver - delete driver from bus's knowledge.
721 : : * @drv: driver.
722 : : *
723 : : * Detach the driver from the devices it controls, and remove
724 : : * it from its bus's list of drivers. Finally, we drop the reference
725 : : * to the bus we took in bus_add_driver().
726 : : */
727 : 0 : void bus_remove_driver(struct device_driver *drv)
728 : : {
729 [ # # ]: 0 : if (!drv->bus)
730 : 0 : return;
731 : :
732 [ # # ]: 0 : if (!drv->suppress_bind_attrs)
733 : 0 : remove_bind_files(drv);
734 : 0 : driver_remove_groups(drv, drv->bus->drv_groups);
735 : 0 : driver_remove_file(drv, &driver_attr_uevent);
736 : 0 : klist_remove(&drv->p->knode_bus);
737 : : pr_debug("bus: '%s': remove driver %s\n", drv->bus->name, drv->name);
738 : 0 : driver_detach(drv);
739 : 0 : module_remove_driver(drv);
740 : 0 : kobject_put(&drv->p->kobj);
741 : 0 : bus_put(drv->bus);
742 : : }
743 : :
744 : : /* Helper for bus_rescan_devices's iter */
745 : 0 : static int __must_check bus_rescan_devices_helper(struct device *dev,
746 : : void *data)
747 : : {
748 : : int ret = 0;
749 : :
750 [ # # ]: 0 : if (!dev->driver) {
751 [ # # ]: 0 : if (dev->parent) /* Needed for USB */
752 : : device_lock(dev->parent);
753 : 0 : ret = device_attach(dev);
754 [ # # ]: 0 : if (dev->parent)
755 : : device_unlock(dev->parent);
756 : : }
757 : 0 : return ret < 0 ? ret : 0;
758 : : }
759 : :
760 : : /**
761 : : * bus_rescan_devices - rescan devices on the bus for possible drivers
762 : : * @bus: the bus to scan.
763 : : *
764 : : * This function will look for devices on the bus with no driver
765 : : * attached and rescan it against existing drivers to see if it matches
766 : : * any by calling device_attach() for the unbound devices.
767 : : */
768 : 0 : int bus_rescan_devices(struct bus_type *bus)
769 : : {
770 : 0 : return bus_for_each_dev(bus, NULL, NULL, bus_rescan_devices_helper);
771 : : }
772 : : EXPORT_SYMBOL_GPL(bus_rescan_devices);
773 : :
774 : : /**
775 : : * device_reprobe - remove driver for a device and probe for a new driver
776 : : * @dev: the device to reprobe
777 : : *
778 : : * This function detaches the attached driver (if any) for the given
779 : : * device and restarts the driver probing process. It is intended
780 : : * to use if probing criteria changed during a devices lifetime and
781 : : * driver attachment should change accordingly.
782 : : */
783 : 0 : int device_reprobe(struct device *dev)
784 : : {
785 [ # # ]: 0 : if (dev->driver) {
786 [ # # ]: 0 : if (dev->parent) /* Needed for USB */
787 : : device_lock(dev->parent);
788 : 0 : device_release_driver(dev);
789 [ # # ]: 0 : if (dev->parent)
790 : : device_unlock(dev->parent);
791 : : }
792 : 0 : return bus_rescan_devices_helper(dev, NULL);
793 : : }
794 : : EXPORT_SYMBOL_GPL(device_reprobe);
795 : :
796 : : /**
797 : : * find_bus - locate bus by name.
798 : : * @name: name of bus.
799 : : *
800 : : * Call kset_find_obj() to iterate over list of buses to
801 : : * find a bus by name. Return bus if found.
802 : : *
803 : : * Note that kset_find_obj increments bus' reference count.
804 : : */
805 : : #if 0
806 : : struct bus_type *find_bus(char *name)
807 : : {
808 : : struct kobject *k = kset_find_obj(bus_kset, name);
809 : : return k ? to_bus(k) : NULL;
810 : : }
811 : : #endif /* 0 */
812 : :
813 : : static int bus_add_groups(struct bus_type *bus,
814 : : const struct attribute_group **groups)
815 : : {
816 : 0 : return sysfs_create_groups(&bus->p->subsys.kobj, groups);
817 : : }
818 : :
819 : : static void bus_remove_groups(struct bus_type *bus,
820 : : const struct attribute_group **groups)
821 : : {
822 : 0 : sysfs_remove_groups(&bus->p->subsys.kobj, groups);
823 : : }
824 : :
825 : 0 : static void klist_devices_get(struct klist_node *n)
826 : : {
827 : : struct device_private *dev_prv = to_device_private_bus(n);
828 : 0 : struct device *dev = dev_prv->device;
829 : :
830 : 0 : get_device(dev);
831 : 0 : }
832 : :
833 : 0 : static void klist_devices_put(struct klist_node *n)
834 : : {
835 : : struct device_private *dev_prv = to_device_private_bus(n);
836 : 0 : struct device *dev = dev_prv->device;
837 : :
838 : 0 : put_device(dev);
839 : 0 : }
840 : :
841 : 0 : static ssize_t bus_uevent_store(struct bus_type *bus,
842 : : const char *buf, size_t count)
843 : : {
844 : : enum kobject_action action;
845 : :
846 [ # # ]: 0 : if (kobject_action_type(buf, count, &action) == 0)
847 : 0 : kobject_uevent(&bus->p->subsys.kobj, action);
848 : 0 : return count;
849 : : }
850 : : static BUS_ATTR(uevent, S_IWUSR, NULL, bus_uevent_store);
851 : :
852 : : /**
853 : : * bus_register - register a driver-core subsystem
854 : : * @bus: bus to register
855 : : *
856 : : * Once we have that, we register the bus with the kobject
857 : : * infrastructure, then register the children subsystems it has:
858 : : * the devices and drivers that belong to the subsystem.
859 : : */
860 : 0 : int bus_register(struct bus_type *bus)
861 : : {
862 : : int retval;
863 : : struct subsys_private *priv;
864 : 0 : struct lock_class_key *key = &bus->lock_key;
865 : :
866 : : priv = kzalloc(sizeof(struct subsys_private), GFP_KERNEL);
867 [ # # ]: 0 : if (!priv)
868 : : return -ENOMEM;
869 : :
870 : 0 : priv->bus = bus;
871 : 0 : bus->p = priv;
872 : :
873 : 0 : BLOCKING_INIT_NOTIFIER_HEAD(&priv->bus_notifier);
874 : :
875 : 0 : retval = kobject_set_name(&priv->subsys.kobj, "%s", bus->name);
876 [ # # ]: 0 : if (retval)
877 : : goto out;
878 : :
879 : 0 : priv->subsys.kobj.kset = bus_kset;
880 : 0 : priv->subsys.kobj.ktype = &bus_ktype;
881 : 0 : priv->drivers_autoprobe = 1;
882 : :
883 : 0 : retval = kset_register(&priv->subsys);
884 [ # # ]: 0 : if (retval)
885 : : goto out;
886 : :
887 : 0 : retval = bus_create_file(bus, &bus_attr_uevent);
888 [ # # ]: 0 : if (retval)
889 : : goto bus_uevent_fail;
890 : :
891 : 0 : priv->devices_kset = kset_create_and_add("devices", NULL,
892 : : &priv->subsys.kobj);
893 [ # # ]: 0 : if (!priv->devices_kset) {
894 : : retval = -ENOMEM;
895 : : goto bus_devices_fail;
896 : : }
897 : :
898 : 0 : priv->drivers_kset = kset_create_and_add("drivers", NULL,
899 : : &priv->subsys.kobj);
900 [ # # ]: 0 : if (!priv->drivers_kset) {
901 : : retval = -ENOMEM;
902 : : goto bus_drivers_fail;
903 : : }
904 : :
905 : 0 : INIT_LIST_HEAD(&priv->interfaces);
906 : 0 : __mutex_init(&priv->mutex, "subsys mutex", key);
907 : 0 : klist_init(&priv->klist_devices, klist_devices_get, klist_devices_put);
908 : 0 : klist_init(&priv->klist_drivers, NULL, NULL);
909 : :
910 : 0 : retval = add_probe_files(bus);
911 [ # # ]: 0 : if (retval)
912 : : goto bus_probe_files_fail;
913 : :
914 : 0 : retval = bus_add_groups(bus, bus->bus_groups);
915 [ # # ]: 0 : if (retval)
916 : : goto bus_groups_fail;
917 : :
918 : : pr_debug("bus: '%s': registered\n", bus->name);
919 : : return 0;
920 : :
921 : : bus_groups_fail:
922 : 0 : remove_probe_files(bus);
923 : : bus_probe_files_fail:
924 : 0 : kset_unregister(bus->p->drivers_kset);
925 : : bus_drivers_fail:
926 : 0 : kset_unregister(bus->p->devices_kset);
927 : : bus_devices_fail:
928 : 0 : bus_remove_file(bus, &bus_attr_uevent);
929 : : bus_uevent_fail:
930 : 0 : kset_unregister(&bus->p->subsys);
931 : : out:
932 : 0 : kfree(bus->p);
933 : 0 : bus->p = NULL;
934 : 0 : return retval;
935 : : }
936 : : EXPORT_SYMBOL_GPL(bus_register);
937 : :
938 : : /**
939 : : * bus_unregister - remove a bus from the system
940 : : * @bus: bus.
941 : : *
942 : : * Unregister the child subsystems and the bus itself.
943 : : * Finally, we call bus_put() to release the refcount
944 : : */
945 : 0 : void bus_unregister(struct bus_type *bus)
946 : : {
947 : : pr_debug("bus: '%s': unregistering\n", bus->name);
948 [ # # ]: 0 : if (bus->dev_root)
949 : 0 : device_unregister(bus->dev_root);
950 : 0 : bus_remove_groups(bus, bus->bus_groups);
951 : 0 : remove_probe_files(bus);
952 : 0 : kset_unregister(bus->p->drivers_kset);
953 : 0 : kset_unregister(bus->p->devices_kset);
954 : 0 : bus_remove_file(bus, &bus_attr_uevent);
955 : 0 : kset_unregister(&bus->p->subsys);
956 : 0 : kfree(bus->p);
957 : 0 : bus->p = NULL;
958 : 0 : }
959 : : EXPORT_SYMBOL_GPL(bus_unregister);
960 : :
961 : 0 : int bus_register_notifier(struct bus_type *bus, struct notifier_block *nb)
962 : : {
963 : 0 : return blocking_notifier_chain_register(&bus->p->bus_notifier, nb);
964 : : }
965 : : EXPORT_SYMBOL_GPL(bus_register_notifier);
966 : :
967 : 0 : int bus_unregister_notifier(struct bus_type *bus, struct notifier_block *nb)
968 : : {
969 : 0 : return blocking_notifier_chain_unregister(&bus->p->bus_notifier, nb);
970 : : }
971 : : EXPORT_SYMBOL_GPL(bus_unregister_notifier);
972 : :
973 : 0 : struct kset *bus_get_kset(struct bus_type *bus)
974 : : {
975 : 0 : return &bus->p->subsys;
976 : : }
977 : : EXPORT_SYMBOL_GPL(bus_get_kset);
978 : :
979 : 0 : struct klist *bus_get_device_klist(struct bus_type *bus)
980 : : {
981 : 0 : return &bus->p->klist_devices;
982 : : }
983 : : EXPORT_SYMBOL_GPL(bus_get_device_klist);
984 : :
985 : : /*
986 : : * Yes, this forcibly breaks the klist abstraction temporarily. It
987 : : * just wants to sort the klist, not change reference counts and
988 : : * take/drop locks rapidly in the process. It does all this while
989 : : * holding the lock for the list, so objects can't otherwise be
990 : : * added/removed while we're swizzling.
991 : : */
992 : 0 : static void device_insertion_sort_klist(struct device *a, struct list_head *list,
993 : : int (*compare)(const struct device *a,
994 : : const struct device *b))
995 : : {
996 : : struct list_head *pos;
997 : : struct klist_node *n;
998 : : struct device_private *dev_prv;
999 : : struct device *b;
1000 : :
1001 [ # # ]: 0 : list_for_each(pos, list) {
1002 : : n = container_of(pos, struct klist_node, n_node);
1003 : : dev_prv = to_device_private_bus(n);
1004 : 0 : b = dev_prv->device;
1005 [ # # ]: 0 : if (compare(a, b) <= 0) {
1006 : 0 : list_move_tail(&a->p->knode_bus.n_node,
1007 : 0 : &b->p->knode_bus.n_node);
1008 : 0 : return;
1009 : : }
1010 : : }
1011 : 0 : list_move_tail(&a->p->knode_bus.n_node, list);
1012 : : }
1013 : :
1014 : 0 : void bus_sort_breadthfirst(struct bus_type *bus,
1015 : : int (*compare)(const struct device *a,
1016 : : const struct device *b))
1017 : : {
1018 : 0 : LIST_HEAD(sorted_devices);
1019 : : struct list_head *pos, *tmp;
1020 : : struct klist_node *n;
1021 : : struct device_private *dev_prv;
1022 : : struct device *dev;
1023 : : struct klist *device_klist;
1024 : :
1025 : : device_klist = bus_get_device_klist(bus);
1026 : :
1027 : : spin_lock(&device_klist->k_lock);
1028 [ # # ]: 0 : list_for_each_safe(pos, tmp, &device_klist->k_list) {
1029 : : n = container_of(pos, struct klist_node, n_node);
1030 : : dev_prv = to_device_private_bus(n);
1031 : 0 : dev = dev_prv->device;
1032 : 0 : device_insertion_sort_klist(dev, &sorted_devices, compare);
1033 : : }
1034 : : list_splice(&sorted_devices, &device_klist->k_list);
1035 : : spin_unlock(&device_klist->k_lock);
1036 : 0 : }
1037 : : EXPORT_SYMBOL_GPL(bus_sort_breadthfirst);
1038 : :
1039 : : /**
1040 : : * subsys_dev_iter_init - initialize subsys device iterator
1041 : : * @iter: subsys iterator to initialize
1042 : : * @subsys: the subsys we wanna iterate over
1043 : : * @start: the device to start iterating from, if any
1044 : : * @type: device_type of the devices to iterate over, NULL for all
1045 : : *
1046 : : * Initialize subsys iterator @iter such that it iterates over devices
1047 : : * of @subsys. If @start is set, the list iteration will start there,
1048 : : * otherwise if it is NULL, the iteration starts at the beginning of
1049 : : * the list.
1050 : : */
1051 : 0 : void subsys_dev_iter_init(struct subsys_dev_iter *iter, struct bus_type *subsys,
1052 : : struct device *start, const struct device_type *type)
1053 : : {
1054 : : struct klist_node *start_knode = NULL;
1055 : :
1056 [ # # ]: 0 : if (start)
1057 : 0 : start_knode = &start->p->knode_bus;
1058 : 0 : klist_iter_init_node(&subsys->p->klist_devices, &iter->ki, start_knode);
1059 : 0 : iter->type = type;
1060 : 0 : }
1061 : : EXPORT_SYMBOL_GPL(subsys_dev_iter_init);
1062 : :
1063 : : /**
1064 : : * subsys_dev_iter_next - iterate to the next device
1065 : : * @iter: subsys iterator to proceed
1066 : : *
1067 : : * Proceed @iter to the next device and return it. Returns NULL if
1068 : : * iteration is complete.
1069 : : *
1070 : : * The returned device is referenced and won't be released till
1071 : : * iterator is proceed to the next device or exited. The caller is
1072 : : * free to do whatever it wants to do with the device including
1073 : : * calling back into subsys code.
1074 : : */
1075 : 0 : struct device *subsys_dev_iter_next(struct subsys_dev_iter *iter)
1076 : : {
1077 : : struct klist_node *knode;
1078 : : struct device *dev;
1079 : :
1080 : : for (;;) {
1081 : 0 : knode = klist_next(&iter->ki);
1082 [ # # ]: 0 : if (!knode)
1083 : : return NULL;
1084 : 0 : dev = container_of(knode, struct device_private, knode_bus)->device;
1085 [ # # ][ # # ]: 0 : if (!iter->type || iter->type == dev->type)
1086 : : return dev;
1087 : : }
1088 : : }
1089 : : EXPORT_SYMBOL_GPL(subsys_dev_iter_next);
1090 : :
1091 : : /**
1092 : : * subsys_dev_iter_exit - finish iteration
1093 : : * @iter: subsys iterator to finish
1094 : : *
1095 : : * Finish an iteration. Always call this function after iteration is
1096 : : * complete whether the iteration ran till the end or not.
1097 : : */
1098 : 0 : void subsys_dev_iter_exit(struct subsys_dev_iter *iter)
1099 : : {
1100 : 0 : klist_iter_exit(&iter->ki);
1101 : 0 : }
1102 : : EXPORT_SYMBOL_GPL(subsys_dev_iter_exit);
1103 : :
1104 : 0 : int subsys_interface_register(struct subsys_interface *sif)
1105 : : {
1106 : : struct bus_type *subsys;
1107 : : struct subsys_dev_iter iter;
1108 : : struct device *dev;
1109 : :
1110 [ # # ][ # # ]: 0 : if (!sif || !sif->subsys)
1111 : : return -ENODEV;
1112 : :
1113 : : subsys = bus_get(sif->subsys);
1114 [ # # ]: 0 : if (!subsys)
1115 : : return -EINVAL;
1116 : :
1117 : 0 : mutex_lock(&subsys->p->mutex);
1118 : 0 : list_add_tail(&sif->node, &subsys->p->interfaces);
1119 [ # # ]: 0 : if (sif->add_dev) {
1120 : : subsys_dev_iter_init(&iter, subsys, NULL, NULL);
1121 [ # # ]: 0 : while ((dev = subsys_dev_iter_next(&iter)))
1122 : 0 : sif->add_dev(dev, sif);
1123 : : subsys_dev_iter_exit(&iter);
1124 : : }
1125 : 0 : mutex_unlock(&subsys->p->mutex);
1126 : :
1127 : 0 : return 0;
1128 : : }
1129 : : EXPORT_SYMBOL_GPL(subsys_interface_register);
1130 : :
1131 : 0 : void subsys_interface_unregister(struct subsys_interface *sif)
1132 : : {
1133 : : struct bus_type *subsys;
1134 : : struct subsys_dev_iter iter;
1135 : : struct device *dev;
1136 : :
1137 [ # # ][ # # ]: 0 : if (!sif || !sif->subsys)
1138 : 0 : return;
1139 : :
1140 : : subsys = sif->subsys;
1141 : :
1142 : 0 : mutex_lock(&subsys->p->mutex);
1143 : 0 : list_del_init(&sif->node);
1144 [ # # ]: 0 : if (sif->remove_dev) {
1145 : : subsys_dev_iter_init(&iter, subsys, NULL, NULL);
1146 [ # # ]: 0 : while ((dev = subsys_dev_iter_next(&iter)))
1147 : 0 : sif->remove_dev(dev, sif);
1148 : : subsys_dev_iter_exit(&iter);
1149 : : }
1150 : 0 : mutex_unlock(&subsys->p->mutex);
1151 : :
1152 : : bus_put(subsys);
1153 : : }
1154 : : EXPORT_SYMBOL_GPL(subsys_interface_unregister);
1155 : :
1156 : 0 : static void system_root_device_release(struct device *dev)
1157 : : {
1158 : 0 : kfree(dev);
1159 : 0 : }
1160 : :
1161 : 0 : static int subsys_register(struct bus_type *subsys,
1162 : : const struct attribute_group **groups,
1163 : : struct kobject *parent_of_root)
1164 : : {
1165 : : struct device *dev;
1166 : : int err;
1167 : :
1168 : 0 : err = bus_register(subsys);
1169 [ # # ]: 0 : if (err < 0)
1170 : : return err;
1171 : :
1172 : : dev = kzalloc(sizeof(struct device), GFP_KERNEL);
1173 [ # # ]: 0 : if (!dev) {
1174 : : err = -ENOMEM;
1175 : : goto err_dev;
1176 : : }
1177 : :
1178 : 0 : err = dev_set_name(dev, "%s", subsys->name);
1179 [ # # ]: 0 : if (err < 0)
1180 : : goto err_name;
1181 : :
1182 : 0 : dev->kobj.parent = parent_of_root;
1183 : 0 : dev->groups = groups;
1184 : 0 : dev->release = system_root_device_release;
1185 : :
1186 : 0 : err = device_register(dev);
1187 [ # # ]: 0 : if (err < 0)
1188 : : goto err_dev_reg;
1189 : :
1190 : 0 : subsys->dev_root = dev;
1191 : 0 : return 0;
1192 : :
1193 : : err_dev_reg:
1194 : 0 : put_device(dev);
1195 : : dev = NULL;
1196 : : err_name:
1197 : 0 : kfree(dev);
1198 : : err_dev:
1199 : 0 : bus_unregister(subsys);
1200 : 0 : return err;
1201 : : }
1202 : :
1203 : : /**
1204 : : * subsys_system_register - register a subsystem at /sys/devices/system/
1205 : : * @subsys: system subsystem
1206 : : * @groups: default attributes for the root device
1207 : : *
1208 : : * All 'system' subsystems have a /sys/devices/system/<name> root device
1209 : : * with the name of the subsystem. The root device can carry subsystem-
1210 : : * wide attributes. All registered devices are below this single root
1211 : : * device and are named after the subsystem with a simple enumeration
1212 : : * number appended. The registered devices are not explicitely named;
1213 : : * only 'id' in the device needs to be set.
1214 : : *
1215 : : * Do not use this interface for anything new, it exists for compatibility
1216 : : * with bad ideas only. New subsystems should use plain subsystems; and
1217 : : * add the subsystem-wide attributes should be added to the subsystem
1218 : : * directory itself and not some create fake root-device placed in
1219 : : * /sys/devices/system/<name>.
1220 : : */
1221 : 0 : int subsys_system_register(struct bus_type *subsys,
1222 : : const struct attribute_group **groups)
1223 : : {
1224 : 0 : return subsys_register(subsys, groups, &system_kset->kobj);
1225 : : }
1226 : : EXPORT_SYMBOL_GPL(subsys_system_register);
1227 : :
1228 : : /**
1229 : : * subsys_virtual_register - register a subsystem at /sys/devices/virtual/
1230 : : * @subsys: virtual subsystem
1231 : : * @groups: default attributes for the root device
1232 : : *
1233 : : * All 'virtual' subsystems have a /sys/devices/system/<name> root device
1234 : : * with the name of the subystem. The root device can carry subsystem-wide
1235 : : * attributes. All registered devices are below this single root device.
1236 : : * There's no restriction on device naming. This is for kernel software
1237 : : * constructs which need sysfs interface.
1238 : : */
1239 : 0 : int subsys_virtual_register(struct bus_type *subsys,
1240 : : const struct attribute_group **groups)
1241 : : {
1242 : : struct kobject *virtual_dir;
1243 : :
1244 : 0 : virtual_dir = virtual_device_parent(NULL);
1245 [ # # ]: 0 : if (!virtual_dir)
1246 : : return -ENOMEM;
1247 : :
1248 : 0 : return subsys_register(subsys, groups, virtual_dir);
1249 : : }
1250 : : EXPORT_SYMBOL_GPL(subsys_virtual_register);
1251 : :
1252 : 0 : int __init buses_init(void)
1253 : : {
1254 : 0 : bus_kset = kset_create_and_add("bus", &bus_uevent_ops, NULL);
1255 [ # # ]: 0 : if (!bus_kset)
1256 : : return -ENOMEM;
1257 : :
1258 : 0 : system_kset = kset_create_and_add("system", NULL, &devices_kset->kobj);
1259 [ # # ]: 0 : if (!system_kset)
1260 : : return -ENOMEM;
1261 : :
1262 : 0 : return 0;
1263 : : }
|
