mirror of
https://git.FreeBSD.org/src.git
synced 2024-12-15 10:17:20 +00:00
Add sysctl interface (Read-only) for temprature, AC-line and Battery.
Patches for acpi_cmbat.c submitted by Munehiro Matsuda.
This commit is contained in:
parent
aafccd6d93
commit
4eb77744b5
Notes:
svn2git
2020-12-20 02:59:44 +00:00
svn path=/head/; revision=78662
@ -1461,3 +1461,202 @@ acpi_set_debugging(void *junk)
|
||||
}
|
||||
SYSINIT(acpi_debugging, SI_SUB_TUNABLES, SI_ORDER_ANY, acpi_set_debugging, NULL);
|
||||
#endif
|
||||
|
||||
/*
|
||||
* ACPI Battery Abstruction Layer
|
||||
*/
|
||||
|
||||
struct acpi_batteries {
|
||||
TAILQ_ENTRY(acpi_batteries) link;
|
||||
struct acpi_battdesc battdesc;
|
||||
};
|
||||
|
||||
static TAILQ_HEAD(,acpi_batteries) acpi_batteries;
|
||||
static int acpi_batteries_initted = 0;
|
||||
static int acpi_batteries_units = 0;
|
||||
static struct acpi_battinfo acpi_battery_battinfo;
|
||||
|
||||
static int
|
||||
acpi_battery_get_units(void)
|
||||
{
|
||||
|
||||
return (acpi_batteries_units);
|
||||
}
|
||||
|
||||
static int
|
||||
acpi_battery_get_battdesc(int logical_unit, struct acpi_battdesc *battdesc)
|
||||
{
|
||||
int i;
|
||||
struct acpi_batteries *bp;
|
||||
|
||||
if (logical_unit < 0 || logical_unit >= acpi_batteries_units) {
|
||||
return (ENXIO);
|
||||
}
|
||||
|
||||
i = 0;
|
||||
TAILQ_FOREACH(bp, &acpi_batteries, link) {
|
||||
if (logical_unit == i) {
|
||||
battdesc->type = bp->battdesc.type;
|
||||
battdesc->phys_unit = bp->battdesc.phys_unit;
|
||||
return (0);
|
||||
}
|
||||
i++;
|
||||
}
|
||||
|
||||
return (ENXIO);
|
||||
}
|
||||
|
||||
static int
|
||||
acpi_battery_get_battinfo(int unit, struct acpi_battinfo *battinfo)
|
||||
{
|
||||
int error;
|
||||
struct acpi_battdesc battdesc;
|
||||
|
||||
error = 0;
|
||||
if (unit == -1) {
|
||||
error = acpi_cmbat_get_battinfo(-1, battinfo);
|
||||
goto out;
|
||||
} else {
|
||||
if ((error = acpi_battery_get_battdesc(unit, &battdesc)) != 0) {
|
||||
goto out;
|
||||
}
|
||||
switch (battdesc.type) {
|
||||
case ACPI_BATT_TYPE_CMBAT:
|
||||
error = acpi_cmbat_get_battinfo(battdesc.phys_unit,
|
||||
battinfo);
|
||||
break;
|
||||
default:
|
||||
error = ENXIO;
|
||||
break;
|
||||
}
|
||||
}
|
||||
out:
|
||||
return (error);
|
||||
}
|
||||
|
||||
static int
|
||||
acpi_battery_ioctl(u_long cmd, caddr_t addr, void *arg)
|
||||
{
|
||||
int error;
|
||||
int logical_unit;
|
||||
union acpi_battery_ioctl_arg *ioctl_arg;
|
||||
|
||||
ioctl_arg = (union acpi_battery_ioctl_arg *)addr;
|
||||
error = 0;
|
||||
switch (cmd) {
|
||||
case ACPIIO_BATT_GET_UNITS:
|
||||
*(int *)addr = acpi_battery_get_units();
|
||||
break;
|
||||
|
||||
case ACPIIO_BATT_GET_BATTDESC:
|
||||
logical_unit = ioctl_arg->unit;
|
||||
error = acpi_battery_get_battdesc(logical_unit, &ioctl_arg->battdesc);
|
||||
break;
|
||||
|
||||
case ACPIIO_BATT_GET_BATTINFO:
|
||||
logical_unit = ioctl_arg->unit;
|
||||
error = acpi_battery_get_battinfo(logical_unit,
|
||||
&ioctl_arg->battinfo);
|
||||
break;
|
||||
|
||||
default:
|
||||
error = EINVAL;
|
||||
break;
|
||||
}
|
||||
|
||||
return (error);
|
||||
}
|
||||
|
||||
static int
|
||||
acpi_battery_sysctl(SYSCTL_HANDLER_ARGS)
|
||||
{
|
||||
int val;
|
||||
int error;
|
||||
|
||||
acpi_battery_get_battinfo(-1, &acpi_battery_battinfo);
|
||||
val = *(u_int *)oidp->oid_arg1;
|
||||
error = sysctl_handle_int(oidp, &val, 0, req);
|
||||
return (error);
|
||||
}
|
||||
|
||||
static int
|
||||
acpi_battery_init(void)
|
||||
{
|
||||
device_t dev;
|
||||
struct acpi_softc *sc;
|
||||
int error;
|
||||
|
||||
if ((dev = devclass_get_device(acpi_devclass, 0)) == NULL) {
|
||||
return (ENXIO);
|
||||
}
|
||||
if ((sc = device_get_softc(dev)) == NULL) {
|
||||
return (ENXIO);
|
||||
}
|
||||
|
||||
error = 0;
|
||||
|
||||
TAILQ_INIT(&acpi_batteries);
|
||||
acpi_batteries_initted = 1;
|
||||
|
||||
if ((error = acpi_register_ioctl(ACPIIO_BATT_GET_UNITS,
|
||||
acpi_battery_ioctl, NULL)) != 0) {
|
||||
return (error);
|
||||
}
|
||||
if ((error = acpi_register_ioctl(ACPIIO_BATT_GET_BATTDESC,
|
||||
acpi_battery_ioctl, NULL)) != 0) {
|
||||
return (error);
|
||||
}
|
||||
if ((error = acpi_register_ioctl(ACPIIO_BATT_GET_BATTINFO,
|
||||
acpi_battery_ioctl, NULL)) != 0) {
|
||||
return (error);
|
||||
}
|
||||
|
||||
sysctl_ctx_init(&sc->acpi_battery_sysctl_ctx);
|
||||
sc->acpi_battery_sysctl_tree = SYSCTL_ADD_NODE(&sc->acpi_battery_sysctl_ctx,
|
||||
SYSCTL_CHILDREN(sc->acpi_sysctl_tree),
|
||||
OID_AUTO, "battery", CTLFLAG_RD, 0, "");
|
||||
SYSCTL_ADD_PROC(&sc->acpi_battery_sysctl_ctx,
|
||||
SYSCTL_CHILDREN(sc->acpi_battery_sysctl_tree),
|
||||
OID_AUTO, "life", CTLTYPE_INT | CTLFLAG_RD,
|
||||
&acpi_battery_battinfo.cap, 0, acpi_battery_sysctl, "I", "");
|
||||
SYSCTL_ADD_PROC(&sc->acpi_battery_sysctl_ctx,
|
||||
SYSCTL_CHILDREN(sc->acpi_battery_sysctl_tree),
|
||||
OID_AUTO, "time", CTLTYPE_INT | CTLFLAG_RD,
|
||||
&acpi_battery_battinfo.min, 0, acpi_battery_sysctl, "I", "");
|
||||
SYSCTL_ADD_PROC(&sc->acpi_battery_sysctl_ctx,
|
||||
SYSCTL_CHILDREN(sc->acpi_battery_sysctl_tree),
|
||||
OID_AUTO, "state", CTLTYPE_INT | CTLFLAG_RD,
|
||||
&acpi_battery_battinfo.state, 0, acpi_battery_sysctl, "I", "");
|
||||
SYSCTL_ADD_INT(&sc->acpi_battery_sysctl_ctx,
|
||||
SYSCTL_CHILDREN(sc->acpi_battery_sysctl_tree),
|
||||
OID_AUTO, "units", CTLFLAG_RD, &acpi_batteries_units, 0, "");
|
||||
|
||||
return (error);
|
||||
}
|
||||
|
||||
int
|
||||
acpi_battery_register(int type, int phys_unit)
|
||||
{
|
||||
int error;
|
||||
struct acpi_batteries *bp;
|
||||
|
||||
error = 0;
|
||||
if ((bp = malloc(sizeof(*bp), M_ACPIDEV, M_NOWAIT)) == NULL) {
|
||||
return(ENOMEM);
|
||||
}
|
||||
|
||||
bp->battdesc.type = type;
|
||||
bp->battdesc.phys_unit = phys_unit;
|
||||
if (acpi_batteries_initted == 0) {
|
||||
if ((error = acpi_battery_init()) != 0) {
|
||||
free(bp, M_ACPIDEV);
|
||||
return(error);
|
||||
}
|
||||
}
|
||||
|
||||
TAILQ_INSERT_TAIL(&acpi_batteries, bp, link);
|
||||
acpi_batteries_units++;
|
||||
|
||||
return(0);
|
||||
}
|
||||
|
||||
|
@ -57,6 +57,7 @@ static void acpi_acad_notify_handler(ACPI_HANDLE , UINT32 ,void *);
|
||||
static int acpi_acad_probe(device_t);
|
||||
static int acpi_acad_attach(device_t);
|
||||
static int acpi_acad_ioctl(u_long, caddr_t, void *);
|
||||
static int acpi_acad_sysctl(SYSCTL_HANDLER_ARGS);
|
||||
|
||||
struct acpi_acad_softc {
|
||||
int status;
|
||||
@ -69,9 +70,14 @@ acpi_acad_get_status(void *context)
|
||||
struct acpi_acad_softc *sc = device_get_softc(dev);
|
||||
ACPI_HANDLE h = acpi_get_handle(dev);
|
||||
|
||||
if (acpi_EvaluateInteger(h, "_PSR", &sc->status) != AE_OK)
|
||||
if (acpi_EvaluateInteger(h, "_PSR", &sc->status) != AE_OK) {
|
||||
sc->status = -1;
|
||||
return;
|
||||
}
|
||||
|
||||
if (bootverbose) {
|
||||
device_printf(dev,"%s\n",(sc->status) ? "On Line" : "Off Line");
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
@ -79,7 +85,10 @@ acpi_acad_notify_handler(ACPI_HANDLE h, UINT32 notify, void *context)
|
||||
{
|
||||
device_t dev = context;
|
||||
|
||||
if (bootverbose) {
|
||||
device_printf(dev, "Notify %d\n", notify);
|
||||
}
|
||||
|
||||
switch (notify) {
|
||||
case ACPI_DEVICE_CHECK_PNP:
|
||||
case ACPI_DEVICE_CHECK_EXISTENCE:
|
||||
@ -113,6 +122,8 @@ static int
|
||||
acpi_acad_attach(device_t dev)
|
||||
{
|
||||
int error;
|
||||
struct acpi_acad_softc *sc;
|
||||
struct acpi_softc *acpi_sc;
|
||||
|
||||
ACPI_HANDLE handle = acpi_get_handle(dev);
|
||||
AcpiInstallNotifyHandler(handle,
|
||||
@ -123,12 +134,21 @@ acpi_acad_attach(device_t dev)
|
||||
ACPI_SYSTEM_NOTIFY,
|
||||
acpi_acad_notify_handler, dev);
|
||||
|
||||
acpi_acad_get_status((void *)dev);
|
||||
|
||||
error = acpi_register_ioctl(ACPIIO_ACAD_GET_STATUS, acpi_acad_ioctl,
|
||||
device_get_softc(dev));
|
||||
if (error)
|
||||
if ((sc = device_get_softc(dev)) == NULL) {
|
||||
return (ENXIO);
|
||||
}
|
||||
if ((error = acpi_register_ioctl(ACPIIO_ACAD_GET_STATUS,
|
||||
acpi_acad_ioctl, dev)) != 0) {
|
||||
return (error);
|
||||
}
|
||||
|
||||
if (device_get_unit(dev) == 0) {
|
||||
acpi_sc = acpi_device_get_parent_softc(dev);
|
||||
SYSCTL_ADD_PROC(&acpi_sc->acpi_sysctl_ctx,
|
||||
SYSCTL_CHILDREN(acpi_sc->acpi_sysctl_tree),
|
||||
OID_AUTO, "acline", CTLTYPE_INT | CTLFLAG_RD,
|
||||
&sc->status, 0, acpi_acad_sysctl, "I", "");
|
||||
}
|
||||
|
||||
return(0);
|
||||
}
|
||||
@ -153,18 +173,41 @@ DRIVER_MODULE(acpi_acad,acpi,acpi_acad_driver,acpi_acad_devclass,0,0);
|
||||
static int
|
||||
acpi_acad_ioctl(u_long cmd, caddr_t addr, void *arg)
|
||||
{
|
||||
device_t dev;
|
||||
struct acpi_acad_softc *sc;
|
||||
|
||||
sc = (struct acpi_acad_softc *)arg;
|
||||
if (sc == NULL) {
|
||||
dev = (device_t)arg;
|
||||
if ((sc = device_get_softc(dev)) == NULL) {
|
||||
return(ENXIO);
|
||||
}
|
||||
|
||||
switch (cmd) {
|
||||
case ACPIIO_ACAD_GET_STATUS:
|
||||
acpi_acad_get_status(dev);
|
||||
*(int *)addr = sc->status;
|
||||
break;
|
||||
}
|
||||
|
||||
return(0);
|
||||
}
|
||||
|
||||
static int
|
||||
acpi_acad_sysctl(SYSCTL_HANDLER_ARGS)
|
||||
{
|
||||
int val;
|
||||
int error;
|
||||
device_t dev;
|
||||
struct acpi_acad_softc *sc;
|
||||
|
||||
if ((dev = devclass_get_device(acpi_acad_devclass, 0)) == NULL) {
|
||||
return (ENXIO);
|
||||
}
|
||||
if ((sc = device_get_softc(dev)) == NULL) {
|
||||
return (ENXIO);
|
||||
}
|
||||
acpi_acad_get_status(dev);
|
||||
val = *(u_int *)oidp->oid_arg1;
|
||||
error = sysctl_handle_int(oidp, &val, 0, req);
|
||||
return (error);
|
||||
}
|
||||
|
||||
|
@ -1,4 +1,5 @@
|
||||
/*-
|
||||
* Copyright (c) 2000 Munehiro Matsuda
|
||||
* Copyright (c) 2000 Takanori Watanabe
|
||||
* Copyright (c) 2000 Mitsuru IWASAKI <iwasaki@FreeBSD.org>
|
||||
* All rights reserved.
|
||||
@ -63,8 +64,17 @@ struct acpi_cmbat_softc {
|
||||
struct acpi_bst bst;
|
||||
ACPI_BUFFER bif_buffer;
|
||||
ACPI_BUFFER bst_buffer;
|
||||
struct timespec bif_lastupdated;
|
||||
struct timespec bst_lastupdated;
|
||||
|
||||
int not_present;
|
||||
int cap;
|
||||
int min;
|
||||
int full_charge_time;
|
||||
};
|
||||
|
||||
static struct timespec acpi_cmbat_info_lastupdated;
|
||||
|
||||
/* XXX: devclass_get_maxunit() don't give us the current allocated units... */
|
||||
static int acpi_cmbat_units = 0;
|
||||
|
||||
@ -73,8 +83,13 @@ static int acpi_cmbat_units = 0;
|
||||
|
||||
#define PKG_GETINT(res, tmp, idx, dest, label) do { \
|
||||
tmp = &res->Package.Elements[idx]; \
|
||||
if (tmp == NULL) { \
|
||||
device_printf(dev, "%s: PKG_GETINT idx = %d\n.", \
|
||||
__func__, idx); \
|
||||
goto label; \
|
||||
} \
|
||||
if (tmp->Type != ACPI_TYPE_INTEGER) \
|
||||
goto label ; \
|
||||
goto label; \
|
||||
dest = tmp->Integer.Value; \
|
||||
} while(0)
|
||||
|
||||
@ -82,6 +97,11 @@ static int acpi_cmbat_units = 0;
|
||||
size_t length; \
|
||||
length = size; \
|
||||
tmp = &res->Package.Elements[idx]; \
|
||||
if (tmp == NULL) { \
|
||||
device_printf(dev, "%s: PKG_GETSTR idx = %d\n.", \
|
||||
__func__, idx); \
|
||||
goto label; \
|
||||
} \
|
||||
bzero(dest, sizeof(dest)); \
|
||||
switch (tmp->Type) { \
|
||||
case ACPI_TYPE_STRING: \
|
||||
@ -92,7 +112,7 @@ static int acpi_cmbat_units = 0;
|
||||
break; \
|
||||
case ACPI_TYPE_BUFFER: \
|
||||
if (tmp->Buffer.Length < length) { \
|
||||
length = tmp->String.Length; \
|
||||
length = tmp->Buffer.Length; \
|
||||
} \
|
||||
strncpy(dest, tmp->Buffer.Pointer, length); \
|
||||
break; \
|
||||
@ -102,6 +122,31 @@ static int acpi_cmbat_units = 0;
|
||||
dest[sizeof(dest)-1] = '\0'; \
|
||||
} while(0)
|
||||
|
||||
#define BATTERY_INFO_EXPIRE 5
|
||||
static __inline int
|
||||
acpi_cmbat_info_expired(struct timespec *lastupdated)
|
||||
{
|
||||
struct timespec curtime;
|
||||
|
||||
if (lastupdated == NULL) {
|
||||
return (1);
|
||||
}
|
||||
|
||||
getnanotime(&curtime);
|
||||
timespecsub(&curtime, lastupdated);
|
||||
return ((curtime.tv_sec < 0 || curtime.tv_sec > BATTERY_INFO_EXPIRE));
|
||||
}
|
||||
|
||||
|
||||
static __inline void
|
||||
acpi_cmbat_info_updated(struct timespec *lastupdated)
|
||||
{
|
||||
|
||||
if (lastupdated != NULL) {
|
||||
getnanotime(lastupdated);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
acpi_cmbat_get_bst(void *context)
|
||||
{
|
||||
@ -111,6 +156,10 @@ acpi_cmbat_get_bst(void *context)
|
||||
ACPI_OBJECT *res, *tmp;
|
||||
ACPI_HANDLE h = acpi_get_handle(dev);
|
||||
|
||||
if (!acpi_cmbat_info_expired(&sc->bst_lastupdated)) {
|
||||
return;
|
||||
}
|
||||
|
||||
retry:
|
||||
if (sc->bst_buffer.Length == 0) {
|
||||
sc->bst_buffer.Pointer = NULL;
|
||||
@ -127,6 +176,7 @@ acpi_cmbat_get_bst(void *context)
|
||||
}
|
||||
}
|
||||
|
||||
bzero(sc->bst_buffer.Pointer, sc->bst_buffer.Length);
|
||||
as = AcpiEvaluateObject(h, "_BST", NULL, &sc->bst_buffer);
|
||||
|
||||
if (as == AE_BUFFER_OVERFLOW){
|
||||
@ -141,15 +191,18 @@ acpi_cmbat_get_bst(void *context)
|
||||
return;
|
||||
}
|
||||
|
||||
res = sc->bst_buffer.Pointer;
|
||||
res = (ACPI_OBJECT *)sc->bst_buffer.Pointer;
|
||||
|
||||
if ((res->Type != ACPI_TYPE_PACKAGE) && (res->Package.Count < 4))
|
||||
return ;
|
||||
if ((res->Type != ACPI_TYPE_PACKAGE) || (res->Package.Count != 4)) {
|
||||
device_printf(dev, "Battery status corrupted\n");
|
||||
return;
|
||||
}
|
||||
|
||||
PKG_GETINT(res, tmp, 0, sc->bst.state, end);
|
||||
PKG_GETINT(res, tmp, 1, sc->bst.rate, end);
|
||||
PKG_GETINT(res, tmp, 2, sc->bst.cap, end);
|
||||
PKG_GETINT(res, tmp, 3, sc->bst.volt, end);
|
||||
acpi_cmbat_info_updated(&sc->bst_lastupdated);
|
||||
end:
|
||||
}
|
||||
|
||||
@ -162,6 +215,10 @@ acpi_cmbat_get_bif(void *context)
|
||||
ACPI_HANDLE h = acpi_get_handle(dev);
|
||||
ACPI_OBJECT *res, *tmp;
|
||||
|
||||
if (!acpi_cmbat_info_expired(&sc->bif_lastupdated)) {
|
||||
return;
|
||||
}
|
||||
|
||||
retry:
|
||||
if (sc->bif_buffer.Length == 0) {
|
||||
sc->bif_buffer.Pointer = NULL;
|
||||
@ -178,6 +235,7 @@ acpi_cmbat_get_bif(void *context)
|
||||
}
|
||||
}
|
||||
|
||||
bzero(sc->bif_buffer.Pointer, sc->bif_buffer.Length);
|
||||
as = AcpiEvaluateObject(h, "_BIF", NULL, &sc->bif_buffer);
|
||||
|
||||
if (as == AE_BUFFER_OVERFLOW){
|
||||
@ -192,9 +250,12 @@ acpi_cmbat_get_bif(void *context)
|
||||
return;
|
||||
}
|
||||
|
||||
res = sc->bif_buffer.Pointer;
|
||||
if ((res->Type != ACPI_TYPE_PACKAGE) && (res->Package.Count < 13))
|
||||
return ;
|
||||
res = (ACPI_OBJECT *)sc->bif_buffer.Pointer;
|
||||
|
||||
if ((res->Type != ACPI_TYPE_PACKAGE) || (res->Package.Count != 13)) {
|
||||
device_printf(dev, "Battery info corrupted\n");
|
||||
return;
|
||||
}
|
||||
|
||||
PKG_GETINT(res, tmp, 0, sc->bif.unit, end);
|
||||
PKG_GETINT(res, tmp, 1, sc->bif.dcap, end);
|
||||
@ -209,12 +270,14 @@ acpi_cmbat_get_bif(void *context)
|
||||
PKG_GETSTR(res, tmp, 10, sc->bif.serial, ACPI_CMBAT_MAXSTRLEN, end);
|
||||
PKG_GETSTR(res, tmp, 11, sc->bif.type, ACPI_CMBAT_MAXSTRLEN, end);
|
||||
PKG_GETSTR(res, tmp, 12, sc->bif.oeminfo, ACPI_CMBAT_MAXSTRLEN, end);
|
||||
acpi_cmbat_info_updated(&sc->bif_lastupdated);
|
||||
end:
|
||||
}
|
||||
|
||||
static void
|
||||
acpi_cmbat_notify_handler(ACPI_HANDLE h, UINT32 notify, void *context)
|
||||
{
|
||||
|
||||
switch (notify) {
|
||||
#if 0
|
||||
/* XXX
|
||||
@ -256,31 +319,38 @@ acpi_cmbat_attach(device_t dev)
|
||||
int error;
|
||||
ACPI_HANDLE handle = acpi_get_handle(dev);
|
||||
struct acpi_cmbat_softc *sc;
|
||||
sc = device_get_softc(dev);
|
||||
|
||||
if ((sc = device_get_softc(dev)) == NULL) {
|
||||
return (ENXIO);
|
||||
}
|
||||
AcpiInstallNotifyHandler(handle, ACPI_DEVICE_NOTIFY,
|
||||
acpi_cmbat_notify_handler,dev);
|
||||
acpi_cmbat_notify_handler, dev);
|
||||
bzero(&sc->bif_buffer, sizeof(sc->bif_buffer));
|
||||
bzero(&sc->bst_buffer, sizeof(sc->bst_buffer));
|
||||
sc->dev = dev;
|
||||
|
||||
acpi_cmbat_get_bif(dev);
|
||||
acpi_cmbat_get_bst(dev);
|
||||
timespecclear(&sc->bif_lastupdated);
|
||||
timespecclear(&sc->bst_lastupdated);
|
||||
|
||||
if (acpi_cmbat_units == 0) {
|
||||
error = acpi_register_ioctl(ACPIIO_CMBAT_GET_UNITS,
|
||||
acpi_cmbat_ioctl, sc);
|
||||
if (error)
|
||||
if ((error = acpi_register_ioctl(ACPIIO_CMBAT_GET_BIF,
|
||||
acpi_cmbat_ioctl, NULL)) != 0) {
|
||||
return (error);
|
||||
error = acpi_register_ioctl(ACPIIO_CMBAT_GET_BIF,
|
||||
acpi_cmbat_ioctl, sc);
|
||||
if (error)
|
||||
}
|
||||
if ((error = acpi_register_ioctl(ACPIIO_CMBAT_GET_BST,
|
||||
acpi_cmbat_ioctl, NULL)) != 0) {
|
||||
return (error);
|
||||
error = acpi_register_ioctl(ACPIIO_CMBAT_GET_BST,
|
||||
acpi_cmbat_ioctl, sc);
|
||||
if (error)
|
||||
}
|
||||
}
|
||||
|
||||
if ((error = acpi_battery_register(ACPI_BATT_TYPE_CMBAT,
|
||||
acpi_cmbat_units)) != 0) {
|
||||
return (error);
|
||||
}
|
||||
|
||||
acpi_cmbat_units++;
|
||||
timespecclear(&acpi_cmbat_info_lastupdated);
|
||||
|
||||
|
||||
return(0);
|
||||
}
|
||||
@ -305,34 +375,23 @@ DRIVER_MODULE(acpi_cmbat, acpi, acpi_cmbat_driver, acpi_cmbat_devclass, 0, 0);
|
||||
static int
|
||||
acpi_cmbat_ioctl(u_long cmd, caddr_t addr, void *arg)
|
||||
{
|
||||
union acpi_cmbat_ioctl_arg *ioctl_arg;
|
||||
device_t dev;
|
||||
union acpi_battery_ioctl_arg *ioctl_arg;
|
||||
struct acpi_cmbat_softc *sc;
|
||||
struct acpi_bif *bifp;
|
||||
struct acpi_bst *bstp;
|
||||
|
||||
if (cmd == ACPIIO_CMBAT_GET_UNITS) {
|
||||
ioctl_arg = NULL;
|
||||
dev = NULL;
|
||||
sc = NULL;
|
||||
} else {
|
||||
ioctl_arg = (union acpi_cmbat_ioctl_arg *)addr;
|
||||
dev = devclass_get_device(acpi_cmbat_devclass, ioctl_arg->unit);
|
||||
if (dev == NULL) {
|
||||
ioctl_arg = (union acpi_battery_ioctl_arg *)addr;
|
||||
if ((dev = devclass_get_device(acpi_cmbat_devclass,
|
||||
ioctl_arg->unit)) == NULL) {
|
||||
return(ENXIO);
|
||||
}
|
||||
|
||||
sc = device_get_softc(dev);
|
||||
if (sc == NULL) {
|
||||
if ((sc = device_get_softc(dev)) == NULL) {
|
||||
return(ENXIO);
|
||||
}
|
||||
}
|
||||
|
||||
switch (cmd) {
|
||||
case ACPIIO_CMBAT_GET_UNITS:
|
||||
*(int *)addr = acpi_cmbat_units;
|
||||
break;
|
||||
|
||||
case ACPIIO_CMBAT_GET_BIF:
|
||||
acpi_cmbat_get_bif(dev);
|
||||
bifp = &ioctl_arg->bif;
|
||||
@ -363,3 +422,198 @@ acpi_cmbat_ioctl(u_long cmd, caddr_t addr, void *arg)
|
||||
|
||||
return(0);
|
||||
}
|
||||
|
||||
static int
|
||||
acpi_cmbat_get_total_battinfo(struct acpi_battinfo *battinfo)
|
||||
{
|
||||
int i;
|
||||
int error;
|
||||
int batt_stat;
|
||||
int valid_rate, valid_units;
|
||||
int cap, min;
|
||||
int total_cap, total_min, total_full;
|
||||
device_t dev;
|
||||
struct acpi_cmbat_softc *sc;
|
||||
static int bat_units = 0;
|
||||
static struct acpi_cmbat_softc **bat = NULL;
|
||||
|
||||
cap = min = -1;
|
||||
batt_stat = ACPI_BATT_STAT_NOT_PRESENT;
|
||||
error = 0;
|
||||
|
||||
/* Allocate array of softc pointers */
|
||||
if (bat_units != acpi_cmbat_units) {
|
||||
if (bat != NULL) {
|
||||
free(bat, M_DEVBUF);
|
||||
}
|
||||
bat_units = 0;
|
||||
}
|
||||
if (bat == NULL) {
|
||||
bat_units = acpi_cmbat_units;
|
||||
bat = malloc(sizeof(struct acpi_cmbat_softc *) * bat_units,
|
||||
M_DEVBUF, M_NOWAIT);
|
||||
if (bat == NULL) {
|
||||
error = ENOMEM;
|
||||
goto out;
|
||||
}
|
||||
|
||||
/* Collect softc pointers */
|
||||
for (i = 0; i < acpi_cmbat_units; i++) {
|
||||
if ((dev = devclass_get_device(acpi_cmbat_devclass, i)) == NULL) {
|
||||
error = ENXIO;
|
||||
goto out;
|
||||
}
|
||||
|
||||
if ((sc = device_get_softc(dev)) == NULL) {
|
||||
error = ENXIO;
|
||||
goto out;
|
||||
}
|
||||
|
||||
bat[i] = sc;
|
||||
}
|
||||
}
|
||||
|
||||
/* Get battery status, valid rate and valid units */
|
||||
batt_stat = valid_rate = valid_units = 0;
|
||||
for (i = 0; i < acpi_cmbat_units; i++) {
|
||||
acpi_cmbat_get_bif(bat[i]->dev);
|
||||
acpi_cmbat_get_bst(bat[i]->dev);
|
||||
|
||||
/* If battey not installed, we get strange values */
|
||||
if (bat[i]->bst.state >= ACPI_BATT_STAT_MAX ||
|
||||
bat[i]->bst.cap == 0xffffffff ||
|
||||
bat[i]->bst.volt == 0xffffffff ||
|
||||
bat[i]->bif.lfcap == 0) {
|
||||
bat[i]->not_present = 1;
|
||||
continue;
|
||||
} else {
|
||||
bat[i]->not_present = 0;
|
||||
}
|
||||
|
||||
valid_units++;
|
||||
|
||||
bat[i]->cap = 100 * bat[i]->bst.cap / bat[i]->bif.lfcap;
|
||||
|
||||
batt_stat |= bat[i]->bst.state;
|
||||
|
||||
if (bat[i]->bst.rate > 0) {
|
||||
/*
|
||||
* XXX Hack to calculate total battery time.
|
||||
* Systems with 2 or more battries, they may get used
|
||||
* one by one, thus bst.rate is set only to the one
|
||||
* in use. For remaining batteries bst.rate = 0, which
|
||||
* makes it impossible to calculate remaining time.
|
||||
* Some other systems may need sum of bst.rate in
|
||||
* dis-charging state.
|
||||
* There for we sum up the bst.rate that is valid
|
||||
* (in dis-charging state), and use the sum to
|
||||
* calcutate remaining batteries' time.
|
||||
*/
|
||||
if (bat[i]->bst.state & ACPI_BATT_STAT_DISCHARG) {
|
||||
valid_rate += bat[i]->bst.rate;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Calculate total battery capacity and time */
|
||||
total_cap = total_min = total_full = 0;
|
||||
for (i = 0; i < acpi_cmbat_units; i++) {
|
||||
if (bat[i]->not_present) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (valid_rate > 0) {
|
||||
/* Use the sum of bst.rate */
|
||||
bat[i]->min = 60 * bat[i]->bst.cap / valid_rate;
|
||||
} else if (bat[i]->full_charge_time > 0) {
|
||||
bat[i]->min = (bat[i]->full_charge_time * bat[i]->cap) / 100;
|
||||
} else {
|
||||
/* Couldn't find valid rate and full battery time */
|
||||
bat[i]->min = 0;
|
||||
}
|
||||
total_min += bat[i]->min;
|
||||
total_cap += bat[i]->cap;
|
||||
total_full += bat[i]->full_charge_time;
|
||||
}
|
||||
|
||||
/* Battery life */
|
||||
if (valid_units == 0) {
|
||||
cap = -1;
|
||||
batt_stat = ACPI_BATT_STAT_NOT_PRESENT;
|
||||
} else {
|
||||
cap = total_cap / valid_units;
|
||||
}
|
||||
|
||||
/* Battery time */
|
||||
if (valid_units == 0) {
|
||||
min = -1;
|
||||
} else if (valid_rate == 0 || (batt_stat & ACPI_BATT_STAT_CHARGING)) {
|
||||
if (total_full == 0) {
|
||||
min = -1;
|
||||
} else {
|
||||
min = (total_full * cap) / 100;
|
||||
}
|
||||
} else {
|
||||
min = total_min;
|
||||
}
|
||||
|
||||
acpi_cmbat_info_updated(&acpi_cmbat_info_lastupdated);
|
||||
out:
|
||||
battinfo->cap = cap;
|
||||
battinfo->min = min;
|
||||
battinfo->state = batt_stat;
|
||||
|
||||
return (error);
|
||||
}
|
||||
|
||||
/*
|
||||
* Public interfaces.
|
||||
*/
|
||||
|
||||
int
|
||||
acpi_cmbat_get_battinfo(int unit, struct acpi_battinfo *battinfo)
|
||||
{
|
||||
int error;
|
||||
device_t dev;
|
||||
struct acpi_cmbat_softc *sc;
|
||||
|
||||
if (unit == -1) {
|
||||
return (acpi_cmbat_get_total_battinfo(battinfo));
|
||||
}
|
||||
|
||||
if (acpi_cmbat_info_expired(&acpi_cmbat_info_lastupdated)) {
|
||||
error = acpi_cmbat_get_total_battinfo(battinfo);
|
||||
if (error) {
|
||||
goto out;
|
||||
}
|
||||
}
|
||||
|
||||
error = 0;
|
||||
if (unit >= acpi_cmbat_units) {
|
||||
error = ENXIO;
|
||||
goto out;
|
||||
}
|
||||
|
||||
if ((dev = devclass_get_device(acpi_cmbat_devclass, unit)) == NULL) {
|
||||
error = ENXIO;
|
||||
goto out;
|
||||
}
|
||||
|
||||
if ((sc = device_get_softc(dev)) == NULL) {
|
||||
error = ENXIO;
|
||||
goto out;
|
||||
}
|
||||
|
||||
if (sc->not_present) {
|
||||
battinfo->cap = -1;
|
||||
battinfo->min = -1;
|
||||
battinfo->state = ACPI_BATT_STAT_NOT_PRESENT;
|
||||
} else {
|
||||
battinfo->cap = sc->cap;
|
||||
battinfo->min = sc->min;
|
||||
battinfo->state = sc->bst.state;
|
||||
}
|
||||
out:
|
||||
return (error);
|
||||
}
|
||||
|
||||
|
@ -48,6 +48,7 @@ MODULE_NAME("THERMAL")
|
||||
struct acpi_tz_softc {
|
||||
device_t tz_dev;
|
||||
ACPI_HANDLE tz_handle;
|
||||
int tz_tmp;
|
||||
};
|
||||
|
||||
static int acpi_tz_probe(device_t dev);
|
||||
@ -90,7 +91,7 @@ static int
|
||||
acpi_tz_attach(device_t dev)
|
||||
{
|
||||
struct acpi_tz_softc *sc;
|
||||
ACPI_STATUS status;
|
||||
struct acpi_softc *acpi_sc;
|
||||
|
||||
FUNCTION_TRACE(__func__);
|
||||
|
||||
@ -101,6 +102,14 @@ acpi_tz_attach(device_t dev)
|
||||
AcpiInstallNotifyHandler(sc->tz_handle, ACPI_DEVICE_NOTIFY,
|
||||
acpi_tz_notify_handler, dev);
|
||||
|
||||
if (device_get_unit(dev) == 0) {
|
||||
acpi_sc = acpi_device_get_parent_softc(dev);
|
||||
SYSCTL_ADD_UINT(&acpi_sc->acpi_sysctl_ctx,
|
||||
SYSCTL_CHILDREN(acpi_sc->acpi_sysctl_tree),
|
||||
OID_AUTO, "temperature", CTLFLAG_RD,
|
||||
&sc->tz_tmp, 0, "");
|
||||
}
|
||||
|
||||
/*
|
||||
* Don't bother evaluating/printing the temperature at this point;
|
||||
* on many systems it'll be bogus until the EC is running.
|
||||
@ -124,7 +133,10 @@ acpi_tz_check_tripping_point(void *context)
|
||||
return_VOID;
|
||||
}
|
||||
|
||||
device_printf(dev,"%d.%dC\n", TZ_KELVTOC(tp));
|
||||
sc->tz_tmp = (tp - TZ_ZEROC) / 10;
|
||||
if (bootverbose) {
|
||||
device_printf(dev, "%dC\n", sc->tz_tmp);
|
||||
}
|
||||
return_VOID;
|
||||
}
|
||||
|
||||
@ -145,8 +157,3 @@ acpi_tz_notify_handler(ACPI_HANDLE h, UINT32 notify, void *context)
|
||||
return_VOID;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
@ -34,6 +34,20 @@
|
||||
#define ACPIIO_DISABLE _IO('P', 2)
|
||||
#define ACPIIO_SETSLPSTATE _IOW('P', 3, int)
|
||||
|
||||
struct acpi_battdesc {
|
||||
int type; /* battery type: e.g. CMBAT */
|
||||
int phys_unit; /* physical unit of devclass */
|
||||
};
|
||||
|
||||
#define ACPI_BATT_TYPE_CMBAT 0x0000
|
||||
#define ACPI_BATT_TYPE_SMBAT 0x0001
|
||||
|
||||
struct acpi_battinfo {
|
||||
int cap; /* percent */
|
||||
int min; /* remianing time */
|
||||
int state; /* battery state */
|
||||
};
|
||||
|
||||
#define ACPI_CMBAT_MAXSTRLEN 32
|
||||
struct acpi_bif {
|
||||
u_int32_t unit; /* 0 for mWh, 1 for mAh */
|
||||
@ -58,15 +72,31 @@ struct acpi_bst {
|
||||
u_int32_t volt; /* Present Voltage */
|
||||
};
|
||||
|
||||
union acpi_cmbat_ioctl_arg {
|
||||
int unit;
|
||||
struct acpi_bif bif;
|
||||
struct acpi_bst bst;
|
||||
#define ACPI_BATT_STAT_DISCHARG 0x0001
|
||||
#define ACPI_BATT_STAT_CHARGING 0x0002
|
||||
#define ACPI_BATT_STAT_CRITICAL 0x0004
|
||||
#define ACPI_BATT_STAT_NOT_PRESENT 0x0007
|
||||
#define ACPI_BATT_STAT_MAX 0x0007
|
||||
|
||||
union acpi_battery_ioctl_arg {
|
||||
int unit; /* argument: logical unit (-1 = overall) */
|
||||
|
||||
struct acpi_battdesc battdesc;
|
||||
struct acpi_battinfo battinfo;
|
||||
|
||||
struct acpi_bif bif; /* for acpi_cmbat */
|
||||
struct acpi_bst bst; /* for acpi_cmbat */
|
||||
};
|
||||
|
||||
#define ACPIIO_CMBAT_GET_UNITS _IOR('B', 1, int)
|
||||
#define ACPIIO_CMBAT_GET_BIF _IOWR('B', 2, union acpi_cmbat_ioctl_arg)
|
||||
#define ACPIIO_CMBAT_GET_BST _IOWR('B', 3, union acpi_cmbat_ioctl_arg)
|
||||
/* Common battery ioctl */
|
||||
#define ACPIIO_BATT_GET_UNITS _IOR('B', 0x01, int)
|
||||
#define ACPIIO_BATT_GET_TYPE _IOR('B', 0x02, union acpi_battery_ioctl_arg)
|
||||
#define ACPIIO_BATT_GET_BATTINFO _IOWR('B', 0x03, union acpi_battery_ioctl_arg)
|
||||
#define ACPIIO_BATT_GET_BATTDESC _IOWR('B', 0x04, union acpi_battery_ioctl_arg)
|
||||
|
||||
/* Cotrol Method battery ioctl */
|
||||
#define ACPIIO_CMBAT_GET_BIF _IOWR('B', 0x10, union acpi_battery_ioctl_arg)
|
||||
#define ACPIIO_CMBAT_GET_BST _IOWR('B', 0x11, union acpi_battery_ioctl_arg)
|
||||
|
||||
#define ACPIIO_ACAD_GET_STATUS _IOR('A', 1, int)
|
||||
|
||||
|
@ -53,6 +53,9 @@ struct acpi_softc {
|
||||
int acpi_power_button_sx;
|
||||
int acpi_sleep_button_sx;
|
||||
int acpi_lid_switch_sx;
|
||||
|
||||
struct sysctl_ctx_list acpi_battery_sysctl_ctx;
|
||||
struct sysctl_oid *acpi_battery_sysctl_tree;
|
||||
};
|
||||
|
||||
struct acpi_device {
|
||||
@ -230,3 +233,12 @@ extern char *acpi_name(ACPI_HANDLE handle);
|
||||
extern int acpi_avoid(ACPI_HANDLE handle);
|
||||
extern int acpi_disabled(char *subsys);
|
||||
|
||||
/*
|
||||
* Battery Abstruction and Generalized Power Management interface.
|
||||
*/
|
||||
struct acpi_battinfo;
|
||||
|
||||
extern int acpi_battery_register(int, int);
|
||||
extern int acpi_acad_get_acline(void);
|
||||
extern int acpi_cmbat_get_battinfo(int, struct acpi_battinfo *);
|
||||
|
||||
|
Loading…
Reference in New Issue
Block a user