projects / linux-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tag 'soc-dt-6.4' of git://git.kernel.org/pub/scm/linux/kernel/git/soc/soc
[linux-block.git] / drivers / input / touchscreen / cyttsp5.c
CommitLineData
5b0c03e2
AF		 1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Parade TrueTouch(TM) Standard Product V5 Module.
4 *
5 * Copyright (C) 2015 Parade Technologies
6 * Copyright (C) 2012-2015 Cypress Semiconductor
7 * Copyright (C) 2018 Bootlin
8 *
9 * Authors: Mylène Josserand <mylene.josserand@bootlin.com>
10 * Alistair Francis <alistair@alistair23.me>
11 */
12
13#include <linux/crc-itu-t.h>
14#include <linux/delay.h>
15#include <linux/device.h>
16#include <linux/gpio/consumer.h>
17#include <linux/input/mt.h>
18#include <linux/input/touchscreen.h>
19#include <linux/interrupt.h>
20#include <linux/i2c.h>
21#include <linux/module.h>
22#include <linux/of_device.h>
23#include <linux/regmap.h>
24#include <asm/unaligned.h>
25
26#define CYTTSP5_NAME "cyttsp5"
27#define CY_I2C_DATA_SIZE (2 * 256)
28#define HID_VERSION 0x0100
29#define CY_MAX_INPUT 512
30#define CYTTSP5_PREALLOCATED_CMD_BUFFER 32
31#define CY_BITS_PER_BTN 1
04249314 32#define CY_NUM_BTN_EVENT_ID GENMASK(CY_BITS_PER_BTN - 1, 0)
5b0c03e2
AF		 33
34#define MAX_AREA 255
35#define HID_OUTPUT_BL_SOP 0x1
36#define HID_OUTPUT_BL_EOP 0x17
37#define HID_OUTPUT_BL_LAUNCH_APP 0x3B
38#define HID_OUTPUT_BL_LAUNCH_APP_SIZE 11
39#define HID_OUTPUT_GET_SYSINFO 0x2
40#define HID_OUTPUT_GET_SYSINFO_SIZE 5
41#define HID_OUTPUT_MAX_CMD_SIZE 12
42
43#define HID_DESC_REG 0x1
44#define HID_INPUT_REG 0x3
45#define HID_OUTPUT_REG 0x4
46
47#define REPORT_ID_TOUCH 0x1
48#define REPORT_ID_BTN 0x3
49#define REPORT_SIZE_5 5
50#define REPORT_SIZE_8 8
51#define REPORT_SIZE_16 16
52
53/* Touch reports offsets */
54/* Header offsets */
55#define TOUCH_REPORT_DESC_HDR_CONTACTCOUNT 16
56/* Record offsets */
57#define TOUCH_REPORT_DESC_CONTACTID 8
58#define TOUCH_REPORT_DESC_X 16
59#define TOUCH_REPORT_DESC_Y 32
60#define TOUCH_REPORT_DESC_P 48
61#define TOUCH_REPORT_DESC_MAJ 56
62#define TOUCH_REPORT_DESC_MIN 64
63
64/* HID */
65#define HID_TOUCH_REPORT_ID 0x1
66#define HID_BTN_REPORT_ID 0x3
67#define HID_APP_RESPONSE_REPORT_ID 0x1F
68#define HID_APP_OUTPUT_REPORT_ID 0x2F
69#define HID_BL_RESPONSE_REPORT_ID 0x30
70#define HID_BL_OUTPUT_REPORT_ID 0x40
71
72#define HID_OUTPUT_RESPONSE_REPORT_OFFSET 2
73#define HID_OUTPUT_RESPONSE_CMD_OFFSET 4
74#define HID_OUTPUT_RESPONSE_CMD_MASK GENMASK(6, 0)
75
76#define HID_SYSINFO_SENSING_OFFSET 33
77#define HID_SYSINFO_BTN_OFFSET 48
78#define HID_SYSINFO_BTN_MASK GENMASK(7, 0)
79#define HID_SYSINFO_MAX_BTN 8
80
81#define CY_HID_OUTPUT_TIMEOUT_MS 200
82#define CY_HID_OUTPUT_GET_SYSINFO_TIMEOUT_MS 3000
83#define CY_HID_GET_HID_DESCRIPTOR_TIMEOUT_MS 4000
84
85/* maximum number of concurrent tracks */
86#define TOUCH_REPORT_SIZE 10
87#define TOUCH_INPUT_HEADER_SIZE 7
88#define BTN_REPORT_SIZE 9
89#define BTN_INPUT_HEADER_SIZE 5
90
91#define MAX_CY_TCH_T_IDS 32
92
93/* All usage pages for Touch Report */
94#define TOUCH_REPORT_USAGE_PG_X 0x00010030
95#define TOUCH_REPORT_USAGE_PG_Y 0x00010031
96#define TOUCH_REPORT_USAGE_PG_P 0x000D0030
97#define TOUCH_REPORT_USAGE_PG_CONTACTID 0x000D0051
98#define TOUCH_REPORT_USAGE_PG_CONTACTCOUNT 0x000D0054
99#define TOUCH_REPORT_USAGE_PG_MAJ 0xFF010062
100#define TOUCH_REPORT_USAGE_PG_MIN 0xFF010063
101#define TOUCH_COL_USAGE_PG 0x000D0022
102
103/* System Information interface definitions */
104struct cyttsp5_sensing_conf_data_dev {
105 u8 electrodes_x;
106 u8 electrodes_y;
107 __le16 len_x;
108 __le16 len_y;
109 __le16 res_x;
110 __le16 res_y;
111 __le16 max_z;
112 u8 origin_x;
113 u8 origin_y;
5dc63e56 114 u8 panel_id;
5b0c03e2
AF		 115 u8 btn;
116 u8 scan_mode;
117 u8 max_num_of_tch_per_refresh_cycle;
118} __packed;
119
120struct cyttsp5_sensing_conf_data {
121 u16 res_x;
122 u16 res_y;
123 u16 max_z;
124 u16 len_x;
125 u16 len_y;
126 u8 origin_x;
127 u8 origin_y;
128 u8 max_tch;
129};
130
131enum cyttsp5_tch_abs { /* for ordering within the extracted touch data array */
132 CY_TCH_X, /* X */
133 CY_TCH_Y, /* Y */
134 CY_TCH_P, /* P (Z) */
135 CY_TCH_T, /* TOUCH ID */
136 CY_TCH_MAJ, /* TOUCH_MAJOR */
137 CY_TCH_MIN, /* TOUCH_MINOR */
138 CY_TCH_NUM_ABS
139};
140
141struct cyttsp5_tch_abs_params {
142 size_t ofs; /* abs byte offset */
143 size_t size; /* size in bits */
144 size_t min; /* min value */
145 size_t max; /* max value */
146 size_t bofs; /* bit offset */
147};
148
149struct cyttsp5_touch {
150 int abs[CY_TCH_NUM_ABS];
151};
152
153struct cyttsp5_sysinfo {
154 struct cyttsp5_sensing_conf_data sensing_conf_data;
155 int num_btns;
156 struct cyttsp5_tch_abs_params tch_hdr;
157 struct cyttsp5_tch_abs_params tch_abs[CY_TCH_NUM_ABS];
158 u32 key_code[HID_SYSINFO_MAX_BTN];
159};
160
161struct cyttsp5_hid_desc {
162 __le16 hid_desc_len;
163 u8 packet_id;
164 u8 reserved_byte;
165 __le16 bcd_version;
166 __le16 report_desc_len;
167 __le16 report_desc_register;
168 __le16 input_register;
169 __le16 max_input_len;
170 __le16 output_register;
171 __le16 max_output_len;
172 __le16 command_register;
173 __le16 data_register;
174 __le16 vendor_id;
175 __le16 product_id;
176 __le16 version_id;
177 u8 reserved[4];
178} __packed;
179
180struct cyttsp5 {
181 struct device *dev;
182 struct completion cmd_done;
183 struct cyttsp5_sysinfo sysinfo;
184 struct cyttsp5_hid_desc hid_desc;
185 u8 cmd_buf[CYTTSP5_PREALLOCATED_CMD_BUFFER];
186 u8 input_buf[CY_MAX_INPUT];
187 u8 response_buf[CY_MAX_INPUT];
188 struct gpio_desc *reset_gpio;
189 struct input_dev *input;
190 char phys[NAME_MAX];
191 int num_prv_rec;
192 struct regmap *regmap;
193 struct touchscreen_properties prop;
194 struct regulator *vdd;
195};
196
197/*
198 * For what is understood in the datasheet, the register does not
199 * matter. For consistency, use the Input Register address
200 * but it does mean anything to the device. The important data
201 * to send is the I2C address
202 */
203static int cyttsp5_read(struct cyttsp5 *ts, u8 *buf, u32 max)
204{
205 int error;
206 u32 size;
207 u8 temp[2];
208
209 /* Read the frame to retrieve the size */
210 error = regmap_bulk_read(ts->regmap, HID_INPUT_REG, temp, sizeof(temp));
211 if (error)
212 return error;
213
214 size = get_unaligned_le16(temp);
215 if (!size || size == 2)
216 return 0;
217
218 if (size > max)
219 return -EINVAL;
220
221 /* Get the real value */
222 return regmap_bulk_read(ts->regmap, HID_INPUT_REG, buf, size);
223}
224
225static int cyttsp5_write(struct cyttsp5 *ts, unsigned int reg, u8 *data,
226 size_t size)
227{
228 u8 cmd[HID_OUTPUT_MAX_CMD_SIZE];
229
230 if (size + 1 > HID_OUTPUT_MAX_CMD_SIZE)
231 return -E2BIG;
232
233 /* High bytes of register address needed as first byte of cmd */
234 cmd[0] = (reg >> 8) & 0xFF;
235
236 /* Copy the rest of the data */
237 if (data)
238 memcpy(&cmd[1], data, size);
239
240 /*
241 * The hardware wants to receive a frame with the address register
242 * contained in the first two bytes. As the regmap_write function
243 * add the register adresse in the frame, we use the low byte as
244 * first frame byte for the address register and the first
245 * data byte is the high register + left of the cmd to send
246 */
247 return regmap_bulk_write(ts->regmap, reg & 0xFF, cmd, size + 1);
248}
249
250static void cyttsp5_get_touch_axis(int *axis, int size, int max, u8 *xy_data,
251 int bofs)
252{
253 int nbyte;
254
255 for (nbyte = 0, *axis = 0; nbyte < size; nbyte++)
256 *axis += ((xy_data[nbyte] >> bofs) << (nbyte * 8));
257
258 *axis &= max - 1;
259}
260
261static void cyttsp5_get_touch_record(struct cyttsp5 *ts,
262 struct cyttsp5_touch *touch, u8 *xy_data)
263{
264 struct cyttsp5_sysinfo *si = &ts->sysinfo;
265 enum cyttsp5_tch_abs abs;
266
267 for (abs = CY_TCH_X; abs < CY_TCH_NUM_ABS; abs++)
268 cyttsp5_get_touch_axis(&touch->abs[abs],
269 si->tch_abs[abs].size,
270 si->tch_abs[abs].max,
271 xy_data + si->tch_abs[abs].ofs,
272 si->tch_abs[abs].bofs);
273}
274
275static void cyttsp5_get_mt_touches(struct cyttsp5 *ts,
276 struct cyttsp5_touch *tch, int num_cur_tch)
277{
278 struct cyttsp5_sysinfo *si = &ts->sysinfo;
279 int i, t = 0, offset = 0;
280 DECLARE_BITMAP(ids, MAX_CY_TCH_T_IDS);
281 u8 *tch_addr;
282 int tmp;
283
284 bitmap_zero(ids, MAX_CY_TCH_T_IDS);
285 memset(tch->abs, 0, sizeof(tch->abs));
286
287 switch (ts->input_buf[2]) {
288 case HID_TOUCH_REPORT_ID:
289 offset = TOUCH_INPUT_HEADER_SIZE;
290 break;
291 case HID_BTN_REPORT_ID:
292 offset = BTN_INPUT_HEADER_SIZE;
293 break;
294 }
295
296 for (i = 0; i < num_cur_tch; i++) {
297 tch_addr = ts->input_buf + offset + (i * TOUCH_REPORT_SIZE);
298 cyttsp5_get_touch_record(ts, tch, tch_addr);
299
300 /* Convert MAJOR/MINOR from mm to resolution */
301 tmp = tch->abs[CY_TCH_MAJ] * 100 * si->sensing_conf_data.res_x;
302 tch->abs[CY_TCH_MAJ] = tmp / si->sensing_conf_data.len_x;
303 tmp = tch->abs[CY_TCH_MIN] * 100 * si->sensing_conf_data.res_x;
304 tch->abs[CY_TCH_MIN] = tmp / si->sensing_conf_data.len_x;
305
306 t = tch->abs[CY_TCH_T];
307 input_mt_slot(ts->input, t);
308 input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, true);
309 __set_bit(t, ids);
310
311 /* position and pressure fields */
312 touchscreen_report_pos(ts->input, &ts->prop,
313 tch->abs[CY_TCH_X], tch->abs[CY_TCH_Y],
314 true);
315 input_report_abs(ts->input, ABS_MT_PRESSURE,
316 tch->abs[CY_TCH_P]);
317
318 /* Get the extended touch fields */
319 input_report_abs(ts->input, ABS_MT_TOUCH_MAJOR,
320 tch->abs[CY_TCH_MAJ]);
321 input_report_abs(ts->input, ABS_MT_TOUCH_MINOR,
322 tch->abs[CY_TCH_MIN]);
323 }
324
325 ts->num_prv_rec = num_cur_tch;
326}
327
328static int cyttsp5_mt_attention(struct device *dev)
329{
330 struct cyttsp5 *ts = dev_get_drvdata(dev);
331 struct cyttsp5_sysinfo *si = &ts->sysinfo;
332 int max_tch = si->sensing_conf_data.max_tch;
333 struct cyttsp5_touch tch;
334 int num_cur_tch;
335
336 cyttsp5_get_touch_axis(&num_cur_tch, si->tch_hdr.size,
337 si->tch_hdr.max,
338 ts->input_buf + 3 + si->tch_hdr.ofs,
339 si->tch_hdr.bofs);
340
341 if (num_cur_tch > max_tch) {
342 dev_err(dev, "Num touch err detected (n=%d)\n", num_cur_tch);
343 num_cur_tch = max_tch;
344 }
345
346 if (num_cur_tch == 0 && ts->num_prv_rec == 0)
347 return 0;
348
349 /* extract xy_data for all currently reported touches */
350 if (num_cur_tch)
351 cyttsp5_get_mt_touches(ts, &tch, num_cur_tch);
352
353 input_mt_sync_frame(ts->input);
354 input_sync(ts->input);
355
356 return 0;
357}
358
359static int cyttsp5_setup_input_device(struct device *dev)
360{
361 struct cyttsp5 *ts = dev_get_drvdata(dev);
362 struct cyttsp5_sysinfo *si = &ts->sysinfo;
363 int max_x, max_y, max_p;
364 int max_x_tmp, max_y_tmp;
365 int error;
366
367 max_x_tmp = si->sensing_conf_data.res_x;
368 max_y_tmp = si->sensing_conf_data.res_y;
369 max_x = max_x_tmp - 1;
370 max_y = max_y_tmp - 1;
371 max_p = si->sensing_conf_data.max_z;
372
373 input_set_abs_params(ts->input, ABS_MT_POSITION_X, 0, max_x, 0, 0);
374 input_set_abs_params(ts->input, ABS_MT_POSITION_Y, 0, max_y, 0, 0);
375 input_set_abs_params(ts->input, ABS_MT_PRESSURE, 0, max_p, 0, 0);
376
377 input_set_abs_params(ts->input, ABS_MT_TOUCH_MAJOR, 0, MAX_AREA, 0, 0);
378 input_set_abs_params(ts->input, ABS_MT_TOUCH_MINOR, 0, MAX_AREA, 0, 0);
379
380 error = input_mt_init_slots(ts->input, si->tch_abs[CY_TCH_T].max,
381 INPUT_MT_DROP_UNUSED | INPUT_MT_DIRECT);
382 if (error)
383 return error;
384
385 error = input_register_device(ts->input);
386 if (error) {
387 dev_err(dev, "failed to register input device: %d\n", error);
388 return error;
389 }
390
391 return error;
392}
393
394static int cyttsp5_parse_dt_key_code(struct device *dev)
395{
396 struct cyttsp5 *ts = dev_get_drvdata(dev);
397 struct cyttsp5_sysinfo *si = &ts->sysinfo;
398
399 if (!si->num_btns)
400 return 0;
401
402 /* Initialize the button to RESERVED */
403 memset32(si->key_code, KEY_RESERVED, si->num_btns);
404
405 return device_property_read_u32_array(dev, "linux,keycodes",
406 si->key_code, si->num_btns);
407}
408
409static int cyttsp5_btn_attention(struct device *dev)
410{
411 struct cyttsp5 *ts = dev_get_drvdata(dev);
412 struct cyttsp5_sysinfo *si = &ts->sysinfo;
413 int cur_btn, offset = 0;
414 int cur_btn_state;
415
416 switch (ts->input_buf[2]) {
417 case HID_TOUCH_REPORT_ID:
418 offset = TOUCH_INPUT_HEADER_SIZE;
419 break;
420 case HID_BTN_REPORT_ID:
421 offset = BTN_INPUT_HEADER_SIZE;
422 break;
423 }
424
425 if (ts->input_buf[2] != HID_BTN_REPORT_ID)
426 return 0;
427
428 /* extract button press/release touch information */
429 for (cur_btn = 0; cur_btn < si->num_btns; cur_btn++) {
430 /* Get current button state */
431 cur_btn_state = (ts->input_buf[offset] >> (cur_btn * CY_BITS_PER_BTN))
432 & CY_NUM_BTN_EVENT_ID;
433
434 input_report_key(ts->input, si->key_code[cur_btn],
435 cur_btn_state);
436 input_sync(ts->input);
437 }
438
439 return 0;
440}
441
442static int cyttsp5_validate_cmd_response(struct cyttsp5 *ts, u8 code)
443{
444 u16 size, crc;
445 u8 status, report_id;
446 int command_code;
447
448 size = get_unaligned_le16(&ts->response_buf[0]);
449 if (!size)
450 return 0;
451
452 report_id = ts->response_buf[HID_OUTPUT_RESPONSE_REPORT_OFFSET];
453
454 switch (report_id) {
455 case HID_BL_RESPONSE_REPORT_ID:
456 if (ts->response_buf[4] != HID_OUTPUT_BL_SOP) {
457 dev_err(ts->dev, "HID output response, wrong SOP\n");
458 return -EPROTO;
459 }
460
461 if (ts->response_buf[size - 1] != HID_OUTPUT_BL_EOP) {
462 dev_err(ts->dev, "HID output response, wrong EOP\n");
463 return -EPROTO;
464 }
465
466 crc = crc_itu_t(0xFFFF, &ts->response_buf[4], size - 7);
467 if (get_unaligned_le16(&ts->response_buf[size - 3]) != crc) {
468 dev_err(ts->dev,
469 "HID output response, wrong CRC 0x%X\n",
470 crc);
471 return -EPROTO;
472 }
473
474 status = ts->response_buf[5];
475 if (status) {
476 dev_err(ts->dev, "HID output response, ERROR:%d\n",
477 status);
478 return -EPROTO;
479 }
480 break;
481
482 case HID_APP_RESPONSE_REPORT_ID:
483 command_code = ts->response_buf[HID_OUTPUT_RESPONSE_CMD_OFFSET]
484 & HID_OUTPUT_RESPONSE_CMD_MASK;
485 if (command_code != code) {
486 dev_err(ts->dev,
487 "HID output response, wrong command_code:%X\n",
488 command_code);
489 return -EPROTO;
490 }
491 break;
492 }
493
494 return 0;
495}
496
497static void cyttsp5_si_get_btn_data(struct cyttsp5 *ts)
498{
499 struct cyttsp5_sysinfo *si = &ts->sysinfo;
500 unsigned int btns = ts->response_buf[HID_SYSINFO_BTN_OFFSET] &
501 HID_SYSINFO_BTN_MASK;
502
503 si->num_btns = hweight8(btns);
504}
505
506static int cyttsp5_get_sysinfo_regs(struct cyttsp5 *ts)
507{
508 struct cyttsp5_sensing_conf_data *scd = &ts->sysinfo.sensing_conf_data;
509 struct cyttsp5_sensing_conf_data_dev *scd_dev =
510 (struct cyttsp5_sensing_conf_data_dev *)
511 &ts->response_buf[HID_SYSINFO_SENSING_OFFSET];
512
513 cyttsp5_si_get_btn_data(ts);
514
515 scd->max_tch = scd_dev->max_num_of_tch_per_refresh_cycle;
516 scd->res_x = get_unaligned_le16(&scd_dev->res_x);
517 scd->res_y = get_unaligned_le16(&scd_dev->res_y);
518 scd->max_z = get_unaligned_le16(&scd_dev->max_z);
519 scd->len_x = get_unaligned_le16(&scd_dev->len_x);
520 scd->len_y = get_unaligned_le16(&scd_dev->len_y);
521
522 return 0;
523}
524
525static int cyttsp5_hid_output_get_sysinfo(struct cyttsp5 *ts)
526{
527 int rc;
528 u8 cmd[HID_OUTPUT_GET_SYSINFO_SIZE];
529
530 /* HI bytes of Output register address */
531 put_unaligned_le16(HID_OUTPUT_GET_SYSINFO_SIZE, cmd);
532 cmd[2] = HID_APP_OUTPUT_REPORT_ID;
533 cmd[3] = 0x0; /* Reserved */
534 cmd[4] = HID_OUTPUT_GET_SYSINFO;
535
536 rc = cyttsp5_write(ts, HID_OUTPUT_REG, cmd,
537 HID_OUTPUT_GET_SYSINFO_SIZE);
538 if (rc) {
539 dev_err(ts->dev, "Failed to write command %d", rc);
540 return rc;
541 }
542
543 rc = wait_for_completion_interruptible_timeout(&ts->cmd_done,
544 msecs_to_jiffies(CY_HID_OUTPUT_GET_SYSINFO_TIMEOUT_MS));
545 if (rc <= 0) {
546 dev_err(ts->dev, "HID output cmd execution timed out\n");
547 rc = -ETIMEDOUT;
548 return rc;
549 }
550
551 rc = cyttsp5_validate_cmd_response(ts, HID_OUTPUT_GET_SYSINFO);
552 if (rc) {
553 dev_err(ts->dev, "Validation of the response failed\n");
554 return rc;
555 }
556
557 return cyttsp5_get_sysinfo_regs(ts);
558}
559
560static int cyttsp5_hid_output_bl_launch_app(struct cyttsp5 *ts)
561{
562 int rc;
563 u8 cmd[HID_OUTPUT_BL_LAUNCH_APP];
564 u16 crc;
565
566 put_unaligned_le16(HID_OUTPUT_BL_LAUNCH_APP_SIZE, cmd);
567 cmd[2] = HID_BL_OUTPUT_REPORT_ID;
568 cmd[3] = 0x0; /* Reserved */
569 cmd[4] = HID_OUTPUT_BL_SOP;
570 cmd[5] = HID_OUTPUT_BL_LAUNCH_APP;
571 put_unaligned_le16(0x00, &cmd[6]);
572 crc = crc_itu_t(0xFFFF, &cmd[4], 4);
573 put_unaligned_le16(crc, &cmd[8]);
574 cmd[10] = HID_OUTPUT_BL_EOP;
575
576 rc = cyttsp5_write(ts, HID_OUTPUT_REG, cmd,
577 HID_OUTPUT_BL_LAUNCH_APP_SIZE);
578 if (rc) {
579 dev_err(ts->dev, "Failed to write command %d", rc);
580 return rc;
581 }
582
583 rc = wait_for_completion_interruptible_timeout(&ts->cmd_done,
584 msecs_to_jiffies(CY_HID_OUTPUT_TIMEOUT_MS));
585 if (rc <= 0) {
586 dev_err(ts->dev, "HID output cmd execution timed out\n");
587 rc = -ETIMEDOUT;
588 return rc;
589 }
590
591 rc = cyttsp5_validate_cmd_response(ts, HID_OUTPUT_BL_LAUNCH_APP);
592 if (rc) {
593 dev_err(ts->dev, "Validation of the response failed\n");
594 return rc;
595 }
596
597 return 0;
598}
599
600static int cyttsp5_get_hid_descriptor(struct cyttsp5 *ts,
601 struct cyttsp5_hid_desc *desc)
602{
603 struct device *dev = ts->dev;
604 __le16 hid_desc_register = cpu_to_le16(HID_DESC_REG);
605 int rc;
606 u8 cmd[2];
607
608 /* Set HID descriptor register */
609 memcpy(cmd, &hid_desc_register, sizeof(hid_desc_register));
610
611 rc = cyttsp5_write(ts, HID_DESC_REG, NULL, 0);
612 if (rc) {
613 dev_err(dev, "Failed to get HID descriptor, rc=%d\n", rc);
614 return rc;
615 }
616
617 rc = wait_for_completion_interruptible_timeout(&ts->cmd_done,
618 msecs_to_jiffies(CY_HID_GET_HID_DESCRIPTOR_TIMEOUT_MS));
619 if (rc <= 0) {
620 dev_err(ts->dev, "HID get descriptor timed out\n");
621 rc = -ETIMEDOUT;
622 return rc;
623 }
624
625 memcpy(desc, ts->response_buf, sizeof(*desc));
626
627 /* Check HID descriptor length and version */
628 if (le16_to_cpu(desc->hid_desc_len) != sizeof(*desc) ||
629 le16_to_cpu(desc->bcd_version) != HID_VERSION) {
630 dev_err(dev, "Unsupported HID version\n");
631 return -ENODEV;
632 }
633
634 return 0;
635}
636
637static int fill_tch_abs(struct cyttsp5_tch_abs_params *tch_abs, int report_size,
638 int offset)
639{
640 tch_abs->ofs = offset / 8;
641 tch_abs->size = report_size / 8;
642 if (report_size % 8)
643 tch_abs->size += 1;
644 tch_abs->min = 0;
645 tch_abs->max = 1 << report_size;
646 tch_abs->bofs = offset - (tch_abs->ofs << 3);
647
648 return 0;
649}
650
651static irqreturn_t cyttsp5_handle_irq(int irq, void *handle)
652{
653 struct cyttsp5 *ts = handle;
654 int report_id;
655 int size;
656 int error;
657
658 error = cyttsp5_read(ts, ts->input_buf, CY_MAX_INPUT);
659 if (error)
660 return IRQ_HANDLED;
661
662 size = get_unaligned_le16(&ts->input_buf[0]);
663 if (size == 0) {
664 /* reset */
665 report_id = 0;
666 size = 2;
667 } else {
668 report_id = ts->input_buf[2];
669 }
670
671 switch (report_id) {
672 case HID_TOUCH_REPORT_ID:
673 cyttsp5_mt_attention(ts->dev);
674 break;
675 case HID_BTN_REPORT_ID:
676 cyttsp5_btn_attention(ts->dev);
677 break;
678 default:
679 /* It is not an input but a command response */
680 memcpy(ts->response_buf, ts->input_buf, size);
681 complete(&ts->cmd_done);
682 }
683
684 return IRQ_HANDLED;
685}
686
687static int cyttsp5_deassert_int(struct cyttsp5 *ts)
688{
689 u16 size;
690 u8 buf[2];
691 int error;
692
693 error = regmap_bulk_read(ts->regmap, HID_INPUT_REG, buf, sizeof(buf));
694 if (error < 0)
695 return error;
696
697 size = get_unaligned_le16(&buf[0]);
698 if (size == 2 || size == 0)
699 return 0;
700
701 return -EINVAL;
702}
703
704static int cyttsp5_fill_all_touch(struct cyttsp5 *ts)
705{
706 struct cyttsp5_sysinfo *si = &ts->sysinfo;
707
708 fill_tch_abs(&si->tch_abs[CY_TCH_X], REPORT_SIZE_16,
709 TOUCH_REPORT_DESC_X);
710 fill_tch_abs(&si->tch_abs[CY_TCH_Y], REPORT_SIZE_16,
711 TOUCH_REPORT_DESC_Y);
712 fill_tch_abs(&si->tch_abs[CY_TCH_P], REPORT_SIZE_8,
713 TOUCH_REPORT_DESC_P);
714 fill_tch_abs(&si->tch_abs[CY_TCH_T], REPORT_SIZE_5,
715 TOUCH_REPORT_DESC_CONTACTID);
716 fill_tch_abs(&si->tch_hdr, REPORT_SIZE_5,
717 TOUCH_REPORT_DESC_HDR_CONTACTCOUNT);
718 fill_tch_abs(&si->tch_abs[CY_TCH_MAJ], REPORT_SIZE_8,
719 TOUCH_REPORT_DESC_MAJ);
720 fill_tch_abs(&si->tch_abs[CY_TCH_MIN], REPORT_SIZE_8,
721 TOUCH_REPORT_DESC_MIN);
722
723 return 0;
724}
725
726static int cyttsp5_startup(struct cyttsp5 *ts)
727{
728 int error;
729
730 error = cyttsp5_deassert_int(ts);
731 if (error) {
732 dev_err(ts->dev, "Error on deassert int r=%d\n", error);
733 return -ENODEV;
734 }
735
736 /*
737 * Launch the application as the device starts in bootloader mode
738 * because of a power-on-reset
739 */
740 error = cyttsp5_hid_output_bl_launch_app(ts);
741 if (error < 0) {
742 dev_err(ts->dev, "Error on launch app r=%d\n", error);
743 return error;
744 }
745
746 error = cyttsp5_get_hid_descriptor(ts, &ts->hid_desc);
747 if (error < 0) {
748 dev_err(ts->dev, "Error on getting HID descriptor r=%d\n", error);
749 return error;
750 }
751
752 error = cyttsp5_fill_all_touch(ts);
753 if (error < 0) {
754 dev_err(ts->dev, "Error on report descriptor r=%d\n", error);
755 return error;
756 }
757
758 error = cyttsp5_hid_output_get_sysinfo(ts);
759 if (error) {
760 dev_err(ts->dev, "Error on getting sysinfo r=%d\n", error);
761 return error;
762 }
763
764 return error;
765}
766
767static void cyttsp5_cleanup(void *data)
768{
769 struct cyttsp5 *ts = data;
770
771 regulator_disable(ts->vdd);
772}
773
774static int cyttsp5_probe(struct device *dev, struct regmap *regmap, int irq,
775 const char *name)
776{
777 struct cyttsp5 *ts;
778 struct cyttsp5_sysinfo *si;
779 int error, i;
780
781 ts = devm_kzalloc(dev, sizeof(*ts), GFP_KERNEL);
782 if (!ts)
783 return -ENOMEM;
784
785 /* Initialize device info */
786 ts->regmap = regmap;
787 ts->dev = dev;
788 si = &ts->sysinfo;
789 dev_set_drvdata(dev, ts);
790
791 init_completion(&ts->cmd_done);
792
793 /* Power up the device */
794 ts->vdd = devm_regulator_get(dev, "vdd");
795 if (IS_ERR(ts->vdd)) {
796 error = PTR_ERR(ts->vdd);
797 return error;
798 }
799
800 error = devm_add_action_or_reset(dev, cyttsp5_cleanup, ts);
801 if (error)
802 return error;
803
804 error = regulator_enable(ts->vdd);
805 if (error)
806 return error;
807
808 ts->input = devm_input_allocate_device(dev);
809 if (!ts->input) {
810 dev_err(dev, "Error, failed to allocate input device\n");
811 return -ENODEV;
812 }
813
814 ts->input->name = "cyttsp5";
815 scnprintf(ts->phys, sizeof(ts->phys), "%s/input0", dev_name(dev));
816 ts->input->phys = ts->phys;
817 input_set_drvdata(ts->input, ts);
818
819 /* Reset the gpio to be in a reset state */
820 ts->reset_gpio = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_HIGH);
821 if (IS_ERR(ts->reset_gpio)) {
822 error = PTR_ERR(ts->reset_gpio);
823 dev_err(dev, "Failed to request reset gpio, error %d\n", error);
824 return error;
825 }
826 gpiod_set_value_cansleep(ts->reset_gpio, 0);
827
828 /* Need a delay to have device up */
829 msleep(20);
830
831 error = devm_request_threaded_irq(dev, irq, NULL, cyttsp5_handle_irq,
832 IRQF_ONESHOT, name, ts);
833 if (error) {
834 dev_err(dev, "unable to request IRQ\n");
835 return error;
836 }
837
838 error = cyttsp5_startup(ts);
839 if (error) {
840 dev_err(ts->dev, "Fail initial startup r=%d\n", error);
841 return error;
842 }
843
844 error = cyttsp5_parse_dt_key_code(dev);
845 if (error < 0) {
846 dev_err(ts->dev, "Error while parsing dts %d\n", error);
847 return error;
848 }
849
850 touchscreen_parse_properties(ts->input, true, &ts->prop);
851
852 __set_bit(EV_KEY, ts->input->evbit);
853 for (i = 0; i < si->num_btns; i++)
854 __set_bit(si->key_code[i], ts->input->keybit);
855
856 return cyttsp5_setup_input_device(dev);
857}
858
eebf2bf1 859static int cyttsp5_i2c_probe(struct i2c_client *client)
5b0c03e2
AF		 860{
861 struct regmap *regmap;
862 static const struct regmap_config config = {
863 .reg_bits = 8,
864 .val_bits = 8,
865 };
866
867 regmap = devm_regmap_init_i2c(client, &config);
868 if (IS_ERR(regmap)) {
869 dev_err(&client->dev, "regmap allocation failed: %ld\n",
870 PTR_ERR(regmap));
871 return PTR_ERR(regmap);
872 }
873
874 return cyttsp5_probe(&client->dev, regmap, client->irq, client->name);
875}
876
877static const struct of_device_id cyttsp5_of_match[] = {
878 { .compatible = "cypress,tt21000", },
879 { }
880};
881MODULE_DEVICE_TABLE(of, cyttsp5_of_match);
882
883static const struct i2c_device_id cyttsp5_i2c_id[] = {
884 { CYTTSP5_NAME, 0, },
885 { }
886};
887MODULE_DEVICE_TABLE(i2c, cyttsp5_i2c_id);
888
889static struct i2c_driver cyttsp5_i2c_driver = {
890 .driver = {
891 .name = CYTTSP5_NAME,
892 .of_match_table = cyttsp5_of_match,
893 },
eebf2bf1 894 .probe_new = cyttsp5_i2c_probe,
5b0c03e2
AF		 895 .id_table = cyttsp5_i2c_id,
896};
897module_i2c_driver(cyttsp5_i2c_driver);
898
899MODULE_LICENSE("GPL");
900MODULE_DESCRIPTION("Touchscreen driver for Cypress TrueTouch Gen 5 Product");
901MODULE_AUTHOR("Mylène Josserand <mylene.josserand@bootlin.com>");
Linux 6.x block layer and io_uring tree(s)