/*
 * 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 2019, Joyent, Inc.
 * Copyright 2024 Oxide Computer Company
 */

/*
 * This implements a temperature sensor for AMD Zen family products that rely
 * upon the SMN framework for getting temperature information.
 *
 * ----------
 * Background
 * ----------
 *
 * When we think of temperature sensors, we generally think of an external or
 * embedded diode that measures a value in Celsius or Fahrenheit with some
 * accuracy and resolution. The most common forms of these are called Tj and
 * Tcase for the junction and case temperature. The junction temperature is the
 * one that comes up most inside of devices like a CPU as it looks at the
 * temperature of the actual transistors inside the part. On AMD, these Tj
 * sensors are often called Tdie, because they represent the temperature of a
 * particular die.
 *
 * While this is represented as a single number, there are often numerous diodes
 * that have some amount of post-processing applied to them from different
 * sources that are used to combine and make up this number.
 *
 * While AMD has various Tdie sensors (we'll get back to them later), the
 * primary thing that the CPU exposes and is used for overall health is quite
 * different and called Tctl, the control temperature. Unlike normal sensors
 * Tctl is not a measure of temperature in a traditional sense and is instead
 * used as part of the processor's control loop and is a unitless quantity that
 * ranges between 0 and 100. There are two notable thresholds:
 *
 * 1) At a value of 95, the CPU will begin internal thermal throttling.
 * 2) At a value of 100, after some period of time the CPU will shutdown. This
 * likely involves asserting the THERMTRIP_L signal, which is a dedicated pin on
 * the CPU socket.
 *
 * It's notable that this value is calculated and has various slew rates
 * applied. While for a few Zen 1 ThreadRipper CPUs, there was a suggestion from
 * the Ryzen Master software that there was a straightforward relationship
 * between Tctl and Tdie, we've found that this isn't quite true in practice and
 * that it's not helpful to try to convert Tctl to Tdie. There is no simple way
 * to do so. As such, we don't pretend to do so anymore, though we did in an
 * earlier life of this driver. The addition of the various CCD-specific sensors
 * is an aid here.
 *
 * -------------------------------------
 * System Management Network and Sensors
 * -------------------------------------
 *
 * The SMN (system management network) exists on a per-die basis. That is there
 * is one for each I/O die and connected devices in the system. In the context
 * of Zen 2+, there is usually only a single SMN network per socket. In Zen 1,
 * there was one for each Zepplin die, which combined both the core complexes
 * and I/O. See uts/intel/os/cpuid.c for more background here.
 *
 * As a result of this split there are two different groups of sensors that
 * exist within a single die:
 *
 * 1) SMU::THM::THM_TCON_CUR_TMP provides Tctl for the overall I/O die and
 * connected components. This is the unitless measurement mentioned above. The
 * aforementioned register is a shadow of whatever the die actually maintains
 * and is read-only for all intents and purposes for us due to its nature as a
 * shadow, despite what the PPR says.
 *
 * 2) SMU::THM::THM_DIEx_TEMP provides Tdie for a single die. Unlike Tctl, this
 * is a valid measurement in degrees Celsius. Notably, this is also a shadow
 * register that is updated by the SMU, while each die has its own underlying
 * diodes and control temperature calculations that are performed. There are
 * generally a fixed number of these die sensors at given offsets on the CPU.
 * These are sourced by the thermal monitor and have a valid bit. The general
 * assumption is that there is a 1:1 mapping on CPUs and APUs to CCDs.
 *
 * -------------------
 * Sensor Organization
 * -------------------
 *
 * The driver uses DDI_NT_SENSOR_TEMP_CPU, which will put us in the
 * /dev/sensors/cpu directory. Each DF maps to the cpuid.c procnode concept. The
 * Tctl sensor is named 'procnode.%u'. The Tdie sensors are named
 * 'procnode.%u:die.%u'. This allows us to have them exist on a per-DF basis.
 * The expectation is that consumers who care will make the assumption that
 * these are CCD-specific sensors rather than this driver itself.
 *
 * To represent this, the driver, which is rooted in the smntemp_t structure,
 * the smntemp_data global, contains a number of smntemp_df_t structures. One
 * for each df that exists. Each DF contains one smntemp_temp_t structure that
 * represents Tctl and a variable number of Tdie sensors based on how many the
 * SoC supports.
 *
 * Because of our desire not to assume that these are specifically CCD sensors
 * here (though they realistically speaking are), we don't try iterating the
 * CCDs as a way to scope which Tdie sensors exist and instead leverage the
 * valid bit that they have to determine which ksensors to create.
 */

