1
2
3
4
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63#define DMAX 10
64
65
66
67
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
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
87#define RMI_F11_NR_ELECTRODES_MASK 0x7F
88
89
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
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
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
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
130#define RMI_F11_NR_TOUCH_SHAPES_MASK 0x1F
131
132
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
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
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
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
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311struct f11_2d_sensor_queries {
312
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
321 u8 nr_x_electrodes;
322
323
324 u8 nr_y_electrodes;
325
326
327 u8 max_electrodes;
328
329
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
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
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
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
375 u8 nr_touch_shapes;
376
377
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
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
398 u8 jitter_window_size;
399 u8 jitter_filter_type;
400
401
402 u8 light_control;
403 bool is_clear;
404 u8 clickpad_props;
405 u8 mouse_buttons;
406 bool has_advanced_gestures;
407
408
409 u16 x_sensor_size_mm;
410 u16 y_sensor_size_mm;
411};
412
413
414#define RMI_F11_REPORT_MODE_MASK 0x07
415#define RMI_F11_REPORT_MODE_CONTINUOUS (0 << 0)
416#define RMI_F11_REPORT_MODE_REDUCED (1 << 0)
417#define RMI_F11_REPORT_MODE_FS_CHANGE (2 << 0)
418#define RMI_F11_REPORT_MODE_FP_CHANGE (3 << 0)
419#define RMI_F11_ABS_POS_FILT (1 << 3)
420#define RMI_F11_REL_POS_FILT (1 << 4)
421#define RMI_F11_REL_BALLISTICS (1 << 5)
422#define RMI_F11_DRIBBLE (1 << 6)
423#define RMI_F11_REPORT_BEYOND_CLIP (1 << 7)
424
425
426#define RMI_F11_PALM_DETECT_THRESH_MASK 0x0F
427#define RMI_F11_MOTION_SENSITIVITY_MASK 0x30
428#define RMI_F11_MANUAL_TRACKING (1 << 6)
429#define RMI_F11_MANUAL_TRACKED_FINGER (1 << 7)
430
431#define RMI_F11_DELTA_X_THRESHOLD 2
432#define RMI_F11_DELTA_Y_THRESHOLD 3
433
434#define RMI_F11_CTRL_REG_COUNT 12
435
436struct f11_2d_ctrl {
437 u8 ctrl0_11[RMI_F11_CTRL_REG_COUNT];
438 u16 ctrl0_11_address;
439};
440
441#define RMI_F11_ABS_BYTES 5
442#define RMI_F11_REL_BYTES 2
443
444
445
446#define RMI_F11_SINGLE_TAP (1 << 0)
447#define RMI_F11_TAP_AND_HOLD (1 << 1)
448#define RMI_F11_DOUBLE_TAP (1 << 2)
449#define RMI_F11_EARLY_TAP (1 << 3)
450#define RMI_F11_FLICK (1 << 4)
451#define RMI_F11_PRESS (1 << 5)
452#define RMI_F11_PINCH (1 << 6)
453
454
455
456#define RMI_F11_PALM_DETECT (1 << 0)
457#define RMI_F11_ROTATE (1 << 1)
458#define RMI_F11_SHAPE (1 << 2)
459#define RMI_F11_SCROLLZONE (1 << 3)
460#define RMI_F11_GESTURE_FINGER_COUNT_MASK 0x70
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475struct f11_2d_data {
476 u8 *f_state;
477 u8 *abs_pos;
478 s8 *rel_pos;
479 u8 *gest_1;
480 u8 *gest_2;
481 s8 *pinch;
482 u8 *flick;
483 u8 *rotate;
484 u8 *shapes;
485 s8 *multi_scroll;
486 s8 *scroll_zones;
487};
488
489
490
491
492
493
494
495
496
497
498
499
500
501struct f11_data {
502 bool has_query9;
503 bool has_query11;
504 bool has_query12;
505 bool has_query27;
506 bool has_query28;
507 bool has_acm;
508 struct f11_2d_ctrl dev_controls;
509 struct mutex dev_controls_mutex;
510 u16 rezero_wait_ms;
511 struct rmi_2d_sensor sensor;
512 struct f11_2d_sensor_queries sens_query;
513 struct f11_2d_data data;
514 struct rmi_2d_sensor_platform_data sensor_pdata;
515 unsigned long *abs_mask;
516 unsigned long *rel_mask;
517};
518
519enum f11_finger_state {
520 F11_NO_FINGER = 0x00,
521 F11_PRESENT = 0x01,
522 F11_INACCURATE = 0x02,
523 F11_RESERVED = 0x03
524};
525
526static 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
538static 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
566static 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
572static void rmi_f11_finger_handler(struct f11_data *f11,
573 struct rmi_2d_sensor *sensor, int size)
574{
575 const u8 *f_state = f11->data.f_state;
576 u8 finger_state;
577 u8 i;
578 int abs_fingers;
579 int rel_fingers;
580 int abs_size = sensor->nbr_fingers * RMI_F11_ABS_BYTES;
581
582 if (sensor->report_abs) {
583 if (abs_size > size)
584 abs_fingers = size / RMI_F11_ABS_BYTES;
585 else
586 abs_fingers = sensor->nbr_fingers;
587
588 for (i = 0; i < abs_fingers; i++) {
589
590 finger_state = rmi_f11_parse_finger_state(f_state, i);
591 if (finger_state == F11_RESERVED) {
592 pr_err("Invalid finger state[%d]: 0x%02x", i,
593 finger_state);
594 continue;
595 }
596
597 rmi_f11_abs_pos_process(f11, sensor, &sensor->objs[i],
598 finger_state, i);
599 }
600
601
602
603
604
605 if (sensor->kernel_tracking)
606 input_mt_assign_slots(sensor->input,
607 sensor->tracking_slots,
608 sensor->tracking_pos,
609 sensor->nbr_fingers,
610 sensor->dmax);
611
612 for (i = 0; i < abs_fingers; i++) {
613 finger_state = rmi_f11_parse_finger_state(f_state, i);
614 if (finger_state == F11_RESERVED)
615
616 continue;
617
618 rmi_2d_sensor_abs_report(sensor, &sensor->objs[i], i);
619 }
620
621 input_mt_sync_frame(sensor->input);
622 } else if (sensor->report_rel) {
623 if ((abs_size + sensor->nbr_fingers * RMI_F11_REL_BYTES) > size)
624 rel_fingers = (size - abs_size) / RMI_F11_REL_BYTES;
625 else
626 rel_fingers = sensor->nbr_fingers;
627
628 for (i = 0; i < rel_fingers; i++)
629 rmi_f11_rel_pos_report(f11, i);
630 }
631
632}
633
634static int f11_2d_construct_data(struct f11_data *f11)
635{
636 struct rmi_2d_sensor *sensor = &f11->sensor;
637 struct f11_2d_sensor_queries *query = &f11->sens_query;
638 struct f11_2d_data *data = &f11->data;
639 int i;
640
641 sensor->nbr_fingers = (query->nr_fingers == 5 ? 10 :
642 query->nr_fingers + 1);
643
644 sensor->pkt_size = DIV_ROUND_UP(sensor->nbr_fingers, 4);
645
646 if (query->has_abs) {
647 sensor->pkt_size += (sensor->nbr_fingers * 5);
648 sensor->attn_size = sensor->pkt_size;
649 }
650
651 if (query->has_rel)
652 sensor->pkt_size += (sensor->nbr_fingers * 2);
653
654
655 if (query->query7_nonzero)
656 sensor->pkt_size += sizeof(u8);
657
658
659 if (query->query7_nonzero || query->query8_nonzero)
660 sensor->pkt_size += sizeof(u8);
661
662 if (query->has_pinch || query->has_flick || query->has_rotate) {
663 sensor->pkt_size += 3;
664 if (!query->has_flick)
665 sensor->pkt_size--;
666 if (!query->has_rotate)
667 sensor->pkt_size--;
668 }
669
670 if (query->has_touch_shapes)
671 sensor->pkt_size +=
672 DIV_ROUND_UP(query->nr_touch_shapes + 1, 8);
673
674 sensor->data_pkt = devm_kzalloc(&sensor->fn->dev, sensor->pkt_size,
675 GFP_KERNEL);
676 if (!sensor->data_pkt)
677 return -ENOMEM;
678
679 data->f_state = sensor->data_pkt;
680 i = DIV_ROUND_UP(sensor->nbr_fingers, 4);
681
682 if (query->has_abs) {
683 data->abs_pos = &sensor->data_pkt[i];
684 i += (sensor->nbr_fingers * RMI_F11_ABS_BYTES);
685 }
686
687 if (query->has_rel) {
688 data->rel_pos = &sensor->data_pkt[i];
689 i += (sensor->nbr_fingers * RMI_F11_REL_BYTES);
690 }
691
692 if (query->query7_nonzero) {
693 data->gest_1 = &sensor->data_pkt[i];
694 i++;
695 }
696
697 if (query->query7_nonzero || query->query8_nonzero) {
698 data->gest_2 = &sensor->data_pkt[i];
699 i++;
700 }
701
702 if (query->has_pinch) {
703 data->pinch = &sensor->data_pkt[i];
704 i++;
705 }
706
707 if (query->has_flick) {
708 if (query->has_pinch) {
709 data->flick = data->pinch;
710 i += 2;
711 } else {
712 data->flick = &sensor->data_pkt[i];
713 i += 3;
714 }
715 }
716
717 if (query->has_rotate) {
718 if (query->has_flick) {
719 data->rotate = data->flick + 1;
720 } else {
721 data->rotate = &sensor->data_pkt[i];
722 i += 2;
723 }
724 }
725
726 if (query->has_touch_shapes)
727 data->shapes = &sensor->data_pkt[i];
728
729 return 0;
730}
731
732static int f11_read_control_regs(struct rmi_function *fn,
733 struct f11_2d_ctrl *ctrl, u16 ctrl_base_addr) {
734 struct rmi_device *rmi_dev = fn->rmi_dev;
735 int error = 0;
736
737 ctrl->ctrl0_11_address = ctrl_base_addr;
738 error = rmi_read_block(rmi_dev, ctrl_base_addr, ctrl->ctrl0_11,
739 RMI_F11_CTRL_REG_COUNT);
740 if (error < 0) {
741 dev_err(&fn->dev, "Failed to read ctrl0, code: %d.\n", error);
742 return error;
743 }
744
745 return 0;
746}
747
748static int f11_write_control_regs(struct rmi_function *fn,
749 struct f11_2d_sensor_queries *query,
750 struct f11_2d_ctrl *ctrl,
751 u16 ctrl_base_addr)
752{
753 struct rmi_device *rmi_dev = fn->rmi_dev;
754 int error;
755
756 error = rmi_write_block(rmi_dev, ctrl_base_addr, ctrl->ctrl0_11,
757 RMI_F11_CTRL_REG_COUNT);
758 if (error < 0)
759 return error;
760
761 return 0;
762}
763
764static int rmi_f11_get_query_parameters(struct rmi_device *rmi_dev,
765 struct f11_data *f11,
766 struct f11_2d_sensor_queries *sensor_query,
767 u16 query_base_addr)
768{
769 int query_size;
770 int rc;
771 u8 query_buf[RMI_F11_QUERY_SIZE];
772 bool has_query36 = false;
773
774 rc = rmi_read_block(rmi_dev, query_base_addr, query_buf,
775 RMI_F11_QUERY_SIZE);
776 if (rc < 0)
777 return rc;
778
779 sensor_query->nr_fingers = query_buf[0] & RMI_F11_NR_FINGERS_MASK;
780 sensor_query->has_rel = !!(query_buf[0] & RMI_F11_HAS_REL);
781 sensor_query->has_abs = !!(query_buf[0] & RMI_F11_HAS_ABS);
782 sensor_query->has_gestures = !!(query_buf[0] & RMI_F11_HAS_GESTURES);
783 sensor_query->has_sensitivity_adjust =
784 !!(query_buf[0] & RMI_F11_HAS_SENSITIVITY_ADJ);
785 sensor_query->configurable = !!(query_buf[0] & RMI_F11_CONFIGURABLE);
786
787 sensor_query->nr_x_electrodes =
788 query_buf[1] & RMI_F11_NR_ELECTRODES_MASK;
789 sensor_query->nr_y_electrodes =
790 query_buf[2] & RMI_F11_NR_ELECTRODES_MASK;
791 sensor_query->max_electrodes =
792 query_buf[3] & RMI_F11_NR_ELECTRODES_MASK;
793
794 query_size = RMI_F11_QUERY_SIZE;
795
796 if (sensor_query->has_abs) {
797 rc = rmi_read(rmi_dev, query_base_addr + query_size, query_buf);
798 if (rc < 0)
799 return rc;
800
801 sensor_query->abs_data_size =
802 query_buf[0] & RMI_F11_ABS_DATA_SIZE_MASK;
803 sensor_query->has_anchored_finger =
804 !!(query_buf[0] & RMI_F11_HAS_ANCHORED_FINGER);
805 sensor_query->has_adj_hyst =
806 !!(query_buf[0] & RMI_F11_HAS_ADJ_HYST);
807 sensor_query->has_dribble =
808 !!(query_buf[0] & RMI_F11_HAS_DRIBBLE);
809 sensor_query->has_bending_correction =
810 !!(query_buf[0] & RMI_F11_HAS_BENDING_CORRECTION);
811 sensor_query->has_large_object_suppression =
812 !!(query_buf[0] & RMI_F11_HAS_LARGE_OBJECT_SUPPRESSION);
813 sensor_query->has_jitter_filter =
814 !!(query_buf[0] & RMI_F11_HAS_JITTER_FILTER);
815 query_size++;
816 }
817
818 if (sensor_query->has_rel) {
819 rc = rmi_read(rmi_dev, query_base_addr + query_size,
820 &sensor_query->f11_2d_query6);
821 if (rc < 0)
822 return rc;
823 query_size++;
824 }
825
826 if (sensor_query->has_gestures) {
827 rc = rmi_read_block(rmi_dev, query_base_addr + query_size,
828 query_buf, RMI_F11_QUERY_GESTURE_SIZE);
829 if (rc < 0)
830 return rc;
831
832 sensor_query->has_single_tap =
833 !!(query_buf[0] & RMI_F11_HAS_SINGLE_TAP);
834 sensor_query->has_tap_n_hold =
835 !!(query_buf[0] & RMI_F11_HAS_TAP_AND_HOLD);
836 sensor_query->has_double_tap =
837 !!(query_buf[0] & RMI_F11_HAS_DOUBLE_TAP);
838 sensor_query->has_early_tap =
839 !!(query_buf[0] & RMI_F11_HAS_EARLY_TAP);
840 sensor_query->has_flick =
841 !!(query_buf[0] & RMI_F11_HAS_FLICK);
842 sensor_query->has_press =
843 !!(query_buf[0] & RMI_F11_HAS_PRESS);
844 sensor_query->has_pinch =
845 !!(query_buf[0] & RMI_F11_HAS_PINCH);
846 sensor_query->has_chiral =
847 !!(query_buf[0] & RMI_F11_HAS_CHIRAL);
848
849
850 sensor_query->has_palm_det =
851 !!(query_buf[1] & RMI_F11_HAS_PALM_DET);
852 sensor_query->has_rotate =
853 !!(query_buf[1] & RMI_F11_HAS_ROTATE);
854 sensor_query->has_touch_shapes =
855 !!(query_buf[1] & RMI_F11_HAS_TOUCH_SHAPES);
856 sensor_query->has_scroll_zones =
857 !!(query_buf[1] & RMI_F11_HAS_SCROLL_ZONES);
858 sensor_query->has_individual_scroll_zones =
859 !!(query_buf[1] & RMI_F11_HAS_INDIVIDUAL_SCROLL_ZONES);
860 sensor_query->has_mf_scroll =
861 !!(query_buf[1] & RMI_F11_HAS_MF_SCROLL);
862 sensor_query->has_mf_edge_motion =
863 !!(query_buf[1] & RMI_F11_HAS_MF_EDGE_MOTION);
864 sensor_query->has_mf_scroll_inertia =
865 !!(query_buf[1] & RMI_F11_HAS_MF_SCROLL_INERTIA);
866
867 sensor_query->query7_nonzero = !!(query_buf[0]);
868 sensor_query->query8_nonzero = !!(query_buf[1]);
869
870 query_size += 2;
871 }
872
873 if (f11->has_query9) {
874 rc = rmi_read(rmi_dev, query_base_addr + query_size, query_buf);
875 if (rc < 0)
876 return rc;
877
878 sensor_query->has_pen =
879 !!(query_buf[0] & RMI_F11_HAS_PEN);
880 sensor_query->has_proximity =
881 !!(query_buf[0] & RMI_F11_HAS_PROXIMITY);
882 sensor_query->has_palm_det_sensitivity =
883 !!(query_buf[0] & RMI_F11_HAS_PALM_DET_SENSITIVITY);
884 sensor_query->has_suppress_on_palm_detect =
885 !!(query_buf[0] & RMI_F11_HAS_SUPPRESS_ON_PALM_DETECT);
886 sensor_query->has_two_pen_thresholds =
887 !!(query_buf[0] & RMI_F11_HAS_TWO_PEN_THRESHOLDS);
888 sensor_query->has_contact_geometry =
889 !!(query_buf[0] & RMI_F11_HAS_CONTACT_GEOMETRY);
890 sensor_query->has_pen_hover_discrimination =
891 !!(query_buf[0] & RMI_F11_HAS_PEN_HOVER_DISCRIMINATION);
892 sensor_query->has_pen_filters =
893 !!(query_buf[0] & RMI_F11_HAS_PEN_FILTERS);
894
895 query_size++;
896 }
897
898 if (sensor_query->has_touch_shapes) {
899 rc = rmi_read(rmi_dev, query_base_addr + query_size, query_buf);
900 if (rc < 0)
901 return rc;
902
903 sensor_query->nr_touch_shapes = query_buf[0] &
904 RMI_F11_NR_TOUCH_SHAPES_MASK;
905
906 query_size++;
907 }
908
909 if (f11->has_query11) {
910 rc = rmi_read(rmi_dev, query_base_addr + query_size, query_buf);
911 if (rc < 0)
912 return rc;
913
914 sensor_query->has_z_tuning =
915 !!(query_buf[0] & RMI_F11_HAS_Z_TUNING);
916 sensor_query->has_algorithm_selection =
917 !!(query_buf[0] & RMI_F11_HAS_ALGORITHM_SELECTION);
918 sensor_query->has_w_tuning =
919 !!(query_buf[0] & RMI_F11_HAS_W_TUNING);
920 sensor_query->has_pitch_info =
921 !!(query_buf[0] & RMI_F11_HAS_PITCH_INFO);
922 sensor_query->has_finger_size =
923 !!(query_buf[0] & RMI_F11_HAS_FINGER_SIZE);
924 sensor_query->has_segmentation_aggressiveness =
925 !!(query_buf[0] &
926 RMI_F11_HAS_SEGMENTATION_AGGRESSIVENESS);
927 sensor_query->has_XY_clip =
928 !!(query_buf[0] & RMI_F11_HAS_XY_CLIP);
929 sensor_query->has_drumming_filter =
930 !!(query_buf[0] & RMI_F11_HAS_DRUMMING_FILTER);
931
932 query_size++;
933 }
934
935 if (f11->has_query12) {
936 rc = rmi_read(rmi_dev, query_base_addr + query_size, query_buf);
937 if (rc < 0)
938 return rc;
939
940 sensor_query->has_gapless_finger =
941 !!(query_buf[0] & RMI_F11_HAS_GAPLESS_FINGER);
942 sensor_query->has_gapless_finger_tuning =
943 !!(query_buf[0] & RMI_F11_HAS_GAPLESS_FINGER_TUNING);
944 sensor_query->has_8bit_w =
945 !!(query_buf[0] & RMI_F11_HAS_8BIT_W);
946 sensor_query->has_adjustable_mapping =
947 !!(query_buf[0] & RMI_F11_HAS_ADJUSTABLE_MAPPING);
948 sensor_query->has_info2 =
949 !!(query_buf[0] & RMI_F11_HAS_INFO2);
950 sensor_query->has_physical_props =
951 !!(query_buf[0] & RMI_F11_HAS_PHYSICAL_PROPS);
952 sensor_query->has_finger_limit =
953 !!(query_buf[0] & RMI_F11_HAS_FINGER_LIMIT);
954 sensor_query->has_linear_coeff_2 =
955 !!(query_buf[0] & RMI_F11_HAS_LINEAR_COEFF);
956
957 query_size++;
958 }
959
960 if (sensor_query->has_jitter_filter) {
961 rc = rmi_read(rmi_dev, query_base_addr + query_size, query_buf);
962 if (rc < 0)
963 return rc;
964
965 sensor_query->jitter_window_size = query_buf[0] &
966 RMI_F11_JITTER_WINDOW_MASK;
967 sensor_query->jitter_filter_type = (query_buf[0] &
968 RMI_F11_JITTER_FILTER_MASK) >>
969 RMI_F11_JITTER_FILTER_SHIFT;
970
971 query_size++;
972 }
973
974 if (sensor_query->has_info2) {
975 rc = rmi_read(rmi_dev, query_base_addr + query_size, query_buf);
976 if (rc < 0)
977 return rc;
978
979 sensor_query->light_control =
980 query_buf[0] & RMI_F11_LIGHT_CONTROL_MASK;
981 sensor_query->is_clear =
982 !!(query_buf[0] & RMI_F11_IS_CLEAR);
983 sensor_query->clickpad_props =
984 (query_buf[0] & RMI_F11_CLICKPAD_PROPS_MASK) >>
985 RMI_F11_CLICKPAD_PROPS_SHIFT;
986 sensor_query->mouse_buttons =
987 (query_buf[0] & RMI_F11_MOUSE_BUTTONS_MASK) >>
988 RMI_F11_MOUSE_BUTTONS_SHIFT;
989 sensor_query->has_advanced_gestures =
990 !!(query_buf[0] & RMI_F11_HAS_ADVANCED_GESTURES);
991
992 query_size++;
993 }
994
995 if (sensor_query->has_physical_props) {
996 rc = rmi_read_block(rmi_dev, query_base_addr
997 + query_size, query_buf, 4);
998 if (rc < 0)
999 return rc;
1000
1001 sensor_query->x_sensor_size_mm =
1002 (query_buf[0] | (query_buf[1] << 8)) / 10;
1003 sensor_query->y_sensor_size_mm =
1004 (query_buf[2] | (query_buf[3] << 8)) / 10;
1005
1006
1007
1008
1009
1010 query_size += 12;
1011 }
1012
1013 if (f11->has_query27)
1014 ++query_size;
1015
1016 if (f11->has_query28) {
1017 rc = rmi_read(rmi_dev, query_base_addr + query_size,
1018 query_buf);
1019 if (rc < 0)
1020 return rc;
1021
1022 has_query36 = !!(query_buf[0] & BIT(6));
1023 }
1024
1025 if (has_query36) {
1026 query_size += 2;
1027 rc = rmi_read(rmi_dev, query_base_addr + query_size,
1028 query_buf);
1029 if (rc < 0)
1030 return rc;
1031
1032 if (!!(query_buf[0] & BIT(5)))
1033 f11->has_acm = true;
1034 }
1035
1036 return query_size;
1037}
1038
1039static int rmi_f11_initialize(struct rmi_function *fn)
1040{
1041 struct rmi_device *rmi_dev = fn->rmi_dev;
1042 struct f11_data *f11;
1043 struct f11_2d_ctrl *ctrl;
1044 u8 query_offset;
1045 u16 query_base_addr;
1046 u16 control_base_addr;
1047 u16 max_x_pos, max_y_pos;
1048 int rc;
1049 const struct rmi_device_platform_data *pdata =
1050 rmi_get_platform_data(rmi_dev);
1051 struct rmi_driver_data *drvdata = dev_get_drvdata(&rmi_dev->dev);
1052 struct rmi_2d_sensor *sensor;
1053 u8 buf;
1054 int mask_size;
1055
1056 rmi_dbg(RMI_DEBUG_FN, &fn->dev, "Initializing F11 values.\n");
1057
1058 mask_size = BITS_TO_LONGS(drvdata->irq_count) * sizeof(unsigned long);
1059
1060
1061
1062
1063 f11 = devm_kzalloc(&fn->dev, sizeof(struct f11_data) + mask_size * 2,
1064 GFP_KERNEL);
1065 if (!f11)
1066 return -ENOMEM;
1067
1068 if (fn->dev.of_node) {
1069 rc = rmi_2d_sensor_of_probe(&fn->dev, &f11->sensor_pdata);
1070 if (rc)
1071 return rc;
1072 } else {
1073 f11->sensor_pdata = pdata->sensor_pdata;
1074 }
1075
1076 f11->rezero_wait_ms = f11->sensor_pdata.rezero_wait;
1077
1078 f11->abs_mask = (unsigned long *)((char *)f11
1079 + sizeof(struct f11_data));
1080 f11->rel_mask = (unsigned long *)((char *)f11
1081 + sizeof(struct f11_data) + mask_size);
1082
1083 set_bit(fn->irq_pos, f11->abs_mask);
1084 set_bit(fn->irq_pos + 1, f11->rel_mask);
1085
1086 query_base_addr = fn->fd.query_base_addr;
1087 control_base_addr = fn->fd.control_base_addr;
1088
1089 rc = rmi_read(rmi_dev, query_base_addr, &buf);
1090 if (rc < 0)
1091 return rc;
1092
1093 f11->has_query9 = !!(buf & RMI_F11_HAS_QUERY9);
1094 f11->has_query11 = !!(buf & RMI_F11_HAS_QUERY11);
1095 f11->has_query12 = !!(buf & RMI_F11_HAS_QUERY12);
1096 f11->has_query27 = !!(buf & RMI_F11_HAS_QUERY27);
1097 f11->has_query28 = !!(buf & RMI_F11_HAS_QUERY28);
1098
1099 query_offset = (query_base_addr + 1);
1100 sensor = &f11->sensor;
1101 sensor->fn = fn;
1102
1103 rc = rmi_f11_get_query_parameters(rmi_dev, f11,
1104 &f11->sens_query, query_offset);
1105 if (rc < 0)
1106 return rc;
1107 query_offset += rc;
1108
1109 rc = f11_read_control_regs(fn, &f11->dev_controls,
1110 control_base_addr);
1111 if (rc < 0) {
1112 dev_err(&fn->dev,
1113 "Failed to read F11 control params.\n");
1114 return rc;
1115 }
1116
1117 if (f11->sens_query.has_info2) {
1118 if (f11->sens_query.is_clear)
1119 f11->sensor.sensor_type = rmi_sensor_touchscreen;
1120 else
1121 f11->sensor.sensor_type = rmi_sensor_touchpad;
1122 }
1123
1124 sensor->report_abs = f11->sens_query.has_abs;
1125
1126 sensor->axis_align =
1127 f11->sensor_pdata.axis_align;
1128
1129 sensor->topbuttonpad = f11->sensor_pdata.topbuttonpad;
1130 sensor->kernel_tracking = f11->sensor_pdata.kernel_tracking;
1131 sensor->dmax = f11->sensor_pdata.dmax;
1132 sensor->dribble = f11->sensor_pdata.dribble;
1133 sensor->palm_detect = f11->sensor_pdata.palm_detect;
1134
1135 if (f11->sens_query.has_physical_props) {
1136 sensor->x_mm = f11->sens_query.x_sensor_size_mm;
1137 sensor->y_mm = f11->sens_query.y_sensor_size_mm;
1138 } else {
1139 sensor->x_mm = f11->sensor_pdata.x_mm;
1140 sensor->y_mm = f11->sensor_pdata.y_mm;
1141 }
1142
1143 if (sensor->sensor_type == rmi_sensor_default)
1144 sensor->sensor_type =
1145 f11->sensor_pdata.sensor_type;
1146
1147 sensor->report_abs = sensor->report_abs
1148 && !(f11->sensor_pdata.disable_report_mask
1149 & RMI_F11_DISABLE_ABS_REPORT);
1150
1151 if (!sensor->report_abs)
1152
1153
1154
1155
1156 sensor->report_rel = f11->sens_query.has_rel;
1157
1158 rc = rmi_read_block(rmi_dev,
1159 control_base_addr + F11_CTRL_SENSOR_MAX_X_POS_OFFSET,
1160 (u8 *)&max_x_pos, sizeof(max_x_pos));
1161 if (rc < 0)
1162 return rc;
1163
1164 rc = rmi_read_block(rmi_dev,
1165 control_base_addr + F11_CTRL_SENSOR_MAX_Y_POS_OFFSET,
1166 (u8 *)&max_y_pos, sizeof(max_y_pos));
1167 if (rc < 0)
1168 return rc;
1169
1170 sensor->max_x = max_x_pos;
1171 sensor->max_y = max_y_pos;
1172
1173 rc = f11_2d_construct_data(f11);
1174 if (rc < 0)
1175 return rc;
1176
1177 if (f11->has_acm)
1178 f11->sensor.attn_size += f11->sensor.nbr_fingers * 2;
1179
1180
1181 sensor->tracking_pos = devm_kcalloc(&fn->dev,
1182 sensor->nbr_fingers, sizeof(struct input_mt_pos),
1183 GFP_KERNEL);
1184 sensor->tracking_slots = devm_kcalloc(&fn->dev,
1185 sensor->nbr_fingers, sizeof(int), GFP_KERNEL);
1186 sensor->objs = devm_kcalloc(&fn->dev,
1187 sensor->nbr_fingers,
1188 sizeof(struct rmi_2d_sensor_abs_object),
1189 GFP_KERNEL);
1190 if (!sensor->tracking_pos || !sensor->tracking_slots || !sensor->objs)
1191 return -ENOMEM;
1192
1193 ctrl = &f11->dev_controls;
1194 if (sensor->axis_align.delta_x_threshold)
1195 ctrl->ctrl0_11[RMI_F11_DELTA_X_THRESHOLD] =
1196 sensor->axis_align.delta_x_threshold;
1197
1198 if (sensor->axis_align.delta_y_threshold)
1199 ctrl->ctrl0_11[RMI_F11_DELTA_Y_THRESHOLD] =
1200 sensor->axis_align.delta_y_threshold;
1201
1202
1203
1204
1205
1206 if (sensor->axis_align.delta_x_threshold ||
1207 sensor->axis_align.delta_y_threshold) {
1208 ctrl->ctrl0_11[0] &= ~RMI_F11_REPORT_MODE_MASK;
1209 ctrl->ctrl0_11[0] |= RMI_F11_REPORT_MODE_REDUCED;
1210 }
1211
1212 if (f11->sens_query.has_dribble) {
1213 switch (sensor->dribble) {
1214 case RMI_REG_STATE_OFF:
1215 ctrl->ctrl0_11[0] &= ~BIT(6);
1216 break;
1217 case RMI_REG_STATE_ON:
1218 ctrl->ctrl0_11[0] |= BIT(6);
1219 break;
1220 case RMI_REG_STATE_DEFAULT:
1221 default:
1222 break;
1223 }
1224 }
1225
1226 if (f11->sens_query.has_palm_det) {
1227 switch (sensor->palm_detect) {
1228 case RMI_REG_STATE_OFF:
1229 ctrl->ctrl0_11[11] &= ~BIT(0);
1230 break;
1231 case RMI_REG_STATE_ON:
1232 ctrl->ctrl0_11[11] |= BIT(0);
1233 break;
1234 case RMI_REG_STATE_DEFAULT:
1235 default:
1236 break;
1237 }
1238 }
1239
1240 rc = f11_write_control_regs(fn, &f11->sens_query,
1241 &f11->dev_controls, fn->fd.control_base_addr);
1242 if (rc)
1243 dev_warn(&fn->dev, "Failed to write control registers\n");
1244
1245 mutex_init(&f11->dev_controls_mutex);
1246
1247 dev_set_drvdata(&fn->dev, f11);
1248
1249 return 0;
1250}
1251
1252static int rmi_f11_config(struct rmi_function *fn)
1253{
1254 struct f11_data *f11 = dev_get_drvdata(&fn->dev);
1255 struct rmi_driver *drv = fn->rmi_dev->driver;
1256 struct rmi_2d_sensor *sensor = &f11->sensor;
1257 int rc;
1258
1259 if (!sensor->report_abs)
1260 drv->clear_irq_bits(fn->rmi_dev, f11->abs_mask);
1261 else
1262 drv->set_irq_bits(fn->rmi_dev, f11->abs_mask);
1263
1264 if (!sensor->report_rel)
1265 drv->clear_irq_bits(fn->rmi_dev, f11->rel_mask);
1266 else
1267 drv->set_irq_bits(fn->rmi_dev, f11->rel_mask);
1268
1269 rc = f11_write_control_regs(fn, &f11->sens_query,
1270 &f11->dev_controls, fn->fd.query_base_addr);
1271 if (rc < 0)
1272 return rc;
1273
1274 return 0;
1275}
1276
1277static irqreturn_t rmi_f11_attention(int irq, void *ctx)
1278{
1279 struct rmi_function *fn = ctx;
1280 struct rmi_device *rmi_dev = fn->rmi_dev;
1281 struct rmi_driver_data *drvdata = dev_get_drvdata(&rmi_dev->dev);
1282 struct f11_data *f11 = dev_get_drvdata(&fn->dev);
1283 u16 data_base_addr = fn->fd.data_base_addr;
1284 int error;
1285 int valid_bytes = f11->sensor.pkt_size;
1286
1287 if (drvdata->attn_data.data) {
1288
1289
1290
1291
1292 if (f11->sensor.attn_size > drvdata->attn_data.size)
1293 valid_bytes = drvdata->attn_data.size;
1294 else
1295 valid_bytes = f11->sensor.attn_size;
1296 memcpy(f11->sensor.data_pkt, drvdata->attn_data.data,
1297 valid_bytes);
1298 drvdata->attn_data.data += valid_bytes;
1299 drvdata->attn_data.size -= valid_bytes;
1300 } else {
1301 error = rmi_read_block(rmi_dev,
1302 data_base_addr, f11->sensor.data_pkt,
1303 f11->sensor.pkt_size);
1304 if (error < 0)
1305 return IRQ_RETVAL(error);
1306 }
1307
1308 rmi_f11_finger_handler(f11, &f11->sensor, valid_bytes);
1309
1310 return IRQ_HANDLED;
1311}
1312
1313static int rmi_f11_resume(struct rmi_function *fn)
1314{
1315 struct f11_data *f11 = dev_get_drvdata(&fn->dev);
1316 int error;
1317
1318 rmi_dbg(RMI_DEBUG_FN, &fn->dev, "Resuming...\n");
1319 if (!f11->rezero_wait_ms)
1320 return 0;
1321
1322 mdelay(f11->rezero_wait_ms);
1323
1324 error = rmi_write(fn->rmi_dev, fn->fd.command_base_addr,
1325 RMI_F11_REZERO);
1326 if (error) {
1327 dev_err(&fn->dev,
1328 "%s: failed to issue rezero command, error = %d.",
1329 __func__, error);
1330 return error;
1331 }
1332
1333 return 0;
1334}
1335
1336static int rmi_f11_probe(struct rmi_function *fn)
1337{
1338 int error;
1339 struct f11_data *f11;
1340
1341 error = rmi_f11_initialize(fn);
1342 if (error)
1343 return error;
1344
1345 f11 = dev_get_drvdata(&fn->dev);
1346 error = rmi_2d_sensor_configure_input(fn, &f11->sensor);
1347 if (error)
1348 return error;
1349
1350 return 0;
1351}
1352
1353struct rmi_function_handler rmi_f11_handler = {
1354 .driver = {
1355 .name = "rmi4_f11",
1356 },
1357 .func = 0x11,
1358 .probe = rmi_f11_probe,
1359 .config = rmi_f11_config,
1360 .attention = rmi_f11_attention,
1361 .resume = rmi_f11_resume,
1362};
1363