/*
 * Copyright (c) 2015 Imre Vadász <imre@vdsz.com>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

/*
 * Device driver for Intel's On Die power usage estimation via MSR.
 * Supported by Sandy Bridge and later CPUs, and also by Atom CPUs
 * of the Silvermont and later architectures.
 */

#include <sys/param.h>
#include <sys/bus.h>
#include <sys/systm.h>
#include <sys/module.h>
#include <sys/conf.h>
#include <sys/cpu_topology.h>
#include <sys/kernel.h>
#include <sys/sensors.h>
#include <sys/bitops.h>

#include <machine/specialreg.h>
#include <machine/cpufunc.h>
#include <machine/cputypes.h>
#include <machine/md_var.h>

#include "cpu_if.h"

#define MSR_RAPL_POWER_UNIT_POWER       __BITS64(0, 3)
#define MSR_RAPL_POWER_UNIT_ENERGY      __BITS64(8, 12)
#define MSR_RAPL_POWER_UNIT_TIME        __BITS64(16, 19)

struct corepower_sensor {
        uint64_t        energy;
        u_int           msr;
        struct ksensor  sensor;
};

struct corepower_softc {
        device_t                sc_dev;

        uint32_t                sc_watt_unit;
        uint32_t                sc_joule_unit;
        uint32_t                sc_second_unit;

        int                     sc_have_sens;
        int                     sc_is_atom;

        struct corepower_sensor sc_pkg_sens;
        struct corepower_sensor sc_dram_sens;
        struct corepower_sensor sc_pp0_sens;
        struct corepower_sensor sc_pp1_sens;
        struct corepower_sensor sc_platform_sens;

        struct ksensordev       sc_sensordev;
        struct sensor_task      *sc_senstask;
};

/*
 * Device methods.
 */
static void     corepower_identify(driver_t *driver, device_t parent);
static int      corepower_probe(device_t dev);
static int      corepower_attach(device_t dev);
static int      corepower_detach(device_t dev);
static uint32_t corepower_energy_to_uwatts(struct corepower_softc *sc,
                                           uint32_t units, uint32_t secs);
static void     corepower_refresh(void *arg);
static void     corepower_sens_init(struct corepower_sensor *sens,
                                    char *desc, u_int msr, int cpu);
static void     corepower_sens_update(struct corepower_softc *sc,
                                      struct corepower_sensor *sens);
static int      corepower_try(u_int msr, char *name);

static device_method_t corepower_methods[] = {
        /* Device interface */
        DEVMETHOD(device_identify,      corepower_identify),
        DEVMETHOD(device_probe,         corepower_probe),
        DEVMETHOD(device_attach,        corepower_attach),
        DEVMETHOD(device_detach,        corepower_detach),

        DEVMETHOD_END
};

static driver_t corepower_driver = {
        "corepower",
        corepower_methods,
        sizeof(struct corepower_softc),
};

static devclass_t corepower_devclass;
DRIVER_MODULE(corepower, cpu, corepower_driver, corepower_devclass, NULL, NULL);
MODULE_VERSION(corepower, 1);

static void
corepower_identify(driver_t *driver, device_t parent)
{
        device_t child;
        const struct cpu_node *node;
        int cpu, master_cpu;

        /* Make sure we're not being doubly invoked. */
        if (device_find_child(parent, "corepower", -1) != NULL)
                return;

        /* Check that the vendor is Intel. */
        if (cpu_vendor_id != CPU_VENDOR_INTEL)
                return;

        /* We only want one child per CPU package */
        cpu = device_get_unit(parent);
        node = get_cpu_node_by_cpuid(cpu);
        while (node != NULL) {
                if (node->type == CHIP_LEVEL) {
                        if (node->child_no == 0)
                                node = NULL;
                        break;
                }
                node = node->parent_node;
        }
        if (node == NULL)
                return;

        master_cpu = BSRCPUMASK(node->members);
        if (cpu != master_cpu)
                return;

        child = device_add_child(parent, "corepower", -1);
        if (child == NULL)
                device_printf(parent, "add corepower child failed\n");
}

