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