#define MAX_ILLEGAL_IRQS 16
 
 void
-handle_irq(int irq, struct pt_regs * regs)
+handle_irq(int irq)
 {      
-       struct pt_regs *old_regs;
        /* 
         * We ack quickly, we don't want the irq controller
         * thinking we're snobs just because some other CPU has
                return;
        }
 
-       old_regs = set_irq_regs(regs);
        irq_enter();
        /*
         * __do_IRQ() must be called with IPL_MAX. Note that we do not
        local_irq_disable();
        __do_IRQ(irq);
        irq_exit();
-       set_irq_regs(old_regs);
 }
 
 #endif
                break;
        case 1:
+               old_regs = set_irq_regs(regs);
 #ifdef CONFIG_SMP
          {
                long cpu;
                if (cpu != boot_cpuid) {
                        kstat_cpu(cpu).irqs[RTC_IRQ]++;
                } else {
-                       handle_irq(RTC_IRQ, regs);
+                       handle_irq(RTC_IRQ);
                }
          }
 #else
-               handle_irq(RTC_IRQ, regs);
+               handle_irq(RTC_IRQ);
 #endif
+               set_irq_regs(old_regs);
                return;
        case 2:
                alpha_mv.machine_check(vector, la_ptr, regs);
 
         */
        int j = *(vuip) IACK_SC;
        j &= 0xff;
-       handle_irq(j, get_irq_regs());
+       handle_irq(j);
 }
 #endif
 
 #if defined(CONFIG_ALPHA_GENERIC) || !defined(IACK_SC)
 void
-isa_no_iack_sc_device_interrupt(unsigned long vector, struct pt_regs *regs)
+isa_no_iack_sc_device_interrupt(unsigned long vector)
 {
        unsigned long pic;
 
        while (pic) {
                int j = ffz(~pic);
                pic &= pic - 1;
-               handle_irq(j, regs);
+               handle_irq(j);
        }
 }
 #endif
 
 #define RTC_IRQ    8
 
 extern void isa_device_interrupt(unsigned long);
-extern void isa_no_iack_sc_device_interrupt(unsigned long, struct pt_regs *);
+extern void isa_no_iack_sc_device_interrupt(unsigned long);
 extern void srm_device_interrupt(unsigned long);
 extern void pyxis_device_interrupt(unsigned long);
 
 extern struct hw_interrupt_type i8259a_irq_type;
 extern void init_i8259a_irqs(void);
 
-extern void handle_irq(int irq, struct pt_regs * regs);
+extern void handle_irq(int irq);
 
                if (i == 7)
                        isa_device_interrupt(vector);
                else
-                       handle_irq(16+i, get_irq_regs());
+                       handle_irq(16+i);
        }
 }
 
 
 srm_device_interrupt(unsigned long vector)
 {
        int irq = (vector - 0x800) >> 4;
-       handle_irq(irq, get_irq_regs());
+       handle_irq(irq);
 }
 
                if (i == 31) {
                        isa_device_interrupt(vector);
                } else {
-                       handle_irq(16 + i, get_irq_regs());
+                       handle_irq(16 + i);
                }
        }
 }
 
                if (i == 4) {
                        isa_device_interrupt(v);
                } else {
-                       handle_irq(16 + i, get_irq_regs());
+                       handle_irq(16 + i);
                }
        }
 }
 
                if (i == 55)
                        isa_device_interrupt(vector);
                else
-                       handle_irq(16 + i, get_irq_regs());
+                       handle_irq(16 + i);
 #if 0
                TSUNAMI_cchip->dir0.csr = 1UL << i; mb();
                tmp = TSUNAMI_cchip->dir0.csr;
        if (irq >= 32)
                irq -= 16;
 
-       handle_irq(irq, get_irq_regs());
+       handle_irq(irq);
 }
 
 static void 
         *
         * Eg IRQ 24 is DRIR bit 8, etc, etc
         */
-       handle_irq(irq, get_irq_regs());
+       handle_irq(irq);
 }
 
 static void __init
 
                if (i == 5) {
                        isa_device_interrupt(vector);
                } else {
-                       handle_irq(16 + i, get_irq_regs());
+                       handle_irq(16 + i);
                }
        }
 }
 
                 * despatch an interrupt if it's set.
                 */
 
