2 * Copyright (c) 2011-2016 Synaptics Incorporated
3 * Copyright (c) 2011 Unixphere
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.
10 #include <linux/kernel.h>
11 #include <linux/device.h>
12 #include <linux/list.h>
14 #include <linux/rmi.h>
15 #include <linux/slab.h>
16 #include <linux/types.h>
19 #include "rmi_driver.h"
21 static int debug_flags
;
22 module_param(debug_flags
, int, 0644);
23 MODULE_PARM_DESC(debug_flags
, "control debugging information");
25 void rmi_dbg(int flags
, struct device
*dev
, const char *fmt
, ...)
30 if (flags
& debug_flags
) {
36 dev_printk(KERN_DEBUG
, dev
, "%pV", &vaf
);
41 EXPORT_SYMBOL_GPL(rmi_dbg
);
44 * RMI Physical devices
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.
51 static void rmi_release_device(struct device
*dev
)
53 struct rmi_device
*rmi_dev
= to_rmi_device(dev
);
58 static struct device_type rmi_device_type
= {
59 .name
= "rmi4_sensor",
60 .release
= rmi_release_device
,
63 bool rmi_is_physical_device(struct device
*dev
)
65 return dev
->type
== &rmi_device_type
;
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.
73 * @xport: the transport device to register
75 int rmi_register_transport_device(struct rmi_transport_dev
*xport
)
77 static atomic_t transport_device_count
= ATOMIC_INIT(0);
78 struct rmi_device
*rmi_dev
;
81 rmi_dev
= kzalloc(sizeof(struct rmi_device
), GFP_KERNEL
);
85 device_initialize(&rmi_dev
->dev
);
87 rmi_dev
->xport
= xport
;
88 rmi_dev
->number
= atomic_inc_return(&transport_device_count
) - 1;
90 dev_set_name(&rmi_dev
->dev
, "rmi4-%02d", rmi_dev
->number
);
92 rmi_dev
->dev
.bus
= &rmi_bus_type
;
93 rmi_dev
->dev
.type
= &rmi_device_type
;
95 xport
->rmi_dev
= rmi_dev
;
97 error
= device_add(&rmi_dev
->dev
);
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
));
108 put_device(&rmi_dev
->dev
);
111 EXPORT_SYMBOL_GPL(rmi_register_transport_device
);
114 * rmi_unregister_transport_device - unregister a transport device connection
115 * @xport: the transport driver to unregister
118 void rmi_unregister_transport_device(struct rmi_transport_dev
*xport
)
120 struct rmi_device
*rmi_dev
= xport
->rmi_dev
;
122 device_del(&rmi_dev
->dev
);
123 put_device(&rmi_dev
->dev
);
125 EXPORT_SYMBOL(rmi_unregister_transport_device
);
128 /* Function specific stuff */
130 static void rmi_release_function(struct device
*dev
)
132 struct rmi_function
*fn
= to_rmi_function(dev
);
137 static struct device_type rmi_function_type
= {
138 .name
= "rmi4_function",
139 .release
= rmi_release_function
,
142 bool rmi_is_function_device(struct device
*dev
)
144 return dev
->type
== &rmi_function_type
;
147 static int rmi_function_match(struct device
*dev
, struct device_driver
*drv
)
149 struct rmi_function_handler
*handler
= to_rmi_function_handler(drv
);
150 struct rmi_function
*fn
= to_rmi_function(dev
);
152 return fn
->fd
.function_number
== handler
->func
;
156 static void rmi_function_of_probe(struct rmi_function
*fn
)
159 struct device_node
*node
= fn
->rmi_dev
->xport
->dev
->of_node
;
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
);
166 static inline void rmi_function_of_probe(struct rmi_function
*fn
)
170 static int rmi_function_probe(struct device
*dev
)
172 struct rmi_function
*fn
= to_rmi_function(dev
);
173 struct rmi_function_handler
*handler
=
174 to_rmi_function_handler(dev
->driver
);
177 rmi_function_of_probe(fn
);
179 if (handler
->probe
) {
180 error
= handler
->probe(fn
);
187 static int rmi_function_remove(struct device
*dev
)
189 struct rmi_function
*fn
= to_rmi_function(dev
);
190 struct rmi_function_handler
*handler
=
191 to_rmi_function_handler(dev
->driver
);
199 int rmi_register_function(struct rmi_function
*fn
)
201 struct rmi_device
*rmi_dev
= fn
->rmi_dev
;
204 device_initialize(&fn
->dev
);
206 dev_set_name(&fn
->dev
, "%s.fn%02x",
207 dev_name(&rmi_dev
->dev
), fn
->fd
.function_number
);
209 fn
->dev
.parent
= &rmi_dev
->dev
;
210 fn
->dev
.type
= &rmi_function_type
;
211 fn
->dev
.bus
= &rmi_bus_type
;
213 error
= device_add(&fn
->dev
);
215 dev_err(&rmi_dev
->dev
,
216 "Failed device_register function device %s\n",
221 rmi_dbg(RMI_DEBUG_CORE
, &rmi_dev
->dev
, "Registered F%02X.\n",
222 fn
->fd
.function_number
);
227 put_device(&fn
->dev
);
231 void rmi_unregister_function(struct rmi_function
*fn
)
233 device_del(&fn
->dev
);
234 of_node_put(fn
->dev
.of_node
);
235 put_device(&fn
->dev
);
239 * rmi_register_function_handler - register a handler for an RMI function
240 * @handler: RMI handler that should be registered.
241 * @module: pointer to module that implements the handler
242 * @mod_name: name of the module implementing the handler
244 * This function performs additional setup of RMI function handler and
245 * registers it with the RMI core so that it can be bound to
246 * RMI function devices.
248 int __rmi_register_function_handler(struct rmi_function_handler
*handler
,
249 struct module
*owner
,
250 const char *mod_name
)
252 struct device_driver
*driver
= &handler
->driver
;
255 driver
->bus
= &rmi_bus_type
;
256 driver
->owner
= owner
;
257 driver
->mod_name
= mod_name
;
258 driver
->probe
= rmi_function_probe
;
259 driver
->remove
= rmi_function_remove
;
261 error
= driver_register(&handler
->driver
);
263 pr_err("driver_register() failed for %s, error: %d\n",
264 handler
->driver
.name
, error
);
270 EXPORT_SYMBOL_GPL(__rmi_register_function_handler
);
273 * rmi_unregister_function_handler - unregister given RMI function handler
274 * @handler: RMI handler that should be unregistered.
276 * This function unregisters given function handler from RMI core which
277 * causes it to be unbound from the function devices.
279 void rmi_unregister_function_handler(struct rmi_function_handler
*handler
)
281 driver_unregister(&handler
->driver
);
283 EXPORT_SYMBOL_GPL(rmi_unregister_function_handler
);
285 /* Bus specific stuff */
287 static int rmi_bus_match(struct device
*dev
, struct device_driver
*drv
)
289 bool physical
= rmi_is_physical_device(dev
);
291 /* First see if types are not compatible */
292 if (physical
!= rmi_is_physical_driver(drv
))
295 return physical
|| rmi_function_match(dev
, drv
);
298 struct bus_type rmi_bus_type
= {
299 .match
= rmi_bus_match
,
303 static struct rmi_function_handler
*fn_handlers
[] = {
305 #ifdef CONFIG_RMI4_F11
308 #ifdef CONFIG_RMI4_F12
311 #ifdef CONFIG_RMI4_F30
314 #ifdef CONFIG_RMI4_F54
319 static void __rmi_unregister_function_handlers(int start_idx
)
323 for (i
= start_idx
; i
>= 0; i
--)
324 rmi_unregister_function_handler(fn_handlers
[i
]);
327 static void rmi_unregister_function_handlers(void)
329 __rmi_unregister_function_handlers(ARRAY_SIZE(fn_handlers
) - 1);
332 static int rmi_register_function_handlers(void)
337 for (i
= 0; i
< ARRAY_SIZE(fn_handlers
); i
++) {
338 ret
= rmi_register_function_handler(fn_handlers
[i
]);
340 pr_err("%s: error registering the RMI F%02x handler: %d\n",
341 __func__
, fn_handlers
[i
]->func
, ret
);
342 goto err_unregister_function_handlers
;
348 err_unregister_function_handlers
:
349 __rmi_unregister_function_handlers(i
- 1);
353 int rmi_of_property_read_u32(struct device
*dev
, u32
*result
,
354 const char *prop
, bool optional
)
359 retval
= of_property_read_u32(dev
->of_node
, prop
, &val
);
360 if (retval
&& (!optional
&& retval
== -EINVAL
)) {
361 dev_err(dev
, "Failed to get %s value: %d\n",
369 EXPORT_SYMBOL_GPL(rmi_of_property_read_u32
);
371 static int __init
rmi_bus_init(void)
375 error
= bus_register(&rmi_bus_type
);
377 pr_err("%s: error registering the RMI bus: %d\n",
382 error
= rmi_register_function_handlers();
384 goto err_unregister_bus
;
386 error
= rmi_register_physical_driver();
388 pr_err("%s: error registering the RMI physical driver: %d\n",
390 goto err_unregister_bus
;
396 bus_unregister(&rmi_bus_type
);
399 module_init(rmi_bus_init
);
401 static void __exit
rmi_bus_exit(void)
404 * We should only ever get here if all drivers are unloaded, so
405 * all we have to do at this point is unregister ourselves.
408 rmi_unregister_physical_driver();
409 rmi_unregister_function_handlers();
410 bus_unregister(&rmi_bus_type
);
412 module_exit(rmi_bus_exit
);
414 MODULE_AUTHOR("Christopher Heiny <cheiny@synaptics.com");
415 MODULE_AUTHOR("Andrew Duggan <aduggan@synaptics.com");
416 MODULE_DESCRIPTION("RMI bus");
417 MODULE_LICENSE("GPL");
418 MODULE_VERSION(RMI_DRIVER_VERSION
);