arm: Cleanup the irq namespace
authorThomas Gleixner <tglx@linutronix.de>
Thu, 24 Mar 2011 12:25:22 +0000 (13:25 +0100)
committerThomas Gleixner <tglx@linutronix.de>
Tue, 29 Mar 2011 12:47:57 +0000 (14:47 +0200)
Convert to the new function names. Automated with coccinelle.

Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
140 files changed:
arch/arm/common/gic.c
arch/arm/common/it8152.c
arch/arm/common/locomo.c
arch/arm/common/sa1111.c
arch/arm/common/vic.c
arch/arm/kernel/ecard.c
arch/arm/mach-at91/at91cap9_devices.c
arch/arm/mach-at91/gpio.c
arch/arm/mach-at91/irq.c
arch/arm/mach-bcmring/irq.c
arch/arm/mach-clps711x/irq.c
arch/arm/mach-davinci/cp_intc.c
arch/arm/mach-davinci/gpio.c
arch/arm/mach-davinci/irq.c
arch/arm/mach-dove/irq.c
arch/arm/mach-ebsa110/core.c
arch/arm/mach-ep93xx/gpio.c
arch/arm/mach-exynos4/irq-combiner.c
arch/arm/mach-exynos4/irq-eint.c
arch/arm/mach-footbridge/common.c
arch/arm/mach-footbridge/isa-irq.c
arch/arm/mach-gemini/gpio.c
arch/arm/mach-gemini/irq.c
arch/arm/mach-h720x/common.c
arch/arm/mach-h720x/cpu-h7202.c
arch/arm/mach-iop13xx/irq.c
arch/arm/mach-iop13xx/msi.c
arch/arm/mach-iop32x/irq.c
arch/arm/mach-iop33x/irq.c
arch/arm/mach-ixp2000/core.c
arch/arm/mach-ixp2000/ixdp2x00.c
arch/arm/mach-ixp2000/ixdp2x01.c
arch/arm/mach-ixp23xx/core.c
arch/arm/mach-ixp23xx/ixdp2351.c
arch/arm/mach-ixp23xx/roadrunner.c
arch/arm/mach-ixp4xx/avila-pci.c
arch/arm/mach-ixp4xx/common.c
arch/arm/mach-ixp4xx/coyote-pci.c
arch/arm/mach-ixp4xx/dsmg600-pci.c
arch/arm/mach-ixp4xx/fsg-pci.c
arch/arm/mach-ixp4xx/gateway7001-pci.c
arch/arm/mach-ixp4xx/goramo_mlr.c
arch/arm/mach-ixp4xx/gtwx5715-pci.c
arch/arm/mach-ixp4xx/ixdp425-pci.c
arch/arm/mach-ixp4xx/ixdpg425-pci.c
arch/arm/mach-ixp4xx/nas100d-pci.c
arch/arm/mach-ixp4xx/nslu2-pci.c
arch/arm/mach-ixp4xx/vulcan-pci.c
arch/arm/mach-ixp4xx/wg302v2-pci.c
arch/arm/mach-kirkwood/irq.c
arch/arm/mach-ks8695/gpio.c
arch/arm/mach-ks8695/irq.c
arch/arm/mach-lpc32xx/irq.c
arch/arm/mach-mmp/irq-mmp2.c
arch/arm/mach-mmp/irq-pxa168.c
arch/arm/mach-msm/board-msm8960.c
arch/arm/mach-msm/board-msm8x60.c
arch/arm/mach-msm/board-trout-gpio.c
arch/arm/mach-msm/board-trout-mmc.c
arch/arm/mach-msm/gpio-v2.c
arch/arm/mach-msm/gpio.c
arch/arm/mach-msm/irq-vic.c
arch/arm/mach-msm/irq.c
arch/arm/mach-msm/sirc.c
arch/arm/mach-mv78xx0/irq.c
arch/arm/mach-mx3/mach-mx31ads.c
arch/arm/mach-mx5/eukrea_mbimx51-baseboard.c
arch/arm/mach-mxs/gpio.c
arch/arm/mach-mxs/icoll.c
arch/arm/mach-netx/generic.c
arch/arm/mach-ns9xxx/board-a9m9750dev.c
arch/arm/mach-ns9xxx/irq.c
arch/arm/mach-nuc93x/irq.c
arch/arm/mach-omap1/board-osk.c
arch/arm/mach-omap1/board-palmz71.c
arch/arm/mach-omap1/board-voiceblue.c
arch/arm/mach-omap1/fpga.c
arch/arm/mach-omap1/irq.c
arch/arm/mach-omap2/gpmc.c
arch/arm/mach-omap2/irq.c
arch/arm/mach-orion5x/db88f5281-setup.c
arch/arm/mach-orion5x/irq.c
arch/arm/mach-orion5x/rd88f5182-setup.c
arch/arm/mach-orion5x/terastation_pro2-setup.c
arch/arm/mach-orion5x/ts209-setup.c
arch/arm/mach-pnx4008/irq.c
arch/arm/mach-pxa/balloon3.c
arch/arm/mach-pxa/cm-x2xx-pci.c
arch/arm/mach-pxa/cm-x300.c
arch/arm/mach-pxa/irq.c
arch/arm/mach-pxa/lpd270.c
arch/arm/mach-pxa/lubbock.c
arch/arm/mach-pxa/mainstone.c
arch/arm/mach-pxa/pcm990-baseboard.c
arch/arm/mach-pxa/pxa3xx.c
arch/arm/mach-pxa/viper.c
arch/arm/mach-pxa/zeus.c
arch/arm/mach-rpc/irq.c
arch/arm/mach-s3c2410/bast-irq.c
arch/arm/mach-s3c2412/irq.c
arch/arm/mach-s3c2416/irq.c
arch/arm/mach-s3c2440/irq.c
arch/arm/mach-s3c2440/s3c244x-irq.c
arch/arm/mach-s3c2443/irq.c
arch/arm/mach-s3c64xx/irq-eint.c
arch/arm/mach-sa1100/cerf.c
arch/arm/mach-sa1100/irq.c
arch/arm/mach-sa1100/neponset.c
arch/arm/mach-sa1100/pleb.c
arch/arm/mach-shark/irq.c
arch/arm/mach-shmobile/board-ap4evb.c
arch/arm/mach-shmobile/board-mackerel.c
arch/arm/mach-shmobile/intc-sh7367.c
arch/arm/mach-shmobile/intc-sh7372.c
arch/arm/mach-shmobile/intc-sh7377.c
arch/arm/mach-tcc8k/irq.c
arch/arm/mach-tegra/gpio.c
arch/arm/mach-tegra/irq.c
arch/arm/mach-ux500/modem-irq-db5500.c
arch/arm/mach-versatile/core.c
arch/arm/mach-vt8500/irq.c
arch/arm/mach-w90x900/irq.c
arch/arm/plat-mxc/3ds_debugboard.c
arch/arm/plat-mxc/avic.c
arch/arm/plat-mxc/gpio.c
arch/arm/plat-mxc/irq-common.c
arch/arm/plat-mxc/tzic.c
arch/arm/plat-nomadik/gpio.c
arch/arm/plat-omap/gpio.c
arch/arm/plat-orion/gpio.c
arch/arm/plat-orion/irq.c
arch/arm/plat-pxa/gpio.c
arch/arm/plat-s3c24xx/irq.c
arch/arm/plat-s5p/irq-eint.c
arch/arm/plat-s5p/irq-gpioint.c
arch/arm/plat-samsung/irq-uart.c
arch/arm/plat-spear/shirq.c
arch/arm/plat-stmp3xxx/irq.c
arch/arm/plat-stmp3xxx/pinmux.c
arch/arm/plat-versatile/fpga-irq.c

