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-2007 Greg Kroah-Hartman <gregkh@suse.de>
6 *
7 * This file is released under the GPLv2
8 *
9 * See Documentation/driver-model/ for more information.
10 */
11
12#ifndef _DEVICE_H_
13#define _DEVICE_H_
14
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>
22#include <linux/pm.h>
23#include <linux/semaphore.h>
24#include <asm/atomic.h>
25#include <asm/device.h>
26
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
32
33
34struct device;
35struct device_driver;
36struct driver_private;
37struct class;
38struct bus_type;
39struct bus_type_private;
40
41struct 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);
45};
46
47#define BUS_ATTR(_name, _mode, _show, _store) \
48struct bus_attribute bus_attr_##_name = __ATTR(_name, _mode, _show, _store)
49
50extern int __must_check bus_create_file(struct bus_type *,
51 struct bus_attribute *);
52extern void bus_remove_file(struct bus_type *, struct bus_attribute *);
53
54struct bus_type {
55 const char *name;
56 struct bus_attribute *bus_attrs;
57 struct device_attribute *dev_attrs;
58 struct driver_attribute *drv_attrs;
59
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);
65
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);
70
71 struct bus_type_private *p;
72};
73
74extern int __must_check bus_register(struct bus_type *bus);
75extern void bus_unregister(struct bus_type *bus);
76
77extern int __must_check bus_rescan_devices(struct bus_type *bus);
78
79/* iterator helpers for buses */
80
81int bus_for_each_dev(struct bus_type *bus, struct device *start, void *data,
82 int (*fn)(struct device *dev, void *data));
83struct device *bus_find_device(struct bus_type *bus, struct device *start,
84 void *data,
85 int (*match)(struct device *dev, void *data));
86struct device *bus_find_device_by_name(struct bus_type *bus,
87 struct device *start,
88 const char *name);
89
90int __must_check bus_for_each_drv(struct bus_type *bus,
91 struct device_driver *start, void *data,
92 int (*fn)(struct device_driver *, void *));
93
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
117extern struct kset *bus_get_kset(struct bus_type *bus);
118extern struct klist *bus_get_device_klist(struct bus_type *bus);
119
120struct device_driver {
121 const char *name;
122 struct bus_type *bus;
123
124 struct module *owner;
125 const char *mod_name; /* used for built-in modules */
126
127 int (*probe) (struct device *dev);
128 int (*remove) (struct device *dev);
129 void (*shutdown) (struct device *dev);
130 int (*suspend) (struct device *dev, pm_message_t state);
131 int (*resume) (struct device *dev);
132 struct attribute_group **groups;
133
134 struct driver_private *p;
135};
136
137
138extern int __must_check driver_register(struct device_driver *drv);
139extern void driver_unregister(struct device_driver *drv);
140
141extern struct device_driver *get_driver(struct device_driver *drv);
142extern void put_driver(struct device_driver *drv);
143extern struct device_driver *driver_find(const char *name,
144 struct bus_type *bus);
145extern int driver_probe_done(void);
146
147/* sysfs interface for exporting driver attributes */
148
149struct driver_attribute {
150 struct attribute attr;
151 ssize_t (*show)(struct device_driver *driver, char *buf);
152 ssize_t (*store)(struct device_driver *driver, const char *buf,
153 size_t count);
154};
155
156#define DRIVER_ATTR(_name, _mode, _show, _store) \
157struct driver_attribute driver_attr_##_name = \
158 __ATTR(_name, _mode, _show, _store)
159
160extern int __must_check driver_create_file(struct device_driver *driver,
161 struct driver_attribute *attr);
162extern void driver_remove_file(struct device_driver *driver,
163 struct driver_attribute *attr);
164
165extern int __must_check driver_add_kobj(struct device_driver *drv,
166 struct kobject *kobj,
167 const char *fmt, ...);
168
169extern int __must_check driver_for_each_device(struct device_driver *drv,
170 struct device *start,
171 void *data,
172 int (*fn)(struct device *dev,
173 void *));
174struct device *driver_find_device(struct device_driver *drv,
175 struct device *start, void *data,
176 int (*match)(struct device *dev, void *data));
177
178/*
179 * device classes
180 */
181struct class {
182 const char *name;
183 struct module *owner;
184
185 struct kset subsys;
186 struct list_head devices;
187 struct list_head interfaces;
188 struct kset class_dirs;
189 struct semaphore sem; /* locks children, devices, interfaces */
190 struct class_attribute *class_attrs;
191 struct device_attribute *dev_attrs;
192
193 int (*dev_uevent)(struct device *dev, struct kobj_uevent_env *env);
194
195 void (*class_release)(struct class *class);
196 void (*dev_release)(struct device *dev);
197
198 int (*suspend)(struct device *dev, pm_message_t state);
199 int (*resume)(struct device *dev);
200};
201
202extern int __must_check class_register(struct class *class);
203extern void class_unregister(struct class *class);
204extern int class_for_each_device(struct class *class, void *data,
205 int (*fn)(struct device *dev, void *data));
206extern struct device *class_find_device(struct class *class, void *data,
207 int (*match)(struct device *, void *));
208
209struct class_attribute {
210 struct attribute attr;
211 ssize_t (*show)(struct class *class, char *buf);
212 ssize_t (*store)(struct class *class, const char *buf, size_t count);
213};
214
215#define CLASS_ATTR(_name, _mode, _show, _store) \
216struct class_attribute class_attr_##_name = __ATTR(_name, _mode, _show, _store)
217
218extern int __must_check class_create_file(struct class *class,
219 const struct class_attribute *attr);
220extern void class_remove_file(struct class *class,
221 const struct class_attribute *attr);
222
223struct class_interface {
224 struct list_head node;
225 struct class *class;
226
227 int (*add_dev) (struct device *, struct class_interface *);
228 void (*remove_dev) (struct device *, struct class_interface *);
229};
230
231extern int __must_check class_interface_register(struct class_interface *);
232extern void class_interface_unregister(struct class_interface *);
233
234extern struct class *class_create(struct module *owner, const char *name);
235extern void class_destroy(struct class *cls);
236
237/*
238 * The type of device, "struct device" is embedded in. A class
239 * or bus can contain devices of different types
240 * like "partitions" and "disks", "mouse" and "event".
241 * This identifies the device type and carries type-specific
242 * information, equivalent to the kobj_type of a kobject.
243 * If "name" is specified, the uevent will contain it in
244 * the DEVTYPE variable.
245 */
246struct device_type {
247 const char *name;
248 struct attribute_group **groups;
249 int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
250 void (*release)(struct device *dev);
251 int (*suspend)(struct device *dev, pm_message_t state);
252 int (*resume)(struct device *dev);
253};
254
255/* interface for exporting device attributes */
256struct device_attribute {
257 struct attribute attr;
258 ssize_t (*show)(struct device *dev, struct device_attribute *attr,
259 char *buf);
260 ssize_t (*store)(struct device *dev, struct device_attribute *attr,
261 const char *buf, size_t count);
262};
263
264#define DEVICE_ATTR(_name, _mode, _show, _store) \
265struct device_attribute dev_attr_##_name = __ATTR(_name, _mode, _show, _store)
266
267extern int __must_check device_create_file(struct device *device,
268 struct device_attribute *entry);
269extern void device_remove_file(struct device *dev,
270 struct device_attribute *attr);
271extern int __must_check device_create_bin_file(struct device *dev,
272 struct bin_attribute *attr);
273extern void device_remove_bin_file(struct device *dev,
274 struct bin_attribute *attr);
275extern int device_schedule_callback_owner(struct device *dev,
276 void (*func)(struct device *dev), struct module *owner);
277
278/* This is a macro to avoid include problems with THIS_MODULE */
279#define device_schedule_callback(dev, func) \
280 device_schedule_callback_owner(dev, func, THIS_MODULE)
281
282/* device resource management */
283typedef void (*dr_release_t)(struct device *dev, void *res);
284typedef int (*dr_match_t)(struct device *dev, void *res, void *match_data);
285
286#ifdef CONFIG_DEBUG_DEVRES
287extern void *__devres_alloc(dr_release_t release, size_t size, gfp_t gfp,
288 const char *name);
289#define devres_alloc(release, size, gfp) \
290 __devres_alloc(release, size, gfp, #release)
291#else
292extern void *devres_alloc(dr_release_t release, size_t size, gfp_t gfp);
293#endif
294extern void devres_free(void *res);
295extern void devres_add(struct device *dev, void *res);
296extern void *devres_find(struct device *dev, dr_release_t release,
297 dr_match_t match, void *match_data);
298extern void *devres_get(struct device *dev, void *new_res,
299 dr_match_t match, void *match_data);
300extern void *devres_remove(struct device *dev, dr_release_t release,
301 dr_match_t match, void *match_data);
302extern int devres_destroy(struct device *dev, dr_release_t release,
303 dr_match_t match, void *match_data);
304
305/* devres group */
306extern void * __must_check devres_open_group(struct device *dev, void *id,
307 gfp_t gfp);
308extern void devres_close_group(struct device *dev, void *id);
309extern void devres_remove_group(struct device *dev, void *id);
310extern int devres_release_group(struct device *dev, void *id);
311
312/* managed kzalloc/kfree for device drivers, no kmalloc, always use kzalloc */
313extern void *devm_kzalloc(struct device *dev, size_t size, gfp_t gfp);
314extern void devm_kfree(struct device *dev, void *p);
315
316struct device_dma_parameters {
317 /*
318 * a low level driver may set these to teach IOMMU code about
319 * sg limitations.
320 */
321 unsigned int max_segment_size;
322 unsigned long segment_boundary_mask;
323};
324
325struct device {
326 struct klist klist_children;
327 struct klist_node knode_parent; /* node in sibling list */
328 struct klist_node knode_driver;
329 struct klist_node knode_bus;
330 struct device *parent;
331
332 struct kobject kobj;
333 char bus_id[BUS_ID_SIZE]; /* position on parent bus */
334 struct device_type *type;
335 unsigned uevent_suppress:1;
336
337 struct semaphore sem; /* semaphore to synchronize calls to
338 * its driver.
339 */
340
341 struct bus_type *bus; /* type of bus device is on */
342 struct device_driver *driver; /* which driver has allocated this
343 device */
344 void *driver_data; /* data private to the driver */
345 void *platform_data; /* Platform specific data, device
346 core doesn't touch it */
347 struct dev_pm_info power;
348
349#ifdef CONFIG_NUMA
350 int numa_node; /* NUMA node this device is close to */
351#endif
352 u64 *dma_mask; /* dma mask (if dma'able device) */
353 u64 coherent_dma_mask;/* Like dma_mask, but for
354 alloc_coherent mappings as
355 not all hardware supports
356 64 bit addresses for consistent
357 allocations such descriptors. */
358
359 struct device_dma_parameters *dma_parms;
360
361 struct list_head dma_pools; /* dma pools (if dma'ble) */
362
363 struct dma_coherent_mem *dma_mem; /* internal for coherent mem
364 override */
365 /* arch specific additions */
366 struct dev_archdata archdata;
367
368 spinlock_t devres_lock;
369 struct list_head devres_head;
370
371 struct list_head node;
372 struct class *class;
373 dev_t devt; /* dev_t, creates the sysfs "dev" */
374 struct attribute_group **groups; /* optional groups */
375
376 void (*release)(struct device *dev);
377};
378
379/* Get the wakeup routines, which depend on struct device */
380#include <linux/pm_wakeup.h>
381
382static inline const char *dev_name(struct device *dev)
383{
384 /* will be changed into kobject_name(&dev->kobj) in the near future */
385 return dev->bus_id;
386}
387
388extern int dev_set_name(struct device *dev, const char *name, ...)
389 __attribute__((format(printf, 2, 3)));
390
391#ifdef CONFIG_NUMA
392static inline int dev_to_node(struct device *dev)
393{
394 return dev->numa_node;
395}
396static inline void set_dev_node(struct device *dev, int node)
397{
398 dev->numa_node = node;
399}
400#else
401static inline int dev_to_node(struct device *dev)
402{
403 return -1;
404}
405static inline void set_dev_node(struct device *dev, int node)
406{
407}
408#endif
409
410static inline void *dev_get_drvdata(struct device *dev)
411{
412 return dev->driver_data;
413}
414
415static inline void dev_set_drvdata(struct device *dev, void *data)
416{
417 dev->driver_data = data;
418}
419
420static inline int device_is_registered(struct device *dev)
421{
422 return dev->kobj.state_in_sysfs;
423}
424
425void driver_init(void);
426
427/*
428 * High level routines for use by the bus drivers
429 */
430extern int __must_check device_register(struct device *dev);
431extern void device_unregister(struct device *dev);
432extern void device_initialize(struct device *dev);
433extern int __must_check device_add(struct device *dev);
434extern void device_del(struct device *dev);
435extern int device_for_each_child(struct device *dev, void *data,
436 int (*fn)(struct device *dev, void *data));
437extern struct device *device_find_child(struct device *dev, void *data,
438 int (*match)(struct device *dev, void *data));
439extern int device_rename(struct device *dev, char *new_name);
440extern int device_move(struct device *dev, struct device *new_parent);
441
442/*
443 * Manual binding of a device to driver. See drivers/base/bus.c
444 * for information on use.
445 */
446extern int __must_check device_bind_driver(struct device *dev);
447extern void device_release_driver(struct device *dev);
448extern int __must_check device_attach(struct device *dev);
449extern int __must_check driver_attach(struct device_driver *drv);
450extern int __must_check device_reprobe(struct device *dev);
451
452/*
453 * Easy functions for dynamically creating devices on the fly
454 */
455extern struct device *device_create_vargs(struct class *cls,
456 struct device *parent,
457 dev_t devt,
458 void *drvdata,
459 const char *fmt,
460 va_list vargs);
461extern struct device *device_create(struct class *cls, struct device *parent,
462 dev_t devt, const char *fmt, ...)
463 __attribute__((format(printf, 4, 5)));
464extern struct device *device_create_drvdata(struct class *cls,
465 struct device *parent,
466 dev_t devt,
467 void *drvdata,
468 const char *fmt, ...)
469 __attribute__((format(printf, 5, 6)));
470extern void device_destroy(struct class *cls, dev_t devt);
471
472/*
473 * Platform "fixup" functions - allow the platform to have their say
474 * about devices and actions that the general device layer doesn't
475 * know about.
476 */
477/* Notify platform of device discovery */
478extern int (*platform_notify)(struct device *dev);
479
480extern int (*platform_notify_remove)(struct device *dev);
481
482
483/**
484 * get_device - atomically increment the reference count for the device.
485 *
486 */
487extern struct device *get_device(struct device *dev);
488extern void put_device(struct device *dev);
489
490
491/* drivers/base/power/shutdown.c */
492extern void device_shutdown(void);
493
494/* drivers/base/sys.c */
495extern void sysdev_shutdown(void);
496
497/* debugging and troubleshooting/diagnostic helpers. */
498extern const char *dev_driver_string(struct device *dev);
499#define dev_printk(level, dev, format, arg...) \
500 printk(level "%s %s: " format , dev_driver_string(dev) , \
501 dev_name(dev) , ## arg)
502
503#define dev_emerg(dev, format, arg...) \
504 dev_printk(KERN_EMERG , dev , format , ## arg)
505#define dev_alert(dev, format, arg...) \
506 dev_printk(KERN_ALERT , dev , format , ## arg)
507#define dev_crit(dev, format, arg...) \
508 dev_printk(KERN_CRIT , dev , format , ## arg)
509#define dev_err(dev, format, arg...) \
510 dev_printk(KERN_ERR , dev , format , ## arg)
511#define dev_warn(dev, format, arg...) \
512 dev_printk(KERN_WARNING , dev , format , ## arg)
513#define dev_notice(dev, format, arg...) \
514 dev_printk(KERN_NOTICE , dev , format , ## arg)
515#define dev_info(dev, format, arg...) \
516 dev_printk(KERN_INFO , dev , format , ## arg)
517
518#ifdef DEBUG
519#define dev_dbg(dev, format, arg...) \
520 dev_printk(KERN_DEBUG , dev , format , ## arg)
521#else
522#define dev_dbg(dev, format, arg...) \
523 ({ if (0) dev_printk(KERN_DEBUG, dev, format, ##arg); 0; })
524#endif
525
526#ifdef VERBOSE_DEBUG
527#define dev_vdbg dev_dbg
528#else
529
530#define dev_vdbg(dev, format, arg...) \
531 ({ if (0) dev_printk(KERN_DEBUG, dev, format, ##arg); 0; })
532#endif
533
534/* Create alias, so I can be autoloaded. */
535#define MODULE_ALIAS_CHARDEV(major,minor) \
536 MODULE_ALIAS("char-major-" __stringify(major) "-" __stringify(minor))
537#define MODULE_ALIAS_CHARDEV_MAJOR(major) \
538 MODULE_ALIAS("char-major-" __stringify(major) "-*")
539#endif /* _DEVICE_H_ */