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