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 <linux/semaphore.h>
24 #include <asm/atomic.h>
25 #include <asm/device.h>
27 #define DEVICE_NAME_SIZE 50
28 /* DEVICE_NAME_HALF is really less than half to accommodate slop */
29 #define DEVICE_NAME_HALF __stringify(20)
30 #define DEVICE_ID_SIZE 32
31 #define BUS_ID_SIZE KOBJ_NAME_LEN
36 struct driver_private
;
39 struct bus_type_private
;
41 struct bus_attribute
{
42 struct attribute attr
;
43 ssize_t (*show
)(struct bus_type
*bus
, char *buf
);
44 ssize_t (*store
)(struct bus_type
*bus
, 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 pm_ext_ops
*pm
;
73 struct bus_type_private
*p
;
76 extern int __must_check
bus_register(struct bus_type
*bus
);
77 extern void bus_unregister(struct bus_type
*bus
);
79 extern int __must_check
bus_rescan_devices(struct bus_type
*bus
);
81 /* iterator helpers for buses */
83 int bus_for_each_dev(struct bus_type
*bus
, struct device
*start
, void *data
,
84 int (*fn
)(struct device
*dev
, void *data
));
85 struct device
*bus_find_device(struct bus_type
*bus
, struct device
*start
,
87 int (*match
)(struct device
*dev
, void *data
));
88 struct device
*bus_find_device_by_name(struct bus_type
*bus
,
92 int __must_check
bus_for_each_drv(struct bus_type
*bus
,
93 struct device_driver
*start
, void *data
,
94 int (*fn
)(struct device_driver
*, void *));
97 * Bus notifiers: Get notified of addition/removal of devices
98 * and binding/unbinding of drivers to devices.
99 * In the long run, it should be a replacement for the platform
102 struct notifier_block
;
104 extern int bus_register_notifier(struct bus_type
*bus
,
105 struct notifier_block
*nb
);
106 extern int bus_unregister_notifier(struct bus_type
*bus
,
107 struct notifier_block
*nb
);
109 /* All 4 notifers below get called with the target struct device *
110 * as an argument. Note that those functions are likely to be called
111 * with the device semaphore held in the core, so be careful.
113 #define BUS_NOTIFY_ADD_DEVICE 0x00000001 /* device added */
114 #define BUS_NOTIFY_DEL_DEVICE 0x00000002 /* device removed */
115 #define BUS_NOTIFY_BOUND_DRIVER 0x00000003 /* driver bound to device */
116 #define BUS_NOTIFY_UNBIND_DRIVER 0x00000004 /* driver about to be
119 extern struct kset
*bus_get_kset(struct bus_type
*bus
);
120 extern struct klist
*bus_get_device_klist(struct bus_type
*bus
);
122 struct device_driver
{
124 struct bus_type
*bus
;
126 struct module
*owner
;
127 const char *mod_name
; /* used for built-in modules */
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 struct attribute_group
**groups
;
138 struct driver_private
*p
;
142 extern int __must_check
driver_register(struct device_driver
*drv
);
143 extern void driver_unregister(struct device_driver
*drv
);
145 extern struct device_driver
*get_driver(struct device_driver
*drv
);
146 extern void put_driver(struct device_driver
*drv
);
147 extern struct device_driver
*driver_find(const char *name
,
148 struct bus_type
*bus
);
149 extern int driver_probe_done(void);
151 /* sysfs interface for exporting driver attributes */
153 struct driver_attribute
{
154 struct attribute attr
;
155 ssize_t (*show
)(struct device_driver
*driver
, char *buf
);
156 ssize_t (*store
)(struct device_driver
*driver
, const char *buf
,
160 #define DRIVER_ATTR(_name, _mode, _show, _store) \
161 struct driver_attribute driver_attr_##_name = \
162 __ATTR(_name, _mode, _show, _store)
164 extern int __must_check
driver_create_file(struct device_driver
*driver
,
165 struct driver_attribute
*attr
);
166 extern void driver_remove_file(struct device_driver
*driver
,
167 struct driver_attribute
*attr
);
169 extern int __must_check
driver_add_kobj(struct device_driver
*drv
,
170 struct kobject
*kobj
,
171 const char *fmt
, ...);
173 extern int __must_check
driver_for_each_device(struct device_driver
*drv
,
174 struct device
*start
,
176 int (*fn
)(struct device
*dev
,
178 struct device
*driver_find_device(struct device_driver
*drv
,
179 struct device
*start
, void *data
,
180 int (*match
)(struct device
*dev
, void *data
));
187 struct module
*owner
;
190 struct list_head devices
;
191 struct list_head interfaces
;
192 struct kset class_dirs
;
193 struct semaphore sem
; /* locks children, devices, interfaces */
194 struct class_attribute
*class_attrs
;
195 struct device_attribute
*dev_attrs
;
197 int (*dev_uevent
)(struct device
*dev
, struct kobj_uevent_env
*env
);
199 void (*class_release
)(struct class *class);
200 void (*dev_release
)(struct device
*dev
);
202 int (*suspend
)(struct device
*dev
, pm_message_t state
);
203 int (*resume
)(struct device
*dev
);
208 extern int __must_check
class_register(struct class *class);
209 extern void class_unregister(struct class *class);
210 extern int class_for_each_device(struct class *class, void *data
,
211 int (*fn
)(struct device
*dev
, void *data
));
212 extern struct device
*class_find_device(struct class *class, void *data
,
213 int (*match
)(struct device
*, void *));
215 struct class_attribute
{
216 struct attribute attr
;
217 ssize_t (*show
)(struct class *class, char *buf
);
218 ssize_t (*store
)(struct class *class, const char *buf
, size_t count
);
221 #define CLASS_ATTR(_name, _mode, _show, _store) \
222 struct class_attribute class_attr_##_name = __ATTR(_name, _mode, _show, _store)
224 extern int __must_check
class_create_file(struct class *class,
225 const struct class_attribute
*attr
);
226 extern void class_remove_file(struct class *class,
227 const struct class_attribute
*attr
);
229 struct class_interface
{
230 struct list_head node
;
233 int (*add_dev
) (struct device
*, struct class_interface
*);
234 void (*remove_dev
) (struct device
*, struct class_interface
*);
237 extern int __must_check
class_interface_register(struct class_interface
*);
238 extern void class_interface_unregister(struct class_interface
*);
240 extern struct class *class_create(struct module
*owner
, const char *name
);
241 extern void class_destroy(struct class *cls
);
244 * The type of device, "struct device" is embedded in. A class
245 * or bus can contain devices of different types
246 * like "partitions" and "disks", "mouse" and "event".
247 * This identifies the device type and carries type-specific
248 * information, equivalent to the kobj_type of a kobject.
249 * If "name" is specified, the uevent will contain it in
250 * the DEVTYPE variable.
254 struct attribute_group
**groups
;
255 int (*uevent
)(struct device
*dev
, struct kobj_uevent_env
*env
);
256 void (*release
)(struct device
*dev
);
258 int (*suspend
)(struct device
*dev
, pm_message_t state
);
259 int (*resume
)(struct device
*dev
);
264 /* interface for exporting device attributes */
265 struct device_attribute
{
266 struct attribute attr
;
267 ssize_t (*show
)(struct device
*dev
, struct device_attribute
*attr
,
269 ssize_t (*store
)(struct device
*dev
, struct device_attribute
*attr
,
270 const char *buf
, size_t count
);
273 #define DEVICE_ATTR(_name, _mode, _show, _store) \
274 struct device_attribute dev_attr_##_name = __ATTR(_name, _mode, _show, _store)
276 extern int __must_check
device_create_file(struct device
*device
,
277 struct device_attribute
*entry
);
278 extern void device_remove_file(struct device
*dev
,
279 struct device_attribute
*attr
);
280 extern int __must_check
device_create_bin_file(struct device
*dev
,
281 struct bin_attribute
*attr
);
282 extern void device_remove_bin_file(struct device
*dev
,
283 struct bin_attribute
*attr
);
284 extern int device_schedule_callback_owner(struct device
*dev
,
285 void (*func
)(struct device
*dev
), struct module
*owner
);
287 /* This is a macro to avoid include problems with THIS_MODULE */
288 #define device_schedule_callback(dev, func) \
289 device_schedule_callback_owner(dev, func, THIS_MODULE)
291 /* device resource management */
292 typedef void (*dr_release_t
)(struct device
*dev
, void *res
);
293 typedef int (*dr_match_t
)(struct device
*dev
, void *res
, void *match_data
);
295 #ifdef CONFIG_DEBUG_DEVRES
296 extern void *__devres_alloc(dr_release_t release
, size_t size
, gfp_t gfp
,
298 #define devres_alloc(release, size, gfp) \
299 __devres_alloc(release, size, gfp, #release)
301 extern void *devres_alloc(dr_release_t release
, size_t size
, gfp_t gfp
);
303 extern void devres_free(void *res
);
304 extern void devres_add(struct device
*dev
, void *res
);
305 extern void *devres_find(struct device
*dev
, dr_release_t release
,
306 dr_match_t match
, void *match_data
);
307 extern void *devres_get(struct device
*dev
, void *new_res
,
308 dr_match_t match
, void *match_data
);
309 extern void *devres_remove(struct device
*dev
, dr_release_t release
,
310 dr_match_t match
, void *match_data
);
311 extern int devres_destroy(struct device
*dev
, dr_release_t release
,
312 dr_match_t match
, void *match_data
);
315 extern void * __must_check
devres_open_group(struct device
*dev
, void *id
,
317 extern void devres_close_group(struct device
*dev
, void *id
);
318 extern void devres_remove_group(struct device
*dev
, void *id
);
319 extern int devres_release_group(struct device
*dev
, void *id
);
321 /* managed kzalloc/kfree for device drivers, no kmalloc, always use kzalloc */
322 extern void *devm_kzalloc(struct device
*dev
, size_t size
, gfp_t gfp
);
323 extern void devm_kfree(struct device
*dev
, void *p
);
325 struct device_dma_parameters
{
327 * a low level driver may set these to teach IOMMU code about
330 unsigned int max_segment_size
;
331 unsigned long segment_boundary_mask
;
335 struct klist klist_children
;
336 struct klist_node knode_parent
; /* node in sibling list */
337 struct klist_node knode_driver
;
338 struct klist_node knode_bus
;
339 struct device
*parent
;
342 char bus_id
[BUS_ID_SIZE
]; /* position on parent bus */
343 struct device_type
*type
;
344 unsigned uevent_suppress
:1;
346 struct semaphore sem
; /* semaphore to synchronize calls to
350 struct bus_type
*bus
; /* type of bus device is on */
351 struct device_driver
*driver
; /* which driver has allocated this
353 void *driver_data
; /* data private to the driver */
354 void *platform_data
; /* Platform specific data, device
355 core doesn't touch it */
356 struct dev_pm_info power
;
359 int numa_node
; /* NUMA node this device is close to */
361 u64
*dma_mask
; /* dma mask (if dma'able device) */
362 u64 coherent_dma_mask
;/* Like dma_mask, but for
363 alloc_coherent mappings as
364 not all hardware supports
365 64 bit addresses for consistent
366 allocations such descriptors. */
368 struct device_dma_parameters
*dma_parms
;
370 struct list_head dma_pools
; /* dma pools (if dma'ble) */
372 struct dma_coherent_mem
*dma_mem
; /* internal for coherent mem
374 /* arch specific additions */
375 struct dev_archdata archdata
;
377 spinlock_t devres_lock
;
378 struct list_head devres_head
;
380 struct list_head node
;
382 dev_t devt
; /* dev_t, creates the sysfs "dev" */
383 struct attribute_group
**groups
; /* optional groups */
385 void (*release
)(struct device
*dev
);
388 /* Get the wakeup routines, which depend on struct device */
389 #include <linux/pm_wakeup.h>
391 static inline const char *dev_name(struct device
*dev
)
393 /* will be changed into kobject_name(&dev->kobj) in the near future */
397 extern int dev_set_name(struct device
*dev
, const char *name
, ...)
398 __attribute__((format(printf
, 2, 3)));
401 static inline int dev_to_node(struct device
*dev
)
403 return dev
->numa_node
;
405 static inline void set_dev_node(struct device
*dev
, int node
)
407 dev
->numa_node
= node
;
410 static inline int dev_to_node(struct device
*dev
)
414 static inline void set_dev_node(struct device
*dev
, int node
)
419 static inline void *dev_get_drvdata(struct device
*dev
)
421 return dev
->driver_data
;
424 static inline void dev_set_drvdata(struct device
*dev
, void *data
)
426 dev
->driver_data
= data
;
429 static inline int device_is_registered(struct device
*dev
)
431 return dev
->kobj
.state_in_sysfs
;
434 void driver_init(void);
437 * High level routines for use by the bus drivers
439 extern int __must_check
device_register(struct device
*dev
);
440 extern void device_unregister(struct device
*dev
);
441 extern void device_initialize(struct device
*dev
);
442 extern int __must_check
device_add(struct device
*dev
);
443 extern void device_del(struct device
*dev
);
444 extern int device_for_each_child(struct device
*dev
, void *data
,
445 int (*fn
)(struct device
*dev
, void *data
));
446 extern struct device
*device_find_child(struct device
*dev
, void *data
,
447 int (*match
)(struct device
*dev
, void *data
));
448 extern int device_rename(struct device
*dev
, char *new_name
);
449 extern int device_move(struct device
*dev
, struct device
*new_parent
);
452 * Manual binding of a device to driver. See drivers/base/bus.c
453 * for information on use.
455 extern int __must_check
device_bind_driver(struct device
*dev
);
456 extern void device_release_driver(struct device
*dev
);
457 extern int __must_check
device_attach(struct device
*dev
);
458 extern int __must_check
driver_attach(struct device_driver
*drv
);
459 extern int __must_check
device_reprobe(struct device
*dev
);
462 * Easy functions for dynamically creating devices on the fly
464 extern struct device
*device_create_vargs(struct class *cls
,
465 struct device
*parent
,
470 extern struct device
*device_create(struct class *cls
, struct device
*parent
,
471 dev_t devt
, const char *fmt
, ...)
472 __attribute__((format(printf
, 4, 5)));
473 extern struct device
*device_create_drvdata(struct class *cls
,
474 struct device
*parent
,
477 const char *fmt
, ...)
478 __attribute__((format(printf
, 5, 6)));
479 extern void device_destroy(struct class *cls
, dev_t devt
);
482 * Platform "fixup" functions - allow the platform to have their say
483 * about devices and actions that the general device layer doesn't
486 /* Notify platform of device discovery */
487 extern int (*platform_notify
)(struct device
*dev
);
489 extern int (*platform_notify_remove
)(struct device
*dev
);
493 * get_device - atomically increment the reference count for the device.
496 extern struct device
*get_device(struct device
*dev
);
497 extern void put_device(struct device
*dev
);
500 /* drivers/base/power/shutdown.c */
501 extern void device_shutdown(void);
503 /* drivers/base/sys.c */
504 extern void sysdev_shutdown(void);
506 /* debugging and troubleshooting/diagnostic helpers. */
507 extern const char *dev_driver_string(struct device
*dev
);
508 #define dev_printk(level, dev, format, arg...) \
509 printk(level "%s %s: " format , dev_driver_string(dev) , \
510 dev_name(dev) , ## arg)
512 #define dev_emerg(dev, format, arg...) \
513 dev_printk(KERN_EMERG , dev , format , ## arg)
514 #define dev_alert(dev, format, arg...) \
515 dev_printk(KERN_ALERT , dev , format , ## arg)
516 #define dev_crit(dev, format, arg...) \
517 dev_printk(KERN_CRIT , dev , format , ## arg)
518 #define dev_err(dev, format, arg...) \
519 dev_printk(KERN_ERR , dev , format , ## arg)
520 #define dev_warn(dev, format, arg...) \
521 dev_printk(KERN_WARNING , dev , format , ## arg)
522 #define dev_notice(dev, format, arg...) \
523 dev_printk(KERN_NOTICE , dev , format , ## arg)
524 #define dev_info(dev, format, arg...) \
525 dev_printk(KERN_INFO , dev , format , ## arg)
528 #define dev_dbg(dev, format, arg...) \
529 dev_printk(KERN_DEBUG , dev , format , ## arg)
531 #define dev_dbg(dev, format, arg...) \
532 ({ if (0) dev_printk(KERN_DEBUG, dev, format, ##arg); 0; })
536 #define dev_vdbg dev_dbg
539 #define dev_vdbg(dev, format, arg...) \
540 ({ if (0) dev_printk(KERN_DEBUG, dev, format, ##arg); 0; })
543 /* Create alias, so I can be autoloaded. */
544 #define MODULE_ALIAS_CHARDEV(major,minor) \
545 MODULE_ALIAS("char-major-" __stringify(major) "-" __stringify(minor))
546 #define MODULE_ALIAS_CHARDEV_MAJOR(major) \
547 MODULE_ALIAS("char-major-" __stringify(major) "-*")
548 #endif /* _DEVICE_H_ */