-               if (intstatus & 8) handle_irq(16+3, get_irq_regs());
-               if (intstatus & 4) handle_irq(16+2, get_irq_regs());
-               if (intstatus & 2) handle_irq(16+1, get_irq_regs());
-               if (intstatus & 1) handle_irq(16+0, get_irq_regs());
+               if (intstatus & 8) handle_irq(16+3);
+               if (intstatus & 4) handle_irq(16+2);
+               if (intstatus & 2) handle_irq(16+1);
+               if (intstatus & 1) handle_irq(16+0);
        } else {
                isa_device_interrupt(vector);
        }
 eiger_srm_device_interrupt(unsigned long vector)
 {
        int irq = (vector - 0x800) >> 4;
-       handle_irq(irq, get_irq_regs());
+       handle_irq(irq);
 }
 
 static void __init
 
         }
 #endif
 
-       handle_irq(irq, get_irq_regs());
+       handle_irq(irq);
 }
 
 static void __init
 
        irq &= MARVEL_IRQ_VEC_IRQ_MASK;         /* not too many bits */
        irq |= pid << MARVEL_IRQ_VEC_PE_SHIFT;  /* merge the pid     */
 
-       handle_irq(irq, get_irq_regs());
+       handle_irq(irq);
 }
 
 static volatile unsigned long *
 
        if (irq >= 16)
                irq = irq + 8;
 
-       handle_irq(irq, get_irq_regs());
+       handle_irq(irq);
 }
 
 static void __init
 
                if (i < 16) {
                        isa_device_interrupt(vector);
                } else {
-                       handle_irq(i, get_irq_regs());
+                       handle_irq(i);
                }
        }
 }
 
                if (i < 16) {
                        isa_device_interrupt(vector);
                } else {
-                       handle_irq(i, get_irq_regs());
+                       handle_irq(i);
                }
        }
 }
        if (irq >= 16)
                irq = irq + 1;
 
-       handle_irq(irq, get_irq_regs());
+       handle_irq(irq);
 }
 
 static void __init
 
        /* Adjust by which hose it is from.  */
        irq -= ((irq + 16) >> 2) & 0x38;
 
-       handle_irq(irq, get_irq_regs());
+       handle_irq(irq);
 }
 
 static void __init
 
                i = ffz(~pld);
                pld &= pld - 1; /* clear least bit set */
                if (i == 20) {
-                       isa_no_iack_sc_device_interrupt(vector, get_irq_regs());
+                       isa_no_iack_sc_device_interrupt(vector);
                } else {
-                       handle_irq(16+i, get_irq_regs());
+                       handle_irq(16+i);
                }
        }
 }
 
        printk("%s: vector 0x%lx bit 0x%x irq 0x%x\n",
               __FUNCTION__, vector, bit, irq);
 #endif
-       handle_irq(irq, get_irq_regs());
+       handle_irq(irq);
 }
 
 static void __init
 
                 * despatch an interrupt if it's set.
                 */
 
-               if (intstatus & 8) handle_irq(16+3, get_irq_regs());
-               if (intstatus & 4) handle_irq(16+2, get_irq_regs());
-               if (intstatus & 2) handle_irq(16+1, get_irq_regs());
-               if (intstatus & 1) handle_irq(16+0, get_irq_regs());
+               if (intstatus & 8) handle_irq(16+3);
+               if (intstatus & 4) handle_irq(16+2);
+               if (intstatus & 2) handle_irq(16+1);
+               if (intstatus & 1) handle_irq(16+0);
        } else {
                isa_device_interrupt (vector);
        }
 takara_srm_device_interrupt(unsigned long vector)
 {
        int irq = (vector - 0x800) >> 4;
-       handle_irq(irq, get_irq_regs());
+       handle_irq(irq);
 }
 
 static void __init
 
        int irq;
 
        irq = (vector - 0x800) >> 4;
-       handle_irq(irq, get_irq_regs());
+       handle_irq(irq);
 }
 
 
 
         * bits 5-0:    irq in PCA
         */
 
-       handle_irq(irq, get_irq_regs());
+       handle_irq(irq);
        return;
 }