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/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
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
88
89
90
91
92
93
94
95const char *dev_driver_string(const struct device *dev)
96{
97 struct device_driver *drv;
98
99
100
101
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
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
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
219
220
221
222
223
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
232
233
234
235
236
237
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
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
333 of_device_uevent(dev, env);
334
335
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
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
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
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
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
401 retval = kset->uevent_ops->uevent(kset, &dev->kobj, env);
402 if (retval)
403 goto out;
404
405
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
533struct kset *devices_kset;
534
535
536
537
538
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
561
562
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
574
575
576
577
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
591
592
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
606
607
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
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
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
727static DEFINE_MUTEX(gdp_mutex);
728
729static struct kobject *get_device_parent(struct device *dev,
730 struct device *parent)
731{
732 if (dev->class) {
733 struct kobject *kobj = NULL;
734 struct kobject *parent_kobj;
735 struct kobject *k;
736
737#ifdef CONFIG_BLOCK
738
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
748
749
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
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
774 k = class_dir_create_and_add(dev->class, parent_kobj);
775
776 mutex_unlock(&gdp_mutex);
777 return k;
778 }
779
780
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
792 if (!glue_dir || !dev->class ||
793 glue_dir->kset != &dev->class->p->glue_dirs)
794 return;
795
796 mutex_lock(&gdp_mutex);
797 kobject_put(glue_dir);
798 mutex_unlock(&gdp_mutex);
799}
800
801static void cleanup_device_parent(struct device *dev)
802{
803 cleanup_glue_dir(dev, dev->kobj.parent);
804}
805
806static int device_add_class_symlinks(struct device *dev)
807{
808 int error;
809
810 if (!dev->class)
811 return 0;
812
813 error = sysfs_create_link(&dev->kobj,
814 &dev->class->p->subsys.kobj,
815 "subsystem");
816 if (error)
817 goto out;
818
819 if (dev->parent && device_is_not_partition(dev)) {
820 error = sysfs_create_link(&dev->kobj, &dev->parent->kobj,
821 "device");
822 if (error)
823 goto out_subsys;
824 }
825
826#ifdef CONFIG_BLOCK
827
828 if (sysfs_deprecated && dev->class == &block_class)
829 return 0;
830#endif
831
832
833 error = sysfs_create_link(&dev->class->p->subsys.kobj,
834 &dev->kobj, dev_name(dev));
835 if (error)
836 goto out_device;
837
838 return 0;
839
840out_device:
841 sysfs_remove_link(&dev->kobj, "device");
842
843out_subsys:
844 sysfs_remove_link(&dev->kobj, "subsystem");
845out:
846 return error;
847}
848
849static void device_remove_class_symlinks(struct device *dev)
850{
851 if (!dev->class)
852 return;
853
854 if (dev->parent && device_is_not_partition(dev))
855 sysfs_remove_link(&dev->kobj, "device");
856 sysfs_remove_link(&dev->kobj, "subsystem");
857#ifdef CONFIG_BLOCK
858 if (sysfs_deprecated && dev->class == &block_class)
859 return;
860#endif
861 sysfs_delete_link(&dev->class->p->subsys.kobj, &dev->kobj, dev_name(dev));
862}
863
864
865
866
867
868
869int dev_set_name(struct device *dev, const char *fmt, ...)
870{
871 va_list vargs;
872 int err;
873
874 va_start(vargs, fmt);
875 err = kobject_set_name_vargs(&dev->kobj, fmt, vargs);
876 va_end(vargs);
877 return err;
878}
879EXPORT_SYMBOL_GPL(dev_set_name);
880
881
882
883
884
885
886
887
888
889
890
891
892static struct kobject *device_to_dev_kobj(struct device *dev)
893{
894 struct kobject *kobj;
895
896 if (dev->class)
897 kobj = dev->class->dev_kobj;
898 else
899 kobj = sysfs_dev_char_kobj;
900
901 return kobj;
902}
903
904static int device_create_sys_dev_entry(struct device *dev)
905{
906 struct kobject *kobj = device_to_dev_kobj(dev);
907 int error = 0;
908 char devt_str[15];
909
910 if (kobj) {
911 format_dev_t(devt_str, dev->devt);
912 error = sysfs_create_link(kobj, &dev->kobj, devt_str);
913 }
914
915 return error;
916}
917
918static void device_remove_sys_dev_entry(struct device *dev)
919{
920 struct kobject *kobj = device_to_dev_kobj(dev);
921 char devt_str[15];
922
923 if (kobj) {
924 format_dev_t(devt_str, dev->devt);
925 sysfs_remove_link(kobj, devt_str);
926 }
927}
928
929int device_private_init(struct device *dev)
930{
931 dev->p = kzalloc(sizeof(*dev->p), GFP_KERNEL);
932 if (!dev->p)
933 return -ENOMEM;
934 dev->p->device = dev;
935 klist_init(&dev->p->klist_children, klist_children_get,
936 klist_children_put);
937 INIT_LIST_HEAD(&dev->p->deferred_probe);
938 return 0;
939}
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963int device_add(struct device *dev)
964{
965 struct device *parent = NULL;
966 struct kobject *kobj;
967 struct class_interface *class_intf;
968 int error = -EINVAL;
969
970 dev = get_device(dev);
971 if (!dev)
972 goto done;
973
974 if (!dev->p) {
975 error = device_private_init(dev);
976 if (error)
977 goto done;
978 }
979
980
981
982
983
984
985 if (dev->init_name) {
986 dev_set_name(dev, "%s", dev->init_name);
987 dev->init_name = NULL;
988 }
989
990
991 if (!dev_name(dev) && dev->bus && dev->bus->dev_name)
992 dev_set_name(dev, "%s%u", dev->bus->dev_name, dev->id);
993
994 if (!dev_name(dev)) {
995 error = -EINVAL;
996 goto name_error;
997 }
998
999 pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
1000
1001 parent = get_device(dev->parent);
1002 kobj = get_device_parent(dev, parent);
1003 if (kobj)
1004 dev->kobj.parent = kobj;
1005
1006
1007 if (parent)
1008 set_dev_node(dev, dev_to_node(parent));
1009
1010
1011
1012 error = kobject_add(&dev->kobj, dev->kobj.parent, NULL);
1013 if (error)
1014 goto Error;
1015
1016
1017 if (platform_notify)
1018 platform_notify(dev);
1019
1020 error = device_create_file(dev, &dev_attr_uevent);
1021 if (error)
1022 goto attrError;
1023
1024 error = device_add_class_symlinks(dev);
1025 if (error)
1026 goto SymlinkError;
1027 error = device_add_attrs(dev);
1028 if (error)
1029 goto AttrsError;
1030 error = bus_add_device(dev);
1031 if (error)
1032 goto BusError;
1033 error = dpm_sysfs_add(dev);
1034 if (error)
1035 goto DPMError;
1036 device_pm_add(dev);
1037
1038 if (MAJOR(dev->devt)) {
1039 error = device_create_file(dev, &dev_attr_dev);
1040 if (error)
1041 goto DevAttrError;
1042
1043 error = device_create_sys_dev_entry(dev);
1044 if (error)
1045 goto SysEntryError;
1046
1047 devtmpfs_create_node(dev);
1048 }
1049
1050
1051
1052
1053 if (dev->bus)
1054 blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
1055 BUS_NOTIFY_ADD_DEVICE, dev);
1056
1057 kobject_uevent(&dev->kobj, KOBJ_ADD);
1058 bus_probe_device(dev);
1059 if (parent)
1060 klist_add_tail(&dev->p->knode_parent,
1061 &parent->p->klist_children);
1062
1063 if (dev->class) {
1064 mutex_lock(&dev->class->p->mutex);
1065
1066 klist_add_tail(&dev->knode_class,
1067 &dev->class->p->klist_devices);
1068
1069
1070 list_for_each_entry(class_intf,
1071 &dev->class->p->interfaces, node)
1072 if (class_intf->add_dev)
1073 class_intf->add_dev(dev, class_intf);
1074 mutex_unlock(&dev->class->p->mutex);
1075 }
1076done:
1077 put_device(dev);
1078 return error;
1079 SysEntryError:
1080 if (MAJOR(dev->devt))
1081 device_remove_file(dev, &dev_attr_dev);
1082 DevAttrError:
1083 device_pm_remove(dev);
1084 dpm_sysfs_remove(dev);
1085 DPMError:
1086 bus_remove_device(dev);
1087 BusError:
1088 device_remove_attrs(dev);
1089 AttrsError:
1090 device_remove_class_symlinks(dev);
1091 SymlinkError:
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
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
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
1134
1135
1136
1137
1138
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
1148
1149
1150void put_device(struct device *dev)
1151{
1152
1153 if (dev)
1154 kobject_put(&dev->kobj);
1155}
1156EXPORT_SYMBOL_GPL(put_device);
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171void device_del(struct device *dev)
1172{
1173 struct device *parent = dev->parent;
1174 struct class_interface *class_intf;
1175
1176
1177
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
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
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
1210
1211
1212 if (platform_notify_remove)
1213 platform_notify_remove(dev);
1214 if (dev->bus)
1215 blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
1216 BUS_NOTIFY_REMOVED_DEVICE, dev);
1217 kobject_uevent(&dev->kobj, KOBJ_REMOVE);
1218 cleanup_device_parent(dev);
1219 kobject_del(&dev->kobj);
1220 put_device(parent);
1221}
1222EXPORT_SYMBOL_GPL(device_del);
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235void device_unregister(struct device *dev)
1236{
1237 pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
1238 device_del(dev);
1239 put_device(dev);
1240}
1241EXPORT_SYMBOL_GPL(device_unregister);
1242
1243static struct device *next_device(struct klist_iter *i)
1244{
1245 struct klist_node *n = klist_next(i);
1246 struct device *dev = NULL;
1247 struct device_private *p;
1248
1249 if (n) {
1250 p = to_device_private_parent(n);
1251 dev = p->device;
1252 }
1253 return dev;
1254}
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269const char *device_get_devnode(struct device *dev,
1270 umode_t *mode, kuid_t *uid, kgid_t *gid,
1271 const char **tmp)
1272{
1273 char *s;
1274
1275 *tmp = NULL;
1276
1277
1278 if (dev->type && dev->type->devnode)
1279 *tmp = dev->type->devnode(dev, mode, uid, gid);
1280 if (*tmp)
1281 return *tmp;
1282
1283
1284 if (dev->class && dev->class->devnode)
1285 *tmp = dev->class->devnode(dev, mode);
1286 if (*tmp)
1287 return *tmp;
1288
1289
1290 if (strchr(dev_name(dev), '!') == NULL)
1291 return dev_name(dev);
1292
1293
1294 *tmp = kstrdup(dev_name(dev), GFP_KERNEL);
1295 if (!*tmp)
1296 return NULL;
1297 while ((s = strchr(*tmp, '!')))
1298 s[0] = '/';
1299 return *tmp;
1300}
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314int device_for_each_child(struct device *parent, void *data,
1315 int (*fn)(struct device *dev, void *data))
1316{
1317 struct klist_iter i;
1318 struct device *child;
1319 int error = 0;
1320
1321 if (!parent->p)
1322 return 0;
1323
1324 klist_iter_init(&parent->p->klist_children, &i);
1325 while ((child = next_device(&i)) && !error)
1326 error = fn(child, data);
1327 klist_iter_exit(&i);
1328 return error;
1329}
1330EXPORT_SYMBOL_GPL(device_for_each_child);
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349struct device *device_find_child(struct device *parent, void *data,
1350 int (*match)(struct device *dev, void *data))
1351{
1352 struct klist_iter i;
1353 struct device *child;
1354
1355 if (!parent)
1356 return NULL;
1357
1358 klist_iter_init(&parent->p->klist_children, &i);
1359 while ((child = next_device(&i)))
1360 if (match(child, data) && get_device(child))
1361 break;
1362 klist_iter_exit(&i);
1363 return child;
1364}
1365EXPORT_SYMBOL_GPL(device_find_child);
1366
1367int __init devices_init(void)
1368{
1369 devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL);
1370 if (!devices_kset)
1371 return -ENOMEM;
1372 dev_kobj = kobject_create_and_add("dev", NULL);
1373 if (!dev_kobj)
1374 goto dev_kobj_err;
1375 sysfs_dev_block_kobj = kobject_create_and_add("block", dev_kobj);
1376 if (!sysfs_dev_block_kobj)
1377 goto block_kobj_err;
1378 sysfs_dev_char_kobj = kobject_create_and_add("char", dev_kobj);
1379 if (!sysfs_dev_char_kobj)
1380 goto char_kobj_err;
1381
1382 return 0;
1383
1384 char_kobj_err:
1385 kobject_put(sysfs_dev_block_kobj);
1386 block_kobj_err:
1387 kobject_put(dev_kobj);
1388 dev_kobj_err:
1389 kset_unregister(devices_kset);
1390 return -ENOMEM;
1391}
1392
1393static int device_check_offline(struct device *dev, void *not_used)
1394{
1395 int ret;
1396
1397 ret = device_for_each_child(dev, NULL, device_check_offline);
1398 if (ret)
1399 return ret;
1400
1401 return device_supports_offline(dev) && !dev->offline ? -EBUSY : 0;
1402}
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415int device_offline(struct device *dev)
1416{
1417 int ret;
1418
1419 if (dev->offline_disabled)
1420 return -EPERM;
1421
1422 ret = device_for_each_child(dev, NULL, device_check_offline);
1423 if (ret)
1424 return ret;
1425
1426 device_lock(dev);
1427 if (device_supports_offline(dev)) {
1428 if (dev->offline) {
1429 ret = 1;
1430 } else {
1431 ret = dev->bus->offline(dev);
1432 if (!ret) {
1433 kobject_uevent(&dev->kobj, KOBJ_OFFLINE);
1434 dev->offline = true;
1435 }
1436 }
1437 }
1438 device_unlock(dev);
1439
1440 return ret;
1441}
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453int device_online(struct device *dev)
1454{
1455 int ret = 0;
1456
1457 device_lock(dev);
1458 if (device_supports_offline(dev)) {
1459 if (dev->offline) {
1460 ret = dev->bus->online(dev);
1461 if (!ret) {
1462 kobject_uevent(&dev->kobj, KOBJ_ONLINE);
1463 dev->offline = false;
1464 }
1465 } else {
1466 ret = 1;
1467 }
1468 }
1469 device_unlock(dev);
1470
1471 return ret;
1472}
1473
1474struct root_device {
1475 struct device dev;
1476 struct module *owner;
1477};
1478
1479static inline struct root_device *to_root_device(struct device *d)
1480{
1481 return container_of(d, struct root_device, dev);
1482}
1483
1484static void root_device_release(struct device *dev)
1485{
1486 kfree(to_root_device(dev));
1487}
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511struct device *__root_device_register(const char *name, struct module *owner)
1512{
1513 struct root_device *root;
1514 int err = -ENOMEM;
1515
1516 root = kzalloc(sizeof(struct root_device), GFP_KERNEL);
1517 if (!root)
1518 return ERR_PTR(err);
1519
1520 err = dev_set_name(&root->dev, "%s", name);
1521 if (err) {
1522 kfree(root);
1523 return ERR_PTR(err);
1524 }
1525
1526 root->dev.release = root_device_release;
1527
1528 err = device_register(&root->dev);
1529 if (err) {
1530 put_device(&root->dev);
1531 return ERR_PTR(err);
1532 }
1533
1534#ifdef CONFIG_MODULES
1535 if (owner) {
1536 struct module_kobject *mk = &owner->mkobj;
1537
1538 err = sysfs_create_link(&root->dev.kobj, &mk->kobj, "module");
1539 if (err) {
1540 device_unregister(&root->dev);
1541 return ERR_PTR(err);
1542 }
1543 root->owner = owner;
1544 }
1545#endif
1546
1547 return &root->dev;
1548}
1549EXPORT_SYMBOL_GPL(__root_device_register);
1550
1551
1552
1553
1554
1555
1556
1557
1558void root_device_unregister(struct device *dev)
1559{
1560 struct root_device *root = to_root_device(dev);
1561
1562 if (root->owner)
1563 sysfs_remove_link(&root->dev.kobj, "module");
1564
1565 device_unregister(dev);
1566}
1567EXPORT_SYMBOL_GPL(root_device_unregister);
1568
1569
1570static void device_create_release(struct device *dev)
1571{
1572 pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
1573 kfree(dev);
1574}
1575
1576static struct device *
1577device_create_groups_vargs(struct class *class, struct device *parent,
1578 dev_t devt, void *drvdata,
1579 const struct attribute_group **groups,
1580 const char *fmt, va_list args)
1581{
1582 struct device *dev = NULL;
1583 int retval = -ENODEV;
1584
1585 if (class == NULL || IS_ERR(class))
1586 goto error;
1587
1588 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1589 if (!dev) {
1590 retval = -ENOMEM;
1591 goto error;
1592 }
1593
1594 device_initialize(dev);
1595 dev->devt = devt;
1596 dev->class = class;
1597 dev->parent = parent;
1598 dev->groups = groups;
1599 dev->release = device_create_release;
1600 dev_set_drvdata(dev, drvdata);
1601
1602 retval = kobject_set_name_vargs(&dev->kobj, fmt, args);
1603 if (retval)
1604 goto error;
1605
1606 retval = device_add(dev);
1607 if (retval)
1608 goto error;
1609
1610 return dev;
1611
1612error:
1613 put_device(dev);
1614 return ERR_PTR(retval);
1615}
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642struct device *device_create_vargs(struct class *class, struct device *parent,
1643 dev_t devt, void *drvdata, const char *fmt,
1644 va_list args)
1645{
1646 return device_create_groups_vargs(class, parent, devt, drvdata, NULL,
1647 fmt, args);
1648}
1649EXPORT_SYMBOL_GPL(device_create_vargs);
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675struct device *device_create(struct class *class, struct device *parent,
1676 dev_t devt, void *drvdata, const char *fmt, ...)
1677{
1678 va_list vargs;
1679 struct device *dev;
1680
1681 va_start(vargs, fmt);
1682 dev = device_create_vargs(class, parent, devt, drvdata, fmt, vargs);
1683 va_end(vargs);
1684 return dev;
1685}
1686EXPORT_SYMBOL_GPL(device_create);
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715struct device *device_create_with_groups(struct class *class,
1716 struct device *parent, dev_t devt,
1717 void *drvdata,
1718 const struct attribute_group **groups,
1719 const char *fmt, ...)
1720{
1721 va_list vargs;
1722 struct device *dev;
1723
1724 va_start(vargs, fmt);
1725 dev = device_create_groups_vargs(class, parent, devt, drvdata, groups,
1726 fmt, vargs);
1727 va_end(vargs);
1728 return dev;
1729}
1730EXPORT_SYMBOL_GPL(device_create_with_groups);
1731
1732static int __match_devt(struct device *dev, const void *data)
1733{
1734 const dev_t *devt = data;
1735
1736 return dev->devt == *devt;
1737}
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747void device_destroy(struct class *class, dev_t devt)
1748{
1749 struct device *dev;
1750
1751 dev = class_find_device(class, NULL, &devt, __match_devt);
1752 if (dev) {
1753 put_device(dev);
1754 device_unregister(dev);
1755 }
1756}
1757EXPORT_SYMBOL_GPL(device_destroy);
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798int device_rename(struct device *dev, const char *new_name)
1799{
1800 struct kobject *kobj = &dev->kobj;
1801 char *old_device_name = NULL;
1802 int error;
1803
1804 dev = get_device(dev);
1805 if (!dev)
1806 return -EINVAL;
1807
1808 dev_dbg(dev, "renaming to %s\n", new_name);
1809
1810 old_device_name = kstrdup(dev_name(dev), GFP_KERNEL);
1811 if (!old_device_name) {
1812 error = -ENOMEM;
1813 goto out;
1814 }
1815
1816 if (dev->class) {
1817 error = sysfs_rename_link_ns(&dev->class->p->subsys.kobj,
1818 kobj, old_device_name,
1819 new_name, kobject_namespace(kobj));
1820 if (error)
1821 goto out;
1822 }
1823
1824 error = kobject_rename(kobj, new_name);
1825 if (error)
1826 goto out;
1827
1828out:
1829 put_device(dev);
1830
1831 kfree(old_device_name);
1832
1833 return error;
1834}
1835EXPORT_SYMBOL_GPL(device_rename);
1836
1837static int device_move_class_links(struct device *dev,
1838 struct device *old_parent,
1839 struct device *new_parent)
1840{
1841 int error = 0;
1842
1843 if (old_parent)
1844 sysfs_remove_link(&dev->kobj, "device");
1845 if (new_parent)
1846 error = sysfs_create_link(&dev->kobj, &new_parent->kobj,
1847 "device");
1848 return error;
1849}
1850
1851
1852
1853
1854
1855
1856
1857int device_move(struct device *dev, struct device *new_parent,
1858 enum dpm_order dpm_order)
1859{
1860 int error;
1861 struct device *old_parent;
1862 struct kobject *new_parent_kobj;
1863
1864 dev = get_device(dev);
1865 if (!dev)
1866 return -EINVAL;
1867
1868 device_pm_lock();
1869 new_parent = get_device(new_parent);
1870 new_parent_kobj = get_device_parent(dev, new_parent);
1871
1872 pr_debug("device: '%s': %s: moving to '%s'\n", dev_name(dev),
1873 __func__, new_parent ? dev_name(new_parent) : "<NULL>");
1874 error = kobject_move(&dev->kobj, new_parent_kobj);
1875 if (error) {
1876 cleanup_glue_dir(dev, new_parent_kobj);
1877 put_device(new_parent);
1878 goto out;
1879 }
1880 old_parent = dev->parent;
1881 dev->parent = new_parent;
1882 if (old_parent)
1883 klist_remove(&dev->p->knode_parent);
1884 if (new_parent) {
1885 klist_add_tail(&dev->p->knode_parent,
1886 &new_parent->p->klist_children);
1887 set_dev_node(dev, dev_to_node(new_parent));
1888 }
1889
1890 if (dev->class) {
1891 error = device_move_class_links(dev, old_parent, new_parent);
1892 if (error) {
1893
1894 device_move_class_links(dev, new_parent, old_parent);
1895 if (!kobject_move(&dev->kobj, &old_parent->kobj)) {
1896 if (new_parent)
1897 klist_remove(&dev->p->knode_parent);
1898 dev->parent = old_parent;
1899 if (old_parent) {
1900 klist_add_tail(&dev->p->knode_parent,
1901 &old_parent->p->klist_children);
1902 set_dev_node(dev, dev_to_node(old_parent));
1903 }
1904 }
1905 cleanup_glue_dir(dev, new_parent_kobj);
1906 put_device(new_parent);
1907 goto out;
1908 }
1909 }
1910 switch (dpm_order) {
1911 case DPM_ORDER_NONE:
1912 break;
1913 case DPM_ORDER_DEV_AFTER_PARENT:
1914 device_pm_move_after(dev, new_parent);
1915 break;
1916 case DPM_ORDER_PARENT_BEFORE_DEV:
1917 device_pm_move_before(new_parent, dev);
1918 break;
1919 case DPM_ORDER_DEV_LAST:
1920 device_pm_move_last(dev);
1921 break;
1922 }
1923
1924 put_device(old_parent);
1925out:
1926 device_pm_unlock();
1927 put_device(dev);
1928 return error;
1929}
1930EXPORT_SYMBOL_GPL(device_move);
1931
1932
1933
1934
1935void device_shutdown(void)
1936{
1937 struct device *dev, *parent;
1938
1939 spin_lock(&devices_kset->list_lock);
1940
1941
1942
1943
1944
1945 while (!list_empty(&devices_kset->list)) {
1946 dev = list_entry(devices_kset->list.prev, struct device,
1947 kobj.entry);
1948
1949
1950
1951
1952
1953
1954 parent = get_device(dev->parent);
1955 get_device(dev);
1956
1957
1958
1959
1960 list_del_init(&dev->kobj.entry);
1961 spin_unlock(&devices_kset->list_lock);
1962
1963
1964 if (parent)
1965 device_lock(parent);
1966 device_lock(dev);
1967
1968
1969 pm_runtime_get_noresume(dev);
1970 pm_runtime_barrier(dev);
1971
1972 if (dev->bus && dev->bus->shutdown) {
1973 if (initcall_debug)
1974 dev_info(dev, "shutdown\n");
1975 dev->bus->shutdown(dev);
1976 } else if (dev->driver && dev->driver->shutdown) {
1977 if (initcall_debug)
1978 dev_info(dev, "shutdown\n");
1979 dev->driver->shutdown(dev);
1980 }
1981
1982 device_unlock(dev);
1983 if (parent)
1984 device_unlock(parent);
1985
1986 put_device(dev);
1987 put_device(parent);
1988
1989 spin_lock(&devices_kset->list_lock);
1990 }
1991 spin_unlock(&devices_kset->list_lock);
1992}
1993
1994
1995
1996
1997
1998#ifdef CONFIG_PRINTK
1999static int
2000create_syslog_header(const struct device *dev, char *hdr, size_t hdrlen)
2001{
2002 const char *subsys;
2003 size_t pos = 0;
2004
2005 if (dev->class)
2006 subsys = dev->class->name;
2007 else if (dev->bus)
2008 subsys = dev->bus->name;
2009 else
2010 return 0;
2011
2012 pos += snprintf(hdr + pos, hdrlen - pos, "SUBSYSTEM=%s", subsys);
2013 if (pos >= hdrlen)
2014 goto overflow;
2015
2016
2017
2018
2019
2020
2021
2022
2023 if (MAJOR(dev->devt)) {
2024 char c;
2025
2026 if (strcmp(subsys, "block") == 0)
2027 c = 'b';
2028 else
2029 c = 'c';
2030 pos++;
2031 pos += snprintf(hdr + pos, hdrlen - pos,
2032 "DEVICE=%c%u:%u",
2033 c, MAJOR(dev->devt), MINOR(dev->devt));
2034 } else if (strcmp(subsys, "net") == 0) {
2035 struct net_device *net = to_net_dev(dev);
2036
2037 pos++;
2038 pos += snprintf(hdr + pos, hdrlen - pos,
2039 "DEVICE=n%u", net->ifindex);
2040 } else {
2041 pos++;
2042 pos += snprintf(hdr + pos, hdrlen - pos,
2043 "DEVICE=+%s:%s", subsys, dev_name(dev));
2044 }
2045
2046 if (pos >= hdrlen)
2047 goto overflow;
2048
2049 return pos;
2050
2051overflow:
2052 dev_WARN(dev, "device/subsystem name too long");
2053 return 0;
2054}
2055
2056int dev_vprintk_emit(int level, const struct device *dev,
2057 const char *fmt, va_list args)
2058{
2059 char hdr[128];
2060 size_t hdrlen;
2061
2062 hdrlen = create_syslog_header(dev, hdr, sizeof(hdr));
2063
2064 return vprintk_emit(0, level, hdrlen ? hdr : NULL, hdrlen, fmt, args);
2065}
2066EXPORT_SYMBOL(dev_vprintk_emit);
2067
2068int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...)
2069{
2070 va_list args;
2071 int r;
2072
2073 va_start(args, fmt);
2074
2075 r = dev_vprintk_emit(level, dev, fmt, args);
2076
2077 va_end(args);
2078
2079 return r;
2080}
2081EXPORT_SYMBOL(dev_printk_emit);
2082
2083static void __dev_printk(const char *level, const struct device *dev,
2084 struct va_format *vaf)
2085{
2086 if (dev)
2087 dev_printk_emit(level[1] - '0', dev, "%s %s: %pV",
2088 dev_driver_string(dev), dev_name(dev), vaf);
2089 else
2090 printk("%s(NULL device *): %pV", level, vaf);
2091}
2092
2093void dev_printk(const char *level, const struct device *dev,
2094 const char *fmt, ...)
2095{
2096 struct va_format vaf;
2097 va_list args;
2098
2099 va_start(args, fmt);
2100
2101 vaf.fmt = fmt;
2102 vaf.va = &args;
2103
2104 __dev_printk(level, dev, &vaf);
2105
2106 va_end(args);
2107}
2108EXPORT_SYMBOL(dev_printk);
2109
2110#define define_dev_printk_level(func, kern_level) \
2111void func(const struct device *dev, const char *fmt, ...) \
2112{ \
2113 struct va_format vaf; \
2114 va_list args; \
2115 \
2116 va_start(args, fmt); \
2117 \
2118 vaf.fmt = fmt; \
2119 vaf.va = &args; \
2120 \
2121 __dev_printk(kern_level, dev, &vaf); \
2122 \
2123 va_end(args); \
2124} \
2125EXPORT_SYMBOL(func);
2126
2127define_dev_printk_level(dev_emerg, KERN_EMERG);
2128define_dev_printk_level(dev_alert, KERN_ALERT);
2129define_dev_printk_level(dev_crit, KERN_CRIT);
2130define_dev_printk_level(dev_err, KERN_ERR);
2131define_dev_printk_level(dev_warn, KERN_WARNING);
2132define_dev_printk_level(dev_notice, KERN_NOTICE);
2133define_dev_printk_level(_dev_info, KERN_INFO);
2134
2135#endif
2136