1
2
3
4
5
6
7
8
9
10
11
12
13#ifndef _DEVICE_H_
14#define _DEVICE_H_
15
16#include <linux/ioport.h>
17#include <linux/kobject.h>
18#include <linux/klist.h>
19#include <linux/list.h>
20#include <linux/lockdep.h>
21#include <linux/compiler.h>
22#include <linux/types.h>
23#include <linux/module.h>
24#include <linux/pm.h>
25#include <asm/atomic.h>
26#include <asm/device.h>
27
28struct device;
29struct device_private;
30struct device_driver;
31struct driver_private;
32struct class;
33struct subsys_private;
34struct bus_type;
35struct device_node;
36
37struct bus_attribute {
38 struct attribute attr;
39 ssize_t (*show)(struct bus_type *bus, char *buf);
40 ssize_t (*store)(struct bus_type *bus, const char *buf, size_t count);
41};
42
43#define BUS_ATTR(_name, _mode, _show, _store) \
44struct bus_attribute bus_attr_##_name = __ATTR(_name, _mode, _show, _store)
45
46extern int __must_check bus_create_file(struct bus_type *,
47 struct bus_attribute *);
48extern void bus_remove_file(struct bus_type *, struct bus_attribute *);
49
50struct bus_type {
51 const char *name;
52 struct bus_attribute *bus_attrs;
53 struct device_attribute *dev_attrs;
54 struct driver_attribute *drv_attrs;
55
56 int (*match)(struct device *dev, struct device_driver *drv);
57 int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
58 int (*probe)(struct device *dev);
59 int (*remove)(struct device *dev);
60 void (*shutdown)(struct device *dev);
61
62 int (*suspend)(struct device *dev, pm_message_t state);
63 int (*resume)(struct device *dev);
64
65 const struct dev_pm_ops *pm;
66
67 struct subsys_private *p;
68};
69
70extern int __must_check bus_register(struct bus_type *bus);
71extern void bus_unregister(struct bus_type *bus);
72
73extern int __must_check bus_rescan_devices(struct bus_type *bus);
74
75
76
77int bus_for_each_dev(struct bus_type *bus, struct device *start, void *data,
78 int (*fn)(struct device *dev, void *data));
79struct device *bus_find_device(struct bus_type *bus, struct device *start,
80 void *data,
81 int (*match)(struct device *dev, void *data));
82struct device *bus_find_device_by_name(struct bus_type *bus,
83 struct device *start,
84 const char *name);
85
86int bus_for_each_drv(struct bus_type *bus, struct device_driver *start,
87 void *data, int (*fn)(struct device_driver *, void *));
88
89void bus_sort_breadthfirst(struct bus_type *bus,
90 int (*compare)(const struct device *a,
91 const struct device *b));
92
93
94
95
96
97
98struct notifier_block;
99
100extern int bus_register_notifier(struct bus_type *bus,
101 struct notifier_block *nb);
102extern int bus_unregister_notifier(struct bus_type *bus,
103 struct notifier_block *nb);
104
105
106
107
108
109#define BUS_NOTIFY_ADD_DEVICE 0x00000001
110#define BUS_NOTIFY_DEL_DEVICE 0x00000002
111#define BUS_NOTIFY_BIND_DRIVER 0x00000003
112
113#define BUS_NOTIFY_BOUND_DRIVER 0x00000004
114#define BUS_NOTIFY_UNBIND_DRIVER 0x00000005
115
116#define BUS_NOTIFY_UNBOUND_DRIVER 0x00000006
117
118
119extern struct kset *bus_get_kset(struct bus_type *bus);
120extern struct klist *bus_get_device_klist(struct bus_type *bus);
121
122struct device_driver {
123 const char *name;
124 struct bus_type *bus;
125
126 struct module *owner;
127 const char *mod_name;
128
129 bool suppress_bind_attrs;
130
131#if defined(CONFIG_OF)
132 const struct of_device_id *of_match_table;
133#endif
134
135 int (*probe) (struct device *dev);
136 int (*remove) (struct device *dev);
137 void (*shutdown) (struct device *dev);
138 int (*suspend) (struct device *dev, pm_message_t state);
139 int (*resume) (struct device *dev);
140 const struct attribute_group **groups;
141
142 const struct dev_pm_ops *pm;
143
144 struct driver_private *p;
145};
146
147
148extern int __must_check driver_register(struct device_driver *drv);
149extern void driver_unregister(struct device_driver *drv);
150
151extern struct device_driver *get_driver(struct device_driver *drv);
152extern void put_driver(struct device_driver *drv);
153extern struct device_driver *driver_find(const char *name,
154 struct bus_type *bus);
155extern int driver_probe_done(void);
156extern void wait_for_device_probe(void);
157
158
159
160
161struct driver_attribute {
162 struct attribute attr;
163 ssize_t (*show)(struct device_driver *driver, char *buf);
164 ssize_t (*store)(struct device_driver *driver, const char *buf,
165 size_t count);
166};
167
168#define DRIVER_ATTR(_name, _mode, _show, _store) \
169struct driver_attribute driver_attr_##_name = \
170 __ATTR(_name, _mode, _show, _store)
171
172extern int __must_check driver_create_file(struct device_driver *driver,
173 const struct driver_attribute *attr);
174extern void driver_remove_file(struct device_driver *driver,
175 const struct driver_attribute *attr);
176
177extern int __must_check driver_add_kobj(struct device_driver *drv,
178 struct kobject *kobj,
179 const char *fmt, ...);
180
181extern int __must_check driver_for_each_device(struct device_driver *drv,
182 struct device *start,
183 void *data,
184 int (*fn)(struct device *dev,
185 void *));
186struct device *driver_find_device(struct device_driver *drv,
187 struct device *start, void *data,
188 int (*match)(struct device *dev, void *data));
189
190
191
192
193struct class {
194 const char *name;
195 struct module *owner;
196
197 struct class_attribute *class_attrs;
198 struct device_attribute *dev_attrs;
199 struct bin_attribute *dev_bin_attrs;
200 struct kobject *dev_kobj;
201
202 int (*dev_uevent)(struct device *dev, struct kobj_uevent_env *env);
203 char *(*devnode)(struct device *dev, mode_t *mode);
204
205 void (*class_release)(struct class *class);
206 void (*dev_release)(struct device *dev);
207
208 int (*suspend)(struct device *dev, pm_message_t state);
209 int (*resume)(struct device *dev);
210
211 const struct kobj_ns_type_operations *ns_type;
212 const void *(*namespace)(struct device *dev);
213
214 const struct dev_pm_ops *pm;
215
216 struct subsys_private *p;
217};
218
219struct class_dev_iter {
220 struct klist_iter ki;
221 const struct device_type *type;
222};
223
224extern struct kobject *sysfs_dev_block_kobj;
225extern struct kobject *sysfs_dev_char_kobj;
226extern int __must_check __class_register(struct class *class,
227 struct lock_class_key *key);
228extern void class_unregister(struct class *class);
229
230
231
232#define class_register(class) \
233({ \
234 static struct lock_class_key __key; \
235 __class_register(class, &__key); \
236})
237
238struct class_compat;
239struct class_compat *class_compat_register(const char *name);
240void class_compat_unregister(struct class_compat *cls);
241int class_compat_create_link(struct class_compat *cls, struct device *dev,
242 struct device *device_link);
243void class_compat_remove_link(struct class_compat *cls, struct device *dev,
244 struct device *device_link);
245
246extern void class_dev_iter_init(struct class_dev_iter *iter,
247 struct class *class,
248 struct device *start,
249 const struct device_type *type);
250extern struct device *class_dev_iter_next(struct class_dev_iter *iter);
251extern void class_dev_iter_exit(struct class_dev_iter *iter);
252
253extern int class_for_each_device(struct class *class, struct device *start,
254 void *data,
255 int (*fn)(struct device *dev, void *data));
256extern struct device *class_find_device(struct class *class,
257 struct device *start, void *data,
258 int (*match)(struct device *, void *));
259
260struct class_attribute {
261 struct attribute attr;
262 ssize_t (*show)(struct class *class, struct class_attribute *attr,
263 char *buf);
264 ssize_t (*store)(struct class *class, struct class_attribute *attr,
265 const char *buf, size_t count);
266};
267
268#define CLASS_ATTR(_name, _mode, _show, _store) \
269struct class_attribute class_attr_##_name = __ATTR(_name, _mode, _show, _store)
270
271extern int __must_check class_create_file(struct class *class,
272 const struct class_attribute *attr);
273extern void class_remove_file(struct class *class,
274 const struct class_attribute *attr);
275
276
277
278struct class_attribute_string {
279 struct class_attribute attr;
280 char *str;
281};
282
283
284#define _CLASS_ATTR_STRING(_name, _mode, _str) \
285 { __ATTR(_name, _mode, show_class_attr_string, NULL), _str }
286#define CLASS_ATTR_STRING(_name, _mode, _str) \
287 struct class_attribute_string class_attr_##_name = \
288 _CLASS_ATTR_STRING(_name, _mode, _str)
289
290extern ssize_t show_class_attr_string(struct class *class, struct class_attribute *attr,
291 char *buf);
292
293struct class_interface {
294 struct list_head node;
295 struct class *class;
296
297 int (*add_dev) (struct device *, struct class_interface *);
298 void (*remove_dev) (struct device *, struct class_interface *);
299};
300
301extern int __must_check class_interface_register(struct class_interface *);
302extern void class_interface_unregister(struct class_interface *);
303
304extern struct class * __must_check __class_create(struct module *owner,
305 const char *name,
306 struct lock_class_key *key);
307extern void class_destroy(struct class *cls);
308
309
310
311#define class_create(owner, name) \
312({ \
313 static struct lock_class_key __key; \
314 __class_create(owner, name, &__key); \
315})
316
317
318
319
320
321
322
323
324
325
326struct device_type {
327 const char *name;
328 const struct attribute_group **groups;
329 int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
330 char *(*devnode)(struct device *dev, mode_t *mode);
331 void (*release)(struct device *dev);
332
333 const struct dev_pm_ops *pm;
334};
335
336
337struct device_attribute {
338 struct attribute attr;
339 ssize_t (*show)(struct device *dev, struct device_attribute *attr,
340 char *buf);
341 ssize_t (*store)(struct device *dev, struct device_attribute *attr,
342 const char *buf, size_t count);
343};
344
345#define DEVICE_ATTR(_name, _mode, _show, _store) \
346struct device_attribute dev_attr_##_name = __ATTR(_name, _mode, _show, _store)
347
348extern int __must_check device_create_file(struct device *device,
349 const struct device_attribute *entry);
350extern void device_remove_file(struct device *dev,
351 const struct device_attribute *attr);
352extern int __must_check device_create_bin_file(struct device *dev,
353 const struct bin_attribute *attr);
354extern void device_remove_bin_file(struct device *dev,
355 const struct bin_attribute *attr);
356extern int device_schedule_callback_owner(struct device *dev,
357 void (*func)(struct device *dev), struct module *owner);
358
359
360#define device_schedule_callback(dev, func) \
361 device_schedule_callback_owner(dev, func, THIS_MODULE)
362
363
364typedef void (*dr_release_t)(struct device *dev, void *res);
365typedef int (*dr_match_t)(struct device *dev, void *res, void *match_data);
366
367#ifdef CONFIG_DEBUG_DEVRES
368extern void *__devres_alloc(dr_release_t release, size_t size, gfp_t gfp,
369 const char *name);
370#define devres_alloc(release, size, gfp) \
371 __devres_alloc(release, size, gfp, #release)
372#else
373extern void *devres_alloc(dr_release_t release, size_t size, gfp_t gfp);
374#endif
375extern void devres_free(void *res);
376extern void devres_add(struct device *dev, void *res);
377extern void *devres_find(struct device *dev, dr_release_t release,
378 dr_match_t match, void *match_data);
379extern void *devres_get(struct device *dev, void *new_res,
380 dr_match_t match, void *match_data);
381extern void *devres_remove(struct device *dev, dr_release_t release,
382 dr_match_t match, void *match_data);
383extern int devres_destroy(struct device *dev, dr_release_t release,
384 dr_match_t match, void *match_data);
385
386
387extern void * __must_check devres_open_group(struct device *dev, void *id,
388 gfp_t gfp);
389extern void devres_close_group(struct device *dev, void *id);
390extern void devres_remove_group(struct device *dev, void *id);
391extern int devres_release_group(struct device *dev, void *id);
392
393
394extern void *devm_kzalloc(struct device *dev, size_t size, gfp_t gfp);
395extern void devm_kfree(struct device *dev, void *p);
396
397struct device_dma_parameters {
398
399
400
401
402 unsigned int max_segment_size;
403 unsigned long segment_boundary_mask;
404};
405
406struct device {
407 struct device *parent;
408
409 struct device_private *p;
410
411 struct kobject kobj;
412 const char *init_name;
413 struct device_type *type;
414
415 struct mutex mutex;
416
417
418
419 struct bus_type *bus;
420 struct device_driver *driver;
421
422 void *platform_data;
423
424 struct dev_pm_info power;
425
426#ifdef CONFIG_NUMA
427 int numa_node;
428#endif
429 u64 *dma_mask;
430 u64 coherent_dma_mask;
431
432
433
434
435
436 struct device_dma_parameters *dma_parms;
437
438 struct list_head dma_pools;
439
440 struct dma_coherent_mem *dma_mem;
441
442
443 struct dev_archdata archdata;
444#ifdef CONFIG_OF
445 struct device_node *of_node;
446#endif
447
448 dev_t devt;
449
450 spinlock_t devres_lock;
451 struct list_head devres_head;
452
453 struct klist_node knode_class;
454 struct class *class;
455 const struct attribute_group **groups;
456
457 void (*release)(struct device *dev);
458};
459
460
461#include <linux/pm_wakeup.h>
462
463static inline const char *dev_name(const struct device *dev)
464{
465
466 if (dev->init_name)
467 return dev->init_name;
468
469 return kobject_name(&dev->kobj);
470}
471
472extern int dev_set_name(struct device *dev, const char *name, ...)
473 __attribute__((format(printf, 2, 3)));
474
475#ifdef CONFIG_NUMA
476static inline int dev_to_node(struct device *dev)
477{
478 return dev->numa_node;
479}
480static inline void set_dev_node(struct device *dev, int node)
481{
482 dev->numa_node = node;
483}
484#else
485static inline int dev_to_node(struct device *dev)
486{
487 return -1;
488}
489static inline void set_dev_node(struct device *dev, int node)
490{
491}
492#endif
493
494static inline unsigned int dev_get_uevent_suppress(const struct device *dev)
495{
496 return dev->kobj.uevent_suppress;
497}
498
499static inline void dev_set_uevent_suppress(struct device *dev, int val)
500{
501 dev->kobj.uevent_suppress = val;
502}
503
504static inline int device_is_registered(struct device *dev)
505{
506 return dev->kobj.state_in_sysfs;
507}
508
509static inline void device_enable_async_suspend(struct device *dev)
510{
511 if (!dev->power.in_suspend)
512 dev->power.async_suspend = true;
513}
514
515static inline void device_disable_async_suspend(struct device *dev)
516{
517 if (!dev->power.in_suspend)
518 dev->power.async_suspend = false;
519}
520
521static inline bool device_async_suspend_enabled(struct device *dev)
522{
523 return !!dev->power.async_suspend;
524}
525
526static inline void device_lock(struct device *dev)
527{
528 mutex_lock(&dev->mutex);
529}
530
531static inline int device_trylock(struct device *dev)
532{
533 return mutex_trylock(&dev->mutex);
534}
535
536static inline void device_unlock(struct device *dev)
537{
538 mutex_unlock(&dev->mutex);
539}
540
541void driver_init(void);
542
543
544
545
546extern int __must_check device_register(struct device *dev);
547extern void device_unregister(struct device *dev);
548extern void device_initialize(struct device *dev);
549extern int __must_check device_add(struct device *dev);
550extern void device_del(struct device *dev);
551extern int device_for_each_child(struct device *dev, void *data,
552 int (*fn)(struct device *dev, void *data));
553extern struct device *device_find_child(struct device *dev, void *data,
554 int (*match)(struct device *dev, void *data));
555extern int device_rename(struct device *dev, const char *new_name);
556extern int device_move(struct device *dev, struct device *new_parent,
557 enum dpm_order dpm_order);
558extern const char *device_get_devnode(struct device *dev,
559 mode_t *mode, const char **tmp);
560extern void *dev_get_drvdata(const struct device *dev);
561extern void dev_set_drvdata(struct device *dev, void *data);
562
563
564
565
566extern struct device *__root_device_register(const char *name,
567 struct module *owner);
568static inline struct device *root_device_register(const char *name)
569{
570 return __root_device_register(name, THIS_MODULE);
571}
572extern void root_device_unregister(struct device *root);
573
574static inline void *dev_get_platdata(const struct device *dev)
575{
576 return dev->platform_data;
577}
578
579
580
581
582
583extern int __must_check device_bind_driver(struct device *dev);
584extern void device_release_driver(struct device *dev);
585extern int __must_check device_attach(struct device *dev);
586extern int __must_check driver_attach(struct device_driver *drv);
587extern int __must_check device_reprobe(struct device *dev);
588
589
590
591
592extern struct device *device_create_vargs(struct class *cls,
593 struct device *parent,
594 dev_t devt,
595 void *drvdata,
596 const char *fmt,
597 va_list vargs);
598extern struct device *device_create(struct class *cls, struct device *parent,
599 dev_t devt, void *drvdata,
600 const char *fmt, ...)
601 __attribute__((format(printf, 5, 6)));
602extern void device_destroy(struct class *cls, dev_t devt);
603
604
605
606
607
608
609
610extern int (*platform_notify)(struct device *dev);
611
612extern int (*platform_notify_remove)(struct device *dev);
613
614
615
616
617
618
619extern struct device *get_device(struct device *dev);
620extern void put_device(struct device *dev);
621
622extern void wait_for_device_probe(void);
623
624#ifdef CONFIG_DEVTMPFS
625extern int devtmpfs_create_node(struct device *dev);
626extern int devtmpfs_delete_node(struct device *dev);
627extern int devtmpfs_mount(const char *mntdir);
628#else
629static inline int devtmpfs_create_node(struct device *dev) { return 0; }
630static inline int devtmpfs_delete_node(struct device *dev) { return 0; }
631static inline int devtmpfs_mount(const char *mountpoint) { return 0; }
632#endif
633
634
635extern void device_shutdown(void);
636
637
638extern void sysdev_shutdown(void);
639
640
641extern const char *dev_driver_string(const struct device *dev);
642
643
644#ifdef CONFIG_PRINTK
645
646extern int dev_printk(const char *level, const struct device *dev,
647 const char *fmt, ...)
648 __attribute__ ((format (printf, 3, 4)));
649extern int dev_emerg(const struct device *dev, const char *fmt, ...)
650 __attribute__ ((format (printf, 2, 3)));
651extern int dev_alert(const struct device *dev, const char *fmt, ...)
652 __attribute__ ((format (printf, 2, 3)));
653extern int dev_crit(const struct device *dev, const char *fmt, ...)
654 __attribute__ ((format (printf, 2, 3)));
655extern int dev_err(const struct device *dev, const char *fmt, ...)
656 __attribute__ ((format (printf, 2, 3)));
657extern int dev_warn(const struct device *dev, const char *fmt, ...)
658 __attribute__ ((format (printf, 2, 3)));
659extern int dev_notice(const struct device *dev, const char *fmt, ...)
660 __attribute__ ((format (printf, 2, 3)));
661extern int _dev_info(const struct device *dev, const char *fmt, ...)
662 __attribute__ ((format (printf, 2, 3)));
663
664#else
665
666static inline int dev_printk(const char *level, const struct device *dev,
667 const char *fmt, ...)
668 __attribute__ ((format (printf, 3, 4)));
669static inline int dev_printk(const char *level, const struct device *dev,
670 const char *fmt, ...)
671 { return 0; }
672
673static inline int dev_emerg(const struct device *dev, const char *fmt, ...)
674 __attribute__ ((format (printf, 2, 3)));
675static inline int dev_emerg(const struct device *dev, const char *fmt, ...)
676 { return 0; }
677static inline int dev_crit(const struct device *dev, const char *fmt, ...)
678 __attribute__ ((format (printf, 2, 3)));
679static inline int dev_crit(const struct device *dev, const char *fmt, ...)
680 { return 0; }
681static inline int dev_alert(const struct device *dev, const char *fmt, ...)
682 __attribute__ ((format (printf, 2, 3)));
683static inline int dev_alert(const struct device *dev, const char *fmt, ...)
684 { return 0; }
685static inline int dev_err(const struct device *dev, const char *fmt, ...)
686 __attribute__ ((format (printf, 2, 3)));
687static inline int dev_err(const struct device *dev, const char *fmt, ...)
688 { return 0; }
689static inline int dev_warn(const struct device *dev, const char *fmt, ...)
690 __attribute__ ((format (printf, 2, 3)));
691static inline int dev_warn(const struct device *dev, const char *fmt, ...)
692 { return 0; }
693static inline int dev_notice(const struct device *dev, const char *fmt, ...)
694 __attribute__ ((format (printf, 2, 3)));
695static inline int dev_notice(const struct device *dev, const char *fmt, ...)
696 { return 0; }
697static inline int _dev_info(const struct device *dev, const char *fmt, ...)
698 __attribute__ ((format (printf, 2, 3)));
699static inline int _dev_info(const struct device *dev, const char *fmt, ...)
700 { return 0; }
701
702#endif
703
704
705
706
707
708
709
710
711#define dev_info(dev, fmt, arg...) _dev_info(dev, fmt, ##arg)
712
713#if defined(DEBUG)
714#define dev_dbg(dev, format, arg...) \
715 dev_printk(KERN_DEBUG, dev, format, ##arg)
716#elif defined(CONFIG_DYNAMIC_DEBUG)
717#define dev_dbg(dev, format, ...) \
718do { \
719 dynamic_dev_dbg(dev, format, ##__VA_ARGS__); \
720} while (0)
721#else
722#define dev_dbg(dev, format, arg...) \
723({ \
724 if (0) \
725 dev_printk(KERN_DEBUG, dev, format, ##arg); \
726 0; \
727})
728#endif
729
730#ifdef VERBOSE_DEBUG
731#define dev_vdbg dev_dbg
732#else
733#define dev_vdbg(dev, format, arg...) \
734({ \
735 if (0) \
736 dev_printk(KERN_DEBUG, dev, format, ##arg); \
737 0; \
738})
739#endif
740
741
742
743
744
745
746#define dev_WARN(dev, format, arg...) \
747 WARN(1, "Device: %s\n" format, dev_driver_string(dev), ## arg);
748
749
750#define MODULE_ALIAS_CHARDEV(major,minor) \
751 MODULE_ALIAS("char-major-" __stringify(major) "-" __stringify(minor))
752#define MODULE_ALIAS_CHARDEV_MAJOR(major) \
753 MODULE_ALIAS("char-major-" __stringify(major) "-*")
754
755#ifdef CONFIG_SYSFS_DEPRECATED
756extern long sysfs_deprecated;
757#else
758#define sysfs_deprecated 0
759#endif
760
761#endif
762