acpi_tz.c revision 1.27
1 /* $NetBSD: acpi_tz.c,v 1.27 2007/11/16 08:00:13 xtraeme 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.27 2007/11/16 08:00:13 xtraeme 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 <sys/mutex.h> 45 #include <dev/sysmon/sysmonvar.h> 46 47 #include <dev/acpi/acpica.h> 48 #include <dev/acpi/acpireg.h> 49 #include <dev/acpi/acpivar.h> 50 51 /* flags */ 52 #define ATZ_F_VERBOSE 0x01 /* show events to console */ 53 #define ATZ_F_CRITICAL 0x02 /* zone critical */ 54 #define ATZ_F_HOT 0x04 /* zone hot */ 55 #define ATZ_F_PASSIVE 0x08 /* zone passive cooling */ 56 #define ATZ_F_PASSIVEONLY 0x10 /* zone is passive cooling only */ 57 58 /* no active cooling level */ 59 #define ATZ_ACTIVE_NONE -1 60 61 /* constants */ 62 #define ATZ_TZP_RATE 300 /* default if no _TZP CM present (30 secs) */ 63 #define ATZ_NLEVELS 10 /* number of cooling levels, from ACPI spec */ 64 #define ATZ_ZEROC 2732 /* 0C in tenths degrees Kelvin */ 65 #define ATZ_TMP_INVALID 0xffffffff /* invalid temperature */ 66 #define ATZ_ZONE_EXPIRE 9000 /* zone info refetch interval (15min) */ 67 68 /* sensor indexes */ 69 #define ATZ_SENSOR_TEMP 0 /* thermal zone temperature */ 70 71 static int acpitz_match(struct device *, struct cfdata *, void *); 72 static void acpitz_attach(struct device *, struct device *, void *); 73 74 /* 75 * ACPI Temperature Zone information. Note all temperatures are reported 76 * in tenths of degrees Kelvin 77 */ 78 struct acpitz_zone { 79 /* Active cooling temperature threshold */ 80 UINT32 ac[ATZ_NLEVELS]; 81 /* Package of references to all active cooling devices for a level */ 82 ACPI_BUFFER al[ATZ_NLEVELS]; 83 /* Critical temperature threshold for system shutdown */ 84 UINT32 crt; 85 /* Critical temperature threshold for S4 sleep */ 86 UINT32 hot; 87 /* Package of references to processor objects for passive cooling */ 88 ACPI_BUFFER psl; 89 /* Passive cooling temperature threshold */ 90 UINT32 psv; 91 /* Thermal constants for use in passive cooling formulas */ 92 UINT32 tc1, tc2; 93 /* Current temperature of the thermal zone */ 94 UINT32 tmp; 95 /* Thermal sampling period for passive cooling, in tenths of seconds */ 96 UINT32 tsp; 97 /* Package of references to devices in this TZ (optional) */ 98 ACPI_BUFFER tzd; 99 /* Recommended TZ polling frequency, in tenths of seconds */ 100 UINT32 tzp; 101 }; 102 103 struct acpitz_softc { 104 struct device sc_dev; 105 struct acpi_devnode *sc_devnode; 106 struct acpitz_zone sc_zone; 107 struct callout sc_callout; 108 struct sysmon_envsys *sc_sme; 109 envsys_data_t sc_sensor; 110 kmutex_t sc_mtx; 111 int sc_active; /* active cooling level */ 112 int sc_flags; 113 int sc_rate; /* tz poll rate */ 114 int sc_zone_expire; 115 }; 116 117 static void acpitz_get_status(void *); 118 static void acpitz_get_zone(void *, int); 119 static void acpitz_get_zone_quiet(void *); 120 static char* acpitz_celcius_string(int); 121 static void acpitz_print_status(struct acpitz_softc *); 122 static void acpitz_power_off(struct acpitz_softc *); 123 static void acpitz_power_zone(struct acpitz_softc *, int, int); 124 static void acpitz_sane_temp(UINT32 *tmp); 125 static ACPI_STATUS 126 acpitz_switch_cooler(ACPI_OBJECT *, void *); 127 static void acpitz_notify_handler(ACPI_HANDLE, UINT32, void *); 128 static int acpitz_get_integer(struct acpitz_softc *, const char *, UINT32 *); 129 static void acpitz_tick(void *); 130 static void acpitz_init_envsys(struct acpitz_softc *); 131 132 CFATTACH_DECL(acpitz, sizeof(struct acpitz_softc), acpitz_match, 133 acpitz_attach, NULL, NULL); 134 135 /* 136 * acpitz_match: autoconf(9) match routine 137 */ 138 static int 139 acpitz_match(struct device *parent, struct cfdata *match, void *aux) 140 { 141 struct acpi_attach_args *aa = aux; 142 143 if (aa->aa_node->ad_type != ACPI_TYPE_THERMAL) 144 return 0; 145 146 return 1; 147 } 148 149 /* 150 * acpitz_attach: autoconf(9) attach routine 151 */ 152 static void 153 acpitz_attach(struct device *parent, struct device *self, void *aux) 154 { 155 struct acpitz_softc *sc = (struct acpitz_softc *)self; 156 struct acpi_attach_args *aa = aux; 157 ACPI_STATUS rv; 158 ACPI_INTEGER v; 159 160 mutex_init(&sc->sc_mtx, MUTEX_DRIVER, IPL_NONE); 161 162 #if 0 163 sc->sc_flags = ATZ_F_VERBOSE; 164 #endif 165 sc->sc_devnode = aa->aa_node; 166 167 aprint_naive(": ACPI Thermal Zone\n"); 168 aprint_normal(": ACPI Thermal Zone\n"); 169 170 rv = acpi_eval_integer(sc->sc_devnode->ad_handle, "_TZP", &v); 171 if (ACPI_FAILURE(rv)) { 172 aprint_verbose("%s: unable to get polling interval; using default of", 173 sc->sc_dev.dv_xname); 174 sc->sc_zone.tzp = ATZ_TZP_RATE; 175 } else { 176 sc->sc_zone.tzp = v; 177 aprint_verbose("%s: polling interval is", sc->sc_dev.dv_xname); 178 } 179 aprint_verbose(" %d.%ds\n", sc->sc_zone.tzp / 10, sc->sc_zone.tzp % 10); 180 181 /* XXX a value of 0 means "polling is not necessary" */ 182 if (sc->sc_zone.tzp == 0) 183 sc->sc_zone.tzp = ATZ_TZP_RATE; 184 185 sc->sc_zone_expire = ATZ_ZONE_EXPIRE / sc->sc_zone.tzp; 186 187 acpitz_get_zone(sc, 1); 188 acpitz_get_status(sc); 189 190 rv = AcpiInstallNotifyHandler(sc->sc_devnode->ad_handle, 191 ACPI_SYSTEM_NOTIFY, acpitz_notify_handler, sc); 192 if (ACPI_FAILURE(rv)) { 193 aprint_error("%s: unable to install SYSTEM NOTIFY handler: %s\n", 194 sc->sc_dev.dv_xname, AcpiFormatException(rv)); 195 return; 196 } 197 198 callout_init(&sc->sc_callout, 0); 199 callout_setfunc(&sc->sc_callout, acpitz_tick, sc); 200 201 acpitz_init_envsys(sc); 202 203 callout_schedule(&sc->sc_callout, sc->sc_zone.tzp * hz / 10); 204 } 205 206 static void 207 acpitz_get_zone_quiet(void *opaque) 208 { 209 acpitz_get_zone(opaque, 0); 210 } 211 212 static void 213 acpitz_get_status(void *opaque) 214 { 215 struct acpitz_softc *sc = opaque; 216 UINT32 tmp, active; 217 int i, flags; 218 219 sc->sc_zone_expire--; 220 if (sc->sc_zone_expire <= 0) { 221 sc->sc_zone_expire = ATZ_ZONE_EXPIRE / sc->sc_zone.tzp; 222 if (sc->sc_flags & ATZ_F_VERBOSE) 223 printf("%s: force refetch zone\n", sc->sc_dev.dv_xname); 224 acpitz_get_zone(sc, 0); 225 } 226 227 if (acpitz_get_integer(sc, "_TMP", &tmp)) { 228 printf("%s: failed to evaluate _TMP\n", sc->sc_dev.dv_xname); 229 return; 230 } 231 sc->sc_zone.tmp = tmp; 232 /* XXX sanity check for tmp here? */ 233 234 /* 235 * The temperature unit for envsys(4) is microKelvin, so convert to 236 * that from ACPI's microKelvin. Also, the ACPI specification assumes 237 * that K = C + 273.2 rather than the nominal 273.15 used by envsys(4), 238 * so we correct for that too. 239 */ 240 sc->sc_sensor.value_cur = sc->sc_zone.tmp * 100000 - 50000; 241 sc->sc_sensor.state = ENVSYS_SVALID; 242 243 if (sc->sc_flags & ATZ_F_VERBOSE) 244 acpitz_print_status(sc); 245 246 if (sc->sc_flags & ATZ_F_PASSIVEONLY) { 247 /* Passive Cooling: XXX not yet */ 248 249 } else { 250 /* Active Cooling */ 251 252 /* temperature threshold: _AC0 > ... > _AC9 */ 253 active = ATZ_ACTIVE_NONE; 254 for (i = ATZ_NLEVELS - 1; i >= 0; i--) { 255 if (sc->sc_zone.ac[i] == ATZ_TMP_INVALID) 256 continue; 257 258 /* we want to keep highest cooling mode in 'active' */ 259 if (sc->sc_zone.ac[i] <= tmp) 260 active = i; 261 } 262 263 flags = sc->sc_flags & ~(ATZ_F_CRITICAL|ATZ_F_HOT|ATZ_F_PASSIVE); 264 if (sc->sc_zone.psv != ATZ_TMP_INVALID && 265 tmp >= sc->sc_zone.psv) 266 flags |= ATZ_F_PASSIVE; 267 if (sc->sc_zone.hot != ATZ_TMP_INVALID && 268 tmp >= sc->sc_zone.hot) 269 flags |= ATZ_F_HOT; 270 if (sc->sc_zone.crt != ATZ_TMP_INVALID && 271 tmp >= sc->sc_zone.crt) 272 flags |= ATZ_F_CRITICAL; 273 274 if (flags != sc->sc_flags) { 275 int changed = (sc->sc_flags ^ flags) & flags; 276 sc->sc_flags = flags; 277 if (changed & ATZ_F_CRITICAL) { 278 sc->sc_sensor.state = ENVSYS_SCRITICAL; 279 printf("%s: zone went critical at temp %sC\n", 280 sc->sc_dev.dv_xname, 281 acpitz_celcius_string(tmp)); 282 } else if (changed & ATZ_F_HOT) { 283 sc->sc_sensor.state = ENVSYS_SWARNOVER; 284 printf("%s: zone went hot at temp %sC\n", 285 sc->sc_dev.dv_xname, 286 acpitz_celcius_string(tmp)); 287 } 288 } 289 290 /* power on fans */ 291 if (sc->sc_active != active) { 292 if (sc->sc_active != ATZ_ACTIVE_NONE) 293 acpitz_power_zone(sc, sc->sc_active, 0); 294 295 if (active != ATZ_ACTIVE_NONE) { 296 if (sc->sc_flags & ATZ_F_VERBOSE) 297 printf("%s: active cooling level %u\n", 298 sc->sc_dev.dv_xname, active); 299 acpitz_power_zone(sc, active, 1); 300 } 301 302 sc->sc_active = active; 303 } 304 } 305 306 return; 307 } 308 309 static char * 310 acpitz_celcius_string(int dk) 311 { 312 static char buf[10]; 313 314 snprintf(buf, sizeof(buf), "%d.%d", (dk - ATZ_ZEROC) / 10, 315 (dk - ATZ_ZEROC) % 10); 316 317 return buf; 318 } 319 320 static void 321 acpitz_print_status(struct acpitz_softc *sc) 322 { 323 324 printf("%s: zone temperature is now %sC\n", sc->sc_dev.dv_xname, 325 acpitz_celcius_string(sc->sc_zone.tmp)); 326 327 return; 328 } 329 330 static ACPI_STATUS 331 acpitz_switch_cooler(ACPI_OBJECT *obj, void *arg) 332 { 333 ACPI_HANDLE cooler; 334 ACPI_STATUS rv; 335 int pwr_state, flag; 336 337 flag = *(int *)arg; 338 339 if (flag) 340 pwr_state = ACPI_STATE_D0; 341 else 342 pwr_state = ACPI_STATE_D3; 343 344 switch(obj->Type) { 345 case ACPI_TYPE_ANY: 346 cooler = obj->Reference.Handle; 347 break; 348 case ACPI_TYPE_STRING: 349 rv = AcpiGetHandle(NULL, obj->String.Pointer, &cooler); 350 if (ACPI_FAILURE(rv)) { 351 printf("failed to get handler from %s\n", 352 obj->String.Pointer); 353 return rv; 354 } 355 break; 356 default: 357 printf("unknown power type: %d\n", obj->Type); 358 return AE_OK; 359 } 360 361 rv = acpi_pwr_switch_consumer(cooler, pwr_state); 362 if (rv != AE_BAD_PARAMETER && ACPI_FAILURE(rv)) { 363 printf("failed to change state for %s: %s\n", 364 acpi_name(obj->Reference.Handle), 365 AcpiFormatException(rv)); 366 } 367 368 return AE_OK; 369 } 370 371 /* 372 * acpitz_power_zone: 373 * power on or off the i:th part of the zone zone 374 */ 375 static void 376 acpitz_power_zone(struct acpitz_softc *sc, int i, int on) 377 { 378 KASSERT(i >= 0 && i < ATZ_NLEVELS); 379 380 acpi_foreach_package_object(sc->sc_zone.al[i].Pointer, 381 acpitz_switch_cooler, &on); 382 } 383 384 385 /* 386 * acpitz_power_off: 387 * power off parts of the zone 388 */ 389 static void 390 acpitz_power_off(struct acpitz_softc *sc) 391 { 392 int i; 393 394 for (i = 0 ; i < ATZ_NLEVELS; i++) { 395 if (sc->sc_zone.al[i].Pointer == NULL) 396 continue; 397 acpitz_power_zone(sc, i, 0); 398 } 399 sc->sc_active = ATZ_ACTIVE_NONE; 400 sc->sc_flags &= ~(ATZ_F_CRITICAL|ATZ_F_HOT|ATZ_F_PASSIVE); 401 } 402 403 static void 404 acpitz_get_zone(void *opaque, int verbose) 405 { 406 struct acpitz_softc *sc = opaque; 407 ACPI_STATUS rv; 408 char buf[8]; 409 int i, valid_levels; 410 static int first = 1; 411 412 if (!first) { 413 acpitz_power_off(sc); 414 415 for (i = 0; i < ATZ_NLEVELS; i++) { 416 if (sc->sc_zone.al[i].Pointer != NULL) 417 AcpiOsFree(sc->sc_zone.al[i].Pointer); 418 sc->sc_zone.al[i].Pointer = NULL; 419 } 420 } 421 422 valid_levels = 0; 423 424 for (i = 0; i < ATZ_NLEVELS; i++) { 425 ACPI_OBJECT *obj; 426 427 snprintf(buf, sizeof(buf), "_AC%d", i); 428 if (acpitz_get_integer(sc, buf, &sc->sc_zone.ac[i])) 429 continue; 430 431 snprintf(buf, sizeof(buf), "_AL%d", i); 432 rv = acpi_eval_struct(sc->sc_devnode->ad_handle, buf, 433 &sc->sc_zone.al[i]); 434 if (ACPI_FAILURE(rv)) { 435 sc->sc_zone.al[i].Pointer = NULL; 436 continue; 437 } 438 439 obj = sc->sc_zone.al[i].Pointer; 440 if (obj != NULL) { 441 if (obj->Type != ACPI_TYPE_PACKAGE) { 442 printf("%s: ac%d not package\n", 443 sc->sc_dev.dv_xname, i); 444 AcpiOsFree(obj); 445 sc->sc_zone.al[i].Pointer = NULL; 446 continue; 447 } 448 } 449 450 if (first) 451 printf("%s: active cooling level %d: %sC\n", 452 sc->sc_dev.dv_xname, i, 453 acpitz_celcius_string(sc->sc_zone.ac[i])); 454 455 valid_levels++; 456 } 457 458 if (valid_levels == 0) { 459 sc->sc_flags |= ATZ_F_PASSIVEONLY; 460 if (first) 461 printf("%s: passive cooling mode only\n", 462 sc->sc_dev.dv_xname); 463 } 464 465 acpitz_get_integer(sc, "_TMP", &sc->sc_zone.tmp); 466 acpitz_get_integer(sc, "_CRT", &sc->sc_zone.crt); 467 acpitz_get_integer(sc, "_HOT", &sc->sc_zone.hot); 468 sc->sc_zone.psl.Length = ACPI_ALLOCATE_BUFFER; 469 sc->sc_zone.psl.Pointer = NULL; 470 AcpiEvaluateObject(sc, "_PSL", NULL, &sc->sc_zone.psl); 471 acpitz_get_integer(sc, "_PSV", &sc->sc_zone.psv); 472 acpitz_get_integer(sc, "_TC1", &sc->sc_zone.tc1); 473 acpitz_get_integer(sc, "_TC2", &sc->sc_zone.tc2); 474 475 acpitz_sane_temp(&sc->sc_zone.tmp); 476 acpitz_sane_temp(&sc->sc_zone.crt); 477 acpitz_sane_temp(&sc->sc_zone.hot); 478 acpitz_sane_temp(&sc->sc_zone.psv); 479 480 if (verbose) { 481 printf("%s:", sc->sc_dev.dv_xname); 482 if (sc->sc_zone.crt != ATZ_TMP_INVALID) 483 printf(" critical %sC", 484 acpitz_celcius_string(sc->sc_zone.crt)); 485 if (sc->sc_zone.hot != ATZ_TMP_INVALID) 486 printf(" hot %sC", 487 acpitz_celcius_string(sc->sc_zone.hot)); 488 if (sc->sc_zone.psv != ATZ_TMP_INVALID) 489 printf(" passive %sC", 490 acpitz_celcius_string(sc->sc_zone.tmp)); 491 printf("\n"); 492 } 493 494 for (i = 0; i < ATZ_NLEVELS; i++) 495 acpitz_sane_temp(&sc->sc_zone.ac[i]); 496 497 acpitz_power_off(sc); 498 first = 0; 499 } 500 501 502 static void 503 acpitz_notify_handler(ACPI_HANDLE hdl, UINT32 notify, void *opaque) 504 { 505 struct acpitz_softc *sc = opaque; 506 ACPI_OSD_EXEC_CALLBACK func = NULL; 507 const char *name; 508 int rv; 509 510 switch (notify) { 511 case ACPI_NOTIFY_ThermalZoneStatusChanged: 512 func = acpitz_get_status; 513 name = "status check"; 514 break; 515 case ACPI_NOTIFY_ThermalZoneTripPointsChanged: 516 case ACPI_NOTIFY_DeviceListsChanged: 517 func = acpitz_get_zone_quiet; 518 name = "get zone"; 519 break; 520 default: 521 printf("%s: received unhandled notify message 0x%x\n", 522 sc->sc_dev.dv_xname, notify); 523 return; 524 } 525 526 KASSERT(func != NULL); 527 528 rv = AcpiOsQueueForExecution(OSD_PRIORITY_LO, func, sc); 529 if (rv != AE_OK) 530 printf("%s: unable to queue %s\n", sc->sc_dev.dv_xname, name); 531 532 return; 533 } 534 535 static void 536 acpitz_sane_temp(UINT32 *tmp) 537 { 538 /* Sane temperatures are beteen 0 and 150 C */ 539 if (*tmp < ATZ_ZEROC || *tmp > ATZ_ZEROC + 1500) 540 *tmp = ATZ_TMP_INVALID; 541 } 542 543 static int 544 acpitz_get_integer(struct acpitz_softc *sc, const char *cm, UINT32 *val) 545 { 546 ACPI_STATUS rv; 547 ACPI_INTEGER tmp; 548 549 rv = acpi_eval_integer(sc->sc_devnode->ad_handle, cm, &tmp); 550 if (ACPI_FAILURE(rv)) { 551 #ifdef ACPI_DEBUG 552 printf("%s: failed to evaluate %s: %s\n", sc->sc_dev.dv_xname, 553 cm, AcpiFormatException(rv)); 554 #endif 555 *val = ATZ_TMP_INVALID; 556 return 1; 557 } 558 559 *val = tmp; 560 561 return 0; 562 } 563 564 static void 565 acpitz_tick(void *opaque) 566 { 567 struct acpitz_softc *sc = opaque; 568 569 AcpiOsQueueForExecution(OSD_PRIORITY_LO, acpitz_get_status, sc); 570 571 callout_schedule(&sc->sc_callout, sc->sc_zone.tzp * hz / 10); 572 } 573 574 static void 575 acpitz_init_envsys(struct acpitz_softc *sc) 576 { 577 sc->sc_sme = sysmon_envsys_create(); 578 sc->sc_sensor.monitor = true; 579 sc->sc_sensor.flags = (ENVSYS_FMONCRITICAL|ENVSYS_FMONWARNOVER); 580 strlcpy(sc->sc_sensor.desc, "temperature", sizeof(sc->sc_sensor.desc)); 581 if (sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor)) { 582 sysmon_envsys_destroy(sc->sc_sme); 583 return; 584 } 585 586 /* hook into sysmon */ 587 sc->sc_sme->sme_name = sc->sc_dev.dv_xname; 588 sc->sc_sme->sme_cookie = sc; 589 sc->sc_sme->sme_flags = SME_DISABLE_REFRESH; 590 591 if (sysmon_envsys_register(sc->sc_sme)) { 592 printf("%s: unable to register with sysmon\n", 593 sc->sc_dev.dv_xname); 594 sysmon_envsys_destroy(sc->sc_sme); 595 } 596 } 597
Indexes created Mon Sep 29 21:09:56 GMT 2025