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
  43static const u8 ldr_exit[] = {
  44	0xFF, 0x01, 0x3B, 0x00, 0x00, 0x4F, 0x6D, 0x17
  45};
  46
  47static const u8 ldr_err_app[] = {
  48	0x01, 0x02, 0x00, 0x00, 0x55, 0xDD, 0x17
  49};
  50
  51static inline size_t merge_bytes(u8 high, u8 low)
  52{
  53	return (high << 8) + low;
  54}
  55
  56#ifdef VERBOSE_DEBUG
  57static 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
  80static 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
  98static 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
 118static 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
 130static 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
 141static 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 */
 154static int cyttsp4_bits_2_bytes(unsigned int nbits, size_t *max)
 155{
 156	*max = 1UL << nbits;
 157	return (nbits + 7) / 8;
 158}
 159
 160static 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
 196static 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
 267static 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
 318static 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
 360static 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
 450cyttsp4_si_get_opcfg_data_exit:
 451	return rc;
 452}
 453
 454static 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
 481static 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
 508static 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
 561static 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
 586static 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
 651static 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
 707static 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
 719static 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
 734static 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
 747static 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
 772static 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	bool flipped;
 779
 780	for (abs = CY_TCH_X; abs < CY_TCH_NUM_ABS; abs++) {
 781		cyttsp4_get_touch_axis(md, &touch->abs[abs],
 782			si->si_ofs.tch_abs[abs].size,
 783			si->si_ofs.tch_abs[abs].max,
 784			xy_data + si->si_ofs.tch_abs[abs].ofs,
 785			si->si_ofs.tch_abs[abs].bofs);
 786		dev_vdbg(dev, "%s: get %s=%04X(%d)\n", __func__,
 787			cyttsp4_tch_abs_string[abs],
 788			touch->abs[abs], touch->abs[abs]);
 789	}
 790
 791	if (md->pdata->flags & CY_FLAG_FLIP) {
 792		swap(touch->abs[CY_TCH_X], touch->abs[CY_TCH_Y]);
 793		flipped = true;
 794	} else
 795		flipped = false;
 796
 797	if (md->pdata->flags & CY_FLAG_INV_X) {
 798		if (flipped)
 799			touch->abs[CY_TCH_X] = md->si->si_ofs.max_y -
 800				touch->abs[CY_TCH_X];
 801		else
 802			touch->abs[CY_TCH_X] = md->si->si_ofs.max_x -
 803				touch->abs[CY_TCH_X];
 804	}
 805	if (md->pdata->flags & CY_FLAG_INV_Y) {
 806		if (flipped)
 807			touch->abs[CY_TCH_Y] = md->si->si_ofs.max_x -
 808				touch->abs[CY_TCH_Y];
 809		else
 810			touch->abs[CY_TCH_Y] = md->si->si_ofs.max_y -
 811				touch->abs[CY_TCH_Y];
 812	}
 813
 814	dev_vdbg(dev, "%s: flip=%s inv-x=%s inv-y=%s x=%04X(%d) y=%04X(%d)\n",
 815		__func__, flipped ? "true" : "false",
 816		md->pdata->flags & CY_FLAG_INV_X ? "true" : "false",
 817		md->pdata->flags & CY_FLAG_INV_Y ? "true" : "false",
 818		touch->abs[CY_TCH_X], touch->abs[CY_TCH_X],
 819		touch->abs[CY_TCH_Y], touch->abs[CY_TCH_Y]);
 820}
 821
 822static void cyttsp4_final_sync(struct input_dev *input, int max_slots, int *ids)
 823{
 824	int t;
 825
 826	for (t = 0; t < max_slots; t++) {
 827		if (ids[t])
 828			continue;
 829		input_mt_slot(input, t);
 830		input_mt_report_slot_state(input, MT_TOOL_FINGER, false);
 831	}
 832
 833	input_sync(input);
 834}
 835
 836static void cyttsp4_get_mt_touches(struct cyttsp4_mt_data *md, int num_cur_tch)
 837{
 838	struct device *dev = &md->input->dev;
 839	struct cyttsp4_sysinfo *si = md->si;
 840	struct cyttsp4_touch tch;
 841	int sig;
 842	int i, j, t = 0;
 843	int ids[max(CY_TMA1036_MAX_TCH, CY_TMA4XX_MAX_TCH)];
 844
 845	memset(ids, 0, si->si_ofs.tch_abs[CY_TCH_T].max * sizeof(int));
 846	for (i = 0; i < num_cur_tch; i++) {
 847		cyttsp4_get_touch(md, &tch, si->xy_data +
 848			(i * si->si_ofs.tch_rec_size));
 849		if ((tch.abs[CY_TCH_T] < md->pdata->frmwrk->abs
 850			[(CY_ABS_ID_OST * CY_NUM_ABS_SET) + CY_MIN_OST]) ||
 851			(tch.abs[CY_TCH_T] > md->pdata->frmwrk->abs
 852			[(CY_ABS_ID_OST * CY_NUM_ABS_SET) + CY_MAX_OST])) {
 853			dev_err(dev, "%s: tch=%d -> bad trk_id=%d max_id=%d\n",
 854				__func__, i, tch.abs[CY_TCH_T],
 855				md->pdata->frmwrk->abs[(CY_ABS_ID_OST *
 856				CY_NUM_ABS_SET) + CY_MAX_OST]);
 857			continue;
 858		}
 859
 860		/* use 0 based track id's */
 861		sig = md->pdata->frmwrk->abs
 862			[(CY_ABS_ID_OST * CY_NUM_ABS_SET) + 0];
 863		if (sig != CY_IGNORE_VALUE) {
 864			t = tch.abs[CY_TCH_T] - md->pdata->frmwrk->abs
 865				[(CY_ABS_ID_OST * CY_NUM_ABS_SET) + CY_MIN_OST];
 866			if (tch.abs[CY_TCH_E] == CY_EV_LIFTOFF) {
 867				dev_dbg(dev, "%s: t=%d e=%d lift-off\n",
 868					__func__, t, tch.abs[CY_TCH_E]);
 869				goto cyttsp4_get_mt_touches_pr_tch;
 870			}
 871			input_mt_slot(md->input, t);
 872			input_mt_report_slot_state(md->input, MT_TOOL_FINGER,
 873					true);
 874			ids[t] = true;
 875		}
 876
 877		/* all devices: position and pressure fields */
 878		for (j = 0; j <= CY_ABS_W_OST; j++) {
 879			sig = md->pdata->frmwrk->abs[((CY_ABS_X_OST + j) *
 880				CY_NUM_ABS_SET) + 0];
 881			if (sig != CY_IGNORE_VALUE)
 882				input_report_abs(md->input, sig,
 883					tch.abs[CY_TCH_X + j]);
 884		}
 885		if (si->si_ofs.tch_rec_size > CY_TMA1036_TCH_REC_SIZE) {
 886			/*
 887			 * TMA400 size and orientation fields:
 888			 * if pressure is non-zero and major touch
 889			 * signal is zero, then set major and minor touch
 890			 * signals to minimum non-zero value
 891			 */
 892			if (tch.abs[CY_TCH_P] > 0 && tch.abs[CY_TCH_MAJ] == 0)
 893				tch.abs[CY_TCH_MAJ] = tch.abs[CY_TCH_MIN] = 1;
 894
 895			/* Get the extended touch fields */
 896			for (j = 0; j < CY_NUM_EXT_TCH_FIELDS; j++) {
 897				sig = md->pdata->frmwrk->abs
 898					[((CY_ABS_MAJ_OST + j) *
 899					CY_NUM_ABS_SET) + 0];
 900				if (sig != CY_IGNORE_VALUE)
 901					input_report_abs(md->input, sig,
 902						tch.abs[CY_TCH_MAJ + j]);
 903			}
 904		}
 905
 906cyttsp4_get_mt_touches_pr_tch:
 907		if (si->si_ofs.tch_rec_size > CY_TMA1036_TCH_REC_SIZE)
 908			dev_dbg(dev,
 909				"%s: t=%d x=%d y=%d z=%d M=%d m=%d o=%d e=%d\n",
 910				__func__, t,
 911				tch.abs[CY_TCH_X],
 912				tch.abs[CY_TCH_Y],
 913				tch.abs[CY_TCH_P],
 914				tch.abs[CY_TCH_MAJ],
 915				tch.abs[CY_TCH_MIN],
 916				tch.abs[CY_TCH_OR],
 917				tch.abs[CY_TCH_E]);
 918		else
 919			dev_dbg(dev,
 920				"%s: t=%d x=%d y=%d z=%d e=%d\n", __func__,
 921				t,
 922				tch.abs[CY_TCH_X],
 923				tch.abs[CY_TCH_Y],
 924				tch.abs[CY_TCH_P],
 925				tch.abs[CY_TCH_E]);
 926	}
 927
 928	cyttsp4_final_sync(md->input, si->si_ofs.tch_abs[CY_TCH_T].max, ids);
 929
 930	md->num_prv_tch = num_cur_tch;
 931
 932	return;
 933}
 934
 935/* read xy_data for all current touches */
 936static int cyttsp4_xy_worker(struct cyttsp4 *cd)
 937{
 938	struct cyttsp4_mt_data *md = &cd->md;
 939	struct device *dev = &md->input->dev;
 940	struct cyttsp4_sysinfo *si = md->si;
 941	u8 num_cur_tch;
 942	u8 hst_mode;
 943	u8 rep_len;
 944	u8 rep_stat;
 945	u8 tt_stat;
 946	int rc = 0;
 947
 948	/*
 949	 * Get event data from cyttsp4 device.
 950	 * The event data includes all data
 951	 * for all active touches.
 952	 * Event data also includes button data
 953	 */
 954	/*
 955	 * Use 2 reads:
 956	 * 1st read to get mode + button bytes + touch count (core)
 957	 * 2nd read (optional) to get touch 1 - touch n data
 958	 */
 959	hst_mode = si->xy_mode[CY_REG_BASE];
 960	rep_len = si->xy_mode[si->si_ofs.rep_ofs];
 961	rep_stat = si->xy_mode[si->si_ofs.rep_ofs + 1];
 962	tt_stat = si->xy_mode[si->si_ofs.tt_stat_ofs];
 963	dev_vdbg(dev, "%s: %s%02X %s%d %s%02X %s%02X\n", __func__,
 964		"hst_mode=", hst_mode, "rep_len=", rep_len,
 965		"rep_stat=", rep_stat, "tt_stat=", tt_stat);
 966
 967	num_cur_tch = GET_NUM_TOUCHES(tt_stat);
 968	dev_vdbg(dev, "%s: num_cur_tch=%d\n", __func__, num_cur_tch);
 969
 970	if (rep_len == 0 && num_cur_tch > 0) {
 971		dev_err(dev, "%s: report length error rep_len=%d num_tch=%d\n",
 972			__func__, rep_len, num_cur_tch);
 973		goto cyttsp4_xy_worker_exit;
 974	}
 975
 976	/* read touches */
 977	if (num_cur_tch > 0) {
 978		rc = cyttsp4_adap_read(cd, si->si_ofs.tt_stat_ofs + 1,
 979				num_cur_tch * si->si_ofs.tch_rec_size,
 980				si->xy_data);
 981		if (rc < 0) {
 982			dev_err(dev, "%s: read fail on touch regs r=%d\n",
 983				__func__, rc);
 984			goto cyttsp4_xy_worker_exit;
 985		}
 986	}
 987
 988	/* print xy data */
 989	cyttsp4_pr_buf(dev, cd->pr_buf, si->xy_data, num_cur_tch *
 990		si->si_ofs.tch_rec_size, "xy_data");
 991
 992	/* check any error conditions */
 993	if (IS_BAD_PKT(rep_stat)) {
 994		dev_dbg(dev, "%s: Invalid buffer detected\n", __func__);
 995		rc = 0;
 996		goto cyttsp4_xy_worker_exit;
 997	}
 998
 999	if (IS_LARGE_AREA(tt_stat))
1000		dev_dbg(dev, "%s: Large area detected\n", __func__);
1001
1002	if (num_cur_tch > si->si_ofs.max_tchs) {
1003		dev_err(dev, "%s: too many tch; set to max tch (n=%d c=%Zd)\n",
1004				__func__, num_cur_tch, si->si_ofs.max_tchs);
1005		num_cur_tch = si->si_ofs.max_tchs;
1006	}
1007
1008	/* extract xy_data for all currently reported touches */
1009	dev_vdbg(dev, "%s: extract data num_cur_tch=%d\n", __func__,
1010		num_cur_tch);
1011	if (num_cur_tch)
1012		cyttsp4_get_mt_touches(md, num_cur_tch);
1013	else
1014		cyttsp4_lift_all(md);
1015
1016	rc = 0;
1017
1018cyttsp4_xy_worker_exit:
1019	return rc;
1020}
1021
1022static int cyttsp4_mt_attention(struct cyttsp4 *cd)
1023{
1024	struct device *dev = cd->dev;
1025	struct cyttsp4_mt_data *md = &cd->md;
1026	int rc = 0;
1027
1028	if (!md->si)
1029		return 0;
1030
1031	mutex_lock(&md->report_lock);
1032	if (!md->is_suspended) {
1033		/* core handles handshake */
1034		rc = cyttsp4_xy_worker(cd);
1035	} else {
1036		dev_vdbg(dev, "%s: Ignoring report while suspended\n",
1037			__func__);
1038	}
1039	mutex_unlock(&md->report_lock);
1040	if (rc < 0)
1041		dev_err(dev, "%s: xy_worker error r=%d\n", __func__, rc);
1042
1043	return rc;
1044}
1045
1046static irqreturn_t cyttsp4_irq(int irq, void *handle)
1047{
1048	struct cyttsp4 *cd = handle;
1049	struct device *dev = cd->dev;
1050	enum cyttsp4_mode cur_mode;
1051	u8 cmd_ofs = cd->sysinfo.si_ofs.cmd_ofs;
1052	u8 mode[3];
1053	int rc;
1054
1055	/*
1056	 * Check whether this IRQ should be ignored (external)
1057	 * This should be the very first thing to check since
1058	 * ignore_irq may be set for a very short period of time
1059	 */
1060	if (atomic_read(&cd->ignore_irq)) {
1061		dev_vdbg(dev, "%s: Ignoring IRQ\n", __func__);
1062		return IRQ_HANDLED;
1063	}
1064
1065	dev_dbg(dev, "%s int:0x%x\n", __func__, cd->int_status);
1066
1067	mutex_lock(&cd->system_lock);
1068
1069	/* Just to debug */
1070	if (cd->sleep_state == SS_SLEEP_ON || cd->sleep_state == SS_SLEEPING)
1071		dev_vdbg(dev, "%s: Received IRQ while in sleep\n", __func__);
1072
1073	rc = cyttsp4_adap_read(cd, CY_REG_BASE, sizeof(mode), mode);
1074	if (rc) {
1075		dev_err(cd->dev, "%s: Fail read adapter r=%d\n", __func__, rc);
1076		goto cyttsp4_irq_exit;
1077	}
1078	dev_vdbg(dev, "%s mode[0-2]:0x%X 0x%X 0x%X\n", __func__,
1079			mode[0], mode[1], mode[2]);
1080
1081	if (IS_BOOTLOADER(mode[0], mode[1])) {
1082		cur_mode = CY_MODE_BOOTLOADER;
1083		dev_vdbg(dev, "%s: bl running\n", __func__);
1084		if (cd->mode == CY_MODE_BOOTLOADER) {
1085			/* Signal bootloader heartbeat heard */
1086			wake_up(&cd->wait_q);
1087			goto cyttsp4_irq_exit;
1088		}
1089
1090		/* switch to bootloader */
1091		dev_dbg(dev, "%s: restart switch to bl m=%d -> m=%d\n",
1092			__func__, cd->mode, cur_mode);
1093
1094		/* catch operation->bl glitch */
1095		if (cd->mode != CY_MODE_UNKNOWN) {
1096			/* Incase startup_state do not let startup_() */
1097			cd->mode = CY_MODE_UNKNOWN;
1098			cyttsp4_queue_startup_(cd);
1099			goto cyttsp4_irq_exit;
1100		}
1101
1102		/*
1103		 * do not wake thread on this switch since
1104		 * it is possible to get an early heartbeat
1105		 * prior to performing the reset
1106		 */
1107		cd->mode = cur_mode;
1108
1109		goto cyttsp4_irq_exit;
1110	}
1111
1112	switch (mode[0] & CY_HST_MODE) {
1113	case CY_HST_OPERATE:
1114		cur_mode = CY_MODE_OPERATIONAL;
1115		dev_vdbg(dev, "%s: operational\n", __func__);
1116		break;
1117	case CY_HST_CAT:
1118		cur_mode = CY_MODE_CAT;
1119		dev_vdbg(dev, "%s: CaT\n", __func__);
1120		break;
1121	case CY_HST_SYSINFO:
1122		cur_mode = CY_MODE_SYSINFO;
1123		dev_vdbg(dev, "%s: sysinfo\n", __func__);
1124		break;
1125	default:
1126		cur_mode = CY_MODE_UNKNOWN;
1127		dev_err(dev, "%s: unknown HST mode 0x%02X\n", __func__,
1128			mode[0]);
1129		break;
1130	}
1131
1132	/* Check whether this IRQ should be ignored (internal) */
1133	if (cd->int_status & CY_INT_IGNORE) {
1134		dev_vdbg(dev, "%s: Ignoring IRQ\n", __func__);
1135		goto cyttsp4_irq_exit;
1136	}
1137
1138	/* Check for wake up interrupt */
1139	if (cd->int_status & CY_INT_AWAKE) {
1140		cd->int_status &= ~CY_INT_AWAKE;
1141		wake_up(&cd->wait_q);
1142		dev_vdbg(dev, "%s: Received wake up interrupt\n", __func__);
1143		goto cyttsp4_irq_handshake;
1144	}
1145
1146	/* Expecting mode change interrupt */
1147	if ((cd->int_status & CY_INT_MODE_CHANGE)
1148			&& (mode[0] & CY_HST_MODE_CHANGE) == 0) {
1149		cd->int_status &= ~CY_INT_MODE_CHANGE;
1150		dev_dbg(dev, "%s: finish mode switch m=%d -> m=%d\n",
1151				__func__, cd->mode, cur_mode);
1152		cd->mode = cur_mode;
1153		wake_up(&cd->wait_q);
1154		goto cyttsp4_irq_handshake;
1155	}
1156
1157	/* compare current core mode to current device mode */
1158	dev_vdbg(dev, "%s: cd->mode=%d cur_mode=%d\n",
1159			__func__, cd->mode, cur_mode);
1160	if ((mode[0] & CY_HST_MODE_CHANGE) == 0 && cd->mode != cur_mode) {
1161		/* Unexpected mode change occurred */
1162		dev_err(dev, "%s %d->%d 0x%x\n", __func__, cd->mode,
1163				cur_mode, cd->int_status);
1164		dev_dbg(dev, "%s: Unexpected mode change, startup\n",
1165				__func__);
1166		cyttsp4_queue_startup_(cd);
1167		goto cyttsp4_irq_exit;
1168	}
1169
1170	/* Expecting command complete interrupt */
1171	dev_vdbg(dev, "%s: command byte:0x%x\n", __func__, mode[cmd_ofs]);
1172	if ((cd->int_status & CY_INT_EXEC_CMD)
1173			&& mode[cmd_ofs] & CY_CMD_COMPLETE) {
1174		cd->int_status &= ~CY_INT_EXEC_CMD;
1175		dev_vdbg(dev, "%s: Received command complete interrupt\n",
1176				__func__);
1177		wake_up(&cd->wait_q);
1178		/*
1179		 * It is possible to receive a single interrupt for
1180		 * command complete and touch/button status report.
1181		 * Continue processing for a possible status report.
1182		 */
1183	}
1184
1185	/* This should be status report, read status regs */
1186	if (cd->mode == CY_MODE_OPERATIONAL) {
1187		dev_vdbg(dev, "%s: Read status registers\n", __func__);
1188		rc = cyttsp4_load_status_regs(cd);
1189		if (rc < 0)
1190			dev_err(dev, "%s: fail read mode regs r=%d\n",
1191				__func__, rc);
1192	}
1193
1194	cyttsp4_mt_attention(cd);
1195
1196cyttsp4_irq_handshake:
1197	/* handshake the event */
1198	dev_vdbg(dev, "%s: Handshake mode=0x%02X r=%d\n",
1199			__func__, mode[0], rc);
1200	rc = cyttsp4_handshake(cd, mode[0]);
1201	if (rc < 0)
1202		dev_err(dev, "%s: Fail handshake mode=0x%02X r=%d\n",
1203				__func__, mode[0], rc);
1204
1205	/*
1206	 * a non-zero udelay period is required for using
1207	 * IRQF_TRIGGER_LOW in order to delay until the
1208	 * device completes isr deassert
1209	 */
1210	udelay(cd->cpdata->level_irq_udelay);
1211
1212cyttsp4_irq_exit:
1213	mutex_unlock(&cd->system_lock);
1214	return IRQ_HANDLED;
1215}
1216
1217static void cyttsp4_start_wd_timer(struct cyttsp4 *cd)
1218{
1219	if (!CY_WATCHDOG_TIMEOUT)
1220		return;
1221
1222	mod_timer(&cd->watchdog_timer, jiffies +
1223			msecs_to_jiffies(CY_WATCHDOG_TIMEOUT));
1224}
1225
1226static void cyttsp4_stop_wd_timer(struct cyttsp4 *cd)
1227{
1228	if (!CY_WATCHDOG_TIMEOUT)
1229		return;
1230
1231	/*
1232	 * Ensure we wait until the watchdog timer
1233	 * running on a different CPU finishes
1234	 */
1235	del_timer_sync(&cd->watchdog_timer);
1236	cancel_work_sync(&cd->watchdog_work);
1237	del_timer_sync(&cd->watchdog_timer);
1238}
1239
1240static void cyttsp4_watchdog_timer(unsigned long handle)
1241{
1242	struct cyttsp4 *cd = (struct cyttsp4 *)handle;
1243
1244	dev_vdbg(cd->dev, "%s: Watchdog timer triggered\n", __func__);
1245
1246	schedule_work(&cd->watchdog_work);
1247
1248	return;
1249}
1250
1251static int cyttsp4_request_exclusive(struct cyttsp4 *cd, void *ownptr,
1252		int timeout_ms)
1253{
1254	int t = msecs_to_jiffies(timeout_ms);
1255	bool with_timeout = (timeout_ms != 0);
1256
1257	mutex_lock(&cd->system_lock);
1258	if (!cd->exclusive_dev && cd->exclusive_waits == 0) {
1259		cd->exclusive_dev = ownptr;
1260		goto exit;
1261	}
1262
1263	cd->exclusive_waits++;
1264wait:
1265	mutex_unlock(&cd->system_lock);
1266	if (with_timeout) {
1267		t = wait_event_timeout(cd->wait_q, !cd->exclusive_dev, t);
1268		if (IS_TMO(t)) {
1269			dev_err(cd->dev, "%s: tmo waiting exclusive access\n",
1270				__func__);
1271			mutex_lock(&cd->system_lock);
1272			cd->exclusive_waits--;
1273			mutex_unlock(&cd->system_lock);
1274			return -ETIME;
1275		}
1276	} else {
1277		wait_event(cd->wait_q, !cd->exclusive_dev);
1278	}
1279	mutex_lock(&cd->system_lock);
1280	if (cd->exclusive_dev)
1281		goto wait;
1282	cd->exclusive_dev = ownptr;
1283	cd->exclusive_waits--;
1284exit:
1285	mutex_unlock(&cd->system_lock);
1286
1287	return 0;
1288}
1289
1290/*
1291 * returns error if was not owned
1292 */
1293static int cyttsp4_release_exclusive(struct cyttsp4 *cd, void *ownptr)
1294{
1295	mutex_lock(&cd->system_lock);
1296	if (cd->exclusive_dev != ownptr) {
1297		mutex_unlock(&cd->system_lock);
1298		return -EINVAL;
1299	}
1300
1301	dev_vdbg(cd->dev, "%s: exclusive_dev %p freed\n",
1302		__func__, cd->exclusive_dev);
1303	cd->exclusive_dev = NULL;
1304	wake_up(&cd->wait_q);
1305	mutex_unlock(&cd->system_lock);
1306	return 0;
1307}
1308
1309static int cyttsp4_wait_bl_heartbeat(struct cyttsp4 *cd)
1310{
1311	long t;
1312	int rc = 0;
1313
1314	/* wait heartbeat */
1315	dev_vdbg(cd->dev, "%s: wait heartbeat...\n", __func__);
1316	t = wait_event_timeout(cd->wait_q, cd->mode == CY_MODE_BOOTLOADER,
1317			msecs_to_jiffies(CY_CORE_RESET_AND_WAIT_TIMEOUT));
1318	if (IS_TMO(t)) {
1319		dev_err(cd->dev, "%s: tmo waiting bl heartbeat cd->mode=%d\n",
1320			__func__, cd->mode);
1321		rc = -ETIME;
1322	}
1323
1324	return rc;
1325}
1326
1327static int cyttsp4_wait_sysinfo_mode(struct cyttsp4 *cd)
1328{
1329	long t;
1330
1331	dev_vdbg(cd->dev, "%s: wait sysinfo...\n", __func__);
1332
1333	t = wait_event_timeout(cd->wait_q, cd->mode == CY_MODE_SYSINFO,
1334			msecs_to_jiffies(CY_CORE_MODE_CHANGE_TIMEOUT));
1335	if (IS_TMO(t)) {
1336		dev_err(cd->dev, "%s: tmo waiting exit bl cd->mode=%d\n",
1337			__func__, cd->mode);
1338		mutex_lock(&cd->system_lock);
1339		cd->int_status &= ~CY_INT_MODE_CHANGE;
1340		mutex_unlock(&cd->system_lock);
1341		return -ETIME;
1342	}
1343
1344	return 0;
1345}
1346
1347static int cyttsp4_reset_and_wait(struct cyttsp4 *cd)
1348{
1349	int rc;
1350
1351	/* reset hardware */
1352	mutex_lock(&cd->system_lock);
1353	dev_dbg(cd->dev, "%s: reset hw...\n", __func__);
1354	rc = cyttsp4_hw_reset(cd);
1355	cd->mode = CY_MODE_UNKNOWN;
1356	mutex_unlock(&cd->system_lock);
1357	if (rc < 0) {
1358		dev_err(cd->dev, "%s:Fail hw reset r=%d\n", __func__, rc);
1359		return rc;
1360	}
1361
1362	return cyttsp4_wait_bl_heartbeat(cd);
1363}
1364
1365/*
1366 * returns err if refused or timeout; block until mode change complete
1367 * bit is set (mode change interrupt)
1368 */
1369static int cyttsp4_set_mode(struct cyttsp4 *cd, int new_mode)
1370{
1371	u8 new_dev_mode;
1372	u8 mode;
1373	long t;
1374	int rc;
1375
1376	switch (new_mode) {
1377	case CY_MODE_OPERATIONAL:
1378		new_dev_mode = CY_HST_OPERATE;
1379		break;
1380	case CY_MODE_SYSINFO:
1381		new_dev_mode = CY_HST_SYSINFO;
1382		break;
1383	case CY_MODE_CAT:
1384		new_dev_mode = CY_HST_CAT;
1385		break;
1386	default:
1387		dev_err(cd->dev, "%s: invalid mode: %02X(%d)\n",
1388			__func__, new_mode, new_mode);
1389		return -EINVAL;
1390	}
1391
1392	/* change mode */
1393	dev_dbg(cd->dev, "%s: %s=%p new_dev_mode=%02X new_mode=%d\n",
1394			__func__, "have exclusive", cd->exclusive_dev,
1395			new_dev_mode, new_mode);
1396
1397	mutex_lock(&cd->system_lock);
1398	rc = cyttsp4_adap_read(cd, CY_REG_BASE, sizeof(mode), &mode);
1399	if (rc < 0) {
1400		mutex_unlock(&cd->system_lock);
1401		dev_err(cd->dev, "%s: Fail read mode r=%d\n",
1402			__func__, rc);
1403		goto exit;
1404	}
1405
1406	/* Clear device mode bits and set to new mode */
1407	mode &= ~CY_HST_MODE;
1408	mode |= new_dev_mode | CY_HST_MODE_CHANGE;
1409
1410	cd->int_status |= CY_INT_MODE_CHANGE;
1411	rc = cyttsp4_adap_write(cd, CY_REG_BASE, sizeof(mode), &mode);
1412	mutex_unlock(&cd->system_lock);
1413	if (rc < 0) {
1414		dev_err(cd->dev, "%s: Fail write mode change r=%d\n",
1415				__func__, rc);
1416		goto exit;
1417	}
1418
1419	/* wait for mode change done interrupt */
1420	t = wait_event_timeout(cd->wait_q,
1421			(cd->int_status & CY_INT_MODE_CHANGE) == 0,
1422			msecs_to_jiffies(CY_CORE_MODE_CHANGE_TIMEOUT));
1423	dev_dbg(cd->dev, "%s: back from wait t=%ld cd->mode=%d\n",
1424			__func__, t, cd->mode);
1425
1426	if (IS_TMO(t)) {
1427		dev_err(cd->dev, "%s: %s\n", __func__,
1428				"tmo waiting mode change");
1429		mutex_lock(&cd->system_lock);
1430		cd->int_status &= ~CY_INT_MODE_CHANGE;
1431		mutex_unlock(&cd->system_lock);
1432		rc = -EINVAL;
1433	}
1434
1435exit:
1436	return rc;
1437}
1438
1439static void cyttsp4_watchdog_work(struct work_struct *work)
1440{
1441	struct cyttsp4 *cd =
1442		container_of(work, struct cyttsp4, watchdog_work);
1443	u8 *mode;
1444	int retval;
1445
1446	mutex_lock(&cd->system_lock);
1447	retval = cyttsp4_load_status_regs(cd);
1448	if (retval < 0) {
1449		dev_err(cd->dev,
1450			"%s: failed to access device in watchdog timer r=%d\n",
1451			__func__, retval);
1452		cyttsp4_queue_startup_(cd);
1453		goto cyttsp4_timer_watchdog_exit_error;
1454	}
1455	mode = &cd->sysinfo.xy_mode[CY_REG_BASE];
1456	if (IS_BOOTLOADER(mode[0], mode[1])) {
1457		dev_err(cd->dev,
1458			"%s: device found in bootloader mode when operational mode\n",
1459			__func__);
1460		cyttsp4_queue_startup_(cd);
1461		goto cyttsp4_timer_watchdog_exit_error;
1462	}
1463
1464	cyttsp4_start_wd_timer(cd);
1465cyttsp4_timer_watchdog_exit_error:
1466	mutex_unlock(&cd->system_lock);
1467	return;
1468}
1469
1470static int cyttsp4_core_sleep_(struct cyttsp4 *cd)
1471{
1472	enum cyttsp4_sleep_state ss = SS_SLEEP_ON;
1473	enum cyttsp4_int_state int_status = CY_INT_IGNORE;
1474	int rc = 0;
1475	u8 mode[2];
1476
1477	/* Already in sleep mode? */
1478	mutex_lock(&cd->system_lock);
1479	if (cd->sleep_state == SS_SLEEP_ON) {
1480		mutex_unlock(&cd->system_lock);
1481		return 0;
1482	}
1483	cd->sleep_state = SS_SLEEPING;
1484	mutex_unlock(&cd->system_lock);
1485
1486	cyttsp4_stop_wd_timer(cd);
1487
1488	/* Wait until currently running IRQ handler exits and disable IRQ */
1489	disable_irq(cd->irq);
1490
1491	dev_vdbg(cd->dev, "%s: write DEEP SLEEP...\n", __func__);
1492	mutex_lock(&cd->system_lock);
1493	rc = cyttsp4_adap_read(cd, CY_REG_BASE, sizeof(mode), &mode);
1494	if (rc) {
1495		mutex_unlock(&cd->system_lock);
1496		dev_err(cd->dev, "%s: Fail read adapter r=%d\n", __func__, rc);
1497		goto error;
1498	}
1499
1500	if (IS_BOOTLOADER(mode[0], mode[1])) {
1501		mutex_unlock(&cd->system_lock);
1502		dev_err(cd->dev, "%s: Device in BOOTLADER mode.\n", __func__);
1503		rc = -EINVAL;
1504		goto error;
1505	}
1506
1507	mode[0] |= CY_HST_SLEEP;
1508	rc = cyttsp4_adap_write(cd, CY_REG_BASE, sizeof(mode[0]), &mode[0]);
1509	mutex_unlock(&cd->system_lock);
1510	if (rc) {
1511		dev_err(cd->dev, "%s: Fail write adapter r=%d\n", __func__, rc);
1512		goto error;
1513	}
1514	dev_vdbg(cd->dev, "%s: write DEEP SLEEP succeeded\n", __func__);
1515
1516	if (cd->cpdata->power) {
1517		dev_dbg(cd->dev, "%s: Power down HW\n", __func__);
1518		rc = cd->cpdata->power(cd->cpdata, 0, cd->dev, &cd->ignore_irq);
1519	} else {
1520		dev_dbg(cd->dev, "%s: No power function\n", __func__);
1521		rc = 0;
1522	}
1523	if (rc < 0) {
1524		dev_err(cd->dev, "%s: HW Power down fails r=%d\n",
1525				__func__, rc);
1526		goto error;
1527	}
1528
1529	/* Give time to FW to sleep */
1530	msleep(50);
1531
1532	goto exit;
1533
1534error:
1535	ss = SS_SLEEP_OFF;
1536	int_status = CY_INT_NONE;
1537	cyttsp4_start_wd_timer(cd);
1538
1539exit:
1540	mutex_lock(&cd->system_lock);
1541	cd->sleep_state = ss;
1542	cd->int_status |= int_status;
1543	mutex_unlock(&cd->system_lock);
1544	enable_irq(cd->irq);
1545	return rc;
1546}
1547
1548static int cyttsp4_startup_(struct cyttsp4 *cd)
1549{
1550	int retry = CY_CORE_STARTUP_RETRY_COUNT;
1551	int rc;
1552
1553	cyttsp4_stop_wd_timer(cd);
1554
1555reset:
1556	if (retry != CY_CORE_STARTUP_RETRY_COUNT)
1557		dev_dbg(cd->dev, "%s: Retry %d\n", __func__,
1558			CY_CORE_STARTUP_RETRY_COUNT - retry);
1559
1560	/* reset hardware and wait for heartbeat */
1561	rc = cyttsp4_reset_and_wait(cd);
1562	if (rc < 0) {
1563		dev_err(cd->dev, "%s: Error on h/w reset r=%d\n", __func__, rc);
1564		if (retry--)
1565			goto reset;
1566		goto exit;
1567	}
1568
1569	/* exit bl into sysinfo mode */
1570	dev_vdbg(cd->dev, "%s: write exit ldr...\n", __func__);
1571	mutex_lock(&cd->system_lock);
1572	cd->int_status &= ~CY_INT_IGNORE;
1573	cd->int_status |= CY_INT_MODE_CHANGE;
1574
1575	rc = cyttsp4_adap_write(cd, CY_REG_BASE, sizeof(ldr_exit),
1576			(u8 *)ldr_exit);
1577	mutex_unlock(&cd->system_lock);
1578	if (rc < 0) {
1579		dev_err(cd->dev, "%s: Fail write r=%d\n", __func__, rc);
1580		if (retry--)
1581			goto reset;
1582		goto exit;
1583	}
1584
1585	rc = cyttsp4_wait_sysinfo_mode(cd);
1586	if (rc < 0) {
1587		u8 buf[sizeof(ldr_err_app)];
1588		int rc1;
1589
1590		/* Check for invalid/corrupted touch application */
1591		rc1 = cyttsp4_adap_read(cd, CY_REG_BASE, sizeof(ldr_err_app),
1592				buf);
1593		if (rc1) {
1594			dev_err(cd->dev, "%s: Fail read r=%d\n", __func__, rc1);
1595		} else if (!memcmp(buf, ldr_err_app, sizeof(ldr_err_app))) {
1596			dev_err(cd->dev, "%s: Error launching touch application\n",
1597				__func__);
1598			mutex_lock(&cd->system_lock);
1599			cd->invalid_touch_app = true;
1600			mutex_unlock(&cd->system_lock);
1601			goto exit_no_wd;
1602		}
1603
1604		if (retry--)
1605			goto reset;
1606		goto exit;
1607	}
1608
1609	mutex_lock(&cd->system_lock);
1610	cd->invalid_touch_app = false;
1611	mutex_unlock(&cd->system_lock);
1612
1613	/* read sysinfo data */
1614	dev_vdbg(cd->dev, "%s: get sysinfo regs..\n", __func__);
1615	rc = cyttsp4_get_sysinfo_regs(cd);
1616	if (rc < 0) {
1617		dev_err(cd->dev, "%s: failed to get sysinfo regs rc=%d\n",
1618			__func__, rc);
1619		if (retry--)
1620			goto reset;
1621		goto exit;
1622	}
1623
1624	rc = cyttsp4_set_mode(cd, CY_MODE_OPERATIONAL);
1625	if (rc < 0) {
1626		dev_err(cd->dev, "%s: failed to set mode to operational rc=%d\n",
1627			__func__, rc);
1628		if (retry--)
1629			goto reset;
1630		goto exit;
1631	}
1632
1633	cyttsp4_lift_all(&cd->md);
1634
1635	/* restore to sleep if was suspended */
1636	mutex_lock(&cd->system_lock);
1637	if (cd->sleep_state == SS_SLEEP_ON) {
1638		cd->sleep_state = SS_SLEEP_OFF;
1639		mutex_unlock(&cd->system_lock);
1640		cyttsp4_core_sleep_(cd);
1641		goto exit_no_wd;
1642	}
1643	mutex_unlock(&cd->system_lock);
1644
1645exit:
1646	cyttsp4_start_wd_timer(cd);
1647exit_no_wd:
1648	return rc;
1649}
1650
1651static int cyttsp4_startup(struct cyttsp4 *cd)
1652{
1653	int rc;
1654
1655	mutex_lock(&cd->system_lock);
1656	cd->startup_state = STARTUP_RUNNING;
1657	mutex_unlock(&cd->system_lock);
1658
1659	rc = cyttsp4_request_exclusive(cd, cd->dev,
1660			CY_CORE_REQUEST_EXCLUSIVE_TIMEOUT);
1661	if (rc < 0) {
1662		dev_err(cd->dev, "%s: fail get exclusive ex=%p own=%p\n",
1663				__func__, cd->exclusive_dev, cd->dev);
1664		goto exit;
1665	}
1666
1667	rc = cyttsp4_startup_(cd);
1668
1669	if (cyttsp4_release_exclusive(cd, cd->dev) < 0)
1670		/* Don't return fail code, mode is already changed. */
1671		dev_err(cd->dev, "%s: fail to release exclusive\n", __func__);
1672	else
1673		dev_vdbg(cd->dev, "%s: pass release exclusive\n", __func__);
1674
1675exit:
1676	mutex_lock(&cd->system_lock);
1677	cd->startup_state = STARTUP_NONE;
1678	mutex_unlock(&cd->system_lock);
1679
1680	/* Wake the waiters for end of startup */
1681	wake_up(&cd->wait_q);
1682
1683	return rc;
1684}
1685
1686static void cyttsp4_startup_work_function(struct work_struct *work)
1687{
1688	struct cyttsp4 *cd =  container_of(work, struct cyttsp4, startup_work);
1689	int rc;
1690
1691	rc = cyttsp4_startup(cd);
1692	if (rc < 0)
1693		dev_err(cd->dev, "%s: Fail queued startup r=%d\n",
1694			__func__, rc);
1695}
1696
1697static void cyttsp4_free_si_ptrs(struct cyttsp4 *cd)
1698{
1699	struct cyttsp4_sysinfo *si = &cd->sysinfo;
1700
1701	if (!si)
1702		return;
1703
1704	kfree(si->si_ptrs.cydata);
1705	kfree(si->si_ptrs.test);
1706	kfree(si->si_ptrs.pcfg);
1707	kfree(si->si_ptrs.opcfg);
1708	kfree(si->si_ptrs.ddata);
1709	kfree(si->si_ptrs.mdata);
1710	kfree(si->btn);
1711	kfree(si->xy_mode);
1712	kfree(si->xy_data);
1713	kfree(si->btn_rec_data);
1714}
1715
1716#ifdef CONFIG_PM
1717static int cyttsp4_core_sleep(struct cyttsp4 *cd)
1718{
1719	int rc;
1720
1721	rc = cyttsp4_request_exclusive(cd, cd->dev,
1722			CY_CORE_SLEEP_REQUEST_EXCLUSIVE_TIMEOUT);
1723	if (rc < 0) {
1724		dev_err(cd->dev, "%s: fail get exclusive ex=%p own=%p\n",
1725				__func__, cd->exclusive_dev, cd->dev);
1726		return 0;
1727	}
1728
1729	rc = cyttsp4_core_sleep_(cd);
1730
1731	if (cyttsp4_release_exclusive(cd, cd->dev) < 0)
1732		dev_err(cd->dev, "%s: fail to release exclusive\n", __func__);
1733	else
1734		dev_vdbg(cd->dev, "%s: pass release exclusive\n", __func__);
1735
1736	return rc;
1737}
1738
1739static int cyttsp4_core_wake_(struct cyttsp4 *cd)
1740{
1741	struct device *dev = cd->dev;
1742	int rc;
1743	u8 mode;
1744	int t;
1745
1746	/* Already woken? */
1747	mutex_lock(&cd->system_lock);
1748	if (cd->sleep_state == SS_SLEEP_OFF) {
1749		mutex_unlock(&cd->system_lock);
1750		return 0;
1751	}
1752	cd->int_status &= ~CY_INT_IGNORE;
1753	cd->int_status |= CY_INT_AWAKE;
1754	cd->sleep_state = SS_WAKING;
1755
1756	if (cd->cpdata->power) {
1757		dev_dbg(dev, "%s: Power up HW\n", __func__);
1758		rc = cd->cpdata->power(cd->cpdata, 1, dev, &cd->ignore_irq);
1759	} else {
1760		dev_dbg(dev, "%s: No power function\n", __func__);
1761		rc = -ENOSYS;
1762	}
1763	if (rc < 0) {
1764		dev_err(dev, "%s: HW Power up fails r=%d\n",
1765				__func__, rc);
1766
1767		/* Initiate a read transaction to wake up */
1768		cyttsp4_adap_read(cd, CY_REG_BASE, sizeof(mode), &mode);
1769	} else
1770		dev_vdbg(cd->dev, "%s: HW power up succeeds\n",
1771			__func__);
1772	mutex_unlock(&cd->system_lock);
1773
1774	t = wait_event_timeout(cd->wait_q,
1775			(cd->int_status & CY_INT_AWAKE) == 0,
1776			msecs_to_jiffies(CY_CORE_WAKEUP_TIMEOUT));
1777	if (IS_TMO(t)) {
1778		dev_err(dev, "%s: TMO waiting for wakeup\n", __func__);
1779		mutex_lock(&cd->system_lock);
1780		cd->int_status &= ~CY_INT_AWAKE;
1781		/* Try starting up */
1782		cyttsp4_queue_startup_(cd);
1783		mutex_unlock(&cd->system_lock);
1784	}
1785
1786	mutex_lock(&cd->system_lock);
1787	cd->sleep_state = SS_SLEEP_OFF;
1788	mutex_unlock(&cd->system_lock);
1789
1790	cyttsp4_start_wd_timer(cd);
1791
1792	return 0;
1793}
1794
1795static int cyttsp4_core_wake(struct cyttsp4 *cd)
1796{
1797	int rc;
1798
1799	rc = cyttsp4_request_exclusive(cd, cd->dev,
1800			CY_CORE_REQUEST_EXCLUSIVE_TIMEOUT);
1801	if (rc < 0) {
1802		dev_err(cd->dev, "%s: fail get exclusive ex=%p own=%p\n",
1803				__func__, cd->exclusive_dev, cd->dev);
1804		return 0;
1805	}
1806
1807	rc = cyttsp4_core_wake_(cd);
1808
1809	if (cyttsp4_release_exclusive(cd, cd->dev) < 0)
1810		dev_err(cd->dev, "%s: fail to release exclusive\n", __func__);
1811	else
1812		dev_vdbg(cd->dev, "%s: pass release exclusive\n", __func__);
1813
1814	return rc;
1815}
1816
1817static int cyttsp4_core_suspend(struct device *dev)
1818{
1819	struct cyttsp4 *cd = dev_get_drvdata(dev);
1820	struct cyttsp4_mt_data *md = &cd->md;
1821	int rc;
1822
1823	md->is_suspended = true;
1824
1825	rc = cyttsp4_core_sleep(cd);
1826	if (rc < 0) {
1827		dev_err(dev, "%s: Error on sleep\n", __func__);
1828		return -EAGAIN;
1829	}
1830	return 0;
1831}
1832
1833static int cyttsp4_core_resume(struct device *dev)
1834{
1835	struct cyttsp4 *cd = dev_get_drvdata(dev);
1836	struct cyttsp4_mt_data *md = &cd->md;
1837	int rc;
1838
1839	md->is_suspended = false;
1840
1841	rc = cyttsp4_core_wake(cd);
1842	if (rc < 0) {
1843		dev_err(dev, "%s: Error on wake\n", __func__);
1844		return -EAGAIN;
1845	}
1846
1847	return 0;
1848}
1849#endif
1850
1851const struct dev_pm_ops cyttsp4_pm_ops = {
1852	SET_SYSTEM_SLEEP_PM_OPS(cyttsp4_core_suspend, cyttsp4_core_resume)
1853	SET_RUNTIME_PM_OPS(cyttsp4_core_suspend, cyttsp4_core_resume, NULL)
1854};
1855EXPORT_SYMBOL_GPL(cyttsp4_pm_ops);
1856
1857static int cyttsp4_mt_open(struct input_dev *input)
1858{
1859	pm_runtime_get(input->dev.parent);
1860	return 0;
1861}
1862
1863static void cyttsp4_mt_close(struct input_dev *input)
1864{
1865	struct cyttsp4_mt_data *md = input_get_drvdata(input);
1866	mutex_lock(&md->report_lock);
1867	if (!md->is_suspended)
1868		pm_runtime_put(input->dev.parent);
1869	mutex_unlock(&md->report_lock);
1870}
1871
1872
1873static int cyttsp4_setup_input_device(struct cyttsp4 *cd)
1874{
1875	struct device *dev = cd->dev;
1876	struct cyttsp4_mt_data *md = &cd->md;
1877	int signal = CY_IGNORE_VALUE;
1878	int max_x, max_y, max_p, min, max;
1879	int max_x_tmp, max_y_tmp;
1880	int i;
1881	int rc;
1882
1883	dev_vdbg(dev, "%s: Initialize event signals\n", __func__);
1884	__set_bit(EV_ABS, md->input->evbit);
1885	__set_bit(EV_REL, md->input->evbit);
1886	__set_bit(EV_KEY, md->input->evbit);
1887
1888	max_x_tmp = md->si->si_ofs.max_x;
1889	max_y_tmp = md->si->si_ofs.max_y;
1890
1891	/* get maximum values from the sysinfo data */
1892	if (md->pdata->flags & CY_FLAG_FLIP) {
1893		max_x = max_y_tmp - 1;
1894		max_y = max_x_tmp - 1;
1895	} else {
1896		max_x = max_x_tmp - 1;
1897		max_y = max_y_tmp - 1;
1898	}
1899	max_p = md->si->si_ofs.max_p;
1900
1901	/* set event signal capabilities */
1902	for (i = 0; i < (md->pdata->frmwrk->size / CY_NUM_ABS_SET); i++) {
1903		signal = md->pdata->frmwrk->abs
1904			[(i * CY_NUM_ABS_SET) + CY_SIGNAL_OST];
1905		if (signal != CY_IGNORE_VALUE) {
1906			__set_bit(signal, md->input->absbit);
1907			min = md->pdata->frmwrk->abs
1908				[(i * CY_NUM_ABS_SET) + CY_MIN_OST];
1909			max = md->pdata->frmwrk->abs
1910				[(i * CY_NUM_ABS_SET) + CY_MAX_OST];
1911			if (i == CY_ABS_ID_OST) {
1912				/* shift track ids down to start at 0 */
1913				max = max - min;
1914				min = min - min;
1915			} else if (i == CY_ABS_X_OST)
1916				max = max_x;
1917			else if (i == CY_ABS_Y_OST)
1918				max = max_y;
1919			else if (i == CY_ABS_P_OST)
1920				max = max_p;
1921			input_set_abs_params(md->input, signal, min, max,
1922				md->pdata->frmwrk->abs
1923				[(i * CY_NUM_ABS_SET) + CY_FUZZ_OST],
1924				md->pdata->frmwrk->abs
1925				[(i * CY_NUM_ABS_SET) + CY_FLAT_OST]);
1926			dev_dbg(dev, "%s: register signal=%02X min=%d max=%d\n",
1927				__func__, signal, min, max);
1928			if ((i == CY_ABS_ID_OST) &&
1929				(md->si->si_ofs.tch_rec_size <
1930				CY_TMA4XX_TCH_REC_SIZE))
1931				break;
1932		}
1933	}
1934
1935	input_mt_init_slots(md->input, md->si->si_ofs.tch_abs[CY_TCH_T].max,
1936			INPUT_MT_DIRECT);
1937	rc = input_register_device(md->input);
1938	if (rc < 0)
1939		dev_err(dev, "%s: Error, failed register input device r=%d\n",
1940			__func__, rc);
1941	return rc;
1942}
1943
1944static int cyttsp4_mt_probe(struct cyttsp4 *cd)
1945{
1946	struct device *dev = cd->dev;
1947	struct cyttsp4_mt_data *md = &cd->md;
1948	struct cyttsp4_mt_platform_data *pdata = cd->pdata->mt_pdata;
1949	int rc = 0;
1950
1951	mutex_init(&md->report_lock);
1952	md->pdata = pdata;
1953	/* Create the input device and register it. */
1954	dev_vdbg(dev, "%s: Create the input device and register it\n",
1955		__func__);
1956	md->input = input_allocate_device();
1957	if (md->input == NULL) {
1958		dev_err(dev, "%s: Error, failed to allocate input device\n",
1959			__func__);
1960		rc = -ENOSYS;
1961		goto error_alloc_failed;
1962	}
1963
1964	md->input->name = pdata->inp_dev_name;
1965	scnprintf(md->phys, sizeof(md->phys)-1, "%s", dev_name(dev));
1966	md->input->phys = md->phys;
1967	md->input->id.bustype = cd->bus_ops->bustype;
1968	md->input->dev.parent = dev;
1969	md->input->open = cyttsp4_mt_open;
1970	md->input->close = cyttsp4_mt_close;
1971	input_set_drvdata(md->input, md);
1972
1973	/* get sysinfo */
1974	md->si = &cd->sysinfo;
1975	if (!md->si) {
1976		dev_err(dev, "%s: Fail get sysinfo pointer from core p=%p\n",
1977			__func__, md->si);
1978		goto error_get_sysinfo;
1979	}
1980
1981	rc = cyttsp4_setup_input_device(cd);
1982	if (rc)
1983		goto error_init_input;
1984
1985	return 0;
1986
1987error_init_input:
1988	input_free_device(md->input);
1989error_get_sysinfo:
1990	input_set_drvdata(md->input, NULL);
1991error_alloc_failed:
1992	dev_err(dev, "%s failed.\n", __func__);
1993	return rc;
1994}
1995
1996struct cyttsp4 *cyttsp4_probe(const struct cyttsp4_bus_ops *ops,
1997		struct device *dev, u16 irq, size_t xfer_buf_size)
1998{
1999	struct cyttsp4 *cd;
2000	struct cyttsp4_platform_data *pdata = dev_get_platdata(dev);
2001	unsigned long irq_flags;
2002	int rc = 0;
2003
2004	if (!pdata || !pdata->core_pdata || !pdata->mt_pdata) {
2005		dev_err(dev, "%s: Missing platform data\n", __func__);
2006		rc = -ENODEV;
2007		goto error_no_pdata;
2008	}
2009
2010	cd = kzalloc(sizeof(*cd), GFP_KERNEL);
2011	if (!cd) {
2012		dev_err(dev, "%s: Error, kzalloc\n", __func__);
2013		rc = -ENOMEM;
2014		goto error_alloc_data;
2015	}
2016
2017	cd->xfer_buf = kzalloc(xfer_buf_size, GFP_KERNEL);
2018	if (!cd->xfer_buf) {
2019		dev_err(dev, "%s: Error, kzalloc\n", __func__);
2020		rc = -ENOMEM;
2021		goto error_free_cd;
2022	}
2023
2024	/* Initialize device info */
2025	cd->dev = dev;
2026	cd->pdata = pdata;
2027	cd->cpdata = pdata->core_pdata;
2028	cd->bus_ops = ops;
2029
2030	/* Initialize mutexes and spinlocks */
2031	mutex_init(&cd->system_lock);
2032	mutex_init(&cd->adap_lock);
2033
2034	/* Initialize wait queue */
2035	init_waitqueue_head(&cd->wait_q);
2036
2037	/* Initialize works */
2038	INIT_WORK(&cd->startup_work, cyttsp4_startup_work_function);
2039	INIT_WORK(&cd->watchdog_work, cyttsp4_watchdog_work);
2040
2041	/* Initialize IRQ */
2042	cd->irq = gpio_to_irq(cd->cpdata->irq_gpio);
2043	if (cd->irq < 0) {
2044		rc = -EINVAL;
2045		goto error_free_xfer;
2046	}
2047
2048	dev_set_drvdata(dev, cd);
2049
2050	/* Call platform init function */
2051	if (cd->cpdata->init) {
2052		dev_dbg(cd->dev, "%s: Init HW\n", __func__);
2053		rc = cd->cpdata->init(cd->cpdata, 1, cd->dev);
2054	} else {
2055		dev_dbg(cd->dev, "%s: No HW INIT function\n", __func__);
2056		rc = 0;
2057	}
2058	if (rc < 0)
2059		dev_err(cd->dev, "%s: HW Init fail r=%d\n", __func__, rc);
2060
2061	dev_dbg(dev, "%s: initialize threaded irq=%d\n", __func__, cd->irq);
2062	if (cd->cpdata->level_irq_udelay > 0)
2063		/* use level triggered interrupts */
2064		irq_flags = IRQF_TRIGGER_LOW | IRQF_ONESHOT;
2065	else
2066		/* use edge triggered interrupts */
2067		irq_flags = IRQF_TRIGGER_FALLING | IRQF_ONESHOT;
2068
2069	rc = request_threaded_irq(cd->irq, NULL, cyttsp4_irq, irq_flags,
2070		dev_name(dev), cd);
2071	if (rc < 0) {
2072		dev_err(dev, "%s: Error, could not request irq\n", __func__);
2073		goto error_request_irq;
2074	}
2075
2076	/* Setup watchdog timer */
2077	setup_timer(&cd->watchdog_timer, cyttsp4_watchdog_timer,
2078		(unsigned long)cd);
2079
2080	/*
2081	 * call startup directly to ensure that the device
2082	 * is tested before leaving the probe
2083	 */
2084	rc = cyttsp4_startup(cd);
2085
2086	/* Do not fail probe if startup fails but the device is detected */
2087	if (rc < 0 && cd->mode == CY_MODE_UNKNOWN) {
2088		dev_err(cd->dev, "%s: Fail initial startup r=%d\n",
2089			__func__, rc);
2090		goto error_startup;
2091	}
2092
2093	rc = cyttsp4_mt_probe(cd);
2094	if (rc < 0) {
2095		dev_err(dev, "%s: Error, fail mt probe\n", __func__);
2096		goto error_startup;
2097	}
2098
2099	pm_runtime_enable(dev);
2100
2101	return cd;
2102
2103error_startup:
2104	cancel_work_sync(&cd->startup_work);
2105	cyttsp4_stop_wd_timer(cd);
2106	pm_runtime_disable(dev);
2107	cyttsp4_free_si_ptrs(cd);
2108	free_irq(cd->irq, cd);
2109error_request_irq:
2110	if (cd->cpdata->init)
2111		cd->cpdata->init(cd->cpdata, 0, dev);
2112error_free_xfer:
2113	kfree(cd->xfer_buf);
2114error_free_cd:
2115	kfree(cd);
2116error_alloc_data:
2117error_no_pdata:
2118	dev_err(dev, "%s failed.\n", __func__);
2119	return ERR_PTR(rc);
2120}
2121EXPORT_SYMBOL_GPL(cyttsp4_probe);
2122
2123static void cyttsp4_mt_release(struct cyttsp4_mt_data *md)
2124{
2125	input_unregister_device(md->input);
2126	input_set_drvdata(md->input, NULL);
2127}
2128
2129int cyttsp4_remove(struct cyttsp4 *cd)
2130{
2131	struct device *dev = cd->dev;
2132
2133	cyttsp4_mt_release(&cd->md);
2134
2135	/*
2136	 * Suspend the device before freeing the startup_work and stopping
2137	 * the watchdog since sleep function restarts watchdog on failure
2138	 */
2139	pm_runtime_suspend(dev);
2140	pm_runtime_disable(dev);
2141
2142	cancel_work_sync(&cd->startup_work);
2143
2144	cyttsp4_stop_wd_timer(cd);
2145
2146	free_irq(cd->irq, cd);
2147	if (cd->cpdata->init)
2148		cd->cpdata->init(cd->cpdata, 0, dev);
2149	cyttsp4_free_si_ptrs(cd);
2150	kfree(cd);
2151	return 0;
2152}
2153EXPORT_SYMBOL_GPL(cyttsp4_remove);
2154
2155MODULE_LICENSE("GPL");
2156MODULE_DESCRIPTION("Cypress TrueTouch(R) Standard touchscreen core driver");
2157MODULE_AUTHOR("Cypress");