1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * cyttsp4_core.c
4  * Cypress TrueTouch(TM) Standard Product V4 Core driver module.
5  * For use with Cypress Txx4xx parts.
6  * Supported parts include:
7  * TMA4XX
8  * TMA1036
9  *
10  * Copyright (C) 2012 Cypress Semiconductor
11  *
12  * Contact Cypress Semiconductor at www.cypress.com <ttdrivers@cypress.com>
13  */
14 
15 #include "cyttsp4_core.h"
16 #include <linux/delay.h>
17 #include <linux/gpio.h>
18 #include <linux/input/mt.h>
19 #include <linux/interrupt.h>
20 #include <linux/pm_runtime.h>
21 #include <linux/sched.h>
22 #include <linux/slab.h>
23 
24 /* Timeout in ms. */
25 #define CY_CORE_REQUEST_EXCLUSIVE_TIMEOUT	500
26 #define CY_CORE_SLEEP_REQUEST_EXCLUSIVE_TIMEOUT	5000
27 #define CY_CORE_MODE_CHANGE_TIMEOUT		1000
28 #define CY_CORE_RESET_AND_WAIT_TIMEOUT		500
29 #define CY_CORE_WAKEUP_TIMEOUT			500
30 
31 #define CY_CORE_STARTUP_RETRY_COUNT		3
32 
33 static const char * const cyttsp4_tch_abs_string[] = {
34 	[CY_TCH_X]	= "X",
35 	[CY_TCH_Y]	= "Y",
36 	[CY_TCH_P]	= "P",
37 	[CY_TCH_T]	= "T",
38 	[CY_TCH_E]	= "E",
39 	[CY_TCH_O]	= "O",
40 	[CY_TCH_W]	= "W",
41 	[CY_TCH_MAJ]	= "MAJ",
42 	[CY_TCH_MIN]	= "MIN",
43 	[CY_TCH_OR]	= "OR",
44 	[CY_TCH_NUM_ABS] = "INVALID"
45 };
46 
47 static const u8 ldr_exit[] = {
48 	0xFF, 0x01, 0x3B, 0x00, 0x00, 0x4F, 0x6D, 0x17
49 };
50 
51 static const u8 ldr_err_app[] = {
52 	0x01, 0x02, 0x00, 0x00, 0x55, 0xDD, 0x17
53 };
54 
55 static inline size_t merge_bytes(u8 high, u8 low)
56 {
57 	return (high << 8) + low;
58 }
59 
60 #ifdef VERBOSE_DEBUG
61 static void cyttsp4_pr_buf(struct device *dev, u8 *pr_buf, u8 *dptr, int size,
62 		const char *data_name)
63 {
64 	int i, k;
65 	const char fmt[] = "%02X ";
66 	int max;
67 
68 	if (!size)
69 		return;
70 
71 	max = (CY_MAX_PRBUF_SIZE - 1) - sizeof(CY_PR_TRUNCATED);
72 
73 	pr_buf[0] = 0;
74 	for (i = k = 0; i < size && k < max; i++, k += 3)
75 		scnprintf(pr_buf + k, CY_MAX_PRBUF_SIZE, fmt, dptr[i]);
76 
77 	dev_vdbg(dev, "%s:  %s[0..%d]=%s%s\n", __func__, data_name, size - 1,
78 			pr_buf, size <= max ? "" : CY_PR_TRUNCATED);
79 }
80 #else
81 #define cyttsp4_pr_buf(dev, pr_buf, dptr, size, data_name) do { } while (0)
82 #endif
83 
84 static int cyttsp4_load_status_regs(struct cyttsp4 *cd)
85 {
86 	struct cyttsp4_sysinfo *si = &cd->sysinfo;
87 	struct device *dev = cd->dev;
88 	int rc;
89 
90 	rc = cyttsp4_adap_read(cd, CY_REG_BASE, si->si_ofs.mode_size,
91 			si->xy_mode);
92 	if (rc < 0)
93 		dev_err(dev, "%s: fail read mode regs r=%d\n",
94 			__func__, rc);
95 	else
96 		cyttsp4_pr_buf(dev, cd->pr_buf, si->xy_mode,
97 			si->si_ofs.mode_size, "xy_mode");
98 
99 	return rc;
100 }
101 
102 static int cyttsp4_handshake(struct cyttsp4 *cd, u8 mode)
103 {
104 	u8 cmd = mode ^ CY_HST_TOGGLE;
105 	int rc;
106 
107 	/*
108 	 * Mode change issued, handshaking now will cause endless mode change
109 	 * requests, for sync mode modechange will do same with handshake
110 	 * */
111 	if (mode & CY_HST_MODE_CHANGE)
112 		return 0;
113 
114 	rc = cyttsp4_adap_write(cd, CY_REG_BASE, sizeof(cmd), &cmd);
115 	if (rc < 0)
116 		dev_err(cd->dev, "%s: bus write fail on handshake (ret=%d)\n",
117 				__func__, rc);
118 
119 	return rc;
120 }
121 
122 static int cyttsp4_hw_soft_reset(struct cyttsp4 *cd)
123 {
124 	u8 cmd = CY_HST_RESET;
125 	int rc = cyttsp4_adap_write(cd, CY_REG_BASE, sizeof(cmd), &cmd);
126 	if (rc < 0) {
127 		dev_err(cd->dev, "%s: FAILED to execute SOFT reset\n",
128 				__func__);
129 		return rc;
130 	}
131 	return 0;
132 }
133 
134 static int cyttsp4_hw_hard_reset(struct cyttsp4 *cd)
135 {
136 	if (cd->cpdata->xres) {
137 		cd->cpdata->xres(cd->cpdata, cd->dev);
138 		dev_dbg(cd->dev, "%s: execute HARD reset\n", __func__);
139 		return 0;
140 	}
141 	dev_err(cd->dev, "%s: FAILED to execute HARD reset\n", __func__);
142 	return -ENOSYS;
143 }
144 
145 static int cyttsp4_hw_reset(struct cyttsp4 *cd)
146 {
147 	int rc = cyttsp4_hw_hard_reset(cd);
148 	if (rc == -ENOSYS)
149 		rc = cyttsp4_hw_soft_reset(cd);
150 	return rc;
151 }
152 
153 /*
154  * Gets number of bits for a touch filed as parameter,
155  * sets maximum value for field which is used as bit mask
156  * and returns number of bytes required for that field
157  */
158 static int cyttsp4_bits_2_bytes(unsigned int nbits, size_t *max)
159 {
160 	*max = 1UL << nbits;
161 	return (nbits + 7) / 8;
162 }
163 
164 static int cyttsp4_si_data_offsets(struct cyttsp4 *cd)
165 {
166 	struct cyttsp4_sysinfo *si = &cd->sysinfo;
167 	int rc = cyttsp4_adap_read(cd, CY_REG_BASE, sizeof(si->si_data),
168 			&si->si_data);
169 	if (rc < 0) {
170 		dev_err(cd->dev, "%s: fail read sysinfo data offsets r=%d\n",
171 			__func__, rc);
172 		return rc;
173 	}
174 
175 	/* Print sysinfo data offsets */
176 	cyttsp4_pr_buf(cd->dev, cd->pr_buf, (u8 *)&si->si_data,
177 		       sizeof(si->si_data), "sysinfo_data_offsets");
178 
179 	/* convert sysinfo data offset bytes into integers */
180 
181 	si->si_ofs.map_sz = merge_bytes(si->si_data.map_szh,
182 			si->si_data.map_szl);
183 	si->si_ofs.map_sz = merge_bytes(si->si_data.map_szh,
184 			si->si_data.map_szl);
185 	si->si_ofs.cydata_ofs = merge_bytes(si->si_data.cydata_ofsh,
186 			si->si_data.cydata_ofsl);
187 	si->si_ofs.test_ofs = merge_bytes(si->si_data.test_ofsh,
188 			si->si_data.test_ofsl);
189 	si->si_ofs.pcfg_ofs = merge_bytes(si->si_data.pcfg_ofsh,
190 			si->si_data.pcfg_ofsl);
191 	si->si_ofs.opcfg_ofs = merge_bytes(si->si_data.opcfg_ofsh,
192 			si->si_data.opcfg_ofsl);
193 	si->si_ofs.ddata_ofs = merge_bytes(si->si_data.ddata_ofsh,
194 			si->si_data.ddata_ofsl);
195 	si->si_ofs.mdata_ofs = merge_bytes(si->si_data.mdata_ofsh,
196 			si->si_data.mdata_ofsl);
197 	return rc;
198 }
199 
200 static int cyttsp4_si_get_cydata(struct cyttsp4 *cd)
201 {
202 	struct cyttsp4_sysinfo *si = &cd->sysinfo;
203 	int read_offset;
204 	int mfgid_sz, calc_mfgid_sz;
205 	void *p;
206 	int rc;
207 
208 	if (si->si_ofs.test_ofs <= si->si_ofs.cydata_ofs) {
209 		dev_err(cd->dev,
210 			"%s: invalid offset test_ofs: %zu, cydata_ofs: %zu\n",
211 			__func__, si->si_ofs.test_ofs, si->si_ofs.cydata_ofs);
212 		return -EINVAL;
213 	}
214 
215 	si->si_ofs.cydata_size = si->si_ofs.test_ofs - si->si_ofs.cydata_ofs;
216 	dev_dbg(cd->dev, "%s: cydata size: %zd\n", __func__,
217 			si->si_ofs.cydata_size);
218 
219 	p = krealloc(si->si_ptrs.cydata, si->si_ofs.cydata_size, GFP_KERNEL);
220 	if (p == NULL) {
221 		dev_err(cd->dev, "%s: failed to allocate cydata memory\n",
222 			__func__);
223 		return -ENOMEM;
224 	}
225 	si->si_ptrs.cydata = p;
226 
227 	read_offset = si->si_ofs.cydata_ofs;
228 
229 	/* Read the CYDA registers up to MFGID field */
230 	rc = cyttsp4_adap_read(cd, read_offset,
231 			offsetof(struct cyttsp4_cydata, mfgid_sz)
232 				+ sizeof(si->si_ptrs.cydata->mfgid_sz),
233 			si->si_ptrs.cydata);
234 	if (rc < 0) {
235 		dev_err(cd->dev, "%s: fail read cydata r=%d\n",
236 			__func__, rc);
237 		return rc;
238 	}
239 
240 	/* Check MFGID size */
241 	mfgid_sz = si->si_ptrs.cydata->mfgid_sz;
242 	calc_mfgid_sz = si->si_ofs.cydata_size - sizeof(struct cyttsp4_cydata);
243 	if (mfgid_sz != calc_mfgid_sz) {
244 		dev_err(cd->dev, "%s: mismatch in MFGID size, reported:%d calculated:%d\n",
245 			__func__, mfgid_sz, calc_mfgid_sz);
246 		return -EINVAL;
247 	}
248 
249 	read_offset += offsetof(struct cyttsp4_cydata, mfgid_sz)
250 			+ sizeof(si->si_ptrs.cydata->mfgid_sz);
251 
252 	/* Read the CYDA registers for MFGID field */
253 	rc = cyttsp4_adap_read(cd, read_offset, si->si_ptrs.cydata->mfgid_sz,
254 			si->si_ptrs.cydata->mfg_id);
255 	if (rc < 0) {
256 		dev_err(cd->dev, "%s: fail read cydata r=%d\n",
257 			__func__, rc);
258 		return rc;
259 	}
260 
261 	read_offset += si->si_ptrs.cydata->mfgid_sz;
262 
263 	/* Read the rest of the CYDA registers */
264 	rc = cyttsp4_adap_read(cd, read_offset,
265 			sizeof(struct cyttsp4_cydata)
266 				- offsetof(struct cyttsp4_cydata, cyito_idh),
267 			&si->si_ptrs.cydata->cyito_idh);
268 	if (rc < 0) {
269 		dev_err(cd->dev, "%s: fail read cydata r=%d\n",
270 			__func__, rc);
271 		return rc;
272 	}
273 
274 	cyttsp4_pr_buf(cd->dev, cd->pr_buf, (u8 *)si->si_ptrs.cydata,
275 		si->si_ofs.cydata_size, "sysinfo_cydata");
276 	return rc;
277 }
278 
279 static int cyttsp4_si_get_test_data(struct cyttsp4 *cd)
280 {
281 	struct cyttsp4_sysinfo *si = &cd->sysinfo;
282 	void *p;
283 	int rc;
284 
285 	if (si->si_ofs.pcfg_ofs <= si->si_ofs.test_ofs) {
286 		dev_err(cd->dev,
287 			"%s: invalid offset pcfg_ofs: %zu, test_ofs: %zu\n",
288 			__func__, si->si_ofs.pcfg_ofs, si->si_ofs.test_ofs);
289 		return -EINVAL;
290 	}
291 
292 	si->si_ofs.test_size = si->si_ofs.pcfg_ofs - si->si_ofs.test_ofs;
293 
294 	p = krealloc(si->si_ptrs.test, si->si_ofs.test_size, GFP_KERNEL);
295 	if (p == NULL) {
296 		dev_err(cd->dev, "%s: failed to allocate test memory\n",
297 			__func__);
298 		return -ENOMEM;
299 	}
300 	si->si_ptrs.test = p;
301 
302 	rc = cyttsp4_adap_read(cd, si->si_ofs.test_ofs, si->si_ofs.test_size,
303 			si->si_ptrs.test);
304 	if (rc < 0) {
305 		dev_err(cd->dev, "%s: fail read test data r=%d\n",
306 			__func__, rc);
307 		return rc;
308 	}
309 
310 	cyttsp4_pr_buf(cd->dev, cd->pr_buf,
311 		       (u8 *)si->si_ptrs.test, si->si_ofs.test_size,
312 		       "sysinfo_test_data");
313 	if (si->si_ptrs.test->post_codel &
314 	    CY_POST_CODEL_WDG_RST)
315 		dev_info(cd->dev, "%s: %s codel=%02X\n",
316 			 __func__, "Reset was a WATCHDOG RESET",
317 			 si->si_ptrs.test->post_codel);
318 
319 	if (!(si->si_ptrs.test->post_codel &
320 	      CY_POST_CODEL_CFG_DATA_CRC_FAIL))
321 		dev_info(cd->dev, "%s: %s codel=%02X\n", __func__,
322 			 "Config Data CRC FAIL",
323 			 si->si_ptrs.test->post_codel);
324 
325 	if (!(si->si_ptrs.test->post_codel &
326 	      CY_POST_CODEL_PANEL_TEST_FAIL))
327 		dev_info(cd->dev, "%s: %s codel=%02X\n",
328 			 __func__, "PANEL TEST FAIL",
329 			 si->si_ptrs.test->post_codel);
330 
331 	dev_info(cd->dev, "%s: SCANNING is %s codel=%02X\n",
332 		 __func__, si->si_ptrs.test->post_codel & 0x08 ?
333 		 "ENABLED" : "DISABLED",
334 		 si->si_ptrs.test->post_codel);
335 	return rc;
336 }
337 
338 static int cyttsp4_si_get_pcfg_data(struct cyttsp4 *cd)
339 {
340 	struct cyttsp4_sysinfo *si = &cd->sysinfo;
341 	void *p;
342 	int rc;
343 
344 	if (si->si_ofs.opcfg_ofs <= si->si_ofs.pcfg_ofs) {
345 		dev_err(cd->dev,
346 			"%s: invalid offset opcfg_ofs: %zu, pcfg_ofs: %zu\n",
347 			__func__, si->si_ofs.opcfg_ofs, si->si_ofs.pcfg_ofs);
348 		return -EINVAL;
349 	}
350 
351 	si->si_ofs.pcfg_size = si->si_ofs.opcfg_ofs - si->si_ofs.pcfg_ofs;
352 
353 	p = krealloc(si->si_ptrs.pcfg, si->si_ofs.pcfg_size, GFP_KERNEL);
354 	if (p == NULL) {
355 		dev_err(cd->dev, "%s: failed to allocate pcfg memory\n",
356 			__func__);
357 		return -ENOMEM;
358 	}
359 	si->si_ptrs.pcfg = p;
360 
361 	rc = cyttsp4_adap_read(cd, si->si_ofs.pcfg_ofs, si->si_ofs.pcfg_size,
362 			si->si_ptrs.pcfg);
363 	if (rc < 0) {
364 		dev_err(cd->dev, "%s: fail read pcfg data r=%d\n",
365 			__func__, rc);
366 		return rc;
367 	}
368 
369 	si->si_ofs.max_x = merge_bytes((si->si_ptrs.pcfg->res_xh
370 			& CY_PCFG_RESOLUTION_X_MASK), si->si_ptrs.pcfg->res_xl);
371 	si->si_ofs.x_origin = !!(si->si_ptrs.pcfg->res_xh
372 			& CY_PCFG_ORIGIN_X_MASK);
373 	si->si_ofs.max_y = merge_bytes((si->si_ptrs.pcfg->res_yh
374 			& CY_PCFG_RESOLUTION_Y_MASK), si->si_ptrs.pcfg->res_yl);
375 	si->si_ofs.y_origin = !!(si->si_ptrs.pcfg->res_yh
376 			& CY_PCFG_ORIGIN_Y_MASK);
377 	si->si_ofs.max_p = merge_bytes(si->si_ptrs.pcfg->max_zh,
378 			si->si_ptrs.pcfg->max_zl);
379 
380 	cyttsp4_pr_buf(cd->dev, cd->pr_buf,
381 		       (u8 *)si->si_ptrs.pcfg,
382 		       si->si_ofs.pcfg_size, "sysinfo_pcfg_data");
383 	return rc;
384 }
385 
386 static int cyttsp4_si_get_opcfg_data(struct cyttsp4 *cd)
387 {
388 	struct cyttsp4_sysinfo *si = &cd->sysinfo;
389 	struct cyttsp4_tch_abs_params *tch;
390 	struct cyttsp4_tch_rec_params *tch_old, *tch_new;
391 	enum cyttsp4_tch_abs abs;
392 	int i;
393 	void *p;
394 	int rc;
395 
396 	if (si->si_ofs.ddata_ofs <= si->si_ofs.opcfg_ofs) {
397 		dev_err(cd->dev,
398 			"%s: invalid offset ddata_ofs: %zu, opcfg_ofs: %zu\n",
399 			__func__, si->si_ofs.ddata_ofs, si->si_ofs.opcfg_ofs);
400 		return -EINVAL;
401 	}
402 
403 	si->si_ofs.opcfg_size = si->si_ofs.ddata_ofs - si->si_ofs.opcfg_ofs;
404 
405 	p = krealloc(si->si_ptrs.opcfg, si->si_ofs.opcfg_size, GFP_KERNEL);
406 	if (p == NULL) {
407 		dev_err(cd->dev, "%s: failed to allocate opcfg memory\n",
408 			__func__);
409 		return -ENOMEM;
410 	}
411 	si->si_ptrs.opcfg = p;
412 
413 	rc = cyttsp4_adap_read(cd, si->si_ofs.opcfg_ofs, si->si_ofs.opcfg_size,
414 			si->si_ptrs.opcfg);
415 	if (rc < 0) {
416 		dev_err(cd->dev, "%s: fail read opcfg data r=%d\n",
417 			__func__, rc);
418 		return rc;
419 	}
420 	si->si_ofs.cmd_ofs = si->si_ptrs.opcfg->cmd_ofs;
421 	si->si_ofs.rep_ofs = si->si_ptrs.opcfg->rep_ofs;
422 	si->si_ofs.rep_sz = (si->si_ptrs.opcfg->rep_szh * 256) +
423 		si->si_ptrs.opcfg->rep_szl;
424 	si->si_ofs.num_btns = si->si_ptrs.opcfg->num_btns;
425 	si->si_ofs.num_btn_regs = (si->si_ofs.num_btns +
426 		CY_NUM_BTN_PER_REG - 1) / CY_NUM_BTN_PER_REG;
427 	si->si_ofs.tt_stat_ofs = si->si_ptrs.opcfg->tt_stat_ofs;
428 	si->si_ofs.obj_cfg0 = si->si_ptrs.opcfg->obj_cfg0;
429 	si->si_ofs.max_tchs = si->si_ptrs.opcfg->max_tchs &
430 		CY_BYTE_OFS_MASK;
431 	si->si_ofs.tch_rec_size = si->si_ptrs.opcfg->tch_rec_size &
432 		CY_BYTE_OFS_MASK;
433 
434 	/* Get the old touch fields */
435 	for (abs = CY_TCH_X; abs < CY_NUM_TCH_FIELDS; abs++) {
436 		tch = &si->si_ofs.tch_abs[abs];
437 		tch_old = &si->si_ptrs.opcfg->tch_rec_old[abs];
438 
439 		tch->ofs = tch_old->loc & CY_BYTE_OFS_MASK;
440 		tch->size = cyttsp4_bits_2_bytes(tch_old->size,
441 						 &tch->max);
442 		tch->bofs = (tch_old->loc & CY_BOFS_MASK) >> CY_BOFS_SHIFT;
443 	}
444 
445 	/* button fields */
446 	si->si_ofs.btn_rec_size = si->si_ptrs.opcfg->btn_rec_size;
447 	si->si_ofs.btn_diff_ofs = si->si_ptrs.opcfg->btn_diff_ofs;
448 	si->si_ofs.btn_diff_size = si->si_ptrs.opcfg->btn_diff_size;
449 
450 	if (si->si_ofs.tch_rec_size > CY_TMA1036_TCH_REC_SIZE) {
451 		/* Get the extended touch fields */
452 		for (i = 0; i < CY_NUM_EXT_TCH_FIELDS; abs++, i++) {
453 			tch = &si->si_ofs.tch_abs[abs];
454 			tch_new = &si->si_ptrs.opcfg->tch_rec_new[i];
455 
456 			tch->ofs = tch_new->loc & CY_BYTE_OFS_MASK;
457 			tch->size = cyttsp4_bits_2_bytes(tch_new->size,
458 							 &tch->max);
459 			tch->bofs = (tch_new->loc & CY_BOFS_MASK) >> CY_BOFS_SHIFT;
460 		}
461 	}
462 
463 	for (abs = 0; abs < CY_TCH_NUM_ABS; abs++) {
464 		dev_dbg(cd->dev, "%s: tch_rec_%s\n", __func__,
465 			cyttsp4_tch_abs_string[abs]);
466 		dev_dbg(cd->dev, "%s:     ofs =%2zd\n", __func__,
467 			si->si_ofs.tch_abs[abs].ofs);
468 		dev_dbg(cd->dev, "%s:     siz =%2zd\n", __func__,
469 			si->si_ofs.tch_abs[abs].size);
470 		dev_dbg(cd->dev, "%s:     max =%2zd\n", __func__,
471 			si->si_ofs.tch_abs[abs].max);
472 		dev_dbg(cd->dev, "%s:     bofs=%2zd\n", __func__,
473 			si->si_ofs.tch_abs[abs].bofs);
474 	}
475 
476 	si->si_ofs.mode_size = si->si_ofs.tt_stat_ofs + 1;
477 	si->si_ofs.data_size = si->si_ofs.max_tchs *
478 		si->si_ptrs.opcfg->tch_rec_size;
479 
480 	cyttsp4_pr_buf(cd->dev, cd->pr_buf, (u8 *)si->si_ptrs.opcfg,
481 		si->si_ofs.opcfg_size, "sysinfo_opcfg_data");
482 
483 	return 0;
484 }
485 
486 static int cyttsp4_si_get_ddata(struct cyttsp4 *cd)
487 {
488 	struct cyttsp4_sysinfo *si = &cd->sysinfo;
489 	void *p;
490 	int rc;
491 
492 	si->si_ofs.ddata_size = si->si_ofs.mdata_ofs - si->si_ofs.ddata_ofs;
493 
494 	p = krealloc(si->si_ptrs.ddata, si->si_ofs.ddata_size, GFP_KERNEL);
495 	if (p == NULL) {
496 		dev_err(cd->dev, "%s: fail alloc ddata memory\n", __func__);
497 		return -ENOMEM;
498 	}
499 	si->si_ptrs.ddata = p;
500 
501 	rc = cyttsp4_adap_read(cd, si->si_ofs.ddata_ofs, si->si_ofs.ddata_size,
502 			si->si_ptrs.ddata);
503 	if (rc < 0)
504 		dev_err(cd->dev, "%s: fail read ddata data r=%d\n",
505 			__func__, rc);
506 	else
507 		cyttsp4_pr_buf(cd->dev, cd->pr_buf,
508 			       (u8 *)si->si_ptrs.ddata,
509 			       si->si_ofs.ddata_size, "sysinfo_ddata");
510 	return rc;
511 }
512 
513 static int cyttsp4_si_get_mdata(struct cyttsp4 *cd)
514 {
515 	struct cyttsp4_sysinfo *si = &cd->sysinfo;
516 	void *p;
517 	int rc;
518 
519 	si->si_ofs.mdata_size = si->si_ofs.map_sz - si->si_ofs.mdata_ofs;
520 
521 	p = krealloc(si->si_ptrs.mdata, si->si_ofs.mdata_size, GFP_KERNEL);
522 	if (p == NULL) {
523 		dev_err(cd->dev, "%s: fail alloc mdata memory\n", __func__);
524 		return -ENOMEM;
525 	}
526 	si->si_ptrs.mdata = p;
527 
528 	rc = cyttsp4_adap_read(cd, si->si_ofs.mdata_ofs, si->si_ofs.mdata_size,
529 			si->si_ptrs.mdata);
530 	if (rc < 0)
531 		dev_err(cd->dev, "%s: fail read mdata data r=%d\n",
532 			__func__, rc);
533 	else
534 		cyttsp4_pr_buf(cd->dev, cd->pr_buf,
535 			       (u8 *)si->si_ptrs.mdata,
536 			       si->si_ofs.mdata_size, "sysinfo_mdata");
537 	return rc;
538 }
539 
540 static int cyttsp4_si_get_btn_data(struct cyttsp4 *cd)
541 {
542 	struct cyttsp4_sysinfo *si = &cd->sysinfo;
543 	int btn;
544 	int num_defined_keys;
545 	u16 *key_table;
546 	void *p;
547 	int rc = 0;
548 
549 	if (si->si_ofs.num_btns) {
550 		si->si_ofs.btn_keys_size = si->si_ofs.num_btns *
551 			sizeof(struct cyttsp4_btn);
552 
553 		p = krealloc(si->btn, si->si_ofs.btn_keys_size,
554 				GFP_KERNEL|__GFP_ZERO);
555 		if (p == NULL) {
556 			dev_err(cd->dev, "%s: %s\n", __func__,
557 				"fail alloc btn_keys memory");
558 			return -ENOMEM;
559 		}
560 		si->btn = p;
561 
562 		if (cd->cpdata->sett[CY_IC_GRPNUM_BTN_KEYS] == NULL)
563 			num_defined_keys = 0;
564 		else if (cd->cpdata->sett[CY_IC_GRPNUM_BTN_KEYS]->data == NULL)
565 			num_defined_keys = 0;
566 		else
567 			num_defined_keys = cd->cpdata->sett
568 				[CY_IC_GRPNUM_BTN_KEYS]->size;
569 
570 		for (btn = 0; btn < si->si_ofs.num_btns &&
571 			btn < num_defined_keys; btn++) {
572 			key_table = (u16 *)cd->cpdata->sett
573 				[CY_IC_GRPNUM_BTN_KEYS]->data;
574 			si->btn[btn].key_code = key_table[btn];
575 			si->btn[btn].state = CY_BTN_RELEASED;
576 			si->btn[btn].enabled = true;
577 		}
578 		for (; btn < si->si_ofs.num_btns; btn++) {
579 			si->btn[btn].key_code = KEY_RESERVED;
580 			si->btn[btn].state = CY_BTN_RELEASED;
581 			si->btn[btn].enabled = true;
582 		}
583 
584 		return rc;
585 	}
586 
587 	si->si_ofs.btn_keys_size = 0;
588 	kfree(si->btn);
589 	si->btn = NULL;
590 	return rc;
591 }
592 
593 static int cyttsp4_si_get_op_data_ptrs(struct cyttsp4 *cd)
594 {
595 	struct cyttsp4_sysinfo *si = &cd->sysinfo;
596 	void *p;
597 
598 	p = krealloc(si->xy_mode, si->si_ofs.mode_size, GFP_KERNEL|__GFP_ZERO);
599 	if (p == NULL)
600 		return -ENOMEM;
601 	si->xy_mode = p;
602 
603 	p = krealloc(si->xy_data, si->si_ofs.data_size, GFP_KERNEL|__GFP_ZERO);
604 	if (p == NULL)
605 		return -ENOMEM;
606 	si->xy_data = p;
607 
608 	p = krealloc(si->btn_rec_data,
609 			si->si_ofs.btn_rec_size * si->si_ofs.num_btns,
610 			GFP_KERNEL|__GFP_ZERO);
611 	if (p == NULL)
612 		return -ENOMEM;
613 	si->btn_rec_data = p;
614 
615 	return 0;
616 }
617 
618 static void cyttsp4_si_put_log_data(struct cyttsp4 *cd)
619 {
620 	struct cyttsp4_sysinfo *si = &cd->sysinfo;
621 	dev_dbg(cd->dev, "%s: cydata_ofs =%4zd siz=%4zd\n", __func__,
622 		si->si_ofs.cydata_ofs, si->si_ofs.cydata_size);
623 	dev_dbg(cd->dev, "%s: test_ofs   =%4zd siz=%4zd\n", __func__,
624 		si->si_ofs.test_ofs, si->si_ofs.test_size);
625 	dev_dbg(cd->dev, "%s: pcfg_ofs   =%4zd siz=%4zd\n", __func__,
626 		si->si_ofs.pcfg_ofs, si->si_ofs.pcfg_size);
627 	dev_dbg(cd->dev, "%s: opcfg_ofs  =%4zd siz=%4zd\n", __func__,
628 		si->si_ofs.opcfg_ofs, si->si_ofs.opcfg_size);
629 	dev_dbg(cd->dev, "%s: ddata_ofs  =%4zd siz=%4zd\n", __func__,
630 		si->si_ofs.ddata_ofs, si->si_ofs.ddata_size);
631 	dev_dbg(cd->dev, "%s: mdata_ofs  =%4zd siz=%4zd\n", __func__,
632 		si->si_ofs.mdata_ofs, si->si_ofs.mdata_size);
633 
634 	dev_dbg(cd->dev, "%s: cmd_ofs       =%4zd\n", __func__,
635 		si->si_ofs.cmd_ofs);
636 	dev_dbg(cd->dev, "%s: rep_ofs       =%4zd\n", __func__,
637 		si->si_ofs.rep_ofs);
638 	dev_dbg(cd->dev, "%s: rep_sz        =%4zd\n", __func__,
639 		si->si_ofs.rep_sz);
640 	dev_dbg(cd->dev, "%s: num_btns      =%4zd\n", __func__,
641 		si->si_ofs.num_btns);
642 	dev_dbg(cd->dev, "%s: num_btn_regs  =%4zd\n", __func__,
643 		si->si_ofs.num_btn_regs);
644 	dev_dbg(cd->dev, "%s: tt_stat_ofs   =%4zd\n", __func__,
645 		si->si_ofs.tt_stat_ofs);
646 	dev_dbg(cd->dev, "%s: tch_rec_size  =%4zd\n", __func__,
647 		si->si_ofs.tch_rec_size);
648 	dev_dbg(cd->dev, "%s: max_tchs      =%4zd\n", __func__,
649 		si->si_ofs.max_tchs);
650 	dev_dbg(cd->dev, "%s: mode_size     =%4zd\n", __func__,
651 		si->si_ofs.mode_size);
652 	dev_dbg(cd->dev, "%s: data_size     =%4zd\n", __func__,
653 		si->si_ofs.data_size);
654 	dev_dbg(cd->dev, "%s: map_sz        =%4zd\n", __func__,
655 		si->si_ofs.map_sz);
656 
657 	dev_dbg(cd->dev, "%s: btn_rec_size   =%2zd\n", __func__,
658 		si->si_ofs.btn_rec_size);
659 	dev_dbg(cd->dev, "%s: btn_diff_ofs   =%2zd\n", __func__,
660 		si->si_ofs.btn_diff_ofs);
661 	dev_dbg(cd->dev, "%s: btn_diff_size  =%2zd\n", __func__,
662 		si->si_ofs.btn_diff_size);
663 
664 	dev_dbg(cd->dev, "%s: max_x    = 0x%04zX (%zd)\n", __func__,
665 		si->si_ofs.max_x, si->si_ofs.max_x);
666 	dev_dbg(cd->dev, "%s: x_origin = %zd (%s)\n", __func__,
667 		si->si_ofs.x_origin,
668 		si->si_ofs.x_origin == CY_NORMAL_ORIGIN ?
669 		"left corner" : "right corner");
670 	dev_dbg(cd->dev, "%s: max_y    = 0x%04zX (%zd)\n", __func__,
671 		si->si_ofs.max_y, si->si_ofs.max_y);
672 	dev_dbg(cd->dev, "%s: y_origin = %zd (%s)\n", __func__,
673 		si->si_ofs.y_origin,
674 		si->si_ofs.y_origin == CY_NORMAL_ORIGIN ?
675 		"upper corner" : "lower corner");
676 	dev_dbg(cd->dev, "%s: max_p    = 0x%04zX (%zd)\n", __func__,
677 		si->si_ofs.max_p, si->si_ofs.max_p);
678 
679 	dev_dbg(cd->dev, "%s: xy_mode=%p xy_data=%p\n", __func__,
680 		si->xy_mode, si->xy_data);
681 }
682 
683 static int cyttsp4_get_sysinfo_regs(struct cyttsp4 *cd)
684 {
685 	struct cyttsp4_sysinfo *si = &cd->sysinfo;
686 	int rc;
687 
688 	rc = cyttsp4_si_data_offsets(cd);
689 	if (rc < 0)
690 		return rc;
691 
692 	rc = cyttsp4_si_get_cydata(cd);
693 	if (rc < 0)
694 		return rc;
695 
696 	rc = cyttsp4_si_get_test_data(cd);
697 	if (rc < 0)
698 		return rc;
699 
700 	rc = cyttsp4_si_get_pcfg_data(cd);
701 	if (rc < 0)
702 		return rc;
703 
704 	rc = cyttsp4_si_get_opcfg_data(cd);
705 	if (rc < 0)
706 		return rc;
707 
708 	rc = cyttsp4_si_get_ddata(cd);
709 	if (rc < 0)
710 		return rc;
711 
712 	rc = cyttsp4_si_get_mdata(cd);
713 	if (rc < 0)
714 		return rc;
715 
716 	rc = cyttsp4_si_get_btn_data(cd);
717 	if (rc < 0)
718 		return rc;
719 
720 	rc = cyttsp4_si_get_op_data_ptrs(cd);
721 	if (rc < 0) {
722 		dev_err(cd->dev, "%s: failed to get_op_data\n",
723 			__func__);
724 		return rc;
725 	}
726 
727 	cyttsp4_si_put_log_data(cd);
728 
729 	/* provide flow control handshake */
730 	rc = cyttsp4_handshake(cd, si->si_data.hst_mode);
731 	if (rc < 0)
732 		dev_err(cd->dev, "%s: handshake fail on sysinfo reg\n",
733 			__func__);
734 
735 	si->ready = true;
736 	return rc;
737 }
738 
739 static void cyttsp4_queue_startup_(struct cyttsp4 *cd)
740 {
741 	if (cd->startup_state == STARTUP_NONE) {
742 		cd->startup_state = STARTUP_QUEUED;
743 		schedule_work(&cd->startup_work);
744 		dev_dbg(cd->dev, "%s: cyttsp4_startup queued\n", __func__);
745 	} else {
746 		dev_dbg(cd->dev, "%s: startup_state = %d\n", __func__,
747 			cd->startup_state);
748 	}
749 }
750 
751 static void cyttsp4_report_slot_liftoff(struct cyttsp4_mt_data *md,
752 		int max_slots)
753 {
754 	int t;
755 
756 	if (md->num_prv_tch == 0)
757 		return;
758 
759 	for (t = 0; t < max_slots; t++) {
760 		input_mt_slot(md->input, t);
761 		input_mt_report_slot_inactive(md->input);
762 	}
763 }
764 
765 static void cyttsp4_lift_all(struct cyttsp4_mt_data *md)
766 {
767 	if (!md->si)
768 		return;
769 
770 	if (md->num_prv_tch != 0) {
771 		cyttsp4_report_slot_liftoff(md,
772 				md->si->si_ofs.tch_abs[CY_TCH_T].max);
773 		input_sync(md->input);
774 		md->num_prv_tch = 0;
775 	}
776 }
777 
778 static void cyttsp4_get_touch_axis(struct cyttsp4_mt_data *md,
779 	int *axis, int size, int max, u8 *xy_data, int bofs)
780 {
781 	int nbyte;
782 	int next;
783 
784 	for (nbyte = 0, *axis = 0, next = 0; nbyte < size; nbyte++) {
785 		dev_vdbg(&md->input->dev,
786 			"%s: *axis=%02X(%d) size=%d max=%08X xy_data=%p"
787 			" xy_data[%d]=%02X(%d) bofs=%d\n",
788 			__func__, *axis, *axis, size, max, xy_data, next,
789 			xy_data[next], xy_data[next], bofs);
790 		*axis = (*axis * 256) + (xy_data[next] >> bofs);
791 		next++;
792 	}
793 
794 	*axis &= max - 1;
795 
796 	dev_vdbg(&md->input->dev,
797 		"%s: *axis=%02X(%d) size=%d max=%08X xy_data=%p"
798 		" xy_data[%d]=%02X(%d)\n",
799 		__func__, *axis, *axis, size, max, xy_data, next,
800 		xy_data[next], xy_data[next]);
801 }
802 
803 static void cyttsp4_get_touch(struct cyttsp4_mt_data *md,
804 	struct cyttsp4_touch *touch, u8 *xy_data)
805 {
806 	struct device *dev = &md->input->dev;
807 	struct cyttsp4_sysinfo *si = md->si;
808 	enum cyttsp4_tch_abs abs;
809 	bool flipped;
810 
811 	for (abs = CY_TCH_X; abs < CY_TCH_NUM_ABS; abs++) {
812 		cyttsp4_get_touch_axis(md, &touch->abs[abs],
813 			si->si_ofs.tch_abs[abs].size,
814 			si->si_ofs.tch_abs[abs].max,
815 			xy_data + si->si_ofs.tch_abs[abs].ofs,
816 			si->si_ofs.tch_abs[abs].bofs);
817 		dev_vdbg(dev, "%s: get %s=%04X(%d)\n", __func__,
818 			cyttsp4_tch_abs_string[abs],
819 			touch->abs[abs], touch->abs[abs]);
820 	}
821 
822 	if (md->pdata->flags & CY_FLAG_FLIP) {
823 		swap(touch->abs[CY_TCH_X], touch->abs[CY_TCH_Y]);
824 		flipped = true;
825 	} else
826 		flipped = false;
827 
828 	if (md->pdata->flags & CY_FLAG_INV_X) {
829 		if (flipped)
830 			touch->abs[CY_TCH_X] = md->si->si_ofs.max_y -
831 				touch->abs[CY_TCH_X];
832 		else
833 			touch->abs[CY_TCH_X] = md->si->si_ofs.max_x -
834 				touch->abs[CY_TCH_X];
835 	}
836 	if (md->pdata->flags & CY_FLAG_INV_Y) {
837 		if (flipped)
838 			touch->abs[CY_TCH_Y] = md->si->si_ofs.max_x -
839 				touch->abs[CY_TCH_Y];
840 		else
841 			touch->abs[CY_TCH_Y] = md->si->si_ofs.max_y -
842 				touch->abs[CY_TCH_Y];
843 	}
844 
845 	dev_vdbg(dev, "%s: flip=%s inv-x=%s inv-y=%s x=%04X(%d) y=%04X(%d)\n",
846 		__func__, flipped ? "true" : "false",
847 		md->pdata->flags & CY_FLAG_INV_X ? "true" : "false",
848 		md->pdata->flags & CY_FLAG_INV_Y ? "true" : "false",
849 		touch->abs[CY_TCH_X], touch->abs[CY_TCH_X],
850 		touch->abs[CY_TCH_Y], touch->abs[CY_TCH_Y]);
851 }
852 
853 static void cyttsp4_final_sync(struct input_dev *input, int max_slots, int *ids)
854 {
855 	int t;
856 
857 	for (t = 0; t < max_slots; t++) {
858 		if (ids[t])
859 			continue;
860 		input_mt_slot(input, t);
861 		input_mt_report_slot_inactive(input);
862 	}
863 
864 	input_sync(input);
865 }
866 
867 static void cyttsp4_get_mt_touches(struct cyttsp4_mt_data *md, int num_cur_tch)
868 {
869 	struct device *dev = &md->input->dev;
870 	struct cyttsp4_sysinfo *si = md->si;
871 	struct cyttsp4_touch tch;
872 	int sig;
873 	int i, j, t = 0;
874 	int ids[max(CY_TMA1036_MAX_TCH, CY_TMA4XX_MAX_TCH)];
875 
876 	memset(ids, 0, si->si_ofs.tch_abs[CY_TCH_T].max * sizeof(int));
877 	for (i = 0; i < num_cur_tch; i++) {
878 		cyttsp4_get_touch(md, &tch, si->xy_data +
879 			(i * si->si_ofs.tch_rec_size));
880 		if ((tch.abs[CY_TCH_T] < md->pdata->frmwrk->abs
881 			[(CY_ABS_ID_OST * CY_NUM_ABS_SET) + CY_MIN_OST]) ||
882 			(tch.abs[CY_TCH_T] > md->pdata->frmwrk->abs
883 			[(CY_ABS_ID_OST * CY_NUM_ABS_SET) + CY_MAX_OST])) {
884 			dev_err(dev, "%s: tch=%d -> bad trk_id=%d max_id=%d\n",
885 				__func__, i, tch.abs[CY_TCH_T],
886 				md->pdata->frmwrk->abs[(CY_ABS_ID_OST *
887 				CY_NUM_ABS_SET) + CY_MAX_OST]);
888 			continue;
889 		}
890 
891 		/* use 0 based track id's */
892 		sig = md->pdata->frmwrk->abs
893 			[(CY_ABS_ID_OST * CY_NUM_ABS_SET) + 0];
894 		if (sig != CY_IGNORE_VALUE) {
895 			t = tch.abs[CY_TCH_T] - md->pdata->frmwrk->abs
896 				[(CY_ABS_ID_OST * CY_NUM_ABS_SET) + CY_MIN_OST];
897 			if (tch.abs[CY_TCH_E] == CY_EV_LIFTOFF) {
898 				dev_dbg(dev, "%s: t=%d e=%d lift-off\n",
899 					__func__, t, tch.abs[CY_TCH_E]);
900 				goto cyttsp4_get_mt_touches_pr_tch;
901 			}
902 			input_mt_slot(md->input, t);
903 			input_mt_report_slot_state(md->input, MT_TOOL_FINGER,
904 					true);
905 			ids[t] = true;
906 		}
907 
908 		/* all devices: position and pressure fields */
909 		for (j = 0; j <= CY_ABS_W_OST; j++) {
910 			sig = md->pdata->frmwrk->abs[((CY_ABS_X_OST + j) *
911 				CY_NUM_ABS_SET) + 0];
912 			if (sig != CY_IGNORE_VALUE)
913 				input_report_abs(md->input, sig,
914 					tch.abs[CY_TCH_X + j]);
915 		}
916 		if (si->si_ofs.tch_rec_size > CY_TMA1036_TCH_REC_SIZE) {
917 			/*
918 			 * TMA400 size and orientation fields:
919 			 * if pressure is non-zero and major touch
920 			 * signal is zero, then set major and minor touch
921 			 * signals to minimum non-zero value
922 			 */
923 			if (tch.abs[CY_TCH_P] > 0 && tch.abs[CY_TCH_MAJ] == 0)
924 				tch.abs[CY_TCH_MAJ] = tch.abs[CY_TCH_MIN] = 1;
925 
926 			/* Get the extended touch fields */
927 			for (j = 0; j < CY_NUM_EXT_TCH_FIELDS; j++) {
928 				sig = md->pdata->frmwrk->abs
929 					[((CY_ABS_MAJ_OST + j) *
930 					CY_NUM_ABS_SET) + 0];
931 				if (sig != CY_IGNORE_VALUE)
932 					input_report_abs(md->input, sig,
933 						tch.abs[CY_TCH_MAJ + j]);
934 			}
935 		}
936 
937 cyttsp4_get_mt_touches_pr_tch:
938 		if (si->si_ofs.tch_rec_size > CY_TMA1036_TCH_REC_SIZE)
939 			dev_dbg(dev,
940 				"%s: t=%d x=%d y=%d z=%d M=%d m=%d o=%d e=%d\n",
941 				__func__, t,
942 				tch.abs[CY_TCH_X],
943 				tch.abs[CY_TCH_Y],
944 				tch.abs[CY_TCH_P],
945 				tch.abs[CY_TCH_MAJ],
946 				tch.abs[CY_TCH_MIN],
947 				tch.abs[CY_TCH_OR],
948 				tch.abs[CY_TCH_E]);
949 		else
950 			dev_dbg(dev,
951 				"%s: t=%d x=%d y=%d z=%d e=%d\n", __func__,
952 				t,
953 				tch.abs[CY_TCH_X],
954 				tch.abs[CY_TCH_Y],
955 				tch.abs[CY_TCH_P],
956 				tch.abs[CY_TCH_E]);
957 	}
958 
959 	cyttsp4_final_sync(md->input, si->si_ofs.tch_abs[CY_TCH_T].max, ids);
960 
961 	md->num_prv_tch = num_cur_tch;
962 
963 	return;
964 }
965 
966 /* read xy_data for all current touches */
967 static int cyttsp4_xy_worker(struct cyttsp4 *cd)
968 {
969 	struct cyttsp4_mt_data *md = &cd->md;
970 	struct device *dev = &md->input->dev;
971 	struct cyttsp4_sysinfo *si = md->si;
972 	u8 num_cur_tch;
973 	u8 hst_mode;
974 	u8 rep_len;
975 	u8 rep_stat;
976 	u8 tt_stat;
977 	int rc = 0;
978 
979 	/*
980 	 * Get event data from cyttsp4 device.
981 	 * The event data includes all data
982 	 * for all active touches.
983 	 * Event data also includes button data
984 	 */
985 	/*
986 	 * Use 2 reads:
987 	 * 1st read to get mode + button bytes + touch count (core)
988 	 * 2nd read (optional) to get touch 1 - touch n data
989 	 */
990 	hst_mode = si->xy_mode[CY_REG_BASE];
991 	rep_len = si->xy_mode[si->si_ofs.rep_ofs];
992 	rep_stat = si->xy_mode[si->si_ofs.rep_ofs + 1];
993 	tt_stat = si->xy_mode[si->si_ofs.tt_stat_ofs];
994 	dev_vdbg(dev, "%s: %s%02X %s%d %s%02X %s%02X\n", __func__,
995 		"hst_mode=", hst_mode, "rep_len=", rep_len,
996 		"rep_stat=", rep_stat, "tt_stat=", tt_stat);
997 
998 	num_cur_tch = GET_NUM_TOUCHES(tt_stat);
999 	dev_vdbg(dev, "%s: num_cur_tch=%d\n", __func__, num_cur_tch);
1000 
1001 	if (rep_len == 0 && num_cur_tch > 0) {
1002 		dev_err(dev, "%s: report length error rep_len=%d num_tch=%d\n",
1003 			__func__, rep_len, num_cur_tch);
1004 		goto cyttsp4_xy_worker_exit;
1005 	}
1006 
1007 	/* read touches */
1008 	if (num_cur_tch > 0) {
1009 		rc = cyttsp4_adap_read(cd, si->si_ofs.tt_stat_ofs + 1,
1010 				num_cur_tch * si->si_ofs.tch_rec_size,
1011 				si->xy_data);
1012 		if (rc < 0) {
1013 			dev_err(dev, "%s: read fail on touch regs r=%d\n",
1014 				__func__, rc);
1015 			goto cyttsp4_xy_worker_exit;
1016 		}
1017 	}
1018 
1019 	/* print xy data */
1020 	cyttsp4_pr_buf(dev, cd->pr_buf, si->xy_data, num_cur_tch *
1021 		si->si_ofs.tch_rec_size, "xy_data");
1022 
1023 	/* check any error conditions */
1024 	if (IS_BAD_PKT(rep_stat)) {
1025 		dev_dbg(dev, "%s: Invalid buffer detected\n", __func__);
1026 		rc = 0;
1027 		goto cyttsp4_xy_worker_exit;
1028 	}
1029 
1030 	if (IS_LARGE_AREA(tt_stat))
1031 		dev_dbg(dev, "%s: Large area detected\n", __func__);
1032 
1033 	if (num_cur_tch > si->si_ofs.max_tchs) {
1034 		dev_err(dev, "%s: too many tch; set to max tch (n=%d c=%zd)\n",
1035 				__func__, num_cur_tch, si->si_ofs.max_tchs);
1036 		num_cur_tch = si->si_ofs.max_tchs;
1037 	}
1038 
1039 	/* extract xy_data for all currently reported touches */
1040 	dev_vdbg(dev, "%s: extract data num_cur_tch=%d\n", __func__,
1041 		num_cur_tch);
1042 	if (num_cur_tch)
1043 		cyttsp4_get_mt_touches(md, num_cur_tch);
1044 	else
1045 		cyttsp4_lift_all(md);
1046 
1047 	rc = 0;
1048 
1049 cyttsp4_xy_worker_exit:
1050 	return rc;
1051 }
1052 
1053 static int cyttsp4_mt_attention(struct cyttsp4 *cd)
1054 {
1055 	struct device *dev = cd->dev;
1056 	struct cyttsp4_mt_data *md = &cd->md;
1057 	int rc = 0;
1058 
1059 	if (!md->si)
1060 		return 0;
1061 
1062 	mutex_lock(&md->report_lock);
1063 	if (!md->is_suspended) {
1064 		/* core handles handshake */
1065 		rc = cyttsp4_xy_worker(cd);
1066 	} else {
1067 		dev_vdbg(dev, "%s: Ignoring report while suspended\n",
1068 			__func__);
1069 	}
1070 	mutex_unlock(&md->report_lock);
1071 	if (rc < 0)
1072 		dev_err(dev, "%s: xy_worker error r=%d\n", __func__, rc);
1073 
1074 	return rc;
1075 }
1076 
1077 static irqreturn_t cyttsp4_irq(int irq, void *handle)
1078 {
1079 	struct cyttsp4 *cd = handle;
1080 	struct device *dev = cd->dev;
1081 	enum cyttsp4_mode cur_mode;
1082 	u8 cmd_ofs = cd->sysinfo.si_ofs.cmd_ofs;
1083 	u8 mode[3];
1084 	int rc;
1085 
1086 	/*
1087 	 * Check whether this IRQ should be ignored (external)
1088 	 * This should be the very first thing to check since
1089 	 * ignore_irq may be set for a very short period of time
1090 	 */
1091 	if (atomic_read(&cd->ignore_irq)) {
1092 		dev_vdbg(dev, "%s: Ignoring IRQ\n", __func__);
1093 		return IRQ_HANDLED;
1094 	}
1095 
1096 	dev_dbg(dev, "%s int:0x%x\n", __func__, cd->int_status);
1097 
1098 	mutex_lock(&cd->system_lock);
1099 
1100 	/* Just to debug */
1101 	if (cd->sleep_state == SS_SLEEP_ON || cd->sleep_state == SS_SLEEPING)
1102 		dev_vdbg(dev, "%s: Received IRQ while in sleep\n", __func__);
1103 
1104 	rc = cyttsp4_adap_read(cd, CY_REG_BASE, sizeof(mode), mode);
1105 	if (rc) {
1106 		dev_err(cd->dev, "%s: Fail read adapter r=%d\n", __func__, rc);
1107 		goto cyttsp4_irq_exit;
1108 	}
1109 	dev_vdbg(dev, "%s mode[0-2]:0x%X 0x%X 0x%X\n", __func__,
1110 			mode[0], mode[1], mode[2]);
1111 
1112 	if (IS_BOOTLOADER(mode[0], mode[1])) {
1113 		cur_mode = CY_MODE_BOOTLOADER;
1114 		dev_vdbg(dev, "%s: bl running\n", __func__);
1115 		if (cd->mode == CY_MODE_BOOTLOADER) {
1116 			/* Signal bootloader heartbeat heard */
1117 			wake_up(&cd->wait_q);
1118 			goto cyttsp4_irq_exit;
1119 		}
1120 
1121 		/* switch to bootloader */
1122 		dev_dbg(dev, "%s: restart switch to bl m=%d -> m=%d\n",
1123 			__func__, cd->mode, cur_mode);
1124 
1125 		/* catch operation->bl glitch */
1126 		if (cd->mode != CY_MODE_UNKNOWN) {
1127 			/* Incase startup_state do not let startup_() */
1128 			cd->mode = CY_MODE_UNKNOWN;
1129 			cyttsp4_queue_startup_(cd);
1130 			goto cyttsp4_irq_exit;
1131 		}
1132 
1133 		/*
1134 		 * do not wake thread on this switch since
1135 		 * it is possible to get an early heartbeat
1136 		 * prior to performing the reset
1137 		 */
1138 		cd->mode = cur_mode;
1139 
1140 		goto cyttsp4_irq_exit;
1141 	}
1142 
1143 	switch (mode[0] & CY_HST_MODE) {
1144 	case CY_HST_OPERATE:
1145 		cur_mode = CY_MODE_OPERATIONAL;
1146 		dev_vdbg(dev, "%s: operational\n", __func__);
1147 		break;
1148 	case CY_HST_CAT:
1149 		cur_mode = CY_MODE_CAT;
1150 		dev_vdbg(dev, "%s: CaT\n", __func__);
1151 		break;
1152 	case CY_HST_SYSINFO:
1153 		cur_mode = CY_MODE_SYSINFO;
1154 		dev_vdbg(dev, "%s: sysinfo\n", __func__);
1155 		break;
1156 	default:
1157 		cur_mode = CY_MODE_UNKNOWN;
1158 		dev_err(dev, "%s: unknown HST mode 0x%02X\n", __func__,
1159 			mode[0]);
1160 		break;
1161 	}
1162 
1163 	/* Check whether this IRQ should be ignored (internal) */
1164 	if (cd->int_status & CY_INT_IGNORE) {
1165 		dev_vdbg(dev, "%s: Ignoring IRQ\n", __func__);
1166 		goto cyttsp4_irq_exit;
1167 	}
1168 
1169 	/* Check for wake up interrupt */
1170 	if (cd->int_status & CY_INT_AWAKE) {
1171 		cd->int_status &= ~CY_INT_AWAKE;
1172 		wake_up(&cd->wait_q);
1173 		dev_vdbg(dev, "%s: Received wake up interrupt\n", __func__);
1174 		goto cyttsp4_irq_handshake;
1175 	}
1176 
1177 	/* Expecting mode change interrupt */
1178 	if ((cd->int_status & CY_INT_MODE_CHANGE)
1179 			&& (mode[0] & CY_HST_MODE_CHANGE) == 0) {
1180 		cd->int_status &= ~CY_INT_MODE_CHANGE;
1181 		dev_dbg(dev, "%s: finish mode switch m=%d -> m=%d\n",
1182 				__func__, cd->mode, cur_mode);
1183 		cd->mode = cur_mode;
1184 		wake_up(&cd->wait_q);
1185 		goto cyttsp4_irq_handshake;
1186 	}
1187 
1188 	/* compare current core mode to current device mode */
1189 	dev_vdbg(dev, "%s: cd->mode=%d cur_mode=%d\n",
1190 			__func__, cd->mode, cur_mode);
1191 	if ((mode[0] & CY_HST_MODE_CHANGE) == 0 && cd->mode != cur_mode) {
1192 		/* Unexpected mode change occurred */
1193 		dev_err(dev, "%s %d->%d 0x%x\n", __func__, cd->mode,
1194 				cur_mode, cd->int_status);
1195 		dev_dbg(dev, "%s: Unexpected mode change, startup\n",
1196 				__func__);
1197 		cyttsp4_queue_startup_(cd);
1198 		goto cyttsp4_irq_exit;
1199 	}
1200 
1201 	/* Expecting command complete interrupt */
1202 	dev_vdbg(dev, "%s: command byte:0x%x\n", __func__, mode[cmd_ofs]);
1203 	if ((cd->int_status & CY_INT_EXEC_CMD)
1204 			&& mode[cmd_ofs] & CY_CMD_COMPLETE) {
1205 		cd->int_status &= ~CY_INT_EXEC_CMD;
1206 		dev_vdbg(dev, "%s: Received command complete interrupt\n",
1207 				__func__);
1208 		wake_up(&cd->wait_q);
1209 		/*
1210 		 * It is possible to receive a single interrupt for
1211 		 * command complete and touch/button status report.
1212 		 * Continue processing for a possible status report.
1213 		 */
1214 	}
1215 
1216 	/* This should be status report, read status regs */
1217 	if (cd->mode == CY_MODE_OPERATIONAL) {
1218 		dev_vdbg(dev, "%s: Read status registers\n", __func__);
1219 		rc = cyttsp4_load_status_regs(cd);
1220 		if (rc < 0)
1221 			dev_err(dev, "%s: fail read mode regs r=%d\n",
1222 				__func__, rc);
1223 	}
1224 
1225 	cyttsp4_mt_attention(cd);
1226 
1227 cyttsp4_irq_handshake:
1228 	/* handshake the event */
1229 	dev_vdbg(dev, "%s: Handshake mode=0x%02X r=%d\n",
1230 			__func__, mode[0], rc);
1231 	rc = cyttsp4_handshake(cd, mode[0]);
1232 	if (rc < 0)
1233 		dev_err(dev, "%s: Fail handshake mode=0x%02X r=%d\n",
1234 				__func__, mode[0], rc);
1235 
1236 	/*
1237 	 * a non-zero udelay period is required for using
1238 	 * IRQF_TRIGGER_LOW in order to delay until the
1239 	 * device completes isr deassert
1240 	 */
1241 	udelay(cd->cpdata->level_irq_udelay);
1242 
1243 cyttsp4_irq_exit:
1244 	mutex_unlock(&cd->system_lock);
1245 	return IRQ_HANDLED;
1246 }
1247 
1248 static void cyttsp4_start_wd_timer(struct cyttsp4 *cd)
1249 {
1250 	if (!CY_WATCHDOG_TIMEOUT)
1251 		return;
1252 
1253 	mod_timer(&cd->watchdog_timer, jiffies +
1254 			msecs_to_jiffies(CY_WATCHDOG_TIMEOUT));
1255 }
1256 
1257 static void cyttsp4_stop_wd_timer(struct cyttsp4 *cd)
1258 {
1259 	if (!CY_WATCHDOG_TIMEOUT)
1260 		return;
1261 
1262 	/*
1263 	 * Ensure we wait until the watchdog timer
1264 	 * running on a different CPU finishes
1265 	 */
1266 	del_timer_sync(&cd->watchdog_timer);
1267 	cancel_work_sync(&cd->watchdog_work);
1268 	del_timer_sync(&cd->watchdog_timer);
1269 }
1270 
1271 static void cyttsp4_watchdog_timer(struct timer_list *t)
1272 {
1273 	struct cyttsp4 *cd = from_timer(cd, t, watchdog_timer);
1274 
1275 	dev_vdbg(cd->dev, "%s: Watchdog timer triggered\n", __func__);
1276 
1277 	schedule_work(&cd->watchdog_work);
1278 
1279 	return;
1280 }
1281 
1282 static int cyttsp4_request_exclusive(struct cyttsp4 *cd, void *ownptr,
1283 		int timeout_ms)
1284 {
1285 	int t = msecs_to_jiffies(timeout_ms);
1286 	bool with_timeout = (timeout_ms != 0);
1287 
1288 	mutex_lock(&cd->system_lock);
1289 	if (!cd->exclusive_dev && cd->exclusive_waits == 0) {
1290 		cd->exclusive_dev = ownptr;
1291 		goto exit;
1292 	}
1293 
1294 	cd->exclusive_waits++;
1295 wait:
1296 	mutex_unlock(&cd->system_lock);
1297 	if (with_timeout) {
1298 		t = wait_event_timeout(cd->wait_q, !cd->exclusive_dev, t);
1299 		if (IS_TMO(t)) {
1300 			dev_err(cd->dev, "%s: tmo waiting exclusive access\n",
1301 				__func__);
1302 			mutex_lock(&cd->system_lock);
1303 			cd->exclusive_waits--;
1304 			mutex_unlock(&cd->system_lock);
1305 			return -ETIME;
1306 		}
1307 	} else {
1308 		wait_event(cd->wait_q, !cd->exclusive_dev);
1309 	}
1310 	mutex_lock(&cd->system_lock);
1311 	if (cd->exclusive_dev)
1312 		goto wait;
1313 	cd->exclusive_dev = ownptr;
1314 	cd->exclusive_waits--;
1315 exit:
1316 	mutex_unlock(&cd->system_lock);
1317 
1318 	return 0;
1319 }
1320 
1321 /*
1322  * returns error if was not owned
1323  */
1324 static int cyttsp4_release_exclusive(struct cyttsp4 *cd, void *ownptr)
1325 {
1326 	mutex_lock(&cd->system_lock);
1327 	if (cd->exclusive_dev != ownptr) {
1328 		mutex_unlock(&cd->system_lock);
1329 		return -EINVAL;
1330 	}
1331 
1332 	dev_vdbg(cd->dev, "%s: exclusive_dev %p freed\n",
1333 		__func__, cd->exclusive_dev);
1334 	cd->exclusive_dev = NULL;
1335 	wake_up(&cd->wait_q);
1336 	mutex_unlock(&cd->system_lock);
1337 	return 0;
1338 }
1339 
1340 static int cyttsp4_wait_bl_heartbeat(struct cyttsp4 *cd)
1341 {
1342 	long t;
1343 	int rc = 0;
1344 
1345 	/* wait heartbeat */
1346 	dev_vdbg(cd->dev, "%s: wait heartbeat...\n", __func__);
1347 	t = wait_event_timeout(cd->wait_q, cd->mode == CY_MODE_BOOTLOADER,
1348 			msecs_to_jiffies(CY_CORE_RESET_AND_WAIT_TIMEOUT));
1349 	if (IS_TMO(t)) {
1350 		dev_err(cd->dev, "%s: tmo waiting bl heartbeat cd->mode=%d\n",
1351 			__func__, cd->mode);
1352 		rc = -ETIME;
1353 	}
1354 
1355 	return rc;
1356 }
1357 
1358 static int cyttsp4_wait_sysinfo_mode(struct cyttsp4 *cd)
1359 {
1360 	long t;
1361 
1362 	dev_vdbg(cd->dev, "%s: wait sysinfo...\n", __func__);
1363 
1364 	t = wait_event_timeout(cd->wait_q, cd->mode == CY_MODE_SYSINFO,
1365 			msecs_to_jiffies(CY_CORE_MODE_CHANGE_TIMEOUT));
1366 	if (IS_TMO(t)) {
1367 		dev_err(cd->dev, "%s: tmo waiting exit bl cd->mode=%d\n",
1368 			__func__, cd->mode);
1369 		mutex_lock(&cd->system_lock);
1370 		cd->int_status &= ~CY_INT_MODE_CHANGE;
1371 		mutex_unlock(&cd->system_lock);
1372 		return -ETIME;
1373 	}
1374 
1375 	return 0;
1376 }
1377 
1378 static int cyttsp4_reset_and_wait(struct cyttsp4 *cd)
1379 {
1380 	int rc;
1381 
1382 	/* reset hardware */
1383 	mutex_lock(&cd->system_lock);
1384 	dev_dbg(cd->dev, "%s: reset hw...\n", __func__);
1385 	rc = cyttsp4_hw_reset(cd);
1386 	cd->mode = CY_MODE_UNKNOWN;
1387 	mutex_unlock(&cd->system_lock);
1388 	if (rc < 0) {
1389 		dev_err(cd->dev, "%s:Fail hw reset r=%d\n", __func__, rc);
1390 		return rc;
1391 	}
1392 
1393 	return cyttsp4_wait_bl_heartbeat(cd);
1394 }
1395 
1396 /*
1397  * returns err if refused or timeout; block until mode change complete
1398  * bit is set (mode change interrupt)
1399  */
1400 static int cyttsp4_set_mode(struct cyttsp4 *cd, int new_mode)
1401 {
1402 	u8 new_dev_mode;
1403 	u8 mode;
1404 	long t;
1405 	int rc;
1406 
1407 	switch (new_mode) {
1408 	case CY_MODE_OPERATIONAL:
1409 		new_dev_mode = CY_HST_OPERATE;
1410 		break;
1411 	case CY_MODE_SYSINFO:
1412 		new_dev_mode = CY_HST_SYSINFO;
1413 		break;
1414 	case CY_MODE_CAT:
1415 		new_dev_mode = CY_HST_CAT;
1416 		break;
1417 	default:
1418 		dev_err(cd->dev, "%s: invalid mode: %02X(%d)\n",
1419 			__func__, new_mode, new_mode);
1420 		return -EINVAL;
1421 	}
1422 
1423 	/* change mode */
1424 	dev_dbg(cd->dev, "%s: %s=%p new_dev_mode=%02X new_mode=%d\n",
1425 			__func__, "have exclusive", cd->exclusive_dev,
1426 			new_dev_mode, new_mode);
1427 
1428 	mutex_lock(&cd->system_lock);
1429 	rc = cyttsp4_adap_read(cd, CY_REG_BASE, sizeof(mode), &mode);
1430 	if (rc < 0) {
1431 		mutex_unlock(&cd->system_lock);
1432 		dev_err(cd->dev, "%s: Fail read mode r=%d\n",
1433 			__func__, rc);
1434 		goto exit;
1435 	}
1436 
1437 	/* Clear device mode bits and set to new mode */
1438 	mode &= ~CY_HST_MODE;
1439 	mode |= new_dev_mode | CY_HST_MODE_CHANGE;
1440 
1441 	cd->int_status |= CY_INT_MODE_CHANGE;
1442 	rc = cyttsp4_adap_write(cd, CY_REG_BASE, sizeof(mode), &mode);
1443 	mutex_unlock(&cd->system_lock);
1444 	if (rc < 0) {
1445 		dev_err(cd->dev, "%s: Fail write mode change r=%d\n",
1446 				__func__, rc);
1447 		goto exit;
1448 	}
1449 
1450 	/* wait for mode change done interrupt */
1451 	t = wait_event_timeout(cd->wait_q,
1452 			(cd->int_status & CY_INT_MODE_CHANGE) == 0,
1453 			msecs_to_jiffies(CY_CORE_MODE_CHANGE_TIMEOUT));
1454 	dev_dbg(cd->dev, "%s: back from wait t=%ld cd->mode=%d\n",
1455 			__func__, t, cd->mode);
1456 
1457 	if (IS_TMO(t)) {
1458 		dev_err(cd->dev, "%s: %s\n", __func__,
1459 				"tmo waiting mode change");
1460 		mutex_lock(&cd->system_lock);
1461 		cd->int_status &= ~CY_INT_MODE_CHANGE;
1462 		mutex_unlock(&cd->system_lock);
1463 		rc = -EINVAL;
1464 	}
1465 
1466 exit:
1467 	return rc;
1468 }
1469 
1470 static void cyttsp4_watchdog_work(struct work_struct *work)
1471 {
1472 	struct cyttsp4 *cd =
1473 		container_of(work, struct cyttsp4, watchdog_work);
1474 	u8 *mode;
1475 	int retval;
1476 
1477 	mutex_lock(&cd->system_lock);
1478 	retval = cyttsp4_load_status_regs(cd);
1479 	if (retval < 0) {
1480 		dev_err(cd->dev,
1481 			"%s: failed to access device in watchdog timer r=%d\n",
1482 			__func__, retval);
1483 		cyttsp4_queue_startup_(cd);
1484 		goto cyttsp4_timer_watchdog_exit_error;
1485 	}
1486 	mode = &cd->sysinfo.xy_mode[CY_REG_BASE];
1487 	if (IS_BOOTLOADER(mode[0], mode[1])) {
1488 		dev_err(cd->dev,
1489 			"%s: device found in bootloader mode when operational mode\n",
1490 			__func__);
1491 		cyttsp4_queue_startup_(cd);
1492 		goto cyttsp4_timer_watchdog_exit_error;
1493 	}
1494 
1495 	cyttsp4_start_wd_timer(cd);
1496 cyttsp4_timer_watchdog_exit_error:
1497 	mutex_unlock(&cd->system_lock);
1498 	return;
1499 }
1500 
1501 static int cyttsp4_core_sleep_(struct cyttsp4 *cd)
1502 {
1503 	enum cyttsp4_sleep_state ss = SS_SLEEP_ON;
1504 	enum cyttsp4_int_state int_status = CY_INT_IGNORE;
1505 	int rc = 0;
1506 	u8 mode[2];
1507 
1508 	/* Already in sleep mode? */
1509 	mutex_lock(&cd->system_lock);
1510 	if (cd->sleep_state == SS_SLEEP_ON) {
1511 		mutex_unlock(&cd->system_lock);
1512 		return 0;
1513 	}
1514 	cd->sleep_state = SS_SLEEPING;
1515 	mutex_unlock(&cd->system_lock);
1516 
1517 	cyttsp4_stop_wd_timer(cd);
1518 
1519 	/* Wait until currently running IRQ handler exits and disable IRQ */
1520 	disable_irq(cd->irq);
1521 
1522 	dev_vdbg(cd->dev, "%s: write DEEP SLEEP...\n", __func__);
1523 	mutex_lock(&cd->system_lock);
1524 	rc = cyttsp4_adap_read(cd, CY_REG_BASE, sizeof(mode), &mode);
1525 	if (rc) {
1526 		mutex_unlock(&cd->system_lock);
1527 		dev_err(cd->dev, "%s: Fail read adapter r=%d\n", __func__, rc);
1528 		goto error;
1529 	}
1530 
1531 	if (IS_BOOTLOADER(mode[0], mode[1])) {
1532 		mutex_unlock(&cd->system_lock);
1533 		dev_err(cd->dev, "%s: Device in BOOTLOADER mode.\n", __func__);
1534 		rc = -EINVAL;
1535 		goto error;
1536 	}
1537 
1538 	mode[0] |= CY_HST_SLEEP;
1539 	rc = cyttsp4_adap_write(cd, CY_REG_BASE, sizeof(mode[0]), &mode[0]);
1540 	mutex_unlock(&cd->system_lock);
1541 	if (rc) {
1542 		dev_err(cd->dev, "%s: Fail write adapter r=%d\n", __func__, rc);
1543 		goto error;
1544 	}
1545 	dev_vdbg(cd->dev, "%s: write DEEP SLEEP succeeded\n", __func__);
1546 
1547 	if (cd->cpdata->power) {
1548 		dev_dbg(cd->dev, "%s: Power down HW\n", __func__);
1549 		rc = cd->cpdata->power(cd->cpdata, 0, cd->dev, &cd->ignore_irq);
1550 	} else {
1551 		dev_dbg(cd->dev, "%s: No power function\n", __func__);
1552 		rc = 0;
1553 	}
1554 	if (rc < 0) {
1555 		dev_err(cd->dev, "%s: HW Power down fails r=%d\n",
1556 				__func__, rc);
1557 		goto error;
1558 	}
1559 
1560 	/* Give time to FW to sleep */
1561 	msleep(50);
1562 
1563 	goto exit;
1564 
1565 error:
1566 	ss = SS_SLEEP_OFF;
1567 	int_status = CY_INT_NONE;
1568 	cyttsp4_start_wd_timer(cd);
1569 
1570 exit:
1571 	mutex_lock(&cd->system_lock);
1572 	cd->sleep_state = ss;
1573 	cd->int_status |= int_status;
1574 	mutex_unlock(&cd->system_lock);
1575 	enable_irq(cd->irq);
1576 	return rc;
1577 }
1578 
1579 static int cyttsp4_startup_(struct cyttsp4 *cd)
1580 {
1581 	int retry = CY_CORE_STARTUP_RETRY_COUNT;
1582 	int rc;
1583 
1584 	cyttsp4_stop_wd_timer(cd);
1585 
1586 reset:
1587 	if (retry != CY_CORE_STARTUP_RETRY_COUNT)
1588 		dev_dbg(cd->dev, "%s: Retry %d\n", __func__,
1589 			CY_CORE_STARTUP_RETRY_COUNT - retry);
1590 
1591 	/* reset hardware and wait for heartbeat */
1592 	rc = cyttsp4_reset_and_wait(cd);
1593 	if (rc < 0) {
1594 		dev_err(cd->dev, "%s: Error on h/w reset r=%d\n", __func__, rc);
1595 		if (retry--)
1596 			goto reset;
1597 		goto exit;
1598 	}
1599 
1600 	/* exit bl into sysinfo mode */
1601 	dev_vdbg(cd->dev, "%s: write exit ldr...\n", __func__);
1602 	mutex_lock(&cd->system_lock);
1603 	cd->int_status &= ~CY_INT_IGNORE;
1604 	cd->int_status |= CY_INT_MODE_CHANGE;
1605 
1606 	rc = cyttsp4_adap_write(cd, CY_REG_BASE, sizeof(ldr_exit),
1607 			(u8 *)ldr_exit);
1608 	mutex_unlock(&cd->system_lock);
1609 	if (rc < 0) {
1610 		dev_err(cd->dev, "%s: Fail write r=%d\n", __func__, rc);
1611 		if (retry--)
1612 			goto reset;
1613 		goto exit;
1614 	}
1615 
1616 	rc = cyttsp4_wait_sysinfo_mode(cd);
1617 	if (rc < 0) {
1618 		u8 buf[sizeof(ldr_err_app)];
1619 		int rc1;
1620 
1621 		/* Check for invalid/corrupted touch application */
1622 		rc1 = cyttsp4_adap_read(cd, CY_REG_BASE, sizeof(ldr_err_app),
1623 				buf);
1624 		if (rc1) {
1625 			dev_err(cd->dev, "%s: Fail read r=%d\n", __func__, rc1);
1626 		} else if (!memcmp(buf, ldr_err_app, sizeof(ldr_err_app))) {
1627 			dev_err(cd->dev, "%s: Error launching touch application\n",
1628 				__func__);
1629 			mutex_lock(&cd->system_lock);
1630 			cd->invalid_touch_app = true;
1631 			mutex_unlock(&cd->system_lock);
1632 			goto exit_no_wd;
1633 		}
1634 
1635 		if (retry--)
1636 			goto reset;
1637 		goto exit;
1638 	}
1639 
1640 	mutex_lock(&cd->system_lock);
1641 	cd->invalid_touch_app = false;
1642 	mutex_unlock(&cd->system_lock);
1643 
1644 	/* read sysinfo data */
1645 	dev_vdbg(cd->dev, "%s: get sysinfo regs..\n", __func__);
1646 	rc = cyttsp4_get_sysinfo_regs(cd);
1647 	if (rc < 0) {
1648 		dev_err(cd->dev, "%s: failed to get sysinfo regs rc=%d\n",
1649 			__func__, rc);
1650 		if (retry--)
1651 			goto reset;
1652 		goto exit;
1653 	}
1654 
1655 	rc = cyttsp4_set_mode(cd, CY_MODE_OPERATIONAL);
1656 	if (rc < 0) {
1657 		dev_err(cd->dev, "%s: failed to set mode to operational rc=%d\n",
1658 			__func__, rc);
1659 		if (retry--)
1660 			goto reset;
1661 		goto exit;
1662 	}
1663 
1664 	cyttsp4_lift_all(&cd->md);
1665 
1666 	/* restore to sleep if was suspended */
1667 	mutex_lock(&cd->system_lock);
1668 	if (cd->sleep_state == SS_SLEEP_ON) {
1669 		cd->sleep_state = SS_SLEEP_OFF;
1670 		mutex_unlock(&cd->system_lock);
1671 		cyttsp4_core_sleep_(cd);
1672 		goto exit_no_wd;
1673 	}
1674 	mutex_unlock(&cd->system_lock);
1675 
1676 exit:
1677 	cyttsp4_start_wd_timer(cd);
1678 exit_no_wd:
1679 	return rc;
1680 }
1681 
1682 static int cyttsp4_startup(struct cyttsp4 *cd)
1683 {
1684 	int rc;
1685 
1686 	mutex_lock(&cd->system_lock);
1687 	cd->startup_state = STARTUP_RUNNING;
1688 	mutex_unlock(&cd->system_lock);
1689 
1690 	rc = cyttsp4_request_exclusive(cd, cd->dev,
1691 			CY_CORE_REQUEST_EXCLUSIVE_TIMEOUT);
1692 	if (rc < 0) {
1693 		dev_err(cd->dev, "%s: fail get exclusive ex=%p own=%p\n",
1694 				__func__, cd->exclusive_dev, cd->dev);
1695 		goto exit;
1696 	}
1697 
1698 	rc = cyttsp4_startup_(cd);
1699 
1700 	if (cyttsp4_release_exclusive(cd, cd->dev) < 0)
1701 		/* Don't return fail code, mode is already changed. */
1702 		dev_err(cd->dev, "%s: fail to release exclusive\n", __func__);
1703 	else
1704 		dev_vdbg(cd->dev, "%s: pass release exclusive\n", __func__);
1705 
1706 exit:
1707 	mutex_lock(&cd->system_lock);
1708 	cd->startup_state = STARTUP_NONE;
1709 	mutex_unlock(&cd->system_lock);
1710 
1711 	/* Wake the waiters for end of startup */
1712 	wake_up(&cd->wait_q);
1713 
1714 	return rc;
1715 }
1716 
1717 static void cyttsp4_startup_work_function(struct work_struct *work)
1718 {
1719 	struct cyttsp4 *cd =  container_of(work, struct cyttsp4, startup_work);
1720 	int rc;
1721 
1722 	rc = cyttsp4_startup(cd);
1723 	if (rc < 0)
1724 		dev_err(cd->dev, "%s: Fail queued startup r=%d\n",
1725 			__func__, rc);
1726 }
1727 
1728 static void cyttsp4_free_si_ptrs(struct cyttsp4 *cd)
1729 {
1730 	struct cyttsp4_sysinfo *si = &cd->sysinfo;
1731 
1732 	if (!si)
1733 		return;
1734 
1735 	kfree(si->si_ptrs.cydata);
1736 	kfree(si->si_ptrs.test);
1737 	kfree(si->si_ptrs.pcfg);
1738 	kfree(si->si_ptrs.opcfg);
1739 	kfree(si->si_ptrs.ddata);
1740 	kfree(si->si_ptrs.mdata);
1741 	kfree(si->btn);
1742 	kfree(si->xy_mode);
1743 	kfree(si->xy_data);
1744 	kfree(si->btn_rec_data);
1745 }
1746 
1747 static int cyttsp4_core_sleep(struct cyttsp4 *cd)
1748 {
1749 	int rc;
1750 
1751 	rc = cyttsp4_request_exclusive(cd, cd->dev,
1752 			CY_CORE_SLEEP_REQUEST_EXCLUSIVE_TIMEOUT);
1753 	if (rc < 0) {
1754 		dev_err(cd->dev, "%s: fail get exclusive ex=%p own=%p\n",
1755 				__func__, cd->exclusive_dev, cd->dev);
1756 		return 0;
1757 	}
1758 
1759 	rc = cyttsp4_core_sleep_(cd);
1760 
1761 	if (cyttsp4_release_exclusive(cd, cd->dev) < 0)
1762 		dev_err(cd->dev, "%s: fail to release exclusive\n", __func__);
1763 	else
1764 		dev_vdbg(cd->dev, "%s: pass release exclusive\n", __func__);
1765 
1766 	return rc;
1767 }
1768 
1769 static int cyttsp4_core_wake_(struct cyttsp4 *cd)
1770 {
1771 	struct device *dev = cd->dev;
1772 	int rc;
1773 	u8 mode;
1774 	int t;
1775 
1776 	/* Already woken? */
1777 	mutex_lock(&cd->system_lock);
1778 	if (cd->sleep_state == SS_SLEEP_OFF) {
1779 		mutex_unlock(&cd->system_lock);
1780 		return 0;
1781 	}
1782 	cd->int_status &= ~CY_INT_IGNORE;
1783 	cd->int_status |= CY_INT_AWAKE;
1784 	cd->sleep_state = SS_WAKING;
1785 
1786 	if (cd->cpdata->power) {
1787 		dev_dbg(dev, "%s: Power up HW\n", __func__);
1788 		rc = cd->cpdata->power(cd->cpdata, 1, dev, &cd->ignore_irq);
1789 	} else {
1790 		dev_dbg(dev, "%s: No power function\n", __func__);
1791 		rc = -ENOSYS;
1792 	}
1793 	if (rc < 0) {
1794 		dev_err(dev, "%s: HW Power up fails r=%d\n",
1795 				__func__, rc);
1796 
1797 		/* Initiate a read transaction to wake up */
1798 		cyttsp4_adap_read(cd, CY_REG_BASE, sizeof(mode), &mode);
1799 	} else
1800 		dev_vdbg(cd->dev, "%s: HW power up succeeds\n",
1801 			__func__);
1802 	mutex_unlock(&cd->system_lock);
1803 
1804 	t = wait_event_timeout(cd->wait_q,
1805 			(cd->int_status & CY_INT_AWAKE) == 0,
1806 			msecs_to_jiffies(CY_CORE_WAKEUP_TIMEOUT));
1807 	if (IS_TMO(t)) {
1808 		dev_err(dev, "%s: TMO waiting for wakeup\n", __func__);
1809 		mutex_lock(&cd->system_lock);
1810 		cd->int_status &= ~CY_INT_AWAKE;
1811 		/* Try starting up */
1812 		cyttsp4_queue_startup_(cd);
1813 		mutex_unlock(&cd->system_lock);
1814 	}
1815 
1816 	mutex_lock(&cd->system_lock);
1817 	cd->sleep_state = SS_SLEEP_OFF;
1818 	mutex_unlock(&cd->system_lock);
1819 
1820 	cyttsp4_start_wd_timer(cd);
1821 
1822 	return 0;
1823 }
1824 
1825 static int cyttsp4_core_wake(struct cyttsp4 *cd)
1826 {
1827 	int rc;
1828 
1829 	rc = cyttsp4_request_exclusive(cd, cd->dev,
1830 			CY_CORE_REQUEST_EXCLUSIVE_TIMEOUT);
1831 	if (rc < 0) {
1832 		dev_err(cd->dev, "%s: fail get exclusive ex=%p own=%p\n",
1833 				__func__, cd->exclusive_dev, cd->dev);
1834 		return 0;
1835 	}
1836 
1837 	rc = cyttsp4_core_wake_(cd);
1838 
1839 	if (cyttsp4_release_exclusive(cd, cd->dev) < 0)
1840 		dev_err(cd->dev, "%s: fail to release exclusive\n", __func__);
1841 	else
1842 		dev_vdbg(cd->dev, "%s: pass release exclusive\n", __func__);
1843 
1844 	return rc;
1845 }
1846 
1847 static int cyttsp4_core_suspend(struct device *dev)
1848 {
1849 	struct cyttsp4 *cd = dev_get_drvdata(dev);
1850 	struct cyttsp4_mt_data *md = &cd->md;
1851 	int rc;
1852 
1853 	md->is_suspended = true;
1854 
1855 	rc = cyttsp4_core_sleep(cd);
1856 	if (rc < 0) {
1857 		dev_err(dev, "%s: Error on sleep\n", __func__);
1858 		return -EAGAIN;
1859 	}
1860 	return 0;
1861 }
1862 
1863 static int cyttsp4_core_resume(struct device *dev)
1864 {
1865 	struct cyttsp4 *cd = dev_get_drvdata(dev);
1866 	struct cyttsp4_mt_data *md = &cd->md;
1867 	int rc;
1868 
1869 	md->is_suspended = false;
1870 
1871 	rc = cyttsp4_core_wake(cd);
1872 	if (rc < 0) {
1873 		dev_err(dev, "%s: Error on wake\n", __func__);
1874 		return -EAGAIN;
1875 	}
1876 
1877 	return 0;
1878 }
1879 
1880 EXPORT_GPL_RUNTIME_DEV_PM_OPS(cyttsp4_pm_ops,
1881 			      cyttsp4_core_suspend, cyttsp4_core_resume, NULL);
1882 
1883 static int cyttsp4_mt_open(struct input_dev *input)
1884 {
1885 	pm_runtime_get(input->dev.parent);
1886 	return 0;
1887 }
1888 
1889 static void cyttsp4_mt_close(struct input_dev *input)
1890 {
1891 	struct cyttsp4_mt_data *md = input_get_drvdata(input);
1892 	mutex_lock(&md->report_lock);
1893 	if (!md->is_suspended)
1894 		pm_runtime_put(input->dev.parent);
1895 	mutex_unlock(&md->report_lock);
1896 }
1897 
1898 
1899 static int cyttsp4_setup_input_device(struct cyttsp4 *cd)
1900 {
1901 	struct device *dev = cd->dev;
1902 	struct cyttsp4_mt_data *md = &cd->md;
1903 	int signal = CY_IGNORE_VALUE;
1904 	int max_x, max_y, max_p, min, max;
1905 	int max_x_tmp, max_y_tmp;
1906 	int i;
1907 	int rc;
1908 
1909 	dev_vdbg(dev, "%s: Initialize event signals\n", __func__);
1910 	__set_bit(EV_ABS, md->input->evbit);
1911 	__set_bit(EV_REL, md->input->evbit);
1912 	__set_bit(EV_KEY, md->input->evbit);
1913 
1914 	max_x_tmp = md->si->si_ofs.max_x;
1915 	max_y_tmp = md->si->si_ofs.max_y;
1916 
1917 	/* get maximum values from the sysinfo data */
1918 	if (md->pdata->flags & CY_FLAG_FLIP) {
1919 		max_x = max_y_tmp - 1;
1920 		max_y = max_x_tmp - 1;
1921 	} else {
1922 		max_x = max_x_tmp - 1;
1923 		max_y = max_y_tmp - 1;
1924 	}
1925 	max_p = md->si->si_ofs.max_p;
1926 
1927 	/* set event signal capabilities */
1928 	for (i = 0; i < (md->pdata->frmwrk->size / CY_NUM_ABS_SET); i++) {
1929 		signal = md->pdata->frmwrk->abs
1930 			[(i * CY_NUM_ABS_SET) + CY_SIGNAL_OST];
1931 		if (signal != CY_IGNORE_VALUE) {
1932 			__set_bit(signal, md->input->absbit);
1933 			min = md->pdata->frmwrk->abs
1934 				[(i * CY_NUM_ABS_SET) + CY_MIN_OST];
1935 			max = md->pdata->frmwrk->abs
1936 				[(i * CY_NUM_ABS_SET) + CY_MAX_OST];
1937 			if (i == CY_ABS_ID_OST) {
1938 				/* shift track ids down to start at 0 */
1939 				max = max - min;
1940 				min = min - min;
1941 			} else if (i == CY_ABS_X_OST)
1942 				max = max_x;
1943 			else if (i == CY_ABS_Y_OST)
1944 				max = max_y;
1945 			else if (i == CY_ABS_P_OST)
1946 				max = max_p;
1947 			input_set_abs_params(md->input, signal, min, max,
1948 				md->pdata->frmwrk->abs
1949 				[(i * CY_NUM_ABS_SET) + CY_FUZZ_OST],
1950 				md->pdata->frmwrk->abs
1951 				[(i * CY_NUM_ABS_SET) + CY_FLAT_OST]);
1952 			dev_dbg(dev, "%s: register signal=%02X min=%d max=%d\n",
1953 				__func__, signal, min, max);
1954 			if ((i == CY_ABS_ID_OST) &&
1955 				(md->si->si_ofs.tch_rec_size <
1956 				CY_TMA4XX_TCH_REC_SIZE))
1957 				break;
1958 		}
1959 	}
1960 
1961 	input_mt_init_slots(md->input, md->si->si_ofs.tch_abs[CY_TCH_T].max,
1962 			INPUT_MT_DIRECT);
1963 	rc = input_register_device(md->input);
1964 	if (rc < 0)
1965 		dev_err(dev, "%s: Error, failed register input device r=%d\n",
1966 			__func__, rc);
1967 	return rc;
1968 }
1969 
1970 static int cyttsp4_mt_probe(struct cyttsp4 *cd)
1971 {
1972 	struct device *dev = cd->dev;
1973 	struct cyttsp4_mt_data *md = &cd->md;
1974 	struct cyttsp4_mt_platform_data *pdata = cd->pdata->mt_pdata;
1975 	int rc = 0;
1976 
1977 	mutex_init(&md->report_lock);
1978 	md->pdata = pdata;
1979 	/* Create the input device and register it. */
1980 	dev_vdbg(dev, "%s: Create the input device and register it\n",
1981 		__func__);
1982 	md->input = input_allocate_device();
1983 	if (md->input == NULL) {
1984 		dev_err(dev, "%s: Error, failed to allocate input device\n",
1985 			__func__);
1986 		rc = -ENOSYS;
1987 		goto error_alloc_failed;
1988 	}
1989 
1990 	md->input->name = pdata->inp_dev_name;
1991 	scnprintf(md->phys, sizeof(md->phys)-1, "%s", dev_name(dev));
1992 	md->input->phys = md->phys;
1993 	md->input->id.bustype = cd->bus_ops->bustype;
1994 	md->input->dev.parent = dev;
1995 	md->input->open = cyttsp4_mt_open;
1996 	md->input->close = cyttsp4_mt_close;
1997 	input_set_drvdata(md->input, md);
1998 
1999 	/* get sysinfo */
2000 	md->si = &cd->sysinfo;
2001 
2002 	rc = cyttsp4_setup_input_device(cd);
2003 	if (rc)
2004 		goto error_init_input;
2005 
2006 	return 0;
2007 
2008 error_init_input:
2009 	input_free_device(md->input);
2010 error_alloc_failed:
2011 	dev_err(dev, "%s failed.\n", __func__);
2012 	return rc;
2013 }
2014 
2015 struct cyttsp4 *cyttsp4_probe(const struct cyttsp4_bus_ops *ops,
2016 		struct device *dev, u16 irq, size_t xfer_buf_size)
2017 {
2018 	struct cyttsp4 *cd;
2019 	struct cyttsp4_platform_data *pdata = dev_get_platdata(dev);
2020 	unsigned long irq_flags;
2021 	int rc = 0;
2022 
2023 	if (!pdata || !pdata->core_pdata || !pdata->mt_pdata) {
2024 		dev_err(dev, "%s: Missing platform data\n", __func__);
2025 		rc = -ENODEV;
2026 		goto error_no_pdata;
2027 	}
2028 
2029 	cd = kzalloc(sizeof(*cd), GFP_KERNEL);
2030 	if (!cd) {
2031 		dev_err(dev, "%s: Error, kzalloc\n", __func__);
2032 		rc = -ENOMEM;
2033 		goto error_alloc_data;
2034 	}
2035 
2036 	cd->xfer_buf = kzalloc(xfer_buf_size, GFP_KERNEL);
2037 	if (!cd->xfer_buf) {
2038 		dev_err(dev, "%s: Error, kzalloc\n", __func__);
2039 		rc = -ENOMEM;
2040 		goto error_free_cd;
2041 	}
2042 
2043 	/* Initialize device info */
2044 	cd->dev = dev;
2045 	cd->pdata = pdata;
2046 	cd->cpdata = pdata->core_pdata;
2047 	cd->bus_ops = ops;
2048 
2049 	/* Initialize mutexes and spinlocks */
2050 	mutex_init(&cd->system_lock);
2051 	mutex_init(&cd->adap_lock);
2052 
2053 	/* Initialize wait queue */
2054 	init_waitqueue_head(&cd->wait_q);
2055 
2056 	/* Initialize works */
2057 	INIT_WORK(&cd->startup_work, cyttsp4_startup_work_function);
2058 	INIT_WORK(&cd->watchdog_work, cyttsp4_watchdog_work);
2059 
2060 	/* Initialize IRQ */
2061 	cd->irq = gpio_to_irq(cd->cpdata->irq_gpio);
2062 	if (cd->irq < 0) {
2063 		rc = -EINVAL;
2064 		goto error_free_xfer;
2065 	}
2066 
2067 	dev_set_drvdata(dev, cd);
2068 
2069 	/* Call platform init function */
2070 	if (cd->cpdata->init) {
2071 		dev_dbg(cd->dev, "%s: Init HW\n", __func__);
2072 		rc = cd->cpdata->init(cd->cpdata, 1, cd->dev);
2073 	} else {
2074 		dev_dbg(cd->dev, "%s: No HW INIT function\n", __func__);
2075 		rc = 0;
2076 	}
2077 	if (rc < 0)
2078 		dev_err(cd->dev, "%s: HW Init fail r=%d\n", __func__, rc);
2079 
2080 	dev_dbg(dev, "%s: initialize threaded irq=%d\n", __func__, cd->irq);
2081 	if (cd->cpdata->level_irq_udelay > 0)
2082 		/* use level triggered interrupts */
2083 		irq_flags = IRQF_TRIGGER_LOW | IRQF_ONESHOT;
2084 	else
2085 		/* use edge triggered interrupts */
2086 		irq_flags = IRQF_TRIGGER_FALLING | IRQF_ONESHOT;
2087 
2088 	rc = request_threaded_irq(cd->irq, NULL, cyttsp4_irq, irq_flags,
2089 		dev_name(dev), cd);
2090 	if (rc < 0) {
2091 		dev_err(dev, "%s: Error, could not request irq\n", __func__);
2092 		goto error_request_irq;
2093 	}
2094 
2095 	/* Setup watchdog timer */
2096 	timer_setup(&cd->watchdog_timer, cyttsp4_watchdog_timer, 0);
2097 
2098 	/*
2099 	 * call startup directly to ensure that the device
2100 	 * is tested before leaving the probe
2101 	 */
2102 	rc = cyttsp4_startup(cd);
2103 
2104 	/* Do not fail probe if startup fails but the device is detected */
2105 	if (rc < 0 && cd->mode == CY_MODE_UNKNOWN) {
2106 		dev_err(cd->dev, "%s: Fail initial startup r=%d\n",
2107 			__func__, rc);
2108 		goto error_startup;
2109 	}
2110 
2111 	rc = cyttsp4_mt_probe(cd);
2112 	if (rc < 0) {
2113 		dev_err(dev, "%s: Error, fail mt probe\n", __func__);
2114 		goto error_startup;
2115 	}
2116 
2117 	pm_runtime_enable(dev);
2118 
2119 	return cd;
2120 
2121 error_startup:
2122 	cancel_work_sync(&cd->startup_work);
2123 	cyttsp4_stop_wd_timer(cd);
2124 	pm_runtime_disable(dev);
2125 	cyttsp4_free_si_ptrs(cd);
2126 	free_irq(cd->irq, cd);
2127 error_request_irq:
2128 	if (cd->cpdata->init)
2129 		cd->cpdata->init(cd->cpdata, 0, dev);
2130 error_free_xfer:
2131 	kfree(cd->xfer_buf);
2132 error_free_cd:
2133 	kfree(cd);
2134 error_alloc_data:
2135 error_no_pdata:
2136 	dev_err(dev, "%s failed.\n", __func__);
2137 	return ERR_PTR(rc);
2138 }
2139 EXPORT_SYMBOL_GPL(cyttsp4_probe);
2140 
2141 static void cyttsp4_mt_release(struct cyttsp4_mt_data *md)
2142 {
2143 	input_unregister_device(md->input);
2144 	input_set_drvdata(md->input, NULL);
2145 }
2146 
2147 int cyttsp4_remove(struct cyttsp4 *cd)
2148 {
2149 	struct device *dev = cd->dev;
2150 
2151 	cyttsp4_mt_release(&cd->md);
2152 
2153 	/*
2154 	 * Suspend the device before freeing the startup_work and stopping
2155 	 * the watchdog since sleep function restarts watchdog on failure
2156 	 */
2157 	pm_runtime_suspend(dev);
2158 	pm_runtime_disable(dev);
2159 
2160 	cancel_work_sync(&cd->startup_work);
2161 
2162 	cyttsp4_stop_wd_timer(cd);
2163 
2164 	free_irq(cd->irq, cd);
2165 	if (cd->cpdata->init)
2166 		cd->cpdata->init(cd->cpdata, 0, dev);
2167 	cyttsp4_free_si_ptrs(cd);
2168 	kfree(cd);
2169 	return 0;
2170 }
2171 EXPORT_SYMBOL_GPL(cyttsp4_remove);
2172 
2173 MODULE_LICENSE("GPL");
2174 MODULE_DESCRIPTION("Cypress TrueTouch(R) Standard touchscreen core driver");
2175 MODULE_AUTHOR("Cypress");
2176