blob: 70adc5f3f50a29a9449d775020d26fa905d6938f [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
109 * with the device semaphore held in the core, so be careful.
110 */
111#define BUS_NOTIFY_ADD_DEVICE 0x00000001 /* device added */
112#define BUS_NOTIFY_DEL_DEVICE 0x00000002 /* device removed */
113#define BUS_NOTIFY_BOUND_DRIVER 0x00000003 /* driver bound to device */
114#define BUS_NOTIFY_UNBIND_DRIVER 0x00000004 /* driver about to be
115 unbound */
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;
254 ssize_t (*show)(struct class *class, char *buf);
255 ssize_t (*store)(struct class *class, const char *buf, size_t count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256};
257
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800258#define CLASS_ATTR(_name, _mode, _show, _store) \
259struct class_attribute class_attr_##_name = __ATTR(_name, _mode, _show, _store)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800261extern int __must_check class_create_file(struct class *class,
262 const struct class_attribute *attr);
263extern void class_remove_file(struct class *class,
264 const struct class_attribute *attr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266struct class_interface {
267 struct list_head node;
268 struct class *class;
269
Greg Kroah-Hartmanc47ed212006-09-13 15:34:05 +0200270 int (*add_dev) (struct device *, struct class_interface *);
271 void (*remove_dev) (struct device *, struct class_interface *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272};
273
Andrew Morton4a7fb632006-08-14 22:43:17 -0700274extern int __must_check class_interface_register(struct class_interface *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275extern void class_interface_unregister(struct class_interface *);
276
Matthew Wilcoxd2a3b912008-05-28 09:28:39 -0700277extern struct class * __must_check __class_create(struct module *owner,
278 const char *name,
279 struct lock_class_key *key);
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800280extern void class_destroy(struct class *cls);
gregkh@suse.dee9ba6362005-03-15 11:54:21 -0800281
Matthew Wilcoxd2a3b912008-05-28 09:28:39 -0700282/* This is a #define to keep the compiler from merging different
283 * instances of the __key variable */
284#define class_create(owner, name) \
285({ \
286 static struct lock_class_key __key; \
287 __class_create(owner, name, &__key); \
288})
289
Kay Sievers414264f2007-03-12 21:08:57 +0100290/*
291 * The type of device, "struct device" is embedded in. A class
292 * or bus can contain devices of different types
293 * like "partitions" and "disks", "mouse" and "event".
294 * This identifies the device type and carries type-specific
295 * information, equivalent to the kobj_type of a kobject.
296 * If "name" is specified, the uevent will contain it in
297 * the DEVTYPE variable.
298 */
Kay Sieversf9f852d2006-10-07 21:54:55 +0200299struct device_type {
Kay Sievers414264f2007-03-12 21:08:57 +0100300 const char *name;
David Brownella4dbd672009-06-24 10:06:31 -0700301 const struct attribute_group **groups;
Kay Sievers7eff2e72007-08-14 15:15:12 +0200302 int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
Kay Sieverse454cea2009-09-18 23:01:12 +0200303 char *(*devnode)(struct device *dev, mode_t *mode);
Kay Sieversf9f852d2006-10-07 21:54:55 +0200304 void (*release)(struct device *dev);
Rafael J. Wysocki1eede072008-05-20 23:00:01 +0200305
Dmitry Torokhov8150f322009-07-24 22:11:32 -0700306 const struct dev_pm_ops *pm;
Kay Sieversf9f852d2006-10-07 21:54:55 +0200307};
308
Kay Sieversa7fd6702005-10-01 14:49:43 +0200309/* interface for exporting device attributes */
310struct device_attribute {
311 struct attribute attr;
312 ssize_t (*show)(struct device *dev, struct device_attribute *attr,
313 char *buf);
314 ssize_t (*store)(struct device *dev, struct device_attribute *attr,
315 const char *buf, size_t count);
316};
317
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800318#define DEVICE_ATTR(_name, _mode, _show, _store) \
319struct device_attribute dev_attr_##_name = __ATTR(_name, _mode, _show, _store)
Kay Sieversa7fd6702005-10-01 14:49:43 +0200320
Andrew Morton4a7fb632006-08-14 22:43:17 -0700321extern int __must_check device_create_file(struct device *device,
Phil Carmody66ecb922009-12-18 15:34:20 +0200322 const struct device_attribute *entry);
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800323extern void device_remove_file(struct device *dev,
Phil Carmody26579ab2009-12-18 15:34:19 +0200324 const struct device_attribute *attr);
Greg Kroah-Hartman2589f1882006-09-19 09:39:19 -0700325extern int __must_check device_create_bin_file(struct device *dev,
Phil Carmody66ecb922009-12-18 15:34:20 +0200326 const struct bin_attribute *attr);
Greg Kroah-Hartman2589f1882006-09-19 09:39:19 -0700327extern void device_remove_bin_file(struct device *dev,
Phil Carmody66ecb922009-12-18 15:34:20 +0200328 const struct bin_attribute *attr);
Alan Stern523ded72007-04-26 00:12:04 -0700329extern int device_schedule_callback_owner(struct device *dev,
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800330 void (*func)(struct device *dev), struct module *owner);
Alan Stern523ded72007-04-26 00:12:04 -0700331
332/* This is a macro to avoid include problems with THIS_MODULE */
333#define device_schedule_callback(dev, func) \
334 device_schedule_callback_owner(dev, func, THIS_MODULE)
Tejun Heo9ac78492007-01-20 16:00:26 +0900335
336/* device resource management */
337typedef void (*dr_release_t)(struct device *dev, void *res);
338typedef int (*dr_match_t)(struct device *dev, void *res, void *match_data);
339
340#ifdef CONFIG_DEBUG_DEVRES
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800341extern void *__devres_alloc(dr_release_t release, size_t size, gfp_t gfp,
Tejun Heo9ac78492007-01-20 16:00:26 +0900342 const char *name);
343#define devres_alloc(release, size, gfp) \
344 __devres_alloc(release, size, gfp, #release)
345#else
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800346extern void *devres_alloc(dr_release_t release, size_t size, gfp_t gfp);
Tejun Heo9ac78492007-01-20 16:00:26 +0900347#endif
348extern void devres_free(void *res);
349extern void devres_add(struct device *dev, void *res);
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800350extern void *devres_find(struct device *dev, dr_release_t release,
Tejun Heo9ac78492007-01-20 16:00:26 +0900351 dr_match_t match, void *match_data);
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800352extern void *devres_get(struct device *dev, void *new_res,
353 dr_match_t match, void *match_data);
354extern void *devres_remove(struct device *dev, dr_release_t release,
355 dr_match_t match, void *match_data);
Tejun Heo9ac78492007-01-20 16:00:26 +0900356extern int devres_destroy(struct device *dev, dr_release_t release,
357 dr_match_t match, void *match_data);
358
359/* devres group */
360extern void * __must_check devres_open_group(struct device *dev, void *id,
361 gfp_t gfp);
362extern void devres_close_group(struct device *dev, void *id);
363extern void devres_remove_group(struct device *dev, void *id);
364extern int devres_release_group(struct device *dev, void *id);
365
366/* managed kzalloc/kfree for device drivers, no kmalloc, always use kzalloc */
367extern void *devm_kzalloc(struct device *dev, size_t size, gfp_t gfp);
368extern void devm_kfree(struct device *dev, void *p);
369
FUJITA Tomonori6b7b6512008-02-04 22:27:55 -0800370struct device_dma_parameters {
371 /*
372 * a low level driver may set these to teach IOMMU code about
373 * sg limitations.
374 */
375 unsigned int max_segment_size;
376 unsigned long segment_boundary_mask;
377};
378
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379struct device {
David Brownell49a4ec12007-05-08 00:29:39 -0700380 struct device *parent;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381
Greg Kroah-Hartmanfb069a52008-12-16 12:23:36 -0800382 struct device_private *p;
383
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384 struct kobject kobj;
Greg Kroah-Hartmanc906a482008-05-30 10:45:12 -0700385 const char *init_name; /* initial name of the device */
Kay Sieversf9f852d2006-10-07 21:54:55 +0200386 struct device_type *type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387
mochel@digitalimplant.orgaf703162005-03-21 10:41:04 -0800388 struct semaphore sem; /* semaphore to synchronize calls to
389 * its driver.
390 */
391
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800392 struct bus_type *bus; /* type of bus device is on */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 struct device_driver *driver; /* which driver has allocated this
394 device */
Greg Kroah-Hartmane67c8562009-03-08 23:13:32 +0800395 void *platform_data; /* Platform specific data, device
396 core doesn't touch it */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 struct dev_pm_info power;
398
Christoph Hellwig87348132006-12-06 20:32:33 -0800399#ifdef CONFIG_NUMA
400 int numa_node; /* NUMA node this device is close to */
401#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 u64 *dma_mask; /* dma mask (if dma'able device) */
403 u64 coherent_dma_mask;/* Like dma_mask, but for
404 alloc_coherent mappings as
405 not all hardware supports
406 64 bit addresses for consistent
407 allocations such descriptors. */
408
FUJITA Tomonori6b7b6512008-02-04 22:27:55 -0800409 struct device_dma_parameters *dma_parms;
410
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 struct list_head dma_pools; /* dma pools (if dma'ble) */
412
413 struct dma_coherent_mem *dma_mem; /* internal for coherent mem
414 override */
Benjamin Herrenschmidtc6dbaef2006-11-11 17:18:39 +1100415 /* arch specific additions */
416 struct dev_archdata archdata;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417
Matthew Wilcox929d2fa2008-10-16 15:51:35 -0600418 dev_t devt; /* dev_t, creates the sysfs "dev" */
419
Tejun Heo9ac78492007-01-20 16:00:26 +0900420 spinlock_t devres_lock;
421 struct list_head devres_head;
422
Tejun Heo5a3ceb82008-08-25 19:50:19 +0200423 struct klist_node knode_class;
Kay Sieversb7a3e812006-10-07 21:54:55 +0200424 struct class *class;
David Brownella4dbd672009-06-24 10:06:31 -0700425 const struct attribute_group **groups; /* optional groups */
Greg Kroah-Hartman23681e42006-06-14 12:14:34 -0700426
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800427 void (*release)(struct device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428};
429
Alan Stern9a3df1f2008-03-19 22:39:13 +0100430/* Get the wakeup routines, which depend on struct device */
431#include <linux/pm_wakeup.h>
432
Jean Delvarebf9ca692008-07-30 12:29:21 -0700433static inline const char *dev_name(const struct device *dev)
Kay Sievers06916632008-05-02 06:02:41 +0200434{
Kay Sievers1fa5ae82009-01-25 15:17:37 +0100435 return kobject_name(&dev->kobj);
Kay Sievers06916632008-05-02 06:02:41 +0200436}
437
Stephen Rothwell413c2392008-05-30 10:16:40 +1000438extern int dev_set_name(struct device *dev, const char *name, ...)
439 __attribute__((format(printf, 2, 3)));
440
Christoph Hellwig87348132006-12-06 20:32:33 -0800441#ifdef CONFIG_NUMA
442static inline int dev_to_node(struct device *dev)
443{
444 return dev->numa_node;
445}
446static inline void set_dev_node(struct device *dev, int node)
447{
448 dev->numa_node = node;
449}
450#else
451static inline int dev_to_node(struct device *dev)
452{
453 return -1;
454}
455static inline void set_dev_node(struct device *dev, int node)
456{
457}
458#endif
459
Ming Leif67f1292009-03-01 21:10:49 +0800460static inline unsigned int dev_get_uevent_suppress(const struct device *dev)
461{
462 return dev->kobj.uevent_suppress;
463}
464
465static inline void dev_set_uevent_suppress(struct device *dev, int val)
466{
467 dev->kobj.uevent_suppress = val;
468}
469
Daniel Ritzd305ef52005-09-22 00:47:24 -0700470static inline int device_is_registered(struct device *dev)
471{
Greg Kroah-Hartman3f62e572008-03-13 17:07:03 -0400472 return dev->kobj.state_in_sysfs;
Daniel Ritzd305ef52005-09-22 00:47:24 -0700473}
474
Rafael J. Wysocki5af84b82010-01-23 22:23:32 +0100475static inline void device_enable_async_suspend(struct device *dev)
476{
477 if (dev->power.status == DPM_ON)
478 dev->power.async_suspend = true;
479}
480
Adrian Bunk1f217822006-12-19 13:01:28 -0800481void driver_init(void);
482
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483/*
484 * High level routines for use by the bus drivers
485 */
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800486extern int __must_check device_register(struct device *dev);
487extern void device_unregister(struct device *dev);
488extern void device_initialize(struct device *dev);
489extern int __must_check device_add(struct device *dev);
490extern void device_del(struct device *dev);
491extern int device_for_each_child(struct device *dev, void *data,
492 int (*fn)(struct device *dev, void *data));
493extern struct device *device_find_child(struct device *dev, void *data,
494 int (*match)(struct device *dev, void *data));
Greg Kroah-Hartmana2de48c2006-07-03 14:31:12 -0700495extern int device_rename(struct device *dev, char *new_name);
Cornelia Huckffa6a702009-03-04 12:44:00 +0100496extern int device_move(struct device *dev, struct device *new_parent,
497 enum dpm_order dpm_order);
Kay Sieverse454cea2009-09-18 23:01:12 +0200498extern const char *device_get_devnode(struct device *dev,
499 mode_t *mode, const char **tmp);
Greg Kroah-Hartmanb4028432009-05-11 14:16:57 -0700500extern void *dev_get_drvdata(const struct device *dev);
501extern void dev_set_drvdata(struct device *dev, void *data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502
503/*
Mark McLoughlin0aa0dc42008-12-15 12:58:26 +0000504 * Root device objects for grouping under /sys/devices
505 */
506extern struct device *__root_device_register(const char *name,
507 struct module *owner);
508static inline struct device *root_device_register(const char *name)
509{
510 return __root_device_register(name, THIS_MODULE);
511}
512extern void root_device_unregister(struct device *root);
513
Mark Browna5b8b1a2009-07-17 15:06:08 +0100514static inline void *dev_get_platdata(const struct device *dev)
515{
516 return dev->platform_data;
517}
518
Mark McLoughlin0aa0dc42008-12-15 12:58:26 +0000519/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520 * Manual binding of a device to driver. See drivers/base/bus.c
521 * for information on use.
522 */
Andrew Mortonf86db392006-08-14 22:43:20 -0700523extern int __must_check device_bind_driver(struct device *dev);
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800524extern void device_release_driver(struct device *dev);
525extern int __must_check device_attach(struct device *dev);
Andrew Mortonf86db392006-08-14 22:43:20 -0700526extern int __must_check driver_attach(struct device_driver *drv);
527extern int __must_check device_reprobe(struct device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528
Greg Kroah-Hartman23681e42006-06-14 12:14:34 -0700529/*
530 * Easy functions for dynamically creating devices on the fly
531 */
Greg Kroah-Hartman8882b392008-05-15 13:44:08 -0700532extern struct device *device_create_vargs(struct class *cls,
533 struct device *parent,
534 dev_t devt,
535 void *drvdata,
536 const char *fmt,
537 va_list vargs);
Greg Kroah-Hartman4e106732008-07-21 20:03:34 -0700538extern struct device *device_create(struct class *cls, struct device *parent,
539 dev_t devt, void *drvdata,
540 const char *fmt, ...)
Greg Kroah-Hartman8882b392008-05-15 13:44:08 -0700541 __attribute__((format(printf, 5, 6)));
Greg Kroah-Hartman23681e42006-06-14 12:14:34 -0700542extern void device_destroy(struct class *cls, dev_t devt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544/*
545 * Platform "fixup" functions - allow the platform to have their say
546 * about devices and actions that the general device layer doesn't
547 * know about.
548 */
549/* Notify platform of device discovery */
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800550extern int (*platform_notify)(struct device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800552extern int (*platform_notify_remove)(struct device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553
554
555/**
556 * get_device - atomically increment the reference count for the device.
557 *
558 */
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800559extern struct device *get_device(struct device *dev);
560extern void put_device(struct device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561
Arjan van de Vend4d52912009-04-21 13:32:54 -0700562extern void wait_for_device_probe(void);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563
Kay Sievers2b2af542009-04-30 15:23:42 +0200564#ifdef CONFIG_DEVTMPFS
565extern int devtmpfs_create_node(struct device *dev);
566extern int devtmpfs_delete_node(struct device *dev);
Kay Sievers073120c2009-10-28 19:51:17 +0100567extern int devtmpfs_mount(const char *mntdir);
Kay Sievers2b2af542009-04-30 15:23:42 +0200568#else
569static inline int devtmpfs_create_node(struct device *dev) { return 0; }
570static inline int devtmpfs_delete_node(struct device *dev) { return 0; }
571static inline int devtmpfs_mount(const char *mountpoint) { return 0; }
572#endif
573
Rytchkov Alexey116f232b2006-03-22 00:58:53 +0100574/* drivers/base/power/shutdown.c */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575extern void device_shutdown(void);
576
Rafael J. Wysocki58b3b712007-07-26 16:29:55 +0200577/* drivers/base/sys.c */
578extern void sysdev_shutdown(void);
579
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580/* debugging and troubleshooting/diagnostic helpers. */
Jean Delvarebf9ca692008-07-30 12:29:21 -0700581extern const char *dev_driver_string(const struct device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582#define dev_printk(level, dev, format, arg...) \
Greg Kroah-Hartmand4629432008-01-24 21:04:46 -0800583 printk(level "%s %s: " format , dev_driver_string(dev) , \
Kay Sievers06916632008-05-02 06:02:41 +0200584 dev_name(dev) , ## arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585
Emil Medve7b8712e2007-10-30 14:37:14 -0500586#define dev_emerg(dev, format, arg...) \
587 dev_printk(KERN_EMERG , dev , format , ## arg)
588#define dev_alert(dev, format, arg...) \
589 dev_printk(KERN_ALERT , dev , format , ## arg)
590#define dev_crit(dev, format, arg...) \
591 dev_printk(KERN_CRIT , dev , format , ## arg)
592#define dev_err(dev, format, arg...) \
593 dev_printk(KERN_ERR , dev , format , ## arg)
594#define dev_warn(dev, format, arg...) \
595 dev_printk(KERN_WARNING , dev , format , ## arg)
596#define dev_notice(dev, format, arg...) \
597 dev_printk(KERN_NOTICE , dev , format , ## arg)
598#define dev_info(dev, format, arg...) \
599 dev_printk(KERN_INFO , dev , format , ## arg)
600
Cornelia Huckd0d85ff2008-12-04 16:55:47 +0100601#if defined(DEBUG)
602#define dev_dbg(dev, format, arg...) \
603 dev_printk(KERN_DEBUG , dev , format , ## arg)
Jason Barone9d376f2009-02-05 11:51:38 -0500604#elif defined(CONFIG_DYNAMIC_DEBUG)
Jason Baron346e15b2008-08-12 16:46:19 -0400605#define dev_dbg(dev, format, ...) do { \
606 dynamic_dev_dbg(dev, format, ##__VA_ARGS__); \
607 } while (0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608#else
Joe Perches1429db82008-02-26 19:08:42 -0800609#define dev_dbg(dev, format, arg...) \
610 ({ if (0) dev_printk(KERN_DEBUG, dev, format, ##arg); 0; })
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611#endif
612
David Brownellaebdc3b2007-07-12 22:08:22 -0700613#ifdef VERBOSE_DEBUG
614#define dev_vdbg dev_dbg
615#else
Joe Perches1429db82008-02-26 19:08:42 -0800616
617#define dev_vdbg(dev, format, arg...) \
618 ({ if (0) dev_printk(KERN_DEBUG, dev, format, ##arg); 0; })
David Brownellaebdc3b2007-07-12 22:08:22 -0700619#endif
620
Arjan van de Vene6139662008-09-20 19:08:39 -0700621/*
622 * dev_WARN() acts like dev_printk(), but with the key difference
623 * of using a WARN/WARN_ON to get the message out, including the
624 * file/line information and a backtrace.
625 */
626#define dev_WARN(dev, format, arg...) \
627 WARN(1, "Device: %s\n" format, dev_driver_string(dev), ## arg);
628
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629/* Create alias, so I can be autoloaded. */
630#define MODULE_ALIAS_CHARDEV(major,minor) \
631 MODULE_ALIAS("char-major-" __stringify(major) "-" __stringify(minor))
632#define MODULE_ALIAS_CHARDEV_MAJOR(major) \
633 MODULE_ALIAS("char-major-" __stringify(major) "-*")
634#endif /* _DEVICE_H_ */