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, struct resource *res);
708
709void __iomem *devm_of_iomap(struct device *dev,
710 struct device_node *node, int index,
711 resource_size_t *size);
712
713
714int devm_add_action(struct device *dev, void (*action)(void *), void *data);
715void devm_remove_action(struct device *dev, void (*action)(void *), void *data);
716
717static inline int devm_add_action_or_reset(struct device *dev,
718 void (*action)(void *), void *data)
719{
720 int ret;
721
722 ret = devm_add_action(dev, action, data);
723 if (ret)
724 action(data);
725
726 return ret;
727}
728
729
730
731
732
733
734
735
736
737
738
739
740#define devm_alloc_percpu(dev, type) \
741 ((typeof(type) __percpu *)__devm_alloc_percpu((dev), sizeof(type), \
742 __alignof__(type)))
743
744void __percpu *__devm_alloc_percpu(struct device *dev, size_t size,
745 size_t align);
746void devm_free_percpu(struct device *dev, void __percpu *pdata);
747
748struct device_dma_parameters {
749
750
751
752
753 unsigned int max_segment_size;
754 unsigned long segment_boundary_mask;
755};
756
757
758
759
760
761
762
763
764
765
766
767
768struct device_connection {
769 struct fwnode_handle *fwnode;
770 const char *endpoint[2];
771 const char *id;
772 struct list_head list;
773};
774
775void *device_connection_find_match(struct device *dev, const char *con_id,
776 void *data,
777 void *(*match)(struct device_connection *con,
778 int ep, void *data));
779
780struct device *device_connection_find(struct device *dev, const char *con_id);
781
782void device_connection_add(struct device_connection *con);
783void device_connection_remove(struct device_connection *con);
784
785
786
787
788
789static inline void device_connections_add(struct device_connection *cons)
790{
791 struct device_connection *c;
792
793 for (c = cons; c->endpoint[0]; c++)
794 device_connection_add(c);
795}
796
797
798
799
800
801static inline void device_connections_remove(struct device_connection *cons)
802{
803 struct device_connection *c;
804
805 for (c = cons; c->endpoint[0]; c++)
806 device_connection_remove(c);
807}
808
809
810
811
812
813
814
815
816
817
818enum device_link_state {
819 DL_STATE_NONE = -1,
820 DL_STATE_DORMANT = 0,
821 DL_STATE_AVAILABLE,
822 DL_STATE_CONSUMER_PROBE,
823 DL_STATE_ACTIVE,
824 DL_STATE_SUPPLIER_UNBIND,
825};
826
827
828
829
830
831
832
833
834
835
836
837#define DL_FLAG_STATELESS BIT(0)
838#define DL_FLAG_AUTOREMOVE_CONSUMER BIT(1)
839#define DL_FLAG_PM_RUNTIME BIT(2)
840#define DL_FLAG_RPM_ACTIVE BIT(3)
841#define DL_FLAG_AUTOREMOVE_SUPPLIER BIT(4)
842#define DL_FLAG_AUTOPROBE_CONSUMER BIT(5)
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857struct device_link {
858 struct device *supplier;
859 struct list_head s_node;
860 struct device *consumer;
861 struct list_head c_node;
862 enum device_link_state status;
863 u32 flags;
864 refcount_t rpm_active;
865 struct kref kref;
866#ifdef CONFIG_SRCU
867 struct rcu_head rcu_head;
868#endif
869 bool supplier_preactivated;
870};
871
872
873
874
875
876
877
878
879enum dl_dev_state {
880 DL_DEV_NO_DRIVER = 0,
881 DL_DEV_PROBING,
882 DL_DEV_DRIVER_BOUND,
883 DL_DEV_UNBINDING,
884};
885
886
887
888
889
890
891
892struct dev_links_info {
893 struct list_head suppliers;
894 struct list_head consumers;
895 enum dl_dev_state status;
896};
897
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
978struct device {
979 struct device *parent;
980
981 struct device_private *p;
982
983 struct kobject kobj;
984 const char *init_name;
985 const struct device_type *type;
986
987 struct mutex mutex;
988
989
990
991 struct bus_type *bus;
992 struct device_driver *driver;
993
994 void *platform_data;
995
996 void *driver_data;
997
998 struct dev_links_info links;
999 struct dev_pm_info power;
1000 struct dev_pm_domain *pm_domain;
1001
1002#ifdef CONFIG_GENERIC_MSI_IRQ_DOMAIN
1003 struct irq_domain *msi_domain;
1004#endif
1005#ifdef CONFIG_PINCTRL
1006 struct dev_pin_info *pins;
1007#endif
1008#ifdef CONFIG_GENERIC_MSI_IRQ
1009 struct list_head msi_list;
1010#endif
1011
1012#ifdef CONFIG_NUMA
1013 int numa_node;
1014#endif
1015 const struct dma_map_ops *dma_ops;
1016 u64 *dma_mask;
1017 u64 coherent_dma_mask;
1018
1019
1020
1021
1022 u64 bus_dma_mask;
1023 unsigned long dma_pfn_offset;
1024
1025 struct device_dma_parameters *dma_parms;
1026
1027 struct list_head dma_pools;
1028
1029#ifdef CONFIG_DMA_DECLARE_COHERENT
1030 struct dma_coherent_mem *dma_mem;
1031
1032#endif
1033#ifdef CONFIG_DMA_CMA
1034 struct cma *cma_area;
1035
1036#endif
1037
1038 struct dev_archdata archdata;
1039
1040 struct device_node *of_node;
1041 struct fwnode_handle *fwnode;
1042
1043 dev_t devt;
1044 u32 id;
1045
1046 spinlock_t devres_lock;
1047 struct list_head devres_head;
1048
1049 struct class *class;
1050 const struct attribute_group **groups;
1051
1052 void (*release)(struct device *dev);
1053 struct iommu_group *iommu_group;
1054 struct iommu_fwspec *iommu_fwspec;
1055
1056 bool offline_disabled:1;
1057 bool offline:1;
1058 bool of_node_reused:1;
1059#if defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_DEVICE) || \
1060 defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU) || \
1061 defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU_ALL)
1062 bool dma_coherent:1;
1063#endif
1064};
1065
1066static inline struct device *kobj_to_dev(struct kobject *kobj)
1067{
1068 return container_of(kobj, struct device, kobj);
1069}
1070
1071
1072
1073
1074
1075
1076static inline bool device_iommu_mapped(struct device *dev)
1077{
1078 return (dev->iommu_group != NULL);
1079}
1080
1081
1082#include <linux/pm_wakeup.h>
1083
1084static inline const char *dev_name(const struct device *dev)
1085{
1086
1087 if (dev->init_name)
1088 return dev->init_name;
1089
1090 return kobject_name(&dev->kobj);
1091}
1092
1093extern __printf(2, 3)
1094int dev_set_name(struct device *dev, const char *name, ...);
1095
1096#ifdef CONFIG_NUMA
1097static inline int dev_to_node(struct device *dev)
1098{
1099 return dev->numa_node;
1100}
1101static inline void set_dev_node(struct device *dev, int node)
1102{
1103 dev->numa_node = node;
1104}
1105#else
1106static inline int dev_to_node(struct device *dev)
1107{
1108 return NUMA_NO_NODE;
1109}
1110static inline void set_dev_node(struct device *dev, int node)
1111{
1112}
1113#endif
1114
1115static inline struct irq_domain *dev_get_msi_domain(const struct device *dev)
1116{
1117#ifdef CONFIG_GENERIC_MSI_IRQ_DOMAIN
1118 return dev->msi_domain;
1119#else
1120 return NULL;
1121#endif
1122}
1123
1124static inline void dev_set_msi_domain(struct device *dev, struct irq_domain *d)
1125{
1126#ifdef CONFIG_GENERIC_MSI_IRQ_DOMAIN
1127 dev->msi_domain = d;
1128#endif
1129}
1130
1131static inline void *dev_get_drvdata(const struct device *dev)
1132{
1133 return dev->driver_data;
1134}
1135
1136static inline void dev_set_drvdata(struct device *dev, void *data)
1137{
1138 dev->driver_data = data;
1139}
1140
1141static inline struct pm_subsys_data *dev_to_psd(struct device *dev)
1142{
1143 return dev ? dev->power.subsys_data : NULL;
1144}
1145
1146static inline unsigned int dev_get_uevent_suppress(const struct device *dev)
1147{
1148 return dev->kobj.uevent_suppress;
1149}
1150
1151static inline void dev_set_uevent_suppress(struct device *dev, int val)
1152{
1153 dev->kobj.uevent_suppress = val;
1154}
1155
1156static inline int device_is_registered(struct device *dev)
1157{
1158 return dev->kobj.state_in_sysfs;
1159}
1160
1161static inline void device_enable_async_suspend(struct device *dev)
1162{
1163 if (!dev->power.is_prepared)
1164 dev->power.async_suspend = true;
1165}
1166
1167static inline void device_disable_async_suspend(struct device *dev)
1168{
1169 if (!dev->power.is_prepared)
1170 dev->power.async_suspend = false;
1171}
1172
1173static inline bool device_async_suspend_enabled(struct device *dev)
1174{
1175 return !!dev->power.async_suspend;
1176}
1177
1178static inline bool device_pm_not_required(struct device *dev)
1179{
1180 return dev->power.no_pm;
1181}
1182
1183static inline void device_set_pm_not_required(struct device *dev)
1184{
1185 dev->power.no_pm = true;
1186}
1187
1188static inline void dev_pm_syscore_device(struct device *dev, bool val)
1189{
1190#ifdef CONFIG_PM_SLEEP
1191 dev->power.syscore = val;
1192#endif
1193}
1194
1195static inline void dev_pm_set_driver_flags(struct device *dev, u32 flags)
1196{
1197 dev->power.driver_flags = flags;
1198}
1199
1200static inline bool dev_pm_test_driver_flags(struct device *dev, u32 flags)
1201{
1202 return !!(dev->power.driver_flags & flags);
1203}
1204
1205static inline void device_lock(struct device *dev)
1206{
1207 mutex_lock(&dev->mutex);
1208}
1209
1210static inline int device_lock_interruptible(struct device *dev)
1211{
1212 return mutex_lock_interruptible(&dev->mutex);
1213}
1214
1215static inline int device_trylock(struct device *dev)
1216{
1217 return mutex_trylock(&dev->mutex);
1218}
1219
1220static inline void device_unlock(struct device *dev)
1221{
1222 mutex_unlock(&dev->mutex);
1223}
1224
1225static inline void device_lock_assert(struct device *dev)
1226{
1227 lockdep_assert_held(&dev->mutex);
1228}
1229
1230static inline struct device_node *dev_of_node(struct device *dev)
1231{
1232 if (!IS_ENABLED(CONFIG_OF))
1233 return NULL;
1234 return dev->of_node;
1235}
1236
1237void driver_init(void);
1238
1239
1240
1241
1242extern int __must_check device_register(struct device *dev);
1243extern void device_unregister(struct device *dev);
1244extern void device_initialize(struct device *dev);
1245extern int __must_check device_add(struct device *dev);
1246extern void device_del(struct device *dev);
1247extern int device_for_each_child(struct device *dev, void *data,
1248 int (*fn)(struct device *dev, void *data));
1249extern int device_for_each_child_reverse(struct device *dev, void *data,
1250 int (*fn)(struct device *dev, void *data));
1251extern struct device *device_find_child(struct device *dev, void *data,
1252 int (*match)(struct device *dev, void *data));
1253extern int device_rename(struct device *dev, const char *new_name);
1254extern int device_move(struct device *dev, struct device *new_parent,
1255 enum dpm_order dpm_order);
1256extern const char *device_get_devnode(struct device *dev,
1257 umode_t *mode, kuid_t *uid, kgid_t *gid,
1258 const char **tmp);
1259
1260static inline bool device_supports_offline(struct device *dev)
1261{
1262 return dev->bus && dev->bus->offline && dev->bus->online;
1263}
1264
1265extern void lock_device_hotplug(void);
1266extern void unlock_device_hotplug(void);
1267extern int lock_device_hotplug_sysfs(void);
1268extern int device_offline(struct device *dev);
1269extern int device_online(struct device *dev);
1270extern void set_primary_fwnode(struct device *dev, struct fwnode_handle *fwnode);
1271extern void set_secondary_fwnode(struct device *dev, struct fwnode_handle *fwnode);
1272void device_set_of_node_from_dev(struct device *dev, const struct device *dev2);
1273
1274static inline int dev_num_vf(struct device *dev)
1275{
1276 if (dev->bus && dev->bus->num_vf)
1277 return dev->bus->num_vf(dev);
1278 return 0;
1279}
1280
1281
1282
1283
1284extern struct device *__root_device_register(const char *name,
1285 struct module *owner);
1286
1287
1288#define root_device_register(name) \
1289 __root_device_register(name, THIS_MODULE)
1290
1291extern void root_device_unregister(struct device *root);
1292
1293static inline void *dev_get_platdata(const struct device *dev)
1294{
1295 return dev->platform_data;
1296}
1297
1298
1299
1300
1301
1302extern int __must_check device_bind_driver(struct device *dev);
1303extern void device_release_driver(struct device *dev);
1304extern int __must_check device_attach(struct device *dev);
1305extern int __must_check driver_attach(struct device_driver *drv);
1306extern void device_initial_probe(struct device *dev);
1307extern int __must_check device_reprobe(struct device *dev);
1308
1309extern bool device_is_bound(struct device *dev);
1310
1311
1312
1313
1314extern __printf(5, 0)
1315struct device *device_create_vargs(struct class *cls, struct device *parent,
1316 dev_t devt, void *drvdata,
1317 const char *fmt, va_list vargs);
1318extern __printf(5, 6)
1319struct device *device_create(struct class *cls, struct device *parent,
1320 dev_t devt, void *drvdata,
1321 const char *fmt, ...);
1322extern __printf(6, 7)
1323struct device *device_create_with_groups(struct class *cls,
1324 struct device *parent, dev_t devt, void *drvdata,
1325 const struct attribute_group **groups,
1326 const char *fmt, ...);
1327extern void device_destroy(struct class *cls, dev_t devt);
1328
1329extern int __must_check device_add_groups(struct device *dev,
1330 const struct attribute_group **groups);
1331extern void device_remove_groups(struct device *dev,
1332 const struct attribute_group **groups);
1333
1334static inline int __must_check device_add_group(struct device *dev,
1335 const struct attribute_group *grp)
1336{
1337 const struct attribute_group *groups[] = { grp, NULL };
1338
1339 return device_add_groups(dev, groups);
1340}
1341
1342static inline void device_remove_group(struct device *dev,
1343 const struct attribute_group *grp)
1344{
1345 const struct attribute_group *groups[] = { grp, NULL };
1346
1347 return device_remove_groups(dev, groups);
1348}
1349
1350extern int __must_check devm_device_add_groups(struct device *dev,
1351 const struct attribute_group **groups);
1352extern void devm_device_remove_groups(struct device *dev,
1353 const struct attribute_group **groups);
1354extern int __must_check devm_device_add_group(struct device *dev,
1355 const struct attribute_group *grp);
1356extern void devm_device_remove_group(struct device *dev,
1357 const struct attribute_group *grp);
1358
1359
1360
1361
1362
1363
1364
1365extern int (*platform_notify)(struct device *dev);
1366
1367extern int (*platform_notify_remove)(struct device *dev);
1368
1369
1370
1371
1372
1373
1374extern struct device *get_device(struct device *dev);
1375extern void put_device(struct device *dev);
1376
1377#ifdef CONFIG_DEVTMPFS
1378extern int devtmpfs_create_node(struct device *dev);
1379extern int devtmpfs_delete_node(struct device *dev);
1380extern int devtmpfs_mount(const char *mntdir);
1381#else
1382static inline int devtmpfs_create_node(struct device *dev) { return 0; }
1383static inline int devtmpfs_delete_node(struct device *dev) { return 0; }
1384static inline int devtmpfs_mount(const char *mountpoint) { return 0; }
1385#endif
1386
1387
1388extern void device_shutdown(void);
1389
1390
1391extern const char *dev_driver_string(const struct device *dev);
1392
1393
1394struct device_link *device_link_add(struct device *consumer,
1395 struct device *supplier, u32 flags);
1396void device_link_del(struct device_link *link);
1397void device_link_remove(void *consumer, struct device *supplier);
1398
1399#ifndef dev_fmt
1400#define dev_fmt(fmt) fmt
1401#endif
1402
1403#ifdef CONFIG_PRINTK
1404
1405__printf(3, 0) __cold
1406int dev_vprintk_emit(int level, const struct device *dev,
1407 const char *fmt, va_list args);
1408__printf(3, 4) __cold
1409int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...);
1410
1411__printf(3, 4) __cold
1412void dev_printk(const char *level, const struct device *dev,
1413 const char *fmt, ...);
1414__printf(2, 3) __cold
1415void _dev_emerg(const struct device *dev, const char *fmt, ...);
1416__printf(2, 3) __cold
1417void _dev_alert(const struct device *dev, const char *fmt, ...);
1418__printf(2, 3) __cold
1419void _dev_crit(const struct device *dev, const char *fmt, ...);
1420__printf(2, 3) __cold
1421void _dev_err(const struct device *dev, const char *fmt, ...);
1422__printf(2, 3) __cold
1423void _dev_warn(const struct device *dev, const char *fmt, ...);
1424__printf(2, 3) __cold
1425void _dev_notice(const struct device *dev, const char *fmt, ...);
1426__printf(2, 3) __cold
1427void _dev_info(const struct device *dev, const char *fmt, ...);
1428
1429#else
1430
1431static inline __printf(3, 0)
1432int dev_vprintk_emit(int level, const struct device *dev,
1433 const char *fmt, va_list args)
1434{ return 0; }
1435static inline __printf(3, 4)
1436int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...)
1437{ return 0; }
1438
1439static inline void __dev_printk(const char *level, const struct device *dev,
1440 struct va_format *vaf)
1441{}
1442static inline __printf(3, 4)
1443void dev_printk(const char *level, const struct device *dev,
1444 const char *fmt, ...)
1445{}
1446
1447static inline __printf(2, 3)
1448void _dev_emerg(const struct device *dev, const char *fmt, ...)
1449{}
1450static inline __printf(2, 3)
1451void _dev_crit(const struct device *dev, const char *fmt, ...)
1452{}
1453static inline __printf(2, 3)
1454void _dev_alert(const struct device *dev, const char *fmt, ...)
1455{}
1456static inline __printf(2, 3)
1457void _dev_err(const struct device *dev, const char *fmt, ...)
1458{}
1459static inline __printf(2, 3)
1460void _dev_warn(const struct device *dev, const char *fmt, ...)
1461{}
1462static inline __printf(2, 3)
1463void _dev_notice(const struct device *dev, const char *fmt, ...)
1464{}
1465static inline __printf(2, 3)
1466void _dev_info(const struct device *dev, const char *fmt, ...)
1467{}
1468
1469#endif
1470
1471
1472
1473
1474
1475
1476#define dev_emerg(dev, fmt, ...) \
1477 _dev_emerg(dev, dev_fmt(fmt), ##__VA_ARGS__)
1478#define dev_crit(dev, fmt, ...) \
1479 _dev_crit(dev, dev_fmt(fmt), ##__VA_ARGS__)
1480#define dev_alert(dev, fmt, ...) \
1481 _dev_alert(dev, dev_fmt(fmt), ##__VA_ARGS__)
1482#define dev_err(dev, fmt, ...) \
1483 _dev_err(dev, dev_fmt(fmt), ##__VA_ARGS__)
1484#define dev_warn(dev, fmt, ...) \
1485 _dev_warn(dev, dev_fmt(fmt), ##__VA_ARGS__)
1486#define dev_notice(dev, fmt, ...) \
1487 _dev_notice(dev, dev_fmt(fmt), ##__VA_ARGS__)
1488#define dev_info(dev, fmt, ...) \
1489 _dev_info(dev, dev_fmt(fmt), ##__VA_ARGS__)
1490
1491#if defined(CONFIG_DYNAMIC_DEBUG)
1492#define dev_dbg(dev, fmt, ...) \
1493 dynamic_dev_dbg(dev, dev_fmt(fmt), ##__VA_ARGS__)
1494#elif defined(DEBUG)
1495#define dev_dbg(dev, fmt, ...) \
1496 dev_printk(KERN_DEBUG, dev, dev_fmt(fmt), ##__VA_ARGS__)
1497#else
1498#define dev_dbg(dev, fmt, ...) \
1499({ \
1500 if (0) \
1501 dev_printk(KERN_DEBUG, dev, dev_fmt(fmt), ##__VA_ARGS__); \
1502})
1503#endif
1504
1505#ifdef CONFIG_PRINTK
1506#define dev_level_once(dev_level, dev, fmt, ...) \
1507do { \
1508 static bool __print_once __read_mostly; \
1509 \
1510 if (!__print_once) { \
1511 __print_once = true; \
1512 dev_level(dev, fmt, ##__VA_ARGS__); \
1513 } \
1514} while (0)
1515#else
1516#define dev_level_once(dev_level, dev, fmt, ...) \
1517do { \
1518 if (0) \
1519 dev_level(dev, fmt, ##__VA_ARGS__); \
1520} while (0)
1521#endif
1522
1523#define dev_emerg_once(dev, fmt, ...) \
1524 dev_level_once(dev_emerg, dev, fmt, ##__VA_ARGS__)
1525#define dev_alert_once(dev, fmt, ...) \
1526 dev_level_once(dev_alert, dev, fmt, ##__VA_ARGS__)
1527#define dev_crit_once(dev, fmt, ...) \
1528 dev_level_once(dev_crit, dev, fmt, ##__VA_ARGS__)
1529#define dev_err_once(dev, fmt, ...) \
1530 dev_level_once(dev_err, dev, fmt, ##__VA_ARGS__)
1531#define dev_warn_once(dev, fmt, ...) \
1532 dev_level_once(dev_warn, dev, fmt, ##__VA_ARGS__)
1533#define dev_notice_once(dev, fmt, ...) \
1534 dev_level_once(dev_notice, dev, fmt, ##__VA_ARGS__)
1535#define dev_info_once(dev, fmt, ...) \
1536 dev_level_once(dev_info, dev, fmt, ##__VA_ARGS__)
1537#define dev_dbg_once(dev, fmt, ...) \
1538 dev_level_once(dev_dbg, dev, fmt, ##__VA_ARGS__)
1539
1540#define dev_level_ratelimited(dev_level, dev, fmt, ...) \
1541do { \
1542 static DEFINE_RATELIMIT_STATE(_rs, \
1543 DEFAULT_RATELIMIT_INTERVAL, \
1544 DEFAULT_RATELIMIT_BURST); \
1545 if (__ratelimit(&_rs)) \
1546 dev_level(dev, fmt, ##__VA_ARGS__); \
1547} while (0)
1548
1549#define dev_emerg_ratelimited(dev, fmt, ...) \
1550 dev_level_ratelimited(dev_emerg, dev, fmt, ##__VA_ARGS__)
1551#define dev_alert_ratelimited(dev, fmt, ...) \
1552 dev_level_ratelimited(dev_alert, dev, fmt, ##__VA_ARGS__)
1553#define dev_crit_ratelimited(dev, fmt, ...) \
1554 dev_level_ratelimited(dev_crit, dev, fmt, ##__VA_ARGS__)
1555#define dev_err_ratelimited(dev, fmt, ...) \
1556 dev_level_ratelimited(dev_err, dev, fmt, ##__VA_ARGS__)
1557#define dev_warn_ratelimited(dev, fmt, ...) \
1558 dev_level_ratelimited(dev_warn, dev, fmt, ##__VA_ARGS__)
1559#define dev_notice_ratelimited(dev, fmt, ...) \
1560 dev_level_ratelimited(dev_notice, dev, fmt, ##__VA_ARGS__)
1561#define dev_info_ratelimited(dev, fmt, ...) \
1562 dev_level_ratelimited(dev_info, dev, fmt, ##__VA_ARGS__)
1563#if defined(CONFIG_DYNAMIC_DEBUG)
1564
1565#define dev_dbg_ratelimited(dev, fmt, ...) \
1566do { \
1567 static DEFINE_RATELIMIT_STATE(_rs, \
1568 DEFAULT_RATELIMIT_INTERVAL, \
1569 DEFAULT_RATELIMIT_BURST); \
1570 DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, fmt); \
1571 if (DYNAMIC_DEBUG_BRANCH(descriptor) && \
1572 __ratelimit(&_rs)) \
1573 __dynamic_dev_dbg(&descriptor, dev, dev_fmt(fmt), \
1574 ##__VA_ARGS__); \
1575} while (0)
1576#elif defined(DEBUG)
1577#define dev_dbg_ratelimited(dev, fmt, ...) \
1578do { \
1579 static DEFINE_RATELIMIT_STATE(_rs, \
1580 DEFAULT_RATELIMIT_INTERVAL, \
1581 DEFAULT_RATELIMIT_BURST); \
1582 if (__ratelimit(&_rs)) \
1583 dev_printk(KERN_DEBUG, dev, dev_fmt(fmt), ##__VA_ARGS__); \
1584} while (0)
1585#else
1586#define dev_dbg_ratelimited(dev, fmt, ...) \
1587do { \
1588 if (0) \
1589 dev_printk(KERN_DEBUG, dev, dev_fmt(fmt), ##__VA_ARGS__); \
1590} while (0)
1591#endif
1592
1593#ifdef VERBOSE_DEBUG
1594#define dev_vdbg dev_dbg
1595#else
1596#define dev_vdbg(dev, fmt, ...) \
1597({ \
1598 if (0) \
1599 dev_printk(KERN_DEBUG, dev, dev_fmt(fmt), ##__VA_ARGS__); \
1600})
1601#endif
1602
1603
1604
1605
1606
1607#define dev_WARN(dev, format, arg...) \
1608 WARN(1, "%s %s: " format, dev_driver_string(dev), dev_name(dev), ## arg);
1609
1610#define dev_WARN_ONCE(dev, condition, format, arg...) \
1611 WARN_ONCE(condition, "%s %s: " format, \
1612 dev_driver_string(dev), dev_name(dev), ## arg)
1613
1614
1615#define MODULE_ALIAS_CHARDEV(major,minor) \
1616 MODULE_ALIAS("char-major-" __stringify(major) "-" __stringify(minor))
1617#define MODULE_ALIAS_CHARDEV_MAJOR(major) \
1618 MODULE_ALIAS("char-major-" __stringify(major) "-*")
1619
1620#ifdef CONFIG_SYSFS_DEPRECATED
1621extern long sysfs_deprecated;
1622#else
1623#define sysfs_deprecated 0
1624#endif
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640#define module_driver(__driver, __register, __unregister, ...) \
1641static int __init __driver##_init(void) \
1642{ \
1643 return __register(&(__driver) , ##__VA_ARGS__); \
1644} \
1645module_init(__driver##_init); \
1646static void __exit __driver##_exit(void) \
1647{ \
1648 __unregister(&(__driver) , ##__VA_ARGS__); \
1649} \
1650module_exit(__driver##_exit);
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667#define builtin_driver(__driver, __register, ...) \
1668static int __init __driver##_init(void) \
1669{ \
1670 return __register(&(__driver) , ##__VA_ARGS__); \
1671} \
1672device_initcall(__driver##_init);
1673
1674#endif
1675