sys/dev/acpica/acpi_smbat.c

   1 /*-
   2  * Copyright (c) 2005 Hans Petter Selasky
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  * $FreeBSD: src/sys/dev/acpica/acpi_smbat.c,v 1.11 2011/11/07 15:43:11 ed Exp $
  27  */
  28
  29 #include "opt_acpi.h"
  30 #include <sys/param.h>
  31 #include <sys/kernel.h>
  32 #include <sys/module.h>
  33 #include <sys/bus.h>
  34
  35 #include "acpi.h"
  36 #include <acpivar.h>
  37 #include <acpiio.h>
  38 #include <acpi_smbus.h>
  39
  40 /* Transactions have failed after 500 ms. */
  41 #define SMBUS_TIMEOUT   50
  42
  43 struct acpi_smbat_softc {
  44         uint8_t         sb_base_addr;
  45         device_t        ec_dev;
  46
  47         struct acpi_bif bif;
  48         struct acpi_bst bst;
  49         struct timespec bif_lastupdated;
  50         struct timespec bst_lastupdated;
  51 };
  52
  53 static int      acpi_smbat_probe(device_t dev);
  54 static int      acpi_smbat_attach(device_t dev);
  55 static int      acpi_smbat_shutdown(device_t dev);
  56 static int      acpi_smbat_info_expired(struct timespec *lastupdated);
  57 static void     acpi_smbat_info_updated(struct timespec *lastupdated);
  58 static int      acpi_smbat_get_bif(device_t dev, struct acpi_bif *bif);
  59 static int      acpi_smbat_get_bst(device_t dev, struct acpi_bst *bst);
  60
  61 ACPI_SERIAL_DECL(smbat, "ACPI Smart Battery");
  62
  63 static SYSCTL_NODE(_debug_acpi, OID_AUTO, batt, CTLFLAG_RD, NULL,
  64     "Battery debugging");
  65
  66 /* On some laptops with smart batteries, enabling battery monitoring
  67  * software causes keystrokes from atkbd to be lost.  This has also been
  68  * reported on Linux, and is apparently due to the keyboard and I2C line
  69  * for the battery being routed through the same chip.  Whether that's
  70  * accurate or not, adding extra sleeps to the status checking code
  71  * causes the problem to go away.
  72  *
  73  * If you experience that problem, try a value of 10ms and move up
  74  * from there.
  75  */
  76 static int      batt_sleep_ms;
  77 SYSCTL_INT(_debug_acpi_batt, OID_AUTO, batt_sleep_ms, CTLFLAG_RW, &batt_sleep_ms, 0,
  78     "Sleep during battery status updates to prevent keystroke loss.");
  79
  80 static device_method_t acpi_smbat_methods[] = {
  81         /* device interface */
  82         DEVMETHOD(device_probe, acpi_smbat_probe),
  83         DEVMETHOD(device_attach, acpi_smbat_attach),
  84         DEVMETHOD(device_shutdown, acpi_smbat_shutdown),
  85
  86         /* ACPI battery interface */
  87         DEVMETHOD(acpi_batt_get_status, acpi_smbat_get_bst),
  88         DEVMETHOD(acpi_batt_get_info, acpi_smbat_get_bif),
  89
  90         DEVMETHOD_END
  91 };
  92
  93 static driver_t acpi_smbat_driver = {
  94         "battery",
  95         acpi_smbat_methods,
  96         sizeof(struct acpi_smbat_softc),
  97 };
  98
  99 static devclass_t acpi_smbat_devclass;
 100 DRIVER_MODULE(acpi_smbat, acpi, acpi_smbat_driver, acpi_smbat_devclass,
 101     NULL, NULL);
 102 MODULE_DEPEND(acpi_smbat, acpi, 1, 1, 1);
 103
 104 static int
 105 acpi_smbat_probe(device_t dev)
 106 {
 107         static char *smbat_ids[] = {"ACPI0001", "ACPI0005", NULL};
 108         ACPI_STATUS status;
 109
 110         if (acpi_disabled("smbat") ||
 111             ACPI_ID_PROBE(device_get_parent(dev), dev, smbat_ids) == NULL)
 112                 return (ENXIO);
 113         status = AcpiEvaluateObject(acpi_get_handle(dev), "_EC", NULL, NULL);
 114         if (ACPI_FAILURE(status))
 115                 return (ENXIO);
 116
 117         device_set_desc(dev, "ACPI Smart Battery");
 118         return (0);
 119 }
 120
 121 static int
 122 acpi_smbat_attach(device_t dev)
 123 {
 124         struct acpi_smbat_softc *sc;
 125         uint32_t base;
 126
 127         sc = device_get_softc(dev);
 128         ACPI_SERIAL_INIT(smbat);
 129         if (ACPI_FAILURE(acpi_GetInteger(acpi_get_handle(dev), "_EC", &base))) {
 130                 device_printf(dev, "cannot get EC base address\n");
 131                 return (ENXIO);
 132         }
 133         sc->sb_base_addr = (base >> 8) & 0xff;
 134
 135         /* XXX Only works with one EC, but nearly all systems only have one. */
 136         sc->ec_dev = devclass_get_device(devclass_find("acpi_ec"), 0);
 137         if (sc->ec_dev == NULL) {
 138                 device_printf(dev, "cannot find EC device\n");
 139                 return (ENXIO);
 140         }
 141
 142         timespecclear(&sc->bif_lastupdated);
 143         timespecclear(&sc->bst_lastupdated);
 144
 145         if (acpi_battery_register(dev) != 0) {
 146                 device_printf(dev, "cannot register battery\n");
 147                 return (ENXIO);
 148         }
 149         return (0);
 150 }
 151
 152 static int
 153 acpi_smbat_shutdown(device_t dev)
 154 {
 155
 156         acpi_battery_remove(dev);
 157         return (0);
 158 }
 159
 160 static int
 161 acpi_smbat_info_expired(struct timespec *lastupdated)
 162 {
 163         struct timespec curtime;
 164
 165         ACPI_SERIAL_ASSERT(smbat);
 166
 167         if (lastupdated == NULL)
 168                 return (TRUE);
 169         if (!timespecisset(lastupdated))
 170                 return (TRUE);
 171
 172         getnanotime(&curtime);
 173         timespecsub(&curtime, lastupdated);
 174         return (curtime.tv_sec < 0 ||
 175             curtime.tv_sec > acpi_battery_get_info_expire());
 176 }
 177
 178 static void
 179 acpi_smbat_info_updated(struct timespec *lastupdated)
 180 {
 181
 182         ACPI_SERIAL_ASSERT(smbat);
 183
 184         if (lastupdated != NULL)
 185                 getnanotime(lastupdated);
 186 }
 187
 188 static int
 189 acpi_smbus_read_2(struct acpi_smbat_softc *sc, uint8_t addr, uint8_t cmd,
 190     uint16_t *ptr)
 191 {
 192         int error, to;
 193         UINT64 val;
 194
 195         ACPI_SERIAL_ASSERT(smbat);
 196
 197         if (batt_sleep_ms)
 198             AcpiOsSleep(batt_sleep_ms);
 199
 200         val = addr;
 201         error = ACPI_EC_WRITE(sc->ec_dev, sc->sb_base_addr + SMBUS_ADDR,
 202             val, 1);
 203         if (error)
 204                 goto out;
 205
 206         val = cmd;
 207         error = ACPI_EC_WRITE(sc->ec_dev, sc->sb_base_addr + SMBUS_CMD,
 208             val, 1);
 209         if (error)
 210                 goto out;
 211
 212         val = 0x09; /* | 0x80 if PEC */
 213         error = ACPI_EC_WRITE(sc->ec_dev, sc->sb_base_addr + SMBUS_PRTCL,
 214             val, 1);
 215         if (error)
 216                 goto out;
 217
 218         if (batt_sleep_ms)
 219             AcpiOsSleep(batt_sleep_ms);
 220
 221         for (to = SMBUS_TIMEOUT; to != 0; to--) {
 222                 error = ACPI_EC_READ(sc->ec_dev, sc->sb_base_addr + SMBUS_PRTCL,
 223                     &val, 1);
 224                 if (error)
 225                         goto out;
 226                 if (val == 0)
 227                         break;
 228                 AcpiOsSleep(10);
 229         }
 230         if (to == 0) {
 231                 error = ETIMEDOUT;
 232                 goto out;
 233         }
 234
 235         error = ACPI_EC_READ(sc->ec_dev, sc->sb_base_addr + SMBUS_STS, &val, 1);
 236         if (error)
 237                 goto out;
 238         if (val & SMBUS_STS_MASK) {
 239                 kprintf("%s: AE_ERROR 0x%x\n",
 240                        __func__, (int)(val & SMBUS_STS_MASK));
 241                 error = EIO;
 242                 goto out;
 243         }
 244
 245         error = ACPI_EC_READ(sc->ec_dev, sc->sb_base_addr + SMBUS_DATA,
 246             &val, 2);
 247         if (error)
 248                 goto out;
 249
 250         *ptr = val;
 251
 252 out:
 253         return (error);
 254 }
 255
 256 static int
 257 acpi_smbus_read_multi_1(struct acpi_smbat_softc *sc, uint8_t addr, uint8_t cmd,
 258     uint8_t *ptr, uint16_t len)
 259 {
 260         UINT64 val;
 261         uint8_t to;
 262         int error;
 263
 264         ACPI_SERIAL_ASSERT(smbat);
 265
 266         if (batt_sleep_ms)
 267             AcpiOsSleep(batt_sleep_ms);
 268
 269         val = addr;
 270         error = ACPI_EC_WRITE(sc->ec_dev, sc->sb_base_addr + SMBUS_ADDR,
 271             val, 1);
 272         if (error)
 273                 goto out;
 274
 275         val = cmd;
 276         error = ACPI_EC_WRITE(sc->ec_dev, sc->sb_base_addr + SMBUS_CMD,
 277             val, 1);
 278         if (error)
 279                 goto out;
 280
 281         val = 0x0B /* | 0x80 if PEC */ ;
 282         error = ACPI_EC_WRITE(sc->ec_dev, sc->sb_base_addr + SMBUS_PRTCL,
 283             val, 1);
 284         if (error)
 285                 goto out;
 286
 287         if (batt_sleep_ms)
 288             AcpiOsSleep(batt_sleep_ms);
 289
 290         for (to = SMBUS_TIMEOUT; to != 0; to--) {
 291                 error = ACPI_EC_READ(sc->ec_dev, sc->sb_base_addr + SMBUS_PRTCL,
 292                     &val, 1);
 293                 if (error)
 294                         goto out;
 295                 if (val == 0)
 296                         break;
 297                 AcpiOsSleep(10);
 298         }
 299         if (to == 0) {
 300                 error = ETIMEDOUT;
 301                 goto out;
 302         }
 303
 304         error = ACPI_EC_READ(sc->ec_dev, sc->sb_base_addr + SMBUS_STS, &val, 1);
 305         if (error)
 306                 goto out;
 307         if (val & SMBUS_STS_MASK) {
 308                 kprintf("%s: AE_ERROR 0x%x\n",
 309                        __func__, (int)(val & SMBUS_STS_MASK));
 310                 error = EIO;
 311                 goto out;
 312         }
 313
 314         /* get length */
 315         error = ACPI_EC_READ(sc->ec_dev, sc->sb_base_addr + SMBUS_BCNT,
 316             &val, 1);
 317         if (error)
 318                 goto out;
 319         val = (val & 0x1f) + 1;
 320
 321         bzero(ptr, len);
 322         if (len > val)
 323                 len = val;
 324
 325         if (batt_sleep_ms)
 326             AcpiOsSleep(batt_sleep_ms);
 327
 328         while (len--) {
 329                 error = ACPI_EC_READ(sc->ec_dev, sc->sb_base_addr + SMBUS_DATA
 330                     + len, &val, 1);
 331                 if (error)
 332                         goto out;
 333
 334                 ptr[len] = val;
 335                 if (batt_sleep_ms)
 336                     AcpiOsSleep(batt_sleep_ms);
 337         }
 338
 339 out:
 340         return (error);
 341 }
 342
 343 static int
 344 acpi_smbat_get_bst(device_t dev, struct acpi_bst *bst)
 345 {
 346         struct acpi_smbat_softc *sc;
 347         int error;
 348         uint32_t factor;
 349         int16_t val;
 350         uint8_t addr;
 351
 352         ACPI_SERIAL_BEGIN(smbat);
 353
 354         addr = SMBATT_ADDRESS;
 355         error = ENXIO;
 356         sc = device_get_softc(dev);
 357
 358         if (!acpi_smbat_info_expired(&sc->bst_lastupdated)) {
 359                 error = 0;
 360                 goto out;
 361         }
 362
 363         if (acpi_smbus_read_2(sc, addr, SMBATT_CMD_BATTERY_MODE, &val))
 364                 goto out;
 365         if (val & SMBATT_BM_CAPACITY_MODE)
 366                 factor = 10;
 367         else
 368                 factor = 1;
 369
 370         /* get battery status */
 371         if (acpi_smbus_read_2(sc, addr, SMBATT_CMD_BATTERY_STATUS, &val))
 372                 goto out;
 373
 374         sc->bst.state = 0;
 375         if (val & SMBATT_BS_DISCHARGING)
 376                 sc->bst.state |= ACPI_BATT_STAT_DISCHARG;
 377
 378         if (val & SMBATT_BS_REMAINING_CAPACITY_ALARM)
 379                 sc->bst.state |= ACPI_BATT_STAT_CRITICAL;
 380
 381         /*
 382          * If the rate is negative, it is discharging.  Otherwise,
 383          * it is charging.
 384          */
 385         if (acpi_smbus_read_2(sc, addr, SMBATT_CMD_CURRENT, &val))
 386                 goto out;
 387
 388         if (val > 0) {
 389                 sc->bst.rate = val * factor;
 390                 sc->bst.state &= ~SMBATT_BS_DISCHARGING;
 391                 sc->bst.state |= ACPI_BATT_STAT_CHARGING;
 392         } else if (val < 0)
 393                 sc->bst.rate = (-val) * factor;
 394         else
 395                 sc->bst.rate = 0;
 396
 397         if (acpi_smbus_read_2(sc, addr, SMBATT_CMD_REMAINING_CAPACITY, &val))
 398                 goto out;
 399         sc->bst.cap = val * factor;
 400
 401         if (acpi_smbus_read_2(sc, addr, SMBATT_CMD_VOLTAGE, &val))
 402                 goto out;
 403         sc->bst.volt = val;
 404
 405         acpi_smbat_info_updated(&sc->bst_lastupdated);
 406         error = 0;
 407
 408 out:
 409         if (error == 0)
 410                 memcpy(bst, &sc->bst, sizeof(sc->bst));
 411         ACPI_SERIAL_END(smbat);
 412         return (error);
 413 }
 414
 415 static int
 416 acpi_smbat_get_bif(device_t dev, struct acpi_bif *bif)
 417 {
 418         struct acpi_smbat_softc *sc;
 419         int error;
 420         uint32_t factor;
 421         uint16_t val;
 422         uint8_t addr;
 423
 424         ACPI_SERIAL_BEGIN(smbat);
 425
 426         addr = SMBATT_ADDRESS;
 427         error = ENXIO;
 428         sc = device_get_softc(dev);
 429
 430         if (!acpi_smbat_info_expired(&sc->bif_lastupdated)) {
 431                 error = 0;
 432                 goto out;
 433         }
 434
 435         if (acpi_smbus_read_2(sc, addr, SMBATT_CMD_BATTERY_MODE, &val))
 436                 goto out;
 437         if (val & SMBATT_BM_CAPACITY_MODE) {
 438                 factor = 10;
 439                 sc->bif.units = ACPI_BIF_UNITS_MW;
 440         } else {
 441                 factor = 1;
 442                 sc->bif.units = ACPI_BIF_UNITS_MA;
 443         }
 444
 445         if (acpi_smbus_read_2(sc, addr, SMBATT_CMD_DESIGN_CAPACITY, &val))
 446                 goto out;
 447         sc->bif.dcap = val * factor;
 448
 449         if (acpi_smbus_read_2(sc, addr, SMBATT_CMD_FULL_CHARGE_CAPACITY, &val))
 450                 goto out;
 451         sc->bif.lfcap = val * factor;
 452         sc->bif.btech = 1;              /* secondary (rechargeable) */
 453
 454         if (acpi_smbus_read_2(sc, addr, SMBATT_CMD_DESIGN_VOLTAGE, &val))
 455                 goto out;
 456         sc->bif.dvol = val;
 457
 458         sc->bif.wcap = sc->bif.dcap / 10;
 459         sc->bif.lcap = sc->bif.dcap / 10;
 460
 461         sc->bif.gra1 = factor;  /* not supported */
 462         sc->bif.gra2 = factor;  /* not supported */
 463
 464         if (acpi_smbus_read_multi_1(sc, addr, SMBATT_CMD_DEVICE_NAME,
 465             sc->bif.model, sizeof(sc->bif.model)))
 466                 goto out;
 467
 468         if (acpi_smbus_read_2(sc, addr, SMBATT_CMD_SERIAL_NUMBER, &val))
 469                 goto out;
 470         ksnprintf(sc->bif.serial, sizeof(sc->bif.serial), "0x%04x", val);
 471
 472         if (acpi_smbus_read_multi_1(sc, addr, SMBATT_CMD_DEVICE_CHEMISTRY,
 473             sc->bif.type, sizeof(sc->bif.type)))
 474                 goto out;
 475
 476         if (acpi_smbus_read_multi_1(sc, addr, SMBATT_CMD_MANUFACTURER_DATA,
 477             sc->bif.oeminfo, sizeof(sc->bif.oeminfo)))
 478                 goto out;
 479
 480         /* XXX check if device was replugged during read? */
 481
 482         acpi_smbat_info_updated(&sc->bif_lastupdated);
 483         error = 0;
 484
 485 out:
 486         if (error == 0)
 487                 memcpy(bif, &sc->bif, sizeof(sc->bif));
 488         ACPI_SERIAL_END(smbat);
 489         return (error);
 490 }