fast_iob();
 
        for (i = base; i < base + IO_INR_DMA; i++)
-               set_irq_chip(i, &ioasic_irq_type);
+               set_irq_chip_and_handler(i, &ioasic_irq_type,
+                                        handle_level_irq);
        for (; i < base + IO_IRQ_LINES; i++)
-               set_irq_chip(i, &ioasic_dma_irq_type);
+               set_irq_chip_and_handler(i, &ioasic_dma_irq_type,
+                                        handle_level_irq);
 
        ioasic_irq_base = base;
 }
 
        iob();
 
        for (i = base; i < base + KN02_IRQ_LINES; i++)
-               set_irq_chip(i, &kn02_irq_type);
+               set_irq_chip_and_handler(i, &kn02_irq_type, handle_level_irq);
 
        kn02_irq_base = base;
 }
 
        u32 i;
 
        for (i = irq_base; i < irq_base + NUM_EMMA2RH_IRQ; i++)
-               set_irq_chip(i, &emma2rh_irq_controller);
+               set_irq_chip_and_handler(i, &emma2rh_irq_controller,
+                                        handle_level_irq);
 
        emma2rh_irq_base = irq_base;
 }
 
        u32 i;
 
        for (i = irq_base; i < irq_base + NUM_EMMA2RH_IRQ_SW; i++)
-               set_irq_chip(i, &emma2rh_sw_irq_controller);
+               set_irq_chip_and_handler(i, &emma2rh_sw_irq_controller,
+                                        handle_level_irq);
 
        emma2rh_sw_irq_base = irq_base;
 }
 
        int i;
 
        for (i = JAZZ_PARALLEL_IRQ; i <= JAZZ_TIMER_IRQ; i++)
-               set_irq_chip(i, &r4030_irq_type);
+               set_irq_chip_and_handler(i, &r4030_irq_type, handle_level_irq);
 
        r4030_write_reg16(JAZZ_IO_IRQ_ENABLE, 0);
        r4030_read_reg16(JAZZ_IO_IRQ_SOURCE);           /* clear pending IRQs */
 
        .mask = mask_msc_irq,
        .mask_ack = level_mask_and_ack_msc_irq,
        .unmask = unmask_msc_irq,
+       .eoi = unmask_msc_irq,
        .end = end_msc_irq,
 };
 
        .mask = mask_msc_irq,
        .mask_ack = edge_mask_and_ack_msc_irq,
        .unmask = unmask_msc_irq,
+       .eoi = unmask_msc_irq,
        .end = end_msc_irq,
 };
 
 
        int i;
 
        for (i = base; i < base + 64; i++)
-               set_irq_chip(i, &mv64340_irq_type);
+               set_irq_chip_and_handler(i, &mv64340_irq_type,
+                                        handle_level_irq);
 
        irq_base = base;
 }
 
        clear_c0_intcontrol(0x00000f00);                /* Mask all */
 
        for (i = base; i < base + 4; i++)
-               set_irq_chip(i, &rm7k_irq_controller);
+               set_irq_chip_and_handler(i, &rm7k_irq_controller,
+                                        handle_level_irq);
 
        irq_base = base;
 }
 
        clear_c0_intcontrol(0x0000f000);                /* Mask all */
 
        for (i = base; i < base + 4; i++)
-               set_irq_chip(i, &rm9k_irq_controller);
+               set_irq_chip_and_handler(i, &rm9k_irq_controller,
+                                        handle_level_irq);
 
        rm9000_perfcount_irq = base + 1;
-       set_irq_chip(rm9000_perfcount_irq, &rm9k_perfcounter_irq);
+       set_irq_chip_and_handler(rm9000_perfcount_irq, &rm9k_perfcounter_irq,
+                                handle_level_irq);
 
        irq_base = base;
 }
 
        .mask           = mask_mips_irq,
        .mask_ack       = mask_mips_irq,
        .unmask         = unmask_mips_irq,
+       .eoi            = unmask_mips_irq,
        .end            = mips_cpu_irq_end,
 };
 
        .mask           = mask_mips_mt_irq,
        .mask_ack       = mips_mt_cpu_irq_ack,
        .unmask         = unmask_mips_mt_irq,
+       .eoi            = unmask_mips_mt_irq,
        .end            = mips_mt_cpu_irq_end,
 };
 
                        set_irq_chip(i, &mips_mt_cpu_irq_controller);
 
        for (i = irq_base + 2; i < irq_base + 8; i++)
-               set_irq_chip(i, &mips_cpu_irq_controller);
+               set_irq_chip_and_handler(i, &mips_cpu_irq_controller,
+                                        handle_level_irq);
 
        mips_cpu_irq_base = irq_base;
 }
 
 
        /* need to mark IPI's as IRQ_PER_CPU */
        irq_desc[cpu_ipi_resched_irq].status |= IRQ_PER_CPU;
