1
2
3
4
5
6
7
8
9
10
11
12
13#ifndef _DEVICE_H_
14#define _DEVICE_H_
15
16#include <linux/ioport.h>
17#include <linux/kobject.h>
18#include <linux/klist.h>
19#include <linux/list.h>
20#include <linux/lockdep.h>
21#include <linux/compiler.h>
22#include <linux/types.h>
23#include <linux/mutex.h>
24#include <linux/pinctrl/devinfo.h>
25#include <linux/pm.h>
26#include <linux/atomic.h>
27#include <linux/ratelimit.h>
28#include <linux/uidgid.h>
29#include <linux/gfp.h>
30#include <asm/device.h>
31
32struct device;
33struct device_private;
34struct device_driver;
35struct driver_private;
36struct module;
37struct class;
38struct subsys_private;
39struct bus_type;
40struct device_node;
41struct iommu_ops;
42struct iommu_group;
43
44struct bus_attribute {
45 struct attribute attr;
46 ssize_t (*show)(struct bus_type *bus, char *buf);
47 ssize_t (*store)(struct bus_type *bus, const char *buf, size_t count);
48};
49
50#define BUS_ATTR(_name, _mode, _show, _store) \
51 struct bus_attribute bus_attr_##_name = __ATTR(_name, _mode, _show, _store)
52#define BUS_ATTR_RW(_name) \
53 struct bus_attribute bus_attr_##_name = __ATTR_RW(_name)
54#define BUS_ATTR_RO(_name) \
55 struct bus_attribute bus_attr_##_name = __ATTR_RO(_name)
56
57extern int __must_check bus_create_file(struct bus_type *,
58 struct bus_attribute *);
59extern void bus_remove_file(struct bus_type *, struct bus_attribute *);
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104struct bus_type {
105 const char *name;
106 const char *dev_name;
107 struct device *dev_root;
108 struct device_attribute *dev_attrs;
109 const struct attribute_group **bus_groups;
110 const struct attribute_group **dev_groups;
111 const struct attribute_group **drv_groups;
112
113 int (*match)(struct device *dev, struct device_driver *drv);
114 int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
115 int (*probe)(struct device *dev);
116 int (*remove)(struct device *dev);
117 void (*shutdown)(struct device *dev);
118
119 int (*online)(struct device *dev);
120 int (*offline)(struct device *dev);
121
122 int (*suspend)(struct device *dev, pm_message_t state);
123 int (*resume)(struct device *dev);
124
125 const struct dev_pm_ops *pm;
126
127 struct iommu_ops *iommu_ops;
128
129 struct subsys_private *p;
130 struct lock_class_key lock_key;
131};
132
133extern int __must_check bus_register(struct bus_type *bus);
134
135extern void bus_unregister(struct bus_type *bus);
136
137extern int __must_check bus_rescan_devices(struct bus_type *bus);
138
139
140struct subsys_dev_iter {
141 struct klist_iter ki;
142 const struct device_type *type;
143};
144void subsys_dev_iter_init(struct subsys_dev_iter *iter,
145 struct bus_type *subsys,
146 struct device *start,
147 const struct device_type *type);
148struct device *subsys_dev_iter_next(struct subsys_dev_iter *iter);
149void subsys_dev_iter_exit(struct subsys_dev_iter *iter);
150
151int bus_for_each_dev(struct bus_type *bus, struct device *start, void *data,
152 int (*fn)(struct device *dev, void *data));
153struct device *bus_find_device(struct bus_type *bus, struct device *start,
154 void *data,
155 int (*match)(struct device *dev, void *data));
156struct device *bus_find_device_by_name(struct bus_type *bus,
157 struct device *start,
158 const char *name);
159struct device *subsys_find_device_by_id(struct bus_type *bus, unsigned int id,
160 struct device *hint);
161int bus_for_each_drv(struct bus_type *bus, struct device_driver *start,
162 void *data, int (*fn)(struct device_driver *, void *));
163void bus_sort_breadthfirst(struct bus_type *bus,
164 int (*compare)(const struct device *a,
165 const struct device *b));
166
167
168
169
170
171
172struct notifier_block;
173
174extern int bus_register_notifier(struct bus_type *bus,
175 struct notifier_block *nb);
176extern int bus_unregister_notifier(struct bus_type *bus,
177 struct notifier_block *nb);
178
179
180
181
182
183#define BUS_NOTIFY_ADD_DEVICE 0x00000001
184#define BUS_NOTIFY_DEL_DEVICE 0x00000002
185#define BUS_NOTIFY_BIND_DRIVER 0x00000003
186
187#define BUS_NOTIFY_BOUND_DRIVER 0x00000004
188#define BUS_NOTIFY_UNBIND_DRIVER 0x00000005
189
190#define BUS_NOTIFY_UNBOUND_DRIVER 0x00000006
191
192
193extern struct kset *bus_get_kset(struct bus_type *bus);
194extern struct klist *bus_get_device_klist(struct bus_type *bus);
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228struct device_driver {
229 const char *name;
230 struct bus_type *bus;
231
232 struct module *owner;
233 const char *mod_name;
234
235 bool suppress_bind_attrs;
236
237 const struct of_device_id *of_match_table;
238 const struct acpi_device_id *acpi_match_table;
239
240 int (*probe) (struct device *dev);
241 int (*remove) (struct device *dev);
242 void (*shutdown) (struct device *dev);
243 int (*suspend) (struct device *dev, pm_message_t state);
244 int (*resume) (struct device *dev);
245 const struct attribute_group **groups;
246
247 const struct dev_pm_ops *pm;
248
249 struct driver_private *p;
250};
251
252
253extern int __must_check driver_register(struct device_driver *drv);
254extern void driver_unregister(struct device_driver *drv);
255
256extern struct device_driver *driver_find(const char *name,
257 struct bus_type *bus);
258extern int driver_probe_done(void);
259extern void wait_for_device_probe(void);
260
261
262
263
264struct driver_attribute {
265 struct attribute attr;
266 ssize_t (*show)(struct device_driver *driver, char *buf);
267 ssize_t (*store)(struct device_driver *driver, const char *buf,
268 size_t count);
269};
270
271#define DRIVER_ATTR(_name, _mode, _show, _store) \
272 struct driver_attribute driver_attr_##_name = __ATTR(_name, _mode, _show, _store)
273#define DRIVER_ATTR_RW(_name) \
274 struct driver_attribute driver_attr_##_name = __ATTR_RW(_name)
275#define DRIVER_ATTR_RO(_name) \
276 struct driver_attribute driver_attr_##_name = __ATTR_RO(_name)
277#define DRIVER_ATTR_WO(_name) \
278 struct driver_attribute driver_attr_##_name = __ATTR_WO(_name)
279
280extern int __must_check driver_create_file(struct device_driver *driver,
281 const struct driver_attribute *attr);
282extern void driver_remove_file(struct device_driver *driver,
283 const struct driver_attribute *attr);
284
285extern int __must_check driver_for_each_device(struct device_driver *drv,
286 struct device *start,
287 void *data,
288 int (*fn)(struct device *dev,
289 void *));
290struct device *driver_find_device(struct device_driver *drv,
291 struct device *start, void *data,
292 int (*match)(struct device *dev, void *data));
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307struct subsys_interface {
308 const char *name;
309 struct bus_type *subsys;
310 struct list_head node;
311 int (*add_dev)(struct device *dev, struct subsys_interface *sif);
312 int (*remove_dev)(struct device *dev, struct subsys_interface *sif);
313};
314
315int subsys_interface_register(struct subsys_interface *sif);
316void subsys_interface_unregister(struct subsys_interface *sif);
317
318int subsys_system_register(struct bus_type *subsys,
319 const struct attribute_group **groups);
320int subsys_virtual_register(struct bus_type *subsys,
321 const struct attribute_group **groups);
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351struct class {
352 const char *name;
353 struct module *owner;
354
355 struct class_attribute *class_attrs;
356 const struct attribute_group **dev_groups;
357 struct kobject *dev_kobj;
358
359 int (*dev_uevent)(struct device *dev, struct kobj_uevent_env *env);
360 char *(*devnode)(struct device *dev, umode_t *mode);
361
362 void (*class_release)(struct class *class);
363 void (*dev_release)(struct device *dev);
364
365 int (*suspend)(struct device *dev, pm_message_t state);
366 int (*resume)(struct device *dev);
367
368 const struct kobj_ns_type_operations *ns_type;
369 const void *(*namespace)(struct device *dev);
370
371 const struct dev_pm_ops *pm;
372
373 struct subsys_private *p;
374};
375
376struct class_dev_iter {
377 struct klist_iter ki;
378 const struct device_type *type;
379};
380
381extern struct kobject *sysfs_dev_block_kobj;
382extern struct kobject *sysfs_dev_char_kobj;
383extern int __must_check __class_register(struct class *class,
384 struct lock_class_key *key);
385extern void class_unregister(struct class *class);
386
387
388
389#define class_register(class) \
390({ \
391 static struct lock_class_key __key; \
392 __class_register(class, &__key); \
393})
394
395struct class_compat;
396struct class_compat *class_compat_register(const char *name);
397void class_compat_unregister(struct class_compat *cls);
398int class_compat_create_link(struct class_compat *cls, struct device *dev,
399 struct device *device_link);
400void class_compat_remove_link(struct class_compat *cls, struct device *dev,
401 struct device *device_link);
402
403extern void class_dev_iter_init(struct class_dev_iter *iter,
404 struct class *class,
405 struct device *start,
406 const struct device_type *type);
407extern struct device *class_dev_iter_next(struct class_dev_iter *iter);
408extern void class_dev_iter_exit(struct class_dev_iter *iter);
409
410extern int class_for_each_device(struct class *class, struct device *start,
411 void *data,
412 int (*fn)(struct device *dev, void *data));
413extern struct device *class_find_device(struct class *class,
414 struct device *start, const void *data,
415 int (*match)(struct device *, const void *));
416
417struct class_attribute {
418 struct attribute attr;
419 ssize_t (*show)(struct class *class, struct class_attribute *attr,
420 char *buf);
421 ssize_t (*store)(struct class *class, struct class_attribute *attr,
422 const char *buf, size_t count);
423};
424
425#define CLASS_ATTR(_name, _mode, _show, _store) \
426 struct class_attribute class_attr_##_name = __ATTR(_name, _mode, _show, _store)
427#define CLASS_ATTR_RW(_name) \
428 struct class_attribute class_attr_##_name = __ATTR_RW(_name)
429#define CLASS_ATTR_RO(_name) \
430 struct class_attribute class_attr_##_name = __ATTR_RO(_name)
431
432extern int __must_check class_create_file_ns(struct class *class,
433 const struct class_attribute *attr,
434 const void *ns);
435extern void class_remove_file_ns(struct class *class,
436 const struct class_attribute *attr,
437 const void *ns);
438
439static inline int __must_check class_create_file(struct class *class,
440 const struct class_attribute *attr)
441{
442 return class_create_file_ns(class, attr, NULL);
443}
444
445static inline void class_remove_file(struct class *class,
446 const struct class_attribute *attr)
447{
448 return class_remove_file_ns(class, attr, NULL);
449}
450
451
452struct class_attribute_string {
453 struct class_attribute attr;
454 char *str;
455};
456
457
458#define _CLASS_ATTR_STRING(_name, _mode, _str) \
459 { __ATTR(_name, _mode, show_class_attr_string, NULL), _str }
460#define CLASS_ATTR_STRING(_name, _mode, _str) \
461 struct class_attribute_string class_attr_##_name = \
462 _CLASS_ATTR_STRING(_name, _mode, _str)
463
464extern ssize_t show_class_attr_string(struct class *class, struct class_attribute *attr,
465 char *buf);
466
467struct class_interface {
468 struct list_head node;
469 struct class *class;
470
471 int (*add_dev) (struct device *, struct class_interface *);
472 void (*remove_dev) (struct device *, struct class_interface *);
473};
474
475extern int __must_check class_interface_register(struct class_interface *);
476extern void class_interface_unregister(struct class_interface *);
477
478extern struct class * __must_check __class_create(struct module *owner,
479 const char *name,
480 struct lock_class_key *key);
481extern void class_destroy(struct class *cls);
482
483
484
485#define class_create(owner, name) \
486({ \
487 static struct lock_class_key __key; \
488 __class_create(owner, name, &__key); \
489})
490
491
492
493
494
495
496
497
498
499
500struct device_type {
501 const char *name;
502 const struct attribute_group **groups;
503 int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
504 char *(*devnode)(struct device *dev, umode_t *mode,
505 kuid_t *uid, kgid_t *gid);
506 void (*release)(struct device *dev);
507
508 const struct dev_pm_ops *pm;
509};
510
511
512struct device_attribute {
513 struct attribute attr;
514 ssize_t (*show)(struct device *dev, struct device_attribute *attr,
515 char *buf);
516 ssize_t (*store)(struct device *dev, struct device_attribute *attr,
517 const char *buf, size_t count);
518};
519
520struct dev_ext_attribute {
521 struct device_attribute attr;
522 void *var;
523};
524
525ssize_t device_show_ulong(struct device *dev, struct device_attribute *attr,
526 char *buf);
527ssize_t device_store_ulong(struct device *dev, struct device_attribute *attr,
528 const char *buf, size_t count);
529ssize_t device_show_int(struct device *dev, struct device_attribute *attr,
530 char *buf);
531ssize_t device_store_int(struct device *dev, struct device_attribute *attr,
532 const char *buf, size_t count);
533ssize_t device_show_bool(struct device *dev, struct device_attribute *attr,
534 char *buf);
535ssize_t device_store_bool(struct device *dev, struct device_attribute *attr,
536 const char *buf, size_t count);
537
538#define DEVICE_ATTR(_name, _mode, _show, _store) \
539 struct device_attribute dev_attr_##_name = __ATTR(_name, _mode, _show, _store)
540#define DEVICE_ATTR_RW(_name) \
541 struct device_attribute dev_attr_##_name = __ATTR_RW(_name)
542#define DEVICE_ATTR_RO(_name) \
543 struct device_attribute dev_attr_##_name = __ATTR_RO(_name)
544#define DEVICE_ATTR_WO(_name) \
545 struct device_attribute dev_attr_##_name = __ATTR_WO(_name)
546#define DEVICE_ULONG_ATTR(_name, _mode, _var) \
547 struct dev_ext_attribute dev_attr_##_name = \
548 { __ATTR(_name, _mode, device_show_ulong, device_store_ulong), &(_var) }
549#define DEVICE_INT_ATTR(_name, _mode, _var) \
550 struct dev_ext_attribute dev_attr_##_name = \
551 { __ATTR(_name, _mode, device_show_int, device_store_int), &(_var) }
552#define DEVICE_BOOL_ATTR(_name, _mode, _var) \
553 struct dev_ext_attribute dev_attr_##_name = \
554 { __ATTR(_name, _mode, device_show_bool, device_store_bool), &(_var) }
555#define DEVICE_ATTR_IGNORE_LOCKDEP(_name, _mode, _show, _store) \
556 struct device_attribute dev_attr_##_name = \
557 __ATTR_IGNORE_LOCKDEP(_name, _mode, _show, _store)
558
559extern int device_create_file(struct device *device,
560 const struct device_attribute *entry);
561extern void device_remove_file(struct device *dev,
562 const struct device_attribute *attr);
563extern int __must_check device_create_bin_file(struct device *dev,
564 const struct bin_attribute *attr);
565extern void device_remove_bin_file(struct device *dev,
566 const struct bin_attribute *attr);
567extern int device_schedule_callback_owner(struct device *dev,
568 void (*func)(struct device *dev), struct module *owner);
569
570
571#define device_schedule_callback(dev, func) \
572 device_schedule_callback_owner(dev, func, THIS_MODULE)
573
574
575typedef void (*dr_release_t)(struct device *dev, void *res);
576typedef int (*dr_match_t)(struct device *dev, void *res, void *match_data);
577
578#ifdef CONFIG_DEBUG_DEVRES
579extern void *__devres_alloc(dr_release_t release, size_t size, gfp_t gfp,
580 const char *name);
581#define devres_alloc(release, size, gfp) \
582 __devres_alloc(release, size, gfp, #release)
583#else
584extern void *devres_alloc(dr_release_t release, size_t size, gfp_t gfp);
585#endif
586extern void devres_for_each_res(struct device *dev, dr_release_t release,
587 dr_match_t match, void *match_data,
588 void (*fn)(struct device *, void *, void *),
589 void *data);
590extern void devres_free(void *res);
591extern void devres_add(struct device *dev, void *res);
592extern void *devres_find(struct device *dev, dr_release_t release,
593 dr_match_t match, void *match_data);
594extern void *devres_get(struct device *dev, void *new_res,
595 dr_match_t match, void *match_data);
596extern void *devres_remove(struct device *dev, dr_release_t release,
597 dr_match_t match, void *match_data);
598extern int devres_destroy(struct device *dev, dr_release_t release,
599 dr_match_t match, void *match_data);
600extern int devres_release(struct device *dev, dr_release_t release,
601 dr_match_t match, void *match_data);
602
603
604extern void * __must_check devres_open_group(struct device *dev, void *id,
605 gfp_t gfp);
606extern void devres_close_group(struct device *dev, void *id);
607extern void devres_remove_group(struct device *dev, void *id);
608extern int devres_release_group(struct device *dev, void *id);
609
610
611extern void *devm_kmalloc(struct device *dev, size_t size, gfp_t gfp);
612static inline void *devm_kzalloc(struct device *dev, size_t size, gfp_t gfp)
613{
614 return devm_kmalloc(dev, size, gfp | __GFP_ZERO);
615}
616static inline void *devm_kmalloc_array(struct device *dev,
617 size_t n, size_t size, gfp_t flags)
618{
619 if (size != 0 && n > SIZE_MAX / size)
620 return NULL;
621 return devm_kmalloc(dev, n * size, flags);
622}
623static inline void *devm_kcalloc(struct device *dev,
624 size_t n, size_t size, gfp_t flags)
625{
626 return devm_kmalloc_array(dev, n, size, flags | __GFP_ZERO);
627}
628extern void devm_kfree(struct device *dev, void *p);
629
630void __iomem *devm_ioremap_resource(struct device *dev, struct resource *res);
631void __iomem *devm_request_and_ioremap(struct device *dev,
632 struct resource *res);
633
634
635int devm_add_action(struct device *dev, void (*action)(void *), void *data);
636void devm_remove_action(struct device *dev, void (*action)(void *), void *data);
637
638struct device_dma_parameters {
639
640
641
642
643 unsigned int max_segment_size;
644 unsigned long segment_boundary_mask;
645};
646
647struct acpi_device;
648
649struct acpi_dev_node {
650#ifdef CONFIG_ACPI
651 struct acpi_device *companion;
652#endif
653};
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722struct device {
723 struct device *parent;
724
725 struct device_private *p;
726
727 struct kobject kobj;
728 const char *init_name;
729 const struct device_type *type;
730
731 struct mutex mutex;
732
733
734
735 struct bus_type *bus;
736 struct device_driver *driver;
737
738 void *platform_data;
739
740 struct dev_pm_info power;
741 struct dev_pm_domain *pm_domain;
742
743#ifdef CONFIG_PINCTRL
744 struct dev_pin_info *pins;
745#endif
746
747#ifdef CONFIG_NUMA
748 int numa_node;
749#endif
750 u64 *dma_mask;
751 u64 coherent_dma_mask;
752
753
754
755
756
757 struct device_dma_parameters *dma_parms;
758
759 struct list_head dma_pools;
760
761 struct dma_coherent_mem *dma_mem;
762
763#ifdef CONFIG_DMA_CMA
764 struct cma *cma_area;
765
766#endif
767
768 struct dev_archdata archdata;
769
770 struct device_node *of_node;
771 struct acpi_dev_node acpi_node;
772
773 dev_t devt;
774 u32 id;
775
776 spinlock_t devres_lock;
777 struct list_head devres_head;
778
779 struct klist_node knode_class;
780 struct class *class;
781 const struct attribute_group **groups;
782
783 void (*release)(struct device *dev);
784 struct iommu_group *iommu_group;
785
786 bool offline_disabled:1;
787 bool offline:1;
788};
789
790static inline struct device *kobj_to_dev(struct kobject *kobj)
791{
792 return container_of(kobj, struct device, kobj);
793}
794
795
796#include <linux/pm_wakeup.h>
797
798static inline const char *dev_name(const struct device *dev)
799{
800
801 if (dev->init_name)
802 return dev->init_name;
803
804 return kobject_name(&dev->kobj);
805}
806
807extern __printf(2, 3)
808int dev_set_name(struct device *dev, const char *name, ...);
809
810#ifdef CONFIG_NUMA
811static inline int dev_to_node(struct device *dev)
812{
813 return dev->numa_node;
814}
815static inline void set_dev_node(struct device *dev, int node)
816{
817 dev->numa_node = node;
818}
819#else
820static inline int dev_to_node(struct device *dev)
821{
822 return -1;
823}
824static inline void set_dev_node(struct device *dev, int node)
825{
826}
827#endif
828
829static inline struct pm_subsys_data *dev_to_psd(struct device *dev)
830{
831 return dev ? dev->power.subsys_data : NULL;
832}
833
834static inline unsigned int dev_get_uevent_suppress(const struct device *dev)
835{
836 return dev->kobj.uevent_suppress;
837}
838
839static inline void dev_set_uevent_suppress(struct device *dev, int val)
840{
841 dev->kobj.uevent_suppress = val;
842}
843
844static inline int device_is_registered(struct device *dev)
845{
846 return dev->kobj.state_in_sysfs;
847}
848
849static inline void device_enable_async_suspend(struct device *dev)
850{
851 if (!dev->power.is_prepared)
852 dev->power.async_suspend = true;
853}
854
855static inline void device_disable_async_suspend(struct device *dev)
856{
857 if (!dev->power.is_prepared)
858 dev->power.async_suspend = false;
859}
860
861static inline bool device_async_suspend_enabled(struct device *dev)
862{
863 return !!dev->power.async_suspend;
864}
865
866static inline void pm_suspend_ignore_children(struct device *dev, bool enable)
867{
868 dev->power.ignore_children = enable;
869}
870
871static inline void dev_pm_syscore_device(struct device *dev, bool val)
872{
873#ifdef CONFIG_PM_SLEEP
874 dev->power.syscore = val;
875#endif
876}
877
878static inline void device_lock(struct device *dev)
879{
880 mutex_lock(&dev->mutex);
881}
882
883static inline int device_trylock(struct device *dev)
884{
885 return mutex_trylock(&dev->mutex);
886}
887
888static inline void device_unlock(struct device *dev)
889{
890 mutex_unlock(&dev->mutex);
891}
892
893void driver_init(void);
894
895
896
897
898extern int __must_check device_register(struct device *dev);
899extern void device_unregister(struct device *dev);
900extern void device_initialize(struct device *dev);
901extern int __must_check device_add(struct device *dev);
902extern void device_del(struct device *dev);
903extern int device_for_each_child(struct device *dev, void *data,
904 int (*fn)(struct device *dev, void *data));
905extern struct device *device_find_child(struct device *dev, void *data,
906 int (*match)(struct device *dev, void *data));
907extern int device_rename(struct device *dev, const char *new_name);
908extern int device_move(struct device *dev, struct device *new_parent,
909 enum dpm_order dpm_order);
910extern const char *device_get_devnode(struct device *dev,
911 umode_t *mode, kuid_t *uid, kgid_t *gid,
912 const char **tmp);
913extern void *dev_get_drvdata(const struct device *dev);
914extern int dev_set_drvdata(struct device *dev, void *data);
915
916static inline bool device_supports_offline(struct device *dev)
917{
918 return dev->bus && dev->bus->offline && dev->bus->online;
919}
920
921extern void lock_device_hotplug(void);
922extern void unlock_device_hotplug(void);
923extern int lock_device_hotplug_sysfs(void);
924extern int device_offline(struct device *dev);
925extern int device_online(struct device *dev);
926
927
928
929extern struct device *__root_device_register(const char *name,
930 struct module *owner);
931
932
933
934
935
936#define root_device_register(name) \
937 __root_device_register(name, THIS_MODULE)
938
939extern void root_device_unregister(struct device *root);
940
941static inline void *dev_get_platdata(const struct device *dev)
942{
943 return dev->platform_data;
944}
945
946
947
948
949
950extern int __must_check device_bind_driver(struct device *dev);
951extern void device_release_driver(struct device *dev);
952extern int __must_check device_attach(struct device *dev);
953extern int __must_check driver_attach(struct device_driver *drv);
954extern int __must_check device_reprobe(struct device *dev);
955
956
957
958
959extern struct device *device_create_vargs(struct class *cls,
960 struct device *parent,
961 dev_t devt,
962 void *drvdata,
963 const char *fmt,
964 va_list vargs);
965extern __printf(5, 6)
966struct device *device_create(struct class *cls, struct device *parent,
967 dev_t devt, void *drvdata,
968 const char *fmt, ...);
969extern __printf(6, 7)
970struct device *device_create_with_groups(struct class *cls,
971 struct device *parent, dev_t devt, void *drvdata,
972 const struct attribute_group **groups,
973 const char *fmt, ...);
974extern void device_destroy(struct class *cls, dev_t devt);
975
976
977
978
979
980
981
982extern int (*platform_notify)(struct device *dev);
983
984extern int (*platform_notify_remove)(struct device *dev);
985
986
987
988
989
990
991extern struct device *get_device(struct device *dev);
992extern void put_device(struct device *dev);
993
994#ifdef CONFIG_DEVTMPFS
995extern int devtmpfs_create_node(struct device *dev);
996extern int devtmpfs_delete_node(struct device *dev);
997extern int devtmpfs_mount(const char *mntdir);
998#else
999static inline int devtmpfs_create_node(struct device *dev) { return 0; }
1000static inline int devtmpfs_delete_node(struct device *dev) { return 0; }
1001static inline int devtmpfs_mount(const char *mountpoint) { return 0; }
1002#endif
1003
1004
1005extern void device_shutdown(void);
1006
1007
1008extern const char *dev_driver_string(const struct device *dev);
1009
1010
1011#ifdef CONFIG_PRINTK
1012
1013extern __printf(3, 0)
1014int dev_vprintk_emit(int level, const struct device *dev,
1015 const char *fmt, va_list args);
1016extern __printf(3, 4)
1017int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...);
1018
1019extern __printf(3, 4)
1020int dev_printk(const char *level, const struct device *dev,
1021 const char *fmt, ...);
1022extern __printf(2, 3)
1023int dev_emerg(const struct device *dev, const char *fmt, ...);
1024extern __printf(2, 3)
1025int dev_alert(const struct device *dev, const char *fmt, ...);
1026extern __printf(2, 3)
1027int dev_crit(const struct device *dev, const char *fmt, ...);
1028extern __printf(2, 3)
1029int dev_err(const struct device *dev, const char *fmt, ...);
1030extern __printf(2, 3)
1031int dev_warn(const struct device *dev, const char *fmt, ...);
1032extern __printf(2, 3)
1033int dev_notice(const struct device *dev, const char *fmt, ...);
1034extern __printf(2, 3)
1035int _dev_info(const struct device *dev, const char *fmt, ...);
1036
1037#else
1038
1039static inline __printf(3, 0)
1040int dev_vprintk_emit(int level, const struct device *dev,
1041 const char *fmt, va_list args)
1042{ return 0; }
1043static inline __printf(3, 4)
1044int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...)
1045{ return 0; }
1046
1047static inline int __dev_printk(const char *level, const struct device *dev,
1048 struct va_format *vaf)
1049{ return 0; }
1050static inline __printf(3, 4)
1051int dev_printk(const char *level, const struct device *dev,
1052 const char *fmt, ...)
1053{ return 0; }
1054
1055static inline __printf(2, 3)
1056int dev_emerg(const struct device *dev, const char *fmt, ...)
1057{ return 0; }
1058static inline __printf(2, 3)
1059int dev_crit(const struct device *dev, const char *fmt, ...)
1060{ return 0; }
1061static inline __printf(2, 3)
1062int dev_alert(const struct device *dev, const char *fmt, ...)
1063{ return 0; }
1064static inline __printf(2, 3)
1065int dev_err(const struct device *dev, const char *fmt, ...)
1066{ return 0; }
1067static inline __printf(2, 3)
1068int dev_warn(const struct device *dev, const char *fmt, ...)
1069{ return 0; }
1070static inline __printf(2, 3)
1071int dev_notice(const struct device *dev, const char *fmt, ...)
1072{ return 0; }
1073static inline __printf(2, 3)
1074int _dev_info(const struct device *dev, const char *fmt, ...)
1075{ return 0; }
1076
1077#endif
1078
1079
1080
1081
1082
1083
1084
1085
1086#define dev_info(dev, fmt, arg...) _dev_info(dev, fmt, ##arg)
1087
1088#if defined(CONFIG_DYNAMIC_DEBUG)
1089#define dev_dbg(dev, format, ...) \
1090do { \
1091 dynamic_dev_dbg(dev, format, ##__VA_ARGS__); \
1092} while (0)
1093#elif defined(DEBUG)
1094#define dev_dbg(dev, format, arg...) \
1095 dev_printk(KERN_DEBUG, dev, format, ##arg)
1096#else
1097#define dev_dbg(dev, format, arg...) \
1098({ \
1099 if (0) \
1100 dev_printk(KERN_DEBUG, dev, format, ##arg); \
1101 0; \
1102})
1103#endif
1104
1105#define dev_level_ratelimited(dev_level, dev, fmt, ...) \
1106do { \
1107 static DEFINE_RATELIMIT_STATE(_rs, \
1108 DEFAULT_RATELIMIT_INTERVAL, \
1109 DEFAULT_RATELIMIT_BURST); \
1110 if (__ratelimit(&_rs)) \
1111 dev_level(dev, fmt, ##__VA_ARGS__); \
1112} while (0)
1113
1114#define dev_emerg_ratelimited(dev, fmt, ...) \
1115 dev_level_ratelimited(dev_emerg, dev, fmt, ##__VA_ARGS__)
1116#define dev_alert_ratelimited(dev, fmt, ...) \
1117 dev_level_ratelimited(dev_alert, dev, fmt, ##__VA_ARGS__)
1118#define dev_crit_ratelimited(dev, fmt, ...) \
1119 dev_level_ratelimited(dev_crit, dev, fmt, ##__VA_ARGS__)
1120#define dev_err_ratelimited(dev, fmt, ...) \
1121 dev_level_ratelimited(dev_err, dev, fmt, ##__VA_ARGS__)
1122#define dev_warn_ratelimited(dev, fmt, ...) \
1123 dev_level_ratelimited(dev_warn, dev, fmt, ##__VA_ARGS__)
1124#define dev_notice_ratelimited(dev, fmt, ...) \
1125 dev_level_ratelimited(dev_notice, dev, fmt, ##__VA_ARGS__)
1126#define dev_info_ratelimited(dev, fmt, ...) \
1127 dev_level_ratelimited(dev_info, dev, fmt, ##__VA_ARGS__)
1128#if defined(CONFIG_DYNAMIC_DEBUG)
1129
1130#define dev_dbg_ratelimited(dev, fmt, ...) \
1131do { \
1132 static DEFINE_RATELIMIT_STATE(_rs, \
1133 DEFAULT_RATELIMIT_INTERVAL, \
1134 DEFAULT_RATELIMIT_BURST); \
1135 DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, fmt); \
1136 if (unlikely(descriptor.flags & _DPRINTK_FLAGS_PRINT) && \
1137 __ratelimit(&_rs)) \
1138 __dynamic_dev_dbg(&descriptor, dev, fmt, \
1139 ##__VA_ARGS__); \
1140} while (0)
1141#elif defined(DEBUG)
1142#define dev_dbg_ratelimited(dev, fmt, ...) \
1143do { \
1144 static DEFINE_RATELIMIT_STATE(_rs, \
1145 DEFAULT_RATELIMIT_INTERVAL, \
1146 DEFAULT_RATELIMIT_BURST); \
1147 if (__ratelimit(&_rs)) \
1148 dev_printk(KERN_DEBUG, dev, fmt, ##__VA_ARGS__); \
1149} while (0)
1150#else
1151#define dev_dbg_ratelimited(dev, fmt, ...) \
1152 no_printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
1153#endif
1154
1155#ifdef VERBOSE_DEBUG
1156#define dev_vdbg dev_dbg
1157#else
1158#define dev_vdbg(dev, format, arg...) \
1159({ \
1160 if (0) \
1161 dev_printk(KERN_DEBUG, dev, format, ##arg); \
1162 0; \
1163})
1164#endif
1165
1166
1167
1168
1169
1170#define dev_WARN(dev, format, arg...) \
1171 WARN(1, "%s %s: " format, dev_driver_string(dev), dev_name(dev), ## arg);
1172
1173#define dev_WARN_ONCE(dev, condition, format, arg...) \
1174 WARN_ONCE(condition, "%s %s: " format, \
1175 dev_driver_string(dev), dev_name(dev), ## arg)
1176
1177
1178#define MODULE_ALIAS_CHARDEV(major,minor) \
1179 MODULE_ALIAS("char-major-" __stringify(major) "-" __stringify(minor))
1180#define MODULE_ALIAS_CHARDEV_MAJOR(major) \
1181 MODULE_ALIAS("char-major-" __stringify(major) "-*")
1182
1183#ifdef CONFIG_SYSFS_DEPRECATED
1184extern long sysfs_deprecated;
1185#else
1186#define sysfs_deprecated 0
1187#endif
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203#define module_driver(__driver, __register, __unregister, ...) \
1204static int __init __driver##_init(void) \
1205{ \
1206 return __register(&(__driver) , ##__VA_ARGS__); \
1207} \
1208module_init(__driver##_init); \
1209static void __exit __driver##_exit(void) \
1210{ \
1211 __unregister(&(__driver) , ##__VA_ARGS__); \
1212} \
1213module_exit(__driver##_exit);
1214
1215#endif
1216