arch/powerpc/kvm/booke_emulate.c

   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
  28 #define OP_31_XOP_MFMSR   83
  29 #define OP_31_XOP_WRTEE   131
  30 #define OP_31_XOP_MTMSR   146
  31 #define OP_31_XOP_WRTEEI  163
  32
  33 static void kvmppc_emul_rfi(struct kvm_vcpu *vcpu)
  34 {
  35         vcpu->arch.pc = vcpu->arch.shared->srr0;
  36         kvmppc_set_msr(vcpu, vcpu->arch.shared->srr1);
  37 }
  38
  39 int kvmppc_booke_emulate_op(struct kvm_run *run, struct kvm_vcpu *vcpu,
  40                             unsigned int inst, int *advance)
  41 {
  42         int emulated = EMULATE_DONE;
  43         int rs = get_rs(inst);
  44         int rt = get_rt(inst);
  45
  46         switch (get_op(inst)) {
  47         case 19:
  48                 switch (get_xop(inst)) {
  49                 case OP_19_XOP_RFI:
  50                         kvmppc_emul_rfi(vcpu);
  51                         kvmppc_set_exit_type(vcpu, EMULATED_RFI_EXITS);
  52                         *advance = 0;
  53                         break;
  54
  55                 default:
  56                         emulated = EMULATE_FAIL;
  57                         break;
  58                 }
  59                 break;
  60
  61         case 31:
  62                 switch (get_xop(inst)) {
  63
  64                 case OP_31_XOP_MFMSR:
  65                         kvmppc_set_gpr(vcpu, rt, vcpu->arch.shared->msr);
  66                         kvmppc_set_exit_type(vcpu, EMULATED_MFMSR_EXITS);
  67                         break;
  68
  69                 case OP_31_XOP_MTMSR:
  70                         kvmppc_set_exit_type(vcpu, EMULATED_MTMSR_EXITS);
  71                         kvmppc_set_msr(vcpu, kvmppc_get_gpr(vcpu, rs));
  72                         break;
  73
  74                 case OP_31_XOP_WRTEE:
  75                         vcpu->arch.shared->msr = (vcpu->arch.shared->msr & ~MSR_EE)
  76                                         | (kvmppc_get_gpr(vcpu, rs) & MSR_EE);
  77                         kvmppc_set_exit_type(vcpu, EMULATED_WRTEE_EXITS);
  78                         break;
  79
  80                 case OP_31_XOP_WRTEEI:
  81                         vcpu->arch.shared->msr = (vcpu->arch.shared->msr & ~MSR_EE)
  82                                                          | (inst & MSR_EE);
  83                         kvmppc_set_exit_type(vcpu, EMULATED_WRTEE_EXITS);
  84                         break;
  85
  86                 default:
  87                         emulated = EMULATE_FAIL;
  88                 }
  89
  90                 break;
  91
  92         default:
  93                 emulated = EMULATE_FAIL;
  94         }
  95
  96         return emulated;
  97 }
  98
  99 /*
 100  * NOTE: some of these registers are not emulated on BOOKE_HV (GS-mode).
 101  * Their backing store is in real registers, and these functions
 102  * will return the wrong result if called for them in another context
 103  * (such as debugging).
 104  */
 105 int kvmppc_booke_emulate_mtspr(struct kvm_vcpu *vcpu, int sprn, int rs)
 106 {
 107         int emulated = EMULATE_DONE;
 108         ulong spr_val = kvmppc_get_gpr(vcpu, rs);
 109
 110         switch (sprn) {
 111         case SPRN_DEAR:
 112                 vcpu->arch.shared->dar = spr_val; break;
 113         case SPRN_ESR:
 114                 vcpu->arch.shared->esr = spr_val; break;
 115         case SPRN_DBCR0:
 116                 vcpu->arch.dbcr0 = spr_val; break;
 117         case SPRN_DBCR1:
 118                 vcpu->arch.dbcr1 = spr_val; break;
 119         case SPRN_DBSR:
 120                 vcpu->arch.dbsr &= ~spr_val; break;
 121         case SPRN_TSR:
 122                 kvmppc_clr_tsr_bits(vcpu, spr_val);
 123                 break;
 124         case SPRN_TCR:
 125                 kvmppc_set_tcr(vcpu, spr_val);
 126                 break;
 127
 128         /*
 129          * Note: SPRG4-7 are user-readable.
 130          * These values are loaded into the real SPRGs when resuming the
 131          * guest (PR-mode only).
 132          */
 133         case SPRN_SPRG4:
 134                 vcpu->arch.shared->sprg4 = spr_val; break;
 135         case SPRN_SPRG5:
 136                 vcpu->arch.shared->sprg5 = spr_val; break;
 137         case SPRN_SPRG6:
 138                 vcpu->arch.shared->sprg6 = spr_val; break;
 139         case SPRN_SPRG7:
 140                 vcpu->arch.shared->sprg7 = spr_val; break;
 141
 142         case SPRN_IVPR:
 143                 vcpu->arch.ivpr = spr_val;
 144 #ifdef CONFIG_KVM_BOOKE_HV
 145                 mtspr(SPRN_GIVPR, spr_val);
 146 #endif
 147                 break;
 148         case SPRN_IVOR0:
 149                 vcpu->arch.ivor[BOOKE_IRQPRIO_CRITICAL] = spr_val;
 150                 break;
 151         case SPRN_IVOR1:
 152                 vcpu->arch.ivor[BOOKE_IRQPRIO_MACHINE_CHECK] = spr_val;
 153                 break;
 154         case SPRN_IVOR2:
 155                 vcpu->arch.ivor[BOOKE_IRQPRIO_DATA_STORAGE] = spr_val;
 156 #ifdef CONFIG_KVM_BOOKE_HV
 157                 mtspr(SPRN_GIVOR2, spr_val);
 158 #endif
 159                 break;
 160         case SPRN_IVOR3:
 161                 vcpu->arch.ivor[BOOKE_IRQPRIO_INST_STORAGE] = spr_val;
 162                 break;
 163         case SPRN_IVOR4:
 164                 vcpu->arch.ivor[BOOKE_IRQPRIO_EXTERNAL] = spr_val;
 165                 break;
 166         case SPRN_IVOR5:
 167                 vcpu->arch.ivor[BOOKE_IRQPRIO_ALIGNMENT] = spr_val;
 168                 break;
 169         case SPRN_IVOR6:
 170                 vcpu->arch.ivor[BOOKE_IRQPRIO_PROGRAM] = spr_val;
 171                 break;
 172         case SPRN_IVOR7:
 173                 vcpu->arch.ivor[BOOKE_IRQPRIO_FP_UNAVAIL] = spr_val;
 174                 break;
 175         case SPRN_IVOR8:
 176                 vcpu->arch.ivor[BOOKE_IRQPRIO_SYSCALL] = spr_val;
 177 #ifdef CONFIG_KVM_BOOKE_HV
 178                 mtspr(SPRN_GIVOR8, spr_val);
 179 #endif
 180                 break;
 181         case SPRN_IVOR9:
 182                 vcpu->arch.ivor[BOOKE_IRQPRIO_AP_UNAVAIL] = spr_val;
 183                 break;
 184         case SPRN_IVOR10:
 185                 vcpu->arch.ivor[BOOKE_IRQPRIO_DECREMENTER] = spr_val;
 186                 break;
 187         case SPRN_IVOR11:
 188                 vcpu->arch.ivor[BOOKE_IRQPRIO_FIT] = spr_val;
 189                 break;
 190         case SPRN_IVOR12:
 191                 vcpu->arch.ivor[BOOKE_IRQPRIO_WATCHDOG] = spr_val;
 192                 break;
 193         case SPRN_IVOR13:
 194                 vcpu->arch.ivor[BOOKE_IRQPRIO_DTLB_MISS] = spr_val;
 195                 break;
 196         case SPRN_IVOR14:
 197                 vcpu->arch.ivor[BOOKE_IRQPRIO_ITLB_MISS] = spr_val;
 198                 break;
 199         case SPRN_IVOR15:
 200                 vcpu->arch.ivor[BOOKE_IRQPRIO_DEBUG] = spr_val;
 201                 break;
 202
 203         default:
 204                 emulated = EMULATE_FAIL;
 205         }
 206
 207         return emulated;
 208 }
 209
 210 int kvmppc_booke_emulate_mfspr(struct kvm_vcpu *vcpu, int sprn, int rt)
 211 {
 212         int emulated = EMULATE_DONE;
 213
 214         switch (sprn) {
 215         case SPRN_IVPR:
 216                 kvmppc_set_gpr(vcpu, rt, vcpu->arch.ivpr); break;
 217         case SPRN_DEAR:
 218                 kvmppc_set_gpr(vcpu, rt, vcpu->arch.shared->dar); break;
 219         case SPRN_ESR:
 220                 kvmppc_set_gpr(vcpu, rt, vcpu->arch.shared->esr); break;
 221         case SPRN_DBCR0:
 222                 kvmppc_set_gpr(vcpu, rt, vcpu->arch.dbcr0); break;
 223         case SPRN_DBCR1:
 224                 kvmppc_set_gpr(vcpu, rt, vcpu->arch.dbcr1); break;
 225         case SPRN_DBSR:
 226                 kvmppc_set_gpr(vcpu, rt, vcpu->arch.dbsr); break;
 227         case SPRN_TSR:
 228                 kvmppc_set_gpr(vcpu, rt, vcpu->arch.tsr); break;
 229         case SPRN_TCR:
 230                 kvmppc_set_gpr(vcpu, rt, vcpu->arch.tcr); break;
 231
 232         case SPRN_IVOR0:
 233                 kvmppc_set_gpr(vcpu, rt, vcpu->arch.ivor[BOOKE_IRQPRIO_CRITICAL]);
 234                 break;
 235         case SPRN_IVOR1:
 236                 kvmppc_set_gpr(vcpu, rt, vcpu->arch.ivor[BOOKE_IRQPRIO_MACHINE_CHECK]);
 237                 break;
 238         case SPRN_IVOR2:
 239                 kvmppc_set_gpr(vcpu, rt, vcpu->arch.ivor[BOOKE_IRQPRIO_DATA_STORAGE]);
 240                 break;
 241         case SPRN_IVOR3:
 242                 kvmppc_set_gpr(vcpu, rt, vcpu->arch.ivor[BOOKE_IRQPRIO_INST_STORAGE]);
 243                 break;
 244         case SPRN_IVOR4:
 245                 kvmppc_set_gpr(vcpu, rt, vcpu->arch.ivor[BOOKE_IRQPRIO_EXTERNAL]);
 246                 break;
 247         case SPRN_IVOR5:
 248                 kvmppc_set_gpr(vcpu, rt, vcpu->arch.ivor[BOOKE_IRQPRIO_ALIGNMENT]);
 249                 break;
 250         case SPRN_IVOR6:
 251                 kvmppc_set_gpr(vcpu, rt, vcpu->arch.ivor[BOOKE_IRQPRIO_PROGRAM]);
 252                 break;
 253         case SPRN_IVOR7:
 254                 kvmppc_set_gpr(vcpu, rt, vcpu->arch.ivor[BOOKE_IRQPRIO_FP_UNAVAIL]);
 255                 break;
 256         case SPRN_IVOR8:
 257                 kvmppc_set_gpr(vcpu, rt, vcpu->arch.ivor[BOOKE_IRQPRIO_SYSCALL]);
 258                 break;
 259         case SPRN_IVOR9:
 260                 kvmppc_set_gpr(vcpu, rt, vcpu->arch.ivor[BOOKE_IRQPRIO_AP_UNAVAIL]);
 261                 break;
 262         case SPRN_IVOR10:
 263                 kvmppc_set_gpr(vcpu, rt, vcpu->arch.ivor[BOOKE_IRQPRIO_DECREMENTER]);
 264                 break;
 265         case SPRN_IVOR11:
 266                 kvmppc_set_gpr(vcpu, rt, vcpu->arch.ivor[BOOKE_IRQPRIO_FIT]);
 267                 break;
 268         case SPRN_IVOR12:
 269                 kvmppc_set_gpr(vcpu, rt, vcpu->arch.ivor[BOOKE_IRQPRIO_WATCHDOG]);
 270                 break;
 271         case SPRN_IVOR13:
 272                 kvmppc_set_gpr(vcpu, rt, vcpu->arch.ivor[BOOKE_IRQPRIO_DTLB_MISS]);
 273                 break;
 274         case SPRN_IVOR14:
 275                 kvmppc_set_gpr(vcpu, rt, vcpu->arch.ivor[BOOKE_IRQPRIO_ITLB_MISS]);
 276                 break;
 277         case SPRN_IVOR15:
 278                 kvmppc_set_gpr(vcpu, rt, vcpu->arch.ivor[BOOKE_IRQPRIO_DEBUG]);
 279                 break;
 280
 281         default:
 282                 emulated = EMULATE_FAIL;
 283         }
 284
 285         return emulated;
 286 }