/* $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 __KERNEL_RCSID(0, "$NetBSD: mcp980x.c,v 1.8 2024/01/16 21:08:52 andvar Exp $"); #include #include #include #include #include #include #include #include #include #include #include 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, ®, 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, ®, 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, ®, 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, ®, 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; }