]>
git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - include/linux/device.h
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/lockdep.h>
20 #include <linux/compiler.h>
21 #include <linux/types.h>
22 #include <linux/module.h>
24 #include <linux/semaphore.h>
25 #include <asm/atomic.h>
26 #include <asm/device.h>
28 #define BUS_ID_SIZE 20
32 struct driver_private
;
36 struct bus_type_private
;
38 struct 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
);
44 #define BUS_ATTR(_name, _mode, _show, _store) \
45 struct bus_attribute bus_attr_##_name = __ATTR(_name, _mode, _show, _store)
47 extern int __must_check
bus_create_file(struct bus_type
*,
48 struct bus_attribute
*);
49 extern void bus_remove_file(struct bus_type
*, struct bus_attribute
*);
53 struct bus_attribute
*bus_attrs
;
54 struct device_attribute
*dev_attrs
;
55 struct driver_attribute
*drv_attrs
;
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
);
63 int (*suspend
)(struct device
*dev
, pm_message_t state
);
64 int (*suspend_late
)(struct device
*dev
, pm_message_t state
);
65 int (*resume_early
)(struct device
*dev
);
66 int (*resume
)(struct device
*dev
);
68 struct dev_pm_ops
*pm
;
70 struct bus_type_private
*p
;
73 extern int __must_check
bus_register(struct bus_type
*bus
);
74 extern void bus_unregister(struct bus_type
*bus
);
76 extern int __must_check
bus_rescan_devices(struct bus_type
*bus
);
78 /* iterator helpers for buses */
80 int bus_for_each_dev(struct bus_type
*bus
, struct device
*start
, void *data
,
81 int (*fn
)(struct device
*dev
, void *data
));
82 struct device
*bus_find_device(struct bus_type
*bus
, struct device
*start
,
84 int (*match
)(struct device
*dev
, void *data
));
85 struct device
*bus_find_device_by_name(struct bus_type
*bus
,
89 int __must_check
bus_for_each_drv(struct bus_type
*bus
,
90 struct device_driver
*start
, void *data
,
91 int (*fn
)(struct device_driver
*, void *));
93 void bus_sort_breadthfirst(struct bus_type
*bus
,
94 int (*compare
)(const struct device
*a
,
95 const struct device
*b
));
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
;
136 struct dev_pm_ops
*pm
;
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
;
189 struct class_attribute
*class_attrs
;
190 struct device_attribute
*dev_attrs
;
191 struct kobject
*dev_kobj
;
193 int (*dev_uevent
)(struct device
*dev
, struct kobj_uevent_env
*env
);
195 void (*class_release
)(struct class *class);
196 void (*dev_release
)(struct device
*dev
);
198 int (*suspend
)(struct device
*dev
, pm_message_t state
);
199 int (*resume
)(struct device
*dev
);
201 struct dev_pm_ops
*pm
;
202 struct class_private
*p
;
205 struct class_dev_iter
{
206 struct klist_iter ki
;
207 const struct device_type
*type
;
210 extern struct kobject
*sysfs_dev_block_kobj
;
211 extern struct kobject
*sysfs_dev_char_kobj
;
212 extern int __must_check
__class_register(struct class *class,
213 struct lock_class_key
*key
);
214 extern void class_unregister(struct class *class);
216 /* This is a #define to keep the compiler from merging different
217 * instances of the __key variable */
218 #define class_register(class) \
220 static struct lock_class_key __key; \
221 __class_register(class, &__key); \
224 extern void class_dev_iter_init(struct class_dev_iter
*iter
,
226 struct device
*start
,
227 const struct device_type
*type
);
228 extern struct device
*class_dev_iter_next(struct class_dev_iter
*iter
);
229 extern void class_dev_iter_exit(struct class_dev_iter
*iter
);
231 extern int class_for_each_device(struct class *class, struct device
*start
,
233 int (*fn
)(struct device
*dev
, void *data
));
234 extern struct device
*class_find_device(struct class *class,
235 struct device
*start
, void *data
,
236 int (*match
)(struct device
*, void *));
238 struct class_attribute
{
239 struct attribute attr
;
240 ssize_t (*show
)(struct class *class, char *buf
);
241 ssize_t (*store
)(struct class *class, const char *buf
, size_t count
);
244 #define CLASS_ATTR(_name, _mode, _show, _store) \
245 struct class_attribute class_attr_##_name = __ATTR(_name, _mode, _show, _store)
247 extern int __must_check
class_create_file(struct class *class,
248 const struct class_attribute
*attr
);
249 extern void class_remove_file(struct class *class,
250 const struct class_attribute
*attr
);
252 struct class_interface
{
253 struct list_head node
;
256 int (*add_dev
) (struct device
*, struct class_interface
*);
257 void (*remove_dev
) (struct device
*, struct class_interface
*);
260 extern int __must_check
class_interface_register(struct class_interface
*);
261 extern void class_interface_unregister(struct class_interface
*);
263 extern struct class * __must_check
__class_create(struct module
*owner
,
265 struct lock_class_key
*key
);
266 extern void class_destroy(struct class *cls
);
268 /* This is a #define to keep the compiler from merging different
269 * instances of the __key variable */
270 #define class_create(owner, name) \
272 static struct lock_class_key __key; \
273 __class_create(owner, name, &__key); \
277 * The type of device, "struct device" is embedded in. A class
278 * or bus can contain devices of different types
279 * like "partitions" and "disks", "mouse" and "event".
280 * This identifies the device type and carries type-specific
281 * information, equivalent to the kobj_type of a kobject.
282 * If "name" is specified, the uevent will contain it in
283 * the DEVTYPE variable.
287 struct attribute_group
**groups
;
288 int (*uevent
)(struct device
*dev
, struct kobj_uevent_env
*env
);
289 void (*release
)(struct device
*dev
);
291 int (*suspend
)(struct device
*dev
, pm_message_t state
);
292 int (*resume
)(struct device
*dev
);
294 struct dev_pm_ops
*pm
;
297 /* interface for exporting device attributes */
298 struct device_attribute
{
299 struct attribute attr
;
300 ssize_t (*show
)(struct device
*dev
, struct device_attribute
*attr
,
302 ssize_t (*store
)(struct device
*dev
, struct device_attribute
*attr
,
303 const char *buf
, size_t count
);
306 #define DEVICE_ATTR(_name, _mode, _show, _store) \
307 struct device_attribute dev_attr_##_name = __ATTR(_name, _mode, _show, _store)
309 extern int __must_check
device_create_file(struct device
*device
,
310 struct device_attribute
*entry
);
311 extern void device_remove_file(struct device
*dev
,
312 struct device_attribute
*attr
);
313 extern int __must_check
device_create_bin_file(struct device
*dev
,
314 struct bin_attribute
*attr
);
315 extern void device_remove_bin_file(struct device
*dev
,
316 struct bin_attribute
*attr
);
317 extern int device_schedule_callback_owner(struct device
*dev
,
318 void (*func
)(struct device
*dev
), struct module
*owner
);
320 /* This is a macro to avoid include problems with THIS_MODULE */
321 #define device_schedule_callback(dev, func) \
322 device_schedule_callback_owner(dev, func, THIS_MODULE)
324 /* device resource management */
325 typedef void (*dr_release_t
)(struct device
*dev
, void *res
);
326 typedef int (*dr_match_t
)(struct device
*dev
, void *res
, void *match_data
);
328 #ifdef CONFIG_DEBUG_DEVRES
329 extern void *__devres_alloc(dr_release_t release
, size_t size
, gfp_t gfp
,
331 #define devres_alloc(release, size, gfp) \
332 __devres_alloc(release, size, gfp, #release)
334 extern void *devres_alloc(dr_release_t release
, size_t size
, gfp_t gfp
);
336 extern void devres_free(void *res
);
337 extern void devres_add(struct device
*dev
, void *res
);
338 extern void *devres_find(struct device
*dev
, dr_release_t release
,
339 dr_match_t match
, void *match_data
);
340 extern void *devres_get(struct device
*dev
, void *new_res
,
341 dr_match_t match
, void *match_data
);
342 extern void *devres_remove(struct device
*dev
, dr_release_t release
,
343 dr_match_t match
, void *match_data
);
344 extern int devres_destroy(struct device
*dev
, dr_release_t release
,
345 dr_match_t match
, void *match_data
);
348 extern void * __must_check
devres_open_group(struct device
*dev
, void *id
,
350 extern void devres_close_group(struct device
*dev
, void *id
);
351 extern void devres_remove_group(struct device
*dev
, void *id
);
352 extern int devres_release_group(struct device
*dev
, void *id
);
354 /* managed kzalloc/kfree for device drivers, no kmalloc, always use kzalloc */
355 extern void *devm_kzalloc(struct device
*dev
, size_t size
, gfp_t gfp
);
356 extern void devm_kfree(struct device
*dev
, void *p
);
358 struct device_dma_parameters
{
360 * a low level driver may set these to teach IOMMU code about
363 unsigned int max_segment_size
;
364 unsigned long segment_boundary_mask
;
368 struct klist klist_children
;
369 struct klist_node knode_parent
; /* node in sibling list */
370 struct klist_node knode_driver
;
371 struct klist_node knode_bus
;
372 struct device
*parent
;
375 char bus_id
[BUS_ID_SIZE
]; /* position on parent bus */
376 unsigned uevent_suppress
:1;
377 const char *init_name
; /* initial name of the device */
378 struct device_type
*type
;
380 struct semaphore sem
; /* semaphore to synchronize calls to
384 struct bus_type
*bus
; /* type of bus device is on */
385 struct device_driver
*driver
; /* which driver has allocated this
387 void *driver_data
; /* data private to the driver */
388 void *platform_data
; /* Platform specific data, device
389 core doesn't touch it */
390 struct dev_pm_info power
;
393 int numa_node
; /* NUMA node this device is close to */
395 u64
*dma_mask
; /* dma mask (if dma'able device) */
396 u64 coherent_dma_mask
;/* Like dma_mask, but for
397 alloc_coherent mappings as
398 not all hardware supports
399 64 bit addresses for consistent
400 allocations such descriptors. */
402 struct device_dma_parameters
*dma_parms
;
404 struct list_head dma_pools
; /* dma pools (if dma'ble) */
406 struct dma_coherent_mem
*dma_mem
; /* internal for coherent mem
408 /* arch specific additions */
409 struct dev_archdata archdata
;
411 dev_t devt
; /* dev_t, creates the sysfs "dev" */
413 spinlock_t devres_lock
;
414 struct list_head devres_head
;
416 struct klist_node knode_class
;
418 struct attribute_group
**groups
; /* optional groups */
420 void (*release
)(struct device
*dev
);
423 /* Get the wakeup routines, which depend on struct device */
424 #include <linux/pm_wakeup.h>
426 static inline const char *dev_name(const struct device
*dev
)
428 /* will be changed into kobject_name(&dev->kobj) in the near future */
432 extern int dev_set_name(struct device
*dev
, const char *name
, ...)
433 __attribute__((format(printf
, 2, 3)));
436 static inline int dev_to_node(struct device
*dev
)
438 return dev
->numa_node
;
440 static inline void set_dev_node(struct device
*dev
, int node
)
442 dev
->numa_node
= node
;
445 static inline int dev_to_node(struct device
*dev
)
449 static inline void set_dev_node(struct device
*dev
, int node
)
454 static inline void *dev_get_drvdata(const struct device
*dev
)
456 return dev
->driver_data
;
459 static inline void dev_set_drvdata(struct device
*dev
, void *data
)
461 dev
->driver_data
= data
;
464 static inline int device_is_registered(struct device
*dev
)
466 return dev
->kobj
.state_in_sysfs
;
469 void driver_init(void);
472 * High level routines for use by the bus drivers
474 extern int __must_check
device_register(struct device
*dev
);
475 extern void device_unregister(struct device
*dev
);
476 extern void device_initialize(struct device
*dev
);
477 extern int __must_check
device_add(struct device
*dev
);
478 extern void device_del(struct device
*dev
);
479 extern int device_for_each_child(struct device
*dev
, void *data
,
480 int (*fn
)(struct device
*dev
, void *data
));
481 extern struct device
*device_find_child(struct device
*dev
, void *data
,
482 int (*match
)(struct device
*dev
, void *data
));
483 extern int device_rename(struct device
*dev
, char *new_name
);
484 extern int device_move(struct device
*dev
, struct device
*new_parent
);
487 * Root device objects for grouping under /sys/devices
489 extern struct device
*__root_device_register(const char *name
,
490 struct module
*owner
);
491 static inline struct device
*root_device_register(const char *name
)
493 return __root_device_register(name
, THIS_MODULE
);
495 extern void root_device_unregister(struct device
*root
);
498 * Manual binding of a device to driver. See drivers/base/bus.c
499 * for information on use.
501 extern int __must_check
device_bind_driver(struct device
*dev
);
502 extern void device_release_driver(struct device
*dev
);
503 extern int __must_check
device_attach(struct device
*dev
);
504 extern int __must_check
driver_attach(struct device_driver
*drv
);
505 extern int __must_check
device_reprobe(struct device
*dev
);
508 * Easy functions for dynamically creating devices on the fly
510 extern struct device
*device_create_vargs(struct class *cls
,
511 struct device
*parent
,
516 extern struct device
*device_create(struct class *cls
, struct device
*parent
,
517 dev_t devt
, void *drvdata
,
518 const char *fmt
, ...)
519 __attribute__((format(printf
, 5, 6)));
520 extern void device_destroy(struct class *cls
, dev_t devt
);
523 * Platform "fixup" functions - allow the platform to have their say
524 * about devices and actions that the general device layer doesn't
527 /* Notify platform of device discovery */
528 extern int (*platform_notify
)(struct device
*dev
);
530 extern int (*platform_notify_remove
)(struct device
*dev
);
534 * get_device - atomically increment the reference count for the device.
537 extern struct device
*get_device(struct device
*dev
);
538 extern void put_device(struct device
*dev
);
541 /* drivers/base/power/shutdown.c */
542 extern void device_shutdown(void);
544 /* drivers/base/sys.c */
545 extern void sysdev_shutdown(void);
547 /* debugging and troubleshooting/diagnostic helpers. */
548 extern const char *dev_driver_string(const struct device
*dev
);
549 #define dev_printk(level, dev, format, arg...) \
550 printk(level "%s %s: " format , dev_driver_string(dev) , \
551 dev_name(dev) , ## arg)
553 #define dev_emerg(dev, format, arg...) \
554 dev_printk(KERN_EMERG , dev , format , ## arg)
555 #define dev_alert(dev, format, arg...) \
556 dev_printk(KERN_ALERT , dev , format , ## arg)
557 #define dev_crit(dev, format, arg...) \
558 dev_printk(KERN_CRIT , dev , format , ## arg)
559 #define dev_err(dev, format, arg...) \
560 dev_printk(KERN_ERR , dev , format , ## arg)
561 #define dev_warn(dev, format, arg...) \
562 dev_printk(KERN_WARNING , dev , format , ## arg)
563 #define dev_notice(dev, format, arg...) \
564 dev_printk(KERN_NOTICE , dev , format , ## arg)
565 #define dev_info(dev, format, arg...) \
566 dev_printk(KERN_INFO , dev , format , ## arg)
569 #define dev_dbg(dev, format, arg...) \
570 dev_printk(KERN_DEBUG , dev , format , ## arg)
571 #elif defined(CONFIG_DYNAMIC_PRINTK_DEBUG)
572 #define dev_dbg(dev, format, ...) do { \
573 dynamic_dev_dbg(dev, format, ##__VA_ARGS__); \
576 #define dev_dbg(dev, format, arg...) \
577 ({ if (0) dev_printk(KERN_DEBUG, dev, format, ##arg); 0; })
581 #define dev_vdbg dev_dbg
584 #define dev_vdbg(dev, format, arg...) \
585 ({ if (0) dev_printk(KERN_DEBUG, dev, format, ##arg); 0; })
589 * dev_WARN() acts like dev_printk(), but with the key difference
590 * of using a WARN/WARN_ON to get the message out, including the
591 * file/line information and a backtrace.
593 #define dev_WARN(dev, format, arg...) \
594 WARN(1, "Device: %s\n" format, dev_driver_string(dev), ## arg);
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_ */