Merge branch 'for-linus' of git://ftp.arm.linux.org.uk/~rmk/linux-arm

Pull ARM updates from Russell King:

 - clang assembly fixes from Ard

 - optimisations and cleanups for Aurora L2 cache support

 - efficient L2 cache support for secure monitor API on Exynos SoCs

 - debug menu cleanup from Daniel Thompson to allow better behaviour for
   multiplatform kernels

 - StrongARM SA11x0 conversion to irq domains, and pxa_timer

 - kprobes updates for older ARM CPUs

 - move probes support out of arch/arm/kernel to arch/arm/probes

 - add inline asm support for the rbit (reverse bits) instruction

 - provide an ARM mode secondary CPU entry point (for Qualcomm CPUs)

 - remove the unused ARMv3 user access code

 - add driver_override support to AMBA Primecell bus

* 'for-linus' of git://ftp.arm.linux.org.uk/~rmk/linux-arm: (55 commits)
  ARM: 8256/1: driver coamba: add device binding path 'driver_override'
  ARM: 8301/1: qcom: Use secondary_startup_arm()
  ARM: 8302/1: Add a secondary_startup that assumes ARM mode
  ARM: 8300/1: teach __asmeq that r11 == fp and r12 == ip
  ARM: kprobes: Fix compilation error caused by superfluous '*'
  ARM: 8297/1: cache-l2x0: optimize aurora range operations
  ARM: 8296/1: cache-l2x0: clean up aurora cache handling
  ARM: 8284/1: sa1100: clear RCSR_SMR on resume
  ARM: 8283/1: sa1100: collie: clear PWER register on machine init
  ARM: 8282/1: sa1100: use handle_domain_irq
  ARM: 8281/1: sa1100: move GPIO-related IRQ code to gpio driver
  ARM: 8280/1: sa1100: switch to irq_domain_add_simple()
  ARM: 8279/1: sa1100: merge both GPIO irqdomains
  ARM: 8278/1: sa1100: split irq handling for low GPIOs
  ARM: 8291/1: replace magic number with PAGE_SHIFT macro in fixup_pv code
  ARM: 8290/1: decompressor: fix a wrong comment
  ARM: 8286/1: mm: Fix dma_contiguous_reserve comment
  ARM: 8248/1: pm: remove outdated comment
  ARM: 8274/1: Fix DEBUG_LL for multi-platform kernels (without PL01X)
  ARM: 8273/1: Seperate DEBUG_UART_PHYS from DEBUG_LL on EP93XX
  ...

1 files changed, 198 insertions, 1 deletions

diff --git a/drivers/gpio/gpio-sa1100.c b/drivers/gpio/gpio-sa1100.c
index a90be34e4d5c..bec397a60204 100644
--- a/drivers/gpio/gpio-sa1100.c
+++ b/drivers/gpio/gpio-sa1100.c
@@ -11,6 +11,7 @@
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/io.h>
+#include <linux/syscore_ops.h>
 #include <mach/hardware.h>
 #include <mach/irqs.h>
 
