/*
 * Copyright (c) 2015 The DragonFly Project.  All rights reserved.
 *
 * This code is derived from software contributed to The DragonFly Project
 * by Sepherosa Ziehau <sepherosa@gmail.com>
 *
 * 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.
 * 3. Neither the name of The DragonFly Project nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific, prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * ``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
 * COPYRIGHT HOLDERS OR CONTRIBUTORS 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.
 */

#include <sys/param.h>
#include <sys/bus.h>
#include <sys/kernel.h>
#include <sys/lock.h>
#include <sys/malloc.h>
#include <sys/module.h>
#include <sys/sensors.h>
#include <sys/sysctl.h>
#include <sys/systm.h>

#include <dev/misc/dimm/dimm.h>

#define DIMM_TEMP_HIWAT_DEFAULT 85
#define DIMM_TEMP_LOWAT_DEFAULT 75

#define DIMM_ECC_THRESH_DEFAULT 5

struct dimm_softc {
        TAILQ_ENTRY(dimm_softc) dimm_link;
        int                     dimm_node;
        int                     dimm_chan;
        int                     dimm_slot;
        int                     dimm_temp_hiwat;
        int                     dimm_temp_lowat;
        int                     dimm_id;
        int                     dimm_ref;
        int                     dimm_ecc_cnt;
        int                     dimm_ecc_thresh;

        struct ksensordev       dimm_sensdev;
        uint32_t                dimm_sens_taskflags;    /* DIMM_SENS_TF_ */

        struct sysctl_ctx_list  dimm_sysctl_ctx;
        struct sysctl_oid       *dimm_sysctl_tree;
};
TAILQ_HEAD(dimm_softc_list, dimm_softc);

#define DIMM_SENS_TF_TEMP_CRIT          0x1
#define DIMM_SENS_TF_ECC_CRIT           0x2

static void     dimm_mod_unload(void);
static void     dimm_sensor_ecc(struct dimm_softc *, struct ksensor *,
                    boolean_t);

/* In the ascending order of dimm_softc.dimm_id */
static struct dimm_softc_list   dimm_softc_list;

static SYSCTL_NODE(_hw, OID_AUTO, dimminfo, CTLFLAG_RD, NULL,
    "DIMM information");

