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