]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - include/linux/device.h
Merge branch 'for-2.6.37/drivers' into for-linus
[mirror_ubuntu-bionic-kernel.git] / include / linux / device.h
CommitLineData
1da177e4
LT
1/*
2 * device.h - generic, centralized driver model
3 *
4 * Copyright (c) 2001-2003 Patrick Mochel <mochel@osdl.org>
b4028437
GKH
5 * Copyright (c) 2004-2009 Greg Kroah-Hartman <gregkh@suse.de>
6 * Copyright (c) 2008-2009 Novell Inc.
1da177e4
LT
7 *
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
1da177e4
LT
16#include <linux/ioport.h>
17#include <linux/kobject.h>
465c7a3a 18#include <linux/klist.h>
1da177e4 19#include <linux/list.h>
d2a3b914 20#include <linux/lockdep.h>
4a7fb636 21#include <linux/compiler.h>
1da177e4
LT
22#include <linux/types.h>
23#include <linux/module.h>
24#include <linux/pm.h>
1da177e4 25#include <asm/atomic.h>
c6dbaef2 26#include <asm/device.h>
1da177e4 27
1da177e4 28struct device;
fb069a5d 29struct device_private;
1da177e4 30struct device_driver;
e5dd1278 31struct driver_private;
1da177e4 32struct class;
7c71448b 33struct class_private;
b8c5cec2 34struct bus_type;
c6f7e72a 35struct bus_type_private;
d706c1b0 36struct device_node;
b8c5cec2
KS
37
38struct bus_attribute {
39 struct attribute attr;
d462943a
GKH
40 ssize_t (*show)(struct bus_type *bus, char *buf);
41 ssize_t (*store)(struct bus_type *bus, const char *buf, size_t count);
b8c5cec2
KS
42};
43
d462943a
GKH
44#define BUS_ATTR(_name, _mode, _show, _store) \
45struct bus_attribute bus_attr_##_name = __ATTR(_name, _mode, _show, _store)
b8c5cec2
KS
46
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 *);
1da177e4
LT
50
51struct bus_type {
d462943a
GKH
52 const char *name;
53 struct bus_attribute *bus_attrs;
54 struct device_attribute *dev_attrs;
55 struct driver_attribute *drv_attrs;
56
57 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);
62
63 int (*suspend)(struct device *dev, pm_message_t state);
d462943a 64 int (*resume)(struct device *dev);
b8c5cec2 65
8150f32b 66 const struct dev_pm_ops *pm;
1eede070 67
c6f7e72a 68 struct bus_type_private *p;
1da177e4
LT
69};
70
d462943a
GKH
71extern int __must_check bus_register(struct bus_type *bus);
72extern void bus_unregister(struct bus_type *bus);
1da177e4 73
d462943a 74extern int __must_check bus_rescan_devices(struct bus_type *bus);
1da177e4 75
1da177e4
LT
76/* iterator helpers for buses */
77
d462943a
GKH
78int 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));
1f9ffc04
GKH
83struct device *bus_find_device_by_name(struct bus_type *bus,
84 struct device *start,
85 const char *name);
1da177e4 86
cc7447a5
JD
87int bus_for_each_drv(struct bus_type *bus, struct device_driver *start,
88 void *data, int (*fn)(struct device_driver *, void *));
1da177e4 89
99178b03
GKH
90void bus_sort_breadthfirst(struct bus_type *bus,
91 int (*compare)(const struct device *a,
92 const struct device *b));
116af378
BH
93/*
94 * Bus notifiers: Get notified of addition/removal of devices
95 * and binding/unbinding of drivers to devices.
96 * In the long run, it should be a replacement for the platform
97 * notify hooks.
98 */
99struct notifier_block;
100
101extern int bus_register_notifier(struct bus_type *bus,
102 struct notifier_block *nb);
103extern int bus_unregister_notifier(struct bus_type *bus,
104 struct notifier_block *nb);
105
106/* All 4 notifers below get called with the target struct device *
107 * as an argument. Note that those functions are likely to be called
8e9394ce 108 * with the device lock held in the core, so be careful.
116af378
BH
109 */
110#define BUS_NOTIFY_ADD_DEVICE 0x00000001 /* device added */
111#define BUS_NOTIFY_DEL_DEVICE 0x00000002 /* device removed */
45daef0f
MD
112#define BUS_NOTIFY_BIND_DRIVER 0x00000003 /* driver about to be
113 bound */
114#define BUS_NOTIFY_BOUND_DRIVER 0x00000004 /* driver bound to device */
115#define BUS_NOTIFY_UNBIND_DRIVER 0x00000005 /* driver about to be
116af378 116 unbound */
45daef0f 117#define BUS_NOTIFY_UNBOUND_DRIVER 0x00000006 /* driver is unbound
309b7d60 118 from the device */
116af378 119
0fed80f7 120extern struct kset *bus_get_kset(struct bus_type *bus);
b249072e 121extern struct klist *bus_get_device_klist(struct bus_type *bus);
0fed80f7 122
1da177e4 123struct device_driver {
e5dd1278
GKH
124 const char *name;
125 struct bus_type *bus;
1da177e4 126
e5dd1278 127 struct module *owner;
1a6f2a75
DT
128 const char *mod_name; /* used for built-in modules */
129
130 bool suppress_bind_attrs; /* disables bind/unbind via sysfs */
1da177e4 131
597b9d1e
GL
132#if defined(CONFIG_OF)
133 const struct of_device_id *of_match_table;
134#endif
135
d462943a
GKH
136 int (*probe) (struct device *dev);
137 int (*remove) (struct device *dev);
138 void (*shutdown) (struct device *dev);
139 int (*suspend) (struct device *dev, pm_message_t state);
140 int (*resume) (struct device *dev);
a4dbd674 141 const struct attribute_group **groups;
e5dd1278 142
8150f32b 143 const struct dev_pm_ops *pm;
1eede070 144
e5dd1278 145 struct driver_private *p;
1da177e4
LT
146};
147
148
d462943a
GKH
149extern int __must_check driver_register(struct device_driver *drv);
150extern void driver_unregister(struct device_driver *drv);
1da177e4 151
d462943a
GKH
152extern struct device_driver *get_driver(struct device_driver *drv);
153extern void put_driver(struct device_driver *drv);
154extern struct device_driver *driver_find(const char *name,
155 struct bus_type *bus);
d779249e 156extern int driver_probe_done(void);
b23530eb 157extern void wait_for_device_probe(void);
216773a7 158
1da177e4 159
405ae7d3 160/* sysfs interface for exporting driver attributes */
1da177e4
LT
161
162struct driver_attribute {
d462943a
GKH
163 struct attribute attr;
164 ssize_t (*show)(struct device_driver *driver, char *buf);
165 ssize_t (*store)(struct device_driver *driver, const char *buf,
166 size_t count);
1da177e4
LT
167};
168
d462943a
GKH
169#define DRIVER_ATTR(_name, _mode, _show, _store) \
170struct driver_attribute driver_attr_##_name = \
171 __ATTR(_name, _mode, _show, _store)
1da177e4 172
d462943a 173extern int __must_check driver_create_file(struct device_driver *driver,
099c2f21 174 const struct driver_attribute *attr);
d462943a 175extern void driver_remove_file(struct device_driver *driver,
099c2f21 176 const struct driver_attribute *attr);
1da177e4 177
cbe9c595
GKH
178extern int __must_check driver_add_kobj(struct device_driver *drv,
179 struct kobject *kobj,
180 const char *fmt, ...);
181
d462943a
GKH
182extern int __must_check driver_for_each_device(struct device_driver *drv,
183 struct device *start,
184 void *data,
185 int (*fn)(struct device *dev,
186 void *));
187struct device *driver_find_device(struct device_driver *drv,
188 struct device *start, void *data,
189 int (*match)(struct device *dev, void *data));
fae3cd00 190
1da177e4
LT
191/*
192 * device classes
193 */
194struct class {
d462943a
GKH
195 const char *name;
196 struct module *owner;
1da177e4 197
d462943a 198 struct class_attribute *class_attrs;
d462943a 199 struct device_attribute *dev_attrs;
e105b8bf 200 struct kobject *dev_kobj;
1da177e4 201
d462943a 202 int (*dev_uevent)(struct device *dev, struct kobj_uevent_env *env);
e454cea2 203 char *(*devnode)(struct device *dev, mode_t *mode);
1da177e4 204
d462943a
GKH
205 void (*class_release)(struct class *class);
206 void (*dev_release)(struct device *dev);
7c8265f5 207
d462943a
GKH
208 int (*suspend)(struct device *dev, pm_message_t state);
209 int (*resume)(struct device *dev);
1eede070 210
bc451f20
EB
211 const struct kobj_ns_type_operations *ns_type;
212 const void *(*namespace)(struct device *dev);
213
8150f32b
DT
214 const struct dev_pm_ops *pm;
215
7c71448b 216 struct class_private *p;
1da177e4
LT
217};
218
5a3ceb86
TH
219struct class_dev_iter {
220 struct klist_iter ki;
221 const struct device_type *type;
222};
223
e105b8bf
DW
224extern struct kobject *sysfs_dev_block_kobj;
225extern struct kobject *sysfs_dev_char_kobj;
d2a3b914
MW
226extern int __must_check __class_register(struct class *class,
227 struct lock_class_key *key);
d462943a 228extern void class_unregister(struct class *class);
d2a3b914
MW
229
230/* This is a #define to keep the compiler from merging different
231 * instances of the __key variable */
232#define class_register(class) \
233({ \
234 static struct lock_class_key __key; \
235 __class_register(class, &__key); \
236})
237
46227094
JD
238struct class_compat;
239struct class_compat *class_compat_register(const char *name);
240void class_compat_unregister(struct class_compat *cls);
241int class_compat_create_link(struct class_compat *cls, struct device *dev,
242 struct device *device_link);
243void class_compat_remove_link(struct class_compat *cls, struct device *dev,
244 struct device *device_link);
245
5a3ceb86
TH
246extern void class_dev_iter_init(struct class_dev_iter *iter,
247 struct class *class,
248 struct device *start,
249 const struct device_type *type);
250extern struct device *class_dev_iter_next(struct class_dev_iter *iter);
251extern void class_dev_iter_exit(struct class_dev_iter *iter);
252
93562b53
GKH
253extern int class_for_each_device(struct class *class, struct device *start,
254 void *data,
fd04897b 255 int (*fn)(struct device *dev, void *data));
695794ae
GKH
256extern struct device *class_find_device(struct class *class,
257 struct device *start, void *data,
fd04897b 258 int (*match)(struct device *, void *));
1da177e4
LT
259
260struct class_attribute {
d462943a 261 struct attribute attr;
28812fe1
AK
262 ssize_t (*show)(struct class *class, struct class_attribute *attr,
263 char *buf);
264 ssize_t (*store)(struct class *class, struct class_attribute *attr,
265 const char *buf, size_t count);
1da177e4
LT
266};
267
d462943a
GKH
268#define CLASS_ATTR(_name, _mode, _show, _store) \
269struct class_attribute class_attr_##_name = __ATTR(_name, _mode, _show, _store)
1da177e4 270
d462943a
GKH
271extern int __must_check class_create_file(struct class *class,
272 const struct class_attribute *attr);
273extern void class_remove_file(struct class *class,
274 const struct class_attribute *attr);
1da177e4 275
869dfc87
AK
276/* Simple class attribute that is just a static string */
277
278struct class_attribute_string {
279 struct class_attribute attr;
280 char *str;
281};
282
283/* Currently read-only only */
284#define _CLASS_ATTR_STRING(_name, _mode, _str) \
285 { __ATTR(_name, _mode, show_class_attr_string, NULL), _str }
286#define CLASS_ATTR_STRING(_name, _mode, _str) \
287 struct class_attribute_string class_attr_##_name = \
288 _CLASS_ATTR_STRING(_name, _mode, _str)
289
290extern ssize_t show_class_attr_string(struct class *class, struct class_attribute *attr,
291 char *buf);
292
1da177e4
LT
293struct class_interface {
294 struct list_head node;
295 struct class *class;
296
c47ed219
GKH
297 int (*add_dev) (struct device *, struct class_interface *);
298 void (*remove_dev) (struct device *, struct class_interface *);
1da177e4
LT
299};
300
4a7fb636 301extern int __must_check class_interface_register(struct class_interface *);
1da177e4
LT
302extern void class_interface_unregister(struct class_interface *);
303
d2a3b914
MW
304extern struct class * __must_check __class_create(struct module *owner,
305 const char *name,
306 struct lock_class_key *key);
e9ba6365 307extern void class_destroy(struct class *cls);
e9ba6365 308
d2a3b914
MW
309/* This is a #define to keep the compiler from merging different
310 * instances of the __key variable */
311#define class_create(owner, name) \
312({ \
313 static struct lock_class_key __key; \
314 __class_create(owner, name, &__key); \
315})
316
414264f9
KS
317/*
318 * The type of device, "struct device" is embedded in. A class
319 * or bus can contain devices of different types
320 * like "partitions" and "disks", "mouse" and "event".
321 * This identifies the device type and carries type-specific
322 * information, equivalent to the kobj_type of a kobject.
323 * If "name" is specified, the uevent will contain it in
324 * the DEVTYPE variable.
325 */
f9f852df 326struct device_type {
414264f9 327 const char *name;
a4dbd674 328 const struct attribute_group **groups;
7eff2e7a 329 int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
e454cea2 330 char *(*devnode)(struct device *dev, mode_t *mode);
f9f852df 331 void (*release)(struct device *dev);
1eede070 332
8150f32b 333 const struct dev_pm_ops *pm;
f9f852df
KS
334};
335
a7fd6706
KS
336/* interface for exporting device attributes */
337struct device_attribute {
338 struct attribute attr;
339 ssize_t (*show)(struct device *dev, struct device_attribute *attr,
340 char *buf);
341 ssize_t (*store)(struct device *dev, struct device_attribute *attr,
342 const char *buf, size_t count);
343};
344
d462943a
GKH
345#define DEVICE_ATTR(_name, _mode, _show, _store) \
346struct device_attribute dev_attr_##_name = __ATTR(_name, _mode, _show, _store)
a7fd6706 347
4a7fb636 348extern int __must_check device_create_file(struct device *device,
66ecb92b 349 const struct device_attribute *entry);
d462943a 350extern void device_remove_file(struct device *dev,
26579ab7 351 const struct device_attribute *attr);
2589f188 352extern int __must_check device_create_bin_file(struct device *dev,
66ecb92b 353 const struct bin_attribute *attr);
2589f188 354extern void device_remove_bin_file(struct device *dev,
66ecb92b 355 const struct bin_attribute *attr);
523ded71 356extern int device_schedule_callback_owner(struct device *dev,
d462943a 357 void (*func)(struct device *dev), struct module *owner);
523ded71
AS
358
359/* This is a macro to avoid include problems with THIS_MODULE */
360#define device_schedule_callback(dev, func) \
361 device_schedule_callback_owner(dev, func, THIS_MODULE)
9ac7849e
TH
362
363/* device resource management */
364typedef void (*dr_release_t)(struct device *dev, void *res);
365typedef int (*dr_match_t)(struct device *dev, void *res, void *match_data);
366
367#ifdef CONFIG_DEBUG_DEVRES
d462943a 368extern void *__devres_alloc(dr_release_t release, size_t size, gfp_t gfp,
9ac7849e
TH
369 const char *name);
370#define devres_alloc(release, size, gfp) \
371 __devres_alloc(release, size, gfp, #release)
372#else
d462943a 373extern void *devres_alloc(dr_release_t release, size_t size, gfp_t gfp);
9ac7849e
TH
374#endif
375extern void devres_free(void *res);
376extern void devres_add(struct device *dev, void *res);
d462943a 377extern void *devres_find(struct device *dev, dr_release_t release,
9ac7849e 378 dr_match_t match, void *match_data);
d462943a
GKH
379extern void *devres_get(struct device *dev, void *new_res,
380 dr_match_t match, void *match_data);
381extern void *devres_remove(struct device *dev, dr_release_t release,
382 dr_match_t match, void *match_data);
9ac7849e
TH
383extern int devres_destroy(struct device *dev, dr_release_t release,
384 dr_match_t match, void *match_data);
385
386/* devres group */
387extern void * __must_check devres_open_group(struct device *dev, void *id,
388 gfp_t gfp);
389extern void devres_close_group(struct device *dev, void *id);
390extern void devres_remove_group(struct device *dev, void *id);
391extern int devres_release_group(struct device *dev, void *id);
392
393/* managed kzalloc/kfree for device drivers, no kmalloc, always use kzalloc */
394extern void *devm_kzalloc(struct device *dev, size_t size, gfp_t gfp);
395extern void devm_kfree(struct device *dev, void *p);
396
6b7b6510
FT
397struct device_dma_parameters {
398 /*
399 * a low level driver may set these to teach IOMMU code about
400 * sg limitations.
401 */
402 unsigned int max_segment_size;
403 unsigned long segment_boundary_mask;
404};
405
1da177e4 406struct device {
49a4ec18 407 struct device *parent;
1da177e4 408
fb069a5d
GKH
409 struct device_private *p;
410
1da177e4 411 struct kobject kobj;
c906a48a 412 const char *init_name; /* initial name of the device */
f9f852df 413 struct device_type *type;
1da177e4 414
3142788b 415 struct mutex mutex; /* mutex to synchronize calls to
af70316a
PM
416 * its driver.
417 */
418
d462943a 419 struct bus_type *bus; /* type of bus device is on */
1da177e4
LT
420 struct device_driver *driver; /* which driver has allocated this
421 device */
e67c8562
GKH
422 void *platform_data; /* Platform specific data, device
423 core doesn't touch it */
1da177e4
LT
424 struct dev_pm_info power;
425
87348136
CH
426#ifdef CONFIG_NUMA
427 int numa_node; /* NUMA node this device is close to */
428#endif
1da177e4
LT
429 u64 *dma_mask; /* dma mask (if dma'able device) */
430 u64 coherent_dma_mask;/* Like dma_mask, but for
431 alloc_coherent mappings as
432 not all hardware supports
433 64 bit addresses for consistent
434 allocations such descriptors. */
435
6b7b6510
FT
436 struct device_dma_parameters *dma_parms;
437
1da177e4
LT
438 struct list_head dma_pools; /* dma pools (if dma'ble) */
439
440 struct dma_coherent_mem *dma_mem; /* internal for coherent mem
441 override */
c6dbaef2
BH
442 /* arch specific additions */
443 struct dev_archdata archdata;
d706c1b0
GL
444#ifdef CONFIG_OF
445 struct device_node *of_node;
446#endif
1da177e4 447
929d2fa5
MW
448 dev_t devt; /* dev_t, creates the sysfs "dev" */
449
9ac7849e
TH
450 spinlock_t devres_lock;
451 struct list_head devres_head;
452
5a3ceb86 453 struct klist_node knode_class;
b7a3e813 454 struct class *class;
a4dbd674 455 const struct attribute_group **groups; /* optional groups */
23681e47 456
d462943a 457 void (*release)(struct device *dev);
1da177e4
LT
458};
459
9a3df1f7
AS
460/* Get the wakeup routines, which depend on struct device */
461#include <linux/pm_wakeup.h>
462
bf9ca69f 463static inline const char *dev_name(const struct device *dev)
06916639 464{
a636ee7f
PM
465 /* Use the init name until the kobject becomes available */
466 if (dev->init_name)
467 return dev->init_name;
468
1fa5ae85 469 return kobject_name(&dev->kobj);
06916639
KS
470}
471
413c239f
SR
472extern int dev_set_name(struct device *dev, const char *name, ...)
473 __attribute__((format(printf, 2, 3)));
474
87348136
CH
475#ifdef CONFIG_NUMA
476static inline int dev_to_node(struct device *dev)
477{
478 return dev->numa_node;
479}
480static inline void set_dev_node(struct device *dev, int node)
481{
482 dev->numa_node = node;
483}
484#else
485static inline int dev_to_node(struct device *dev)
486{
487 return -1;
488}
489static inline void set_dev_node(struct device *dev, int node)
490{
491}
492#endif
493
f67f129e
ML
494static inline unsigned int dev_get_uevent_suppress(const struct device *dev)
495{
496 return dev->kobj.uevent_suppress;
497}
498
499static inline void dev_set_uevent_suppress(struct device *dev, int val)
500{
501 dev->kobj.uevent_suppress = val;
502}
503
d305ef5d
DR
504static inline int device_is_registered(struct device *dev)
505{
3f62e570 506 return dev->kobj.state_in_sysfs;
d305ef5d
DR
507}
508
5af84b82
RW
509static inline void device_enable_async_suspend(struct device *dev)
510{
511 if (dev->power.status == DPM_ON)
512 dev->power.async_suspend = true;
513}
514
5a2eb858
RW
515static inline void device_disable_async_suspend(struct device *dev)
516{
517 if (dev->power.status == DPM_ON)
518 dev->power.async_suspend = false;
519}
520
521static inline bool device_async_suspend_enabled(struct device *dev)
522{
523 return !!dev->power.async_suspend;
524}
525
8e9394ce
GKH
526static inline void device_lock(struct device *dev)
527{
3142788b 528 mutex_lock(&dev->mutex);
8e9394ce
GKH
529}
530
531static inline int device_trylock(struct device *dev)
532{
3142788b 533 return mutex_trylock(&dev->mutex);
8e9394ce
GKH
534}
535
536static inline void device_unlock(struct device *dev)
537{
3142788b 538 mutex_unlock(&dev->mutex);
8e9394ce
GKH
539}
540
1f21782e
AB
541void driver_init(void);
542
1da177e4
LT
543/*
544 * High level routines for use by the bus drivers
545 */
d462943a
GKH
546extern int __must_check device_register(struct device *dev);
547extern void device_unregister(struct device *dev);
548extern void device_initialize(struct device *dev);
549extern int __must_check device_add(struct device *dev);
550extern void device_del(struct device *dev);
551extern int device_for_each_child(struct device *dev, void *data,
552 int (*fn)(struct device *dev, void *data));
553extern struct device *device_find_child(struct device *dev, void *data,
554 int (*match)(struct device *dev, void *data));
6937e8f8 555extern int device_rename(struct device *dev, const char *new_name);
ffa6a705
CH
556extern int device_move(struct device *dev, struct device *new_parent,
557 enum dpm_order dpm_order);
e454cea2
KS
558extern const char *device_get_devnode(struct device *dev,
559 mode_t *mode, const char **tmp);
b4028437
GKH
560extern void *dev_get_drvdata(const struct device *dev);
561extern void dev_set_drvdata(struct device *dev, void *data);
1da177e4 562
0aa0dc41
MM
563/*
564 * Root device objects for grouping under /sys/devices
565 */
566extern struct device *__root_device_register(const char *name,
567 struct module *owner);
568static inline struct device *root_device_register(const char *name)
569{
570 return __root_device_register(name, THIS_MODULE);
571}
572extern void root_device_unregister(struct device *root);
573
a5b8b1ad
MB
574static inline void *dev_get_platdata(const struct device *dev)
575{
576 return dev->platform_data;
577}
578
1da177e4
LT
579/*
580 * Manual binding of a device to driver. See drivers/base/bus.c
581 * for information on use.
582 */
f86db396 583extern int __must_check device_bind_driver(struct device *dev);
d462943a
GKH
584extern void device_release_driver(struct device *dev);
585extern int __must_check device_attach(struct device *dev);
f86db396
AM
586extern int __must_check driver_attach(struct device_driver *drv);
587extern int __must_check device_reprobe(struct device *dev);
1da177e4 588
23681e47
GKH
589/*
590 * Easy functions for dynamically creating devices on the fly
591 */
8882b394
GKH
592extern struct device *device_create_vargs(struct class *cls,
593 struct device *parent,
594 dev_t devt,
595 void *drvdata,
596 const char *fmt,
597 va_list vargs);
4e106739
GKH
598extern struct device *device_create(struct class *cls, struct device *parent,
599 dev_t devt, void *drvdata,
600 const char *fmt, ...)
8882b394 601 __attribute__((format(printf, 5, 6)));
23681e47 602extern void device_destroy(struct class *cls, dev_t devt);
1da177e4 603
1da177e4
LT
604/*
605 * Platform "fixup" functions - allow the platform to have their say
606 * about devices and actions that the general device layer doesn't
607 * know about.
608 */
609/* Notify platform of device discovery */
d462943a 610extern int (*platform_notify)(struct device *dev);
1da177e4 611
d462943a 612extern int (*platform_notify_remove)(struct device *dev);
1da177e4
LT
613
614
615/**
616 * get_device - atomically increment the reference count for the device.
617 *
618 */
d462943a
GKH
619extern struct device *get_device(struct device *dev);
620extern void put_device(struct device *dev);
1da177e4 621
d4d5291c 622extern void wait_for_device_probe(void);
1da177e4 623
2b2af54a
KS
624#ifdef CONFIG_DEVTMPFS
625extern int devtmpfs_create_node(struct device *dev);
626extern int devtmpfs_delete_node(struct device *dev);
073120cc 627extern int devtmpfs_mount(const char *mntdir);
2b2af54a
KS
628#else
629static inline int devtmpfs_create_node(struct device *dev) { return 0; }
630static inline int devtmpfs_delete_node(struct device *dev) { return 0; }
631static inline int devtmpfs_mount(const char *mountpoint) { return 0; }
632#endif
633
116f232b 634/* drivers/base/power/shutdown.c */
1da177e4
LT
635extern void device_shutdown(void);
636
58b3b71d
RW
637/* drivers/base/sys.c */
638extern void sysdev_shutdown(void);
639
1da177e4 640/* debugging and troubleshooting/diagnostic helpers. */
bf9ca69f 641extern const char *dev_driver_string(const struct device *dev);
99bcf217
JP
642
643
644#ifdef CONFIG_PRINTK
645
646extern int dev_printk(const char *level, const struct device *dev,
647 const char *fmt, ...)
648 __attribute__ ((format (printf, 3, 4)));
649extern int dev_emerg(const struct device *dev, const char *fmt, ...)
650 __attribute__ ((format (printf, 2, 3)));
651extern int dev_alert(const struct device *dev, const char *fmt, ...)
652 __attribute__ ((format (printf, 2, 3)));
653extern int dev_crit(const struct device *dev, const char *fmt, ...)
654 __attribute__ ((format (printf, 2, 3)));
655extern int dev_err(const struct device *dev, const char *fmt, ...)
656 __attribute__ ((format (printf, 2, 3)));
657extern int dev_warn(const struct device *dev, const char *fmt, ...)
658 __attribute__ ((format (printf, 2, 3)));
659extern int dev_notice(const struct device *dev, const char *fmt, ...)
660 __attribute__ ((format (printf, 2, 3)));
661extern int _dev_info(const struct device *dev, const char *fmt, ...)
662 __attribute__ ((format (printf, 2, 3)));
663
664#else
665
666static inline int dev_printk(const char *level, const struct device *dev,
667 const char *fmt, ...)
668 __attribute__ ((format (printf, 3, 4)));
669static inline int dev_printk(const char *level, const struct device *dev,
670 const char *fmt, ...)
671 { return 0; }
672
673static inline int dev_emerg(const struct device *dev, const char *fmt, ...)
674 __attribute__ ((format (printf, 2, 3)));
675static inline int dev_emerg(const struct device *dev, const char *fmt, ...)
676 { return 0; }
677static inline int dev_crit(const struct device *dev, const char *fmt, ...)
678 __attribute__ ((format (printf, 2, 3)));
679static inline int dev_crit(const struct device *dev, const char *fmt, ...)
680 { return 0; }
681static inline int dev_alert(const struct device *dev, const char *fmt, ...)
682 __attribute__ ((format (printf, 2, 3)));
683static inline int dev_alert(const struct device *dev, const char *fmt, ...)
684 { return 0; }
685static inline int dev_err(const struct device *dev, const char *fmt, ...)
686 __attribute__ ((format (printf, 2, 3)));
687static inline int dev_err(const struct device *dev, const char *fmt, ...)
688 { return 0; }
689static inline int dev_warn(const struct device *dev, const char *fmt, ...)
690 __attribute__ ((format (printf, 2, 3)));
691static inline int dev_warn(const struct device *dev, const char *fmt, ...)
692 { return 0; }
693static inline int dev_notice(const struct device *dev, const char *fmt, ...)
694 __attribute__ ((format (printf, 2, 3)));
695static inline int dev_notice(const struct device *dev, const char *fmt, ...)
696 { return 0; }
697static inline int _dev_info(const struct device *dev, const char *fmt, ...)
698 __attribute__ ((format (printf, 2, 3)));
699static inline int _dev_info(const struct device *dev, const char *fmt, ...)
700 { return 0; }
701
702#endif
703
704/*
705 * Stupid hackaround for existing uses of non-printk uses dev_info
706 *
707 * Note that the definition of dev_info below is actually _dev_info
708 * and a macro is used to avoid redefining dev_info
709 */
710
711#define dev_info(dev, fmt, arg...) _dev_info(dev, fmt, ##arg)
7b8712e5 712
d0d85ff9
CH
713#if defined(DEBUG)
714#define dev_dbg(dev, format, arg...) \
99bcf217 715 dev_printk(KERN_DEBUG, dev, format, ##arg)
e9d376f0 716#elif defined(CONFIG_DYNAMIC_DEBUG)
99bcf217
JP
717#define dev_dbg(dev, format, ...) \
718do { \
346e15be 719 dynamic_dev_dbg(dev, format, ##__VA_ARGS__); \
99bcf217 720} while (0)
1da177e4 721#else
99bcf217
JP
722#define dev_dbg(dev, format, arg...) \
723({ \
724 if (0) \
725 dev_printk(KERN_DEBUG, dev, format, ##arg); \
726 0; \
727})
1da177e4
LT
728#endif
729
aebdc3b4
DB
730#ifdef VERBOSE_DEBUG
731#define dev_vdbg dev_dbg
732#else
99bcf217
JP
733#define dev_vdbg(dev, format, arg...) \
734({ \
735 if (0) \
736 dev_printk(KERN_DEBUG, dev, format, ##arg); \
737 0; \
738})
aebdc3b4
DB
739#endif
740
e6139662
AV
741/*
742 * dev_WARN() acts like dev_printk(), but with the key difference
743 * of using a WARN/WARN_ON to get the message out, including the
744 * file/line information and a backtrace.
745 */
746#define dev_WARN(dev, format, arg...) \
747 WARN(1, "Device: %s\n" format, dev_driver_string(dev), ## arg);
748
1da177e4
LT
749/* Create alias, so I can be autoloaded. */
750#define MODULE_ALIAS_CHARDEV(major,minor) \
751 MODULE_ALIAS("char-major-" __stringify(major) "-" __stringify(minor))
752#define MODULE_ALIAS_CHARDEV_MAJOR(major) \
753 MODULE_ALIAS("char-major-" __stringify(major) "-*")
e52eec13
AK
754
755#ifdef CONFIG_SYSFS_DEPRECATED
756extern long sysfs_deprecated;
757#else
758#define sysfs_deprecated 0
759#endif
760
1da177e4 761#endif /* _DEVICE_H_ */