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