powerpc: Add SPE/EFP math emulation for E500v1/v2 processors.

This patch add the handlers of SPE/EFP exceptions.
The code is used to emulate float point arithmetic,
when MSR(SPE) is enabled and receive EFP data interrupt or EFP round interrupt.

This patch has no conflict with or dependence on FP math-emu.

The code has been tested by TestFloat.

Now the code doesn't support SPE/EFP instructions emulation
(it won't be called when receive program interrupt),
but it could be easily added.

Signed-off-by: Liu Yu <yu.liu@freescale.com>
Signed-off-by: Kumar Gala <galak@kernel.crashing.org>

2 files changed, 59 insertions, 10 deletions

diff --git a/arch/powerpc/kernel/head_fsl_booke.S b/arch/powerpc/kernel/head_fsl_booke.S
index 590304c24dad..837e3cc9cc85 100644
--- a/arch/powerpc/kernel/head_fsl_booke.S
+++ b/arch/powerpc/kernel/head_fsl_booke.S
@@ -685,12 +685,13 @@ interrupt_base:
         /* SPE Floating Point Data */
 #ifdef CONFIG_SPE
         EXCEPTION(0x2030, SPEFloatingPointData, SPEFloatingPointException, EXC_XFER_EE);
-#else
-        EXCEPTION(0x2040, SPEFloatingPointData, unknown_exception, EXC_XFER_EE)
-#endif /* CONFIG_SPE */
 
         /* SPE Floating Point Round */
+        EXCEPTION(0x2050, SPEFloatingPointRound, SPEFloatingPointRoundException, EXC_XFER_EE)
+#else
+        EXCEPTION(0x2040, SPEFloatingPointData, unknown_exception, EXC_XFER_EE)
         EXCEPTION(0x2050, SPEFloatingPointRound, unknown_exception, EXC_XFER_EE)
+#endif /* CONFIG_SPE */
 
         /* Performance Monitor */
         EXCEPTION(0x2060, PerformanceMonitor, performance_monitor_exception, EXC_XFER_STD)
diff --git a/arch/powerpc/kernel/traps.c b/arch/powerpc/kernel/traps.c
index f5def6cf5cd6..5457e9575685 100644
--- a/arch/powerpc/kernel/traps.c
+++ b/arch/powerpc/kernel/traps.c
@@ -1160,37 +1160,85 @@ void CacheLockingException(struct pt_regs *regs, unsigned long address,
 #ifdef CONFIG_SPE
 void SPEFloatingPointException(struct pt_regs *regs)
 {
+        extern int do_spe_mathemu(struct pt_regs *regs);
         unsigned long spefscr;
         int fpexc_mode;
         int code = 0;
+        int err;
+
+        preempt_disable();
+        if (regs->msr & MSR_SPE)
+                giveup_spe(current);
+        preempt_enable();
 
         spefscr = current->thread.spefscr;
         fpexc_mode = current->thread.fpexc_mode;
 
-        /* Hardware does not neccessarily set sticky
-         * underflow/overflow/invalid flags */
         if ((spefscr & SPEFSCR_FOVF) && (fpexc_mode & PR_FP_EXC_OVF)) {
                 code = FPE_FLTOVF;
-                spefscr |= SPEFSCR_FOVFS;
         }
         else if ((spefscr & SPEFSCR_FUNF) && (fpexc_mode & PR_FP_EXC_UND)) {
                 code = FPE_FLTUND;
-                spefscr |= SPEFSCR_FUNFS;
         }
         else if ((spefscr & SPEFSCR_FDBZ) && (fpexc_mode & PR_FP_EXC_DIV))
                 code = FPE_FLTDIV;
         else if ((spefscr & SPEFSCR_FINV) && (fpexc_mode & PR_FP_EXC_INV)) {
                 code = FPE_FLTINV;
-                spefscr |= SPEFSCR_FINVS;
         }
         else if ((spefscr & (SPEFSCR_FG | SPEFSCR_FX)) && (fpexc_mode & PR_FP_EXC_RES))
                 code = FPE_FLTRES;
 
-        current->thread.spefscr = spefscr;
+        err = do_spe_mathemu(regs);
+        if (err == 0) {
+                regs->nip += 4;         /* skip emulated instruction */
+                emulate_single_step(regs);
+                return;
+        }
+
+        if (err == -EFAULT) {
+                /* got an error reading the instruction */
+                _exception(SIGSEGV, regs, SEGV_ACCERR, regs->nip);
+        } else if (err == -EINVAL) {
+                /* didn't recognize the instruction */
+                printk(KERN_ERR "unrecognized spe instruction "
+                       "in %s at %lx\n", current->comm, regs->nip);
+        } else {
+                _exception(SIGFPE, regs, code, regs->nip);
+        }
 
-        _exception(SIGFPE, regs, code, regs->nip);
         return;
 }
+
+void SPEFloatingPointRoundException(struct pt_regs *regs)
+{
+        extern int speround_handler(struct pt_regs *regs);
+        int err;
+
+        preempt_disable();
+        if (regs->msr & MSR_SPE)
+                giveup_spe(current);
+        preempt_enable();
+
+        regs->nip -= 4;
+        err = speround_handler(regs);
+        if (err == 0) {
+                regs->nip += 4;         /* skip emulated instruction */
+                emulate_single_step(regs);
+                return;
+        }
+
+        if (err == -EFAULT) {
+                /* got an error reading the instruction */
+                _exception(SIGSEGV, regs, SEGV_ACCERR, regs->nip);
+        } else if (err == -EINVAL) {
+                /* didn't recognize the instruction */
+                printk(KERN_ERR "unrecognized spe instruction "
+                       "in %s at %lx\n", current->comm, regs->nip);
+        } else {
+                _exception(SIGFPE, regs, 0, regs->nip);
+                return;
+        }
+}
 #endif
 
 /*