summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--drivers/input/Kconfig2
-rw-r--r--drivers/input/Makefile2
-rw-r--r--drivers/input/rmi4/Kconfig10
-rw-r--r--drivers/input/rmi4/Makefile2
-rw-r--r--drivers/input/rmi4/rmi_bus.c375
-rw-r--r--drivers/input/rmi4/rmi_bus.h186
-rw-r--r--drivers/input/rmi4/rmi_driver.c1027
-rw-r--r--drivers/input/rmi4/rmi_driver.h103
-rw-r--r--drivers/input/rmi4/rmi_f01.c574
-rw-r--r--include/linux/rmi.h209
-rw-r--r--include/uapi/linux/input.h1
11 files changed, 2491 insertions, 0 deletions
diff --git a/drivers/input/Kconfig b/drivers/input/Kconfig
index a35532ec00e4..6261874c07c9 100644
--- a/drivers/input/Kconfig
+++ b/drivers/input/Kconfig
@@ -201,6 +201,8 @@ source "drivers/input/touchscreen/Kconfig"
201 201
202source "drivers/input/misc/Kconfig" 202source "drivers/input/misc/Kconfig"
203 203
204source "drivers/input/rmi4/Kconfig"
205
204endif 206endif
205 207
206menu "Hardware I/O ports" 208menu "Hardware I/O ports"
diff --git a/drivers/input/Makefile b/drivers/input/Makefile
index 0c9302ca9954..595820bbabe9 100644
--- a/drivers/input/Makefile
+++ b/drivers/input/Makefile
@@ -26,3 +26,5 @@ obj-$(CONFIG_INPUT_TOUCHSCREEN) += touchscreen/
26obj-$(CONFIG_INPUT_MISC) += misc/ 26obj-$(CONFIG_INPUT_MISC) += misc/
27 27
28obj-$(CONFIG_INPUT_APMPOWER) += apm-power.o 28obj-$(CONFIG_INPUT_APMPOWER) += apm-power.o
29
30obj-$(CONFIG_RMI4_CORE) += rmi4/
diff --git a/drivers/input/rmi4/Kconfig b/drivers/input/rmi4/Kconfig
new file mode 100644
index 000000000000..5ea60e338093
--- /dev/null
+++ b/drivers/input/rmi4/Kconfig
@@ -0,0 +1,10 @@
1#
2# RMI4 configuration
3#
4config RMI4_CORE
5 tristate "Synaptics RMI4 bus support"
6 help
7 Say Y here if you want to support the Synaptics RMI4 bus. This is
8 required for all RMI4 device support.
9
10 If unsure, say Y.
diff --git a/drivers/input/rmi4/Makefile b/drivers/input/rmi4/Makefile
new file mode 100644
index 000000000000..12f219779b74
--- /dev/null
+++ b/drivers/input/rmi4/Makefile
@@ -0,0 +1,2 @@
1obj-$(CONFIG_RMI4_CORE) += rmi_core.o
2rmi_core-y := rmi_bus.o rmi_driver.o rmi_f01.o
diff --git a/drivers/input/rmi4/rmi_bus.c b/drivers/input/rmi4/rmi_bus.c
new file mode 100644
index 000000000000..0a2bd5a0f2b7
--- /dev/null
+++ b/drivers/input/rmi4/rmi_bus.c
@@ -0,0 +1,375 @@
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>
12#include <linux/kconfig.h>
13#include <linux/list.h>
14#include <linux/pm.h>
15#include <linux/rmi.h>
16#include <linux/slab.h>
17#include <linux/types.h>
18#include <linux/of.h>
19#include "rmi_bus.h"
20#include "rmi_driver.h"
21
22static int debug_flags;
23module_param(debug_flags, int, 0644);
24MODULE_PARM_DESC(debug_flags, "control debugging information");
25
26void rmi_dbg(int flags, struct device *dev, const char *fmt, ...)
27{
28 struct va_format vaf;
29 va_list args;
30
31 if (flags & debug_flags) {
32 va_start(args, fmt);
33
34 vaf.fmt = fmt;
35 vaf.va = &args;
36
37 dev_printk(KERN_DEBUG, dev, "%pV", &vaf);
38
39 va_end(args);
40 }
41}
42EXPORT_SYMBOL_GPL(rmi_dbg);
43
44/*
45 * RMI Physical devices
46 *
47 * Physical RMI device consists of several functions serving particular
48 * purpose. For example F11 is a 2D touch sensor while F01 is a generic
49 * function present in every RMI device.
50 */
51
52static void rmi_release_device(struct device *dev)
53{
54 struct rmi_device *rmi_dev = to_rmi_device(dev);
55
56 kfree(rmi_dev);
57}
58
59static struct device_type rmi_device_type = {
60 .name = "rmi4_sensor",
61 .release = rmi_release_device,
62};
63
64bool rmi_is_physical_device(struct device *dev)
65{
66 return dev->type == &rmi_device_type;
67}
68
69/**
70 * rmi_register_transport_device - register a transport device connection
71 * on the RMI bus. Transport drivers provide communication from the devices
72 * on a bus (such as SPI, I2C, and so on) to the RMI4 sensor.
73 *
74 * @xport: the transport device to register
75 */
76int rmi_register_transport_device(struct rmi_transport_dev *xport)
77{
78 static atomic_t transport_device_count = ATOMIC_INIT(0);
79 struct rmi_device *rmi_dev;
80 int error;
81
82 rmi_dev = kzalloc(sizeof(struct rmi_device), GFP_KERNEL);
83 if (!rmi_dev)
84 return -ENOMEM;
85
86 device_initialize(&rmi_dev->dev);
87
88 rmi_dev->xport = xport;
89 rmi_dev->number = atomic_inc_return(&transport_device_count) - 1;
90
91 dev_set_name(&rmi_dev->dev, "rmi4-%02d", rmi_dev->number);
92
93 rmi_dev->dev.bus = &rmi_bus_type;
94 rmi_dev->dev.type = &rmi_device_type;
95
96 xport->rmi_dev = rmi_dev;
97
98 error = device_add(&rmi_dev->dev);
99 if (error)
100 goto err_put_device;
101
102 rmi_dbg(RMI_DEBUG_CORE, xport->dev,
103 "%s: Registered %s as %s.\n", __func__,
104 dev_name(rmi_dev->xport->dev), dev_name(&rmi_dev->dev));
105
106 return 0;
107
108err_put_device:
109 put_device(&rmi_dev->dev);
110 return error;
111}
112EXPORT_SYMBOL_GPL(rmi_register_transport_device);
113
114/**
115 * rmi_unregister_transport_device - unregister a transport device connection
116 * @xport: the transport driver to unregister
117 *
118 */
119void rmi_unregister_transport_device(struct rmi_transport_dev *xport)
120{
121 struct rmi_device *rmi_dev = xport->rmi_dev;
122
123 device_del(&rmi_dev->dev);
124 put_device(&rmi_dev->dev);
125}
126EXPORT_SYMBOL(rmi_unregister_transport_device);
127
128
129/* Function specific stuff */
130
131static void rmi_release_function(struct device *dev)
132{
133 struct rmi_function *fn = to_rmi_function(dev);
134
135 kfree(fn);
136}
137
138static struct device_type rmi_function_type = {
139 .name = "rmi4_function",
140 .release = rmi_release_function,
141};
142
143bool rmi_is_function_device(struct device *dev)
144{
145 return dev->type == &rmi_function_type;
146}
147
148static int rmi_function_match(struct device *dev, struct device_driver *drv)
149{
150 struct rmi_function_handler *handler = to_rmi_function_handler(drv);
151 struct rmi_function *fn = to_rmi_function(dev);
152
153 return fn->fd.function_number == handler->func;
154}
155
156static int rmi_function_probe(struct device *dev)
157{
158 struct rmi_function *fn = to_rmi_function(dev);
159 struct rmi_function_handler *handler =
160 to_rmi_function_handler(dev->driver);
161 int error;
162
163 if (handler->probe) {
164 error = handler->probe(fn);
165 return error;
166 }
167
168 return 0;
169}
170
171static int rmi_function_remove(struct device *dev)
172{
173 struct rmi_function *fn = to_rmi_function(dev);
174 struct rmi_function_handler *handler =
175 to_rmi_function_handler(dev->driver);
176
177 if (handler->remove)
178 handler->remove(fn);
179
180 return 0;
181}
182
183int rmi_register_function(struct rmi_function *fn)
184{
185 struct rmi_device *rmi_dev = fn->rmi_dev;
186 int error;
187
188 device_initialize(&fn->dev);
189
190 dev_set_name(&fn->dev, "%s.fn%02x",
191 dev_name(&rmi_dev->dev), fn->fd.function_number);
192
193 fn->dev.parent = &rmi_dev->dev;
194 fn->dev.type = &rmi_function_type;
195 fn->dev.bus = &rmi_bus_type;
196
197 error = device_add(&fn->dev);
198 if (error) {
199 dev_err(&rmi_dev->dev,
200 "Failed device_register function device %s\n",
201 dev_name(&fn->dev));
202 goto err_put_device;
203 }
204
205 rmi_dbg(RMI_DEBUG_CORE, &rmi_dev->dev, "Registered F%02X.\n",
206 fn->fd.function_number);
207
208 return 0;
209
210err_put_device:
211 put_device(&fn->dev);
212 return error;
213}
214
215void rmi_unregister_function(struct rmi_function *fn)
216{
217 device_del(&fn->dev);
218
219 if (fn->dev.of_node)
220 of_node_put(fn->dev.of_node);
221
222 put_device(&fn->dev);
223}
224
225/**
226 * rmi_register_function_handler - register a handler for an RMI function
227 * @handler: RMI handler that should be registered.
228 * @module: pointer to module that implements the handler
229 * @mod_name: name of the module implementing the handler
230 *
231 * This function performs additional setup of RMI function handler and
232 * registers it with the RMI core so that it can be bound to
233 * RMI function devices.
234 */
235int __rmi_register_function_handler(struct rmi_function_handler *handler,
236 struct module *owner,
237 const char *mod_name)
238{
239 struct device_driver *driver = &handler->driver;
240 int error;
241
242 driver->bus = &rmi_bus_type;
243 driver->owner = owner;
244 driver->mod_name = mod_name;
245 driver->probe = rmi_function_probe;
246 driver->remove = rmi_function_remove;
247
248 error = driver_register(&handler->driver);
249 if (error) {
250 pr_err("driver_register() failed for %s, error: %d\n",
251 handler->driver.name, error);
252 return error;
253 }
254
255 return 0;
256}
257EXPORT_SYMBOL_GPL(__rmi_register_function_handler);
258
259/**
260 * rmi_unregister_function_handler - unregister given RMI function handler
261 * @handler: RMI handler that should be unregistered.
262 *
263 * This function unregisters given function handler from RMI core which
264 * causes it to be unbound from the function devices.
265 */
266void rmi_unregister_function_handler(struct rmi_function_handler *handler)
267{
268 driver_unregister(&handler->driver);
269}
270EXPORT_SYMBOL_GPL(rmi_unregister_function_handler);
271
272/* Bus specific stuff */
273
274static int rmi_bus_match(struct device *dev, struct device_driver *drv)
275{
276 bool physical = rmi_is_physical_device(dev);
277
278 /* First see if types are not compatible */
279 if (physical != rmi_is_physical_driver(drv))
280 return 0;
281
282 return physical || rmi_function_match(dev, drv);
283}
284
285struct bus_type rmi_bus_type = {
286 .match = rmi_bus_match,
287 .name = "rmi4",
288};
289
290static struct rmi_function_handler *fn_handlers[] = {
291 &rmi_f01_handler,
292};
293
294static void __rmi_unregister_function_handlers(int start_idx)
295{
296 int i;
297
298 for (i = start_idx; i >= 0; i--)
299 rmi_unregister_function_handler(fn_handlers[i]);
300}
301
302static void rmi_unregister_function_handlers(void)
303{
304 __rmi_unregister_function_handlers(ARRAY_SIZE(fn_handlers) - 1);
305}
306
307static int rmi_register_function_handlers(void)
308{
309 int ret;
310 int i;
311
312 for (i = 0; i < ARRAY_SIZE(fn_handlers); i++) {
313 ret = rmi_register_function_handler(fn_handlers[i]);
314 if (ret) {
315 pr_err("%s: error registering the RMI F%02x handler: %d\n",
316 __func__, fn_handlers[i]->func, ret);
317 goto err_unregister_function_handlers;
318 }
319 }
320
321 return 0;
322
323err_unregister_function_handlers:
324 __rmi_unregister_function_handlers(i - 1);
325 return ret;
326}
327
328static int __init rmi_bus_init(void)
329{
330 int error;
331
332 error = bus_register(&rmi_bus_type);
333 if (error) {
334 pr_err("%s: error registering the RMI bus: %d\n",
335 __func__, error);
336 return error;
337 }
338
339 error = rmi_register_function_handlers();
340 if (error)
341 goto err_unregister_bus;
342
343 error = rmi_register_physical_driver();
344 if (error) {
345 pr_err("%s: error registering the RMI physical driver: %d\n",
346 __func__, error);
347 goto err_unregister_bus;
348 }
349
350 return 0;
351
352err_unregister_bus:
353 bus_unregister(&rmi_bus_type);
354 return error;
355}
356module_init(rmi_bus_init);
357
358static void __exit rmi_bus_exit(void)
359{
360 /*
361 * We should only ever get here if all drivers are unloaded, so
362 * all we have to do at this point is unregister ourselves.
363 */
364
365 rmi_unregister_physical_driver();
366 rmi_unregister_function_handlers();
367 bus_unregister(&rmi_bus_type);
368}
369module_exit(rmi_bus_exit);
370
371MODULE_AUTHOR("Christopher Heiny <cheiny@synaptics.com");
372MODULE_AUTHOR("Andrew Duggan <aduggan@synaptics.com");
373MODULE_DESCRIPTION("RMI bus");
374MODULE_LICENSE("GPL");
375MODULE_VERSION(RMI_DRIVER_VERSION);
diff --git a/drivers/input/rmi4/rmi_bus.h b/drivers/input/rmi4/rmi_bus.h
new file mode 100644
index 000000000000..13b148d44b37
--- /dev/null
+++ b/drivers/input/rmi4/rmi_bus.h
@@ -0,0 +1,186 @@
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#ifndef _RMI_BUS_H
11#define _RMI_BUS_H
12
13#include <linux/rmi.h>
14
15struct rmi_device;
16
17/**
18 * struct rmi_function - represents the implementation of an RMI4
19 * function for a particular device (basically, a driver for that RMI4 function)
20 *
21 * @fd: The function descriptor of the RMI function
22 * @rmi_dev: Pointer to the RMI device associated with this function container
23 * @dev: The device associated with this particular function.
24 *
25 * @num_of_irqs: The number of irqs needed by this function
26 * @irq_pos: The position in the irq bitfield this function holds
27 * @irq_mask: For convenience, can be used to mask IRQ bits off during ATTN
28 * interrupt handling.
29 *
30 * @node: entry in device's list of functions
31 */
32struct rmi_function {
33 struct rmi_function_descriptor fd;
34 struct rmi_device *rmi_dev;
35 struct device dev;
36 struct list_head node;
37
38 unsigned int num_of_irqs;
39 unsigned int irq_pos;
40 unsigned long irq_mask[];
41};
42
43#define to_rmi_function(d) container_of(d, struct rmi_function, dev)
44
45bool rmi_is_function_device(struct device *dev);
46
47int __must_check rmi_register_function(struct rmi_function *);
48void rmi_unregister_function(struct rmi_function *);
49
50/**
51 * struct rmi_function_handler - driver routines for a particular RMI function.
52 *
53 * @func: The RMI function number
54 * @reset: Called when a reset of the touch sensor is detected. The routine
55 * should perform any out-of-the-ordinary reset handling that might be
56 * necessary. Restoring of touch sensor configuration registers should be
57 * handled in the config() callback, below.
58 * @config: Called when the function container is first initialized, and
59 * after a reset is detected. This routine should write any necessary
60 * configuration settings to the device.
61 * @attention: Called when the IRQ(s) for the function are set by the touch
62 * sensor.
63 * @suspend: Should perform any required operations to suspend the particular
64 * function.
65 * @resume: Should perform any required operations to resume the particular
66 * function.
67 *
68 * All callbacks are expected to return 0 on success, error code on failure.
69 */
70struct rmi_function_handler {
71 struct device_driver driver;
72
73 u8 func;
74
75 int (*probe)(struct rmi_function *fn);
76 void (*remove)(struct rmi_function *fn);
77 int (*config)(struct rmi_function *fn);
78 int (*reset)(struct rmi_function *fn);
79 int (*attention)(struct rmi_function *fn, unsigned long *irq_bits);
80 int (*suspend)(struct rmi_function *fn);
81 int (*resume)(struct rmi_function *fn);
82};
83
84#define to_rmi_function_handler(d) \
85 container_of(d, struct rmi_function_handler, driver)
86
87int __must_check __rmi_register_function_handler(struct rmi_function_handler *,
88 struct module *, const char *);
89#define rmi_register_function_handler(handler) \
90 __rmi_register_function_handler(handler, THIS_MODULE, KBUILD_MODNAME)
91
92void rmi_unregister_function_handler(struct rmi_function_handler *);
93
94#define to_rmi_driver(d) \
95 container_of(d, struct rmi_driver, driver)
96
97#define to_rmi_device(d) container_of(d, struct rmi_device, dev)
98
99static inline struct rmi_device_platform_data *
100rmi_get_platform_data(struct rmi_device *d)
101{
102 return &d->xport->pdata;
103}
104
105bool rmi_is_physical_device(struct device *dev);
106
107/**
108 * rmi_read - read a single byte
109 * @d: Pointer to an RMI device
110 * @addr: The address to read from
111 * @buf: The read buffer
112 *
113 * Reads a single byte of data using the underlying transport protocol
114 * into memory pointed by @buf. It returns 0 on success or a negative
115 * error code.
116 */
117static inline int rmi_read(struct rmi_device *d, u16 addr, u8 *buf)
118{
119 return d->xport->ops->read_block(d->xport, addr, buf, 1);
120}
121
122/**
123 * rmi_read_block - read a block of bytes
124 * @d: Pointer to an RMI device
125 * @addr: The start address to read from
126 * @buf: The read buffer
127 * @len: Length of the read buffer
128 *
129 * Reads a block of byte data using the underlying transport protocol
130 * into memory pointed by @buf. It returns 0 on success or a negative
131 * error code.
132 */
133static inline int rmi_read_block(struct rmi_device *d, u16 addr,
134 void *buf, size_t len)
135{
136 return d->xport->ops->read_block(d->xport, addr, buf, len);
137}
138
139/**
140 * rmi_write - write a single byte
141 * @d: Pointer to an RMI device
142 * @addr: The address to write to
143 * @data: The data to write
144 *
145 * Writes a single byte using the underlying transport protocol. It
146 * returns zero on success or a negative error code.
147 */
148static inline int rmi_write(struct rmi_device *d, u16 addr, u8 data)
149{
150 return d->xport->ops->write_block(d->xport, addr, &data, 1);
151}
152
153/**
154 * rmi_write_block - write a block of bytes
155 * @d: Pointer to an RMI device
156 * @addr: The start address to write to
157 * @buf: The write buffer
158 * @len: Length of the write buffer
159 *
160 * Writes a block of byte data from buf using the underlaying transport
161 * protocol. It returns the amount of bytes written or a negative error code.
162 */
163static inline int rmi_write_block(struct rmi_device *d, u16 addr,
164 const void *buf, size_t len)
165{
166 return d->xport->ops->write_block(d->xport, addr, buf, len);
167}
168
169int rmi_for_each_dev(void *data, int (*func)(struct device *dev, void *data));
170
171extern struct bus_type rmi_bus_type;
172
173int rmi_of_property_read_u32(struct device *dev, u32 *result,
174 const char *prop, bool optional);
175int rmi_of_property_read_u16(struct device *dev, u16 *result,
176 const char *prop, bool optional);
177int rmi_of_property_read_u8(struct device *dev, u8 *result,
178 const char *prop, bool optional);
179
180#define RMI_DEBUG_CORE BIT(0)
181#define RMI_DEBUG_XPORT BIT(1)
182#define RMI_DEBUG_FN BIT(2)
183#define RMI_DEBUG_2D_SENSOR BIT(3)
184
185void rmi_dbg(int flags, struct device *dev, const char *fmt, ...);
186#endif
diff --git a/drivers/input/rmi4/rmi_driver.c b/drivers/input/rmi4/rmi_driver.c
new file mode 100644
index 000000000000..b0f34b57a126
--- /dev/null
+++ b/drivers/input/rmi4/rmi_driver.c
@@ -0,0 +1,1027 @@
1/*
2 * Copyright (c) 2011-2016 Synaptics Incorporated
3 * Copyright (c) 2011 Unixphere
4 *
5 * This driver provides the core support for a single RMI4-based device.
6 *
7 * The RMI4 specification can be found here (URL split for line length):
8 *
9 * http://www.synaptics.com/sites/default/files/
10 * 511-000136-01-Rev-E-RMI4-Interfacing-Guide.pdf
11 *
12 * This program is free software; you can redistribute it and/or modify it
13 * under the terms of the GNU General Public License version 2 as published by
14 * the Free Software Foundation.
15 */
16
17#include <linux/bitmap.h>
18#include <linux/delay.h>
19#include <linux/fs.h>
20#include <linux/kconfig.h>
21#include <linux/pm.h>
22#include <linux/slab.h>
23#include <uapi/linux/input.h>
24#include <linux/rmi.h>
25#include "rmi_bus.h"
26#include "rmi_driver.h"
27
28#define HAS_NONSTANDARD_PDT_MASK 0x40
29#define RMI4_MAX_PAGE 0xff
30#define RMI4_PAGE_SIZE 0x100
31#define RMI4_PAGE_MASK 0xFF00
32
33#define RMI_DEVICE_RESET_CMD 0x01
34#define DEFAULT_RESET_DELAY_MS 100
35
36static void rmi_free_function_list(struct rmi_device *rmi_dev)
37{
38 struct rmi_function *fn, *tmp;
39 struct rmi_driver_data *data = dev_get_drvdata(&rmi_dev->dev);
40
41 data->f01_container = NULL;
42
43 /* Doing it in the reverse order so F01 will be removed last */
44 list_for_each_entry_safe_reverse(fn, tmp,
45 &data->function_list, node) {
46 list_del(&fn->node);
47 rmi_unregister_function(fn);
48 }
49}
50
51static int reset_one_function(struct rmi_function *fn)
52{
53 struct rmi_function_handler *fh;
54 int retval = 0;
55
56 if (!fn || !fn->dev.driver)
57 return 0;
58
59 fh = to_rmi_function_handler(fn->dev.driver);
60 if (fh->reset) {
61 retval = fh->reset(fn);
62 if (retval < 0)
63 dev_err(&fn->dev, "Reset failed with code %d.\n",
64 retval);
65 }
66
67 return retval;
68}
69
70static int configure_one_function(struct rmi_function *fn)
71{
72 struct rmi_function_handler *fh;
73 int retval = 0;
74
75 if (!fn || !fn->dev.driver)
76 return 0;
77
78 fh = to_rmi_function_handler(fn->dev.driver);
79 if (fh->config) {
80 retval = fh->config(fn);
81 if (retval < 0)
82 dev_err(&fn->dev, "Config failed with code %d.\n",
83 retval);
84 }
85
86 return retval;
87}
88
89static int rmi_driver_process_reset_requests(struct rmi_device *rmi_dev)
90{
91 struct rmi_driver_data *data = dev_get_drvdata(&rmi_dev->dev);
92 struct rmi_function *entry;
93 int retval;
94
95 list_for_each_entry(entry, &data->function_list, node) {
96 retval = reset_one_function(entry);
97 if (retval < 0)
98 return retval;
99 }
100
101 return 0;
102}
103
104static int rmi_driver_process_config_requests(struct rmi_device *rmi_dev)
105{
106 struct rmi_driver_data *data = dev_get_drvdata(&rmi_dev->dev);
107 struct rmi_function *entry;
108 int retval;
109
110 list_for_each_entry(entry, &data->function_list, node) {
111 retval = configure_one_function(entry);
112 if (retval < 0)
113 return retval;
114 }
115
116 return 0;
117}
118
119static void process_one_interrupt(struct rmi_driver_data *data,
120 struct rmi_function *fn)
121{
122 struct rmi_function_handler *fh;
123
124 if (!fn || !fn->dev.driver)
125 return;
126
127 fh = to_rmi_function_handler(fn->dev.driver);
128 if (fn->irq_mask && fh->attention) {
129 bitmap_and(data->fn_irq_bits, data->irq_status, fn->irq_mask,
130 data->irq_count);
131 if (!bitmap_empty(data->fn_irq_bits, data->irq_count))
132 fh->attention(fn, data->fn_irq_bits);
133 }
134}
135
136int rmi_process_interrupt_requests(struct rmi_device *rmi_dev)
137{
138 struct rmi_driver_data *data = dev_get_drvdata(&rmi_dev->dev);
139 struct device *dev = &rmi_dev->dev;
140 struct rmi_function *entry;
141 int error;
142
143 if (!data)
144 return 0;
145
146 if (!rmi_dev->xport->attn_data) {
147 error = rmi_read_block(rmi_dev,
148 data->f01_container->fd.data_base_addr + 1,
149 data->irq_status, data->num_of_irq_regs);
150 if (error < 0) {
151 dev_err(dev, "Failed to read irqs, code=%d\n", error);
152 return error;
153 }
154 }
155
156 mutex_lock(&data->irq_mutex);
157 bitmap_and(data->irq_status, data->irq_status, data->current_irq_mask,
158 data->irq_count);
159 /*
160 * At this point, irq_status has all bits that are set in the
161 * interrupt status register and are enabled.
162 */
163 mutex_unlock(&data->irq_mutex);
164
165 /*
166 * It would be nice to be able to use irq_chip to handle these
167 * nested IRQs. Unfortunately, most of the current customers for
168 * this driver are using older kernels (3.0.x) that don't support
169 * the features required for that. Once they've shifted to more
170 * recent kernels (say, 3.3 and higher), this should be switched to
171 * use irq_chip.
172 */
173 list_for_each_entry(entry, &data->function_list, node)
174 if (entry->irq_mask)
175 process_one_interrupt(data, entry);
176
177 if (data->input)
178 input_sync(data->input);
179
180 return 0;
181}
182EXPORT_SYMBOL_GPL(rmi_process_interrupt_requests);
183
184static int suspend_one_function(struct rmi_function *fn)
185{
186 struct rmi_function_handler *fh;
187 int retval = 0;
188
189 if (!fn || !fn->dev.driver)
190 return 0;
191
192 fh = to_rmi_function_handler(fn->dev.driver);
193 if (fh->suspend) {
194 retval = fh->suspend(fn);
195 if (retval < 0)
196 dev_err(&fn->dev, "Suspend failed with code %d.\n",
197 retval);
198 }
199
200 return retval;
201}
202
203static int rmi_suspend_functions(struct rmi_device *rmi_dev)
204{
205 struct rmi_driver_data *data = dev_get_drvdata(&rmi_dev->dev);
206 struct rmi_function *entry;
207 int retval;
208
209 list_for_each_entry(entry, &data->function_list, node) {
210 retval = suspend_one_function(entry);
211 if (retval < 0)
212 return retval;
213 }
214
215 return 0;
216}
217
218static int resume_one_function(struct rmi_function *fn)
219{
220 struct rmi_function_handler *fh;
221 int retval = 0;
222
223 if (!fn || !fn->dev.driver)
224 return 0;
225
226 fh = to_rmi_function_handler(fn->dev.driver);
227 if (fh->resume) {
228 retval = fh->resume(fn);
229 if (retval < 0)
230 dev_err(&fn->dev, "Resume failed with code %d.\n",
231 retval);
232 }
233
234 return retval;
235}
236
237static int rmi_resume_functions(struct rmi_device *rmi_dev)
238{
239 struct rmi_driver_data *data = dev_get_drvdata(&rmi_dev->dev);
240 struct rmi_function *entry;
241 int retval;
242
243 list_for_each_entry(entry, &data->function_list, node) {
244 retval = resume_one_function(entry);
245 if (retval < 0)
246 return retval;
247 }
248
249 return 0;
250}
251
252static int enable_sensor(struct rmi_device *rmi_dev)
253{
254 int retval = 0;
255
256 retval = rmi_driver_process_config_requests(rmi_dev);
257 if (retval < 0)
258 return retval;
259
260 return rmi_process_interrupt_requests(rmi_dev);
261}
262
263/**
264 * rmi_driver_set_input_params - set input device id and other data.
265 *
266 * @rmi_dev: Pointer to an RMI device
267 * @input: Pointer to input device
268 *
269 */
270static int rmi_driver_set_input_params(struct rmi_device *rmi_dev,
271 struct input_dev *input)
272{
273 input->name = SYNAPTICS_INPUT_DEVICE_NAME;
274 input->id.vendor = SYNAPTICS_VENDOR_ID;
275 input->id.bustype = BUS_RMI;
276 return 0;
277}
278
279static void rmi_driver_set_input_name(struct rmi_device *rmi_dev,
280 struct input_dev *input)
281{
282 struct rmi_driver_data *data = dev_get_drvdata(&rmi_dev->dev);
283 char *device_name = rmi_f01_get_product_ID(data->f01_container);
284 char *name;
285
286 name = devm_kasprintf(&rmi_dev->dev, GFP_KERNEL,
287 "Synaptics %s", device_name);
288 if (!name)
289 return;
290
291 input->name = name;
292}
293
294static int rmi_driver_set_irq_bits(struct rmi_device *rmi_dev,
295 unsigned long *mask)
296{
297 int error = 0;
298 struct rmi_driver_data *data = dev_get_drvdata(&rmi_dev->dev);
299 struct device *dev = &rmi_dev->dev;
300
301 mutex_lock(&data->irq_mutex);
302 bitmap_or(data->new_irq_mask,
303 data->current_irq_mask, mask, data->irq_count);
304
305 error = rmi_write_block(rmi_dev,
306 data->f01_container->fd.control_base_addr + 1,
307 data->new_irq_mask, data->num_of_irq_regs);
308 if (error < 0) {
309 dev_err(dev, "%s: Failed to change enabled interrupts!",
310 __func__);
311 goto error_unlock;
312 }
313 bitmap_copy(data->current_irq_mask, data->new_irq_mask,
314 data->num_of_irq_regs);
315
316error_unlock:
317 mutex_unlock(&data->irq_mutex);
318 return error;
319}
320
321static int rmi_driver_clear_irq_bits(struct rmi_device *rmi_dev,
322 unsigned long *mask)
323{
324 int error = 0;
325 struct rmi_driver_data *data = dev_get_drvdata(&rmi_dev->dev);
326 struct device *dev = &rmi_dev->dev;
327
328 mutex_lock(&data->irq_mutex);
329 bitmap_andnot(data->new_irq_mask,
330 data->current_irq_mask, mask, data->irq_count);
331
332 error = rmi_write_block(rmi_dev,
333 data->f01_container->fd.control_base_addr + 1,
334 data->new_irq_mask, data->num_of_irq_regs);
335 if (error < 0) {
336 dev_err(dev, "%s: Failed to change enabled interrupts!",
337 __func__);
338 goto error_unlock;
339 }
340 bitmap_copy(data->current_irq_mask, data->new_irq_mask,
341 data->num_of_irq_regs);
342
343error_unlock:
344 mutex_unlock(&data->irq_mutex);
345 return error;
346}
347
348static int rmi_driver_reset_handler(struct rmi_device *rmi_dev)
349{
350 struct rmi_driver_data *data = dev_get_drvdata(&rmi_dev->dev);
351 int error;
352
353 /*
354 * Can get called before the driver is fully ready to deal with
355 * this situation.
356 */
357 if (!data || !data->f01_container) {
358 dev_warn(&rmi_dev->dev,
359 "Not ready to handle reset yet!\n");
360 return 0;
361 }
362
363 error = rmi_read_block(rmi_dev,
364 data->f01_container->fd.control_base_addr + 1,
365 data->current_irq_mask, data->num_of_irq_regs);
366 if (error < 0) {
367 dev_err(&rmi_dev->dev, "%s: Failed to read current IRQ mask.\n",
368 __func__);
369 return error;
370 }
371
372 error = rmi_driver_process_reset_requests(rmi_dev);
373 if (error < 0)
374 return error;
375
376 error = rmi_driver_process_config_requests(rmi_dev);
377 if (error < 0)
378 return error;
379
380 return 0;
381}
382
383int rmi_read_pdt_entry(struct rmi_device *rmi_dev, struct pdt_entry *entry,
384 u16 pdt_address)
385{
386 u8 buf[RMI_PDT_ENTRY_SIZE];
387 int error;
388
389 error = rmi_read_block(rmi_dev, pdt_address, buf, RMI_PDT_ENTRY_SIZE);
390 if (error) {
391 dev_err(&rmi_dev->dev, "Read PDT entry at %#06x failed, code: %d.\n",
392 pdt_address, error);
393 return error;
394 }
395
396 entry->page_start = pdt_address & RMI4_PAGE_MASK;
397 entry->query_base_addr = buf[0];
398 entry->command_base_addr = buf[1];
399 entry->control_base_addr = buf[2];
400 entry->data_base_addr = buf[3];
401 entry->interrupt_source_count = buf[4] & RMI_PDT_INT_SOURCE_COUNT_MASK;
402 entry->function_version = (buf[4] & RMI_PDT_FUNCTION_VERSION_MASK) >> 5;
403 entry->function_number = buf[5];
404
405 return 0;
406}
407EXPORT_SYMBOL_GPL(rmi_read_pdt_entry);
408
409static void rmi_driver_copy_pdt_to_fd(const struct pdt_entry *pdt,
410 struct rmi_function_descriptor *fd)
411{
412 fd->query_base_addr = pdt->query_base_addr + pdt->page_start;
413 fd->command_base_addr = pdt->command_base_addr + pdt->page_start;
414 fd->control_base_addr = pdt->control_base_addr + pdt->page_start;
415 fd->data_base_addr = pdt->data_base_addr + pdt->page_start;
416 fd->function_number = pdt->function_number;
417 fd->interrupt_source_count = pdt->interrupt_source_count;
418 fd->function_version = pdt->function_version;
419}
420
421#define RMI_SCAN_CONTINUE 0
422#define RMI_SCAN_DONE 1
423
424static int rmi_scan_pdt_page(struct rmi_device *rmi_dev,
425 int page,
426 void *ctx,
427 int (*callback)(struct rmi_device *rmi_dev,
428 void *ctx,
429 const struct pdt_entry *entry))
430{
431 struct rmi_driver_data *data = dev_get_drvdata(&rmi_dev->dev);
432 struct pdt_entry pdt_entry;
433 u16 page_start = RMI4_PAGE_SIZE * page;
434 u16 pdt_start = page_start + PDT_START_SCAN_LOCATION;
435 u16 pdt_end = page_start + PDT_END_SCAN_LOCATION;
436 u16 addr;
437 int error;
438 int retval;
439
440 for (addr = pdt_start; addr >= pdt_end; addr -= RMI_PDT_ENTRY_SIZE) {
441 error = rmi_read_pdt_entry(rmi_dev, &pdt_entry, addr);
442 if (error)
443 return error;
444
445 if (RMI4_END_OF_PDT(pdt_entry.function_number))
446 break;
447
448 retval = callback(rmi_dev, ctx, &pdt_entry);
449 if (retval != RMI_SCAN_CONTINUE)
450 return retval;
451 }
452
453 return (data->f01_bootloader_mode || addr == pdt_start) ?
454 RMI_SCAN_DONE : RMI_SCAN_CONTINUE;
455}
456
457static int rmi_scan_pdt(struct rmi_device *rmi_dev, void *ctx,
458 int (*callback)(struct rmi_device *rmi_dev,
459 void *ctx,
460 const struct pdt_entry *entry))
461{
462 int page;
463 int retval = RMI_SCAN_DONE;
464
465 for (page = 0; page <= RMI4_MAX_PAGE; page++) {
466 retval = rmi_scan_pdt_page(rmi_dev, page, ctx, callback);
467 if (retval != RMI_SCAN_CONTINUE)
468 break;
469 }
470
471 return retval < 0 ? retval : 0;
472}
473
474int rmi_read_register_desc(struct rmi_device *d, u16 addr,
475 struct rmi_register_descriptor *rdesc)
476{
477 int ret;
478 u8 size_presence_reg;
479 u8 buf[35];
480 int presense_offset = 1;
481 u8 *struct_buf;
482 int reg;
483 int offset = 0;
484 int map_offset = 0;
485 int i;
486 int b;
487
488 /*
489 * The first register of the register descriptor is the size of
490 * the register descriptor's presense register.
491 */
492 ret = rmi_read(d, addr, &size_presence_reg);
493 if (ret)
494 return ret;
495 ++addr;
496
497 if (size_presence_reg < 0 || size_presence_reg > 35)
498 return -EIO;
499
500 memset(buf, 0, sizeof(buf));
501
502 /*
503 * The presence register contains the size of the register structure
504 * and a bitmap which identified which packet registers are present
505 * for this particular register type (ie query, control, or data).
506 */
507 ret = rmi_read_block(d, addr, buf, size_presence_reg);
508 if (ret)
509 return ret;
510 ++addr;
511
512 if (buf[0] == 0) {
513 presense_offset = 3;
514 rdesc->struct_size = buf[1] | (buf[2] << 8);
515 } else {
516 rdesc->struct_size = buf[0];
517 }
518
519 for (i = presense_offset; i < size_presence_reg; i++) {
520 for (b = 0; b < 8; b++) {
521 if (buf[i] & (0x1 << b))
522 bitmap_set(rdesc->presense_map, map_offset, 1);
523 ++map_offset;
524 }
525 }
526
527 rdesc->num_registers = bitmap_weight(rdesc->presense_map,
528 RMI_REG_DESC_PRESENSE_BITS);
529
530 rdesc->registers = devm_kzalloc(&d->dev, rdesc->num_registers *
531 sizeof(struct rmi_register_desc_item),
532 GFP_KERNEL);
533 if (!rdesc->registers)
534 return -ENOMEM;
535
536 /*
537 * Allocate a temporary buffer to hold the register structure.
538 * I'm not using devm_kzalloc here since it will not be retained
539 * after exiting this function
540 */
541 struct_buf = kzalloc(rdesc->struct_size, GFP_KERNEL);
542 if (!struct_buf)
543 return -ENOMEM;
544
545 /*
546 * The register structure contains information about every packet
547 * register of this type. This includes the size of the packet
548 * register and a bitmap of all subpackets contained in the packet
549 * register.
550 */
551 ret = rmi_read_block(d, addr, struct_buf, rdesc->struct_size);
552 if (ret)
553 goto free_struct_buff;
554
555 reg = find_first_bit(rdesc->presense_map, RMI_REG_DESC_PRESENSE_BITS);
556 map_offset = 0;
557 for (i = 0; i < rdesc->num_registers; i++) {
558 struct rmi_register_desc_item *item = &rdesc->registers[i];
559 int reg_size = struct_buf[offset];
560
561 ++offset;
562 if (reg_size == 0) {
563 reg_size = struct_buf[offset] |
564 (struct_buf[offset + 1] << 8);
565 offset += 2;
566 }
567
568 if (reg_size == 0) {
569 reg_size = struct_buf[offset] |
570 (struct_buf[offset + 1] << 8) |
571 (struct_buf[offset + 2] << 16) |
572 (struct_buf[offset + 3] << 24);
573 offset += 4;
574 }
575
576 item->reg = reg;
577 item->reg_size = reg_size;
578
579 do {
580 for (b = 0; b < 7; b++) {
581 if (struct_buf[offset] & (0x1 << b))
582 bitmap_set(item->subpacket_map,
583 map_offset, 1);
584 ++map_offset;
585 }
586 } while (struct_buf[offset++] & 0x80);
587
588 item->num_subpackets = bitmap_weight(item->subpacket_map,
589 RMI_REG_DESC_SUBPACKET_BITS);
590
591 rmi_dbg(RMI_DEBUG_CORE, &d->dev,
592 "%s: reg: %d reg size: %ld subpackets: %d\n", __func__,
593 item->reg, item->reg_size, item->num_subpackets);
594
595 reg = find_next_bit(rdesc->presense_map,
596 RMI_REG_DESC_PRESENSE_BITS, reg + 1);
597 }
598
599free_struct_buff:
600 kfree(struct_buf);
601 return ret;
602}
603EXPORT_SYMBOL_GPL(rmi_read_register_desc);
604
605const struct rmi_register_desc_item *rmi_get_register_desc_item(
606 struct rmi_register_descriptor *rdesc, u16 reg)
607{
608 const struct rmi_register_desc_item *item;
609 int i;
610
611 for (i = 0; i < rdesc->num_registers; i++) {
612 item = &rdesc->registers[i];
613 if (item->reg == reg)
614 return item;
615 }
616
617 return NULL;
618}
619EXPORT_SYMBOL_GPL(rmi_get_register_desc_item);
620
621size_t rmi_register_desc_calc_size(struct rmi_register_descriptor *rdesc)
622{
623 const struct rmi_register_desc_item *item;
624 int i;
625 size_t size = 0;
626
627 for (i = 0; i < rdesc->num_registers; i++) {
628 item = &rdesc->registers[i];
629 size += item->reg_size;
630 }
631 return size;
632}
633EXPORT_SYMBOL_GPL(rmi_register_desc_calc_size);
634
635/* Compute the register offset relative to the base address */
636int rmi_register_desc_calc_reg_offset(
637 struct rmi_register_descriptor *rdesc, u16 reg)
638{
639 const struct rmi_register_desc_item *item;
640 int offset = 0;
641 int i;
642
643 for (i = 0; i < rdesc->num_registers; i++) {
644 item = &rdesc->registers[i];
645 if (item->reg == reg)
646 return offset;
647 ++offset;
648 }
649 return -1;
650}
651EXPORT_SYMBOL_GPL(rmi_register_desc_calc_reg_offset);
652
653bool rmi_register_desc_has_subpacket(const struct rmi_register_desc_item *item,
654 u8 subpacket)
655{
656 return find_next_bit(item->subpacket_map, RMI_REG_DESC_PRESENSE_BITS,
657 subpacket) == subpacket;
658}
659
660/* Indicates that flash programming is enabled (bootloader mode). */
661#define RMI_F01_STATUS_BOOTLOADER(status) (!!((status) & 0x40))
662
663/*
664 * Given the PDT entry for F01, read the device status register to determine
665 * if we're stuck in bootloader mode or not.
666 *
667 */
668static int rmi_check_bootloader_mode(struct rmi_device *rmi_dev,
669 const struct pdt_entry *pdt)
670{
671 int error;
672 u8 device_status;
673
674 error = rmi_read(rmi_dev, pdt->data_base_addr + pdt->page_start,
675 &device_status);
676 if (error) {
677 dev_err(&rmi_dev->dev,
678 "Failed to read device status: %d.\n", error);
679 return error;
680 }
681
682 return RMI_F01_STATUS_BOOTLOADER(device_status);
683}
684
685static int rmi_count_irqs(struct rmi_device *rmi_dev,
686 void *ctx, const struct pdt_entry *pdt)
687{
688 struct rmi_driver_data *data = dev_get_drvdata(&rmi_dev->dev);
689 int *irq_count = ctx;
690
691 *irq_count += pdt->interrupt_source_count;
692 if (pdt->function_number == 0x01) {
693 data->f01_bootloader_mode =
694 rmi_check_bootloader_mode(rmi_dev, pdt);
695 if (data->f01_bootloader_mode)
696 dev_warn(&rmi_dev->dev,
697 "WARNING: RMI4 device is in bootloader mode!\n");
698 }
699
700 return RMI_SCAN_CONTINUE;
701}
702
703static int rmi_initial_reset(struct rmi_device *rmi_dev,
704 void *ctx, const struct pdt_entry *pdt)
705{
706 int error;
707
708 if (pdt->function_number == 0x01) {
709 u16 cmd_addr = pdt->page_start + pdt->command_base_addr;
710 u8 cmd_buf = RMI_DEVICE_RESET_CMD;
711 const struct rmi_device_platform_data *pdata =
712 rmi_get_platform_data(rmi_dev);
713
714 if (rmi_dev->xport->ops->reset) {
715 error = rmi_dev->xport->ops->reset(rmi_dev->xport,
716 cmd_addr);
717 if (error)
718 return error;
719
720 return RMI_SCAN_DONE;
721 }
722
723 error = rmi_write_block(rmi_dev, cmd_addr, &cmd_buf, 1);
724 if (error) {
725 dev_err(&rmi_dev->dev,
726 "Initial reset failed. Code = %d.\n", error);
727 return error;
728 }
729
730 mdelay(pdata->reset_delay_ms ?: DEFAULT_RESET_DELAY_MS);
731
732 return RMI_SCAN_DONE;
733 }
734
735 /* F01 should always be on page 0. If we don't find it there, fail. */
736 return pdt->page_start == 0 ? RMI_SCAN_CONTINUE : -ENODEV;
737}
738
739static int rmi_create_function(struct rmi_device *rmi_dev,
740 void *ctx, const struct pdt_entry *pdt)
741{
742 struct device *dev = &rmi_dev->dev;
743 struct rmi_driver_data *data = dev_get_drvdata(&rmi_dev->dev);
744 int *current_irq_count = ctx;
745 struct rmi_function *fn;
746 int i;
747 int error;
748
749 rmi_dbg(RMI_DEBUG_CORE, dev, "Initializing F%02X.\n",
750 pdt->function_number);
751
752 fn = kzalloc(sizeof(struct rmi_function) +
753 BITS_TO_LONGS(data->irq_count) * sizeof(unsigned long),
754 GFP_KERNEL);
755 if (!fn) {
756 dev_err(dev, "Failed to allocate memory for F%02X\n",
757 pdt->function_number);
758 return -ENOMEM;
759 }
760
761 INIT_LIST_HEAD(&fn->node);
762 rmi_driver_copy_pdt_to_fd(pdt, &fn->fd);
763
764 fn->rmi_dev = rmi_dev;
765
766 fn->num_of_irqs = pdt->interrupt_source_count;
767 fn->irq_pos = *current_irq_count;
768 *current_irq_count += fn->num_of_irqs;
769
770 for (i = 0; i < fn->num_of_irqs; i++)
771 set_bit(fn->irq_pos + i, fn->irq_mask);
772
773 error = rmi_register_function(fn);
774 if (error)
775 goto err_put_fn;
776
777 if (pdt->function_number == 0x01)
778 data->f01_container = fn;
779
780 list_add_tail(&fn->node, &data->function_list);
781
782 return RMI_SCAN_CONTINUE;
783
784err_put_fn:
785 put_device(&fn->dev);
786 return error;
787}
788
789int rmi_driver_suspend(struct rmi_device *rmi_dev)
790{
791 int retval = 0;
792
793 retval = rmi_suspend_functions(rmi_dev);
794 if (retval)
795 dev_warn(&rmi_dev->dev, "Failed to suspend functions: %d\n",
796 retval);
797
798 return retval;
799}
800EXPORT_SYMBOL_GPL(rmi_driver_suspend);
801
802int rmi_driver_resume(struct rmi_device *rmi_dev)
803{
804 int retval;
805
806 retval = rmi_resume_functions(rmi_dev);
807 if (retval)
808 dev_warn(&rmi_dev->dev, "Failed to suspend functions: %d\n",
809 retval);
810
811 return retval;
812}
813EXPORT_SYMBOL_GPL(rmi_driver_resume);
814
815static int rmi_driver_remove(struct device *dev)
816{
817 struct rmi_device *rmi_dev = to_rmi_device(dev);
818
819 rmi_free_function_list(rmi_dev);
820
821 return 0;
822}
823
824static int rmi_driver_probe(struct device *dev)
825{
826 struct rmi_driver *rmi_driver;
827 struct rmi_driver_data *data;
828 struct rmi_device_platform_data *pdata;
829 struct rmi_device *rmi_dev;
830 size_t size;
831 void *irq_memory;
832 int irq_count;
833 int retval;
834
835 rmi_dbg(RMI_DEBUG_CORE, dev, "%s: Starting probe.\n",
836 __func__);
837
838 if (!rmi_is_physical_device(dev)) {
839 rmi_dbg(RMI_DEBUG_CORE, dev, "Not a physical device.\n");
840 return -ENODEV;
841 }
842
843 rmi_dev = to_rmi_device(dev);
844 rmi_driver = to_rmi_driver(dev->driver);
845 rmi_dev->driver = rmi_driver;
846
847 pdata = rmi_get_platform_data(rmi_dev);
848
849 data = devm_kzalloc(dev, sizeof(struct rmi_driver_data), GFP_KERNEL);
850 if (!data)
851 return -ENOMEM;
852
853 INIT_LIST_HEAD(&data->function_list);
854 data->rmi_dev = rmi_dev;
855 dev_set_drvdata(&rmi_dev->dev, data);
856
857 /*
858 * Right before a warm boot, the sensor might be in some unusual state,
859 * such as F54 diagnostics, or F34 bootloader mode after a firmware
860 * or configuration update. In order to clear the sensor to a known
861 * state and/or apply any updates, we issue a initial reset to clear any
862 * previous settings and force it into normal operation.
863 *
864 * We have to do this before actually building the PDT because
865 * the reflash updates (if any) might cause various registers to move
866 * around.
867 *
868 * For a number of reasons, this initial reset may fail to return
869 * within the specified time, but we'll still be able to bring up the
870 * driver normally after that failure. This occurs most commonly in
871 * a cold boot situation (where then firmware takes longer to come up
872 * than from a warm boot) and the reset_delay_ms in the platform data
873 * has been set too short to accommodate that. Since the sensor will
874 * eventually come up and be usable, we don't want to just fail here
875 * and leave the customer's device unusable. So we warn them, and
876 * continue processing.
877 */
878 retval = rmi_scan_pdt(rmi_dev, NULL, rmi_initial_reset);
879 if (retval < 0)
880 dev_warn(dev, "RMI initial reset failed! Continuing in spite of this.\n");
881
882 retval = rmi_read(rmi_dev, PDT_PROPERTIES_LOCATION, &data->pdt_props);
883 if (retval < 0) {
884 /*
885 * we'll print out a warning and continue since
886 * failure to get the PDT properties is not a cause to fail
887 */
888 dev_warn(dev, "Could not read PDT properties from %#06x (code %d). Assuming 0x00.\n",
889 PDT_PROPERTIES_LOCATION, retval);
890 }
891
892 /*
893 * We need to count the IRQs and allocate their storage before scanning
894 * the PDT and creating the function entries, because adding a new
895 * function can trigger events that result in the IRQ related storage
896 * being accessed.
897 */
898 rmi_dbg(RMI_DEBUG_CORE, dev, "Counting IRQs.\n");
899 irq_count = 0;
900 retval = rmi_scan_pdt(rmi_dev, &irq_count, rmi_count_irqs);
901 if (retval < 0) {
902 dev_err(dev, "IRQ counting failed with code %d.\n", retval);
903 goto err;
904 }
905 data->irq_count = irq_count;
906 data->num_of_irq_regs = (data->irq_count + 7) / 8;
907
908 mutex_init(&data->irq_mutex);
909
910 size = BITS_TO_LONGS(data->irq_count) * sizeof(unsigned long);
911 irq_memory = devm_kzalloc(dev, size * 4, GFP_KERNEL);
912 if (!irq_memory) {
913 dev_err(dev, "Failed to allocate memory for irq masks.\n");
914 goto err;
915 }
916
917 data->irq_status = irq_memory + size * 0;
918 data->fn_irq_bits = irq_memory + size * 1;
919 data->current_irq_mask = irq_memory + size * 2;
920 data->new_irq_mask = irq_memory + size * 3;
921
922 if (rmi_dev->xport->input) {
923 /*
924 * The transport driver already has an input device.
925 * In some cases it is preferable to reuse the transport
926 * devices input device instead of creating a new one here.
927 * One example is some HID touchpads report "pass-through"
928 * button events are not reported by rmi registers.
929 */
930 data->input = rmi_dev->xport->input;
931 } else {
932 data->input = devm_input_allocate_device(dev);
933 if (!data->input) {
934 dev_err(dev, "%s: Failed to allocate input device.\n",
935 __func__);
936 retval = -ENOMEM;
937 goto err_destroy_functions;
938 }
939 rmi_driver_set_input_params(rmi_dev, data->input);
940 data->input->phys = devm_kasprintf(dev, GFP_KERNEL,
941 "%s/input0", dev_name(dev));
942 }
943
944 irq_count = 0;
945 rmi_dbg(RMI_DEBUG_CORE, dev, "Creating functions.");
946 retval = rmi_scan_pdt(rmi_dev, &irq_count, rmi_create_function);
947 if (retval < 0) {
948 dev_err(dev, "Function creation failed with code %d.\n",
949 retval);
950 goto err_destroy_functions;
951 }
952
953 if (!data->f01_container) {
954 dev_err(dev, "Missing F01 container!\n");
955 retval = -EINVAL;
956 goto err_destroy_functions;
957 }
958
959 retval = rmi_read_block(rmi_dev,
960 data->f01_container->fd.control_base_addr + 1,
961 data->current_irq_mask, data->num_of_irq_regs);
962 if (retval < 0) {
963 dev_err(dev, "%s: Failed to read current IRQ mask.\n",
964 __func__);
965 goto err_destroy_functions;
966 }
967
968 if (data->input) {
969 rmi_driver_set_input_name(rmi_dev, data->input);
970 if (!rmi_dev->xport->input) {
971 if (input_register_device(data->input)) {
972 dev_err(dev, "%s: Failed to register input device.\n",
973 __func__);
974 goto err_destroy_functions;
975 }
976 }
977 }
978
979 if (data->f01_container->dev.driver)
980 /* Driver already bound, so enable ATTN now. */
981 return enable_sensor(rmi_dev);
982
983 return 0;
984
985err_destroy_functions:
986 rmi_free_function_list(rmi_dev);
987err:
988 return retval < 0 ? retval : 0;
989}
990
991static struct rmi_driver rmi_physical_driver = {
992 .driver = {
993 .owner = THIS_MODULE,
994 .name = "rmi4_physical",
995 .bus = &rmi_bus_type,
996 .probe = rmi_driver_probe,
997 .remove = rmi_driver_remove,
998 },
999 .reset_handler = rmi_driver_reset_handler,
1000 .clear_irq_bits = rmi_driver_clear_irq_bits,
1001 .set_irq_bits = rmi_driver_set_irq_bits,
1002 .set_input_params = rmi_driver_set_input_params,
1003};
1004
1005bool rmi_is_physical_driver(struct device_driver *drv)
1006{
1007 return drv == &rmi_physical_driver.driver;
1008}
1009
1010int __init rmi_register_physical_driver(void)
1011{
1012 int error;
1013
1014 error = driver_register(&rmi_physical_driver.driver);
1015 if (error) {
1016 pr_err("%s: driver register failed, code=%d.\n", __func__,
1017 error);
1018 return error;
1019 }
1020
1021 return 0;
1022}
1023
1024void __exit rmi_unregister_physical_driver(void)
1025{
1026 driver_unregister(&rmi_physical_driver.driver);
1027}
diff --git a/drivers/input/rmi4/rmi_driver.h b/drivers/input/rmi4/rmi_driver.h
new file mode 100644
index 000000000000..3ab3f1a8078f
--- /dev/null
+++ b/drivers/input/rmi4/rmi_driver.h
@@ -0,0 +1,103 @@
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#ifndef _RMI_DRIVER_H
11#define _RMI_DRIVER_H
12
13#include <linux/ctype.h>
14#include <linux/hrtimer.h>
15#include <linux/ktime.h>
16#include <linux/input.h>
17#include "rmi_bus.h"
18
19#define RMI_DRIVER_VERSION "2.0"
20
21#define SYNAPTICS_INPUT_DEVICE_NAME "Synaptics RMI4 Touch Sensor"
22#define SYNAPTICS_VENDOR_ID 0x06cb
23
24#define GROUP(_attrs) { \
25 .attrs = _attrs, \
26}
27
28#define PDT_PROPERTIES_LOCATION 0x00EF
29#define BSR_LOCATION 0x00FE
30
31#define RMI_PDT_PROPS_HAS_BSR 0x02
32
33#define NAME_BUFFER_SIZE 256
34
35#define RMI_PDT_ENTRY_SIZE 6
36#define RMI_PDT_FUNCTION_VERSION_MASK 0x60
37#define RMI_PDT_INT_SOURCE_COUNT_MASK 0x07
38
39#define PDT_START_SCAN_LOCATION 0x00e9
40#define PDT_END_SCAN_LOCATION 0x0005
41#define RMI4_END_OF_PDT(id) ((id) == 0x00 || (id) == 0xff)
42
43struct pdt_entry {
44 u16 page_start;
45 u8 query_base_addr;
46 u8 command_base_addr;
47 u8 control_base_addr;
48 u8 data_base_addr;
49 u8 interrupt_source_count;
50 u8 function_version;
51 u8 function_number;
52};
53
54int rmi_read_pdt_entry(struct rmi_device *rmi_dev, struct pdt_entry *entry,
55 u16 pdt_address);
56
57#define RMI_REG_DESC_PRESENSE_BITS (32 * BITS_PER_BYTE)
58#define RMI_REG_DESC_SUBPACKET_BITS (37 * BITS_PER_BYTE)
59
60/* describes a single packet register */
61struct rmi_register_desc_item {
62 u16 reg;
63 unsigned long reg_size;
64 u8 num_subpackets;
65 unsigned long subpacket_map[BITS_TO_LONGS(
66 RMI_REG_DESC_SUBPACKET_BITS)];
67};
68
69/*
70 * describes the packet registers for a particular type
71 * (ie query, control, data)
72 */
73struct rmi_register_descriptor {
74 unsigned long struct_size;
75 unsigned long presense_map[BITS_TO_LONGS(RMI_REG_DESC_PRESENSE_BITS)];
76 u8 num_registers;
77 struct rmi_register_desc_item *registers;
78};
79
80int rmi_read_register_desc(struct rmi_device *d, u16 addr,
81 struct rmi_register_descriptor *rdesc);
82const struct rmi_register_desc_item *rmi_get_register_desc_item(
83 struct rmi_register_descriptor *rdesc, u16 reg);
84
85/*
86 * Calculate the total size of all of the registers described in the
87 * descriptor.
88 */
89size_t rmi_register_desc_calc_size(struct rmi_register_descriptor *rdesc);
90int rmi_register_desc_calc_reg_offset(
91 struct rmi_register_descriptor *rdesc, u16 reg);
92bool rmi_register_desc_has_subpacket(const struct rmi_register_desc_item *item,
93 u8 subpacket);
94
95bool rmi_is_physical_driver(struct device_driver *);
96int rmi_register_physical_driver(void);
97void rmi_unregister_physical_driver(void);
98
99char *rmi_f01_get_product_ID(struct rmi_function *fn);
100
101extern struct rmi_function_handler rmi_f01_handler;
102
103#endif
diff --git a/drivers/input/rmi4/rmi_f01.c b/drivers/input/rmi4/rmi_f01.c
new file mode 100644
index 000000000000..e50ecc6699e7
--- /dev/null
+++ b/drivers/input/rmi4/rmi_f01.c
@@ -0,0 +1,574 @@
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/kconfig.h>
12#include <linux/rmi.h>
13#include <linux/slab.h>
14#include <linux/uaccess.h>
15#include <linux/of.h>
16#include "rmi_driver.h"
17
18#define RMI_PRODUCT_ID_LENGTH 10
19#define RMI_PRODUCT_INFO_LENGTH 2
20
21#define RMI_DATE_CODE_LENGTH 3
22
23#define PRODUCT_ID_OFFSET 0x10
24#define PRODUCT_INFO_OFFSET 0x1E
25
26
27/* Force a firmware reset of the sensor */
28#define RMI_F01_CMD_DEVICE_RESET 1
29
30/* Various F01_RMI_QueryX bits */
31
32#define RMI_F01_QRY1_CUSTOM_MAP BIT(0)
33#define RMI_F01_QRY1_NON_COMPLIANT BIT(1)
34#define RMI_F01_QRY1_HAS_LTS BIT(2)
35#define RMI_F01_QRY1_HAS_SENSOR_ID BIT(3)
36#define RMI_F01_QRY1_HAS_CHARGER_INP BIT(4)
37#define RMI_F01_QRY1_HAS_ADJ_DOZE BIT(5)
38#define RMI_F01_QRY1_HAS_ADJ_DOZE_HOFF BIT(6)
39#define RMI_F01_QRY1_HAS_QUERY42 BIT(7)
40
41#define RMI_F01_QRY5_YEAR_MASK 0x1f
42#define RMI_F01_QRY6_MONTH_MASK 0x0f
43#define RMI_F01_QRY7_DAY_MASK 0x1f
44
45#define RMI_F01_QRY2_PRODINFO_MASK 0x7f
46
47#define RMI_F01_BASIC_QUERY_LEN 21 /* From Query 00 through 20 */
48
49struct f01_basic_properties {
50 u8 manufacturer_id;
51 bool has_lts;
52 bool has_adjustable_doze;
53 bool has_adjustable_doze_holdoff;
54 char dom[11]; /* YYYY/MM/DD + '\0' */
55 u8 product_id[RMI_PRODUCT_ID_LENGTH + 1];
56 u16 productinfo;
57 u32 firmware_id;
58};
59
60/* F01 device status bits */
61
62/* Most recent device status event */
63#define RMI_F01_STATUS_CODE(status) ((status) & 0x0f)
64/* The device has lost its configuration for some reason. */
65#define RMI_F01_STATUS_UNCONFIGURED(status) (!!((status) & 0x80))
66
67/* Control register bits */
68
69/*
70 * Sleep mode controls power management on the device and affects all
71 * functions of the device.
72 */
73#define RMI_F01_CTRL0_SLEEP_MODE_MASK 0x03
74
75#define RMI_SLEEP_MODE_NORMAL 0x00
76#define RMI_SLEEP_MODE_SENSOR_SLEEP 0x01
77#define RMI_SLEEP_MODE_RESERVED0 0x02
78#define RMI_SLEEP_MODE_RESERVED1 0x03
79
80/*
81 * This bit disables whatever sleep mode may be selected by the sleep_mode
82 * field and forces the device to run at full power without sleeping.
83 */
84#define RMI_F01_CRTL0_NOSLEEP_BIT BIT(2)
85
86/*
87 * When this bit is set, the touch controller employs a noise-filtering
88 * algorithm designed for use with a connected battery charger.
89 */
90#define RMI_F01_CRTL0_CHARGER_BIT BIT(5)
91
92/*
93 * Sets the report rate for the device. The effect of this setting is
94 * highly product dependent. Check the spec sheet for your particular
95 * touch sensor.
96 */
97#define RMI_F01_CRTL0_REPORTRATE_BIT BIT(6)
98
99/*
100 * Written by the host as an indicator that the device has been
101 * successfully configured.
102 */
103#define RMI_F01_CRTL0_CONFIGURED_BIT BIT(7)
104
105/**
106 * @ctrl0 - see the bit definitions above.
107 * @doze_interval - controls the interval between checks for finger presence
108 * when the touch sensor is in doze mode, in units of 10ms.
109 * @wakeup_threshold - controls the capacitance threshold at which the touch
110 * sensor will decide to wake up from that low power state.
111 * @doze_holdoff - controls how long the touch sensor waits after the last
112 * finger lifts before entering the doze state, in units of 100ms.
113 */
114struct f01_device_control {
115 u8 ctrl0;
116 u8 doze_interval;
117 u8 wakeup_threshold;
118 u8 doze_holdoff;
119};
120
121struct f01_data {
122 struct f01_basic_properties properties;
123 struct f01_device_control device_control;
124
125 u16 doze_interval_addr;
126 u16 wakeup_threshold_addr;
127 u16 doze_holdoff_addr;
128
129 bool suspended;
130 bool old_nosleep;
131
132 unsigned int num_of_irq_regs;
133};
134
135static int rmi_f01_read_properties(struct rmi_device *rmi_dev,
136 u16 query_base_addr,
137 struct f01_basic_properties *props)
138{
139 u8 queries[RMI_F01_BASIC_QUERY_LEN];
140 int ret;
141 int query_offset = query_base_addr;
142 bool has_ds4_queries = false;
143 bool has_query42 = false;
144 bool has_sensor_id = false;
145 bool has_package_id_query = false;
146 bool has_build_id_query = false;
147 u16 prod_info_addr;
148 u8 ds4_query_len;
149
150 ret = rmi_read_block(rmi_dev, query_offset,
151 queries, RMI_F01_BASIC_QUERY_LEN);
152 if (ret) {
153 dev_err(&rmi_dev->dev,
154 "Failed to read device query registers: %d\n", ret);
155 return ret;
156 }
157
158 prod_info_addr = query_offset + 17;
159 query_offset += RMI_F01_BASIC_QUERY_LEN;
160
161 /* Now parse what we got */
162 props->manufacturer_id = queries[0];
163
164 props->has_lts = queries[1] & RMI_F01_QRY1_HAS_LTS;
165 props->has_adjustable_doze =
166 queries[1] & RMI_F01_QRY1_HAS_ADJ_DOZE;
167 props->has_adjustable_doze_holdoff =
168 queries[1] & RMI_F01_QRY1_HAS_ADJ_DOZE_HOFF;
169 has_query42 = queries[1] & RMI_F01_QRY1_HAS_QUERY42;
170 has_sensor_id = queries[1] & RMI_F01_QRY1_HAS_SENSOR_ID;
171
172 snprintf(props->dom, sizeof(props->dom), "20%02d/%02d/%02d",
173 queries[5] & RMI_F01_QRY5_YEAR_MASK,
174 queries[6] & RMI_F01_QRY6_MONTH_MASK,
175 queries[7] & RMI_F01_QRY7_DAY_MASK);
176
177 memcpy(props->product_id, &queries[11],
178 RMI_PRODUCT_ID_LENGTH);
179 props->product_id[RMI_PRODUCT_ID_LENGTH] = '\0';
180
181 props->productinfo =
182 ((queries[2] & RMI_F01_QRY2_PRODINFO_MASK) << 7) |
183 (queries[3] & RMI_F01_QRY2_PRODINFO_MASK);
184
185 if (has_sensor_id)
186 query_offset++;
187
188 if (has_query42) {
189 ret = rmi_read(rmi_dev, query_offset, queries);
190 if (ret) {
191 dev_err(&rmi_dev->dev,
192 "Failed to read query 42 register: %d\n", ret);
193 return ret;
194 }
195
196 has_ds4_queries = !!(queries[0] & BIT(0));
197 query_offset++;
198 }
199
200 if (has_ds4_queries) {
201 ret = rmi_read(rmi_dev, query_offset, &ds4_query_len);
202 if (ret) {
203 dev_err(&rmi_dev->dev,
204 "Failed to read DS4 queries length: %d\n", ret);
205 return ret;
206 }
207 query_offset++;
208
209 if (ds4_query_len > 0) {
210 ret = rmi_read(rmi_dev, query_offset, queries);
211 if (ret) {
212 dev_err(&rmi_dev->dev,
213 "Failed to read DS4 queries: %d\n",
214 ret);
215 return ret;
216 }
217
218 has_package_id_query = !!(queries[0] & BIT(0));
219 has_build_id_query = !!(queries[0] & BIT(1));
220 }
221
222 if (has_package_id_query)
223 prod_info_addr++;
224
225 if (has_build_id_query) {
226 ret = rmi_read_block(rmi_dev, prod_info_addr, queries,
227 3);
228 if (ret) {
229 dev_err(&rmi_dev->dev,
230 "Failed to read product info: %d\n",
231 ret);
232 return ret;
233 }
234
235 props->firmware_id = queries[1] << 8 | queries[0];
236 props->firmware_id += queries[2] * 65536;
237 }
238 }
239
240 return 0;
241}
242
243char *rmi_f01_get_product_ID(struct rmi_function *fn)
244{
245 struct f01_data *f01 = dev_get_drvdata(&fn->dev);
246
247 return f01->properties.product_id;
248}
249
250static int rmi_f01_probe(struct rmi_function *fn)
251{
252 struct rmi_device *rmi_dev = fn->rmi_dev;
253 struct rmi_driver_data *driver_data = dev_get_drvdata(&rmi_dev->dev);
254 struct rmi_device_platform_data *pdata = rmi_get_platform_data(rmi_dev);
255 struct f01_data *f01;
256 int error;
257 u16 ctrl_base_addr = fn->fd.control_base_addr;
258 u8 device_status;
259 u8 temp;
260
261 f01 = devm_kzalloc(&fn->dev, sizeof(struct f01_data), GFP_KERNEL);
262 if (!f01)
263 return -ENOMEM;
264
265 f01->num_of_irq_regs = driver_data->num_of_irq_regs;
266
267 /*
268 * Set the configured bit and (optionally) other important stuff
269 * in the device control register.
270 */
271
272 error = rmi_read(rmi_dev, fn->fd.control_base_addr,
273 &f01->device_control.ctrl0);
274 if (error) {
275 dev_err(&fn->dev, "Failed to read F01 control: %d\n", error);
276 return error;
277 }
278
279 switch (pdata->power_management.nosleep) {
280 case RMI_F01_NOSLEEP_DEFAULT:
281 break;
282 case RMI_F01_NOSLEEP_OFF:
283 f01->device_control.ctrl0 &= ~RMI_F01_CRTL0_NOSLEEP_BIT;
284 break;
285 case RMI_F01_NOSLEEP_ON:
286 f01->device_control.ctrl0 |= RMI_F01_CRTL0_NOSLEEP_BIT;
287 break;
288 }
289
290 /*
291 * Sleep mode might be set as a hangover from a system crash or
292 * reboot without power cycle. If so, clear it so the sensor
293 * is certain to function.
294 */
295 if ((f01->device_control.ctrl0 & RMI_F01_CTRL0_SLEEP_MODE_MASK) !=
296 RMI_SLEEP_MODE_NORMAL) {
297 dev_warn(&fn->dev,
298 "WARNING: Non-zero sleep mode found. Clearing...\n");
299 f01->device_control.ctrl0 &= ~RMI_F01_CTRL0_SLEEP_MODE_MASK;
300 }
301
302 f01->device_control.ctrl0 |= RMI_F01_CRTL0_CONFIGURED_BIT;
303
304 error = rmi_write(rmi_dev, fn->fd.control_base_addr,
305 f01->device_control.ctrl0);
306 if (error) {
307 dev_err(&fn->dev, "Failed to write F01 control: %d\n", error);
308 return error;
309 }
310
311 /* Dummy read in order to clear irqs */
312 error = rmi_read(rmi_dev, fn->fd.data_base_addr + 1, &temp);
313 if (error < 0) {
314 dev_err(&fn->dev, "Failed to read Interrupt Status.\n");
315 return error;
316 }
317
318 error = rmi_f01_read_properties(rmi_dev, fn->fd.query_base_addr,
319 &f01->properties);
320 if (error < 0) {
321 dev_err(&fn->dev, "Failed to read F01 properties.\n");
322 return error;
323 }
324
325 dev_info(&fn->dev, "found RMI device, manufacturer: %s, product: %s, fw id: %d\n",
326 f01->properties.manufacturer_id == 1 ? "Synaptics" : "unknown",
327 f01->properties.product_id, f01->properties.firmware_id);
328
329 /* Advance to interrupt control registers, then skip over them. */
330 ctrl_base_addr++;
331 ctrl_base_addr += f01->num_of_irq_regs;
332
333 /* read control register */
334 if (f01->properties.has_adjustable_doze) {
335 f01->doze_interval_addr = ctrl_base_addr;
336 ctrl_base_addr++;
337
338 if (pdata->power_management.doze_interval) {
339 f01->device_control.doze_interval =
340 pdata->power_management.doze_interval;
341 error = rmi_write(rmi_dev, f01->doze_interval_addr,
342 f01->device_control.doze_interval);
343 if (error) {
344 dev_err(&fn->dev,
345 "Failed to configure F01 doze interval register: %d\n",
346 error);
347 return error;
348 }
349 } else {
350 error = rmi_read(rmi_dev, f01->doze_interval_addr,
351 &f01->device_control.doze_interval);
352 if (error) {
353 dev_err(&fn->dev,
354 "Failed to read F01 doze interval register: %d\n",
355 error);
356 return error;
357 }
358 }
359
360 f01->wakeup_threshold_addr = ctrl_base_addr;
361 ctrl_base_addr++;
362
363 if (pdata->power_management.wakeup_threshold) {
364 f01->device_control.wakeup_threshold =
365 pdata->power_management.wakeup_threshold;
366 error = rmi_write(rmi_dev, f01->wakeup_threshold_addr,
367 f01->device_control.wakeup_threshold);
368 if (error) {
369 dev_err(&fn->dev,
370 "Failed to configure F01 wakeup threshold register: %d\n",
371 error);
372 return error;
373 }
374 } else {
375 error = rmi_read(rmi_dev, f01->wakeup_threshold_addr,
376 &f01->device_control.wakeup_threshold);
377 if (error < 0) {
378 dev_err(&fn->dev,
379 "Failed to read F01 wakeup threshold register: %d\n",
380 error);
381 return error;
382 }
383 }
384 }
385
386 if (f01->properties.has_lts)
387 ctrl_base_addr++;
388
389 if (f01->properties.has_adjustable_doze_holdoff) {
390 f01->doze_holdoff_addr = ctrl_base_addr;
391 ctrl_base_addr++;
392
393 if (pdata->power_management.doze_holdoff) {
394 f01->device_control.doze_holdoff =
395 pdata->power_management.doze_holdoff;
396 error = rmi_write(rmi_dev, f01->doze_holdoff_addr,
397 f01->device_control.doze_holdoff);
398 if (error) {
399 dev_err(&fn->dev,
400 "Failed to configure F01 doze holdoff register: %d\n",
401 error);
402 return error;
403 }
404 } else {
405 error = rmi_read(rmi_dev, f01->doze_holdoff_addr,
406 &f01->device_control.doze_holdoff);
407 if (error) {
408 dev_err(&fn->dev,
409 "Failed to read F01 doze holdoff register: %d\n",
410 error);
411 return error;
412 }
413 }
414 }
415
416 error = rmi_read(rmi_dev, fn->fd.data_base_addr, &device_status);
417 if (error < 0) {
418 dev_err(&fn->dev,
419 "Failed to read device status: %d\n", error);
420 return error;
421 }
422
423 if (RMI_F01_STATUS_UNCONFIGURED(device_status)) {
424 dev_err(&fn->dev,
425 "Device was reset during configuration process, status: %#02x!\n",
426 RMI_F01_STATUS_CODE(device_status));
427 return -EINVAL;
428 }
429
430 dev_set_drvdata(&fn->dev, f01);
431
432 return 0;
433}
434
435static int rmi_f01_config(struct rmi_function *fn)
436{
437 struct f01_data *f01 = dev_get_drvdata(&fn->dev);
438 int error;
439
440 error = rmi_write(fn->rmi_dev, fn->fd.control_base_addr,
441 f01->device_control.ctrl0);
442 if (error) {
443 dev_err(&fn->dev,
444 "Failed to write device_control register: %d\n", error);
445 return error;
446 }
447
448 if (f01->properties.has_adjustable_doze) {
449 error = rmi_write(fn->rmi_dev, f01->doze_interval_addr,
450 f01->device_control.doze_interval);
451 if (error) {
452 dev_err(&fn->dev,
453 "Failed to write doze interval: %d\n", error);
454 return error;
455 }
456
457 error = rmi_write_block(fn->rmi_dev,
458 f01->wakeup_threshold_addr,
459 &f01->device_control.wakeup_threshold,
460 sizeof(u8));
461 if (error) {
462 dev_err(&fn->dev,
463 "Failed to write wakeup threshold: %d\n",
464 error);
465 return error;
466 }
467 }
468
469 if (f01->properties.has_adjustable_doze_holdoff) {
470 error = rmi_write(fn->rmi_dev, f01->doze_holdoff_addr,
471 f01->device_control.doze_holdoff);
472 if (error) {
473 dev_err(&fn->dev,
474 "Failed to write doze holdoff: %d\n", error);
475 return error;
476 }
477 }
478
479 return 0;
480}
481
482static int rmi_f01_suspend(struct rmi_function *fn)
483{
484 struct f01_data *f01 = dev_get_drvdata(&fn->dev);
485 int error;
486
487 f01->old_nosleep =
488 f01->device_control.ctrl0 & RMI_F01_CRTL0_NOSLEEP_BIT;
489 f01->device_control.ctrl0 &= ~RMI_F01_CRTL0_NOSLEEP_BIT;
490
491 f01->device_control.ctrl0 &= ~RMI_F01_CTRL0_SLEEP_MODE_MASK;
492 if (device_may_wakeup(fn->rmi_dev->xport->dev))
493 f01->device_control.ctrl0 |= RMI_SLEEP_MODE_RESERVED1;
494 else
495 f01->device_control.ctrl0 |= RMI_SLEEP_MODE_SENSOR_SLEEP;
496
497 error = rmi_write(fn->rmi_dev, fn->fd.control_base_addr,
498 f01->device_control.ctrl0);
499 if (error) {
500 dev_err(&fn->dev, "Failed to write sleep mode: %d.\n", error);
501 if (f01->old_nosleep)
502 f01->device_control.ctrl0 |= RMI_F01_CRTL0_NOSLEEP_BIT;
503 f01->device_control.ctrl0 &= ~RMI_F01_CTRL0_SLEEP_MODE_MASK;
504 f01->device_control.ctrl0 |= RMI_SLEEP_MODE_NORMAL;
505 return error;
506 }
507
508 return 0;
509}
510
511static int rmi_f01_resume(struct rmi_function *fn)
512{
513 struct f01_data *f01 = dev_get_drvdata(&fn->dev);
514 int error;
515
516 if (f01->old_nosleep)
517 f01->device_control.ctrl0 |= RMI_F01_CRTL0_NOSLEEP_BIT;
518
519 f01->device_control.ctrl0 &= ~RMI_F01_CTRL0_SLEEP_MODE_MASK;
520 f01->device_control.ctrl0 |= RMI_SLEEP_MODE_NORMAL;
521
522 error = rmi_write(fn->rmi_dev, fn->fd.control_base_addr,
523 f01->device_control.ctrl0);
524 if (error) {
525 dev_err(&fn->dev,
526 "Failed to restore normal operation: %d.\n", error);
527 return error;
528 }
529
530 return 0;
531}
532
533static int rmi_f01_attention(struct rmi_function *fn,
534 unsigned long *irq_bits)
535{
536 struct rmi_device *rmi_dev = fn->rmi_dev;
537 int error;
538 u8 device_status;
539
540 error = rmi_read(rmi_dev, fn->fd.data_base_addr, &device_status);
541 if (error) {
542 dev_err(&fn->dev,
543 "Failed to read device status: %d.\n", error);
544 return error;
545 }
546
547 if (RMI_F01_STATUS_UNCONFIGURED(device_status)) {
548 dev_warn(&fn->dev, "Device reset detected.\n");
549 error = rmi_dev->driver->reset_handler(rmi_dev);
550 if (error) {
551 dev_err(&fn->dev, "Device reset failed: %d\n", error);
552 return error;
553 }
554 }
555
556 return 0;
557}
558
559struct rmi_function_handler rmi_f01_handler = {
560 .driver = {
561 .name = "rmi4_f01",
562 /*
563 * Do not allow user unbinding F01 as it is critical
564 * function.
565 */
566 .suppress_bind_attrs = true,
567 },
568 .func = 0x01,
569 .probe = rmi_f01_probe,
570 .config = rmi_f01_config,
571 .attention = rmi_f01_attention,
572 .suspend = rmi_f01_suspend,
573 .resume = rmi_f01_resume,
574};
diff --git a/include/linux/rmi.h b/include/linux/rmi.h
new file mode 100644
index 000000000000..c748fa302067
--- /dev/null
+++ b/include/linux/rmi.h
@@ -0,0 +1,209 @@
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#ifndef _RMI_H
11#define _RMI_H
12#include <linux/kernel.h>
13#include <linux/device.h>
14#include <linux/interrupt.h>
15#include <linux/input.h>
16#include <linux/list.h>
17#include <linux/module.h>
18#include <linux/types.h>
19
20#define NAME_BUFFER_SIZE 256
21
22/**
23 * struct rmi_f01_power - override default power management settings.
24 *
25 */
26enum rmi_f01_nosleep {
27 RMI_F01_NOSLEEP_DEFAULT = 0,
28 RMI_F01_NOSLEEP_OFF = 1,
29 RMI_F01_NOSLEEP_ON = 2
30};
31
32/**
33 * struct rmi_f01_power_management -When non-zero, these values will be written
34 * to the touch sensor to override the default firmware settigns. For a
35 * detailed explanation of what each field does, see the corresponding
36 * documention in the RMI4 specification.
37 *
38 * @nosleep - specifies whether the device is permitted to sleep or doze (that
39 * is, enter a temporary low power state) when no fingers are touching the
40 * sensor.
41 * @wakeup_threshold - controls the capacitance threshold at which the touch
42 * sensor will decide to wake up from that low power state.
43 * @doze_holdoff - controls how long the touch sensor waits after the last
44 * finger lifts before entering the doze state, in units of 100ms.
45 * @doze_interval - controls the interval between checks for finger presence
46 * when the touch sensor is in doze mode, in units of 10ms.
47 */
48struct rmi_f01_power_management {
49 enum rmi_f01_nosleep nosleep;
50 u8 wakeup_threshold;
51 u8 doze_holdoff;
52 u8 doze_interval;
53};
54
55/**
56 * struct rmi_device_platform_data - system specific configuration info.
57 *
58 * @reset_delay_ms - after issuing a reset command to the touch sensor, the
59 * driver waits a few milliseconds to give the firmware a chance to
60 * to re-initialize. You can override the default wait period here.
61 */
62struct rmi_device_platform_data {
63 int reset_delay_ms;
64
65 /* function handler pdata */
66 struct rmi_f01_power_management power_management;
67};
68
69/**
70 * struct rmi_function_descriptor - RMI function base addresses
71 *
72 * @query_base_addr: The RMI Query base address
73 * @command_base_addr: The RMI Command base address
74 * @control_base_addr: The RMI Control base address
75 * @data_base_addr: The RMI Data base address
76 * @interrupt_source_count: The number of irqs this RMI function needs
77 * @function_number: The RMI function number
78 *
79 * This struct is used when iterating the Page Description Table. The addresses
80 * are 16-bit values to include the current page address.
81 *
82 */
83struct rmi_function_descriptor {
84 u16 query_base_addr;
85 u16 command_base_addr;
86 u16 control_base_addr;
87 u16 data_base_addr;
88 u8 interrupt_source_count;
89 u8 function_number;
90 u8 function_version;
91};
92
93struct rmi_device;
94
95/**
96 * struct rmi_transport_dev - represent an RMI transport device
97 *
98 * @dev: Pointer to the communication device, e.g. i2c or spi
99 * @rmi_dev: Pointer to the RMI device
100 * @proto_name: name of the transport protocol (SPI, i2c, etc)
101 * @ops: pointer to transport operations implementation
102 *
103 * The RMI transport device implements the glue between different communication
104 * buses such as I2C and SPI.
105 *
106 */
107struct rmi_transport_dev {
108 struct device *dev;
109 struct rmi_device *rmi_dev;
110
111 const char *proto_name;
112 const struct rmi_transport_ops *ops;
113
114 struct rmi_device_platform_data pdata;
115
116 struct input_dev *input;
117
118 void *attn_data;
119 int attn_size;
120};
121
122/**
123 * struct rmi_transport_ops - defines transport protocol operations.
124 *
125 * @write_block: Writing a block of data to the specified address
126 * @read_block: Read a block of data from the specified address.
127 */
128struct rmi_transport_ops {
129 int (*write_block)(struct rmi_transport_dev *xport, u16 addr,
130 const void *buf, size_t len);
131 int (*read_block)(struct rmi_transport_dev *xport, u16 addr,
132 void *buf, size_t len);
133 int (*reset)(struct rmi_transport_dev *xport, u16 reset_addr);
134};
135
136/**
137 * struct rmi_driver - driver for an RMI4 sensor on the RMI bus.
138 *
139 * @driver: Device driver model driver
140 * @reset_handler: Called when a reset is detected.
141 * @clear_irq_bits: Clear the specified bits in the current interrupt mask.
142 * @set_irq_bist: Set the specified bits in the current interrupt mask.
143 * @store_productid: Callback for cache product id from function 01
144 * @data: Private data pointer
145 *
146 */
147struct rmi_driver {
148 struct device_driver driver;
149
150 int (*reset_handler)(struct rmi_device *rmi_dev);
151 int (*clear_irq_bits)(struct rmi_device *rmi_dev, unsigned long *mask);
152 int (*set_irq_bits)(struct rmi_device *rmi_dev, unsigned long *mask);
153 int (*store_productid)(struct rmi_device *rmi_dev);
154 int (*set_input_params)(struct rmi_device *rmi_dev,
155 struct input_dev *input);
156 void *data;
157};
158
159/**
160 * struct rmi_device - represents an RMI4 sensor device on the RMI bus.
161 *
162 * @dev: The device created for the RMI bus
163 * @number: Unique number for the device on the bus.
164 * @driver: Pointer to associated driver
165 * @xport: Pointer to the transport interface
166 *
167 */
168struct rmi_device {
169 struct device dev;
170 int number;
171
172 struct rmi_driver *driver;
173 struct rmi_transport_dev *xport;
174
175};
176
177struct rmi_driver_data {
178 struct list_head function_list;
179
180 struct rmi_device *rmi_dev;
181
182 struct rmi_function *f01_container;
183 bool f01_bootloader_mode;
184
185 u32 attn_count;
186 int num_of_irq_regs;
187 int irq_count;
188 unsigned long *irq_status;
189 unsigned long *fn_irq_bits;
190 unsigned long *current_irq_mask;
191 unsigned long *new_irq_mask;
192 struct mutex irq_mutex;
193 struct input_dev *input;
194
195 u8 pdt_props;
196 u8 bsr;
197
198 bool enabled;
199
200 void *data;
201};
202
203int rmi_register_transport_device(struct rmi_transport_dev *xport);
204void rmi_unregister_transport_device(struct rmi_transport_dev *xport);
205int rmi_process_interrupt_requests(struct rmi_device *rmi_dev);
206
207int rmi_driver_suspend(struct rmi_device *rmi_dev);
208int rmi_driver_resume(struct rmi_device *rmi_dev);
209#endif
diff --git a/include/uapi/linux/input.h b/include/uapi/linux/input.h
index 2758687300b4..01113841190d 100644
--- a/include/uapi/linux/input.h
+++ b/include/uapi/linux/input.h
@@ -246,6 +246,7 @@ struct input_mask {
246#define BUS_GSC 0x1A 246#define BUS_GSC 0x1A
247#define BUS_ATARI 0x1B 247#define BUS_ATARI 0x1B
248#define BUS_SPI 0x1C 248#define BUS_SPI 0x1C
249#define BUS_RMI 0x1D
249 250
250/* 251/*
251 * MT_TOOL types 252 * MT_TOOL types
generated by cgit v1.2.2 (git 2.25.0) at 2025-09-10 21:23:27 -0400