arch/arm/plat-nomadik/gpio.c

   1 /*
   2  * Generic GPIO driver for logic cells found in the Nomadik SoC
   3  *
   4  * Copyright (C) 2008,2009 STMicroelectronics
   5  * Copyright (C) 2009 Alessandro Rubini <rubini@unipv.it>
   6  *   Rewritten based on work by Prafulla WADASKAR <prafulla.wadaskar@st.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 #include <linux/kernel.h>
  13 #include <linux/module.h>
  14 #include <linux/init.h>
  15 #include <linux/device.h>
  16 #include <linux/platform_device.h>
  17 #include <linux/io.h>
  18 #include <linux/gpio.h>
  19 #include <linux/spinlock.h>
  20 #include <linux/interrupt.h>
  21 #include <linux/irq.h>
  22
  23 #include <mach/hardware.h>
  24 #include <mach/gpio.h>
  25
  26 /*
  27  * The GPIO module in the Nomadik family of Systems-on-Chip is an
  28  * AMBA device, managing 32 pins and alternate functions.  The logic block
  29  * is currently only used in the Nomadik.
  30  *
  31  * Symbols in this file are called "nmk_gpio" for "nomadik gpio"
  32  */
  33
  34 #define NMK_GPIO_PER_CHIP 32
  35 struct nmk_gpio_chip {
  36         struct gpio_chip chip;
  37         void __iomem *addr;
  38         unsigned int parent_irq;
  39         spinlock_t lock;
  40         /* Keep track of configured edges */
  41         u32 edge_rising;
  42         u32 edge_falling;
  43 };
  44
  45 /* Mode functions */
  46 int nmk_gpio_set_mode(int gpio, int gpio_mode)
  47 {
  48         struct nmk_gpio_chip *nmk_chip;
  49         unsigned long flags;
  50         u32 afunc, bfunc, bit;
  51
  52         nmk_chip = get_irq_chip_data(NOMADIK_GPIO_TO_IRQ(gpio));
  53         if (!nmk_chip)
  54                 return -EINVAL;
  55
  56         bit = 1 << (gpio - nmk_chip->chip.base);
  57
  58         spin_lock_irqsave(&nmk_chip->lock, flags);
  59         afunc = readl(nmk_chip->addr + NMK_GPIO_AFSLA) & ~bit;
  60         bfunc = readl(nmk_chip->addr + NMK_GPIO_AFSLB) & ~bit;
  61         if (gpio_mode & NMK_GPIO_ALT_A)
  62                 afunc |= bit;
  63         if (gpio_mode & NMK_GPIO_ALT_B)
  64                 bfunc |= bit;
  65         writel(afunc, nmk_chip->addr + NMK_GPIO_AFSLA);
  66         writel(bfunc, nmk_chip->addr + NMK_GPIO_AFSLB);
  67         spin_unlock_irqrestore(&nmk_chip->lock, flags);
  68
  69         return 0;
  70 }
  71 EXPORT_SYMBOL(nmk_gpio_set_mode);
  72
  73 int nmk_gpio_get_mode(int gpio)
  74 {
  75         struct nmk_gpio_chip *nmk_chip;
  76         u32 afunc, bfunc, bit;
  77
  78         nmk_chip = get_irq_chip_data(NOMADIK_GPIO_TO_IRQ(gpio));
  79         if (!nmk_chip)
  80                 return -EINVAL;
  81
  82         bit = 1 << (gpio - nmk_chip->chip.base);
  83
  84         afunc = readl(nmk_chip->addr + NMK_GPIO_AFSLA) & bit;
  85         bfunc = readl(nmk_chip->addr + NMK_GPIO_AFSLB) & bit;
  86
  87         return (afunc ? NMK_GPIO_ALT_A : 0) | (bfunc ? NMK_GPIO_ALT_B : 0);
  88 }
  89 EXPORT_SYMBOL(nmk_gpio_get_mode);
  90
  91
  92 /* IRQ functions */
  93 static inline int nmk_gpio_get_bitmask(int gpio)
  94 {
  95         return 1 << (gpio % 32);
  96 }
  97
  98 static void nmk_gpio_irq_ack(unsigned int irq)
  99 {
 100         int gpio;
 101         struct nmk_gpio_chip *nmk_chip;
 102
 103         gpio = NOMADIK_IRQ_TO_GPIO(irq);
 104         nmk_chip = get_irq_chip_data(irq);
 105         if (!nmk_chip)
 106                 return;
 107         writel(nmk_gpio_get_bitmask(gpio), nmk_chip->addr + NMK_GPIO_IC);
 108 }
 109
 110 static void nmk_gpio_irq_mask(unsigned int irq)
 111 {
 112         int gpio;
 113         struct nmk_gpio_chip *nmk_chip;
 114         unsigned long flags;
 115         u32 bitmask, reg;
 116
 117         gpio = NOMADIK_IRQ_TO_GPIO(irq);
 118         nmk_chip = get_irq_chip_data(irq);
 119         bitmask = nmk_gpio_get_bitmask(gpio);
 120         if (!nmk_chip)
 121                 return;
 122
 123         /* we must individually clear the two edges */
 124         spin_lock_irqsave(&nmk_chip->lock, flags);
 125         if (nmk_chip->edge_rising & bitmask) {
 126                 reg = readl(nmk_chip->addr + NMK_GPIO_RWIMSC);
 127                 reg &= ~bitmask;
 128                 writel(reg, nmk_chip->addr + NMK_GPIO_RWIMSC);
 129         }
 130         if (nmk_chip->edge_falling & bitmask) {
 131                 reg = readl(nmk_chip->addr + NMK_GPIO_FWIMSC);
 132                 reg &= ~bitmask;
 133                 writel(reg, nmk_chip->addr + NMK_GPIO_FWIMSC);
 134         }
 135         spin_unlock_irqrestore(&nmk_chip->lock, flags);
 136 };
 137
 138 static void nmk_gpio_irq_unmask(unsigned int irq)
 139 {
 140         int gpio;
 141         struct nmk_gpio_chip *nmk_chip;
 142         unsigned long flags;
 143         u32 bitmask, reg;
 144
 145         gpio = NOMADIK_IRQ_TO_GPIO(irq);
 146         nmk_chip = get_irq_chip_data(irq);
 147         bitmask = nmk_gpio_get_bitmask(gpio);
 148         if (!nmk_chip)
 149                 return;
 150
 151         /* we must individually set the two edges */
 152         spin_lock_irqsave(&nmk_chip->lock, flags);
 153         if (nmk_chip->edge_rising & bitmask) {
 154                 reg = readl(nmk_chip->addr + NMK_GPIO_RWIMSC);
 155                 reg |= bitmask;
 156                 writel(reg, nmk_chip->addr + NMK_GPIO_RWIMSC);
 157         }
 158         if (nmk_chip->edge_falling & bitmask) {
 159                 reg = readl(nmk_chip->addr + NMK_GPIO_FWIMSC);
 160                 reg |= bitmask;
 161                 writel(reg, nmk_chip->addr + NMK_GPIO_FWIMSC);
 162         }
 163         spin_unlock_irqrestore(&nmk_chip->lock, flags);
 164 }
 165
 166 static int nmk_gpio_irq_set_type(unsigned int irq, unsigned int type)
 167 {
 168         int gpio;
 169         struct nmk_gpio_chip *nmk_chip;
 170         unsigned long flags;
 171         u32 bitmask;
 172
 173         gpio = NOMADIK_IRQ_TO_GPIO(irq);
 174         nmk_chip = get_irq_chip_data(irq);
 175         bitmask = nmk_gpio_get_bitmask(gpio);
 176         if (!nmk_chip)
 177                 return -EINVAL;
 178
 179         if (type & IRQ_TYPE_LEVEL_HIGH)
 180                 return -EINVAL;
 181         if (type & IRQ_TYPE_LEVEL_LOW)
 182                 return -EINVAL;
 183
 184         spin_lock_irqsave(&nmk_chip->lock, flags);
 185
 186         nmk_chip->edge_rising &= ~bitmask;
 187         if (type & IRQ_TYPE_EDGE_RISING)
 188                 nmk_chip->edge_rising |= bitmask;
 189         writel(nmk_chip->edge_rising, nmk_chip->addr + NMK_GPIO_RIMSC);
 190
 191         nmk_chip->edge_falling &= ~bitmask;
 192         if (type & IRQ_TYPE_EDGE_FALLING)
 193                 nmk_chip->edge_falling |= bitmask;
 194         writel(nmk_chip->edge_falling, nmk_chip->addr + NMK_GPIO_FIMSC);
 195
 196         spin_unlock_irqrestore(&nmk_chip->lock, flags);
 197
 198         nmk_gpio_irq_unmask(irq);
 199
 200         return 0;
 201 }
 202
 203 static struct irq_chip nmk_gpio_irq_chip = {
 204         .name           = "Nomadik-GPIO",
 205         .ack            = nmk_gpio_irq_ack,
 206         .mask           = nmk_gpio_irq_mask,
 207         .unmask         = nmk_gpio_irq_unmask,
 208         .set_type       = nmk_gpio_irq_set_type,
 209 };
 210
 211 static void nmk_gpio_irq_handler(unsigned int irq, struct irq_desc *desc)
 212 {
 213         struct nmk_gpio_chip *nmk_chip;
 214         struct irq_chip *host_chip = get_irq_chip(irq);
 215         unsigned int gpio_irq;
 216         u32 pending;
 217         unsigned int first_irq;
 218
 219         if (host_chip->mask_ack)
 220                 host_chip->mask_ack(irq);
 221         else {
 222                 host_chip->mask(irq);
 223                 if (host_chip->ack)
 224                         host_chip->ack(irq);
 225         }
 226
 227         nmk_chip = get_irq_data(irq);
 228         first_irq = NOMADIK_GPIO_TO_IRQ(nmk_chip->chip.base);
 229         while ( (pending = readl(nmk_chip->addr + NMK_GPIO_IS)) ) {
 230                 gpio_irq = first_irq + __ffs(pending);
 231                 generic_handle_irq(gpio_irq);
 232         }
 233
 234         host_chip->unmask(irq);
 235 }
 236
 237 static int nmk_gpio_init_irq(struct nmk_gpio_chip *nmk_chip)
 238 {
 239         unsigned int first_irq;
 240         int i;
 241
 242         first_irq = NOMADIK_GPIO_TO_IRQ(nmk_chip->chip.base);
 243         for (i = first_irq; i < first_irq + NMK_GPIO_PER_CHIP; i++) {
 244                 set_irq_chip(i, &nmk_gpio_irq_chip);
 245                 set_irq_handler(i, handle_edge_irq);
 246                 set_irq_flags(i, IRQF_VALID);
 247                 set_irq_chip_data(i, nmk_chip);
 248         }
 249         set_irq_chained_handler(nmk_chip->parent_irq, nmk_gpio_irq_handler);
 250         set_irq_data(nmk_chip->parent_irq, nmk_chip);
 251         return 0;
 252 }
 253
 254 /* I/O Functions */
 255 static int nmk_gpio_make_input(struct gpio_chip *chip, unsigned offset)
 256 {
 257         struct nmk_gpio_chip *nmk_chip =
 258                 container_of(chip, struct nmk_gpio_chip, chip);
 259
 260         writel(1 << offset, nmk_chip->addr + NMK_GPIO_DIRC);
 261         return 0;
 262 }
 263
 264 static int nmk_gpio_make_output(struct gpio_chip *chip, unsigned offset,
 265                                 int val)
 266 {
 267         struct nmk_gpio_chip *nmk_chip =
 268                 container_of(chip, struct nmk_gpio_chip, chip);
 269
 270         writel(1 << offset, nmk_chip->addr + NMK_GPIO_DIRS);
 271         return 0;
 272 }
 273
 274 static int nmk_gpio_get_input(struct gpio_chip *chip, unsigned offset)
 275 {
 276         struct nmk_gpio_chip *nmk_chip =
 277                 container_of(chip, struct nmk_gpio_chip, chip);
 278         u32 bit = 1 << offset;
 279
 280         return (readl(nmk_chip->addr + NMK_GPIO_DAT) & bit) != 0;
 281 }
 282
 283 static void nmk_gpio_set_output(struct gpio_chip *chip, unsigned offset,
 284                                 int val)
 285 {
 286         struct nmk_gpio_chip *nmk_chip =
 287                 container_of(chip, struct nmk_gpio_chip, chip);
 288         u32 bit = 1 << offset;
 289
 290         if (val)
 291                 writel(bit, nmk_chip->addr + NMK_GPIO_DATS);
 292         else
 293                 writel(bit, nmk_chip->addr + NMK_GPIO_DATC);
 294 }
 295
 296 /* This structure is replicated for each GPIO block allocated at probe time */
 297 static struct gpio_chip nmk_gpio_template = {
 298         .direction_input        = nmk_gpio_make_input,
 299         .get                    = nmk_gpio_get_input,
 300         .direction_output       = nmk_gpio_make_output,
 301         .set                    = nmk_gpio_set_output,
 302         .ngpio                  = NMK_GPIO_PER_CHIP,
 303         .can_sleep              = 0,
 304 };
 305
 306 static int __init nmk_gpio_probe(struct platform_device *dev)
 307 {
 308         struct nmk_gpio_platform_data *pdata = dev->dev.platform_data;
 309         struct nmk_gpio_chip *nmk_chip;
 310         struct gpio_chip *chip;
 311         struct resource *res;
 312         int irq;
 313         int ret;
 314
 315         if (!pdata)
 316                 return -ENODEV;
 317
 318         res = platform_get_resource(dev, IORESOURCE_MEM, 0);
 319         if (!res) {
 320                 ret = -ENOENT;
 321                 goto out;
 322         }
 323
 324         irq = platform_get_irq(dev, 0);
 325         if (irq < 0) {
 326                 ret = irq;
 327                 goto out;
 328         }
 329
 330         if (request_mem_region(res->start, resource_size(res),
 331                                dev_name(&dev->dev)) == NULL) {
 332                 ret = -EBUSY;
 333                 goto out;
 334         }
 335
 336         nmk_chip = kzalloc(sizeof(*nmk_chip), GFP_KERNEL);
 337         if (!nmk_chip) {
 338                 ret = -ENOMEM;
 339                 goto out_release;
 340         }
 341         /*
 342          * The virt address in nmk_chip->addr is in the nomadik register space,
 343          * so we can simply convert the resource address, without remapping
 344          */
 345         nmk_chip->addr = io_p2v(res->start);
 346         nmk_chip->chip = nmk_gpio_template;
 347         nmk_chip->parent_irq = irq;
 348         spin_lock_init(&nmk_chip->lock);
 349
 350         chip = &nmk_chip->chip;
 351         chip->base = pdata->first_gpio;
 352         chip->label = pdata->name;
 353         chip->dev = &dev->dev;
 354         chip->owner = THIS_MODULE;
 355
 356         ret = gpiochip_add(&nmk_chip->chip);
 357         if (ret)
 358                 goto out_free;
 359
 360         platform_set_drvdata(dev, nmk_chip);
 361
 362         nmk_gpio_init_irq(nmk_chip);
 363
 364         dev_info(&dev->dev, "Bits %i-%i at address %p\n",
 365                  nmk_chip->chip.base, nmk_chip->chip.base+31, nmk_chip->addr);
 366         return 0;
 367
 368 out_free:
 369         kfree(nmk_chip);
 370 out_release:
 371         release_mem_region(res->start, resource_size(res));
 372 out:
 373         dev_err(&dev->dev, "Failure %i for GPIO %i-%i\n", ret,
 374                   pdata->first_gpio, pdata->first_gpio+31);
 375         return ret;
 376 }
 377
 378 static int __exit nmk_gpio_remove(struct platform_device *dev)
 379 {
 380         struct nmk_gpio_chip *nmk_chip;
 381         struct resource *res;
 382
 383         res = platform_get_resource(dev, IORESOURCE_MEM, 0);
 384
 385         nmk_chip = platform_get_drvdata(dev);
 386         gpiochip_remove(&nmk_chip->chip);
 387         kfree(nmk_chip);
 388         release_mem_region(res->start, resource_size(res));
 389         return 0;
 390 }
 391
 392
 393 static struct platform_driver nmk_gpio_driver = {
 394         .driver = {
 395                 .owner = THIS_MODULE,
 396                 .name = "gpio",
 397                 },
 398         .probe = nmk_gpio_probe,
 399         .remove = __exit_p(nmk_gpio_remove),
 400         .suspend = NULL, /* to be done */
 401         .resume = NULL,
 402 };
 403
 404 static int __init nmk_gpio_init(void)
 405 {
 406         return platform_driver_register(&nmk_gpio_driver);
 407 }
 408
 409 arch_initcall(nmk_gpio_init);
 410
 411 MODULE_AUTHOR("Prafulla WADASKAR and Alessandro Rubini");
 412 MODULE_DESCRIPTION("Nomadik GPIO Driver");
 413 MODULE_LICENSE("GPL");
 414
 415