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