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/kfifo.h>
17#include <linux/list.h>
18#include <linux/module.h>
19#include <linux/types.h>
20
21#define NAME_BUFFER_SIZE 256
22
23/**
24 * struct rmi_2d_axis_alignment - target axis alignment
25 * @swap_axes: set to TRUE if desired to swap x- and y-axis
26 * @flip_x: set to TRUE if desired to flip direction on x-axis
27 * @flip_y: set to TRUE if desired to flip direction on y-axis
28 * @clip_x_low - reported X coordinates below this setting will be clipped to
29 * the specified value
30 * @clip_x_high - reported X coordinates above this setting will be clipped to
31 * the specified value
32 * @clip_y_low - reported Y coordinates below this setting will be clipped to
33 * the specified value
34 * @clip_y_high - reported Y coordinates above this setting will be clipped to
35 * the specified value
36 * @offset_x - this value will be added to all reported X coordinates
37 * @offset_y - this value will be added to all reported Y coordinates
38 * @rel_report_enabled - if set to true, the relative reporting will be
39 * automatically enabled for this sensor.
40 */
41struct rmi_2d_axis_alignment {
42 bool swap_axes;
43 bool flip_x;
44 bool flip_y;
45 u16 clip_x_low;
46 u16 clip_y_low;
47 u16 clip_x_high;
48 u16 clip_y_high;
49 u16 offset_x;
50 u16 offset_y;
51 u8 delta_x_threshold;
52 u8 delta_y_threshold;
53};
54
55/** This is used to override any hints an F11 2D sensor might have provided
56 * as to what type of sensor it is.
57 *
58 * @rmi_f11_sensor_default - do not override, determine from F11_2D_QUERY14 if
59 * available.
60 * @rmi_f11_sensor_touchscreen - treat the sensor as a touchscreen (direct
61 * pointing).
62 * @rmi_f11_sensor_touchpad - thread the sensor as a touchpad (indirect
63 * pointing).
64 */
65enum rmi_sensor_type {
66 rmi_sensor_default = 0,
67 rmi_sensor_touchscreen,
68 rmi_sensor_touchpad
69};
70
71#define RMI_F11_DISABLE_ABS_REPORT BIT(0)
72
73/**
74 * struct rmi_2d_sensor_data - overrides defaults for a 2D sensor.
75 * @axis_align - provides axis alignment overrides (see above).
76 * @sensor_type - Forces the driver to treat the sensor as an indirect
77 * pointing device (touchpad) rather than a direct pointing device
78 * (touchscreen). This is useful when F11_2D_QUERY14 register is not
79 * available.
80 * @disable_report_mask - Force data to not be reported even if it is supported
81 * by the firware.
82 * @topbuttonpad - Used with the "5 buttons touchpads" found on the Lenovo 40
83 * series
84 * @kernel_tracking - most moderns RMI f11 firmwares implement Multifinger
85 * Type B protocol. However, there are some corner cases where the user
86 * triggers some jumps by tapping with two fingers on the touchpad.
87 * Use this setting and dmax to filter out these jumps.
88 * Also, when using an old sensor using MF Type A behavior, set to true to
89 * report an actual MT protocol B.
90 * @dmax - the maximum distance (in sensor units) the kernel tracking allows two
91 * distincts fingers to be considered the same.
92 */
93struct rmi_2d_sensor_platform_data {
94 struct rmi_2d_axis_alignment axis_align;
95 enum rmi_sensor_type sensor_type;
96 int x_mm;
97 int y_mm;
98 int disable_report_mask;
99 u16 rezero_wait;
100 bool topbuttonpad;
101 bool kernel_tracking;
102 int dmax;
103 int dribble;
104 int palm_detect;
105};
106
107/**
108 * struct rmi_f30_data - overrides defaults for a single F30 GPIOs/LED chip.
109 * @buttonpad - the touchpad is a buttonpad, so enable only the first actual
110 * button that is found.
111 * @trackstick_buttons - Set when the function 30 is handling the physical
112 * buttons of the trackstick (as a PS/2 passthrough device).
113 * @disable - the touchpad incorrectly reports F30 and it should be ignored.
114 * This is a special case which is due to misconfigured firmware.
115 */
116struct rmi_f30_data {
117 bool buttonpad;
118 bool trackstick_buttons;
119 bool disable;
120};
121
122
123/*
124 * Set the state of a register
125 * DEFAULT - use the default value set by the firmware config
126 * OFF - explicitly disable the register
127 * ON - explicitly enable the register
128 */
129enum rmi_reg_state {
130 RMI_REG_STATE_DEFAULT = 0,
131 RMI_REG_STATE_OFF = 1,
132 RMI_REG_STATE_ON = 2
133};
134
135/**
136 * struct rmi_f01_power_management -When non-zero, these values will be written
137 * to the touch sensor to override the default firmware settigns. For a
138 * detailed explanation of what each field does, see the corresponding
139 * documention in the RMI4 specification.
140 *
141 * @nosleep - specifies whether the device is permitted to sleep or doze (that
142 * is, enter a temporary low power state) when no fingers are touching the
143 * sensor.
144 * @wakeup_threshold - controls the capacitance threshold at which the touch
145 * sensor will decide to wake up from that low power state.
146 * @doze_holdoff - controls how long the touch sensor waits after the last
147 * finger lifts before entering the doze state, in units of 100ms.
148 * @doze_interval - controls the interval between checks for finger presence
149 * when the touch sensor is in doze mode, in units of 10ms.
150 */
151struct rmi_f01_power_management {
152 enum rmi_reg_state nosleep;
153 u8 wakeup_threshold;
154 u8 doze_holdoff;
155 u8 doze_interval;
156};
157
158/**
159 * struct rmi_device_platform_data_spi - provides parameters used in SPI
160 * communications. All Synaptics SPI products support a standard SPI
161 * interface; some also support what is called SPI V2 mode, depending on
162 * firmware and/or ASIC limitations. In V2 mode, the touch sensor can
163 * support shorter delays during certain operations, and these are specified
164 * separately from the standard mode delays.
165 *
166 * @block_delay - for standard SPI transactions consisting of both a read and
167 * write operation, the delay (in microseconds) between the read and write
168 * operations.
169 * @split_read_block_delay_us - for V2 SPI transactions consisting of both a
170 * read and write operation, the delay (in microseconds) between the read and
171 * write operations.
172 * @read_delay_us - the delay between each byte of a read operation in normal
173 * SPI mode.
174 * @write_delay_us - the delay between each byte of a write operation in normal
175 * SPI mode.
176 * @split_read_byte_delay_us - the delay between each byte of a read operation
177 * in V2 mode.
178 * @pre_delay_us - the delay before the start of a SPI transaction. This is
179 * typically useful in conjunction with custom chip select assertions (see
180 * below).
181 * @post_delay_us - the delay after the completion of an SPI transaction. This
182 * is typically useful in conjunction with custom chip select assertions (see
183 * below).
184 * @cs_assert - For systems where the SPI subsystem does not control the CS/SSB
185 * line, or where such control is broken, you can provide a custom routine to
186 * handle a GPIO as CS/SSB. This routine will be called at the beginning and
187 * end of each SPI transaction. The RMI SPI implementation will wait
188 * pre_delay_us after this routine returns before starting the SPI transfer;
189 * and post_delay_us after completion of the SPI transfer(s) before calling it
190 * with assert==FALSE.
191 */
192struct rmi_device_platform_data_spi {
193 u32 block_delay_us;
194 u32 split_read_block_delay_us;
195 u32 read_delay_us;
196 u32 write_delay_us;
197 u32 split_read_byte_delay_us;
198 u32 pre_delay_us;
199 u32 post_delay_us;
200 u8 bits_per_word;
201 u16 mode;
202
203 void *cs_assert_data;
204 int (*cs_assert)(const void *cs_assert_data, const bool assert);
205};
206
207/**
208 * struct rmi_device_platform_data - system specific configuration info.
209 *
210 * @reset_delay_ms - after issuing a reset command to the touch sensor, the
211 * driver waits a few milliseconds to give the firmware a chance to
212 * to re-initialize. You can override the default wait period here.
213 * @irq: irq associated with the attn gpio line, or negative
214 */
215struct rmi_device_platform_data {
216 int reset_delay_ms;
217 int irq;
218
219 struct rmi_device_platform_data_spi spi_data;
220
221 /* function handler pdata */
222 struct rmi_2d_sensor_platform_data sensor_pdata;
223 struct rmi_f01_power_management power_management;
224 struct rmi_f30_data f30_data;
225};
226
227/**
228 * struct rmi_function_descriptor - RMI function base addresses
229 *
230 * @query_base_addr: The RMI Query base address
231 * @command_base_addr: The RMI Command base address
232 * @control_base_addr: The RMI Control base address
233 * @data_base_addr: The RMI Data base address
234 * @interrupt_source_count: The number of irqs this RMI function needs
235 * @function_number: The RMI function number
236 *
237 * This struct is used when iterating the Page Description Table. The addresses
238 * are 16-bit values to include the current page address.
239 *
240 */
241struct rmi_function_descriptor {
242 u16 query_base_addr;
243 u16 command_base_addr;
244 u16 control_base_addr;
245 u16 data_base_addr;
246 u8 interrupt_source_count;
247 u8 function_number;
248 u8 function_version;
249};
250
251struct rmi_device;
252
253/**
254 * struct rmi_transport_dev - represent an RMI transport device
255 *
256 * @dev: Pointer to the communication device, e.g. i2c or spi
257 * @rmi_dev: Pointer to the RMI device
258 * @proto_name: name of the transport protocol (SPI, i2c, etc)
259 * @ops: pointer to transport operations implementation
260 *
261 * The RMI transport device implements the glue between different communication
262 * buses such as I2C and SPI.
263 *
264 */
265struct rmi_transport_dev {
266 struct device *dev;
267 struct rmi_device *rmi_dev;
268
269 const char *proto_name;
270 const struct rmi_transport_ops *ops;
271
272 struct rmi_device_platform_data pdata;
273
274 struct input_dev *input;
275};
276
277/**
278 * struct rmi_transport_ops - defines transport protocol operations.
279 *
280 * @write_block: Writing a block of data to the specified address
281 * @read_block: Read a block of data from the specified address.
282 */
283struct rmi_transport_ops {
284 int (*write_block)(struct rmi_transport_dev *xport, u16 addr,
285 const void *buf, size_t len);
286 int (*read_block)(struct rmi_transport_dev *xport, u16 addr,
287 void *buf, size_t len);
288 int (*reset)(struct rmi_transport_dev *xport, u16 reset_addr);
289};
290
291/**
292 * struct rmi_driver - driver for an RMI4 sensor on the RMI bus.
293 *
294 * @driver: Device driver model driver
295 * @reset_handler: Called when a reset is detected.
296 * @clear_irq_bits: Clear the specified bits in the current interrupt mask.
297 * @set_irq_bist: Set the specified bits in the current interrupt mask.
298 * @store_productid: Callback for cache product id from function 01
299 * @data: Private data pointer
300 *
301 */
302struct rmi_driver {
303 struct device_driver driver;
304
305 int (*reset_handler)(struct rmi_device *rmi_dev);
306 int (*clear_irq_bits)(struct rmi_device *rmi_dev, unsigned long *mask);
307 int (*set_irq_bits)(struct rmi_device *rmi_dev, unsigned long *mask);
308 int (*store_productid)(struct rmi_device *rmi_dev);
309 int (*set_input_params)(struct rmi_device *rmi_dev,
310 struct input_dev *input);
311 void *data;
312};
313
314/**
315 * struct rmi_device - represents an RMI4 sensor device on the RMI bus.
316 *
317 * @dev: The device created for the RMI bus
318 * @number: Unique number for the device on the bus.
319 * @driver: Pointer to associated driver
320 * @xport: Pointer to the transport interface
321 *
322 */
323struct rmi_device {
324 struct device dev;
325 int number;
326
327 struct rmi_driver *driver;
328 struct rmi_transport_dev *xport;
329
330};
331
332struct rmi4_attn_data {
333 unsigned long irq_status;
334 size_t size;
335 void *data;
336};
337
338struct rmi_driver_data {
339 struct list_head function_list;
340
341 struct rmi_device *rmi_dev;
342
343 struct rmi_function *f01_container;
344 struct rmi_function *f34_container;
345 bool bootloader_mode;
346
347 int num_of_irq_regs;
348 int irq_count;
349 void *irq_memory;
350 unsigned long *irq_status;
351 unsigned long *fn_irq_bits;
352 unsigned long *current_irq_mask;
353 unsigned long *new_irq_mask;
354 struct mutex irq_mutex;
355 struct input_dev *input;
356
357 struct irq_domain *irqdomain;
358
359 u8 pdt_props;
360
361 u8 num_rx_electrodes;
362 u8 num_tx_electrodes;
363
364 bool enabled;
365 struct mutex enabled_mutex;
366
367 struct rmi4_attn_data attn_data;
368 DECLARE_KFIFO(attn_fifo, struct rmi4_attn_data, 16);
369};
370
371int rmi_register_transport_device(struct rmi_transport_dev *xport);
372void rmi_unregister_transport_device(struct rmi_transport_dev *xport);
373
374void rmi_set_attn_data(struct rmi_device *rmi_dev, unsigned long irq_status,
375 void *data, size_t size);
376
377int rmi_driver_suspend(struct rmi_device *rmi_dev, bool enable_wake);
378int rmi_driver_resume(struct rmi_device *rmi_dev, bool clear_wake);
379#endif
380