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/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
21 static int debug_flags;
22 module_param(debug_flags, int, 0644);
23 MODULE_PARM_DESC(debug_flags, "control debugging information");
24
25 void 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 }
41 EXPORT_SYMBOL_GPL(rmi_dbg);
42
43 /*
44  * RMI Physical devices
45  *
46  * Physical RMI device consists of several functions serving particular
47  * purpose. For example F11 is a 2D touch sensor while F01 is a generic
48  * function present in every RMI device.
49  */
50
51 static 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
58 static struct device_type rmi_device_type = {
59         .name           = "rmi4_sensor",
60         .release        = rmi_release_device,
61 };
62
63 bool rmi_is_physical_device(struct device *dev)
64 {
65         return dev->type == &rmi_device_type;
66 }
67
68 /**
69  * rmi_register_transport_device - register a transport device connection
70  * on the RMI bus.  Transport drivers provide communication from the devices
71  * on a bus (such as SPI, I2C, and so on) to the RMI4 sensor.
72  *
73  * @xport: the transport device to register
74  */
75 int 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
107 err_put_device:
108         put_device(&rmi_dev->dev);
109         return error;
110 }
111 EXPORT_SYMBOL_GPL(rmi_register_transport_device);
112
113 /**
114  * rmi_unregister_transport_device - unregister a transport device connection
115  * @xport: the transport driver to unregister
116  *
117  */
118 void 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 }
125 EXPORT_SYMBOL(rmi_unregister_transport_device);
126
127
128 /* Function specific stuff */
129
130 static void rmi_release_function(struct device *dev)
131 {
132         struct rmi_function *fn = to_rmi_function(dev);
133
134         kfree(fn);
135 }
136
137 static struct device_type rmi_function_type = {
138         .name           = "rmi4_function",
139         .release        = rmi_release_function,
140 };
141
142 bool rmi_is_function_device(struct device *dev)
143 {
144         return dev->type == &rmi_function_type;
145 }
146
147 static 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
156 static 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
166 static inline void rmi_function_of_probe(struct rmi_function *fn)
167 {}
168 #endif
169
170 static 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
187 static 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
199 int 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
226 err_put_device:
227         put_device(&fn->dev);
228         return error;
229 }
230
231 void 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  * rmi_register_function_handler - register a handler for an RMI function
243  * @handler: RMI handler that should be registered.
244  * @module: pointer to module that implements the handler
245  * @mod_name: name of the module implementing the handler
246  *
247  * This function performs additional setup of RMI function handler and
248  * registers it with the RMI core so that it can be bound to
249  * RMI function devices.
250  */
251 int __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(&handler->driver);
265         if (error) {
266                 pr_err("driver_register() failed for %s, error: %d\n",
267                         handler->driver.name, error);
268                 return error;
269         }
270
271         return 0;
272 }
273 EXPORT_SYMBOL_GPL(__rmi_register_function_handler);
274
275 /**
276  * rmi_unregister_function_handler - unregister given RMI function handler
277  * @handler: RMI handler that should be unregistered.
278  *
279  * This function unregisters given function handler from RMI core which
280  * causes it to be unbound from the function devices.
281  */
282 void rmi_unregister_function_handler(struct rmi_function_handler *handler)
283 {
284         driver_unregister(&handler->driver);
285 }
286 EXPORT_SYMBOL_GPL(rmi_unregister_function_handler);
287
288 /* Bus specific stuff */
289
290 static int rmi_bus_match(struct device *dev, struct device_driver *drv)
291 {
292         bool physical = rmi_is_physical_device(dev);
293
294         /* First see if types are not compatible */
295         if (physical != rmi_is_physical_driver(drv))
296                 return 0;
297
298         return physical || rmi_function_match(dev, drv);
299 }
300
301 struct bus_type rmi_bus_type = {
302         .match          = rmi_bus_match,
303         .name           = "rmi4",
304 };
305
306 static 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
331 static 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
339 static void rmi_unregister_function_handlers(void)
340 {
341         __rmi_unregister_function_handlers(ARRAY_SIZE(fn_handlers) - 1);
342 }
343
344 static 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
360 err_unregister_function_handlers:
361         __rmi_unregister_function_handlers(i - 1);
362         return ret;
363 }
364
365 int 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 }
381 EXPORT_SYMBOL_GPL(rmi_of_property_read_u32);
382
383 static 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
407 err_unregister_bus:
408         bus_unregister(&rmi_bus_type);
409         return error;
410 }
411 module_init(rmi_bus_init);
412
413 static void __exit rmi_bus_exit(void)
414 {
415         /*
416          * We should only ever get here if all drivers are unloaded, so
417          * all we have to do at this point is unregister ourselves.
418          */
419
420         rmi_unregister_physical_driver();
421         rmi_unregister_function_handlers();
422         bus_unregister(&rmi_bus_type);
423 }
424 module_exit(rmi_bus_exit);
425
426 MODULE_AUTHOR("Christopher Heiny <cheiny@synaptics.com");
427 MODULE_AUTHOR("Andrew Duggan <aduggan@synaptics.com");
428 MODULE_DESCRIPTION("RMI bus");
429 MODULE_LICENSE("GPL");
430 MODULE_VERSION(RMI_DRIVER_VERSION);