sdtemp.c revision 1.5
1 /* $NetBSD: sdtemp.c,v 1.5 2009/06/13 20:27:19 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.5 2009/06/13 20:27:19 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 *, 66 sysmon_envsys_lim_t *); 67 static void sdtemp_set_limits(struct sysmon_envsys *, 68 sysmon_envsys_lim_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 PMF_FN_PROTO); 77 static bool sdtemp_pmf_resume(device_t PMF_FN_PROTO); 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 uint16_t mfgid, devid; 176 int i, error; 177 178 sc->sc_tag = ia->ia_tag; 179 sc->sc_address = ia->ia_addr; 180 sc->sc_dev = self; 181 182 iic_acquire_bus(sc->sc_tag, 0); 183 if ((error = sdtemp_read_16(sc, SDTEMP_REG_MFG_ID, &mfgid)) != 0 || 184 (error = sdtemp_read_16(sc, SDTEMP_REG_DEV_REV, &devid)) != 0) { 185 iic_release_bus(sc->sc_tag, 0); 186 aprint_error(": attach error %d\n", error); 187 return; 188 } 189 i = sdtemp_lookup(mfgid, devid >> 8, devid & 0xff); 190 sc->sc_resolution = 191 sdtemp_dev_table[i].sdtemp_resolution; 192 193 aprint_naive(": Temp Sensor\n"); 194 aprint_normal(": %s Temp Sensor\n", sdtemp_dev_table[i].sdtemp_desc); 195 196 if (sdtemp_dev_table[i].sdtemp_mfg_id == 0) 197 aprint_debug_dev(self, 198 "mfg 0x%04x dev 0x%02x rev 0x%02x at addr 0x%02x\n", 199 mfgid, devid >> 8, devid & 0xff, ia->ia_addr); 200 201 /* 202 * Alarm capability is required; if not present, this is likely 203 * not a real sdtemp device. 204 */ 205 error = sdtemp_read_16(sc, SDTEMP_REG_CAPABILITY, &sc->sc_capability); 206 if (error != 0 || (sc->sc_capability & SDTEMP_CAP_HAS_ALARM) == 0) { 207 iic_release_bus(sc->sc_tag, 0); 208 aprint_error_dev(self, 209 "required alarm capability not present!\n"); 210 return; 211 } 212 /* Set the configuration to defaults. */ 213 error = sdtemp_write_16(sc, SDTEMP_REG_CONFIG, 0); 214 if (error != 0) { 215 iic_release_bus(sc->sc_tag, 0); 216 aprint_error_dev(self, "error %d writing config register\n", 217 error); 218 return; 219 } 220 /* If variable resolution, set to max */ 221 if (sc->sc_resolution < 0) { 222 sc->sc_resolution = ~sc->sc_resolution; 223 error = sdtemp_write_16(sc, SDTEMP_REG_RESOLUTION, 224 sc->sc_resolution & 0x3); 225 if (error != 0) { 226 iic_release_bus(sc->sc_tag, 0); 227 aprint_error_dev(self, 228 "error %d writing resolution register\n", error); 229 return; 230 } else 231 sc->sc_resolution++; 232 } 233 iic_release_bus(sc->sc_tag, 0); 234 235 /* Hook us into the sysmon_envsys subsystem */ 236 sc->sc_sme = sysmon_envsys_create(); 237 sc->sc_sme->sme_name = device_xname(self); 238 sc->sc_sme->sme_cookie = sc; 239 sc->sc_sme->sme_refresh = sdtemp_refresh; 240 sc->sc_sme->sme_get_limits = sdtemp_get_limits; 241 sc->sc_sme->sme_set_limits = sdtemp_set_limits; 242 243 sc->sc_sensor = kmem_zalloc(sizeof(envsys_data_t), KM_NOSLEEP); 244 if (!sc->sc_sensor) { 245 aprint_error_dev(self, "unable to allocate sc_sensor\n"); 246 goto bad2; 247 } 248 249 /* Initialize sensor data. */ 250 sc->sc_sensor->units = ENVSYS_STEMP; 251 sc->sc_sensor->state = ENVSYS_SINVALID; 252 sc->sc_sensor->flags |= ENVSYS_FMONLIMITS; 253 sc->sc_sensor->monitor = true; 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, &limits); 276 aprint_normal_dev(self, ""); 277 i = 0; 278 if (limits.sel_flags & PROP_WARNMIN) { 279 aprint_normal("low limit %dC", __UK2C(limits.sel_warnmin)); 280 i++; 281 } 282 if (limits.sel_flags & PROP_WARNMAX) { 283 aprint_normal("%shigh limit %dC ", (i)?", ":"", 284 __UK2C(limits.sel_warnmax)); 285 i++; 286 } 287 if (limits.sel_flags & 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, sysmon_envsys_lim_t *limits) 308 { 309 struct sdtemp_softc *sc = sme->sme_cookie; 310 uint16_t lim; 311 312 limits->sel_flags = PROP_DRIVER_LIMITS; 313 iic_acquire_bus(sc->sc_tag, 0); 314 if (sdtemp_read_16(sc, SDTEMP_REG_LOWER_LIM, &lim) == 0 && lim != 0) { 315 limits->sel_warnmin = sdtemp_decode_temp(sc, lim); 316 limits->sel_flags |= PROP_WARNMIN; 317 } 318 if (sdtemp_read_16(sc, SDTEMP_REG_UPPER_LIM, &lim) == 0 && lim != 0) { 319 limits->sel_warnmax = sdtemp_decode_temp(sc, lim); 320 limits->sel_flags |= PROP_WARNMAX; 321 } 322 if (sdtemp_read_16(sc, SDTEMP_REG_CRIT_LIM, &lim) == 0 && lim != 0) { 323 limits->sel_critmax = sdtemp_decode_temp(sc, lim); 324 limits->sel_flags |= PROP_CRITMAX; 325 } 326 iic_release_bus(sc->sc_tag, 0); 327 } 328 329 /* Send current limit values to the device */ 330 static void 331 sdtemp_set_limits(struct sysmon_envsys *sme, sysmon_envsys_lim_t *limits) 332 { 333 uint16_t val; 334 struct sdtemp_softc *sc = sme->sme_cookie; 335 336 iic_acquire_bus(sc->sc_tag, 0); 337 if (limits->sel_flags & PROP_WARNMIN) { 338 val = __UK2C(limits->sel_warnmin); 339 (void)sdtemp_write_16(sc, SDTEMP_REG_LOWER_LIM, 340 (val << 4) & SDTEMP_TEMP_MASK); 341 } 342 if (limits->sel_flags & PROP_WARNMAX) { 343 val = __UK2C(limits->sel_warnmax); 344 (void)sdtemp_write_16(sc, SDTEMP_REG_UPPER_LIM, 345 (val << 4) & SDTEMP_TEMP_MASK); 346 } 347 if (limits->sel_flags & PROP_CRITMAX) { 348 val = __UK2C(limits->sel_critmax); 349 (void)sdtemp_write_16(sc, SDTEMP_REG_CRIT_LIM, 350 (val << 4) & SDTEMP_TEMP_MASK); 351 } 352 iic_release_bus(sc->sc_tag, 0); 353 354 /* 355 * If at least one limit is set that we can handle, and no 356 * limits are set that we cannot handle, tell sysmon that 357 * the driver will take care of monitoring the limits! 358 */ 359 if (limits->sel_flags & (PROP_CRITMIN | PROP_BATTCAP | PROP_BATTWARN)) 360 limits->sel_flags &= ~PROP_DRIVER_LIMITS; 361 else if (limits->sel_flags & PROP_LIMITS) 362 limits->sel_flags |= PROP_DRIVER_LIMITS; 363 else 364 limits->sel_flags &= ~PROP_DRIVER_LIMITS; 365 } 366 367 #ifdef NOT_YET /* All registers on these sensors are 16-bits */ 368 369 /* Read a 8-bit value from a register */ 370 static int 371 sdtemp_read_8(struct sdtemp_softc *sc, uint8_t reg, uint8_t *valp) 372 { 373 int error; 374 375 error = iic_exec(sc->sc_tag, I2C_OP_READ_WITH_STOP, 376 sc->sc_address, ®, 1, valp, sizeof(*valp), 0); 377 378 return error; 379 } 380 381 static int 382 sdtemp_write_8(struct sdtemp_softc *sc, uint8_t reg, uint8_t val) 383 { 384 return iic_exec(sc->sc_tag, I2C_OP_WRITE_WITH_STOP, 385 sc->sc_address, ®, 1, &val, sizeof(val), 0); 386 } 387 #endif /* NOT_YET */ 388 389 /* Read a 16-bit value from a register */ 390 static int 391 sdtemp_read_16(struct sdtemp_softc *sc, uint8_t reg, uint16_t *valp) 392 { 393 int error; 394 395 error = iic_exec(sc->sc_tag, I2C_OP_READ_WITH_STOP, 396 sc->sc_address, ®, 1, valp, sizeof(*valp), 0); 397 if (error) 398 return error; 399 400 *valp = be16toh(*valp); 401 402 return 0; 403 } 404 405 static int 406 sdtemp_write_16(struct sdtemp_softc *sc, uint8_t reg, uint16_t val) 407 { 408 uint16_t temp; 409 410 temp = htobe16(val); 411 return iic_exec(sc->sc_tag, I2C_OP_WRITE_WITH_STOP, 412 sc->sc_address, ®, 1, &temp, sizeof(temp), 0); 413 } 414 415 static uint32_t 416 sdtemp_decode_temp(struct sdtemp_softc *sc, uint16_t temp) 417 { 418 uint32_t val; 419 int32_t stemp; 420 421 /* Get only the temperature bits */ 422 temp &= SDTEMP_TEMP_MASK; 423 424 /* If necessary, extend the sign bit */ 425 if ((sc->sc_capability & SDTEMP_CAP_WIDER_RANGE) && 426 (temp & SDTEMP_TEMP_NEGATIVE)) 427 temp |= SDTEMP_TEMP_SIGN_EXT; 428 429 /* Mask off only bits valid within current resolution */ 430 temp &= ~(0xf >> sc->sc_resolution); 431 432 /* Treat as signed and extend to 32-bits */ 433 stemp = (int16_t)temp; 434 435 /* Now convert from 0.0625 (1/16) deg C increments to microKelvins */ 436 val = (stemp * 62500) + 273150000; 437 438 return val; 439 } 440 441 static void 442 sdtemp_refresh(struct sysmon_envsys *sme, envsys_data_t *edata) 443 { 444 struct sdtemp_softc *sc = sme->sme_cookie; 445 uint16_t val; 446 int error; 447 448 iic_acquire_bus(sc->sc_tag, 0); 449 error = sdtemp_read_16(sc, SDTEMP_REG_AMBIENT_TEMP, &val); 450 iic_release_bus(sc->sc_tag, 0); 451 452 if (error) { 453 edata->state = ENVSYS_SINVALID; 454 return; 455 } 456 457 edata->value_cur = sdtemp_decode_temp(sc, val); 458 459 /* Now check for limits */ 460 if ((edata->upropset & PROP_DRIVER_LIMITS) == 0) 461 edata->state = ENVSYS_SVALID; 462 else if (val & SDTEMP_ABOVE_CRIT) 463 edata->state = ENVSYS_SCRITOVER; 464 else if (val & SDTEMP_ABOVE_UPPER) 465 edata->state = ENVSYS_SWARNOVER; 466 else if (val & SDTEMP_BELOW_LOWER) 467 edata->state = ENVSYS_SWARNUNDER; 468 else 469 edata->state = ENVSYS_SVALID; 470 } 471 472 /* 473 * power management functions 474 * 475 * We go into "shutdown" mode at suspend time, and return to normal 476 * mode upon resume. This reduces power consumption by disabling 477 * the A/D converter. 478 */ 479 480 static bool 481 sdtemp_pmf_suspend(device_t dev PMF_FN_ARGS) 482 { 483 struct sdtemp_softc *sc = device_private(dev); 484 int error; 485 uint16_t config; 486 487 iic_acquire_bus(sc->sc_tag, 0); 488 error = sdtemp_read_16(sc, SDTEMP_REG_CONFIG, &config); 489 if (error == 0) { 490 config |= SDTEMP_CONFIG_SHUTDOWN_MODE; 491 error = sdtemp_write_16(sc, SDTEMP_REG_CONFIG, config); 492 } 493 iic_release_bus(sc->sc_tag, 0); 494 return (error == 0); 495 } 496 497 static bool 498 sdtemp_pmf_resume(device_t dev PMF_FN_ARGS) 499 { 500 struct sdtemp_softc *sc = device_private(dev); 501 int error; 502 uint16_t config; 503 504 iic_acquire_bus(sc->sc_tag, 0); 505 error = sdtemp_read_16(sc, SDTEMP_REG_CONFIG, &config); 506 if (error == 0) { 507 config &= ~SDTEMP_CONFIG_SHUTDOWN_MODE; 508 error = sdtemp_write_16(sc, SDTEMP_REG_CONFIG, config); 509 } 510 iic_release_bus(sc->sc_tag, 0); 511 return (error == 0); 512 } 513
Indexes created Thu Sep 25 15:09:46 GMT 2025