Loading...
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 */
333struct 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
458struct 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 */
497struct 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 */
523struct 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
541enum f11_finger_state {
542 F11_NO_FINGER = 0x00,
543 F11_PRESENT = 0x01,
544 F11_INACCURATE = 0x02,
545 F11_RESERVED = 0x03
546};
547
548static 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
560static 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
588static 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
594static 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
656static 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
754static 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
770static 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
786static 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
1061static 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
1274static 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
1299static 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
1335static 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
1358static 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
1375struct 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};
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 */
311struct f11_2d_sensor_queries {
312 /* query1 */
313 u8 nr_fingers;
314 bool has_rel;
315 bool has_abs;
316 bool has_gestures;
317 bool has_sensitivity_adjust;
318 bool configurable;
319
320 /* query2 */
321 u8 nr_x_electrodes;
322
323 /* query3 */
324 u8 nr_y_electrodes;
325
326 /* query4 */
327 u8 max_electrodes;
328
329 /* query5 */
330 u8 abs_data_size;
331 bool has_anchored_finger;
332 bool has_adj_hyst;
333 bool has_dribble;
334 bool has_bending_correction;
335 bool has_large_object_suppression;
336 bool has_jitter_filter;
337
338 u8 f11_2d_query6;
339
340 /* query 7 */
341 bool has_single_tap;
342 bool has_tap_n_hold;
343 bool has_double_tap;
344 bool has_early_tap;
345 bool has_flick;
346 bool has_press;
347 bool has_pinch;
348 bool has_chiral;
349
350 bool query7_nonzero;
351
352 /* query 8 */
353 bool has_palm_det;
354 bool has_rotate;
355 bool has_touch_shapes;
356 bool has_scroll_zones;
357 bool has_individual_scroll_zones;
358 bool has_mf_scroll;
359 bool has_mf_edge_motion;
360 bool has_mf_scroll_inertia;
361
362 bool query8_nonzero;
363
364 /* Query 9 */
365 bool has_pen;
366 bool has_proximity;
367 bool has_palm_det_sensitivity;
368 bool has_suppress_on_palm_detect;
369 bool has_two_pen_thresholds;
370 bool has_contact_geometry;
371 bool has_pen_hover_discrimination;
372 bool has_pen_filters;
373
374 /* Query 10 */
375 u8 nr_touch_shapes;
376
377 /* Query 11. */
378 bool has_z_tuning;
379 bool has_algorithm_selection;
380 bool has_w_tuning;
381 bool has_pitch_info;
382 bool has_finger_size;
383 bool has_segmentation_aggressiveness;
384 bool has_XY_clip;
385 bool has_drumming_filter;
386
387 /* Query 12 */
388 bool has_gapless_finger;
389 bool has_gapless_finger_tuning;
390 bool has_8bit_w;
391 bool has_adjustable_mapping;
392 bool has_info2;
393 bool has_physical_props;
394 bool has_finger_limit;
395 bool has_linear_coeff_2;
396
397 /* Query 13 */
398 u8 jitter_window_size;
399 u8 jitter_filter_type;
400
401 /* Query 14 */
402 u8 light_control;
403 bool is_clear;
404 u8 clickpad_props;
405 u8 mouse_buttons;
406 bool has_advanced_gestures;
407
408 /* Query 15 - 18 */
409 u16 x_sensor_size_mm;
410 u16 y_sensor_size_mm;
411};
412
413/* Defs for Ctrl0. */
414#define RMI_F11_REPORT_MODE_MASK 0x07
415#define RMI_F11_ABS_POS_FILT (1 << 3)
416#define RMI_F11_REL_POS_FILT (1 << 4)
417#define RMI_F11_REL_BALLISTICS (1 << 5)
418#define RMI_F11_DRIBBLE (1 << 6)
419#define RMI_F11_REPORT_BEYOND_CLIP (1 << 7)
420
421/* Defs for Ctrl1. */
422#define RMI_F11_PALM_DETECT_THRESH_MASK 0x0F
423#define RMI_F11_MOTION_SENSITIVITY_MASK 0x30
424#define RMI_F11_MANUAL_TRACKING (1 << 6)
425#define RMI_F11_MANUAL_TRACKED_FINGER (1 << 7)
426
427#define RMI_F11_DELTA_X_THRESHOLD 2
428#define RMI_F11_DELTA_Y_THRESHOLD 3
429
430#define RMI_F11_CTRL_REG_COUNT 12
431
432struct f11_2d_ctrl {
433 u8 ctrl0_11[RMI_F11_CTRL_REG_COUNT];
434 u16 ctrl0_11_address;
435};
436
437#define RMI_F11_ABS_BYTES 5
438#define RMI_F11_REL_BYTES 2
439
440/* Defs for Data 8 */
441
442#define RMI_F11_SINGLE_TAP (1 << 0)
443#define RMI_F11_TAP_AND_HOLD (1 << 1)
444#define RMI_F11_DOUBLE_TAP (1 << 2)
445#define RMI_F11_EARLY_TAP (1 << 3)
446#define RMI_F11_FLICK (1 << 4)
447#define RMI_F11_PRESS (1 << 5)
448#define RMI_F11_PINCH (1 << 6)
449
450/* Defs for Data 9 */
451
452#define RMI_F11_PALM_DETECT (1 << 0)
453#define RMI_F11_ROTATE (1 << 1)
454#define RMI_F11_SHAPE (1 << 2)
455#define RMI_F11_SCROLLZONE (1 << 3)
456#define RMI_F11_GESTURE_FINGER_COUNT_MASK 0x70
457
458/** Handy pointers into our data buffer.
459 *
460 * @f_state - start of finger state registers.
461 * @abs_pos - start of absolute position registers (if present).
462 * @rel_pos - start of relative data registers (if present).
463 * @gest_1 - gesture flags (if present).
464 * @gest_2 - gesture flags & finger count (if present).
465 * @pinch - pinch motion register (if present).
466 * @flick - flick distance X & Y, flick time (if present).
467 * @rotate - rotate motion and finger separation.
468 * @multi_scroll - chiral deltas for X and Y (if present).
469 * @scroll_zones - scroll deltas for 4 regions (if present).
470 */
471struct f11_2d_data {
472 u8 *f_state;
473 u8 *abs_pos;
474 s8 *rel_pos;
475 u8 *gest_1;
476 u8 *gest_2;
477 s8 *pinch;
478 u8 *flick;
479 u8 *rotate;
480 u8 *shapes;
481 s8 *multi_scroll;
482 s8 *scroll_zones;
483};
484
485/** Data pertaining to F11 in general. For per-sensor data, see struct
486 * f11_2d_sensor.
487 *
488 * @dev_query - F11 device specific query registers.
489 * @dev_controls - F11 device specific control registers.
490 * @dev_controls_mutex - lock for the control registers.
491 * @rezero_wait_ms - if nonzero, upon resume we will wait this many
492 * milliseconds before rezeroing the sensor(s). This is useful in systems with
493 * poor electrical behavior on resume, where the initial calibration of the
494 * sensor(s) coming out of sleep state may be bogus.
495 * @sensors - per sensor data structures.
496 */
497struct f11_data {
498 bool has_query9;
499 bool has_query11;
500 bool has_query12;
501 bool has_query27;
502 bool has_query28;
503 bool has_acm;
504 struct f11_2d_ctrl dev_controls;
505 struct mutex dev_controls_mutex;
506 u16 rezero_wait_ms;
507 struct rmi_2d_sensor sensor;
508 struct f11_2d_sensor_queries sens_query;
509 struct f11_2d_data data;
510 struct rmi_2d_sensor_platform_data sensor_pdata;
511 unsigned long *abs_mask;
512 unsigned long *rel_mask;
513};
514
515enum f11_finger_state {
516 F11_NO_FINGER = 0x00,
517 F11_PRESENT = 0x01,
518 F11_INACCURATE = 0x02,
519 F11_RESERVED = 0x03
520};
521
522static void rmi_f11_rel_pos_report(struct f11_data *f11, u8 n_finger)
523{
524 struct rmi_2d_sensor *sensor = &f11->sensor;
525 struct f11_2d_data *data = &f11->data;
526 s8 x, y;
527
528 x = data->rel_pos[n_finger * RMI_F11_REL_BYTES];
529 y = data->rel_pos[n_finger * RMI_F11_REL_BYTES + 1];
530
531 rmi_2d_sensor_rel_report(sensor, x, y);
532}
533
534static void rmi_f11_abs_pos_process(struct f11_data *f11,
535 struct rmi_2d_sensor *sensor,
536 struct rmi_2d_sensor_abs_object *obj,
537 enum f11_finger_state finger_state,
538 u8 n_finger)
539{
540 struct f11_2d_data *data = &f11->data;
541 u8 *pos_data = &data->abs_pos[n_finger * RMI_F11_ABS_BYTES];
542 int tool_type = MT_TOOL_FINGER;
543
544 switch (finger_state) {
545 case F11_PRESENT:
546 obj->type = RMI_2D_OBJECT_FINGER;
547 break;
548 default:
549 obj->type = RMI_2D_OBJECT_NONE;
550 }
551
552 obj->mt_tool = tool_type;
553 obj->x = (pos_data[0] << 4) | (pos_data[2] & 0x0F);
554 obj->y = (pos_data[1] << 4) | (pos_data[2] >> 4);
555 obj->z = pos_data[4];
556 obj->wx = pos_data[3] & 0x0f;
557 obj->wy = pos_data[3] >> 4;
558
559 rmi_2d_sensor_abs_process(sensor, obj, n_finger);
560}
561
562static inline u8 rmi_f11_parse_finger_state(const u8 *f_state, u8 n_finger)
563{
564 return (f_state[n_finger / 4] >> (2 * (n_finger % 4))) &
565 FINGER_STATE_MASK;
566}
567
568static void rmi_f11_finger_handler(struct f11_data *f11,
569 struct rmi_2d_sensor *sensor, int size)
570{
571 const u8 *f_state = f11->data.f_state;
572 u8 finger_state;
573 u8 i;
574 int abs_fingers;
575 int rel_fingers;
576 int abs_size = sensor->nbr_fingers * RMI_F11_ABS_BYTES;
577
578 if (sensor->report_abs) {
579 if (abs_size > size)
580 abs_fingers = size / RMI_F11_ABS_BYTES;
581 else
582 abs_fingers = sensor->nbr_fingers;
583
584 for (i = 0; i < abs_fingers; i++) {
585 /* Possible of having 4 fingers per f_state register */
586 finger_state = rmi_f11_parse_finger_state(f_state, i);
587 if (finger_state == F11_RESERVED) {
588 pr_err("Invalid finger state[%d]: 0x%02x", i,
589 finger_state);
590 continue;
591 }
592
593 rmi_f11_abs_pos_process(f11, sensor, &sensor->objs[i],
594 finger_state, i);
595 }
596
597 /*
598 * the absolute part is made in 2 parts to allow the kernel
599 * tracking to take place.
600 */
601 if (sensor->kernel_tracking)
602 input_mt_assign_slots(sensor->input,
603 sensor->tracking_slots,
604 sensor->tracking_pos,
605 sensor->nbr_fingers,
606 sensor->dmax);
607
608 for (i = 0; i < abs_fingers; i++) {
609 finger_state = rmi_f11_parse_finger_state(f_state, i);
610 if (finger_state == F11_RESERVED)
611 /* no need to send twice the error */
612 continue;
613
614 rmi_2d_sensor_abs_report(sensor, &sensor->objs[i], i);
615 }
616
617 input_mt_sync_frame(sensor->input);
618 } else if (sensor->report_rel) {
619 if ((abs_size + sensor->nbr_fingers * RMI_F11_REL_BYTES) > size)
620 rel_fingers = (size - abs_size) / RMI_F11_REL_BYTES;
621 else
622 rel_fingers = sensor->nbr_fingers;
623
624 for (i = 0; i < rel_fingers; i++)
625 rmi_f11_rel_pos_report(f11, i);
626 }
627
628}
629
630static int f11_2d_construct_data(struct f11_data *f11)
631{
632 struct rmi_2d_sensor *sensor = &f11->sensor;
633 struct f11_2d_sensor_queries *query = &f11->sens_query;
634 struct f11_2d_data *data = &f11->data;
635 int i;
636
637 sensor->nbr_fingers = (query->nr_fingers == 5 ? 10 :
638 query->nr_fingers + 1);
639
640 sensor->pkt_size = DIV_ROUND_UP(sensor->nbr_fingers, 4);
641
642 if (query->has_abs) {
643 sensor->pkt_size += (sensor->nbr_fingers * 5);
644 sensor->attn_size = sensor->pkt_size;
645 }
646
647 if (query->has_rel)
648 sensor->pkt_size += (sensor->nbr_fingers * 2);
649
650 /* Check if F11_2D_Query7 is non-zero */
651 if (query->query7_nonzero)
652 sensor->pkt_size += sizeof(u8);
653
654 /* Check if F11_2D_Query7 or F11_2D_Query8 is non-zero */
655 if (query->query7_nonzero || query->query8_nonzero)
656 sensor->pkt_size += sizeof(u8);
657
658 if (query->has_pinch || query->has_flick || query->has_rotate) {
659 sensor->pkt_size += 3;
660 if (!query->has_flick)
661 sensor->pkt_size--;
662 if (!query->has_rotate)
663 sensor->pkt_size--;
664 }
665
666 if (query->has_touch_shapes)
667 sensor->pkt_size +=
668 DIV_ROUND_UP(query->nr_touch_shapes + 1, 8);
669
670 sensor->data_pkt = devm_kzalloc(&sensor->fn->dev, sensor->pkt_size,
671 GFP_KERNEL);
672 if (!sensor->data_pkt)
673 return -ENOMEM;
674
675 data->f_state = sensor->data_pkt;
676 i = DIV_ROUND_UP(sensor->nbr_fingers, 4);
677
678 if (query->has_abs) {
679 data->abs_pos = &sensor->data_pkt[i];
680 i += (sensor->nbr_fingers * RMI_F11_ABS_BYTES);
681 }
682
683 if (query->has_rel) {
684 data->rel_pos = &sensor->data_pkt[i];
685 i += (sensor->nbr_fingers * RMI_F11_REL_BYTES);
686 }
687
688 if (query->query7_nonzero) {
689 data->gest_1 = &sensor->data_pkt[i];
690 i++;
691 }
692
693 if (query->query7_nonzero || query->query8_nonzero) {
694 data->gest_2 = &sensor->data_pkt[i];
695 i++;
696 }
697
698 if (query->has_pinch) {
699 data->pinch = &sensor->data_pkt[i];
700 i++;
701 }
702
703 if (query->has_flick) {
704 if (query->has_pinch) {
705 data->flick = data->pinch;
706 i += 2;
707 } else {
708 data->flick = &sensor->data_pkt[i];
709 i += 3;
710 }
711 }
712
713 if (query->has_rotate) {
714 if (query->has_flick) {
715 data->rotate = data->flick + 1;
716 } else {
717 data->rotate = &sensor->data_pkt[i];
718 i += 2;
719 }
720 }
721
722 if (query->has_touch_shapes)
723 data->shapes = &sensor->data_pkt[i];
724
725 return 0;
726}
727
728static int f11_read_control_regs(struct rmi_function *fn,
729 struct f11_2d_ctrl *ctrl, u16 ctrl_base_addr) {
730 struct rmi_device *rmi_dev = fn->rmi_dev;
731 int error = 0;
732
733 ctrl->ctrl0_11_address = ctrl_base_addr;
734 error = rmi_read_block(rmi_dev, ctrl_base_addr, ctrl->ctrl0_11,
735 RMI_F11_CTRL_REG_COUNT);
736 if (error < 0) {
737 dev_err(&fn->dev, "Failed to read ctrl0, code: %d.\n", error);
738 return error;
739 }
740
741 return 0;
742}
743
744static int f11_write_control_regs(struct rmi_function *fn,
745 struct f11_2d_sensor_queries *query,
746 struct f11_2d_ctrl *ctrl,
747 u16 ctrl_base_addr)
748{
749 struct rmi_device *rmi_dev = fn->rmi_dev;
750 int error;
751
752 error = rmi_write_block(rmi_dev, ctrl_base_addr, ctrl->ctrl0_11,
753 RMI_F11_CTRL_REG_COUNT);
754 if (error < 0)
755 return error;
756
757 return 0;
758}
759
760static int rmi_f11_get_query_parameters(struct rmi_device *rmi_dev,
761 struct f11_data *f11,
762 struct f11_2d_sensor_queries *sensor_query,
763 u16 query_base_addr)
764{
765 int query_size;
766 int rc;
767 u8 query_buf[RMI_F11_QUERY_SIZE];
768 bool has_query36 = false;
769
770 rc = rmi_read_block(rmi_dev, query_base_addr, query_buf,
771 RMI_F11_QUERY_SIZE);
772 if (rc < 0)
773 return rc;
774
775 sensor_query->nr_fingers = query_buf[0] & RMI_F11_NR_FINGERS_MASK;
776 sensor_query->has_rel = !!(query_buf[0] & RMI_F11_HAS_REL);
777 sensor_query->has_abs = !!(query_buf[0] & RMI_F11_HAS_ABS);
778 sensor_query->has_gestures = !!(query_buf[0] & RMI_F11_HAS_GESTURES);
779 sensor_query->has_sensitivity_adjust =
780 !!(query_buf[0] & RMI_F11_HAS_SENSITIVITY_ADJ);
781 sensor_query->configurable = !!(query_buf[0] & RMI_F11_CONFIGURABLE);
782
783 sensor_query->nr_x_electrodes =
784 query_buf[1] & RMI_F11_NR_ELECTRODES_MASK;
785 sensor_query->nr_y_electrodes =
786 query_buf[2] & RMI_F11_NR_ELECTRODES_MASK;
787 sensor_query->max_electrodes =
788 query_buf[3] & RMI_F11_NR_ELECTRODES_MASK;
789
790 query_size = RMI_F11_QUERY_SIZE;
791
792 if (sensor_query->has_abs) {
793 rc = rmi_read(rmi_dev, query_base_addr + query_size, query_buf);
794 if (rc < 0)
795 return rc;
796
797 sensor_query->abs_data_size =
798 query_buf[0] & RMI_F11_ABS_DATA_SIZE_MASK;
799 sensor_query->has_anchored_finger =
800 !!(query_buf[0] & RMI_F11_HAS_ANCHORED_FINGER);
801 sensor_query->has_adj_hyst =
802 !!(query_buf[0] & RMI_F11_HAS_ADJ_HYST);
803 sensor_query->has_dribble =
804 !!(query_buf[0] & RMI_F11_HAS_DRIBBLE);
805 sensor_query->has_bending_correction =
806 !!(query_buf[0] & RMI_F11_HAS_BENDING_CORRECTION);
807 sensor_query->has_large_object_suppression =
808 !!(query_buf[0] & RMI_F11_HAS_LARGE_OBJECT_SUPPRESSION);
809 sensor_query->has_jitter_filter =
810 !!(query_buf[0] & RMI_F11_HAS_JITTER_FILTER);
811 query_size++;
812 }
813
814 if (sensor_query->has_rel) {
815 rc = rmi_read(rmi_dev, query_base_addr + query_size,
816 &sensor_query->f11_2d_query6);
817 if (rc < 0)
818 return rc;
819 query_size++;
820 }
821
822 if (sensor_query->has_gestures) {
823 rc = rmi_read_block(rmi_dev, query_base_addr + query_size,
824 query_buf, RMI_F11_QUERY_GESTURE_SIZE);
825 if (rc < 0)
826 return rc;
827
828 sensor_query->has_single_tap =
829 !!(query_buf[0] & RMI_F11_HAS_SINGLE_TAP);
830 sensor_query->has_tap_n_hold =
831 !!(query_buf[0] & RMI_F11_HAS_TAP_AND_HOLD);
832 sensor_query->has_double_tap =
833 !!(query_buf[0] & RMI_F11_HAS_DOUBLE_TAP);
834 sensor_query->has_early_tap =
835 !!(query_buf[0] & RMI_F11_HAS_EARLY_TAP);
836 sensor_query->has_flick =
837 !!(query_buf[0] & RMI_F11_HAS_FLICK);
838 sensor_query->has_press =
839 !!(query_buf[0] & RMI_F11_HAS_PRESS);
840 sensor_query->has_pinch =
841 !!(query_buf[0] & RMI_F11_HAS_PINCH);
842 sensor_query->has_chiral =
843 !!(query_buf[0] & RMI_F11_HAS_CHIRAL);
844
845 /* query 8 */
846 sensor_query->has_palm_det =
847 !!(query_buf[1] & RMI_F11_HAS_PALM_DET);
848 sensor_query->has_rotate =
849 !!(query_buf[1] & RMI_F11_HAS_ROTATE);
850 sensor_query->has_touch_shapes =
851 !!(query_buf[1] & RMI_F11_HAS_TOUCH_SHAPES);
852 sensor_query->has_scroll_zones =
853 !!(query_buf[1] & RMI_F11_HAS_SCROLL_ZONES);
854 sensor_query->has_individual_scroll_zones =
855 !!(query_buf[1] & RMI_F11_HAS_INDIVIDUAL_SCROLL_ZONES);
856 sensor_query->has_mf_scroll =
857 !!(query_buf[1] & RMI_F11_HAS_MF_SCROLL);
858 sensor_query->has_mf_edge_motion =
859 !!(query_buf[1] & RMI_F11_HAS_MF_EDGE_MOTION);
860 sensor_query->has_mf_scroll_inertia =
861 !!(query_buf[1] & RMI_F11_HAS_MF_SCROLL_INERTIA);
862
863 sensor_query->query7_nonzero = !!(query_buf[0]);
864 sensor_query->query8_nonzero = !!(query_buf[1]);
865
866 query_size += 2;
867 }
868
869 if (f11->has_query9) {
870 rc = rmi_read(rmi_dev, query_base_addr + query_size, query_buf);
871 if (rc < 0)
872 return rc;
873
874 sensor_query->has_pen =
875 !!(query_buf[0] & RMI_F11_HAS_PEN);
876 sensor_query->has_proximity =
877 !!(query_buf[0] & RMI_F11_HAS_PROXIMITY);
878 sensor_query->has_palm_det_sensitivity =
879 !!(query_buf[0] & RMI_F11_HAS_PALM_DET_SENSITIVITY);
880 sensor_query->has_suppress_on_palm_detect =
881 !!(query_buf[0] & RMI_F11_HAS_SUPPRESS_ON_PALM_DETECT);
882 sensor_query->has_two_pen_thresholds =
883 !!(query_buf[0] & RMI_F11_HAS_TWO_PEN_THRESHOLDS);
884 sensor_query->has_contact_geometry =
885 !!(query_buf[0] & RMI_F11_HAS_CONTACT_GEOMETRY);
886 sensor_query->has_pen_hover_discrimination =
887 !!(query_buf[0] & RMI_F11_HAS_PEN_HOVER_DISCRIMINATION);
888 sensor_query->has_pen_filters =
889 !!(query_buf[0] & RMI_F11_HAS_PEN_FILTERS);
890
891 query_size++;
892 }
893
894 if (sensor_query->has_touch_shapes) {
895 rc = rmi_read(rmi_dev, query_base_addr + query_size, query_buf);
896 if (rc < 0)
897 return rc;
898
899 sensor_query->nr_touch_shapes = query_buf[0] &
900 RMI_F11_NR_TOUCH_SHAPES_MASK;
901
902 query_size++;
903 }
904
905 if (f11->has_query11) {
906 rc = rmi_read(rmi_dev, query_base_addr + query_size, query_buf);
907 if (rc < 0)
908 return rc;
909
910 sensor_query->has_z_tuning =
911 !!(query_buf[0] & RMI_F11_HAS_Z_TUNING);
912 sensor_query->has_algorithm_selection =
913 !!(query_buf[0] & RMI_F11_HAS_ALGORITHM_SELECTION);
914 sensor_query->has_w_tuning =
915 !!(query_buf[0] & RMI_F11_HAS_W_TUNING);
916 sensor_query->has_pitch_info =
917 !!(query_buf[0] & RMI_F11_HAS_PITCH_INFO);
918 sensor_query->has_finger_size =
919 !!(query_buf[0] & RMI_F11_HAS_FINGER_SIZE);
920 sensor_query->has_segmentation_aggressiveness =
921 !!(query_buf[0] &
922 RMI_F11_HAS_SEGMENTATION_AGGRESSIVENESS);
923 sensor_query->has_XY_clip =
924 !!(query_buf[0] & RMI_F11_HAS_XY_CLIP);
925 sensor_query->has_drumming_filter =
926 !!(query_buf[0] & RMI_F11_HAS_DRUMMING_FILTER);
927
928 query_size++;
929 }
930
931 if (f11->has_query12) {
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_gapless_finger =
937 !!(query_buf[0] & RMI_F11_HAS_GAPLESS_FINGER);
938 sensor_query->has_gapless_finger_tuning =
939 !!(query_buf[0] & RMI_F11_HAS_GAPLESS_FINGER_TUNING);
940 sensor_query->has_8bit_w =
941 !!(query_buf[0] & RMI_F11_HAS_8BIT_W);
942 sensor_query->has_adjustable_mapping =
943 !!(query_buf[0] & RMI_F11_HAS_ADJUSTABLE_MAPPING);
944 sensor_query->has_info2 =
945 !!(query_buf[0] & RMI_F11_HAS_INFO2);
946 sensor_query->has_physical_props =
947 !!(query_buf[0] & RMI_F11_HAS_PHYSICAL_PROPS);
948 sensor_query->has_finger_limit =
949 !!(query_buf[0] & RMI_F11_HAS_FINGER_LIMIT);
950 sensor_query->has_linear_coeff_2 =
951 !!(query_buf[0] & RMI_F11_HAS_LINEAR_COEFF);
952
953 query_size++;
954 }
955
956 if (sensor_query->has_jitter_filter) {
957 rc = rmi_read(rmi_dev, query_base_addr + query_size, query_buf);
958 if (rc < 0)
959 return rc;
960
961 sensor_query->jitter_window_size = query_buf[0] &
962 RMI_F11_JITTER_WINDOW_MASK;
963 sensor_query->jitter_filter_type = (query_buf[0] &
964 RMI_F11_JITTER_FILTER_MASK) >>
965 RMI_F11_JITTER_FILTER_SHIFT;
966
967 query_size++;
968 }
969
970 if (sensor_query->has_info2) {
971 rc = rmi_read(rmi_dev, query_base_addr + query_size, query_buf);
972 if (rc < 0)
973 return rc;
974
975 sensor_query->light_control =
976 query_buf[0] & RMI_F11_LIGHT_CONTROL_MASK;
977 sensor_query->is_clear =
978 !!(query_buf[0] & RMI_F11_IS_CLEAR);
979 sensor_query->clickpad_props =
980 (query_buf[0] & RMI_F11_CLICKPAD_PROPS_MASK) >>
981 RMI_F11_CLICKPAD_PROPS_SHIFT;
982 sensor_query->mouse_buttons =
983 (query_buf[0] & RMI_F11_MOUSE_BUTTONS_MASK) >>
984 RMI_F11_MOUSE_BUTTONS_SHIFT;
985 sensor_query->has_advanced_gestures =
986 !!(query_buf[0] & RMI_F11_HAS_ADVANCED_GESTURES);
987
988 query_size++;
989 }
990
991 if (sensor_query->has_physical_props) {
992 rc = rmi_read_block(rmi_dev, query_base_addr
993 + query_size, query_buf, 4);
994 if (rc < 0)
995 return rc;
996
997 sensor_query->x_sensor_size_mm =
998 (query_buf[0] | (query_buf[1] << 8)) / 10;
999 sensor_query->y_sensor_size_mm =
1000 (query_buf[2] | (query_buf[3] << 8)) / 10;
1001
1002 /*
1003 * query 15 - 18 contain the size of the sensor
1004 * and query 19 - 26 contain bezel dimensions
1005 */
1006 query_size += 12;
1007 }
1008
1009 if (f11->has_query27)
1010 ++query_size;
1011
1012 if (f11->has_query28) {
1013 rc = rmi_read(rmi_dev, query_base_addr + query_size,
1014 query_buf);
1015 if (rc < 0)
1016 return rc;
1017
1018 has_query36 = !!(query_buf[0] & BIT(6));
1019 }
1020
1021 if (has_query36) {
1022 query_size += 2;
1023 rc = rmi_read(rmi_dev, query_base_addr + query_size,
1024 query_buf);
1025 if (rc < 0)
1026 return rc;
1027
1028 if (!!(query_buf[0] & BIT(5)))
1029 f11->has_acm = true;
1030 }
1031
1032 return query_size;
1033}
1034
1035static int rmi_f11_initialize(struct rmi_function *fn)
1036{
1037 struct rmi_device *rmi_dev = fn->rmi_dev;
1038 struct f11_data *f11;
1039 struct f11_2d_ctrl *ctrl;
1040 u8 query_offset;
1041 u16 query_base_addr;
1042 u16 control_base_addr;
1043 u16 max_x_pos, max_y_pos;
1044 int rc;
1045 const struct rmi_device_platform_data *pdata =
1046 rmi_get_platform_data(rmi_dev);
1047 struct rmi_driver_data *drvdata = dev_get_drvdata(&rmi_dev->dev);
1048 struct rmi_2d_sensor *sensor;
1049 u8 buf;
1050 int mask_size;
1051
1052 rmi_dbg(RMI_DEBUG_FN, &fn->dev, "Initializing F11 values.\n");
1053
1054 mask_size = BITS_TO_LONGS(drvdata->irq_count) * sizeof(unsigned long);
1055
1056 /*
1057 ** init instance data, fill in values and create any sysfs files
1058 */
1059 f11 = devm_kzalloc(&fn->dev, sizeof(struct f11_data) + mask_size * 2,
1060 GFP_KERNEL);
1061 if (!f11)
1062 return -ENOMEM;
1063
1064 if (fn->dev.of_node) {
1065 rc = rmi_2d_sensor_of_probe(&fn->dev, &f11->sensor_pdata);
1066 if (rc)
1067 return rc;
1068 } else {
1069 f11->sensor_pdata = pdata->sensor_pdata;
1070 }
1071
1072 f11->rezero_wait_ms = f11->sensor_pdata.rezero_wait;
1073
1074 f11->abs_mask = (unsigned long *)((char *)f11
1075 + sizeof(struct f11_data));
1076 f11->rel_mask = (unsigned long *)((char *)f11
1077 + sizeof(struct f11_data) + mask_size);
1078
1079 set_bit(fn->irq_pos, f11->abs_mask);
1080 set_bit(fn->irq_pos + 1, f11->rel_mask);
1081
1082 query_base_addr = fn->fd.query_base_addr;
1083 control_base_addr = fn->fd.control_base_addr;
1084
1085 rc = rmi_read(rmi_dev, query_base_addr, &buf);
1086 if (rc < 0)
1087 return rc;
1088
1089 f11->has_query9 = !!(buf & RMI_F11_HAS_QUERY9);
1090 f11->has_query11 = !!(buf & RMI_F11_HAS_QUERY11);
1091 f11->has_query12 = !!(buf & RMI_F11_HAS_QUERY12);
1092 f11->has_query27 = !!(buf & RMI_F11_HAS_QUERY27);
1093 f11->has_query28 = !!(buf & RMI_F11_HAS_QUERY28);
1094
1095 query_offset = (query_base_addr + 1);
1096 sensor = &f11->sensor;
1097 sensor->fn = fn;
1098
1099 rc = rmi_f11_get_query_parameters(rmi_dev, f11,
1100 &f11->sens_query, query_offset);
1101 if (rc < 0)
1102 return rc;
1103 query_offset += rc;
1104
1105 rc = f11_read_control_regs(fn, &f11->dev_controls,
1106 control_base_addr);
1107 if (rc < 0) {
1108 dev_err(&fn->dev,
1109 "Failed to read F11 control params.\n");
1110 return rc;
1111 }
1112
1113 if (f11->sens_query.has_info2) {
1114 if (f11->sens_query.is_clear)
1115 f11->sensor.sensor_type = rmi_sensor_touchscreen;
1116 else
1117 f11->sensor.sensor_type = rmi_sensor_touchpad;
1118 }
1119
1120 sensor->report_abs = f11->sens_query.has_abs;
1121
1122 sensor->axis_align =
1123 f11->sensor_pdata.axis_align;
1124
1125 sensor->topbuttonpad = f11->sensor_pdata.topbuttonpad;
1126 sensor->kernel_tracking = f11->sensor_pdata.kernel_tracking;
1127 sensor->dmax = f11->sensor_pdata.dmax;
1128 sensor->dribble = f11->sensor_pdata.dribble;
1129 sensor->palm_detect = f11->sensor_pdata.palm_detect;
1130
1131 if (f11->sens_query.has_physical_props) {
1132 sensor->x_mm = f11->sens_query.x_sensor_size_mm;
1133 sensor->y_mm = f11->sens_query.y_sensor_size_mm;
1134 } else {
1135 sensor->x_mm = f11->sensor_pdata.x_mm;
1136 sensor->y_mm = f11->sensor_pdata.y_mm;
1137 }
1138
1139 if (sensor->sensor_type == rmi_sensor_default)
1140 sensor->sensor_type =
1141 f11->sensor_pdata.sensor_type;
1142
1143 sensor->report_abs = sensor->report_abs
1144 && !(f11->sensor_pdata.disable_report_mask
1145 & RMI_F11_DISABLE_ABS_REPORT);
1146
1147 if (!sensor->report_abs)
1148 /*
1149 * If device doesn't have abs or if it has been disables
1150 * fallback to reporting rel data.
1151 */
1152 sensor->report_rel = f11->sens_query.has_rel;
1153
1154 rc = rmi_read_block(rmi_dev,
1155 control_base_addr + F11_CTRL_SENSOR_MAX_X_POS_OFFSET,
1156 (u8 *)&max_x_pos, sizeof(max_x_pos));
1157 if (rc < 0)
1158 return rc;
1159
1160 rc = rmi_read_block(rmi_dev,
1161 control_base_addr + F11_CTRL_SENSOR_MAX_Y_POS_OFFSET,
1162 (u8 *)&max_y_pos, sizeof(max_y_pos));
1163 if (rc < 0)
1164 return rc;
1165
1166 sensor->max_x = max_x_pos;
1167 sensor->max_y = max_y_pos;
1168
1169 rc = f11_2d_construct_data(f11);
1170 if (rc < 0)
1171 return rc;
1172
1173 if (f11->has_acm)
1174 f11->sensor.attn_size += f11->sensor.nbr_fingers * 2;
1175
1176 /* allocate the in-kernel tracking buffers */
1177 sensor->tracking_pos = devm_kcalloc(&fn->dev,
1178 sensor->nbr_fingers, sizeof(struct input_mt_pos),
1179 GFP_KERNEL);
1180 sensor->tracking_slots = devm_kcalloc(&fn->dev,
1181 sensor->nbr_fingers, sizeof(int), GFP_KERNEL);
1182 sensor->objs = devm_kcalloc(&fn->dev,
1183 sensor->nbr_fingers,
1184 sizeof(struct rmi_2d_sensor_abs_object),
1185 GFP_KERNEL);
1186 if (!sensor->tracking_pos || !sensor->tracking_slots || !sensor->objs)
1187 return -ENOMEM;
1188
1189 ctrl = &f11->dev_controls;
1190 if (sensor->axis_align.delta_x_threshold)
1191 ctrl->ctrl0_11[RMI_F11_DELTA_X_THRESHOLD] =
1192 sensor->axis_align.delta_x_threshold;
1193
1194 if (sensor->axis_align.delta_y_threshold)
1195 ctrl->ctrl0_11[RMI_F11_DELTA_Y_THRESHOLD] =
1196 sensor->axis_align.delta_y_threshold;
1197
1198 if (f11->sens_query.has_dribble) {
1199 switch (sensor->dribble) {
1200 case RMI_REG_STATE_OFF:
1201 ctrl->ctrl0_11[0] &= ~BIT(6);
1202 break;
1203 case RMI_REG_STATE_ON:
1204 ctrl->ctrl0_11[0] |= BIT(6);
1205 break;
1206 case RMI_REG_STATE_DEFAULT:
1207 default:
1208 break;
1209 }
1210 }
1211
1212 if (f11->sens_query.has_palm_det) {
1213 switch (sensor->palm_detect) {
1214 case RMI_REG_STATE_OFF:
1215 ctrl->ctrl0_11[11] &= ~BIT(0);
1216 break;
1217 case RMI_REG_STATE_ON:
1218 ctrl->ctrl0_11[11] |= BIT(0);
1219 break;
1220 case RMI_REG_STATE_DEFAULT:
1221 default:
1222 break;
1223 }
1224 }
1225
1226 rc = f11_write_control_regs(fn, &f11->sens_query,
1227 &f11->dev_controls, fn->fd.control_base_addr);
1228 if (rc)
1229 dev_warn(&fn->dev, "Failed to write control registers\n");
1230
1231 mutex_init(&f11->dev_controls_mutex);
1232
1233 dev_set_drvdata(&fn->dev, f11);
1234
1235 return 0;
1236}
1237
1238static int rmi_f11_config(struct rmi_function *fn)
1239{
1240 struct f11_data *f11 = dev_get_drvdata(&fn->dev);
1241 struct rmi_driver *drv = fn->rmi_dev->driver;
1242 struct rmi_2d_sensor *sensor = &f11->sensor;
1243 int rc;
1244
1245 if (!sensor->report_abs)
1246 drv->clear_irq_bits(fn->rmi_dev, f11->abs_mask);
1247 else
1248 drv->set_irq_bits(fn->rmi_dev, f11->abs_mask);
1249
1250 if (!sensor->report_rel)
1251 drv->clear_irq_bits(fn->rmi_dev, f11->rel_mask);
1252 else
1253 drv->set_irq_bits(fn->rmi_dev, f11->rel_mask);
1254
1255 rc = f11_write_control_regs(fn, &f11->sens_query,
1256 &f11->dev_controls, fn->fd.query_base_addr);
1257 if (rc < 0)
1258 return rc;
1259
1260 return 0;
1261}
1262
1263static irqreturn_t rmi_f11_attention(int irq, void *ctx)
1264{
1265 struct rmi_function *fn = ctx;
1266 struct rmi_device *rmi_dev = fn->rmi_dev;
1267 struct rmi_driver_data *drvdata = dev_get_drvdata(&rmi_dev->dev);
1268 struct f11_data *f11 = dev_get_drvdata(&fn->dev);
1269 u16 data_base_addr = fn->fd.data_base_addr;
1270 int error;
1271 int valid_bytes = f11->sensor.pkt_size;
1272
1273 if (drvdata->attn_data.data) {
1274 /*
1275 * The valid data in the attention report is less then
1276 * expected. Only process the complete fingers.
1277 */
1278 if (f11->sensor.attn_size > drvdata->attn_data.size)
1279 valid_bytes = drvdata->attn_data.size;
1280 else
1281 valid_bytes = f11->sensor.attn_size;
1282 memcpy(f11->sensor.data_pkt, drvdata->attn_data.data,
1283 valid_bytes);
1284 drvdata->attn_data.data += valid_bytes;
1285 drvdata->attn_data.size -= valid_bytes;
1286 } else {
1287 error = rmi_read_block(rmi_dev,
1288 data_base_addr, f11->sensor.data_pkt,
1289 f11->sensor.pkt_size);
1290 if (error < 0)
1291 return IRQ_RETVAL(error);
1292 }
1293
1294 rmi_f11_finger_handler(f11, &f11->sensor, valid_bytes);
1295
1296 return IRQ_HANDLED;
1297}
1298
1299static int rmi_f11_resume(struct rmi_function *fn)
1300{
1301 struct f11_data *f11 = dev_get_drvdata(&fn->dev);
1302 int error;
1303
1304 rmi_dbg(RMI_DEBUG_FN, &fn->dev, "Resuming...\n");
1305 if (!f11->rezero_wait_ms)
1306 return 0;
1307
1308 mdelay(f11->rezero_wait_ms);
1309
1310 error = rmi_write(fn->rmi_dev, fn->fd.command_base_addr,
1311 RMI_F11_REZERO);
1312 if (error) {
1313 dev_err(&fn->dev,
1314 "%s: failed to issue rezero command, error = %d.",
1315 __func__, error);
1316 return error;
1317 }
1318
1319 return 0;
1320}
1321
1322static int rmi_f11_probe(struct rmi_function *fn)
1323{
1324 int error;
1325 struct f11_data *f11;
1326
1327 error = rmi_f11_initialize(fn);
1328 if (error)
1329 return error;
1330
1331 f11 = dev_get_drvdata(&fn->dev);
1332 error = rmi_2d_sensor_configure_input(fn, &f11->sensor);
1333 if (error)
1334 return error;
1335
1336 return 0;
1337}
1338
1339struct rmi_function_handler rmi_f11_handler = {
1340 .driver = {
1341 .name = "rmi4_f11",
1342 },
1343 .func = 0x11,
1344 .probe = rmi_f11_probe,
1345 .config = rmi_f11_config,
1346 .attention = rmi_f11_attention,
1347 .resume = rmi_f11_resume,
1348};