Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/shaggy...

[pandora-kernel.git] / arch / arm / common / locomo.c

diff --git a/arch/arm/common/locomo.c b/arch/arm/common/locomo.c
index fbc3ab0..cfe6f46 100644 (file)
--- a/arch/arm/common/locomo.c
+++ b/arch/arm/common/locomo.c
@@ -121,6 +121,13 @@ static struct locomo_dev_info locomo_devices[] = {
                .offset         = 0,
                .length         = 0,
        },
+       {
+               .devid          = LOCOMO_DEVID_SPI,
+               .irq            = {},
+               .name           = "locomo-spi",
+               .offset         = LOCOMO_SPI,
+               .length         = 0x30,
+       },
 };
 
 
@@ -156,12 +163,11 @@ static struct locomo_dev_info locomo_devices[] = {
 #define        LOCOMO_IRQ_LT_START     (IRQ_LOCOMO_LT)
 #define        LOCOMO_IRQ_SPI_START    (IRQ_LOCOMO_SPI_RFR)
 
-static void locomo_handler(unsigned int irq, struct irqdesc *desc,
-                       struct pt_regs *regs)
+static void locomo_handler(unsigned int irq, struct irq_desc *desc)
 {
        int req, i;
-       struct irqdesc *d;
-       void __iomem *mapbase = get_irq_chipdata(irq);
+       struct irq_desc *d;
+       void __iomem *mapbase = get_irq_chip_data(irq);
 
        /* Acknowledge the parent IRQ */
        desc->chip->ack(irq);
@@ -175,7 +181,7 @@ static void locomo_handler(unsigned int irq, struct irqdesc *desc,
                d = irq_desc + irq;
                for (i = 0; i <= 3; i++, d++, irq++) {
                        if (req & (0x0100 << i)) {
-                               desc_handle_irq(irq, d, regs);
+                               desc_handle_irq(irq, d);
                        }
 
                }
@@ -188,7 +194,7 @@ static void locomo_ack_irq(unsigned int irq)
 
 static void locomo_mask_irq(unsigned int irq)
 {
-       void __iomem *mapbase = get_irq_chipdata(irq);
+       void __iomem *mapbase = get_irq_chip_data(irq);
        unsigned int r;
        r = locomo_readl(mapbase + LOCOMO_ICR);
        r &= ~(0x0010 << (irq - LOCOMO_IRQ_START));
@@ -197,34 +203,34 @@ static void locomo_mask_irq(unsigned int irq)
 
 static void locomo_unmask_irq(unsigned int irq)
 {
-       void __iomem *mapbase = get_irq_chipdata(irq);
+       void __iomem *mapbase = get_irq_chip_data(irq);
        unsigned int r;
        r = locomo_readl(mapbase + LOCOMO_ICR);
        r |= (0x0010 << (irq - LOCOMO_IRQ_START));
        locomo_writel(r, mapbase + LOCOMO_ICR);
 }
 
-static struct irqchip locomo_chip = {
+static struct irq_chip locomo_chip = {
+       .name   = "LOCOMO",
        .ack    = locomo_ack_irq,
        .mask   = locomo_mask_irq,
        .unmask = locomo_unmask_irq,
 };
 
-static void locomo_key_handler(unsigned int irq, struct irqdesc *desc,
-                           struct pt_regs *regs)
+static void locomo_key_handler(unsigned int irq, struct irq_desc *desc)
 {
-       struct irqdesc *d;
-       void __iomem *mapbase = get_irq_chipdata(irq);
+       struct irq_desc *d;
+       void __iomem *mapbase = get_irq_chip_data(irq);
 
        if (locomo_readl(mapbase + LOCOMO_KEYBOARD + LOCOMO_KIC) & 0x0001) {
                d = irq_desc + LOCOMO_IRQ_KEY_START;
-               desc_handle_irq(LOCOMO_IRQ_KEY_START, d, regs);
+               desc_handle_irq(LOCOMO_IRQ_KEY_START, d);
        }
 }
 
 static void locomo_key_ack_irq(unsigned int irq)
 {
-       void __iomem *mapbase = get_irq_chipdata(irq);
+       void __iomem *mapbase = get_irq_chip_data(irq);
        unsigned int r;
        r = locomo_readl(mapbase + LOCOMO_KEYBOARD + LOCOMO_KIC);
        r &= ~(0x0100 << (irq - LOCOMO_IRQ_KEY_START));
@@ -233,7 +239,7 @@ static void locomo_key_ack_irq(unsigned int irq)
 
 static void locomo_key_mask_irq(unsigned int irq)
 {
-       void __iomem *mapbase = get_irq_chipdata(irq);
+       void __iomem *mapbase = get_irq_chip_data(irq);
        unsigned int r;
        r = locomo_readl(mapbase + LOCOMO_KEYBOARD + LOCOMO_KIC);
        r &= ~(0x0010 << (irq - LOCOMO_IRQ_KEY_START));
@@ -242,25 +248,25 @@ static void locomo_key_mask_irq(unsigned int irq)
 
 static void locomo_key_unmask_irq(unsigned int irq)
 {
-       void __iomem *mapbase = get_irq_chipdata(irq);
+       void __iomem *mapbase = get_irq_chip_data(irq);
        unsigned int r;
        r = locomo_readl(mapbase + LOCOMO_KEYBOARD + LOCOMO_KIC);
        r |= (0x0010 << (irq - LOCOMO_IRQ_KEY_START));
        locomo_writel(r, mapbase + LOCOMO_KEYBOARD + LOCOMO_KIC);
 }
 
-static struct irqchip locomo_key_chip = {
+static struct irq_chip locomo_key_chip = {
+       .name   = "LOCOMO-key",
        .ack    = locomo_key_ack_irq,
        .mask   = locomo_key_mask_irq,
        .unmask = locomo_key_unmask_irq,
 };
 
-static void locomo_gpio_handler(unsigned int irq, struct irqdesc *desc,
-                            struct pt_regs *regs)
+static void locomo_gpio_handler(unsigned int irq, struct irq_desc *desc)
 {
        int req, i;
-       struct irqdesc *d;
-       void __iomem *mapbase = get_irq_chipdata(irq);
+       struct irq_desc *d;
+       void __iomem *mapbase = get_irq_chip_data(irq);
 
        req =   locomo_readl(mapbase + LOCOMO_GIR) &
                locomo_readl(mapbase + LOCOMO_GPD) &
@@ -271,7 +277,7 @@ static void locomo_gpio_handler(unsigned int irq, struct irqdesc *desc,
                d = irq_desc + LOCOMO_IRQ_GPIO_START;
                for (i = 0; i <= 15; i++, irq++, d++) {
                        if (req & (0x0001 << i)) {
-                               desc_handle_irq(irq, d, regs);
+                               desc_handle_irq(irq, d);
                        }
                }
        }
@@ -279,7 +285,7 @@ static void locomo_gpio_handler(unsigned int irq, struct irqdesc *desc,
 
 static void locomo_gpio_ack_irq(unsigned int irq)
 {
-       void __iomem *mapbase = get_irq_chipdata(irq);
+       void __iomem *mapbase = get_irq_chip_data(irq);
        unsigned int r;
        r = locomo_readl(mapbase + LOCOMO_GWE);
        r |= (0x0001 << (irq - LOCOMO_IRQ_GPIO_START));
@@ -296,7 +302,7 @@ static void locomo_gpio_ack_irq(unsigned int irq)
 
 static void locomo_gpio_mask_irq(unsigned int irq)
 {
-       void __iomem *mapbase = get_irq_chipdata(irq);
+       void __iomem *mapbase = get_irq_chip_data(irq);
        unsigned int r;
        r = locomo_readl(mapbase + LOCOMO_GIE);
        r &= ~(0x0001 << (irq - LOCOMO_IRQ_GPIO_START));
@@ -305,34 +311,34 @@ static void locomo_gpio_mask_irq(unsigned int irq)
 
 static void locomo_gpio_unmask_irq(unsigned int irq)
 {
-       void __iomem *mapbase = get_irq_chipdata(irq);
+       void __iomem *mapbase = get_irq_chip_data(irq);
        unsigned int r;
        r = locomo_readl(mapbase + LOCOMO_GIE);
        r |= (0x0001 << (irq - LOCOMO_IRQ_GPIO_START));
        locomo_writel(r, mapbase + LOCOMO_GIE);
 }
 
-static struct irqchip locomo_gpio_chip = {
+static struct irq_chip locomo_gpio_chip = {
+       .name   = "LOCOMO-gpio",
        .ack    = locomo_gpio_ack_irq,
        .mask   = locomo_gpio_mask_irq,
        .unmask = locomo_gpio_unmask_irq,
 };
 
-static void locomo_lt_handler(unsigned int irq, struct irqdesc *desc,
-                          struct pt_regs *regs)
+static void locomo_lt_handler(unsigned int irq, struct irq_desc *desc)
 {
-       struct irqdesc *d;
-       void __iomem *mapbase = get_irq_chipdata(irq);
+       struct irq_desc *d;
+       void __iomem *mapbase = get_irq_chip_data(irq);
 
        if (locomo_readl(mapbase + LOCOMO_LTINT) & 0x0001) {
                d = irq_desc + LOCOMO_IRQ_LT_START;
-               desc_handle_irq(LOCOMO_IRQ_LT_START, d, regs);
+               desc_handle_irq(LOCOMO_IRQ_LT_START, d);
        }
 }
 
 static void locomo_lt_ack_irq(unsigned int irq)
 {
-       void __iomem *mapbase = get_irq_chipdata(irq);
+       void __iomem *mapbase = get_irq_chip_data(irq);
        unsigned int r;
        r = locomo_readl(mapbase + LOCOMO_LTINT);
        r &= ~(0x0100 << (irq - LOCOMO_IRQ_LT_START));
@@ -341,7 +347,7 @@ static void locomo_lt_ack_irq(unsigned int irq)
 
 static void locomo_lt_mask_irq(unsigned int irq)
 {
-       void __iomem *mapbase = get_irq_chipdata(irq);
+       void __iomem *mapbase = get_irq_chip_data(irq);
        unsigned int r;
        r = locomo_readl(mapbase + LOCOMO_LTINT);
        r &= ~(0x0010 << (irq - LOCOMO_IRQ_LT_START));
@@ -350,34 +356,34 @@ static void locomo_lt_mask_irq(unsigned int irq)
 
 static void locomo_lt_unmask_irq(unsigned int irq)
 {
-       void __iomem *mapbase = get_irq_chipdata(irq);
+       void __iomem *mapbase = get_irq_chip_data(irq);
        unsigned int r;
        r = locomo_readl(mapbase + LOCOMO_LTINT);
        r |= (0x0010 << (irq - LOCOMO_IRQ_LT_START));
        locomo_writel(r, mapbase + LOCOMO_LTINT);
 }
 
-static struct irqchip locomo_lt_chip = {
+static struct irq_chip locomo_lt_chip = {
+       .name   = "LOCOMO-lt",
        .ack    = locomo_lt_ack_irq,
        .mask   = locomo_lt_mask_irq,
        .unmask = locomo_lt_unmask_irq,
 };
 
-static void locomo_spi_handler(unsigned int irq, struct irqdesc *desc,
-                           struct pt_regs *regs)
+static void locomo_spi_handler(unsigned int irq, struct irq_desc *desc)
 {
        int req, i;
-       struct irqdesc *d;
-       void __iomem *mapbase = get_irq_chipdata(irq);
+       struct irq_desc *d;
+       void __iomem *mapbase = get_irq_chip_data(irq);
 
-       req = locomo_readl(mapbase + LOCOMO_SPIIR) & 0x000F;
+       req = locomo_readl(mapbase + LOCOMO_SPI + LOCOMO_SPIIR) & 0x000F;
        if (req) {
                irq = LOCOMO_IRQ_SPI_START;
                d = irq_desc + irq;
 
                for (i = 0; i <= 3; i++, irq++, d++) {
                        if (req & (0x0001 << i)) {
-                               desc_handle_irq(irq, d, regs);
+                               desc_handle_irq(irq, d);
                        }
                }
        }
@@ -385,40 +391,41 @@ static void locomo_spi_handler(unsigned int irq, struct irqdesc *desc,
 
 static void locomo_spi_ack_irq(unsigned int irq)
 {
-       void __iomem *mapbase = get_irq_chipdata(irq);
+       void __iomem *mapbase = get_irq_chip_data(irq);
        unsigned int r;
-       r = locomo_readl(mapbase + LOCOMO_SPIWE);
+       r = locomo_readl(mapbase + LOCOMO_SPI + LOCOMO_SPIWE);
        r |= (0x0001 << (irq - LOCOMO_IRQ_SPI_START));
-       locomo_writel(r, mapbase + LOCOMO_SPIWE);
+       locomo_writel(r, mapbase + LOCOMO_SPI + LOCOMO_SPIWE);
 
-       r = locomo_readl(mapbase + LOCOMO_SPIIS);
+       r = locomo_readl(mapbase + LOCOMO_SPI + LOCOMO_SPIIS);
        r &= ~(0x0001 << (irq - LOCOMO_IRQ_SPI_START));
-       locomo_writel(r, mapbase + LOCOMO_SPIIS);
+       locomo_writel(r, mapbase + LOCOMO_SPI + LOCOMO_SPIIS);
 
-       r = locomo_readl(mapbase + LOCOMO_SPIWE);
+       r = locomo_readl(mapbase + LOCOMO_SPI + LOCOMO_SPIWE);
        r &= ~(0x0001 << (irq - LOCOMO_IRQ_SPI_START));
-       locomo_writel(r, mapbase + LOCOMO_SPIWE);
+       locomo_writel(r, mapbase + LOCOMO_SPI + LOCOMO_SPIWE);
 }
 
 static void locomo_spi_mask_irq(unsigned int irq)
 {
-       void __iomem *mapbase = get_irq_chipdata(irq);
+       void __iomem *mapbase = get_irq_chip_data(irq);
        unsigned int r;
-       r = locomo_readl(mapbase + LOCOMO_SPIIE);
+       r = locomo_readl(mapbase + LOCOMO_SPI + LOCOMO_SPIIE);
        r &= ~(0x0001 << (irq - LOCOMO_IRQ_SPI_START));
-       locomo_writel(r, mapbase + LOCOMO_SPIIE);
+       locomo_writel(r, mapbase + LOCOMO_SPI + LOCOMO_SPIIE);
 }
 
 static void locomo_spi_unmask_irq(unsigned int irq)
 {
-       void __iomem *mapbase = get_irq_chipdata(irq);
+       void __iomem *mapbase = get_irq_chip_data(irq);
        unsigned int r;
-       r = locomo_readl(mapbase + LOCOMO_SPIIE);
+       r = locomo_readl(mapbase + LOCOMO_SPI + LOCOMO_SPIIE);
        r |= (0x0001 << (irq - LOCOMO_IRQ_SPI_START));
-       locomo_writel(r, mapbase + LOCOMO_SPIIE);
+       locomo_writel(r, mapbase + LOCOMO_SPI + LOCOMO_SPIIE);
 }
 
-static struct irqchip locomo_spi_chip = {
+static struct irq_chip locomo_spi_chip = {
+       .name   = "LOCOMO-spi",
        .ack    = locomo_spi_ack_irq,
        .mask   = locomo_spi_mask_irq,
        .unmask = locomo_spi_unmask_irq,
@@ -433,55 +440,55 @@ static void locomo_setup_irq(struct locomo *lchip)
         * Install handler for IRQ_LOCOMO_HW.
         */
        set_irq_type(lchip->irq, IRQT_FALLING);
-       set_irq_chipdata(lchip->irq, irqbase);
+       set_irq_chip_data(lchip->irq, irqbase);
        set_irq_chained_handler(lchip->irq, locomo_handler);
 
        /* Install handlers for IRQ_LOCOMO_*_BASE */
        set_irq_chip(IRQ_LOCOMO_KEY_BASE, &locomo_chip);
-       set_irq_chipdata(IRQ_LOCOMO_KEY_BASE, irqbase);
+       set_irq_chip_data(IRQ_LOCOMO_KEY_BASE, irqbase);
        set_irq_chained_handler(IRQ_LOCOMO_KEY_BASE, locomo_key_handler);
        set_irq_flags(IRQ_LOCOMO_KEY_BASE, IRQF_VALID | IRQF_PROBE);
 
        set_irq_chip(IRQ_LOCOMO_GPIO_BASE, &locomo_chip);
-       set_irq_chipdata(IRQ_LOCOMO_GPIO_BASE, irqbase);
+       set_irq_chip_data(IRQ_LOCOMO_GPIO_BASE, irqbase);
        set_irq_chained_handler(IRQ_LOCOMO_GPIO_BASE, locomo_gpio_handler);
        set_irq_flags(IRQ_LOCOMO_GPIO_BASE, IRQF_VALID | IRQF_PROBE);
 
        set_irq_chip(IRQ_LOCOMO_LT_BASE, &locomo_chip);
-       set_irq_chipdata(IRQ_LOCOMO_LT_BASE, irqbase);
+       set_irq_chip_data(IRQ_LOCOMO_LT_BASE, irqbase);
        set_irq_chained_handler(IRQ_LOCOMO_LT_BASE, locomo_lt_handler);
        set_irq_flags(IRQ_LOCOMO_LT_BASE, IRQF_VALID | IRQF_PROBE);
 
        set_irq_chip(IRQ_LOCOMO_SPI_BASE, &locomo_chip);
-       set_irq_chipdata(IRQ_LOCOMO_SPI_BASE, irqbase);
+       set_irq_chip_data(IRQ_LOCOMO_SPI_BASE, irqbase);
        set_irq_chained_handler(IRQ_LOCOMO_SPI_BASE, locomo_spi_handler);
        set_irq_flags(IRQ_LOCOMO_SPI_BASE, IRQF_VALID | IRQF_PROBE);
 
        /* install handlers for IRQ_LOCOMO_KEY_BASE generated interrupts */
        set_irq_chip(LOCOMO_IRQ_KEY_START, &locomo_key_chip);
-       set_irq_chipdata(LOCOMO_IRQ_KEY_START, irqbase);
-       set_irq_handler(LOCOMO_IRQ_KEY_START, do_edge_IRQ);
+       set_irq_chip_data(LOCOMO_IRQ_KEY_START, irqbase);
+       set_irq_handler(LOCOMO_IRQ_KEY_START, handle_edge_irq);
        set_irq_flags(LOCOMO_IRQ_KEY_START, IRQF_VALID | IRQF_PROBE);
 
        /* install handlers for IRQ_LOCOMO_GPIO_BASE generated interrupts */
        for (irq = LOCOMO_IRQ_GPIO_START; irq < LOCOMO_IRQ_GPIO_START + 16; irq++) {
                set_irq_chip(irq, &locomo_gpio_chip);
-               set_irq_chipdata(irq, irqbase);
-               set_irq_handler(irq, do_edge_IRQ);
+               set_irq_chip_data(irq, irqbase);
+               set_irq_handler(irq, handle_edge_irq);
                set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
        }
 
        /* install handlers for IRQ_LOCOMO_LT_BASE generated interrupts */
        set_irq_chip(LOCOMO_IRQ_LT_START, &locomo_lt_chip);
-       set_irq_chipdata(LOCOMO_IRQ_LT_START, irqbase);
-       set_irq_handler(LOCOMO_IRQ_LT_START, do_edge_IRQ);
+       set_irq_chip_data(LOCOMO_IRQ_LT_START, irqbase);
+       set_irq_handler(LOCOMO_IRQ_LT_START, handle_edge_irq);
        set_irq_flags(LOCOMO_IRQ_LT_START, IRQF_VALID | IRQF_PROBE);
 
        /* install handlers for IRQ_LOCOMO_SPI_BASE generated interrupts */
        for (irq = LOCOMO_IRQ_SPI_START; irq < LOCOMO_IRQ_SPI_START + 3; irq++) {
                set_irq_chip(irq, &locomo_spi_chip);
-               set_irq_chipdata(irq, irqbase);
-               set_irq_handler(irq, do_edge_IRQ);
+               set_irq_chip_data(irq, irqbase);
+               set_irq_handler(irq, handle_edge_irq);
                set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
        }
 }
@@ -506,7 +513,7 @@ locomo_init_one_child(struct locomo *lchip, struct locomo_dev_info *info)
                goto out;
        }
 
-       strncpy(dev->dev.bus_id,info->name,sizeof(dev->dev.bus_id));
+       strncpy(dev->dev.bus_id, info->name, sizeof(dev->dev.bus_id));
        /*
         * If the parent device has a DMA mask associated with it,
         * propagate it down to the children.
@@ -729,7 +736,6 @@ __locomo_probe(struct device *me, struct resource *mem, int irq)
 
        for (i = 0; i < ARRAY_SIZE(locomo_devices); i++)
                locomo_init_one_child(lchip, &locomo_devices[i]);
-
        return 0;
 
  out:
@@ -810,12 +816,15 @@ static inline struct locomo *locomo_chip_driver(struct locomo_dev *ldev)
        return (struct locomo *)dev_get_drvdata(ldev->dev.parent);
 }
 
-void locomo_gpio_set_dir(struct locomo_dev *ldev, unsigned int bits, unsigned int dir)
+void locomo_gpio_set_dir(struct device *dev, unsigned int bits, unsigned int dir)
 {
-       struct locomo *lchip = locomo_chip_driver(ldev);
+       struct locomo *lchip = dev_get_drvdata(dev);
        unsigned long flags;
        unsigned int r;
 
+       if (!lchip)
+               return;
+
        spin_lock_irqsave(&lchip->lock, flags);
 
        r = locomo_readl(lchip->base + LOCOMO_GPD);
@@ -832,12 +841,15 @@ void locomo_gpio_set_dir(struct locomo_dev *ldev, unsigned int bits, unsigned in
        spin_unlock_irqrestore(&lchip->lock, flags);
 }
 
-unsigned int locomo_gpio_read_level(struct locomo_dev *ldev, unsigned int bits)
+int locomo_gpio_read_level(struct device *dev, unsigned int bits)
 {
-       struct locomo *lchip = locomo_chip_driver(ldev);
+       struct locomo *lchip = dev_get_drvdata(dev);
        unsigned long flags;
        unsigned int ret;
 
+       if (!lchip)
+               return -ENODEV;
+
        spin_lock_irqsave(&lchip->lock, flags);
        ret = locomo_readl(lchip->base + LOCOMO_GPL);
        spin_unlock_irqrestore(&lchip->lock, flags);
@@ -846,12 +858,15 @@ unsigned int locomo_gpio_read_level(struct locomo_dev *ldev, unsigned int bits)
        return ret;
 }
 
-unsigned int locomo_gpio_read_output(struct locomo_dev *ldev, unsigned int bits)
+int locomo_gpio_read_output(struct device *dev, unsigned int bits)
 {
-       struct locomo *lchip = locomo_chip_driver(ldev);
+       struct locomo *lchip = dev_get_drvdata(dev);
        unsigned long flags;
        unsigned int ret;
 
+       if (!lchip)
+               return -ENODEV;
+
        spin_lock_irqsave(&lchip->lock, flags);
        ret = locomo_readl(lchip->base + LOCOMO_GPO);
        spin_unlock_irqrestore(&lchip->lock, flags);
@@ -860,12 +875,15 @@ unsigned int locomo_gpio_read_output(struct locomo_dev *ldev, unsigned int bits)
        return ret;
 }
 
-void locomo_gpio_write(struct locomo_dev *ldev, unsigned int bits, unsigned int set)
+void locomo_gpio_write(struct device *dev, unsigned int bits, unsigned int set)
 {
-       struct locomo *lchip = locomo_chip_driver(ldev);
+       struct locomo *lchip = dev_get_drvdata(dev);
        unsigned long flags;
        unsigned int r;
 
+       if (!lchip)
+               return;
+
        spin_lock_irqsave(&lchip->lock, flags);
 
        r = locomo_readl(lchip->base + LOCOMO_GPO);
@@ -1054,9 +1072,9 @@ void locomo_frontlight_set(struct locomo_dev *dev, int duty, int vr, int bpwf)
        struct locomo *lchip = locomo_chip_driver(dev);
 
        if (vr)
-               locomo_gpio_write(dev, LOCOMO_GPIO_FL_VR, 1);
+               locomo_gpio_write(dev->dev.parent, LOCOMO_GPIO_FL_VR, 1);
        else
-               locomo_gpio_write(dev, LOCOMO_GPIO_FL_VR, 0);
+               locomo_gpio_write(dev->dev.parent, LOCOMO_GPIO_FL_VR, 0);
 
        spin_lock_irqsave(&lchip->lock, flags);
        locomo_writel(bpwf, lchip->base + LOCOMO_FRONTLIGHT + LOCOMO_ALS);