drivers/soc/tsc2101.c

   1 /*
   2  * TI TSC2102 Common Code
   3  *
   4  * Copyright 2005 Openedhand Ltd.
   5  *
   6  * Author: Richard Purdie <richard@o-hand.com>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 as
  10  * published by the Free Software Foundation.
  11  *
  12  */
  13
  14 #include <linux/delay.h>
  15 #include <linux/device.h>
  16 #include <linux/init.h>
  17 #include <linux/input.h>
  18 #include <linux/interrupt.h>
  19 #include <linux/module.h>
  20 #include <linux/slab.h>
  21 #include <linux/soc/tsc2101.h>
  22 #include "tsc2101.h"
  23
  24 extern void tsc2101_ts_setup(struct device *dev);
  25 extern void tsc2101_ts_report(struct tsc2101_data *devdata, int x, int y, int p, int pendown);
  26
  27 static int tsc2101_regread(struct tsc2101_data *devdata, int regnum)
  28 {
  29         int reg;
  30         devdata->platform->send(TSC2101_READ, regnum, &reg, 1);
  31         return reg;
  32 }
  33
  34 static void tsc2101_regwrite(struct tsc2101_data *devdata, int regnum, int value)
  35 {
  36         int reg=value;
  37         devdata->platform->send(TSC2101_WRITE, regnum, &reg, 1);
  38         return;
  39 }
  40
  41 static int tsc2101_ts_penup(struct tsc2101_data *devdata)
  42 {
  43         return !( tsc2101_regread(devdata, TSC2101_REG_STATUS) & TSC2101_STATUS_DAVAIL);
  44 }
  45
  46 #define TSC2101_ADC_DEFAULT (TSC2101_ADC_RES(TSC2101_ADC_RES_12BITP) | TSC2101_ADC_AVG(TSC2101_ADC_4AVG) | TSC2101_ADC_CL(TSC2101_ADC_CL_1MHZ_12BIT) | TSC2101_ADC_PV(TSC2101_ADC_PV_500us) | TSC2101_ADC_AVGFILT_MEAN)
  47
  48 static void tsc2101_readdata(struct tsc2101_data *devdata, struct tsc2101_ts_event *ts_data)
  49 {
  50         int z1,z2,fixadc=0;
  51         u32 values[4],status;
  52
  53         status=tsc2101_regread(devdata, TSC2101_REG_STATUS);
  54
  55         if (status & (TSC2101_STATUS_XSTAT | TSC2101_STATUS_YSTAT | TSC2101_STATUS_Z1STAT
  56                 | TSC2101_STATUS_Z2STAT)) {
  57
  58                 /* Read X, Y, Z1 and Z2 */
  59                 devdata->platform->send(TSC2101_READ, TSC2101_REG_X, &values[0], 4);
  60
  61                 ts_data->x=values[0];
  62                 ts_data->y=values[1];
  63                 z1=values[2];
  64                 z2=values[3];
  65
  66                 /* Calculate Pressure */
  67                 if ((z1 != 0) && (ts_data->x!=0) && (ts_data->y!=0))
  68                         ts_data->p = ((ts_data->x * (z2 -z1) / z1));
  69                 else
  70                         ts_data->p=0;
  71         }
  72
  73     if (status & TSC2101_STATUS_BSTAT) {
  74                 devdata->platform->send(TSC2101_READ, TSC2101_REG_BAT, &values[0], 1);
  75                 devdata->miscdata.bat=values[0];
  76                 fixadc=1;
  77         }
  78         if (status & TSC2101_STATUS_AX1STAT) {
  79                 devdata->platform->send(TSC2101_READ, TSC2101_REG_AUX1, &values[0], 1);
  80                 devdata->miscdata.aux1=values[0];
  81                 fixadc=1;
  82         }
  83     if (status & TSC2101_STATUS_AX2STAT) {
  84         devdata->platform->send(TSC2101_READ, TSC2101_REG_AUX2, &values[0], 1);
  85         devdata->miscdata.aux2=values[0];
  86         fixadc=1;
  87         }
  88     if (status & TSC2101_STATUS_T1STAT) {
  89         devdata->platform->send(TSC2101_READ, TSC2101_REG_TEMP1, &values[0], 1);
  90         devdata->miscdata.temp1=values[0];
  91         fixadc=1;
  92         }
  93     if (status & TSC2101_STATUS_T2STAT) {
  94         devdata->platform->send(TSC2101_READ, TSC2101_REG_TEMP2, &values[0], 1);
  95         devdata->miscdata.temp2=values[0];
  96         fixadc=1;
  97     }
  98     if (fixadc) {
  99                 /* Switch back to touchscreen autoscan */
 100                 tsc2101_regwrite(devdata, TSC2101_REG_ADC, TSC2101_ADC_DEFAULT | TSC2101_ADC_PSM | TSC2101_ADC_ADMODE(0x2));
 101         }
 102 }
 103
 104 static void tsc2101_ts_enable(struct tsc2101_data *devdata)
 105 {
 106         //tsc2101_regwrite(devdata, TSC2101_REG_RESETCTL, 0xbb00);
 107
 108         /* PINTDAV is data available only */
 109         tsc2101_regwrite(devdata, TSC2101_REG_STATUS, 0x4000);
 110
 111         /* disable buffer mode */
 112         tsc2101_regwrite(devdata, TSC2101_REG_BUFMODE, 0x0);
 113
 114         /* use internal reference, 100 usec power-up delay,
 115          * power down between conversions, 1.25V internal reference */
 116         tsc2101_regwrite(devdata, TSC2101_REG_REF, 0x16);
 117
 118         /* enable touch detection, 84usec precharge time, 32 usec sense time */
 119         tsc2101_regwrite(devdata, TSC2101_REG_CONFIG, 0x08);
 120
 121         /* 3 msec conversion delays  */
 122         tsc2101_regwrite(devdata, TSC2101_REG_DELAY, 0x0900);
 123
 124         /*
 125          * TSC2101-controlled conversions
 126          * 12-bit samples
 127          * continuous X,Y,Z1,Z2 scan mode
 128          * average (mean) 4 samples per coordinate
 129          * 1 MHz internal conversion clock
 130          * 500 usec panel voltage stabilization delay
 131          */
 132         tsc2101_regwrite(devdata, TSC2101_REG_ADC, TSC2101_ADC_DEFAULT | TSC2101_ADC_PSM | TSC2101_ADC_ADMODE(0x2));
 133
 134         return;
 135 }
 136
 137 static void tsc2101_ts_disable(struct tsc2101_data *devdata)
 138 {
 139         /* stop conversions and power down */
 140         tsc2101_regwrite(devdata, TSC2101_REG_ADC, 0x4000);
 141 }
 142
 143 static void ts_interrupt_main(struct tsc2101_data *devdata, int isTimer, struct pt_regs *regs)
 144 {
 145         unsigned long flags;
 146         struct tsc2101_ts_event ts_data;
 147
 148         spin_lock_irqsave(&devdata->lock, flags);
 149
 150         //if (!tsc2101_ts_penup(devdata)) {
 151         if (devdata->platform->pendown()) {
 152                 devdata->pendown = 1;
 153                 tsc2101_readdata(devdata, &ts_data);
 154                 tsc2101_ts_report(devdata, ts_data.x, ts_data.y, ts_data.p, 1);
 155                 mod_timer(&(devdata->ts_timer), jiffies + HZ / 100);
 156         } else if (devdata->pendown > 0 && devdata->pendown < 3) {
 157                 mod_timer(&(devdata->ts_timer), jiffies + HZ / 100);
 158                 devdata->pendown++;
 159         } else {
 160                 if (devdata->pendown)
 161                         tsc2101_ts_report(devdata, 0, 0, 0, 0);
 162
 163                 devdata->pendown = 0;
 164
 165                 set_irq_type(devdata->platform->irq,IRQT_FALLING);
 166
 167                 /* This must be checked after set_irq_type() to make sure no data was missed */
 168                 if (devdata->platform->pendown()) {
 169                         tsc2101_readdata(devdata, &ts_data);
 170                         mod_timer(&(devdata->ts_timer), jiffies + HZ / 100);
 171                 }
 172         }
 173
 174         spin_unlock_irqrestore(&devdata->lock, flags);
 175 }
 176
 177
 178 static void tsc2101_timer(unsigned long data)
 179 {
 180         struct tsc2101_data *devdata = (struct tsc2101_data *) data;
 181
 182         ts_interrupt_main(devdata, 1, NULL);
 183 }
 184
 185 static irqreturn_t tsc2101_handler(int irq, void *dev_id, struct pt_regs *regs)
 186 {
 187         struct tsc2101_data *devdata = dev_id;
 188
 189         set_irq_type(devdata->platform->irq,IRQT_NOEDGE);
 190         ts_interrupt_main(devdata, 0, regs);
 191         return IRQ_HANDLED;
 192 }
 193
 194
 195 static void tsc2101_get_miscdata(struct tsc2101_data *devdata)
 196 {
 197         static int i=0;
 198         unsigned long flags;
 199
 200         if (devdata->pendown == 0) {
 201                 i++;
 202                 spin_lock_irqsave(&devdata->lock, flags);
 203                 if (i==1)
 204                         tsc2101_regwrite(devdata, TSC2101_REG_ADC, TSC2101_ADC_DEFAULT | TSC2101_ADC_ADMODE(0x6));
 205                 else if (i==2)
 206                         tsc2101_regwrite(devdata, TSC2101_REG_ADC, TSC2101_ADC_DEFAULT | TSC2101_ADC_ADMODE(0x7));
 207                 else if (i==3)
 208                         tsc2101_regwrite(devdata, TSC2101_REG_ADC, TSC2101_ADC_DEFAULT | TSC2101_ADC_ADMODE(0x8));
 209                 else if (i==4)
 210                         tsc2101_regwrite(devdata, TSC2101_REG_ADC, TSC2101_ADC_DEFAULT | TSC2101_ADC_ADMODE(0xa));
 211                 else if (i>=5) {
 212                         tsc2101_regwrite(devdata, TSC2101_REG_ADC, TSC2101_ADC_DEFAULT | TSC2101_ADC_ADMODE(0xc));
 213                         i=0;
 214                 }
 215                 spin_unlock_irqrestore(&devdata->lock, flags);
 216         }
 217 }
 218
 219
 220 static void tsc2101_misc_timer(unsigned long data)
 221 {
 222
 223         struct tsc2101_data *devdata = (struct tsc2101_data *) data;
 224         tsc2101_get_miscdata(devdata);
 225         mod_timer(&(devdata->misc_timer), jiffies + HZ);
 226 }
 227
 228 void tsc2101_print_miscdata(struct device *dev)
 229 {
 230         struct tsc2101_data *devdata = dev_get_drvdata(dev);
 231
 232         printk(KERN_ERR "TSC2101 Bat:   %04x\n",devdata->miscdata.bat);
 233         printk(KERN_ERR "TSC2101 Aux1:  %04x\n",devdata->miscdata.aux1);
 234         printk(KERN_ERR "TSC2101 Aux2:  %04x\n",devdata->miscdata.aux2);
 235         printk(KERN_ERR "TSC2101 Temp1: %04x\n",devdata->miscdata.temp1);
 236         printk(KERN_ERR "TSC2101 Temp2: %04x\n",devdata->miscdata.temp2);
 237 }
 238
 239 static int tsc2101_suspend(struct device *dev, u32 state, u32 level)
 240 {
 241         struct tsc2101_data *devdata = dev_get_drvdata(dev);
 242
 243         if (level == SUSPEND_POWER_DOWN) {
 244                 tsc2101_ts_disable(devdata);
 245                 devdata->platform->suspend();
 246         }
 247
 248         return 0;
 249 }
 250
 251 static int tsc2101_resume(struct device *dev, u32 level)
 252 {
 253         struct tsc2101_data *devdata = dev_get_drvdata(dev);
 254
 255         if (level == RESUME_POWER_ON) {
 256                 devdata->platform->resume();
 257                 tsc2101_ts_enable(devdata);
 258         }
 259
 260         return 0;
 261 }
 262
 263
 264 static int __init tsc2101_probe(struct device *dev)
 265 {
 266         struct tsc2101_data *devdata;
 267         struct tsc2101_ts_event ts_data;
 268
 269         if (!(devdata = kcalloc(1, sizeof(struct tsc2101_data), GFP_KERNEL)))
 270                 return -ENOMEM;
 271
 272         dev_set_drvdata(dev,devdata);
 273         spin_lock_init(&devdata->lock);
 274         devdata->platform = dev->platform_data;
 275
 276         init_timer(&devdata->ts_timer);
 277         devdata->ts_timer.data = (unsigned long) devdata;
 278         devdata->ts_timer.function = tsc2101_timer;
 279
 280         init_timer(&devdata->misc_timer);
 281         devdata->misc_timer.data = (unsigned long) devdata;
 282         devdata->misc_timer.function = tsc2101_misc_timer;
 283
 284         /* request irq */
 285         if (request_irq(devdata->platform->irq, tsc2101_handler, 0, "tsc2101", devdata)) {
 286                 printk(KERN_ERR "tsc2101: Could not allocate touchscreen IRQ!\n");
 287                 kfree(devdata);
 288                 return -EINVAL;
 289         }
 290
 291         tsc2101_ts_setup(dev);
 292         tsc2101_ts_enable(devdata);
 293
 294         set_irq_type(devdata->platform->irq,IRQT_FALLING);
 295         /* Check there is no pending data */
 296         tsc2101_readdata(devdata, &ts_data);
 297
 298         mod_timer(&(devdata->misc_timer), jiffies + HZ);
 299
 300         return 0;
 301 }
 302
 303
 304 static  int __exit tsc2101_remove(struct device *dev)
 305 {
 306         struct tsc2101_data *devdata = dev_get_drvdata(dev);
 307
 308         free_irq(devdata->platform->irq, devdata);
 309         del_timer_sync(&devdata->ts_timer);
 310         del_timer_sync(&devdata->misc_timer);
 311         input_unregister_device(&devdata->inputdevice);
 312         tsc2101_ts_disable(devdata);
 313         kfree(devdata);
 314         return 0;
 315 }
 316
 317 static struct device_driver tsc2101_driver = {
 318         .name           = "tsc2101",
 319         .bus            = &platform_bus_type,
 320         .probe          = tsc2101_probe,
 321         .remove         = __exit_p(tsc2101_remove),
 322         .suspend        = tsc2101_suspend,
 323         .resume         = tsc2101_resume,
 324 };
 325
 326 static int __init tsc2101_init(void)
 327 {
 328         return driver_register(&tsc2101_driver);
 329 }
 330
 331 static void __exit tsc2101_exit(void)
 332 {
 333         driver_unregister(&tsc2101_driver);
 334 }
 335
 336 module_init(tsc2101_init);
 337 module_exit(tsc2101_exit);
 338
 339 MODULE_LICENSE("GPL");