blob: 241b96bcd7ad252c223e264e5b5ce8de09c6e528 [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-Hartmanb4028432009-05-11 14:16:57 -07005 * Copyright (c) 2004-2009 Greg Kroah-Hartman <gregkh@suse.de>
6 * Copyright (c) 2008-2009 Novell Inc.
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 *
8 * This file is released under the GPLv2
9 *
10 * See Documentation/driver-model/ for more information.
11 */
12
13#ifndef _DEVICE_H_
14#define _DEVICE_H_
15
Linus Torvalds1da177e2005-04-16 15:20:36 -070016#include <linux/ioport.h>
17#include <linux/kobject.h>
mochel@digitalimplant.org465c7a32005-03-21 11:49:14 -080018#include <linux/klist.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include <linux/list.h>
Matthew Wilcoxd2a3b912008-05-28 09:28:39 -070020#include <linux/lockdep.h>
Andrew Morton4a7fb632006-08-14 22:43:17 -070021#include <linux/compiler.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include <linux/types.h>
23#include <linux/module.h>
24#include <linux/pm.h>
Matthew Wilcox6188e102008-04-18 22:21:05 -040025#include <linux/semaphore.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include <asm/atomic.h>
Benjamin Herrenschmidtc6dbaef2006-11-11 17:18:39 +110027#include <asm/device.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028
Linus Torvalds1da177e2005-04-16 15:20:36 -070029struct device;
Greg Kroah-Hartmanfb069a52008-12-16 12:23:36 -080030struct device_private;
Linus Torvalds1da177e2005-04-16 15:20:36 -070031struct device_driver;
Greg Kroah-Hartmane5dd1272007-11-28 15:59:15 -080032struct driver_private;
Linus Torvalds1da177e2005-04-16 15:20:36 -070033struct class;
Greg Kroah-Hartman7c714482008-01-22 18:17:41 -050034struct class_private;
Kay Sieversb8c5cec2007-02-16 17:33:36 +010035struct bus_type;
Greg Kroah-Hartmanc6f7e722007-11-01 19:41:16 -070036struct bus_type_private;
Kay Sieversb8c5cec2007-02-16 17:33:36 +010037
38struct bus_attribute {
39 struct attribute attr;
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -080040 ssize_t (*show)(struct bus_type *bus, char *buf);
41 ssize_t (*store)(struct bus_type *bus, const char *buf, size_t count);
Kay Sieversb8c5cec2007-02-16 17:33:36 +010042};
43
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -080044#define BUS_ATTR(_name, _mode, _show, _store) \
45struct bus_attribute bus_attr_##_name = __ATTR(_name, _mode, _show, _store)
Kay Sieversb8c5cec2007-02-16 17:33:36 +010046
47extern int __must_check bus_create_file(struct bus_type *,
48 struct bus_attribute *);
49extern void bus_remove_file(struct bus_type *, struct bus_attribute *);
Linus Torvalds1da177e2005-04-16 15:20:36 -070050
51struct bus_type {
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -080052 const char *name;
53 struct bus_attribute *bus_attrs;
54 struct device_attribute *dev_attrs;
55 struct driver_attribute *drv_attrs;
Linus Torvalds1da177e2005-04-16 15:20:36 -070056
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -080057 int (*match)(struct device *dev, struct device_driver *drv);
58 int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
59 int (*probe)(struct device *dev);
60 int (*remove)(struct device *dev);
61 void (*shutdown)(struct device *dev);
Linus Torvalds7c8265f2006-06-24 14:50:29 -070062
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -080063 int (*suspend)(struct device *dev, pm_message_t state);
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -080064 int (*resume)(struct device *dev);
Kay Sieversb8c5cec2007-02-16 17:33:36 +010065
Dmitry Torokhov8150f322009-07-24 22:11:32 -070066 const struct dev_pm_ops *pm;
Rafael J. Wysocki1eede072008-05-20 23:00:01 +020067
Greg Kroah-Hartmanc6f7e722007-11-01 19:41:16 -070068 struct bus_type_private *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -070069};
70
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -080071extern int __must_check bus_register(struct bus_type *bus);
72extern void bus_unregister(struct bus_type *bus);
Linus Torvalds1da177e2005-04-16 15:20:36 -070073
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -080074extern int __must_check bus_rescan_devices(struct bus_type *bus);
Linus Torvalds1da177e2005-04-16 15:20:36 -070075
Linus Torvalds1da177e2005-04-16 15:20:36 -070076/* iterator helpers for buses */
77
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -080078int bus_for_each_dev(struct bus_type *bus, struct device *start, void *data,
79 int (*fn)(struct device *dev, void *data));
80struct device *bus_find_device(struct bus_type *bus, struct device *start,
81 void *data,
82 int (*match)(struct device *dev, void *data));
Greg Kroah-Hartman1f9ffc02008-01-27 10:29:20 -080083struct device *bus_find_device_by_name(struct bus_type *bus,
84 struct device *start,
85 const char *name);
Linus Torvalds1da177e2005-04-16 15:20:36 -070086
Andrew Morton4a7fb632006-08-14 22:43:17 -070087int __must_check bus_for_each_drv(struct bus_type *bus,
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -080088 struct device_driver *start, void *data,
89 int (*fn)(struct device_driver *, void *));
Linus Torvalds1da177e2005-04-16 15:20:36 -070090
Greg Kroah-Hartman99178b02008-08-26 11:00:57 -050091void bus_sort_breadthfirst(struct bus_type *bus,
92 int (*compare)(const struct device *a,
93 const struct device *b));
Benjamin Herrenschmidt116af372006-10-25 13:44:59 +100094/*
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
Greg Kroah-Hartman8e9394c2010-02-17 10:57:05 -0800109 * with the device lock held in the core, so be careful.
Benjamin Herrenschmidt116af372006-10-25 13:44:59 +1000110 */
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 */
Joerg Roedel309b7d62009-04-24 14:57:00 +0200116#define BUS_NOTIFY_UNBOUND_DRIVER 0x00000005 /* driver is unbound
117 from the device */
Benjamin Herrenschmidt116af372006-10-25 13:44:59 +1000118
Greg Kroah-Hartman0fed80f2007-11-01 19:41:16 -0700119extern struct kset *bus_get_kset(struct bus_type *bus);
Greg Kroah-Hartmanb2490722007-11-01 19:41:16 -0700120extern struct klist *bus_get_device_klist(struct bus_type *bus);
Greg Kroah-Hartman0fed80f2007-11-01 19:41:16 -0700121
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122struct device_driver {
Greg Kroah-Hartmane5dd1272007-11-28 15:59:15 -0800123 const char *name;
124 struct bus_type *bus;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125
Greg Kroah-Hartmane5dd1272007-11-28 15:59:15 -0800126 struct module *owner;
Dmitry Torokhov1a6f2a72009-10-12 20:17:41 -0700127 const char *mod_name; /* used for built-in modules */
128
129 bool suppress_bind_attrs; /* disables bind/unbind via sysfs */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800131 int (*probe) (struct device *dev);
132 int (*remove) (struct device *dev);
133 void (*shutdown) (struct device *dev);
134 int (*suspend) (struct device *dev, pm_message_t state);
135 int (*resume) (struct device *dev);
David Brownella4dbd672009-06-24 10:06:31 -0700136 const struct attribute_group **groups;
Greg Kroah-Hartmane5dd1272007-11-28 15:59:15 -0800137
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700138 const struct dev_pm_ops *pm;
Rafael J. Wysocki1eede072008-05-20 23:00:01 +0200139
Greg Kroah-Hartmane5dd1272007-11-28 15:59:15 -0800140 struct driver_private *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141};
142
143
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800144extern int __must_check driver_register(struct device_driver *drv);
145extern void driver_unregister(struct device_driver *drv);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800147extern struct device_driver *get_driver(struct device_driver *drv);
148extern void put_driver(struct device_driver *drv);
149extern struct device_driver *driver_find(const char *name,
150 struct bus_type *bus);
Greg Kroah-Hartmand7792492006-07-18 10:59:59 -0700151extern int driver_probe_done(void);
Ming Leib23530e2009-02-21 16:45:07 +0800152extern void wait_for_device_probe(void);
Arjan van de Ven216773a2009-02-14 01:59:06 +0100153
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154
Robert P. J. Day405ae7d2007-02-17 19:13:42 +0100155/* sysfs interface for exporting driver attributes */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156
157struct driver_attribute {
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800158 struct attribute attr;
159 ssize_t (*show)(struct device_driver *driver, char *buf);
160 ssize_t (*store)(struct device_driver *driver, const char *buf,
161 size_t count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162};
163
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800164#define DRIVER_ATTR(_name, _mode, _show, _store) \
165struct driver_attribute driver_attr_##_name = \
166 __ATTR(_name, _mode, _show, _store)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800168extern int __must_check driver_create_file(struct device_driver *driver,
Phil Carmody099c2f22009-12-18 15:34:21 +0200169 const struct driver_attribute *attr);
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800170extern void driver_remove_file(struct device_driver *driver,
Phil Carmody099c2f22009-12-18 15:34:21 +0200171 const struct driver_attribute *attr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172
Greg Kroah-Hartmancbe9c592007-12-19 15:54:39 -0400173extern int __must_check driver_add_kobj(struct device_driver *drv,
174 struct kobject *kobj,
175 const char *fmt, ...);
176
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800177extern int __must_check driver_for_each_device(struct device_driver *drv,
178 struct device *start,
179 void *data,
180 int (*fn)(struct device *dev,
181 void *));
182struct device *driver_find_device(struct device_driver *drv,
183 struct device *start, void *data,
184 int (*match)(struct device *dev, void *data));
mochel@digitalimplant.orgfae3cd02005-03-21 10:59:56 -0800185
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186/*
187 * device classes
188 */
189struct class {
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800190 const char *name;
191 struct module *owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800193 struct class_attribute *class_attrs;
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800194 struct device_attribute *dev_attrs;
Dan Williamse105b8b2008-04-21 10:51:07 -0700195 struct kobject *dev_kobj;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800197 int (*dev_uevent)(struct device *dev, struct kobj_uevent_env *env);
Kay Sieverse454cea2009-09-18 23:01:12 +0200198 char *(*devnode)(struct device *dev, mode_t *mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800200 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);
Rafael J. Wysocki1eede072008-05-20 23:00:01 +0200205
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700206 const struct dev_pm_ops *pm;
207
Greg Kroah-Hartman7c714482008-01-22 18:17:41 -0500208 struct class_private *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209};
210
Tejun Heo5a3ceb82008-08-25 19:50:19 +0200211struct class_dev_iter {
212 struct klist_iter ki;
213 const struct device_type *type;
214};
215
Dan Williamse105b8b2008-04-21 10:51:07 -0700216extern struct kobject *sysfs_dev_block_kobj;
217extern struct kobject *sysfs_dev_char_kobj;
Matthew Wilcoxd2a3b912008-05-28 09:28:39 -0700218extern int __must_check __class_register(struct class *class,
219 struct lock_class_key *key);
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800220extern void class_unregister(struct class *class);
Matthew Wilcoxd2a3b912008-05-28 09:28:39 -0700221
222/* This is a #define to keep the compiler from merging different
223 * instances of the __key variable */
224#define class_register(class) \
225({ \
226 static struct lock_class_key __key; \
227 __class_register(class, &__key); \
228})
229
Jean Delvare46227092009-08-04 12:55:34 +0200230struct class_compat;
231struct class_compat *class_compat_register(const char *name);
232void class_compat_unregister(struct class_compat *cls);
233int class_compat_create_link(struct class_compat *cls, struct device *dev,
234 struct device *device_link);
235void class_compat_remove_link(struct class_compat *cls, struct device *dev,
236 struct device *device_link);
237
Tejun Heo5a3ceb82008-08-25 19:50:19 +0200238extern void class_dev_iter_init(struct class_dev_iter *iter,
239 struct class *class,
240 struct device *start,
241 const struct device_type *type);
242extern struct device *class_dev_iter_next(struct class_dev_iter *iter);
243extern void class_dev_iter_exit(struct class_dev_iter *iter);
244
Greg Kroah-Hartman93562b52008-05-22 17:21:08 -0400245extern int class_for_each_device(struct class *class, struct device *start,
246 void *data,
Dave Youngfd048972008-01-22 15:27:08 +0800247 int (*fn)(struct device *dev, void *data));
Greg Kroah-Hartman695794a2008-05-22 17:21:08 -0400248extern struct device *class_find_device(struct class *class,
249 struct device *start, void *data,
Dave Youngfd048972008-01-22 15:27:08 +0800250 int (*match)(struct device *, void *));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251
252struct class_attribute {
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800253 struct attribute attr;
Andi Kleen28812fe2010-01-05 12:48:07 +0100254 ssize_t (*show)(struct class *class, struct class_attribute *attr,
255 char *buf);
256 ssize_t (*store)(struct class *class, struct class_attribute *attr,
257 const char *buf, size_t count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258};
259
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800260#define CLASS_ATTR(_name, _mode, _show, _store) \
261struct class_attribute class_attr_##_name = __ATTR(_name, _mode, _show, _store)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800263extern int __must_check class_create_file(struct class *class,
264 const struct class_attribute *attr);
265extern void class_remove_file(struct class *class,
266 const struct class_attribute *attr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267
Andi Kleen869dfc82010-01-05 12:48:08 +0100268/* Simple class attribute that is just a static string */
269
270struct class_attribute_string {
271 struct class_attribute attr;
272 char *str;
273};
274
275/* Currently read-only only */
276#define _CLASS_ATTR_STRING(_name, _mode, _str) \
277 { __ATTR(_name, _mode, show_class_attr_string, NULL), _str }
278#define CLASS_ATTR_STRING(_name, _mode, _str) \
279 struct class_attribute_string class_attr_##_name = \
280 _CLASS_ATTR_STRING(_name, _mode, _str)
281
282extern ssize_t show_class_attr_string(struct class *class, struct class_attribute *attr,
283 char *buf);
284
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285struct class_interface {
286 struct list_head node;
287 struct class *class;
288
Greg Kroah-Hartmanc47ed212006-09-13 15:34:05 +0200289 int (*add_dev) (struct device *, struct class_interface *);
290 void (*remove_dev) (struct device *, struct class_interface *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291};
292
Andrew Morton4a7fb632006-08-14 22:43:17 -0700293extern int __must_check class_interface_register(struct class_interface *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294extern void class_interface_unregister(struct class_interface *);
295
Matthew Wilcoxd2a3b912008-05-28 09:28:39 -0700296extern struct class * __must_check __class_create(struct module *owner,
297 const char *name,
298 struct lock_class_key *key);
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800299extern void class_destroy(struct class *cls);
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800300
Matthew Wilcoxd2a3b912008-05-28 09:28:39 -0700301/* This is a #define to keep the compiler from merging different
302 * instances of the __key variable */
303#define class_create(owner, name) \
304({ \
305 static struct lock_class_key __key; \
306 __class_create(owner, name, &__key); \
307})
308
Kay Sievers414264f2007-03-12 21:08:57 +0100309/*
310 * The type of device, "struct device" is embedded in. A class
311 * or bus can contain devices of different types
312 * like "partitions" and "disks", "mouse" and "event".
313 * This identifies the device type and carries type-specific
314 * information, equivalent to the kobj_type of a kobject.
315 * If "name" is specified, the uevent will contain it in
316 * the DEVTYPE variable.
317 */
Kay Sieversf9f852d2006-10-07 21:54:55 +0200318struct device_type {
Kay Sievers414264f2007-03-12 21:08:57 +0100319 const char *name;
David Brownella4dbd672009-06-24 10:06:31 -0700320 const struct attribute_group **groups;
Kay Sievers7eff2e72007-08-14 15:15:12 +0200321 int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
Kay Sieverse454cea2009-09-18 23:01:12 +0200322 char *(*devnode)(struct device *dev, mode_t *mode);
Kay Sieversf9f852d2006-10-07 21:54:55 +0200323 void (*release)(struct device *dev);
Rafael J. Wysocki1eede072008-05-20 23:00:01 +0200324
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700325 const struct dev_pm_ops *pm;
Kay Sieversf9f852d2006-10-07 21:54:55 +0200326};
327
Kay Sieversa7fd6702005-10-01 14:49:43 +0200328/* interface for exporting device attributes */
329struct device_attribute {
330 struct attribute attr;
331 ssize_t (*show)(struct device *dev, struct device_attribute *attr,
332 char *buf);
333 ssize_t (*store)(struct device *dev, struct device_attribute *attr,
334 const char *buf, size_t count);
335};
336
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800337#define DEVICE_ATTR(_name, _mode, _show, _store) \
338struct device_attribute dev_attr_##_name = __ATTR(_name, _mode, _show, _store)
Kay Sieversa7fd6702005-10-01 14:49:43 +0200339
Andrew Morton4a7fb632006-08-14 22:43:17 -0700340extern int __must_check device_create_file(struct device *device,
Phil Carmody66ecb922009-12-18 15:34:20 +0200341 const struct device_attribute *entry);
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800342extern void device_remove_file(struct device *dev,
Phil Carmody26579ab2009-12-18 15:34:19 +0200343 const struct device_attribute *attr);
Greg Kroah-Hartman2589f1882006-09-19 09:39:19 -0700344extern int __must_check device_create_bin_file(struct device *dev,
Phil Carmody66ecb922009-12-18 15:34:20 +0200345 const struct bin_attribute *attr);
Greg Kroah-Hartman2589f1882006-09-19 09:39:19 -0700346extern void device_remove_bin_file(struct device *dev,
Phil Carmody66ecb922009-12-18 15:34:20 +0200347 const struct bin_attribute *attr);
Alan Stern523ded72007-04-26 00:12:04 -0700348extern int device_schedule_callback_owner(struct device *dev,
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800349 void (*func)(struct device *dev), struct module *owner);
Alan Stern523ded72007-04-26 00:12:04 -0700350
351/* This is a macro to avoid include problems with THIS_MODULE */
352#define device_schedule_callback(dev, func) \
353 device_schedule_callback_owner(dev, func, THIS_MODULE)
Tejun Heo9ac78492007-01-20 16:00:26 +0900354
355/* device resource management */
356typedef void (*dr_release_t)(struct device *dev, void *res);
357typedef int (*dr_match_t)(struct device *dev, void *res, void *match_data);
358
359#ifdef CONFIG_DEBUG_DEVRES
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800360extern void *__devres_alloc(dr_release_t release, size_t size, gfp_t gfp,
Tejun Heo9ac78492007-01-20 16:00:26 +0900361 const char *name);
362#define devres_alloc(release, size, gfp) \
363 __devres_alloc(release, size, gfp, #release)
364#else
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800365extern void *devres_alloc(dr_release_t release, size_t size, gfp_t gfp);
Tejun Heo9ac78492007-01-20 16:00:26 +0900366#endif
367extern void devres_free(void *res);
368extern void devres_add(struct device *dev, void *res);
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800369extern void *devres_find(struct device *dev, dr_release_t release,
Tejun Heo9ac78492007-01-20 16:00:26 +0900370 dr_match_t match, void *match_data);
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800371extern void *devres_get(struct device *dev, void *new_res,
372 dr_match_t match, void *match_data);
373extern void *devres_remove(struct device *dev, dr_release_t release,
374 dr_match_t match, void *match_data);
Tejun Heo9ac78492007-01-20 16:00:26 +0900375extern int devres_destroy(struct device *dev, dr_release_t release,
376 dr_match_t match, void *match_data);
377
378/* devres group */
379extern void * __must_check devres_open_group(struct device *dev, void *id,
380 gfp_t gfp);
381extern void devres_close_group(struct device *dev, void *id);
382extern void devres_remove_group(struct device *dev, void *id);
383extern int devres_release_group(struct device *dev, void *id);
384
385/* managed kzalloc/kfree for device drivers, no kmalloc, always use kzalloc */
386extern void *devm_kzalloc(struct device *dev, size_t size, gfp_t gfp);
387extern void devm_kfree(struct device *dev, void *p);
388
FUJITA Tomonori6b7b6512008-02-04 22:27:55 -0800389struct device_dma_parameters {
390 /*
391 * a low level driver may set these to teach IOMMU code about
392 * sg limitations.
393 */
394 unsigned int max_segment_size;
395 unsigned long segment_boundary_mask;
396};
397
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398struct device {
David Brownell49a4ec12007-05-08 00:29:39 -0700399 struct device *parent;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400
Greg Kroah-Hartmanfb069a52008-12-16 12:23:36 -0800401 struct device_private *p;
402
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403 struct kobject kobj;
Greg Kroah-Hartmanc906a482008-05-30 10:45:12 -0700404 const char *init_name; /* initial name of the device */
Kay Sieversf9f852d2006-10-07 21:54:55 +0200405 struct device_type *type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406
mochel@digitalimplant.orgaf703162005-03-21 10:41:04 -0800407 struct semaphore sem; /* semaphore to synchronize calls to
408 * its driver.
409 */
410
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800411 struct bus_type *bus; /* type of bus device is on */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412 struct device_driver *driver; /* which driver has allocated this
413 device */
Greg Kroah-Hartmane67c8562009-03-08 23:13:32 +0800414 void *platform_data; /* Platform specific data, device
415 core doesn't touch it */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 struct dev_pm_info power;
417
Christoph Hellwig87348132006-12-06 20:32:33 -0800418#ifdef CONFIG_NUMA
419 int numa_node; /* NUMA node this device is close to */
420#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 u64 *dma_mask; /* dma mask (if dma'able device) */
422 u64 coherent_dma_mask;/* Like dma_mask, but for
423 alloc_coherent mappings as
424 not all hardware supports
425 64 bit addresses for consistent
426 allocations such descriptors. */
427
FUJITA Tomonori6b7b6512008-02-04 22:27:55 -0800428 struct device_dma_parameters *dma_parms;
429
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430 struct list_head dma_pools; /* dma pools (if dma'ble) */
431
432 struct dma_coherent_mem *dma_mem; /* internal for coherent mem
433 override */
Benjamin Herrenschmidtc6dbaef2006-11-11 17:18:39 +1100434 /* arch specific additions */
435 struct dev_archdata archdata;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436
Matthew Wilcox929d2fa2008-10-16 15:51:35 -0600437 dev_t devt; /* dev_t, creates the sysfs "dev" */
438
Tejun Heo9ac78492007-01-20 16:00:26 +0900439 spinlock_t devres_lock;
440 struct list_head devres_head;
441
Tejun Heo5a3ceb82008-08-25 19:50:19 +0200442 struct klist_node knode_class;
Kay Sieversb7a3e812006-10-07 21:54:55 +0200443 struct class *class;
David Brownella4dbd672009-06-24 10:06:31 -0700444 const struct attribute_group **groups; /* optional groups */
Greg Kroah-Hartman23681e42006-06-14 12:14:34 -0700445
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800446 void (*release)(struct device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447};
448
Alan Stern9a3df1f2008-03-19 22:39:13 +0100449/* Get the wakeup routines, which depend on struct device */
450#include <linux/pm_wakeup.h>
451
Jean Delvarebf9ca692008-07-30 12:29:21 -0700452static inline const char *dev_name(const struct device *dev)
Kay Sievers06916632008-05-02 06:02:41 +0200453{
Paul Mundta636ee72010-03-09 06:57:53 +0000454 /* Use the init name until the kobject becomes available */
455 if (dev->init_name)
456 return dev->init_name;
457
Kay Sievers1fa5ae82009-01-25 15:17:37 +0100458 return kobject_name(&dev->kobj);
Kay Sievers06916632008-05-02 06:02:41 +0200459}
460
Stephen Rothwell413c2392008-05-30 10:16:40 +1000461extern int dev_set_name(struct device *dev, const char *name, ...)
462 __attribute__((format(printf, 2, 3)));
463
Christoph Hellwig87348132006-12-06 20:32:33 -0800464#ifdef CONFIG_NUMA
465static inline int dev_to_node(struct device *dev)
466{
467 return dev->numa_node;
468}
469static inline void set_dev_node(struct device *dev, int node)
470{
471 dev->numa_node = node;
472}
473#else
474static inline int dev_to_node(struct device *dev)
475{
476 return -1;
477}
478static inline void set_dev_node(struct device *dev, int node)
479{
480}
481#endif
482
Ming Leif67f1292009-03-01 21:10:49 +0800483static inline unsigned int dev_get_uevent_suppress(const struct device *dev)
484{
485 return dev->kobj.uevent_suppress;
486}
487
488static inline void dev_set_uevent_suppress(struct device *dev, int val)
489{
490 dev->kobj.uevent_suppress = val;
491}
492
Daniel Ritzd305ef52005-09-22 00:47:24 -0700493static inline int device_is_registered(struct device *dev)
494{
Greg Kroah-Hartman3f62e572008-03-13 17:07:03 -0400495 return dev->kobj.state_in_sysfs;
Daniel Ritzd305ef52005-09-22 00:47:24 -0700496}
497
Rafael J. Wysocki5af84b82010-01-23 22:23:32 +0100498static inline void device_enable_async_suspend(struct device *dev)
499{
500 if (dev->power.status == DPM_ON)
501 dev->power.async_suspend = true;
502}
503
Rafael J. Wysocki5a2eb852010-01-23 22:25:23 +0100504static inline void device_disable_async_suspend(struct device *dev)
505{
506 if (dev->power.status == DPM_ON)
507 dev->power.async_suspend = false;
508}
509
510static inline bool device_async_suspend_enabled(struct device *dev)
511{
512 return !!dev->power.async_suspend;
513}
514
Greg Kroah-Hartman8e9394c2010-02-17 10:57:05 -0800515static inline void device_lock(struct device *dev)
516{
517 down(&dev->sem);
518}
519
520static inline int device_trylock(struct device *dev)
521{
522 return down_trylock(&dev->sem);
523}
524
525static inline void device_unlock(struct device *dev)
526{
527 up(&dev->sem);
528}
529
Adrian Bunk1f217822006-12-19 13:01:28 -0800530void driver_init(void);
531
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532/*
533 * High level routines for use by the bus drivers
534 */
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800535extern int __must_check device_register(struct device *dev);
536extern void device_unregister(struct device *dev);
537extern void device_initialize(struct device *dev);
538extern int __must_check device_add(struct device *dev);
539extern void device_del(struct device *dev);
540extern int device_for_each_child(struct device *dev, void *data,
541 int (*fn)(struct device *dev, void *data));
542extern struct device *device_find_child(struct device *dev, void *data,
543 int (*match)(struct device *dev, void *data));
Greg Kroah-Hartmana2de48c2006-07-03 14:31:12 -0700544extern int device_rename(struct device *dev, char *new_name);
Cornelia Huckffa6a702009-03-04 12:44:00 +0100545extern int device_move(struct device *dev, struct device *new_parent,
546 enum dpm_order dpm_order);
Kay Sieverse454cea2009-09-18 23:01:12 +0200547extern const char *device_get_devnode(struct device *dev,
548 mode_t *mode, const char **tmp);
Greg Kroah-Hartmanb4028432009-05-11 14:16:57 -0700549extern void *dev_get_drvdata(const struct device *dev);
550extern void dev_set_drvdata(struct device *dev, void *data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551
552/*
Mark McLoughlin0aa0dc42008-12-15 12:58:26 +0000553 * Root device objects for grouping under /sys/devices
554 */
555extern struct device *__root_device_register(const char *name,
556 struct module *owner);
557static inline struct device *root_device_register(const char *name)
558{
559 return __root_device_register(name, THIS_MODULE);
560}
561extern void root_device_unregister(struct device *root);
562
Mark Browna5b8b1a2009-07-17 15:06:08 +0100563static inline void *dev_get_platdata(const struct device *dev)
564{
565 return dev->platform_data;
566}
567
Mark McLoughlin0aa0dc42008-12-15 12:58:26 +0000568/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 * Manual binding of a device to driver. See drivers/base/bus.c
570 * for information on use.
571 */
Andrew Mortonf86db392006-08-14 22:43:20 -0700572extern int __must_check device_bind_driver(struct device *dev);
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800573extern void device_release_driver(struct device *dev);
574extern int __must_check device_attach(struct device *dev);
Andrew Mortonf86db392006-08-14 22:43:20 -0700575extern int __must_check driver_attach(struct device_driver *drv);
576extern int __must_check device_reprobe(struct device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577
Greg Kroah-Hartman23681e42006-06-14 12:14:34 -0700578/*
579 * Easy functions for dynamically creating devices on the fly
580 */
Greg Kroah-Hartman8882b392008-05-15 13:44:08 -0700581extern struct device *device_create_vargs(struct class *cls,
582 struct device *parent,
583 dev_t devt,
584 void *drvdata,
585 const char *fmt,
586 va_list vargs);
Greg Kroah-Hartman4e106732008-07-21 20:03:34 -0700587extern struct device *device_create(struct class *cls, struct device *parent,
588 dev_t devt, void *drvdata,
589 const char *fmt, ...)
Greg Kroah-Hartman8882b392008-05-15 13:44:08 -0700590 __attribute__((format(printf, 5, 6)));
Greg Kroah-Hartman23681e42006-06-14 12:14:34 -0700591extern void device_destroy(struct class *cls, dev_t devt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593/*
594 * Platform "fixup" functions - allow the platform to have their say
595 * about devices and actions that the general device layer doesn't
596 * know about.
597 */
598/* Notify platform of device discovery */
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800599extern int (*platform_notify)(struct device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800601extern int (*platform_notify_remove)(struct device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602
603
604/**
605 * get_device - atomically increment the reference count for the device.
606 *
607 */
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800608extern struct device *get_device(struct device *dev);
609extern void put_device(struct device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610
Arjan van de Vend4d52912009-04-21 13:32:54 -0700611extern void wait_for_device_probe(void);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612
Kay Sievers2b2af542009-04-30 15:23:42 +0200613#ifdef CONFIG_DEVTMPFS
614extern int devtmpfs_create_node(struct device *dev);
615extern int devtmpfs_delete_node(struct device *dev);
Kay Sievers073120c2009-10-28 19:51:17 +0100616extern int devtmpfs_mount(const char *mntdir);
Kay Sievers2b2af542009-04-30 15:23:42 +0200617#else
618static inline int devtmpfs_create_node(struct device *dev) { return 0; }
619static inline int devtmpfs_delete_node(struct device *dev) { return 0; }
620static inline int devtmpfs_mount(const char *mountpoint) { return 0; }
621#endif
622
Rytchkov Alexey116f232b2006-03-22 00:58:53 +0100623/* drivers/base/power/shutdown.c */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624extern void device_shutdown(void);
625
Rafael J. Wysocki58b3b712007-07-26 16:29:55 +0200626/* drivers/base/sys.c */
627extern void sysdev_shutdown(void);
628
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629/* debugging and troubleshooting/diagnostic helpers. */
Jean Delvarebf9ca692008-07-30 12:29:21 -0700630extern const char *dev_driver_string(const struct device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631#define dev_printk(level, dev, format, arg...) \
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800632 printk(level "%s %s: " format , dev_driver_string(dev) , \
Kay Sievers06916632008-05-02 06:02:41 +0200633 dev_name(dev) , ## arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634
Emil Medve7b8712e2007-10-30 14:37:14 -0500635#define dev_emerg(dev, format, arg...) \
636 dev_printk(KERN_EMERG , dev , format , ## arg)
637#define dev_alert(dev, format, arg...) \
638 dev_printk(KERN_ALERT , dev , format , ## arg)
639#define dev_crit(dev, format, arg...) \
640 dev_printk(KERN_CRIT , dev , format , ## arg)
641#define dev_err(dev, format, arg...) \
642 dev_printk(KERN_ERR , dev , format , ## arg)
643#define dev_warn(dev, format, arg...) \
644 dev_printk(KERN_WARNING , dev , format , ## arg)
645#define dev_notice(dev, format, arg...) \
646 dev_printk(KERN_NOTICE , dev , format , ## arg)
647#define dev_info(dev, format, arg...) \
648 dev_printk(KERN_INFO , dev , format , ## arg)
649
Cornelia Huckd0d85ff2008-12-04 16:55:47 +0100650#if defined(DEBUG)
651#define dev_dbg(dev, format, arg...) \
652 dev_printk(KERN_DEBUG , dev , format , ## arg)
Jason Barone9d376f2009-02-05 11:51:38 -0500653#elif defined(CONFIG_DYNAMIC_DEBUG)
Jason Baron346e15b2008-08-12 16:46:19 -0400654#define dev_dbg(dev, format, ...) do { \
655 dynamic_dev_dbg(dev, format, ##__VA_ARGS__); \
656 } while (0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657#else
Joe Perches1429db82008-02-26 19:08:42 -0800658#define dev_dbg(dev, format, arg...) \
659 ({ if (0) dev_printk(KERN_DEBUG, dev, format, ##arg); 0; })
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660#endif
661
David Brownellaebdc3b2007-07-12 22:08:22 -0700662#ifdef VERBOSE_DEBUG
663#define dev_vdbg dev_dbg
664#else
Joe Perches1429db82008-02-26 19:08:42 -0800665
666#define dev_vdbg(dev, format, arg...) \
667 ({ if (0) dev_printk(KERN_DEBUG, dev, format, ##arg); 0; })
David Brownellaebdc3b2007-07-12 22:08:22 -0700668#endif
669
Arjan van de Vene6139662008-09-20 19:08:39 -0700670/*
671 * dev_WARN() acts like dev_printk(), but with the key difference
672 * of using a WARN/WARN_ON to get the message out, including the
673 * file/line information and a backtrace.
674 */
675#define dev_WARN(dev, format, arg...) \
676 WARN(1, "Device: %s\n" format, dev_driver_string(dev), ## arg);
677
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678/* Create alias, so I can be autoloaded. */
679#define MODULE_ALIAS_CHARDEV(major,minor) \
680 MODULE_ALIAS("char-major-" __stringify(major) "-" __stringify(minor))
681#define MODULE_ALIAS_CHARDEV_MAJOR(major) \
682 MODULE_ALIAS("char-major-" __stringify(major) "-*")
683#endif /* _DEVICE_H_ */