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