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