1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Copyright (c) 2011-2015 Synaptics Incorporated
4 * Copyright (c) 2011 Unixphere
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>
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_REPORT_MODE_CONTINUOUS (0 << 0)
416 #define RMI_F11_REPORT_MODE_REDUCED (1 << 0)
417 #define RMI_F11_REPORT_MODE_FS_CHANGE (2 << 0)
418 #define RMI_F11_REPORT_MODE_FP_CHANGE (3 << 0)
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 };
518
519 enum f11_finger_state {
520 F11_NO_FINGER = 0x00,
521 F11_PRESENT = 0x01,
522 F11_INACCURATE = 0x02,
523 F11_RESERVED = 0x03
524 };
525
rmi_f11_rel_pos_report(struct f11_data * f11,u8 n_finger)526 static void rmi_f11_rel_pos_report(struct f11_data *f11, u8 n_finger)
527 {
528 struct rmi_2d_sensor *sensor = &f11->sensor;
529 struct f11_2d_data *data = &f11->data;
530 s8 x, y;
531
532 x = data->rel_pos[n_finger * RMI_F11_REL_BYTES];
533 y = data->rel_pos[n_finger * RMI_F11_REL_BYTES + 1];
534
535 rmi_2d_sensor_rel_report(sensor, x, y);
536 }
537
rmi_f11_abs_pos_process(struct f11_data * f11,struct rmi_2d_sensor * sensor,struct rmi_2d_sensor_abs_object * obj,enum f11_finger_state finger_state,u8 n_finger)538 static void rmi_f11_abs_pos_process(struct f11_data *f11,
539 struct rmi_2d_sensor *sensor,
540 struct rmi_2d_sensor_abs_object *obj,
541 enum f11_finger_state finger_state,
542 u8 n_finger)
543 {
544 struct f11_2d_data *data = &f11->data;
545 u8 *pos_data = &data->abs_pos[n_finger * RMI_F11_ABS_BYTES];
546 int tool_type = MT_TOOL_FINGER;
547
548 switch (finger_state) {
549 case F11_PRESENT:
550 obj->type = RMI_2D_OBJECT_FINGER;
551 break;
552 default:
553 obj->type = RMI_2D_OBJECT_NONE;
554 }
555
556 obj->mt_tool = tool_type;
557 obj->x = (pos_data[0] << 4) | (pos_data[2] & 0x0F);
558 obj->y = (pos_data[1] << 4) | (pos_data[2] >> 4);
559 obj->z = pos_data[4];
560 obj->wx = pos_data[3] & 0x0f;
561 obj->wy = pos_data[3] >> 4;
562
563 rmi_2d_sensor_abs_process(sensor, obj, n_finger);
564 }
565
rmi_f11_parse_finger_state(const u8 * f_state,u8 n_finger)566 static inline u8 rmi_f11_parse_finger_state(const u8 *f_state, u8 n_finger)
567 {
568 return (f_state[n_finger / 4] >> (2 * (n_finger % 4))) &
569 FINGER_STATE_MASK;
570 }
571
rmi_f11_finger_handler(struct f11_data * f11,struct rmi_2d_sensor * sensor,int size)572 static void rmi_f11_finger_handler(struct f11_data *f11,
573 struct rmi_2d_sensor *sensor, int size)
574 {
575 const u8 *f_state = f11->data.f_state;
576 u8 finger_state;
577 u8 i;
578 int abs_fingers;
579 int rel_fingers;
580 int abs_size = sensor->nbr_fingers * RMI_F11_ABS_BYTES;
581
582 if (sensor->report_abs) {
583 if (abs_size > size)
584 abs_fingers = size / RMI_F11_ABS_BYTES;
585 else
586 abs_fingers = sensor->nbr_fingers;
587
588 for (i = 0; i < abs_fingers; i++) {
589 /* Possible of having 4 fingers per f_state register */
590 finger_state = rmi_f11_parse_finger_state(f_state, i);
591 if (finger_state == F11_RESERVED) {
592 pr_err("Invalid finger state[%d]: 0x%02x", i,
593 finger_state);
594 continue;
595 }
596
597 rmi_f11_abs_pos_process(f11, sensor, &sensor->objs[i],
598 finger_state, i);
599 }
600
601 /*
602 * the absolute part is made in 2 parts to allow the kernel
603 * tracking to take place.
604 */
605 if (sensor->kernel_tracking)
606 input_mt_assign_slots(sensor->input,
607 sensor->tracking_slots,
608 sensor->tracking_pos,
609 sensor->nbr_fingers,
610 sensor->dmax);
611
612 for (i = 0; i < abs_fingers; i++) {
613 finger_state = rmi_f11_parse_finger_state(f_state, i);
614 if (finger_state == F11_RESERVED)
615 /* no need to send twice the error */
616 continue;
617
618 rmi_2d_sensor_abs_report(sensor, &sensor->objs[i], i);
619 }
620
621 input_mt_sync_frame(sensor->input);
622 } else if (sensor->report_rel) {
623 if ((abs_size + sensor->nbr_fingers * RMI_F11_REL_BYTES) > size)
624 rel_fingers = (size - abs_size) / RMI_F11_REL_BYTES;
625 else
626 rel_fingers = sensor->nbr_fingers;
627
628 for (i = 0; i < rel_fingers; i++)
629 rmi_f11_rel_pos_report(f11, i);
630 }
631
632 }
633
f11_2d_construct_data(struct f11_data * f11)634 static int f11_2d_construct_data(struct f11_data *f11)
635 {
636 struct rmi_2d_sensor *sensor = &f11->sensor;
637 struct f11_2d_sensor_queries *query = &f11->sens_query;
638 struct f11_2d_data *data = &f11->data;
639 int i;
640
641 sensor->nbr_fingers = (query->nr_fingers == 5 ? 10 :
642 query->nr_fingers + 1);
643
644 sensor->pkt_size = DIV_ROUND_UP(sensor->nbr_fingers, 4);
645
646 if (query->has_abs) {
647 sensor->pkt_size += (sensor->nbr_fingers * 5);
648 sensor->attn_size = sensor->pkt_size;
649 }
650
651 if (query->has_rel)
652 sensor->pkt_size += (sensor->nbr_fingers * 2);
653
654 /* Check if F11_2D_Query7 is non-zero */
655 if (query->query7_nonzero)
656 sensor->pkt_size += sizeof(u8);
657
658 /* Check if F11_2D_Query7 or F11_2D_Query8 is non-zero */
659 if (query->query7_nonzero || query->query8_nonzero)
660 sensor->pkt_size += sizeof(u8);
661
662 if (query->has_pinch || query->has_flick || query->has_rotate) {
663 sensor->pkt_size += 3;
664 if (!query->has_flick)
665 sensor->pkt_size--;
666 if (!query->has_rotate)
667 sensor->pkt_size--;
668 }
669
670 if (query->has_touch_shapes)
671 sensor->pkt_size +=
672 DIV_ROUND_UP(query->nr_touch_shapes + 1, 8);
673
674 sensor->data_pkt = devm_kzalloc(&sensor->fn->dev, sensor->pkt_size,
675 GFP_KERNEL);
676 if (!sensor->data_pkt)
677 return -ENOMEM;
678
679 data->f_state = sensor->data_pkt;
680 i = DIV_ROUND_UP(sensor->nbr_fingers, 4);
681
682 if (query->has_abs) {
683 data->abs_pos = &sensor->data_pkt[i];
684 i += (sensor->nbr_fingers * RMI_F11_ABS_BYTES);
685 }
686
687 if (query->has_rel) {
688 data->rel_pos = &sensor->data_pkt[i];
689 i += (sensor->nbr_fingers * RMI_F11_REL_BYTES);
690 }
691
692 if (query->query7_nonzero) {
693 data->gest_1 = &sensor->data_pkt[i];
694 i++;
695 }
696
697 if (query->query7_nonzero || query->query8_nonzero) {
698 data->gest_2 = &sensor->data_pkt[i];
699 i++;
700 }
701
702 if (query->has_pinch) {
703 data->pinch = &sensor->data_pkt[i];
704 i++;
705 }
706
707 if (query->has_flick) {
708 if (query->has_pinch) {
709 data->flick = data->pinch;
710 i += 2;
711 } else {
712 data->flick = &sensor->data_pkt[i];
713 i += 3;
714 }
715 }
716
717 if (query->has_rotate) {
718 if (query->has_flick) {
719 data->rotate = data->flick + 1;
720 } else {
721 data->rotate = &sensor->data_pkt[i];
722 i += 2;
723 }
724 }
725
726 if (query->has_touch_shapes)
727 data->shapes = &sensor->data_pkt[i];
728
729 return 0;
730 }
731
f11_read_control_regs(struct rmi_function * fn,struct f11_2d_ctrl * ctrl,u16 ctrl_base_addr)732 static int f11_read_control_regs(struct rmi_function *fn,
733 struct f11_2d_ctrl *ctrl, u16 ctrl_base_addr) {
734 struct rmi_device *rmi_dev = fn->rmi_dev;
735 int error = 0;
736
737 ctrl->ctrl0_11_address = ctrl_base_addr;
738 error = rmi_read_block(rmi_dev, ctrl_base_addr, ctrl->ctrl0_11,
739 RMI_F11_CTRL_REG_COUNT);
740 if (error < 0) {
741 dev_err(&fn->dev, "Failed to read ctrl0, code: %d.\n", error);
742 return error;
743 }
744
745 return 0;
746 }
747
f11_write_control_regs(struct rmi_function * fn,struct f11_2d_sensor_queries * query,struct f11_2d_ctrl * ctrl,u16 ctrl_base_addr)748 static int f11_write_control_regs(struct rmi_function *fn,
749 struct f11_2d_sensor_queries *query,
750 struct f11_2d_ctrl *ctrl,
751 u16 ctrl_base_addr)
752 {
753 struct rmi_device *rmi_dev = fn->rmi_dev;
754 int error;
755
756 error = rmi_write_block(rmi_dev, ctrl_base_addr, ctrl->ctrl0_11,
757 RMI_F11_CTRL_REG_COUNT);
758 if (error < 0)
759 return error;
760
761 return 0;
762 }
763
rmi_f11_get_query_parameters(struct rmi_device * rmi_dev,struct f11_data * f11,struct f11_2d_sensor_queries * sensor_query,u16 query_base_addr)764 static int rmi_f11_get_query_parameters(struct rmi_device *rmi_dev,
765 struct f11_data *f11,
766 struct f11_2d_sensor_queries *sensor_query,
767 u16 query_base_addr)
768 {
769 int query_size;
770 int rc;
771 u8 query_buf[RMI_F11_QUERY_SIZE];
772 bool has_query36 = false;
773
774 rc = rmi_read_block(rmi_dev, query_base_addr, query_buf,
775 RMI_F11_QUERY_SIZE);
776 if (rc < 0)
777 return rc;
778
779 sensor_query->nr_fingers = query_buf[0] & RMI_F11_NR_FINGERS_MASK;
780 sensor_query->has_rel = !!(query_buf[0] & RMI_F11_HAS_REL);
781 sensor_query->has_abs = !!(query_buf[0] & RMI_F11_HAS_ABS);
782 sensor_query->has_gestures = !!(query_buf[0] & RMI_F11_HAS_GESTURES);
783 sensor_query->has_sensitivity_adjust =
784 !!(query_buf[0] & RMI_F11_HAS_SENSITIVITY_ADJ);
785 sensor_query->configurable = !!(query_buf[0] & RMI_F11_CONFIGURABLE);
786
787 sensor_query->nr_x_electrodes =
788 query_buf[1] & RMI_F11_NR_ELECTRODES_MASK;
789 sensor_query->nr_y_electrodes =
790 query_buf[2] & RMI_F11_NR_ELECTRODES_MASK;
791 sensor_query->max_electrodes =
792 query_buf[3] & RMI_F11_NR_ELECTRODES_MASK;
793
794 query_size = RMI_F11_QUERY_SIZE;
795
796 if (sensor_query->has_abs) {
797 rc = rmi_read(rmi_dev, query_base_addr + query_size, query_buf);
798 if (rc < 0)
799 return rc;
800
801 sensor_query->abs_data_size =
802 query_buf[0] & RMI_F11_ABS_DATA_SIZE_MASK;
803 sensor_query->has_anchored_finger =
804 !!(query_buf[0] & RMI_F11_HAS_ANCHORED_FINGER);
805 sensor_query->has_adj_hyst =
806 !!(query_buf[0] & RMI_F11_HAS_ADJ_HYST);
807 sensor_query->has_dribble =
808 !!(query_buf[0] & RMI_F11_HAS_DRIBBLE);
809 sensor_query->has_bending_correction =
810 !!(query_buf[0] & RMI_F11_HAS_BENDING_CORRECTION);
811 sensor_query->has_large_object_suppression =
812 !!(query_buf[0] & RMI_F11_HAS_LARGE_OBJECT_SUPPRESSION);
813 sensor_query->has_jitter_filter =
814 !!(query_buf[0] & RMI_F11_HAS_JITTER_FILTER);
815 query_size++;
816 }
817
818 if (sensor_query->has_rel) {
819 rc = rmi_read(rmi_dev, query_base_addr + query_size,
820 &sensor_query->f11_2d_query6);
821 if (rc < 0)
822 return rc;
823 query_size++;
824 }
825
826 if (sensor_query->has_gestures) {
827 rc = rmi_read_block(rmi_dev, query_base_addr + query_size,
828 query_buf, RMI_F11_QUERY_GESTURE_SIZE);
829 if (rc < 0)
830 return rc;
831
832 sensor_query->has_single_tap =
833 !!(query_buf[0] & RMI_F11_HAS_SINGLE_TAP);
834 sensor_query->has_tap_n_hold =
835 !!(query_buf[0] & RMI_F11_HAS_TAP_AND_HOLD);
836 sensor_query->has_double_tap =
837 !!(query_buf[0] & RMI_F11_HAS_DOUBLE_TAP);
838 sensor_query->has_early_tap =
839 !!(query_buf[0] & RMI_F11_HAS_EARLY_TAP);
840 sensor_query->has_flick =
841 !!(query_buf[0] & RMI_F11_HAS_FLICK);
842 sensor_query->has_press =
843 !!(query_buf[0] & RMI_F11_HAS_PRESS);
844 sensor_query->has_pinch =
845 !!(query_buf[0] & RMI_F11_HAS_PINCH);
846 sensor_query->has_chiral =
847 !!(query_buf[0] & RMI_F11_HAS_CHIRAL);
848
849 /* query 8 */
850 sensor_query->has_palm_det =
851 !!(query_buf[1] & RMI_F11_HAS_PALM_DET);
852 sensor_query->has_rotate =
853 !!(query_buf[1] & RMI_F11_HAS_ROTATE);
854 sensor_query->has_touch_shapes =
855 !!(query_buf[1] & RMI_F11_HAS_TOUCH_SHAPES);
856 sensor_query->has_scroll_zones =
857 !!(query_buf[1] & RMI_F11_HAS_SCROLL_ZONES);
858 sensor_query->has_individual_scroll_zones =
859 !!(query_buf[1] & RMI_F11_HAS_INDIVIDUAL_SCROLL_ZONES);
860 sensor_query->has_mf_scroll =
861 !!(query_buf[1] & RMI_F11_HAS_MF_SCROLL);
862 sensor_query->has_mf_edge_motion =
863 !!(query_buf[1] & RMI_F11_HAS_MF_EDGE_MOTION);
864 sensor_query->has_mf_scroll_inertia =
865 !!(query_buf[1] & RMI_F11_HAS_MF_SCROLL_INERTIA);
866
867 sensor_query->query7_nonzero = !!(query_buf[0]);
868 sensor_query->query8_nonzero = !!(query_buf[1]);
869
870 query_size += 2;
871 }
872
873 if (f11->has_query9) {
874 rc = rmi_read(rmi_dev, query_base_addr + query_size, query_buf);
875 if (rc < 0)
876 return rc;
877
878 sensor_query->has_pen =
879 !!(query_buf[0] & RMI_F11_HAS_PEN);
880 sensor_query->has_proximity =
881 !!(query_buf[0] & RMI_F11_HAS_PROXIMITY);
882 sensor_query->has_palm_det_sensitivity =
883 !!(query_buf[0] & RMI_F11_HAS_PALM_DET_SENSITIVITY);
884 sensor_query->has_suppress_on_palm_detect =
885 !!(query_buf[0] & RMI_F11_HAS_SUPPRESS_ON_PALM_DETECT);
886 sensor_query->has_two_pen_thresholds =
887 !!(query_buf[0] & RMI_F11_HAS_TWO_PEN_THRESHOLDS);
888 sensor_query->has_contact_geometry =
889 !!(query_buf[0] & RMI_F11_HAS_CONTACT_GEOMETRY);
890 sensor_query->has_pen_hover_discrimination =
891 !!(query_buf[0] & RMI_F11_HAS_PEN_HOVER_DISCRIMINATION);
892 sensor_query->has_pen_filters =
893 !!(query_buf[0] & RMI_F11_HAS_PEN_FILTERS);
894
895 query_size++;
896 }
897
898 if (sensor_query->has_touch_shapes) {
899 rc = rmi_read(rmi_dev, query_base_addr + query_size, query_buf);
900 if (rc < 0)
901 return rc;
902
903 sensor_query->nr_touch_shapes = query_buf[0] &
904 RMI_F11_NR_TOUCH_SHAPES_MASK;
905
906 query_size++;
907 }
908
909 if (f11->has_query11) {
910 rc = rmi_read(rmi_dev, query_base_addr + query_size, query_buf);
911 if (rc < 0)
912 return rc;
913
914 sensor_query->has_z_tuning =
915 !!(query_buf[0] & RMI_F11_HAS_Z_TUNING);
916 sensor_query->has_algorithm_selection =
917 !!(query_buf[0] & RMI_F11_HAS_ALGORITHM_SELECTION);
918 sensor_query->has_w_tuning =
919 !!(query_buf[0] & RMI_F11_HAS_W_TUNING);
920 sensor_query->has_pitch_info =
921 !!(query_buf[0] & RMI_F11_HAS_PITCH_INFO);
922 sensor_query->has_finger_size =
923 !!(query_buf[0] & RMI_F11_HAS_FINGER_SIZE);
924 sensor_query->has_segmentation_aggressiveness =
925 !!(query_buf[0] &
926 RMI_F11_HAS_SEGMENTATION_AGGRESSIVENESS);
927 sensor_query->has_XY_clip =
928 !!(query_buf[0] & RMI_F11_HAS_XY_CLIP);
929 sensor_query->has_drumming_filter =
930 !!(query_buf[0] & RMI_F11_HAS_DRUMMING_FILTER);
931
932 query_size++;
933 }
934
935 if (f11->has_query12) {
936 rc = rmi_read(rmi_dev, query_base_addr + query_size, query_buf);
937 if (rc < 0)
938 return rc;
939
940 sensor_query->has_gapless_finger =
941 !!(query_buf[0] & RMI_F11_HAS_GAPLESS_FINGER);
942 sensor_query->has_gapless_finger_tuning =
943 !!(query_buf[0] & RMI_F11_HAS_GAPLESS_FINGER_TUNING);
944 sensor_query->has_8bit_w =
945 !!(query_buf[0] & RMI_F11_HAS_8BIT_W);
946 sensor_query->has_adjustable_mapping =
947 !!(query_buf[0] & RMI_F11_HAS_ADJUSTABLE_MAPPING);
948 sensor_query->has_info2 =
949 !!(query_buf[0] & RMI_F11_HAS_INFO2);
950 sensor_query->has_physical_props =
951 !!(query_buf[0] & RMI_F11_HAS_PHYSICAL_PROPS);
952 sensor_query->has_finger_limit =
953 !!(query_buf[0] & RMI_F11_HAS_FINGER_LIMIT);
954 sensor_query->has_linear_coeff_2 =
955 !!(query_buf[0] & RMI_F11_HAS_LINEAR_COEFF);
956
957 query_size++;
958 }
959
960 if (sensor_query->has_jitter_filter) {
961 rc = rmi_read(rmi_dev, query_base_addr + query_size, query_buf);
962 if (rc < 0)
963 return rc;
964
965 sensor_query->jitter_window_size = query_buf[0] &
966 RMI_F11_JITTER_WINDOW_MASK;
967 sensor_query->jitter_filter_type = (query_buf[0] &
968 RMI_F11_JITTER_FILTER_MASK) >>
969 RMI_F11_JITTER_FILTER_SHIFT;
970
971 query_size++;
972 }
973
974 if (sensor_query->has_info2) {
975 rc = rmi_read(rmi_dev, query_base_addr + query_size, query_buf);
976 if (rc < 0)
977 return rc;
978
979 sensor_query->light_control =
980 query_buf[0] & RMI_F11_LIGHT_CONTROL_MASK;
981 sensor_query->is_clear =
982 !!(query_buf[0] & RMI_F11_IS_CLEAR);
983 sensor_query->clickpad_props =
984 (query_buf[0] & RMI_F11_CLICKPAD_PROPS_MASK) >>
985 RMI_F11_CLICKPAD_PROPS_SHIFT;
986 sensor_query->mouse_buttons =
987 (query_buf[0] & RMI_F11_MOUSE_BUTTONS_MASK) >>
988 RMI_F11_MOUSE_BUTTONS_SHIFT;
989 sensor_query->has_advanced_gestures =
990 !!(query_buf[0] & RMI_F11_HAS_ADVANCED_GESTURES);
991
992 query_size++;
993 }
994
995 if (sensor_query->has_physical_props) {
996 rc = rmi_read_block(rmi_dev, query_base_addr
997 + query_size, query_buf, 4);
998 if (rc < 0)
999 return rc;
1000
1001 sensor_query->x_sensor_size_mm =
1002 (query_buf[0] | (query_buf[1] << 8)) / 10;
1003 sensor_query->y_sensor_size_mm =
1004 (query_buf[2] | (query_buf[3] << 8)) / 10;
1005
1006 /*
1007 * query 15 - 18 contain the size of the sensor
1008 * and query 19 - 26 contain bezel dimensions
1009 */
1010 query_size += 12;
1011 }
1012
1013 if (f11->has_query27)
1014 ++query_size;
1015
1016 if (f11->has_query28) {
1017 rc = rmi_read(rmi_dev, query_base_addr + query_size,
1018 query_buf);
1019 if (rc < 0)
1020 return rc;
1021
1022 has_query36 = !!(query_buf[0] & BIT(6));
1023 }
1024
1025 if (has_query36) {
1026 query_size += 2;
1027 rc = rmi_read(rmi_dev, query_base_addr + query_size,
1028 query_buf);
1029 if (rc < 0)
1030 return rc;
1031
1032 if (!!(query_buf[0] & BIT(5)))
1033 f11->has_acm = true;
1034 }
1035
1036 return query_size;
1037 }
1038
rmi_f11_initialize(struct rmi_function * fn)1039 static int rmi_f11_initialize(struct rmi_function *fn)
1040 {
1041 struct rmi_device *rmi_dev = fn->rmi_dev;
1042 struct f11_data *f11;
1043 struct f11_2d_ctrl *ctrl;
1044 u8 query_offset;
1045 u16 query_base_addr;
1046 u16 control_base_addr;
1047 u16 max_x_pos, max_y_pos;
1048 int rc;
1049 const struct rmi_device_platform_data *pdata =
1050 rmi_get_platform_data(rmi_dev);
1051 struct rmi_driver_data *drvdata = dev_get_drvdata(&rmi_dev->dev);
1052 struct rmi_2d_sensor *sensor;
1053 u8 buf;
1054 int mask_size;
1055
1056 rmi_dbg(RMI_DEBUG_FN, &fn->dev, "Initializing F11 values.\n");
1057
1058 mask_size = BITS_TO_LONGS(drvdata->irq_count) * sizeof(unsigned long);
1059
1060 /*
1061 ** init instance data, fill in values and create any sysfs files
1062 */
1063 f11 = devm_kzalloc(&fn->dev, sizeof(struct f11_data) + mask_size * 2,
1064 GFP_KERNEL);
1065 if (!f11)
1066 return -ENOMEM;
1067
1068 if (fn->dev.of_node) {
1069 rc = rmi_2d_sensor_of_probe(&fn->dev, &f11->sensor_pdata);
1070 if (rc)
1071 return rc;
1072 } else {
1073 f11->sensor_pdata = pdata->sensor_pdata;
1074 }
1075
1076 f11->rezero_wait_ms = f11->sensor_pdata.rezero_wait;
1077
1078 f11->abs_mask = (unsigned long *)((char *)f11
1079 + sizeof(struct f11_data));
1080 f11->rel_mask = (unsigned long *)((char *)f11
1081 + sizeof(struct f11_data) + mask_size);
1082
1083 set_bit(fn->irq_pos, f11->abs_mask);
1084 set_bit(fn->irq_pos + 1, f11->rel_mask);
1085
1086 query_base_addr = fn->fd.query_base_addr;
1087 control_base_addr = fn->fd.control_base_addr;
1088
1089 rc = rmi_read(rmi_dev, query_base_addr, &buf);
1090 if (rc < 0)
1091 return rc;
1092
1093 f11->has_query9 = !!(buf & RMI_F11_HAS_QUERY9);
1094 f11->has_query11 = !!(buf & RMI_F11_HAS_QUERY11);
1095 f11->has_query12 = !!(buf & RMI_F11_HAS_QUERY12);
1096 f11->has_query27 = !!(buf & RMI_F11_HAS_QUERY27);
1097 f11->has_query28 = !!(buf & RMI_F11_HAS_QUERY28);
1098
1099 query_offset = (query_base_addr + 1);
1100 sensor = &f11->sensor;
1101 sensor->fn = fn;
1102
1103 rc = rmi_f11_get_query_parameters(rmi_dev, f11,
1104 &f11->sens_query, query_offset);
1105 if (rc < 0)
1106 return rc;
1107 query_offset += rc;
1108
1109 rc = f11_read_control_regs(fn, &f11->dev_controls,
1110 control_base_addr);
1111 if (rc < 0) {
1112 dev_err(&fn->dev,
1113 "Failed to read F11 control params.\n");
1114 return rc;
1115 }
1116
1117 if (f11->sens_query.has_info2) {
1118 if (f11->sens_query.is_clear)
1119 f11->sensor.sensor_type = rmi_sensor_touchscreen;
1120 else
1121 f11->sensor.sensor_type = rmi_sensor_touchpad;
1122 }
1123
1124 sensor->report_abs = f11->sens_query.has_abs;
1125
1126 sensor->axis_align =
1127 f11->sensor_pdata.axis_align;
1128
1129 sensor->topbuttonpad = f11->sensor_pdata.topbuttonpad;
1130 sensor->kernel_tracking = f11->sensor_pdata.kernel_tracking;
1131 sensor->dmax = f11->sensor_pdata.dmax;
1132 sensor->dribble = f11->sensor_pdata.dribble;
1133 sensor->palm_detect = f11->sensor_pdata.palm_detect;
1134
1135 if (f11->sens_query.has_physical_props) {
1136 sensor->x_mm = f11->sens_query.x_sensor_size_mm;
1137 sensor->y_mm = f11->sens_query.y_sensor_size_mm;
1138 } else {
1139 sensor->x_mm = f11->sensor_pdata.x_mm;
1140 sensor->y_mm = f11->sensor_pdata.y_mm;
1141 }
1142
1143 if (sensor->sensor_type == rmi_sensor_default)
1144 sensor->sensor_type =
1145 f11->sensor_pdata.sensor_type;
1146
1147 sensor->report_abs = sensor->report_abs
1148 && !(f11->sensor_pdata.disable_report_mask
1149 & RMI_F11_DISABLE_ABS_REPORT);
1150
1151 if (!sensor->report_abs)
1152 /*
1153 * If device doesn't have abs or if it has been disables
1154 * fallback to reporting rel data.
1155 */
1156 sensor->report_rel = f11->sens_query.has_rel;
1157
1158 rc = rmi_read_block(rmi_dev,
1159 control_base_addr + F11_CTRL_SENSOR_MAX_X_POS_OFFSET,
1160 (u8 *)&max_x_pos, sizeof(max_x_pos));
1161 if (rc < 0)
1162 return rc;
1163
1164 rc = rmi_read_block(rmi_dev,
1165 control_base_addr + F11_CTRL_SENSOR_MAX_Y_POS_OFFSET,
1166 (u8 *)&max_y_pos, sizeof(max_y_pos));
1167 if (rc < 0)
1168 return rc;
1169
1170 sensor->max_x = max_x_pos;
1171 sensor->max_y = max_y_pos;
1172
1173 rc = f11_2d_construct_data(f11);
1174 if (rc < 0)
1175 return rc;
1176
1177 if (f11->has_acm)
1178 f11->sensor.attn_size += f11->sensor.nbr_fingers * 2;
1179
1180 /* allocate the in-kernel tracking buffers */
1181 sensor->tracking_pos = devm_kcalloc(&fn->dev,
1182 sensor->nbr_fingers, sizeof(struct input_mt_pos),
1183 GFP_KERNEL);
1184 sensor->tracking_slots = devm_kcalloc(&fn->dev,
1185 sensor->nbr_fingers, sizeof(int), GFP_KERNEL);
1186 sensor->objs = devm_kcalloc(&fn->dev,
1187 sensor->nbr_fingers,
1188 sizeof(struct rmi_2d_sensor_abs_object),
1189 GFP_KERNEL);
1190 if (!sensor->tracking_pos || !sensor->tracking_slots || !sensor->objs)
1191 return -ENOMEM;
1192
1193 ctrl = &f11->dev_controls;
1194 if (sensor->axis_align.delta_x_threshold)
1195 ctrl->ctrl0_11[RMI_F11_DELTA_X_THRESHOLD] =
1196 sensor->axis_align.delta_x_threshold;
1197
1198 if (sensor->axis_align.delta_y_threshold)
1199 ctrl->ctrl0_11[RMI_F11_DELTA_Y_THRESHOLD] =
1200 sensor->axis_align.delta_y_threshold;
1201
1202 /*
1203 * If distance threshold values are set, switch to reduced reporting
1204 * mode so they actually get used by the controller.
1205 */
1206 if (sensor->axis_align.delta_x_threshold ||
1207 sensor->axis_align.delta_y_threshold) {
1208 ctrl->ctrl0_11[0] &= ~RMI_F11_REPORT_MODE_MASK;
1209 ctrl->ctrl0_11[0] |= RMI_F11_REPORT_MODE_REDUCED;
1210 }
1211
1212 if (f11->sens_query.has_dribble) {
1213 switch (sensor->dribble) {
1214 case RMI_REG_STATE_OFF:
1215 ctrl->ctrl0_11[0] &= ~BIT(6);
1216 break;
1217 case RMI_REG_STATE_ON:
1218 ctrl->ctrl0_11[0] |= BIT(6);
1219 break;
1220 case RMI_REG_STATE_DEFAULT:
1221 default:
1222 break;
1223 }
1224 }
1225
1226 if (f11->sens_query.has_palm_det) {
1227 switch (sensor->palm_detect) {
1228 case RMI_REG_STATE_OFF:
1229 ctrl->ctrl0_11[11] &= ~BIT(0);
1230 break;
1231 case RMI_REG_STATE_ON:
1232 ctrl->ctrl0_11[11] |= BIT(0);
1233 break;
1234 case RMI_REG_STATE_DEFAULT:
1235 default:
1236 break;
1237 }
1238 }
1239
1240 rc = f11_write_control_regs(fn, &f11->sens_query,
1241 &f11->dev_controls, fn->fd.control_base_addr);
1242 if (rc)
1243 dev_warn(&fn->dev, "Failed to write control registers\n");
1244
1245 mutex_init(&f11->dev_controls_mutex);
1246
1247 dev_set_drvdata(&fn->dev, f11);
1248
1249 return 0;
1250 }
1251
rmi_f11_config(struct rmi_function * fn)1252 static int rmi_f11_config(struct rmi_function *fn)
1253 {
1254 struct f11_data *f11 = dev_get_drvdata(&fn->dev);
1255 struct rmi_driver *drv = fn->rmi_dev->driver;
1256 struct rmi_2d_sensor *sensor = &f11->sensor;
1257 int rc;
1258
1259 if (!sensor->report_abs)
1260 drv->clear_irq_bits(fn->rmi_dev, f11->abs_mask);
1261 else
1262 drv->set_irq_bits(fn->rmi_dev, f11->abs_mask);
1263
1264 if (!sensor->report_rel)
1265 drv->clear_irq_bits(fn->rmi_dev, f11->rel_mask);
1266 else
1267 drv->set_irq_bits(fn->rmi_dev, f11->rel_mask);
1268
1269 rc = f11_write_control_regs(fn, &f11->sens_query,
1270 &f11->dev_controls, fn->fd.query_base_addr);
1271 if (rc < 0)
1272 return rc;
1273
1274 return 0;
1275 }
1276
rmi_f11_attention(int irq,void * ctx)1277 static irqreturn_t rmi_f11_attention(int irq, void *ctx)
1278 {
1279 struct rmi_function *fn = ctx;
1280 struct rmi_device *rmi_dev = fn->rmi_dev;
1281 struct rmi_driver_data *drvdata = dev_get_drvdata(&rmi_dev->dev);
1282 struct f11_data *f11 = dev_get_drvdata(&fn->dev);
1283 u16 data_base_addr = fn->fd.data_base_addr;
1284 int error;
1285 int valid_bytes = f11->sensor.pkt_size;
1286
1287 if (drvdata->attn_data.data) {
1288 /*
1289 * The valid data in the attention report is less then
1290 * expected. Only process the complete fingers.
1291 */
1292 if (f11->sensor.attn_size > drvdata->attn_data.size)
1293 valid_bytes = drvdata->attn_data.size;
1294 else
1295 valid_bytes = f11->sensor.attn_size;
1296 memcpy(f11->sensor.data_pkt, drvdata->attn_data.data,
1297 valid_bytes);
1298 drvdata->attn_data.data += valid_bytes;
1299 drvdata->attn_data.size -= valid_bytes;
1300 } else {
1301 error = rmi_read_block(rmi_dev,
1302 data_base_addr, f11->sensor.data_pkt,
1303 f11->sensor.pkt_size);
1304 if (error < 0)
1305 return IRQ_RETVAL(error);
1306 }
1307
1308 rmi_f11_finger_handler(f11, &f11->sensor, valid_bytes);
1309
1310 return IRQ_HANDLED;
1311 }
1312
rmi_f11_resume(struct rmi_function * fn)1313 static int rmi_f11_resume(struct rmi_function *fn)
1314 {
1315 struct f11_data *f11 = dev_get_drvdata(&fn->dev);
1316 int error;
1317
1318 rmi_dbg(RMI_DEBUG_FN, &fn->dev, "Resuming...\n");
1319 if (!f11->rezero_wait_ms)
1320 return 0;
1321
1322 mdelay(f11->rezero_wait_ms);
1323
1324 error = rmi_write(fn->rmi_dev, fn->fd.command_base_addr,
1325 RMI_F11_REZERO);
1326 if (error) {
1327 dev_err(&fn->dev,
1328 "%s: failed to issue rezero command, error = %d.",
1329 __func__, error);
1330 return error;
1331 }
1332
1333 return 0;
1334 }
1335
rmi_f11_probe(struct rmi_function * fn)1336 static int rmi_f11_probe(struct rmi_function *fn)
1337 {
1338 int error;
1339 struct f11_data *f11;
1340
1341 error = rmi_f11_initialize(fn);
1342 if (error)
1343 return error;
1344
1345 f11 = dev_get_drvdata(&fn->dev);
1346 error = rmi_2d_sensor_configure_input(fn, &f11->sensor);
1347 if (error)
1348 return error;
1349
1350 return 0;
1351 }
1352
1353 struct rmi_function_handler rmi_f11_handler = {
1354 .driver = {
1355 .name = "rmi4_f11",
1356 },
1357 .func = 0x11,
1358 .probe = rmi_f11_probe,
1359 .config = rmi_f11_config,
1360 .attention = rmi_f11_attention,
1361 .resume = rmi_f11_resume,
1362 };
1363