1 // SPDX-License-Identifier: GPL-2.0 2 // Copyright (C) 2019 Arm Ltd. 3 4 #include <linux/arm-smccc.h> 5 #include <linux/kvm_host.h> 6 7 #include <asm/kvm_emulate.h> 8 9 #include <kvm/arm_hypercalls.h> 10 #include <kvm/arm_psci.h> 11 12 static void kvm_ptp_get_time(struct kvm_vcpu *vcpu, u64 *val) 13 { 14 struct system_time_snapshot systime_snapshot; 15 u64 cycles = ~0UL; 16 u32 feature; 17 18 /* 19 * system time and counter value must captured at the same 20 * time to keep consistency and precision. 21 */ 22 ktime_get_snapshot(&systime_snapshot); 23 24 /* 25 * This is only valid if the current clocksource is the 26 * architected counter, as this is the only one the guest 27 * can see. 28 */ 29 if (systime_snapshot.cs_id != CSID_ARM_ARCH_COUNTER) 30 return; 31 32 /* 33 * The guest selects one of the two reference counters 34 * (virtual or physical) with the first argument of the SMCCC 35 * call. In case the identifier is not supported, error out. 36 */ 37 feature = smccc_get_arg1(vcpu); 38 switch (feature) { 39 case KVM_PTP_VIRT_COUNTER: 40 cycles = systime_snapshot.cycles - vcpu_read_sys_reg(vcpu, CNTVOFF_EL2); 41 break; 42 case KVM_PTP_PHYS_COUNTER: 43 cycles = systime_snapshot.cycles; 44 break; 45 default: 46 return; 47 } 48 49 /* 50 * This relies on the top bit of val[0] never being set for 51 * valid values of system time, because that is *really* far 52 * in the future (about 292 years from 1970, and at that stage 53 * nobody will give a damn about it). 54 */ 55 val[0] = upper_32_bits(systime_snapshot.real); 56 val[1] = lower_32_bits(systime_snapshot.real); 57 val[2] = upper_32_bits(cycles); 58 val[3] = lower_32_bits(cycles); 59 } 60 61 int kvm_hvc_call_handler(struct kvm_vcpu *vcpu) 62 { 63 u32 func_id = smccc_get_function(vcpu); 64 u64 val[4] = {SMCCC_RET_NOT_SUPPORTED}; 65 u32 feature; 66 gpa_t gpa; 67 68 switch (func_id) { 69 case ARM_SMCCC_VERSION_FUNC_ID: 70 val[0] = ARM_SMCCC_VERSION_1_1; 71 break; 72 case ARM_SMCCC_ARCH_FEATURES_FUNC_ID: 73 feature = smccc_get_arg1(vcpu); 74 switch (feature) { 75 case ARM_SMCCC_ARCH_WORKAROUND_1: 76 switch (arm64_get_spectre_v2_state()) { 77 case SPECTRE_VULNERABLE: 78 break; 79 case SPECTRE_MITIGATED: 80 val[0] = SMCCC_RET_SUCCESS; 81 break; 82 case SPECTRE_UNAFFECTED: 83 val[0] = SMCCC_ARCH_WORKAROUND_RET_UNAFFECTED; 84 break; 85 } 86 break; 87 case ARM_SMCCC_ARCH_WORKAROUND_2: 88 switch (arm64_get_spectre_v4_state()) { 89 case SPECTRE_VULNERABLE: 90 break; 91 case SPECTRE_MITIGATED: 92 /* 93 * SSBS everywhere: Indicate no firmware 94 * support, as the SSBS support will be 95 * indicated to the guest and the default is 96 * safe. 97 * 98 * Otherwise, expose a permanent mitigation 99 * to the guest, and hide SSBS so that the 100 * guest stays protected. 101 */ 102 if (cpus_have_final_cap(ARM64_SSBS)) 103 break; 104 fallthrough; 105 case SPECTRE_UNAFFECTED: 106 val[0] = SMCCC_RET_NOT_REQUIRED; 107 break; 108 } 109 break; 110 case ARM_SMCCC_HV_PV_TIME_FEATURES: 111 val[0] = SMCCC_RET_SUCCESS; 112 break; 113 } 114 break; 115 case ARM_SMCCC_HV_PV_TIME_FEATURES: 116 val[0] = kvm_hypercall_pv_features(vcpu); 117 break; 118 case ARM_SMCCC_HV_PV_TIME_ST: 119 gpa = kvm_init_stolen_time(vcpu); 120 if (gpa != GPA_INVALID) 121 val[0] = gpa; 122 break; 123 case ARM_SMCCC_VENDOR_HYP_CALL_UID_FUNC_ID: 124 val[0] = ARM_SMCCC_VENDOR_HYP_UID_KVM_REG_0; 125 val[1] = ARM_SMCCC_VENDOR_HYP_UID_KVM_REG_1; 126 val[2] = ARM_SMCCC_VENDOR_HYP_UID_KVM_REG_2; 127 val[3] = ARM_SMCCC_VENDOR_HYP_UID_KVM_REG_3; 128 break; 129 case ARM_SMCCC_VENDOR_HYP_KVM_FEATURES_FUNC_ID: 130 val[0] = BIT(ARM_SMCCC_KVM_FUNC_FEATURES); 131 val[0] |= BIT(ARM_SMCCC_KVM_FUNC_PTP); 132 break; 133 case ARM_SMCCC_VENDOR_HYP_KVM_PTP_FUNC_ID: 134 kvm_ptp_get_time(vcpu, val); 135 break; 136 case ARM_SMCCC_TRNG_VERSION: 137 case ARM_SMCCC_TRNG_FEATURES: 138 case ARM_SMCCC_TRNG_GET_UUID: 139 case ARM_SMCCC_TRNG_RND32: 140 case ARM_SMCCC_TRNG_RND64: 141 return kvm_trng_call(vcpu); 142 default: 143 return kvm_psci_call(vcpu); 144 } 145 146 smccc_set_retval(vcpu, val[0], val[1], val[2], val[3]); 147 return 1; 148 } 149