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