git.openpandora.org / pandora-kernel.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Merge branch 'x86-geode-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git...
[pandora-kernel.git] / drivers / dma / ipu / ipu_irq.c
diff --git a/drivers/dma/ipu/ipu_irq.c b/drivers/dma/ipu/ipu_irq.c
index dd8ebc7..a71f55e 100644 (file)
--- a/drivers/dma/ipu/ipu_irq.c
+++ b/drivers/dma/ipu/ipu_irq.c
@@ -81,7 +81,7 @@ static struct ipu_irq_map irq_map[CONFIG_MX3_IPU_IRQS];
 /* Protects allocations from the above array of maps */
 static DEFINE_MUTEX(map_lock);
 /* Protects register accesses and individual mappings */
-static DEFINE_SPINLOCK(bank_lock);
+static DEFINE_RAW_SPINLOCK(bank_lock);
 
 static struct ipu_irq_map *src2map(unsigned int src)
 {
@@ -94,19 +94,19 @@ static struct ipu_irq_map *src2map(unsigned int src)
        return NULL;
 }
 
-static void ipu_irq_unmask(unsigned int irq)
+static void ipu_irq_unmask(struct irq_data *d)
 {
-       struct ipu_irq_map *map = get_irq_chip_data(irq);
+       struct ipu_irq_map *map = irq_data_get_irq_chip_data(d);
        struct ipu_irq_bank *bank;
        uint32_t reg;
        unsigned long lock_flags;
 
-       spin_lock_irqsave(&bank_lock, lock_flags);
+       raw_spin_lock_irqsave(&bank_lock, lock_flags);
 
        bank = map->bank;
        if (!bank) {
-               spin_unlock_irqrestore(&bank_lock, lock_flags);
-               pr_err("IPU: %s(%u) - unmapped!\n", __func__, irq);
+               raw_spin_unlock_irqrestore(&bank_lock, lock_flags);
+               pr_err("IPU: %s(%u) - unmapped!\n", __func__, d->irq);
                return;
        }
 
@@ -114,22 +114,22 @@ static void ipu_irq_unmask(unsigned int irq)
        reg |= (1UL << (map->source & 31));
        ipu_write_reg(bank->ipu, reg, bank->control);
 
-       spin_unlock_irqrestore(&bank_lock, lock_flags);
+       raw_spin_unlock_irqrestore(&bank_lock, lock_flags);
 }
 
-static void ipu_irq_mask(unsigned int irq)
+static void ipu_irq_mask(struct irq_data *d)
 {
-       struct ipu_irq_map *map = get_irq_chip_data(irq);
+       struct ipu_irq_map *map = irq_data_get_irq_chip_data(d);
        struct ipu_irq_bank *bank;
        uint32_t reg;
        unsigned long lock_flags;
 
-       spin_lock_irqsave(&bank_lock, lock_flags);
+       raw_spin_lock_irqsave(&bank_lock, lock_flags);
 
        bank = map->bank;
        if (!bank) {
-               spin_unlock_irqrestore(&bank_lock, lock_flags);
-               pr_err("IPU: %s(%u) - unmapped!\n", __func__, irq);
+               raw_spin_unlock_irqrestore(&bank_lock, lock_flags);
+               pr_err("IPU: %s(%u) - unmapped!\n", __func__, d->irq);
                return;
        }
 
@@ -137,26 +137,26 @@ static void ipu_irq_mask(unsigned int irq)
        reg &= ~(1UL << (map->source & 31));
        ipu_write_reg(bank->ipu, reg, bank->control);
 
-       spin_unlock_irqrestore(&bank_lock, lock_flags);
+       raw_spin_unlock_irqrestore(&bank_lock, lock_flags);
 }
 