@@ -50,7 +51,7 @@ static int sa1100_direction_output(struct gpio_chip *chip, unsigned offset, int
 
 static int sa1100_to_irq(struct gpio_chip *chip, unsigned offset)
 {
-        return offset < 11 ? (IRQ_GPIO0 + offset) : (IRQ_GPIO11 - 11 + offset);
+        return IRQ_GPIO0 + offset;
 }
 
 static struct gpio_chip sa1100_gpio_chip = {
@@ -64,7 +65,203 @@ static struct gpio_chip sa1100_gpio_chip = {
         .ngpio                  = GPIO_MAX + 1,
 };
 
+/*
+ * SA1100 GPIO edge detection for IRQs:
+ * IRQs are generated on Falling-Edge, Rising-Edge, or both.
+ * Use this instead of directly setting GRER/GFER.
+ */
+static int GPIO_IRQ_rising_edge;
+static int GPIO_IRQ_falling_edge;
+static int GPIO_IRQ_mask;
+
+static int sa1100_gpio_type(struct irq_data *d, unsigned int type)
+{
+        unsigned int mask;
+
+        mask = BIT(d->hwirq);
+
+        if (type == IRQ_TYPE_PROBE) {
+                if ((GPIO_IRQ_rising_edge | GPIO_IRQ_falling_edge) & mask)
+                        return 0;
+                type = IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING;
+        }
+
+        if (type & IRQ_TYPE_EDGE_RISING)
+                GPIO_IRQ_rising_edge |= mask;
+        else
+                GPIO_IRQ_rising_edge &= ~mask;
+        if (type & IRQ_TYPE_EDGE_FALLING)
+                GPIO_IRQ_falling_edge |= mask;
+        else
+                GPIO_IRQ_falling_edge &= ~mask;
+
+        GRER = GPIO_IRQ_rising_edge & GPIO_IRQ_mask;
+        GFER = GPIO_IRQ_falling_edge & GPIO_IRQ_mask;
+
+        return 0;
+}
+
+/*
+ * GPIO IRQs must be acknowledged.
+ */
+static void sa1100_gpio_ack(struct irq_data *d)
+{
+        GEDR = BIT(d->hwirq);
+}
+
+static void sa1100_gpio_mask(struct irq_data *d)
+{
+        unsigned int mask = BIT(d->hwirq);
+
+        GPIO_IRQ_mask &= ~mask;
+
+        GRER &= ~mask;
+        GFER &= ~mask;
+}
+
+static void sa1100_gpio_unmask(struct irq_data *d)
+{
+        unsigned int mask = BIT(d->hwirq);
+
+        GPIO_IRQ_mask |= mask;
+
+        GRER = GPIO_IRQ_rising_edge & GPIO_IRQ_mask;
+        GFER = GPIO_IRQ_falling_edge & GPIO_IRQ_mask;
+}
+
+static int sa1100_gpio_wake(struct irq_data *d, unsigned int on)
+{
+        if (on)
+                PWER |= BIT(d->hwirq);
+        else
+                PWER &= ~BIT(d->hwirq);
+        return 0;
+}
+
+/*
+ * This is for GPIO IRQs
+ */
+static struct irq_chip sa1100_gpio_irq_chip = {
+        .name           = "GPIO",
+        .irq_ack        = sa1100_gpio_ack,
+        .irq_mask       = sa1100_gpio_mask,
+        .irq_unmask     = sa1100_gpio_unmask,
+        .irq_set_type   = sa1100_gpio_type,
+        .irq_set_wake   = sa1100_gpio_wake,
+};
+
+static int sa1100_gpio_irqdomain_map(struct irq_domain *d,
+                unsigned int irq, irq_hw_number_t hwirq)
+{
+        irq_set_chip_and_handler(irq, &sa1100_gpio_irq_chip,
+                                 handle_edge_irq);
+        set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
+
+        return 0;
+}
+
+static struct irq_domain_ops sa1100_gpio_irqdomain_ops = {
+        .map = sa1100_gpio_irqdomain_map,
+        .xlate = irq_domain_xlate_onetwocell,
+};
+
+static struct irq_domain *sa1100_gpio_irqdomain;
+
+/*
+ * IRQ 0-11 (GPIO) handler.  We enter here with the
+ * irq_controller_lock held, and IRQs disabled.  Decode the IRQ
+ * and call the handler.
+ */
+static void
+sa1100_gpio_handler(unsigned int irq, struct irq_desc *desc)
+{
+        unsigned int mask;
+
+        mask = GEDR;
+        do {
+                /*
+                 * clear down all currently active IRQ sources.
+                 * We will be processing them all.
+                 */
+                GEDR = mask;
+
+                irq = IRQ_GPIO0;
+                do {
+                        if (mask & 1)
+                                generic_handle_irq(irq);
+                        mask >>= 1;
+                        irq++;
+                } while (mask);
+
+                mask = GEDR;
+        } while (mask);
+}
+
+static int sa1100_gpio_suspend(void)
+{
+        /*
+         * Set the appropriate edges for wakeup.
+         */
+        GRER = PWER & GPIO_IRQ_rising_edge;
+        GFER = PWER & GPIO_IRQ_falling_edge;
+
+        /*
+         * Clear any pending GPIO interrupts.
+         */
+        GEDR = GEDR;
+
+        return 0;
+}
+
+static void sa1100_gpio_resume(void)
+{
+        GRER = GPIO_IRQ_rising_edge & GPIO_IRQ_mask;
+        GFER = GPIO_IRQ_falling_edge & GPIO_IRQ_mask;
+}
+
+static struct syscore_ops sa1100_gpio_syscore_ops = {
+        .suspend        = sa1100_gpio_suspend,
+        .resume         = sa1100_gpio_resume,
+};
+
+static int __init sa1100_gpio_init_devicefs(void)
+{
+        register_syscore_ops(&sa1100_gpio_syscore_ops);
+        return 0;
+}
+
+device_initcall(sa1100_gpio_init_devicefs);
+
 void __init sa1100_init_gpio(void)
 {
+        /* clear all GPIO edge detects */
+        GFER = 0;
+        GRER = 0;
+        GEDR = -1;
+
         gpiochip_add(&sa1100_gpio_chip);
+
+        sa1100_gpio_irqdomain = irq_domain_add_simple(NULL,
+                        28, IRQ_GPIO0,
+                        &sa1100_gpio_irqdomain_ops, NULL);
+
+        /*
+         * Install handlers for GPIO 0-10 edge detect interrupts
+         */
+        irq_set_chained_handler(IRQ_GPIO0_SC, sa1100_gpio_handler);
+        irq_set_chained_handler(IRQ_GPIO1_SC, sa1100_gpio_handler);
+        irq_set_chained_handler(IRQ_GPIO2_SC, sa1100_gpio_handler);
+        irq_set_chained_handler(IRQ_GPIO3_SC, sa1100_gpio_handler);
+        irq_set_chained_handler(IRQ_GPIO4_SC, sa1100_gpio_handler);
+        irq_set_chained_handler(IRQ_GPIO5_SC, sa1100_gpio_handler);
+        irq_set_chained_handler(IRQ_GPIO6_SC, sa1100_gpio_handler);
+        irq_set_chained_handler(IRQ_GPIO7_SC, sa1100_gpio_handler);
+        irq_set_chained_handler(IRQ_GPIO8_SC, sa1100_gpio_handler);
+        irq_set_chained_handler(IRQ_GPIO9_SC, sa1100_gpio_handler);
+        irq_set_chained_handler(IRQ_GPIO10_SC, sa1100_gpio_handler);
+        /*
+         * Install handler for GPIO 11-27 edge detect interrupts
+         */
+        irq_set_chained_handler(IRQ_GPIO11_27, sa1100_gpio_handler);
+
 }