// SPDX-License-Identifier: GPL-2.0

/*
 * Low level utility routines for interacting with Hyper-V.
 *
 * Copyright (C) 2021, Microsoft, Inc.
 *
 * Author : Michael Kelley <mikelley@microsoft.com>
 */

#include <linux/types.h>
#include <linux/export.h>
#include <linux/mm.h>
#include <linux/arm-smccc.h>
#include <linux/module.h>
#include <asm-generic/bug.h>
#include <hyperv/hvhdk.h>
#include <asm/mshyperv.h>

/*
 * hv_do_hypercall- Invoke the specified hypercall
 */
u64 hv_do_hypercall(u64 control, void *input, void *output)
{
        struct arm_smccc_res    res;
        u64                     input_address;
        u64                     output_address;

        input_address = input ? virt_to_phys(input) : 0;
        output_address = output ? virt_to_phys(output) : 0;

        arm_smccc_1_1_hvc(HV_FUNC_ID, control,
                          input_address, output_address, &res);
        return res.a0;
}
EXPORT_SYMBOL_GPL(hv_do_hypercall);

/*
 * hv_do_fast_hypercall8 -- Invoke the specified hypercall
 * with arguments in registers instead of physical memory.
 * Avoids the overhead of virt_to_phys for simple hypercalls.
 */

u64 hv_do_fast_hypercall8(u16 code, u64 input)
{
        struct arm_smccc_res    res;
        u64                     control;

        control = (u64)code | HV_HYPERCALL_FAST_BIT;

        arm_smccc_1_1_hvc(HV_FUNC_ID, control, input, &res);
        return res.a0;
}
EXPORT_SYMBOL_GPL(hv_do_fast_hypercall8);

/*
 * hv_do_fast_hypercall16 -- Invoke the specified hypercall
 * with arguments in registers instead of physical memory.
 * Avoids the overhead of virt_to_phys for simple hypercalls.
 */
u64 hv_do_fast_hypercall16(u16 code, u64 input1, u64 input2)
{
        struct arm_smccc_res    res;
        u64                     control;

        control = (u64)code | HV_HYPERCALL_FAST_BIT;

        arm_smccc_1_1_hvc(HV_FUNC_ID, control, input1, input2, &res);
        return res.a0;
}
EXPORT_SYMBOL_GPL(hv_do_fast_hypercall16);

/*
 * Set a single VP register to a 64-bit value.
 */
void hv_set_vpreg(u32 msr, u64 value)
{
        struct arm_smccc_res res;

        arm_smccc_1_1_hvc(HV_FUNC_ID,
                HVCALL_SET_VP_REGISTERS | HV_HYPERCALL_FAST_BIT |
                        HV_HYPERCALL_REP_COMP_1,
                HV_PARTITION_ID_SELF,
                HV_VP_INDEX_SELF,
                msr,
                0,
                value,
                0,
                &res);

        /*
         * Something is fundamentally broken in the hypervisor if
         * setting a VP register fails. There's really no way to
         * continue as a guest VM, so panic.
         */
        BUG_ON(!hv_result_success(res.a0));
}
EXPORT_SYMBOL_GPL(hv_set_vpreg);

/*
 * Get the value of a single VP register.  One version
 * returns just 64 bits and another returns the full 128 bits.
 * The two versions are separate to avoid complicating the
 * calling sequence for the more frequently used 64 bit version.
 */

void hv_get_vpreg_128(u32 msr, struct hv_get_vp_registers_output *result)
{
        struct arm_smccc_1_2_regs args;
        struct arm_smccc_1_2_regs res;

        args.a0 = HV_FUNC_ID;
        args.a1 = HVCALL_GET_VP_REGISTERS | HV_HYPERCALL_FAST_BIT |
                        HV_HYPERCALL_REP_COMP_1;
        args.a2 = HV_PARTITION_ID_SELF;
        args.a3 = HV_VP_INDEX_SELF;
        args.a4 = msr;

        /*
         * Use the SMCCC 1.2 interface because the results are in registers
         * beyond X0-X3.
         */
        arm_smccc_1_2_hvc(&args, &res);

        /*
         * Something is fundamentally broken in the hypervisor if
         * getting a VP register fails. There's really no way to
         * continue as a guest VM, so panic.
         */
        BUG_ON(!hv_result_success(res.a0));

        result->as64.low = res.a6;
        result->as64.high = res.a7;
}
EXPORT_SYMBOL_GPL(hv_get_vpreg_128);

u64 hv_get_vpreg(u32 msr)
{
        struct hv_get_vp_registers_output output;

        hv_get_vpreg_128(msr, &output);

        return output.as64.low;
}
EXPORT_SYMBOL_GPL(hv_get_vpreg);

/*
 * hyperv_report_panic - report a panic to Hyper-V.  This function uses
 * the older version of the Hyper-V interface that admittedly doesn't
 * pass enough information to be useful beyond just recording the
 * occurrence of a panic. The parallel hv_kmsg_dump() uses the
 * new interface that allows reporting 4 Kbytes of data, which is much
 * more useful. Hyper-V on ARM64 always supports the newer interface, but
 * we retain support for the older version because the sysadmin is allowed
 * to disable the newer version via sysctl in case of information security
 * concerns about the more verbose version.
 */
void hyperv_report_panic(struct pt_regs *regs, long err, bool in_die)
{
        static bool     panic_reported;
        u64             guest_id;

        /* Don't report a panic to Hyper-V if we're not going to panic */
        if (in_die && !panic_on_oops)
                return;

        /*
         * We prefer to report panic on 'die' chain as we have proper
         * registers to report, but if we miss it (e.g. on BUG()) we need
         * to report it on 'panic'.
         *
         * Calling code in the 'die' and 'panic' paths ensures that only
         * one CPU is running this code, so no atomicity is needed.
         */
        if (panic_reported)
                return;
        panic_reported = true;

        guest_id = hv_get_vpreg(HV_REGISTER_GUEST_OS_ID);

        /*
         * Hyper-V provides the ability to store only 5 values.
         * Pick the passed in error value, the guest_id, the PC,
         * and the SP.
         */
        hv_set_vpreg(HV_REGISTER_GUEST_CRASH_P0, err);
        hv_set_vpreg(HV_REGISTER_GUEST_CRASH_P1, guest_id);
        hv_set_vpreg(HV_REGISTER_GUEST_CRASH_P2, regs->pc);
        hv_set_vpreg(HV_REGISTER_GUEST_CRASH_P3, regs->sp);
        hv_set_vpreg(HV_REGISTER_GUEST_CRASH_P4, 0);

        /*
         * Let Hyper-V know there is crash data available
         */
        hv_set_vpreg(HV_REGISTER_GUEST_CRASH_CTL, HV_CRASH_CTL_CRASH_NOTIFY);
}
EXPORT_SYMBOL_GPL(hyperv_report_panic);