/*
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2026 Abdelkader Boudih <dragonflybsd@seuros.com>
 *
 * Thermal fan governor -- linear fan curve for CPU temperature when
 * the driver has overridden SMC fan control via PROCHOT override.
 */

#include "smc.h"

#include <sys/kthread.h>

#define THERMAL_MIN_INTERVAL    1       /* minimum poll interval (seconds) */
#define THERMAL_MAX_INTERVAL    60      /* maximum poll interval (seconds) */
#define THERMAL_MIN_TEMP        10000   /* 10C -- reject implausible readings */
#define THERMAL_RAMP_DOWN_MAX   200     /* max RPM decrease per tick */
#define THERMAL_WRITE_DELTA     100     /* min RPM change to bother writing */

/*
 * Set all fans to maximum RPM.  Fail-hot / emergency path.
 */
int
apple_smc_thermal_fans_to_max(device_t dev)
{
        struct apple_smc_softc *sc = device_get_softc(dev);
        int i, max_rpm, ok = 0;

        /* Reassert manual mode. */
        if (apple_smc_fan_reassert_manual(dev) != 0)
                device_printf(dev,
                    "thermal: WARNING: manual mode reassert failed\n");

        /* Write max to every fan. */
        for (i = 0; i < sc->sc_nfan; i++) {
                max_rpm = apple_smc_fan_getvalue(dev, ASMC_KEY_FANMAXSPEED, i);
                if (max_rpm <= 0)
                        continue;
                if (apple_smc_fan_setvalue(dev, ASMC_KEY_FANTARGETSPEED,
                    i, max_rpm) == 0)
                        ok++;
        }
        return (ok);
}

/*
 * Read hottest CPU core temperature in millidegrees.  Returns -1 on failure.
 */
static int
apple_smc_thermal_read_cpu_temp(device_t dev)
{
        struct apple_smc_softc *sc = device_get_softc(dev);
        int val, best, i, error;

        best = -1;

        /* TC0c is CPU package composite -- try first. */
        error = apple_smc_sensor_read(dev, "TC0c", &val);
        if (error == 0 && val > THERMAL_MIN_TEMP && val < 130000)
                best = val;

        /* Scan TC* sensors for hottest core. */
        for (i = 0; i < sc->sc_temp_count; i++) {
                if (sc->sc_temp_sensors[i][0] != 'T' ||
                    sc->sc_temp_sensors[i][1] != 'C')
                        continue;
                error = apple_smc_sensor_read(dev,
                    sc->sc_temp_sensors[i], &val);
                if (error == 0 && val > best && val > THERMAL_MIN_TEMP &&
                    val < 130000)
                        best = val;
        }
        return (best);
}

/*
 * Linear fan curve: min_rpm at temp_low, max_rpm at temp_high.
 */
static int
apple_smc_thermal_compute_rpm(int temp_mc, int temp_low_mc, int temp_high_mc,
    int min_rpm, int max_rpm)
{
        int64_t range, delta, result;

        if (temp_high_mc <= temp_low_mc)
                return (max_rpm);       /* misconfigured -- fail hot */
        if (temp_mc <= temp_low_mc)
                return (min_rpm);
        if (temp_mc >= temp_high_mc)
                return (max_rpm);

        range = (int64_t)(temp_high_mc - temp_low_mc);
        delta = (int64_t)(temp_mc - temp_low_mc);
        result = (int64_t)min_rpm +
            ((int64_t)(max_rpm - min_rpm) * delta) / range;

        /* Clamp. */
        if (result < min_rpm)
                return (min_rpm);
        if (result > max_rpm)
                return (max_rpm);
        return ((int)result);
}

/*
 * Thermal governor thread.
 */
