/*      $NetBSD: mcp980x.c,v 1.8 2024/01/16 21:08:52 andvar Exp $ */

/*-
 * Copyright (c) 2013 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Radoslaw Kujawa.
 *
 * 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
 */

/*
 * Microchip MCP9800/1/2/3 2-Wire High-Accuracy Temperature Sensor driver.
 *
 * TODO: better error checking, particularly in user settable limits.
 *
 * Note: MCP9805 is different and is supported by the sdtemp(4) driver.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: mcp980x.c,v 1.8 2024/01/16 21:08:52 andvar Exp $");

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/device.h>
#include <sys/kernel.h>
#include <sys/mutex.h>
#include <sys/endian.h>
#include <sys/sysctl.h>

#include <sys/bus.h>
#include <dev/i2c/i2cvar.h>

#include <dev/sysmon/sysmonvar.h>

#include <dev/i2c/mcp980xreg.h>

struct mcp980x_softc {
        device_t                sc_dev;

        i2c_tag_t               sc_tag;
        i2c_addr_t              sc_addr;

        int                     sc_res;
        int                     sc_hyst;
        int                     sc_limit;

        /* envsys(4) stuff */
        struct sysmon_envsys    *sc_sme;
        envsys_data_t           sc_sensor;
        kmutex_t                sc_lock; 
};


static int mcp980x_match(device_t, cfdata_t, void *);
static void mcp980x_attach(device_t, device_t, void *);

static uint8_t mcp980x_reg_read_1(struct mcp980x_softc *, uint8_t);
static uint16_t mcp980x_reg_read_2(struct mcp980x_softc *, uint8_t);
static void mcp980x_reg_write_1(struct mcp980x_softc *, uint8_t, uint8_t);

static uint8_t mcp980x_resolution_get(struct mcp980x_softc *);
static void mcp980x_resolution_set(struct mcp980x_softc *, uint8_t);

static int8_t mcp980x_hysteresis_get(struct mcp980x_softc *);
static void mcp980x_hysteresis_set(struct mcp980x_softc *, int8_t);
static int8_t mcp980x_templimit_get(struct mcp980x_softc *);
static void mcp980x_templimit_set(struct mcp980x_softc *, int8_t);

static int8_t mcp980x_s8b_get(struct mcp980x_softc *, uint8_t);
static void mcp980x_s8b_set(struct mcp980x_softc *, uint8_t, int8_t);

static uint32_t mcp980x_temperature(struct mcp980x_softc *);

static void mcp980x_envsys_register(struct mcp980x_softc *);
static void mcp980x_envsys_refresh(struct sysmon_envsys *, envsys_data_t *);

static void mcp980x_setup_sysctl(struct mcp980x_softc *);
static int sysctl_mcp980x_res(SYSCTLFN_ARGS);
static int sysctl_mcp980x_hysteresis(SYSCTLFN_ARGS);
static int sysctl_mcp980x_templimit(SYSCTLFN_ARGS);

CFATTACH_DECL_NEW(mcp980x, sizeof (struct mcp980x_softc),
    mcp980x_match, mcp980x_attach, NULL, NULL);

static int
mcp980x_match(device_t parent, cfdata_t cf, void *aux)
{

        if (ia->ia_addr >= MCP980X_ADDR_CONST &&
            ia->ia_addr <= (MCP980X_ADDR_CONST + MCP980X_ADDR_VAR))
                return I2C_MATCH_ADDRESS_ONLY;

        return 0;
}

static void
mcp980x_attach(device_t parent, device_t self, void *aux)
{
        struct mcp980x_softc *sc = device_private(self);
        struct i2c_attach_args *ia = aux;

        sc->sc_dev = self;
        sc->sc_addr = ia->ia_addr;
        sc->sc_tag = ia->ia_tag;

        aprint_normal(": Microchip MCP980x Temperature Sensor\n");

        sc->sc_res = MCP980X_CONFIG_ADC_RES_12BIT;
        mcp980x_resolution_set(sc, sc->sc_res);

        sc->sc_hyst = mcp980x_hysteresis_get(sc);
        sc->sc_limit = mcp980x_templimit_get(sc);

        mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_NONE);

        mcp980x_setup_sysctl(sc);
        mcp980x_envsys_register(sc);
}

