Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input
[linux-2.6.git] / drivers / input / touchscreen / w90p910_ts.c
1 /*
2  * Copyright (c) 2008 Nuvoton technology corporation.
3  *
4  * Wan ZongShun <mcuos.com@gmail.com>
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation;version 2 of the License.
9  *
10  */
11
12 #include <linux/delay.h>
13 #include <linux/module.h>
14 #include <linux/platform_device.h>
15 #include <linux/io.h>
16 #include <linux/clk.h>
17 #include <linux/input.h>
18 #include <linux/interrupt.h>
19
20 /* ADC controller bit defines */
21 #define ADC_DELAY       0xf00
22 #define ADC_DOWN        0x01
23 #define ADC_TSC_Y       (0x01 << 8)
24 #define ADC_TSC_X       (0x00 << 8)
25 #define TSC_FOURWIRE    (~(0x03 << 1))
26 #define ADC_CLK_EN      (0x01 << 28)    /* ADC clock enable */
27 #define ADC_READ_CON    (0x01 << 12)
28 #define ADC_CONV        (0x01 << 13)
29 #define ADC_SEMIAUTO    (0x01 << 14)
30 #define ADC_WAITTRIG    (0x03 << 14)
31 #define ADC_RST1        (0x01 << 16)
32 #define ADC_RST0        (0x00 << 16)
33 #define ADC_EN          (0x01 << 17)
34 #define ADC_INT         (0x01 << 18)
35 #define WT_INT          (0x01 << 20)
36 #define ADC_INT_EN      (0x01 << 21)
37 #define LVD_INT_EN      (0x01 << 22)
38 #define WT_INT_EN       (0x01 << 23)
39 #define ADC_DIV         (0x04 << 1)     /* div = 6 */
40
41 enum ts_state {
42         TS_WAIT_NEW_PACKET,     /* We are waiting next touch report */
43         TS_WAIT_X_COORD,        /* We are waiting for ADC to report X coord */
44         TS_WAIT_Y_COORD,        /* We are waiting for ADC to report Y coord */
45         TS_IDLE,                /* Input device is closed, don't do anything */
46 };
47
48 struct w90p910_ts {
49         struct input_dev *input;
50         struct timer_list timer;
51         struct clk *clk;
52         int irq_num;
53         void __iomem *ts_reg;
54         spinlock_t lock;
55         enum ts_state state;
56 };
57
58 static void w90p910_report_event(struct w90p910_ts *w90p910_ts, bool down)
59 {
60         struct input_dev *dev = w90p910_ts->input;
61
62         if (down) {
63                 input_report_abs(dev, ABS_X,
64                                  __raw_readl(w90p910_ts->ts_reg + 0x0c));
65                 input_report_abs(dev, ABS_Y,
66                                  __raw_readl(w90p910_ts->ts_reg + 0x10));
67         }
68
69         input_report_key(dev, BTN_TOUCH, down);
70         input_sync(dev);
71 }
72
73 static void w90p910_prepare_x_reading(struct w90p910_ts *w90p910_ts)
74 {
75         unsigned long ctlreg;
76
77         __raw_writel(ADC_TSC_X, w90p910_ts->ts_reg + 0x04);
78         ctlreg = __raw_readl(w90p910_ts->ts_reg);
79         ctlreg &= ~(ADC_WAITTRIG | WT_INT | WT_INT_EN);
80         ctlreg |= ADC_SEMIAUTO | ADC_INT_EN | ADC_CONV;
81         __raw_writel(ctlreg, w90p910_ts->ts_reg);
82
83         w90p910_ts->state = TS_WAIT_X_COORD;
84 }
85
86 static void w90p910_prepare_y_reading(struct w90p910_ts *w90p910_ts)
87 {
88         unsigned long ctlreg;
89
90         __raw_writel(ADC_TSC_Y, w90p910_ts->ts_reg + 0x04);
91         ctlreg = __raw_readl(w90p910_ts->ts_reg);
92         ctlreg &= ~(ADC_WAITTRIG | ADC_INT | WT_INT_EN);
93         ctlreg |= ADC_SEMIAUTO | ADC_INT_EN | ADC_CONV;
94         __raw_writel(ctlreg, w90p910_ts->ts_reg);
95
96         w90p910_ts->state = TS_WAIT_Y_COORD;
97 }
98
99 static void w90p910_prepare_next_packet(struct w90p910_ts *w90p910_ts)
100 {
101         unsigned long ctlreg;
102
103         ctlreg = __raw_readl(w90p910_ts->ts_reg);
104         ctlreg &= ~(ADC_INT | ADC_INT_EN | ADC_SEMIAUTO | ADC_CONV);
105         ctlreg |= ADC_WAITTRIG | WT_INT_EN;
106         __raw_writel(ctlreg, w90p910_ts->ts_reg);
107
108         w90p910_ts->state = TS_WAIT_NEW_PACKET;
109 }
110
111 static irqreturn_t w90p910_ts_interrupt(int irq, void *dev_id)
112 {
113         struct w90p910_ts *w90p910_ts = dev_id;
114         unsigned long flags;
115
116         spin_lock_irqsave(&w90p910_ts->lock, flags);
117
118         switch (w90p910_ts->state) {
119         case TS_WAIT_NEW_PACKET:
120                 /*
121                  * The controller only generates interrupts when pen
122                  * is down.
123                  */
124                 del_timer(&w90p910_ts->timer);
125                 w90p910_prepare_x_reading(w90p910_ts);
126                 break;
127
128
129         case TS_WAIT_X_COORD:
130                 w90p910_prepare_y_reading(w90p910_ts);
131                 break;
132
133         case TS_WAIT_Y_COORD:
134                 w90p910_report_event(w90p910_ts, true);
135                 w90p910_prepare_next_packet(w90p910_ts);
136                 mod_timer(&w90p910_ts->timer, jiffies + msecs_to_jiffies(100));
137                 break;
138
139         case TS_IDLE:
140                 break;
141         }
142
143         spin_unlock_irqrestore(&w90p910_ts->lock, flags);
144
145         return IRQ_HANDLED;
146 }
147
148 static void w90p910_check_pen_up(unsigned long data)
149 {
150         struct w90p910_ts *w90p910_ts = (struct w90p910_ts *) data;
151         unsigned long flags;
152
153         spin_lock_irqsave(&w90p910_ts->lock, flags);
154
155         if (w90p910_ts->state == TS_WAIT_NEW_PACKET &&
156             !(__raw_readl(w90p910_ts->ts_reg + 0x04) & ADC_DOWN)) {
157
158                 w90p910_report_event(w90p910_ts, false);
159         }
160
161         spin_unlock_irqrestore(&w90p910_ts->lock, flags);
162 }
163
164 static int w90p910_open(struct input_dev *dev)
165 {
166         struct w90p910_ts *w90p910_ts = input_get_drvdata(dev);
167         unsigned long val;
168
169         /* enable the ADC clock */
170         clk_enable(w90p910_ts->clk);
171
172         __raw_writel(ADC_RST1, w90p910_ts->ts_reg);
173         msleep(1);
174         __raw_writel(ADC_RST0, w90p910_ts->ts_reg);
175         msleep(1);
176
177         /* set delay and screen type */
178         val = __raw_readl(w90p910_ts->ts_reg + 0x04);
179         __raw_writel(val & TSC_FOURWIRE, w90p910_ts->ts_reg + 0x04);
180         __raw_writel(ADC_DELAY, w90p910_ts->ts_reg + 0x08);
181
182         w90p910_ts->state = TS_WAIT_NEW_PACKET;
183         wmb();
184
185         /* set trigger mode */
186         val = __raw_readl(w90p910_ts->ts_reg);
187         val |= ADC_WAITTRIG | ADC_DIV | ADC_EN | WT_INT_EN;
188         __raw_writel(val, w90p910_ts->ts_reg);
189
190         return 0;
191 }
192
193 static void w90p910_close(struct input_dev *dev)
194 {
195         struct w90p910_ts *w90p910_ts = input_get_drvdata(dev);
196         unsigned long val;
197
198         /* disable trigger mode */
199
200         spin_lock_irq(&w90p910_ts->lock);
201
202         w90p910_ts->state = TS_IDLE;
203
204         val = __raw_readl(w90p910_ts->ts_reg);
205         val &= ~(ADC_WAITTRIG | ADC_DIV | ADC_EN | WT_INT_EN | ADC_INT_EN);
206         __raw_writel(val, w90p910_ts->ts_reg);
207
208         spin_unlock_irq(&w90p910_ts->lock);
209
210         /* Now that interrupts are shut off we can safely delete timer */
211         del_timer_sync(&w90p910_ts->timer);
212
213         /* stop the ADC clock */
214         clk_disable(w90p910_ts->clk);
215 }
216
217 static int __devinit w90x900ts_probe(struct platform_device *pdev)
218 {
219         struct w90p910_ts *w90p910_ts;
220         struct input_dev *input_dev;
221         struct resource *res;
222         int err;
223
224         w90p910_ts = kzalloc(sizeof(struct w90p910_ts), GFP_KERNEL);
225         input_dev = input_allocate_device();
226         if (!w90p910_ts || !input_dev) {
227                 err = -ENOMEM;
228                 goto fail1;
229         }
230
231         w90p910_ts->input = input_dev;
232         w90p910_ts->state = TS_IDLE;
233         spin_lock_init(&w90p910_ts->lock);
234         setup_timer(&w90p910_ts->timer, w90p910_check_pen_up,
235                     (unsigned long)&w90p910_ts);
236
237         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
238         if (!res) {
239                 err = -ENXIO;
240                 goto fail1;
241         }
242
243         if (!request_mem_region(res->start, resource_size(res),
244                                 pdev->name)) {
245                 err = -EBUSY;
246                 goto fail1;
247         }
248
249         w90p910_ts->ts_reg = ioremap(res->start, resource_size(res));
250         if (!w90p910_ts->ts_reg) {
251                 err = -ENOMEM;
252                 goto fail2;
253         }
254
255         w90p910_ts->clk = clk_get(&pdev->dev, NULL);
256         if (IS_ERR(w90p910_ts->clk)) {
257                 err = PTR_ERR(w90p910_ts->clk);
258                 goto fail3;
259         }
260
261         input_dev->name = "W90P910 TouchScreen";
262         input_dev->phys = "w90p910ts/event0";
263         input_dev->id.bustype = BUS_HOST;
264         input_dev->id.vendor  = 0x0005;
265         input_dev->id.product = 0x0001;
266         input_dev->id.version = 0x0100;
267         input_dev->dev.parent = &pdev->dev;
268         input_dev->open = w90p910_open;
269         input_dev->close = w90p910_close;
270
271         input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
272         input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
273
274         input_set_abs_params(input_dev, ABS_X, 0, 0x400, 0, 0);
275         input_set_abs_params(input_dev, ABS_Y, 0, 0x400, 0, 0);
276
277         input_set_drvdata(input_dev, w90p910_ts);
278
279         w90p910_ts->irq_num = platform_get_irq(pdev, 0);
280         if (request_irq(w90p910_ts->irq_num, w90p910_ts_interrupt,
281                         IRQF_DISABLED, "w90p910ts", w90p910_ts)) {
282                 err = -EBUSY;
283                 goto fail4;
284         }
285
286         err = input_register_device(w90p910_ts->input);
287         if (err)
288                 goto fail5;
289
290         platform_set_drvdata(pdev, w90p910_ts);
291
292         return 0;
293
294 fail5:  free_irq(w90p910_ts->irq_num, w90p910_ts);
295 fail4:  clk_put(w90p910_ts->clk);
296 fail3:  iounmap(w90p910_ts->ts_reg);
297 fail2:  release_mem_region(res->start, resource_size(res));
298 fail1:  input_free_device(input_dev);
299         kfree(w90p910_ts);
300         return err;
301 }
302
303 static int __devexit w90x900ts_remove(struct platform_device *pdev)
304 {
305         struct w90p910_ts *w90p910_ts = platform_get_drvdata(pdev);
306         struct resource *res;
307
308         free_irq(w90p910_ts->irq_num, w90p910_ts);
309         del_timer_sync(&w90p910_ts->timer);
310         iounmap(w90p910_ts->ts_reg);
311
312         clk_put(w90p910_ts->clk);
313
314         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
315         release_mem_region(res->start, resource_size(res));
316
317         input_unregister_device(w90p910_ts->input);
318         kfree(w90p910_ts);
319
320         platform_set_drvdata(pdev, NULL);
321
322         return 0;
323 }
324
325 static struct platform_driver w90x900ts_driver = {
326         .probe          = w90x900ts_probe,
327         .remove         = __devexit_p(w90x900ts_remove),
328         .driver         = {
329                 .name   = "nuc900-ts",
330                 .owner  = THIS_MODULE,
331         },
332 };
333
334 static int __init w90x900ts_init(void)
335 {
336         return platform_driver_register(&w90x900ts_driver);
337 }
338
339 static void __exit w90x900ts_exit(void)
340 {
341         platform_driver_unregister(&w90x900ts_driver);
342 }
343
344 module_init(w90x900ts_init);
345 module_exit(w90x900ts_exit);
346
347 MODULE_AUTHOR("Wan ZongShun <mcuos.com@gmail.com>");
348 MODULE_DESCRIPTION("w90p910 touch screen driver!");
349 MODULE_LICENSE("GPL");
350 MODULE_ALIAS("platform:nuc900-ts");