Blame view
include/linux/device.h
34.8 KB
1da177e4c
|
1 2 3 4 |
/* * device.h - generic, centralized driver model * * Copyright (c) 2001-2003 Patrick Mochel <mochel@osdl.org> |
b40284378
|
5 6 |
* Copyright (c) 2004-2009 Greg Kroah-Hartman <gregkh@suse.de> * Copyright (c) 2008-2009 Novell Inc. |
1da177e4c
|
7 8 9 10 11 12 13 14 |
* * This file is released under the GPLv2 * * See Documentation/driver-model/ for more information. */ #ifndef _DEVICE_H_ #define _DEVICE_H_ |
1da177e4c
|
15 16 |
#include <linux/ioport.h> #include <linux/kobject.h> |
465c7a3a3
|
17 |
#include <linux/klist.h> |
1da177e4c
|
18 |
#include <linux/list.h> |
d2a3b9146
|
19 |
#include <linux/lockdep.h> |
4a7fb6363
|
20 |
#include <linux/compiler.h> |
1da177e4c
|
21 |
#include <linux/types.h> |
de4772542
|
22 |
#include <linux/mutex.h> |
1da177e4c
|
23 |
#include <linux/pm.h> |
60063497a
|
24 |
#include <linux/atomic.h> |
c6dbaef22
|
25 |
#include <asm/device.h> |
1da177e4c
|
26 |
|
1da177e4c
|
27 |
struct device; |
fb069a5d1
|
28 |
struct device_private; |
1da177e4c
|
29 |
struct device_driver; |
e5dd12784
|
30 |
struct driver_private; |
de4772542
|
31 |
struct module; |
1da177e4c
|
32 |
struct class; |
6b6e39a6a
|
33 |
struct subsys_private; |
b8c5cec23
|
34 |
struct bus_type; |
d706c1b05
|
35 |
struct device_node; |
ff21776d1
|
36 |
struct iommu_ops; |
b8c5cec23
|
37 38 39 |
struct bus_attribute { struct attribute attr; |
d462943af
|
40 41 |
ssize_t (*show)(struct bus_type *bus, char *buf); ssize_t (*store)(struct bus_type *bus, const char *buf, size_t count); |
b8c5cec23
|
42 |
}; |
d462943af
|
43 44 |
#define BUS_ATTR(_name, _mode, _show, _store) \ struct bus_attribute bus_attr_##_name = __ATTR(_name, _mode, _show, _store) |
b8c5cec23
|
45 46 47 48 |
extern int __must_check bus_create_file(struct bus_type *, struct bus_attribute *); extern void bus_remove_file(struct bus_type *, struct bus_attribute *); |
1da177e4c
|
49 |
|
880ffb5c6
|
50 51 52 53 |
/** * struct bus_type - The bus type of the device * * @name: The name of the bus. |
ca22e56de
|
54 55 |
* @dev_name: Used for subsystems to enumerate devices like ("foo%u", dev->id). * @dev_root: Default device to use as the parent. |
880ffb5c6
|
56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 |
* @bus_attrs: Default attributes of the bus. * @dev_attrs: Default attributes of the devices on the bus. * @drv_attrs: Default attributes of the device drivers on the bus. * @match: Called, perhaps multiple times, whenever a new device or driver * is added for this bus. It should return a nonzero value if the * given device can be handled by the given driver. * @uevent: Called when a device is added, removed, or a few other things * that generate uevents to add the environment variables. * @probe: Called when a new device or driver add to this bus, and callback * the specific driver's probe to initial the matched device. * @remove: Called when a device removed from this bus. * @shutdown: Called at shut-down time to quiesce the device. * @suspend: Called when a device on this bus wants to go to sleep mode. * @resume: Called to bring a device on this bus out of sleep mode. * @pm: Power management operations of this bus, callback the specific * device driver's pm-ops. |
7b08fae8f
|
72 |
* @iommu_ops: IOMMU specific operations for this bus, used to attach IOMMU |
ff21776d1
|
73 74 |
* driver implementations to a bus and allow the driver to do * bus-specific setup |
880ffb5c6
|
75 76 77 78 79 80 81 82 83 84 85 86 |
* @p: The private data of the driver core, only the driver core can * touch this. * * A bus is a channel between the processor and one or more devices. For the * purposes of the device model, all devices are connected via a bus, even if * it is an internal, virtual, "platform" bus. Buses can plug into each other. * A USB controller is usually a PCI device, for example. The device model * represents the actual connections between buses and the devices they control. * A bus is represented by the bus_type structure. It contains the name, the * default attributes, the bus' methods, PM operations, and the driver core's * private data. */ |
1da177e4c
|
87 |
struct bus_type { |
d462943af
|
88 |
const char *name; |
ca22e56de
|
89 90 |
const char *dev_name; struct device *dev_root; |
d462943af
|
91 92 93 94 95 96 97 98 99 100 101 |
struct bus_attribute *bus_attrs; struct device_attribute *dev_attrs; struct driver_attribute *drv_attrs; int (*match)(struct device *dev, struct device_driver *drv); int (*uevent)(struct device *dev, struct kobj_uevent_env *env); int (*probe)(struct device *dev); int (*remove)(struct device *dev); void (*shutdown)(struct device *dev); int (*suspend)(struct device *dev, pm_message_t state); |
d462943af
|
102 |
int (*resume)(struct device *dev); |
b8c5cec23
|
103 |
|
8150f32b9
|
104 |
const struct dev_pm_ops *pm; |
1eede070a
|
105 |
|
ff21776d1
|
106 |
struct iommu_ops *iommu_ops; |
6b6e39a6a
|
107 |
struct subsys_private *p; |
1da177e4c
|
108 |
}; |
ca22e56de
|
109 110 111 112 113 114 115 116 117 |
/* This is a #define to keep the compiler from merging different * instances of the __key variable */ #define bus_register(subsys) \ ({ \ static struct lock_class_key __key; \ __bus_register(subsys, &__key); \ }) extern int __must_check __bus_register(struct bus_type *bus, struct lock_class_key *key); |
d462943af
|
118 |
extern void bus_unregister(struct bus_type *bus); |
1da177e4c
|
119 |
|
d462943af
|
120 |
extern int __must_check bus_rescan_devices(struct bus_type *bus); |
1da177e4c
|
121 |
|
1da177e4c
|
122 |
/* iterator helpers for buses */ |
ca22e56de
|
123 124 125 126 127 128 129 130 131 132 |
struct subsys_dev_iter { struct klist_iter ki; const struct device_type *type; }; void subsys_dev_iter_init(struct subsys_dev_iter *iter, struct bus_type *subsys, struct device *start, const struct device_type *type); struct device *subsys_dev_iter_next(struct subsys_dev_iter *iter); void subsys_dev_iter_exit(struct subsys_dev_iter *iter); |
1da177e4c
|
133 |
|
d462943af
|
134 135 136 137 138 |
int bus_for_each_dev(struct bus_type *bus, struct device *start, void *data, int (*fn)(struct device *dev, void *data)); struct device *bus_find_device(struct bus_type *bus, struct device *start, void *data, int (*match)(struct device *dev, void *data)); |
1f9ffc049
|
139 140 141 |
struct device *bus_find_device_by_name(struct bus_type *bus, struct device *start, const char *name); |
ca22e56de
|
142 143 |
struct device *subsys_find_device_by_id(struct bus_type *bus, unsigned int id, struct device *hint); |
cc7447a5f
|
144 145 |
int bus_for_each_drv(struct bus_type *bus, struct device_driver *start, void *data, int (*fn)(struct device_driver *, void *)); |
99178b036
|
146 147 148 |
void bus_sort_breadthfirst(struct bus_type *bus, int (*compare)(const struct device *a, const struct device *b)); |
116af3782
|
149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 |
/* * Bus notifiers: Get notified of addition/removal of devices * and binding/unbinding of drivers to devices. * In the long run, it should be a replacement for the platform * notify hooks. */ struct notifier_block; extern int bus_register_notifier(struct bus_type *bus, struct notifier_block *nb); extern int bus_unregister_notifier(struct bus_type *bus, struct notifier_block *nb); /* All 4 notifers below get called with the target struct device * * as an argument. Note that those functions are likely to be called |
8e9394ce2
|
164 |
* with the device lock held in the core, so be careful. |
116af3782
|
165 166 167 |
*/ #define BUS_NOTIFY_ADD_DEVICE 0x00000001 /* device added */ #define BUS_NOTIFY_DEL_DEVICE 0x00000002 /* device removed */ |
45daef0fd
|
168 169 170 171 |
#define BUS_NOTIFY_BIND_DRIVER 0x00000003 /* driver about to be bound */ #define BUS_NOTIFY_BOUND_DRIVER 0x00000004 /* driver bound to device */ #define BUS_NOTIFY_UNBIND_DRIVER 0x00000005 /* driver about to be |
116af3782
|
172 |
unbound */ |
45daef0fd
|
173 |
#define BUS_NOTIFY_UNBOUND_DRIVER 0x00000006 /* driver is unbound |
309b7d60a
|
174 |
from the device */ |
116af3782
|
175 |
|
0fed80f7a
|
176 |
extern struct kset *bus_get_kset(struct bus_type *bus); |
b249072ee
|
177 |
extern struct klist *bus_get_device_klist(struct bus_type *bus); |
0fed80f7a
|
178 |
|
880ffb5c6
|
179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 |
/** * struct device_driver - The basic device driver structure * @name: Name of the device driver. * @bus: The bus which the device of this driver belongs to. * @owner: The module owner. * @mod_name: Used for built-in modules. * @suppress_bind_attrs: Disables bind/unbind via sysfs. * @of_match_table: The open firmware table. * @probe: Called to query the existence of a specific device, * whether this driver can work with it, and bind the driver * to a specific device. * @remove: Called when the device is removed from the system to * unbind a device from this driver. * @shutdown: Called at shut-down time to quiesce the device. * @suspend: Called to put the device to sleep mode. Usually to a * low power state. * @resume: Called to bring a device from sleep mode. * @groups: Default attributes that get created by the driver core * automatically. * @pm: Power management operations of the device which matched * this driver. * @p: Driver core's private data, no one other than the driver * core can touch this. * * The device driver-model tracks all of the drivers known to the system. * The main reason for this tracking is to enable the driver core to match * up drivers with new devices. Once drivers are known objects within the * system, however, a number of other things become possible. Device drivers * can export information and configuration variables that are independent * of any specific device. */ |
1da177e4c
|
210 |
struct device_driver { |
e5dd12784
|
211 212 |
const char *name; struct bus_type *bus; |
1da177e4c
|
213 |
|
e5dd12784
|
214 |
struct module *owner; |
1a6f2a751
|
215 216 217 |
const char *mod_name; /* used for built-in modules */ bool suppress_bind_attrs; /* disables bind/unbind via sysfs */ |
1da177e4c
|
218 |
|
597b9d1e4
|
219 |
const struct of_device_id *of_match_table; |
597b9d1e4
|
220 |
|
d462943af
|
221 222 223 224 225 |
int (*probe) (struct device *dev); int (*remove) (struct device *dev); void (*shutdown) (struct device *dev); int (*suspend) (struct device *dev, pm_message_t state); int (*resume) (struct device *dev); |
a4dbd6740
|
226 |
const struct attribute_group **groups; |
e5dd12784
|
227 |
|
8150f32b9
|
228 |
const struct dev_pm_ops *pm; |
1eede070a
|
229 |
|
e5dd12784
|
230 |
struct driver_private *p; |
1da177e4c
|
231 |
}; |
d462943af
|
232 233 |
extern int __must_check driver_register(struct device_driver *drv); extern void driver_unregister(struct device_driver *drv); |
1da177e4c
|
234 |
|
d462943af
|
235 236 237 238 |
extern struct device_driver *get_driver(struct device_driver *drv); extern void put_driver(struct device_driver *drv); extern struct device_driver *driver_find(const char *name, struct bus_type *bus); |
d779249ed
|
239 |
extern int driver_probe_done(void); |
b23530ebc
|
240 |
extern void wait_for_device_probe(void); |
216773a78
|
241 |
|
1da177e4c
|
242 |
|
405ae7d38
|
243 |
/* sysfs interface for exporting driver attributes */ |
1da177e4c
|
244 245 |
struct driver_attribute { |
d462943af
|
246 247 248 249 |
struct attribute attr; ssize_t (*show)(struct device_driver *driver, char *buf); ssize_t (*store)(struct device_driver *driver, const char *buf, size_t count); |
1da177e4c
|
250 |
}; |
d462943af
|
251 252 253 |
#define DRIVER_ATTR(_name, _mode, _show, _store) \ struct driver_attribute driver_attr_##_name = \ __ATTR(_name, _mode, _show, _store) |
1da177e4c
|
254 |
|
d462943af
|
255 |
extern int __must_check driver_create_file(struct device_driver *driver, |
099c2f21d
|
256 |
const struct driver_attribute *attr); |
d462943af
|
257 |
extern void driver_remove_file(struct device_driver *driver, |
099c2f21d
|
258 |
const struct driver_attribute *attr); |
1da177e4c
|
259 |
|
cbe9c595f
|
260 261 262 |
extern int __must_check driver_add_kobj(struct device_driver *drv, struct kobject *kobj, const char *fmt, ...); |
d462943af
|
263 264 265 266 267 268 269 270 |
extern int __must_check driver_for_each_device(struct device_driver *drv, struct device *start, void *data, int (*fn)(struct device *dev, void *)); struct device *driver_find_device(struct device_driver *drv, struct device *start, void *data, int (*match)(struct device *dev, void *data)); |
fae3cd002
|
271 |
|
880ffb5c6
|
272 |
/** |
ca22e56de
|
273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 |
* struct subsys_interface - interfaces to device functions * @name name of the device function * @subsystem subsytem of the devices to attach to * @node the list of functions registered at the subsystem * @add device hookup to device function handler * @remove device hookup to device function handler * * Simple interfaces attached to a subsystem. Multiple interfaces can * attach to a subsystem and its devices. Unlike drivers, they do not * exclusively claim or control devices. Interfaces usually represent * a specific functionality of a subsystem/class of devices. */ struct subsys_interface { const char *name; struct bus_type *subsys; struct list_head node; int (*add_dev)(struct device *dev, struct subsys_interface *sif); int (*remove_dev)(struct device *dev, struct subsys_interface *sif); }; int subsys_interface_register(struct subsys_interface *sif); void subsys_interface_unregister(struct subsys_interface *sif); int subsys_system_register(struct bus_type *subsys, const struct attribute_group **groups); /** |
880ffb5c6
|
300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 |
* struct class - device classes * @name: Name of the class. * @owner: The module owner. * @class_attrs: Default attributes of this class. * @dev_attrs: Default attributes of the devices belong to the class. * @dev_bin_attrs: Default binary attributes of the devices belong to the class. * @dev_kobj: The kobject that represents this class and links it into the hierarchy. * @dev_uevent: Called when a device is added, removed from this class, or a * few other things that generate uevents to add the environment * variables. * @devnode: Callback to provide the devtmpfs. * @class_release: Called to release this class. * @dev_release: Called to release the device. * @suspend: Used to put the device to sleep mode, usually to a low power * state. * @resume: Used to bring the device from the sleep mode. * @ns_type: Callbacks so sysfs can detemine namespaces. * @namespace: Namespace of the device belongs to this class. * @pm: The default device power management operations of this class. * @p: The private data of the driver core, no one other than the * driver core can touch this. * * A class is a higher-level view of a device that abstracts out low-level * implementation details. Drivers may see a SCSI disk or an ATA disk, but, * at the class level, they are all simply disks. Classes allow user space * to work with devices based on what they do, rather than how they are * connected or how they work. |
1da177e4c
|
327 328 |
*/ struct class { |
d462943af
|
329 330 |
const char *name; struct module *owner; |
1da177e4c
|
331 |
|
d462943af
|
332 |
struct class_attribute *class_attrs; |
d462943af
|
333 |
struct device_attribute *dev_attrs; |
c97415a72
|
334 |
struct bin_attribute *dev_bin_attrs; |
e105b8bfc
|
335 |
struct kobject *dev_kobj; |
1da177e4c
|
336 |
|
d462943af
|
337 |
int (*dev_uevent)(struct device *dev, struct kobj_uevent_env *env); |
2c9ede55e
|
338 |
char *(*devnode)(struct device *dev, umode_t *mode); |
1da177e4c
|
339 |
|
d462943af
|
340 341 |
void (*class_release)(struct class *class); void (*dev_release)(struct device *dev); |
7c8265f51
|
342 |
|
d462943af
|
343 344 |
int (*suspend)(struct device *dev, pm_message_t state); int (*resume)(struct device *dev); |
1eede070a
|
345 |
|
bc451f205
|
346 347 |
const struct kobj_ns_type_operations *ns_type; const void *(*namespace)(struct device *dev); |
8150f32b9
|
348 |
const struct dev_pm_ops *pm; |
6b6e39a6a
|
349 |
struct subsys_private *p; |
1da177e4c
|
350 |
}; |
5a3ceb861
|
351 352 353 354 |
struct class_dev_iter { struct klist_iter ki; const struct device_type *type; }; |
e105b8bfc
|
355 356 |
extern struct kobject *sysfs_dev_block_kobj; extern struct kobject *sysfs_dev_char_kobj; |
d2a3b9146
|
357 358 |
extern int __must_check __class_register(struct class *class, struct lock_class_key *key); |
d462943af
|
359 |
extern void class_unregister(struct class *class); |
d2a3b9146
|
360 361 362 363 364 365 366 367 |
/* This is a #define to keep the compiler from merging different * instances of the __key variable */ #define class_register(class) \ ({ \ static struct lock_class_key __key; \ __class_register(class, &__key); \ }) |
462270944
|
368 369 370 371 372 373 374 |
struct class_compat; struct class_compat *class_compat_register(const char *name); void class_compat_unregister(struct class_compat *cls); int class_compat_create_link(struct class_compat *cls, struct device *dev, struct device *device_link); void class_compat_remove_link(struct class_compat *cls, struct device *dev, struct device *device_link); |
5a3ceb861
|
375 376 377 378 379 380 |
extern void class_dev_iter_init(struct class_dev_iter *iter, struct class *class, struct device *start, const struct device_type *type); extern struct device *class_dev_iter_next(struct class_dev_iter *iter); extern void class_dev_iter_exit(struct class_dev_iter *iter); |
93562b537
|
381 382 |
extern int class_for_each_device(struct class *class, struct device *start, void *data, |
fd04897bb
|
383 |
int (*fn)(struct device *dev, void *data)); |
695794ae0
|
384 385 |
extern struct device *class_find_device(struct class *class, struct device *start, void *data, |
fd04897bb
|
386 |
int (*match)(struct device *, void *)); |
1da177e4c
|
387 388 |
struct class_attribute { |
d462943af
|
389 |
struct attribute attr; |
28812fe11
|
390 391 392 393 |
ssize_t (*show)(struct class *class, struct class_attribute *attr, char *buf); ssize_t (*store)(struct class *class, struct class_attribute *attr, const char *buf, size_t count); |
672d82c18
|
394 395 |
const void *(*namespace)(struct class *class, const struct class_attribute *attr); |
1da177e4c
|
396 |
}; |
d462943af
|
397 398 |
#define CLASS_ATTR(_name, _mode, _show, _store) \ struct class_attribute class_attr_##_name = __ATTR(_name, _mode, _show, _store) |
1da177e4c
|
399 |
|
d462943af
|
400 401 402 403 |
extern int __must_check class_create_file(struct class *class, const struct class_attribute *attr); extern void class_remove_file(struct class *class, const struct class_attribute *attr); |
1da177e4c
|
404 |
|
869dfc875
|
405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 |
/* Simple class attribute that is just a static string */ struct class_attribute_string { struct class_attribute attr; char *str; }; /* Currently read-only only */ #define _CLASS_ATTR_STRING(_name, _mode, _str) \ { __ATTR(_name, _mode, show_class_attr_string, NULL), _str } #define CLASS_ATTR_STRING(_name, _mode, _str) \ struct class_attribute_string class_attr_##_name = \ _CLASS_ATTR_STRING(_name, _mode, _str) extern ssize_t show_class_attr_string(struct class *class, struct class_attribute *attr, char *buf); |
1da177e4c
|
421 422 423 |
struct class_interface { struct list_head node; struct class *class; |
c47ed219b
|
424 425 |
int (*add_dev) (struct device *, struct class_interface *); void (*remove_dev) (struct device *, struct class_interface *); |
1da177e4c
|
426 |
}; |
4a7fb6363
|
427 |
extern int __must_check class_interface_register(struct class_interface *); |
1da177e4c
|
428 |
extern void class_interface_unregister(struct class_interface *); |
d2a3b9146
|
429 430 431 |
extern struct class * __must_check __class_create(struct module *owner, const char *name, struct lock_class_key *key); |
e9ba6365f
|
432 |
extern void class_destroy(struct class *cls); |
e9ba6365f
|
433 |
|
d2a3b9146
|
434 435 436 437 438 439 440 |
/* This is a #define to keep the compiler from merging different * instances of the __key variable */ #define class_create(owner, name) \ ({ \ static struct lock_class_key __key; \ __class_create(owner, name, &__key); \ }) |
414264f95
|
441 442 443 444 445 446 447 448 449 |
/* * The type of device, "struct device" is embedded in. A class * or bus can contain devices of different types * like "partitions" and "disks", "mouse" and "event". * This identifies the device type and carries type-specific * information, equivalent to the kobj_type of a kobject. * If "name" is specified, the uevent will contain it in * the DEVTYPE variable. */ |
f9f852df2
|
450 |
struct device_type { |
414264f95
|
451 |
const char *name; |
a4dbd6740
|
452 |
const struct attribute_group **groups; |
7eff2e7a8
|
453 |
int (*uevent)(struct device *dev, struct kobj_uevent_env *env); |
2c9ede55e
|
454 |
char *(*devnode)(struct device *dev, umode_t *mode); |
f9f852df2
|
455 |
void (*release)(struct device *dev); |
1eede070a
|
456 |
|
8150f32b9
|
457 |
const struct dev_pm_ops *pm; |
f9f852df2
|
458 |
}; |
a7fd67062
|
459 460 461 462 463 464 465 466 |
/* interface for exporting device attributes */ struct device_attribute { struct attribute attr; ssize_t (*show)(struct device *dev, struct device_attribute *attr, char *buf); ssize_t (*store)(struct device *dev, struct device_attribute *attr, const char *buf, size_t count); }; |
ca22e56de
|
467 468 469 470 471 472 473 474 475 476 477 478 479 |
struct dev_ext_attribute { struct device_attribute attr; void *var; }; ssize_t device_show_ulong(struct device *dev, struct device_attribute *attr, char *buf); ssize_t device_store_ulong(struct device *dev, struct device_attribute *attr, const char *buf, size_t count); ssize_t device_show_int(struct device *dev, struct device_attribute *attr, char *buf); ssize_t device_store_int(struct device *dev, struct device_attribute *attr, const char *buf, size_t count); |
a7fd67062
|
480 |
|
d462943af
|
481 |
#define DEVICE_ATTR(_name, _mode, _show, _store) \ |
ca22e56de
|
482 483 484 485 486 487 488 |
struct device_attribute dev_attr_##_name = __ATTR(_name, _mode, _show, _store) #define DEVICE_ULONG_ATTR(_name, _mode, _var) \ struct dev_ext_attribute dev_attr_##_name = \ { __ATTR(_name, _mode, device_show_ulong, device_store_ulong), &(_var) } #define DEVICE_INT_ATTR(_name, _mode, _var) \ struct dev_ext_attribute dev_attr_##_name = \ { __ATTR(_name, _mode, device_show_ulong, device_store_ulong), &(_var) } |
a7fd67062
|
489 |
|
b9d4e714a
|
490 491 |
extern int device_create_file(struct device *device, const struct device_attribute *entry); |
d462943af
|
492 |
extern void device_remove_file(struct device *dev, |
26579ab70
|
493 |
const struct device_attribute *attr); |
2589f1887
|
494 |
extern int __must_check device_create_bin_file(struct device *dev, |
66ecb92be
|
495 |
const struct bin_attribute *attr); |
2589f1887
|
496 |
extern void device_remove_bin_file(struct device *dev, |
66ecb92be
|
497 |
const struct bin_attribute *attr); |
523ded71d
|
498 |
extern int device_schedule_callback_owner(struct device *dev, |
d462943af
|
499 |
void (*func)(struct device *dev), struct module *owner); |
523ded71d
|
500 501 502 503 |
/* This is a macro to avoid include problems with THIS_MODULE */ #define device_schedule_callback(dev, func) \ device_schedule_callback_owner(dev, func, THIS_MODULE) |
9ac7849e3
|
504 505 506 507 508 509 |
/* device resource management */ typedef void (*dr_release_t)(struct device *dev, void *res); typedef int (*dr_match_t)(struct device *dev, void *res, void *match_data); #ifdef CONFIG_DEBUG_DEVRES |
d462943af
|
510 |
extern void *__devres_alloc(dr_release_t release, size_t size, gfp_t gfp, |
9ac7849e3
|
511 512 513 514 |
const char *name); #define devres_alloc(release, size, gfp) \ __devres_alloc(release, size, gfp, #release) #else |
d462943af
|
515 |
extern void *devres_alloc(dr_release_t release, size_t size, gfp_t gfp); |
9ac7849e3
|
516 517 518 |
#endif extern void devres_free(void *res); extern void devres_add(struct device *dev, void *res); |
d462943af
|
519 |
extern void *devres_find(struct device *dev, dr_release_t release, |
9ac7849e3
|
520 |
dr_match_t match, void *match_data); |
d462943af
|
521 522 523 524 |
extern void *devres_get(struct device *dev, void *new_res, dr_match_t match, void *match_data); extern void *devres_remove(struct device *dev, dr_release_t release, dr_match_t match, void *match_data); |
9ac7849e3
|
525 526 527 528 529 530 531 532 533 534 535 536 537 |
extern int devres_destroy(struct device *dev, dr_release_t release, dr_match_t match, void *match_data); /* devres group */ extern void * __must_check devres_open_group(struct device *dev, void *id, gfp_t gfp); extern void devres_close_group(struct device *dev, void *id); extern void devres_remove_group(struct device *dev, void *id); extern int devres_release_group(struct device *dev, void *id); /* managed kzalloc/kfree for device drivers, no kmalloc, always use kzalloc */ extern void *devm_kzalloc(struct device *dev, size_t size, gfp_t gfp); extern void devm_kfree(struct device *dev, void *p); |
72f8c0bfa
|
538 539 |
void __iomem *devm_request_and_ioremap(struct device *dev, struct resource *res); |
6b7b65105
|
540 541 542 543 544 545 546 547 |
struct device_dma_parameters { /* * a low level driver may set these to teach IOMMU code about * sg limitations. */ unsigned int max_segment_size; unsigned long segment_boundary_mask; }; |
880ffb5c6
|
548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 |
/** * struct device - The basic device structure * @parent: The device's "parent" device, the device to which it is attached. * In most cases, a parent device is some sort of bus or host * controller. If parent is NULL, the device, is a top-level device, * which is not usually what you want. * @p: Holds the private data of the driver core portions of the device. * See the comment of the struct device_private for detail. * @kobj: A top-level, abstract class from which other classes are derived. * @init_name: Initial name of the device. * @type: The type of device. * This identifies the device type and carries type-specific * information. * @mutex: Mutex to synchronize calls to its driver. * @bus: Type of bus device is on. * @driver: Which driver has allocated this * @platform_data: Platform data specific to the device. * Example: For devices on custom boards, as typical of embedded * and SOC based hardware, Linux often uses platform_data to point * to board-specific structures describing devices and how they * are wired. That can include what ports are available, chip * variants, which GPIO pins act in what additional roles, and so * on. This shrinks the "Board Support Packages" (BSPs) and * minimizes board-specific #ifdefs in drivers. * @power: For device power management. * See Documentation/power/devices.txt for details. |
564b905ab
|
574 |
* @pm_domain: Provide callbacks that are executed during system suspend, |
880ffb5c6
|
575 576 577 578 579 580 581 582 583 584 585 586 587 |
* hibernation, system resume and during runtime PM transitions * along with subsystem-level and driver-level callbacks. * @numa_node: NUMA node this device is close to. * @dma_mask: Dma mask (if dma'ble device). * @coherent_dma_mask: Like dma_mask, but for alloc_coherent mapping as not all * hardware supports 64-bit addresses for consistent allocations * such descriptors. * @dma_parms: A low level driver may set these to teach IOMMU code about * segment limitations. * @dma_pools: Dma pools (if dma'ble device). * @dma_mem: Internal for coherent mem override. * @archdata: For arch-specific additions. * @of_node: Associated device tree node. |
880ffb5c6
|
588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 |
* @devt: For creating the sysfs "dev". * @devres_lock: Spinlock to protect the resource of the device. * @devres_head: The resources list of the device. * @knode_class: The node used to add the device to the class list. * @class: The class of the device. * @groups: Optional attribute groups. * @release: Callback to free the device after all references have * gone away. This should be set by the allocator of the * device (i.e. the bus driver that discovered the device). * * At the lowest level, every device in a Linux system is represented by an * instance of struct device. The device structure contains the information * that the device model core needs to model the system. Most subsystems, * however, track additional information about the devices they host. As a * result, it is rare for devices to be represented by bare device structures; * instead, that structure, like kobject structures, is usually embedded within * a higher-level representation of the device. */ |
1da177e4c
|
606 |
struct device { |
49a4ec188
|
607 |
struct device *parent; |
1da177e4c
|
608 |
|
fb069a5d1
|
609 |
struct device_private *p; |
1da177e4c
|
610 |
struct kobject kobj; |
c906a48ad
|
611 |
const char *init_name; /* initial name of the device */ |
aed65af1c
|
612 |
const struct device_type *type; |
1da177e4c
|
613 |
|
3142788b7
|
614 |
struct mutex mutex; /* mutex to synchronize calls to |
af70316af
|
615 616 |
* its driver. */ |
d462943af
|
617 |
struct bus_type *bus; /* type of bus device is on */ |
1da177e4c
|
618 619 |
struct device_driver *driver; /* which driver has allocated this device */ |
e67c85626
|
620 621 |
void *platform_data; /* Platform specific data, device core doesn't touch it */ |
1da177e4c
|
622 |
struct dev_pm_info power; |
564b905ab
|
623 |
struct dev_pm_domain *pm_domain; |
1da177e4c
|
624 |
|
873481367
|
625 626 627 |
#ifdef CONFIG_NUMA int numa_node; /* NUMA node this device is close to */ #endif |
1da177e4c
|
628 629 630 631 632 633 |
u64 *dma_mask; /* dma mask (if dma'able device) */ u64 coherent_dma_mask;/* Like dma_mask, but for alloc_coherent mappings as not all hardware supports 64 bit addresses for consistent allocations such descriptors. */ |
6b7b65105
|
634 |
struct device_dma_parameters *dma_parms; |
1da177e4c
|
635 636 637 638 |
struct list_head dma_pools; /* dma pools (if dma'ble) */ struct dma_coherent_mem *dma_mem; /* internal for coherent mem override */ |
c6dbaef22
|
639 640 |
/* arch specific additions */ struct dev_archdata archdata; |
c9e358dfc
|
641 642 |
struct device_node *of_node; /* associated device tree node */ |
1da177e4c
|
643 |
|
929d2fa59
|
644 |
dev_t devt; /* dev_t, creates the sysfs "dev" */ |
ca22e56de
|
645 |
u32 id; /* device instance */ |
929d2fa59
|
646 |
|
9ac7849e3
|
647 648 |
spinlock_t devres_lock; struct list_head devres_head; |
5a3ceb861
|
649 |
struct klist_node knode_class; |
b7a3e813f
|
650 |
struct class *class; |
a4dbd6740
|
651 |
const struct attribute_group **groups; /* optional groups */ |
23681e479
|
652 |
|
d462943af
|
653 |
void (*release)(struct device *dev); |
1da177e4c
|
654 |
}; |
9a3df1f7d
|
655 656 |
/* Get the wakeup routines, which depend on struct device */ #include <linux/pm_wakeup.h> |
bf9ca69fc
|
657 |
static inline const char *dev_name(const struct device *dev) |
06916639e
|
658 |
{ |
a636ee7fb
|
659 660 661 |
/* Use the init name until the kobject becomes available */ if (dev->init_name) return dev->init_name; |
1fa5ae857
|
662 |
return kobject_name(&dev->kobj); |
06916639e
|
663 |
} |
b9075fa96
|
664 665 |
extern __printf(2, 3) int dev_set_name(struct device *dev, const char *name, ...); |
413c239fa
|
666 |
|
873481367
|
667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 |
#ifdef CONFIG_NUMA static inline int dev_to_node(struct device *dev) { return dev->numa_node; } static inline void set_dev_node(struct device *dev, int node) { dev->numa_node = node; } #else static inline int dev_to_node(struct device *dev) { return -1; } static inline void set_dev_node(struct device *dev, int node) { } #endif |
5c095a0e0
|
685 686 687 688 |
static inline struct pm_subsys_data *dev_to_psd(struct device *dev) { return dev ? dev->power.subsys_data : NULL; } |
f67f129e5
|
689 690 691 692 693 694 695 696 697 |
static inline unsigned int dev_get_uevent_suppress(const struct device *dev) { return dev->kobj.uevent_suppress; } static inline void dev_set_uevent_suppress(struct device *dev, int val) { dev->kobj.uevent_suppress = val; } |
d305ef5d2
|
698 699 |
static inline int device_is_registered(struct device *dev) { |
3f62e5700
|
700 |
return dev->kobj.state_in_sysfs; |
d305ef5d2
|
701 |
} |
5af84b827
|
702 703 |
static inline void device_enable_async_suspend(struct device *dev) { |
f76b168b6
|
704 |
if (!dev->power.is_prepared) |
5af84b827
|
705 706 |
dev->power.async_suspend = true; } |
5a2eb8585
|
707 708 |
static inline void device_disable_async_suspend(struct device *dev) { |
f76b168b6
|
709 |
if (!dev->power.is_prepared) |
5a2eb8585
|
710 711 712 713 714 715 716 |
dev->power.async_suspend = false; } static inline bool device_async_suspend_enabled(struct device *dev) { return !!dev->power.async_suspend; } |
8b258cc8a
|
717 718 719 720 |
static inline void pm_suspend_ignore_children(struct device *dev, bool enable) { dev->power.ignore_children = enable; } |
8e9394ce2
|
721 722 |
static inline void device_lock(struct device *dev) { |
3142788b7
|
723 |
mutex_lock(&dev->mutex); |
8e9394ce2
|
724 725 726 727 |
} static inline int device_trylock(struct device *dev) { |
3142788b7
|
728 |
return mutex_trylock(&dev->mutex); |
8e9394ce2
|
729 730 731 732 |
} static inline void device_unlock(struct device *dev) { |
3142788b7
|
733 |
mutex_unlock(&dev->mutex); |
8e9394ce2
|
734 |
} |
1f21782e6
|
735 |
void driver_init(void); |
1da177e4c
|
736 737 738 |
/* * High level routines for use by the bus drivers */ |
d462943af
|
739 740 741 742 743 744 745 746 747 |
extern int __must_check device_register(struct device *dev); extern void device_unregister(struct device *dev); extern void device_initialize(struct device *dev); extern int __must_check device_add(struct device *dev); extern void device_del(struct device *dev); extern int device_for_each_child(struct device *dev, void *data, int (*fn)(struct device *dev, void *data)); extern struct device *device_find_child(struct device *dev, void *data, int (*match)(struct device *dev, void *data)); |
6937e8f8c
|
748 |
extern int device_rename(struct device *dev, const char *new_name); |
ffa6a7054
|
749 750 |
extern int device_move(struct device *dev, struct device *new_parent, enum dpm_order dpm_order); |
e454cea20
|
751 |
extern const char *device_get_devnode(struct device *dev, |
2c9ede55e
|
752 |
umode_t *mode, const char **tmp); |
b40284378
|
753 |
extern void *dev_get_drvdata(const struct device *dev); |
c87050824
|
754 |
extern int dev_set_drvdata(struct device *dev, void *data); |
1da177e4c
|
755 756 |
/* |
0aa0dc41b
|
757 758 759 760 |
* Root device objects for grouping under /sys/devices */ extern struct device *__root_device_register(const char *name, struct module *owner); |
eb5589a8f
|
761 762 763 764 765 766 767 |
/* * This is a macro to avoid include problems with THIS_MODULE, * just as per what is done for device_schedule_callback() above. */ #define root_device_register(name) \ __root_device_register(name, THIS_MODULE) |
0aa0dc41b
|
768 |
extern void root_device_unregister(struct device *root); |
a5b8b1ada
|
769 770 771 772 |
static inline void *dev_get_platdata(const struct device *dev) { return dev->platform_data; } |
0aa0dc41b
|
773 |
/* |
1da177e4c
|
774 775 776 |
* Manual binding of a device to driver. See drivers/base/bus.c * for information on use. */ |
f86db396f
|
777 |
extern int __must_check device_bind_driver(struct device *dev); |
d462943af
|
778 779 |
extern void device_release_driver(struct device *dev); extern int __must_check device_attach(struct device *dev); |
f86db396f
|
780 781 |
extern int __must_check driver_attach(struct device_driver *drv); extern int __must_check device_reprobe(struct device *dev); |
1da177e4c
|
782 |
|
23681e479
|
783 784 785 |
/* * Easy functions for dynamically creating devices on the fly */ |
8882b3942
|
786 787 788 789 790 791 |
extern struct device *device_create_vargs(struct class *cls, struct device *parent, dev_t devt, void *drvdata, const char *fmt, va_list vargs); |
b9075fa96
|
792 793 794 795 |
extern __printf(5, 6) struct device *device_create(struct class *cls, struct device *parent, dev_t devt, void *drvdata, const char *fmt, ...); |
23681e479
|
796 |
extern void device_destroy(struct class *cls, dev_t devt); |
1da177e4c
|
797 |
|
1da177e4c
|
798 799 800 801 802 803 |
/* * Platform "fixup" functions - allow the platform to have their say * about devices and actions that the general device layer doesn't * know about. */ /* Notify platform of device discovery */ |
d462943af
|
804 |
extern int (*platform_notify)(struct device *dev); |
1da177e4c
|
805 |
|
d462943af
|
806 |
extern int (*platform_notify_remove)(struct device *dev); |
1da177e4c
|
807 |
|
880ffb5c6
|
808 |
/* |
1da177e4c
|
809 810 811 |
* get_device - atomically increment the reference count for the device. * */ |
d462943af
|
812 813 |
extern struct device *get_device(struct device *dev); extern void put_device(struct device *dev); |
1da177e4c
|
814 |
|
d4d5291c8
|
815 |
extern void wait_for_device_probe(void); |
1da177e4c
|
816 |
|
2b2af54a5
|
817 818 819 |
#ifdef CONFIG_DEVTMPFS extern int devtmpfs_create_node(struct device *dev); extern int devtmpfs_delete_node(struct device *dev); |
073120cc2
|
820 |
extern int devtmpfs_mount(const char *mntdir); |
2b2af54a5
|
821 822 823 824 825 |
#else static inline int devtmpfs_create_node(struct device *dev) { return 0; } static inline int devtmpfs_delete_node(struct device *dev) { return 0; } static inline int devtmpfs_mount(const char *mountpoint) { return 0; } #endif |
116f232b3
|
826 |
/* drivers/base/power/shutdown.c */ |
1da177e4c
|
827 |
extern void device_shutdown(void); |
1da177e4c
|
828 |
/* debugging and troubleshooting/diagnostic helpers. */ |
bf9ca69fc
|
829 |
extern const char *dev_driver_string(const struct device *dev); |
99bcf2171
|
830 831 832 |
#ifdef CONFIG_PRINTK |
cbc466355
|
833 834 |
extern int __dev_printk(const char *level, const struct device *dev, struct va_format *vaf); |
b9075fa96
|
835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 |
extern __printf(3, 4) int dev_printk(const char *level, const struct device *dev, const char *fmt, ...) ; extern __printf(2, 3) int dev_emerg(const struct device *dev, const char *fmt, ...); extern __printf(2, 3) int dev_alert(const struct device *dev, const char *fmt, ...); extern __printf(2, 3) int dev_crit(const struct device *dev, const char *fmt, ...); extern __printf(2, 3) int dev_err(const struct device *dev, const char *fmt, ...); extern __printf(2, 3) int dev_warn(const struct device *dev, const char *fmt, ...); extern __printf(2, 3) int dev_notice(const struct device *dev, const char *fmt, ...); extern __printf(2, 3) int _dev_info(const struct device *dev, const char *fmt, ...); |
99bcf2171
|
853 854 |
#else |
cbc466355
|
855 856 |
static inline int __dev_printk(const char *level, const struct device *dev, struct va_format *vaf) |
b9075fa96
|
857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 |
{ return 0; } static inline __printf(3, 4) int dev_printk(const char *level, const struct device *dev, const char *fmt, ...) { return 0; } static inline __printf(2, 3) int dev_emerg(const struct device *dev, const char *fmt, ...) { return 0; } static inline __printf(2, 3) int dev_crit(const struct device *dev, const char *fmt, ...) { return 0; } static inline __printf(2, 3) int dev_alert(const struct device *dev, const char *fmt, ...) { return 0; } static inline __printf(2, 3) int dev_err(const struct device *dev, const char *fmt, ...) { return 0; } static inline __printf(2, 3) int dev_warn(const struct device *dev, const char *fmt, ...) { return 0; } static inline __printf(2, 3) int dev_notice(const struct device *dev, const char *fmt, ...) { return 0; } static inline __printf(2, 3) int _dev_info(const struct device *dev, const char *fmt, ...) { return 0; } |
99bcf2171
|
884 885 886 887 888 889 890 891 892 893 894 |
#endif /* * Stupid hackaround for existing uses of non-printk uses dev_info * * Note that the definition of dev_info below is actually _dev_info * and a macro is used to avoid redefining dev_info */ #define dev_info(dev, fmt, arg...) _dev_info(dev, fmt, ##arg) |
7b8712e56
|
895 |
|
d0d85ff98
|
896 897 |
#if defined(DEBUG) #define dev_dbg(dev, format, arg...) \ |
99bcf2171
|
898 |
dev_printk(KERN_DEBUG, dev, format, ##arg) |
e9d376f0f
|
899 |
#elif defined(CONFIG_DYNAMIC_DEBUG) |
99bcf2171
|
900 901 |
#define dev_dbg(dev, format, ...) \ do { \ |
346e15beb
|
902 |
dynamic_dev_dbg(dev, format, ##__VA_ARGS__); \ |
99bcf2171
|
903 |
} while (0) |
1da177e4c
|
904 |
#else |
99bcf2171
|
905 906 907 908 909 910 |
#define dev_dbg(dev, format, arg...) \ ({ \ if (0) \ dev_printk(KERN_DEBUG, dev, format, ##arg); \ 0; \ }) |
1da177e4c
|
911 |
#endif |
aebdc3b45
|
912 913 914 |
#ifdef VERBOSE_DEBUG #define dev_vdbg dev_dbg #else |
99bcf2171
|
915 916 917 918 919 920 |
#define dev_vdbg(dev, format, arg...) \ ({ \ if (0) \ dev_printk(KERN_DEBUG, dev, format, ##arg); \ 0; \ }) |
aebdc3b45
|
921 |
#endif |
e61396627
|
922 |
/* |
bcdd323b8
|
923 |
* dev_WARN*() acts like dev_printk(), but with the key difference |
e61396627
|
924 925 926 927 928 929 |
* of using a WARN/WARN_ON to get the message out, including the * file/line information and a backtrace. */ #define dev_WARN(dev, format, arg...) \ WARN(1, "Device: %s " format, dev_driver_string(dev), ## arg); |
bcdd323b8
|
930 931 932 933 |
#define dev_WARN_ONCE(dev, condition, format, arg...) \ WARN_ONCE(condition, "Device %s " format, \ dev_driver_string(dev), ## arg) |
1da177e4c
|
934 935 936 937 938 |
/* Create alias, so I can be autoloaded. */ #define MODULE_ALIAS_CHARDEV(major,minor) \ MODULE_ALIAS("char-major-" __stringify(major) "-" __stringify(minor)) #define MODULE_ALIAS_CHARDEV_MAJOR(major) \ MODULE_ALIAS("char-major-" __stringify(major) "-*") |
e52eec13c
|
939 940 941 942 943 944 |
#ifdef CONFIG_SYSFS_DEPRECATED extern long sysfs_deprecated; #else #define sysfs_deprecated 0 #endif |
907d0ed1c
|
945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 |
/** * module_driver() - Helper macro for drivers that don't do anything * special in module init/exit. This eliminates a lot of boilerplate. * Each module may only use this macro once, and calling it replaces * module_init() and module_exit(). * * Use this macro to construct bus specific macros for registering * drivers, and do not use it on its own. */ #define module_driver(__driver, __register, __unregister) \ static int __init __driver##_init(void) \ { \ return __register(&(__driver)); \ } \ module_init(__driver##_init); \ static void __exit __driver##_exit(void) \ { \ __unregister(&(__driver)); \ } \ module_exit(__driver##_exit); |
1da177e4c
|
965 |
#endif /* _DEVICE_H_ */ |