projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tag 'arc-v3.13-rc1-part2' of git://git.kernel.org/pub/scm/linux/kernel/git...
[deliverable/linux.git] / drivers / input / touchscreen / cyttsp4_core.c
CommitLineData
17fb1563
FY		 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{
0fb82ec0 156 *max = 1UL << nbits;
17fb1563
FY		 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
17fb1563
FY		 1249 if (!work_pending(&cd->watchdog_work))
1250 schedule_work(&cd->watchdog_work);
1251
1252 return;
1253}
1254
1255static int cyttsp4_request_exclusive(struct cyttsp4 *cd, void *ownptr,
1256 int timeout_ms)
1257{
1258 int t = msecs_to_jiffies(timeout_ms);
1259 bool with_timeout = (timeout_ms != 0);
1260
1261 mutex_lock(&cd->system_lock);
1262 if (!cd->exclusive_dev && cd->exclusive_waits == 0) {
1263 cd->exclusive_dev = ownptr;
1264 goto exit;
1265 }
1266
1267 cd->exclusive_waits++;
1268wait:
1269 mutex_unlock(&cd->system_lock);
1270 if (with_timeout) {
1271 t = wait_event_timeout(cd->wait_q, !cd->exclusive_dev, t);
1272 if (IS_TMO(t)) {
1273 dev_err(cd->dev, "%s: tmo waiting exclusive access\n",
1274 __func__);
1275 mutex_lock(&cd->system_lock);
1276 cd->exclusive_waits--;
1277 mutex_unlock(&cd->system_lock);
1278 return -ETIME;
1279 }
1280 } else {
1281 wait_event(cd->wait_q, !cd->exclusive_dev);
1282 }
1283 mutex_lock(&cd->system_lock);
1284 if (cd->exclusive_dev)
1285 goto wait;
1286 cd->exclusive_dev = ownptr;
1287 cd->exclusive_waits--;
1288exit:
1289 mutex_unlock(&cd->system_lock);
1290
1291 return 0;
1292}
1293
1294/*
1295 * returns error if was not owned
1296 */
1297static int cyttsp4_release_exclusive(struct cyttsp4 *cd, void *ownptr)
1298{
1299 mutex_lock(&cd->system_lock);
1300 if (cd->exclusive_dev != ownptr) {
1301 mutex_unlock(&cd->system_lock);
1302 return -EINVAL;
1303 }
1304
1305 dev_vdbg(cd->dev, "%s: exclusive_dev %p freed\n",
1306 __func__, cd->exclusive_dev);
1307 cd->exclusive_dev = NULL;
1308 wake_up(&cd->wait_q);
1309 mutex_unlock(&cd->system_lock);
1310 return 0;
1311}
1312
1313static int cyttsp4_wait_bl_heartbeat(struct cyttsp4 *cd)
1314{
1315 long t;
1316 int rc = 0;
1317
1318 /* wait heartbeat */
1319 dev_vdbg(cd->dev, "%s: wait heartbeat...\n", __func__);
1320 t = wait_event_timeout(cd->wait_q, cd->mode == CY_MODE_BOOTLOADER,
1321 msecs_to_jiffies(CY_CORE_RESET_AND_WAIT_TIMEOUT));
1322 if (IS_TMO(t)) {
1323 dev_err(cd->dev, "%s: tmo waiting bl heartbeat cd->mode=%d\n",
1324 __func__, cd->mode);
1325 rc = -ETIME;
1326 }
1327
1328 return rc;
1329}
1330
1331static int cyttsp4_wait_sysinfo_mode(struct cyttsp4 *cd)
1332{
1333 long t;
1334
1335 dev_vdbg(cd->dev, "%s: wait sysinfo...\n", __func__);
1336
1337 t = wait_event_timeout(cd->wait_q, cd->mode == CY_MODE_SYSINFO,
1338 msecs_to_jiffies(CY_CORE_MODE_CHANGE_TIMEOUT));
1339 if (IS_TMO(t)) {
1340 dev_err(cd->dev, "%s: tmo waiting exit bl cd->mode=%d\n",
1341 __func__, cd->mode);
1342 mutex_lock(&cd->system_lock);
1343 cd->int_status &= ~CY_INT_MODE_CHANGE;
1344 mutex_unlock(&cd->system_lock);
1345 return -ETIME;
1346 }
1347
1348 return 0;
1349}
1350
1351static int cyttsp4_reset_and_wait(struct cyttsp4 *cd)
1352{
1353 int rc;
1354
1355 /* reset hardware */
1356 mutex_lock(&cd->system_lock);
1357 dev_dbg(cd->dev, "%s: reset hw...\n", __func__);
1358 rc = cyttsp4_hw_reset(cd);
1359 cd->mode = CY_MODE_UNKNOWN;
1360 mutex_unlock(&cd->system_lock);
1361 if (rc < 0) {
1362 dev_err(cd->dev, "%s:Fail hw reset r=%d\n", __func__, rc);
1363 return rc;
1364 }
1365
1366 return cyttsp4_wait_bl_heartbeat(cd);
1367}
1368
1369/*
1370 * returns err if refused or timeout; block until mode change complete
1371 * bit is set (mode change interrupt)
1372 */
1373static int cyttsp4_set_mode(struct cyttsp4 *cd, int new_mode)
1374{
1375 u8 new_dev_mode;
1376 u8 mode;
1377 long t;
1378 int rc;
1379
1380 switch (new_mode) {
1381 case CY_MODE_OPERATIONAL:
1382 new_dev_mode = CY_HST_OPERATE;
1383 break;
1384 case CY_MODE_SYSINFO:
1385 new_dev_mode = CY_HST_SYSINFO;
1386 break;
1387 case CY_MODE_CAT:
1388 new_dev_mode = CY_HST_CAT;
1389 break;
1390 default:
1391 dev_err(cd->dev, "%s: invalid mode: %02X(%d)\n",
1392 __func__, new_mode, new_mode);
1393 return -EINVAL;
1394 }
1395
1396 /* change mode */
1397 dev_dbg(cd->dev, "%s: %s=%p new_dev_mode=%02X new_mode=%d\n",
1398 __func__, "have exclusive", cd->exclusive_dev,
1399 new_dev_mode, new_mode);
1400
1401 mutex_lock(&cd->system_lock);
1402 rc = cyttsp4_adap_read(cd, CY_REG_BASE, sizeof(mode), &mode);
1403 if (rc < 0) {
1404 mutex_unlock(&cd->system_lock);
1405 dev_err(cd->dev, "%s: Fail read mode r=%d\n",
1406 __func__, rc);
1407 goto exit;
1408 }
1409
1410 /* Clear device mode bits and set to new mode */
1411 mode &= ~CY_HST_MODE;
1412 mode |= new_dev_mode | CY_HST_MODE_CHANGE;
1413
1414 cd->int_status |= CY_INT_MODE_CHANGE;
1415 rc = cyttsp4_adap_write(cd, CY_REG_BASE, sizeof(mode), &mode);
1416 mutex_unlock(&cd->system_lock);
1417 if (rc < 0) {
1418 dev_err(cd->dev, "%s: Fail write mode change r=%d\n",
1419 __func__, rc);
1420 goto exit;
1421 }
1422
1423 /* wait for mode change done interrupt */
1424 t = wait_event_timeout(cd->wait_q,
1425 (cd->int_status & CY_INT_MODE_CHANGE) == 0,
1426 msecs_to_jiffies(CY_CORE_MODE_CHANGE_TIMEOUT));
1427 dev_dbg(cd->dev, "%s: back from wait t=%ld cd->mode=%d\n",
1428 __func__, t, cd->mode);
1429
1430 if (IS_TMO(t)) {
1431 dev_err(cd->dev, "%s: %s\n", __func__,
1432 "tmo waiting mode change");
1433 mutex_lock(&cd->system_lock);
1434 cd->int_status &= ~CY_INT_MODE_CHANGE;
1435 mutex_unlock(&cd->system_lock);
1436 rc = -EINVAL;
1437 }
1438
1439exit:
1440 return rc;
1441}
1442
1443static void cyttsp4_watchdog_work(struct work_struct *work)
1444{
1445 struct cyttsp4 *cd =
1446 container_of(work, struct cyttsp4, watchdog_work);
1447 u8 *mode;
1448 int retval;
1449
17fb1563
FY		 1450 mutex_lock(&cd->system_lock);
1451 retval = cyttsp4_load_status_regs(cd);
1452 if (retval < 0) {
1453 dev_err(cd->dev,
1454 "%s: failed to access device in watchdog timer r=%d\n",
1455 __func__, retval);
1456 cyttsp4_queue_startup_(cd);
1457 goto cyttsp4_timer_watchdog_exit_error;
1458 }
1459 mode = &cd->sysinfo.xy_mode[CY_REG_BASE];
1460 if (IS_BOOTLOADER(mode[0], mode[1])) {
1461 dev_err(cd->dev,
1462 "%s: device found in bootloader mode when operational mode\n",
1463 __func__);
1464 cyttsp4_queue_startup_(cd);
1465 goto cyttsp4_timer_watchdog_exit_error;
1466 }
1467
1468 cyttsp4_start_wd_timer(cd);
1469cyttsp4_timer_watchdog_exit_error:
1470 mutex_unlock(&cd->system_lock);
1471 return;
1472}
1473
1474static int cyttsp4_core_sleep_(struct cyttsp4 *cd)
1475{
1476 enum cyttsp4_sleep_state ss = SS_SLEEP_ON;
1477 enum cyttsp4_int_state int_status = CY_INT_IGNORE;
1478 int rc = 0;
1479 u8 mode[2];
1480
1481 /* Already in sleep mode? */
1482 mutex_lock(&cd->system_lock);
1483 if (cd->sleep_state == SS_SLEEP_ON) {
1484 mutex_unlock(&cd->system_lock);
1485 return 0;
1486 }
1487 cd->sleep_state = SS_SLEEPING;
1488 mutex_unlock(&cd->system_lock);
1489
1490 cyttsp4_stop_wd_timer(cd);
1491
1492 /* Wait until currently running IRQ handler exits and disable IRQ */
1493 disable_irq(cd->irq);
1494
1495 dev_vdbg(cd->dev, "%s: write DEEP SLEEP...\n", __func__);
1496 mutex_lock(&cd->system_lock);
1497 rc = cyttsp4_adap_read(cd, CY_REG_BASE, sizeof(mode), &mode);
1498 if (rc) {
1499 mutex_unlock(&cd->system_lock);
1500 dev_err(cd->dev, "%s: Fail read adapter r=%d\n", __func__, rc);
1501 goto error;
1502 }
1503
1504 if (IS_BOOTLOADER(mode[0], mode[1])) {
1505 mutex_unlock(&cd->system_lock);
1506 dev_err(cd->dev, "%s: Device in BOOTLADER mode.\n", __func__);
1507 rc = -EINVAL;
1508 goto error;
1509 }
1510
1511 mode[0] |= CY_HST_SLEEP;
1512 rc = cyttsp4_adap_write(cd, CY_REG_BASE, sizeof(mode[0]), &mode[0]);
1513 mutex_unlock(&cd->system_lock);
1514 if (rc) {
1515 dev_err(cd->dev, "%s: Fail write adapter r=%d\n", __func__, rc);
1516 goto error;
1517 }
1518 dev_vdbg(cd->dev, "%s: write DEEP SLEEP succeeded\n", __func__);
1519
1520 if (cd->cpdata->power) {
1521 dev_dbg(cd->dev, "%s: Power down HW\n", __func__);
1522 rc = cd->cpdata->power(cd->cpdata, 0, cd->dev, &cd->ignore_irq);
1523 } else {
1524 dev_dbg(cd->dev, "%s: No power function\n", __func__);
1525 rc = 0;
1526 }
1527 if (rc < 0) {
1528 dev_err(cd->dev, "%s: HW Power down fails r=%d\n",
1529 __func__, rc);
1530 goto error;
1531 }
1532
1533 /* Give time to FW to sleep */
1534 msleep(50);
1535
1536 goto exit;
1537
1538error:
1539 ss = SS_SLEEP_OFF;
1540 int_status = CY_INT_NONE;
1541 cyttsp4_start_wd_timer(cd);
1542
1543exit:
1544 mutex_lock(&cd->system_lock);
1545 cd->sleep_state = ss;
1546 cd->int_status |= int_status;
1547 mutex_unlock(&cd->system_lock);
1548 enable_irq(cd->irq);
1549 return rc;
1550}
1551
17fb1563
FY		 1552static int cyttsp4_startup_(struct cyttsp4 *cd)
1553{
1554 int retry = CY_CORE_STARTUP_RETRY_COUNT;
1555 int rc;
1556
1557 cyttsp4_stop_wd_timer(cd);
1558
1559reset:
1560 if (retry != CY_CORE_STARTUP_RETRY_COUNT)
1561 dev_dbg(cd->dev, "%s: Retry %d\n", __func__,
1562 CY_CORE_STARTUP_RETRY_COUNT - retry);
1563
1564 /* reset hardware and wait for heartbeat */
1565 rc = cyttsp4_reset_and_wait(cd);
1566 if (rc < 0) {
1567 dev_err(cd->dev, "%s: Error on h/w reset r=%d\n", __func__, rc);
1568 if (retry--)
1569 goto reset;
1570 goto exit;
1571 }
1572
1573 /* exit bl into sysinfo mode */
1574 dev_vdbg(cd->dev, "%s: write exit ldr...\n", __func__);
1575 mutex_lock(&cd->system_lock);
1576 cd->int_status &= ~CY_INT_IGNORE;
1577 cd->int_status |= CY_INT_MODE_CHANGE;
1578
1579 rc = cyttsp4_adap_write(cd, CY_REG_BASE, sizeof(ldr_exit),
1580 (u8 *)ldr_exit);
1581 mutex_unlock(&cd->system_lock);
1582 if (rc < 0) {
1583 dev_err(cd->dev, "%s: Fail write r=%d\n", __func__, rc);
1584 if (retry--)
1585 goto reset;
1586 goto exit;
1587 }
1588
1589 rc = cyttsp4_wait_sysinfo_mode(cd);
1590 if (rc < 0) {
1591 u8 buf[sizeof(ldr_err_app)];
1592 int rc1;
1593
1594 /* Check for invalid/corrupted touch application */
1595 rc1 = cyttsp4_adap_read(cd, CY_REG_BASE, sizeof(ldr_err_app),
1596 buf);
1597 if (rc1) {
1598 dev_err(cd->dev, "%s: Fail read r=%d\n", __func__, rc1);
1599 } else if (!memcmp(buf, ldr_err_app, sizeof(ldr_err_app))) {
1600 dev_err(cd->dev, "%s: Error launching touch application\n",
1601 __func__);
1602 mutex_lock(&cd->system_lock);
1603 cd->invalid_touch_app = true;
1604 mutex_unlock(&cd->system_lock);
1605 goto exit_no_wd;
1606 }
1607
1608 if (retry--)
1609 goto reset;
1610 goto exit;
1611 }
1612
1613 mutex_lock(&cd->system_lock);
1614 cd->invalid_touch_app = false;
1615 mutex_unlock(&cd->system_lock);
1616
1617 /* read sysinfo data */
1618 dev_vdbg(cd->dev, "%s: get sysinfo regs..\n", __func__);
1619 rc = cyttsp4_get_sysinfo_regs(cd);
1620 if (rc < 0) {
1621 dev_err(cd->dev, "%s: failed to get sysinfo regs rc=%d\n",
1622 __func__, rc);
1623 if (retry--)
1624 goto reset;
1625 goto exit;
1626 }
1627
1628 rc = cyttsp4_set_mode(cd, CY_MODE_OPERATIONAL);
1629 if (rc < 0) {
1630 dev_err(cd->dev, "%s: failed to set mode to operational rc=%d\n",
1631 __func__, rc);
1632 if (retry--)
1633 goto reset;
1634 goto exit;
1635 }
1636
1637 cyttsp4_lift_all(&cd->md);
1638
1639 /* restore to sleep if was suspended */
1640 mutex_lock(&cd->system_lock);
1641 if (cd->sleep_state == SS_SLEEP_ON) {
1642 cd->sleep_state = SS_SLEEP_OFF;
1643 mutex_unlock(&cd->system_lock);
1644 cyttsp4_core_sleep_(cd);
1645 goto exit_no_wd;
1646 }
1647 mutex_unlock(&cd->system_lock);
1648
1649exit:
1650 cyttsp4_start_wd_timer(cd);
1651exit_no_wd:
1652 return rc;
1653}
1654
1655static int cyttsp4_startup(struct cyttsp4 *cd)
1656{
1657 int rc;
1658
1659 mutex_lock(&cd->system_lock);
1660 cd->startup_state = STARTUP_RUNNING;
1661 mutex_unlock(&cd->system_lock);
1662
1663 rc = cyttsp4_request_exclusive(cd, cd->dev,
1664 CY_CORE_REQUEST_EXCLUSIVE_TIMEOUT);
1665 if (rc < 0) {
1666 dev_err(cd->dev, "%s: fail get exclusive ex=%p own=%p\n",
1667 __func__, cd->exclusive_dev, cd->dev);
1668 goto exit;
1669 }
1670
1671 rc = cyttsp4_startup_(cd);
1672
1673 if (cyttsp4_release_exclusive(cd, cd->dev) < 0)
1674 /* Don't return fail code, mode is already changed. */
1675 dev_err(cd->dev, "%s: fail to release exclusive\n", __func__);
1676 else
1677 dev_vdbg(cd->dev, "%s: pass release exclusive\n", __func__);
1678
1679exit:
1680 mutex_lock(&cd->system_lock);
1681 cd->startup_state = STARTUP_NONE;
1682 mutex_unlock(&cd->system_lock);
1683
1684 /* Wake the waiters for end of startup */
1685 wake_up(&cd->wait_q);
1686
1687 return rc;
1688}
1689
1690static void cyttsp4_startup_work_function(struct work_struct *work)
1691{
1692 struct cyttsp4 *cd = container_of(work, struct cyttsp4, startup_work);
1693 int rc;
1694
1695 rc = cyttsp4_startup(cd);
1696 if (rc < 0)
1697 dev_err(cd->dev, "%s: Fail queued startup r=%d\n",
1698 __func__, rc);
1699}
1700
1701static void cyttsp4_free_si_ptrs(struct cyttsp4 *cd)
1702{
1703 struct cyttsp4_sysinfo *si = &cd->sysinfo;
1704
1705 if (!si)
1706 return;
1707
1708 kfree(si->si_ptrs.cydata);
1709 kfree(si->si_ptrs.test);
1710 kfree(si->si_ptrs.pcfg);
1711 kfree(si->si_ptrs.opcfg);
1712 kfree(si->si_ptrs.ddata);
1713 kfree(si->si_ptrs.mdata);
1714 kfree(si->btn);
1715 kfree(si->xy_mode);
1716 kfree(si->xy_data);
1717 kfree(si->btn_rec_data);
1718}
1719
1720#if defined(CONFIG_PM_SLEEP) || defined(CONFIG_PM_RUNTIME)
ca0abe3d
GU		 1721static int cyttsp4_core_sleep(struct cyttsp4 *cd)
1722{
1723 int rc;
1724
1725 rc = cyttsp4_request_exclusive(cd, cd->dev,
1726 CY_CORE_SLEEP_REQUEST_EXCLUSIVE_TIMEOUT);
1727 if (rc < 0) {
1728 dev_err(cd->dev, "%s: fail get exclusive ex=%p own=%p\n",
1729 __func__, cd->exclusive_dev, cd->dev);
1730 return 0;
1731 }
1732
1733 rc = cyttsp4_core_sleep_(cd);
1734
1735 if (cyttsp4_release_exclusive(cd, cd->dev) < 0)
1736 dev_err(cd->dev, "%s: fail to release exclusive\n", __func__);
1737 else
1738 dev_vdbg(cd->dev, "%s: pass release exclusive\n", __func__);
1739
1740 return rc;
1741}
1742
1743static int cyttsp4_core_wake_(struct cyttsp4 *cd)
1744{
1745 struct device *dev = cd->dev;
1746 int rc;
1747 u8 mode;
1748 int t;
1749
1750 /* Already woken? */
1751 mutex_lock(&cd->system_lock);
1752 if (cd->sleep_state == SS_SLEEP_OFF) {
1753 mutex_unlock(&cd->system_lock);
1754 return 0;
1755 }
1756 cd->int_status &= ~CY_INT_IGNORE;
1757 cd->int_status |= CY_INT_AWAKE;
1758 cd->sleep_state = SS_WAKING;
1759
1760 if (cd->cpdata->power) {
1761 dev_dbg(dev, "%s: Power up HW\n", __func__);
1762 rc = cd->cpdata->power(cd->cpdata, 1, dev, &cd->ignore_irq);
1763 } else {
1764 dev_dbg(dev, "%s: No power function\n", __func__);
1765 rc = -ENOSYS;
1766 }
1767 if (rc < 0) {
1768 dev_err(dev, "%s: HW Power up fails r=%d\n",
1769 __func__, rc);
1770
1771 /* Initiate a read transaction to wake up */
1772 cyttsp4_adap_read(cd, CY_REG_BASE, sizeof(mode), &mode);
1773 } else
1774 dev_vdbg(cd->dev, "%s: HW power up succeeds\n",
1775 __func__);
1776 mutex_unlock(&cd->system_lock);
1777
1778 t = wait_event_timeout(cd->wait_q,
1779 (cd->int_status & CY_INT_AWAKE) == 0,
1780 msecs_to_jiffies(CY_CORE_WAKEUP_TIMEOUT));
1781 if (IS_TMO(t)) {
1782 dev_err(dev, "%s: TMO waiting for wakeup\n", __func__);
1783 mutex_lock(&cd->system_lock);
1784 cd->int_status &= ~CY_INT_AWAKE;
1785 /* Try starting up */
1786 cyttsp4_queue_startup_(cd);
1787 mutex_unlock(&cd->system_lock);
1788 }
1789
1790 mutex_lock(&cd->system_lock);
1791 cd->sleep_state = SS_SLEEP_OFF;
1792 mutex_unlock(&cd->system_lock);
1793
1794 cyttsp4_start_wd_timer(cd);
1795
1796 return 0;
1797}
1798
1799static int cyttsp4_core_wake(struct cyttsp4 *cd)
1800{
1801 int rc;
1802
1803 rc = cyttsp4_request_exclusive(cd, cd->dev,
1804 CY_CORE_REQUEST_EXCLUSIVE_TIMEOUT);
1805 if (rc < 0) {
1806 dev_err(cd->dev, "%s: fail get exclusive ex=%p own=%p\n",
1807 __func__, cd->exclusive_dev, cd->dev);
1808 return 0;
1809 }
1810
1811 rc = cyttsp4_core_wake_(cd);
1812
1813 if (cyttsp4_release_exclusive(cd, cd->dev) < 0)
1814 dev_err(cd->dev, "%s: fail to release exclusive\n", __func__);
1815 else
1816 dev_vdbg(cd->dev, "%s: pass release exclusive\n", __func__);
1817
1818 return rc;
1819}
1820
17fb1563
FY		 1821static int cyttsp4_core_suspend(struct device *dev)
1822{
1823 struct cyttsp4 *cd = dev_get_drvdata(dev);
1824 struct cyttsp4_mt_data *md = &cd->md;
1825 int rc;
1826
1827 md->is_suspended = true;
1828
1829 rc = cyttsp4_core_sleep(cd);
1830 if (rc < 0) {
1831 dev_err(dev, "%s: Error on sleep\n", __func__);
1832 return -EAGAIN;
1833 }
1834 return 0;
1835}
1836
1837static int cyttsp4_core_resume(struct device *dev)
1838{
1839 struct cyttsp4 *cd = dev_get_drvdata(dev);
1840 struct cyttsp4_mt_data *md = &cd->md;
1841 int rc;
1842
1843 md->is_suspended = false;
1844
1845 rc = cyttsp4_core_wake(cd);
1846 if (rc < 0) {
1847 dev_err(dev, "%s: Error on wake\n", __func__);
1848 return -EAGAIN;
1849 }
1850
1851 return 0;
1852}
1853#endif
1854
1855const struct dev_pm_ops cyttsp4_pm_ops = {
1856 SET_SYSTEM_SLEEP_PM_OPS(cyttsp4_core_suspend, cyttsp4_core_resume)
1857 SET_RUNTIME_PM_OPS(cyttsp4_core_suspend, cyttsp4_core_resume, NULL)
1858};
1859EXPORT_SYMBOL_GPL(cyttsp4_pm_ops);
1860
1861static int cyttsp4_mt_open(struct input_dev *input)
1862{
1863 pm_runtime_get(input->dev.parent);
1864 return 0;
1865}
1866
1867static void cyttsp4_mt_close(struct input_dev *input)
1868{
1869 struct cyttsp4_mt_data *md = input_get_drvdata(input);
1870 mutex_lock(&md->report_lock);
1871 if (!md->is_suspended)
1872 pm_runtime_put(input->dev.parent);
1873 mutex_unlock(&md->report_lock);
1874}
1875
1876
1877static int cyttsp4_setup_input_device(struct cyttsp4 *cd)
1878{
1879 struct device *dev = cd->dev;
1880 struct cyttsp4_mt_data *md = &cd->md;
1881 int signal = CY_IGNORE_VALUE;
1882 int max_x, max_y, max_p, min, max;
1883 int max_x_tmp, max_y_tmp;
1884 int i;
1885 int rc;
1886
1887 dev_vdbg(dev, "%s: Initialize event signals\n", __func__);
1888 __set_bit(EV_ABS, md->input->evbit);
1889 __set_bit(EV_REL, md->input->evbit);
1890 __set_bit(EV_KEY, md->input->evbit);
1891
1892 max_x_tmp = md->si->si_ofs.max_x;
1893 max_y_tmp = md->si->si_ofs.max_y;
1894
1895 /* get maximum values from the sysinfo data */
1896 if (md->pdata->flags & CY_FLAG_FLIP) {
1897 max_x = max_y_tmp - 1;
1898 max_y = max_x_tmp - 1;
1899 } else {
1900 max_x = max_x_tmp - 1;
1901 max_y = max_y_tmp - 1;
1902 }
1903 max_p = md->si->si_ofs.max_p;
1904
1905 /* set event signal capabilities */
1906 for (i = 0; i < (md->pdata->frmwrk->size / CY_NUM_ABS_SET); i++) {
1907 signal = md->pdata->frmwrk->abs
1908 [(i * CY_NUM_ABS_SET) + CY_SIGNAL_OST];
1909 if (signal != CY_IGNORE_VALUE) {
1910 __set_bit(signal, md->input->absbit);
1911 min = md->pdata->frmwrk->abs
1912 [(i * CY_NUM_ABS_SET) + CY_MIN_OST];
1913 max = md->pdata->frmwrk->abs
1914 [(i * CY_NUM_ABS_SET) + CY_MAX_OST];
1915 if (i == CY_ABS_ID_OST) {
1916 /* shift track ids down to start at 0 */
1917 max = max - min;
1918 min = min - min;
1919 } else if (i == CY_ABS_X_OST)
1920 max = max_x;
1921 else if (i == CY_ABS_Y_OST)
1922 max = max_y;
1923 else if (i == CY_ABS_P_OST)
1924 max = max_p;
1925 input_set_abs_params(md->input, signal, min, max,
1926 md->pdata->frmwrk->abs
1927 [(i * CY_NUM_ABS_SET) + CY_FUZZ_OST],
1928 md->pdata->frmwrk->abs
1929 [(i * CY_NUM_ABS_SET) + CY_FLAT_OST]);
1930 dev_dbg(dev, "%s: register signal=%02X min=%d max=%d\n",
1931 __func__, signal, min, max);
1932 if ((i == CY_ABS_ID_OST) &&
1933 (md->si->si_ofs.tch_rec_size <
1934 CY_TMA4XX_TCH_REC_SIZE))
1935 break;
1936 }
1937 }
1938
1939 input_mt_init_slots(md->input, md->si->si_ofs.tch_abs[CY_TCH_T].max,
1940 INPUT_MT_DIRECT);
1941 rc = input_register_device(md->input);
1942 if (rc < 0)
1943 dev_err(dev, "%s: Error, failed register input device r=%d\n",
1944 __func__, rc);
1945 return rc;
1946}
1947
1948static int cyttsp4_mt_probe(struct cyttsp4 *cd)
1949{
1950 struct device *dev = cd->dev;
1951 struct cyttsp4_mt_data *md = &cd->md;
1952 struct cyttsp4_mt_platform_data *pdata = cd->pdata->mt_pdata;
1953 int rc = 0;
1954
1955 mutex_init(&md->report_lock);
1956 md->pdata = pdata;
1957 /* Create the input device and register it. */
1958 dev_vdbg(dev, "%s: Create the input device and register it\n",
1959 __func__);
1960 md->input = input_allocate_device();
1961 if (md->input == NULL) {
1962 dev_err(dev, "%s: Error, failed to allocate input device\n",
1963 __func__);
1964 rc = -ENOSYS;
1965 goto error_alloc_failed;
1966 }
1967
1968 md->input->name = pdata->inp_dev_name;
1969 scnprintf(md->phys, sizeof(md->phys)-1, "%s", dev_name(dev));
1970 md->input->phys = md->phys;
1971 md->input->id.bustype = cd->bus_ops->bustype;
1972 md->input->dev.parent = dev;
1973 md->input->open = cyttsp4_mt_open;
1974 md->input->close = cyttsp4_mt_close;
1975 input_set_drvdata(md->input, md);
1976
1977 /* get sysinfo */
1978 md->si = &cd->sysinfo;
1979 if (!md->si) {
1980 dev_err(dev, "%s: Fail get sysinfo pointer from core p=%p\n",
1981 __func__, md->si);
1982 goto error_get_sysinfo;
1983 }
1984
1985 rc = cyttsp4_setup_input_device(cd);
1986 if (rc)
1987 goto error_init_input;
1988
1989 return 0;
1990
1991error_init_input:
1992 input_free_device(md->input);
1993error_get_sysinfo:
1994 input_set_drvdata(md->input, NULL);
1995error_alloc_failed:
1996 dev_err(dev, "%s failed.\n", __func__);
1997 return rc;
1998}
1999
2000struct cyttsp4 *cyttsp4_probe(const struct cyttsp4_bus_ops *ops,
2001 struct device *dev, u16 irq, size_t xfer_buf_size)
2002{
2003 struct cyttsp4 *cd;
2004 struct cyttsp4_platform_data *pdata = dev_get_platdata(dev);
2005 unsigned long irq_flags;
2006 int rc = 0;
2007
2008 if (!pdata || !pdata->core_pdata || !pdata->mt_pdata) {
2009 dev_err(dev, "%s: Missing platform data\n", __func__);
2010 rc = -ENODEV;
2011 goto error_no_pdata;
2012 }
2013
2014 cd = kzalloc(sizeof(*cd), GFP_KERNEL);
2015 if (!cd) {
2016 dev_err(dev, "%s: Error, kzalloc\n", __func__);
2017 rc = -ENOMEM;
2018 goto error_alloc_data;
2019 }
2020
2021 cd->xfer_buf = kzalloc(xfer_buf_size, GFP_KERNEL);
2022 if (!cd->xfer_buf) {
2023 dev_err(dev, "%s: Error, kzalloc\n", __func__);
2024 rc = -ENOMEM;
394fc05b 2025 goto error_free_cd;
17fb1563
FY		 2026 }
2027
2028 /* Initialize device info */
2029 cd->dev = dev;
2030 cd->pdata = pdata;
2031 cd->cpdata = pdata->core_pdata;
2032 cd->bus_ops = ops;
2033
2034 /* Initialize mutexes and spinlocks */
2035 mutex_init(&cd->system_lock);
2036 mutex_init(&cd->adap_lock);
2037
2038 /* Initialize wait queue */
2039 init_waitqueue_head(&cd->wait_q);
2040
2041 /* Initialize works */
2042 INIT_WORK(&cd->startup_work, cyttsp4_startup_work_function);
2043 INIT_WORK(&cd->watchdog_work, cyttsp4_watchdog_work);
2044
2045 /* Initialize IRQ */
2046 cd->irq = gpio_to_irq(cd->cpdata->irq_gpio);
2047 if (cd->irq < 0) {
2048 rc = -EINVAL;
57961e3b 2049 goto error_free_xfer;
17fb1563
FY		 2050 }
2051
2052 dev_set_drvdata(dev, cd);
2053
2054 /* Call platform init function */
2055 if (cd->cpdata->init) {
2056 dev_dbg(cd->dev, "%s: Init HW\n", __func__);
2057 rc = cd->cpdata->init(cd->cpdata, 1, cd->dev);
2058 } else {
2059 dev_dbg(cd->dev, "%s: No HW INIT function\n", __func__);
2060 rc = 0;
2061 }
2062 if (rc < 0)
2063 dev_err(cd->dev, "%s: HW Init fail r=%d\n", __func__, rc);
2064
2065 dev_dbg(dev, "%s: initialize threaded irq=%d\n", __func__, cd->irq);
2066 if (cd->cpdata->level_irq_udelay > 0)
2067 /* use level triggered interrupts */
2068 irq_flags = IRQF_TRIGGER_LOW | IRQF_ONESHOT;
2069 else
2070 /* use edge triggered interrupts */
2071 irq_flags = IRQF_TRIGGER_FALLING | IRQF_ONESHOT;
2072
2073 rc = request_threaded_irq(cd->irq, NULL, cyttsp4_irq, irq_flags,
2074 dev_name(dev), cd);
2075 if (rc < 0) {
2076 dev_err(dev, "%s: Error, could not request irq\n", __func__);
2077 goto error_request_irq;
2078 }
2079
2080 /* Setup watchdog timer */
2081 setup_timer(&cd->watchdog_timer, cyttsp4_watchdog_timer,
2082 (unsigned long)cd);
2083
2084 /*
2085 * call startup directly to ensure that the device
2086 * is tested before leaving the probe
2087 */
2088 rc = cyttsp4_startup(cd);
2089
2090 /* Do not fail probe if startup fails but the device is detected */
2091 if (rc < 0 && cd->mode == CY_MODE_UNKNOWN) {
2092 dev_err(cd->dev, "%s: Fail initial startup r=%d\n",
2093 __func__, rc);
2094 goto error_startup;
2095 }
2096
2097 rc = cyttsp4_mt_probe(cd);
2098 if (rc < 0) {
2099 dev_err(dev, "%s: Error, fail mt probe\n", __func__);
2100 goto error_startup;
2101 }
2102
2103 pm_runtime_enable(dev);
2104
2105 return cd;
2106
2107error_startup:
2108 cancel_work_sync(&cd->startup_work);
2109 cyttsp4_stop_wd_timer(cd);
2110 pm_runtime_disable(dev);
2111 cyttsp4_free_si_ptrs(cd);
2112 free_irq(cd->irq, cd);
2113error_request_irq:
2114 if (cd->cpdata->init)
2115 cd->cpdata->init(cd->cpdata, 0, dev);
57961e3b
FY		 2116error_free_xfer:
2117 kfree(cd->xfer_buf);
394fc05b 2118error_free_cd:
17fb1563
FY		 2119 kfree(cd);
2120error_alloc_data:
2121error_no_pdata:
2122 dev_err(dev, "%s failed.\n", __func__);
2123 return ERR_PTR(rc);
2124}
2125EXPORT_SYMBOL_GPL(cyttsp4_probe);
2126
2127static void cyttsp4_mt_release(struct cyttsp4_mt_data *md)
2128{
2129 input_unregister_device(md->input);
2130 input_set_drvdata(md->input, NULL);
2131}
2132
2133int cyttsp4_remove(struct cyttsp4 *cd)
2134{
2135 struct device *dev = cd->dev;
2136
2137 cyttsp4_mt_release(&cd->md);
2138
2139 /*
2140 * Suspend the device before freeing the startup_work and stopping
2141 * the watchdog since sleep function restarts watchdog on failure
2142 */
2143 pm_runtime_suspend(dev);
2144 pm_runtime_disable(dev);
2145
2146 cancel_work_sync(&cd->startup_work);
2147
2148 cyttsp4_stop_wd_timer(cd);
2149
2150 free_irq(cd->irq, cd);
2151 if (cd->cpdata->init)
2152 cd->cpdata->init(cd->cpdata, 0, dev);
17fb1563
FY		 2153 cyttsp4_free_si_ptrs(cd);
2154 kfree(cd);
2155 return 0;
2156}
2157EXPORT_SYMBOL_GPL(cyttsp4_remove);
2158
2159MODULE_LICENSE("GPL");
2160MODULE_DESCRIPTION("Cypress TrueTouch(R) Standard touchscreen core driver");
2161MODULE_AUTHOR("Cypress");
Linux kernel - Deliverables
This page took 0.123519 seconds and 5 git commands to generate.