1
2
3
4
5
6
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
43 const struct rmi_register_desc_item *data1;
44 u16 data1_offset;
45
46
47 const struct rmi_register_desc_item *data5;
48 u16 data5_offset;
49
50
51 const struct rmi_register_desc_item *data6;
52 u16 data6_offset;
53
54
55
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 sensor->axis_align.clip_x_low = buf[offset];
117 sensor->axis_align.clip_x_high = sensor->max_x
118 - buf[offset + 1];
119 sensor->axis_align.clip_y_low = buf[offset + 2];
120 sensor->axis_align.clip_y_high = sensor->max_y
121 - buf[offset + 3];
122 offset += 4;
123 }
124
125 rmi_dbg(RMI_DEBUG_FN, &fn->dev, "%s: x low: %d x high: %d y low: %d y high: %d\n",
126 __func__,
127 sensor->axis_align.clip_x_low, sensor->axis_align.clip_x_high,
128 sensor->axis_align.clip_y_low, sensor->axis_align.clip_y_high);
129
130 if (rmi_register_desc_has_subpacket(item, 3)) {
131 rx_receivers = buf[offset];
132 tx_receivers = buf[offset + 1];
133 offset += 2;
134 }
135
136 if (rmi_register_desc_has_subpacket(item, 4)) {
137 sensor_flags = buf[offset];
138 offset += 1;
139 }
140
141 sensor->x_mm = (pitch_x * rx_receivers) >> 12;
142 sensor->y_mm = (pitch_y * tx_receivers) >> 12;
143
144 rmi_dbg(RMI_DEBUG_FN, &fn->dev, "%s: x_mm: %d y_mm: %d\n", __func__,
145 sensor->x_mm, sensor->y_mm);
146
147 return 0;
148}
149
150static void rmi_f12_process_objects(struct f12_data *f12, u8 *data1, int size)
151{
152 int i;
153 struct rmi_2d_sensor *sensor = &f12->sensor;
154 int objects = f12->data1->num_subpackets;
155
156 if ((f12->data1->num_subpackets * F12_DATA1_BYTES_PER_OBJ) > size)
157 objects = size / F12_DATA1_BYTES_PER_OBJ;
158
159 for (i = 0; i < objects; i++) {
160 struct rmi_2d_sensor_abs_object *obj = &sensor->objs[i];
161
162 obj->type = RMI_2D_OBJECT_NONE;
163 obj->mt_tool = MT_TOOL_FINGER;
164
165 switch (data1[0]) {
166 case RMI_F12_OBJECT_FINGER:
167 obj->type = RMI_2D_OBJECT_FINGER;
168 break;
169 case RMI_F12_OBJECT_STYLUS:
170 obj->type = RMI_2D_OBJECT_STYLUS;
171 obj->mt_tool = MT_TOOL_PEN;
172 break;
173 case RMI_F12_OBJECT_PALM:
174 obj->type = RMI_2D_OBJECT_PALM;
175 obj->mt_tool = MT_TOOL_PALM;
176 break;
177 case RMI_F12_OBJECT_UNCLASSIFIED:
178 obj->type = RMI_2D_OBJECT_UNCLASSIFIED;
179 break;
180 }
181
182 obj->x = (data1[2] << 8) | data1[1];
183 obj->y = (data1[4] << 8) | data1[3];
184 obj->z = data1[5];
185 obj->wx = data1[6];
186 obj->wy = data1[7];
187
188 rmi_2d_sensor_abs_process(sensor, obj, i);
189
190 data1 += F12_DATA1_BYTES_PER_OBJ;
191 }
192
193 if (sensor->kernel_tracking)
194 input_mt_assign_slots(sensor->input,
195 sensor->tracking_slots,
196 sensor->tracking_pos,
197 sensor->nbr_fingers,
198 sensor->dmax);
199
200 for (i = 0; i < objects; i++)
201 rmi_2d_sensor_abs_report(sensor, &sensor->objs[i], i);
202}
203
204static int rmi_f12_attention(struct rmi_function *fn,
205 unsigned long *irq_nr_regs)
206{
207 int retval;
208 struct rmi_device *rmi_dev = fn->rmi_dev;
209 struct rmi_driver_data *drvdata = dev_get_drvdata(&rmi_dev->dev);
210 struct f12_data *f12 = dev_get_drvdata(&fn->dev);
211 struct rmi_2d_sensor *sensor = &f12->sensor;
212 int valid_bytes = sensor->pkt_size;
213
214 if (drvdata->attn_data.data) {
215 if (sensor->attn_size > drvdata->attn_data.size)
216 valid_bytes = drvdata->attn_data.size;
217 else
218 valid_bytes = sensor->attn_size;
219 memcpy(sensor->data_pkt, drvdata->attn_data.data,
220 valid_bytes);
221 drvdata->attn_data.data += sensor->attn_size;
222 drvdata->attn_data.size -= sensor->attn_size;
223 } else {
224 retval = rmi_read_block(rmi_dev, f12->data_addr,
225 sensor->data_pkt, sensor->pkt_size);
226 if (retval < 0) {
227 dev_err(&fn->dev, "Failed to read object data. Code: %d.\n",
228 retval);
229 return retval;
230 }
231 }
232
233 if (f12->data1)
234 rmi_f12_process_objects(f12,
235 &sensor->data_pkt[f12->data1_offset], valid_bytes);
236
237 input_mt_sync_frame(sensor->input);
238
239 return 0;
240}
241
242static int rmi_f12_write_control_regs(struct rmi_function *fn)
243{
244 int ret;
245 const struct rmi_register_desc_item *item;
246 struct rmi_device *rmi_dev = fn->rmi_dev;
247 struct f12_data *f12 = dev_get_drvdata(&fn->dev);
248 int control_size;
249 char buf[3];
250 u16 control_offset = 0;
251 u8 subpacket_offset = 0;
252
253 if (f12->has_dribble
254 && (f12->sensor.dribble != RMI_REG_STATE_DEFAULT)) {
255 item = rmi_get_register_desc_item(&f12->control_reg_desc, 20);
256 if (item) {
257 control_offset = rmi_register_desc_calc_reg_offset(
258 &f12->control_reg_desc, 20);
259
260
261
262
263
264
265
266 control_size = min(item->reg_size, 3UL);
267
268 ret = rmi_read_block(rmi_dev, fn->fd.control_base_addr
269 + control_offset, buf, control_size);
270 if (ret)
271 return ret;
272
273 if (rmi_register_desc_has_subpacket(item, 0))
274 subpacket_offset += 1;
275
276 switch (f12->sensor.dribble) {
277 case RMI_REG_STATE_OFF:
278 buf[subpacket_offset] &= ~BIT(2);
279 break;
280 case RMI_REG_STATE_ON:
281 buf[subpacket_offset] |= BIT(2);
282 break;
283 case RMI_REG_STATE_DEFAULT:
284 default:
285 break;
286 }
287
288 ret = rmi_write_block(rmi_dev,
289 fn->fd.control_base_addr + control_offset,
290 buf, control_size);
291 if (ret)
292 return ret;
293 }
294 }
295
296 return 0;
297
298}
299
300static int rmi_f12_config(struct rmi_function *fn)
301{
302 struct rmi_driver *drv = fn->rmi_dev->driver;
303 int ret;
304
305 drv->set_irq_bits(fn->rmi_dev, fn->irq_mask);
306
307 ret = rmi_f12_write_control_regs(fn);
308 if (ret)
309 dev_warn(&fn->dev,
310 "Failed to write F12 control registers: %d\n", ret);
311
312 return 0;
313}
314
315static int rmi_f12_probe(struct rmi_function *fn)
316{
317 struct f12_data *f12;
318 int ret;
319 struct rmi_device *rmi_dev = fn->rmi_dev;
320 char buf;
321 u16 query_addr = fn->fd.query_base_addr;
322 const struct rmi_register_desc_item *item;
323 struct rmi_2d_sensor *sensor;
324 struct rmi_device_platform_data *pdata = rmi_get_platform_data(rmi_dev);
325 struct rmi_driver_data *drvdata = dev_get_drvdata(&rmi_dev->dev);
326 u16 data_offset = 0;
327
328 rmi_dbg(RMI_DEBUG_FN, &fn->dev, "%s\n", __func__);
329
330 ret = rmi_read(fn->rmi_dev, query_addr, &buf);
331 if (ret < 0) {
332 dev_err(&fn->dev, "Failed to read general info register: %d\n",
333 ret);
334 return -ENODEV;
335 }
336 ++query_addr;
337
338 if (!(buf & BIT(0))) {
339 dev_err(&fn->dev,
340 "Behavior of F12 without register descriptors is undefined.\n");
341 return -ENODEV;
342 }
343
344 f12 = devm_kzalloc(&fn->dev, sizeof(struct f12_data), GFP_KERNEL);
345 if (!f12)
346 return -ENOMEM;
347
348 f12->has_dribble = !!(buf & BIT(3));
349
350 if (fn->dev.of_node) {
351 ret = rmi_2d_sensor_of_probe(&fn->dev, &f12->sensor_pdata);
352 if (ret)
353 return ret;
354 } else {
355 f12->sensor_pdata = pdata->sensor_pdata;
356 }
357
358 ret = rmi_read_register_desc(rmi_dev, query_addr,
359 &f12->query_reg_desc);
360 if (ret) {
361 dev_err(&fn->dev,
362 "Failed to read the Query Register Descriptor: %d\n",
363 ret);
364 return ret;
365 }
366 query_addr += 3;
367
368 ret = rmi_read_register_desc(rmi_dev, query_addr,
369 &f12->control_reg_desc);
370 if (ret) {
371 dev_err(&fn->dev,
372 "Failed to read the Control Register Descriptor: %d\n",
373 ret);
374 return ret;
375 }
376 query_addr += 3;
377
378 ret = rmi_read_register_desc(rmi_dev, query_addr,
379 &f12->data_reg_desc);
380 if (ret) {
381 dev_err(&fn->dev,
382 "Failed to read the Data Register Descriptor: %d\n",
383 ret);
384 return ret;
385 }
386 query_addr += 3;
387
388 sensor = &f12->sensor;
389 sensor->fn = fn;
390 f12->data_addr = fn->fd.data_base_addr;
391 sensor->pkt_size = rmi_register_desc_calc_size(&f12->data_reg_desc);
392
393 sensor->axis_align =
394 f12->sensor_pdata.axis_align;
395
396 sensor->x_mm = f12->sensor_pdata.x_mm;
397 sensor->y_mm = f12->sensor_pdata.y_mm;
398 sensor->dribble = f12->sensor_pdata.dribble;
399
400 if (sensor->sensor_type == rmi_sensor_default)
401 sensor->sensor_type =
402 f12->sensor_pdata.sensor_type;
403
404 rmi_dbg(RMI_DEBUG_FN, &fn->dev, "%s: data packet size: %d\n", __func__,
405 sensor->pkt_size);
406 sensor->data_pkt = devm_kzalloc(&fn->dev, sensor->pkt_size, GFP_KERNEL);
407 if (!sensor->data_pkt)
408 return -ENOMEM;
409
410 dev_set_drvdata(&fn->dev, f12);
411
412 ret = rmi_f12_read_sensor_tuning(f12);
413 if (ret)
414 return ret;
415
416
417
418
419
420
421
422
423 item = rmi_get_register_desc_item(&f12->data_reg_desc, 0);
424 if (item && !drvdata->attn_data.data)
425 data_offset += item->reg_size;
426
427 item = rmi_get_register_desc_item(&f12->data_reg_desc, 1);
428 if (item) {
429 f12->data1 = item;
430 f12->data1_offset = data_offset;
431 data_offset += item->reg_size;
432 sensor->nbr_fingers = item->num_subpackets;
433 sensor->report_abs = 1;
434 sensor->attn_size += item->reg_size;
435 }
436
437 item = rmi_get_register_desc_item(&f12->data_reg_desc, 2);
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, 3);
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, 4);
446 if (item && !drvdata->attn_data.data)
447 data_offset += item->reg_size;
448
449 item = rmi_get_register_desc_item(&f12->data_reg_desc, 5);
450 if (item) {
451 f12->data5 = item;
452 f12->data5_offset = data_offset;
453 data_offset += item->reg_size;
454 sensor->attn_size += item->reg_size;
455 }
456
457 item = rmi_get_register_desc_item(&f12->data_reg_desc, 6);
458 if (item && !drvdata->attn_data.data) {
459 f12->data6 = item;
460 f12->data6_offset = data_offset;
461 data_offset += item->reg_size;
462 }
463
464 item = rmi_get_register_desc_item(&f12->data_reg_desc, 7);
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, 8);
469 if (item && !drvdata->attn_data.data)
470 data_offset += item->reg_size;
471
472 item = rmi_get_register_desc_item(&f12->data_reg_desc, 9);
473 if (item && !drvdata->attn_data.data) {
474 f12->data9 = item;
475 f12->data9_offset = data_offset;
476 data_offset += item->reg_size;
477 if (!sensor->report_abs)
478 sensor->report_rel = 1;
479 }
480
481 item = rmi_get_register_desc_item(&f12->data_reg_desc, 10);
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, 11);
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, 12);
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, 13);
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, 14);
498 if (item && !drvdata->attn_data.data)
499 data_offset += item->reg_size;
500
501 item = rmi_get_register_desc_item(&f12->data_reg_desc, 15);
502 if (item && !drvdata->attn_data.data) {
503 f12->data15 = item;
504 f12->data15_offset = data_offset;
505 data_offset += item->reg_size;
506 }
507
508
509 sensor->tracking_pos = devm_kzalloc(&fn->dev,
510 sizeof(struct input_mt_pos) * sensor->nbr_fingers,
511 GFP_KERNEL);
512 sensor->tracking_slots = devm_kzalloc(&fn->dev,
513 sizeof(int) * sensor->nbr_fingers, GFP_KERNEL);
514 sensor->objs = devm_kzalloc(&fn->dev,
515 sizeof(struct rmi_2d_sensor_abs_object)
516 * sensor->nbr_fingers, GFP_KERNEL);
517 if (!sensor->tracking_pos || !sensor->tracking_slots || !sensor->objs)
518 return -ENOMEM;
519
520 ret = rmi_2d_sensor_configure_input(fn, sensor);
521 if (ret)
522 return ret;
523
524 return 0;
525}
526
527struct rmi_function_handler rmi_f12_handler = {
528 .driver = {
529 .name = "rmi4_f12",
530 },
531 .func = 0x12,
532 .probe = rmi_f12_probe,
533 .config = rmi_f12_config,
534 .attention = rmi_f12_attention,
535};
536
