sys/dev/acpica/acpi_thermal.c

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