/arch/arm/nwfpe/fpa11_cpdt.c

https://bitbucket.org/evzijst/gittest · C · 392 lines · 315 code · 56 blank · 21 comment · 41 complexity · d741d66346e32ff704d112369e8c0b9e MD5 · raw file 

    

  1. /*
    2. 

  2.     NetWinder Floating Point Emulator
    3. 

  3.     (c) Rebel.com, 1998-1999
    4. 

  4.     (c) Philip Blundell, 1998, 2001
    5. 

    6. 

  6.     Direct questions, comments to Scott Bambrough <scottb@netwinder.org>
    7. 

    8. 

  8.     This program is free software; you can redistribute it and/or modify
    9. 

  9.     it under the terms of the GNU General Public License as published by
    10. 

  10.     the Free Software Foundation; either version 2 of the License, or
    11. 

  11.     (at your option) any later version.
    12. 

    13. 

  13.     This program is distributed in the hope that it will be useful,
    14. 

  14.     but WITHOUT ANY WARRANTY; without even the implied warranty of
    15. 

  15.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    16. 

  16.     GNU General Public License for more details.
    17. 

    18. 

  18.     You should have received a copy of the GNU General Public License
    19. 

  19.     along with this program; if not, write to the Free Software
    20. 

  20.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
    21. 

  21. */
    22. 

  22. 

  23. #include <linux/config.h>
    24. 

  24. #include "fpa11.h"
    25. 

  25. #include "softfloat.h"
    26. 

  26. #include "fpopcode.h"
    27. 

  27. #include "fpmodule.h"
    28. 

  28. #include "fpmodule.inl"
    29. 

  29. 

  30. #include <asm/uaccess.h>
    31. 

  31. 

  32. static inline void loadSingle(const unsigned int Fn, const unsigned int __user *pMem)
    33. 

  33. {
    34. 

  34. 	FPA11 *fpa11 = GET_FPA11();
    35. 

  35. 	fpa11->fType[Fn] = typeSingle;
    36. 

  36. 	get_user(fpa11->fpreg[Fn].fSingle, pMem);
    37. 

  37. }
    38. 

  38. 

  39. static inline void loadDouble(const unsigned int Fn, const unsigned int __user *pMem)
    40. 

  40. {
    41. 

  41. 	FPA11 *fpa11 = GET_FPA11();
    42. 

  42. 	unsigned int *p;
    43. 

  43. 	p = (unsigned int *) &fpa11->fpreg[Fn].fDouble;
    44. 

  44. 	fpa11->fType[Fn] = typeDouble;
    45. 

  45. #ifdef __ARMEB__
    46. 

  46. 	get_user(p[0], &pMem[0]);	/* sign & exponent */
    47. 

  47. 	get_user(p[1], &pMem[1]);
    48. 

  48. #else
    49. 

  49. 	get_user(p[0], &pMem[1]);
    50. 

  50. 	get_user(p[1], &pMem[0]);	/* sign & exponent */
    51. 

  51. #endif
    52. 

  52. }
    53. 

  53. 

  54. #ifdef CONFIG_FPE_NWFPE_XP
    55. 

  55. static inline void loadExtended(const unsigned int Fn, const unsigned int __user *pMem)
    56. 

  56. {
    57. 

  57. 	FPA11 *fpa11 = GET_FPA11();
    58. 

  58. 	unsigned int *p;
    59. 

  59. 	p = (unsigned int *) &fpa11->fpreg[Fn].fExtended;
    60. 

  60. 	fpa11->fType[Fn] = typeExtended;
    61. 

  61. 	get_user(p[0], &pMem[0]);	/* sign & exponent */
    62. 

  62. 	get_user(p[1], &pMem[2]);	/* ls bits */
    63. 

  63. 	get_user(p[2], &pMem[1]);	/* ms bits */
    64. 

  64. }
    65. 

  65. #endif
    66. 

  66. 

  67. static inline void loadMultiple(const unsigned int Fn, const unsigned int __user *pMem)
    68. 

  68. {
    69. 

  69. 	FPA11 *fpa11 = GET_FPA11();
    70. 

  70. 	register unsigned int *p;
    71. 

  71. 	unsigned long x;
    72. 

  72. 

  73. 	p = (unsigned int *) &(fpa11->fpreg[Fn]);
    74. 

  74. 	get_user(x, &pMem[0]);
    75. 

  75. 	fpa11->fType[Fn] = (x >> 14) & 0x00000003;
    76. 

  76. 

  77. 	switch (fpa11->fType[Fn]) {
    78. 

  78. 	case typeSingle:
    79. 

  79. 	case typeDouble:
    80. 

  80. 		{
    81. 

  81. 			get_user(p[0], &pMem[2]);	/* Single */
    82. 

  82. 			get_user(p[1], &pMem[1]);	/* double msw */
    83. 

  83. 			p[2] = 0;			/* empty */
    84. 

  84. 		}
    85. 

  85. 		break;
    86. 

  86. 

  87. #ifdef CONFIG_FPE_NWFPE_XP
    88. 

  88. 	case typeExtended:
    89. 

  89. 		{
    90. 

  90. 			get_user(p[1], &pMem[2]);
    91. 

  91. 			get_user(p[2], &pMem[1]);	/* msw */
    92. 

  92. 			p[0] = (x & 0x80003fff);
    93. 

  93. 		}
    94. 

  94. 		break;
    95. 

  95. #endif
    96. 

  96. 	}
    97. 

  97. }
    98. 

  98. 

  99. static inline void storeSingle(const unsigned int Fn, unsigned int __user *pMem)
    100. 

  100. {
    101. 

  101. 	FPA11 *fpa11 = GET_FPA11();
    102. 

  102. 	union {
    103. 

  103. 		float32 f;
    104. 

  104. 		unsigned int i[1];
    105. 

  105. 	} val;
    106. 

  106. 

  107. 	switch (fpa11->fType[Fn]) {
    108. 

  108. 	case typeDouble:
    109. 

  109. 		val.f = float64_to_float32(fpa11->fpreg[Fn].fDouble);
    110. 

  110. 		break;
    111. 

  111. 

  112. #ifdef CONFIG_FPE_NWFPE_XP
    113. 

  113. 	case typeExtended:
    114. 

  114. 		val.f = floatx80_to_float32(fpa11->fpreg[Fn].fExtended);
    115. 

  115. 		break;
    116. 

  116. #endif
    117. 

  117. 

  118. 	default:
    119. 

  119. 		val.f = fpa11->fpreg[Fn].fSingle;
    120. 

  120. 	}
    121. 

  121. 

  122. 	put_user(val.i[0], pMem);
    123. 

  123. }
    124. 

  124. 

  125. static inline void storeDouble(const unsigned int Fn, unsigned int __user *pMem)
    126. 

  126. {
    127. 

  127. 	FPA11 *fpa11 = GET_FPA11();
    128. 

  128. 	union {
    129. 

  129. 		float64 f;
    130. 

  130. 		unsigned int i[2];
    131. 

  131. 	} val;
    132. 

  132. 

  133. 	switch (fpa11->fType[Fn]) {
    134. 

  134. 	case typeSingle:
    135. 

  135. 		val.f = float32_to_float64(fpa11->fpreg[Fn].fSingle);
    136. 

  136. 		break;
    137. 

  137. 

  138. #ifdef CONFIG_FPE_NWFPE_XP
    139. 

  139. 	case typeExtended:
    140. 

  140. 		val.f = floatx80_to_float64(fpa11->fpreg[Fn].fExtended);
    141. 

  141. 		break;
    142. 

  142. #endif
    143. 

  143. 

  144. 	default:
    145. 

  145. 		val.f = fpa11->fpreg[Fn].fDouble;
    146. 

  146. 	}
    147. 

  147. 

  148. #ifdef __ARMEB__
    149. 

  149. 	put_user(val.i[0], &pMem[0]);	/* msw */
    150. 

  150. 	put_user(val.i[1], &pMem[1]);	/* lsw */
    151. 

  151. #else
    152. 

  152. 	put_user(val.i[1], &pMem[0]);	/* msw */
    153. 

  153. 	put_user(val.i[0], &pMem[1]);	/* lsw */
    154. 

  154. #endif
    155. 

  155. }
    156. 

  156. 

  157. #ifdef CONFIG_FPE_NWFPE_XP
    158. 

  158. static inline void storeExtended(const unsigned int Fn, unsigned int __user *pMem)
    159. 

  159. {
    160. 

  160. 	FPA11 *fpa11 = GET_FPA11();
    161. 

  161. 	union {
    162. 

  162. 		floatx80 f;
    163. 

  163. 		unsigned int i[3];
    164. 

  164. 	} val;
    165. 

  165. 

  166. 	switch (fpa11->fType[Fn]) {
    167. 

  167. 	case typeSingle:
    168. 

  168. 		val.f = float32_to_floatx80(fpa11->fpreg[Fn].fSingle);
    169. 

  169. 		break;
    170. 

  170. 

  171. 	case typeDouble:
    172. 

  172. 		val.f = float64_to_floatx80(fpa11->fpreg[Fn].fDouble);
    173. 

  173. 		break;
    174. 

  174. 

  175. 	default:
    176. 

  176. 		val.f = fpa11->fpreg[Fn].fExtended;
    177. 

  177. 	}
    178. 

  178. 

  179. 	put_user(val.i[0], &pMem[0]);	/* sign & exp */
    180. 

  180. 	put_user(val.i[1], &pMem[2]);
    181. 

  181. 	put_user(val.i[2], &pMem[1]);	/* msw */
    182. 

  182. }
    183. 

  183. #endif
    184. 

  184. 

  185. static inline void storeMultiple(const unsigned int Fn, unsigned int __user *pMem)
    186. 

  186. {
    187. 

  187. 	FPA11 *fpa11 = GET_FPA11();
    188. 

  188. 	register unsigned int nType, *p;
    189. 

  189. 

  190. 	p = (unsigned int *) &(fpa11->fpreg[Fn]);
    191. 

  191. 	nType = fpa11->fType[Fn];
    192. 

  192. 

  193. 	switch (nType) {
    194. 

  194. 	case typeSingle:
    195. 

  195. 	case typeDouble:
    196. 

  196. 		{
    197. 

  197. 			put_user(p[0], &pMem[2]);	/* single */
    198. 

  198. 			put_user(p[1], &pMem[1]);	/* double msw */
    199. 

  199. 			put_user(nType << 14, &pMem[0]);
    200. 

  200. 		}
    201. 

  201. 		break;
    202. 

  202. 

  203. #ifdef CONFIG_FPE_NWFPE_XP
    204. 

  204. 	case typeExtended:
    205. 

  205. 		{
    206. 

  206. 			put_user(p[2], &pMem[1]);	/* msw */
    207. 

  207. 			put_user(p[1], &pMem[2]);
    208. 

  208. 			put_user((p[0] & 0x80003fff) | (nType << 14), &pMem[0]);
    209. 

  209. 		}
    210. 

  210. 		break;
    211. 

  211. #endif
    212. 

  212. 	}
    213. 

  213. }
    214. 

  214. 

  215. unsigned int PerformLDF(const unsigned int opcode)
    216. 

  216. {
    217. 

  217. 	unsigned int __user *pBase, *pAddress, *pFinal;
    218. 

  218. 	unsigned int nRc = 1, write_back = WRITE_BACK(opcode);
    219. 

  219. 

  220. 	pBase = (unsigned int __user *) readRegister(getRn(opcode));
    221. 

  221. 	if (REG_PC == getRn(opcode)) {
    222. 

  222. 		pBase += 2;
    223. 

  223. 		write_back = 0;
    224. 

  224. 	}
    225. 

  225. 

  226. 	pFinal = pBase;
    227. 

  227. 	if (BIT_UP_SET(opcode))
    228. 

  228. 		pFinal += getOffset(opcode);
    229. 

  229. 	else
    230. 

  230. 		pFinal -= getOffset(opcode);
    231. 

  231. 

  232. 	if (PREINDEXED(opcode))
    233. 

  233. 		pAddress = pFinal;
    234. 

  234. 	else
    235. 

  235. 		pAddress = pBase;
    236. 

  236. 

  237. 	switch (opcode & MASK_TRANSFER_LENGTH) {
    238. 

  238. 	case TRANSFER_SINGLE:
    239. 

  239. 		loadSingle(getFd(opcode), pAddress);
    240. 

  240. 		break;
    241. 

  241. 	case TRANSFER_DOUBLE:
    242. 

  242. 		loadDouble(getFd(opcode), pAddress);
    243. 

  243. 		break;
    244. 

  244. #ifdef CONFIG_FPE_NWFPE_XP
    245. 

  245. 	case TRANSFER_EXTENDED:
    246. 

  246. 		loadExtended(getFd(opcode), pAddress);
    247. 

  247. 		break;
    248. 

  248. #endif
    249. 

  249. 	default:
    250. 

  250. 		nRc = 0;
    251. 

  251. 	}
    252. 

  252. 

  253. 	if (write_back)
    254. 

  254. 		writeRegister(getRn(opcode), (unsigned long) pFinal);
    255. 

  255. 	return nRc;
    256. 

  256. }
    257. 

  257. 

  258. unsigned int PerformSTF(const unsigned int opcode)
    259. 

  259. {
    260. 

  260. 	unsigned int __user *pBase, *pAddress, *pFinal;
    261. 

  261. 	unsigned int nRc = 1, write_back = WRITE_BACK(opcode);
    262. 

  262. 

  263. 	SetRoundingMode(ROUND_TO_NEAREST);
    264. 

  264. 

  265. 	pBase = (unsigned int __user *) readRegister(getRn(opcode));
    266. 

  266. 	if (REG_PC == getRn(opcode)) {
    267. 

  267. 		pBase += 2;
    268. 

  268. 		write_back = 0;
    269. 

  269. 	}
    270. 

  270. 

  271. 	pFinal = pBase;
    272. 

  272. 	if (BIT_UP_SET(opcode))
    273. 

  273. 		pFinal += getOffset(opcode);
    274. 

  274. 	else
    275. 

  275. 		pFinal -= getOffset(opcode);
    276. 

  276. 

  277. 	if (PREINDEXED(opcode))
    278. 

  278. 		pAddress = pFinal;
    279. 

  279. 	else
    280. 

  280. 		pAddress = pBase;
    281. 

  281. 

  282. 	switch (opcode & MASK_TRANSFER_LENGTH) {
    283. 

  283. 	case TRANSFER_SINGLE:
    284. 

  284. 		storeSingle(getFd(opcode), pAddress);
    285. 

  285. 		break;
    286. 

  286. 	case TRANSFER_DOUBLE:
    287. 

  287. 		storeDouble(getFd(opcode), pAddress);
    288. 

  288. 		break;
    289. 

  289. #ifdef CONFIG_FPE_NWFPE_XP
    290. 

  290. 	case TRANSFER_EXTENDED:
    291. 

  291. 		storeExtended(getFd(opcode), pAddress);
    292. 

  292. 		break;
    293. 

  293. #endif
    294. 

  294. 	default:
    295. 

  295. 		nRc = 0;
    296. 

  296. 	}
    297. 

  297. 

  298. 	if (write_back)
    299. 

  299. 		writeRegister(getRn(opcode), (unsigned long) pFinal);
    300. 

  300. 	return nRc;
    301. 

  301. }
    302. 

  302. 

  303. unsigned int PerformLFM(const unsigned int opcode)
    304. 

  304. {
    305. 

  305. 	unsigned int __user *pBase, *pAddress, *pFinal;
    306. 

  306. 	unsigned int i, Fd, write_back = WRITE_BACK(opcode);
    307. 

  307. 

  308. 	pBase = (unsigned int __user *) readRegister(getRn(opcode));
    309. 

  309. 	if (REG_PC == getRn(opcode)) {
    310. 

  310. 		pBase += 2;
    311. 

  311. 		write_back = 0;
    312. 

  312. 	}
    313. 

  313. 

  314. 	pFinal = pBase;
    315. 

  315. 	if (BIT_UP_SET(opcode))
    316. 

  316. 		pFinal += getOffset(opcode);
    317. 

  317. 	else
    318. 

  318. 		pFinal -= getOffset(opcode);
    319. 

  319. 

  320. 	if (PREINDEXED(opcode))
    321. 

  321. 		pAddress = pFinal;
    322. 

  322. 	else
    323. 

  323. 		pAddress = pBase;
    324. 

  324. 

  325. 	Fd = getFd(opcode);
    326. 

  326. 	for (i = getRegisterCount(opcode); i > 0; i--) {
    327. 

  327. 		loadMultiple(Fd, pAddress);
    328. 

  328. 		pAddress += 3;
    329. 

  329. 		Fd++;
    330. 

  330. 		if (Fd == 8)
    331. 

  331. 			Fd = 0;
    332. 

  332. 	}
    333. 

  333. 

  334. 	if (write_back)
    335. 

  335. 		writeRegister(getRn(opcode), (unsigned long) pFinal);
    336. 

  336. 	return 1;
    337. 

  337. }
    338. 

  338. 

  339. unsigned int PerformSFM(const unsigned int opcode)
    340. 

  340. {
    341. 

  341. 	unsigned int __user *pBase, *pAddress, *pFinal;
    342. 

  342. 	unsigned int i, Fd, write_back = WRITE_BACK(opcode);
    343. 

  343. 

  344. 	pBase = (unsigned int __user *) readRegister(getRn(opcode));
    345. 

  345. 	if (REG_PC == getRn(opcode)) {
    346. 

  346. 		pBase += 2;
    347. 

  347. 		write_back = 0;
    348. 

  348. 	}
    349. 

  349. 

  350. 	pFinal = pBase;
    351. 

  351. 	if (BIT_UP_SET(opcode))
    352. 

  352. 		pFinal += getOffset(opcode);
    353. 

  353. 	else
    354. 

  354. 		pFinal -= getOffset(opcode);
    355. 

  355. 

  356. 	if (PREINDEXED(opcode))
    357. 

  357. 		pAddress = pFinal;
    358. 

  358. 	else
    359. 

  359. 		pAddress = pBase;
    360. 

  360. 

  361. 	Fd = getFd(opcode);
    362. 

  362. 	for (i = getRegisterCount(opcode); i > 0; i--) {
    363. 

  363. 		storeMultiple(Fd, pAddress);
    364. 

  364. 		pAddress += 3;
    365. 

  365. 		Fd++;
    366. 

  366. 		if (Fd == 8)
    367. 

  367. 			Fd = 0;
    368. 

  368. 	}
    369. 

  369. 

  370. 	if (write_back)
    371. 

  371. 		writeRegister(getRn(opcode), (unsigned long) pFinal);
    372. 

  372. 	return 1;
    373. 

  373. }
    374. 

  374. 

  375. unsigned int EmulateCPDT(const unsigned int opcode)
    376. 

  376. {
    377. 

  377. 	unsigned int nRc = 0;
    378. 

  378. 

  379. 	if (LDF_OP(opcode)) {
    380. 

  380. 		nRc = PerformLDF(opcode);
    381. 

  381. 	} else if (LFM_OP(opcode)) {
    382. 

  382. 		nRc = PerformLFM(opcode);
    383. 

  383. 	} else if (STF_OP(opcode)) {
    384. 

  384. 		nRc = PerformSTF(opcode);
    385. 

  385. 	} else if (SFM_OP(opcode)) {
    386. 

  386. 		nRc = PerformSFM(opcode);
    387. 

  387. 	} else {
    388. 

  388. 		nRc = 0;
    389. 

  389. 	}
    390. 

  390. 

  391. 	return nRc;
    392. 

  392. }
    393.