index 90919d5391c8139d788a4e8773f2ebe9745f6110..50d5b20d5c93c7283f7c456ae19e582bb56835f5 100644 (file)
@@ -213,8 +213,8 @@ static int gic_set_wake(struct irq_data *d, unsigned int on)
 
 static void gic_handle_cascade_irq(unsigned int irq, struct irq_desc *desc)
 {
-       struct gic_chip_data *chip_data = get_irq_data(irq);
-       struct irq_chip *chip = get_irq_chip(irq);
+       struct gic_chip_data *chip_data = irq_get_handler_data(irq);
+       struct irq_chip *chip = irq_get_chip(irq);
        unsigned int cascade_irq, gic_irq;
        unsigned long status;
 
@@ -257,9 +257,9 @@ void __init gic_cascade_irq(unsigned int gic_nr, unsigned int irq)
 {
        if (gic_nr >= MAX_GIC_NR)
                BUG();
-       if (set_irq_data(irq, &gic_data[gic_nr]) != 0)
+       if (irq_set_handler_data(irq, &gic_data[gic_nr]) != 0)
                BUG();
-       set_irq_chained_handler(irq, gic_handle_cascade_irq);
+       irq_set_chained_handler(irq, gic_handle_cascade_irq);
 }
 
 static void __init gic_dist_init(struct gic_chip_data *gic,
@@ -319,9 +319,9 @@ static void __init gic_dist_init(struct gic_chip_data *gic,
         * Setup the Linux IRQ subsystem.
         */
        for (i = irq_start; i < irq_limit; i++) {
-               set_irq_chip(i, &gic_chip);
-               set_irq_chip_data(i, gic);
-               set_irq_handler(i, handle_level_irq);
+               irq_set_chip(i, &gic_chip);
+               irq_set_chip_data(i, gic);
+               irq_set_handler(i, handle_level_irq);
                set_irq_flags(i, IRQF_VALID | IRQF_PROBE);
        }
 
index fcddd48fe9da3a287172e9ad97ebf64e6e41bc63..c815d00eb3494e8a89d859037e4e120930df25eb 100644 (file)
@@ -88,8 +88,8 @@ void it8152_init_irq(void)
        __raw_writel((0), IT8152_INTC_LDCNIRR);
 
        for (irq = IT8152_IRQ(0); irq <= IT8152_LAST_IRQ; irq++) {
-               set_irq_chip(irq, &it8152_irq_chip);
-               set_irq_handler(irq, handle_level_irq);
+               irq_set_chip(irq, &it8152_irq_chip);
+               irq_set_handler(irq, handle_level_irq);
                set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
        }
 }
index a026a6bf4892fef5d535b93209e593d9444f1449..ea18b351f205978f32298a45824b6e8586cfc12a 100644 (file)
@@ -140,7 +140,7 @@ static struct locomo_dev_info locomo_devices[] = {
 
 static void locomo_handler(unsigned int irq, struct irq_desc *desc)
 {
-       struct locomo *lchip = get_irq_chip_data(irq);
+       struct locomo *lchip = irq_get_chip_data(irq);
        int req, i;
 
        /* Acknowledge the parent IRQ */
@@ -197,15 +197,15 @@ static void locomo_setup_irq(struct locomo *lchip)
        /*
         * Install handler for IRQ_LOCOMO_HW.
         */
-       set_irq_type(lchip->irq, IRQ_TYPE_EDGE_FALLING);
-       set_irq_chip_data(lchip->irq, lchip);
-       set_irq_chained_handler(lchip->irq, locomo_handler);
+       irq_set_irq_type(lchip->irq, IRQ_TYPE_EDGE_FALLING);
+       irq_set_chip_data(lchip->irq, lchip);
+       irq_set_chained_handler(lchip->irq, locomo_handler);
 
        /* Install handlers for IRQ_LOCOMO_* */
        for ( ; irq <= lchip->irq_base + 3; irq++) {
-               set_irq_chip(irq, &locomo_chip);
-               set_irq_chip_data(irq, lchip);
-               set_irq_handler(irq, handle_level_irq);
+               irq_set_chip(irq, &locomo_chip);
+               irq_set_chip_data(irq, lchip);
+               irq_set_handler(irq, handle_level_irq);
                set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
        }
 }
@@ -476,8 +476,8 @@ static void __locomo_remove(struct locomo *lchip)
        device_for_each_child(lchip->dev, NULL, locomo_remove_child);
 
        if (lchip->irq != NO_IRQ) {
-               set_irq_chained_handler(lchip->irq, NULL);
-               set_irq_data(lchip->irq, NULL);
+               irq_set_chained_handler(lchip->irq, NULL);
+               irq_set_handler_data(lchip->irq, NULL);
        }
 
        iounmap(lchip->base);
index eb9796b0dab23020356b15ae14ca386286c8f478..11ab3c24103c5c46cf818aba8ddc8c1ba0576664 100644 (file)
@@ -202,7 +202,7 @@ static void
 sa1111_irq_handler(unsigned int irq, struct irq_desc *desc)
 {
        unsigned int stat0, stat1, i;
-       struct sa1111 *sachip = get_irq_data(irq);
+       struct sa1111 *sachip = irq_get_handler_data(irq);
        void __iomem *mapbase = sachip->base + SA1111_INTC;
 
        stat0 = sa1111_readl(mapbase + SA1111_INTSTATCLR0);
@@ -472,25 +472,25 @@ static void sa1111_setup_irq(struct sa1111 *sachip)
        sa1111_writel(~0, irqbase + SA1111_INTSTATCLR1);
 
        for (irq = IRQ_GPAIN0; irq <= SSPROR; irq++) {
-               set_irq_chip(irq, &sa1111_low_chip);
-               set_irq_chip_data(irq, sachip);
-               set_irq_handler(irq, handle_edge_irq);
+               irq_set_chip(irq, &sa1111_low_chip);
+               irq_set_chip_data(irq, sachip);
+               irq_set_handler(irq, handle_edge_irq);
                set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
        }
 
        for (irq = AUDXMTDMADONEA; irq <= IRQ_S1_BVD1_STSCHG; irq++) {
-               set_irq_chip(irq, &sa1111_high_chip);
-               set_irq_chip_data(irq, sachip);
-               set_irq_handler(irq, handle_edge_irq);
+               irq_set_chip(irq, &sa1111_high_chip);
+               irq_set_chip_data(irq, sachip);
+               irq_set_handler(irq, handle_edge_irq);
                set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
        }
 
        /*
         * Register SA1111 interrupt
         */
-       set_irq_type(sachip->irq, IRQ_TYPE_EDGE_RISING);
-       set_irq_data(sachip->irq, sachip);
-       set_irq_chained_handler(sachip->irq, sa1111_irq_handler);
+       irq_set_irq_type(sachip->irq, IRQ_TYPE_EDGE_RISING);
+       irq_set_handler_data(sachip->irq, sachip);
+       irq_set_chained_handler(sachip->irq, sa1111_irq_handler);
 }
 
 /*
@@ -815,8 +815,8 @@ static void __sa1111_remove(struct sa1111 *sachip)
        clk_disable(sachip->clk);
 
        if (sachip->irq != NO_IRQ) {
-               set_irq_chained_handler(sachip->irq, NULL);
-               set_irq_data(sachip->irq, NULL);
+               irq_set_chained_handler(sachip->irq, NULL);
+               irq_set_handler_data(sachip->irq, NULL);
 
                release_mem_region(sachip->phys + SA1111_INTC, 512);
        }
index ae5fe7292e0d441124367c4154f42217de65c2af..297078b4dd300bf543667ed331837cb09cb54979 100644 (file)
@@ -305,9 +305,9 @@ static void __init vic_set_irq_sources(void __iomem *base,
                if (vic_sources & (1 << i)) {
                        unsigned int irq = irq_start + i;
 
-                       set_irq_chip(irq, &vic_chip);
-                       set_irq_chip_data(irq, base);
-                       set_irq_handler(irq, handle_level_irq);
+                       irq_set_chip(irq, &vic_chip);
+                       irq_set_chip_data(irq, base);
+                       irq_set_handler(irq, handle_level_irq);
                        set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
                }
        }
index 2ad62df377300698db90598544227c16332bdfe4..a9690f1c28e2efac9b6d3bfc0b33ee0e0147cbf9 100644 (file)
@@ -1043,8 +1043,8 @@ ecard_probe(int slot, card_type_t type)
         */
        if (slot < 8) {
                ec->irq = 32 + slot;
-               set_irq_chip(ec->irq, &ecard_chip);
-               set_irq_handler(ec->irq, handle_level_irq);
+               irq_set_chip(ec->irq, &ecard_chip);
+               irq_set_handler(ec->irq, handle_level_irq);
                set_irq_flags(ec->irq, IRQF_VALID);
        }
 
@@ -1103,7 +1103,7 @@ static int __init ecard_init(void)
 
        irqhw = ecard_probeirqhw();
 
-       set_irq_chained_handler(IRQ_EXPANSIONCARD,
+       irq_set_chained_handler(IRQ_EXPANSIONCARD,
                                irqhw ? ecard_irqexp_handler : ecard_irq_handler);
 
        ecard_proc_init();
index d1f775e8635346e154d95a05dd2d2d85ff8f0c8c..9ffbf3a2dfeaa07ac6fd81bd154520d977250bd2 100644 (file)
@@ -72,7 +72,7 @@ void __init at91_add_device_usbh(struct at91_usbh_data *data)
                return;
 
        if (cpu_is_at91cap9_revB())
-               set_irq_type(AT91CAP9_ID_UHP, IRQ_TYPE_LEVEL_HIGH);
+               irq_set_irq_type(AT91CAP9_ID_UHP, IRQ_TYPE_LEVEL_HIGH);
 
        /* Enable VBus control for UHP ports */
        for (i = 0; i < data->ports; i++) {
@@ -157,7 +157,7 @@ static struct platform_device at91_usba_udc_device = {
 void __init at91_add_device_usba(struct usba_platform_data *data)
 {
        if (cpu_is_at91cap9_revB()) {
-               set_irq_type(AT91CAP9_ID_UDPHS, IRQ_TYPE_LEVEL_HIGH);
+               irq_set_irq_type(AT91CAP9_ID_UDPHS, IRQ_TYPE_LEVEL_HIGH);
                at91_sys_write(AT91_MATRIX_UDPHS, AT91_MATRIX_SELECT_UDPHS |
                                                  AT91_MATRIX_UDPHS_BYPASS_LOCK);
        }
@@ -861,7 +861,7 @@ void __init at91_add_device_lcdc(struct atmel_lcdfb_info *data)
                return;
 
        if (cpu_is_at91cap9_revB())
-               set_irq_type(AT91CAP9_ID_LCDC, IRQ_TYPE_LEVEL_HIGH);
+               irq_set_irq_type(AT91CAP9_ID_LCDC, IRQ_TYPE_LEVEL_HIGH);
 
        at91_set_A_periph(AT91_PIN_PC1, 0);     /* LCDHSYNC */
        at91_set_A_periph(AT91_PIN_PC2, 0);     /* LCDDOTCK */
index 6fd82480756cc36053d86b9ba80c04d373d44218..8512b796e6531b9da53c6493e98da01892e84ddf 100644 (file)
@@ -287,7 +287,7 @@ static int gpio_irq_set_wake(struct irq_data *d, unsigned state)
        else
                wakeups[bank] &= ~mask;
 
-       set_irq_wake(gpio_chip[bank].bank->id, state);
+       irq_set_irq_wake(gpio_chip[bank].bank->id, state);
 
        return 0;
 }
@@ -511,8 +511,8 @@ void __init at91_gpio_irq_setup(void)
                         * Can use the "simple" and not "edge" handler since it's
                         * shorter, and the AIC handles interrupts sanely.
                         */
-                       set_irq_chip(pin, &gpio_irqchip);
-                       set_irq_handler(pin, handle_simple_irq);
+                       irq_set_chip(pin, &gpio_irqchip);
+                       irq_set_handler(pin, handle_simple_irq);
                        set_irq_flags(pin, IRQF_VALID);
                }
 
@@ -523,8 +523,8 @@ void __init at91_gpio_irq_setup(void)
                if (prev && prev->next == this)
                        continue;
 
-               set_irq_chip_data(id, this);
-               set_irq_chained_handler(id, gpio_irq_handler);
+               irq_set_chip_data(id, this);
+               irq_set_chained_handler(id, gpio_irq_handler);
        }
        pr_info("AT91: %d gpio irqs in %d banks\n", pin - PIN_BASE, gpio_banks);
 }
index b56d6b3a40876c31840181a1d8922c531bc2d38e..566cec1d90734836031c8cd7b454affb8a1fa150 100644 (file)
@@ -143,8 +143,8 @@ void __init at91_aic_init(unsigned int priority[NR_AIC_IRQS])
                /* Active Low interrupt, with the specified priority */
                at91_sys_write(AT91_AIC_SMR(i), AT91_AIC_SRCTYPE_LOW | priority[i]);
 
-               set_irq_chip(i, &at91_aic_chip);
-               set_irq_handler(i, handle_level_irq);
+               irq_set_chip(i, &at91_aic_chip);
+               irq_set_handler(i, handle_level_irq);
                set_irq_flags(i, IRQF_VALID | IRQF_PROBE);
 
                /* Perform 8 End Of Interrupt Command to make sure AIC will not Lock out nIRQ */
index 84dcda0d1d9a4997ac2d761575050627a76c59e0..c48feaf4e8e9538655a7586c2a69fe340f87d0c8 100644 (file)
@@ -93,11 +93,11 @@ static void vic_init(void __iomem *base, struct irq_chip *chip,
        unsigned int i;
        for (i = 0; i < 32; i++) {
                unsigned int irq = irq_start + i;
-               set_irq_chip(irq, chip);
-               set_irq_chip_data(irq, base);
+               irq_set_chip(irq, chip);
+               irq_set_chip_data(irq, base);
 
                if (vic_sources & (1 << i)) {
-                       set_irq_handler(irq, handle_level_irq);
+                       irq_set_handler(irq, handle_level_irq);
                        set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
                }
        }
@@ -119,9 +119,9 @@ void __init bcmring_init_irq(void)
 
        /* special cases */
        if (INTCHW_INTC1_GPIO0 & IRQ_INTC1_VALID_MASK) {
-               set_irq_handler(IRQ_GPIO0, handle_simple_irq);
+               irq_set_handler(IRQ_GPIO0, handle_simple_irq);
        }
        if (INTCHW_INTC1_GPIO1 & IRQ_INTC1_VALID_MASK) {
-               set_irq_handler(IRQ_GPIO1, handle_simple_irq);
+               irq_set_handler(IRQ_GPIO1, handle_simple_irq);
        }
 }
index 86da7a1b2bbe045cd7c2cb1b8f7d016a48a225fd..5c5ec01d8972e5f0ab2f2fdbdd179391a4e406a0 100644 (file)
@@ -112,13 +112,13 @@ void __init clps711x_init_irq(void)
 
        for (i = 0; i < NR_IRQS; i++) {
                if (INT1_IRQS & (1 << i)) {
-                       set_irq_handler(i, handle_level_irq);
-                       set_irq_chip(i, &int1_chip);
+                       irq_set_handler(i, handle_level_irq);
+                       irq_set_chip(i, &int1_chip);
                        set_irq_flags(i, IRQF_VALID | IRQF_PROBE);
                }
                if (INT2_IRQS & (1 << i)) {
-                       set_irq_handler(i, handle_level_irq);
-                       set_irq_chip(i, &int2_chip);
+                       irq_set_handler(i, handle_level_irq);
+                       irq_set_chip(i, &int2_chip);
                        set_irq_flags(i, IRQF_VALID | IRQF_PROBE);
                }                       
        }
index 9abc80a86a22b5bb1ac6c6b4fe734af3dc5dad28..f83152d643c5d58921a7b91a826a1790b7bbe4f9 100644 (file)
@@ -167,9 +167,9 @@ void __init cp_intc_init(void)
 
        /* Set up genirq dispatching for cp_intc */
        for (i = 0; i < num_irq; i++) {
-               set_irq_chip(i, &cp_intc_irq_chip);
+               irq_set_chip(i, &cp_intc_irq_chip);
                set_irq_flags(i, IRQF_VALID | IRQF_PROBE);
-               set_irq_handler(i, handle_edge_irq);
+               irq_set_handler(i, handle_edge_irq);
        }
 
        /* Enable global interrupt */
index f33d4380e3673b742e3d61495483a3741f8431ec..a0b838894ac99b27daaf413fbfbd8f78ae842066 100644 (file)
@@ -62,7 +62,7 @@ static inline struct davinci_gpio_regs __iomem *irq2regs(int irq)
 {
        struct davinci_gpio_regs __iomem *g;
 
-       g = (__force struct davinci_gpio_regs __iomem *)get_irq_chip_data(irq);
+       g = (__force struct davinci_gpio_regs __iomem *)irq_get_chip_data(irq);
 
        return g;
 }
@@ -208,7 +208,7 @@ pure_initcall(davinci_gpio_setup);
 static void gpio_irq_disable(struct irq_data *d)
 {
        struct davinci_gpio_regs __iomem *g = irq2regs(d->irq);
-       u32 mask = (u32) irq_data_get_irq_data(d);
+       u32 mask = (u32) irq_data_get_irq_handler_data(d);
 
        __raw_writel(mask, &g->clr_falling);
        __raw_writel(mask, &g->clr_rising);
@@ -217,7 +217,7 @@ static void gpio_irq_disable(struct irq_data *d)
 static void gpio_irq_enable(struct irq_data *d)
 {
        struct davinci_gpio_regs __iomem *g = irq2regs(d->irq);
-       u32 mask = (u32) irq_data_get_irq_data(d);
+       u32 mask = (u32) irq_data_get_irq_handler_data(d);
        unsigned status = irqd_get_trigger_type(d);
 
        status &= IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING;
@@ -233,7 +233,7 @@ static void gpio_irq_enable(struct irq_data *d)
 static int gpio_irq_type(struct irq_data *d, unsigned trigger)
 {
        struct davinci_gpio_regs __iomem *g = irq2regs(d->irq);
-       u32 mask = (u32) irq_data_get_irq_data(d);
+       u32 mask = (u32) irq_data_get_irq_handler_data(d);
 
        if (trigger & ~(IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING))
                return -EINVAL;
@@ -276,7 +276,7 @@ gpio_irq_handler(unsigned irq, struct irq_desc *desc)
                        status >>= 16;
 
                /* now demux them to the right lowlevel handler */
-               n = (int)get_irq_data(irq);
+               n = (int)irq_get_handler_data(irq);
                while (status) {
                        res = ffs(status);
                        n += res;
@@ -314,7 +314,7 @@ static int gpio_to_irq_unbanked(struct gpio_chip *chip, unsigned offset)
 static int gpio_irq_type_unbanked(struct irq_data *d, unsigned trigger)
 {
        struct davinci_gpio_regs __iomem *g = irq2regs(d->irq);
-       u32 mask = (u32) irq_data_get_irq_data(d);
+       u32 mask = (u32) irq_data_get_irq_handler_data(d);
 
        if (trigger & ~(IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING))
                return -EINVAL;
@@ -397,9 +397,9 @@ static int __init davinci_gpio_irq_setup(void)
 
                /* set the direct IRQs up to use that irqchip */
                for (gpio = 0; gpio < soc_info->gpio_unbanked; gpio++, irq++) {
-                       set_irq_chip(irq, &gpio_irqchip_unbanked);
-                       set_irq_data(irq, (void *) __gpio_mask(gpio));
-                       set_irq_chip_data(irq, (__force void *) g);
+                       irq_set_chip(irq, &gpio_irqchip_unbanked);
+                       irq_set_handler_data(irq, (void *)__gpio_mask(gpio));
+                       irq_set_chip_data(irq, (__force void *)g);
                        irq_set_status_flags(irq, IRQ_TYPE_EDGE_BOTH);
                }
 
@@ -421,15 +421,15 @@ static int __init davinci_gpio_irq_setup(void)
                __raw_writel(~0, &g->clr_rising);
 
                /* set up all irqs in this bank */
-               set_irq_chained_handler(bank_irq, gpio_irq_handler);
-               set_irq_chip_data(bank_irq, (__force void *) g);
-               set_irq_data(bank_irq, (void *) irq);
+               irq_set_chained_handler(bank_irq, gpio_irq_handler);
+               irq_set_chip_data(bank_irq, (__force void *)g);
+               irq_set_handler_data(bank_irq, (void *)irq);
 
                for (i = 0; i < 16 && gpio < ngpio; i++, irq++, gpio++) {
-                       set_irq_chip(irq, &gpio_irqchip);
-                       set_irq_chip_data(irq, (__force void *) g);
-                       set_irq_data(irq, (void *) __gpio_mask(gpio));
-                       set_irq_handler(irq, handle_simple_irq);
+                       irq_set_chip(irq, &gpio_irqchip);
+                       irq_set_chip_data(irq, (__force void *)g);
+                       irq_set_handler_data(irq, (void *)__gpio_mask(gpio));
+                       irq_set_handler(irq, handle_simple_irq);
                        set_irq_flags(irq, IRQF_VALID);
                }
 
index 5e05c9b64e1fa17e0c74d40e299b3babc9f68581..e6269a6e0014fb49b92a5ee8bd5820397885913c 100644 (file)
@@ -154,11 +154,11 @@ void __init davinci_irq_init(void)
 
        /* set up genirq dispatch for ARM INTC */
        for (i = 0; i < davinci_soc_info.intc_irq_num; i++) {
-               set_irq_chip(i, &davinci_irq_chip_0);
+               irq_set_chip(i, &davinci_irq_chip_0);
                set_irq_flags(i, IRQF_VALID | IRQF_PROBE);
                if (i != IRQ_TINT1_TINT34)
-                       set_irq_handler(i, handle_edge_irq);
+                       irq_set_handler(i, handle_edge_irq);
                else
-                       set_irq_handler(i, handle_level_irq);
+                       irq_set_handler(i, handle_level_irq);
        }
 }
index aac6e23763e0e068a1b54ba6165d59448b7838f7..f038a19f4c6ec6526a1ef9407373d8ad2470a1da 100644 (file)
@@ -102,14 +102,14 @@ void __init dove_init_irq(void)
         */
        orion_gpio_init(0, 32, DOVE_GPIO_LO_VIRT_BASE, 0,
                        IRQ_DOVE_GPIO_START);
-       set_irq_chained_handler(IRQ_DOVE_GPIO_0_7, gpio_irq_handler);
-       set_irq_chained_handler(IRQ_DOVE_GPIO_8_15, gpio_irq_handler);
-       set_irq_chained_handler(IRQ_DOVE_GPIO_16_23, gpio_irq_handler);
-       set_irq_chained_handler(IRQ_DOVE_GPIO_24_31, gpio_irq_handler);
+       irq_set_chained_handler(IRQ_DOVE_GPIO_0_7, gpio_irq_handler);
+       irq_set_chained_handler(IRQ_DOVE_GPIO_8_15, gpio_irq_handler);
+       irq_set_chained_handler(IRQ_DOVE_GPIO_16_23, gpio_irq_handler);
+       irq_set_chained_handler(IRQ_DOVE_GPIO_24_31, gpio_irq_handler);
 
        orion_gpio_init(32, 32, DOVE_GPIO_HI_VIRT_BASE, 0,
                        IRQ_DOVE_GPIO_START + 32);
-       set_irq_chained_handler(IRQ_DOVE_HIGH_GPIO, gpio_irq_handler);
+       irq_set_chained_handler(IRQ_DOVE_HIGH_GPIO, gpio_irq_handler);
 
        orion_gpio_init(64, 8, DOVE_GPIO2_VIRT_BASE, 0,
                        IRQ_DOVE_GPIO_START + 64);
@@ -121,10 +121,10 @@ void __init dove_init_irq(void)
        writel(0, PMU_INTERRUPT_CAUSE);
 
        for (i = IRQ_DOVE_PMU_START; i < NR_IRQS; i++) {
-               set_irq_chip(i, &pmu_irq_chip);
-               set_irq_handler(i, handle_level_irq);
+               irq_set_chip(i, &pmu_irq_chip);
+               irq_set_handler(i, handle_level_irq);
                irq_set_status_flags(i, IRQ_LEVEL);
                set_irq_flags(i, IRQF_VALID);
        }
-       set_irq_chained_handler(IRQ_DOVE_PMU, pmu_irq_handler);
+       irq_set_chained_handler(IRQ_DOVE_PMU, pmu_irq_handler);
 }
index 7df083f37fa761b4bead3f52d1b65f27e4265c1b..caf6cbac33e0866abcf077d29ec83bcd4e35deb6 100644 (file)
@@ -66,8 +66,8 @@ static void __init ebsa110_init_irq(void)
        local_irq_restore(flags);
 
        for (irq = 0; irq < NR_IRQS; irq++) {
-               set_irq_chip(irq, &ebsa110_irq_chip);
-               set_irq_handler(irq, handle_level_irq);
+               irq_set_chip(irq, &ebsa110_irq_chip);
+               irq_set_handler(irq, handle_level_irq);
                set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
        }
 }
index 6e7bbf72b36bdd5a2b6c1c437cbba47ac6a6001d..7da0a5cefa5fe5d132cd3cd56f8cf0ac773e6d03 100644 (file)
@@ -231,20 +231,29 @@ void __init ep93xx_gpio_init_irq(void)
 
        for (gpio_irq = gpio_to_irq(0);
             gpio_irq <= gpio_to_irq(EP93XX_GPIO_LINE_MAX_IRQ); ++gpio_irq) {
-               set_irq_chip(gpio_irq, &ep93xx_gpio_irq_chip);
-               set_irq_handler(gpio_irq, handle_level_irq);
+               irq_set_chip(gpio_irq, &ep93xx_gpio_irq_chip);
+               irq_set_handler(gpio_irq, handle_level_irq);
                set_irq_flags(gpio_irq, IRQF_VALID);
        }
 
-       set_irq_chained_handler(IRQ_EP93XX_GPIO_AB, ep93xx_gpio_ab_irq_handler);
-       set_irq_chained_handler(IRQ_EP93XX_GPIO0MUX, ep93xx_gpio_f_irq_handler);
-       set_irq_chained_handler(IRQ_EP93XX_GPIO1MUX, ep93xx_gpio_f_irq_handler);
-       set_irq_chained_handler(IRQ_EP93XX_GPIO2MUX, ep93xx_gpio_f_irq_handler);
-       set_irq_chained_handler(IRQ_EP93XX_GPIO3MUX, ep93xx_gpio_f_irq_handler);
-       set_irq_chained_handler(IRQ_EP93XX_GPIO4MUX, ep93xx_gpio_f_irq_handler);
-       set_irq_chained_handler(IRQ_EP93XX_GPIO5MUX, ep93xx_gpio_f_irq_handler);
-       set_irq_chained_handler(IRQ_EP93XX_GPIO6MUX, ep93xx_gpio_f_irq_handler);
-       set_irq_chained_handler(IRQ_EP93XX_GPIO7MUX, ep93xx_gpio_f_irq_handler);
+       irq_set_chained_handler(IRQ_EP93XX_GPIO_AB,
+                               ep93xx_gpio_ab_irq_handler);
+       irq_set_chained_handler(IRQ_EP93XX_GPIO0MUX,
+                               ep93xx_gpio_f_irq_handler);
+       irq_set_chained_handler(IRQ_EP93XX_GPIO1MUX,
+                               ep93xx_gpio_f_irq_handler);
+       irq_set_chained_handler(IRQ_EP93XX_GPIO2MUX,
+                               ep93xx_gpio_f_irq_handler);
+       irq_set_chained_handler(IRQ_EP93XX_GPIO3MUX,
+                               ep93xx_gpio_f_irq_handler);
+       irq_set_chained_handler(IRQ_EP93XX_GPIO4MUX,
+                               ep93xx_gpio_f_irq_handler);
+       irq_set_chained_handler(IRQ_EP93XX_GPIO5MUX,
+                               ep93xx_gpio_f_irq_handler);
+       irq_set_chained_handler(IRQ_EP93XX_GPIO6MUX,
+                               ep93xx_gpio_f_irq_handler);
+       irq_set_chained_handler(IRQ_EP93XX_GPIO7MUX,
+                               ep93xx_gpio_f_irq_handler);
 }
 
 
index 31618d91ce15902cd00b4bea30e24999aa00e078..0c180800c8a792cb1e5bb17102571a65a8c7f9ec 100644 (file)
@@ -54,8 +54,8 @@ static void combiner_unmask_irq(struct irq_data *data)
 
 static void combiner_handle_cascade_irq(unsigned int irq, struct irq_desc *desc)
 {
-       struct combiner_chip_data *chip_data = get_irq_data(irq);
-       struct irq_chip *chip = get_irq_chip(irq);
+       struct combiner_chip_data *chip_data = irq_get_handler_data(irq);
+       struct irq_chip *chip = irq_get_chip(irq);
        unsigned int cascade_irq, combiner_irq;
        unsigned long status;
 
@@ -93,9 +93,9 @@ void __init combiner_cascade_irq(unsigned int combiner_nr, unsigned int irq)
 {
        if (combiner_nr >= MAX_COMBINER_NR)
                BUG();
-       if (set_irq_data(irq, &combiner_data[combiner_nr]) != 0)
+       if (irq_set_handler_data(irq, &combiner_data[combiner_nr]) != 0)
                BUG();
-       set_irq_chained_handler(irq, combiner_handle_cascade_irq);
+       irq_set_chained_handler(irq, combiner_handle_cascade_irq);
 }
 
 void __init combiner_init(unsigned int combiner_nr, void __iomem *base,
@@ -119,9 +119,9 @@ void __init combiner_init(unsigned int combiner_nr, void __iomem *base,
 
        for (i = irq_start; i < combiner_data[combiner_nr].irq_offset
                                + MAX_IRQ_IN_COMBINER; i++) {
-               set_irq_chip(i, &combiner_chip);
-               set_irq_chip_data(i, &combiner_data[combiner_nr]);
-               set_irq_handler(i, handle_level_irq);
+               irq_set_chip(i, &combiner_chip);
+               irq_set_chip_data(i, &combiner_data[combiner_nr]);
+               irq_set_handler(i, handle_level_irq);
                set_irq_flags(i, IRQF_VALID | IRQF_PROBE);
        }
 }
index 4f7ad4a796e4ce87e6d8dfe7966720b50b4fe9b0..0441dfc7c924650b1314b831d0cdd335d7bcc780 100644 (file)
@@ -190,8 +190,8 @@ static void exynos4_irq_demux_eint16_31(unsigned int irq, struct irq_desc *desc)
 
 static void exynos4_irq_eint0_15(unsigned int irq, struct irq_desc *desc)
 {
-       u32 *irq_data = get_irq_data(irq);
-       struct irq_chip *chip = get_irq_chip(irq);
+       u32 *irq_data = irq_get_handler_data(irq);
+       struct irq_chip *chip = irq_get_chip(irq);
 
        chip->irq_mask(&desc->irq_data);
 
@@ -208,18 +208,19 @@ int __init exynos4_init_irq_eint(void)
        int irq;
 
        for (irq = 0 ; irq <= 31 ; irq++) {
-               set_irq_chip(IRQ_EINT(irq), &exynos4_irq_eint);
-               set_irq_handler(IRQ_EINT(irq), handle_level_irq);
+               irq_set_chip(IRQ_EINT(irq), &exynos4_irq_eint);
+               irq_set_handler(IRQ_EINT(irq), handle_level_irq);
                set_irq_flags(IRQ_EINT(irq), IRQF_VALID);
        }
 
-       set_irq_chained_handler(IRQ_EINT16_31, exynos4_irq_demux_eint16_31);
+       irq_set_chained_handler(IRQ_EINT16_31, exynos4_irq_demux_eint16_31);
 
        for (irq = 0 ; irq <= 15 ; irq++) {
                eint0_15_data[irq] = IRQ_EINT(irq);
 
-               set_irq_data(exynos4_get_irq_nr(irq), &eint0_15_data[irq]);
-               set_irq_chained_handler(exynos4_get_irq_nr(irq),
+               irq_set_handler_data(exynos4_get_irq_nr(irq),
+                                    &eint0_15_data[irq]);
+               irq_set_chained_handler(exynos4_get_irq_nr(irq),
                                        exynos4_irq_eint0_15);
        }
 
index 84c5f258f2d87d40e1de00055c2957daee8b4e6f..06239f9a7afbce180bb5b74e17cfad302396d51b 100644 (file)
@@ -102,8 +102,8 @@ static void __init __fb_init_irq(void)
        *CSR_FIQ_DISABLE = -1;
 
        for (irq = _DC21285_IRQ(0); irq < _DC21285_IRQ(20); irq++) {
-               set_irq_chip(irq, &fb_chip);
-               set_irq_handler(irq, handle_level_irq);
+               irq_set_chip(irq, &fb_chip);
+               irq_set_handler(irq, handle_level_irq);
                set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
        }
 }
index de7a5cb5dbe1abe9a578d10dcdf7b0c467bce63d..0bc528e6cb2327edd050044c2ec5beafb605b043 100644 (file)
@@ -151,14 +151,14 @@ void __init isa_init_irq(unsigned int host_irq)
 
        if (host_irq != (unsigned int)-1) {
                for (irq = _ISA_IRQ(0); irq < _ISA_IRQ(8); irq++) {
-                       set_irq_chip(irq, &isa_lo_chip);
-                       set_irq_handler(irq, handle_level_irq);
+                       irq_set_chip(irq, &isa_lo_chip);
+                       irq_set_handler(irq, handle_level_irq);
                        set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
                }
 
                for (irq = _ISA_IRQ(8); irq < _ISA_IRQ(16); irq++) {
-                       set_irq_chip(irq, &isa_hi_chip);
-                       set_irq_handler(irq, handle_level_irq);
+                       irq_set_chip(irq, &isa_hi_chip);
+                       irq_set_handler(irq, handle_level_irq);
                        set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
                }
 
@@ -166,7 +166,7 @@ void __init isa_init_irq(unsigned int host_irq)
                request_resource(&ioport_resource, &pic2_resource);
                setup_irq(IRQ_ISA_CASCADE, &irq_cascade);
 
-               set_irq_chained_handler(host_irq, isa_irq_handler);
+               irq_set_chained_handler(host_irq, isa_irq_handler);
 
                /*
                 * On the NetWinder, don't automatically
index c999b16c815f6f5d7ff7f1898c4811cd8a4b1346..0e7b56ea6295f931db7c6d1de15a173c0d1274b6 100644 (file)
@@ -217,13 +217,13 @@ void __init gemini_gpio_init(void)
 
                for (j = GPIO_IRQ_BASE + i * 32;
                     j < GPIO_IRQ_BASE + (i + 1) * 32; j++) {
-                       set_irq_chip(j, &gpio_irq_chip);
-                       set_irq_handler(j, handle_edge_irq);
+                       irq_set_chip(j, &gpio_irq_chip);
+                       irq_set_handler(j, handle_edge_irq);
                        set_irq_flags(j, IRQF_VALID);
                }
 
-               set_irq_chained_handler(IRQ_GPIO(i), gpio_irq_handler);
-               set_irq_data(IRQ_GPIO(i), (void *)i);
+               irq_set_chained_handler(IRQ_GPIO(i), gpio_irq_handler);
+               irq_set_handler_data(IRQ_GPIO(i), (void *)i);
        }
 
        BUG_ON(gpiochip_add(&gemini_gpio_chip));
index 96bc227dd8496c802db1f4e19745cb403e9b3a88..9485a8fdf851cf2a6c50f7530dd9d3c8b330fc16 100644 (file)
@@ -81,13 +81,13 @@ void __init gemini_init_irq(void)
        request_resource(&iomem_resource, &irq_resource);
 
        for (i = 0; i < NR_IRQS; i++) {
-               set_irq_chip(i, &gemini_irq_chip);
+               irq_set_chip(i, &gemini_irq_chip);
                if((i >= IRQ_TIMER1 && i <= IRQ_TIMER3) || (i >= IRQ_SERIRQ0 && i <= IRQ_SERIRQ1)) {
-                       set_irq_handler(i, handle_edge_irq);
+                       irq_set_handler(i, handle_edge_irq);
                        mode |= 1 << i;
                        level |= 1 << i;
                } else {                        
-                       set_irq_handler(i, handle_level_irq);
+                       irq_set_handler(i, handle_level_irq);
                }
                set_irq_flags(i, IRQF_VALID | IRQF_PROBE);
        }
index 1f28c90932c754d082848af2f85e9fba45f75b08..f118182a99ca316e17eab9f78ee8bd21b1f9793e 100644 (file)
@@ -199,29 +199,29 @@ void __init h720x_init_irq (void)
 
        /* Initialize global IRQ's, fast path */
        for (irq = 0; irq < NR_GLBL_IRQS; irq++) {
-               set_irq_chip(irq, &h720x_global_chip);
-               set_irq_handler(irq, handle_level_irq);
+               irq_set_chip(irq, &h720x_global_chip);
+               irq_set_handler(irq, handle_level_irq);
                set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
        }
 
        /* Initialize multiplexed IRQ's, slow path */
        for (irq = IRQ_CHAINED_GPIOA(0) ; irq <= IRQ_CHAINED_GPIOD(31); irq++) {
-               set_irq_chip(irq, &h720x_gpio_chip);
-               set_irq_handler(irq, handle_edge_irq);
+               irq_set_chip(irq, &h720x_gpio_chip);
+               irq_set_handler(irq, handle_edge_irq);
                set_irq_flags(irq, IRQF_VALID );
        }
-       set_irq_chained_handler(IRQ_GPIOA, h720x_gpioa_demux_handler);
-       set_irq_chained_handler(IRQ_GPIOB, h720x_gpiob_demux_handler);
-       set_irq_chained_handler(IRQ_GPIOC, h720x_gpioc_demux_handler);
-       set_irq_chained_handler(IRQ_GPIOD, h720x_gpiod_demux_handler);
+       irq_set_chained_handler(IRQ_GPIOA, h720x_gpioa_demux_handler);
+       irq_set_chained_handler(IRQ_GPIOB, h720x_gpiob_demux_handler);
+       irq_set_chained_handler(IRQ_GPIOC, h720x_gpioc_demux_handler);
+       irq_set_chained_handler(IRQ_GPIOD, h720x_gpiod_demux_handler);
 
 #ifdef CONFIG_CPU_H7202
        for (irq = IRQ_CHAINED_GPIOE(0) ; irq <= IRQ_CHAINED_GPIOE(31); irq++) {
-               set_irq_chip(irq, &h720x_gpio_chip);
-               set_irq_handler(irq, handle_edge_irq);
+               irq_set_chip(irq, &h720x_gpio_chip);
+               irq_set_handler(irq, handle_edge_irq);
                set_irq_flags(irq, IRQF_VALID );
        }
-       set_irq_chained_handler(IRQ_GPIOE, h720x_gpioe_demux_handler);
+       irq_set_chained_handler(IRQ_GPIOE, h720x_gpioe_demux_handler);
 #endif
 
        /* Enable multiplexed irq's */
index bcf91a517278574440422f807583bc0e2d0a726e..dd5c72a75dad944679a4b15dd4339b8a192e66f9 100644 (file)
@@ -202,11 +202,11 @@ void __init h7202_init_irq (void)
        for (irq = IRQ_TIMER1;
                          irq < IRQ_CHAINED_TIMERX(NR_TIMERX_IRQS); irq++) {
                __mask_timerx_irq(irq);
-               set_irq_chip(irq, &h7202_timerx_chip);
-               set_irq_handler(irq, handle_edge_irq);
+               irq_set_chip(irq, &h7202_timerx_chip);
+               irq_set_handler(irq, handle_edge_irq);
                set_irq_flags(irq, IRQF_VALID );
        }
-       set_irq_chained_handler(IRQ_TIMERX, h7202_timerx_demux_handler);
+       irq_set_chained_handler(IRQ_TIMERX, h7202_timerx_demux_handler);
 
        h720x_init_irq();
 }
index a233470dd10c8486031ced12f37b0ce31ab18ddb..bc739701c3014861fce43f525f0273e7dd8502e9 100644 (file)
@@ -224,15 +224,15 @@ void __init iop13xx_init_irq(void)
 
        for(i = 0; i <= IRQ_IOP13XX_HPI; i++) {
                if (i < 32)
-                       set_irq_chip(i, &iop13xx_irqchip1);
+                       irq_set_chip(i, &iop13xx_irqchip1);
                else if (i < 64)
-                       set_irq_chip(i, &iop13xx_irqchip2);
+                       irq_set_chip(i, &iop13xx_irqchip2);
                else if (i < 96)
-                       set_irq_chip(i, &iop13xx_irqchip3);
+                       irq_set_chip(i, &iop13xx_irqchip3);
                else
-                       set_irq_chip(i, &iop13xx_irqchip4);
+                       irq_set_chip(i, &iop13xx_irqchip4);
 
-               set_irq_handler(i, handle_level_irq);
+               irq_set_handler(i, handle_level_irq);
                set_irq_flags(i, IRQF_VALID | IRQF_PROBE);
        }
 
index c9c02e3698bc6d0cb2f348125c802788c6af3aed..560d5b2dec2270c00e06bebbe8bac54d7caa8585 100644 (file)
@@ -118,7 +118,7 @@ static void iop13xx_msi_handler(unsigned int irq, struct irq_desc *desc)
 
 void __init iop13xx_msi_init(void)
 {
-       set_irq_chained_handler(IRQ_IOP13XX_INBD_MSI, iop13xx_msi_handler);
+       irq_set_chained_handler(IRQ_IOP13XX_INBD_MSI, iop13xx_msi_handler);
 }
 
 /*
@@ -178,7 +178,7 @@ int arch_setup_msi_irq(struct pci_dev *pdev, struct msi_desc *desc)
        if (irq < 0)
                return irq;
 
-       set_irq_msi(irq, desc);
+       irq_set_msi_desc(irq, desc);
 
        msg.address_hi = 0x0;
        msg.address_lo = IOP13XX_MU_MIMR_PCI;
@@ -187,7 +187,7 @@ int arch_setup_msi_irq(struct pci_dev *pdev, struct msi_desc *desc)
        msg.data = (id << IOP13XX_MU_MIMR_CORE_SELECT) | (irq & 0x7f);
 
        write_msi_msg(irq, &msg);
-       set_irq_chip_and_handler(irq, &iop13xx_msi_chip, handle_simple_irq);
+       irq_set_chip_and_handler(irq, &iop13xx_msi_chip, handle_simple_irq);
 
        return 0;
 }
index d3426a120599e95617e8c82b954208244184ad09..226604633d662224c1f3df5d4901d8ee32d2e8ea 100644 (file)
@@ -68,8 +68,8 @@ void __init iop32x_init_irq(void)
                *IOP3XX_PCIIRSR = 0x0f;
 
        for (i = 0; i < NR_IRQS; i++) {
-               set_irq_chip(i, &ext_chip);
-               set_irq_handler(i, handle_level_irq);
+               irq_set_chip(i, &ext_chip);
+               irq_set_handler(i, handle_level_irq);
                set_irq_flags(i, IRQF_VALID | IRQF_PROBE);
        }
 }
index 0ff2f74363a51313cbb8c5d1e601bba3e5384370..7b205e9902989bf22b21dce39f451bc2698b5ebd 100644 (file)
@@ -110,8 +110,9 @@ void __init iop33x_init_irq(void)
                *IOP3XX_PCIIRSR = 0x0f;
 
        for (i = 0; i < NR_IRQS; i++) {
-               set_irq_chip(i, (i < 32) ? &iop33x_irqchip1 : &iop33x_irqchip2);
-               set_irq_handler(i, handle_level_irq);
+               irq_set_chip(i,
+                            (i < 32) ? &iop33x_irqchip1 : &iop33x_irqchip2);
+               irq_set_handler(i, handle_level_irq);
                set_irq_flags(i, IRQF_VALID | IRQF_PROBE);
        }
 }
index 5fc4e064b6504268122f988438de1c9d10ab0552..98956a136b944c7d1bff087d96bdee5cab5af805 100644 (file)
@@ -476,8 +476,8 @@ void __init ixp2000_init_irq(void)
         */
        for (irq = IRQ_IXP2000_SOFT_INT; irq <= IRQ_IXP2000_THDB3; irq++) {
                if ((1 << irq) & IXP2000_VALID_IRQ_MASK) {
-                       set_irq_chip(irq, &ixp2000_irq_chip);
-                       set_irq_handler(irq, handle_level_irq);
+                       irq_set_chip(irq, &ixp2000_irq_chip);
+                       irq_set_handler(irq, handle_level_irq);
                        set_irq_flags(irq, IRQF_VALID);
                } else set_irq_flags(irq, 0);
        }
@@ -485,21 +485,21 @@ void __init ixp2000_init_irq(void)
        for (irq = IRQ_IXP2000_DRAM0_MIN_ERR; irq <= IRQ_IXP2000_SP_INT; irq++) {
                if((1 << (irq - IRQ_IXP2000_DRAM0_MIN_ERR)) &
                                IXP2000_VALID_ERR_IRQ_MASK) {
-                       set_irq_chip(irq, &ixp2000_err_irq_chip);
-                       set_irq_handler(irq, handle_level_irq);
+                       irq_set_chip(irq, &ixp2000_err_irq_chip);
+                       irq_set_handler(irq, handle_level_irq);
                        set_irq_flags(irq, IRQF_VALID);
                }
                else
                        set_irq_flags(irq, 0);
        }
-       set_irq_chained_handler(IRQ_IXP2000_ERRSUM, ixp2000_err_irq_handler);
+       irq_set_chained_handler(IRQ_IXP2000_ERRSUM, ixp2000_err_irq_handler);
 
        for (irq = IRQ_IXP2000_GPIO0; irq <= IRQ_IXP2000_GPIO7; irq++) {
-               set_irq_chip(irq, &ixp2000_GPIO_irq_chip);
-               set_irq_handler(irq, handle_level_irq);
+               irq_set_chip(irq, &ixp2000_GPIO_irq_chip);
+               irq_set_handler(irq, handle_level_irq);
                set_irq_flags(irq, IRQF_VALID);
        }
-       set_irq_chained_handler(IRQ_IXP2000_GPIO, ixp2000_GPIO_irq_handler);
+       irq_set_chained_handler(IRQ_IXP2000_GPIO, ixp2000_GPIO_irq_handler);
 
        /*
         * Enable PCI irqs.  The actual PCI[AB] decoding is done in
@@ -508,8 +508,8 @@ void __init ixp2000_init_irq(void)
         */
        ixp2000_reg_write(IXP2000_IRQ_ENABLE_SET, (1 << IRQ_IXP2000_PCI));
        for (irq = IRQ_IXP2000_PCIA; irq <= IRQ_IXP2000_PCIB; irq++) {
-               set_irq_chip(irq, &ixp2000_pci_irq_chip);
-               set_irq_handler(irq, handle_level_irq);
+               irq_set_chip(irq, &ixp2000_pci_irq_chip);
+               irq_set_handler(irq, handle_level_irq);
                set_irq_flags(irq, IRQF_VALID);
        }
 }
index 7d90d3f13ee87046b40651bf1bf529a8530b7500..52f88648522f29551327d3d0dacd314b376f1607 100644 (file)
@@ -158,13 +158,13 @@ void __init ixdp2x00_init_irq(volatile unsigned long *stat_reg, volatile unsigne
        *board_irq_mask = 0xffffffff;
 
        for(irq = IXP2000_BOARD_IRQ(0); irq < IXP2000_BOARD_IRQ(board_irq_count); irq++) {
-               set_irq_chip(irq, &ixdp2x00_cpld_irq_chip);
-               set_irq_handler(irq, handle_level_irq);
+               irq_set_chip(irq, &ixdp2x00_cpld_irq_chip);
+               irq_set_handler(irq, handle_level_irq);
                set_irq_flags(irq, IRQF_VALID);
        }
 
        /* Hook into PCI interrupt */
-       set_irq_chained_handler(IRQ_IXP2000_PCIB, ixdp2x00_irq_handler);
+       irq_set_chained_handler(IRQ_IXP2000_PCIB, ixdp2x00_irq_handler);
 }
 
 /*************************************************************************
index 34b1b2af37c82fe9f78774749e5b48709d5b4928..f1ff50ba6c9a60f6c68128b1530631e98502397a 100644 (file)
@@ -115,8 +115,8 @@ void __init ixdp2x01_init_irq(void)
 
        for (irq = NR_IXP2000_IRQS; irq < NR_IXDP2X01_IRQS; irq++) {
                if (irq & valid_irq_mask) {
-                       set_irq_chip(irq, &ixdp2x01_irq_chip);
-                       set_irq_handler(irq, handle_level_irq);
+                       irq_set_chip(irq, &ixdp2x01_irq_chip);
+                       irq_set_handler(irq, handle_level_irq);
                        set_irq_flags(irq, IRQF_VALID);
                } else {
                        set_irq_flags(irq, 0);
@@ -124,7 +124,7 @@ void __init ixdp2x01_init_irq(void)
        }
 
        /* Hook into PCI interrupts */
-       set_irq_chained_handler(IRQ_IXP2000_PCIB, ixdp2x01_irq_handler);
+       irq_set_chained_handler(IRQ_IXP2000_PCIB, ixdp2x01_irq_handler);
 }
 
 
index 9c8a3390321675a656a3a54d424e8f3e8bf82a91..f2039722bace7fe5547243e34b4dd0f30cca4270 100644 (file)
@@ -289,12 +289,12 @@ static void ixp23xx_config_irq(unsigned int irq, enum ixp23xx_irq_type type)
 {
        switch (type) {
        case IXP23XX_IRQ_LEVEL:
-               set_irq_chip(irq, &ixp23xx_irq_level_chip);
-               set_irq_handler(irq, handle_level_irq);
+               irq_set_chip(irq, &ixp23xx_irq_level_chip);
+               irq_set_handler(irq, handle_level_irq);
                break;
        case IXP23XX_IRQ_EDGE:
-               set_irq_chip(irq, &ixp23xx_irq_edge_chip);
-               set_irq_handler(irq, handle_edge_irq);
+               irq_set_chip(irq, &ixp23xx_irq_edge_chip);
+               irq_set_handler(irq, handle_edge_irq);
                break;
        }
        set_irq_flags(irq, IRQF_VALID);
@@ -324,12 +324,12 @@ void __init ixp23xx_init_irq(void)
        }
 
        for (irq = IRQ_IXP23XX_INTA; irq <= IRQ_IXP23XX_INTB; irq++) {
-               set_irq_chip(irq, &ixp23xx_pci_irq_chip);
-               set_irq_handler(irq, handle_level_irq);
+               irq_set_chip(irq, &ixp23xx_pci_irq_chip);
+               irq_set_handler(irq, handle_level_irq);
                set_irq_flags(irq, IRQF_VALID);
        }
 
-       set_irq_chained_handler(IRQ_IXP23XX_PCI_INT_RPH, pci_handler);
+       irq_set_chained_handler(IRQ_IXP23XX_PCI_INT_RPH, pci_handler);
 }
 
 
index 181116aa6591236715b138951208e9860576da04..720befb0a402dd92792c334170811c82b3edf47e 100644 (file)
@@ -136,8 +136,8 @@ void __init ixdp2351_init_irq(void)
             irq++) {
                if (IXDP2351_INTA_IRQ_MASK(irq) & IXDP2351_INTA_IRQ_VALID) {
                        set_irq_flags(irq, IRQF_VALID);
-                       set_irq_handler(irq, handle_level_irq);
-                       set_irq_chip(irq, &ixdp2351_inta_chip);
+                       irq_set_handler(irq, handle_level_irq);
+                       irq_set_chip(irq, &ixdp2351_inta_chip);
                }
        }
 
@@ -147,13 +147,13 @@ void __init ixdp2351_init_irq(void)
             irq++) {
                if (IXDP2351_INTB_IRQ_MASK(irq) & IXDP2351_INTB_IRQ_VALID) {
                        set_irq_flags(irq, IRQF_VALID);
-                       set_irq_handler(irq, handle_level_irq);
-                       set_irq_chip(irq, &ixdp2351_intb_chip);
+                       irq_set_handler(irq, handle_level_irq);
+                       irq_set_chip(irq, &ixdp2351_intb_chip);
                }
        }
 
-       set_irq_chained_handler(IRQ_IXP23XX_INTA, ixdp2351_inta_handler);
-       set_irq_chained_handler(IRQ_IXP23XX_INTB, ixdp2351_intb_handler);
+       irq_set_chained_handler(IRQ_IXP23XX_INTA, ixdp2351_inta_handler);
+       irq_set_chained_handler(IRQ_IXP23XX_INTB, ixdp2351_intb_handler);
 }
 
 /*
index 76c61ba73218778987cec85683909e70ccf897fa..8fe0c6273262bbe26029736fc968a55d074b2495 100644 (file)
@@ -110,8 +110,8 @@ static int __init roadrunner_map_irq(struct pci_dev *dev, u8 idsel, u8 pin)
 
 static void __init roadrunner_pci_preinit(void)
 {
-       set_irq_type(IRQ_ROADRUNNER_PCI_INTC, IRQ_TYPE_LEVEL_LOW);
-       set_irq_type(IRQ_ROADRUNNER_PCI_INTD, IRQ_TYPE_LEVEL_LOW);
+       irq_set_irq_type(IRQ_ROADRUNNER_PCI_INTC, IRQ_TYPE_LEVEL_LOW);
+       irq_set_irq_type(IRQ_ROADRUNNER_PCI_INTD, IRQ_TYPE_LEVEL_LOW);
 
        ixp23xx_pci_preinit();
 }
index 845e1b5005484d0bfb79c6e8a0993951d3dc0341..162043ff29ff5af56ac045ec55732c205f048d81 100644 (file)
 
 void __init avila_pci_preinit(void)
 {
-       set_irq_type(IXP4XX_GPIO_IRQ(INTA), IRQ_TYPE_LEVEL_LOW);
-       set_irq_type(IXP4XX_GPIO_IRQ(INTB), IRQ_TYPE_LEVEL_LOW);
-       set_irq_type(IXP4XX_GPIO_IRQ(INTC), IRQ_TYPE_LEVEL_LOW);
-       set_irq_type(IXP4XX_GPIO_IRQ(INTD), IRQ_TYPE_LEVEL_LOW);
+       irq_set_irq_type(IXP4XX_GPIO_IRQ(INTA), IRQ_TYPE_LEVEL_LOW);
+       irq_set_irq_type(IXP4XX_GPIO_IRQ(INTB), IRQ_TYPE_LEVEL_LOW);
+       irq_set_irq_type(IXP4XX_GPIO_IRQ(INTC), IRQ_TYPE_LEVEL_LOW);
+       irq_set_irq_type(IXP4XX_GPIO_IRQ(INTD), IRQ_TYPE_LEVEL_LOW);
        ixp4xx_pci_preinit();
 }
 
index 9fd894271d5d0b353ca1e5214af258d22f99f686..eca5590711853416f7f63b1c0350484765b28921 100644 (file)
@@ -252,8 +252,8 @@ void __init ixp4xx_init_irq(void)
 
         /* Default to all level triggered */
        for(i = 0; i < NR_IRQS; i++) {
-               set_irq_chip(i, &ixp4xx_irq_chip);
-               set_irq_handler(i, handle_level_irq);
+               irq_set_chip(i, &ixp4xx_irq_chip);
+               irq_set_handler(i, handle_level_irq);
                set_irq_flags(i, IRQF_VALID);
        }
 }
