diff options
Diffstat (limited to 'src/freebsd/up-device-supply.c')
| -rw-r--r-- | src/freebsd/up-device-supply.c | 542 |
1 files changed, 542 insertions, 0 deletions
diff --git a/src/freebsd/up-device-supply.c b/src/freebsd/up-device-supply.c new file mode 100644 index 0000000..69eb092 --- /dev/null +++ b/src/freebsd/up-device-supply.c @@ -0,0 +1,542 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- + * + * Copyright (C) 2009 Joe Marcus Clarke <marcus@FreeBSD.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 St, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#include "config.h" + +#include <string.h> +#include <math.h> +#include <string.h> +#include <errno.h> +#include <fcntl.h> +#include <limits.h> +#include <unistd.h> +#include <sys/ioctl.h> +#include <sys/types.h> +#include <dev/acpica/acpiio.h> + +#include <glib.h> +#include <glib/gstdio.h> +#include <glib/gprintf.h> +#include <glib/gi18n-lib.h> +#include <glib-object.h> + +#include "up-acpi-native.h" +#include "up-util.h" + +#include "egg-debug.h" + +#include "up-enum.h" +#include "up-device-supply.h" + +#define DKP_ACPIDEV "/dev/acpi" + +G_DEFINE_TYPE (DkpDeviceSupply, dkp_device_supply, DKP_TYPE_DEVICE) + +static gboolean dkp_device_supply_refresh (DkpDevice *device); +static DkpDeviceTechnology dkp_device_supply_convert_device_technology (const gchar *type); +static gboolean dkp_device_supply_acline_coldplug (DkpDevice *device); +static gboolean dkp_device_supply_battery_coldplug (DkpDevice *device, DkpAcpiNative *native); +static gboolean dkp_device_supply_acline_set_properties (DkpDevice *device); +static gboolean dkp_device_supply_battery_set_properties (DkpDevice *device, DkpAcpiNative *native); +static gboolean dkp_device_supply_get_on_battery (DkpDevice *device, gboolean *on_battery); +static gboolean dkp_device_supply_get_low_battery (DkpDevice *device, gboolean *low_battery); +static gboolean dkp_device_supply_get_online (DkpDevice *device, gboolean *online); + +/** + * dkp_device_supply_convert_device_technology: + * + * This is taken from linux/dkp-device-supply.c. + **/ +static DkpDeviceTechnology +dkp_device_supply_convert_device_technology (const gchar *type) +{ + if (type == NULL) + return DKP_DEVICE_TECHNOLOGY_UNKNOWN; + if (g_ascii_strcasecmp (type, "li-ion") == 0 || + g_ascii_strcasecmp (type, "lion") == 0) + return DKP_DEVICE_TECHNOLOGY_LITHIUM_ION; + if (g_ascii_strcasecmp (type, "pb") == 0 || + g_ascii_strcasecmp (type, "pbac") == 0) + return DKP_DEVICE_TECHNOLOGY_LEAD_ACID; + if (g_ascii_strcasecmp (type, "lip") == 0 || + g_ascii_strcasecmp (type, "lipo") == 0 || + g_ascii_strcasecmp (type, "li-poly") == 0) + return DKP_DEVICE_TECHNOLOGY_LITHIUM_POLYMER; + if (g_ascii_strcasecmp (type, "nimh") == 0) + return DKP_DEVICE_TECHNOLOGY_NICKEL_METAL_HYDRIDE; + if (g_ascii_strcasecmp (type, "lifo") == 0) + return DKP_DEVICE_TECHNOLOGY_LITHIUM_IRON_PHOSPHATE; + return DKP_DEVICE_TECHNOLOGY_UNKNOWN; +} + +/** + * dkp_device_supply_reset_values: + **/ +static void +dkp_device_supply_reset_values (DkpDevice *device) +{ + /* reset to default */ + g_object_set (device, + "vendor", NULL, + "model", NULL, + "serial", NULL, + "update-time", (guint64) 0, + "power-supply", FALSE, + "online", FALSE, + "energy", (gdouble) 0.0, + "is-present", FALSE, + "is-rechargeable", FALSE, + "has-history", FALSE, + "has-statistics", FALSE, + "state", DKP_DEVICE_STATE_UNKNOWN, + "capacity", (gdouble) 0.0, + "energy-empty", (gdouble) 0.0, + "energy-full", (gdouble) 0.0, + "energy-full-design", (gdouble) 0.0, + "energy-rate", (gdouble) 0.0, + "voltage", (gdouble) 0.0, + "time-to-empty", (guint64) 0, + "time-to-full", (guint64) 0, + "percentage", (gdouble) 0.0, + "technology", DKP_DEVICE_TECHNOLOGY_UNKNOWN, + NULL); +} + +/** + * dkp_device_supply_acline_coldplug: + **/ +static gboolean +dkp_device_supply_acline_coldplug (DkpDevice *device) +{ + gboolean ret; + + g_object_set (device, + "online", FALSE, + "power-supply", TRUE, + "type", DKP_DEVICE_TYPE_LINE_POWER, + NULL); + + ret = dkp_device_supply_acline_set_properties (device); + + return ret; +} + +/** + * dkp_device_supply_battery_coldplug: + **/ +static gboolean +dkp_device_supply_battery_coldplug (DkpDevice *device, DkpAcpiNative *native) +{ + gboolean ret; + + g_object_set (device, "type", DKP_DEVICE_TYPE_BATTERY, NULL); + ret = dkp_device_supply_battery_set_properties (device, native); + + return ret; +} + +/** + * dkp_device_supply_battery_set_properties: + **/ +static gboolean +dkp_device_supply_battery_set_properties (DkpDevice *device, DkpAcpiNative *native) +{ + gint fd; + gdouble volt, dvolt, rate, lastfull, cap, dcap, lcap, capacity; + gboolean is_present; + gboolean ret = FALSE; + guint64 time_to_empty, time_to_full; + gchar *vendor, *model, *serial; + DkpDeviceTechnology technology; + DkpDeviceState state; + union acpi_battery_ioctl_arg battif, battst, battinfo; + + if (!dkp_has_sysctl ("hw.acpi.battery.units")) + return FALSE; + + battif.unit = battst.unit = battinfo.unit = + dkp_acpi_native_get_unit (native); + fd = open (DKP_ACPIDEV, O_RDONLY); + if (fd < 0) { + egg_warning ("unable to open %s: '%s'", DKP_ACPIDEV, g_strerror (errno)); + return FALSE; + } + + if (ioctl (fd, ACPIIO_BATT_GET_BIF, &battif) == -1) { + egg_warning ("ioctl ACPIIO_BATT_GET_BIF failed for battery %d: '%s'", battif.unit, g_strerror (errno)); + goto end; + } + + if (ioctl (fd, ACPIIO_BATT_GET_BST, &battst) == -1) { + egg_warning ("ioctl ACPIIO_BATT_GET_BST failed for battery %d: '%s'", battst.unit, g_strerror (errno)); + goto end; + } + + if (ioctl (fd, ACPIIO_BATT_GET_BATTINFO, &battinfo) == -1) { + egg_warning ("ioctl ACPIIO_BATT_GET_BATTINFO failed for battery %d: '%s'", battinfo.unit, g_strerror (errno)); + goto end; + } + + ret = TRUE; + + is_present = (battst.bst.state == ACPI_BATT_STAT_NOT_PRESENT) ? FALSE : TRUE; + g_object_set (device, "is-present", is_present, NULL); + + if (!is_present) { + dkp_device_supply_reset_values (device); + goto end; + } + + vendor = dkp_make_safe_string (battif.bif.oeminfo); + model = dkp_make_safe_string (battif.bif.model); + serial = dkp_make_safe_string (battif.bif.serial); + technology = dkp_device_supply_convert_device_technology (battif.bif.type); + + g_object_set (device, + "vendor", vendor, + "model", model, + "serial", serial, + "power-supply", TRUE, + "technology", technology, + "has-history", TRUE, + "has-statistics", TRUE, + NULL); + g_free (vendor); + g_free (model); + g_free (serial); + + g_object_set (device, "is-rechargeable", + battif.bif.btech == 0 ? FALSE : TRUE, NULL); + + volt = (gdouble) battst.bst.volt; + dvolt = (gdouble) battif.bif.dvol; + lastfull = (gdouble) battif.bif.lfcap; + dcap = (gdouble) battif.bif.dcap; + rate = (gdouble) battst.bst.rate; + cap = (gdouble) battst.bst.cap; + lcap = (gdouble) battif.bif.lcap; + if (rate == 0xffff) + rate = 0.0f; + if (rate > 100.0f * 1000.0f) + rate = 0.0f; + + dvolt /= 1000.0f; + volt /= 1000.0f; + + if (battif.bif.units == ACPI_BIF_UNITS_MA) { + if (dvolt <= 0.0f) + dvolt = 1.0f; + if (volt <= 0.0f || volt > dvolt) + volt = dvolt; + + dcap *= volt; + lastfull *= volt; + rate *= volt; + cap *= volt; + lcap *= volt; + } + + dcap /= 1000.0f; + lastfull /= 1000.0f; + rate /= 1000.0f; + cap /= 1000.0f; + lcap /= 1000.0f; + + if (cap == 0.0f) + rate = 0.0f; + + capacity = 0.0f; + if (lastfull > 0 && dcap > 0) { + capacity = (lastfull / dcap) * 100.0f; + if (capacity < 0) + capacity = 0.0f; + if (capacity > 100.0) + capacity = 100.0f; + } + + g_object_set (device, + "percentage", (gdouble) battinfo.battinfo.cap, + "energy", cap, + "energy-full", lastfull, + "energy-full-design", dcap, + "energy-rate", rate, + "energy-empty", lcap, + "voltage", volt, + "capacity", capacity, + NULL); + + time_to_empty = 0; + time_to_full = 0; + + if (battinfo.battinfo.state & ACPI_BATT_STAT_DISCHARG) { + state = DKP_DEVICE_STATE_DISCHARGING; + if (battinfo.battinfo.min > 0) + time_to_empty = battinfo.battinfo.min * 60; + else if (rate > 0) { + time_to_empty = 3600 * (cap / rate); + if (time_to_empty > (20 * 60 * 60)) + time_to_empty = 0; + } + } else if (battinfo.battinfo.state & ACPI_BATT_STAT_CHARGING) { + state = DKP_DEVICE_STATE_CHARGING; + if (battinfo.battinfo.min > 0) + time_to_full = battinfo.battinfo.min * 60; + else if (rate > 0) { + time_to_full = 3600 * ((lastfull - cap) / rate); + if (time_to_full > (20 * 60 * 60)) + time_to_full = 0; + } + } else if (battinfo.battinfo.state & ACPI_BATT_STAT_CRITICAL) { + state = DKP_DEVICE_STATE_EMPTY; + } else if (battinfo.battinfo.state == 0) { + state = DKP_DEVICE_STATE_FULLY_CHARGED; + } else { + state = DKP_DEVICE_STATE_UNKNOWN; + } + + g_object_set (device, + "state", state, + "time-to-empty", time_to_empty, + "time-to-full", time_to_full, + NULL); + +end: + close (fd); + return ret; +} + +/** + * dkp_device_supply_acline_set_properties: + **/ +static gboolean +dkp_device_supply_acline_set_properties (DkpDevice *device) +{ + int acstate; + + if (dkp_get_int_sysctl (&acstate, NULL, "hw.acpi.acline")) { + g_object_set (device, "online", acstate ? TRUE : FALSE, NULL); + return TRUE; + } + + return FALSE; +} + +/** + * dkp_device_supply_coldplug: + * Return %TRUE on success, %FALSE if we failed to get data and should be removed + **/ +static gboolean +dkp_device_supply_coldplug (DkpDevice *device) +{ + DkpAcpiNative *native; + const gchar *native_path; + const gchar *driver; + gboolean ret = FALSE; + + dkp_device_supply_reset_values (device); + + native = DKP_ACPI_NATIVE (dkp_device_get_native (device)); + native_path = dkp_acpi_native_get_path (native); + driver = dkp_acpi_native_get_driver (native); + if (native_path == NULL) { + egg_warning ("could not get native path for %p", device); + goto out; + } + + if (!strcmp (native_path, "hw.acpi.acline")) { + ret = dkp_device_supply_acline_coldplug (device); + goto out; + } + + if (!g_strcmp0 (driver, "battery")) { + ret = dkp_device_supply_battery_coldplug (device, native); + goto out; + } + + egg_warning ("invalid device %s with driver %s", native_path, driver); + +out: + return ret; +} + +/** + * dkp_device_supply_refresh: + * + * Return %TRUE on success, %FALSE if we failed to refresh or no data + **/ +static gboolean +dkp_device_supply_refresh (DkpDevice *device) +{ + GObject *object; + GTimeVal timeval; + DkpDeviceType type; + gboolean ret; + + g_object_get (device, "type", &type, NULL); + switch (type) { + case DKP_DEVICE_TYPE_LINE_POWER: + ret = dkp_device_supply_acline_set_properties (device); + break; + case DKP_DEVICE_TYPE_BATTERY: + object = dkp_device_get_native (device); + ret = dkp_device_supply_battery_set_properties (device, DKP_ACPI_NATIVE (object)); + break; + default: + g_assert_not_reached (); + break; + } + + if (ret) { + g_get_current_time (&timeval); + g_object_set (device, "update-time", (guint64) timeval.tv_sec, NULL); + } + + return ret; +} + +/** + * dkp_device_supply_get_on_battery: + **/ +static gboolean +dkp_device_supply_get_on_battery (DkpDevice *device, gboolean *on_battery) +{ + DkpDeviceType type; + DkpDeviceState state; + gboolean is_present; + + g_return_val_if_fail (on_battery != NULL, FALSE); + + g_object_get (device, + "type", &type, + "state", &state, + "is-present", &is_present, + NULL); + + if (type != DKP_DEVICE_TYPE_BATTERY) + return FALSE; + if (state == DKP_DEVICE_STATE_UNKNOWN) + return FALSE; + if (!is_present) + return FALSE; + + *on_battery = (state == DKP_DEVICE_STATE_DISCHARGING); + return TRUE; +} + +/** + * dkp_device_supply_get_low_battery: + **/ +static gboolean +dkp_device_supply_get_low_battery (DkpDevice *device, gboolean *low_battery) +{ + gboolean ret; + gboolean on_battery; + gdouble percentage; + + g_return_val_if_fail (low_battery != NULL, FALSE); + + ret = dkp_device_supply_get_on_battery (device, &on_battery); + if (!ret) + return FALSE; + + if (!on_battery) { + *low_battery = FALSE; + return TRUE; + } + + g_object_get (device, "percentage", &percentage, NULL); + *low_battery = (percentage < 10.0f); + return TRUE; +} + +/** + * dkp_device_supply_get_online: + **/ +static gboolean +dkp_device_supply_get_online (DkpDevice *device, gboolean *online) +{ + DkpDeviceType type; + gboolean online_tmp; + + g_return_val_if_fail (online != NULL, FALSE); + + g_object_get (device, + "type", &type, + "online", &online_tmp, + NULL); + + if (type != DKP_DEVICE_TYPE_LINE_POWER) + return FALSE; + + *online = online_tmp; + + return TRUE; +} + +/** + * dkp_device_supply_init: + **/ +static void +dkp_device_supply_init (DkpDeviceSupply *supply) +{ +} + +/** + * dkp_device_supply_finalize: + **/ +static void +dkp_device_supply_finalize (GObject *object) +{ + DkpDeviceSupply *supply; + + g_return_if_fail (object != NULL); + g_return_if_fail (DKP_IS_SUPPLY (object)); + + supply = DKP_DEVICE_SUPPLY (object); + + G_OBJECT_CLASS (dkp_device_supply_parent_class)->finalize (object); +} + +/** + * dkp_device_supply_class_init: + **/ +static void +dkp_device_supply_class_init (DkpDeviceSupplyClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + DkpDeviceClass *device_class = DKP_DEVICE_CLASS (klass); + + object_class->finalize = dkp_device_supply_finalize; + device_class->get_on_battery = dkp_device_supply_get_on_battery; + device_class->get_low_battery = dkp_device_supply_get_low_battery; + device_class->get_online = dkp_device_supply_get_online; + device_class->coldplug = dkp_device_supply_coldplug; + device_class->refresh = dkp_device_supply_refresh; +} + +/** + * dkp_device_supply_new: + **/ +DkpDeviceSupply * +dkp_device_supply_new (void) +{ + return g_object_new (DKP_TYPE_SUPPLY, NULL); +} + |