[deliverable/linux.git] / arch / arm64 / kvm / reset.c

/*
 * Copyright (C) 2012,2013 - ARM Ltd
 * Author: Marc Zyngier <marc.zyngier@arm.com>
 *
 * Derived from arch/arm/kvm/reset.c
 * Copyright (C) 2012 - Virtual Open Systems and Columbia University
 * Author: Christoffer Dall <c.dall@virtualopensystems.com>
 *
 * 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, see <http://www.gnu.org/licenses/>.
 */

#include <linux/errno.h>
#include <linux/kvm_host.h>
#include <linux/kvm.h>
#include <linux/hw_breakpoint.h>

#include <kvm/arm_arch_timer.h>

#include <asm/cputype.h>
#include <asm/ptrace.h>
#include <asm/kvm_arm.h>
#include <asm/kvm_asm.h>
#include <asm/kvm_coproc.h>
#include <asm/kvm_mmu.h>

/*
 * ARMv8 Reset Values
 */
static const struct kvm_regs default_regs_reset = {
	.regs.pstate = (PSR_MODE_EL1h | PSR_A_BIT | PSR_I_BIT |
			PSR_F_BIT | PSR_D_BIT),
};

static const struct kvm_regs default_regs_reset32 = {
	.regs.pstate = (COMPAT_PSR_MODE_SVC | COMPAT_PSR_A_BIT |
			COMPAT_PSR_I_BIT | COMPAT_PSR_F_BIT),
};

static const struct kvm_irq_level default_vtimer_irq = {
	.irq	= 27,
	.level	= 1,
};

static bool cpu_has_32bit_el1(void)
{
	u64 pfr0;

	pfr0 = read_system_reg(SYS_ID_AA64PFR0_EL1);
	return !!(pfr0 & 0x20);
}

/**
 * kvm_arch_dev_ioctl_check_extension
 *
 * We currently assume that the number of HW registers is uniform
 * across all CPUs (see cpuinfo_sanity_check).
 */
int kvm_arch_dev_ioctl_check_extension(long ext)
{
	int r;

	switch (ext) {
	case KVM_CAP_ARM_EL1_32BIT:
		r = cpu_has_32bit_el1();
		break;
	case KVM_CAP_GUEST_DEBUG_HW_BPS:
		r = get_num_brps();
		break;
	case KVM_CAP_GUEST_DEBUG_HW_WPS:
		r = get_num_wrps();
		break;
	case KVM_CAP_ARM_PMU_V3:
		r = kvm_arm_support_pmu_v3();
		break;
	case KVM_CAP_SET_GUEST_DEBUG:
	case KVM_CAP_VCPU_ATTRIBUTES:
		r = 1;
		break;
	default:
		r = 0;
	}

	return r;
}

/**
 * kvm_reset_vcpu - sets core registers and sys_regs to reset value
 * @vcpu: The VCPU pointer
 *
 * This function finds the right table above and sets the registers on
 * the virtual CPU struct to their architectually defined reset
 * values.
 */
int kvm_reset_vcpu(struct kvm_vcpu *vcpu)
{
	const struct kvm_irq_level *cpu_vtimer_irq;
	const struct kvm_regs *cpu_reset;

	switch (vcpu->arch.target) {
	default:
		if (test_bit(KVM_ARM_VCPU_EL1_32BIT, vcpu->arch.features)) {
			if (!cpu_has_32bit_el1())
				return -EINVAL;
			cpu_reset = &default_regs_reset32;
		} else {
			cpu_reset = &default_regs_reset;
		}

		cpu_vtimer_irq = &default_vtimer_irq;
		break;
	}

	/* Reset core registers */
	memcpy(vcpu_gp_regs(vcpu), cpu_reset, sizeof(*cpu_reset));

	/* Reset system registers */
	kvm_reset_sys_regs(vcpu);

	/* Reset PMU */
	kvm_pmu_vcpu_reset(vcpu);

	/* Reset timer */
	return kvm_timer_vcpu_reset(vcpu, cpu_vtimer_irq);
}

