]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * driver.c - centralized device driver management | |
3 | * | |
4 | * Copyright (c) 2002-3 Patrick Mochel | |
5 | * Copyright (c) 2002-3 Open Source Development Labs | |
6 | * | |
7 | * This file is released under the GPLv2 | |
8 | * | |
9 | */ | |
10 | ||
11 | #include <linux/config.h> | |
12 | #include <linux/device.h> | |
13 | #include <linux/module.h> | |
14 | #include <linux/errno.h> | |
15 | #include <linux/string.h> | |
16 | #include "base.h" | |
17 | ||
18 | #define to_dev(node) container_of(node, struct device, driver_list) | |
19 | #define to_drv(obj) container_of(obj, struct device_driver, kobj) | |
20 | ||
fae3cd00 | 21 | |
94e7b1c5 PM |
22 | static struct device * next_device(struct klist_iter * i) |
23 | { | |
24 | struct klist_node * n = klist_next(i); | |
25 | return n ? container_of(n, struct device, knode_driver) : NULL; | |
26 | } | |
27 | ||
fae3cd00 PM |
28 | /** |
29 | * driver_for_each_device - Iterator for devices bound to a driver. | |
30 | * @drv: Driver we're iterating. | |
31 | * @data: Data to pass to the callback. | |
32 | * @fn: Function to call for each device. | |
33 | * | |
4d12d2d9 | 34 | * Iterate over the @drv's list of devices calling @fn for each one. |
fae3cd00 PM |
35 | */ |
36 | ||
37 | int driver_for_each_device(struct device_driver * drv, struct device * start, | |
38 | void * data, int (*fn)(struct device *, void *)) | |
39 | { | |
94e7b1c5 | 40 | struct klist_iter i; |
fae3cd00 PM |
41 | struct device * dev; |
42 | int error = 0; | |
43 | ||
94e7b1c5 PM |
44 | if (!drv) |
45 | return -EINVAL; | |
46 | ||
47 | klist_iter_init_node(&drv->klist_devices, &i, | |
48 | start ? &start->knode_driver : NULL); | |
49 | while ((dev = next_device(&i)) && !error) | |
fae3cd00 | 50 | error = fn(dev, data); |
94e7b1c5 | 51 | klist_iter_exit(&i); |
fae3cd00 PM |
52 | return error; |
53 | } | |
54 | ||
126eddfb | 55 | EXPORT_SYMBOL_GPL(driver_for_each_device); |
fae3cd00 PM |
56 | |
57 | ||
1da177e4 LT |
58 | /** |
59 | * driver_create_file - create sysfs file for driver. | |
60 | * @drv: driver. | |
61 | * @attr: driver attribute descriptor. | |
62 | */ | |
63 | ||
64 | int driver_create_file(struct device_driver * drv, struct driver_attribute * attr) | |
65 | { | |
66 | int error; | |
67 | if (get_driver(drv)) { | |
68 | error = sysfs_create_file(&drv->kobj, &attr->attr); | |
69 | put_driver(drv); | |
70 | } else | |
71 | error = -EINVAL; | |
72 | return error; | |
73 | } | |
74 | ||
75 | ||
76 | /** | |
77 | * driver_remove_file - remove sysfs file for driver. | |
78 | * @drv: driver. | |
79 | * @attr: driver attribute descriptor. | |
80 | */ | |
81 | ||
82 | void driver_remove_file(struct device_driver * drv, struct driver_attribute * attr) | |
83 | { | |
84 | if (get_driver(drv)) { | |
85 | sysfs_remove_file(&drv->kobj, &attr->attr); | |
86 | put_driver(drv); | |
87 | } | |
88 | } | |
89 | ||
90 | ||
91 | /** | |
92 | * get_driver - increment driver reference count. | |
93 | * @drv: driver. | |
94 | */ | |
95 | struct device_driver * get_driver(struct device_driver * drv) | |
96 | { | |
97 | return drv ? to_drv(kobject_get(&drv->kobj)) : NULL; | |
98 | } | |
99 | ||
100 | ||
101 | /** | |
102 | * put_driver - decrement driver's refcount. | |
103 | * @drv: driver. | |
104 | */ | |
105 | void put_driver(struct device_driver * drv) | |
106 | { | |
107 | kobject_put(&drv->kobj); | |
108 | } | |
109 | ||
110 | ||
111 | /** | |
112 | * driver_register - register driver with bus | |
113 | * @drv: driver to register | |
114 | * | |
115 | * We pass off most of the work to the bus_add_driver() call, | |
116 | * since most of the things we have to do deal with the bus | |
117 | * structures. | |
118 | * | |
119 | * The one interesting aspect is that we setup @drv->unloaded | |
120 | * as a completion that gets complete when the driver reference | |
121 | * count reaches 0. | |
122 | */ | |
123 | int driver_register(struct device_driver * drv) | |
124 | { | |
94e7b1c5 | 125 | klist_init(&drv->klist_devices); |
1da177e4 LT |
126 | init_completion(&drv->unloaded); |
127 | return bus_add_driver(drv); | |
128 | } | |
129 | ||
130 | ||
131 | /** | |
132 | * driver_unregister - remove driver from system. | |
133 | * @drv: driver. | |
134 | * | |
135 | * Again, we pass off most of the work to the bus-level call. | |
136 | * | |
137 | * Though, once that is done, we wait until @drv->unloaded is completed. | |
138 | * This will block until the driver refcount reaches 0, and it is | |
139 | * released. Only modular drivers will call this function, and we | |
140 | * have to guarantee that it won't complete, letting the driver | |
141 | * unload until all references are gone. | |
142 | */ | |
143 | ||
144 | void driver_unregister(struct device_driver * drv) | |
145 | { | |
146 | bus_remove_driver(drv); | |
147 | wait_for_completion(&drv->unloaded); | |
148 | } | |
149 | ||
150 | /** | |
151 | * driver_find - locate driver on a bus by its name. | |
152 | * @name: name of the driver. | |
153 | * @bus: bus to scan for the driver. | |
154 | * | |
155 | * Call kset_find_obj() to iterate over list of drivers on | |
156 | * a bus to find driver by name. Return driver if found. | |
157 | * | |
158 | * Note that kset_find_obj increments driver's reference count. | |
159 | */ | |
160 | struct device_driver *driver_find(const char *name, struct bus_type *bus) | |
161 | { | |
162 | struct kobject *k = kset_find_obj(&bus->drivers, name); | |
163 | if (k) | |
164 | return to_drv(k); | |
165 | return NULL; | |
166 | } | |
167 | ||
168 | EXPORT_SYMBOL_GPL(driver_register); | |
169 | EXPORT_SYMBOL_GPL(driver_unregister); | |
170 | EXPORT_SYMBOL_GPL(get_driver); | |
171 | EXPORT_SYMBOL_GPL(put_driver); | |
172 | EXPORT_SYMBOL_GPL(driver_find); | |
173 | ||
174 | EXPORT_SYMBOL_GPL(driver_create_file); | |
175 | EXPORT_SYMBOL_GPL(driver_remove_file); |