desc_handle_irq() was declared as obsolete since long ago.
Replace it with generic_handle_irq()
Signed-off-by: Dmitry Baryshkov <dbaryshkov@gmail.com>
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
        }
 }
 
-static inline void it8152_irq(int irq)
-{
-       struct irq_desc *desc;
-
-       desc = irq_desc + irq;
-       desc_handle_irq(irq, desc);
-}
-
 static struct irq_chip it8152_irq_chip = {
        .name           = "it8152",
        .ack            = it8152_mask_irq,
               bits_pd &= ((1 << IT8152_PD_IRQ_COUNT) - 1);
               while (bits_pd) {
                       i = __ffs(bits_pd);
-                      it8152_irq(IT8152_PD_IRQ(i));
+                      generic_handle_irq(IT8152_PD_IRQ(i));
                       bits_pd &= ~(1 << i);
               }
 
               bits_lp &= ((1 << IT8152_LP_IRQ_COUNT) - 1);
               while (bits_lp) {
                       i = __ffs(bits_lp);
-                      it8152_irq(IT8152_LP_IRQ(i));
+                      generic_handle_irq(IT8152_LP_IRQ(i));
                       bits_lp &= ~(1 << i);
               }
 
               bits_ld &= ((1 << IT8152_LD_IRQ_COUNT) - 1);
               while (bits_ld) {
                       i = __ffs(bits_ld);
-                      it8152_irq(IT8152_LD_IRQ(i));
+                      generic_handle_irq(IT8152_LD_IRQ(i));
                       bits_ld &= ~(1 << i);
               }
        }
 
 static void locomo_handler(unsigned int irq, struct irq_desc *desc)
 {
        int req, i;
-       struct irq_desc *d;
        void __iomem *mapbase = get_irq_chip_data(irq);
 
        /* Acknowledge the parent IRQ */
        if (req) {
                /* generate the next interrupt(s) */
                irq = LOCOMO_IRQ_START;
-               d = irq_desc + irq;
-               for (i = 0; i <= 3; i++, d++, irq++) {
+               for (i = 0; i <= 3; i++, irq++) {
                        if (req & (0x0100 << i)) {
-                               desc_handle_irq(irq, d);
+                               generic_handle_irq(irq);
                        }
 
                }
 
 static void locomo_key_handler(unsigned int irq, struct irq_desc *desc)
 {
-       struct irq_desc *d;
        void __iomem *mapbase = get_irq_chip_data(irq);
 
        if (locomo_readl(mapbase + LOCOMO_KEYBOARD + LOCOMO_KIC) & 0x0001) {
-               d = irq_desc + LOCOMO_IRQ_KEY_START;
-               desc_handle_irq(LOCOMO_IRQ_KEY_START, d);
+               generic_handle_irq(LOCOMO_IRQ_KEY_START);
        }
 }
 
 static void locomo_gpio_handler(unsigned int irq, struct irq_desc *desc)
 {
        int req, i;
-       struct irq_desc *d;
        void __iomem *mapbase = get_irq_chip_data(irq);
 
        req =   locomo_readl(mapbase + LOCOMO_GIR) &
 
        if (req) {
                irq = LOCOMO_IRQ_GPIO_START;
-               d = irq_desc + LOCOMO_IRQ_GPIO_START;
-               for (i = 0; i <= 15; i++, irq++, d++) {
+               for (i = 0; i <= 15; i++, irq++) {
                        if (req & (0x0001 << i)) {
-                               desc_handle_irq(irq, d);
+                               generic_handle_irq(irq);
                        }
                }
        }
 
 static void locomo_lt_handler(unsigned int irq, struct irq_desc *desc)
 {
-       struct irq_desc *d;
        void __iomem *mapbase = get_irq_chip_data(irq);
 
        if (locomo_readl(mapbase + LOCOMO_LTINT) & 0x0001) {
-               d = irq_desc + LOCOMO_IRQ_LT_START;
-               desc_handle_irq(LOCOMO_IRQ_LT_START, d);
+               generic_handle_irq(LOCOMO_IRQ_LT_START);
        }
 }
 
 static void locomo_spi_handler(unsigned int irq, struct irq_desc *desc)
 {
        int req, i;
-       struct irq_desc *d;
        void __iomem *mapbase = get_irq_chip_data(irq);
 
        req = locomo_readl(mapbase + LOCOMO_SPI + LOCOMO_SPIIR) & 0x000F;
        if (req) {
                irq = LOCOMO_IRQ_SPI_START;
-               d = irq_desc + irq;
 
-               for (i = 0; i <= 3; i++, irq++, d++) {
+               for (i = 0; i <= 3; i++, irq++) {
                        if (req & (0x0001 << i)) {
-                               desc_handle_irq(irq, d);
+                               generic_handle_irq(irq);
                        }
                }
        }
 
                        pending = ecard_default_ops.irqpending(ec);
 
                if (pending) {
-                       struct irq_desc *d = irq_desc + ec->irq;
-                       desc_handle_irq(ec->irq, d);
+                       generic_handle_irq(ec->irq);
                        called ++;
                }
        }
                ecard_t *ec = slot_to_ecard(slot);
 
                if (ec->claimed) {
-                       struct irq_desc *d = irq_desc + ec->irq;
                        /*
                         * this ugly code is so that we can operate a
                         * prioritorising system:
                         * Serial cards should go in 0/1, ethernet/scsi in 2/3
                         * otherwise you will lose serial data at high speeds!
                         */
-                       desc_handle_irq(ec->irq, d);
+                       generic_handle_irq(ec->irq);
                } else {
                        printk(KERN_WARNING "card%d: interrupt from unclaimed "
                               "card???\n", slot);
 
 asmlinkage void __exception asm_do_IRQ(unsigned int irq, struct pt_regs *regs)
 {
        struct pt_regs *old_regs = set_irq_regs(regs);
-       struct irq_desc *desc = irq_desc + irq;
+
+       irq_enter();
 
        /*
         * Some hardware gives randomly wrong interrupts.  Rather
         * than crashing, do something sensible.
         */
        if (irq >= NR_IRQS)
-               desc = &bad_irq_desc;
-
-       irq_enter();
-
-       desc_handle_irq(irq, desc);
+               handle_bad_irq(irq, &bad_irq_desc);
+       else
+               generic_handle_irq(irq);
 
        /* AT91 specific workaround */
        irq_finish(irq);
 
                }
 
                pin = bank->chipbase;
-               gpio = &irq_desc[pin];
 
                while (isr) {
                        if (isr & 1) {
                                        gpio_irq_mask(pin);
                                }
                                else
-                                       desc_handle_irq(pin, gpio);
+                                       generic_handle_irq(pin);
                        }
                        pin++;
                        gpio++;
 
        desc->chip->ack(irq);
        while (1) {
                u32             status;
-               struct irq_desc *gpio;
                int             n;
                int             res;
 
 
                /* now demux them to the right lowlevel handler */
                n = (int)get_irq_data(irq);
-               gpio = &irq_desc[n];
                while (status) {
                        res = ffs(status);
                        n += res;
-                       gpio += res;
-                       desc_handle_irq(n - 1, gpio - 1);
+                       generic_handle_irq(n - 1);
                        status >>= res;
                }
        }
 
        for (i = 0; i < 8; i++) {
                if (status & (1 << i)) {
                        int gpio_irq = gpio_to_irq(EP93XX_GPIO_LINE_A(0)) + i;
-                       desc = irq_desc + gpio_irq;
-                       desc_handle_irq(gpio_irq, desc);
+                       generic_handle_irq(gpio_irq);
                }
        }
 
                if (status & (1 << i)) {
                        int gpio_irq = gpio_to_irq(EP93XX_GPIO_LINE_B(0)) + i;
                        desc = irq_desc + gpio_irq;
-                       desc_handle_irq(gpio_irq, desc);
+                       generic_handle_irq(gpio_irq);
                }
        }
 }
        int port_f_idx = ((irq + 1) & 7) ^ 4; /* {19..22,47..50} -> {0..7} */
        int gpio_irq = gpio_to_irq(EP93XX_GPIO_LINE_F(0)) + port_f_idx;
 
-       desc_handle_irq(gpio_irq, irq_desc + gpio_irq);
+       generic_handle_irq(gpio_irq);
 }
 
 static void ep93xx_gpio_irq_ack(unsigned int irq)
 
                return;
        }
 
-       desc = irq_desc + isa_irq;
-       desc_handle_irq(isa_irq, desc);
+       generic_handle_irq(isa_irq);
 }
 
 static struct irqaction irq_cascade = {
 
                  struct irq_desc *desc)
 {
        IRQDBG("%s irq: %d\n", __func__, irq);
-       desc = irq_desc + irq;
        while (mask) {
                if (mask & 1) {
                        IRQDBG("handling irq %d\n", irq);
-                       desc_handle_irq(irq, desc);
+                       generic_handle_irq(irq);
                }
                irq++;
-               desc++;
                mask >>= 1;
        }
 }
 
 
        mask >>= 1;
        irq = IRQ_TIMER1;
-       desc = irq_desc + irq;
        while (mask) {
                if (mask & 1)
-                       desc_handle_irq(irq, desc);
+                       generic_handle_irq(irq);
                irq++;
-               desc++;
                mask >>= 1;
        }
 }
 
 imx_gpio_handler(unsigned int mask, unsigned int irq,
                  struct irq_desc *desc)
 {
-       desc = irq_desc + irq;
        while (mask) {
                if (mask & 1) {
                        DEBUG_IRQ("handling irq %d\n", irq);
-                       desc_handle_irq(irq, desc);
+                       generic_handle_irq(irq);
                }
                irq++;
-               desc++;
                mask >>= 1;
        }
 }
 
 
                irq += IRQ_SIC_START;
 
-               desc = irq_desc + irq;
-               desc_handle_irq(irq, desc);
+               generic_handle_irq(irq);
        } while (status);
 }
 
 
                do {
                        j = find_first_bit(&status, 32);
                        (write_imipr[i])(1 << j); /* write back to clear bit */
-                       desc = irq_desc + IRQ_IOP13XX_MSI_0 + j + (32*i);
-                       desc_handle_irq(IRQ_IOP13XX_MSI_0 + j + (32*i), desc);
+                       generic_handle_irq(IRQ_IOP13XX_MSI_0 + j + (32*i));
                        status = (read_imipr[i])();
                } while (status);
        }
 
                   
        for (i = 0; i <= 7; i++) {
                if (status & (1<<i)) {
-                       desc = irq_desc + i + IRQ_IXP2000_GPIO0;
-                       desc_handle_irq(i + IRQ_IXP2000_GPIO0, desc);
+                       generic_handle_irq(i + IRQ_IXP2000_GPIO0);
                }
        }
 }
 
        for(i = 31; i >= 0; i--) {
                if(status & (1 << i)) {
-                       desc = irq_desc + IRQ_IXP2000_DRAM0_MIN_ERR + i;
-                       desc_handle_irq(IRQ_IXP2000_DRAM0_MIN_ERR + i, desc);
+                       generic_handle_irq(IRQ_IXP2000_DRAM0_MIN_ERR + i);
                }
        }
 }
 
 
        for(i = 0; i < board_irq_count; i++) {
                if(ex_interrupt & (1 << i))  {
-                       struct irq_desc *cpld_desc;
                        int cpld_irq = IXP2000_BOARD_IRQ(0) + i;
-                       cpld_desc = irq_desc + cpld_irq;
-                       desc_handle_irq(cpld_irq, cpld_desc);
+                       generic_handle_irq(cpld_irq);
                }
        }
 
 
 
        for (i = 0; i < IXP2000_BOARD_IRQS; i++) {
                if (ex_interrupt & (1 << i)) {
-                       struct irq_desc *cpld_desc;
                        int cpld_irq = IXP2000_BOARD_IRQ(0) + i;
-                       cpld_desc = irq_desc + cpld_irq;
-                       desc_handle_irq(cpld_irq, cpld_desc);
+                       generic_handle_irq(cpld_irq);
                }
        }
 
 
 {
        u32 pci_interrupt;
        unsigned int irqno;
-       struct irq_desc *int_desc;
 
        pci_interrupt = *IXP23XX_PCI_XSCALE_INT_STATUS;
 
                BUG();
        }
 
