drivers/input/touchscreen/cyttsp4_core.c

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