acpi_tz.c revision 1.50
1 /* $NetBSD: acpi_tz.c,v 1.50 2009/11/29 18:08:22 uebayasi Exp $ */ 2 3 /* 4 * Copyright (c) 2003 Jared D. McNeill <jmcneill (at) invisible.ca> 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. The name of the author may not be used to endorse or promote products 13 * derived from this software without specific prior written permission. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 20 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 21 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 22 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 23 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 25 * SUCH DAMAGE. 26 */ 27 28 /* 29 * ACPI Thermal Zone driver 30 */ 31 32 #include <sys/cdefs.h> 33 __KERNEL_RCSID(0, "$NetBSD: acpi_tz.c,v 1.50 2009/11/29 18:08:22 uebayasi Exp $"); 34 35 #include <sys/param.h> 36 #include <sys/systm.h> 37 #include <sys/kernel.h> 38 #include <sys/errno.h> 39 #include <sys/ioctl.h> 40 #include <sys/syslog.h> 41 #include <sys/device.h> 42 #include <sys/callout.h> 43 #include <sys/proc.h> 44 #include <dev/sysmon/sysmonvar.h> 45 46 #include <dev/acpi/acpica.h> 47 #include <dev/acpi/acpireg.h> 48 #include <dev/acpi/acpivar.h> 49 50 #define _COMPONENT ACPI_TZ_COMPONENT 51 ACPI_MODULE_NAME ("acpi_tz") 52 53 /* flags */ 54 #define ATZ_F_VERBOSE 0x01 /* show events to console */ 55 #define ATZ_F_CRITICAL 0x02 /* zone critical */ 56 #define ATZ_F_HOT 0x04 /* zone hot */ 57 #define ATZ_F_PASSIVE 0x08 /* zone passive cooling */ 58 #define ATZ_F_PASSIVEONLY 0x10 /* zone is passive cooling only */ 59 60 /* no active cooling level */ 61 #define ATZ_ACTIVE_NONE -1 62 63 /* constants */ 64 #define ATZ_TZP_RATE 300 /* default if no _TZP CM present (30 secs) */ 65 #define ATZ_NLEVELS 10 /* number of cooling levels, from ACPI spec */ 66 #define ATZ_ZEROC 2732 /* 0C in tenths degrees Kelvin */ 67 #define ATZ_TMP_INVALID 0xffffffff /* invalid temperature */ 68 #define ATZ_ZONE_EXPIRE 9000 /* zone info refetch interval (15min) */ 69 70 /* sensor indexes */ 71 #define ATZ_SENSOR_TEMP 0 /* thermal zone temperature */ 72 73 static int acpitz_match(device_t, cfdata_t, void *); 74 static void acpitz_attach(device_t, device_t, void *); 75 76 /* 77 * ACPI Temperature Zone information. Note all temperatures are reported 78 * in tenths of degrees Kelvin, and that the ACPI specification assumes 79 * that K = C + 273.2 rather than the nominal 273.15 used by envsys(4). 80 * So define an appropriate conversion. 81 */ 82 83 #define ATZ2UKELVIN(t) ((t) * 100000 - 50000) 84 85 struct acpitz_zone { 86 /* Active cooling temperature threshold */ 87 UINT32 ac[ATZ_NLEVELS]; 88 /* Package of references to all active cooling devices for a level */ 89 ACPI_BUFFER al[ATZ_NLEVELS]; 90 /* Critical temperature threshold for system shutdown */ 91 UINT32 crt; 92 /* Critical temperature threshold for S4 sleep */ 93 UINT32 hot; 94 /* Package of references to processor objects for passive cooling */ 95 ACPI_BUFFER psl; 96 /* Conveys if temperatures are absolute or relative values. */ 97 UINT32 rtv; 98 /* Passive cooling temperature threshold */ 99 UINT32 psv; 100 /* Thermal constants for use in passive cooling formulas */ 101 UINT32 tc1, tc2; 102 /* Current temperature of the thermal zone */ 103 UINT32 prevtmp, tmp; 104 /* Thermal sampling period for passive cooling, in tenths of seconds */ 105 UINT32 tsp; 106 /* Package of references to devices in this TZ (optional) */ 107 ACPI_BUFFER tzd; 108 /* Recommended TZ polling frequency, in tenths of seconds */ 109 UINT32 tzp; 110 /* Thermal zone name */ 111 char *name; 112 /* FAN min, max, current rpms */ 113 UINT32 fanmin, fanmax, fancurrent; 114 }; 115 116 struct acpitz_softc { 117 struct acpi_devnode *sc_devnode; 118 struct acpitz_zone sc_zone; 119 struct callout sc_callout; 120 struct sysmon_envsys *sc_sme; 121 envsys_data_t sc_temp_sensor; 122 envsys_data_t sc_fan_sensor; 123 int sc_active; /* active cooling level */ 124 int sc_flags; 125 int sc_rate; /* tz poll rate */ 126 int sc_zone_expire; 127 128 int sc_first; 129 int sc_have_fan; /* FAN sensor is optional */ 130 }; 131 132 static void acpitz_get_status(void *); 133 static void acpitz_get_zone(void *, int); 134 static void acpitz_get_zone_quiet(void *); 135 static char *acpitz_celcius_string(int); 136 static void acpitz_print_status(device_t); 137 static void acpitz_power_off(struct acpitz_softc *); 138 static void acpitz_power_zone(struct acpitz_softc *, int, int); 139 static void acpitz_sane_temp(UINT32 *tmp); 140 static ACPI_STATUS 141 acpitz_switch_cooler(ACPI_OBJECT *, void *); 142 static void acpitz_notify_handler(ACPI_HANDLE, UINT32, void *); 143 static int acpitz_get_integer(device_t, const char *, UINT32 *); 144 static void acpitz_tick(void *); 145 static void acpitz_init_envsys(device_t); 146 static void acpitz_get_limits(struct sysmon_envsys *, envsys_data_t *, 147 sysmon_envsys_lim_t *); 148 static int acpitz_get_fanspeed(device_t, UINT32 *, UINT32 *, UINT32 *); 149 #ifdef notyet 150 static ACPI_STATUS 151 acpitz_set_fanspeed(device_t, UINT32); 152 #endif 153 154 CFATTACH_DECL_NEW(acpitz, sizeof(struct acpitz_softc), acpitz_match, 155 acpitz_attach, NULL, NULL); 156 157 /* 158 * acpitz_match: autoconf(9) match routine 159 */ 160 static int 161 acpitz_match(device_t parent, cfdata_t match, void *aux) 162 { 163 struct acpi_attach_args *aa = aux; 164 165 if (aa->aa_node->ad_type != ACPI_TYPE_THERMAL) 166 return 0; 167 168 return 1; 169 } 170 171 /* 172 * acpitz_attach: autoconf(9) attach routine 173 */ 174 static void 175 acpitz_attach(device_t parent, device_t self, void *aux) 176 { 177 struct acpitz_softc *sc = device_private(self); 178 struct acpi_attach_args *aa = aux; 179 ACPI_STATUS rv; 180 ACPI_INTEGER v; 181 182 #if 0 183 sc->sc_flags = ATZ_F_VERBOSE; 184 #endif 185 sc->sc_devnode = aa->aa_node; 186 187 aprint_naive("\n"); 188 189 rv = acpi_eval_integer(sc->sc_devnode->ad_handle, "_TZP", &v); 190 if (ACPI_FAILURE(rv)) 191 sc->sc_zone.tzp = ATZ_TZP_RATE; 192 else 193 sc->sc_zone.tzp = v; 194 195 aprint_debug(" sample rate %d.%ds\n", 196 sc->sc_zone.tzp / 10, sc->sc_zone.tzp % 10); 197 198 /* XXX a value of 0 means "polling is not necessary" */ 199 if (sc->sc_zone.tzp == 0) 200 sc->sc_zone.tzp = ATZ_TZP_RATE; 201 202 sc->sc_zone_expire = ATZ_ZONE_EXPIRE / sc->sc_zone.tzp; 203 sc->sc_first = 1; 204 sc->sc_have_fan = 0; 205 if (acpitz_get_fanspeed(self, 206 &sc->sc_zone.fanmin, &sc->sc_zone.fanmax, &sc->sc_zone.fancurrent) 207 == 0) 208 sc->sc_have_fan = 1; 209 210 rv = acpi_eval_string(sc->sc_devnode->ad_handle, 211 "REGN", &sc->sc_zone.name); 212 if (ACPI_FAILURE(rv)) 213 sc->sc_zone.name = __UNCONST("temperature"); 214 acpitz_get_zone(self, 1); 215 acpitz_get_status(self); 216 217 rv = AcpiInstallNotifyHandler(sc->sc_devnode->ad_handle, 218 ACPI_SYSTEM_NOTIFY, acpitz_notify_handler, self); 219 if (ACPI_FAILURE(rv)) { 220 aprint_error(": unable to install SYSTEM NOTIFY handler: %s\n", 221 AcpiFormatException(rv)); 222 return; 223 } 224 225 callout_init(&sc->sc_callout, CALLOUT_MPSAFE); 226 callout_setfunc(&sc->sc_callout, acpitz_tick, self); 227 228 acpitz_init_envsys(self); 229 230 if (!pmf_device_register(self, NULL, NULL)) 231 aprint_error(": couldn't establish power handler\n"); 232 233 callout_schedule(&sc->sc_callout, sc->sc_zone.tzp * hz / 10); 234 } 235 236 static void 237 acpitz_get_zone_quiet(void *opaque) 238 { 239 acpitz_get_zone(opaque, 0); 240 } 241 242 static void 243 acpitz_get_status(void *opaque) 244 { 245 device_t dv = opaque; 246 struct acpitz_softc *sc = device_private(dv); 247 UINT32 tmp, active; 248 int i, flags; 249 UINT32 fmin, fmax, fcurrent; 250 251 sc->sc_zone_expire--; 252 if (sc->sc_zone_expire <= 0) { 253 sc->sc_zone_expire = ATZ_ZONE_EXPIRE / sc->sc_zone.tzp; 254 if (sc->sc_flags & ATZ_F_VERBOSE) 255 printf("%s: force refetch zone\n", device_xname(dv)); 256 acpitz_get_zone(dv, 0); 257 } 258 259 if (acpitz_get_integer(dv, "_TMP", &tmp)) { 260 aprint_error_dev(dv, "failed to evaluate _TMP\n"); 261 return; 262 } 263 264 sc->sc_zone.prevtmp = sc->sc_zone.tmp; 265 sc->sc_zone.tmp = tmp; 266 if (sc->sc_first) 267 sc->sc_zone.prevtmp = tmp; 268 /* XXX sanity check for tmp here? */ 269 270 if (acpitz_get_fanspeed(dv, &fmin, &fmax, &fcurrent) == 0) { 271 if (fcurrent != ATZ_TMP_INVALID) 272 sc->sc_zone.fancurrent = fcurrent; 273 } 274 275 /* 276 * The temperature unit for envsys(4) is microKelvin, so convert to 277 * that from ACPI's microKelvin. Also, the ACPI specification assumes 278 * that K = C + 273.2 rather than the nominal 273.15 used by envsys(4), 279 * so we correct for that too. 280 */ 281 sc->sc_temp_sensor.value_cur = ATZ2UKELVIN(sc->sc_zone.tmp); 282 sc->sc_temp_sensor.state = ENVSYS_SVALID; 283 284 sc->sc_fan_sensor.value_cur = sc->sc_zone.fancurrent; 285 sc->sc_fan_sensor.state = ENVSYS_SVALID; 286 287 if (sc->sc_flags & ATZ_F_VERBOSE) 288 acpitz_print_status(dv); 289 290 if (sc->sc_flags & ATZ_F_PASSIVEONLY) { 291 /* Passive Cooling: XXX not yet */ 292 293 } else { 294 /* Active Cooling */ 295 296 /* temperature threshold: _AC0 > ... > _AC9 */ 297 active = ATZ_ACTIVE_NONE; 298 for (i = ATZ_NLEVELS - 1; i >= 0; i--) { 299 if (sc->sc_zone.ac[i] == ATZ_TMP_INVALID) 300 continue; 301 302 /* we want to keep highest cooling mode in 'active' */ 303 if (sc->sc_zone.ac[i] <= tmp) 304 active = i; 305 } 306 if (active != ATZ_ACTIVE_NONE) 307 sc->sc_temp_sensor.state = ENVSYS_SWARNOVER; 308 309 flags = sc->sc_flags & 310 ~(ATZ_F_CRITICAL|ATZ_F_HOT|ATZ_F_PASSIVE); 311 if (sc->sc_zone.psv != ATZ_TMP_INVALID && 312 tmp >= sc->sc_zone.psv) 313 flags |= ATZ_F_PASSIVE; 314 if (sc->sc_zone.hot != ATZ_TMP_INVALID && 315 tmp >= sc->sc_zone.hot) 316 flags |= ATZ_F_HOT; 317 if (sc->sc_zone.crt != ATZ_TMP_INVALID && 318 tmp >= sc->sc_zone.crt) 319 flags |= ATZ_F_CRITICAL; 320 321 if (flags != sc->sc_flags) { 322 int changed = (sc->sc_flags ^ flags) & flags; 323 sc->sc_flags = flags; 324 if (changed & ATZ_F_CRITICAL) { 325 sc->sc_temp_sensor.state = ENVSYS_SCRITOVER; 326 aprint_debug_dev(dv, 327 "zone went critical at temp %sC\n", 328 acpitz_celcius_string(tmp)); 329 } else if (changed & ATZ_F_HOT) { 330 sc->sc_temp_sensor.state = ENVSYS_SCRITOVER; 331 aprint_debug_dev(dv, 332 "zone went hot at temp %sC\n", 333 acpitz_celcius_string(tmp)); 334 } 335 } 336 337 /* power on fans */ 338 if (sc->sc_active != active) { 339 if (sc->sc_active != ATZ_ACTIVE_NONE) 340 acpitz_power_zone(sc, sc->sc_active, 0); 341 342 if (active != ATZ_ACTIVE_NONE) { 343 if (sc->sc_flags & ATZ_F_VERBOSE) 344 printf("%s: active cooling level %u\n", 345 device_xname(dv), active); 346 acpitz_power_zone(sc, active, 1); 347 } 348 349 sc->sc_active = active; 350 } 351 } 352 353 return; 354 } 355 356 static char * 357 acpitz_celcius_string(int dk) 358 { 359 static char buf[10]; 360 361 snprintf(buf, sizeof(buf), "%d.%d", (dk - ATZ_ZEROC) / 10, 362 (dk - ATZ_ZEROC) % 10); 363 364 return buf; 365 } 366 367 static void 368 acpitz_print_status(device_t dv) 369 { 370 struct acpitz_softc *sc = device_private(dv); 371 372 printf("%s: zone temperature is now %sC\n", device_xname(dv), 373 acpitz_celcius_string(sc->sc_zone.tmp)); 374 if (sc->sc_have_fan) { 375 printf("%s: fan rpm %u\n", device_xname(dv), 376 sc->sc_zone.fancurrent); 377 } 378 379 return; 380 } 381 382 static ACPI_STATUS 383 acpitz_switch_cooler(ACPI_OBJECT *obj, void *arg) 384 { 385 ACPI_HANDLE cooler; 386 ACPI_STATUS rv; 387 int pwr_state, flag; 388 389 flag = *(int *)arg; 390 391 if (flag) 392 pwr_state = ACPI_STATE_D0; 393 else 394 pwr_state = ACPI_STATE_D3; 395 396 switch(obj->Type) { 397 case ACPI_TYPE_LOCAL_REFERENCE: 398 case ACPI_TYPE_ANY: 399 cooler = obj->Reference.Handle; 400 break; 401 case ACPI_TYPE_STRING: 402 rv = AcpiGetHandle(NULL, obj->String.Pointer, &cooler); 403 if (ACPI_FAILURE(rv)) { 404 printf("acpitz_switch_cooler: " 405 "failed to get handler from %s\n", 406 obj->String.Pointer); 407 return rv; 408 } 409 break; 410 default: 411 printf("acpitz_switch_cooler: " 412 "unknown power type: %d\n", obj->Type); 413 return AE_OK; 414 } 415 416 rv = acpi_pwr_switch_consumer(cooler, pwr_state); 417 if (rv != AE_BAD_PARAMETER && ACPI_FAILURE(rv)) { 418 printf("acpitz_switch_cooler: " 419 "failed to change state for %s: %s\n", 420 acpi_name(obj->Reference.Handle), 421 AcpiFormatException(rv)); 422 } 423 424 return AE_OK; 425 } 426 427 /* 428 * acpitz_power_zone: 429 * power on or off the i:th part of the zone zone 430 */ 431 static void 432 acpitz_power_zone(struct acpitz_softc *sc, int i, int on) 433 { 434 KASSERT(i >= 0 && i < ATZ_NLEVELS); 435 436 acpi_foreach_package_object(sc->sc_zone.al[i].Pointer, 437 acpitz_switch_cooler, &on); 438 } 439 440 441 /* 442 * acpitz_power_off: 443 * power off parts of the zone 444 */ 445 static void 446 acpitz_power_off(struct acpitz_softc *sc) 447 { 448 int i; 449 450 for (i = 0 ; i < ATZ_NLEVELS; i++) { 451 if (sc->sc_zone.al[i].Pointer == NULL) 452 continue; 453 acpitz_power_zone(sc, i, 0); 454 } 455 sc->sc_active = ATZ_ACTIVE_NONE; 456 sc->sc_flags &= ~(ATZ_F_CRITICAL|ATZ_F_HOT|ATZ_F_PASSIVE); 457 } 458 459 static void 460 acpitz_get_zone(void *opaque, int verbose) 461 { 462 device_t dv = opaque; 463 struct acpitz_softc *sc = device_private(dv); 464 ACPI_STATUS rv; 465 char buf[8]; 466 int i, valid_levels; 467 468 if (!sc->sc_first) { 469 acpitz_power_off(sc); 470 471 for (i = 0; i < ATZ_NLEVELS; i++) { 472 if (sc->sc_zone.al[i].Pointer != NULL) 473 ACPI_FREE(sc->sc_zone.al[i].Pointer); 474 sc->sc_zone.al[i].Pointer = NULL; 475 } 476 } else 477 aprint_normal(":"); 478 479 valid_levels = 0; 480 481 for (i = 0; i < ATZ_NLEVELS; i++) { 482 ACPI_OBJECT *obj; 483 484 snprintf(buf, sizeof(buf), "_AC%d", i); 485 if (acpitz_get_integer(dv, buf, &sc->sc_zone.ac[i])) 486 continue; 487 488 snprintf(buf, sizeof(buf), "_AL%d", i); 489 rv = acpi_eval_struct(sc->sc_devnode->ad_handle, buf, 490 &sc->sc_zone.al[i]); 491 if (ACPI_FAILURE(rv)) { 492 sc->sc_zone.al[i].Pointer = NULL; 493 continue; 494 } 495 496 obj = sc->sc_zone.al[i].Pointer; 497 if (obj != NULL) { 498 if (obj->Type != ACPI_TYPE_PACKAGE) { 499 aprint_error("%d not package\n", i); 500 ACPI_FREE(obj); 501 sc->sc_zone.al[i].Pointer = NULL; 502 continue; 503 } 504 } 505 506 if (sc->sc_first) 507 aprint_normal(" active cooling level %d: %sC", i, 508 acpitz_celcius_string(sc->sc_zone.ac[i])); 509 510 valid_levels++; 511 } 512 513 acpitz_get_integer(dv, "_TMP", &sc->sc_zone.tmp); 514 acpitz_get_integer(dv, "_CRT", &sc->sc_zone.crt); 515 acpitz_get_integer(dv, "_HOT", &sc->sc_zone.hot); 516 sc->sc_zone.psl.Length = ACPI_ALLOCATE_LOCAL_BUFFER; 517 sc->sc_zone.psl.Pointer = NULL; 518 AcpiEvaluateObject(sc->sc_devnode->ad_handle, 519 "_PSL", NULL, &sc->sc_zone.psl); 520 acpitz_get_integer(dv, "_PSV", &sc->sc_zone.psv); 521 acpitz_get_integer(dv, "_TC1", &sc->sc_zone.tc1); 522 acpitz_get_integer(dv, "_TC2", &sc->sc_zone.tc2); 523 524 /* ACPI spec: If _RTV is not present or present and zero, 525 * values are absolute. */ 526 acpitz_get_integer(dv, "_RTV", &sc->sc_zone.rtv); 527 if (sc->sc_zone.rtv == ATZ_TMP_INVALID) 528 sc->sc_zone.rtv = 0; 529 530 531 acpitz_sane_temp(&sc->sc_zone.tmp); 532 acpitz_sane_temp(&sc->sc_zone.crt); 533 acpitz_sane_temp(&sc->sc_zone.hot); 534 acpitz_sane_temp(&sc->sc_zone.psv); 535 536 if (verbose) { 537 if (sc->sc_zone.crt != ATZ_TMP_INVALID) 538 aprint_normal(" critical %sC", 539 acpitz_celcius_string(sc->sc_zone.crt)); 540 if (sc->sc_zone.hot != ATZ_TMP_INVALID) 541 aprint_normal(" hot %sC", 542 acpitz_celcius_string(sc->sc_zone.hot)); 543 if (sc->sc_zone.psv != ATZ_TMP_INVALID) 544 aprint_normal(" passive %sC", 545 acpitz_celcius_string(sc->sc_zone.tmp)); 546 } 547 548 if (valid_levels == 0) { 549 sc->sc_flags |= ATZ_F_PASSIVEONLY; 550 if (sc->sc_first) 551 aprint_normal(", passive cooling"); 552 } 553 if (verbose) 554 aprint_normal("\n"); 555 556 for (i = 0; i < ATZ_NLEVELS; i++) 557 acpitz_sane_temp(&sc->sc_zone.ac[i]); 558 559 acpitz_power_off(sc); 560 sc->sc_first = 0; 561 } 562 563 564 static void 565 acpitz_notify_handler(ACPI_HANDLE hdl, UINT32 notify, void *opaque) 566 { 567 device_t dv = opaque; 568 ACPI_OSD_EXEC_CALLBACK func = NULL; 569 const char *name; 570 ACPI_STATUS rv; 571 572 switch (notify) { 573 case ACPI_NOTIFY_ThermalZoneStatusChanged: 574 func = acpitz_get_status; 575 name = "status check"; 576 break; 577 case ACPI_NOTIFY_ThermalZoneTripPointsChanged: 578 case ACPI_NOTIFY_DeviceListsChanged: 579 func = acpitz_get_zone_quiet; 580 name = "get zone"; 581 break; 582 default: 583 aprint_debug_dev(dv, 584 "received unhandled notify message 0x%x\n", notify); 585 return; 586 } 587 588 KASSERT(func != NULL); 589 590 rv = AcpiOsExecute(OSL_NOTIFY_HANDLER, func, dv); 591 if (ACPI_FAILURE(rv)) 592 aprint_debug_dev(dv, "unable to queue %s\n", name); 593 } 594 595 static void 596 acpitz_sane_temp(UINT32 *tmp) 597 { 598 /* Sane temperatures are beteen 0 and 150 C */ 599 if (*tmp < ATZ_ZEROC || *tmp > ATZ_ZEROC + 1500) 600 *tmp = ATZ_TMP_INVALID; 601 } 602 603 static int 604 acpitz_get_integer(device_t dv, const char *cm, UINT32 *val) 605 { 606 struct acpitz_softc *sc = device_private(dv); 607 ACPI_STATUS rv; 608 ACPI_INTEGER tmp; 609 610 rv = acpi_eval_integer(sc->sc_devnode->ad_handle, cm, &tmp); 611 if (ACPI_FAILURE(rv)) { 612 #ifdef ACPI_DEBUG 613 aprint_debug_dev(dv, "failed to evaluate %s: %s\n", 614 cm, AcpiFormatException(rv)); 615 #endif 616 *val = ATZ_TMP_INVALID; 617 return 1; 618 } 619 620 *val = tmp; 621 622 return 0; 623 } 624 625 static int 626 acpitz_get_fanspeed(device_t dv, 627 UINT32 *fanmin, UINT32 *fanmax, UINT32 *fancurrent) 628 { 629 struct acpitz_softc *sc = device_private(dv); 630 ACPI_STATUS rv; 631 ACPI_HANDLE handle; 632 ACPI_INTEGER fmin, fmax, fcurr; 633 int rc = 0; 634 635 handle = sc->sc_devnode->ad_handle; 636 rv = acpi_eval_integer(handle, "FMIN", &fmin); 637 if (ACPI_FAILURE(rv)) { 638 fmin = ATZ_TMP_INVALID; 639 rc = 1; 640 } 641 rv = acpi_eval_integer(handle, "FMAX", &fmax); 642 if (ACPI_FAILURE(rv)) { 643 fmax = ATZ_TMP_INVALID; 644 rc = 1; 645 } 646 rv = acpi_eval_integer(handle, "FRSP", &fcurr); 647 if (ACPI_FAILURE(rv)) { 648 fcurr = ATZ_TMP_INVALID; 649 rc = 1; 650 } 651 652 if (fanmin) 653 *fanmin = fmin; 654 if (fanmax) 655 *fanmax = fmax; 656 if (fancurrent) 657 *fancurrent = fcurr; 658 return rc; 659 } 660 661 #ifdef notyet 662 static ACPI_STATUS 663 acpitz_set_fanspeed(device_t dv, UINT32 fanspeed) 664 { 665 struct acpitz_softc *sc = device_private(dv); 666 ACPI_STATUS rv; 667 ACPI_HANDLE handle; 668 handle = sc->sc_devnode->ad_handle; 669 670 rv = acpi_eval_set_integer(handle, "FSSP", fanspeed); 671 if (ACPI_FAILURE(rv)) 672 aprint_debug_dev(dv, "failed to set fanspeed to %u rpm: %s\n", 673 fanspeed, AcpiFormatException(rv)); 674 return rv; 675 } 676 #endif 677 678 static void 679 acpitz_tick(void *opaque) 680 { 681 device_t dv = opaque; 682 struct acpitz_softc *sc = device_private(dv); 683 684 AcpiOsExecute(OSL_NOTIFY_HANDLER, acpitz_get_status, dv); 685 686 callout_schedule(&sc->sc_callout, sc->sc_zone.tzp * hz / 10); 687 } 688 689 static void 690 acpitz_init_envsys(device_t dv) 691 { 692 struct acpitz_softc *sc = device_private(dv); 693 694 sc->sc_sme = sysmon_envsys_create(); 695 sc->sc_sme->sme_get_limits = acpitz_get_limits; 696 sc->sc_sme->sme_cookie = sc; 697 sc->sc_sme->sme_name = device_xname(dv); 698 sc->sc_sme->sme_flags = SME_DISABLE_REFRESH; 699 700 sc->sc_temp_sensor.monitor = true; 701 sc->sc_temp_sensor.flags = ENVSYS_FMONLIMITS | ENVSYS_FMONNOTSUPP; 702 sc->sc_temp_sensor.units = ENVSYS_STEMP; 703 strlcpy(sc->sc_temp_sensor.desc, 704 sc->sc_zone.name, sizeof(sc->sc_temp_sensor.desc)); 705 if (sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_temp_sensor)) 706 goto out; 707 708 if (sc->sc_have_fan) { 709 sc->sc_fan_sensor.monitor = true; 710 sc->sc_fan_sensor.flags = 711 ENVSYS_FMONLIMITS | ENVSYS_FMONNOTSUPP; 712 sc->sc_fan_sensor.units = ENVSYS_SFANRPM; 713 strlcpy(sc->sc_fan_sensor.desc, 714 "FAN", sizeof(sc->sc_fan_sensor.desc)); 715 if (sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_fan_sensor)) 716 /* ignore error because fan sensor is optional */ 717 aprint_error_dev(dv, "unable to attach fan sensor\n"); 718 } 719 720 /* hook into sysmon */ 721 if (sysmon_envsys_register(sc->sc_sme) == 0) 722 return; 723 724 out: 725 aprint_error_dev(dv, "unable to register with sysmon\n"); 726 sysmon_envsys_destroy(sc->sc_sme); 727 } 728 729 static void 730 acpitz_get_limits(struct sysmon_envsys *sme, envsys_data_t *edata, 731 sysmon_envsys_lim_t *limits) 732 { 733 struct acpitz_softc *sc = sme->sme_cookie; 734 int i; 735 736 switch (edata->units) { 737 case ENVSYS_STEMP: 738 limits->sel_flags = 0; 739 if (sc->sc_zone.hot != ATZ_TMP_INVALID) { 740 limits->sel_flags |= PROP_CRITMAX; 741 limits->sel_critmax = ATZ2UKELVIN(sc->sc_zone.hot); 742 } else if (sc->sc_zone.crt != ATZ_TMP_INVALID) { 743 limits->sel_flags |= PROP_CRITMAX; 744 limits->sel_critmax = ATZ2UKELVIN(sc->sc_zone.crt); 745 } 746 for (i = 0; i < ATZ_NLEVELS; i++) { 747 if (sc->sc_zone.ac[i] != ATZ_TMP_INVALID) { 748 limits->sel_critmax = 749 ATZ2UKELVIN(sc->sc_zone.ac[i]); 750 limits->sel_flags |= PROP_WARNMAX; 751 break; 752 } 753 } 754 break; 755 756 case ENVSYS_SFANRPM: 757 limits->sel_flags = 0; 758 if (sc->sc_zone.fanmin != ATZ_TMP_INVALID) { 759 limits->sel_flags |= PROP_WARNMIN; 760 limits->sel_warnmin = sc->sc_zone.fanmin; 761 sc->sc_fan_sensor.flags |= ENVSYS_FVALID_MIN; 762 } 763 if (sc->sc_zone.fanmax != ATZ_TMP_INVALID) { 764 limits->sel_flags |= PROP_WARNMAX; 765 limits->sel_warnmax = sc->sc_zone.fanmax; 766 sc->sc_fan_sensor.flags |= ENVSYS_FVALID_MAX; 767 } 768 break; 769 } 770 } 771
Indexes created Tue Oct 14 21:09:58 GMT 2025