1 /* $NetBSD: nslm7x.c,v 1.44 2007/11/16 08:00:14 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.44 2007/11/16 08:00:14 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 <sys/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 <sys/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 = "-12V", 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 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(34, 34) / 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 lmsc->sc_sme = sysmon_envsys_create(); 1680 /* Initialize sensors */ 1681 for (i = 0; i < lmsc->numsensors; i++) { 1682 if (sysmon_envsys_sensor_attach(lmsc->sc_sme, 1683 &lmsc->sensors[i])) { 1684 sysmon_envsys_destroy(lmsc->sc_sme); 1685 return; 1686 } 1687 } 1688 1689 /* 1690 * Setup the callout to refresh sensor data every 2 seconds. 1691 */ 1692 callout_init(&lmsc->sc_callout, 0); 1693 callout_setfunc(&lmsc->sc_callout, lm_refresh, lmsc); 1694 callout_schedule(&lmsc->sc_callout, LM_REFRESH_TIMO); 1695 1696 /* 1697 * Hook into the System Monitor. 1698 */ 1699 lmsc->sc_sme->sme_name = lmsc->sc_dev.dv_xname; 1700 lmsc->sc_sme->sme_flags = SME_DISABLE_REFRESH; 1701 1702 if (sysmon_envsys_register(lmsc->sc_sme)) { 1703 aprint_error("%s: unable to register with sysmon\n", 1704 lmsc->sc_dev.dv_xname); 1705 sysmon_envsys_destroy(lmsc->sc_sme); 1706 } 1707 } 1708 1709 /* 1710 * Stop, destroy the callout and unregister the driver with the 1711 * sysmon_envsys(9) framework. 1712 */ 1713 void 1714 lm_detach(struct lm_softc *lmsc) 1715 { 1716 callout_stop(&lmsc->sc_callout); 1717 callout_destroy(&lmsc->sc_callout); 1718 sysmon_envsys_unregister(lmsc->sc_sme); 1719 } 1720 1721 static void 1722 lm_refresh(void *arg) 1723 { 1724 struct lm_softc *lmsc = arg; 1725 1726 lmsc->refresh_sensor_data(lmsc); 1727 callout_schedule(&lmsc->sc_callout, LM_REFRESH_TIMO); 1728 } 1729 1730 static int 1731 lm_match(struct lm_softc *sc) 1732 { 1733 const char *model = NULL; 1734 int chipid; 1735 1736 /* See if we have an LM78/LM78J/LM79 or LM81 */ 1737 chipid = (*sc->lm_readreg)(sc, LMD_CHIPID) & LM_ID_MASK; 1738 switch(chipid) { 1739 case LM_ID_LM78: 1740 model = "LM78"; 1741 break; 1742 case LM_ID_LM78J: 1743 model = "LM78J"; 1744 break; 1745 case LM_ID_LM79: 1746 model = "LM79"; 1747 break; 1748 case LM_ID_LM81: 1749 model = "LM81"; 1750 break; 1751 default: 1752 return 0; 1753 } 1754 1755 aprint_normal("\n"); 1756 aprint_normal("%s: National Semiconductor %s Hardware monitor\n", 1757 sc->sc_dev.dv_xname, model); 1758 1759 lm_setup_sensors(sc, lm78_sensors); 1760 sc->refresh_sensor_data = lm_refresh_sensor_data; 1761 return 1; 1762 } 1763 1764 static int 1765 def_match(struct lm_softc *sc) 1766 { 1767 int chipid; 1768 1769 chipid = (*sc->lm_readreg)(sc, LMD_CHIPID) & LM_ID_MASK; 1770 aprint_normal("\n"); 1771 aprint_error("%s: Unknown chip (ID %d)\n", sc->sc_dev.dv_xname, 1772 chipid); 1773 1774 lm_setup_sensors(sc, lm78_sensors); 1775 sc->refresh_sensor_data = lm_refresh_sensor_data; 1776 return 1; 1777 } 1778 1779 static int 1780 wb_match(struct lm_softc *sc) 1781 { 1782 const char *model = NULL; 1783 int banksel, vendid, devid; 1784 1785 aprint_normal("\n"); 1786 /* Read vendor ID */ 1787 banksel = (*sc->lm_readreg)(sc, WB_BANKSEL); 1788 lm_generic_banksel(sc, WB_BANKSEL_HBAC); 1789 vendid = (*sc->lm_readreg)(sc, WB_VENDID) << 8; 1790 lm_generic_banksel(sc, 0); 1791 vendid |= (*sc->lm_readreg)(sc, WB_VENDID); 1792 DPRINTF(("%s: winbond vend id 0x%x\n", __func__, vendid)); 1793 if (vendid != WB_VENDID_WINBOND && vendid != WB_VENDID_ASUS) 1794 return 0; 1795 1796 /* Read device/chip ID */ 1797 lm_generic_banksel(sc, WB_BANKSEL_B0); 1798 devid = (*sc->lm_readreg)(sc, LMD_CHIPID); 1799 sc->chipid = (*sc->lm_readreg)(sc, WB_BANK0_CHIPID); 1800 lm_generic_banksel(sc, banksel); 1801 DPRINTF(("%s: winbond chip id 0x%x\n", __func__, sc->chipid)); 1802 1803 switch(sc->chipid) { 1804 case WB_CHIPID_W83627HF: 1805 model = "W83627HF"; 1806 lm_setup_sensors(sc, w83627hf_sensors); 1807 break; 1808 case WB_CHIPID_W83627THF: 1809 model = "W83627THF"; 1810 lm_setup_sensors(sc, w83637hf_sensors); 1811 break; 1812 case WB_CHIPID_W83627EHF_A: 1813 model = "W83627EHF-A"; 1814 lm_setup_sensors(sc, w83627ehf_sensors); 1815 break; 1816 case WB_CHIPID_W83627EHF: 1817 model = "W83627EHF"; 1818 lm_setup_sensors(sc, w83627ehf_sensors); 1819 break; 1820 case WB_CHIPID_W83627DHG: 1821 model = "W83627DHG"; 1822 lm_setup_sensors(sc, w83627dhg_sensors); 1823 break; 1824 case WB_CHIPID_W83637HF: 1825 model = "W83637HF"; 1826 lm_generic_banksel(sc, WB_BANKSEL_B0); 1827 if ((*sc->lm_readreg)(sc, WB_BANK0_CONFIG) & WB_CONFIG_VMR9) 1828 sc->vrm9 = 1; 1829 lm_generic_banksel(sc, banksel); 1830 lm_setup_sensors(sc, w83637hf_sensors); 1831 break; 1832 case WB_CHIPID_W83697HF: 1833 model = "W83697HF"; 1834 lm_setup_sensors(sc, w83697hf_sensors); 1835 break; 1836 case WB_CHIPID_W83781D: 1837 case WB_CHIPID_W83781D_2: 1838 model = "W83781D"; 1839 lm_setup_sensors(sc, w83781d_sensors); 1840 break; 1841 case WB_CHIPID_W83782D: 1842 model = "W83782D"; 1843 lm_setup_sensors(sc, w83782d_sensors); 1844 break; 1845 case WB_CHIPID_W83783S: 1846 model = "W83783S"; 1847 lm_setup_sensors(sc, w83783s_sensors); 1848 break; 1849 case WB_CHIPID_W83791D: 1850 model = "W83791D"; 1851 lm_setup_sensors(sc, w83791d_sensors); 1852 break; 1853 case WB_CHIPID_W83791SD: 1854 model = "W83791SD"; 1855 break; 1856 case WB_CHIPID_W83792D: 1857 model = "W83792D"; 1858 lm_setup_sensors(sc, w83792d_sensors); 1859 break; 1860 case WB_CHIPID_AS99127F: 1861 if (vendid == WB_VENDID_ASUS) { 1862 model = "AS99127F"; 1863 lm_setup_sensors(sc, w83781d_sensors); 1864 } else { 1865 model = "AS99127F rev 2"; 1866 lm_setup_sensors(sc, as99127f_sensors); 1867 } 1868 break; 1869 default: 1870 aprint_normal("%s: unknown Winbond chip (ID 0x%x)\n", 1871 sc->sc_dev.dv_xname, sc->chipid); 1872 /* Handle as a standard LM78. */ 1873 lm_setup_sensors(sc, lm78_sensors); 1874 sc->refresh_sensor_data = lm_refresh_sensor_data; 1875 return 1; 1876 } 1877 1878 aprint_normal("%s: Winbond %s Hardware monitor\n", 1879 sc->sc_dev.dv_xname, model); 1880 1881 sc->refresh_sensor_data = wb_refresh_sensor_data; 1882 return 1; 1883 } 1884 1885 static void 1886 lm_setup_sensors(struct lm_softc *sc, struct lm_sensor *sensors) 1887 { 1888 int i; 1889 1890 for (i = 0; sensors[i].desc; i++) { 1891 sc->sensors[i].units = sensors[i].type; 1892 strlcpy(sc->sensors[i].desc, sensors[i].desc, 1893 sizeof(sc->sensors[i].desc)); 1894 sc->numsensors++; 1895 } 1896 sc->lm_sensors = sensors; 1897 } 1898 1899 static void 1900 lm_refresh_sensor_data(struct lm_softc *sc) 1901 { 1902 int i; 1903 1904 for (i = 0; i < sc->numsensors; i++) 1905 sc->lm_sensors[i].refresh(sc, i); 1906 } 1907 1908 static void 1909 lm_refresh_volt(struct lm_softc *sc, int n) 1910 { 1911 int data; 1912 1913 data = (*sc->lm_readreg)(sc, sc->lm_sensors[n].reg); 1914 if (data == 0xff) 1915 sc->sensors[n].state = ENVSYS_SINVALID; 1916 1917 sc->sensors[n].flags = ENVSYS_FCHANGERFACT; 1918 sc->sensors[n].value_cur = (data << 4); 1919 1920 if (sc->sensors[n].rfact) { 1921 sc->sensors[n].value_cur *= sc->sensors[n].rfact; 1922 sc->sensors[n].value_cur /= 10; 1923 } else { 1924 sc->sensors[n].value_cur *= sc->lm_sensors[n].rfact; 1925 sc->sensors[n].value_cur /= 10; 1926 sc->sensors[n].rfact = sc->lm_sensors[n].rfact; 1927 } 1928 1929 sc->sensors[n].state = ENVSYS_SVALID; 1930 DPRINTF(("%s: volt[%d] data=0x%x value_cur=%d\n", 1931 __func__, n, data, sc->sensors[n].value_cur)); 1932 } 1933 1934 static void 1935 lm_refresh_temp(struct lm_softc *sc, int n) 1936 { 1937 int data; 1938 1939 /* 1940 * The data sheet suggests that the range of the temperature 1941 * sensor is between -55 degC and +125 degC. 1942 */ 1943 data = (*sc->lm_readreg)(sc, sc->lm_sensors[n].reg); 1944 if (data > 0x7d && data < 0xc9) 1945 sc->sensors[n].state = ENVSYS_SINVALID; 1946 else { 1947 if (data & 0x80) 1948 data -= 0x100; 1949 sc->sensors[n].state = ENVSYS_SVALID; 1950 sc->sensors[n].value_cur = data * 1000000 + 273150000; 1951 } 1952 DPRINTF(("%s: temp[%d] data=0x%x value_cur=%d\n", 1953 __func__, n, data, sc->sensors[n].value_cur)); 1954 } 1955 1956 static void 1957 lm_refresh_fanrpm(struct lm_softc *sc, int n) 1958 { 1959 int data, divisor = 1; 1960 1961 /* 1962 * We might get more accurate fan readings by adjusting the 1963 * divisor, but that might interfere with APM or other SMM 1964 * BIOS code reading the fan speeds. 1965 */ 1966 1967 /* FAN3 has a fixed fan divisor. */ 1968 if (sc->lm_sensors[n].reg == LMD_FAN1 || 1969 sc->lm_sensors[n].reg == LMD_FAN2) { 1970 data = (*sc->lm_readreg)(sc, LMD_VIDFAN); 1971 if (sc->lm_sensors[n].reg == LMD_FAN1) 1972 divisor = (data >> 4) & 0x03; 1973 else 1974 divisor = (data >> 6) & 0x03; 1975 } 1976 1977 data = (*sc->lm_readreg)(sc, sc->lm_sensors[n].reg); 1978 if (data == 0xff || data == 0x00) 1979 sc->sensors[n].state = ENVSYS_SINVALID; 1980 else { 1981 sc->sensors[n].state = ENVSYS_SVALID; 1982 sc->sensors[n].value_cur = 1350000 / (data << divisor); 1983 } 1984 DPRINTF(("%s: fan[%d] data=0x%x value_cur=%d\n", 1985 __func__, n, data, sc->sensors[n].value_cur)); 1986 } 1987 1988 static void 1989 wb_refresh_sensor_data(struct lm_softc *sc) 1990 { 1991 int banksel, bank, i; 1992 1993 /* 1994 * Properly save and restore bank selection register. 1995 */ 1996 banksel = bank = sc->lm_readreg(sc, WB_BANKSEL); 1997 for (i = 0; i < sc->numsensors; i++) { 1998 if (bank != sc->lm_sensors[i].bank) { 1999 bank = sc->lm_sensors[i].bank; 2000 lm_generic_banksel(sc, bank); 2001 } 2002 sc->lm_sensors[i].refresh(sc, i); 2003 } 2004 lm_generic_banksel(sc, banksel); 2005 } 2006 2007 static void 2008 wb_w83637hf_refresh_vcore(struct lm_softc *sc, int n) 2009 { 2010 int data; 2011 2012 data = (*sc->lm_readreg)(sc, sc->lm_sensors[n].reg); 2013 /* 2014 * Depending on the voltage detection method, 2015 * one of the following formulas is used: 2016 * VRM8 method: value = raw * 0.016V 2017 * VRM9 method: value = raw * 0.00488V + 0.70V 2018 */ 2019 if (sc->vrm9) 2020 sc->sensors[n].value_cur = (data * 4880) + 700000; 2021 else 2022 sc->sensors[n].value_cur = (data * 16000); 2023 DPRINTF(("%s: volt[%d] data=0x%x value_cur=%d\n", 2024 __func__, n, data, sc->sensors[n].value_cur)); 2025 } 2026 2027 static void 2028 wb_refresh_nvolt(struct lm_softc *sc, int n) 2029 { 2030 int data; 2031 2032 data = (*sc->lm_readreg)(sc, sc->lm_sensors[n].reg); 2033 sc->sensors[n].flags = ENVSYS_FCHANGERFACT; 2034 sc->sensors[n].value_cur = ((data << 4) - WB_VREF); 2035 if (sc->sensors[n].rfact) 2036 sc->sensors[n].value_cur *= sc->sensors[n].rfact; 2037 else 2038 sc->sensors[n].value_cur *= sc->lm_sensors[n].rfact; 2039 2040 sc->sensors[n].value_cur /= 10; 2041 sc->sensors[n].value_cur += WB_VREF * 1000; 2042 DPRINTF(("%s: volt[%d] data=0x%x value_cur=%d\n", 2043 __func__, n , data, sc->sensors[n].value_cur)); 2044 } 2045 2046 static void 2047 wb_w83627ehf_refresh_nvolt(struct lm_softc *sc, int n) 2048 { 2049 int data; 2050 2051 data = (*sc->lm_readreg)(sc, sc->lm_sensors[n].reg); 2052 sc->sensors[n].value_cur = ((data << 3) - WB_W83627EHF_VREF); 2053 sc->sensors[n].flags = ENVSYS_FCHANGERFACT; 2054 if (sc->sensors[n].rfact) 2055 sc->sensors[n].value_cur *= sc->sensors[n].rfact; 2056 else 2057 sc->sensors[n].value_cur *= RFACT(232, 10); 2058 2059 sc->sensors[n].value_cur /= 10; 2060 sc->sensors[n].value_cur += WB_W83627EHF_VREF * 1000; 2061 DPRINTF(("%s: volt[%d] data=0x%x value_cur=%d\n", 2062 __func__, n , data, sc->sensors[n].value_cur)); 2063 } 2064 2065 static void 2066 wb_refresh_temp(struct lm_softc *sc, int n) 2067 { 2068 int data; 2069 2070 /* 2071 * The data sheet suggests that the range of the temperature 2072 * sensor is between -55 degC and +125 degC. However, values 2073 * around -48 degC seem to be a very common bogus values. 2074 * Since such values are unreasonably low, we use -45 degC for 2075 * the lower limit instead. 2076 */ 2077 data = (*sc->lm_readreg)(sc, sc->lm_sensors[n].reg) << 1; 2078 data += (*sc->lm_readreg)(sc, sc->lm_sensors[n].reg + 1) >> 7; 2079 if (data > 0xfffffff || (data > 0x0fa && data < 0x1a6)) { 2080 sc->sensors[n].state = ENVSYS_SINVALID; 2081 } else { 2082 if (data & 0x100) 2083 data -= 0x200; 2084 sc->sensors[n].state = ENVSYS_SVALID; 2085 sc->sensors[n].value_cur = data * 500000 + 273150000; 2086 } 2087 DPRINTF(("%s: temp[%d] data=0x%x value_cur=%d\n", 2088 __func__, n , data, sc->sensors[n].value_cur)); 2089 } 2090 2091 static void 2092 wb_refresh_fanrpm(struct lm_softc *sc, int n) 2093 { 2094 int fan, data, divisor = 0; 2095 2096 /* 2097 * This is madness; the fan divisor bits are scattered all 2098 * over the place. 2099 */ 2100 2101 if (sc->lm_sensors[n].reg == LMD_FAN1 || 2102 sc->lm_sensors[n].reg == LMD_FAN2 || 2103 sc->lm_sensors[n].reg == LMD_FAN3) { 2104 data = (*sc->lm_readreg)(sc, WB_BANK0_VBAT); 2105 fan = (sc->lm_sensors[n].reg - LMD_FAN1); 2106 if ((data >> 5) & (1 << fan)) 2107 divisor |= 0x04; 2108 } 2109 2110 if (sc->lm_sensors[n].reg == LMD_FAN1 || 2111 sc->lm_sensors[n].reg == LMD_FAN2) { 2112 data = (*sc->lm_readreg)(sc, LMD_VIDFAN); 2113 if (sc->lm_sensors[n].reg == LMD_FAN1) 2114 divisor |= (data >> 4) & 0x03; 2115 else 2116 divisor |= (data >> 6) & 0x03; 2117 } else if (sc->lm_sensors[n].reg == LMD_FAN3) { 2118 data = (*sc->lm_readreg)(sc, WB_PIN); 2119 divisor |= (data >> 6) & 0x03; 2120 } else if (sc->lm_sensors[n].reg == WB_BANK0_FAN4 || 2121 sc->lm_sensors[n].reg == WB_BANK0_FAN5) { 2122 data = (*sc->lm_readreg)(sc, WB_BANK0_FAN45); 2123 if (sc->lm_sensors[n].reg == WB_BANK0_FAN4) 2124 divisor |= (data >> 0) & 0x07; 2125 else 2126 divisor |= (data >> 4) & 0x07; 2127 } 2128 2129 data = (*sc->lm_readreg)(sc, sc->lm_sensors[n].reg); 2130 if (data >= 0xff || data == 0x00) 2131 sc->sensors[n].state = ENVSYS_SINVALID; 2132 else { 2133 sc->sensors[n].state = ENVSYS_SVALID; 2134 sc->sensors[n].value_cur = 1350000 / (data << divisor); 2135 } 2136 DPRINTF(("%s: fan[%d] data=0x%x value_cur=%d\n", 2137 __func__, n , data, sc->sensors[n].value_cur)); 2138 } 2139 2140 static void 2141 wb_w83792d_refresh_fanrpm(struct lm_softc *sc, int n) 2142 { 2143 int reg, shift, data, divisor = 1; 2144 2145 shift = 0; 2146 2147 switch (sc->lm_sensors[n].reg) { 2148 case 0x28: 2149 reg = 0x47; shift = 0; 2150 break; 2151 case 0x29: 2152 reg = 0x47; shift = 4; 2153 break; 2154 case 0x2a: 2155 reg = 0x5b; shift = 0; 2156 break; 2157 case 0xb8: 2158 reg = 0x5b; shift = 4; 2159 break; 2160 case 0xb9: 2161 reg = 0x5c; shift = 0; 2162 break; 2163 case 0xba: 2164 reg = 0x5c; shift = 4; 2165 break; 2166 case 0xbe: 2167 reg = 0x9e; shift = 0; 2168 break; 2169 default: 2170 reg = 0; 2171 break; 2172 } 2173 2174 data = (*sc->lm_readreg)(sc, sc->lm_sensors[n].reg); 2175 if (data == 0xff || data == 0x00) 2176 sc->sensors[n].state = ENVSYS_SINVALID; 2177 else { 2178 if (reg != 0) 2179 divisor = ((*sc->lm_readreg)(sc, reg) >> shift) & 0x7; 2180 sc->sensors[n].state = ENVSYS_SVALID; 2181 sc->sensors[n].value_cur = 1350000 / (data << divisor); 2182 } 2183 DPRINTF(("%s: fan[%d] data=0x%x value_cur=%d\n", 2184 __func__, n , data, sc->sensors[n].value_cur)); 2185 } 2186 2187 static void 2188 as_refresh_temp(struct lm_softc *sc, int n) 2189 { 2190 int data; 2191 2192 /* 2193 * It seems a shorted temperature diode produces an all-ones 2194 * bit pattern. 2195 */ 2196 data = (*sc->lm_readreg)(sc, sc->lm_sensors[n].reg) << 1; 2197 data += (*sc->lm_readreg)(sc, sc->lm_sensors[n].reg + 1) >> 7; 2198 if (data == 0x1ff) 2199 sc->sensors[n].state = ENVSYS_SINVALID; 2200 else { 2201 if (data & 0x100) 2202 data -= 0x200; 2203 sc->sensors[n].state = ENVSYS_SVALID; 2204 sc->sensors[n].value_cur = data * 500000 + 273150000; 2205 } 2206 DPRINTF(("%s: temp[%d] data=0x%x value_cur=%d\n", 2207 __func__, n, data, sc->sensors[n].value_cur)); 2208 } 2209