struct dimm_softc *
dimm_create(int node, int chan, int slot)
{
        struct dimm_softc *sc, *after = NULL;
        int dimm_id = 0;

        SYSCTL_XLOCK();

        TAILQ_FOREACH(sc, &dimm_softc_list, dimm_link) {
                /*
                 * Already exists; done.
                 */
                if (sc->dimm_node == node && sc->dimm_chan == chan &&
                    sc->dimm_slot == slot) {
                        KASSERT(sc->dimm_ref > 0, ("invalid dimm reference %d",
                            sc->dimm_ref));
                        sc->dimm_ref++;
                        SYSCTL_XUNLOCK();
                        return sc;
                }

                /*
                 * Find the lowest usable id.
                 */
                if (sc->dimm_id == dimm_id) {
                        ++dimm_id;
                        after = sc;
                }
        }

        sc = kmalloc(sizeof(*sc), M_DEVBUF, M_WAITOK | M_ZERO);
        sc->dimm_node = node;
        sc->dimm_chan = chan;
        sc->dimm_slot = slot;
        sc->dimm_id = dimm_id;
        sc->dimm_ref = 1;
        sc->dimm_temp_hiwat = DIMM_TEMP_HIWAT_DEFAULT;
        sc->dimm_temp_lowat = DIMM_TEMP_LOWAT_DEFAULT;
        sc->dimm_ecc_thresh = DIMM_ECC_THRESH_DEFAULT;

        ksnprintf(sc->dimm_sensdev.xname, sizeof(sc->dimm_sensdev.xname),
            "dimm%d", sc->dimm_id);

        /*
         * Create sysctl tree for the location information.  Use
         * same name as the sensor device.
         */
        sysctl_ctx_init(&sc->dimm_sysctl_ctx);
        sc->dimm_sysctl_tree = SYSCTL_ADD_NODE(&sc->dimm_sysctl_ctx,
            SYSCTL_STATIC_CHILDREN(_hw_dimminfo), OID_AUTO,
            sc->dimm_sensdev.xname, CTLFLAG_RD, 0, "");
        if (sc->dimm_sysctl_tree != NULL) {
                SYSCTL_ADD_INT(&sc->dimm_sysctl_ctx,
                    SYSCTL_CHILDREN(sc->dimm_sysctl_tree), OID_AUTO,
                    "node", CTLFLAG_RD, &sc->dimm_node, 0,
                    "CPU node of this DIMM");
                SYSCTL_ADD_INT(&sc->dimm_sysctl_ctx,
                    SYSCTL_CHILDREN(sc->dimm_sysctl_tree), OID_AUTO,
                    "chan", CTLFLAG_RD, &sc->dimm_chan, 0,
                    "channel of this DIMM");
                SYSCTL_ADD_INT(&sc->dimm_sysctl_ctx,
                    SYSCTL_CHILDREN(sc->dimm_sysctl_tree), OID_AUTO,
                    "slot", CTLFLAG_RD, &sc->dimm_slot, 0,
                    "slot of this DIMM");
                SYSCTL_ADD_INT(&sc->dimm_sysctl_ctx,
                    SYSCTL_CHILDREN(sc->dimm_sysctl_tree), OID_AUTO,
                    "temp_hiwat", CTLFLAG_RW, &sc->dimm_temp_hiwat, 0,
                    "Raise alarm once DIMM temperature is above this value "
                    "(unit: C)");
                SYSCTL_ADD_INT(&sc->dimm_sysctl_ctx,
                    SYSCTL_CHILDREN(sc->dimm_sysctl_tree), OID_AUTO,
                    "temp_lowat", CTLFLAG_RW, &sc->dimm_temp_lowat, 0,
                    "Cancel alarm once DIMM temperature is below this value "
                    "(unit: C)");
                SYSCTL_ADD_INT(&sc->dimm_sysctl_ctx,
                    SYSCTL_CHILDREN(sc->dimm_sysctl_tree), OID_AUTO,
                    "ecc_thresh", CTLFLAG_RW, &sc->dimm_ecc_thresh, 0,
                    "Raise alarm once number ECC errors go above this value");
        }

        if (after == NULL) {
                KKASSERT(sc->dimm_id == 0);
                TAILQ_INSERT_HEAD(&dimm_softc_list, sc, dimm_link);
        } else {
                TAILQ_INSERT_AFTER(&dimm_softc_list, after, sc, dimm_link);
        }

        sensordev_install(&sc->dimm_sensdev);

        SYSCTL_XUNLOCK();
        return sc;
}

int
dimm_destroy(struct dimm_softc *sc)
{
        SYSCTL_XLOCK();

        KASSERT(sc->dimm_ref > 0, ("invalid dimm reference %d", sc->dimm_ref));
        sc->dimm_ref--;
        if (sc->dimm_ref > 0) {
                SYSCTL_XUNLOCK();
                return EAGAIN;
        }

        sensordev_deinstall(&sc->dimm_sensdev);

        TAILQ_REMOVE(&dimm_softc_list, sc, dimm_link);
        if (sc->dimm_sysctl_tree != NULL)
                sysctl_ctx_free(&sc->dimm_sysctl_ctx);
        kfree(sc, M_DEVBUF);

        SYSCTL_XUNLOCK();
        return 0;
}

void
dimm_sensor_attach(struct dimm_softc *sc, struct ksensor *sens)
{
        sensor_attach(&sc->dimm_sensdev, sens);
}

void
dimm_sensor_detach(struct dimm_softc *sc, struct ksensor *sens)
{
        sensor_detach(&sc->dimm_sensdev, sens);
}

void
dimm_set_temp_thresh(struct dimm_softc *sc, int hiwat, int lowat)
{
        sc->dimm_temp_hiwat = hiwat;
        sc->dimm_temp_lowat = lowat;
}

void
dimm_set_ecc_thresh(struct dimm_softc *sc, int thresh)
{
        sc->dimm_ecc_thresh = thresh;
}