static uint16_t
mcp980x_reg_read_2(struct mcp980x_softc *sc, uint8_t reg)
{
        uint16_t rv;

        if (iic_acquire_bus(sc->sc_tag, 0) != 0) {
                aprint_error_dev(sc->sc_dev, "cannot acquire bus for read\n");
                return 0;
        }

        if (iic_exec(sc->sc_tag, I2C_OP_READ_WITH_STOP, sc->sc_addr, &reg,
            1, &rv, 2, 0)) {
                iic_release_bus(sc->sc_tag, 0);
                aprint_error_dev(sc->sc_dev, "cannot execute operation\n");
                return 0;
        }
        iic_release_bus(sc->sc_tag, 0);

        return be16toh(rv);
}

static uint8_t
mcp980x_reg_read_1(struct mcp980x_softc *sc, uint8_t reg)
{
        uint8_t rv;

        if (iic_acquire_bus(sc->sc_tag, 0) != 0) {
                aprint_error_dev(sc->sc_dev, "cannot acquire bus for read\n");
                return 0;
        }

        if (iic_exec(sc->sc_tag, I2C_OP_READ_WITH_STOP, sc->sc_addr, &reg,
            1, &rv, 1, 0)) {
                iic_release_bus(sc->sc_tag, 0);
                aprint_error_dev(sc->sc_dev, "cannot execute operation\n");
                return 0;
        }
        iic_release_bus(sc->sc_tag, 0);

        return rv;
}

static void
mcp980x_reg_write_2(struct mcp980x_softc *sc, uint8_t reg, uint16_t val)
{
        uint16_t beval;

        beval = htobe16(val);

        if (iic_acquire_bus(sc->sc_tag, 0) != 0) {
                aprint_error_dev(sc->sc_dev, "cannot acquire bus for write\n");
                return;
        }

        if (iic_exec(sc->sc_tag, I2C_OP_WRITE_WITH_STOP, sc->sc_addr, &reg,
            1, &beval, 2, 0)) {
                aprint_error_dev(sc->sc_dev, "cannot execute operation\n");
        }

        iic_release_bus(sc->sc_tag, 0);

}

static void
mcp980x_reg_write_1(struct mcp980x_softc *sc, uint8_t reg, uint8_t val)
{
        if (iic_acquire_bus(sc->sc_tag, 0) != 0) {
                aprint_error_dev(sc->sc_dev, "cannot acquire bus for write\n");
                return;
        }

        if (iic_exec(sc->sc_tag, I2C_OP_WRITE_WITH_STOP, sc->sc_addr, &reg,
            1, &val, 1, 0)) {
                aprint_error_dev(sc->sc_dev, "cannot execute operation\n");
        }

        iic_release_bus(sc->sc_tag, 0);

}

static int8_t
mcp980x_templimit_get(struct mcp980x_softc *sc)
{
        return mcp980x_s8b_get(sc, MCP980X_TEMP_LIMIT);
}

static void
mcp980x_templimit_set(struct mcp980x_softc *sc, int8_t val)
{
        mcp980x_s8b_set(sc, MCP980X_TEMP_LIMIT, val);
}

static int8_t
mcp980x_hysteresis_get(struct mcp980x_softc *sc)
{
        return mcp980x_s8b_get(sc, MCP980X_TEMP_HYSTERESIS);
}

static void
mcp980x_hysteresis_set(struct mcp980x_softc *sc, int8_t val)
{
        mcp980x_s8b_set(sc, MCP980X_TEMP_HYSTERESIS, val);
}

static int8_t
mcp980x_s8b_get(struct mcp980x_softc *sc, uint8_t reg) 
{
        return mcp980x_reg_read_2(sc, reg) >> MCP980X_TEMP_HYSTLIMIT_INT_SHIFT;
}

