sys/dev/acpi/acpi_tz.c

   1 /* $NetBSD: acpi_tz.c,v 1.46 2009/08/25 10:34:08 jmcneill 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.46 2009/08/25 10:34:08 jmcneill 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         /* Passive cooling temperature threshold */
  97         UINT32 psv;
  98         /* Thermal constants for use in passive cooling formulas */
  99         UINT32 tc1, tc2;
 100         /* Current temperature of the thermal zone */
 101         UINT32 tmp;
 102         /* Thermal sampling period for passive cooling, in tenths of seconds */
 103         UINT32 tsp;
 104         /* Package of references to devices in this TZ (optional) */
 105         ACPI_BUFFER tzd;
 106         /* Recommended TZ polling frequency, in tenths of seconds */
 107         UINT32 tzp;
 108 };
 109
 110 struct acpitz_softc {
 111         struct acpi_devnode *sc_devnode;
 112         struct acpitz_zone sc_zone;
 113         struct callout sc_callout;
 114         struct sysmon_envsys *sc_sme;
 115         envsys_data_t sc_sensor;
 116         int sc_active;          /* active cooling level */
 117         int sc_flags;
 118         int sc_rate;            /* tz poll rate */
 119         int sc_zone_expire;
 120
 121         int sc_first;
 122 };
 123
 124 static void     acpitz_get_status(void *);
 125 static void     acpitz_get_zone(void *, int);
 126 static void     acpitz_get_zone_quiet(void *);
 127 static char     *acpitz_celcius_string(int);
 128 static void     acpitz_print_status(device_t);
 129 static void     acpitz_power_off(struct acpitz_softc *);
 130 static void     acpitz_power_zone(struct acpitz_softc *, int, int);
 131 static void     acpitz_sane_temp(UINT32 *tmp);
 132 static ACPI_STATUS
 133                 acpitz_switch_cooler(ACPI_OBJECT *, void *);
 134 static void     acpitz_notify_handler(ACPI_HANDLE, UINT32, void *);
 135 static int      acpitz_get_integer(device_t, const char *, UINT32 *);
 136 static void     acpitz_tick(void *);
 137 static void     acpitz_init_envsys(device_t);
 138 static void     acpitz_get_limits(struct sysmon_envsys *, envsys_data_t *,
 139                                   sysmon_envsys_lim_t *);
 140
 141 CFATTACH_DECL_NEW(acpitz, sizeof(struct acpitz_softc), acpitz_match,
 142     acpitz_attach, NULL, NULL);
 143
 144 /*
 145  * acpitz_match: autoconf(9) match routine
 146  */
 147 static int
 148 acpitz_match(device_t parent, cfdata_t match, void *aux)
 149 {
 150         struct acpi_attach_args *aa = aux;
 151
 152         if (aa->aa_node->ad_type != ACPI_TYPE_THERMAL)
 153                 return 0;
 154
 155         return 1;
 156 }
 157
 158 /*
 159  * acpitz_attach: autoconf(9) attach routine
 160  */
 161 static void
 162 acpitz_attach(device_t parent, device_t self, void *aux)
 163 {
 164         struct acpitz_softc *sc = device_private(self);
 165         struct acpi_attach_args *aa = aux;
 166         ACPI_STATUS rv;
 167         ACPI_INTEGER v;
 168
 169 #if 0
 170         sc->sc_flags = ATZ_F_VERBOSE;
 171 #endif
 172         sc->sc_devnode = aa->aa_node;
 173
 174         aprint_naive("\n");
 175
 176         rv = acpi_eval_integer(sc->sc_devnode->ad_handle, "_TZP", &v);
 177         if (ACPI_FAILURE(rv))
 178                 sc->sc_zone.tzp = ATZ_TZP_RATE;
 179         else
 180                 sc->sc_zone.tzp = v;
 181
 182         aprint_debug(" sample rate %d.%ds\n",
 183             sc->sc_zone.tzp / 10, sc->sc_zone.tzp % 10);
 184
 185         /* XXX a value of 0 means "polling is not necessary" */
 186         if (sc->sc_zone.tzp == 0)
 187                 sc->sc_zone.tzp = ATZ_TZP_RATE;
 188
 189         sc->sc_zone_expire = ATZ_ZONE_EXPIRE / sc->sc_zone.tzp;
 190         sc->sc_first = 1;
 191
 192         acpitz_get_zone(self, 1);
 193         acpitz_get_status(self);
 194
 195         rv = AcpiInstallNotifyHandler(sc->sc_devnode->ad_handle,
 196             ACPI_SYSTEM_NOTIFY, acpitz_notify_handler, self);
 197         if (ACPI_FAILURE(rv)) {
 198                 aprint_error(": unable to install SYSTEM NOTIFY handler: %s\n",
 199                     AcpiFormatException(rv));
 200                 return;
 201         }
 202
 203         callout_init(&sc->sc_callout, CALLOUT_MPSAFE);
 204         callout_setfunc(&sc->sc_callout, acpitz_tick, self);
 205
 206         acpitz_init_envsys(self);
 207
 208         if (!pmf_device_register(self, NULL, NULL))
 209                 aprint_error(": couldn't establish power handler\n");
 210
 211         callout_schedule(&sc->sc_callout, sc->sc_zone.tzp * hz / 10);
 212 }
 213
 214 static void
 215 acpitz_get_zone_quiet(void *opaque)
 216 {
 217         acpitz_get_zone(opaque, 0);
 218 }
 219
 220 static void
 221 acpitz_get_status(void *opaque)
 222 {
 223         device_t dv = opaque;
 224         struct acpitz_softc *sc = device_private(dv);
 225         UINT32 tmp, active;
 226         int i, flags;
 227
 228         sc->sc_zone_expire--;
 229         if (sc->sc_zone_expire <= 0) {
 230                 sc->sc_zone_expire = ATZ_ZONE_EXPIRE / sc->sc_zone.tzp;
 231                 if (sc->sc_flags & ATZ_F_VERBOSE)
 232                         printf("%s: force refetch zone\n", device_xname(dv));
 233                 acpitz_get_zone(dv, 0);
 234         }
 235
 236         if (acpitz_get_integer(dv, "_TMP", &tmp)) {
 237                 aprint_error_dev(dv, "failed to evaluate _TMP\n");
 238                 return;
 239         }
 240         sc->sc_zone.tmp = tmp;
 241         /* XXX sanity check for tmp here? */
 242
 243         /*
 244          * The temperature unit for envsys(4) is microKelvin, so convert to
 245          * that from ACPI's microKelvin. Also, the ACPI specification assumes
 246          * that K = C + 273.2 rather than the nominal 273.15 used by envsys(4),
 247          * so we correct for that too.
 248          */
 249         sc->sc_sensor.value_cur = ATZ2UKELVIN(sc->sc_zone.tmp);
 250         sc->sc_sensor.state = ENVSYS_SVALID;
 251
 252         if (sc->sc_flags & ATZ_F_VERBOSE)
 253                 acpitz_print_status(dv);
 254
 255         if (sc->sc_flags & ATZ_F_PASSIVEONLY) {
 256                 /* Passive Cooling: XXX not yet */
 257
 258         } else {
 259                 /* Active Cooling */
 260
 261                 /* temperature threshold: _AC0 > ... > _AC9 */
 262                 active = ATZ_ACTIVE_NONE;
 263                 for (i = ATZ_NLEVELS - 1; i >= 0; i--) {
 264                         if (sc->sc_zone.ac[i] == ATZ_TMP_INVALID)
 265                                 continue;
 266
 267                         /* we want to keep highest cooling mode in 'active' */
 268                         if (sc->sc_zone.ac[i] <= tmp)
 269                                 active = i;
 270                 }
 271                 if (active != ATZ_ACTIVE_NONE)
 272                         sc->sc_sensor.state = ENVSYS_SWARNOVER;
 273
 274                 flags = sc->sc_flags &
 275                     ~(ATZ_F_CRITICAL|ATZ_F_HOT|ATZ_F_PASSIVE);
 276                 if (sc->sc_zone.psv != ATZ_TMP_INVALID &&
 277                     tmp >= sc->sc_zone.psv)
 278                         flags |= ATZ_F_PASSIVE;
 279                 if (sc->sc_zone.hot != ATZ_TMP_INVALID &&
 280                     tmp >= sc->sc_zone.hot)
 281                         flags |= ATZ_F_HOT;
 282                 if (sc->sc_zone.crt != ATZ_TMP_INVALID &&
 283                     tmp >= sc->sc_zone.crt)
 284                         flags |= ATZ_F_CRITICAL;
 285
 286                 if (flags != sc->sc_flags) {
 287                         int changed = (sc->sc_flags ^ flags) & flags;
 288                         sc->sc_flags = flags;
 289                         if (changed & ATZ_F_CRITICAL) {
 290                                 sc->sc_sensor.state = ENVSYS_SCRITOVER;
 291                                 aprint_debug_dev(dv,
 292                                     "zone went critical at temp %sC\n",
 293                                     acpitz_celcius_string(tmp));
 294                         } else if (changed & ATZ_F_HOT) {
 295                                 sc->sc_sensor.state = ENVSYS_SCRITOVER;
 296                                 aprint_debug_dev(dv,
 297                                     "zone went hot at temp %sC\n",
 298                                     acpitz_celcius_string(tmp));
 299                         }
 300                 }
 301
 302                 /* power on fans */
 303                 if (sc->sc_active != active) {
 304                         if (sc->sc_active != ATZ_ACTIVE_NONE)
 305                                 acpitz_power_zone(sc, sc->sc_active, 0);
 306
 307                         if (active != ATZ_ACTIVE_NONE) {
 308                                 if (sc->sc_flags & ATZ_F_VERBOSE)
 309                                         printf("%s: active cooling level %u\n",
 310                                             device_xname(dv), active);
 311                                 acpitz_power_zone(sc, active, 1);
 312                         }
 313
 314                         sc->sc_active = active;
 315                 }
 316         }
 317
 318         return;
 319 }
 320
 321 static char *
 322 acpitz_celcius_string(int dk)
 323 {
 324         static char buf[10];
 325
 326         snprintf(buf, sizeof(buf), "%d.%d", (dk - ATZ_ZEROC) / 10,
 327             (dk - ATZ_ZEROC) % 10);
 328
 329         return buf;
 330 }
 331
 332 static void
 333 acpitz_print_status(device_t dv)
 334 {
 335         struct acpitz_softc *sc = device_private(dv);
 336
 337         printf("%s: zone temperature is now %sC\n", device_xname(dv),
 338             acpitz_celcius_string(sc->sc_zone.tmp));
 339
 340         return;
 341 }
 342
 343 static ACPI_STATUS
 344 acpitz_switch_cooler(ACPI_OBJECT *obj, void *arg)
 345 {
 346         ACPI_HANDLE cooler;
 347         ACPI_STATUS rv;
 348         int pwr_state, flag;
 349
 350         flag = *(int *)arg;
 351
 352         if (flag)
 353                 pwr_state = ACPI_STATE_D0;
 354         else
 355                 pwr_state = ACPI_STATE_D3;
 356
 357         switch(obj->Type) {
 358         case ACPI_TYPE_LOCAL_REFERENCE:
 359         case ACPI_TYPE_ANY:
 360                 cooler = obj->Reference.Handle;
 361                 break;
 362         case ACPI_TYPE_STRING:
 363                 rv = AcpiGetHandle(NULL, obj->String.Pointer, &cooler);
 364                 if (ACPI_FAILURE(rv)) {
 365                         printf("acpitz_switch_cooler: "
 366                             "failed to get handler from %s\n",
 367                             obj->String.Pointer);
 368                         return rv;
 369                 }
 370                 break;
 371         default:
 372                 printf("acpitz_switch_cooler: "
 373                     "unknown power type: %d\n", obj->Type);
 374                 return AE_OK;
 375         }
 376
 377         rv = acpi_pwr_switch_consumer(cooler, pwr_state);
 378         if (rv != AE_BAD_PARAMETER && ACPI_FAILURE(rv)) {
 379                 printf("acpitz_switch_cooler: "
 380                     "failed to change state for %s: %s\n",
 381                     acpi_name(obj->Reference.Handle),
 382                     AcpiFormatException(rv));
 383         }
 384
 385         return AE_OK;
 386 }
 387
 388 /*
 389  * acpitz_power_zone:
 390  *      power on or off the i:th part of the zone zone
 391  */
 392 static void
 393 acpitz_power_zone(struct acpitz_softc *sc, int i, int on)
 394 {
 395         KASSERT(i >= 0 && i < ATZ_NLEVELS);
 396
 397         acpi_foreach_package_object(sc->sc_zone.al[i].Pointer,
 398             acpitz_switch_cooler, &on);
 399 }
 400
 401
 402 /*
 403  * acpitz_power_off:
 404  *      power off parts of the zone
 405  */
 406 static void
 407 acpitz_power_off(struct acpitz_softc *sc)
 408 {
 409         int i;
 410
 411         for (i = 0 ; i < ATZ_NLEVELS; i++) {
 412                 if (sc->sc_zone.al[i].Pointer == NULL)
 413                         continue;
 414                 acpitz_power_zone(sc, i, 0);
 415         }
 416         sc->sc_active = ATZ_ACTIVE_NONE;
 417         sc->sc_flags &= ~(ATZ_F_CRITICAL|ATZ_F_HOT|ATZ_F_PASSIVE);
 418 }
 419
 420 static void
 421 acpitz_get_zone(void *opaque, int verbose)
 422 {
 423         device_t dv = opaque;
 424         struct acpitz_softc *sc = device_private(dv);
 425         ACPI_STATUS rv;
 426         char buf[8];
 427         int i, valid_levels;
 428
 429         if (!sc->sc_first) {
 430                 acpitz_power_off(sc);
 431
 432                 for (i = 0; i < ATZ_NLEVELS; i++) {
 433                         if (sc->sc_zone.al[i].Pointer != NULL)
 434                                 ACPI_FREE(sc->sc_zone.al[i].Pointer);
 435                         sc->sc_zone.al[i].Pointer = NULL;
 436                 }
 437         } else
 438                 aprint_normal(":");
 439
 440         valid_levels = 0;
 441
 442         for (i = 0; i < ATZ_NLEVELS; i++) {
 443                 ACPI_OBJECT *obj;
 444
 445                 snprintf(buf, sizeof(buf), "_AC%d", i);
 446                 if (acpitz_get_integer(dv, buf, &sc->sc_zone.ac[i]))
 447                         continue;
 448
 449                 snprintf(buf, sizeof(buf), "_AL%d", i);
 450                 rv = acpi_eval_struct(sc->sc_devnode->ad_handle, buf,
 451                     &sc->sc_zone.al[i]);
 452                 if (ACPI_FAILURE(rv)) {
 453                         sc->sc_zone.al[i].Pointer = NULL;
 454                         continue;
 455                 }
 456
 457                 obj = sc->sc_zone.al[i].Pointer;
 458                 if (obj != NULL) {
 459                         if (obj->Type != ACPI_TYPE_PACKAGE) {
 460                                 aprint_error("%d not package\n", i);
 461                                 ACPI_FREE(obj);
 462                                 sc->sc_zone.al[i].Pointer = NULL;
 463                                 continue;
 464                         }
 465                 }
 466
 467                 if (sc->sc_first)
 468                         aprint_normal(" active cooling level %d: %sC", i,
 469                             acpitz_celcius_string(sc->sc_zone.ac[i]));
 470
 471                 valid_levels++;
 472         }
 473
 474         acpitz_get_integer(dv, "_TMP", &sc->sc_zone.tmp);
 475         acpitz_get_integer(dv, "_CRT", &sc->sc_zone.crt);
 476         acpitz_get_integer(dv, "_HOT", &sc->sc_zone.hot);
 477         sc->sc_zone.psl.Length = ACPI_ALLOCATE_LOCAL_BUFFER;
 478         sc->sc_zone.psl.Pointer = NULL;
 479         AcpiEvaluateObject(sc, "_PSL", NULL, &sc->sc_zone.psl);
 480         acpitz_get_integer(dv, "_PSV", &sc->sc_zone.psv);
 481         acpitz_get_integer(dv, "_TC1", &sc->sc_zone.tc1);
 482         acpitz_get_integer(dv, "_TC2", &sc->sc_zone.tc2);
 483
 484         acpitz_sane_temp(&sc->sc_zone.tmp);
 485         acpitz_sane_temp(&sc->sc_zone.crt);
 486         acpitz_sane_temp(&sc->sc_zone.hot);
 487         acpitz_sane_temp(&sc->sc_zone.psv);
 488
 489         if (verbose) {
 490                 if (sc->sc_zone.crt != ATZ_TMP_INVALID)
 491                         aprint_normal(" critical %sC",
 492                             acpitz_celcius_string(sc->sc_zone.crt));
 493                 if (sc->sc_zone.hot != ATZ_TMP_INVALID)
 494                         aprint_normal(" hot %sC",
 495                             acpitz_celcius_string(sc->sc_zone.hot));
 496                 if (sc->sc_zone.psv != ATZ_TMP_INVALID)
 497                         aprint_normal(" passive %sC",
 498                             acpitz_celcius_string(sc->sc_zone.tmp));
 499         }
 500
 501         if (valid_levels == 0) {
 502                 sc->sc_flags |= ATZ_F_PASSIVEONLY;
 503                 if (sc->sc_first)
 504                         aprint_normal(", passive cooling");
 505         }
 506         if (verbose)
 507                 aprint_normal("\n");
 508
 509         for (i = 0; i < ATZ_NLEVELS; i++)
 510                 acpitz_sane_temp(&sc->sc_zone.ac[i]);
 511
 512         acpitz_power_off(sc);
 513         sc->sc_first = 0;
 514 }
 515
 516
 517 static void
 518 acpitz_notify_handler(ACPI_HANDLE hdl, UINT32 notify, void *opaque)
 519 {
 520         device_t dv = opaque;
 521         ACPI_OSD_EXEC_CALLBACK func = NULL;
 522         const char *name;
 523         ACPI_STATUS rv;
 524
 525         switch (notify) {
 526         case ACPI_NOTIFY_ThermalZoneStatusChanged:
 527                 func = acpitz_get_status;
 528                 name = "status check";
 529                 break;
 530         case ACPI_NOTIFY_ThermalZoneTripPointsChanged:
 531         case ACPI_NOTIFY_DeviceListsChanged:
 532                 func = acpitz_get_zone_quiet;
 533                 name = "get zone";
 534                 break;
 535         default:
 536                 aprint_debug_dev(dv,
 537                     "received unhandled notify message 0x%x\n", notify);
 538                 return;
 539         }
 540
 541         KASSERT(func != NULL);
 542
 543         rv = AcpiOsExecute(OSL_NOTIFY_HANDLER, func, dv);
 544         if (ACPI_FAILURE(rv))
 545                 aprint_debug_dev(dv, "unable to queue %s\n", name);
 546 }
 547
 548 static void
 549 acpitz_sane_temp(UINT32 *tmp)
 550 {
 551         /* Sane temperatures are beteen 0 and 150 C */
 552         if (*tmp < ATZ_ZEROC || *tmp > ATZ_ZEROC + 1500)
 553                 *tmp = ATZ_TMP_INVALID;
 554 }
 555
 556 static int
 557 acpitz_get_integer(device_t dv, const char *cm, UINT32 *val)
 558 {
 559         struct acpitz_softc *sc = device_private(dv);
 560         ACPI_STATUS rv;
 561         ACPI_INTEGER tmp;
 562
 563         rv = acpi_eval_integer(sc->sc_devnode->ad_handle, cm, &tmp);
 564         if (ACPI_FAILURE(rv)) {
 565 #ifdef ACPI_DEBUG
 566                 aprint_debug_dev(dv, "failed to evaluate %s: %s\n",
 567                     cm, AcpiFormatException(rv));
 568 #endif
 569                 *val = ATZ_TMP_INVALID;
 570                 return 1;
 571         }
 572
 573         *val = tmp;
 574
 575         return 0;
 576 }
 577
 578 static void
 579 acpitz_tick(void *opaque)
 580 {
 581         device_t dv = opaque;
 582         struct acpitz_softc *sc = device_private(dv);
 583
 584         AcpiOsExecute(OSL_NOTIFY_HANDLER, acpitz_get_status, dv);
 585
 586         callout_schedule(&sc->sc_callout, sc->sc_zone.tzp * hz / 10);
 587 }
 588
 589 static void
 590 acpitz_init_envsys(device_t dv)
 591 {
 592         struct acpitz_softc *sc = device_private(dv);
 593
 594         sc->sc_sme = sysmon_envsys_create();
 595         sc->sc_sme->sme_get_limits = acpitz_get_limits;
 596         sc->sc_sme->sme_cookie = sc;
 597         sc->sc_sme->sme_name = device_xname(dv);
 598         sc->sc_sme->sme_flags = SME_DISABLE_REFRESH;
 599         sc->sc_sensor.monitor = true;
 600         sc->sc_sensor.flags = ENVSYS_FMONLIMITS | ENVSYS_FMONNOTSUPP;
 601         sc->sc_sensor.units = ENVSYS_STEMP;
 602         strlcpy(sc->sc_sensor.desc, "temperature", sizeof(sc->sc_sensor.desc));
 603         if (sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor))
 604                 goto out;
 605
 606         /* hook into sysmon */
 607         if (sysmon_envsys_register(sc->sc_sme) == 0)
 608                 return;
 609 out:
 610         aprint_error_dev(dv, "unable to register with sysmon\n");
 611         sysmon_envsys_destroy(sc->sc_sme);
 612 }
 613
 614 static void
 615 acpitz_get_limits(struct sysmon_envsys *sme, envsys_data_t *edata,
 616                   sysmon_envsys_lim_t *limits)
 617 {
 618         struct acpitz_softc *sc = sme->sme_cookie;
 619         int i;
 620
 621         limits->sel_flags = 0;
 622
 623         if (sc->sc_zone.hot != ATZ_TMP_INVALID) {
 624                 limits->sel_flags |= PROP_CRITMAX;
 625                 limits->sel_critmax = ATZ2UKELVIN(sc->sc_zone.hot);
 626         } else if (sc->sc_zone.crt != ATZ_TMP_INVALID) {
 627                 limits->sel_flags |= PROP_CRITMAX;
 628                 limits->sel_critmax = ATZ2UKELVIN(sc->sc_zone.crt);
 629         }
 630         for (i = 0; i < ATZ_NLEVELS; i++)
 631                 if (sc->sc_zone.ac[i] != ATZ_TMP_INVALID) {
 632                         limits->sel_critmax = ATZ2UKELVIN(sc->sc_zone.ac[i]);
 633                         limits->sel_flags |= PROP_WARNMAX;
 634                         break;
 635                 }
 636 }