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