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
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333struct f11_2d_sensor_queries {
334
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
343 u8 nr_x_electrodes;
344
345
346 u8 nr_y_electrodes;
347
348
349 u8 max_electrodes;
350
351
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
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
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
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
397 u8 nr_touch_shapes;
398
399
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
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
420 u8 jitter_window_size;
421 u8 jitter_filter_type;
422
423
424 u8 light_control;
425 bool is_clear;
426 u8 clickpad_props;
427 u8 mouse_buttons;
428 bool has_advanced_gestures;
429
430
431 u16 x_sensor_size_mm;
432 u16 y_sensor_size_mm;
433};
434
435
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
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
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
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
485
486
487
488
489
490
491
492
493
494
495
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
512
513
514
515
516
517
518
519
520
521
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
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
625
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
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
677 if (query->query7_nonzero)
678 sensor->pkt_size += sizeof(u8);
679
680
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
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
1030
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
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
1176
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
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
1226
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
1312
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};
1385