+       set_irq_handler(cpu_ipi_resched_irq, handle_percpu_irq);
        irq_desc[cpu_ipi_call_irq].status |= IRQ_PER_CPU;
+       set_irq_handler(cpu_ipi_call_irq, handle_percpu_irq);
 }
 
 /*
 
        setup_irq_smtc(cpu_ipi_irq, &irq_ipi, (0x100 << MIPS_CPU_IPI_IRQ));
 
        irq_desc[cpu_ipi_irq].status |= IRQ_PER_CPU;
+       set_irq_handler(cpu_ipi_irq, handle_percpu_irq);
 }
 
 /*
 
        }
 
        for (i = 0; i <= LASATINT_END; i++)
-               set_irq_chip(i, &lasat_irq_type);
+               set_irq_chip_and_handler(i, &lasat_irq_type, handle_level_irq);
 }
 
        .mask = disable_atlas_irq,
        .mask_ack = disable_atlas_irq,
        .unmask = enable_atlas_irq,
+       .eoi = enable_atlas_irq,
        .end = end_atlas_irq,
 };
 
        atlas_hw0_icregs->intrsten = 0xffffffff;
 
        for (i = ATLAS_INT_BASE; i <= ATLAS_INT_END; i++)
-               set_irq_chip(i, &atlas_irq_type);
+               set_irq_chip_and_handler(i, &atlas_irq_type, handle_level_irq);
 }
 
 static struct irqaction atlasirq = {
 
           The effect is that the int remains disabled on the second cpu.
           Mark the interrupt with IRQ_PER_CPU to avoid any confusion */
        irq_desc[mips_cpu_timer_irq].status |= IRQ_PER_CPU;
+       set_irq_handler(mips_cpu_timer_irq, handle_percpu_irq);
 #endif
 
         /* to generate the first timer interrupt */
 
           on seperate cpu's the first one tries to handle the second interrupt.
           The effect is that the int remains disabled on the second cpu.
           Mark the interrupt with IRQ_PER_CPU to avoid any confusion */
-       irq_desc[mips_cpu_timer_irq].status |= IRQ_PER_CPU;
+       irq_desc[mips_cpu_timer_irq].flags |= IRQ_PER_CPU;
+       set_irq_handler(mips_cpu_timer_irq, handle_percpu_irq);
 #endif
 
        /* to generate the first timer interrupt */
 
        int i;
 
        for (i = CPCI_IRQ_BASE; i < (CPCI_IRQ_BASE + 8); i++)
-               set_irq_chip(i, &cpci_irq_type);
+               set_irq_chip_and_handler(i, &cpci_irq_type, handle_level_irq);
 }
 
 
 void uart_irq_init(void)
 {
-       set_irq_chip(80, &uart_irq_type);
-       set_irq_chip(81, &uart_irq_type);
+       set_irq_chip_and_handler(80, &uart_irq_type, handle_level_irq);
+       set_irq_chip_and_handler(81, &uart_irq_type, handle_level_irq);
 }
 
        int configPR;
 
        for (i = 0; i < PNX8550_INT_CP0_TOTINT; i++) {
-               set_irq_chip(i, &level_irq_type);
+               set_irq_chip_and_handler(i, &level_irq_type, handle_level_irq);
                mask_irq(i);    /* mask the irq just in case  */
        }
 
                /* mask/priority is still 0 so we will not get any
                 * interrupts until it is unmasked */
 
-               set_irq_chip(i, &level_irq_type);
+               set_irq_chip_and_handler(i, &level_irq_type, handle_level_irq);
        }
 
        /* Priority level 0 */
        /* Set int vector table address */
        PNX8550_GIC_VECTOR_0 = PNX8550_GIC_VECTOR_1 = 0;
 
-       set_irq_chip(MIPS_CPU_GIC_IRQ, &level_irq_type);
+       set_irq_chip_and_handler(MIPS_CPU_GIC_IRQ, &level_irq_type,
+                                handle_level_irq);
        setup_irq(MIPS_CPU_GIC_IRQ, &gic_action);
 
        /* init of Timer interrupts */
        for (i = PNX8550_INT_TIMER_MIN; i <= PNX8550_INT_TIMER_MAX; i++)
-               set_irq_chip(i, &level_irq_type);
+               set_irq_chip_and_handler(i, &level_irq_type, handle_level_irq);
 
        /* Stop Timer 1-3 */
        configPR = read_c0_config7();
        configPR |= 0x00000038;
        write_c0_config7(configPR);
 
-       set_irq_chip(MIPS_CPU_TIMER_IRQ, &level_irq_type);
+       set_irq_chip_and_handler(MIPS_CPU_TIMER_IRQ, &level_irq_type,
+                                handle_level_irq);
        setup_irq(MIPS_CPU_TIMER_IRQ, &timer_action);
 }
 
 
                else
                        handler         = &ip22_local3_irq_type;
 
