sys/dev/acpica/acpi_battery.c

   1 /*-
   2  * Copyright (c) 2000 Mitsuru IWASAKI <iwasaki@jp.freebsd.org>
   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$
  27  */
  28
  29 #include "opt_acpi.h"           /* XXX trim includes */
  30 #include <sys/param.h>
  31 #include <sys/kernel.h>
  32 #include <sys/proc.h>
  33 #include <sys/lock.h>
  34 #include <sys/malloc.h>
  35 #include <sys/mutex.h>
  36 #include <sys/bus.h>
  37 #include <sys/conf.h>
  38 #include <sys/ioccom.h>
  39 #include <sys/reboot.h>
  40 #include <sys/sysctl.h>
  41 #include <sys/ctype.h>
  42
  43 #include <machine/clock.h>
  44
  45 #include <machine/resource.h>
  46
  47 #include "acpi.h"
  48
  49 #include <dev/acpica/acpivar.h>
  50 #include <dev/acpica/acpiio.h>
  51
  52 MALLOC_DEFINE(M_ACPIBATT, "acpibatt", "ACPI generic battery data");
  53
  54 /*
  55  * ACPI Battery Abstruction Layer.
  56  */
  57
  58 struct acpi_batteries {
  59         TAILQ_ENTRY(acpi_batteries) link;
  60         struct   acpi_battdesc battdesc;
  61 };
  62
  63 static TAILQ_HEAD(,acpi_batteries) acpi_batteries;
  64 static int                      acpi_batteries_initted = 0;
  65 static int                      acpi_batteries_units = 0;
  66 static int                      acpi_battery_info_expire = 5;
  67 static struct acpi_battinfo     acpi_battery_battinfo;
  68
  69 int
  70 acpi_battery_get_units(void)
  71 {
  72
  73         return (acpi_batteries_units);
  74 }
  75
  76 int
  77 acpi_battery_get_battdesc(int logical_unit, struct acpi_battdesc *battdesc)
  78 {
  79         int      i;
  80         struct acpi_batteries   *bp;
  81
  82         if (logical_unit < 0 || logical_unit >= acpi_batteries_units) {
  83                 return (ENXIO);
  84         }
  85
  86         i = 0;
  87         TAILQ_FOREACH(bp, &acpi_batteries, link) {
  88                 if (logical_unit == i) {
  89                         battdesc->type = bp->battdesc.type;
  90                         battdesc->phys_unit = bp->battdesc.phys_unit;
  91                         return (0);
  92                 }
  93                 i++;
  94         }
  95
  96         return (ENXIO);
  97 }
  98
  99 int
 100 acpi_battery_get_battinfo(int unit, struct acpi_battinfo *battinfo)
 101 {
 102         int      error;
 103         struct   acpi_battdesc battdesc;
 104
 105         error = 0;
 106         if (unit == -1) {
 107                 error = acpi_cmbat_get_battinfo(-1, battinfo);
 108                 goto out;
 109         } else {
 110                 if ((error = acpi_battery_get_battdesc(unit, &battdesc)) != 0) {
 111                         goto out;
 112                 }
 113                 switch (battdesc.type) {
 114                 case ACPI_BATT_TYPE_CMBAT:
 115                         error = acpi_cmbat_get_battinfo(battdesc.phys_unit,
 116                            battinfo);
 117                         break;
 118                 default:
 119                         error = ENXIO;
 120                         break;
 121                 }
 122         }
 123 out:
 124         return (error);
 125 }
 126
 127 int
 128 acpi_battery_get_info_expire(void)
 129 {
 130
 131         return (acpi_battery_info_expire);
 132 }
 133
 134 static int
 135 acpi_battery_ioctl(u_long cmd, caddr_t addr, void *arg)
 136 {
 137         int      error;
 138         int      logical_unit;
 139         union acpi_battery_ioctl_arg    *ioctl_arg;
 140
 141         ioctl_arg = (union acpi_battery_ioctl_arg *)addr;
 142         error = 0;
 143         switch (cmd) {
 144         case ACPIIO_BATT_GET_UNITS:
 145                 *(int *)addr = acpi_battery_get_units();
 146                 break;
 147
 148         case ACPIIO_BATT_GET_BATTDESC:
 149                 logical_unit = ioctl_arg->unit;
 150                 error = acpi_battery_get_battdesc(logical_unit, &ioctl_arg->battdesc);
 151                 break;
 152
 153         case ACPIIO_BATT_GET_BATTINFO:
 154                 logical_unit = ioctl_arg->unit;
 155                 error = acpi_battery_get_battinfo(logical_unit,
 156                     &ioctl_arg->battinfo);
 157                 break;
 158
 159         default:
 160                 error = EINVAL;
 161                 break;
 162         }
 163
 164         return (error);
 165 }
 166
 167 static int
 168 acpi_battery_sysctl(SYSCTL_HANDLER_ARGS)
 169 {
 170         int     val;
 171         int     error;
 172
 173         acpi_battery_get_battinfo(-1, &acpi_battery_battinfo);
 174         val = *(u_int *)oidp->oid_arg1;
 175         error = sysctl_handle_int(oidp, &val, 0, req);
 176         return (error);
 177 }
 178
 179 static int
 180 acpi_battery_init(void)
 181 {
 182         device_t                 dev;
 183         struct acpi_softc       *sc;
 184         int                      error;
 185
 186         if ((dev = devclass_get_device(devclass_find("acpi"), 0)) == NULL) {
 187                 return (ENXIO);
 188         }
 189         if ((sc = device_get_softc(dev)) == NULL) {
 190                 return (ENXIO);
 191         }
 192
 193         error = 0;
 194
 195         TAILQ_INIT(&acpi_batteries);
 196         acpi_batteries_initted = 1;
 197
 198         if ((error = acpi_register_ioctl(ACPIIO_BATT_GET_UNITS,
 199                         acpi_battery_ioctl, NULL)) != 0) {
 200                 return (error);
 201         }
 202         if ((error = acpi_register_ioctl(ACPIIO_BATT_GET_BATTDESC,
 203                         acpi_battery_ioctl, NULL)) != 0) {
 204                 return (error);
 205         }
 206         if ((error = acpi_register_ioctl(ACPIIO_BATT_GET_BATTINFO,
 207                         acpi_battery_ioctl, NULL)) != 0) {
 208                 return (error);
 209         }
 210
 211         sysctl_ctx_init(&sc->acpi_battery_sysctl_ctx);
 212         sc->acpi_battery_sysctl_tree = SYSCTL_ADD_NODE(&sc->acpi_battery_sysctl_ctx,
 213                                 SYSCTL_CHILDREN(sc->acpi_sysctl_tree),
 214                                 OID_AUTO, "battery", CTLFLAG_RD, 0, "");
 215         SYSCTL_ADD_PROC(&sc->acpi_battery_sysctl_ctx,
 216                 SYSCTL_CHILDREN(sc->acpi_battery_sysctl_tree),
 217                 OID_AUTO, "life", CTLTYPE_INT | CTLFLAG_RD,
 218                 &acpi_battery_battinfo.cap, 0, acpi_battery_sysctl, "I", "");
 219         SYSCTL_ADD_PROC(&sc->acpi_battery_sysctl_ctx,
 220                 SYSCTL_CHILDREN(sc->acpi_battery_sysctl_tree),
 221                 OID_AUTO, "time", CTLTYPE_INT | CTLFLAG_RD,
 222                 &acpi_battery_battinfo.min, 0, acpi_battery_sysctl, "I", "");
 223         SYSCTL_ADD_PROC(&sc->acpi_battery_sysctl_ctx,
 224                 SYSCTL_CHILDREN(sc->acpi_battery_sysctl_tree),
 225                 OID_AUTO, "state", CTLTYPE_INT | CTLFLAG_RD,
 226                 &acpi_battery_battinfo.state, 0, acpi_battery_sysctl, "I", "");
 227         SYSCTL_ADD_INT(&sc->acpi_battery_sysctl_ctx,
 228                 SYSCTL_CHILDREN(sc->acpi_battery_sysctl_tree),
 229                 OID_AUTO, "units", CTLFLAG_RD, &acpi_batteries_units, 0, "");
 230         SYSCTL_ADD_INT(&sc->acpi_battery_sysctl_ctx,
 231                 SYSCTL_CHILDREN(sc->acpi_battery_sysctl_tree),
 232                 OID_AUTO, "info_expire", CTLFLAG_RD | CTLFLAG_RW,
 233                 &acpi_battery_info_expire, 0, "");
 234
 235         return (error);
 236 }
 237
 238 int
 239 acpi_battery_register(int type, int phys_unit)
 240 {
 241         int     error;
 242         struct acpi_batteries   *bp;
 243
 244         error = 0;
 245         if ((bp = malloc(sizeof(*bp), M_ACPIBATT, M_NOWAIT)) == NULL) {
 246                 return(ENOMEM);
 247         }
 248
 249         bp->battdesc.type = type;
 250         bp->battdesc.phys_unit = phys_unit;
 251         if (acpi_batteries_initted == 0) {
 252                 if ((error = acpi_battery_init()) != 0) {
 253                         free(bp, M_ACPIBATT);
 254                         return(error);
 255                 }
 256         }
 257
 258         TAILQ_INSERT_TAIL(&acpi_batteries, bp, link);
 259         acpi_batteries_units++;
 260
 261         return(0);
 262 }