1 /* 2 * arch/sh/math-emu/math.c 3 * 4 * Copyright (C) 2006 Takashi YOSHII <takasi-y@ops.dti.ne.jp> 5 * 6 * This file is subject to the terms and conditions of the GNU General Public 7 * License. See the file "COPYING" in the main directory of this archive 8 * for more details. 9 */ 10 #include <linux/kernel.h> 11 #include <linux/errno.h> 12 #include <linux/types.h> 13 #include <linux/sched/signal.h> 14 #include <linux/signal.h> 15 #include <linux/perf_event.h> 16 17 #include <linux/uaccess.h> 18 #include <asm/processor.h> 19 #include <asm/io.h> 20 21 #include "sfp-util.h" 22 #include <math-emu/soft-fp.h> 23 #include <math-emu/single.h> 24 #include <math-emu/double.h> 25 26 #define FPUL (fregs->fpul) 27 #define FPSCR (fregs->fpscr) 28 #define FPSCR_RM (FPSCR&3) 29 #define FPSCR_DN ((FPSCR>>18)&1) 30 #define FPSCR_PR ((FPSCR>>19)&1) 31 #define FPSCR_SZ ((FPSCR>>20)&1) 32 #define FPSCR_FR ((FPSCR>>21)&1) 33 #define FPSCR_MASK 0x003fffffUL 34 35 #define BANK(n) (n^(FPSCR_FR?16:0)) 36 #define FR ((unsigned long*)(fregs->fp_regs)) 37 #define FR0 (FR[BANK(0)]) 38 #define FRn (FR[BANK(n)]) 39 #define FRm (FR[BANK(m)]) 40 #define DR ((unsigned long long*)(fregs->fp_regs)) 41 #define DRn (DR[BANK(n)/2]) 42 #define DRm (DR[BANK(m)/2]) 43 44 #define XREG(n) (n^16) 45 #define XFn (FR[BANK(XREG(n))]) 46 #define XFm (FR[BANK(XREG(m))]) 47 #define XDn (DR[BANK(XREG(n))/2]) 48 #define XDm (DR[BANK(XREG(m))/2]) 49 50 #define R0 (regs->regs[0]) 51 #define Rn (regs->regs[n]) 52 #define Rm (regs->regs[m]) 53 54 #define WRITE(d,a) ({if(put_user(d, (typeof (d)*)a)) return -EFAULT;}) 55 #define READ(d,a) ({if(get_user(d, (typeof (d)*)a)) return -EFAULT;}) 56 57 #define PACK_S(r,f) FP_PACK_SP(&r,f) 58 #define UNPACK_S(f,r) FP_UNPACK_SP(f,&r) 59 #define PACK_D(r,f) \ 60 {u32 t[2]; FP_PACK_DP(t,f); ((u32*)&r)[0]=t[1]; ((u32*)&r)[1]=t[0];} 61 #define UNPACK_D(f,r) \ 62 {u32 t[2]; t[0]=((u32*)&r)[1]; t[1]=((u32*)&r)[0]; FP_UNPACK_DP(f,t);} 63 64 // 2 args instructions. 65 #define BOTH_PRmn(op,x) \ 66 FP_DECL_EX; if(FPSCR_PR) op(D,x,DRm,DRn); else op(S,x,FRm,FRn); 67 68 #define CMP_X(SZ,R,M,N) do{ \ 69 FP_DECL_##SZ(Fm); FP_DECL_##SZ(Fn); \ 70 UNPACK_##SZ(Fm, M); UNPACK_##SZ(Fn, N); \ 71 FP_CMP_##SZ(R, Fn, Fm, 2); }while(0) 72 #define EQ_X(SZ,R,M,N) do{ \ 73 FP_DECL_##SZ(Fm); FP_DECL_##SZ(Fn); \ 74 UNPACK_##SZ(Fm, M); UNPACK_##SZ(Fn, N); \ 75 FP_CMP_EQ_##SZ(R, Fn, Fm); }while(0) 76 #define CMP(OP) ({ int r; BOTH_PRmn(OP##_X,r); r; }) 77 78 static int 79 fcmp_gt(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, int m, int n) 80 { 81 if (CMP(CMP) > 0) 82 regs->sr |= 1; 83 else 84 regs->sr &= ~1; 85 86 return 0; 87 } 88 89 static int 90 fcmp_eq(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, int m, int n) 91 { 92 if (CMP(CMP /*EQ*/) == 0) 93 regs->sr |= 1; 94 else 95 regs->sr &= ~1; 96 return 0; 97 } 98 99 #define ARITH_X(SZ,OP,M,N) do{ \ 100 FP_DECL_##SZ(Fm); FP_DECL_##SZ(Fn); FP_DECL_##SZ(Fr); \ 101 UNPACK_##SZ(Fm, M); UNPACK_##SZ(Fn, N); \ 102 FP_##OP##_##SZ(Fr, Fn, Fm); \ 103 PACK_##SZ(N, Fr); }while(0) 104 105 static int 106 fadd(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, int m, int n) 107 { 108 BOTH_PRmn(ARITH_X, ADD); 109 return 0; 110 } 111 112 static int 113 fsub(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, int m, int n) 114 { 115 BOTH_PRmn(ARITH_X, SUB); 116 return 0; 117 } 118 119 static int 120 fmul(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, int m, int n) 121 { 122 BOTH_PRmn(ARITH_X, MUL); 123 return 0; 124 } 125 126 static int 127 fdiv(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, int m, int n) 128 { 129 BOTH_PRmn(ARITH_X, DIV); 130 return 0; 131 } 132 133 static int 134 fmac(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, int m, int n) 135 { 136 FP_DECL_EX; 137 FP_DECL_S(Fr); 138 FP_DECL_S(Ft); 139 FP_DECL_S(F0); 140 FP_DECL_S(Fm); 141 FP_DECL_S(Fn); 142 UNPACK_S(F0, FR0); 143 UNPACK_S(Fm, FRm); 144 UNPACK_S(Fn, FRn); 145 FP_MUL_S(Ft, Fm, F0); 146 FP_ADD_S(Fr, Fn, Ft); 147 PACK_S(FRn, Fr); 148 return 0; 149 } 150 151 // to process fmov's extension (odd n for DR access XD). 152 #define FMOV_EXT(x) if(x&1) x+=16-1 153 154 static int 155 fmov_idx_reg(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, int m, 156 int n) 157 { 158 if (FPSCR_SZ) { 159 FMOV_EXT(n); 160 READ(FRn, Rm + R0 + 4); 161 n++; 162 READ(FRn, Rm + R0); 163 } else { 164 READ(FRn, Rm + R0); 165 } 166 167 return 0; 168 } 169 170 static int 171 fmov_mem_reg(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, int m, 172 int n) 173 { 174 if (FPSCR_SZ) { 175 FMOV_EXT(n); 176 READ(FRn, Rm + 4); 177 n++; 178 READ(FRn, Rm); 179 } else { 180 READ(FRn, Rm); 181 } 182 183 return 0; 184 } 185 186 static int 187 fmov_inc_reg(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, int m, 188 int n) 189 { 190 if (FPSCR_SZ) { 191 FMOV_EXT(n); 192 READ(FRn, Rm + 4); 193 n++; 194 READ(FRn, Rm); 195 Rm += 8; 196 } else { 197 READ(FRn, Rm); 198 Rm += 4; 199 } 200 201 return 0; 202 } 203 204 static int 205 fmov_reg_idx(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, int m, 206 int n) 207 { 208 if (FPSCR_SZ) { 209 FMOV_EXT(m); 210 WRITE(FRm, Rn + R0 + 4); 211 m++; 212 WRITE(FRm, Rn + R0); 213 } else { 214 WRITE(FRm, Rn + R0); 215 } 216 217 return 0; 218 } 219 220 static int 221 fmov_reg_mem(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, int m, 222 int n) 223 { 224 if (FPSCR_SZ) { 225 FMOV_EXT(m); 226 WRITE(FRm, Rn + 4); 227 m++; 228 WRITE(FRm, Rn); 229 } else { 230 WRITE(FRm, Rn); 231 } 232 233 return 0; 234 } 235 236 static int 237 fmov_reg_dec(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, int m, 238 int n) 239 { 240 if (FPSCR_SZ) { 241 FMOV_EXT(m); 242 Rn -= 8; 243 WRITE(FRm, Rn + 4); 244 m++; 245 WRITE(FRm, Rn); 246 } else { 247 Rn -= 4; 248 WRITE(FRm, Rn); 249 } 250 251 return 0; 252 } 253 254 static int 255 fmov_reg_reg(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, int m, 256 int n) 257 { 258 if (FPSCR_SZ) { 259 FMOV_EXT(m); 260 FMOV_EXT(n); 261 DRn = DRm; 262 } else { 263 FRn = FRm; 264 } 265 266 return 0; 267 } 268 269 static int 270 fnop_mn(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, int m, int n) 271 { 272 return -EINVAL; 273 } 274 275 // 1 arg instructions. 276 #define NOTYETn(i) static int i(struct sh_fpu_soft_struct *fregs, int n) \ 277 { printk( #i " not yet done.\n"); return 0; } 278 279 NOTYETn(ftrv) 280 NOTYETn(fsqrt) 281 NOTYETn(fipr) 282 NOTYETn(fsca) 283 NOTYETn(fsrra) 284 285 #define EMU_FLOAT_X(SZ,N) do { \ 286 FP_DECL_##SZ(Fn); \ 287 FP_FROM_INT_##SZ(Fn, FPUL, 32, int); \ 288 PACK_##SZ(N, Fn); }while(0) 289 static int ffloat(struct sh_fpu_soft_struct *fregs, int n) 290 { 291 FP_DECL_EX; 292 293 if (FPSCR_PR) 294 EMU_FLOAT_X(D, DRn); 295 else 296 EMU_FLOAT_X(S, FRn); 297 298 return 0; 299 } 300 301 #define EMU_FTRC_X(SZ,N) do { \ 302 FP_DECL_##SZ(Fn); \ 303 UNPACK_##SZ(Fn, N); \ 304 FP_TO_INT_##SZ(FPUL, Fn, 32, 1); }while(0) 305 static int ftrc(struct sh_fpu_soft_struct *fregs, int n) 306 { 307 FP_DECL_EX; 308 309 if (FPSCR_PR) 310 EMU_FTRC_X(D, DRn); 311 else 312 EMU_FTRC_X(S, FRn); 313 314 return 0; 315 } 316 317 static int fcnvsd(struct sh_fpu_soft_struct *fregs, int n) 318 { 319 FP_DECL_EX; 320 FP_DECL_S(Fn); 321 FP_DECL_D(Fr); 322 UNPACK_S(Fn, FPUL); 323 FP_CONV(D, S, 2, 1, Fr, Fn); 324 PACK_D(DRn, Fr); 325 return 0; 326 } 327 328 static int fcnvds(struct sh_fpu_soft_struct *fregs, int n) 329 { 330 FP_DECL_EX; 331 FP_DECL_D(Fn); 332 FP_DECL_S(Fr); 333 UNPACK_D(Fn, DRn); 334 FP_CONV(S, D, 1, 2, Fr, Fn); 335 PACK_S(FPUL, Fr); 336 return 0; 337 } 338 339 static int fxchg(struct sh_fpu_soft_struct *fregs, int flag) 340 { 341 FPSCR ^= flag; 342 return 0; 343 } 344 345 static int fsts(struct sh_fpu_soft_struct *fregs, int n) 346 { 347 FRn = FPUL; 348 return 0; 349 } 350 351 static int flds(struct sh_fpu_soft_struct *fregs, int n) 352 { 353 FPUL = FRn; 354 return 0; 355 } 356 357 static int fneg(struct sh_fpu_soft_struct *fregs, int n) 358 { 359 FRn ^= (1 << (_FP_W_TYPE_SIZE - 1)); 360 return 0; 361 } 362 363 static int fabs(struct sh_fpu_soft_struct *fregs, int n) 364 { 365 FRn &= ~(1 << (_FP_W_TYPE_SIZE - 1)); 366 return 0; 367 } 368 369 static int fld0(struct sh_fpu_soft_struct *fregs, int n) 370 { 371 FRn = 0; 372 return 0; 373 } 374 375 static int fld1(struct sh_fpu_soft_struct *fregs, int n) 376 { 377 FRn = (_FP_EXPBIAS_S << (_FP_FRACBITS_S - 1)); 378 return 0; 379 } 380 381 static int fnop_n(struct sh_fpu_soft_struct *fregs, int n) 382 { 383 return -EINVAL; 384 } 385 386 /// Instruction decoders. 387 388 static int id_fxfd(struct sh_fpu_soft_struct *, int); 389 static int id_fnxd(struct sh_fpu_soft_struct *, struct pt_regs *, int, int); 390 391 static int (*fnxd[])(struct sh_fpu_soft_struct *, int) = { 392 fsts, flds, ffloat, ftrc, fneg, fabs, fsqrt, fsrra, 393 fld0, fld1, fcnvsd, fcnvds, fnop_n, fnop_n, fipr, id_fxfd 394 }; 395 396 static int (*fnmx[])(struct sh_fpu_soft_struct *, struct pt_regs *, int, int) = { 397 fadd, fsub, fmul, fdiv, fcmp_eq, fcmp_gt, fmov_idx_reg, fmov_reg_idx, 398 fmov_mem_reg, fmov_inc_reg, fmov_reg_mem, fmov_reg_dec, 399 fmov_reg_reg, id_fnxd, fmac, fnop_mn}; 400 401 static int id_fxfd(struct sh_fpu_soft_struct *fregs, int x) 402 { 403 const int flag[] = { FPSCR_SZ, FPSCR_PR, FPSCR_FR, 0 }; 404 switch (x & 3) { 405 case 3: 406 fxchg(fregs, flag[x >> 2]); 407 break; 408 case 1: 409 ftrv(fregs, x - 1); 410 break; 411 default: 412 fsca(fregs, x); 413 } 414 return 0; 415 } 416 417 static int 418 id_fnxd(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, int x, int n) 419 { 420 return (fnxd[x])(fregs, n); 421 } 422 423 static int 424 id_fnmx(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, u16 code) 425 { 426 int n = (code >> 8) & 0xf, m = (code >> 4) & 0xf, x = code & 0xf; 427 return (fnmx[x])(fregs, regs, m, n); 428 } 429 430 static int 431 id_sys(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, u16 code) 432 { 433 int n = ((code >> 8) & 0xf); 434 unsigned long *reg = (code & 0x0010) ? &FPUL : &FPSCR; 435 436 switch (code & 0xf0ff) { 437 case 0x005a: 438 case 0x006a: 439 Rn = *reg; 440 break; 441 case 0x405a: 442 case 0x406a: 443 *reg = Rn; 444 break; 445 case 0x4052: 446 case 0x4062: 447 Rn -= 4; 448 WRITE(*reg, Rn); 449 break; 450 case 0x4056: 451 case 0x4066: 452 READ(*reg, Rn); 453 Rn += 4; 454 break; 455 default: 456 return -EINVAL; 457 } 458 459 return 0; 460 } 461 462 static int fpu_emulate(u16 code, struct sh_fpu_soft_struct *fregs, struct pt_regs *regs) 463 { 464 if ((code & 0xf000) == 0xf000) 465 return id_fnmx(fregs, regs, code); 466 else 467 return id_sys(fregs, regs, code); 468 } 469 470 /** 471 * denormal_to_double - Given denormalized float number, 472 * store double float 473 * 474 * @fpu: Pointer to sh_fpu_soft structure 475 * @n: Index to FP register 476 */ 477 static void denormal_to_double(struct sh_fpu_soft_struct *fpu, int n) 478 { 479 unsigned long du, dl; 480 unsigned long x = fpu->fpul; 481 int exp = 1023 - 126; 482 483 if (x != 0 && (x & 0x7f800000) == 0) { 484 du = (x & 0x80000000); 485 while ((x & 0x00800000) == 0) { 486 x <<= 1; 487 exp--; 488 } 489 x &= 0x007fffff; 490 du |= (exp << 20) | (x >> 3); 491 dl = x << 29; 492 493 fpu->fp_regs[n] = du; 494 fpu->fp_regs[n+1] = dl; 495 } 496 } 497 498 /** 499 * ieee_fpe_handler - Handle denormalized number exception 500 * 501 * @regs: Pointer to register structure 502 * 503 * Returns 1 when it's handled (should not cause exception). 504 */ 505 static int ieee_fpe_handler(struct pt_regs *regs) 506 { 507 unsigned short insn = *(unsigned short *)regs->pc; 508 unsigned short finsn; 509 unsigned long nextpc; 510 siginfo_t info; 511 int nib[4] = { 512 (insn >> 12) & 0xf, 513 (insn >> 8) & 0xf, 514 (insn >> 4) & 0xf, 515 insn & 0xf}; 516 517 if (nib[0] == 0xb || 518 (nib[0] == 0x4 && nib[2] == 0x0 && nib[3] == 0xb)) /* bsr & jsr */ 519 regs->pr = regs->pc + 4; 520 521 if (nib[0] == 0xa || nib[0] == 0xb) { /* bra & bsr */ 522 nextpc = regs->pc + 4 + ((short) ((insn & 0xfff) << 4) >> 3); 523 finsn = *(unsigned short *) (regs->pc + 2); 524 } else if (nib[0] == 0x8 && nib[1] == 0xd) { /* bt/s */ 525 if (regs->sr & 1) 526 nextpc = regs->pc + 4 + ((char) (insn & 0xff) << 1); 527 else 528 nextpc = regs->pc + 4; 529 finsn = *(unsigned short *) (regs->pc + 2); 530 } else if (nib[0] == 0x8 && nib[1] == 0xf) { /* bf/s */ 531 if (regs->sr & 1) 532 nextpc = regs->pc + 4; 533 else 534 nextpc = regs->pc + 4 + ((char) (insn & 0xff) << 1); 535 finsn = *(unsigned short *) (regs->pc + 2); 536 } else if (nib[0] == 0x4 && nib[3] == 0xb && 537 (nib[2] == 0x0 || nib[2] == 0x2)) { /* jmp & jsr */ 538 nextpc = regs->regs[nib[1]]; 539 finsn = *(unsigned short *) (regs->pc + 2); 540 } else if (nib[0] == 0x0 && nib[3] == 0x3 && 541 (nib[2] == 0x0 || nib[2] == 0x2)) { /* braf & bsrf */ 542 nextpc = regs->pc + 4 + regs->regs[nib[1]]; 543 finsn = *(unsigned short *) (regs->pc + 2); 544 } else if (insn == 0x000b) { /* rts */ 545 nextpc = regs->pr; 546 finsn = *(unsigned short *) (regs->pc + 2); 547 } else { 548 nextpc = regs->pc + 2; 549 finsn = insn; 550 } 551 552 if ((finsn & 0xf1ff) == 0xf0ad) { /* fcnvsd */ 553 struct task_struct *tsk = current; 554 555 if ((tsk->thread.xstate->softfpu.fpscr & (1 << 17))) { 556 /* FPU error */ 557 denormal_to_double (&tsk->thread.xstate->softfpu, 558 (finsn >> 8) & 0xf); 559 tsk->thread.xstate->softfpu.fpscr &= 560 ~(FPSCR_CAUSE_MASK | FPSCR_FLAG_MASK); 561 task_thread_info(tsk)->status |= TS_USEDFPU; 562 } else { 563 info.si_signo = SIGFPE; 564 info.si_errno = 0; 565 info.si_code = FPE_FLTINV; 566 info.si_addr = (void __user *)regs->pc; 567 force_sig_info(SIGFPE, &info, tsk); 568 } 569 570 regs->pc = nextpc; 571 return 1; 572 } 573 574 return 0; 575 } 576 577 /** 578 * fpu_init - Initialize FPU registers 579 * @fpu: Pointer to software emulated FPU registers. 580 */ 581 static void fpu_init(struct sh_fpu_soft_struct *fpu) 582 { 583 int i; 584 585 fpu->fpscr = FPSCR_INIT; 586 fpu->fpul = 0; 587 588 for (i = 0; i < 16; i++) { 589 fpu->fp_regs[i] = 0; 590 fpu->xfp_regs[i]= 0; 591 } 592 } 593 594 /** 595 * do_fpu_inst - Handle reserved instructions for FPU emulation 596 * @inst: instruction code. 597 * @regs: registers on stack. 598 */ 599 int do_fpu_inst(unsigned short inst, struct pt_regs *regs) 600 { 601 struct task_struct *tsk = current; 602 struct sh_fpu_soft_struct *fpu = &(tsk->thread.xstate->softfpu); 603 604 perf_sw_event(PERF_COUNT_SW_EMULATION_FAULTS, 1, regs, 0); 605 606 if (!(task_thread_info(tsk)->status & TS_USEDFPU)) { 607 /* initialize once. */ 608 fpu_init(fpu); 609 task_thread_info(tsk)->status |= TS_USEDFPU; 610 } 611 612 return fpu_emulate(inst, fpu, regs); 613 } 614