Version:  2.0.40 2.2.26 2.4.37 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16

Linux/drivers/input/touchscreen/s3c2410_ts.c

  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>
 29 #include <linux/gpio.h>
 30 #include <linux/input.h>
 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>
 39 #include <linux/platform_data/touchscreen-s3c2410.h>
 40 
 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 
 57 #define FEAT_PEN_IRQ    (1 << 0)        /* HAS ADCCLRINTPNDNUP */
 58 
 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.
 73  * @features: The features supported by the TSADC MOdule.
 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;
 86         int features;
 87 };
 88 
 89 static struct s3c2410ts ts;
 90 
 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 
116         if (down) {
117                 if (ts.count == (1 << ts.shift)) {
118                         ts.xp >>= ts.shift;
119                         ts.yp >>= ts.shift;
120 
121                         dev_dbg(ts.dev, "%s: X=%lu, Y=%lu, count=%d\n",
122                                 __func__, ts.xp, ts.yp, ts.count);
123 
124                         input_report_abs(ts.input, ABS_X, ts.xp);
125                         input_report_abs(ts.input, ABS_Y, ts.yp);
126 
127                         input_report_key(ts.input, BTN_TOUCH, 1);
128                         input_sync(ts.input);
129 
130                         ts.xp = 0;
131                         ts.yp = 0;
132                         ts.count = 0;
133                 }
134 
135                 s3c_adc_start(ts.client, 0, 1 << ts.shift);
136         } else {
137                 ts.xp = 0;
138                 ts.yp = 0;
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
175                 dev_dbg(ts.dev, "%s: count=%d\n", __func__, ts.count);
176 
177         if (ts.features & FEAT_PEN_IRQ) {
178                 /* Clear pen down/up interrupt */
179                 writel(0x0, ts.io + S3C64XX_ADCCLRINTPNDNUP);
180         }
181 
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  */
240 static int s3c2410ts_probe(struct platform_device *pdev)
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 
253         info = dev_get_platdata(&pdev->dev);
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 
267         clk_enable(ts.clock);
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 
290         /* inititalise the gpio */
291         if (info->cfg_gpio)
292                 info->cfg_gpio(to_platform_device(ts.dev));
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;
328         ts.features = platform_get_device_id(pdev)->driver_data;
329 
330         ret = request_irq(ts.irq_tc, stylus_irq, 0,
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:
352         input_free_device(ts.input);
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  */
367 static int s3c2410ts_remove(struct platform_device *pdev)
368 {
369         free_irq(ts.irq_tc, ts.input);
370         del_timer_sync(&touch_timer);
371 
372         clk_disable(ts.clock);
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);
394         struct s3c2410_ts_mach_info *info = dev_get_platdata(&pdev->dev);
395 
396         clk_enable(ts.clock);
397         enable_irq(ts.irq_tc);
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 
408 static const struct dev_pm_ops s3c_ts_pmops = {
409         .suspend        = s3c2410ts_suspend,
410         .resume         = s3c2410ts_resume,
411 };
412 #endif
413 
414 static struct platform_device_id s3cts_driver_ids[] = {
415         { "s3c2410-ts", 0 },
416         { "s3c2440-ts", 0 },
417         { "s3c64xx-ts", FEAT_PEN_IRQ },
418         { }
419 };
420 MODULE_DEVICE_TABLE(platform, s3cts_driver_ids);
421 
422 static struct platform_driver s3c_ts_driver = {
423         .driver         = {
424                 .name   = "samsung-ts",
425                 .owner  = THIS_MODULE,
426 #ifdef CONFIG_PM
427                 .pm     = &s3c_ts_pmops,
428 #endif
429         },
430         .id_table       = s3cts_driver_ids,
431         .probe          = s3c2410ts_probe,
432         .remove         = s3c2410ts_remove,
433 };
434 module_platform_driver(s3c_ts_driver);
435 
436 MODULE_AUTHOR("Arnaud Patard <arnaud.patard@rtp-net.org>, "
437               "Ben Dooks <ben@simtec.co.uk>, "
438               "Simtec Electronics <linux@simtec.co.uk>");
439 MODULE_DESCRIPTION("S3C24XX Touchscreen driver");
440 MODULE_LICENSE("GPL v2");
441 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us