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