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