blob: 479c0b31593c6e3b6e5225144af1a51ae86534e0 [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>
Greg Kroah-Hartman89790fd2007-02-12 22:33:06 -08005 * Copyright (c) 2004-2007 Greg Kroah-Hartman <gregkh@suse.de>
Linus Torvalds1da177e2005-04-16 15:20:36 -07006 *
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
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <linux/ioport.h>
16#include <linux/kobject.h>
mochel@digitalimplant.org465c7a32005-03-21 11:49:14 -080017#include <linux/klist.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include <linux/list.h>
Andrew Morton4a7fb632006-08-14 22:43:17 -070019#include <linux/compiler.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include <linux/types.h>
21#include <linux/module.h>
22#include <linux/pm.h>
23#include <asm/semaphore.h>
24#include <asm/atomic.h>
Benjamin Herrenschmidtc6dbaef2006-11-11 17:18:39 +110025#include <asm/device.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026
27#define DEVICE_NAME_SIZE 50
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -080028/* DEVICE_NAME_HALF is really less than half to accommodate slop */
29#define DEVICE_NAME_HALF __stringify(20)
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#define DEVICE_ID_SIZE 32
31#define BUS_ID_SIZE KOBJ_NAME_LEN
32
33
Linus Torvalds1da177e2005-04-16 15:20:36 -070034struct device;
35struct device_driver;
Greg Kroah-Hartmane5dd1272007-11-28 15:59:15 -080036struct driver_private;
Linus Torvalds1da177e2005-04-16 15:20:36 -070037struct class;
38struct class_device;
Kay Sieversb8c5cec2007-02-16 17:33:36 +010039struct bus_type;
Greg Kroah-Hartmanc6f7e722007-11-01 19:41:16 -070040struct bus_type_private;
Kay Sieversb8c5cec2007-02-16 17:33:36 +010041
42struct bus_attribute {
43 struct attribute attr;
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -080044 ssize_t (*show)(struct bus_type *bus, char *buf);
45 ssize_t (*store)(struct bus_type *bus, const char *buf, size_t count);
Kay Sieversb8c5cec2007-02-16 17:33:36 +010046};
47
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -080048#define BUS_ATTR(_name, _mode, _show, _store) \
49struct bus_attribute bus_attr_##_name = __ATTR(_name, _mode, _show, _store)
Kay Sieversb8c5cec2007-02-16 17:33:36 +010050
51extern int __must_check bus_create_file(struct bus_type *,
52 struct bus_attribute *);
53extern void bus_remove_file(struct bus_type *, struct bus_attribute *);
Linus Torvalds1da177e2005-04-16 15:20:36 -070054
55struct bus_type {
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -080056 const char *name;
57 struct bus_attribute *bus_attrs;
58 struct device_attribute *dev_attrs;
59 struct driver_attribute *drv_attrs;
Linus Torvalds1da177e2005-04-16 15:20:36 -070060
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -080061 int (*match)(struct device *dev, struct device_driver *drv);
62 int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
63 int (*probe)(struct device *dev);
64 int (*remove)(struct device *dev);
65 void (*shutdown)(struct device *dev);
Linus Torvalds7c8265f2006-06-24 14:50:29 -070066
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -080067 int (*suspend)(struct device *dev, pm_message_t state);
68 int (*suspend_late)(struct device *dev, pm_message_t state);
69 int (*resume_early)(struct device *dev);
70 int (*resume)(struct device *dev);
Kay Sieversb8c5cec2007-02-16 17:33:36 +010071
Greg Kroah-Hartmanc6f7e722007-11-01 19:41:16 -070072 struct bus_type_private *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -070073};
74
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -080075extern int __must_check bus_register(struct bus_type *bus);
76extern void bus_unregister(struct bus_type *bus);
Linus Torvalds1da177e2005-04-16 15:20:36 -070077
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -080078extern int __must_check bus_rescan_devices(struct bus_type *bus);
Linus Torvalds1da177e2005-04-16 15:20:36 -070079
Linus Torvalds1da177e2005-04-16 15:20:36 -070080/* iterator helpers for buses */
81
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -080082int bus_for_each_dev(struct bus_type *bus, struct device *start, void *data,
83 int (*fn)(struct device *dev, void *data));
84struct device *bus_find_device(struct bus_type *bus, struct device *start,
85 void *data,
86 int (*match)(struct device *dev, void *data));
Greg Kroah-Hartman1f9ffc02008-01-27 10:29:20 -080087struct device *bus_find_device_by_name(struct bus_type *bus,
88 struct device *start,
89 const char *name);
Linus Torvalds1da177e2005-04-16 15:20:36 -070090
Andrew Morton4a7fb632006-08-14 22:43:17 -070091int __must_check bus_for_each_drv(struct bus_type *bus,
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -080092 struct device_driver *start, void *data,
93 int (*fn)(struct device_driver *, void *));
Linus Torvalds1da177e2005-04-16 15:20:36 -070094
Benjamin Herrenschmidt116af372006-10-25 13:44:59 +100095/*
96 * Bus notifiers: Get notified of addition/removal of devices
97 * and binding/unbinding of drivers to devices.
98 * In the long run, it should be a replacement for the platform
99 * notify hooks.
100 */
101struct notifier_block;
102
103extern int bus_register_notifier(struct bus_type *bus,
104 struct notifier_block *nb);
105extern int bus_unregister_notifier(struct bus_type *bus,
106 struct notifier_block *nb);
107
108/* All 4 notifers below get called with the target struct device *
109 * as an argument. Note that those functions are likely to be called
110 * with the device semaphore held in the core, so be careful.
111 */
112#define BUS_NOTIFY_ADD_DEVICE 0x00000001 /* device added */
113#define BUS_NOTIFY_DEL_DEVICE 0x00000002 /* device removed */
114#define BUS_NOTIFY_BOUND_DRIVER 0x00000003 /* driver bound to device */
115#define BUS_NOTIFY_UNBIND_DRIVER 0x00000004 /* driver about to be
116 unbound */
117
Greg Kroah-Hartman0fed80f2007-11-01 19:41:16 -0700118extern struct kset *bus_get_kset(struct bus_type *bus);
Greg Kroah-Hartmanb2490722007-11-01 19:41:16 -0700119extern struct klist *bus_get_device_klist(struct bus_type *bus);
Greg Kroah-Hartman0fed80f2007-11-01 19:41:16 -0700120
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121struct device_driver {
Greg Kroah-Hartmane5dd1272007-11-28 15:59:15 -0800122 const char *name;
123 struct bus_type *bus;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124
Greg Kroah-Hartmane5dd1272007-11-28 15:59:15 -0800125 struct module *owner;
126 const char *mod_name; /* used for built-in modules */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800128 int (*probe) (struct device *dev);
129 int (*remove) (struct device *dev);
130 void (*shutdown) (struct device *dev);
131 int (*suspend) (struct device *dev, pm_message_t state);
132 int (*resume) (struct device *dev);
Cornelia Huck57c74532007-12-05 12:50:23 +0100133 struct attribute_group **groups;
Greg Kroah-Hartmane5dd1272007-11-28 15:59:15 -0800134
135 struct driver_private *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136};
137
138
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800139extern int __must_check driver_register(struct device_driver *drv);
140extern void driver_unregister(struct device_driver *drv);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800142extern struct device_driver *get_driver(struct device_driver *drv);
143extern void put_driver(struct device_driver *drv);
144extern struct device_driver *driver_find(const char *name,
145 struct bus_type *bus);
Greg Kroah-Hartmand7792492006-07-18 10:59:59 -0700146extern int driver_probe_done(void);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147
Robert P. J. Day405ae7d2007-02-17 19:13:42 +0100148/* sysfs interface for exporting driver attributes */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149
150struct driver_attribute {
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800151 struct attribute attr;
152 ssize_t (*show)(struct device_driver *driver, char *buf);
153 ssize_t (*store)(struct device_driver *driver, const char *buf,
154 size_t count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155};
156
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800157#define DRIVER_ATTR(_name, _mode, _show, _store) \
158struct driver_attribute driver_attr_##_name = \
159 __ATTR(_name, _mode, _show, _store)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800161extern int __must_check driver_create_file(struct device_driver *driver,
162 struct driver_attribute *attr);
163extern void driver_remove_file(struct device_driver *driver,
164 struct driver_attribute *attr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165
Greg Kroah-Hartmancbe9c592007-12-19 15:54:39 -0400166extern int __must_check driver_add_kobj(struct device_driver *drv,
167 struct kobject *kobj,
168 const char *fmt, ...);
169
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800170extern int __must_check driver_for_each_device(struct device_driver *drv,
171 struct device *start,
172 void *data,
173 int (*fn)(struct device *dev,
174 void *));
175struct device *driver_find_device(struct device_driver *drv,
176 struct device *start, void *data,
177 int (*match)(struct device *dev, void *data));
mochel@digitalimplant.orgfae3cd02005-03-21 10:59:56 -0800178
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179/*
180 * device classes
181 */
182struct class {
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800183 const char *name;
184 struct module *owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185
Greg Kroah-Hartman823bccf2007-04-13 13:15:19 -0700186 struct kset subsys;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187 struct list_head children;
Greg Kroah-Hartman23681e42006-06-14 12:14:34 -0700188 struct list_head devices;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 struct list_head interfaces;
Kay Sievers86406242007-03-14 03:25:56 +0100190 struct kset class_dirs;
Dave Youngfd048972008-01-22 15:27:08 +0800191 struct semaphore sem; /* locks children, devices, interfaces */
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800192 struct class_attribute *class_attrs;
193 struct class_device_attribute *class_dev_attrs;
194 struct device_attribute *dev_attrs;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800196 int (*uevent)(struct class_device *dev, struct kobj_uevent_env *env);
197 int (*dev_uevent)(struct device *dev, struct kobj_uevent_env *env);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800199 void (*release)(struct class_device *dev);
200 void (*class_release)(struct class *class);
201 void (*dev_release)(struct device *dev);
Linus Torvalds7c8265f2006-06-24 14:50:29 -0700202
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800203 int (*suspend)(struct device *dev, pm_message_t state);
204 int (*resume)(struct device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205};
206
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800207extern int __must_check class_register(struct class *class);
208extern void class_unregister(struct class *class);
Dave Youngfd048972008-01-22 15:27:08 +0800209extern int class_for_each_device(struct class *class, void *data,
210 int (*fn)(struct device *dev, void *data));
211extern struct device *class_find_device(struct class *class, void *data,
212 int (*match)(struct device *, void *));
213extern struct class_device *class_find_child(struct class *class, void *data,
214 int (*match)(struct class_device *, void *));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216
217struct class_attribute {
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800218 struct attribute attr;
219 ssize_t (*show)(struct class *class, char *buf);
220 ssize_t (*store)(struct class *class, const char *buf, size_t count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221};
222
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800223#define CLASS_ATTR(_name, _mode, _show, _store) \
224struct class_attribute class_attr_##_name = __ATTR(_name, _mode, _show, _store)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800226extern int __must_check class_create_file(struct class *class,
227 const struct class_attribute *attr);
228extern void class_remove_file(struct class *class,
229 const struct class_attribute *attr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230
Kay Sieversa7fd6702005-10-01 14:49:43 +0200231struct class_device_attribute {
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800232 struct attribute attr;
233 ssize_t (*show)(struct class_device *, char *buf);
234 ssize_t (*store)(struct class_device *, const char *buf, size_t count);
Kay Sieversa7fd6702005-10-01 14:49:43 +0200235};
236
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800237#define CLASS_DEVICE_ATTR(_name, _mode, _show, _store) \
Kay Sieversa7fd6702005-10-01 14:49:43 +0200238struct class_device_attribute class_device_attr_##_name = \
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800239 __ATTR(_name, _mode, _show, _store)
Kay Sieversa7fd6702005-10-01 14:49:43 +0200240
Andrew Morton4a7fb632006-08-14 22:43:17 -0700241extern int __must_check class_device_create_file(struct class_device *,
Kay Sieversa7fd6702005-10-01 14:49:43 +0200242 const struct class_device_attribute *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243
Greg Kroah-Hartman74be2272005-10-27 22:25:43 -0700244/**
245 * struct class_device - class devices
246 * @class: pointer to the parent class for this class device. This is required.
247 * @devt: for internal use by the driver core only.
248 * @node: for internal use by the driver core only.
249 * @kobj: for internal use by the driver core only.
Stephen Hemminger14982212006-05-06 17:55:11 -0700250 * @groups: optional additional groups to be created
Greg Kroah-Hartman74be2272005-10-27 22:25:43 -0700251 * @dev: if set, a symlink to the struct device is created in the sysfs
252 * directory for this struct class device.
253 * @class_data: pointer to whatever you want to store here for this struct
254 * class_device. Use class_get_devdata() and class_set_devdata() to get and
255 * set this pointer.
256 * @parent: pointer to a struct class_device that is the parent of this struct
257 * class_device. If NULL, this class_device will show up at the root of the
258 * struct class in sysfs (which is probably what you want to have happen.)
259 * @release: pointer to a release function for this struct class_device. If
260 * set, this will be called instead of the class specific release function.
261 * Only use this if you want to override the default release function, like
262 * when you are nesting class_device structures.
Kay Sievers312c0042005-11-16 09:00:00 +0100263 * @uevent: pointer to a uevent function for this struct class_device. If
264 * set, this will be called instead of the class specific uevent function.
265 * Only use this if you want to override the default uevent function, like
Greg Kroah-Hartman74be2272005-10-27 22:25:43 -0700266 * when you are nesting class_device structures.
267 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268struct class_device {
269 struct list_head node;
270
271 struct kobject kobj;
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800272 struct class *class;
273 dev_t devt;
274 struct device *dev;
275 void *class_data;
276 struct class_device *parent;
277 struct attribute_group **groups;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800279 void (*release)(struct class_device *dev);
280 int (*uevent)(struct class_device *dev, struct kobj_uevent_env *env);
281 char class_id[BUS_ID_SIZE];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282};
283
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800284static inline void *class_get_devdata(struct class_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285{
286 return dev->class_data;
287}
288
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800289static inline void class_set_devdata(struct class_device *dev, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290{
291 dev->class_data = data;
292}
293
294
Andrew Morton4a7fb632006-08-14 22:43:17 -0700295extern int __must_check class_device_register(struct class_device *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296extern void class_device_unregister(struct class_device *);
297extern void class_device_initialize(struct class_device *);
Andrew Morton4a7fb632006-08-14 22:43:17 -0700298extern int __must_check class_device_add(struct class_device *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299extern void class_device_del(struct class_device *);
300
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800301extern struct class_device *class_device_get(struct class_device *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302extern void class_device_put(struct class_device *);
303
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800304extern void class_device_remove_file(struct class_device *,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305 const struct class_device_attribute *);
Greg Kroah-Hartmand919fd42007-10-31 12:51:29 -0700306extern int __must_check class_device_create_bin_file(struct class_device *,
307 struct bin_attribute *);
308extern void class_device_remove_bin_file(struct class_device *,
309 struct bin_attribute *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310
311struct class_interface {
312 struct list_head node;
313 struct class *class;
314
Dmitry Torokhovd8539d82005-09-15 02:01:36 -0500315 int (*add) (struct class_device *, struct class_interface *);
316 void (*remove) (struct class_device *, struct class_interface *);
Greg Kroah-Hartmanc47ed212006-09-13 15:34:05 +0200317 int (*add_dev) (struct device *, struct class_interface *);
318 void (*remove_dev) (struct device *, struct class_interface *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319};
320
Andrew Morton4a7fb632006-08-14 22:43:17 -0700321extern int __must_check class_interface_register(struct class_interface *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322extern void class_interface_unregister(struct class_interface *);
323
Miguel Ojeda Sandonisab7d7372006-09-13 15:34:05 +0200324extern struct class *class_create(struct module *owner, const char *name);
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800325extern void class_destroy(struct class *cls);
Greg Kroah-Hartman51d172d2005-10-27 22:25:43 -0700326extern struct class_device *class_device_create(struct class *cls,
327 struct class_device *parent,
328 dev_t devt,
329 struct device *device,
Dmitry Torokhovddd5d352006-08-10 01:18:18 -0400330 const char *fmt, ...)
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800331 __attribute__((format(printf, 5, 6)));
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800332extern void class_device_destroy(struct class *cls, dev_t devt);
333
Kay Sievers414264f2007-03-12 21:08:57 +0100334/*
335 * The type of device, "struct device" is embedded in. A class
336 * or bus can contain devices of different types
337 * like "partitions" and "disks", "mouse" and "event".
338 * This identifies the device type and carries type-specific
339 * information, equivalent to the kobj_type of a kobject.
340 * If "name" is specified, the uevent will contain it in
341 * the DEVTYPE variable.
342 */
Kay Sieversf9f852d2006-10-07 21:54:55 +0200343struct device_type {
Kay Sievers414264f2007-03-12 21:08:57 +0100344 const char *name;
Dmitry Torokhov621a1672007-03-10 01:37:34 -0500345 struct attribute_group **groups;
Kay Sievers7eff2e72007-08-14 15:15:12 +0200346 int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
Kay Sieversf9f852d2006-10-07 21:54:55 +0200347 void (*release)(struct device *dev);
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800348 int (*suspend)(struct device *dev, pm_message_t state);
349 int (*resume)(struct device *dev);
Kay Sieversf9f852d2006-10-07 21:54:55 +0200350};
351
Kay Sieversa7fd6702005-10-01 14:49:43 +0200352/* interface for exporting device attributes */
353struct device_attribute {
354 struct attribute attr;
355 ssize_t (*show)(struct device *dev, struct device_attribute *attr,
356 char *buf);
357 ssize_t (*store)(struct device *dev, struct device_attribute *attr,
358 const char *buf, size_t count);
359};
360
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800361#define DEVICE_ATTR(_name, _mode, _show, _store) \
362struct device_attribute dev_attr_##_name = __ATTR(_name, _mode, _show, _store)
Kay Sieversa7fd6702005-10-01 14:49:43 +0200363
Andrew Morton4a7fb632006-08-14 22:43:17 -0700364extern int __must_check device_create_file(struct device *device,
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800365 struct device_attribute *entry);
366extern void device_remove_file(struct device *dev,
367 struct device_attribute *attr);
Greg Kroah-Hartman2589f1882006-09-19 09:39:19 -0700368extern int __must_check device_create_bin_file(struct device *dev,
369 struct bin_attribute *attr);
370extern void device_remove_bin_file(struct device *dev,
371 struct bin_attribute *attr);
Alan Stern523ded72007-04-26 00:12:04 -0700372extern int device_schedule_callback_owner(struct device *dev,
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800373 void (*func)(struct device *dev), struct module *owner);
Alan Stern523ded72007-04-26 00:12:04 -0700374
375/* This is a macro to avoid include problems with THIS_MODULE */
376#define device_schedule_callback(dev, func) \
377 device_schedule_callback_owner(dev, func, THIS_MODULE)
Tejun Heo9ac78492007-01-20 16:00:26 +0900378
379/* device resource management */
380typedef void (*dr_release_t)(struct device *dev, void *res);
381typedef int (*dr_match_t)(struct device *dev, void *res, void *match_data);
382
383#ifdef CONFIG_DEBUG_DEVRES
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800384extern void *__devres_alloc(dr_release_t release, size_t size, gfp_t gfp,
Tejun Heo9ac78492007-01-20 16:00:26 +0900385 const char *name);
386#define devres_alloc(release, size, gfp) \
387 __devres_alloc(release, size, gfp, #release)
388#else
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800389extern void *devres_alloc(dr_release_t release, size_t size, gfp_t gfp);
Tejun Heo9ac78492007-01-20 16:00:26 +0900390#endif
391extern void devres_free(void *res);
392extern void devres_add(struct device *dev, void *res);
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800393extern void *devres_find(struct device *dev, dr_release_t release,
Tejun Heo9ac78492007-01-20 16:00:26 +0900394 dr_match_t match, void *match_data);
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800395extern void *devres_get(struct device *dev, void *new_res,
396 dr_match_t match, void *match_data);
397extern void *devres_remove(struct device *dev, dr_release_t release,
398 dr_match_t match, void *match_data);
Tejun Heo9ac78492007-01-20 16:00:26 +0900399extern int devres_destroy(struct device *dev, dr_release_t release,
400 dr_match_t match, void *match_data);
401
402/* devres group */
403extern void * __must_check devres_open_group(struct device *dev, void *id,
404 gfp_t gfp);
405extern void devres_close_group(struct device *dev, void *id);
406extern void devres_remove_group(struct device *dev, void *id);
407extern int devres_release_group(struct device *dev, void *id);
408
409/* managed kzalloc/kfree for device drivers, no kmalloc, always use kzalloc */
410extern void *devm_kzalloc(struct device *dev, size_t size, gfp_t gfp);
411extern void devm_kfree(struct device *dev, void *p);
412
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413struct device {
mochel@digitalimplant.org36239572005-03-24 19:08:30 -0800414 struct klist klist_children;
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800415 struct klist_node knode_parent; /* node in sibling list */
mochel@digitalimplant.org94e7b1c52005-03-21 12:25:36 -0800416 struct klist_node knode_driver;
mochel@digitalimplant.org465c7a32005-03-21 11:49:14 -0800417 struct klist_node knode_bus;
David Brownell49a4ec12007-05-08 00:29:39 -0700418 struct device *parent;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419
420 struct kobject kobj;
421 char bus_id[BUS_ID_SIZE]; /* position on parent bus */
Kay Sieversf9f852d2006-10-07 21:54:55 +0200422 struct device_type *type;
Alan Sternf2eaae12006-09-18 16:22:34 -0400423 unsigned is_registered:1;
David Brownell49a4ec12007-05-08 00:29:39 -0700424 unsigned uevent_suppress:1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425
mochel@digitalimplant.orgaf703162005-03-21 10:41:04 -0800426 struct semaphore sem; /* semaphore to synchronize calls to
427 * its driver.
428 */
429
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800430 struct bus_type *bus; /* type of bus device is on */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 struct device_driver *driver; /* which driver has allocated this
432 device */
433 void *driver_data; /* data private to the driver */
David Shaohua Li4e10d122005-03-18 18:45:35 -0500434 void *platform_data; /* Platform specific data, device
435 core doesn't touch it */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436 struct dev_pm_info power;
437
Christoph Hellwig87348132006-12-06 20:32:33 -0800438#ifdef CONFIG_NUMA
439 int numa_node; /* NUMA node this device is close to */
440#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 u64 *dma_mask; /* dma mask (if dma'able device) */
442 u64 coherent_dma_mask;/* Like dma_mask, but for
443 alloc_coherent mappings as
444 not all hardware supports
445 64 bit addresses for consistent
446 allocations such descriptors. */
447
448 struct list_head dma_pools; /* dma pools (if dma'ble) */
449
450 struct dma_coherent_mem *dma_mem; /* internal for coherent mem
451 override */
Benjamin Herrenschmidtc6dbaef2006-11-11 17:18:39 +1100452 /* arch specific additions */
453 struct dev_archdata archdata;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454
Tejun Heo9ac78492007-01-20 16:00:26 +0900455 spinlock_t devres_lock;
456 struct list_head devres_head;
457
Greg Kroah-Hartman23681e42006-06-14 12:14:34 -0700458 /* class_device migration path */
459 struct list_head node;
Kay Sieversb7a3e812006-10-07 21:54:55 +0200460 struct class *class;
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800461 dev_t devt; /* dev_t, creates the sysfs "dev" */
Greg Kroah-Hartmande0ff002006-06-27 00:06:09 -0700462 struct attribute_group **groups; /* optional groups */
Greg Kroah-Hartman23681e42006-06-14 12:14:34 -0700463
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800464 void (*release)(struct device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465};
466
Christoph Hellwig87348132006-12-06 20:32:33 -0800467#ifdef CONFIG_NUMA
468static inline int dev_to_node(struct device *dev)
469{
470 return dev->numa_node;
471}
472static inline void set_dev_node(struct device *dev, int node)
473{
474 dev->numa_node = node;
475}
476#else
477static inline int dev_to_node(struct device *dev)
478{
479 return -1;
480}
481static inline void set_dev_node(struct device *dev, int node)
482{
483}
484#endif
485
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800486static inline void *dev_get_drvdata(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487{
488 return dev->driver_data;
489}
490
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800491static inline void dev_set_drvdata(struct device *dev, void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492{
493 dev->driver_data = data;
494}
495
Daniel Ritzd305ef52005-09-22 00:47:24 -0700496static inline int device_is_registered(struct device *dev)
497{
Alan Sternf2eaae12006-09-18 16:22:34 -0400498 return dev->is_registered;
Daniel Ritzd305ef52005-09-22 00:47:24 -0700499}
500
Adrian Bunk1f217822006-12-19 13:01:28 -0800501void driver_init(void);
502
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503/*
504 * High level routines for use by the bus drivers
505 */
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800506extern int __must_check device_register(struct device *dev);
507extern void device_unregister(struct device *dev);
508extern void device_initialize(struct device *dev);
509extern int __must_check device_add(struct device *dev);
510extern void device_del(struct device *dev);
511extern int device_for_each_child(struct device *dev, void *data,
512 int (*fn)(struct device *dev, void *data));
513extern struct device *device_find_child(struct device *dev, void *data,
514 int (*match)(struct device *dev, void *data));
Greg Kroah-Hartmana2de48c2006-07-03 14:31:12 -0700515extern int device_rename(struct device *dev, char *new_name);
Cornelia Huck8a824722006-11-20 17:07:51 +0100516extern int device_move(struct device *dev, struct device *new_parent);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517
518/*
519 * Manual binding of a device to driver. See drivers/base/bus.c
520 * for information on use.
521 */
Andrew Mortonf86db392006-08-14 22:43:20 -0700522extern int __must_check device_bind_driver(struct device *dev);
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800523extern void device_release_driver(struct device *dev);
524extern int __must_check device_attach(struct device *dev);
Andrew Mortonf86db392006-08-14 22:43:20 -0700525extern int __must_check driver_attach(struct device_driver *drv);
526extern int __must_check device_reprobe(struct device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527
Greg Kroah-Hartman23681e42006-06-14 12:14:34 -0700528/*
529 * Easy functions for dynamically creating devices on the fly
530 */
531extern struct device *device_create(struct class *cls, struct device *parent,
Greg Kroah-Hartman5cbe5f82006-08-10 01:19:19 -0400532 dev_t devt, const char *fmt, ...)
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800533 __attribute__((format(printf, 4, 5)));
Greg Kroah-Hartman23681e42006-06-14 12:14:34 -0700534extern void device_destroy(struct class *cls, dev_t devt);
Rafael J. Wysocki775b64d2008-01-12 20:40:46 +0100535#ifdef CONFIG_PM_SLEEP
536extern void destroy_suspended_device(struct class *cls, dev_t devt);
Rafael J. Wysocki9617c3e2008-01-25 01:30:25 +0100537extern void device_pm_schedule_removal(struct device *);
Rafael J. Wysocki775b64d2008-01-12 20:40:46 +0100538#else /* !CONFIG_PM_SLEEP */
539static inline void destroy_suspended_device(struct class *cls, dev_t devt)
540{
541 device_destroy(cls, devt);
542}
Rafael J. Wysocki9617c3e2008-01-25 01:30:25 +0100543
544static inline void device_pm_schedule_removal(struct device *dev)
545{
546 device_unregister(dev);
547}
Rafael J. Wysocki775b64d2008-01-12 20:40:46 +0100548#endif /* !CONFIG_PM_SLEEP */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550/*
551 * Platform "fixup" functions - allow the platform to have their say
552 * about devices and actions that the general device layer doesn't
553 * know about.
554 */
555/* Notify platform of device discovery */
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800556extern int (*platform_notify)(struct device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800558extern int (*platform_notify_remove)(struct device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559
560
561/**
562 * get_device - atomically increment the reference count for the device.
563 *
564 */
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800565extern struct device *get_device(struct device *dev);
566extern void put_device(struct device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567
568
Rytchkov Alexey116f232b2006-03-22 00:58:53 +0100569/* drivers/base/power/shutdown.c */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570extern void device_shutdown(void);
571
Rafael J. Wysocki58b3b712007-07-26 16:29:55 +0200572/* drivers/base/sys.c */
573extern void sysdev_shutdown(void);
574
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575/* debugging and troubleshooting/diagnostic helpers. */
Alan Stern3e956372006-06-16 17:10:48 -0400576extern const char *dev_driver_string(struct device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577#define dev_printk(level, dev, format, arg...) \
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800578 printk(level "%s %s: " format , dev_driver_string(dev) , \
579 (dev)->bus_id , ## arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580
Emil Medve7b8712e2007-10-30 14:37:14 -0500581#define dev_emerg(dev, format, arg...) \
582 dev_printk(KERN_EMERG , dev , format , ## arg)
583#define dev_alert(dev, format, arg...) \
584 dev_printk(KERN_ALERT , dev , format , ## arg)
585#define dev_crit(dev, format, arg...) \
586 dev_printk(KERN_CRIT , dev , format , ## arg)
587#define dev_err(dev, format, arg...) \
588 dev_printk(KERN_ERR , dev , format , ## arg)
589#define dev_warn(dev, format, arg...) \
590 dev_printk(KERN_WARNING , dev , format , ## arg)
591#define dev_notice(dev, format, arg...) \
592 dev_printk(KERN_NOTICE , dev , format , ## arg)
593#define dev_info(dev, format, arg...) \
594 dev_printk(KERN_INFO , dev , format , ## arg)
595
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596#ifdef DEBUG
597#define dev_dbg(dev, format, arg...) \
598 dev_printk(KERN_DEBUG , dev , format , ## arg)
599#else
Dan Williams404d5b12007-04-26 00:12:10 -0700600static inline int __attribute__ ((format (printf, 2, 3)))
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800601dev_dbg(struct device *dev, const char *fmt, ...)
Dan Williams404d5b12007-04-26 00:12:10 -0700602{
603 return 0;
604}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605#endif
606
David Brownellaebdc3b2007-07-12 22:08:22 -0700607#ifdef VERBOSE_DEBUG
608#define dev_vdbg dev_dbg
609#else
610static inline int __attribute__ ((format (printf, 2, 3)))
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800611dev_vdbg(struct device *dev, const char *fmt, ...)
David Brownellaebdc3b2007-07-12 22:08:22 -0700612{
613 return 0;
614}
615#endif
616
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617/* Create alias, so I can be autoloaded. */
618#define MODULE_ALIAS_CHARDEV(major,minor) \
619 MODULE_ALIAS("char-major-" __stringify(major) "-" __stringify(minor))
620#define MODULE_ALIAS_CHARDEV_MAJOR(major) \
621 MODULE_ALIAS("char-major-" __stringify(major) "-*")
622#endif /* _DEVICE_H_ */