static void
apple_smc_thermal_thread(void *arg)
{
        device_t dev = (device_t)arg;
        struct apple_smc_softc *sc = device_get_softc(dev);
        int temp_mc, target_rpm, cur_target, i;
        int min_rpm, max_rpm;
        int last_temp = 0;
        int sensor_fail_logged = 0;
        int interval;
        /* Snapshot tunables. */
        int s_temp_low, s_temp_high, s_hysteresis, s_emergency;

        while (!sc->sc_thermal_stop) {
                interval = sc->sc_thermal_interval;
                if (interval < THERMAL_MIN_INTERVAL)
                        interval = THERMAL_MIN_INTERVAL;
                if (interval > THERMAL_MAX_INTERVAL)
                        interval = THERMAL_MAX_INTERVAL;

                if (!sc->sc_thermal_enabled) {
                        tsleep(&sc->sc_thermal_enabled, 0, "smcthw",
                            hz * interval);
                        continue;
                }

                /* Snapshot. */
                s_temp_low = sc->sc_thermal_temp_low;
                s_temp_high = sc->sc_thermal_temp_high;
                s_hysteresis = sc->sc_thermal_hysteresis;
                s_emergency = sc->sc_thermal_emergency;

                temp_mc = apple_smc_thermal_read_cpu_temp(dev);

                if (temp_mc < 0) {
                        /* Fail hot. */
                        apple_smc_thermal_fans_to_max(dev);
                        if (!sensor_fail_logged) {
                                device_printf(dev,
                                    "thermal: sensor read failed, "
                                    "fans to max\n");
                                sensor_fail_logged = 1;
                        }
                        tsleep(&sc->sc_thermal_stop, 0, "smcthf",
                            hz * interval);
                        continue;
                }
                sensor_fail_logged = 0;

                /* Emergency threshold. */
                if (temp_mc >= s_emergency) {
                        if (last_temp < s_emergency)
                                device_printf(dev,
                                    "thermal: EMERGENCY %d.%03dC, "
                                    "fans to max\n",
                                    temp_mc / 1000, temp_mc % 1000);
                        apple_smc_thermal_fans_to_max(dev);
                        last_temp = temp_mc;
                        tsleep(&sc->sc_thermal_stop, 0, "smcthe",
                            hz * interval);
                        continue;
                }

                /* Reassert manual mode; SMC reclaims auto periodically. */
                apple_smc_fan_reassert_manual(dev);

                for (i = 0; i < sc->sc_nfan; i++) {
                        /* Only govern fans we've overridden. */
                        if (!(sc->sc_fan_manual_mask & (1 << i)))
                                continue;

                        min_rpm = apple_smc_fan_getvalue(dev,
                            ASMC_KEY_FANMINSPEED, i);
                        max_rpm = apple_smc_fan_getvalue(dev,
                            ASMC_KEY_FANMAXSPEED, i);
                        if (min_rpm <= 0 || max_rpm <= 0 || max_rpm < min_rpm)
                                continue;

                        target_rpm = apple_smc_thermal_compute_rpm(
                            temp_mc, s_temp_low, s_temp_high,
                            min_rpm, max_rpm);

                        cur_target = apple_smc_fan_getvalue(dev,
                            ASMC_KEY_FANTARGETSPEED, i);

                        /* Hysteresis + ramp-down limit. */
                        if (cur_target > 0) {
                                int delta = target_rpm - cur_target;

                                /* Skip trivial. */
                                if (abs(delta) < THERMAL_WRITE_DELTA &&
                                    abs(temp_mc - last_temp) < s_hysteresis)
                                        continue;

                                /* Slow ramp-down. */
                                if (delta < -THERMAL_RAMP_DOWN_MAX)
                                        target_rpm =
                                            cur_target - THERMAL_RAMP_DOWN_MAX;
                        }

                        apple_smc_fan_setvalue(dev,
                            ASMC_KEY_FANTARGETSPEED, i, target_rpm);
                }

                last_temp = temp_mc;
                tsleep(&sc->sc_thermal_stop, 0, "smcth",
                    hz * interval);
        }

        sc->sc_thermal_running = 0;
        wakeup(&sc->sc_thermal_running);
}

int
apple_smc_thermal_start(device_t dev)
{
        struct apple_smc_softc *sc = device_get_softc(dev);
        int error;

        sc->sc_thermal_stop = 0;
        sc->sc_thermal_running = 0;

        error = kthread_create(apple_smc_thermal_thread, dev,
            &sc->sc_thermal_td, "apple_smc_thermal");
        if (error == 0)
                sc->sc_thermal_running = 1;
        return (error);
}

void
apple_smc_thermal_stop(device_t dev)
{
        struct apple_smc_softc *sc = device_get_softc(dev);

        if (!sc->sc_thermal_running)
                return;

        sc->sc_thermal_stop = 1;
        wakeup(&sc->sc_thermal_enabled);
        wakeup(&sc->sc_thermal_stop);

        /* Wait for thread to exit. */
        while (sc->sc_thermal_running)
                tsleep(&sc->sc_thermal_running, 0, "smcthx", hz);

        sc->sc_thermal_td = NULL;
}

/* Sysctl handler for thermal.enabled. */
int
apple_smc_thermal_enabled_sysctl(SYSCTL_HANDLER_ARGS)
{
        device_t dev = (device_t)arg1;
        struct apple_smc_softc *sc = device_get_softc(dev);
        int val, error;

        val = sc->sc_thermal_enabled;
        error = sysctl_handle_int(oidp, &val, 0, req);
        if (error || req->newptr == NULL)
                return (error);

        val = (val != 0) ? 1 : 0;
        if (val == sc->sc_thermal_enabled)
                return (0);

        sc->sc_thermal_enabled = val;

        if (!val && sc->sc_prochot_override) {
                apple_smc_thermal_fans_to_max(dev);
                device_printf(dev,
                    "thermal: governor disabled, fans set to max\n");
        }

        wakeup(&sc->sc_thermal_enabled);
        return (0);
}

int
apple_smc_thermal_int_sysctl(SYSCTL_HANDLER_ARGS)
{
        int *valp = (int *)arg1;
        int val, error;

        val = *valp;
        error = sysctl_handle_int(oidp, &val, 0, req);
        if (error || req->newptr == NULL)
                return (error);
        if (val <= 0)
                return (EINVAL);
        *valp = val;
        return (0);
}