1/* $NetBSD: owtemp.c,v 1.15 2009/12/06 22:49:48 dyoung Exp $ */ 2/* $OpenBSD: owtemp.c,v 1.1 2006/03/04 16:27:03 grange Exp $ */ 3 4/* 5 * Copyright (c) 2006 Alexander Yurchenko <grange@openbsd.org> 6 * 7 * Permission to use, copy, modify, and distribute this software for any 8 * purpose with or without fee is hereby granted, provided that the above 9 * copyright notice and this permission notice appear in all copies. 10 * 11 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 12 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 13 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 14 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 15 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 16 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 17 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 18 */ 19 20/* 21 * 1-Wire temperature family type device driver. 22 */ 23 24#include <sys/cdefs.h> 25__KERNEL_RCSID(0, "$NetBSD: owtemp.c,v 1.15 2009/12/06 22:49:48 dyoung Exp $"); 26 27#include <sys/param.h> 28#include <sys/systm.h> 29#include <sys/device.h> 30#include <sys/kernel.h> 31#include <sys/proc.h> 32 33#include <dev/sysmon/sysmonvar.h> 34 35#include <dev/onewire/onewiredevs.h> 36#include <dev/onewire/onewirereg.h> 37#include <dev/onewire/onewirevar.h> 38 39#define DS_CMD_CONVERT 0x44 40#define DS_CMD_READ_SCRATCHPAD 0xbe 41 42struct owtemp_softc { 43 void * sc_onewire; 44 u_int64_t sc_rom; 45 46 envsys_data_t sc_sensor; 47 struct sysmon_envsys *sc_sme; 48 49 uint32_t (*sc_owtemp_decode)(const uint8_t *); 50 51 int sc_dying; 52}; 53 54static int owtemp_match(device_t, cfdata_t, void *); 55static void owtemp_attach(device_t, device_t, void *); 56static int owtemp_detach(device_t, int); 57static int owtemp_activate(device_t, enum devact); 58 59static void owtemp_update(void *); 60 61CFATTACH_DECL_NEW(owtemp, sizeof(struct owtemp_softc), 62 owtemp_match, owtemp_attach, owtemp_detach, owtemp_activate); 63 64extern struct cfdriver owtemp_cd; 65 66static const struct onewire_matchfam owtemp_fams[] = { 67 { ONEWIRE_FAMILY_DS1920 }, 68 { ONEWIRE_FAMILY_DS18B20 }, 69 { ONEWIRE_FAMILY_DS1822 }, 70}; 71 72static void owtemp_refresh(struct sysmon_envsys *, envsys_data_t *); 73 74static uint32_t owtemp_decode_ds18b20(const uint8_t *); 75static uint32_t owtemp_decode_ds1920(const uint8_t *); 76 77static int 78owtemp_match(device_t parent, cfdata_t match, void *aux) 79{ 80 return (onewire_matchbyfam(aux, owtemp_fams, 81 __arraycount(owtemp_fams))); 82} 83 84static void 85owtemp_attach(device_t parent, device_t self, void *aux) 86{ 87 struct owtemp_softc *sc = device_private(self); 88 struct onewire_attach_args *oa = aux; 89 90 aprint_naive("\n"); 91 92 sc->sc_onewire = oa->oa_onewire; 93 sc->sc_rom = oa->oa_rom; 94 95 switch(ONEWIRE_ROM_FAMILY_TYPE(sc->sc_rom)) { 96 case ONEWIRE_FAMILY_DS18B20: 97 case ONEWIRE_FAMILY_DS1822: 98 sc->sc_owtemp_decode = owtemp_decode_ds18b20; 99 break; 100 case ONEWIRE_FAMILY_DS1920: 101 sc->sc_owtemp_decode = owtemp_decode_ds1920; 102 break; 103 } 104 105 sc->sc_sme = sysmon_envsys_create(); 106 107 /* Initialize sensor */ 108 sc->sc_sensor.units = ENVSYS_STEMP; 109 sc->sc_sensor.state = ENVSYS_SINVALID; 110 (void)strlcpy(sc->sc_sensor.desc, 111 device_xname(self), sizeof(sc->sc_sensor.desc)); 112 if (sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor)) { 113 sysmon_envsys_destroy(sc->sc_sme); 114 return; 115 } 116 117 /* Hook into system monitor. */ 118 sc->sc_sme->sme_name = device_xname(self); 119 sc->sc_sme->sme_cookie = sc; 120 sc->sc_sme->sme_refresh = owtemp_refresh; 121 122 if (sysmon_envsys_register(sc->sc_sme)) { 123 aprint_error_dev(self, "unable to register with sysmon\n"); 124 sysmon_envsys_destroy(sc->sc_sme); 125 return; 126 } 127 128 aprint_normal("\n"); 129} 130 131static int 132owtemp_detach(device_t self, int flags) 133{ 134 struct owtemp_softc *sc = device_private(self); 135 136 sysmon_envsys_unregister(sc->sc_sme); 137 138 return 0; 139} 140 141static int 142owtemp_activate(device_t self, enum devact act) 143{ 144 struct owtemp_softc *sc = device_private(self); 145 146 switch (act) { 147 case DVACT_DEACTIVATE: 148 sc->sc_dying = 1; 149 return 0; 150 default: 151 return EOPNOTSUPP; 152 } 153} 154 155static void 156owtemp_update(void *arg) 157{ 158 struct owtemp_softc *sc = arg; 159 u_int8_t data[9]; 160 161 onewire_lock(sc->sc_onewire); 162 if (onewire_reset(sc->sc_onewire) != 0) 163 goto done; 164 onewire_matchrom(sc->sc_onewire, sc->sc_rom); 165 166 /* 167 * Start temperature conversion. The conversion takes up to 750ms. 168 * After sending the command, the data line must be held high for 169 * at least 750ms to provide power during the conversion process. 170 * As such, no other activity may take place on the 1-Wire bus for 171 * at least this period. 172 */ 173 onewire_write_byte(sc->sc_onewire, DS_CMD_CONVERT); 174 tsleep(sc, PRIBIO, "owtemp", hz); 175 176 if (onewire_reset(sc->sc_onewire) != 0) 177 goto done; 178 onewire_matchrom(sc->sc_onewire, sc->sc_rom); 179 180 /* 181 * The result of the temperature measurement is placed in the 182 * first two bytes of the scratchpad. 183 */ 184 onewire_write_byte(sc->sc_onewire, DS_CMD_READ_SCRATCHPAD); 185 onewire_read_block(sc->sc_onewire, data, 9); 186#if 0 187 if (onewire_crc(data, 8) == data[8]) { 188 sc->sc_sensor.value = 273150000 + 189 (int)((u_int16_t)data[1] << 8 | data[0]) * 500000; 190 } 191#endif 192 193 sc->sc_sensor.value_cur = sc->sc_owtemp_decode(data); 194 sc->sc_sensor.state = ENVSYS_SVALID; 195 196done: 197 onewire_unlock(sc->sc_onewire); 198} 199 200static void 201owtemp_refresh(struct sysmon_envsys *sme, envsys_data_t *edata) 202{ 203 struct owtemp_softc *sc = sme->sme_cookie; 204 205 owtemp_update(sc); 206} 207 208static uint32_t 209owtemp_decode_ds18b20(const uint8_t *buf) 210{ 211 int temp; 212 213 /* 214 * Sign-extend the MSB byte, and add in the fractions of a 215 * degree contained in the LSB (precision 1/16th DegC). 216 */ 217 temp = (int8_t)buf[1]; 218 temp = (temp << 8) | buf[0]; 219 220 /* 221 * Conversion to uK is simple. 222 */ 223 return (temp * 62500 + 273150000); 224} 225 226static uint32_t 227owtemp_decode_ds1920(const uint8_t *buf) 228{ 229 int temp; 230 231 /* 232 * Sign-extend the MSB byte, and add in the fractions of a 233 * degree contained in the LSB (precision 1/2 DegC). 234 */ 235 temp = (int8_t)buf[1]; 236 temp = (temp << 8) | buf[0]; 237 238 /* Convert to uK */ 239 return (temp * 500000 + 273150000); 240} 241