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