sys/dev/acpi/acpi_tz.c

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