Loading...
1/*
2 * arch/sh/math-emu/math.c
3 *
4 * Copyright (C) 2006 Takashi YOSHII <takasi-y@ops.dti.ne.jp>
5 *
6 * This file is subject to the terms and conditions of the GNU General Public
7 * License. See the file "COPYING" in the main directory of this archive
8 * for more details.
9 */
10#include <linux/kernel.h>
11#include <linux/errno.h>
12#include <linux/types.h>
13#include <linux/sched/signal.h>
14#include <linux/signal.h>
15#include <linux/perf_event.h>
16
17#include <linux/uaccess.h>
18
19#include <asm/fpu.h>
20#include <asm/processor.h>
21#include <asm/io.h>
22
23#include "sfp-util.h"
24#include <math-emu/soft-fp.h>
25#include <math-emu/single.h>
26#include <math-emu/double.h>
27
28#define FPUL (fregs->fpul)
29#define FPSCR (fregs->fpscr)
30#define FPSCR_RM (FPSCR&3)
31#define FPSCR_DN ((FPSCR>>18)&1)
32#define FPSCR_PR ((FPSCR>>19)&1)
33#define FPSCR_SZ ((FPSCR>>20)&1)
34#define FPSCR_FR ((FPSCR>>21)&1)
35#define FPSCR_MASK 0x003fffffUL
36
37#define BANK(n) (n^(FPSCR_FR?16:0))
38#define FR ((unsigned long*)(fregs->fp_regs))
39#define FR0 (FR[BANK(0)])
40#define FRn (FR[BANK(n)])
41#define FRm (FR[BANK(m)])
42#define DR ((unsigned long long*)(fregs->fp_regs))
43#define DRn (DR[BANK(n)/2])
44#define DRm (DR[BANK(m)/2])
45
46#define XREG(n) (n^16)
47#define XFn (FR[BANK(XREG(n))])
48#define XFm (FR[BANK(XREG(m))])
49#define XDn (DR[BANK(XREG(n))/2])
50#define XDm (DR[BANK(XREG(m))/2])
51
52#define R0 (regs->regs[0])
53#define Rn (regs->regs[n])
54#define Rm (regs->regs[m])
55
56#define MWRITE(d,a) ({if(put_user(d, (typeof (d) __user *)a)) return -EFAULT;})
57#define MREAD(d,a) ({if(get_user(d, (typeof (d) __user *)a)) return -EFAULT;})
58
59#define PACK_S(r,f) FP_PACK_SP(&r,f)
60#define UNPACK_S(f,r) FP_UNPACK_SP(f,&r)
61#define PACK_D(r,f) \
62 {u32 t[2]; FP_PACK_DP(t,f); ((u32*)&r)[0]=t[1]; ((u32*)&r)[1]=t[0];}
63#define UNPACK_D(f,r) \
64 {u32 t[2]; t[0]=((u32*)&r)[1]; t[1]=((u32*)&r)[0]; FP_UNPACK_DP(f,t);}
65
66// 2 args instructions.
67#define BOTH_PRmn(op,x) \
68 FP_DECL_EX; if(FPSCR_PR) op(D,x,DRm,DRn); else op(S,x,FRm,FRn);
69
70#define CMP_X(SZ,R,M,N) do{ \
71 FP_DECL_##SZ(Fm); FP_DECL_##SZ(Fn); \
72 UNPACK_##SZ(Fm, M); UNPACK_##SZ(Fn, N); \
73 FP_CMP_##SZ(R, Fn, Fm, 2); }while(0)
74#define EQ_X(SZ,R,M,N) do{ \
75 FP_DECL_##SZ(Fm); FP_DECL_##SZ(Fn); \
76 UNPACK_##SZ(Fm, M); UNPACK_##SZ(Fn, N); \
77 FP_CMP_EQ_##SZ(R, Fn, Fm); }while(0)
78#define CMP(OP) ({ int r; BOTH_PRmn(OP##_X,r); r; })
79
80static int
81fcmp_gt(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, int m, int n)
82{
83 if (CMP(CMP) > 0)
84 regs->sr |= 1;
85 else
86 regs->sr &= ~1;
87
88 return 0;
89}
90
91static int
92fcmp_eq(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, int m, int n)
93{
94 if (CMP(CMP /*EQ*/) == 0)
95 regs->sr |= 1;
96 else
97 regs->sr &= ~1;
98 return 0;
99}
100
101#define ARITH_X(SZ,OP,M,N) do{ \
102 FP_DECL_##SZ(Fm); FP_DECL_##SZ(Fn); FP_DECL_##SZ(Fr); \
103 UNPACK_##SZ(Fm, M); UNPACK_##SZ(Fn, N); \
104 FP_##OP##_##SZ(Fr, Fn, Fm); \
105 PACK_##SZ(N, Fr); }while(0)
106
107static int
108fadd(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, int m, int n)
109{
110 BOTH_PRmn(ARITH_X, ADD);
111 return 0;
112}
113
114static int
115fsub(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, int m, int n)
116{
117 BOTH_PRmn(ARITH_X, SUB);
118 return 0;
119}
120
121static int
122fmul(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, int m, int n)
123{
124 BOTH_PRmn(ARITH_X, MUL);
125 return 0;
126}
127
128static int
129fdiv(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, int m, int n)
130{
131 BOTH_PRmn(ARITH_X, DIV);
132 return 0;
133}
134
135static int
136fmac(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, int m, int n)
137{
138 FP_DECL_EX;
139 FP_DECL_S(Fr);
140 FP_DECL_S(Ft);
141 FP_DECL_S(F0);
142 FP_DECL_S(Fm);
143 FP_DECL_S(Fn);
144 UNPACK_S(F0, FR0);
145 UNPACK_S(Fm, FRm);
146 UNPACK_S(Fn, FRn);
147 FP_MUL_S(Ft, Fm, F0);
148 FP_ADD_S(Fr, Fn, Ft);
149 PACK_S(FRn, Fr);
150 return 0;
151}
152
153// to process fmov's extension (odd n for DR access XD).
154#define FMOV_EXT(x) if(x&1) x+=16-1
155
156static int
157fmov_idx_reg(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, int m,
158 int n)
159{
160 if (FPSCR_SZ) {
161 FMOV_EXT(n);
162 MREAD(FRn, Rm + R0 + 4);
163 n++;
164 MREAD(FRn, Rm + R0);
165 } else {
166 MREAD(FRn, Rm + R0);
167 }
168
169 return 0;
170}
171
172static int
173fmov_mem_reg(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, int m,
174 int n)
175{
176 if (FPSCR_SZ) {
177 FMOV_EXT(n);
178 MREAD(FRn, Rm + 4);
179 n++;
180 MREAD(FRn, Rm);
181 } else {
182 MREAD(FRn, Rm);
183 }
184
185 return 0;
186}
187
188static int
189fmov_inc_reg(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, int m,
190 int n)
191{
192 if (FPSCR_SZ) {
193 FMOV_EXT(n);
194 MREAD(FRn, Rm + 4);
195 n++;
196 MREAD(FRn, Rm);
197 Rm += 8;
198 } else {
199 MREAD(FRn, Rm);
200 Rm += 4;
201 }
202
203 return 0;
204}
205
206static int
207fmov_reg_idx(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, int m,
208 int n)
209{
210 if (FPSCR_SZ) {
211 FMOV_EXT(m);
212 MWRITE(FRm, Rn + R0 + 4);
213 m++;
214 MWRITE(FRm, Rn + R0);
215 } else {
216 MWRITE(FRm, Rn + R0);
217 }
218
219 return 0;
220}
221
222static int
223fmov_reg_mem(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, int m,
224 int n)
225{
226 if (FPSCR_SZ) {
227 FMOV_EXT(m);
228 MWRITE(FRm, Rn + 4);
229 m++;
230 MWRITE(FRm, Rn);
231 } else {
232 MWRITE(FRm, Rn);
233 }
234
235 return 0;
236}
237
238static int
239fmov_reg_dec(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, int m,
240 int n)
241{
242 if (FPSCR_SZ) {
243 FMOV_EXT(m);
244 Rn -= 8;
245 MWRITE(FRm, Rn + 4);
246 m++;
247 MWRITE(FRm, Rn);
248 } else {
249 Rn -= 4;
250 MWRITE(FRm, Rn);
251 }
252
253 return 0;
254}
255
256static int
257fmov_reg_reg(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, int m,
258 int n)
259{
260 if (FPSCR_SZ) {
261 FMOV_EXT(m);
262 FMOV_EXT(n);
263 DRn = DRm;
264 } else {
265 FRn = FRm;
266 }
267
268 return 0;
269}
270
271static int
272fnop_mn(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, int m, int n)
273{
274 return -EINVAL;
275}
276
277// 1 arg instructions.
278#define NOTYETn(i) static int i(struct sh_fpu_soft_struct *fregs, int n) \
279 { printk( #i " not yet done.\n"); return 0; }
280
281NOTYETn(ftrv)
282NOTYETn(fsqrt)
283NOTYETn(fipr)
284NOTYETn(fsca)
285NOTYETn(fsrra)
286
287#define EMU_FLOAT_X(SZ,N) do { \
288 FP_DECL_##SZ(Fn); \
289 FP_FROM_INT_##SZ(Fn, FPUL, 32, int); \
290 PACK_##SZ(N, Fn); }while(0)
291static int ffloat(struct sh_fpu_soft_struct *fregs, int n)
292{
293 FP_DECL_EX;
294
295 if (FPSCR_PR)
296 EMU_FLOAT_X(D, DRn);
297 else
298 EMU_FLOAT_X(S, FRn);
299
300 return 0;
301}
302
303#define EMU_FTRC_X(SZ,N) do { \
304 FP_DECL_##SZ(Fn); \
305 UNPACK_##SZ(Fn, N); \
306 FP_TO_INT_##SZ(FPUL, Fn, 32, 1); }while(0)
307static int ftrc(struct sh_fpu_soft_struct *fregs, int n)
308{
309 FP_DECL_EX;
310
311 if (FPSCR_PR)
312 EMU_FTRC_X(D, DRn);
313 else
314 EMU_FTRC_X(S, FRn);
315
316 return 0;
317}
318
319static int fcnvsd(struct sh_fpu_soft_struct *fregs, int n)
320{
321 FP_DECL_EX;
322 FP_DECL_S(Fn);
323 FP_DECL_D(Fr);
324 UNPACK_S(Fn, FPUL);
325 FP_CONV(D, S, 2, 1, Fr, Fn);
326 PACK_D(DRn, Fr);
327 return 0;
328}
329
330static int fcnvds(struct sh_fpu_soft_struct *fregs, int n)
331{
332 FP_DECL_EX;
333 FP_DECL_D(Fn);
334 FP_DECL_S(Fr);
335 UNPACK_D(Fn, DRn);
336 FP_CONV(S, D, 1, 2, Fr, Fn);
337 PACK_S(FPUL, Fr);
338 return 0;
339}
340
341static int fxchg(struct sh_fpu_soft_struct *fregs, int flag)
342{
343 FPSCR ^= flag;
344 return 0;
345}
346
347static int fsts(struct sh_fpu_soft_struct *fregs, int n)
348{
349 FRn = FPUL;
350 return 0;
351}
352
353static int flds(struct sh_fpu_soft_struct *fregs, int n)
354{
355 FPUL = FRn;
356 return 0;
357}
358
359static int fneg(struct sh_fpu_soft_struct *fregs, int n)
360{
361 FRn ^= (1 << (_FP_W_TYPE_SIZE - 1));
362 return 0;
363}
364
365static int fabs(struct sh_fpu_soft_struct *fregs, int n)
366{
367 FRn &= ~(1 << (_FP_W_TYPE_SIZE - 1));
368 return 0;
369}
370
371static int fld0(struct sh_fpu_soft_struct *fregs, int n)
372{
373 FRn = 0;
374 return 0;
375}
376
377static int fld1(struct sh_fpu_soft_struct *fregs, int n)
378{
379 FRn = (_FP_EXPBIAS_S << (_FP_FRACBITS_S - 1));
380 return 0;
381}
382
383static int fnop_n(struct sh_fpu_soft_struct *fregs, int n)
384{
385 return -EINVAL;
386}
387
388/// Instruction decoders.
389
390static int id_fxfd(struct sh_fpu_soft_struct *, int);
391static int id_fnxd(struct sh_fpu_soft_struct *, struct pt_regs *, int, int);
392
393static int (*fnxd[])(struct sh_fpu_soft_struct *, int) = {
394 fsts, flds, ffloat, ftrc, fneg, fabs, fsqrt, fsrra,
395 fld0, fld1, fcnvsd, fcnvds, fnop_n, fnop_n, fipr, id_fxfd
396};
397
398static int (*fnmx[])(struct sh_fpu_soft_struct *, struct pt_regs *, int, int) = {
399 fadd, fsub, fmul, fdiv, fcmp_eq, fcmp_gt, fmov_idx_reg, fmov_reg_idx,
400 fmov_mem_reg, fmov_inc_reg, fmov_reg_mem, fmov_reg_dec,
401 fmov_reg_reg, id_fnxd, fmac, fnop_mn};
402
403static int id_fxfd(struct sh_fpu_soft_struct *fregs, int x)
404{
405 const int flag[] = { FPSCR_SZ, FPSCR_PR, FPSCR_FR, 0 };
406 switch (x & 3) {
407 case 3:
408 fxchg(fregs, flag[x >> 2]);
409 break;
410 case 1:
411 ftrv(fregs, x - 1);
412 break;
413 default:
414 fsca(fregs, x);
415 }
416 return 0;
417}
418
419static int
420id_fnxd(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, int x, int n)
421{
422 return (fnxd[x])(fregs, n);
423}
424
425static int
426id_fnmx(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, u16 code)
427{
428 int n = (code >> 8) & 0xf, m = (code >> 4) & 0xf, x = code & 0xf;
429 return (fnmx[x])(fregs, regs, m, n);
430}
431
432static int
433id_sys(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, u16 code)
434{
435 int n = ((code >> 8) & 0xf);
436 unsigned long *reg = (code & 0x0010) ? &FPUL : &FPSCR;
437
438 switch (code & 0xf0ff) {
439 case 0x005a:
440 case 0x006a:
441 Rn = *reg;
442 break;
443 case 0x405a:
444 case 0x406a:
445 *reg = Rn;
446 break;
447 case 0x4052:
448 case 0x4062:
449 Rn -= 4;
450 MWRITE(*reg, Rn);
451 break;
452 case 0x4056:
453 case 0x4066:
454 MREAD(*reg, Rn);
455 Rn += 4;
456 break;
457 default:
458 return -EINVAL;
459 }
460
461 return 0;
462}
463
464static int fpu_emulate(u16 code, struct sh_fpu_soft_struct *fregs, struct pt_regs *regs)
465{
466 if ((code & 0xf000) == 0xf000)
467 return id_fnmx(fregs, regs, code);
468 else
469 return id_sys(fregs, regs, code);
470}
471
472/**
473 * fpu_init - Initialize FPU registers
474 * @fpu: Pointer to software emulated FPU registers.
475 */
476static void fpu_init(struct sh_fpu_soft_struct *fpu)
477{
478 int i;
479
480 fpu->fpscr = FPSCR_INIT;
481 fpu->fpul = 0;
482
483 for (i = 0; i < 16; i++) {
484 fpu->fp_regs[i] = 0;
485 fpu->xfp_regs[i]= 0;
486 }
487}
488
489/**
490 * do_fpu_inst - Handle reserved instructions for FPU emulation
491 * @inst: instruction code.
492 * @regs: registers on stack.
493 */
494int do_fpu_inst(unsigned short inst, struct pt_regs *regs)
495{
496 struct task_struct *tsk = current;
497 struct sh_fpu_soft_struct *fpu = &(tsk->thread.xstate->softfpu);
498
499 perf_sw_event(PERF_COUNT_SW_EMULATION_FAULTS, 1, regs, 0);
500
501 if (!(task_thread_info(tsk)->status & TS_USEDFPU)) {
502 /* initialize once. */
503 fpu_init(fpu);
504 task_thread_info(tsk)->status |= TS_USEDFPU;
505 }
506
507 return fpu_emulate(inst, fpu, regs);
508}
1/*
2 * arch/sh/math-emu/math.c
3 *
4 * Copyright (C) 2006 Takashi YOSHII <takasi-y@ops.dti.ne.jp>
5 *
6 * This file is subject to the terms and conditions of the GNU General Public
7 * License. See the file "COPYING" in the main directory of this archive
8 * for more details.
9 */
10#include <linux/kernel.h>
11#include <linux/errno.h>
12#include <linux/types.h>
13#include <linux/sched.h>
14#include <linux/signal.h>
15#include <linux/perf_event.h>
16
17#include <asm/system.h>
18#include <asm/uaccess.h>
19#include <asm/processor.h>
20#include <asm/io.h>
21
22#include "sfp-util.h"
23#include <math-emu/soft-fp.h>
24#include <math-emu/single.h>
25#include <math-emu/double.h>
26
27#define FPUL (fregs->fpul)
28#define FPSCR (fregs->fpscr)
29#define FPSCR_RM (FPSCR&3)
30#define FPSCR_DN ((FPSCR>>18)&1)
31#define FPSCR_PR ((FPSCR>>19)&1)
32#define FPSCR_SZ ((FPSCR>>20)&1)
33#define FPSCR_FR ((FPSCR>>21)&1)
34#define FPSCR_MASK 0x003fffffUL
35
36#define BANK(n) (n^(FPSCR_FR?16:0))
37#define FR ((unsigned long*)(fregs->fp_regs))
38#define FR0 (FR[BANK(0)])
39#define FRn (FR[BANK(n)])
40#define FRm (FR[BANK(m)])
41#define DR ((unsigned long long*)(fregs->fp_regs))
42#define DRn (DR[BANK(n)/2])
43#define DRm (DR[BANK(m)/2])
44
45#define XREG(n) (n^16)
46#define XFn (FR[BANK(XREG(n))])
47#define XFm (FR[BANK(XREG(m))])
48#define XDn (DR[BANK(XREG(n))/2])
49#define XDm (DR[BANK(XREG(m))/2])
50
51#define R0 (regs->regs[0])
52#define Rn (regs->regs[n])
53#define Rm (regs->regs[m])
54
55#define WRITE(d,a) ({if(put_user(d, (typeof (d)*)a)) return -EFAULT;})
56#define READ(d,a) ({if(get_user(d, (typeof (d)*)a)) return -EFAULT;})
57
58#define PACK_S(r,f) FP_PACK_SP(&r,f)
59#define UNPACK_S(f,r) FP_UNPACK_SP(f,&r)
60#define PACK_D(r,f) \
61 {u32 t[2]; FP_PACK_DP(t,f); ((u32*)&r)[0]=t[1]; ((u32*)&r)[1]=t[0];}
62#define UNPACK_D(f,r) \
63 {u32 t[2]; t[0]=((u32*)&r)[1]; t[1]=((u32*)&r)[0]; FP_UNPACK_DP(f,t);}
64
65// 2 args instructions.
66#define BOTH_PRmn(op,x) \
67 FP_DECL_EX; if(FPSCR_PR) op(D,x,DRm,DRn); else op(S,x,FRm,FRn);
68
69#define CMP_X(SZ,R,M,N) do{ \
70 FP_DECL_##SZ(Fm); FP_DECL_##SZ(Fn); \
71 UNPACK_##SZ(Fm, M); UNPACK_##SZ(Fn, N); \
72 FP_CMP_##SZ(R, Fn, Fm, 2); }while(0)
73#define EQ_X(SZ,R,M,N) do{ \
74 FP_DECL_##SZ(Fm); FP_DECL_##SZ(Fn); \
75 UNPACK_##SZ(Fm, M); UNPACK_##SZ(Fn, N); \
76 FP_CMP_EQ_##SZ(R, Fn, Fm); }while(0)
77#define CMP(OP) ({ int r; BOTH_PRmn(OP##_X,r); r; })
78
79static int
80fcmp_gt(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, int m, int n)
81{
82 if (CMP(CMP) > 0)
83 regs->sr |= 1;
84 else
85 regs->sr &= ~1;
86
87 return 0;
88}
89
90static int
91fcmp_eq(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, int m, int n)
92{
93 if (CMP(CMP /*EQ*/) == 0)
94 regs->sr |= 1;
95 else
96 regs->sr &= ~1;
97 return 0;
98}
99
100#define ARITH_X(SZ,OP,M,N) do{ \
101 FP_DECL_##SZ(Fm); FP_DECL_##SZ(Fn); FP_DECL_##SZ(Fr); \
102 UNPACK_##SZ(Fm, M); UNPACK_##SZ(Fn, N); \
103 FP_##OP##_##SZ(Fr, Fn, Fm); \
104 PACK_##SZ(N, Fr); }while(0)
105
106static int
107fadd(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, int m, int n)
108{
109 BOTH_PRmn(ARITH_X, ADD);
110 return 0;
111}
112
113static int
114fsub(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, int m, int n)
115{
116 BOTH_PRmn(ARITH_X, SUB);
117 return 0;
118}
119
120static int
121fmul(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, int m, int n)
122{
123 BOTH_PRmn(ARITH_X, MUL);
124 return 0;
125}
126
127static int
128fdiv(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, int m, int n)
129{
130 BOTH_PRmn(ARITH_X, DIV);
131 return 0;
132}
133
134static int
135fmac(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, int m, int n)
136{
137 FP_DECL_EX;
138 FP_DECL_S(Fr);
139 FP_DECL_S(Ft);
140 FP_DECL_S(F0);
141 FP_DECL_S(Fm);
142 FP_DECL_S(Fn);
143 UNPACK_S(F0, FR0);
144 UNPACK_S(Fm, FRm);
145 UNPACK_S(Fn, FRn);
146 FP_MUL_S(Ft, Fm, F0);
147 FP_ADD_S(Fr, Fn, Ft);
148 PACK_S(FRn, Fr);
149 return 0;
150}
151
152// to process fmov's extension (odd n for DR access XD).
153#define FMOV_EXT(x) if(x&1) x+=16-1
154
155static int
156fmov_idx_reg(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, int m,
157 int n)
158{
159 if (FPSCR_SZ) {
160 FMOV_EXT(n);
161 READ(FRn, Rm + R0 + 4);
162 n++;
163 READ(FRn, Rm + R0);
164 } else {
165 READ(FRn, Rm + R0);
166 }
167
168 return 0;
169}
170
171static int
172fmov_mem_reg(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, int m,
173 int n)
174{
175 if (FPSCR_SZ) {
176 FMOV_EXT(n);
177 READ(FRn, Rm + 4);
178 n++;
179 READ(FRn, Rm);
180 } else {
181 READ(FRn, Rm);
182 }
183
184 return 0;
185}
186
187static int
188fmov_inc_reg(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, int m,
189 int n)
190{
191 if (FPSCR_SZ) {
192 FMOV_EXT(n);
193 READ(FRn, Rm + 4);
194 n++;
195 READ(FRn, Rm);
196 Rm += 8;
197 } else {
198 READ(FRn, Rm);
199 Rm += 4;
200 }
201
202 return 0;
203}
204
205static int
206fmov_reg_idx(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, int m,
207 int n)
208{
209 if (FPSCR_SZ) {
210 FMOV_EXT(m);
211 WRITE(FRm, Rn + R0 + 4);
212 m++;
213 WRITE(FRm, Rn + R0);
214 } else {
215 WRITE(FRm, Rn + R0);
216 }
217
218 return 0;
219}
220
221static int
222fmov_reg_mem(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, int m,
223 int n)
224{
225 if (FPSCR_SZ) {
226 FMOV_EXT(m);
227 WRITE(FRm, Rn + 4);
228 m++;
229 WRITE(FRm, Rn);
230 } else {
231 WRITE(FRm, Rn);
232 }
233
234 return 0;
235}
236
237static int
238fmov_reg_dec(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, int m,
239 int n)
240{
241 if (FPSCR_SZ) {
242 FMOV_EXT(m);
243 Rn -= 8;
244 WRITE(FRm, Rn + 4);
245 m++;
246 WRITE(FRm, Rn);
247 } else {
248 Rn -= 4;
249 WRITE(FRm, Rn);
250 }
251
252 return 0;
253}
254
255static int
256fmov_reg_reg(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, int m,
257 int n)
258{
259 if (FPSCR_SZ) {
260 FMOV_EXT(m);
261 FMOV_EXT(n);
262 DRn = DRm;
263 } else {
264 FRn = FRm;
265 }
266
267 return 0;
268}
269
270static int
271fnop_mn(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, int m, int n)
272{
273 return -EINVAL;
274}
275
276// 1 arg instructions.
277#define NOTYETn(i) static int i(struct sh_fpu_soft_struct *fregs, int n) \
278 { printk( #i " not yet done.\n"); return 0; }
279
280NOTYETn(ftrv)
281NOTYETn(fsqrt)
282NOTYETn(fipr)
283NOTYETn(fsca)
284NOTYETn(fsrra)
285
286#define EMU_FLOAT_X(SZ,N) do { \
287 FP_DECL_##SZ(Fn); \
288 FP_FROM_INT_##SZ(Fn, FPUL, 32, int); \
289 PACK_##SZ(N, Fn); }while(0)
290static int ffloat(struct sh_fpu_soft_struct *fregs, int n)
291{
292 FP_DECL_EX;
293
294 if (FPSCR_PR)
295 EMU_FLOAT_X(D, DRn);
296 else
297 EMU_FLOAT_X(S, FRn);
298
299 return 0;
300}
301
302#define EMU_FTRC_X(SZ,N) do { \
303 FP_DECL_##SZ(Fn); \
304 UNPACK_##SZ(Fn, N); \
305 FP_TO_INT_##SZ(FPUL, Fn, 32, 1); }while(0)
306static int ftrc(struct sh_fpu_soft_struct *fregs, int n)
307{
308 FP_DECL_EX;
309
310 if (FPSCR_PR)
311 EMU_FTRC_X(D, DRn);
312 else
313 EMU_FTRC_X(S, FRn);
314
315 return 0;
316}
317
318static int fcnvsd(struct sh_fpu_soft_struct *fregs, int n)
319{
320 FP_DECL_EX;
321 FP_DECL_S(Fn);
322 FP_DECL_D(Fr);
323 UNPACK_S(Fn, FPUL);
324 FP_CONV(D, S, 2, 1, Fr, Fn);
325 PACK_D(DRn, Fr);
326 return 0;
327}
328
329static int fcnvds(struct sh_fpu_soft_struct *fregs, int n)
330{
331 FP_DECL_EX;
332 FP_DECL_D(Fn);
333 FP_DECL_S(Fr);
334 UNPACK_D(Fn, DRn);
335 FP_CONV(S, D, 1, 2, Fr, Fn);
336 PACK_S(FPUL, Fr);
337 return 0;
338}
339
340static int fxchg(struct sh_fpu_soft_struct *fregs, int flag)
341{
342 FPSCR ^= flag;
343 return 0;
344}
345
346static int fsts(struct sh_fpu_soft_struct *fregs, int n)
347{
348 FRn = FPUL;
349 return 0;
350}
351
352static int flds(struct sh_fpu_soft_struct *fregs, int n)
353{
354 FPUL = FRn;
355 return 0;
356}
357
358static int fneg(struct sh_fpu_soft_struct *fregs, int n)
359{
360 FRn ^= (1 << (_FP_W_TYPE_SIZE - 1));
361 return 0;
362}
363
364static int fabs(struct sh_fpu_soft_struct *fregs, int n)
365{
366 FRn &= ~(1 << (_FP_W_TYPE_SIZE - 1));
367 return 0;
368}
369
370static int fld0(struct sh_fpu_soft_struct *fregs, int n)
371{
372 FRn = 0;
373 return 0;
374}
375
376static int fld1(struct sh_fpu_soft_struct *fregs, int n)
377{
378 FRn = (_FP_EXPBIAS_S << (_FP_FRACBITS_S - 1));
379 return 0;
380}
381
382static int fnop_n(struct sh_fpu_soft_struct *fregs, int n)
383{
384 return -EINVAL;
385}
386
387/// Instruction decoders.
388
389static int id_fxfd(struct sh_fpu_soft_struct *, int);
390static int id_fnxd(struct sh_fpu_soft_struct *, struct pt_regs *, int, int);
391
392static int (*fnxd[])(struct sh_fpu_soft_struct *, int) = {
393 fsts, flds, ffloat, ftrc, fneg, fabs, fsqrt, fsrra,
394 fld0, fld1, fcnvsd, fcnvds, fnop_n, fnop_n, fipr, id_fxfd
395};
396
397static int (*fnmx[])(struct sh_fpu_soft_struct *, struct pt_regs *, int, int) = {
398 fadd, fsub, fmul, fdiv, fcmp_eq, fcmp_gt, fmov_idx_reg, fmov_reg_idx,
399 fmov_mem_reg, fmov_inc_reg, fmov_reg_mem, fmov_reg_dec,
400 fmov_reg_reg, id_fnxd, fmac, fnop_mn};
401
402static int id_fxfd(struct sh_fpu_soft_struct *fregs, int x)
403{
404 const int flag[] = { FPSCR_SZ, FPSCR_PR, FPSCR_FR, 0 };
405 switch (x & 3) {
406 case 3:
407 fxchg(fregs, flag[x >> 2]);
408 break;
409 case 1:
410 ftrv(fregs, x - 1);
411 break;
412 default:
413 fsca(fregs, x);
414 }
415 return 0;
416}
417
418static int
419id_fnxd(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, int x, int n)
420{
421 return (fnxd[x])(fregs, n);
422}
423
424static int
425id_fnmx(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, u16 code)
426{
427 int n = (code >> 8) & 0xf, m = (code >> 4) & 0xf, x = code & 0xf;
428 return (fnmx[x])(fregs, regs, m, n);
429}
430
431static int
432id_sys(struct sh_fpu_soft_struct *fregs, struct pt_regs *regs, u16 code)
433{
434 int n = ((code >> 8) & 0xf);
435 unsigned long *reg = (code & 0x0010) ? &FPUL : &FPSCR;
436
437 switch (code & 0xf0ff) {
438 case 0x005a:
439 case 0x006a:
440 Rn = *reg;
441 break;
442 case 0x405a:
443 case 0x406a:
444 *reg = Rn;
445 break;
446 case 0x4052:
447 case 0x4062:
448 Rn -= 4;
449 WRITE(*reg, Rn);
450 break;
451 case 0x4056:
452 case 0x4066:
453 READ(*reg, Rn);
454 Rn += 4;
455 break;
456 default:
457 return -EINVAL;
458 }
459
460 return 0;
461}
462
463static int fpu_emulate(u16 code, struct sh_fpu_soft_struct *fregs, struct pt_regs *regs)
464{
465 if ((code & 0xf000) == 0xf000)
466 return id_fnmx(fregs, regs, code);
467 else
468 return id_sys(fregs, regs, code);
469}
470
471/**
472 * denormal_to_double - Given denormalized float number,
473 * store double float
474 *
475 * @fpu: Pointer to sh_fpu_soft structure
476 * @n: Index to FP register
477 */
478static void denormal_to_double(struct sh_fpu_soft_struct *fpu, int n)
479{
480 unsigned long du, dl;
481 unsigned long x = fpu->fpul;
482 int exp = 1023 - 126;
483
484 if (x != 0 && (x & 0x7f800000) == 0) {
485 du = (x & 0x80000000);
486 while ((x & 0x00800000) == 0) {
487 x <<= 1;
488 exp--;
489 }
490 x &= 0x007fffff;
491 du |= (exp << 20) | (x >> 3);
492 dl = x << 29;
493
494 fpu->fp_regs[n] = du;
495 fpu->fp_regs[n+1] = dl;
496 }
497}
498
499/**
500 * ieee_fpe_handler - Handle denormalized number exception
501 *
502 * @regs: Pointer to register structure
503 *
504 * Returns 1 when it's handled (should not cause exception).
505 */
506static int ieee_fpe_handler(struct pt_regs *regs)
507{
508 unsigned short insn = *(unsigned short *)regs->pc;
509 unsigned short finsn;
510 unsigned long nextpc;
511 siginfo_t info;
512 int nib[4] = {
513 (insn >> 12) & 0xf,
514 (insn >> 8) & 0xf,
515 (insn >> 4) & 0xf,
516 insn & 0xf};
517
518 if (nib[0] == 0xb ||
519 (nib[0] == 0x4 && nib[2] == 0x0 && nib[3] == 0xb)) /* bsr & jsr */
520 regs->pr = regs->pc + 4;
521
522 if (nib[0] == 0xa || nib[0] == 0xb) { /* bra & bsr */
523 nextpc = regs->pc + 4 + ((short) ((insn & 0xfff) << 4) >> 3);
524 finsn = *(unsigned short *) (regs->pc + 2);
525 } else if (nib[0] == 0x8 && nib[1] == 0xd) { /* bt/s */
526 if (regs->sr & 1)
527 nextpc = regs->pc + 4 + ((char) (insn & 0xff) << 1);
528 else
529 nextpc = regs->pc + 4;
530 finsn = *(unsigned short *) (regs->pc + 2);
531 } else if (nib[0] == 0x8 && nib[1] == 0xf) { /* bf/s */
532 if (regs->sr & 1)
533 nextpc = regs->pc + 4;
534 else
535 nextpc = regs->pc + 4 + ((char) (insn & 0xff) << 1);
536 finsn = *(unsigned short *) (regs->pc + 2);
537 } else if (nib[0] == 0x4 && nib[3] == 0xb &&
538 (nib[2] == 0x0 || nib[2] == 0x2)) { /* jmp & jsr */
539 nextpc = regs->regs[nib[1]];
540 finsn = *(unsigned short *) (regs->pc + 2);
541 } else if (nib[0] == 0x0 && nib[3] == 0x3 &&
542 (nib[2] == 0x0 || nib[2] == 0x2)) { /* braf & bsrf */
543 nextpc = regs->pc + 4 + regs->regs[nib[1]];
544 finsn = *(unsigned short *) (regs->pc + 2);
545 } else if (insn == 0x000b) { /* rts */
546 nextpc = regs->pr;
547 finsn = *(unsigned short *) (regs->pc + 2);
548 } else {
549 nextpc = regs->pc + 2;
550 finsn = insn;
551 }
552
553 if ((finsn & 0xf1ff) == 0xf0ad) { /* fcnvsd */
554 struct task_struct *tsk = current;
555
556 if ((tsk->thread.xstate->softfpu.fpscr & (1 << 17))) {
557 /* FPU error */
558 denormal_to_double (&tsk->thread.xstate->softfpu,
559 (finsn >> 8) & 0xf);
560 tsk->thread.xstate->softfpu.fpscr &=
561 ~(FPSCR_CAUSE_MASK | FPSCR_FLAG_MASK);
562 task_thread_info(tsk)->status |= TS_USEDFPU;
563 } else {
564 info.si_signo = SIGFPE;
565 info.si_errno = 0;
566 info.si_code = FPE_FLTINV;
567 info.si_addr = (void __user *)regs->pc;
568 force_sig_info(SIGFPE, &info, tsk);
569 }
570
571 regs->pc = nextpc;
572 return 1;
573 }
574
575 return 0;
576}
577
578asmlinkage void do_fpu_error(unsigned long r4, unsigned long r5,
579 unsigned long r6, unsigned long r7,
580 struct pt_regs regs)
581{
582 struct task_struct *tsk = current;
583 siginfo_t info;
584
585 if (ieee_fpe_handler (®s))
586 return;
587
588 regs.pc += 2;
589 info.si_signo = SIGFPE;
590 info.si_errno = 0;
591 info.si_code = FPE_FLTINV;
592 info.si_addr = (void __user *)regs.pc;
593 force_sig_info(SIGFPE, &info, tsk);
594}
595
596/**
597 * fpu_init - Initialize FPU registers
598 * @fpu: Pointer to software emulated FPU registers.
599 */
600static void fpu_init(struct sh_fpu_soft_struct *fpu)
601{
602 int i;
603
604 fpu->fpscr = FPSCR_INIT;
605 fpu->fpul = 0;
606
607 for (i = 0; i < 16; i++) {
608 fpu->fp_regs[i] = 0;
609 fpu->xfp_regs[i]= 0;
610 }
611}
612
613/**
614 * do_fpu_inst - Handle reserved instructions for FPU emulation
615 * @inst: instruction code.
616 * @regs: registers on stack.
617 */
618int do_fpu_inst(unsigned short inst, struct pt_regs *regs)
619{
620 struct task_struct *tsk = current;
621 struct sh_fpu_soft_struct *fpu = &(tsk->thread.xstate->softfpu);
622
623 perf_sw_event(PERF_COUNT_SW_EMULATION_FAULTS, 1, regs, 0);
624
625 if (!(task_thread_info(tsk)->status & TS_USEDFPU)) {
626 /* initialize once. */
627 fpu_init(fpu);
628 task_thread_info(tsk)->status |= TS_USEDFPU;
629 }
630
631 return fpu_emulate(inst, fpu, regs);
632}