-static void ipu_irq_ack(unsigned int irq)
+static void ipu_irq_ack(struct irq_data *d)
 {
-       struct ipu_irq_map *map = get_irq_chip_data(irq);
+       struct ipu_irq_map *map = irq_data_get_irq_chip_data(d);
        struct ipu_irq_bank *bank;
        unsigned long lock_flags;
 
-       spin_lock_irqsave(&bank_lock, lock_flags);
+       raw_spin_lock_irqsave(&bank_lock, lock_flags);
 
        bank = map->bank;
        if (!bank) {
-               spin_unlock_irqrestore(&bank_lock, lock_flags);
-               pr_err("IPU: %s(%u) - unmapped!\n", __func__, irq);
+               raw_spin_unlock_irqrestore(&bank_lock, lock_flags);
+               pr_err("IPU: %s(%u) - unmapped!\n", __func__, d->irq);
                return;
        }
 
        ipu_write_reg(bank->ipu, 1UL << (map->source & 31), bank->status);
-       spin_unlock_irqrestore(&bank_lock, lock_flags);
+       raw_spin_unlock_irqrestore(&bank_lock, lock_flags);
 }
 
 /**
@@ -167,16 +167,16 @@ static void ipu_irq_ack(unsigned int irq)
  */
 bool ipu_irq_status(unsigned int irq)
 {
-       struct ipu_irq_map *map = get_irq_chip_data(irq);
+       struct ipu_irq_map *map = irq_get_chip_data(irq);
        struct ipu_irq_bank *bank;
        unsigned long lock_flags;
        bool ret;
 
-       spin_lock_irqsave(&bank_lock, lock_flags);
+       raw_spin_lock_irqsave(&bank_lock, lock_flags);
        bank = map->bank;
        ret = bank && ipu_read_reg(bank->ipu, bank->status) &
                (1UL << (map->source & 31));
-       spin_unlock_irqrestore(&bank_lock, lock_flags);
+       raw_spin_unlock_irqrestore(&bank_lock, lock_flags);
 
        return ret;
 }
