drivers/input/touchscreen/cyttsp4_core.c

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