/*
 * Copyright 2018 Google LLC
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "hf/arch/timer.h"

#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>

#include "hf/arch/cpu.h"

#include "hf/addr.h"

#include "msr.h"

#define CNTV_CTL_EL0_ENABLE (1u << 0)
#define CNTV_CTL_EL0_IMASK (1u << 1)
#define CNTV_CTL_EL0_ISTATUS (1u << 2)

#define NANOS_PER_UNIT 1000000000

/**
 * Sets the bit to mask virtual timer interrupts.
 */
void arch_timer_mask(struct arch_regs *regs)
{
	regs->lazy.cntv_ctl_el0 |= CNTV_CTL_EL0_IMASK;
}

/**
 * Checks whether the virtual timer is enabled and its interrupt not masked.
 */
bool arch_timer_enabled(struct arch_regs *regs)
{
	uintreg_t cntv_ctl_el0 = regs->lazy.cntv_ctl_el0;

	return (cntv_ctl_el0 & CNTV_CTL_EL0_ENABLE) &&
	       !(cntv_ctl_el0 & CNTV_CTL_EL0_IMASK);
}

/**
 * Converts a number of timer ticks to the equivalent number of nanoseconds.
 */
static uint64_t ticks_to_ns(uint64_t ticks)
{
	return (ticks * NANOS_PER_UNIT) / read_msr(cntfrq_el0);
}

/**
 * Returns the number of ticks remaining on the virtual timer as stored in
 * the given `arch_regs`, or 0 if it has already expired. This is undefined if
 * the timer is not enabled.
 */
uint64_t arch_timer_remaining_ticks(struct arch_regs *regs)
{
	/*
	 * Calculate the value from the saved CompareValue (cntv_cval_el0) and
	 * the virtual count value.
	 */
	uintreg_t cntv_cval_el0 = regs->lazy.cntv_cval_el0;
	uintreg_t cntvct_el0 = read_msr(cntvct_el0);

	if (cntv_cval_el0 >= cntvct_el0) {
		return cntv_cval_el0 - cntvct_el0;
	}

	return 0;
}

/**
 * Returns the number of nanoseconds remaining on the virtual timer as stored in
 * the given `arch_regs`, or 0 if it has already expired. This is undefined if
 * the timer is not enabled.
 */
uint64_t arch_timer_remaining_ns(struct arch_regs *regs)
{
	return ticks_to_ns(arch_timer_remaining_ticks(regs));
}

/**
 * Returns whether the timer is ready to fire: i.e. it is enabled, not masked,
 * and the condition is met.
 */
bool arch_timer_pending(struct arch_regs *regs)
{
	if (!arch_timer_enabled(regs)) {
		return false;
	}

	if (regs->lazy.cntv_ctl_el0 & CNTV_CTL_EL0_ISTATUS) {
		return true;
	}

	if (arch_timer_remaining_ticks(regs) == 0) {
		/*
		 * This can happen even if the (stored) ISTATUS bit is not set,
		 * because time has passed between when the registers were
		 * stored and now.
		 */
		return true;
	}

	return false;
}

/**
 * Checks whether the virtual timer is enabled and its interrupt not masked, for
 * the currently active vCPU.
 */
bool arch_timer_enabled_current(void)
{
	uintreg_t cntv_ctl_el0 = read_msr(cntv_ctl_el0);

	return (cntv_ctl_el0 & CNTV_CTL_EL0_ENABLE) &&
	       !(cntv_ctl_el0 & CNTV_CTL_EL0_IMASK);
}

/**
 * Returns the number of ticks remaining on the virtual timer of the currently
 * active vCPU, or 0 if it has already expired. This is undefined if the timer
 * is not enabled.
 */
uint64_t arch_timer_remaining_ticks_current(void)
{
	uintreg_t cntv_cval_el0 = read_msr(cntv_cval_el0);
	uintreg_t cntvct_el0 = read_msr(cntvct_el0);

	if (cntv_cval_el0 >= cntvct_el0) {
		return cntv_cval_el0 - cntvct_el0;
	}

	return 0;
}

/**
 * Returns the number of nanoseconds remaining on the virtual timer of the
 * currently active vCPU, or 0 if it has already expired. This is undefined if
 * the timer is not enabled.
 */
uint64_t arch_timer_remaining_ns_current(void)
{
	return ticks_to_ns(arch_timer_remaining_ticks_current());
}