arch/powerpc/kvm/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. 2007
  16  *
  17  * Authors: Hollis Blanchard <hollisb@us.ibm.com>
  18  */
  19
  20 #include <linux/jiffies.h>
  21 #include <linux/timer.h>
  22 #include <linux/types.h>
  23 #include <linux/string.h>
  24 #include <linux/kvm_host.h>
  25
  26 #include <asm/dcr.h>
  27 #include <asm/dcr-regs.h>
  28 #include <asm/time.h>
  29 #include <asm/byteorder.h>
  30 #include <asm/kvm_ppc.h>
  31
  32 #include "44x_tlb.h"
  33
  34 /* Instruction decoding */
  35 static inline unsigned int get_op(u32 inst)
  36 {
  37         return inst >> 26;
  38 }
  39
  40 static inline unsigned int get_xop(u32 inst)
  41 {
  42         return (inst >> 1) & 0x3ff;
  43 }
  44
  45 static inline unsigned int get_sprn(u32 inst)
  46 {
  47         return ((inst >> 16) & 0x1f) | ((inst >> 6) & 0x3e0);
  48 }
  49
  50 static inline unsigned int get_dcrn(u32 inst)
  51 {
  52         return ((inst >> 16) & 0x1f) | ((inst >> 6) & 0x3e0);
  53 }
  54
  55 static inline unsigned int get_rt(u32 inst)
  56 {
  57         return (inst >> 21) & 0x1f;
  58 }
  59
  60 static inline unsigned int get_rs(u32 inst)
  61 {
  62         return (inst >> 21) & 0x1f;
  63 }
  64
  65 static inline unsigned int get_ra(u32 inst)
  66 {
  67         return (inst >> 16) & 0x1f;
  68 }
  69
  70 static inline unsigned int get_rb(u32 inst)
  71 {
  72         return (inst >> 11) & 0x1f;
  73 }
  74
  75 static inline unsigned int get_rc(u32 inst)
  76 {
  77         return inst & 0x1;
  78 }
  79
  80 static inline unsigned int get_ws(u32 inst)
  81 {
  82         return (inst >> 11) & 0x1f;
  83 }
  84
  85 static inline unsigned int get_d(u32 inst)
  86 {
  87         return inst & 0xffff;
  88 }
  89
  90 static int tlbe_is_host_safe(const struct kvm_vcpu *vcpu,
  91                              const struct tlbe *tlbe)
  92 {
  93         gpa_t gpa;
  94
  95         if (!get_tlb_v(tlbe))
  96                 return 0;
  97
  98         /* Does it match current guest AS? */
  99         /* XXX what about IS != DS? */
 100         if (get_tlb_ts(tlbe) != !!(vcpu->arch.msr & MSR_IS))
 101                 return 0;
 102
 103         gpa = get_tlb_raddr(tlbe);
 104         if (!gfn_to_memslot(vcpu->kvm, gpa >> PAGE_SHIFT))
 105                 /* Mapping is not for RAM. */
 106                 return 0;
 107
 108         return 1;
 109 }
 110
 111 static int kvmppc_emul_tlbwe(struct kvm_vcpu *vcpu, u32 inst)
 112 {
 113         u64 eaddr;
 114         u64 raddr;
 115         u64 asid;
 116         u32 flags;
 117         struct tlbe *tlbe;
 118         unsigned int ra;
 119         unsigned int rs;
 120         unsigned int ws;
 121         unsigned int index;
 122
 123         ra = get_ra(inst);
 124         rs = get_rs(inst);
 125         ws = get_ws(inst);
 126
 127         index = vcpu->arch.gpr[ra];
 128         if (index > PPC44x_TLB_SIZE) {
 129                 printk("%s: index %d\n", __func__, index);
 130                 kvmppc_dump_vcpu(vcpu);
 131                 return EMULATE_FAIL;
 132         }
 133
 134         tlbe = &vcpu->arch.guest_tlb[index];
 135
 136         /* Invalidate shadow mappings for the about-to-be-clobbered TLBE. */
 137         if (tlbe->word0 & PPC44x_TLB_VALID) {
 138                 eaddr = get_tlb_eaddr(tlbe);
 139                 asid = (tlbe->word0 & PPC44x_TLB_TS) | tlbe->tid;
 140                 kvmppc_mmu_invalidate(vcpu, eaddr, asid);
 141         }
 142
 143         switch (ws) {
 144         case PPC44x_TLB_PAGEID:
 145                 tlbe->tid = vcpu->arch.mmucr & 0xff;
 146                 tlbe->word0 = vcpu->arch.gpr[rs];
 147                 break;
 148
 149         case PPC44x_TLB_XLAT:
 150                 tlbe->word1 = vcpu->arch.gpr[rs];
 151                 break;
 152
 153         case PPC44x_TLB_ATTRIB:
 154                 tlbe->word2 = vcpu->arch.gpr[rs];
 155                 break;
 156
 157         default:
 158                 return EMULATE_FAIL;
 159         }
 160
 161         if (tlbe_is_host_safe(vcpu, tlbe)) {
 162                 eaddr = get_tlb_eaddr(tlbe);
 163                 raddr = get_tlb_raddr(tlbe);
 164                 asid = (tlbe->word0 & PPC44x_TLB_TS) | tlbe->tid;
 165                 flags = tlbe->word2 & 0xffff;
 166
 167                 /* Create a 4KB mapping on the host. If the guest wanted a
 168                  * large page, only the first 4KB is mapped here and the rest
 169                  * are mapped on the fly. */
 170                 kvmppc_mmu_map(vcpu, eaddr, raddr >> PAGE_SHIFT, asid, flags);
 171         }
 172
 173         return EMULATE_DONE;
 174 }
 175
 176 static void kvmppc_emulate_dec(struct kvm_vcpu *vcpu)
 177 {
 178         if (vcpu->arch.tcr & TCR_DIE) {
 179                 /* The decrementer ticks at the same rate as the timebase, so
 180                  * that's how we convert the guest DEC value to the number of
 181                  * host ticks. */
 182                 unsigned long nr_jiffies;
 183
 184                 nr_jiffies = vcpu->arch.dec / tb_ticks_per_jiffy;
 185                 mod_timer(&vcpu->arch.dec_timer,
 186                           get_jiffies_64() + nr_jiffies);
 187         } else {
 188                 del_timer(&vcpu->arch.dec_timer);
 189         }
 190 }
 191
 192 static void kvmppc_emul_rfi(struct kvm_vcpu *vcpu)
 193 {
 194         vcpu->arch.pc = vcpu->arch.srr0;
 195         kvmppc_set_msr(vcpu, vcpu->arch.srr1);
 196 }
 197
 198 /* XXX to do:
 199  * lhax
 200  * lhaux
 201  * lswx
 202  * lswi
 203  * stswx
 204  * stswi
 205  * lha
 206  * lhau
 207  * lmw
 208  * stmw
 209  *
 210  * XXX is_bigendian should depend on MMU mapping or MSR[LE]
 211  */
 212 int kvmppc_emulate_instruction(struct kvm_run *run, struct kvm_vcpu *vcpu)
 213 {
 214         u32 inst = vcpu->arch.last_inst;
 215         u32 ea;
 216         int ra;
 217         int rb;
 218         int rc;
 219         int rs;
 220         int rt;
 221         int sprn;
 222         int dcrn;
 223         enum emulation_result emulated = EMULATE_DONE;
 224         int advance = 1;
 225
 226         switch (get_op(inst)) {
 227         case 3:                                                 /* trap */
 228                 printk("trap!\n");
 229                 kvmppc_queue_exception(vcpu, BOOKE_INTERRUPT_PROGRAM);
 230                 advance = 0;
 231                 break;
 232
 233         case 19:
 234                 switch (get_xop(inst)) {
 235                 case 50:                                        /* rfi */
 236                         kvmppc_emul_rfi(vcpu);
 237                         advance = 0;
 238                         break;
 239
 240                 default:
 241                         emulated = EMULATE_FAIL;
 242                         break;
 243                 }
 244                 break;
 245
 246         case 31:
 247                 switch (get_xop(inst)) {
 248
 249                 case 83:                                        /* mfmsr */
 250                         rt = get_rt(inst);
 251                         vcpu->arch.gpr[rt] = vcpu->arch.msr;
 252                         break;
 253
 254                 case 87:                                        /* lbzx */
 255                         rt = get_rt(inst);
 256                         emulated = kvmppc_handle_load(run, vcpu, rt, 1, 1);
 257                         break;
 258
 259                 case 131:                                       /* wrtee */
 260                         rs = get_rs(inst);
 261                         vcpu->arch.msr = (vcpu->arch.msr & ~MSR_EE)
 262                                          | (vcpu->arch.gpr[rs] & MSR_EE);
 263                         break;
 264
 265                 case 146:                                       /* mtmsr */
 266                         rs = get_rs(inst);
 267                         kvmppc_set_msr(vcpu, vcpu->arch.gpr[rs]);
 268                         break;
 269
 270                 case 163:                                       /* wrteei */
 271                         vcpu->arch.msr = (vcpu->arch.msr & ~MSR_EE)
 272                                          | (inst & MSR_EE);
 273                         break;
 274
 275                 case 215:                                       /* stbx */
 276                         rs = get_rs(inst);
 277                         emulated = kvmppc_handle_store(run, vcpu,
 278                                                        vcpu->arch.gpr[rs],
 279                                                        1, 1);
 280                         break;
 281
 282                 case 247:                                       /* stbux */
 283                         rs = get_rs(inst);
 284                         ra = get_ra(inst);
 285                         rb = get_rb(inst);
 286
 287                         ea = vcpu->arch.gpr[rb];
 288                         if (ra)
 289                                 ea += vcpu->arch.gpr[ra];
 290
 291                         emulated = kvmppc_handle_store(run, vcpu,
 292                                                        vcpu->arch.gpr[rs],
 293                                                        1, 1);
 294                         vcpu->arch.gpr[rs] = ea;
 295                         break;
 296
 297                 case 279:                                       /* lhzx */
 298                         rt = get_rt(inst);
 299                         emulated = kvmppc_handle_load(run, vcpu, rt, 2, 1);
 300                         break;
 301
 302                 case 311:                                       /* lhzux */
 303                         rt = get_rt(inst);
 304                         ra = get_ra(inst);
 305                         rb = get_rb(inst);
 306
 307                         ea = vcpu->arch.gpr[rb];
 308                         if (ra)
 309                                 ea += vcpu->arch.gpr[ra];
 310
 311                         emulated = kvmppc_handle_load(run, vcpu, rt, 2, 1);
 312                         vcpu->arch.gpr[ra] = ea;
 313                         break;
 314
 315                 case 323:                                       /* mfdcr */
 316                         dcrn = get_dcrn(inst);
 317                         rt = get_rt(inst);
 318
 319                         /* The guest may access CPR0 registers to determine the timebase
 320                          * frequency, and it must know the real host frequency because it
 321                          * can directly access the timebase registers.
 322                          *
 323                          * It would be possible to emulate those accesses in userspace,
 324                          * but userspace can really only figure out the end frequency.
 325                          * We could decompose that into the factors that compute it, but
 326                          * that's tricky math, and it's easier to just report the real
 327                          * CPR0 values.
 328                          */
 329                         switch (dcrn) {
 330                         case DCRN_CPR0_CONFIG_ADDR:
 331                                 vcpu->arch.gpr[rt] = vcpu->arch.cpr0_cfgaddr;
 332                                 break;
 333                         case DCRN_CPR0_CONFIG_DATA:
 334                                 local_irq_disable();
 335                                 mtdcr(DCRN_CPR0_CONFIG_ADDR,
 336                                       vcpu->arch.cpr0_cfgaddr);
 337                                 vcpu->arch.gpr[rt] = mfdcr(DCRN_CPR0_CONFIG_DATA);
 338                                 local_irq_enable();
 339                                 break;
 340                         default:
 341                                 run->dcr.dcrn = dcrn;
 342                                 run->dcr.data =  0;
 343                                 run->dcr.is_write = 0;
 344                                 vcpu->arch.io_gpr = rt;
 345                                 vcpu->arch.dcr_needed = 1;
 346                                 emulated = EMULATE_DO_DCR;
 347                         }
 348
 349                         break;
 350
 351                 case 339:                                       /* mfspr */
 352                         sprn = get_sprn(inst);
 353                         rt = get_rt(inst);
 354
 355                         switch (sprn) {
 356                         case SPRN_SRR0:
 357                                 vcpu->arch.gpr[rt] = vcpu->arch.srr0; break;
 358                         case SPRN_SRR1:
 359                                 vcpu->arch.gpr[rt] = vcpu->arch.srr1; break;
 360                         case SPRN_MMUCR:
 361                                 vcpu->arch.gpr[rt] = vcpu->arch.mmucr; break;
 362                         case SPRN_PID:
 363                                 vcpu->arch.gpr[rt] = vcpu->arch.pid; break;
 364                         case SPRN_IVPR:
 365                                 vcpu->arch.gpr[rt] = vcpu->arch.ivpr; break;
 366                         case SPRN_CCR0:
 367                                 vcpu->arch.gpr[rt] = vcpu->arch.ccr0; break;
 368                         case SPRN_CCR1:
 369                                 vcpu->arch.gpr[rt] = vcpu->arch.ccr1; break;
 370                         case SPRN_PVR:
 371                                 vcpu->arch.gpr[rt] = vcpu->arch.pvr; break;
 372                         case SPRN_DEAR:
 373                                 vcpu->arch.gpr[rt] = vcpu->arch.dear; break;
 374                         case SPRN_ESR:
 375                                 vcpu->arch.gpr[rt] = vcpu->arch.esr; break;
 376                         case SPRN_DBCR0:
 377                                 vcpu->arch.gpr[rt] = vcpu->arch.dbcr0; break;
 378                         case SPRN_DBCR1:
 379                                 vcpu->arch.gpr[rt] = vcpu->arch.dbcr1; break;
 380
 381                         /* Note: mftb and TBRL/TBWL are user-accessible, so
 382                          * the guest can always access the real TB anyways.
 383                          * In fact, we probably will never see these traps. */
 384                         case SPRN_TBWL:
 385                                 vcpu->arch.gpr[rt] = mftbl(); break;
 386                         case SPRN_TBWU:
 387                                 vcpu->arch.gpr[rt] = mftbu(); break;
 388
 389                         case SPRN_SPRG0:
 390                                 vcpu->arch.gpr[rt] = vcpu->arch.sprg0; break;
 391                         case SPRN_SPRG1:
 392                                 vcpu->arch.gpr[rt] = vcpu->arch.sprg1; break;
 393                         case SPRN_SPRG2:
 394                                 vcpu->arch.gpr[rt] = vcpu->arch.sprg2; break;
 395                         case SPRN_SPRG3:
 396                                 vcpu->arch.gpr[rt] = vcpu->arch.sprg3; break;
 397                         /* Note: SPRG4-7 are user-readable, so we don't get
 398                          * a trap. */
 399
 400                         case SPRN_IVOR0:
 401                                 vcpu->arch.gpr[rt] = vcpu->arch.ivor[0]; break;
 402                         case SPRN_IVOR1:
 403                                 vcpu->arch.gpr[rt] = vcpu->arch.ivor[1]; break;
 404                         case SPRN_IVOR2:
 405                                 vcpu->arch.gpr[rt] = vcpu->arch.ivor[2]; break;
 406                         case SPRN_IVOR3:
 407                                 vcpu->arch.gpr[rt] = vcpu->arch.ivor[3]; break;
 408                         case SPRN_IVOR4:
 409                                 vcpu->arch.gpr[rt] = vcpu->arch.ivor[4]; break;
 410                         case SPRN_IVOR5:
 411                                 vcpu->arch.gpr[rt] = vcpu->arch.ivor[5]; break;
 412                         case SPRN_IVOR6:
 413                                 vcpu->arch.gpr[rt] = vcpu->arch.ivor[6]; break;
 414                         case SPRN_IVOR7:
 415                                 vcpu->arch.gpr[rt] = vcpu->arch.ivor[7]; break;
 416                         case SPRN_IVOR8:
 417                                 vcpu->arch.gpr[rt] = vcpu->arch.ivor[8]; break;
 418                         case SPRN_IVOR9:
 419                                 vcpu->arch.gpr[rt] = vcpu->arch.ivor[9]; break;
 420                         case SPRN_IVOR10:
 421                                 vcpu->arch.gpr[rt] = vcpu->arch.ivor[10]; break;
 422                         case SPRN_IVOR11:
 423                                 vcpu->arch.gpr[rt] = vcpu->arch.ivor[11]; break;
 424                         case SPRN_IVOR12:
 425                                 vcpu->arch.gpr[rt] = vcpu->arch.ivor[12]; break;
 426                         case SPRN_IVOR13:
 427                                 vcpu->arch.gpr[rt] = vcpu->arch.ivor[13]; break;
 428                         case SPRN_IVOR14:
 429                                 vcpu->arch.gpr[rt] = vcpu->arch.ivor[14]; break;
 430                         case SPRN_IVOR15:
 431                                 vcpu->arch.gpr[rt] = vcpu->arch.ivor[15]; break;
 432
 433                         default:
 434                                 printk("mfspr: unknown spr %x\n", sprn);
 435                                 vcpu->arch.gpr[rt] = 0;
 436                                 break;
 437                         }
 438                         break;
 439
 440                 case 407:                                       /* sthx */
 441                         rs = get_rs(inst);
 442                         ra = get_ra(inst);
 443                         rb = get_rb(inst);
 444
 445                         emulated = kvmppc_handle_store(run, vcpu,
 446                                                        vcpu->arch.gpr[rs],
 447                                                        2, 1);
 448                         break;
 449
 450                 case 439:                                       /* sthux */
 451                         rs = get_rs(inst);
 452                         ra = get_ra(inst);
 453                         rb = get_rb(inst);
 454
 455                         ea = vcpu->arch.gpr[rb];
 456                         if (ra)
 457                                 ea += vcpu->arch.gpr[ra];
 458
 459                         emulated = kvmppc_handle_store(run, vcpu,
 460                                                        vcpu->arch.gpr[rs],
 461                                                        2, 1);
 462                         vcpu->arch.gpr[ra] = ea;
 463                         break;
 464
 465                 case 451:                                       /* mtdcr */
 466                         dcrn = get_dcrn(inst);
 467                         rs = get_rs(inst);
 468
 469                         /* emulate some access in kernel */
 470                         switch (dcrn) {
 471                         case DCRN_CPR0_CONFIG_ADDR:
 472                                 vcpu->arch.cpr0_cfgaddr = vcpu->arch.gpr[rs];
 473                                 break;
 474                         default:
 475                                 run->dcr.dcrn = dcrn;
 476                                 run->dcr.data = vcpu->arch.gpr[rs];
 477                                 run->dcr.is_write = 1;
 478                                 vcpu->arch.dcr_needed = 1;
 479                                 emulated = EMULATE_DO_DCR;
 480                         }
 481
 482                         break;
 483
 484                 case 467:                                       /* mtspr */
 485                         sprn = get_sprn(inst);
 486                         rs = get_rs(inst);
 487                         switch (sprn) {
 488                         case SPRN_SRR0:
 489                                 vcpu->arch.srr0 = vcpu->arch.gpr[rs]; break;
 490                         case SPRN_SRR1:
 491                                 vcpu->arch.srr1 = vcpu->arch.gpr[rs]; break;
 492                         case SPRN_MMUCR:
 493                                 vcpu->arch.mmucr = vcpu->arch.gpr[rs]; break;
 494                         case SPRN_PID:
 495                                 vcpu->arch.pid = vcpu->arch.gpr[rs]; break;
 496                         case SPRN_CCR0:
 497                                 vcpu->arch.ccr0 = vcpu->arch.gpr[rs]; break;
 498                         case SPRN_CCR1:
 499                                 vcpu->arch.ccr1 = vcpu->arch.gpr[rs]; break;
 500                         case SPRN_DEAR:
 501                                 vcpu->arch.dear = vcpu->arch.gpr[rs]; break;
 502                         case SPRN_ESR:
 503                                 vcpu->arch.esr = vcpu->arch.gpr[rs]; break;
 504                         case SPRN_DBCR0:
 505                                 vcpu->arch.dbcr0 = vcpu->arch.gpr[rs]; break;
 506                         case SPRN_DBCR1:
 507                                 vcpu->arch.dbcr1 = vcpu->arch.gpr[rs]; break;
 508
 509                         /* XXX We need to context-switch the timebase for
 510                          * watchdog and FIT. */
 511                         case SPRN_TBWL: break;
 512                         case SPRN_TBWU: break;
 513
 514                         case SPRN_DEC:
 515                                 vcpu->arch.dec = vcpu->arch.gpr[rs];
 516                                 kvmppc_emulate_dec(vcpu);
 517                                 break;
 518
 519                         case SPRN_TSR:
 520                                 vcpu->arch.tsr &= ~vcpu->arch.gpr[rs]; break;
 521
 522                         case SPRN_TCR:
 523                                 vcpu->arch.tcr = vcpu->arch.gpr[rs];
 524                                 kvmppc_emulate_dec(vcpu);
 525                                 break;
 526
 527                         case SPRN_SPRG0:
 528                                 vcpu->arch.sprg0 = vcpu->arch.gpr[rs]; break;
 529                         case SPRN_SPRG1:
 530                                 vcpu->arch.sprg1 = vcpu->arch.gpr[rs]; break;
 531                         case SPRN_SPRG2:
 532                                 vcpu->arch.sprg2 = vcpu->arch.gpr[rs]; break;
 533                         case SPRN_SPRG3:
 534                                 vcpu->arch.sprg3 = vcpu->arch.gpr[rs]; break;
 535
 536                         /* Note: SPRG4-7 are user-readable. These values are
 537                          * loaded into the real SPRGs when resuming the
 538                          * guest. */
 539                         case SPRN_SPRG4:
 540                                 vcpu->arch.sprg4 = vcpu->arch.gpr[rs]; break;
 541                         case SPRN_SPRG5:
 542                                 vcpu->arch.sprg5 = vcpu->arch.gpr[rs]; break;
 543                         case SPRN_SPRG6:
 544                                 vcpu->arch.sprg6 = vcpu->arch.gpr[rs]; break;
 545                         case SPRN_SPRG7:
 546                                 vcpu->arch.sprg7 = vcpu->arch.gpr[rs]; break;
 547
 548                         case SPRN_IVPR:
 549                                 vcpu->arch.ivpr = vcpu->arch.gpr[rs]; break;
 550                         case SPRN_IVOR0:
 551                                 vcpu->arch.ivor[0] = vcpu->arch.gpr[rs]; break;
 552                         case SPRN_IVOR1:
 553                                 vcpu->arch.ivor[1] = vcpu->arch.gpr[rs]; break;
 554                         case SPRN_IVOR2:
 555                                 vcpu->arch.ivor[2] = vcpu->arch.gpr[rs]; break;
 556                         case SPRN_IVOR3:
 557                                 vcpu->arch.ivor[3] = vcpu->arch.gpr[rs]; break;
 558                         case SPRN_IVOR4:
 559                                 vcpu->arch.ivor[4] = vcpu->arch.gpr[rs]; break;
 560                         case SPRN_IVOR5:
 561                                 vcpu->arch.ivor[5] = vcpu->arch.gpr[rs]; break;
 562                         case SPRN_IVOR6:
 563                                 vcpu->arch.ivor[6] = vcpu->arch.gpr[rs]; break;
 564                         case SPRN_IVOR7:
 565                                 vcpu->arch.ivor[7] = vcpu->arch.gpr[rs]; break;
 566                         case SPRN_IVOR8:
 567                                 vcpu->arch.ivor[8] = vcpu->arch.gpr[rs]; break;
 568                         case SPRN_IVOR9:
 569                                 vcpu->arch.ivor[9] = vcpu->arch.gpr[rs]; break;
 570                         case SPRN_IVOR10:
 571                                 vcpu->arch.ivor[10] = vcpu->arch.gpr[rs]; break;
 572                         case SPRN_IVOR11:
 573                                 vcpu->arch.ivor[11] = vcpu->arch.gpr[rs]; break;
 574                         case SPRN_IVOR12:
 575                                 vcpu->arch.ivor[12] = vcpu->arch.gpr[rs]; break;
 576                         case SPRN_IVOR13:
 577                                 vcpu->arch.ivor[13] = vcpu->arch.gpr[rs]; break;
 578                         case SPRN_IVOR14:
 579                                 vcpu->arch.ivor[14] = vcpu->arch.gpr[rs]; break;
 580                         case SPRN_IVOR15:
 581                                 vcpu->arch.ivor[15] = vcpu->arch.gpr[rs]; break;
 582
 583                         default:
 584                                 printk("mtspr: unknown spr %x\n", sprn);
 585                                 emulated = EMULATE_FAIL;
 586                                 break;
 587                         }
 588                         break;
 589
 590                 case 470:                                       /* dcbi */
 591                         /* Do nothing. The guest is performing dcbi because
 592                          * hardware DMA is not snooped by the dcache, but
 593                          * emulated DMA either goes through the dcache as
 594                          * normal writes, or the host kernel has handled dcache
 595                          * coherence. */
 596                         break;
 597
 598                 case 534:                                       /* lwbrx */
 599                         rt = get_rt(inst);
 600                         emulated = kvmppc_handle_load(run, vcpu, rt, 4, 0);
 601                         break;
 602
 603                 case 566:                                       /* tlbsync */
 604                         break;
 605
 606                 case 662:                                       /* stwbrx */
 607                         rs = get_rs(inst);
 608                         ra = get_ra(inst);
 609                         rb = get_rb(inst);
 610
 611                         emulated = kvmppc_handle_store(run, vcpu,
 612                                                        vcpu->arch.gpr[rs],
 613                                                        4, 0);
 614                         break;
 615
 616                 case 978:                                       /* tlbwe */
 617                         emulated = kvmppc_emul_tlbwe(vcpu, inst);
 618                         break;
 619
 620                 case 914:       {                               /* tlbsx */
 621                         int index;
 622                         unsigned int as = get_mmucr_sts(vcpu);
 623                         unsigned int pid = get_mmucr_stid(vcpu);
 624
 625                         rt = get_rt(inst);
 626                         ra = get_ra(inst);
 627                         rb = get_rb(inst);
 628                         rc = get_rc(inst);
 629
 630                         ea = vcpu->arch.gpr[rb];
 631                         if (ra)
 632                                 ea += vcpu->arch.gpr[ra];
 633
 634                         index = kvmppc_44x_tlb_index(vcpu, ea, pid, as);
 635                         if (rc) {
 636                                 if (index < 0)
 637                                         vcpu->arch.cr &= ~0x20000000;
 638                                 else
 639                                         vcpu->arch.cr |= 0x20000000;
 640                         }
 641                         vcpu->arch.gpr[rt] = index;
 642
 643                         }
 644                         break;
 645
 646                 case 790:                                       /* lhbrx */
 647                         rt = get_rt(inst);
 648                         emulated = kvmppc_handle_load(run, vcpu, rt, 2, 0);
 649                         break;
 650
 651                 case 918:                                       /* sthbrx */
 652                         rs = get_rs(inst);
 653                         ra = get_ra(inst);
 654                         rb = get_rb(inst);
 655
 656                         emulated = kvmppc_handle_store(run, vcpu,
 657                                                        vcpu->arch.gpr[rs],
 658                                                        2, 0);
 659                         break;
 660
 661                 case 966:                                       /* iccci */
 662                         break;
 663
 664                 default:
 665                         printk("unknown: op %d xop %d\n", get_op(inst),
 666                                 get_xop(inst));
 667                         emulated = EMULATE_FAIL;
 668                         break;
 669                 }
 670                 break;
 671
 672         case 32:                                                /* lwz */
 673                 rt = get_rt(inst);
 674                 emulated = kvmppc_handle_load(run, vcpu, rt, 4, 1);
 675                 break;
 676
 677         case 33:                                                /* lwzu */
 678                 ra = get_ra(inst);
 679                 rt = get_rt(inst);
 680                 emulated = kvmppc_handle_load(run, vcpu, rt, 4, 1);
 681                 vcpu->arch.gpr[ra] = vcpu->arch.paddr_accessed;
 682                 break;
 683
 684         case 34:                                                /* lbz */
 685                 rt = get_rt(inst);
 686                 emulated = kvmppc_handle_load(run, vcpu, rt, 1, 1);
 687                 break;
 688
 689         case 35:                                                /* lbzu */
 690                 ra = get_ra(inst);
 691                 rt = get_rt(inst);
 692                 emulated = kvmppc_handle_load(run, vcpu, rt, 1, 1);
 693                 vcpu->arch.gpr[ra] = vcpu->arch.paddr_accessed;
 694                 break;
 695
 696         case 36:                                                /* stw */
 697                 rs = get_rs(inst);
 698                 emulated = kvmppc_handle_store(run, vcpu, vcpu->arch.gpr[rs],
 699                                                4, 1);
 700                 break;
 701
 702         case 37:                                                /* stwu */
 703                 ra = get_ra(inst);
 704                 rs = get_rs(inst);
 705                 emulated = kvmppc_handle_store(run, vcpu, vcpu->arch.gpr[rs],
 706                                                4, 1);
 707                 vcpu->arch.gpr[ra] = vcpu->arch.paddr_accessed;
 708                 break;
 709
 710         case 38:                                                /* stb */
 711                 rs = get_rs(inst);
 712                 emulated = kvmppc_handle_store(run, vcpu, vcpu->arch.gpr[rs],
 713                                                1, 1);
 714                 break;
 715
 716         case 39:                                                /* stbu */
 717                 ra = get_ra(inst);
 718                 rs = get_rs(inst);
 719                 emulated = kvmppc_handle_store(run, vcpu, vcpu->arch.gpr[rs],
 720                                                1, 1);
 721                 vcpu->arch.gpr[ra] = vcpu->arch.paddr_accessed;
 722                 break;
 723
 724         case 40:                                                /* lhz */
 725                 rt = get_rt(inst);
 726                 emulated = kvmppc_handle_load(run, vcpu, rt, 2, 1);
 727                 break;
 728
 729         case 41:                                                /* lhzu */
 730                 ra = get_ra(inst);
 731                 rt = get_rt(inst);
 732                 emulated = kvmppc_handle_load(run, vcpu, rt, 2, 1);
 733                 vcpu->arch.gpr[ra] = vcpu->arch.paddr_accessed;
 734                 break;
 735
 736         case 44:                                                /* sth */
 737                 rs = get_rs(inst);
 738                 emulated = kvmppc_handle_store(run, vcpu, vcpu->arch.gpr[rs],
 739                                                2, 1);
 740                 break;
 741
 742         case 45:                                                /* sthu */
 743                 ra = get_ra(inst);
 744                 rs = get_rs(inst);
 745                 emulated = kvmppc_handle_store(run, vcpu, vcpu->arch.gpr[rs],
 746                                                2, 1);
 747                 vcpu->arch.gpr[ra] = vcpu->arch.paddr_accessed;
 748                 break;
 749
 750         default:
 751                 printk("unknown op %d\n", get_op(inst));
 752                 emulated = EMULATE_FAIL;
 753                 break;
 754         }
 755
 756         if (advance)
 757                 vcpu->arch.pc += 4; /* Advance past emulated instruction. */
 758
 759         return emulated;
 760 }