static void
mcp980x_s8b_set(struct mcp980x_softc *sc, uint8_t reg, int8_t val)
{
        mcp980x_reg_write_2(sc, reg, val << MCP980X_TEMP_HYSTLIMIT_INT_SHIFT);
}

static uint8_t 
mcp980x_resolution_get(struct mcp980x_softc *sc)
{
        uint8_t cfg, res;

        cfg = mcp980x_reg_read_1(sc, MCP980X_CONFIG);
        res = (cfg & MCP980X_CONFIG_ADC_RES) >> 
            MCP980X_CONFIG_ADC_RES_SHIFT;

        return res;
}

static void
mcp980x_resolution_set(struct mcp980x_softc *sc, uint8_t res)
{
        uint8_t cfg;

        /* read config register but discard resolution bits */
        cfg = mcp980x_reg_read_1(sc, MCP980X_CONFIG) & ~MCP980X_CONFIG_ADC_RES;
        /* set resolution bits to new value */
        cfg |= res << MCP980X_CONFIG_ADC_RES_SHIFT;

        mcp980x_reg_write_1(sc, MCP980X_CONFIG, cfg);
}

/* Get temperature in microKelvins. */
static uint32_t
mcp980x_temperature(struct mcp980x_softc *sc)
{
        uint16_t raw;
        uint32_t rv, uk, basedegc;

        raw = mcp980x_reg_read_2(sc, MCP980X_AMBIENT_TEMP);

        basedegc = (raw & MCP980X_AMBIENT_TEMP_DEGREES) >> 
            MCP980X_AMBIENT_TEMP_DEGREES_SHIFT;

        uk = 1000000 * basedegc;

        if (raw & MCP980X_AMBIENT_TEMP_05DEGREE)
                uk += 500000;
        if (raw & MCP980X_AMBIENT_TEMP_025DEGREE)
                uk += 250000;
        if (raw & MCP980X_AMBIENT_TEMP_0125DEGREE)
                uk += 125000;
        if (raw & MCP980X_AMBIENT_TEMP_00625DEGREE)
                uk += 62500;

        if (raw & MCP980X_AMBIENT_TEMP_SIGN)
                rv = 273150000U - uk;
        else
                rv = 273150000U + uk;

        return rv;      
}

static void
mcp980x_envsys_register(struct mcp980x_softc *sc)
{
        sc->sc_sme = sysmon_envsys_create();

        strlcpy(sc->sc_sensor.desc, "Ambient temp",
            sizeof(sc->sc_sensor.desc));
        sc->sc_sensor.units = ENVSYS_STEMP;
        sc->sc_sensor.state = ENVSYS_SINVALID;

        if (sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor)) {
                aprint_error_dev(sc->sc_dev,
                    "error attaching sensor\n");
                return;
        }

        sc->sc_sme->sme_name = device_xname(sc->sc_dev);
        sc->sc_sme->sme_cookie = sc;
        sc->sc_sme->sme_refresh = mcp980x_envsys_refresh;

        if (sysmon_envsys_register(sc->sc_sme)) {
                aprint_error_dev(sc->sc_dev, "unable to register in sysmon\n");
                sysmon_envsys_destroy(sc->sc_sme);
        }
}

static void
mcp980x_envsys_refresh(struct sysmon_envsys *sme, envsys_data_t *edata)
{
        struct mcp980x_softc *sc = sme->sme_cookie;

        mutex_enter(&sc->sc_lock);

        edata->value_cur = mcp980x_temperature(sc);
        edata->state = ENVSYS_SVALID;

        mutex_exit(&sc->sc_lock);
}

