6 files changed, 140 insertions, 35 deletions

diff --git a/arch/arm/mach-ixp2000/Kconfig b/arch/arm/mach-ixp2000/Kconfig
index 9361e05f6fa3..ecb58d83478e 100644
--- a/arch/arm/mach-ixp2000/Kconfig
+++ b/arch/arm/mach-ixp2000/Kconfig
@@ -54,6 +54,14 @@ config ARCH_IXDP2X01
         depends on ARCH_IXDP2401 || ARCH_IXDP2801
         default y       
 
+config IXP2000_SUPPORT_BROKEN_PCI_IO
+        bool "Support broken PCI I/O on older IXP2000s"
+        default y
+        help
+          Say 'N' here if you only intend to run your kernel on an
+          IXP2000 B0 or later model and do not need the PCI I/O
+          byteswap workaround.  Say 'Y' otherwise.
+
 endmenu
 
 endif
diff --git a/arch/arm/mach-ixp2000/core.c b/arch/arm/mach-ixp2000/core.c
index 4f3c3d5c781c..4b9d841e04c1 100644
--- a/arch/arm/mach-ixp2000/core.c
+++ b/arch/arm/mach-ixp2000/core.c
@@ -40,6 +40,8 @@
 #include <asm/mach/time.h>
 #include <asm/mach/irq.h>
 
+#include <asm/arch/gpio.h>
+
 static DEFINE_SPINLOCK(ixp2000_slowport_lock);
 static unsigned long ixp2000_slowport_irq_flags;
 
