drivers/gpio/gpio-pxa.c

   1 /*
   2  *  linux/arch/arm/plat-pxa/gpio.c
   3  *
   4  *  Generic PXA GPIO handling
   5  *
   6  *  Author:     Nicolas Pitre
   7  *  Created:    Jun 15, 2001
   8  *  Copyright:  MontaVista Software Inc.
   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 #include <linux/module.h>
  15 #include <linux/clk.h>
  16 #include <linux/err.h>
  17 #include <linux/gpio.h>
  18 #include <linux/gpio-pxa.h>
  19 #include <linux/init.h>
  20 #include <linux/irq.h>
  21 #include <linux/irqdomain.h>
  22 #include <linux/io.h>
  23 #include <linux/of.h>
  24 #include <linux/of_device.h>
  25 #include <linux/platform_device.h>
  26 #include <linux/syscore_ops.h>
  27 #include <linux/slab.h>
  28
  29 #include <asm/mach/irq.h>
  30
  31 #include <mach/irqs.h>
  32
  33 /*
  34  * We handle the GPIOs by banks, each bank covers up to 32 GPIOs with
  35  * one set of registers. The register offsets are organized below:
  36  *
  37  *           GPLR    GPDR    GPSR    GPCR    GRER    GFER    GEDR
  38  * BANK 0 - 0x0000  0x000C  0x0018  0x0024  0x0030  0x003C  0x0048
  39  * BANK 1 - 0x0004  0x0010  0x001C  0x0028  0x0034  0x0040  0x004C
  40  * BANK 2 - 0x0008  0x0014  0x0020  0x002C  0x0038  0x0044  0x0050
  41  *
  42  * BANK 3 - 0x0100  0x010C  0x0118  0x0124  0x0130  0x013C  0x0148
  43  * BANK 4 - 0x0104  0x0110  0x011C  0x0128  0x0134  0x0140  0x014C
  44  * BANK 5 - 0x0108  0x0114  0x0120  0x012C  0x0138  0x0144  0x0150
  45  *
  46  * NOTE:
  47  *   BANK 3 is only available on PXA27x and later processors.
  48  *   BANK 4 and 5 are only available on PXA935
  49  */
  50
  51 #define GPLR_OFFSET     0x00
  52 #define GPDR_OFFSET     0x0C
  53 #define GPSR_OFFSET     0x18
  54 #define GPCR_OFFSET     0x24
  55 #define GRER_OFFSET     0x30
  56 #define GFER_OFFSET     0x3C
  57 #define GEDR_OFFSET     0x48
  58 #define GAFR_OFFSET     0x54
  59 #define ED_MASK_OFFSET  0x9C    /* GPIO edge detection for AP side */
  60
  61 #define BANK_OFF(n)     (((n) < 3) ? (n) << 2 : 0x100 + (((n) - 3) << 2))
  62
  63 int pxa_last_gpio;
  64 static int irq_base;
  65
  66 #ifdef CONFIG_OF
  67 static struct irq_domain *domain;
  68 static struct device_node *pxa_gpio_of_node;
  69 #endif
  70
  71 struct pxa_gpio_chip {
  72         struct gpio_chip chip;
  73         void __iomem    *regbase;
  74         char label[10];
  75
  76         unsigned long   irq_mask;
  77         unsigned long   irq_edge_rise;
  78         unsigned long   irq_edge_fall;
  79         int (*set_wake)(unsigned int gpio, unsigned int on);
  80
  81 #ifdef CONFIG_PM
  82         unsigned long   saved_gplr;
  83         unsigned long   saved_gpdr;
  84         unsigned long   saved_grer;
  85         unsigned long   saved_gfer;
  86 #endif
  87 };
  88
  89 enum {
  90         PXA25X_GPIO = 0,
  91         PXA26X_GPIO,
  92         PXA27X_GPIO,
  93         PXA3XX_GPIO,
  94         PXA93X_GPIO,
  95         MMP_GPIO = 0x10,
  96 };
  97
  98 static DEFINE_SPINLOCK(gpio_lock);
  99 static struct pxa_gpio_chip *pxa_gpio_chips;
 100 static int gpio_type;
 101 static void __iomem *gpio_reg_base;
 102
 103 #define for_each_gpio_chip(i, c)                        \
 104         for (i = 0, c = &pxa_gpio_chips[0]; i <= pxa_last_gpio; i += 32, c++)
 105
 106 static inline void __iomem *gpio_chip_base(struct gpio_chip *c)
 107 {
 108         return container_of(c, struct pxa_gpio_chip, chip)->regbase;
 109 }
 110
 111 static inline struct pxa_gpio_chip *gpio_to_pxachip(unsigned gpio)
 112 {
 113         return &pxa_gpio_chips[gpio_to_bank(gpio)];
 114 }
 115
 116 static inline int gpio_is_pxa_type(int type)
 117 {
 118         return (type & MMP_GPIO) == 0;
 119 }
 120
 121 static inline int gpio_is_mmp_type(int type)
 122 {
 123         return (type & MMP_GPIO) != 0;
 124 }
 125
 126 /* GPIO86/87/88/89 on PXA26x have their direction bits in PXA_GPDR(2 inverted,
 127  * as well as their Alternate Function value being '1' for GPIO in GAFRx.
 128  */
 129 static inline int __gpio_is_inverted(int gpio)
 130 {
 131         if ((gpio_type == PXA26X_GPIO) && (gpio > 85))
 132                 return 1;
 133         return 0;
 134 }
 135
 136 /*
 137  * On PXA25x and PXA27x, GAFRx and GPDRx together decide the alternate
 138  * function of a GPIO, and GPDRx cannot be altered once configured. It
 139  * is attributed as "occupied" here (I know this terminology isn't
 140  * accurate, you are welcome to propose a better one :-)
 141  */
 142 static inline int __gpio_is_occupied(unsigned gpio)
 143 {
 144         struct pxa_gpio_chip *pxachip;
 145         void __iomem *base;
 146         unsigned long gafr = 0, gpdr = 0;
 147         int ret, af = 0, dir = 0;
 148
 149         pxachip = gpio_to_pxachip(gpio);
 150         base = gpio_chip_base(&pxachip->chip);
 151         gpdr = readl_relaxed(base + GPDR_OFFSET);
 152
 153         switch (gpio_type) {
 154         case PXA25X_GPIO:
 155         case PXA26X_GPIO:
 156         case PXA27X_GPIO:
 157                 gafr = readl_relaxed(base + GAFR_OFFSET);
 158                 af = (gafr >> ((gpio & 0xf) * 2)) & 0x3;
 159                 dir = gpdr & GPIO_bit(gpio);
 160
 161                 if (__gpio_is_inverted(gpio))
 162                         ret = (af != 1) || (dir == 0);
 163                 else
 164                         ret = (af != 0) || (dir != 0);
 165                 break;
 166         default:
 167                 ret = gpdr & GPIO_bit(gpio);
 168                 break;
 169         }
 170         return ret;
 171 }
 172
 173 static int pxa_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
 174 {
 175         return chip->base + offset + irq_base;
 176 }
 177
 178 int pxa_irq_to_gpio(int irq)
 179 {
 180         return irq - irq_base;
 181 }
 182
 183 static int pxa_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
 184 {
 185         void __iomem *base = gpio_chip_base(chip);
 186         uint32_t value, mask = 1 << offset;
 187         unsigned long flags;
 188
 189         spin_lock_irqsave(&gpio_lock, flags);
 190
 191         value = readl_relaxed(base + GPDR_OFFSET);
 192         if (__gpio_is_inverted(chip->base + offset))
 193                 value |= mask;
 194         else
 195                 value &= ~mask;
 196         writel_relaxed(value, base + GPDR_OFFSET);
 197
 198         spin_unlock_irqrestore(&gpio_lock, flags);
 199         return 0;
 200 }
 201
 202 static int pxa_gpio_direction_output(struct gpio_chip *chip,
 203                                      unsigned offset, int value)
 204 {
 205         void __iomem *base = gpio_chip_base(chip);
 206         uint32_t tmp, mask = 1 << offset;
 207         unsigned long flags;
 208
 209         writel_relaxed(mask, base + (value ? GPSR_OFFSET : GPCR_OFFSET));
 210
 211         spin_lock_irqsave(&gpio_lock, flags);
 212
 213         tmp = readl_relaxed(base + GPDR_OFFSET);
 214         if (__gpio_is_inverted(chip->base + offset))
 215                 tmp &= ~mask;
 216         else
 217                 tmp |= mask;
 218         writel_relaxed(tmp, base + GPDR_OFFSET);
 219
 220         spin_unlock_irqrestore(&gpio_lock, flags);
 221         return 0;
 222 }
 223
 224 static int pxa_gpio_get(struct gpio_chip *chip, unsigned offset)
 225 {
 226         return readl_relaxed(gpio_chip_base(chip) + GPLR_OFFSET) & (1 << offset);
 227 }
 228
 229 static void pxa_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 230 {
 231         writel_relaxed(1 << offset, gpio_chip_base(chip) +
 232                                 (value ? GPSR_OFFSET : GPCR_OFFSET));
 233 }
 234
 235 #ifdef CONFIG_OF_GPIO
 236 static int pxa_gpio_of_xlate(struct gpio_chip *gc,
 237                              const struct of_phandle_args *gpiospec,
 238                              u32 *flags)
 239 {
 240         if (gpiospec->args[0] > pxa_last_gpio)
 241                 return -EINVAL;
 242
 243         if (gc != &pxa_gpio_chips[gpiospec->args[0] / 32].chip)
 244                 return -EINVAL;
 245
 246         if (flags)
 247                 *flags = gpiospec->args[1];
 248
 249         return gpiospec->args[0] % 32;
 250 }
 251 #endif
 252
 253 static int __devinit pxa_init_gpio_chip(int gpio_end,
 254                                         int (*set_wake)(unsigned int, unsigned int))
 255 {
 256         int i, gpio, nbanks = gpio_to_bank(gpio_end) + 1;
 257         struct pxa_gpio_chip *chips;
 258
 259         chips = kzalloc(nbanks * sizeof(struct pxa_gpio_chip), GFP_KERNEL);
 260         if (chips == NULL) {
 261                 pr_err("%s: failed to allocate GPIO chips\n", __func__);
 262                 return -ENOMEM;
 263         }
 264
 265         for (i = 0, gpio = 0; i < nbanks; i++, gpio += 32) {
 266                 struct gpio_chip *c = &chips[i].chip;
 267
 268                 sprintf(chips[i].label, "gpio-%d", i);
 269                 chips[i].regbase = gpio_reg_base + BANK_OFF(i);
 270                 chips[i].set_wake = set_wake;
 271
 272                 c->base  = gpio;
 273                 c->label = chips[i].label;
 274
 275                 c->direction_input  = pxa_gpio_direction_input;
 276                 c->direction_output = pxa_gpio_direction_output;
 277                 c->get = pxa_gpio_get;
 278                 c->set = pxa_gpio_set;
 279                 c->to_irq = pxa_gpio_to_irq;
 280 #ifdef CONFIG_OF_GPIO
 281                 c->of_node = pxa_gpio_of_node;
 282                 c->of_xlate = pxa_gpio_of_xlate;
 283                 c->of_gpio_n_cells = 2;
 284 #endif
 285
 286                 /* number of GPIOs on last bank may be less than 32 */
 287                 c->ngpio = (gpio + 31 > gpio_end) ? (gpio_end - gpio + 1) : 32;
 288                 gpiochip_add(c);
 289         }
 290         pxa_gpio_chips = chips;
 291         return 0;
 292 }
 293
 294 /* Update only those GRERx and GFERx edge detection register bits if those
 295  * bits are set in c->irq_mask
 296  */
 297 static inline void update_edge_detect(struct pxa_gpio_chip *c)
 298 {
 299         uint32_t grer, gfer;
 300
 301         grer = readl_relaxed(c->regbase + GRER_OFFSET) & ~c->irq_mask;
 302         gfer = readl_relaxed(c->regbase + GFER_OFFSET) & ~c->irq_mask;
 303         grer |= c->irq_edge_rise & c->irq_mask;
 304         gfer |= c->irq_edge_fall & c->irq_mask;
 305         writel_relaxed(grer, c->regbase + GRER_OFFSET);
 306         writel_relaxed(gfer, c->regbase + GFER_OFFSET);
 307 }
 308
 309 static int pxa_gpio_irq_type(struct irq_data *d, unsigned int type)
 310 {
 311         struct pxa_gpio_chip *c;
 312         int gpio = pxa_irq_to_gpio(d->irq);
 313         unsigned long gpdr, mask = GPIO_bit(gpio);
 314
 315         c = gpio_to_pxachip(gpio);
 316
 317         if (type == IRQ_TYPE_PROBE) {
 318                 /* Don't mess with enabled GPIOs using preconfigured edges or
 319                  * GPIOs set to alternate function or to output during probe
 320                  */
 321                 if ((c->irq_edge_rise | c->irq_edge_fall) & GPIO_bit(gpio))
 322                         return 0;
 323
 324                 if (__gpio_is_occupied(gpio))
 325                         return 0;
 326
 327                 type = IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING;
 328         }
 329
 330         gpdr = readl_relaxed(c->regbase + GPDR_OFFSET);
 331
 332         if (__gpio_is_inverted(gpio))
 333                 writel_relaxed(gpdr | mask,  c->regbase + GPDR_OFFSET);
 334         else
 335                 writel_relaxed(gpdr & ~mask, c->regbase + GPDR_OFFSET);
 336
 337         if (type & IRQ_TYPE_EDGE_RISING)
 338                 c->irq_edge_rise |= mask;
 339         else
 340                 c->irq_edge_rise &= ~mask;
 341
 342         if (type & IRQ_TYPE_EDGE_FALLING)
 343                 c->irq_edge_fall |= mask;
 344         else
 345                 c->irq_edge_fall &= ~mask;
 346
 347         update_edge_detect(c);
 348
 349         pr_debug("%s: IRQ%d (GPIO%d) - edge%s%s\n", __func__, d->irq, gpio,
 350                 ((type & IRQ_TYPE_EDGE_RISING)  ? " rising"  : ""),
 351                 ((type & IRQ_TYPE_EDGE_FALLING) ? " falling" : ""));
 352         return 0;
 353 }
 354
 355 static void pxa_gpio_demux_handler(unsigned int irq, struct irq_desc *desc)
 356 {
 357         struct pxa_gpio_chip *c;
 358         int loop, gpio, gpio_base, n;
 359         unsigned long gedr;
 360         struct irq_chip *chip = irq_desc_get_chip(desc);
 361
 362         chained_irq_enter(chip, desc);
 363
 364         do {
 365                 loop = 0;
 366                 for_each_gpio_chip(gpio, c) {
 367                         gpio_base = c->chip.base;
 368
 369                         gedr = readl_relaxed(c->regbase + GEDR_OFFSET);
 370                         gedr = gedr & c->irq_mask;
 371                         writel_relaxed(gedr, c->regbase + GEDR_OFFSET);
 372
 373                         n = find_first_bit(&gedr, BITS_PER_LONG);
 374                         while (n < BITS_PER_LONG) {
 375                                 loop = 1;
 376
 377                                 generic_handle_irq(gpio_to_irq(gpio_base + n));
 378                                 n = find_next_bit(&gedr, BITS_PER_LONG, n + 1);
 379                         }
 380                 }
 381         } while (loop);
 382
 383         chained_irq_exit(chip, desc);
 384 }
 385
 386 static void pxa_ack_muxed_gpio(struct irq_data *d)
 387 {
 388         int gpio = pxa_irq_to_gpio(d->irq);
 389         struct pxa_gpio_chip *c = gpio_to_pxachip(gpio);
 390
 391         writel_relaxed(GPIO_bit(gpio), c->regbase + GEDR_OFFSET);
 392 }
 393
 394 static void pxa_mask_muxed_gpio(struct irq_data *d)
 395 {
 396         int gpio = pxa_irq_to_gpio(d->irq);
 397         struct pxa_gpio_chip *c = gpio_to_pxachip(gpio);
 398         uint32_t grer, gfer;
 399
 400         c->irq_mask &= ~GPIO_bit(gpio);
 401
 402         grer = readl_relaxed(c->regbase + GRER_OFFSET) & ~GPIO_bit(gpio);
 403         gfer = readl_relaxed(c->regbase + GFER_OFFSET) & ~GPIO_bit(gpio);
 404         writel_relaxed(grer, c->regbase + GRER_OFFSET);
 405         writel_relaxed(gfer, c->regbase + GFER_OFFSET);
 406 }
 407
 408 static int pxa_gpio_set_wake(struct irq_data *d, unsigned int on)
 409 {
 410         int gpio = pxa_irq_to_gpio(d->irq);
 411         struct pxa_gpio_chip *c = gpio_to_pxachip(gpio);
 412
 413         if (c->set_wake)
 414                 return c->set_wake(gpio, on);
 415         else
 416                 return 0;
 417 }
 418
 419 static void pxa_unmask_muxed_gpio(struct irq_data *d)
 420 {
 421         int gpio = pxa_irq_to_gpio(d->irq);
 422         struct pxa_gpio_chip *c = gpio_to_pxachip(gpio);
 423
 424         c->irq_mask |= GPIO_bit(gpio);
 425         update_edge_detect(c);
 426 }
 427
 428 static struct irq_chip pxa_muxed_gpio_chip = {
 429         .name           = "GPIO",
 430         .irq_ack        = pxa_ack_muxed_gpio,
 431         .irq_mask       = pxa_mask_muxed_gpio,
 432         .irq_unmask     = pxa_unmask_muxed_gpio,
 433         .irq_set_type   = pxa_gpio_irq_type,
 434         .irq_set_wake   = pxa_gpio_set_wake,
 435 };
 436
 437 static int pxa_gpio_nums(void)
 438 {
 439         int count = 0;
 440
 441 #ifdef CONFIG_ARCH_PXA
 442         if (cpu_is_pxa25x()) {
 443 #ifdef CONFIG_CPU_PXA26x
 444                 count = 89;
 445                 gpio_type = PXA26X_GPIO;
 446 #elif defined(CONFIG_PXA25x)
 447                 count = 84;
 448                 gpio_type = PXA26X_GPIO;
 449 #endif /* CONFIG_CPU_PXA26x */
 450         } else if (cpu_is_pxa27x()) {
 451                 count = 120;
 452                 gpio_type = PXA27X_GPIO;
 453         } else if (cpu_is_pxa93x() || cpu_is_pxa95x()) {
 454                 count = 191;
 455                 gpio_type = PXA93X_GPIO;
 456         } else if (cpu_is_pxa3xx()) {
 457                 count = 127;
 458                 gpio_type = PXA3XX_GPIO;
 459         }
 460 #endif /* CONFIG_ARCH_PXA */
 461
 462 #ifdef CONFIG_ARCH_MMP
 463         if (cpu_is_pxa168() || cpu_is_pxa910()) {
 464                 count = 127;
 465                 gpio_type = MMP_GPIO;
 466         } else if (cpu_is_mmp2()) {
 467                 count = 191;
 468                 gpio_type = MMP_GPIO;
 469         }
 470 #endif /* CONFIG_ARCH_MMP */
 471         return count;
 472 }
 473
 474 #ifdef CONFIG_OF
 475 static struct of_device_id pxa_gpio_dt_ids[] = {
 476         { .compatible = "mrvl,pxa-gpio" },
 477         { .compatible = "mrvl,mmp-gpio", .data = (void *)MMP_GPIO },
 478         {}
 479 };
 480
 481 static int pxa_irq_domain_map(struct irq_domain *d, unsigned int irq,
 482                               irq_hw_number_t hw)
 483 {
 484         irq_set_chip_and_handler(irq, &pxa_muxed_gpio_chip,
 485                                  handle_edge_irq);
 486         set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
 487         return 0;
 488 }
 489
 490 const struct irq_domain_ops pxa_irq_domain_ops = {
 491         .map    = pxa_irq_domain_map,
 492         .xlate  = irq_domain_xlate_twocell,
 493 };
 494
 495 static int __devinit pxa_gpio_probe_dt(struct platform_device *pdev)
 496 {
 497         int ret, nr_banks, nr_gpios;
 498         struct device_node *prev, *next, *np = pdev->dev.of_node;
 499         const struct of_device_id *of_id =
 500                                 of_match_device(pxa_gpio_dt_ids, &pdev->dev);
 501
 502         if (!of_id) {
 503                 dev_err(&pdev->dev, "Failed to find gpio controller\n");
 504                 return -EFAULT;
 505         }
 506         gpio_type = (int)of_id->data;
 507
 508         next = of_get_next_child(np, NULL);
 509         prev = next;
 510         if (!next) {
 511                 dev_err(&pdev->dev, "Failed to find child gpio node\n");
 512                 ret = -EINVAL;
 513                 goto err;
 514         }
 515         for (nr_banks = 1; ; nr_banks++) {
 516                 next = of_get_next_child(np, prev);
 517                 if (!next)
 518                         break;
 519                 prev = next;
 520         }
 521         of_node_put(prev);
 522         nr_gpios = nr_banks << 5;
 523         pxa_last_gpio = nr_gpios - 1;
 524
 525         irq_base = irq_alloc_descs(-1, 0, nr_gpios, 0);
 526         if (irq_base < 0) {
 527                 dev_err(&pdev->dev, "Failed to allocate IRQ numbers\n");
 528                 goto err;
 529         }
 530         domain = irq_domain_add_legacy(np, nr_gpios, irq_base, 0,
 531                                        &pxa_irq_domain_ops, NULL);
 532         pxa_gpio_of_node = np;
 533         return 0;
 534 err:
 535         iounmap(gpio_reg_base);
 536         return ret;
 537 }
 538 #else
 539 #define pxa_gpio_probe_dt(pdev)         (-1)
 540 #endif
 541
 542 static int __devinit pxa_gpio_probe(struct platform_device *pdev)
 543 {
 544         struct pxa_gpio_chip *c;
 545         struct resource *res;
 546         struct clk *clk;
 547         struct pxa_gpio_platform_data *info;
 548         int gpio, irq, ret, use_of = 0;
 549         int irq0 = 0, irq1 = 0, irq_mux, gpio_offset = 0;
 550
 551         ret = pxa_gpio_probe_dt(pdev);
 552         if (ret < 0) {
 553                 pxa_last_gpio = pxa_gpio_nums();
 554 #ifdef CONFIG_ARCH_PXA
 555                 if (gpio_is_pxa_type(gpio_type))
 556                         irq_base = PXA_GPIO_TO_IRQ(0);
 557 #endif
 558 #ifdef CONFIG_ARCH_MMP
 559                 if (gpio_is_mmp_type(gpio_type))
 560                         irq_base = MMP_GPIO_TO_IRQ(0);
 561 #endif
 562         } else {
 563                 use_of = 1;
 564         }
 565
 566         if (!pxa_last_gpio)
 567                 return -EINVAL;
 568
 569         irq0 = platform_get_irq_byname(pdev, "gpio0");
 570         irq1 = platform_get_irq_byname(pdev, "gpio1");
 571         irq_mux = platform_get_irq_byname(pdev, "gpio_mux");
 572         if ((irq0 > 0 && irq1 <= 0) || (irq0 <= 0 && irq1 > 0)
 573                 || (irq_mux <= 0))
 574                 return -EINVAL;
 575         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 576         if (!res)
 577                 return -EINVAL;
 578         gpio_reg_base = ioremap(res->start, resource_size(res));
 579         if (!gpio_reg_base)
 580                 return -EINVAL;
 581
 582         if (irq0 > 0)
 583                 gpio_offset = 2;
 584
 585         clk = clk_get(&pdev->dev, NULL);
 586         if (IS_ERR(clk)) {
 587                 dev_err(&pdev->dev, "Error %ld to get gpio clock\n",
 588                         PTR_ERR(clk));
 589                 iounmap(gpio_reg_base);
 590                 return PTR_ERR(clk);
 591         }
 592         ret = clk_prepare(clk);
 593         if (ret) {
 594                 clk_put(clk);
 595                 iounmap(gpio_reg_base);
 596                 return ret;
 597         }
 598         ret = clk_enable(clk);
 599         if (ret) {
 600                 clk_unprepare(clk);
 601                 clk_put(clk);
 602                 iounmap(gpio_reg_base);
 603                 return ret;
 604         }
 605
 606         /* Initialize GPIO chips */
 607         info = dev_get_platdata(&pdev->dev);
 608         pxa_init_gpio_chip(pxa_last_gpio, info ? info->gpio_set_wake : NULL);
 609
 610         /* clear all GPIO edge detects */
 611         for_each_gpio_chip(gpio, c) {
 612                 writel_relaxed(0, c->regbase + GFER_OFFSET);
 613                 writel_relaxed(0, c->regbase + GRER_OFFSET);
 614                 writel_relaxed(~0,c->regbase + GEDR_OFFSET);
 615                 /* unmask GPIO edge detect for AP side */
 616                 if (gpio_is_mmp_type(gpio_type))
 617                         writel_relaxed(~0, c->regbase + ED_MASK_OFFSET);
 618         }
 619
 620         if (!use_of) {
 621 #ifdef CONFIG_ARCH_PXA
 622                 irq = gpio_to_irq(0);
 623                 irq_set_chip_and_handler(irq, &pxa_muxed_gpio_chip,
 624                                          handle_edge_irq);
 625                 set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
 626                 irq_set_chained_handler(IRQ_GPIO0, pxa_gpio_demux_handler);
 627
 628                 irq = gpio_to_irq(1);
 629                 irq_set_chip_and_handler(irq, &pxa_muxed_gpio_chip,
 630                                          handle_edge_irq);
 631                 set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
 632                 irq_set_chained_handler(IRQ_GPIO1, pxa_gpio_demux_handler);
 633 #endif
 634
 635                 for (irq  = gpio_to_irq(gpio_offset);
 636                         irq <= gpio_to_irq(pxa_last_gpio); irq++) {
 637                         irq_set_chip_and_handler(irq, &pxa_muxed_gpio_chip,
 638                                                  handle_edge_irq);
 639                         set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
 640                 }
 641         }
 642
 643         irq_set_chained_handler(irq_mux, pxa_gpio_demux_handler);
 644         return 0;
 645 }
 646
 647 static struct platform_driver pxa_gpio_driver = {
 648         .probe          = pxa_gpio_probe,
 649         .driver         = {
 650                 .name   = "pxa-gpio",
 651                 .of_match_table = of_match_ptr(pxa_gpio_dt_ids),
 652         },
 653 };
 654
 655 static int __init pxa_gpio_init(void)
 656 {
 657         return platform_driver_register(&pxa_gpio_driver);
 658 }
 659 postcore_initcall(pxa_gpio_init);
 660
 661 #ifdef CONFIG_PM
 662 static int pxa_gpio_suspend(void)
 663 {
 664         struct pxa_gpio_chip *c;
 665         int gpio;
 666
 667         for_each_gpio_chip(gpio, c) {
 668                 c->saved_gplr = readl_relaxed(c->regbase + GPLR_OFFSET);
 669                 c->saved_gpdr = readl_relaxed(c->regbase + GPDR_OFFSET);
 670                 c->saved_grer = readl_relaxed(c->regbase + GRER_OFFSET);
 671                 c->saved_gfer = readl_relaxed(c->regbase + GFER_OFFSET);
 672
 673                 /* Clear GPIO transition detect bits */
 674                 writel_relaxed(0xffffffff, c->regbase + GEDR_OFFSET);
 675         }
 676         return 0;
 677 }
 678
 679 static void pxa_gpio_resume(void)
 680 {
 681         struct pxa_gpio_chip *c;
 682         int gpio;
 683
 684         for_each_gpio_chip(gpio, c) {
 685                 /* restore level with set/clear */
 686                 writel_relaxed( c->saved_gplr, c->regbase + GPSR_OFFSET);
 687                 writel_relaxed(~c->saved_gplr, c->regbase + GPCR_OFFSET);
 688
 689                 writel_relaxed(c->saved_grer, c->regbase + GRER_OFFSET);
 690                 writel_relaxed(c->saved_gfer, c->regbase + GFER_OFFSET);
 691                 writel_relaxed(c->saved_gpdr, c->regbase + GPDR_OFFSET);
 692         }
 693 }
 694 #else
 695 #define pxa_gpio_suspend        NULL
 696 #define pxa_gpio_resume         NULL
 697 #endif
 698
 699 struct syscore_ops pxa_gpio_syscore_ops = {
 700         .suspend        = pxa_gpio_suspend,
 701         .resume         = pxa_gpio_resume,
 702 };
 703
 704 static int __init pxa_gpio_sysinit(void)
 705 {
 706         register_syscore_ops(&pxa_gpio_syscore_ops);
 707         return 0;
 708 }
 709 postcore_initcall(pxa_gpio_sysinit);