/*-
 * Copyright (c) 2016 Microsoft Corp.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice unmodified, this list of conditions, and the following
 *    disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <sys/param.h>
#include <sys/systimer.h>
#include <sys/systm.h>

#include <machine/cpufunc.h>
#include <machine/specialreg.h>
#include <machine/msi_machdep.h>

#include <dev/virtual/hyperv/hyperv_busdma.h>
#include <dev/virtual/hyperv/hyperv_machdep.h>
#include <dev/virtual/hyperv/hyperv_reg.h>
#include <dev/virtual/hyperv/hyperv_var.h>

struct hyperv_reftsc_ctx {
        struct hyperv_reftsc    *tsc_ref;
        struct hyperv_dma       tsc_ref_dma;
};

static void             hyperv_tsc_cputimer_construct(struct cputimer *,
                            sysclock_t);
static sysclock_t       hyperv_tsc_cputimer_count_mfence(void);
static sysclock_t       hyperv_tsc_cputimer_count_lfence(void);

static struct hyperv_reftsc_ctx hyperv_ref_tsc;
static hyperv_tc64_t    hyperv_tc64_saved;

static struct cputimer  hyperv_tsc_cputimer = {
        .next           = SLIST_ENTRY_INITIALIZER,
        .name           = "Hyper-V-TSC",
        .pri            = CPUTIMER_PRI_VMM_HI,
        .type           = CPUTIMER_VMM1,
        .count          = NULL, /* determined later */
        .fromhz         = cputimer_default_fromhz,
        .fromus         = cputimer_default_fromus,
        .construct      = hyperv_tsc_cputimer_construct,
        .destruct       = cputimer_default_destruct,
        .freq           = HYPERV_TIMER_FREQ
};

static struct cpucounter hyperv_tsc_cpucounter = {
        .freq           = HYPERV_TIMER_FREQ,
        .count          = NULL, /* determined later */
        .flags          = CPUCOUNTER_FLAG_MPSYNC,
        .prio           = CPUCOUNTER_PRIO_VMM_HI,
        .type           = CPUCOUNTER_VMM1
};

uint64_t
hypercall_md(volatile void *hc_addr, uint64_t in_val,
    uint64_t in_paddr, uint64_t out_paddr)
{
        uint64_t status;

        __asm__ __volatile__ ("mov %0, %%r8" : : "r" (out_paddr): "r8");
        __asm__ __volatile__ ("call *%3" : "=a" (status) :
            "c" (in_val), "d" (in_paddr), "m" (hc_addr));
        return (status);
}

int
hyperv_msi2vector(uint64_t msi_addr __unused, uint32_t msi_data)
{
        return (msi_data & MSI_X86_DATA_INTVEC);
}

#define HYPERV_TSC(fence)                                       \
static uint64_t                                                 \
hyperv_tsc_##fence(void)                                        \
{                                                               \
        struct hyperv_reftsc *tsc_ref = hyperv_ref_tsc.tsc_ref; \
        uint32_t seq;                                           \
                                                                \
        while ((seq = tsc_ref->tsc_seq) != 0) {                 \
                uint64_t disc, ret, tsc;                        \
                uint64_t scale;                                 \
                int64_t ofs;                                    \
                                                                \
                cpu_ccfence();                                  \
                scale = tsc_ref->tsc_scale;                     \
                ofs = tsc_ref->tsc_ofs;                         \
                                                                \
                cpu_##fence();                                  \
                tsc = rdtsc();                                  \
                                                                \
                /* ret = ((tsc * scale) >> 64) + ofs */         \
                __asm__ __volatile__ ("mulq %3" :               \
                    "=d" (ret), "=a" (disc) :                   \
                    "a" (tsc), "r" (scale));                    \
                ret += ofs;                                     \
                                                                \
                cpu_ccfence();                                  \
                if (tsc_ref->tsc_seq == seq)                    \
                        return (ret);                           \
                                                                \
                /* Sequence changed; re-sync. */                \
        }                                                       \
        /* Fallback to the generic rdmsr. */                    \
        return (rdmsr(MSR_HV_TIME_REF_COUNT));                  \
}                                                               \
struct __hack

