mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-16 03:46:48 +07:00
d94d71cb45
Based on 1 normalized pattern(s): this program is free software you can redistribute it and or modify it under the terms of the gnu general public license version 2 as published by the free software foundation this program is distributed in the hope that it will be useful but without any warranty without even the implied warranty of merchantability or fitness for a particular purpose see the gnu general public license for more details you should have received a copy of the gnu general public license along with this program if not write to the free software foundation 51 franklin street fifth floor boston ma 02110 1301 usa extracted by the scancode license scanner the SPDX license identifier GPL-2.0-only has been chosen to replace the boilerplate/reference in 67 file(s). Signed-off-by: Thomas Gleixner <tglx@linutronix.de> Reviewed-by: Allison Randal <allison@lohutok.net> Reviewed-by: Richard Fontana <rfontana@redhat.com> Reviewed-by: Alexios Zavras <alexios.zavras@intel.com> Cc: linux-spdx@vger.kernel.org Link: https://lkml.kernel.org/r/20190529141333.953658117@linutronix.de Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
307 lines
6.7 KiB
C
307 lines
6.7 KiB
C
// SPDX-License-Identifier: GPL-2.0-only
|
|
/*
|
|
*
|
|
* Copyright IBM Corp. 2007
|
|
* Copyright 2011 Freescale Semiconductor, Inc.
|
|
*
|
|
* Authors: Hollis Blanchard <hollisb@us.ibm.com>
|
|
*/
|
|
|
|
#include <linux/jiffies.h>
|
|
#include <linux/hrtimer.h>
|
|
#include <linux/types.h>
|
|
#include <linux/string.h>
|
|
#include <linux/kvm_host.h>
|
|
#include <linux/clockchips.h>
|
|
|
|
#include <asm/reg.h>
|
|
#include <asm/time.h>
|
|
#include <asm/byteorder.h>
|
|
#include <asm/kvm_ppc.h>
|
|
#include <asm/disassemble.h>
|
|
#include <asm/ppc-opcode.h>
|
|
#include "timing.h"
|
|
#include "trace.h"
|
|
|
|
void kvmppc_emulate_dec(struct kvm_vcpu *vcpu)
|
|
{
|
|
unsigned long dec_nsec;
|
|
unsigned long long dec_time;
|
|
|
|
pr_debug("mtDEC: %lx\n", vcpu->arch.dec);
|
|
hrtimer_try_to_cancel(&vcpu->arch.dec_timer);
|
|
|
|
#ifdef CONFIG_PPC_BOOK3S
|
|
/* mtdec lowers the interrupt line when positive. */
|
|
kvmppc_core_dequeue_dec(vcpu);
|
|
#endif
|
|
|
|
#ifdef CONFIG_BOOKE
|
|
/* On BOOKE, DEC = 0 is as good as decrementer not enabled */
|
|
if (vcpu->arch.dec == 0)
|
|
return;
|
|
#endif
|
|
|
|
/*
|
|
* The decrementer ticks at the same rate as the timebase, so
|
|
* that's how we convert the guest DEC value to the number of
|
|
* host ticks.
|
|
*/
|
|
|
|
dec_time = vcpu->arch.dec;
|
|
/*
|
|
* Guest timebase ticks at the same frequency as host timebase.
|
|
* So use the host timebase calculations for decrementer emulation.
|
|
*/
|
|
dec_time = tb_to_ns(dec_time);
|
|
dec_nsec = do_div(dec_time, NSEC_PER_SEC);
|
|
hrtimer_start(&vcpu->arch.dec_timer,
|
|
ktime_set(dec_time, dec_nsec), HRTIMER_MODE_REL);
|
|
vcpu->arch.dec_jiffies = get_tb();
|
|
}
|
|
|
|
u32 kvmppc_get_dec(struct kvm_vcpu *vcpu, u64 tb)
|
|
{
|
|
u64 jd = tb - vcpu->arch.dec_jiffies;
|
|
|
|
#ifdef CONFIG_BOOKE
|
|
if (vcpu->arch.dec < jd)
|
|
return 0;
|
|
#endif
|
|
|
|
return vcpu->arch.dec - jd;
|
|
}
|
|
|
|
static int kvmppc_emulate_mtspr(struct kvm_vcpu *vcpu, int sprn, int rs)
|
|
{
|
|
enum emulation_result emulated = EMULATE_DONE;
|
|
ulong spr_val = kvmppc_get_gpr(vcpu, rs);
|
|
|
|
switch (sprn) {
|
|
case SPRN_SRR0:
|
|
kvmppc_set_srr0(vcpu, spr_val);
|
|
break;
|
|
case SPRN_SRR1:
|
|
kvmppc_set_srr1(vcpu, spr_val);
|
|
break;
|
|
|
|
/* XXX We need to context-switch the timebase for
|
|
* watchdog and FIT. */
|
|
case SPRN_TBWL: break;
|
|
case SPRN_TBWU: break;
|
|
|
|
case SPRN_DEC:
|
|
vcpu->arch.dec = (u32) spr_val;
|
|
kvmppc_emulate_dec(vcpu);
|
|
break;
|
|
|
|
case SPRN_SPRG0:
|
|
kvmppc_set_sprg0(vcpu, spr_val);
|
|
break;
|
|
case SPRN_SPRG1:
|
|
kvmppc_set_sprg1(vcpu, spr_val);
|
|
break;
|
|
case SPRN_SPRG2:
|
|
kvmppc_set_sprg2(vcpu, spr_val);
|
|
break;
|
|
case SPRN_SPRG3:
|
|
kvmppc_set_sprg3(vcpu, spr_val);
|
|
break;
|
|
|
|
/* PIR can legally be written, but we ignore it */
|
|
case SPRN_PIR: break;
|
|
|
|
default:
|
|
emulated = vcpu->kvm->arch.kvm_ops->emulate_mtspr(vcpu, sprn,
|
|
spr_val);
|
|
if (emulated == EMULATE_FAIL)
|
|
printk(KERN_INFO "mtspr: unknown spr "
|
|
"0x%x\n", sprn);
|
|
break;
|
|
}
|
|
|
|
kvmppc_set_exit_type(vcpu, EMULATED_MTSPR_EXITS);
|
|
|
|
return emulated;
|
|
}
|
|
|
|
static int kvmppc_emulate_mfspr(struct kvm_vcpu *vcpu, int sprn, int rt)
|
|
{
|
|
enum emulation_result emulated = EMULATE_DONE;
|
|
ulong spr_val = 0;
|
|
|
|
switch (sprn) {
|
|
case SPRN_SRR0:
|
|
spr_val = kvmppc_get_srr0(vcpu);
|
|
break;
|
|
case SPRN_SRR1:
|
|
spr_val = kvmppc_get_srr1(vcpu);
|
|
break;
|
|
case SPRN_PVR:
|
|
spr_val = vcpu->arch.pvr;
|
|
break;
|
|
case SPRN_PIR:
|
|
spr_val = vcpu->vcpu_id;
|
|
break;
|
|
|
|
/* Note: mftb and TBRL/TBWL are user-accessible, so
|
|
* the guest can always access the real TB anyways.
|
|
* In fact, we probably will never see these traps. */
|
|
case SPRN_TBWL:
|
|
spr_val = get_tb() >> 32;
|
|
break;
|
|
case SPRN_TBWU:
|
|
spr_val = get_tb();
|
|
break;
|
|
|
|
case SPRN_SPRG0:
|
|
spr_val = kvmppc_get_sprg0(vcpu);
|
|
break;
|
|
case SPRN_SPRG1:
|
|
spr_val = kvmppc_get_sprg1(vcpu);
|
|
break;
|
|
case SPRN_SPRG2:
|
|
spr_val = kvmppc_get_sprg2(vcpu);
|
|
break;
|
|
case SPRN_SPRG3:
|
|
spr_val = kvmppc_get_sprg3(vcpu);
|
|
break;
|
|
/* Note: SPRG4-7 are user-readable, so we don't get
|
|
* a trap. */
|
|
|
|
case SPRN_DEC:
|
|
spr_val = kvmppc_get_dec(vcpu, get_tb());
|
|
break;
|
|
default:
|
|
emulated = vcpu->kvm->arch.kvm_ops->emulate_mfspr(vcpu, sprn,
|
|
&spr_val);
|
|
if (unlikely(emulated == EMULATE_FAIL)) {
|
|
printk(KERN_INFO "mfspr: unknown spr "
|
|
"0x%x\n", sprn);
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (emulated == EMULATE_DONE)
|
|
kvmppc_set_gpr(vcpu, rt, spr_val);
|
|
kvmppc_set_exit_type(vcpu, EMULATED_MFSPR_EXITS);
|
|
|
|
return emulated;
|
|
}
|
|
|
|
/* XXX Should probably auto-generate instruction decoding for a particular core
|
|
* from opcode tables in the future. */
|
|
int kvmppc_emulate_instruction(struct kvm_run *run, struct kvm_vcpu *vcpu)
|
|
{
|
|
u32 inst;
|
|
int rs, rt, sprn;
|
|
enum emulation_result emulated;
|
|
int advance = 1;
|
|
|
|
/* this default type might be overwritten by subcategories */
|
|
kvmppc_set_exit_type(vcpu, EMULATED_INST_EXITS);
|
|
|
|
emulated = kvmppc_get_last_inst(vcpu, INST_GENERIC, &inst);
|
|
if (emulated != EMULATE_DONE)
|
|
return emulated;
|
|
|
|
pr_debug("Emulating opcode %d / %d\n", get_op(inst), get_xop(inst));
|
|
|
|
rs = get_rs(inst);
|
|
rt = get_rt(inst);
|
|
sprn = get_sprn(inst);
|
|
|
|
switch (get_op(inst)) {
|
|
case OP_TRAP:
|
|
#ifdef CONFIG_PPC_BOOK3S
|
|
case OP_TRAP_64:
|
|
kvmppc_core_queue_program(vcpu, SRR1_PROGTRAP);
|
|
#else
|
|
kvmppc_core_queue_program(vcpu,
|
|
vcpu->arch.shared->esr | ESR_PTR);
|
|
#endif
|
|
advance = 0;
|
|
break;
|
|
|
|
case 31:
|
|
switch (get_xop(inst)) {
|
|
|
|
case OP_31_XOP_TRAP:
|
|
#ifdef CONFIG_64BIT
|
|
case OP_31_XOP_TRAP_64:
|
|
#endif
|
|
#ifdef CONFIG_PPC_BOOK3S
|
|
kvmppc_core_queue_program(vcpu, SRR1_PROGTRAP);
|
|
#else
|
|
kvmppc_core_queue_program(vcpu,
|
|
vcpu->arch.shared->esr | ESR_PTR);
|
|
#endif
|
|
advance = 0;
|
|
break;
|
|
|
|
case OP_31_XOP_MFSPR:
|
|
emulated = kvmppc_emulate_mfspr(vcpu, sprn, rt);
|
|
if (emulated == EMULATE_AGAIN) {
|
|
emulated = EMULATE_DONE;
|
|
advance = 0;
|
|
}
|
|
break;
|
|
|
|
case OP_31_XOP_MTSPR:
|
|
emulated = kvmppc_emulate_mtspr(vcpu, sprn, rs);
|
|
if (emulated == EMULATE_AGAIN) {
|
|
emulated = EMULATE_DONE;
|
|
advance = 0;
|
|
}
|
|
break;
|
|
|
|
case OP_31_XOP_TLBSYNC:
|
|
break;
|
|
|
|
default:
|
|
/* Attempt core-specific emulation below. */
|
|
emulated = EMULATE_FAIL;
|
|
}
|
|
break;
|
|
|
|
case 0:
|
|
/*
|
|
* Instruction with primary opcode 0. Based on PowerISA
|
|
* these are illegal instructions.
|
|
*/
|
|
if (inst == KVMPPC_INST_SW_BREAKPOINT) {
|
|
run->exit_reason = KVM_EXIT_DEBUG;
|
|
run->debug.arch.address = kvmppc_get_pc(vcpu);
|
|
emulated = EMULATE_EXIT_USER;
|
|
advance = 0;
|
|
} else
|
|
emulated = EMULATE_FAIL;
|
|
|
|
break;
|
|
|
|
default:
|
|
emulated = EMULATE_FAIL;
|
|
}
|
|
|
|
if (emulated == EMULATE_FAIL) {
|
|
emulated = vcpu->kvm->arch.kvm_ops->emulate_op(run, vcpu, inst,
|
|
&advance);
|
|
if (emulated == EMULATE_AGAIN) {
|
|
advance = 0;
|
|
} else if (emulated == EMULATE_FAIL) {
|
|
advance = 0;
|
|
printk(KERN_ERR "Couldn't emulate instruction 0x%08x "
|
|
"(op %d xop %d)\n", inst, get_op(inst), get_xop(inst));
|
|
}
|
|
}
|
|
|
|
trace_kvm_ppc_instr(inst, kvmppc_get_pc(vcpu), emulated);
|
|
|
|
/* Advance past emulated instruction. */
|
|
if (advance)
|
|
kvmppc_set_pc(vcpu, kvmppc_get_pc(vcpu) + 4);
|
|
|
|
return emulated;
|
|
}
|
|
EXPORT_SYMBOL_GPL(kvmppc_emulate_instruction);
|