1 /*- 2 * Copyright (c) 2000, 2001 Michael Smith 3 * Copyright (c) 2000 BSDi 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 23 * LIABILITY, 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 #include <sys/cdefs.h> 29 __FBSDID("$FreeBSD$"); 30 31 #include "opt_acpi.h" 32 #include <sys/param.h> 33 #include <sys/eventhandler.h> 34 #include <sys/kernel.h> 35 #include <sys/bus.h> 36 #include <sys/cpu.h> 37 #include <sys/kthread.h> 38 #include <sys/malloc.h> 39 #include <sys/module.h> 40 #include <sys/proc.h> 41 #include <sys/reboot.h> 42 #include <sys/sysctl.h> 43 #include <sys/unistd.h> 44 #include <sys/power.h> 45 46 #include "cpufreq_if.h" 47 48 #include <contrib/dev/acpica/include/acpi.h> 49 #include <contrib/dev/acpica/include/accommon.h> 50 51 #include <dev/acpica/acpivar.h> 52 53 /* Hooks for the ACPI CA debugging infrastructure */ 54 #define _COMPONENT ACPI_THERMAL 55 ACPI_MODULE_NAME("THERMAL") 56 57 #define TZ_ZEROC 2731 58 #define TZ_KELVTOC(x) (((x) - TZ_ZEROC) / 10), abs(((x) - TZ_ZEROC) % 10) 59 60 #define TZ_NOTIFY_TEMPERATURE 0x80 /* Temperature changed. */ 61 #define TZ_NOTIFY_LEVELS 0x81 /* Cooling levels changed. */ 62 #define TZ_NOTIFY_DEVICES 0x82 /* Device lists changed. */ 63 #define TZ_NOTIFY_CRITICAL 0xcc /* Fake notify that _CRT/_HOT reached. */ 64 65 /* Check for temperature changes every 10 seconds by default */ 66 #define TZ_POLLRATE 10 67 68 /* Make sure the reported temperature is valid for this number of polls. */ 69 #define TZ_VALIDCHECKS 3 70 71 /* Notify the user we will be shutting down in one more poll cycle. */ 72 #define TZ_NOTIFYCOUNT (TZ_VALIDCHECKS - 1) 73 74 /* ACPI spec defines this */ 75 #define TZ_NUMLEVELS 10 76 struct acpi_tz_zone { 77 int ac[TZ_NUMLEVELS]; 78 ACPI_BUFFER al[TZ_NUMLEVELS]; 79 int crt; 80 int hot; 81 ACPI_BUFFER psl; 82 int psv; 83 int tc1; 84 int tc2; 85 int tsp; 86 int tzp; 87 }; 88 89 struct acpi_tz_softc { 90 device_t tz_dev; 91 ACPI_HANDLE tz_handle; /*Thermal zone handle*/ 92 int tz_temperature; /*Current temperature*/ 93 int tz_active; /*Current active cooling*/ 94 #define TZ_ACTIVE_NONE -1 95 #define TZ_ACTIVE_UNKNOWN -2 96 int tz_requested; /*Minimum active cooling*/ 97 int tz_thflags; /*Current temp-related flags*/ 98 #define TZ_THFLAG_NONE 0 99 #define TZ_THFLAG_PSV (1<<0) 100 #define TZ_THFLAG_HOT (1<<2) 101 #define TZ_THFLAG_CRT (1<<3) 102 int tz_flags; 103 #define TZ_FLAG_NO_SCP (1<<0) /*No _SCP method*/ 104 #define TZ_FLAG_GETPROFILE (1<<1) /*Get power_profile in timeout*/ 105 #define TZ_FLAG_GETSETTINGS (1<<2) /*Get devs/setpoints*/ 106 struct timespec tz_cooling_started; 107 /*Current cooling starting time*/ 108 109 struct sysctl_ctx_list tz_sysctl_ctx; 110 struct sysctl_oid *tz_sysctl_tree; 111 eventhandler_tag tz_event; 112 113 struct acpi_tz_zone tz_zone; /*Thermal zone parameters*/ 114 int tz_validchecks; 115 int tz_insane_tmp_notified; 116 117 /* passive cooling */ 118 struct proc *tz_cooling_proc; 119 int tz_cooling_proc_running; 120 int tz_cooling_enabled; 121 int tz_cooling_active; 122 int tz_cooling_updated; 123 int tz_cooling_saved_freq; 124 }; 125 126 #define TZ_ACTIVE_LEVEL(act) ((act) >= 0 ? (act) : TZ_NUMLEVELS) 127 128 #define CPUFREQ_MAX_LEVELS 64 /* XXX cpufreq should export this */ 129 130 static int acpi_tz_probe(device_t dev); 131 static int acpi_tz_attach(device_t dev); 132 static int acpi_tz_establish(struct acpi_tz_softc *sc); 133 static void acpi_tz_monitor(void *Context); 134 static void acpi_tz_switch_cooler_off(ACPI_OBJECT *obj, void *arg); 135 static void acpi_tz_switch_cooler_on(ACPI_OBJECT *obj, void *arg); 136 static void acpi_tz_getparam(struct acpi_tz_softc *sc, char *node, 137 int *data); 138 static void acpi_tz_sanity(struct acpi_tz_softc *sc, int *val, char *what); 139 static int acpi_tz_active_sysctl(SYSCTL_HANDLER_ARGS); 140 static int acpi_tz_cooling_sysctl(SYSCTL_HANDLER_ARGS); 141 static int acpi_tz_temp_sysctl(SYSCTL_HANDLER_ARGS); 142 static int acpi_tz_passive_sysctl(SYSCTL_HANDLER_ARGS); 143 static void acpi_tz_notify_handler(ACPI_HANDLE h, UINT32 notify, 144 void *context); 145 static void acpi_tz_signal(struct acpi_tz_softc *sc, int flags); 146 static void acpi_tz_timeout(struct acpi_tz_softc *sc, int flags); 147 static void acpi_tz_power_profile(void *arg); 148 static void acpi_tz_thread(void *arg); 149 static int acpi_tz_cooling_is_available(struct acpi_tz_softc *sc); 150 static int acpi_tz_cooling_thread_start(struct acpi_tz_softc *sc); 151 152 static device_method_t acpi_tz_methods[] = { 153 /* Device interface */ 154 DEVMETHOD(device_probe, acpi_tz_probe), 155 DEVMETHOD(device_attach, acpi_tz_attach), 156 157 DEVMETHOD_END 158 }; 159 160 static driver_t acpi_tz_driver = { 161 "acpi_tz", 162 acpi_tz_methods, 163 sizeof(struct acpi_tz_softc), 164 }; 165 166 static char *acpi_tz_tmp_name = "_TMP"; 167 168 static devclass_t acpi_tz_devclass; 169 DRIVER_MODULE(acpi_tz, acpi, acpi_tz_driver, acpi_tz_devclass, 0, 0); 170 MODULE_DEPEND(acpi_tz, acpi, 1, 1, 1); 171 172 static struct sysctl_ctx_list acpi_tz_sysctl_ctx; 173 static struct sysctl_oid *acpi_tz_sysctl_tree; 174 175 /* Minimum cooling run time */ 176 static int acpi_tz_min_runtime; 177 static int acpi_tz_polling_rate = TZ_POLLRATE; 178 static int acpi_tz_override; 179 180 /* Timezone polling thread */ 181 static struct proc *acpi_tz_proc; 182 ACPI_LOCK_DECL(thermal, "ACPI thermal zone"); 183 184 static int acpi_tz_cooling_unit = -1; 185 186 static int 187 acpi_tz_probe(device_t dev) 188 { 189 int result; 190 191 if (acpi_get_type(dev) == ACPI_TYPE_THERMAL && !acpi_disabled("thermal")) { 192 device_set_desc(dev, "Thermal Zone"); 193 result = -10; 194 } else 195 result = ENXIO; 196 return (result); 197 } 198 199 static int 200 acpi_tz_attach(device_t dev) 201 { 202 struct acpi_tz_softc *sc; 203 struct acpi_softc *acpi_sc; 204 int error; 205 char oidname[8]; 206 207 ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 208 209 sc = device_get_softc(dev); 210 sc->tz_dev = dev; 211 sc->tz_handle = acpi_get_handle(dev); 212 sc->tz_requested = TZ_ACTIVE_NONE; 213 sc->tz_active = TZ_ACTIVE_UNKNOWN; 214 sc->tz_thflags = TZ_THFLAG_NONE; 215 sc->tz_cooling_proc = NULL; 216 sc->tz_cooling_proc_running = FALSE; 217 sc->tz_cooling_active = FALSE; 218 sc->tz_cooling_updated = FALSE; 219 sc->tz_cooling_enabled = FALSE; 220 221 /* 222 * Parse the current state of the thermal zone and build control 223 * structures. We don't need to worry about interference with the 224 * control thread since we haven't fully attached this device yet. 225 */ 226 if ((error = acpi_tz_establish(sc)) != 0) 227 return (error); 228 229 /* 230 * Register for any Notify events sent to this zone. 231 */ 232 AcpiInstallNotifyHandler(sc->tz_handle, ACPI_DEVICE_NOTIFY, 233 acpi_tz_notify_handler, sc); 234 235 /* 236 * Create our sysctl nodes. 237 * 238 * XXX we need a mechanism for adding nodes under ACPI. 239 */ 240 if (device_get_unit(dev) == 0) { 241 acpi_sc = acpi_device_get_parent_softc(dev); 242 sysctl_ctx_init(&acpi_tz_sysctl_ctx); 243 acpi_tz_sysctl_tree = SYSCTL_ADD_NODE(&acpi_tz_sysctl_ctx, 244 SYSCTL_CHILDREN(acpi_sc->acpi_sysctl_tree), 245 OID_AUTO, "thermal", CTLFLAG_RD, 0, ""); 246 SYSCTL_ADD_INT(&acpi_tz_sysctl_ctx, 247 SYSCTL_CHILDREN(acpi_tz_sysctl_tree), 248 OID_AUTO, "min_runtime", CTLFLAG_RW, 249 &acpi_tz_min_runtime, 0, 250 "minimum cooling run time in sec"); 251 SYSCTL_ADD_INT(&acpi_tz_sysctl_ctx, 252 SYSCTL_CHILDREN(acpi_tz_sysctl_tree), 253 OID_AUTO, "polling_rate", CTLFLAG_RW, 254 &acpi_tz_polling_rate, 0, "monitor polling interval in seconds"); 255 SYSCTL_ADD_INT(&acpi_tz_sysctl_ctx, 256 SYSCTL_CHILDREN(acpi_tz_sysctl_tree), OID_AUTO, 257 "user_override", CTLFLAG_RW, &acpi_tz_override, 0, 258 "allow override of thermal settings"); 259 } 260 sysctl_ctx_init(&sc->tz_sysctl_ctx); 261 sprintf(oidname, "tz%d", device_get_unit(dev)); 262 sc->tz_sysctl_tree = SYSCTL_ADD_NODE_WITH_LABEL(&sc->tz_sysctl_ctx, 263 SYSCTL_CHILDREN(acpi_tz_sysctl_tree), 264 OID_AUTO, oidname, CTLFLAG_RD, 0, "", "thermal_zone"); 265 SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree), 266 OID_AUTO, "temperature", CTLTYPE_INT | CTLFLAG_RD, 267 &sc->tz_temperature, 0, sysctl_handle_int, 268 "IK", "current thermal zone temperature"); 269 SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree), 270 OID_AUTO, "active", CTLTYPE_INT | CTLFLAG_RW, 271 sc, 0, acpi_tz_active_sysctl, "I", "cooling is active"); 272 SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree), 273 OID_AUTO, "passive_cooling", CTLTYPE_INT | CTLFLAG_RW, 274 sc, 0, acpi_tz_cooling_sysctl, "I", 275 "enable passive (speed reduction) cooling"); 276 277 SYSCTL_ADD_INT(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree), 278 OID_AUTO, "thermal_flags", CTLFLAG_RD, 279 &sc->tz_thflags, 0, "thermal zone flags"); 280 SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree), 281 OID_AUTO, "_PSV", CTLTYPE_INT | CTLFLAG_RW, 282 sc, offsetof(struct acpi_tz_softc, tz_zone.psv), 283 acpi_tz_temp_sysctl, "IK", "passive cooling temp setpoint"); 284 SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree), 285 OID_AUTO, "_HOT", CTLTYPE_INT | CTLFLAG_RW, 286 sc, offsetof(struct acpi_tz_softc, tz_zone.hot), 287 acpi_tz_temp_sysctl, "IK", 288 "too hot temp setpoint (suspend now)"); 289 SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree), 290 OID_AUTO, "_CRT", CTLTYPE_INT | CTLFLAG_RW, 291 sc, offsetof(struct acpi_tz_softc, tz_zone.crt), 292 acpi_tz_temp_sysctl, "IK", 293 "critical temp setpoint (shutdown now)"); 294 SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree), 295 OID_AUTO, "_ACx", CTLTYPE_INT | CTLFLAG_RD, 296 &sc->tz_zone.ac, sizeof(sc->tz_zone.ac), 297 sysctl_handle_opaque, "IK", ""); 298 SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree), 299 OID_AUTO, "_TC1", CTLTYPE_INT | CTLFLAG_RW, 300 sc, offsetof(struct acpi_tz_softc, tz_zone.tc1), 301 acpi_tz_passive_sysctl, "I", 302 "thermal constant 1 for passive cooling"); 303 SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree), 304 OID_AUTO, "_TC2", CTLTYPE_INT | CTLFLAG_RW, 305 sc, offsetof(struct acpi_tz_softc, tz_zone.tc2), 306 acpi_tz_passive_sysctl, "I", 307 "thermal constant 2 for passive cooling"); 308 SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree), 309 OID_AUTO, "_TSP", CTLTYPE_INT | CTLFLAG_RW, 310 sc, offsetof(struct acpi_tz_softc, tz_zone.tsp), 311 acpi_tz_passive_sysctl, "I", 312 "thermal sampling period for passive cooling"); 313 314 /* 315 * Register our power profile event handler. 316 */ 317 sc->tz_event = EVENTHANDLER_REGISTER(power_profile_change, 318 acpi_tz_power_profile, sc, 0); 319 320 /* 321 * Flag the event handler for a manual invocation by our timeout. 322 * We defer it like this so that the rest of the subsystem has time 323 * to come up. Don't bother evaluating/printing the temperature at 324 * this point; on many systems it'll be bogus until the EC is running. 325 */ 326 sc->tz_flags |= TZ_FLAG_GETPROFILE; 327 328 return_VALUE (0); 329 } 330 331 static void 332 acpi_tz_startup(void *arg __unused) 333 { 334 struct acpi_tz_softc *sc; 335 device_t *devs; 336 int devcount, error, i; 337 338 devclass_get_devices(acpi_tz_devclass, &devs, &devcount); 339 if (devcount == 0) { 340 free(devs, M_TEMP); 341 return; 342 } 343 344 /* 345 * Create thread to service all of the thermal zones. 346 */ 347 error = kproc_create(acpi_tz_thread, NULL, &acpi_tz_proc, RFHIGHPID, 0, 348 "acpi_thermal"); 349 if (error != 0) 350 printf("acpi_tz: could not create thread - %d", error); 351 352 /* 353 * Create a thread to handle passive cooling for 1st zone which 354 * has _PSV, _TSP, _TC1 and _TC2. Users can enable it for other 355 * zones manually for now. 356 * 357 * XXX We enable only one zone to avoid multiple zones conflict 358 * with each other since cpufreq currently sets all CPUs to the 359 * given frequency whereas it's possible for different thermal 360 * zones to specify independent settings for multiple CPUs. 361 */ 362 for (i = 0; i < devcount; i++) { 363 sc = device_get_softc(devs[i]); 364 if (acpi_tz_cooling_is_available(sc)) { 365 sc->tz_cooling_enabled = TRUE; 366 error = acpi_tz_cooling_thread_start(sc); 367 if (error != 0) { 368 sc->tz_cooling_enabled = FALSE; 369 break; 370 } 371 acpi_tz_cooling_unit = device_get_unit(devs[i]); 372 break; 373 } 374 } 375 free(devs, M_TEMP); 376 } 377 SYSINIT(acpi_tz, SI_SUB_KICK_SCHEDULER, SI_ORDER_ANY, acpi_tz_startup, NULL); 378 379 /* 380 * Parse the current state of this thermal zone and set up to use it. 381 * 382 * Note that we may have previous state, which will have to be discarded. 383 */ 384 static int 385 acpi_tz_establish(struct acpi_tz_softc *sc) 386 { 387 ACPI_OBJECT *obj; 388 int i; 389 char nbuf[8]; 390 391 ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 392 393 /* Erase any existing state. */ 394 for (i = 0; i < TZ_NUMLEVELS; i++) 395 if (sc->tz_zone.al[i].Pointer != NULL) 396 AcpiOsFree(sc->tz_zone.al[i].Pointer); 397 if (sc->tz_zone.psl.Pointer != NULL) 398 AcpiOsFree(sc->tz_zone.psl.Pointer); 399 400 /* 401 * XXX: We initialize only ACPI_BUFFER to avoid race condition 402 * with passive cooling thread which refers psv, tc1, tc2 and tsp. 403 */ 404 bzero(sc->tz_zone.ac, sizeof(sc->tz_zone.ac)); 405 bzero(sc->tz_zone.al, sizeof(sc->tz_zone.al)); 406 bzero(&sc->tz_zone.psl, sizeof(sc->tz_zone.psl)); 407 408 /* Evaluate thermal zone parameters. */ 409 for (i = 0; i < TZ_NUMLEVELS; i++) { 410 sprintf(nbuf, "_AC%d", i); 411 acpi_tz_getparam(sc, nbuf, &sc->tz_zone.ac[i]); 412 sprintf(nbuf, "_AL%d", i); 413 sc->tz_zone.al[i].Length = ACPI_ALLOCATE_BUFFER; 414 sc->tz_zone.al[i].Pointer = NULL; 415 AcpiEvaluateObject(sc->tz_handle, nbuf, NULL, &sc->tz_zone.al[i]); 416 obj = (ACPI_OBJECT *)sc->tz_zone.al[i].Pointer; 417 if (obj != NULL) { 418 /* Should be a package containing a list of power objects */ 419 if (obj->Type != ACPI_TYPE_PACKAGE) { 420 device_printf(sc->tz_dev, "%s has unknown type %d, rejecting\n", 421 nbuf, obj->Type); 422 return_VALUE (ENXIO); 423 } 424 } 425 } 426 acpi_tz_getparam(sc, "_CRT", &sc->tz_zone.crt); 427 acpi_tz_getparam(sc, "_HOT", &sc->tz_zone.hot); 428 sc->tz_zone.psl.Length = ACPI_ALLOCATE_BUFFER; 429 sc->tz_zone.psl.Pointer = NULL; 430 AcpiEvaluateObject(sc->tz_handle, "_PSL", NULL, &sc->tz_zone.psl); 431 acpi_tz_getparam(sc, "_PSV", &sc->tz_zone.psv); 432 acpi_tz_getparam(sc, "_TC1", &sc->tz_zone.tc1); 433 acpi_tz_getparam(sc, "_TC2", &sc->tz_zone.tc2); 434 acpi_tz_getparam(sc, "_TSP", &sc->tz_zone.tsp); 435 acpi_tz_getparam(sc, "_TZP", &sc->tz_zone.tzp); 436 437 /* 438 * Sanity-check the values we've been given. 439 * 440 * XXX what do we do about systems that give us the same value for 441 * more than one of these setpoints? 442 */ 443 acpi_tz_sanity(sc, &sc->tz_zone.crt, "_CRT"); 444 acpi_tz_sanity(sc, &sc->tz_zone.hot, "_HOT"); 445 acpi_tz_sanity(sc, &sc->tz_zone.psv, "_PSV"); 446 for (i = 0; i < TZ_NUMLEVELS; i++) 447 acpi_tz_sanity(sc, &sc->tz_zone.ac[i], "_ACx"); 448 449 return_VALUE (0); 450 } 451 452 static char *aclevel_string[] = { 453 "NONE", "_AC0", "_AC1", "_AC2", "_AC3", "_AC4", 454 "_AC5", "_AC6", "_AC7", "_AC8", "_AC9" 455 }; 456 457 static __inline const char * 458 acpi_tz_aclevel_string(int active) 459 { 460 if (active < -1 || active >= TZ_NUMLEVELS) 461 return (aclevel_string[0]); 462 463 return (aclevel_string[active + 1]); 464 } 465 466 /* 467 * Get the current temperature. 468 */ 469 static int 470 acpi_tz_get_temperature(struct acpi_tz_softc *sc) 471 { 472 int temp; 473 ACPI_STATUS status; 474 475 ACPI_FUNCTION_NAME ("acpi_tz_get_temperature"); 476 477 /* Evaluate the thermal zone's _TMP method. */ 478 status = acpi_GetInteger(sc->tz_handle, acpi_tz_tmp_name, &temp); 479 if (ACPI_FAILURE(status)) { 480 ACPI_VPRINT(sc->tz_dev, acpi_device_get_parent_softc(sc->tz_dev), 481 "error fetching current temperature -- %s\n", 482 AcpiFormatException(status)); 483 return (FALSE); 484 } 485 486 /* Check it for validity. */ 487 acpi_tz_sanity(sc, &temp, acpi_tz_tmp_name); 488 if (temp == -1) 489 return (FALSE); 490 491 ACPI_DEBUG_PRINT((ACPI_DB_VALUES, "got %d.%dC\n", TZ_KELVTOC(temp))); 492 sc->tz_temperature = temp; 493 return (TRUE); 494 } 495 496 /* 497 * Evaluate the condition of a thermal zone, take appropriate actions. 498 */ 499 static void 500 acpi_tz_monitor(void *Context) 501 { 502 struct acpi_tz_softc *sc; 503 struct timespec curtime; 504 int temp; 505 int i; 506 int newactive, newflags; 507 508 ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 509 510 sc = (struct acpi_tz_softc *)Context; 511 512 /* Get the current temperature. */ 513 if (!acpi_tz_get_temperature(sc)) { 514 /* XXX disable zone? go to max cooling? */ 515 return_VOID; 516 } 517 temp = sc->tz_temperature; 518 519 /* 520 * Work out what we ought to be doing right now. 521 * 522 * Note that the _ACx levels sort from hot to cold. 523 */ 524 newactive = TZ_ACTIVE_NONE; 525 for (i = TZ_NUMLEVELS - 1; i >= 0; i--) { 526 if (sc->tz_zone.ac[i] != -1 && temp >= sc->tz_zone.ac[i]) 527 newactive = i; 528 } 529 530 /* 531 * We are going to get _ACx level down (colder side), but give a guaranteed 532 * minimum cooling run time if requested. 533 */ 534 if (acpi_tz_min_runtime > 0 && sc->tz_active != TZ_ACTIVE_NONE && 535 sc->tz_active != TZ_ACTIVE_UNKNOWN && 536 (newactive == TZ_ACTIVE_NONE || newactive > sc->tz_active)) { 537 538 getnanotime(&curtime); 539 timespecsub(&curtime, &sc->tz_cooling_started, &curtime); 540 if (curtime.tv_sec < acpi_tz_min_runtime) 541 newactive = sc->tz_active; 542 } 543 544 /* Handle user override of active mode */ 545 if (sc->tz_requested != TZ_ACTIVE_NONE && (newactive == TZ_ACTIVE_NONE 546 || sc->tz_requested < newactive)) 547 newactive = sc->tz_requested; 548 549 /* update temperature-related flags */ 550 newflags = TZ_THFLAG_NONE; 551 if (sc->tz_zone.psv != -1 && temp >= sc->tz_zone.psv) 552 newflags |= TZ_THFLAG_PSV; 553 if (sc->tz_zone.hot != -1 && temp >= sc->tz_zone.hot) 554 newflags |= TZ_THFLAG_HOT; 555 if (sc->tz_zone.crt != -1 && temp >= sc->tz_zone.crt) 556 newflags |= TZ_THFLAG_CRT; 557 558 /* If the active cooling state has changed, we have to switch things. */ 559 if (sc->tz_active == TZ_ACTIVE_UNKNOWN) { 560 /* 561 * We don't know which cooling device is on or off, 562 * so stop them all, because we now know which 563 * should be on (if any). 564 */ 565 for (i = 0; i < TZ_NUMLEVELS; i++) { 566 if (sc->tz_zone.al[i].Pointer != NULL) { 567 acpi_ForeachPackageObject( 568 (ACPI_OBJECT *)sc->tz_zone.al[i].Pointer, 569 acpi_tz_switch_cooler_off, sc); 570 } 571 } 572 /* now we know that all devices are off */ 573 sc->tz_active = TZ_ACTIVE_NONE; 574 } 575 576 if (newactive != sc->tz_active) { 577 /* Turn off unneeded cooling devices that are on, if any are */ 578 for (i = TZ_ACTIVE_LEVEL(sc->tz_active); 579 i < TZ_ACTIVE_LEVEL(newactive); i++) { 580 acpi_ForeachPackageObject( 581 (ACPI_OBJECT *)sc->tz_zone.al[i].Pointer, 582 acpi_tz_switch_cooler_off, sc); 583 } 584 /* Turn on cooling devices that are required, if any are */ 585 for (i = TZ_ACTIVE_LEVEL(sc->tz_active) - 1; 586 i >= TZ_ACTIVE_LEVEL(newactive); i--) { 587 acpi_ForeachPackageObject( 588 (ACPI_OBJECT *)sc->tz_zone.al[i].Pointer, 589 acpi_tz_switch_cooler_on, sc); 590 } 591 592 ACPI_VPRINT(sc->tz_dev, acpi_device_get_parent_softc(sc->tz_dev), 593 "switched from %s to %s: %d.%dC\n", 594 acpi_tz_aclevel_string(sc->tz_active), 595 acpi_tz_aclevel_string(newactive), TZ_KELVTOC(temp)); 596 sc->tz_active = newactive; 597 getnanotime(&sc->tz_cooling_started); 598 } 599 600 /* XXX (de)activate any passive cooling that may be required. */ 601 602 /* 603 * If the temperature is at _HOT or _CRT, increment our event count. 604 * If it has occurred enough times, shutdown the system. This is 605 * needed because some systems will report an invalid high temperature 606 * for one poll cycle. It is suspected this is due to the embedded 607 * controller timing out. A typical value is 138C for one cycle on 608 * a system that is otherwise 65C. 609 * 610 * If we're almost at that threshold, notify the user through devd(8). 611 */ 612 if ((newflags & (TZ_THFLAG_HOT | TZ_THFLAG_CRT)) != 0) { 613 sc->tz_validchecks++; 614 if (sc->tz_validchecks == TZ_VALIDCHECKS) { 615 device_printf(sc->tz_dev, 616 "WARNING - current temperature (%d.%dC) exceeds safe limits\n", 617 TZ_KELVTOC(sc->tz_temperature)); 618 shutdown_nice(RB_POWEROFF); 619 } else if (sc->tz_validchecks == TZ_NOTIFYCOUNT) 620 acpi_UserNotify("Thermal", sc->tz_handle, TZ_NOTIFY_CRITICAL); 621 } else { 622 sc->tz_validchecks = 0; 623 } 624 sc->tz_thflags = newflags; 625 626 return_VOID; 627 } 628 629 /* 630 * Given an object, verify that it's a reference to a device of some sort, 631 * and try to switch it off. 632 */ 633 static void 634 acpi_tz_switch_cooler_off(ACPI_OBJECT *obj, void *arg) 635 { 636 ACPI_HANDLE cooler; 637 638 ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 639 640 cooler = acpi_GetReference(NULL, obj); 641 if (cooler == NULL) { 642 ACPI_DEBUG_PRINT((ACPI_DB_OBJECTS, "can't get handle\n")); 643 return_VOID; 644 } 645 646 ACPI_DEBUG_PRINT((ACPI_DB_OBJECTS, "called to turn %s off\n", 647 acpi_name(cooler))); 648 acpi_pwr_switch_consumer(cooler, ACPI_STATE_D3); 649 650 return_VOID; 651 } 652 653 /* 654 * Given an object, verify that it's a reference to a device of some sort, 655 * and try to switch it on. 656 * 657 * XXX replication of off/on function code is bad. 658 */ 659 static void 660 acpi_tz_switch_cooler_on(ACPI_OBJECT *obj, void *arg) 661 { 662 struct acpi_tz_softc *sc = (struct acpi_tz_softc *)arg; 663 ACPI_HANDLE cooler; 664 ACPI_STATUS status; 665 666 ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 667 668 cooler = acpi_GetReference(NULL, obj); 669 if (cooler == NULL) { 670 ACPI_DEBUG_PRINT((ACPI_DB_OBJECTS, "can't get handle\n")); 671 return_VOID; 672 } 673 674 ACPI_DEBUG_PRINT((ACPI_DB_OBJECTS, "called to turn %s on\n", 675 acpi_name(cooler))); 676 status = acpi_pwr_switch_consumer(cooler, ACPI_STATE_D0); 677 if (ACPI_FAILURE(status)) { 678 ACPI_VPRINT(sc->tz_dev, acpi_device_get_parent_softc(sc->tz_dev), 679 "failed to activate %s - %s\n", acpi_name(cooler), 680 AcpiFormatException(status)); 681 } 682 683 return_VOID; 684 } 685 686 /* 687 * Read/debug-print a parameter, default it to -1. 688 */ 689 static void 690 acpi_tz_getparam(struct acpi_tz_softc *sc, char *node, int *data) 691 { 692 693 ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 694 695 if (ACPI_FAILURE(acpi_GetInteger(sc->tz_handle, node, data))) { 696 *data = -1; 697 } else { 698 ACPI_DEBUG_PRINT((ACPI_DB_VALUES, "%s.%s = %d\n", 699 acpi_name(sc->tz_handle), node, *data)); 700 } 701 702 return_VOID; 703 } 704 705 /* 706 * Sanity-check a temperature value. Assume that setpoints 707 * should be between 0C and 200C. 708 */ 709 static void 710 acpi_tz_sanity(struct acpi_tz_softc *sc, int *val, char *what) 711 { 712 if (*val != -1 && (*val < TZ_ZEROC || *val > TZ_ZEROC + 2000)) { 713 /* 714 * If the value we are checking is _TMP, warn the user only 715 * once. This avoids spamming messages if, for instance, the 716 * sensor is broken and always returns an invalid temperature. 717 * 718 * This is only done for _TMP; other values always emit a 719 * warning. 720 */ 721 if (what != acpi_tz_tmp_name || !sc->tz_insane_tmp_notified) { 722 device_printf(sc->tz_dev, "%s value is absurd, ignored (%d.%dC)\n", 723 what, TZ_KELVTOC(*val)); 724 725 /* Don't warn the user again if the read value doesn't improve. */ 726 if (what == acpi_tz_tmp_name) 727 sc->tz_insane_tmp_notified = 1; 728 } 729 *val = -1; 730 return; 731 } 732 733 /* This value is correct. Warn if it's incorrect again. */ 734 if (what == acpi_tz_tmp_name) 735 sc->tz_insane_tmp_notified = 0; 736 } 737 738 /* 739 * Respond to a sysctl on the active state node. 740 */ 741 static int 742 acpi_tz_active_sysctl(SYSCTL_HANDLER_ARGS) 743 { 744 struct acpi_tz_softc *sc; 745 int active; 746 int error; 747 748 sc = (struct acpi_tz_softc *)oidp->oid_arg1; 749 active = sc->tz_active; 750 error = sysctl_handle_int(oidp, &active, 0, req); 751 752 /* Error or no new value */ 753 if (error != 0 || req->newptr == NULL) 754 return (error); 755 if (active < -1 || active >= TZ_NUMLEVELS) 756 return (EINVAL); 757 758 /* Set new preferred level and re-switch */ 759 sc->tz_requested = active; 760 acpi_tz_signal(sc, 0); 761 return (0); 762 } 763 764 static int 765 acpi_tz_cooling_sysctl(SYSCTL_HANDLER_ARGS) 766 { 767 struct acpi_tz_softc *sc; 768 int enabled, error; 769 770 sc = (struct acpi_tz_softc *)oidp->oid_arg1; 771 enabled = sc->tz_cooling_enabled; 772 error = sysctl_handle_int(oidp, &enabled, 0, req); 773 774 /* Error or no new value */ 775 if (error != 0 || req->newptr == NULL) 776 return (error); 777 if (enabled != TRUE && enabled != FALSE) 778 return (EINVAL); 779 780 if (enabled) { 781 if (acpi_tz_cooling_is_available(sc)) 782 error = acpi_tz_cooling_thread_start(sc); 783 else 784 error = ENODEV; 785 if (error) 786 enabled = FALSE; 787 } 788 sc->tz_cooling_enabled = enabled; 789 return (error); 790 } 791 792 static int 793 acpi_tz_temp_sysctl(SYSCTL_HANDLER_ARGS) 794 { 795 struct acpi_tz_softc *sc; 796 int temp, *temp_ptr; 797 int error; 798 799 sc = oidp->oid_arg1; 800 temp_ptr = (int *)(void *)(uintptr_t)((uintptr_t)sc + oidp->oid_arg2); 801 temp = *temp_ptr; 802 error = sysctl_handle_int(oidp, &temp, 0, req); 803 804 /* Error or no new value */ 805 if (error != 0 || req->newptr == NULL) 806 return (error); 807 808 /* Only allow changing settings if override is set. */ 809 if (!acpi_tz_override) 810 return (EPERM); 811 812 /* Check user-supplied value for sanity. */ 813 acpi_tz_sanity(sc, &temp, "user-supplied temp"); 814 if (temp == -1) 815 return (EINVAL); 816 817 *temp_ptr = temp; 818 return (0); 819 } 820 821 static int 822 acpi_tz_passive_sysctl(SYSCTL_HANDLER_ARGS) 823 { 824 struct acpi_tz_softc *sc; 825 int val, *val_ptr; 826 int error; 827 828 sc = oidp->oid_arg1; 829 val_ptr = (int *)(void *)(uintptr_t)((uintptr_t)sc + oidp->oid_arg2); 830 val = *val_ptr; 831 error = sysctl_handle_int(oidp, &val, 0, req); 832 833 /* Error or no new value */ 834 if (error != 0 || req->newptr == NULL) 835 return (error); 836 837 /* Only allow changing settings if override is set. */ 838 if (!acpi_tz_override) 839 return (EPERM); 840 841 *val_ptr = val; 842 return (0); 843 } 844 845 static void 846 acpi_tz_notify_handler(ACPI_HANDLE h, UINT32 notify, void *context) 847 { 848 struct acpi_tz_softc *sc = (struct acpi_tz_softc *)context; 849 850 ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 851 852 switch (notify) { 853 case TZ_NOTIFY_TEMPERATURE: 854 /* Temperature change occurred */ 855 acpi_tz_signal(sc, 0); 856 break; 857 case TZ_NOTIFY_DEVICES: 858 case TZ_NOTIFY_LEVELS: 859 /* Zone devices/setpoints changed */ 860 acpi_tz_signal(sc, TZ_FLAG_GETSETTINGS); 861 break; 862 default: 863 ACPI_VPRINT(sc->tz_dev, acpi_device_get_parent_softc(sc->tz_dev), 864 "unknown Notify event 0x%x\n", notify); 865 break; 866 } 867 868 acpi_UserNotify("Thermal", h, notify); 869 870 return_VOID; 871 } 872 873 static void 874 acpi_tz_signal(struct acpi_tz_softc *sc, int flags) 875 { 876 ACPI_LOCK(thermal); 877 sc->tz_flags |= flags; 878 ACPI_UNLOCK(thermal); 879 wakeup(&acpi_tz_proc); 880 } 881 882 /* 883 * Notifies can be generated asynchronously but have also been seen to be 884 * triggered by other thermal methods. One system generates a notify of 885 * 0x81 when the fan is turned on or off. Another generates it when _SCP 886 * is called. To handle these situations, we check the zone via 887 * acpi_tz_monitor() before evaluating changes to setpoints or the cooling 888 * policy. 889 */ 890 static void 891 acpi_tz_timeout(struct acpi_tz_softc *sc, int flags) 892 { 893 894 /* Check the current temperature and take action based on it */ 895 acpi_tz_monitor(sc); 896 897 /* If requested, get the power profile settings. */ 898 if (flags & TZ_FLAG_GETPROFILE) 899 acpi_tz_power_profile(sc); 900 901 /* 902 * If requested, check for new devices/setpoints. After finding them, 903 * check if we need to switch fans based on the new values. 904 */ 905 if (flags & TZ_FLAG_GETSETTINGS) { 906 acpi_tz_establish(sc); 907 acpi_tz_monitor(sc); 908 } 909 910 /* XXX passive cooling actions? */ 911 } 912 913 /* 914 * System power profile may have changed; fetch and notify the 915 * thermal zone accordingly. 916 * 917 * Since this can be called from an arbitrary eventhandler, it needs 918 * to get the ACPI lock itself. 919 */ 920 static void 921 acpi_tz_power_profile(void *arg) 922 { 923 ACPI_STATUS status; 924 struct acpi_tz_softc *sc = (struct acpi_tz_softc *)arg; 925 int state; 926 927 state = power_profile_get_state(); 928 if (state != POWER_PROFILE_PERFORMANCE && state != POWER_PROFILE_ECONOMY) 929 return; 930 931 /* check that we haven't decided there's no _SCP method */ 932 if ((sc->tz_flags & TZ_FLAG_NO_SCP) == 0) { 933 934 /* Call _SCP to set the new profile */ 935 status = acpi_SetInteger(sc->tz_handle, "_SCP", 936 (state == POWER_PROFILE_PERFORMANCE) ? 0 : 1); 937 if (ACPI_FAILURE(status)) { 938 if (status != AE_NOT_FOUND) 939 ACPI_VPRINT(sc->tz_dev, 940 acpi_device_get_parent_softc(sc->tz_dev), 941 "can't evaluate %s._SCP - %s\n", 942 acpi_name(sc->tz_handle), 943 AcpiFormatException(status)); 944 sc->tz_flags |= TZ_FLAG_NO_SCP; 945 } else { 946 /* We have to re-evaluate the entire zone now */ 947 acpi_tz_signal(sc, TZ_FLAG_GETSETTINGS); 948 } 949 } 950 } 951 952 /* 953 * Thermal zone monitor thread. 954 */ 955 static void 956 acpi_tz_thread(void *arg) 957 { 958 device_t *devs; 959 int devcount, i; 960 int flags; 961 struct acpi_tz_softc **sc; 962 963 ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 964 965 devs = NULL; 966 devcount = 0; 967 sc = NULL; 968 969 for (;;) { 970 /* If the number of devices has changed, re-evaluate. */ 971 if (devclass_get_count(acpi_tz_devclass) != devcount) { 972 if (devs != NULL) { 973 free(devs, M_TEMP); 974 free(sc, M_TEMP); 975 } 976 devclass_get_devices(acpi_tz_devclass, &devs, &devcount); 977 sc = malloc(sizeof(struct acpi_tz_softc *) * devcount, M_TEMP, 978 M_WAITOK | M_ZERO); 979 for (i = 0; i < devcount; i++) 980 sc[i] = device_get_softc(devs[i]); 981 } 982 983 /* Check for temperature events and act on them. */ 984 for (i = 0; i < devcount; i++) { 985 ACPI_LOCK(thermal); 986 flags = sc[i]->tz_flags; 987 sc[i]->tz_flags &= TZ_FLAG_NO_SCP; 988 ACPI_UNLOCK(thermal); 989 acpi_tz_timeout(sc[i], flags); 990 } 991 992 /* If more work to do, don't go to sleep yet. */ 993 ACPI_LOCK(thermal); 994 for (i = 0; i < devcount; i++) { 995 if (sc[i]->tz_flags & ~TZ_FLAG_NO_SCP) 996 break; 997 } 998 999 /* 1000 * If we have no more work, sleep for a while, setting PDROP so that 1001 * the mutex will not be reacquired. Otherwise, drop the mutex and 1002 * loop to handle more events. 1003 */ 1004 if (i == devcount) 1005 msleep(&acpi_tz_proc, &thermal_mutex, PZERO | PDROP, "tzpoll", 1006 hz * acpi_tz_polling_rate); 1007 else 1008 ACPI_UNLOCK(thermal); 1009 } 1010 } 1011 1012 static int 1013 acpi_tz_cpufreq_restore(struct acpi_tz_softc *sc) 1014 { 1015 device_t dev; 1016 int error; 1017 1018 if (!sc->tz_cooling_updated) 1019 return (0); 1020 if ((dev = devclass_get_device(devclass_find("cpufreq"), 0)) == NULL) 1021 return (ENXIO); 1022 ACPI_VPRINT(sc->tz_dev, acpi_device_get_parent_softc(sc->tz_dev), 1023 "temperature %d.%dC: resuming previous clock speed (%d MHz)\n", 1024 TZ_KELVTOC(sc->tz_temperature), sc->tz_cooling_saved_freq); 1025 error = CPUFREQ_SET(dev, NULL, CPUFREQ_PRIO_KERN); 1026 if (error == 0) 1027 sc->tz_cooling_updated = FALSE; 1028 return (error); 1029 } 1030 1031 static int 1032 acpi_tz_cpufreq_update(struct acpi_tz_softc *sc, int req) 1033 { 1034 device_t dev; 1035 struct cf_level *levels; 1036 int num_levels, error, freq, desired_freq, perf, i; 1037 1038 levels = malloc(CPUFREQ_MAX_LEVELS * sizeof(*levels), M_TEMP, M_NOWAIT); 1039 if (levels == NULL) 1040 return (ENOMEM); 1041 1042 /* 1043 * Find the main device, cpufreq0. We don't yet support independent 1044 * CPU frequency control on SMP. 1045 */ 1046 if ((dev = devclass_get_device(devclass_find("cpufreq"), 0)) == NULL) { 1047 error = ENXIO; 1048 goto out; 1049 } 1050 1051 /* Get the current frequency. */ 1052 error = CPUFREQ_GET(dev, &levels[0]); 1053 if (error) 1054 goto out; 1055 freq = levels[0].total_set.freq; 1056 1057 /* Get the current available frequency levels. */ 1058 num_levels = CPUFREQ_MAX_LEVELS; 1059 error = CPUFREQ_LEVELS(dev, levels, &num_levels); 1060 if (error) { 1061 if (error == E2BIG) 1062 printf("cpufreq: need to increase CPUFREQ_MAX_LEVELS\n"); 1063 goto out; 1064 } 1065 1066 /* Calculate the desired frequency as a percent of the max frequency. */ 1067 perf = 100 * freq / levels[0].total_set.freq - req; 1068 if (perf < 0) 1069 perf = 0; 1070 else if (perf > 100) 1071 perf = 100; 1072 desired_freq = levels[0].total_set.freq * perf / 100; 1073 1074 if (desired_freq < freq) { 1075 /* Find the closest available frequency, rounding down. */ 1076 for (i = 0; i < num_levels; i++) 1077 if (levels[i].total_set.freq <= desired_freq) 1078 break; 1079 1080 /* If we didn't find a relevant setting, use the lowest. */ 1081 if (i == num_levels) 1082 i--; 1083 } else { 1084 /* If we didn't decrease frequency yet, don't increase it. */ 1085 if (!sc->tz_cooling_updated) { 1086 sc->tz_cooling_active = FALSE; 1087 goto out; 1088 } 1089 1090 /* Use saved cpu frequency as maximum value. */ 1091 if (desired_freq > sc->tz_cooling_saved_freq) 1092 desired_freq = sc->tz_cooling_saved_freq; 1093 1094 /* Find the closest available frequency, rounding up. */ 1095 for (i = num_levels - 1; i >= 0; i--) 1096 if (levels[i].total_set.freq >= desired_freq) 1097 break; 1098 1099 /* If we didn't find a relevant setting, use the highest. */ 1100 if (i == -1) 1101 i++; 1102 1103 /* If we're going to the highest frequency, restore the old setting. */ 1104 if (i == 0 || desired_freq == sc->tz_cooling_saved_freq) { 1105 error = acpi_tz_cpufreq_restore(sc); 1106 if (error == 0) 1107 sc->tz_cooling_active = FALSE; 1108 goto out; 1109 } 1110 } 1111 1112 /* If we are going to a new frequency, activate it. */ 1113 if (levels[i].total_set.freq != freq) { 1114 ACPI_VPRINT(sc->tz_dev, acpi_device_get_parent_softc(sc->tz_dev), 1115 "temperature %d.%dC: %screasing clock speed " 1116 "from %d MHz to %d MHz\n", 1117 TZ_KELVTOC(sc->tz_temperature), 1118 (freq > levels[i].total_set.freq) ? "de" : "in", 1119 freq, levels[i].total_set.freq); 1120 error = CPUFREQ_SET(dev, &levels[i], CPUFREQ_PRIO_KERN); 1121 if (error == 0 && !sc->tz_cooling_updated) { 1122 sc->tz_cooling_saved_freq = freq; 1123 sc->tz_cooling_updated = TRUE; 1124 } 1125 } 1126 1127 out: 1128 if (levels) 1129 free(levels, M_TEMP); 1130 return (error); 1131 } 1132 1133 /* 1134 * Passive cooling thread; monitors current temperature according to the 1135 * cooling interval and calculates whether to scale back CPU frequency. 1136 */ 1137 static void 1138 acpi_tz_cooling_thread(void *arg) 1139 { 1140 struct acpi_tz_softc *sc; 1141 int error, perf, curr_temp, prev_temp; 1142 1143 ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 1144 1145 sc = (struct acpi_tz_softc *)arg; 1146 1147 prev_temp = sc->tz_temperature; 1148 while (sc->tz_cooling_enabled) { 1149 if (sc->tz_cooling_active) 1150 (void)acpi_tz_get_temperature(sc); 1151 curr_temp = sc->tz_temperature; 1152 if (curr_temp >= sc->tz_zone.psv) 1153 sc->tz_cooling_active = TRUE; 1154 if (sc->tz_cooling_active) { 1155 perf = sc->tz_zone.tc1 * (curr_temp - prev_temp) + 1156 sc->tz_zone.tc2 * (curr_temp - sc->tz_zone.psv); 1157 perf /= 10; 1158 1159 if (perf != 0) { 1160 error = acpi_tz_cpufreq_update(sc, perf); 1161 1162 /* 1163 * If error and not simply a higher priority setting was 1164 * active, disable cooling. 1165 */ 1166 if (error != 0 && error != EPERM) { 1167 device_printf(sc->tz_dev, 1168 "failed to set new freq, disabling passive cooling\n"); 1169 sc->tz_cooling_enabled = FALSE; 1170 } 1171 } 1172 } 1173 prev_temp = curr_temp; 1174 tsleep(&sc->tz_cooling_proc, PZERO, "cooling", 1175 hz * sc->tz_zone.tsp / 10); 1176 } 1177 if (sc->tz_cooling_active) { 1178 acpi_tz_cpufreq_restore(sc); 1179 sc->tz_cooling_active = FALSE; 1180 } 1181 sc->tz_cooling_proc = NULL; 1182 ACPI_LOCK(thermal); 1183 sc->tz_cooling_proc_running = FALSE; 1184 ACPI_UNLOCK(thermal); 1185 kproc_exit(0); 1186 } 1187 1188 /* 1189 * TODO: We ignore _PSL (list of cooling devices) since cpufreq enumerates 1190 * all CPUs for us. However, it's possible in the future _PSL will 1191 * reference non-CPU devices so we may want to support it then. 1192 */ 1193 static int 1194 acpi_tz_cooling_is_available(struct acpi_tz_softc *sc) 1195 { 1196 return (sc->tz_zone.tc1 != -1 && sc->tz_zone.tc2 != -1 && 1197 sc->tz_zone.tsp != -1 && sc->tz_zone.tsp != 0 && 1198 sc->tz_zone.psv != -1); 1199 } 1200 1201 static int 1202 acpi_tz_cooling_thread_start(struct acpi_tz_softc *sc) 1203 { 1204 int error; 1205 1206 ACPI_LOCK(thermal); 1207 if (sc->tz_cooling_proc_running) { 1208 ACPI_UNLOCK(thermal); 1209 return (0); 1210 } 1211 sc->tz_cooling_proc_running = TRUE; 1212 ACPI_UNLOCK(thermal); 1213 error = 0; 1214 if (sc->tz_cooling_proc == NULL) { 1215 error = kproc_create(acpi_tz_cooling_thread, sc, 1216 &sc->tz_cooling_proc, RFHIGHPID, 0, "acpi_cooling%d", 1217 device_get_unit(sc->tz_dev)); 1218 if (error != 0) { 1219 device_printf(sc->tz_dev, "could not create thread - %d", error); 1220 ACPI_LOCK(thermal); 1221 sc->tz_cooling_proc_running = FALSE; 1222 ACPI_UNLOCK(thermal); 1223 } 1224 } 1225 return (error); 1226 } 1227