index b978ea8bd6f09ed723aa18d2d7b7f23ceef93363..37fda7d6e83da4896746b60552e411e0265ff022 100644 (file)
@@ -32,8 +32,8 @@
 
 void __init coyote_pci_preinit(void)
 {
-       set_irq_type(IXP4XX_GPIO_IRQ(SLOT0_INTA), IRQ_TYPE_LEVEL_LOW);
-       set_irq_type(IXP4XX_GPIO_IRQ(SLOT1_INTA), IRQ_TYPE_LEVEL_LOW);
+       irq_set_irq_type(IXP4XX_GPIO_IRQ(SLOT0_INTA), IRQ_TYPE_LEVEL_LOW);
+       irq_set_irq_type(IXP4XX_GPIO_IRQ(SLOT1_INTA), IRQ_TYPE_LEVEL_LOW);
        ixp4xx_pci_preinit();
 }
 
index fa70fed462babf1a20dc2a0eba30313b726666b4..c7612010b3fc982c9cdc002ab3b998356e7e95b9 100644 (file)
 
 void __init dsmg600_pci_preinit(void)
 {
-       set_irq_type(IXP4XX_GPIO_IRQ(INTA), IRQ_TYPE_LEVEL_LOW);
-       set_irq_type(IXP4XX_GPIO_IRQ(INTB), IRQ_TYPE_LEVEL_LOW);
-       set_irq_type(IXP4XX_GPIO_IRQ(INTC), IRQ_TYPE_LEVEL_LOW);
-       set_irq_type(IXP4XX_GPIO_IRQ(INTD), IRQ_TYPE_LEVEL_LOW);
-       set_irq_type(IXP4XX_GPIO_IRQ(INTE), IRQ_TYPE_LEVEL_LOW);
-       set_irq_type(IXP4XX_GPIO_IRQ(INTF), IRQ_TYPE_LEVEL_LOW);
+       irq_set_irq_type(IXP4XX_GPIO_IRQ(INTA), IRQ_TYPE_LEVEL_LOW);
+       irq_set_irq_type(IXP4XX_GPIO_IRQ(INTB), IRQ_TYPE_LEVEL_LOW);
+       irq_set_irq_type(IXP4XX_GPIO_IRQ(INTC), IRQ_TYPE_LEVEL_LOW);
+       irq_set_irq_type(IXP4XX_GPIO_IRQ(INTD), IRQ_TYPE_LEVEL_LOW);
+       irq_set_irq_type(IXP4XX_GPIO_IRQ(INTE), IRQ_TYPE_LEVEL_LOW);
+       irq_set_irq_type(IXP4XX_GPIO_IRQ(INTF), IRQ_TYPE_LEVEL_LOW);
        ixp4xx_pci_preinit();
 }
 
index 5a810c930624cb0768259fc19043d32f8cfbda46..44ccde9d4879b02c79eec491e8864677de8c4853 100644 (file)
@@ -32,9 +32,9 @@
 
 void __init fsg_pci_preinit(void)
 {
-       set_irq_type(IXP4XX_GPIO_IRQ(INTA), IRQ_TYPE_LEVEL_LOW);
-       set_irq_type(IXP4XX_GPIO_IRQ(INTB), IRQ_TYPE_LEVEL_LOW);
-       set_irq_type(IXP4XX_GPIO_IRQ(INTC), IRQ_TYPE_LEVEL_LOW);
+       irq_set_irq_type(IXP4XX_GPIO_IRQ(INTA), IRQ_TYPE_LEVEL_LOW);
+       irq_set_irq_type(IXP4XX_GPIO_IRQ(INTB), IRQ_TYPE_LEVEL_LOW);
+       irq_set_irq_type(IXP4XX_GPIO_IRQ(INTC), IRQ_TYPE_LEVEL_LOW);
        ixp4xx_pci_preinit();
 }
 
index 7e93a0975c4d0ef4de231d67a5650fa43eb6b15c..fc11241688740df0077c036f1cc4f46574d3ff74 100644 (file)
@@ -29,8 +29,8 @@
 
 void __init gateway7001_pci_preinit(void)
 {
-       set_irq_type(IRQ_IXP4XX_GPIO10, IRQ_TYPE_LEVEL_LOW);
-       set_irq_type(IRQ_IXP4XX_GPIO11, IRQ_TYPE_LEVEL_LOW);
+       irq_set_irq_type(IRQ_IXP4XX_GPIO10, IRQ_TYPE_LEVEL_LOW);
+       irq_set_irq_type(IRQ_IXP4XX_GPIO11, IRQ_TYPE_LEVEL_LOW);
 
        ixp4xx_pci_preinit();
 }
index d0e4861ac03d5bc39c0f201d60e956f43559c28a..3e8c0e33b59ce46db2c83169ee2c616b809937e5 100644 (file)
@@ -420,8 +420,8 @@ static void __init gmlr_init(void)
        gpio_line_config(GPIO_HSS1_RTS_N, IXP4XX_GPIO_OUT);
        gpio_line_config(GPIO_HSS0_DCD_N, IXP4XX_GPIO_IN);
        gpio_line_config(GPIO_HSS1_DCD_N, IXP4XX_GPIO_IN);
-       set_irq_type(IXP4XX_GPIO_IRQ(GPIO_HSS0_DCD_N), IRQ_TYPE_EDGE_BOTH);
-       set_irq_type(IXP4XX_GPIO_IRQ(GPIO_HSS1_DCD_N), IRQ_TYPE_EDGE_BOTH);
+       irq_set_irq_type(IXP4XX_GPIO_IRQ(GPIO_HSS0_DCD_N), IRQ_TYPE_EDGE_BOTH);
+       irq_set_irq_type(IXP4XX_GPIO_IRQ(GPIO_HSS1_DCD_N), IRQ_TYPE_EDGE_BOTH);
 
        set_control(CONTROL_HSS0_DTR_N, 1);
        set_control(CONTROL_HSS1_DTR_N, 1);
@@ -441,10 +441,10 @@ static void __init gmlr_init(void)
 #ifdef CONFIG_PCI
 static void __init gmlr_pci_preinit(void)
 {
-       set_irq_type(IXP4XX_GPIO_IRQ(GPIO_IRQ_ETHA), IRQ_TYPE_LEVEL_LOW);
-       set_irq_type(IXP4XX_GPIO_IRQ(GPIO_IRQ_ETHB), IRQ_TYPE_LEVEL_LOW);
-       set_irq_type(IXP4XX_GPIO_IRQ(GPIO_IRQ_NEC), IRQ_TYPE_LEVEL_LOW);
-       set_irq_type(IXP4XX_GPIO_IRQ(GPIO_IRQ_MPCI), IRQ_TYPE_LEVEL_LOW);
+       irq_set_irq_type(IXP4XX_GPIO_IRQ(GPIO_IRQ_ETHA), IRQ_TYPE_LEVEL_LOW);
+       irq_set_irq_type(IXP4XX_GPIO_IRQ(GPIO_IRQ_ETHB), IRQ_TYPE_LEVEL_LOW);
+       irq_set_irq_type(IXP4XX_GPIO_IRQ(GPIO_IRQ_NEC), IRQ_TYPE_LEVEL_LOW);
+       irq_set_irq_type(IXP4XX_GPIO_IRQ(GPIO_IRQ_MPCI), IRQ_TYPE_LEVEL_LOW);
        ixp4xx_pci_preinit();
 }
 
index 25d2c333c2045f2e353b26ce3f74292a2cf69d4e..38cc0725dbd855cc4a6d147450ec5c0176479626 100644 (file)
@@ -43,8 +43,8 @@
  */
 void __init gtwx5715_pci_preinit(void)
 {
-       set_irq_type(IXP4XX_GPIO_IRQ(INTA), IRQ_TYPE_LEVEL_LOW);
-       set_irq_type(IXP4XX_GPIO_IRQ(INTB), IRQ_TYPE_LEVEL_LOW);
+       irq_set_irq_type(IXP4XX_GPIO_IRQ(INTA), IRQ_TYPE_LEVEL_LOW);
+       irq_set_irq_type(IXP4XX_GPIO_IRQ(INTB), IRQ_TYPE_LEVEL_LOW);
        ixp4xx_pci_preinit();
 }
 
index 1ba165a6edaca3b0b77583a7e7380c3ffe021f01..58f400417eaff182302164431a6dce138fccd527 100644 (file)
 
 void __init ixdp425_pci_preinit(void)
 {
-       set_irq_type(IXP4XX_GPIO_IRQ(INTA), IRQ_TYPE_LEVEL_LOW);
-       set_irq_type(IXP4XX_GPIO_IRQ(INTB), IRQ_TYPE_LEVEL_LOW);
-       set_irq_type(IXP4XX_GPIO_IRQ(INTC), IRQ_TYPE_LEVEL_LOW);
-       set_irq_type(IXP4XX_GPIO_IRQ(INTD), IRQ_TYPE_LEVEL_LOW);
+       irq_set_irq_type(IXP4XX_GPIO_IRQ(INTA), IRQ_TYPE_LEVEL_LOW);
+       irq_set_irq_type(IXP4XX_GPIO_IRQ(INTB), IRQ_TYPE_LEVEL_LOW);
+       irq_set_irq_type(IXP4XX_GPIO_IRQ(INTC), IRQ_TYPE_LEVEL_LOW);
+       irq_set_irq_type(IXP4XX_GPIO_IRQ(INTD), IRQ_TYPE_LEVEL_LOW);
        ixp4xx_pci_preinit();
 }
 
index 4ed7ac6149209448cba57dd42d49c28bb2a9eb7e..e64f6d04148866fe321ee5e9c91c29baa07a6495 100644 (file)
@@ -25,8 +25,8 @@
 
 void __init ixdpg425_pci_preinit(void)
 {
-       set_irq_type(IRQ_IXP4XX_GPIO6, IRQ_TYPE_LEVEL_LOW);
-       set_irq_type(IRQ_IXP4XX_GPIO7, IRQ_TYPE_LEVEL_LOW);
+       irq_set_irq_type(IRQ_IXP4XX_GPIO6, IRQ_TYPE_LEVEL_LOW);
+       irq_set_irq_type(IRQ_IXP4XX_GPIO7, IRQ_TYPE_LEVEL_LOW);
 
        ixp4xx_pci_preinit();
 }
index d0cea34cf61e4987d164895eee0b2208af004b0b..428d1202b7990e0df6c29f59a24e9df923ebc556 100644 (file)
 
 void __init nas100d_pci_preinit(void)
 {
-       set_irq_type(IXP4XX_GPIO_IRQ(INTA), IRQ_TYPE_LEVEL_LOW);
-       set_irq_type(IXP4XX_GPIO_IRQ(INTB), IRQ_TYPE_LEVEL_LOW);
-       set_irq_type(IXP4XX_GPIO_IRQ(INTC), IRQ_TYPE_LEVEL_LOW);
-       set_irq_type(IXP4XX_GPIO_IRQ(INTD), IRQ_TYPE_LEVEL_LOW);
-       set_irq_type(IXP4XX_GPIO_IRQ(INTE), IRQ_TYPE_LEVEL_LOW);
+       irq_set_irq_type(IXP4XX_GPIO_IRQ(INTA), IRQ_TYPE_LEVEL_LOW);
+       irq_set_irq_type(IXP4XX_GPIO_IRQ(INTB), IRQ_TYPE_LEVEL_LOW);
+       irq_set_irq_type(IXP4XX_GPIO_IRQ(INTC), IRQ_TYPE_LEVEL_LOW);
+       irq_set_irq_type(IXP4XX_GPIO_IRQ(INTD), IRQ_TYPE_LEVEL_LOW);
+       irq_set_irq_type(IXP4XX_GPIO_IRQ(INTE), IRQ_TYPE_LEVEL_LOW);
        ixp4xx_pci_preinit();
 }
 