-       int_desc = irq_desc + irqno;
-       desc_handle_irq(irqno, int_desc);
+       generic_handle_irq(irqno);
 
        desc->chip->unmask(irq);
 }
 
 
        for (i = 0; i < IXDP2351_INTA_IRQ_NUM; i++) {
                if (ex_interrupt & (1 << i)) {
-                       struct irq_desc *cpld_desc;
                        int cpld_irq =
                                IXP23XX_MACH_IRQ(IXDP2351_INTA_IRQ_BASE + i);
-                       cpld_desc = irq_desc + cpld_irq;
-                       desc_handle_irq(cpld_irq, cpld_desc);
+                       generic_handle_irq(cpld_irq);
                }
        }
 
 
        for (i = 0; i < IXDP2351_INTB_IRQ_NUM; i++) {
                if (ex_interrupt & (1 << i)) {
-                       struct irq_desc *cpld_desc;
                        int cpld_irq =
                                IXP23XX_MACH_IRQ(IXDP2351_INTB_IRQ_BASE + i);
-                       cpld_desc = irq_desc + cpld_irq;
-                       desc_handle_irq(cpld_irq, cpld_desc);
+                       generic_handle_irq(cpld_irq);
                }
        }
 
 
        irq = IRQ_KEV7A400_CPLD;
        for (; mask; mask >>= 1, ++irq)
                if (mask & 1)
