Loading...
1/*
2 * drivers/base/core.c - core driver model code (device registration, etc)
3 *
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.
8 *
9 * This file is released under the GPLv2
10 *
11 */
12
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>
25
26#include "base.h"
27#include "power/power.h"
28
29#ifdef CONFIG_SYSFS_DEPRECATED
30#ifdef CONFIG_SYSFS_DEPRECATED_V2
31long sysfs_deprecated = 1;
32#else
33long sysfs_deprecated = 0;
34#endif
35static __init int sysfs_deprecated_setup(char *arg)
36{
37 return strict_strtol(arg, 10, &sysfs_deprecated);
38}
39early_param("sysfs.deprecated", sysfs_deprecated_setup);
40#endif
41
42int (*platform_notify)(struct device *dev) = NULL;
43int (*platform_notify_remove)(struct device *dev) = NULL;
44static struct kobject *dev_kobj;
45struct kobject *sysfs_dev_char_kobj;
46struct kobject *sysfs_dev_block_kobj;
47
48#ifdef CONFIG_BLOCK
49static inline int device_is_not_partition(struct device *dev)
50{
51 return !(dev->type == &part_type);
52}
53#else
54static inline int device_is_not_partition(struct device *dev)
55{
56 return 1;
57}
58#endif
59
60/**
61 * dev_driver_string - Return a device's driver name, if at all possible
62 * @dev: struct device to get the name of
63 *
64 * Will return the device's driver's name if it is bound to a device. If
65 * the device is not bound to a device, it will return the name of the bus
66 * it is attached to. If it is not attached to a bus either, an empty
67 * string will be returned.
68 */
69const char *dev_driver_string(const struct device *dev)
70{
71 struct device_driver *drv;
72
73 /* dev->driver can change to NULL underneath us because of unbinding,
74 * so be careful about accessing it. dev->bus and dev->class should
75 * never change once they are set, so they don't need special care.
76 */
77 drv = ACCESS_ONCE(dev->driver);
78 return drv ? drv->name :
79 (dev->bus ? dev->bus->name :
80 (dev->class ? dev->class->name : ""));
81}
82EXPORT_SYMBOL(dev_driver_string);
83
84#define to_dev(obj) container_of(obj, struct device, kobj)
85#define to_dev_attr(_attr) container_of(_attr, struct device_attribute, attr)
86
87static ssize_t dev_attr_show(struct kobject *kobj, struct attribute *attr,
88 char *buf)
89{
90 struct device_attribute *dev_attr = to_dev_attr(attr);
91 struct device *dev = to_dev(kobj);
92 ssize_t ret = -EIO;
93
94 if (dev_attr->show)
95 ret = dev_attr->show(dev, dev_attr, buf);
96 if (ret >= (ssize_t)PAGE_SIZE) {
97 print_symbol("dev_attr_show: %s returned bad count\n",
98 (unsigned long)dev_attr->show);
99 }
100 return ret;
101}
102
103static ssize_t dev_attr_store(struct kobject *kobj, struct attribute *attr,
104 const char *buf, size_t count)
105{
106 struct device_attribute *dev_attr = to_dev_attr(attr);
107 struct device *dev = to_dev(kobj);
108 ssize_t ret = -EIO;
109
110 if (dev_attr->store)
111 ret = dev_attr->store(dev, dev_attr, buf, count);
112 return ret;
113}
114
115static const struct sysfs_ops dev_sysfs_ops = {
116 .show = dev_attr_show,
117 .store = dev_attr_store,
118};
119
120
121/**
122 * device_release - free device structure.
123 * @kobj: device's kobject.
124 *
125 * This is called once the reference count for the object
126 * reaches 0. We forward the call to the device's release
127 * method, which should handle actually freeing the structure.
128 */
129static void device_release(struct kobject *kobj)
130{
131 struct device *dev = to_dev(kobj);
132 struct device_private *p = dev->p;
133
134 if (dev->release)
135 dev->release(dev);
136 else if (dev->type && dev->type->release)
137 dev->type->release(dev);
138 else if (dev->class && dev->class->dev_release)
139 dev->class->dev_release(dev);
140 else
141 WARN(1, KERN_ERR "Device '%s' does not have a release() "
142 "function, it is broken and must be fixed.\n",
143 dev_name(dev));
144 kfree(p);
145}
146
147static const void *device_namespace(struct kobject *kobj)
148{
149 struct device *dev = to_dev(kobj);
150 const void *ns = NULL;
151
152 if (dev->class && dev->class->ns_type)
153 ns = dev->class->namespace(dev);
154
155 return ns;
156}
157
158static struct kobj_type device_ktype = {
159 .release = device_release,
160 .sysfs_ops = &dev_sysfs_ops,
161 .namespace = device_namespace,
162};
163
164
165static int dev_uevent_filter(struct kset *kset, struct kobject *kobj)
166{
167 struct kobj_type *ktype = get_ktype(kobj);
168
169 if (ktype == &device_ktype) {
170 struct device *dev = to_dev(kobj);
171 if (dev->bus)
172 return 1;
173 if (dev->class)
174 return 1;
175 }
176 return 0;
177}
178
179static const char *dev_uevent_name(struct kset *kset, struct kobject *kobj)
180{
181 struct device *dev = to_dev(kobj);
182
183 if (dev->bus)
184 return dev->bus->name;
185 if (dev->class)
186 return dev->class->name;
187 return NULL;
188}
189
190static int dev_uevent(struct kset *kset, struct kobject *kobj,
191 struct kobj_uevent_env *env)
192{
193 struct device *dev = to_dev(kobj);
194 int retval = 0;
195
196 /* add device node properties if present */
197 if (MAJOR(dev->devt)) {
198 const char *tmp;
199 const char *name;
200 mode_t mode = 0;
201
202 add_uevent_var(env, "MAJOR=%u", MAJOR(dev->devt));
203 add_uevent_var(env, "MINOR=%u", MINOR(dev->devt));
204 name = device_get_devnode(dev, &mode, &tmp);
205 if (name) {
206 add_uevent_var(env, "DEVNAME=%s", name);
207 kfree(tmp);
208 if (mode)
209 add_uevent_var(env, "DEVMODE=%#o", mode & 0777);
210 }
211 }
212
213 if (dev->type && dev->type->name)
214 add_uevent_var(env, "DEVTYPE=%s", dev->type->name);
215
216 if (dev->driver)
217 add_uevent_var(env, "DRIVER=%s", dev->driver->name);
218
219 /* have the bus specific function add its stuff */
220 if (dev->bus && dev->bus->uevent) {
221 retval = dev->bus->uevent(dev, env);
222 if (retval)
223 pr_debug("device: '%s': %s: bus uevent() returned %d\n",
224 dev_name(dev), __func__, retval);
225 }
226
227 /* have the class specific function add its stuff */
228 if (dev->class && dev->class->dev_uevent) {
229 retval = dev->class->dev_uevent(dev, env);
230 if (retval)
231 pr_debug("device: '%s': %s: class uevent() "
232 "returned %d\n", dev_name(dev),
233 __func__, retval);
234 }
235
236 /* have the device type specific function add its stuff */
237 if (dev->type && dev->type->uevent) {
238 retval = dev->type->uevent(dev, env);
239 if (retval)
240 pr_debug("device: '%s': %s: dev_type uevent() "
241 "returned %d\n", dev_name(dev),
242 __func__, retval);
243 }
244
245 return retval;
246}
247
248static const struct kset_uevent_ops device_uevent_ops = {
249 .filter = dev_uevent_filter,
250 .name = dev_uevent_name,
251 .uevent = dev_uevent,
252};
253
254static ssize_t show_uevent(struct device *dev, struct device_attribute *attr,
255 char *buf)
256{
257 struct kobject *top_kobj;
258 struct kset *kset;
259 struct kobj_uevent_env *env = NULL;
260 int i;
261 size_t count = 0;
262 int retval;
263
264 /* search the kset, the device belongs to */
265 top_kobj = &dev->kobj;
266 while (!top_kobj->kset && top_kobj->parent)
267 top_kobj = top_kobj->parent;
268 if (!top_kobj->kset)
269 goto out;
270
271 kset = top_kobj->kset;
272 if (!kset->uevent_ops || !kset->uevent_ops->uevent)
273 goto out;
274
275 /* respect filter */
276 if (kset->uevent_ops && kset->uevent_ops->filter)
277 if (!kset->uevent_ops->filter(kset, &dev->kobj))
278 goto out;
279
280 env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL);
281 if (!env)
282 return -ENOMEM;
283
284 /* let the kset specific function add its keys */
285 retval = kset->uevent_ops->uevent(kset, &dev->kobj, env);
286 if (retval)
287 goto out;
288
289 /* copy keys to file */
290 for (i = 0; i < env->envp_idx; i++)
291 count += sprintf(&buf[count], "%s\n", env->envp[i]);
292out:
293 kfree(env);
294 return count;
295}
296
297static ssize_t store_uevent(struct device *dev, struct device_attribute *attr,
298 const char *buf, size_t count)
299{
300 enum kobject_action action;
301
302 if (kobject_action_type(buf, count, &action) == 0)
303 kobject_uevent(&dev->kobj, action);
304 else
305 dev_err(dev, "uevent: unknown action-string\n");
306 return count;
307}
308
309static struct device_attribute uevent_attr =
310 __ATTR(uevent, S_IRUGO | S_IWUSR, show_uevent, store_uevent);
311
312static int device_add_attributes(struct device *dev,
313 struct device_attribute *attrs)
314{
315 int error = 0;
316 int i;
317
318 if (attrs) {
319 for (i = 0; attr_name(attrs[i]); i++) {
320 error = device_create_file(dev, &attrs[i]);
321 if (error)
322 break;
323 }
324 if (error)
325 while (--i >= 0)
326 device_remove_file(dev, &attrs[i]);
327 }
328 return error;
329}
330
331static void device_remove_attributes(struct device *dev,
332 struct device_attribute *attrs)
333{
334 int i;
335
336 if (attrs)
337 for (i = 0; attr_name(attrs[i]); i++)
338 device_remove_file(dev, &attrs[i]);
339}
340
341static int device_add_bin_attributes(struct device *dev,
342 struct bin_attribute *attrs)
343{
344 int error = 0;
345 int i;
346
347 if (attrs) {
348 for (i = 0; attr_name(attrs[i]); i++) {
349 error = device_create_bin_file(dev, &attrs[i]);
350 if (error)
351 break;
352 }
353 if (error)
354 while (--i >= 0)
355 device_remove_bin_file(dev, &attrs[i]);
356 }
357 return error;
358}
359
360static void device_remove_bin_attributes(struct device *dev,
361 struct bin_attribute *attrs)
362{
363 int i;
364
365 if (attrs)
366 for (i = 0; attr_name(attrs[i]); i++)
367 device_remove_bin_file(dev, &attrs[i]);
368}
369
370static int device_add_groups(struct device *dev,
371 const struct attribute_group **groups)
372{
373 int error = 0;
374 int i;
375
376 if (groups) {
377 for (i = 0; groups[i]; i++) {
378 error = sysfs_create_group(&dev->kobj, groups[i]);
379 if (error) {
380 while (--i >= 0)
381 sysfs_remove_group(&dev->kobj,
382 groups[i]);
383 break;
384 }
385 }
386 }
387 return error;
388}
389
390static void device_remove_groups(struct device *dev,
391 const struct attribute_group **groups)
392{
393 int i;
394
395 if (groups)
396 for (i = 0; groups[i]; i++)
397 sysfs_remove_group(&dev->kobj, groups[i]);
398}
399
400static int device_add_attrs(struct device *dev)
401{
402 struct class *class = dev->class;
403 const struct device_type *type = dev->type;
404 int error;
405
406 if (class) {
407 error = device_add_attributes(dev, class->dev_attrs);
408 if (error)
409 return error;
410 error = device_add_bin_attributes(dev, class->dev_bin_attrs);
411 if (error)
412 goto err_remove_class_attrs;
413 }
414
415 if (type) {
416 error = device_add_groups(dev, type->groups);
417 if (error)
418 goto err_remove_class_bin_attrs;
419 }
420
421 error = device_add_groups(dev, dev->groups);
422 if (error)
423 goto err_remove_type_groups;
424
425 return 0;
426
427 err_remove_type_groups:
428 if (type)
429 device_remove_groups(dev, type->groups);
430 err_remove_class_bin_attrs:
431 if (class)
432 device_remove_bin_attributes(dev, class->dev_bin_attrs);
433 err_remove_class_attrs:
434 if (class)
435 device_remove_attributes(dev, class->dev_attrs);
436
437 return error;
438}
439
440static void device_remove_attrs(struct device *dev)
441{
442 struct class *class = dev->class;
443 const struct device_type *type = dev->type;
444
445 device_remove_groups(dev, dev->groups);
446
447 if (type)
448 device_remove_groups(dev, type->groups);
449
450 if (class) {
451 device_remove_attributes(dev, class->dev_attrs);
452 device_remove_bin_attributes(dev, class->dev_bin_attrs);
453 }
454}
455
456
457static ssize_t show_dev(struct device *dev, struct device_attribute *attr,
458 char *buf)
459{
460 return print_dev_t(buf, dev->devt);
461}
462
463static struct device_attribute devt_attr =
464 __ATTR(dev, S_IRUGO, show_dev, NULL);
465
466/* kset to create /sys/devices/ */
467struct kset *devices_kset;
468
469/**
470 * device_create_file - create sysfs attribute file for device.
471 * @dev: device.
472 * @attr: device attribute descriptor.
473 */
474int device_create_file(struct device *dev,
475 const struct device_attribute *attr)
476{
477 int error = 0;
478 if (dev)
479 error = sysfs_create_file(&dev->kobj, &attr->attr);
480 return error;
481}
482
483/**
484 * device_remove_file - remove sysfs attribute file.
485 * @dev: device.
486 * @attr: device attribute descriptor.
487 */
488void device_remove_file(struct device *dev,
489 const struct device_attribute *attr)
490{
491 if (dev)
492 sysfs_remove_file(&dev->kobj, &attr->attr);
493}
494
495/**
496 * device_create_bin_file - create sysfs binary attribute file for device.
497 * @dev: device.
498 * @attr: device binary attribute descriptor.
499 */
500int device_create_bin_file(struct device *dev,
501 const struct bin_attribute *attr)
502{
503 int error = -EINVAL;
504 if (dev)
505 error = sysfs_create_bin_file(&dev->kobj, attr);
506 return error;
507}
508EXPORT_SYMBOL_GPL(device_create_bin_file);
509
510/**
511 * device_remove_bin_file - remove sysfs binary attribute file
512 * @dev: device.
513 * @attr: device binary attribute descriptor.
514 */
515void device_remove_bin_file(struct device *dev,
516 const struct bin_attribute *attr)
517{
518 if (dev)
519 sysfs_remove_bin_file(&dev->kobj, attr);
520}
521EXPORT_SYMBOL_GPL(device_remove_bin_file);
522
523/**
524 * device_schedule_callback_owner - helper to schedule a callback for a device
525 * @dev: device.
526 * @func: callback function to invoke later.
527 * @owner: module owning the callback routine
528 *
529 * Attribute methods must not unregister themselves or their parent device
530 * (which would amount to the same thing). Attempts to do so will deadlock,
531 * since unregistration is mutually exclusive with driver callbacks.
532 *
533 * Instead methods can call this routine, which will attempt to allocate
534 * and schedule a workqueue request to call back @func with @dev as its
535 * argument in the workqueue's process context. @dev will be pinned until
536 * @func returns.
537 *
538 * This routine is usually called via the inline device_schedule_callback(),
539 * which automatically sets @owner to THIS_MODULE.
540 *
541 * Returns 0 if the request was submitted, -ENOMEM if storage could not
542 * be allocated, -ENODEV if a reference to @owner isn't available.
543 *
544 * NOTE: This routine won't work if CONFIG_SYSFS isn't set! It uses an
545 * underlying sysfs routine (since it is intended for use by attribute
546 * methods), and if sysfs isn't available you'll get nothing but -ENOSYS.
547 */
548int device_schedule_callback_owner(struct device *dev,
549 void (*func)(struct device *), struct module *owner)
550{
551 return sysfs_schedule_callback(&dev->kobj,
552 (void (*)(void *)) func, dev, owner);
553}
554EXPORT_SYMBOL_GPL(device_schedule_callback_owner);
555
556static void klist_children_get(struct klist_node *n)
557{
558 struct device_private *p = to_device_private_parent(n);
559 struct device *dev = p->device;
560
561 get_device(dev);
562}
563
564static void klist_children_put(struct klist_node *n)
565{
566 struct device_private *p = to_device_private_parent(n);
567 struct device *dev = p->device;
568
569 put_device(dev);
570}
571
572/**
573 * device_initialize - init device structure.
574 * @dev: device.
575 *
576 * This prepares the device for use by other layers by initializing
577 * its fields.
578 * It is the first half of device_register(), if called by
579 * that function, though it can also be called separately, so one
580 * may use @dev's fields. In particular, get_device()/put_device()
581 * may be used for reference counting of @dev after calling this
582 * function.
583 *
584 * NOTE: Use put_device() to give up your reference instead of freeing
585 * @dev directly once you have called this function.
586 */
587void device_initialize(struct device *dev)
588{
589 dev->kobj.kset = devices_kset;
590 kobject_init(&dev->kobj, &device_ktype);
591 INIT_LIST_HEAD(&dev->dma_pools);
592 mutex_init(&dev->mutex);
593 lockdep_set_novalidate_class(&dev->mutex);
594 spin_lock_init(&dev->devres_lock);
595 INIT_LIST_HEAD(&dev->devres_head);
596 device_pm_init(dev);
597 set_dev_node(dev, -1);
598}
599
600static struct kobject *virtual_device_parent(struct device *dev)
601{
602 static struct kobject *virtual_dir = NULL;
603
604 if (!virtual_dir)
605 virtual_dir = kobject_create_and_add("virtual",
606 &devices_kset->kobj);
607
608 return virtual_dir;
609}
610
611struct class_dir {
612 struct kobject kobj;
613 struct class *class;
614};
615
616#define to_class_dir(obj) container_of(obj, struct class_dir, kobj)
617
618static void class_dir_release(struct kobject *kobj)
619{
620 struct class_dir *dir = to_class_dir(kobj);
621 kfree(dir);
622}
623
624static const
625struct kobj_ns_type_operations *class_dir_child_ns_type(struct kobject *kobj)
626{
627 struct class_dir *dir = to_class_dir(kobj);
628 return dir->class->ns_type;
629}
630
631static struct kobj_type class_dir_ktype = {
632 .release = class_dir_release,
633 .sysfs_ops = &kobj_sysfs_ops,
634 .child_ns_type = class_dir_child_ns_type
635};
636
637static struct kobject *
638class_dir_create_and_add(struct class *class, struct kobject *parent_kobj)
639{
640 struct class_dir *dir;
641 int retval;
642
643 dir = kzalloc(sizeof(*dir), GFP_KERNEL);
644 if (!dir)
645 return NULL;
646
647 dir->class = class;
648 kobject_init(&dir->kobj, &class_dir_ktype);
649
650 dir->kobj.kset = &class->p->glue_dirs;
651
652 retval = kobject_add(&dir->kobj, parent_kobj, "%s", class->name);
653 if (retval < 0) {
654 kobject_put(&dir->kobj);
655 return NULL;
656 }
657 return &dir->kobj;
658}
659
660
661static struct kobject *get_device_parent(struct device *dev,
662 struct device *parent)
663{
664 if (dev->class) {
665 static DEFINE_MUTEX(gdp_mutex);
666 struct kobject *kobj = NULL;
667 struct kobject *parent_kobj;
668 struct kobject *k;
669
670#ifdef CONFIG_BLOCK
671 /* block disks show up in /sys/block */
672 if (sysfs_deprecated && dev->class == &block_class) {
673 if (parent && parent->class == &block_class)
674 return &parent->kobj;
675 return &block_class.p->subsys.kobj;
676 }
677#endif
678
679 /*
680 * If we have no parent, we live in "virtual".
681 * Class-devices with a non class-device as parent, live
682 * in a "glue" directory to prevent namespace collisions.
683 */
684 if (parent == NULL)
685 parent_kobj = virtual_device_parent(dev);
686 else if (parent->class && !dev->class->ns_type)
687 return &parent->kobj;
688 else
689 parent_kobj = &parent->kobj;
690
691 mutex_lock(&gdp_mutex);
692
693 /* find our class-directory at the parent and reference it */
694 spin_lock(&dev->class->p->glue_dirs.list_lock);
695 list_for_each_entry(k, &dev->class->p->glue_dirs.list, entry)
696 if (k->parent == parent_kobj) {
697 kobj = kobject_get(k);
698 break;
699 }
700 spin_unlock(&dev->class->p->glue_dirs.list_lock);
701 if (kobj) {
702 mutex_unlock(&gdp_mutex);
703 return kobj;
704 }
705
706 /* or create a new class-directory at the parent device */
707 k = class_dir_create_and_add(dev->class, parent_kobj);
708 /* do not emit an uevent for this simple "glue" directory */
709 mutex_unlock(&gdp_mutex);
710 return k;
711 }
712
713 if (parent)
714 return &parent->kobj;
715 return NULL;
716}
717
718static void cleanup_glue_dir(struct device *dev, struct kobject *glue_dir)
719{
720 /* see if we live in a "glue" directory */
721 if (!glue_dir || !dev->class ||
722 glue_dir->kset != &dev->class->p->glue_dirs)
723 return;
724
725 kobject_put(glue_dir);
726}
727
728static void cleanup_device_parent(struct device *dev)
729{
730 cleanup_glue_dir(dev, dev->kobj.parent);
731}
732
733static void setup_parent(struct device *dev, struct device *parent)
734{
735 struct kobject *kobj;
736 kobj = get_device_parent(dev, parent);
737 if (kobj)
738 dev->kobj.parent = kobj;
739}
740
741static int device_add_class_symlinks(struct device *dev)
742{
743 int error;
744
745 if (!dev->class)
746 return 0;
747
748 error = sysfs_create_link(&dev->kobj,
749 &dev->class->p->subsys.kobj,
750 "subsystem");
751 if (error)
752 goto out;
753
754 if (dev->parent && device_is_not_partition(dev)) {
755 error = sysfs_create_link(&dev->kobj, &dev->parent->kobj,
756 "device");
757 if (error)
758 goto out_subsys;
759 }
760
761#ifdef CONFIG_BLOCK
762 /* /sys/block has directories and does not need symlinks */
763 if (sysfs_deprecated && dev->class == &block_class)
764 return 0;
765#endif
766
767 /* link in the class directory pointing to the device */
768 error = sysfs_create_link(&dev->class->p->subsys.kobj,
769 &dev->kobj, dev_name(dev));
770 if (error)
771 goto out_device;
772
773 return 0;
774
775out_device:
776 sysfs_remove_link(&dev->kobj, "device");
777
778out_subsys:
779 sysfs_remove_link(&dev->kobj, "subsystem");
780out:
781 return error;
782}
783
784static void device_remove_class_symlinks(struct device *dev)
785{
786 if (!dev->class)
787 return;
788
789 if (dev->parent && device_is_not_partition(dev))
790 sysfs_remove_link(&dev->kobj, "device");
791 sysfs_remove_link(&dev->kobj, "subsystem");
792#ifdef CONFIG_BLOCK
793 if (sysfs_deprecated && dev->class == &block_class)
794 return;
795#endif
796 sysfs_delete_link(&dev->class->p->subsys.kobj, &dev->kobj, dev_name(dev));
797}
798
799/**
800 * dev_set_name - set a device name
801 * @dev: device
802 * @fmt: format string for the device's name
803 */
804int dev_set_name(struct device *dev, const char *fmt, ...)
805{
806 va_list vargs;
807 int err;
808
809 va_start(vargs, fmt);
810 err = kobject_set_name_vargs(&dev->kobj, fmt, vargs);
811 va_end(vargs);
812 return err;
813}
814EXPORT_SYMBOL_GPL(dev_set_name);
815
816/**
817 * device_to_dev_kobj - select a /sys/dev/ directory for the device
818 * @dev: device
819 *
820 * By default we select char/ for new entries. Setting class->dev_obj
821 * to NULL prevents an entry from being created. class->dev_kobj must
822 * be set (or cleared) before any devices are registered to the class
823 * otherwise device_create_sys_dev_entry() and
824 * device_remove_sys_dev_entry() will disagree about the the presence
825 * of the link.
826 */
827static struct kobject *device_to_dev_kobj(struct device *dev)
828{
829 struct kobject *kobj;
830
831 if (dev->class)
832 kobj = dev->class->dev_kobj;
833 else
834 kobj = sysfs_dev_char_kobj;
835
836 return kobj;
837}
838
839static int device_create_sys_dev_entry(struct device *dev)
840{
841 struct kobject *kobj = device_to_dev_kobj(dev);
842 int error = 0;
843 char devt_str[15];
844
845 if (kobj) {
846 format_dev_t(devt_str, dev->devt);
847 error = sysfs_create_link(kobj, &dev->kobj, devt_str);
848 }
849
850 return error;
851}
852
853static void device_remove_sys_dev_entry(struct device *dev)
854{
855 struct kobject *kobj = device_to_dev_kobj(dev);
856 char devt_str[15];
857
858 if (kobj) {
859 format_dev_t(devt_str, dev->devt);
860 sysfs_remove_link(kobj, devt_str);
861 }
862}
863
864int device_private_init(struct device *dev)
865{
866 dev->p = kzalloc(sizeof(*dev->p), GFP_KERNEL);
867 if (!dev->p)
868 return -ENOMEM;
869 dev->p->device = dev;
870 klist_init(&dev->p->klist_children, klist_children_get,
871 klist_children_put);
872 return 0;
873}
874
875/**
876 * device_add - add device to device hierarchy.
877 * @dev: device.
878 *
879 * This is part 2 of device_register(), though may be called
880 * separately _iff_ device_initialize() has been called separately.
881 *
882 * This adds @dev to the kobject hierarchy via kobject_add(), adds it
883 * to the global and sibling lists for the device, then
884 * adds it to the other relevant subsystems of the driver model.
885 *
886 * NOTE: _Never_ directly free @dev after calling this function, even
887 * if it returned an error! Always use put_device() to give up your
888 * reference instead.
889 */
890int device_add(struct device *dev)
891{
892 struct device *parent = NULL;
893 struct class_interface *class_intf;
894 int error = -EINVAL;
895
896 dev = get_device(dev);
897 if (!dev)
898 goto done;
899
900 if (!dev->p) {
901 error = device_private_init(dev);
902 if (error)
903 goto done;
904 }
905
906 /*
907 * for statically allocated devices, which should all be converted
908 * some day, we need to initialize the name. We prevent reading back
909 * the name, and force the use of dev_name()
910 */
911 if (dev->init_name) {
912 dev_set_name(dev, "%s", dev->init_name);
913 dev->init_name = NULL;
914 }
915
916 if (!dev_name(dev)) {
917 error = -EINVAL;
918 goto name_error;
919 }
920
921 pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
922
923 parent = get_device(dev->parent);
924 setup_parent(dev, parent);
925
926 /* use parent numa_node */
927 if (parent)
928 set_dev_node(dev, dev_to_node(parent));
929
930 /* first, register with generic layer. */
931 /* we require the name to be set before, and pass NULL */
932 error = kobject_add(&dev->kobj, dev->kobj.parent, NULL);
933 if (error)
934 goto Error;
935
936 /* notify platform of device entry */
937 if (platform_notify)
938 platform_notify(dev);
939
940 error = device_create_file(dev, &uevent_attr);
941 if (error)
942 goto attrError;
943
944 if (MAJOR(dev->devt)) {
945 error = device_create_file(dev, &devt_attr);
946 if (error)
947 goto ueventattrError;
948
949 error = device_create_sys_dev_entry(dev);
950 if (error)
951 goto devtattrError;
952
953 devtmpfs_create_node(dev);
954 }
955
956 error = device_add_class_symlinks(dev);
957 if (error)
958 goto SymlinkError;
959 error = device_add_attrs(dev);
960 if (error)
961 goto AttrsError;
962 error = bus_add_device(dev);
963 if (error)
964 goto BusError;
965 error = dpm_sysfs_add(dev);
966 if (error)
967 goto DPMError;
968 device_pm_add(dev);
969
970 /* Notify clients of device addition. This call must come
971 * after dpm_sysf_add() and before kobject_uevent().
972 */
973 if (dev->bus)
974 blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
975 BUS_NOTIFY_ADD_DEVICE, dev);
976
977 kobject_uevent(&dev->kobj, KOBJ_ADD);
978 bus_probe_device(dev);
979 if (parent)
980 klist_add_tail(&dev->p->knode_parent,
981 &parent->p->klist_children);
982
983 if (dev->class) {
984 mutex_lock(&dev->class->p->class_mutex);
985 /* tie the class to the device */
986 klist_add_tail(&dev->knode_class,
987 &dev->class->p->klist_devices);
988
989 /* notify any interfaces that the device is here */
990 list_for_each_entry(class_intf,
991 &dev->class->p->class_interfaces, node)
992 if (class_intf->add_dev)
993 class_intf->add_dev(dev, class_intf);
994 mutex_unlock(&dev->class->p->class_mutex);
995 }
996done:
997 put_device(dev);
998 return error;
999 DPMError:
1000 bus_remove_device(dev);
1001 BusError:
1002 device_remove_attrs(dev);
1003 AttrsError:
1004 device_remove_class_symlinks(dev);
1005 SymlinkError:
1006 if (MAJOR(dev->devt))
1007 devtmpfs_delete_node(dev);
1008 if (MAJOR(dev->devt))
1009 device_remove_sys_dev_entry(dev);
1010 devtattrError:
1011 if (MAJOR(dev->devt))
1012 device_remove_file(dev, &devt_attr);
1013 ueventattrError:
1014 device_remove_file(dev, &uevent_attr);
1015 attrError:
1016 kobject_uevent(&dev->kobj, KOBJ_REMOVE);
1017 kobject_del(&dev->kobj);
1018 Error:
1019 cleanup_device_parent(dev);
1020 if (parent)
1021 put_device(parent);
1022name_error:
1023 kfree(dev->p);
1024 dev->p = NULL;
1025 goto done;
1026}
1027
1028/**
1029 * device_register - register a device with the system.
1030 * @dev: pointer to the device structure
1031 *
1032 * This happens in two clean steps - initialize the device
1033 * and add it to the system. The two steps can be called
1034 * separately, but this is the easiest and most common.
1035 * I.e. you should only call the two helpers separately if
1036 * have a clearly defined need to use and refcount the device
1037 * before it is added to the hierarchy.
1038 *
1039 * NOTE: _Never_ directly free @dev after calling this function, even
1040 * if it returned an error! Always use put_device() to give up the
1041 * reference initialized in this function instead.
1042 */
1043int device_register(struct device *dev)
1044{
1045 device_initialize(dev);
1046 return device_add(dev);
1047}
1048
1049/**
1050 * get_device - increment reference count for device.
1051 * @dev: device.
1052 *
1053 * This simply forwards the call to kobject_get(), though
1054 * we do take care to provide for the case that we get a NULL
1055 * pointer passed in.
1056 */
1057struct device *get_device(struct device *dev)
1058{
1059 return dev ? to_dev(kobject_get(&dev->kobj)) : NULL;
1060}
1061
1062/**
1063 * put_device - decrement reference count.
1064 * @dev: device in question.
1065 */
1066void put_device(struct device *dev)
1067{
1068 /* might_sleep(); */
1069 if (dev)
1070 kobject_put(&dev->kobj);
1071}
1072
1073/**
1074 * device_del - delete device from system.
1075 * @dev: device.
1076 *
1077 * This is the first part of the device unregistration
1078 * sequence. This removes the device from the lists we control
1079 * from here, has it removed from the other driver model
1080 * subsystems it was added to in device_add(), and removes it
1081 * from the kobject hierarchy.
1082 *
1083 * NOTE: this should be called manually _iff_ device_add() was
1084 * also called manually.
1085 */
1086void device_del(struct device *dev)
1087{
1088 struct device *parent = dev->parent;
1089 struct class_interface *class_intf;
1090
1091 /* Notify clients of device removal. This call must come
1092 * before dpm_sysfs_remove().
1093 */
1094 if (dev->bus)
1095 blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
1096 BUS_NOTIFY_DEL_DEVICE, dev);
1097 device_pm_remove(dev);
1098 dpm_sysfs_remove(dev);
1099 if (parent)
1100 klist_del(&dev->p->knode_parent);
1101 if (MAJOR(dev->devt)) {
1102 devtmpfs_delete_node(dev);
1103 device_remove_sys_dev_entry(dev);
1104 device_remove_file(dev, &devt_attr);
1105 }
1106 if (dev->class) {
1107 device_remove_class_symlinks(dev);
1108
1109 mutex_lock(&dev->class->p->class_mutex);
1110 /* notify any interfaces that the device is now gone */
1111 list_for_each_entry(class_intf,
1112 &dev->class->p->class_interfaces, node)
1113 if (class_intf->remove_dev)
1114 class_intf->remove_dev(dev, class_intf);
1115 /* remove the device from the class list */
1116 klist_del(&dev->knode_class);
1117 mutex_unlock(&dev->class->p->class_mutex);
1118 }
1119 device_remove_file(dev, &uevent_attr);
1120 device_remove_attrs(dev);
1121 bus_remove_device(dev);
1122
1123 /*
1124 * Some platform devices are driven without driver attached
1125 * and managed resources may have been acquired. Make sure
1126 * all resources are released.
1127 */
1128 devres_release_all(dev);
1129
1130 /* Notify the platform of the removal, in case they
1131 * need to do anything...
1132 */
1133 if (platform_notify_remove)
1134 platform_notify_remove(dev);
1135 kobject_uevent(&dev->kobj, KOBJ_REMOVE);
1136 cleanup_device_parent(dev);
1137 kobject_del(&dev->kobj);
1138 put_device(parent);
1139}
1140
1141/**
1142 * device_unregister - unregister device from system.
1143 * @dev: device going away.
1144 *
1145 * We do this in two parts, like we do device_register(). First,
1146 * we remove it from all the subsystems with device_del(), then
1147 * we decrement the reference count via put_device(). If that
1148 * is the final reference count, the device will be cleaned up
1149 * via device_release() above. Otherwise, the structure will
1150 * stick around until the final reference to the device is dropped.
1151 */
1152void device_unregister(struct device *dev)
1153{
1154 pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
1155 device_del(dev);
1156 put_device(dev);
1157}
1158
1159static struct device *next_device(struct klist_iter *i)
1160{
1161 struct klist_node *n = klist_next(i);
1162 struct device *dev = NULL;
1163 struct device_private *p;
1164
1165 if (n) {
1166 p = to_device_private_parent(n);
1167 dev = p->device;
1168 }
1169 return dev;
1170}
1171
1172/**
1173 * device_get_devnode - path of device node file
1174 * @dev: device
1175 * @mode: returned file access mode
1176 * @tmp: possibly allocated string
1177 *
1178 * Return the relative path of a possible device node.
1179 * Non-default names may need to allocate a memory to compose
1180 * a name. This memory is returned in tmp and needs to be
1181 * freed by the caller.
1182 */
1183const char *device_get_devnode(struct device *dev,
1184 mode_t *mode, const char **tmp)
1185{
1186 char *s;
1187
1188 *tmp = NULL;
1189
1190 /* the device type may provide a specific name */
1191 if (dev->type && dev->type->devnode)
1192 *tmp = dev->type->devnode(dev, mode);
1193 if (*tmp)
1194 return *tmp;
1195
1196 /* the class may provide a specific name */
1197 if (dev->class && dev->class->devnode)
1198 *tmp = dev->class->devnode(dev, mode);
1199 if (*tmp)
1200 return *tmp;
1201
1202 /* return name without allocation, tmp == NULL */
1203 if (strchr(dev_name(dev), '!') == NULL)
1204 return dev_name(dev);
1205
1206 /* replace '!' in the name with '/' */
1207 *tmp = kstrdup(dev_name(dev), GFP_KERNEL);
1208 if (!*tmp)
1209 return NULL;
1210 while ((s = strchr(*tmp, '!')))
1211 s[0] = '/';
1212 return *tmp;
1213}
1214
1215/**
1216 * device_for_each_child - device child iterator.
1217 * @parent: parent struct device.
1218 * @data: data for the callback.
1219 * @fn: function to be called for each device.
1220 *
1221 * Iterate over @parent's child devices, and call @fn for each,
1222 * passing it @data.
1223 *
1224 * We check the return of @fn each time. If it returns anything
1225 * other than 0, we break out and return that value.
1226 */
1227int device_for_each_child(struct device *parent, void *data,
1228 int (*fn)(struct device *dev, void *data))
1229{
1230 struct klist_iter i;
1231 struct device *child;
1232 int error = 0;
1233
1234 if (!parent->p)
1235 return 0;
1236
1237 klist_iter_init(&parent->p->klist_children, &i);
1238 while ((child = next_device(&i)) && !error)
1239 error = fn(child, data);
1240 klist_iter_exit(&i);
1241 return error;
1242}
1243
1244/**
1245 * device_find_child - device iterator for locating a particular device.
1246 * @parent: parent struct device
1247 * @data: Data to pass to match function
1248 * @match: Callback function to check device
1249 *
1250 * This is similar to the device_for_each_child() function above, but it
1251 * returns a reference to a device that is 'found' for later use, as
1252 * determined by the @match callback.
1253 *
1254 * The callback should return 0 if the device doesn't match and non-zero
1255 * if it does. If the callback returns non-zero and a reference to the
1256 * current device can be obtained, this function will return to the caller
1257 * and not iterate over any more devices.
1258 */
1259struct device *device_find_child(struct device *parent, void *data,
1260 int (*match)(struct device *dev, void *data))
1261{
1262 struct klist_iter i;
1263 struct device *child;
1264
1265 if (!parent)
1266 return NULL;
1267
1268 klist_iter_init(&parent->p->klist_children, &i);
1269 while ((child = next_device(&i)))
1270 if (match(child, data) && get_device(child))
1271 break;
1272 klist_iter_exit(&i);
1273 return child;
1274}
1275
1276int __init devices_init(void)
1277{
1278 devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL);
1279 if (!devices_kset)
1280 return -ENOMEM;
1281 dev_kobj = kobject_create_and_add("dev", NULL);
1282 if (!dev_kobj)
1283 goto dev_kobj_err;
1284 sysfs_dev_block_kobj = kobject_create_and_add("block", dev_kobj);
1285 if (!sysfs_dev_block_kobj)
1286 goto block_kobj_err;
1287 sysfs_dev_char_kobj = kobject_create_and_add("char", dev_kobj);
1288 if (!sysfs_dev_char_kobj)
1289 goto char_kobj_err;
1290
1291 return 0;
1292
1293 char_kobj_err:
1294 kobject_put(sysfs_dev_block_kobj);
1295 block_kobj_err:
1296 kobject_put(dev_kobj);
1297 dev_kobj_err:
1298 kset_unregister(devices_kset);
1299 return -ENOMEM;
1300}
1301
1302EXPORT_SYMBOL_GPL(device_for_each_child);
1303EXPORT_SYMBOL_GPL(device_find_child);
1304
1305EXPORT_SYMBOL_GPL(device_initialize);
1306EXPORT_SYMBOL_GPL(device_add);
1307EXPORT_SYMBOL_GPL(device_register);
1308
1309EXPORT_SYMBOL_GPL(device_del);
1310EXPORT_SYMBOL_GPL(device_unregister);
1311EXPORT_SYMBOL_GPL(get_device);
1312EXPORT_SYMBOL_GPL(put_device);
1313
1314EXPORT_SYMBOL_GPL(device_create_file);
1315EXPORT_SYMBOL_GPL(device_remove_file);
1316
1317struct root_device {
1318 struct device dev;
1319 struct module *owner;
1320};
1321
1322inline struct root_device *to_root_device(struct device *d)
1323{
1324 return container_of(d, struct root_device, dev);
1325}
1326
1327static void root_device_release(struct device *dev)
1328{
1329 kfree(to_root_device(dev));
1330}
1331
1332/**
1333 * __root_device_register - allocate and register a root device
1334 * @name: root device name
1335 * @owner: owner module of the root device, usually THIS_MODULE
1336 *
1337 * This function allocates a root device and registers it
1338 * using device_register(). In order to free the returned
1339 * device, use root_device_unregister().
1340 *
1341 * Root devices are dummy devices which allow other devices
1342 * to be grouped under /sys/devices. Use this function to
1343 * allocate a root device and then use it as the parent of
1344 * any device which should appear under /sys/devices/{name}
1345 *
1346 * The /sys/devices/{name} directory will also contain a
1347 * 'module' symlink which points to the @owner directory
1348 * in sysfs.
1349 *
1350 * Returns &struct device pointer on success, or ERR_PTR() on error.
1351 *
1352 * Note: You probably want to use root_device_register().
1353 */
1354struct device *__root_device_register(const char *name, struct module *owner)
1355{
1356 struct root_device *root;
1357 int err = -ENOMEM;
1358
1359 root = kzalloc(sizeof(struct root_device), GFP_KERNEL);
1360 if (!root)
1361 return ERR_PTR(err);
1362
1363 err = dev_set_name(&root->dev, "%s", name);
1364 if (err) {
1365 kfree(root);
1366 return ERR_PTR(err);
1367 }
1368
1369 root->dev.release = root_device_release;
1370
1371 err = device_register(&root->dev);
1372 if (err) {
1373 put_device(&root->dev);
1374 return ERR_PTR(err);
1375 }
1376
1377#ifdef CONFIG_MODULES /* gotta find a "cleaner" way to do this */
1378 if (owner) {
1379 struct module_kobject *mk = &owner->mkobj;
1380
1381 err = sysfs_create_link(&root->dev.kobj, &mk->kobj, "module");
1382 if (err) {
1383 device_unregister(&root->dev);
1384 return ERR_PTR(err);
1385 }
1386 root->owner = owner;
1387 }
1388#endif
1389
1390 return &root->dev;
1391}
1392EXPORT_SYMBOL_GPL(__root_device_register);
1393
1394/**
1395 * root_device_unregister - unregister and free a root device
1396 * @dev: device going away
1397 *
1398 * This function unregisters and cleans up a device that was created by
1399 * root_device_register().
1400 */
1401void root_device_unregister(struct device *dev)
1402{
1403 struct root_device *root = to_root_device(dev);
1404
1405 if (root->owner)
1406 sysfs_remove_link(&root->dev.kobj, "module");
1407
1408 device_unregister(dev);
1409}
1410EXPORT_SYMBOL_GPL(root_device_unregister);
1411
1412
1413static void device_create_release(struct device *dev)
1414{
1415 pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
1416 kfree(dev);
1417}
1418
1419/**
1420 * device_create_vargs - creates a device and registers it with sysfs
1421 * @class: pointer to the struct class that this device should be registered to
1422 * @parent: pointer to the parent struct device of this new device, if any
1423 * @devt: the dev_t for the char device to be added
1424 * @drvdata: the data to be added to the device for callbacks
1425 * @fmt: string for the device's name
1426 * @args: va_list for the device's name
1427 *
1428 * This function can be used by char device classes. A struct device
1429 * will be created in sysfs, registered to the specified class.
1430 *
1431 * A "dev" file will be created, showing the dev_t for the device, if
1432 * the dev_t is not 0,0.
1433 * If a pointer to a parent struct device is passed in, the newly created
1434 * struct device will be a child of that device in sysfs.
1435 * The pointer to the struct device will be returned from the call.
1436 * Any further sysfs files that might be required can be created using this
1437 * pointer.
1438 *
1439 * Returns &struct device pointer on success, or ERR_PTR() on error.
1440 *
1441 * Note: the struct class passed to this function must have previously
1442 * been created with a call to class_create().
1443 */
1444struct device *device_create_vargs(struct class *class, struct device *parent,
1445 dev_t devt, void *drvdata, const char *fmt,
1446 va_list args)
1447{
1448 struct device *dev = NULL;
1449 int retval = -ENODEV;
1450
1451 if (class == NULL || IS_ERR(class))
1452 goto error;
1453
1454 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1455 if (!dev) {
1456 retval = -ENOMEM;
1457 goto error;
1458 }
1459
1460 dev->devt = devt;
1461 dev->class = class;
1462 dev->parent = parent;
1463 dev->release = device_create_release;
1464 dev_set_drvdata(dev, drvdata);
1465
1466 retval = kobject_set_name_vargs(&dev->kobj, fmt, args);
1467 if (retval)
1468 goto error;
1469
1470 retval = device_register(dev);
1471 if (retval)
1472 goto error;
1473
1474 return dev;
1475
1476error:
1477 put_device(dev);
1478 return ERR_PTR(retval);
1479}
1480EXPORT_SYMBOL_GPL(device_create_vargs);
1481
1482/**
1483 * device_create - creates a device and registers it with sysfs
1484 * @class: pointer to the struct class that this device should be registered to
1485 * @parent: pointer to the parent struct device of this new device, if any
1486 * @devt: the dev_t for the char device to be added
1487 * @drvdata: the data to be added to the device for callbacks
1488 * @fmt: string for the device's name
1489 *
1490 * This function can be used by char device classes. A struct device
1491 * will be created in sysfs, registered to the specified class.
1492 *
1493 * A "dev" file will be created, showing the dev_t for the device, if
1494 * the dev_t is not 0,0.
1495 * If a pointer to a parent struct device is passed in, the newly created
1496 * struct device will be a child of that device in sysfs.
1497 * The pointer to the struct device will be returned from the call.
1498 * Any further sysfs files that might be required can be created using this
1499 * pointer.
1500 *
1501 * Returns &struct device pointer on success, or ERR_PTR() on error.
1502 *
1503 * Note: the struct class passed to this function must have previously
1504 * been created with a call to class_create().
1505 */
1506struct device *device_create(struct class *class, struct device *parent,
1507 dev_t devt, void *drvdata, const char *fmt, ...)
1508{
1509 va_list vargs;
1510 struct device *dev;
1511
1512 va_start(vargs, fmt);
1513 dev = device_create_vargs(class, parent, devt, drvdata, fmt, vargs);
1514 va_end(vargs);
1515 return dev;
1516}
1517EXPORT_SYMBOL_GPL(device_create);
1518
1519static int __match_devt(struct device *dev, void *data)
1520{
1521 dev_t *devt = data;
1522
1523 return dev->devt == *devt;
1524}
1525
1526/**
1527 * device_destroy - removes a device that was created with device_create()
1528 * @class: pointer to the struct class that this device was registered with
1529 * @devt: the dev_t of the device that was previously registered
1530 *
1531 * This call unregisters and cleans up a device that was created with a
1532 * call to device_create().
1533 */
1534void device_destroy(struct class *class, dev_t devt)
1535{
1536 struct device *dev;
1537
1538 dev = class_find_device(class, NULL, &devt, __match_devt);
1539 if (dev) {
1540 put_device(dev);
1541 device_unregister(dev);
1542 }
1543}
1544EXPORT_SYMBOL_GPL(device_destroy);
1545
1546/**
1547 * device_rename - renames a device
1548 * @dev: the pointer to the struct device to be renamed
1549 * @new_name: the new name of the device
1550 *
1551 * It is the responsibility of the caller to provide mutual
1552 * exclusion between two different calls of device_rename
1553 * on the same device to ensure that new_name is valid and
1554 * won't conflict with other devices.
1555 *
1556 * Note: Don't call this function. Currently, the networking layer calls this
1557 * function, but that will change. The following text from Kay Sievers offers
1558 * some insight:
1559 *
1560 * Renaming devices is racy at many levels, symlinks and other stuff are not
1561 * replaced atomically, and you get a "move" uevent, but it's not easy to
1562 * connect the event to the old and new device. Device nodes are not renamed at
1563 * all, there isn't even support for that in the kernel now.
1564 *
1565 * In the meantime, during renaming, your target name might be taken by another
1566 * driver, creating conflicts. Or the old name is taken directly after you
1567 * renamed it -- then you get events for the same DEVPATH, before you even see
1568 * the "move" event. It's just a mess, and nothing new should ever rely on
1569 * kernel device renaming. Besides that, it's not even implemented now for
1570 * other things than (driver-core wise very simple) network devices.
1571 *
1572 * We are currently about to change network renaming in udev to completely
1573 * disallow renaming of devices in the same namespace as the kernel uses,
1574 * because we can't solve the problems properly, that arise with swapping names
1575 * of multiple interfaces without races. Means, renaming of eth[0-9]* will only
1576 * be allowed to some other name than eth[0-9]*, for the aforementioned
1577 * reasons.
1578 *
1579 * Make up a "real" name in the driver before you register anything, or add
1580 * some other attributes for userspace to find the device, or use udev to add
1581 * symlinks -- but never rename kernel devices later, it's a complete mess. We
1582 * don't even want to get into that and try to implement the missing pieces in
1583 * the core. We really have other pieces to fix in the driver core mess. :)
1584 */
1585int device_rename(struct device *dev, const char *new_name)
1586{
1587 char *old_class_name = NULL;
1588 char *new_class_name = NULL;
1589 char *old_device_name = NULL;
1590 int error;
1591
1592 dev = get_device(dev);
1593 if (!dev)
1594 return -EINVAL;
1595
1596 pr_debug("device: '%s': %s: renaming to '%s'\n", dev_name(dev),
1597 __func__, new_name);
1598
1599 old_device_name = kstrdup(dev_name(dev), GFP_KERNEL);
1600 if (!old_device_name) {
1601 error = -ENOMEM;
1602 goto out;
1603 }
1604
1605 if (dev->class) {
1606 error = sysfs_rename_link(&dev->class->p->subsys.kobj,
1607 &dev->kobj, old_device_name, new_name);
1608 if (error)
1609 goto out;
1610 }
1611
1612 error = kobject_rename(&dev->kobj, new_name);
1613 if (error)
1614 goto out;
1615
1616out:
1617 put_device(dev);
1618
1619 kfree(new_class_name);
1620 kfree(old_class_name);
1621 kfree(old_device_name);
1622
1623 return error;
1624}
1625EXPORT_SYMBOL_GPL(device_rename);
1626
1627static int device_move_class_links(struct device *dev,
1628 struct device *old_parent,
1629 struct device *new_parent)
1630{
1631 int error = 0;
1632
1633 if (old_parent)
1634 sysfs_remove_link(&dev->kobj, "device");
1635 if (new_parent)
1636 error = sysfs_create_link(&dev->kobj, &new_parent->kobj,
1637 "device");
1638 return error;
1639}
1640
1641/**
1642 * device_move - moves a device to a new parent
1643 * @dev: the pointer to the struct device to be moved
1644 * @new_parent: the new parent of the device (can by NULL)
1645 * @dpm_order: how to reorder the dpm_list
1646 */
1647int device_move(struct device *dev, struct device *new_parent,
1648 enum dpm_order dpm_order)
1649{
1650 int error;
1651 struct device *old_parent;
1652 struct kobject *new_parent_kobj;
1653
1654 dev = get_device(dev);
1655 if (!dev)
1656 return -EINVAL;
1657
1658 device_pm_lock();
1659 new_parent = get_device(new_parent);
1660 new_parent_kobj = get_device_parent(dev, new_parent);
1661
1662 pr_debug("device: '%s': %s: moving to '%s'\n", dev_name(dev),
1663 __func__, new_parent ? dev_name(new_parent) : "<NULL>");
1664 error = kobject_move(&dev->kobj, new_parent_kobj);
1665 if (error) {
1666 cleanup_glue_dir(dev, new_parent_kobj);
1667 put_device(new_parent);
1668 goto out;
1669 }
1670 old_parent = dev->parent;
1671 dev->parent = new_parent;
1672 if (old_parent)
1673 klist_remove(&dev->p->knode_parent);
1674 if (new_parent) {
1675 klist_add_tail(&dev->p->knode_parent,
1676 &new_parent->p->klist_children);
1677 set_dev_node(dev, dev_to_node(new_parent));
1678 }
1679
1680 if (!dev->class)
1681 goto out_put;
1682 error = device_move_class_links(dev, old_parent, new_parent);
1683 if (error) {
1684 /* We ignore errors on cleanup since we're hosed anyway... */
1685 device_move_class_links(dev, new_parent, old_parent);
1686 if (!kobject_move(&dev->kobj, &old_parent->kobj)) {
1687 if (new_parent)
1688 klist_remove(&dev->p->knode_parent);
1689 dev->parent = old_parent;
1690 if (old_parent) {
1691 klist_add_tail(&dev->p->knode_parent,
1692 &old_parent->p->klist_children);
1693 set_dev_node(dev, dev_to_node(old_parent));
1694 }
1695 }
1696 cleanup_glue_dir(dev, new_parent_kobj);
1697 put_device(new_parent);
1698 goto out;
1699 }
1700 switch (dpm_order) {
1701 case DPM_ORDER_NONE:
1702 break;
1703 case DPM_ORDER_DEV_AFTER_PARENT:
1704 device_pm_move_after(dev, new_parent);
1705 break;
1706 case DPM_ORDER_PARENT_BEFORE_DEV:
1707 device_pm_move_before(new_parent, dev);
1708 break;
1709 case DPM_ORDER_DEV_LAST:
1710 device_pm_move_last(dev);
1711 break;
1712 }
1713out_put:
1714 put_device(old_parent);
1715out:
1716 device_pm_unlock();
1717 put_device(dev);
1718 return error;
1719}
1720EXPORT_SYMBOL_GPL(device_move);
1721
1722/**
1723 * device_shutdown - call ->shutdown() on each device to shutdown.
1724 */
1725void device_shutdown(void)
1726{
1727 struct device *dev;
1728
1729 spin_lock(&devices_kset->list_lock);
1730 /*
1731 * Walk the devices list backward, shutting down each in turn.
1732 * Beware that device unplug events may also start pulling
1733 * devices offline, even as the system is shutting down.
1734 */
1735 while (!list_empty(&devices_kset->list)) {
1736 dev = list_entry(devices_kset->list.prev, struct device,
1737 kobj.entry);
1738 get_device(dev);
1739 /*
1740 * Make sure the device is off the kset list, in the
1741 * event that dev->*->shutdown() doesn't remove it.
1742 */
1743 list_del_init(&dev->kobj.entry);
1744 spin_unlock(&devices_kset->list_lock);
1745
1746 if (dev->bus && dev->bus->shutdown) {
1747 dev_dbg(dev, "shutdown\n");
1748 dev->bus->shutdown(dev);
1749 } else if (dev->driver && dev->driver->shutdown) {
1750 dev_dbg(dev, "shutdown\n");
1751 dev->driver->shutdown(dev);
1752 }
1753 put_device(dev);
1754
1755 spin_lock(&devices_kset->list_lock);
1756 }
1757 spin_unlock(&devices_kset->list_lock);
1758 async_synchronize_full();
1759}
1760
1761/*
1762 * Device logging functions
1763 */
1764
1765#ifdef CONFIG_PRINTK
1766
1767static int __dev_printk(const char *level, const struct device *dev,
1768 struct va_format *vaf)
1769{
1770 if (!dev)
1771 return printk("%s(NULL device *): %pV", level, vaf);
1772
1773 return printk("%s%s %s: %pV",
1774 level, dev_driver_string(dev), dev_name(dev), vaf);
1775}
1776
1777int dev_printk(const char *level, const struct device *dev,
1778 const char *fmt, ...)
1779{
1780 struct va_format vaf;
1781 va_list args;
1782 int r;
1783
1784 va_start(args, fmt);
1785
1786 vaf.fmt = fmt;
1787 vaf.va = &args;
1788
1789 r = __dev_printk(level, dev, &vaf);
1790 va_end(args);
1791
1792 return r;
1793}
1794EXPORT_SYMBOL(dev_printk);
1795
1796#define define_dev_printk_level(func, kern_level) \
1797int func(const struct device *dev, const char *fmt, ...) \
1798{ \
1799 struct va_format vaf; \
1800 va_list args; \
1801 int r; \
1802 \
1803 va_start(args, fmt); \
1804 \
1805 vaf.fmt = fmt; \
1806 vaf.va = &args; \
1807 \
1808 r = __dev_printk(kern_level, dev, &vaf); \
1809 va_end(args); \
1810 \
1811 return r; \
1812} \
1813EXPORT_SYMBOL(func);
1814
1815define_dev_printk_level(dev_emerg, KERN_EMERG);
1816define_dev_printk_level(dev_alert, KERN_ALERT);
1817define_dev_printk_level(dev_crit, KERN_CRIT);
1818define_dev_printk_level(dev_err, KERN_ERR);
1819define_dev_printk_level(dev_warn, KERN_WARNING);
1820define_dev_printk_level(dev_notice, KERN_NOTICE);
1821define_dev_printk_level(_dev_info, KERN_INFO);
1822
1823#endif
1/*
2 * drivers/base/core.c - core driver model code (device registration, etc)
3 *
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.
8 *
9 * This file is released under the GPLv2
10 *
11 */
12
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/of.h>
22#include <linux/of_device.h>
23#include <linux/genhd.h>
24#include <linux/kallsyms.h>
25#include <linux/mutex.h>
26#include <linux/pm_runtime.h>
27#include <linux/netdevice.h>
28#include <linux/sysfs.h>
29
30#include "base.h"
31#include "power/power.h"
32
33#ifdef CONFIG_SYSFS_DEPRECATED
34#ifdef CONFIG_SYSFS_DEPRECATED_V2
35long sysfs_deprecated = 1;
36#else
37long sysfs_deprecated = 0;
38#endif
39static int __init sysfs_deprecated_setup(char *arg)
40{
41 return kstrtol(arg, 10, &sysfs_deprecated);
42}
43early_param("sysfs.deprecated", sysfs_deprecated_setup);
44#endif
45
46int (*platform_notify)(struct device *dev) = NULL;
47int (*platform_notify_remove)(struct device *dev) = NULL;
48static struct kobject *dev_kobj;
49struct kobject *sysfs_dev_char_kobj;
50struct kobject *sysfs_dev_block_kobj;
51
52static DEFINE_MUTEX(device_hotplug_lock);
53
54void lock_device_hotplug(void)
55{
56 mutex_lock(&device_hotplug_lock);
57}
58
59void unlock_device_hotplug(void)
60{
61 mutex_unlock(&device_hotplug_lock);
62}
63
64int lock_device_hotplug_sysfs(void)
65{
66 if (mutex_trylock(&device_hotplug_lock))
67 return 0;
68
69 /* Avoid busy looping (5 ms of sleep should do). */
70 msleep(5);
71 return restart_syscall();
72}
73
74#ifdef CONFIG_BLOCK
75static inline int device_is_not_partition(struct device *dev)
76{
77 return !(dev->type == &part_type);
78}
79#else
80static inline int device_is_not_partition(struct device *dev)
81{
82 return 1;
83}
84#endif
85
86/**
87 * dev_driver_string - Return a device's driver name, if at all possible
88 * @dev: struct device to get the name of
89 *
90 * Will return the device's driver's name if it is bound to a device. If
91 * the device is not bound to a driver, it will return the name of the bus
92 * it is attached to. If it is not attached to a bus either, an empty
93 * string will be returned.
94 */
95const char *dev_driver_string(const struct device *dev)
96{
97 struct device_driver *drv;
98
99 /* dev->driver can change to NULL underneath us because of unbinding,
100 * so be careful about accessing it. dev->bus and dev->class should
101 * never change once they are set, so they don't need special care.
102 */
103 drv = ACCESS_ONCE(dev->driver);
104 return drv ? drv->name :
105 (dev->bus ? dev->bus->name :
106 (dev->class ? dev->class->name : ""));
107}
108EXPORT_SYMBOL(dev_driver_string);
109
110#define to_dev_attr(_attr) container_of(_attr, struct device_attribute, attr)
111
112static ssize_t dev_attr_show(struct kobject *kobj, struct attribute *attr,
113 char *buf)
114{
115 struct device_attribute *dev_attr = to_dev_attr(attr);
116 struct device *dev = kobj_to_dev(kobj);
117 ssize_t ret = -EIO;
118
119 if (dev_attr->show)
120 ret = dev_attr->show(dev, dev_attr, buf);
121 if (ret >= (ssize_t)PAGE_SIZE) {
122 print_symbol("dev_attr_show: %s returned bad count\n",
123 (unsigned long)dev_attr->show);
124 }
125 return ret;
126}
127
128static ssize_t dev_attr_store(struct kobject *kobj, struct attribute *attr,
129 const char *buf, size_t count)
130{
131 struct device_attribute *dev_attr = to_dev_attr(attr);
132 struct device *dev = kobj_to_dev(kobj);
133 ssize_t ret = -EIO;
134
135 if (dev_attr->store)
136 ret = dev_attr->store(dev, dev_attr, buf, count);
137 return ret;
138}
139
140static const struct sysfs_ops dev_sysfs_ops = {
141 .show = dev_attr_show,
142 .store = dev_attr_store,
143};
144
145#define to_ext_attr(x) container_of(x, struct dev_ext_attribute, attr)
146
147ssize_t device_store_ulong(struct device *dev,
148 struct device_attribute *attr,
149 const char *buf, size_t size)
150{
151 struct dev_ext_attribute *ea = to_ext_attr(attr);
152 char *end;
153 unsigned long new = simple_strtoul(buf, &end, 0);
154 if (end == buf)
155 return -EINVAL;
156 *(unsigned long *)(ea->var) = new;
157 /* Always return full write size even if we didn't consume all */
158 return size;
159}
160EXPORT_SYMBOL_GPL(device_store_ulong);
161
162ssize_t device_show_ulong(struct device *dev,
163 struct device_attribute *attr,
164 char *buf)
165{
166 struct dev_ext_attribute *ea = to_ext_attr(attr);
167 return snprintf(buf, PAGE_SIZE, "%lx\n", *(unsigned long *)(ea->var));
168}
169EXPORT_SYMBOL_GPL(device_show_ulong);
170
171ssize_t device_store_int(struct device *dev,
172 struct device_attribute *attr,
173 const char *buf, size_t size)
174{
175 struct dev_ext_attribute *ea = to_ext_attr(attr);
176 char *end;
177 long new = simple_strtol(buf, &end, 0);
178 if (end == buf || new > INT_MAX || new < INT_MIN)
179 return -EINVAL;
180 *(int *)(ea->var) = new;
181 /* Always return full write size even if we didn't consume all */
182 return size;
183}
184EXPORT_SYMBOL_GPL(device_store_int);
185
186ssize_t device_show_int(struct device *dev,
187 struct device_attribute *attr,
188 char *buf)
189{
190 struct dev_ext_attribute *ea = to_ext_attr(attr);
191
192 return snprintf(buf, PAGE_SIZE, "%d\n", *(int *)(ea->var));
193}
194EXPORT_SYMBOL_GPL(device_show_int);
195
196ssize_t device_store_bool(struct device *dev, struct device_attribute *attr,
197 const char *buf, size_t size)
198{
199 struct dev_ext_attribute *ea = to_ext_attr(attr);
200
201 if (strtobool(buf, ea->var) < 0)
202 return -EINVAL;
203
204 return size;
205}
206EXPORT_SYMBOL_GPL(device_store_bool);
207
208ssize_t device_show_bool(struct device *dev, struct device_attribute *attr,
209 char *buf)
210{
211 struct dev_ext_attribute *ea = to_ext_attr(attr);
212
213 return snprintf(buf, PAGE_SIZE, "%d\n", *(bool *)(ea->var));
214}
215EXPORT_SYMBOL_GPL(device_show_bool);
216
217/**
218 * device_release - free device structure.
219 * @kobj: device's kobject.
220 *
221 * This is called once the reference count for the object
222 * reaches 0. We forward the call to the device's release
223 * method, which should handle actually freeing the structure.
224 */
225static void device_release(struct kobject *kobj)
226{
227 struct device *dev = kobj_to_dev(kobj);
228 struct device_private *p = dev->p;
229
230 /*
231 * Some platform devices are driven without driver attached
232 * and managed resources may have been acquired. Make sure
233 * all resources are released.
234 *
235 * Drivers still can add resources into device after device
236 * is deleted but alive, so release devres here to avoid
237 * possible memory leak.
238 */
239 devres_release_all(dev);
240
241 if (dev->release)
242 dev->release(dev);
243 else if (dev->type && dev->type->release)
244 dev->type->release(dev);
245 else if (dev->class && dev->class->dev_release)
246 dev->class->dev_release(dev);
247 else
248 WARN(1, KERN_ERR "Device '%s' does not have a release() "
249 "function, it is broken and must be fixed.\n",
250 dev_name(dev));
251 kfree(p);
252}
253
254static const void *device_namespace(struct kobject *kobj)
255{
256 struct device *dev = kobj_to_dev(kobj);
257 const void *ns = NULL;
258
259 if (dev->class && dev->class->ns_type)
260 ns = dev->class->namespace(dev);
261
262 return ns;
263}
264
265static struct kobj_type device_ktype = {
266 .release = device_release,
267 .sysfs_ops = &dev_sysfs_ops,
268 .namespace = device_namespace,
269};
270
271
272static int dev_uevent_filter(struct kset *kset, struct kobject *kobj)
273{
274 struct kobj_type *ktype = get_ktype(kobj);
275
276 if (ktype == &device_ktype) {
277 struct device *dev = kobj_to_dev(kobj);
278 if (dev->bus)
279 return 1;
280 if (dev->class)
281 return 1;
282 }
283 return 0;
284}
285
286static const char *dev_uevent_name(struct kset *kset, struct kobject *kobj)
287{
288 struct device *dev = kobj_to_dev(kobj);
289
290 if (dev->bus)
291 return dev->bus->name;
292 if (dev->class)
293 return dev->class->name;
294 return NULL;
295}
296
297static int dev_uevent(struct kset *kset, struct kobject *kobj,
298 struct kobj_uevent_env *env)
299{
300 struct device *dev = kobj_to_dev(kobj);
301 int retval = 0;
302
303 /* add device node properties if present */
304 if (MAJOR(dev->devt)) {
305 const char *tmp;
306 const char *name;
307 umode_t mode = 0;
308 kuid_t uid = GLOBAL_ROOT_UID;
309 kgid_t gid = GLOBAL_ROOT_GID;
310
311 add_uevent_var(env, "MAJOR=%u", MAJOR(dev->devt));
312 add_uevent_var(env, "MINOR=%u", MINOR(dev->devt));
313 name = device_get_devnode(dev, &mode, &uid, &gid, &tmp);
314 if (name) {
315 add_uevent_var(env, "DEVNAME=%s", name);
316 if (mode)
317 add_uevent_var(env, "DEVMODE=%#o", mode & 0777);
318 if (!uid_eq(uid, GLOBAL_ROOT_UID))
319 add_uevent_var(env, "DEVUID=%u", from_kuid(&init_user_ns, uid));
320 if (!gid_eq(gid, GLOBAL_ROOT_GID))
321 add_uevent_var(env, "DEVGID=%u", from_kgid(&init_user_ns, gid));
322 kfree(tmp);
323 }
324 }
325
326 if (dev->type && dev->type->name)
327 add_uevent_var(env, "DEVTYPE=%s", dev->type->name);
328
329 if (dev->driver)
330 add_uevent_var(env, "DRIVER=%s", dev->driver->name);
331
332 /* Add common DT information about the device */
333 of_device_uevent(dev, env);
334
335 /* have the bus specific function add its stuff */
336 if (dev->bus && dev->bus->uevent) {
337 retval = dev->bus->uevent(dev, env);
338 if (retval)
339 pr_debug("device: '%s': %s: bus uevent() returned %d\n",
340 dev_name(dev), __func__, retval);
341 }
342
343 /* have the class specific function add its stuff */
344 if (dev->class && dev->class->dev_uevent) {
345 retval = dev->class->dev_uevent(dev, env);
346 if (retval)
347 pr_debug("device: '%s': %s: class uevent() "
348 "returned %d\n", dev_name(dev),
349 __func__, retval);
350 }
351
352 /* have the device type specific function add its stuff */
353 if (dev->type && dev->type->uevent) {
354 retval = dev->type->uevent(dev, env);
355 if (retval)
356 pr_debug("device: '%s': %s: dev_type uevent() "
357 "returned %d\n", dev_name(dev),
358 __func__, retval);
359 }
360
361 return retval;
362}
363
364static const struct kset_uevent_ops device_uevent_ops = {
365 .filter = dev_uevent_filter,
366 .name = dev_uevent_name,
367 .uevent = dev_uevent,
368};
369
370static ssize_t uevent_show(struct device *dev, struct device_attribute *attr,
371 char *buf)
372{
373 struct kobject *top_kobj;
374 struct kset *kset;
375 struct kobj_uevent_env *env = NULL;
376 int i;
377 size_t count = 0;
378 int retval;
379
380 /* search the kset, the device belongs to */
381 top_kobj = &dev->kobj;
382 while (!top_kobj->kset && top_kobj->parent)
383 top_kobj = top_kobj->parent;
384 if (!top_kobj->kset)
385 goto out;
386
387 kset = top_kobj->kset;
388 if (!kset->uevent_ops || !kset->uevent_ops->uevent)
389 goto out;
390
391 /* respect filter */
392 if (kset->uevent_ops && kset->uevent_ops->filter)
393 if (!kset->uevent_ops->filter(kset, &dev->kobj))
394 goto out;
395
396 env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL);
397 if (!env)
398 return -ENOMEM;
399
400 /* let the kset specific function add its keys */
401 retval = kset->uevent_ops->uevent(kset, &dev->kobj, env);
402 if (retval)
403 goto out;
404
405 /* copy keys to file */
406 for (i = 0; i < env->envp_idx; i++)
407 count += sprintf(&buf[count], "%s\n", env->envp[i]);
408out:
409 kfree(env);
410 return count;
411}
412
413static ssize_t uevent_store(struct device *dev, struct device_attribute *attr,
414 const char *buf, size_t count)
415{
416 enum kobject_action action;
417
418 if (kobject_action_type(buf, count, &action) == 0)
419 kobject_uevent(&dev->kobj, action);
420 else
421 dev_err(dev, "uevent: unknown action-string\n");
422 return count;
423}
424static DEVICE_ATTR_RW(uevent);
425
426static ssize_t online_show(struct device *dev, struct device_attribute *attr,
427 char *buf)
428{
429 bool val;
430
431 device_lock(dev);
432 val = !dev->offline;
433 device_unlock(dev);
434 return sprintf(buf, "%u\n", val);
435}
436
437static ssize_t online_store(struct device *dev, struct device_attribute *attr,
438 const char *buf, size_t count)
439{
440 bool val;
441 int ret;
442
443 ret = strtobool(buf, &val);
444 if (ret < 0)
445 return ret;
446
447 ret = lock_device_hotplug_sysfs();
448 if (ret)
449 return ret;
450
451 ret = val ? device_online(dev) : device_offline(dev);
452 unlock_device_hotplug();
453 return ret < 0 ? ret : count;
454}
455static DEVICE_ATTR_RW(online);
456
457int device_add_groups(struct device *dev, const struct attribute_group **groups)
458{
459 return sysfs_create_groups(&dev->kobj, groups);
460}
461
462void device_remove_groups(struct device *dev,
463 const struct attribute_group **groups)
464{
465 sysfs_remove_groups(&dev->kobj, groups);
466}
467
468static int device_add_attrs(struct device *dev)
469{
470 struct class *class = dev->class;
471 const struct device_type *type = dev->type;
472 int error;
473
474 if (class) {
475 error = device_add_groups(dev, class->dev_groups);
476 if (error)
477 return error;
478 }
479
480 if (type) {
481 error = device_add_groups(dev, type->groups);
482 if (error)
483 goto err_remove_class_groups;
484 }
485
486 error = device_add_groups(dev, dev->groups);
487 if (error)
488 goto err_remove_type_groups;
489
490 if (device_supports_offline(dev) && !dev->offline_disabled) {
491 error = device_create_file(dev, &dev_attr_online);
492 if (error)
493 goto err_remove_dev_groups;
494 }
495
496 return 0;
497
498 err_remove_dev_groups:
499 device_remove_groups(dev, dev->groups);
500 err_remove_type_groups:
501 if (type)
502 device_remove_groups(dev, type->groups);
503 err_remove_class_groups:
504 if (class)
505 device_remove_groups(dev, class->dev_groups);
506
507 return error;
508}
509
510static void device_remove_attrs(struct device *dev)
511{
512 struct class *class = dev->class;
513 const struct device_type *type = dev->type;
514
515 device_remove_file(dev, &dev_attr_online);
516 device_remove_groups(dev, dev->groups);
517
518 if (type)
519 device_remove_groups(dev, type->groups);
520
521 if (class)
522 device_remove_groups(dev, class->dev_groups);
523}
524
525static ssize_t dev_show(struct device *dev, struct device_attribute *attr,
526 char *buf)
527{
528 return print_dev_t(buf, dev->devt);
529}
530static DEVICE_ATTR_RO(dev);
531
532/* /sys/devices/ */
533struct kset *devices_kset;
534
535/**
536 * device_create_file - create sysfs attribute file for device.
537 * @dev: device.
538 * @attr: device attribute descriptor.
539 */
540int device_create_file(struct device *dev,
541 const struct device_attribute *attr)
542{
543 int error = 0;
544
545 if (dev) {
546 WARN(((attr->attr.mode & S_IWUGO) && !attr->store),
547 "Attribute %s: write permission without 'store'\n",
548 attr->attr.name);
549 WARN(((attr->attr.mode & S_IRUGO) && !attr->show),
550 "Attribute %s: read permission without 'show'\n",
551 attr->attr.name);
552 error = sysfs_create_file(&dev->kobj, &attr->attr);
553 }
554
555 return error;
556}
557EXPORT_SYMBOL_GPL(device_create_file);
558
559/**
560 * device_remove_file - remove sysfs attribute file.
561 * @dev: device.
562 * @attr: device attribute descriptor.
563 */
564void device_remove_file(struct device *dev,
565 const struct device_attribute *attr)
566{
567 if (dev)
568 sysfs_remove_file(&dev->kobj, &attr->attr);
569}
570EXPORT_SYMBOL_GPL(device_remove_file);
571
572/**
573 * device_remove_file_self - remove sysfs attribute file from its own method.
574 * @dev: device.
575 * @attr: device attribute descriptor.
576 *
577 * See kernfs_remove_self() for details.
578 */
579bool device_remove_file_self(struct device *dev,
580 const struct device_attribute *attr)
581{
582 if (dev)
583 return sysfs_remove_file_self(&dev->kobj, &attr->attr);
584 else
585 return false;
586}
587EXPORT_SYMBOL_GPL(device_remove_file_self);
588
589/**
590 * device_create_bin_file - create sysfs binary attribute file for device.
591 * @dev: device.
592 * @attr: device binary attribute descriptor.
593 */
594int device_create_bin_file(struct device *dev,
595 const struct bin_attribute *attr)
596{
597 int error = -EINVAL;
598 if (dev)
599 error = sysfs_create_bin_file(&dev->kobj, attr);
600 return error;
601}
602EXPORT_SYMBOL_GPL(device_create_bin_file);
603
604/**
605 * device_remove_bin_file - remove sysfs binary attribute file
606 * @dev: device.
607 * @attr: device binary attribute descriptor.
608 */
609void device_remove_bin_file(struct device *dev,
610 const struct bin_attribute *attr)
611{
612 if (dev)
613 sysfs_remove_bin_file(&dev->kobj, attr);
614}
615EXPORT_SYMBOL_GPL(device_remove_bin_file);
616
617static void klist_children_get(struct klist_node *n)
618{
619 struct device_private *p = to_device_private_parent(n);
620 struct device *dev = p->device;
621
622 get_device(dev);
623}
624
625static void klist_children_put(struct klist_node *n)
626{
627 struct device_private *p = to_device_private_parent(n);
628 struct device *dev = p->device;
629
630 put_device(dev);
631}
632
633/**
634 * device_initialize - init device structure.
635 * @dev: device.
636 *
637 * This prepares the device for use by other layers by initializing
638 * its fields.
639 * It is the first half of device_register(), if called by
640 * that function, though it can also be called separately, so one
641 * may use @dev's fields. In particular, get_device()/put_device()
642 * may be used for reference counting of @dev after calling this
643 * function.
644 *
645 * All fields in @dev must be initialized by the caller to 0, except
646 * for those explicitly set to some other value. The simplest
647 * approach is to use kzalloc() to allocate the structure containing
648 * @dev.
649 *
650 * NOTE: Use put_device() to give up your reference instead of freeing
651 * @dev directly once you have called this function.
652 */
653void device_initialize(struct device *dev)
654{
655 dev->kobj.kset = devices_kset;
656 kobject_init(&dev->kobj, &device_ktype);
657 INIT_LIST_HEAD(&dev->dma_pools);
658 mutex_init(&dev->mutex);
659 lockdep_set_novalidate_class(&dev->mutex);
660 spin_lock_init(&dev->devres_lock);
661 INIT_LIST_HEAD(&dev->devres_head);
662 device_pm_init(dev);
663 set_dev_node(dev, -1);
664}
665EXPORT_SYMBOL_GPL(device_initialize);
666
667struct kobject *virtual_device_parent(struct device *dev)
668{
669 static struct kobject *virtual_dir = NULL;
670
671 if (!virtual_dir)
672 virtual_dir = kobject_create_and_add("virtual",
673 &devices_kset->kobj);
674
675 return virtual_dir;
676}
677
678struct class_dir {
679 struct kobject kobj;
680 struct class *class;
681};
682
683#define to_class_dir(obj) container_of(obj, struct class_dir, kobj)
684
685static void class_dir_release(struct kobject *kobj)
686{
687 struct class_dir *dir = to_class_dir(kobj);
688 kfree(dir);
689}
690
691static const
692struct kobj_ns_type_operations *class_dir_child_ns_type(struct kobject *kobj)
693{
694 struct class_dir *dir = to_class_dir(kobj);
695 return dir->class->ns_type;
696}
697
698static struct kobj_type class_dir_ktype = {
699 .release = class_dir_release,
700 .sysfs_ops = &kobj_sysfs_ops,
701 .child_ns_type = class_dir_child_ns_type
702};
703
704static struct kobject *
705class_dir_create_and_add(struct class *class, struct kobject *parent_kobj)
706{
707 struct class_dir *dir;
708 int retval;
709
710 dir = kzalloc(sizeof(*dir), GFP_KERNEL);
711 if (!dir)
712 return NULL;
713
714 dir->class = class;
715 kobject_init(&dir->kobj, &class_dir_ktype);
716
717 dir->kobj.kset = &class->p->glue_dirs;
718
719 retval = kobject_add(&dir->kobj, parent_kobj, "%s", class->name);
720 if (retval < 0) {
721 kobject_put(&dir->kobj);
722 return NULL;
723 }
724 return &dir->kobj;
725}
726
727
728static struct kobject *get_device_parent(struct device *dev,
729 struct device *parent)
730{
731 if (dev->class) {
732 static DEFINE_MUTEX(gdp_mutex);
733 struct kobject *kobj = NULL;
734 struct kobject *parent_kobj;
735 struct kobject *k;
736
737#ifdef CONFIG_BLOCK
738 /* block disks show up in /sys/block */
739 if (sysfs_deprecated && dev->class == &block_class) {
740 if (parent && parent->class == &block_class)
741 return &parent->kobj;
742 return &block_class.p->subsys.kobj;
743 }
744#endif
745
746 /*
747 * If we have no parent, we live in "virtual".
748 * Class-devices with a non class-device as parent, live
749 * in a "glue" directory to prevent namespace collisions.
750 */
751 if (parent == NULL)
752 parent_kobj = virtual_device_parent(dev);
753 else if (parent->class && !dev->class->ns_type)
754 return &parent->kobj;
755 else
756 parent_kobj = &parent->kobj;
757
758 mutex_lock(&gdp_mutex);
759
760 /* find our class-directory at the parent and reference it */
761 spin_lock(&dev->class->p->glue_dirs.list_lock);
762 list_for_each_entry(k, &dev->class->p->glue_dirs.list, entry)
763 if (k->parent == parent_kobj) {
764 kobj = kobject_get(k);
765 break;
766 }
767 spin_unlock(&dev->class->p->glue_dirs.list_lock);
768 if (kobj) {
769 mutex_unlock(&gdp_mutex);
770 return kobj;
771 }
772
773 /* or create a new class-directory at the parent device */
774 k = class_dir_create_and_add(dev->class, parent_kobj);
775 /* do not emit an uevent for this simple "glue" directory */
776 mutex_unlock(&gdp_mutex);
777 return k;
778 }
779
780 /* subsystems can specify a default root directory for their devices */
781 if (!parent && dev->bus && dev->bus->dev_root)
782 return &dev->bus->dev_root->kobj;
783
784 if (parent)
785 return &parent->kobj;
786 return NULL;
787}
788
789static void cleanup_glue_dir(struct device *dev, struct kobject *glue_dir)
790{
791 /* see if we live in a "glue" directory */
792 if (!glue_dir || !dev->class ||
793 glue_dir->kset != &dev->class->p->glue_dirs)
794 return;
795
796 kobject_put(glue_dir);
797}
798
799static void cleanup_device_parent(struct device *dev)
800{
801 cleanup_glue_dir(dev, dev->kobj.parent);
802}
803
804static int device_add_class_symlinks(struct device *dev)
805{
806 int error;
807
808 if (!dev->class)
809 return 0;
810
811 error = sysfs_create_link(&dev->kobj,
812 &dev->class->p->subsys.kobj,
813 "subsystem");
814 if (error)
815 goto out;
816
817 if (dev->parent && device_is_not_partition(dev)) {
818 error = sysfs_create_link(&dev->kobj, &dev->parent->kobj,
819 "device");
820 if (error)
821 goto out_subsys;
822 }
823
824#ifdef CONFIG_BLOCK
825 /* /sys/block has directories and does not need symlinks */
826 if (sysfs_deprecated && dev->class == &block_class)
827 return 0;
828#endif
829
830 /* link in the class directory pointing to the device */
831 error = sysfs_create_link(&dev->class->p->subsys.kobj,
832 &dev->kobj, dev_name(dev));
833 if (error)
834 goto out_device;
835
836 return 0;
837
838out_device:
839 sysfs_remove_link(&dev->kobj, "device");
840
841out_subsys:
842 sysfs_remove_link(&dev->kobj, "subsystem");
843out:
844 return error;
845}
846
847static void device_remove_class_symlinks(struct device *dev)
848{
849 if (!dev->class)
850 return;
851
852 if (dev->parent && device_is_not_partition(dev))
853 sysfs_remove_link(&dev->kobj, "device");
854 sysfs_remove_link(&dev->kobj, "subsystem");
855#ifdef CONFIG_BLOCK
856 if (sysfs_deprecated && dev->class == &block_class)
857 return;
858#endif
859 sysfs_delete_link(&dev->class->p->subsys.kobj, &dev->kobj, dev_name(dev));
860}
861
862/**
863 * dev_set_name - set a device name
864 * @dev: device
865 * @fmt: format string for the device's name
866 */
867int dev_set_name(struct device *dev, const char *fmt, ...)
868{
869 va_list vargs;
870 int err;
871
872 va_start(vargs, fmt);
873 err = kobject_set_name_vargs(&dev->kobj, fmt, vargs);
874 va_end(vargs);
875 return err;
876}
877EXPORT_SYMBOL_GPL(dev_set_name);
878
879/**
880 * device_to_dev_kobj - select a /sys/dev/ directory for the device
881 * @dev: device
882 *
883 * By default we select char/ for new entries. Setting class->dev_obj
884 * to NULL prevents an entry from being created. class->dev_kobj must
885 * be set (or cleared) before any devices are registered to the class
886 * otherwise device_create_sys_dev_entry() and
887 * device_remove_sys_dev_entry() will disagree about the presence of
888 * the link.
889 */
890static struct kobject *device_to_dev_kobj(struct device *dev)
891{
892 struct kobject *kobj;
893
894 if (dev->class)
895 kobj = dev->class->dev_kobj;
896 else
897 kobj = sysfs_dev_char_kobj;
898
899 return kobj;
900}
901
902static int device_create_sys_dev_entry(struct device *dev)
903{
904 struct kobject *kobj = device_to_dev_kobj(dev);
905 int error = 0;
906 char devt_str[15];
907
908 if (kobj) {
909 format_dev_t(devt_str, dev->devt);
910 error = sysfs_create_link(kobj, &dev->kobj, devt_str);
911 }
912
913 return error;
914}
915
916static void device_remove_sys_dev_entry(struct device *dev)
917{
918 struct kobject *kobj = device_to_dev_kobj(dev);
919 char devt_str[15];
920
921 if (kobj) {
922 format_dev_t(devt_str, dev->devt);
923 sysfs_remove_link(kobj, devt_str);
924 }
925}
926
927int device_private_init(struct device *dev)
928{
929 dev->p = kzalloc(sizeof(*dev->p), GFP_KERNEL);
930 if (!dev->p)
931 return -ENOMEM;
932 dev->p->device = dev;
933 klist_init(&dev->p->klist_children, klist_children_get,
934 klist_children_put);
935 INIT_LIST_HEAD(&dev->p->deferred_probe);
936 return 0;
937}
938
939/**
940 * device_add - add device to device hierarchy.
941 * @dev: device.
942 *
943 * This is part 2 of device_register(), though may be called
944 * separately _iff_ device_initialize() has been called separately.
945 *
946 * This adds @dev to the kobject hierarchy via kobject_add(), adds it
947 * to the global and sibling lists for the device, then
948 * adds it to the other relevant subsystems of the driver model.
949 *
950 * Do not call this routine or device_register() more than once for
951 * any device structure. The driver model core is not designed to work
952 * with devices that get unregistered and then spring back to life.
953 * (Among other things, it's very hard to guarantee that all references
954 * to the previous incarnation of @dev have been dropped.) Allocate
955 * and register a fresh new struct device instead.
956 *
957 * NOTE: _Never_ directly free @dev after calling this function, even
958 * if it returned an error! Always use put_device() to give up your
959 * reference instead.
960 */
961int device_add(struct device *dev)
962{
963 struct device *parent = NULL;
964 struct kobject *kobj;
965 struct class_interface *class_intf;
966 int error = -EINVAL;
967
968 dev = get_device(dev);
969 if (!dev)
970 goto done;
971
972 if (!dev->p) {
973 error = device_private_init(dev);
974 if (error)
975 goto done;
976 }
977
978 /*
979 * for statically allocated devices, which should all be converted
980 * some day, we need to initialize the name. We prevent reading back
981 * the name, and force the use of dev_name()
982 */
983 if (dev->init_name) {
984 dev_set_name(dev, "%s", dev->init_name);
985 dev->init_name = NULL;
986 }
987
988 /* subsystems can specify simple device enumeration */
989 if (!dev_name(dev) && dev->bus && dev->bus->dev_name)
990 dev_set_name(dev, "%s%u", dev->bus->dev_name, dev->id);
991
992 if (!dev_name(dev)) {
993 error = -EINVAL;
994 goto name_error;
995 }
996
997 pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
998
999 parent = get_device(dev->parent);
1000 kobj = get_device_parent(dev, parent);
1001 if (kobj)
1002 dev->kobj.parent = kobj;
1003
1004 /* use parent numa_node */
1005 if (parent)
1006 set_dev_node(dev, dev_to_node(parent));
1007
1008 /* first, register with generic layer. */
1009 /* we require the name to be set before, and pass NULL */
1010 error = kobject_add(&dev->kobj, dev->kobj.parent, NULL);
1011 if (error)
1012 goto Error;
1013
1014 /* notify platform of device entry */
1015 if (platform_notify)
1016 platform_notify(dev);
1017
1018 error = device_create_file(dev, &dev_attr_uevent);
1019 if (error)
1020 goto attrError;
1021
1022 if (MAJOR(dev->devt)) {
1023 error = device_create_file(dev, &dev_attr_dev);
1024 if (error)
1025 goto ueventattrError;
1026
1027 error = device_create_sys_dev_entry(dev);
1028 if (error)
1029 goto devtattrError;
1030
1031 devtmpfs_create_node(dev);
1032 }
1033
1034 error = device_add_class_symlinks(dev);
1035 if (error)
1036 goto SymlinkError;
1037 error = device_add_attrs(dev);
1038 if (error)
1039 goto AttrsError;
1040 error = bus_add_device(dev);
1041 if (error)
1042 goto BusError;
1043 error = dpm_sysfs_add(dev);
1044 if (error)
1045 goto DPMError;
1046 device_pm_add(dev);
1047
1048 /* Notify clients of device addition. This call must come
1049 * after dpm_sysfs_add() and before kobject_uevent().
1050 */
1051 if (dev->bus)
1052 blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
1053 BUS_NOTIFY_ADD_DEVICE, dev);
1054
1055 kobject_uevent(&dev->kobj, KOBJ_ADD);
1056 bus_probe_device(dev);
1057 if (parent)
1058 klist_add_tail(&dev->p->knode_parent,
1059 &parent->p->klist_children);
1060
1061 if (dev->class) {
1062 mutex_lock(&dev->class->p->mutex);
1063 /* tie the class to the device */
1064 klist_add_tail(&dev->knode_class,
1065 &dev->class->p->klist_devices);
1066
1067 /* notify any interfaces that the device is here */
1068 list_for_each_entry(class_intf,
1069 &dev->class->p->interfaces, node)
1070 if (class_intf->add_dev)
1071 class_intf->add_dev(dev, class_intf);
1072 mutex_unlock(&dev->class->p->mutex);
1073 }
1074done:
1075 put_device(dev);
1076 return error;
1077 DPMError:
1078 bus_remove_device(dev);
1079 BusError:
1080 device_remove_attrs(dev);
1081 AttrsError:
1082 device_remove_class_symlinks(dev);
1083 SymlinkError:
1084 if (MAJOR(dev->devt))
1085 devtmpfs_delete_node(dev);
1086 if (MAJOR(dev->devt))
1087 device_remove_sys_dev_entry(dev);
1088 devtattrError:
1089 if (MAJOR(dev->devt))
1090 device_remove_file(dev, &dev_attr_dev);
1091 ueventattrError:
1092 device_remove_file(dev, &dev_attr_uevent);
1093 attrError:
1094 kobject_uevent(&dev->kobj, KOBJ_REMOVE);
1095 kobject_del(&dev->kobj);
1096 Error:
1097 cleanup_device_parent(dev);
1098 if (parent)
1099 put_device(parent);
1100name_error:
1101 kfree(dev->p);
1102 dev->p = NULL;
1103 goto done;
1104}
1105EXPORT_SYMBOL_GPL(device_add);
1106
1107/**
1108 * device_register - register a device with the system.
1109 * @dev: pointer to the device structure
1110 *
1111 * This happens in two clean steps - initialize the device
1112 * and add it to the system. The two steps can be called
1113 * separately, but this is the easiest and most common.
1114 * I.e. you should only call the two helpers separately if
1115 * have a clearly defined need to use and refcount the device
1116 * before it is added to the hierarchy.
1117 *
1118 * For more information, see the kerneldoc for device_initialize()
1119 * and device_add().
1120 *
1121 * NOTE: _Never_ directly free @dev after calling this function, even
1122 * if it returned an error! Always use put_device() to give up the
1123 * reference initialized in this function instead.
1124 */
1125int device_register(struct device *dev)
1126{
1127 device_initialize(dev);
1128 return device_add(dev);
1129}
1130EXPORT_SYMBOL_GPL(device_register);
1131
1132/**
1133 * get_device - increment reference count for device.
1134 * @dev: device.
1135 *
1136 * This simply forwards the call to kobject_get(), though
1137 * we do take care to provide for the case that we get a NULL
1138 * pointer passed in.
1139 */
1140struct device *get_device(struct device *dev)
1141{
1142 return dev ? kobj_to_dev(kobject_get(&dev->kobj)) : NULL;
1143}
1144EXPORT_SYMBOL_GPL(get_device);
1145
1146/**
1147 * put_device - decrement reference count.
1148 * @dev: device in question.
1149 */
1150void put_device(struct device *dev)
1151{
1152 /* might_sleep(); */
1153 if (dev)
1154 kobject_put(&dev->kobj);
1155}
1156EXPORT_SYMBOL_GPL(put_device);
1157
1158/**
1159 * device_del - delete device from system.
1160 * @dev: device.
1161 *
1162 * This is the first part of the device unregistration
1163 * sequence. This removes the device from the lists we control
1164 * from here, has it removed from the other driver model
1165 * subsystems it was added to in device_add(), and removes it
1166 * from the kobject hierarchy.
1167 *
1168 * NOTE: this should be called manually _iff_ device_add() was
1169 * also called manually.
1170 */
1171void device_del(struct device *dev)
1172{
1173 struct device *parent = dev->parent;
1174 struct class_interface *class_intf;
1175
1176 /* Notify clients of device removal. This call must come
1177 * before dpm_sysfs_remove().
1178 */
1179 if (dev->bus)
1180 blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
1181 BUS_NOTIFY_DEL_DEVICE, dev);
1182 dpm_sysfs_remove(dev);
1183 if (parent)
1184 klist_del(&dev->p->knode_parent);
1185 if (MAJOR(dev->devt)) {
1186 devtmpfs_delete_node(dev);
1187 device_remove_sys_dev_entry(dev);
1188 device_remove_file(dev, &dev_attr_dev);
1189 }
1190 if (dev->class) {
1191 device_remove_class_symlinks(dev);
1192
1193 mutex_lock(&dev->class->p->mutex);
1194 /* notify any interfaces that the device is now gone */
1195 list_for_each_entry(class_intf,
1196 &dev->class->p->interfaces, node)
1197 if (class_intf->remove_dev)
1198 class_intf->remove_dev(dev, class_intf);
1199 /* remove the device from the class list */
1200 klist_del(&dev->knode_class);
1201 mutex_unlock(&dev->class->p->mutex);
1202 }
1203 device_remove_file(dev, &dev_attr_uevent);
1204 device_remove_attrs(dev);
1205 bus_remove_device(dev);
1206 device_pm_remove(dev);
1207 driver_deferred_probe_del(dev);
1208
1209 /* Notify the platform of the removal, in case they
1210 * need to do anything...
1211 */
1212 if (platform_notify_remove)
1213 platform_notify_remove(dev);
1214 kobject_uevent(&dev->kobj, KOBJ_REMOVE);
1215 cleanup_device_parent(dev);
1216 kobject_del(&dev->kobj);
1217 put_device(parent);
1218}
1219EXPORT_SYMBOL_GPL(device_del);
1220
1221/**
1222 * device_unregister - unregister device from system.
1223 * @dev: device going away.
1224 *
1225 * We do this in two parts, like we do device_register(). First,
1226 * we remove it from all the subsystems with device_del(), then
1227 * we decrement the reference count via put_device(). If that
1228 * is the final reference count, the device will be cleaned up
1229 * via device_release() above. Otherwise, the structure will
1230 * stick around until the final reference to the device is dropped.
1231 */
1232void device_unregister(struct device *dev)
1233{
1234 pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
1235 device_del(dev);
1236 put_device(dev);
1237}
1238EXPORT_SYMBOL_GPL(device_unregister);
1239
1240static struct device *next_device(struct klist_iter *i)
1241{
1242 struct klist_node *n = klist_next(i);
1243 struct device *dev = NULL;
1244 struct device_private *p;
1245
1246 if (n) {
1247 p = to_device_private_parent(n);
1248 dev = p->device;
1249 }
1250 return dev;
1251}
1252
1253/**
1254 * device_get_devnode - path of device node file
1255 * @dev: device
1256 * @mode: returned file access mode
1257 * @uid: returned file owner
1258 * @gid: returned file group
1259 * @tmp: possibly allocated string
1260 *
1261 * Return the relative path of a possible device node.
1262 * Non-default names may need to allocate a memory to compose
1263 * a name. This memory is returned in tmp and needs to be
1264 * freed by the caller.
1265 */
1266const char *device_get_devnode(struct device *dev,
1267 umode_t *mode, kuid_t *uid, kgid_t *gid,
1268 const char **tmp)
1269{
1270 char *s;
1271
1272 *tmp = NULL;
1273
1274 /* the device type may provide a specific name */
1275 if (dev->type && dev->type->devnode)
1276 *tmp = dev->type->devnode(dev, mode, uid, gid);
1277 if (*tmp)
1278 return *tmp;
1279
1280 /* the class may provide a specific name */
1281 if (dev->class && dev->class->devnode)
1282 *tmp = dev->class->devnode(dev, mode);
1283 if (*tmp)
1284 return *tmp;
1285
1286 /* return name without allocation, tmp == NULL */
1287 if (strchr(dev_name(dev), '!') == NULL)
1288 return dev_name(dev);
1289
1290 /* replace '!' in the name with '/' */
1291 *tmp = kstrdup(dev_name(dev), GFP_KERNEL);
1292 if (!*tmp)
1293 return NULL;
1294 while ((s = strchr(*tmp, '!')))
1295 s[0] = '/';
1296 return *tmp;
1297}
1298
1299/**
1300 * device_for_each_child - device child iterator.
1301 * @parent: parent struct device.
1302 * @fn: function to be called for each device.
1303 * @data: data for the callback.
1304 *
1305 * Iterate over @parent's child devices, and call @fn for each,
1306 * passing it @data.
1307 *
1308 * We check the return of @fn each time. If it returns anything
1309 * other than 0, we break out and return that value.
1310 */
1311int device_for_each_child(struct device *parent, void *data,
1312 int (*fn)(struct device *dev, void *data))
1313{
1314 struct klist_iter i;
1315 struct device *child;
1316 int error = 0;
1317
1318 if (!parent->p)
1319 return 0;
1320
1321 klist_iter_init(&parent->p->klist_children, &i);
1322 while ((child = next_device(&i)) && !error)
1323 error = fn(child, data);
1324 klist_iter_exit(&i);
1325 return error;
1326}
1327EXPORT_SYMBOL_GPL(device_for_each_child);
1328
1329/**
1330 * device_find_child - device iterator for locating a particular device.
1331 * @parent: parent struct device
1332 * @match: Callback function to check device
1333 * @data: Data to pass to match function
1334 *
1335 * This is similar to the device_for_each_child() function above, but it
1336 * returns a reference to a device that is 'found' for later use, as
1337 * determined by the @match callback.
1338 *
1339 * The callback should return 0 if the device doesn't match and non-zero
1340 * if it does. If the callback returns non-zero and a reference to the
1341 * current device can be obtained, this function will return to the caller
1342 * and not iterate over any more devices.
1343 *
1344 * NOTE: you will need to drop the reference with put_device() after use.
1345 */
1346struct device *device_find_child(struct device *parent, void *data,
1347 int (*match)(struct device *dev, void *data))
1348{
1349 struct klist_iter i;
1350 struct device *child;
1351
1352 if (!parent)
1353 return NULL;
1354
1355 klist_iter_init(&parent->p->klist_children, &i);
1356 while ((child = next_device(&i)))
1357 if (match(child, data) && get_device(child))
1358 break;
1359 klist_iter_exit(&i);
1360 return child;
1361}
1362EXPORT_SYMBOL_GPL(device_find_child);
1363
1364int __init devices_init(void)
1365{
1366 devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL);
1367 if (!devices_kset)
1368 return -ENOMEM;
1369 dev_kobj = kobject_create_and_add("dev", NULL);
1370 if (!dev_kobj)
1371 goto dev_kobj_err;
1372 sysfs_dev_block_kobj = kobject_create_and_add("block", dev_kobj);
1373 if (!sysfs_dev_block_kobj)
1374 goto block_kobj_err;
1375 sysfs_dev_char_kobj = kobject_create_and_add("char", dev_kobj);
1376 if (!sysfs_dev_char_kobj)
1377 goto char_kobj_err;
1378
1379 return 0;
1380
1381 char_kobj_err:
1382 kobject_put(sysfs_dev_block_kobj);
1383 block_kobj_err:
1384 kobject_put(dev_kobj);
1385 dev_kobj_err:
1386 kset_unregister(devices_kset);
1387 return -ENOMEM;
1388}
1389
1390static int device_check_offline(struct device *dev, void *not_used)
1391{
1392 int ret;
1393
1394 ret = device_for_each_child(dev, NULL, device_check_offline);
1395 if (ret)
1396 return ret;
1397
1398 return device_supports_offline(dev) && !dev->offline ? -EBUSY : 0;
1399}
1400
1401/**
1402 * device_offline - Prepare the device for hot-removal.
1403 * @dev: Device to be put offline.
1404 *
1405 * Execute the device bus type's .offline() callback, if present, to prepare
1406 * the device for a subsequent hot-removal. If that succeeds, the device must
1407 * not be used until either it is removed or its bus type's .online() callback
1408 * is executed.
1409 *
1410 * Call under device_hotplug_lock.
1411 */
1412int device_offline(struct device *dev)
1413{
1414 int ret;
1415
1416 if (dev->offline_disabled)
1417 return -EPERM;
1418
1419 ret = device_for_each_child(dev, NULL, device_check_offline);
1420 if (ret)
1421 return ret;
1422
1423 device_lock(dev);
1424 if (device_supports_offline(dev)) {
1425 if (dev->offline) {
1426 ret = 1;
1427 } else {
1428 ret = dev->bus->offline(dev);
1429 if (!ret) {
1430 kobject_uevent(&dev->kobj, KOBJ_OFFLINE);
1431 dev->offline = true;
1432 }
1433 }
1434 }
1435 device_unlock(dev);
1436
1437 return ret;
1438}
1439
1440/**
1441 * device_online - Put the device back online after successful device_offline().
1442 * @dev: Device to be put back online.
1443 *
1444 * If device_offline() has been successfully executed for @dev, but the device
1445 * has not been removed subsequently, execute its bus type's .online() callback
1446 * to indicate that the device can be used again.
1447 *
1448 * Call under device_hotplug_lock.
1449 */
1450int device_online(struct device *dev)
1451{
1452 int ret = 0;
1453
1454 device_lock(dev);
1455 if (device_supports_offline(dev)) {
1456 if (dev->offline) {
1457 ret = dev->bus->online(dev);
1458 if (!ret) {
1459 kobject_uevent(&dev->kobj, KOBJ_ONLINE);
1460 dev->offline = false;
1461 }
1462 } else {
1463 ret = 1;
1464 }
1465 }
1466 device_unlock(dev);
1467
1468 return ret;
1469}
1470
1471struct root_device {
1472 struct device dev;
1473 struct module *owner;
1474};
1475
1476static inline struct root_device *to_root_device(struct device *d)
1477{
1478 return container_of(d, struct root_device, dev);
1479}
1480
1481static void root_device_release(struct device *dev)
1482{
1483 kfree(to_root_device(dev));
1484}
1485
1486/**
1487 * __root_device_register - allocate and register a root device
1488 * @name: root device name
1489 * @owner: owner module of the root device, usually THIS_MODULE
1490 *
1491 * This function allocates a root device and registers it
1492 * using device_register(). In order to free the returned
1493 * device, use root_device_unregister().
1494 *
1495 * Root devices are dummy devices which allow other devices
1496 * to be grouped under /sys/devices. Use this function to
1497 * allocate a root device and then use it as the parent of
1498 * any device which should appear under /sys/devices/{name}
1499 *
1500 * The /sys/devices/{name} directory will also contain a
1501 * 'module' symlink which points to the @owner directory
1502 * in sysfs.
1503 *
1504 * Returns &struct device pointer on success, or ERR_PTR() on error.
1505 *
1506 * Note: You probably want to use root_device_register().
1507 */
1508struct device *__root_device_register(const char *name, struct module *owner)
1509{
1510 struct root_device *root;
1511 int err = -ENOMEM;
1512
1513 root = kzalloc(sizeof(struct root_device), GFP_KERNEL);
1514 if (!root)
1515 return ERR_PTR(err);
1516
1517 err = dev_set_name(&root->dev, "%s", name);
1518 if (err) {
1519 kfree(root);
1520 return ERR_PTR(err);
1521 }
1522
1523 root->dev.release = root_device_release;
1524
1525 err = device_register(&root->dev);
1526 if (err) {
1527 put_device(&root->dev);
1528 return ERR_PTR(err);
1529 }
1530
1531#ifdef CONFIG_MODULES /* gotta find a "cleaner" way to do this */
1532 if (owner) {
1533 struct module_kobject *mk = &owner->mkobj;
1534
1535 err = sysfs_create_link(&root->dev.kobj, &mk->kobj, "module");
1536 if (err) {
1537 device_unregister(&root->dev);
1538 return ERR_PTR(err);
1539 }
1540 root->owner = owner;
1541 }
1542#endif
1543
1544 return &root->dev;
1545}
1546EXPORT_SYMBOL_GPL(__root_device_register);
1547
1548/**
1549 * root_device_unregister - unregister and free a root device
1550 * @dev: device going away
1551 *
1552 * This function unregisters and cleans up a device that was created by
1553 * root_device_register().
1554 */
1555void root_device_unregister(struct device *dev)
1556{
1557 struct root_device *root = to_root_device(dev);
1558
1559 if (root->owner)
1560 sysfs_remove_link(&root->dev.kobj, "module");
1561
1562 device_unregister(dev);
1563}
1564EXPORT_SYMBOL_GPL(root_device_unregister);
1565
1566
1567static void device_create_release(struct device *dev)
1568{
1569 pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
1570 kfree(dev);
1571}
1572
1573static struct device *
1574device_create_groups_vargs(struct class *class, struct device *parent,
1575 dev_t devt, void *drvdata,
1576 const struct attribute_group **groups,
1577 const char *fmt, va_list args)
1578{
1579 struct device *dev = NULL;
1580 int retval = -ENODEV;
1581
1582 if (class == NULL || IS_ERR(class))
1583 goto error;
1584
1585 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1586 if (!dev) {
1587 retval = -ENOMEM;
1588 goto error;
1589 }
1590
1591 device_initialize(dev);
1592 dev->devt = devt;
1593 dev->class = class;
1594 dev->parent = parent;
1595 dev->groups = groups;
1596 dev->release = device_create_release;
1597 dev_set_drvdata(dev, drvdata);
1598
1599 retval = kobject_set_name_vargs(&dev->kobj, fmt, args);
1600 if (retval)
1601 goto error;
1602
1603 retval = device_add(dev);
1604 if (retval)
1605 goto error;
1606
1607 return dev;
1608
1609error:
1610 put_device(dev);
1611 return ERR_PTR(retval);
1612}
1613
1614/**
1615 * device_create_vargs - creates a device and registers it with sysfs
1616 * @class: pointer to the struct class that this device should be registered to
1617 * @parent: pointer to the parent struct device of this new device, if any
1618 * @devt: the dev_t for the char device to be added
1619 * @drvdata: the data to be added to the device for callbacks
1620 * @fmt: string for the device's name
1621 * @args: va_list for the device's name
1622 *
1623 * This function can be used by char device classes. A struct device
1624 * will be created in sysfs, registered to the specified class.
1625 *
1626 * A "dev" file will be created, showing the dev_t for the device, if
1627 * the dev_t is not 0,0.
1628 * If a pointer to a parent struct device is passed in, the newly created
1629 * struct device will be a child of that device in sysfs.
1630 * The pointer to the struct device will be returned from the call.
1631 * Any further sysfs files that might be required can be created using this
1632 * pointer.
1633 *
1634 * Returns &struct device pointer on success, or ERR_PTR() on error.
1635 *
1636 * Note: the struct class passed to this function must have previously
1637 * been created with a call to class_create().
1638 */
1639struct device *device_create_vargs(struct class *class, struct device *parent,
1640 dev_t devt, void *drvdata, const char *fmt,
1641 va_list args)
1642{
1643 return device_create_groups_vargs(class, parent, devt, drvdata, NULL,
1644 fmt, args);
1645}
1646EXPORT_SYMBOL_GPL(device_create_vargs);
1647
1648/**
1649 * device_create - creates a device and registers it with sysfs
1650 * @class: pointer to the struct class that this device should be registered to
1651 * @parent: pointer to the parent struct device of this new device, if any
1652 * @devt: the dev_t for the char device to be added
1653 * @drvdata: the data to be added to the device for callbacks
1654 * @fmt: string for the device's name
1655 *
1656 * This function can be used by char device classes. A struct device
1657 * will be created in sysfs, registered to the specified class.
1658 *
1659 * A "dev" file will be created, showing the dev_t for the device, if
1660 * the dev_t is not 0,0.
1661 * If a pointer to a parent struct device is passed in, the newly created
1662 * struct device will be a child of that device in sysfs.
1663 * The pointer to the struct device will be returned from the call.
1664 * Any further sysfs files that might be required can be created using this
1665 * pointer.
1666 *
1667 * Returns &struct device pointer on success, or ERR_PTR() on error.
1668 *
1669 * Note: the struct class passed to this function must have previously
1670 * been created with a call to class_create().
1671 */
1672struct device *device_create(struct class *class, struct device *parent,
1673 dev_t devt, void *drvdata, const char *fmt, ...)
1674{
1675 va_list vargs;
1676 struct device *dev;
1677
1678 va_start(vargs, fmt);
1679 dev = device_create_vargs(class, parent, devt, drvdata, fmt, vargs);
1680 va_end(vargs);
1681 return dev;
1682}
1683EXPORT_SYMBOL_GPL(device_create);
1684
1685/**
1686 * device_create_with_groups - creates a device and registers it with sysfs
1687 * @class: pointer to the struct class that this device should be registered to
1688 * @parent: pointer to the parent struct device of this new device, if any
1689 * @devt: the dev_t for the char device to be added
1690 * @drvdata: the data to be added to the device for callbacks
1691 * @groups: NULL-terminated list of attribute groups to be created
1692 * @fmt: string for the device's name
1693 *
1694 * This function can be used by char device classes. A struct device
1695 * will be created in sysfs, registered to the specified class.
1696 * Additional attributes specified in the groups parameter will also
1697 * be created automatically.
1698 *
1699 * A "dev" file will be created, showing the dev_t for the device, if
1700 * the dev_t is not 0,0.
1701 * If a pointer to a parent struct device is passed in, the newly created
1702 * struct device will be a child of that device in sysfs.
1703 * The pointer to the struct device will be returned from the call.
1704 * Any further sysfs files that might be required can be created using this
1705 * pointer.
1706 *
1707 * Returns &struct device pointer on success, or ERR_PTR() on error.
1708 *
1709 * Note: the struct class passed to this function must have previously
1710 * been created with a call to class_create().
1711 */
1712struct device *device_create_with_groups(struct class *class,
1713 struct device *parent, dev_t devt,
1714 void *drvdata,
1715 const struct attribute_group **groups,
1716 const char *fmt, ...)
1717{
1718 va_list vargs;
1719 struct device *dev;
1720
1721 va_start(vargs, fmt);
1722 dev = device_create_groups_vargs(class, parent, devt, drvdata, groups,
1723 fmt, vargs);
1724 va_end(vargs);
1725 return dev;
1726}
1727EXPORT_SYMBOL_GPL(device_create_with_groups);
1728
1729static int __match_devt(struct device *dev, const void *data)
1730{
1731 const dev_t *devt = data;
1732
1733 return dev->devt == *devt;
1734}
1735
1736/**
1737 * device_destroy - removes a device that was created with device_create()
1738 * @class: pointer to the struct class that this device was registered with
1739 * @devt: the dev_t of the device that was previously registered
1740 *
1741 * This call unregisters and cleans up a device that was created with a
1742 * call to device_create().
1743 */
1744void device_destroy(struct class *class, dev_t devt)
1745{
1746 struct device *dev;
1747
1748 dev = class_find_device(class, NULL, &devt, __match_devt);
1749 if (dev) {
1750 put_device(dev);
1751 device_unregister(dev);
1752 }
1753}
1754EXPORT_SYMBOL_GPL(device_destroy);
1755
1756/**
1757 * device_rename - renames a device
1758 * @dev: the pointer to the struct device to be renamed
1759 * @new_name: the new name of the device
1760 *
1761 * It is the responsibility of the caller to provide mutual
1762 * exclusion between two different calls of device_rename
1763 * on the same device to ensure that new_name is valid and
1764 * won't conflict with other devices.
1765 *
1766 * Note: Don't call this function. Currently, the networking layer calls this
1767 * function, but that will change. The following text from Kay Sievers offers
1768 * some insight:
1769 *
1770 * Renaming devices is racy at many levels, symlinks and other stuff are not
1771 * replaced atomically, and you get a "move" uevent, but it's not easy to
1772 * connect the event to the old and new device. Device nodes are not renamed at
1773 * all, there isn't even support for that in the kernel now.
1774 *
1775 * In the meantime, during renaming, your target name might be taken by another
1776 * driver, creating conflicts. Or the old name is taken directly after you
1777 * renamed it -- then you get events for the same DEVPATH, before you even see
1778 * the "move" event. It's just a mess, and nothing new should ever rely on
1779 * kernel device renaming. Besides that, it's not even implemented now for
1780 * other things than (driver-core wise very simple) network devices.
1781 *
1782 * We are currently about to change network renaming in udev to completely
1783 * disallow renaming of devices in the same namespace as the kernel uses,
1784 * because we can't solve the problems properly, that arise with swapping names
1785 * of multiple interfaces without races. Means, renaming of eth[0-9]* will only
1786 * be allowed to some other name than eth[0-9]*, for the aforementioned
1787 * reasons.
1788 *
1789 * Make up a "real" name in the driver before you register anything, or add
1790 * some other attributes for userspace to find the device, or use udev to add
1791 * symlinks -- but never rename kernel devices later, it's a complete mess. We
1792 * don't even want to get into that and try to implement the missing pieces in
1793 * the core. We really have other pieces to fix in the driver core mess. :)
1794 */
1795int device_rename(struct device *dev, const char *new_name)
1796{
1797 struct kobject *kobj = &dev->kobj;
1798 char *old_device_name = NULL;
1799 int error;
1800
1801 dev = get_device(dev);
1802 if (!dev)
1803 return -EINVAL;
1804
1805 dev_dbg(dev, "renaming to %s\n", new_name);
1806
1807 old_device_name = kstrdup(dev_name(dev), GFP_KERNEL);
1808 if (!old_device_name) {
1809 error = -ENOMEM;
1810 goto out;
1811 }
1812
1813 if (dev->class) {
1814 error = sysfs_rename_link_ns(&dev->class->p->subsys.kobj,
1815 kobj, old_device_name,
1816 new_name, kobject_namespace(kobj));
1817 if (error)
1818 goto out;
1819 }
1820
1821 error = kobject_rename(kobj, new_name);
1822 if (error)
1823 goto out;
1824
1825out:
1826 put_device(dev);
1827
1828 kfree(old_device_name);
1829
1830 return error;
1831}
1832EXPORT_SYMBOL_GPL(device_rename);
1833
1834static int device_move_class_links(struct device *dev,
1835 struct device *old_parent,
1836 struct device *new_parent)
1837{
1838 int error = 0;
1839
1840 if (old_parent)
1841 sysfs_remove_link(&dev->kobj, "device");
1842 if (new_parent)
1843 error = sysfs_create_link(&dev->kobj, &new_parent->kobj,
1844 "device");
1845 return error;
1846}
1847
1848/**
1849 * device_move - moves a device to a new parent
1850 * @dev: the pointer to the struct device to be moved
1851 * @new_parent: the new parent of the device (can by NULL)
1852 * @dpm_order: how to reorder the dpm_list
1853 */
1854int device_move(struct device *dev, struct device *new_parent,
1855 enum dpm_order dpm_order)
1856{
1857 int error;
1858 struct device *old_parent;
1859 struct kobject *new_parent_kobj;
1860
1861 dev = get_device(dev);
1862 if (!dev)
1863 return -EINVAL;
1864
1865 device_pm_lock();
1866 new_parent = get_device(new_parent);
1867 new_parent_kobj = get_device_parent(dev, new_parent);
1868
1869 pr_debug("device: '%s': %s: moving to '%s'\n", dev_name(dev),
1870 __func__, new_parent ? dev_name(new_parent) : "<NULL>");
1871 error = kobject_move(&dev->kobj, new_parent_kobj);
1872 if (error) {
1873 cleanup_glue_dir(dev, new_parent_kobj);
1874 put_device(new_parent);
1875 goto out;
1876 }
1877 old_parent = dev->parent;
1878 dev->parent = new_parent;
1879 if (old_parent)
1880 klist_remove(&dev->p->knode_parent);
1881 if (new_parent) {
1882 klist_add_tail(&dev->p->knode_parent,
1883 &new_parent->p->klist_children);
1884 set_dev_node(dev, dev_to_node(new_parent));
1885 }
1886
1887 if (dev->class) {
1888 error = device_move_class_links(dev, old_parent, new_parent);
1889 if (error) {
1890 /* We ignore errors on cleanup since we're hosed anyway... */
1891 device_move_class_links(dev, new_parent, old_parent);
1892 if (!kobject_move(&dev->kobj, &old_parent->kobj)) {
1893 if (new_parent)
1894 klist_remove(&dev->p->knode_parent);
1895 dev->parent = old_parent;
1896 if (old_parent) {
1897 klist_add_tail(&dev->p->knode_parent,
1898 &old_parent->p->klist_children);
1899 set_dev_node(dev, dev_to_node(old_parent));
1900 }
1901 }
1902 cleanup_glue_dir(dev, new_parent_kobj);
1903 put_device(new_parent);
1904 goto out;
1905 }
1906 }
1907 switch (dpm_order) {
1908 case DPM_ORDER_NONE:
1909 break;
1910 case DPM_ORDER_DEV_AFTER_PARENT:
1911 device_pm_move_after(dev, new_parent);
1912 break;
1913 case DPM_ORDER_PARENT_BEFORE_DEV:
1914 device_pm_move_before(new_parent, dev);
1915 break;
1916 case DPM_ORDER_DEV_LAST:
1917 device_pm_move_last(dev);
1918 break;
1919 }
1920
1921 put_device(old_parent);
1922out:
1923 device_pm_unlock();
1924 put_device(dev);
1925 return error;
1926}
1927EXPORT_SYMBOL_GPL(device_move);
1928
1929/**
1930 * device_shutdown - call ->shutdown() on each device to shutdown.
1931 */
1932void device_shutdown(void)
1933{
1934 struct device *dev, *parent;
1935
1936 spin_lock(&devices_kset->list_lock);
1937 /*
1938 * Walk the devices list backward, shutting down each in turn.
1939 * Beware that device unplug events may also start pulling
1940 * devices offline, even as the system is shutting down.
1941 */
1942 while (!list_empty(&devices_kset->list)) {
1943 dev = list_entry(devices_kset->list.prev, struct device,
1944 kobj.entry);
1945
1946 /*
1947 * hold reference count of device's parent to
1948 * prevent it from being freed because parent's
1949 * lock is to be held
1950 */
1951 parent = get_device(dev->parent);
1952 get_device(dev);
1953 /*
1954 * Make sure the device is off the kset list, in the
1955 * event that dev->*->shutdown() doesn't remove it.
1956 */
1957 list_del_init(&dev->kobj.entry);
1958 spin_unlock(&devices_kset->list_lock);
1959
1960 /* hold lock to avoid race with probe/release */
1961 if (parent)
1962 device_lock(parent);
1963 device_lock(dev);
1964
1965 /* Don't allow any more runtime suspends */
1966 pm_runtime_get_noresume(dev);
1967 pm_runtime_barrier(dev);
1968
1969 if (dev->bus && dev->bus->shutdown) {
1970 if (initcall_debug)
1971 dev_info(dev, "shutdown\n");
1972 dev->bus->shutdown(dev);
1973 } else if (dev->driver && dev->driver->shutdown) {
1974 if (initcall_debug)
1975 dev_info(dev, "shutdown\n");
1976 dev->driver->shutdown(dev);
1977 }
1978
1979 device_unlock(dev);
1980 if (parent)
1981 device_unlock(parent);
1982
1983 put_device(dev);
1984 put_device(parent);
1985
1986 spin_lock(&devices_kset->list_lock);
1987 }
1988 spin_unlock(&devices_kset->list_lock);
1989}
1990
1991/*
1992 * Device logging functions
1993 */
1994
1995#ifdef CONFIG_PRINTK
1996static int
1997create_syslog_header(const struct device *dev, char *hdr, size_t hdrlen)
1998{
1999 const char *subsys;
2000 size_t pos = 0;
2001
2002 if (dev->class)
2003 subsys = dev->class->name;
2004 else if (dev->bus)
2005 subsys = dev->bus->name;
2006 else
2007 return 0;
2008
2009 pos += snprintf(hdr + pos, hdrlen - pos, "SUBSYSTEM=%s", subsys);
2010
2011 /*
2012 * Add device identifier DEVICE=:
2013 * b12:8 block dev_t
2014 * c127:3 char dev_t
2015 * n8 netdev ifindex
2016 * +sound:card0 subsystem:devname
2017 */
2018 if (MAJOR(dev->devt)) {
2019 char c;
2020
2021 if (strcmp(subsys, "block") == 0)
2022 c = 'b';
2023 else
2024 c = 'c';
2025 pos++;
2026 pos += snprintf(hdr + pos, hdrlen - pos,
2027 "DEVICE=%c%u:%u",
2028 c, MAJOR(dev->devt), MINOR(dev->devt));
2029 } else if (strcmp(subsys, "net") == 0) {
2030 struct net_device *net = to_net_dev(dev);
2031
2032 pos++;
2033 pos += snprintf(hdr + pos, hdrlen - pos,
2034 "DEVICE=n%u", net->ifindex);
2035 } else {
2036 pos++;
2037 pos += snprintf(hdr + pos, hdrlen - pos,
2038 "DEVICE=+%s:%s", subsys, dev_name(dev));
2039 }
2040
2041 return pos;
2042}
2043
2044int dev_vprintk_emit(int level, const struct device *dev,
2045 const char *fmt, va_list args)
2046{
2047 char hdr[128];
2048 size_t hdrlen;
2049
2050 hdrlen = create_syslog_header(dev, hdr, sizeof(hdr));
2051
2052 return vprintk_emit(0, level, hdrlen ? hdr : NULL, hdrlen, fmt, args);
2053}
2054EXPORT_SYMBOL(dev_vprintk_emit);
2055
2056int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...)
2057{
2058 va_list args;
2059 int r;
2060
2061 va_start(args, fmt);
2062
2063 r = dev_vprintk_emit(level, dev, fmt, args);
2064
2065 va_end(args);
2066
2067 return r;
2068}
2069EXPORT_SYMBOL(dev_printk_emit);
2070
2071static int __dev_printk(const char *level, const struct device *dev,
2072 struct va_format *vaf)
2073{
2074 if (!dev)
2075 return printk("%s(NULL device *): %pV", level, vaf);
2076
2077 return dev_printk_emit(level[1] - '0', dev,
2078 "%s %s: %pV",
2079 dev_driver_string(dev), dev_name(dev), vaf);
2080}
2081
2082int dev_printk(const char *level, const struct device *dev,
2083 const char *fmt, ...)
2084{
2085 struct va_format vaf;
2086 va_list args;
2087 int r;
2088
2089 va_start(args, fmt);
2090
2091 vaf.fmt = fmt;
2092 vaf.va = &args;
2093
2094 r = __dev_printk(level, dev, &vaf);
2095
2096 va_end(args);
2097
2098 return r;
2099}
2100EXPORT_SYMBOL(dev_printk);
2101
2102#define define_dev_printk_level(func, kern_level) \
2103int func(const struct device *dev, const char *fmt, ...) \
2104{ \
2105 struct va_format vaf; \
2106 va_list args; \
2107 int r; \
2108 \
2109 va_start(args, fmt); \
2110 \
2111 vaf.fmt = fmt; \
2112 vaf.va = &args; \
2113 \
2114 r = __dev_printk(kern_level, dev, &vaf); \
2115 \
2116 va_end(args); \
2117 \
2118 return r; \
2119} \
2120EXPORT_SYMBOL(func);
2121
2122define_dev_printk_level(dev_emerg, KERN_EMERG);
2123define_dev_printk_level(dev_alert, KERN_ALERT);
2124define_dev_printk_level(dev_crit, KERN_CRIT);
2125define_dev_printk_level(dev_err, KERN_ERR);
2126define_dev_printk_level(dev_warn, KERN_WARNING);
2127define_dev_printk_level(dev_notice, KERN_NOTICE);
2128define_dev_printk_level(_dev_info, KERN_INFO);
2129
2130#endif