sdtemp.c revision 1.12
1 /* $NetBSD: sdtemp.c,v 1.12 2010/03/14 18:05:49 pgoyette Exp $ */ 2 3 /* 4 * Copyright (c) 2009 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Paul Goyette. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 #include <sys/cdefs.h> 33 __KERNEL_RCSID(0, "$NetBSD: sdtemp.c,v 1.12 2010/03/14 18:05:49 pgoyette Exp $"); 34 35 #include <sys/param.h> 36 #include <sys/systm.h> 37 #include <sys/kmem.h> 38 #include <sys/device.h> 39 #include <sys/kernel.h> 40 #include <sys/endian.h> 41 42 #include <dev/sysmon/sysmonvar.h> 43 44 #include <dev/i2c/i2cvar.h> 45 #include <dev/i2c/sdtemp_reg.h> 46 47 struct sdtemp_softc { 48 device_t sc_dev; 49 i2c_tag_t sc_tag; 50 int sc_address; 51 52 struct sysmon_envsys *sc_sme; 53 envsys_data_t *sc_sensor; 54 int sc_resolution; 55 uint16_t sc_capability; 56 }; 57 58 static int sdtemp_match(device_t, cfdata_t, void *); 59 static void sdtemp_attach(device_t, device_t, void *); 60 61 CFATTACH_DECL_NEW(sdtemp, sizeof(struct sdtemp_softc), 62 sdtemp_match, sdtemp_attach, NULL, NULL); 63 64 static void sdtemp_refresh(struct sysmon_envsys *, envsys_data_t *); 65 static void sdtemp_get_limits(struct sysmon_envsys *, envsys_data_t *, 66 sysmon_envsys_lim_t *, uint32_t *); 67 static void sdtemp_set_limits(struct sysmon_envsys *, envsys_data_t *, 68 sysmon_envsys_lim_t *, uint32_t *); 69 #ifdef NOT_YET 70 static int sdtemp_read_8(struct sdtemp_softc *, uint8_t, uint8_t *); 71 static int sdtemp_write_8(struct sdtemp_softc *, uint8_t, uint8_t); 72 #endif /* NOT YET */ 73 static int sdtemp_read_16(struct sdtemp_softc *, uint8_t, uint16_t *); 74 static int sdtemp_write_16(struct sdtemp_softc *, uint8_t, uint16_t); 75 static uint32_t sdtemp_decode_temp(struct sdtemp_softc *, uint16_t); 76 static bool sdtemp_pmf_suspend(device_t, const pmf_qual_t *); 77 static bool sdtemp_pmf_resume(device_t, const pmf_qual_t *); 78 79 struct sdtemp_dev_entry { 80 const uint16_t sdtemp_mfg_id; 81 const uint8_t sdtemp_dev_id; 82 const uint8_t sdtemp_rev_id; 83 const uint8_t sdtemp_resolution; 84 const char *sdtemp_desc; 85 }; 86 87 /* Convert sysmon_envsys uKelvin value to simple degC */ 88 89 #define __UK2C(uk) (((uk) - 273150000) / 1000000) 90 91 /* 92 * List of devices known to conform to JEDEC JC42.4 93 * 94 * NOTE: A non-negative value for resolution indicates that the sensor 95 * resolution is fixed at that number of fractional bits; a negative 96 * value indicates that the sensor needs to be configured. In either 97 * case, trip-point registers are fixed at two-bit (0.25C) resolution. 98 */ 99 static const struct sdtemp_dev_entry 100 sdtemp_dev_table[] = { 101 { MAXIM_MANUFACTURER_ID, MAX_6604_DEVICE_ID, 0xff, 3, 102 "Maxim MAX604" }, 103 { MCP_MANUFACTURER_ID, MCP_9805_DEVICE_ID, 0xff, 2, 104 "Microchip Tech MCP9805" }, 105 { MCP_MANUFACTURER_ID, MCP_98242_DEVICE_ID, 0xff, -4, 106 "Microchip Tech MCP98242" }, 107 { ADT_MANUFACTURER_ID, ADT_7408_DEVICE_ID, 0xff, 4, 108 "Analog Devices ADT7408" }, 109 { NXP_MANUFACTURER_ID, NXP_SE97_DEVICE_ID, 0xff, 3, 110 "NXP Semiconductors SE97/SE98" }, 111 { STTS_MANUFACTURER_ID, STTS_424E02_DEVICE_ID, 0x00, 2, 112 "STmicroelectronics STTS424E02-DA" }, 113 { STTS_MANUFACTURER_ID, STTS_424E02_DEVICE_ID, 0x01, 2, 114 "STmicroelectronics STTS424E02-DN" }, 115 { CAT_MANUFACTURER_ID, CAT_34TS02_DEVICE_ID, 0xff, 4, 116 "Catalyst CAT34TS02/CAT6095" }, 117 { 0, 0, 0, 2, "Unknown" } 118 }; 119 120 static int 121 sdtemp_lookup(uint16_t mfg, uint16_t dev, uint16_t rev) 122 { 123 int i; 124 125 for (i = 0; sdtemp_dev_table[i].sdtemp_mfg_id; i++) 126 if (sdtemp_dev_table[i].sdtemp_mfg_id == mfg && 127 sdtemp_dev_table[i].sdtemp_dev_id == dev && 128 (sdtemp_dev_table[i].sdtemp_rev_id == 0xff || 129 sdtemp_dev_table[i].sdtemp_rev_id == rev)) 130 break; 131 132 return i; 133 } 134 135 static int 136 sdtemp_match(device_t parent, cfdata_t cf, void *aux) 137 { 138 struct i2c_attach_args *ia = aux; 139 uint16_t mfgid, devid; 140 struct sdtemp_softc sc; 141 int i, error; 142 143 sc.sc_tag = ia->ia_tag; 144 sc.sc_address = ia->ia_addr; 145 146 if ((ia->ia_addr & SDTEMP_ADDRMASK) != SDTEMP_ADDR) 147 return 0; 148 149 /* Verify that we can read the manufacturer ID & Device ID */ 150 iic_acquire_bus(sc.sc_tag, 0); 151 error = sdtemp_read_16(&sc, SDTEMP_REG_MFG_ID, &mfgid) | 152 sdtemp_read_16(&sc, SDTEMP_REG_DEV_REV, &devid); 153 iic_release_bus(sc.sc_tag, 0); 154 155 if (error) 156 return 0; 157 158 i = sdtemp_lookup(mfgid, devid >> 8, devid & 0xff); 159 if (sdtemp_dev_table[i].sdtemp_mfg_id == 0) { 160 aprint_debug("sdtemp: No match for mfg 0x%04x dev 0x%02x " 161 "rev 0x%02x at address 0x%02x\n", mfgid, devid >> 8, 162 devid & 0xff, sc.sc_address); 163 return 0; 164 } 165 166 return 1; 167 } 168 169 static void 170 sdtemp_attach(device_t parent, device_t self, void *aux) 171 { 172 struct sdtemp_softc *sc = device_private(self); 173 struct i2c_attach_args *ia = aux; 174 sysmon_envsys_lim_t limits; 175 uint32_t props; 176 uint16_t mfgid, devid; 177 int i, error; 178 179 sc->sc_tag = ia->ia_tag; 180 sc->sc_address = ia->ia_addr; 181 sc->sc_dev = self; 182 183 iic_acquire_bus(sc->sc_tag, 0); 184 if ((error = sdtemp_read_16(sc, SDTEMP_REG_MFG_ID, &mfgid)) != 0 || 185 (error = sdtemp_read_16(sc, SDTEMP_REG_DEV_REV, &devid)) != 0) { 186 iic_release_bus(sc->sc_tag, 0); 187 aprint_error(": attach error %d\n", error); 188 return; 189 } 190 i = sdtemp_lookup(mfgid, devid >> 8, devid & 0xff); 191 sc->sc_resolution = 192 sdtemp_dev_table[i].sdtemp_resolution; 193 194 aprint_naive(": Temp Sensor\n"); 195 aprint_normal(": %s Temp Sensor\n", sdtemp_dev_table[i].sdtemp_desc); 196 197 if (sdtemp_dev_table[i].sdtemp_mfg_id == 0) 198 aprint_debug_dev(self, 199 "mfg 0x%04x dev 0x%02x rev 0x%02x at addr 0x%02x\n", 200 mfgid, devid >> 8, devid & 0xff, ia->ia_addr); 201 202 /* 203 * Alarm capability is required; if not present, this is likely 204 * not a real sdtemp device. 205 */ 206 error = sdtemp_read_16(sc, SDTEMP_REG_CAPABILITY, &sc->sc_capability); 207 if (error != 0 || (sc->sc_capability & SDTEMP_CAP_HAS_ALARM) == 0) { 208 iic_release_bus(sc->sc_tag, 0); 209 aprint_error_dev(self, 210 "required alarm capability not present!\n"); 211 return; 212 } 213 /* Set the configuration to defaults. */ 214 error = sdtemp_write_16(sc, SDTEMP_REG_CONFIG, 0); 215 if (error != 0) { 216 iic_release_bus(sc->sc_tag, 0); 217 aprint_error_dev(self, "error %d writing config register\n", 218 error); 219 return; 220 } 221 /* If variable resolution, set to max */ 222 if (sc->sc_resolution < 0) { 223 sc->sc_resolution = ~sc->sc_resolution; 224 error = sdtemp_write_16(sc, SDTEMP_REG_RESOLUTION, 225 sc->sc_resolution & 0x3); 226 if (error != 0) { 227 iic_release_bus(sc->sc_tag, 0); 228 aprint_error_dev(self, 229 "error %d writing resolution register\n", error); 230 return; 231 } else 232 sc->sc_resolution++; 233 } 234 iic_release_bus(sc->sc_tag, 0); 235 236 /* Hook us into the sysmon_envsys subsystem */ 237 sc->sc_sme = sysmon_envsys_create(); 238 sc->sc_sme->sme_name = device_xname(self); 239 sc->sc_sme->sme_cookie = sc; 240 sc->sc_sme->sme_refresh = sdtemp_refresh; 241 sc->sc_sme->sme_get_limits = sdtemp_get_limits; 242 sc->sc_sme->sme_set_limits = sdtemp_set_limits; 243 244 sc->sc_sensor = kmem_zalloc(sizeof(envsys_data_t), KM_NOSLEEP); 245 if (!sc->sc_sensor) { 246 aprint_error_dev(self, "unable to allocate sc_sensor\n"); 247 goto bad2; 248 } 249 250 /* Initialize sensor data. */ 251 sc->sc_sensor->units = ENVSYS_STEMP; 252 sc->sc_sensor->state = ENVSYS_SINVALID; 253 sc->sc_sensor->flags |= ENVSYS_FMONLIMITS; 254 (void)strlcpy(sc->sc_sensor->desc, device_xname(self), 255 sizeof(sc->sc_sensor->desc)); 256 257 /* Now attach the sensor */ 258 if (sysmon_envsys_sensor_attach(sc->sc_sme, sc->sc_sensor)) { 259 aprint_error_dev(self, "unable to attach sensor\n"); 260 goto bad; 261 } 262 263 /* Register the device */ 264 error = sysmon_envsys_register(sc->sc_sme); 265 if (error) { 266 aprint_error_dev(self, "error %d registering with sysmon\n", 267 error); 268 goto bad; 269 } 270 271 if (!pmf_device_register(self, sdtemp_pmf_suspend, sdtemp_pmf_resume)) 272 aprint_error_dev(self, "couldn't establish power handler\n"); 273 274 /* Retrieve and display hardware monitor limits */ 275 sdtemp_get_limits(sc->sc_sme, sc->sc_sensor, &limits, &props); 276 aprint_normal_dev(self, ""); 277 i = 0; 278 if (props & PROP_WARNMIN) { 279 aprint_normal("low limit %dC", __UK2C(limits.sel_warnmin)); 280 i++; 281 } 282 if (props & PROP_WARNMAX) { 283 aprint_normal("%shigh limit %dC ", (i)?", ":"", 284 __UK2C(limits.sel_warnmax)); 285 i++; 286 } 287 if (props & PROP_CRITMAX) { 288 aprint_normal("%scritical limit %dC ", (i)?", ":"", 289 __UK2C(limits.sel_critmax)); 290 i++; 291 } 292 if (i == 0) 293 aprint_normal("no hardware limits set\n"); 294 else 295 aprint_normal("\n"); 296 297 return; 298 299 bad: 300 kmem_free(sc->sc_sensor, sizeof(envsys_data_t)); 301 bad2: 302 sysmon_envsys_destroy(sc->sc_sme); 303 } 304 305 /* Retrieve current limits from device, and encode in uKelvins */ 306 static void 307 sdtemp_get_limits(struct sysmon_envsys *sme, envsys_data_t *edata, 308 sysmon_envsys_lim_t *limits, uint32_t *props) 309 { 310 struct sdtemp_softc *sc = sme->sme_cookie; 311 uint16_t lim; 312 313 *props = 0; 314 iic_acquire_bus(sc->sc_tag, 0); 315 if (sdtemp_read_16(sc, SDTEMP_REG_LOWER_LIM, &lim) == 0 && lim != 0) { 316 limits->sel_warnmin = sdtemp_decode_temp(sc, lim); 317 *props |= PROP_WARNMIN; 318 } 319 if (sdtemp_read_16(sc, SDTEMP_REG_UPPER_LIM, &lim) == 0 && lim != 0) { 320 limits->sel_warnmax = sdtemp_decode_temp(sc, lim); 321 *props |= PROP_WARNMAX; 322 } 323 if (sdtemp_read_16(sc, SDTEMP_REG_CRIT_LIM, &lim) == 0 && lim != 0) { 324 limits->sel_critmax = sdtemp_decode_temp(sc, lim); 325 *props |= PROP_CRITMAX; 326 } 327 iic_release_bus(sc->sc_tag, 0); 328 if (*props != 0) 329 *props |= PROP_DRIVER_LIMITS; 330 } 331 332 /* Send current limit values to the device */ 333 static void 334 sdtemp_set_limits(struct sysmon_envsys *sme, envsys_data_t *edata, 335 sysmon_envsys_lim_t *limits, uint32_t *props) 336 { 337 uint16_t val; 338 struct sdtemp_softc *sc = sme->sme_cookie; 339 340 iic_acquire_bus(sc->sc_tag, 0); 341 if (*props & PROP_WARNMIN) { 342 val = __UK2C(limits->sel_warnmin); 343 (void)sdtemp_write_16(sc, SDTEMP_REG_LOWER_LIM, 344 (val << 4) & SDTEMP_TEMP_MASK); 345 } 346 if (*props & PROP_WARNMAX) { 347 val = __UK2C(limits->sel_warnmax); 348 (void)sdtemp_write_16(sc, SDTEMP_REG_UPPER_LIM, 349 (val << 4) & SDTEMP_TEMP_MASK); 350 } 351 if (*props & PROP_CRITMAX) { 352 val = __UK2C(limits->sel_critmax); 353 (void)sdtemp_write_16(sc, SDTEMP_REG_CRIT_LIM, 354 (val << 4) & SDTEMP_TEMP_MASK); 355 } 356 iic_release_bus(sc->sc_tag, 0); 357 358 /* 359 * If at least one limit is set that we can handle, and no 360 * limits are set that we cannot handle, tell sysmon that 361 * the driver will take care of monitoring the limits! 362 */ 363 if (*props & (PROP_CRITMIN | PROP_BATTCAP | PROP_BATTWARN)) 364 *props &= ~PROP_DRIVER_LIMITS; 365 else if (*props & PROP_LIMITS) 366 *props |= PROP_DRIVER_LIMITS; 367 else 368 *props &= ~PROP_DRIVER_LIMITS; 369 } 370 371 #ifdef NOT_YET /* All registers on these sensors are 16-bits */ 372 373 /* Read a 8-bit value from a register */ 374 static int 375 sdtemp_read_8(struct sdtemp_softc *sc, uint8_t reg, uint8_t *valp) 376 { 377 int error; 378 379 error = iic_exec(sc->sc_tag, I2C_OP_READ_WITH_STOP, 380 sc->sc_address, ®, 1, valp, sizeof(*valp), 0); 381 382 return error; 383 } 384 385 static int 386 sdtemp_write_8(struct sdtemp_softc *sc, uint8_t reg, uint8_t val) 387 { 388 return iic_exec(sc->sc_tag, I2C_OP_WRITE_WITH_STOP, 389 sc->sc_address, ®, 1, &val, sizeof(val), 0); 390 } 391 #endif /* NOT_YET */ 392 393 /* Read a 16-bit value from a register */ 394 static int 395 sdtemp_read_16(struct sdtemp_softc *sc, uint8_t reg, uint16_t *valp) 396 { 397 int error; 398 399 error = iic_exec(sc->sc_tag, I2C_OP_READ_WITH_STOP, 400 sc->sc_address, ®, 1, valp, sizeof(*valp), 0); 401 if (error) 402 return error; 403 404 *valp = be16toh(*valp); 405 406 return 0; 407 } 408 409 static int 410 sdtemp_write_16(struct sdtemp_softc *sc, uint8_t reg, uint16_t val) 411 { 412 uint16_t temp; 413 414 temp = htobe16(val); 415 return iic_exec(sc->sc_tag, I2C_OP_WRITE_WITH_STOP, 416 sc->sc_address, ®, 1, &temp, sizeof(temp), 0); 417 } 418 419 static uint32_t 420 sdtemp_decode_temp(struct sdtemp_softc *sc, uint16_t temp) 421 { 422 uint32_t val; 423 int32_t stemp; 424 425 /* Get only the temperature bits */ 426 temp &= SDTEMP_TEMP_MASK; 427 428 /* If necessary, extend the sign bit */ 429 if ((sc->sc_capability & SDTEMP_CAP_WIDER_RANGE) && 430 (temp & SDTEMP_TEMP_NEGATIVE)) 431 temp |= SDTEMP_TEMP_SIGN_EXT; 432 433 /* Mask off only bits valid within current resolution */ 434 temp &= ~(0xf >> sc->sc_resolution); 435 436 /* Treat as signed and extend to 32-bits */ 437 stemp = (int16_t)temp; 438 439 /* Now convert from 0.0625 (1/16) deg C increments to microKelvins */ 440 val = (stemp * 62500) + 273150000; 441 442 return val; 443 } 444 445 static void 446 sdtemp_refresh(struct sysmon_envsys *sme, envsys_data_t *edata) 447 { 448 struct sdtemp_softc *sc = sme->sme_cookie; 449 uint16_t val; 450 int error; 451 452 iic_acquire_bus(sc->sc_tag, 0); 453 error = sdtemp_read_16(sc, SDTEMP_REG_AMBIENT_TEMP, &val); 454 iic_release_bus(sc->sc_tag, 0); 455 456 if (error) { 457 edata->state = ENVSYS_SINVALID; 458 return; 459 } 460 461 edata->value_cur = sdtemp_decode_temp(sc, val); 462 463 /* Now check for limits */ 464 if ((edata->upropset & PROP_DRIVER_LIMITS) == 0) 465 edata->state = ENVSYS_SVALID; 466 else if (val & SDTEMP_ABOVE_CRIT) 467 edata->state = ENVSYS_SCRITOVER; 468 else if (val & SDTEMP_ABOVE_UPPER) 469 edata->state = ENVSYS_SWARNOVER; 470 else if (val & SDTEMP_BELOW_LOWER) 471 edata->state = ENVSYS_SWARNUNDER; 472 else 473 edata->state = ENVSYS_SVALID; 474 } 475 476 /* 477 * power management functions 478 * 479 * We go into "shutdown" mode at suspend time, and return to normal 480 * mode upon resume. This reduces power consumption by disabling 481 * the A/D converter. 482 */ 483 484 static bool 485 sdtemp_pmf_suspend(device_t dev, const pmf_qual_t *qual) 486 { 487 struct sdtemp_softc *sc = device_private(dev); 488 int error; 489 uint16_t config; 490 491 iic_acquire_bus(sc->sc_tag, 0); 492 error = sdtemp_read_16(sc, SDTEMP_REG_CONFIG, &config); 493 if (error == 0) { 494 config |= SDTEMP_CONFIG_SHUTDOWN_MODE; 495 error = sdtemp_write_16(sc, SDTEMP_REG_CONFIG, config); 496 } 497 iic_release_bus(sc->sc_tag, 0); 498 return (error == 0); 499 } 500 501 static bool 502 sdtemp_pmf_resume(device_t dev, const pmf_qual_t *qual) 503 { 504 struct sdtemp_softc *sc = device_private(dev); 505 int error; 506 uint16_t config; 507 508 iic_acquire_bus(sc->sc_tag, 0); 509 error = sdtemp_read_16(sc, SDTEMP_REG_CONFIG, &config); 510 if (error == 0) { 511 config &= ~SDTEMP_CONFIG_SHUTDOWN_MODE; 512 error = sdtemp_write_16(sc, SDTEMP_REG_CONFIG, config); 513 } 514 iic_release_bus(sc->sc_tag, 0); 515 return (error == 0); 516 } 517
Indexes created Wed Oct 01 18:09:54 GMT 2025