do set_irq_regs() in caller, kill pt_regs argument.
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
 }
 
 void
-apecs_machine_check(unsigned long vector, unsigned long la_ptr,
-                   struct pt_regs * regs)
+apecs_machine_check(unsigned long vector, unsigned long la_ptr)
 {
        struct el_common *mchk_header;
        struct el_apecs_procdata *mchk_procdata;
        wrmces(0x7);            /* reset machine check pending flag */
        mb();
 
-       process_mcheck_info(vector, la_ptr, regs, "APECS",
+       process_mcheck_info(vector, la_ptr, "APECS",
                            (mcheck_expected(0)
                             && (mchk_sysdata->epic_dcsr & 0x0c00UL)));
 }
 
 }
 
 void
-cia_machine_check(unsigned long vector, unsigned long la_ptr,
-                 struct pt_regs * regs)
+cia_machine_check(unsigned long vector, unsigned long la_ptr)
 {
        int expected;
 
        expected = mcheck_expected(0);
        if (!expected && vector == 0x660)
                expected = cia_decode_mchk(la_ptr);
-       process_mcheck_info(vector, la_ptr, regs, "CIA", expected);
+       process_mcheck_info(vector, la_ptr, "CIA", expected);
 }
 
 #include <linux/tty.h>
 
 #include <asm/ptrace.h>
+#include <asm/irq_regs.h>
 #include <asm/smp.h>
 
 #include "proto.h"
 }
 
 void
-lca_machine_check(unsigned long vector, unsigned long la_ptr,
-                 struct pt_regs *regs)
+lca_machine_check(unsigned long vector, unsigned long la_ptr)
 {
        const char * reason;
        union el_lca el;
        wrmces(rdmces());       /* reset machine check pending flag */
 
        printk(KERN_CRIT "LCA machine check: vector=%#lx pc=%#lx code=%#x\n",
-              vector, regs->pc, (unsigned int) el.c->code);
+              vector, get_irq_regs()->pc, (unsigned int) el.c->code);
 
        /*
         * The first quadword after the common header always seems to
 
 }
 
 void
-mcpcia_machine_check(unsigned long vector, unsigned long la_ptr,
-                    struct pt_regs * regs)
+mcpcia_machine_check(unsigned long vector, unsigned long la_ptr)
 {
        struct el_common *mchk_header;
        struct el_MCPCIA_uncorrected_frame_mcheck *mchk_logout;
        wrmces(0x7);
        mb();
 
-       process_mcheck_info(vector, la_ptr, regs, "MCPCIA", expected != 0);
+       process_mcheck_info(vector, la_ptr, "MCPCIA", expected != 0);
        if (!expected && vector != 0x620 && vector != 0x630) {
                mcpcia_print_uncorrectable(mchk_logout);
                mcpcia_print_system_area(la_ptr);
 
 }
 
 void
-polaris_machine_check(unsigned long vector, unsigned long la_ptr,
-                     struct pt_regs * regs)
+polaris_machine_check(unsigned long vector, unsigned long la_ptr)
 {
        /* Clear the error before any reporting.  */
        mb();
        wrmces(0x7);
        mb();
 
-       process_mcheck_info(vector, la_ptr, regs, "POLARIS",
+       process_mcheck_info(vector, la_ptr, "POLARIS",
                            mcheck_expected(0));
 }
 
  * Hence all the taken/expected/any_expected/last_taken stuff...
  */
 void
-t2_machine_check(unsigned long vector, unsigned long la_ptr,
-                struct pt_regs * regs)
+t2_machine_check(unsigned long vector, unsigned long la_ptr)
 {
        int cpu = smp_processor_id();
 #ifdef CONFIG_VERBOSE_MCHECK
        }
 #endif
 
-       process_mcheck_info(vector, la_ptr, regs, "T2", mcheck_expected(cpu));
+       process_mcheck_info(vector, la_ptr, "T2", mcheck_expected(cpu));
 }
 
 }
 
 void
-tsunami_machine_check(unsigned long vector, unsigned long la_ptr,
-                     struct pt_regs * regs)
+tsunami_machine_check(unsigned long vector, unsigned long la_ptr)
 {
        /* Clear error before any reporting.  */
        mb();
        wrmces(0x7);
        mb();
 
-       process_mcheck_info(vector, la_ptr, regs, "TSUNAMI",
+       process_mcheck_info(vector, la_ptr, "TSUNAMI",
                            mcheck_expected(smp_processor_id()));
 }
 
 }
 
 void