#include <sys/modctl.h>
#include <sys/conf.h>
#include <sys/devops.h>
#include <sys/types.h>
#include <sys/cred.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/cmn_err.h>
#include <sys/stdbool.h>
#include <sys/x86_archext.h>
#include <sys/cpuvar.h>
#include <sys/sensors.h>
#include <sys/sysmacros.h>
#include <sys/amdzen/smn.h>
#include <sys/amdzen/thm.h>
#include <amdzen_client.h>

typedef enum {
        SMNTEMP_F_MUTEX = 1 << 0,
        SMNTEMP_F_VALID = 1 << 1
} smntemp_flags_t;

typedef enum {
        SMNTEMP_K_TCTL = 1,
        SMNTEMP_K_TDIE
} smntemp_kind_t;

typedef struct smntemp_temp smntemp_temp_t;
typedef struct smntemp_df smntemp_df_t;
typedef struct smntemp smntemp_t;

/*
 * This represents the per-temperature data that we keep around per exposed
 * ksensor.
 */
struct smntemp_temp {
        smntemp_kind_t stt_kind;
        smntemp_df_t *stt_df;
        smn_reg_t stt_reg;
        smntemp_flags_t stt_flags;
        id_t stt_ksensor;
        kmutex_t stt_mutex;
        hrtime_t stt_last_read;
        uint32_t stt_raw;
        int64_t stt_temp;
};

/*
 * This represents a single DF in the system and contains all of the temperature
 * sensors for it, both its Tctl and however many Tdie exist.
 */
struct smntemp_df {
        uint32_t sd_dfno;
        smntemp_temp_t sd_tctl;
        uint32_t sd_nccd;
        uint32_t sd_nccd_valid;
        smntemp_temp_t *sd_tdie;
};

/*
 * Primary driver state structure.
 */
struct smntemp {
        dev_info_t *smn_dip;
        x86_processor_family_t smn_fam;
        uint_t smn_ndf;
        smntemp_df_t *smn_df;
};

static smntemp_t smntemp_data;

/*
 * Determine if the "temperature" requires adjustment in some form. Tdie is
 * always adjusted. Tctl may in two different circumstances:
 *
 * (1) If the range bit, 'THM_CURTEMP_GET_RANGE' is set.
 * (2) if the mode is set to r/w. While the former is made much more explicit,
 * the latter is something that AMD has suggested, but hasn't been formally
 * documented in the PPR. However, experimentally this has proven to hold.
 */
static int64_t
smntemp_temp_adjust(smntemp_temp_t *stt)
{
        if (stt->stt_kind == SMNTEMP_K_TDIE) {
                return (THM_CURTEMP_RANGE_ADJ);
        }

        if (THM_CURTEMP_GET_RANGE(stt->stt_raw) == THM_CURTEMP_RANGE_N49_206 ||
            THM_CURTEMP_GET_TJ_SEL(stt->stt_raw) == THM_CURTEMP_TJ_SEL_RW) {
                return (THM_CURTEMP_RANGE_ADJ);
        }

        return (0);
}

