2 * Copyright (c) 2005 Nate Lawson
3 * Copyright (c) 2000 Mitsuru IWASAKI <iwasaki@jp.freebsd.org>
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * $FreeBSD: src/sys/dev/acpica/acpi_battery.c,v 1.30 2009/08/20 19:17:53 jhb
29 #include <sys/cdefs.h>
32 #include <sys/param.h>
33 #include <sys/kernel.h>
34 #include <sys/malloc.h>
36 #include <sys/ioccom.h>
37 #include <sys/sysctl.h>
41 #include <dev/acpica5/acpivar.h>
42 #include <dev/acpica5/acpiio.h>
44 /* Default seconds before re-sampling the battery state. */
45 #define ACPI_BATTERY_INFO_EXPIRE 5
47 static int acpi_batteries_initted
;
48 static int acpi_battery_info_expire
= ACPI_BATTERY_INFO_EXPIRE
;
49 static struct acpi_battinfo acpi_battery_battinfo
;
50 static struct sysctl_ctx_list acpi_battery_sysctl_ctx
;
51 static struct sysctl_oid
*acpi_battery_sysctl_tree
;
53 ACPI_SERIAL_DECL(battery
, "ACPI generic battery");
55 static void acpi_reset_battinfo(struct acpi_battinfo
*info
);
56 static void acpi_battery_clean_str(char *str
, int len
);
57 static device_t
acpi_battery_find_dev(u_int logical_unit
);
58 static int acpi_battery_ioctl(u_long cmd
, caddr_t addr
, void *arg
);
59 static int acpi_battery_sysctl(SYSCTL_HANDLER_ARGS
);
60 static int acpi_battery_units_sysctl(SYSCTL_HANDLER_ARGS
);
61 static int acpi_battery_init(void);
64 acpi_battery_register(device_t dev
)
69 ACPI_SERIAL_BEGIN(battery
);
70 if (!acpi_batteries_initted
)
71 error
= acpi_battery_init();
72 ACPI_SERIAL_END(battery
);
77 acpi_battery_remove(device_t dev
)
84 acpi_battery_get_units(void)
88 batt_dc
= devclass_find("battery");
91 return (devclass_get_count(batt_dc
));
95 acpi_battery_get_info_expire(void)
98 return (acpi_battery_info_expire
);
101 /* Check _BST results for validity. */
103 acpi_battery_bst_valid(struct acpi_bst
*bst
)
105 return (bst
->state
< ACPI_BATT_STAT_MAX
&& bst
->cap
!= ACPI_BATT_UNKNOWN
&&
106 bst
->volt
!= ACPI_BATT_UNKNOWN
);
109 /* Check _BIF results for validity. */
111 acpi_battery_bif_valid(struct acpi_bif
*bif
)
113 return (bif
->lfcap
!= 0);
116 /* Get info about one or all batteries. */
118 acpi_battery_get_battinfo(device_t dev
, struct acpi_battinfo
*battinfo
)
120 int batt_stat
, devcount
, dev_idx
, error
, i
;
121 int total_cap
, total_min
, valid_rate
, valid_units
;
124 struct acpi_bst
*bst
;
125 struct acpi_bif
*bif
;
126 struct acpi_battinfo
*bi
;
129 * Get the battery devclass and max unit for battery devices. If there
130 * are none or error, return immediately.
132 batt_dc
= devclass_find("battery");
135 devcount
= devclass_get_maxunit(batt_dc
);
140 * Allocate storage for all _BST data, their derived battinfo data,
141 * and the current battery's _BIF data.
143 bst
= kmalloc(devcount
* sizeof(*bst
), M_TEMP
, M_WAITOK
| M_ZERO
);
144 bi
= kmalloc(devcount
* sizeof(*bi
), M_TEMP
, M_WAITOK
| M_ZERO
);
145 bif
= kmalloc(sizeof(*bif
), M_TEMP
, M_WAITOK
| M_ZERO
);
148 * Pass 1: for each battery that is present and valid, get its status,
149 * calculate percent capacity remaining, and sum all the current
153 batt_stat
= valid_rate
= valid_units
= 0;
154 for (i
= 0; i
< devcount
; i
++) {
155 /* Default info for every battery is "not present". */
156 acpi_reset_battinfo(&bi
[i
]);
159 * Find the device. Since devcount is in terms of max units, this
160 * may be a sparse array so skip devices that aren't present.
162 batt_dev
= devclass_get_device(batt_dc
, i
);
163 if (batt_dev
== NULL
)
166 /* If examining a specific battery and this is it, record its index. */
167 if (dev
!= NULL
&& dev
== batt_dev
)
171 * Be sure we can get various info from the battery. Note that
172 * acpi_BatteryIsPresent() is not enough because smart batteries only
173 * return that the device is present.
175 if (!acpi_BatteryIsPresent(batt_dev
) ||
176 ACPI_BATT_GET_STATUS(batt_dev
, &bst
[i
]) != 0 ||
177 ACPI_BATT_GET_INFO(batt_dev
, bif
) != 0)
180 /* If a battery is not installed, we sometimes get strange values. */
181 if (!acpi_battery_bst_valid(&bst
[i
]) ||
182 !acpi_battery_bif_valid(bif
))
186 * Record current state. If both charging and discharging are set,
187 * ignore the charging flag.
190 if ((bst
[i
].state
& ACPI_BATT_STAT_DISCHARG
) != 0)
191 bst
[i
].state
&= ~ACPI_BATT_STAT_CHARGING
;
192 batt_stat
|= bst
[i
].state
;
193 bi
[i
].state
= bst
[i
].state
;
196 * If the battery info is in terms of mA, convert to mW by
197 * multiplying by the design voltage. If the design voltage
198 * is 0 (due to some error reading the battery), skip this
201 if (bif
->units
== ACPI_BIF_UNITS_MA
&& bif
->dvol
!= 0 && dev
== NULL
) {
202 bst
[i
].rate
= (bst
[i
].rate
* bif
->dvol
) / 1000;
203 bst
[i
].cap
= (bst
[i
].cap
* bif
->dvol
) / 1000;
204 bif
->lfcap
= (bif
->lfcap
* bif
->dvol
) / 1000;
207 /* Calculate percent capacity remaining. */
208 bi
[i
].cap
= (100 * bst
[i
].cap
) / bif
->lfcap
;
211 * Some laptops report the "design-capacity" instead of the
212 * "real-capacity" when the battery is fully charged. That breaks
213 * the above arithmetic as it needs to be 100% maximum.
219 * On systems with more than one battery, they may get used
220 * sequentially, thus bst.rate may only signify the one currently
221 * in use. For the remaining batteries, bst.rate will be zero,
222 * which makes it impossible to calculate the total remaining time.
223 * Therefore, we sum the bst.rate for batteries in the discharging
224 * state and use the sum to calculate the total remaining time.
226 if (bst
[i
].rate
!= ACPI_BATT_UNKNOWN
&&
227 (bst
[i
].state
& ACPI_BATT_STAT_DISCHARG
) != 0)
228 valid_rate
+= bst
[i
].rate
;
231 /* If the caller asked for a device but we didn't find it, error. */
232 if (dev
!= NULL
&& dev_idx
== -1) {
237 /* Pass 2: calculate capacity and remaining time for all batteries. */
238 total_cap
= total_min
= 0;
239 for (i
= 0; i
< devcount
; i
++) {
241 * If any batteries are discharging, use the sum of the bst.rate
242 * values. Otherwise, we are on AC power, and there is infinite
243 * time remaining for this battery until we go offline.
246 bi
[i
].min
= (60 * bst
[i
].cap
) / valid_rate
;
249 total_min
+= bi
[i
].min
;
251 /* If this battery is not present, don't use its capacity. */
253 total_cap
+= bi
[i
].cap
;
257 * Return total battery percent and time remaining. If there are
258 * no valid batteries, report values as unknown.
260 if (valid_units
> 0) {
262 battinfo
->cap
= total_cap
/ valid_units
;
263 battinfo
->min
= total_min
;
264 battinfo
->state
= batt_stat
;
265 battinfo
->rate
= valid_rate
;
267 battinfo
->cap
= bi
[dev_idx
].cap
;
268 battinfo
->min
= bi
[dev_idx
].min
;
269 battinfo
->state
= bi
[dev_idx
].state
;
270 battinfo
->rate
= bst
[dev_idx
].rate
;
274 * If the queried battery has no discharge rate or is charging,
275 * report that we don't know the remaining time.
277 if (valid_rate
== 0 || (battinfo
->state
& ACPI_BATT_STAT_CHARGING
))
280 acpi_reset_battinfo(battinfo
);
295 acpi_reset_battinfo(struct acpi_battinfo
*info
)
299 info
->state
= ACPI_BATT_STAT_NOT_PRESENT
;
303 /* Make string printable, removing invalid chars. */
305 acpi_battery_clean_str(char *str
, int len
)
309 for (i
= 0; i
< len
&& *str
!= '\0'; i
++, str
++) {
314 /* NUL-terminate the string if we reached the end. */
320 * The battery interface deals with devices and methods but userland
321 * expects a logical unit number. Convert a logical unit to a device_t.
324 acpi_battery_find_dev(u_int logical_unit
)
326 int found_unit
, i
, maxunit
;
332 batt_dc
= devclass_find("battery");
333 maxunit
= devclass_get_maxunit(batt_dc
);
334 for (i
= 0; i
< maxunit
; i
++) {
335 dev
= devclass_get_device(batt_dc
, i
);
338 if (logical_unit
== found_unit
)
348 acpi_battery_ioctl(u_long cmd
, caddr_t addr
, void *arg
)
350 union acpi_battery_ioctl_arg
*ioctl_arg
;
354 /* For commands that use the ioctl_arg struct, validate it first. */
359 if (IOCPARM_LEN(cmd
) == sizeof(*ioctl_arg
)) {
360 ioctl_arg
= (union acpi_battery_ioctl_arg
*)addr
;
361 unit
= ioctl_arg
->unit
;
362 if (unit
!= ACPI_BATTERY_ALL_UNITS
)
363 dev
= acpi_battery_find_dev(unit
);
367 * No security check required: information retrieval only. If
368 * new functions are added here, a check might be required.
371 case ACPIIO_BATT_GET_UNITS
:
372 *(int *)addr
= acpi_battery_get_units();
375 case ACPIIO_BATT_GET_BATTINFO
:
376 if (dev
!= NULL
|| unit
== ACPI_BATTERY_ALL_UNITS
) {
377 bzero(&ioctl_arg
->battinfo
, sizeof(ioctl_arg
->battinfo
));
378 error
= acpi_battery_get_battinfo(dev
, &ioctl_arg
->battinfo
);
381 case ACPIIO_BATT_GET_BIF
:
383 bzero(&ioctl_arg
->bif
, sizeof(ioctl_arg
->bif
));
384 error
= ACPI_BATT_GET_INFO(dev
, &ioctl_arg
->bif
);
387 * Remove invalid characters. Perhaps this should be done
388 * within a convenience function so all callers get the
391 acpi_battery_clean_str(ioctl_arg
->bif
.model
,
392 sizeof(ioctl_arg
->bif
.model
));
393 acpi_battery_clean_str(ioctl_arg
->bif
.serial
,
394 sizeof(ioctl_arg
->bif
.serial
));
395 acpi_battery_clean_str(ioctl_arg
->bif
.type
,
396 sizeof(ioctl_arg
->bif
.type
));
397 acpi_battery_clean_str(ioctl_arg
->bif
.oeminfo
,
398 sizeof(ioctl_arg
->bif
.oeminfo
));
401 case ACPIIO_BATT_GET_BST
:
403 bzero(&ioctl_arg
->bst
, sizeof(ioctl_arg
->bst
));
404 error
= ACPI_BATT_GET_STATUS(dev
, &ioctl_arg
->bst
);
415 acpi_battery_sysctl(SYSCTL_HANDLER_ARGS
)
419 acpi_battery_get_battinfo(NULL
, &acpi_battery_battinfo
);
420 val
= *(u_int
*)oidp
->oid_arg1
;
421 error
= sysctl_handle_int(oidp
, &val
, 0, req
);
426 acpi_battery_units_sysctl(SYSCTL_HANDLER_ARGS
)
430 count
= acpi_battery_get_units();
431 error
= sysctl_handle_int(oidp
, &count
, 0, req
);
436 acpi_battery_init(void)
438 struct acpi_softc
*sc
;
442 ACPI_SERIAL_ASSERT(battery
);
445 dev
= devclass_get_device(devclass_find("acpi"), 0);
448 sc
= device_get_softc(dev
);
450 error
= acpi_register_ioctl(ACPIIO_BATT_GET_UNITS
, acpi_battery_ioctl
,
454 error
= acpi_register_ioctl(ACPIIO_BATT_GET_BATTINFO
, acpi_battery_ioctl
,
458 error
= acpi_register_ioctl(ACPIIO_BATT_GET_BIF
, acpi_battery_ioctl
, NULL
);
461 error
= acpi_register_ioctl(ACPIIO_BATT_GET_BST
, acpi_battery_ioctl
, NULL
);
465 sysctl_ctx_init(&acpi_battery_sysctl_ctx
);
466 acpi_battery_sysctl_tree
= SYSCTL_ADD_NODE(&acpi_battery_sysctl_ctx
,
467 SYSCTL_CHILDREN(sc
->acpi_sysctl_tree
), OID_AUTO
, "battery", CTLFLAG_RD
,
468 0, "battery status and info");
469 SYSCTL_ADD_PROC(&acpi_battery_sysctl_ctx
,
470 SYSCTL_CHILDREN(acpi_battery_sysctl_tree
),
471 OID_AUTO
, "life", CTLTYPE_INT
| CTLFLAG_RD
,
472 &acpi_battery_battinfo
.cap
, 0, acpi_battery_sysctl
, "I",
473 "percent capacity remaining");
474 SYSCTL_ADD_PROC(&acpi_battery_sysctl_ctx
,
475 SYSCTL_CHILDREN(acpi_battery_sysctl_tree
),
476 OID_AUTO
, "time", CTLTYPE_INT
| CTLFLAG_RD
,
477 &acpi_battery_battinfo
.min
, 0, acpi_battery_sysctl
, "I",
478 "remaining time in minutes");
479 SYSCTL_ADD_PROC(&acpi_battery_sysctl_ctx
,
480 SYSCTL_CHILDREN(acpi_battery_sysctl_tree
),
481 OID_AUTO
, "state", CTLTYPE_INT
| CTLFLAG_RD
,
482 &acpi_battery_battinfo
.state
, 0, acpi_battery_sysctl
, "I",
483 "current status flags");
484 SYSCTL_ADD_PROC(&acpi_battery_sysctl_ctx
,
485 SYSCTL_CHILDREN(acpi_battery_sysctl_tree
),
486 OID_AUTO
, "units", CTLTYPE_INT
| CTLFLAG_RD
,
487 NULL
, 0, acpi_battery_units_sysctl
, "I", "number of batteries");
488 SYSCTL_ADD_INT(&acpi_battery_sysctl_ctx
,
489 SYSCTL_CHILDREN(acpi_battery_sysctl_tree
),
490 OID_AUTO
, "info_expire", CTLFLAG_RW
,
491 &acpi_battery_info_expire
, 0,
492 "time in seconds until info is refreshed");
494 acpi_batteries_initted
= TRUE
;
498 acpi_deregister_ioctl(ACPIIO_BATT_GET_UNITS
, acpi_battery_ioctl
);
499 acpi_deregister_ioctl(ACPIIO_BATT_GET_BATTINFO
, acpi_battery_ioctl
);
500 acpi_deregister_ioctl(ACPIIO_BATT_GET_BIF
, acpi_battery_ioctl
);
501 acpi_deregister_ioctl(ACPIIO_BATT_GET_BST
, acpi_battery_ioctl
);