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