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

source code of linux/drivers/input/rmi4/rmi_bus.c