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