static int
smntemp_temp_update(smntemp_temp_t *stt)
{
        int ret;
        uint32_t reg;
        int64_t raw, decimal;

        ASSERT(MUTEX_HELD((&stt->stt_mutex)));

        if ((ret = amdzen_c_smn_read(stt->stt_df->sd_dfno, stt->stt_reg,
            &reg)) != 0) {
                return (ret);
        }

        stt->stt_last_read = gethrtime();
        stt->stt_raw = reg;
        if (stt->stt_kind == SMNTEMP_K_TCTL) {
                raw = THM_CURTEMP_GET_TEMP(reg);
        } else {
                raw = THM_DIE_GET_TEMP(reg);
        }

        decimal = raw & THM_CURTEMP_TEMP_DEC_MASK;
        raw = raw >> THM_CURTEMP_TEMP_DEC_BITS;
        raw += smntemp_temp_adjust(stt);

        stt->stt_temp = raw << THM_CURTEMP_TEMP_DEC_BITS;
        stt->stt_temp += decimal;

        return (0);
}

static uint32_t
smntemp_temp_unit(smntemp_temp_t *stt)
{
        ASSERT(MUTEX_HELD(&stt->stt_mutex));

        if (stt->stt_kind == SMNTEMP_K_TDIE) {
                return (SENSOR_UNIT_CELSIUS);
        } else if (THM_CURTEMP_GET_TJ_SEL(stt->stt_raw) ==
            THM_CURTEMP_TJ_SEL_TJ) {
                return (SENSOR_UNIT_CELSIUS);
        } else {
                return (SENSOR_UNIT_NONE);
        }
}

static int
smntemp_temp_read(void *arg, sensor_ioctl_scalar_t *temp)
{
        int ret;
        smntemp_temp_t *stt = arg;

        mutex_enter(&stt->stt_mutex);
        if ((ret = smntemp_temp_update(stt)) != 0) {
                mutex_exit(&stt->stt_mutex);
                return (ret);
        }

        temp->sis_unit = smntemp_temp_unit(stt);
        temp->sis_value = stt->stt_temp;
        /* This is the same between Tctl and Tdie */
        temp->sis_gran = THM_CURTEMP_TEMP_DEC_GRAN;
        mutex_exit(&stt->stt_mutex);

        return (0);
}

/*
 * Because Tctl is usually a control temperature, but isn't guaranteed, we
 * cannot use a stock ksensor function and must implement this ourselves.
 */
static int
smntemp_temp_kind(void *arg, sensor_ioctl_kind_t *kind)
{
        smntemp_temp_t *stt = arg;

        if (stt->stt_kind == SMNTEMP_K_TDIE) {
                kind->sik_kind = SENSOR_KIND_TEMPERATURE;
                return (0);
        }

        mutex_enter(&stt->stt_mutex);
        if (stt->stt_raw == 0) {
                int ret = smntemp_temp_update(stt);
                if (ret != 0) {
                        mutex_exit(&stt->stt_mutex);
                        return (ret);
                }
        }

        if (THM_CURTEMP_GET_TJ_SEL(stt->stt_raw) == THM_CURTEMP_TJ_SEL_TJ) {
                kind->sik_kind = SENSOR_KIND_TEMPERATURE;
        } else {
                kind->sik_kind = SENSOR_KIND_SYNTHETIC;
                kind->sik_derive = SENSOR_KIND_TEMPERATURE;
        }

        mutex_exit(&stt->stt_mutex);
        return (0);
}

static const ksensor_ops_t smntemp_temp_ops = {
        .kso_kind = smntemp_temp_kind,
        .kso_scalar = smntemp_temp_read
};

