Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
1/*
2 * device.h - generic, centralized driver model
3 *
4 * Copyright (c) 2001-2003 Patrick Mochel <mochel@osdl.org>
5 * Copyright (c) 2004-2009 Greg Kroah-Hartman <gregkh@suse.de>
6 * Copyright (c) 2008-2009 Novell Inc.
7 *
8 * This file is released under the GPLv2
9 *
10 * See Documentation/driver-model/ for more information.
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 <linux/semaphore.h>
26#include <asm/atomic.h>
27#include <asm/device.h>
28
29struct device;
30struct device_private;
31struct device_driver;
32struct driver_private;
33struct class;
34struct class_private;
35struct bus_type;
36struct bus_type_private;
37
38struct bus_attribute {
39 struct attribute attr;
40 ssize_t (*show)(struct bus_type *bus, char *buf);
41 ssize_t (*store)(struct bus_type *bus, const char *buf, size_t count);
42};
43
44#define BUS_ATTR(_name, _mode, _show, _store) \
45struct bus_attribute bus_attr_##_name = __ATTR(_name, _mode, _show, _store)
46
47extern int __must_check bus_create_file(struct bus_type *,
48 struct bus_attribute *);
49extern void bus_remove_file(struct bus_type *, struct bus_attribute *);
50
51struct bus_type {
52 const char *name;
53 struct bus_attribute *bus_attrs;
54 struct device_attribute *dev_attrs;
55 struct driver_attribute *drv_attrs;
56
57 int (*match)(struct device *dev, struct device_driver *drv);
58 int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
59 int (*probe)(struct device *dev);
60 int (*remove)(struct device *dev);
61 void (*shutdown)(struct device *dev);
62
63 int (*suspend)(struct device *dev, pm_message_t state);
64 int (*resume)(struct device *dev);
65
66 const struct dev_pm_ops *pm;
67
68 struct bus_type_private *p;
69};
70
71extern int __must_check bus_register(struct bus_type *bus);
72extern void bus_unregister(struct bus_type *bus);
73
74extern int __must_check bus_rescan_devices(struct bus_type *bus);
75
76/* iterator helpers for buses */
77
78int bus_for_each_dev(struct bus_type *bus, struct device *start, void *data,
79 int (*fn)(struct device *dev, void *data));
80struct device *bus_find_device(struct bus_type *bus, struct device *start,
81 void *data,
82 int (*match)(struct device *dev, void *data));
83struct device *bus_find_device_by_name(struct bus_type *bus,
84 struct device *start,
85 const char *name);
86
87int __must_check bus_for_each_drv(struct bus_type *bus,
88 struct device_driver *start, void *data,
89 int (*fn)(struct device_driver *, void *));
90
91void bus_sort_breadthfirst(struct bus_type *bus,
92 int (*compare)(const struct device *a,
93 const struct device *b));
94/*
95 * Bus notifiers: Get notified of addition/removal of devices
96 * and binding/unbinding of drivers to devices.
97 * In the long run, it should be a replacement for the platform
98 * notify hooks.
99 */
100struct notifier_block;
101
102extern int bus_register_notifier(struct bus_type *bus,
103 struct notifier_block *nb);
104extern int bus_unregister_notifier(struct bus_type *bus,
105 struct notifier_block *nb);
106
107/* All 4 notifers below get called with the target struct device *
108 * as an argument. Note that those functions are likely to be called
109 * with the device semaphore held in the core, so be careful.
110 */
111#define BUS_NOTIFY_ADD_DEVICE 0x00000001 /* device added */
112#define BUS_NOTIFY_DEL_DEVICE 0x00000002 /* device removed */
113#define BUS_NOTIFY_BOUND_DRIVER 0x00000003 /* driver bound to device */
114#define BUS_NOTIFY_UNBIND_DRIVER 0x00000004 /* driver about to be
115 unbound */
116#define BUS_NOTIFY_UNBOUND_DRIVER 0x00000005 /* driver is unbound
117 from the device */
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; /* used for built-in modules */
128
129 int (*probe) (struct device *dev);
130 int (*remove) (struct device *dev);
131 void (*shutdown) (struct device *dev);
132 int (*suspend) (struct device *dev, pm_message_t state);
133 int (*resume) (struct device *dev);
134 const struct attribute_group **groups;
135
136 const struct dev_pm_ops *pm;
137
138 struct driver_private *p;
139};
140
141
142extern int __must_check driver_register(struct device_driver *drv);
143extern void driver_unregister(struct device_driver *drv);
144
145extern struct device_driver *get_driver(struct device_driver *drv);
146extern void put_driver(struct device_driver *drv);
147extern struct device_driver *driver_find(const char *name,
148 struct bus_type *bus);
149extern int driver_probe_done(void);
150extern void wait_for_device_probe(void);
151
152
153/* sysfs interface for exporting driver attributes */
154
155struct driver_attribute {
156 struct attribute attr;
157 ssize_t (*show)(struct device_driver *driver, char *buf);
158 ssize_t (*store)(struct device_driver *driver, const char *buf,
159 size_t count);
160};
161
162#define DRIVER_ATTR(_name, _mode, _show, _store) \
163struct driver_attribute driver_attr_##_name = \
164 __ATTR(_name, _mode, _show, _store)
165
166extern int __must_check driver_create_file(struct device_driver *driver,
167 struct driver_attribute *attr);
168extern void driver_remove_file(struct device_driver *driver,
169 struct driver_attribute *attr);
170
171extern int __must_check driver_add_kobj(struct device_driver *drv,
172 struct kobject *kobj,
173 const char *fmt, ...);
174
175extern int __must_check driver_for_each_device(struct device_driver *drv,
176 struct device *start,
177 void *data,
178 int (*fn)(struct device *dev,
179 void *));
180struct device *driver_find_device(struct device_driver *drv,
181 struct device *start, void *data,
182 int (*match)(struct device *dev, void *data));
183
184/*
185 * device classes
186 */
187struct class {
188 const char *name;
189 struct module *owner;
190
191 struct class_attribute *class_attrs;
192 struct device_attribute *dev_attrs;
193 struct kobject *dev_kobj;
194
195 int (*dev_uevent)(struct device *dev, struct kobj_uevent_env *env);
196 char *(*devnode)(struct device *dev, mode_t *mode);
197
198 void (*class_release)(struct class *class);
199 void (*dev_release)(struct device *dev);
200
201 int (*suspend)(struct device *dev, pm_message_t state);
202 int (*resume)(struct device *dev);
203
204 const struct dev_pm_ops *pm;
205
206 struct class_private *p;
207};
208
209struct class_dev_iter {
210 struct klist_iter ki;
211 const struct device_type *type;
212};
213
214extern struct kobject *sysfs_dev_block_kobj;
215extern struct kobject *sysfs_dev_char_kobj;
216extern int __must_check __class_register(struct class *class,
217 struct lock_class_key *key);
218extern void class_unregister(struct class *class);
219
220/* This is a #define to keep the compiler from merging different
221 * instances of the __key variable */
222#define class_register(class) \
223({ \
224 static struct lock_class_key __key; \
225 __class_register(class, &__key); \
226})
227
228struct class_compat;
229struct class_compat *class_compat_register(const char *name);
230void class_compat_unregister(struct class_compat *cls);
231int class_compat_create_link(struct class_compat *cls, struct device *dev,
232 struct device *device_link);
233void class_compat_remove_link(struct class_compat *cls, struct device *dev,
234 struct device *device_link);
235
236extern void class_dev_iter_init(struct class_dev_iter *iter,
237 struct class *class,
238 struct device *start,
239 const struct device_type *type);
240extern struct device *class_dev_iter_next(struct class_dev_iter *iter);
241extern void class_dev_iter_exit(struct class_dev_iter *iter);
242
243extern int class_for_each_device(struct class *class, struct device *start,
244 void *data,
245 int (*fn)(struct device *dev, void *data));
246extern struct device *class_find_device(struct class *class,
247 struct device *start, void *data,
248 int (*match)(struct device *, void *));
249
250struct class_attribute {
251 struct attribute attr;
252 ssize_t (*show)(struct class *class, char *buf);
253 ssize_t (*store)(struct class *class, const char *buf, size_t count);
254};
255
256#define CLASS_ATTR(_name, _mode, _show, _store) \
257struct class_attribute class_attr_##_name = __ATTR(_name, _mode, _show, _store)
258
259extern int __must_check class_create_file(struct class *class,
260 const struct class_attribute *attr);
261extern void class_remove_file(struct class *class,
262 const struct class_attribute *attr);
263
264struct class_interface {
265 struct list_head node;
266 struct class *class;
267
268 int (*add_dev) (struct device *, struct class_interface *);
269 void (*remove_dev) (struct device *, struct class_interface *);
270};
271
272extern int __must_check class_interface_register(struct class_interface *);
273extern void class_interface_unregister(struct class_interface *);
274
275extern struct class * __must_check __class_create(struct module *owner,
276 const char *name,
277 struct lock_class_key *key);
278extern void class_destroy(struct class *cls);
279
280/* This is a #define to keep the compiler from merging different
281 * instances of the __key variable */
282#define class_create(owner, name) \
283({ \
284 static struct lock_class_key __key; \
285 __class_create(owner, name, &__key); \
286})
287
288/*
289 * The type of device, "struct device" is embedded in. A class
290 * or bus can contain devices of different types
291 * like "partitions" and "disks", "mouse" and "event".
292 * This identifies the device type and carries type-specific
293 * information, equivalent to the kobj_type of a kobject.
294 * If "name" is specified, the uevent will contain it in
295 * the DEVTYPE variable.
296 */
297struct device_type {
298 const char *name;
299 const struct attribute_group **groups;
300 int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
301 char *(*devnode)(struct device *dev, mode_t *mode);
302 void (*release)(struct device *dev);
303
304 const struct dev_pm_ops *pm;
305};
306
307/* interface for exporting device attributes */
308struct device_attribute {
309 struct attribute attr;
310 ssize_t (*show)(struct device *dev, struct device_attribute *attr,
311 char *buf);
312 ssize_t (*store)(struct device *dev, struct device_attribute *attr,
313 const char *buf, size_t count);
314};
315
316#define DEVICE_ATTR(_name, _mode, _show, _store) \
317struct device_attribute dev_attr_##_name = __ATTR(_name, _mode, _show, _store)
318
319extern int __must_check device_create_file(struct device *device,
320 struct device_attribute *entry);
321extern void device_remove_file(struct device *dev,
322 struct device_attribute *attr);
323extern int __must_check device_create_bin_file(struct device *dev,
324 struct bin_attribute *attr);
325extern void device_remove_bin_file(struct device *dev,
326 struct bin_attribute *attr);
327extern int device_schedule_callback_owner(struct device *dev,
328 void (*func)(struct device *dev), struct module *owner);
329
330/* This is a macro to avoid include problems with THIS_MODULE */
331#define device_schedule_callback(dev, func) \
332 device_schedule_callback_owner(dev, func, THIS_MODULE)
333
334/* device resource management */
335typedef void (*dr_release_t)(struct device *dev, void *res);
336typedef int (*dr_match_t)(struct device *dev, void *res, void *match_data);
337
338#ifdef CONFIG_DEBUG_DEVRES
339extern void *__devres_alloc(dr_release_t release, size_t size, gfp_t gfp,
340 const char *name);
341#define devres_alloc(release, size, gfp) \
342 __devres_alloc(release, size, gfp, #release)
343#else
344extern void *devres_alloc(dr_release_t release, size_t size, gfp_t gfp);
345#endif
346extern void devres_free(void *res);
347extern void devres_add(struct device *dev, void *res);
348extern void *devres_find(struct device *dev, dr_release_t release,
349 dr_match_t match, void *match_data);
350extern void *devres_get(struct device *dev, void *new_res,
351 dr_match_t match, void *match_data);
352extern void *devres_remove(struct device *dev, dr_release_t release,
353 dr_match_t match, void *match_data);
354extern int devres_destroy(struct device *dev, dr_release_t release,
355 dr_match_t match, void *match_data);
356
357/* devres group */
358extern void * __must_check devres_open_group(struct device *dev, void *id,
359 gfp_t gfp);
360extern void devres_close_group(struct device *dev, void *id);
361extern void devres_remove_group(struct device *dev, void *id);
362extern int devres_release_group(struct device *dev, void *id);
363
364/* managed kzalloc/kfree for device drivers, no kmalloc, always use kzalloc */
365extern void *devm_kzalloc(struct device *dev, size_t size, gfp_t gfp);
366extern void devm_kfree(struct device *dev, void *p);
367
368struct device_dma_parameters {
369 /*
370 * a low level driver may set these to teach IOMMU code about
371 * sg limitations.
372 */
373 unsigned int max_segment_size;
374 unsigned long segment_boundary_mask;
375};
376
377struct device {
378 struct device *parent;
379
380 struct device_private *p;
381
382 struct kobject kobj;
383 const char *init_name; /* initial name of the device */
384 struct device_type *type;
385
386 struct semaphore sem; /* semaphore to synchronize calls to
387 * its driver.
388 */
389
390 struct bus_type *bus; /* type of bus device is on */
391 struct device_driver *driver; /* which driver has allocated this
392 device */
393 void *platform_data; /* Platform specific data, device
394 core doesn't touch it */
395 struct dev_pm_info power;
396
397#ifdef CONFIG_NUMA
398 int numa_node; /* NUMA node this device is close to */
399#endif
400 u64 *dma_mask; /* dma mask (if dma'able device) */
401 u64 coherent_dma_mask;/* Like dma_mask, but for
402 alloc_coherent mappings as
403 not all hardware supports
404 64 bit addresses for consistent
405 allocations such descriptors. */
406
407 struct device_dma_parameters *dma_parms;
408
409 struct list_head dma_pools; /* dma pools (if dma'ble) */
410
411 struct dma_coherent_mem *dma_mem; /* internal for coherent mem
412 override */
413 /* arch specific additions */
414 struct dev_archdata archdata;
415
416 dev_t devt; /* dev_t, creates the sysfs "dev" */
417
418 spinlock_t devres_lock;
419 struct list_head devres_head;
420
421 struct klist_node knode_class;
422 struct class *class;
423 const struct attribute_group **groups; /* optional groups */
424
425 void (*release)(struct device *dev);
426};
427
428/* Get the wakeup routines, which depend on struct device */
429#include <linux/pm_wakeup.h>
430
431static inline const char *dev_name(const struct device *dev)
432{
433 return kobject_name(&dev->kobj);
434}
435
436extern int dev_set_name(struct device *dev, const char *name, ...)
437 __attribute__((format(printf, 2, 3)));
438
439#ifdef CONFIG_NUMA
440static inline int dev_to_node(struct device *dev)
441{
442 return dev->numa_node;
443}
444static inline void set_dev_node(struct device *dev, int node)
445{
446 dev->numa_node = node;
447}
448#else
449static inline int dev_to_node(struct device *dev)
450{
451 return -1;
452}
453static inline void set_dev_node(struct device *dev, int node)
454{
455}
456#endif
457
458static inline unsigned int dev_get_uevent_suppress(const struct device *dev)
459{
460 return dev->kobj.uevent_suppress;
461}
462
463static inline void dev_set_uevent_suppress(struct device *dev, int val)
464{
465 dev->kobj.uevent_suppress = val;
466}
467
468static inline int device_is_registered(struct device *dev)
469{
470 return dev->kobj.state_in_sysfs;
471}
472
473void driver_init(void);
474
475/*
476 * High level routines for use by the bus drivers
477 */
478extern int __must_check device_register(struct device *dev);
479extern void device_unregister(struct device *dev);
480extern void device_initialize(struct device *dev);
481extern int __must_check device_add(struct device *dev);
482extern void device_del(struct device *dev);
483extern int device_for_each_child(struct device *dev, void *data,
484 int (*fn)(struct device *dev, void *data));
485extern struct device *device_find_child(struct device *dev, void *data,
486 int (*match)(struct device *dev, void *data));
487extern int device_rename(struct device *dev, char *new_name);
488extern int device_move(struct device *dev, struct device *new_parent,
489 enum dpm_order dpm_order);
490extern const char *device_get_devnode(struct device *dev,
491 mode_t *mode, const char **tmp);
492extern void *dev_get_drvdata(const struct device *dev);
493extern void dev_set_drvdata(struct device *dev, void *data);
494
495/*
496 * Root device objects for grouping under /sys/devices
497 */
498extern struct device *__root_device_register(const char *name,
499 struct module *owner);
500static inline struct device *root_device_register(const char *name)
501{
502 return __root_device_register(name, THIS_MODULE);
503}
504extern void root_device_unregister(struct device *root);
505
506static inline void *dev_get_platdata(const struct device *dev)
507{
508 return dev->platform_data;
509}
510
511/*
512 * Manual binding of a device to driver. See drivers/base/bus.c
513 * for information on use.
514 */
515extern int __must_check device_bind_driver(struct device *dev);
516extern void device_release_driver(struct device *dev);
517extern int __must_check device_attach(struct device *dev);
518extern int __must_check driver_attach(struct device_driver *drv);
519extern int __must_check device_reprobe(struct device *dev);
520
521/*
522 * Easy functions for dynamically creating devices on the fly
523 */
524extern struct device *device_create_vargs(struct class *cls,
525 struct device *parent,
526 dev_t devt,
527 void *drvdata,
528 const char *fmt,
529 va_list vargs);
530extern struct device *device_create(struct class *cls, struct device *parent,
531 dev_t devt, void *drvdata,
532 const char *fmt, ...)
533 __attribute__((format(printf, 5, 6)));
534extern void device_destroy(struct class *cls, dev_t devt);
535
536/*
537 * Platform "fixup" functions - allow the platform to have their say
538 * about devices and actions that the general device layer doesn't
539 * know about.
540 */
541/* Notify platform of device discovery */
542extern int (*platform_notify)(struct device *dev);
543
544extern int (*platform_notify_remove)(struct device *dev);
545
546
547/**
548 * get_device - atomically increment the reference count for the device.
549 *
550 */
551extern struct device *get_device(struct device *dev);
552extern void put_device(struct device *dev);
553
554extern void wait_for_device_probe(void);
555
556#ifdef CONFIG_DEVTMPFS
557extern int devtmpfs_create_node(struct device *dev);
558extern int devtmpfs_delete_node(struct device *dev);
559extern int devtmpfs_mount(const char *mountpoint);
560#else
561static inline int devtmpfs_create_node(struct device *dev) { return 0; }
562static inline int devtmpfs_delete_node(struct device *dev) { return 0; }
563static inline int devtmpfs_mount(const char *mountpoint) { return 0; }
564#endif
565
566/* drivers/base/power/shutdown.c */
567extern void device_shutdown(void);
568
569/* drivers/base/sys.c */
570extern void sysdev_shutdown(void);
571
572/* debugging and troubleshooting/diagnostic helpers. */
573extern const char *dev_driver_string(const struct device *dev);
574#define dev_printk(level, dev, format, arg...) \
575 printk(level "%s %s: " format , dev_driver_string(dev) , \
576 dev_name(dev) , ## arg)
577
578#define dev_emerg(dev, format, arg...) \
579 dev_printk(KERN_EMERG , dev , format , ## arg)
580#define dev_alert(dev, format, arg...) \
581 dev_printk(KERN_ALERT , dev , format , ## arg)
582#define dev_crit(dev, format, arg...) \
583 dev_printk(KERN_CRIT , dev , format , ## arg)
584#define dev_err(dev, format, arg...) \
585 dev_printk(KERN_ERR , dev , format , ## arg)
586#define dev_warn(dev, format, arg...) \
587 dev_printk(KERN_WARNING , dev , format , ## arg)
588#define dev_notice(dev, format, arg...) \
589 dev_printk(KERN_NOTICE , dev , format , ## arg)
590#define dev_info(dev, format, arg...) \
591 dev_printk(KERN_INFO , dev , format , ## arg)
592
593#if defined(DEBUG)
594#define dev_dbg(dev, format, arg...) \
595 dev_printk(KERN_DEBUG , dev , format , ## arg)
596#elif defined(CONFIG_DYNAMIC_DEBUG)
597#define dev_dbg(dev, format, ...) do { \
598 dynamic_dev_dbg(dev, format, ##__VA_ARGS__); \
599 } while (0)
600#else
601#define dev_dbg(dev, format, arg...) \
602 ({ if (0) dev_printk(KERN_DEBUG, dev, format, ##arg); 0; })
603#endif
604
605#ifdef VERBOSE_DEBUG
606#define dev_vdbg dev_dbg
607#else
608
609#define dev_vdbg(dev, format, arg...) \
610 ({ if (0) dev_printk(KERN_DEBUG, dev, format, ##arg); 0; })
611#endif
612
613/*
614 * dev_WARN() acts like dev_printk(), but with the key difference
615 * of using a WARN/WARN_ON to get the message out, including the
616 * file/line information and a backtrace.
617 */
618#define dev_WARN(dev, format, arg...) \
619 WARN(1, "Device: %s\n" format, dev_driver_string(dev), ## arg);
620
621/* Create alias, so I can be autoloaded. */
622#define MODULE_ALIAS_CHARDEV(major,minor) \
623 MODULE_ALIAS("char-major-" __stringify(major) "-" __stringify(minor))
624#define MODULE_ALIAS_CHARDEV_MAJOR(major) \
625 MODULE_ALIAS("char-major-" __stringify(major) "-*")
626#endif /* _DEVICE_H_ */