2 * device.h - generic, centralized driver model
4 * Copyright (c) 2001-2003 Patrick Mochel <mochel@osdl.org>
5 * Copyright (c) 2004-2007 Greg Kroah-Hartman <gregkh@suse.de>
7 * This file is released under the GPLv2
9 * See Documentation/driver-model/ for more information.
15 #include <linux/ioport.h>
16 #include <linux/kobject.h>
17 #include <linux/klist.h>
18 #include <linux/list.h>
19 #include <linux/compiler.h>
20 #include <linux/types.h>
21 #include <linux/module.h>
23 #include <asm/semaphore.h>
24 #include <asm/atomic.h>
25 #include <asm/device.h>
27 #define DEVICE_NAME_SIZE 50
28 #define DEVICE_NAME_HALF __stringify(20) /* Less than half to accommodate slop */
29 #define DEVICE_ID_SIZE 32
30 #define BUS_ID_SIZE KOBJ_NAME_LEN
35 struct driver_private
;
39 struct bus_type_private
;
41 struct bus_attribute
{
42 struct attribute attr
;
43 ssize_t (*show
)(struct bus_type
*, char * buf
);
44 ssize_t (*store
)(struct bus_type
*, const char * buf
, size_t count
);
47 #define BUS_ATTR(_name,_mode,_show,_store) \
48 struct bus_attribute bus_attr_##_name = __ATTR(_name,_mode,_show,_store)
50 extern int __must_check
bus_create_file(struct bus_type
*,
51 struct bus_attribute
*);
52 extern void bus_remove_file(struct bus_type
*, struct bus_attribute
*);
56 struct bus_attribute
* bus_attrs
;
57 struct device_attribute
* dev_attrs
;
58 struct driver_attribute
* drv_attrs
;
60 int (*match
)(struct device
* dev
, struct device_driver
* drv
);
61 int (*uevent
)(struct device
*dev
, struct kobj_uevent_env
*env
);
62 int (*probe
)(struct device
* dev
);
63 int (*remove
)(struct device
* dev
);
64 void (*shutdown
)(struct device
* dev
);
66 int (*suspend
)(struct device
* dev
, pm_message_t state
);
67 int (*suspend_late
)(struct device
* dev
, pm_message_t state
);
68 int (*resume_early
)(struct device
* dev
);
69 int (*resume
)(struct device
* dev
);
71 struct bus_type_private
*p
;
74 extern int __must_check
bus_register(struct bus_type
* bus
);
75 extern void bus_unregister(struct bus_type
* bus
);
77 extern int __must_check
bus_rescan_devices(struct bus_type
* bus
);
79 /* iterator helpers for buses */
81 int bus_for_each_dev(struct bus_type
* bus
, struct device
* start
, void * data
,
82 int (*fn
)(struct device
*, void *));
83 struct device
* bus_find_device(struct bus_type
*bus
, struct device
*start
,
84 void *data
, int (*match
)(struct device
*, void *));
86 int __must_check
bus_for_each_drv(struct bus_type
*bus
,
87 struct device_driver
*start
, void *data
,
88 int (*fn
)(struct device_driver
*, void *));
91 * Bus notifiers: Get notified of addition/removal of devices
92 * and binding/unbinding of drivers to devices.
93 * In the long run, it should be a replacement for the platform
96 struct notifier_block
;
98 extern int bus_register_notifier(struct bus_type
*bus
,
99 struct notifier_block
*nb
);
100 extern int bus_unregister_notifier(struct bus_type
*bus
,
101 struct notifier_block
*nb
);
103 /* All 4 notifers below get called with the target struct device *
104 * as an argument. Note that those functions are likely to be called
105 * with the device semaphore held in the core, so be careful.
107 #define BUS_NOTIFY_ADD_DEVICE 0x00000001 /* device added */
108 #define BUS_NOTIFY_DEL_DEVICE 0x00000002 /* device removed */
109 #define BUS_NOTIFY_BOUND_DRIVER 0x00000003 /* driver bound to device */
110 #define BUS_NOTIFY_UNBIND_DRIVER 0x00000004 /* driver about to be
113 extern struct kset
*bus_get_kset(struct bus_type
*bus
);
114 extern struct klist
*bus_get_device_klist(struct bus_type
*bus
);
116 struct device_driver
{
118 struct bus_type
*bus
;
120 struct module
*owner
;
121 const char *mod_name
; /* used for built-in modules */
123 int (*probe
) (struct device
* dev
);
124 int (*remove
) (struct device
* dev
);
125 void (*shutdown
) (struct device
* dev
);
126 int (*suspend
) (struct device
* dev
, pm_message_t state
);
127 int (*resume
) (struct device
* dev
);
128 struct attribute_group
**groups
;
130 struct driver_private
*p
;
134 extern int __must_check
driver_register(struct device_driver
* drv
);
135 extern void driver_unregister(struct device_driver
* drv
);
137 extern struct device_driver
* get_driver(struct device_driver
* drv
);
138 extern void put_driver(struct device_driver
* drv
);
139 extern struct device_driver
*driver_find(const char *name
, struct bus_type
*bus
);
140 extern int driver_probe_done(void);
142 /* sysfs interface for exporting driver attributes */
144 struct driver_attribute
{
145 struct attribute attr
;
146 ssize_t (*show
)(struct device_driver
*, char * buf
);
147 ssize_t (*store
)(struct device_driver
*, const char * buf
, size_t count
);
150 #define DRIVER_ATTR(_name,_mode,_show,_store) \
151 struct driver_attribute driver_attr_##_name = __ATTR(_name,_mode,_show,_store)
153 extern int __must_check
driver_create_file(struct device_driver
*,
154 struct driver_attribute
*);
155 extern void driver_remove_file(struct device_driver
*, struct driver_attribute
*);
157 extern int __must_check
driver_add_kobj(struct device_driver
*drv
,
158 struct kobject
*kobj
,
159 const char *fmt
, ...);
161 extern int __must_check
driver_for_each_device(struct device_driver
* drv
,
162 struct device
*start
, void *data
,
163 int (*fn
)(struct device
*, void *));
164 struct device
* driver_find_device(struct device_driver
*drv
,
165 struct device
*start
, void *data
,
166 int (*match
)(struct device
*, void *));
173 struct module
* owner
;
176 struct list_head children
;
177 struct list_head devices
;
178 struct list_head interfaces
;
179 struct kset class_dirs
;
180 struct semaphore sem
; /* locks both the children and interfaces lists */
182 struct class_attribute
* class_attrs
;
183 struct class_device_attribute
* class_dev_attrs
;
184 struct device_attribute
* dev_attrs
;
186 int (*uevent
)(struct class_device
*dev
, struct kobj_uevent_env
*env
);
187 int (*dev_uevent
)(struct device
*dev
, struct kobj_uevent_env
*env
);
189 void (*release
)(struct class_device
*dev
);
190 void (*class_release
)(struct class *class);
191 void (*dev_release
)(struct device
*dev
);
193 int (*suspend
)(struct device
*, pm_message_t state
);
194 int (*resume
)(struct device
*);
197 extern int __must_check
class_register(struct class *);
198 extern void class_unregister(struct class *);
201 struct class_attribute
{
202 struct attribute attr
;
203 ssize_t (*show
)(struct class *, char * buf
);
204 ssize_t (*store
)(struct class *, const char * buf
, size_t count
);
207 #define CLASS_ATTR(_name,_mode,_show,_store) \
208 struct class_attribute class_attr_##_name = __ATTR(_name,_mode,_show,_store)
210 extern int __must_check
class_create_file(struct class *,
211 const struct class_attribute
*);
212 extern void class_remove_file(struct class *, const struct class_attribute
*);
214 struct class_device_attribute
{
215 struct attribute attr
;
216 ssize_t (*show
)(struct class_device
*, char * buf
);
217 ssize_t (*store
)(struct class_device
*, const char * buf
, size_t count
);
220 #define CLASS_DEVICE_ATTR(_name,_mode,_show,_store) \
221 struct class_device_attribute class_device_attr_##_name = \
222 __ATTR(_name,_mode,_show,_store)
224 extern int __must_check
class_device_create_file(struct class_device
*,
225 const struct class_device_attribute
*);
228 * struct class_device - class devices
229 * @class: pointer to the parent class for this class device. This is required.
230 * @devt: for internal use by the driver core only.
231 * @node: for internal use by the driver core only.
232 * @kobj: for internal use by the driver core only.
233 * @groups: optional additional groups to be created
234 * @dev: if set, a symlink to the struct device is created in the sysfs
235 * directory for this struct class device.
236 * @class_data: pointer to whatever you want to store here for this struct
237 * class_device. Use class_get_devdata() and class_set_devdata() to get and
239 * @parent: pointer to a struct class_device that is the parent of this struct
240 * class_device. If NULL, this class_device will show up at the root of the
241 * struct class in sysfs (which is probably what you want to have happen.)
242 * @release: pointer to a release function for this struct class_device. If
243 * set, this will be called instead of the class specific release function.
244 * Only use this if you want to override the default release function, like
245 * when you are nesting class_device structures.
246 * @uevent: pointer to a uevent function for this struct class_device. If
247 * set, this will be called instead of the class specific uevent function.
248 * Only use this if you want to override the default uevent function, like
249 * when you are nesting class_device structures.
251 struct class_device
{
252 struct list_head node
;
255 struct class * class; /* required */
256 dev_t devt
; /* dev_t, creates the sysfs "dev" */
257 struct device
* dev
; /* not necessary, but nice to have */
258 void * class_data
; /* class-specific data */
259 struct class_device
*parent
; /* parent of this child device, if there is one */
260 struct attribute_group
** groups
; /* optional groups */
262 void (*release
)(struct class_device
*dev
);
263 int (*uevent
)(struct class_device
*dev
, struct kobj_uevent_env
*env
);
264 char class_id
[BUS_ID_SIZE
]; /* unique to this class */
268 class_get_devdata (struct class_device
*dev
)
270 return dev
->class_data
;
274 class_set_devdata (struct class_device
*dev
, void *data
)
276 dev
->class_data
= data
;
280 extern int __must_check
class_device_register(struct class_device
*);
281 extern void class_device_unregister(struct class_device
*);
282 extern void class_device_initialize(struct class_device
*);
283 extern int __must_check
class_device_add(struct class_device
*);
284 extern void class_device_del(struct class_device
*);
286 extern struct class_device
* class_device_get(struct class_device
*);
287 extern void class_device_put(struct class_device
*);
289 extern void class_device_remove_file(struct class_device
*,
290 const struct class_device_attribute
*);
291 extern int __must_check
class_device_create_bin_file(struct class_device
*,
292 struct bin_attribute
*);
293 extern void class_device_remove_bin_file(struct class_device
*,
294 struct bin_attribute
*);
296 struct class_interface
{
297 struct list_head node
;
300 int (*add
) (struct class_device
*, struct class_interface
*);
301 void (*remove
) (struct class_device
*, struct class_interface
*);
302 int (*add_dev
) (struct device
*, struct class_interface
*);
303 void (*remove_dev
) (struct device
*, struct class_interface
*);
306 extern int __must_check
class_interface_register(struct class_interface
*);
307 extern void class_interface_unregister(struct class_interface
*);
309 extern struct class *class_create(struct module
*owner
, const char *name
);
310 extern void class_destroy(struct class *cls
);
311 extern struct class_device
*class_device_create(struct class *cls
,
312 struct class_device
*parent
,
314 struct device
*device
,
315 const char *fmt
, ...)
316 __attribute__((format(printf
,5,6)));
317 extern void class_device_destroy(struct class *cls
, dev_t devt
);
320 * The type of device, "struct device" is embedded in. A class
321 * or bus can contain devices of different types
322 * like "partitions" and "disks", "mouse" and "event".
323 * This identifies the device type and carries type-specific
324 * information, equivalent to the kobj_type of a kobject.
325 * If "name" is specified, the uevent will contain it in
326 * the DEVTYPE variable.
330 struct attribute_group
**groups
;
331 int (*uevent
)(struct device
*dev
, struct kobj_uevent_env
*env
);
332 void (*release
)(struct device
*dev
);
333 int (*suspend
)(struct device
* dev
, pm_message_t state
);
334 int (*resume
)(struct device
* dev
);
337 /* interface for exporting device attributes */
338 struct device_attribute
{
339 struct attribute attr
;
340 ssize_t (*show
)(struct device
*dev
, struct device_attribute
*attr
,
342 ssize_t (*store
)(struct device
*dev
, struct device_attribute
*attr
,
343 const char *buf
, size_t count
);
346 #define DEVICE_ATTR(_name,_mode,_show,_store) \
347 struct device_attribute dev_attr_##_name = __ATTR(_name,_mode,_show,_store)
349 extern int __must_check
device_create_file(struct device
*device
,
350 struct device_attribute
* entry
);
351 extern void device_remove_file(struct device
* dev
, struct device_attribute
* attr
);
352 extern int __must_check
device_create_bin_file(struct device
*dev
,
353 struct bin_attribute
*attr
);
354 extern void device_remove_bin_file(struct device
*dev
,
355 struct bin_attribute
*attr
);
356 extern int device_schedule_callback_owner(struct device
*dev
,
357 void (*func
)(struct device
*), struct module
*owner
);
359 /* This is a macro to avoid include problems with THIS_MODULE */
360 #define device_schedule_callback(dev, func) \
361 device_schedule_callback_owner(dev, func, THIS_MODULE)
363 /* device resource management */
364 typedef void (*dr_release_t
)(struct device
*dev
, void *res
);
365 typedef int (*dr_match_t
)(struct device
*dev
, void *res
, void *match_data
);
367 #ifdef CONFIG_DEBUG_DEVRES
368 extern void * __devres_alloc(dr_release_t release
, size_t size
, gfp_t gfp
,
370 #define devres_alloc(release, size, gfp) \
371 __devres_alloc(release, size, gfp, #release)
373 extern void * devres_alloc(dr_release_t release
, size_t size
, gfp_t gfp
);
375 extern void devres_free(void *res
);
376 extern void devres_add(struct device
*dev
, void *res
);
377 extern void * devres_find(struct device
*dev
, dr_release_t release
,
378 dr_match_t match
, void *match_data
);
379 extern void * devres_get(struct device
*dev
, void *new_res
,
380 dr_match_t match
, void *match_data
);
381 extern void * devres_remove(struct device
*dev
, dr_release_t release
,
382 dr_match_t match
, void *match_data
);
383 extern int devres_destroy(struct device
*dev
, dr_release_t release
,
384 dr_match_t match
, void *match_data
);
387 extern void * __must_check
devres_open_group(struct device
*dev
, void *id
,
389 extern void devres_close_group(struct device
*dev
, void *id
);
390 extern void devres_remove_group(struct device
*dev
, void *id
);
391 extern int devres_release_group(struct device
*dev
, void *id
);
393 /* managed kzalloc/kfree for device drivers, no kmalloc, always use kzalloc */
394 extern void *devm_kzalloc(struct device
*dev
, size_t size
, gfp_t gfp
);
395 extern void devm_kfree(struct device
*dev
, void *p
);
398 struct klist klist_children
;
399 struct klist_node knode_parent
; /* node in sibling list */
400 struct klist_node knode_driver
;
401 struct klist_node knode_bus
;
402 struct device
*parent
;
405 char bus_id
[BUS_ID_SIZE
]; /* position on parent bus */
406 struct device_type
*type
;
407 unsigned is_registered
:1;
408 unsigned uevent_suppress
:1;
410 struct semaphore sem
; /* semaphore to synchronize calls to
414 struct bus_type
* bus
; /* type of bus device is on */
415 struct device_driver
*driver
; /* which driver has allocated this
417 void *driver_data
; /* data private to the driver */
418 void *platform_data
; /* Platform specific data, device
419 core doesn't touch it */
420 struct dev_pm_info power
;
423 int numa_node
; /* NUMA node this device is close to */
425 u64
*dma_mask
; /* dma mask (if dma'able device) */
426 u64 coherent_dma_mask
;/* Like dma_mask, but for
427 alloc_coherent mappings as
428 not all hardware supports
429 64 bit addresses for consistent
430 allocations such descriptors. */
432 struct list_head dma_pools
; /* dma pools (if dma'ble) */
434 struct dma_coherent_mem
*dma_mem
; /* internal for coherent mem
436 /* arch specific additions */
437 struct dev_archdata archdata
;
439 spinlock_t devres_lock
;
440 struct list_head devres_head
;
442 /* class_device migration path */
443 struct list_head node
;
445 dev_t devt
; /* dev_t, creates the sysfs "dev" */
446 struct attribute_group
**groups
; /* optional groups */
448 void (*release
)(struct device
* dev
);
452 static inline int dev_to_node(struct device
*dev
)
454 return dev
->numa_node
;
456 static inline void set_dev_node(struct device
*dev
, int node
)
458 dev
->numa_node
= node
;
461 static inline int dev_to_node(struct device
*dev
)
465 static inline void set_dev_node(struct device
*dev
, int node
)
471 dev_get_drvdata (struct device
*dev
)
473 return dev
->driver_data
;
477 dev_set_drvdata (struct device
*dev
, void *data
)
479 dev
->driver_data
= data
;
482 static inline int device_is_registered(struct device
*dev
)
484 return dev
->is_registered
;
487 void driver_init(void);
490 * High level routines for use by the bus drivers
492 extern int __must_check
device_register(struct device
* dev
);
493 extern void device_unregister(struct device
* dev
);
494 extern void device_initialize(struct device
* dev
);
495 extern int __must_check
device_add(struct device
* dev
);
496 extern void device_del(struct device
* dev
);
497 extern int device_for_each_child(struct device
*, void *,
498 int (*fn
)(struct device
*, void *));
499 extern struct device
*device_find_child(struct device
*, void *data
,
500 int (*match
)(struct device
*, void *));
501 extern int device_rename(struct device
*dev
, char *new_name
);
502 extern int device_move(struct device
*dev
, struct device
*new_parent
);
505 * Manual binding of a device to driver. See drivers/base/bus.c
506 * for information on use.
508 extern int __must_check
device_bind_driver(struct device
*dev
);
509 extern void device_release_driver(struct device
* dev
);
510 extern int __must_check
device_attach(struct device
* dev
);
511 extern int __must_check
driver_attach(struct device_driver
*drv
);
512 extern int __must_check
device_reprobe(struct device
*dev
);
515 * Easy functions for dynamically creating devices on the fly
517 extern struct device
*device_create(struct class *cls
, struct device
*parent
,
518 dev_t devt
, const char *fmt
, ...)
519 __attribute__((format(printf
,4,5)));
520 extern void device_destroy(struct class *cls
, dev_t devt
);
521 #ifdef CONFIG_PM_SLEEP
522 extern void destroy_suspended_device(struct class *cls
, dev_t devt
);
523 #else /* !CONFIG_PM_SLEEP */
524 static inline void destroy_suspended_device(struct class *cls
, dev_t devt
)
526 device_destroy(cls
, devt
);
528 #endif /* !CONFIG_PM_SLEEP */
531 * Platform "fixup" functions - allow the platform to have their say
532 * about devices and actions that the general device layer doesn't
535 /* Notify platform of device discovery */
536 extern int (*platform_notify
)(struct device
* dev
);
538 extern int (*platform_notify_remove
)(struct device
* dev
);
542 * get_device - atomically increment the reference count for the device.
545 extern struct device
* get_device(struct device
* dev
);
546 extern void put_device(struct device
* dev
);
549 /* drivers/base/power/shutdown.c */
550 extern void device_shutdown(void);
552 /* drivers/base/sys.c */
553 extern void sysdev_shutdown(void);
555 /* debugging and troubleshooting/diagnostic helpers. */
556 extern const char *dev_driver_string(struct device
*dev
);
557 #define dev_printk(level, dev, format, arg...) \
558 printk(level "%s %s: " format , dev_driver_string(dev) , (dev)->bus_id , ## arg)
560 #define dev_emerg(dev, format, arg...) \
561 dev_printk(KERN_EMERG , dev , format , ## arg)
562 #define dev_alert(dev, format, arg...) \
563 dev_printk(KERN_ALERT , dev , format , ## arg)
564 #define dev_crit(dev, format, arg...) \
565 dev_printk(KERN_CRIT , dev , format , ## arg)
566 #define dev_err(dev, format, arg...) \
567 dev_printk(KERN_ERR , dev , format , ## arg)
568 #define dev_warn(dev, format, arg...) \
569 dev_printk(KERN_WARNING , dev , format , ## arg)
570 #define dev_notice(dev, format, arg...) \
571 dev_printk(KERN_NOTICE , dev , format , ## arg)
572 #define dev_info(dev, format, arg...) \
573 dev_printk(KERN_INFO , dev , format , ## arg)
576 #define dev_dbg(dev, format, arg...) \
577 dev_printk(KERN_DEBUG , dev , format , ## arg)
579 static inline int __attribute__ ((format (printf
, 2, 3)))
580 dev_dbg(struct device
* dev
, const char * fmt
, ...)
587 #define dev_vdbg dev_dbg
589 static inline int __attribute__ ((format (printf
, 2, 3)))
590 dev_vdbg(struct device
* dev
, const char * fmt
, ...)
596 /* Create alias, so I can be autoloaded. */
597 #define MODULE_ALIAS_CHARDEV(major,minor) \
598 MODULE_ALIAS("char-major-" __stringify(major) "-" __stringify(minor))
599 #define MODULE_ALIAS_CHARDEV_MAJOR(major) \
600 MODULE_ALIAS("char-major-" __stringify(major) "-*")
601 #endif /* _DEVICE_H_ */