HYPERV_TSC(lfence);
HYPERV_TSC(mfence);

static sysclock_t
hyperv_tsc_cputimer_count_lfence(void)
{
        uint64_t val;

        val = hyperv_tsc_lfence();
        return (val + hyperv_tsc_cputimer.base);
}

static sysclock_t
hyperv_tsc_cputimer_count_mfence(void)
{
        uint64_t val;

        val = hyperv_tsc_mfence();
        return (val + hyperv_tsc_cputimer.base);
}

static void
hyperv_tsc_cputimer_construct(struct cputimer *timer, sysclock_t oldclock)
{
        timer->base = 0;
        timer->base = oldclock - timer->count();
}

void
hyperv_md_init(void)
{
        hyperv_tc64_t tc64 = NULL;
        uint64_t val, orig;

        if ((hyperv_features &
             (CPUID_HV_MSR_TIME_REFCNT | CPUID_HV_MSR_REFERENCE_TSC)) !=
            (CPUID_HV_MSR_TIME_REFCNT | CPUID_HV_MSR_REFERENCE_TSC) ||
            (cpu_feature & CPUID_SSE2) == 0)    /* SSE2 for mfence/lfence */
                return;

        switch (cpu_vendor_id) {
        case CPU_VENDOR_AMD:
                hyperv_tsc_cputimer.count = hyperv_tsc_cputimer_count_mfence;
                tc64 = hyperv_tsc_mfence;
                break;

        case CPU_VENDOR_INTEL:
                hyperv_tsc_cputimer.count = hyperv_tsc_cputimer_count_lfence;
                tc64 = hyperv_tsc_lfence;
                break;

        default:
                /* Unsupport CPU vendors. */
                return;
        }
        KASSERT(tc64 != NULL, ("tc64 is not set"));
        hyperv_tsc_cpucounter.count = tc64;

        hyperv_ref_tsc.tsc_ref = hyperv_dmamem_alloc(NULL, PAGE_SIZE, 0,
            sizeof(struct hyperv_reftsc), &hyperv_ref_tsc.tsc_ref_dma,
            BUS_DMA_WAITOK | BUS_DMA_ZERO);
        if (hyperv_ref_tsc.tsc_ref == NULL) {
                kprintf("hyperv: reftsc page allocation failed\n");
                return;
        }

        orig = rdmsr(MSR_HV_REFERENCE_TSC);
        val = MSR_HV_REFTSC_ENABLE | (orig & MSR_HV_REFTSC_RSVD_MASK) |
            ((hyperv_ref_tsc.tsc_ref_dma.hv_paddr >> PAGE_SHIFT) <<
             MSR_HV_REFTSC_PGSHIFT);
        wrmsr(MSR_HV_REFERENCE_TSC, val);

        /* Register Hyper-V reference TSC cputimers. */
        cputimer_register(&hyperv_tsc_cputimer);
        cputimer_select(&hyperv_tsc_cputimer, 0);
        cpucounter_register(&hyperv_tsc_cpucounter);
        hyperv_tc64_saved = hyperv_tc64;
        hyperv_tc64 = tc64;
}

void
hyperv_md_uninit(void)
{
        if (hyperv_ref_tsc.tsc_ref != NULL) {
                uint64_t val;

                /* Deregister Hyper-V reference TSC systimer. */
                cputimer_deregister(&hyperv_tsc_cputimer);
                /* Revert tc64 change. */
                hyperv_tc64 = hyperv_tc64_saved;

                val = rdmsr(MSR_HV_REFERENCE_TSC);
                wrmsr(MSR_HV_REFERENCE_TSC, val & MSR_HV_REFTSC_RSVD_MASK);

                hyperv_dmamem_free(&hyperv_ref_tsc.tsc_ref_dma,
                    hyperv_ref_tsc.tsc_ref);
                hyperv_ref_tsc.tsc_ref = NULL;
        }
}