nslm7x.c revision 1.41
1 /* $NetBSD: nslm7x.c,v 1.41 2007/09/08 03:38:35 xtraeme Exp $ */ 2 3 /*- 4 * Copyright (c) 2000 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Bill Squier. 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 * 3. All advertising materials mentioning features or use of this software 19 * must display the following acknowledgement: 20 * This product includes software developed by the NetBSD 21 * Foundation, Inc. and its contributors. 22 * 4. Neither the name of The NetBSD Foundation nor the names of its 23 * contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 27 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 28 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 29 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 36 * POSSIBILITY OF SUCH DAMAGE. 37 */ 38 39 #include <sys/cdefs.h> 40 __KERNEL_RCSID(0, "$NetBSD: nslm7x.c,v 1.41 2007/09/08 03:38:35 xtraeme Exp $"); 41 42 #include <sys/param.h> 43 #include <sys/systm.h> 44 #include <sys/kernel.h> 45 #include <sys/proc.h> 46 #include <sys/device.h> 47 #include <sys/conf.h> 48 #include <sys/time.h> 49 50 #include <machine/bus.h> 51 52 #include <dev/isa/isareg.h> 53 #include <dev/isa/isavar.h> 54 55 #include <dev/sysmon/sysmonvar.h> 56 57 #include <dev/ic/nslm7xvar.h> 58 59 #include <machine/intr.h> 60 61 #if defined(LMDEBUG) 62 #define DPRINTF(x) do { printf x; } while (0) 63 #else 64 #define DPRINTF(x) 65 #endif 66 67 /* 68 * LM78-compatible chips can typically measure voltages up to 4.096 V. 69 * To measure higher voltages the input is attenuated with (external) 70 * resistors. Negative voltages are measured using inverting op amps 71 * and resistors. So we have to convert the sensor values back to 72 * real voltages by applying the appropriate resistor factor. 73 */ 74 #define RFACT_NONE 10000 75 #define RFACT(x, y) (RFACT_NONE * ((x) + (y)) / (y)) 76 #define NRFACT(x, y) (-RFACT_NONE * (x) / (y)) 77 78 #define LM_REFRESH_TIMO (2 * hz) /* 2 seconds */ 79 80 static int lm_match(struct lm_softc *); 81 static int wb_match(struct lm_softc *); 82 static int def_match(struct lm_softc *); 83 84 static void lm_refresh(void *); 85 86 static void lm_generic_banksel(struct lm_softc *, int); 87 static void lm_setup_sensors(struct lm_softc *, struct lm_sensor *); 88 static void lm_refresh_sensor_data(struct lm_softc *); 89 static void lm_refresh_volt(struct lm_softc *, int); 90 static void lm_refresh_temp(struct lm_softc *, int); 91 static void lm_refresh_fanrpm(struct lm_softc *, int); 92 93 static void wb_refresh_sensor_data(struct lm_softc *); 94 static void wb_w83637hf_refresh_vcore(struct lm_softc *, int); 95 static void wb_refresh_nvolt(struct lm_softc *, int); 96 static void wb_w83627ehf_refresh_nvolt(struct lm_softc *, int); 97 static void wb_refresh_temp(struct lm_softc *, int); 98 static void wb_refresh_fanrpm(struct lm_softc *, int); 99 static void wb_w83792d_refresh_fanrpm(struct lm_softc *, int); 100 101 static void as_refresh_temp(struct lm_softc *, int); 102 103 struct lm_chip { 104 int (*chip_match)(struct lm_softc *); 105 }; 106 107 static struct lm_chip lm_chips[] = { 108 { wb_match }, 109 { lm_match }, 110 { def_match } /* Must be last */ 111 }; 112 113 /* LM78/78J/79/81 */ 114 static struct lm_sensor lm78_sensors[] = { 115 /* Voltage */ 116 { 117 .desc = "VCore A", 118 .type = ENVSYS_SVOLTS_DC, 119 .bank = 0, 120 .reg = 0x20, 121 .refresh = lm_refresh_volt, 122 .rfact = RFACT_NONE 123 }, 124 { 125 .desc = "VCore B", 126 .type = ENVSYS_SVOLTS_DC, 127 .bank = 0, 128 .reg = 0x21, 129 .refresh = lm_refresh_volt, 130 .rfact = RFACT_NONE 131 }, 132 { 133 .desc = "+3.3V", 134 .type = ENVSYS_SVOLTS_DC, 135 .bank = 0, 136 .reg = 0x22, 137 .refresh = lm_refresh_volt, 138 .rfact = RFACT_NONE 139 }, 140 { 141 .desc = "+5V", 142 .type = ENVSYS_SVOLTS_DC, 143 .bank = 0, 144 .reg = 0x23, 145 .refresh = lm_refresh_volt, 146 .rfact = RFACT(68, 100) 147 }, 148 { 149 .desc = "+12V", 150 .type = ENVSYS_SVOLTS_DC, 151 .bank = 0, 152 .reg = 0x24, 153 .refresh = lm_refresh_volt, 154 .rfact = RFACT(30, 10) 155 }, 156 { 157 .desc = "-12V", 158 .type = ENVSYS_SVOLTS_DC, 159 .bank = 0, 160 .reg = 0x25, 161 .refresh = lm_refresh_volt, 162 .rfact = NRFACT(240, 60) 163 }, 164 { 165 .desc = "-5V", 166 .type = ENVSYS_SVOLTS_DC, 167 .bank = 0, 168 .reg = 0x26, 169 .refresh = lm_refresh_volt, 170 .rfact = NRFACT(100, 60) 171 }, 172 173 /* Temperature */ 174 { 175 .desc = "Temp0", 176 .type = ENVSYS_STEMP, 177 .bank = 0, 178 .reg = 0x27, 179 .refresh = lm_refresh_temp, 180 .rfact = 0 181 }, 182 183 /* Fans */ 184 { 185 .desc = "Fan0", 186 .type = ENVSYS_SFANRPM, 187 .bank = 0, 188 .reg = 0x28, 189 .refresh = lm_refresh_fanrpm, 190 .rfact = 0 191 }, 192 { 193 .desc = "Fan1", 194 .type = ENVSYS_SFANRPM, 195 .bank = 0, 196 .reg = 0x29, 197 .refresh = lm_refresh_fanrpm, 198 .rfact = 0 199 }, 200 { 201 .desc = "Fan2", 202 .type = ENVSYS_SFANRPM, 203 .bank = 0, 204 .reg = 0x2a, 205 .refresh = lm_refresh_fanrpm, 206 .rfact = 0 207 }, 208 209 { .desc = NULL } 210 }; 211 212 /* W83627HF */ 213 static struct lm_sensor w83627hf_sensors[] = { 214 /* Voltage */ 215 { 216 .desc = "VCore A", 217 .type = ENVSYS_SVOLTS_DC, 218 .bank = 0, 219 .reg = 0x20, 220 .refresh = lm_refresh_volt, 221 .rfact = RFACT_NONE 222 }, 223 { 224 .desc = "VCore B", 225 .type = ENVSYS_SVOLTS_DC, 226 .bank = 0, 227 .reg = 0x21, 228 .refresh = lm_refresh_volt, 229 .rfact = RFACT_NONE 230 }, 231 { 232 .desc = "+3.3V", 233 .type = ENVSYS_SVOLTS_DC, 234 .bank = 0, 235 .reg = 0x22, 236 .refresh = lm_refresh_volt, 237 .rfact = RFACT_NONE 238 }, 239 { 240 .desc = "+5V", 241 .type = ENVSYS_SVOLTS_DC, 242 .bank = 0, 243 .reg = 0x23, 244 .refresh = lm_refresh_volt, 245 .rfact = RFACT(34, 50) 246 }, 247 { 248 .desc = "+12V", 249 .type = ENVSYS_SVOLTS_DC, 250 .bank = 0, 251 .reg = 0x24, 252 .refresh = lm_refresh_volt, 253 .rfact = RFACT(28, 10) 254 }, 255 { 256 .desc = "-12V", 257 .type = ENVSYS_SVOLTS_DC, 258 .bank = 0, 259 .reg = 0x25, 260 .refresh = wb_refresh_nvolt, 261 .rfact = RFACT(232, 56) 262 }, 263 { 264 .desc = "-5V", 265 .type = ENVSYS_SVOLTS_DC, 266 .bank = 0, 267 .reg = 0x26, 268 .refresh = wb_refresh_nvolt, 269 .rfact = RFACT(120, 56) 270 }, 271 { 272 .desc = "5VSB", 273 .type = ENVSYS_SVOLTS_DC, 274 .bank = 5, 275 .reg = 0x50, 276 .refresh = lm_refresh_volt, 277 .rfact = RFACT(17, 33) 278 }, 279 { 280 .desc = "VBAT", 281 .type = ENVSYS_SVOLTS_DC, 282 .bank = 5, 283 .reg = 0x51, 284 .refresh = lm_refresh_volt, 285 .rfact = RFACT_NONE 286 }, 287 288 /* Temperature */ 289 { 290 .desc = "Temp0", 291 .type = ENVSYS_STEMP, 292 .bank = 0, 293 .reg = 0x27, 294 .refresh = lm_refresh_temp, 295 .rfact = 0 296 }, 297 { 298 .desc = "Temp1", 299 .type = ENVSYS_STEMP, 300 .bank = 1, 301 .reg = 0x50, 302 .refresh = wb_refresh_temp, 303 .rfact = 0 304 }, 305 { 306 .desc = "Temp2", 307 .type = ENVSYS_STEMP, 308 .bank = 2, 309 .reg = 0x50, 310 .refresh = wb_refresh_temp, 311 .rfact = 0 312 }, 313 314 /* Fans */ 315 { 316 .desc = "Fan0", 317 .type = ENVSYS_SFANRPM, 318 .bank = 0, 319 .reg = 0x28, 320 .refresh = wb_refresh_fanrpm, 321 .rfact = 0 322 }, 323 { 324 .desc = "Fan1", 325 .type = ENVSYS_SFANRPM, 326 .bank = 0, 327 .reg = 0x29, 328 .refresh = wb_refresh_fanrpm, 329 .rfact = 0 330 }, 331 { 332 .desc = "Fan2", 333 .type = ENVSYS_SFANRPM, 334 .bank = 0, 335 .reg = 0x2a, 336 .refresh = wb_refresh_fanrpm, 337 .rfact = 0 338 }, 339 340 { .desc = NULL } 341 }; 342 343 /* W8627EHF */ 344 345 /* 346 * The W83627EHF can measure voltages up to 2.048 V instead of the 347 * traditional 4.096 V. For measuring positive voltages, this can be 348 * accounted for by halving the resistor factor. Negative voltages 349 * need special treatment, also because the reference voltage is 2.048 V 350 * instead of the traditional 3.6 V. 351 */ 352 static struct lm_sensor w83627ehf_sensors[] = { 353 /* Voltage */ 354 { 355 .desc = "VCore", 356 .type = ENVSYS_SVOLTS_DC, 357 .bank = 0, 358 .reg = 0x20, 359 .refresh = lm_refresh_volt, 360 .rfact = RFACT_NONE / 2 361 }, 362 { 363 .desc = "+12V", 364 .type = ENVSYS_SVOLTS_DC, 365 .bank = 0, 366 .reg = 0x21, 367 .refresh = lm_refresh_volt, 368 .rfact = RFACT(56, 10) / 2 369 }, 370 { 371 .desc = "+3.3V", 372 .type = ENVSYS_SVOLTS_DC, 373 .bank = 0, 374 .reg = 0x22, 375 .refresh = lm_refresh_volt, 376 .rfact = RFACT(34, 34) / 2 377 }, 378 { 379 .desc = "VIN3", 380 .type = ENVSYS_SVOLTS_DC, 381 .bank = 0, 382 .reg = 0x23, 383 .refresh = lm_refresh_volt, 384 .rfact = RFACT(34, 34) / 2 385 }, 386 { 387 .desc = "-12V", 388 .type = ENVSYS_SVOLTS_DC, 389 .bank = 0, 390 .reg = 0x24, 391 .refresh = wb_w83627ehf_refresh_nvolt, 392 .rfact = 0 393 }, 394 { 395 .desc = "VIN5", 396 .type = ENVSYS_SVOLTS_DC, 397 .bank = 0, 398 .reg = 0x25, 399 .refresh = lm_refresh_volt, 400 .rfact = RFACT_NONE / 2 401 }, 402 { 403 .desc = "VIN6", 404 .type = ENVSYS_SVOLTS_DC, 405 .bank = 0, 406 .reg = 0x26, 407 .refresh = lm_refresh_volt, 408 .rfact = RFACT_NONE / 2 409 }, 410 { 411 .desc = "3.3VSB", 412 .type = ENVSYS_SVOLTS_DC, 413 .bank = 5, 414 .reg = 0x50, 415 .refresh = lm_refresh_volt, 416 .rfact = RFACT(34, 34) / 2 417 }, 418 { 419 .desc = "VBAT", 420 .type = ENVSYS_SVOLTS_DC, 421 .bank = 5, 422 .reg = 0x51, 423 .refresh = lm_refresh_volt, 424 .rfact = RFACT_NONE / 2 425 }, 426 { 427 .desc = "VIN8", 428 .type = ENVSYS_SVOLTS_DC, 429 .bank = 5, 430 .reg = 0x52, 431 .refresh = lm_refresh_volt, 432 .rfact = RFACT_NONE / 2 433 }, 434 435 /* Temperature */ 436 { 437 .desc = "Temp0", 438 .type = ENVSYS_STEMP, 439 .bank = 0, 440 .reg = 0x27, 441 .refresh = lm_refresh_temp, 442 .rfact = 0 443 }, 444 { 445 .desc = "Temp1", 446 .type = ENVSYS_STEMP, 447 .bank = 1, 448 .reg = 0x50, 449 .refresh = wb_refresh_temp, 450 .rfact = 0 451 }, 452 { 453 .desc = "Temp2", 454 .type = ENVSYS_STEMP, 455 .bank = 2, 456 .reg = 0x50, 457 .refresh = wb_refresh_temp, 458 .rfact = 0 459 }, 460 461 /* Fans */ 462 { 463 .desc = "Fan0", 464 .type = ENVSYS_SFANRPM, 465 .bank = 0, 466 .reg = 0x28, 467 .refresh = wb_refresh_fanrpm, 468 .rfact = 0 469 }, 470 { 471 .desc = "Fan1", 472 .type = ENVSYS_SFANRPM, 473 .bank = 0, 474 .reg = 0x29, 475 .refresh = wb_refresh_fanrpm, 476 .rfact = 0 477 }, 478 { 479 .desc = "Fan2", 480 .type = ENVSYS_SFANRPM, 481 .bank = 0, 482 .reg = 0x2a, 483 .refresh = wb_refresh_fanrpm, 484 .rfact = 0 485 }, 486 487 { .desc = NULL } 488 }; 489 490 /* W83627DHG */ 491 static struct lm_sensor w83627dhg_sensors[] = { 492 /* Voltage */ 493 { 494 .desc = "VCore", 495 .type = ENVSYS_SVOLTS_DC, 496 .bank = 0, 497 .reg = 0x20, 498 .refresh = lm_refresh_volt, 499 .rfact = RFACT_NONE / 2 500 }, 501 { 502 .desc = "+12V", 503 .type = ENVSYS_SVOLTS_DC, 504 .bank = 0, 505 .reg = 0x21, 506 .refresh = lm_refresh_volt, 507 .rfact = RFACT(56, 10) / 2 508 }, 509 { 510 .desc = "AVCC", 511 .type = ENVSYS_SVOLTS_DC, 512 .bank = 0, 513 .reg = 0x22, 514 .refresh = lm_refresh_volt, 515 .rfact = RFACT(34, 34) / 2 516 }, 517 { 518 .desc = "+3.3V", 519 .type = ENVSYS_SVOLTS_DC, 520 .bank = 0, 521 .reg = 0x23, 522 .refresh = lm_refresh_volt, 523 .rfact = RFACT(34, 34) / 2 524 }, 525 { 526 .desc = "VIN1", 527 .type = ENVSYS_SVOLTS_DC, 528 .bank = 0, 529 .reg = 0x24, 530 .refresh = wb_w83627ehf_refresh_nvolt, 531 .rfact = 0 532 }, 533 { 534 .desc = "+5V", 535 .type = ENVSYS_SVOLTS_DC, 536 .bank = 0, 537 .reg = 0x25, 538 .refresh = lm_refresh_volt, 539 .rfact = 16000 540 }, 541 { 542 .desc = "VIN3", 543 .type = ENVSYS_SVOLTS_DC, 544 .bank = 0, 545 .reg = 0x26, 546 .refresh = lm_refresh_volt, 547 .rfact = RFACT_NONE / 2 548 }, 549 { 550 .desc = "+3.3VSB", 551 .type = ENVSYS_SVOLTS_DC, 552 .bank = 5, 553 .reg = 0x50, 554 .refresh = lm_refresh_volt, 555 .rfact = RFACT(34, 34) / 2 556 }, 557 { 558 .desc = "VBAT", 559 .type = ENVSYS_SVOLTS_DC, 560 .bank = 5, 561 .reg = 0x51, 562 .refresh = lm_refresh_volt, 563 .rfact = RFACT_NONE / 2 564 }, 565 566 /* Temperature */ 567 { 568 .desc = "MB Temperature", 569 .type = ENVSYS_STEMP, 570 .bank = 0, 571 .reg = 0x27, 572 .refresh = lm_refresh_temp, 573 .rfact = 0 574 }, 575 { 576 .desc = "CPU Temperature", 577 .type = ENVSYS_STEMP, 578 .bank = 1, 579 .reg = 0x50, 580 .refresh = lm_refresh_temp, 581 .rfact = 0 582 }, 583 { 584 .desc = "Aux Temp", 585 .type = ENVSYS_STEMP, 586 .bank = 2, 587 .reg = 0x50, 588 .refresh = lm_refresh_temp, 589 .rfact = 0 590 }, 591 592 /* Fans */ 593 { 594 .desc = "System Fan", 595 .type = ENVSYS_SFANRPM, 596 .bank = 0, 597 .reg = 0x28, 598 .refresh = wb_refresh_fanrpm, 599 .rfact = 0 600 }, 601 { 602 .desc = "CPU Fan", 603 .type = ENVSYS_SFANRPM, 604 .bank = 0, 605 .reg = 0x29, 606 .refresh = wb_refresh_fanrpm, 607 .rfact = 0 608 }, 609 { 610 .desc = "Aux Fan", 611 .type = ENVSYS_SFANRPM, 612 .bank = 0, 613 .reg = 0x2a, 614 .refresh = wb_refresh_fanrpm, 615 .rfact = 0 616 }, 617 618 { .desc = NULL } 619 }; 620 621 /* W83637HF */ 622 static struct lm_sensor w83637hf_sensors[] = { 623 /* Voltage */ 624 { 625 .desc = "VCore", 626 .type = ENVSYS_SVOLTS_DC, 627 .bank = 0, 628 .reg = 0x20, 629 .refresh = wb_w83637hf_refresh_vcore, 630 .rfact = 0 631 }, 632 { 633 .desc = "+12V", 634 .type = ENVSYS_SVOLTS_DC, 635 .bank = 0, 636 .reg = 0x21, 637 .refresh = lm_refresh_volt, 638 .rfact = RFACT(28, 10) 639 }, 640 { 641 .desc = "+3.3V", 642 .type = ENVSYS_SVOLTS_DC, 643 .bank = 0, 644 .reg = 0x22, 645 .refresh = lm_refresh_volt, 646 .rfact = RFACT_NONE 647 }, 648 { 649 .desc = "+5V", 650 .type = ENVSYS_SVOLTS_DC, 651 .bank = 0, 652 .reg = 0x23, 653 .refresh = lm_refresh_volt, 654 .rfact = RFACT(34, 51) 655 }, 656 { 657 .desc = "-12V", 658 .type = ENVSYS_SVOLTS_DC, 659 .bank = 0, 660 .reg = 0x24, 661 .refresh = wb_refresh_nvolt, 662 .rfact = RFACT(232, 56) 663 }, 664 { 665 .desc = "5VSB", 666 .type = ENVSYS_SVOLTS_DC, 667 .bank = 5, 668 .reg = 0x50, 669 .refresh = lm_refresh_volt, 670 .rfact = RFACT(34, 51) 671 }, 672 { 673 .desc = "VBAT", 674 .type = ENVSYS_SVOLTS_DC, 675 .bank = 5, 676 .reg = 0x51, 677 .refresh = lm_refresh_volt, 678 .rfact = RFACT_NONE 679 }, 680 681 /* Temperature */ 682 { 683 .desc = "Temp0", 684 .type = ENVSYS_STEMP, 685 .bank = 0, 686 .reg = 0x27, 687 .refresh = lm_refresh_temp, 688 .rfact = 0 689 }, 690 { 691 .desc = "Temp1", 692 .type = ENVSYS_STEMP, 693 .bank = 1, 694 .reg = 0x50, 695 .refresh = wb_refresh_temp, 696 .rfact = 0 697 }, 698 { 699 .desc = "Temp2", 700 .type = ENVSYS_STEMP, 701 .bank = 2, 702 .reg = 0x50, 703 .refresh = wb_refresh_temp, 704 .rfact = 0 705 }, 706 707 /* Fans */ 708 { 709 .desc = "Fan0", 710 .type = ENVSYS_SFANRPM, 711 .bank = 0, 712 .reg = 0x28, 713 .refresh = wb_refresh_fanrpm, 714 .rfact = 0 715 }, 716 { 717 .desc = "Fan1", 718 .type = ENVSYS_SFANRPM, 719 .bank = 0, 720 .reg = 0x29, 721 .refresh = wb_refresh_fanrpm, 722 .rfact = 0 723 }, 724 { 725 .desc = "Fan2", 726 .type = ENVSYS_SFANRPM, 727 .bank = 0, 728 .reg = 0x2a, 729 .refresh = wb_refresh_fanrpm, 730 .rfact = 0 731 }, 732 733 { .desc = NULL } 734 }; 735 736 /* W83697HF */ 737 static struct lm_sensor w83697hf_sensors[] = { 738 /* Voltage */ 739 { 740 .desc = "VCore", 741 .type = ENVSYS_SVOLTS_DC, 742 .bank = 0, 743 .reg = 0x20, 744 .refresh = lm_refresh_volt, 745 .rfact = RFACT_NONE 746 }, 747 { 748 .desc = "+3.3V", 749 .type = ENVSYS_SVOLTS_DC, 750 .bank = 0, 751 .reg = 0x22, 752 .refresh = lm_refresh_volt, 753 .rfact = RFACT_NONE 754 }, 755 { 756 .desc = "+5V", 757 .type = ENVSYS_SVOLTS_DC, 758 .bank = 0, 759 .reg = 0x23, 760 .refresh = lm_refresh_volt, 761 .rfact = RFACT(34, 50) 762 }, 763 { 764 .desc = "+12V", 765 .type = ENVSYS_SVOLTS_DC, 766 .bank = 0, 767 .reg = 0x24, 768 .refresh = lm_refresh_volt, 769 .rfact = RFACT(28, 10) 770 }, 771 { 772 .desc = "-12V", 773 .type = ENVSYS_SVOLTS_DC, 774 .bank = 0, 775 .reg = 0x25, 776 .refresh = wb_refresh_nvolt, 777 .rfact = RFACT(232, 56) 778 }, 779 { 780 .desc = "-5V", 781 .type = ENVSYS_SVOLTS_DC, 782 .bank = 0, 783 .reg = 0x26, 784 .refresh = wb_refresh_nvolt, 785 .rfact = RFACT(120, 56) 786 }, 787 { 788 .desc = "5VSB", 789 .type = ENVSYS_SVOLTS_DC, 790 .bank = 5, 791 .reg = 0x50, 792 .refresh = lm_refresh_volt, 793 .rfact = RFACT(17, 33) 794 }, 795 { 796 .desc = "VBAT", 797 .type = ENVSYS_SVOLTS_DC, 798 .bank = 5, 799 .reg = 0x51, 800 .refresh = lm_refresh_volt, 801 .rfact = RFACT_NONE 802 }, 803 804 /* Temperature */ 805 { 806 .desc = "Temp0", 807 .type = ENVSYS_STEMP, 808 .bank = 0, 809 .reg = 0x27, 810 .refresh = lm_refresh_temp, 811 .rfact = 0 812 }, 813 { 814 .desc = "Temp1", 815 .type = ENVSYS_STEMP, 816 .bank = 1, 817 .reg = 0x50, 818 .refresh = wb_refresh_temp, 819 .rfact = 0 820 }, 821 822 /* Fans */ 823 { 824 .desc = "Fan0", 825 .type = ENVSYS_SFANRPM, 826 .bank = 0, 827 .reg = 0x28, 828 .refresh = wb_refresh_fanrpm, 829 .rfact = 0 830 }, 831 { 832 .desc = "Fan1", 833 .type = ENVSYS_SFANRPM, 834 .bank = 0, 835 .reg = 0x29, 836 .refresh = wb_refresh_fanrpm, 837 .rfact = 0 838 }, 839 840 { .desc = NULL } 841 }; 842 843 /* W83781D */ 844 845 /* 846 * The datasheet doesn't mention the (internal) resistors used for the 847 * +5V, but using the values from the W83782D datasheets seems to 848 * provide sensible results. 849 */ 850 static struct lm_sensor w83781d_sensors[] = { 851 /* Voltage */ 852 { 853 .desc = "VCore A", 854 .type = ENVSYS_SVOLTS_DC, 855 .bank = 0, 856 .reg = 0x20, 857 .refresh = lm_refresh_volt, 858 .rfact = RFACT_NONE 859 }, 860 { 861 .desc = "VCore B", 862 .type = ENVSYS_SVOLTS_DC, 863 .bank = 0, 864 .reg = 0x21, 865 .refresh = lm_refresh_volt, 866 .rfact = RFACT_NONE 867 }, 868 { 869 .desc = "+3.3V", 870 .type = ENVSYS_SVOLTS_DC, 871 .bank = 0, 872 .reg = 0x22, 873 .refresh = lm_refresh_volt, 874 .rfact = RFACT_NONE 875 }, 876 { 877 .desc = "+5V", 878 .type = ENVSYS_SVOLTS_DC, 879 .bank = 0, 880 .reg = 0x23, 881 .refresh = lm_refresh_volt, 882 .rfact = RFACT(34, 50) 883 }, 884 { 885 .desc = "+12V", 886 .type = ENVSYS_SVOLTS_DC, 887 .bank = 0, 888 .reg = 0x24, 889 .refresh = lm_refresh_volt, 890 .rfact = RFACT(28, 10) 891 }, 892 { 893 .desc = "-12V", 894 .type = ENVSYS_SVOLTS_DC, 895 .bank = 0, 896 .reg = 0x25, 897 .refresh = lm_refresh_volt, 898 .rfact = NRFACT(2100, 604) 899 }, 900 { 901 .desc = "-5V", 902 .type = ENVSYS_SVOLTS_DC, 903 .bank = 0, 904 .reg = 0x26, 905 .refresh = lm_refresh_volt, 906 .rfact = NRFACT(909, 604) 907 }, 908 909 /* Temperature */ 910 { 911 .desc = "Temp0", 912 .type = ENVSYS_STEMP, 913 .bank = 0, 914 .reg = 0x27, 915 .refresh = lm_refresh_temp, 916 .rfact = 0 917 }, 918 { 919 .desc = "Temp1", 920 .type = ENVSYS_STEMP, 921 .bank = 1, 922 .reg = 0x50, 923 .refresh = wb_refresh_temp, 924 .rfact = 0 925 }, 926 { 927 .desc = "Temp2", 928 .type = ENVSYS_STEMP, 929 .bank = 2, 930 .reg = 0x50, 931 .refresh = wb_refresh_temp, 932 .rfact = 0 933 }, 934 935 /* Fans */ 936 { 937 .desc = "Fan0", 938 .type = ENVSYS_SFANRPM, 939 .bank = 0, 940 .reg = 0x28, 941 .refresh = lm_refresh_fanrpm, 942 .rfact = 0 943 }, 944 { 945 .desc = "Fan1", 946 .type = ENVSYS_SFANRPM, 947 .bank = 0, 948 .reg = 0x29, 949 .refresh = lm_refresh_fanrpm, 950 .rfact = 0 951 }, 952 { 953 .desc = "Fan2", 954 .type = ENVSYS_SFANRPM, 955 .bank = 0, 956 .reg = 0x2a, 957 .refresh = lm_refresh_fanrpm, 958 .rfact = 0 959 }, 960 961 { .desc = NULL } 962 }; 963 964 /* W83782D */ 965 static struct lm_sensor w83782d_sensors[] = { 966 /* Voltage */ 967 { 968 .desc = "VCore", 969 .type = ENVSYS_SVOLTS_DC, 970 .bank = 0, 971 .reg = 0x20, 972 .refresh = lm_refresh_volt, 973 .rfact = RFACT_NONE 974 }, 975 { 976 .desc = "VINR0", 977 .type = ENVSYS_SVOLTS_DC, 978 .bank = 0, 979 .reg = 0x21, 980 .refresh = lm_refresh_volt, 981 .rfact = RFACT_NONE 982 }, 983 { 984 .desc = "+3.3V", 985 .type = ENVSYS_SVOLTS_DC, 986 .bank = 0, 987 .reg = 0x22, 988 .refresh = lm_refresh_volt, 989 .rfact = RFACT_NONE 990 }, 991 { 992 .desc = "+5V", 993 .type = ENVSYS_SVOLTS_DC, 994 .bank = 0, 995 .reg = 0x23, 996 .refresh = lm_refresh_volt, 997 .rfact = RFACT(34, 50) 998 }, 999 { 1000 .desc = "+12V", 1001 .type = ENVSYS_SVOLTS_DC, 1002 .bank = 0, 1003 .reg = 0x24, 1004 .refresh = lm_refresh_volt, 1005 .rfact = RFACT(28, 10) 1006 }, 1007 { 1008 .desc = "-12V", 1009 .type = ENVSYS_SVOLTS_DC, 1010 .bank = 0, 1011 .reg = 0x25, 1012 .refresh = wb_refresh_nvolt, 1013 .rfact = RFACT(232, 56) 1014 }, 1015 { 1016 .desc = "-5V", 1017 .type = ENVSYS_SVOLTS_DC, 1018 .bank = 0, 1019 .reg = 0x26, 1020 .refresh = wb_refresh_nvolt, 1021 .rfact = RFACT(120, 56) 1022 }, 1023 { 1024 .desc = "5VSB", 1025 .type = ENVSYS_SVOLTS_DC, 1026 .bank = 5, 1027 .reg = 0x50, 1028 .refresh = lm_refresh_volt, 1029 .rfact = RFACT(17, 33) 1030 }, 1031 { 1032 .desc = "VBAT", 1033 .type = ENVSYS_SVOLTS_DC, 1034 .bank = 5, 1035 .reg = 0x51, 1036 .refresh = lm_refresh_volt, 1037 .rfact = RFACT_NONE 1038 }, 1039 1040 /* Temperature */ 1041 { 1042 .desc = "Temp0", 1043 .type = ENVSYS_STEMP, 1044 .bank = 0, 1045 .reg = 0x27, 1046 .refresh = lm_refresh_temp, 1047 .rfact = 0 1048 }, 1049 { 1050 .desc = "Temp1", 1051 .type = ENVSYS_STEMP, 1052 .bank = 1, 1053 .reg = 0x50, 1054 .refresh = wb_refresh_temp, 1055 .rfact = 0 1056 }, 1057 { 1058 .desc = "Temp2", 1059 .type = ENVSYS_STEMP, 1060 .bank = 2, 1061 .reg = 0x50, 1062 .refresh = wb_refresh_temp, 1063 .rfact = 0 1064 }, 1065 1066 /* Fans */ 1067 { 1068 .desc = "Fan0", 1069 .type = ENVSYS_SFANRPM, 1070 .bank = 0, 1071 .reg = 0x28, 1072 .refresh = wb_refresh_fanrpm, 1073 .rfact = 0 1074 }, 1075 { 1076 .desc = "Fan1", 1077 .type = ENVSYS_SFANRPM, 1078 .bank = 0, 1079 .reg = 0x29, 1080 .refresh = wb_refresh_fanrpm, 1081 .rfact = 0 1082 }, 1083 { 1084 .desc = "Fan2", 1085 .type = ENVSYS_SFANRPM, 1086 .bank = 0, 1087 .reg = 0x2a, 1088 .refresh = wb_refresh_fanrpm, 1089 .rfact = 0 1090 }, 1091 1092 { .desc = NULL } 1093 }; 1094 1095 /* W83783S */ 1096 static struct lm_sensor w83783s_sensors[] = { 1097 /* Voltage */ 1098 { 1099 .desc = "VCore", 1100 .type = ENVSYS_SVOLTS_DC, 1101 .bank = 0, 1102 .reg = 0x20, 1103 .refresh = lm_refresh_volt, 1104 .rfact = RFACT_NONE 1105 }, 1106 { 1107 .desc = "+3.3V", 1108 .type = ENVSYS_SVOLTS_DC, 1109 .bank = 0, 1110 .reg = 0x22, 1111 .refresh = lm_refresh_volt, 1112 .rfact = RFACT_NONE 1113 }, 1114 { 1115 .desc = "+5V", 1116 .type = ENVSYS_SVOLTS_DC, 1117 .bank = 0, 1118 .reg = 0x23, 1119 .refresh = lm_refresh_volt, 1120 .rfact = RFACT(34, 50) 1121 }, 1122 { 1123 .desc = "+12V", 1124 .type = ENVSYS_SVOLTS_DC, 1125 .bank = 0, 1126 .reg = 0x24, 1127 .refresh = lm_refresh_volt, 1128 .rfact = RFACT(28, 10) 1129 }, 1130 { 1131 .desc = "-12V", 1132 .type = ENVSYS_SVOLTS_DC, 1133 .bank = 0, 1134 .reg = 0x25, 1135 .refresh = wb_refresh_nvolt, 1136 .rfact = RFACT(232, 56) 1137 }, 1138 { 1139 .desc = "-5V", 1140 .type = ENVSYS_SVOLTS_DC, 1141 .bank = 0, 1142 .reg = 0x26, 1143 .refresh = wb_refresh_nvolt, 1144 .rfact = RFACT(120, 56) 1145 }, 1146 1147 /* Temperature */ 1148 { 1149 .desc = "Temp0", 1150 .type = ENVSYS_STEMP, 1151 .bank = 0, 1152 .reg = 0x27, 1153 .refresh = lm_refresh_temp, 1154 .rfact = 0 1155 }, 1156 { 1157 .desc = "Temp1", 1158 .type = ENVSYS_STEMP, 1159 .bank = 1, 1160 .reg = 0x50, 1161 .refresh = wb_refresh_temp, 1162 .rfact = 0 1163 }, 1164 1165 /* Fans */ 1166 { 1167 .desc = "Fan0", 1168 .type = ENVSYS_SFANRPM, 1169 .bank = 0, 1170 .reg = 0x28, 1171 .refresh = wb_refresh_fanrpm, 1172 .rfact = 0 1173 }, 1174 { 1175 .desc = "Fan1", 1176 .type = ENVSYS_SFANRPM, 1177 .bank = 0, 1178 .reg = 0x29, 1179 .refresh = wb_refresh_fanrpm, 1180 .rfact = 0 1181 }, 1182 { 1183 .desc = "Fan2", 1184 .type = ENVSYS_SFANRPM, 1185 .bank = 0, 1186 .reg = 0x2a, 1187 .refresh = wb_refresh_fanrpm, 1188 .rfact = 0 1189 }, 1190 1191 { .desc = NULL } 1192 }; 1193 1194 /* W83791D */ 1195 static struct lm_sensor w83791d_sensors[] = { 1196 /* Voltage */ 1197 { 1198 .desc = "VCore", 1199 .type = ENVSYS_SVOLTS_DC, 1200 .bank = 0, 1201 .reg = 0x20, 1202 .refresh = lm_refresh_volt, 1203 .rfact = 10000 1204 }, 1205 { 1206 .desc = "VINR0", 1207 .type = ENVSYS_SVOLTS_DC, 1208 .bank = 0, 1209 .reg = 0x21, 1210 .refresh = lm_refresh_volt, 1211 .rfact = 10000 1212 }, 1213 { 1214 .desc = "+3.3V", 1215 .type = ENVSYS_SVOLTS_DC, 1216 .bank = 0, 1217 .reg = 0x22, 1218 .refresh = lm_refresh_volt, 1219 .rfact = 10000 1220 }, 1221 { 1222 .desc = "+5V", 1223 .type = ENVSYS_SVOLTS_DC, 1224 .bank = 0, 1225 .reg = 0x23, 1226 .refresh = lm_refresh_volt, 1227 .rfact = RFACT(34, 50) 1228 }, 1229 { 1230 .desc = "+12V", 1231 .type = ENVSYS_SVOLTS_DC, 1232 .bank = 0, 1233 .reg = 0x24, 1234 .refresh = lm_refresh_volt, 1235 .rfact = RFACT(28, 10) 1236 }, 1237 { 1238 .desc = "-12V", 1239 .type = ENVSYS_SVOLTS_DC, 1240 .bank = 0, 1241 .reg = 0x25, 1242 .refresh = wb_refresh_nvolt, 1243 .rfact = RFACT(232, 56) 1244 }, 1245 { 1246 .desc = "-5V", 1247 .type = ENVSYS_SVOLTS_DC, 1248 .bank = 0, 1249 .reg = 0x26, 1250 .refresh = wb_refresh_nvolt, 1251 .rfact = RFACT(120, 56) 1252 }, 1253 { 1254 .desc = "5VSB", 1255 .type = ENVSYS_SVOLTS_DC, 1256 .bank = 0, 1257 .reg = 0xb0, 1258 .refresh = lm_refresh_volt, 1259 .rfact = RFACT(17, 33) 1260 }, 1261 { 1262 .desc = "VBAT", 1263 .type = ENVSYS_SVOLTS_DC, 1264 .bank = 0, 1265 .reg = 0xb1, 1266 .refresh = lm_refresh_volt, 1267 .rfact = RFACT_NONE 1268 }, 1269 { 1270 .desc = "VINR1", 1271 .type = ENVSYS_SVOLTS_DC, 1272 .bank = 0, 1273 .reg = 0xb2, 1274 .refresh = lm_refresh_volt, 1275 .rfact = RFACT_NONE 1276 }, 1277 1278 /* Temperature */ 1279 { 1280 .desc = "Temp0", 1281 .type = ENVSYS_STEMP, 1282 .bank = 0, 1283 .reg = 0x27, 1284 .refresh = lm_refresh_temp, 1285 .rfact = 0 1286 }, 1287 { 1288 .desc = "Temp1", 1289 .type = ENVSYS_STEMP, 1290 .bank = 0, 1291 .reg = 0xc0, 1292 .refresh = wb_refresh_temp, 1293 .rfact = 0 1294 }, 1295 { 1296 .desc = "Temp2", 1297 .type = ENVSYS_STEMP, 1298 .bank = 0, 1299 .reg = 0xc8, 1300 .refresh = wb_refresh_temp, 1301 .rfact = 0 1302 }, 1303 1304 /* Fans */ 1305 { 1306 .desc = "Fan0", 1307 .type = ENVSYS_SFANRPM, 1308 .bank = 0, 1309 .reg = 0x28, 1310 .refresh = wb_refresh_fanrpm, 1311 .rfact = 0 1312 }, 1313 { 1314 .desc = "Fan1", 1315 .type = ENVSYS_SFANRPM, 1316 .bank = 0, 1317 .reg = 0x29, 1318 .refresh = wb_refresh_fanrpm, 1319 .rfact = 0 1320 }, 1321 { 1322 .desc = "Fan2", 1323 .type = ENVSYS_SFANRPM, 1324 .bank = 0, 1325 .reg = 0x2a, 1326 .refresh = wb_refresh_fanrpm, 1327 .rfact = 0 1328 }, 1329 { 1330 .desc = "Fan3", 1331 .type = ENVSYS_SFANRPM, 1332 .bank = 0, 1333 .reg = 0xba, 1334 .refresh = wb_refresh_fanrpm, 1335 .rfact = 0 1336 }, 1337 { 1338 .desc = "Fan4", 1339 .type = ENVSYS_SFANRPM, 1340 .bank = 0, 1341 .reg = 0xbb, 1342 .refresh = wb_refresh_fanrpm, 1343 .rfact = 0 1344 }, 1345 1346 { .desc = NULL } 1347 }; 1348 1349 /* W83792D */ 1350 static struct lm_sensor w83792d_sensors[] = { 1351 /* Voltage */ 1352 { 1353 .desc = "VCore A", 1354 .type = ENVSYS_SVOLTS_DC, 1355 .bank = 0, 1356 .reg = 0x20, 1357 .refresh = lm_refresh_volt, 1358 .rfact = RFACT_NONE 1359 }, 1360 { 1361 .desc = "VCore B", 1362 .type = ENVSYS_SVOLTS_DC, 1363 .bank = 0, 1364 .reg = 0x21, 1365 .refresh = lm_refresh_volt, 1366 .rfact = RFACT_NONE 1367 }, 1368 { 1369 .desc = "+3.3V", 1370 .type = ENVSYS_SVOLTS_DC, 1371 .bank = 0, 1372 .reg = 0x22, 1373 .refresh = lm_refresh_volt, 1374 .rfact = RFACT_NONE 1375 }, 1376 { 1377 .desc = "-5V", 1378 .type = ENVSYS_SVOLTS_DC, 1379 .bank = 0, 1380 .reg = 0x23, 1381 .refresh = wb_refresh_nvolt, 1382 .rfact = RFACT(120, 56) 1383 }, 1384 { 1385 .desc = "+12V", 1386 .type = ENVSYS_SVOLTS_DC, 1387 .bank = 0, 1388 .reg = 0x24, 1389 .refresh = lm_refresh_volt, 1390 .rfact = RFACT(28, 10) 1391 }, 1392 { 1393 .desc = "-12V", 1394 .type = ENVSYS_SVOLTS_DC, 1395 .bank = 0, 1396 .reg = 0x25, 1397 .refresh = wb_refresh_nvolt, 1398 .rfact = RFACT(232, 56) 1399 }, 1400 { 1401 .desc = "+5V", 1402 .type = ENVSYS_SVOLTS_DC, 1403 .bank = 0, 1404 .reg = 0x26, 1405 .refresh = lm_refresh_volt, 1406 .rfact = RFACT(34, 50) 1407 }, 1408 { 1409 .desc = "5VSB", 1410 .type = ENVSYS_SVOLTS_DC, 1411 .bank = 0, 1412 .reg = 0xb0, 1413 .refresh = lm_refresh_volt, 1414 .rfact = RFACT(17, 33) 1415 }, 1416 { 1417 .desc = "VBAT", 1418 .type = ENVSYS_SVOLTS_DC, 1419 .bank = 0, 1420 .reg = 0xb1, 1421 .refresh = lm_refresh_volt, 1422 .rfact = RFACT_NONE 1423 }, 1424 1425 /* Temperature */ 1426 { 1427 .desc = "Temp0", 1428 .type = ENVSYS_STEMP, 1429 .bank = 0, 1430 .reg = 0x27, 1431 .refresh = lm_refresh_temp, 1432 .rfact = 0 1433 }, 1434 { 1435 .desc = "Temp1", 1436 .type = ENVSYS_STEMP, 1437 .bank = 0, 1438 .reg = 0xc0, 1439 .refresh = wb_refresh_temp, 1440 .rfact = 0 1441 }, 1442 { 1443 .desc = "Temp2", 1444 .type = ENVSYS_STEMP, 1445 .bank = 0, 1446 .reg = 0xc8, 1447 .refresh = wb_refresh_temp, 1448 .rfact = 0 1449 }, 1450 1451 /* Fans */ 1452 { 1453 .desc = "Fan0", 1454 .type = ENVSYS_SFANRPM, 1455 .bank = 0, 1456 .reg = 0x28, 1457 .refresh = wb_w83792d_refresh_fanrpm, 1458 .rfact = 0 1459 }, 1460 { 1461 .desc = "Fan1", 1462 .type = ENVSYS_SFANRPM, 1463 .bank = 0, 1464 .reg = 0x29, 1465 .refresh = wb_w83792d_refresh_fanrpm, 1466 .rfact = 0 1467 }, 1468 { 1469 .desc = "Fan2", 1470 .type = ENVSYS_SFANRPM, 1471 .bank = 0, 1472 .reg = 0x2a, 1473 .refresh = wb_w83792d_refresh_fanrpm, 1474 .rfact = 0 1475 }, 1476 { 1477 .desc = "Fan3", 1478 .type = ENVSYS_SFANRPM, 1479 .bank = 0, 1480 .reg = 0xb8, 1481 .refresh = wb_w83792d_refresh_fanrpm, 1482 .rfact = 0 1483 }, 1484 { 1485 .desc = "Fan4", 1486 .type = ENVSYS_SFANRPM, 1487 .bank = 0, 1488 .reg = 0xb9, 1489 .refresh = wb_w83792d_refresh_fanrpm, 1490 .rfact = 0 1491 }, 1492 { 1493 .desc = "Fan5", 1494 .type = ENVSYS_SFANRPM, 1495 .bank = 0, 1496 .reg = 0xba, 1497 .refresh = wb_w83792d_refresh_fanrpm, 1498 .rfact = 0 1499 }, 1500 { 1501 .desc = "Fan6", 1502 .type = ENVSYS_SFANRPM, 1503 .bank = 0, 1504 .reg = 0xbe, 1505 .refresh = wb_w83792d_refresh_fanrpm, 1506 .rfact = 0 1507 }, 1508 1509 { .desc = NULL } 1510 }; 1511 1512 /* AS99127F */ 1513 static struct lm_sensor as99127f_sensors[] = { 1514 /* Voltage */ 1515 { 1516 .desc = "VCore A", 1517 .type = ENVSYS_SVOLTS_DC, 1518 .bank = 0, 1519 .reg = 0x20, 1520 .refresh = lm_refresh_volt, 1521 .rfact = RFACT_NONE 1522 }, 1523 { 1524 .desc = "VCore B", 1525 .type = ENVSYS_SVOLTS_DC, 1526 .bank = 0, 1527 .reg = 0x21, 1528 .refresh = lm_refresh_volt, 1529 .rfact = RFACT_NONE 1530 }, 1531 { 1532 .desc = "+3.3V", 1533 .type = ENVSYS_SVOLTS_DC, 1534 .bank = 0, 1535 .reg = 0x22, 1536 .refresh = lm_refresh_volt, 1537 .rfact = RFACT_NONE 1538 }, 1539 { 1540 .desc = "+5V", 1541 .type = ENVSYS_SVOLTS_DC, 1542 .bank = 0, 1543 .reg = 0x23, 1544 .refresh = lm_refresh_volt, 1545 .rfact = RFACT(34, 50) 1546 }, 1547 { 1548 .desc = "+12V", 1549 .type = ENVSYS_SVOLTS_DC, 1550 .bank = 0, 1551 .reg = 0x24, 1552 .refresh = lm_refresh_volt, 1553 .rfact = RFACT(28, 10) 1554 }, 1555 { 1556 .desc = "-12V", 1557 .type = ENVSYS_SVOLTS_DC, 1558 .bank = 0, 1559 .reg = 0x25, 1560 .refresh = wb_refresh_nvolt, 1561 .rfact = RFACT(232, 56) 1562 }, 1563 { 1564 .desc = "-5V", 1565 .type = ENVSYS_SVOLTS_DC, 1566 .bank = 0, 1567 .reg = 0x26, 1568 .refresh = wb_refresh_nvolt, 1569 .rfact = RFACT(120, 56) 1570 }, 1571 1572 /* Temperature */ 1573 { 1574 .desc = "Temp0", 1575 .type = ENVSYS_STEMP, 1576 .bank = 0, 1577 .reg = 0x27, 1578 .refresh = lm_refresh_temp, 1579 .rfact = 0 1580 }, 1581 { 1582 .desc = "Temp1", 1583 .type = ENVSYS_STEMP, 1584 .bank = 1, 1585 .reg = 0x50, 1586 .refresh = as_refresh_temp, 1587 .rfact = 0 1588 }, 1589 { 1590 .desc = "Temp2", 1591 .type = ENVSYS_STEMP, 1592 .bank = 2, 1593 .reg = 0x50, 1594 .refresh = as_refresh_temp, 1595 .rfact = 0 1596 }, 1597 1598 /* Fans */ 1599 { 1600 .desc = "Fan0", 1601 .type = ENVSYS_SFANRPM, 1602 .bank = 0, 1603 .reg = 0x28, 1604 .refresh = lm_refresh_fanrpm, 1605 .rfact = 0 1606 }, 1607 { 1608 .desc = "Fan1", 1609 .type = ENVSYS_SFANRPM, 1610 .bank = 0, 1611 .reg = 0x29, 1612 .refresh = lm_refresh_fanrpm, 1613 .rfact = 0 1614 }, 1615 { 1616 .desc = "Fan2", 1617 .type = ENVSYS_SFANRPM, 1618 .bank = 0, 1619 .reg = 0x2a, 1620 .refresh = lm_refresh_fanrpm, 1621 .rfact = 0 1622 }, 1623 1624 { .desc = NULL } 1625 }; 1626 1627 static void 1628 lm_generic_banksel(struct lm_softc *lmsc, int bank) 1629 { 1630 (*lmsc->lm_writereg)(lmsc, WB_BANKSEL, bank); 1631 } 1632 1633 /* 1634 * bus independent probe 1635 */ 1636 int 1637 lm_probe(bus_space_tag_t iot, bus_space_handle_t ioh) 1638 { 1639 uint8_t cr; 1640 int rv; 1641 1642 /* Check for some power-on defaults */ 1643 bus_space_write_1(iot, ioh, LMC_ADDR, LMD_CONFIG); 1644 1645 /* Perform LM78 reset */ 1646 /* bus_space_write_1(iot, ioh, LMC_DATA, 0x80); */ 1647 1648 /* XXX - Why do I have to reselect the register? */ 1649 bus_space_write_1(iot, ioh, LMC_ADDR, LMD_CONFIG); 1650 cr = bus_space_read_1(iot, ioh, LMC_DATA); 1651 1652 /* XXX - spec says *only* 0x08! */ 1653 if ((cr == 0x08) || (cr == 0x01) || (cr == 0x03)) 1654 rv = 1; 1655 else 1656 rv = 0; 1657 1658 DPRINTF(("%s: rv = %d, cr = %x\n", __func__, rv, cr)); 1659 1660 return rv; 1661 } 1662 1663 1664 /* 1665 * pre: lmsc contains valid busspace tag and handle 1666 */ 1667 void 1668 lm_attach(struct lm_softc *lmsc) 1669 { 1670 uint32_t i; 1671 1672 for (i = 0; i < __arraycount(lm_chips); i++) 1673 if (lm_chips[i].chip_match(lmsc)) 1674 break; 1675 1676 /* Start the monitoring loop */ 1677 (*lmsc->lm_writereg)(lmsc, LMD_CONFIG, 0x01); 1678 1679 /* Initialize sensors */ 1680 for (i = 0; i < lmsc->numsensors; i++) { 1681 lmsc->sensors[i].sensor = i; 1682 lmsc->sensors[i].state = ENVSYS_SVALID; 1683 } 1684 1685 /* 1686 * Setup the callout to refresh sensor data every 1.5 sec. 1687 */ 1688 callout_init(&lmsc->sc_callout, 0); 1689 callout_setfunc(&lmsc->sc_callout, lm_refresh, lmsc); 1690 callout_schedule(&lmsc->sc_callout, LM_REFRESH_TIMO); 1691 1692 /* 1693 * Hook into the System Monitor. 1694 */ 1695 lmsc->sc_sysmon.sme_sensor_data = lmsc->sensors; 1696 lmsc->sc_sysmon.sme_name = lmsc->sc_dev.dv_xname; 1697 lmsc->sc_sysmon.sme_nsensors = lmsc->numsensors; 1698 lmsc->sc_sysmon.sme_flags |= SME_DISABLE_GTREDATA; 1699 1700 if (sysmon_envsys_register(&lmsc->sc_sysmon)) 1701 aprint_error("%s: unable to register with sysmon\n", 1702 lmsc->sc_dev.dv_xname); 1703 } 1704 1705 /* 1706 * Stop, destroy the callout and unregister the driver with the 1707 * sysmon_envsys(9) framework. 1708 */ 1709 void 1710 lm_detach(struct lm_softc *lmsc) 1711 { 1712 callout_stop(&lmsc->sc_callout); 1713 callout_destroy(&lmsc->sc_callout); 1714 sysmon_envsys_unregister(&lmsc->sc_sysmon); 1715 } 1716 1717 static void 1718 lm_refresh(void *arg) 1719 { 1720 struct lm_softc *lmsc = arg; 1721 1722 if (lmsc->numsensors != lmsc->sc_sysmon.sme_nsensors) 1723 lmsc->numsensors = lmsc->sc_sysmon.sme_nsensors; 1724 1725 lmsc->refresh_sensor_data(lmsc); 1726 callout_schedule(&lmsc->sc_callout, LM_REFRESH_TIMO); 1727 } 1728 1729 static int 1730 lm_match(struct lm_softc *sc) 1731 { 1732 const char *model = NULL; 1733 int chipid; 1734 1735 /* See if we have an LM78/LM78J/LM79 or LM81 */ 1736 chipid = (*sc->lm_readreg)(sc, LMD_CHIPID) & LM_ID_MASK; 1737 switch(chipid) { 1738 case LM_ID_LM78: 1739 model = "LM78"; 1740 break; 1741 case LM_ID_LM78J: 1742 model = "LM78J"; 1743 break; 1744 case LM_ID_LM79: 1745 model = "LM79"; 1746 break; 1747 case LM_ID_LM81: 1748 model = "LM81"; 1749 break; 1750 default: 1751 return 0; 1752 } 1753 1754 aprint_normal("\n"); 1755 aprint_normal("%s: National Semiconductor %s Hardware monitor\n", 1756 sc->sc_dev.dv_xname, model); 1757 1758 lm_setup_sensors(sc, lm78_sensors); 1759 sc->refresh_sensor_data = lm_refresh_sensor_data; 1760 return 1; 1761 } 1762 1763 static int 1764 def_match(struct lm_softc *sc) 1765 { 1766 int chipid; 1767 1768 chipid = (*sc->lm_readreg)(sc, LMD_CHIPID) & LM_ID_MASK; 1769 aprint_normal("\n"); 1770 aprint_error("%s: Unknown chip (ID %d)\n", sc->sc_dev.dv_xname, 1771 chipid); 1772 1773 lm_setup_sensors(sc, lm78_sensors); 1774 sc->refresh_sensor_data = lm_refresh_sensor_data; 1775 return 1; 1776 } 1777 1778 static int 1779 wb_match(struct lm_softc *sc) 1780 { 1781 const char *model = NULL; 1782 int banksel, vendid, devid; 1783 1784 aprint_normal("\n"); 1785 /* Read vendor ID */ 1786 banksel = (*sc->lm_readreg)(sc, WB_BANKSEL); 1787 lm_generic_banksel(sc, WB_BANKSEL_HBAC); 1788 vendid = (*sc->lm_readreg)(sc, WB_VENDID) << 8; 1789 lm_generic_banksel(sc, 0); 1790 vendid |= (*sc->lm_readreg)(sc, WB_VENDID); 1791 DPRINTF(("%s: winbond vend id 0x%x\n", __func__, vendid)); 1792 if (vendid != WB_VENDID_WINBOND && vendid != WB_VENDID_ASUS) 1793 return 0; 1794 1795 /* Read device/chip ID */ 1796 lm_generic_banksel(sc, WB_BANKSEL_B0); 1797 devid = (*sc->lm_readreg)(sc, LMD_CHIPID); 1798 sc->chipid = (*sc->lm_readreg)(sc, WB_BANK0_CHIPID); 1799 lm_generic_banksel(sc, banksel); 1800 DPRINTF(("%s: winbond chip id 0x%x\n", __func__, sc->chipid)); 1801 1802 switch(sc->chipid) { 1803 case WB_CHIPID_W83627HF: 1804 model = "W83627HF"; 1805 lm_setup_sensors(sc, w83627hf_sensors); 1806 break; 1807 case WB_CHIPID_W83627THF: 1808 model = "W83627THF"; 1809 lm_setup_sensors(sc, w83637hf_sensors); 1810 break; 1811 case WB_CHIPID_W83627EHF_A: 1812 model = "W83627EHF-A"; 1813 lm_setup_sensors(sc, w83627ehf_sensors); 1814 break; 1815 case WB_CHIPID_W83627EHF: 1816 model = "W83627EHF"; 1817 lm_setup_sensors(sc, w83627ehf_sensors); 1818 break; 1819 case WB_CHIPID_W83627DHG: 1820 model = "W83627DHG"; 1821 lm_setup_sensors(sc, w83627dhg_sensors); 1822 break; 1823 case WB_CHIPID_W83637HF: 1824 model = "W83637HF"; 1825 lm_generic_banksel(sc, WB_BANKSEL_B0); 1826 if ((*sc->lm_readreg)(sc, WB_BANK0_CONFIG) & WB_CONFIG_VMR9) 1827 sc->vrm9 = 1; 1828 lm_generic_banksel(sc, banksel); 1829 lm_setup_sensors(sc, w83637hf_sensors); 1830 break; 1831 case WB_CHIPID_W83697HF: 1832 model = "W83697HF"; 1833 lm_setup_sensors(sc, w83697hf_sensors); 1834 break; 1835 case WB_CHIPID_W83781D: 1836 case WB_CHIPID_W83781D_2: 1837 model = "W83781D"; 1838 lm_setup_sensors(sc, w83781d_sensors); 1839 break; 1840 case WB_CHIPID_W83782D: 1841 model = "W83782D"; 1842 lm_setup_sensors(sc, w83782d_sensors); 1843 break; 1844 case WB_CHIPID_W83783S: 1845 model = "W83783S"; 1846 lm_setup_sensors(sc, w83783s_sensors); 1847 break; 1848 case WB_CHIPID_W83791D: 1849 model = "W83791D"; 1850 lm_setup_sensors(sc, w83791d_sensors); 1851 break; 1852 case WB_CHIPID_W83791SD: 1853 model = "W83791SD"; 1854 break; 1855 case WB_CHIPID_W83792D: 1856 model = "W83792D"; 1857 lm_setup_sensors(sc, w83792d_sensors); 1858 break; 1859 case WB_CHIPID_AS99127F: 1860 if (vendid == WB_VENDID_ASUS) { 1861 model = "AS99127F"; 1862 lm_setup_sensors(sc, w83781d_sensors); 1863 } else { 1864 model = "AS99127F rev 2"; 1865 lm_setup_sensors(sc, as99127f_sensors); 1866 } 1867 break; 1868 default: 1869 aprint_normal("%s: unknown Winbond chip (ID 0x%x)\n", 1870 sc->sc_dev.dv_xname, sc->chipid); 1871 /* Handle as a standard LM78. */ 1872 lm_setup_sensors(sc, lm78_sensors); 1873 sc->refresh_sensor_data = lm_refresh_sensor_data; 1874 return 1; 1875 } 1876 1877 aprint_normal("%s: Winbond %s Hardware monitor\n", 1878 sc->sc_dev.dv_xname, model); 1879 1880 sc->refresh_sensor_data = wb_refresh_sensor_data; 1881 return 1; 1882 } 1883 1884 static void 1885 lm_setup_sensors(struct lm_softc *sc, struct lm_sensor *sensors) 1886 { 1887 int i; 1888 1889 for (i = 0; sensors[i].desc; i++) { 1890 sc->sensors[i].units = sensors[i].type; 1891 strlcpy(sc->sensors[i].desc, sensors[i].desc, 1892 sizeof(sc->sensors[i].desc)); 1893 sc->numsensors++; 1894 } 1895 sc->lm_sensors = sensors; 1896 } 1897 1898 static void 1899 lm_refresh_sensor_data(struct lm_softc *sc) 1900 { 1901 int i; 1902 1903 for (i = 0; i < sc->numsensors; i++) 1904 sc->lm_sensors[i].refresh(sc, i); 1905 } 1906 1907 static void 1908 lm_refresh_volt(struct lm_softc *sc, int n) 1909 { 1910 int data; 1911 1912 data = (*sc->lm_readreg)(sc, sc->lm_sensors[n].reg); 1913 if (data == 0xff) 1914 sc->sensors[n].state = ENVSYS_SINVALID; 1915 1916 sc->sensors[n].flags = ENVSYS_FCHANGERFACT; 1917 sc->sensors[n].value_cur = (data << 4); 1918 1919 if (sc->sensors[n].rfact) { 1920 sc->sensors[n].value_cur *= sc->sensors[n].rfact; 1921 sc->sensors[n].value_cur /= 10; 1922 } else { 1923 sc->sensors[n].value_cur *= sc->lm_sensors[n].rfact; 1924 sc->sensors[n].value_cur /= 10; 1925 sc->sensors[n].rfact = sc->lm_sensors[n].rfact; 1926 } 1927 1928 sc->sensors[n].state = ENVSYS_SVALID; 1929 DPRINTF(("%s: volt[%d] data=0x%x value_cur=%d\n", 1930 __func__, n, data, sc->sensors[n].value_cur)); 1931 } 1932 1933 static void 1934 lm_refresh_temp(struct lm_softc *sc, int n) 1935 { 1936 int data; 1937 1938 /* 1939 * The data sheet suggests that the range of the temperature 1940 * sensor is between -55 degC and +125 degC. 1941 */ 1942 data = (*sc->lm_readreg)(sc, sc->lm_sensors[n].reg); 1943 if (data > 0x7d && data < 0xc9) 1944 sc->sensors[n].state = ENVSYS_SINVALID; 1945 else { 1946 if (data & 0x80) 1947 data -= 0x100; 1948 sc->sensors[n].state = ENVSYS_SVALID; 1949 sc->sensors[n].value_cur = data * 1000000 + 273150000; 1950 } 1951 DPRINTF(("%s: temp[%d] data=0x%x value_cur=%d\n", 1952 __func__, n, data, sc->sensors[n].value_cur)); 1953 } 1954 1955 static void 1956 lm_refresh_fanrpm(struct lm_softc *sc, int n) 1957 { 1958 int data, divisor = 1; 1959 1960 /* 1961 * We might get more accurate fan readings by adjusting the 1962 * divisor, but that might interfere with APM or other SMM 1963 * BIOS code reading the fan speeds. 1964 */ 1965 1966 /* FAN3 has a fixed fan divisor. */ 1967 if (sc->lm_sensors[n].reg == LMD_FAN1 || 1968 sc->lm_sensors[n].reg == LMD_FAN2) { 1969 data = (*sc->lm_readreg)(sc, LMD_VIDFAN); 1970 if (sc->lm_sensors[n].reg == LMD_FAN1) 1971 divisor = (data >> 4) & 0x03; 1972 else 1973 divisor = (data >> 6) & 0x03; 1974 } 1975 1976 data = (*sc->lm_readreg)(sc, sc->lm_sensors[n].reg); 1977 if (data == 0xff || data == 0x00) 1978 sc->sensors[n].state = ENVSYS_SINVALID; 1979 else { 1980 sc->sensors[n].state = ENVSYS_SVALID; 1981 sc->sensors[n].value_cur = 1350000 / (data << divisor); 1982 } 1983 DPRINTF(("%s: fan[%d] data=0x%x value_cur=%d\n", 1984 __func__, n, data, sc->sensors[n].value_cur)); 1985 } 1986 1987 static void 1988 wb_refresh_sensor_data(struct lm_softc *sc) 1989 { 1990 int banksel, bank, i; 1991 1992 /* 1993 * Properly save and restore bank selection register. 1994 */ 1995 banksel = bank = sc->lm_readreg(sc, WB_BANKSEL); 1996 for (i = 0; i < sc->numsensors; i++) { 1997 if (bank != sc->lm_sensors[i].bank) { 1998 bank = sc->lm_sensors[i].bank; 1999 lm_generic_banksel(sc, bank); 2000 } 2001 sc->lm_sensors[i].refresh(sc, i); 2002 } 2003 lm_generic_banksel(sc, banksel); 2004 } 2005 2006 static void 2007 wb_w83637hf_refresh_vcore(struct lm_softc *sc, int n) 2008 { 2009 int data; 2010 2011 data = (*sc->lm_readreg)(sc, sc->lm_sensors[n].reg); 2012 /* 2013 * Depending on the voltage detection method, 2014 * one of the following formulas is used: 2015 * VRM8 method: value = raw * 0.016V 2016 * VRM9 method: value = raw * 0.00488V + 0.70V 2017 */ 2018 if (sc->vrm9) 2019 sc->sensors[n].value_cur = (data * 4880) + 700000; 2020 else 2021 sc->sensors[n].value_cur = (data * 16000); 2022 DPRINTF(("%s: volt[%d] data=0x%x value_cur=%d\n", 2023 __func__, n, data, sc->sensors[n].value_cur)); 2024 } 2025 2026 static void 2027 wb_refresh_nvolt(struct lm_softc *sc, int n) 2028 { 2029 int data; 2030 2031 data = (*sc->lm_readreg)(sc, sc->lm_sensors[n].reg); 2032 sc->sensors[n].flags = ENVSYS_FCHANGERFACT; 2033 sc->sensors[n].value_cur = ((data << 4) - WB_VREF); 2034 if (sc->sensors[n].rfact) 2035 sc->sensors[n].value_cur *= sc->sensors[n].rfact; 2036 else 2037 sc->sensors[n].value_cur *= sc->lm_sensors[n].rfact; 2038 2039 sc->sensors[n].value_cur /= 10; 2040 sc->sensors[n].value_cur += WB_VREF * 1000; 2041 DPRINTF(("%s: volt[%d] data=0x%x value_cur=%d\n", 2042 __func__, n , data, sc->sensors[n].value_cur)); 2043 } 2044 2045 static void 2046 wb_w83627ehf_refresh_nvolt(struct lm_softc *sc, int n) 2047 { 2048 int data; 2049 2050 data = (*sc->lm_readreg)(sc, sc->lm_sensors[n].reg); 2051 sc->sensors[n].value_cur = ((data << 3) - WB_W83627EHF_VREF); 2052 sc->sensors[n].flags = ENVSYS_FCHANGERFACT; 2053 if (sc->sensors[n].rfact) 2054 sc->sensors[n].value_cur *= sc->sensors[n].rfact; 2055 else 2056 sc->sensors[n].value_cur *= RFACT(232, 10); 2057 2058 sc->sensors[n].value_cur /= 10; 2059 sc->sensors[n].value_cur += WB_W83627EHF_VREF * 1000; 2060 DPRINTF(("%s: volt[%d] data=0x%x value_cur=%d\n", 2061 __func__, n , data, sc->sensors[n].value_cur)); 2062 } 2063 2064 static void 2065 wb_refresh_temp(struct lm_softc *sc, int n) 2066 { 2067 int data; 2068 2069 /* 2070 * The data sheet suggests that the range of the temperature 2071 * sensor is between -55 degC and +125 degC. However, values 2072 * around -48 degC seem to be a very common bogus values. 2073 * Since such values are unreasonably low, we use -45 degC for 2074 * the lower limit instead. 2075 */ 2076 data = (*sc->lm_readreg)(sc, sc->lm_sensors[n].reg) << 1; 2077 data += (*sc->lm_readreg)(sc, sc->lm_sensors[n].reg + 1) >> 7; 2078 if (data > 0xfffffff || (data > 0x0fa && data < 0x1a6)) { 2079 sc->sensors[n].state = ENVSYS_SINVALID; 2080 } else { 2081 if (data & 0x100) 2082 data -= 0x200; 2083 sc->sensors[n].state = ENVSYS_SVALID; 2084 sc->sensors[n].value_cur = data * 500000 + 273150000; 2085 } 2086 DPRINTF(("%s: temp[%d] data=0x%x value_cur=%d\n", 2087 __func__, n , data, sc->sensors[n].value_cur)); 2088 } 2089 2090 static void 2091 wb_refresh_fanrpm(struct lm_softc *sc, int n) 2092 { 2093 int fan, data, divisor = 0; 2094 2095 /* 2096 * This is madness; the fan divisor bits are scattered all 2097 * over the place. 2098 */ 2099 2100 if (sc->lm_sensors[n].reg == LMD_FAN1 || 2101 sc->lm_sensors[n].reg == LMD_FAN2 || 2102 sc->lm_sensors[n].reg == LMD_FAN3) { 2103 data = (*sc->lm_readreg)(sc, WB_BANK0_VBAT); 2104 fan = (sc->lm_sensors[n].reg - LMD_FAN1); 2105 if ((data >> 5) & (1 << fan)) 2106 divisor |= 0x04; 2107 } 2108 2109 if (sc->lm_sensors[n].reg == LMD_FAN1 || 2110 sc->lm_sensors[n].reg == LMD_FAN2) { 2111 data = (*sc->lm_readreg)(sc, LMD_VIDFAN); 2112 if (sc->lm_sensors[n].reg == LMD_FAN1) 2113 divisor |= (data >> 4) & 0x03; 2114 else 2115 divisor |= (data >> 6) & 0x03; 2116 } else if (sc->lm_sensors[n].reg == LMD_FAN3) { 2117 data = (*sc->lm_readreg)(sc, WB_PIN); 2118 divisor |= (data >> 6) & 0x03; 2119 } else if (sc->lm_sensors[n].reg == WB_BANK0_FAN4 || 2120 sc->lm_sensors[n].reg == WB_BANK0_FAN5) { 2121 data = (*sc->lm_readreg)(sc, WB_BANK0_FAN45); 2122 if (sc->lm_sensors[n].reg == WB_BANK0_FAN4) 2123 divisor |= (data >> 0) & 0x07; 2124 else 2125 divisor |= (data >> 4) & 0x07; 2126 } 2127 2128 data = (*sc->lm_readreg)(sc, sc->lm_sensors[n].reg); 2129 if (data >= 0xff || data == 0x00) 2130 sc->sensors[n].state = ENVSYS_SINVALID; 2131 else { 2132 sc->sensors[n].state = ENVSYS_SVALID; 2133 sc->sensors[n].value_cur = 1350000 / (data << divisor); 2134 } 2135 DPRINTF(("%s: fan[%d] data=0x%x value_cur=%d\n", 2136 __func__, n , data, sc->sensors[n].value_cur)); 2137 } 2138 2139 static void 2140 wb_w83792d_refresh_fanrpm(struct lm_softc *sc, int n) 2141 { 2142 int reg, shift, data, divisor = 1; 2143 2144 shift = 0; 2145 2146 switch (sc->lm_sensors[n].reg) { 2147 case 0x28: 2148 reg = 0x47; shift = 0; 2149 break; 2150 case 0x29: 2151 reg = 0x47; shift = 4; 2152 break; 2153 case 0x2a: 2154 reg = 0x5b; shift = 0; 2155 break; 2156 case 0xb8: 2157 reg = 0x5b; shift = 4; 2158 break; 2159 case 0xb9: 2160 reg = 0x5c; shift = 0; 2161 break; 2162 case 0xba: 2163 reg = 0x5c; shift = 4; 2164 break; 2165 case 0xbe: 2166 reg = 0x9e; shift = 0; 2167 break; 2168 default: 2169 reg = 0; 2170 break; 2171 } 2172 2173 data = (*sc->lm_readreg)(sc, sc->lm_sensors[n].reg); 2174 if (data == 0xff || data == 0x00) 2175 sc->sensors[n].state = ENVSYS_SINVALID; 2176 else { 2177 if (reg != 0) 2178 divisor = ((*sc->lm_readreg)(sc, reg) >> shift) & 0x7; 2179 sc->sensors[n].state = ENVSYS_SVALID; 2180 sc->sensors[n].value_cur = 1350000 / (data << divisor); 2181 } 2182 DPRINTF(("%s: fan[%d] data=0x%x value_cur=%d\n", 2183 __func__, n , data, sc->sensors[n].value_cur)); 2184 } 2185 2186 static void 2187 as_refresh_temp(struct lm_softc *sc, int n) 2188 { 2189 int data; 2190 2191 /* 2192 * It seems a shorted temperature diode produces an all-ones 2193 * bit pattern. 2194 */ 2195 data = (*sc->lm_readreg)(sc, sc->lm_sensors[n].reg) << 1; 2196 data += (*sc->lm_readreg)(sc, sc->lm_sensors[n].reg + 1) >> 7; 2197 if (data == 0x1ff) 2198 sc->sensors[n].state = ENVSYS_SINVALID; 2199 else { 2200 if (data & 0x100) 2201 data -= 0x200; 2202 sc->sensors[n].state = ENVSYS_SVALID; 2203 sc->sensors[n].value_cur = data * 500000 + 273150000; 2204 } 2205 DPRINTF(("%s: temp[%d] data=0x%x value_cur=%d\n", 2206 __func__, n, data, sc->sensors[n].value_cur)); 2207 } 2208
Indexes created Mon Sep 22 13:09:51 GMT 2025