-wildfire_machine_check(unsigned long vector, unsigned long la_ptr,
-                      struct pt_regs * regs)
+wildfire_machine_check(unsigned long vector, unsigned long la_ptr)
 {
        mb();
        mb();  /* magic */
        wrmces(0x7);
        mb();
 
-       process_mcheck_info(vector, la_ptr, regs, "WILDFIRE",
+       process_mcheck_info(vector, la_ptr, "WILDFIRE",
                            mcheck_expected(smp_processor_id()));
 }
 
 
 #include <linux/sched.h>
 
 #include <asm/io.h>
+#include <asm/irq_regs.h>
 #include <asm/hwrpb.h>
 #include <asm/smp.h>
 #include <asm/err_common.h>
 }
 
 void
-ev6_machine_check(u64 vector, u64 la_ptr, struct pt_regs *regs)
+ev6_machine_check(u64 vector, u64 la_ptr)
 {
        struct el_common *mchk_header = (struct el_common *)la_ptr;
 
                       (unsigned int)vector, (int)smp_processor_id());
                
                ev6_process_logout_frame(mchk_header, 1);
-               dik_show_regs(regs, NULL);
+               dik_show_regs(get_irq_regs(), NULL);
 
                err_print_prefix = saved_err_prefix;
        }
 
 }
 
 void
-ev7_machine_check(u64 vector, u64 la_ptr, struct pt_regs *regs)
+ev7_machine_check(u64 vector, u64 la_ptr)
 {
        struct el_subpacket *el_ptr = (struct el_subpacket *)la_ptr;
        char *saved_err_prefix = err_print_prefix;
 
 ev7_collect_logout_frame_subpackets(struct el_subpacket *,
                                    struct ev7_lf_subpackets *);
 extern void ev7_register_error_handlers(void);
-extern void ev7_machine_check(u64, u64, struct pt_regs *);
+extern void ev7_machine_check(u64, u64);
 
 /*
  * err_ev6.c
  */
 extern void ev6_register_error_handlers(void);
 extern int ev6_process_logout_frame(struct el_common *, int);
-extern void ev6_machine_check(u64, u64, struct pt_regs *);
+extern void ev6_machine_check(u64, u64);
 
 /*
  * err_marvel.c
  */
-extern void marvel_machine_check(u64, u64, struct pt_regs *);
+extern void marvel_machine_check(u64, u64);
 extern void marvel_register_error_handlers(void);
 
 /*
  * err_titan.c
  */
 extern int titan_process_logout_frame(struct el_common *, int);
-extern void titan_machine_check(u64, u64, struct pt_regs *);
+extern void titan_machine_check(u64, u64);
 extern void titan_register_error_handlers(void);
 extern int privateer_process_logout_frame(struct el_common *, int);
-extern void privateer_machine_check(u64, u64, struct pt_regs *);
+extern void privateer_machine_check(u64, u64);
 
 }
 
 void
-marvel_machine_check(u64 vector, u64 la_ptr, struct pt_regs *regs)
+marvel_machine_check(u64 vector, u64 la_ptr)
 {
        struct el_subpacket *el_ptr = (struct el_subpacket *)la_ptr;
        int (*process_frame)(struct ev7_lf_subpackets *, int) = NULL;
 
        default:
                /* Don't know it - pass it up.  */
-               ev7_machine_check(vector, la_ptr, regs);
+               ev7_machine_check(vector, la_ptr);
                return;
        }       
 
 
 }
 
 void
-titan_machine_check(u64 vector, u64 la_ptr, struct pt_regs *regs)
+titan_machine_check(u64 vector, u64 la_ptr)
 {
        struct el_common *mchk_header = (struct el_common *)la_ptr;
        struct el_TITAN_sysdata_mcheck *tmchk =
         * Only handle system errors here 
         */
        if ((vector != SCB_Q_SYSMCHK) && (vector != SCB_Q_SYSERR)) {
-               ev6_machine_check(vector, la_ptr, regs);
+               ev6_machine_check(vector, la_ptr);
                return;
        }
 
 #ifdef CONFIG_VERBOSE_MCHECK
                titan_process_logout_frame(mchk_header, alpha_verbose_mcheck);
                if (alpha_verbose_mcheck)
-                       dik_show_regs(regs, NULL);
+                       dik_show_regs(get_irq_regs(), NULL);
 #endif /* CONFIG_VERBOSE_MCHECK */
 
                err_print_prefix = saved_err_prefix;
                 * machine checks to interrupts
                 */
                irqmask = tmchk->c_dirx & TITAN_MCHECK_INTERRUPT_MASK;
-               titan_dispatch_irqs(irqmask, regs);
+               titan_dispatch_irqs(irqmask, get_irq_regs());
        }       
 
 
 }
 
 void