@@ -101,6 +103,11 @@ static struct map_desc ixp2000_io_desc[] __initdata = {
                 .length         = IXP2000_PCI_CSR_SIZE,
                 .type           = MT_DEVICE
         }, {
+                .virtual        = IXP2000_MSF_VIRT_BASE,
+                .physical       = IXP2000_MSF_PHYS_BASE,
+                .length         = IXP2000_MSF_SIZE,
+                .type           = MT_DEVICE
+        }, {
                 .virtual        = IXP2000_PCI_IO_VIRT_BASE,
                 .physical       = IXP2000_PCI_IO_PHYS_BASE,
                 .length         = IXP2000_PCI_IO_SIZE,
@@ -162,12 +169,13 @@ void __init ixp2000_map_io(void)
 static unsigned ticks_per_jiffy;
 static unsigned ticks_per_usec;
 static unsigned next_jiffy_time;
+static volatile unsigned long *missing_jiffy_timer_csr;
 
 unsigned long ixp2000_gettimeoffset (void)
 {
         unsigned long offset;
 
-        offset = next_jiffy_time - *IXP2000_T4_CSR;
+        offset = next_jiffy_time - *missing_jiffy_timer_csr;
 
         return offset / ticks_per_usec;
 }
@@ -178,8 +186,8 @@ static int ixp2000_timer_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 
         /* clear timer 1 */
         ixp2000_reg_write(IXP2000_T1_CLR, 1);
-        
-        while ((next_jiffy_time - *IXP2000_T4_CSR) > ticks_per_jiffy) {
+
+        while ((next_jiffy_time - *missing_jiffy_timer_csr) > ticks_per_jiffy) {
                 timer_tick(regs);
                 next_jiffy_time -= ticks_per_jiffy;
         }
@@ -191,26 +199,43 @@ static int ixp2000_timer_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 
 static struct irqaction ixp2000_timer_irq = {
         .name           = "IXP2000 Timer Tick",
-        .flags          = SA_INTERRUPT,
-        .handler        = ixp2000_timer_interrupt
+        .flags          = SA_INTERRUPT | SA_TIMER,
+        .handler        = ixp2000_timer_interrupt,
 };
 
 void __init ixp2000_init_time(unsigned long tick_rate)
 {
-        ixp2000_reg_write(IXP2000_T1_CLR, 0);
-        ixp2000_reg_write(IXP2000_T4_CLR, 0);
-
         ticks_per_jiffy = (tick_rate + HZ/2) / HZ;
         ticks_per_usec = tick_rate / 1000000;
 
+        /*
+         * We use timer 1 as our timer interrupt.
+         */
+        ixp2000_reg_write(IXP2000_T1_CLR, 0);
         ixp2000_reg_write(IXP2000_T1_CLD, ticks_per_jiffy - 1);
         ixp2000_reg_write(IXP2000_T1_CTL, (1 << 7));
 
         /*
-         * We use T4 as a monotonic counter to track missed jiffies
+         * We use a second timer as a monotonic counter for tracking
+         * missed jiffies.  The IXP2000 has four timers, but if we're
+         * on an A-step IXP2800, timer 2 and 3 don't work, so on those
+         * chips we use timer 4.  Timer 4 is the only timer that can
+         * be used for the watchdog, so we use timer 2 if we're on a
+         * non-buggy chip.
          */
-        ixp2000_reg_write(IXP2000_T4_CLD, -1);
-        ixp2000_reg_write(IXP2000_T4_CTL, (1 << 7));
+        if ((*IXP2000_PRODUCT_ID & 0x001ffef0) == 0x00000000) {
+                printk(KERN_INFO "Enabling IXP2800 erratum #25 workaround\n");
+
+                ixp2000_reg_write(IXP2000_T4_CLR, 0);
+                ixp2000_reg_write(IXP2000_T4_CLD, -1);
+                ixp2000_reg_write(IXP2000_T4_CTL, (1 << 7));
+                missing_jiffy_timer_csr = IXP2000_T4_CSR;
+        } else {
+                ixp2000_reg_write(IXP2000_T2_CLR, 0);
+                ixp2000_reg_write(IXP2000_T2_CLD, -1);
+                ixp2000_reg_write(IXP2000_T2_CTL, (1 << 7));
+                missing_jiffy_timer_csr = IXP2000_T2_CSR;
+        }
         next_jiffy_time = 0xffffffff;
 
         /* register for interrupt */
@@ -220,35 +245,40 @@ void __init ixp2000_init_time(unsigned long tick_rate)
 /*************************************************************************
  * GPIO helpers
  *************************************************************************/
-static unsigned long GPIO_IRQ_rising_edge;
 static unsigned long GPIO_IRQ_falling_edge;
+static unsigned long GPIO_IRQ_rising_edge;
 static unsigned long GPIO_IRQ_level_low;
 static unsigned long GPIO_IRQ_level_high;
 
-void gpio_line_config(int line, int style)
+static void update_gpio_int_csrs(void)
+{
+        ixp2000_reg_write(IXP2000_GPIO_FEDR, GPIO_IRQ_falling_edge);
+        ixp2000_reg_write(IXP2000_GPIO_REDR, GPIO_IRQ_rising_edge);
+        ixp2000_reg_write(IXP2000_GPIO_LSLR, GPIO_IRQ_level_low);
+        ixp2000_reg_write(IXP2000_GPIO_LSHR, GPIO_IRQ_level_high);
+}
+
+void gpio_line_config(int line, int direction)
 {
         unsigned long flags;
 
         local_irq_save(flags);
+        if (direction == GPIO_OUT) {
+                irq_desc[line + IRQ_IXP2000_GPIO0].valid = 0;
 
-        if(style == GPIO_OUT) {
                 /* if it's an output, it ain't an interrupt anymore */
-                ixp2000_reg_write(IXP2000_GPIO_PDSR, (1 << line));
                 GPIO_IRQ_falling_edge &= ~(1 << line);
                 GPIO_IRQ_rising_edge &= ~(1 << line);
                 GPIO_IRQ_level_low &= ~(1 << line);
                 GPIO_IRQ_level_high &= ~(1 << line);
-                ixp2000_reg_write(IXP2000_GPIO_FEDR, GPIO_IRQ_falling_edge);
-                ixp2000_reg_write(IXP2000_GPIO_REDR, GPIO_IRQ_rising_edge);
-                ixp2000_reg_write(IXP2000_GPIO_LSHR, GPIO_IRQ_level_high);
-                ixp2000_reg_write(IXP2000_GPIO_LSLR, GPIO_IRQ_level_low);
-                irq_desc[line+IRQ_IXP2000_GPIO0].valid = 0;
-        } else if(style == GPIO_IN) {
-                ixp2000_reg_write(IXP2000_GPIO_PDCR, (1 << line));
+                update_gpio_int_csrs();
+
+                ixp2000_reg_write(IXP2000_GPIO_PDSR, 1 << line);
+        } else if (direction == GPIO_IN) {
+                ixp2000_reg_write(IXP2000_GPIO_PDCR, 1 << line);
         }
-                
         local_irq_restore(flags);
-}       
+}
 
 
 /*************************************************************************
@@ -267,9 +297,50 @@ static void ixp2000_GPIO_irq_handler(unsigned int irq, struct irqdesc *desc, str
         }
 }
 
+static int ixp2000_GPIO_irq_type(unsigned int irq, unsigned int type)
+{
+        int line = irq - IRQ_IXP2000_GPIO0;
+
+        /*
+         * First, configure this GPIO line as an input.
+         */
+        ixp2000_reg_write(IXP2000_GPIO_PDCR, 1 << line);
+
+        /*
+         * Then, set the proper trigger type.
+         */
+        if (type & IRQT_FALLING)
+                GPIO_IRQ_falling_edge |= 1 << line;
+        else
+                GPIO_IRQ_falling_edge &= ~(1 << line);
+        if (type & IRQT_RISING)
+                GPIO_IRQ_rising_edge |= 1 << line;
+        else
+                GPIO_IRQ_rising_edge &= ~(1 << line);
+        if (type & IRQT_LOW)
+                GPIO_IRQ_level_low |= 1 << line;
+        else
+                GPIO_IRQ_level_low &= ~(1 << line);
+        if (type & IRQT_HIGH)
+                GPIO_IRQ_level_high |= 1 << line;
+        else
+                GPIO_IRQ_level_high &= ~(1 << line);
+        update_gpio_int_csrs();
+
+        /*
+         * Finally, mark the corresponding IRQ as valid.
+         */
+        irq_desc[irq].valid = 1;
+
+        return 0;
+}
+
 static void ixp2000_GPIO_irq_mask_ack(unsigned int irq)
 {
         ixp2000_reg_write(IXP2000_GPIO_INCR, (1 << (irq - IRQ_IXP2000_GPIO0)));
+
+        ixp2000_reg_write(IXP2000_GPIO_EDSR, (1 << (irq - IRQ_IXP2000_GPIO0)));
+        ixp2000_reg_write(IXP2000_GPIO_LDSR, (1 << (irq - IRQ_IXP2000_GPIO0)));
         ixp2000_reg_write(IXP2000_GPIO_INST, (1 << (irq - IRQ_IXP2000_GPIO0)));
 }
 
@@ -284,6 +355,7 @@ static void ixp2000_GPIO_irq_unmask(unsigned int irq)
 }
 
 static struct irqchip ixp2000_GPIO_irq_chip = {
+        .type   = ixp2000_GPIO_irq_type,
         .ack    = ixp2000_GPIO_irq_mask_ack,
         .mask   = ixp2000_GPIO_irq_mask,
         .unmask = ixp2000_GPIO_irq_unmask
@@ -320,7 +392,7 @@ static void ixp2000_irq_mask(unsigned int irq)
 
 static void ixp2000_irq_unmask(unsigned int irq)
 {
-        ixp2000_reg_write(IXP2000_IRQ_ENABLE_SET,  (1 << irq));
+        ixp2000_reg_write(IXP2000_IRQ_ENABLE_SET, (1 << irq));
 }
 
 static struct irqchip ixp2000_irq_chip = {
@@ -357,16 +429,16 @@ void __init ixp2000_init_irq(void)
          * our mask/unmask code much simpler.
          */
         for (irq = IRQ_IXP2000_SOFT_INT; irq <= IRQ_IXP2000_THDB3; irq++) {
-                if((1 << irq) & IXP2000_VALID_IRQ_MASK) {
+                if ((1 << irq) & IXP2000_VALID_IRQ_MASK) {
                         set_irq_chip(irq, &ixp2000_irq_chip);
                         set_irq_handler(irq, do_level_IRQ);
                         set_irq_flags(irq, IRQF_VALID);
                 } else set_irq_flags(irq, 0);
         }
-        
+
         /*
          * GPIO IRQs are invalid until someone sets the interrupt mode
-         * by calling gpio_line_set();
+         * by calling set_irq_type().
          */
         for (irq = IRQ_IXP2000_GPIO0; irq <= IRQ_IXP2000_GPIO7; irq++) {
                 set_irq_chip(irq, &ixp2000_GPIO_irq_chip);
diff --git a/arch/arm/mach-ixp2000/enp2611.c b/arch/arm/mach-ixp2000/enp2611.c
index 04b38bcf9aac..f3a291b6a9fb 100644
--- a/arch/arm/mach-ixp2000/enp2611.c
+++ b/arch/arm/mach-ixp2000/enp2611.c
@@ -197,8 +197,23 @@ static struct platform_device enp2611_flash = {
         .resource       = &enp2611_flash_resource,
 };
 
+static struct ixp2000_i2c_pins enp2611_i2c_gpio_pins = {
+        .sda_pin        = ENP2611_GPIO_SDA,
+        .scl_pin        = ENP2611_GPIO_SCL,
+};
+
+static struct platform_device enp2611_i2c_controller = {
+        .name           = "IXP2000-I2C",
+        .id             = 0,
+        .dev            = {
+                .platform_data = &enp2611_i2c_gpio_pins
+        },
+        .num_resources  = 0
+};
+
 static struct platform_device *enp2611_devices[] __initdata = {
-        &enp2611_flash
+        &enp2611_flash,
+        &enp2611_i2c_controller
 };
 
 static void __init enp2611_init_machine(void)
diff --git a/arch/arm/mach-ixp2000/ixdp2800.c b/arch/arm/mach-ixp2000/ixdp2800.c
index aec13c7108a9..468a4bbfb724 100644
--- a/arch/arm/mach-ixp2000/ixdp2800.c
+++ b/arch/arm/mach-ixp2000/ixdp2800.c
@@ -42,12 +42,6 @@
 #include <asm/mach/flash.h>
 #include <asm/mach/arch.h>
 
-
-void ixdp2400_init_irq(void)
-{
-        ixdp2x00_init_irq(IXDP2800_CPLD_INT_STAT, IXDP2800_CPLD_INT_MASK, IXDP2400_NR_IRQS);
-}
-
 /*************************************************************************
  * IXDP2800 timer tick
  *************************************************************************/
diff --git a/arch/arm/mach-ixp2000/ixdp2x00.c b/arch/arm/mach-ixp2000/ixdp2x00.c
index 21c41fe15b99..5e4380747b53 100644
--- a/arch/arm/mach-ixp2000/ixdp2x00.c
+++ b/arch/arm/mach-ixp2000/ixdp2x00.c
@@ -42,6 +42,9 @@
 #include <asm/mach/flash.h>
 #include <asm/mach/arch.h>
 
+#include <asm/arch/gpio.h>
+
+
 /*************************************************************************
  * IXDP2x00 IRQ Initialization
  *************************************************************************/
diff --git a/arch/arm/mach-ixp2000/pci.c b/arch/arm/mach-ixp2000/pci.c
index 5ff2f2718c58..0788fb2b5c10 100644
--- a/arch/arm/mach-ixp2000/pci.c
+++ b/arch/arm/mach-ixp2000/pci.c
@@ -198,6 +198,19 @@ clear_master_aborts(void)
 void __init
 ixp2000_pci_preinit(void)
 {
+#ifndef CONFIG_IXP2000_SUPPORT_BROKEN_PCI_IO
+        /*
+         * Configure the PCI unit to properly byteswap I/O transactions,
+         * and verify that it worked.
+         */
+        ixp2000_reg_write(IXP2000_PCI_CONTROL,
+                          (*IXP2000_PCI_CONTROL | PCI_CONTROL_IEE));
+
+        if ((*IXP2000_PCI_CONTROL & PCI_CONTROL_IEE) == 0)
+                panic("IXP2000: PCI I/O is broken on this ixp model, and "
+                        "the needed workaround has not been configured in");
+#endif
+
         hook_fault_code(16+6, ixp2000_pci_abort_handler, SIGBUS,
                                 "PCI config cycle to non-existent device");
 }