@@ -213,10 +213,10 @@ int ipu_irq_map(unsigned int source)
                if (irq_map[i].source < 0) {
                        unsigned long lock_flags;
 
-                       spin_lock_irqsave(&bank_lock, lock_flags);
+                       raw_spin_lock_irqsave(&bank_lock, lock_flags);
                        irq_map[i].source = source;
                        irq_map[i].bank = irq_bank + source / 32;
-                       spin_unlock_irqrestore(&bank_lock, lock_flags);
+                       raw_spin_unlock_irqrestore(&bank_lock, lock_flags);
 
                        ret = irq_map[i].irq;
                        pr_debug("IPU: mapped source %u to IRQ %u\n",
@@ -252,10 +252,10 @@ int ipu_irq_unmap(unsigned int source)
                        pr_debug("IPU: unmapped source %u from IRQ %u\n",
                                 source, irq_map[i].irq);
 
-                       spin_lock_irqsave(&bank_lock, lock_flags);
+                       raw_spin_lock_irqsave(&bank_lock, lock_flags);
                        irq_map[i].source = -EINVAL;
                        irq_map[i].bank = NULL;
-                       spin_unlock_irqrestore(&bank_lock, lock_flags);
+                       raw_spin_unlock_irqrestore(&bank_lock, lock_flags);
 
                        ret = 0;
                        break;
@@ -269,14 +269,14 @@ int ipu_irq_unmap(unsigned int source)
 /* Chained IRQ handler for IPU error interrupt */
 static void ipu_irq_err(unsigned int irq, struct irq_desc *desc)
 {
-       struct ipu *ipu = get_irq_data(irq);
+       struct ipu *ipu = irq_get_handler_data(irq);
        u32 status;
        int i, line;
 
        for (i = IPU_IRQ_NR_FN_BANKS; i < IPU_IRQ_NR_BANKS; i++) {
                struct ipu_irq_bank *bank = irq_bank + i;
 
-               spin_lock(&bank_lock);
+               raw_spin_lock(&bank_lock);
                status = ipu_read_reg(ipu, bank->status);
                /*
                 * Don't think we have to clear all interrupts here, they will
@@ -284,18 +284,18 @@ static void ipu_irq_err(unsigned int irq, struct irq_desc *desc)
                 * might want to clear unhandled interrupts after the loop...
                 */
                status &= ipu_read_reg(ipu, bank->control);
-               spin_unlock(&bank_lock);
+               raw_spin_unlock(&bank_lock);
                while ((line = ffs(status))) {
                        struct ipu_irq_map *map;
 
                        line--;
                        status &= ~(1UL << line);
 
-                       spin_lock(&bank_lock);
+                       raw_spin_lock(&bank_lock);
                        map = src2map(32 * i + line);
                        if (map)
                                irq = map->irq;
-                       spin_unlock(&bank_lock);
+                       raw_spin_unlock(&bank_lock);
 
                        if (!map) {
                                pr_err("IPU: Interrupt on unmapped source %u bank %d\n",
@@ -310,29 +310,29 @@ static void ipu_irq_err(unsigned int irq, struct irq_desc *desc)
 /* Chained IRQ handler for IPU function interrupt */
 static void ipu_irq_fn(unsigned int irq, struct irq_desc *desc)
 {
-       struct ipu *ipu = get_irq_data(irq);
+       struct ipu *ipu = irq_desc_get_handler_data(desc);
        u32 status;
        int i, line;
 
        for (i = 0; i < IPU_IRQ_NR_FN_BANKS; i++) {
                struct ipu_irq_bank *bank = irq_bank + i;
 
-               spin_lock(&bank_lock);
+               raw_spin_lock(&bank_lock);
                status = ipu_read_reg(ipu, bank->status);
                /* Not clearing all interrupts, see above */
                status &= ipu_read_reg(ipu, bank->control);
-               spin_unlock(&bank_lock);
+               raw_spin_unlock(&bank_lock);
                while ((line = ffs(status))) {
                        struct ipu_irq_map *map;
 
                        line--;
                        status &= ~(1UL << line);
 
-                       spin_lock(&bank_lock);
+                       raw_spin_lock(&bank_lock);
                        map = src2map(32 * i + line);
                        if (map)
                                irq = map->irq;
-                       spin_unlock(&bank_lock);
+                       raw_spin_unlock(&bank_lock);
 
                        if (!map) {
                                pr_err("IPU: Interrupt on unmapped source %u bank %d\n",
@@ -345,10 +345,10 @@ static void ipu_irq_fn(unsigned int irq, struct irq_desc *desc)
 }
 
 static struct irq_chip ipu_irq_chip = {
-       .name   = "ipu_irq",
-       .ack    = ipu_irq_ack,
-       .mask   = ipu_irq_mask,
-       .unmask = ipu_irq_unmask,
+       .name           = "ipu_irq",
+       .irq_ack        = ipu_irq_ack,
+       .irq_mask       = ipu_irq_mask,
+       .irq_unmask     = ipu_irq_unmask,
 };
 
 /* Install the IRQ handler */
@@ -366,26 +366,26 @@ int __init ipu_irq_attach_irq(struct ipu *ipu, struct platform_device *dev)
                int ret;
 
                irq = irq_base + i;
-               ret = set_irq_chip(irq, &ipu_irq_chip);
+               ret = irq_set_chip(irq, &ipu_irq_chip);
                if (ret < 0)
                        return ret;
-               ret = set_irq_chip_data(irq, irq_map + i);
+               ret = irq_set_chip_data(irq, irq_map + i);
                if (ret < 0)
                        return ret;
                irq_map[i].ipu = ipu;
                irq_map[i].irq = irq;
                irq_map[i].source = -EINVAL;
-               set_irq_handler(irq, handle_level_irq);
+               irq_set_handler(irq, handle_level_irq);
 #ifdef CONFIG_ARM
                set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
 #endif
        }
 
-       set_irq_data(ipu->irq_fn, ipu);
-       set_irq_chained_handler(ipu->irq_fn, ipu_irq_fn);
+       irq_set_handler_data(ipu->irq_fn, ipu);
+       irq_set_chained_handler(ipu->irq_fn, ipu_irq_fn);
 
-       set_irq_data(ipu->irq_err, ipu);
-       set_irq_chained_handler(ipu->irq_err, ipu_irq_err);
+       irq_set_handler_data(ipu->irq_err, ipu);
+       irq_set_chained_handler(ipu->irq_err, ipu_irq_err);
 
        return 0;
 }
@@ -397,17 +397,17 @@ void ipu_irq_detach_irq(struct ipu *ipu, struct platform_device *dev)
 
        irq_base = pdata->irq_base;
 
-       set_irq_chained_handler(ipu->irq_fn, NULL);
-       set_irq_data(ipu->irq_fn, NULL);
+       irq_set_chained_handler(ipu->irq_fn, NULL);
+       irq_set_handler_data(ipu->irq_fn, NULL);
 
-       set_irq_chained_handler(ipu->irq_err, NULL);
-       set_irq_data(ipu->irq_err, NULL);
+       irq_set_chained_handler(ipu->irq_err, NULL);
+       irq_set_handler_data(ipu->irq_err, NULL);
 
        for (irq = irq_base; irq < irq_base + CONFIG_MX3_IPU_IRQS; irq++) {
 #ifdef CONFIG_ARM
                set_irq_flags(irq, 0);
 #endif
-               set_irq_chip(irq, NULL);
-               set_irq_chip_data(irq, NULL);
+               irq_set_chip(irq, NULL);
+               irq_set_chip_data(irq, NULL);
        }
 }
Pandora Kernel Repository