1 files changed, 439 insertions, 0 deletions
diff --git a/battstat/acpi-linux.c b/battstat/acpi-linux.c
new file mode 100644
index 00000000..d982f6cc
--- /dev/null
+++ b/battstat/acpi-linux.c
@@ -0,0 +1,439 @@
+/* battstat A MATE battery meter for laptops. 
+ * Copyright (C) 2000 by J�rgen Pehrson <[email protected]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Street #330, Boston, MA 02111-1307, USA.
+ *
+ $Id$
+ */
+
+/*
+ * ACPI battery read-out functions for Linux >= 2.4.12
+ * October 2001 by Lennart Poettering <[email protected]>
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#ifdef __linux__
+
+#include <stdio.h>
+#include <apm.h>
+#include <glib.h>
+#include <string.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <unistd.h>
+#include <dirent.h>
+#include "acpi-linux.h"
+
+static GHashTable *
+read_file (const char *file, char *buf, size_t bufsize)
+{
+ GHashTable *hash = NULL;
+
+ int fd, len, i;
+ char *key, *value;
+ gboolean reading_key;
+
+ fd = open (file, O_RDONLY);
+
+ if (fd == -1) {
+ return hash;
+ }
+
+ len = read (fd, buf, bufsize);
+
+ close (fd);
+
+ if (len < 0) {
+ if (getenv ("BATTSTAT_DEBUG"))
+ g_message ("Error reading %s: %s", file, g_strerror (errno));
+ return hash;
+ }
+
+ hash = g_hash_table_new (g_str_hash, g_str_equal);
+
+ for (i = 0, value = key = buf, reading_key = TRUE; i < len; i++) {
+ if (buf[i] == ':' && reading_key) {
+ reading_key = FALSE;
+ buf[i] = '\0';
+ value = buf + i + 1;
+ } else if (buf[i] == '\n') {
+ reading_key = TRUE;
+ buf[i] = '\0';
+ /* g_message ("Read: %s => %s\n", key, value); */
+ g_hash_table_insert (hash, key, g_strstrip (value));
+ key = buf + i + 1;
+ } else if (reading_key) {
+ /* in acpi 20020214 it switched to lower-case proc
+ * entries. fixing this up here simplifies the
+ * code.
+ */
+ buf[i] = g_ascii_tolower (buf[i]);
+ }
+ }
+
+ return hash;
+}
+
+#if 0
+static gboolean
+read_bool (GHashTable *hash, const char *key)
+{
+ char *s;
+
+ g_return_val_if_fail (hash, FALSE);
+ g_return_val_if_fail (key, FALSE);
+
+ s = g_hash_table_lookup (hash, key);
+ return s && (*s == 'y');
+}
+#endif
+
+static long
+read_long (GHashTable *hash, const char *key)
+{
+ char *s;
+
+ g_return_val_if_fail (hash, 0);
+ g_return_val_if_fail (key, 0);
+
+ s = g_hash_table_lookup (hash, key);
+ return s ? strtol (s, NULL, 10) : 0;
+}
+
+static gulong
+read_ulong (GHashTable *hash, const char *key)
+{
+ char *s;
+
+ g_return_val_if_fail (hash, 0);
+ g_return_val_if_fail (key, 0);
+
+ s = g_hash_table_lookup (hash, key);
+ return s ? strtoul (s, NULL, 10) : 0;
+}
+
+static const char *
+read_string (GHashTable *hash, const char *key)
+{
+ return g_hash_table_lookup (hash, key);
+}
+
+/* Reads the current status of the AC adapter and stores the
+ * result in acpiinfo->ac_online. */
+static gboolean update_ac_info(struct acpi_info * acpiinfo)
+{
+ gchar *ac_state = NULL;
+ DIR * procdir;
+ struct dirent * procdirentry;
+ char buf[BUFSIZ];
+ GHashTable *hash;
+ gboolean have_adaptor = FALSE;
+
+ acpiinfo->ac_online = FALSE;
+
+ procdir=opendir("/proc/acpi/ac_adapter/");
+ if (!procdir)
+ return FALSE;
+
+ while ((procdirentry=readdir(procdir)))
+ {
+ if (procdirentry->d_name[0]!='.')
+ {
+ have_adaptor = TRUE;
+ ac_state = g_strconcat("/proc/acpi/ac_adapter/",
+ procdirentry->d_name,
+ "/",
+ acpiinfo->ac_state_state,
+ NULL);
+ hash = read_file (ac_state, buf, sizeof (buf));
+ if (hash && !acpiinfo->ac_online)
+ {
+ const char *s;
+ s = read_string (hash, acpiinfo->ac_state_state);
+ acpiinfo->ac_online = s ? (strcmp (s, "on-line") == 0) : 0;
+ g_hash_table_destroy (hash);
+ }
+ g_free(ac_state);
+ }
+ }
+
+ /* If there are no AC adaptors registered in the system, then we're
+ probably on a desktop (and therefore, on AC power).
+ */
+ if (have_adaptor == FALSE)
+ acpiinfo->ac_online = 1;
+
+ closedir(procdir);
+
+ return TRUE;
+}
+
+/* Reads the ACPI info for the system batteries, and finds
+ * the total capacity, which is stored in acpiinfo. */
+static gboolean update_battery_info(struct acpi_info * acpiinfo)
+{
+ gchar* batt_info = NULL;
+ GHashTable *hash;
+ DIR * procdir;
+ struct dirent * procdirentry;
+ char buf[BUFSIZ];
+
+ acpiinfo->max_capacity = 0;
+ acpiinfo->low_capacity = 0;
+ acpiinfo->critical_capacity = 0;
+
+ procdir=opendir("/proc/acpi/battery/");
+ if (!procdir)
+ return FALSE;
+
+ while ((procdirentry=readdir(procdir)))
+ {
+ if (procdirentry->d_name[0]!='.')
+ {
+ batt_info = g_strconcat("/proc/acpi/battery/",
+ procdirentry->d_name,
+ "/info",
+ NULL);
+ hash = read_file (batt_info, buf, sizeof (buf));
+ if (hash)
+ {
+ acpiinfo->max_capacity += read_long (hash, "last full capacity");
+ acpiinfo->low_capacity += read_long (hash, "design capacity warning");
+ acpiinfo->critical_capacity += read_long (hash, "design capacity low");
+ g_hash_table_destroy (hash);
+ }
+ g_free(batt_info);
+ }
+ }
+ closedir(procdir);
+
+ return TRUE;
+}
+
+
+/* Initializes the ACPI-reading subsystem by opening a file
+ * descriptor to the ACPI event file. This can either be the
+ * /proc/acpi/event exported by the kernel, or if it's already
+ * in use, the /var/run/acpid.socket maintained by acpid. Also
+ * initializes the stored battery and AC adapter information. */
+gboolean acpi_linux_init(struct acpi_info * acpiinfo)
+{
+ GHashTable *hash;
+ char buf[BUFSIZ];
+ gchar *pbuf;
+ gulong acpi_ver;
+ int fd;
+
+ g_assert(acpiinfo);
+
+ if (g_file_get_contents ("/sys/module/acpi/parameters/acpica_version", &pbuf, NULL, NULL)) {
+ acpi_ver = strtoul (pbuf, NULL, 10);
+ g_free (pbuf);
+ } else if (hash = read_file ("/proc/acpi/info", buf, sizeof (buf))) {
+ acpi_ver = read_ulong (hash, "version");
+ g_hash_table_destroy (hash);
+ } else
+ return FALSE;
+
+ if (acpi_ver < (gulong)20020208) {
+ acpiinfo->ac_state_state = "status";
+ acpiinfo->batt_state_state = "status";
+ acpiinfo->charging_state = "state";
+ } else {
+ acpiinfo->ac_state_state = "state";
+ acpiinfo->batt_state_state = "state";
+ acpiinfo->charging_state = "charging state";
+ }
+
+ if (!update_battery_info(acpiinfo) || !update_ac_info(acpiinfo))
+ return FALSE;
+ 
+ fd = open("/proc/acpi/event", 0);
+ if (fd >= 0) {
+ acpiinfo->event_fd = fd;
+ acpiinfo->channel = g_io_channel_unix_new(fd);
+ return TRUE;
+ }
+
+ fd = socket(PF_UNIX, SOCK_STREAM, 0);
+ if (fd >= 0) {
+ struct sockaddr_un addr;
+ addr.sun_family = AF_UNIX;
+ strcpy(addr.sun_path, "/var/run/acpid.socket");
+ if (connect(fd, (struct sockaddr *) &addr, sizeof(addr)) == 0) {
+ acpiinfo->event_fd = fd;
+ acpiinfo->channel = g_io_channel_unix_new(fd);
+ return TRUE;
+ }
+ }
+
+ close(fd);
+ acpiinfo->event_fd = -1;
+ return FALSE;
+}
+
+/* Cleans up ACPI */
+void acpi_linux_cleanup(struct acpi_info * acpiinfo)
+{
+ g_assert(acpiinfo);
+
+ if (acpiinfo->event_fd >= 0) {
+ g_io_channel_unref(acpiinfo->channel);
+ close(acpiinfo->event_fd);
+ acpiinfo->event_fd = -1;
+ }
+}
+
+#define ACPI_EVENT_IGNORE 0
+#define ACPI_EVENT_DONE 1
+#define ACPI_EVENT_AC 2
+#define ACPI_EVENT_BATTERY_INFO 3
+
+/* Given a string event from the ACPI system, returns the type
+ * of event if we're interested in it. str is updated to point
+ * to the next event. */
+static int parse_acpi_event(GString *buffer)
+{
+ 
+ if (strstr(buffer->str, "ac_adapter"))
+ return ACPI_EVENT_AC;
+ if (strstr(buffer->str, "battery") )
+ return ACPI_EVENT_BATTERY_INFO;
+
+ return ACPI_EVENT_IGNORE;
+}
+
+/* Handles a new ACPI event by reading it from the event file
+ * and calling any handlers. Since this does a blocking read,
+ * it should only be called when there is a new event as indicated
+ * by select(). */
+gboolean acpi_process_event(struct acpi_info * acpiinfo)
+{
+ gsize i;
+ int evt;
+ GString *buffer;
+ GError *gerror=NULL;
+ buffer=g_string_new(NULL);
+ g_io_channel_read_line_string ( acpiinfo->channel,buffer,&i,&gerror);
+
+ 
+ evt = parse_acpi_event(buffer);
+ switch (evt) {
+ case ACPI_EVENT_AC:
+ return update_ac_info(acpiinfo);
+ case ACPI_EVENT_BATTERY_INFO:
+ if (update_battery_info(acpiinfo)) {
+ /* Update AC info on battery info updates. This works around
+ * a bug in ACPI (as per bug #163013).
+ */
+ return update_ac_info(acpiinfo);
+ }
+ /* fall-through */
+ default:
+ return FALSE;
+ }
+}
+
+/*
+ * Fills out a classic apm_info structure with the data gathered from
+ * the ACPI kernel interface in /proc
+ */
+gboolean acpi_linux_read(struct apm_info *apminfo, struct acpi_info * acpiinfo)
+{
+ guint32 remain;
+ guint32 rate;
+ gboolean charging;
+ GHashTable *hash;
+ gchar* batt_state = NULL;
+ DIR * procdir;
+ struct dirent * procdirentry;
+ char buf[BUFSIZ];
+
+ g_assert(acpiinfo);
+
+ /*
+ * apminfo.ac_line_status must be one when on ac power
+ * apminfo.battery_status must be 0 for high, 1 for low, 2 for critical, 3 for charging
+ * apminfo.battery_percentage must contain batter charge percentage
+ * apminfo.battery_flags & 0x8 must be nonzero when charging
+ */
+ 
+ g_assert(apminfo);
+
+ charging = FALSE;
+ remain = 0;
+ rate = 0;
+
+ procdir=opendir("/proc/acpi/battery/");
+ if (!procdir)
+ return FALSE;
+
+ /* Get the remaining capacity for the batteries. Other information
+ * such as AC state and battery max capacity are read only when they
+ * change using acpi_process_event(). */
+ while ((procdirentry=readdir(procdir)))
+ {
+ if (procdirentry->d_name[0]!='.')
+ {
+ batt_state = g_strconcat("/proc/acpi/battery/",
+ procdirentry->d_name,
+ "/",
+ acpiinfo->batt_state_state,
+ NULL);
+ hash = read_file (batt_state, buf, sizeof (buf));
+ if (hash)
+ {
+ const char *s;
+ if (!charging)
+ {
+ s = read_string (hash, acpiinfo->charging_state);
+ charging = s ? (strcmp (s, "charging") == 0) : 0;
+ }
+ remain += read_long (hash, "remaining capacity");
+ rate += read_long (hash, "present rate");
+ g_hash_table_destroy (hash);
+ }
+ g_free(batt_state);
+ }
+ }
+ closedir(procdir);
+
+ apminfo->ac_line_status = acpiinfo->ac_online ? 1 : 0;
+ apminfo->battery_status = remain < acpiinfo->low_capacity ? 1 : remain < acpiinfo->critical_capacity ? 2 : 0;
+ if (!acpiinfo->max_capacity)
+ apminfo->battery_percentage = -1;
+ else
+ apminfo->battery_percentage = (int) (remain/(float)acpiinfo->max_capacity*100);
+ apminfo->battery_flags = charging ? 0x8 : 0;
+ if (rate && !charging)
+ apminfo->battery_time = (int) (remain/(float)rate * 60);
+ else if (rate && charging)
+ apminfo->battery_time = (int) ((acpiinfo->max_capacity-remain)/(float)rate * 60);
+ else
+ apminfo->battery_time = -1;
+
+ return TRUE;
+}
+
+
+#endif