-               set_irq_chip(i, handler);
+               set_irq_chip_and_handler(i, handler, handle_level_irq);
        }
 
        /* vector handler. this register the IRQ as non-sharable */
 
 
 void __devinit register_bridge_irq(unsigned int irq)
 {
-       set_irq_chip(irq, &bridge_irq_type);
+       set_irq_chip_and_handler(irq, &bridge_irq_type, handle_level_irq);
 }
 
 int __devinit request_bridge_irq(struct bridge_controller *bc)
 
        .mask           = disable_rt_irq,
        .mask_ack       = disable_rt_irq,
        .unmask         = enable_rt_irq,
+       .eoi            = enable_rt_irq,
        .end            = end_rt_irq,
 };
 
        if (irqno < 0)
                panic("Can't allocate interrupt number for timer interrupt");
 
-       set_irq_chip(irqno, &rt_irq_type);
+       set_irq_chip_and_handler(irqno, &rt_irq_type, handle_percpu_irq);
 
        /* over-write the handler, we use our own way */
        irq->handler = no_action;
 
                           TX4927_IRQ_CP0_BEG, TX4927_IRQ_CP0_END);
 
        for (i = TX4927_IRQ_CP0_BEG; i <= TX4927_IRQ_CP0_END; i++)
-               set_irq_chip(i, &tx4927_irq_cp0_type);
+               set_irq_chip_and_handler(i, &tx4927_irq_cp0_type,
+                                        handle_level_irq);
 }
 
 static void tx4927_irq_cp0_enable(unsigned int irq)
                           TX4927_IRQ_PIC_BEG, TX4927_IRQ_PIC_END);
 
        for (i = TX4927_IRQ_PIC_BEG; i <= TX4927_IRQ_PIC_END; i++)
-               set_irq_chip(i, &tx4927_irq_pic_type);
+               set_irq_chip_and_handler(i, &tx4927_irq_pic_type,
+                                        handle_level_irq);
 
        setup_irq(TX4927_IRQ_NEST_PIC_ON_CP0, &tx4927_irq_pic_action);
 
 
 
        for (i = TOSHIBA_RBTX4927_IRQ_IOC_BEG;
             i <= TOSHIBA_RBTX4927_IRQ_IOC_END; i++)
-               set_irq_chip(i, &toshiba_rbtx4927_irq_ioc_type);
+               set_irq_chip_and_handler(i, &toshiba_rbtx4927_irq_ioc_type,
+                                        handle_level_irq);
 
        setup_irq(TOSHIBA_RBTX4927_IRQ_NEST_IOC_ON_PIC,
                  &toshiba_rbtx4927_irq_ioc_action);
 
        int i;
 
        for (i = TX4938_IRQ_CP0_BEG; i <= TX4938_IRQ_CP0_END; i++)
-               set_irq_chip(i, &tx4938_irq_cp0_type);
+               set_irq_chip_and_handler(i, &tx4938_irq_cp0_type,
+                                        handle_level_irq);
 }
 
 static void
        int i;
 
        for (i = TX4938_IRQ_PIC_BEG; i <= TX4938_IRQ_PIC_END; i++)
-               set_irq_chip(i, &tx4938_irq_pic_type);
+               set_irq_chip_and_handler(i, &tx4938_irq_pic_type,
+                                        handle_level_irq);
 
        setup_irq(TX4938_IRQ_NEST_PIC_ON_CP0, &tx4938_irq_pic_action);
 
 
 
        for (i = TOSHIBA_RBTX4938_IRQ_IOC_BEG;
             i <= TOSHIBA_RBTX4938_IRQ_IOC_END; i++)
-               set_irq_chip(i, &toshiba_rbtx4938_irq_ioc_type);
+               set_irq_chip_and_handler(i, &toshiba_rbtx4938_irq_ioc_type,
+                                        handle_level_irq);
 
        setup_irq(RBTX4938_IRQ_IOCINT,
                  &toshiba_rbtx4938_irq_ioc_action);
 
        icu2_write(MGIUINTHREG, 0xffff);
 
        for (i = SYSINT1_IRQ_BASE; i <= SYSINT1_IRQ_LAST; i++)
-               set_irq_chip(i, &sysint1_irq_type);
+               set_irq_chip_and_handler(i, &sysint1_irq_type,
+                                        handle_level_irq);
 
        for (i = SYSINT2_IRQ_BASE; i <= SYSINT2_IRQ_LAST; i++)
-               set_irq_chip(i, &sysint2_irq_type);
+               set_irq_chip_and_handler(i, &sysint2_irq_type,
+                                        handle_level_irq);
 
        cascade_irq(INT0_IRQ, icu_get_irq);
        cascade_irq(INT1_IRQ, icu_get_irq);
 
 do {                                                                   \
        irq_enter();                                                    \
        __DO_IRQ_SMTC_HOOK();                                           \
-       __do_IRQ((irq));                                                \
+       generic_handle_irq(irq);                                        \
        irq_exit();                                                     \
 } while (0)