drivers/input/touchscreen/omap/omap_ts.c

   1 /*
   2  * input/touchscreen/omap/omap_ts.c
   3  *
   4  * touchscreen input device driver for various TI OMAP boards
   5  * Copyright (c) 2002 MontaVista Software Inc.
   6  * Copyright (c) 2004 Texas Instruments, Inc.
   7  * Cleanup and modularization 2004 by Dirk Behme <dirk.behme@de.bosch.com>
   8  *
   9  * Assembled using driver code copyright the companies above.
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  24  * History:
  25  * 12/12/2004    Srinath Modified and intergrated code for H2 and H3
  26  *
  27  */
  28
  29 #include <linux/errno.h>
  30 #include <linux/kernel.h>
  31 #include <linux/module.h>
  32 #include <linux/slab.h>
  33 #include <linux/input.h>
  34 #include <linux/init.h>
  35 #include <linux/wait.h>
  36 #include <linux/interrupt.h>
  37 #include <linux/suspend.h>
  38 #include <linux/device.h>
  39
  40 #include <asm/mach-types.h>
  41
  42 //#define DEBUG
  43
  44 #include "omap_ts.h"
  45
  46 #define OMAP_TS_NAME    "omap_ts"
  47
  48 static struct ts_device *__initdata ts_devs[] = {
  49 #if defined(CONFIG_MACH_OMAP_H2) || defined(CONFIG_MACH_OMAP_H3)
  50         &hx_ts,
  51 #endif
  52 #ifdef CONFIG_MACH_OMAP_OSK
  53         &osk_ts,
  54 #endif
  55 #if defined(CONFIG_MACH_OMAP_INNOVATOR) && defined(CONFIG_ARCH_OMAP1510)
  56         &innovator1510_ts,
  57 #endif
  58 };
  59
  60 static struct omap_ts_t ts_omap;
  61
  62 static int omap_ts_read(void)
  63 {
  64         u16 data[4] = { 0, 0, 0, 0 };
  65
  66         ts_omap.dev->read(data);
  67
  68         input_report_abs(&(ts_omap.inputdevice), ABS_X, data[0]);
  69         input_report_abs(&(ts_omap.inputdevice), ABS_Y, data[1]);
  70         input_report_abs(&(ts_omap.inputdevice), ABS_PRESSURE, data[2]);
  71         input_sync(&(ts_omap.inputdevice));
  72
  73         DEBUG_TS("omap_ts_read: read x=%d,y=%d,p=%d\n", data[0], data[1],
  74                  data[2]);
  75
  76         return 0;
  77 }
  78
  79 static void omap_ts_timer(unsigned long data)
  80 {
  81         unsigned long flags;
  82
  83         spin_lock_irqsave(&ts_omap.lock, flags);
  84
  85         if (!ts_omap.dev->penup()) {
  86                 if (!ts_omap.touched) {
  87                         DEBUG_TS("omap_ts_timer: pen down\n");
  88                         input_report_key(&(ts_omap.inputdevice), BTN_TOUCH, 1);
  89                 }
  90                 ts_omap.touched = 1;
  91                 omap_ts_read();
  92                 ts_omap.ts_timer.expires = jiffies + HZ / 100;
  93                 add_timer(&(ts_omap.ts_timer));
  94         } else {
  95                 if (ts_omap.touched) {
  96                         DEBUG_TS("omap_ts_timer: pen up\n");
  97                         ts_omap.touched = 0;
  98                         input_report_abs(&(ts_omap.inputdevice), ABS_X, 0);
  99                         input_report_abs(&(ts_omap.inputdevice), ABS_Y, 0);
 100                         input_report_abs(&(ts_omap.inputdevice), ABS_PRESSURE,
 101                                          0);
 102                         input_sync(&(ts_omap.inputdevice));
 103                         input_report_key(&(ts_omap.inputdevice), BTN_TOUCH, 0);
 104                 }
 105                 if (!ts_omap.irq_enabled) {
 106                         ts_omap.irq_enabled = 1;
 107                         enable_irq(ts_omap.irq);
 108                 }
 109         }
 110
 111         spin_unlock_irqrestore(&ts_omap.lock, flags);
 112 }
 113
 114 static irqreturn_t omap_ts_handler(int irq, void *dev_id, struct pt_regs *regs)
 115 {
 116         spin_lock(&ts_omap.lock);
 117
 118         if (ts_omap.irq_enabled) {
 119                 ts_omap.irq_enabled = 0;
 120                 disable_irq(irq);
 121         }
 122         // restart acquire
 123         ts_omap.ts_timer.expires = jiffies + HZ / 100;
 124         add_timer(&(ts_omap.ts_timer));
 125
 126         spin_unlock(&ts_omap.lock);
 127
 128         return IRQ_HANDLED;
 129 }
 130
 131 static int __init omap_ts_probe(struct device *dev)
 132 {
 133         int i;
 134         int status = -ENODEV;
 135
 136         memset(&ts_omap, 0, sizeof(ts_omap));
 137         spin_lock_init(&ts_omap.lock);
 138
 139         for (i = 0; i < ARRAY_SIZE(ts_devs); i++) {
 140                 if (!ts_devs[i] || !ts_devs[i]->probe)
 141                         continue;
 142                 status = ts_devs[i]->probe(&ts_omap);
 143                 if (status == 0) {
 144                         ts_omap.dev = ts_devs[i];
 145                         break;
 146                 }
 147         }
 148
 149         if (status != 0)
 150                 return status;
 151
 152         // Init acquisition timer function
 153         init_timer(&ts_omap.ts_timer);
 154         ts_omap.ts_timer.function = omap_ts_timer;
 155
 156         /* request irq */
 157         if (ts_omap.irq != -1) {
 158                 if (request_irq(ts_omap.irq, omap_ts_handler, 0,
 159                                 OMAP_TS_NAME, &ts_omap)) {
 160                         printk(KERN_ERR
 161           "omap_ts.c: Could not allocate touchscreen IRQ!\n");
 162                         ts_omap.irq = -1;
 163                         return -EINVAL;
 164                 }
 165                 ts_omap.irq_enabled = 1;
 166         } else {
 167                 printk(KERN_ERR "omap_ts.c: No touchscreen IRQ assigned!\n");
 168                 return -EINVAL;
 169         }
 170
 171         init_input_dev(&(ts_omap.inputdevice));
 172         ts_omap.inputdevice.name = OMAP_TS_NAME;
 173         ts_omap.inputdevice.evbit[0] = BIT(EV_KEY) | BIT(EV_ABS);
 174         ts_omap.inputdevice.keybit[LONG(BTN_TOUCH)] |= BIT(BTN_TOUCH);
 175         ts_omap.inputdevice.absbit[0] =
 176             BIT(ABS_X) | BIT(ABS_Y) | BIT(ABS_PRESSURE);
 177         input_register_device(&(ts_omap.inputdevice));
 178
 179         ts_omap.dev->enable();
 180
 181         printk("OMAP touchscreen driver initialized\n");
 182
 183         return 0;
 184 }
 185
 186 static int __exit omap_ts_remove(struct device *dev)
 187 {
 188         ts_omap.dev->disable();
 189         input_unregister_device(&ts_omap.inputdevice);
 190         if (ts_omap.irq != -1)
 191                 free_irq(ts_omap.irq, &ts_omap);
 192
 193         ts_omap.dev->remove();
 194
 195         return 0;
 196 }
 197
 198 static int omap_ts_suspend(struct device *dev, pm_message_t mesg, u32 level)
 199 {
 200         if (level != SUSPEND_POWER_DOWN) {
 201                 return 0;
 202         }
 203
 204         ts_omap.dev->disable();
 205         return 0;
 206 }
 207
 208 static int omap_ts_resume(struct device *dev, u32 level)
 209 {
 210         if (level != RESUME_POWER_ON) {
 211                 return 0;
 212         }
 213
 214         ts_omap.dev->enable();
 215         return 0;
 216 }
 217
 218 static void omap_ts_device_release(struct device *dev)
 219 {
 220         /* Nothing */
 221 }
 222
 223 static struct device_driver omap_ts_driver = {
 224         .name           = OMAP_TS_NAME,
 225         .bus            = &platform_bus_type,
 226         .probe          = omap_ts_probe,
 227         .remove         = __exit_p(omap_ts_remove),
 228         .suspend        = omap_ts_suspend,
 229         .resume         = omap_ts_resume,
 230 };
 231
 232 static struct platform_device omap_ts_device = {
 233         .name           = OMAP_TS_NAME,
 234         .id             = -1,
 235         .dev = {
 236                 .release        = omap_ts_device_release,
 237         },
 238 };
 239
 240 static int __init omap_ts_init(void)
 241 {
 242         int ret;
 243
 244         ret = platform_device_register(&omap_ts_device);
 245         if (ret != 0)
 246                 return -ENODEV;
 247
 248         ret = driver_register(&omap_ts_driver);
 249         if (ret != 0) {
 250                 platform_device_unregister(&omap_ts_device);
 251                 return -ENODEV;
 252         }
 253
 254         return 0;
 255 }
 256
 257 static void __exit omap_ts_exit(void)
 258 {
 259         driver_unregister(&omap_ts_driver);
 260         platform_device_unregister(&omap_ts_device);
 261 }
 262
 263 module_init(omap_ts_init);
 264 module_exit(omap_ts_exit);
 265
 266 MODULE_LICENSE("GPL");