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