sys/dev/acpica5/acpi_cmbat.c

   1 /*-
   2  * Copyright (c) 2005 Nate Lawson
   3  * Copyright (c) 2000 Munehiro Matsuda
   4  * Copyright (c) 2000 Takanori Watanabe
   5  * Copyright (c) 2000 Mitsuru IWASAKI <iwasaki@FreeBSD.org>
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  *
  29  * $FreeBSD: src/sys/dev/acpica/acpi_cmbat.c,v 1.46.8.1 2009/04/15 03:14:26 kensmith Exp $
  30  */
  31
  32 #include "opt_acpi.h"
  33 #include <sys/param.h>
  34 #include <sys/kernel.h>
  35 #include <sys/module.h>
  36 #include <sys/bus.h>
  37 #include <sys/ioccom.h>
  38
  39 #include <sys/rman.h>
  40 #include <sys/malloc.h>
  41
  42 #include "acpi.h"
  43 #include <dev/acpica5/acpivar.h>
  44 #include <dev/acpica5/acpiio.h>
  45
  46 MALLOC_DEFINE(M_ACPICMBAT, "acpicmbat", "ACPI control method battery data");
  47
  48 /* Number of times to retry initialization before giving up. */
  49 #define ACPI_CMBAT_RETRY_MAX    6
  50
  51 /* Check the battery once a minute. */
  52 #define CMBAT_POLLRATE          (60 * hz)
  53
  54 /* Hooks for the ACPI CA debugging infrastructure */
  55 #define _COMPONENT      ACPI_BATTERY
  56 ACPI_MODULE_NAME("BATTERY")
  57
  58 #define ACPI_BATTERY_BST_CHANGE 0x80
  59 #define ACPI_BATTERY_BIF_CHANGE 0x81
  60
  61 struct acpi_cmbat_softc {
  62     device_t        dev;
  63     int             flags;
  64
  65     struct acpi_bif bif;
  66     struct acpi_bst bst;
  67     struct timespec bst_lastupdated;
  68 };
  69
  70 ACPI_SERIAL_DECL(cmbat, "ACPI cmbat");
  71
  72 static int              acpi_cmbat_probe(device_t dev);
  73 static int              acpi_cmbat_attach(device_t dev);
  74 static int              acpi_cmbat_detach(device_t dev);
  75 static int              acpi_cmbat_resume(device_t dev);
  76 static void             acpi_cmbat_notify_handler(ACPI_HANDLE h, UINT32 notify,
  77                             void *context);
  78 static int              acpi_cmbat_info_expired(struct timespec *lastupdated);
  79 static void             acpi_cmbat_info_updated(struct timespec *lastupdated);
  80 static void             acpi_cmbat_get_bst(void *arg);
  81 static void             acpi_cmbat_get_bif_task(void *arg);
  82 static void             acpi_cmbat_get_bif(void *arg);
  83 static int              acpi_cmbat_bst(device_t dev, struct acpi_bst *bstp);
  84 static int              acpi_cmbat_bif(device_t dev, struct acpi_bif *bifp);
  85 static void             acpi_cmbat_init_battery(void *arg);
  86
  87 static device_method_t acpi_cmbat_methods[] = {
  88     /* Device interface */
  89     DEVMETHOD(device_probe,     acpi_cmbat_probe),
  90     DEVMETHOD(device_attach,    acpi_cmbat_attach),
  91     DEVMETHOD(device_detach,    acpi_cmbat_detach),
  92     DEVMETHOD(device_resume,    acpi_cmbat_resume),
  93
  94     /* ACPI battery interface */
  95     DEVMETHOD(acpi_batt_get_info, acpi_cmbat_bif),
  96     DEVMETHOD(acpi_batt_get_status, acpi_cmbat_bst),
  97
  98     {0, 0}
  99 };
 100
 101 static driver_t acpi_cmbat_driver = {
 102     "battery",
 103     acpi_cmbat_methods,
 104     sizeof(struct acpi_cmbat_softc),
 105 };
 106
 107 static devclass_t acpi_cmbat_devclass;
 108 DRIVER_MODULE(acpi_cmbat, acpi, acpi_cmbat_driver, acpi_cmbat_devclass, 0, 0);
 109 MODULE_DEPEND(acpi_cmbat, acpi, 1, 1, 1);
 110
 111 static int
 112 acpi_cmbat_probe(device_t dev)
 113 {
 114     static char *cmbat_ids[] = { "PNP0C0A", NULL };
 115
 116     if (acpi_disabled("cmbat") ||
 117         ACPI_ID_PROBE(device_get_parent(dev), dev, cmbat_ids) == NULL)
 118         return (ENXIO);
 119
 120     device_set_desc(dev, "ACPI Control Method Battery");
 121     return (0);
 122 }
 123
 124 static int
 125 acpi_cmbat_attach(device_t dev)
 126 {
 127     int         error;
 128     ACPI_HANDLE handle;
 129     struct acpi_cmbat_softc *sc;
 130
 131     sc = device_get_softc(dev);
 132     handle = acpi_get_handle(dev);
 133     sc->dev = dev;
 134
 135     ACPI_SERIAL_INIT(cmbat);
 136
 137     timespecclear(&sc->bst_lastupdated);
 138
 139     error = acpi_battery_register(dev);
 140     if (error != 0) {
 141         device_printf(dev, "registering battery failed\n");
 142         return (error);
 143     }
 144
 145     /*
 146      * Install a system notify handler in addition to the device notify.
 147      * Toshiba notebook uses this alternate notify for its battery.
 148      */
 149     AcpiInstallNotifyHandler(handle, ACPI_ALL_NOTIFY,
 150         acpi_cmbat_notify_handler, dev);
 151
 152     AcpiOsExecute(OSL_NOTIFY_HANDLER, acpi_cmbat_init_battery, dev);
 153
 154     return (0);
 155 }
 156
 157 static int
 158 acpi_cmbat_detach(device_t dev)
 159 {
 160     ACPI_HANDLE handle;
 161
 162     handle = acpi_get_handle(dev);
 163     AcpiRemoveNotifyHandler(handle, ACPI_ALL_NOTIFY, acpi_cmbat_notify_handler);
 164     acpi_battery_remove(dev);
 165     return (0);
 166 }
 167
 168 static int
 169 acpi_cmbat_resume(device_t dev)
 170 {
 171
 172     AcpiOsExecute(OSL_NOTIFY_HANDLER, acpi_cmbat_init_battery, dev);
 173     return (0);
 174 }
 175
 176 static void
 177 acpi_cmbat_notify_handler(ACPI_HANDLE h, UINT32 notify, void *context)
 178 {
 179     struct acpi_cmbat_softc *sc;
 180     device_t dev;
 181
 182     dev = (device_t)context;
 183     sc = device_get_softc(dev);
 184
 185     switch (notify) {
 186     case ACPI_NOTIFY_DEVICE_CHECK:
 187     case ACPI_BATTERY_BST_CHANGE:
 188         /*
 189          * Clear the last updated time.  The next call to retrieve the
 190          * battery status will get the new value for us.
 191          */
 192         timespecclear(&sc->bst_lastupdated);
 193         break;
 194     case ACPI_NOTIFY_BUS_CHECK:
 195     case ACPI_BATTERY_BIF_CHANGE:
 196         /*
 197          * Queue a callback to get the current battery info from thread
 198          * context.  It's not safe to block in a notify handler.
 199          */
 200         AcpiOsExecute(OSL_NOTIFY_HANDLER, acpi_cmbat_get_bif_task, dev);
 201         break;
 202     }
 203
 204     acpi_UserNotify("CMBAT", h, notify);
 205 }
 206
 207 static int
 208 acpi_cmbat_info_expired(struct timespec *lastupdated)
 209 {
 210     struct timespec     curtime;
 211
 212     ACPI_SERIAL_ASSERT(cmbat);
 213
 214     if (lastupdated == NULL)
 215         return (TRUE);
 216     if (!timespecisset(lastupdated))
 217         return (TRUE);
 218
 219     getnanotime(&curtime);
 220     timespecsub(&curtime, lastupdated);
 221     return (curtime.tv_sec < 0 ||
 222             curtime.tv_sec > acpi_battery_get_info_expire());
 223 }
 224
 225 static void
 226 acpi_cmbat_info_updated(struct timespec *lastupdated)
 227 {
 228
 229     ACPI_SERIAL_ASSERT(cmbat);
 230
 231     if (lastupdated != NULL)
 232         getnanotime(lastupdated);
 233 }
 234
 235 static void
 236 acpi_cmbat_get_bst(void *arg)
 237 {
 238     struct acpi_cmbat_softc *sc;
 239     ACPI_STATUS as;
 240     ACPI_OBJECT *res;
 241     ACPI_HANDLE h;
 242     ACPI_BUFFER bst_buffer;
 243     device_t dev;
 244
 245     ACPI_SERIAL_ASSERT(cmbat);
 246
 247     dev = arg;
 248     sc = device_get_softc(dev);
 249     h = acpi_get_handle(dev);
 250     bst_buffer.Pointer = NULL;
 251     bst_buffer.Length = ACPI_ALLOCATE_BUFFER;
 252
 253     if (!acpi_cmbat_info_expired(&sc->bst_lastupdated))
 254         goto end;
 255
 256     as = AcpiEvaluateObject(h, "_BST", NULL, &bst_buffer);
 257     if (ACPI_FAILURE(as)) {
 258         ACPI_VPRINT(dev, acpi_device_get_parent_softc(dev),
 259                     "error fetching current battery status -- %s\n",
 260                     AcpiFormatException(as));
 261         goto end;
 262     }
 263
 264     res = (ACPI_OBJECT *)bst_buffer.Pointer;
 265     if (!ACPI_PKG_VALID(res, 4)) {
 266         ACPI_VPRINT(dev, acpi_device_get_parent_softc(dev),
 267                     "battery status corrupted\n");
 268         goto end;
 269     }
 270
 271     if (acpi_PkgInt32(res, 0, &sc->bst.state) != 0)
 272         goto end;
 273     if (acpi_PkgInt32(res, 1, &sc->bst.rate) != 0)
 274         goto end;
 275     if (acpi_PkgInt32(res, 2, &sc->bst.cap) != 0)
 276         goto end;
 277     if (acpi_PkgInt32(res, 3, &sc->bst.volt) != 0)
 278         goto end;
 279     acpi_cmbat_info_updated(&sc->bst_lastupdated);
 280
 281     /* XXX If all batteries are critical, perhaps we should suspend. */
 282     if (sc->bst.state & ACPI_BATT_STAT_CRITICAL) {
 283         if ((sc->flags & ACPI_BATT_STAT_CRITICAL) == 0) {
 284             sc->flags |= ACPI_BATT_STAT_CRITICAL;
 285             device_printf(dev, "critically low charge!\n");
 286         }
 287     } else
 288         sc->flags &= ~ACPI_BATT_STAT_CRITICAL;
 289
 290 end:
 291     if (bst_buffer.Pointer != NULL)
 292         AcpiOsFree(bst_buffer.Pointer);
 293 }
 294
 295 /* XXX There should be a cleaner way to do this locking. */
 296 static void
 297 acpi_cmbat_get_bif_task(void *arg)
 298 {
 299
 300     ACPI_SERIAL_BEGIN(cmbat);
 301     acpi_cmbat_get_bif(arg);
 302     ACPI_SERIAL_END(cmbat);
 303 }
 304
 305 static void
 306 acpi_cmbat_get_bif(void *arg)
 307 {
 308     struct acpi_cmbat_softc *sc;
 309     ACPI_STATUS as;
 310     ACPI_OBJECT *res;
 311     ACPI_HANDLE h;
 312     ACPI_BUFFER bif_buffer;
 313     device_t dev;
 314
 315     ACPI_SERIAL_ASSERT(cmbat);
 316
 317     dev = arg;
 318     sc = device_get_softc(dev);
 319     h = acpi_get_handle(dev);
 320     bif_buffer.Pointer = NULL;
 321     bif_buffer.Length = ACPI_ALLOCATE_BUFFER;
 322
 323     as = AcpiEvaluateObject(h, "_BIF", NULL, &bif_buffer);
 324     if (ACPI_FAILURE(as)) {
 325         ACPI_VPRINT(dev, acpi_device_get_parent_softc(dev),
 326                     "error fetching current battery info -- %s\n",
 327                     AcpiFormatException(as));
 328         goto end;
 329     }
 330
 331     res = (ACPI_OBJECT *)bif_buffer.Pointer;
 332     if (!ACPI_PKG_VALID(res, 13)) {
 333         ACPI_VPRINT(dev, acpi_device_get_parent_softc(dev),
 334                     "battery info corrupted\n");
 335         goto end;
 336     }
 337
 338     if (acpi_PkgInt32(res, 0, &sc->bif.units) != 0)
 339         goto end;
 340     if (acpi_PkgInt32(res, 1, &sc->bif.dcap) != 0)
 341         goto end;
 342     if (acpi_PkgInt32(res, 2, &sc->bif.lfcap) != 0)
 343         goto end;
 344     if (acpi_PkgInt32(res, 3, &sc->bif.btech) != 0)
 345         goto end;
 346     if (acpi_PkgInt32(res, 4, &sc->bif.dvol) != 0)
 347         goto end;
 348     if (acpi_PkgInt32(res, 5, &sc->bif.wcap) != 0)
 349         goto end;
 350     if (acpi_PkgInt32(res, 6, &sc->bif.lcap) != 0)
 351         goto end;
 352     if (acpi_PkgInt32(res, 7, &sc->bif.gra1) != 0)
 353         goto end;
 354     if (acpi_PkgInt32(res, 8, &sc->bif.gra2) != 0)
 355         goto end;
 356     if (acpi_PkgStr(res,  9, sc->bif.model, ACPI_CMBAT_MAXSTRLEN) != 0)
 357         goto end;
 358     if (acpi_PkgStr(res, 10, sc->bif.serial, ACPI_CMBAT_MAXSTRLEN) != 0)
 359         goto end;
 360     if (acpi_PkgStr(res, 11, sc->bif.type, ACPI_CMBAT_MAXSTRLEN) != 0)
 361         goto end;
 362     if (acpi_PkgStr(res, 12, sc->bif.oeminfo, ACPI_CMBAT_MAXSTRLEN) != 0)
 363         goto end;
 364
 365 end:
 366     if (bif_buffer.Pointer != NULL)
 367         AcpiOsFree(bif_buffer.Pointer);
 368 }
 369
 370 static int
 371 acpi_cmbat_bif(device_t dev, struct acpi_bif *bifp)
 372 {
 373     struct acpi_cmbat_softc *sc;
 374
 375     sc = device_get_softc(dev);
 376
 377     /*
 378      * Just copy the data.  The only value that should change is the
 379      * last-full capacity, so we only update when we get a notify that says
 380      * the info has changed.  Many systems apparently take a long time to
 381      * process a _BIF call so we avoid it if possible.
 382      */
 383     ACPI_SERIAL_BEGIN(cmbat);
 384     bifp->units = sc->bif.units;
 385     bifp->dcap = sc->bif.dcap;
 386     bifp->lfcap = sc->bif.lfcap;
 387     bifp->btech = sc->bif.btech;
 388     bifp->dvol = sc->bif.dvol;
 389     bifp->wcap = sc->bif.wcap;
 390     bifp->lcap = sc->bif.lcap;
 391     bifp->gra1 = sc->bif.gra1;
 392     bifp->gra2 = sc->bif.gra2;
 393     strncpy(bifp->model, sc->bif.model, sizeof(sc->bif.model));
 394     strncpy(bifp->serial, sc->bif.serial, sizeof(sc->bif.serial));
 395     strncpy(bifp->type, sc->bif.type, sizeof(sc->bif.type));
 396     strncpy(bifp->oeminfo, sc->bif.oeminfo, sizeof(sc->bif.oeminfo));
 397     ACPI_SERIAL_END(cmbat);
 398
 399     return (0);
 400 }
 401
 402 static int
 403 acpi_cmbat_bst(device_t dev, struct acpi_bst *bstp)
 404 {
 405     struct acpi_cmbat_softc *sc;
 406
 407     sc = device_get_softc(dev);
 408
 409     ACPI_SERIAL_BEGIN(cmbat);
 410     if (acpi_BatteryIsPresent(dev)) {
 411         acpi_cmbat_get_bst(dev);
 412         bstp->state = sc->bst.state;
 413         bstp->rate = sc->bst.rate;
 414         bstp->cap = sc->bst.cap;
 415         bstp->volt = sc->bst.volt;
 416     } else
 417         bstp->state = ACPI_BATT_STAT_NOT_PRESENT;
 418     ACPI_SERIAL_END(cmbat);
 419
 420     return (0);
 421 }
 422
 423 static void
 424 acpi_cmbat_init_battery(void *arg)
 425 {
 426     struct acpi_cmbat_softc *sc;
 427     int         retry, valid;
 428     device_t    dev;
 429
 430     dev = (device_t)arg;
 431     sc = device_get_softc(dev);
 432     ACPI_VPRINT(dev, acpi_device_get_parent_softc(dev),
 433                 "battery initialization start\n");
 434
 435     /*
 436      * Try repeatedly to get valid data from the battery.  Since the
 437      * embedded controller isn't always ready just after boot, we may have
 438      * to wait a while.
 439      */
 440     for (retry = 0; retry < ACPI_CMBAT_RETRY_MAX; retry++, AcpiOsSleep(10000)) {
 441         /* batteries on DOCK can be ejected w/ DOCK during retrying */
 442         if (!device_is_attached(dev))
 443             return;
 444
 445         if (!acpi_BatteryIsPresent(dev))
 446             continue;
 447
 448         /*
 449          * Only query the battery if this is the first try or the specific
 450          * type of info is still invalid.
 451          */
 452         ACPI_SERIAL_BEGIN(cmbat);
 453         if (retry == 0 || !acpi_battery_bst_valid(&sc->bst)) {
 454             timespecclear(&sc->bst_lastupdated);
 455             acpi_cmbat_get_bst(dev);
 456         }
 457         if (retry == 0 || !acpi_battery_bif_valid(&sc->bif))
 458             acpi_cmbat_get_bif(dev);
 459
 460         valid = acpi_battery_bst_valid(&sc->bst) &&
 461             acpi_battery_bif_valid(&sc->bif);
 462         ACPI_SERIAL_END(cmbat);
 463
 464         if (valid)
 465             break;
 466     }
 467
 468     if (retry == ACPI_CMBAT_RETRY_MAX) {
 469         ACPI_VPRINT(dev, acpi_device_get_parent_softc(dev),
 470                     "battery initialization failed, giving up\n");
 471     } else {
 472         ACPI_VPRINT(dev, acpi_device_get_parent_softc(dev),
 473                     "battery initialization done, tried %d times\n", retry + 1);
 474     }
 475 }