44e92e0364
Currently, the nds32 FPU dose not support the arithmetic of denormalized
number. When the nds32 FPU finds the result of the instruction is a
denormlized number, the nds32 FPU considers it to be an underflow condition
and rounds the result to an appropriate number. It may causes some loss
of precision. This commit proposes a solution to re-execute the
instruction by the FPU emulator to enhance the precision. To transfer
calculations from user space to kernel space, this feature will enable
the underflow exception trap by default. Enabling this feature may cause
some side effects:
1. Performance loss due to extra FPU exception
2. Need another scheme to control real underflow trap
A new parameter, UDF_trap, which is belong to FPU context is used
to control underflow trap.
User can configure this feature via CONFIG_SUPPORT_DENORMAL_ARITHMETIC
Signed-off-by: Vincent Chen <vincentc@andestech.com>
Acked-by: Greentime Hu <greentime@andestech.com>
Signed-off-by: Greentime Hu <greentime@andestech.com>
127 lines
3.1 KiB
C
127 lines
3.1 KiB
C
/* SPDX-License-Identifier: GPL-2.0 */
|
|
/* Copyright (C) 2005-2018 Andes Technology Corporation */
|
|
|
|
#ifndef __ASM_NDS32_FPU_H
|
|
#define __ASM_NDS32_FPU_H
|
|
|
|
#if IS_ENABLED(CONFIG_FPU)
|
|
#ifndef __ASSEMBLY__
|
|
#include <linux/sched/task_stack.h>
|
|
#include <linux/preempt.h>
|
|
#include <asm/ptrace.h>
|
|
|
|
extern bool has_fpu;
|
|
|
|
extern void save_fpu(struct task_struct *__tsk);
|
|
extern void load_fpu(const struct fpu_struct *fpregs);
|
|
extern bool do_fpu_exception(unsigned int subtype, struct pt_regs *regs);
|
|
extern int do_fpuemu(struct pt_regs *regs, struct fpu_struct *fpu);
|
|
|
|
#define test_tsk_fpu(regs) (regs->fucop_ctl & FUCOP_CTL_mskCP0EN)
|
|
|
|
/*
|
|
* Initially load the FPU with signalling NANS. This bit pattern
|
|
* has the property that no matter whether considered as single or as
|
|
* double precision, it still represents a signalling NAN.
|
|
*/
|
|
|
|
#define sNAN64 0xFFFFFFFFFFFFFFFFULL
|
|
#define sNAN32 0xFFFFFFFFUL
|
|
|
|
#if IS_ENABLED(CONFIG_SUPPORT_DENORMAL_ARITHMETIC)
|
|
/*
|
|
* Denormalized number is unsupported by nds32 FPU. Hence the operation
|
|
* is treated as underflow cases when the final result is a denormalized
|
|
* number. To enhance precision, underflow exception trap should be
|
|
* enabled by default and kerenl will re-execute it by fpu emulator
|
|
* when getting underflow exception.
|
|
*/
|
|
#define FPCSR_INIT FPCSR_mskUDFE
|
|
#else
|
|
#define FPCSR_INIT 0x0UL
|
|
#endif
|
|
|
|
extern const struct fpu_struct init_fpuregs;
|
|
|
|
static inline void disable_ptreg_fpu(struct pt_regs *regs)
|
|
{
|
|
regs->fucop_ctl &= ~FUCOP_CTL_mskCP0EN;
|
|
}
|
|
|
|
static inline void enable_ptreg_fpu(struct pt_regs *regs)
|
|
{
|
|
regs->fucop_ctl |= FUCOP_CTL_mskCP0EN;
|
|
}
|
|
|
|
static inline void enable_fpu(void)
|
|
{
|
|
unsigned long fucop_ctl;
|
|
|
|
fucop_ctl = __nds32__mfsr(NDS32_SR_FUCOP_CTL) | FUCOP_CTL_mskCP0EN;
|
|
__nds32__mtsr(fucop_ctl, NDS32_SR_FUCOP_CTL);
|
|
__nds32__isb();
|
|
}
|
|
|
|
static inline void disable_fpu(void)
|
|
{
|
|
unsigned long fucop_ctl;
|
|
|
|
fucop_ctl = __nds32__mfsr(NDS32_SR_FUCOP_CTL) & ~FUCOP_CTL_mskCP0EN;
|
|
__nds32__mtsr(fucop_ctl, NDS32_SR_FUCOP_CTL);
|
|
__nds32__isb();
|
|
}
|
|
|
|
static inline void lose_fpu(void)
|
|
{
|
|
preempt_disable();
|
|
#if IS_ENABLED(CONFIG_LAZY_FPU)
|
|
if (last_task_used_math == current) {
|
|
last_task_used_math = NULL;
|
|
#else
|
|
if (test_tsk_fpu(task_pt_regs(current))) {
|
|
#endif
|
|
save_fpu(current);
|
|
}
|
|
disable_ptreg_fpu(task_pt_regs(current));
|
|
preempt_enable();
|
|
}
|
|
|
|
static inline void own_fpu(void)
|
|
{
|
|
preempt_disable();
|
|
#if IS_ENABLED(CONFIG_LAZY_FPU)
|
|
if (last_task_used_math != current) {
|
|
if (last_task_used_math != NULL)
|
|
save_fpu(last_task_used_math);
|
|
load_fpu(¤t->thread.fpu);
|
|
last_task_used_math = current;
|
|
}
|
|
#else
|
|
if (!test_tsk_fpu(task_pt_regs(current))) {
|
|
load_fpu(¤t->thread.fpu);
|
|
}
|
|
#endif
|
|
enable_ptreg_fpu(task_pt_regs(current));
|
|
preempt_enable();
|
|
}
|
|
|
|
#if !IS_ENABLED(CONFIG_LAZY_FPU)
|
|
static inline void unlazy_fpu(struct task_struct *tsk)
|
|
{
|
|
preempt_disable();
|
|
if (test_tsk_fpu(task_pt_regs(tsk)))
|
|
save_fpu(tsk);
|
|
preempt_enable();
|
|
}
|
|
#endif /* !CONFIG_LAZY_FPU */
|
|
static inline void clear_fpu(struct pt_regs *regs)
|
|
{
|
|
preempt_disable();
|
|
if (test_tsk_fpu(regs))
|
|
disable_ptreg_fpu(regs);
|
|
preempt_enable();
|
|
}
|
|
#endif /* CONFIG_FPU */
|
|
#endif /* __ASSEMBLY__ */
|
|
#endif /* __ASM_NDS32_FPU_H */
|