-privateer_machine_check(u64 vector, u64 la_ptr, struct pt_regs *regs)
+privateer_machine_check(u64 vector, u64 la_ptr)
 {
        struct el_common *mchk_header = (struct el_common *)la_ptr;
        struct el_TITAN_sysdata_mcheck *tmchk =
         * Only handle system events here.
         */
        if (vector != SCB_Q_SYSEVENT) 
-               return titan_machine_check(vector, la_ptr, regs);
+               return titan_machine_check(vector, la_ptr);
 
        /*
         * Report the event - System Events should be reported even if no
        /*
         * Dispatch the interrupt(s).
         */
-       titan_dispatch_irqs(irqmask, regs);
+       titan_dispatch_irqs(irqmask, get_irq_regs());
 
        /* 
         * Release the logout frame.
 
                set_irq_regs(old_regs);
                return;
        case 2:
-               alpha_mv.machine_check(vector, la_ptr, regs);
+               old_regs = set_irq_regs(regs);
+               alpha_mv.machine_check(vector, la_ptr);
+               set_irq_regs(old_regs);
                return;
        case 3:
                old_regs = set_irq_regs(regs);
 
 void
 process_mcheck_info(unsigned long vector, unsigned long la_ptr,
-                   struct pt_regs *regs, const char *machine,
-                   int expected)
+                   const char *machine, int expected)
 {
        struct el_common *mchk_header;
        const char *reason;
        mchk_header = (struct el_common *)la_ptr;
 
        printk(KERN_CRIT "%s machine check: vector=0x%lx pc=0x%lx code=0x%x\n",
-              machine, vector, regs->pc, mchk_header->code);
+              machine, vector, get_irq_regs()->pc, mchk_header->code);
 
        switch (mchk_header->code) {
        /* Machine check reasons.  Defined according to PALcode sources.  */
        printk(KERN_CRIT "machine check type: %s%s\n",
               reason, mchk_header->retry ? " (retryable)" : "");
 
-       dik_show_regs(regs, NULL);
+       dik_show_regs(get_irq_regs(), NULL);
 
 #ifdef CONFIG_VERBOSE_MCHECK
        if (alpha_verbose_mcheck > 1) {
 
 extern struct pci_ops apecs_pci_ops;
 extern void apecs_init_arch(void);
 extern void apecs_pci_clr_err(void);
-extern void apecs_machine_check(u64, u64, struct pt_regs *);
+extern void apecs_machine_check(u64, u64);
 extern void apecs_pci_tbi(struct pci_controller *, dma_addr_t, dma_addr_t);
 
 /* core_cia.c */
 extern void cia_init_arch(void);
 extern void pyxis_init_arch(void);
 extern void cia_kill_arch(int);
-extern void cia_machine_check(u64, u64, struct pt_regs *);
+extern void cia_machine_check(u64, u64);
 extern void cia_pci_tbi(struct pci_controller *, dma_addr_t, dma_addr_t);
 
 /* core_irongate.c */
 /* core_lca.c */
 extern struct pci_ops lca_pci_ops;
 extern void lca_init_arch(void);
-extern void lca_machine_check(u64, u64, struct pt_regs *);
+extern void lca_machine_check(u64, u64);
 extern void lca_pci_tbi(struct pci_controller *, dma_addr_t, dma_addr_t);
 
 /* core_marvel.c */
 extern struct pci_ops marvel_pci_ops;
 extern void marvel_init_arch(void);
 extern void marvel_kill_arch(int);
-extern void marvel_machine_check(u64, u64, struct pt_regs *);
+extern void marvel_machine_check(u64, u64);
 extern void marvel_pci_tbi(struct pci_controller *, dma_addr_t, dma_addr_t);
 extern int marvel_pa_to_nid(unsigned long);
 extern int marvel_cpuid_to_nid(int);
 extern struct pci_ops mcpcia_pci_ops;
 extern void mcpcia_init_arch(void);
 extern void mcpcia_init_hoses(void);
-extern void mcpcia_machine_check(u64, u64, struct pt_regs *);
+extern void mcpcia_machine_check(u64, u64);
 extern void mcpcia_pci_tbi(struct pci_controller *, dma_addr_t, dma_addr_t);
 
 /* core_polaris.c */
 extern int polaris_read_config_dword(struct pci_dev *, int, u32 *);
 extern int polaris_write_config_dword(struct pci_dev *, int, u32);
 extern void polaris_init_arch(void);
-extern void polaris_machine_check(u64, u64, struct pt_regs *);
+extern void polaris_machine_check(u64, u64);
 #define polaris_pci_tbi ((void *)0)
 
 /* core_t2.c */
 extern struct pci_ops t2_pci_ops;
 extern void t2_init_arch(void);
 extern void t2_kill_arch(int);
-extern void t2_machine_check(u64, u64, struct pt_regs *);
+extern void t2_machine_check(u64, u64);
 extern void t2_pci_tbi(struct pci_controller *, dma_addr_t, dma_addr_t);
 
 /* core_titan.c */
 extern struct pci_ops titan_pci_ops;
 extern void titan_init_arch(void);
 extern void titan_kill_arch(int);
-extern void titan_machine_check(u64, u64, struct pt_regs *);
+extern void titan_machine_check(u64, u64);
 extern void titan_pci_tbi(struct pci_controller *, dma_addr_t, dma_addr_t);
 extern struct _alpha_agp_info *titan_agp_info(void);
 
 extern struct pci_ops tsunami_pci_ops;
 extern void tsunami_init_arch(void);
 extern void tsunami_kill_arch(int);
-extern void tsunami_machine_check(u64, u64, struct pt_regs *);
+extern void tsunami_machine_check(u64, u64);
 extern void tsunami_pci_tbi(struct pci_controller *, dma_addr_t, dma_addr_t);
 
 /* core_wildfire.c */
 extern struct pci_ops wildfire_pci_ops;
 extern void wildfire_init_arch(void);
 extern void wildfire_kill_arch(int);
-extern void wildfire_machine_check(u64, u64, struct pt_regs *);
+extern void wildfire_machine_check(u64, u64);
 extern void wildfire_pci_tbi(struct pci_controller *, dma_addr_t, dma_addr_t);
 extern int wildfire_pa_to_nid(unsigned long);
 extern int wildfire_cpuid_to_nid(int);
 #endif
 
 extern void process_mcheck_info(unsigned long vector, unsigned long la_ptr,
-                               struct pt_regs *regs, const char *machine,
-                               int expected);
+                               const char *machine, int expected);
 
 }
 
 static void