static void
mcp980x_setup_sysctl(struct mcp980x_softc *sc)
{
        const struct sysctlnode *me = NULL, *node = NULL;
 
        sysctl_createv(NULL, 0, NULL, &me,
            CTLFLAG_READWRITE,
            CTLTYPE_NODE, device_xname(sc->sc_dev), NULL,
            NULL, 0, NULL, 0,
            CTL_MACHDEP, CTL_CREATE, CTL_EOL);

        sysctl_createv(NULL, 0, NULL, &node,
            CTLFLAG_READWRITE | CTLFLAG_OWNDESC,
            CTLTYPE_INT, "res", "Resolution",
            sysctl_mcp980x_res, 1, (void *)sc, 0,
            CTL_MACHDEP, me->sysctl_num, CTL_CREATE, CTL_EOL);
        
        sysctl_createv(NULL, 0, NULL, &node,
            CTLFLAG_READWRITE | CTLFLAG_OWNDESC,
            CTLTYPE_INT, "hysteresis", "Temperature hysteresis",
            sysctl_mcp980x_hysteresis, 1, (void *)sc, 0,
            CTL_MACHDEP, me->sysctl_num, CTL_CREATE, CTL_EOL);

        sysctl_createv(NULL, 0, NULL, &node,
            CTLFLAG_READWRITE | CTLFLAG_OWNDESC,
            CTLTYPE_INT, "templimit", "Temperature limit",
            sysctl_mcp980x_templimit, 1, (void *)sc, 0,
            CTL_MACHDEP, me->sysctl_num, CTL_CREATE, CTL_EOL);
}


SYSCTL_SETUP(sysctl_mcp980x_setup, "sysctl mcp980x subtree setup")
{
        sysctl_createv(NULL, 0, NULL, NULL, CTLFLAG_PERMANENT,
            CTLTYPE_NODE, "machdep", NULL, NULL, 0, NULL, 0,
            CTL_MACHDEP, CTL_EOL);
}


static int
sysctl_mcp980x_res(SYSCTLFN_ARGS)
{
        struct sysctlnode node = *rnode;
        struct mcp980x_softc *sc = node.sysctl_data;
        int newres, err;

        node.sysctl_data = &sc->sc_res;
        if ((err = (sysctl_lookup(SYSCTLFN_CALL(&node)))) != 0) 
                return err;

        if (newp) {
                newres = *(int *)node.sysctl_data;
                if (newres > MCP980X_CONFIG_ADC_RES_12BIT)
                        return EINVAL;
                sc->sc_res = (uint8_t) newres;
                mcp980x_resolution_set(sc, sc->sc_res);
                return 0;
        } else {
                sc->sc_res = mcp980x_resolution_get(sc);
                node.sysctl_size = 4;
        }

        return err;
}

static int
sysctl_mcp980x_hysteresis(SYSCTLFN_ARGS)
{
        struct sysctlnode node = *rnode;
        struct mcp980x_softc *sc = node.sysctl_data;
        int newhyst, err;

        node.sysctl_data = &sc->sc_hyst;
        if ((err = (sysctl_lookup(SYSCTLFN_CALL(&node)))) != 0) 
                return err;

        if (newp) {
                newhyst = *(int *)node.sysctl_data;
                sc->sc_hyst = newhyst;
                mcp980x_hysteresis_set(sc, sc->sc_hyst);
                return 0;
        } else {
                sc->sc_hyst = mcp980x_hysteresis_get(sc);
                node.sysctl_size = 4;
        }

        return err;
}

static int
sysctl_mcp980x_templimit(SYSCTLFN_ARGS)
{
        struct sysctlnode node = *rnode;
        struct mcp980x_softc *sc = node.sysctl_data;
        int newlimit, err;

        node.sysctl_data = &sc->sc_limit;
        if ((err = (sysctl_lookup(SYSCTLFN_CALL(&node)))) != 0) 
                return err;

        if (newp) {
                newlimit = *(int *)node.sysctl_data;
                sc->sc_limit = newlimit;
                mcp980x_templimit_set(sc, sc->sc_limit);
                return 0;
        } else {
                sc->sc_limit = mcp980x_templimit_get(sc);
                node.sysctl_size = 4;
        }

        return err;
}