1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Copyright (c) 2012-2016 Synaptics Incorporated
4 */
5 #include <linux/input.h>
6 #include <linux/input/mt.h>
7 #include <linux/rmi.h>
8 #include <linux/sizes.h>
9 #include <linux/unaligned.h>
10 #include "rmi_driver.h"
11 #include "rmi_2d_sensor.h"
12
13 enum rmi_f12_object_type {
14 RMI_F12_OBJECT_NONE = 0x00,
15 RMI_F12_OBJECT_FINGER = 0x01,
16 RMI_F12_OBJECT_STYLUS = 0x02,
17 RMI_F12_OBJECT_PALM = 0x03,
18 RMI_F12_OBJECT_UNCLASSIFIED = 0x04,
19 RMI_F12_OBJECT_GLOVED_FINGER = 0x06,
20 RMI_F12_OBJECT_NARROW_OBJECT = 0x07,
21 RMI_F12_OBJECT_HAND_EDGE = 0x08,
22 RMI_F12_OBJECT_COVER = 0x0A,
23 RMI_F12_OBJECT_STYLUS_2 = 0x0B,
24 RMI_F12_OBJECT_ERASER = 0x0C,
25 RMI_F12_OBJECT_SMALL_OBJECT = 0x0D,
26 };
27
28 #define F12_DATA1_BYTES_PER_OBJ 8
29 #define RMI_F12_QUERY_RESOLUTION 29
30
31 struct f12_data {
32 struct rmi_2d_sensor sensor;
33 struct rmi_2d_sensor_platform_data sensor_pdata;
34 bool has_dribble;
35
36 u16 data_addr;
37
38 struct rmi_register_descriptor query_reg_desc;
39 struct rmi_register_descriptor control_reg_desc;
40 struct rmi_register_descriptor data_reg_desc;
41
42 /* F12 Data1 describes sensed objects */
43 const struct rmi_register_desc_item *data1;
44 u16 data1_offset;
45
46 /* F12 Data5 describes finger ACM */
47 const struct rmi_register_desc_item *data5;
48 u16 data5_offset;
49
50 /* F12 Data5 describes Pen */
51 const struct rmi_register_desc_item *data6;
52 u16 data6_offset;
53
54 /* F12 Data9 reports relative data */
55 const struct rmi_register_desc_item *data9;
56 u16 data9_offset;
57
58 const struct rmi_register_desc_item *data15;
59 u16 data15_offset;
60
61 unsigned long irq_mask[];
62 };
63
rmi_f12_read_register_descs(struct rmi_function * fn,struct f12_data * f12,u16 query_addr)64 static int rmi_f12_read_register_descs(struct rmi_function *fn,
65 struct f12_data *f12, u16 query_addr)
66 {
67 struct {
68 struct rmi_register_descriptor *desc;
69 const char *name;
70 } descriptors[] = {
71 { &f12->query_reg_desc, "Query" },
72 { &f12->control_reg_desc, "Control" },
73 { &f12->data_reg_desc, "Data" },
74 };
75 struct rmi_device *rmi_dev = fn->rmi_dev;
76 int error;
77 int i;
78
79 for (i = 0; i < ARRAY_SIZE(descriptors); i++) {
80 error = rmi_read_register_desc(rmi_dev, query_addr,
81 descriptors[i].desc);
82 if (error) {
83 dev_err(&fn->dev,
84 "Failed to read the %s Register Descriptor: %d\n",
85 descriptors[i].name, error);
86 return error;
87 }
88 query_addr += 3;
89 }
90
91 return 0;
92 }
93
rmi_f12_read_sensor_tuning(struct f12_data * f12)94 static int rmi_f12_read_sensor_tuning(struct f12_data *f12)
95 {
96 const struct rmi_register_desc_item *item;
97 struct rmi_2d_sensor *sensor = &f12->sensor;
98 struct rmi_function *fn = sensor->fn;
99 struct rmi_device *rmi_dev = fn->rmi_dev;
100 int ret;
101 int offset;
102 u8 buf[15];
103 int pitch_x = 0;
104 int pitch_y = 0;
105 int rx_receivers = 0;
106 int tx_receivers = 0;
107 u16 query_dpm_addr = 0;
108 int dpm_resolution = 0;
109
110 item = rmi_get_register_desc_item(&f12->control_reg_desc, 8);
111 if (!item) {
112 dev_err(&fn->dev,
113 "F12 does not have the sensor tuning control register\n");
114 return -ENODEV;
115 }
116
117 offset = rmi_register_desc_calc_reg_offset(&f12->control_reg_desc, 8);
118
119 if (item->reg_size > sizeof(buf)) {
120 dev_err(&fn->dev,
121 "F12 control8 should be no bigger than %zd bytes, not: %u\n",
122 sizeof(buf), item->reg_size);
123 return -ENODEV;
124 }
125
126 ret = rmi_read_block(rmi_dev, fn->fd.control_base_addr + offset,
127 buf, item->reg_size);
128 if (ret)
129 return ret;
130
131 offset = 0;
132 if (rmi_register_desc_has_subpacket(item, 0)) {
133 sensor->max_x = get_unaligned_le16(&buf[offset]);
134 sensor->max_y = get_unaligned_le16(&buf[offset + 2]);
135 offset += 4;
136 }
137
138 rmi_dbg(RMI_DEBUG_FN, &fn->dev, "%s: max_x: %d max_y: %d\n", __func__,
139 sensor->max_x, sensor->max_y);
140
141 if (rmi_register_desc_has_subpacket(item, 1)) {
142 pitch_x = get_unaligned_le16(&buf[offset]);
143 pitch_y = get_unaligned_le16(&buf[offset + 2]);
144 offset += 4;
145 }
146
147 if (rmi_register_desc_has_subpacket(item, 2)) {
148 /* Units 1/128 sensor pitch */
149 rmi_dbg(RMI_DEBUG_FN, &fn->dev,
150 "%s: Inactive Border xlo:%d xhi:%d ylo:%d yhi:%d\n",
151 __func__,
152 buf[offset], buf[offset + 1],
153 buf[offset + 2], buf[offset + 3]);
154
155 offset += 4;
156 }
157
158 /* When platform data are provided, we're done */
159 if (sensor->x_mm && sensor->y_mm)
160 return 0;
161
162 /*
163 * Use the Query DPM feature when the resolution query register
164 * exists.
165 */
166 if (rmi_get_register_desc_item(&f12->query_reg_desc,
167 RMI_F12_QUERY_RESOLUTION)) {
168 offset = rmi_register_desc_calc_reg_offset(&f12->query_reg_desc,
169 RMI_F12_QUERY_RESOLUTION);
170 query_dpm_addr = fn->fd.query_base_addr + offset;
171 ret = rmi_read(fn->rmi_dev, query_dpm_addr, buf);
172 if (ret) {
173 dev_err(&fn->dev, "Failed to read DPM value: %d\n", ret);
174 return ret;
175 }
176 dpm_resolution = buf[0];
177
178 if (!sensor->x_mm)
179 sensor->x_mm = sensor->max_x / dpm_resolution;
180 if (!sensor->y_mm)
181 sensor->y_mm = sensor->max_y / dpm_resolution;
182 } else {
183 if (rmi_register_desc_has_subpacket(item, 3)) {
184 rx_receivers = buf[offset];
185 tx_receivers = buf[offset + 1];
186 offset += 2;
187 }
188
189 /* Skip over sensor flags */
190 if (rmi_register_desc_has_subpacket(item, 4))
191 offset += 1;
192
193 if (!sensor->x_mm)
194 sensor->x_mm = (pitch_x * rx_receivers) >> 12;
195 if (!sensor->y_mm)
196 sensor->y_mm = (pitch_y * tx_receivers) >> 12;
197 }
198
199 rmi_dbg(RMI_DEBUG_FN, &fn->dev, "%s: x_mm: %d y_mm: %d\n", __func__,
200 sensor->x_mm, sensor->y_mm);
201
202 return 0;
203 }
204
rmi_f12_process_objects(struct f12_data * f12,u8 * data1,u32 size)205 static void rmi_f12_process_objects(struct f12_data *f12, u8 *data1, u32 size)
206 {
207 struct rmi_2d_sensor *sensor = &f12->sensor;
208 u32 objects = min(f12->data1->num_subpackets, size / F12_DATA1_BYTES_PER_OBJ);
209 int i;
210
211 for (i = 0; i < objects; i++) {
212 struct rmi_2d_sensor_abs_object *obj = &sensor->objs[i];
213
214 obj->type = RMI_2D_OBJECT_NONE;
215 obj->mt_tool = MT_TOOL_FINGER;
216
217 switch (data1[0]) {
218 case RMI_F12_OBJECT_FINGER:
219 obj->type = RMI_2D_OBJECT_FINGER;
220 break;
221 case RMI_F12_OBJECT_STYLUS:
222 obj->type = RMI_2D_OBJECT_STYLUS;
223 obj->mt_tool = MT_TOOL_PEN;
224 break;
225 case RMI_F12_OBJECT_PALM:
226 obj->type = RMI_2D_OBJECT_PALM;
227 obj->mt_tool = MT_TOOL_PALM;
228 break;
229 case RMI_F12_OBJECT_UNCLASSIFIED:
230 obj->type = RMI_2D_OBJECT_UNCLASSIFIED;
231 break;
232 }
233
234 obj->x = get_unaligned_le16(&data1[1]);
235 obj->y = get_unaligned_le16(&data1[3]);
236 obj->z = data1[5];
237 obj->wx = data1[6];
238 obj->wy = data1[7];
239
240 rmi_2d_sensor_abs_process(sensor, obj, i);
241
242 data1 += F12_DATA1_BYTES_PER_OBJ;
243 }
244
245 if (sensor->kernel_tracking)
246 input_mt_assign_slots(sensor->input,
247 sensor->tracking_slots,
248 sensor->tracking_pos,
249 sensor->nbr_fingers,
250 sensor->dmax);
251
252 for (i = 0; i < objects; i++)
253 rmi_2d_sensor_abs_report(sensor, &sensor->objs[i], i);
254 }
255
rmi_f12_attention(int irq,void * ctx)256 static irqreturn_t rmi_f12_attention(int irq, void *ctx)
257 {
258 struct rmi_function *fn = ctx;
259 struct rmi_device *rmi_dev = fn->rmi_dev;
260 struct rmi_driver_data *drvdata = dev_get_drvdata(&rmi_dev->dev);
261 struct f12_data *f12 = dev_get_drvdata(&fn->dev);
262 struct rmi_2d_sensor *sensor = &f12->sensor;
263 u32 valid_bytes = sensor->pkt_size;
264 int retval;
265
266 if (drvdata->attn_data.data) {
267 valid_bytes = min_t(u32, sensor->attn_size, drvdata->attn_data.size);
268 memcpy(sensor->data_pkt, drvdata->attn_data.data, valid_bytes);
269 drvdata->attn_data.data += valid_bytes;
270 drvdata->attn_data.size -= valid_bytes;
271 } else {
272 retval = rmi_read_block(rmi_dev, f12->data_addr,
273 sensor->data_pkt, sensor->pkt_size);
274 if (retval < 0) {
275 dev_err(&fn->dev, "Failed to read object data. Code: %d.\n",
276 retval);
277 return IRQ_RETVAL(retval);
278 }
279 }
280
281 if (f12->data1)
282 rmi_f12_process_objects(f12, &sensor->data_pkt[f12->data1_offset],
283 valid_bytes);
284
285 input_mt_sync_frame(sensor->input);
286
287 return IRQ_HANDLED;
288 }
289
rmi_f12_update_dribble(struct rmi_function * fn,struct f12_data * f12)290 static int rmi_f12_update_dribble(struct rmi_function *fn, struct f12_data *f12)
291 {
292 const struct rmi_register_desc_item *item;
293 struct rmi_device *rmi_dev = fn->rmi_dev;
294 u8 subpacket_offset = 0;
295 u16 control_offset;
296 u32 control_size;
297 int error;
298 u8 buf[3];
299
300 item = rmi_get_register_desc_item(&f12->control_reg_desc, 20);
301 if (!item)
302 return 0;
303
304 control_offset = rmi_register_desc_calc_reg_offset(&f12->control_reg_desc, 20);
305
306 /*
307 * The byte containing the EnableDribble bit will be
308 * in either byte 0 or byte 2 of control 20. Depending
309 * on the existence of subpacket 0. If control 20 is
310 * larger then 3 bytes, just read the first 3.
311 */
312 control_size = min(item->reg_size, 3U);
313
314 error = rmi_read_block(rmi_dev, fn->fd.control_base_addr + control_offset,
315 buf, control_size);
316 if (error)
317 return error;
318
319 if (rmi_register_desc_has_subpacket(item, 0))
320 subpacket_offset += 1;
321
322 switch (f12->sensor.dribble) {
323 case RMI_REG_STATE_OFF:
324 buf[subpacket_offset] &= ~BIT(2);
325 break;
326 case RMI_REG_STATE_ON:
327 buf[subpacket_offset] |= BIT(2);
328 break;
329 case RMI_REG_STATE_DEFAULT:
330 default:
331 break;
332 }
333
334 error = rmi_write_block(rmi_dev, fn->fd.control_base_addr + control_offset,
335 buf, control_size);
336 if (error)
337 return error;
338
339 return 0;
340 }
341
rmi_f12_write_control_regs(struct rmi_function * fn)342 static int rmi_f12_write_control_regs(struct rmi_function *fn)
343 {
344 struct f12_data *f12 = dev_get_drvdata(&fn->dev);
345
346 if (f12->has_dribble && f12->sensor.dribble != RMI_REG_STATE_DEFAULT)
347 return rmi_f12_update_dribble(fn, f12);
348
349 return 0;
350 }
351
rmi_f12_config(struct rmi_function * fn)352 static int rmi_f12_config(struct rmi_function *fn)
353 {
354 struct rmi_driver *drv = fn->rmi_dev->driver;
355 struct f12_data *f12 = dev_get_drvdata(&fn->dev);
356 struct rmi_driver_data *drvdata = dev_get_drvdata(&fn->rmi_dev->dev);
357 int irq_mask_size = BITS_TO_LONGS(drvdata->irq_count);
358 unsigned long *abs_mask = f12->irq_mask;
359 unsigned long *rel_mask = f12->irq_mask + irq_mask_size;
360 struct rmi_2d_sensor *sensor;
361 int ret;
362
363 sensor = &f12->sensor;
364
365 if (!sensor->report_abs)
366 drv->clear_irq_bits(fn->rmi_dev, abs_mask);
367 else
368 drv->set_irq_bits(fn->rmi_dev, abs_mask);
369
370 drv->clear_irq_bits(fn->rmi_dev, rel_mask);
371
372 ret = rmi_f12_write_control_regs(fn);
373 if (ret)
374 dev_warn(&fn->dev,
375 "Failed to write F12 control registers: %d\n", ret);
376
377 return 0;
378 }
379
rmi_f12_probe(struct rmi_function * fn)380 static int rmi_f12_probe(struct rmi_function *fn)
381 {
382 struct f12_data *f12;
383 int ret;
384 struct rmi_device *rmi_dev = fn->rmi_dev;
385 char buf;
386 u16 query_addr = fn->fd.query_base_addr;
387 const struct rmi_register_desc_item *item;
388 struct rmi_2d_sensor *sensor;
389 struct rmi_device_platform_data *pdata = rmi_get_platform_data(rmi_dev);
390 struct rmi_driver_data *drvdata = dev_get_drvdata(&rmi_dev->dev);
391 size_t data_offset = 0;
392 size_t pkt_size;
393 int irq_mask_size;
394 int i;
395
396 rmi_dbg(RMI_DEBUG_FN, &fn->dev, "%s\n", __func__);
397
398 irq_mask_size = BITS_TO_LONGS(drvdata->irq_count);
399
400 ret = rmi_read(fn->rmi_dev, query_addr, &buf);
401 if (ret < 0) {
402 dev_err(&fn->dev, "Failed to read general info register: %d\n",
403 ret);
404 return -ENODEV;
405 }
406 ++query_addr;
407
408 if (!(buf & BIT(0))) {
409 dev_err(&fn->dev,
410 "Behavior of F12 without register descriptors is undefined.\n");
411 return -ENODEV;
412 }
413
414 f12 = devm_kzalloc(&fn->dev, struct_size(f12, irq_mask, irq_mask_size * 2),
415 GFP_KERNEL);
416 if (!f12)
417 return -ENOMEM;
418
419 set_bit(fn->irq_pos, f12->irq_mask);
420 set_bit(fn->irq_pos + 1, f12->irq_mask + irq_mask_size);
421
422 f12->has_dribble = !!(buf & BIT(3));
423
424 if (fn->dev.of_node) {
425 ret = rmi_2d_sensor_of_probe(&fn->dev, &f12->sensor_pdata);
426 if (ret)
427 return ret;
428 } else {
429 f12->sensor_pdata = pdata->sensor_pdata;
430 }
431
432 ret = rmi_f12_read_register_descs(fn, f12, query_addr);
433 if (ret)
434 return ret;
435
436 sensor = &f12->sensor;
437 sensor->fn = fn;
438 f12->data_addr = fn->fd.data_base_addr;
439 pkt_size = rmi_register_desc_calc_size(&f12->data_reg_desc);
440 if (pkt_size > SZ_1M) {
441 dev_err(&fn->dev, "Invalid data packet size: %zu\n", pkt_size);
442 return -EINVAL;
443 }
444 sensor->pkt_size = pkt_size;
445
446 sensor->axis_align = f12->sensor_pdata.axis_align;
447
448 sensor->x_mm = f12->sensor_pdata.x_mm;
449 sensor->y_mm = f12->sensor_pdata.y_mm;
450 sensor->dribble = f12->sensor_pdata.dribble;
451
452 if (sensor->sensor_type == rmi_sensor_default)
453 sensor->sensor_type = f12->sensor_pdata.sensor_type;
454
455 rmi_dbg(RMI_DEBUG_FN, &fn->dev, "%s: data packet size: %u\n", __func__,
456 sensor->pkt_size);
457 sensor->data_pkt = devm_kmalloc(&fn->dev, sensor->pkt_size, GFP_KERNEL);
458 if (!sensor->data_pkt)
459 return -ENOMEM;
460
461 dev_set_drvdata(&fn->dev, f12);
462
463 ret = rmi_f12_read_sensor_tuning(f12);
464 if (ret)
465 return ret;
466
467 /*
468 * Identify available data registers and calculate their offsets within
469 * the attention report. For HID devices, only Data1 and Data5 are
470 * included in the report; other registers may be described but are
471 * not transmitted in the attention packet and thus skipped here.
472 */
473 for (i = 0; i < 16; i++) {
474 item = rmi_get_register_desc_item(&f12->data_reg_desc, i);
475 if (!item)
476 continue;
477
478 /* HID attention reports only contain Data1 and Data5 */
479 if (drvdata->attn_data.data && i != 1 && i != 5)
480 continue;
481
482 if (data_offset > U16_MAX) {
483 dev_err(&fn->dev, "Invalid offset for data%d: %zu\n",
484 i, data_offset);
485 return -EINVAL;
486 }
487
488 switch (i) {
489 case 1:
490 f12->data1 = item;
491 f12->data1_offset = data_offset;
492
493 if (item->num_subpackets > 255) {
494 dev_err(&fn->dev,
495 "Too many fingers declared: %d\n",
496 item->num_subpackets);
497 return -EINVAL;
498 }
499
500 sensor->nbr_fingers = item->num_subpackets;
501 sensor->report_abs = 1;
502 sensor->attn_size += item->reg_size;
503 break;
504
505 case 5:
506 f12->data5 = item;
507 f12->data5_offset = data_offset;
508 sensor->attn_size += item->reg_size;
509 break;
510
511 case 6:
512 f12->data6 = item;
513 f12->data6_offset = data_offset;
514 break;
515
516 case 9:
517 f12->data9 = item;
518 f12->data9_offset = data_offset;
519 if (!sensor->report_abs)
520 sensor->report_rel = 1;
521 break;
522
523 case 15:
524 f12->data15 = item;
525 f12->data15_offset = data_offset;
526 break;
527 }
528
529 data_offset += item->reg_size;
530 }
531
532 /* allocate the in-kernel tracking buffers */
533 sensor->tracking_pos = devm_kcalloc(&fn->dev, sensor->nbr_fingers,
534 sizeof(*sensor->tracking_pos),
535 GFP_KERNEL);
536 if (!sensor->tracking_pos)
537 return -ENOMEM;
538
539 sensor->tracking_slots = devm_kcalloc(&fn->dev, sensor->nbr_fingers,
540 sizeof(*sensor->tracking_slots),
541 GFP_KERNEL);
542 if (!sensor->tracking_slots)
543 return -ENOMEM;
544
545 sensor->objs = devm_kcalloc(&fn->dev, sensor->nbr_fingers,
546 sizeof(*sensor->objs), GFP_KERNEL);
547 if (!sensor->objs)
548 return -ENOMEM;
549
550 ret = rmi_2d_sensor_configure_input(fn, sensor);
551 if (ret)
552 return ret;
553
554 return 0;
555 }
556
557 struct rmi_function_handler rmi_f12_handler = {
558 .driver = {
559 .name = "rmi4_f12",
560 },
561 .func = 0x12,
562 .probe = rmi_f12_probe,
563 .config = rmi_f12_config,
564 .attention = rmi_f12_attention,
565 };
566