/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2020 Joyent, Inc.
 */

#include <sys/pit.h>
#include <sys/tsc.h>
#include <sys/archsystm.h>
#include <sys/prom_debug.h>

extern uint64_t freq_tsc_pit(uint32_t *);

/*
 * Traditionally, the PIT has been used to calibrate both the TSC and the
 * APIC. As we transition to supporting alternate TSC calibration sources
 * and using the TSC to calibrate the APIC, we may still want (for diagnostic
 * purposes) to know what would have happened if we had used the PIT
 * instead. As a result, if we are using an alternate calibration source
 * we will still measure the frequency using the PIT and save the result in
 * pit_tsc_hz for use by the APIC (to similarly save the timings using the
 * PIT).
 *
 * A wrinkle in this is that some systems no longer have a functioning PIT.
 * In these instances, we simply have no way to provide the 'what if the PIT
 * was used' values. When we try to use the PIT, we first perform a small
 * test to see if it appears to be working (i.e. will it count down). If
 * it does not, we set pit_is_broken to let the APIC calibration code that
 * it shouldn't attempt to get PIC timings.
 *
 * While the systems without a functioning PIT don't seem to experience
 * any undesirable behavior when attempting to use the non-functional/not
 * present PIT (i.e. they don't lock up or otherwise act funny -- the counter
 * values that are read just never change), we still allow pit_is_broken to be
 * set in /etc/system to inform the system to avoid attempting to use the PIT
 * at all.
 *
 * In the future, we could remove these transitional bits once we have more
 * history built up using the alternative calibration sources.
 */
uint64_t pit_tsc_hz;
int pit_is_broken;

/*
 * On all of the systems seen so far without functioning PITs, it appears
 * that they always just return the values written to the PITCTR0_PORT (or
 * more specifically when they've been programmed to start counting down from
 * 0xFFFF, they always return 0xFFFF no matter how little/much time has
 * elapsed).
 *
 * Since we have no better way to know if the PIT is broken, we use this
 * behavior to sanity check the PIT. We program the PIT to count down from
 * 0xFFFF and wait an amount of time and re-read the result. While we cannot
 * rely on the TSC frequency being known at this point, we do know that
 * we are almost certainly never going to see a TSC frequency below 1GHz
 * on any supported system.
 *
 * As such, we (somewhat) arbitrarily pick 400,000 TSC ticks as the amount
 * of time we wait before re-reading the PIT counter. On a 1GHz machine,
 * 1 PIT tick would correspond to approximately 838 TSC ticks, therefore
 * waiting 400,000 TSC ticks should correspond to approx 477 PIT ticks.
 * On a (currently) theoritical 100GHz machine, 400,000 TSC ticks would still
 * correspond to approx 4-5 PIT ticks, so this seems a reasonably safe value.
 */
#define TSC_MIN_TICKS   400000ULL

static boolean_t
pit_sanity_check(void)
{
        uint64_t tsc_now, tsc_end;
        ulong_t flags;
        uint16_t pit_count;

        flags = clear_int_flag();

        tsc_now = tsc_read();
        tsc_end = tsc_now + TSC_MIN_TICKS;

        /*
         * Put the PIT in mode 0, "Interrupt On Terminal Count":
         */
        outb(PITCTL_PORT, PIT_C0 | PIT_LOADMODE | PIT_ENDSIGMODE);

        outb(PITCTR0_PORT, 0xFF);
        outb(PITCTR0_PORT, 0xFF);

        while (tsc_now < tsc_end)
                tsc_now = tsc_read();

        /*
         * Latch the counter value and status for counter 0 with the
         * readback command.
         */
        outb(PITCTL_PORT, PIT_READBACK | PIT_READBACKC0);

        /*
         * In readback mode, reading from the counter port produces a
         * status byte, the low counter byte, and finally the high counter byte.
         *
         * We ignore the status byte -- as noted above, we've delayed for an
         * amount of time that should allow the counter to count off at least
         * 4-5 ticks (and more realistically at least a hundred), so we just
         * want to see if the count has changed at all.
         */
        (void) inb(PITCTR0_PORT);
        pit_count = inb(PITCTR0_PORT);
        pit_count |= inb(PITCTR0_PORT) << 8;

        restore_int_flag(flags);

        if (pit_count == 0xFFFF) {
                pit_is_broken = 1;
                return (B_FALSE);
        }

        return (B_TRUE);
}

static boolean_t
tsc_calibrate_pit(uint64_t *freqp)
{
        uint64_t processor_clks;
        ulong_t flags;
        uint32_t pit_counter;

        if (pit_is_broken)
                return (B_FALSE);

        if (!pit_sanity_check())
                return (B_FALSE);

        /*
         * freq_tsc_pit() is a hand-rolled assembly function that returns
         * the number of TSC ticks and sets pit_counter to the number
         * of corresponding PIT ticks in the same time period.
         */
        flags = clear_int_flag();
        processor_clks = freq_tsc_pit(&pit_counter);
        restore_int_flag(flags);

        if (pit_counter == 0 || processor_clks == 0 ||
            processor_clks > (((uint64_t)-1) / PIT_HZ)) {
                return (B_FALSE);
        }

        *freqp = pit_tsc_hz = ((uint64_t)PIT_HZ * processor_clks) / pit_counter;
        return (B_TRUE);
}

/*
 * Typically a calibration source that allows the hardware or the hypervisor to
 * simply declare a specific frequency, rather than requiring calibration at
 * runtime, is going to provide better results than the using PIT.
 */
static tsc_calibrate_t tsc_calibration_pit = {
        .tscc_source = "PIT",
        .tscc_preference = 10,
        .tscc_calibrate = tsc_calibrate_pit,
};
TSC_CALIBRATION_SOURCE(tsc_calibration_pit);