blob: da7221913114ce31488fdeae8b7e81cba10f4299 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * device.h - generic, centralized driver model
3 *
4 * Copyright (c) 2001-2003 Patrick Mochel <mochel@osdl.org>
5 *
6 * This file is released under the GPLv2
7 *
8 * See Documentation/driver-model/ for more information.
9 */
10
11#ifndef _DEVICE_H_
12#define _DEVICE_H_
13
Linus Torvalds1da177e2005-04-16 15:20:36 -070014#include <linux/ioport.h>
15#include <linux/kobject.h>
mochel@digitalimplant.org465c7a32005-03-21 11:49:14 -080016#include <linux/klist.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#include <linux/list.h>
Andrew Morton4a7fb632006-08-14 22:43:17 -070018#include <linux/compiler.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include <linux/types.h>
20#include <linux/module.h>
21#include <linux/pm.h>
22#include <asm/semaphore.h>
23#include <asm/atomic.h>
Benjamin Herrenschmidtc6dbaef2006-11-11 17:18:39 +110024#include <asm/device.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070025
26#define DEVICE_NAME_SIZE 50
27#define DEVICE_NAME_HALF __stringify(20) /* Less than half to accommodate slop */
28#define DEVICE_ID_SIZE 32
29#define BUS_ID_SIZE KOBJ_NAME_LEN
30
31
Linus Torvalds1da177e2005-04-16 15:20:36 -070032struct device;
33struct device_driver;
34struct class;
35struct class_device;
Linus Torvalds1da177e2005-04-16 15:20:36 -070036
37struct bus_type {
Dmitry Torokhov8d790d72005-04-26 02:34:05 -050038 const char * name;
Linus Torvalds1da177e2005-04-16 15:20:36 -070039
40 struct subsystem subsys;
41 struct kset drivers;
42 struct kset devices;
mochel@digitalimplant.org465c7a32005-03-21 11:49:14 -080043 struct klist klist_devices;
mochel@digitalimplant.org38fdac32005-03-21 12:00:18 -080044 struct klist klist_drivers;
Linus Torvalds1da177e2005-04-16 15:20:36 -070045
Benjamin Herrenschmidt116af372006-10-25 13:44:59 +100046 struct blocking_notifier_head bus_notifier;
47
Linus Torvalds1da177e2005-04-16 15:20:36 -070048 struct bus_attribute * bus_attrs;
49 struct device_attribute * dev_attrs;
50 struct driver_attribute * drv_attrs;
51
52 int (*match)(struct device * dev, struct device_driver * drv);
Kay Sievers312c0042005-11-16 09:00:00 +010053 int (*uevent)(struct device *dev, char **envp,
54 int num_envp, char *buffer, int buffer_size);
Russell King594c8282006-01-05 14:29:51 +000055 int (*probe)(struct device * dev);
56 int (*remove)(struct device * dev);
57 void (*shutdown)(struct device * dev);
Linus Torvalds7c8265f2006-06-24 14:50:29 -070058
Linus Torvalds7c8265f2006-06-24 14:50:29 -070059 int (*suspend)(struct device * dev, pm_message_t state);
60 int (*suspend_late)(struct device * dev, pm_message_t state);
61 int (*resume_early)(struct device * dev);
62 int (*resume)(struct device * dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070063};
64
Andrew Morton4a7fb632006-08-14 22:43:17 -070065extern int __must_check bus_register(struct bus_type * bus);
Linus Torvalds1da177e2005-04-16 15:20:36 -070066extern void bus_unregister(struct bus_type * bus);
67
Andrew Mortonf86db392006-08-14 22:43:20 -070068extern int __must_check bus_rescan_devices(struct bus_type * bus);
Linus Torvalds1da177e2005-04-16 15:20:36 -070069
Linus Torvalds1da177e2005-04-16 15:20:36 -070070/* iterator helpers for buses */
71
72int bus_for_each_dev(struct bus_type * bus, struct device * start, void * data,
73 int (*fn)(struct device *, void *));
Cornelia Huck0edb5862005-06-22 16:59:51 +020074struct device * bus_find_device(struct bus_type *bus, struct device *start,
75 void *data, int (*match)(struct device *, void *));
Linus Torvalds1da177e2005-04-16 15:20:36 -070076
Andrew Morton4a7fb632006-08-14 22:43:17 -070077int __must_check bus_for_each_drv(struct bus_type *bus,
78 struct device_driver *start, void *data,
79 int (*fn)(struct device_driver *, void *));
Linus Torvalds1da177e2005-04-16 15:20:36 -070080
Benjamin Herrenschmidt116af372006-10-25 13:44:59 +100081/*
82 * Bus notifiers: Get notified of addition/removal of devices
83 * and binding/unbinding of drivers to devices.
84 * In the long run, it should be a replacement for the platform
85 * notify hooks.
86 */
87struct notifier_block;
88
89extern int bus_register_notifier(struct bus_type *bus,
90 struct notifier_block *nb);
91extern int bus_unregister_notifier(struct bus_type *bus,
92 struct notifier_block *nb);
93
94/* All 4 notifers below get called with the target struct device *
95 * as an argument. Note that those functions are likely to be called
96 * with the device semaphore held in the core, so be careful.
97 */
98#define BUS_NOTIFY_ADD_DEVICE 0x00000001 /* device added */
99#define BUS_NOTIFY_DEL_DEVICE 0x00000002 /* device removed */
100#define BUS_NOTIFY_BOUND_DRIVER 0x00000003 /* driver bound to device */
101#define BUS_NOTIFY_UNBIND_DRIVER 0x00000004 /* driver about to be
102 unbound */
103
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104/* driverfs interface for exporting bus attributes */
105
106struct bus_attribute {
107 struct attribute attr;
108 ssize_t (*show)(struct bus_type *, char * buf);
109 ssize_t (*store)(struct bus_type *, const char * buf, size_t count);
110};
111
112#define BUS_ATTR(_name,_mode,_show,_store) \
113struct bus_attribute bus_attr_##_name = __ATTR(_name,_mode,_show,_store)
114
Andrew Morton4a7fb632006-08-14 22:43:17 -0700115extern int __must_check bus_create_file(struct bus_type *,
116 struct bus_attribute *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117extern void bus_remove_file(struct bus_type *, struct bus_attribute *);
118
119struct device_driver {
Dmitry Torokhov8d790d72005-04-26 02:34:05 -0500120 const char * name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121 struct bus_type * bus;
122
123 struct completion unloaded;
124 struct kobject kobj;
mochel@digitalimplant.org94e7b1c2005-03-21 12:25:36 -0800125 struct klist klist_devices;
mochel@digitalimplant.org38fdac32005-03-21 12:00:18 -0800126 struct klist_node knode_bus;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127
Dmitry Torokhov8d790d72005-04-26 02:34:05 -0500128 struct module * owner;
Kay Sieversf30c53a2007-01-15 20:22:02 +0100129 const char * mod_name; /* used for built-in modules */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130
131 int (*probe) (struct device * dev);
Dmitry Torokhov8d790d72005-04-26 02:34:05 -0500132 int (*remove) (struct device * dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133 void (*shutdown) (struct device * dev);
Russell King9480e302005-10-28 09:52:56 -0700134 int (*suspend) (struct device * dev, pm_message_t state);
135 int (*resume) (struct device * dev);
Greg Kroah-Hartmand7792492006-07-18 10:59:59 -0700136
137 unsigned int multithread_probe:1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138};
139
140
Andrew Morton4a7fb632006-08-14 22:43:17 -0700141extern int __must_check driver_register(struct device_driver * drv);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142extern void driver_unregister(struct device_driver * drv);
143
144extern struct device_driver * get_driver(struct device_driver * drv);
145extern void put_driver(struct device_driver * drv);
146extern struct device_driver *driver_find(const char *name, struct bus_type *bus);
Greg Kroah-Hartmand7792492006-07-18 10:59:59 -0700147extern int driver_probe_done(void);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149/* driverfs interface for exporting driver attributes */
150
151struct driver_attribute {
152 struct attribute attr;
153 ssize_t (*show)(struct device_driver *, char * buf);
154 ssize_t (*store)(struct device_driver *, const char * buf, size_t count);
155};
156
157#define DRIVER_ATTR(_name,_mode,_show,_store) \
158struct driver_attribute driver_attr_##_name = __ATTR(_name,_mode,_show,_store)
159
Andrew Morton4a7fb632006-08-14 22:43:17 -0700160extern int __must_check driver_create_file(struct device_driver *,
161 struct driver_attribute *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162extern void driver_remove_file(struct device_driver *, struct driver_attribute *);
163
Andrew Morton4a7fb632006-08-14 22:43:17 -0700164extern int __must_check driver_for_each_device(struct device_driver * drv,
165 struct device *start, void *data,
166 int (*fn)(struct device *, void *));
Cornelia Huck0edb5862005-06-22 16:59:51 +0200167struct device * driver_find_device(struct device_driver *drv,
168 struct device *start, void *data,
169 int (*match)(struct device *, void *));
mochel@digitalimplant.orgfae3cd02005-03-21 10:59:56 -0800170
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171/*
172 * device classes
173 */
174struct class {
Dmitry Torokhov8d790d72005-04-26 02:34:05 -0500175 const char * name;
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800176 struct module * owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177
178 struct subsystem subsys;
179 struct list_head children;
Greg Kroah-Hartman23681e42006-06-14 12:14:34 -0700180 struct list_head devices;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181 struct list_head interfaces;
182 struct semaphore sem; /* locks both the children and interfaces lists */
183
Greg Kroah-Hartmanc205ef42006-08-07 22:19:37 -0700184 struct kobject *virtual_dir;
185
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186 struct class_attribute * class_attrs;
187 struct class_device_attribute * class_dev_attrs;
Greg Kroah-Hartman2620efe2006-06-28 16:19:58 -0700188 struct device_attribute * dev_attrs;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189
Kay Sievers312c0042005-11-16 09:00:00 +0100190 int (*uevent)(struct class_device *dev, char **envp,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191 int num_envp, char *buffer, int buffer_size);
Greg Kroah-Hartman2620efe2006-06-28 16:19:58 -0700192 int (*dev_uevent)(struct device *dev, char **envp, int num_envp,
193 char *buffer, int buffer_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194
195 void (*release)(struct class_device *dev);
196 void (*class_release)(struct class *class);
Greg Kroah-Hartman2620efe2006-06-28 16:19:58 -0700197 void (*dev_release)(struct device *dev);
Linus Torvalds7c8265f2006-06-24 14:50:29 -0700198
199 int (*suspend)(struct device *, pm_message_t state);
200 int (*resume)(struct device *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201};
202
Andrew Morton4a7fb632006-08-14 22:43:17 -0700203extern int __must_check class_register(struct class *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204extern void class_unregister(struct class *);
205
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206
207struct class_attribute {
208 struct attribute attr;
209 ssize_t (*show)(struct class *, char * buf);
210 ssize_t (*store)(struct class *, const char * buf, size_t count);
211};
212
213#define CLASS_ATTR(_name,_mode,_show,_store) \
214struct class_attribute class_attr_##_name = __ATTR(_name,_mode,_show,_store)
215
Andrew Morton4a7fb632006-08-14 22:43:17 -0700216extern int __must_check class_create_file(struct class *,
217 const struct class_attribute *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218extern void class_remove_file(struct class *, const struct class_attribute *);
219
Kay Sieversa7fd6702005-10-01 14:49:43 +0200220struct class_device_attribute {
221 struct attribute attr;
222 ssize_t (*show)(struct class_device *, char * buf);
223 ssize_t (*store)(struct class_device *, const char * buf, size_t count);
224};
225
226#define CLASS_DEVICE_ATTR(_name,_mode,_show,_store) \
227struct class_device_attribute class_device_attr_##_name = \
228 __ATTR(_name,_mode,_show,_store)
229
Andrew Morton4a7fb632006-08-14 22:43:17 -0700230extern int __must_check class_device_create_file(struct class_device *,
Kay Sieversa7fd6702005-10-01 14:49:43 +0200231 const struct class_device_attribute *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232
Greg Kroah-Hartman74be2272005-10-27 22:25:43 -0700233/**
234 * struct class_device - class devices
235 * @class: pointer to the parent class for this class device. This is required.
236 * @devt: for internal use by the driver core only.
237 * @node: for internal use by the driver core only.
238 * @kobj: for internal use by the driver core only.
239 * @devt_attr: for internal use by the driver core only.
Stephen Hemminger14982212006-05-06 17:55:11 -0700240 * @groups: optional additional groups to be created
Greg Kroah-Hartman74be2272005-10-27 22:25:43 -0700241 * @dev: if set, a symlink to the struct device is created in the sysfs
242 * directory for this struct class device.
243 * @class_data: pointer to whatever you want to store here for this struct
244 * class_device. Use class_get_devdata() and class_set_devdata() to get and
245 * set this pointer.
246 * @parent: pointer to a struct class_device that is the parent of this struct
247 * class_device. If NULL, this class_device will show up at the root of the
248 * struct class in sysfs (which is probably what you want to have happen.)
249 * @release: pointer to a release function for this struct class_device. If
250 * set, this will be called instead of the class specific release function.
251 * Only use this if you want to override the default release function, like
252 * when you are nesting class_device structures.
Kay Sievers312c0042005-11-16 09:00:00 +0100253 * @uevent: pointer to a uevent function for this struct class_device. If
254 * set, this will be called instead of the class specific uevent function.
255 * Only use this if you want to override the default uevent function, like
Greg Kroah-Hartman74be2272005-10-27 22:25:43 -0700256 * when you are nesting class_device structures.
257 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258struct class_device {
259 struct list_head node;
260
261 struct kobject kobj;
262 struct class * class; /* required */
263 dev_t devt; /* dev_t, creates the sysfs "dev" */
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800264 struct class_device_attribute *devt_attr;
Kay Sieversa7fd6702005-10-01 14:49:43 +0200265 struct class_device_attribute uevent_attr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266 struct device * dev; /* not necessary, but nice to have */
267 void * class_data; /* class-specific data */
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700268 struct class_device *parent; /* parent of this child device, if there is one */
Stephen Hemminger14982212006-05-06 17:55:11 -0700269 struct attribute_group ** groups; /* optional groups */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700271 void (*release)(struct class_device *dev);
Kay Sievers312c0042005-11-16 09:00:00 +0100272 int (*uevent)(struct class_device *dev, char **envp,
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700273 int num_envp, char *buffer, int buffer_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 char class_id[BUS_ID_SIZE]; /* unique to this class */
275};
276
277static inline void *
278class_get_devdata (struct class_device *dev)
279{
280 return dev->class_data;
281}
282
283static inline void
284class_set_devdata (struct class_device *dev, void *data)
285{
286 dev->class_data = data;
287}
288
289
Andrew Morton4a7fb632006-08-14 22:43:17 -0700290extern int __must_check class_device_register(struct class_device *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291extern void class_device_unregister(struct class_device *);
292extern void class_device_initialize(struct class_device *);
Andrew Morton4a7fb632006-08-14 22:43:17 -0700293extern int __must_check class_device_add(struct class_device *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294extern void class_device_del(struct class_device *);
295
296extern int class_device_rename(struct class_device *, char *);
297
298extern struct class_device * class_device_get(struct class_device *);
299extern void class_device_put(struct class_device *);
300
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301extern void class_device_remove_file(struct class_device *,
302 const struct class_device_attribute *);
Andrew Morton4a7fb632006-08-14 22:43:17 -0700303extern int __must_check class_device_create_bin_file(struct class_device *,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 struct bin_attribute *);
305extern void class_device_remove_bin_file(struct class_device *,
306 struct bin_attribute *);
307
308struct class_interface {
309 struct list_head node;
310 struct class *class;
311
Dmitry Torokhovd8539d82005-09-15 02:01:36 -0500312 int (*add) (struct class_device *, struct class_interface *);
313 void (*remove) (struct class_device *, struct class_interface *);
Greg Kroah-Hartmanc47ed212006-09-13 15:34:05 +0200314 int (*add_dev) (struct device *, struct class_interface *);
315 void (*remove_dev) (struct device *, struct class_interface *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316};
317
Andrew Morton4a7fb632006-08-14 22:43:17 -0700318extern int __must_check class_interface_register(struct class_interface *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319extern void class_interface_unregister(struct class_interface *);
320
Miguel Ojeda Sandonisab7d7372006-09-13 15:34:05 +0200321extern struct class *class_create(struct module *owner, const char *name);
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800322extern void class_destroy(struct class *cls);
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700323extern struct class_device *class_device_create(struct class *cls,
324 struct class_device *parent,
325 dev_t devt,
326 struct device *device,
Dmitry Torokhovddd5d352006-08-10 01:18:18 -0400327 const char *fmt, ...)
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700328 __attribute__((format(printf,5,6)));
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800329extern void class_device_destroy(struct class *cls, dev_t devt);
330
Kay Sieversa7fd6702005-10-01 14:49:43 +0200331/* interface for exporting device attributes */
332struct device_attribute {
333 struct attribute attr;
334 ssize_t (*show)(struct device *dev, struct device_attribute *attr,
335 char *buf);
336 ssize_t (*store)(struct device *dev, struct device_attribute *attr,
337 const char *buf, size_t count);
338};
339
340#define DEVICE_ATTR(_name,_mode,_show,_store) \
341struct device_attribute dev_attr_##_name = __ATTR(_name,_mode,_show,_store)
342
Andrew Morton4a7fb632006-08-14 22:43:17 -0700343extern int __must_check device_create_file(struct device *device,
344 struct device_attribute * entry);
Kay Sieversa7fd6702005-10-01 14:49:43 +0200345extern void device_remove_file(struct device * dev, struct device_attribute * attr);
Greg Kroah-Hartman2589f1882006-09-19 09:39:19 -0700346extern int __must_check device_create_bin_file(struct device *dev,
347 struct bin_attribute *attr);
348extern void device_remove_bin_file(struct device *dev,
349 struct bin_attribute *attr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350struct device {
mochel@digitalimplant.org36239572005-03-24 19:08:30 -0800351 struct klist klist_children;
352 struct klist_node knode_parent; /* node in sibling list */
mochel@digitalimplant.org94e7b1c2005-03-21 12:25:36 -0800353 struct klist_node knode_driver;
mochel@digitalimplant.org465c7a32005-03-21 11:49:14 -0800354 struct klist_node knode_bus;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 struct device * parent;
356
357 struct kobject kobj;
358 char bus_id[BUS_ID_SIZE]; /* position on parent bus */
Alan Sternf2eaae12006-09-18 16:22:34 -0400359 unsigned is_registered:1;
Kay Sieversa7fd6702005-10-01 14:49:43 +0200360 struct device_attribute uevent_attr;
Greg Kroah-Hartman23681e42006-06-14 12:14:34 -0700361 struct device_attribute *devt_attr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362
mochel@digitalimplant.orgaf703162005-03-21 10:41:04 -0800363 struct semaphore sem; /* semaphore to synchronize calls to
364 * its driver.
365 */
366
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367 struct bus_type * bus; /* type of bus device is on */
368 struct device_driver *driver; /* which driver has allocated this
369 device */
370 void *driver_data; /* data private to the driver */
David Shaohua Li4e10d122005-03-18 18:45:35 -0500371 void *platform_data; /* Platform specific data, device
372 core doesn't touch it */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373 struct dev_pm_info power;
374
Christoph Hellwig87348132006-12-06 20:32:33 -0800375#ifdef CONFIG_NUMA
376 int numa_node; /* NUMA node this device is close to */
377#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378 u64 *dma_mask; /* dma mask (if dma'able device) */
379 u64 coherent_dma_mask;/* Like dma_mask, but for
380 alloc_coherent mappings as
381 not all hardware supports
382 64 bit addresses for consistent
383 allocations such descriptors. */
384
385 struct list_head dma_pools; /* dma pools (if dma'ble) */
386
387 struct dma_coherent_mem *dma_mem; /* internal for coherent mem
388 override */
Benjamin Herrenschmidtc6dbaef2006-11-11 17:18:39 +1100389 /* arch specific additions */
390 struct dev_archdata archdata;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391
Greg Kroah-Hartman23681e42006-06-14 12:14:34 -0700392 /* class_device migration path */
393 struct list_head node;
394 struct class *class; /* optional*/
395 dev_t devt; /* dev_t, creates the sysfs "dev" */
Greg Kroah-Hartmande0ff002006-06-27 00:06:09 -0700396 struct attribute_group **groups; /* optional groups */
Greg Kroah-Hartman23681e42006-06-14 12:14:34 -0700397
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398 void (*release)(struct device * dev);
399};
400
Christoph Hellwig87348132006-12-06 20:32:33 -0800401#ifdef CONFIG_NUMA
402static inline int dev_to_node(struct device *dev)
403{
404 return dev->numa_node;
405}
406static inline void set_dev_node(struct device *dev, int node)
407{
408 dev->numa_node = node;
409}
410#else
411static inline int dev_to_node(struct device *dev)
412{
413 return -1;
414}
415static inline void set_dev_node(struct device *dev, int node)
416{
417}
418#endif
419
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420static inline void *
421dev_get_drvdata (struct device *dev)
422{
423 return dev->driver_data;
424}
425
426static inline void
427dev_set_drvdata (struct device *dev, void *data)
428{
429 dev->driver_data = data;
430}
431
Daniel Ritzd305ef52005-09-22 00:47:24 -0700432static inline int device_is_registered(struct device *dev)
433{
Alan Sternf2eaae12006-09-18 16:22:34 -0400434 return dev->is_registered;
Daniel Ritzd305ef52005-09-22 00:47:24 -0700435}
436
Adrian Bunk1f217822006-12-19 13:01:28 -0800437void driver_init(void);
438
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439/*
440 * High level routines for use by the bus drivers
441 */
Andrew Morton4a7fb632006-08-14 22:43:17 -0700442extern int __must_check device_register(struct device * dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443extern void device_unregister(struct device * dev);
444extern void device_initialize(struct device * dev);
Andrew Morton4a7fb632006-08-14 22:43:17 -0700445extern int __must_check device_add(struct device * dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446extern void device_del(struct device * dev);
Russell King04fed362006-10-22 15:57:18 +0100447extern int device_for_each_child(struct device *, void *,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 int (*fn)(struct device *, void *));
Cornelia Huck5ab69982006-11-16 15:42:07 +0100449extern struct device *device_find_child(struct device *, void *data,
450 int (*match)(struct device *, void *));
Greg Kroah-Hartmana2de48c2006-07-03 14:31:12 -0700451extern int device_rename(struct device *dev, char *new_name);
Cornelia Huck8a824722006-11-20 17:07:51 +0100452extern int device_move(struct device *dev, struct device *new_parent);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453
454/*
455 * Manual binding of a device to driver. See drivers/base/bus.c
456 * for information on use.
457 */
Andrew Mortonf86db392006-08-14 22:43:20 -0700458extern int __must_check device_bind_driver(struct device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459extern void device_release_driver(struct device * dev);
Andrew Morton4a7fb632006-08-14 22:43:17 -0700460extern int __must_check device_attach(struct device * dev);
Andrew Mortonf86db392006-08-14 22:43:20 -0700461extern int __must_check driver_attach(struct device_driver *drv);
462extern int __must_check device_reprobe(struct device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463
Greg Kroah-Hartman23681e42006-06-14 12:14:34 -0700464/*
465 * Easy functions for dynamically creating devices on the fly
466 */
467extern struct device *device_create(struct class *cls, struct device *parent,
Greg Kroah-Hartman5cbe5f82006-08-10 01:19:19 -0400468 dev_t devt, const char *fmt, ...)
Greg Kroah-Hartman23681e42006-06-14 12:14:34 -0700469 __attribute__((format(printf,4,5)));
470extern void device_destroy(struct class *cls, dev_t devt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472/*
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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489
490
Rytchkov Alexey116f2322006-03-22 00:58:53 +0100491/* drivers/base/power/shutdown.c */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492extern void device_shutdown(void);
493
494
495/* drivers/base/firmware.c */
Andrew Morton4a7fb632006-08-14 22:43:17 -0700496extern int __must_check firmware_register(struct subsystem *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497extern void firmware_unregister(struct subsystem *);
498
499/* debugging and troubleshooting/diagnostic helpers. */
Alan Stern3e956372006-06-16 17:10:48 -0400500extern const char *dev_driver_string(struct device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501#define dev_printk(level, dev, format, arg...) \
Alan Stern3e956372006-06-16 17:10:48 -0400502 printk(level "%s %s: " format , dev_driver_string(dev) , (dev)->bus_id , ## arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503
504#ifdef DEBUG
505#define dev_dbg(dev, format, arg...) \
506 dev_printk(KERN_DEBUG , dev , format , ## arg)
507#else
508#define dev_dbg(dev, format, arg...) do { (void)(dev); } while (0)
509#endif
510
511#define dev_err(dev, format, arg...) \
512 dev_printk(KERN_ERR , dev , format , ## arg)
513#define dev_info(dev, format, arg...) \
514 dev_printk(KERN_INFO , dev , format , ## arg)
515#define dev_warn(dev, format, arg...) \
516 dev_printk(KERN_WARNING , dev , format , ## arg)
Tilman Schmidt4f2928d2006-02-24 11:05:45 +0100517#define dev_notice(dev, format, arg...) \
518 dev_printk(KERN_NOTICE , dev , format , ## arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519
520/* Create alias, so I can be autoloaded. */
521#define MODULE_ALIAS_CHARDEV(major,minor) \
522 MODULE_ALIAS("char-major-" __stringify(major) "-" __stringify(minor))
523#define MODULE_ALIAS_CHARDEV_MAJOR(major) \
524 MODULE_ALIAS("char-major-" __stringify(major) "-*")
525#endif /* _DEVICE_H_ */