-jensen_machine_check (u64 vector, u64 la, struct pt_regs *regs)
+jensen_machine_check (u64 vector, u64 la)
 {
        printk(KERN_CRIT "Machine check\n");
 }
 
 
 #if defined(CONFIG_ALPHA_GENERIC) || !defined(CONFIG_ALPHA_PRIMO)
 static void
-mikasa_apecs_machine_check(unsigned long vector, unsigned long la_ptr,
-                          struct pt_regs * regs)
+mikasa_apecs_machine_check(unsigned long vector, unsigned long la_ptr)
 {
 #define MCHK_NO_DEVSEL 0x205U
 #define MCHK_NO_TABT 0x204U
        mb();
 
        code = mchk_header->code;
-       process_mcheck_info(vector, la_ptr, regs, "MIKASA APECS",
+       process_mcheck_info(vector, la_ptr, "MIKASA APECS",
                            (mcheck_expected(0)
                             && (code == MCHK_NO_DEVSEL
                                 || code == MCHK_NO_TABT)));
 
    in the system.  They are analysed separately but all starts here.  */
 
 void
-nautilus_machine_check(unsigned long vector, unsigned long la_ptr,
-                      struct pt_regs *regs)
+nautilus_machine_check(unsigned long vector, unsigned long la_ptr)
 {
        char *mchk_class;
 
        else if (vector == SCB_Q_SYSMCHK)
                mchk_class = "Fatal";
        else {
-               ev6_machine_check(vector, la_ptr, regs);
+               ev6_machine_check(vector, la_ptr);
                return;
        }
 
                         "[%s System Machine Check (NMI)]\n",
               vector, mchk_class);
 
-       naut_sys_machine_check(vector, la_ptr, regs);
+       naut_sys_machine_check(vector, la_ptr, get_irq_regs());
 
        /* Tell the PALcode to clear the machine check */
        draina();
 
 
 #if defined(CONFIG_ALPHA_GENERIC) || !defined(CONFIG_ALPHA_PRIMO)
 static void
-noritake_apecs_machine_check(unsigned long vector, unsigned long la_ptr,
-                            struct pt_regs * regs)
+noritake_apecs_machine_check(unsigned long vector, unsigned long la_ptr)
 {
 #define MCHK_NO_DEVSEL 0x205U
 #define MCHK_NO_TABT 0x204U
         mb();
 
         code = mchk_header->code;
-        process_mcheck_info(vector, la_ptr, regs, "NORITAKE APECS",
+        process_mcheck_info(vector, la_ptr, "NORITAKE APECS",
                             (mcheck_expected(0)
                              && (code == MCHK_NO_DEVSEL
                                  || code == MCHK_NO_TABT)));
 
 
 struct task_struct;
 struct mm_struct;
-struct pt_regs;
 struct vm_area_struct;
 struct linux_hose_info;
 struct pci_dev;
        void (*update_irq_hw)(unsigned long, unsigned long, int);
        void (*ack_irq)(unsigned long);
        void (*device_interrupt)(unsigned long vector);
-       void (*machine_check)(u64 vector, u64 la, struct pt_regs *regs);
+       void (*machine_check)(u64 vector, u64 la);
 
        void (*smp_callin)(void);
        void (*init_arch)(void);