| 1 | /* |
| 2 | * This program is free software; you can redistribute it and/or modify |
| 3 | * it under the terms of the GNU General Public License as published by |
| 4 | * the Free Software Foundation; either version 2 of the License, or |
| 5 | * (at your option) any later version. |
| 6 | * |
| 7 | * This program is distributed in the hope that it will be useful, |
| 8 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 9 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 10 | * GNU General Public License for more details. |
| 11 | * |
| 12 | * You should have received a copy of the GNU General Public License |
| 13 | * along with this program; if not, write to the Free Software |
| 14 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| 15 | * |
| 16 | * Copyright (c) 2004 Arnaud Patard <arnaud.patard@rtp-net.org> |
| 17 | * iPAQ H1940 touchscreen support |
| 18 | * |
| 19 | * ChangeLog |
| 20 | * |
| 21 | * 2004-09-05: Herbert Pötzl <herbert@13thfloor.at> |
| 22 | * - added clock (de-)allocation code |
| 23 | * |
| 24 | * 2005-03-06: Arnaud Patard <arnaud.patard@rtp-net.org> |
| 25 | * - h1940_ -> s3c2410 (this driver is now also used on the n30 |
| 26 | * machines :P) |
| 27 | * - Debug messages are now enabled with the config option |
| 28 | * TOUCHSCREEN_S3C2410_DEBUG |
| 29 | * - Changed the way the value are read |
| 30 | * - Input subsystem should now work |
| 31 | * - Use ioremap and readl/writel |
| 32 | * |
| 33 | * 2005-03-23: Arnaud Patard <arnaud.patard@rtp-net.org> |
| 34 | * - Make use of some undocumented features of the touchscreen |
| 35 | * controller |
| 36 | * |
| 37 | * 2007-05-23: Harald Welte <laforge@openmoko.org> |
| 38 | * - Add proper support for S32440 |
| 39 | * |
| 40 | * 2008-06-23: Andy Green <andy@openmoko.com> |
| 41 | * - removed averaging system |
| 42 | * - added generic Touchscreen filter stuff |
| 43 | * |
| 44 | * 2008-11-27: Nelson Castillo <arhuaco@freaks-unidos.net> |
| 45 | * - improve interrupt handling |
| 46 | */ |
| 47 | |
| 48 | #include <linux/errno.h> |
| 49 | #include <linux/kernel.h> |
| 50 | #include <linux/module.h> |
| 51 | #include <linux/slab.h> |
| 52 | #include <linux/input.h> |
| 53 | #include <linux/init.h> |
| 54 | #include <linux/serio.h> |
| 55 | #include <linux/timer.h> |
| 56 | #include <linux/kfifo.h> |
| 57 | #include <linux/delay.h> |
| 58 | #include <linux/platform_device.h> |
| 59 | #include <linux/clk.h> |
| 60 | #include <asm/io.h> |
| 61 | #include <asm/irq.h> |
| 62 | |
| 63 | #include <mach/regs-gpio.h> |
| 64 | #include <mach/ts.h> |
| 65 | #include <mach/hardware.h> |
| 66 | #include <plat/regs-adc.h> |
| 67 | |
| 68 | #include <linux/touchscreen/ts_filter_chain.h> |
| 69 | |
| 70 | /* For ts.dev.id.version */ |
| 71 | #define S3C2410TSVERSION 0x0101 |
| 72 | |
| 73 | #define TSC_SLEEP (S3C2410_ADCTSC_PULL_UP_DISABLE | S3C2410_ADCTSC_XY_PST(0)) |
| 74 | |
| 75 | #define WAIT4INT(x) (((x)<<8) | \ |
| 76 | S3C2410_ADCTSC_YM_SEN | \ |
| 77 | S3C2410_ADCTSC_YP_SEN | \ |
| 78 | S3C2410_ADCTSC_XP_SEN | \ |
| 79 | S3C2410_ADCTSC_XY_PST(3)) |
| 80 | |
| 81 | #define AUTOPST (S3C2410_ADCTSC_YM_SEN | \ |
| 82 | S3C2410_ADCTSC_YP_SEN | \ |
| 83 | S3C2410_ADCTSC_XP_SEN | \ |
| 84 | S3C2410_ADCTSC_AUTO_PST | \ |
| 85 | S3C2410_ADCTSC_XY_PST(0)) |
| 86 | |
| 87 | #define DEBUG_LVL KERN_DEBUG |
| 88 | |
| 89 | MODULE_AUTHOR("Arnaud Patard <arnaud.patard@rtp-net.org>"); |
| 90 | MODULE_DESCRIPTION("s3c2410 touchscreen driver"); |
| 91 | MODULE_LICENSE("GPL"); |
| 92 | |
| 93 | /* |
| 94 | * Definitions & global arrays. |
| 95 | */ |
| 96 | |
| 97 | static char *s3c2410ts_name = "s3c2410 TouchScreen"; |
| 98 | |
| 99 | #define TS_RELEASE_TIMEOUT (HZ >> 7 ? HZ >> 7 : 1) /* 8ms (5ms if HZ is 200) */ |
| 100 | #define TS_EVENT_FIFO_SIZE (2 << 6) /* must be a power of 2 */ |
| 101 | |
| 102 | #define TS_STATE_STANDBY 0 /* initial state */ |
| 103 | #define TS_STATE_PRESSED 1 |
| 104 | #define TS_STATE_RELEASE_PENDING 2 |
| 105 | #define TS_STATE_RELEASE 3 |
| 106 | |
| 107 | /* |
| 108 | * Per-touchscreen data. |
| 109 | */ |
| 110 | |
| 111 | struct s3c2410ts { |
| 112 | struct input_dev *dev; |
| 113 | struct ts_filter_chain *chain; |
| 114 | int is_down; |
| 115 | int state; |
| 116 | struct kfifo *event_fifo; |
| 117 | }; |
| 118 | |
| 119 | static struct s3c2410ts ts; |
| 120 | |
| 121 | static void __iomem *base_addr; |
| 122 | |
| 123 | /* |
| 124 | * A few low level functions. |
| 125 | */ |
| 126 | |
| 127 | static inline void s3c2410_ts_connect(void) |
| 128 | { |
| 129 | s3c2410_gpio_cfgpin(S3C2410_GPG12, S3C2410_GPG12_XMON); |
| 130 | s3c2410_gpio_cfgpin(S3C2410_GPG13, S3C2410_GPG13_nXPON); |
| 131 | s3c2410_gpio_cfgpin(S3C2410_GPG14, S3C2410_GPG14_YMON); |
| 132 | s3c2410_gpio_cfgpin(S3C2410_GPG15, S3C2410_GPG15_nYPON); |
| 133 | } |
| 134 | |
| 135 | static void s3c2410_ts_start_adc_conversion(void) |
| 136 | { |
| 137 | writel(S3C2410_ADCTSC_PULL_UP_DISABLE | AUTOPST, |
| 138 | base_addr + S3C2410_ADCTSC); |
| 139 | writel(readl(base_addr + S3C2410_ADCCON) | S3C2410_ADCCON_ENABLE_START, |
| 140 | base_addr + S3C2410_ADCCON); |
| 141 | } |
| 142 | |
| 143 | /* |
| 144 | * Just send the input events. |
| 145 | */ |
| 146 | |
| 147 | enum ts_input_event {IE_DOWN = 0, IE_UP}; |
| 148 | |
| 149 | static void ts_input_report(int event, int coords[]) |
| 150 | { |
| 151 | #ifdef CONFIG_TOUCHSCREEN_S3C2410_DEBUG |
| 152 | static char *s[] = {"down", "up"}; |
| 153 | struct timeval tv; |
| 154 | |
| 155 | do_gettimeofday(&tv); |
| 156 | #endif |
| 157 | |
| 158 | if (event == IE_DOWN) { |
| 159 | input_report_abs(ts.dev, ABS_X, coords[0]); |
| 160 | input_report_abs(ts.dev, ABS_Y, coords[1]); |
| 161 | input_report_key(ts.dev, BTN_TOUCH, 1); |
| 162 | input_report_abs(ts.dev, ABS_PRESSURE, 1); |
| 163 | |
| 164 | #ifdef CONFIG_TOUCHSCREEN_S3C2410_DEBUG |
| 165 | printk(DEBUG_LVL "T:%06d %6s (X:%03d, Y:%03d)\n", |
| 166 | (int)tv.tv_usec, s[event], coords[0], coords[1]); |
| 167 | #endif |
| 168 | } else { |
| 169 | input_report_key(ts.dev, BTN_TOUCH, 0); |
| 170 | input_report_abs(ts.dev, ABS_PRESSURE, 0); |
| 171 | |
| 172 | #ifdef CONFIG_TOUCHSCREEN_S3C2410_DEBUG |
| 173 | printk(DEBUG_LVL "T:%06d %6s\n", |
| 174 | (int)tv.tv_usec, s[event]); |
| 175 | #endif |
| 176 | } |
| 177 | |
| 178 | input_sync(ts.dev); |
| 179 | } |
| 180 | |
| 181 | /* |
| 182 | * Manage the state of the touchscreen. |
| 183 | */ |
| 184 | |
| 185 | static void event_send_timer_f(unsigned long data); |
| 186 | |
| 187 | static struct timer_list event_send_timer = |
| 188 | TIMER_INITIALIZER(event_send_timer_f, 0, 0); |
| 189 | |
| 190 | static void event_send_timer_f(unsigned long data) |
| 191 | { |
| 192 | static int noop_counter; |
| 193 | int event_type; |
| 194 | |
| 195 | while (__kfifo_get(ts.event_fifo, (unsigned char *)&event_type, |
| 196 | sizeof(int))) { |
| 197 | int buf[2]; |
| 198 | |
| 199 | switch (event_type) { |
| 200 | case 'D': |
| 201 | if (ts.state == TS_STATE_RELEASE_PENDING) |
| 202 | /* Ignore short UP event */ |
| 203 | ts.state = TS_STATE_PRESSED; |
| 204 | break; |
| 205 | |
| 206 | case 'U': |
| 207 | ts.state = TS_STATE_RELEASE_PENDING; |
| 208 | break; |
| 209 | |
| 210 | case 'P': |
| 211 | if (ts.is_down) /* stylus_action needs a conversion */ |
| 212 | s3c2410_ts_start_adc_conversion(); |
| 213 | |
| 214 | if (unlikely(__kfifo_get(ts.event_fifo, |
| 215 | (unsigned char *)buf, |
| 216 | sizeof(int) * 2) |
| 217 | != sizeof(int) * 2)) |
| 218 | goto ts_exit_error; |
| 219 | |
| 220 | ts_input_report(IE_DOWN, buf); |
| 221 | ts.state = TS_STATE_PRESSED; |
| 222 | break; |
| 223 | |
| 224 | default: |
| 225 | goto ts_exit_error; |
| 226 | } |
| 227 | |
| 228 | noop_counter = 0; |
| 229 | } |
| 230 | |
| 231 | if (noop_counter++ >= 1) { |
| 232 | noop_counter = 0; |
| 233 | if (ts.state == TS_STATE_RELEASE_PENDING) { |
| 234 | /* |
| 235 | * We delay the UP event for a while to avoid jitter. |
| 236 | * If we get a DOWN event we do not send it. |
| 237 | */ |
| 238 | ts_input_report(IE_UP, NULL); |
| 239 | ts.state = TS_STATE_STANDBY; |
| 240 | |
| 241 | ts_filter_chain_clear(ts.chain); |
| 242 | } |
| 243 | } else { |
| 244 | mod_timer(&event_send_timer, jiffies + TS_RELEASE_TIMEOUT); |
| 245 | } |
| 246 | |
| 247 | return; |
| 248 | |
| 249 | ts_exit_error: /* should not happen unless we have a bug */ |
| 250 | printk(KERN_ERR __FILE__ ": event_send_timer_f failed\n"); |
| 251 | } |
| 252 | |
| 253 | /* |
| 254 | * Manage interrupts. |
| 255 | */ |
| 256 | |
| 257 | static irqreturn_t stylus_updown(int irq, void *dev_id) |
| 258 | { |
| 259 | unsigned long data0; |
| 260 | unsigned long data1; |
| 261 | int event_type; |
| 262 | |
| 263 | data0 = readl(base_addr+S3C2410_ADCDAT0); |
| 264 | data1 = readl(base_addr+S3C2410_ADCDAT1); |
| 265 | |
| 266 | ts.is_down = (!(data0 & S3C2410_ADCDAT0_UPDOWN)) && |
| 267 | (!(data1 & S3C2410_ADCDAT0_UPDOWN)); |
| 268 | |
| 269 | event_type = ts.is_down ? 'D' : 'U'; |
| 270 | |
| 271 | if (unlikely(__kfifo_put(ts.event_fifo, (unsigned char *)&event_type, |
| 272 | sizeof(int)) != sizeof(int))) /* should not happen */ |
| 273 | printk(KERN_ERR __FILE__": stylus_updown lost event!\n"); |
| 274 | |
| 275 | if (ts.is_down) |
| 276 | s3c2410_ts_start_adc_conversion(); |
| 277 | else |
| 278 | writel(WAIT4INT(0), base_addr+S3C2410_ADCTSC); |
| 279 | |
| 280 | mod_timer(&event_send_timer, jiffies + 1); |
| 281 | |
| 282 | return IRQ_HANDLED; |
| 283 | } |
| 284 | |
| 285 | static irqreturn_t stylus_action(int irq, void *dev_id) |
| 286 | { |
| 287 | int buf[3]; |
| 288 | |
| 289 | /* Grab the ADC results. */ |
| 290 | buf[1] = readl(base_addr + S3C2410_ADCDAT0) & |
| 291 | S3C2410_ADCDAT0_XPDATA_MASK; |
| 292 | buf[2] = readl(base_addr + S3C2410_ADCDAT1) & |
| 293 | S3C2410_ADCDAT1_YPDATA_MASK; |
| 294 | |
| 295 | switch (ts_filter_chain_feed(ts.chain, &buf[1])) { |
| 296 | case 0: |
| 297 | /* The filter wants more points. */ |
| 298 | s3c2410_ts_start_adc_conversion(); |
| 299 | return IRQ_HANDLED; |
| 300 | case 1: |
| 301 | /* We have a point from the filters or no filtering enabled. */ |
| 302 | buf[0] = 'P'; |
| 303 | break; |
| 304 | default: |
| 305 | printk(KERN_ERR __FILE__ |
| 306 | ":%d Invalid ts_filter_chain_feed return value.\n", |
| 307 | __LINE__); |
| 308 | case -1: |
| 309 | /* Error. Ignore the event. */ |
| 310 | ts_filter_chain_clear(ts.chain); |
| 311 | writel(WAIT4INT(1), base_addr + S3C2410_ADCTSC); |
| 312 | return IRQ_HANDLED; |
| 313 | }; |
| 314 | |
| 315 | if (unlikely(__kfifo_put(ts.event_fifo, (unsigned char *)buf, |
| 316 | sizeof(int) * 3) != sizeof(int) * 3)) |
| 317 | printk(KERN_ERR __FILE__":stylus_action bug.\n"); |
| 318 | |
| 319 | writel(WAIT4INT(1), base_addr + S3C2410_ADCTSC); |
| 320 | mod_timer(&event_send_timer, jiffies + 1); |
| 321 | |
| 322 | return IRQ_HANDLED; |
| 323 | } |
| 324 | |
| 325 | static struct clk *adc_clock; |
| 326 | |
| 327 | /* |
| 328 | * The functions for inserting/removing us as a module. |
| 329 | */ |
| 330 | |
| 331 | static int __init s3c2410ts_probe(struct platform_device *pdev) |
| 332 | { |
| 333 | int rc; |
| 334 | struct s3c2410_ts_mach_info *info; |
| 335 | struct input_dev *input_dev; |
| 336 | int ret = 0; |
| 337 | |
| 338 | dev_info(&pdev->dev, "Starting\n"); |
| 339 | |
| 340 | info = (struct s3c2410_ts_mach_info *)pdev->dev.platform_data; |
| 341 | |
| 342 | if (!info) |
| 343 | { |
| 344 | dev_err(&pdev->dev, "Hm... too bad: no platform data for ts\n"); |
| 345 | return -EINVAL; |
| 346 | } |
| 347 | |
| 348 | #ifdef CONFIG_TOUCHSCREEN_S3C2410_DEBUG |
| 349 | printk(DEBUG_LVL "Entering s3c2410ts_init\n"); |
| 350 | #endif |
| 351 | |
| 352 | adc_clock = clk_get(NULL, "adc"); |
| 353 | if (!adc_clock) { |
| 354 | dev_err(&pdev->dev, "failed to get adc clock source\n"); |
| 355 | return -ENOENT; |
| 356 | } |
| 357 | clk_enable(adc_clock); |
| 358 | |
| 359 | #ifdef CONFIG_TOUCHSCREEN_S3C2410_DEBUG |
| 360 | printk(DEBUG_LVL "got and enabled clock\n"); |
| 361 | #endif |
| 362 | |
| 363 | base_addr = ioremap(S3C2410_PA_ADC,0x20); |
| 364 | if (base_addr == NULL) { |
| 365 | dev_err(&pdev->dev, "Failed to remap register block\n"); |
| 366 | ret = -ENOMEM; |
| 367 | goto bail0; |
| 368 | } |
| 369 | |
| 370 | |
| 371 | /* If we acutally are a S3C2410: Configure GPIOs */ |
| 372 | if (!strcmp(pdev->name, "s3c2410-ts")) |
| 373 | s3c2410_ts_connect(); |
| 374 | |
| 375 | if ((info->presc & 0xff) > 0) |
| 376 | writel(S3C2410_ADCCON_PRSCEN | |
| 377 | S3C2410_ADCCON_PRSCVL(info->presc&0xFF), |
| 378 | base_addr + S3C2410_ADCCON); |
| 379 | else |
| 380 | writel(0, base_addr+S3C2410_ADCCON); |
| 381 | |
| 382 | /* Initialise registers */ |
| 383 | if ((info->delay & 0xffff) > 0) |
| 384 | writel(info->delay & 0xffff, base_addr + S3C2410_ADCDLY); |
| 385 | |
| 386 | writel(WAIT4INT(0), base_addr + S3C2410_ADCTSC); |
| 387 | |
| 388 | /* Initialise input stuff */ |
| 389 | memset(&ts, 0, sizeof(struct s3c2410ts)); |
| 390 | input_dev = input_allocate_device(); |
| 391 | |
| 392 | if (!input_dev) { |
| 393 | dev_err(&pdev->dev, "Unable to allocate the input device\n"); |
| 394 | ret = -ENOMEM; |
| 395 | goto bail1; |
| 396 | } |
| 397 | |
| 398 | ts.dev = input_dev; |
| 399 | ts.dev->evbit[0] = BIT_MASK(EV_SYN) | BIT_MASK(EV_KEY) | |
| 400 | BIT_MASK(EV_ABS); |
| 401 | ts.dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH); |
| 402 | input_set_abs_params(ts.dev, ABS_X, 0, 0x3FF, 0, 0); |
| 403 | input_set_abs_params(ts.dev, ABS_Y, 0, 0x3FF, 0, 0); |
| 404 | input_set_abs_params(ts.dev, ABS_PRESSURE, 0, 1, 0, 0); |
| 405 | |
| 406 | ts.dev->name = s3c2410ts_name; |
| 407 | ts.dev->id.bustype = BUS_RS232; |
| 408 | ts.dev->id.vendor = 0xDEAD; |
| 409 | ts.dev->id.product = 0xBEEF; |
| 410 | ts.dev->id.version = S3C2410TSVERSION; |
| 411 | ts.state = TS_STATE_STANDBY; |
| 412 | ts.event_fifo = kfifo_alloc(TS_EVENT_FIFO_SIZE, GFP_KERNEL, NULL); |
| 413 | if (IS_ERR(ts.event_fifo)) { |
| 414 | ret = -EIO; |
| 415 | goto bail2; |
| 416 | } |
| 417 | |
| 418 | /* create the filter chain set up for the 2 coordinates we produce */ |
| 419 | ts.chain = ts_filter_chain_create(pdev, info->filter_config, 2); |
| 420 | |
| 421 | if (IS_ERR(ts.chain)) |
| 422 | goto bail2; |
| 423 | |
| 424 | ts_filter_chain_clear(ts.chain); |
| 425 | |
| 426 | /* Get irqs */ |
| 427 | if (request_irq(IRQ_ADC, stylus_action, 0, |
| 428 | "s3c2410_action", ts.dev)) { |
| 429 | dev_err(&pdev->dev, "Could not allocate ts IRQ_ADC !\n"); |
| 430 | iounmap(base_addr); |
| 431 | ret = -EIO; |
| 432 | goto bail3; |
| 433 | } |
| 434 | if (request_irq(IRQ_TC, stylus_updown, 0, |
| 435 | "s3c2410_action", ts.dev)) { |
| 436 | dev_err(&pdev->dev, "Could not allocate ts IRQ_TC !\n"); |
| 437 | free_irq(IRQ_ADC, ts.dev); |
| 438 | iounmap(base_addr); |
| 439 | ret = -EIO; |
| 440 | goto bail4; |
| 441 | } |
| 442 | |
| 443 | dev_info(&pdev->dev, "Successfully loaded\n"); |
| 444 | |
| 445 | /* All went ok, so register to the input system */ |
| 446 | rc = input_register_device(ts.dev); |
| 447 | if (rc) { |
| 448 | ret = -EIO; |
| 449 | goto bail5; |
| 450 | } |
| 451 | |
| 452 | return 0; |
| 453 | |
| 454 | bail5: |
| 455 | free_irq(IRQ_TC, ts.dev); |
| 456 | free_irq(IRQ_ADC, ts.dev); |
| 457 | clk_disable(adc_clock); |
| 458 | iounmap(base_addr); |
| 459 | disable_irq(IRQ_TC); |
| 460 | bail4: |
| 461 | disable_irq(IRQ_ADC); |
| 462 | bail3: |
| 463 | ts_filter_chain_destroy(ts.chain); |
| 464 | kfifo_free(ts.event_fifo); |
| 465 | bail2: |
| 466 | input_unregister_device(ts.dev); |
| 467 | bail1: |
| 468 | iounmap(base_addr); |
| 469 | bail0: |
| 470 | |
| 471 | return ret; |
| 472 | } |
| 473 | |
| 474 | static int s3c2410ts_remove(struct platform_device *pdev) |
| 475 | { |
| 476 | disable_irq(IRQ_ADC); |
| 477 | disable_irq(IRQ_TC); |
| 478 | free_irq(IRQ_TC,ts.dev); |
| 479 | free_irq(IRQ_ADC,ts.dev); |
| 480 | |
| 481 | if (adc_clock) { |
| 482 | clk_disable(adc_clock); |
| 483 | clk_put(adc_clock); |
| 484 | adc_clock = NULL; |
| 485 | } |
| 486 | |
| 487 | input_unregister_device(ts.dev); |
| 488 | iounmap(base_addr); |
| 489 | |
| 490 | ts_filter_chain_destroy(ts.chain); |
| 491 | |
| 492 | kfifo_free(ts.event_fifo); |
| 493 | |
| 494 | return 0; |
| 495 | } |
| 496 | |
| 497 | #ifdef CONFIG_PM |
| 498 | static int s3c2410ts_suspend(struct platform_device *pdev, pm_message_t state) |
| 499 | { |
| 500 | writel(TSC_SLEEP, base_addr+S3C2410_ADCTSC); |
| 501 | writel(readl(base_addr+S3C2410_ADCCON) | S3C2410_ADCCON_STDBM, |
| 502 | base_addr+S3C2410_ADCCON); |
| 503 | |
| 504 | disable_irq(IRQ_ADC); |
| 505 | disable_irq(IRQ_TC); |
| 506 | |
| 507 | clk_disable(adc_clock); |
| 508 | |
| 509 | return 0; |
| 510 | } |
| 511 | |
| 512 | static int s3c2410ts_resume(struct platform_device *pdev) |
| 513 | { |
| 514 | struct s3c2410_ts_mach_info *info = |
| 515 | ( struct s3c2410_ts_mach_info *)pdev->dev.platform_data; |
| 516 | |
| 517 | clk_enable(adc_clock); |
| 518 | mdelay(1); |
| 519 | |
| 520 | ts_filter_chain_clear(ts.chain); |
| 521 | |
| 522 | enable_irq(IRQ_ADC); |
| 523 | enable_irq(IRQ_TC); |
| 524 | |
| 525 | if ((info->presc&0xff) > 0) |
| 526 | writel(S3C2410_ADCCON_PRSCEN | |
| 527 | S3C2410_ADCCON_PRSCVL(info->presc&0xFF), |
| 528 | base_addr+S3C2410_ADCCON); |
| 529 | else |
| 530 | writel(0,base_addr+S3C2410_ADCCON); |
| 531 | |
| 532 | /* Initialise registers */ |
| 533 | if ((info->delay & 0xffff) > 0) |
| 534 | writel(info->delay & 0xffff, base_addr+S3C2410_ADCDLY); |
| 535 | |
| 536 | writel(WAIT4INT(0), base_addr+S3C2410_ADCTSC); |
| 537 | |
| 538 | return 0; |
| 539 | } |
| 540 | |
| 541 | #else |
| 542 | #define s3c2410ts_suspend NULL |
| 543 | #define s3c2410ts_resume NULL |
| 544 | #endif |
| 545 | |
| 546 | static struct platform_driver s3c2410ts_driver = { |
| 547 | .driver = { |
| 548 | .name = "s3c2410-ts", |
| 549 | .owner = THIS_MODULE, |
| 550 | }, |
| 551 | .probe = s3c2410ts_probe, |
| 552 | .remove = s3c2410ts_remove, |
| 553 | .suspend = s3c2410ts_suspend, |
| 554 | .resume = s3c2410ts_resume, |
| 555 | |
| 556 | }; |
| 557 | |
| 558 | static struct platform_driver s3c2440ts_driver = { |
| 559 | .driver = { |
| 560 | .name = "s3c2440-ts", |
| 561 | .owner = THIS_MODULE, |
| 562 | }, |
| 563 | .probe = s3c2410ts_probe, |
| 564 | .remove = s3c2410ts_remove, |
| 565 | .suspend = s3c2410ts_suspend, |
| 566 | .resume = s3c2410ts_resume, |
| 567 | |
| 568 | }; |
| 569 | |
| 570 | static int __init s3c2410ts_init(void) |
| 571 | { |
| 572 | int rc; |
| 573 | |
| 574 | rc = platform_driver_register(&s3c2410ts_driver); |
| 575 | if (rc < 0) |
| 576 | return rc; |
| 577 | |
| 578 | rc = platform_driver_register(&s3c2440ts_driver); |
| 579 | if (rc < 0) |
| 580 | platform_driver_unregister(&s3c2410ts_driver); |
| 581 | |
| 582 | return rc; |
| 583 | } |
| 584 | |
| 585 | static void __exit s3c2410ts_exit(void) |
| 586 | { |
| 587 | platform_driver_unregister(&s3c2440ts_driver); |
| 588 | platform_driver_unregister(&s3c2410ts_driver); |
| 589 | } |
| 590 | |
| 591 | module_init(s3c2410ts_init); |
| 592 | module_exit(s3c2410ts_exit); |
| 593 | |
| 594 | |
