/*      $OpenBSD: clock.c,v 1.14 2024/01/27 12:05:40 kettenis Exp $     */

/*
 * Copyright (c) 2020 Mark Kettenis <kettenis@openbsd.org>
 * Copyright (c) 2003 Dale Rahn <drahn@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/param.h>
#include <sys/kernel.h>
#include <sys/systm.h>
#include <sys/clockintr.h>
#include <sys/evcount.h>
#include <sys/stdint.h>
#include <sys/timetc.h>

#include <machine/cpufunc.h>
#include <machine/sbi.h>

#include <riscv64/dev/riscv_cpu_intc.h>

extern uint64_t tb_freq;        /* machdep.c */
uint64_t timer_nsec_max;
uint64_t timer_nsec_cycle_ratio;

struct evcount clock_count;

void timer_startclock(void);
void timer_rearm(void *, uint64_t);
void timer_trigger(void *);

const struct intrclock timer_intrclock = {
        .ic_rearm = timer_rearm,
        .ic_trigger = timer_trigger
};

u_int   tb_get_timecount(struct timecounter *);

static struct timecounter tb_timecounter = {
        .tc_get_timecount = tb_get_timecount,
        .tc_counter_mask = 0xffffffff,
        .tc_frequency = 0,
        .tc_name = "tb",
        .tc_quality = 0,
        .tc_priv = NULL,
        .tc_user = TC_TB,
};

void    (*cpu_startclock_fcn)(void) = timer_startclock;
int     clock_intr(void *);

void
timer_rearm(void *unused, uint64_t nsecs)
{
        uint32_t cycles;

        if (nsecs > timer_nsec_max)
                nsecs = timer_nsec_max;
        cycles = (nsecs * timer_nsec_cycle_ratio) >> 32;
        sbi_set_timer(rdtime() + cycles);
}

void
timer_trigger(void *unused)
{
        sbi_set_timer(0);
}

u_int
tb_get_timecount(struct timecounter *tc)
{
        return rdtime();
}

void
cpu_initclocks(void)
{
        tb_timecounter.tc_frequency = tb_freq;
        tc_init(&tb_timecounter);

        stathz = hz;
        profhz = stathz * 10;
        statclock_is_randomized = 1;

        if (cpu_startclock_fcn == timer_startclock) {
                timer_nsec_cycle_ratio = tb_freq * (1ULL << 32) / 1000000000;
                timer_nsec_max = UINT64_MAX / timer_nsec_cycle_ratio;

                riscv_intc_intr_establish(IRQ_TIMER_SUPERVISOR, 0,
                    clock_intr, NULL, NULL);

                evcount_attach(&clock_count, "clock", NULL);
                evcount_percpu(&clock_count);
        }
}

void
timer_startclock(void)
{
        clockintr_cpu_init(&timer_intrclock);
        clockintr_trigger();
        csr_set(sie, SIE_STIE);
}

void
cpu_startclock(void)
{
        cpu_startclock_fcn();
}

int
clock_intr(void *frame)
{
        struct cpu_info *ci = curcpu();
        int s;

        sbi_set_timer(UINT64_MAX);      /* clear timer interrupt */

        /*
         * If the clock interrupt is masked, defer all clock interrupt
         * work until the clock interrupt is unmasked from splx(9).
         */
        if (ci->ci_cpl >= IPL_CLOCK) {
                ci->ci_timer_deferred = 1;
                return 0;
        }
        ci->ci_timer_deferred = 0;

        s = splclock();
        intr_enable();
        clockintr_dispatch(frame);
        intr_disable();
        splx(s);

        evcount_inc(&clock_count);

        return 0;
}

void
setstatclockrate(int newhz)
{
}

void
delay(u_int us)
{
        uint64_t tb;

        tb = rdtime();
        tb += (us * tb_freq + 999999) / 1000000;
        while (tb > rdtime())
                continue;
}