index 1eb5a90470bc58e031d29942dcdfb66955352799..2e85f76b950de0711c3e94f6d176dba22961ba9a 100644 (file)
@@ -32,9 +32,9 @@
 
 void __init nslu2_pci_preinit(void)
 {
-       set_irq_type(IXP4XX_GPIO_IRQ(INTA), IRQ_TYPE_LEVEL_LOW);
-       set_irq_type(IXP4XX_GPIO_IRQ(INTB), IRQ_TYPE_LEVEL_LOW);
-       set_irq_type(IXP4XX_GPIO_IRQ(INTC), IRQ_TYPE_LEVEL_LOW);
+       irq_set_irq_type(IXP4XX_GPIO_IRQ(INTA), IRQ_TYPE_LEVEL_LOW);
+       irq_set_irq_type(IXP4XX_GPIO_IRQ(INTB), IRQ_TYPE_LEVEL_LOW);
+       irq_set_irq_type(IXP4XX_GPIO_IRQ(INTC), IRQ_TYPE_LEVEL_LOW);
        ixp4xx_pci_preinit();
 }
 
index f3111c6840efe6c110108bd7e24ba6b221651e94..03bdec5140a79f4515b8ed17018ab4fb77e3e68e 100644 (file)
@@ -38,8 +38,8 @@ void __init vulcan_pci_preinit(void)
        pr_info("Vulcan PCI: limiting CardBus memory size to %dMB\n",
                (int)(pci_cardbus_mem_size >> 20));
 #endif
-       set_irq_type(IXP4XX_GPIO_IRQ(INTA), IRQ_TYPE_LEVEL_LOW);
-       set_irq_type(IXP4XX_GPIO_IRQ(INTB), IRQ_TYPE_LEVEL_LOW);
+       irq_set_irq_type(IXP4XX_GPIO_IRQ(INTA), IRQ_TYPE_LEVEL_LOW);
+       irq_set_irq_type(IXP4XX_GPIO_IRQ(INTB), IRQ_TYPE_LEVEL_LOW);
        ixp4xx_pci_preinit();
 }
 
index 9b59ed03b15133713a0cf91939122d6e7569276b..17f3cf59a31beb95e6651c6c01aa0de070709090 100644 (file)
@@ -29,8 +29,8 @@
 
 void __init wg302v2_pci_preinit(void)
 {
-       set_irq_type(IRQ_IXP4XX_GPIO8, IRQ_TYPE_LEVEL_LOW);
-       set_irq_type(IRQ_IXP4XX_GPIO9, IRQ_TYPE_LEVEL_LOW);
+       irq_set_irq_type(IRQ_IXP4XX_GPIO8, IRQ_TYPE_LEVEL_LOW);
+       irq_set_irq_type(IRQ_IXP4XX_GPIO9, IRQ_TYPE_LEVEL_LOW);
 
        ixp4xx_pci_preinit();
 }
index cbdb5863d13b0df2e44d1618583ba43783d8f683..05d193a25b250d73c90830c52050e106e70eddca 100644 (file)
@@ -35,14 +35,15 @@ void __init kirkwood_init_irq(void)
         */
        orion_gpio_init(0, 32, GPIO_LOW_VIRT_BASE, 0,
                        IRQ_KIRKWOOD_GPIO_START);
-       set_irq_chained_handler(IRQ_KIRKWOOD_GPIO_LOW_0_7, gpio_irq_handler);
-       set_irq_chained_handler(IRQ_KIRKWOOD_GPIO_LOW_8_15, gpio_irq_handler);
-       set_irq_chained_handler(IRQ_KIRKWOOD_GPIO_LOW_16_23, gpio_irq_handler);
-       set_irq_chained_handler(IRQ_KIRKWOOD_GPIO_LOW_24_31, gpio_irq_handler);
+       irq_set_chained_handler(IRQ_KIRKWOOD_GPIO_LOW_0_7, gpio_irq_handler);
+       irq_set_chained_handler(IRQ_KIRKWOOD_GPIO_LOW_8_15, gpio_irq_handler);
+       irq_set_chained_handler(IRQ_KIRKWOOD_GPIO_LOW_16_23, gpio_irq_handler);
+       irq_set_chained_handler(IRQ_KIRKWOOD_GPIO_LOW_24_31, gpio_irq_handler);
 
        orion_gpio_init(32, 18, GPIO_HIGH_VIRT_BASE, 0,
                        IRQ_KIRKWOOD_GPIO_START + 32);
-       set_irq_chained_handler(IRQ_KIRKWOOD_GPIO_HIGH_0_7, gpio_irq_handler);
-       set_irq_chained_handler(IRQ_KIRKWOOD_GPIO_HIGH_8_15, gpio_irq_handler);
-       set_irq_chained_handler(IRQ_KIRKWOOD_GPIO_HIGH_16_23, gpio_irq_handler);
+       irq_set_chained_handler(IRQ_KIRKWOOD_GPIO_HIGH_0_7, gpio_irq_handler);
+       irq_set_chained_handler(IRQ_KIRKWOOD_GPIO_HIGH_8_15, gpio_irq_handler);
+       irq_set_chained_handler(IRQ_KIRKWOOD_GPIO_HIGH_16_23,
+                               gpio_irq_handler);
 }
index 55fbf7111a5bd3fb5e720fd68e2c023b965f9dcb..31e456508a6f4d83adbf06d256216a717dd1b96c 100644 (file)
@@ -80,7 +80,7 @@ int ks8695_gpio_interrupt(unsigned int pin, unsigned int type)
        local_irq_restore(flags);
 
        /* Set IRQ triggering type */
-       set_irq_type(gpio_irq[pin], type);
+       irq_set_irq_type(gpio_irq[pin], type);
 
        /* enable interrupt mode */
        ks8695_gpio_mode(pin, 0);
index 7998ccaa63331bd06939326d14a0182c82b8df66..da54a5d19237e54ee6f22c0865862cfb28a06ea8 100644 (file)
@@ -115,12 +115,12 @@ static int ks8695_irq_set_type(struct irq_data *d, unsigned int type)
        }
 
        if (level_triggered) {
-               set_irq_chip(d->irq, &ks8695_irq_level_chip);
-               set_irq_handler(d->irq, handle_level_irq);
+               irq_set_chip(d->irq, &ks8695_irq_level_chip);
+               irq_set_handler(d->irq, handle_level_irq);
        }
        else {
-               set_irq_chip(d->irq, &ks8695_irq_edge_chip);
-               set_irq_handler(d->irq, handle_edge_irq);
+               irq_set_chip(d->irq, &ks8695_irq_edge_chip);
+               irq_set_handler(d->irq, handle_edge_irq);
        }
 
        __raw_writel(ctrl, KS8695_GPIO_VA + KS8695_IOPC);
@@ -158,16 +158,16 @@ void __init ks8695_init_irq(void)
                        case KS8695_IRQ_UART_RX:
                        case KS8695_IRQ_COMM_TX:
                        case KS8695_IRQ_COMM_RX:
-                               set_irq_chip(irq, &ks8695_irq_level_chip);
-                               set_irq_handler(irq, handle_level_irq);
+                               irq_set_chip(irq, &ks8695_irq_level_chip);
+                               irq_set_handler(irq, handle_level_irq);
                                break;
 
                        /* Edge-triggered interrupts */
                        default:
                                /* clear pending bit */
                                ks8695_irq_ack(irq_get_irq_data(irq));
-                               set_irq_chip(irq, &ks8695_irq_edge_chip);
-                               set_irq_handler(irq, handle_edge_irq);
+                               irq_set_chip(irq, &ks8695_irq_edge_chip);
+                               irq_set_handler(irq, handle_edge_irq);
                }
 
                set_irq_flags(irq, IRQF_VALID);
index 316ecbf6c586a6874e1855e3e5a9cb81f7238069..3088ca3286661513302fbf38a03f84f693514172 100644 (file)
@@ -290,7 +290,7 @@ static int lpc32xx_set_irq_type(struct irq_data *d, unsigned int type)
        }
 
        /* Ok to use the level handler for all types */
-       set_irq_handler(d->irq, handle_level_irq);
+       irq_set_handler(d->irq, handle_level_irq);
 
        return 0;
 }
@@ -390,8 +390,8 @@ void __init lpc32xx_init_irq(void)
 
        /* Configure supported IRQ's */
        for (i = 0; i < NR_IRQS; i++) {
-               set_irq_chip(i, &lpc32xx_irq_chip);
-               set_irq_handler(i, handle_level_irq);
+               irq_set_chip(i, &lpc32xx_irq_chip);
+               irq_set_handler(i, handle_level_irq);
                set_irq_flags(i, IRQF_VALID);
        }
 
@@ -406,8 +406,8 @@ void __init lpc32xx_init_irq(void)
        __raw_writel(0, LPC32XX_INTC_MASK(LPC32XX_SIC2_BASE));
 
        /* MIC SUBIRQx interrupts will route handling to the chain handlers */
-       set_irq_chained_handler(IRQ_LPC32XX_SUB1IRQ, lpc32xx_sic1_handler);
-       set_irq_chained_handler(IRQ_LPC32XX_SUB2IRQ, lpc32xx_sic2_handler);
+       irq_set_chained_handler(IRQ_LPC32XX_SUB1IRQ, lpc32xx_sic1_handler);
+       irq_set_chained_handler(IRQ_LPC32XX_SUB2IRQ, lpc32xx_sic2_handler);
 
        /* Initially disable all wake events */
        __raw_writel(0, LPC32XX_CLKPWR_P01_ER);
index fa037038e7b839632f905b489356b33201bb6d39..d21c5441a3d0c7c8e0649376b4556d29b6e44cd5 100644 (file)
@@ -110,9 +110,9 @@ static void init_mux_irq(struct irq_chip *chip, int start, int num)
                if (chip->irq_ack)
                        chip->irq_ack(d);
 
-               set_irq_chip(irq, chip);
+               irq_set_chip(irq, chip);
                set_irq_flags(irq, IRQF_VALID);
-               set_irq_handler(irq, handle_level_irq);
+               irq_set_handler(irq, handle_level_irq);
        }
 }
 
@@ -122,7 +122,7 @@ void __init mmp2_init_icu(void)
 
        for (irq = 0; irq < IRQ_MMP2_MUX_BASE; irq++) {
                icu_mask_irq(irq_get_irq_data(irq));
-               set_irq_chip(irq, &icu_irq_chip);
+               irq_set_chip(irq, &icu_irq_chip);
                set_irq_flags(irq, IRQF_VALID);
 
                switch (irq) {
@@ -133,7 +133,7 @@ void __init mmp2_init_icu(void)
                case IRQ_MMP2_SSP_MUX:
                        break;
                default:
-                       set_irq_handler(irq, handle_level_irq);
+                       irq_set_handler(irq, handle_level_irq);
                        break;
                }
        }
@@ -149,9 +149,9 @@ void __init mmp2_init_icu(void)
        init_mux_irq(&misc_irq_chip, IRQ_MMP2_MISC_BASE, 15);
        init_mux_irq(&ssp_irq_chip, IRQ_MMP2_SSP_BASE, 2);
 
-       set_irq_chained_handler(IRQ_MMP2_PMIC_MUX, pmic_irq_demux);
-       set_irq_chained_handler(IRQ_MMP2_RTC_MUX, rtc_irq_demux);
-       set_irq_chained_handler(IRQ_MMP2_TWSI_MUX, twsi_irq_demux);
-       set_irq_chained_handler(IRQ_MMP2_MISC_MUX, misc_irq_demux);
-       set_irq_chained_handler(IRQ_MMP2_SSP_MUX, ssp_irq_demux);
+       irq_set_chained_handler(IRQ_MMP2_PMIC_MUX, pmic_irq_demux);
+       irq_set_chained_handler(IRQ_MMP2_RTC_MUX, rtc_irq_demux);
+       irq_set_chained_handler(IRQ_MMP2_TWSI_MUX, twsi_irq_demux);
+       irq_set_chained_handler(IRQ_MMP2_MISC_MUX, misc_irq_demux);
+       irq_set_chained_handler(IRQ_MMP2_SSP_MUX, ssp_irq_demux);
 }
index f86b450cb93c86daf0923f7fdbf086e17df16ebd..6a8676205e6ecf4c10caa5b14cf1088055a55623 100644 (file)
@@ -48,8 +48,8 @@ void __init icu_init_irq(void)
 
        for (irq = 0; irq < 64; irq++) {
                icu_mask_irq(irq_get_irq_data(irq));
-               set_irq_chip(irq, &icu_irq_chip);
-               set_irq_handler(irq, handle_level_irq);
+               irq_set_chip(irq, &icu_irq_chip);
+               irq_set_handler(irq, handle_level_irq);
                set_irq_flags(irq, IRQF_VALID);
        }
 }
index 1993721d472edf422f35e2ff7b1423b16866f7ab..35c7ceeb3f29bfa1b7cb7aa606dfe7930a543712 100644 (file)
@@ -53,7 +53,7 @@ static void __init msm8960_init_irq(void)
         */
        for (i = GIC_PPI_START; i < GIC_SPI_START; i++) {
                if (i != AVS_SVICINT && i != AVS_SVICINTSWDONE)
-                       set_irq_handler(i, handle_percpu_irq);
+                       irq_set_handler(i, handle_percpu_irq);
        }
 }
 
index b3c55f138fce8909250cc51d642f462d91a1c524..1163b6fd05d2ceb71ae21b5b3bef550a65ba3ca6 100644 (file)
@@ -56,7 +56,7 @@ static void __init msm8x60_init_irq(void)
         */
        for (i = GIC_PPI_START; i < GIC_SPI_START; i++) {
                if (i != AVS_SVICINT && i != AVS_SVICINTSWDONE)
-                       set_irq_handler(i, handle_percpu_irq);
+                       irq_set_handler(i, handle_percpu_irq);
        }
 }
 
index 31117a4499c4bcb543904e0fbad05202df7111d6..ffcd4f3c63ee89afde5aa9a1eaf8e3579333712e 100644 (file)
@@ -214,17 +214,17 @@ int __init trout_init_gpio(void)
 {
        int i;
        for(i = TROUT_INT_START; i <= TROUT_INT_END; i++) {
-               set_irq_chip(i, &trout_gpio_irq_chip);
-               set_irq_handler(i, handle_edge_irq);
+               irq_set_chip(i, &trout_gpio_irq_chip);
+               irq_set_handler(i, handle_edge_irq);
                set_irq_flags(i, IRQF_VALID);
        }
 
        for (i = 0; i < ARRAY_SIZE(msm_gpio_banks); i++)
                gpiochip_add(&msm_gpio_banks[i].chip);
 
-       set_irq_type(MSM_GPIO_TO_INT(17), IRQF_TRIGGER_HIGH);
-       set_irq_chained_handler(MSM_GPIO_TO_INT(17), trout_gpio_irq_handler);
-       set_irq_wake(MSM_GPIO_TO_INT(17), 1);
+       irq_set_irq_type(MSM_GPIO_TO_INT(17), IRQF_TRIGGER_HIGH);
+       irq_set_chained_handler(MSM_GPIO_TO_INT(17), trout_gpio_irq_handler);
+       irq_set_irq_wake(MSM_GPIO_TO_INT(17), 1);
 
        return 0;
 }
index 44be8464657b323b9a49921a6ad39ab02b27a0f2..f7a9724788b0f54fe7dc7e239d895d9ed6162ffa 100644 (file)
@@ -174,7 +174,7 @@ int __init trout_init_mmc(unsigned int sys_rev)
        if (IS_ERR(vreg_sdslot))
                return PTR_ERR(vreg_sdslot);
 
-       set_irq_wake(TROUT_GPIO_TO_INT(TROUT_GPIO_SDMC_CD_N), 1);
+       irq_set_irq_wake(TROUT_GPIO_TO_INT(TROUT_GPIO_SDMC_CD_N), 1);
 
        if (!opt_disable_sdcard)
                msm_add_sdcc(2, &trout_sdslot_data,
index e00e4dee4274bb0766812130a89e1f14c350cf3e..997ded1270bfe31be89102f375bd17c21e641fc6 100644 (file)
@@ -328,12 +328,12 @@ static int msm_gpio_irq_set_wake(struct irq_data *d, unsigned int on)
 
        if (on) {
                if (bitmap_empty(msm_gpio.wake_irqs, NR_GPIO_IRQS))
-                       set_irq_wake(TLMM_SCSS_SUMMARY_IRQ, 1);
+                       irq_set_irq_wake(TLMM_SCSS_SUMMARY_IRQ, 1);
                set_bit(gpio, msm_gpio.wake_irqs);
        } else {
                clear_bit(gpio, msm_gpio.wake_irqs);
                if (bitmap_empty(msm_gpio.wake_irqs, NR_GPIO_IRQS))
-                       set_irq_wake(TLMM_SCSS_SUMMARY_IRQ, 0);
+                       irq_set_irq_wake(TLMM_SCSS_SUMMARY_IRQ, 0);
        }
 
        return 0;
@@ -362,12 +362,12 @@ static int __devinit msm_gpio_probe(struct platform_device *dev)
 
        for (i = 0; i < msm_gpio.gpio_chip.ngpio; ++i) {
                irq = msm_gpio_to_irq(&msm_gpio.gpio_chip, i);
-               set_irq_chip(irq, &msm_gpio_irq_chip);
-               set_irq_handler(irq, handle_level_irq);
+               irq_set_chip(irq, &msm_gpio_irq_chip);
+               irq_set_handler(irq, handle_level_irq);
                set_irq_flags(irq, IRQF_VALID);
        }
 
-       set_irq_chained_handler(TLMM_SCSS_SUMMARY_IRQ,
+       irq_set_chained_handler(TLMM_SCSS_SUMMARY_IRQ,
                                msm_summary_irq_handler);
        return 0;
 }
@@ -379,7 +379,7 @@ static int __devexit msm_gpio_remove(struct platform_device *dev)
        if (ret < 0)
                return ret;
 
-       set_irq_handler(TLMM_SCSS_SUMMARY_IRQ, NULL);
+       irq_set_handler(TLMM_SCSS_SUMMARY_IRQ, NULL);
 
        return 0;
 }
index 448f2677051b80b6af0330d2314c562b8606d3f5..c9e0c616545c77d94f671528ac7c8d93fd3dd608 100644 (file)
@@ -354,9 +354,9 @@ static int __init msm_init_gpio(void)
                        msm_gpio_chips[j].chip.base +
                        msm_gpio_chips[j].chip.ngpio)
                        j++;
-               set_irq_chip_data(i, &msm_gpio_chips[j]);
-               set_irq_chip(i, &msm_gpio_irq_chip);
-               set_irq_handler(i, handle_edge_irq);
+               irq_set_chip_data(i, &msm_gpio_chips[j]);
+               irq_set_chip(i, &msm_gpio_irq_chip);
+               irq_set_handler(i, handle_edge_irq);
                set_irq_flags(i, IRQF_VALID);
        }
 
@@ -366,10 +366,10 @@ static int __init msm_init_gpio(void)
                gpiochip_add(&msm_gpio_chips[i].chip);
        }
 
-       set_irq_chained_handler(INT_GPIO_GROUP1, msm_gpio_irq_handler);
-       set_irq_chained_handler(INT_GPIO_GROUP2, msm_gpio_irq_handler);
-       set_irq_wake(INT_GPIO_GROUP1, 1);
-       set_irq_wake(INT_GPIO_GROUP2, 2);
+       irq_set_chained_handler(INT_GPIO_GROUP1, msm_gpio_irq_handler);
+       irq_set_chained_handler(INT_GPIO_GROUP2, msm_gpio_irq_handler);
+       irq_set_irq_wake(INT_GPIO_GROUP1, 1);
+       irq_set_irq_wake(INT_GPIO_GROUP2, 2);
        return 0;
 }
 
index 84b8103b46868135a8c09f4bb78f14f550d4b0c5..7a805bec32afaa7adad734a4fbc932cf2e783a4a 100644 (file)
@@ -357,8 +357,8 @@ void __init msm_init_irq(void)
        writel(3, VIC_INT_MASTEREN);
 
        for (n = 0; n < NR_MSM_IRQS; n++) {
-               set_irq_chip(n, &msm_irq_chip);
-               set_irq_handler(n, handle_level_irq);
+               irq_set_chip(n, &msm_irq_chip);
+               irq_set_handler(n, handle_level_irq);
                set_irq_flags(n, IRQF_VALID);
        }
 }
index 8033c6aab974bcc49b226a2b98341626e8be23fc..782e8054539e7766a81c166fd11d2e77347452b5 100644 (file)
@@ -145,8 +145,8 @@ void __init msm_init_irq(void)
        writel(1, VIC_INT_MASTEREN);
 
        for (n = 0; n < NR_MSM_IRQS; n++) {
-               set_irq_chip(n, &msm_irq_chip);
-               set_irq_handler(n, handle_level_irq);
+               irq_set_chip(n, &msm_irq_chip);
+               irq_set_handler(n, handle_level_irq);
                set_irq_flags(n, IRQF_VALID);
        }
 }
index cfab1c472fbc49888ddb0c943de34d97e6f1fe8e..276f91899ff3a4f20b5cf61dea198c8f464479d4 100644 (file)
@@ -158,15 +158,15 @@ void __init msm_init_sirc(void)
        wake_enable = 0;
 
        for (i = FIRST_SIRC_IRQ; i < LAST_SIRC_IRQ; i++) {
-               set_irq_chip(i, &sirc_irq_chip);
-               set_irq_handler(i, handle_edge_irq);
+               irq_set_chip(i, &sirc_irq_chip);
+               irq_set_handler(i, handle_edge_irq);
                set_irq_flags(i, IRQF_VALID);
        }
 
        for (i = 0; i < ARRAY_SIZE(sirc_reg_table); i++) {
-               set_irq_chained_handler(sirc_reg_table[i].cascade_irq,
+               irq_set_chained_handler(sirc_reg_table[i].cascade_irq,
                                        sirc_irq_handler);
-               set_irq_wake(sirc_reg_table[i].cascade_irq, 1);
+               irq_set_irq_wake(sirc_reg_table[i].cascade_irq, 1);
        }
        return;
 }
index 08da497c39c2db2d927cff8f8adeb61bfa5c52e8..3e24431bb5eaf929c28ed46cd77b62286711c512 100644 (file)
@@ -38,8 +38,8 @@ void __init mv78xx0_init_irq(void)
        orion_gpio_init(0, 32, GPIO_VIRT_BASE,
                        mv78xx0_core_index() ? 0x18 : 0,
                        IRQ_MV78XX0_GPIO_START);
-       set_irq_chained_handler(IRQ_MV78XX0_GPIO_0_7, gpio_irq_handler);
-       set_irq_chained_handler(IRQ_MV78XX0_GPIO_8_15, gpio_irq_handler);
-       set_irq_chained_handler(IRQ_MV78XX0_GPIO_16_23, gpio_irq_handler);
-       set_irq_chained_handler(IRQ_MV78XX0_GPIO_24_31, gpio_irq_handler);
+       irq_set_chained_handler(IRQ_MV78XX0_GPIO_0_7, gpio_irq_handler);
+       irq_set_chained_handler(IRQ_MV78XX0_GPIO_8_15, gpio_irq_handler);
+       irq_set_chained_handler(IRQ_MV78XX0_GPIO_16_23, gpio_irq_handler);
+       irq_set_chained_handler(IRQ_MV78XX0_GPIO_24_31, gpio_irq_handler);
 }
index 4e4b780c481df9c371e12bc8d18217440c78bbe4..de494525ec7e48d50f3494bd149a6fcfe6c27cdd 100644 (file)
@@ -199,12 +199,12 @@ static void __init mx31ads_init_expio(void)
        __raw_writew(0xFFFF, PBC_INTSTATUS_REG);
        for (i = MXC_EXP_IO_BASE; i < (MXC_EXP_IO_BASE + MXC_MAX_EXP_IO_LINES);
             i++) {
-               set_irq_chip(i, &expio_irq_chip);
-               set_irq_handler(i, handle_level_irq);
+               irq_set_chip(i, &expio_irq_chip);
+               irq_set_handler(i, handle_level_irq);
                set_irq_flags(i, IRQF_VALID);
        }
-       set_irq_type(EXPIO_PARENT_INT, IRQ_TYPE_LEVEL_HIGH);
-       set_irq_chained_handler(EXPIO_PARENT_INT, mx31ads_expio_irq_handler);
+       irq_set_irq_type(EXPIO_PARENT_INT, IRQ_TYPE_LEVEL_HIGH);
+       irq_set_chained_handler(EXPIO_PARENT_INT, mx31ads_expio_irq_handler);
 }
 
 #ifdef CONFIG_MACH_MX31ADS_WM1133_EV1
index e83ffadb65f862934f39c6b5ee1b0cd94acbaff4..4a8550529b04f6aa6fbb4a2c3a635da7c7467d2e 100644 (file)
@@ -212,7 +212,7 @@ void __init eukrea_mbimx51_baseboard_init(void)
 
        gpio_request(MBIMX51_TSC2007_GPIO, "tsc2007_irq");
        gpio_direction_input(MBIMX51_TSC2007_GPIO);
-       set_irq_type(MBIMX51_TSC2007_IRQ, IRQF_TRIGGER_FALLING);
+       irq_set_irq_type(MBIMX51_TSC2007_IRQ, IRQF_TRIGGER_FALLING);
        i2c_register_board_info(1, mbimx51_i2c_devices,
                                ARRAY_SIZE(mbimx51_i2c_devices));
 
