Loading...
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 *
4 * Copyright IBM Corp. 2008
5 * Copyright 2011 Freescale Semiconductor, Inc.
6 *
7 * Authors: Hollis Blanchard <hollisb@us.ibm.com>
8 */
9
10#include <linux/kvm_host.h>
11#include <asm/disassemble.h>
12
13#include "booke.h"
14
15#define OP_19_XOP_RFI 50
16#define OP_19_XOP_RFCI 51
17#define OP_19_XOP_RFDI 39
18
19#define OP_31_XOP_MFMSR 83
20#define OP_31_XOP_WRTEE 131
21#define OP_31_XOP_MTMSR 146
22#define OP_31_XOP_WRTEEI 163
23
24static void kvmppc_emul_rfi(struct kvm_vcpu *vcpu)
25{
26 vcpu->arch.regs.nip = vcpu->arch.shared->srr0;
27 kvmppc_set_msr(vcpu, vcpu->arch.shared->srr1);
28}
29
30static void kvmppc_emul_rfdi(struct kvm_vcpu *vcpu)
31{
32 vcpu->arch.regs.nip = vcpu->arch.dsrr0;
33 kvmppc_set_msr(vcpu, vcpu->arch.dsrr1);
34}
35
36static void kvmppc_emul_rfci(struct kvm_vcpu *vcpu)
37{
38 vcpu->arch.regs.nip = vcpu->arch.csrr0;
39 kvmppc_set_msr(vcpu, vcpu->arch.csrr1);
40}
41
42int kvmppc_booke_emulate_op(struct kvm_vcpu *vcpu,
43 unsigned int inst, int *advance)
44{
45 int emulated = EMULATE_DONE;
46 int rs = get_rs(inst);
47 int rt = get_rt(inst);
48
49 switch (get_op(inst)) {
50 case 19:
51 switch (get_xop(inst)) {
52 case OP_19_XOP_RFI:
53 kvmppc_emul_rfi(vcpu);
54 kvmppc_set_exit_type(vcpu, EMULATED_RFI_EXITS);
55 *advance = 0;
56 break;
57
58 case OP_19_XOP_RFCI:
59 kvmppc_emul_rfci(vcpu);
60 kvmppc_set_exit_type(vcpu, EMULATED_RFCI_EXITS);
61 *advance = 0;
62 break;
63
64 case OP_19_XOP_RFDI:
65 kvmppc_emul_rfdi(vcpu);
66 kvmppc_set_exit_type(vcpu, EMULATED_RFDI_EXITS);
67 *advance = 0;
68 break;
69
70 default:
71 emulated = EMULATE_FAIL;
72 break;
73 }
74 break;
75
76 case 31:
77 switch (get_xop(inst)) {
78
79 case OP_31_XOP_MFMSR:
80 kvmppc_set_gpr(vcpu, rt, vcpu->arch.shared->msr);
81 kvmppc_set_exit_type(vcpu, EMULATED_MFMSR_EXITS);
82 break;
83
84 case OP_31_XOP_MTMSR:
85 kvmppc_set_exit_type(vcpu, EMULATED_MTMSR_EXITS);
86 kvmppc_set_msr(vcpu, kvmppc_get_gpr(vcpu, rs));
87 break;
88
89 case OP_31_XOP_WRTEE:
90 vcpu->arch.shared->msr = (vcpu->arch.shared->msr & ~MSR_EE)
91 | (kvmppc_get_gpr(vcpu, rs) & MSR_EE);
92 kvmppc_set_exit_type(vcpu, EMULATED_WRTEE_EXITS);
93 break;
94
95 case OP_31_XOP_WRTEEI:
96 vcpu->arch.shared->msr = (vcpu->arch.shared->msr & ~MSR_EE)
97 | (inst & MSR_EE);
98 kvmppc_set_exit_type(vcpu, EMULATED_WRTEE_EXITS);
99 break;
100
101 default:
102 emulated = EMULATE_FAIL;
103 }
104
105 break;
106
107 default:
108 emulated = EMULATE_FAIL;
109 }
110
111 return emulated;
112}
113
114/*
115 * NOTE: some of these registers are not emulated on BOOKE_HV (GS-mode).
116 * Their backing store is in real registers, and these functions
117 * will return the wrong result if called for them in another context
118 * (such as debugging).
119 */
120int kvmppc_booke_emulate_mtspr(struct kvm_vcpu *vcpu, int sprn, ulong spr_val)
121{
122 int emulated = EMULATE_DONE;
123 bool debug_inst = false;
124
125 switch (sprn) {
126 case SPRN_DEAR:
127 vcpu->arch.shared->dar = spr_val;
128 break;
129 case SPRN_ESR:
130 vcpu->arch.shared->esr = spr_val;
131 break;
132 case SPRN_CSRR0:
133 vcpu->arch.csrr0 = spr_val;
134 break;
135 case SPRN_CSRR1:
136 vcpu->arch.csrr1 = spr_val;
137 break;
138 case SPRN_DSRR0:
139 vcpu->arch.dsrr0 = spr_val;
140 break;
141 case SPRN_DSRR1:
142 vcpu->arch.dsrr1 = spr_val;
143 break;
144 case SPRN_IAC1:
145 /*
146 * If userspace is debugging guest then guest
147 * can not access debug registers.
148 */
149 if (vcpu->guest_debug)
150 break;
151
152 debug_inst = true;
153 vcpu->arch.dbg_reg.iac1 = spr_val;
154 break;
155 case SPRN_IAC2:
156 /*
157 * If userspace is debugging guest then guest
158 * can not access debug registers.
159 */
160 if (vcpu->guest_debug)
161 break;
162
163 debug_inst = true;
164 vcpu->arch.dbg_reg.iac2 = spr_val;
165 break;
166#if CONFIG_PPC_ADV_DEBUG_IACS > 2
167 case SPRN_IAC3:
168 /*
169 * If userspace is debugging guest then guest
170 * can not access debug registers.
171 */
172 if (vcpu->guest_debug)
173 break;
174
175 debug_inst = true;
176 vcpu->arch.dbg_reg.iac3 = spr_val;
177 break;
178 case SPRN_IAC4:
179 /*
180 * If userspace is debugging guest then guest
181 * can not access debug registers.
182 */
183 if (vcpu->guest_debug)
184 break;
185
186 debug_inst = true;
187 vcpu->arch.dbg_reg.iac4 = spr_val;
188 break;
189#endif
190 case SPRN_DAC1:
191 /*
192 * If userspace is debugging guest then guest
193 * can not access debug registers.
194 */
195 if (vcpu->guest_debug)
196 break;
197
198 debug_inst = true;
199 vcpu->arch.dbg_reg.dac1 = spr_val;
200 break;
201 case SPRN_DAC2:
202 /*
203 * If userspace is debugging guest then guest
204 * can not access debug registers.
205 */
206 if (vcpu->guest_debug)
207 break;
208
209 debug_inst = true;
210 vcpu->arch.dbg_reg.dac2 = spr_val;
211 break;
212 case SPRN_DBCR0:
213 /*
214 * If userspace is debugging guest then guest
215 * can not access debug registers.
216 */
217 if (vcpu->guest_debug)
218 break;
219
220 debug_inst = true;
221 spr_val &= (DBCR0_IDM | DBCR0_IC | DBCR0_BT | DBCR0_TIE |
222 DBCR0_IAC1 | DBCR0_IAC2 | DBCR0_IAC3 | DBCR0_IAC4 |
223 DBCR0_DAC1R | DBCR0_DAC1W | DBCR0_DAC2R | DBCR0_DAC2W);
224
225 vcpu->arch.dbg_reg.dbcr0 = spr_val;
226 break;
227 case SPRN_DBCR1:
228 /*
229 * If userspace is debugging guest then guest
230 * can not access debug registers.
231 */
232 if (vcpu->guest_debug)
233 break;
234
235 debug_inst = true;
236 vcpu->arch.dbg_reg.dbcr1 = spr_val;
237 break;
238 case SPRN_DBCR2:
239 /*
240 * If userspace is debugging guest then guest
241 * can not access debug registers.
242 */
243 if (vcpu->guest_debug)
244 break;
245
246 debug_inst = true;
247 vcpu->arch.dbg_reg.dbcr2 = spr_val;
248 break;
249 case SPRN_DBSR:
250 /*
251 * If userspace is debugging guest then guest
252 * can not access debug registers.
253 */
254 if (vcpu->guest_debug)
255 break;
256
257 vcpu->arch.dbsr &= ~spr_val;
258 if (!(vcpu->arch.dbsr & ~DBSR_IDE))
259 kvmppc_core_dequeue_debug(vcpu);
260 break;
261 case SPRN_TSR:
262 kvmppc_clr_tsr_bits(vcpu, spr_val);
263 break;
264 case SPRN_TCR:
265 /*
266 * WRC is a 2-bit field that is supposed to preserve its
267 * value once written to non-zero.
268 */
269 if (vcpu->arch.tcr & TCR_WRC_MASK) {
270 spr_val &= ~TCR_WRC_MASK;
271 spr_val |= vcpu->arch.tcr & TCR_WRC_MASK;
272 }
273 kvmppc_set_tcr(vcpu, spr_val);
274 break;
275
276 case SPRN_DECAR:
277 vcpu->arch.decar = spr_val;
278 break;
279 /*
280 * Note: SPRG4-7 are user-readable.
281 * These values are loaded into the real SPRGs when resuming the
282 * guest (PR-mode only).
283 */
284 case SPRN_SPRG4:
285 kvmppc_set_sprg4(vcpu, spr_val);
286 break;
287 case SPRN_SPRG5:
288 kvmppc_set_sprg5(vcpu, spr_val);
289 break;
290 case SPRN_SPRG6:
291 kvmppc_set_sprg6(vcpu, spr_val);
292 break;
293 case SPRN_SPRG7:
294 kvmppc_set_sprg7(vcpu, spr_val);
295 break;
296
297 case SPRN_IVPR:
298 vcpu->arch.ivpr = spr_val;
299#ifdef CONFIG_KVM_BOOKE_HV
300 mtspr(SPRN_GIVPR, spr_val);
301#endif
302 break;
303 case SPRN_IVOR0:
304 vcpu->arch.ivor[BOOKE_IRQPRIO_CRITICAL] = spr_val;
305 break;
306 case SPRN_IVOR1:
307 vcpu->arch.ivor[BOOKE_IRQPRIO_MACHINE_CHECK] = spr_val;
308 break;
309 case SPRN_IVOR2:
310 vcpu->arch.ivor[BOOKE_IRQPRIO_DATA_STORAGE] = spr_val;
311#ifdef CONFIG_KVM_BOOKE_HV
312 mtspr(SPRN_GIVOR2, spr_val);
313#endif
314 break;
315 case SPRN_IVOR3:
316 vcpu->arch.ivor[BOOKE_IRQPRIO_INST_STORAGE] = spr_val;
317 break;
318 case SPRN_IVOR4:
319 vcpu->arch.ivor[BOOKE_IRQPRIO_EXTERNAL] = spr_val;
320 break;
321 case SPRN_IVOR5:
322 vcpu->arch.ivor[BOOKE_IRQPRIO_ALIGNMENT] = spr_val;
323 break;
324 case SPRN_IVOR6:
325 vcpu->arch.ivor[BOOKE_IRQPRIO_PROGRAM] = spr_val;
326 break;
327 case SPRN_IVOR7:
328 vcpu->arch.ivor[BOOKE_IRQPRIO_FP_UNAVAIL] = spr_val;
329 break;
330 case SPRN_IVOR8:
331 vcpu->arch.ivor[BOOKE_IRQPRIO_SYSCALL] = spr_val;
332#ifdef CONFIG_KVM_BOOKE_HV
333 mtspr(SPRN_GIVOR8, spr_val);
334#endif
335 break;
336 case SPRN_IVOR9:
337 vcpu->arch.ivor[BOOKE_IRQPRIO_AP_UNAVAIL] = spr_val;
338 break;
339 case SPRN_IVOR10:
340 vcpu->arch.ivor[BOOKE_IRQPRIO_DECREMENTER] = spr_val;
341 break;
342 case SPRN_IVOR11:
343 vcpu->arch.ivor[BOOKE_IRQPRIO_FIT] = spr_val;
344 break;
345 case SPRN_IVOR12:
346 vcpu->arch.ivor[BOOKE_IRQPRIO_WATCHDOG] = spr_val;
347 break;
348 case SPRN_IVOR13:
349 vcpu->arch.ivor[BOOKE_IRQPRIO_DTLB_MISS] = spr_val;
350 break;
351 case SPRN_IVOR14:
352 vcpu->arch.ivor[BOOKE_IRQPRIO_ITLB_MISS] = spr_val;
353 break;
354 case SPRN_IVOR15:
355 vcpu->arch.ivor[BOOKE_IRQPRIO_DEBUG] = spr_val;
356 break;
357 case SPRN_MCSR:
358 vcpu->arch.mcsr &= ~spr_val;
359 break;
360#if defined(CONFIG_64BIT)
361 case SPRN_EPCR:
362 kvmppc_set_epcr(vcpu, spr_val);
363#ifdef CONFIG_KVM_BOOKE_HV
364 mtspr(SPRN_EPCR, vcpu->arch.shadow_epcr);
365#endif
366 break;
367#endif
368 default:
369 emulated = EMULATE_FAIL;
370 }
371
372 if (debug_inst) {
373 current->thread.debug = vcpu->arch.dbg_reg;
374 switch_booke_debug_regs(&vcpu->arch.dbg_reg);
375 }
376 return emulated;
377}
378
379int kvmppc_booke_emulate_mfspr(struct kvm_vcpu *vcpu, int sprn, ulong *spr_val)
380{
381 int emulated = EMULATE_DONE;
382
383 switch (sprn) {
384 case SPRN_IVPR:
385 *spr_val = vcpu->arch.ivpr;
386 break;
387 case SPRN_DEAR:
388 *spr_val = vcpu->arch.shared->dar;
389 break;
390 case SPRN_ESR:
391 *spr_val = vcpu->arch.shared->esr;
392 break;
393 case SPRN_EPR:
394 *spr_val = vcpu->arch.epr;
395 break;
396 case SPRN_CSRR0:
397 *spr_val = vcpu->arch.csrr0;
398 break;
399 case SPRN_CSRR1:
400 *spr_val = vcpu->arch.csrr1;
401 break;
402 case SPRN_DSRR0:
403 *spr_val = vcpu->arch.dsrr0;
404 break;
405 case SPRN_DSRR1:
406 *spr_val = vcpu->arch.dsrr1;
407 break;
408 case SPRN_IAC1:
409 *spr_val = vcpu->arch.dbg_reg.iac1;
410 break;
411 case SPRN_IAC2:
412 *spr_val = vcpu->arch.dbg_reg.iac2;
413 break;
414#if CONFIG_PPC_ADV_DEBUG_IACS > 2
415 case SPRN_IAC3:
416 *spr_val = vcpu->arch.dbg_reg.iac3;
417 break;
418 case SPRN_IAC4:
419 *spr_val = vcpu->arch.dbg_reg.iac4;
420 break;
421#endif
422 case SPRN_DAC1:
423 *spr_val = vcpu->arch.dbg_reg.dac1;
424 break;
425 case SPRN_DAC2:
426 *spr_val = vcpu->arch.dbg_reg.dac2;
427 break;
428 case SPRN_DBCR0:
429 *spr_val = vcpu->arch.dbg_reg.dbcr0;
430 if (vcpu->guest_debug)
431 *spr_val = *spr_val | DBCR0_EDM;
432 break;
433 case SPRN_DBCR1:
434 *spr_val = vcpu->arch.dbg_reg.dbcr1;
435 break;
436 case SPRN_DBCR2:
437 *spr_val = vcpu->arch.dbg_reg.dbcr2;
438 break;
439 case SPRN_DBSR:
440 *spr_val = vcpu->arch.dbsr;
441 break;
442 case SPRN_TSR:
443 *spr_val = vcpu->arch.tsr;
444 break;
445 case SPRN_TCR:
446 *spr_val = vcpu->arch.tcr;
447 break;
448
449 case SPRN_IVOR0:
450 *spr_val = vcpu->arch.ivor[BOOKE_IRQPRIO_CRITICAL];
451 break;
452 case SPRN_IVOR1:
453 *spr_val = vcpu->arch.ivor[BOOKE_IRQPRIO_MACHINE_CHECK];
454 break;
455 case SPRN_IVOR2:
456 *spr_val = vcpu->arch.ivor[BOOKE_IRQPRIO_DATA_STORAGE];
457 break;
458 case SPRN_IVOR3:
459 *spr_val = vcpu->arch.ivor[BOOKE_IRQPRIO_INST_STORAGE];
460 break;
461 case SPRN_IVOR4:
462 *spr_val = vcpu->arch.ivor[BOOKE_IRQPRIO_EXTERNAL];
463 break;
464 case SPRN_IVOR5:
465 *spr_val = vcpu->arch.ivor[BOOKE_IRQPRIO_ALIGNMENT];
466 break;
467 case SPRN_IVOR6:
468 *spr_val = vcpu->arch.ivor[BOOKE_IRQPRIO_PROGRAM];
469 break;
470 case SPRN_IVOR7:
471 *spr_val = vcpu->arch.ivor[BOOKE_IRQPRIO_FP_UNAVAIL];
472 break;
473 case SPRN_IVOR8:
474 *spr_val = vcpu->arch.ivor[BOOKE_IRQPRIO_SYSCALL];
475 break;
476 case SPRN_IVOR9:
477 *spr_val = vcpu->arch.ivor[BOOKE_IRQPRIO_AP_UNAVAIL];
478 break;
479 case SPRN_IVOR10:
480 *spr_val = vcpu->arch.ivor[BOOKE_IRQPRIO_DECREMENTER];
481 break;
482 case SPRN_IVOR11:
483 *spr_val = vcpu->arch.ivor[BOOKE_IRQPRIO_FIT];
484 break;
485 case SPRN_IVOR12:
486 *spr_val = vcpu->arch.ivor[BOOKE_IRQPRIO_WATCHDOG];
487 break;
488 case SPRN_IVOR13:
489 *spr_val = vcpu->arch.ivor[BOOKE_IRQPRIO_DTLB_MISS];
490 break;
491 case SPRN_IVOR14:
492 *spr_val = vcpu->arch.ivor[BOOKE_IRQPRIO_ITLB_MISS];
493 break;
494 case SPRN_IVOR15:
495 *spr_val = vcpu->arch.ivor[BOOKE_IRQPRIO_DEBUG];
496 break;
497 case SPRN_MCSR:
498 *spr_val = vcpu->arch.mcsr;
499 break;
500#if defined(CONFIG_64BIT)
501 case SPRN_EPCR:
502 *spr_val = vcpu->arch.epcr;
503 break;
504#endif
505
506 default:
507 emulated = EMULATE_FAIL;
508 }
509
510 return emulated;
511}
1/*
2 * This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License, version 2, as
4 * published by the Free Software Foundation.
5 *
6 * This program is distributed in the hope that it will be useful,
7 * but WITHOUT ANY WARRANTY; without even the implied warranty of
8 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
9 * GNU General Public License for more details.
10 *
11 * You should have received a copy of the GNU General Public License
12 * along with this program; if not, write to the Free Software
13 * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
14 *
15 * Copyright IBM Corp. 2008
16 * Copyright 2011 Freescale Semiconductor, Inc.
17 *
18 * Authors: Hollis Blanchard <hollisb@us.ibm.com>
19 */
20
21#include <linux/kvm_host.h>
22#include <asm/disassemble.h>
23
24#include "booke.h"
25
26#define OP_19_XOP_RFI 50
27#define OP_19_XOP_RFCI 51
28#define OP_19_XOP_RFDI 39
29
30#define OP_31_XOP_MFMSR 83
31#define OP_31_XOP_WRTEE 131
32#define OP_31_XOP_MTMSR 146
33#define OP_31_XOP_WRTEEI 163
34
35static void kvmppc_emul_rfi(struct kvm_vcpu *vcpu)
36{
37 vcpu->arch.pc = vcpu->arch.shared->srr0;
38 kvmppc_set_msr(vcpu, vcpu->arch.shared->srr1);
39}
40
41static void kvmppc_emul_rfdi(struct kvm_vcpu *vcpu)
42{
43 vcpu->arch.pc = vcpu->arch.dsrr0;
44 kvmppc_set_msr(vcpu, vcpu->arch.dsrr1);
45}
46
47static void kvmppc_emul_rfci(struct kvm_vcpu *vcpu)
48{
49 vcpu->arch.pc = vcpu->arch.csrr0;
50 kvmppc_set_msr(vcpu, vcpu->arch.csrr1);
51}
52
53int kvmppc_booke_emulate_op(struct kvm_run *run, struct kvm_vcpu *vcpu,
54 unsigned int inst, int *advance)
55{
56 int emulated = EMULATE_DONE;
57 int rs = get_rs(inst);
58 int rt = get_rt(inst);
59
60 switch (get_op(inst)) {
61 case 19:
62 switch (get_xop(inst)) {
63 case OP_19_XOP_RFI:
64 kvmppc_emul_rfi(vcpu);
65 kvmppc_set_exit_type(vcpu, EMULATED_RFI_EXITS);
66 *advance = 0;
67 break;
68
69 case OP_19_XOP_RFCI:
70 kvmppc_emul_rfci(vcpu);
71 kvmppc_set_exit_type(vcpu, EMULATED_RFCI_EXITS);
72 *advance = 0;
73 break;
74
75 case OP_19_XOP_RFDI:
76 kvmppc_emul_rfdi(vcpu);
77 kvmppc_set_exit_type(vcpu, EMULATED_RFDI_EXITS);
78 *advance = 0;
79 break;
80
81 default:
82 emulated = EMULATE_FAIL;
83 break;
84 }
85 break;
86
87 case 31:
88 switch (get_xop(inst)) {
89
90 case OP_31_XOP_MFMSR:
91 kvmppc_set_gpr(vcpu, rt, vcpu->arch.shared->msr);
92 kvmppc_set_exit_type(vcpu, EMULATED_MFMSR_EXITS);
93 break;
94
95 case OP_31_XOP_MTMSR:
96 kvmppc_set_exit_type(vcpu, EMULATED_MTMSR_EXITS);
97 kvmppc_set_msr(vcpu, kvmppc_get_gpr(vcpu, rs));
98 break;
99
100 case OP_31_XOP_WRTEE:
101 vcpu->arch.shared->msr = (vcpu->arch.shared->msr & ~MSR_EE)
102 | (kvmppc_get_gpr(vcpu, rs) & MSR_EE);
103 kvmppc_set_exit_type(vcpu, EMULATED_WRTEE_EXITS);
104 break;
105
106 case OP_31_XOP_WRTEEI:
107 vcpu->arch.shared->msr = (vcpu->arch.shared->msr & ~MSR_EE)
108 | (inst & MSR_EE);
109 kvmppc_set_exit_type(vcpu, EMULATED_WRTEE_EXITS);
110 break;
111
112 default:
113 emulated = EMULATE_FAIL;
114 }
115
116 break;
117
118 default:
119 emulated = EMULATE_FAIL;
120 }
121
122 return emulated;
123}
124
125/*
126 * NOTE: some of these registers are not emulated on BOOKE_HV (GS-mode).
127 * Their backing store is in real registers, and these functions
128 * will return the wrong result if called for them in another context
129 * (such as debugging).
130 */
131int kvmppc_booke_emulate_mtspr(struct kvm_vcpu *vcpu, int sprn, ulong spr_val)
132{
133 int emulated = EMULATE_DONE;
134 bool debug_inst = false;
135
136 switch (sprn) {
137 case SPRN_DEAR:
138 vcpu->arch.shared->dar = spr_val;
139 break;
140 case SPRN_ESR:
141 vcpu->arch.shared->esr = spr_val;
142 break;
143 case SPRN_CSRR0:
144 vcpu->arch.csrr0 = spr_val;
145 break;
146 case SPRN_CSRR1:
147 vcpu->arch.csrr1 = spr_val;
148 break;
149 case SPRN_DSRR0:
150 vcpu->arch.dsrr0 = spr_val;
151 break;
152 case SPRN_DSRR1:
153 vcpu->arch.dsrr1 = spr_val;
154 break;
155 case SPRN_IAC1:
156 /*
157 * If userspace is debugging guest then guest
158 * can not access debug registers.
159 */
160 if (vcpu->guest_debug)
161 break;
162
163 debug_inst = true;
164 vcpu->arch.dbg_reg.iac1 = spr_val;
165 break;
166 case SPRN_IAC2:
167 /*
168 * If userspace is debugging guest then guest
169 * can not access debug registers.
170 */
171 if (vcpu->guest_debug)
172 break;
173
174 debug_inst = true;
175 vcpu->arch.dbg_reg.iac2 = spr_val;
176 break;
177#if CONFIG_PPC_ADV_DEBUG_IACS > 2
178 case SPRN_IAC3:
179 /*
180 * If userspace is debugging guest then guest
181 * can not access debug registers.
182 */
183 if (vcpu->guest_debug)
184 break;
185
186 debug_inst = true;
187 vcpu->arch.dbg_reg.iac3 = spr_val;
188 break;
189 case SPRN_IAC4:
190 /*
191 * If userspace is debugging guest then guest
192 * can not access debug registers.
193 */
194 if (vcpu->guest_debug)
195 break;
196
197 debug_inst = true;
198 vcpu->arch.dbg_reg.iac4 = spr_val;
199 break;
200#endif
201 case SPRN_DAC1:
202 /*
203 * If userspace is debugging guest then guest
204 * can not access debug registers.
205 */
206 if (vcpu->guest_debug)
207 break;
208
209 debug_inst = true;
210 vcpu->arch.dbg_reg.dac1 = spr_val;
211 break;
212 case SPRN_DAC2:
213 /*
214 * If userspace is debugging guest then guest
215 * can not access debug registers.
216 */
217 if (vcpu->guest_debug)
218 break;
219
220 debug_inst = true;
221 vcpu->arch.dbg_reg.dac2 = spr_val;
222 break;
223 case SPRN_DBCR0:
224 /*
225 * If userspace is debugging guest then guest
226 * can not access debug registers.
227 */
228 if (vcpu->guest_debug)
229 break;
230
231 debug_inst = true;
232 spr_val &= (DBCR0_IDM | DBCR0_IC | DBCR0_BT | DBCR0_TIE |
233 DBCR0_IAC1 | DBCR0_IAC2 | DBCR0_IAC3 | DBCR0_IAC4 |
234 DBCR0_DAC1R | DBCR0_DAC1W | DBCR0_DAC2R | DBCR0_DAC2W);
235
236 vcpu->arch.dbg_reg.dbcr0 = spr_val;
237 break;
238 case SPRN_DBCR1:
239 /*
240 * If userspace is debugging guest then guest
241 * can not access debug registers.
242 */
243 if (vcpu->guest_debug)
244 break;
245
246 debug_inst = true;
247 vcpu->arch.dbg_reg.dbcr1 = spr_val;
248 break;
249 case SPRN_DBCR2:
250 /*
251 * If userspace is debugging guest then guest
252 * can not access debug registers.
253 */
254 if (vcpu->guest_debug)
255 break;
256
257 debug_inst = true;
258 vcpu->arch.dbg_reg.dbcr2 = spr_val;
259 break;
260 case SPRN_DBSR:
261 /*
262 * If userspace is debugging guest then guest
263 * can not access debug registers.
264 */
265 if (vcpu->guest_debug)
266 break;
267
268 vcpu->arch.dbsr &= ~spr_val;
269 if (!(vcpu->arch.dbsr & ~DBSR_IDE))
270 kvmppc_core_dequeue_debug(vcpu);
271 break;
272 case SPRN_TSR:
273 kvmppc_clr_tsr_bits(vcpu, spr_val);
274 break;
275 case SPRN_TCR:
276 /*
277 * WRC is a 2-bit field that is supposed to preserve its
278 * value once written to non-zero.
279 */
280 if (vcpu->arch.tcr & TCR_WRC_MASK) {
281 spr_val &= ~TCR_WRC_MASK;
282 spr_val |= vcpu->arch.tcr & TCR_WRC_MASK;
283 }
284 kvmppc_set_tcr(vcpu, spr_val);
285 break;
286
287 case SPRN_DECAR:
288 vcpu->arch.decar = spr_val;
289 break;
290 /*
291 * Note: SPRG4-7 are user-readable.
292 * These values are loaded into the real SPRGs when resuming the
293 * guest (PR-mode only).
294 */
295 case SPRN_SPRG4:
296 kvmppc_set_sprg4(vcpu, spr_val);
297 break;
298 case SPRN_SPRG5:
299 kvmppc_set_sprg5(vcpu, spr_val);
300 break;
301 case SPRN_SPRG6:
302 kvmppc_set_sprg6(vcpu, spr_val);
303 break;
304 case SPRN_SPRG7:
305 kvmppc_set_sprg7(vcpu, spr_val);
306 break;
307
308 case SPRN_IVPR:
309 vcpu->arch.ivpr = spr_val;
310#ifdef CONFIG_KVM_BOOKE_HV
311 mtspr(SPRN_GIVPR, spr_val);
312#endif
313 break;
314 case SPRN_IVOR0:
315 vcpu->arch.ivor[BOOKE_IRQPRIO_CRITICAL] = spr_val;
316 break;
317 case SPRN_IVOR1:
318 vcpu->arch.ivor[BOOKE_IRQPRIO_MACHINE_CHECK] = spr_val;
319 break;
320 case SPRN_IVOR2:
321 vcpu->arch.ivor[BOOKE_IRQPRIO_DATA_STORAGE] = spr_val;
322#ifdef CONFIG_KVM_BOOKE_HV
323 mtspr(SPRN_GIVOR2, spr_val);
324#endif
325 break;
326 case SPRN_IVOR3:
327 vcpu->arch.ivor[BOOKE_IRQPRIO_INST_STORAGE] = spr_val;
328 break;
329 case SPRN_IVOR4:
330 vcpu->arch.ivor[BOOKE_IRQPRIO_EXTERNAL] = spr_val;
331 break;
332 case SPRN_IVOR5:
333 vcpu->arch.ivor[BOOKE_IRQPRIO_ALIGNMENT] = spr_val;
334 break;
335 case SPRN_IVOR6:
336 vcpu->arch.ivor[BOOKE_IRQPRIO_PROGRAM] = spr_val;
337 break;
338 case SPRN_IVOR7:
339 vcpu->arch.ivor[BOOKE_IRQPRIO_FP_UNAVAIL] = spr_val;
340 break;
341 case SPRN_IVOR8:
342 vcpu->arch.ivor[BOOKE_IRQPRIO_SYSCALL] = spr_val;
343#ifdef CONFIG_KVM_BOOKE_HV
344 mtspr(SPRN_GIVOR8, spr_val);
345#endif
346 break;
347 case SPRN_IVOR9:
348 vcpu->arch.ivor[BOOKE_IRQPRIO_AP_UNAVAIL] = spr_val;
349 break;
350 case SPRN_IVOR10:
351 vcpu->arch.ivor[BOOKE_IRQPRIO_DECREMENTER] = spr_val;
352 break;
353 case SPRN_IVOR11:
354 vcpu->arch.ivor[BOOKE_IRQPRIO_FIT] = spr_val;
355 break;
356 case SPRN_IVOR12:
357 vcpu->arch.ivor[BOOKE_IRQPRIO_WATCHDOG] = spr_val;
358 break;
359 case SPRN_IVOR13:
360 vcpu->arch.ivor[BOOKE_IRQPRIO_DTLB_MISS] = spr_val;
361 break;
362 case SPRN_IVOR14:
363 vcpu->arch.ivor[BOOKE_IRQPRIO_ITLB_MISS] = spr_val;
364 break;
365 case SPRN_IVOR15:
366 vcpu->arch.ivor[BOOKE_IRQPRIO_DEBUG] = spr_val;
367 break;
368 case SPRN_MCSR:
369 vcpu->arch.mcsr &= ~spr_val;
370 break;
371#if defined(CONFIG_64BIT)
372 case SPRN_EPCR:
373 kvmppc_set_epcr(vcpu, spr_val);
374#ifdef CONFIG_KVM_BOOKE_HV
375 mtspr(SPRN_EPCR, vcpu->arch.shadow_epcr);
376#endif
377 break;
378#endif
379 default:
380 emulated = EMULATE_FAIL;
381 }
382
383 if (debug_inst) {
384 current->thread.debug = vcpu->arch.dbg_reg;
385 switch_booke_debug_regs(&vcpu->arch.dbg_reg);
386 }
387 return emulated;
388}
389
390int kvmppc_booke_emulate_mfspr(struct kvm_vcpu *vcpu, int sprn, ulong *spr_val)
391{
392 int emulated = EMULATE_DONE;
393
394 switch (sprn) {
395 case SPRN_IVPR:
396 *spr_val = vcpu->arch.ivpr;
397 break;
398 case SPRN_DEAR:
399 *spr_val = vcpu->arch.shared->dar;
400 break;
401 case SPRN_ESR:
402 *spr_val = vcpu->arch.shared->esr;
403 break;
404 case SPRN_EPR:
405 *spr_val = vcpu->arch.epr;
406 break;
407 case SPRN_CSRR0:
408 *spr_val = vcpu->arch.csrr0;
409 break;
410 case SPRN_CSRR1:
411 *spr_val = vcpu->arch.csrr1;
412 break;
413 case SPRN_DSRR0:
414 *spr_val = vcpu->arch.dsrr0;
415 break;
416 case SPRN_DSRR1:
417 *spr_val = vcpu->arch.dsrr1;
418 break;
419 case SPRN_IAC1:
420 *spr_val = vcpu->arch.dbg_reg.iac1;
421 break;
422 case SPRN_IAC2:
423 *spr_val = vcpu->arch.dbg_reg.iac2;
424 break;
425#if CONFIG_PPC_ADV_DEBUG_IACS > 2
426 case SPRN_IAC3:
427 *spr_val = vcpu->arch.dbg_reg.iac3;
428 break;
429 case SPRN_IAC4:
430 *spr_val = vcpu->arch.dbg_reg.iac4;
431 break;
432#endif
433 case SPRN_DAC1:
434 *spr_val = vcpu->arch.dbg_reg.dac1;
435 break;
436 case SPRN_DAC2:
437 *spr_val = vcpu->arch.dbg_reg.dac2;
438 break;
439 case SPRN_DBCR0:
440 *spr_val = vcpu->arch.dbg_reg.dbcr0;
441 if (vcpu->guest_debug)
442 *spr_val = *spr_val | DBCR0_EDM;
443 break;
444 case SPRN_DBCR1:
445 *spr_val = vcpu->arch.dbg_reg.dbcr1;
446 break;
447 case SPRN_DBCR2:
448 *spr_val = vcpu->arch.dbg_reg.dbcr2;
449 break;
450 case SPRN_DBSR:
451 *spr_val = vcpu->arch.dbsr;
452 break;
453 case SPRN_TSR:
454 *spr_val = vcpu->arch.tsr;
455 break;
456 case SPRN_TCR:
457 *spr_val = vcpu->arch.tcr;
458 break;
459
460 case SPRN_IVOR0:
461 *spr_val = vcpu->arch.ivor[BOOKE_IRQPRIO_CRITICAL];
462 break;
463 case SPRN_IVOR1:
464 *spr_val = vcpu->arch.ivor[BOOKE_IRQPRIO_MACHINE_CHECK];
465 break;
466 case SPRN_IVOR2:
467 *spr_val = vcpu->arch.ivor[BOOKE_IRQPRIO_DATA_STORAGE];
468 break;
469 case SPRN_IVOR3:
470 *spr_val = vcpu->arch.ivor[BOOKE_IRQPRIO_INST_STORAGE];
471 break;
472 case SPRN_IVOR4:
473 *spr_val = vcpu->arch.ivor[BOOKE_IRQPRIO_EXTERNAL];
474 break;
475 case SPRN_IVOR5:
476 *spr_val = vcpu->arch.ivor[BOOKE_IRQPRIO_ALIGNMENT];
477 break;
478 case SPRN_IVOR6:
479 *spr_val = vcpu->arch.ivor[BOOKE_IRQPRIO_PROGRAM];
480 break;
481 case SPRN_IVOR7:
482 *spr_val = vcpu->arch.ivor[BOOKE_IRQPRIO_FP_UNAVAIL];
483 break;
484 case SPRN_IVOR8:
485 *spr_val = vcpu->arch.ivor[BOOKE_IRQPRIO_SYSCALL];
486 break;
487 case SPRN_IVOR9:
488 *spr_val = vcpu->arch.ivor[BOOKE_IRQPRIO_AP_UNAVAIL];
489 break;
490 case SPRN_IVOR10:
491 *spr_val = vcpu->arch.ivor[BOOKE_IRQPRIO_DECREMENTER];
492 break;
493 case SPRN_IVOR11:
494 *spr_val = vcpu->arch.ivor[BOOKE_IRQPRIO_FIT];
495 break;
496 case SPRN_IVOR12:
497 *spr_val = vcpu->arch.ivor[BOOKE_IRQPRIO_WATCHDOG];
498 break;
499 case SPRN_IVOR13:
500 *spr_val = vcpu->arch.ivor[BOOKE_IRQPRIO_DTLB_MISS];
501 break;
502 case SPRN_IVOR14:
503 *spr_val = vcpu->arch.ivor[BOOKE_IRQPRIO_ITLB_MISS];
504 break;
505 case SPRN_IVOR15:
506 *spr_val = vcpu->arch.ivor[BOOKE_IRQPRIO_DEBUG];
507 break;
508 case SPRN_MCSR:
509 *spr_val = vcpu->arch.mcsr;
510 break;
511#if defined(CONFIG_64BIT)
512 case SPRN_EPCR:
513 *spr_val = vcpu->arch.epcr;
514 break;
515#endif
516
517 default:
518 emulated = EMULATE_FAIL;
519 }
520
521 return emulated;
522}