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