static int
corepower_probe(device_t dev)
{
        int cpu_family, cpu_model;

        if (resource_disabled("corepower", 0))
                return (ENXIO);

        cpu_model = CPUID_TO_MODEL(cpu_id);
        cpu_family = CPUID_TO_FAMILY(cpu_id);

        if (cpu_family == 0x06) {
                switch (cpu_model) {
                /* Core CPUs */
                case 0x2a:
                case 0x3a:
                /* Xeon CPUs */
                case 0x2d:
                case 0x3e:
                case 0x3f:
                case 0x4f:
                case 0x56:
                /* Haswell, Broadwell, Skylake, Kaby Lake, Coffee Lake */
                case 0x3c:
                case 0x3d:
                case 0x45:
                case 0x46:
                case 0x47:
                case 0x4e:
                case 0x5e:
                case 0x8e:      /* Kaby Lake, Coffee Lake */
                case 0x9e:      /* dito */
                /* Atom CPUs */
                case 0x37:
                case 0x4a:
                case 0x4c:
                case 0x4d:
                case 0x5a:
                case 0x5d:
                        break;
                default:
                        return (ENXIO);
                }
        }

        if (corepower_try(MSR_RAPL_POWER_UNIT, "MSR_RAPL_POWER_UNIT") == 0)
                return (ENXIO);

        device_set_desc(dev, "CPU On-Die Power Usage Estimation");

        return (BUS_PROBE_GENERIC);
}

static int
corepower_attach(device_t dev)
{
        struct corepower_softc *sc = device_get_softc(dev);
        uint64_t val;
        uint32_t power_units;
        uint32_t energy_units;
        uint32_t time_units;
        int cpu_family, cpu_model;
        int cpu;

        sc->sc_dev = dev;
        sc->sc_have_sens = 0;
        sc->sc_is_atom = 0;

        cpu_family = CPUID_TO_FAMILY(cpu_id);
        cpu_model = CPUID_TO_MODEL(cpu_id);

        /* Check CPU model */
        if (cpu_family == 0x06) {
                switch (cpu_model) {
                /* Core CPUs */
                case 0x2a:
                case 0x3a:
                        sc->sc_have_sens = 0xd;
                        break;
                /* Xeon CPUs */
                case 0x2d: /* Only Xeon branded, Core i version should probably be 0x5 */
                case 0x3e:
                case 0x3f:
                case 0x4f:
                case 0x56:
                        sc->sc_have_sens = 0x7;
                        break;
                /* Haswell, Broadwell */
                case 0x3c:
                case 0x3d:
                case 0x45:
                case 0x46:
                case 0x47:
                        /* Check if Core or Xeon (Xeon CPUs might be 0x7) */
                        sc->sc_have_sens = 0xf;
                        break;
                /* Skylake, Kaby Lake, Coffee Lake */
                case 0x4e:
                case 0x5e:
                case 0x8e:      /* Kaby Lake, Coffee Lake */
                case 0x9e:      /* dito */
                        sc->sc_have_sens = 0x1f;
                        break;
                /* Atom CPUs */
                case 0x37:
                case 0x4a:
                case 0x4c:
                case 0x4d:
                case 0x5a:
                case 0x5d:
                        sc->sc_have_sens = 0x5;
                        /* use quirk for Valleyview Atom CPUs */
                        sc->sc_is_atom = 1;
                        break;
                default:
                        return (ENXIO);
                }
        }

        val = rdmsr(MSR_RAPL_POWER_UNIT);

        power_units = __SHIFTOUT(val, MSR_RAPL_POWER_UNIT_POWER);
        energy_units = __SHIFTOUT(val, MSR_RAPL_POWER_UNIT_ENERGY);
        time_units = __SHIFTOUT(val, MSR_RAPL_POWER_UNIT_TIME);

        sc->sc_watt_unit = (1 << power_units);
        sc->sc_joule_unit = (1 << energy_units);
        sc->sc_second_unit = (1 << time_units);

        /*
         * Add hw.sensors.cpu_nodeN MIB.
         */
        cpu = device_get_unit(device_get_parent(dev));
        ksnprintf(sc->sc_sensordev.xname, sizeof(sc->sc_sensordev.xname),
            "cpu_node%d", get_chip_ID(cpu));
        if ((sc->sc_have_sens & 1) &&
            corepower_try(MSR_PKG_ENERGY_STATUS, "MSR_PKG_ENERGY_STATUS")) {
                corepower_sens_init(&sc->sc_pkg_sens, "Package Power",
                    MSR_PKG_ENERGY_STATUS, cpu);
                sensor_attach(&sc->sc_sensordev, &sc->sc_pkg_sens.sensor);
        } else {
                sc->sc_have_sens &= ~1;
        }
        if ((sc->sc_have_sens & 2) &&
            corepower_try(MSR_DRAM_ENERGY_STATUS, "MSR_DRAM_ENERGY_STATUS")) {
                corepower_sens_init(&sc->sc_dram_sens, "DRAM Power",
                    MSR_DRAM_ENERGY_STATUS, cpu);
                sensor_attach(&sc->sc_sensordev, &sc->sc_dram_sens.sensor);
        } else {
                sc->sc_have_sens &= ~2;
        }
        if ((sc->sc_have_sens & 4) &&
            corepower_try(MSR_PP0_ENERGY_STATUS, "MSR_PP0_ENERGY_STATUS")) {
                corepower_sens_init(&sc->sc_pp0_sens, "Cores Power",
                    MSR_PP0_ENERGY_STATUS, cpu);
                sensor_attach(&sc->sc_sensordev, &sc->sc_pp0_sens.sensor);
        } else {
                sc->sc_have_sens &= ~4;
        }
        if ((sc->sc_have_sens & 8) &&
            corepower_try(MSR_PP1_ENERGY_STATUS, "MSR_PP1_ENERGY_STATUS")) {
                corepower_sens_init(&sc->sc_pp1_sens, "Graphics Power",
                    MSR_PP1_ENERGY_STATUS, cpu);
                sensor_attach(&sc->sc_sensordev, &sc->sc_pp1_sens.sensor);
        } else {
                sc->sc_have_sens &= ~8;
        }
        if ((sc->sc_have_sens & 0x10) &&
            corepower_try(MSR_PLATFORM_ENERGY_COUNTER, "MSR_PLATFORM_ENERGY_COUNTER") &&
            (rdmsr(MSR_PLATFORM_ENERGY_COUNTER) & 0xffffffffU) != 0) {
                corepower_sens_init(&sc->sc_platform_sens, "Platform Power",
                    MSR_PLATFORM_ENERGY_COUNTER, cpu);
                sensor_attach(&sc->sc_sensordev, &sc->sc_platform_sens.sensor);
        } else {
                sc->sc_have_sens &= ~0x10;
        }

        if (sc->sc_have_sens == 0)
                return (ENXIO);

        sc->sc_senstask = sensor_task_register2(sc, corepower_refresh, 1, cpu);

        sensordev_install(&sc->sc_sensordev);

        return (0);
}

