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