-                       desc_handle_irq(irq, desc);
+                       generic_handle_irq(irq);
 }
 
 void __init lh7a40x_init_board_irq (void)
 
        desc->chip->ack (irq);
 
        if ((mask & (1<<0)) == 0)       /* WLAN */
-               IRQ_DISPATCH (IRQ_LPD7A40X_ETH_INT);
+               generic_handle_irq(IRQ_LPD7A40X_ETH_INT);
 
 #if defined (IRQ_TOUCH)
        if ((mask & (1<<1)) == 0)       /* Touch */
-               IRQ_DISPATCH (IRQ_TOUCH);
+               generic_handle_irq(IRQ_TOUCH);
 #endif
 
        desc->chip->unmask (irq); /* Level-triggered need this */
 
 extern void lh7a40x_clcd_init (void);
 extern void lh7a40x_init_board_irq (void);
 
-#define IRQ_DISPATCH(irq) desc_handle_irq((irq),(irq_desc + irq))
 
        desc->chip->ack (irq);
 
        if ((mask & 0x1) == 0)  /* WLAN */
-               IRQ_DISPATCH (IRQ_LPD7A40X_ETH_INT);
+               generic_handle_irq(IRQ_LPD7A40X_ETH_INT);
 
        if ((mask & 0x2) == 0)  /* Touch */
