drivers/gpio/gpio-omap.c

   1 /*
   2  * Support functions for OMAP GPIO
   3  *
   4  * Copyright (C) 2003-2005 Nokia Corporation
   5  * Written by Juha Yrjölä <juha.yrjola@nokia.com>
   6  *
   7  * Copyright (C) 2009 Texas Instruments
   8  * Added OMAP4 support - Santosh Shilimkar <santosh.shilimkar@ti.com>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License version 2 as
  12  * published by the Free Software Foundation.
  13  */
  14
  15 #include <linux/init.h>
  16 #include <linux/module.h>
  17 #include <linux/interrupt.h>
  18 #include <linux/syscore_ops.h>
  19 #include <linux/err.h>
  20 #include <linux/clk.h>
  21 #include <linux/io.h>
  22 #include <linux/slab.h>
  23 #include <linux/pm_runtime.h>
  24
  25 #include <mach/hardware.h>
  26 #include <asm/irq.h>
  27 #include <mach/irqs.h>
  28 #include <asm/gpio.h>
  29 #include <asm/mach/irq.h>
  30
  31 struct gpio_bank {
  32         unsigned long pbase;
  33         void __iomem *base;
  34         u16 irq;
  35         u16 virtual_irq_start;
  36         int method;
  37         u32 suspend_wakeup;
  38 #if defined(CONFIG_ARCH_OMAP16XX) || defined(CONFIG_ARCH_OMAP2PLUS)
  39         u32 saved_wakeup;
  40 #endif
  41         u32 non_wakeup_gpios;
  42         u32 enabled_non_wakeup_gpios;
  43
  44         u32 saved_datain;
  45         u32 saved_fallingdetect;
  46         u32 saved_risingdetect;
  47         u32 saved_irqstatus;
  48         u32 level_mask;
  49         u32 toggle_mask;
  50         spinlock_t lock;
  51         struct gpio_chip chip;
  52         struct clk *dbck;
  53         u32 mod_usage;
  54         u32 dbck_enable_mask;
  55         struct device *dev;
  56         bool dbck_flag;
  57         int stride;
  58         u32 width;
  59
  60         void (*set_dataout)(struct gpio_bank *bank, int gpio, int enable);
  61
  62         struct omap_gpio_reg_offs *regs;
  63 };
  64
  65 #ifdef CONFIG_ARCH_OMAP3
  66 struct omap3_gpio_regs {
  67         u32 irqenable1;
  68         u32 irqenable2;
  69         u32 wake_en;
  70         u32 ctrl;
  71         u32 oe;
  72         u32 leveldetect0;
  73         u32 leveldetect1;
  74         u32 risingdetect;
  75         u32 fallingdetect;
  76         u32 dataout;
  77 };
  78
  79 static struct omap3_gpio_regs gpio_context[OMAP34XX_NR_GPIOS];
  80 #endif
  81
  82 /*
  83  * TODO: Cleanup gpio_bank usage as it is having information
  84  * related to all instances of the device
  85  */
  86 static struct gpio_bank *gpio_bank;
  87
  88 /* TODO: Analyze removing gpio_bank_count usage from driver code */
  89 int gpio_bank_count;
  90
  91 #define GPIO_INDEX(bank, gpio) (gpio % bank->width)
  92 #define GPIO_BIT(bank, gpio) (1 << GPIO_INDEX(bank, gpio))
  93
  94 static void _set_gpio_direction(struct gpio_bank *bank, int gpio, int is_input)
  95 {
  96         void __iomem *reg = bank->base;
  97         u32 l;
  98
  99         reg += bank->regs->direction;
 100         l = __raw_readl(reg);
 101         if (is_input)
 102                 l |= 1 << gpio;
 103         else
 104                 l &= ~(1 << gpio);
 105         __raw_writel(l, reg);
 106 }
 107
 108
 109 /* set data out value using dedicate set/clear register */
 110 static void _set_gpio_dataout_reg(struct gpio_bank *bank, int gpio, int enable)
 111 {
 112         void __iomem *reg = bank->base;
 113         u32 l = GPIO_BIT(bank, gpio);
 114
 115         if (enable)
 116                 reg += bank->regs->set_dataout;
 117         else
 118                 reg += bank->regs->clr_dataout;
 119
 120         __raw_writel(l, reg);
 121 }
 122
 123 /* set data out value using mask register */
 124 static void _set_gpio_dataout_mask(struct gpio_bank *bank, int gpio, int enable)
 125 {
 126         void __iomem *reg = bank->base + bank->regs->dataout;
 127         u32 gpio_bit = GPIO_BIT(bank, gpio);
 128         u32 l;
 129
 130         l = __raw_readl(reg);
 131         if (enable)
 132                 l |= gpio_bit;
 133         else
 134                 l &= ~gpio_bit;
 135         __raw_writel(l, reg);
 136 }
 137
 138 static int _get_gpio_datain(struct gpio_bank *bank, int gpio)
 139 {
 140         void __iomem *reg = bank->base + bank->regs->datain;
 141
 142         return (__raw_readl(reg) & GPIO_BIT(bank, gpio)) != 0;
 143 }
 144
 145 static int _get_gpio_dataout(struct gpio_bank *bank, int gpio)
 146 {
 147         void __iomem *reg = bank->base + bank->regs->dataout;
 148
 149         return (__raw_readl(reg) & GPIO_BIT(bank, gpio)) != 0;
 150 }
 151
 152 static inline void _gpio_rmw(void __iomem *base, u32 reg, u32 mask, bool set)
 153 {
 154         int l = __raw_readl(base + reg);
 155
 156         if (set)
 157                 l |= mask;
 158         else
 159                 l &= ~mask;
 160
 161         __raw_writel(l, base + reg);
 162 }
 163
 164 /**
 165  * _set_gpio_debounce - low level gpio debounce time
 166  * @bank: the gpio bank we're acting upon
 167  * @gpio: the gpio number on this @gpio
 168  * @debounce: debounce time to use
 169  *
 170  * OMAP's debounce time is in 31us steps so we need
 171  * to convert and round up to the closest unit.
 172  */
 173 static void _set_gpio_debounce(struct gpio_bank *bank, unsigned gpio,
 174                 unsigned debounce)
 175 {
 176         void __iomem            *reg;
 177         u32                     val;
 178         u32                     l;
 179
 180         if (!bank->dbck_flag)
 181                 return;
 182
 183         if (debounce < 32)
 184                 debounce = 0x01;
 185         else if (debounce > 7936)
 186                 debounce = 0xff;
 187         else
 188                 debounce = (debounce / 0x1f) - 1;
 189
 190         l = GPIO_BIT(bank, gpio);
 191
 192         reg = bank->base + bank->regs->debounce;
 193         __raw_writel(debounce, reg);
 194
 195         reg = bank->base + bank->regs->debounce_en;
 196         val = __raw_readl(reg);
 197
 198         if (debounce) {
 199                 val |= l;
 200                 clk_enable(bank->dbck);
 201         } else {
 202                 val &= ~l;
 203                 clk_disable(bank->dbck);
 204         }
 205         bank->dbck_enable_mask = val;
 206
 207         __raw_writel(val, reg);
 208 }
 209
 210 #ifdef CONFIG_ARCH_OMAP2PLUS
 211 static inline void set_24xx_gpio_triggering(struct gpio_bank *bank, int gpio,
 212                                                 int trigger)
 213 {
 214         void __iomem *base = bank->base;
 215         u32 gpio_bit = 1 << gpio;
 216
 217         if (cpu_is_omap44xx()) {
 218                 _gpio_rmw(base, OMAP4_GPIO_LEVELDETECT0, gpio_bit,
 219                           trigger & IRQ_TYPE_LEVEL_LOW);
 220                 _gpio_rmw(base, OMAP4_GPIO_LEVELDETECT1, gpio_bit,
 221                           trigger & IRQ_TYPE_LEVEL_HIGH);
 222                 _gpio_rmw(base, OMAP4_GPIO_RISINGDETECT, gpio_bit,
 223                           trigger & IRQ_TYPE_EDGE_RISING);
 224                 _gpio_rmw(base, OMAP4_GPIO_FALLINGDETECT, gpio_bit,
 225                           trigger & IRQ_TYPE_EDGE_FALLING);
 226         } else {
 227                 _gpio_rmw(base, OMAP24XX_GPIO_LEVELDETECT0, gpio_bit,
 228                           trigger & IRQ_TYPE_LEVEL_LOW);
 229                 _gpio_rmw(base, OMAP24XX_GPIO_LEVELDETECT1, gpio_bit,
 230                           trigger & IRQ_TYPE_LEVEL_HIGH);
 231                 _gpio_rmw(base, OMAP24XX_GPIO_RISINGDETECT, gpio_bit,
 232                           trigger & IRQ_TYPE_EDGE_RISING);
 233                 _gpio_rmw(base, OMAP24XX_GPIO_FALLINGDETECT, gpio_bit,
 234                           trigger & IRQ_TYPE_EDGE_FALLING);
 235         }
 236         if (likely(!(bank->non_wakeup_gpios & gpio_bit))) {
 237                 if (cpu_is_omap44xx()) {
 238                         _gpio_rmw(base, OMAP4_GPIO_IRQWAKEN0, gpio_bit,
 239                                   trigger != 0);
 240                 } else {
 241                         /*
 242                          * GPIO wakeup request can only be generated on edge
 243                          * transitions
 244                          */
 245                         if (trigger & IRQ_TYPE_EDGE_BOTH)
 246                                 __raw_writel(1 << gpio, bank->base
 247                                         + OMAP24XX_GPIO_SETWKUENA);
 248                         else
 249                                 __raw_writel(1 << gpio, bank->base
 250                                         + OMAP24XX_GPIO_CLEARWKUENA);
 251                 }
 252         }
 253         /* This part needs to be executed always for OMAP{34xx, 44xx} */
 254         if (cpu_is_omap34xx() || cpu_is_omap44xx() ||
 255                         (bank->non_wakeup_gpios & gpio_bit)) {
 256                 /*
 257                  * Log the edge gpio and manually trigger the IRQ
 258                  * after resume if the input level changes
 259                  * to avoid irq lost during PER RET/OFF mode
 260                  * Applies for omap2 non-wakeup gpio and all omap3 gpios
 261                  */
 262                 if (trigger & IRQ_TYPE_EDGE_BOTH)
 263                         bank->enabled_non_wakeup_gpios |= gpio_bit;
 264                 else
 265                         bank->enabled_non_wakeup_gpios &= ~gpio_bit;
 266         }
 267
 268         if (cpu_is_omap44xx()) {
 269                 bank->level_mask =
 270                         __raw_readl(bank->base + OMAP4_GPIO_LEVELDETECT0) |
 271                         __raw_readl(bank->base + OMAP4_GPIO_LEVELDETECT1);
 272         } else {
 273                 bank->level_mask =
 274                         __raw_readl(bank->base + OMAP24XX_GPIO_LEVELDETECT0) |
 275                         __raw_readl(bank->base + OMAP24XX_GPIO_LEVELDETECT1);
 276         }
 277 }
 278 #endif
 279
 280 #ifdef CONFIG_ARCH_OMAP1
 281 /*
 282  * This only applies to chips that can't do both rising and falling edge
 283  * detection at once.  For all other chips, this function is a noop.
 284  */
 285 static void _toggle_gpio_edge_triggering(struct gpio_bank *bank, int gpio)
 286 {
 287         void __iomem *reg = bank->base;
 288         u32 l = 0;
 289
 290         switch (bank->method) {
 291         case METHOD_MPUIO:
 292                 reg += OMAP_MPUIO_GPIO_INT_EDGE / bank->stride;
 293                 break;
 294 #ifdef CONFIG_ARCH_OMAP15XX
 295         case METHOD_GPIO_1510:
 296                 reg += OMAP1510_GPIO_INT_CONTROL;
 297                 break;
 298 #endif
 299 #if defined(CONFIG_ARCH_OMAP730) || defined(CONFIG_ARCH_OMAP850)
 300         case METHOD_GPIO_7XX:
 301                 reg += OMAP7XX_GPIO_INT_CONTROL;
 302                 break;
 303 #endif
 304         default:
 305                 return;
 306         }
 307
 308         l = __raw_readl(reg);
 309         if ((l >> gpio) & 1)
 310                 l &= ~(1 << gpio);
 311         else
 312                 l |= 1 << gpio;
 313
 314         __raw_writel(l, reg);
 315 }
 316 #endif
 317
 318 static int _set_gpio_triggering(struct gpio_bank *bank, int gpio, int trigger)
 319 {
 320         void __iomem *reg = bank->base;
 321         u32 l = 0;
 322
 323         switch (bank->method) {
 324 #ifdef CONFIG_ARCH_OMAP1
 325         case METHOD_MPUIO:
 326                 reg += OMAP_MPUIO_GPIO_INT_EDGE / bank->stride;
 327                 l = __raw_readl(reg);
 328                 if ((trigger & IRQ_TYPE_SENSE_MASK) == IRQ_TYPE_EDGE_BOTH)
 329                         bank->toggle_mask |= 1 << gpio;
 330                 if (trigger & IRQ_TYPE_EDGE_RISING)
 331                         l |= 1 << gpio;
 332                 else if (trigger & IRQ_TYPE_EDGE_FALLING)
 333                         l &= ~(1 << gpio);
 334                 else
 335                         goto bad;
 336                 break;
 337 #endif
 338 #ifdef CONFIG_ARCH_OMAP15XX
 339         case METHOD_GPIO_1510:
 340                 reg += OMAP1510_GPIO_INT_CONTROL;
 341                 l = __raw_readl(reg);
 342                 if ((trigger & IRQ_TYPE_SENSE_MASK) == IRQ_TYPE_EDGE_BOTH)
 343                         bank->toggle_mask |= 1 << gpio;
 344                 if (trigger & IRQ_TYPE_EDGE_RISING)
 345                         l |= 1 << gpio;
 346                 else if (trigger & IRQ_TYPE_EDGE_FALLING)
 347                         l &= ~(1 << gpio);
 348                 else
 349                         goto bad;
 350                 break;
 351 #endif
 352 #ifdef CONFIG_ARCH_OMAP16XX
 353         case METHOD_GPIO_1610:
 354                 if (gpio & 0x08)
 355                         reg += OMAP1610_GPIO_EDGE_CTRL2;
 356                 else
 357                         reg += OMAP1610_GPIO_EDGE_CTRL1;
 358                 gpio &= 0x07;
 359                 l = __raw_readl(reg);
 360                 l &= ~(3 << (gpio << 1));
 361                 if (trigger & IRQ_TYPE_EDGE_RISING)
 362                         l |= 2 << (gpio << 1);
 363                 if (trigger & IRQ_TYPE_EDGE_FALLING)
 364                         l |= 1 << (gpio << 1);
 365                 if (trigger)
 366                         /* Enable wake-up during idle for dynamic tick */
 367                         __raw_writel(1 << gpio, bank->base + OMAP1610_GPIO_SET_WAKEUPENA);
 368                 else
 369                         __raw_writel(1 << gpio, bank->base + OMAP1610_GPIO_CLEAR_WAKEUPENA);
 370                 break;
 371 #endif
 372 #if defined(CONFIG_ARCH_OMAP730) || defined(CONFIG_ARCH_OMAP850)
 373         case METHOD_GPIO_7XX:
 374                 reg += OMAP7XX_GPIO_INT_CONTROL;
 375                 l = __raw_readl(reg);
 376                 if ((trigger & IRQ_TYPE_SENSE_MASK) == IRQ_TYPE_EDGE_BOTH)
 377                         bank->toggle_mask |= 1 << gpio;
 378                 if (trigger & IRQ_TYPE_EDGE_RISING)
 379                         l |= 1 << gpio;
 380                 else if (trigger & IRQ_TYPE_EDGE_FALLING)
 381                         l &= ~(1 << gpio);
 382                 else
 383                         goto bad;
 384                 break;
 385 #endif
 386 #ifdef CONFIG_ARCH_OMAP2PLUS
 387         case METHOD_GPIO_24XX:
 388         case METHOD_GPIO_44XX:
 389                 set_24xx_gpio_triggering(bank, gpio, trigger);
 390                 return 0;
 391 #endif
 392         default:
 393                 goto bad;
 394         }
 395         __raw_writel(l, reg);
 396         return 0;
 397 bad:
 398         return -EINVAL;
 399 }
 400
 401 static int gpio_irq_type(struct irq_data *d, unsigned type)
 402 {
 403         struct gpio_bank *bank;
 404         unsigned gpio;
 405         int retval;
 406         unsigned long flags;
 407
 408         if (!cpu_class_is_omap2() && d->irq > IH_MPUIO_BASE)
 409                 gpio = OMAP_MPUIO(d->irq - IH_MPUIO_BASE);
 410         else
 411                 gpio = d->irq - IH_GPIO_BASE;
 412
 413         if (type & ~IRQ_TYPE_SENSE_MASK)
 414                 return -EINVAL;
 415
 416         /* OMAP1 allows only only edge triggering */
 417         if (!cpu_class_is_omap2()
 418                         && (type & (IRQ_TYPE_LEVEL_LOW|IRQ_TYPE_LEVEL_HIGH)))
 419                 return -EINVAL;
 420
 421         bank = irq_data_get_irq_chip_data(d);
 422         spin_lock_irqsave(&bank->lock, flags);
 423         retval = _set_gpio_triggering(bank, GPIO_INDEX(bank, gpio), type);
 424         spin_unlock_irqrestore(&bank->lock, flags);
 425
 426         if (type & (IRQ_TYPE_LEVEL_LOW | IRQ_TYPE_LEVEL_HIGH))
 427                 __irq_set_handler_locked(d->irq, handle_level_irq);
 428         else if (type & (IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING))
 429                 __irq_set_handler_locked(d->irq, handle_edge_irq);
 430
 431         return retval;
 432 }
 433
 434 static void _clear_gpio_irqbank(struct gpio_bank *bank, int gpio_mask)
 435 {
 436         void __iomem *reg = bank->base;
 437
 438         reg += bank->regs->irqstatus;
 439         __raw_writel(gpio_mask, reg);
 440
 441         /* Workaround for clearing DSP GPIO interrupts to allow retention */
 442         if (bank->regs->irqstatus2) {
 443                 reg = bank->base + bank->regs->irqstatus2;
 444                 __raw_writel(gpio_mask, reg);
 445         }
 446
 447         /* Flush posted write for the irq status to avoid spurious interrupts */
 448         __raw_readl(reg);
 449 }
 450
 451 static inline void _clear_gpio_irqstatus(struct gpio_bank *bank, int gpio)
 452 {
 453         _clear_gpio_irqbank(bank, GPIO_BIT(bank, gpio));
 454 }
 455
 456 static u32 _get_gpio_irqbank_mask(struct gpio_bank *bank)
 457 {
 458         void __iomem *reg = bank->base;
 459         u32 l;
 460         u32 mask = (1 << bank->width) - 1;
 461
 462         reg += bank->regs->irqenable;
 463         l = __raw_readl(reg);
 464         if (bank->regs->irqenable_inv)
 465                 l = ~l;
 466         l &= mask;
 467         return l;
 468 }
 469
 470 static void _enable_gpio_irqbank(struct gpio_bank *bank, int gpio_mask)
 471 {
 472         void __iomem *reg = bank->base;
 473         u32 l;
 474
 475         if (bank->regs->set_irqenable) {
 476                 reg += bank->regs->set_irqenable;
 477                 l = gpio_mask;
 478         } else {
 479                 reg += bank->regs->irqenable;
 480                 l = __raw_readl(reg);
 481                 if (bank->regs->irqenable_inv)
 482                         l &= ~gpio_mask;
 483                 else
 484                         l |= gpio_mask;
 485         }
 486
 487         __raw_writel(l, reg);
 488 }
 489
 490 static void _disable_gpio_irqbank(struct gpio_bank *bank, int gpio_mask)
 491 {
 492         void __iomem *reg = bank->base;
 493         u32 l;
 494
 495         if (bank->regs->clr_irqenable) {
 496                 reg += bank->regs->clr_irqenable;
 497                 l = gpio_mask;
 498         } else {
 499                 reg += bank->regs->irqenable;
 500                 l = __raw_readl(reg);
 501                 if (bank->regs->irqenable_inv)
 502                         l |= gpio_mask;
 503                 else
 504                         l &= ~gpio_mask;
 505         }
 506
 507         __raw_writel(l, reg);
 508 }
 509
 510 static inline void _set_gpio_irqenable(struct gpio_bank *bank, int gpio, int enable)
 511 {
 512         if (enable)
 513                 _enable_gpio_irqbank(bank, GPIO_BIT(bank, gpio));
 514         else
 515                 _disable_gpio_irqbank(bank, GPIO_BIT(bank, gpio));
 516 }
 517
 518 /*
 519  * Note that ENAWAKEUP needs to be enabled in GPIO_SYSCONFIG register.
 520  * 1510 does not seem to have a wake-up register. If JTAG is connected
 521  * to the target, system will wake up always on GPIO events. While
 522  * system is running all registered GPIO interrupts need to have wake-up
 523  * enabled. When system is suspended, only selected GPIO interrupts need
 524  * to have wake-up enabled.
 525  */
 526 static int _set_gpio_wakeup(struct gpio_bank *bank, int gpio, int enable)
 527 {
 528         u32 gpio_bit = GPIO_BIT(bank, gpio);
 529         unsigned long flags;
 530
 531         if (bank->non_wakeup_gpios & gpio_bit) {
 532                 dev_err(bank->dev,
 533                         "Unable to modify wakeup on non-wakeup GPIO%d\n", gpio);
 534                 return -EINVAL;
 535         }
 536
 537         spin_lock_irqsave(&bank->lock, flags);
 538         if (enable)
 539                 bank->suspend_wakeup |= gpio_bit;
 540         else
 541                 bank->suspend_wakeup &= ~gpio_bit;
 542
 543         spin_unlock_irqrestore(&bank->lock, flags);
 544
 545         return 0;
 546 }
 547
 548 static void _reset_gpio(struct gpio_bank *bank, int gpio)
 549 {
 550         _set_gpio_direction(bank, GPIO_INDEX(bank, gpio), 1);
 551         _set_gpio_irqenable(bank, gpio, 0);
 552         _clear_gpio_irqstatus(bank, gpio);
 553         _set_gpio_triggering(bank, GPIO_INDEX(bank, gpio), IRQ_TYPE_NONE);
 554 }
 555
 556 /* Use disable_irq_wake() and enable_irq_wake() functions from drivers */
 557 static int gpio_wake_enable(struct irq_data *d, unsigned int enable)
 558 {
 559         unsigned int gpio = d->irq - IH_GPIO_BASE;
 560         struct gpio_bank *bank;
 561         int retval;
 562
 563         bank = irq_data_get_irq_chip_data(d);
 564         retval = _set_gpio_wakeup(bank, gpio, enable);
 565
 566         return retval;
 567 }
 568
 569 static int omap_gpio_request(struct gpio_chip *chip, unsigned offset)
 570 {
 571         struct gpio_bank *bank = container_of(chip, struct gpio_bank, chip);
 572         unsigned long flags;
 573
 574         spin_lock_irqsave(&bank->lock, flags);
 575
 576         /* Set trigger to none. You need to enable the desired trigger with
 577          * request_irq() or set_irq_type().
 578          */
 579         _set_gpio_triggering(bank, offset, IRQ_TYPE_NONE);
 580
 581 #ifdef CONFIG_ARCH_OMAP15XX
 582         if (bank->method == METHOD_GPIO_1510) {
 583                 void __iomem *reg;
 584
 585                 /* Claim the pin for MPU */
 586                 reg = bank->base + OMAP1510_GPIO_PIN_CONTROL;
 587                 __raw_writel(__raw_readl(reg) | (1 << offset), reg);
 588         }
 589 #endif
 590         if (!cpu_class_is_omap1()) {
 591                 if (!bank->mod_usage) {
 592                         void __iomem *reg = bank->base;
 593                         u32 ctrl;
 594
 595                         if (cpu_is_omap24xx() || cpu_is_omap34xx())
 596                                 reg += OMAP24XX_GPIO_CTRL;
 597                         else if (cpu_is_omap44xx())
 598                                 reg += OMAP4_GPIO_CTRL;
 599                         ctrl = __raw_readl(reg);
 600                         /* Module is enabled, clocks are not gated */
 601                         ctrl &= 0xFFFFFFFE;
 602                         __raw_writel(ctrl, reg);
 603                 }
 604                 bank->mod_usage |= 1 << offset;
 605         }
 606         spin_unlock_irqrestore(&bank->lock, flags);
 607
 608         return 0;
 609 }
 610
 611 static void omap_gpio_free(struct gpio_chip *chip, unsigned offset)
 612 {
 613         struct gpio_bank *bank = container_of(chip, struct gpio_bank, chip);
 614         unsigned long flags;
 615
 616         spin_lock_irqsave(&bank->lock, flags);
 617 #ifdef CONFIG_ARCH_OMAP16XX
 618         if (bank->method == METHOD_GPIO_1610) {
 619                 /* Disable wake-up during idle for dynamic tick */
 620                 void __iomem *reg = bank->base + OMAP1610_GPIO_CLEAR_WAKEUPENA;
 621                 __raw_writel(1 << offset, reg);
 622         }
 623 #endif
 624 #if defined(CONFIG_ARCH_OMAP2) || defined(CONFIG_ARCH_OMAP3)
 625         if (bank->method == METHOD_GPIO_24XX) {
 626                 /* Disable wake-up during idle for dynamic tick */
 627                 void __iomem *reg = bank->base + OMAP24XX_GPIO_CLEARWKUENA;
 628                 __raw_writel(1 << offset, reg);
 629         }
 630 #endif
 631 #ifdef CONFIG_ARCH_OMAP4
 632         if (bank->method == METHOD_GPIO_44XX) {
 633                 /* Disable wake-up during idle for dynamic tick */
 634                 void __iomem *reg = bank->base + OMAP4_GPIO_IRQWAKEN0;
 635                 __raw_writel(1 << offset, reg);
 636         }
 637 #endif
 638         if (!cpu_class_is_omap1()) {
 639                 bank->mod_usage &= ~(1 << offset);
 640                 if (!bank->mod_usage) {
 641                         void __iomem *reg = bank->base;
 642                         u32 ctrl;
 643
 644                         if (cpu_is_omap24xx() || cpu_is_omap34xx())
 645                                 reg += OMAP24XX_GPIO_CTRL;
 646                         else if (cpu_is_omap44xx())
 647                                 reg += OMAP4_GPIO_CTRL;
 648                         ctrl = __raw_readl(reg);
 649                         /* Module is disabled, clocks are gated */
 650                         ctrl |= 1;
 651                         __raw_writel(ctrl, reg);
 652                 }
 653         }
 654         _reset_gpio(bank, bank->chip.base + offset);
 655         spin_unlock_irqrestore(&bank->lock, flags);
 656 }
 657
 658 /*
 659  * We need to unmask the GPIO bank interrupt as soon as possible to
 660  * avoid missing GPIO interrupts for other lines in the bank.
 661  * Then we need to mask-read-clear-unmask the triggered GPIO lines
 662  * in the bank to avoid missing nested interrupts for a GPIO line.
 663  * If we wait to unmask individual GPIO lines in the bank after the
 664  * line's interrupt handler has been run, we may miss some nested
 665  * interrupts.
 666  */
 667 static void gpio_irq_handler(unsigned int irq, struct irq_desc *desc)
 668 {
 669         void __iomem *isr_reg = NULL;
 670         u32 isr;
 671         unsigned int gpio_irq, gpio_index;
 672         struct gpio_bank *bank;
 673         u32 retrigger = 0;
 674         int unmasked = 0;
 675         struct irq_chip *chip = irq_desc_get_chip(desc);
 676
 677         chained_irq_enter(chip, desc);
 678
 679         bank = irq_get_handler_data(irq);
 680         isr_reg = bank->base + bank->regs->irqstatus;
 681
 682         if (WARN_ON(!isr_reg))
 683                 goto exit;
 684
 685         while(1) {
 686                 u32 isr_saved, level_mask = 0;
 687                 u32 enabled;
 688
 689                 enabled = _get_gpio_irqbank_mask(bank);
 690                 isr_saved = isr = __raw_readl(isr_reg) & enabled;
 691
 692                 if (cpu_is_omap15xx() && (bank->method == METHOD_MPUIO))
 693                         isr &= 0x0000ffff;
 694
 695                 if (cpu_class_is_omap2()) {
 696                         level_mask = bank->level_mask & enabled;
 697                 }
 698
 699                 /* clear edge sensitive interrupts before handler(s) are
 700                 called so that we don't miss any interrupt occurred while
 701                 executing them */
 702                 _disable_gpio_irqbank(bank, isr_saved & ~level_mask);
 703                 _clear_gpio_irqbank(bank, isr_saved & ~level_mask);
 704                 _enable_gpio_irqbank(bank, isr_saved & ~level_mask);
 705
 706                 /* if there is only edge sensitive GPIO pin interrupts
 707                 configured, we could unmask GPIO bank interrupt immediately */
 708                 if (!level_mask && !unmasked) {
 709                         unmasked = 1;
 710                         chained_irq_exit(chip, desc);
 711                 }
 712
 713                 isr |= retrigger;
 714                 retrigger = 0;
 715                 if (!isr)
 716                         break;
 717
 718                 gpio_irq = bank->virtual_irq_start;
 719                 for (; isr != 0; isr >>= 1, gpio_irq++) {
 720                         gpio_index = GPIO_INDEX(bank, irq_to_gpio(gpio_irq));
 721
 722                         if (!(isr & 1))
 723                                 continue;
 724
 725 #ifdef CONFIG_ARCH_OMAP1
 726                         /*
 727                          * Some chips can't respond to both rising and falling
 728                          * at the same time.  If this irq was requested with
 729                          * both flags, we need to flip the ICR data for the IRQ
 730                          * to respond to the IRQ for the opposite direction.
 731                          * This will be indicated in the bank toggle_mask.
 732                          */
 733                         if (bank->toggle_mask & (1 << gpio_index))
 734                                 _toggle_gpio_edge_triggering(bank, gpio_index);
 735 #endif
 736
 737                         generic_handle_irq(gpio_irq);
 738                 }
 739         }
 740         /* if bank has any level sensitive GPIO pin interrupt
 741         configured, we must unmask the bank interrupt only after
 742         handler(s) are executed in order to avoid spurious bank
 743         interrupt */
 744 exit:
 745         if (!unmasked)
 746                 chained_irq_exit(chip, desc);
 747 }
 748
 749 static void gpio_irq_shutdown(struct irq_data *d)
 750 {
 751         unsigned int gpio = d->irq - IH_GPIO_BASE;
 752         struct gpio_bank *bank = irq_data_get_irq_chip_data(d);
 753         unsigned long flags;
 754
 755         spin_lock_irqsave(&bank->lock, flags);
 756         _reset_gpio(bank, gpio);
 757         spin_unlock_irqrestore(&bank->lock, flags);
 758 }
 759
 760 static void gpio_ack_irq(struct irq_data *d)
 761 {
 762         unsigned int gpio = d->irq - IH_GPIO_BASE;
 763         struct gpio_bank *bank = irq_data_get_irq_chip_data(d);
 764
 765         _clear_gpio_irqstatus(bank, gpio);
 766 }
 767
 768 static void gpio_mask_irq(struct irq_data *d)
 769 {
 770         unsigned int gpio = d->irq - IH_GPIO_BASE;
 771         struct gpio_bank *bank = irq_data_get_irq_chip_data(d);
 772         unsigned long flags;
 773
 774         spin_lock_irqsave(&bank->lock, flags);
 775         _set_gpio_irqenable(bank, gpio, 0);
 776         _set_gpio_triggering(bank, GPIO_INDEX(bank, gpio), IRQ_TYPE_NONE);
 777         spin_unlock_irqrestore(&bank->lock, flags);
 778 }
 779
 780 static void gpio_unmask_irq(struct irq_data *d)
 781 {
 782         unsigned int gpio = d->irq - IH_GPIO_BASE;
 783         struct gpio_bank *bank = irq_data_get_irq_chip_data(d);
 784         unsigned int irq_mask = GPIO_BIT(bank, gpio);
 785         u32 trigger = irqd_get_trigger_type(d);
 786         unsigned long flags;
 787
 788         spin_lock_irqsave(&bank->lock, flags);
 789         if (trigger)
 790                 _set_gpio_triggering(bank, GPIO_INDEX(bank, gpio), trigger);
 791
 792         /* For level-triggered GPIOs, the clearing must be done after
 793          * the HW source is cleared, thus after the handler has run */
 794         if (bank->level_mask & irq_mask) {
 795                 _set_gpio_irqenable(bank, gpio, 0);
 796                 _clear_gpio_irqstatus(bank, gpio);
 797         }
 798
 799         _set_gpio_irqenable(bank, gpio, 1);
 800         spin_unlock_irqrestore(&bank->lock, flags);
 801 }
 802
 803 static struct irq_chip gpio_irq_chip = {
 804         .name           = "GPIO",
 805         .irq_shutdown   = gpio_irq_shutdown,
 806         .irq_ack        = gpio_ack_irq,
 807         .irq_mask       = gpio_mask_irq,
 808         .irq_unmask     = gpio_unmask_irq,
 809         .irq_set_type   = gpio_irq_type,
 810         .irq_set_wake   = gpio_wake_enable,
 811 };
 812
 813 /*---------------------------------------------------------------------*/
 814
 815 #ifdef CONFIG_ARCH_OMAP1
 816
 817 #define bank_is_mpuio(bank)     ((bank)->method == METHOD_MPUIO)
 818
 819 #ifdef CONFIG_ARCH_OMAP16XX
 820
 821 #include <linux/platform_device.h>
 822
 823 static int omap_mpuio_suspend_noirq(struct device *dev)
 824 {
 825         struct platform_device *pdev = to_platform_device(dev);
 826         struct gpio_bank        *bank = platform_get_drvdata(pdev);
 827         void __iomem            *mask_reg = bank->base +
 828                                         OMAP_MPUIO_GPIO_MASKIT / bank->stride;
 829         unsigned long           flags;
 830
 831         spin_lock_irqsave(&bank->lock, flags);
 832         bank->saved_wakeup = __raw_readl(mask_reg);
 833         __raw_writel(0xffff & ~bank->suspend_wakeup, mask_reg);
 834         spin_unlock_irqrestore(&bank->lock, flags);
 835
 836         return 0;
 837 }
 838
 839 static int omap_mpuio_resume_noirq(struct device *dev)
 840 {
 841         struct platform_device *pdev = to_platform_device(dev);
 842         struct gpio_bank        *bank = platform_get_drvdata(pdev);
 843         void __iomem            *mask_reg = bank->base +
 844                                         OMAP_MPUIO_GPIO_MASKIT / bank->stride;
 845         unsigned long           flags;
 846
 847         spin_lock_irqsave(&bank->lock, flags);
 848         __raw_writel(bank->saved_wakeup, mask_reg);
 849         spin_unlock_irqrestore(&bank->lock, flags);
 850
 851         return 0;
 852 }
 853
 854 static const struct dev_pm_ops omap_mpuio_dev_pm_ops = {
 855         .suspend_noirq = omap_mpuio_suspend_noirq,
 856         .resume_noirq = omap_mpuio_resume_noirq,
 857 };
 858
 859 /* use platform_driver for this. */
 860 static struct platform_driver omap_mpuio_driver = {
 861         .driver         = {
 862                 .name   = "mpuio",
 863                 .pm     = &omap_mpuio_dev_pm_ops,
 864         },
 865 };
 866
 867 static struct platform_device omap_mpuio_device = {
 868         .name           = "mpuio",
 869         .id             = -1,
 870         .dev = {
 871                 .driver = &omap_mpuio_driver.driver,
 872         }
 873         /* could list the /proc/iomem resources */
 874 };
 875
 876 static inline void mpuio_init(void)
 877 {
 878         struct gpio_bank *bank = &gpio_bank[0];
 879         platform_set_drvdata(&omap_mpuio_device, bank);
 880
 881         if (platform_driver_register(&omap_mpuio_driver) == 0)
 882                 (void) platform_device_register(&omap_mpuio_device);
 883 }
 884
 885 #else
 886 static inline void mpuio_init(void) {}
 887 #endif  /* 16xx */
 888
 889 #else
 890
 891 #define bank_is_mpuio(bank)     0
 892 static inline void mpuio_init(void) {}
 893
 894 #endif
 895
 896 /*---------------------------------------------------------------------*/
 897
 898 /* REVISIT these are stupid implementations!  replace by ones that
 899  * don't switch on METHOD_* and which mostly avoid spinlocks
 900  */
 901
 902 static int gpio_input(struct gpio_chip *chip, unsigned offset)
 903 {
 904         struct gpio_bank *bank;
 905         unsigned long flags;
 906
 907         bank = container_of(chip, struct gpio_bank, chip);
 908         spin_lock_irqsave(&bank->lock, flags);
 909         _set_gpio_direction(bank, offset, 1);
 910         spin_unlock_irqrestore(&bank->lock, flags);
 911         return 0;
 912 }
 913
 914 static int gpio_is_input(struct gpio_bank *bank, int mask)
 915 {
 916         void __iomem *reg = bank->base + bank->regs->direction;
 917
 918         return __raw_readl(reg) & mask;
 919 }
 920
 921 static int gpio_get(struct gpio_chip *chip, unsigned offset)
 922 {
 923         struct gpio_bank *bank;
 924         void __iomem *reg;
 925         int gpio;
 926         u32 mask;
 927
 928         gpio = chip->base + offset;
 929         bank = container_of(chip, struct gpio_bank, chip);
 930         reg = bank->base;
 931         mask = GPIO_BIT(bank, gpio);
 932
 933         if (gpio_is_input(bank, mask))
 934                 return _get_gpio_datain(bank, gpio);
 935         else
 936                 return _get_gpio_dataout(bank, gpio);
 937 }
 938
 939 static int gpio_output(struct gpio_chip *chip, unsigned offset, int value)
 940 {
 941         struct gpio_bank *bank;
 942         unsigned long flags;
 943
 944         bank = container_of(chip, struct gpio_bank, chip);
 945         spin_lock_irqsave(&bank->lock, flags);
 946         bank->set_dataout(bank, offset, value);
 947         _set_gpio_direction(bank, offset, 0);
 948         spin_unlock_irqrestore(&bank->lock, flags);
 949         return 0;
 950 }
 951
 952 static int gpio_debounce(struct gpio_chip *chip, unsigned offset,
 953                 unsigned debounce)
 954 {
 955         struct gpio_bank *bank;
 956         unsigned long flags;
 957
 958         bank = container_of(chip, struct gpio_bank, chip);
 959
 960         if (!bank->dbck) {
 961                 bank->dbck = clk_get(bank->dev, "dbclk");
 962                 if (IS_ERR(bank->dbck))
 963                         dev_err(bank->dev, "Could not get gpio dbck\n");
 964         }
 965
 966         spin_lock_irqsave(&bank->lock, flags);
 967         _set_gpio_debounce(bank, offset, debounce);
 968         spin_unlock_irqrestore(&bank->lock, flags);
 969
 970         return 0;
 971 }
 972
 973 static void gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 974 {
 975         struct gpio_bank *bank;
 976         unsigned long flags;
 977
 978         bank = container_of(chip, struct gpio_bank, chip);
 979         spin_lock_irqsave(&bank->lock, flags);
 980         bank->set_dataout(bank, offset, value);
 981         spin_unlock_irqrestore(&bank->lock, flags);
 982 }
 983
 984 static int gpio_2irq(struct gpio_chip *chip, unsigned offset)
 985 {
 986         struct gpio_bank *bank;
 987
 988         bank = container_of(chip, struct gpio_bank, chip);
 989         return bank->virtual_irq_start + offset;
 990 }
 991
 992 /*---------------------------------------------------------------------*/
 993
 994 static void __init omap_gpio_show_rev(struct gpio_bank *bank)
 995 {
 996         static bool called;
 997         u32 rev;
 998
 999         if (called || bank->regs->revision == USHRT_MAX)
1000                 return;
1001
1002         rev = __raw_readw(bank->base + bank->regs->revision);
1003         pr_info("OMAP GPIO hardware version %d.%d\n",
1004                 (rev >> 4) & 0x0f, rev & 0x0f);
1005
1006         called = true;
1007 }
1008
1009 /* This lock class tells lockdep that GPIO irqs are in a different
1010  * category than their parents, so it won't report false recursion.
1011  */
1012 static struct lock_class_key gpio_lock_class;
1013
1014 static inline int init_gpio_info(struct platform_device *pdev)
1015 {
1016         /* TODO: Analyze removing gpio_bank_count usage from driver code */
1017         gpio_bank = kzalloc(gpio_bank_count * sizeof(struct gpio_bank),
1018                                 GFP_KERNEL);
1019         if (!gpio_bank) {
1020                 dev_err(&pdev->dev, "Memory alloc failed for gpio_bank\n");
1021                 return -ENOMEM;
1022         }
1023         return 0;
1024 }
1025
1026 /* TODO: Cleanup cpu_is_* checks */
1027 static void omap_gpio_mod_init(struct gpio_bank *bank, int id)
1028 {
1029         if (cpu_class_is_omap2()) {
1030                 if (cpu_is_omap44xx()) {
1031                         __raw_writel(0xffffffff, bank->base +
1032                                         OMAP4_GPIO_IRQSTATUSCLR0);
1033                         __raw_writel(0x00000000, bank->base +
1034                                          OMAP4_GPIO_DEBOUNCENABLE);
1035                         /* Initialize interface clk ungated, module enabled */
1036                         __raw_writel(0, bank->base + OMAP4_GPIO_CTRL);
1037                 } else if (cpu_is_omap34xx()) {
1038                         __raw_writel(0x00000000, bank->base +
1039                                         OMAP24XX_GPIO_IRQENABLE1);
1040                         __raw_writel(0xffffffff, bank->base +
1041                                         OMAP24XX_GPIO_IRQSTATUS1);
1042                         __raw_writel(0x00000000, bank->base +
1043                                         OMAP24XX_GPIO_DEBOUNCE_EN);
1044
1045                         /* Initialize interface clk ungated, module enabled */
1046                         __raw_writel(0, bank->base + OMAP24XX_GPIO_CTRL);
1047                 } else if (cpu_is_omap24xx()) {
1048                         static const u32 non_wakeup_gpios[] = {
1049                                 0xe203ffc0, 0x08700040
1050                         };
1051                         if (id < ARRAY_SIZE(non_wakeup_gpios))
1052                                 bank->non_wakeup_gpios = non_wakeup_gpios[id];
1053                 }
1054         } else if (cpu_class_is_omap1()) {
1055                 if (bank_is_mpuio(bank))
1056                         __raw_writew(0xffff, bank->base +
1057                                 OMAP_MPUIO_GPIO_MASKIT / bank->stride);
1058                 if (cpu_is_omap15xx() && bank->method == METHOD_GPIO_1510) {
1059                         __raw_writew(0xffff, bank->base
1060                                                 + OMAP1510_GPIO_INT_MASK);
1061                         __raw_writew(0x0000, bank->base
1062                                                 + OMAP1510_GPIO_INT_STATUS);
1063                 }
1064                 if (cpu_is_omap16xx() && bank->method == METHOD_GPIO_1610) {
1065                         __raw_writew(0x0000, bank->base
1066                                                 + OMAP1610_GPIO_IRQENABLE1);
1067                         __raw_writew(0xffff, bank->base
1068                                                 + OMAP1610_GPIO_IRQSTATUS1);
1069                         __raw_writew(0x0014, bank->base
1070                                                 + OMAP1610_GPIO_SYSCONFIG);
1071
1072                         /*
1073                          * Enable system clock for GPIO module.
1074                          * The CAM_CLK_CTRL *is* really the right place.
1075                          */
1076                         omap_writel(omap_readl(ULPD_CAM_CLK_CTRL) | 0x04,
1077                                                 ULPD_CAM_CLK_CTRL);
1078                 }
1079                 if (cpu_is_omap7xx() && bank->method == METHOD_GPIO_7XX) {
1080                         __raw_writel(0xffffffff, bank->base
1081                                                 + OMAP7XX_GPIO_INT_MASK);
1082                         __raw_writel(0x00000000, bank->base
1083                                                 + OMAP7XX_GPIO_INT_STATUS);
1084                 }
1085         }
1086 }
1087
1088 static __init void
1089 omap_mpuio_alloc_gc(struct gpio_bank *bank, unsigned int irq_start,
1090                     unsigned int num)
1091 {
1092         struct irq_chip_generic *gc;
1093         struct irq_chip_type *ct;
1094
1095         gc = irq_alloc_generic_chip("MPUIO", 1, irq_start, bank->base,
1096                                     handle_simple_irq);
1097         if (!gc) {
1098                 dev_err(bank->dev, "Memory alloc failed for gc\n");
1099                 return;
1100         }
1101
1102         ct = gc->chip_types;
1103
1104         /* NOTE: No ack required, reading IRQ status clears it. */
1105         ct->chip.irq_mask = irq_gc_mask_set_bit;
1106         ct->chip.irq_unmask = irq_gc_mask_clr_bit;
1107         ct->chip.irq_set_type = gpio_irq_type;
1108         /* REVISIT: assuming only 16xx supports MPUIO wake events */
1109         if (cpu_is_omap16xx())
1110                 ct->chip.irq_set_wake = gpio_wake_enable,
1111
1112         ct->regs.mask = OMAP_MPUIO_GPIO_INT / bank->stride;
1113         irq_setup_generic_chip(gc, IRQ_MSK(num), IRQ_GC_INIT_MASK_CACHE,
1114                                IRQ_NOREQUEST | IRQ_NOPROBE, 0);
1115 }
1116
1117 static void __devinit omap_gpio_chip_init(struct gpio_bank *bank)
1118 {
1119         int j;
1120         static int gpio;
1121
1122         bank->mod_usage = 0;
1123         /*
1124          * REVISIT eventually switch from OMAP-specific gpio structs
1125          * over to the generic ones
1126          */
1127         bank->chip.request = omap_gpio_request;
1128         bank->chip.free = omap_gpio_free;
1129         bank->chip.direction_input = gpio_input;
1130         bank->chip.get = gpio_get;
1131         bank->chip.direction_output = gpio_output;
1132         bank->chip.set_debounce = gpio_debounce;
1133         bank->chip.set = gpio_set;
1134         bank->chip.to_irq = gpio_2irq;
1135         if (bank_is_mpuio(bank)) {
1136                 bank->chip.label = "mpuio";
1137 #ifdef CONFIG_ARCH_OMAP16XX
1138                 bank->chip.dev = &omap_mpuio_device.dev;
1139 #endif
1140                 bank->chip.base = OMAP_MPUIO(0);
1141         } else {
1142                 bank->chip.label = "gpio";
1143                 bank->chip.base = gpio;
1144                 gpio += bank->width;
1145         }
1146         bank->chip.ngpio = bank->width;
1147
1148         gpiochip_add(&bank->chip);
1149
1150         for (j = bank->virtual_irq_start;
1151                      j < bank->virtual_irq_start + bank->width; j++) {
1152                 irq_set_lockdep_class(j, &gpio_lock_class);
1153                 irq_set_chip_data(j, bank);
1154                 if (bank_is_mpuio(bank)) {
1155                         omap_mpuio_alloc_gc(bank, j, bank->width);
1156                 } else {
1157                         irq_set_chip(j, &gpio_irq_chip);
1158                         irq_set_handler(j, handle_simple_irq);
1159                         set_irq_flags(j, IRQF_VALID);
1160                 }
1161         }
1162         irq_set_chained_handler(bank->irq, gpio_irq_handler);
1163         irq_set_handler_data(bank->irq, bank);
1164 }
1165
1166 static int __devinit omap_gpio_probe(struct platform_device *pdev)
1167 {
1168         static int gpio_init_done;
1169         struct omap_gpio_platform_data *pdata;
1170         struct resource *res;
1171         int id;
1172         struct gpio_bank *bank;
1173
1174         if (!pdev->dev.platform_data)
1175                 return -EINVAL;
1176
1177         pdata = pdev->dev.platform_data;
1178
1179         if (!gpio_init_done) {
1180                 int ret;
1181
1182                 ret = init_gpio_info(pdev);
1183                 if (ret)
1184                         return ret;
1185         }
1186
1187         id = pdev->id;
1188         bank = &gpio_bank[id];
1189
1190         res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
1191         if (unlikely(!res)) {
1192                 dev_err(&pdev->dev, "GPIO Bank %i Invalid IRQ resource\n", id);
1193                 return -ENODEV;
1194         }
1195
1196         bank->irq = res->start;
1197         bank->virtual_irq_start = pdata->virtual_irq_start;
1198         bank->method = pdata->bank_type;
1199         bank->dev = &pdev->dev;
1200         bank->dbck_flag = pdata->dbck_flag;
1201         bank->stride = pdata->bank_stride;
1202         bank->width = pdata->bank_width;
1203
1204         bank->regs = pdata->regs;
1205
1206         if (bank->regs->set_dataout && bank->regs->clr_dataout)
1207                 bank->set_dataout = _set_gpio_dataout_reg;
1208         else
1209                 bank->set_dataout = _set_gpio_dataout_mask;
1210
1211         spin_lock_init(&bank->lock);
1212
1213         /* Static mapping, never released */
1214         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1215         if (unlikely(!res)) {
1216                 dev_err(&pdev->dev, "GPIO Bank %i Invalid mem resource\n", id);
1217                 return -ENODEV;
1218         }
1219
1220         bank->base = ioremap(res->start, resource_size(res));
1221         if (!bank->base) {
1222                 dev_err(&pdev->dev, "Could not ioremap gpio bank%i\n", id);
1223                 return -ENOMEM;
1224         }
1225
1226         pm_runtime_enable(bank->dev);
1227         pm_runtime_get_sync(bank->dev);
1228
1229         omap_gpio_mod_init(bank, id);
1230         omap_gpio_chip_init(bank);
1231         omap_gpio_show_rev(bank);
1232
1233         if (!gpio_init_done)
1234                 gpio_init_done = 1;
1235
1236         return 0;
1237 }
1238
1239 #if defined(CONFIG_ARCH_OMAP16XX) || defined(CONFIG_ARCH_OMAP2PLUS)
1240 static int omap_gpio_suspend(void)
1241 {
1242         int i;
1243
1244         if (!cpu_class_is_omap2() && !cpu_is_omap16xx())
1245                 return 0;
1246
1247         for (i = 0; i < gpio_bank_count; i++) {
1248                 struct gpio_bank *bank = &gpio_bank[i];
1249                 void __iomem *wake_status;
1250                 void __iomem *wake_clear;
1251                 void __iomem *wake_set;
1252                 unsigned long flags;
1253
1254                 switch (bank->method) {
1255 #ifdef CONFIG_ARCH_OMAP16XX
1256                 case METHOD_GPIO_1610:
1257                         wake_status = bank->base + OMAP1610_GPIO_WAKEUPENABLE;
1258                         wake_clear = bank->base + OMAP1610_GPIO_CLEAR_WAKEUPENA;
1259                         wake_set = bank->base + OMAP1610_GPIO_SET_WAKEUPENA;
1260                         break;
1261 #endif
1262 #if defined(CONFIG_ARCH_OMAP2) || defined(CONFIG_ARCH_OMAP3)
1263                 case METHOD_GPIO_24XX:
1264                         wake_status = bank->base + OMAP24XX_GPIO_WAKE_EN;
1265                         wake_clear = bank->base + OMAP24XX_GPIO_CLEARWKUENA;
1266                         wake_set = bank->base + OMAP24XX_GPIO_SETWKUENA;
1267                         break;
1268 #endif
1269 #ifdef CONFIG_ARCH_OMAP4
1270                 case METHOD_GPIO_44XX:
1271                         wake_status = bank->base + OMAP4_GPIO_IRQWAKEN0;
1272                         wake_clear = bank->base + OMAP4_GPIO_IRQWAKEN0;
1273                         wake_set = bank->base + OMAP4_GPIO_IRQWAKEN0;
1274                         break;
1275 #endif
1276                 default:
1277                         continue;
1278                 }
1279
1280                 spin_lock_irqsave(&bank->lock, flags);
1281                 bank->saved_wakeup = __raw_readl(wake_status);
1282                 __raw_writel(0xffffffff, wake_clear);
1283                 __raw_writel(bank->suspend_wakeup, wake_set);
1284                 spin_unlock_irqrestore(&bank->lock, flags);
1285         }
1286
1287         return 0;
1288 }
1289
1290 static void omap_gpio_resume(void)
1291 {
1292         int i;
1293
1294         if (!cpu_class_is_omap2() && !cpu_is_omap16xx())
1295                 return;
1296
1297         for (i = 0; i < gpio_bank_count; i++) {
1298                 struct gpio_bank *bank = &gpio_bank[i];
1299                 void __iomem *wake_clear;
1300                 void __iomem *wake_set;
1301                 unsigned long flags;
1302
1303                 switch (bank->method) {
1304 #ifdef CONFIG_ARCH_OMAP16XX
1305                 case METHOD_GPIO_1610:
1306                         wake_clear = bank->base + OMAP1610_GPIO_CLEAR_WAKEUPENA;
1307                         wake_set = bank->base + OMAP1610_GPIO_SET_WAKEUPENA;
1308                         break;
1309 #endif
1310 #if defined(CONFIG_ARCH_OMAP2) || defined(CONFIG_ARCH_OMAP3)
1311                 case METHOD_GPIO_24XX:
1312                         wake_clear = bank->base + OMAP24XX_GPIO_CLEARWKUENA;
1313                         wake_set = bank->base + OMAP24XX_GPIO_SETWKUENA;
1314                         break;
1315 #endif
1316 #ifdef CONFIG_ARCH_OMAP4
1317                 case METHOD_GPIO_44XX:
1318                         wake_clear = bank->base + OMAP4_GPIO_IRQWAKEN0;
1319                         wake_set = bank->base + OMAP4_GPIO_IRQWAKEN0;
1320                         break;
1321 #endif
1322                 default:
1323                         continue;
1324                 }
1325
1326                 spin_lock_irqsave(&bank->lock, flags);
1327                 __raw_writel(0xffffffff, wake_clear);
1328                 __raw_writel(bank->saved_wakeup, wake_set);
1329                 spin_unlock_irqrestore(&bank->lock, flags);
1330         }
1331 }
1332
1333 static struct syscore_ops omap_gpio_syscore_ops = {
1334         .suspend        = omap_gpio_suspend,
1335         .resume         = omap_gpio_resume,
1336 };
1337
1338 #endif
1339
1340 #ifdef CONFIG_ARCH_OMAP2PLUS
1341
1342 static int workaround_enabled;
1343
1344 void omap2_gpio_prepare_for_idle(int off_mode)
1345 {
1346         int i, c = 0;
1347         int min = 0;
1348
1349         if (cpu_is_omap34xx())
1350                 min = 1;
1351
1352         for (i = min; i < gpio_bank_count; i++) {
1353                 struct gpio_bank *bank = &gpio_bank[i];
1354                 void __iomem *reg;
1355                 u32 l1 = 0, l2 = 0;
1356                 int j;
1357
1358                 /*
1359                  * Disable debounce since clock disable below will cause
1360                  * problems if GPIO module doesn't go idle for some reason.
1361                  */
1362                 if (bank->dbck_enable_mask != 0) {
1363                         reg = bank->base + bank->regs->datain;
1364                         bank->saved_datain = __raw_readl(reg);
1365                         reg = bank->base + bank->regs->irqstatus;
1366                         bank->saved_irqstatus = __raw_readl(reg);
1367                         reg = bank->base + bank->regs->debounce_en;
1368                         __raw_writel(0, reg);
1369                 }
1370
1371                 for (j = 0; j < hweight_long(bank->dbck_enable_mask); j++)
1372                         clk_disable(bank->dbck);
1373
1374                 if (!off_mode)
1375                         continue;
1376
1377                 /* If going to OFF, remove triggering for all
1378                  * non-wakeup GPIOs.  Otherwise spurious IRQs will be
1379                  * generated.  See OMAP2420 Errata item 1.101. */
1380                 if (!(bank->enabled_non_wakeup_gpios))
1381                         continue;
1382
1383                 if (cpu_is_omap24xx() || cpu_is_omap34xx()) {
1384                         bank->saved_datain = __raw_readl(bank->base +
1385                                         OMAP24XX_GPIO_DATAIN);
1386                         l1 = __raw_readl(bank->base +
1387                                         OMAP24XX_GPIO_FALLINGDETECT);
1388                         l2 = __raw_readl(bank->base +
1389                                         OMAP24XX_GPIO_RISINGDETECT);
1390                 }
1391
1392                 if (cpu_is_omap44xx()) {
1393                         bank->saved_datain = __raw_readl(bank->base +
1394                                                 OMAP4_GPIO_DATAIN);
1395                         l1 = __raw_readl(bank->base +
1396                                                 OMAP4_GPIO_FALLINGDETECT);
1397                         l2 = __raw_readl(bank->base +
1398                                                 OMAP4_GPIO_RISINGDETECT);
1399                 }
1400
1401                 bank->saved_fallingdetect = l1;
1402                 bank->saved_risingdetect = l2;
1403                 l1 &= ~bank->enabled_non_wakeup_gpios;
1404                 l2 &= ~bank->enabled_non_wakeup_gpios;
1405
1406                 if (cpu_is_omap24xx() || cpu_is_omap34xx()) {
1407                         __raw_writel(l1, bank->base +
1408                                         OMAP24XX_GPIO_FALLINGDETECT);
1409                         __raw_writel(l2, bank->base +
1410                                         OMAP24XX_GPIO_RISINGDETECT);
1411                 }
1412
1413                 if (cpu_is_omap44xx()) {
1414                         __raw_writel(l1, bank->base + OMAP4_GPIO_FALLINGDETECT);
1415                         __raw_writel(l2, bank->base + OMAP4_GPIO_RISINGDETECT);
1416                 }
1417
1418                 c++;
1419         }
1420         if (!c) {
1421                 workaround_enabled = 0;
1422                 return;
1423         }
1424         workaround_enabled = 1;
1425 }
1426
1427 void omap2_gpio_resume_after_idle(void)
1428 {
1429         int i;
1430         int min = 0;
1431
1432         if (cpu_is_omap34xx())
1433                 min = 1;
1434         for (i = min; i < gpio_bank_count; i++) {
1435                 struct gpio_bank *bank = &gpio_bank[i];
1436                 void __iomem *reg;
1437                 u32 l = 0, gen, gen0, gen1;
1438                 int j;
1439
1440                 for (j = 0; j < hweight_long(bank->dbck_enable_mask); j++)
1441                         clk_enable(bank->dbck);
1442
1443                 if (bank->dbck_enable_mask != 0) {
1444                         reg = bank->base + bank->regs->debounce_en;
1445                         __raw_writel(bank->dbck_enable_mask, reg);
1446                         /* clear irqs that could come from glitches
1447                          * because debounce was disabled */
1448                         reg = bank->base + bank->regs->irqstatus;
1449                         gen = __raw_readl(reg) & ~bank->saved_irqstatus;
1450                         reg = bank->base + bank->regs->datain;
1451                         l = __raw_readl(reg) ^ bank->saved_datain;
1452                         l = gen & ~l;
1453                         l = l & bank->dbck_enable_mask & ~bank->level_mask;
1454                         if (l)
1455                                 _clear_gpio_irqbank(bank, l);
1456                 }
1457
1458                 if (!workaround_enabled)
1459                         continue;
1460
1461                 if (!(bank->enabled_non_wakeup_gpios))
1462                         continue;
1463
1464                 if (cpu_is_omap24xx() || cpu_is_omap34xx()) {
1465                         __raw_writel(bank->saved_fallingdetect,
1466                                  bank->base + OMAP24XX_GPIO_FALLINGDETECT);
1467                         __raw_writel(bank->saved_risingdetect,
1468                                  bank->base + OMAP24XX_GPIO_RISINGDETECT);
1469                         l = __raw_readl(bank->base + OMAP24XX_GPIO_DATAIN);
1470                 }
1471
1472                 if (cpu_is_omap44xx()) {
1473                         __raw_writel(bank->saved_fallingdetect,
1474                                  bank->base + OMAP4_GPIO_FALLINGDETECT);
1475                         __raw_writel(bank->saved_risingdetect,
1476                                  bank->base + OMAP4_GPIO_RISINGDETECT);
1477                         l = __raw_readl(bank->base + OMAP4_GPIO_DATAIN);
1478                 }
1479
1480                 /* Check if any of the non-wakeup interrupt GPIOs have changed
1481                  * state.  If so, generate an IRQ by software.  This is
1482                  * horribly racy, but it's the best we can do to work around
1483                  * this silicon bug. */
1484                 l ^= bank->saved_datain;
1485                 l &= bank->enabled_non_wakeup_gpios;
1486
1487                 /*
1488                  * No need to generate IRQs for the rising edge for gpio IRQs
1489                  * configured with falling edge only; and vice versa.
1490                  */
1491                 gen0 = l & bank->saved_fallingdetect;
1492                 gen0 &= bank->saved_datain;
1493
1494                 gen1 = l & bank->saved_risingdetect;
1495                 gen1 &= ~(bank->saved_datain);
1496
1497                 /* FIXME: Consider GPIO IRQs with level detections properly! */
1498                 gen = l & (~(bank->saved_fallingdetect) &
1499                                 ~(bank->saved_risingdetect));
1500                 /* Consider all GPIO IRQs needed to be updated */
1501                 gen |= gen0 | gen1;
1502
1503                 if (gen) {
1504                         u32 old0, old1;
1505
1506                         if (cpu_is_omap24xx() || cpu_is_omap34xx()) {
1507                                 old0 = __raw_readl(bank->base +
1508                                         OMAP24XX_GPIO_LEVELDETECT0);
1509                                 old1 = __raw_readl(bank->base +
1510                                         OMAP24XX_GPIO_LEVELDETECT1);
1511                                 __raw_writel(old0 | gen, bank->base +
1512                                         OMAP24XX_GPIO_LEVELDETECT0);
1513                                 __raw_writel(old1 | gen, bank->base +
1514                                         OMAP24XX_GPIO_LEVELDETECT1);
1515                                 __raw_writel(old0, bank->base +
1516                                         OMAP24XX_GPIO_LEVELDETECT0);
1517                                 __raw_writel(old1, bank->base +
1518                                         OMAP24XX_GPIO_LEVELDETECT1);
1519                         }
1520
1521                         if (cpu_is_omap44xx()) {
1522                                 old0 = __raw_readl(bank->base +
1523                                                 OMAP4_GPIO_LEVELDETECT0);
1524                                 old1 = __raw_readl(bank->base +
1525                                                 OMAP4_GPIO_LEVELDETECT1);
1526                                 __raw_writel(old0 | l, bank->base +
1527                                                 OMAP4_GPIO_LEVELDETECT0);
1528                                 __raw_writel(old1 | l, bank->base +
1529                                                 OMAP4_GPIO_LEVELDETECT1);
1530                                 __raw_writel(old0, bank->base +
1531                                                 OMAP4_GPIO_LEVELDETECT0);
1532                                 __raw_writel(old1, bank->base +
1533                                                 OMAP4_GPIO_LEVELDETECT1);
1534                         }
1535                 }
1536         }
1537
1538 }
1539
1540 #endif
1541
1542 #ifdef CONFIG_ARCH_OMAP3
1543 /* save the registers of bank 2-6 */
1544 void omap_gpio_save_context(void)
1545 {
1546         int i;
1547
1548         /* saving banks from 2-6 only since GPIO1 is in WKUP */
1549         for (i = 1; i < gpio_bank_count; i++) {
1550                 struct gpio_bank *bank = &gpio_bank[i];
1551                 gpio_context[i].irqenable1 =
1552                         __raw_readl(bank->base + OMAP24XX_GPIO_IRQENABLE1);
1553                 gpio_context[i].irqenable2 =
1554                         __raw_readl(bank->base + OMAP24XX_GPIO_IRQENABLE2);
1555                 gpio_context[i].wake_en =
1556                         __raw_readl(bank->base + OMAP24XX_GPIO_WAKE_EN);
1557                 gpio_context[i].ctrl =
1558                         __raw_readl(bank->base + OMAP24XX_GPIO_CTRL);
1559                 gpio_context[i].oe =
1560                         __raw_readl(bank->base + OMAP24XX_GPIO_OE);
1561                 gpio_context[i].leveldetect0 =
1562                         __raw_readl(bank->base + OMAP24XX_GPIO_LEVELDETECT0);
1563                 gpio_context[i].leveldetect1 =
1564                         __raw_readl(bank->base + OMAP24XX_GPIO_LEVELDETECT1);
1565                 gpio_context[i].risingdetect =
1566                         __raw_readl(bank->base + OMAP24XX_GPIO_RISINGDETECT);
1567                 gpio_context[i].fallingdetect =
1568                         __raw_readl(bank->base + OMAP24XX_GPIO_FALLINGDETECT);
1569                 gpio_context[i].dataout =
1570                         __raw_readl(bank->base + OMAP24XX_GPIO_DATAOUT);
1571         }
1572 }
1573
1574 /* restore the required registers of bank 2-6 */
1575 void omap_gpio_restore_context(void)
1576 {
1577         int i;
1578
1579         for (i = 1; i < gpio_bank_count; i++) {
1580                 struct gpio_bank *bank = &gpio_bank[i];
1581                 __raw_writel(gpio_context[i].irqenable1,
1582                                 bank->base + OMAP24XX_GPIO_IRQENABLE1);
1583                 __raw_writel(gpio_context[i].irqenable2,
1584                                 bank->base + OMAP24XX_GPIO_IRQENABLE2);
1585                 __raw_writel(gpio_context[i].wake_en,
1586                                 bank->base + OMAP24XX_GPIO_WAKE_EN);
1587                 __raw_writel(gpio_context[i].ctrl,
1588                                 bank->base + OMAP24XX_GPIO_CTRL);
1589                 __raw_writel(gpio_context[i].oe,
1590                                 bank->base + OMAP24XX_GPIO_OE);
1591                 __raw_writel(gpio_context[i].leveldetect0,
1592                                 bank->base + OMAP24XX_GPIO_LEVELDETECT0);
1593                 __raw_writel(gpio_context[i].leveldetect1,
1594                                 bank->base + OMAP24XX_GPIO_LEVELDETECT1);
1595                 __raw_writel(gpio_context[i].risingdetect,
1596                                 bank->base + OMAP24XX_GPIO_RISINGDETECT);
1597                 __raw_writel(gpio_context[i].fallingdetect,
1598                                 bank->base + OMAP24XX_GPIO_FALLINGDETECT);
1599                 __raw_writel(gpio_context[i].dataout,
1600                                 bank->base + OMAP24XX_GPIO_DATAOUT);
1601         }
1602 }
1603 #endif
1604
1605 static struct platform_driver omap_gpio_driver = {
1606         .probe          = omap_gpio_probe,
1607         .driver         = {
1608                 .name   = "omap_gpio",
1609         },
1610 };
1611
1612 /*
1613  * gpio driver register needs to be done before
1614  * machine_init functions access gpio APIs.
1615  * Hence omap_gpio_drv_reg() is a postcore_initcall.
1616  */
1617 static int __init omap_gpio_drv_reg(void)
1618 {
1619         return platform_driver_register(&omap_gpio_driver);
1620 }
1621 postcore_initcall(omap_gpio_drv_reg);
1622
1623 static int __init omap_gpio_sysinit(void)
1624 {
1625         mpuio_init();
1626
1627 #if defined(CONFIG_ARCH_OMAP16XX) || defined(CONFIG_ARCH_OMAP2PLUS)
1628         if (cpu_is_omap16xx() || cpu_class_is_omap2())
1629                 register_syscore_ops(&omap_gpio_syscore_ops);
1630 #endif
1631
1632         return 0;
1633 }
1634
1635 arch_initcall(omap_gpio_sysinit);