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