1
2
3
4
5
6
7
8
9
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/async.h>
27#include <linux/pm_runtime.h>
28#include <linux/netdevice.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 __init int sysfs_deprecated_setup(char *arg)
40{
41 return strict_strtol(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
52#ifdef CONFIG_BLOCK
53static inline int device_is_not_partition(struct device *dev)
54{
55 return !(dev->type == &part_type);
56}
57#else
58static inline int device_is_not_partition(struct device *dev)
59{
60 return 1;
61}
62#endif
63
64
65
66
67
68
69
70
71
72
73const char *dev_driver_string(const struct device *dev)
74{
75 struct device_driver *drv;
76
77
78
79
80
81 drv = ACCESS_ONCE(dev->driver);
82 return drv ? drv->name :
83 (dev->bus ? dev->bus->name :
84 (dev->class ? dev->class->name : ""));
85}
86EXPORT_SYMBOL(dev_driver_string);
87
88#define to_dev_attr(_attr) container_of(_attr, struct device_attribute, attr)
89
90static ssize_t dev_attr_show(struct kobject *kobj, struct attribute *attr,
91 char *buf)
92{
93 struct device_attribute *dev_attr = to_dev_attr(attr);
94 struct device *dev = kobj_to_dev(kobj);
95 ssize_t ret = -EIO;
96
97 if (dev_attr->show)
98 ret = dev_attr->show(dev, dev_attr, buf);
99 if (ret >= (ssize_t)PAGE_SIZE) {
100 print_symbol("dev_attr_show: %s returned bad count\n",
101 (unsigned long)dev_attr->show);
102 }
103 return ret;
104}
105
106static ssize_t dev_attr_store(struct kobject *kobj, struct attribute *attr,
107 const char *buf, size_t count)
108{
109 struct device_attribute *dev_attr = to_dev_attr(attr);
110 struct device *dev = kobj_to_dev(kobj);
111 ssize_t ret = -EIO;
112
113 if (dev_attr->store)
114 ret = dev_attr->store(dev, dev_attr, buf, count);
115 return ret;
116}
117
118static const struct sysfs_ops dev_sysfs_ops = {
119 .show = dev_attr_show,
120 .store = dev_attr_store,
121};
122
123#define to_ext_attr(x) container_of(x, struct dev_ext_attribute, attr)
124
125ssize_t device_store_ulong(struct device *dev,
126 struct device_attribute *attr,
127 const char *buf, size_t size)
128{
129 struct dev_ext_attribute *ea = to_ext_attr(attr);
130 char *end;
131 unsigned long new = simple_strtoul(buf, &end, 0);
132 if (end == buf)
133 return -EINVAL;
134 *(unsigned long *)(ea->var) = new;
135
136 return size;
137}
138EXPORT_SYMBOL_GPL(device_store_ulong);
139
140ssize_t device_show_ulong(struct device *dev,
141 struct device_attribute *attr,
142 char *buf)
143{
144 struct dev_ext_attribute *ea = to_ext_attr(attr);
145 return snprintf(buf, PAGE_SIZE, "%lx\n", *(unsigned long *)(ea->var));
146}
147EXPORT_SYMBOL_GPL(device_show_ulong);
148
149ssize_t device_store_int(struct device *dev,
150 struct device_attribute *attr,
151 const char *buf, size_t size)
152{
153 struct dev_ext_attribute *ea = to_ext_attr(attr);
154 char *end;
155 long new = simple_strtol(buf, &end, 0);
156 if (end == buf || new > INT_MAX || new < INT_MIN)
157 return -EINVAL;
158 *(int *)(ea->var) = new;
159
160 return size;
161}
162EXPORT_SYMBOL_GPL(device_store_int);
163
164ssize_t device_show_int(struct device *dev,
165 struct device_attribute *attr,
166 char *buf)
167{
168 struct dev_ext_attribute *ea = to_ext_attr(attr);
169
170 return snprintf(buf, PAGE_SIZE, "%d\n", *(int *)(ea->var));
171}
172EXPORT_SYMBOL_GPL(device_show_int);
173
174ssize_t device_store_bool(struct device *dev, struct device_attribute *attr,
175 const char *buf, size_t size)
176{
177 struct dev_ext_attribute *ea = to_ext_attr(attr);
178
179 if (strtobool(buf, ea->var) < 0)
180 return -EINVAL;
181
182 return size;
183}
184EXPORT_SYMBOL_GPL(device_store_bool);
185
186ssize_t device_show_bool(struct device *dev, struct device_attribute *attr,
187 char *buf)
188{
189 struct dev_ext_attribute *ea = to_ext_attr(attr);
190
191 return snprintf(buf, PAGE_SIZE, "%d\n", *(bool *)(ea->var));
192}
193EXPORT_SYMBOL_GPL(device_show_bool);
194
195
196
197
198
199
200
201
202
203static void device_release(struct kobject *kobj)
204{
205 struct device *dev = kobj_to_dev(kobj);
206 struct device_private *p = dev->p;
207
208
209
210
211
212
213
214
215
216
217 devres_release_all(dev);
218
219 if (dev->release)
220 dev->release(dev);
221 else if (dev->type && dev->type->release)
222 dev->type->release(dev);
223 else if (dev->class && dev->class->dev_release)
224 dev->class->dev_release(dev);
225 else
226 WARN(1, KERN_ERR "Device '%s' does not have a release() "
227 "function, it is broken and must be fixed.\n",
228 dev_name(dev));
229 kfree(p);
230}
231
232static const void *device_namespace(struct kobject *kobj)
233{
234 struct device *dev = kobj_to_dev(kobj);
235 const void *ns = NULL;
236
237 if (dev->class && dev->class->ns_type)
238 ns = dev->class->namespace(dev);
239
240 return ns;
241}
242
243static struct kobj_type device_ktype = {
244 .release = device_release,
245 .sysfs_ops = &dev_sysfs_ops,
246 .namespace = device_namespace,
247};
248
249
250static int dev_uevent_filter(struct kset *kset, struct kobject *kobj)
251{
252 struct kobj_type *ktype = get_ktype(kobj);
253
254 if (ktype == &device_ktype) {
255 struct device *dev = kobj_to_dev(kobj);
256 if (dev->bus)
257 return 1;
258 if (dev->class)
259 return 1;
260 }
261 return 0;
262}
263
264static const char *dev_uevent_name(struct kset *kset, struct kobject *kobj)
265{
266 struct device *dev = kobj_to_dev(kobj);
267
268 if (dev->bus)
269 return dev->bus->name;
270 if (dev->class)
271 return dev->class->name;
272 return NULL;
273}
274
275static int dev_uevent(struct kset *kset, struct kobject *kobj,
276 struct kobj_uevent_env *env)
277{
278 struct device *dev = kobj_to_dev(kobj);
279 int retval = 0;
280
281
282 if (MAJOR(dev->devt)) {
283 const char *tmp;
284 const char *name;
285 umode_t mode = 0;
286 kuid_t uid = GLOBAL_ROOT_UID;
287 kgid_t gid = GLOBAL_ROOT_GID;
288
289 add_uevent_var(env, "MAJOR=%u", MAJOR(dev->devt));
290 add_uevent_var(env, "MINOR=%u", MINOR(dev->devt));
291 name = device_get_devnode(dev, &mode, &uid, &gid, &tmp);
292 if (name) {
293 add_uevent_var(env, "DEVNAME=%s", name);
294 if (mode)
295 add_uevent_var(env, "DEVMODE=%#o", mode & 0777);
296 if (!uid_eq(uid, GLOBAL_ROOT_UID))
297 add_uevent_var(env, "DEVUID=%u", from_kuid(&init_user_ns, uid));
298 if (!gid_eq(gid, GLOBAL_ROOT_GID))
299 add_uevent_var(env, "DEVGID=%u", from_kgid(&init_user_ns, gid));
300 kfree(tmp);
301 }
302 }
303
304 if (dev->type && dev->type->name)
305 add_uevent_var(env, "DEVTYPE=%s", dev->type->name);
306
307 if (dev->driver)
308 add_uevent_var(env, "DRIVER=%s", dev->driver->name);
309
310
311 of_device_uevent(dev, env);
312
313
314 if (dev->bus && dev->bus->uevent) {
315 retval = dev->bus->uevent(dev, env);
316 if (retval)
317 pr_debug("device: '%s': %s: bus uevent() returned %d\n",
318 dev_name(dev), __func__, retval);
319 }
320
321
322 if (dev->class && dev->class->dev_uevent) {
323 retval = dev->class->dev_uevent(dev, env);
324 if (retval)
325 pr_debug("device: '%s': %s: class uevent() "
326 "returned %d\n", dev_name(dev),
327 __func__, retval);
328 }
329
330
331 if (dev->type && dev->type->uevent) {
332 retval = dev->type->uevent(dev, env);
333 if (retval)
334 pr_debug("device: '%s': %s: dev_type uevent() "
335 "returned %d\n", dev_name(dev),
336 __func__, retval);
337 }
338
339 return retval;
340}
341
342static const struct kset_uevent_ops device_uevent_ops = {
343 .filter = dev_uevent_filter,
344 .name = dev_uevent_name,
345 .uevent = dev_uevent,
346};
347
348static ssize_t show_uevent(struct device *dev, struct device_attribute *attr,
349 char *buf)
350{
351 struct kobject *top_kobj;
352 struct kset *kset;
353 struct kobj_uevent_env *env = NULL;
354 int i;
355 size_t count = 0;
356 int retval;
357
358
359 top_kobj = &dev->kobj;
360 while (!top_kobj->kset && top_kobj->parent)
361 top_kobj = top_kobj->parent;
362 if (!top_kobj->kset)
363 goto out;
364
365 kset = top_kobj->kset;
366 if (!kset->uevent_ops || !kset->uevent_ops->uevent)
367 goto out;
368
369
370 if (kset->uevent_ops && kset->uevent_ops->filter)
371 if (!kset->uevent_ops->filter(kset, &dev->kobj))
372 goto out;
373
374 env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL);
375 if (!env)
376 return -ENOMEM;
377
378
379 retval = kset->uevent_ops->uevent(kset, &dev->kobj, env);
380 if (retval)
381 goto out;
382
383
384 for (i = 0; i < env->envp_idx; i++)
385 count += sprintf(&buf[count], "%s\n", env->envp[i]);
386out:
387 kfree(env);
388 return count;
389}
390
391static ssize_t store_uevent(struct device *dev, struct device_attribute *attr,
392 const char *buf, size_t count)
393{
394 enum kobject_action action;
395
396 if (kobject_action_type(buf, count, &action) == 0)
397 kobject_uevent(&dev->kobj, action);
398 else
399 dev_err(dev, "uevent: unknown action-string\n");
400 return count;
401}
402
403static struct device_attribute uevent_attr =
404 __ATTR(uevent, S_IRUGO | S_IWUSR, show_uevent, store_uevent);
405
406static int device_add_attributes(struct device *dev,
407 struct device_attribute *attrs)
408{
409 int error = 0;
410 int i;
411
412 if (attrs) {
413 for (i = 0; attr_name(attrs[i]); i++) {
414 error = device_create_file(dev, &attrs[i]);
415 if (error)
416 break;
417 }
418 if (error)
419 while (--i >= 0)
420 device_remove_file(dev, &attrs[i]);
421 }
422 return error;
423}
424
425static void device_remove_attributes(struct device *dev,
426 struct device_attribute *attrs)
427{
428 int i;
429
430 if (attrs)
431 for (i = 0; attr_name(attrs[i]); i++)
432 device_remove_file(dev, &attrs[i]);
433}
434
435static int device_add_bin_attributes(struct device *dev,
436 struct bin_attribute *attrs)
437{
438 int error = 0;
439 int i;
440
441 if (attrs) {
442 for (i = 0; attr_name(attrs[i]); i++) {
443 error = device_create_bin_file(dev, &attrs[i]);
444 if (error)
445 break;
446 }
447 if (error)
448 while (--i >= 0)
449 device_remove_bin_file(dev, &attrs[i]);
450 }
451 return error;
452}
453
454static void device_remove_bin_attributes(struct device *dev,
455 struct bin_attribute *attrs)
456{
457 int i;
458
459 if (attrs)
460 for (i = 0; attr_name(attrs[i]); i++)
461 device_remove_bin_file(dev, &attrs[i]);
462}
463
464static int device_add_groups(struct device *dev,
465 const struct attribute_group **groups)
466{
467 int error = 0;
468 int i;
469
470 if (groups) {
471 for (i = 0; groups[i]; i++) {
472 error = sysfs_create_group(&dev->kobj, groups[i]);
473 if (error) {
474 while (--i >= 0)
475 sysfs_remove_group(&dev->kobj,
476 groups[i]);
477 break;
478 }
479 }
480 }
481 return error;
482}
483
484static void device_remove_groups(struct device *dev,
485 const struct attribute_group **groups)
486{
487 int i;
488
489 if (groups)
490 for (i = 0; groups[i]; i++)
491 sysfs_remove_group(&dev->kobj, groups[i]);
492}
493
494static int device_add_attrs(struct device *dev)
495{
496 struct class *class = dev->class;
497 const struct device_type *type = dev->type;
498 int error;
499
500 if (class) {
501 error = device_add_attributes(dev, class->dev_attrs);
502 if (error)
503 return error;
504 error = device_add_bin_attributes(dev, class->dev_bin_attrs);
505 if (error)
506 goto err_remove_class_attrs;
507 }
508
509 if (type) {
510 error = device_add_groups(dev, type->groups);
511 if (error)
512 goto err_remove_class_bin_attrs;
513 }
514
515 error = device_add_groups(dev, dev->groups);
516 if (error)
517 goto err_remove_type_groups;
518
519 return 0;
520
521 err_remove_type_groups:
522 if (type)
523 device_remove_groups(dev, type->groups);
524 err_remove_class_bin_attrs:
525 if (class)
526 device_remove_bin_attributes(dev, class->dev_bin_attrs);
527 err_remove_class_attrs:
528 if (class)
529 device_remove_attributes(dev, class->dev_attrs);
530
531 return error;
532}
533
534static void device_remove_attrs(struct device *dev)
535{
536 struct class *class = dev->class;
537 const struct device_type *type = dev->type;
538
539 device_remove_groups(dev, dev->groups);
540
541 if (type)
542 device_remove_groups(dev, type->groups);
543
544 if (class) {
545 device_remove_attributes(dev, class->dev_attrs);
546 device_remove_bin_attributes(dev, class->dev_bin_attrs);
547 }
548}
549
550
551static ssize_t show_dev(struct device *dev, struct device_attribute *attr,
552 char *buf)
553{
554 return print_dev_t(buf, dev->devt);
555}
556
557static struct device_attribute devt_attr =
558 __ATTR(dev, S_IRUGO, show_dev, NULL);
559
560
561struct kset *devices_kset;
562
563
564
565
566
567
568int device_create_file(struct device *dev,
569 const struct device_attribute *attr)
570{
571 int error = 0;
572
573 if (dev) {
574 WARN(((attr->attr.mode & S_IWUGO) && !attr->store),
575 "Attribute %s: write permission without 'store'\n",
576 attr->attr.name);
577 WARN(((attr->attr.mode & S_IRUGO) && !attr->show),
578 "Attribute %s: read permission without 'show'\n",
579 attr->attr.name);
580 error = sysfs_create_file(&dev->kobj, &attr->attr);
581 }
582
583 return error;
584}
585
586
587
588
589
590
591void device_remove_file(struct device *dev,
592 const struct device_attribute *attr)
593{
594 if (dev)
595 sysfs_remove_file(&dev->kobj, &attr->attr);
596}
597
598
599
600
601
602
603int device_create_bin_file(struct device *dev,
604 const struct bin_attribute *attr)
605{
606 int error = -EINVAL;
607 if (dev)
608 error = sysfs_create_bin_file(&dev->kobj, attr);
609 return error;
610}
611EXPORT_SYMBOL_GPL(device_create_bin_file);
612
613
614
615
616
617
618void device_remove_bin_file(struct device *dev,
619 const struct bin_attribute *attr)
620{
621 if (dev)
622 sysfs_remove_bin_file(&dev->kobj, attr);
623}
624EXPORT_SYMBOL_GPL(device_remove_bin_file);
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651int device_schedule_callback_owner(struct device *dev,
652 void (*func)(struct device *), struct module *owner)
653{
654 return sysfs_schedule_callback(&dev->kobj,
655 (void (*)(void *)) func, dev, owner);
656}
657EXPORT_SYMBOL_GPL(device_schedule_callback_owner);
658
659static void klist_children_get(struct klist_node *n)
660{
661 struct device_private *p = to_device_private_parent(n);
662 struct device *dev = p->device;
663
664 get_device(dev);
665}
666
667static void klist_children_put(struct klist_node *n)
668{
669 struct device_private *p = to_device_private_parent(n);
670 struct device *dev = p->device;
671
672 put_device(dev);
673}
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695void device_initialize(struct device *dev)
696{
697 dev->kobj.kset = devices_kset;
698 kobject_init(&dev->kobj, &device_ktype);
699 INIT_LIST_HEAD(&dev->dma_pools);
700 mutex_init(&dev->mutex);
701 lockdep_set_novalidate_class(&dev->mutex);
702 spin_lock_init(&dev->devres_lock);
703 INIT_LIST_HEAD(&dev->devres_head);
704 device_pm_init(dev);
705 set_dev_node(dev, -1);
706}
707
708struct kobject *virtual_device_parent(struct device *dev)
709{
710 static struct kobject *virtual_dir = NULL;
711
712 if (!virtual_dir)
713 virtual_dir = kobject_create_and_add("virtual",
714 &devices_kset->kobj);
715
716 return virtual_dir;
717}
718
719struct class_dir {
720 struct kobject kobj;
721 struct class *class;
722};
723
724#define to_class_dir(obj) container_of(obj, struct class_dir, kobj)
725
726static void class_dir_release(struct kobject *kobj)
727{
728 struct class_dir *dir = to_class_dir(kobj);
729 kfree(dir);
730}
731
732static const
733struct kobj_ns_type_operations *class_dir_child_ns_type(struct kobject *kobj)
734{
735 struct class_dir *dir = to_class_dir(kobj);
736 return dir->class->ns_type;
737}
738
739static struct kobj_type class_dir_ktype = {
740 .release = class_dir_release,
741 .sysfs_ops = &kobj_sysfs_ops,
742 .child_ns_type = class_dir_child_ns_type
743};
744
745static struct kobject *
746class_dir_create_and_add(struct class *class, struct kobject *parent_kobj)
747{
748 struct class_dir *dir;
749 int retval;
750
751 dir = kzalloc(sizeof(*dir), GFP_KERNEL);
752 if (!dir)
753 return NULL;
754
755 dir->class = class;
756 kobject_init(&dir->kobj, &class_dir_ktype);
757
758 dir->kobj.kset = &class->p->glue_dirs;
759
760 retval = kobject_add(&dir->kobj, parent_kobj, "%s", class->name);
761 if (retval < 0) {
762 kobject_put(&dir->kobj);
763 return NULL;
764 }
765 return &dir->kobj;
766}
767
768
769static struct kobject *get_device_parent(struct device *dev,
770 struct device *parent)
771{
772 if (dev->class) {
773 static DEFINE_MUTEX(gdp_mutex);
774 struct kobject *kobj = NULL;
775 struct kobject *parent_kobj;
776 struct kobject *k;
777
778#ifdef CONFIG_BLOCK
779
780 if (sysfs_deprecated && dev->class == &block_class) {
781 if (parent && parent->class == &block_class)
782 return &parent->kobj;
783 return &block_class.p->subsys.kobj;
784 }
785#endif
786
787
788
789
790
791
792 if (parent == NULL)
793 parent_kobj = virtual_device_parent(dev);
794 else if (parent->class && !dev->class->ns_type)
795 return &parent->kobj;
796 else
797 parent_kobj = &parent->kobj;
798
799 mutex_lock(&gdp_mutex);
800
801
802 spin_lock(&dev->class->p->glue_dirs.list_lock);
803 list_for_each_entry(k, &dev->class->p->glue_dirs.list, entry)
804 if (k->parent == parent_kobj) {
805 kobj = kobject_get(k);
806 break;
807 }
808 spin_unlock(&dev->class->p->glue_dirs.list_lock);
809 if (kobj) {
810 mutex_unlock(&gdp_mutex);
811 return kobj;
812 }
813
814
815 k = class_dir_create_and_add(dev->class, parent_kobj);
816
817 mutex_unlock(&gdp_mutex);
818 return k;
819 }
820
821
822 if (!parent && dev->bus && dev->bus->dev_root)
823 return &dev->bus->dev_root->kobj;
824
825 if (parent)
826 return &parent->kobj;
827 return NULL;
828}
829
830static void cleanup_glue_dir(struct device *dev, struct kobject *glue_dir)
831{
832
833 if (!glue_dir || !dev->class ||
834 glue_dir->kset != &dev->class->p->glue_dirs)
835 return;
836
837 kobject_put(glue_dir);
838}
839
840static void cleanup_device_parent(struct device *dev)
841{
842 cleanup_glue_dir(dev, dev->kobj.parent);
843}
844
845static int device_add_class_symlinks(struct device *dev)
846{
847 int error;
848
849 if (!dev->class)
850 return 0;
851
852 error = sysfs_create_link(&dev->kobj,
853 &dev->class->p->subsys.kobj,
854 "subsystem");
855 if (error)
856 goto out;
857
858 if (dev->parent && device_is_not_partition(dev)) {
859 error = sysfs_create_link(&dev->kobj, &dev->parent->kobj,
860 "device");
861 if (error)
862 goto out_subsys;
863 }
864
865#ifdef CONFIG_BLOCK
866
867 if (sysfs_deprecated && dev->class == &block_class)
868 return 0;
869#endif
870
871
872 error = sysfs_create_link(&dev->class->p->subsys.kobj,
873 &dev->kobj, dev_name(dev));
874 if (error)
875 goto out_device;
876
877 return 0;
878
879out_device:
880 sysfs_remove_link(&dev->kobj, "device");
881
882out_subsys:
883 sysfs_remove_link(&dev->kobj, "subsystem");
884out:
885 return error;
886}
887
888static void device_remove_class_symlinks(struct device *dev)
889{
890 if (!dev->class)
891 return;
892
893 if (dev->parent && device_is_not_partition(dev))
894 sysfs_remove_link(&dev->kobj, "device");
895 sysfs_remove_link(&dev->kobj, "subsystem");
896#ifdef CONFIG_BLOCK
897 if (sysfs_deprecated && dev->class == &block_class)
898 return;
899#endif
900 sysfs_delete_link(&dev->class->p->subsys.kobj, &dev->kobj, dev_name(dev));
901}
902
903
904
905
906
907
908int dev_set_name(struct device *dev, const char *fmt, ...)
909{
910 va_list vargs;
911 int err;
912
913 va_start(vargs, fmt);
914 err = kobject_set_name_vargs(&dev->kobj, fmt, vargs);
915 va_end(vargs);
916 return err;
917}
918EXPORT_SYMBOL_GPL(dev_set_name);
919
920
921
922
923
924
925
926
927
928
929
930
931static struct kobject *device_to_dev_kobj(struct device *dev)
932{
933 struct kobject *kobj;
934
935 if (dev->class)
936 kobj = dev->class->dev_kobj;
937 else
938 kobj = sysfs_dev_char_kobj;
939
940 return kobj;
941}
942
943static int device_create_sys_dev_entry(struct device *dev)
944{
945 struct kobject *kobj = device_to_dev_kobj(dev);
946 int error = 0;
947 char devt_str[15];
948
949 if (kobj) {
950 format_dev_t(devt_str, dev->devt);
951 error = sysfs_create_link(kobj, &dev->kobj, devt_str);
952 }
953
954 return error;
955}
956
957static void device_remove_sys_dev_entry(struct device *dev)
958{
959 struct kobject *kobj = device_to_dev_kobj(dev);
960 char devt_str[15];
961
962 if (kobj) {
963 format_dev_t(devt_str, dev->devt);
964 sysfs_remove_link(kobj, devt_str);
965 }
966}
967
968int device_private_init(struct device *dev)
969{
970 dev->p = kzalloc(sizeof(*dev->p), GFP_KERNEL);
971 if (!dev->p)
972 return -ENOMEM;
973 dev->p->device = dev;
974 klist_init(&dev->p->klist_children, klist_children_get,
975 klist_children_put);
976 INIT_LIST_HEAD(&dev->p->deferred_probe);
977 return 0;
978}
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002int device_add(struct device *dev)
1003{
1004 struct device *parent = NULL;
1005 struct kobject *kobj;
1006 struct class_interface *class_intf;
1007 int error = -EINVAL;
1008
1009 dev = get_device(dev);
1010 if (!dev)
1011 goto done;
1012
1013 if (!dev->p) {
1014 error = device_private_init(dev);
1015 if (error)
1016 goto done;
1017 }
1018
1019
1020
1021
1022
1023
1024 if (dev->init_name) {
1025 dev_set_name(dev, "%s", dev->init_name);
1026 dev->init_name = NULL;
1027 }
1028
1029
1030 if (!dev_name(dev) && dev->bus && dev->bus->dev_name)
1031 dev_set_name(dev, "%s%u", dev->bus->dev_name, dev->id);
1032
1033 if (!dev_name(dev)) {
1034 error = -EINVAL;
1035 goto name_error;
1036 }
1037
1038 pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
1039
1040 parent = get_device(dev->parent);
1041 kobj = get_device_parent(dev, parent);
1042 if (kobj)
1043 dev->kobj.parent = kobj;
1044
1045
1046 if (parent)
1047 set_dev_node(dev, dev_to_node(parent));
1048
1049
1050
1051 error = kobject_add(&dev->kobj, dev->kobj.parent, NULL);
1052 if (error)
1053 goto Error;
1054
1055
1056 if (platform_notify)
1057 platform_notify(dev);
1058
1059 error = device_create_file(dev, &uevent_attr);
1060 if (error)
1061 goto attrError;
1062
1063 if (MAJOR(dev->devt)) {
1064 error = device_create_file(dev, &devt_attr);
1065 if (error)
1066 goto ueventattrError;
1067
1068 error = device_create_sys_dev_entry(dev);
1069 if (error)
1070 goto devtattrError;
1071
1072 devtmpfs_create_node(dev);
1073 }
1074
1075 error = device_add_class_symlinks(dev);
1076 if (error)
1077 goto SymlinkError;
1078 error = device_add_attrs(dev);
1079 if (error)
1080 goto AttrsError;
1081 error = bus_add_device(dev);
1082 if (error)
1083 goto BusError;
1084 error = dpm_sysfs_add(dev);
1085 if (error)
1086 goto DPMError;
1087 device_pm_add(dev);
1088
1089
1090
1091
1092 if (dev->bus)
1093 blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
1094 BUS_NOTIFY_ADD_DEVICE, dev);
1095
1096 kobject_uevent(&dev->kobj, KOBJ_ADD);
1097 bus_probe_device(dev);
1098 if (parent)
1099 klist_add_tail(&dev->p->knode_parent,
1100 &parent->p->klist_children);
1101
1102 if (dev->class) {
1103 mutex_lock(&dev->class->p->mutex);
1104
1105 klist_add_tail(&dev->knode_class,
1106 &dev->class->p->klist_devices);
1107
1108
1109 list_for_each_entry(class_intf,
1110 &dev->class->p->interfaces, node)
1111 if (class_intf->add_dev)
1112 class_intf->add_dev(dev, class_intf);
1113 mutex_unlock(&dev->class->p->mutex);
1114 }
1115done:
1116 put_device(dev);
1117 return error;
1118 DPMError:
1119 bus_remove_device(dev);
1120 BusError:
1121 device_remove_attrs(dev);
1122 AttrsError:
1123 device_remove_class_symlinks(dev);
1124 SymlinkError:
1125 if (MAJOR(dev->devt))
1126 devtmpfs_delete_node(dev);
1127 if (MAJOR(dev->devt))
1128 device_remove_sys_dev_entry(dev);
1129 devtattrError:
1130 if (MAJOR(dev->devt))
1131 device_remove_file(dev, &devt_attr);
1132 ueventattrError:
1133 device_remove_file(dev, &uevent_attr);
1134 attrError:
1135 kobject_uevent(&dev->kobj, KOBJ_REMOVE);
1136 kobject_del(&dev->kobj);
1137 Error:
1138 cleanup_device_parent(dev);
1139 if (parent)
1140 put_device(parent);
1141name_error:
1142 kfree(dev->p);
1143 dev->p = NULL;
1144 goto done;
1145}
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165int device_register(struct device *dev)
1166{
1167 device_initialize(dev);
1168 return device_add(dev);
1169}
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179struct device *get_device(struct device *dev)
1180{
1181 return dev ? kobj_to_dev(kobject_get(&dev->kobj)) : NULL;
1182}
1183
1184
1185
1186
1187
1188void put_device(struct device *dev)
1189{
1190
1191 if (dev)
1192 kobject_put(&dev->kobj);
1193}
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208void device_del(struct device *dev)
1209{
1210 struct device *parent = dev->parent;
1211 struct class_interface *class_intf;
1212
1213
1214
1215
1216 if (dev->bus)
1217 blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
1218 BUS_NOTIFY_DEL_DEVICE, dev);
1219 dpm_sysfs_remove(dev);
1220 if (parent)
1221 klist_del(&dev->p->knode_parent);
1222 if (MAJOR(dev->devt)) {
1223 devtmpfs_delete_node(dev);
1224 device_remove_sys_dev_entry(dev);
1225 device_remove_file(dev, &devt_attr);
1226 }
1227 if (dev->class) {
1228 device_remove_class_symlinks(dev);
1229
1230 mutex_lock(&dev->class->p->mutex);
1231
1232 list_for_each_entry(class_intf,
1233 &dev->class->p->interfaces, node)
1234 if (class_intf->remove_dev)
1235 class_intf->remove_dev(dev, class_intf);
1236
1237 klist_del(&dev->knode_class);
1238 mutex_unlock(&dev->class->p->mutex);
1239 }
1240 device_remove_file(dev, &uevent_attr);
1241 device_remove_attrs(dev);
1242 bus_remove_device(dev);
1243 device_pm_remove(dev);
1244 driver_deferred_probe_del(dev);
1245
1246
1247
1248
1249 if (platform_notify_remove)
1250 platform_notify_remove(dev);
1251 kobject_uevent(&dev->kobj, KOBJ_REMOVE);
1252 cleanup_device_parent(dev);
1253 kobject_del(&dev->kobj);
1254 put_device(parent);
1255}
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268void device_unregister(struct device *dev)
1269{
1270 pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
1271 device_del(dev);
1272 put_device(dev);
1273}
1274
1275static struct device *next_device(struct klist_iter *i)
1276{
1277 struct klist_node *n = klist_next(i);
1278 struct device *dev = NULL;
1279 struct device_private *p;
1280
1281 if (n) {
1282 p = to_device_private_parent(n);
1283 dev = p->device;
1284 }
1285 return dev;
1286}
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301const char *device_get_devnode(struct device *dev,
1302 umode_t *mode, kuid_t *uid, kgid_t *gid,
1303 const char **tmp)
1304{
1305 char *s;
1306
1307 *tmp = NULL;
1308
1309
1310 if (dev->type && dev->type->devnode)
1311 *tmp = dev->type->devnode(dev, mode, uid, gid);
1312 if (*tmp)
1313 return *tmp;
1314
1315
1316 if (dev->class && dev->class->devnode)
1317 *tmp = dev->class->devnode(dev, mode);
1318 if (*tmp)
1319 return *tmp;
1320
1321
1322 if (strchr(dev_name(dev), '!') == NULL)
1323 return dev_name(dev);
1324
1325
1326 *tmp = kstrdup(dev_name(dev), GFP_KERNEL);
1327 if (!*tmp)
1328 return NULL;
1329 while ((s = strchr(*tmp, '!')))
1330 s[0] = '/';
1331 return *tmp;
1332}
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346int device_for_each_child(struct device *parent, void *data,
1347 int (*fn)(struct device *dev, void *data))
1348{
1349 struct klist_iter i;
1350 struct device *child;
1351 int error = 0;
1352
1353 if (!parent->p)
1354 return 0;
1355
1356 klist_iter_init(&parent->p->klist_children, &i);
1357 while ((child = next_device(&i)) && !error)
1358 error = fn(child, data);
1359 klist_iter_exit(&i);
1360 return error;
1361}
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378struct device *device_find_child(struct device *parent, void *data,
1379 int (*match)(struct device *dev, void *data))
1380{
1381 struct klist_iter i;
1382 struct device *child;
1383
1384 if (!parent)
1385 return NULL;
1386
1387 klist_iter_init(&parent->p->klist_children, &i);
1388 while ((child = next_device(&i)))
1389 if (match(child, data) && get_device(child))
1390 break;
1391 klist_iter_exit(&i);
1392 return child;
1393}
1394
1395int __init devices_init(void)
1396{
1397 devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL);
1398 if (!devices_kset)
1399 return -ENOMEM;
1400 dev_kobj = kobject_create_and_add("dev", NULL);
1401 if (!dev_kobj)
1402 goto dev_kobj_err;
1403 sysfs_dev_block_kobj = kobject_create_and_add("block", dev_kobj);
1404 if (!sysfs_dev_block_kobj)
1405 goto block_kobj_err;
1406 sysfs_dev_char_kobj = kobject_create_and_add("char", dev_kobj);
1407 if (!sysfs_dev_char_kobj)
1408 goto char_kobj_err;
1409
1410 return 0;
1411
1412 char_kobj_err:
1413 kobject_put(sysfs_dev_block_kobj);
1414 block_kobj_err:
1415 kobject_put(dev_kobj);
1416 dev_kobj_err:
1417 kset_unregister(devices_kset);
1418 return -ENOMEM;
1419}
1420
1421EXPORT_SYMBOL_GPL(device_for_each_child);
1422EXPORT_SYMBOL_GPL(device_find_child);
1423
1424EXPORT_SYMBOL_GPL(device_initialize);
1425EXPORT_SYMBOL_GPL(device_add);
1426EXPORT_SYMBOL_GPL(device_register);
1427
1428EXPORT_SYMBOL_GPL(device_del);
1429EXPORT_SYMBOL_GPL(device_unregister);
1430EXPORT_SYMBOL_GPL(get_device);
1431EXPORT_SYMBOL_GPL(put_device);
1432
1433EXPORT_SYMBOL_GPL(device_create_file);
1434EXPORT_SYMBOL_GPL(device_remove_file);
1435
1436struct root_device {
1437 struct device dev;
1438 struct module *owner;
1439};
1440
1441static inline struct root_device *to_root_device(struct device *d)
1442{
1443 return container_of(d, struct root_device, dev);
1444}
1445
1446static void root_device_release(struct device *dev)
1447{
1448 kfree(to_root_device(dev));
1449}
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473struct device *__root_device_register(const char *name, struct module *owner)
1474{
1475 struct root_device *root;
1476 int err = -ENOMEM;
1477
1478 root = kzalloc(sizeof(struct root_device), GFP_KERNEL);
1479 if (!root)
1480 return ERR_PTR(err);
1481
1482 err = dev_set_name(&root->dev, "%s", name);
1483 if (err) {
1484 kfree(root);
1485 return ERR_PTR(err);
1486 }
1487
1488 root->dev.release = root_device_release;
1489
1490 err = device_register(&root->dev);
1491 if (err) {
1492 put_device(&root->dev);
1493 return ERR_PTR(err);
1494 }
1495
1496#ifdef CONFIG_MODULES
1497 if (owner) {
1498 struct module_kobject *mk = &owner->mkobj;
1499
1500 err = sysfs_create_link(&root->dev.kobj, &mk->kobj, "module");
1501 if (err) {
1502 device_unregister(&root->dev);
1503 return ERR_PTR(err);
1504 }
1505 root->owner = owner;
1506 }
1507#endif
1508
1509 return &root->dev;
1510}
1511EXPORT_SYMBOL_GPL(__root_device_register);
1512
1513
1514
1515
1516
1517
1518
1519
1520void root_device_unregister(struct device *dev)
1521{
1522 struct root_device *root = to_root_device(dev);
1523
1524 if (root->owner)
1525 sysfs_remove_link(&root->dev.kobj, "module");
1526
1527 device_unregister(dev);
1528}
1529EXPORT_SYMBOL_GPL(root_device_unregister);
1530
1531
1532static void device_create_release(struct device *dev)
1533{
1534 pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
1535 kfree(dev);
1536}
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563struct device *device_create_vargs(struct class *class, struct device *parent,
1564 dev_t devt, void *drvdata, const char *fmt,
1565 va_list args)
1566{
1567 struct device *dev = NULL;
1568 int retval = -ENODEV;
1569
1570 if (class == NULL || IS_ERR(class))
1571 goto error;
1572
1573 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1574 if (!dev) {
1575 retval = -ENOMEM;
1576 goto error;
1577 }
1578
1579 dev->devt = devt;
1580 dev->class = class;
1581 dev->parent = parent;
1582 dev->release = device_create_release;
1583 dev_set_drvdata(dev, drvdata);
1584
1585 retval = kobject_set_name_vargs(&dev->kobj, fmt, args);
1586 if (retval)
1587 goto error;
1588
1589 retval = device_register(dev);
1590 if (retval)
1591 goto error;
1592
1593 return dev;
1594
1595error:
1596 put_device(dev);
1597 return ERR_PTR(retval);
1598}
1599EXPORT_SYMBOL_GPL(device_create_vargs);
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625struct device *device_create(struct class *class, struct device *parent,
1626 dev_t devt, void *drvdata, const char *fmt, ...)
1627{
1628 va_list vargs;
1629 struct device *dev;
1630
1631 va_start(vargs, fmt);
1632 dev = device_create_vargs(class, parent, devt, drvdata, fmt, vargs);
1633 va_end(vargs);
1634 return dev;
1635}
1636EXPORT_SYMBOL_GPL(device_create);
1637
1638static int __match_devt(struct device *dev, const void *data)
1639{
1640 const dev_t *devt = data;
1641
1642 return dev->devt == *devt;
1643}
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653void device_destroy(struct class *class, dev_t devt)
1654{
1655 struct device *dev;
1656
1657 dev = class_find_device(class, NULL, &devt, __match_devt);
1658 if (dev) {
1659 put_device(dev);
1660 device_unregister(dev);
1661 }
1662}
1663EXPORT_SYMBOL_GPL(device_destroy);
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704int device_rename(struct device *dev, const char *new_name)
1705{
1706 char *old_device_name = NULL;
1707 int error;
1708
1709 dev = get_device(dev);
1710 if (!dev)
1711 return -EINVAL;
1712
1713 pr_debug("device: '%s': %s: renaming to '%s'\n", dev_name(dev),
1714 __func__, new_name);
1715
1716 old_device_name = kstrdup(dev_name(dev), GFP_KERNEL);
1717 if (!old_device_name) {
1718 error = -ENOMEM;
1719 goto out;
1720 }
1721
1722 if (dev->class) {
1723 error = sysfs_rename_link(&dev->class->p->subsys.kobj,
1724 &dev->kobj, old_device_name, new_name);
1725 if (error)
1726 goto out;
1727 }
1728
1729 error = kobject_rename(&dev->kobj, new_name);
1730 if (error)
1731 goto out;
1732
1733out:
1734 put_device(dev);
1735
1736 kfree(old_device_name);
1737
1738 return error;
1739}
1740EXPORT_SYMBOL_GPL(device_rename);
1741
1742static int device_move_class_links(struct device *dev,
1743 struct device *old_parent,
1744 struct device *new_parent)
1745{
1746 int error = 0;
1747
1748 if (old_parent)
1749 sysfs_remove_link(&dev->kobj, "device");
1750 if (new_parent)
1751 error = sysfs_create_link(&dev->kobj, &new_parent->kobj,
1752 "device");
1753 return error;
1754}
1755
1756
1757
1758
1759
1760
1761
1762int device_move(struct device *dev, struct device *new_parent,
1763 enum dpm_order dpm_order)
1764{
1765 int error;
1766 struct device *old_parent;
1767 struct kobject *new_parent_kobj;
1768
1769 dev = get_device(dev);
1770 if (!dev)
1771 return -EINVAL;
1772
1773 device_pm_lock();
1774 new_parent = get_device(new_parent);
1775 new_parent_kobj = get_device_parent(dev, new_parent);
1776
1777 pr_debug("device: '%s': %s: moving to '%s'\n", dev_name(dev),
1778 __func__, new_parent ? dev_name(new_parent) : "<NULL>");
1779 error = kobject_move(&dev->kobj, new_parent_kobj);
1780 if (error) {
1781 cleanup_glue_dir(dev, new_parent_kobj);
1782 put_device(new_parent);
1783 goto out;
1784 }
1785 old_parent = dev->parent;
1786 dev->parent = new_parent;
1787 if (old_parent)
1788 klist_remove(&dev->p->knode_parent);
1789 if (new_parent) {
1790 klist_add_tail(&dev->p->knode_parent,
1791 &new_parent->p->klist_children);
1792 set_dev_node(dev, dev_to_node(new_parent));
1793 }
1794
1795 if (dev->class) {
1796 error = device_move_class_links(dev, old_parent, new_parent);
1797 if (error) {
1798
1799 device_move_class_links(dev, new_parent, old_parent);
1800 if (!kobject_move(&dev->kobj, &old_parent->kobj)) {
1801 if (new_parent)
1802 klist_remove(&dev->p->knode_parent);
1803 dev->parent = old_parent;
1804 if (old_parent) {
1805 klist_add_tail(&dev->p->knode_parent,
1806 &old_parent->p->klist_children);
1807 set_dev_node(dev, dev_to_node(old_parent));
1808 }
1809 }
1810 cleanup_glue_dir(dev, new_parent_kobj);
1811 put_device(new_parent);
1812 goto out;
1813 }
1814 }
1815 switch (dpm_order) {
1816 case DPM_ORDER_NONE:
1817 break;
1818 case DPM_ORDER_DEV_AFTER_PARENT:
1819 device_pm_move_after(dev, new_parent);
1820 break;
1821 case DPM_ORDER_PARENT_BEFORE_DEV:
1822 device_pm_move_before(new_parent, dev);
1823 break;
1824 case DPM_ORDER_DEV_LAST:
1825 device_pm_move_last(dev);
1826 break;
1827 }
1828
1829 put_device(old_parent);
1830out:
1831 device_pm_unlock();
1832 put_device(dev);
1833 return error;
1834}
1835EXPORT_SYMBOL_GPL(device_move);
1836
1837
1838
1839
1840void device_shutdown(void)
1841{
1842 struct device *dev;
1843
1844 spin_lock(&devices_kset->list_lock);
1845
1846
1847
1848
1849
1850 while (!list_empty(&devices_kset->list)) {
1851 dev = list_entry(devices_kset->list.prev, struct device,
1852 kobj.entry);
1853
1854
1855
1856
1857
1858
1859 get_device(dev->parent);
1860 get_device(dev);
1861
1862
1863
1864
1865 list_del_init(&dev->kobj.entry);
1866 spin_unlock(&devices_kset->list_lock);
1867
1868
1869 if (dev->parent)
1870 device_lock(dev->parent);
1871 device_lock(dev);
1872
1873
1874 pm_runtime_get_noresume(dev);
1875 pm_runtime_barrier(dev);
1876
1877 if (dev->bus && dev->bus->shutdown) {
1878 if (initcall_debug)
1879 dev_info(dev, "shutdown\n");
1880 dev->bus->shutdown(dev);
1881 } else if (dev->driver && dev->driver->shutdown) {
1882 if (initcall_debug)
1883 dev_info(dev, "shutdown\n");
1884 dev->driver->shutdown(dev);
1885 }
1886
1887 device_unlock(dev);
1888 if (dev->parent)
1889 device_unlock(dev->parent);
1890
1891 put_device(dev);
1892 put_device(dev->parent);
1893
1894 spin_lock(&devices_kset->list_lock);
1895 }
1896 spin_unlock(&devices_kset->list_lock);
1897 async_synchronize_full();
1898}
1899
1900
1901
1902
1903
1904#ifdef CONFIG_PRINTK
1905static int
1906create_syslog_header(const struct device *dev, char *hdr, size_t hdrlen)
1907{
1908 const char *subsys;
1909 size_t pos = 0;
1910
1911 if (dev->class)
1912 subsys = dev->class->name;
1913 else if (dev->bus)
1914 subsys = dev->bus->name;
1915 else
1916 return 0;
1917
1918 pos += snprintf(hdr + pos, hdrlen - pos, "SUBSYSTEM=%s", subsys);
1919
1920
1921
1922
1923
1924
1925
1926
1927 if (MAJOR(dev->devt)) {
1928 char c;
1929
1930 if (strcmp(subsys, "block") == 0)
1931 c = 'b';
1932 else
1933 c = 'c';
1934 pos++;
1935 pos += snprintf(hdr + pos, hdrlen - pos,
1936 "DEVICE=%c%u:%u",
1937 c, MAJOR(dev->devt), MINOR(dev->devt));
1938 } else if (strcmp(subsys, "net") == 0) {
1939 struct net_device *net = to_net_dev(dev);
1940
1941 pos++;
1942 pos += snprintf(hdr + pos, hdrlen - pos,
1943 "DEVICE=n%u", net->ifindex);
1944 } else {
1945 pos++;
1946 pos += snprintf(hdr + pos, hdrlen - pos,
1947 "DEVICE=+%s:%s", subsys, dev_name(dev));
1948 }
1949
1950 return pos;
1951}
1952EXPORT_SYMBOL(create_syslog_header);
1953
1954int dev_vprintk_emit(int level, const struct device *dev,
1955 const char *fmt, va_list args)
1956{
1957 char hdr[128];
1958 size_t hdrlen;
1959
1960 hdrlen = create_syslog_header(dev, hdr, sizeof(hdr));
1961
1962 return vprintk_emit(0, level, hdrlen ? hdr : NULL, hdrlen, fmt, args);
1963}
1964EXPORT_SYMBOL(dev_vprintk_emit);
1965
1966int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...)
1967{
1968 va_list args;
1969 int r;
1970
1971 va_start(args, fmt);
1972
1973 r = dev_vprintk_emit(level, dev, fmt, args);
1974
1975 va_end(args);
1976
1977 return r;
1978}
1979EXPORT_SYMBOL(dev_printk_emit);
1980
1981static int __dev_printk(const char *level, const struct device *dev,
1982 struct va_format *vaf)
1983{
1984 if (!dev)
1985 return printk("%s(NULL device *): %pV", level, vaf);
1986
1987 return dev_printk_emit(level[1] - '0', dev,
1988 "%s %s: %pV",
1989 dev_driver_string(dev), dev_name(dev), vaf);
1990}
1991
1992int dev_printk(const char *level, const struct device *dev,
1993 const char *fmt, ...)
1994{
1995 struct va_format vaf;
1996 va_list args;
1997 int r;
1998
1999 va_start(args, fmt);
2000
2001 vaf.fmt = fmt;
2002 vaf.va = &args;
2003
2004 r = __dev_printk(level, dev, &vaf);
2005
2006 va_end(args);
2007
2008 return r;
2009}
2010EXPORT_SYMBOL(dev_printk);
2011
2012#define define_dev_printk_level(func, kern_level) \
2013int func(const struct device *dev, const char *fmt, ...) \
2014{ \
2015 struct va_format vaf; \
2016 va_list args; \
2017 int r; \
2018 \
2019 va_start(args, fmt); \
2020 \
2021 vaf.fmt = fmt; \
2022 vaf.va = &args; \
2023 \
2024 r = __dev_printk(kern_level, dev, &vaf); \
2025 \
2026 va_end(args); \
2027 \
2028 return r; \
2029} \
2030EXPORT_SYMBOL(func);
2031
2032define_dev_printk_level(dev_emerg, KERN_EMERG);
2033define_dev_printk_level(dev_alert, KERN_ALERT);
2034define_dev_printk_level(dev_crit, KERN_CRIT);
2035define_dev_printk_level(dev_err, KERN_ERR);
2036define_dev_printk_level(dev_warn, KERN_WARNING);
2037define_dev_printk_level(dev_notice, KERN_NOTICE);
2038define_dev_printk_level(_dev_info, KERN_INFO);
2039
2040#endif
2041