-               IRQ_DISPATCH (IRQ_LPD7A400_TS);
+               generic_handle_irq(IRQ_LPD7A400_TS);
 
        desc->chip->unmask (irq); /* Level-triggered need this */
 }
 
        stat = ((readl(NETX_DPMAS_INT_EN) &
                readl(NETX_DPMAS_INT_STAT)) >> 24) & 0x1f;
 
-       desc = irq_desc + NETX_IRQ_HIF_CHAINED(0);
-
        while (stat) {
                if (stat & 1) {
                        DEBUG_IRQ("handling irq %d\n", irq);
-                       desc_handle_irq(irq, desc);
+                       generic_handle_irq(irq);
                }
                irq++;
-               desc++;
                stat >>= 1;
        }
 }
 
 
        while (stat != 0) {
                int irqno = fls(stat) - 1;
-               struct irq_desc *fpgadesc;
 
                stat &= ~(1 << irqno);
 
-               fpgadesc = irq_desc + FPGA_IRQ(irqno);
-
-               desc_handle_irq(FPGA_IRQ(irqno), fpgadesc);
+               generic_handle_irq(FPGA_IRQ(irqno));
        }
 
        desc->chip->unmask(irq);
 
 #include <linux/reboot.h>
 #include <linux/serial_8250.h>
 #include <linux/serial_reg.h>
+#include <linux/irq.h>
 
 #include <mach/hardware.h>
 #include <asm/mach-types.h>
 
 
 void innovator_fpga_IRQ_demux(unsigned int irq, struct irq_desc *desc)
 {
-       struct irq_desc *d;
        u32 stat;
        int fpga_irq;
 
             (fpga_irq < OMAP_FPGA_IRQ_END) && stat;
             fpga_irq++, stat >>= 1) {
                if (stat & 1) {
-                       d = irq_desc + fpga_irq;
-                       desc_handle_irq(fpga_irq, d);
+                       generic_handle_irq(fpga_irq);
                }
        }
 }
 
                                polarity ^= 1 << pin;
                                writel(polarity, GPIO_IN_POL);
                        }
-                       desc_handle_irq(irq, desc);
+                       generic_handle_irq(irq);
                }
        }
 }
 
                        loop = 1;
 
                        n = PXA_GPIO_IRQ_BASE + bit;
