1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 *
4 * Copyright Novell Inc 2010
5 *
6 * Authors: Alexander Graf <agraf@suse.de>
7 */
8
9 #include <asm/kvm.h>
10 #include <asm/kvm_ppc.h>
11 #include <asm/disassemble.h>
12 #include <asm/kvm_book3s.h>
13 #include <asm/kvm_fpu.h>
14 #include <asm/reg.h>
15 #include <asm/cacheflush.h>
16 #include <asm/switch_to.h>
17 #include <linux/vmalloc.h>
18
19 /* #define DEBUG */
20
21 #ifdef DEBUG
22 #define dprintk printk
23 #else
24 #define dprintk(...) do { } while(0);
25 #endif
26
27 #define OP_LFS 48
28 #define OP_LFSU 49
29 #define OP_LFD 50
30 #define OP_LFDU 51
31 #define OP_STFS 52
32 #define OP_STFSU 53
33 #define OP_STFD 54
34 #define OP_STFDU 55
35 #define OP_PSQ_L 56
36 #define OP_PSQ_LU 57
37 #define OP_PSQ_ST 60
38 #define OP_PSQ_STU 61
39
40 #define OP_31_LFSX 535
41 #define OP_31_LFSUX 567
42 #define OP_31_LFDX 599
43 #define OP_31_LFDUX 631
44 #define OP_31_STFSX 663
45 #define OP_31_STFSUX 695
46 #define OP_31_STFX 727
47 #define OP_31_STFUX 759
48 #define OP_31_LWIZX 887
49 #define OP_31_STFIWX 983
50
51 #define OP_59_FADDS 21
52 #define OP_59_FSUBS 20
53 #define OP_59_FSQRTS 22
54 #define OP_59_FDIVS 18
55 #define OP_59_FRES 24
56 #define OP_59_FMULS 25
57 #define OP_59_FRSQRTES 26
58 #define OP_59_FMSUBS 28
59 #define OP_59_FMADDS 29
60 #define OP_59_FNMSUBS 30
61 #define OP_59_FNMADDS 31
62
63 #define OP_63_FCMPU 0
64 #define OP_63_FCPSGN 8
65 #define OP_63_FRSP 12
66 #define OP_63_FCTIW 14
67 #define OP_63_FCTIWZ 15
68 #define OP_63_FDIV 18
69 #define OP_63_FADD 21
70 #define OP_63_FSQRT 22
71 #define OP_63_FSEL 23
72 #define OP_63_FRE 24
73 #define OP_63_FMUL 25
74 #define OP_63_FRSQRTE 26
75 #define OP_63_FMSUB 28
76 #define OP_63_FMADD 29
77 #define OP_63_FNMSUB 30
78 #define OP_63_FNMADD 31
79 #define OP_63_FCMPO 32
80 #define OP_63_MTFSB1 38 // XXX
81 #define OP_63_FSUB 20
82 #define OP_63_FNEG 40
83 #define OP_63_MCRFS 64
84 #define OP_63_MTFSB0 70
85 #define OP_63_FMR 72
86 #define OP_63_MTFSFI 134
87 #define OP_63_FABS 264
88 #define OP_63_MFFS 583
89 #define OP_63_MTFSF 711
90
91 #define OP_4X_PS_CMPU0 0
92 #define OP_4X_PSQ_LX 6
93 #define OP_4XW_PSQ_STX 7
94 #define OP_4A_PS_SUM0 10
95 #define OP_4A_PS_SUM1 11
96 #define OP_4A_PS_MULS0 12
97 #define OP_4A_PS_MULS1 13
98 #define OP_4A_PS_MADDS0 14
99 #define OP_4A_PS_MADDS1 15
100 #define OP_4A_PS_DIV 18
101 #define OP_4A_PS_SUB 20
102 #define OP_4A_PS_ADD 21
103 #define OP_4A_PS_SEL 23
104 #define OP_4A_PS_RES 24
105 #define OP_4A_PS_MUL 25
106 #define OP_4A_PS_RSQRTE 26
107 #define OP_4A_PS_MSUB 28
108 #define OP_4A_PS_MADD 29
109 #define OP_4A_PS_NMSUB 30
110 #define OP_4A_PS_NMADD 31
111 #define OP_4X_PS_CMPO0 32
112 #define OP_4X_PSQ_LUX 38
113 #define OP_4XW_PSQ_STUX 39
114 #define OP_4X_PS_NEG 40
115 #define OP_4X_PS_CMPU1 64
116 #define OP_4X_PS_MR 72
117 #define OP_4X_PS_CMPO1 96
118 #define OP_4X_PS_NABS 136
119 #define OP_4X_PS_ABS 264
120 #define OP_4X_PS_MERGE00 528
121 #define OP_4X_PS_MERGE01 560
122 #define OP_4X_PS_MERGE10 592
123 #define OP_4X_PS_MERGE11 624
124
125 #define SCALAR_NONE 0
126 #define SCALAR_HIGH (1 << 0)
127 #define SCALAR_LOW (1 << 1)
128 #define SCALAR_NO_PS0 (1 << 2)
129 #define SCALAR_NO_PS1 (1 << 3)
130
131 #define GQR_ST_TYPE_MASK 0x00000007
132 #define GQR_ST_TYPE_SHIFT 0
133 #define GQR_ST_SCALE_MASK 0x00003f00
134 #define GQR_ST_SCALE_SHIFT 8
135 #define GQR_LD_TYPE_MASK 0x00070000
136 #define GQR_LD_TYPE_SHIFT 16
137 #define GQR_LD_SCALE_MASK 0x3f000000
138 #define GQR_LD_SCALE_SHIFT 24
139
140 #define GQR_QUANTIZE_FLOAT 0
141 #define GQR_QUANTIZE_U8 4
142 #define GQR_QUANTIZE_U16 5
143 #define GQR_QUANTIZE_S8 6
144 #define GQR_QUANTIZE_S16 7
145
146 #define FPU_LS_SINGLE 0
147 #define FPU_LS_DOUBLE 1
148 #define FPU_LS_SINGLE_LOW 2
149
150 static inline void kvmppc_sync_qpr(struct kvm_vcpu *vcpu, int rt)
151 {
152 kvm_cvt_df(&VCPU_FPR(vcpu, rt), &vcpu->arch.qpr[rt]);
153 }
154
155 static void kvmppc_inject_pf(struct kvm_vcpu *vcpu, ulong eaddr, bool is_store)
156 {
157 u32 dsisr;
158 u64 msr = kvmppc_get_msr(vcpu);
159
160 msr = kvmppc_set_field(msr, 33, 36, 0);
161 msr = kvmppc_set_field(msr, 42, 47, 0);
162 kvmppc_set_msr(vcpu, msr);
163 kvmppc_set_dar(vcpu, eaddr);
164 /* Page Fault */
165 dsisr = kvmppc_set_field(0, 33, 33, 1);
166 if (is_store)
167 dsisr = kvmppc_set_field(dsisr, 38, 38, 1);
168 kvmppc_set_dsisr(vcpu, dsisr);
169 kvmppc_book3s_queue_irqprio(vcpu, BOOK3S_INTERRUPT_DATA_STORAGE);
170 }
171
172 static int kvmppc_emulate_fpr_load(struct kvm_vcpu *vcpu,
173 int rs, ulong addr, int ls_type)
174 {
175 int emulated = EMULATE_FAIL;
176 int r;
177 char tmp[8];
178 int len = sizeof(u32);
179
180 if (ls_type == FPU_LS_DOUBLE)
181 len = sizeof(u64);
182
183 /* read from memory */
184 r = kvmppc_ld(vcpu, &addr, len, tmp, true);
185 vcpu->arch.paddr_accessed = addr;
186
187 if (r < 0) {
188 kvmppc_inject_pf(vcpu, addr, false);
189 goto done_load;
190 } else if (r == EMULATE_DO_MMIO) {
191 emulated = kvmppc_handle_load(vcpu, KVM_MMIO_REG_FPR | rs,
192 len, 1);
193 goto done_load;
194 }
195
196 emulated = EMULATE_DONE;
197
198 /* put in registers */
199 switch (ls_type) {
200 case FPU_LS_SINGLE:
201 kvm_cvt_fd((u32*)tmp, &VCPU_FPR(vcpu, rs));
202 vcpu->arch.qpr[rs] = *((u32*)tmp);
203 break;
204 case FPU_LS_DOUBLE:
205 VCPU_FPR(vcpu, rs) = *((u64*)tmp);
206 break;
207 }
208
209 dprintk(KERN_INFO "KVM: FPR_LD [0x%llx] at 0x%lx (%d)\n", *(u64*)tmp,
210 addr, len);
211
212 done_load:
213 return emulated;
214 }
215
216 static int kvmppc_emulate_fpr_store(struct kvm_vcpu *vcpu,
217 int rs, ulong addr, int ls_type)
218 {
219 int emulated = EMULATE_FAIL;
220 int r;
221 char tmp[8];
222 u64 val;
223 int len;
224
225 switch (ls_type) {
226 case FPU_LS_SINGLE:
227 kvm_cvt_df(&VCPU_FPR(vcpu, rs), (u32*)tmp);
228 val = *((u32*)tmp);
229 len = sizeof(u32);
230 break;
231 case FPU_LS_SINGLE_LOW:
232 *((u32*)tmp) = VCPU_FPR(vcpu, rs);
233 val = VCPU_FPR(vcpu, rs) & 0xffffffff;
234 len = sizeof(u32);
235 break;
236 case FPU_LS_DOUBLE:
237 *((u64*)tmp) = VCPU_FPR(vcpu, rs);
238 val = VCPU_FPR(vcpu, rs);
239 len = sizeof(u64);
240 break;
241 default:
242 val = 0;
243 len = 0;
244 }
245
246 r = kvmppc_st(vcpu, &addr, len, tmp, true);
247 vcpu->arch.paddr_accessed = addr;
248 if (r < 0) {
249 kvmppc_inject_pf(vcpu, addr, true);
250 } else if (r == EMULATE_DO_MMIO) {
251 emulated = kvmppc_handle_store(vcpu, val, len, 1);
252 } else {
253 emulated = EMULATE_DONE;
254 }
255
256 dprintk(KERN_INFO "KVM: FPR_ST [0x%llx] at 0x%lx (%d)\n",
257 val, addr, len);
258
259 return emulated;
260 }
261
262 static int kvmppc_emulate_psq_load(struct kvm_vcpu *vcpu,
263 int rs, ulong addr, bool w, int i)
264 {
265 int emulated = EMULATE_FAIL;
266 int r;
267 float one = 1.0;
268 u32 tmp[2];
269
270 /* read from memory */
271 if (w) {
272 r = kvmppc_ld(vcpu, &addr, sizeof(u32), tmp, true);
273 memcpy(&tmp[1], &one, sizeof(u32));
274 } else {
275 r = kvmppc_ld(vcpu, &addr, sizeof(u32) * 2, tmp, true);
276 }
277 vcpu->arch.paddr_accessed = addr;
278 if (r < 0) {
279 kvmppc_inject_pf(vcpu, addr, false);
280 goto done_load;
281 } else if ((r == EMULATE_DO_MMIO) && w) {
282 emulated = kvmppc_handle_load(vcpu, KVM_MMIO_REG_FPR | rs,
283 4, 1);
284 vcpu->arch.qpr[rs] = tmp[1];
285 goto done_load;
286 } else if (r == EMULATE_DO_MMIO) {
287 emulated = kvmppc_handle_load(vcpu, KVM_MMIO_REG_FQPR | rs,
288 8, 1);
289 goto done_load;
290 }
291
292 emulated = EMULATE_DONE;
293
294 /* put in registers */
295 kvm_cvt_fd(&tmp[0], &VCPU_FPR(vcpu, rs));
296 vcpu->arch.qpr[rs] = tmp[1];
297
298 dprintk(KERN_INFO "KVM: PSQ_LD [0x%x, 0x%x] at 0x%lx (%d)\n", tmp[0],
299 tmp[1], addr, w ? 4 : 8);
300
301 done_load:
302 return emulated;
303 }
304
305 static int kvmppc_emulate_psq_store(struct kvm_vcpu *vcpu,
306 int rs, ulong addr, bool w, int i)
307 {
308 int emulated = EMULATE_FAIL;
309 int r;
310 u32 tmp[2];
311 int len = w ? sizeof(u32) : sizeof(u64);
312
313 kvm_cvt_df(&VCPU_FPR(vcpu, rs), &tmp[0]);
314 tmp[1] = vcpu->arch.qpr[rs];
315
316 r = kvmppc_st(vcpu, &addr, len, tmp, true);
317 vcpu->arch.paddr_accessed = addr;
318 if (r < 0) {
319 kvmppc_inject_pf(vcpu, addr, true);
320 } else if ((r == EMULATE_DO_MMIO) && w) {
321 emulated = kvmppc_handle_store(vcpu, tmp[0], 4, 1);
322 } else if (r == EMULATE_DO_MMIO) {
323 u64 val = ((u64)tmp[0] << 32) | tmp[1];
324 emulated = kvmppc_handle_store(vcpu, val, 8, 1);
325 } else {
326 emulated = EMULATE_DONE;
327 }
328
329 dprintk(KERN_INFO "KVM: PSQ_ST [0x%x, 0x%x] at 0x%lx (%d)\n",
330 tmp[0], tmp[1], addr, len);
331
332 return emulated;
333 }
334
335 /*
336 * Cuts out inst bits with ordering according to spec.
337 * That means the leftmost bit is zero. All given bits are included.
338 */
339 static inline u32 inst_get_field(u32 inst, int msb, int lsb)
340 {
341 return kvmppc_get_field(inst, msb + 32, lsb + 32);
342 }
343
344 static bool kvmppc_inst_is_paired_single(struct kvm_vcpu *vcpu, u32 inst)
345 {
346 if (!(vcpu->arch.hflags & BOOK3S_HFLAG_PAIRED_SINGLE))
347 return false;
348
349 switch (get_op(inst)) {
350 case OP_PSQ_L:
351 case OP_PSQ_LU:
352 case OP_PSQ_ST:
353 case OP_PSQ_STU:
354 case OP_LFS:
355 case OP_LFSU:
356 case OP_LFD:
357 case OP_LFDU:
358 case OP_STFS:
359 case OP_STFSU:
360 case OP_STFD:
361 case OP_STFDU:
362 return true;
363 case 4:
364 /* X form */
365 switch (inst_get_field(inst, 21, 30)) {
366 case OP_4X_PS_CMPU0:
367 case OP_4X_PSQ_LX:
368 case OP_4X_PS_CMPO0:
369 case OP_4X_PSQ_LUX:
370 case OP_4X_PS_NEG:
371 case OP_4X_PS_CMPU1:
372 case OP_4X_PS_MR:
373 case OP_4X_PS_CMPO1:
374 case OP_4X_PS_NABS:
375 case OP_4X_PS_ABS:
376 case OP_4X_PS_MERGE00:
377 case OP_4X_PS_MERGE01:
378 case OP_4X_PS_MERGE10:
379 case OP_4X_PS_MERGE11:
380 return true;
381 }
382 /* XW form */
383 switch (inst_get_field(inst, 25, 30)) {
384 case OP_4XW_PSQ_STX:
385 case OP_4XW_PSQ_STUX:
386 return true;
387 }
388 /* A form */
389 switch (inst_get_field(inst, 26, 30)) {
390 case OP_4A_PS_SUM1:
391 case OP_4A_PS_SUM0:
392 case OP_4A_PS_MULS0:
393 case OP_4A_PS_MULS1:
394 case OP_4A_PS_MADDS0:
395 case OP_4A_PS_MADDS1:
396 case OP_4A_PS_DIV:
397 case OP_4A_PS_SUB:
398 case OP_4A_PS_ADD:
399 case OP_4A_PS_SEL:
400 case OP_4A_PS_RES:
401 case OP_4A_PS_MUL:
402 case OP_4A_PS_RSQRTE:
403 case OP_4A_PS_MSUB:
404 case OP_4A_PS_MADD:
405 case OP_4A_PS_NMSUB:
406 case OP_4A_PS_NMADD:
407 return true;
408 }
409 break;
410 case 59:
411 switch (inst_get_field(inst, 21, 30)) {
412 case OP_59_FADDS:
413 case OP_59_FSUBS:
414 case OP_59_FDIVS:
415 case OP_59_FRES:
416 case OP_59_FRSQRTES:
417 return true;
418 }
419 switch (inst_get_field(inst, 26, 30)) {
420 case OP_59_FMULS:
421 case OP_59_FMSUBS:
422 case OP_59_FMADDS:
423 case OP_59_FNMSUBS:
424 case OP_59_FNMADDS:
425 return true;
426 }
427 break;
428 case 63:
429 switch (inst_get_field(inst, 21, 30)) {
430 case OP_63_MTFSB0:
431 case OP_63_MTFSB1:
432 case OP_63_MTFSF:
433 case OP_63_MTFSFI:
434 case OP_63_MCRFS:
435 case OP_63_MFFS:
436 case OP_63_FCMPU:
437 case OP_63_FCMPO:
438 case OP_63_FNEG:
439 case OP_63_FMR:
440 case OP_63_FABS:
441 case OP_63_FRSP:
442 case OP_63_FDIV:
443 case OP_63_FADD:
444 case OP_63_FSUB:
445 case OP_63_FCTIW:
446 case OP_63_FCTIWZ:
447 case OP_63_FRSQRTE:
448 case OP_63_FCPSGN:
449 return true;
450 }
451 switch (inst_get_field(inst, 26, 30)) {
452 case OP_63_FMUL:
453 case OP_63_FSEL:
454 case OP_63_FMSUB:
455 case OP_63_FMADD:
456 case OP_63_FNMSUB:
457 case OP_63_FNMADD:
458 return true;
459 }
460 break;
461 case 31:
462 switch (inst_get_field(inst, 21, 30)) {
463 case OP_31_LFSX:
464 case OP_31_LFSUX:
465 case OP_31_LFDX:
466 case OP_31_LFDUX:
467 case OP_31_STFSX:
468 case OP_31_STFSUX:
469 case OP_31_STFX:
470 case OP_31_STFUX:
471 case OP_31_STFIWX:
472 return true;
473 }
474 break;
475 }
476
477 return false;
478 }
479
480 static int get_d_signext(u32 inst)
481 {
482 int d = inst & 0x8ff;
483
484 if (d & 0x800)
485 return -(d & 0x7ff);
486
487 return (d & 0x7ff);
488 }
489
490 static int kvmppc_ps_three_in(struct kvm_vcpu *vcpu, bool rc,
491 int reg_out, int reg_in1, int reg_in2,
492 int reg_in3, int scalar,
493 void (*func)(u64 *fpscr,
494 u32 *dst, u32 *src1,
495 u32 *src2, u32 *src3))
496 {
497 u32 *qpr = vcpu->arch.qpr;
498 u32 ps0_out;
499 u32 ps0_in1, ps0_in2, ps0_in3;
500 u32 ps1_in1, ps1_in2, ps1_in3;
501
502 /* RC */
503 WARN_ON(rc);
504
505 /* PS0 */
506 kvm_cvt_df(&VCPU_FPR(vcpu, reg_in1), &ps0_in1);
507 kvm_cvt_df(&VCPU_FPR(vcpu, reg_in2), &ps0_in2);
508 kvm_cvt_df(&VCPU_FPR(vcpu, reg_in3), &ps0_in3);
509
510 if (scalar & SCALAR_LOW)
511 ps0_in2 = qpr[reg_in2];
512
513 func(&vcpu->arch.fp.fpscr, &ps0_out, &ps0_in1, &ps0_in2, &ps0_in3);
514
515 dprintk(KERN_INFO "PS3 ps0 -> f(0x%x, 0x%x, 0x%x) = 0x%x\n",
516 ps0_in1, ps0_in2, ps0_in3, ps0_out);
517
518 if (!(scalar & SCALAR_NO_PS0))
519 kvm_cvt_fd(&ps0_out, &VCPU_FPR(vcpu, reg_out));
520
521 /* PS1 */
522 ps1_in1 = qpr[reg_in1];
523 ps1_in2 = qpr[reg_in2];
524 ps1_in3 = qpr[reg_in3];
525
526 if (scalar & SCALAR_HIGH)
527 ps1_in2 = ps0_in2;
528
529 if (!(scalar & SCALAR_NO_PS1))
530 func(&vcpu->arch.fp.fpscr, &qpr[reg_out], &ps1_in1, &ps1_in2, &ps1_in3);
531
532 dprintk(KERN_INFO "PS3 ps1 -> f(0x%x, 0x%x, 0x%x) = 0x%x\n",
533 ps1_in1, ps1_in2, ps1_in3, qpr[reg_out]);
534
535 return EMULATE_DONE;
536 }
537
538 static int kvmppc_ps_two_in(struct kvm_vcpu *vcpu, bool rc,
539 int reg_out, int reg_in1, int reg_in2,
540 int scalar,
541 void (*func)(u64 *fpscr,
542 u32 *dst, u32 *src1,
543 u32 *src2))
544 {
545 u32 *qpr = vcpu->arch.qpr;
546 u32 ps0_out;
547 u32 ps0_in1, ps0_in2;
548 u32 ps1_out;
549 u32 ps1_in1, ps1_in2;
550
551 /* RC */
552 WARN_ON(rc);
553
554 /* PS0 */
555 kvm_cvt_df(&VCPU_FPR(vcpu, reg_in1), &ps0_in1);
556
557 if (scalar & SCALAR_LOW)
558 ps0_in2 = qpr[reg_in2];
559 else
560 kvm_cvt_df(&VCPU_FPR(vcpu, reg_in2), &ps0_in2);
561
562 func(&vcpu->arch.fp.fpscr, &ps0_out, &ps0_in1, &ps0_in2);
563
564 if (!(scalar & SCALAR_NO_PS0)) {
565 dprintk(KERN_INFO "PS2 ps0 -> f(0x%x, 0x%x) = 0x%x\n",
566 ps0_in1, ps0_in2, ps0_out);
567
568 kvm_cvt_fd(&ps0_out, &VCPU_FPR(vcpu, reg_out));
569 }
570
571 /* PS1 */
572 ps1_in1 = qpr[reg_in1];
573 ps1_in2 = qpr[reg_in2];
574
575 if (scalar & SCALAR_HIGH)
576 ps1_in2 = ps0_in2;
577
578 func(&vcpu->arch.fp.fpscr, &ps1_out, &ps1_in1, &ps1_in2);
579
580 if (!(scalar & SCALAR_NO_PS1)) {
581 qpr[reg_out] = ps1_out;
582
583 dprintk(KERN_INFO "PS2 ps1 -> f(0x%x, 0x%x) = 0x%x\n",
584 ps1_in1, ps1_in2, qpr[reg_out]);
585 }
586
587 return EMULATE_DONE;
588 }
589
590 static int kvmppc_ps_one_in(struct kvm_vcpu *vcpu, bool rc,
591 int reg_out, int reg_in,
592 void (*func)(u64 *t,
593 u32 *dst, u32 *src1))
594 {
595 u32 *qpr = vcpu->arch.qpr;
596 u32 ps0_out, ps0_in;
597 u32 ps1_in;
598
599 /* RC */
600 WARN_ON(rc);
601
602 /* PS0 */
603 kvm_cvt_df(&VCPU_FPR(vcpu, reg_in), &ps0_in);
604 func(&vcpu->arch.fp.fpscr, &ps0_out, &ps0_in);
605
606 dprintk(KERN_INFO "PS1 ps0 -> f(0x%x) = 0x%x\n",
607 ps0_in, ps0_out);
608
609 kvm_cvt_fd(&ps0_out, &VCPU_FPR(vcpu, reg_out));
610
611 /* PS1 */
612 ps1_in = qpr[reg_in];
613 func(&vcpu->arch.fp.fpscr, &qpr[reg_out], &ps1_in);
614
615 dprintk(KERN_INFO "PS1 ps1 -> f(0x%x) = 0x%x\n",
616 ps1_in, qpr[reg_out]);
617
618 return EMULATE_DONE;
619 }
620
621 int kvmppc_emulate_paired_single(struct kvm_vcpu *vcpu)
622 {
623 u32 inst;
624 ppc_inst_t pinst;
625 enum emulation_result emulated = EMULATE_DONE;
626 int ax_rd, ax_ra, ax_rb, ax_rc;
627 short full_d;
628 u64 *fpr_d, *fpr_a, *fpr_b, *fpr_c;
629
630 bool rcomp;
631 u32 cr;
632 #ifdef DEBUG
633 int i;
634 #endif
635
636 emulated = kvmppc_get_last_inst(vcpu, INST_GENERIC, &pinst);
637 inst = ppc_inst_val(pinst);
638 if (emulated != EMULATE_DONE)
639 return emulated;
640
641 ax_rd = inst_get_field(inst, 6, 10);
642 ax_ra = inst_get_field(inst, 11, 15);
643 ax_rb = inst_get_field(inst, 16, 20);
644 ax_rc = inst_get_field(inst, 21, 25);
645 full_d = inst_get_field(inst, 16, 31);
646
647 fpr_d = &VCPU_FPR(vcpu, ax_rd);
648 fpr_a = &VCPU_FPR(vcpu, ax_ra);
649 fpr_b = &VCPU_FPR(vcpu, ax_rb);
650 fpr_c = &VCPU_FPR(vcpu, ax_rc);
651
652 rcomp = (inst & 1) ? true : false;
653 cr = kvmppc_get_cr(vcpu);
654
655 if (!kvmppc_inst_is_paired_single(vcpu, inst))
656 return EMULATE_FAIL;
657
658 if (!(kvmppc_get_msr(vcpu) & MSR_FP)) {
659 kvmppc_book3s_queue_irqprio(vcpu, BOOK3S_INTERRUPT_FP_UNAVAIL);
660 return EMULATE_AGAIN;
661 }
662
663 kvmppc_giveup_ext(vcpu, MSR_FP);
664 preempt_disable();
665 enable_kernel_fp();
666 /* Do we need to clear FE0 / FE1 here? Don't think so. */
667
668 #ifdef DEBUG
669 for (i = 0; i < ARRAY_SIZE(vcpu->arch.fp.fpr); i++) {
670 u32 f;
671 kvm_cvt_df(&VCPU_FPR(vcpu, i), &f);
672 dprintk(KERN_INFO "FPR[%d] = 0x%x / 0x%llx QPR[%d] = 0x%x\n",
673 i, f, VCPU_FPR(vcpu, i), i, vcpu->arch.qpr[i]);
674 }
675 #endif
676
677 switch (get_op(inst)) {
678 case OP_PSQ_L:
679 {
680 ulong addr = ax_ra ? kvmppc_get_gpr(vcpu, ax_ra) : 0;
681 bool w = inst_get_field(inst, 16, 16) ? true : false;
682 int i = inst_get_field(inst, 17, 19);
683
684 addr += get_d_signext(inst);
685 emulated = kvmppc_emulate_psq_load(vcpu, ax_rd, addr, w, i);
686 break;
687 }
688 case OP_PSQ_LU:
689 {
690 ulong addr = kvmppc_get_gpr(vcpu, ax_ra);
691 bool w = inst_get_field(inst, 16, 16) ? true : false;
692 int i = inst_get_field(inst, 17, 19);
693
694 addr += get_d_signext(inst);
695 emulated = kvmppc_emulate_psq_load(vcpu, ax_rd, addr, w, i);
696
697 if (emulated == EMULATE_DONE)
698 kvmppc_set_gpr(vcpu, ax_ra, addr);
699 break;
700 }
701 case OP_PSQ_ST:
702 {
703 ulong addr = ax_ra ? kvmppc_get_gpr(vcpu, ax_ra) : 0;
704 bool w = inst_get_field(inst, 16, 16) ? true : false;
705 int i = inst_get_field(inst, 17, 19);
706
707 addr += get_d_signext(inst);
708 emulated = kvmppc_emulate_psq_store(vcpu, ax_rd, addr, w, i);
709 break;
710 }
711 case OP_PSQ_STU:
712 {
713 ulong addr = kvmppc_get_gpr(vcpu, ax_ra);
714 bool w = inst_get_field(inst, 16, 16) ? true : false;
715 int i = inst_get_field(inst, 17, 19);
716
717 addr += get_d_signext(inst);
718 emulated = kvmppc_emulate_psq_store(vcpu, ax_rd, addr, w, i);
719
720 if (emulated == EMULATE_DONE)
721 kvmppc_set_gpr(vcpu, ax_ra, addr);
722 break;
723 }
724 case 4:
725 /* X form */
726 switch (inst_get_field(inst, 21, 30)) {
727 case OP_4X_PS_CMPU0:
728 /* XXX */
729 emulated = EMULATE_FAIL;
730 break;
731 case OP_4X_PSQ_LX:
732 {
733 ulong addr = ax_ra ? kvmppc_get_gpr(vcpu, ax_ra) : 0;
734 bool w = inst_get_field(inst, 21, 21) ? true : false;
735 int i = inst_get_field(inst, 22, 24);
736
737 addr += kvmppc_get_gpr(vcpu, ax_rb);
738 emulated = kvmppc_emulate_psq_load(vcpu, ax_rd, addr, w, i);
739 break;
740 }
741 case OP_4X_PS_CMPO0:
742 /* XXX */
743 emulated = EMULATE_FAIL;
744 break;
745 case OP_4X_PSQ_LUX:
746 {
747 ulong addr = kvmppc_get_gpr(vcpu, ax_ra);
748 bool w = inst_get_field(inst, 21, 21) ? true : false;
749 int i = inst_get_field(inst, 22, 24);
750
751 addr += kvmppc_get_gpr(vcpu, ax_rb);
752 emulated = kvmppc_emulate_psq_load(vcpu, ax_rd, addr, w, i);
753
754 if (emulated == EMULATE_DONE)
755 kvmppc_set_gpr(vcpu, ax_ra, addr);
756 break;
757 }
758 case OP_4X_PS_NEG:
759 VCPU_FPR(vcpu, ax_rd) = VCPU_FPR(vcpu, ax_rb);
760 VCPU_FPR(vcpu, ax_rd) ^= 0x8000000000000000ULL;
761 vcpu->arch.qpr[ax_rd] = vcpu->arch.qpr[ax_rb];
762 vcpu->arch.qpr[ax_rd] ^= 0x80000000;
763 break;
764 case OP_4X_PS_CMPU1:
765 /* XXX */
766 emulated = EMULATE_FAIL;
767 break;
768 case OP_4X_PS_MR:
769 WARN_ON(rcomp);
770 VCPU_FPR(vcpu, ax_rd) = VCPU_FPR(vcpu, ax_rb);
771 vcpu->arch.qpr[ax_rd] = vcpu->arch.qpr[ax_rb];
772 break;
773 case OP_4X_PS_CMPO1:
774 /* XXX */
775 emulated = EMULATE_FAIL;
776 break;
777 case OP_4X_PS_NABS:
778 WARN_ON(rcomp);
779 VCPU_FPR(vcpu, ax_rd) = VCPU_FPR(vcpu, ax_rb);
780 VCPU_FPR(vcpu, ax_rd) |= 0x8000000000000000ULL;
781 vcpu->arch.qpr[ax_rd] = vcpu->arch.qpr[ax_rb];
782 vcpu->arch.qpr[ax_rd] |= 0x80000000;
783 break;
784 case OP_4X_PS_ABS:
785 WARN_ON(rcomp);
786 VCPU_FPR(vcpu, ax_rd) = VCPU_FPR(vcpu, ax_rb);
787 VCPU_FPR(vcpu, ax_rd) &= ~0x8000000000000000ULL;
788 vcpu->arch.qpr[ax_rd] = vcpu->arch.qpr[ax_rb];
789 vcpu->arch.qpr[ax_rd] &= ~0x80000000;
790 break;
791 case OP_4X_PS_MERGE00:
792 WARN_ON(rcomp);
793 VCPU_FPR(vcpu, ax_rd) = VCPU_FPR(vcpu, ax_ra);
794 /* vcpu->arch.qpr[ax_rd] = VCPU_FPR(vcpu, ax_rb); */
795 kvm_cvt_df(&VCPU_FPR(vcpu, ax_rb),
796 &vcpu->arch.qpr[ax_rd]);
797 break;
798 case OP_4X_PS_MERGE01:
799 WARN_ON(rcomp);
800 VCPU_FPR(vcpu, ax_rd) = VCPU_FPR(vcpu, ax_ra);
801 vcpu->arch.qpr[ax_rd] = vcpu->arch.qpr[ax_rb];
802 break;
803 case OP_4X_PS_MERGE10:
804 WARN_ON(rcomp);
805 /* VCPU_FPR(vcpu, ax_rd) = vcpu->arch.qpr[ax_ra]; */
806 kvm_cvt_fd(&vcpu->arch.qpr[ax_ra],
807 &VCPU_FPR(vcpu, ax_rd));
808 /* vcpu->arch.qpr[ax_rd] = VCPU_FPR(vcpu, ax_rb); */
809 kvm_cvt_df(&VCPU_FPR(vcpu, ax_rb),
810 &vcpu->arch.qpr[ax_rd]);
811 break;
812 case OP_4X_PS_MERGE11:
813 WARN_ON(rcomp);
814 /* VCPU_FPR(vcpu, ax_rd) = vcpu->arch.qpr[ax_ra]; */
815 kvm_cvt_fd(&vcpu->arch.qpr[ax_ra],
816 &VCPU_FPR(vcpu, ax_rd));
817 vcpu->arch.qpr[ax_rd] = vcpu->arch.qpr[ax_rb];
818 break;
819 }
820 /* XW form */
821 switch (inst_get_field(inst, 25, 30)) {
822 case OP_4XW_PSQ_STX:
823 {
824 ulong addr = ax_ra ? kvmppc_get_gpr(vcpu, ax_ra) : 0;
825 bool w = inst_get_field(inst, 21, 21) ? true : false;
826 int i = inst_get_field(inst, 22, 24);
827
828 addr += kvmppc_get_gpr(vcpu, ax_rb);
829 emulated = kvmppc_emulate_psq_store(vcpu, ax_rd, addr, w, i);
830 break;
831 }
832 case OP_4XW_PSQ_STUX:
833 {
834 ulong addr = kvmppc_get_gpr(vcpu, ax_ra);
835 bool w = inst_get_field(inst, 21, 21) ? true : false;
836 int i = inst_get_field(inst, 22, 24);
837
838 addr += kvmppc_get_gpr(vcpu, ax_rb);
839 emulated = kvmppc_emulate_psq_store(vcpu, ax_rd, addr, w, i);
840
841 if (emulated == EMULATE_DONE)
842 kvmppc_set_gpr(vcpu, ax_ra, addr);
843 break;
844 }
845 }
846 /* A form */
847 switch (inst_get_field(inst, 26, 30)) {
848 case OP_4A_PS_SUM1:
849 emulated = kvmppc_ps_two_in(vcpu, rcomp, ax_rd,
850 ax_rb, ax_ra, SCALAR_NO_PS0 | SCALAR_HIGH, fps_fadds);
851 VCPU_FPR(vcpu, ax_rd) = VCPU_FPR(vcpu, ax_rc);
852 break;
853 case OP_4A_PS_SUM0:
854 emulated = kvmppc_ps_two_in(vcpu, rcomp, ax_rd,
855 ax_ra, ax_rb, SCALAR_NO_PS1 | SCALAR_LOW, fps_fadds);
856 vcpu->arch.qpr[ax_rd] = vcpu->arch.qpr[ax_rc];
857 break;
858 case OP_4A_PS_MULS0:
859 emulated = kvmppc_ps_two_in(vcpu, rcomp, ax_rd,
860 ax_ra, ax_rc, SCALAR_HIGH, fps_fmuls);
861 break;
862 case OP_4A_PS_MULS1:
863 emulated = kvmppc_ps_two_in(vcpu, rcomp, ax_rd,
864 ax_ra, ax_rc, SCALAR_LOW, fps_fmuls);
865 break;
866 case OP_4A_PS_MADDS0:
867 emulated = kvmppc_ps_three_in(vcpu, rcomp, ax_rd,
868 ax_ra, ax_rc, ax_rb, SCALAR_HIGH, fps_fmadds);
869 break;
870 case OP_4A_PS_MADDS1:
871 emulated = kvmppc_ps_three_in(vcpu, rcomp, ax_rd,
872 ax_ra, ax_rc, ax_rb, SCALAR_LOW, fps_fmadds);
873 break;
874 case OP_4A_PS_DIV:
875 emulated = kvmppc_ps_two_in(vcpu, rcomp, ax_rd,
876 ax_ra, ax_rb, SCALAR_NONE, fps_fdivs);
877 break;
878 case OP_4A_PS_SUB:
879 emulated = kvmppc_ps_two_in(vcpu, rcomp, ax_rd,
880 ax_ra, ax_rb, SCALAR_NONE, fps_fsubs);
881 break;
882 case OP_4A_PS_ADD:
883 emulated = kvmppc_ps_two_in(vcpu, rcomp, ax_rd,
884 ax_ra, ax_rb, SCALAR_NONE, fps_fadds);
885 break;
886 case OP_4A_PS_SEL:
887 emulated = kvmppc_ps_three_in(vcpu, rcomp, ax_rd,
888 ax_ra, ax_rc, ax_rb, SCALAR_NONE, fps_fsel);
889 break;
890 case OP_4A_PS_RES:
891 emulated = kvmppc_ps_one_in(vcpu, rcomp, ax_rd,
892 ax_rb, fps_fres);
893 break;
894 case OP_4A_PS_MUL:
895 emulated = kvmppc_ps_two_in(vcpu, rcomp, ax_rd,
896 ax_ra, ax_rc, SCALAR_NONE, fps_fmuls);
897 break;
898 case OP_4A_PS_RSQRTE:
899 emulated = kvmppc_ps_one_in(vcpu, rcomp, ax_rd,
900 ax_rb, fps_frsqrte);
901 break;
902 case OP_4A_PS_MSUB:
903 emulated = kvmppc_ps_three_in(vcpu, rcomp, ax_rd,
904 ax_ra, ax_rc, ax_rb, SCALAR_NONE, fps_fmsubs);
905 break;
906 case OP_4A_PS_MADD:
907 emulated = kvmppc_ps_three_in(vcpu, rcomp, ax_rd,
908 ax_ra, ax_rc, ax_rb, SCALAR_NONE, fps_fmadds);
909 break;
910 case OP_4A_PS_NMSUB:
911 emulated = kvmppc_ps_three_in(vcpu, rcomp, ax_rd,
912 ax_ra, ax_rc, ax_rb, SCALAR_NONE, fps_fnmsubs);
913 break;
914 case OP_4A_PS_NMADD:
915 emulated = kvmppc_ps_three_in(vcpu, rcomp, ax_rd,
916 ax_ra, ax_rc, ax_rb, SCALAR_NONE, fps_fnmadds);
917 break;
918 }
919 break;
920
921 /* Real FPU operations */
922
923 case OP_LFS:
924 {
925 ulong addr = (ax_ra ? kvmppc_get_gpr(vcpu, ax_ra) : 0) + full_d;
926
927 emulated = kvmppc_emulate_fpr_load(vcpu, ax_rd, addr,
928 FPU_LS_SINGLE);
929 break;
930 }
931 case OP_LFSU:
932 {
933 ulong addr = kvmppc_get_gpr(vcpu, ax_ra) + full_d;
934
935 emulated = kvmppc_emulate_fpr_load(vcpu, ax_rd, addr,
936 FPU_LS_SINGLE);
937
938 if (emulated == EMULATE_DONE)
939 kvmppc_set_gpr(vcpu, ax_ra, addr);
940 break;
941 }
942 case OP_LFD:
943 {
944 ulong addr = (ax_ra ? kvmppc_get_gpr(vcpu, ax_ra) : 0) + full_d;
945
946 emulated = kvmppc_emulate_fpr_load(vcpu, ax_rd, addr,
947 FPU_LS_DOUBLE);
948 break;
949 }
950 case OP_LFDU:
951 {
952 ulong addr = kvmppc_get_gpr(vcpu, ax_ra) + full_d;
953
954 emulated = kvmppc_emulate_fpr_load(vcpu, ax_rd, addr,
955 FPU_LS_DOUBLE);
956
957 if (emulated == EMULATE_DONE)
958 kvmppc_set_gpr(vcpu, ax_ra, addr);
959 break;
960 }
961 case OP_STFS:
962 {
963 ulong addr = (ax_ra ? kvmppc_get_gpr(vcpu, ax_ra) : 0) + full_d;
964
965 emulated = kvmppc_emulate_fpr_store(vcpu, ax_rd, addr,
966 FPU_LS_SINGLE);
967 break;
968 }
969 case OP_STFSU:
970 {
971 ulong addr = kvmppc_get_gpr(vcpu, ax_ra) + full_d;
972
973 emulated = kvmppc_emulate_fpr_store(vcpu, ax_rd, addr,
974 FPU_LS_SINGLE);
975
976 if (emulated == EMULATE_DONE)
977 kvmppc_set_gpr(vcpu, ax_ra, addr);
978 break;
979 }
980 case OP_STFD:
981 {
982 ulong addr = (ax_ra ? kvmppc_get_gpr(vcpu, ax_ra) : 0) + full_d;
983
984 emulated = kvmppc_emulate_fpr_store(vcpu, ax_rd, addr,
985 FPU_LS_DOUBLE);
986 break;
987 }
988 case OP_STFDU:
989 {
990 ulong addr = kvmppc_get_gpr(vcpu, ax_ra) + full_d;
991
992 emulated = kvmppc_emulate_fpr_store(vcpu, ax_rd, addr,
993 FPU_LS_DOUBLE);
994
995 if (emulated == EMULATE_DONE)
996 kvmppc_set_gpr(vcpu, ax_ra, addr);
997 break;
998 }
999 case 31:
1000 switch (inst_get_field(inst, 21, 30)) {
1001 case OP_31_LFSX:
1002 {
1003 ulong addr = ax_ra ? kvmppc_get_gpr(vcpu, ax_ra) : 0;
1004
1005 addr += kvmppc_get_gpr(vcpu, ax_rb);
1006 emulated = kvmppc_emulate_fpr_load(vcpu, ax_rd,
1007 addr, FPU_LS_SINGLE);
1008 break;
1009 }
1010 case OP_31_LFSUX:
1011 {
1012 ulong addr = kvmppc_get_gpr(vcpu, ax_ra) +
1013 kvmppc_get_gpr(vcpu, ax_rb);
1014
1015 emulated = kvmppc_emulate_fpr_load(vcpu, ax_rd,
1016 addr, FPU_LS_SINGLE);
1017
1018 if (emulated == EMULATE_DONE)
1019 kvmppc_set_gpr(vcpu, ax_ra, addr);
1020 break;
1021 }
1022 case OP_31_LFDX:
1023 {
1024 ulong addr = (ax_ra ? kvmppc_get_gpr(vcpu, ax_ra) : 0) +
1025 kvmppc_get_gpr(vcpu, ax_rb);
1026
1027 emulated = kvmppc_emulate_fpr_load(vcpu, ax_rd,
1028 addr, FPU_LS_DOUBLE);
1029 break;
1030 }
1031 case OP_31_LFDUX:
1032 {
1033 ulong addr = kvmppc_get_gpr(vcpu, ax_ra) +
1034 kvmppc_get_gpr(vcpu, ax_rb);
1035
1036 emulated = kvmppc_emulate_fpr_load(vcpu, ax_rd,
1037 addr, FPU_LS_DOUBLE);
1038
1039 if (emulated == EMULATE_DONE)
1040 kvmppc_set_gpr(vcpu, ax_ra, addr);
1041 break;
1042 }
1043 case OP_31_STFSX:
1044 {
1045 ulong addr = (ax_ra ? kvmppc_get_gpr(vcpu, ax_ra) : 0) +
1046 kvmppc_get_gpr(vcpu, ax_rb);
1047
1048 emulated = kvmppc_emulate_fpr_store(vcpu, ax_rd,
1049 addr, FPU_LS_SINGLE);
1050 break;
1051 }
1052 case OP_31_STFSUX:
1053 {
1054 ulong addr = kvmppc_get_gpr(vcpu, ax_ra) +
1055 kvmppc_get_gpr(vcpu, ax_rb);
1056
1057 emulated = kvmppc_emulate_fpr_store(vcpu, ax_rd,
1058 addr, FPU_LS_SINGLE);
1059
1060 if (emulated == EMULATE_DONE)
1061 kvmppc_set_gpr(vcpu, ax_ra, addr);
1062 break;
1063 }
1064 case OP_31_STFX:
1065 {
1066 ulong addr = (ax_ra ? kvmppc_get_gpr(vcpu, ax_ra) : 0) +
1067 kvmppc_get_gpr(vcpu, ax_rb);
1068
1069 emulated = kvmppc_emulate_fpr_store(vcpu, ax_rd,
1070 addr, FPU_LS_DOUBLE);
1071 break;
1072 }
1073 case OP_31_STFUX:
1074 {
1075 ulong addr = kvmppc_get_gpr(vcpu, ax_ra) +
1076 kvmppc_get_gpr(vcpu, ax_rb);
1077
1078 emulated = kvmppc_emulate_fpr_store(vcpu, ax_rd,
1079 addr, FPU_LS_DOUBLE);
1080
1081 if (emulated == EMULATE_DONE)
1082 kvmppc_set_gpr(vcpu, ax_ra, addr);
1083 break;
1084 }
1085 case OP_31_STFIWX:
1086 {
1087 ulong addr = (ax_ra ? kvmppc_get_gpr(vcpu, ax_ra) : 0) +
1088 kvmppc_get_gpr(vcpu, ax_rb);
1089
1090 emulated = kvmppc_emulate_fpr_store(vcpu, ax_rd,
1091 addr,
1092 FPU_LS_SINGLE_LOW);
1093 break;
1094 }
1095 break;
1096 }
1097 break;
1098 case 59:
1099 switch (inst_get_field(inst, 21, 30)) {
1100 case OP_59_FADDS:
1101 fpd_fadds(&vcpu->arch.fp.fpscr, &cr, fpr_d, fpr_a, fpr_b);
1102 kvmppc_sync_qpr(vcpu, ax_rd);
1103 break;
1104 case OP_59_FSUBS:
1105 fpd_fsubs(&vcpu->arch.fp.fpscr, &cr, fpr_d, fpr_a, fpr_b);
1106 kvmppc_sync_qpr(vcpu, ax_rd);
1107 break;
1108 case OP_59_FDIVS:
1109 fpd_fdivs(&vcpu->arch.fp.fpscr, &cr, fpr_d, fpr_a, fpr_b);
1110 kvmppc_sync_qpr(vcpu, ax_rd);
1111 break;
1112 case OP_59_FRES:
1113 fpd_fres(&vcpu->arch.fp.fpscr, &cr, fpr_d, fpr_b);
1114 kvmppc_sync_qpr(vcpu, ax_rd);
1115 break;
1116 case OP_59_FRSQRTES:
1117 fpd_frsqrtes(&vcpu->arch.fp.fpscr, &cr, fpr_d, fpr_b);
1118 kvmppc_sync_qpr(vcpu, ax_rd);
1119 break;
1120 }
1121 switch (inst_get_field(inst, 26, 30)) {
1122 case OP_59_FMULS:
1123 fpd_fmuls(&vcpu->arch.fp.fpscr, &cr, fpr_d, fpr_a, fpr_c);
1124 kvmppc_sync_qpr(vcpu, ax_rd);
1125 break;
1126 case OP_59_FMSUBS:
1127 fpd_fmsubs(&vcpu->arch.fp.fpscr, &cr, fpr_d, fpr_a, fpr_c, fpr_b);
1128 kvmppc_sync_qpr(vcpu, ax_rd);
1129 break;
1130 case OP_59_FMADDS:
1131 fpd_fmadds(&vcpu->arch.fp.fpscr, &cr, fpr_d, fpr_a, fpr_c, fpr_b);
1132 kvmppc_sync_qpr(vcpu, ax_rd);
1133 break;
1134 case OP_59_FNMSUBS:
1135 fpd_fnmsubs(&vcpu->arch.fp.fpscr, &cr, fpr_d, fpr_a, fpr_c, fpr_b);
1136 kvmppc_sync_qpr(vcpu, ax_rd);
1137 break;
1138 case OP_59_FNMADDS:
1139 fpd_fnmadds(&vcpu->arch.fp.fpscr, &cr, fpr_d, fpr_a, fpr_c, fpr_b);
1140 kvmppc_sync_qpr(vcpu, ax_rd);
1141 break;
1142 }
1143 break;
1144 case 63:
1145 switch (inst_get_field(inst, 21, 30)) {
1146 case OP_63_MTFSB0:
1147 case OP_63_MTFSB1:
1148 case OP_63_MCRFS:
1149 case OP_63_MTFSFI:
1150 /* XXX need to implement */
1151 break;
1152 case OP_63_MFFS:
1153 /* XXX missing CR */
1154 *fpr_d = vcpu->arch.fp.fpscr;
1155 break;
1156 case OP_63_MTFSF:
1157 /* XXX missing fm bits */
1158 /* XXX missing CR */
1159 vcpu->arch.fp.fpscr = *fpr_b;
1160 break;
1161 case OP_63_FCMPU:
1162 {
1163 u32 tmp_cr;
1164 u32 cr0_mask = 0xf0000000;
1165 u32 cr_shift = inst_get_field(inst, 6, 8) * 4;
1166
1167 fpd_fcmpu(&vcpu->arch.fp.fpscr, &tmp_cr, fpr_a, fpr_b);
1168 cr &= ~(cr0_mask >> cr_shift);
1169 cr |= (cr & cr0_mask) >> cr_shift;
1170 break;
1171 }
1172 case OP_63_FCMPO:
1173 {
1174 u32 tmp_cr;
1175 u32 cr0_mask = 0xf0000000;
1176 u32 cr_shift = inst_get_field(inst, 6, 8) * 4;
1177
1178 fpd_fcmpo(&vcpu->arch.fp.fpscr, &tmp_cr, fpr_a, fpr_b);
1179 cr &= ~(cr0_mask >> cr_shift);
1180 cr |= (cr & cr0_mask) >> cr_shift;
1181 break;
1182 }
1183 case OP_63_FNEG:
1184 fpd_fneg(&vcpu->arch.fp.fpscr, &cr, fpr_d, fpr_b);
1185 break;
1186 case OP_63_FMR:
1187 *fpr_d = *fpr_b;
1188 break;
1189 case OP_63_FABS:
1190 fpd_fabs(&vcpu->arch.fp.fpscr, &cr, fpr_d, fpr_b);
1191 break;
1192 case OP_63_FCPSGN:
1193 fpd_fcpsgn(&vcpu->arch.fp.fpscr, &cr, fpr_d, fpr_a, fpr_b);
1194 break;
1195 case OP_63_FDIV:
1196 fpd_fdiv(&vcpu->arch.fp.fpscr, &cr, fpr_d, fpr_a, fpr_b);
1197 break;
1198 case OP_63_FADD:
1199 fpd_fadd(&vcpu->arch.fp.fpscr, &cr, fpr_d, fpr_a, fpr_b);
1200 break;
1201 case OP_63_FSUB:
1202 fpd_fsub(&vcpu->arch.fp.fpscr, &cr, fpr_d, fpr_a, fpr_b);
1203 break;
1204 case OP_63_FCTIW:
1205 fpd_fctiw(&vcpu->arch.fp.fpscr, &cr, fpr_d, fpr_b);
1206 break;
1207 case OP_63_FCTIWZ:
1208 fpd_fctiwz(&vcpu->arch.fp.fpscr, &cr, fpr_d, fpr_b);
1209 break;
1210 case OP_63_FRSP:
1211 fpd_frsp(&vcpu->arch.fp.fpscr, &cr, fpr_d, fpr_b);
1212 kvmppc_sync_qpr(vcpu, ax_rd);
1213 break;
1214 case OP_63_FRSQRTE:
1215 {
1216 double one = 1.0f;
1217
1218 /* fD = sqrt(fB) */
1219 fpd_fsqrt(&vcpu->arch.fp.fpscr, &cr, fpr_d, fpr_b);
1220 /* fD = 1.0f / fD */
1221 fpd_fdiv(&vcpu->arch.fp.fpscr, &cr, fpr_d, (u64*)&one, fpr_d);
1222 break;
1223 }
1224 }
1225 switch (inst_get_field(inst, 26, 30)) {
1226 case OP_63_FMUL:
1227 fpd_fmul(&vcpu->arch.fp.fpscr, &cr, fpr_d, fpr_a, fpr_c);
1228 break;
1229 case OP_63_FSEL:
1230 fpd_fsel(&vcpu->arch.fp.fpscr, &cr, fpr_d, fpr_a, fpr_c, fpr_b);
1231 break;
1232 case OP_63_FMSUB:
1233 fpd_fmsub(&vcpu->arch.fp.fpscr, &cr, fpr_d, fpr_a, fpr_c, fpr_b);
1234 break;
1235 case OP_63_FMADD:
1236 fpd_fmadd(&vcpu->arch.fp.fpscr, &cr, fpr_d, fpr_a, fpr_c, fpr_b);
1237 break;
1238 case OP_63_FNMSUB:
1239 fpd_fnmsub(&vcpu->arch.fp.fpscr, &cr, fpr_d, fpr_a, fpr_c, fpr_b);
1240 break;
1241 case OP_63_FNMADD:
1242 fpd_fnmadd(&vcpu->arch.fp.fpscr, &cr, fpr_d, fpr_a, fpr_c, fpr_b);
1243 break;
1244 }
1245 break;
1246 }
1247
1248 #ifdef DEBUG
1249 for (i = 0; i < ARRAY_SIZE(vcpu->arch.fp.fpr); i++) {
1250 u32 f;
1251 kvm_cvt_df(&VCPU_FPR(vcpu, i), &f);
1252 dprintk(KERN_INFO "FPR[%d] = 0x%x\n", i, f);
1253 }
1254 #endif
1255
1256 if (rcomp)
1257 kvmppc_set_cr(vcpu, cr);
1258
1259 disable_kernel_fp();
1260 preempt_enable();
1261
1262 return emulated;
1263 }
1264
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.