fpa11_cpdt.c 8.2 KB

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