path: root/battstat/acpi-linux.c

/* battstat        A MATE battery meter for laptops.
 * Copyright (C) 2000 by Jörgen Pehrson <jp@spektr.eu.org>
 *
 *  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 <lennart@poettering.de>
 */

#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;
    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__ */