1
2
3
4
5
6
7
8#define pr_fmt(fmt) "%s:%s: " fmt, KBUILD_MODNAME, __func__
9
10#include <linux/device.h>
11#include <linux/init.h>
12#include <linux/slab.h>
13#include <linux/module.h>
14#include <linux/pm_domain.h>
15#include <linux/pm_runtime.h>
16#include <linux/string.h>
17#include <linux/auxiliary_bus.h>
18#include "base.h"
19
20static const struct auxiliary_device_id *auxiliary_match_id(const struct auxiliary_device_id *id,
21 const struct auxiliary_device *auxdev)
22{
23 for (; id->name[0]; id++) {
24 const char *p = strrchr(dev_name(&auxdev->dev), '.');
25 int match_size;
26
27 if (!p)
28 continue;
29 match_size = p - dev_name(&auxdev->dev);
30
31
32 if (strlen(id->name) == match_size &&
33 !strncmp(dev_name(&auxdev->dev), id->name, match_size))
34 return id;
35 }
36 return NULL;
37}
38
39static int auxiliary_match(struct device *dev, struct device_driver *drv)
40{
41 struct auxiliary_device *auxdev = to_auxiliary_dev(dev);
42 struct auxiliary_driver *auxdrv = to_auxiliary_drv(drv);
43
44 return !!auxiliary_match_id(auxdrv->id_table, auxdev);
45}
46
47static int auxiliary_uevent(struct device *dev, struct kobj_uevent_env *env)
48{
49 const char *name, *p;
50
51 name = dev_name(dev);
52 p = strrchr(name, '.');
53
54 return add_uevent_var(env, "MODALIAS=%s%.*s", AUXILIARY_MODULE_PREFIX,
55 (int)(p - name), name);
56}
57
58static const struct dev_pm_ops auxiliary_dev_pm_ops = {
59 SET_RUNTIME_PM_OPS(pm_generic_runtime_suspend, pm_generic_runtime_resume, NULL)
60 SET_SYSTEM_SLEEP_PM_OPS(pm_generic_suspend, pm_generic_resume)
61};
62
63static int auxiliary_bus_probe(struct device *dev)
64{
65 struct auxiliary_driver *auxdrv = to_auxiliary_drv(dev->driver);
66 struct auxiliary_device *auxdev = to_auxiliary_dev(dev);
67 int ret;
68
69 ret = dev_pm_domain_attach(dev, true);
70 if (ret) {
71 dev_warn(dev, "Failed to attach to PM Domain : %d\n", ret);
72 return ret;
73 }
74
75 ret = auxdrv->probe(auxdev, auxiliary_match_id(auxdrv->id_table, auxdev));
76 if (ret)
77 dev_pm_domain_detach(dev, true);
78
79 return ret;
80}
81
82static void auxiliary_bus_remove(struct device *dev)
83{
84 struct auxiliary_driver *auxdrv = to_auxiliary_drv(dev->driver);
85 struct auxiliary_device *auxdev = to_auxiliary_dev(dev);
86
87 if (auxdrv->remove)
88 auxdrv->remove(auxdev);
89 dev_pm_domain_detach(dev, true);
90}
91
92static void auxiliary_bus_shutdown(struct device *dev)
93{
94 struct auxiliary_driver *auxdrv = NULL;
95 struct auxiliary_device *auxdev;
96
97 if (dev->driver) {
98 auxdrv = to_auxiliary_drv(dev->driver);
99 auxdev = to_auxiliary_dev(dev);
100 }
101
102 if (auxdrv && auxdrv->shutdown)
103 auxdrv->shutdown(auxdev);
104}
105
106static struct bus_type auxiliary_bus_type = {
107 .name = "auxiliary",
108 .probe = auxiliary_bus_probe,
109 .remove = auxiliary_bus_remove,
110 .shutdown = auxiliary_bus_shutdown,
111 .match = auxiliary_match,
112 .uevent = auxiliary_uevent,
113 .pm = &auxiliary_dev_pm_ops,
114};
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133int auxiliary_device_init(struct auxiliary_device *auxdev)
134{
135 struct device *dev = &auxdev->dev;
136
137 if (!dev->parent) {
138 pr_err("auxiliary_device has a NULL dev->parent\n");
139 return -EINVAL;
140 }
141
142 if (!auxdev->name) {
143 pr_err("auxiliary_device has a NULL name\n");
144 return -EINVAL;
145 }
146
147 dev->bus = &auxiliary_bus_type;
148 device_initialize(&auxdev->dev);
149 return 0;
150}
151EXPORT_SYMBOL_GPL(auxiliary_device_init);
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172int __auxiliary_device_add(struct auxiliary_device *auxdev, const char *modname)
173{
174 struct device *dev = &auxdev->dev;
175 int ret;
176
177 if (!modname) {
178 dev_err(dev, "auxiliary device modname is NULL\n");
179 return -EINVAL;
180 }
181
182 ret = dev_set_name(dev, "%s.%s.%d", modname, auxdev->name, auxdev->id);
183 if (ret) {
184 dev_err(dev, "auxiliary device dev_set_name failed: %d\n", ret);
185 return ret;
186 }
187
188 ret = device_add(dev);
189 if (ret)
190 dev_err(dev, "adding auxiliary device failed!: %d\n", ret);
191
192 return ret;
193}
194EXPORT_SYMBOL_GPL(__auxiliary_device_add);
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209struct auxiliary_device *auxiliary_find_device(struct device *start,
210 const void *data,
211 int (*match)(struct device *dev, const void *data))
212{
213 struct device *dev;
214
215 dev = bus_find_device(&auxiliary_bus_type, start, data, match);
216 if (!dev)
217 return NULL;
218
219 return to_auxiliary_dev(dev);
220}
221EXPORT_SYMBOL_GPL(auxiliary_find_device);
222
223
224
225
226
227
228
229int __auxiliary_driver_register(struct auxiliary_driver *auxdrv,
230 struct module *owner, const char *modname)
231{
232 int ret;
233
234 if (WARN_ON(!auxdrv->probe) || WARN_ON(!auxdrv->id_table))
235 return -EINVAL;
236
237 if (auxdrv->name)
238 auxdrv->driver.name = kasprintf(GFP_KERNEL, "%s.%s", modname,
239 auxdrv->name);
240 else
241 auxdrv->driver.name = kasprintf(GFP_KERNEL, "%s", modname);
242 if (!auxdrv->driver.name)
243 return -ENOMEM;
244
245 auxdrv->driver.owner = owner;
246 auxdrv->driver.bus = &auxiliary_bus_type;
247 auxdrv->driver.mod_name = modname;
248
249 ret = driver_register(&auxdrv->driver);
250 if (ret)
251 kfree(auxdrv->driver.name);
252
253 return ret;
254}
255EXPORT_SYMBOL_GPL(__auxiliary_driver_register);
256
257
258
259
260
261void auxiliary_driver_unregister(struct auxiliary_driver *auxdrv)
262{
263 driver_unregister(&auxdrv->driver);
264 kfree(auxdrv->driver.name);
265}
266EXPORT_SYMBOL_GPL(auxiliary_driver_unregister);
267
268void __init auxiliary_bus_init(void)
269{
270 WARN_ON(bus_register(&auxiliary_bus_type));
271}
272