index 56fa2ed15222654446a6bb317818542bbe7ecb4f..a1e01dd4a4ff6d41818d7c60b80584562d39250e 100644 (file)
@@ -136,7 +136,7 @@ static int mxs_gpio_set_irq_type(struct irq_data *d, unsigned int type)
 static void mxs_gpio_irq_handler(u32 irq, struct irq_desc *desc)
 {
        u32 irq_stat;
-       struct mxs_gpio_port *port = (struct mxs_gpio_port *)get_irq_data(irq);
+       struct mxs_gpio_port *port = (struct mxs_gpio_port *)irq_get_handler_data(irq);
        u32 gpio_irq_no_base = port->virtual_irq_start;
 
        desc->irq_data.chip->irq_ack(&desc->irq_data);
@@ -265,14 +265,14 @@ int __init mxs_gpio_init(struct mxs_gpio_port *port, int cnt)
 
                for (j = port[i].virtual_irq_start;
                        j < port[i].virtual_irq_start + 32; j++) {
-                       set_irq_chip(j, &gpio_irq_chip);
-                       set_irq_handler(j, handle_level_irq);
+                       irq_set_chip(j, &gpio_irq_chip);
+                       irq_set_handler(j, handle_level_irq);
                        set_irq_flags(j, IRQF_VALID);
                }
 
                /* setup one handler for each entry */
-               set_irq_chained_handler(port[i].irq, mxs_gpio_irq_handler);
-               set_irq_data(port[i].irq, &port[i]);
+               irq_set_chained_handler(port[i].irq, mxs_gpio_irq_handler);
+               irq_set_handler_data(port[i].irq, &port[i]);
 
                /* register gpio chip */
                port[i].chip.direction_input = mxs_gpio_direction_input;
index 0f4c120fc169f0098710ac8ce433046f32563258..ae8a0d98f995c0343c26993cc7fc45f1252ae6b0 100644 (file)
@@ -74,8 +74,8 @@ void __init icoll_init_irq(void)
        mxs_reset_block(icoll_base + HW_ICOLL_CTRL);
 
        for (i = 0; i < MXS_INTERNAL_IRQS; i++) {
-               set_irq_chip(i, &mxs_icoll_chip);
-               set_irq_handler(i, handle_level_irq);
+               irq_set_chip(i, &mxs_icoll_chip);
+               irq_set_handler(i, handle_level_irq);
                set_irq_flags(i, IRQF_VALID);
        }
 }
index 29ffa750fbe6413d178cdf008323cf89b02b93f9..783e327892dcd2cb7005b7159baedb12d6eaa7b9 100644 (file)
@@ -171,13 +171,13 @@ void __init netx_init_irq(void)
        vic_init(__io(io_p2v(NETX_PA_VIC)), 0, ~0, 0);
 
        for (irq = NETX_IRQ_HIF_CHAINED(0); irq <= NETX_IRQ_HIF_LAST; irq++) {
-               set_irq_chip(irq, &netx_hif_chip);
-               set_irq_handler(irq, handle_level_irq);
+               irq_set_chip(irq, &netx_hif_chip);
+               irq_set_handler(irq, handle_level_irq);
                set_irq_flags(irq, IRQF_VALID);
        }
 
        writel(NETX_DPMAS_INT_EN_GLB_EN, NETX_DPMAS_INT_EN);
-       set_irq_chained_handler(NETX_IRQ_HIF, netx_hif_demux_handler);
+       irq_set_chained_handler(NETX_IRQ_HIF, netx_hif_demux_handler);
 }
 
 static int __init netx_init(void)
index 0c0d5248c3687734a5296184eb33f6f8b6fb0093..7e29e4ae03ee26f2cf416507feeef09f82e3187d 100644 (file)
@@ -107,8 +107,8 @@ void __init board_a9m9750dev_init_irq(void)
                                __func__);
 
        for (i = FPGA_IRQ(0); i <= FPGA_IRQ(7); ++i) {
-               set_irq_chip(i, &a9m9750dev_fpga_chip);
-               set_irq_handler(i, handle_level_irq);
+               irq_set_chip(i, &a9m9750dev_fpga_chip);
+               irq_set_handler(i, handle_level_irq);
                set_irq_flags(i, IRQF_VALID);
        }
 
@@ -118,8 +118,8 @@ void __init board_a9m9750dev_init_irq(void)
        REGSET(eic, SYS_EIC, LVEDG, LEVEL);
        __raw_writel(eic, SYS_EIC(2));
 
-       set_irq_chained_handler(IRQ_NS9XXX_EXT2,
-                       a9m9750dev_fpga_demux_handler);
+       irq_set_chained_handler(IRQ_NS9XXX_EXT2,
+                               a9m9750dev_fpga_demux_handler);
 }
 
 void __init board_a9m9750dev_init_machine(void)
index bf0fd48cbd80016c1190e45161da4d6e24ee45a8..14997e9fdb7ad8feaec130743b51dbd587418948 100644 (file)
@@ -67,8 +67,8 @@ void __init ns9xxx_init_irq(void)
                __raw_writel(prio2irq(i), SYS_IVA(i));
 
        for (i = 0; i <= 31; ++i) {
-               set_irq_chip(i, &ns9xxx_chip);
-               set_irq_handler(i, handle_fasteoi_irq);
+               irq_set_chip(i, &ns9xxx_chip);
+               irq_set_handler(i, handle_fasteoi_irq);
                set_irq_flags(i, IRQF_VALID);
                irq_set_status_flags(i, IRQ_LEVEL);
        }
index 1f8a05a228345246bce7f2ae6b4e9c622ec0140f..fcf1212d97060484397a7f1be9ec4b59d9ac2168 100644 (file)
@@ -59,8 +59,8 @@ void __init nuc93x_init_irq(void)
        __raw_writel(0xFFFFFFFE, REG_AIC_MDCR);
 
        for (irqno = IRQ_WDT; irqno <= NR_IRQS; irqno++) {
-               set_irq_chip(irqno, &nuc93x_irq_chip);
-               set_irq_handler(irqno, handle_level_irq);
+               irq_set_chip(irqno, &nuc93x_irq_chip);
+               irq_set_handler(irqno, handle_level_irq);
                set_irq_flags(irqno, IRQF_VALID);
        }
 }
index 7c5e2112c776ecc47c480a4afd27805a77a989e4..e68dfde1918e7dd437808e49c8e7fcf93089586c 100644 (file)
@@ -276,7 +276,7 @@ static void __init osk_init_cf(void)
                return;
        }
        /* the CF I/O IRQ is really active-low */
-       set_irq_type(gpio_to_irq(62), IRQ_TYPE_EDGE_FALLING);
+       irq_set_irq_type(gpio_to_irq(62), IRQ_TYPE_EDGE_FALLING);
 }
 
 static void __init osk_init_irq(void)
@@ -482,7 +482,7 @@ static void __init osk_mistral_init(void)
        omap_cfg_reg(P20_1610_GPIO4);   /* PENIRQ */
        gpio_request(4, "ts_int");
        gpio_direction_input(4);
-       set_irq_type(gpio_to_irq(4), IRQ_TYPE_EDGE_FALLING);
+       irq_set_irq_type(gpio_to_irq(4), IRQ_TYPE_EDGE_FALLING);
 
        spi_register_board_info(mistral_boardinfo,
                        ARRAY_SIZE(mistral_boardinfo));
@@ -500,7 +500,7 @@ static void __init osk_mistral_init(void)
                int irq = gpio_to_irq(OMAP_MPUIO(2));
 
                gpio_direction_input(OMAP_MPUIO(2));
-               set_irq_type(irq, IRQ_TYPE_EDGE_RISING);
+               irq_set_irq_type(irq, IRQ_TYPE_EDGE_RISING);
 #ifdef CONFIG_PM
                /* share the IRQ in case someone wants to use the
                 * button for more than wakeup from system sleep.
index d7bbbe721a75f7ae8339863ce41fc9b69cfd871c..45f01d2c3a7a0c812c06d134cbd829f2277f11d6 100644 (file)
@@ -256,12 +256,12 @@ palmz71_powercable(int irq, void *dev_id)
 {
        if (gpio_get_value(PALMZ71_USBDETECT_GPIO)) {
                printk(KERN_INFO "PM: Power cable connected\n");
-               set_irq_type(gpio_to_irq(PALMZ71_USBDETECT_GPIO),
-                               IRQ_TYPE_EDGE_FALLING);
+               irq_set_irq_type(gpio_to_irq(PALMZ71_USBDETECT_GPIO),
+                                IRQ_TYPE_EDGE_FALLING);
        } else {
                printk(KERN_INFO "PM: Power cable disconnected\n");
-               set_irq_type(gpio_to_irq(PALMZ71_USBDETECT_GPIO),
-                               IRQ_TYPE_EDGE_RISING);
+               irq_set_irq_type(gpio_to_irq(PALMZ71_USBDETECT_GPIO),
+                                IRQ_TYPE_EDGE_RISING);
        }
        return IRQ_HANDLED;
 }
index bdc0ac8dc21f4069bcaeddb00d7a080c61724da1..65d24204937a9da268fb333bfda122448cc050ad 100644 (file)
@@ -279,10 +279,10 @@ static void __init voiceblue_init(void)
        gpio_request(13, "16C554 irq");
        gpio_request(14, "16C554 irq");
        gpio_request(15, "16C554 irq");
-       set_irq_type(gpio_to_irq(12), IRQ_TYPE_EDGE_RISING);
-       set_irq_type(gpio_to_irq(13), IRQ_TYPE_EDGE_RISING);
-       set_irq_type(gpio_to_irq(14), IRQ_TYPE_EDGE_RISING);
-       set_irq_type(gpio_to_irq(15), IRQ_TYPE_EDGE_RISING);
+       irq_set_irq_type(gpio_to_irq(12), IRQ_TYPE_EDGE_RISING);
+       irq_set_irq_type(gpio_to_irq(13), IRQ_TYPE_EDGE_RISING);
+       irq_set_irq_type(gpio_to_irq(14), IRQ_TYPE_EDGE_RISING);
+       irq_set_irq_type(gpio_to_irq(15), IRQ_TYPE_EDGE_RISING);
 
        platform_add_devices(voiceblue_devices, ARRAY_SIZE(voiceblue_devices));
        omap_board_config = voiceblue_config;
index 0ace7998aaa5301f1b4b5881482644cffec1d622..cddbf8b089cef4c08e2d9138e886b7cd0f086e06 100644 (file)
@@ -156,17 +156,17 @@ void omap1510_fpga_init_irq(void)
                         * The touchscreen interrupt is level-sensitive, so
                         * we'll use the regular mask_ack routine for it.
                         */
-                       set_irq_chip(i, &omap_fpga_irq_ack);
+                       irq_set_chip(i, &omap_fpga_irq_ack);
                }
                else {
                        /*
                         * All FPGA interrupts except the touchscreen are
                         * edge-sensitive, so we won't mask them.
                         */
-                       set_irq_chip(i, &omap_fpga_irq);
+                       irq_set_chip(i, &omap_fpga_irq);
                }
 
-               set_irq_handler(i, handle_edge_irq);
+               irq_set_handler(i, handle_edge_irq);
                set_irq_flags(i, IRQF_VALID);
        }
 
@@ -183,6 +183,6 @@ void omap1510_fpga_init_irq(void)
                return;
        }
        gpio_direction_input(13);
-       set_irq_type(gpio_to_irq(13), IRQ_TYPE_EDGE_RISING);
-       set_irq_chained_handler(OMAP1510_INT_FPGA, innovator_fpga_IRQ_demux);
+       irq_set_irq_type(gpio_to_irq(13), IRQ_TYPE_EDGE_RISING);
+       irq_set_chained_handler(OMAP1510_INT_FPGA, innovator_fpga_IRQ_demux);
 }
index 731dd33bff511ad412e5e314bc6be36771d2eded..53dbb5d7efdca251313c44935e2990cbdf0b1116 100644 (file)
@@ -230,8 +230,8 @@ void __init omap_init_irq(void)
                        irq_trigger = irq_banks[i].trigger_map >> IRQ_BIT(j);
                        omap_irq_set_cfg(j, 0, 0, irq_trigger);
 
-                       set_irq_chip(j, &omap_irq_chip);
-                       set_irq_handler(j, handle_level_irq);
+                       irq_set_chip(j, &omap_irq_chip);
+                       irq_set_handler(j, handle_level_irq);
                        set_irq_flags(j, IRQF_VALID);
                }
        }
index 493505c3b2f565fa61a3eaf5aef2e1b67cd5a505..130034bf01d5f880541976cf3210de7e74293ce1 100644 (file)
@@ -743,7 +743,7 @@ static int __init gpmc_init(void)
        /* initalize the irq_chained */
        irq = OMAP_GPMC_IRQ_BASE;
        for (cs = 0; cs < GPMC_CS_NUM; cs++) {
-               set_irq_chip_and_handler(irq, &dummy_irq_chip,
+               irq_set_chip_and_handler(irq, &dummy_irq_chip,
                                                handle_simple_irq);
                set_irq_flags(irq, IRQF_VALID);
                irq++;
index bc524b94fd592ed47259335e299cd1cdc59231b0..4fff5e3270d823ac03454396ccbc9d207ff1bfa3 100644 (file)
@@ -223,8 +223,8 @@ void __init omap_init_irq(void)
               nr_of_irqs, nr_banks, nr_banks > 1 ? "s" : "");
 
        for (i = 0; i < nr_of_irqs; i++) {
-               set_irq_chip(i, &omap_irq_chip);
-               set_irq_handler(i, handle_level_irq);
+               irq_set_chip(i, &omap_irq_chip);
+               irq_set_handler(i, handle_level_irq);
                set_irq_flags(i, IRQF_VALID);
        }
 }
