arch/powerpc/kvm/44x_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  *
  17  * Authors: Hollis Blanchard <hollisb@us.ibm.com>
  18  */
  19
  20 #include <asm/kvm_ppc.h>
  21 #include <asm/dcr.h>
  22 #include <asm/dcr-regs.h>
  23 #include <asm/disassemble.h>
  24 #include <asm/kvm_44x.h>
  25 #include "timing.h"
  26
  27 #include "booke.h"
  28 #include "44x_tlb.h"
  29
  30 #define XOP_MFDCR   323
  31 #define XOP_MTDCR   451
  32 #define XOP_TLBSX   914
  33 #define XOP_ICCCI   966
  34 #define XOP_TLBWE   978
  35
  36 int kvmppc_core_emulate_op(struct kvm_run *run, struct kvm_vcpu *vcpu,
  37                            unsigned int inst, int *advance)
  38 {
  39         int emulated = EMULATE_DONE;
  40         int dcrn;
  41         int ra;
  42         int rb;
  43         int rc;
  44         int rs;
  45         int rt;
  46         int ws;
  47
  48         switch (get_op(inst)) {
  49         case 31:
  50                 switch (get_xop(inst)) {
  51
  52                 case XOP_MFDCR:
  53                         dcrn = get_dcrn(inst);
  54                         rt = get_rt(inst);
  55
  56                         /* The guest may access CPR0 registers to determine the timebase
  57                          * frequency, and it must know the real host frequency because it
  58                          * can directly access the timebase registers.
  59                          *
  60                          * It would be possible to emulate those accesses in userspace,
  61                          * but userspace can really only figure out the end frequency.
  62                          * We could decompose that into the factors that compute it, but
  63                          * that's tricky math, and it's easier to just report the real
  64                          * CPR0 values.
  65                          */
  66                         switch (dcrn) {
  67                         case DCRN_CPR0_CONFIG_ADDR:
  68                                 kvmppc_set_gpr(vcpu, rt, vcpu->arch.cpr0_cfgaddr);
  69                                 break;
  70                         case DCRN_CPR0_CONFIG_DATA:
  71                                 local_irq_disable();
  72                                 mtdcr(DCRN_CPR0_CONFIG_ADDR,
  73                                           vcpu->arch.cpr0_cfgaddr);
  74                                 kvmppc_set_gpr(vcpu, rt,
  75                                                mfdcr(DCRN_CPR0_CONFIG_DATA));
  76                                 local_irq_enable();
  77                                 break;
  78                         default:
  79                                 run->dcr.dcrn = dcrn;
  80                                 run->dcr.data =  0;
  81                                 run->dcr.is_write = 0;
  82                                 vcpu->arch.dcr_is_write = 0;
  83                                 vcpu->arch.io_gpr = rt;
  84                                 vcpu->arch.dcr_needed = 1;
  85                                 kvmppc_account_exit(vcpu, DCR_EXITS);
  86                                 emulated = EMULATE_DO_DCR;
  87                         }
  88
  89                         break;
  90
  91                 case XOP_MTDCR:
  92                         dcrn = get_dcrn(inst);
  93                         rs = get_rs(inst);
  94
  95                         /* emulate some access in kernel */
  96                         switch (dcrn) {
  97                         case DCRN_CPR0_CONFIG_ADDR:
  98                                 vcpu->arch.cpr0_cfgaddr = kvmppc_get_gpr(vcpu, rs);
  99                                 break;
 100                         default:
 101                                 run->dcr.dcrn = dcrn;
 102                                 run->dcr.data = kvmppc_get_gpr(vcpu, rs);
 103                                 run->dcr.is_write = 1;
 104                                 vcpu->arch.dcr_is_write = 1;
 105                                 vcpu->arch.dcr_needed = 1;
 106                                 kvmppc_account_exit(vcpu, DCR_EXITS);
 107                                 emulated = EMULATE_DO_DCR;
 108                         }
 109
 110                         break;
 111
 112                 case XOP_TLBWE:
 113                         ra = get_ra(inst);
 114                         rs = get_rs(inst);
 115                         ws = get_ws(inst);
 116                         emulated = kvmppc_44x_emul_tlbwe(vcpu, ra, rs, ws);
 117                         break;
 118
 119                 case XOP_TLBSX:
 120                         rt = get_rt(inst);
 121                         ra = get_ra(inst);
 122                         rb = get_rb(inst);
 123                         rc = get_rc(inst);
 124                         emulated = kvmppc_44x_emul_tlbsx(vcpu, rt, ra, rb, rc);
 125                         break;
 126
 127                 case XOP_ICCCI:
 128                         break;
 129
 130                 default:
 131                         emulated = EMULATE_FAIL;
 132                 }
 133
 134                 break;
 135
 136         default:
 137                 emulated = EMULATE_FAIL;
 138         }
 139
 140         if (emulated == EMULATE_FAIL)
 141                 emulated = kvmppc_booke_emulate_op(run, vcpu, inst, advance);
 142
 143         return emulated;
 144 }
 145
 146 int kvmppc_core_emulate_mtspr(struct kvm_vcpu *vcpu, int sprn, int rs)
 147 {
 148         int emulated = EMULATE_DONE;
 149
 150         switch (sprn) {
 151         case SPRN_PID:
 152                 kvmppc_set_pid(vcpu, kvmppc_get_gpr(vcpu, rs)); break;
 153         case SPRN_MMUCR:
 154                 vcpu->arch.mmucr = kvmppc_get_gpr(vcpu, rs); break;
 155         case SPRN_CCR0:
 156                 vcpu->arch.ccr0 = kvmppc_get_gpr(vcpu, rs); break;
 157         case SPRN_CCR1:
 158                 vcpu->arch.ccr1 = kvmppc_get_gpr(vcpu, rs); break;
 159         default:
 160                 emulated = kvmppc_booke_emulate_mtspr(vcpu, sprn, rs);
 161         }
 162
 163         return emulated;
 164 }
 165
 166 int kvmppc_core_emulate_mfspr(struct kvm_vcpu *vcpu, int sprn, int rt)
 167 {
 168         int emulated = EMULATE_DONE;
 169
 170         switch (sprn) {
 171         case SPRN_PID:
 172                 kvmppc_set_gpr(vcpu, rt, vcpu->arch.pid); break;
 173         case SPRN_MMUCR:
 174                 kvmppc_set_gpr(vcpu, rt, vcpu->arch.mmucr); break;
 175         case SPRN_CCR0:
 176                 kvmppc_set_gpr(vcpu, rt, vcpu->arch.ccr0); break;
 177         case SPRN_CCR1:
 178                 kvmppc_set_gpr(vcpu, rt, vcpu->arch.ccr1); break;
 179         default:
 180                 emulated = kvmppc_booke_emulate_mfspr(vcpu, sprn, rt);
 181         }
 182
 183         return emulated;
 184 }
 185