-                       desc_handle_irq(n, irq_desc + n);
+                       generic_handle_irq(n);
 
                        bit = find_next_bit(gedr, GEDR_BITS, bit + 1);
                }
 
                GEDR(0) = GPIO_bit(0);  /* clear useless edge notification */
                if (likely(pending)) {
                        irq = LPD270_IRQ(0) + __ffs(pending);
-                       desc = irq_desc + irq;
-                       desc_handle_irq(irq, desc);
+                       generic_handle_irq(irq);
 
                        pending = __raw_readw(LPD270_INT_STATUS) &
                                                lpd270_irq_enabled;
 
                GEDR(0) = GPIO_bit(0);  /* clear our parent irq */
                if (likely(pending)) {
                        irq = LUBBOCK_IRQ(0) + __ffs(pending);
-                       desc = irq_desc + irq;
-                       desc_handle_irq(irq, desc);
+                       generic_handle_irq(irq);
                }
                pending = LUB_IRQ_SET_CLR & lubbock_irq_enabled;
        } while (pending);
 
                GEDR(0) = GPIO_bit(0);  /* clear useless edge notification */
                if (likely(pending)) {
                        irq = MAINSTONE_IRQ(0) + __ffs(pending);
-                       desc = irq_desc + irq;
-                       desc_handle_irq(irq, desc);
+                       generic_handle_irq(irq);
                }
                pending = MST_INTSETCLR & mainstone_irq_enabled;
        } while (pending);
 
                                        GPIO_bit(PCM990_CTRL_INT_IRQ_GPIO);
                if (likely(pending)) {
                        irq = PCM027_IRQ(0) + __ffs(pending);
-                       desc = irq_desc + irq;
-                       desc_handle_irq(irq, desc);
+                       generic_handle_irq(irq);
                }
                pending = (~PCM990_INTSETCLR) & pcm990_irq_enabled;
        } while (pending);
 
                for (i = 0; stat != 0; i++, stat >>= 1) {
                        if (stat & 1) {
                                irqno = bast_pc104_irqs[i];
-                               desc = irq_desc + irqno;
-                               desc_handle_irq(irqno, desc);
+                               generic_handle_irq(irqno);
                        }
                }
        }
 
        subsrc  &= ~submsk;
 
        if (subsrc & INTBIT(IRQ_S3C2412_SDI))
-               desc_handle_irq(IRQ_S3C2412_SDI, irq_desc + IRQ_S3C2412_SDI);
+               generic_handle_irq(IRQ_S3C2412_SDI);
 
        if (subsrc & INTBIT(IRQ_S3C2412_CF))
-               desc_handle_irq(IRQ_S3C2412_CF, irq_desc + IRQ_S3C2412_CF);
+               generic_handle_irq(IRQ_S3C2412_CF);
 }
 
 #define INTMSK_CFSDI   (1UL << (IRQ_S3C2412_CFSDI - IRQ_EINT0))
 
                                  struct irq_desc *desc)
 {
        unsigned int subsrc, submsk;
-       struct irq_desc *mydesc;
 
        /* read the current pending interrupts, and the mask
         * for what it is available */
 
        if (subsrc != 0) {
                if (subsrc & 1) {
-                       mydesc = irq_desc + IRQ_S3C2440_WDT;
-                       desc_handle_irq(IRQ_S3C2440_WDT, mydesc);
+                       generic_handle_irq(IRQ_S3C2440_WDT);
                }
                if (subsrc & 2) {
-                       mydesc = irq_desc + IRQ_S3C2440_AC97;
-                       desc_handle_irq(IRQ_S3C2440_AC97, mydesc);
+                       generic_handle_irq(IRQ_S3C2440_AC97);
                }
        }
 }
 
 {
        unsigned int subsrc, submsk;
        unsigned int end;
-       struct irq_desc *mydesc;
 
        /* read the current pending interrupts, and the mask
         * for what it is available */
        subsrc  &= (1 << len)-1;
 
        end = len + irq;
-       mydesc = irq_desc + irq;
 
        for (; irq < end && subsrc; irq++) {
                if (subsrc & 1)
-                       desc_handle_irq(irq, mydesc);
+                       generic_handle_irq(irq);
 
-               mydesc++;
                subsrc >>= 1;
        }
 }
 
                GEDR = mask;
 
                irq = IRQ_GPIO11;
