Arnaud Patard | f5f96b9 | 2009-11-23 09:47:12 -0800 | [diff] [blame] | 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> |
Arnaud Patard | f5f96b9 | 2009-11-23 09:47:12 -0800 | [diff] [blame] | 29 | #include <linux/gpio.h> |
| 30 | #include <linux/input.h> |
Arnaud Patard | f5f96b9 | 2009-11-23 09:47:12 -0800 | [diff] [blame] | 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> |
Arnd Bergmann | 436d42c | 2012-08-24 15:22:12 +0200 | [diff] [blame] | 39 | #include <linux/platform_data/touchscreen-s3c2410.h> |
Arnaud Patard | f5f96b9 | 2009-11-23 09:47:12 -0800 | [diff] [blame] | 40 | |
Arnaud Patard | f5f96b9 | 2009-11-23 09:47:12 -0800 | [diff] [blame] | 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 | |
Naveen Krishna | 91df77d | 2010-05-18 20:44:45 +0900 | [diff] [blame] | 57 | #define FEAT_PEN_IRQ (1 << 0) /* HAS ADCCLRINTPNDNUP */ |
| 58 | |
Arnaud Patard | f5f96b9 | 2009-11-23 09:47:12 -0800 | [diff] [blame] | 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. |
Naveen Krishna | 91df77d | 2010-05-18 20:44:45 +0900 | [diff] [blame] | 73 | * @features: The features supported by the TSADC MOdule. |
Arnaud Patard | f5f96b9 | 2009-11-23 09:47:12 -0800 | [diff] [blame] | 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; |
Naveen Krishna | 91df77d | 2010-05-18 20:44:45 +0900 | [diff] [blame] | 86 | int features; |
Arnaud Patard | f5f96b9 | 2009-11-23 09:47:12 -0800 | [diff] [blame] | 87 | }; |
| 88 | |
| 89 | static struct s3c2410ts ts; |
| 90 | |
| 91 | /** |
Arnaud Patard | f5f96b9 | 2009-11-23 09:47:12 -0800 | [diff] [blame] | 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 | |
Arnaud Patard | f5f96b9 | 2009-11-23 09:47:12 -0800 | [diff] [blame] | 116 | if (down) { |
Vasily Khoruzhick | 23c239b | 2010-02-20 01:06:20 -0800 | [diff] [blame] | 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 | |
Arnaud Patard | f5f96b9 | 2009-11-23 09:47:12 -0800 | [diff] [blame] | 135 | s3c_adc_start(ts.client, 0, 1 << ts.shift); |
| 136 | } else { |
Vasily Khoruzhick | 23c239b | 2010-02-20 01:06:20 -0800 | [diff] [blame] | 137 | ts.xp = 0; |
| 138 | ts.yp = 0; |
Arnaud Patard | f5f96b9 | 2009-11-23 09:47:12 -0800 | [diff] [blame] | 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 |
Mark Brown | fbf89f2 | 2010-05-31 11:57:24 -0700 | [diff] [blame] | 175 | dev_dbg(ts.dev, "%s: count=%d\n", __func__, ts.count); |
Arnaud Patard | f5f96b9 | 2009-11-23 09:47:12 -0800 | [diff] [blame] | 176 | |
Naveen Krishna | 91df77d | 2010-05-18 20:44:45 +0900 | [diff] [blame] | 177 | if (ts.features & FEAT_PEN_IRQ) { |
| 178 | /* Clear pen down/up interrupt */ |
| 179 | writel(0x0, ts.io + S3C64XX_ADCCLRINTPNDNUP); |
| 180 | } |
| 181 | |
Arnaud Patard | f5f96b9 | 2009-11-23 09:47:12 -0800 | [diff] [blame] | 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 | */ |
Bill Pemberton | 5298cc4 | 2012-11-23 21:38:25 -0800 | [diff] [blame] | 240 | static int s3c2410ts_probe(struct platform_device *pdev) |
Arnaud Patard | f5f96b9 | 2009-11-23 09:47:12 -0800 | [diff] [blame] | 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 | |
Jingoo Han | c838cb3 | 2013-12-05 19:21:10 -0800 | [diff] [blame] | 253 | info = dev_get_platdata(&pdev->dev); |
Arnaud Patard | f5f96b9 | 2009-11-23 09:47:12 -0800 | [diff] [blame] | 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 | |
Vasily Khoruzhick | 09c8fb6 | 2014-07-08 17:57:42 -0700 | [diff] [blame] | 267 | clk_prepare_enable(ts.clock); |
Arnaud Patard | f5f96b9 | 2009-11-23 09:47:12 -0800 | [diff] [blame] | 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 | |
Naveen Krishna | 658ad39 | 2010-05-18 20:44:38 +0900 | [diff] [blame] | 290 | /* inititalise the gpio */ |
| 291 | if (info->cfg_gpio) |
| 292 | info->cfg_gpio(to_platform_device(ts.dev)); |
Arnaud Patard | f5f96b9 | 2009-11-23 09:47:12 -0800 | [diff] [blame] | 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; |
Naveen Krishna | 91df77d | 2010-05-18 20:44:45 +0900 | [diff] [blame] | 328 | ts.features = platform_get_device_id(pdev)->driver_data; |
Arnaud Patard | f5f96b9 | 2009-11-23 09:47:12 -0800 | [diff] [blame] | 329 | |
Yong Zhang | ec4665c | 2011-09-07 14:04:16 -0700 | [diff] [blame] | 330 | ret = request_irq(ts.irq_tc, stylus_irq, 0, |
Arnaud Patard | f5f96b9 | 2009-11-23 09:47:12 -0800 | [diff] [blame] | 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: |
Axel Lin | ec1496b | 2010-09-02 10:26:31 -0700 | [diff] [blame] | 352 | input_free_device(ts.input); |
Arnaud Patard | f5f96b9 | 2009-11-23 09:47:12 -0800 | [diff] [blame] | 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 | */ |
Bill Pemberton | e2619cf | 2012-11-23 21:50:47 -0800 | [diff] [blame] | 367 | static int s3c2410ts_remove(struct platform_device *pdev) |
Arnaud Patard | f5f96b9 | 2009-11-23 09:47:12 -0800 | [diff] [blame] | 368 | { |
| 369 | free_irq(ts.irq_tc, ts.input); |
| 370 | del_timer_sync(&touch_timer); |
| 371 | |
Vasily Khoruzhick | 09c8fb6 | 2014-07-08 17:57:42 -0700 | [diff] [blame] | 372 | clk_disable_unprepare(ts.clock); |
Arnaud Patard | f5f96b9 | 2009-11-23 09:47:12 -0800 | [diff] [blame] | 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); |
Jingoo Han | c838cb3 | 2013-12-05 19:21:10 -0800 | [diff] [blame] | 394 | struct s3c2410_ts_mach_info *info = dev_get_platdata(&pdev->dev); |
Arnaud Patard | f5f96b9 | 2009-11-23 09:47:12 -0800 | [diff] [blame] | 395 | |
| 396 | clk_enable(ts.clock); |
Vasily Khoruzhick | 2f09586 | 2010-02-19 01:18:11 -0800 | [diff] [blame] | 397 | enable_irq(ts.irq_tc); |
Arnaud Patard | f5f96b9 | 2009-11-23 09:47:12 -0800 | [diff] [blame] | 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 | |
Sachin Kamat | bd68dfe | 2012-08-31 07:50:21 -0700 | [diff] [blame] | 408 | static const struct dev_pm_ops s3c_ts_pmops = { |
Arnaud Patard | f5f96b9 | 2009-11-23 09:47:12 -0800 | [diff] [blame] | 409 | .suspend = s3c2410ts_suspend, |
| 410 | .resume = s3c2410ts_resume, |
| 411 | }; |
| 412 | #endif |
| 413 | |
Krzysztof Kozlowski | 3419e49 | 2015-05-06 16:55:21 -0700 | [diff] [blame] | 414 | static const struct platform_device_id s3cts_driver_ids[] = { |
Vasily Khoruzhick | 03a3f69 | 2010-05-27 09:03:19 -0700 | [diff] [blame] | 415 | { "s3c2410-ts", 0 }, |
| 416 | { "s3c2440-ts", 0 }, |
Naveen Krishna | 91df77d | 2010-05-18 20:44:45 +0900 | [diff] [blame] | 417 | { "s3c64xx-ts", FEAT_PEN_IRQ }, |
Arnaud Patard | f5f96b9 | 2009-11-23 09:47:12 -0800 | [diff] [blame] | 418 | { } |
| 419 | }; |
| 420 | MODULE_DEVICE_TABLE(platform, s3cts_driver_ids); |
| 421 | |
| 422 | static struct platform_driver s3c_ts_driver = { |
| 423 | .driver = { |
Naveen Krishna | 91df77d | 2010-05-18 20:44:45 +0900 | [diff] [blame] | 424 | .name = "samsung-ts", |
Arnaud Patard | f5f96b9 | 2009-11-23 09:47:12 -0800 | [diff] [blame] | 425 | #ifdef CONFIG_PM |
| 426 | .pm = &s3c_ts_pmops, |
| 427 | #endif |
| 428 | }, |
| 429 | .id_table = s3cts_driver_ids, |
| 430 | .probe = s3c2410ts_probe, |
Bill Pemberton | 1cb0aa8 | 2012-11-23 21:27:39 -0800 | [diff] [blame] | 431 | .remove = s3c2410ts_remove, |
Arnaud Patard | f5f96b9 | 2009-11-23 09:47:12 -0800 | [diff] [blame] | 432 | }; |
JJ Ding | cdcc96e | 2011-11-29 11:14:13 -0800 | [diff] [blame] | 433 | module_platform_driver(s3c_ts_driver); |
Arnaud Patard | f5f96b9 | 2009-11-23 09:47:12 -0800 | [diff] [blame] | 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"); |