index c10a117153767a5f113d4d1cf35dca19a8d2cc3d..b7d4591214e0ba35361f136c3cb30c8321809abd 100644 (file)
@@ -213,7 +213,7 @@ void __init db88f5281_pci_preinit(void)
        pin = DB88F5281_PCI_SLOT0_IRQ_PIN;
        if (gpio_request(pin, "PCI Int1") == 0) {
                if (gpio_direction_input(pin) == 0) {
-                       set_irq_type(gpio_to_irq(pin), IRQ_TYPE_LEVEL_LOW);
+                       irq_set_irq_type(gpio_to_irq(pin), IRQ_TYPE_LEVEL_LOW);
                } else {
                        printk(KERN_ERR "db88f5281_pci_preinit faield to "
                                        "set_irq_type pin %d\n", pin);
@@ -226,7 +226,7 @@ void __init db88f5281_pci_preinit(void)
        pin = DB88F5281_PCI_SLOT1_SLOT2_IRQ_PIN;
        if (gpio_request(pin, "PCI Int2") == 0) {
                if (gpio_direction_input(pin) == 0) {
-                       set_irq_type(gpio_to_irq(pin), IRQ_TYPE_LEVEL_LOW);
+                       irq_set_irq_type(gpio_to_irq(pin), IRQ_TYPE_LEVEL_LOW);
                } else {
                        printk(KERN_ERR "db88f5281_pci_preinit faield "
                                        "to set_irq_type pin %d\n", pin);
index ed85891f86997afeada549a7f0f2f7301c866469..43cf8bc9767bbe8cb5fab72f06b11da74c804d8d 100644 (file)
@@ -34,8 +34,8 @@ void __init orion5x_init_irq(void)
         * Initialize gpiolib for GPIOs 0-31.
         */
        orion_gpio_init(0, 32, GPIO_VIRT_BASE, 0, IRQ_ORION5X_GPIO_START);
-       set_irq_chained_handler(IRQ_ORION5X_GPIO_0_7, gpio_irq_handler);
-       set_irq_chained_handler(IRQ_ORION5X_GPIO_8_15, gpio_irq_handler);
-       set_irq_chained_handler(IRQ_ORION5X_GPIO_16_23, gpio_irq_handler);
-       set_irq_chained_handler(IRQ_ORION5X_GPIO_24_31, gpio_irq_handler);
+       irq_set_chained_handler(IRQ_ORION5X_GPIO_0_7, gpio_irq_handler);
+       irq_set_chained_handler(IRQ_ORION5X_GPIO_8_15, gpio_irq_handler);
+       irq_set_chained_handler(IRQ_ORION5X_GPIO_16_23, gpio_irq_handler);
+       irq_set_chained_handler(IRQ_ORION5X_GPIO_24_31, gpio_irq_handler);
 }
index 67ec6959b26770577f1089b7d7d4c6a0568c9594..4fc46772a0870f0c7f16b25c8b4c48588af5cc5e 100644 (file)
@@ -148,7 +148,7 @@ void __init rd88f5182_pci_preinit(void)
        pin = RD88F5182_PCI_SLOT0_IRQ_A_PIN;
        if (gpio_request(pin, "PCI IntA") == 0) {
                if (gpio_direction_input(pin) == 0) {
-                       set_irq_type(gpio_to_irq(pin), IRQ_TYPE_LEVEL_LOW);
+                       irq_set_irq_type(gpio_to_irq(pin), IRQ_TYPE_LEVEL_LOW);
                } else {
                        printk(KERN_ERR "rd88f5182_pci_preinit faield to "
                                        "set_irq_type pin %d\n", pin);
@@ -161,7 +161,7 @@ void __init rd88f5182_pci_preinit(void)
        pin = RD88F5182_PCI_SLOT0_IRQ_B_PIN;
        if (gpio_request(pin, "PCI IntB") == 0) {
                if (gpio_direction_input(pin) == 0) {
-                       set_irq_type(gpio_to_irq(pin), IRQ_TYPE_LEVEL_LOW);
+                       irq_set_irq_type(gpio_to_irq(pin), IRQ_TYPE_LEVEL_LOW);
                } else {
                        printk(KERN_ERR "rd88f5182_pci_preinit faield to "
                                        "set_irq_type pin %d\n", pin);
index 5653ee6c71d800d55c66ce1412d59a35d2fb1b16..616004143912159e4b6bba85057ec69f1aa86248 100644 (file)
@@ -88,7 +88,7 @@ void __init tsp2_pci_preinit(void)
        pin = TSP2_PCI_SLOT0_IRQ_PIN;
        if (gpio_request(pin, "PCI Int1") == 0) {
                if (gpio_direction_input(pin) == 0) {
-                       set_irq_type(gpio_to_irq(pin), IRQ_TYPE_LEVEL_LOW);
+                       irq_set_irq_type(gpio_to_irq(pin), IRQ_TYPE_LEVEL_LOW);
                } else {
                        printk(KERN_ERR "tsp2_pci_preinit failed "
                                        "to set_irq_type pin %d\n", pin);
index 8bbd27ea673556d55cf4deb11f1bfc5def9aa3a5..f0f43e13ac873a4f3375e0215721d73e01d901c6 100644 (file)
@@ -117,7 +117,7 @@ void __init qnap_ts209_pci_preinit(void)
        pin = QNAP_TS209_PCI_SLOT0_IRQ_PIN;
        if (gpio_request(pin, "PCI Int1") == 0) {
                if (gpio_direction_input(pin) == 0) {
-                       set_irq_type(gpio_to_irq(pin), IRQ_TYPE_LEVEL_LOW);
+                       irq_set_irq_type(gpio_to_irq(pin), IRQ_TYPE_LEVEL_LOW);
                } else {
                        printk(KERN_ERR "qnap_ts209_pci_preinit failed to "
                                        "set_irq_type pin %d\n", pin);
@@ -131,7 +131,7 @@ void __init qnap_ts209_pci_preinit(void)
        pin = QNAP_TS209_PCI_SLOT1_IRQ_PIN;
        if (gpio_request(pin, "PCI Int2") == 0) {
                if (gpio_direction_input(pin) == 0) {
-                       set_irq_type(gpio_to_irq(pin), IRQ_TYPE_LEVEL_LOW);
+                       irq_set_irq_type(gpio_to_irq(pin), IRQ_TYPE_LEVEL_LOW);
                } else {
                        printk(KERN_ERR "qnap_ts209_pci_preinit failed "
                                        "to set_irq_type pin %d\n", pin);
index c69c180aec76b474668311406c986a3a5c586ce0..7608c7a288cfbabf3f69ebc0ff7f43daaf41b017 100644 (file)
@@ -58,22 +58,22 @@ static int pnx4008_set_irq_type(struct irq_data *d, unsigned int type)
        case IRQ_TYPE_EDGE_RISING:
                __raw_writel(__raw_readl(INTC_ATR(d->irq)) | INTC_BIT(d->irq), INTC_ATR(d->irq));       /*edge sensitive */
                __raw_writel(__raw_readl(INTC_APR(d->irq)) | INTC_BIT(d->irq), INTC_APR(d->irq));       /*rising edge */
-               set_irq_handler(d->irq, handle_edge_irq);
+               irq_set_handler(d->irq, handle_edge_irq);
                break;
        case IRQ_TYPE_EDGE_FALLING:
                __raw_writel(__raw_readl(INTC_ATR(d->irq)) | INTC_BIT(d->irq), INTC_ATR(d->irq));       /*edge sensitive */
                __raw_writel(__raw_readl(INTC_APR(d->irq)) & ~INTC_BIT(d->irq), INTC_APR(d->irq));      /*falling edge */
-               set_irq_handler(d->irq, handle_edge_irq);
+               irq_set_handler(d->irq, handle_edge_irq);
                break;
        case IRQ_TYPE_LEVEL_LOW:
                __raw_writel(__raw_readl(INTC_ATR(d->irq)) & ~INTC_BIT(d->irq), INTC_ATR(d->irq));      /*level sensitive */
                __raw_writel(__raw_readl(INTC_APR(d->irq)) & ~INTC_BIT(d->irq), INTC_APR(d->irq));      /*low level */
-               set_irq_handler(d->irq, handle_level_irq);
+               irq_set_handler(d->irq, handle_level_irq);
                break;
        case IRQ_TYPE_LEVEL_HIGH:
                __raw_writel(__raw_readl(INTC_ATR(d->irq)) & ~INTC_BIT(d->irq), INTC_ATR(d->irq));      /*level sensitive */
                __raw_writel(__raw_readl(INTC_APR(d->irq)) | INTC_BIT(d->irq), INTC_APR(d->irq));       /* high level */
-               set_irq_handler(d->irq, handle_level_irq);
+               irq_set_handler(d->irq, handle_level_irq);
                break;
 
        /* IRQ_TYPE_EDGE_BOTH is not supported */
@@ -98,7 +98,7 @@ void __init pnx4008_init_irq(void)
        /* configure IRQ's */
        for (i = 0; i < NR_IRQS; i++) {
                set_irq_flags(i, IRQF_VALID);
-               set_irq_chip(i, &pnx4008_irq_chip);
+               irq_set_chip(i, &pnx4008_irq_chip);
                pnx4008_set_irq_type(irq_get_irq_data(i), pnx4008_irq_type[i]);
        }
 
index d2af73321daee0b28162280c3075f465ef9eac4f..a773b730e43210f63fd2602f9b934fc0086f4052 100644 (file)
@@ -527,13 +527,13 @@ static void __init balloon3_init_irq(void)
        pxa27x_init_irq();
        /* setup extra Balloon3 irqs */
        for (irq = BALLOON3_IRQ(0); irq <= BALLOON3_IRQ(7); irq++) {
-               set_irq_chip(irq, &balloon3_irq_chip);
-               set_irq_handler(irq, handle_level_irq);
+               irq_set_chip(irq, &balloon3_irq_chip);
+               irq_set_handler(irq, handle_level_irq);
                set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
        }
 
-       set_irq_chained_handler(BALLOON3_AUX_NIRQ, balloon3_irq_handler);
-       set_irq_type(BALLOON3_AUX_NIRQ, IRQ_TYPE_EDGE_FALLING);
+       irq_set_chained_handler(BALLOON3_AUX_NIRQ, balloon3_irq_handler);
+       irq_set_irq_type(BALLOON3_AUX_NIRQ, IRQ_TYPE_EDGE_FALLING);
 
        pr_debug("%s: chained handler installed - irq %d automatically "
                "enabled\n", __func__, BALLOON3_AUX_NIRQ);
index a2380cd76f80188247e637e5b9678b0570c16557..8b1a30959fae3e0426bd1475114cc042d7b08856 100644 (file)
@@ -70,9 +70,10 @@ void __cmx2xx_pci_init_irq(int irq_gpio)
 
        cmx2xx_it8152_irq_gpio = irq_gpio;
 
-       set_irq_type(gpio_to_irq(irq_gpio), IRQ_TYPE_EDGE_RISING);
+       irq_set_irq_type(gpio_to_irq(irq_gpio), IRQ_TYPE_EDGE_RISING);
 
-       set_irq_chained_handler(gpio_to_irq(irq_gpio), cmx2xx_it8152_irq_demux);
+       irq_set_chained_handler(gpio_to_irq(irq_gpio),
+                               cmx2xx_it8152_irq_demux);
 }
 
 #ifdef CONFIG_PM
index bfca7ed2fea3be49fb63181c5a86680a71a8a8f0..06d0a03f462d7a60d63da4aea16baad309174f70 100644 (file)
@@ -765,7 +765,7 @@ static void __init cm_x300_init_da9030(void)
 {
        pxa3xx_set_i2c_power_info(&cm_x300_pwr_i2c_info);
        i2c_register_board_info(1, &cm_x300_pmic_info, 1);
-       set_irq_wake(IRQ_WAKEUP0, 1);
+       irq_set_irq_wake(IRQ_WAKEUP0, 1);
 }
 
 static void __init cm_x300_init_wi2wi(void)
index 2693e3c3776fc32283ad29ed191cebe2446f4f09..cc7bfc3428c8f2807758a08d4da53fad6296b2f6 100644 (file)
@@ -137,9 +137,9 @@ static void __init pxa_init_low_gpio_irq(set_wake_t fn)
        GEDR0 = 0x3;
 
        for (irq = IRQ_GPIO0; irq <= IRQ_GPIO1; irq++) {
-               set_irq_chip(irq, &pxa_low_gpio_chip);
-               set_irq_chip_data(irq, irq_base(0));
-               set_irq_handler(irq, handle_edge_irq);
+               irq_set_chip(irq, &pxa_low_gpio_chip);
+               irq_set_chip_data(irq, irq_base(0));
+               irq_set_handler(irq, handle_edge_irq);
                set_irq_flags(irq, IRQF_VALID);
        }
 
@@ -165,9 +165,9 @@ void __init pxa_init_irq(int irq_nr, set_wake_t fn)
                                __raw_writel(i | IPR_VALID, IRQ_BASE + IPR(i));
 
                        irq = PXA_IRQ(i);
-                       set_irq_chip(irq, &pxa_internal_irq_chip);
-                       set_irq_chip_data(irq, base);
-                       set_irq_handler(irq, handle_level_irq);
+                       irq_set_chip(irq, &pxa_internal_irq_chip);
+                       irq_set_chip_data(irq, base);
+                       irq_set_handler(irq, handle_level_irq);
                        set_irq_flags(irq, IRQF_VALID);
                }
        }
index c9a3e775c2de13474f573759fe8cbbb2e2a5f9e6..a1b094223e31751f76afa1e3b974fa6fd890a7f5 100644 (file)
@@ -149,12 +149,12 @@ static void __init lpd270_init_irq(void)
 
        /* setup extra LogicPD PXA270 irqs */
        for (irq = LPD270_IRQ(2); irq <= LPD270_IRQ(4); irq++) {
-               set_irq_chip(irq, &lpd270_irq_chip);
-               set_irq_handler(irq, handle_level_irq);
+               irq_set_chip(irq, &lpd270_irq_chip);
+               irq_set_handler(irq, handle_level_irq);
                set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
        }
-       set_irq_chained_handler(IRQ_GPIO(0), lpd270_irq_handler);
-       set_irq_type(IRQ_GPIO(0), IRQ_TYPE_EDGE_FALLING);
+       irq_set_chained_handler(IRQ_GPIO(0), lpd270_irq_handler);
+       irq_set_irq_type(IRQ_GPIO(0), IRQ_TYPE_EDGE_FALLING);
 }
 
 
index dca20de306bbe1f3fe410b1d2f215a494d2d1dbb..061d01b50094215f095224f7d5a40a96b602c27e 100644 (file)
@@ -165,13 +165,13 @@ static void __init lubbock_init_irq(void)
 
        /* setup extra lubbock irqs */
        for (irq = LUBBOCK_IRQ(0); irq <= LUBBOCK_LAST_IRQ; irq++) {
-               set_irq_chip(irq, &lubbock_irq_chip);
-               set_irq_handler(irq, handle_level_irq);
+               irq_set_chip(irq, &lubbock_irq_chip);
+               irq_set_handler(irq, handle_level_irq);
                set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
        }
 
-       set_irq_chained_handler(IRQ_GPIO(0), lubbock_irq_handler);
-       set_irq_type(IRQ_GPIO(0), IRQ_TYPE_EDGE_FALLING);
+       irq_set_chained_handler(IRQ_GPIO(0), lubbock_irq_handler);
+       irq_set_irq_type(IRQ_GPIO(0), IRQ_TYPE_EDGE_FALLING);
 }
 
 #ifdef CONFIG_PM
index f9542220595a6beaaa1f9ffe1694df0971a2a3ea..9ee703225ab8766433c3e0463a65a48822438dff 100644 (file)
@@ -166,8 +166,8 @@ static void __init mainstone_init_irq(void)
 
        /* setup extra Mainstone irqs */
        for(irq = MAINSTONE_IRQ(0); irq <= MAINSTONE_IRQ(15); irq++) {
-               set_irq_chip(irq, &mainstone_irq_chip);
-               set_irq_handler(irq, handle_level_irq);
+               irq_set_chip(irq, &mainstone_irq_chip);
+               irq_set_handler(irq, handle_level_irq);
                if (irq == MAINSTONE_IRQ(10) || irq == MAINSTONE_IRQ(14))
                        set_irq_flags(irq, IRQF_VALID | IRQF_PROBE | IRQF_NOAUTOEN);
                else
@@ -179,8 +179,8 @@ static void __init mainstone_init_irq(void)
        MST_INTMSKENA = 0;
        MST_INTSETCLR = 0;
 
-       set_irq_chained_handler(IRQ_GPIO(0), mainstone_irq_handler);
-       set_irq_type(IRQ_GPIO(0), IRQ_TYPE_EDGE_FALLING);
+       irq_set_chained_handler(IRQ_GPIO(0), mainstone_irq_handler);
+       irq_set_irq_type(IRQ_GPIO(0), IRQ_TYPE_EDGE_FALLING);
 }
 
 #ifdef CONFIG_PM
index 9dbf3ccd4150c88eadfbbb4f79aa72d38c1f321a..6c02b589d1434c878d1cd9ae2a9d5fee8f5a20e9 100644 (file)
@@ -281,16 +281,16 @@ static void __init pcm990_init_irq(void)
 
        /* setup extra PCM990 irqs */
        for (irq = PCM027_IRQ(0); irq <= PCM027_IRQ(3); irq++) {
-               set_irq_chip(irq, &pcm990_irq_chip);
-               set_irq_handler(irq, handle_level_irq);
+               irq_set_chip(irq, &pcm990_irq_chip);
+               irq_set_handler(irq, handle_level_irq);
                set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
        }
 
        PCM990_INTMSKENA = 0x00;        /* disable all Interrupts */
        PCM990_INTSETCLR = 0xFF;
 
-       set_irq_chained_handler(PCM990_CTRL_INT_IRQ, pcm990_irq_handler);
-       set_irq_type(PCM990_CTRL_INT_IRQ, PCM990_CTRL_INT_IRQ_EDGE);
+       irq_set_chained_handler(PCM990_CTRL_INT_IRQ, pcm990_irq_handler);
+       irq_set_irq_type(PCM990_CTRL_INT_IRQ, PCM990_CTRL_INT_IRQ_EDGE);
 }
 
 static int pcm990_mci_init(struct device *dev, irq_handler_t mci_detect_int,
index f374247b8466d358fab0ed529f3b2d1704806978..8abe93f4e51957d9b02b7924516f2d23534c677c 100644 (file)
@@ -362,8 +362,8 @@ static void __init pxa_init_ext_wakeup_irq(set_wake_t fn)
        int irq;
 
        for (irq = IRQ_WAKEUP0; irq <= IRQ_WAKEUP1; irq++) {
-               set_irq_chip(irq, &pxa_ext_wakeup_chip);
-               set_irq_handler(irq, handle_edge_irq);
+               irq_set_chip(irq, &pxa_ext_wakeup_chip);
+               irq_set_handler(irq, handle_edge_irq);
                set_irq_flags(irq, IRQF_VALID);
        }
 
index 12279214c875a88f242c79dbc8fe02fdeca45ca7..26facf1cef650f5f0e9f87c93305cba271ccc280 100644 (file)
@@ -310,14 +310,14 @@ static void __init viper_init_irq(void)
        /* setup ISA IRQs */
        for (level = 0; level < ARRAY_SIZE(viper_isa_irqs); level++) {
                isa_irq = viper_bit_to_irq(level);
-               set_irq_chip(isa_irq, &viper_irq_chip);
-               set_irq_handler(isa_irq, handle_edge_irq);
+               irq_set_chip(isa_irq, &viper_irq_chip);
+               irq_set_handler(isa_irq, handle_edge_irq);
                set_irq_flags(isa_irq, IRQF_VALID | IRQF_PROBE);
        }
 
-       set_irq_chained_handler(gpio_to_irq(VIPER_CPLD_GPIO),
+       irq_set_chained_handler(gpio_to_irq(VIPER_CPLD_GPIO),
                                viper_irq_handler);
-       set_irq_type(gpio_to_irq(VIPER_CPLD_GPIO), IRQ_TYPE_EDGE_BOTH);
+       irq_set_irq_type(gpio_to_irq(VIPER_CPLD_GPIO), IRQ_TYPE_EDGE_BOTH);
 }
 
 /* Flat Panel */
index 730f51e57c17105fd2184967095b8fa78582fb6e..a7cdc4a83d40f86b93e863b60666d47175bbdfc4 100644 (file)
@@ -136,22 +136,23 @@ static void __init zeus_init_irq(void)
 
        /* Peripheral IRQs. It would be nice to move those inside driver
           configuration, but it is not supported at the moment. */
-       set_irq_type(gpio_to_irq(ZEUS_AC97_GPIO),       IRQ_TYPE_EDGE_RISING);
-       set_irq_type(gpio_to_irq(ZEUS_WAKEUP_GPIO),     IRQ_TYPE_EDGE_RISING);
-       set_irq_type(gpio_to_irq(ZEUS_PTT_GPIO),        IRQ_TYPE_EDGE_RISING);
-       set_irq_type(gpio_to_irq(ZEUS_EXTGPIO_GPIO),    IRQ_TYPE_EDGE_FALLING);
-       set_irq_type(gpio_to_irq(ZEUS_CAN_GPIO),        IRQ_TYPE_EDGE_FALLING);
+       irq_set_irq_type(gpio_to_irq(ZEUS_AC97_GPIO), IRQ_TYPE_EDGE_RISING);
+       irq_set_irq_type(gpio_to_irq(ZEUS_WAKEUP_GPIO), IRQ_TYPE_EDGE_RISING);
+       irq_set_irq_type(gpio_to_irq(ZEUS_PTT_GPIO), IRQ_TYPE_EDGE_RISING);
+       irq_set_irq_type(gpio_to_irq(ZEUS_EXTGPIO_GPIO),
+                        IRQ_TYPE_EDGE_FALLING);
+       irq_set_irq_type(gpio_to_irq(ZEUS_CAN_GPIO), IRQ_TYPE_EDGE_FALLING);
 
        /* Setup ISA IRQs */
        for (level = 0; level < ARRAY_SIZE(zeus_isa_irqs); level++) {
                isa_irq = zeus_bit_to_irq(level);
-               set_irq_chip(isa_irq, &zeus_irq_chip);
-               set_irq_handler(isa_irq, handle_edge_irq);
+               irq_set_chip(isa_irq, &zeus_irq_chip);
+               irq_set_handler(isa_irq, handle_edge_irq);
                set_irq_flags(isa_irq, IRQF_VALID | IRQF_PROBE);
        }
 
-       set_irq_type(gpio_to_irq(ZEUS_ISA_GPIO), IRQ_TYPE_EDGE_RISING);
-       set_irq_chained_handler(gpio_to_irq(ZEUS_ISA_GPIO), zeus_irq_handler);
+       irq_set_irq_type(gpio_to_irq(ZEUS_ISA_GPIO), IRQ_TYPE_EDGE_RISING);
+       irq_set_chained_handler(gpio_to_irq(ZEUS_ISA_GPIO), zeus_irq_handler);
 }
 
 
index d29cd9b737fc0aaca7522cfed688c85f16ecebbe..49fb9886f56c2ae49f855adbfe76e9124baa126b 100644 (file)
@@ -133,25 +133,25 @@ void __init rpc_init_irq(void)
 
                switch (irq) {
                case 0 ... 7:
-                       set_irq_chip(irq, &iomd_a_chip);
-                       set_irq_handler(irq, handle_level_irq);
+                       irq_set_chip(irq, &iomd_a_chip);
+                       irq_set_handler(irq, handle_level_irq);
                        set_irq_flags(irq, flags);
                        break;
 
                case 8 ... 15:
-                       set_irq_chip(irq, &iomd_b_chip);
-                       set_irq_handler(irq, handle_level_irq);
+                       irq_set_chip(irq, &iomd_b_chip);
+                       irq_set_handler(irq, handle_level_irq);
                        set_irq_flags(irq, flags);
                        break;
 
                case 16 ... 21:
-                       set_irq_chip(irq, &iomd_dma_chip);
-                       set_irq_handler(irq, handle_level_irq);
+                       irq_set_chip(irq, &iomd_dma_chip);
+                       irq_set_handler(irq, handle_level_irq);
                        set_irq_flags(irq, flags);
                        break;
 
                case 64 ... 71:
-                       set_irq_chip(irq, &iomd_fiq_chip);
+                       irq_set_chip(irq, &iomd_fiq_chip);
                        set_irq_flags(irq, IRQF_VALID);
                        break;
                }
index 606cb6b1cc4714f1932a30b4557eded86c3cb586..4139f5f0b418e18dbdf68c3d7b3c06fca52a97d9 100644 (file)
@@ -147,15 +147,15 @@ static __init int bast_irq_init(void)
 
                __raw_writeb(0x0, BAST_VA_PC104_IRQMASK);
 
-               set_irq_chained_handler(IRQ_ISA, bast_irq_pc104_demux);
+               irq_set_chained_handler(IRQ_ISA, bast_irq_pc104_demux);
 
                /* register our IRQs */
 
                for (i = 0; i < 4; i++) {
                        unsigned int irqno = bast_pc104_irqs[i];
 
-                       set_irq_chip(irqno, &bast_pc104_chip);
-                       set_irq_handler(irqno, handle_level_irq);
+                       irq_set_chip(irqno, &bast_pc104_chip);
+                       irq_set_handler(irqno, handle_level_irq);
                        set_irq_flags(irqno, IRQF_VALID);
                }
        }
index eddb52ba5b656efb5aef7d20cbc1e36750689b50..30f79ae032890ed2a76bc5c49e7df97bb184d9e1 100644 (file)
@@ -175,18 +175,18 @@ static int s3c2412_irq_add(struct sys_device *sysdev)
        unsigned int irqno;
 
        for (irqno = IRQ_EINT0; irqno <= IRQ_EINT3; irqno++) {
-               set_irq_chip(irqno, &s3c2412_irq_eint0t4);
-               set_irq_handler(irqno, handle_edge_irq);
+               irq_set_chip(irqno, &s3c2412_irq_eint0t4);
+               irq_set_handler(irqno, handle_edge_irq);
                set_irq_flags(irqno, IRQF_VALID);
        }
 
        /* add demux support for CF/SDI */
 
-       set_irq_chained_handler(IRQ_S3C2412_CFSDI, s3c2412_irq_demux_cfsdi);
+       irq_set_chained_handler(IRQ_S3C2412_CFSDI, s3c2412_irq_demux_cfsdi);
 
        for (irqno = IRQ_S3C2412_SDI; irqno <= IRQ_S3C2412_CF; irqno++) {
-               set_irq_chip(irqno, &s3c2412_irq_cfsdi);
-               set_irq_handler(irqno, handle_level_irq);
+               irq_set_chip(irqno, &s3c2412_irq_cfsdi);
+               irq_set_handler(irqno, handle_level_irq);
                set_irq_flags(irqno, IRQF_VALID);
        }
 
@@ -195,7 +195,7 @@ static int s3c2412_irq_add(struct sys_device *sysdev)
        s3c2412_irq_rtc_chip = s3c_irq_chip;
        s3c2412_irq_rtc_chip.irq_set_wake = s3c2412_irq_rtc_wake;
 
-       set_irq_chip(IRQ_RTC, &s3c2412_irq_rtc_chip);
+       irq_set_chip(IRQ_RTC, &s3c2412_irq_rtc_chip);
 
        return 0;
 }
index 680fe386aca58471ee2207210a69f43041cfa920..de21c841b56d0f74bbad2aa4cd4bcea5d70ab1d6 100644 (file)
@@ -202,13 +202,13 @@ static int __init s3c2416_add_sub(unsigned int base,
 {
        unsigned int irqno;
 
-       set_irq_chip(base, &s3c_irq_level_chip);
-       set_irq_handler(base, handle_level_irq);
-       set_irq_chained_handler(base, demux);
+       irq_set_chip(base, &s3c_irq_level_chip);
+       irq_set_handler(base, handle_level_irq);
+       irq_set_chained_handler(base, demux);
 
        for (irqno = start; irqno <= end; irqno++) {
-               set_irq_chip(irqno, chip);
-               set_irq_handler(irqno, handle_level_irq);
+               irq_set_chip(irqno, chip);
+               irq_set_handler(irqno, handle_level_irq);
                set_irq_flags(irqno, IRQF_VALID);
        }
 
index acad4428bef05881969644dd6411356c2a604a50..0c564b149a46166b33c89e96614aeaa7a77489d1 100644 (file)
@@ -100,13 +100,13 @@ static int s3c2440_irq_add(struct sys_device *sysdev)
 
        /* add new chained handler for wdt, ac7 */
 
-       set_irq_chip(IRQ_WDT, &s3c_irq_level_chip);
-       set_irq_handler(IRQ_WDT, handle_level_irq);
-       set_irq_chained_handler(IRQ_WDT, s3c_irq_demux_wdtac97);
+       irq_set_chip(IRQ_WDT, &s3c_irq_level_chip);
+       irq_set_handler(IRQ_WDT, handle_level_irq);
+       irq_set_chained_handler(IRQ_WDT, s3c_irq_demux_wdtac97);
 
        for (irqno = IRQ_S3C2440_WDT; irqno <= IRQ_S3C2440_AC97; irqno++) {
-               set_irq_chip(irqno, &s3c_irq_wdtac97);
-               set_irq_handler(irqno, handle_level_irq);
+               irq_set_chip(irqno, &s3c_irq_wdtac97);
+               irq_set_handler(irqno, handle_level_irq);
                set_irq_flags(irqno, IRQF_VALID);
        }
 
index 83daf4ece76464773a3604dabd1540a5570377fd..5a48881c45081b601fde7680ea7fab5ae9383a8f 100644 (file)
@@ -95,19 +95,19 @@ static int s3c244x_irq_add(struct sys_device *sysdev)
 {
        unsigned int irqno;
 
-       set_irq_chip(IRQ_NFCON, &s3c_irq_level_chip);
-       set_irq_handler(IRQ_NFCON, handle_level_irq);
+       irq_set_chip(IRQ_NFCON, &s3c_irq_level_chip);
+       irq_set_handler(IRQ_NFCON, handle_level_irq);
        set_irq_flags(IRQ_NFCON, IRQF_VALID);
 
        /* add chained handler for camera */
 
-       set_irq_chip(IRQ_CAM, &s3c_irq_level_chip);
-       set_irq_handler(IRQ_CAM, handle_level_irq);
-       set_irq_chained_handler(IRQ_CAM, s3c_irq_demux_cam);
+       irq_set_chip(IRQ_CAM, &s3c_irq_level_chip);
+       irq_set_handler(IRQ_CAM, handle_level_irq);
+       irq_set_chained_handler(IRQ_CAM, s3c_irq_demux_cam);
 
        for (irqno = IRQ_S3C2440_CAM_C; irqno <= IRQ_S3C2440_CAM_P; irqno++) {
-               set_irq_chip(irqno, &s3c_irq_cam);
-               set_irq_handler(irqno, handle_level_irq);
+               irq_set_chip(irqno, &s3c_irq_cam);
+               irq_set_handler(irqno, handle_level_irq);
                set_irq_flags(irqno, IRQF_VALID);
        }
 
index c7820f9c135231105c08a50f2b58cb1d4115a588..b12431fae2630fd14e9269871dccc66d34ed143a 100644 (file)
@@ -230,13 +230,13 @@ static int __init s3c2443_add_sub(unsigned int base,
 {
        unsigned int irqno;
 
-       set_irq_chip(base, &s3c_irq_level_chip);
-       set_irq_handler(base, handle_level_irq);
-       set_irq_chained_handler(base, demux);
+       irq_set_chip(base, &s3c_irq_level_chip);
+       irq_set_handler(base, handle_level_irq);
+       irq_set_chained_handler(base, demux);
 
        for (irqno = start; irqno <= end; irqno++) {
-               set_irq_chip(irqno, chip);
-               set_irq_handler(irqno, handle_level_irq);
+               irq_set_chip(irqno, chip);
+               irq_set_handler(irqno, handle_level_irq);
                set_irq_flags(irqno, IRQF_VALID);
        }
 
index 2ead8189da7438d900c573eb62ca447968dd7e09..9a4c7aeab5c5915083bd56faca94bf495a7a2793 100644 (file)
@@ -197,16 +197,16 @@ static int __init s3c64xx_init_irq_eint(void)
        int irq;
 
        for (irq = IRQ_EINT(0); irq <= IRQ_EINT(27); irq++) {
-               set_irq_chip(irq, &s3c_irq_eint);
-               set_irq_chip_data(irq, (void *)eint_irq_to_bit(irq));
-               set_irq_handler(irq, handle_level_irq);
+               irq_set_chip(irq, &s3c_irq_eint);
+               irq_set_chip_data(irq, (void *)eint_irq_to_bit(irq));
+               irq_set_handler(irq, handle_level_irq);
                set_irq_flags(irq, IRQF_VALID);
        }
 
-       set_irq_chained_handler(IRQ_EINT0_3, s3c_irq_demux_eint0_3);
-       set_irq_chained_handler(IRQ_EINT4_11, s3c_irq_demux_eint4_11);
-       set_irq_chained_handler(IRQ_EINT12_19, s3c_irq_demux_eint12_19);
-       set_irq_chained_handler(IRQ_EINT20_27, s3c_irq_demux_eint20_27);
+       irq_set_chained_handler(IRQ_EINT0_3, s3c_irq_demux_eint0_3);
+       irq_set_chained_handler(IRQ_EINT4_11, s3c_irq_demux_eint4_11);
+       irq_set_chained_handler(IRQ_EINT12_19, s3c_irq_demux_eint12_19);
+       irq_set_chained_handler(IRQ_EINT20_27, s3c_irq_demux_eint20_27);
 
        return 0;
 }
index 98d780608c7e98ffb3a64fb285301cc88731a6b5..7f3da4b11ec90fd7caeff810d65ea3ffc010546e 100644 (file)
@@ -96,7 +96,7 @@ static struct resource cerf_flash_resource = {
 static void __init cerf_init_irq(void)
 {
        sa1100_init_irq();
-       set_irq_type(CERF_ETH_IRQ, IRQ_TYPE_EDGE_RISING);
+       irq_set_irq_type(CERF_ETH_IRQ, IRQ_TYPE_EDGE_RISING);
 }
 
 static struct map_desc cerf_io_desc[] __initdata = {
index 3d85dfad9c1fc60fabace59e90b26afa0b66db63..0f109e179cbbb598aa220e882644c9ead1b4c6df 100644 (file)
@@ -323,28 +323,28 @@ void __init sa1100_init_irq(void)
        ICCR = 1;
 
        for (irq = 0; irq <= 10; irq++) {
-               set_irq_chip(irq, &sa1100_low_gpio_chip);
-               set_irq_handler(irq, handle_edge_irq);
+               irq_set_chip(irq, &sa1100_low_gpio_chip);
+               irq_set_handler(irq, handle_edge_irq);
                set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
        }
 
        for (irq = 12; irq <= 31; irq++) {
-               set_irq_chip(irq, &sa1100_normal_chip);
-               set_irq_handler(irq, handle_level_irq);
+               irq_set_chip(irq, &sa1100_normal_chip);
+               irq_set_handler(irq, handle_level_irq);
                set_irq_flags(irq, IRQF_VALID);
        }
 
        for (irq = 32; irq <= 48; irq++) {
-               set_irq_chip(irq, &sa1100_high_gpio_chip);
-               set_irq_handler(irq, handle_edge_irq);
+               irq_set_chip(irq, &sa1100_high_gpio_chip);
+               irq_set_handler(irq, handle_edge_irq);
                set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
        }
 
        /*
         * Install handler for GPIO 11-27 edge detect interrupts
         */
-       set_irq_chip(IRQ_GPIO11_27, &sa1100_normal_chip);
-       set_irq_chained_handler(IRQ_GPIO11_27, sa1100_high_gpio_handler);
+       irq_set_chip(IRQ_GPIO11_27, &sa1100_normal_chip);
+       irq_set_chained_handler(IRQ_GPIO11_27, sa1100_high_gpio_handler);
 
        sa1100_init_gpio();
 }
index 4aad01f73660eada599be0d1ed61b0e86d87745b..b4fa53a1427e437a8592c9d4f8f947ba32742ad2 100644 (file)
@@ -145,8 +145,8 @@ static int __devinit neponset_probe(struct platform_device *dev)
        /*
         * Install handler for GPIO25.
         */
-       set_irq_type(IRQ_GPIO25, IRQ_TYPE_EDGE_RISING);
-       set_irq_chained_handler(IRQ_GPIO25, neponset_irq_handler);
+       irq_set_irq_type(IRQ_GPIO25, IRQ_TYPE_EDGE_RISING);
+       irq_set_chained_handler(IRQ_GPIO25, neponset_irq_handler);
 
        /*
         * We would set IRQ_GPIO25 to be a wake-up IRQ, but
@@ -161,9 +161,9 @@ static int __devinit neponset_probe(struct platform_device *dev)
         * Setup other Neponset IRQs.  SA1111 will be done by the
         * generic SA1111 code.
         */
-       set_irq_handler(IRQ_NEPONSET_SMC9196, handle_simple_irq);
+       irq_set_handler(IRQ_NEPONSET_SMC9196, handle_simple_irq);
        set_irq_flags(IRQ_NEPONSET_SMC9196, IRQF_VALID | IRQF_PROBE);
-       set_irq_handler(IRQ_NEPONSET_USAR, handle_simple_irq);
+       irq_set_handler(IRQ_NEPONSET_USAR, handle_simple_irq);
        set_irq_flags(IRQ_NEPONSET_USAR, IRQF_VALID | IRQF_PROBE);
 
        /*
index 42b80400c1006b8927f8c71046ab090ae536447c..65161f2bea29132632a468328c0616c66e6f84b2 100644 (file)
@@ -142,7 +142,7 @@ static void __init pleb_map_io(void)
 
        GPDR &= ~GPIO_ETH0_IRQ;
 
-       set_irq_type(GPIO_ETH0_IRQ, IRQ_TYPE_EDGE_FALLING);
+       irq_set_irq_type(GPIO_ETH0_IRQ, IRQ_TYPE_EDGE_FALLING);
 }
 
 MACHINE_START(PLEB, "PLEB")
index 831fc66dfa4dc34ae96c238593edb9c1b4f1dbd8..2e6da5fe18597ed976415fb27b1b2a730df95cfd 100644 (file)
@@ -80,8 +80,8 @@ void __init shark_init_irq(void)
        int irq;
 
        for (irq = 0; irq < NR_IRQS; irq++) {
-               set_irq_chip(irq, &fb_chip);
-               set_irq_handler(irq, handle_edge_irq);
+               irq_set_chip(irq, &fb_chip);
+               irq_set_handler(irq, handle_edge_irq);
                set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
        }
 
index a94f29da5d308adaf216159fbc9184a5f1eb75b3..08cc45137bdcb87f55e3d63cb60e620c3bb5d6bc 100644 (file)
@@ -1255,7 +1255,7 @@ static void __init ap4evb_init(void)
        gpio_request(GPIO_FN_KEYIN4,     NULL);
 
        /* enable TouchScreen */
-       set_irq_type(IRQ28, IRQ_TYPE_LEVEL_LOW);
+       irq_set_irq_type(IRQ28, IRQ_TYPE_LEVEL_LOW);
 
        tsc_device.irq = IRQ28;
        i2c_register_board_info(1, &tsc_device, 1);
@@ -1311,7 +1311,7 @@ static void __init ap4evb_init(void)
        lcdc_info.ch[0].lcd_size_cfg.height     = 91;
 
        /* enable TouchScreen */
-       set_irq_type(IRQ7, IRQ_TYPE_LEVEL_LOW);
+       irq_set_irq_type(IRQ7, IRQ_TYPE_LEVEL_LOW);
 
        tsc_device.irq = IRQ7;
        i2c_register_board_info(0, &tsc_device, 1);
index 49bc07482179b3c5fd64bd1bbc14ff558de2da06..f0d0af14ae0631059fea608679086f05aefe8b2c 100644 (file)
@@ -1124,15 +1124,15 @@ static void __init mackerel_init(void)
 
        /* enable Keypad */
        gpio_request(GPIO_FN_IRQ9_42,   NULL);
-       set_irq_type(IRQ9, IRQ_TYPE_LEVEL_HIGH);
+       irq_set_irq_type(IRQ9, IRQ_TYPE_LEVEL_HIGH);
 
        /* enable Touchscreen */
        gpio_request(GPIO_FN_IRQ7_40,   NULL);
-       set_irq_type(IRQ7, IRQ_TYPE_LEVEL_LOW);
+       irq_set_irq_type(IRQ7, IRQ_TYPE_LEVEL_LOW);
 
        /* enable Accelerometer */
        gpio_request(GPIO_FN_IRQ21,     NULL);
-       set_irq_type(IRQ21, IRQ_TYPE_LEVEL_HIGH);
+       irq_set_irq_type(IRQ21, IRQ_TYPE_LEVEL_HIGH);
 
        /* enable SDHI0 */
        gpio_request(GPIO_FN_SDHICD0, NULL);
index 2fe9704d5ea1cf081ca862a1b53f9d7034258b49..cc442d198cdc302b907e731233fcbef8186e16e2 100644 (file)
@@ -421,7 +421,7 @@ static struct intc_desc intcs_desc __initdata = {
 
 static void intcs_demux(unsigned int irq, struct irq_desc *desc)
 {
-       void __iomem *reg = (void *)get_irq_data(irq);
+       void __iomem *reg = (void *)irq_get_handler_data(irq);
        unsigned int evtcodeas = ioread32(reg);
 
        generic_handle_irq(intcs_evt2irq(evtcodeas));
@@ -435,6 +435,6 @@ void __init sh7367_init_irq(void)
        register_intc_controller(&intcs_desc);
 
        /* demux using INTEVTSA */
-       set_irq_data(evt2irq(0xf80), (void *)intevtsa);
-       set_irq_chained_handler(evt2irq(0xf80), intcs_demux);
+       irq_set_handler_data(evt2irq(0xf80), (void *)intevtsa);
+       irq_set_chained_handler(evt2irq(0xf80), intcs_demux);
 }
index ca5f9d17b39abd6cb1f92ce2d33c09bf5f9e86b8..7a4960f9c1e3fcb313cf103fcacd3ccbfe3fab71 100644 (file)
@@ -601,7 +601,7 @@ static struct intc_desc intcs_desc __initdata = {
 
 static void intcs_demux(unsigned int irq, struct irq_desc *desc)
 {
-       void __iomem *reg = (void *)get_irq_data(irq);
+       void __iomem *reg = (void *)irq_get_handler_data(irq);
        unsigned int evtcodeas = ioread32(reg);
 
        generic_handle_irq(intcs_evt2irq(evtcodeas));
@@ -615,6 +615,6 @@ void __init sh7372_init_irq(void)
        register_intc_controller(&intcs_desc);
 
        /* demux using INTEVTSA */
-       set_irq_data(evt2irq(0xf80), (void *)intevtsa);
-       set_irq_chained_handler(evt2irq(0xf80), intcs_demux);
+       irq_set_handler_data(evt2irq(0xf80), (void *)intevtsa);
+       irq_set_chained_handler(evt2irq(0xf80), intcs_demux);
 }
index dd568382cc9f7bacdad0dbb6e60fc70e2a6391ee..fe45154ce660a420d55bf0b31b73c3f684a0f886 100644 (file)
@@ -626,7 +626,7 @@ static struct intc_desc intcs_desc __initdata = {
 
 static void intcs_demux(unsigned int irq, struct irq_desc *desc)
 {
-       void __iomem *reg = (void *)get_irq_data(irq);
+       void __iomem *reg = (void *)irq_get_handler_data(irq);
        unsigned int evtcodeas = ioread32(reg);
 
        generic_handle_irq(intcs_evt2irq(evtcodeas));
@@ -641,6 +641,6 @@ void __init sh7377_init_irq(void)
        register_intc_controller(&intcs_desc);
 
        /* demux using INTEVTSA */
-       set_irq_data(evt2irq(INTCS_INTVECT), (void *)intevtsa);
-       set_irq_chained_handler(evt2irq(INTCS_INTVECT), intcs_demux);
+       irq_set_handler_data(evt2irq(INTCS_INTVECT), (void *)intevtsa);
+       irq_set_chained_handler(evt2irq(INTCS_INTVECT), intcs_demux);
 }
index aa9231f4fc6e7cbe91d62ece3b4aeaf16f945122..209fa5c65d4cee50bafa54e6a5d38b120472c33d 100644 (file)
@@ -102,10 +102,10 @@ void __init tcc8k_init_irq(void)
 
        for (irqno = 0; irqno < NR_IRQS; irqno++) {
                if (irqno < 32)
-                       set_irq_chip(irqno, &tcc8000_irq_chip0);
+                       irq_set_chip(irqno, &tcc8000_irq_chip0);
                else
-                       set_irq_chip(irqno, &tcc8000_irq_chip1);
-               set_irq_handler(irqno, handle_level_irq);
+                       irq_set_chip(irqno, &tcc8000_irq_chip1);
+               irq_set_handler(irqno, handle_level_irq);
                set_irq_flags(irqno, IRQF_VALID);
        }
 }
index 8ab2131f41d44d652fbda983b802ca2b65dae11b..4148048c4191041d6de9afef34377de31ff0d4ce 100644 (file)
@@ -208,9 +208,9 @@ static int tegra_gpio_irq_set_type(struct irq_data *d, unsigned int type)
        spin_unlock_irqrestore(&bank->lvl_lock[port], flags);
 
        if (type & (IRQ_TYPE_LEVEL_LOW | IRQ_TYPE_LEVEL_HIGH))
-               __set_irq_handler_unlocked(d->irq, handle_level_irq);
+               __irq_set_handler_locked(d->irq, handle_level_irq);
        else if (type & (IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING))
-               __set_irq_handler_unlocked(d->irq, handle_edge_irq);
+               __irq_set_handler_locked(d->irq, handle_edge_irq);
 
        return 0;
 }
@@ -224,7 +224,7 @@ static void tegra_gpio_irq_handler(unsigned int irq, struct irq_desc *desc)
 
        desc->irq_data.chip->irq_ack(&desc->irq_data);
 
-       bank = get_irq_data(irq);
+       bank = irq_get_handler_data(irq);
 
        for (port = 0; port < 4; port++) {
                int gpio = tegra_gpio_compose(bank->bank, port, 0);
@@ -301,7 +301,7 @@ void tegra_gpio_suspend(void)
 static int tegra_gpio_wake_enable(struct irq_data *d, unsigned int enable)
 {
        struct tegra_gpio_bank *bank = irq_data_get_irq_chip_data(d);
-       return set_irq_wake(bank->irq, enable);
+       return irq_set_irq_wake(bank->irq, enable);
 }
 #endif
 
@@ -341,17 +341,17 @@ static int __init tegra_gpio_init(void)
                bank = &tegra_gpio_banks[GPIO_BANK(irq_to_gpio(i))];
 
                irq_set_lockdep_class(i, &gpio_lock_class);
-               set_irq_chip_data(i, bank);
-               set_irq_chip(i, &tegra_gpio_irq_chip);
-               set_irq_handler(i, handle_simple_irq);
+               irq_set_chip_data(i, bank);
+               irq_set_chip(i, &tegra_gpio_irq_chip);
+               irq_set_handler(i, handle_simple_irq);
                set_irq_flags(i, IRQF_VALID);
        }
 
        for (i = 0; i < ARRAY_SIZE(tegra_gpio_banks); i++) {
                bank = &tegra_gpio_banks[i];
 
-               set_irq_chained_handler(bank->irq, tegra_gpio_irq_handler);
-               set_irq_data(bank->irq, bank);
+               irq_set_chained_handler(bank->irq, tegra_gpio_irq_handler);
+               irq_set_handler_data(bank->irq, bank);
 
                for (j = 0; j < 4; j++)
                        spin_lock_init(&bank->lvl_lock[j]);
index dfbc219ea4923ad920b27918cf6fc76fff813f1e..6b5c8b8abe02eba3fc52ab65b290135fabee4579 100644 (file)
@@ -144,7 +144,7 @@ void __init tegra_init_irq(void)
        gic_init(0, 29, IO_ADDRESS(TEGRA_ARM_INT_DIST_BASE),
                 IO_ADDRESS(TEGRA_ARM_PERIF_BASE + 0x100));
 
-       gic = get_irq_chip(29);
+       gic = irq_get_chip(29);
        tegra_gic_unmask_irq = gic->irq_unmask;
        tegra_gic_mask_irq = gic->irq_mask;
        tegra_gic_ack_irq = gic->irq_ack;
@@ -154,8 +154,8 @@ void __init tegra_init_irq(void)
 
        for (i = 0; i < INT_MAIN_NR; i++) {
                irq = INT_PRI_BASE + i;
-               set_irq_chip(irq, &tegra_irq);
-               set_irq_handler(irq, handle_level_irq);
+               irq_set_chip(irq, &tegra_irq);
+               irq_set_handler(irq, handle_level_irq);
                set_irq_flags(irq, IRQF_VALID);
        }
 }
index e1296a7447c8493eabccf5ce189b4a0aaf1a6ed6..5f2322e6c108014dc5b68ce113b503a8275de62f 100644 (file)
@@ -90,8 +90,8 @@ static irqreturn_t modem_cpu_irq_handler(int irq, void *data)
 
 static void create_virtual_irq(int irq, struct irq_chip *modem_irq_chip)
 {
-       set_irq_chip(irq, modem_irq_chip);
-       set_irq_handler(irq, handle_simple_irq);
+       irq_set_chip(irq, modem_irq_chip);
+       irq_set_handler(irq, handle_simple_irq);
        set_irq_flags(irq, IRQF_VALID);
 
        pr_debug("modem_irq: Created virtual IRQ %d\n", irq);
index eb7ffa0ee8b544d77caf42cc542892413b055952..96e59e3ee4f551d0c72e3f0960ea5ebe953ff308 100644 (file)
@@ -314,7 +314,7 @@ static struct mmci_platform_data mmc0_plat_data = {
        .gpio_cd        = -1,
 };
 
-static struct resource char_lcd_resources[] = {
+static struct resource chalcd_resources[] = {
        {
                .start = VERSATILE_CHAR_LCD_BASE,
                .end   = (VERSATILE_CHAR_LCD_BASE + SZ_4K - 1),
index cba4695c0fa303a4663021a48655880e914c14f6..e495c014fefda9d4f27e9065b30cf1e3d14cad70 100644 (file)
@@ -136,8 +136,8 @@ void __init vt8500_init_irq(void)
                        /* Disable all interrupts and route them to IRQ */
                        writeb(0x00, ic_regbase + VT8500_IC_DCTR + i);
 
-                       set_irq_chip(i, &vt8500_irq_chip);
-                       set_irq_handler(i, handle_level_irq);
+                       irq_set_chip(i, &vt8500_irq_chip);
+                       irq_set_handler(i, handle_level_irq);
                        set_irq_flags(i, IRQF_VALID);
                }
        } else {
@@ -167,8 +167,8 @@ void __init wm8505_init_irq(void)
                                writeb(0x00, sic_regbase + VT8500_IC_DCTR
                                                                + i - 64);
 
-                       set_irq_chip(i, &vt8500_irq_chip);
-                       set_irq_handler(i, handle_level_irq);
+                       irq_set_chip(i, &vt8500_irq_chip);
+                       irq_set_handler(i, handle_level_irq);
                        set_irq_flags(i, IRQF_VALID);
                }
        } else {
index 9c350103dcdab4e35fff1475a6ef6ee253898ce3..5947d1f630d2be6607ef68993460dc5133f2e94e 100644 (file)
@@ -207,8 +207,8 @@ void __init nuc900_init_irq(void)
        __raw_writel(0xFFFFFFFE, REG_AIC_MDCR);
 
        for (irqno = IRQ_WDT; irqno <= IRQ_ADC; irqno++) {
-               set_irq_chip(irqno, &nuc900_irq_chip);
-               set_irq_handler(irqno, handle_level_irq);
+               irq_set_chip(irqno, &nuc900_irq_chip);
+               irq_set_handler(irqno, handle_level_irq);
                set_irq_flags(irqno, IRQF_VALID);
        }
 }
index 8a2fb7046c9479a50b75dce7111138431ce74b08..9d424ce93354babf0b78745c901e6741848e7f6a 100644 (file)
@@ -181,12 +181,12 @@ int __init mxc_expio_init(u32 base, u32 p_irq)
        __raw_writew(0x1F, brd_io + INTR_MASK_REG);
        for (i = MXC_EXP_IO_BASE;
             i < (MXC_EXP_IO_BASE + MXC_MAX_EXP_IO_LINES); i++) {
-               set_irq_chip(i, &expio_irq_chip);
-               set_irq_handler(i, handle_level_irq);
+               irq_set_chip(i, &expio_irq_chip);
+               irq_set_handler(i, handle_level_irq);
                set_irq_flags(i, IRQF_VALID);
        }
-       set_irq_type(p_irq, IRQF_TRIGGER_LOW);
-       set_irq_chained_handler(p_irq, mxc_expio_irq_handler);
+       irq_set_irq_type(p_irq, IRQF_TRIGGER_LOW);
+       irq_set_chained_handler(p_irq, mxc_expio_irq_handler);
 
        /* Register Lan device on the debugboard */
        smsc911x_resources[0].start = LAN9217_BASE_ADDR(base);
index deb284bc7c4bbc31bc0af8730efcf7604debae73..8b30c83a2ab18fbfc1840958389e4846c242864c 100644 (file)
@@ -139,8 +139,8 @@ void __init mxc_init_irq(void __iomem *irqbase)
        __raw_writel(0, avic_base + AVIC_INTTYPEH);
        __raw_writel(0, avic_base + AVIC_INTTYPEL);
        for (i = 0; i < MXC_INTERNAL_IRQS; i++) {
-               set_irq_chip(i, &mxc_avic_chip.base);
-               set_irq_handler(i, handle_level_irq);
+               irq_set_chip(i, &mxc_avic_chip.base);
+               irq_set_handler(i, handle_level_irq);
                set_irq_flags(i, IRQF_VALID);
        }
 
index 57d59855f9ecbc1e603fc9ab2cecd9779ea1bb48..2ff0b3f9b46d7240b13d8f7bb7a193d045ed17e6 100644 (file)
@@ -175,7 +175,7 @@ static void mxc_gpio_irq_handler(struct mxc_gpio_port *port, u32 irq_stat)
 static void mx3_gpio_irq_handler(u32 irq, struct irq_desc *desc)
 {
        u32 irq_stat;
-       struct mxc_gpio_port *port = get_irq_data(irq);
+       struct mxc_gpio_port *port = irq_get_handler_data(irq);
 
        irq_stat = __raw_readl(port->base + GPIO_ISR) &
                        __raw_readl(port->base + GPIO_IMR);
@@ -188,7 +188,7 @@ static void mx2_gpio_irq_handler(u32 irq, struct irq_desc *desc)
 {
        int i;
        u32 irq_msk, irq_stat;
-       struct mxc_gpio_port *port = get_irq_data(irq);
+       struct mxc_gpio_port *port = irq_get_handler_data(irq);
 
        /* walk through all interrupt status registers */
        for (i = 0; i < gpio_table_size; i++) {
@@ -311,8 +311,8 @@ int __init mxc_gpio_init(struct mxc_gpio_port *port, int cnt)
                __raw_writel(~0, port[i].base + GPIO_ISR);
                for (j = port[i].virtual_irq_start;
                        j < port[i].virtual_irq_start + 32; j++) {
-                       set_irq_chip(j, &gpio_irq_chip);
-                       set_irq_handler(j, handle_level_irq);
+                       irq_set_chip(j, &gpio_irq_chip);
+                       irq_set_handler(j, handle_level_irq);
                        set_irq_flags(j, IRQF_VALID);
                }
 
@@ -331,21 +331,23 @@ int __init mxc_gpio_init(struct mxc_gpio_port *port, int cnt)
 
                if (cpu_is_mx1() || cpu_is_mx3() || cpu_is_mx25() || cpu_is_mx51()) {
                        /* setup one handler for each entry */
-                       set_irq_chained_handler(port[i].irq, mx3_gpio_irq_handler);
-                       set_irq_data(port[i].irq, &port[i]);
+                       irq_set_chained_handler(port[i].irq,
+                                               mx3_gpio_irq_handler);
+                       irq_set_handler_data(port[i].irq, &port[i]);
                        if (port[i].irq_high) {
                                /* setup handler for GPIO 16 to 31 */
-                               set_irq_chained_handler(port[i].irq_high,
-                                               mx3_gpio_irq_handler);
-                               set_irq_data(port[i].irq_high, &port[i]);
+                               irq_set_chained_handler(port[i].irq_high,
+                                                       mx3_gpio_irq_handler);
+                               irq_set_handler_data(port[i].irq_high,
+                                                    &port[i]);
                        }
                }
        }
 
        if (cpu_is_mx2()) {
                /* setup one handler for all GPIO interrupts */
-               set_irq_chained_handler(port[0].irq, mx2_gpio_irq_handler);
-               set_irq_data(port[0].irq, port);
+               irq_set_chained_handler(port[0].irq, mx2_gpio_irq_handler);
+               irq_set_handler_data(port[0].irq, port);
        }
 
        return 0;
index 0c799ac27730883dfc37aa633605d528262bc13f..e1c6eff7258ae4728bb4d09e19fbbd1153c5e3f1 100644 (file)
@@ -29,7 +29,7 @@ int imx_irq_set_priority(unsigned char irq, unsigned char prio)
 
        ret = -ENOSYS;
 
-       base = get_irq_chip(irq);
+       base = irq_get_chip(irq);
        if (base) {
                chip = container_of(base, struct mxc_irq_chip, base);
                if (chip->set_priority)
@@ -48,7 +48,7 @@ int mxc_set_irq_fiq(unsigned int irq, unsigned int type)
 
        ret = -ENOSYS;
 
-       base = get_irq_chip(irq);
+       base = irq_get_chip(irq);
        if (base) {
                chip = container_of(base, struct mxc_irq_chip, base);
                if (chip->set_irq_fiq)
index bc3a6be8a27fe210dd0ed45d67f75b884a86289a..c299152e0841900e014f84f7467257e6f018476d 100644 (file)
@@ -167,8 +167,8 @@ void __init tzic_init_irq(void __iomem *irqbase)
        /* all IRQ no FIQ Warning :: No selection */
 
        for (i = 0; i < MXC_INTERNAL_IRQS; i++) {
-               set_irq_chip(i, &mxc_tzic_chip.base);
-               set_irq_handler(i, handle_level_irq);
+               irq_set_chip(i, &mxc_tzic_chip.base);
+               irq_set_handler(i, handle_level_irq);
                set_irq_flags(i, IRQF_VALID);
        }
 
index 1b402a8e90314d25841f1f3cd7e5fcc66c7feb71..63adc4d417fef7f33d0a49d4ac0bb31aa1977346 100644 (file)
@@ -319,7 +319,7 @@ static int __nmk_config_pins(pin_cfg_t *cfgs, int num, bool sleep)
                struct nmk_gpio_chip *nmk_chip;
                int pin = PIN_NUM(cfgs[i]);
 
-               nmk_chip = get_irq_chip_data(NOMADIK_GPIO_TO_IRQ(pin));
+               nmk_chip = irq_get_chip_data(NOMADIK_GPIO_TO_IRQ(pin));
                if (!nmk_chip) {
                        ret = -EINVAL;
                        break;
@@ -398,7 +398,7 @@ int nmk_gpio_set_slpm(int gpio, enum nmk_gpio_slpm mode)
        struct nmk_gpio_chip *nmk_chip;
        unsigned long flags;
 
-       nmk_chip = get_irq_chip_data(NOMADIK_GPIO_TO_IRQ(gpio));
+       nmk_chip = irq_get_chip_data(NOMADIK_GPIO_TO_IRQ(gpio));
        if (!nmk_chip)
                return -EINVAL;
 
@@ -431,7 +431,7 @@ int nmk_gpio_set_pull(int gpio, enum nmk_gpio_pull pull)
        struct nmk_gpio_chip *nmk_chip;
        unsigned long flags;
 
-       nmk_chip = get_irq_chip_data(NOMADIK_GPIO_TO_IRQ(gpio));
+       nmk_chip = irq_get_chip_data(NOMADIK_GPIO_TO_IRQ(gpio));
        if (!nmk_chip)
                return -EINVAL;
 
@@ -457,7 +457,7 @@ int nmk_gpio_set_mode(int gpio, int gpio_mode)
        struct nmk_gpio_chip *nmk_chip;
        unsigned long flags;
 
-       nmk_chip = get_irq_chip_data(NOMADIK_GPIO_TO_IRQ(gpio));
+       nmk_chip = irq_get_chip_data(NOMADIK_GPIO_TO_IRQ(gpio));
        if (!nmk_chip)
                return -EINVAL;
 
@@ -474,7 +474,7 @@ int nmk_gpio_get_mode(int gpio)
        struct nmk_gpio_chip *nmk_chip;
        u32 afunc, bfunc, bit;
 
-       nmk_chip = get_irq_chip_data(NOMADIK_GPIO_TO_IRQ(gpio));
+       nmk_chip = irq_get_chip_data(NOMADIK_GPIO_TO_IRQ(gpio));
        if (!nmk_chip)
                return -EINVAL;
 
@@ -678,7 +678,7 @@ static void __nmk_gpio_irq_handler(unsigned int irq, struct irq_desc *desc,
                                   u32 status)
 {
        struct nmk_gpio_chip *nmk_chip;
-       struct irq_chip *host_chip = get_irq_chip(irq);
+       struct irq_chip *host_chip = irq_get_chip(irq);
        unsigned int first_irq;
 
        if (host_chip->irq_mask_ack)
@@ -689,7 +689,7 @@ static void __nmk_gpio_irq_handler(unsigned int irq, struct irq_desc *desc,
                        host_chip->irq_ack(&desc->irq_data);
        }
 
-       nmk_chip = get_irq_data(irq);
+       nmk_chip = irq_get_handler_data(irq);
        first_irq = NOMADIK_GPIO_TO_IRQ(nmk_chip->chip.base);
        while (status) {
                int bit = __ffs(status);
@@ -703,7 +703,7 @@ static void __nmk_gpio_irq_handler(unsigned int irq, struct irq_desc *desc,
 
 static void nmk_gpio_irq_handler(unsigned int irq, struct irq_desc *desc)
 {
-       struct nmk_gpio_chip *nmk_chip = get_irq_data(irq);
+       struct nmk_gpio_chip *nmk_chip = irq_get_handler_data(irq);
        u32 status = readl(nmk_chip->addr + NMK_GPIO_IS);
 
        __nmk_gpio_irq_handler(irq, desc, status);
@@ -712,7 +712,7 @@ static void nmk_gpio_irq_handler(unsigned int irq, struct irq_desc *desc)
 static void nmk_gpio_secondary_irq_handler(unsigned int irq,
                                           struct irq_desc *desc)
 {
-       struct nmk_gpio_chip *nmk_chip = get_irq_data(irq);
+       struct nmk_gpio_chip *nmk_chip = irq_get_handler_data(irq);
        u32 status = nmk_chip->get_secondary_status(nmk_chip->bank);
 
        __nmk_gpio_irq_handler(irq, desc, status);
@@ -725,20 +725,20 @@ static int nmk_gpio_init_irq(struct nmk_gpio_chip *nmk_chip)
 
        first_irq = NOMADIK_GPIO_TO_IRQ(nmk_chip->chip.base);
        for (i = first_irq; i < first_irq + nmk_chip->chip.ngpio; i++) {
-               set_irq_chip(i, &nmk_gpio_irq_chip);
-               set_irq_handler(i, handle_edge_irq);
+               irq_set_chip(i, &nmk_gpio_irq_chip);
+               irq_set_handler(i, handle_edge_irq);
                set_irq_flags(i, IRQF_VALID);
-               set_irq_chip_data(i, nmk_chip);
-               set_irq_type(i, IRQ_TYPE_EDGE_FALLING);
+               irq_set_chip_data(i, nmk_chip);
+               irq_set_irq_type(i, IRQ_TYPE_EDGE_FALLING);
        }
 
-       set_irq_chained_handler(nmk_chip->parent_irq, nmk_gpio_irq_handler);
-       set_irq_data(nmk_chip->parent_irq, nmk_chip);
+       irq_set_chained_handler(nmk_chip->parent_irq, nmk_gpio_irq_handler);
+       irq_set_handler_data(nmk_chip->parent_irq, nmk_chip);
 
        if (nmk_chip->secondary_parent_irq >= 0) {
-               set_irq_chained_handler(nmk_chip->secondary_parent_irq,
+               irq_set_chained_handler(nmk_chip->secondary_parent_irq,
                                        nmk_gpio_secondary_irq_handler);
-               set_irq_data(nmk_chip->secondary_parent_irq, nmk_chip);
+               irq_set_handler_data(nmk_chip->secondary_parent_irq, nmk_chip);
        }
 
        return 0;
index af07333e478e3c39c29f91d65c20715d6e47f0ac..d2adcdda23cf41c351fe418e31097fe2e4773df3 100644 (file)
@@ -758,9 +758,9 @@ static int gpio_irq_type(struct irq_data *d, unsigned type)
        spin_unlock_irqrestore(&bank->lock, flags);
 
        if (type & (IRQ_TYPE_LEVEL_LOW | IRQ_TYPE_LEVEL_HIGH))
-               __set_irq_handler_unlocked(d->irq, handle_level_irq);
+               __irq_set_handler_locked(d->irq, handle_level_irq);
        else if (type & (IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING))
-               __set_irq_handler_unlocked(d->irq, handle_edge_irq);
+               __irq_set_handler_locked(d->irq, handle_edge_irq);
 
        return retval;
 }
@@ -1140,7 +1140,7 @@ static void gpio_irq_handler(unsigned int irq, struct irq_desc *desc)
 
        desc->irq_data.chip->irq_ack(&desc->irq_data);
 
-       bank = get_irq_data(irq);
+       bank = irq_get_handler_data(irq);
 #ifdef CONFIG_ARCH_OMAP1
        if (bank->method == METHOD_MPUIO)
                isr_reg = bank->base +
@@ -1666,16 +1666,16 @@ static void __init omap_gpio_chip_init(struct gpio_bank *bank)
        for (j = bank->virtual_irq_start;
                     j < bank->virtual_irq_start + bank_width; j++) {
                irq_set_lockdep_class(j, &gpio_lock_class);
-               set_irq_chip_data(j, bank);
+               irq_set_chip_data(j, bank);
                if (bank_is_mpuio(bank))
-                       set_irq_chip(j, &mpuio_irq_chip);
+                       irq_set_chip(j, &mpuio_irq_chip);
                else
-                       set_irq_chip(j, &gpio_irq_chip);
-               set_irq_handler(j, handle_simple_irq);
+                       irq_set_chip(j, &gpio_irq_chip);
+               irq_set_handler(j, handle_simple_irq);
                set_irq_flags(j, IRQF_VALID);
        }
-       set_irq_chained_handler(bank->irq, gpio_irq_handler);
-       set_irq_data(bank->irq, bank);
+       irq_set_chained_handler(bank->irq, gpio_irq_handler);
+       irq_set_handler_data(bank->irq, bank);
 }
 
 static int __devinit omap_gpio_probe(struct platform_device *pdev)
index 222327b2c230bc0fde3d5e28383fed5a3d6c1254..9ea0ae4b782f4b4569e235bac47b19b8ae72360d 100644 (file)
@@ -474,9 +474,9 @@ void __init orion_gpio_init(int gpio_base, int ngpio,
        for (i = 0; i < ngpio; i++) {
                unsigned int irq = secondary_irq_base + i;
 
-               set_irq_chip(irq, &orion_gpio_irq_chip);
-               set_irq_handler(irq, handle_level_irq);
-               set_irq_chip_data(irq, ochip);
+               irq_set_chip(irq, &orion_gpio_irq_chip);
+               irq_set_handler(irq, handle_level_irq);
+               irq_set_chip_data(irq, ochip);
                irq_set_status_flags(irq, IRQ_LEVEL);
                set_irq_flags(irq, IRQF_VALID);
        }
index c163f9079e4bd570880f48db93bc5f861d811a1c..aba3ffed942751b0f031c0828a51401ffdad22c9 100644 (file)
@@ -56,9 +56,9 @@ void __init orion_irq_init(unsigned int irq_start, void __iomem *maskaddr)
        for (i = 0; i < 32; i++) {
                unsigned int irq = irq_start + i;
 
-               set_irq_chip(irq, &orion_irq_chip);
-               set_irq_chip_data(irq, maskaddr);
-               set_irq_handler(irq, handle_level_irq);
+               irq_set_chip(irq, &orion_irq_chip);
+               irq_set_chip_data(irq, maskaddr);
+               irq_set_handler(irq, handle_level_irq);
                irq_set_status_flags(irq, IRQ_LEVEL);
                set_irq_flags(irq, IRQF_VALID);
        }
index e7de6ae2a1e816212407476b784defd76fd94758..5e05467eec3dc34c3ead6c70867ebb671bea037b 100644 (file)
@@ -284,13 +284,13 @@ void __init pxa_init_gpio(int mux_irq, int start, int end, set_wake_t fn)
        }
 
        for (irq  = gpio_to_irq(start); irq <= gpio_to_irq(end); irq++) {
-               set_irq_chip(irq, &pxa_muxed_gpio_chip);
-               set_irq_handler(irq, handle_edge_irq);
+               irq_set_chip(irq, &pxa_muxed_gpio_chip);
+               irq_set_handler(irq, handle_edge_irq);
                set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
        }
 
        /* Install handler for GPIO>=2 edge detect interrupts */
-       set_irq_chained_handler(mux_irq, pxa_gpio_demux_handler);
+       irq_set_chained_handler(mux_irq, pxa_gpio_demux_handler);
        pxa_muxed_gpio_chip.irq_set_wake = fn;
 }
 
index 4434cb56bd9ad898a76ca54c31fb4ca07af52fc1..c2a42d526635115273a208e3a6c2bfd8c89b12a1 100644 (file)
@@ -592,8 +592,8 @@ void __init s3c24xx_init_irq(void)
                case IRQ_UART1:
                case IRQ_UART2:
                case IRQ_ADCPARENT:
-                       set_irq_chip(irqno, &s3c_irq_level_chip);
-                       set_irq_handler(irqno, handle_level_irq);
+                       irq_set_chip(irqno, &s3c_irq_level_chip);
+                       irq_set_handler(irqno, handle_level_irq);
                        break;
 
                case IRQ_RESERVED6:
@@ -603,35 +603,35 @@ void __init s3c24xx_init_irq(void)
 
                default:
                        //irqdbf("registering irq %d (s3c irq)\n", irqno);
-                       set_irq_chip(irqno, &s3c_irq_chip);
-                       set_irq_handler(irqno, handle_edge_irq);
+                       irq_set_chip(irqno, &s3c_irq_chip);
+                       irq_set_handler(irqno, handle_edge_irq);
                        set_irq_flags(irqno, IRQF_VALID);
                }
        }
 
        /* setup the cascade irq handlers */
 
-       set_irq_chained_handler(IRQ_EINT4t7, s3c_irq_demux_extint4t7);
-       set_irq_chained_handler(IRQ_EINT8t23, s3c_irq_demux_extint8);
+       irq_set_chained_handler(IRQ_EINT4t7, s3c_irq_demux_extint4t7);
+       irq_set_chained_handler(IRQ_EINT8t23, s3c_irq_demux_extint8);
 
-       set_irq_chained_handler(IRQ_UART0, s3c_irq_demux_uart0);
-       set_irq_chained_handler(IRQ_UART1, s3c_irq_demux_uart1);
-       set_irq_chained_handler(IRQ_UART2, s3c_irq_demux_uart2);
-       set_irq_chained_handler(IRQ_ADCPARENT, s3c_irq_demux_adc);
+       irq_set_chained_handler(IRQ_UART0, s3c_irq_demux_uart0);
+       irq_set_chained_handler(IRQ_UART1, s3c_irq_demux_uart1);
+       irq_set_chained_handler(IRQ_UART2, s3c_irq_demux_uart2);
+       irq_set_chained_handler(IRQ_ADCPARENT, s3c_irq_demux_adc);
 
        /* external interrupts */
 
        for (irqno = IRQ_EINT0; irqno <= IRQ_EINT3; irqno++) {
                irqdbf("registering irq %d (ext int)\n", irqno);
-               set_irq_chip(irqno, &s3c_irq_eint0t4);
-               set_irq_handler(irqno, handle_edge_irq);
+               irq_set_chip(irqno, &s3c_irq_eint0t4);
+               irq_set_handler(irqno, handle_edge_irq);
                set_irq_flags(irqno, IRQF_VALID);
        }
 
        for (irqno = IRQ_EINT4; irqno <= IRQ_EINT23; irqno++) {
                irqdbf("registering irq %d (extended s3c irq)\n", irqno);
-               set_irq_chip(irqno, &s3c_irqext_chip);
-               set_irq_handler(irqno, handle_edge_irq);
+               irq_set_chip(irqno, &s3c_irqext_chip);
+               irq_set_handler(irqno, handle_edge_irq);
                set_irq_flags(irqno, IRQF_VALID);
        }
 
@@ -641,29 +641,29 @@ void __init s3c24xx_init_irq(void)
 
        for (irqno = IRQ_S3CUART_RX0; irqno <= IRQ_S3CUART_ERR0; irqno++) {
                irqdbf("registering irq %d (s3c uart0 irq)\n", irqno);
-               set_irq_chip(irqno, &s3c_irq_uart0);
-               set_irq_handler(irqno, handle_level_irq);
+               irq_set_chip(irqno, &s3c_irq_uart0);
+               irq_set_handler(irqno, handle_level_irq);
                set_irq_flags(irqno, IRQF_VALID);
        }
 
        for (irqno = IRQ_S3CUART_RX1; irqno <= IRQ_S3CUART_ERR1; irqno++) {
                irqdbf("registering irq %d (s3c uart1 irq)\n", irqno);
-               set_irq_chip(irqno, &s3c_irq_uart1);
-               set_irq_handler(irqno, handle_level_irq);
+               irq_set_chip(irqno, &s3c_irq_uart1);
+               irq_set_handler(irqno, handle_level_irq);
                set_irq_flags(irqno, IRQF_VALID);
        }
 
        for (irqno = IRQ_S3CUART_RX2; irqno <= IRQ_S3CUART_ERR2; irqno++) {
                irqdbf("registering irq %d (s3c uart2 irq)\n", irqno);
-               set_irq_chip(irqno, &s3c_irq_uart2);
-               set_irq_handler(irqno, handle_level_irq);
+               irq_set_chip(irqno, &s3c_irq_uart2);
+               irq_set_handler(irqno, handle_level_irq);
                set_irq_flags(irqno, IRQF_VALID);
        }
 
        for (irqno = IRQ_TC; irqno <= IRQ_ADC; irqno++) {
                irqdbf("registering irq %d (s3c adc irq)\n", irqno);
-               set_irq_chip(irqno, &s3c_irq_adc);
-               set_irq_handler(irqno, handle_edge_irq);
+               irq_set_chip(irqno, &s3c_irq_adc);
+               irq_set_handler(irqno, handle_edge_irq);
                set_irq_flags(irqno, IRQF_VALID);
        }
 
index 225aa25405db4701d42c01abc2fb40d53b45faed..f3d15e8c02c1e94b8d5668ec44d68406cb2eb1e8 100644 (file)
@@ -205,15 +205,15 @@ int __init s5p_init_irq_eint(void)
        int irq;
 
        for (irq = IRQ_EINT(0); irq <= IRQ_EINT(15); irq++)
-               set_irq_chip(irq, &s5p_irq_vic_eint);
+               irq_set_chip(irq, &s5p_irq_vic_eint);
 
        for (irq = IRQ_EINT(16); irq <= IRQ_EINT(31); irq++) {
-               set_irq_chip(irq, &s5p_irq_eint);
-               set_irq_handler(irq, handle_level_irq);
+               irq_set_chip(irq, &s5p_irq_eint);
+               irq_set_handler(irq, handle_level_irq);
                set_irq_flags(irq, IRQF_VALID);
        }
 
-       set_irq_chained_handler(IRQ_EINT16_31, s5p_irq_demux_eint16_31);
+       irq_set_chained_handler(IRQ_EINT16_31, s5p_irq_demux_eint16_31);
        return 0;
 }
 
index cd87d3256e033b553fb5540ff1da308c880c4792..46dd078147d8b13e0750e11bd6f047c18ac033e6 100644 (file)
@@ -43,13 +43,13 @@ LIST_HEAD(banks);
 
 static int s5p_gpioint_get_offset(struct irq_data *data)
 {
-       struct s3c_gpio_chip *chip = irq_data_get_irq_data(data);
+       struct s3c_gpio_chip *chip = irq_data_get_irq_handler_data(data);
        return data->irq - chip->irq_base;
 }
 
 static void s5p_gpioint_ack(struct irq_data *data)
 {
-       struct s3c_gpio_chip *chip = irq_data_get_irq_data(data);
+       struct s3c_gpio_chip *chip = irq_data_get_irq_handler_data(data);
        int group, offset, pend_offset;
        unsigned int value;
 
@@ -64,7 +64,7 @@ static void s5p_gpioint_ack(struct irq_data *data)
 
 static void s5p_gpioint_mask(struct irq_data *data)
 {
-       struct s3c_gpio_chip *chip = irq_data_get_irq_data(data);
+       struct s3c_gpio_chip *chip = irq_data_get_irq_handler_data(data);
        int group, offset, mask_offset;
        unsigned int value;
 
@@ -79,7 +79,7 @@ static void s5p_gpioint_mask(struct irq_data *data)
 
 static void s5p_gpioint_unmask(struct irq_data *data)
 {
-       struct s3c_gpio_chip *chip = irq_data_get_irq_data(data);
+       struct s3c_gpio_chip *chip = irq_data_get_irq_handler_data(data);
        int group, offset, mask_offset;
        unsigned int value;
 
@@ -100,7 +100,7 @@ static void s5p_gpioint_mask_ack(struct irq_data *data)
 
 static int s5p_gpioint_set_type(struct irq_data *data, unsigned int type)
 {
-       struct s3c_gpio_chip *chip = irq_data_get_irq_data(data);
+       struct s3c_gpio_chip *chip = irq_data_get_irq_handler_data(data);
        int group, offset, con_offset;
        unsigned int value;
 
@@ -149,7 +149,7 @@ static struct irq_chip s5p_gpioint = {
 
 static void s5p_gpioint_handler(unsigned int irq, struct irq_desc *desc)
 {
-       struct s5p_gpioint_bank *bank = get_irq_data(irq);
+       struct s5p_gpioint_bank *bank = irq_get_handler_data(irq);
        int group, pend_offset, mask_offset;
        unsigned int pend, mask;
 
@@ -200,8 +200,8 @@ static __init int s5p_gpioint_add(struct s3c_gpio_chip *chip)
                if (!bank->chips)
                        return -ENOMEM;
 
-               set_irq_chained_handler(bank->irq, s5p_gpioint_handler);
-               set_irq_data(bank->irq, bank);
+               irq_set_chained_handler(bank->irq, s5p_gpioint_handler);
+               irq_set_handler_data(bank->irq, bank);
                bank->handler = s5p_gpioint_handler;
                printk(KERN_INFO "Registered chained gpio int handler for interrupt %d.\n",
                       bank->irq);
@@ -219,9 +219,9 @@ static __init int s5p_gpioint_add(struct s3c_gpio_chip *chip)
        bank->chips[group - bank->start] = chip;
        for (i = 0; i < chip->chip.ngpio; i++) {
                irq = chip->irq_base + i;
-               set_irq_chip(irq, &s5p_gpioint);
-               set_irq_data(irq, chip);
-               set_irq_handler(irq, handle_level_irq);
+               irq_set_chip(irq, &s5p_gpioint);
+               irq_set_handler_data(irq, chip);
+               irq_set_handler(irq, handle_level_irq);
                set_irq_flags(irq, IRQF_VALID);
        }
        return 0;
index b721c04a830ef0066d2703114b6872ede3f6420a..3c064a0176b70015aa3076ef5b0552768934f3b6 100644 (file)
@@ -117,9 +117,9 @@ static void __init s3c_init_uart_irq(struct s3c_uart_irq *uirq)
        for (offs = 0; offs < 3; offs++) {
                irq = uirq->base_irq + offs;
 
-               set_irq_chip(irq, &s3c_irq_uart);
-               set_irq_chip_data(irq, uirq);
-               set_irq_handler(irq, handle_level_irq);
+               irq_set_chip(irq, &s3c_irq_uart);
+               irq_set_chip_data(irq, uirq);
+               irq_set_handler(irq, handle_level_irq);
                set_irq_flags(irq, IRQF_VALID);
        }
 
index 78189035e7f109202272419bee7d1169b1e38c0f..b4294cc140fa175acf783c0994ca7f4ff8976f91 100644 (file)
@@ -68,7 +68,7 @@ static struct irq_chip shirq_chip = {
 static void shirq_handler(unsigned irq, struct irq_desc *desc)
 {
        u32 i, val, mask;
-       struct spear_shirq *shirq = get_irq_data(irq);
+       struct spear_shirq *shirq = irq_get_handler_data(irq);
 
        desc->irq_data.chip->irq_ack(&desc->irq_data);
        while ((val = readl(shirq->regs.base + shirq->regs.status_reg) &
@@ -105,14 +105,14 @@ int spear_shirq_register(struct spear_shirq *shirq)
        if (!shirq->dev_count)
                return -EINVAL;
 
-       set_irq_chained_handler(shirq->irq, shirq_handler);
+       irq_set_chained_handler(shirq->irq, shirq_handler);
        for (i = 0; i < shirq->dev_count; i++) {
-               set_irq_chip(shirq->dev_config[i].virq, &shirq_chip);
-               set_irq_handler(shirq->dev_config[i].virq, handle_simple_irq);
+               irq_set_chip(shirq->dev_config[i].virq, &shirq_chip);
+               irq_set_handler(shirq->dev_config[i].virq, handle_simple_irq);
                set_irq_flags(shirq->dev_config[i].virq, IRQF_VALID);
-               set_irq_chip_data(shirq->dev_config[i].virq, shirq);
+               irq_set_chip_data(shirq->dev_config[i].virq, shirq);
        }
 
-       set_irq_data(shirq->irq, shirq);
+       irq_set_handler_data(shirq->irq, shirq);
        return 0;
 }
index aaa168683d4e5734a24485a5807f4f8871a720c0..fc2e76488c16988f94d18d2d9b9c42f39793fcee 100644 (file)
@@ -35,8 +35,8 @@ void __init stmp3xxx_init_irq(struct irq_chip *chip)
        /* Disable all interrupts initially */
        for (i = 0; i < NR_REAL_IRQS; i++) {
                chip->irq_mask(irq_get_irq_data(i));
-               set_irq_chip(i, chip);
-               set_irq_handler(i, handle_level_irq);
+               irq_set_chip(i, chip);
+               irq_set_handler(i, handle_level_irq);
                set_irq_flags(i, IRQF_VALID | IRQF_PROBE);
        }
 
index c9c38e8d8b13eb022ed2895b2ed004584843629b..9057d932799a4f06b59db25d6db2f34e161ff719 100644 (file)
@@ -489,7 +489,7 @@ static void stmp3xxx_gpio_free(struct gpio_chip *chip, unsigned offset)
 
 static void stmp3xxx_gpio_irq(u32 irq, struct irq_desc *desc)
 {
-       struct stmp3xxx_pinmux_bank *pm = get_irq_data(irq);
+       struct stmp3xxx_pinmux_bank *pm = irq_get_handler_data(irq);
        int gpio_irq = pm->virq;
        u32 stat = __raw_readl(pm->irqstat);
 
@@ -533,15 +533,15 @@ int __init stmp3xxx_pinmux_init(int virtual_irq_start)
 
                for (virq = pm->virq; virq < pm->virq; virq++) {
                        gpio_irq_chip.irq_mask(irq_get_irq_data(virq));
-                       set_irq_chip(virq, &gpio_irq_chip);
-                       set_irq_handler(virq, handle_level_irq);
+                       irq_set_chip(virq, &gpio_irq_chip);
+                       irq_set_handler(virq, handle_level_irq);
                        set_irq_flags(virq, IRQF_VALID);
                }
                r = gpiochip_add(&pm->chip);
                if (r < 0)
                        break;
-               set_irq_chained_handler(pm->irq, stmp3xxx_gpio_irq);
-               set_irq_data(pm->irq, pm);
+               irq_set_chained_handler(pm->irq, stmp3xxx_gpio_irq);
+               irq_set_handler_data(pm->irq, pm);
        }
        return r;
 }
index 31d945d37e4f10011421488c6b45deaa04a99c71..f21d838044c866d986eadddddbcb04d3bf21ad5a 100644 (file)
@@ -30,7 +30,7 @@ static void fpga_irq_unmask(struct irq_data *d)
 
 static void fpga_irq_handle(unsigned int irq, struct irq_desc *desc)
 {
-       struct fpga_irq_data *f = get_irq_desc_data(desc);
+       struct fpga_irq_data *f = irq_desc_get_handler_data(desc);
        u32 status = readl(f->base + IRQ_STATUS);
 
        if (status == 0) {
@@ -55,17 +55,17 @@ void __init fpga_irq_init(int parent_irq, u32 valid, struct fpga_irq_data *f)
        f->chip.irq_unmask = fpga_irq_unmask;
 
        if (parent_irq != -1) {
-               set_irq_data(parent_irq, f);
-               set_irq_chained_handler(parent_irq, fpga_irq_handle);
+               irq_set_handler_data(parent_irq, f);
+               irq_set_chained_handler(parent_irq, fpga_irq_handle);
        }
 
        for (i = 0; i < 32; i++) {
                if (valid & (1 << i)) {
                        unsigned int irq = f->irq_start + i;
 
-                       set_irq_chip_data(irq, f);
-                       set_irq_chip(irq, &f->chip);
-                       set_irq_handler(irq, handle_level_irq);
+                       irq_set_chip_data(irq, f);
+                       irq_set_chip(irq, &f->chip);
+                       irq_set_handler(irq, handle_level_irq);
                        set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
                }
        }