xref: /linux/drivers/input/rmi4/rmi_bus.c (revision a1c3be890440a1769ed6f822376a3e3ab0d42994) 
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 
94 	xport->rmi_dev = rmi_dev;
95 
96 	error = device_add(&rmi_dev->dev);
97 	if (error)
98 		goto err_put_device;
99 
100 	rmi_dbg(RMI_DEBUG_CORE, xport->dev,
101 		"%s: Registered %s as %s.\n", __func__,
102 		dev_name(rmi_dev->xport->dev), dev_name(&rmi_dev->dev));
103 
104 	return 0;
105 
106 err_put_device:
107 	put_device(&rmi_dev->dev);
108 	return error;
109 }
110 EXPORT_SYMBOL_GPL(rmi_register_transport_device);
111 
112 /**
113  * rmi_unregister_transport_device - unregister a transport device connection
114  * @xport: the transport driver to unregister
115  *
116  */
117 void rmi_unregister_transport_device(struct rmi_transport_dev *xport)
118 {
119 	struct rmi_device *rmi_dev = xport->rmi_dev;
120 
121 	device_del(&rmi_dev->dev);
122 	put_device(&rmi_dev->dev);
123 }
124 EXPORT_SYMBOL(rmi_unregister_transport_device);
125 
126 
127 /* Function specific stuff */
128 
129 static void rmi_release_function(struct device *dev)
130 {
131 	struct rmi_function *fn = to_rmi_function(dev);
132 
133 	kfree(fn);
134 }
135 
136 static const struct device_type rmi_function_type = {
137 	.name		= "rmi4_function",
138 	.release	= rmi_release_function,
139 };
140 
141 bool rmi_is_function_device(struct device *dev)
142 {
143 	return dev->type == &rmi_function_type;
144 }
145 
146 static int rmi_function_match(struct device *dev, struct device_driver *drv)
147 {
148 	struct rmi_function_handler *handler = to_rmi_function_handler(drv);
149 	struct rmi_function *fn = to_rmi_function(dev);
150 
151 	return fn->fd.function_number == handler->func;
152 }
153 
154 #ifdef CONFIG_OF
155 static void rmi_function_of_probe(struct rmi_function *fn)
156 {
157 	char of_name[9];
158 	struct device_node *node = fn->rmi_dev->xport->dev->of_node;
159 
160 	snprintf(of_name, sizeof(of_name), "rmi4-f%02x",
161 		fn->fd.function_number);
162 	fn->dev.of_node = of_get_child_by_name(node, of_name);
163 }
164 #else
165 static inline void rmi_function_of_probe(struct rmi_function *fn)
166 {}
167 #endif
168 
169 static struct irq_chip rmi_irq_chip = {
170 	.name = "rmi4",
171 };
172 
173 static int rmi_create_function_irq(struct rmi_function *fn,
174 				   struct rmi_function_handler *handler)
175 {
176 	struct rmi_driver_data *drvdata = dev_get_drvdata(&fn->rmi_dev->dev);
177 	int i, error;
178 
179 	for (i = 0; i < fn->num_of_irqs; i++) {
180 		set_bit(fn->irq_pos + i, fn->irq_mask);
181 
182 		fn->irq[i] = irq_create_mapping(drvdata->irqdomain,
183 						fn->irq_pos + i);
184 
185 		irq_set_chip_data(fn->irq[i], fn);
186 		irq_set_chip_and_handler(fn->irq[i], &rmi_irq_chip,
187 					 handle_simple_irq);
188 		irq_set_nested_thread(fn->irq[i], 1);
189 
190 		error = devm_request_threaded_irq(&fn->dev, fn->irq[i], NULL,
191 					handler->attention, IRQF_ONESHOT,
192 					dev_name(&fn->dev), fn);
193 		if (error) {
194 			dev_err(&fn->dev, "Error %d registering IRQ\n", error);
195 			return error;
196 		}
197 	}
198 
199 	return 0;
200 }
201 
202 static int rmi_function_probe(struct device *dev)
203 {
204 	struct rmi_function *fn = to_rmi_function(dev);
205 	struct rmi_function_handler *handler =
206 					to_rmi_function_handler(dev->driver);
207 	int error;
208 
209 	rmi_function_of_probe(fn);
210 
211 	if (handler->probe) {
212 		error = handler->probe(fn);
213 		if (error)
214 			return error;
215 	}
216 
217 	if (fn->num_of_irqs && handler->attention) {
218 		error = rmi_create_function_irq(fn, handler);
219 		if (error)
220 			return error;
221 	}
222 
223 	return 0;
224 }
225 
226 static int rmi_function_remove(struct device *dev)
227 {
228 	struct rmi_function *fn = to_rmi_function(dev);
229 	struct rmi_function_handler *handler =
230 					to_rmi_function_handler(dev->driver);
231 
232 	if (handler->remove)
233 		handler->remove(fn);
234 
235 	return 0;
236 }
237 
238 int rmi_register_function(struct rmi_function *fn)
239 {
240 	struct rmi_device *rmi_dev = fn->rmi_dev;
241 	int error;
242 
243 	device_initialize(&fn->dev);
244 
245 	dev_set_name(&fn->dev, "%s.fn%02x",
246 		     dev_name(&rmi_dev->dev), fn->fd.function_number);
247 
248 	fn->dev.parent = &rmi_dev->dev;
249 	fn->dev.type = &rmi_function_type;
250 	fn->dev.bus = &rmi_bus_type;
251 
252 	error = device_add(&fn->dev);
253 	if (error) {
254 		dev_err(&rmi_dev->dev,
255 			"Failed device_register function device %s\n",
256 			dev_name(&fn->dev));
257 		goto err_put_device;
258 	}
259 
260 	rmi_dbg(RMI_DEBUG_CORE, &rmi_dev->dev, "Registered F%02X.\n",
261 			fn->fd.function_number);
262 
263 	return 0;
264 
265 err_put_device:
266 	put_device(&fn->dev);
267 	return error;
268 }
269 
270 void rmi_unregister_function(struct rmi_function *fn)
271 {
272 	int i;
273 
274 	rmi_dbg(RMI_DEBUG_CORE, &fn->dev, "Unregistering F%02X.\n",
275 			fn->fd.function_number);
276 
277 	device_del(&fn->dev);
278 	of_node_put(fn->dev.of_node);
279 	put_device(&fn->dev);
280 
281 	for (i = 0; i < fn->num_of_irqs; i++)
282 		irq_dispose_mapping(fn->irq[i]);
283 
284 }
285 
286 /**
287  * rmi_register_function_handler - register a handler for an RMI function
288  * @handler: RMI handler that should be registered.
289  * @owner: pointer to module that implements the handler
290  * @mod_name: name of the module implementing the handler
291  *
292  * This function performs additional setup of RMI function handler and
293  * registers it with the RMI core so that it can be bound to
294  * RMI function devices.
295  */
296 int __rmi_register_function_handler(struct rmi_function_handler *handler,
297 				     struct module *owner,
298 				     const char *mod_name)
299 {
300 	struct device_driver *driver = &handler->driver;
301 	int error;
302 
303 	driver->bus = &rmi_bus_type;
304 	driver->owner = owner;
305 	driver->mod_name = mod_name;
306 	driver->probe = rmi_function_probe;
307 	driver->remove = rmi_function_remove;
308 
309 	error = driver_register(driver);
310 	if (error) {
311 		pr_err("driver_register() failed for %s, error: %d\n",
312 			driver->name, error);
313 		return error;
314 	}
315 
316 	return 0;
317 }
318 EXPORT_SYMBOL_GPL(__rmi_register_function_handler);
319 
320 /**
321  * rmi_unregister_function_handler - unregister given RMI function handler
322  * @handler: RMI handler that should be unregistered.
323  *
324  * This function unregisters given function handler from RMI core which
325  * causes it to be unbound from the function devices.
326  */
327 void rmi_unregister_function_handler(struct rmi_function_handler *handler)
328 {
329 	driver_unregister(&handler->driver);
330 }
331 EXPORT_SYMBOL_GPL(rmi_unregister_function_handler);
332 
333 /* Bus specific stuff */
334 
335 static int rmi_bus_match(struct device *dev, struct device_driver *drv)
336 {
337 	bool physical = rmi_is_physical_device(dev);
338 
339 	/* First see if types are not compatible */
340 	if (physical != rmi_is_physical_driver(drv))
341 		return 0;
342 
343 	return physical || rmi_function_match(dev, drv);
344 }
345 
346 struct bus_type rmi_bus_type = {
347 	.match		= rmi_bus_match,
348 	.name		= "rmi4",
349 };
350 
351 static struct rmi_function_handler *fn_handlers[] = {
352 	&rmi_f01_handler,
353 #ifdef CONFIG_RMI4_F03
354 	&rmi_f03_handler,
355 #endif
356 #ifdef CONFIG_RMI4_F11
357 	&rmi_f11_handler,
358 #endif
359 #ifdef CONFIG_RMI4_F12
360 	&rmi_f12_handler,
361 #endif
362 #ifdef CONFIG_RMI4_F30
363 	&rmi_f30_handler,
364 #endif
365 #ifdef CONFIG_RMI4_F34
366 	&rmi_f34_handler,
367 #endif
368 #ifdef CONFIG_RMI4_F3A
369 	&rmi_f3a_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");
478