git.oblomov.eu Git - linux-2.6/blob - arch/arm/mach-pxa/corgi_ssp.c

   1 /*
   2  *  SSP control code for Sharp Corgi devices
   3  *
   4  *  Copyright (c) 2004 Richard Purdie
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License version 2 as
   8  *  published by the Free Software Foundation.
   9  *
  10  */
  11
  12 #include <linux/module.h>
  13 #include <linux/init.h>
  14 #include <linux/kernel.h>
  15 #include <linux/sched.h>
  16 #include <linux/slab.h>
  17 #include <linux/delay.h>
  18 #include <linux/device.h>
  19 #include <asm/hardware.h>
  20
  21 #include <asm/arch/ssp.h>
  22 #include <asm/arch/corgi.h>
  23 #include <asm/arch/pxa-regs.h>
  24
  25 static DEFINE_SPINLOCK(corgi_ssp_lock);
  26 static struct ssp_dev corgi_ssp_dev;
  27 static struct ssp_state corgi_ssp_state;
  28
  29 /*
  30  * There are three devices connected to the SSP interface:
  31  *   1. A touchscreen controller (TI ADS7846 compatible)
  32  *   2. An LCD contoller (with some Backlight functionality)
  33  *   3. A battery moinitoring IC (Maxim MAX1111)
  34  *
  35  * Each device uses a different speed/mode of communication.
  36  *
  37  * The touchscreen is very sensitive and the most frequently used
  38  * so the port is left configured for this.
  39  *
  40  * Devices are selected using Chip Selects on GPIOs.
  41  */
  42
  43 /*
  44  *  ADS7846 Routines
  45  */
  46 unsigned long corgi_ssp_ads7846_putget(ulong data)
  47 {
  48         unsigned long ret,flag;
  49
  50         spin_lock_irqsave(&corgi_ssp_lock, flag);
  51         GPCR0 = GPIO_bit(CORGI_GPIO_ADS7846_CS);
  52
  53         ssp_write_word(&corgi_ssp_dev,data);
  54         ret = ssp_read_word(&corgi_ssp_dev);
  55
  56         GPSR0 = GPIO_bit(CORGI_GPIO_ADS7846_CS);
  57         spin_unlock_irqrestore(&corgi_ssp_lock, flag);
  58
  59         return ret;
  60 }
  61
  62 /*
  63  * NOTE: These functions should always be called in interrupt context
  64  * and use the _lock and _unlock functions. They are very time sensitive.
  65  */
  66 void corgi_ssp_ads7846_lock(void)
  67 {
  68         spin_lock(&corgi_ssp_lock);
  69         GPCR0 = GPIO_bit(CORGI_GPIO_ADS7846_CS);
  70 }
  71
  72 void corgi_ssp_ads7846_unlock(void)
  73 {
  74         GPSR0 = GPIO_bit(CORGI_GPIO_ADS7846_CS);
  75         spin_unlock(&corgi_ssp_lock);
  76 }
  77
  78 void corgi_ssp_ads7846_put(ulong data)
  79 {
  80         ssp_write_word(&corgi_ssp_dev,data);
  81 }
  82
  83 unsigned long corgi_ssp_ads7846_get(void)
  84 {
  85         return ssp_read_word(&corgi_ssp_dev);
  86 }
  87
  88 EXPORT_SYMBOL(corgi_ssp_ads7846_putget);
  89 EXPORT_SYMBOL(corgi_ssp_ads7846_lock);
  90 EXPORT_SYMBOL(corgi_ssp_ads7846_unlock);
  91 EXPORT_SYMBOL(corgi_ssp_ads7846_put);
  92 EXPORT_SYMBOL(corgi_ssp_ads7846_get);
  93
  94
  95 /*
  96  *  LCD/Backlight Routines
  97  */
  98 unsigned long corgi_ssp_dac_put(ulong data)
  99 {
 100         unsigned long flag;
 101
 102         spin_lock_irqsave(&corgi_ssp_lock, flag);
 103         GPCR0 = GPIO_bit(CORGI_GPIO_LCDCON_CS);
 104
 105         ssp_disable(&corgi_ssp_dev);
 106         ssp_config(&corgi_ssp_dev, (SSCR0_Motorola | (SSCR0_DSS & 0x07 )), SSCR1_SPH, 0, SSCR0_SerClkDiv(76));
 107         ssp_enable(&corgi_ssp_dev);
 108
 109         ssp_write_word(&corgi_ssp_dev,data);
 110         /* Read null data back from device to prevent SSP overflow */
 111         ssp_read_word(&corgi_ssp_dev);
 112
 113         ssp_disable(&corgi_ssp_dev);
 114         ssp_config(&corgi_ssp_dev, (SSCR0_National | (SSCR0_DSS & 0x0b )), 0, 0, SSCR0_SerClkDiv(2));
 115         ssp_enable(&corgi_ssp_dev);
 116         GPSR0 = GPIO_bit(CORGI_GPIO_LCDCON_CS);
 117         spin_unlock_irqrestore(&corgi_ssp_lock, flag);
 118
 119         return 0;
 120 }
 121
 122 void corgi_ssp_lcdtg_send(u8 adrs, u8 data)
 123 {
 124         corgi_ssp_dac_put(((adrs & 0x07) << 5) | (data & 0x1f));
 125 }
 126
 127 void corgi_ssp_blduty_set(int duty)
 128 {
 129         corgi_ssp_lcdtg_send(0x02,duty);
 130 }
 131
 132 EXPORT_SYMBOL(corgi_ssp_lcdtg_send);
 133 EXPORT_SYMBOL(corgi_ssp_blduty_set);
 134
 135 /*
 136  *  Max1111 Routines
 137  */
 138 int corgi_ssp_max1111_get(ulong data)
 139 {
 140         unsigned long flag;
 141         int voltage,voltage1,voltage2;
 142
 143         spin_lock_irqsave(&corgi_ssp_lock, flag);
 144         GPCR0 = GPIO_bit(CORGI_GPIO_MAX1111_CS);
 145         ssp_disable(&corgi_ssp_dev);
 146         ssp_config(&corgi_ssp_dev, (SSCR0_Motorola | (SSCR0_DSS & 0x07 )), 0, 0, SSCR0_SerClkDiv(8));
 147         ssp_enable(&corgi_ssp_dev);
 148
 149         udelay(1);
 150
 151         /* TB1/RB1 */
 152         ssp_write_word(&corgi_ssp_dev,data);
 153         ssp_read_word(&corgi_ssp_dev); /* null read */
 154
 155         /* TB12/RB2 */
 156         ssp_write_word(&corgi_ssp_dev,0);
 157         voltage1=ssp_read_word(&corgi_ssp_dev);
 158
 159         /* TB13/RB3*/
 160         ssp_write_word(&corgi_ssp_dev,0);
 161         voltage2=ssp_read_word(&corgi_ssp_dev);
 162
 163         ssp_disable(&corgi_ssp_dev);
 164         ssp_config(&corgi_ssp_dev, (SSCR0_National | (SSCR0_DSS & 0x0b )), 0, 0, SSCR0_SerClkDiv(2));
 165         ssp_enable(&corgi_ssp_dev);
 166         GPSR0 = GPIO_bit(CORGI_GPIO_MAX1111_CS);
 167         spin_unlock_irqrestore(&corgi_ssp_lock, flag);
 168
 169         if (voltage1 & 0xc0 || voltage2 & 0x3f)
 170                 voltage = -1;
 171         else
 172                 voltage = ((voltage1 << 2) & 0xfc) | ((voltage2 >> 6) & 0x03);
 173
 174         return voltage;
 175 }
 176
 177 EXPORT_SYMBOL(corgi_ssp_max1111_get);
 178
 179 /*
 180  *  Support Routines
 181  */
 182 int __init corgi_ssp_probe(struct device *dev)
 183 {
 184         int ret;
 185
 186         /* Chip Select - Disable All */
 187         GPDR0 |= GPIO_bit(CORGI_GPIO_LCDCON_CS); /* output */
 188         GPSR0 = GPIO_bit(CORGI_GPIO_LCDCON_CS);  /* High - Disable LCD Control/Timing Gen */
 189         GPDR0 |= GPIO_bit(CORGI_GPIO_MAX1111_CS); /* output */
 190         GPSR0 = GPIO_bit(CORGI_GPIO_MAX1111_CS);  /* High - Disable MAX1111*/
 191         GPDR0 |= GPIO_bit(CORGI_GPIO_ADS7846_CS);  /* output */
 192         GPSR0 = GPIO_bit(CORGI_GPIO_ADS7846_CS);   /* High - Disable ADS7846*/
 193
 194         ret=ssp_init(&corgi_ssp_dev,1);
 195
 196         if (ret)
 197                 printk(KERN_ERR "Unable to register SSP handler!\n");
 198         else {
 199                 ssp_disable(&corgi_ssp_dev);
 200                 ssp_config(&corgi_ssp_dev, (SSCR0_National | (SSCR0_DSS & 0x0b )), 0, 0, SSCR0_SerClkDiv(2));
 201                 ssp_enable(&corgi_ssp_dev);
 202         }
 203
 204         return ret;
 205 }
 206
 207 static int corgi_ssp_remove(struct device *dev)
 208 {
 209         ssp_exit(&corgi_ssp_dev);
 210         return 0;
 211 }
 212
 213 static int corgi_ssp_suspend(struct device *dev, pm_message_t state, u32 level)
 214 {
 215         if (level == SUSPEND_POWER_DOWN) {
 216                 ssp_flush(&corgi_ssp_dev);
 217                 ssp_save_state(&corgi_ssp_dev,&corgi_ssp_state);
 218         }
 219         return 0;
 220 }
 221
 222 static int corgi_ssp_resume(struct device *dev, u32 level)
 223 {
 224         if (level == RESUME_POWER_ON) {
 225                 GPSR0 = GPIO_bit(CORGI_GPIO_LCDCON_CS);  /* High - Disable LCD Control/Timing Gen */
 226                 GPSR0 = GPIO_bit(CORGI_GPIO_MAX1111_CS); /* High - Disable MAX1111*/
 227                 GPSR0 = GPIO_bit(CORGI_GPIO_ADS7846_CS); /* High - Disable ADS7846*/
 228                 ssp_restore_state(&corgi_ssp_dev,&corgi_ssp_state);
 229                 ssp_enable(&corgi_ssp_dev);
 230         }
 231         return 0;
 232 }
 233
 234 static struct device_driver corgissp_driver = {
 235         .name           = "corgi-ssp",
 236         .bus            = &platform_bus_type,
 237         .probe          = corgi_ssp_probe,
 238         .remove         = corgi_ssp_remove,
 239         .suspend        = corgi_ssp_suspend,
 240         .resume         = corgi_ssp_resume,
 241 };
 242
 243 int __init corgi_ssp_init(void)
 244 {
 245         return driver_register(&corgissp_driver);
 246 }
 247
 248 arch_initcall(corgi_ssp_init);