Linux Kernel
3.7.1
Main Page
Related Pages
Modules
Namespaces
Data Structures
Files
File List
Globals
All
Data Structures
Namespaces
Files
Functions
Variables
Typedefs
Enumerations
Enumerator
Macros
Groups
Pages
include
linux
device.h
Go to the documentation of this file.
1
/*
2
* device.h - generic, centralized driver model
3
*
4
* Copyright (c) 2001-2003 Patrick Mochel <
[email protected]
>
5
* Copyright (c) 2004-2009 Greg Kroah-Hartman <
[email protected]
>
6
* Copyright (c) 2008-2009 Novell Inc.
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
16
#include <
linux/ioport.h
>
17
#include <
linux/kobject.h
>
18
#include <
linux/klist.h
>
19
#include <linux/list.h>
20
#include <
linux/lockdep.h
>
21
#include <linux/compiler.h>
22
#include <linux/types.h>
23
#include <
linux/mutex.h
>
24
#include <
linux/pm.h
>
25
#include <
linux/atomic.h
>
26
#include <
linux/ratelimit.h
>
27
#include <asm/device.h>
28
29
struct
device
;
30
struct
device_private
;
31
struct
device_driver
;
32
struct
driver_private
;
33
struct
module
;
34
struct
class
;
35
struct
subsys_private
;
36
struct
bus_type
;
37
struct
device_node
;
38
struct
iommu_ops
;
39
struct
iommu_group
;
40
41
struct
bus_attribute
{
42
struct
attribute
attr
;
43
ssize_t
(*
show
)(
struct
bus_type
*
bus
,
char
*
buf
);
44
ssize_t
(*
store
)(
struct
bus_type
*
bus
,
const
char
*
buf
,
size_t
count
);
45
};
46
47
#define BUS_ATTR(_name, _mode, _show, _store) \
48
struct bus_attribute bus_attr_##_name = __ATTR(_name, _mode, _show, _store)
49
50
extern
int
__must_check
bus_create_file
(
struct
bus_type
*,
51
struct
bus_attribute
*);
52
extern
void
bus_remove_file
(
struct
bus_type
*,
struct
bus_attribute
*);
53
91
struct
bus_type
{
92
const
char
*
name
;
93
const
char
*
dev_name
;
94
struct
device
*
dev_root
;
95
struct
bus_attribute
*
bus_attrs
;
96
struct
device_attribute
*
dev_attrs
;
97
struct
driver_attribute
*
drv_attrs
;
98
99
int
(*
match
)(
struct
device
*
dev
,
struct
device_driver
*drv);
100
int
(*
uevent
)(
struct
device
*
dev
,
struct
kobj_uevent_env
*
env
);
101
int
(*
probe
)(
struct
device
*
dev
);
102
int
(*
remove
)(
struct
device
*
dev
);
103
void
(*
shutdown
)(
struct
device
*
dev
);
104
105
int
(*
suspend
)(
struct
device
*
dev
,
pm_message_t
state
);
106
int
(*
resume
)(
struct
device
*
dev
);
107
108
const
struct
dev_pm_ops
*
pm
;
109
110
struct
iommu_ops
*
iommu_ops
;
111
112
struct
subsys_private
*
p
;
113
};
114
115
/* This is a #define to keep the compiler from merging different
116
* instances of the __key variable */
117
#define bus_register(subsys) \
118
({ \
119
static struct lock_class_key __key; \
120
__bus_register(subsys, &__key); \
121
})
122
extern
int
__must_check
__bus_register
(
struct
bus_type
*
bus
,
123
struct
lock_class_key
*
key
);
124
extern
void
bus_unregister
(
struct
bus_type
*
bus
);
125
126
extern
int
__must_check
bus_rescan_devices
(
struct
bus_type
*
bus
);
127
128
/* iterator helpers for buses */
129
struct
subsys_dev_iter
{
130
struct
klist_iter
ki
;
131
const
struct
device_type
*
type
;
132
};
133
void
subsys_dev_iter_init
(
struct
subsys_dev_iter
*iter,
134
struct
bus_type
*subsys,
135
struct
device
*
start
,
136
const
struct
device_type
*
type
);
137
struct
device
*
subsys_dev_iter_next
(
struct
subsys_dev_iter
*iter);
138
void
subsys_dev_iter_exit
(
struct
subsys_dev_iter
*iter);
139
140
int
bus_for_each_dev
(
struct
bus_type
*
bus
,
struct
device
*
start
,
void
*
data
,
141
int
(*
fn
)(
struct
device
*
dev
,
void
*data));
142
struct
device
*
bus_find_device
(
struct
bus_type
*bus,
struct
device
*start,
143
void
*data,
144
int
(*
match
)(
struct
device
*
dev
,
void
*data));
145
struct
device
*
bus_find_device_by_name
(
struct
bus_type
*bus,
146
struct
device
*start,
147
const
char
*
name
);
148
struct
device
*
subsys_find_device_by_id
(
struct
bus_type
*bus,
unsigned
int
id
,
149
struct
device
*hint);
150
int
bus_for_each_drv
(
struct
bus_type
*bus,
struct
device_driver
*start,
151
void
*data,
int
(*
fn
)(
struct
device_driver
*,
void
*));
152
void
bus_sort_breadthfirst
(
struct
bus_type
*bus,
153
int
(*compare)(
const
struct
device
*
a
,
154
const
struct
device
*
b
));
155
/*
156
* Bus notifiers: Get notified of addition/removal of devices
157
* and binding/unbinding of drivers to devices.
158
* In the long run, it should be a replacement for the platform
159
* notify hooks.
160
*/
161
struct
notifier_block
;
162
163
extern
int
bus_register_notifier
(
struct
bus_type
*bus,
164
struct
notifier_block
*nb);
165
extern
int
bus_unregister_notifier
(
struct
bus_type
*bus,
166
struct
notifier_block
*nb);
167
168
/* All 4 notifers below get called with the target struct device *
169
* as an argument. Note that those functions are likely to be called
170
* with the device lock held in the core, so be careful.
171
*/
172
#define BUS_NOTIFY_ADD_DEVICE 0x00000001
/* device added */
173
#define BUS_NOTIFY_DEL_DEVICE 0x00000002
/* device removed */
174
#define BUS_NOTIFY_BIND_DRIVER 0x00000003
/* driver about to be
175
bound */
176
#define BUS_NOTIFY_BOUND_DRIVER 0x00000004
/* driver bound to device */
177
#define BUS_NOTIFY_UNBIND_DRIVER 0x00000005
/* driver about to be
178
unbound */
179
#define BUS_NOTIFY_UNBOUND_DRIVER 0x00000006
/* driver is unbound
180
from the device */
181
182
extern
struct
kset
*
bus_get_kset
(
struct
bus_type
*bus);
183
extern
struct
klist
*
bus_get_device_klist
(
struct
bus_type
*bus);
184
216
struct
device_driver
{
217
const
char
*
name
;
218
struct
bus_type
*
bus
;
219
220
struct
module
*
owner
;
221
const
char
*
mod_name
;
/* used for built-in modules */
222
223
bool
suppress_bind_attrs
;
/* disables bind/unbind via sysfs */
224
225
const
struct
of_device_id
*
of_match_table
;
226
227
int
(*
probe
) (
struct
device
*
dev
);
228
int
(*
remove
) (
struct
device
*
dev
);
229
void
(*
shutdown
) (
struct
device
*
dev
);
230
int
(*
suspend
) (
struct
device
*
dev
,
pm_message_t
state
);
231
int
(*
resume
) (
struct
device
*
dev
);
232
const
struct
attribute_group
**
groups
;
233
234
const
struct
dev_pm_ops
*
pm
;
235
236
struct
driver_private
*
p
;
237
};
238
239
240
extern
int
__must_check
driver_register
(
struct
device_driver
*drv);
241
extern
void
driver_unregister
(
struct
device_driver
*drv);
242
243
extern
struct
device_driver
*
driver_find
(
const
char
*
name
,
244
struct
bus_type
*bus);
245
extern
int
driver_probe_done
(
void
);
246
extern
void
wait_for_device_probe
(
void
);
247
248
249
/* sysfs interface for exporting driver attributes */
250
251
struct
driver_attribute
{
252
struct
attribute
attr;
253
ssize_t
(*
show
)(
struct
device_driver
*
driver
,
char
*
buf
);
254
ssize_t
(*
store
)(
struct
device_driver
*
driver
,
const
char
*
buf
,
255
size_t
count
);
256
};
257
258
#define DRIVER_ATTR(_name, _mode, _show, _store) \
259
struct driver_attribute driver_attr_##_name = \
260
__ATTR(_name, _mode, _show, _store)
261
262
extern
int
__must_check
driver_create_file
(
struct
device_driver
*
driver
,
263
const
struct
driver_attribute
*
attr
);
264
extern
void
driver_remove_file
(
struct
device_driver
*
driver
,
265
const
struct
driver_attribute
*
attr
);
266
267
extern
int
__must_check
driver_for_each_device
(
struct
device_driver
*drv,
268
struct
device
*start,
269
void
*data,
270
int
(*
fn
)(
struct
device
*
dev
,
271
void
*));
272
struct
device
*
driver_find_device
(
struct
device_driver
*drv,
273
struct
device
*start,
void
*data,
274
int
(*
match
)(
struct
device
*
dev
,
void
*data));
275
289
struct
subsys_interface
{
290
const
char
*
name
;
291
struct
bus_type
*
subsys
;
292
struct
list_head
node
;
293
int
(*
add_dev
)(
struct
device
*
dev
,
struct
subsys_interface
*sif);
294
int
(*
remove_dev
)(
struct
device
*
dev
,
struct
subsys_interface
*sif);
295
};
296
297
int
subsys_interface_register
(
struct
subsys_interface
*sif);
298
void
subsys_interface_unregister
(
struct
subsys_interface
*sif);
299
300
int
subsys_system_register
(
struct
bus_type
*
subsys
,
301
const
struct
attribute_group
**groups);
302
332
struct
class
{
333
const
char
*
name
;
334
struct
module
*
owner
;
335
336
struct
class_attribute
*
class_attrs
;
337
struct
device_attribute
*
dev_attrs
;
338
struct
bin_attribute
*
dev_bin_attrs
;
339
struct
kobject
*
dev_kobj
;
340
341
int
(*
dev_uevent
)(
struct
device
*
dev
,
struct
kobj_uevent_env
*
env
);
342
char
*(*devnode)(
struct
device
*
dev
,
umode_t
*
mode
);
343
344
void
(*
class_release
)(
struct
class
*
class
);
345
void
(*
dev_release
)(
struct
device
*
dev
);
346
347
int
(*
suspend
)(
struct
device
*
dev
,
pm_message_t
state
);
348
int
(*
resume
)(
struct
device
*
dev
);
349
350
const
struct
kobj_ns_type_operations
*
ns_type
;
351
const
void
*(*namespace)(
struct
device
*
dev
);
352
353
const
struct
dev_pm_ops
*
pm
;
354
355
struct
subsys_private
*
p
;
356
};
357
358
struct
class_dev_iter
{
359
struct
klist_iter
ki;
360
const
struct
device_type
*
type
;
361
};
362
363
extern
struct
kobject
*
sysfs_dev_block_kobj
;
364
extern
struct
kobject
*
sysfs_dev_char_kobj
;
365
extern
int
__must_check
__class_register
(
struct
class
*
class
,
366
struct
lock_class_key
*
key
);
367
extern
void
class_unregister
(
struct
class
*
class
);
368
369
/* This is a #define to keep the compiler from merging different
370
* instances of the __key variable */
371
#define class_register(class) \
372
({ \
373
static struct lock_class_key __key; \
374
__class_register(class, &__key); \
375
})
376
377
struct
class_compat
;
378
struct
class_compat
*
class_compat_register
(
const
char
*
name
);
379
void
class_compat_unregister
(
struct
class_compat
*cls);
380
int
class_compat_create_link
(
struct
class_compat
*cls,
struct
device
*
dev
,
381
struct
device
*device_link);
382
void
class_compat_remove_link
(
struct
class_compat
*cls,
struct
device
*
dev
,
383
struct
device
*device_link);
384
385
extern
void
class_dev_iter_init
(
struct
class_dev_iter
*iter,
386
struct
class
*
class
,
387
struct
device
*start,
388
const
struct
device_type
*
type
);
389
extern
struct
device
*
class_dev_iter_next
(
struct
class_dev_iter
*iter);
390
extern
void
class_dev_iter_exit
(
struct
class_dev_iter
*iter);
391
392
extern
int
class_for_each_device
(
struct
class
*
class
,
struct
device
*start,
393
void
*data,
394
int
(*
fn
)(
struct
device
*
dev
,
void
*data));
395
extern
struct
device
*
class_find_device
(
struct
class
*
class
,
396
struct
device
*start,
void
*data,
397
int
(*
match
)(
struct
device
*,
void
*));
398
399
struct
class_attribute
{
400
struct
attribute
attr
;
401
ssize_t
(*
show
)(
struct
class
*
class
,
struct
class_attribute
*
attr
,
402
char
*
buf
);
403
ssize_t
(*
store
)(
struct
class
*
class
,
struct
class_attribute
*
attr
,
404
const
char
*
buf
,
size_t
count
);
405
const
void
*(*namespace)(
struct
class
*
class
,
406
const
struct
class_attribute
*
attr
);
407
};
408
409
#define CLASS_ATTR(_name, _mode, _show, _store) \
410
struct class_attribute class_attr_##_name = __ATTR(_name, _mode, _show, _store)
411
412
extern
int
__must_check
class_create_file
(
struct
class
*
class
,
413
const
struct
class_attribute
*
attr
);
414
extern
void
class_remove_file
(
struct
class
*
class
,
415
const
struct
class_attribute
*
attr
);
416
417
/* Simple class attribute that is just a static string */
418
419
struct
class_attribute_string
{
420
struct
class_attribute
attr;
421
char
*
str
;
422
};
423
424
/* Currently read-only only */
425
#define _CLASS_ATTR_STRING(_name, _mode, _str) \
426
{ __ATTR(_name, _mode, show_class_attr_string, NULL), _str }
427
#define CLASS_ATTR_STRING(_name, _mode, _str) \
428
struct class_attribute_string class_attr_##_name = \
429
_CLASS_ATTR_STRING(_name, _mode, _str)
430
431
extern
ssize_t
show_class_attr_string
(
struct
class
*
class
,
struct
class_attribute
*
attr
,
432
char
*
buf
);
433
434
struct
class_interface
{
435
struct
list_head
node
;
436
struct
class
*
class
;
437
438
int
(*
add_dev
) (
struct
device
*,
struct
class_interface
*);
439
void
(*
remove_dev
) (
struct
device
*,
struct
class_interface
*);
440
};
441
442
extern
int
__must_check
class_interface_register
(
struct
class_interface
*);
443
extern
void
class_interface_unregister
(
struct
class_interface
*);
444
445
extern
struct
class
*
__must_check
__class_create
(
struct
module
*
owner
,
446
const
char
*
name
,
447
struct
lock_class_key
*
key
);
448
extern
void
class_destroy
(
struct
class
*cls);
449
450
/* This is a #define to keep the compiler from merging different
451
* instances of the __key variable */
452
#define class_create(owner, name) \
453
({ \
454
static struct lock_class_key __key; \
455
__class_create(owner, name, &__key); \
456
})
457
458
/*
459
* The type of device, "struct device" is embedded in. A class
460
* or bus can contain devices of different types
461
* like "partitions" and "disks", "mouse" and "event".
462
* This identifies the device type and carries type-specific
463
* information, equivalent to the kobj_type of a kobject.
464
* If "name" is specified, the uevent will contain it in
465
* the DEVTYPE variable.
466
*/
467
struct
device_type
{
468
const
char
*
name
;
469
const
struct
attribute_group
**
groups
;
470
int
(*
uevent
)(
struct
device
*
dev
,
struct
kobj_uevent_env
*
env
);
471
char
*(*devnode)(
struct
device
*
dev
,
umode_t
*
mode
);
472
void
(*
release
)(
struct
device
*
dev
);
473
474
const
struct
dev_pm_ops
*
pm
;
475
};
476
477
/* interface for exporting device attributes */
478
struct
device_attribute
{
479
struct
attribute
attr
;
480
ssize_t
(*
show
)(
struct
device
*
dev
,
struct
device_attribute
*
attr
,
481
char
*
buf
);
482
ssize_t
(*
store
)(
struct
device
*
dev
,
struct
device_attribute
*
attr
,
483
const
char
*
buf
,
size_t
count
);
484
};
485
486
struct
dev_ext_attribute
{
487
struct
device_attribute
attr;
488
void
*
var
;
489
};
490
491
ssize_t
device_show_ulong
(
struct
device
*
dev
,
struct
device_attribute
*
attr
,
492
char
*
buf
);
493
ssize_t
device_store_ulong
(
struct
device
*
dev
,
struct
device_attribute
*
attr
,
494
const
char
*
buf
,
size_t
count
);
495
ssize_t
device_show_int
(
struct
device
*
dev
,
struct
device_attribute
*
attr
,
496
char
*
buf
);
497
ssize_t
device_store_int
(
struct
device
*
dev
,
struct
device_attribute
*
attr
,
498
const
char
*
buf
,
size_t
count
);
499
500
#define DEVICE_ATTR(_name, _mode, _show, _store) \
501
struct device_attribute dev_attr_##_name = __ATTR(_name, _mode, _show, _store)
502
#define DEVICE_ULONG_ATTR(_name, _mode, _var) \
503
struct dev_ext_attribute dev_attr_##_name = \
504
{ __ATTR(_name, _mode, device_show_ulong, device_store_ulong), &(_var) }
505
#define DEVICE_INT_ATTR(_name, _mode, _var) \
506
struct dev_ext_attribute dev_attr_##_name = \
507
{ __ATTR(_name, _mode, device_show_int, device_store_int), &(_var) }
508
#define DEVICE_ATTR_IGNORE_LOCKDEP(_name, _mode, _show, _store) \
509
struct device_attribute dev_attr_##_name = \
510
__ATTR_IGNORE_LOCKDEP(_name, _mode, _show, _store)
511
512
extern
int
device_create_file
(
struct
device
*
device
,
513
const
struct
device_attribute
*
entry
);
514
extern
void
device_remove_file
(
struct
device
*
dev
,
515
const
struct
device_attribute
*
attr
);
516
extern
int
__must_check
device_create_bin_file
(
struct
device
*
dev
,
517
const
struct
bin_attribute
*
attr
);
518
extern
void
device_remove_bin_file
(
struct
device
*
dev
,
519
const
struct
bin_attribute
*
attr
);
520
extern
int
device_schedule_callback_owner
(
struct
device
*
dev
,
521
void
(*
func
)(
struct
device
*dev),
struct
module
*
owner
);
522
523
/* This is a macro to avoid include problems with THIS_MODULE */
524
#define device_schedule_callback(dev, func) \
525
device_schedule_callback_owner(dev, func, THIS_MODULE)
526
527
/* device resource management */
528
typedef
void
(*
dr_release_t
)(
struct
device
*
dev
,
void
*
res
);
529
typedef
int
(*
dr_match_t
)(
struct
device
*
dev
,
void
*
res
,
void
*match_data);
530
531
#ifdef CONFIG_DEBUG_DEVRES
532
extern
void
*__devres_alloc(
dr_release_t
release
,
size_t
size
,
gfp_t
gfp,
533
const
char
*
name
);
534
#define devres_alloc(release, size, gfp) \
535
__devres_alloc(release, size, gfp, #release)
536
#else
537
extern
void
*
devres_alloc
(
dr_release_t
release
,
size_t
size
,
gfp_t
gfp);
538
#endif
539
extern
void
devres_for_each_res
(
struct
device
*dev,
dr_release_t
release
,
540
dr_match_t
match
,
void
*match_data,
541
void
(*
fn
)(
struct
device
*,
void
*,
void
*),
542
void
*data);
543
extern
void
devres_free
(
void
*res);
544
extern
void
devres_add
(
struct
device
*dev,
void
*res);
545
extern
void
*
devres_find
(
struct
device
*dev,
dr_release_t
release,
546
dr_match_t
match,
void
*match_data);
547
extern
void
*
devres_get
(
struct
device
*dev,
void
*new_res,
548
dr_match_t
match,
void
*match_data);
549
extern
void
*
devres_remove
(
struct
device
*dev,
dr_release_t
release,
550
dr_match_t
match,
void
*match_data);
551
extern
int
devres_destroy
(
struct
device
*dev,
dr_release_t
release,
552
dr_match_t
match,
void
*match_data);
553
extern
int
devres_release
(
struct
device
*dev,
dr_release_t
release,
554
dr_match_t
match,
void
*match_data);
555
556
/* devres group */
557
extern
void
*
__must_check
devres_open_group
(
struct
device
*dev,
void
*
id
,
558
gfp_t
gfp);
559
extern
void
devres_close_group
(
struct
device
*dev,
void
*
id
);
560
extern
void
devres_remove_group
(
struct
device
*dev,
void
*
id
);
561
extern
int
devres_release_group
(
struct
device
*dev,
void
*
id
);
562
563
/* managed kzalloc/kfree for device drivers, no kmalloc, always use kzalloc */
564
extern
void
*
devm_kzalloc
(
struct
device
*dev,
size_t
size
,
gfp_t
gfp);
565
extern
void
devm_kfree
(
struct
device
*dev,
void
*
p
);
566
567
void
__iomem
*
devm_request_and_ioremap
(
struct
device
*dev,
568
struct
resource
*res);
569
570
struct
device_dma_parameters
{
571
/*
572
* a low level driver may set these to teach IOMMU code about
573
* sg limitations.
574
*/
575
unsigned
int
max_segment_size
;
576
unsigned
long
segment_boundary_mask
;
577
};
578
638
struct
device
{
639
struct
device
*
parent
;
640
641
struct
device_private
*
p
;
642
643
struct
kobject
kobj
;
644
const
char
*
init_name
;
/* initial name of the device */
645
const
struct
device_type
*
type
;
646
647
struct
mutex
mutex
;
/* mutex to synchronize calls to
648
* its driver.
649
*/
650
651
struct
bus_type
*
bus
;
/* type of bus device is on */
652
struct
device_driver
*
driver
;
/* which driver has allocated this
653
device */
654
void
*
platform_data
;
/* Platform specific data, device
655
core doesn't touch it */
656
struct
dev_pm_info
power
;
657
struct
dev_pm_domain
*
pm_domain
;
658
659
#ifdef CONFIG_NUMA
660
int
numa_node;
/* NUMA node this device is close to */
661
#endif
662
u64
*
dma_mask
;
/* dma mask (if dma'able device) */
663
u64
coherent_dma_mask
;
/* Like dma_mask, but for
664
alloc_coherent mappings as
665
not all hardware supports
666
64 bit addresses for consistent
667
allocations such descriptors. */
668
669
struct
device_dma_parameters
*
dma_parms
;
670
671
struct
list_head
dma_pools
;
/* dma pools (if dma'ble) */
672
673
struct
dma_coherent_mem
*
dma_mem
;
/* internal for coherent mem
674
override */
675
#ifdef CONFIG_CMA
676
struct
cma
*cma_area;
/* contiguous memory area for dma
677
allocations */
678
#endif
679
/* arch specific additions */
680
struct
dev_archdata
archdata
;
681
682
struct
device_node
*
of_node
;
/* associated device tree node */
683
684
dev_t
devt
;
/* dev_t, creates the sysfs "dev" */
685
u32
id
;
/* device instance */
686
687
spinlock_t
devres_lock
;
688
struct
list_head
devres_head
;
689
690
struct
klist_node
knode_class
;
691
struct
class
*
class
;
692
const
struct
attribute_group
**
groups
;
/* optional groups */
693
694
void
(*release)(
struct
device
*
dev
);
695
struct
iommu_group
*
iommu_group
;
696
};
697
698
static
inline
struct
device
*kobj_to_dev(
struct
kobject
*
kobj
)
699
{
700
return
container_of
(kobj,
struct
device
, kobj);
701
}
702
703
/* Get the wakeup routines, which depend on struct device */
704
#include <
linux/pm_wakeup.h
>
705
706
static
inline
const
char
*dev_name(
const
struct
device
*dev)
707
{
708
/* Use the init name until the kobject becomes available */
709
if
(dev->
init_name
)
710
return
dev->
init_name
;
711
712
return
kobject_name(&dev->
kobj
);
713
}
714
715
extern
__printf
(2, 3)
716
int
dev_set_name
(
struct
device
*dev,
const
char
*
name
, ...);
717
718
#ifdef CONFIG_NUMA
719
static
inline
int
dev_to_node(
struct
device
*dev)
720
{
721
return
dev->numa_node;
722
}
723
static
inline
void
set_dev_node(
struct
device
*dev,
int
node
)
724
{
725
dev->numa_node =
node
;
726
}
727
#else
728
static
inline
int
dev_to_node(
struct
device
*dev)
729
{
730
return
-1;
731
}
732
static
inline
void
set_dev_node(
struct
device
*dev,
int
node
)
733
{
734
}
735
#endif
736
737
static
inline
struct
pm_subsys_data
*dev_to_psd(
struct
device
*dev)
738
{
739
return
dev ? dev->
power
.subsys_data :
NULL
;
740
}
741
742
static
inline
unsigned
int
dev_get_uevent_suppress(
const
struct
device
*dev)
743
{
744
return
dev->
kobj
.uevent_suppress;
745
}
746
747
static
inline
void
dev_set_uevent_suppress(
struct
device
*dev,
int
val
)
748
{
749
dev->
kobj
.uevent_suppress =
val
;
750
}
751
752
static
inline
int
device_is_registered(
struct
device
*dev)
753
{
754
return
dev->
kobj
.state_in_sysfs;
755
}
756
757
static
inline
void
device_enable_async_suspend(
struct
device
*dev)
758
{
759
if
(!dev->
power
.is_prepared)
760
dev->
power
.async_suspend =
true
;
761
}
762
763
static
inline
void
device_disable_async_suspend(
struct
device
*dev)
764
{
765
if
(!dev->
power
.is_prepared)
766
dev->
power
.async_suspend =
false
;
767
}
768
769
static
inline
bool
device_async_suspend_enabled(
struct
device
*dev)
770
{
771
return
!!dev->
power
.async_suspend;
772
}
773
774
static
inline
void
pm_suspend_ignore_children(
struct
device
*dev,
bool
enable
)
775
{
776
dev->
power
.ignore_children =
enable
;
777
}
778
779
static
inline
void
dev_pm_syscore_device(
struct
device
*dev,
bool
val
)
780
{
781
#ifdef CONFIG_PM_SLEEP
782
dev->
power
.syscore =
val
;
783
#endif
784
}
785
786
static
inline
void
device_lock(
struct
device
*dev)
787
{
788
mutex_lock
(&dev->
mutex
);
789
}
790
791
static
inline
int
device_trylock(
struct
device
*dev)
792
{
793
return
mutex_trylock
(&dev->
mutex
);
794
}
795
796
static
inline
void
device_unlock(
struct
device
*dev)
797
{
798
mutex_unlock
(&dev->
mutex
);
799
}
800
801
void
driver_init
(
void
);
802
803
/*
804
* High level routines for use by the bus drivers
805
*/
806
extern
int
__must_check
device_register
(
struct
device
*dev);
807
extern
void
device_unregister
(
struct
device
*dev);
808
extern
void
device_initialize
(
struct
device
*dev);
809
extern
int
__must_check
device_add
(
struct
device
*dev);
810
extern
void
device_del
(
struct
device
*dev);
811
extern
int
device_for_each_child
(
struct
device
*dev,
void
*data,
812
int
(*
fn
)(
struct
device
*dev,
void
*data));
813
extern
struct
device
*
device_find_child
(
struct
device
*dev,
void
*data,
814
int
(*match)(
struct
device
*dev,
void
*data));
815
extern
int
device_rename
(
struct
device
*dev,
const
char
*new_name);
816
extern
int
device_move
(
struct
device
*dev,
struct
device
*new_parent,
817
enum
dpm_order
dpm_order
);
818
extern
const
char
*
device_get_devnode
(
struct
device
*dev,
819
umode_t
*
mode
,
const
char
**
tmp
);
820
extern
void
*
dev_get_drvdata
(
const
struct
device
*dev);
821
extern
int
dev_set_drvdata
(
struct
device
*dev,
void
*data);
822
823
/*
824
* Root device objects for grouping under /sys/devices
825
*/
826
extern
struct
device
*
__root_device_register
(
const
char
*name,
827
struct
module
*
owner
);
828
829
/*
830
* This is a macro to avoid include problems with THIS_MODULE,
831
* just as per what is done for device_schedule_callback() above.
832
*/
833
#define root_device_register(name) \
834
__root_device_register(name, THIS_MODULE)
835
836
extern
void
root_device_unregister
(
struct
device
*root);
837
838
static
inline
void
*dev_get_platdata(
const
struct
device
*dev)
839
{
840
return
dev->
platform_data
;
841
}
842
843
/*
844
* Manual binding of a device to driver. See drivers/base/bus.c
845
* for information on use.
846
*/
847
extern
int
__must_check
device_bind_driver
(
struct
device
*dev);
848
extern
void
device_release_driver
(
struct
device
*dev);
849
extern
int
__must_check
device_attach
(
struct
device
*dev);
850
extern
int
__must_check
driver_attach
(
struct
device_driver
*drv);
851
extern
int
__must_check
device_reprobe
(
struct
device
*dev);
852
853
/*
854
* Easy functions for dynamically creating devices on the fly
855
*/
856
extern
struct
device
*
device_create_vargs
(
struct
class
*cls,
857
struct
device
*
parent
,
858
dev_t
devt
,
859
void
*
drvdata
,
860
const
char
*
fmt
,
861
va_list
vargs);
862
extern
__printf
(5, 6)
863
struct
device
*
device_create
(
struct
class
*cls,
struct
device
*
parent
,
864
dev_t
devt
,
void
*
drvdata
,
865
const
char
*
fmt
, ...);
866
extern
void
device_destroy
(
struct
class
*cls,
dev_t
devt);
867
868
/*
869
* Platform "fixup" functions - allow the platform to have their say
870
* about devices and actions that the general device layer doesn't
871
* know about.
872
*/
873
/* Notify platform of device discovery */
874
extern
int
(*
platform_notify
)(
struct
device
*dev);
875
876
extern
int
(*
platform_notify_remove
)(
struct
device
*dev);
877
878
879
/*
880
* get_device - atomically increment the reference count for the device.
881
*
882
*/
883
extern
struct
device
*
get_device
(
struct
device
*dev);
884
extern
void
put_device
(
struct
device
*dev);
885
886
#ifdef CONFIG_DEVTMPFS
887
extern
int
devtmpfs_create_node
(
struct
device
*dev);
888
extern
int
devtmpfs_delete_node
(
struct
device
*dev);
889
extern
int
devtmpfs_mount
(
const
char
*mntdir);
890
#else
891
static
inline
int
devtmpfs_create_node
(
struct
device
*dev) {
return
0; }
892
static
inline
int
devtmpfs_delete_node
(
struct
device
*dev) {
return
0; }
893
static
inline
int
devtmpfs_mount
(
const
char
*mountpoint) {
return
0; }
894
#endif
895
896
/* drivers/base/power/shutdown.c */
897
extern
void
device_shutdown
(
void
);
898
899
/* debugging and troubleshooting/diagnostic helpers. */
900
extern
const
char
*
dev_driver_string
(
const
struct
device
*dev);
901
902
903
#ifdef CONFIG_PRINTK
904
905
extern
__printf
(3, 0)
906
int
dev_vprintk_emit(
int
level
,
const
struct
device
*dev,
907
const
char
*fmt,
va_list
args);
908
extern
__printf
(3, 4)
909
int
dev_printk_emit(
int
level,
const
struct
device
*dev,
const
char
*fmt, ...);
910
911
extern __printf(3, 4)
912
int
dev_printk(
const
char
*level,
const
struct
device
*dev,
913
const
char
*fmt, ...);
914
extern __printf(2, 3)
915
int
dev_emerg(
const
struct
device
*dev,
const
char
*fmt, ...);
916
extern __printf(2, 3)
917
int
dev_alert(
const
struct
device
*dev,
const
char
*fmt, ...);
918
extern __printf(2, 3)
919
int
dev_crit(
const
struct
device
*dev,
const
char
*fmt, ...);
920
extern __printf(2, 3)
921
int
dev_err
(
const
struct
device
*dev,
const
char
*fmt, ...);
922
extern __printf(2, 3)
923
int
dev_warn
(
const
struct
device
*dev,
const
char
*fmt, ...);
924
extern __printf(2, 3)
925
int
dev_notice(
const
struct
device
*dev,
const
char
*fmt, ...);
926
extern __printf(2, 3)
927
int
_dev_info(
const
struct
device
*dev,
const
char
*fmt, ...);
928
929
#else
930
931
static
inline
__printf
(3, 0)
932
int
dev_vprintk_emit(
int
level,
const
struct
device
*dev,
933
const
char
*fmt,
va_list
args)
934
{
return
0; }
935
static
inline
__printf
(3, 4)
936
int
dev_printk_emit(
int
level,
const
struct
device
*dev,
const
char
*fmt, ...)
937
{
return
0; }
938
939
static
inline
int
__dev_printk(
const
char
*level,
const
struct
device
*dev,
940
struct
va_format
*vaf)
941
{
return
0; }
942
static
inline
__printf
(3, 4)
943
int
dev_printk(
const
char
*level,
const
struct
device
*dev,
944
const
char
*fmt, ...)
945
{
return
0; }
946
947
static
inline
__printf
(2, 3)
948
int
dev_emerg(
const
struct
device
*dev,
const
char
*fmt, ...)
949
{
return
0; }
950
static
inline
__printf
(2, 3)
951
int
dev_crit(
const
struct
device
*dev,
const
char
*fmt, ...)
952
{
return
0; }
953
static
inline
__printf
(2, 3)
954
int
dev_alert(
const
struct
device
*dev,
const
char
*fmt, ...)
955
{
return
0; }
956
static
inline
__printf
(2, 3)
957
int
dev_err
(
const
struct
device
*dev,
const
char
*fmt, ...)
958
{
return
0; }
959
static
inline
__printf
(2, 3)
960
int
dev_warn
(
const
struct
device
*dev,
const
char
*fmt, ...)
961
{
return
0; }
962
static
inline
__printf
(2, 3)
963
int
dev_notice(
const
struct
device
*dev,
const
char
*fmt, ...)
964
{
return
0; }
965
static
inline
__printf
(2, 3)
966
int
_dev_info(
const
struct
device
*dev,
const
char
*fmt, ...)
967
{
return
0; }
968
969
#endif
970
971
/*
972
* Stupid hackaround for existing uses of non-printk uses dev_info
973
*
974
* Note that the definition of dev_info below is actually _dev_info
975
* and a macro is used to avoid redefining dev_info
976
*/
977
978
#define dev_info(dev, fmt, arg...) _dev_info(dev, fmt, ##arg)
979
980
#if defined(CONFIG_DYNAMIC_DEBUG)
981
#define dev_dbg(dev, format, ...) \
982
do { \
983
dynamic_dev_dbg(dev, format, ##__VA_ARGS__); \
984
} while (0)
985
#elif defined(DEBUG)
986
#define dev_dbg(dev, format, arg...) \
987
dev_printk(KERN_DEBUG, dev, format, ##arg)
988
#else
989
#define dev_dbg(dev, format, arg...) \
990
({ \
991
if (0) \
992
dev_printk(KERN_DEBUG, dev, format, ##arg); \
993
0; \
994
})
995
#endif
996
997
#define dev_level_ratelimited(dev_level, dev, fmt, ...) \
998
do { \
999
static DEFINE_RATELIMIT_STATE(_rs, \
1000
DEFAULT_RATELIMIT_INTERVAL, \
1001
DEFAULT_RATELIMIT_BURST); \
1002
if (__ratelimit(&_rs)) \
1003
dev_level(dev, fmt, ##__VA_ARGS__); \
1004
} while (0)
1005
1006
#define dev_emerg_ratelimited(dev, fmt, ...) \
1007
dev_level_ratelimited(dev_emerg, dev, fmt, ##__VA_ARGS__)
1008
#define dev_alert_ratelimited(dev, fmt, ...) \
1009
dev_level_ratelimited(dev_alert, dev, fmt, ##__VA_ARGS__)
1010
#define dev_crit_ratelimited(dev, fmt, ...) \
1011
dev_level_ratelimited(dev_crit, dev, fmt, ##__VA_ARGS__)
1012
#define dev_err_ratelimited(dev, fmt, ...) \
1013
dev_level_ratelimited(dev_err, dev, fmt, ##__VA_ARGS__)
1014
#define dev_warn_ratelimited(dev, fmt, ...) \
1015
dev_level_ratelimited(dev_warn, dev, fmt, ##__VA_ARGS__)
1016
#define dev_notice_ratelimited(dev, fmt, ...) \
1017
dev_level_ratelimited(dev_notice, dev, fmt, ##__VA_ARGS__)
1018
#define dev_info_ratelimited(dev, fmt, ...) \
1019
dev_level_ratelimited(dev_info, dev, fmt, ##__VA_ARGS__)
1020
#if defined(CONFIG_DYNAMIC_DEBUG) || defined(DEBUG)
1021
#define dev_dbg_ratelimited(dev, fmt, ...) \
1022
do { \
1023
static DEFINE_RATELIMIT_STATE(_rs, \
1024
DEFAULT_RATELIMIT_INTERVAL, \
1025
DEFAULT_RATELIMIT_BURST); \
1026
DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, fmt); \
1027
if (unlikely(descriptor.flags & _DPRINTK_FLAGS_PRINT) && \
1028
__ratelimit(&_rs)) \
1029
__dynamic_pr_debug(&descriptor, pr_fmt(fmt), \
1030
##__VA_ARGS__); \
1031
} while (0)
1032
#else
1033
#define dev_dbg_ratelimited(dev, fmt, ...) \
1034
no_printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
1035
#endif
1036
1037
#ifdef VERBOSE_DEBUG
1038
#define dev_vdbg dev_dbg
1039
#else
1040
#define dev_vdbg(dev, format, arg...) \
1041
({ \
1042
if (0) \
1043
dev_printk(KERN_DEBUG, dev, format, ##arg); \
1044
0; \
1045
})
1046
#endif
1047
1048
/*
1049
* dev_WARN*() acts like dev_printk(), but with the key difference
1050
* of using a WARN/WARN_ON to get the message out, including the
1051
* file/line information and a backtrace.
1052
*/
1053
#define dev_WARN(dev, format, arg...) \
1054
WARN(1, "Device: %s\n" format, dev_driver_string(dev), ## arg);
1055
1056
#define dev_WARN_ONCE(dev, condition, format, arg...) \
1057
WARN_ONCE(condition, "Device %s\n" format, \
1058
dev_driver_string(dev), ## arg)
1059
1060
/* Create alias, so I can be autoloaded. */
1061
#define MODULE_ALIAS_CHARDEV(major,minor) \
1062
MODULE_ALIAS("char-major-" __stringify(major) "-" __stringify(minor))
1063
#define MODULE_ALIAS_CHARDEV_MAJOR(major) \
1064
MODULE_ALIAS("char-major-" __stringify(major) "-*")
1065
1066
#ifdef CONFIG_SYSFS_DEPRECATED
1067
extern
long
sysfs_deprecated
;
1068
#else
1069
#define sysfs_deprecated 0
1070
#endif
1071
1086
#define module_driver(__driver, __register, __unregister, ...) \
1087
static int __init __driver##_init(void) \
1088
{ \
1089
return __register(&(__driver) , ##__VA_ARGS__); \
1090
} \
1091
module_init(__driver##_init); \
1092
static void __exit __driver##_exit(void) \
1093
{ \
1094
__unregister(&(__driver) , ##__VA_ARGS__); \
1095
} \
1096
module_exit(__driver##_exit);
1097
1098
#endif
/* _DEVICE_H_ */
Generated on Thu Jan 10 2013 12:49:24 for Linux Kernel by
1.8.2