static bool
smntemp_create_tdie(smntemp_t *smn, smntemp_df_t *df, smntemp_temp_t *temp,
    uint32_t ccdno)
{
        int ret;
        uint32_t val;
        char buf[128];

        temp->stt_kind = SMNTEMP_K_TDIE;
        temp->stt_df = df;
        temp->stt_reg = THM_DIE(ccdno, smn->smn_fam);
        mutex_init(&temp->stt_mutex, NULL, MUTEX_DRIVER, NULL);
        temp->stt_flags = SMNTEMP_F_MUTEX;

        /*
         * Tdie sensors have a valid bit that we need to check before we
         * register with the ksensor framework.
         */
        if (snprintf(buf, sizeof (buf), "procnode.%u.die.%u", df->sd_dfno,
            ccdno) >= sizeof (buf)) {
                dev_err(smn->smn_dip, CE_WARN, "!unexpected buffer name "
                    "overrun assembling DF/CCD %u/%u Tdie", df->sd_dfno,
                    ccdno);
                return (false);
        }

        if ((ret = amdzen_c_smn_read(temp->stt_df->sd_dfno, temp->stt_reg,
            &val)) != 0) {
                dev_err(smn->smn_dip, CE_WARN, "!unexpected SMN read failure "
                    "reading DF/CCD %u/%u Tdie: %d", df->sd_dfno, ccdno, ret);
                return (false);
        }

        /*
         * Tdie sensors have a valid bit in them. We more or less assume that
         * this valid bit is set by the SMU early in life and remains valid
         * throughout a given system boot.
         */
        if (THM_DIE_GET_VALID(val) == 0) {
                return (true);
        }

        df->sd_nccd_valid++;
        temp->stt_flags |= SMNTEMP_F_VALID;

        if ((ret = ksensor_create(smn->smn_dip, &smntemp_temp_ops, temp, buf,
            DDI_NT_SENSOR_TEMP_CPU, &temp->stt_ksensor)) != 0) {
                dev_err(smn->smn_dip, CE_WARN, "!failed to create sensor %s: "
                    "%d", buf, ret);
                return (false);
        }

        return (true);
}

static bool
smntemp_create_tctl(smntemp_t *smn, smntemp_df_t *df, smntemp_temp_t *temp)
{
        int ret;
        char buf[128];

        temp->stt_kind = SMNTEMP_K_TCTL;
        temp->stt_df = df;
        temp->stt_reg = THM_CURTEMP;
        mutex_init(&temp->stt_mutex, NULL, MUTEX_DRIVER, NULL);
        temp->stt_flags = SMNTEMP_F_VALID | SMNTEMP_F_MUTEX;

        if (snprintf(buf, sizeof (buf), "procnode.%u", df->sd_dfno) >=
            sizeof (buf)) {
                dev_err(smn->smn_dip, CE_WARN, "!unexpected buffer name "
                    "overrun assembling DF %u Tctl", df->sd_dfno);
                return (false);
        }

        if ((ret = ksensor_create(smn->smn_dip, &smntemp_temp_ops, temp, buf,
            DDI_NT_SENSOR_TEMP_CPU, &temp->stt_ksensor)) != 0) {
                dev_err(smn->smn_dip, CE_WARN, "!failed to create sensor %s: "
                    "%d", buf, ret);
                return (false);
        }

        return (true);
}

static void
smntemp_cleanup_temp(smntemp_temp_t *temp)
{
        temp->stt_flags &= ~SMNTEMP_F_VALID;
        if ((temp->stt_flags & SMNTEMP_F_MUTEX) != 0) {
                mutex_destroy(&temp->stt_mutex);
                temp->stt_flags &= ~SMNTEMP_F_MUTEX;
        }
        ASSERT0(temp->stt_flags);
}

static void
smntemp_cleanup(smntemp_t *smn)
{
        (void) ksensor_remove(smn->smn_dip, KSENSOR_ALL_IDS);

        for (uint32_t dfno = 0; dfno < smn->smn_ndf; dfno++) {
                smntemp_df_t *df = &smn->smn_df[dfno];
                smntemp_cleanup_temp(&df->sd_tctl);
                for (uint32_t ccdno = 0; ccdno < df->sd_nccd; ccdno++) {
                        smntemp_cleanup_temp(&df->sd_tdie[ccdno]);
                }

                if (df->sd_nccd > 0) {
                        kmem_free(df->sd_tdie, df->sd_nccd *
                            sizeof (smntemp_temp_t));
                        df->sd_nccd = 0;
                        df->sd_tdie = NULL;
                }
        }
        if (smn->smn_ndf > 0) {
                kmem_free(smn->smn_df, sizeof (smntemp_df_t) * smn->smn_ndf);
                smn->smn_ndf = 0;
                smn->smn_df = NULL;
        }

        if (smn->smn_dip != NULL) {
                ddi_remove_minor_node(smn->smn_dip, NULL);
                ddi_set_driver_private(smn->smn_dip, NULL);
                smn->smn_dip = NULL;
        }
}

