arch/arm/mach-davinci/gpio.c

   1 /*
   2  * TI DaVinci GPIO Support
   3  *
   4  * Copyright (c) 2006-2007 David Brownell
   5  * Copyright (c) 2007, MontaVista Software, Inc. <source@mvista.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  */
  12
  13 #include <linux/errno.h>
  14 #include <linux/kernel.h>
  15 #include <linux/clk.h>
  16 #include <linux/err.h>
  17 #include <linux/io.h>
  18
  19 #include <mach/gpio.h>
  20
  21 #include <asm/mach/irq.h>
  22
  23 static DEFINE_SPINLOCK(gpio_lock);
  24
  25 #define chip2controller(chip)   \
  26         container_of(chip, struct davinci_gpio_controller, chip)
  27
  28 static struct davinci_gpio_controller chips[DIV_ROUND_UP(DAVINCI_N_GPIO, 32)];
  29
  30 /* create a non-inlined version */
  31 static struct davinci_gpio_regs __iomem __init *gpio2regs(unsigned gpio)
  32 {
  33         return __gpio_to_controller(gpio);
  34 }
  35
  36 static inline struct davinci_gpio_regs __iomem *irq2regs(int irq)
  37 {
  38         struct davinci_gpio_regs __iomem *g;
  39
  40         g = (__force struct davinci_gpio_regs __iomem *)get_irq_chip_data(irq);
  41
  42         return g;
  43 }
  44
  45 static int __init davinci_gpio_irq_setup(void);
  46
  47 /*--------------------------------------------------------------------------*/
  48
  49 /*
  50  * board setup code *MUST* set PINMUX0 and PINMUX1 as
  51  * needed, and enable the GPIO clock.
  52  */
  53
  54 static inline int __davinci_direction(struct gpio_chip *chip,
  55                         unsigned offset, bool out, int value)
  56 {
  57         struct davinci_gpio_controller *d = chip2controller(chip);
  58         struct davinci_gpio_regs __iomem *g = d->regs;
  59         u32 temp;
  60         u32 mask = 1 << offset;
  61
  62         spin_lock(&gpio_lock);
  63         temp = __raw_readl(&g->dir);
  64         if (out) {
  65                 temp &= ~mask;
  66                 __raw_writel(mask, value ? &g->set_data : &g->clr_data);
  67         } else {
  68                 temp |= mask;
  69         }
  70         __raw_writel(temp, &g->dir);
  71         spin_unlock(&gpio_lock);
  72
  73         return 0;
  74 }
  75
  76 static int davinci_direction_in(struct gpio_chip *chip, unsigned offset)
  77 {
  78         return __davinci_direction(chip, offset, false, 0);
  79 }
  80
  81 static int
  82 davinci_direction_out(struct gpio_chip *chip, unsigned offset, int value)
  83 {
  84         return __davinci_direction(chip, offset, true, value);
  85 }
  86
  87 /*
  88  * Read the pin's value (works even if it's set up as output);
  89  * returns zero/nonzero.
  90  *
  91  * Note that changes are synched to the GPIO clock, so reading values back
  92  * right after you've set them may give old values.
  93  */
  94 static int davinci_gpio_get(struct gpio_chip *chip, unsigned offset)
  95 {
  96         struct davinci_gpio_controller *d = chip2controller(chip);
  97         struct davinci_gpio_regs __iomem *g = d->regs;
  98
  99         return (1 << offset) & __raw_readl(&g->in_data);
 100 }
 101
 102 /*
 103  * Assuming the pin is muxed as a gpio output, set its output value.
 104  */
 105 static void
 106 davinci_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 107 {
 108         struct davinci_gpio_controller *d = chip2controller(chip);
 109         struct davinci_gpio_regs __iomem *g = d->regs;
 110
 111         __raw_writel((1 << offset), value ? &g->set_data : &g->clr_data);
 112 }
 113
 114 static int __init davinci_gpio_setup(void)
 115 {
 116         int i, base;
 117         unsigned ngpio;
 118         struct davinci_soc_info *soc_info = &davinci_soc_info;
 119
 120         /*
 121          * The gpio banks conceptually expose a segmented bitmap,
 122          * and "ngpio" is one more than the largest zero-based
 123          * bit index that's valid.
 124          */
 125         ngpio = soc_info->gpio_num;
 126         if (ngpio == 0) {
 127                 pr_err("GPIO setup:  how many GPIOs?\n");
 128                 return -EINVAL;
 129         }
 130
 131         if (WARN_ON(DAVINCI_N_GPIO < ngpio))
 132                 ngpio = DAVINCI_N_GPIO;
 133
 134         for (i = 0, base = 0; base < ngpio; i++, base += 32) {
 135                 chips[i].chip.label = "DaVinci";
 136
 137                 chips[i].chip.direction_input = davinci_direction_in;
 138                 chips[i].chip.get = davinci_gpio_get;
 139                 chips[i].chip.direction_output = davinci_direction_out;
 140                 chips[i].chip.set = davinci_gpio_set;
 141
 142                 chips[i].chip.base = base;
 143                 chips[i].chip.ngpio = ngpio - base;
 144                 if (chips[i].chip.ngpio > 32)
 145                         chips[i].chip.ngpio = 32;
 146
 147                 chips[i].regs = gpio2regs(base);
 148
 149                 gpiochip_add(&chips[i].chip);
 150         }
 151
 152         davinci_gpio_irq_setup();
 153         return 0;
 154 }
 155 pure_initcall(davinci_gpio_setup);
 156
 157 /*--------------------------------------------------------------------------*/
 158 /*
 159  * We expect irqs will normally be set up as input pins, but they can also be
 160  * used as output pins ... which is convenient for testing.
 161  *
 162  * NOTE:  The first few GPIOs also have direct INTC hookups in addition
 163  * to their GPIOBNK0 irq, with a bit less overhead.
 164  *
 165  * All those INTC hookups (direct, plus several IRQ banks) can also
 166  * serve as EDMA event triggers.
 167  */
 168
 169 static void gpio_irq_disable(unsigned irq)
 170 {
 171         struct davinci_gpio_regs __iomem *g = irq2regs(irq);
 172         u32 mask = (u32) get_irq_data(irq);
 173
 174         __raw_writel(mask, &g->clr_falling);
 175         __raw_writel(mask, &g->clr_rising);
 176 }
 177
 178 static void gpio_irq_enable(unsigned irq)
 179 {
 180         struct davinci_gpio_regs __iomem *g = irq2regs(irq);
 181         u32 mask = (u32) get_irq_data(irq);
 182         unsigned status = irq_desc[irq].status;
 183
 184         status &= IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING;
 185         if (!status)
 186                 status = IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING;
 187
 188         if (status & IRQ_TYPE_EDGE_FALLING)
 189                 __raw_writel(mask, &g->set_falling);
 190         if (status & IRQ_TYPE_EDGE_RISING)
 191                 __raw_writel(mask, &g->set_rising);
 192 }
 193
 194 static int gpio_irq_type(unsigned irq, unsigned trigger)
 195 {
 196         struct davinci_gpio_regs __iomem *g = irq2regs(irq);
 197         u32 mask = (u32) get_irq_data(irq);
 198
 199         if (trigger & ~(IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING))
 200                 return -EINVAL;
 201
 202         irq_desc[irq].status &= ~IRQ_TYPE_SENSE_MASK;
 203         irq_desc[irq].status |= trigger;
 204
 205         /* don't enable the IRQ if it's currently disabled */
 206         if (irq_desc[irq].depth == 0) {
 207                 __raw_writel(mask, (trigger & IRQ_TYPE_EDGE_FALLING)
 208                              ? &g->set_falling : &g->clr_falling);
 209                 __raw_writel(mask, (trigger & IRQ_TYPE_EDGE_RISING)
 210                              ? &g->set_rising : &g->clr_rising);
 211         }
 212         return 0;
 213 }
 214
 215 static struct irq_chip gpio_irqchip = {
 216         .name           = "GPIO",
 217         .enable         = gpio_irq_enable,
 218         .disable        = gpio_irq_disable,
 219         .set_type       = gpio_irq_type,
 220 };
 221
 222 static void
 223 gpio_irq_handler(unsigned irq, struct irq_desc *desc)
 224 {
 225         struct davinci_gpio_regs __iomem *g = irq2regs(irq);
 226         u32 mask = 0xffff;
 227
 228         /* we only care about one bank */
 229         if (irq & 1)
 230                 mask <<= 16;
 231
 232         /* temporarily mask (level sensitive) parent IRQ */
 233         desc->chip->mask(irq);
 234         desc->chip->ack(irq);
 235         while (1) {
 236                 u32             status;
 237                 int             n;
 238                 int             res;
 239
 240                 /* ack any irqs */
 241                 status = __raw_readl(&g->intstat) & mask;
 242                 if (!status)
 243                         break;
 244                 __raw_writel(status, &g->intstat);
 245                 if (irq & 1)
 246                         status >>= 16;
 247
 248                 /* now demux them to the right lowlevel handler */
 249                 n = (int)get_irq_data(irq);
 250                 while (status) {
 251                         res = ffs(status);
 252                         n += res;
 253                         generic_handle_irq(n - 1);
 254                         status >>= res;
 255                 }
 256         }
 257         desc->chip->unmask(irq);
 258         /* now it may re-trigger */
 259 }
 260
 261 static int gpio_to_irq_banked(struct gpio_chip *chip, unsigned offset)
 262 {
 263         struct davinci_gpio_controller *d = chip2controller(chip);
 264
 265         if (d->irq_base >= 0)
 266                 return d->irq_base + offset;
 267         else
 268                 return -ENODEV;
 269 }
 270
 271 static int gpio_to_irq_unbanked(struct gpio_chip *chip, unsigned offset)
 272 {
 273         struct davinci_soc_info *soc_info = &davinci_soc_info;
 274
 275         /* NOTE:  we assume for now that only irqs in the first gpio_chip
 276          * can provide direct-mapped IRQs to AINTC (up to 32 GPIOs).
 277          */
 278         if (offset < soc_info->gpio_unbanked)
 279                 return soc_info->gpio_irq + offset;
 280         else
 281                 return -ENODEV;
 282 }
 283
 284 static int gpio_irq_type_unbanked(unsigned irq, unsigned trigger)
 285 {
 286         struct davinci_gpio_regs __iomem *g = irq2regs(irq);
 287         u32 mask = (u32) get_irq_data(irq);
 288
 289         if (trigger & ~(IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING))
 290                 return -EINVAL;
 291
 292         __raw_writel(mask, (trigger & IRQ_TYPE_EDGE_FALLING)
 293                      ? &g->set_falling : &g->clr_falling);
 294         __raw_writel(mask, (trigger & IRQ_TYPE_EDGE_RISING)
 295                      ? &g->set_rising : &g->clr_rising);
 296
 297         return 0;
 298 }
 299
 300 /*
 301  * NOTE:  for suspend/resume, probably best to make a platform_device with
 302  * suspend_late/resume_resume calls hooking into results of the set_wake()
 303  * calls ... so if no gpios are wakeup events the clock can be disabled,
 304  * with outputs left at previously set levels, and so that VDD3P3V.IOPWDN0
 305  * (dm6446) can be set appropriately for GPIOV33 pins.
 306  */
 307
 308 static int __init davinci_gpio_irq_setup(void)
 309 {
 310         unsigned        gpio, irq, bank;
 311         struct clk      *clk;
 312         u32             binten = 0;
 313         unsigned        ngpio, bank_irq;
 314         struct davinci_soc_info *soc_info = &davinci_soc_info;
 315         struct davinci_gpio_regs        __iomem *g;
 316
 317         ngpio = soc_info->gpio_num;
 318
 319         bank_irq = soc_info->gpio_irq;
 320         if (bank_irq == 0) {
 321                 printk(KERN_ERR "Don't know first GPIO bank IRQ.\n");
 322                 return -EINVAL;
 323         }
 324
 325         clk = clk_get(NULL, "gpio");
 326         if (IS_ERR(clk)) {
 327                 printk(KERN_ERR "Error %ld getting gpio clock?\n",
 328                        PTR_ERR(clk));
 329                 return PTR_ERR(clk);
 330         }
 331         clk_enable(clk);
 332
 333         /* Arrange gpio_to_irq() support, handling either direct IRQs or
 334          * banked IRQs.  Having GPIOs in the first GPIO bank use direct
 335          * IRQs, while the others use banked IRQs, would need some setup
 336          * tweaks to recognize hardware which can do that.
 337          */
 338         for (gpio = 0, bank = 0; gpio < ngpio; bank++, gpio += 32) {
 339                 chips[bank].chip.to_irq = gpio_to_irq_banked;
 340                 chips[bank].irq_base = soc_info->gpio_unbanked
 341                         ? -EINVAL
 342                         : (soc_info->intc_irq_num + gpio);
 343         }
 344
 345         /*
 346          * AINTC can handle direct/unbanked IRQs for GPIOs, with the GPIO
 347          * controller only handling trigger modes.  We currently assume no
 348          * IRQ mux conflicts; gpio_irq_type_unbanked() is only for GPIOs.
 349          */
 350         if (soc_info->gpio_unbanked) {
 351                 static struct irq_chip gpio_irqchip_unbanked;
 352
 353                 /* pass "bank 0" GPIO IRQs to AINTC */
 354                 chips[0].chip.to_irq = gpio_to_irq_unbanked;
 355                 binten = BIT(0);
 356
 357                 /* AINTC handles mask/unmask; GPIO handles triggering */
 358                 irq = bank_irq;
 359                 gpio_irqchip_unbanked = *get_irq_desc_chip(irq_to_desc(irq));
 360                 gpio_irqchip_unbanked.name = "GPIO-AINTC";
 361                 gpio_irqchip_unbanked.set_type = gpio_irq_type_unbanked;
 362
 363                 /* default trigger: both edges */
 364                 g = gpio2regs(0);
 365                 __raw_writel(~0, &g->set_falling);
 366                 __raw_writel(~0, &g->set_rising);
 367
 368                 /* set the direct IRQs up to use that irqchip */
 369                 for (gpio = 0; gpio < soc_info->gpio_unbanked; gpio++, irq++) {
 370                         set_irq_chip(irq, &gpio_irqchip_unbanked);
 371                         set_irq_data(irq, (void *) __gpio_mask(gpio));
 372                         set_irq_chip_data(irq, (__force void *) g);
 373                         irq_desc[irq].status |= IRQ_TYPE_EDGE_BOTH;
 374                 }
 375
 376                 goto done;
 377         }
 378
 379         /*
 380          * Or, AINTC can handle IRQs for banks of 16 GPIO IRQs, which we
 381          * then chain through our own handler.
 382          */
 383         for (gpio = 0, irq = gpio_to_irq(0), bank = 0;
 384                         gpio < ngpio;
 385                         bank++, bank_irq++) {
 386                 unsigned                i;
 387
 388                 /* disabled by default, enabled only as needed */
 389                 g = gpio2regs(gpio);
 390                 __raw_writel(~0, &g->clr_falling);
 391                 __raw_writel(~0, &g->clr_rising);
 392
 393                 /* set up all irqs in this bank */
 394                 set_irq_chained_handler(bank_irq, gpio_irq_handler);
 395                 set_irq_chip_data(bank_irq, (__force void *) g);
 396                 set_irq_data(bank_irq, (void *) irq);
 397
 398                 for (i = 0; i < 16 && gpio < ngpio; i++, irq++, gpio++) {
 399                         set_irq_chip(irq, &gpio_irqchip);
 400                         set_irq_chip_data(irq, (__force void *) g);
 401                         set_irq_data(irq, (void *) __gpio_mask(gpio));
 402                         set_irq_handler(irq, handle_simple_irq);
 403                         set_irq_flags(irq, IRQF_VALID);
 404                 }
 405
 406                 binten |= BIT(bank);
 407         }
 408
 409 done:
 410         /* BINTEN -- per-bank interrupt enable. genirq would also let these
 411          * bits be set/cleared dynamically.
 412          */
 413         __raw_writel(binten, soc_info->gpio_base + 0x08);
 414
 415         printk(KERN_INFO "DaVinci: %d gpio irqs\n", irq - gpio_to_irq(0));
 416
 417         return 0;
 418 }