sys/src/9/bcm/vfp3.c

   1 /*
   2  * VFPv2 or VFPv3 floating point unit
   3  */
   4 #include "u.h"
   5 #include "../port/lib.h"
   6 #include "mem.h"
   7 #include "dat.h"
   8 #include "fns.h"
   9 #include "ureg.h"
  10 #include "arm.h"
  11
  12 /* subarchitecture code in m->havefp */
  13 enum {
  14         VFPv2   = 2,
  15         VFPv3   = 3,
  16 };
  17
  18 /* fp control regs.  most are read-only */
  19 enum {
  20         Fpsid = 0,
  21         Fpscr = 1,                      /* rw */
  22         Mvfr1 = 6,
  23         Mvfr0 = 7,
  24         Fpexc = 8,                      /* rw */
  25         Fpinst= 9,                      /* optional, for exceptions */
  26         Fpinst2=10,
  27 };
  28 enum {
  29         /* Fpexc bits */
  30         Fpex =          1u << 31,
  31         Fpenabled =     1 << 30,
  32         Fpdex =         1 << 29,        /* defined synch exception */
  33 //      Fp2v =          1 << 28,        /* Fpinst2 reg is valid */
  34 //      Fpvv =          1 << 27,        /* if Fpdex, vecitr is valid */
  35 //      Fptfv =         1 << 26,        /* trapped fault is valid */
  36 //      Fpvecitr =      MASK(3) << 8,
  37         /* FSR bits appear here */
  38         Fpmbc =         Fpdex,          /* bits exception handler must clear */
  39
  40         /* Fpscr bits; see u.h for more */
  41         Stride =        MASK(2) << 20,
  42         Len =           MASK(3) << 16,
  43         Dn=             1 << 25,
  44         Fz=             1 << 24,
  45         /* trap exception enables (not allowed in vfp3) */
  46         FPIDNRM =       1 << 15,        /* input denormal */
  47         Alltraps = FPIDNRM | FPINEX | FPUNFL | FPOVFL | FPZDIV | FPINVAL,
  48         /* pending exceptions */
  49         FPAIDNRM =      1 << 7,         /* input denormal */
  50         Allexc = FPAIDNRM | FPAINEX | FPAUNFL | FPAOVFL | FPAZDIV | FPAINVAL,
  51         /* condition codes */
  52         Allcc =         MASK(4) << 28,
  53 };
  54 enum {
  55         /* CpCPaccess bits */
  56         Cpaccnosimd =   1u << 31,
  57         Cpaccd16 =      1 << 30,
  58 };
  59
  60 static char *
  61 subarch(int impl, uint sa)
  62 {
  63         static char *armarchs[] = {
  64                 "VFPv1 (unsupported)",
  65                 "VFPv2",
  66                 "VFPv3+ with common VFP subarch v2",
  67                 "VFPv3+ with null subarch",
  68                 "VFPv3+ with common VFP subarch v3",
  69         };
  70
  71         if (impl != 'A' || sa >= nelem(armarchs))
  72                 return "GOK";
  73         else
  74                 return armarchs[sa];
  75 }
  76
  77 static char *
  78 implement(uchar impl)
  79 {
  80         if (impl == 'A')
  81                 return "arm";
  82         else
  83                 return "unknown";
  84 }
  85
  86 static int
  87 havefp(void)
  88 {
  89         int gotfp;
  90         ulong acc, sid;
  91
  92         if (m->havefpvalid)
  93                 return m->havefp;
  94
  95         m->havefp = 0;
  96         gotfp = 1 << CpFP | 1 << CpDFP;
  97         cpwrsc(0, CpCONTROL, 0, CpCPaccess, MASK(28));
  98         acc = cprdsc(0, CpCONTROL, 0, CpCPaccess);
  99         if ((acc & (MASK(2) << (2*CpFP))) == 0) {
 100                 gotfp &= ~(1 << CpFP);
 101                 print("fpon: no single FP coprocessor\n");
 102         }
 103         if ((acc & (MASK(2) << (2*CpDFP))) == 0) {
 104                 gotfp &= ~(1 << CpDFP);
 105                 print("fpon: no double FP coprocessor\n");
 106         }
 107         if (!gotfp) {
 108                 print("fpon: no FP coprocessors\n");
 109                 m->havefpvalid = 1;
 110                 return 0;
 111         }
 112         m->fpon = 1;                    /* don't panic */
 113         sid = fprd(Fpsid);
 114         m->fpon = 0;
 115         switch((sid >> 16) & MASK(7)){
 116         case 0:                         /* VFPv1 */
 117                 break;
 118         case 1:                         /* VFPv2 */
 119                 m->havefp = VFPv2;
 120                 m->fpnregs = 16;
 121                 break;
 122         default:                        /* VFPv3 or later */
 123                 m->havefp = VFPv3;
 124                 m->fpnregs = (acc & Cpaccd16) ? 16 : 32;
 125                 break;
 126         }
 127         if (m->machno == 0)
 128                 print("fp: %d registers, %s simd\n", m->fpnregs,
 129                         (acc & Cpaccnosimd? " no": ""));
 130         m->havefpvalid = 1;
 131         return 1;
 132 }
 133
 134 /*
 135  * these can be called to turn the fpu on or off for user procs,
 136  * not just at system start up or shutdown.
 137  */
 138
 139 void
 140 fpoff(void)
 141 {
 142         if (m->fpon) {
 143                 fpwr(Fpexc, 0);
 144                 m->fpon = 0;
 145         }
 146 }
 147
 148 void
 149 fpononly(void)
 150 {
 151         if (!m->fpon && havefp()) {
 152                 /* enable fp.  must be first operation on the FPUs. */
 153                 fpwr(Fpexc, Fpenabled);
 154                 m->fpon = 1;
 155         }
 156 }
 157
 158 static void
 159 fpcfg(void)
 160 {
 161         int impl;
 162         ulong sid;
 163         static int printed;
 164
 165         /* clear pending exceptions; no traps in vfp3; all v7 ops are scalar */
 166         m->fpscr = Dn | FPRNR | (FPINVAL | FPZDIV | FPOVFL) & ~Alltraps;
 167         /* VFPv2 needs software support for underflows, so force them to zero */
 168         if(m->havefp == VFPv2)
 169                 m->fpscr |= Fz;
 170         fpwr(Fpscr, m->fpscr);
 171         m->fpconfiged = 1;
 172
 173         if (printed)
 174                 return;
 175         sid = fprd(Fpsid);
 176         impl = sid >> 24;
 177         print("fp: %s arch %s; rev %ld\n", implement(impl),
 178                 subarch(impl, (sid >> 16) & MASK(7)), sid & MASK(4));
 179         printed = 1;
 180 }
 181
 182 void
 183 fpinit(void)
 184 {
 185         if (havefp()) {
 186                 fpononly();
 187                 fpcfg();
 188         }
 189 }
 190
 191 void
 192 fpon(void)
 193 {
 194         if (havefp()) {
 195                 fpononly();
 196                 if (m->fpconfiged)
 197                         fpwr(Fpscr, (fprd(Fpscr) & Allcc) | m->fpscr);
 198                 else
 199                         fpcfg();        /* 1st time on this fpu; configure it */
 200         }
 201 }
 202
 203 void
 204 fpclear(void)
 205 {
 206 //      ulong scr;
 207
 208         fpon();
 209 //      scr = fprd(Fpscr);
 210 //      m->fpscr = scr & ~Allexc;
 211 //      fpwr(Fpscr, m->fpscr);
 212
 213         fpwr(Fpexc, fprd(Fpexc) & ~Fpmbc);
 214 }
 215
 216
 217 /*
 218  * Called when a note is about to be delivered to a
 219  * user process, usually at the end of a system call.
 220  * Note handlers are not allowed to use the FPU so
 221  * the state is marked (after saving if necessary) and
 222  * checked in the Device Not Available handler.
 223  */
 224 void
 225 fpunotify(Ureg*)
 226 {
 227         if(up->fpstate == FPactive){
 228                 fpsave(up->fpsave);
 229                 up->fpstate = FPinactive;
 230         }
 231         up->fpstate |= FPillegal;
 232 }
 233
 234 /*
 235  * Called from sysnoted() via the machine-dependent
 236  * noted() routine.
 237  * Clear the flag set above in fpunotify().
 238  */
 239 void
 240 fpunoted(void)
 241 {
 242         up->fpstate &= ~FPillegal;
 243 }
 244
 245 /* should only be called if p->fpstate == FPactive */
 246 void
 247 fpsave(FPsave *fps)
 248 {
 249         int n;
 250
 251         fpon();
 252         fps->control = fps->status = fprd(Fpscr);
 253         assert(m->fpnregs);
 254         for (n = 0; n < m->fpnregs; n++)
 255                 fpsavereg(n, (uvlong *)fps->regs[n]);
 256         fpoff();
 257 }
 258
 259 static void
 260 fprestore(Proc *p)
 261 {
 262         int n;
 263
 264         fpon();
 265         fpwr(Fpscr, p->fpsave->control);
 266         m->fpscr = fprd(Fpscr) & ~Allcc;
 267         assert(m->fpnregs);
 268         for (n = 0; n < m->fpnregs; n++)
 269                 fprestreg(n, *(uvlong *)p->fpsave->regs[n]);
 270 }
 271
 272 /*
 273  * Called from sched() and sleep() via the machine-dependent
 274  * procsave() routine.
 275  * About to go in to the scheduler.
 276  * If the process wasn't using the FPU
 277  * there's nothing to do.
 278  */
 279 void
 280 fpuprocsave(Proc *p)
 281 {
 282         if(p->fpstate == FPactive){
 283                 if(p->state == Moribund)
 284                         fpoff();
 285                 else{
 286                         /*
 287                          * Fpsave() stores without handling pending
 288                          * unmasked exeptions. Postnote() can't be called
 289                          * here as sleep() already has up->rlock, so
 290                          * the handling of pending exceptions is delayed
 291                          * until the process runs again and generates an
 292                          * emulation fault to activate the FPU.
 293                          */
 294                         fpsave(p->fpsave);
 295                 }
 296                 p->fpstate = FPinactive;
 297         }
 298 }
 299
 300 /*
 301  * The process has been rescheduled and is about to run.
 302  * Nothing to do here right now. If the process tries to use
 303  * the FPU again it will cause a Device Not Available
 304  * exception and the state will then be restored.
 305  */
 306 void
 307 fpuprocrestore(Proc *)
 308 {
 309 }
 310
 311 /*
 312  * The current process has been forked,
 313  * save and copy neccesary state to child.
 314  */
 315 void
 316 fpuprocfork(Proc *p)
 317 {
 318         int s;
 319
 320         s = splhi();
 321         switch(up->fpstate & ~FPillegal){
 322         case FPactive:
 323                 fpsave(up->fpsave);
 324                 up->fpstate = FPinactive;
 325                 /* no break */
 326         case FPinactive:
 327                 memmove(p->fpsave, up->fpsave, sizeof(FPsave));
 328                 p->fpstate = FPinactive;
 329         }
 330         splx(s);
 331 }
 332
 333 /*
 334  * Disable the FPU.
 335  * Called from sysexec() via sysprocsetup() to
 336  * set the FPU for the new process.
 337  */
 338 void
 339 fpusysprocsetup(Proc *p)
 340 {
 341         int s;
 342
 343         s = splhi();
 344         p->fpstate = FPinit;
 345         fpoff();
 346         splx(s);
 347 }
 348
 349 static void
 350 mathnote(void)
 351 {
 352         ulong status;
 353         char *msg, note[ERRMAX];
 354
 355         status = up->fpsave->status;
 356
 357         /*
 358          * Some attention should probably be paid here to the
 359          * exception masks and error summary.
 360          */
 361         if (status & FPAINEX)
 362                 msg = "inexact";
 363         else if (status & FPAOVFL)
 364                 msg = "overflow";
 365         else if (status & FPAUNFL)
 366                 msg = "underflow";
 367         else if (status & FPAZDIV)
 368                 msg = "divide by zero";
 369         else if (status & FPAINVAL)
 370                 msg = "bad operation";
 371         else
 372                 msg = "spurious";
 373         snprint(note, sizeof note, "sys: fp: %s fppc=%#p status=%#lux",
 374                 msg, up->fpsave->pc, status);
 375         postnote(up, 1, note, NDebug);
 376 }
 377
 378 static void
 379 mathemu(Ureg *)
 380 {
 381         switch(up->fpstate){
 382         case FPemu:
 383                 error("illegal instruction: VFP opcode in emulated mode");
 384         case FPinit:
 385                 fpinit();
 386                 up->fpstate = FPactive;
 387                 break;
 388         case FPinactive:
 389                 /*
 390                  * Before restoring the state, check for any pending
 391                  * exceptions.  There's no way to restore the state without
 392                  * generating an unmasked exception.
 393                  * More attention should probably be paid here to the
 394                  * exception masks and error summary.
 395                  */
 396                 if(up->fpsave->status & (FPAINEX|FPAUNFL|FPAOVFL|FPAZDIV|FPAINVAL)){
 397                         mathnote();
 398                         break;
 399                 }
 400                 fprestore(up);
 401                 up->fpstate = FPactive;
 402                 break;
 403         case FPactive:
 404                 error("illegal instruction: bad vfp fpu opcode");
 405                 break;
 406         }
 407         fpclear();
 408 }
 409
 410 void
 411 fpstuck(uintptr pc)
 412 {
 413         if (m->fppc == pc && m->fppid == up->pid) {
 414                 m->fpcnt++;
 415                 if (m->fpcnt > 4)
 416                         panic("fpuemu: cpu%d stuck at pid %ld %s pc %#p "
 417                                 "instr %#8.8lux", m->machno, up->pid, up->text,
 418                                 pc, *(ulong *)pc);
 419         } else {
 420                 m->fppid = up->pid;
 421                 m->fppc = pc;
 422                 m->fpcnt = 0;
 423         }
 424 }
 425
 426 enum {
 427         N = 1<<31,
 428         Z = 1<<30,
 429         C = 1<<29,
 430         V = 1<<28,
 431         REGPC = 15,
 432 };
 433
 434 static int
 435 condok(int cc, int c)
 436 {
 437         switch(c){
 438         case 0: /* Z set */
 439                 return cc&Z;
 440         case 1: /* Z clear */
 441                 return (cc&Z) == 0;
 442         case 2: /* C set */
 443                 return cc&C;
 444         case 3: /* C clear */
 445                 return (cc&C) == 0;
 446         case 4: /* N set */
 447                 return cc&N;
 448         case 5: /* N clear */
 449                 return (cc&N) == 0;
 450         case 6: /* V set */
 451                 return cc&V;
 452         case 7: /* V clear */
 453                 return (cc&V) == 0;
 454         case 8: /* C set and Z clear */
 455                 return cc&C && (cc&Z) == 0;
 456         case 9: /* C clear or Z set */
 457                 return (cc&C) == 0 || cc&Z;
 458         case 10:        /* N set and V set, or N clear and V clear */
 459                 return (~cc&(N|V))==0 || (cc&(N|V)) == 0;
 460         case 11:        /* N set and V clear, or N clear and V set */
 461                 return (cc&(N|V))==N || (cc&(N|V))==V;
 462         case 12:        /* Z clear, and either N set and V set or N clear and V clear */
 463                 return (cc&Z) == 0 && ((~cc&(N|V))==0 || (cc&(N|V))==0);
 464         case 13:        /* Z set, or N set and V clear or N clear and V set */
 465                 return (cc&Z) || (cc&(N|V))==N || (cc&(N|V))==V;
 466         case 14:        /* always */
 467                 return 1;
 468         case 15:        /* never (reserved) */
 469                 return 0;
 470         }
 471         return 0;       /* not reached */
 472 }
 473
 474 /* only called to deal with user-mode instruction faults */
 475 int
 476 fpuemu(Ureg* ureg)
 477 {
 478         int s, nfp, cop, op;
 479         uintptr pc;
 480         static int already;
 481
 482         if(waserror()){
 483                 postnote(up, 1, up->errstr, NDebug);
 484                 return 1;
 485         }
 486
 487         if(up->fpstate & FPillegal)
 488                 error("floating point in note handler");
 489
 490         nfp = 0;
 491         pc = ureg->pc;
 492         validaddr(pc, 4, 0);
 493         op  = (*(ulong *)pc >> 24) & MASK(4);
 494         cop = (*(ulong *)pc >>  8) & MASK(4);
 495         if(m->fpon)
 496                 fpstuck(pc);            /* debugging; could move down 1 line */
 497         if (ISFPAOP(cop, op)) {         /* old arm 7500 fpa opcode? */
 498                 s = spllo();
 499                 if(!already++)
 500                         pprint("warning: emulated arm7500 fpa instr %#8.8lux at %#p\n", *(ulong *)pc, pc);
 501                 if(waserror()){
 502                         splx(s);
 503                         nexterror();
 504                 }
 505                 nfp = fpiarm(ureg);     /* advances pc past emulated instr(s) */
 506                 if (nfp > 1)            /* could adjust this threshold */
 507                         m->fppc = m->fpcnt = 0;
 508                 splx(s);
 509                 poperror();
 510         } else if (ISVFPOP(cop, op)) {  /* if vfp, fpu off or unsupported instruction */
 511                 mathemu(ureg);          /* enable fpu & retry */
 512                 nfp = 1;
 513         }
 514
 515         poperror();
 516         return nfp;
 517 }