void
dimm_sensor_temp(struct dimm_softc *sc, struct ksensor *sens, int temp)
{
        enum sensor_status status;

        if (temp >= sc->dimm_temp_hiwat &&
            (sc->dimm_sens_taskflags & DIMM_SENS_TF_TEMP_CRIT) == 0) {
                char temp_str[16], data[64];

                ksnprintf(temp_str, sizeof(temp_str), "%d", temp);
                ksnprintf(data, sizeof(data), "node=%d channel=%d dimm=%d",
                    sc->dimm_node, sc->dimm_chan, sc->dimm_slot);
                devctl_notify("memtemp", "Thermal", temp_str, data);

                kprintf("dimm%d: node%d channel%d DIMM%d "
                    "temperature (%dC) is too high (>= %dC)\n",
                    sc->dimm_id, sc->dimm_node, sc->dimm_chan, sc->dimm_slot,
                    temp, sc->dimm_temp_hiwat);

                sc->dimm_sens_taskflags |= DIMM_SENS_TF_TEMP_CRIT;
        } else if ((sc->dimm_sens_taskflags & DIMM_SENS_TF_TEMP_CRIT) &&
             temp < sc->dimm_temp_lowat) {
                sc->dimm_sens_taskflags &= ~DIMM_SENS_TF_TEMP_CRIT;
        }

        if (sc->dimm_sens_taskflags & DIMM_SENS_TF_TEMP_CRIT)
                status = SENSOR_S_CRIT;
        else
                status = SENSOR_S_OK;
        sensor_set_temp_degc(sens, temp, status);
}

void
dimm_sensor_ecc_set(struct dimm_softc *sc, struct ksensor *sens,
    int ecc_cnt, boolean_t crit)
{
        sc->dimm_ecc_cnt = ecc_cnt;
        dimm_sensor_ecc(sc, sens, crit);
}

void
dimm_sensor_ecc_add(struct dimm_softc *sc, struct ksensor *sens,
    int ecc_cnt, boolean_t crit)
{
        sc->dimm_ecc_cnt += ecc_cnt;
        dimm_sensor_ecc(sc, sens, crit);
}

static void
dimm_sensor_ecc(struct dimm_softc *sc, struct ksensor *sens, boolean_t crit)
{
        enum sensor_status status;

        if (!crit && sc->dimm_ecc_cnt >= sc->dimm_ecc_thresh)
                crit = TRUE;

        if (crit && (sc->dimm_sens_taskflags & DIMM_SENS_TF_ECC_CRIT) == 0) {
                char ecc_str[16], data[64];

                ksnprintf(ecc_str, sizeof(ecc_str), "%d", sc->dimm_ecc_cnt);
                ksnprintf(data, sizeof(data), "node=%d channel=%d dimm=%d",
                    sc->dimm_node, sc->dimm_chan, sc->dimm_slot);
                devctl_notify("ecc", "ECC", ecc_str, data);

                kprintf("dimm%d: node%d channel%d DIMM%d "
                    "too many ECC errors %d\n",
                    sc->dimm_id, sc->dimm_node, sc->dimm_chan, sc->dimm_slot,
                    sc->dimm_ecc_cnt);

                sc->dimm_sens_taskflags |= DIMM_SENS_TF_ECC_CRIT;
        }

        if (sc->dimm_sens_taskflags & DIMM_SENS_TF_ECC_CRIT)
                status = SENSOR_S_CRIT;
        else
                status = SENSOR_S_OK;
        sensor_set(sens, sc->dimm_ecc_cnt, status);
}

static void
dimm_mod_unload(void)
{
        struct dimm_softc *sc;

        SYSCTL_XLOCK();

        while ((sc = TAILQ_FIRST(&dimm_softc_list)) != NULL) {
                int error;

                error = dimm_destroy(sc);
                KASSERT(!error, ("dimm%d is still referenced, ref %d",
                    sc->dimm_id, sc->dimm_ref));
        }

        SYSCTL_XUNLOCK();
}

static int
dimm_mod_event(module_t mod, int type, void *unused)
{
        switch (type) {
        case MOD_LOAD:
                TAILQ_INIT(&dimm_softc_list);
                return 0;

        case MOD_UNLOAD:
                dimm_mod_unload();
                return 0;

        default:
                return 0;
        }
}

static moduledata_t dimm_mod = {
        "dimm",
        dimm_mod_event,
        0
};
DECLARE_MODULE(dimm, dimm_mod, SI_SUB_PRE_DRIVERS, SI_ORDER_ANY);
MODULE_VERSION(dimm, 1);