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
33static 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
47static const u8 ldr_exit[] = {
48	0xFF, 0x01, 0x3B, 0x00, 0x00, 0x4F, 0x6D, 0x17
49};
50
51static const u8 ldr_err_app[] = {
52	0x01, 0x02, 0x00, 0x00, 0x55, 0xDD, 0x17
53};
54
55static inline size_t merge_bytes(u8 high, u8 low)
56{
57	return (high << 8) + low;
58}
59
60#ifdef VERBOSE_DEBUG
61static 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
84static 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
102static 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
122static 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
134static 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
145static 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 */
158static int cyttsp4_bits_2_bytes(unsigned int nbits, size_t *max)
159{
160	*max = 1UL << nbits;
161	return (nbits + 7) / 8;
162}
163
164static 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
200static 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
279static 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
338static 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
386static 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
486static 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
513static 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
540static 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
593static 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
618static 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
683static 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
739static 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
751static 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
765static 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
778static 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
803static 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
853static 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
867static 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
937cyttsp4_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 */
967static 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
1049cyttsp4_xy_worker_exit:
1050	return rc;
1051}
1052
1053static 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
1077static 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
1227cyttsp4_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
1243cyttsp4_irq_exit:
1244	mutex_unlock(&cd->system_lock);
1245	return IRQ_HANDLED;
1246}
1247
1248static 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
1257static 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
1271static 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
1282static 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++;
1295wait:
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--;
1315exit:
1316	mutex_unlock(&cd->system_lock);
1317
1318	return 0;
1319}
1320
1321/*
1322 * returns error if was not owned
1323 */
1324static 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
1340static 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
1358static 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
1378static 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 */
1400static 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
1466exit:
1467	return rc;
1468}
1469
1470static 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);
1496cyttsp4_timer_watchdog_exit_error:
1497	mutex_unlock(&cd->system_lock);
1498	return;
1499}
1500
1501static 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
1565error:
1566	ss = SS_SLEEP_OFF;
1567	int_status = CY_INT_NONE;
1568	cyttsp4_start_wd_timer(cd);
1569
1570exit:
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
1579static 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
1586reset:
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
1676exit:
1677	cyttsp4_start_wd_timer(cd);
1678exit_no_wd:
1679	return rc;
1680}
1681
1682static 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
1706exit:
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
1717static 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
1728static 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#ifdef CONFIG_PM
1748static int cyttsp4_core_sleep(struct cyttsp4 *cd)
1749{
1750	int rc;
1751
1752	rc = cyttsp4_request_exclusive(cd, cd->dev,
1753			CY_CORE_SLEEP_REQUEST_EXCLUSIVE_TIMEOUT);
1754	if (rc < 0) {
1755		dev_err(cd->dev, "%s: fail get exclusive ex=%p own=%p\n",
1756				__func__, cd->exclusive_dev, cd->dev);
1757		return 0;
1758	}
1759
1760	rc = cyttsp4_core_sleep_(cd);
1761
1762	if (cyttsp4_release_exclusive(cd, cd->dev) < 0)
1763		dev_err(cd->dev, "%s: fail to release exclusive\n", __func__);
1764	else
1765		dev_vdbg(cd->dev, "%s: pass release exclusive\n", __func__);
1766
1767	return rc;
1768}
1769
1770static int cyttsp4_core_wake_(struct cyttsp4 *cd)
1771{
1772	struct device *dev = cd->dev;
1773	int rc;
1774	u8 mode;
1775	int t;
1776
1777	/* Already woken? */
1778	mutex_lock(&cd->system_lock);
1779	if (cd->sleep_state == SS_SLEEP_OFF) {
1780		mutex_unlock(&cd->system_lock);
1781		return 0;
1782	}
1783	cd->int_status &= ~CY_INT_IGNORE;
1784	cd->int_status |= CY_INT_AWAKE;
1785	cd->sleep_state = SS_WAKING;
1786
1787	if (cd->cpdata->power) {
1788		dev_dbg(dev, "%s: Power up HW\n", __func__);
1789		rc = cd->cpdata->power(cd->cpdata, 1, dev, &cd->ignore_irq);
1790	} else {
1791		dev_dbg(dev, "%s: No power function\n", __func__);
1792		rc = -ENOSYS;
1793	}
1794	if (rc < 0) {
1795		dev_err(dev, "%s: HW Power up fails r=%d\n",
1796				__func__, rc);
1797
1798		/* Initiate a read transaction to wake up */
1799		cyttsp4_adap_read(cd, CY_REG_BASE, sizeof(mode), &mode);
1800	} else
1801		dev_vdbg(cd->dev, "%s: HW power up succeeds\n",
1802			__func__);
1803	mutex_unlock(&cd->system_lock);
1804
1805	t = wait_event_timeout(cd->wait_q,
1806			(cd->int_status & CY_INT_AWAKE) == 0,
1807			msecs_to_jiffies(CY_CORE_WAKEUP_TIMEOUT));
1808	if (IS_TMO(t)) {
1809		dev_err(dev, "%s: TMO waiting for wakeup\n", __func__);
1810		mutex_lock(&cd->system_lock);
1811		cd->int_status &= ~CY_INT_AWAKE;
1812		/* Try starting up */
1813		cyttsp4_queue_startup_(cd);
1814		mutex_unlock(&cd->system_lock);
1815	}
1816
1817	mutex_lock(&cd->system_lock);
1818	cd->sleep_state = SS_SLEEP_OFF;
1819	mutex_unlock(&cd->system_lock);
1820
1821	cyttsp4_start_wd_timer(cd);
1822
1823	return 0;
1824}
1825
1826static int cyttsp4_core_wake(struct cyttsp4 *cd)
1827{
1828	int rc;
1829
1830	rc = cyttsp4_request_exclusive(cd, cd->dev,
1831			CY_CORE_REQUEST_EXCLUSIVE_TIMEOUT);
1832	if (rc < 0) {
1833		dev_err(cd->dev, "%s: fail get exclusive ex=%p own=%p\n",
1834				__func__, cd->exclusive_dev, cd->dev);
1835		return 0;
1836	}
1837
1838	rc = cyttsp4_core_wake_(cd);
1839
1840	if (cyttsp4_release_exclusive(cd, cd->dev) < 0)
1841		dev_err(cd->dev, "%s: fail to release exclusive\n", __func__);
1842	else
1843		dev_vdbg(cd->dev, "%s: pass release exclusive\n", __func__);
1844
1845	return rc;
1846}
1847
1848static int cyttsp4_core_suspend(struct device *dev)
1849{
1850	struct cyttsp4 *cd = dev_get_drvdata(dev);
1851	struct cyttsp4_mt_data *md = &cd->md;
1852	int rc;
1853
1854	md->is_suspended = true;
1855
1856	rc = cyttsp4_core_sleep(cd);
1857	if (rc < 0) {
1858		dev_err(dev, "%s: Error on sleep\n", __func__);
1859		return -EAGAIN;
1860	}
1861	return 0;
1862}
1863
1864static int cyttsp4_core_resume(struct device *dev)
1865{
1866	struct cyttsp4 *cd = dev_get_drvdata(dev);
1867	struct cyttsp4_mt_data *md = &cd->md;
1868	int rc;
1869
1870	md->is_suspended = false;
1871
1872	rc = cyttsp4_core_wake(cd);
1873	if (rc < 0) {
1874		dev_err(dev, "%s: Error on wake\n", __func__);
1875		return -EAGAIN;
1876	}
1877
1878	return 0;
1879}
1880#endif
1881
1882const struct dev_pm_ops cyttsp4_pm_ops = {
1883	SET_SYSTEM_SLEEP_PM_OPS(cyttsp4_core_suspend, cyttsp4_core_resume)
1884	SET_RUNTIME_PM_OPS(cyttsp4_core_suspend, cyttsp4_core_resume, NULL)
1885};
1886EXPORT_SYMBOL_GPL(cyttsp4_pm_ops);
1887
1888static int cyttsp4_mt_open(struct input_dev *input)
1889{
1890	pm_runtime_get(input->dev.parent);
1891	return 0;
1892}
1893
1894static void cyttsp4_mt_close(struct input_dev *input)
1895{
1896	struct cyttsp4_mt_data *md = input_get_drvdata(input);
1897	mutex_lock(&md->report_lock);
1898	if (!md->is_suspended)
1899		pm_runtime_put(input->dev.parent);
1900	mutex_unlock(&md->report_lock);
1901}
1902
1903
1904static int cyttsp4_setup_input_device(struct cyttsp4 *cd)
1905{
1906	struct device *dev = cd->dev;
1907	struct cyttsp4_mt_data *md = &cd->md;
1908	int signal = CY_IGNORE_VALUE;
1909	int max_x, max_y, max_p, min, max;
1910	int max_x_tmp, max_y_tmp;
1911	int i;
1912	int rc;
1913
1914	dev_vdbg(dev, "%s: Initialize event signals\n", __func__);
1915	__set_bit(EV_ABS, md->input->evbit);
1916	__set_bit(EV_REL, md->input->evbit);
1917	__set_bit(EV_KEY, md->input->evbit);
1918
1919	max_x_tmp = md->si->si_ofs.max_x;
1920	max_y_tmp = md->si->si_ofs.max_y;
1921
1922	/* get maximum values from the sysinfo data */
1923	if (md->pdata->flags & CY_FLAG_FLIP) {
1924		max_x = max_y_tmp - 1;
1925		max_y = max_x_tmp - 1;
1926	} else {
1927		max_x = max_x_tmp - 1;
1928		max_y = max_y_tmp - 1;
1929	}
1930	max_p = md->si->si_ofs.max_p;
1931
1932	/* set event signal capabilities */
1933	for (i = 0; i < (md->pdata->frmwrk->size / CY_NUM_ABS_SET); i++) {
1934		signal = md->pdata->frmwrk->abs
1935			[(i * CY_NUM_ABS_SET) + CY_SIGNAL_OST];
1936		if (signal != CY_IGNORE_VALUE) {
1937			__set_bit(signal, md->input->absbit);
1938			min = md->pdata->frmwrk->abs
1939				[(i * CY_NUM_ABS_SET) + CY_MIN_OST];
1940			max = md->pdata->frmwrk->abs
1941				[(i * CY_NUM_ABS_SET) + CY_MAX_OST];
1942			if (i == CY_ABS_ID_OST) {
1943				/* shift track ids down to start at 0 */
1944				max = max - min;
1945				min = min - min;
1946			} else if (i == CY_ABS_X_OST)
1947				max = max_x;
1948			else if (i == CY_ABS_Y_OST)
1949				max = max_y;
1950			else if (i == CY_ABS_P_OST)
1951				max = max_p;
1952			input_set_abs_params(md->input, signal, min, max,
1953				md->pdata->frmwrk->abs
1954				[(i * CY_NUM_ABS_SET) + CY_FUZZ_OST],
1955				md->pdata->frmwrk->abs
1956				[(i * CY_NUM_ABS_SET) + CY_FLAT_OST]);
1957			dev_dbg(dev, "%s: register signal=%02X min=%d max=%d\n",
1958				__func__, signal, min, max);
1959			if ((i == CY_ABS_ID_OST) &&
1960				(md->si->si_ofs.tch_rec_size <
1961				CY_TMA4XX_TCH_REC_SIZE))
1962				break;
1963		}
1964	}
1965
1966	input_mt_init_slots(md->input, md->si->si_ofs.tch_abs[CY_TCH_T].max,
1967			INPUT_MT_DIRECT);
1968	rc = input_register_device(md->input);
1969	if (rc < 0)
1970		dev_err(dev, "%s: Error, failed register input device r=%d\n",
1971			__func__, rc);
1972	return rc;
1973}
1974
1975static int cyttsp4_mt_probe(struct cyttsp4 *cd)
1976{
1977	struct device *dev = cd->dev;
1978	struct cyttsp4_mt_data *md = &cd->md;
1979	struct cyttsp4_mt_platform_data *pdata = cd->pdata->mt_pdata;
1980	int rc = 0;
1981
1982	mutex_init(&md->report_lock);
1983	md->pdata = pdata;
1984	/* Create the input device and register it. */
1985	dev_vdbg(dev, "%s: Create the input device and register it\n",
1986		__func__);
1987	md->input = input_allocate_device();
1988	if (md->input == NULL) {
1989		dev_err(dev, "%s: Error, failed to allocate input device\n",
1990			__func__);
1991		rc = -ENOSYS;
1992		goto error_alloc_failed;
1993	}
1994
1995	md->input->name = pdata->inp_dev_name;
1996	scnprintf(md->phys, sizeof(md->phys)-1, "%s", dev_name(dev));
1997	md->input->phys = md->phys;
1998	md->input->id.bustype = cd->bus_ops->bustype;
1999	md->input->dev.parent = dev;
2000	md->input->open = cyttsp4_mt_open;
2001	md->input->close = cyttsp4_mt_close;
2002	input_set_drvdata(md->input, md);
2003
2004	/* get sysinfo */
2005	md->si = &cd->sysinfo;
2006
2007	rc = cyttsp4_setup_input_device(cd);
2008	if (rc)
2009		goto error_init_input;
2010
2011	return 0;
2012
2013error_init_input:
2014	input_free_device(md->input);
2015error_alloc_failed:
2016	dev_err(dev, "%s failed.\n", __func__);
2017	return rc;
2018}
2019
2020struct cyttsp4 *cyttsp4_probe(const struct cyttsp4_bus_ops *ops,
2021		struct device *dev, u16 irq, size_t xfer_buf_size)
2022{
2023	struct cyttsp4 *cd;
2024	struct cyttsp4_platform_data *pdata = dev_get_platdata(dev);
2025	unsigned long irq_flags;
2026	int rc = 0;
2027
2028	if (!pdata || !pdata->core_pdata || !pdata->mt_pdata) {
2029		dev_err(dev, "%s: Missing platform data\n", __func__);
2030		rc = -ENODEV;
2031		goto error_no_pdata;
2032	}
2033
2034	cd = kzalloc(sizeof(*cd), GFP_KERNEL);
2035	if (!cd) {
2036		dev_err(dev, "%s: Error, kzalloc\n", __func__);
2037		rc = -ENOMEM;
2038		goto error_alloc_data;
2039	}
2040
2041	cd->xfer_buf = kzalloc(xfer_buf_size, GFP_KERNEL);
2042	if (!cd->xfer_buf) {
2043		dev_err(dev, "%s: Error, kzalloc\n", __func__);
2044		rc = -ENOMEM;
2045		goto error_free_cd;
2046	}
2047
2048	/* Initialize device info */
2049	cd->dev = dev;
2050	cd->pdata = pdata;
2051	cd->cpdata = pdata->core_pdata;
2052	cd->bus_ops = ops;
2053
2054	/* Initialize mutexes and spinlocks */
2055	mutex_init(&cd->system_lock);
2056	mutex_init(&cd->adap_lock);
2057
2058	/* Initialize wait queue */
2059	init_waitqueue_head(&cd->wait_q);
2060
2061	/* Initialize works */
2062	INIT_WORK(&cd->startup_work, cyttsp4_startup_work_function);
2063	INIT_WORK(&cd->watchdog_work, cyttsp4_watchdog_work);
2064
2065	/* Initialize IRQ */
2066	cd->irq = gpio_to_irq(cd->cpdata->irq_gpio);
2067	if (cd->irq < 0) {
2068		rc = -EINVAL;
2069		goto error_free_xfer;
2070	}
2071
2072	dev_set_drvdata(dev, cd);
2073
2074	/* Call platform init function */
2075	if (cd->cpdata->init) {
2076		dev_dbg(cd->dev, "%s: Init HW\n", __func__);
2077		rc = cd->cpdata->init(cd->cpdata, 1, cd->dev);
2078	} else {
2079		dev_dbg(cd->dev, "%s: No HW INIT function\n", __func__);
2080		rc = 0;
2081	}
2082	if (rc < 0)
2083		dev_err(cd->dev, "%s: HW Init fail r=%d\n", __func__, rc);
2084
2085	dev_dbg(dev, "%s: initialize threaded irq=%d\n", __func__, cd->irq);
2086	if (cd->cpdata->level_irq_udelay > 0)
2087		/* use level triggered interrupts */
2088		irq_flags = IRQF_TRIGGER_LOW | IRQF_ONESHOT;
2089	else
2090		/* use edge triggered interrupts */
2091		irq_flags = IRQF_TRIGGER_FALLING | IRQF_ONESHOT;
2092
2093	rc = request_threaded_irq(cd->irq, NULL, cyttsp4_irq, irq_flags,
2094		dev_name(dev), cd);
2095	if (rc < 0) {
2096		dev_err(dev, "%s: Error, could not request irq\n", __func__);
2097		goto error_request_irq;
2098	}
2099
2100	/* Setup watchdog timer */
2101	timer_setup(&cd->watchdog_timer, cyttsp4_watchdog_timer, 0);
2102
2103	/*
2104	 * call startup directly to ensure that the device
2105	 * is tested before leaving the probe
2106	 */
2107	rc = cyttsp4_startup(cd);
2108
2109	/* Do not fail probe if startup fails but the device is detected */
2110	if (rc < 0 && cd->mode == CY_MODE_UNKNOWN) {
2111		dev_err(cd->dev, "%s: Fail initial startup r=%d\n",
2112			__func__, rc);
2113		goto error_startup;
2114	}
2115
2116	rc = cyttsp4_mt_probe(cd);
2117	if (rc < 0) {
2118		dev_err(dev, "%s: Error, fail mt probe\n", __func__);
2119		goto error_startup;
2120	}
2121
2122	pm_runtime_enable(dev);
2123
2124	return cd;
2125
2126error_startup:
2127	cancel_work_sync(&cd->startup_work);
2128	cyttsp4_stop_wd_timer(cd);
2129	pm_runtime_disable(dev);
2130	cyttsp4_free_si_ptrs(cd);
2131	free_irq(cd->irq, cd);
2132error_request_irq:
2133	if (cd->cpdata->init)
2134		cd->cpdata->init(cd->cpdata, 0, dev);
2135error_free_xfer:
2136	kfree(cd->xfer_buf);
2137error_free_cd:
2138	kfree(cd);
2139error_alloc_data:
2140error_no_pdata:
2141	dev_err(dev, "%s failed.\n", __func__);
2142	return ERR_PTR(rc);
2143}
2144EXPORT_SYMBOL_GPL(cyttsp4_probe);
2145
2146static void cyttsp4_mt_release(struct cyttsp4_mt_data *md)
2147{
2148	input_unregister_device(md->input);
2149	input_set_drvdata(md->input, NULL);
2150}
2151
2152int cyttsp4_remove(struct cyttsp4 *cd)
2153{
2154	struct device *dev = cd->dev;
2155
2156	cyttsp4_mt_release(&cd->md);
2157
2158	/*
2159	 * Suspend the device before freeing the startup_work and stopping
2160	 * the watchdog since sleep function restarts watchdog on failure
2161	 */
2162	pm_runtime_suspend(dev);
2163	pm_runtime_disable(dev);
2164
2165	cancel_work_sync(&cd->startup_work);
2166
2167	cyttsp4_stop_wd_timer(cd);
2168
2169	free_irq(cd->irq, cd);
2170	if (cd->cpdata->init)
2171		cd->cpdata->init(cd->cpdata, 0, dev);
2172	cyttsp4_free_si_ptrs(cd);
2173	kfree(cd);
2174	return 0;
2175}
2176EXPORT_SYMBOL_GPL(cyttsp4_remove);
2177
2178MODULE_LICENSE("GPL");
2179MODULE_DESCRIPTION("Cypress TrueTouch(R) Standard touchscreen core driver");
2180MODULE_AUTHOR("Cypress");
2181