arch/arm/nwfpe/fpa11_cpdt.c

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