tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
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
41enum 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
48struct 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
58static 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
73static 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
86static 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
99static 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
111static 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
148static 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
164static 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
193static 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
217static 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
294fail5: free_irq(w90p910_ts->irq_num, w90p910_ts);
295fail4: clk_put(w90p910_ts->clk);
296fail3: iounmap(w90p910_ts->ts_reg);
297fail2: release_mem_region(res->start, resource_size(res));
298fail1: input_free_device(input_dev);
299 kfree(w90p910_ts);
300 return err;
301}
302
303static 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
325static 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
334static int __init w90x900ts_init(void)
335{
336 return platform_driver_register(&w90x900ts_driver);
337}
338
339static void __exit w90x900ts_exit(void)
340{
341 platform_driver_unregister(&w90x900ts_driver);
342}
343
344module_init(w90x900ts_init);
345module_exit(w90x900ts_exit);
346
347MODULE_AUTHOR("Wan ZongShun <mcuos.com@gmail.com>");
348MODULE_DESCRIPTION("w90p910 touch screen driver!");
349MODULE_LICENSE("GPL");
350MODULE_ALIAS("platform:nuc900-ts");