xref: /linux/drivers/input/rmi4/rmi_bus.c (revision 6885d7263ecd8ce5ab06029078861fbeb06c4a0a) 
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 
20 static int debug_flags;
21 module_param(debug_flags, int, 0644);
22 MODULE_PARM_DESC(debug_flags, "control debugging information");
23 
24 void 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 }
40 EXPORT_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 
50 static void rmi_release_device(struct device *dev)
51 {
52 	struct rmi_device *rmi_dev = to_rmi_device(dev);
53 
54 	kfree(rmi_dev);
55 }
56 
57 static const struct device_type rmi_device_type = {
58 	.name		= "rmi4_sensor",
59 	.release	= rmi_release_device,
60 };
61 
62 bool 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  */
74 int 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(sizeof(struct rmi_device), GFP_KERNEL);
81 	if (!rmi_dev)
82 		return -ENOMEM;
83 
84 	device_initialize(&rmi_dev->dev);
85 
86 	rmi_dev->xport = xport;
87 	rmi_dev->number = atomic_inc_return(&transport_device_count) - 1;
88 
89 	dev_set_name(&rmi_dev->dev, "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(&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 const 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 struct irq_chip rmi_irq_chip = {
171 	.name = "rmi4",
172 };
173 
174 static 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(&fn->rmi_dev->dev);
178 	int i, error;
179 
180 	for (i = 0; i < fn->num_of_irqs; i++) {
181 		set_bit(fn->irq_pos + i, fn->irq_mask);
182 
183 		fn->irq[i] = irq_create_mapping(drvdata->irqdomain,
184 						fn->irq_pos + i);
185 
186 		irq_set_chip_data(fn->irq[i], fn);
187 		irq_set_chip_and_handler(fn->irq[i], &rmi_irq_chip,
188 					 handle_simple_irq);
189 		irq_set_nested_thread(fn->irq[i], 1);
190 
191 		error = devm_request_threaded_irq(&fn->dev, fn->irq[i], NULL,
192 					handler->attention, IRQF_ONESHOT,
193 					dev_name(&fn->dev), 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 
203 static 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 
227 static 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 
239 int rmi_register_function(struct rmi_function *fn)
240 {
241 	struct rmi_device *rmi_dev = fn->rmi_dev;
242 	int error;
243 
244 	device_initialize(&fn->dev);
245 
246 	dev_set_name(&fn->dev, "%s.fn%02x",
247 		     dev_name(&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(&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 
266 err_put_device:
267 	put_device(&fn->dev);
268 	return error;
269 }
270 
271 void 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(&fn->dev);
279 	of_node_put(fn->dev.of_node);
280 
281 	for (i = 0; i < fn->num_of_irqs; i++)
282 		irq_dispose_mapping(fn->irq[i]);
283 
284 	put_device(&fn->dev);
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  */
297 int __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(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 }
319 EXPORT_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  */
328 void rmi_unregister_function_handler(struct rmi_function_handler *handler)
329 {
330 	driver_unregister(&handler->driver);
331 }
332 EXPORT_SYMBOL_GPL(rmi_unregister_function_handler);
333 
334 /* Bus specific stuff */
335 
336 static 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 
347 const struct bus_type rmi_bus_type = {
348 	.match		= rmi_bus_match,
349 	.name		= "rmi4",
350 };
351 
352 static 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 
380 static 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 
388 static void rmi_unregister_function_handlers(void)
389 {
390 	__rmi_unregister_function_handlers(ARRAY_SIZE(fn_handlers) - 1);
391 }
392 
393 static 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 
409 err_unregister_function_handlers:
410 	__rmi_unregister_function_handlers(i - 1);
411 	return ret;
412 }
413 
414 int 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(dev->of_node, prop, &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 }
430 EXPORT_SYMBOL_GPL(rmi_of_property_read_u32);
431 
432 static int __init rmi_bus_init(void)
433 {
434 	int error;
435 
436 	error = bus_register(&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 
456 err_unregister_bus:
457 	bus_unregister(&rmi_bus_type);
458 	return error;
459 }
460 module_init(rmi_bus_init);
461 
462 static 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(&rmi_bus_type);
472 }
473 module_exit(rmi_bus_exit);
474 
475 MODULE_AUTHOR("Christopher Heiny <cheiny@synaptics.com");
476 MODULE_AUTHOR("Andrew Duggan <aduggan@synaptics.com");
477 MODULE_DESCRIPTION("RMI bus");
478 MODULE_LICENSE("GPL");
479