2 * drivers/base/core.c - core driver model code (device registration, etc)
4 * Copyright (c) 2002-3 Patrick Mochel
5 * Copyright (c) 2002-3 Open Source Development Labs
6 * Copyright (c) 2006 Greg Kroah-Hartman <gregkh@suse.de>
7 * Copyright (c) 2006 Novell, Inc.
9 * This file is released under the GPLv2
13 #include <linux/device.h>
14 #include <linux/err.h>
15 #include <linux/init.h>
16 #include <linux/module.h>
17 #include <linux/slab.h>
18 #include <linux/string.h>
19 #include <linux/kdev_t.h>
20 #include <linux/notifier.h>
21 #include <linux/genhd.h>
22 #include <linux/kallsyms.h>
23 #include <linux/mutex.h>
24 #include <linux/async.h>
27 #include "power/power.h"
29 int (*platform_notify)(struct device *dev) = NULL;
30 int (*platform_notify_remove)(struct device *dev) = NULL;
31 static struct kobject *dev_kobj;
32 struct kobject *sysfs_dev_char_kobj;
33 struct kobject *sysfs_dev_block_kobj;
36 static inline int device_is_not_partition(struct device *dev)
38 return !(dev->type == &part_type);
41 static inline int device_is_not_partition(struct device *dev)
48 * dev_driver_string - Return a device's driver name, if at all possible
49 * @dev: struct device to get the name of
51 * Will return the device's driver's name if it is bound to a device. If
52 * the device is not bound to a device, it will return the name of the bus
53 * it is attached to. If it is not attached to a bus either, an empty
54 * string will be returned.
56 const char *dev_driver_string(const struct device *dev)
58 struct device_driver *drv;
60 /* dev->driver can change to NULL underneath us because of unbinding,
61 * so be careful about accessing it. dev->bus and dev->class should
62 * never change once they are set, so they don't need special care.
64 drv = ACCESS_ONCE(dev->driver);
65 return drv ? drv->name :
66 (dev->bus ? dev->bus->name :
67 (dev->class ? dev->class->name : ""));
69 EXPORT_SYMBOL(dev_driver_string);
71 #define to_dev(obj) container_of(obj, struct device, kobj)
72 #define to_dev_attr(_attr) container_of(_attr, struct device_attribute, attr)
74 static ssize_t dev_attr_show(struct kobject *kobj, struct attribute *attr,
77 struct device_attribute *dev_attr = to_dev_attr(attr);
78 struct device *dev = to_dev(kobj);
82 ret = dev_attr->show(dev, dev_attr, buf);
83 if (ret >= (ssize_t)PAGE_SIZE) {
84 print_symbol("dev_attr_show: %s returned bad count\n",
85 (unsigned long)dev_attr->show);
90 static ssize_t dev_attr_store(struct kobject *kobj, struct attribute *attr,
91 const char *buf, size_t count)
93 struct device_attribute *dev_attr = to_dev_attr(attr);
94 struct device *dev = to_dev(kobj);
98 ret = dev_attr->store(dev, dev_attr, buf, count);
102 static const struct sysfs_ops dev_sysfs_ops = {
103 .show = dev_attr_show,
104 .store = dev_attr_store,
109 * device_release - free device structure.
110 * @kobj: device's kobject.
112 * This is called once the reference count for the object
113 * reaches 0. We forward the call to the device's release
114 * method, which should handle actually freeing the structure.
116 static void device_release(struct kobject *kobj)
118 struct device *dev = to_dev(kobj);
119 struct device_private *p = dev->p;
123 else if (dev->type && dev->type->release)
124 dev->type->release(dev);
125 else if (dev->class && dev->class->dev_release)
126 dev->class->dev_release(dev);
128 WARN(1, KERN_ERR "Device '%s' does not have a release() "
129 "function, it is broken and must be fixed.\n",
134 static struct kobj_type device_ktype = {
135 .release = device_release,
136 .sysfs_ops = &dev_sysfs_ops,
140 static int dev_uevent_filter(struct kset *kset, struct kobject *kobj)
142 struct kobj_type *ktype = get_ktype(kobj);
144 if (ktype == &device_ktype) {
145 struct device *dev = to_dev(kobj);
154 static const char *dev_uevent_name(struct kset *kset, struct kobject *kobj)
156 struct device *dev = to_dev(kobj);
159 return dev->bus->name;
161 return dev->class->name;
165 static int dev_uevent(struct kset *kset, struct kobject *kobj,
166 struct kobj_uevent_env *env)
168 struct device *dev = to_dev(kobj);
171 /* add device node properties if present */
172 if (MAJOR(dev->devt)) {
177 add_uevent_var(env, "MAJOR=%u", MAJOR(dev->devt));
178 add_uevent_var(env, "MINOR=%u", MINOR(dev->devt));
179 name = device_get_devnode(dev, &mode, &tmp);
181 add_uevent_var(env, "DEVNAME=%s", name);
184 add_uevent_var(env, "DEVMODE=%#o", mode & 0777);
188 if (dev->type && dev->type->name)
189 add_uevent_var(env, "DEVTYPE=%s", dev->type->name);
192 add_uevent_var(env, "DRIVER=%s", dev->driver->name);
194 #ifdef CONFIG_SYSFS_DEPRECATED
196 struct device *parent = dev->parent;
198 /* find first bus device in parent chain */
199 while (parent && !parent->bus)
200 parent = parent->parent;
201 if (parent && parent->bus) {
204 path = kobject_get_path(&parent->kobj, GFP_KERNEL);
206 add_uevent_var(env, "PHYSDEVPATH=%s", path);
210 add_uevent_var(env, "PHYSDEVBUS=%s", parent->bus->name);
213 add_uevent_var(env, "PHYSDEVDRIVER=%s",
214 parent->driver->name);
216 } else if (dev->bus) {
217 add_uevent_var(env, "PHYSDEVBUS=%s", dev->bus->name);
220 add_uevent_var(env, "PHYSDEVDRIVER=%s",
225 /* have the bus specific function add its stuff */
226 if (dev->bus && dev->bus->uevent) {
227 retval = dev->bus->uevent(dev, env);
229 pr_debug("device: '%s': %s: bus uevent() returned %d\n",
230 dev_name(dev), __func__, retval);
233 /* have the class specific function add its stuff */
234 if (dev->class && dev->class->dev_uevent) {
235 retval = dev->class->dev_uevent(dev, env);
237 pr_debug("device: '%s': %s: class uevent() "
238 "returned %d\n", dev_name(dev),
242 /* have the device type specific fuction add its stuff */
243 if (dev->type && dev->type->uevent) {
244 retval = dev->type->uevent(dev, env);
246 pr_debug("device: '%s': %s: dev_type uevent() "
247 "returned %d\n", dev_name(dev),
254 static const struct kset_uevent_ops device_uevent_ops = {
255 .filter = dev_uevent_filter,
256 .name = dev_uevent_name,
257 .uevent = dev_uevent,
260 static ssize_t show_uevent(struct device *dev, struct device_attribute *attr,
263 struct kobject *top_kobj;
265 struct kobj_uevent_env *env = NULL;
270 /* search the kset, the device belongs to */
271 top_kobj = &dev->kobj;
272 while (!top_kobj->kset && top_kobj->parent)
273 top_kobj = top_kobj->parent;
277 kset = top_kobj->kset;
278 if (!kset->uevent_ops || !kset->uevent_ops->uevent)
282 if (kset->uevent_ops && kset->uevent_ops->filter)
283 if (!kset->uevent_ops->filter(kset, &dev->kobj))
286 env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL);
290 /* let the kset specific function add its keys */
291 retval = kset->uevent_ops->uevent(kset, &dev->kobj, env);
295 /* copy keys to file */
296 for (i = 0; i < env->envp_idx; i++)
297 count += sprintf(&buf[count], "%s\n", env->envp[i]);
303 static ssize_t store_uevent(struct device *dev, struct device_attribute *attr,
304 const char *buf, size_t count)
306 enum kobject_action action;
308 if (kobject_action_type(buf, count, &action) == 0)
309 kobject_uevent(&dev->kobj, action);
311 dev_err(dev, "uevent: unknown action-string\n");
315 static struct device_attribute uevent_attr =
316 __ATTR(uevent, S_IRUGO | S_IWUSR, show_uevent, store_uevent);
318 static int device_add_attributes(struct device *dev,
319 struct device_attribute *attrs)
325 for (i = 0; attr_name(attrs[i]); i++) {
326 error = device_create_file(dev, &attrs[i]);
332 device_remove_file(dev, &attrs[i]);
337 static void device_remove_attributes(struct device *dev,
338 struct device_attribute *attrs)
343 for (i = 0; attr_name(attrs[i]); i++)
344 device_remove_file(dev, &attrs[i]);
347 static int device_add_groups(struct device *dev,
348 const struct attribute_group **groups)
354 for (i = 0; groups[i]; i++) {
355 error = sysfs_create_group(&dev->kobj, groups[i]);
358 sysfs_remove_group(&dev->kobj,
367 static void device_remove_groups(struct device *dev,
368 const struct attribute_group **groups)
373 for (i = 0; groups[i]; i++)
374 sysfs_remove_group(&dev->kobj, groups[i]);
377 static int device_add_attrs(struct device *dev)
379 struct class *class = dev->class;
380 struct device_type *type = dev->type;
384 error = device_add_attributes(dev, class->dev_attrs);
390 error = device_add_groups(dev, type->groups);
392 goto err_remove_class_attrs;
395 error = device_add_groups(dev, dev->groups);
397 goto err_remove_type_groups;
401 err_remove_type_groups:
403 device_remove_groups(dev, type->groups);
404 err_remove_class_attrs:
406 device_remove_attributes(dev, class->dev_attrs);
411 static void device_remove_attrs(struct device *dev)
413 struct class *class = dev->class;
414 struct device_type *type = dev->type;
416 device_remove_groups(dev, dev->groups);
419 device_remove_groups(dev, type->groups);
422 device_remove_attributes(dev, class->dev_attrs);
426 static ssize_t show_dev(struct device *dev, struct device_attribute *attr,
429 return print_dev_t(buf, dev->devt);
432 static struct device_attribute devt_attr =
433 __ATTR(dev, S_IRUGO, show_dev, NULL);
435 /* kset to create /sys/devices/ */
436 struct kset *devices_kset;
439 * device_create_file - create sysfs attribute file for device.
441 * @attr: device attribute descriptor.
443 int device_create_file(struct device *dev,
444 const struct device_attribute *attr)
448 error = sysfs_create_file(&dev->kobj, &attr->attr);
453 * device_remove_file - remove sysfs attribute file.
455 * @attr: device attribute descriptor.
457 void device_remove_file(struct device *dev,
458 const struct device_attribute *attr)
461 sysfs_remove_file(&dev->kobj, &attr->attr);
465 * device_create_bin_file - create sysfs binary attribute file for device.
467 * @attr: device binary attribute descriptor.
469 int device_create_bin_file(struct device *dev,
470 const struct bin_attribute *attr)
474 error = sysfs_create_bin_file(&dev->kobj, attr);
477 EXPORT_SYMBOL_GPL(device_create_bin_file);
480 * device_remove_bin_file - remove sysfs binary attribute file
482 * @attr: device binary attribute descriptor.
484 void device_remove_bin_file(struct device *dev,
485 const struct bin_attribute *attr)
488 sysfs_remove_bin_file(&dev->kobj, attr);
490 EXPORT_SYMBOL_GPL(device_remove_bin_file);
493 * device_schedule_callback_owner - helper to schedule a callback for a device
495 * @func: callback function to invoke later.
496 * @owner: module owning the callback routine
498 * Attribute methods must not unregister themselves or their parent device
499 * (which would amount to the same thing). Attempts to do so will deadlock,
500 * since unregistration is mutually exclusive with driver callbacks.
502 * Instead methods can call this routine, which will attempt to allocate
503 * and schedule a workqueue request to call back @func with @dev as its
504 * argument in the workqueue's process context. @dev will be pinned until
507 * This routine is usually called via the inline device_schedule_callback(),
508 * which automatically sets @owner to THIS_MODULE.
510 * Returns 0 if the request was submitted, -ENOMEM if storage could not
511 * be allocated, -ENODEV if a reference to @owner isn't available.
513 * NOTE: This routine won't work if CONFIG_SYSFS isn't set! It uses an
514 * underlying sysfs routine (since it is intended for use by attribute
515 * methods), and if sysfs isn't available you'll get nothing but -ENOSYS.
517 int device_schedule_callback_owner(struct device *dev,
518 void (*func)(struct device *), struct module *owner)
520 return sysfs_schedule_callback(&dev->kobj,
521 (void (*)(void *)) func, dev, owner);
523 EXPORT_SYMBOL_GPL(device_schedule_callback_owner);
525 static void klist_children_get(struct klist_node *n)
527 struct device_private *p = to_device_private_parent(n);
528 struct device *dev = p->device;
533 static void klist_children_put(struct klist_node *n)
535 struct device_private *p = to_device_private_parent(n);
536 struct device *dev = p->device;
542 * device_initialize - init device structure.
545 * This prepares the device for use by other layers by initializing
547 * It is the first half of device_register(), if called by
548 * that function, though it can also be called separately, so one
549 * may use @dev's fields. In particular, get_device()/put_device()
550 * may be used for reference counting of @dev after calling this
553 * NOTE: Use put_device() to give up your reference instead of freeing
554 * @dev directly once you have called this function.
556 void device_initialize(struct device *dev)
558 dev->kobj.kset = devices_kset;
559 kobject_init(&dev->kobj, &device_ktype);
560 INIT_LIST_HEAD(&dev->dma_pools);
561 mutex_init(&dev->mutex);
562 spin_lock_init(&dev->devres_lock);
563 INIT_LIST_HEAD(&dev->devres_head);
565 set_dev_node(dev, -1);
568 #ifdef CONFIG_SYSFS_DEPRECATED
569 static struct kobject *get_device_parent(struct device *dev,
570 struct device *parent)
572 /* class devices without a parent live in /sys/class/<classname>/ */
573 if (dev->class && (!parent || parent->class != dev->class))
574 return &dev->class->p->class_subsys.kobj;
575 /* all other devices keep their parent */
577 return &parent->kobj;
582 static inline void cleanup_device_parent(struct device *dev) {}
583 static inline void cleanup_glue_dir(struct device *dev,
584 struct kobject *glue_dir) {}
586 static struct kobject *virtual_device_parent(struct device *dev)
588 static struct kobject *virtual_dir = NULL;
591 virtual_dir = kobject_create_and_add("virtual",
592 &devices_kset->kobj);
597 static struct kobject *get_device_parent(struct device *dev,
598 struct device *parent)
603 static DEFINE_MUTEX(gdp_mutex);
604 struct kobject *kobj = NULL;
605 struct kobject *parent_kobj;
609 * If we have no parent, we live in "virtual".
610 * Class-devices with a non class-device as parent, live
611 * in a "glue" directory to prevent namespace collisions.
614 parent_kobj = virtual_device_parent(dev);
615 else if (parent->class)
616 return &parent->kobj;
618 parent_kobj = &parent->kobj;
620 mutex_lock(&gdp_mutex);
622 /* find our class-directory at the parent and reference it */
623 spin_lock(&dev->class->p->class_dirs.list_lock);
624 list_for_each_entry(k, &dev->class->p->class_dirs.list, entry)
625 if (k->parent == parent_kobj) {
626 kobj = kobject_get(k);
629 spin_unlock(&dev->class->p->class_dirs.list_lock);
631 mutex_unlock(&gdp_mutex);
635 /* or create a new class-directory at the parent device */
636 k = kobject_create();
638 mutex_unlock(&gdp_mutex);
641 k->kset = &dev->class->p->class_dirs;
642 retval = kobject_add(k, parent_kobj, "%s", dev->class->name);
644 mutex_unlock(&gdp_mutex);
648 /* do not emit an uevent for this simple "glue" directory */
649 mutex_unlock(&gdp_mutex);
654 return &parent->kobj;
658 static void cleanup_glue_dir(struct device *dev, struct kobject *glue_dir)
660 /* see if we live in a "glue" directory */
661 if (!glue_dir || !dev->class ||
662 glue_dir->kset != &dev->class->p->class_dirs)
665 kobject_put(glue_dir);
668 static void cleanup_device_parent(struct device *dev)
670 cleanup_glue_dir(dev, dev->kobj.parent);
674 static void setup_parent(struct device *dev, struct device *parent)
676 struct kobject *kobj;
677 kobj = get_device_parent(dev, parent);
679 dev->kobj.parent = kobj;
682 static int device_add_class_symlinks(struct device *dev)
689 error = sysfs_create_link(&dev->kobj,
690 &dev->class->p->class_subsys.kobj,
695 #ifdef CONFIG_SYSFS_DEPRECATED
696 /* stacked class devices need a symlink in the class directory */
697 if (dev->kobj.parent != &dev->class->p->class_subsys.kobj &&
698 device_is_not_partition(dev)) {
699 error = sysfs_create_link(&dev->class->p->class_subsys.kobj,
700 &dev->kobj, dev_name(dev));
705 if (dev->parent && device_is_not_partition(dev)) {
706 struct device *parent = dev->parent;
710 * stacked class devices have the 'device' link
711 * pointing to the bus device instead of the parent
713 while (parent->class && !parent->bus && parent->parent)
714 parent = parent->parent;
716 error = sysfs_create_link(&dev->kobj,
722 class_name = make_class_name(dev->class->name,
725 error = sysfs_create_link(&dev->parent->kobj,
726 &dev->kobj, class_name);
734 if (dev->parent && device_is_not_partition(dev))
735 sysfs_remove_link(&dev->kobj, "device");
737 if (dev->kobj.parent != &dev->class->p->class_subsys.kobj &&
738 device_is_not_partition(dev))
739 sysfs_remove_link(&dev->class->p->class_subsys.kobj,
742 /* link in the class directory pointing to the device */
743 error = sysfs_create_link(&dev->class->p->class_subsys.kobj,
744 &dev->kobj, dev_name(dev));
748 if (dev->parent && device_is_not_partition(dev)) {
749 error = sysfs_create_link(&dev->kobj, &dev->parent->kobj,
757 sysfs_remove_link(&dev->class->p->class_subsys.kobj, dev_name(dev));
761 sysfs_remove_link(&dev->kobj, "subsystem");
766 static void device_remove_class_symlinks(struct device *dev)
771 #ifdef CONFIG_SYSFS_DEPRECATED
772 if (dev->parent && device_is_not_partition(dev)) {
775 class_name = make_class_name(dev->class->name, &dev->kobj);
777 sysfs_remove_link(&dev->parent->kobj, class_name);
780 sysfs_remove_link(&dev->kobj, "device");
783 if (dev->kobj.parent != &dev->class->p->class_subsys.kobj &&
784 device_is_not_partition(dev))
785 sysfs_remove_link(&dev->class->p->class_subsys.kobj,
788 if (dev->parent && device_is_not_partition(dev))
789 sysfs_remove_link(&dev->kobj, "device");
791 sysfs_remove_link(&dev->class->p->class_subsys.kobj, dev_name(dev));
794 sysfs_remove_link(&dev->kobj, "subsystem");
798 * dev_set_name - set a device name
800 * @fmt: format string for the device's name
802 int dev_set_name(struct device *dev, const char *fmt, ...)
807 va_start(vargs, fmt);
808 err = kobject_set_name_vargs(&dev->kobj, fmt, vargs);
812 EXPORT_SYMBOL_GPL(dev_set_name);
815 * device_to_dev_kobj - select a /sys/dev/ directory for the device
818 * By default we select char/ for new entries. Setting class->dev_obj
819 * to NULL prevents an entry from being created. class->dev_kobj must
820 * be set (or cleared) before any devices are registered to the class
821 * otherwise device_create_sys_dev_entry() and
822 * device_remove_sys_dev_entry() will disagree about the the presence
825 static struct kobject *device_to_dev_kobj(struct device *dev)
827 struct kobject *kobj;
830 kobj = dev->class->dev_kobj;
832 kobj = sysfs_dev_char_kobj;
837 static int device_create_sys_dev_entry(struct device *dev)
839 struct kobject *kobj = device_to_dev_kobj(dev);
844 format_dev_t(devt_str, dev->devt);
845 error = sysfs_create_link(kobj, &dev->kobj, devt_str);
851 static void device_remove_sys_dev_entry(struct device *dev)
853 struct kobject *kobj = device_to_dev_kobj(dev);
857 format_dev_t(devt_str, dev->devt);
858 sysfs_remove_link(kobj, devt_str);
862 int device_private_init(struct device *dev)
864 dev->p = kzalloc(sizeof(*dev->p), GFP_KERNEL);
867 dev->p->device = dev;
868 klist_init(&dev->p->klist_children, klist_children_get,
874 * device_add - add device to device hierarchy.
877 * This is part 2 of device_register(), though may be called
878 * separately _iff_ device_initialize() has been called separately.
880 * This adds @dev to the kobject hierarchy via kobject_add(), adds it
881 * to the global and sibling lists for the device, then
882 * adds it to the other relevant subsystems of the driver model.
884 * NOTE: _Never_ directly free @dev after calling this function, even
885 * if it returned an error! Always use put_device() to give up your
888 int device_add(struct device *dev)
890 struct device *parent = NULL;
891 struct class_interface *class_intf;
894 dev = get_device(dev);
899 error = device_private_init(dev);
905 * for statically allocated devices, which should all be converted
906 * some day, we need to initialize the name. We prevent reading back
907 * the name, and force the use of dev_name()
909 if (dev->init_name) {
910 dev_set_name(dev, "%s", dev->init_name);
911 dev->init_name = NULL;
914 if (!dev_name(dev)) {
919 pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
921 parent = get_device(dev->parent);
922 setup_parent(dev, parent);
924 /* use parent numa_node */
926 set_dev_node(dev, dev_to_node(parent));
928 /* first, register with generic layer. */
929 /* we require the name to be set before, and pass NULL */
930 error = kobject_add(&dev->kobj, dev->kobj.parent, NULL);
934 /* notify platform of device entry */
936 platform_notify(dev);
938 error = device_create_file(dev, &uevent_attr);
942 if (MAJOR(dev->devt)) {
943 error = device_create_file(dev, &devt_attr);
945 goto ueventattrError;
947 error = device_create_sys_dev_entry(dev);
951 devtmpfs_create_node(dev);
954 error = device_add_class_symlinks(dev);
957 error = device_add_attrs(dev);
960 error = bus_add_device(dev);
963 error = dpm_sysfs_add(dev);
968 /* Notify clients of device addition. This call must come
969 * after dpm_sysf_add() and before kobject_uevent().
972 blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
973 BUS_NOTIFY_ADD_DEVICE, dev);
975 kobject_uevent(&dev->kobj, KOBJ_ADD);
976 bus_probe_device(dev);
978 klist_add_tail(&dev->p->knode_parent,
979 &parent->p->klist_children);
982 mutex_lock(&dev->class->p->class_mutex);
983 /* tie the class to the device */
984 klist_add_tail(&dev->knode_class,
985 &dev->class->p->class_devices);
987 /* notify any interfaces that the device is here */
988 list_for_each_entry(class_intf,
989 &dev->class->p->class_interfaces, node)
990 if (class_intf->add_dev)
991 class_intf->add_dev(dev, class_intf);
992 mutex_unlock(&dev->class->p->class_mutex);
998 bus_remove_device(dev);
1000 device_remove_attrs(dev);
1002 device_remove_class_symlinks(dev);
1004 if (MAJOR(dev->devt))
1005 devtmpfs_delete_node(dev);
1006 if (MAJOR(dev->devt))
1007 device_remove_sys_dev_entry(dev);
1009 if (MAJOR(dev->devt))
1010 device_remove_file(dev, &devt_attr);
1012 device_remove_file(dev, &uevent_attr);
1014 kobject_uevent(&dev->kobj, KOBJ_REMOVE);
1015 kobject_del(&dev->kobj);
1017 cleanup_device_parent(dev);
1027 * device_register - register a device with the system.
1028 * @dev: pointer to the device structure
1030 * This happens in two clean steps - initialize the device
1031 * and add it to the system. The two steps can be called
1032 * separately, but this is the easiest and most common.
1033 * I.e. you should only call the two helpers separately if
1034 * have a clearly defined need to use and refcount the device
1035 * before it is added to the hierarchy.
1037 * NOTE: _Never_ directly free @dev after calling this function, even
1038 * if it returned an error! Always use put_device() to give up the
1039 * reference initialized in this function instead.
1041 int device_register(struct device *dev)
1043 device_initialize(dev);
1044 return device_add(dev);
1048 * get_device - increment reference count for device.
1051 * This simply forwards the call to kobject_get(), though
1052 * we do take care to provide for the case that we get a NULL
1053 * pointer passed in.
1055 struct device *get_device(struct device *dev)
1057 return dev ? to_dev(kobject_get(&dev->kobj)) : NULL;
1061 * put_device - decrement reference count.
1062 * @dev: device in question.
1064 void put_device(struct device *dev)
1066 /* might_sleep(); */
1068 kobject_put(&dev->kobj);
1072 * device_del - delete device from system.
1075 * This is the first part of the device unregistration
1076 * sequence. This removes the device from the lists we control
1077 * from here, has it removed from the other driver model
1078 * subsystems it was added to in device_add(), and removes it
1079 * from the kobject hierarchy.
1081 * NOTE: this should be called manually _iff_ device_add() was
1082 * also called manually.
1084 void device_del(struct device *dev)
1086 struct device *parent = dev->parent;
1087 struct class_interface *class_intf;
1089 /* Notify clients of device removal. This call must come
1090 * before dpm_sysfs_remove().
1093 blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
1094 BUS_NOTIFY_DEL_DEVICE, dev);
1095 device_pm_remove(dev);
1096 dpm_sysfs_remove(dev);
1098 klist_del(&dev->p->knode_parent);
1099 if (MAJOR(dev->devt)) {
1100 devtmpfs_delete_node(dev);
1101 device_remove_sys_dev_entry(dev);
1102 device_remove_file(dev, &devt_attr);
1105 device_remove_class_symlinks(dev);
1107 mutex_lock(&dev->class->p->class_mutex);
1108 /* notify any interfaces that the device is now gone */
1109 list_for_each_entry(class_intf,
1110 &dev->class->p->class_interfaces, node)
1111 if (class_intf->remove_dev)
1112 class_intf->remove_dev(dev, class_intf);
1113 /* remove the device from the class list */
1114 klist_del(&dev->knode_class);
1115 mutex_unlock(&dev->class->p->class_mutex);
1117 device_remove_file(dev, &uevent_attr);
1118 device_remove_attrs(dev);
1119 bus_remove_device(dev);
1122 * Some platform devices are driven without driver attached
1123 * and managed resources may have been acquired. Make sure
1124 * all resources are released.
1126 devres_release_all(dev);
1128 /* Notify the platform of the removal, in case they
1129 * need to do anything...
1131 if (platform_notify_remove)
1132 platform_notify_remove(dev);
1133 kobject_uevent(&dev->kobj, KOBJ_REMOVE);
1134 cleanup_device_parent(dev);
1135 kobject_del(&dev->kobj);
1140 * device_unregister - unregister device from system.
1141 * @dev: device going away.
1143 * We do this in two parts, like we do device_register(). First,
1144 * we remove it from all the subsystems with device_del(), then
1145 * we decrement the reference count via put_device(). If that
1146 * is the final reference count, the device will be cleaned up
1147 * via device_release() above. Otherwise, the structure will
1148 * stick around until the final reference to the device is dropped.
1150 void device_unregister(struct device *dev)
1152 pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
1157 static struct device *next_device(struct klist_iter *i)
1159 struct klist_node *n = klist_next(i);
1160 struct device *dev = NULL;
1161 struct device_private *p;
1164 p = to_device_private_parent(n);
1171 * device_get_devnode - path of device node file
1173 * @mode: returned file access mode
1174 * @tmp: possibly allocated string
1176 * Return the relative path of a possible device node.
1177 * Non-default names may need to allocate a memory to compose
1178 * a name. This memory is returned in tmp and needs to be
1179 * freed by the caller.
1181 const char *device_get_devnode(struct device *dev,
1182 mode_t *mode, const char **tmp)
1188 /* the device type may provide a specific name */
1189 if (dev->type && dev->type->devnode)
1190 *tmp = dev->type->devnode(dev, mode);
1194 /* the class may provide a specific name */
1195 if (dev->class && dev->class->devnode)
1196 *tmp = dev->class->devnode(dev, mode);
1200 /* return name without allocation, tmp == NULL */
1201 if (strchr(dev_name(dev), '!') == NULL)
1202 return dev_name(dev);
1204 /* replace '!' in the name with '/' */
1205 *tmp = kstrdup(dev_name(dev), GFP_KERNEL);
1208 while ((s = strchr(*tmp, '!')))
1214 * device_for_each_child - device child iterator.
1215 * @parent: parent struct device.
1216 * @data: data for the callback.
1217 * @fn: function to be called for each device.
1219 * Iterate over @parent's child devices, and call @fn for each,
1222 * We check the return of @fn each time. If it returns anything
1223 * other than 0, we break out and return that value.
1225 int device_for_each_child(struct device *parent, void *data,
1226 int (*fn)(struct device *dev, void *data))
1228 struct klist_iter i;
1229 struct device *child;
1235 klist_iter_init(&parent->p->klist_children, &i);
1236 while ((child = next_device(&i)) && !error)
1237 error = fn(child, data);
1238 klist_iter_exit(&i);
1243 * device_find_child - device iterator for locating a particular device.
1244 * @parent: parent struct device
1245 * @data: Data to pass to match function
1246 * @match: Callback function to check device
1248 * This is similar to the device_for_each_child() function above, but it
1249 * returns a reference to a device that is 'found' for later use, as
1250 * determined by the @match callback.
1252 * The callback should return 0 if the device doesn't match and non-zero
1253 * if it does. If the callback returns non-zero and a reference to the
1254 * current device can be obtained, this function will return to the caller
1255 * and not iterate over any more devices.
1257 struct device *device_find_child(struct device *parent, void *data,
1258 int (*match)(struct device *dev, void *data))
1260 struct klist_iter i;
1261 struct device *child;
1266 klist_iter_init(&parent->p->klist_children, &i);
1267 while ((child = next_device(&i)))
1268 if (match(child, data) && get_device(child))
1270 klist_iter_exit(&i);
1274 int __init devices_init(void)
1276 devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL);
1279 dev_kobj = kobject_create_and_add("dev", NULL);
1282 sysfs_dev_block_kobj = kobject_create_and_add("block", dev_kobj);
1283 if (!sysfs_dev_block_kobj)
1284 goto block_kobj_err;
1285 sysfs_dev_char_kobj = kobject_create_and_add("char", dev_kobj);
1286 if (!sysfs_dev_char_kobj)
1292 kobject_put(sysfs_dev_block_kobj);
1294 kobject_put(dev_kobj);
1296 kset_unregister(devices_kset);
1300 EXPORT_SYMBOL_GPL(device_for_each_child);
1301 EXPORT_SYMBOL_GPL(device_find_child);
1303 EXPORT_SYMBOL_GPL(device_initialize);
1304 EXPORT_SYMBOL_GPL(device_add);
1305 EXPORT_SYMBOL_GPL(device_register);
1307 EXPORT_SYMBOL_GPL(device_del);
1308 EXPORT_SYMBOL_GPL(device_unregister);
1309 EXPORT_SYMBOL_GPL(get_device);
1310 EXPORT_SYMBOL_GPL(put_device);
1312 EXPORT_SYMBOL_GPL(device_create_file);
1313 EXPORT_SYMBOL_GPL(device_remove_file);
1318 struct module *owner;
1321 #define to_root_device(dev) container_of(dev, struct root_device, dev)
1323 static void root_device_release(struct device *dev)
1325 kfree(to_root_device(dev));
1329 * __root_device_register - allocate and register a root device
1330 * @name: root device name
1331 * @owner: owner module of the root device, usually THIS_MODULE
1333 * This function allocates a root device and registers it
1334 * using device_register(). In order to free the returned
1335 * device, use root_device_unregister().
1337 * Root devices are dummy devices which allow other devices
1338 * to be grouped under /sys/devices. Use this function to
1339 * allocate a root device and then use it as the parent of
1340 * any device which should appear under /sys/devices/{name}
1342 * The /sys/devices/{name} directory will also contain a
1343 * 'module' symlink which points to the @owner directory
1346 * Returns &struct device pointer on success, or ERR_PTR() on error.
1348 * Note: You probably want to use root_device_register().
1350 struct device *__root_device_register(const char *name, struct module *owner)
1352 struct root_device *root;
1355 root = kzalloc(sizeof(struct root_device), GFP_KERNEL);
1357 return ERR_PTR(err);
1359 err = dev_set_name(&root->dev, "%s", name);
1362 return ERR_PTR(err);
1365 root->dev.release = root_device_release;
1367 err = device_register(&root->dev);
1369 put_device(&root->dev);
1370 return ERR_PTR(err);
1373 #ifdef CONFIG_MODULE /* gotta find a "cleaner" way to do this */
1375 struct module_kobject *mk = &owner->mkobj;
1377 err = sysfs_create_link(&root->dev.kobj, &mk->kobj, "module");
1379 device_unregister(&root->dev);
1380 return ERR_PTR(err);
1382 root->owner = owner;
1388 EXPORT_SYMBOL_GPL(__root_device_register);
1391 * root_device_unregister - unregister and free a root device
1392 * @dev: device going away
1394 * This function unregisters and cleans up a device that was created by
1395 * root_device_register().
1397 void root_device_unregister(struct device *dev)
1399 struct root_device *root = to_root_device(dev);
1402 sysfs_remove_link(&root->dev.kobj, "module");
1404 device_unregister(dev);
1406 EXPORT_SYMBOL_GPL(root_device_unregister);
1409 static void device_create_release(struct device *dev)
1411 pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
1416 * device_create_vargs - creates a device and registers it with sysfs
1417 * @class: pointer to the struct class that this device should be registered to
1418 * @parent: pointer to the parent struct device of this new device, if any
1419 * @devt: the dev_t for the char device to be added
1420 * @drvdata: the data to be added to the device for callbacks
1421 * @fmt: string for the device's name
1422 * @args: va_list for the device's name
1424 * This function can be used by char device classes. A struct device
1425 * will be created in sysfs, registered to the specified class.
1427 * A "dev" file will be created, showing the dev_t for the device, if
1428 * the dev_t is not 0,0.
1429 * If a pointer to a parent struct device is passed in, the newly created
1430 * struct device will be a child of that device in sysfs.
1431 * The pointer to the struct device will be returned from the call.
1432 * Any further sysfs files that might be required can be created using this
1435 * Returns &struct device pointer on success, or ERR_PTR() on error.
1437 * Note: the struct class passed to this function must have previously
1438 * been created with a call to class_create().
1440 struct device *device_create_vargs(struct class *class, struct device *parent,
1441 dev_t devt, void *drvdata, const char *fmt,
1444 struct device *dev = NULL;
1445 int retval = -ENODEV;
1447 if (class == NULL || IS_ERR(class))
1450 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1458 dev->parent = parent;
1459 dev->release = device_create_release;
1460 dev_set_drvdata(dev, drvdata);
1462 retval = kobject_set_name_vargs(&dev->kobj, fmt, args);
1466 retval = device_register(dev);
1474 return ERR_PTR(retval);
1476 EXPORT_SYMBOL_GPL(device_create_vargs);
1479 * device_create - creates a device and registers it with sysfs
1480 * @class: pointer to the struct class that this device should be registered to
1481 * @parent: pointer to the parent struct device of this new device, if any
1482 * @devt: the dev_t for the char device to be added
1483 * @drvdata: the data to be added to the device for callbacks
1484 * @fmt: string for the device's name
1486 * This function can be used by char device classes. A struct device
1487 * will be created in sysfs, registered to the specified class.
1489 * A "dev" file will be created, showing the dev_t for the device, if
1490 * the dev_t is not 0,0.
1491 * If a pointer to a parent struct device is passed in, the newly created
1492 * struct device will be a child of that device in sysfs.
1493 * The pointer to the struct device will be returned from the call.
1494 * Any further sysfs files that might be required can be created using this
1497 * Returns &struct device pointer on success, or ERR_PTR() on error.
1499 * Note: the struct class passed to this function must have previously
1500 * been created with a call to class_create().
1502 struct device *device_create(struct class *class, struct device *parent,
1503 dev_t devt, void *drvdata, const char *fmt, ...)
1508 va_start(vargs, fmt);
1509 dev = device_create_vargs(class, parent, devt, drvdata, fmt, vargs);
1513 EXPORT_SYMBOL_GPL(device_create);
1515 static int __match_devt(struct device *dev, void *data)
1519 return dev->devt == *devt;
1523 * device_destroy - removes a device that was created with device_create()
1524 * @class: pointer to the struct class that this device was registered with
1525 * @devt: the dev_t of the device that was previously registered
1527 * This call unregisters and cleans up a device that was created with a
1528 * call to device_create().
1530 void device_destroy(struct class *class, dev_t devt)
1534 dev = class_find_device(class, NULL, &devt, __match_devt);
1537 device_unregister(dev);
1540 EXPORT_SYMBOL_GPL(device_destroy);
1543 * device_rename - renames a device
1544 * @dev: the pointer to the struct device to be renamed
1545 * @new_name: the new name of the device
1547 * It is the responsibility of the caller to provide mutual
1548 * exclusion between two different calls of device_rename
1549 * on the same device to ensure that new_name is valid and
1550 * won't conflict with other devices.
1552 int device_rename(struct device *dev, char *new_name)
1554 char *old_class_name = NULL;
1555 char *new_class_name = NULL;
1556 char *old_device_name = NULL;
1559 dev = get_device(dev);
1563 pr_debug("device: '%s': %s: renaming to '%s'\n", dev_name(dev),
1564 __func__, new_name);
1566 #ifdef CONFIG_SYSFS_DEPRECATED
1567 if ((dev->class) && (dev->parent))
1568 old_class_name = make_class_name(dev->class->name, &dev->kobj);
1571 old_device_name = kstrdup(dev_name(dev), GFP_KERNEL);
1572 if (!old_device_name) {
1577 error = kobject_rename(&dev->kobj, new_name);
1581 #ifdef CONFIG_SYSFS_DEPRECATED
1582 if (old_class_name) {
1583 new_class_name = make_class_name(dev->class->name, &dev->kobj);
1584 if (new_class_name) {
1585 error = sysfs_rename_link(&dev->parent->kobj,
1593 error = sysfs_rename_link(&dev->class->p->class_subsys.kobj,
1594 &dev->kobj, old_device_name, new_name);
1601 kfree(new_class_name);
1602 kfree(old_class_name);
1603 kfree(old_device_name);
1607 EXPORT_SYMBOL_GPL(device_rename);
1609 static int device_move_class_links(struct device *dev,
1610 struct device *old_parent,
1611 struct device *new_parent)
1614 #ifdef CONFIG_SYSFS_DEPRECATED
1617 class_name = make_class_name(dev->class->name, &dev->kobj);
1623 sysfs_remove_link(&dev->kobj, "device");
1624 sysfs_remove_link(&old_parent->kobj, class_name);
1627 error = sysfs_create_link(&dev->kobj, &new_parent->kobj,
1631 error = sysfs_create_link(&new_parent->kobj, &dev->kobj,
1634 sysfs_remove_link(&dev->kobj, "device");
1642 sysfs_remove_link(&dev->kobj, "device");
1644 error = sysfs_create_link(&dev->kobj, &new_parent->kobj,
1651 * device_move - moves a device to a new parent
1652 * @dev: the pointer to the struct device to be moved
1653 * @new_parent: the new parent of the device (can by NULL)
1654 * @dpm_order: how to reorder the dpm_list
1656 int device_move(struct device *dev, struct device *new_parent,
1657 enum dpm_order dpm_order)
1660 struct device *old_parent;
1661 struct kobject *new_parent_kobj;
1663 dev = get_device(dev);
1668 new_parent = get_device(new_parent);
1669 new_parent_kobj = get_device_parent(dev, new_parent);
1671 pr_debug("device: '%s': %s: moving to '%s'\n", dev_name(dev),
1672 __func__, new_parent ? dev_name(new_parent) : "<NULL>");
1673 error = kobject_move(&dev->kobj, new_parent_kobj);
1675 cleanup_glue_dir(dev, new_parent_kobj);
1676 put_device(new_parent);
1679 old_parent = dev->parent;
1680 dev->parent = new_parent;
1682 klist_remove(&dev->p->knode_parent);
1684 klist_add_tail(&dev->p->knode_parent,
1685 &new_parent->p->klist_children);
1686 set_dev_node(dev, dev_to_node(new_parent));
1691 error = device_move_class_links(dev, old_parent, new_parent);
1693 /* We ignore errors on cleanup since we're hosed anyway... */
1694 device_move_class_links(dev, new_parent, old_parent);
1695 if (!kobject_move(&dev->kobj, &old_parent->kobj)) {
1697 klist_remove(&dev->p->knode_parent);
1698 dev->parent = old_parent;
1700 klist_add_tail(&dev->p->knode_parent,
1701 &old_parent->p->klist_children);
1702 set_dev_node(dev, dev_to_node(old_parent));
1705 cleanup_glue_dir(dev, new_parent_kobj);
1706 put_device(new_parent);
1709 switch (dpm_order) {
1710 case DPM_ORDER_NONE:
1712 case DPM_ORDER_DEV_AFTER_PARENT:
1713 device_pm_move_after(dev, new_parent);
1715 case DPM_ORDER_PARENT_BEFORE_DEV:
1716 device_pm_move_before(new_parent, dev);
1718 case DPM_ORDER_DEV_LAST:
1719 device_pm_move_last(dev);
1723 put_device(old_parent);
1729 EXPORT_SYMBOL_GPL(device_move);
1732 * device_shutdown - call ->shutdown() on each device to shutdown.
1734 void device_shutdown(void)
1736 struct device *dev, *devn;
1738 list_for_each_entry_safe_reverse(dev, devn, &devices_kset->list,
1740 if (dev->bus && dev->bus->shutdown) {
1741 dev_dbg(dev, "shutdown\n");
1742 dev->bus->shutdown(dev);
1743 } else if (dev->driver && dev->driver->shutdown) {
1744 dev_dbg(dev, "shutdown\n");
1745 dev->driver->shutdown(dev);
1748 async_synchronize_full();