Commit | Line | Data |
---|---|---|
f5f96b93 AP |
1 | /* |
2 | * Samsung S3C24XX touchscreen driver | |
3 | * | |
4 | * This program is free software; you can redistribute it and/or modify | |
5 | * it under the term of the GNU General Public License as published by | |
6 | * the Free Software Foundation; either version 2 of the License, or | |
7 | * (at your option) any later version. | |
8 | * | |
9 | * This program is distributed in the hope that it will be useful, | |
10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
12 | * GNU General Public License for more details. | |
13 | * | |
14 | * You should have received a copy of the GNU General Public License | |
15 | * along with this program; if not, write to the Free Software | |
16 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
17 | * | |
18 | * Copyright 2004 Arnaud Patard <arnaud.patard@rtp-net.org> | |
19 | * Copyright 2008 Ben Dooks <ben-linux@fluff.org> | |
20 | * Copyright 2009 Simtec Electronics <linux@simtec.co.uk> | |
21 | * | |
22 | * Additional work by Herbert Pƶtzl <herbert@13thfloor.at> and | |
23 | * Harald Welte <laforge@openmoko.org> | |
24 | */ | |
25 | ||
26 | #include <linux/errno.h> | |
27 | #include <linux/kernel.h> | |
28 | #include <linux/module.h> | |
f5f96b93 AP |
29 | #include <linux/gpio.h> |
30 | #include <linux/input.h> | |
f5f96b93 AP |
31 | #include <linux/delay.h> |
32 | #include <linux/interrupt.h> | |
33 | #include <linux/platform_device.h> | |
34 | #include <linux/clk.h> | |
35 | #include <linux/io.h> | |
36 | ||
37 | #include <plat/adc.h> | |
38 | #include <plat/regs-adc.h> | |
436d42c6 | 39 | #include <linux/platform_data/touchscreen-s3c2410.h> |
f5f96b93 | 40 | |
f5f96b93 AP |
41 | #define TSC_SLEEP (S3C2410_ADCTSC_PULL_UP_DISABLE | S3C2410_ADCTSC_XY_PST(0)) |
42 | ||
43 | #define INT_DOWN (0) | |
44 | #define INT_UP (1 << 8) | |
45 | ||
46 | #define WAIT4INT (S3C2410_ADCTSC_YM_SEN | \ | |
47 | S3C2410_ADCTSC_YP_SEN | \ | |
48 | S3C2410_ADCTSC_XP_SEN | \ | |
49 | S3C2410_ADCTSC_XY_PST(3)) | |
50 | ||
51 | #define AUTOPST (S3C2410_ADCTSC_YM_SEN | \ | |
52 | S3C2410_ADCTSC_YP_SEN | \ | |
53 | S3C2410_ADCTSC_XP_SEN | \ | |
54 | S3C2410_ADCTSC_AUTO_PST | \ | |
55 | S3C2410_ADCTSC_XY_PST(0)) | |
56 | ||
91df77d7 NK |
57 | #define FEAT_PEN_IRQ (1 << 0) /* HAS ADCCLRINTPNDNUP */ |
58 | ||
f5f96b93 AP |
59 | /* Per-touchscreen data. */ |
60 | ||
61 | /** | |
62 | * struct s3c2410ts - driver touchscreen state. | |
63 | * @client: The ADC client we registered with the core driver. | |
64 | * @dev: The device we are bound to. | |
65 | * @input: The input device we registered with the input subsystem. | |
66 | * @clock: The clock for the adc. | |
67 | * @io: Pointer to the IO base. | |
68 | * @xp: The accumulated X position data. | |
69 | * @yp: The accumulated Y position data. | |
70 | * @irq_tc: The interrupt number for pen up/down interrupt | |
71 | * @count: The number of samples collected. | |
72 | * @shift: The log2 of the maximum count to read in one go. | |
91df77d7 | 73 | * @features: The features supported by the TSADC MOdule. |
f5f96b93 AP |
74 | */ |
75 | struct s3c2410ts { | |
76 | struct s3c_adc_client *client; | |
77 | struct device *dev; | |
78 | struct input_dev *input; | |
79 | struct clk *clock; | |
80 | void __iomem *io; | |
81 | unsigned long xp; | |
82 | unsigned long yp; | |
83 | int irq_tc; | |
84 | int count; | |
85 | int shift; | |
91df77d7 | 86 | int features; |
f5f96b93 AP |
87 | }; |
88 | ||
89 | static struct s3c2410ts ts; | |
90 | ||
f5f96b93 AP |
91 | /** |
92 | * get_down - return the down state of the pen | |
93 | * @data0: The data read from ADCDAT0 register. | |
94 | * @data1: The data read from ADCDAT1 register. | |
95 | * | |
96 | * Return non-zero if both readings show that the pen is down. | |
97 | */ | |
98 | static inline bool get_down(unsigned long data0, unsigned long data1) | |
99 | { | |
100 | /* returns true if both data values show stylus down */ | |
101 | return (!(data0 & S3C2410_ADCDAT0_UPDOWN) && | |
102 | !(data1 & S3C2410_ADCDAT0_UPDOWN)); | |
103 | } | |
104 | ||
105 | static void touch_timer_fire(unsigned long data) | |
106 | { | |
107 | unsigned long data0; | |
108 | unsigned long data1; | |
109 | bool down; | |
110 | ||
111 | data0 = readl(ts.io + S3C2410_ADCDAT0); | |
112 | data1 = readl(ts.io + S3C2410_ADCDAT1); | |
113 | ||
114 | down = get_down(data0, data1); | |
115 | ||
23c239be VK |
116 | if (down) { |
117 | if (ts.count == (1 << ts.shift)) { | |
118 | ts.xp >>= ts.shift; | |
119 | ts.yp >>= ts.shift; | |
f5f96b93 | 120 | |
23c239be VK |
121 | dev_dbg(ts.dev, "%s: X=%lu, Y=%lu, count=%d\n", |
122 | __func__, ts.xp, ts.yp, ts.count); | |
f5f96b93 | 123 | |
23c239be VK |
124 | input_report_abs(ts.input, ABS_X, ts.xp); |
125 | input_report_abs(ts.input, ABS_Y, ts.yp); | |
f5f96b93 | 126 | |
23c239be VK |
127 | input_report_key(ts.input, BTN_TOUCH, 1); |
128 | input_sync(ts.input); | |
f5f96b93 | 129 | |
23c239be VK |
130 | ts.xp = 0; |
131 | ts.yp = 0; | |
132 | ts.count = 0; | |
133 | } | |
f5f96b93 | 134 | |
f5f96b93 AP |
135 | s3c_adc_start(ts.client, 0, 1 << ts.shift); |
136 | } else { | |
23c239be VK |
137 | ts.xp = 0; |
138 | ts.yp = 0; | |
f5f96b93 AP |
139 | ts.count = 0; |
140 | ||
141 | input_report_key(ts.input, BTN_TOUCH, 0); | |
142 | input_sync(ts.input); | |
143 | ||
144 | writel(WAIT4INT | INT_DOWN, ts.io + S3C2410_ADCTSC); | |
145 | } | |
146 | } | |
147 | ||
148 | static DEFINE_TIMER(touch_timer, touch_timer_fire, 0, 0); | |
149 | ||
150 | /** | |
151 | * stylus_irq - touchscreen stylus event interrupt | |
152 | * @irq: The interrupt number | |
153 | * @dev_id: The device ID. | |
154 | * | |
155 | * Called when the IRQ_TC is fired for a pen up or down event. | |
156 | */ | |
157 | static irqreturn_t stylus_irq(int irq, void *dev_id) | |
158 | { | |
159 | unsigned long data0; | |
160 | unsigned long data1; | |
161 | bool down; | |
162 | ||
163 | data0 = readl(ts.io + S3C2410_ADCDAT0); | |
164 | data1 = readl(ts.io + S3C2410_ADCDAT1); | |
165 | ||
166 | down = get_down(data0, data1); | |
167 | ||
168 | /* TODO we should never get an interrupt with down set while | |
169 | * the timer is running, but maybe we ought to verify that the | |
170 | * timer isn't running anyways. */ | |
171 | ||
172 | if (down) | |
173 | s3c_adc_start(ts.client, 0, 1 << ts.shift); | |
174 | else | |
fbf89f25 | 175 | dev_dbg(ts.dev, "%s: count=%d\n", __func__, ts.count); |
f5f96b93 | 176 | |
91df77d7 NK |
177 | if (ts.features & FEAT_PEN_IRQ) { |
178 | /* Clear pen down/up interrupt */ | |
179 | writel(0x0, ts.io + S3C64XX_ADCCLRINTPNDNUP); | |
180 | } | |
181 | ||
f5f96b93 AP |
182 | return IRQ_HANDLED; |
183 | } | |
184 | ||
185 | /** | |
186 | * s3c24xx_ts_conversion - ADC conversion callback | |
187 | * @client: The client that was registered with the ADC core. | |
188 | * @data0: The reading from ADCDAT0. | |
189 | * @data1: The reading from ADCDAT1. | |
190 | * @left: The number of samples left. | |
191 | * | |
192 | * Called when a conversion has finished. | |
193 | */ | |
194 | static void s3c24xx_ts_conversion(struct s3c_adc_client *client, | |
195 | unsigned data0, unsigned data1, | |
196 | unsigned *left) | |
197 | { | |
198 | dev_dbg(ts.dev, "%s: %d,%d\n", __func__, data0, data1); | |
199 | ||
200 | ts.xp += data0; | |
201 | ts.yp += data1; | |
202 | ||
203 | ts.count++; | |
204 | ||
205 | /* From tests, it seems that it is unlikely to get a pen-up | |
206 | * event during the conversion process which means we can | |
207 | * ignore any pen-up events with less than the requisite | |
208 | * count done. | |
209 | * | |
210 | * In several thousand conversions, no pen-ups where detected | |
211 | * before count completed. | |
212 | */ | |
213 | } | |
214 | ||
215 | /** | |
216 | * s3c24xx_ts_select - ADC selection callback. | |
217 | * @client: The client that was registered with the ADC core. | |
218 | * @select: The reason for select. | |
219 | * | |
220 | * Called when the ADC core selects (or deslects) us as a client. | |
221 | */ | |
222 | static void s3c24xx_ts_select(struct s3c_adc_client *client, unsigned select) | |
223 | { | |
224 | if (select) { | |
225 | writel(S3C2410_ADCTSC_PULL_UP_DISABLE | AUTOPST, | |
226 | ts.io + S3C2410_ADCTSC); | |
227 | } else { | |
228 | mod_timer(&touch_timer, jiffies+1); | |
229 | writel(WAIT4INT | INT_UP, ts.io + S3C2410_ADCTSC); | |
230 | } | |
231 | } | |
232 | ||
233 | /** | |
234 | * s3c2410ts_probe - device core probe entry point | |
235 | * @pdev: The device we are being bound to. | |
236 | * | |
237 | * Initialise, find and allocate any resources we need to run and then | |
238 | * register with the ADC and input systems. | |
239 | */ | |
5298cc4c | 240 | static int s3c2410ts_probe(struct platform_device *pdev) |
f5f96b93 AP |
241 | { |
242 | struct s3c2410_ts_mach_info *info; | |
243 | struct device *dev = &pdev->dev; | |
244 | struct input_dev *input_dev; | |
245 | struct resource *res; | |
246 | int ret = -EINVAL; | |
247 | ||
248 | /* Initialise input stuff */ | |
249 | memset(&ts, 0, sizeof(struct s3c2410ts)); | |
250 | ||
251 | ts.dev = dev; | |
252 | ||
c838cb3d | 253 | info = dev_get_platdata(&pdev->dev); |
f5f96b93 AP |
254 | if (!info) { |
255 | dev_err(dev, "no platform data, cannot attach\n"); | |
256 | return -EINVAL; | |
257 | } | |
258 | ||
259 | dev_dbg(dev, "initialising touchscreen\n"); | |
260 | ||
261 | ts.clock = clk_get(dev, "adc"); | |
262 | if (IS_ERR(ts.clock)) { | |
263 | dev_err(dev, "cannot get adc clock source\n"); | |
264 | return -ENOENT; | |
265 | } | |
266 | ||
09c8fb63 | 267 | clk_prepare_enable(ts.clock); |
f5f96b93 AP |
268 | dev_dbg(dev, "got and enabled clocks\n"); |
269 | ||
270 | ts.irq_tc = ret = platform_get_irq(pdev, 0); | |
271 | if (ret < 0) { | |
272 | dev_err(dev, "no resource for interrupt\n"); | |
273 | goto err_clk; | |
274 | } | |
275 | ||
276 | res = platform_get_resource(pdev, IORESOURCE_MEM, 0); | |
277 | if (!res) { | |
278 | dev_err(dev, "no resource for registers\n"); | |
279 | ret = -ENOENT; | |
280 | goto err_clk; | |
281 | } | |
282 | ||
283 | ts.io = ioremap(res->start, resource_size(res)); | |
284 | if (ts.io == NULL) { | |
285 | dev_err(dev, "cannot map registers\n"); | |
286 | ret = -ENOMEM; | |
287 | goto err_clk; | |
288 | } | |
289 | ||
658ad39e NK |
290 | /* inititalise the gpio */ |
291 | if (info->cfg_gpio) | |
292 | info->cfg_gpio(to_platform_device(ts.dev)); | |
f5f96b93 AP |
293 | |
294 | ts.client = s3c_adc_register(pdev, s3c24xx_ts_select, | |
295 | s3c24xx_ts_conversion, 1); | |
296 | if (IS_ERR(ts.client)) { | |
297 | dev_err(dev, "failed to register adc client\n"); | |
298 | ret = PTR_ERR(ts.client); | |
299 | goto err_iomap; | |
300 | } | |
301 | ||
302 | /* Initialise registers */ | |
303 | if ((info->delay & 0xffff) > 0) | |
304 | writel(info->delay & 0xffff, ts.io + S3C2410_ADCDLY); | |
305 | ||
306 | writel(WAIT4INT | INT_DOWN, ts.io + S3C2410_ADCTSC); | |
307 | ||
308 | input_dev = input_allocate_device(); | |
309 | if (!input_dev) { | |
310 | dev_err(dev, "Unable to allocate the input device !!\n"); | |
311 | ret = -ENOMEM; | |
312 | goto err_iomap; | |
313 | } | |
314 | ||
315 | ts.input = input_dev; | |
316 | ts.input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); | |
317 | ts.input->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH); | |
318 | input_set_abs_params(ts.input, ABS_X, 0, 0x3FF, 0, 0); | |
319 | input_set_abs_params(ts.input, ABS_Y, 0, 0x3FF, 0, 0); | |
320 | ||
321 | ts.input->name = "S3C24XX TouchScreen"; | |
322 | ts.input->id.bustype = BUS_HOST; | |
323 | ts.input->id.vendor = 0xDEAD; | |
324 | ts.input->id.product = 0xBEEF; | |
325 | ts.input->id.version = 0x0102; | |
326 | ||
327 | ts.shift = info->oversampling_shift; | |
91df77d7 | 328 | ts.features = platform_get_device_id(pdev)->driver_data; |
f5f96b93 | 329 | |
ec4665c4 | 330 | ret = request_irq(ts.irq_tc, stylus_irq, 0, |
f5f96b93 AP |
331 | "s3c2410_ts_pen", ts.input); |
332 | if (ret) { | |
333 | dev_err(dev, "cannot get TC interrupt\n"); | |
334 | goto err_inputdev; | |
335 | } | |
336 | ||
337 | dev_info(dev, "driver attached, registering input device\n"); | |
338 | ||
339 | /* All went ok, so register to the input system */ | |
340 | ret = input_register_device(ts.input); | |
341 | if (ret < 0) { | |
342 | dev_err(dev, "failed to register input device\n"); | |
343 | ret = -EIO; | |
344 | goto err_tcirq; | |
345 | } | |
346 | ||
347 | return 0; | |
348 | ||
349 | err_tcirq: | |
350 | free_irq(ts.irq_tc, ts.input); | |
351 | err_inputdev: | |
ec1496b3 | 352 | input_free_device(ts.input); |
f5f96b93 AP |
353 | err_iomap: |
354 | iounmap(ts.io); | |
355 | err_clk: | |
356 | del_timer_sync(&touch_timer); | |
357 | clk_put(ts.clock); | |
358 | return ret; | |
359 | } | |
360 | ||
361 | /** | |
362 | * s3c2410ts_remove - device core removal entry point | |
363 | * @pdev: The device we are being removed from. | |
364 | * | |
365 | * Free up our state ready to be removed. | |
366 | */ | |
e2619cf7 | 367 | static int s3c2410ts_remove(struct platform_device *pdev) |
f5f96b93 AP |
368 | { |
369 | free_irq(ts.irq_tc, ts.input); | |
370 | del_timer_sync(&touch_timer); | |
371 | ||
09c8fb63 | 372 | clk_disable_unprepare(ts.clock); |
f5f96b93 AP |
373 | clk_put(ts.clock); |
374 | ||
375 | input_unregister_device(ts.input); | |
376 | iounmap(ts.io); | |
377 | ||
378 | return 0; | |
379 | } | |
380 | ||
381 | #ifdef CONFIG_PM | |
382 | static int s3c2410ts_suspend(struct device *dev) | |
383 | { | |
384 | writel(TSC_SLEEP, ts.io + S3C2410_ADCTSC); | |
385 | disable_irq(ts.irq_tc); | |
386 | clk_disable(ts.clock); | |
387 | ||
388 | return 0; | |
389 | } | |
390 | ||
391 | static int s3c2410ts_resume(struct device *dev) | |
392 | { | |
393 | struct platform_device *pdev = to_platform_device(dev); | |
c838cb3d | 394 | struct s3c2410_ts_mach_info *info = dev_get_platdata(&pdev->dev); |
f5f96b93 AP |
395 | |
396 | clk_enable(ts.clock); | |
2f095865 | 397 | enable_irq(ts.irq_tc); |
f5f96b93 AP |
398 | |
399 | /* Initialise registers */ | |
400 | if ((info->delay & 0xffff) > 0) | |
401 | writel(info->delay & 0xffff, ts.io + S3C2410_ADCDLY); | |
402 | ||
403 | writel(WAIT4INT | INT_DOWN, ts.io + S3C2410_ADCTSC); | |
404 | ||
405 | return 0; | |
406 | } | |
407 | ||
bd68dfe0 | 408 | static const struct dev_pm_ops s3c_ts_pmops = { |
f5f96b93 AP |
409 | .suspend = s3c2410ts_suspend, |
410 | .resume = s3c2410ts_resume, | |
411 | }; | |
412 | #endif | |
413 | ||
414 | static struct platform_device_id s3cts_driver_ids[] = { | |
03a3f695 VK |
415 | { "s3c2410-ts", 0 }, |
416 | { "s3c2440-ts", 0 }, | |
91df77d7 | 417 | { "s3c64xx-ts", FEAT_PEN_IRQ }, |
f5f96b93 AP |
418 | { } |
419 | }; | |
420 | MODULE_DEVICE_TABLE(platform, s3cts_driver_ids); | |
421 | ||
422 | static struct platform_driver s3c_ts_driver = { | |
423 | .driver = { | |
91df77d7 | 424 | .name = "samsung-ts", |
f5f96b93 AP |
425 | #ifdef CONFIG_PM |
426 | .pm = &s3c_ts_pmops, | |
427 | #endif | |
428 | }, | |
429 | .id_table = s3cts_driver_ids, | |
430 | .probe = s3c2410ts_probe, | |
1cb0aa88 | 431 | .remove = s3c2410ts_remove, |
f5f96b93 | 432 | }; |
cdcc96e2 | 433 | module_platform_driver(s3c_ts_driver); |
f5f96b93 AP |
434 | |
435 | MODULE_AUTHOR("Arnaud Patard <arnaud.patard@rtp-net.org>, " | |
436 | "Ben Dooks <ben@simtec.co.uk>, " | |
437 | "Simtec Electronics <linux@simtec.co.uk>"); | |
438 | MODULE_DESCRIPTION("S3C24XX Touchscreen driver"); | |
439 | MODULE_LICENSE("GPL v2"); |