/*      $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;
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.