]>
Commit | Line | Data |
---|---|---|
2b6a321d AD |
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> | |
2b6a321d AD |
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 | ||
f719315b | 58 | static const struct device_type rmi_device_type = { |
2b6a321d AD |
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 | ||
f719315b | 137 | static const struct device_type rmi_function_type = { |
2b6a321d AD |
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 | ||
d8a8b3ed AD |
155 | #ifdef CONFIG_OF |
156 | static void rmi_function_of_probe(struct rmi_function *fn) | |
157 | { | |
158 | char of_name[9]; | |
9624516d | 159 | struct device_node *node = fn->rmi_dev->xport->dev->of_node; |
d8a8b3ed AD |
160 | |
161 | snprintf(of_name, sizeof(of_name), "rmi4-f%02x", | |
162 | fn->fd.function_number); | |
9624516d | 163 | fn->dev.of_node = of_get_child_by_name(node, of_name); |
d8a8b3ed AD |
164 | } |
165 | #else | |
166 | static inline void rmi_function_of_probe(struct rmi_function *fn) | |
167 | {} | |
168 | #endif | |
169 | ||
2b6a321d AD |
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 | ||
d8a8b3ed AD |
177 | rmi_function_of_probe(fn); |
178 | ||
2b6a321d AD |
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 | { | |
8029a283 ND |
233 | rmi_dbg(RMI_DEBUG_CORE, &fn->dev, "Unregistering F%02X.\n", |
234 | fn->fd.function_number); | |
235 | ||
2b6a321d | 236 | device_del(&fn->dev); |
887ec0bf | 237 | of_node_put(fn->dev.of_node); |
2b6a321d AD |
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 | ||
ed77bdf4 | 264 | error = driver_register(driver); |
2b6a321d AD |
265 | if (error) { |
266 | pr_err("driver_register() failed for %s, error: %d\n", | |
ed77bdf4 | 267 | driver->name, error); |
2b6a321d AD |
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, | |
c5e8848f LP |
308 | #ifdef CONFIG_RMI4_F03 |
309 | &rmi_f03_handler, | |
310 | #endif | |
ff8f8370 AD |
311 | #ifdef CONFIG_RMI4_F11 |
312 | &rmi_f11_handler, | |
313 | #endif | |
b43d2c1e AD |
314 | #ifdef CONFIG_RMI4_F12 |
315 | &rmi_f12_handler, | |
316 | #endif | |
562b42d3 AD |
317 | #ifdef CONFIG_RMI4_F30 |
318 | &rmi_f30_handler, | |
319 | #endif | |
29fd0ec2 ND |
320 | #ifdef CONFIG_RMI4_F34 |
321 | &rmi_f34_handler, | |
322 | #endif | |
3a762dbd ND |
323 | #ifdef CONFIG_RMI4_F54 |
324 | &rmi_f54_handler, | |
325 | #endif | |
6adba43f GR |
326 | #ifdef CONFIG_RMI4_F55 |
327 | &rmi_f55_handler, | |
328 | #endif | |
2b6a321d AD |
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 | ||
d8a8b3ed AD |
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 | ||
2b6a321d AD |
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); |