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 *tmp = kstrdup(dev_name(dev), GFP_KERNEL);
1307 if (!*tmp)
1308 return NULL;
1309 while ((s = strchr(*tmp, '!')))
1310 s[0] = '/';
1311 return *tmp;
1312}
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326int device_for_each_child(struct device *parent, void *data,
1327 int (*fn)(struct device *dev, void *data))
1328{
1329 struct klist_iter i;
1330 struct device *child;
1331 int error = 0;
1332
1333 if (!parent->p)
1334 return 0;
1335
1336 klist_iter_init(&parent->p->klist_children, &i);
1337 while ((child = next_device(&i)) && !error)
1338 error = fn(child, data);
1339 klist_iter_exit(&i);
1340 return error;
1341}
1342EXPORT_SYMBOL_GPL(device_for_each_child);
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361struct device *device_find_child(struct device *parent, void *data,
1362 int (*match)(struct device *dev, void *data))
1363{
1364 struct klist_iter i;
1365 struct device *child;
1366
1367 if (!parent)
1368 return NULL;
1369
1370 klist_iter_init(&parent->p->klist_children, &i);
1371 while ((child = next_device(&i)))
1372 if (match(child, data) && get_device(child))
1373 break;
1374 klist_iter_exit(&i);
1375 return child;
1376}
1377EXPORT_SYMBOL_GPL(device_find_child);
1378
1379int __init devices_init(void)
1380{
1381 devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL);
1382 if (!devices_kset)
1383 return -ENOMEM;
1384 dev_kobj = kobject_create_and_add("dev", NULL);
1385 if (!dev_kobj)
1386 goto dev_kobj_err;
1387 sysfs_dev_block_kobj = kobject_create_and_add("block", dev_kobj);
1388 if (!sysfs_dev_block_kobj)
1389 goto block_kobj_err;
1390 sysfs_dev_char_kobj = kobject_create_and_add("char", dev_kobj);
1391 if (!sysfs_dev_char_kobj)
1392 goto char_kobj_err;
1393
1394 return 0;
1395
1396 char_kobj_err:
1397 kobject_put(sysfs_dev_block_kobj);
1398 block_kobj_err:
1399 kobject_put(dev_kobj);
1400 dev_kobj_err:
1401 kset_unregister(devices_kset);
1402 return -ENOMEM;
1403}
1404
1405static int device_check_offline(struct device *dev, void *not_used)
1406{
1407 int ret;
1408
1409 ret = device_for_each_child(dev, NULL, device_check_offline);
1410 if (ret)
1411 return ret;
1412
1413 return device_supports_offline(dev) && !dev->offline ? -EBUSY : 0;
1414}
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427int device_offline(struct device *dev)
1428{
1429 int ret;
1430
1431 if (dev->offline_disabled)
1432 return -EPERM;
1433
1434 ret = device_for_each_child(dev, NULL, device_check_offline);
1435 if (ret)
1436 return ret;
1437
1438 device_lock(dev);
1439 if (device_supports_offline(dev)) {
1440 if (dev->offline) {
1441 ret = 1;
1442 } else {
1443 ret = dev->bus->offline(dev);
1444 if (!ret) {
1445 kobject_uevent(&dev->kobj, KOBJ_OFFLINE);
1446 dev->offline = true;
1447 }
1448 }
1449 }
1450 device_unlock(dev);
1451
1452 return ret;
1453}
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465int device_online(struct device *dev)
1466{
1467 int ret = 0;
1468
1469 device_lock(dev);
1470 if (device_supports_offline(dev)) {
1471 if (dev->offline) {
1472 ret = dev->bus->online(dev);
1473 if (!ret) {
1474 kobject_uevent(&dev->kobj, KOBJ_ONLINE);
1475 dev->offline = false;
1476 }
1477 } else {
1478 ret = 1;
1479 }
1480 }
1481 device_unlock(dev);
1482
1483 return ret;
1484}
1485
1486struct root_device {
1487 struct device dev;
1488 struct module *owner;
1489};
1490
1491static inline struct root_device *to_root_device(struct device *d)
1492{
1493 return container_of(d, struct root_device, dev);
1494}
1495
1496static void root_device_release(struct device *dev)
1497{
1498 kfree(to_root_device(dev));
1499}
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523struct device *__root_device_register(const char *name, struct module *owner)
1524{
1525 struct root_device *root;
1526 int err = -ENOMEM;
1527
1528 root = kzalloc(sizeof(struct root_device), GFP_KERNEL);
1529 if (!root)
1530 return ERR_PTR(err);
1531
1532 err = dev_set_name(&root->dev, "%s", name);
1533 if (err) {
1534 kfree(root);
1535 return ERR_PTR(err);
1536 }
1537
1538 root->dev.release = root_device_release;
1539
1540 err = device_register(&root->dev);
1541 if (err) {
1542 put_device(&root->dev);
1543 return ERR_PTR(err);
1544 }
1545
1546#ifdef CONFIG_MODULES
1547 if (owner) {
1548 struct module_kobject *mk = &owner->mkobj;
1549
1550 err = sysfs_create_link(&root->dev.kobj, &mk->kobj, "module");
1551 if (err) {
1552 device_unregister(&root->dev);
1553 return ERR_PTR(err);
1554 }
1555 root->owner = owner;
1556 }
1557#endif
1558
1559 return &root->dev;
1560}
1561EXPORT_SYMBOL_GPL(__root_device_register);
1562
1563
1564
1565
1566
1567
1568
1569
1570void root_device_unregister(struct device *dev)
1571{
1572 struct root_device *root = to_root_device(dev);
1573
1574 if (root->owner)
1575 sysfs_remove_link(&root->dev.kobj, "module");
1576
1577 device_unregister(dev);
1578}
1579EXPORT_SYMBOL_GPL(root_device_unregister);
1580
1581
1582static void device_create_release(struct device *dev)
1583{
1584 pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
1585 kfree(dev);
1586}
1587
1588static struct device *
1589device_create_groups_vargs(struct class *class, struct device *parent,
1590 dev_t devt, void *drvdata,
1591 const struct attribute_group **groups,
1592 const char *fmt, va_list args)
1593{
1594 struct device *dev = NULL;
1595 int retval = -ENODEV;
1596
1597 if (class == NULL || IS_ERR(class))
1598 goto error;
1599
1600 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1601 if (!dev) {
1602 retval = -ENOMEM;
1603 goto error;
1604 }
1605
1606 device_initialize(dev);
1607 dev->devt = devt;
1608 dev->class = class;
1609 dev->parent = parent;
1610 dev->groups = groups;
1611 dev->release = device_create_release;
1612 dev_set_drvdata(dev, drvdata);
1613
1614 retval = kobject_set_name_vargs(&dev->kobj, fmt, args);
1615 if (retval)
1616 goto error;
1617
1618 retval = device_add(dev);
1619 if (retval)
1620 goto error;
1621
1622 return dev;
1623
1624error:
1625 put_device(dev);
1626 return ERR_PTR(retval);
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
1653
1654struct device *device_create_vargs(struct class *class, struct device *parent,
1655 dev_t devt, void *drvdata, const char *fmt,
1656 va_list args)
1657{
1658 return device_create_groups_vargs(class, parent, devt, drvdata, NULL,
1659 fmt, args);
1660}
1661EXPORT_SYMBOL_GPL(device_create_vargs);
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687struct device *device_create(struct class *class, struct device *parent,
1688 dev_t devt, void *drvdata, const char *fmt, ...)
1689{
1690 va_list vargs;
1691 struct device *dev;
1692
1693 va_start(vargs, fmt);
1694 dev = device_create_vargs(class, parent, devt, drvdata, fmt, vargs);
1695 va_end(vargs);
1696 return dev;
1697}
1698EXPORT_SYMBOL_GPL(device_create);
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
1726
1727struct device *device_create_with_groups(struct class *class,
1728 struct device *parent, dev_t devt,
1729 void *drvdata,
1730 const struct attribute_group **groups,
1731 const char *fmt, ...)
1732{
1733 va_list vargs;
1734 struct device *dev;
1735
1736 va_start(vargs, fmt);
1737 dev = device_create_groups_vargs(class, parent, devt, drvdata, groups,
1738 fmt, vargs);
1739 va_end(vargs);
1740 return dev;
1741}
1742EXPORT_SYMBOL_GPL(device_create_with_groups);
1743
1744static int __match_devt(struct device *dev, const void *data)
1745{
1746 const dev_t *devt = data;
1747
1748 return dev->devt == *devt;
1749}
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759void device_destroy(struct class *class, dev_t devt)
1760{
1761 struct device *dev;
1762
1763 dev = class_find_device(class, NULL, &devt, __match_devt);
1764 if (dev) {
1765 put_device(dev);
1766 device_unregister(dev);
1767 }
1768}
1769EXPORT_SYMBOL_GPL(device_destroy);
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
1809
1810int device_rename(struct device *dev, const char *new_name)
1811{
1812 struct kobject *kobj = &dev->kobj;
1813 char *old_device_name = NULL;
1814 int error;
1815
1816 dev = get_device(dev);
1817 if (!dev)
1818 return -EINVAL;
1819
1820 dev_dbg(dev, "renaming to %s\n", new_name);
1821
1822 old_device_name = kstrdup(dev_name(dev), GFP_KERNEL);
1823 if (!old_device_name) {
1824 error = -ENOMEM;
1825 goto out;
1826 }
1827
1828 if (dev->class) {
1829 error = sysfs_rename_link_ns(&dev->class->p->subsys.kobj,
1830 kobj, old_device_name,
1831 new_name, kobject_namespace(kobj));
1832 if (error)
1833 goto out;
1834 }
1835
1836 error = kobject_rename(kobj, new_name);
1837 if (error)
1838 goto out;
1839
1840out:
1841 put_device(dev);
1842
1843 kfree(old_device_name);
1844
1845 return error;
1846}
1847EXPORT_SYMBOL_GPL(device_rename);
1848
1849static int device_move_class_links(struct device *dev,
1850 struct device *old_parent,
1851 struct device *new_parent)
1852{
1853 int error = 0;
1854
1855 if (old_parent)
1856 sysfs_remove_link(&dev->kobj, "device");
1857 if (new_parent)
1858 error = sysfs_create_link(&dev->kobj, &new_parent->kobj,
1859 "device");
1860 return error;
1861}
1862
1863
1864
1865
1866
1867
1868
1869int device_move(struct device *dev, struct device *new_parent,
1870 enum dpm_order dpm_order)
1871{
1872 int error;
1873 struct device *old_parent;
1874 struct kobject *new_parent_kobj;
1875
1876 dev = get_device(dev);
1877 if (!dev)
1878 return -EINVAL;
1879
1880 device_pm_lock();
1881 new_parent = get_device(new_parent);
1882 new_parent_kobj = get_device_parent(dev, new_parent);
1883
1884 pr_debug("device: '%s': %s: moving to '%s'\n", dev_name(dev),
1885 __func__, new_parent ? dev_name(new_parent) : "<NULL>");
1886 error = kobject_move(&dev->kobj, new_parent_kobj);
1887 if (error) {
1888 cleanup_glue_dir(dev, new_parent_kobj);
1889 put_device(new_parent);
1890 goto out;
1891 }
1892 old_parent = dev->parent;
1893 dev->parent = new_parent;
1894 if (old_parent)
1895 klist_remove(&dev->p->knode_parent);
1896 if (new_parent) {
1897 klist_add_tail(&dev->p->knode_parent,
1898 &new_parent->p->klist_children);
1899 set_dev_node(dev, dev_to_node(new_parent));
1900 }
1901
1902 if (dev->class) {
1903 error = device_move_class_links(dev, old_parent, new_parent);
1904 if (error) {
1905
1906 device_move_class_links(dev, new_parent, old_parent);
1907 if (!kobject_move(&dev->kobj, &old_parent->kobj)) {
1908 if (new_parent)
1909 klist_remove(&dev->p->knode_parent);
1910 dev->parent = old_parent;
1911 if (old_parent) {
1912 klist_add_tail(&dev->p->knode_parent,
1913 &old_parent->p->klist_children);
1914 set_dev_node(dev, dev_to_node(old_parent));
1915 }
1916 }
1917 cleanup_glue_dir(dev, new_parent_kobj);
1918 put_device(new_parent);
1919 goto out;
1920 }
1921 }
1922 switch (dpm_order) {
1923 case DPM_ORDER_NONE:
1924 break;
1925 case DPM_ORDER_DEV_AFTER_PARENT:
1926 device_pm_move_after(dev, new_parent);
1927 break;
1928 case DPM_ORDER_PARENT_BEFORE_DEV:
1929 device_pm_move_before(new_parent, dev);
1930 break;
1931 case DPM_ORDER_DEV_LAST:
1932 device_pm_move_last(dev);
1933 break;
1934 }
1935
1936 put_device(old_parent);
1937out:
1938 device_pm_unlock();
1939 put_device(dev);
1940 return error;
1941}
1942EXPORT_SYMBOL_GPL(device_move);
1943
1944
1945
1946
1947void device_shutdown(void)
1948{
1949 struct device *dev, *parent;
1950
1951 spin_lock(&devices_kset->list_lock);
1952
1953
1954
1955
1956
1957 while (!list_empty(&devices_kset->list)) {
1958 dev = list_entry(devices_kset->list.prev, struct device,
1959 kobj.entry);
1960
1961
1962
1963
1964
1965
1966 parent = get_device(dev->parent);
1967 get_device(dev);
1968
1969
1970
1971
1972 list_del_init(&dev->kobj.entry);
1973 spin_unlock(&devices_kset->list_lock);
1974
1975
1976 if (parent)
1977 device_lock(parent);
1978 device_lock(dev);
1979
1980
1981 pm_runtime_get_noresume(dev);
1982 pm_runtime_barrier(dev);
1983
1984 if (dev->bus && dev->bus->shutdown) {
1985 if (initcall_debug)
1986 dev_info(dev, "shutdown\n");
1987 dev->bus->shutdown(dev);
1988 } else if (dev->driver && dev->driver->shutdown) {
1989 if (initcall_debug)
1990 dev_info(dev, "shutdown\n");
1991 dev->driver->shutdown(dev);
1992 }
1993
1994 device_unlock(dev);
1995 if (parent)
1996 device_unlock(parent);
1997
1998 put_device(dev);
1999 put_device(parent);
2000
2001 spin_lock(&devices_kset->list_lock);
2002 }
2003 spin_unlock(&devices_kset->list_lock);
2004}
2005
2006
2007
2008
2009
2010#ifdef CONFIG_PRINTK
2011static int
2012create_syslog_header(const struct device *dev, char *hdr, size_t hdrlen)
2013{
2014 const char *subsys;
2015 size_t pos = 0;
2016
2017 if (dev->class)
2018 subsys = dev->class->name;
2019 else if (dev->bus)
2020 subsys = dev->bus->name;
2021 else
2022 return 0;
2023
2024 pos += snprintf(hdr + pos, hdrlen - pos, "SUBSYSTEM=%s", subsys);
2025 if (pos >= hdrlen)
2026 goto overflow;
2027
2028
2029
2030
2031
2032
2033
2034
2035 if (MAJOR(dev->devt)) {
2036 char c;
2037
2038 if (strcmp(subsys, "block") == 0)
2039 c = 'b';
2040 else
2041 c = 'c';
2042 pos++;
2043 pos += snprintf(hdr + pos, hdrlen - pos,
2044 "DEVICE=%c%u:%u",
2045 c, MAJOR(dev->devt), MINOR(dev->devt));
2046 } else if (strcmp(subsys, "net") == 0) {
2047 struct net_device *net = to_net_dev(dev);
2048
2049 pos++;
2050 pos += snprintf(hdr + pos, hdrlen - pos,
2051 "DEVICE=n%u", net->ifindex);
2052 } else {
2053 pos++;
2054 pos += snprintf(hdr + pos, hdrlen - pos,
2055 "DEVICE=+%s:%s", subsys, dev_name(dev));
2056 }
2057
2058 if (pos >= hdrlen)
2059 goto overflow;
2060
2061 return pos;
2062
2063overflow:
2064 dev_WARN(dev, "device/subsystem name too long");
2065 return 0;
2066}
2067
2068int dev_vprintk_emit(int level, const struct device *dev,
2069 const char *fmt, va_list args)
2070{
2071 char hdr[128];
2072 size_t hdrlen;
2073
2074 hdrlen = create_syslog_header(dev, hdr, sizeof(hdr));
2075
2076 return vprintk_emit(0, level, hdrlen ? hdr : NULL, hdrlen, fmt, args);
2077}
2078EXPORT_SYMBOL(dev_vprintk_emit);
2079
2080int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...)
2081{
2082 va_list args;
2083 int r;
2084
2085 va_start(args, fmt);
2086
2087 r = dev_vprintk_emit(level, dev, fmt, args);
2088
2089 va_end(args);
2090
2091 return r;
2092}
2093EXPORT_SYMBOL(dev_printk_emit);
2094
2095static void __dev_printk(const char *level, const struct device *dev,
2096 struct va_format *vaf)
2097{
2098 if (dev)
2099 dev_printk_emit(level[1] - '0', dev, "%s %s: %pV",
2100 dev_driver_string(dev), dev_name(dev), vaf);
2101 else
2102 printk("%s(NULL device *): %pV", level, vaf);
2103}
2104
2105void dev_printk(const char *level, const struct device *dev,
2106 const char *fmt, ...)
2107{
2108 struct va_format vaf;
2109 va_list args;
2110
2111 va_start(args, fmt);
2112
2113 vaf.fmt = fmt;
2114 vaf.va = &args;
2115
2116 __dev_printk(level, dev, &vaf);
2117
2118 va_end(args);
2119}
2120EXPORT_SYMBOL(dev_printk);
2121
2122#define define_dev_printk_level(func, kern_level) \
2123void func(const struct device *dev, const char *fmt, ...) \
2124{ \
2125 struct va_format vaf; \
2126 va_list args; \
2127 \
2128 va_start(args, fmt); \
2129 \
2130 vaf.fmt = fmt; \
2131 vaf.va = &args; \
2132 \
2133 __dev_printk(kern_level, dev, &vaf); \
2134 \
2135 va_end(args); \
2136} \
2137EXPORT_SYMBOL(func);
2138
2139define_dev_printk_level(dev_emerg, KERN_EMERG);
2140define_dev_printk_level(dev_alert, KERN_ALERT);
2141define_dev_printk_level(dev_crit, KERN_CRIT);
2142define_dev_printk_level(dev_err, KERN_ERR);
2143define_dev_printk_level(dev_warn, KERN_WARNING);
2144define_dev_printk_level(dev_notice, KERN_NOTICE);
2145define_dev_printk_level(_dev_info, KERN_INFO);
2146
2147#endif
2148
2149static inline bool fwnode_is_primary(struct fwnode_handle *fwnode)
2150{
2151 return fwnode && !IS_ERR(fwnode->secondary);
2152}
2153
2154
2155
2156
2157
2158
2159
2160
2161
2162void set_primary_fwnode(struct device *dev, struct fwnode_handle *fwnode)
2163{
2164 if (fwnode) {
2165 struct fwnode_handle *fn = dev->fwnode;
2166
2167 if (fwnode_is_primary(fn))
2168 fn = fn->secondary;
2169
2170 fwnode->secondary = fn;
2171 dev->fwnode = fwnode;
2172 } else {
2173 dev->fwnode = fwnode_is_primary(dev->fwnode) ?
2174 dev->fwnode->secondary : NULL;
2175 }
2176}
2177EXPORT_SYMBOL_GPL(set_primary_fwnode);
2178
2179
2180
2181
2182
2183
2184
2185
2186
2187
2188void set_secondary_fwnode(struct device *dev, struct fwnode_handle *fwnode)
2189{
2190 if (fwnode)
2191 fwnode->secondary = ERR_PTR(-ENODEV);
2192
2193 if (fwnode_is_primary(dev->fwnode))
2194 dev->fwnode->secondary = fwnode;
2195 else
2196 dev->fwnode = fwnode;
2197}
2198