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