kernel/2.6.29.6-aldebaran-rt/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         /* XXX: I'm usure,  but it seems so */
  86         return ioread16(sdev->base + SCOOP_GPRR) & (1 << (offset + 1));
  87 }
  88
  89 static int scoop_gpio_direction_input(struct gpio_chip *chip,
  90                         unsigned offset)
  91 {
  92         struct scoop_dev *sdev = container_of(chip, struct scoop_dev, gpio);
  93         unsigned long flags;
  94         unsigned short gpcr;
  95
  96         spin_lock_irqsave(&sdev->scoop_lock, flags);
  97
  98         gpcr = ioread16(sdev->base + SCOOP_GPCR);
  99         gpcr &= ~(1 << (offset + 1));
 100         iowrite16(gpcr, sdev->base + SCOOP_GPCR);
 101
 102         spin_unlock_irqrestore(&sdev->scoop_lock, flags);
 103
 104         return 0;
 105 }
 106
 107 static int scoop_gpio_direction_output(struct gpio_chip *chip,
 108                         unsigned offset, int value)
 109 {
 110         struct scoop_dev *sdev = container_of(chip, struct scoop_dev, gpio);
 111         unsigned long flags;
 112         unsigned short gpcr;
 113
 114         spin_lock_irqsave(&sdev->scoop_lock, flags);
 115
 116         __scoop_gpio_set(sdev, offset, value);
 117
 118         gpcr = ioread16(sdev->base + SCOOP_GPCR);
 119         gpcr |= 1 << (offset + 1);
 120         iowrite16(gpcr, sdev->base + SCOOP_GPCR);
 121
 122         spin_unlock_irqrestore(&sdev->scoop_lock, flags);
 123
 124         return 0;
 125 }
 126
 127 unsigned short set_scoop_gpio(struct device *dev, unsigned short bit)
 128 {
 129         unsigned short gpio_bit;
 130         unsigned long flag;
 131         struct scoop_dev *sdev = dev_get_drvdata(dev);
 132
 133         spin_lock_irqsave(&sdev->scoop_lock, flag);
 134         gpio_bit = ioread16(sdev->base + SCOOP_GPWR) | bit;
 135         iowrite16(gpio_bit, sdev->base + SCOOP_GPWR);
 136         spin_unlock_irqrestore(&sdev->scoop_lock, flag);
 137
 138         return gpio_bit;
 139 }
 140
 141 unsigned short reset_scoop_gpio(struct device *dev, unsigned short bit)
 142 {
 143         unsigned short gpio_bit;
 144         unsigned long flag;
 145         struct scoop_dev *sdev = dev_get_drvdata(dev);
 146
 147         spin_lock_irqsave(&sdev->scoop_lock, flag);
 148         gpio_bit = ioread16(sdev->base + SCOOP_GPWR) & ~bit;
 149         iowrite16(gpio_bit, sdev->base + SCOOP_GPWR);
 150         spin_unlock_irqrestore(&sdev->scoop_lock, flag);
 151
 152         return gpio_bit;
 153 }
 154
 155 EXPORT_SYMBOL(set_scoop_gpio);
 156 EXPORT_SYMBOL(reset_scoop_gpio);
 157
 158 unsigned short read_scoop_reg(struct device *dev, unsigned short reg)
 159 {
 160         struct scoop_dev *sdev = dev_get_drvdata(dev);
 161         return ioread16(sdev->base + reg);
 162 }
 163
 164 void write_scoop_reg(struct device *dev, unsigned short reg, unsigned short data)
 165 {
 166         struct scoop_dev *sdev = dev_get_drvdata(dev);
 167         iowrite16(data, sdev->base + reg);
 168 }
 169
 170 EXPORT_SYMBOL(reset_scoop);
 171 EXPORT_SYMBOL(read_scoop_reg);
 172 EXPORT_SYMBOL(write_scoop_reg);
 173
 174 static void check_scoop_reg(struct scoop_dev *sdev)
 175 {
 176         unsigned short mcr;
 177
 178         mcr = ioread16(sdev->base + SCOOP_MCR);
 179         if ((mcr & 0x100) == 0)
 180                 iowrite16(0x0101, sdev->base + SCOOP_MCR);
 181 }
 182
 183 #ifdef CONFIG_PM
 184 static int scoop_suspend(struct platform_device *dev, pm_message_t state)
 185 {
 186         struct scoop_dev *sdev = platform_get_drvdata(dev);
 187
 188         check_scoop_reg(sdev);
 189         sdev->scoop_gpwr = ioread16(sdev->base + SCOOP_GPWR);
 190         iowrite16((sdev->scoop_gpwr & ~sdev->suspend_clr) | sdev->suspend_set, sdev->base + SCOOP_GPWR);
 191
 192         return 0;
 193 }
 194
 195 static int scoop_resume(struct platform_device *dev)
 196 {
 197         struct scoop_dev *sdev = platform_get_drvdata(dev);
 198
 199         check_scoop_reg(sdev);
 200         iowrite16(sdev->scoop_gpwr, sdev->base + SCOOP_GPWR);
 201
 202         return 0;
 203 }
 204 #else
 205 #define scoop_suspend   NULL
 206 #define scoop_resume    NULL
 207 #endif
 208
 209 static int __devinit scoop_probe(struct platform_device *pdev)
 210 {
 211         struct scoop_dev *devptr;
 212         struct scoop_config *inf;
 213         struct resource *mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 214         int ret;
 215         int temp;
 216
 217         if (!mem)
 218                 return -EINVAL;
 219
 220         devptr = kzalloc(sizeof(struct scoop_dev), GFP_KERNEL);
 221         if (!devptr)
 222                 return -ENOMEM;
 223
 224         spin_lock_init(&devptr->scoop_lock);
 225
 226         inf = pdev->dev.platform_data;
 227         devptr->base = ioremap(mem->start, mem->end - mem->start + 1);
 228
 229         if (!devptr->base) {
 230                 ret = -ENOMEM;
 231                 goto err_ioremap;
 232         }
 233
 234         platform_set_drvdata(pdev, devptr);
 235
 236         printk("Sharp Scoop Device found at 0x%08x -> 0x%8p\n",(unsigned int)mem->start, devptr->base);
 237
 238         iowrite16(0x0140, devptr->base + SCOOP_MCR);
 239         reset_scoop(&pdev->dev);
 240         iowrite16(0x0000, devptr->base + SCOOP_CPR);
 241         iowrite16(inf->io_dir & 0xffff, devptr->base + SCOOP_GPCR);
 242         iowrite16(inf->io_out & 0xffff, devptr->base + SCOOP_GPWR);
 243
 244         devptr->suspend_clr = inf->suspend_clr;
 245         devptr->suspend_set = inf->suspend_set;
 246
 247         devptr->gpio.base = -1;
 248
 249         if (inf->gpio_base != 0) {
 250                 devptr->gpio.label = dev_name(&pdev->dev);
 251                 devptr->gpio.base = inf->gpio_base;
 252                 devptr->gpio.ngpio = 12; /* PA11 = 0, PA12 = 1, etc. up to PA22 = 11 */
 253                 devptr->gpio.set = scoop_gpio_set;
 254                 devptr->gpio.get = scoop_gpio_get;
 255                 devptr->gpio.direction_input = scoop_gpio_direction_input;
 256                 devptr->gpio.direction_output = scoop_gpio_direction_output;
 257
 258                 ret = gpiochip_add(&devptr->gpio);
 259                 if (ret)
 260                         goto err_gpio;
 261         }
 262
 263         return 0;
 264
 265         if (devptr->gpio.base != -1)
 266                 temp = gpiochip_remove(&devptr->gpio);
 267 err_gpio:
 268         platform_set_drvdata(pdev, NULL);
 269 err_ioremap:
 270         iounmap(devptr->base);
 271         kfree(devptr);
 272
 273         return ret;
 274 }
 275
 276 static int __devexit scoop_remove(struct platform_device *pdev)
 277 {
 278         struct scoop_dev *sdev = platform_get_drvdata(pdev);
 279         int ret;
 280
 281         if (!sdev)
 282                 return -EINVAL;
 283
 284         if (sdev->gpio.base != -1) {
 285                 ret = gpiochip_remove(&sdev->gpio);
 286                 if (ret) {
 287                         dev_err(&pdev->dev, "Can't remove gpio chip: %d\n", ret);
 288                         return ret;
 289                 }
 290         }
 291
 292         platform_set_drvdata(pdev, NULL);
 293         iounmap(sdev->base);
 294         kfree(sdev);
 295
 296         return 0;
 297 }
 298
 299 static struct platform_driver scoop_driver = {
 300         .probe          = scoop_probe,
 301         .remove         = __devexit_p(scoop_remove),
 302         .suspend        = scoop_suspend,
 303         .resume         = scoop_resume,
 304         .driver         = {
 305                 .name   = "sharp-scoop",
 306         },
 307 };
 308
 309 static int __init scoop_init(void)
 310 {
 311         return platform_driver_register(&scoop_driver);
 312 }
 313
 314 subsys_initcall(scoop_init);