release/src-rt-6.x.4708/linux/linux-2.6.36/arch/arm/common/scoop.c

   1 /*
   2  * Support code for the SCOOP interface found on various Sharp PDAs
   3  *
   4  * Copyright (c) 2004 Richard Purdie
   5  *
   6  *      Based on code written by Sharp/Lineo for 2.4 kernels
   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/device.h>
  15 #include <linux/string.h>
  16 #include <linux/slab.h>
  17 #include <linux/platform_device.h>
  18 #include <linux/io.h>
  19 #include <asm/gpio.h>
  20 #include <asm/hardware/scoop.h>
  21
  22 /* PCMCIA to Scoop linkage
  23
  24    There is no easy way to link multiple scoop devices into one
  25    single entity for the pxa2xx_pcmcia device so this structure
  26    is used which is setup by the platform code.
  27
  28    This file is never modular so this symbol is always
  29    accessile to the board support files.
  30 */
  31 struct scoop_pcmcia_config *platform_scoop_config;
  32 EXPORT_SYMBOL(platform_scoop_config);
  33
  34 struct  scoop_dev {
  35         void __iomem *base;
  36         struct gpio_chip gpio;
  37         spinlock_t scoop_lock;
  38         unsigned short suspend_clr;
  39         unsigned short suspend_set;
  40         u32 scoop_gpwr;
  41 };
  42
  43 void reset_scoop(struct device *dev)
  44 {
  45         struct scoop_dev *sdev = dev_get_drvdata(dev);
  46
  47         iowrite16(0x0100, sdev->base + SCOOP_MCR);  // 00
  48         iowrite16(0x0000, sdev->base + SCOOP_CDR);  // 04
  49         iowrite16(0x0000, sdev->base + SCOOP_CCR);  // 10
  50         iowrite16(0x0000, sdev->base + SCOOP_IMR);  // 18
  51         iowrite16(0x00FF, sdev->base + SCOOP_IRM);  // 14
  52         iowrite16(0x0000, sdev->base + SCOOP_ISR);  // 1C
  53         iowrite16(0x0000, sdev->base + SCOOP_IRM);
  54 }
  55
  56 static void __scoop_gpio_set(struct scoop_dev *sdev,
  57                         unsigned offset, int value)
  58 {
  59         unsigned short gpwr;
  60
  61         gpwr = ioread16(sdev->base + SCOOP_GPWR);
  62         if (value)
  63                 gpwr |= 1 << (offset + 1);
  64         else
  65                 gpwr &= ~(1 << (offset + 1));
  66         iowrite16(gpwr, sdev->base + SCOOP_GPWR);
  67 }
  68
  69 static void scoop_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
  70 {
  71         struct scoop_dev *sdev = container_of(chip, struct scoop_dev, gpio);
  72         unsigned long flags;
  73
  74         spin_lock_irqsave(&sdev->scoop_lock, flags);
  75
  76         __scoop_gpio_set(sdev, offset, value);
  77
  78         spin_unlock_irqrestore(&sdev->scoop_lock, flags);
  79 }
  80
  81 static int scoop_gpio_get(struct gpio_chip *chip, unsigned offset)
  82 {
  83         struct scoop_dev *sdev = container_of(chip, struct scoop_dev, gpio);
  84
  85         return ioread16(sdev->base + SCOOP_GPRR) & (1 << (offset + 1));
  86 }
  87
  88 static int scoop_gpio_direction_input(struct gpio_chip *chip,
  89                         unsigned offset)
  90 {
  91         struct scoop_dev *sdev = container_of(chip, struct scoop_dev, gpio);
  92         unsigned long flags;
  93         unsigned short gpcr;
  94
  95         spin_lock_irqsave(&sdev->scoop_lock, flags);
  96
  97         gpcr = ioread16(sdev->base + SCOOP_GPCR);
  98         gpcr &= ~(1 << (offset + 1));
  99         iowrite16(gpcr, sdev->base + SCOOP_GPCR);
 100
 101         spin_unlock_irqrestore(&sdev->scoop_lock, flags);
 102
 103         return 0;
 104 }
 105
 106 static int scoop_gpio_direction_output(struct gpio_chip *chip,
 107                         unsigned offset, int value)
 108 {
 109         struct scoop_dev *sdev = container_of(chip, struct scoop_dev, gpio);
 110         unsigned long flags;
 111         unsigned short gpcr;
 112
 113         spin_lock_irqsave(&sdev->scoop_lock, flags);
 114
 115         __scoop_gpio_set(sdev, offset, value);
 116
 117         gpcr = ioread16(sdev->base + SCOOP_GPCR);
 118         gpcr |= 1 << (offset + 1);
 119         iowrite16(gpcr, sdev->base + SCOOP_GPCR);
 120
 121         spin_unlock_irqrestore(&sdev->scoop_lock, flags);
 122
 123         return 0;
 124 }
 125
 126 unsigned short read_scoop_reg(struct device *dev, unsigned short reg)
 127 {
 128         struct scoop_dev *sdev = dev_get_drvdata(dev);
 129         return ioread16(sdev->base + reg);
 130 }
 131
 132 void write_scoop_reg(struct device *dev, unsigned short reg, unsigned short data)
 133 {
 134         struct scoop_dev *sdev = dev_get_drvdata(dev);
 135         iowrite16(data, sdev->base + reg);
 136 }
 137
 138 EXPORT_SYMBOL(reset_scoop);
 139 EXPORT_SYMBOL(read_scoop_reg);
 140 EXPORT_SYMBOL(write_scoop_reg);
 141
 142 #ifdef CONFIG_PM
 143 static void check_scoop_reg(struct scoop_dev *sdev)
 144 {
 145         unsigned short mcr;
 146
 147         mcr = ioread16(sdev->base + SCOOP_MCR);
 148         if ((mcr & 0x100) == 0)
 149                 iowrite16(0x0101, sdev->base + SCOOP_MCR);
 150 }
 151
 152 static int scoop_suspend(struct platform_device *dev, pm_message_t state)
 153 {
 154         struct scoop_dev *sdev = platform_get_drvdata(dev);
 155
 156         check_scoop_reg(sdev);
 157         sdev->scoop_gpwr = ioread16(sdev->base + SCOOP_GPWR);
 158         iowrite16((sdev->scoop_gpwr & ~sdev->suspend_clr) | sdev->suspend_set, sdev->base + SCOOP_GPWR);
 159
 160         return 0;
 161 }
 162
 163 static int scoop_resume(struct platform_device *dev)
 164 {
 165         struct scoop_dev *sdev = platform_get_drvdata(dev);
 166
 167         check_scoop_reg(sdev);
 168         iowrite16(sdev->scoop_gpwr, sdev->base + SCOOP_GPWR);
 169
 170         return 0;
 171 }
 172 #else
 173 #define scoop_suspend   NULL
 174 #define scoop_resume    NULL
 175 #endif
 176
 177 static int __devinit scoop_probe(struct platform_device *pdev)
 178 {
 179         struct scoop_dev *devptr;
 180         struct scoop_config *inf;
 181         struct resource *mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 182         int ret;
 183         int temp;
 184
 185         if (!mem)
 186                 return -EINVAL;
 187
 188         devptr = kzalloc(sizeof(struct scoop_dev), GFP_KERNEL);
 189         if (!devptr)
 190                 return -ENOMEM;
 191
 192         spin_lock_init(&devptr->scoop_lock);
 193
 194         inf = pdev->dev.platform_data;
 195         devptr->base = ioremap(mem->start, mem->end - mem->start + 1);
 196
 197         if (!devptr->base) {
 198                 ret = -ENOMEM;
 199                 goto err_ioremap;
 200         }
 201
 202         platform_set_drvdata(pdev, devptr);
 203
 204         printk("Sharp Scoop Device found at 0x%08x -> 0x%8p\n",(unsigned int)mem->start, devptr->base);
 205
 206         iowrite16(0x0140, devptr->base + SCOOP_MCR);
 207         reset_scoop(&pdev->dev);
 208         iowrite16(0x0000, devptr->base + SCOOP_CPR);
 209         iowrite16(inf->io_dir & 0xffff, devptr->base + SCOOP_GPCR);
 210         iowrite16(inf->io_out & 0xffff, devptr->base + SCOOP_GPWR);
 211
 212         devptr->suspend_clr = inf->suspend_clr;
 213         devptr->suspend_set = inf->suspend_set;
 214
 215         devptr->gpio.base = -1;
 216
 217         if (inf->gpio_base != 0) {
 218                 devptr->gpio.label = dev_name(&pdev->dev);
 219                 devptr->gpio.base = inf->gpio_base;
 220                 devptr->gpio.ngpio = 12; /* PA11 = 0, PA12 = 1, etc. up to PA22 = 11 */
 221                 devptr->gpio.set = scoop_gpio_set;
 222                 devptr->gpio.get = scoop_gpio_get;
 223                 devptr->gpio.direction_input = scoop_gpio_direction_input;
 224                 devptr->gpio.direction_output = scoop_gpio_direction_output;
 225
 226                 ret = gpiochip_add(&devptr->gpio);
 227                 if (ret)
 228                         goto err_gpio;
 229         }
 230
 231         return 0;
 232
 233         if (devptr->gpio.base != -1)
 234                 temp = gpiochip_remove(&devptr->gpio);
 235 err_gpio:
 236         platform_set_drvdata(pdev, NULL);
 237 err_ioremap:
 238         iounmap(devptr->base);
 239         kfree(devptr);
 240
 241         return ret;
 242 }
 243
 244 static int __devexit scoop_remove(struct platform_device *pdev)
 245 {
 246         struct scoop_dev *sdev = platform_get_drvdata(pdev);
 247         int ret;
 248
 249         if (!sdev)
 250                 return -EINVAL;
 251
 252         if (sdev->gpio.base != -1) {
 253                 ret = gpiochip_remove(&sdev->gpio);
 254                 if (ret) {
 255                         dev_err(&pdev->dev, "Can't remove gpio chip: %d\n", ret);
 256                         return ret;
 257                 }
 258         }
 259
 260         platform_set_drvdata(pdev, NULL);
 261         iounmap(sdev->base);
 262         kfree(sdev);
 263
 264         return 0;
 265 }
 266
 267 static struct platform_driver scoop_driver = {
 268         .probe          = scoop_probe,
 269         .remove         = __devexit_p(scoop_remove),
 270         .suspend        = scoop_suspend,
 271         .resume         = scoop_resume,
 272         .driver         = {
 273                 .name   = "sharp-scoop",
 274         },
 275 };
 276
 277 static int __init scoop_init(void)
 278 {
 279         return platform_driver_register(&scoop_driver);
 280 }
 281
 282 subsys_initcall(scoop_init);