2 * device.h - generic, centralized driver model
4 * Copyright (c) 2001-2003 Patrick Mochel <mochel@osdl.org>
6 * This file is released under the GPLv2
8 * See Documentation/driver-model/ for more information.
14 #include <linux/ioport.h>
15 #include <linux/kobject.h>
16 #include <linux/klist.h>
17 #include <linux/list.h>
18 #include <linux/compiler.h>
19 #include <linux/types.h>
20 #include <linux/module.h>
22 #include <asm/semaphore.h>
23 #include <asm/atomic.h>
25 #define DEVICE_NAME_SIZE 50
26 #define DEVICE_NAME_HALF __stringify(20) /* Less than half to accommodate slop */
27 #define DEVICE_ID_SIZE 32
28 #define BUS_ID_SIZE KOBJ_NAME_LEN
39 struct subsystem subsys
;
42 struct klist klist_devices
;
43 struct klist klist_drivers
;
45 struct blocking_notifier_head bus_notifier
;
47 struct bus_attribute
* bus_attrs
;
48 struct device_attribute
* dev_attrs
;
49 struct driver_attribute
* drv_attrs
;
51 int (*match
)(struct device
* dev
, struct device_driver
* drv
);
52 int (*uevent
)(struct device
*dev
, char **envp
,
53 int num_envp
, char *buffer
, int buffer_size
);
54 int (*probe
)(struct device
* dev
);
55 int (*remove
)(struct device
* dev
);
56 void (*shutdown
)(struct device
* dev
);
58 int (*suspend
)(struct device
* dev
, pm_message_t state
);
59 int (*suspend_late
)(struct device
* dev
, pm_message_t state
);
60 int (*resume_early
)(struct device
* dev
);
61 int (*resume
)(struct device
* dev
);
64 extern int __must_check
bus_register(struct bus_type
* bus
);
65 extern void bus_unregister(struct bus_type
* bus
);
67 extern int __must_check
bus_rescan_devices(struct bus_type
* bus
);
69 /* iterator helpers for buses */
71 int bus_for_each_dev(struct bus_type
* bus
, struct device
* start
, void * data
,
72 int (*fn
)(struct device
*, void *));
73 struct device
* bus_find_device(struct bus_type
*bus
, struct device
*start
,
74 void *data
, int (*match
)(struct device
*, void *));
76 int __must_check
bus_for_each_drv(struct bus_type
*bus
,
77 struct device_driver
*start
, void *data
,
78 int (*fn
)(struct device_driver
*, void *));
81 * Bus notifiers: Get notified of addition/removal of devices
82 * and binding/unbinding of drivers to devices.
83 * In the long run, it should be a replacement for the platform
86 struct notifier_block
;
88 extern int bus_register_notifier(struct bus_type
*bus
,
89 struct notifier_block
*nb
);
90 extern int bus_unregister_notifier(struct bus_type
*bus
,
91 struct notifier_block
*nb
);
93 /* All 4 notifers below get called with the target struct device *
94 * as an argument. Note that those functions are likely to be called
95 * with the device semaphore held in the core, so be careful.
97 #define BUS_NOTIFY_ADD_DEVICE 0x00000001 /* device added */
98 #define BUS_NOTIFY_DEL_DEVICE 0x00000002 /* device removed */
99 #define BUS_NOTIFY_BOUND_DRIVER 0x00000003 /* driver bound to device */
100 #define BUS_NOTIFY_UNBIND_DRIVER 0x00000004 /* driver about to be
103 /* driverfs interface for exporting bus attributes */
105 struct bus_attribute
{
106 struct attribute attr
;
107 ssize_t (*show
)(struct bus_type
*, char * buf
);
108 ssize_t (*store
)(struct bus_type
*, const char * buf
, size_t count
);
111 #define BUS_ATTR(_name,_mode,_show,_store) \
112 struct bus_attribute bus_attr_##_name = __ATTR(_name,_mode,_show,_store)
114 extern int __must_check
bus_create_file(struct bus_type
*,
115 struct bus_attribute
*);
116 extern void bus_remove_file(struct bus_type
*, struct bus_attribute
*);
118 struct device_driver
{
120 struct bus_type
* bus
;
122 struct completion unloaded
;
124 struct klist klist_devices
;
125 struct klist_node knode_bus
;
127 struct module
* owner
;
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
);
135 unsigned int multithread_probe
:1;
139 extern int __must_check
driver_register(struct device_driver
* drv
);
140 extern void driver_unregister(struct device_driver
* drv
);
142 extern struct device_driver
* get_driver(struct device_driver
* drv
);
143 extern void put_driver(struct device_driver
* drv
);
144 extern struct device_driver
*driver_find(const char *name
, struct bus_type
*bus
);
145 extern int driver_probe_done(void);
147 /* driverfs interface for exporting driver attributes */
149 struct driver_attribute
{
150 struct attribute attr
;
151 ssize_t (*show
)(struct device_driver
*, char * buf
);
152 ssize_t (*store
)(struct device_driver
*, const char * buf
, size_t count
);
155 #define DRIVER_ATTR(_name,_mode,_show,_store) \
156 struct driver_attribute driver_attr_##_name = __ATTR(_name,_mode,_show,_store)
158 extern int __must_check
driver_create_file(struct device_driver
*,
159 struct driver_attribute
*);
160 extern void driver_remove_file(struct device_driver
*, struct driver_attribute
*);
162 extern int __must_check
driver_for_each_device(struct device_driver
* drv
,
163 struct device
*start
, void *data
,
164 int (*fn
)(struct device
*, void *));
165 struct device
* driver_find_device(struct device_driver
*drv
,
166 struct device
*start
, void *data
,
167 int (*match
)(struct device
*, void *));
174 struct module
* owner
;
176 struct subsystem subsys
;
177 struct list_head children
;
178 struct list_head devices
;
179 struct list_head interfaces
;
180 struct semaphore sem
; /* locks both the children and interfaces lists */
182 struct kobject
*virtual_dir
;
184 struct class_attribute
* class_attrs
;
185 struct class_device_attribute
* class_dev_attrs
;
186 struct device_attribute
* dev_attrs
;
188 int (*uevent
)(struct class_device
*dev
, char **envp
,
189 int num_envp
, char *buffer
, int buffer_size
);
190 int (*dev_uevent
)(struct device
*dev
, char **envp
, int num_envp
,
191 char *buffer
, int buffer_size
);
193 void (*release
)(struct class_device
*dev
);
194 void (*class_release
)(struct class *class);
195 void (*dev_release
)(struct device
*dev
);
197 int (*suspend
)(struct device
*, pm_message_t state
);
198 int (*resume
)(struct device
*);
201 extern int __must_check
class_register(struct class *);
202 extern void class_unregister(struct class *);
205 struct class_attribute
{
206 struct attribute attr
;
207 ssize_t (*show
)(struct class *, char * buf
);
208 ssize_t (*store
)(struct class *, const char * buf
, size_t count
);
211 #define CLASS_ATTR(_name,_mode,_show,_store) \
212 struct class_attribute class_attr_##_name = __ATTR(_name,_mode,_show,_store)
214 extern int __must_check
class_create_file(struct class *,
215 const struct class_attribute
*);
216 extern void class_remove_file(struct class *, const struct class_attribute
*);
218 struct class_device_attribute
{
219 struct attribute attr
;
220 ssize_t (*show
)(struct class_device
*, char * buf
);
221 ssize_t (*store
)(struct class_device
*, const char * buf
, size_t count
);
224 #define CLASS_DEVICE_ATTR(_name,_mode,_show,_store) \
225 struct class_device_attribute class_device_attr_##_name = \
226 __ATTR(_name,_mode,_show,_store)
228 extern int __must_check
class_device_create_file(struct class_device
*,
229 const struct class_device_attribute
*);
232 * struct class_device - class devices
233 * @class: pointer to the parent class for this class device. This is required.
234 * @devt: for internal use by the driver core only.
235 * @node: for internal use by the driver core only.
236 * @kobj: for internal use by the driver core only.
237 * @devt_attr: for internal use by the driver core only.
238 * @groups: optional additional groups to be created
239 * @dev: if set, a symlink to the struct device is created in the sysfs
240 * directory for this struct class device.
241 * @class_data: pointer to whatever you want to store here for this struct
242 * class_device. Use class_get_devdata() and class_set_devdata() to get and
244 * @parent: pointer to a struct class_device that is the parent of this struct
245 * class_device. If NULL, this class_device will show up at the root of the
246 * struct class in sysfs (which is probably what you want to have happen.)
247 * @release: pointer to a release function for this struct class_device. If
248 * set, this will be called instead of the class specific release function.
249 * Only use this if you want to override the default release function, like
250 * when you are nesting class_device structures.
251 * @uevent: pointer to a uevent function for this struct class_device. If
252 * set, this will be called instead of the class specific uevent function.
253 * Only use this if you want to override the default uevent function, like
254 * when you are nesting class_device structures.
256 struct class_device
{
257 struct list_head node
;
260 struct class * class; /* required */
261 dev_t devt
; /* dev_t, creates the sysfs "dev" */
262 struct class_device_attribute
*devt_attr
;
263 struct class_device_attribute uevent_attr
;
264 struct device
* dev
; /* not necessary, but nice to have */
265 void * class_data
; /* class-specific data */
266 struct class_device
*parent
; /* parent of this child device, if there is one */
267 struct attribute_group
** groups
; /* optional groups */
269 void (*release
)(struct class_device
*dev
);
270 int (*uevent
)(struct class_device
*dev
, char **envp
,
271 int num_envp
, char *buffer
, int buffer_size
);
272 char class_id
[BUS_ID_SIZE
]; /* unique to this class */
276 class_get_devdata (struct class_device
*dev
)
278 return dev
->class_data
;
282 class_set_devdata (struct class_device
*dev
, void *data
)
284 dev
->class_data
= data
;
288 extern int __must_check
class_device_register(struct class_device
*);
289 extern void class_device_unregister(struct class_device
*);
290 extern void class_device_initialize(struct class_device
*);
291 extern int __must_check
class_device_add(struct class_device
*);
292 extern void class_device_del(struct class_device
*);
294 extern int class_device_rename(struct class_device
*, char *);
296 extern struct class_device
* class_device_get(struct class_device
*);
297 extern void class_device_put(struct class_device
*);
299 extern void class_device_remove_file(struct class_device
*,
300 const struct class_device_attribute
*);
301 extern int __must_check
class_device_create_bin_file(struct class_device
*,
302 struct bin_attribute
*);
303 extern void class_device_remove_bin_file(struct class_device
*,
304 struct bin_attribute
*);
306 struct class_interface
{
307 struct list_head node
;
310 int (*add
) (struct class_device
*, struct class_interface
*);
311 void (*remove
) (struct class_device
*, struct class_interface
*);
312 int (*add_dev
) (struct device
*, struct class_interface
*);
313 void (*remove_dev
) (struct device
*, struct class_interface
*);
316 extern int __must_check
class_interface_register(struct class_interface
*);
317 extern void class_interface_unregister(struct class_interface
*);
319 extern struct class *class_create(struct module
*owner
, const char *name
);
320 extern void class_destroy(struct class *cls
);
321 extern struct class_device
*class_device_create(struct class *cls
,
322 struct class_device
*parent
,
324 struct device
*device
,
325 const char *fmt
, ...)
326 __attribute__((format(printf
,5,6)));
327 extern void class_device_destroy(struct class *cls
, dev_t devt
);
329 /* interface for exporting device attributes */
330 struct device_attribute
{
331 struct attribute attr
;
332 ssize_t (*show
)(struct device
*dev
, struct device_attribute
*attr
,
334 ssize_t (*store
)(struct device
*dev
, struct device_attribute
*attr
,
335 const char *buf
, size_t count
);
338 #define DEVICE_ATTR(_name,_mode,_show,_store) \
339 struct device_attribute dev_attr_##_name = __ATTR(_name,_mode,_show,_store)
341 extern int __must_check
device_create_file(struct device
*device
,
342 struct device_attribute
* entry
);
343 extern void device_remove_file(struct device
* dev
, struct device_attribute
* attr
);
344 extern int __must_check
device_create_bin_file(struct device
*dev
,
345 struct bin_attribute
*attr
);
346 extern void device_remove_bin_file(struct device
*dev
,
347 struct bin_attribute
*attr
);
349 struct klist klist_children
;
350 struct klist_node knode_parent
; /* node in sibling list */
351 struct klist_node knode_driver
;
352 struct klist_node knode_bus
;
353 struct device
* parent
;
356 char bus_id
[BUS_ID_SIZE
]; /* position on parent bus */
357 unsigned is_registered
:1;
358 struct device_attribute uevent_attr
;
359 struct device_attribute
*devt_attr
;
361 struct semaphore sem
; /* semaphore to synchronize calls to
365 struct bus_type
* bus
; /* type of bus device is on */
366 struct device_driver
*driver
; /* which driver has allocated this
368 void *driver_data
; /* data private to the driver */
369 void *platform_data
; /* Platform specific data, device
370 core doesn't touch it */
371 void *firmware_data
; /* Firmware specific data (e.g. ACPI,
372 BIOS data),reserved for device core*/
373 struct dev_pm_info power
;
375 u64
*dma_mask
; /* dma mask (if dma'able device) */
376 u64 coherent_dma_mask
;/* Like dma_mask, but for
377 alloc_coherent mappings as
378 not all hardware supports
379 64 bit addresses for consistent
380 allocations such descriptors. */
382 struct list_head dma_pools
; /* dma pools (if dma'ble) */
384 struct dma_coherent_mem
*dma_mem
; /* internal for coherent mem
387 /* class_device migration path */
388 struct list_head node
;
389 struct class *class; /* optional*/
390 dev_t devt
; /* dev_t, creates the sysfs "dev" */
391 struct attribute_group
**groups
; /* optional groups */
393 void (*release
)(struct device
* dev
);
397 dev_get_drvdata (struct device
*dev
)
399 return dev
->driver_data
;
403 dev_set_drvdata (struct device
*dev
, void *data
)
405 dev
->driver_data
= data
;
408 static inline int device_is_registered(struct device
*dev
)
410 return dev
->is_registered
;
414 * High level routines for use by the bus drivers
416 extern int __must_check
device_register(struct device
* dev
);
417 extern void device_unregister(struct device
* dev
);
418 extern void device_initialize(struct device
* dev
);
419 extern int __must_check
device_add(struct device
* dev
);
420 extern void device_del(struct device
* dev
);
421 extern int device_for_each_child(struct device
*, void *,
422 int (*fn
)(struct device
*, void *));
423 extern int device_rename(struct device
*dev
, char *new_name
);
426 * Manual binding of a device to driver. See drivers/base/bus.c
427 * for information on use.
429 extern int __must_check
device_bind_driver(struct device
*dev
);
430 extern void device_release_driver(struct device
* dev
);
431 extern int __must_check
device_attach(struct device
* dev
);
432 extern int __must_check
driver_attach(struct device_driver
*drv
);
433 extern int __must_check
device_reprobe(struct device
*dev
);
436 * Easy functions for dynamically creating devices on the fly
438 extern struct device
*device_create(struct class *cls
, struct device
*parent
,
439 dev_t devt
, const char *fmt
, ...)
440 __attribute__((format(printf
,4,5)));
441 extern void device_destroy(struct class *cls
, dev_t devt
);
443 extern int virtual_device_parent(struct device
*dev
);
446 * Platform "fixup" functions - allow the platform to have their say
447 * about devices and actions that the general device layer doesn't
450 /* Notify platform of device discovery */
451 extern int (*platform_notify
)(struct device
* dev
);
453 extern int (*platform_notify_remove
)(struct device
* dev
);
457 * get_device - atomically increment the reference count for the device.
460 extern struct device
* get_device(struct device
* dev
);
461 extern void put_device(struct device
* dev
);
464 /* drivers/base/power/shutdown.c */
465 extern void device_shutdown(void);
468 /* drivers/base/firmware.c */
469 extern int __must_check
firmware_register(struct subsystem
*);
470 extern void firmware_unregister(struct subsystem
*);
472 /* debugging and troubleshooting/diagnostic helpers. */
473 extern const char *dev_driver_string(struct device
*dev
);
474 #define dev_printk(level, dev, format, arg...) \
475 printk(level "%s %s: " format , dev_driver_string(dev) , (dev)->bus_id , ## arg)
478 #define dev_dbg(dev, format, arg...) \
479 dev_printk(KERN_DEBUG , dev , format , ## arg)
481 #define dev_dbg(dev, format, arg...) do { (void)(dev); } while (0)
484 #define dev_err(dev, format, arg...) \
485 dev_printk(KERN_ERR , dev , format , ## arg)
486 #define dev_info(dev, format, arg...) \
487 dev_printk(KERN_INFO , dev , format , ## arg)
488 #define dev_warn(dev, format, arg...) \
489 dev_printk(KERN_WARNING , dev , format , ## arg)
490 #define dev_notice(dev, format, arg...) \
491 dev_printk(KERN_NOTICE , dev , format , ## arg)
493 /* Create alias, so I can be autoloaded. */
494 #define MODULE_ALIAS_CHARDEV(major,minor) \
495 MODULE_ALIAS("char-major-" __stringify(major) "-" __stringify(minor))
496 #define MODULE_ALIAS_CHARDEV_MAJOR(major) \
497 MODULE_ALIAS("char-major-" __stringify(major) "-*")
498 #endif /* _DEVICE_H_ */