Loading...
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * arch/powerpc/math-emu/math_efp.c
4 *
5 * Copyright (C) 2006-2008, 2010 Freescale Semiconductor, Inc.
6 *
7 * Author: Ebony Zhu, <ebony.zhu@freescale.com>
8 * Yu Liu, <yu.liu@freescale.com>
9 *
10 * Derived from arch/alpha/math-emu/math.c
11 * arch/powerpc/math-emu/math.c
12 *
13 * Description:
14 * This file is the exception handler to make E500 SPE instructions
15 * fully comply with IEEE-754 floating point standard.
16 */
17
18#include <linux/types.h>
19#include <linux/prctl.h>
20#include <linux/module.h>
21
22#include <linux/uaccess.h>
23#include <asm/reg.h>
24
25#define FP_EX_BOOKE_E500_SPE
26#include <asm/sfp-machine.h>
27
28#include <math-emu/soft-fp.h>
29#include <math-emu/single.h>
30#include <math-emu/double.h>
31
32#define EFAPU 0x4
33
34#define VCT 0x4
35#define SPFP 0x6
36#define DPFP 0x7
37
38#define EFSADD 0x2c0
39#define EFSSUB 0x2c1
40#define EFSABS 0x2c4
41#define EFSNABS 0x2c5
42#define EFSNEG 0x2c6
43#define EFSMUL 0x2c8
44#define EFSDIV 0x2c9
45#define EFSCMPGT 0x2cc
46#define EFSCMPLT 0x2cd
47#define EFSCMPEQ 0x2ce
48#define EFSCFD 0x2cf
49#define EFSCFSI 0x2d1
50#define EFSCTUI 0x2d4
51#define EFSCTSI 0x2d5
52#define EFSCTUF 0x2d6
53#define EFSCTSF 0x2d7
54#define EFSCTUIZ 0x2d8
55#define EFSCTSIZ 0x2da
56
57#define EVFSADD 0x280
58#define EVFSSUB 0x281
59#define EVFSABS 0x284
60#define EVFSNABS 0x285
61#define EVFSNEG 0x286
62#define EVFSMUL 0x288
63#define EVFSDIV 0x289
64#define EVFSCMPGT 0x28c
65#define EVFSCMPLT 0x28d
66#define EVFSCMPEQ 0x28e
67#define EVFSCTUI 0x294
68#define EVFSCTSI 0x295
69#define EVFSCTUF 0x296
70#define EVFSCTSF 0x297
71#define EVFSCTUIZ 0x298
72#define EVFSCTSIZ 0x29a
73
74#define EFDADD 0x2e0
75#define EFDSUB 0x2e1
76#define EFDABS 0x2e4
77#define EFDNABS 0x2e5
78#define EFDNEG 0x2e6
79#define EFDMUL 0x2e8
80#define EFDDIV 0x2e9
81#define EFDCTUIDZ 0x2ea
82#define EFDCTSIDZ 0x2eb
83#define EFDCMPGT 0x2ec
84#define EFDCMPLT 0x2ed
85#define EFDCMPEQ 0x2ee
86#define EFDCFS 0x2ef
87#define EFDCTUI 0x2f4
88#define EFDCTSI 0x2f5
89#define EFDCTUF 0x2f6
90#define EFDCTSF 0x2f7
91#define EFDCTUIZ 0x2f8
92#define EFDCTSIZ 0x2fa
93
94#define AB 2
95#define XA 3
96#define XB 4
97#define XCR 5
98#define NOTYPE 0
99
100#define SIGN_BIT_S (1UL << 31)
101#define SIGN_BIT_D (1ULL << 63)
102#define FP_EX_MASK (FP_EX_INEXACT | FP_EX_INVALID | FP_EX_DIVZERO | \
103 FP_EX_UNDERFLOW | FP_EX_OVERFLOW)
104
105static int have_e500_cpu_a005_erratum;
106
107union dw_union {
108 u64 dp[1];
109 u32 wp[2];
110};
111
112static unsigned long insn_type(unsigned long speinsn)
113{
114 unsigned long ret = NOTYPE;
115
116 switch (speinsn & 0x7ff) {
117 case EFSABS: ret = XA; break;
118 case EFSADD: ret = AB; break;
119 case EFSCFD: ret = XB; break;
120 case EFSCMPEQ: ret = XCR; break;
121 case EFSCMPGT: ret = XCR; break;
122 case EFSCMPLT: ret = XCR; break;
123 case EFSCTSF: ret = XB; break;
124 case EFSCTSI: ret = XB; break;
125 case EFSCTSIZ: ret = XB; break;
126 case EFSCTUF: ret = XB; break;
127 case EFSCTUI: ret = XB; break;
128 case EFSCTUIZ: ret = XB; break;
129 case EFSDIV: ret = AB; break;
130 case EFSMUL: ret = AB; break;
131 case EFSNABS: ret = XA; break;
132 case EFSNEG: ret = XA; break;
133 case EFSSUB: ret = AB; break;
134 case EFSCFSI: ret = XB; break;
135
136 case EVFSABS: ret = XA; break;
137 case EVFSADD: ret = AB; break;
138 case EVFSCMPEQ: ret = XCR; break;
139 case EVFSCMPGT: ret = XCR; break;
140 case EVFSCMPLT: ret = XCR; break;
141 case EVFSCTSF: ret = XB; break;
142 case EVFSCTSI: ret = XB; break;
143 case EVFSCTSIZ: ret = XB; break;
144 case EVFSCTUF: ret = XB; break;
145 case EVFSCTUI: ret = XB; break;
146 case EVFSCTUIZ: ret = XB; break;
147 case EVFSDIV: ret = AB; break;
148 case EVFSMUL: ret = AB; break;
149 case EVFSNABS: ret = XA; break;
150 case EVFSNEG: ret = XA; break;
151 case EVFSSUB: ret = AB; break;
152
153 case EFDABS: ret = XA; break;
154 case EFDADD: ret = AB; break;
155 case EFDCFS: ret = XB; break;
156 case EFDCMPEQ: ret = XCR; break;
157 case EFDCMPGT: ret = XCR; break;
158 case EFDCMPLT: ret = XCR; break;
159 case EFDCTSF: ret = XB; break;
160 case EFDCTSI: ret = XB; break;
161 case EFDCTSIDZ: ret = XB; break;
162 case EFDCTSIZ: ret = XB; break;
163 case EFDCTUF: ret = XB; break;
164 case EFDCTUI: ret = XB; break;
165 case EFDCTUIDZ: ret = XB; break;
166 case EFDCTUIZ: ret = XB; break;
167 case EFDDIV: ret = AB; break;
168 case EFDMUL: ret = AB; break;
169 case EFDNABS: ret = XA; break;
170 case EFDNEG: ret = XA; break;
171 case EFDSUB: ret = AB; break;
172 }
173
174 return ret;
175}
176
177int do_spe_mathemu(struct pt_regs *regs)
178{
179 FP_DECL_EX;
180 int IR, cmp;
181
182 unsigned long type, func, fc, fa, fb, src, speinsn;
183 union dw_union vc, va, vb;
184
185 if (get_user(speinsn, (unsigned int __user *) regs->nip))
186 return -EFAULT;
187 if ((speinsn >> 26) != EFAPU)
188 return -EINVAL; /* not an spe instruction */
189
190 type = insn_type(speinsn);
191 if (type == NOTYPE)
192 goto illegal;
193
194 func = speinsn & 0x7ff;
195 fc = (speinsn >> 21) & 0x1f;
196 fa = (speinsn >> 16) & 0x1f;
197 fb = (speinsn >> 11) & 0x1f;
198 src = (speinsn >> 5) & 0x7;
199
200 vc.wp[0] = current->thread.evr[fc];
201 vc.wp[1] = regs->gpr[fc];
202 va.wp[0] = current->thread.evr[fa];
203 va.wp[1] = regs->gpr[fa];
204 vb.wp[0] = current->thread.evr[fb];
205 vb.wp[1] = regs->gpr[fb];
206
207 __FPU_FPSCR = mfspr(SPRN_SPEFSCR);
208
209 pr_debug("speinsn:%08lx spefscr:%08lx\n", speinsn, __FPU_FPSCR);
210 pr_debug("vc: %08x %08x\n", vc.wp[0], vc.wp[1]);
211 pr_debug("va: %08x %08x\n", va.wp[0], va.wp[1]);
212 pr_debug("vb: %08x %08x\n", vb.wp[0], vb.wp[1]);
213
214 switch (src) {
215 case SPFP: {
216 FP_DECL_S(SA); FP_DECL_S(SB); FP_DECL_S(SR);
217
218 switch (type) {
219 case AB:
220 case XCR:
221 FP_UNPACK_SP(SA, va.wp + 1);
222 fallthrough;
223 case XB:
224 FP_UNPACK_SP(SB, vb.wp + 1);
225 break;
226 case XA:
227 FP_UNPACK_SP(SA, va.wp + 1);
228 break;
229 }
230
231 pr_debug("SA: %d %08x %d (%d)\n", SA_s, SA_f, SA_e, SA_c);
232 pr_debug("SB: %d %08x %d (%d)\n", SB_s, SB_f, SB_e, SB_c);
233
234 switch (func) {
235 case EFSABS:
236 vc.wp[1] = va.wp[1] & ~SIGN_BIT_S;
237 goto update_regs;
238
239 case EFSNABS:
240 vc.wp[1] = va.wp[1] | SIGN_BIT_S;
241 goto update_regs;
242
243 case EFSNEG:
244 vc.wp[1] = va.wp[1] ^ SIGN_BIT_S;
245 goto update_regs;
246
247 case EFSADD:
248 FP_ADD_S(SR, SA, SB);
249 goto pack_s;
250
251 case EFSSUB:
252 FP_SUB_S(SR, SA, SB);
253 goto pack_s;
254
255 case EFSMUL:
256 FP_MUL_S(SR, SA, SB);
257 goto pack_s;
258
259 case EFSDIV:
260 FP_DIV_S(SR, SA, SB);
261 goto pack_s;
262
263 case EFSCMPEQ:
264 cmp = 0;
265 goto cmp_s;
266
267 case EFSCMPGT:
268 cmp = 1;
269 goto cmp_s;
270
271 case EFSCMPLT:
272 cmp = -1;
273 goto cmp_s;
274
275 case EFSCTSF:
276 case EFSCTUF:
277 if (SB_c == FP_CLS_NAN) {
278 vc.wp[1] = 0;
279 FP_SET_EXCEPTION(FP_EX_INVALID);
280 } else {
281 SB_e += (func == EFSCTSF ? 31 : 32);
282 FP_TO_INT_ROUND_S(vc.wp[1], SB, 32,
283 (func == EFSCTSF) ? 1 : 0);
284 }
285 goto update_regs;
286
287 case EFSCFD: {
288 FP_DECL_D(DB);
289 FP_CLEAR_EXCEPTIONS;
290 FP_UNPACK_DP(DB, vb.dp);
291
292 pr_debug("DB: %d %08x %08x %d (%d)\n",
293 DB_s, DB_f1, DB_f0, DB_e, DB_c);
294
295 FP_CONV(S, D, 1, 2, SR, DB);
296 goto pack_s;
297 }
298
299 case EFSCTSI:
300 case EFSCTUI:
301 if (SB_c == FP_CLS_NAN) {
302 vc.wp[1] = 0;
303 FP_SET_EXCEPTION(FP_EX_INVALID);
304 } else {
305 FP_TO_INT_ROUND_S(vc.wp[1], SB, 32,
306 ((func & 0x3) != 0) ? 1 : 0);
307 }
308 goto update_regs;
309
310 case EFSCTSIZ:
311 case EFSCTUIZ:
312 if (SB_c == FP_CLS_NAN) {
313 vc.wp[1] = 0;
314 FP_SET_EXCEPTION(FP_EX_INVALID);
315 } else {
316 FP_TO_INT_S(vc.wp[1], SB, 32,
317 ((func & 0x3) != 0) ? 1 : 0);
318 }
319 goto update_regs;
320
321 default:
322 goto illegal;
323 }
324 break;
325
326pack_s:
327 pr_debug("SR: %d %08x %d (%d)\n", SR_s, SR_f, SR_e, SR_c);
328
329 FP_PACK_SP(vc.wp + 1, SR);
330 goto update_regs;
331
332cmp_s:
333 FP_CMP_S(IR, SA, SB, 3);
334 if (IR == 3 && (FP_ISSIGNAN_S(SA) || FP_ISSIGNAN_S(SB)))
335 FP_SET_EXCEPTION(FP_EX_INVALID);
336 if (IR == cmp) {
337 IR = 0x4;
338 } else {
339 IR = 0;
340 }
341 goto update_ccr;
342 }
343
344 case DPFP: {
345 FP_DECL_D(DA); FP_DECL_D(DB); FP_DECL_D(DR);
346
347 switch (type) {
348 case AB:
349 case XCR:
350 FP_UNPACK_DP(DA, va.dp);
351 fallthrough;
352 case XB:
353 FP_UNPACK_DP(DB, vb.dp);
354 break;
355 case XA:
356 FP_UNPACK_DP(DA, va.dp);
357 break;
358 }
359
360 pr_debug("DA: %d %08x %08x %d (%d)\n",
361 DA_s, DA_f1, DA_f0, DA_e, DA_c);
362 pr_debug("DB: %d %08x %08x %d (%d)\n",
363 DB_s, DB_f1, DB_f0, DB_e, DB_c);
364
365 switch (func) {
366 case EFDABS:
367 vc.dp[0] = va.dp[0] & ~SIGN_BIT_D;
368 goto update_regs;
369
370 case EFDNABS:
371 vc.dp[0] = va.dp[0] | SIGN_BIT_D;
372 goto update_regs;
373
374 case EFDNEG:
375 vc.dp[0] = va.dp[0] ^ SIGN_BIT_D;
376 goto update_regs;
377
378 case EFDADD:
379 FP_ADD_D(DR, DA, DB);
380 goto pack_d;
381
382 case EFDSUB:
383 FP_SUB_D(DR, DA, DB);
384 goto pack_d;
385
386 case EFDMUL:
387 FP_MUL_D(DR, DA, DB);
388 goto pack_d;
389
390 case EFDDIV:
391 FP_DIV_D(DR, DA, DB);
392 goto pack_d;
393
394 case EFDCMPEQ:
395 cmp = 0;
396 goto cmp_d;
397
398 case EFDCMPGT:
399 cmp = 1;
400 goto cmp_d;
401
402 case EFDCMPLT:
403 cmp = -1;
404 goto cmp_d;
405
406 case EFDCTSF:
407 case EFDCTUF:
408 if (DB_c == FP_CLS_NAN) {
409 vc.wp[1] = 0;
410 FP_SET_EXCEPTION(FP_EX_INVALID);
411 } else {
412 DB_e += (func == EFDCTSF ? 31 : 32);
413 FP_TO_INT_ROUND_D(vc.wp[1], DB, 32,
414 (func == EFDCTSF) ? 1 : 0);
415 }
416 goto update_regs;
417
418 case EFDCFS: {
419 FP_DECL_S(SB);
420 FP_CLEAR_EXCEPTIONS;
421 FP_UNPACK_SP(SB, vb.wp + 1);
422
423 pr_debug("SB: %d %08x %d (%d)\n",
424 SB_s, SB_f, SB_e, SB_c);
425
426 FP_CONV(D, S, 2, 1, DR, SB);
427 goto pack_d;
428 }
429
430 case EFDCTUIDZ:
431 case EFDCTSIDZ:
432 if (DB_c == FP_CLS_NAN) {
433 vc.dp[0] = 0;
434 FP_SET_EXCEPTION(FP_EX_INVALID);
435 } else {
436 FP_TO_INT_D(vc.dp[0], DB, 64,
437 ((func & 0x1) == 0) ? 1 : 0);
438 }
439 goto update_regs;
440
441 case EFDCTUI:
442 case EFDCTSI:
443 if (DB_c == FP_CLS_NAN) {
444 vc.wp[1] = 0;
445 FP_SET_EXCEPTION(FP_EX_INVALID);
446 } else {
447 FP_TO_INT_ROUND_D(vc.wp[1], DB, 32,
448 ((func & 0x3) != 0) ? 1 : 0);
449 }
450 goto update_regs;
451
452 case EFDCTUIZ:
453 case EFDCTSIZ:
454 if (DB_c == FP_CLS_NAN) {
455 vc.wp[1] = 0;
456 FP_SET_EXCEPTION(FP_EX_INVALID);
457 } else {
458 FP_TO_INT_D(vc.wp[1], DB, 32,
459 ((func & 0x3) != 0) ? 1 : 0);
460 }
461 goto update_regs;
462
463 default:
464 goto illegal;
465 }
466 break;
467
468pack_d:
469 pr_debug("DR: %d %08x %08x %d (%d)\n",
470 DR_s, DR_f1, DR_f0, DR_e, DR_c);
471
472 FP_PACK_DP(vc.dp, DR);
473 goto update_regs;
474
475cmp_d:
476 FP_CMP_D(IR, DA, DB, 3);
477 if (IR == 3 && (FP_ISSIGNAN_D(DA) || FP_ISSIGNAN_D(DB)))
478 FP_SET_EXCEPTION(FP_EX_INVALID);
479 if (IR == cmp) {
480 IR = 0x4;
481 } else {
482 IR = 0;
483 }
484 goto update_ccr;
485
486 }
487
488 case VCT: {
489 FP_DECL_S(SA0); FP_DECL_S(SB0); FP_DECL_S(SR0);
490 FP_DECL_S(SA1); FP_DECL_S(SB1); FP_DECL_S(SR1);
491 int IR0, IR1;
492
493 switch (type) {
494 case AB:
495 case XCR:
496 FP_UNPACK_SP(SA0, va.wp);
497 FP_UNPACK_SP(SA1, va.wp + 1);
498 fallthrough;
499 case XB:
500 FP_UNPACK_SP(SB0, vb.wp);
501 FP_UNPACK_SP(SB1, vb.wp + 1);
502 break;
503 case XA:
504 FP_UNPACK_SP(SA0, va.wp);
505 FP_UNPACK_SP(SA1, va.wp + 1);
506 break;
507 }
508
509 pr_debug("SA0: %d %08x %d (%d)\n",
510 SA0_s, SA0_f, SA0_e, SA0_c);
511 pr_debug("SA1: %d %08x %d (%d)\n",
512 SA1_s, SA1_f, SA1_e, SA1_c);
513 pr_debug("SB0: %d %08x %d (%d)\n",
514 SB0_s, SB0_f, SB0_e, SB0_c);
515 pr_debug("SB1: %d %08x %d (%d)\n",
516 SB1_s, SB1_f, SB1_e, SB1_c);
517
518 switch (func) {
519 case EVFSABS:
520 vc.wp[0] = va.wp[0] & ~SIGN_BIT_S;
521 vc.wp[1] = va.wp[1] & ~SIGN_BIT_S;
522 goto update_regs;
523
524 case EVFSNABS:
525 vc.wp[0] = va.wp[0] | SIGN_BIT_S;
526 vc.wp[1] = va.wp[1] | SIGN_BIT_S;
527 goto update_regs;
528
529 case EVFSNEG:
530 vc.wp[0] = va.wp[0] ^ SIGN_BIT_S;
531 vc.wp[1] = va.wp[1] ^ SIGN_BIT_S;
532 goto update_regs;
533
534 case EVFSADD:
535 FP_ADD_S(SR0, SA0, SB0);
536 FP_ADD_S(SR1, SA1, SB1);
537 goto pack_vs;
538
539 case EVFSSUB:
540 FP_SUB_S(SR0, SA0, SB0);
541 FP_SUB_S(SR1, SA1, SB1);
542 goto pack_vs;
543
544 case EVFSMUL:
545 FP_MUL_S(SR0, SA0, SB0);
546 FP_MUL_S(SR1, SA1, SB1);
547 goto pack_vs;
548
549 case EVFSDIV:
550 FP_DIV_S(SR0, SA0, SB0);
551 FP_DIV_S(SR1, SA1, SB1);
552 goto pack_vs;
553
554 case EVFSCMPEQ:
555 cmp = 0;
556 goto cmp_vs;
557
558 case EVFSCMPGT:
559 cmp = 1;
560 goto cmp_vs;
561
562 case EVFSCMPLT:
563 cmp = -1;
564 goto cmp_vs;
565
566 case EVFSCTUF:
567 case EVFSCTSF:
568 if (SB0_c == FP_CLS_NAN) {
569 vc.wp[0] = 0;
570 FP_SET_EXCEPTION(FP_EX_INVALID);
571 } else {
572 SB0_e += (func == EVFSCTSF ? 31 : 32);
573 FP_TO_INT_ROUND_S(vc.wp[0], SB0, 32,
574 (func == EVFSCTSF) ? 1 : 0);
575 }
576 if (SB1_c == FP_CLS_NAN) {
577 vc.wp[1] = 0;
578 FP_SET_EXCEPTION(FP_EX_INVALID);
579 } else {
580 SB1_e += (func == EVFSCTSF ? 31 : 32);
581 FP_TO_INT_ROUND_S(vc.wp[1], SB1, 32,
582 (func == EVFSCTSF) ? 1 : 0);
583 }
584 goto update_regs;
585
586 case EVFSCTUI:
587 case EVFSCTSI:
588 if (SB0_c == FP_CLS_NAN) {
589 vc.wp[0] = 0;
590 FP_SET_EXCEPTION(FP_EX_INVALID);
591 } else {
592 FP_TO_INT_ROUND_S(vc.wp[0], SB0, 32,
593 ((func & 0x3) != 0) ? 1 : 0);
594 }
595 if (SB1_c == FP_CLS_NAN) {
596 vc.wp[1] = 0;
597 FP_SET_EXCEPTION(FP_EX_INVALID);
598 } else {
599 FP_TO_INT_ROUND_S(vc.wp[1], SB1, 32,
600 ((func & 0x3) != 0) ? 1 : 0);
601 }
602 goto update_regs;
603
604 case EVFSCTUIZ:
605 case EVFSCTSIZ:
606 if (SB0_c == FP_CLS_NAN) {
607 vc.wp[0] = 0;
608 FP_SET_EXCEPTION(FP_EX_INVALID);
609 } else {
610 FP_TO_INT_S(vc.wp[0], SB0, 32,
611 ((func & 0x3) != 0) ? 1 : 0);
612 }
613 if (SB1_c == FP_CLS_NAN) {
614 vc.wp[1] = 0;
615 FP_SET_EXCEPTION(FP_EX_INVALID);
616 } else {
617 FP_TO_INT_S(vc.wp[1], SB1, 32,
618 ((func & 0x3) != 0) ? 1 : 0);
619 }
620 goto update_regs;
621
622 default:
623 goto illegal;
624 }
625 break;
626
627pack_vs:
628 pr_debug("SR0: %d %08x %d (%d)\n",
629 SR0_s, SR0_f, SR0_e, SR0_c);
630 pr_debug("SR1: %d %08x %d (%d)\n",
631 SR1_s, SR1_f, SR1_e, SR1_c);
632
633 FP_PACK_SP(vc.wp, SR0);
634 FP_PACK_SP(vc.wp + 1, SR1);
635 goto update_regs;
636
637cmp_vs:
638 {
639 int ch, cl;
640
641 FP_CMP_S(IR0, SA0, SB0, 3);
642 FP_CMP_S(IR1, SA1, SB1, 3);
643 if (IR0 == 3 && (FP_ISSIGNAN_S(SA0) || FP_ISSIGNAN_S(SB0)))
644 FP_SET_EXCEPTION(FP_EX_INVALID);
645 if (IR1 == 3 && (FP_ISSIGNAN_S(SA1) || FP_ISSIGNAN_S(SB1)))
646 FP_SET_EXCEPTION(FP_EX_INVALID);
647 ch = (IR0 == cmp) ? 1 : 0;
648 cl = (IR1 == cmp) ? 1 : 0;
649 IR = (ch << 3) | (cl << 2) | ((ch | cl) << 1) |
650 ((ch & cl) << 0);
651 goto update_ccr;
652 }
653 }
654 default:
655 return -EINVAL;
656 }
657
658update_ccr:
659 regs->ccr &= ~(15 << ((7 - ((speinsn >> 23) & 0x7)) << 2));
660 regs->ccr |= (IR << ((7 - ((speinsn >> 23) & 0x7)) << 2));
661
662update_regs:
663 /*
664 * If the "invalid" exception sticky bit was set by the
665 * processor for non-finite input, but was not set before the
666 * instruction being emulated, clear it. Likewise for the
667 * "underflow" bit, which may have been set by the processor
668 * for exact underflow, not just inexact underflow when the
669 * flag should be set for IEEE 754 semantics. Other sticky
670 * exceptions will only be set by the processor when they are
671 * correct according to IEEE 754 semantics, and we must not
672 * clear sticky bits that were already set before the emulated
673 * instruction as they represent the user-visible sticky
674 * exception status. "inexact" traps to kernel are not
675 * required for IEEE semantics and are not enabled by default,
676 * so the "inexact" sticky bit may have been set by a previous
677 * instruction without the kernel being aware of it.
678 */
679 __FPU_FPSCR
680 &= ~(FP_EX_INVALID | FP_EX_UNDERFLOW) | current->thread.spefscr_last;
681 __FPU_FPSCR |= (FP_CUR_EXCEPTIONS & FP_EX_MASK);
682 mtspr(SPRN_SPEFSCR, __FPU_FPSCR);
683 current->thread.spefscr_last = __FPU_FPSCR;
684
685 current->thread.evr[fc] = vc.wp[0];
686 regs->gpr[fc] = vc.wp[1];
687
688 pr_debug("ccr = %08lx\n", regs->ccr);
689 pr_debug("cur exceptions = %08x spefscr = %08lx\n",
690 FP_CUR_EXCEPTIONS, __FPU_FPSCR);
691 pr_debug("vc: %08x %08x\n", vc.wp[0], vc.wp[1]);
692 pr_debug("va: %08x %08x\n", va.wp[0], va.wp[1]);
693 pr_debug("vb: %08x %08x\n", vb.wp[0], vb.wp[1]);
694
695 if (current->thread.fpexc_mode & PR_FP_EXC_SW_ENABLE) {
696 if ((FP_CUR_EXCEPTIONS & FP_EX_DIVZERO)
697 && (current->thread.fpexc_mode & PR_FP_EXC_DIV))
698 return 1;
699 if ((FP_CUR_EXCEPTIONS & FP_EX_OVERFLOW)
700 && (current->thread.fpexc_mode & PR_FP_EXC_OVF))
701 return 1;
702 if ((FP_CUR_EXCEPTIONS & FP_EX_UNDERFLOW)
703 && (current->thread.fpexc_mode & PR_FP_EXC_UND))
704 return 1;
705 if ((FP_CUR_EXCEPTIONS & FP_EX_INEXACT)
706 && (current->thread.fpexc_mode & PR_FP_EXC_RES))
707 return 1;
708 if ((FP_CUR_EXCEPTIONS & FP_EX_INVALID)
709 && (current->thread.fpexc_mode & PR_FP_EXC_INV))
710 return 1;
711 }
712 return 0;
713
714illegal:
715 if (have_e500_cpu_a005_erratum) {
716 /* according to e500 cpu a005 erratum, reissue efp inst */
717 regs_add_return_ip(regs, -4);
718 pr_debug("re-issue efp inst: %08lx\n", speinsn);
719 return 0;
720 }
721
722 printk(KERN_ERR "\nOoops! IEEE-754 compliance handler encountered un-supported instruction.\ninst code: %08lx\n", speinsn);
723 return -ENOSYS;
724}
725
726int speround_handler(struct pt_regs *regs)
727{
728 union dw_union fgpr;
729 int s_lo, s_hi;
730 int lo_inexact, hi_inexact;
731 int fp_result;
732 unsigned long speinsn, type, fb, fc, fptype, func;
733
734 if (get_user(speinsn, (unsigned int __user *) regs->nip))
735 return -EFAULT;
736 if ((speinsn >> 26) != 4)
737 return -EINVAL; /* not an spe instruction */
738
739 func = speinsn & 0x7ff;
740 type = insn_type(func);
741 if (type == XCR) return -ENOSYS;
742
743 __FPU_FPSCR = mfspr(SPRN_SPEFSCR);
744 pr_debug("speinsn:%08lx spefscr:%08lx\n", speinsn, __FPU_FPSCR);
745
746 fptype = (speinsn >> 5) & 0x7;
747
748 /* No need to round if the result is exact */
749 lo_inexact = __FPU_FPSCR & (SPEFSCR_FG | SPEFSCR_FX);
750 hi_inexact = __FPU_FPSCR & (SPEFSCR_FGH | SPEFSCR_FXH);
751 if (!(lo_inexact || (hi_inexact && fptype == VCT)))
752 return 0;
753
754 fc = (speinsn >> 21) & 0x1f;
755 s_lo = regs->gpr[fc] & SIGN_BIT_S;
756 s_hi = current->thread.evr[fc] & SIGN_BIT_S;
757 fgpr.wp[0] = current->thread.evr[fc];
758 fgpr.wp[1] = regs->gpr[fc];
759
760 fb = (speinsn >> 11) & 0x1f;
761 switch (func) {
762 case EFSCTUIZ:
763 case EFSCTSIZ:
764 case EVFSCTUIZ:
765 case EVFSCTSIZ:
766 case EFDCTUIDZ:
767 case EFDCTSIDZ:
768 case EFDCTUIZ:
769 case EFDCTSIZ:
770 /*
771 * These instructions always round to zero,
772 * independent of the rounding mode.
773 */
774 return 0;
775
776 case EFSCTUI:
777 case EFSCTUF:
778 case EVFSCTUI:
779 case EVFSCTUF:
780 case EFDCTUI:
781 case EFDCTUF:
782 fp_result = 0;
783 s_lo = 0;
784 s_hi = 0;
785 break;
786
787 case EFSCTSI:
788 case EFSCTSF:
789 fp_result = 0;
790 /* Recover the sign of a zero result if possible. */
791 if (fgpr.wp[1] == 0)
792 s_lo = regs->gpr[fb] & SIGN_BIT_S;
793 break;
794
795 case EVFSCTSI:
796 case EVFSCTSF:
797 fp_result = 0;
798 /* Recover the sign of a zero result if possible. */
799 if (fgpr.wp[1] == 0)
800 s_lo = regs->gpr[fb] & SIGN_BIT_S;
801 if (fgpr.wp[0] == 0)
802 s_hi = current->thread.evr[fb] & SIGN_BIT_S;
803 break;
804
805 case EFDCTSI:
806 case EFDCTSF:
807 fp_result = 0;
808 s_hi = s_lo;
809 /* Recover the sign of a zero result if possible. */
810 if (fgpr.wp[1] == 0)
811 s_hi = current->thread.evr[fb] & SIGN_BIT_S;
812 break;
813
814 default:
815 fp_result = 1;
816 break;
817 }
818
819 pr_debug("round fgpr: %08x %08x\n", fgpr.wp[0], fgpr.wp[1]);
820
821 switch (fptype) {
822 /* Since SPE instructions on E500 core can handle round to nearest
823 * and round toward zero with IEEE-754 complied, we just need
824 * to handle round toward +Inf and round toward -Inf by software.
825 */
826 case SPFP:
827 if ((FP_ROUNDMODE) == FP_RND_PINF) {
828 if (!s_lo) fgpr.wp[1]++; /* Z > 0, choose Z1 */
829 } else { /* round to -Inf */
830 if (s_lo) {
831 if (fp_result)
832 fgpr.wp[1]++; /* Z < 0, choose Z2 */
833 else
834 fgpr.wp[1]--; /* Z < 0, choose Z2 */
835 }
836 }
837 break;
838
839 case DPFP:
840 if (FP_ROUNDMODE == FP_RND_PINF) {
841 if (!s_hi) {
842 if (fp_result)
843 fgpr.dp[0]++; /* Z > 0, choose Z1 */
844 else
845 fgpr.wp[1]++; /* Z > 0, choose Z1 */
846 }
847 } else { /* round to -Inf */
848 if (s_hi) {
849 if (fp_result)
850 fgpr.dp[0]++; /* Z < 0, choose Z2 */
851 else
852 fgpr.wp[1]--; /* Z < 0, choose Z2 */
853 }
854 }
855 break;
856
857 case VCT:
858 if (FP_ROUNDMODE == FP_RND_PINF) {
859 if (lo_inexact && !s_lo)
860 fgpr.wp[1]++; /* Z_low > 0, choose Z1 */
861 if (hi_inexact && !s_hi)
862 fgpr.wp[0]++; /* Z_high word > 0, choose Z1 */
863 } else { /* round to -Inf */
864 if (lo_inexact && s_lo) {
865 if (fp_result)
866 fgpr.wp[1]++; /* Z_low < 0, choose Z2 */
867 else
868 fgpr.wp[1]--; /* Z_low < 0, choose Z2 */
869 }
870 if (hi_inexact && s_hi) {
871 if (fp_result)
872 fgpr.wp[0]++; /* Z_high < 0, choose Z2 */
873 else
874 fgpr.wp[0]--; /* Z_high < 0, choose Z2 */
875 }
876 }
877 break;
878
879 default:
880 return -EINVAL;
881 }
882
883 current->thread.evr[fc] = fgpr.wp[0];
884 regs->gpr[fc] = fgpr.wp[1];
885
886 pr_debug(" to fgpr: %08x %08x\n", fgpr.wp[0], fgpr.wp[1]);
887
888 if (current->thread.fpexc_mode & PR_FP_EXC_SW_ENABLE)
889 return (current->thread.fpexc_mode & PR_FP_EXC_RES) ? 1 : 0;
890 return 0;
891}
892
893static int __init spe_mathemu_init(void)
894{
895 u32 pvr, maj, min;
896
897 pvr = mfspr(SPRN_PVR);
898
899 if ((PVR_VER(pvr) == PVR_VER_E500V1) ||
900 (PVR_VER(pvr) == PVR_VER_E500V2)) {
901 maj = PVR_MAJ(pvr);
902 min = PVR_MIN(pvr);
903
904 /*
905 * E500 revision below 1.1, 2.3, 3.1, 4.1, 5.1
906 * need cpu a005 errata workaround
907 */
908 switch (maj) {
909 case 1:
910 if (min < 1)
911 have_e500_cpu_a005_erratum = 1;
912 break;
913 case 2:
914 if (min < 3)
915 have_e500_cpu_a005_erratum = 1;
916 break;
917 case 3:
918 case 4:
919 case 5:
920 if (min < 1)
921 have_e500_cpu_a005_erratum = 1;
922 break;
923 default:
924 break;
925 }
926 }
927
928 return 0;
929}
930
931module_init(spe_mathemu_init);
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * arch/powerpc/math-emu/math_efp.c
4 *
5 * Copyright (C) 2006-2008, 2010 Freescale Semiconductor, Inc.
6 *
7 * Author: Ebony Zhu, <ebony.zhu@freescale.com>
8 * Yu Liu, <yu.liu@freescale.com>
9 *
10 * Derived from arch/alpha/math-emu/math.c
11 * arch/powerpc/math-emu/math.c
12 *
13 * Description:
14 * This file is the exception handler to make E500 SPE instructions
15 * fully comply with IEEE-754 floating point standard.
16 */
17
18#include <linux/types.h>
19#include <linux/prctl.h>
20
21#include <linux/uaccess.h>
22#include <asm/reg.h>
23
24#define FP_EX_BOOKE_E500_SPE
25#include <asm/sfp-machine.h>
26
27#include <math-emu/soft-fp.h>
28#include <math-emu/single.h>
29#include <math-emu/double.h>
30
31#define EFAPU 0x4
32
33#define VCT 0x4
34#define SPFP 0x6
35#define DPFP 0x7
36
37#define EFSADD 0x2c0
38#define EFSSUB 0x2c1
39#define EFSABS 0x2c4
40#define EFSNABS 0x2c5
41#define EFSNEG 0x2c6
42#define EFSMUL 0x2c8
43#define EFSDIV 0x2c9
44#define EFSCMPGT 0x2cc
45#define EFSCMPLT 0x2cd
46#define EFSCMPEQ 0x2ce
47#define EFSCFD 0x2cf
48#define EFSCFSI 0x2d1
49#define EFSCTUI 0x2d4
50#define EFSCTSI 0x2d5
51#define EFSCTUF 0x2d6
52#define EFSCTSF 0x2d7
53#define EFSCTUIZ 0x2d8
54#define EFSCTSIZ 0x2da
55
56#define EVFSADD 0x280
57#define EVFSSUB 0x281
58#define EVFSABS 0x284
59#define EVFSNABS 0x285
60#define EVFSNEG 0x286
61#define EVFSMUL 0x288
62#define EVFSDIV 0x289
63#define EVFSCMPGT 0x28c
64#define EVFSCMPLT 0x28d
65#define EVFSCMPEQ 0x28e
66#define EVFSCTUI 0x294
67#define EVFSCTSI 0x295
68#define EVFSCTUF 0x296
69#define EVFSCTSF 0x297
70#define EVFSCTUIZ 0x298
71#define EVFSCTSIZ 0x29a
72
73#define EFDADD 0x2e0
74#define EFDSUB 0x2e1
75#define EFDABS 0x2e4
76#define EFDNABS 0x2e5
77#define EFDNEG 0x2e6
78#define EFDMUL 0x2e8
79#define EFDDIV 0x2e9
80#define EFDCTUIDZ 0x2ea
81#define EFDCTSIDZ 0x2eb
82#define EFDCMPGT 0x2ec
83#define EFDCMPLT 0x2ed
84#define EFDCMPEQ 0x2ee
85#define EFDCFS 0x2ef
86#define EFDCTUI 0x2f4
87#define EFDCTSI 0x2f5
88#define EFDCTUF 0x2f6
89#define EFDCTSF 0x2f7
90#define EFDCTUIZ 0x2f8
91#define EFDCTSIZ 0x2fa
92
93#define AB 2
94#define XA 3
95#define XB 4
96#define XCR 5
97#define NOTYPE 0
98
99#define SIGN_BIT_S (1UL << 31)
100#define SIGN_BIT_D (1ULL << 63)
101#define FP_EX_MASK (FP_EX_INEXACT | FP_EX_INVALID | FP_EX_DIVZERO | \
102 FP_EX_UNDERFLOW | FP_EX_OVERFLOW)
103
104static int have_e500_cpu_a005_erratum;
105
106union dw_union {
107 u64 dp[1];
108 u32 wp[2];
109};
110
111static unsigned long insn_type(unsigned long speinsn)
112{
113 unsigned long ret = NOTYPE;
114
115 switch (speinsn & 0x7ff) {
116 case EFSABS: ret = XA; break;
117 case EFSADD: ret = AB; break;
118 case EFSCFD: ret = XB; break;
119 case EFSCMPEQ: ret = XCR; break;
120 case EFSCMPGT: ret = XCR; break;
121 case EFSCMPLT: ret = XCR; break;
122 case EFSCTSF: ret = XB; break;
123 case EFSCTSI: ret = XB; break;
124 case EFSCTSIZ: ret = XB; break;
125 case EFSCTUF: ret = XB; break;
126 case EFSCTUI: ret = XB; break;
127 case EFSCTUIZ: ret = XB; break;
128 case EFSDIV: ret = AB; break;
129 case EFSMUL: ret = AB; break;
130 case EFSNABS: ret = XA; break;
131 case EFSNEG: ret = XA; break;
132 case EFSSUB: ret = AB; break;
133 case EFSCFSI: ret = XB; break;
134
135 case EVFSABS: ret = XA; break;
136 case EVFSADD: ret = AB; break;
137 case EVFSCMPEQ: ret = XCR; break;
138 case EVFSCMPGT: ret = XCR; break;
139 case EVFSCMPLT: ret = XCR; break;
140 case EVFSCTSF: ret = XB; break;
141 case EVFSCTSI: ret = XB; break;
142 case EVFSCTSIZ: ret = XB; break;
143 case EVFSCTUF: ret = XB; break;
144 case EVFSCTUI: ret = XB; break;
145 case EVFSCTUIZ: ret = XB; break;
146 case EVFSDIV: ret = AB; break;
147 case EVFSMUL: ret = AB; break;
148 case EVFSNABS: ret = XA; break;
149 case EVFSNEG: ret = XA; break;
150 case EVFSSUB: ret = AB; break;
151
152 case EFDABS: ret = XA; break;
153 case EFDADD: ret = AB; break;
154 case EFDCFS: ret = XB; break;
155 case EFDCMPEQ: ret = XCR; break;
156 case EFDCMPGT: ret = XCR; break;
157 case EFDCMPLT: ret = XCR; break;
158 case EFDCTSF: ret = XB; break;
159 case EFDCTSI: ret = XB; break;
160 case EFDCTSIDZ: ret = XB; break;
161 case EFDCTSIZ: ret = XB; break;
162 case EFDCTUF: ret = XB; break;
163 case EFDCTUI: ret = XB; break;
164 case EFDCTUIDZ: ret = XB; break;
165 case EFDCTUIZ: ret = XB; break;
166 case EFDDIV: ret = AB; break;
167 case EFDMUL: ret = AB; break;
168 case EFDNABS: ret = XA; break;
169 case EFDNEG: ret = XA; break;
170 case EFDSUB: ret = AB; break;
171 }
172
173 return ret;
174}
175
176int do_spe_mathemu(struct pt_regs *regs)
177{
178 FP_DECL_EX;
179 int IR, cmp;
180
181 unsigned long type, func, fc, fa, fb, src, speinsn;
182 union dw_union vc, va, vb;
183
184 if (get_user(speinsn, (unsigned int __user *) regs->nip))
185 return -EFAULT;
186 if ((speinsn >> 26) != EFAPU)
187 return -EINVAL; /* not an spe instruction */
188
189 type = insn_type(speinsn);
190 if (type == NOTYPE)
191 goto illegal;
192
193 func = speinsn & 0x7ff;
194 fc = (speinsn >> 21) & 0x1f;
195 fa = (speinsn >> 16) & 0x1f;
196 fb = (speinsn >> 11) & 0x1f;
197 src = (speinsn >> 5) & 0x7;
198
199 vc.wp[0] = current->thread.evr[fc];
200 vc.wp[1] = regs->gpr[fc];
201 va.wp[0] = current->thread.evr[fa];
202 va.wp[1] = regs->gpr[fa];
203 vb.wp[0] = current->thread.evr[fb];
204 vb.wp[1] = regs->gpr[fb];
205
206 __FPU_FPSCR = mfspr(SPRN_SPEFSCR);
207
208 pr_debug("speinsn:%08lx spefscr:%08lx\n", speinsn, __FPU_FPSCR);
209 pr_debug("vc: %08x %08x\n", vc.wp[0], vc.wp[1]);
210 pr_debug("va: %08x %08x\n", va.wp[0], va.wp[1]);
211 pr_debug("vb: %08x %08x\n", vb.wp[0], vb.wp[1]);
212
213 switch (src) {
214 case SPFP: {
215 FP_DECL_S(SA); FP_DECL_S(SB); FP_DECL_S(SR);
216
217 switch (type) {
218 case AB:
219 case XCR:
220 FP_UNPACK_SP(SA, va.wp + 1);
221 case XB:
222 FP_UNPACK_SP(SB, vb.wp + 1);
223 break;
224 case XA:
225 FP_UNPACK_SP(SA, va.wp + 1);
226 break;
227 }
228
229 pr_debug("SA: %ld %08lx %ld (%ld)\n", SA_s, SA_f, SA_e, SA_c);
230 pr_debug("SB: %ld %08lx %ld (%ld)\n", SB_s, SB_f, SB_e, SB_c);
231
232 switch (func) {
233 case EFSABS:
234 vc.wp[1] = va.wp[1] & ~SIGN_BIT_S;
235 goto update_regs;
236
237 case EFSNABS:
238 vc.wp[1] = va.wp[1] | SIGN_BIT_S;
239 goto update_regs;
240
241 case EFSNEG:
242 vc.wp[1] = va.wp[1] ^ SIGN_BIT_S;
243 goto update_regs;
244
245 case EFSADD:
246 FP_ADD_S(SR, SA, SB);
247 goto pack_s;
248
249 case EFSSUB:
250 FP_SUB_S(SR, SA, SB);
251 goto pack_s;
252
253 case EFSMUL:
254 FP_MUL_S(SR, SA, SB);
255 goto pack_s;
256
257 case EFSDIV:
258 FP_DIV_S(SR, SA, SB);
259 goto pack_s;
260
261 case EFSCMPEQ:
262 cmp = 0;
263 goto cmp_s;
264
265 case EFSCMPGT:
266 cmp = 1;
267 goto cmp_s;
268
269 case EFSCMPLT:
270 cmp = -1;
271 goto cmp_s;
272
273 case EFSCTSF:
274 case EFSCTUF:
275 if (SB_c == FP_CLS_NAN) {
276 vc.wp[1] = 0;
277 FP_SET_EXCEPTION(FP_EX_INVALID);
278 } else {
279 SB_e += (func == EFSCTSF ? 31 : 32);
280 FP_TO_INT_ROUND_S(vc.wp[1], SB, 32,
281 (func == EFSCTSF));
282 }
283 goto update_regs;
284
285 case EFSCFD: {
286 FP_DECL_D(DB);
287 FP_CLEAR_EXCEPTIONS;
288 FP_UNPACK_DP(DB, vb.dp);
289
290 pr_debug("DB: %ld %08lx %08lx %ld (%ld)\n",
291 DB_s, DB_f1, DB_f0, DB_e, DB_c);
292
293 FP_CONV(S, D, 1, 2, SR, DB);
294 goto pack_s;
295 }
296
297 case EFSCTSI:
298 case EFSCTUI:
299 if (SB_c == FP_CLS_NAN) {
300 vc.wp[1] = 0;
301 FP_SET_EXCEPTION(FP_EX_INVALID);
302 } else {
303 FP_TO_INT_ROUND_S(vc.wp[1], SB, 32,
304 ((func & 0x3) != 0));
305 }
306 goto update_regs;
307
308 case EFSCTSIZ:
309 case EFSCTUIZ:
310 if (SB_c == FP_CLS_NAN) {
311 vc.wp[1] = 0;
312 FP_SET_EXCEPTION(FP_EX_INVALID);
313 } else {
314 FP_TO_INT_S(vc.wp[1], SB, 32,
315 ((func & 0x3) != 0));
316 }
317 goto update_regs;
318
319 default:
320 goto illegal;
321 }
322 break;
323
324pack_s:
325 pr_debug("SR: %ld %08lx %ld (%ld)\n", SR_s, SR_f, SR_e, SR_c);
326
327 FP_PACK_SP(vc.wp + 1, SR);
328 goto update_regs;
329
330cmp_s:
331 FP_CMP_S(IR, SA, SB, 3);
332 if (IR == 3 && (FP_ISSIGNAN_S(SA) || FP_ISSIGNAN_S(SB)))
333 FP_SET_EXCEPTION(FP_EX_INVALID);
334 if (IR == cmp) {
335 IR = 0x4;
336 } else {
337 IR = 0;
338 }
339 goto update_ccr;
340 }
341
342 case DPFP: {
343 FP_DECL_D(DA); FP_DECL_D(DB); FP_DECL_D(DR);
344
345 switch (type) {
346 case AB:
347 case XCR:
348 FP_UNPACK_DP(DA, va.dp);
349 case XB:
350 FP_UNPACK_DP(DB, vb.dp);
351 break;
352 case XA:
353 FP_UNPACK_DP(DA, va.dp);
354 break;
355 }
356
357 pr_debug("DA: %ld %08lx %08lx %ld (%ld)\n",
358 DA_s, DA_f1, DA_f0, DA_e, DA_c);
359 pr_debug("DB: %ld %08lx %08lx %ld (%ld)\n",
360 DB_s, DB_f1, DB_f0, DB_e, DB_c);
361
362 switch (func) {
363 case EFDABS:
364 vc.dp[0] = va.dp[0] & ~SIGN_BIT_D;
365 goto update_regs;
366
367 case EFDNABS:
368 vc.dp[0] = va.dp[0] | SIGN_BIT_D;
369 goto update_regs;
370
371 case EFDNEG:
372 vc.dp[0] = va.dp[0] ^ SIGN_BIT_D;
373 goto update_regs;
374
375 case EFDADD:
376 FP_ADD_D(DR, DA, DB);
377 goto pack_d;
378
379 case EFDSUB:
380 FP_SUB_D(DR, DA, DB);
381 goto pack_d;
382
383 case EFDMUL:
384 FP_MUL_D(DR, DA, DB);
385 goto pack_d;
386
387 case EFDDIV:
388 FP_DIV_D(DR, DA, DB);
389 goto pack_d;
390
391 case EFDCMPEQ:
392 cmp = 0;
393 goto cmp_d;
394
395 case EFDCMPGT:
396 cmp = 1;
397 goto cmp_d;
398
399 case EFDCMPLT:
400 cmp = -1;
401 goto cmp_d;
402
403 case EFDCTSF:
404 case EFDCTUF:
405 if (DB_c == FP_CLS_NAN) {
406 vc.wp[1] = 0;
407 FP_SET_EXCEPTION(FP_EX_INVALID);
408 } else {
409 DB_e += (func == EFDCTSF ? 31 : 32);
410 FP_TO_INT_ROUND_D(vc.wp[1], DB, 32,
411 (func == EFDCTSF));
412 }
413 goto update_regs;
414
415 case EFDCFS: {
416 FP_DECL_S(SB);
417 FP_CLEAR_EXCEPTIONS;
418 FP_UNPACK_SP(SB, vb.wp + 1);
419
420 pr_debug("SB: %ld %08lx %ld (%ld)\n",
421 SB_s, SB_f, SB_e, SB_c);
422
423 FP_CONV(D, S, 2, 1, DR, SB);
424 goto pack_d;
425 }
426
427 case EFDCTUIDZ:
428 case EFDCTSIDZ:
429 if (DB_c == FP_CLS_NAN) {
430 vc.dp[0] = 0;
431 FP_SET_EXCEPTION(FP_EX_INVALID);
432 } else {
433 FP_TO_INT_D(vc.dp[0], DB, 64,
434 ((func & 0x1) == 0));
435 }
436 goto update_regs;
437
438 case EFDCTUI:
439 case EFDCTSI:
440 if (DB_c == FP_CLS_NAN) {
441 vc.wp[1] = 0;
442 FP_SET_EXCEPTION(FP_EX_INVALID);
443 } else {
444 FP_TO_INT_ROUND_D(vc.wp[1], DB, 32,
445 ((func & 0x3) != 0));
446 }
447 goto update_regs;
448
449 case EFDCTUIZ:
450 case EFDCTSIZ:
451 if (DB_c == FP_CLS_NAN) {
452 vc.wp[1] = 0;
453 FP_SET_EXCEPTION(FP_EX_INVALID);
454 } else {
455 FP_TO_INT_D(vc.wp[1], DB, 32,
456 ((func & 0x3) != 0));
457 }
458 goto update_regs;
459
460 default:
461 goto illegal;
462 }
463 break;
464
465pack_d:
466 pr_debug("DR: %ld %08lx %08lx %ld (%ld)\n",
467 DR_s, DR_f1, DR_f0, DR_e, DR_c);
468
469 FP_PACK_DP(vc.dp, DR);
470 goto update_regs;
471
472cmp_d:
473 FP_CMP_D(IR, DA, DB, 3);
474 if (IR == 3 && (FP_ISSIGNAN_D(DA) || FP_ISSIGNAN_D(DB)))
475 FP_SET_EXCEPTION(FP_EX_INVALID);
476 if (IR == cmp) {
477 IR = 0x4;
478 } else {
479 IR = 0;
480 }
481 goto update_ccr;
482
483 }
484
485 case VCT: {
486 FP_DECL_S(SA0); FP_DECL_S(SB0); FP_DECL_S(SR0);
487 FP_DECL_S(SA1); FP_DECL_S(SB1); FP_DECL_S(SR1);
488 int IR0, IR1;
489
490 switch (type) {
491 case AB:
492 case XCR:
493 FP_UNPACK_SP(SA0, va.wp);
494 FP_UNPACK_SP(SA1, va.wp + 1);
495 case XB:
496 FP_UNPACK_SP(SB0, vb.wp);
497 FP_UNPACK_SP(SB1, vb.wp + 1);
498 break;
499 case XA:
500 FP_UNPACK_SP(SA0, va.wp);
501 FP_UNPACK_SP(SA1, va.wp + 1);
502 break;
503 }
504
505 pr_debug("SA0: %ld %08lx %ld (%ld)\n",
506 SA0_s, SA0_f, SA0_e, SA0_c);
507 pr_debug("SA1: %ld %08lx %ld (%ld)\n",
508 SA1_s, SA1_f, SA1_e, SA1_c);
509 pr_debug("SB0: %ld %08lx %ld (%ld)\n",
510 SB0_s, SB0_f, SB0_e, SB0_c);
511 pr_debug("SB1: %ld %08lx %ld (%ld)\n",
512 SB1_s, SB1_f, SB1_e, SB1_c);
513
514 switch (func) {
515 case EVFSABS:
516 vc.wp[0] = va.wp[0] & ~SIGN_BIT_S;
517 vc.wp[1] = va.wp[1] & ~SIGN_BIT_S;
518 goto update_regs;
519
520 case EVFSNABS:
521 vc.wp[0] = va.wp[0] | SIGN_BIT_S;
522 vc.wp[1] = va.wp[1] | SIGN_BIT_S;
523 goto update_regs;
524
525 case EVFSNEG:
526 vc.wp[0] = va.wp[0] ^ SIGN_BIT_S;
527 vc.wp[1] = va.wp[1] ^ SIGN_BIT_S;
528 goto update_regs;
529
530 case EVFSADD:
531 FP_ADD_S(SR0, SA0, SB0);
532 FP_ADD_S(SR1, SA1, SB1);
533 goto pack_vs;
534
535 case EVFSSUB:
536 FP_SUB_S(SR0, SA0, SB0);
537 FP_SUB_S(SR1, SA1, SB1);
538 goto pack_vs;
539
540 case EVFSMUL:
541 FP_MUL_S(SR0, SA0, SB0);
542 FP_MUL_S(SR1, SA1, SB1);
543 goto pack_vs;
544
545 case EVFSDIV:
546 FP_DIV_S(SR0, SA0, SB0);
547 FP_DIV_S(SR1, SA1, SB1);
548 goto pack_vs;
549
550 case EVFSCMPEQ:
551 cmp = 0;
552 goto cmp_vs;
553
554 case EVFSCMPGT:
555 cmp = 1;
556 goto cmp_vs;
557
558 case EVFSCMPLT:
559 cmp = -1;
560 goto cmp_vs;
561
562 case EVFSCTUF:
563 case EVFSCTSF:
564 if (SB0_c == FP_CLS_NAN) {
565 vc.wp[0] = 0;
566 FP_SET_EXCEPTION(FP_EX_INVALID);
567 } else {
568 SB0_e += (func == EVFSCTSF ? 31 : 32);
569 FP_TO_INT_ROUND_S(vc.wp[0], SB0, 32,
570 (func == EVFSCTSF));
571 }
572 if (SB1_c == FP_CLS_NAN) {
573 vc.wp[1] = 0;
574 FP_SET_EXCEPTION(FP_EX_INVALID);
575 } else {
576 SB1_e += (func == EVFSCTSF ? 31 : 32);
577 FP_TO_INT_ROUND_S(vc.wp[1], SB1, 32,
578 (func == EVFSCTSF));
579 }
580 goto update_regs;
581
582 case EVFSCTUI:
583 case EVFSCTSI:
584 if (SB0_c == FP_CLS_NAN) {
585 vc.wp[0] = 0;
586 FP_SET_EXCEPTION(FP_EX_INVALID);
587 } else {
588 FP_TO_INT_ROUND_S(vc.wp[0], SB0, 32,
589 ((func & 0x3) != 0));
590 }
591 if (SB1_c == FP_CLS_NAN) {
592 vc.wp[1] = 0;
593 FP_SET_EXCEPTION(FP_EX_INVALID);
594 } else {
595 FP_TO_INT_ROUND_S(vc.wp[1], SB1, 32,
596 ((func & 0x3) != 0));
597 }
598 goto update_regs;
599
600 case EVFSCTUIZ:
601 case EVFSCTSIZ:
602 if (SB0_c == FP_CLS_NAN) {
603 vc.wp[0] = 0;
604 FP_SET_EXCEPTION(FP_EX_INVALID);
605 } else {
606 FP_TO_INT_S(vc.wp[0], SB0, 32,
607 ((func & 0x3) != 0));
608 }
609 if (SB1_c == FP_CLS_NAN) {
610 vc.wp[1] = 0;
611 FP_SET_EXCEPTION(FP_EX_INVALID);
612 } else {
613 FP_TO_INT_S(vc.wp[1], SB1, 32,
614 ((func & 0x3) != 0));
615 }
616 goto update_regs;
617
618 default:
619 goto illegal;
620 }
621 break;
622
623pack_vs:
624 pr_debug("SR0: %ld %08lx %ld (%ld)\n",
625 SR0_s, SR0_f, SR0_e, SR0_c);
626 pr_debug("SR1: %ld %08lx %ld (%ld)\n",
627 SR1_s, SR1_f, SR1_e, SR1_c);
628
629 FP_PACK_SP(vc.wp, SR0);
630 FP_PACK_SP(vc.wp + 1, SR1);
631 goto update_regs;
632
633cmp_vs:
634 {
635 int ch, cl;
636
637 FP_CMP_S(IR0, SA0, SB0, 3);
638 FP_CMP_S(IR1, SA1, SB1, 3);
639 if (IR0 == 3 && (FP_ISSIGNAN_S(SA0) || FP_ISSIGNAN_S(SB0)))
640 FP_SET_EXCEPTION(FP_EX_INVALID);
641 if (IR1 == 3 && (FP_ISSIGNAN_S(SA1) || FP_ISSIGNAN_S(SB1)))
642 FP_SET_EXCEPTION(FP_EX_INVALID);
643 ch = (IR0 == cmp) ? 1 : 0;
644 cl = (IR1 == cmp) ? 1 : 0;
645 IR = (ch << 3) | (cl << 2) | ((ch | cl) << 1) |
646 ((ch & cl) << 0);
647 goto update_ccr;
648 }
649 }
650 default:
651 return -EINVAL;
652 }
653
654update_ccr:
655 regs->ccr &= ~(15 << ((7 - ((speinsn >> 23) & 0x7)) << 2));
656 regs->ccr |= (IR << ((7 - ((speinsn >> 23) & 0x7)) << 2));
657
658update_regs:
659 /*
660 * If the "invalid" exception sticky bit was set by the
661 * processor for non-finite input, but was not set before the
662 * instruction being emulated, clear it. Likewise for the
663 * "underflow" bit, which may have been set by the processor
664 * for exact underflow, not just inexact underflow when the
665 * flag should be set for IEEE 754 semantics. Other sticky
666 * exceptions will only be set by the processor when they are
667 * correct according to IEEE 754 semantics, and we must not
668 * clear sticky bits that were already set before the emulated
669 * instruction as they represent the user-visible sticky
670 * exception status. "inexact" traps to kernel are not
671 * required for IEEE semantics and are not enabled by default,
672 * so the "inexact" sticky bit may have been set by a previous
673 * instruction without the kernel being aware of it.
674 */
675 __FPU_FPSCR
676 &= ~(FP_EX_INVALID | FP_EX_UNDERFLOW) | current->thread.spefscr_last;
677 __FPU_FPSCR |= (FP_CUR_EXCEPTIONS & FP_EX_MASK);
678 mtspr(SPRN_SPEFSCR, __FPU_FPSCR);
679 current->thread.spefscr_last = __FPU_FPSCR;
680
681 current->thread.evr[fc] = vc.wp[0];
682 regs->gpr[fc] = vc.wp[1];
683
684 pr_debug("ccr = %08lx\n", regs->ccr);
685 pr_debug("cur exceptions = %08x spefscr = %08lx\n",
686 FP_CUR_EXCEPTIONS, __FPU_FPSCR);
687 pr_debug("vc: %08x %08x\n", vc.wp[0], vc.wp[1]);
688 pr_debug("va: %08x %08x\n", va.wp[0], va.wp[1]);
689 pr_debug("vb: %08x %08x\n", vb.wp[0], vb.wp[1]);
690
691 if (current->thread.fpexc_mode & PR_FP_EXC_SW_ENABLE) {
692 if ((FP_CUR_EXCEPTIONS & FP_EX_DIVZERO)
693 && (current->thread.fpexc_mode & PR_FP_EXC_DIV))
694 return 1;
695 if ((FP_CUR_EXCEPTIONS & FP_EX_OVERFLOW)
696 && (current->thread.fpexc_mode & PR_FP_EXC_OVF))
697 return 1;
698 if ((FP_CUR_EXCEPTIONS & FP_EX_UNDERFLOW)
699 && (current->thread.fpexc_mode & PR_FP_EXC_UND))
700 return 1;
701 if ((FP_CUR_EXCEPTIONS & FP_EX_INEXACT)
702 && (current->thread.fpexc_mode & PR_FP_EXC_RES))
703 return 1;
704 if ((FP_CUR_EXCEPTIONS & FP_EX_INVALID)
705 && (current->thread.fpexc_mode & PR_FP_EXC_INV))
706 return 1;
707 }
708 return 0;
709
710illegal:
711 if (have_e500_cpu_a005_erratum) {
712 /* according to e500 cpu a005 erratum, reissue efp inst */
713 regs_add_return_ip(regs, -4);
714 pr_debug("re-issue efp inst: %08lx\n", speinsn);
715 return 0;
716 }
717
718 printk(KERN_ERR "\nOoops! IEEE-754 compliance handler encountered un-supported instruction.\ninst code: %08lx\n", speinsn);
719 return -ENOSYS;
720}
721
722int speround_handler(struct pt_regs *regs)
723{
724 union dw_union fgpr;
725 int s_lo, s_hi;
726 int lo_inexact, hi_inexact;
727 int fp_result;
728 unsigned long speinsn, type, fb, fc, fptype, func;
729
730 if (get_user(speinsn, (unsigned int __user *) regs->nip))
731 return -EFAULT;
732 if ((speinsn >> 26) != 4)
733 return -EINVAL; /* not an spe instruction */
734
735 func = speinsn & 0x7ff;
736 type = insn_type(func);
737 if (type == XCR) return -ENOSYS;
738
739 __FPU_FPSCR = mfspr(SPRN_SPEFSCR);
740 pr_debug("speinsn:%08lx spefscr:%08lx\n", speinsn, __FPU_FPSCR);
741
742 fptype = (speinsn >> 5) & 0x7;
743
744 /* No need to round if the result is exact */
745 lo_inexact = __FPU_FPSCR & (SPEFSCR_FG | SPEFSCR_FX);
746 hi_inexact = __FPU_FPSCR & (SPEFSCR_FGH | SPEFSCR_FXH);
747 if (!(lo_inexact || (hi_inexact && fptype == VCT)))
748 return 0;
749
750 fc = (speinsn >> 21) & 0x1f;
751 s_lo = regs->gpr[fc] & SIGN_BIT_S;
752 s_hi = current->thread.evr[fc] & SIGN_BIT_S;
753 fgpr.wp[0] = current->thread.evr[fc];
754 fgpr.wp[1] = regs->gpr[fc];
755
756 fb = (speinsn >> 11) & 0x1f;
757 switch (func) {
758 case EFSCTUIZ:
759 case EFSCTSIZ:
760 case EVFSCTUIZ:
761 case EVFSCTSIZ:
762 case EFDCTUIDZ:
763 case EFDCTSIDZ:
764 case EFDCTUIZ:
765 case EFDCTSIZ:
766 /*
767 * These instructions always round to zero,
768 * independent of the rounding mode.
769 */
770 return 0;
771
772 case EFSCTUI:
773 case EFSCTUF:
774 case EVFSCTUI:
775 case EVFSCTUF:
776 case EFDCTUI:
777 case EFDCTUF:
778 fp_result = 0;
779 s_lo = 0;
780 s_hi = 0;
781 break;
782
783 case EFSCTSI:
784 case EFSCTSF:
785 fp_result = 0;
786 /* Recover the sign of a zero result if possible. */
787 if (fgpr.wp[1] == 0)
788 s_lo = regs->gpr[fb] & SIGN_BIT_S;
789 break;
790
791 case EVFSCTSI:
792 case EVFSCTSF:
793 fp_result = 0;
794 /* Recover the sign of a zero result if possible. */
795 if (fgpr.wp[1] == 0)
796 s_lo = regs->gpr[fb] & SIGN_BIT_S;
797 if (fgpr.wp[0] == 0)
798 s_hi = current->thread.evr[fb] & SIGN_BIT_S;
799 break;
800
801 case EFDCTSI:
802 case EFDCTSF:
803 fp_result = 0;
804 s_hi = s_lo;
805 /* Recover the sign of a zero result if possible. */
806 if (fgpr.wp[1] == 0)
807 s_hi = current->thread.evr[fb] & SIGN_BIT_S;
808 break;
809
810 default:
811 fp_result = 1;
812 break;
813 }
814
815 pr_debug("round fgpr: %08x %08x\n", fgpr.wp[0], fgpr.wp[1]);
816
817 switch (fptype) {
818 /* Since SPE instructions on E500 core can handle round to nearest
819 * and round toward zero with IEEE-754 complied, we just need
820 * to handle round toward +Inf and round toward -Inf by software.
821 */
822 case SPFP:
823 if ((FP_ROUNDMODE) == FP_RND_PINF) {
824 if (!s_lo) fgpr.wp[1]++; /* Z > 0, choose Z1 */
825 } else { /* round to -Inf */
826 if (s_lo) {
827 if (fp_result)
828 fgpr.wp[1]++; /* Z < 0, choose Z2 */
829 else
830 fgpr.wp[1]--; /* Z < 0, choose Z2 */
831 }
832 }
833 break;
834
835 case DPFP:
836 if (FP_ROUNDMODE == FP_RND_PINF) {
837 if (!s_hi) {
838 if (fp_result)
839 fgpr.dp[0]++; /* Z > 0, choose Z1 */
840 else
841 fgpr.wp[1]++; /* Z > 0, choose Z1 */
842 }
843 } else { /* round to -Inf */
844 if (s_hi) {
845 if (fp_result)
846 fgpr.dp[0]++; /* Z < 0, choose Z2 */
847 else
848 fgpr.wp[1]--; /* Z < 0, choose Z2 */
849 }
850 }
851 break;
852
853 case VCT:
854 if (FP_ROUNDMODE == FP_RND_PINF) {
855 if (lo_inexact && !s_lo)
856 fgpr.wp[1]++; /* Z_low > 0, choose Z1 */
857 if (hi_inexact && !s_hi)
858 fgpr.wp[0]++; /* Z_high word > 0, choose Z1 */
859 } else { /* round to -Inf */
860 if (lo_inexact && s_lo) {
861 if (fp_result)
862 fgpr.wp[1]++; /* Z_low < 0, choose Z2 */
863 else
864 fgpr.wp[1]--; /* Z_low < 0, choose Z2 */
865 }
866 if (hi_inexact && s_hi) {
867 if (fp_result)
868 fgpr.wp[0]++; /* Z_high < 0, choose Z2 */
869 else
870 fgpr.wp[0]--; /* Z_high < 0, choose Z2 */
871 }
872 }
873 break;
874
875 default:
876 return -EINVAL;
877 }
878
879 current->thread.evr[fc] = fgpr.wp[0];
880 regs->gpr[fc] = fgpr.wp[1];
881
882 pr_debug(" to fgpr: %08x %08x\n", fgpr.wp[0], fgpr.wp[1]);
883
884 if (current->thread.fpexc_mode & PR_FP_EXC_SW_ENABLE)
885 return (current->thread.fpexc_mode & PR_FP_EXC_RES) ? 1 : 0;
886 return 0;
887}
888
889int __init spe_mathemu_init(void)
890{
891 u32 pvr, maj, min;
892
893 pvr = mfspr(SPRN_PVR);
894
895 if ((PVR_VER(pvr) == PVR_VER_E500V1) ||
896 (PVR_VER(pvr) == PVR_VER_E500V2)) {
897 maj = PVR_MAJ(pvr);
898 min = PVR_MIN(pvr);
899
900 /*
901 * E500 revision below 1.1, 2.3, 3.1, 4.1, 5.1
902 * need cpu a005 errata workaround
903 */
904 switch (maj) {
905 case 1:
906 if (min < 1)
907 have_e500_cpu_a005_erratum = 1;
908 break;
909 case 2:
910 if (min < 3)
911 have_e500_cpu_a005_erratum = 1;
912 break;
913 case 3:
914 case 4:
915 case 5:
916 if (min < 1)
917 have_e500_cpu_a005_erratum = 1;
918 break;
919 default:
920 break;
921 }
922 }
923
924 return 0;
925}
926
927module_init(spe_mathemu_init);