/*- * Copyright (c) 2010 Andreas Tobler. * Copyright (c) 2013-2014 Luiz Otavio O Souza * 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. */ #include #include "opt_platform.h" #include #include #include #include #include #include #include #include #include #include #ifdef FDT #include #include #include #endif /* LM75 registers. */ #define LM75_TEMP 0x0 #define LM75_CONF 0x1 #define LM75_CONF_FSHIFT 3 #define LM75_CONF_FAULT 0x18 #define LM75_CONF_POL 0x04 #define LM75_CONF_MODE 0x02 #define LM75_CONF_SHUTD 0x01 #define LM75_CONF_MASK 0x1f #define LM75_THYST 0x2 #define LM75_TOS 0x3 /* LM75 constants. */ #define LM75_TEST_PATTERN 0xa #define LM75_MIN_TEMP -55 #define LM75_MAX_TEMP 125 #define TZ_ZEROC 27315 #define TZ_ZEROC_DIVIDER 100 enum max_resolution{ BITS_9 = 1, BITS_11 }; /* Regular bus attachment functions */ static int lm75_probe(device_t); static int lm75_attach(device_t); struct lm75_softc { device_t sc_dev; struct intr_config_hook enum_hook; uint32_t sc_addr; uint32_t sc_conf; uint8_t sc_resolution; uint8_t sc_max_resolution; uint16_t sc_multiplier; }; /* Utility functions */ static int lm75_conf_read(struct lm75_softc *); static int lm75_conf_write(struct lm75_softc *); static int lm75_temp_read(struct lm75_softc *, uint8_t, int *); static int lm75_temp_write(struct lm75_softc *, uint8_t, int); static void lm75_start(void *); static int lm75_read(device_t, uint32_t, uint8_t, uint8_t *, size_t); static int lm75_write(device_t, uint32_t, uint8_t *, size_t); static int lm75_str_mode(char *); static int lm75_str_pol(char *); static int lm75_temp_sysctl(SYSCTL_HANDLER_ARGS); static int lm75_faults_sysctl(SYSCTL_HANDLER_ARGS); static int lm75_mode_sysctl(SYSCTL_HANDLER_ARGS); static int lm75_pol_sysctl(SYSCTL_HANDLER_ARGS); static int lm75_shutdown_sysctl(SYSCTL_HANDLER_ARGS); static int lm75_resolution_sysctl(SYSCTL_HANDLER_ARGS); static device_method_t lm75_methods[] = { /* Device interface */ DEVMETHOD(device_probe, lm75_probe), DEVMETHOD(device_attach, lm75_attach), DEVMETHOD_END }; static driver_t lm75_driver = { "lm75", lm75_methods, sizeof(struct lm75_softc) }; #ifdef FDT static struct ofw_compat_data compat_data[] = { {"national,lm75", BITS_9}, {"ti,lm75", BITS_9}, {0,0} }; #endif DRIVER_MODULE(lm75, iicbus, lm75_driver, 0, 0); static int lm75_read(device_t dev, uint32_t addr, uint8_t reg, uint8_t *data, size_t len) { struct iic_msg msg[2] = { { addr, IIC_M_WR | IIC_M_NOSTOP, 1, ® }, { addr, IIC_M_RD, len, data }, }; if (iicbus_transfer(dev, msg, nitems(msg)) != 0) return (-1); return (0); } static int lm75_write(device_t dev, uint32_t addr, uint8_t *data, size_t len) { struct iic_msg msg[1] = { { addr, IIC_M_WR, len, data }, }; if (iicbus_transfer(dev, msg, nitems(msg)) != 0) return (-1); return (0); } static int lm75_probe(device_t dev) { #ifdef FDT const struct ofw_compat_data *compat_ptr; #endif struct lm75_softc *sc; sc = device_get_softc(dev); sc->sc_max_resolution = 9; #ifdef FDT if (!ofw_bus_status_okay(dev)) return (ENXIO); compat_ptr = ofw_bus_search_compatible(dev, compat_data); switch (compat_ptr->ocd_data){ case BITS_9: sc->sc_max_resolution = 9; break; case BITS_11: sc->sc_max_resolution = 11; break; default: return (ENXIO); } #endif device_set_desc(dev, "LM75 temperature sensor"); return (BUS_PROBE_GENERIC); } static int lm75_attach(device_t dev) { struct lm75_softc *sc; sc = device_get_softc(dev); sc->sc_dev = dev; sc->sc_addr = iicbus_get_addr(dev); sc->enum_hook.ich_func = lm75_start; sc->enum_hook.ich_arg = dev; switch (sc->sc_max_resolution) { case 9: sc->sc_resolution = 9; sc->sc_max_resolution = 9; sc->sc_multiplier = 10; break; case 11: sc->sc_resolution = 11; sc->sc_max_resolution = 11; sc->sc_multiplier = 1000; break; default: return (ENXIO); } /* * We have to wait until interrupts are enabled. Usually I2C read * and write only works when the interrupts are available. */ if (config_intrhook_establish(&sc->enum_hook) != 0) return (ENOMEM); return (0); } static int lm75_type_detect(struct lm75_softc *sc) { int i, lm75a; uint8_t buf8; uint32_t conf; /* Save the contents of the configuration register. */ if (lm75_conf_read(sc) != 0) return (-1); conf = sc->sc_conf; /* * Just write some pattern at configuration register so we can later * verify. The test pattern should be pretty harmless. */ sc->sc_conf = LM75_TEST_PATTERN; if (lm75_conf_write(sc) != 0) return (-1); /* * Read the configuration register again and check for our test * pattern. */ if (lm75_conf_read(sc) != 0) return (-1); if (sc->sc_conf != LM75_TEST_PATTERN) return (-1); /* * Read from nonexistent registers (0x4 ~ 0x6). * LM75A always return 0xff for nonexistent registers. * LM75 will return the last read value - our test pattern written to * configuration register. */ lm75a = 0; for (i = 4; i <= 6; i++) { if (lm75_read(sc->sc_dev, sc->sc_addr, i, &buf8, sizeof(buf8)) < 0) return (-1); if (buf8 != LM75_TEST_PATTERN && buf8 != 0xff) return (-1); if (buf8 == 0xff) lm75a++; } if (lm75a == 3){ sc->sc_multiplier = 1000; sc->sc_resolution = 11; sc->sc_max_resolution = 11; } /* Restore the configuration register. */ sc->sc_conf = conf; if (lm75_conf_write(sc) != 0) return (-1); return (0); } static void lm75_start(void *xdev) { device_t dev; struct lm75_softc *sc; struct sysctl_ctx_list *ctx; struct sysctl_oid *tree_node; struct sysctl_oid_list *tree; char *mult_format; dev = (device_t)xdev; sc = device_get_softc(dev); ctx = device_get_sysctl_ctx(dev); tree_node = device_get_sysctl_tree(dev); tree = SYSCTL_CHILDREN(tree_node); config_intrhook_disestablish(&sc->enum_hook); /* * Detect the kind of chip we are attaching to. * This may not work for LM75 clones. */ if (lm75_type_detect(sc) != 0) { device_printf(dev, "cannot detect sensor.\n"); #ifndef FDT return; #endif } device_printf(dev,"%d bit resolution sensor attached.\n", sc->sc_resolution); if (sc->sc_multiplier == 1000) mult_format = "IK3"; else mult_format = "IK"; /* Temperature. */ SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "temperature", CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_MPSAFE, dev, LM75_TEMP, lm75_temp_sysctl, mult_format, "Current temperature"); SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "thyst", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE, dev, LM75_THYST, lm75_temp_sysctl, mult_format, "Hysteresis temperature"); SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "tos", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE, dev, LM75_TOS, lm75_temp_sysctl, mult_format, "Overtemperature"); /* Configuration parameters. */ SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "faults", CTLFLAG_RW | CTLTYPE_UINT | CTLFLAG_MPSAFE, dev, 0, lm75_faults_sysctl, "IU", "LM75 fault queue"); SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "mode", CTLFLAG_RW | CTLTYPE_STRING | CTLFLAG_MPSAFE, dev, 0, lm75_mode_sysctl, "A", "LM75 mode"); SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "polarity", CTLFLAG_RW | CTLTYPE_STRING | CTLFLAG_MPSAFE, dev, 0, lm75_pol_sysctl, "A", "LM75 OS polarity"); SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "shutdown", CTLFLAG_RW | CTLTYPE_UINT | CTLFLAG_MPSAFE, dev, 0, lm75_shutdown_sysctl, "IU", "LM75 shutdown"); SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "resolution", CTLFLAG_RW | CTLTYPE_INT | CTLFLAG_MPSAFE, dev, 0, lm75_resolution_sysctl, "IU", "LM75 resolution"); } static int lm75_conf_read(struct lm75_softc *sc) { uint8_t buf8; if (lm75_read(sc->sc_dev, sc->sc_addr, LM75_CONF, &buf8, sizeof(buf8)) < 0) return (-1); sc->sc_conf = (uint32_t)buf8; return (0); } static int lm75_conf_write(struct lm75_softc *sc) { uint8_t buf8[2]; buf8[0] = LM75_CONF; buf8[1] = (uint8_t)sc->sc_conf & LM75_CONF_MASK; if (lm75_write(sc->sc_dev, sc->sc_addr, buf8, sizeof(buf8)) < 0) return (-1); return (0); } static int lm75_temp_read(struct lm75_softc *sc, uint8_t reg, int32_t *temp) { int32_t buf; uint8_t buf8[2]; uint8_t resolution = sc->sc_resolution; uint16_t multiplier = sc->sc_multiplier; if (lm75_read(sc->sc_dev, sc->sc_addr, reg, buf8, sizeof(buf8)) < 0) return (-1); buf = (int16_t)((buf8[0] << 8) | buf8[1]); *temp = ((buf >> (16 - resolution)) * multiplier) >> (resolution - 8); *temp += TZ_ZEROC * sc->sc_multiplier / TZ_ZEROC_DIVIDER; return (0); } static int lm75_temp_write(struct lm75_softc *sc, uint8_t reg, int32_t temp) { int32_t buf; uint8_t buf8[3], resolution = sc->sc_resolution; uint16_t multiplier = sc->sc_multiplier; temp -= TZ_ZEROC * multiplier / TZ_ZEROC_DIVIDER; if (temp > LM75_MAX_TEMP * multiplier) temp = LM75_MAX_TEMP * multiplier; if (temp < LM75_MIN_TEMP * multiplier) temp = LM75_MIN_TEMP * multiplier; buf = ((temp << (resolution - 8)) / multiplier) << (16 - resolution); buf8[0] = reg; buf8[1] = (buf >> 8) & 0xff; buf8[2] = buf & 0xff; if (lm75_write(sc->sc_dev, sc->sc_addr, buf8, sizeof(buf8)) < 0) return (-1); return (0); } static int lm75_str_mode(char *buf) { int len, rtrn; rtrn = -1; len = strlen(buf); if (len > 2 && strncasecmp("interrupt", buf, len) == 0) rtrn = 1; else if (len > 2 && strncasecmp("comparator", buf, len) == 0) rtrn = 0; return (rtrn); } static int lm75_str_pol(char *buf) { int len, rtrn; rtrn = -1; len = strlen(buf); if (len > 1 && strncasecmp("high", buf, len) == 0) rtrn = 1; else if (len > 1 && strncasecmp("low", buf, len) == 0) rtrn = 0; else if (len > 8 && strncasecmp("active-high", buf, len) == 0) rtrn = 1; else if (len > 8 && strncasecmp("active-low", buf, len) == 0) rtrn = 0; return (rtrn); } static int lm75_temp_sysctl(SYSCTL_HANDLER_ARGS) { device_t dev; int error; int32_t temp; struct lm75_softc *sc; uint8_t reg; dev = (device_t)arg1; reg = (uint8_t)arg2; sc = device_get_softc(dev); if (lm75_temp_read(sc, reg, &temp) != 0) return (EIO); error = sysctl_handle_int(oidp, &temp, 0, req); if (error != 0 || req->newptr == NULL) return (error); if (lm75_temp_write(sc, reg, temp) != 0) return (EIO); return (error); } static int lm75_faults_sysctl(SYSCTL_HANDLER_ARGS) { device_t dev; int lm75_faults[] = { 1, 2, 4, 6 }; int error, faults, i, newf, tmp; struct lm75_softc *sc; dev = (device_t)arg1; sc = device_get_softc(dev); tmp = (sc->sc_conf & LM75_CONF_FAULT) >> LM75_CONF_FSHIFT; if (tmp >= nitems(lm75_faults)) tmp = nitems(lm75_faults) - 1; faults = lm75_faults[tmp]; error = sysctl_handle_int(oidp, &faults, 0, req); if (error != 0 || req->newptr == NULL) return (error); if (faults != lm75_faults[tmp]) { newf = 0; for (i = 0; i < nitems(lm75_faults); i++) if (faults >= lm75_faults[i]) newf = i; sc->sc_conf &= ~LM75_CONF_FAULT; sc->sc_conf |= newf << LM75_CONF_FSHIFT; if (lm75_conf_write(sc) != 0) return (EIO); } return (error); } static int lm75_mode_sysctl(SYSCTL_HANDLER_ARGS) { char buf[16]; device_t dev; int error, mode, newm; struct lm75_softc *sc; dev = (device_t)arg1; sc = device_get_softc(dev); if (sc->sc_conf & LM75_CONF_MODE) { mode = 1; strlcpy(buf, "interrupt", sizeof(buf)); } else { mode = 0; strlcpy(buf, "comparator", sizeof(buf)); } error = sysctl_handle_string(oidp, buf, sizeof(buf), req); if (error != 0 || req->newptr == NULL) return (error); newm = lm75_str_mode(buf); if (newm != -1 && mode != newm) { sc->sc_conf &= ~LM75_CONF_MODE; if (newm == 1) sc->sc_conf |= LM75_CONF_MODE; if (lm75_conf_write(sc) != 0) return (EIO); } return (error); } static int lm75_pol_sysctl(SYSCTL_HANDLER_ARGS) { char buf[16]; device_t dev; int error, newp, pol; struct lm75_softc *sc; dev = (device_t)arg1; sc = device_get_softc(dev); if (sc->sc_conf & LM75_CONF_POL) { pol = 1; strlcpy(buf, "active-high", sizeof(buf)); } else { pol = 0; strlcpy(buf, "active-low", sizeof(buf)); } error = sysctl_handle_string(oidp, buf, sizeof(buf), req); if (error != 0 || req->newptr == NULL) return (error); newp = lm75_str_pol(buf); if (newp != -1 && pol != newp) { sc->sc_conf &= ~LM75_CONF_POL; if (newp == 1) sc->sc_conf |= LM75_CONF_POL; if (lm75_conf_write(sc) != 0) return (EIO); } return (error); } static int lm75_shutdown_sysctl(SYSCTL_HANDLER_ARGS) { device_t dev; int error, shutdown, tmp; struct lm75_softc *sc; dev = (device_t)arg1; sc = device_get_softc(dev); tmp = shutdown = (sc->sc_conf & LM75_CONF_SHUTD) ? 1 : 0; error = sysctl_handle_int(oidp, &shutdown, 0, req); if (error != 0 || req->newptr == NULL) return (error); if (shutdown != tmp) { sc->sc_conf &= ~LM75_CONF_SHUTD; if (shutdown) sc->sc_conf |= LM75_CONF_SHUTD; if (lm75_conf_write(sc) != 0) return (EIO); } return (error); } static int lm75_resolution_sysctl(SYSCTL_HANDLER_ARGS) { device_t dev; int error; struct lm75_softc *sc; int resolution; dev = (device_t)arg1; sc = device_get_softc(dev); resolution = sc->sc_resolution; error = sysctl_handle_int(oidp, &resolution, 0, req); if (error != 0 || req->newptr == NULL) return (error); if (resolution > sc->sc_max_resolution || resolution < 9) return (EINVAL); sc->sc_resolution = (uint8_t) resolution; return (0); }