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_name(struct device *dev, const void *name);
168int device_match_of_node(struct device *dev, const void *np);
169int device_match_fwnode(struct device *dev, const void *fwnode);
170int device_match_devt(struct device *dev, const void *pdevt);
171int device_match_acpi_dev(struct device *dev, const void *adev);
172int device_match_any(struct device *dev, const void *unused);
173
174int bus_for_each_dev(struct bus_type *bus, struct device *start, void *data,
175 int (*fn)(struct device *dev, void *data));
176struct 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
186static 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
199static inline struct device *
200bus_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
211static inline struct device *
212bus_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
223static 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
235static inline struct device *
236bus_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
242struct acpi_device;
243
244
245
246
247
248
249
250static inline struct device *
251bus_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
256static inline struct device *
257bus_find_device_by_acpi_dev(struct bus_type *bus, const void *adev)
258{
259 return NULL;
260}
261#endif
262
263struct device *subsys_find_device_by_id(struct bus_type *bus, unsigned int id,
264 struct device *hint);
265int bus_for_each_drv(struct bus_type *bus, struct device_driver *start,
266 void *data, int (*fn)(struct device_driver *, void *));
267void 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
276struct notifier_block;
277
278extern int bus_register_notifier(struct bus_type *bus,
279 struct notifier_block *nb);
280extern 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
299extern struct kset *bus_get_kset(struct bus_type *bus);
300extern 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
324enum 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
368struct 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
396extern int __must_check driver_register(struct device_driver *drv);
397extern void driver_unregister(struct device_driver *drv);
398
399extern struct device_driver *driver_find(const char *name,
400 struct bus_type *bus);
401extern int driver_probe_done(void);
402extern void wait_for_device_probe(void);
403
404
405
406struct 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
420extern int __must_check driver_create_file(struct device_driver *driver,
421 const struct driver_attribute *attr);
422extern void driver_remove_file(struct device_driver *driver,
423 const struct driver_attribute *attr);
424
425extern 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 *));
430struct 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
440static 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
452static inline struct device *
453driver_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
465static inline struct device *
466driver_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
478static 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
484static 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
497static inline struct device *
498driver_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
504static inline struct device *
505driver_find_device_by_acpi_dev(struct device_driver *drv, const void *adev)
506{
507 return NULL;
508}
509#endif
510
511void driver_deferred_probe_add(struct device *dev);
512int driver_deferred_probe_check_state(struct device *dev);
513int driver_deferred_probe_check_state_continue(struct device *dev);
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528struct 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
536int subsys_interface_register(struct subsys_interface *sif);
537void subsys_interface_unregister(struct subsys_interface *sif);
538
539int subsys_system_register(struct bus_type *subsys,
540 const struct attribute_group **groups);
541int 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
573struct 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
599struct class_dev_iter {
600 struct klist_iter ki;
601 const struct device_type *type;
602};
603
604extern struct kobject *sysfs_dev_block_kobj;
605extern struct kobject *sysfs_dev_char_kobj;
606extern int __must_check __class_register(struct class *class,
607 struct lock_class_key *key);
608extern 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
618struct class_compat;
619struct class_compat *class_compat_register(const char *name);
620void class_compat_unregister(struct class_compat *cls);
621int class_compat_create_link(struct class_compat *cls, struct device *dev,
622 struct device *device_link);
623void class_compat_remove_link(struct class_compat *cls, struct device *dev,
624 struct device *device_link);
625
626extern void class_dev_iter_init(struct class_dev_iter *iter,
627 struct class *class,
628 struct device *start,
629 const struct device_type *type);
630extern struct device *class_dev_iter_next(struct class_dev_iter *iter);
631extern void class_dev_iter_exit(struct class_dev_iter *iter);
632
633extern int class_for_each_device(struct class *class, struct device *start,
634 void *data,
635 int (*fn)(struct device *dev, void *data));
636extern 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
646static 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
658static inline struct device *
659class_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
670static inline struct device *
671class_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
683static 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
690struct acpi_device;
691
692
693
694
695
696
697static inline struct device *
698class_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
703static inline struct device *
704class_find_device_by_acpi_dev(struct class *class, const void *adev)
705{
706 return NULL;
707}
708#endif
709
710struct 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
725extern int __must_check class_create_file_ns(struct class *class,
726 const struct class_attribute *attr,
727 const void *ns);
728extern void class_remove_file_ns(struct class *class,
729 const struct class_attribute *attr,
730 const void *ns);
731
732static 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
738static 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
745struct 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
757extern ssize_t show_class_attr_string(struct class *class, struct class_attribute *attr,
758 char *buf);
759
760struct 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
768extern int __must_check class_interface_register(struct class_interface *);
769extern void class_interface_unregister(struct class_interface *);
770
771extern struct class * __must_check __class_create(struct module *owner,
772 const char *name,
773 struct lock_class_key *key);
774extern 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
793struct 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
805struct 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
813struct dev_ext_attribute {
814 struct device_attribute attr;
815 void *var;
816};
817
818ssize_t device_show_ulong(struct device *dev, struct device_attribute *attr,
819 char *buf);
820ssize_t device_store_ulong(struct device *dev, struct device_attribute *attr,
821 const char *buf, size_t count);
822ssize_t device_show_int(struct device *dev, struct device_attribute *attr,
823 char *buf);
824ssize_t device_store_int(struct device *dev, struct device_attribute *attr,
825 const char *buf, size_t count);
826ssize_t device_show_bool(struct device *dev, struct device_attribute *attr,
827 char *buf);
828ssize_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
855extern int device_create_file(struct device *device,
856 const struct device_attribute *entry);
857extern void device_remove_file(struct device *dev,
858 const struct device_attribute *attr);
859extern bool device_remove_file_self(struct device *dev,
860 const struct device_attribute *attr);
861extern int __must_check device_create_bin_file(struct device *dev,
862 const struct bin_attribute *attr);
863extern void device_remove_bin_file(struct device *dev,
864 const struct bin_attribute *attr);
865
866
867typedef void (*dr_release_t)(struct device *dev, void *res);
868typedef int (*dr_match_t)(struct device *dev, void *res, void *match_data);
869
870#ifdef CONFIG_DEBUG_DEVRES
871extern 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
878extern void *devres_alloc_node(dr_release_t release, size_t size, gfp_t gfp,
879 int nid) __malloc;
880static 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
886extern 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);
890extern void devres_free(void *res);
891extern void devres_add(struct device *dev, void *res);
892extern void *devres_find(struct device *dev, dr_release_t release,
893 dr_match_t match, void *match_data);
894extern void *devres_get(struct device *dev, void *new_res,
895 dr_match_t match, void *match_data);
896extern void *devres_remove(struct device *dev, dr_release_t release,
897 dr_match_t match, void *match_data);
898extern int devres_destroy(struct device *dev, dr_release_t release,
899 dr_match_t match, void *match_data);
900extern int devres_release(struct device *dev, dr_release_t release,
901 dr_match_t match, void *match_data);
902
903
904extern void * __must_check devres_open_group(struct device *dev, void *id,
905 gfp_t gfp);
906extern void devres_close_group(struct device *dev, void *id);
907extern void devres_remove_group(struct device *dev, void *id);
908extern int devres_release_group(struct device *dev, void *id);
909
910
911extern void *devm_kmalloc(struct device *dev, size_t size, gfp_t gfp) __malloc;
912extern __printf(3, 0)
913char *devm_kvasprintf(struct device *dev, gfp_t gfp, const char *fmt,
914 va_list ap) __malloc;
915extern __printf(3, 4)
916char *devm_kasprintf(struct device *dev, gfp_t gfp, const char *fmt, ...) __malloc;
917static inline void *devm_kzalloc(struct device *dev, size_t size, gfp_t gfp)
918{
919 return devm_kmalloc(dev, size, gfp | __GFP_ZERO);
920}
921static 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}
931static 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}
936extern void devm_kfree(struct device *dev, const void *p);
937extern char *devm_kstrdup(struct device *dev, const char *s, gfp_t gfp) __malloc;
938extern const char *devm_kstrdup_const(struct device *dev,
939 const char *s, gfp_t gfp);
940extern void *devm_kmemdup(struct device *dev, const void *src, size_t len,
941 gfp_t gfp);
942
943extern unsigned long devm_get_free_pages(struct device *dev,
944 gfp_t gfp_mask, unsigned int order);
945extern void devm_free_pages(struct device *dev, unsigned long addr);
946
947void __iomem *devm_ioremap_resource(struct device *dev,
948 const struct resource *res);
949
950void __iomem *devm_of_iomap(struct device *dev,
951 struct device_node *node, int index,
952 resource_size_t *size);
953
954
955int devm_add_action(struct device *dev, void (*action)(void *), void *data);
956void devm_remove_action(struct device *dev, void (*action)(void *), void *data);
957void devm_release_action(struct device *dev, void (*action)(void *), void *data);
958
959static 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
986void __percpu *__devm_alloc_percpu(struct device *dev, size_t size,
987 size_t align);
988void devm_free_percpu(struct device *dev, void __percpu *pdata);
989
990struct 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
1010struct device_connection {
1011 struct fwnode_handle *fwnode;
1012 const char *endpoint[2];
1013 const char *id;
1014 struct list_head list;
1015};
1016
1017typedef void *(*devcon_match_fn_t)(struct device_connection *con, int ep,
1018 void *data);
1019
1020void *fwnode_connection_find_match(struct fwnode_handle *fwnode,
1021 const char *con_id, void *data,
1022 devcon_match_fn_t match);
1023void *device_connection_find_match(struct device *dev, const char *con_id,
1024 void *data, devcon_match_fn_t match);
1025
1026struct device *device_connection_find(struct device *dev, const char *con_id);
1027
1028void device_connection_add(struct device_connection *con);
1029void device_connection_remove(struct device_connection *con);
1030
1031
1032
1033
1034
1035static 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
1047static 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
1064enum 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
1105struct 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
1127enum 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
1140struct 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
1229struct 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
1321static 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
1331static 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
1339static 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
1348extern __printf(2, 3)
1349int dev_set_name(struct device *dev, const char *name, ...);
1350
1351#ifdef CONFIG_NUMA
1352static inline int dev_to_node(struct device *dev)
1353{
1354 return dev->numa_node;
1355}
1356static inline void set_dev_node(struct device *dev, int node)
1357{
1358 dev->numa_node = node;
1359}
1360#else
1361static inline int dev_to_node(struct device *dev)
1362{
1363 return NUMA_NO_NODE;
1364}
1365static inline void set_dev_node(struct device *dev, int node)
1366{
1367}
1368#endif
1369
1370static 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
1379static 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
1386static inline void *dev_get_drvdata(const struct device *dev)
1387{
1388 return dev->driver_data;
1389}
1390
1391static inline void dev_set_drvdata(struct device *dev, void *data)
1392{
1393 dev->driver_data = data;
1394}
1395
1396static inline struct pm_subsys_data *dev_to_psd(struct device *dev)
1397{
1398 return dev ? dev->power.subsys_data : NULL;
1399}
1400
1401static inline unsigned int dev_get_uevent_suppress(const struct device *dev)
1402{
1403 return dev->kobj.uevent_suppress;
1404}
1405
1406static inline void dev_set_uevent_suppress(struct device *dev, int val)
1407{
1408 dev->kobj.uevent_suppress = val;
1409}
1410
1411static inline int device_is_registered(struct device *dev)
1412{
1413 return dev->kobj.state_in_sysfs;
1414}
1415
1416static inline void device_enable_async_suspend(struct device *dev)
1417{
1418 if (!dev->power.is_prepared)
1419 dev->power.async_suspend = true;
1420}
1421
1422static inline void device_disable_async_suspend(struct device *dev)
1423{
1424 if (!dev->power.is_prepared)
1425 dev->power.async_suspend = false;
1426}
1427
1428static inline bool device_async_suspend_enabled(struct device *dev)
1429{
1430 return !!dev->power.async_suspend;
1431}
1432
1433static inline bool device_pm_not_required(struct device *dev)
1434{
1435 return dev->power.no_pm;
1436}
1437
1438static inline void device_set_pm_not_required(struct device *dev)
1439{
1440 dev->power.no_pm = true;
1441}
1442
1443static 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
1450static inline void dev_pm_set_driver_flags(struct device *dev, u32 flags)
1451{
1452 dev->power.driver_flags = flags;
1453}
1454
1455static inline bool dev_pm_test_driver_flags(struct device *dev, u32 flags)
1456{
1457 return !!(dev->power.driver_flags & flags);
1458}
1459
1460static inline void device_lock(struct device *dev)
1461{
1462 mutex_lock(&dev->mutex);
1463}
1464
1465static inline int device_lock_interruptible(struct device *dev)
1466{
1467 return mutex_lock_interruptible(&dev->mutex);
1468}
1469
1470static inline int device_trylock(struct device *dev)
1471{
1472 return mutex_trylock(&dev->mutex);
1473}
1474
1475static inline void device_unlock(struct device *dev)
1476{
1477 mutex_unlock(&dev->mutex);
1478}
1479
1480static inline void device_lock_assert(struct device *dev)
1481{
1482 lockdep_assert_held(&dev->mutex);
1483}
1484
1485static 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
1492void driver_init(void);
1493
1494
1495
1496
1497extern int __must_check device_register(struct device *dev);
1498extern void device_unregister(struct device *dev);
1499extern void device_initialize(struct device *dev);
1500extern int __must_check device_add(struct device *dev);
1501extern void device_del(struct device *dev);
1502extern int device_for_each_child(struct device *dev, void *data,
1503 int (*fn)(struct device *dev, void *data));
1504extern int device_for_each_child_reverse(struct device *dev, void *data,
1505 int (*fn)(struct device *dev, void *data));
1506extern struct device *device_find_child(struct device *dev, void *data,
1507 int (*match)(struct device *dev, void *data));
1508extern struct device *device_find_child_by_name(struct device *parent,
1509 const char *name);
1510extern int device_rename(struct device *dev, const char *new_name);
1511extern int device_move(struct device *dev, struct device *new_parent,
1512 enum dpm_order dpm_order);
1513extern const char *device_get_devnode(struct device *dev,
1514 umode_t *mode, kuid_t *uid, kgid_t *gid,
1515 const char **tmp);
1516
1517static inline bool device_supports_offline(struct device *dev)
1518{
1519 return dev->bus && dev->bus->offline && dev->bus->online;
1520}
1521
1522extern void lock_device_hotplug(void);
1523extern void unlock_device_hotplug(void);
1524extern int lock_device_hotplug_sysfs(void);
1525extern int device_offline(struct device *dev);
1526extern int device_online(struct device *dev);
1527extern void set_primary_fwnode(struct device *dev, struct fwnode_handle *fwnode);
1528extern void set_secondary_fwnode(struct device *dev, struct fwnode_handle *fwnode);
1529void device_set_of_node_from_dev(struct device *dev, const struct device *dev2);
1530
1531static 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
1541extern 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
1548extern void root_device_unregister(struct device *root);
1549
1550static inline void *dev_get_platdata(const struct device *dev)
1551{
1552 return dev->platform_data;
1553}
1554
1555
1556
1557
1558
1559extern int __must_check device_bind_driver(struct device *dev);
1560extern void device_release_driver(struct device *dev);
1561extern int __must_check device_attach(struct device *dev);
1562extern int __must_check driver_attach(struct device_driver *drv);
1563extern void device_initial_probe(struct device *dev);
1564extern int __must_check device_reprobe(struct device *dev);
1565
1566extern bool device_is_bound(struct device *dev);
1567
1568
1569
1570
1571extern __printf(5, 0)
1572struct device *device_create_vargs(struct class *cls, struct device *parent,
1573 dev_t devt, void *drvdata,
1574 const char *fmt, va_list vargs);
1575extern __printf(5, 6)
1576struct device *device_create(struct class *cls, struct device *parent,
1577 dev_t devt, void *drvdata,
1578 const char *fmt, ...);
1579extern __printf(6, 7)
1580struct 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, ...);
1584extern void device_destroy(struct class *cls, dev_t devt);
1585
1586extern int __must_check device_add_groups(struct device *dev,
1587 const struct attribute_group **groups);
1588extern void device_remove_groups(struct device *dev,
1589 const struct attribute_group **groups);
1590
1591static 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
1599static 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
1607extern int __must_check devm_device_add_groups(struct device *dev,
1608 const struct attribute_group **groups);
1609extern void devm_device_remove_groups(struct device *dev,
1610 const struct attribute_group **groups);
1611extern int __must_check devm_device_add_group(struct device *dev,
1612 const struct attribute_group *grp);
1613extern void devm_device_remove_group(struct device *dev,
1614 const struct attribute_group *grp);
1615
1616
1617
1618
1619
1620
1621
1622extern int (*platform_notify)(struct device *dev);
1623
1624extern int (*platform_notify_remove)(struct device *dev);
1625
1626
1627
1628
1629
1630
1631extern struct device *get_device(struct device *dev);
1632extern void put_device(struct device *dev);
1633extern bool kill_device(struct device *dev);
1634
1635#ifdef CONFIG_DEVTMPFS
1636extern int devtmpfs_create_node(struct device *dev);
1637extern int devtmpfs_delete_node(struct device *dev);
1638extern int devtmpfs_mount(const char *mntdir);
1639#else
1640static inline int devtmpfs_create_node(struct device *dev) { return 0; }
1641static inline int devtmpfs_delete_node(struct device *dev) { return 0; }
1642static inline int devtmpfs_mount(const char *mountpoint) { return 0; }
1643#endif
1644
1645
1646extern void device_shutdown(void);
1647
1648
1649extern const char *dev_driver_string(const struct device *dev);
1650
1651
1652struct device_link *device_link_add(struct device *consumer,
1653 struct device *supplier, u32 flags);
1654void device_link_del(struct device_link *link);
1655void 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
1664int dev_vprintk_emit(int level, const struct device *dev,
1665 const char *fmt, va_list args);
1666__printf(3, 4) __cold
1667int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...);
1668
1669__printf(3, 4) __cold
1670void dev_printk(const char *level, const struct device *dev,
1671 const char *fmt, ...);
1672__printf(2, 3) __cold
1673void _dev_emerg(const struct device *dev, const char *fmt, ...);
1674__printf(2, 3) __cold
1675void _dev_alert(const struct device *dev, const char *fmt, ...);
1676__printf(2, 3) __cold
1677void _dev_crit(const struct device *dev, const char *fmt, ...);
1678__printf(2, 3) __cold
1679void _dev_err(const struct device *dev, const char *fmt, ...);
1680__printf(2, 3) __cold
1681void _dev_warn(const struct device *dev, const char *fmt, ...);
1682__printf(2, 3) __cold
1683void _dev_notice(const struct device *dev, const char *fmt, ...);
1684__printf(2, 3) __cold
1685void _dev_info(const struct device *dev, const char *fmt, ...);
1686
1687#else
1688
1689static inline __printf(3, 0)
1690int dev_vprintk_emit(int level, const struct device *dev,
1691 const char *fmt, va_list args)
1692{ return 0; }
1693static inline __printf(3, 4)
1694int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...)
1695{ return 0; }
1696
1697static inline void __dev_printk(const char *level, const struct device *dev,
1698 struct va_format *vaf)
1699{}
1700static inline __printf(3, 4)
1701void dev_printk(const char *level, const struct device *dev,
1702 const char *fmt, ...)
1703{}
1704
1705static inline __printf(2, 3)
1706void _dev_emerg(const struct device *dev, const char *fmt, ...)
1707{}
1708static inline __printf(2, 3)
1709void _dev_crit(const struct device *dev, const char *fmt, ...)
1710{}
1711static inline __printf(2, 3)
1712void _dev_alert(const struct device *dev, const char *fmt, ...)
1713{}
1714static inline __printf(2, 3)
1715void _dev_err(const struct device *dev, const char *fmt, ...)
1716{}
1717static inline __printf(2, 3)
1718void _dev_warn(const struct device *dev, const char *fmt, ...)
1719{}
1720static inline __printf(2, 3)
1721void _dev_notice(const struct device *dev, const char *fmt, ...)
1722{}
1723static inline __printf(2, 3)
1724void _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, ...) \
1765do { \
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, ...) \
1775do { \
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, ...) \
1799do { \
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, ...) \
1824do { \
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, ...) \
1836do { \
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, ...) \
1845do { \
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
1879extern 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, ...) \
1899static int __init __driver##_init(void) \
1900{ \
1901 return __register(&(__driver) , ##__VA_ARGS__); \
1902} \
1903module_init(__driver##_init); \
1904static void __exit __driver##_exit(void) \
1905{ \
1906 __unregister(&(__driver) , ##__VA_ARGS__); \
1907} \
1908module_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, ...) \
1926static int __init __driver##_init(void) \
1927{ \
1928 return __register(&(__driver) , ##__VA_ARGS__); \
1929} \
1930device_initcall(__driver##_init);
1931
1932#endif
1933