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