arch/arm/nwfpe/fpa11_cpdt.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3     NetWinder Floating Point Emulator
   4     (c) Rebel.com, 1998-1999
   5     (c) Philip Blundell, 1998, 2001
   6
   7     Direct questions, comments to Scott Bambrough <scottb@netwinder.org>
   8
   9 */
  10
  11 #include "fpa11.h"
  12 #include "softfloat.h"
  13 #include "fpopcode.h"
  14 #include "fpmodule.h"
  15 #include "fpmodule.inl"
  16
  17 #include <linux/uaccess.h>
  18
  19 static inline void loadSingle(const unsigned int Fn, const unsigned int __user *pMem)
  20 {
  21         FPA11 *fpa11 = GET_FPA11();
  22         fpa11->fType[Fn] = typeSingle;
  23         get_user(fpa11->fpreg[Fn].fSingle, pMem);
  24 }
  25
  26 static inline void loadDouble(const unsigned int Fn, const unsigned int __user *pMem)
  27 {
  28         FPA11 *fpa11 = GET_FPA11();
  29         unsigned int *p;
  30         p = (unsigned int *) &fpa11->fpreg[Fn].fDouble;
  31         fpa11->fType[Fn] = typeDouble;
  32 #ifdef __ARMEB__
  33         get_user(p[0], &pMem[0]);       /* sign & exponent */
  34         get_user(p[1], &pMem[1]);
  35 #else
  36         get_user(p[0], &pMem[1]);
  37         get_user(p[1], &pMem[0]);       /* sign & exponent */
  38 #endif
  39 }
  40
  41 #ifdef CONFIG_FPE_NWFPE_XP
  42 static inline void loadExtended(const unsigned int Fn, const unsigned int __user *pMem)
  43 {
  44         FPA11 *fpa11 = GET_FPA11();
  45         unsigned int *p;
  46         p = (unsigned int *) &fpa11->fpreg[Fn].fExtended;
  47         fpa11->fType[Fn] = typeExtended;
  48         get_user(p[0], &pMem[0]);       /* sign & exponent */
  49 #ifdef __ARMEB__
  50         get_user(p[1], &pMem[1]);       /* ms bits */
  51         get_user(p[2], &pMem[2]);       /* ls bits */
  52 #else
  53         get_user(p[1], &pMem[2]);       /* ls bits */
  54         get_user(p[2], &pMem[1]);       /* ms bits */
  55 #endif
  56 }
  57 #endif
  58
  59 static inline void loadMultiple(const unsigned int Fn, const unsigned int __user *pMem)
  60 {
  61         FPA11 *fpa11 = GET_FPA11();
  62         register unsigned int *p;
  63         unsigned long x;
  64
  65         p = (unsigned int *) &(fpa11->fpreg[Fn]);
  66         get_user(x, &pMem[0]);
  67         fpa11->fType[Fn] = (x >> 14) & 0x00000003;
  68
  69         switch (fpa11->fType[Fn]) {
  70         case typeSingle:
  71         case typeDouble:
  72                 {
  73                         get_user(p[0], &pMem[2]);       /* Single */
  74                         get_user(p[1], &pMem[1]);       /* double msw */
  75                         p[2] = 0;                       /* empty */
  76                 }
  77                 break;
  78
  79 #ifdef CONFIG_FPE_NWFPE_XP
  80         case typeExtended:
  81                 {
  82                         get_user(p[1], &pMem[2]);
  83                         get_user(p[2], &pMem[1]);       /* msw */
  84                         p[0] = (x & 0x80003fff);
  85                 }
  86                 break;
  87 #endif
  88         }
  89 }
  90
  91 static inline void storeSingle(struct roundingData *roundData, const unsigned int Fn, unsigned int __user *pMem)
  92 {
  93         FPA11 *fpa11 = GET_FPA11();
  94         union {
  95                 float32 f;
  96                 unsigned int i[1];
  97         } val;
  98
  99         switch (fpa11->fType[Fn]) {
 100         case typeDouble:
 101                 val.f = float64_to_float32(roundData, fpa11->fpreg[Fn].fDouble);
 102                 break;
 103
 104 #ifdef CONFIG_FPE_NWFPE_XP
 105         case typeExtended:
 106                 val.f = floatx80_to_float32(roundData, fpa11->fpreg[Fn].fExtended);
 107                 break;
 108 #endif
 109
 110         default:
 111                 val.f = fpa11->fpreg[Fn].fSingle;
 112         }
 113
 114         put_user(val.i[0], pMem);
 115 }
 116
 117 static inline void storeDouble(struct roundingData *roundData, const unsigned int Fn, unsigned int __user *pMem)
 118 {
 119         FPA11 *fpa11 = GET_FPA11();
 120         union {
 121                 float64 f;
 122                 unsigned int i[2];
 123         } val;
 124
 125         switch (fpa11->fType[Fn]) {
 126         case typeSingle:
 127                 val.f = float32_to_float64(fpa11->fpreg[Fn].fSingle);
 128                 break;
 129
 130 #ifdef CONFIG_FPE_NWFPE_XP
 131         case typeExtended:
 132                 val.f = floatx80_to_float64(roundData, fpa11->fpreg[Fn].fExtended);
 133                 break;
 134 #endif
 135
 136         default:
 137                 val.f = fpa11->fpreg[Fn].fDouble;
 138         }
 139
 140 #ifdef __ARMEB__
 141         put_user(val.i[0], &pMem[0]);   /* msw */
 142         put_user(val.i[1], &pMem[1]);   /* lsw */
 143 #else
 144         put_user(val.i[1], &pMem[0]);   /* msw */
 145         put_user(val.i[0], &pMem[1]);   /* lsw */
 146 #endif
 147 }
 148
 149 #ifdef CONFIG_FPE_NWFPE_XP
 150 static inline void storeExtended(const unsigned int Fn, unsigned int __user *pMem)
 151 {
 152         FPA11 *fpa11 = GET_FPA11();
 153         union {
 154                 floatx80 f;
 155                 unsigned int i[3];
 156         } val;
 157
 158         switch (fpa11->fType[Fn]) {
 159         case typeSingle:
 160                 val.f = float32_to_floatx80(fpa11->fpreg[Fn].fSingle);
 161                 break;
 162
 163         case typeDouble:
 164                 val.f = float64_to_floatx80(fpa11->fpreg[Fn].fDouble);
 165                 break;
 166
 167         default:
 168                 val.f = fpa11->fpreg[Fn].fExtended;
 169         }
 170
 171         put_user(val.i[0], &pMem[0]);   /* sign & exp */
 172 #ifdef __ARMEB__
 173         put_user(val.i[1], &pMem[1]);   /* msw */
 174         put_user(val.i[2], &pMem[2]);
 175 #else
 176         put_user(val.i[1], &pMem[2]);
 177         put_user(val.i[2], &pMem[1]);   /* msw */
 178 #endif
 179 }
 180 #endif
 181
 182 static inline void storeMultiple(const unsigned int Fn, unsigned int __user *pMem)
 183 {
 184         FPA11 *fpa11 = GET_FPA11();
 185         register unsigned int nType, *p;
 186
 187         p = (unsigned int *) &(fpa11->fpreg[Fn]);
 188         nType = fpa11->fType[Fn];
 189
 190         switch (nType) {
 191         case typeSingle:
 192         case typeDouble:
 193                 {
 194                         put_user(p[0], &pMem[2]);       /* single */
 195                         put_user(p[1], &pMem[1]);       /* double msw */
 196                         put_user(nType << 14, &pMem[0]);
 197                 }
 198                 break;
 199
 200 #ifdef CONFIG_FPE_NWFPE_XP
 201         case typeExtended:
 202                 {
 203                         put_user(p[2], &pMem[1]);       /* msw */
 204                         put_user(p[1], &pMem[2]);
 205                         put_user((p[0] & 0x80003fff) | (nType << 14), &pMem[0]);
 206                 }
 207                 break;
 208 #endif
 209         }
 210 }
 211
 212 unsigned int PerformLDF(const unsigned int opcode)
 213 {
 214         unsigned int __user *pBase, *pAddress, *pFinal;
 215         unsigned int nRc = 1, write_back = WRITE_BACK(opcode);
 216
 217         pBase = (unsigned int __user *) readRegister(getRn(opcode));
 218         if (REG_PC == getRn(opcode)) {
 219                 pBase += 2;
 220                 write_back = 0;
 221         }
 222
 223         pFinal = pBase;
 224         if (BIT_UP_SET(opcode))
 225                 pFinal += getOffset(opcode);
 226         else
 227                 pFinal -= getOffset(opcode);
 228
 229         if (PREINDEXED(opcode))
 230                 pAddress = pFinal;
 231         else
 232                 pAddress = pBase;
 233
 234         switch (opcode & MASK_TRANSFER_LENGTH) {
 235         case TRANSFER_SINGLE:
 236                 loadSingle(getFd(opcode), pAddress);
 237                 break;
 238         case TRANSFER_DOUBLE:
 239                 loadDouble(getFd(opcode), pAddress);
 240                 break;
 241 #ifdef CONFIG_FPE_NWFPE_XP
 242         case TRANSFER_EXTENDED:
 243                 loadExtended(getFd(opcode), pAddress);
 244                 break;
 245 #endif
 246         default:
 247                 nRc = 0;
 248         }
 249
 250         if (write_back)
 251                 writeRegister(getRn(opcode), (unsigned long) pFinal);
 252         return nRc;
 253 }
 254
 255 unsigned int PerformSTF(const unsigned int opcode)
 256 {
 257         unsigned int __user *pBase, *pAddress, *pFinal;
 258         unsigned int nRc = 1, write_back = WRITE_BACK(opcode);
 259         struct roundingData roundData;
 260
 261         roundData.mode = SetRoundingMode(opcode);
 262         roundData.precision = SetRoundingPrecision(opcode);
 263         roundData.exception = 0;
 264
 265         pBase = (unsigned int __user *) readRegister(getRn(opcode));
 266         if (REG_PC == getRn(opcode)) {
 267                 pBase += 2;
 268                 write_back = 0;
 269         }
 270
 271         pFinal = pBase;
 272         if (BIT_UP_SET(opcode))
 273                 pFinal += getOffset(opcode);
 274         else
 275                 pFinal -= getOffset(opcode);
 276
 277         if (PREINDEXED(opcode))
 278                 pAddress = pFinal;
 279         else
 280                 pAddress = pBase;
 281
 282         switch (opcode & MASK_TRANSFER_LENGTH) {
 283         case TRANSFER_SINGLE:
 284                 storeSingle(&roundData, getFd(opcode), pAddress);
 285                 break;
 286         case TRANSFER_DOUBLE:
 287                 storeDouble(&roundData, getFd(opcode), pAddress);
 288                 break;
 289 #ifdef CONFIG_FPE_NWFPE_XP
 290         case TRANSFER_EXTENDED:
 291                 storeExtended(getFd(opcode), pAddress);
 292                 break;
 293 #endif
 294         default:
 295                 nRc = 0;
 296         }
 297
 298         if (roundData.exception)
 299                 float_raise(roundData.exception);
 300
 301         if (write_back)
 302                 writeRegister(getRn(opcode), (unsigned long) pFinal);
 303         return nRc;
 304 }
 305
 306 unsigned int PerformLFM(const unsigned int opcode)
 307 {
 308         unsigned int __user *pBase, *pAddress, *pFinal;
 309         unsigned int i, Fd, write_back = WRITE_BACK(opcode);
 310
 311         pBase = (unsigned int __user *) readRegister(getRn(opcode));
 312         if (REG_PC == getRn(opcode)) {
 313                 pBase += 2;
 314                 write_back = 0;
 315         }
 316
 317         pFinal = pBase;
 318         if (BIT_UP_SET(opcode))
 319                 pFinal += getOffset(opcode);
 320         else
 321                 pFinal -= getOffset(opcode);
 322
 323         if (PREINDEXED(opcode))
 324                 pAddress = pFinal;
 325         else
 326                 pAddress = pBase;
 327
 328         Fd = getFd(opcode);
 329         for (i = getRegisterCount(opcode); i > 0; i--) {
 330                 loadMultiple(Fd, pAddress);
 331                 pAddress += 3;
 332                 Fd++;
 333                 if (Fd == 8)
 334                         Fd = 0;
 335         }
 336
 337         if (write_back)
 338                 writeRegister(getRn(opcode), (unsigned long) pFinal);
 339         return 1;
 340 }
 341
 342 unsigned int PerformSFM(const unsigned int opcode)
 343 {
 344         unsigned int __user *pBase, *pAddress, *pFinal;
 345         unsigned int i, Fd, write_back = WRITE_BACK(opcode);
 346
 347         pBase = (unsigned int __user *) readRegister(getRn(opcode));
 348         if (REG_PC == getRn(opcode)) {
 349                 pBase += 2;
 350                 write_back = 0;
 351         }
 352
 353         pFinal = pBase;
 354         if (BIT_UP_SET(opcode))
 355                 pFinal += getOffset(opcode);
 356         else
 357                 pFinal -= getOffset(opcode);
 358
 359         if (PREINDEXED(opcode))
 360                 pAddress = pFinal;
 361         else
 362                 pAddress = pBase;
 363
 364         Fd = getFd(opcode);
 365         for (i = getRegisterCount(opcode); i > 0; i--) {
 366                 storeMultiple(Fd, pAddress);
 367                 pAddress += 3;
 368                 Fd++;
 369                 if (Fd == 8)
 370                         Fd = 0;
 371         }
 372
 373         if (write_back)
 374                 writeRegister(getRn(opcode), (unsigned long) pFinal);
 375         return 1;
 376 }
 377
 378 unsigned int EmulateCPDT(const unsigned int opcode)
 379 {
 380         unsigned int nRc = 0;
 381
 382         if (LDF_OP(opcode)) {
 383                 nRc = PerformLDF(opcode);
 384         } else if (LFM_OP(opcode)) {
 385                 nRc = PerformLFM(opcode);
 386         } else if (STF_OP(opcode)) {
 387                 nRc = PerformSTF(opcode);
 388         } else if (SFM_OP(opcode)) {
 389                 nRc = PerformSFM(opcode);
 390         } else {
 391                 nRc = 0;
 392         }
 393
 394         return nRc;
 395 }