1
2
3
4
5
6
7
8
9
10#include <linux/kernel.h>
11#include <linux/device.h>
12#include <linux/list.h>
13#include <linux/pm.h>
14#include <linux/rmi.h>
15#include <linux/slab.h>
16#include <linux/types.h>
17#include <linux/of.h>
18#include "rmi_bus.h"
19#include "rmi_driver.h"
20
21static int debug_flags;
22module_param(debug_flags, int, 0644);
23MODULE_PARM_DESC(debug_flags, "control debugging information");
24
25void rmi_dbg(int flags, struct device *dev, const char *fmt, ...)
26{
27 struct va_format vaf;
28 va_list args;
29
30 if (flags & debug_flags) {
31 va_start(args, fmt);
32
33 vaf.fmt = fmt;
34 vaf.va = &args;
35
36 dev_printk(KERN_DEBUG, dev, "%pV", &vaf);
37
38 va_end(args);
39 }
40}
41EXPORT_SYMBOL_GPL(rmi_dbg);
42
43
44
45
46
47
48
49
50
51static void rmi_release_device(struct device *dev)
52{
53 struct rmi_device *rmi_dev = to_rmi_device(dev);
54
55 kfree(rmi_dev);
56}
57
58static const struct device_type rmi_device_type = {
59 .name = "rmi4_sensor",
60 .release = rmi_release_device,
61};
62
63bool rmi_is_physical_device(struct device *dev)
64{
65 return dev->type == &rmi_device_type;
66}
67
68
69
70
71
72
73
74
75int rmi_register_transport_device(struct rmi_transport_dev *xport)
76{
77 static atomic_t transport_device_count = ATOMIC_INIT(0);
78 struct rmi_device *rmi_dev;
79 int error;
80
81 rmi_dev = kzalloc(sizeof(struct rmi_device), GFP_KERNEL);
82 if (!rmi_dev)
83 return -ENOMEM;
84
85 device_initialize(&rmi_dev->dev);
86
87 rmi_dev->xport = xport;
88 rmi_dev->number = atomic_inc_return(&transport_device_count) - 1;
89
90 dev_set_name(&rmi_dev->dev, "rmi4-%02d", rmi_dev->number);
91
92 rmi_dev->dev.bus = &rmi_bus_type;
93 rmi_dev->dev.type = &rmi_device_type;
94
95 xport->rmi_dev = rmi_dev;
96
97 error = device_add(&rmi_dev->dev);
98 if (error)
99 goto err_put_device;
100
101 rmi_dbg(RMI_DEBUG_CORE, xport->dev,
102 "%s: Registered %s as %s.\n", __func__,
103 dev_name(rmi_dev->xport->dev), dev_name(&rmi_dev->dev));
104
105 return 0;
106
107err_put_device:
108 put_device(&rmi_dev->dev);
109 return error;
110}
111EXPORT_SYMBOL_GPL(rmi_register_transport_device);
112
113
114
115
116
117
118void rmi_unregister_transport_device(struct rmi_transport_dev *xport)
119{
120 struct rmi_device *rmi_dev = xport->rmi_dev;
121
122 device_del(&rmi_dev->dev);
123 put_device(&rmi_dev->dev);
124}
125EXPORT_SYMBOL(rmi_unregister_transport_device);
126
127
128
129
130static void rmi_release_function(struct device *dev)
131{
132 struct rmi_function *fn = to_rmi_function(dev);
133
134 kfree(fn);
135}
136
137static const struct device_type rmi_function_type = {
138 .name = "rmi4_function",
139 .release = rmi_release_function,
140};
141
142bool rmi_is_function_device(struct device *dev)
143{
144 return dev->type == &rmi_function_type;
145}
146
147static int rmi_function_match(struct device *dev, struct device_driver *drv)
148{
149 struct rmi_function_handler *handler = to_rmi_function_handler(drv);
150 struct rmi_function *fn = to_rmi_function(dev);
151
152 return fn->fd.function_number == handler->func;
153}
154
155#ifdef CONFIG_OF
156static void rmi_function_of_probe(struct rmi_function *fn)
157{
158 char of_name[9];
159 struct device_node *node = fn->rmi_dev->xport->dev->of_node;
160
161 snprintf(of_name, sizeof(of_name), "rmi4-f%02x",
162 fn->fd.function_number);
163 fn->dev.of_node = of_get_child_by_name(node, of_name);
164}
165#else
166static inline void rmi_function_of_probe(struct rmi_function *fn)
167{}
168#endif
169
170static int rmi_function_probe(struct device *dev)
171{
172 struct rmi_function *fn = to_rmi_function(dev);
173 struct rmi_function_handler *handler =
174 to_rmi_function_handler(dev->driver);
175 int error;
176
177 rmi_function_of_probe(fn);
178
179 if (handler->probe) {
180 error = handler->probe(fn);
181 return error;
182 }
183
184 return 0;
185}
186
187static int rmi_function_remove(struct device *dev)
188{
189 struct rmi_function *fn = to_rmi_function(dev);
190 struct rmi_function_handler *handler =
191 to_rmi_function_handler(dev->driver);
192
193 if (handler->remove)
194 handler->remove(fn);
195
196 return 0;
197}
198
199int rmi_register_function(struct rmi_function *fn)
200{
201 struct rmi_device *rmi_dev = fn->rmi_dev;
202 int error;
203
204 device_initialize(&fn->dev);
205
206 dev_set_name(&fn->dev, "%s.fn%02x",
207 dev_name(&rmi_dev->dev), fn->fd.function_number);
208
209 fn->dev.parent = &rmi_dev->dev;
210 fn->dev.type = &rmi_function_type;
211 fn->dev.bus = &rmi_bus_type;
212
213 error = device_add(&fn->dev);
214 if (error) {
215 dev_err(&rmi_dev->dev,
216 "Failed device_register function device %s\n",
217 dev_name(&fn->dev));
218 goto err_put_device;
219 }
220
221 rmi_dbg(RMI_DEBUG_CORE, &rmi_dev->dev, "Registered F%02X.\n",
222 fn->fd.function_number);
223
224 return 0;
225
226err_put_device:
227 put_device(&fn->dev);
228 return error;
229}
230
231void rmi_unregister_function(struct rmi_function *fn)
232{
233 rmi_dbg(RMI_DEBUG_CORE, &fn->dev, "Unregistering F%02X.\n",
234 fn->fd.function_number);
235
236 device_del(&fn->dev);
237 of_node_put(fn->dev.of_node);
238 put_device(&fn->dev);
239}
240
241
242
243
244
245
246
247
248
249
250
251int __rmi_register_function_handler(struct rmi_function_handler *handler,
252 struct module *owner,
253 const char *mod_name)
254{
255 struct device_driver *driver = &handler->driver;
256 int error;
257
258 driver->bus = &rmi_bus_type;
259 driver->owner = owner;
260 driver->mod_name = mod_name;
261 driver->probe = rmi_function_probe;
262 driver->remove = rmi_function_remove;
263
264 error = driver_register(driver);
265 if (error) {
266 pr_err("driver_register() failed for %s, error: %d\n",
267 driver->name, error);
268 return error;
269 }
270
271 return 0;
272}
273EXPORT_SYMBOL_GPL(__rmi_register_function_handler);
274
275
276
277
278
279
280
281
282void rmi_unregister_function_handler(struct rmi_function_handler *handler)
283{
284 driver_unregister(&handler->driver);
285}
286EXPORT_SYMBOL_GPL(rmi_unregister_function_handler);
287
288
289
290static int rmi_bus_match(struct device *dev, struct device_driver *drv)
291{
292 bool physical = rmi_is_physical_device(dev);
293
294
295 if (physical != rmi_is_physical_driver(drv))
296 return 0;
297
298 return physical || rmi_function_match(dev, drv);
299}
300
301struct bus_type rmi_bus_type = {
302 .match = rmi_bus_match,
303 .name = "rmi4",
304};
305
306static struct rmi_function_handler *fn_handlers[] = {
307 &rmi_f01_handler,
308#ifdef CONFIG_RMI4_F03
309 &rmi_f03_handler,
310#endif
311#ifdef CONFIG_RMI4_F11
312 &rmi_f11_handler,
313#endif
314#ifdef CONFIG_RMI4_F12
315 &rmi_f12_handler,
316#endif
317#ifdef CONFIG_RMI4_F30
318 &rmi_f30_handler,
319#endif
320#ifdef CONFIG_RMI4_F34
321 &rmi_f34_handler,
322#endif
323#ifdef CONFIG_RMI4_F54
324 &rmi_f54_handler,
325#endif
326#ifdef CONFIG_RMI4_F55
327 &rmi_f55_handler,
328#endif
329};
330
331static void __rmi_unregister_function_handlers(int start_idx)
332{
333 int i;
334
335 for (i = start_idx; i >= 0; i--)
336 rmi_unregister_function_handler(fn_handlers[i]);
337}
338
339static void rmi_unregister_function_handlers(void)
340{
341 __rmi_unregister_function_handlers(ARRAY_SIZE(fn_handlers) - 1);
342}
343
344static int rmi_register_function_handlers(void)
345{
346 int ret;
347 int i;
348
349 for (i = 0; i < ARRAY_SIZE(fn_handlers); i++) {
350 ret = rmi_register_function_handler(fn_handlers[i]);
351 if (ret) {
352 pr_err("%s: error registering the RMI F%02x handler: %d\n",
353 __func__, fn_handlers[i]->func, ret);
354 goto err_unregister_function_handlers;
355 }
356 }
357
358 return 0;
359
360err_unregister_function_handlers:
361 __rmi_unregister_function_handlers(i - 1);
362 return ret;
363}
364
365int rmi_of_property_read_u32(struct device *dev, u32 *result,
366 const char *prop, bool optional)
367{
368 int retval;
369 u32 val = 0;
370
371 retval = of_property_read_u32(dev->of_node, prop, &val);
372 if (retval && (!optional && retval == -EINVAL)) {
373 dev_err(dev, "Failed to get %s value: %d\n",
374 prop, retval);
375 return retval;
376 }
377 *result = val;
378
379 return 0;
380}
381EXPORT_SYMBOL_GPL(rmi_of_property_read_u32);
382
383static int __init rmi_bus_init(void)
384{
385 int error;
386
387 error = bus_register(&rmi_bus_type);
388 if (error) {
389 pr_err("%s: error registering the RMI bus: %d\n",
390 __func__, error);
391 return error;
392 }
393
394 error = rmi_register_function_handlers();
395 if (error)
396 goto err_unregister_bus;
397
398 error = rmi_register_physical_driver();
399 if (error) {
400 pr_err("%s: error registering the RMI physical driver: %d\n",
401 __func__, error);
402 goto err_unregister_bus;
403 }
404
405 return 0;
406
407err_unregister_bus:
408 bus_unregister(&rmi_bus_type);
409 return error;
410}
411module_init(rmi_bus_init);
412
413static void __exit rmi_bus_exit(void)
414{
415
416
417
418
419
420 rmi_unregister_physical_driver();
421 rmi_unregister_function_handlers();
422 bus_unregister(&rmi_bus_type);
423}
424module_exit(rmi_bus_exit);
425
426MODULE_AUTHOR("Christopher Heiny <cheiny@synaptics.com");
427MODULE_AUTHOR("Andrew Duggan <aduggan@synaptics.com");
428MODULE_DESCRIPTION("RMI bus");
429MODULE_LICENSE("GPL");
430MODULE_VERSION(RMI_DRIVER_VERSION);
431