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