]>
Commit | Line | Data |
---|---|---|
d2912cb1 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
ff8f8370 AD |
2 | /* |
3 | * Copyright (c) 2011-2015 Synaptics Incorporated | |
4 | * Copyright (c) 2011 Unixphere | |
ff8f8370 AD |
5 | */ |
6 | ||
7 | #include <linux/kernel.h> | |
8 | #include <linux/delay.h> | |
9 | #include <linux/device.h> | |
10 | #include <linux/input.h> | |
11 | #include <linux/input/mt.h> | |
ff8f8370 AD |
12 | #include <linux/rmi.h> |
13 | #include <linux/slab.h> | |
14 | #include <linux/of.h> | |
15 | #include "rmi_driver.h" | |
16 | #include "rmi_2d_sensor.h" | |
17 | ||
18 | #define F11_MAX_NUM_OF_FINGERS 10 | |
19 | #define F11_MAX_NUM_OF_TOUCH_SHAPES 16 | |
20 | ||
21 | #define FINGER_STATE_MASK 0x03 | |
22 | ||
23 | #define F11_CTRL_SENSOR_MAX_X_POS_OFFSET 6 | |
24 | #define F11_CTRL_SENSOR_MAX_Y_POS_OFFSET 8 | |
25 | ||
26 | #define DEFAULT_XY_MAX 9999 | |
27 | #define DEFAULT_MAX_ABS_MT_PRESSURE 255 | |
28 | #define DEFAULT_MAX_ABS_MT_TOUCH 15 | |
29 | #define DEFAULT_MAX_ABS_MT_ORIENTATION 1 | |
30 | #define DEFAULT_MIN_ABS_MT_TRACKING_ID 1 | |
31 | #define DEFAULT_MAX_ABS_MT_TRACKING_ID 10 | |
32 | ||
33 | /** A note about RMI4 F11 register structure. | |
34 | * | |
35 | * The properties for | |
36 | * a given sensor are described by its query registers. The number of query | |
37 | * registers and the layout of their contents are described by the F11 device | |
38 | * queries as well as the sensor query information. | |
39 | * | |
40 | * Similarly, each sensor has control registers that govern its behavior. The | |
41 | * size and layout of the control registers for a given sensor can be determined | |
42 | * by parsing that sensors query registers. | |
43 | * | |
44 | * And in a likewise fashion, each sensor has data registers where it reports | |
45 | * its touch data and other interesting stuff. The size and layout of a | |
46 | * sensors data registers must be determined by parsing its query registers. | |
47 | * | |
48 | * The short story is that we need to read and parse a lot of query | |
49 | * registers in order to determine the attributes of a sensor. Then | |
50 | * we need to use that data to compute the size of the control and data | |
51 | * registers for sensor. | |
52 | * | |
53 | * The end result is that we have a number of structs that aren't used to | |
54 | * directly generate the input events, but their size, location and contents | |
55 | * are critical to determining where the data we are interested in lives. | |
56 | * | |
57 | * At this time, the driver does not yet comprehend all possible F11 | |
58 | * configuration options, but it should be sufficient to cover 99% of RMI4 F11 | |
59 | * devices currently in the field. | |
60 | */ | |
61 | ||
62 | /* maximum ABS_MT_POSITION displacement (in mm) */ | |
63 | #define DMAX 10 | |
64 | ||
65 | /** | |
66 | * @rezero - writing this to the F11 command register will cause the sensor to | |
67 | * calibrate to the current capacitive state. | |
68 | */ | |
69 | #define RMI_F11_REZERO 0x01 | |
70 | ||
71 | #define RMI_F11_HAS_QUERY9 (1 << 3) | |
72 | #define RMI_F11_HAS_QUERY11 (1 << 4) | |
73 | #define RMI_F11_HAS_QUERY12 (1 << 5) | |
74 | #define RMI_F11_HAS_QUERY27 (1 << 6) | |
75 | #define RMI_F11_HAS_QUERY28 (1 << 7) | |
76 | ||
77 | /** Defs for Query 1 */ | |
78 | ||
79 | #define RMI_F11_NR_FINGERS_MASK 0x07 | |
80 | #define RMI_F11_HAS_REL (1 << 3) | |
81 | #define RMI_F11_HAS_ABS (1 << 4) | |
82 | #define RMI_F11_HAS_GESTURES (1 << 5) | |
83 | #define RMI_F11_HAS_SENSITIVITY_ADJ (1 << 6) | |
84 | #define RMI_F11_CONFIGURABLE (1 << 7) | |
85 | ||
86 | /** Defs for Query 2, 3, and 4. */ | |
87 | #define RMI_F11_NR_ELECTRODES_MASK 0x7F | |
88 | ||
89 | /** Defs for Query 5 */ | |
90 | ||
91 | #define RMI_F11_ABS_DATA_SIZE_MASK 0x03 | |
92 | #define RMI_F11_HAS_ANCHORED_FINGER (1 << 2) | |
93 | #define RMI_F11_HAS_ADJ_HYST (1 << 3) | |
94 | #define RMI_F11_HAS_DRIBBLE (1 << 4) | |
95 | #define RMI_F11_HAS_BENDING_CORRECTION (1 << 5) | |
96 | #define RMI_F11_HAS_LARGE_OBJECT_SUPPRESSION (1 << 6) | |
97 | #define RMI_F11_HAS_JITTER_FILTER (1 << 7) | |
98 | ||
99 | /** Defs for Query 7 */ | |
100 | #define RMI_F11_HAS_SINGLE_TAP (1 << 0) | |
101 | #define RMI_F11_HAS_TAP_AND_HOLD (1 << 1) | |
102 | #define RMI_F11_HAS_DOUBLE_TAP (1 << 2) | |
103 | #define RMI_F11_HAS_EARLY_TAP (1 << 3) | |
104 | #define RMI_F11_HAS_FLICK (1 << 4) | |
105 | #define RMI_F11_HAS_PRESS (1 << 5) | |
106 | #define RMI_F11_HAS_PINCH (1 << 6) | |
107 | #define RMI_F11_HAS_CHIRAL (1 << 7) | |
108 | ||
109 | /** Defs for Query 8 */ | |
110 | #define RMI_F11_HAS_PALM_DET (1 << 0) | |
111 | #define RMI_F11_HAS_ROTATE (1 << 1) | |
112 | #define RMI_F11_HAS_TOUCH_SHAPES (1 << 2) | |
113 | #define RMI_F11_HAS_SCROLL_ZONES (1 << 3) | |
114 | #define RMI_F11_HAS_INDIVIDUAL_SCROLL_ZONES (1 << 4) | |
115 | #define RMI_F11_HAS_MF_SCROLL (1 << 5) | |
116 | #define RMI_F11_HAS_MF_EDGE_MOTION (1 << 6) | |
117 | #define RMI_F11_HAS_MF_SCROLL_INERTIA (1 << 7) | |
118 | ||
119 | /** Defs for Query 9. */ | |
120 | #define RMI_F11_HAS_PEN (1 << 0) | |
121 | #define RMI_F11_HAS_PROXIMITY (1 << 1) | |
122 | #define RMI_F11_HAS_PALM_DET_SENSITIVITY (1 << 2) | |
123 | #define RMI_F11_HAS_SUPPRESS_ON_PALM_DETECT (1 << 3) | |
124 | #define RMI_F11_HAS_TWO_PEN_THRESHOLDS (1 << 4) | |
125 | #define RMI_F11_HAS_CONTACT_GEOMETRY (1 << 5) | |
126 | #define RMI_F11_HAS_PEN_HOVER_DISCRIMINATION (1 << 6) | |
127 | #define RMI_F11_HAS_PEN_FILTERS (1 << 7) | |
128 | ||
129 | /** Defs for Query 10. */ | |
130 | #define RMI_F11_NR_TOUCH_SHAPES_MASK 0x1F | |
131 | ||
132 | /** Defs for Query 11 */ | |
133 | ||
134 | #define RMI_F11_HAS_Z_TUNING (1 << 0) | |
135 | #define RMI_F11_HAS_ALGORITHM_SELECTION (1 << 1) | |
136 | #define RMI_F11_HAS_W_TUNING (1 << 2) | |
137 | #define RMI_F11_HAS_PITCH_INFO (1 << 3) | |
138 | #define RMI_F11_HAS_FINGER_SIZE (1 << 4) | |
139 | #define RMI_F11_HAS_SEGMENTATION_AGGRESSIVENESS (1 << 5) | |
140 | #define RMI_F11_HAS_XY_CLIP (1 << 6) | |
141 | #define RMI_F11_HAS_DRUMMING_FILTER (1 << 7) | |
142 | ||
143 | /** Defs for Query 12. */ | |
144 | ||
145 | #define RMI_F11_HAS_GAPLESS_FINGER (1 << 0) | |
146 | #define RMI_F11_HAS_GAPLESS_FINGER_TUNING (1 << 1) | |
147 | #define RMI_F11_HAS_8BIT_W (1 << 2) | |
148 | #define RMI_F11_HAS_ADJUSTABLE_MAPPING (1 << 3) | |
149 | #define RMI_F11_HAS_INFO2 (1 << 4) | |
150 | #define RMI_F11_HAS_PHYSICAL_PROPS (1 << 5) | |
151 | #define RMI_F11_HAS_FINGER_LIMIT (1 << 6) | |
152 | #define RMI_F11_HAS_LINEAR_COEFF (1 << 7) | |
153 | ||
154 | /** Defs for Query 13. */ | |
155 | ||
156 | #define RMI_F11_JITTER_WINDOW_MASK 0x1F | |
157 | #define RMI_F11_JITTER_FILTER_MASK 0x60 | |
158 | #define RMI_F11_JITTER_FILTER_SHIFT 5 | |
159 | ||
160 | /** Defs for Query 14. */ | |
161 | #define RMI_F11_LIGHT_CONTROL_MASK 0x03 | |
162 | #define RMI_F11_IS_CLEAR (1 << 2) | |
163 | #define RMI_F11_CLICKPAD_PROPS_MASK 0x18 | |
164 | #define RMI_F11_CLICKPAD_PROPS_SHIFT 3 | |
165 | #define RMI_F11_MOUSE_BUTTONS_MASK 0x60 | |
166 | #define RMI_F11_MOUSE_BUTTONS_SHIFT 5 | |
167 | #define RMI_F11_HAS_ADVANCED_GESTURES (1 << 7) | |
168 | ||
169 | #define RMI_F11_QUERY_SIZE 4 | |
170 | #define RMI_F11_QUERY_GESTURE_SIZE 2 | |
171 | ||
172 | #define F11_LIGHT_CTL_NONE 0x00 | |
173 | #define F11_LUXPAD 0x01 | |
174 | #define F11_DUAL_MODE 0x02 | |
175 | ||
176 | #define F11_NOT_CLICKPAD 0x00 | |
177 | #define F11_HINGED_CLICKPAD 0x01 | |
178 | #define F11_UNIFORM_CLICKPAD 0x02 | |
179 | ||
180 | /** | |
181 | * Query registers 1 through 4 are always present. | |
182 | * | |
183 | * @nr_fingers - describes the maximum number of fingers the 2-D sensor | |
184 | * supports. | |
185 | * @has_rel - the sensor supports relative motion reporting. | |
186 | * @has_abs - the sensor supports absolute poition reporting. | |
187 | * @has_gestures - the sensor supports gesture reporting. | |
188 | * @has_sensitivity_adjust - the sensor supports a global sensitivity | |
189 | * adjustment. | |
190 | * @configurable - the sensor supports various configuration options. | |
191 | * @num_of_x_electrodes - the maximum number of electrodes the 2-D sensor | |
192 | * supports on the X axis. | |
193 | * @num_of_y_electrodes - the maximum number of electrodes the 2-D sensor | |
194 | * supports on the Y axis. | |
195 | * @max_electrodes - the total number of X and Y electrodes that may be | |
196 | * configured. | |
197 | * | |
198 | * Query 5 is present if the has_abs bit is set. | |
199 | * | |
200 | * @abs_data_size - describes the format of data reported by the absolute | |
201 | * data source. Only one format (the kind used here) is supported at this | |
202 | * time. | |
203 | * @has_anchored_finger - then the sensor supports the high-precision second | |
204 | * finger tracking provided by the manual tracking and motion sensitivity | |
205 | * options. | |
206 | * @has_adjust_hyst - the difference between the finger release threshold and | |
207 | * the touch threshold. | |
208 | * @has_dribble - the sensor supports the generation of dribble interrupts, | |
209 | * which may be enabled or disabled with the dribble control bit. | |
210 | * @has_bending_correction - Bending related data registers 28 and 36, and | |
211 | * control register 52..57 are present. | |
212 | * @has_large_object_suppression - control register 58 and data register 28 | |
213 | * exist. | |
214 | * @has_jitter_filter - query 13 and control 73..76 exist. | |
215 | * | |
216 | * Gesture information queries 7 and 8 are present if has_gestures bit is set. | |
217 | * | |
218 | * @has_single_tap - a basic single-tap gesture is supported. | |
219 | * @has_tap_n_hold - tap-and-hold gesture is supported. | |
220 | * @has_double_tap - double-tap gesture is supported. | |
221 | * @has_early_tap - early tap is supported and reported as soon as the finger | |
222 | * lifts for any tap event that could be interpreted as either a single tap | |
223 | * or as the first tap of a double-tap or tap-and-hold gesture. | |
224 | * @has_flick - flick detection is supported. | |
225 | * @has_press - press gesture reporting is supported. | |
226 | * @has_pinch - pinch gesture detection is supported. | |
227 | * @has_palm_det - the 2-D sensor notifies the host whenever a large conductive | |
228 | * object such as a palm or a cheek touches the 2-D sensor. | |
229 | * @has_rotate - rotation gesture detection is supported. | |
230 | * @has_touch_shapes - TouchShapes are supported. A TouchShape is a fixed | |
231 | * rectangular area on the sensor that behaves like a capacitive button. | |
232 | * @has_scroll_zones - scrolling areas near the sensor edges are supported. | |
233 | * @has_individual_scroll_zones - if 1, then 4 scroll zones are supported; | |
234 | * if 0, then only two are supported. | |
235 | * @has_mf_scroll - the multifinger_scrolling bit will be set when | |
236 | * more than one finger is involved in a scrolling action. | |
237 | * | |
238 | * Convenience for checking bytes in the gesture info registers. This is done | |
239 | * often enough that we put it here to declutter the conditionals | |
240 | * | |
241 | * @query7_nonzero - true if none of the query 7 bits are set | |
242 | * @query8_nonzero - true if none of the query 8 bits are set | |
243 | * | |
244 | * Query 9 is present if the has_query9 is set. | |
245 | * | |
246 | * @has_pen - detection of a stylus is supported and registers F11_2D_Ctrl20 | |
247 | * and F11_2D_Ctrl21 exist. | |
248 | * @has_proximity - detection of fingers near the sensor is supported and | |
249 | * registers F11_2D_Ctrl22 through F11_2D_Ctrl26 exist. | |
250 | * @has_palm_det_sensitivity - the sensor supports the palm detect sensitivity | |
251 | * feature and register F11_2D_Ctrl27 exists. | |
252 | * @has_two_pen_thresholds - is has_pen is also set, then F11_2D_Ctrl35 exists. | |
253 | * @has_contact_geometry - the sensor supports the use of contact geometry to | |
254 | * map absolute X and Y target positions and registers F11_2D_Data18 | |
255 | * through F11_2D_Data27 exist. | |
256 | * | |
257 | * Touch shape info (query 10) is present if has_touch_shapes is set. | |
258 | * | |
259 | * @nr_touch_shapes - the total number of touch shapes supported. | |
260 | * | |
261 | * Query 11 is present if the has_query11 bit is set in query 0. | |
262 | * | |
263 | * @has_z_tuning - if set, the sensor supports Z tuning and registers | |
264 | * F11_2D_Ctrl29 through F11_2D_Ctrl33 exist. | |
265 | * @has_algorithm_selection - controls choice of noise suppression algorithm | |
266 | * @has_w_tuning - the sensor supports Wx and Wy scaling and registers | |
267 | * F11_2D_Ctrl36 through F11_2D_Ctrl39 exist. | |
268 | * @has_pitch_info - the X and Y pitches of the sensor electrodes can be | |
269 | * configured and registers F11_2D_Ctrl40 and F11_2D_Ctrl41 exist. | |
270 | * @has_finger_size - the default finger width settings for the | |
271 | * sensor can be configured and registers F11_2D_Ctrl42 through F11_2D_Ctrl44 | |
272 | * exist. | |
273 | * @has_segmentation_aggressiveness - the sensor’s ability to distinguish | |
274 | * multiple objects close together can be configured and register F11_2D_Ctrl45 | |
275 | * exists. | |
276 | * @has_XY_clip - the inactive outside borders of the sensor can be | |
277 | * configured and registers F11_2D_Ctrl46 through F11_2D_Ctrl49 exist. | |
278 | * @has_drumming_filter - the sensor can be configured to distinguish | |
279 | * between a fast flick and a quick drumming movement and registers | |
280 | * F11_2D_Ctrl50 and F11_2D_Ctrl51 exist. | |
281 | * | |
282 | * Query 12 is present if hasQuery12 bit is set. | |
283 | * | |
284 | * @has_gapless_finger - control registers relating to gapless finger are | |
285 | * present. | |
286 | * @has_gapless_finger_tuning - additional control and data registers relating | |
287 | * to gapless finger are present. | |
288 | * @has_8bit_w - larger W value reporting is supported. | |
289 | * @has_adjustable_mapping - TBD | |
290 | * @has_info2 - the general info query14 is present | |
291 | * @has_physical_props - additional queries describing the physical properties | |
292 | * of the sensor are present. | |
293 | * @has_finger_limit - indicates that F11 Ctrl 80 exists. | |
294 | * @has_linear_coeff - indicates that F11 Ctrl 81 exists. | |
295 | * | |
296 | * Query 13 is present if Query 5's has_jitter_filter bit is set. | |
297 | * @jitter_window_size - used by Design Studio 4. | |
298 | * @jitter_filter_type - used by Design Studio 4. | |
299 | * | |
300 | * Query 14 is present if query 12's has_general_info2 flag is set. | |
301 | * | |
302 | * @light_control - Indicates what light/led control features are present, if | |
303 | * any. | |
304 | * @is_clear - if set, this is a clear sensor (indicating direct pointing | |
305 | * application), otherwise it's opaque (indicating indirect pointing). | |
306 | * @clickpad_props - specifies if this is a clickpad, and if so what sort of | |
307 | * mechanism it uses | |
308 | * @mouse_buttons - specifies the number of mouse buttons present (if any). | |
309 | * @has_advanced_gestures - advanced driver gestures are supported. | |
310 | */ | |
311 | struct f11_2d_sensor_queries { | |
312 | /* query1 */ | |
313 | u8 nr_fingers; | |
314 | bool has_rel; | |
315 | bool has_abs; | |
316 | bool has_gestures; | |
317 | bool has_sensitivity_adjust; | |
318 | bool configurable; | |
319 | ||
320 | /* query2 */ | |
321 | u8 nr_x_electrodes; | |
322 | ||
323 | /* query3 */ | |
324 | u8 nr_y_electrodes; | |
325 | ||
326 | /* query4 */ | |
327 | u8 max_electrodes; | |
328 | ||
329 | /* query5 */ | |
330 | u8 abs_data_size; | |
331 | bool has_anchored_finger; | |
332 | bool has_adj_hyst; | |
333 | bool has_dribble; | |
334 | bool has_bending_correction; | |
335 | bool has_large_object_suppression; | |
336 | bool has_jitter_filter; | |
337 | ||
338 | u8 f11_2d_query6; | |
339 | ||
340 | /* query 7 */ | |
341 | bool has_single_tap; | |
342 | bool has_tap_n_hold; | |
343 | bool has_double_tap; | |
344 | bool has_early_tap; | |
345 | bool has_flick; | |
346 | bool has_press; | |
347 | bool has_pinch; | |
348 | bool has_chiral; | |
349 | ||
350 | bool query7_nonzero; | |
351 | ||
352 | /* query 8 */ | |
353 | bool has_palm_det; | |
354 | bool has_rotate; | |
355 | bool has_touch_shapes; | |
356 | bool has_scroll_zones; | |
357 | bool has_individual_scroll_zones; | |
358 | bool has_mf_scroll; | |
359 | bool has_mf_edge_motion; | |
360 | bool has_mf_scroll_inertia; | |
361 | ||
362 | bool query8_nonzero; | |
363 | ||
364 | /* Query 9 */ | |
365 | bool has_pen; | |
366 | bool has_proximity; | |
367 | bool has_palm_det_sensitivity; | |
368 | bool has_suppress_on_palm_detect; | |
369 | bool has_two_pen_thresholds; | |
370 | bool has_contact_geometry; | |
371 | bool has_pen_hover_discrimination; | |
372 | bool has_pen_filters; | |
373 | ||
374 | /* Query 10 */ | |
375 | u8 nr_touch_shapes; | |
376 | ||
377 | /* Query 11. */ | |
378 | bool has_z_tuning; | |
379 | bool has_algorithm_selection; | |
380 | bool has_w_tuning; | |
381 | bool has_pitch_info; | |
382 | bool has_finger_size; | |
383 | bool has_segmentation_aggressiveness; | |
384 | bool has_XY_clip; | |
385 | bool has_drumming_filter; | |
386 | ||
387 | /* Query 12 */ | |
388 | bool has_gapless_finger; | |
389 | bool has_gapless_finger_tuning; | |
390 | bool has_8bit_w; | |
391 | bool has_adjustable_mapping; | |
392 | bool has_info2; | |
393 | bool has_physical_props; | |
394 | bool has_finger_limit; | |
395 | bool has_linear_coeff_2; | |
396 | ||
397 | /* Query 13 */ | |
398 | u8 jitter_window_size; | |
399 | u8 jitter_filter_type; | |
400 | ||
401 | /* Query 14 */ | |
402 | u8 light_control; | |
403 | bool is_clear; | |
404 | u8 clickpad_props; | |
405 | u8 mouse_buttons; | |
406 | bool has_advanced_gestures; | |
407 | ||
408 | /* Query 15 - 18 */ | |
409 | u16 x_sensor_size_mm; | |
410 | u16 y_sensor_size_mm; | |
411 | }; | |
412 | ||
413 | /* Defs for Ctrl0. */ | |
414 | #define RMI_F11_REPORT_MODE_MASK 0x07 | |
415 | #define RMI_F11_ABS_POS_FILT (1 << 3) | |
416 | #define RMI_F11_REL_POS_FILT (1 << 4) | |
417 | #define RMI_F11_REL_BALLISTICS (1 << 5) | |
418 | #define RMI_F11_DRIBBLE (1 << 6) | |
419 | #define RMI_F11_REPORT_BEYOND_CLIP (1 << 7) | |
420 | ||
421 | /* Defs for Ctrl1. */ | |
422 | #define RMI_F11_PALM_DETECT_THRESH_MASK 0x0F | |
423 | #define RMI_F11_MOTION_SENSITIVITY_MASK 0x30 | |
424 | #define RMI_F11_MANUAL_TRACKING (1 << 6) | |
425 | #define RMI_F11_MANUAL_TRACKED_FINGER (1 << 7) | |
426 | ||
427 | #define RMI_F11_DELTA_X_THRESHOLD 2 | |
428 | #define RMI_F11_DELTA_Y_THRESHOLD 3 | |
429 | ||
430 | #define RMI_F11_CTRL_REG_COUNT 12 | |
431 | ||
432 | struct f11_2d_ctrl { | |
433 | u8 ctrl0_11[RMI_F11_CTRL_REG_COUNT]; | |
434 | u16 ctrl0_11_address; | |
435 | }; | |
436 | ||
437 | #define RMI_F11_ABS_BYTES 5 | |
438 | #define RMI_F11_REL_BYTES 2 | |
439 | ||
440 | /* Defs for Data 8 */ | |
441 | ||
442 | #define RMI_F11_SINGLE_TAP (1 << 0) | |
443 | #define RMI_F11_TAP_AND_HOLD (1 << 1) | |
444 | #define RMI_F11_DOUBLE_TAP (1 << 2) | |
445 | #define RMI_F11_EARLY_TAP (1 << 3) | |
446 | #define RMI_F11_FLICK (1 << 4) | |
447 | #define RMI_F11_PRESS (1 << 5) | |
448 | #define RMI_F11_PINCH (1 << 6) | |
449 | ||
450 | /* Defs for Data 9 */ | |
451 | ||
452 | #define RMI_F11_PALM_DETECT (1 << 0) | |
453 | #define RMI_F11_ROTATE (1 << 1) | |
454 | #define RMI_F11_SHAPE (1 << 2) | |
455 | #define RMI_F11_SCROLLZONE (1 << 3) | |
456 | #define RMI_F11_GESTURE_FINGER_COUNT_MASK 0x70 | |
457 | ||
458 | /** Handy pointers into our data buffer. | |
459 | * | |
460 | * @f_state - start of finger state registers. | |
461 | * @abs_pos - start of absolute position registers (if present). | |
462 | * @rel_pos - start of relative data registers (if present). | |
463 | * @gest_1 - gesture flags (if present). | |
464 | * @gest_2 - gesture flags & finger count (if present). | |
465 | * @pinch - pinch motion register (if present). | |
466 | * @flick - flick distance X & Y, flick time (if present). | |
467 | * @rotate - rotate motion and finger separation. | |
468 | * @multi_scroll - chiral deltas for X and Y (if present). | |
469 | * @scroll_zones - scroll deltas for 4 regions (if present). | |
470 | */ | |
471 | struct f11_2d_data { | |
472 | u8 *f_state; | |
473 | u8 *abs_pos; | |
474 | s8 *rel_pos; | |
475 | u8 *gest_1; | |
476 | u8 *gest_2; | |
477 | s8 *pinch; | |
478 | u8 *flick; | |
479 | u8 *rotate; | |
480 | u8 *shapes; | |
481 | s8 *multi_scroll; | |
482 | s8 *scroll_zones; | |
483 | }; | |
484 | ||
485 | /** Data pertaining to F11 in general. For per-sensor data, see struct | |
486 | * f11_2d_sensor. | |
487 | * | |
488 | * @dev_query - F11 device specific query registers. | |
489 | * @dev_controls - F11 device specific control registers. | |
490 | * @dev_controls_mutex - lock for the control registers. | |
491 | * @rezero_wait_ms - if nonzero, upon resume we will wait this many | |
492 | * milliseconds before rezeroing the sensor(s). This is useful in systems with | |
493 | * poor electrical behavior on resume, where the initial calibration of the | |
494 | * sensor(s) coming out of sleep state may be bogus. | |
495 | * @sensors - per sensor data structures. | |
496 | */ | |
497 | struct f11_data { | |
498 | bool has_query9; | |
499 | bool has_query11; | |
500 | bool has_query12; | |
501 | bool has_query27; | |
502 | bool has_query28; | |
503 | bool has_acm; | |
504 | struct f11_2d_ctrl dev_controls; | |
505 | struct mutex dev_controls_mutex; | |
506 | u16 rezero_wait_ms; | |
507 | struct rmi_2d_sensor sensor; | |
508 | struct f11_2d_sensor_queries sens_query; | |
509 | struct f11_2d_data data; | |
510 | struct rmi_2d_sensor_platform_data sensor_pdata; | |
511 | unsigned long *abs_mask; | |
512 | unsigned long *rel_mask; | |
513 | unsigned long *result_bits; | |
514 | }; | |
515 | ||
516 | enum f11_finger_state { | |
517 | F11_NO_FINGER = 0x00, | |
518 | F11_PRESENT = 0x01, | |
519 | F11_INACCURATE = 0x02, | |
520 | F11_RESERVED = 0x03 | |
521 | }; | |
522 | ||
523 | static void rmi_f11_rel_pos_report(struct f11_data *f11, u8 n_finger) | |
524 | { | |
525 | struct rmi_2d_sensor *sensor = &f11->sensor; | |
526 | struct f11_2d_data *data = &f11->data; | |
527 | s8 x, y; | |
528 | ||
345ded8e AD |
529 | x = data->rel_pos[n_finger * RMI_F11_REL_BYTES]; |
530 | y = data->rel_pos[n_finger * RMI_F11_REL_BYTES + 1]; | |
ff8f8370 AD |
531 | |
532 | rmi_2d_sensor_rel_report(sensor, x, y); | |
533 | } | |
534 | ||
535 | static void rmi_f11_abs_pos_process(struct f11_data *f11, | |
536 | struct rmi_2d_sensor *sensor, | |
537 | struct rmi_2d_sensor_abs_object *obj, | |
538 | enum f11_finger_state finger_state, | |
539 | u8 n_finger) | |
540 | { | |
541 | struct f11_2d_data *data = &f11->data; | |
542 | u8 *pos_data = &data->abs_pos[n_finger * RMI_F11_ABS_BYTES]; | |
543 | int tool_type = MT_TOOL_FINGER; | |
544 | ||
545 | switch (finger_state) { | |
546 | case F11_PRESENT: | |
547 | obj->type = RMI_2D_OBJECT_FINGER; | |
548 | break; | |
549 | default: | |
550 | obj->type = RMI_2D_OBJECT_NONE; | |
551 | } | |
552 | ||
553 | obj->mt_tool = tool_type; | |
554 | obj->x = (pos_data[0] << 4) | (pos_data[2] & 0x0F); | |
555 | obj->y = (pos_data[1] << 4) | (pos_data[2] >> 4); | |
556 | obj->z = pos_data[4]; | |
557 | obj->wx = pos_data[3] & 0x0f; | |
558 | obj->wy = pos_data[3] >> 4; | |
559 | ||
560 | rmi_2d_sensor_abs_process(sensor, obj, n_finger); | |
561 | } | |
562 | ||
563 | static inline u8 rmi_f11_parse_finger_state(const u8 *f_state, u8 n_finger) | |
564 | { | |
565 | return (f_state[n_finger / 4] >> (2 * (n_finger % 4))) & | |
566 | FINGER_STATE_MASK; | |
567 | } | |
568 | ||
569 | static void rmi_f11_finger_handler(struct f11_data *f11, | |
24d28e4f | 570 | struct rmi_2d_sensor *sensor, int size) |
ff8f8370 AD |
571 | { |
572 | const u8 *f_state = f11->data.f_state; | |
573 | u8 finger_state; | |
574 | u8 i; | |
6d0dbeae AD |
575 | int abs_fingers; |
576 | int rel_fingers; | |
577 | int abs_size = sensor->nbr_fingers * RMI_F11_ABS_BYTES; | |
ff8f8370 | 578 | |
24d28e4f | 579 | if (sensor->report_abs) { |
6d0dbeae AD |
580 | if (abs_size > size) |
581 | abs_fingers = size / RMI_F11_ABS_BYTES; | |
582 | else | |
583 | abs_fingers = sensor->nbr_fingers; | |
584 | ||
585 | for (i = 0; i < abs_fingers; i++) { | |
586 | /* Possible of having 4 fingers per f_state register */ | |
587 | finger_state = rmi_f11_parse_finger_state(f_state, i); | |
588 | if (finger_state == F11_RESERVED) { | |
589 | pr_err("Invalid finger state[%d]: 0x%02x", i, | |
590 | finger_state); | |
591 | continue; | |
592 | } | |
ff8f8370 | 593 | |
ff8f8370 AD |
594 | rmi_f11_abs_pos_process(f11, sensor, &sensor->objs[i], |
595 | finger_state, i); | |
6d0dbeae | 596 | } |
6d0dbeae | 597 | |
ff8f8370 AD |
598 | /* |
599 | * the absolute part is made in 2 parts to allow the kernel | |
600 | * tracking to take place. | |
601 | */ | |
602 | if (sensor->kernel_tracking) | |
603 | input_mt_assign_slots(sensor->input, | |
604 | sensor->tracking_slots, | |
605 | sensor->tracking_pos, | |
606 | sensor->nbr_fingers, | |
607 | sensor->dmax); | |
608 | ||
6d0dbeae | 609 | for (i = 0; i < abs_fingers; i++) { |
ff8f8370 AD |
610 | finger_state = rmi_f11_parse_finger_state(f_state, i); |
611 | if (finger_state == F11_RESERVED) | |
612 | /* no need to send twice the error */ | |
613 | continue; | |
614 | ||
615 | rmi_2d_sensor_abs_report(sensor, &sensor->objs[i], i); | |
616 | } | |
617 | ||
618 | input_mt_sync_frame(sensor->input); | |
24d28e4f ND |
619 | } else if (sensor->report_rel) { |
620 | if ((abs_size + sensor->nbr_fingers * RMI_F11_REL_BYTES) > size) | |
621 | rel_fingers = (size - abs_size) / RMI_F11_REL_BYTES; | |
622 | else | |
623 | rel_fingers = sensor->nbr_fingers; | |
624 | ||
625 | for (i = 0; i < rel_fingers; i++) | |
626 | rmi_f11_rel_pos_report(f11, i); | |
ff8f8370 | 627 | } |
24d28e4f | 628 | |
ff8f8370 AD |
629 | } |
630 | ||
631 | static int f11_2d_construct_data(struct f11_data *f11) | |
632 | { | |
633 | struct rmi_2d_sensor *sensor = &f11->sensor; | |
634 | struct f11_2d_sensor_queries *query = &f11->sens_query; | |
635 | struct f11_2d_data *data = &f11->data; | |
636 | int i; | |
637 | ||
638 | sensor->nbr_fingers = (query->nr_fingers == 5 ? 10 : | |
639 | query->nr_fingers + 1); | |
640 | ||
641 | sensor->pkt_size = DIV_ROUND_UP(sensor->nbr_fingers, 4); | |
642 | ||
643 | if (query->has_abs) { | |
644 | sensor->pkt_size += (sensor->nbr_fingers * 5); | |
645 | sensor->attn_size = sensor->pkt_size; | |
646 | } | |
647 | ||
648 | if (query->has_rel) | |
649 | sensor->pkt_size += (sensor->nbr_fingers * 2); | |
650 | ||
651 | /* Check if F11_2D_Query7 is non-zero */ | |
652 | if (query->query7_nonzero) | |
653 | sensor->pkt_size += sizeof(u8); | |
654 | ||
655 | /* Check if F11_2D_Query7 or F11_2D_Query8 is non-zero */ | |
656 | if (query->query7_nonzero || query->query8_nonzero) | |
657 | sensor->pkt_size += sizeof(u8); | |
658 | ||
659 | if (query->has_pinch || query->has_flick || query->has_rotate) { | |
660 | sensor->pkt_size += 3; | |
661 | if (!query->has_flick) | |
662 | sensor->pkt_size--; | |
663 | if (!query->has_rotate) | |
664 | sensor->pkt_size--; | |
665 | } | |
666 | ||
667 | if (query->has_touch_shapes) | |
668 | sensor->pkt_size += | |
669 | DIV_ROUND_UP(query->nr_touch_shapes + 1, 8); | |
670 | ||
671 | sensor->data_pkt = devm_kzalloc(&sensor->fn->dev, sensor->pkt_size, | |
672 | GFP_KERNEL); | |
673 | if (!sensor->data_pkt) | |
674 | return -ENOMEM; | |
675 | ||
676 | data->f_state = sensor->data_pkt; | |
677 | i = DIV_ROUND_UP(sensor->nbr_fingers, 4); | |
678 | ||
679 | if (query->has_abs) { | |
680 | data->abs_pos = &sensor->data_pkt[i]; | |
681 | i += (sensor->nbr_fingers * RMI_F11_ABS_BYTES); | |
682 | } | |
683 | ||
684 | if (query->has_rel) { | |
685 | data->rel_pos = &sensor->data_pkt[i]; | |
686 | i += (sensor->nbr_fingers * RMI_F11_REL_BYTES); | |
687 | } | |
688 | ||
689 | if (query->query7_nonzero) { | |
690 | data->gest_1 = &sensor->data_pkt[i]; | |
691 | i++; | |
692 | } | |
693 | ||
694 | if (query->query7_nonzero || query->query8_nonzero) { | |
695 | data->gest_2 = &sensor->data_pkt[i]; | |
696 | i++; | |
697 | } | |
698 | ||
699 | if (query->has_pinch) { | |
700 | data->pinch = &sensor->data_pkt[i]; | |
701 | i++; | |
702 | } | |
703 | ||
704 | if (query->has_flick) { | |
705 | if (query->has_pinch) { | |
706 | data->flick = data->pinch; | |
707 | i += 2; | |
708 | } else { | |
709 | data->flick = &sensor->data_pkt[i]; | |
710 | i += 3; | |
711 | } | |
712 | } | |
713 | ||
714 | if (query->has_rotate) { | |
715 | if (query->has_flick) { | |
716 | data->rotate = data->flick + 1; | |
717 | } else { | |
718 | data->rotate = &sensor->data_pkt[i]; | |
719 | i += 2; | |
720 | } | |
721 | } | |
722 | ||
723 | if (query->has_touch_shapes) | |
724 | data->shapes = &sensor->data_pkt[i]; | |
725 | ||
726 | return 0; | |
727 | } | |
728 | ||
729 | static int f11_read_control_regs(struct rmi_function *fn, | |
730 | struct f11_2d_ctrl *ctrl, u16 ctrl_base_addr) { | |
731 | struct rmi_device *rmi_dev = fn->rmi_dev; | |
732 | int error = 0; | |
733 | ||
734 | ctrl->ctrl0_11_address = ctrl_base_addr; | |
735 | error = rmi_read_block(rmi_dev, ctrl_base_addr, ctrl->ctrl0_11, | |
736 | RMI_F11_CTRL_REG_COUNT); | |
737 | if (error < 0) { | |
738 | dev_err(&fn->dev, "Failed to read ctrl0, code: %d.\n", error); | |
739 | return error; | |
740 | } | |
741 | ||
742 | return 0; | |
743 | } | |
744 | ||
745 | static int f11_write_control_regs(struct rmi_function *fn, | |
746 | struct f11_2d_sensor_queries *query, | |
747 | struct f11_2d_ctrl *ctrl, | |
748 | u16 ctrl_base_addr) | |
749 | { | |
750 | struct rmi_device *rmi_dev = fn->rmi_dev; | |
751 | int error; | |
752 | ||
753 | error = rmi_write_block(rmi_dev, ctrl_base_addr, ctrl->ctrl0_11, | |
754 | RMI_F11_CTRL_REG_COUNT); | |
755 | if (error < 0) | |
756 | return error; | |
757 | ||
758 | return 0; | |
759 | } | |
760 | ||
761 | static int rmi_f11_get_query_parameters(struct rmi_device *rmi_dev, | |
762 | struct f11_data *f11, | |
763 | struct f11_2d_sensor_queries *sensor_query, | |
764 | u16 query_base_addr) | |
765 | { | |
766 | int query_size; | |
767 | int rc; | |
768 | u8 query_buf[RMI_F11_QUERY_SIZE]; | |
769 | bool has_query36 = false; | |
770 | ||
771 | rc = rmi_read_block(rmi_dev, query_base_addr, query_buf, | |
772 | RMI_F11_QUERY_SIZE); | |
773 | if (rc < 0) | |
774 | return rc; | |
775 | ||
776 | sensor_query->nr_fingers = query_buf[0] & RMI_F11_NR_FINGERS_MASK; | |
777 | sensor_query->has_rel = !!(query_buf[0] & RMI_F11_HAS_REL); | |
778 | sensor_query->has_abs = !!(query_buf[0] & RMI_F11_HAS_ABS); | |
779 | sensor_query->has_gestures = !!(query_buf[0] & RMI_F11_HAS_GESTURES); | |
780 | sensor_query->has_sensitivity_adjust = | |
24672bdf | 781 | !!(query_buf[0] & RMI_F11_HAS_SENSITIVITY_ADJ); |
ff8f8370 AD |
782 | sensor_query->configurable = !!(query_buf[0] & RMI_F11_CONFIGURABLE); |
783 | ||
784 | sensor_query->nr_x_electrodes = | |
785 | query_buf[1] & RMI_F11_NR_ELECTRODES_MASK; | |
786 | sensor_query->nr_y_electrodes = | |
787 | query_buf[2] & RMI_F11_NR_ELECTRODES_MASK; | |
788 | sensor_query->max_electrodes = | |
789 | query_buf[3] & RMI_F11_NR_ELECTRODES_MASK; | |
790 | ||
791 | query_size = RMI_F11_QUERY_SIZE; | |
792 | ||
793 | if (sensor_query->has_abs) { | |
794 | rc = rmi_read(rmi_dev, query_base_addr + query_size, query_buf); | |
795 | if (rc < 0) | |
796 | return rc; | |
797 | ||
798 | sensor_query->abs_data_size = | |
799 | query_buf[0] & RMI_F11_ABS_DATA_SIZE_MASK; | |
800 | sensor_query->has_anchored_finger = | |
801 | !!(query_buf[0] & RMI_F11_HAS_ANCHORED_FINGER); | |
802 | sensor_query->has_adj_hyst = | |
803 | !!(query_buf[0] & RMI_F11_HAS_ADJ_HYST); | |
804 | sensor_query->has_dribble = | |
805 | !!(query_buf[0] & RMI_F11_HAS_DRIBBLE); | |
806 | sensor_query->has_bending_correction = | |
807 | !!(query_buf[0] & RMI_F11_HAS_BENDING_CORRECTION); | |
808 | sensor_query->has_large_object_suppression = | |
24672bdf | 809 | !!(query_buf[0] & RMI_F11_HAS_LARGE_OBJECT_SUPPRESSION); |
ff8f8370 AD |
810 | sensor_query->has_jitter_filter = |
811 | !!(query_buf[0] & RMI_F11_HAS_JITTER_FILTER); | |
812 | query_size++; | |
813 | } | |
814 | ||
815 | if (sensor_query->has_rel) { | |
816 | rc = rmi_read(rmi_dev, query_base_addr + query_size, | |
817 | &sensor_query->f11_2d_query6); | |
818 | if (rc < 0) | |
819 | return rc; | |
820 | query_size++; | |
821 | } | |
822 | ||
823 | if (sensor_query->has_gestures) { | |
824 | rc = rmi_read_block(rmi_dev, query_base_addr + query_size, | |
825 | query_buf, RMI_F11_QUERY_GESTURE_SIZE); | |
826 | if (rc < 0) | |
827 | return rc; | |
828 | ||
829 | sensor_query->has_single_tap = | |
830 | !!(query_buf[0] & RMI_F11_HAS_SINGLE_TAP); | |
831 | sensor_query->has_tap_n_hold = | |
832 | !!(query_buf[0] & RMI_F11_HAS_TAP_AND_HOLD); | |
833 | sensor_query->has_double_tap = | |
834 | !!(query_buf[0] & RMI_F11_HAS_DOUBLE_TAP); | |
835 | sensor_query->has_early_tap = | |
836 | !!(query_buf[0] & RMI_F11_HAS_EARLY_TAP); | |
837 | sensor_query->has_flick = | |
838 | !!(query_buf[0] & RMI_F11_HAS_FLICK); | |
839 | sensor_query->has_press = | |
840 | !!(query_buf[0] & RMI_F11_HAS_PRESS); | |
841 | sensor_query->has_pinch = | |
842 | !!(query_buf[0] & RMI_F11_HAS_PINCH); | |
843 | sensor_query->has_chiral = | |
844 | !!(query_buf[0] & RMI_F11_HAS_CHIRAL); | |
845 | ||
846 | /* query 8 */ | |
847 | sensor_query->has_palm_det = | |
848 | !!(query_buf[1] & RMI_F11_HAS_PALM_DET); | |
849 | sensor_query->has_rotate = | |
850 | !!(query_buf[1] & RMI_F11_HAS_ROTATE); | |
851 | sensor_query->has_touch_shapes = | |
852 | !!(query_buf[1] & RMI_F11_HAS_TOUCH_SHAPES); | |
853 | sensor_query->has_scroll_zones = | |
854 | !!(query_buf[1] & RMI_F11_HAS_SCROLL_ZONES); | |
855 | sensor_query->has_individual_scroll_zones = | |
856 | !!(query_buf[1] & RMI_F11_HAS_INDIVIDUAL_SCROLL_ZONES); | |
857 | sensor_query->has_mf_scroll = | |
858 | !!(query_buf[1] & RMI_F11_HAS_MF_SCROLL); | |
859 | sensor_query->has_mf_edge_motion = | |
860 | !!(query_buf[1] & RMI_F11_HAS_MF_EDGE_MOTION); | |
861 | sensor_query->has_mf_scroll_inertia = | |
862 | !!(query_buf[1] & RMI_F11_HAS_MF_SCROLL_INERTIA); | |
863 | ||
864 | sensor_query->query7_nonzero = !!(query_buf[0]); | |
865 | sensor_query->query8_nonzero = !!(query_buf[1]); | |
866 | ||
867 | query_size += 2; | |
868 | } | |
869 | ||
870 | if (f11->has_query9) { | |
871 | rc = rmi_read(rmi_dev, query_base_addr + query_size, query_buf); | |
872 | if (rc < 0) | |
873 | return rc; | |
874 | ||
875 | sensor_query->has_pen = | |
876 | !!(query_buf[0] & RMI_F11_HAS_PEN); | |
877 | sensor_query->has_proximity = | |
878 | !!(query_buf[0] & RMI_F11_HAS_PROXIMITY); | |
879 | sensor_query->has_palm_det_sensitivity = | |
880 | !!(query_buf[0] & RMI_F11_HAS_PALM_DET_SENSITIVITY); | |
881 | sensor_query->has_suppress_on_palm_detect = | |
882 | !!(query_buf[0] & RMI_F11_HAS_SUPPRESS_ON_PALM_DETECT); | |
883 | sensor_query->has_two_pen_thresholds = | |
884 | !!(query_buf[0] & RMI_F11_HAS_TWO_PEN_THRESHOLDS); | |
885 | sensor_query->has_contact_geometry = | |
886 | !!(query_buf[0] & RMI_F11_HAS_CONTACT_GEOMETRY); | |
887 | sensor_query->has_pen_hover_discrimination = | |
888 | !!(query_buf[0] & RMI_F11_HAS_PEN_HOVER_DISCRIMINATION); | |
889 | sensor_query->has_pen_filters = | |
890 | !!(query_buf[0] & RMI_F11_HAS_PEN_FILTERS); | |
891 | ||
892 | query_size++; | |
893 | } | |
894 | ||
895 | if (sensor_query->has_touch_shapes) { | |
896 | rc = rmi_read(rmi_dev, query_base_addr + query_size, query_buf); | |
897 | if (rc < 0) | |
898 | return rc; | |
899 | ||
900 | sensor_query->nr_touch_shapes = query_buf[0] & | |
901 | RMI_F11_NR_TOUCH_SHAPES_MASK; | |
902 | ||
903 | query_size++; | |
904 | } | |
905 | ||
906 | if (f11->has_query11) { | |
907 | rc = rmi_read(rmi_dev, query_base_addr + query_size, query_buf); | |
908 | if (rc < 0) | |
909 | return rc; | |
910 | ||
911 | sensor_query->has_z_tuning = | |
912 | !!(query_buf[0] & RMI_F11_HAS_Z_TUNING); | |
913 | sensor_query->has_algorithm_selection = | |
914 | !!(query_buf[0] & RMI_F11_HAS_ALGORITHM_SELECTION); | |
915 | sensor_query->has_w_tuning = | |
916 | !!(query_buf[0] & RMI_F11_HAS_W_TUNING); | |
917 | sensor_query->has_pitch_info = | |
918 | !!(query_buf[0] & RMI_F11_HAS_PITCH_INFO); | |
919 | sensor_query->has_finger_size = | |
920 | !!(query_buf[0] & RMI_F11_HAS_FINGER_SIZE); | |
921 | sensor_query->has_segmentation_aggressiveness = | |
922 | !!(query_buf[0] & | |
923 | RMI_F11_HAS_SEGMENTATION_AGGRESSIVENESS); | |
924 | sensor_query->has_XY_clip = | |
925 | !!(query_buf[0] & RMI_F11_HAS_XY_CLIP); | |
926 | sensor_query->has_drumming_filter = | |
927 | !!(query_buf[0] & RMI_F11_HAS_DRUMMING_FILTER); | |
928 | ||
929 | query_size++; | |
930 | } | |
931 | ||
932 | if (f11->has_query12) { | |
933 | rc = rmi_read(rmi_dev, query_base_addr + query_size, query_buf); | |
934 | if (rc < 0) | |
935 | return rc; | |
936 | ||
937 | sensor_query->has_gapless_finger = | |
938 | !!(query_buf[0] & RMI_F11_HAS_GAPLESS_FINGER); | |
939 | sensor_query->has_gapless_finger_tuning = | |
940 | !!(query_buf[0] & RMI_F11_HAS_GAPLESS_FINGER_TUNING); | |
941 | sensor_query->has_8bit_w = | |
942 | !!(query_buf[0] & RMI_F11_HAS_8BIT_W); | |
943 | sensor_query->has_adjustable_mapping = | |
944 | !!(query_buf[0] & RMI_F11_HAS_ADJUSTABLE_MAPPING); | |
945 | sensor_query->has_info2 = | |
946 | !!(query_buf[0] & RMI_F11_HAS_INFO2); | |
947 | sensor_query->has_physical_props = | |
948 | !!(query_buf[0] & RMI_F11_HAS_PHYSICAL_PROPS); | |
949 | sensor_query->has_finger_limit = | |
950 | !!(query_buf[0] & RMI_F11_HAS_FINGER_LIMIT); | |
951 | sensor_query->has_linear_coeff_2 = | |
952 | !!(query_buf[0] & RMI_F11_HAS_LINEAR_COEFF); | |
953 | ||
954 | query_size++; | |
955 | } | |
956 | ||
957 | if (sensor_query->has_jitter_filter) { | |
958 | rc = rmi_read(rmi_dev, query_base_addr + query_size, query_buf); | |
959 | if (rc < 0) | |
960 | return rc; | |
961 | ||
962 | sensor_query->jitter_window_size = query_buf[0] & | |
963 | RMI_F11_JITTER_WINDOW_MASK; | |
964 | sensor_query->jitter_filter_type = (query_buf[0] & | |
965 | RMI_F11_JITTER_FILTER_MASK) >> | |
966 | RMI_F11_JITTER_FILTER_SHIFT; | |
967 | ||
968 | query_size++; | |
969 | } | |
970 | ||
971 | if (sensor_query->has_info2) { | |
972 | rc = rmi_read(rmi_dev, query_base_addr + query_size, query_buf); | |
973 | if (rc < 0) | |
974 | return rc; | |
975 | ||
976 | sensor_query->light_control = | |
977 | query_buf[0] & RMI_F11_LIGHT_CONTROL_MASK; | |
978 | sensor_query->is_clear = | |
979 | !!(query_buf[0] & RMI_F11_IS_CLEAR); | |
980 | sensor_query->clickpad_props = | |
981 | (query_buf[0] & RMI_F11_CLICKPAD_PROPS_MASK) >> | |
982 | RMI_F11_CLICKPAD_PROPS_SHIFT; | |
983 | sensor_query->mouse_buttons = | |
984 | (query_buf[0] & RMI_F11_MOUSE_BUTTONS_MASK) >> | |
985 | RMI_F11_MOUSE_BUTTONS_SHIFT; | |
986 | sensor_query->has_advanced_gestures = | |
987 | !!(query_buf[0] & RMI_F11_HAS_ADVANCED_GESTURES); | |
988 | ||
989 | query_size++; | |
990 | } | |
991 | ||
992 | if (sensor_query->has_physical_props) { | |
993 | rc = rmi_read_block(rmi_dev, query_base_addr | |
994 | + query_size, query_buf, 4); | |
995 | if (rc < 0) | |
996 | return rc; | |
997 | ||
998 | sensor_query->x_sensor_size_mm = | |
999 | (query_buf[0] | (query_buf[1] << 8)) / 10; | |
1000 | sensor_query->y_sensor_size_mm = | |
1001 | (query_buf[2] | (query_buf[3] << 8)) / 10; | |
1002 | ||
1003 | /* | |
1004 | * query 15 - 18 contain the size of the sensor | |
1005 | * and query 19 - 26 contain bezel dimensions | |
1006 | */ | |
1007 | query_size += 12; | |
1008 | } | |
1009 | ||
1010 | if (f11->has_query27) | |
1011 | ++query_size; | |
1012 | ||
1013 | if (f11->has_query28) { | |
1014 | rc = rmi_read(rmi_dev, query_base_addr + query_size, | |
1015 | query_buf); | |
1016 | if (rc < 0) | |
1017 | return rc; | |
1018 | ||
1019 | has_query36 = !!(query_buf[0] & BIT(6)); | |
1020 | } | |
1021 | ||
1022 | if (has_query36) { | |
1023 | query_size += 2; | |
1024 | rc = rmi_read(rmi_dev, query_base_addr + query_size, | |
1025 | query_buf); | |
1026 | if (rc < 0) | |
1027 | return rc; | |
1028 | ||
1029 | if (!!(query_buf[0] & BIT(5))) | |
1030 | f11->has_acm = true; | |
1031 | } | |
1032 | ||
1033 | return query_size; | |
1034 | } | |
1035 | ||
1036 | static int rmi_f11_initialize(struct rmi_function *fn) | |
1037 | { | |
1038 | struct rmi_device *rmi_dev = fn->rmi_dev; | |
1039 | struct f11_data *f11; | |
1040 | struct f11_2d_ctrl *ctrl; | |
1041 | u8 query_offset; | |
1042 | u16 query_base_addr; | |
1043 | u16 control_base_addr; | |
1044 | u16 max_x_pos, max_y_pos; | |
1045 | int rc; | |
1046 | const struct rmi_device_platform_data *pdata = | |
1047 | rmi_get_platform_data(rmi_dev); | |
1048 | struct rmi_driver_data *drvdata = dev_get_drvdata(&rmi_dev->dev); | |
1049 | struct rmi_2d_sensor *sensor; | |
1050 | u8 buf; | |
1051 | int mask_size; | |
1052 | ||
1053 | rmi_dbg(RMI_DEBUG_FN, &fn->dev, "Initializing F11 values.\n"); | |
1054 | ||
1055 | mask_size = BITS_TO_LONGS(drvdata->irq_count) * sizeof(unsigned long); | |
1056 | ||
1057 | /* | |
1058 | ** init instance data, fill in values and create any sysfs files | |
1059 | */ | |
1060 | f11 = devm_kzalloc(&fn->dev, sizeof(struct f11_data) + mask_size * 3, | |
1061 | GFP_KERNEL); | |
1062 | if (!f11) | |
1063 | return -ENOMEM; | |
1064 | ||
aaa27982 AD |
1065 | if (fn->dev.of_node) { |
1066 | rc = rmi_2d_sensor_of_probe(&fn->dev, &f11->sensor_pdata); | |
1067 | if (rc) | |
1068 | return rc; | |
0a135b88 BT |
1069 | } else { |
1070 | f11->sensor_pdata = pdata->sensor_pdata; | |
aaa27982 | 1071 | } |
ff8f8370 AD |
1072 | |
1073 | f11->rezero_wait_ms = f11->sensor_pdata.rezero_wait; | |
1074 | ||
1075 | f11->abs_mask = (unsigned long *)((char *)f11 | |
1076 | + sizeof(struct f11_data)); | |
1077 | f11->rel_mask = (unsigned long *)((char *)f11 | |
1078 | + sizeof(struct f11_data) + mask_size); | |
1079 | f11->result_bits = (unsigned long *)((char *)f11 | |
1080 | + sizeof(struct f11_data) + mask_size * 2); | |
1081 | ||
1082 | set_bit(fn->irq_pos, f11->abs_mask); | |
1083 | set_bit(fn->irq_pos + 1, f11->rel_mask); | |
1084 | ||
1085 | query_base_addr = fn->fd.query_base_addr; | |
1086 | control_base_addr = fn->fd.control_base_addr; | |
1087 | ||
1088 | rc = rmi_read(rmi_dev, query_base_addr, &buf); | |
1089 | if (rc < 0) | |
1090 | return rc; | |
1091 | ||
1092 | f11->has_query9 = !!(buf & RMI_F11_HAS_QUERY9); | |
1093 | f11->has_query11 = !!(buf & RMI_F11_HAS_QUERY11); | |
1094 | f11->has_query12 = !!(buf & RMI_F11_HAS_QUERY12); | |
1095 | f11->has_query27 = !!(buf & RMI_F11_HAS_QUERY27); | |
1096 | f11->has_query28 = !!(buf & RMI_F11_HAS_QUERY28); | |
1097 | ||
1098 | query_offset = (query_base_addr + 1); | |
1099 | sensor = &f11->sensor; | |
1100 | sensor->fn = fn; | |
1101 | ||
1102 | rc = rmi_f11_get_query_parameters(rmi_dev, f11, | |
1103 | &f11->sens_query, query_offset); | |
1104 | if (rc < 0) | |
1105 | return rc; | |
1106 | query_offset += rc; | |
1107 | ||
1108 | rc = f11_read_control_regs(fn, &f11->dev_controls, | |
1109 | control_base_addr); | |
1110 | if (rc < 0) { | |
1111 | dev_err(&fn->dev, | |
1112 | "Failed to read F11 control params.\n"); | |
1113 | return rc; | |
1114 | } | |
1115 | ||
1116 | if (f11->sens_query.has_info2) { | |
1117 | if (f11->sens_query.is_clear) | |
1118 | f11->sensor.sensor_type = rmi_sensor_touchscreen; | |
1119 | else | |
1120 | f11->sensor.sensor_type = rmi_sensor_touchpad; | |
1121 | } | |
1122 | ||
1123 | sensor->report_abs = f11->sens_query.has_abs; | |
1124 | ||
1125 | sensor->axis_align = | |
1126 | f11->sensor_pdata.axis_align; | |
1127 | ||
1128 | sensor->topbuttonpad = f11->sensor_pdata.topbuttonpad; | |
1129 | sensor->kernel_tracking = f11->sensor_pdata.kernel_tracking; | |
1130 | sensor->dmax = f11->sensor_pdata.dmax; | |
2775e523 AD |
1131 | sensor->dribble = f11->sensor_pdata.dribble; |
1132 | sensor->palm_detect = f11->sensor_pdata.palm_detect; | |
ff8f8370 AD |
1133 | |
1134 | if (f11->sens_query.has_physical_props) { | |
1135 | sensor->x_mm = f11->sens_query.x_sensor_size_mm; | |
1136 | sensor->y_mm = f11->sens_query.y_sensor_size_mm; | |
1137 | } else { | |
1138 | sensor->x_mm = f11->sensor_pdata.x_mm; | |
1139 | sensor->y_mm = f11->sensor_pdata.y_mm; | |
1140 | } | |
1141 | ||
1142 | if (sensor->sensor_type == rmi_sensor_default) | |
1143 | sensor->sensor_type = | |
1144 | f11->sensor_pdata.sensor_type; | |
1145 | ||
1146 | sensor->report_abs = sensor->report_abs | |
1147 | && !(f11->sensor_pdata.disable_report_mask | |
1148 | & RMI_F11_DISABLE_ABS_REPORT); | |
1149 | ||
1150 | if (!sensor->report_abs) | |
1151 | /* | |
1152 | * If device doesn't have abs or if it has been disables | |
1153 | * fallback to reporting rel data. | |
1154 | */ | |
1155 | sensor->report_rel = f11->sens_query.has_rel; | |
1156 | ||
1157 | rc = rmi_read_block(rmi_dev, | |
1158 | control_base_addr + F11_CTRL_SENSOR_MAX_X_POS_OFFSET, | |
1159 | (u8 *)&max_x_pos, sizeof(max_x_pos)); | |
1160 | if (rc < 0) | |
1161 | return rc; | |
1162 | ||
1163 | rc = rmi_read_block(rmi_dev, | |
1164 | control_base_addr + F11_CTRL_SENSOR_MAX_Y_POS_OFFSET, | |
1165 | (u8 *)&max_y_pos, sizeof(max_y_pos)); | |
1166 | if (rc < 0) | |
1167 | return rc; | |
1168 | ||
1169 | sensor->max_x = max_x_pos; | |
1170 | sensor->max_y = max_y_pos; | |
1171 | ||
1172 | rc = f11_2d_construct_data(f11); | |
1173 | if (rc < 0) | |
1174 | return rc; | |
1175 | ||
1176 | if (f11->has_acm) | |
1177 | f11->sensor.attn_size += f11->sensor.nbr_fingers * 2; | |
1178 | ||
1179 | /* allocate the in-kernel tracking buffers */ | |
a86854d0 KC |
1180 | sensor->tracking_pos = devm_kcalloc(&fn->dev, |
1181 | sensor->nbr_fingers, sizeof(struct input_mt_pos), | |
1182 | GFP_KERNEL); | |
1183 | sensor->tracking_slots = devm_kcalloc(&fn->dev, | |
1184 | sensor->nbr_fingers, sizeof(int), GFP_KERNEL); | |
1185 | sensor->objs = devm_kcalloc(&fn->dev, | |
1186 | sensor->nbr_fingers, | |
1187 | sizeof(struct rmi_2d_sensor_abs_object), | |
ff8f8370 | 1188 | GFP_KERNEL); |
ff8f8370 AD |
1189 | if (!sensor->tracking_pos || !sensor->tracking_slots || !sensor->objs) |
1190 | return -ENOMEM; | |
1191 | ||
1192 | ctrl = &f11->dev_controls; | |
1193 | if (sensor->axis_align.delta_x_threshold) | |
1194 | ctrl->ctrl0_11[RMI_F11_DELTA_X_THRESHOLD] = | |
1195 | sensor->axis_align.delta_x_threshold; | |
1196 | ||
1197 | if (sensor->axis_align.delta_y_threshold) | |
1198 | ctrl->ctrl0_11[RMI_F11_DELTA_Y_THRESHOLD] = | |
1199 | sensor->axis_align.delta_y_threshold; | |
1200 | ||
2775e523 AD |
1201 | if (f11->sens_query.has_dribble) { |
1202 | switch (sensor->dribble) { | |
1203 | case RMI_REG_STATE_OFF: | |
1204 | ctrl->ctrl0_11[0] &= ~BIT(6); | |
1205 | break; | |
1206 | case RMI_REG_STATE_ON: | |
1207 | ctrl->ctrl0_11[0] |= BIT(6); | |
1208 | break; | |
1209 | case RMI_REG_STATE_DEFAULT: | |
1210 | default: | |
1211 | break; | |
1212 | } | |
1213 | } | |
ff8f8370 | 1214 | |
2775e523 AD |
1215 | if (f11->sens_query.has_palm_det) { |
1216 | switch (sensor->palm_detect) { | |
1217 | case RMI_REG_STATE_OFF: | |
1218 | ctrl->ctrl0_11[11] &= ~BIT(0); | |
1219 | break; | |
1220 | case RMI_REG_STATE_ON: | |
1221 | ctrl->ctrl0_11[11] |= BIT(0); | |
1222 | break; | |
1223 | case RMI_REG_STATE_DEFAULT: | |
1224 | default: | |
1225 | break; | |
1226 | } | |
1227 | } | |
ff8f8370 AD |
1228 | |
1229 | rc = f11_write_control_regs(fn, &f11->sens_query, | |
3a349763 | 1230 | &f11->dev_controls, fn->fd.control_base_addr); |
ff8f8370 AD |
1231 | if (rc) |
1232 | dev_warn(&fn->dev, "Failed to write control registers\n"); | |
1233 | ||
1234 | mutex_init(&f11->dev_controls_mutex); | |
1235 | ||
1236 | dev_set_drvdata(&fn->dev, f11); | |
1237 | ||
1238 | return 0; | |
1239 | } | |
1240 | ||
1241 | static int rmi_f11_config(struct rmi_function *fn) | |
1242 | { | |
1243 | struct f11_data *f11 = dev_get_drvdata(&fn->dev); | |
1244 | struct rmi_driver *drv = fn->rmi_dev->driver; | |
1245 | struct rmi_2d_sensor *sensor = &f11->sensor; | |
1246 | int rc; | |
1247 | ||
1248 | if (!sensor->report_abs) | |
1249 | drv->clear_irq_bits(fn->rmi_dev, f11->abs_mask); | |
1250 | else | |
1251 | drv->set_irq_bits(fn->rmi_dev, f11->abs_mask); | |
1252 | ||
1253 | if (!sensor->report_rel) | |
1254 | drv->clear_irq_bits(fn->rmi_dev, f11->rel_mask); | |
1255 | else | |
1256 | drv->set_irq_bits(fn->rmi_dev, f11->rel_mask); | |
1257 | ||
1258 | rc = f11_write_control_regs(fn, &f11->sens_query, | |
1259 | &f11->dev_controls, fn->fd.query_base_addr); | |
1260 | if (rc < 0) | |
1261 | return rc; | |
1262 | ||
1263 | return 0; | |
1264 | } | |
1265 | ||
24d28e4f | 1266 | static irqreturn_t rmi_f11_attention(int irq, void *ctx) |
ff8f8370 | 1267 | { |
24d28e4f | 1268 | struct rmi_function *fn = ctx; |
ff8f8370 AD |
1269 | struct rmi_device *rmi_dev = fn->rmi_dev; |
1270 | struct rmi_driver_data *drvdata = dev_get_drvdata(&rmi_dev->dev); | |
1271 | struct f11_data *f11 = dev_get_drvdata(&fn->dev); | |
1272 | u16 data_base_addr = fn->fd.data_base_addr; | |
ff8f8370 | 1273 | int error; |
6d0dbeae | 1274 | int valid_bytes = f11->sensor.pkt_size; |
ff8f8370 | 1275 | |
ae9979c3 | 1276 | if (drvdata->attn_data.data) { |
6d0dbeae AD |
1277 | /* |
1278 | * The valid data in the attention report is less then | |
1279 | * expected. Only process the complete fingers. | |
1280 | */ | |
ae9979c3 BT |
1281 | if (f11->sensor.attn_size > drvdata->attn_data.size) |
1282 | valid_bytes = drvdata->attn_data.size; | |
6d0dbeae AD |
1283 | else |
1284 | valid_bytes = f11->sensor.attn_size; | |
ae9979c3 | 1285 | memcpy(f11->sensor.data_pkt, drvdata->attn_data.data, |
6d0dbeae | 1286 | valid_bytes); |
ae9979c3 BT |
1287 | drvdata->attn_data.data += f11->sensor.attn_size; |
1288 | drvdata->attn_data.size -= f11->sensor.attn_size; | |
ff8f8370 AD |
1289 | } else { |
1290 | error = rmi_read_block(rmi_dev, | |
546ae108 | 1291 | data_base_addr, f11->sensor.data_pkt, |
ff8f8370 AD |
1292 | f11->sensor.pkt_size); |
1293 | if (error < 0) | |
24d28e4f | 1294 | return IRQ_RETVAL(error); |
ff8f8370 AD |
1295 | } |
1296 | ||
24d28e4f | 1297 | rmi_f11_finger_handler(f11, &f11->sensor, valid_bytes); |
ff8f8370 | 1298 | |
24d28e4f | 1299 | return IRQ_HANDLED; |
ff8f8370 AD |
1300 | } |
1301 | ||
1302 | static int rmi_f11_resume(struct rmi_function *fn) | |
1303 | { | |
1304 | struct f11_data *f11 = dev_get_drvdata(&fn->dev); | |
1305 | int error; | |
1306 | ||
1307 | rmi_dbg(RMI_DEBUG_FN, &fn->dev, "Resuming...\n"); | |
1308 | if (!f11->rezero_wait_ms) | |
1309 | return 0; | |
1310 | ||
1311 | mdelay(f11->rezero_wait_ms); | |
1312 | ||
1313 | error = rmi_write(fn->rmi_dev, fn->fd.command_base_addr, | |
1314 | RMI_F11_REZERO); | |
1315 | if (error) { | |
1316 | dev_err(&fn->dev, | |
1317 | "%s: failed to issue rezero command, error = %d.", | |
1318 | __func__, error); | |
1319 | return error; | |
1320 | } | |
1321 | ||
1322 | return 0; | |
1323 | } | |
1324 | ||
1325 | static int rmi_f11_probe(struct rmi_function *fn) | |
1326 | { | |
1327 | int error; | |
1328 | struct f11_data *f11; | |
1329 | ||
1330 | error = rmi_f11_initialize(fn); | |
1331 | if (error) | |
1332 | return error; | |
1333 | ||
1334 | f11 = dev_get_drvdata(&fn->dev); | |
1335 | error = rmi_2d_sensor_configure_input(fn, &f11->sensor); | |
1336 | if (error) | |
1337 | return error; | |
1338 | ||
1339 | return 0; | |
1340 | } | |
1341 | ||
1342 | struct rmi_function_handler rmi_f11_handler = { | |
1343 | .driver = { | |
1344 | .name = "rmi4_f11", | |
1345 | }, | |
1346 | .func = 0x11, | |
1347 | .probe = rmi_f11_probe, | |
1348 | .config = rmi_f11_config, | |
1349 | .attention = rmi_f11_attention, | |
1350 | .resume = rmi_f11_resume, | |
1351 | }; |