static int
smntemp_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
        smntemp_t *smntemp = &smntemp_data;

        if (cmd == DDI_RESUME) {
                return (DDI_SUCCESS);
        } else if (cmd != DDI_ATTACH) {
                return (DDI_FAILURE);
        }

        if (smntemp->smn_dip != NULL) {
                dev_err(dip, CE_WARN, "!smntemp already attached");
                return (DDI_FAILURE);
        }
        smntemp->smn_dip = dip;
        smntemp->smn_fam = chiprev_family(cpuid_getchiprev(CPU));

        /*
         * First account for each actual DF instance. Then determine the number
         * of CCD entries we need to care about per SoC.
         */
        smntemp->smn_ndf = amdzen_c_df_count();
        if (smntemp->smn_ndf == 0) {
                dev_err(dip, CE_WARN, "!found zero DFs, can't attach smntemp");
                goto err;
        }
        smntemp->smn_df = kmem_zalloc(sizeof (smntemp_df_t) * smntemp->smn_ndf,
            KM_SLEEP);
        for (uint32_t dfno = 0; dfno < smntemp->smn_ndf; dfno++) {
                smntemp_df_t *df = &smntemp->smn_df[dfno];
                df->sd_dfno = dfno;
                df->sd_nccd = THM_DIE_MAX_UNITS(smntemp->smn_fam);

                if (!smntemp_create_tctl(smntemp, df, &df->sd_tctl)) {
                        goto err;
                }

                if (df->sd_nccd > 0) {
                        df->sd_tdie = kmem_zalloc(sizeof (smntemp_temp_t) *
                            df->sd_nccd, KM_SLEEP);
                }

                for (uint32_t i = 0; i < df->sd_nccd; i++) {
                        if (!smntemp_create_tdie(smntemp, df,
                            &df->sd_tdie[i], i)) {
                                goto err;
                        }
                }
        }

        ddi_set_driver_private(dip, smntemp);
        return (DDI_SUCCESS);

err:
        smntemp_cleanup(smntemp);
        return (DDI_FAILURE);
}

static int
smntemp_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
        smntemp_t *smntemp = &smntemp_data;

        if (cmd == DDI_SUSPEND) {
                return (DDI_SUCCESS);
        } else if (cmd != DDI_DETACH) {
                return (DDI_FAILURE);
        }

        if (smntemp->smn_dip == NULL) {
                dev_err(smntemp->smn_dip, CE_WARN, "!asked to detach smn "
                    "instance %d that was never attached",
                    ddi_get_instance(dip));
                return (DDI_FAILURE);
        }

        smntemp_cleanup(smntemp);
        return (DDI_SUCCESS);
}

static struct dev_ops smntemp_dev_ops = {
        .devo_rev = DEVO_REV,
        .devo_refcnt = 0,
        .devo_getinfo = nodev,
        .devo_identify = nulldev,
        .devo_probe = nulldev,
        .devo_attach = smntemp_attach,
        .devo_detach = smntemp_detach,
        .devo_reset = nodev,
        .devo_quiesce = ddi_quiesce_not_needed,
};

static struct modldrv smntemp_modldrv = {
        .drv_modops = &mod_driverops,
        .drv_linkinfo = "AMD SMN Temperature Driver",
        .drv_dev_ops = &smntemp_dev_ops
};

static struct modlinkage smntemp_modlinkage = {
        .ml_rev = MODREV_1,
        .ml_linkage = { &smntemp_modldrv, NULL }
};

int
_init(void)
{
        return (mod_install(&smntemp_modlinkage));
}

int
_info(struct modinfo *modinfop)
{
        return (mod_info(&smntemp_modlinkage, modinfop));
}

int
_fini(void)
{
        return (mod_remove(&smntemp_modlinkage));
}