]>
Commit | Line | Data |
---|---|---|
a4cff8b8 SD |
1 | /* |
2 | * intel_mid_touch.c - Intel MID Resistive Touch Screen Driver | |
3 | * | |
4 | * Copyright (C) 2008 Intel Corp | |
5 | * | |
6 | * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
7 | * | |
8 | * This program is free software; you can redistribute it and/or modify | |
9 | * it under the terms of the GNU General Public License as published by | |
10 | * the Free Software Foundation; version 2 of the License. | |
11 | * | |
12 | * This program is distributed in the hope that it will be useful, but | |
13 | * WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
15 | * General Public License for more details. | |
16 | * | |
17 | * You should have received a copy of the GNU General Public License along | |
18 | * with this program; ifnot, write to the Free Software Foundation, Inc., | |
19 | * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. | |
20 | * | |
21 | * Questions/Comments/Bug fixes to Sreedhara (sreedhara.ds@intel.com) | |
22 | * Ramesh Agarwal (ramesh.agarwal@intel.com) | |
23 | * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
24 | * | |
25 | * TODO: | |
26 | * kill off mrstouch_debug eventually | |
27 | * review conversion of r/m/w sequences | |
28 | * Replace interrupt mutex abuse | |
29 | * Kill of mrstouchdevp pointer | |
30 | * | |
31 | */ | |
32 | ||
33 | #include <linux/module.h> | |
34 | #include <linux/init.h> | |
35 | #include <linux/input.h> | |
36 | #include <linux/interrupt.h> | |
37 | #include <linux/err.h> | |
38 | #include <linux/param.h> | |
39 | #include <linux/spi/spi.h> | |
40 | #include <linux/irq.h> | |
41 | #include <linux/delay.h> | |
42 | #include <linux/kthread.h> | |
43 | #include <asm/intel_scu_ipc.h> | |
44 | ||
45 | ||
46 | #if defined(MRSTOUCH_DEBUG) | |
47 | #define mrstouch_debug(fmt, args...)\ | |
48 | do { \ | |
49 | printk(KERN_DEBUG "\n[MRSTOUCH(%d)] - ", __LINE__); \ | |
50 | printk(KERN_DEBUG fmt, ##args); \ | |
51 | } while (0); | |
52 | #else | |
53 | #define mrstouch_debug(fmt, args...) | |
54 | #endif | |
55 | ||
56 | /* PMIC Interrupt registers */ | |
57 | #define PMIC_REG_ID1 0x00 /*PMIC ID1 register */ | |
58 | ||
59 | /* PMIC Interrupt registers */ | |
60 | #define PMIC_REG_INT 0x04 /*PMIC interrupt register */ | |
61 | #define PMIC_REG_MINT 0x05 /*PMIC interrupt mask register */ | |
62 | ||
63 | /* ADC Interrupt registers */ | |
64 | #define PMIC_REG_ADCINT 0x5F /*ADC interrupt register */ | |
65 | #define PMIC_REG_MADCINT 0x60 /*ADC interrupt mask register */ | |
66 | ||
67 | /* ADC Control registers */ | |
68 | #define PMIC_REG_ADCCNTL1 0x61 /*ADC control register */ | |
69 | ||
70 | /* ADC Channel Selection registers */ | |
71 | #define PMICADDR0 0xA4 | |
72 | #define END_OF_CHANNEL 0x1F | |
73 | ||
74 | /* ADC Result register */ | |
75 | #define PMIC_REG_ADCSNS0H 0x64 | |
76 | ||
77 | /* ADC channels for touch screen */ | |
78 | #define MRST_TS_CHAN10 0xA /* Touch screen X+ connection */ | |
79 | #define MRST_TS_CHAN11 0xB /* Touch screen X- connection */ | |
80 | #define MRST_TS_CHAN12 0xC /* Touch screen Y+ connection */ | |
81 | #define MRST_TS_CHAN13 0xD /* Touch screen Y- connection */ | |
82 | ||
83 | /* Touch screen coordinate constants */ | |
84 | #define TOUCH_PRESSURE 50 | |
85 | #define TOUCH_PRESSURE_FS 100 | |
86 | ||
87 | #define XMOVE_LIMIT 5 | |
88 | #define YMOVE_LIMIT 5 | |
89 | #define XYMOVE_CNT 3 | |
90 | ||
91 | #define MAX_10BIT ((1<<10)-1) | |
92 | ||
93 | /* Touch screen channel BIAS constants */ | |
94 | #define XBIAS 0x20 | |
95 | #define YBIAS 0x40 | |
96 | #define ZBIAS 0x80 | |
97 | ||
98 | /* Touch screen coordinates */ | |
99 | #define MIN_X 10 | |
100 | #define MAX_X 1024 | |
101 | #define MIN_Y 10 | |
102 | #define MAX_Y 1024 | |
103 | #define WAIT_ADC_COMPLETION 10 | |
104 | ||
105 | /* PMIC ADC round robin delays */ | |
106 | #define ADC_LOOP_DELAY0 0x0 /* Continuous loop */ | |
107 | #define ADC_LOOP_DELAY1 0x1 /* 4.5 ms approximate */ | |
108 | ||
109 | /* PMIC Vendor Identifiers */ | |
110 | #define PMIC_VENDOR_FS 0 /* PMIC vendor FreeScale */ | |
111 | #define PMIC_VENDOR_MAXIM 1 /* PMIC vendor MAXIM */ | |
112 | #define PMIC_VENDOR_NEC 2 /* PMIC vendor NEC */ | |
113 | #define MRSTOUCH_MAX_CHANNELS 32 /* Maximum ADC channels */ | |
114 | ||
115 | /* Touch screen device structure */ | |
116 | struct mrstouch_dev { | |
117 | struct spi_device *spi; /* SPI device associated with touch screen */ | |
118 | struct input_dev *input; /* input device for touchscreen*/ | |
119 | char phys[32]; /* Device name */ | |
120 | struct task_struct *pendet_thrd; /* PENDET interrupt handler */ | |
121 | struct mutex lock; /* Sync between interrupt and PENDET handler */ | |
122 | bool busy; /* Busy flag */ | |
123 | u16 asr; /* Address selection register */ | |
124 | int irq; /* Touch screen IRQ # */ | |
125 | uint vendor; /* PMIC vendor */ | |
126 | uint rev; /* PMIC revision */ | |
127 | bool suspended; /* Device suspended status */ | |
128 | bool disabled; /* Device disabled status */ | |
129 | u16 x; /* X coordinate */ | |
130 | u16 y; /* Y coordinate */ | |
131 | bool pendown; /* PEN position */ | |
132 | } ; | |
133 | ||
134 | ||
135 | /* Global Pointer to Touch screen device */ | |
136 | static struct mrstouch_dev *mrstouchdevp; | |
137 | ||
138 | /* Utility to read PMIC ID */ | |
139 | static int mrstouch_pmic_id(uint *vendor, uint *rev) | |
140 | { | |
141 | int err; | |
142 | u8 r; | |
143 | ||
144 | err = intel_scu_ipc_ioread8(PMIC_REG_ID1, &r); | |
145 | if (err) | |
146 | return err; | |
147 | ||
148 | *vendor = r & 0x7; | |
149 | *rev = (r >> 3) & 0x7; | |
150 | ||
151 | return 0; | |
152 | } | |
153 | ||
154 | /* | |
155 | * Parse ADC channels to find end of the channel configured by other ADC user | |
156 | * NEC and MAXIM requires 4 channels and FreeScale needs 18 channels | |
157 | */ | |
158 | static int mrstouch_chan_parse(struct mrstouch_dev *tsdev) | |
159 | { | |
160 | int err, i, j, found; | |
161 | u32 r32; | |
162 | ||
163 | found = -1; | |
164 | ||
165 | for (i = 0; i < MRSTOUCH_MAX_CHANNELS; i++) { | |
166 | if (found >= 0) | |
167 | break; | |
168 | ||
169 | err = intel_scu_ipc_ioread32(PMICADDR0, &r32); | |
170 | if (err) | |
171 | return err; | |
172 | ||
173 | for (j = 0; j < 32; j+= 8) { | |
174 | if (((r32 >> j) & 0xFF) == END_OF_CHANNEL) { | |
175 | found = i; | |
176 | break; | |
177 | } | |
178 | } | |
179 | } | |
180 | if (found < 0) | |
181 | return 0; | |
182 | ||
183 | if (tsdev->vendor == PMIC_VENDOR_FS) { | |
184 | if (found && found > (MRSTOUCH_MAX_CHANNELS - 18)) | |
185 | return -ENOSPC; | |
186 | } else { | |
187 | if (found && found > (MRSTOUCH_MAX_CHANNELS - 4)) | |
188 | return -ENOSPC; | |
189 | } | |
190 | return found; | |
191 | } | |
192 | ||
193 | /* Utility to enable/disable pendet. | |
194 | * pendet set to true enables PENDET interrupt | |
195 | * pendet set to false disables PENDET interrupt | |
196 | * Also clears RND mask bit | |
197 | */ | |
198 | static int pendet_enable(struct mrstouch_dev *tsdev, bool pendet) | |
199 | { | |
200 | u16 reg; | |
201 | u8 r; | |
202 | u8 pendet_enabled = 0; | |
203 | int retry = 0; | |
204 | int err; | |
205 | ||
206 | err = intel_scu_ipc_ioread16(PMIC_REG_MADCINT, ®); | |
207 | if (err) | |
208 | return err; | |
209 | ||
210 | if (pendet) { | |
211 | reg &= ~0x0005; | |
212 | reg |= 0x2000; /* Enable pendet */ | |
213 | } else | |
214 | reg &= 0xDFFF; /* Disable pendet */ | |
215 | ||
216 | /* Set MADCINT and update ADCCNTL1 (next reg byte) */ | |
217 | err = intel_scu_ipc_iowrite16(PMIC_REG_MADCINT, reg); | |
218 | if (!pendet || err) | |
219 | return err; | |
220 | ||
221 | /* | |
222 | * Sometimes even after the register write succeeds | |
223 | * the PMIC register value is not updated. Retry few iterations | |
224 | * to enable pendet. | |
225 | */ | |
226 | ||
227 | err = intel_scu_ipc_ioread8(PMIC_REG_ADCCNTL1, &r); | |
228 | pendet_enabled = (r >> 5) & 0x01; | |
229 | ||
230 | retry = 0; | |
231 | while (!err && !pendet_enabled) { | |
232 | retry++; | |
233 | msleep(10); | |
234 | err = intel_scu_ipc_iowrite8(PMIC_REG_ADCCNTL1, reg >> 8); | |
235 | if (err) | |
236 | break; | |
237 | err = intel_scu_ipc_ioread8(PMIC_REG_ADCCNTL1, &r); | |
238 | if (err == 0) | |
239 | pendet_enabled = (r >> 5) & 0x01; | |
240 | if (retry >= 10) { | |
241 | dev_err(&tsdev->spi->dev, "Touch screen disabled.\n"); | |
242 | return -EIO; | |
243 | } | |
244 | } | |
245 | return 0; | |
246 | } | |
247 | ||
248 | /* To read PMIC ADC touch screen result | |
249 | * Reads ADC storage registers for higher 7 and lower 3 bits | |
250 | * converts the two readings to single value and turns off gain bit | |
251 | */ | |
252 | static int mrstouch_ts_chan_read(u16 offset, u16 chan, u16 *vp, u16 *vm) | |
253 | { | |
254 | int err; | |
255 | u16 result; | |
256 | u32 res; | |
257 | ||
258 | result = PMIC_REG_ADCSNS0H + offset; | |
259 | ||
260 | if (chan == MRST_TS_CHAN12) | |
261 | result += 4; | |
262 | ||
263 | err = intel_scu_ipc_ioread32(result, &res); | |
264 | if (err) | |
265 | return err; | |
266 | ||
267 | /* Mash the bits up */ | |
268 | ||
269 | *vp = (res & 0xFF) << 3; /* Highest 7 bits */ | |
270 | *vp |= (res >> 8) & 0x07; /* Lower 3 bits */ | |
271 | *vp &= 0x3FF; | |
272 | ||
273 | res >>= 16; | |
274 | ||
275 | *vm = (res & 0xFF) << 3; /* Highest 7 bits */ | |
276 | *vm |= (res >> 8) & 0x07; /* Lower 3 bits */ | |
277 | *vm &= 0x3FF; | |
278 | ||
279 | return 0; | |
280 | } | |
281 | ||
282 | /* To configure touch screen channels | |
283 | * Writes touch screen channels to ADC address selection registers | |
284 | */ | |
285 | static int mrstouch_ts_chan_set(uint offset) | |
286 | { | |
287 | int count; | |
288 | u16 chan; | |
289 | u16 reg[5]; | |
290 | u8 data[5]; | |
291 | ||
292 | chan = PMICADDR0 + offset; | |
293 | for (count = 0; count <= 3; count++) { | |
294 | reg[count] = chan++; | |
295 | data[count] = MRST_TS_CHAN10 + count; | |
296 | } | |
297 | reg[count] = chan; | |
298 | data[count] = END_OF_CHANNEL; | |
299 | ||
300 | return intel_scu_ipc_writev(reg, data, 5); | |
301 | } | |
302 | ||
303 | /* Initialize ADC */ | |
304 | static int mrstouch_adc_init(struct mrstouch_dev *tsdev) | |
305 | { | |
306 | int err, start; | |
307 | u8 ra, rm; | |
308 | ||
309 | err = mrstouch_pmic_id(&tsdev->vendor, &tsdev->rev); | |
310 | if (err) { | |
311 | dev_err(&tsdev->spi->dev, "Unable to read PMIC id\n"); | |
312 | return err; | |
313 | } | |
314 | ||
315 | start = mrstouch_chan_parse(tsdev); | |
316 | if (start < 0) { | |
317 | dev_err(&tsdev->spi->dev, "Unable to parse channels\n"); | |
318 | return start; | |
319 | } | |
320 | ||
321 | tsdev->asr = start; | |
322 | ||
323 | mrstouch_debug("Channel offset(%d): 0x%X\n", tsdev->asr, tsdev->vendor); | |
324 | ||
325 | /* ADC power on, start, enable PENDET and set loop delay | |
326 | * ADC loop delay is set to 4.5 ms approximately | |
327 | * Loop delay more than this results in jitter in adc readings | |
328 | * Setting loop delay to 0 (continous loop) in MAXIM stops PENDET | |
329 | * interrupt generation sometimes. | |
330 | */ | |
331 | ||
332 | if (tsdev->vendor == PMIC_VENDOR_FS) { | |
333 | ra = 0xE0 | ADC_LOOP_DELAY0; | |
334 | rm = 0x5; | |
335 | } else { | |
336 | /* NEC and MAXIm not consistent with loop delay 0 */ | |
337 | ra = 0xE0 | ADC_LOOP_DELAY1; | |
338 | rm = 0x0; | |
339 | ||
340 | /* configure touch screen channels */ | |
341 | err = mrstouch_ts_chan_set(tsdev->asr); | |
342 | if (err) | |
343 | return err; | |
344 | } | |
345 | err = intel_scu_ipc_update_register(PMIC_REG_ADCCNTL1, ra, 0xE7); | |
346 | if (err == 0) | |
347 | err = intel_scu_ipc_update_register(PMIC_REG_MADCINT, rm, 0x03); | |
348 | return err; | |
349 | } | |
350 | ||
351 | /* Reports x,y coordinates to event subsystem */ | |
352 | static void mrstouch_report_xy(struct mrstouch_dev *tsdev, u16 x, u16 y, u16 z) | |
353 | { | |
354 | int xdiff, ydiff; | |
355 | ||
356 | if (tsdev->pendown && z <= TOUCH_PRESSURE) { | |
357 | /* Pen removed, report button release */ | |
358 | mrstouch_debug("BTN REL(%d)", z); | |
359 | input_report_key(tsdev->input, BTN_TOUCH, 0); | |
360 | tsdev->pendown = false; | |
361 | } | |
362 | ||
363 | xdiff = abs(x - tsdev->x); | |
364 | ydiff = abs(y - tsdev->y); | |
365 | ||
366 | /* | |
367 | if x and y values changes for XYMOVE_CNT readings it is considered | |
368 | as stylus is moving. This is required to differentiate between stylus | |
369 | movement and jitter | |
370 | */ | |
371 | if (x < MIN_X || x > MAX_X || y < MIN_Y || y > MAX_Y) { | |
372 | /* Spurious values, release button if touched and return */ | |
373 | if (tsdev->pendown) { | |
374 | mrstouch_debug("BTN REL(%d)", z); | |
375 | input_report_key(tsdev->input, BTN_TOUCH, 0); | |
376 | tsdev->pendown = false; | |
377 | } | |
378 | return; | |
379 | } else if (xdiff >= XMOVE_LIMIT || ydiff >= YMOVE_LIMIT) { | |
380 | tsdev->x = x; | |
381 | tsdev->y = y; | |
382 | ||
383 | input_report_abs(tsdev->input, ABS_X, x); | |
384 | input_report_abs(tsdev->input, ABS_Y, y); | |
385 | input_sync(tsdev->input); | |
386 | } | |
387 | ||
388 | ||
389 | if (!tsdev->pendown && z > TOUCH_PRESSURE) { | |
390 | /* Pen touched, report button touch */ | |
391 | mrstouch_debug("BTN TCH(%d, %d, %d)", x, y, z); | |
392 | input_report_key(tsdev->input, BTN_TOUCH, 1); | |
393 | tsdev->pendown = true; | |
394 | } | |
395 | } | |
396 | ||
397 | ||
398 | /* Utility to start ADC, used by freescale handler */ | |
399 | static int pendet_mask(void) | |
400 | { | |
401 | return intel_scu_ipc_update_register(PMIC_REG_MADCINT, 0x02, 0x02); | |
402 | } | |
403 | ||
404 | /* Utility to stop ADC, used by freescale handler */ | |
405 | static int pendet_umask(void) | |
406 | { | |
407 | return intel_scu_ipc_update_register(PMIC_REG_MADCINT, 0x00, 0x02); | |
408 | } | |
409 | ||
410 | /* Utility to read ADC, used by freescale handler */ | |
411 | static int mrstouch_pmic_fs_adc_read(struct mrstouch_dev *tsdev) | |
412 | { | |
413 | int err; | |
414 | u16 x, y, z, result; | |
415 | u16 reg[4]; | |
416 | u8 data[4]; | |
417 | ||
418 | result = PMIC_REG_ADCSNS0H + tsdev->asr; | |
419 | ||
420 | reg[0] = result + 4; | |
421 | reg[1] = result + 5; | |
422 | reg[2] = result + 16; | |
423 | reg[3] = result + 17; | |
424 | ||
425 | err = intel_scu_ipc_readv(reg, data, 4); | |
426 | if (err) | |
427 | goto ipc_error; | |
428 | ||
429 | x = data[0] << 3; /* Higher 7 bits */ | |
430 | x |= data[1] & 0x7; /* Lower 3 bits */ | |
431 | x &= 0x3FF; | |
432 | ||
433 | y = data[2] << 3; /* Higher 7 bits */ | |
434 | y |= data[3] & 0x7; /* Lower 3 bits */ | |
435 | y &= 0x3FF; | |
436 | ||
437 | /* Read Z value */ | |
438 | reg[0] = result + 28; | |
439 | reg[1] = result + 29; | |
440 | ||
441 | err = intel_scu_ipc_readv(reg, data, 4); | |
442 | if (err) | |
443 | goto ipc_error; | |
444 | ||
445 | z = data[0] << 3; /* Higher 7 bits */ | |
446 | z |= data[1] & 0x7; /* Lower 3 bits */ | |
447 | z &= 0x3FF; | |
448 | ||
449 | #if defined(MRSTOUCH_PRINT_XYZP) | |
450 | mrstouch_debug("X: %d, Y: %d, Z: %d", x, y, z); | |
451 | #endif | |
452 | ||
453 | if (z >= TOUCH_PRESSURE_FS) { | |
454 | mrstouch_report_xy(tsdev, x, y, TOUCH_PRESSURE - 1); /* Pen Removed */ | |
455 | return TOUCH_PRESSURE - 1; | |
456 | } else { | |
457 | mrstouch_report_xy(tsdev, x, y, TOUCH_PRESSURE + 1); /* Pen Touched */ | |
458 | return TOUCH_PRESSURE + 1; | |
459 | } | |
460 | ||
461 | return 0; | |
462 | ||
463 | ipc_error: | |
464 | dev_err(&tsdev->spi->dev, "ipc error during fs_adc read\n"); | |
465 | return err; | |
466 | } | |
467 | ||
468 | /* To handle free scale pmic pendet interrupt */ | |
469 | static int pmic0_pendet(void *dev_id) | |
470 | { | |
471 | int err, count; | |
472 | u16 chan; | |
473 | unsigned int touched; | |
474 | struct mrstouch_dev *tsdev = (struct mrstouch_dev *)dev_id; | |
475 | u16 reg[5]; | |
476 | u8 data[5]; | |
477 | ||
478 | chan = PMICADDR0 + tsdev->asr; | |
479 | ||
480 | /* Set X BIAS */ | |
481 | for (count = 0; count <= 3; count++) { | |
482 | reg[count] = chan++; | |
483 | data[count] = 0x2A; | |
484 | } | |
485 | reg[count] = chan++; /* Dummy */ | |
486 | data[count] = 0; | |
487 | ||
488 | err = intel_scu_ipc_writev(reg, data, 5); | |
489 | if (err) | |
490 | goto ipc_error; | |
491 | ||
492 | msleep(WAIT_ADC_COMPLETION); | |
493 | ||
494 | /* Set Y BIAS */ | |
495 | for (count = 0; count <= 3; count++) { | |
496 | reg[count] = chan++; | |
497 | data[count] = 0x4A; | |
498 | } | |
499 | reg[count] = chan++; /* Dummy */ | |
500 | data[count] = 0; | |
501 | ||
502 | err = intel_scu_ipc_writev(reg, data, 5); | |
503 | if (err) | |
504 | goto ipc_error; | |
505 | ||
506 | msleep(WAIT_ADC_COMPLETION); | |
507 | ||
508 | /* Set Z BIAS */ | |
509 | err = intel_scu_ipc_iowrite32(chan + 2, 0x8A8A8A8A); | |
510 | if (err) | |
511 | goto ipc_error; | |
512 | ||
513 | msleep(WAIT_ADC_COMPLETION); | |
514 | ||
515 | /*Read touch screen channels till pen removed | |
516 | * Freescale reports constant value of z for all points | |
517 | * z is high when screen is not touched and low when touched | |
518 | * Map high z value to not touched and low z value to pen touched | |
519 | */ | |
520 | touched = mrstouch_pmic_fs_adc_read(tsdev); | |
521 | while (touched > TOUCH_PRESSURE) { | |
522 | touched = mrstouch_pmic_fs_adc_read(tsdev); | |
523 | msleep(WAIT_ADC_COMPLETION); | |
524 | } | |
525 | ||
526 | /* Clear all TS channels */ | |
527 | chan = PMICADDR0 + tsdev->asr; | |
528 | for (count = 0; count <= 4; count++) { | |
529 | reg[count] = chan++; | |
530 | data[count] = 0; | |
531 | } | |
532 | err = intel_scu_ipc_writev(reg, data, 5); | |
533 | if (err) | |
534 | goto ipc_error; | |
535 | ||
536 | for (count = 0; count <= 4; count++) { | |
537 | reg[count] = chan++; | |
538 | data[count] = 0; | |
539 | } | |
540 | err = intel_scu_ipc_writev(reg, data, 5); | |
541 | if (err) | |
542 | goto ipc_error; | |
543 | ||
544 | err = intel_scu_ipc_iowrite32(chan + 2, 0x00000000); | |
545 | if (err) | |
546 | goto ipc_error; | |
547 | ||
548 | return 0; | |
549 | ||
550 | ipc_error: | |
551 | dev_err(&tsdev->spi->dev, "ipc error during pendet\n"); | |
552 | return err; | |
553 | } | |
554 | ||
555 | ||
556 | /* To enable X, Y and Z bias values | |
557 | * Enables YPYM for X channels and XPXM for Y channels | |
558 | */ | |
559 | static int mrstouch_ts_bias_set(uint offset, uint bias) | |
560 | { | |
561 | int count; | |
562 | u16 chan, start; | |
563 | u16 reg[4]; | |
564 | u8 data[4]; | |
565 | ||
566 | chan = PMICADDR0 + offset; | |
567 | start = MRST_TS_CHAN10; | |
568 | ||
569 | for (count = 0; count <= 3; count++) { | |
570 | reg[count] = chan++; | |
571 | data[count] = bias | (start + count); | |
572 | } | |
573 | return intel_scu_ipc_writev(reg, data, 4); | |
574 | } | |
575 | ||
576 | /* To read touch screen channel values */ | |
577 | static int mrstouch_adc_read(struct mrstouch_dev *tsdev) | |
578 | { | |
579 | int err; | |
580 | u16 xp, xm, yp, ym, zp, zm; | |
581 | ||
582 | /* configure Y bias for X channels */ | |
583 | err = mrstouch_ts_bias_set(tsdev->asr, YBIAS); | |
584 | if (err) | |
585 | goto ipc_error; | |
586 | ||
587 | msleep(WAIT_ADC_COMPLETION); | |
588 | ||
589 | /* read x+ and x- channels */ | |
590 | err = mrstouch_ts_chan_read(tsdev->asr, MRST_TS_CHAN10, &xp, &xm); | |
591 | if (err) | |
592 | goto ipc_error; | |
593 | ||
594 | /* configure x bias for y channels */ | |
595 | err = mrstouch_ts_bias_set(tsdev->asr, XBIAS); | |
596 | if (err) | |
597 | goto ipc_error; | |
598 | ||
599 | msleep(WAIT_ADC_COMPLETION); | |
600 | ||
601 | /* read y+ and y- channels */ | |
602 | err = mrstouch_ts_chan_read(tsdev->asr, MRST_TS_CHAN12, &yp, &ym); | |
603 | if (err) | |
604 | goto ipc_error; | |
605 | ||
606 | /* configure z bias for x and y channels */ | |
607 | err = mrstouch_ts_bias_set(tsdev->asr, ZBIAS); | |
608 | if (err) | |
609 | goto ipc_error; | |
610 | ||
611 | msleep(WAIT_ADC_COMPLETION); | |
612 | ||
613 | /* read z+ and z- channels */ | |
614 | err = mrstouch_ts_chan_read(tsdev->asr, MRST_TS_CHAN10, &zp, &zm); | |
615 | if (err) | |
616 | goto ipc_error; | |
617 | ||
618 | #if defined(MRSTOUCH_PRINT_XYZP) | |
619 | printk(KERN_INFO "X+: %d, Y+: %d, Z+: %d\n", xp, yp, zp); | |
620 | #endif | |
621 | ||
622 | #if defined(MRSTOUCH_PRINT_XYZM) | |
623 | printk(KERN_INFO "X-: %d, Y-: %d, Z-: %d\n", xm, ym, zm); | |
624 | #endif | |
625 | ||
626 | mrstouch_report_xy(tsdev, xp, yp, zp); /* report x and y to eventX */ | |
627 | ||
628 | return zp; | |
629 | ||
630 | ipc_error: | |
631 | dev_err(&tsdev->spi->dev, "ipc error during adc read\n"); | |
632 | return err; | |
633 | } | |
634 | ||
635 | /* PENDET interrupt handler function for NEC and MAXIM */ | |
636 | static void pmic12_pendet(void *data) | |
637 | { | |
638 | unsigned int touched; | |
639 | struct mrstouch_dev *tsdev = (struct mrstouch_dev *)data; | |
640 | ||
641 | /* read touch screen channels till pen removed */ | |
642 | do { | |
643 | touched = mrstouch_adc_read(tsdev); | |
644 | } while (touched > TOUCH_PRESSURE); | |
645 | } | |
646 | ||
647 | /* Handler to process PENDET interrupt */ | |
648 | int mrstouch_pendet(void *data) | |
649 | { | |
650 | struct mrstouch_dev *tsdev = (struct mrstouch_dev *)data; | |
651 | while (1) { | |
652 | /* Wait for PENDET interrupt */ | |
653 | if (mutex_lock_interruptible(&tsdev->lock)) { | |
654 | msleep(WAIT_ADC_COMPLETION); | |
655 | continue; | |
656 | } | |
657 | ||
658 | if (tsdev->busy) | |
659 | return 0; | |
660 | ||
661 | tsdev->busy = true; | |
662 | ||
663 | if (tsdev->vendor == PMIC_VENDOR_NEC || | |
664 | tsdev->vendor == PMIC_VENDOR_MAXIM) { | |
665 | /* PENDET must be disabled in NEC before reading ADC */ | |
666 | pendet_enable(tsdev,false); /* Disbale PENDET */ | |
667 | pmic12_pendet(tsdev); | |
668 | pendet_enable(tsdev, true); /*Enable PENDET */ | |
669 | } else if (tsdev->vendor == PMIC_VENDOR_FS) { | |
670 | pendet_umask(); /* Stop ADC */ | |
671 | pmic0_pendet(tsdev); | |
672 | pendet_mask(); /* Stop ADC */ | |
673 | } else | |
674 | dev_err(&tsdev->spi->dev, "Unsupported touchscreen: %d\n", | |
675 | tsdev->vendor); | |
676 | ||
677 | tsdev->busy = false; | |
678 | ||
679 | } | |
680 | return 0; | |
681 | } | |
682 | ||
683 | /* PENDET interrupt handler */ | |
684 | static irqreturn_t pendet_intr_handler(int irq, void *handle) | |
685 | { | |
686 | struct mrstouch_dev *tsdev = (struct mrstouch_dev *)handle; | |
687 | ||
688 | mutex_unlock(&tsdev->lock); | |
689 | return IRQ_HANDLED; | |
690 | } | |
691 | ||
692 | /* Intializes input device and registers with input subsystem */ | |
693 | static int ts_input_dev_init(struct mrstouch_dev *tsdev, struct spi_device *spi) | |
694 | { | |
695 | int err = 0; | |
696 | ||
697 | mrstouch_debug("%s", __func__); | |
698 | ||
699 | tsdev->input = input_allocate_device(); | |
700 | if (!tsdev->input) { | |
701 | dev_err(&tsdev->spi->dev, "Unable to allocate input device.\n"); | |
702 | return -EINVAL; | |
703 | } | |
704 | ||
705 | tsdev->input->name = "mrst_touchscreen"; | |
706 | snprintf(tsdev->phys, sizeof(tsdev->phys), | |
707 | "%s/input0", dev_name(&spi->dev)); | |
708 | tsdev->input->phys = tsdev->phys; | |
709 | tsdev->input->dev.parent = &spi->dev; | |
710 | ||
711 | tsdev->input->id.vendor = tsdev->vendor; | |
712 | tsdev->input->id.version = tsdev->rev; | |
713 | ||
714 | tsdev->input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); | |
715 | tsdev->input->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH); | |
716 | ||
717 | input_set_abs_params(tsdev->input, ABS_X, MIN_X, MIN_Y, 0, 0); | |
718 | input_set_abs_params(tsdev->input, ABS_Y, MIN_X, MIN_Y, 0, 0); | |
719 | ||
720 | err = input_register_device(tsdev->input); | |
721 | if (err) { | |
722 | dev_err(&tsdev->spi->dev, "unable to register input device\n"); | |
723 | input_free_device(tsdev->input); | |
724 | return err; | |
725 | } | |
726 | ||
727 | mrstouch_debug("%s", "mrstouch initialized"); | |
728 | ||
729 | return 0; | |
730 | ||
731 | } | |
732 | ||
733 | /* Probe function for touch screen driver */ | |
734 | static int __devinit mrstouch_probe(struct spi_device *mrstouch_spi) | |
735 | { | |
736 | int err; | |
737 | unsigned int myirq; | |
738 | struct mrstouch_dev *tsdev; | |
739 | ||
740 | mrstouch_debug("%s(%p)", __func__, mrstouch_spi); | |
741 | ||
742 | mrstouchdevp = NULL; | |
743 | myirq = mrstouch_spi->irq; | |
744 | ||
745 | if (!mrstouch_spi->irq) { | |
746 | dev_err(&mrstouch_spi->dev, "no interrupt assigned\n"); | |
747 | return -EINVAL; | |
748 | } | |
749 | ||
750 | tsdev = kzalloc(sizeof(struct mrstouch_dev), GFP_KERNEL); | |
751 | if (!tsdev) { | |
752 | dev_err(&mrstouch_spi->dev, "unable to allocate memory\n"); | |
753 | return -ENOMEM; | |
754 | } | |
755 | ||
756 | tsdev->irq = myirq; | |
757 | mrstouchdevp = tsdev; | |
758 | ||
759 | err = mrstouch_adc_init(tsdev); | |
760 | if (err) { | |
761 | dev_err(&mrstouch_spi->dev, "ADC init failed\n"); | |
762 | goto mrstouch_err_free_mem; | |
763 | } | |
764 | ||
765 | dev_set_drvdata(&mrstouch_spi->dev, tsdev); | |
766 | tsdev->spi = mrstouch_spi; | |
767 | ||
768 | err = ts_input_dev_init(tsdev, mrstouch_spi); | |
769 | if (err) { | |
770 | dev_err(&tsdev->spi->dev, "ts_input_dev_init failed"); | |
771 | goto mrstouch_err_free_mem; | |
772 | } | |
773 | ||
774 | mutex_init(&tsdev->lock); | |
775 | mutex_lock(&tsdev->lock) | |
776 | ||
777 | mrstouch_debug("Requesting IRQ-%d", myirq); | |
778 | err = request_irq(myirq, pendet_intr_handler, | |
779 | 0, "mrstouch", tsdev); | |
780 | if (err) { | |
781 | dev_err(&tsdev->spi->dev, "unable to allocate irq\n"); | |
782 | goto mrstouch_err_free_mem; | |
783 | } | |
784 | ||
785 | tsdev->pendet_thrd = kthread_run(mrstouch_pendet, | |
786 | (void *)tsdev, "pendet handler"); | |
787 | if (IS_ERR(tsdev->pendet_thrd)) { | |
788 | dev_err(&tsdev->spi->dev, "kthread_run failed\n"); | |
789 | err = PTR_ERR(tsdev->pendet_thrd); | |
790 | goto mrstouch_err_free_mem; | |
791 | } | |
792 | mrstouch_debug("%s", "Driver initialized"); | |
793 | return 0; | |
794 | ||
795 | mrstouch_err_free_mem: | |
796 | kfree(tsdev); | |
797 | return err; | |
798 | } | |
799 | ||
800 | static int mrstouch_suspend(struct spi_device *spi, pm_message_t msg) | |
801 | { | |
802 | mrstouch_debug("%s", __func__); | |
803 | mrstouchdevp->suspended = 1; | |
804 | return 0; | |
805 | } | |
806 | ||
807 | static int mrstouch_resume(struct spi_device *spi) | |
808 | { | |
809 | mrstouch_debug("%s", __func__); | |
810 | mrstouchdevp->suspended = 0; | |
811 | return 0; | |
812 | } | |
813 | ||
814 | static int mrstouch_remove(struct spi_device *spi) | |
815 | { | |
816 | mrstouch_debug("%s", __func__); | |
817 | free_irq(mrstouchdevp->irq, mrstouchdevp); | |
818 | input_unregister_device(mrstouchdevp->input); | |
819 | input_free_device(mrstouchdevp->input); | |
a4cff8b8 SD |
820 | if (mrstouchdevp->pendet_thrd) |
821 | kthread_stop(mrstouchdevp->pendet_thrd); | |
44176d9f | 822 | kfree(mrstouchdevp); |
a4cff8b8 SD |
823 | return 0; |
824 | } | |
825 | ||
826 | static struct spi_driver mrstouch_driver = { | |
827 | .driver = { | |
828 | .name = "pmic_touch", | |
829 | .bus = &spi_bus_type, | |
830 | .owner = THIS_MODULE, | |
831 | }, | |
832 | .probe = mrstouch_probe, | |
833 | .suspend = mrstouch_suspend, | |
834 | .resume = mrstouch_resume, | |
835 | .remove = mrstouch_remove, | |
836 | }; | |
837 | ||
838 | static int __init mrstouch_module_init(void) | |
839 | { | |
840 | int err; | |
841 | ||
842 | mrstouch_debug("%s", __func__); | |
843 | err = spi_register_driver(&mrstouch_driver); | |
844 | if (err) { | |
845 | mrstouch_debug("%s(%d)", "SPI PENDET failed", err); | |
846 | return -1; | |
847 | } | |
848 | ||
849 | return 0; | |
850 | } | |
851 | ||
852 | static void __exit mrstouch_module_exit(void) | |
853 | { | |
854 | mrstouch_debug("%s", __func__); | |
855 | spi_unregister_driver(&mrstouch_driver); | |
856 | return; | |
857 | } | |
858 | ||
859 | module_init(mrstouch_module_init); | |
860 | module_exit(mrstouch_module_exit); | |
861 | ||
862 | MODULE_AUTHOR("Sreedhara Murthy. D.S, sreedhara.ds@intel.com"); | |
863 | MODULE_DESCRIPTION("Intel Moorestown Resistive Touch Screen Driver"); | |
864 | MODULE_LICENSE("GPL"); |