drivers/soc/tsc2200.c

   1 /*
   2  * TI TSC2200 Common Code
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License version 2 as
   6  * published by the Free Software Foundation.
   7  *
   8  */
   9
  10 #include <asm/mach-types.h>
  11 #include <asm/arch/hardware.h>
  12 #include <asm/arch/pxa-regs.h>
  13
  14 #include <linux/interrupt.h>
  15 #include <linux/device.h>
  16 #include <linux/delay.h>
  17 #include <linux/soc/tsc2200.h>
  18 #include <linux/platform_device.h>
  19
  20 unsigned short tsc2200_read(struct device *dev, unsigned short reg)
  21 {
  22
  23         struct tsc2200_data *devdata = dev_get_drvdata(dev);
  24
  25         reg |= TSC2200_REG_READ;
  26
  27         return devdata->platform->send(reg, 0);
  28 }
  29 EXPORT_SYMBOL(tsc2200_read);
  30
  31 void tsc2200_write(struct device *dev, unsigned short reg, unsigned short value)
  32 {
  33         struct tsc2200_data *devdata = dev_get_drvdata(dev);
  34
  35 //      int reg=value;
  36         devdata->platform->send(reg, value);
  37         return;
  38 }
  39 EXPORT_SYMBOL(tsc2200_write);
  40
  41 unsigned short tsc2200_dav(struct device *dev)
  42 {
  43         return ( tsc2200_read(dev, TSC2200_CTRLREG_CONFIG) & TSC2200_CTRLREG_CONFIG_DAV ) ? 0 : 1;
  44 }
  45 EXPORT_SYMBOL(tsc2200_dav);
  46
  47 void tsc2200_lock( struct device *dev )
  48 {
  49         unsigned long flags=0;
  50         struct tsc2200_data *devdata = dev_get_drvdata(dev);
  51         spin_lock_irqsave(&devdata->lock, flags);
  52 }
  53 EXPORT_SYMBOL(tsc2200_lock);
  54
  55 void tsc2200_unlock( struct device *dev )
  56 {
  57         unsigned long flags=0;
  58         struct tsc2200_data *devdata = dev_get_drvdata(dev);
  59         spin_unlock_irqrestore(&devdata->lock, flags);
  60 }
  61 EXPORT_SYMBOL(tsc2200_unlock);
  62
  63 void tsc2200_stop(struct device *dev ) {
  64         printk("TSC2200_ADC: %d\n", tsc2200_read( dev, TSC2200_CTRLREG_ADC ) );
  65         tsc2200_write( dev, TSC2200_CTRLREG_ADC, 0);
  66         printk("TSC2200_ADC: %d\n", tsc2200_read( dev, TSC2200_CTRLREG_ADC ) );
  67 }
  68 EXPORT_SYMBOL( tsc2200_stop );
  69
  70 void tsc2200_reset( struct device *dev )
  71 {
  72         unsigned long flags;
  73         struct tsc2200_data *devdata = dev_get_drvdata(dev);
  74
  75         spin_lock_irqsave(&devdata->lock, flags);
  76
  77         tsc2200_write(dev, TSC2200_CTRLREG_RESET, 0xBBFF);
  78
  79         printk("%s: %X.\n", __FUNCTION__, tsc2200_read(dev, TSC2200_CTRLREG_ADC));
  80         msleep(100);
  81         printk("%s: %X.\n", __FUNCTION__, tsc2200_read(dev, TSC2200_CTRLREG_ADC));
  82
  83         tsc2200_write(dev, TSC2200_CTRLREG_REF, 0x1F);
  84         tsc2200_write(dev, TSC2200_CTRLREG_CONFIG, 0xA);
  85
  86         spin_unlock_irqrestore(&devdata->lock, flags);
  87 }
  88
  89 static int tsc2200_suspend(struct device *dev, pm_message_t state)
  90 {
  91         struct tsc2200_data *devdata = dev_get_drvdata(dev);
  92         if (devdata->platform->exit) {
  93                 devdata->platform->exit();
  94         }
  95         return 0;
  96 }
  97
  98 static int tsc2200_resume(struct device *dev)
  99 {
 100         struct tsc2200_data *devdata = dev_get_drvdata(dev);
 101         if (devdata->platform->init) {
 102                 devdata->platform->init();
 103         }
 104 //      tsc2200_reset( dev );
 105         return 0;
 106 }
 107
 108 static void tsc2200_register_button_driver ( struct device *dev ) {
 109
 110         struct tsc2200_data *devdata = dev_get_drvdata(dev);
 111         struct tsc2200_platform_info *platform_info = devdata->platform;
 112
 113         struct platform_device *sdev = kzalloc (sizeof (*sdev), GFP_KERNEL);
 114         struct tsc2200_buttons_data *buttons_devdata = kzalloc (sizeof (*buttons_devdata), GFP_KERNEL);
 115
 116
 117         // Prepare some platform info for the tsc2200 buttons
 118         sdev->name = "tsc2200-keys";
 119         sdev->dev.platform_data = buttons_devdata;
 120
 121         buttons_devdata->tsc2200_dev = dev;
 122         buttons_devdata->platform_info = platform_info->buttons_info;
 123
 124         platform_device_register( sdev );
 125
 126         devdata->buttons_dev = sdev;
 127
 128 }
 129
 130 static void tsc2200_unregister_button_driver (struct device *dev ) {
 131         struct tsc2200_data *devdata = dev_get_drvdata(dev);
 132         //struct tsc2200_platform_info *platform_info = devdata->platform;
 133
 134         kfree (devdata->buttons_dev->dev.platform_data);
 135         kfree (devdata->buttons_dev);
 136
 137 }
 138
 139 static void tsc2200_register_ts_driver ( struct device *dev ) {
 140
 141         struct tsc2200_data *devdata = dev_get_drvdata(dev);
 142         struct tsc2200_platform_info *platform_info = devdata->platform;
 143
 144         struct platform_device *sdev = kzalloc (sizeof (*sdev), GFP_KERNEL);
 145         struct tsc2200_ts_data *ts_devdata = kzalloc (sizeof (*ts_devdata), GFP_KERNEL);
 146
 147
 148         // Prepare some platform info for the tsc2200 buttons
 149         sdev->name = "tsc2200-ts";
 150         sdev->dev.platform_data = ts_devdata;
 151
 152         ts_devdata->tsc2200_dev = dev;
 153         ts_devdata->platform_info = platform_info->touchscreen_info;
 154
 155         platform_device_register( sdev );
 156
 157         devdata->ts_dev = sdev;
 158
 159 }
 160
 161 static void tsc2200_unregister_ts_driver (struct device *dev ) {
 162         struct tsc2200_data *devdata = dev_get_drvdata(dev);
 163         //struct tsc2200_platform_info *platform_info = devdata->platform;
 164
 165         kfree (devdata->ts_dev->dev.platform_data);
 166         kfree (devdata->ts_dev);
 167 }
 168
 169
 170 static int __init tsc2200_probe(struct device *dev)
 171 {
 172         struct tsc2200_data *devdata;
 173
 174         if (!(devdata = kcalloc(1, sizeof(struct tsc2200_data), GFP_KERNEL)))
 175                 return -ENOMEM;
 176
 177         dev_set_drvdata(dev, devdata);
 178         spin_lock_init(&devdata->lock);
 179         devdata->platform = dev->platform_data;
 180
 181         if (devdata->platform->init) {
 182                 devdata->platform->init();
 183         }
 184
 185         udelay(300);
 186 //      tsc2200_reset( dev );
 187         udelay(300);
 188
 189         printk("%s: SPI: cr0 %08x cr1 %08x sr: %08x it: %08x to: %08x ps: %08x\n",
 190                         __FUNCTION__,
 191                         SSCR0_P2, SSCR1_P2, SSSR_P2, SSITR_P2, SSTO_P2, SSPSP_P2);
 192
 193         // Are there keys on this device?
 194         if (devdata->platform->buttons_info) {
 195                 tsc2200_register_button_driver( dev );
 196         }
 197
 198         // Is there a touchscreen on this device?
 199         if (devdata->platform->touchscreen_info) {
 200                 tsc2200_register_ts_driver( dev );
 201         }
 202
 203
 204         return 0;
 205 }
 206
 207
 208 static  int __exit tsc2200_remove(struct device *dev)
 209 {
 210         struct tsc2200_data *devdata = dev_get_drvdata(dev);
 211
 212         // Are there keys on this device?
 213         if (devdata->platform->buttons_info) {
 214                 tsc2200_unregister_button_driver( dev );
 215         }
 216
 217         // Is there a touchscreen on this device?
 218         if (devdata->platform->touchscreen_info) {
 219                 tsc2200_unregister_ts_driver( dev );
 220         }
 221
 222         kfree(devdata);
 223         return 0;
 224 }
 225
 226 static struct platform_driver tsc2200_driver = {
 227         .driver = {
 228             .name       = "tsc2200",
 229       .bus    = &platform_bus_type,
 230             .probe      = tsc2200_probe,
 231             .remove     = __exit_p(tsc2200_remove),
 232             .suspend    = tsc2200_suspend,
 233             .resume     = tsc2200_resume,
 234         }
 235 };
 236
 237 static int __init tsc2200_init(void)
 238 {
 239         return platform_driver_register(&tsc2200_driver);
 240 }
 241
 242 static void __exit tsc2200_exit(void)
 243 {
 244         platform_driver_unregister(&tsc2200_driver);
 245 }
 246
 247 module_init(tsc2200_init);
 248 module_exit(tsc2200_exit);
 249
 250 MODULE_LICENSE("GPL");