initial

1 files changed, 535 insertions, 0 deletions

diff --git a/battstat/power-management.c b/battstat/power-management.c
new file mode 100644
index 00000000..53ae081a
--- /dev/null
+++ b/battstat/power-management.c
@@ -0,0 +1,535 @@
+/* battstat        A MATE battery meter for laptops. 
+ * Copyright (C) 2000 by Jörgen Pehrson <[email protected]>
+ * Copyright (C) 2002-2005 Free Software Foundation
+ *
+ *  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$
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <sys/file.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#ifdef HAVE_SYS_SYSCTL_H
+#include <sys/sysctl.h>
+#endif
+
+#ifdef HAVE_ERR_H
+#include <err.h>
+#endif
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <unistd.h>
+
+#include "battstat.h"
+#include "battstat-hal.h"
+
+#define ERR_ACPID _("Can't access ACPI events in /var/run/acpid.socket! "    \
+                    "Make sure the ACPI subsystem is working and "           \
+                    "the acpid daemon is running.")
+
+#define ERR_OPEN_APMDEV _("Can't open the APM device!\n\n"                  \
+                          "Make sure you have read permission to the\n"     \
+                          "APM device.")
+
+#define ERR_APM_E _("The APM Management subsystem seems to be disabled.\n"  \
+                    "Try executing \"apm -e 1\" (FreeBSD) and see if \n"    \
+                    "that helps.\n")
+
+#define ERR_NO_SUPPORT _("Your platform is not supported!  The battery\n"   \
+                         "monitor applet will not work on your system.\n")
+
+#define ERR_FREEBSD_ACPI _("There was an error reading information from "   \
+                           "the ACPI subsystem.  Check to make sure the "   \
+                           "ACPI subsystem is properly loaded.")
+
+static const char *apm_readinfo (BatteryStatus *status);
+static int pm_initialised;
+#ifdef HAVE_HAL
+static int using_hal;
+#endif
+
+/*
+ * What follows is a series of platform-specific apm_readinfo functions
+ * that take care of the quirks of getting battery information for different
+ * platforms.  Each function takes a BatteryStatus pointer and fills it
+ * then returns a const char *.
+ *
+ * In the case of success, NULL is returned.  In case of failure, a
+ * localised error message is returned to give the user hints about what
+ * the problem might be.  This error message is not to be freed.
+ */
+
+
+/* Uncomment the following to enable a 'testing' backend.  When you add the
+   applet to the panel a window will appear that allows you to manually
+   change the battery status values for testing purposes.
+
+   NB: Be sure to unset this before committing!!
+ */
+
+/* #define BATTSTAT_TESTING_BACKEND */
+#ifdef BATTSTAT_TESTING_BACKEND
+
+#include <gtk/gtk.h>
+
+BatteryStatus test_status;
+
+static void
+test_update_boolean( GtkToggleButton *button, gboolean *value )
+{
+  *value = gtk_toggle_button_get_active( button );
+}
+
+static void
+test_update_integer( GtkSpinButton *spin, gint *value )
+{
+  *value = gtk_spin_button_get_value_as_int( spin );
+}
+
+static void
+initialise_test( void )
+{
+  GtkWidget *w;
+  GtkBox *box;
+
+  test_status.percent = 50;
+  test_status.minutes = 180;
+  test_status.present = TRUE;
+  test_status.on_ac_power = FALSE;
+  test_status.charging = FALSE;
+
+  box = GTK_BOX( gtk_vbox_new( 5, FALSE ) );
+
+  gtk_box_pack_start( box, gtk_label_new( "percent" ), TRUE, TRUE, 0);
+  w = gtk_spin_button_new_with_range( -1.0, 100.0, 1 );
+  gtk_spin_button_set_value( GTK_SPIN_BUTTON( w ), 50.0 );
+  g_signal_connect( G_OBJECT( w ), "value-changed",
+                    G_CALLBACK( test_update_integer ), &test_status.percent );
+  gtk_box_pack_start( box, w, TRUE, TRUE, 0 );
+
+  gtk_box_pack_start( box, gtk_label_new( "minutes" ), TRUE, TRUE, 0);
+  w = gtk_spin_button_new_with_range( -1.0, 1000.0, 1 );
+  gtk_spin_button_set_value( GTK_SPIN_BUTTON( w ), 180.0 );
+  g_signal_connect( G_OBJECT( w ), "value-changed",
+                    G_CALLBACK( test_update_integer ), &test_status.minutes );
+  gtk_box_pack_start( box, w, TRUE, TRUE, 0);
+
+
+  w = gtk_toggle_button_new_with_label( "on_ac_power" );
+  g_signal_connect( G_OBJECT( w ), "toggled",
+                    G_CALLBACK( test_update_boolean ),
+                    &test_status.on_ac_power );
+  gtk_box_pack_start( box, w, TRUE, TRUE, 0);
+
+  w = gtk_toggle_button_new_with_label( "charging" );
+  g_signal_connect( G_OBJECT( w ), "toggled",
+                    G_CALLBACK( test_update_boolean ), &test_status.charging );
+  gtk_box_pack_start( box, w, TRUE, TRUE, 0);
+
+  w = gtk_toggle_button_new_with_label( "present" );
+  gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ), TRUE );
+  g_signal_connect( G_OBJECT( w ), "toggled",
+                    G_CALLBACK( test_update_boolean ), &test_status.present );
+  gtk_box_pack_start( box, w, TRUE, TRUE, 0);
+
+  w = gtk_window_new( GTK_WINDOW_TOPLEVEL );
+  gtk_container_add( GTK_CONTAINER( w ), GTK_WIDGET( box ) );
+  gtk_widget_show_all( w );
+}
+
+static const char *
+apm_readinfo (BatteryStatus *status)
+{
+  static int test_initialised;
+
+  if( !test_initialised )
+    initialise_test();
+
+  test_initialised = 1;
+  *status = test_status;
+
+  return NULL;
+}
+
+#undef __linux__
+#undef HAVE_HAL
+
+#elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
+
+#include <machine/apm_bios.h>
+#include "acpi-freebsd.h"
+
+static struct acpi_info acpiinfo;
+static gboolean using_acpi;
+static int acpi_count;
+static struct apm_info apminfo;
+
+#define APMDEVICE "/dev/apm"
+
+static const char *
+apm_readinfo (BatteryStatus *status)
+{
+  int fd;
+
+  if (DEBUG) g_print("apm_readinfo() (FreeBSD)\n");
+
+  if (using_acpi) {
+    if (acpi_count <= 0) {
+      acpi_count = 30;
+      acpi_process_event(&acpiinfo);
+      if (acpi_freebsd_read(&apminfo, &acpiinfo) == FALSE)
+        return ERR_FREEBSD_ACPI;
+    }
+    acpi_count--;
+  }
+  else
+  {
+    /* This is how I read the information from the APM subsystem under
+       FreeBSD.  Each time this functions is called (once every second)
+       the APM device is opened, read from and then closed.
+    */
+    fd = open(APMDEVICE, O_RDONLY);
+    if (fd == -1) {
+      return ERR_OPEN_APMDEV;
+    }
+
+    if (ioctl(fd, APMIO_GETINFO, &apminfo) == -1)
+      err(1, "ioctl(APMIO_GETINFO)");
+
+    close(fd);
+
+    if(apminfo.ai_status == 0)
+      return ERR_APM_E;
+  }
+
+  status->present = TRUE;
+  status->on_ac_power = apminfo.ai_acline ? 1 : 0;
+  status->percent = apminfo.ai_batt_life;
+  status->charging = (apminfo.ai_batt_stat) ? TRUE : FALSE;
+  if (using_acpi)
+    status->minutes = apminfo.ai_batt_time;
+  else
+    status->minutes = (int) (apminfo.ai_batt_time/60.0);
+
+  return NULL;
+}
+
+#elif defined(__NetBSD__) || defined(__OpenBSD__)
+
+#include <sys/param.h>
+#include <machine/apmvar.h>
+
+#define APMDEVICE "/dev/apm"
+
+static const char *
+apm_readinfo (BatteryStatus *status)
+{
+  /* Code for OpenBSD by Joe Ammond <[email protected]>. Using the same
+     procedure as for FreeBSD.
+  */
+  struct apm_info apminfo;
+  int fd;
+
+#if defined(__NetBSD__)
+  if (DEBUG) g_print("apm_readinfo() (NetBSD)\n");
+#else /* __OpenBSD__ */
+  if (DEBUG) g_print("apm_readinfo() (OpenBSD)\n");
+#endif
+
+  fd = open(APMDEVICE, O_RDONLY);
+  if (fd == -1)
+  {
+    pm_initialised = 0;
+    return ERR_OPEN_APMDEV;
+  }
+  if (ioctl(fd, APM_IOC_GETPOWER, &apminfo) == -1)
+    err(1, "ioctl(APM_IOC_GETPOWER)");
+  close(fd);
+
+  status->present = TRUE;
+  status->on_ac_power = apminfo.ac_state ? 1 : 0;
+  status->percent = apminfo.battery_life;
+  status->charging = (apminfo.battery_state == 3) ? TRUE : FALSE;
+  status->minutes = apminfo.minutes_left;
+
+  return NULL;
+}
+
+#elif __linux__
+
+#include <apm.h>
+#include "acpi-linux.h"
+
+static struct acpi_info acpiinfo;
+static gboolean using_acpi;
+static int acpi_count;
+static int acpiwatch;
+static struct apm_info apminfo;
+
+/* Declared in acpi-linux.c */
+gboolean acpi_linux_read(struct apm_info *apminfo, struct acpi_info *acpiinfo);
+
+static gboolean acpi_callback (GIOChannel * chan, GIOCondition cond, gpointer data)
+{
+  if (cond & (G_IO_ERR | G_IO_HUP)) {
+    acpi_linux_cleanup(&acpiinfo);
+    apminfo.battery_percentage = -1;
+    return FALSE;
+  }
+  
+  if (acpi_process_event(&acpiinfo)) {
+    acpi_linux_read(&apminfo, &acpiinfo);
+  }
+  return TRUE;
+}
+
+static const char *
+apm_readinfo (BatteryStatus *status)
+{
+  /* Code for Linux by Thomas Hood <[email protected]>. apm_read() will
+     read from /proc/... instead and we do not need to open the device
+     ourselves.
+  */
+  if (DEBUG) g_print("apm_readinfo() (Linux)\n");
+
+  /* ACPI support added by Lennart Poettering <[email protected]> 10/27/2001
+   * Updated by David Moore <[email protected]> 5/29/2003 to poll less and
+   *   use ACPI events. */
+  if (using_acpi && acpiinfo.event_fd >= 0) {
+    if (acpi_count <= 0) {
+      /* Only call this one out of 30 calls to apm_readinfo() (every 30 seconds)
+       * since reading the ACPI system takes CPU cycles. */
+      acpi_count=30;
+      acpi_linux_read(&apminfo, &acpiinfo);
+    }
+    acpi_count--;
+  }
+  /* If we lost the file descriptor with ACPI events, try to get it back. */
+  else if (using_acpi) {
+      if (acpi_linux_init(&acpiinfo)) {
+          acpiwatch = g_io_add_watch (acpiinfo.channel,
+              G_IO_IN | G_IO_ERR | G_IO_HUP,
+              acpi_callback, NULL);
+          acpi_linux_read(&apminfo, &acpiinfo);
+      }
+  }
+  else
+    apm_read(&apminfo);
+
+  status->present = TRUE;
+  status->on_ac_power = apminfo.ac_line_status ? 1 : 0;
+  status->percent = (guint) apminfo.battery_percentage;
+  status->charging = (apminfo.battery_flags & 0x8) ? TRUE : FALSE;
+  status->minutes = apminfo.battery_time;
+
+  return NULL;
+}
+
+#else
+
+static const char *
+apm_readinfo (BatteryStatus *status)
+{
+  status->present = FALSE;
+  status->on_ac_power = 1;
+  status->percent = 100;
+  status->charging = FALSE;
+  status->minutes = 0;
+
+  return ERR_NO_SUPPORT;
+}
+
+#endif
+
+/*
+ * End platform-specific code.
+ */
+
+/*
+ * power_management_getinfo
+ *
+ * Main interface to the power management code.  Fills 'status' for you so
+ * you don't have to worry about platform-specific details.
+ *
+ * In the case of success, NULL is returned.  In case of failure, a
+ * localised error message is returned to give the user hints about what
+ * the problem might be.  This error message is not to be freed.
+ */
+const char *
+power_management_getinfo( BatteryStatus *status )
+{
+  const char *retval;
+
+  if( !pm_initialised )
+  {
+    status->on_ac_power = TRUE;
+    status->minutes = -1;
+    status->percent = 0;
+    status->charging = FALSE;
+    status->present = FALSE;
+
+    return NULL;
+  }
+
+#ifdef HAVE_HAL
+  if( using_hal )
+  {
+    battstat_hal_get_battery_info( status );
+    return NULL;
+  }
+#endif
+
+  retval = apm_readinfo( status );
+
+  if(status->percent == -1) {
+    status->percent = 0;
+    status->present = FALSE;
+  }
+
+  if(status->percent > 100)
+    status->percent = 100;
+
+  if(status->percent == 100)
+    status->charging = FALSE;
+
+  if(!status->on_ac_power)
+    status->charging = FALSE;
+
+  return retval;
+}
+
+/*
+ * power_management_initialise
+ *
+ * Initialise the power management code.  Call this before you call anything
+ * else.
+ *
+ * In the case of success, NULL is returned.  In case of failure, a
+ * localised error message is returned to give the user hints about what
+ * the problem might be.  This error message is not to be freed.
+ */
+const char *
+power_management_initialise (int no_hal, void (*callback) (void))
+{
+#ifdef __linux__
+  struct stat statbuf;
+#endif
+#ifdef HAVE_HAL
+  char *err;
+
+  if( no_hal )
+    err = g_strdup( ":(" );
+  else
+    err = battstat_hal_initialise (callback);
+
+
+  if( err == NULL ) /* HAL is up */
+  {
+    pm_initialised = 1;
+    using_hal = TRUE;
+    return NULL;
+  }
+  else
+    /* fallback to legacy methods */
+    g_free( err );
+#endif
+    
+#ifdef __linux__
+
+  if (acpi_linux_init(&acpiinfo)) {
+    using_acpi = TRUE;
+    acpi_count = 0;
+  }
+  else
+    using_acpi = FALSE;
+
+  /* If neither ACPI nor APM could be read, but ACPI does seem to be
+   * installed, warn the user how to get ACPI working. */
+  if (!using_acpi && (apm_exists() == 1) &&
+          (stat("/proc/acpi", &statbuf) == 0)) {
+    using_acpi = TRUE;
+    acpi_count = 0;
+    return ERR_ACPID;
+  }
+
+  /* Watch for ACPI events and handle them immediately with acpi_callback(). */
+  if (using_acpi && acpiinfo.event_fd >= 0) {
+    acpiwatch = g_io_add_watch (acpiinfo.channel,
+        G_IO_IN | G_IO_ERR | G_IO_HUP,
+        acpi_callback, NULL);
+  }
+#elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
+  if (acpi_freebsd_init(&acpiinfo)) {
+    using_acpi = TRUE;
+    acpi_count = 0;
+  }
+  else
+    using_acpi = FALSE;
+#endif
+  pm_initialised = 1;
+
+  return NULL;
+}
+
+/*
+ * power_management_cleanup
+ *
+ * Perform any cleanup that might be required.
+ */
+void
+power_management_cleanup( void )
+{
+#ifdef HAVE_HAL
+  if( using_hal )
+  {
+    battstat_hal_cleanup();
+    pm_initialised = 1;
+    return;
+  }
+#endif
+
+#ifdef __linux__
+  if (using_acpi)
+  {
+    if (acpiwatch != 0)
+      g_source_remove(acpiwatch);
+     acpiwatch = 0;
+     acpi_linux_cleanup(&acpiinfo);
+  }
+#elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
+  if (using_acpi) {
+    acpi_freebsd_cleanup(&acpiinfo);
+  }
+#endif
+
+  pm_initialised = 0;
+}
+
+int
+power_management_using_hal( void )
+{
+#ifdef HAVE_HAL
+  return using_hal;
+#else
+  return 0;
+#endif
+}