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 fwnode_handle;
42struct iommu_ops;
43struct iommu_group;
44struct iommu_fwspec;
45
46struct bus_attribute {
47 struct attribute attr;
48 ssize_t (*show)(struct bus_type *bus, char *buf);
49 ssize_t (*store)(struct bus_type *bus, const char *buf, size_t count);
50};
51
52#define BUS_ATTR(_name, _mode, _show, _store) \
53 struct bus_attribute bus_attr_##_name = __ATTR(_name, _mode, _show, _store)
54#define BUS_ATTR_RW(_name) \
55 struct bus_attribute bus_attr_##_name = __ATTR_RW(_name)
56#define BUS_ATTR_RO(_name) \
57 struct bus_attribute bus_attr_##_name = __ATTR_RO(_name)
58
59extern int __must_check bus_create_file(struct bus_type *,
60 struct bus_attribute *);
61extern void bus_remove_file(struct bus_type *, struct bus_attribute *);
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
104
105
106
107
108
109
110struct bus_type {
111 const char *name;
112 const char *dev_name;
113 struct device *dev_root;
114 const struct attribute_group **bus_groups;
115 const struct attribute_group **dev_groups;
116 const struct attribute_group **drv_groups;
117
118 int (*match)(struct device *dev, struct device_driver *drv);
119 int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
120 int (*probe)(struct device *dev);
121 int (*remove)(struct device *dev);
122 void (*shutdown)(struct device *dev);
123
124 int (*online)(struct device *dev);
125 int (*offline)(struct device *dev);
126
127 int (*suspend)(struct device *dev, pm_message_t state);
128 int (*resume)(struct device *dev);
129
130 int (*num_vf)(struct device *dev);
131
132 const struct dev_pm_ops *pm;
133
134 const struct iommu_ops *iommu_ops;
135
136 struct subsys_private *p;
137 struct lock_class_key lock_key;
138};
139
140extern int __must_check bus_register(struct bus_type *bus);
141
142extern void bus_unregister(struct bus_type *bus);
143
144extern int __must_check bus_rescan_devices(struct bus_type *bus);
145
146
147struct subsys_dev_iter {
148 struct klist_iter ki;
149 const struct device_type *type;
150};
151void subsys_dev_iter_init(struct subsys_dev_iter *iter,
152 struct bus_type *subsys,
153 struct device *start,
154 const struct device_type *type);
155struct device *subsys_dev_iter_next(struct subsys_dev_iter *iter);
156void subsys_dev_iter_exit(struct subsys_dev_iter *iter);
157
158int bus_for_each_dev(struct bus_type *bus, struct device *start, void *data,
159 int (*fn)(struct device *dev, void *data));
160struct device *bus_find_device(struct bus_type *bus, struct device *start,
161 void *data,
162 int (*match)(struct device *dev, void *data));
163struct device *bus_find_device_by_name(struct bus_type *bus,
164 struct device *start,
165 const char *name);
166struct device *subsys_find_device_by_id(struct bus_type *bus, unsigned int id,
167 struct device *hint);
168int bus_for_each_drv(struct bus_type *bus, struct device_driver *start,
169 void *data, int (*fn)(struct device_driver *, void *));
170void bus_sort_breadthfirst(struct bus_type *bus,
171 int (*compare)(const struct device *a,
172 const struct device *b));
173
174
175
176
177
178
179struct notifier_block;
180
181extern int bus_register_notifier(struct bus_type *bus,
182 struct notifier_block *nb);
183extern int bus_unregister_notifier(struct bus_type *bus,
184 struct notifier_block *nb);
185
186
187
188
189
190#define BUS_NOTIFY_ADD_DEVICE 0x00000001
191#define BUS_NOTIFY_DEL_DEVICE 0x00000002
192#define BUS_NOTIFY_REMOVED_DEVICE 0x00000003
193#define BUS_NOTIFY_BIND_DRIVER 0x00000004
194
195#define BUS_NOTIFY_BOUND_DRIVER 0x00000005
196#define BUS_NOTIFY_UNBIND_DRIVER 0x00000006
197
198#define BUS_NOTIFY_UNBOUND_DRIVER 0x00000007
199
200#define BUS_NOTIFY_DRIVER_NOT_BOUND 0x00000008
201
202extern struct kset *bus_get_kset(struct bus_type *bus);
203extern struct klist *bus_get_device_klist(struct bus_type *bus);
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227enum probe_type {
228 PROBE_DEFAULT_STRATEGY,
229 PROBE_PREFER_ASYNCHRONOUS,
230 PROBE_FORCE_SYNCHRONOUS,
231};
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266struct device_driver {
267 const char *name;
268 struct bus_type *bus;
269
270 struct module *owner;
271 const char *mod_name;
272
273 bool suppress_bind_attrs;
274 enum probe_type probe_type;
275
276 const struct of_device_id *of_match_table;
277 const struct acpi_device_id *acpi_match_table;
278
279 int (*probe) (struct device *dev);
280 int (*remove) (struct device *dev);
281 void (*shutdown) (struct device *dev);
282 int (*suspend) (struct device *dev, pm_message_t state);
283 int (*resume) (struct device *dev);
284 const struct attribute_group **groups;
285
286 const struct dev_pm_ops *pm;
287
288 struct driver_private *p;
289};
290
291
292extern int __must_check driver_register(struct device_driver *drv);
293extern void driver_unregister(struct device_driver *drv);
294
295extern struct device_driver *driver_find(const char *name,
296 struct bus_type *bus);
297extern int driver_probe_done(void);
298extern void wait_for_device_probe(void);
299
300
301
302
303struct driver_attribute {
304 struct attribute attr;
305 ssize_t (*show)(struct device_driver *driver, char *buf);
306 ssize_t (*store)(struct device_driver *driver, const char *buf,
307 size_t count);
308};
309
310#define DRIVER_ATTR(_name, _mode, _show, _store) \
311 struct driver_attribute driver_attr_##_name = __ATTR(_name, _mode, _show, _store)
312#define DRIVER_ATTR_RW(_name) \
313 struct driver_attribute driver_attr_##_name = __ATTR_RW(_name)
314#define DRIVER_ATTR_RO(_name) \
315 struct driver_attribute driver_attr_##_name = __ATTR_RO(_name)
316#define DRIVER_ATTR_WO(_name) \
317 struct driver_attribute driver_attr_##_name = __ATTR_WO(_name)
318
319extern int __must_check driver_create_file(struct device_driver *driver,
320 const struct driver_attribute *attr);
321extern void driver_remove_file(struct device_driver *driver,
322 const struct driver_attribute *attr);
323
324extern int __must_check driver_for_each_device(struct device_driver *drv,
325 struct device *start,
326 void *data,
327 int (*fn)(struct device *dev,
328 void *));
329struct device *driver_find_device(struct device_driver *drv,
330 struct device *start, void *data,
331 int (*match)(struct device *dev, void *data));
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346struct subsys_interface {
347 const char *name;
348 struct bus_type *subsys;
349 struct list_head node;
350 int (*add_dev)(struct device *dev, struct subsys_interface *sif);
351 void (*remove_dev)(struct device *dev, struct subsys_interface *sif);
352};
353
354int subsys_interface_register(struct subsys_interface *sif);
355void subsys_interface_unregister(struct subsys_interface *sif);
356
357int subsys_system_register(struct bus_type *subsys,
358 const struct attribute_group **groups);
359int subsys_virtual_register(struct bus_type *subsys,
360 const struct attribute_group **groups);
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391struct class {
392 const char *name;
393 struct module *owner;
394
395 const struct attribute_group **class_groups;
396 const struct attribute_group **dev_groups;
397 struct kobject *dev_kobj;
398
399 int (*dev_uevent)(struct device *dev, struct kobj_uevent_env *env);
400 char *(*devnode)(struct device *dev, umode_t *mode);
401
402 void (*class_release)(struct class *class);
403 void (*dev_release)(struct device *dev);
404
405 int (*suspend)(struct device *dev, pm_message_t state);
406 int (*resume)(struct device *dev);
407 int (*shutdown)(struct device *dev);
408
409 const struct kobj_ns_type_operations *ns_type;
410 const void *(*namespace)(struct device *dev);
411
412 const struct dev_pm_ops *pm;
413
414 struct subsys_private *p;
415};
416
417struct class_dev_iter {
418 struct klist_iter ki;
419 const struct device_type *type;
420};
421
422extern struct kobject *sysfs_dev_block_kobj;
423extern struct kobject *sysfs_dev_char_kobj;
424extern int __must_check __class_register(struct class *class,
425 struct lock_class_key *key);
426extern void class_unregister(struct class *class);
427
428
429
430#define class_register(class) \
431({ \
432 static struct lock_class_key __key; \
433 __class_register(class, &__key); \
434})
435
436struct class_compat;
437struct class_compat *class_compat_register(const char *name);
438void class_compat_unregister(struct class_compat *cls);
439int class_compat_create_link(struct class_compat *cls, struct device *dev,
440 struct device *device_link);
441void class_compat_remove_link(struct class_compat *cls, struct device *dev,
442 struct device *device_link);
443
444extern void class_dev_iter_init(struct class_dev_iter *iter,
445 struct class *class,
446 struct device *start,
447 const struct device_type *type);
448extern struct device *class_dev_iter_next(struct class_dev_iter *iter);
449extern void class_dev_iter_exit(struct class_dev_iter *iter);
450
451extern int class_for_each_device(struct class *class, struct device *start,
452 void *data,
453 int (*fn)(struct device *dev, void *data));
454extern struct device *class_find_device(struct class *class,
455 struct device *start, const void *data,
456 int (*match)(struct device *, const void *));
457
458struct class_attribute {
459 struct attribute attr;
460 ssize_t (*show)(struct class *class, struct class_attribute *attr,
461 char *buf);
462 ssize_t (*store)(struct class *class, struct class_attribute *attr,
463 const char *buf, size_t count);
464};
465
466#define CLASS_ATTR_RW(_name) \
467 struct class_attribute class_attr_##_name = __ATTR_RW(_name)
468#define CLASS_ATTR_RO(_name) \
469 struct class_attribute class_attr_##_name = __ATTR_RO(_name)
470#define CLASS_ATTR_WO(_name) \
471 struct class_attribute class_attr_##_name = __ATTR_WO(_name)
472
473extern int __must_check class_create_file_ns(struct class *class,
474 const struct class_attribute *attr,
475 const void *ns);
476extern void class_remove_file_ns(struct class *class,
477 const struct class_attribute *attr,
478 const void *ns);
479
480static inline int __must_check class_create_file(struct class *class,
481 const struct class_attribute *attr)
482{
483 return class_create_file_ns(class, attr, NULL);
484}
485
486static inline void class_remove_file(struct class *class,
487 const struct class_attribute *attr)
488{
489 return class_remove_file_ns(class, attr, NULL);
490}
491
492
493struct class_attribute_string {
494 struct class_attribute attr;
495 char *str;
496};
497
498
499#define _CLASS_ATTR_STRING(_name, _mode, _str) \
500 { __ATTR(_name, _mode, show_class_attr_string, NULL), _str }
501#define CLASS_ATTR_STRING(_name, _mode, _str) \
502 struct class_attribute_string class_attr_##_name = \
503 _CLASS_ATTR_STRING(_name, _mode, _str)
504
505extern ssize_t show_class_attr_string(struct class *class, struct class_attribute *attr,
506 char *buf);
507
508struct class_interface {
509 struct list_head node;
510 struct class *class;
511
512 int (*add_dev) (struct device *, struct class_interface *);
513 void (*remove_dev) (struct device *, struct class_interface *);
514};
515
516extern int __must_check class_interface_register(struct class_interface *);
517extern void class_interface_unregister(struct class_interface *);
518
519extern struct class * __must_check __class_create(struct module *owner,
520 const char *name,
521 struct lock_class_key *key);
522extern void class_destroy(struct class *cls);
523
524
525
526#define class_create(owner, name) \
527({ \
528 static struct lock_class_key __key; \
529 __class_create(owner, name, &__key); \
530})
531
532
533
534
535
536
537
538
539
540
541struct device_type {
542 const char *name;
543 const struct attribute_group **groups;
544 int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
545 char *(*devnode)(struct device *dev, umode_t *mode,
546 kuid_t *uid, kgid_t *gid);
547 void (*release)(struct device *dev);
548
549 const struct dev_pm_ops *pm;
550};
551
552
553struct device_attribute {
554 struct attribute attr;
555 ssize_t (*show)(struct device *dev, struct device_attribute *attr,
556 char *buf);
557 ssize_t (*store)(struct device *dev, struct device_attribute *attr,
558 const char *buf, size_t count);
559};
560
561struct dev_ext_attribute {
562 struct device_attribute attr;
563 void *var;
564};
565
566ssize_t device_show_ulong(struct device *dev, struct device_attribute *attr,
567 char *buf);
568ssize_t device_store_ulong(struct device *dev, struct device_attribute *attr,
569 const char *buf, size_t count);
570ssize_t device_show_int(struct device *dev, struct device_attribute *attr,
571 char *buf);
572ssize_t device_store_int(struct device *dev, struct device_attribute *attr,
573 const char *buf, size_t count);
574ssize_t device_show_bool(struct device *dev, struct device_attribute *attr,
575 char *buf);
576ssize_t device_store_bool(struct device *dev, struct device_attribute *attr,
577 const char *buf, size_t count);
578
579#define DEVICE_ATTR(_name, _mode, _show, _store) \
580 struct device_attribute dev_attr_##_name = __ATTR(_name, _mode, _show, _store)
581#define DEVICE_ATTR_RW(_name) \
582 struct device_attribute dev_attr_##_name = __ATTR_RW(_name)
583#define DEVICE_ATTR_RO(_name) \
584 struct device_attribute dev_attr_##_name = __ATTR_RO(_name)
585#define DEVICE_ATTR_WO(_name) \
586 struct device_attribute dev_attr_##_name = __ATTR_WO(_name)
587#define DEVICE_ULONG_ATTR(_name, _mode, _var) \
588 struct dev_ext_attribute dev_attr_##_name = \
589 { __ATTR(_name, _mode, device_show_ulong, device_store_ulong), &(_var) }
590#define DEVICE_INT_ATTR(_name, _mode, _var) \
591 struct dev_ext_attribute dev_attr_##_name = \
592 { __ATTR(_name, _mode, device_show_int, device_store_int), &(_var) }
593#define DEVICE_BOOL_ATTR(_name, _mode, _var) \
594 struct dev_ext_attribute dev_attr_##_name = \
595 { __ATTR(_name, _mode, device_show_bool, device_store_bool), &(_var) }
596#define DEVICE_ATTR_IGNORE_LOCKDEP(_name, _mode, _show, _store) \
597 struct device_attribute dev_attr_##_name = \
598 __ATTR_IGNORE_LOCKDEP(_name, _mode, _show, _store)
599
600extern int device_create_file(struct device *device,
601 const struct device_attribute *entry);
602extern void device_remove_file(struct device *dev,
603 const struct device_attribute *attr);
604extern bool device_remove_file_self(struct device *dev,
605 const struct device_attribute *attr);
606extern int __must_check device_create_bin_file(struct device *dev,
607 const struct bin_attribute *attr);
608extern void device_remove_bin_file(struct device *dev,
609 const struct bin_attribute *attr);
610
611
612typedef void (*dr_release_t)(struct device *dev, void *res);
613typedef int (*dr_match_t)(struct device *dev, void *res, void *match_data);
614
615#ifdef CONFIG_DEBUG_DEVRES
616extern void *__devres_alloc_node(dr_release_t release, size_t size, gfp_t gfp,
617 int nid, const char *name) __malloc;
618#define devres_alloc(release, size, gfp) \
619 __devres_alloc_node(release, size, gfp, NUMA_NO_NODE, #release)
620#define devres_alloc_node(release, size, gfp, nid) \
621 __devres_alloc_node(release, size, gfp, nid, #release)
622#else
623extern void *devres_alloc_node(dr_release_t release, size_t size, gfp_t gfp,
624 int nid) __malloc;
625static inline void *devres_alloc(dr_release_t release, size_t size, gfp_t gfp)
626{
627 return devres_alloc_node(release, size, gfp, NUMA_NO_NODE);
628}
629#endif
630
631extern void devres_for_each_res(struct device *dev, dr_release_t release,
632 dr_match_t match, void *match_data,
633 void (*fn)(struct device *, void *, void *),
634 void *data);
635extern void devres_free(void *res);
636extern void devres_add(struct device *dev, void *res);
637extern void *devres_find(struct device *dev, dr_release_t release,
638 dr_match_t match, void *match_data);
639extern void *devres_get(struct device *dev, void *new_res,
640 dr_match_t match, void *match_data);
641extern void *devres_remove(struct device *dev, dr_release_t release,
642 dr_match_t match, void *match_data);
643extern int devres_destroy(struct device *dev, dr_release_t release,
644 dr_match_t match, void *match_data);
645extern int devres_release(struct device *dev, dr_release_t release,
646 dr_match_t match, void *match_data);
647
648
649extern void * __must_check devres_open_group(struct device *dev, void *id,
650 gfp_t gfp);
651extern void devres_close_group(struct device *dev, void *id);
652extern void devres_remove_group(struct device *dev, void *id);
653extern int devres_release_group(struct device *dev, void *id);
654
655
656extern void *devm_kmalloc(struct device *dev, size_t size, gfp_t gfp) __malloc;
657extern __printf(3, 0)
658char *devm_kvasprintf(struct device *dev, gfp_t gfp, const char *fmt,
659 va_list ap) __malloc;
660extern __printf(3, 4)
661char *devm_kasprintf(struct device *dev, gfp_t gfp, const char *fmt, ...) __malloc;
662static inline void *devm_kzalloc(struct device *dev, size_t size, gfp_t gfp)
663{
664 return devm_kmalloc(dev, size, gfp | __GFP_ZERO);
665}
666static inline void *devm_kmalloc_array(struct device *dev,
667 size_t n, size_t size, gfp_t flags)
668{
669 if (size != 0 && n > SIZE_MAX / size)
670 return NULL;
671 return devm_kmalloc(dev, n * size, flags);
672}
673static inline void *devm_kcalloc(struct device *dev,
674 size_t n, size_t size, gfp_t flags)
675{
676 return devm_kmalloc_array(dev, n, size, flags | __GFP_ZERO);
677}
678extern void devm_kfree(struct device *dev, void *p);
679extern char *devm_kstrdup(struct device *dev, const char *s, gfp_t gfp) __malloc;
680extern void *devm_kmemdup(struct device *dev, const void *src, size_t len,
681 gfp_t gfp);
682
683extern unsigned long devm_get_free_pages(struct device *dev,
684 gfp_t gfp_mask, unsigned int order);
685extern void devm_free_pages(struct device *dev, unsigned long addr);
686
687void __iomem *devm_ioremap_resource(struct device *dev, struct resource *res);
688
689
690int devm_add_action(struct device *dev, void (*action)(void *), void *data);
691void devm_remove_action(struct device *dev, void (*action)(void *), void *data);
692
693static inline int devm_add_action_or_reset(struct device *dev,
694 void (*action)(void *), void *data)
695{
696 int ret;
697
698 ret = devm_add_action(dev, action, data);
699 if (ret)
700 action(data);
701
702 return ret;
703}
704
705
706
707
708
709
710
711
712
713
714
715
716#define devm_alloc_percpu(dev, type) \
717 ((typeof(type) __percpu *)__devm_alloc_percpu((dev), sizeof(type), \
718 __alignof__(type)))
719
720void __percpu *__devm_alloc_percpu(struct device *dev, size_t size,
721 size_t align);
722void devm_free_percpu(struct device *dev, void __percpu *pdata);
723
724struct device_dma_parameters {
725
726
727
728
729 unsigned int max_segment_size;
730 unsigned long segment_boundary_mask;
731};
732
733
734
735
736
737
738
739
740
741
742enum device_link_state {
743 DL_STATE_NONE = -1,
744 DL_STATE_DORMANT = 0,
745 DL_STATE_AVAILABLE,
746 DL_STATE_CONSUMER_PROBE,
747 DL_STATE_ACTIVE,
748 DL_STATE_SUPPLIER_UNBIND,
749};
750
751
752
753
754
755
756
757
758
759#define DL_FLAG_STATELESS BIT(0)
760#define DL_FLAG_AUTOREMOVE BIT(1)
761#define DL_FLAG_PM_RUNTIME BIT(2)
762#define DL_FLAG_RPM_ACTIVE BIT(3)
763
764
765
766
767
768
769
770
771
772
773
774
775struct device_link {
776 struct device *supplier;
777 struct list_head s_node;
778 struct device *consumer;
779 struct list_head c_node;
780 enum device_link_state status;
781 u32 flags;
782 bool rpm_active;
783#ifdef CONFIG_SRCU
784 struct rcu_head rcu_head;
785#endif
786};
787
788
789
790
791
792
793
794
795enum dl_dev_state {
796 DL_DEV_NO_DRIVER = 0,
797 DL_DEV_PROBING,
798 DL_DEV_DRIVER_BOUND,
799 DL_DEV_UNBINDING,
800};
801
802
803
804
805
806
807
808struct dev_links_info {
809 struct list_head suppliers;
810 struct list_head consumers;
811 enum dl_dev_state status;
812};
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889struct device {
890 struct device *parent;
891
892 struct device_private *p;
893
894 struct kobject kobj;
895 const char *init_name;
896 const struct device_type *type;
897
898 struct mutex mutex;
899
900
901
902 struct bus_type *bus;
903 struct device_driver *driver;
904
905 void *platform_data;
906
907 void *driver_data;
908
909 struct dev_links_info links;
910 struct dev_pm_info power;
911 struct dev_pm_domain *pm_domain;
912
913#ifdef CONFIG_GENERIC_MSI_IRQ_DOMAIN
914 struct irq_domain *msi_domain;
915#endif
916#ifdef CONFIG_PINCTRL
917 struct dev_pin_info *pins;
918#endif
919#ifdef CONFIG_GENERIC_MSI_IRQ
920 struct list_head msi_list;
921#endif
922
923#ifdef CONFIG_NUMA
924 int numa_node;
925#endif
926 const struct dma_map_ops *dma_ops;
927 u64 *dma_mask;
928 u64 coherent_dma_mask;
929
930
931
932
933 unsigned long dma_pfn_offset;
934
935 struct device_dma_parameters *dma_parms;
936
937 struct list_head dma_pools;
938
939 struct dma_coherent_mem *dma_mem;
940
941#ifdef CONFIG_DMA_CMA
942 struct cma *cma_area;
943
944#endif
945
946 struct dev_archdata archdata;
947
948 struct device_node *of_node;
949 struct fwnode_handle *fwnode;
950
951 dev_t devt;
952 u32 id;
953
954 spinlock_t devres_lock;
955 struct list_head devres_head;
956
957 struct klist_node knode_class;
958 struct class *class;
959 const struct attribute_group **groups;
960
961 void (*release)(struct device *dev);
962 struct iommu_group *iommu_group;
963 struct iommu_fwspec *iommu_fwspec;
964
965 bool offline_disabled:1;
966 bool offline:1;
967 bool of_node_reused:1;
968};
969
970static inline struct device *kobj_to_dev(struct kobject *kobj)
971{
972 return container_of(kobj, struct device, kobj);
973}
974
975
976#include <linux/pm_wakeup.h>
977
978static inline const char *dev_name(const struct device *dev)
979{
980
981 if (dev->init_name)
982 return dev->init_name;
983
984 return kobject_name(&dev->kobj);
985}
986
987extern __printf(2, 3)
988int dev_set_name(struct device *dev, const char *name, ...);
989
990#ifdef CONFIG_NUMA
991static inline int dev_to_node(struct device *dev)
992{
993 return dev->numa_node;
994}
995static inline void set_dev_node(struct device *dev, int node)
996{
997 dev->numa_node = node;
998}
999#else
1000static inline int dev_to_node(struct device *dev)
1001{
1002 return -1;
1003}
1004static inline void set_dev_node(struct device *dev, int node)
1005{
1006}
1007#endif
1008
1009static inline struct irq_domain *dev_get_msi_domain(const struct device *dev)
1010{
1011#ifdef CONFIG_GENERIC_MSI_IRQ_DOMAIN
1012 return dev->msi_domain;
1013#else
1014 return NULL;
1015#endif
1016}
1017
1018static inline void dev_set_msi_domain(struct device *dev, struct irq_domain *d)
1019{
1020#ifdef CONFIG_GENERIC_MSI_IRQ_DOMAIN
1021 dev->msi_domain = d;
1022#endif
1023}
1024
1025static inline void *dev_get_drvdata(const struct device *dev)
1026{
1027 return dev->driver_data;
1028}
1029
1030static inline void dev_set_drvdata(struct device *dev, void *data)
1031{
1032 dev->driver_data = data;
1033}
1034
1035static inline struct pm_subsys_data *dev_to_psd(struct device *dev)
1036{
1037 return dev ? dev->power.subsys_data : NULL;
1038}
1039
1040static inline unsigned int dev_get_uevent_suppress(const struct device *dev)
1041{
1042 return dev->kobj.uevent_suppress;
1043}
1044
1045static inline void dev_set_uevent_suppress(struct device *dev, int val)
1046{
1047 dev->kobj.uevent_suppress = val;
1048}
1049
1050static inline int device_is_registered(struct device *dev)
1051{
1052 return dev->kobj.state_in_sysfs;
1053}
1054
1055static inline void device_enable_async_suspend(struct device *dev)
1056{
1057 if (!dev->power.is_prepared)
1058 dev->power.async_suspend = true;
1059}
1060
1061static inline void device_disable_async_suspend(struct device *dev)
1062{
1063 if (!dev->power.is_prepared)
1064 dev->power.async_suspend = false;
1065}
1066
1067static inline bool device_async_suspend_enabled(struct device *dev)
1068{
1069 return !!dev->power.async_suspend;
1070}
1071
1072static inline void dev_pm_syscore_device(struct device *dev, bool val)
1073{
1074#ifdef CONFIG_PM_SLEEP
1075 dev->power.syscore = val;
1076#endif
1077}
1078
1079static inline void device_lock(struct device *dev)
1080{
1081 mutex_lock(&dev->mutex);
1082}
1083
1084static inline int device_lock_interruptible(struct device *dev)
1085{
1086 return mutex_lock_interruptible(&dev->mutex);
1087}
1088
1089static inline int device_trylock(struct device *dev)
1090{
1091 return mutex_trylock(&dev->mutex);
1092}
1093
1094static inline void device_unlock(struct device *dev)
1095{
1096 mutex_unlock(&dev->mutex);
1097}
1098
1099static inline void device_lock_assert(struct device *dev)
1100{
1101 lockdep_assert_held(&dev->mutex);
1102}
1103
1104static inline struct device_node *dev_of_node(struct device *dev)
1105{
1106 if (!IS_ENABLED(CONFIG_OF))
1107 return NULL;
1108 return dev->of_node;
1109}
1110
1111void driver_init(void);
1112
1113
1114
1115
1116extern int __must_check device_register(struct device *dev);
1117extern void device_unregister(struct device *dev);
1118extern void device_initialize(struct device *dev);
1119extern int __must_check device_add(struct device *dev);
1120extern void device_del(struct device *dev);
1121extern int device_for_each_child(struct device *dev, void *data,
1122 int (*fn)(struct device *dev, void *data));
1123extern int device_for_each_child_reverse(struct device *dev, void *data,
1124 int (*fn)(struct device *dev, void *data));
1125extern struct device *device_find_child(struct device *dev, void *data,
1126 int (*match)(struct device *dev, void *data));
1127extern int device_rename(struct device *dev, const char *new_name);
1128extern int device_move(struct device *dev, struct device *new_parent,
1129 enum dpm_order dpm_order);
1130extern const char *device_get_devnode(struct device *dev,
1131 umode_t *mode, kuid_t *uid, kgid_t *gid,
1132 const char **tmp);
1133
1134static inline bool device_supports_offline(struct device *dev)
1135{
1136 return dev->bus && dev->bus->offline && dev->bus->online;
1137}
1138
1139extern void lock_device_hotplug(void);
1140extern void unlock_device_hotplug(void);
1141extern int lock_device_hotplug_sysfs(void);
1142extern int device_offline(struct device *dev);
1143extern int device_online(struct device *dev);
1144extern void set_primary_fwnode(struct device *dev, struct fwnode_handle *fwnode);
1145extern void set_secondary_fwnode(struct device *dev, struct fwnode_handle *fwnode);
1146void device_set_of_node_from_dev(struct device *dev, const struct device *dev2);
1147
1148static inline int dev_num_vf(struct device *dev)
1149{
1150 if (dev->bus && dev->bus->num_vf)
1151 return dev->bus->num_vf(dev);
1152 return 0;
1153}
1154
1155
1156
1157
1158extern struct device *__root_device_register(const char *name,
1159 struct module *owner);
1160
1161
1162#define root_device_register(name) \
1163 __root_device_register(name, THIS_MODULE)
1164
1165extern void root_device_unregister(struct device *root);
1166
1167static inline void *dev_get_platdata(const struct device *dev)
1168{
1169 return dev->platform_data;
1170}
1171
1172
1173
1174
1175
1176extern int __must_check device_bind_driver(struct device *dev);
1177extern void device_release_driver(struct device *dev);
1178extern int __must_check device_attach(struct device *dev);
1179extern int __must_check driver_attach(struct device_driver *drv);
1180extern void device_initial_probe(struct device *dev);
1181extern int __must_check device_reprobe(struct device *dev);
1182
1183extern bool device_is_bound(struct device *dev);
1184
1185
1186
1187
1188extern __printf(5, 0)
1189struct device *device_create_vargs(struct class *cls, struct device *parent,
1190 dev_t devt, void *drvdata,
1191 const char *fmt, va_list vargs);
1192extern __printf(5, 6)
1193struct device *device_create(struct class *cls, struct device *parent,
1194 dev_t devt, void *drvdata,
1195 const char *fmt, ...);
1196extern __printf(6, 7)
1197struct device *device_create_with_groups(struct class *cls,
1198 struct device *parent, dev_t devt, void *drvdata,
1199 const struct attribute_group **groups,
1200 const char *fmt, ...);
1201extern void device_destroy(struct class *cls, dev_t devt);
1202
1203
1204
1205
1206
1207
1208
1209extern int (*platform_notify)(struct device *dev);
1210
1211extern int (*platform_notify_remove)(struct device *dev);
1212
1213
1214
1215
1216
1217
1218extern struct device *get_device(struct device *dev);
1219extern void put_device(struct device *dev);
1220
1221#ifdef CONFIG_DEVTMPFS
1222extern int devtmpfs_create_node(struct device *dev);
1223extern int devtmpfs_delete_node(struct device *dev);
1224extern int devtmpfs_mount(const char *mntdir);
1225#else
1226static inline int devtmpfs_create_node(struct device *dev) { return 0; }
1227static inline int devtmpfs_delete_node(struct device *dev) { return 0; }
1228static inline int devtmpfs_mount(const char *mountpoint) { return 0; }
1229#endif
1230
1231
1232extern void device_shutdown(void);
1233
1234
1235extern const char *dev_driver_string(const struct device *dev);
1236
1237
1238struct device_link *device_link_add(struct device *consumer,
1239 struct device *supplier, u32 flags);
1240void device_link_del(struct device_link *link);
1241
1242#ifdef CONFIG_PRINTK
1243
1244extern __printf(3, 0)
1245int dev_vprintk_emit(int level, const struct device *dev,
1246 const char *fmt, va_list args);
1247extern __printf(3, 4)
1248int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...);
1249
1250extern __printf(3, 4)
1251void dev_printk(const char *level, const struct device *dev,
1252 const char *fmt, ...);
1253extern __printf(2, 3)
1254void dev_emerg(const struct device *dev, const char *fmt, ...);
1255extern __printf(2, 3)
1256void dev_alert(const struct device *dev, const char *fmt, ...);
1257extern __printf(2, 3)
1258void dev_crit(const struct device *dev, const char *fmt, ...);
1259extern __printf(2, 3)
1260void dev_err(const struct device *dev, const char *fmt, ...);
1261extern __printf(2, 3)
1262void dev_warn(const struct device *dev, const char *fmt, ...);
1263extern __printf(2, 3)
1264void dev_notice(const struct device *dev, const char *fmt, ...);
1265extern __printf(2, 3)
1266void _dev_info(const struct device *dev, const char *fmt, ...);
1267
1268#else
1269
1270static inline __printf(3, 0)
1271int dev_vprintk_emit(int level, const struct device *dev,
1272 const char *fmt, va_list args)
1273{ return 0; }
1274static inline __printf(3, 4)
1275int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...)
1276{ return 0; }
1277
1278static inline void __dev_printk(const char *level, const struct device *dev,
1279 struct va_format *vaf)
1280{}
1281static inline __printf(3, 4)
1282void dev_printk(const char *level, const struct device *dev,
1283 const char *fmt, ...)
1284{}
1285
1286static inline __printf(2, 3)
1287void dev_emerg(const struct device *dev, const char *fmt, ...)
1288{}
1289static inline __printf(2, 3)
1290void dev_crit(const struct device *dev, const char *fmt, ...)
1291{}
1292static inline __printf(2, 3)
1293void dev_alert(const struct device *dev, const char *fmt, ...)
1294{}
1295static inline __printf(2, 3)
1296void dev_err(const struct device *dev, const char *fmt, ...)
1297{}
1298static inline __printf(2, 3)
1299void dev_warn(const struct device *dev, const char *fmt, ...)
1300{}
1301static inline __printf(2, 3)
1302void dev_notice(const struct device *dev, const char *fmt, ...)
1303{}
1304static inline __printf(2, 3)
1305void _dev_info(const struct device *dev, const char *fmt, ...)
1306{}
1307
1308#endif
1309
1310
1311
1312
1313
1314
1315
1316
1317#define dev_info(dev, fmt, arg...) _dev_info(dev, fmt, ##arg)
1318
1319#if defined(CONFIG_DYNAMIC_DEBUG)
1320#define dev_dbg(dev, format, ...) \
1321do { \
1322 dynamic_dev_dbg(dev, format, ##__VA_ARGS__); \
1323} while (0)
1324#elif defined(DEBUG)
1325#define dev_dbg(dev, format, arg...) \
1326 dev_printk(KERN_DEBUG, dev, format, ##arg)
1327#else
1328#define dev_dbg(dev, format, arg...) \
1329({ \
1330 if (0) \
1331 dev_printk(KERN_DEBUG, dev, format, ##arg); \
1332})
1333#endif
1334
1335#ifdef CONFIG_PRINTK
1336#define dev_level_once(dev_level, dev, fmt, ...) \
1337do { \
1338 static bool __print_once __read_mostly; \
1339 \
1340 if (!__print_once) { \
1341 __print_once = true; \
1342 dev_level(dev, fmt, ##__VA_ARGS__); \
1343 } \
1344} while (0)
1345#else
1346#define dev_level_once(dev_level, dev, fmt, ...) \
1347do { \
1348 if (0) \
1349 dev_level(dev, fmt, ##__VA_ARGS__); \
1350} while (0)
1351#endif
1352
1353#define dev_emerg_once(dev, fmt, ...) \
1354 dev_level_once(dev_emerg, dev, fmt, ##__VA_ARGS__)
1355#define dev_alert_once(dev, fmt, ...) \
1356 dev_level_once(dev_alert, dev, fmt, ##__VA_ARGS__)
1357#define dev_crit_once(dev, fmt, ...) \
1358 dev_level_once(dev_crit, dev, fmt, ##__VA_ARGS__)
1359#define dev_err_once(dev, fmt, ...) \
1360 dev_level_once(dev_err, dev, fmt, ##__VA_ARGS__)
1361#define dev_warn_once(dev, fmt, ...) \
1362 dev_level_once(dev_warn, dev, fmt, ##__VA_ARGS__)
1363#define dev_notice_once(dev, fmt, ...) \
1364 dev_level_once(dev_notice, dev, fmt, ##__VA_ARGS__)
1365#define dev_info_once(dev, fmt, ...) \
1366 dev_level_once(dev_info, dev, fmt, ##__VA_ARGS__)
1367#define dev_dbg_once(dev, fmt, ...) \
1368 dev_level_once(dev_dbg, dev, fmt, ##__VA_ARGS__)
1369
1370#define dev_level_ratelimited(dev_level, dev, fmt, ...) \
1371do { \
1372 static DEFINE_RATELIMIT_STATE(_rs, \
1373 DEFAULT_RATELIMIT_INTERVAL, \
1374 DEFAULT_RATELIMIT_BURST); \
1375 if (__ratelimit(&_rs)) \
1376 dev_level(dev, fmt, ##__VA_ARGS__); \
1377} while (0)
1378
1379#define dev_emerg_ratelimited(dev, fmt, ...) \
1380 dev_level_ratelimited(dev_emerg, dev, fmt, ##__VA_ARGS__)
1381#define dev_alert_ratelimited(dev, fmt, ...) \
1382 dev_level_ratelimited(dev_alert, dev, fmt, ##__VA_ARGS__)
1383#define dev_crit_ratelimited(dev, fmt, ...) \
1384 dev_level_ratelimited(dev_crit, dev, fmt, ##__VA_ARGS__)
1385#define dev_err_ratelimited(dev, fmt, ...) \
1386 dev_level_ratelimited(dev_err, dev, fmt, ##__VA_ARGS__)
1387#define dev_warn_ratelimited(dev, fmt, ...) \
1388 dev_level_ratelimited(dev_warn, dev, fmt, ##__VA_ARGS__)
1389#define dev_notice_ratelimited(dev, fmt, ...) \
1390 dev_level_ratelimited(dev_notice, dev, fmt, ##__VA_ARGS__)
1391#define dev_info_ratelimited(dev, fmt, ...) \
1392 dev_level_ratelimited(dev_info, dev, fmt, ##__VA_ARGS__)
1393#if defined(CONFIG_DYNAMIC_DEBUG)
1394
1395#define dev_dbg_ratelimited(dev, fmt, ...) \
1396do { \
1397 static DEFINE_RATELIMIT_STATE(_rs, \
1398 DEFAULT_RATELIMIT_INTERVAL, \
1399 DEFAULT_RATELIMIT_BURST); \
1400 DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, fmt); \
1401 if (unlikely(descriptor.flags & _DPRINTK_FLAGS_PRINT) && \
1402 __ratelimit(&_rs)) \
1403 __dynamic_dev_dbg(&descriptor, dev, fmt, \
1404 ##__VA_ARGS__); \
1405} while (0)
1406#elif defined(DEBUG)
1407#define dev_dbg_ratelimited(dev, fmt, ...) \
1408do { \
1409 static DEFINE_RATELIMIT_STATE(_rs, \
1410 DEFAULT_RATELIMIT_INTERVAL, \
1411 DEFAULT_RATELIMIT_BURST); \
1412 if (__ratelimit(&_rs)) \
1413 dev_printk(KERN_DEBUG, dev, fmt, ##__VA_ARGS__); \
1414} while (0)
1415#else
1416#define dev_dbg_ratelimited(dev, fmt, ...) \
1417do { \
1418 if (0) \
1419 dev_printk(KERN_DEBUG, dev, fmt, ##__VA_ARGS__); \
1420} while (0)
1421#endif
1422
1423#ifdef VERBOSE_DEBUG
1424#define dev_vdbg dev_dbg
1425#else
1426#define dev_vdbg(dev, format, arg...) \
1427({ \
1428 if (0) \
1429 dev_printk(KERN_DEBUG, dev, format, ##arg); \
1430})
1431#endif
1432
1433
1434
1435
1436
1437#define dev_WARN(dev, format, arg...) \
1438 WARN(1, "%s %s: " format, dev_driver_string(dev), dev_name(dev), ## arg);
1439
1440#define dev_WARN_ONCE(dev, condition, format, arg...) \
1441 WARN_ONCE(condition, "%s %s: " format, \
1442 dev_driver_string(dev), dev_name(dev), ## arg)
1443
1444
1445#define MODULE_ALIAS_CHARDEV(major,minor) \
1446 MODULE_ALIAS("char-major-" __stringify(major) "-" __stringify(minor))
1447#define MODULE_ALIAS_CHARDEV_MAJOR(major) \
1448 MODULE_ALIAS("char-major-" __stringify(major) "-*")
1449
1450#ifdef CONFIG_SYSFS_DEPRECATED
1451extern long sysfs_deprecated;
1452#else
1453#define sysfs_deprecated 0
1454#endif
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470#define module_driver(__driver, __register, __unregister, ...) \
1471static int __init __driver##_init(void) \
1472{ \
1473 return __register(&(__driver) , ##__VA_ARGS__); \
1474} \
1475module_init(__driver##_init); \
1476static void __exit __driver##_exit(void) \
1477{ \
1478 __unregister(&(__driver) , ##__VA_ARGS__); \
1479} \
1480module_exit(__driver##_exit);
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497#define builtin_driver(__driver, __register, ...) \
1498static int __init __driver##_init(void) \
1499{ \
1500 return __register(&(__driver) , ##__VA_ARGS__); \
1501} \
1502device_initcall(__driver##_init);
1503
1504#endif
1505