Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input
[muen/linux.git] / drivers / input / rmi4 / rmi_bus.c
1 /*
2  * Copyright (c) 2011-2016 Synaptics Incorporated
3  * Copyright (c) 2011 Unixphere
4  *
5  * This program is free software; you can redistribute it and/or modify it
6  * under the terms of the GNU General Public License version 2 as published by
7  * the Free Software Foundation.
8  */
9
10 #include <linux/kernel.h>
11 #include <linux/device.h>
12 #include <linux/irq.h>
13 #include <linux/irqdomain.h>
14 #include <linux/list.h>
15 #include <linux/pm.h>
16 #include <linux/rmi.h>
17 #include <linux/slab.h>
18 #include <linux/types.h>
19 #include <linux/of.h>
20 #include "rmi_bus.h"
21 #include "rmi_driver.h"
22
23 static int debug_flags;
24 module_param(debug_flags, int, 0644);
25 MODULE_PARM_DESC(debug_flags, "control debugging information");
26
27 void rmi_dbg(int flags, struct device *dev, const char *fmt, ...)
28 {
29         struct va_format vaf;
30         va_list args;
31
32         if (flags & debug_flags) {
33                 va_start(args, fmt);
34
35                 vaf.fmt = fmt;
36                 vaf.va = &args;
37
38                 dev_printk(KERN_DEBUG, dev, "%pV", &vaf);
39
40                 va_end(args);
41         }
42 }
43 EXPORT_SYMBOL_GPL(rmi_dbg);
44
45 /*
46  * RMI Physical devices
47  *
48  * Physical RMI device consists of several functions serving particular
49  * purpose. For example F11 is a 2D touch sensor while F01 is a generic
50  * function present in every RMI device.
51  */
52
53 static void rmi_release_device(struct device *dev)
54 {
55         struct rmi_device *rmi_dev = to_rmi_device(dev);
56
57         kfree(rmi_dev);
58 }
59
60 static const struct device_type rmi_device_type = {
61         .name           = "rmi4_sensor",
62         .release        = rmi_release_device,
63 };
64
65 bool rmi_is_physical_device(struct device *dev)
66 {
67         return dev->type == &rmi_device_type;
68 }
69
70 /**
71  * rmi_register_transport_device - register a transport device connection
72  * on the RMI bus.  Transport drivers provide communication from the devices
73  * on a bus (such as SPI, I2C, and so on) to the RMI4 sensor.
74  *
75  * @xport: the transport device to register
76  */
77 int rmi_register_transport_device(struct rmi_transport_dev *xport)
78 {
79         static atomic_t transport_device_count = ATOMIC_INIT(0);
80         struct rmi_device *rmi_dev;
81         int error;
82
83         rmi_dev = kzalloc(sizeof(struct rmi_device), GFP_KERNEL);
84         if (!rmi_dev)
85                 return -ENOMEM;
86
87         device_initialize(&rmi_dev->dev);
88
89         rmi_dev->xport = xport;
90         rmi_dev->number = atomic_inc_return(&transport_device_count) - 1;
91
92         dev_set_name(&rmi_dev->dev, "rmi4-%02d", rmi_dev->number);
93
94         rmi_dev->dev.bus = &rmi_bus_type;
95         rmi_dev->dev.type = &rmi_device_type;
96
97         xport->rmi_dev = rmi_dev;
98
99         error = device_add(&rmi_dev->dev);
100         if (error)
101                 goto err_put_device;
102
103         rmi_dbg(RMI_DEBUG_CORE, xport->dev,
104                 "%s: Registered %s as %s.\n", __func__,
105                 dev_name(rmi_dev->xport->dev), dev_name(&rmi_dev->dev));
106
107         return 0;
108
109 err_put_device:
110         put_device(&rmi_dev->dev);
111         return error;
112 }
113 EXPORT_SYMBOL_GPL(rmi_register_transport_device);
114
115 /**
116  * rmi_unregister_transport_device - unregister a transport device connection
117  * @xport: the transport driver to unregister
118  *
119  */
120 void rmi_unregister_transport_device(struct rmi_transport_dev *xport)
121 {
122         struct rmi_device *rmi_dev = xport->rmi_dev;
123
124         device_del(&rmi_dev->dev);
125         put_device(&rmi_dev->dev);
126 }
127 EXPORT_SYMBOL(rmi_unregister_transport_device);
128
129
130 /* Function specific stuff */
131
132 static void rmi_release_function(struct device *dev)
133 {
134         struct rmi_function *fn = to_rmi_function(dev);
135
136         kfree(fn);
137 }
138
139 static const struct device_type rmi_function_type = {
140         .name           = "rmi4_function",
141         .release        = rmi_release_function,
142 };
143
144 bool rmi_is_function_device(struct device *dev)
145 {
146         return dev->type == &rmi_function_type;
147 }
148
149 static int rmi_function_match(struct device *dev, struct device_driver *drv)
150 {
151         struct rmi_function_handler *handler = to_rmi_function_handler(drv);
152         struct rmi_function *fn = to_rmi_function(dev);
153
154         return fn->fd.function_number == handler->func;
155 }
156
157 #ifdef CONFIG_OF
158 static void rmi_function_of_probe(struct rmi_function *fn)
159 {
160         char of_name[9];
161         struct device_node *node = fn->rmi_dev->xport->dev->of_node;
162
163         snprintf(of_name, sizeof(of_name), "rmi4-f%02x",
164                 fn->fd.function_number);
165         fn->dev.of_node = of_get_child_by_name(node, of_name);
166 }
167 #else
168 static inline void rmi_function_of_probe(struct rmi_function *fn)
169 {}
170 #endif
171
172 static struct irq_chip rmi_irq_chip = {
173         .name = "rmi4",
174 };
175
176 static int rmi_create_function_irq(struct rmi_function *fn,
177                                    struct rmi_function_handler *handler)
178 {
179         struct rmi_driver_data *drvdata = dev_get_drvdata(&fn->rmi_dev->dev);
180         int i, error;
181
182         for (i = 0; i < fn->num_of_irqs; i++) {
183                 set_bit(fn->irq_pos + i, fn->irq_mask);
184
185                 fn->irq[i] = irq_create_mapping(drvdata->irqdomain,
186                                                 fn->irq_pos + i);
187
188                 irq_set_chip_data(fn->irq[i], fn);
189                 irq_set_chip_and_handler(fn->irq[i], &rmi_irq_chip,
190                                          handle_simple_irq);
191                 irq_set_nested_thread(fn->irq[i], 1);
192
193                 error = devm_request_threaded_irq(&fn->dev, fn->irq[i], NULL,
194                                         handler->attention, IRQF_ONESHOT,
195                                         dev_name(&fn->dev), fn);
196                 if (error) {
197                         dev_err(&fn->dev, "Error %d registering IRQ\n", error);
198                         return error;
199                 }
200         }
201
202         return 0;
203 }
204
205 static int rmi_function_probe(struct device *dev)
206 {
207         struct rmi_function *fn = to_rmi_function(dev);
208         struct rmi_function_handler *handler =
209                                         to_rmi_function_handler(dev->driver);
210         int error;
211
212         rmi_function_of_probe(fn);
213
214         if (handler->probe) {
215                 error = handler->probe(fn);
216                 if (error)
217                         return error;
218         }
219
220         if (fn->num_of_irqs && handler->attention) {
221                 error = rmi_create_function_irq(fn, handler);
222                 if (error)
223                         return error;
224         }
225
226         return 0;
227 }
228
229 static int rmi_function_remove(struct device *dev)
230 {
231         struct rmi_function *fn = to_rmi_function(dev);
232         struct rmi_function_handler *handler =
233                                         to_rmi_function_handler(dev->driver);
234
235         if (handler->remove)
236                 handler->remove(fn);
237
238         return 0;
239 }
240
241 int rmi_register_function(struct rmi_function *fn)
242 {
243         struct rmi_device *rmi_dev = fn->rmi_dev;
244         int error;
245
246         device_initialize(&fn->dev);
247
248         dev_set_name(&fn->dev, "%s.fn%02x",
249                      dev_name(&rmi_dev->dev), fn->fd.function_number);
250
251         fn->dev.parent = &rmi_dev->dev;
252         fn->dev.type = &rmi_function_type;
253         fn->dev.bus = &rmi_bus_type;
254
255         error = device_add(&fn->dev);
256         if (error) {
257                 dev_err(&rmi_dev->dev,
258                         "Failed device_register function device %s\n",
259                         dev_name(&fn->dev));
260                 goto err_put_device;
261         }
262
263         rmi_dbg(RMI_DEBUG_CORE, &rmi_dev->dev, "Registered F%02X.\n",
264                         fn->fd.function_number);
265
266         return 0;
267
268 err_put_device:
269         put_device(&fn->dev);
270         return error;
271 }
272
273 void rmi_unregister_function(struct rmi_function *fn)
274 {
275         int i;
276
277         rmi_dbg(RMI_DEBUG_CORE, &fn->dev, "Unregistering F%02X.\n",
278                         fn->fd.function_number);
279
280         device_del(&fn->dev);
281         of_node_put(fn->dev.of_node);
282         put_device(&fn->dev);
283
284         for (i = 0; i < fn->num_of_irqs; i++)
285                 irq_dispose_mapping(fn->irq[i]);
286
287 }
288
289 /**
290  * rmi_register_function_handler - register a handler for an RMI function
291  * @handler: RMI handler that should be registered.
292  * @module: pointer to module that implements the handler
293  * @mod_name: name of the module implementing the handler
294  *
295  * This function performs additional setup of RMI function handler and
296  * registers it with the RMI core so that it can be bound to
297  * RMI function devices.
298  */
299 int __rmi_register_function_handler(struct rmi_function_handler *handler,
300                                      struct module *owner,
301                                      const char *mod_name)
302 {
303         struct device_driver *driver = &handler->driver;
304         int error;
305
306         driver->bus = &rmi_bus_type;
307         driver->owner = owner;
308         driver->mod_name = mod_name;
309         driver->probe = rmi_function_probe;
310         driver->remove = rmi_function_remove;
311
312         error = driver_register(driver);
313         if (error) {
314                 pr_err("driver_register() failed for %s, error: %d\n",
315                         driver->name, error);
316                 return error;
317         }
318
319         return 0;
320 }
321 EXPORT_SYMBOL_GPL(__rmi_register_function_handler);
322
323 /**
324  * rmi_unregister_function_handler - unregister given RMI function handler
325  * @handler: RMI handler that should be unregistered.
326  *
327  * This function unregisters given function handler from RMI core which
328  * causes it to be unbound from the function devices.
329  */
330 void rmi_unregister_function_handler(struct rmi_function_handler *handler)
331 {
332         driver_unregister(&handler->driver);
333 }
334 EXPORT_SYMBOL_GPL(rmi_unregister_function_handler);
335
336 /* Bus specific stuff */
337
338 static int rmi_bus_match(struct device *dev, struct device_driver *drv)
339 {
340         bool physical = rmi_is_physical_device(dev);
341
342         /* First see if types are not compatible */
343         if (physical != rmi_is_physical_driver(drv))
344                 return 0;
345
346         return physical || rmi_function_match(dev, drv);
347 }
348
349 struct bus_type rmi_bus_type = {
350         .match          = rmi_bus_match,
351         .name           = "rmi4",
352 };
353
354 static struct rmi_function_handler *fn_handlers[] = {
355         &rmi_f01_handler,
356 #ifdef CONFIG_RMI4_F03
357         &rmi_f03_handler,
358 #endif
359 #ifdef CONFIG_RMI4_F11
360         &rmi_f11_handler,
361 #endif
362 #ifdef CONFIG_RMI4_F12
363         &rmi_f12_handler,
364 #endif
365 #ifdef CONFIG_RMI4_F30
366         &rmi_f30_handler,
367 #endif
368 #ifdef CONFIG_RMI4_F34
369         &rmi_f34_handler,
370 #endif
371 #ifdef CONFIG_RMI4_F54
372         &rmi_f54_handler,
373 #endif
374 #ifdef CONFIG_RMI4_F55
375         &rmi_f55_handler,
376 #endif
377 };
378
379 static void __rmi_unregister_function_handlers(int start_idx)
380 {
381         int i;
382
383         for (i = start_idx; i >= 0; i--)
384                 rmi_unregister_function_handler(fn_handlers[i]);
385 }
386
387 static void rmi_unregister_function_handlers(void)
388 {
389         __rmi_unregister_function_handlers(ARRAY_SIZE(fn_handlers) - 1);
390 }
391
392 static int rmi_register_function_handlers(void)
393 {
394         int ret;
395         int i;
396
397         for (i = 0; i < ARRAY_SIZE(fn_handlers); i++)   {
398                 ret = rmi_register_function_handler(fn_handlers[i]);
399                 if (ret) {
400                         pr_err("%s: error registering the RMI F%02x handler: %d\n",
401                                 __func__, fn_handlers[i]->func, ret);
402                         goto err_unregister_function_handlers;
403                 }
404         }
405
406         return 0;
407
408 err_unregister_function_handlers:
409         __rmi_unregister_function_handlers(i - 1);
410         return ret;
411 }
412
413 int rmi_of_property_read_u32(struct device *dev, u32 *result,
414                                 const char *prop, bool optional)
415 {
416         int retval;
417         u32 val = 0;
418
419         retval = of_property_read_u32(dev->of_node, prop, &val);
420         if (retval && (!optional && retval == -EINVAL)) {
421                 dev_err(dev, "Failed to get %s value: %d\n",
422                         prop, retval);
423                 return retval;
424         }
425         *result = val;
426
427         return 0;
428 }
429 EXPORT_SYMBOL_GPL(rmi_of_property_read_u32);
430
431 static int __init rmi_bus_init(void)
432 {
433         int error;
434
435         error = bus_register(&rmi_bus_type);
436         if (error) {
437                 pr_err("%s: error registering the RMI bus: %d\n",
438                         __func__, error);
439                 return error;
440         }
441
442         error = rmi_register_function_handlers();
443         if (error)
444                 goto err_unregister_bus;
445
446         error = rmi_register_physical_driver();
447         if (error) {
448                 pr_err("%s: error registering the RMI physical driver: %d\n",
449                         __func__, error);
450                 goto err_unregister_bus;
451         }
452
453         return 0;
454
455 err_unregister_bus:
456         bus_unregister(&rmi_bus_type);
457         return error;
458 }
459 module_init(rmi_bus_init);
460
461 static void __exit rmi_bus_exit(void)
462 {
463         /*
464          * We should only ever get here if all drivers are unloaded, so
465          * all we have to do at this point is unregister ourselves.
466          */
467
468         rmi_unregister_physical_driver();
469         rmi_unregister_function_handlers();
470         bus_unregister(&rmi_bus_type);
471 }
472 module_exit(rmi_bus_exit);
473
474 MODULE_AUTHOR("Christopher Heiny <cheiny@synaptics.com");
475 MODULE_AUTHOR("Andrew Duggan <aduggan@synaptics.com");
476 MODULE_DESCRIPTION("RMI bus");
477 MODULE_LICENSE("GPL");