GNU Linux-libre 5.15.72-gnu
[releases.git] / arch / powerpc / kvm / booke_emulate.c
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
24 static 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
30 static 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
36 static 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
42 int 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  */
120 int 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
379 int 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 }