/* battstat A MATE battery meter for laptops. * Copyright (C) 2000 by Jörgen Pehrson * * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * $Id$ */ /* * ACPI battery read-out functions for Linux >= 2.4.12 * October 2001 by Lennart Poettering */ #ifdef HAVE_CONFIG_H #include #endif #ifdef __linux__ #include #include #include #include #include #include #include #include #include #include #include #include #include #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; char* 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); if (gerror != NULL) { g_warning ("%s", gerror->message); g_error_free (gerror); } gboolean result; evt = parse_acpi_event (buffer); switch (evt) { case ACPI_EVENT_AC: result = update_ac_info (acpiinfo); break; 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). */ result = update_ac_info (acpiinfo); break; } /* fall-through */ default: result = FALSE; } g_string_free (buffer, FALSE); return result; } /* * 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 /* __linux__ */