1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 | /* 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([31mCONFIG_FPU[0m) #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([31mCONFIG_SUPPORT_DENORMAL_ARITHMETIC[0m) /* * 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 | FPCSR_mskIEXE) #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([31mCONFIG_LAZY_FPU[0m) 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([31mCONFIG_LAZY_FPU[0m) 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([31mCONFIG_LAZY_FPU[0m) 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 */ |