The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/dev/acpica/acpi_smbat.c

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

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

Cache object: facaaa56729aead3a214364b47df66bf


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.