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