static int
corepower_detach(device_t dev)
{
        struct corepower_softc *sc = device_get_softc(dev);

        sensordev_deinstall(&sc->sc_sensordev);
        sensor_task_unregister2(sc->sc_senstask);

        return (0);
}

static uint32_t
corepower_energy_to_uwatts(struct corepower_softc *sc, uint32_t units,
    uint32_t secs)
{
        uint64_t val;

        if (sc->sc_is_atom) {
                val = ((uint64_t)units) * sc->sc_joule_unit;
        } else {
                val = ((uint64_t)units) * 1000ULL * 1000ULL;
                val /= sc->sc_joule_unit;
        }

        return val / secs;
}

static void
corepower_refresh(void *arg)
{
        struct corepower_softc *sc = (struct corepower_softc *)arg;

        if (sc->sc_have_sens & 1)
                corepower_sens_update(sc, &sc->sc_pkg_sens);
        if (sc->sc_have_sens & 2)
                corepower_sens_update(sc, &sc->sc_dram_sens);
        if (sc->sc_have_sens & 4)
                corepower_sens_update(sc, &sc->sc_pp0_sens);
        if (sc->sc_have_sens & 8)
                corepower_sens_update(sc, &sc->sc_pp1_sens);
        if (sc->sc_have_sens & 0x10)
                corepower_sens_update(sc, &sc->sc_platform_sens);
}

static void
corepower_sens_init(struct corepower_sensor *sens, char *desc, u_int msr,
    int cpu)
{
        ksnprintf(sens->sensor.desc, sizeof(sens->sensor.desc), "node%d %s",
            get_chip_ID(cpu), desc);
        sens->sensor.type = SENSOR_WATTS;
        sens->msr = msr;
        sens->energy = rdmsr(sens->msr) & 0xffffffffU;
}

static void
corepower_sens_update(struct corepower_softc *sc,
    struct corepower_sensor *sens)
{
        uint64_t a, res;

        a = rdmsr(sens->msr) & 0xffffffffU;
        if (sens->energy > a) {
                res = (0x100000000ULL - sens->energy) + a;
        } else {
                res = a - sens->energy;
        }
        sens->energy = a;
        sens->sensor.value = corepower_energy_to_uwatts(sc, res, 1);
}

static int
corepower_try(u_int msr, char *name)
{
        uint64_t val;

        if (rdmsr_safe(msr, &val) != 0) {
                kprintf("msr %s (0x%08x) not available\n", name, msr);
                return 0;
        }
        return 1;
}