drivers/input/touchscreen/cyttsp4_core.c

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