extern char __hyp_idmap_text_start[];

unsigned long kvm_hyp_reset_entry(void)
{
	if (!__kvm_cpu_uses_extended_idmap()) {
		unsigned long offset;

		/*
		 * Find the address of __kvm_hyp_reset() in the trampoline page.
		 * This is present in the running page tables, and the boot page
		 * tables, so we call the code here to start the trampoline
		 * dance in reverse.
		 */
		offset = (unsigned long)__kvm_hyp_reset
			 - ((unsigned long)__hyp_idmap_text_start & PAGE_MASK);

		return TRAMPOLINE_VA + offset;
	} else {
		/*
		 * KVM is running with merged page tables, which don't have the
		 * trampoline page mapped. We know the idmap is still mapped,
		 * but can't be called into directly. Use
		 * __extended_idmap_trampoline to do the call.
		 */
		return (unsigned long)kvm_ksym_ref(__extended_idmap_trampoline);
	}
}
Commit	Line	Data
f4672752 MZ	1	/*
	2	* Copyright (C) 2012,2013 - ARM Ltd
	3	* Author: Marc Zyngier <marc.zyngier@arm.com>
	4	*
	5	* Derived from arch/arm/kvm/reset.c
	6	* Copyright (C) 2012 - Virtual Open Systems and Columbia University
	7	* Author: Christoffer Dall <c.dall@virtualopensystems.com>
	8	*
	9	* This program is free software; you can redistribute it and/or modify
	10	* it under the terms of the GNU General Public License, version 2, as
	11	* published by the Free Software Foundation.
	12	*
	13	* This program is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	* GNU General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU General Public License
	19	* along with this program. If not, see <http://www.gnu.org/licenses/>.
	20	*/
	21
	22	#include <linux/errno.h>
	23	#include <linux/kvm_host.h>
	24	#include <linux/kvm.h>
834bf887	25	#include <linux/hw_breakpoint.h>
f4672752	26
003300de MZ	27	#include <kvm/arm_arch_timer.h>
003300de MZ	28
f4672752 MZ	29	#include <asm/cputype.h>
	30	#include <asm/ptrace.h>
	31	#include <asm/kvm_arm.h>
67f69197	32	#include <asm/kvm_asm.h>
f4672752	33	#include <asm/kvm_coproc.h>
67f69197	34	#include <asm/kvm_mmu.h>
f4672752 MZ	35
	36	/*
	37	* ARMv8 Reset Values
	38	*/
	39	static const struct kvm_regs default_regs_reset = {
	40	.regs.pstate = (PSR_MODE_EL1h \| PSR_A_BIT \| PSR_I_BIT \|
	41	PSR_F_BIT \| PSR_D_BIT),
	42	};
	43
0d854a60 MZ	44	static const struct kvm_regs default_regs_reset32 = {
	45	.regs.pstate = (COMPAT_PSR_MODE_SVC \| COMPAT_PSR_A_BIT \|
	46	COMPAT_PSR_I_BIT \| COMPAT_PSR_F_BIT),
	47	};
	48
003300de MZ	49	static const struct kvm_irq_level default_vtimer_irq = {
	50	.irq = 27,
	51	.level = 1,
	52	};
	53
0d854a60 MZ	54	static bool cpu_has_32bit_el1(void)
	55	{
	56	u64 pfr0;
	57
4db8e5ea	58	pfr0 = read_system_reg(SYS_ID_AA64PFR0_EL1);
0d854a60 MZ	59	return !!(pfr0 & 0x20);
	60	}
	61
834bf887 AB	62	/**
	63	* kvm_arch_dev_ioctl_check_extension
	64	*
	65	* We currently assume that the number of HW registers is uniform
	66	* across all CPUs (see cpuinfo_sanity_check).
	67	*/