-               desc = irq_desc + irq;
                mask >>= 11;
                do {
                        if (mask & 1)
-                               desc_handle_irq(irq, desc);
+                               generic_handle_irq(irq);
                        mask >>= 1;
                        irq++;
-                       desc++;
                } while (mask);
 
                mask = GEDR & 0xfffff800;
 
        unsigned int irr;
 
        while (1) {
-               struct irq_desc *d;
-
                /*
                 * Acknowledge the parent IRQ.
                 */
                        desc->chip->ack(irq);
 
                        if (irr & IRR_ETHERNET) {
-                               d = irq_desc + IRQ_NEPONSET_SMC9196;
-                               desc_handle_irq(IRQ_NEPONSET_SMC9196, d);
+                               generic_handle_irq(IRQ_NEPONSET_SMC9196);
                        }
 
                        if (irr & IRR_USAR) {
-                               d = irq_desc + IRQ_NEPONSET_USAR;
-                               desc_handle_irq(IRQ_NEPONSET_USAR, d);
+                               generic_handle_irq(IRQ_NEPONSET_USAR);
                        }
 
                        desc->chip->unmask(irq);
                }
 
                if (irr & IRR_SA1111) {
-                       d = irq_desc + IRQ_NEPONSET_SA1111;
-                       desc_handle_irq(IRQ_NEPONSET_SA1111, d);
+                       generic_handle_irq(IRQ_NEPONSET_SA1111);
                }
        }
 }
 
 
                irq += IRQ_SIC_START;
 
-               desc = irq_desc + irq;
-               desc_handle_irq(irq, desc);
+               generic_handle_irq(irq);
        } while (status);
 }
 
 
 
                gpio_irq = bank->virtual_irq_start;
                for (; isr != 0; isr >>= 1, gpio_irq++) {
-                       struct irq_desc *d;
-
                        if (!(isr & 1))
                                continue;
-                       d = irq_desc + gpio_irq;
 
-                       desc_handle_irq(gpio_irq, d);
+                       generic_handle_irq(gpio_irq);
                }
        }
        /* if bank has any level sensitive GPIO pin interrupt
 
 {
        unsigned int subsrc, submsk;
        unsigned int offset = 9;
-       struct irq_desc *mydesc;
 
        /* read the current pending interrupts, and the mask
         * for what it is available */
 
        if (subsrc != 0) {
                if (subsrc & 1) {
-                       mydesc = irq_desc + IRQ_TC;
-                       desc_handle_irq(IRQ_TC, mydesc);
+                       generic_handle_irq(IRQ_TC);
                }
                if (subsrc & 2) {
-                       mydesc = irq_desc + IRQ_ADC;
-                       desc_handle_irq(IRQ_ADC, mydesc);
+                       generic_handle_irq(IRQ_ADC);
                }
        }
 }
 {
        unsigned int subsrc, submsk;
        unsigned int offset = start - IRQ_S3CUART_RX0;
-       struct irq_desc *desc;
 
        /* read the current pending interrupts, and the mask
         * for what it is available */
        subsrc &= 7;
 
        if (subsrc != 0) {
-               desc = irq_desc + start;
-
                if (subsrc & 1)
-                       desc_handle_irq(start, desc);
-
-               desc++;
+                       generic_handle_irq(start);
 
                if (subsrc & 2)
-                       desc_handle_irq(start+1, desc);
-
-               desc++;
+                       generic_handle_irq(start+1);
 
                if (subsrc & 4)
-                       desc_handle_irq(start+2, desc);
+                       generic_handle_irq(start+2);
        }
 }
 
                eintpnd &= ~(1<<irq);
 
                irq += (IRQ_EINT4 - 4);
-               desc_handle_irq(irq, irq_desc + irq);
+               generic_handle_irq(irq);
        }
 
 }
 
                irq += (IRQ_EINT4 - 4);
 
-               desc_handle_irq(irq, irq_desc + irq);
+               generic_handle_irq(irq);
        }
 }
 
 
                              struct irq_desc *desc)
 {
        unsigned int subsrc, submsk;
-       struct irq_desc *mydesc;
 
        /* read the current pending interrupts, and the mask
         * for what it is available */
 
        if (subsrc != 0) {
                if (subsrc & 1) {
-                       mydesc = irq_desc + IRQ_S3C2440_CAM_C;
-                       desc_handle_irq(IRQ_S3C2440_CAM_C, mydesc);
+                       generic_handle_irq(IRQ_S3C2440_CAM_C);
                }
                if (subsrc & 2) {
-                       mydesc = irq_desc + IRQ_S3C2440_CAM_P;
-                       desc_handle_irq(IRQ_S3C2440_CAM_P, mydesc);
+                       generic_handle_irq(IRQ_S3C2440_CAM_P);
                }
        }
 }