f4672752 MZ	68	int kvm_arch_dev_ioctl_check_extension(long ext)
	69	{
	70	int r;
	71
	72	switch (ext) {
0d854a60 MZ	73	case KVM_CAP_ARM_EL1_32BIT:
	74	r = cpu_has_32bit_el1();
	75	break;
834bf887 AB	76	case KVM_CAP_GUEST_DEBUG_HW_BPS:
	77	r = get_num_brps();
	78	break;
	79	case KVM_CAP_GUEST_DEBUG_HW_WPS:
	80	r = get_num_wrps();
	81	break;
808e7381 SZ	82	case KVM_CAP_ARM_PMU_V3:
	83	r = kvm_arm_support_pmu_v3();
	84	break;
834bf887	85	case KVM_CAP_SET_GUEST_DEBUG:
f577f6c2	86	case KVM_CAP_VCPU_ATTRIBUTES:
834bf887 AB	87	r = 1;
834bf887 AB	88	break;
f4672752 MZ	89	default:
	90	r = 0;
	91	}
	92
	93	return r;
	94	}
	95
	96	/**
	97	* kvm_reset_vcpu - sets core registers and sys_regs to reset value
	98	* @vcpu: The VCPU pointer
	99	*
	100	* This function finds the right table above and sets the registers on
	101	* the virtual CPU struct to their architectually defined reset
	102	* values.
	103	*/
	104	int kvm_reset_vcpu(struct kvm_vcpu *vcpu)
	105	{
003300de	106	const struct kvm_irq_level *cpu_vtimer_irq;
f4672752 MZ	107	const struct kvm_regs *cpu_reset;
	108
	109	switch (vcpu->arch.target) {
	110	default:
0d854a60 MZ	111	if (test_bit(KVM_ARM_VCPU_EL1_32BIT, vcpu->arch.features)) {
	112	if (!cpu_has_32bit_el1())
	113	return -EINVAL;
	114	cpu_reset = &default_regs_reset32;
0d854a60 MZ	115	} else {
	116	cpu_reset = &default_regs_reset;
	117	}
	118
003300de	119	cpu_vtimer_irq = &default_vtimer_irq;
f4672752 MZ	120	break;
	121	}
	122
	123	/* Reset core registers */
	124	memcpy(vcpu_gp_regs(vcpu), cpu_reset, sizeof(*cpu_reset));
	125
	126	/* Reset system registers */
	127	kvm_reset_sys_regs(vcpu);
	128
2aa36e98 SZ	129	/* Reset PMU */
	130	kvm_pmu_vcpu_reset(vcpu);
	131
003300de	132	/* Reset timer */
f120cd65	133	return kvm_timer_vcpu_reset(vcpu, cpu_vtimer_irq);
f4672752	134	}
67f69197 AT	135
	136	extern char __hyp_idmap_text_start[];
	137
c612505f	138	unsigned long kvm_hyp_reset_entry(void)
67f69197	139	{
c612505f JM	140	if (!__kvm_cpu_uses_extended_idmap()) {
	141	unsigned long offset;
	142
	143	/*
	144	* Find the address of __kvm_hyp_reset() in the trampoline page.
	145	* This is present in the running page tables, and the boot page
	146	* tables, so we call the code here to start the trampoline
	147	* dance in reverse.
	148	*/
	149	offset = (unsigned long)__kvm_hyp_reset
	150	- ((unsigned long)__hyp_idmap_text_start & PAGE_MASK);
	151
	152	return TRAMPOLINE_VA + offset;
	153	} else {
	154	/*
	155	* KVM is running with merged page tables, which don't have the
	156	* trampoline page mapped. We know the idmap is still mapped,
	157	* but can't be called into directly. Use
	158	* __extended_idmap_trampoline to do the call.
	159	*/
	160	return (unsigned long)kvm_ksym_ref(__extended_idmap_trampoline);
	161	}
67f69197	162	}