static ssize_t battery_read_supply(struct kobj_t * kobj, void * buf, size_t size)
{
struct battery_t * bat = (struct battery_t *)kobj->priv;
struct battery_info_t info;
char * supply = "unknown";
if(battery_update(bat, &info))
{
switch(info.supply)
{
case POWER_SUPPLAY_BATTERY:
supply = "battery";
break;
case POWER_SUPPLAY_AC:
supply = "ac";
break;
case POWER_SUPPLAY_USB:
supply = "usb";
break;
case POWER_SUPPLAY_WIRELESS:
supply = "wireless";
break;
default:
break;
}
}
return sprintf(buf, "%s", supply);
}
battery *battery_get() {
GError * error = NULL;
const gchar *entry;
GDir * dir = g_dir_open( ACPI_PATH_SYS_POWER_SUPPY, 0, &error );
battery *b = NULL;
if ( dir == NULL )
{
g_warning( "NO ACPI/sysfs support in kernel: %s", error->message );
return NULL;
}
while ( ( entry = g_dir_read_name (dir) ) != NULL )
{
b = battery_new();
b->path = g_strdup( entry );
battery_update ( b );
if ( b->type_battery == TRUE )
break;
/* ignore non-batteries */
else {
g_free(b);
b = NULL;
}
}
g_dir_close( dir );
return b;
}
static ssize_t battery_read_status(struct kobj_t * kobj, void * buf, size_t size)
{
struct battery_t * bat = (struct battery_t *)kobj->priv;
struct battery_info_t info;
char * status = "unknown";
if(battery_update(bat, &info))
{
switch(info.status)
{
case BATTERY_STATUS_DISCHARGING:
status = "discharging";
break;
case BATTERY_STATUS_CHARGING:
status = "charging";
break;
case BATTERY_STATUS_FULL:
status = "full";
break;
default:
break;
}
}
return sprintf(buf, "%s", status);
}
static ssize_t battery_read_health(struct kobj_t * kobj, void * buf, size_t size)
{
struct battery_t * bat = (struct battery_t *)kobj->priv;
struct battery_info_t info;
char * health = "unknown";
if(battery_update(bat, &info))
{
switch(info.health)
{
case BATTERY_HEALTH_GOOD:
health = "good";
break;
case BATTERY_HEALTH_DEAD:
health = "dead";
break;
case BATTERY_HEALTH_OVERHEAT:
health = "overheat";
break;
case BATTERY_HEALTH_OVERVOLTAGE:
health = "overvoltage";
break;
default:
break;
}
}
return sprintf(buf, "%s", health);
}
static void
battery_cb(struct ev_loop *loop, ev_timer *w, int revents)
{
(void) loop;
(void) revents;
BatteryInfo *info = (BatteryInfo *)w->data;
battery_update(info);
}
static ssize_t battery_read_level(struct kobj_t * kobj, void * buf, size_t size)
{
struct battery_t * bat = (struct battery_t *)kobj->priv;
struct battery_info_t info;
if(battery_update(bat, &info))
return sprintf(buf, "%d", info.level);
return sprintf(buf, "%d", 0);
}
int
main(int argc, char *argv[])
{
int ret = 1;
int fd = -1;
char *udi;
char device_file[HAL_PATH_MAX] = "/devices";
char *devfs_path;
LibHalContext *ctx = NULL;
DBusError error;
if ((udi = getenv("UDI")) == NULL)
goto out;
if ((devfs_path = getenv("HAL_PROP_SOLARIS_DEVFS_PATH")) == NULL)
goto out;
strlcat(device_file, devfs_path, HAL_PATH_MAX);
setup_logger();
dbus_error_init(&error);
if ((ctx = libhal_ctx_init_direct(&error)) == NULL)
goto out;
HAL_DEBUG(("Doing probe-battery for %s (udi=%s)",
device_file, udi));
if ((fd = open(device_file, O_RDONLY | O_NONBLOCK)) < 0) {
HAL_DEBUG(("Cannot open %s: %s", device_file, strerror(errno)));
goto out;
}
if (strstr(udi, "ac")) {
ac_adapter_update(ctx, udi, fd);
} else {
battery_update(ctx, udi, fd);
}
ret = 0;
out:
if (fd >= 0) {
close(fd);
}
if (ctx != NULL) {
libhal_ctx_shutdown(ctx, &error);
libhal_ctx_free(ctx);
if (dbus_error_is_set(&error)) {
dbus_error_free(&error);
}
}
return (ret);
}
static int
battery_constructor(plugin_instance *p)
{
battery_priv *c;
ENTER;
if (!(k = class_get("meter")))
RET(0);
if (!PLUGIN_CLASS(k)->constructor(p))
RET(0);
c = (battery_priv *) p;
c->timer = g_timeout_add(2000, (GSourceFunc) battery_update, c);
battery_update(c);
RET(1);
}
static void
battery_refresh(struct sysmon_envsys *sme, envsys_data_t *edata)
{
struct battery_softc *sc = sme->sme_cookie;
int which = edata->sensor;
battery_update(sc, 0);
switch (which) {
case BAT_CPU_TEMPERATURE:
edata->value_cur = sc->sc_cpu_temp * 1000000 + 273150000;
break;
case BAT_AC_PRESENT:
edata->value_cur = (sc->sc_flags & PMU_PWR_AC_PRESENT);
break;
case BAT_PRESENT:
edata->value_cur = (sc->sc_flags & PMU_PWR_BATT_PRESENT);
break;
case BAT_VOLTAGE:
edata->value_cur = sc->sc_voltage * 1000;
break;
case BAT_CURRENT:
edata->value_cur = sc->sc_current * 1000;
break;
case BAT_CHARGE:
edata->value_cur = sc->sc_charge;
break;
case BAT_MAX_CHARGE:
edata->value_cur = 100;
break;
case BAT_TEMPERATURE:
edata->value_cur = sc->sc_bat_temp * 1000000 + 273150000;
break;
case BAT_CHARGING:
if ((sc->sc_flags & PMU_PWR_BATT_CHARGING) &&
(sc->sc_flags & PMU_PWR_AC_PRESENT))
edata->value_cur = 1;
else
edata->value_cur = 0;
break;
case BAT_FULL:
edata->value_cur = (sc->sc_flags & PMU_PWR_BATT_FULL);
break;
}
edata->state = ENVSYS_SVALID;
}
static void
battery_poll(void *cookie)
{
struct battery_softc *sc = cookie;
battery_update(sc, 0);
if ((sc->sc_flags & PMU_PWR_AC_PRESENT) == sc->sc_oflags)
return;
sc->sc_oflags = sc->sc_flags & PMU_PWR_AC_PRESENT;
sysmon_pswitch_event(&sc->sc_sm_acpower,
sc->sc_oflags ? PSWITCH_EVENT_PRESSED :
PSWITCH_EVENT_RELEASED);
}
void gui_set_debug_action(uint8_t index)
{
switch(index)
{
// case(3):
// gui_dialog_set_P(PSTR("Confirmation"), PSTR("Do you want to\nreset Factory\ntest?"), GUI_STYLE_YESNO, gui_set_debug_reset_fc);
// gui_switch_task(GUI_DIALOG);
// break;
case(2):
battery_update();
break;
case(4):
if (config.system.debug_log == DEBUG_MAGIC_ON)
config.system.debug_log = 0;
else
config.system.debug_log = DEBUG_MAGIC_ON;
eeprom_busy_wait();
eeprom_update_byte(&config_ee.system.debug_log, config.system.debug_log);
break;
case(5):
gui_dialog_set_P(PSTR("Confirmation"), PSTR("Clear\ndebug.log?"), GUI_STYLE_YESNO, gui_set_debug_delete_fc);
gui_switch_task(GUI_DIALOG);
break;
case(6):
config.system.debug_gps = !config.system.debug_gps;
eeprom_busy_wait();
eeprom_update_byte(&config_ee.system.debug_gps, config.system.debug_gps);
break;
case(8):
config.system.record_screen = !config.system.record_screen;
eeprom_busy_wait();
eeprom_update_byte(&config_ee.system.record_screen, config.system.record_screen);
break;
}
}
static void
battery_attach(struct device *parent, struct device *self, void *aux)
{
struct battery_attach_args *baa = aux;
struct battery_softc *sc = (struct battery_softc *)self;
uint32_t reg;
sc->sc_pmu_ops = baa->baa_pmu_ops;
printf(": legacy battery ");
reg = in32rb(0xf3000034);
DPRINTF("reg: %08x\n", reg);
if (reg & 0x20000000) {
sc->sc_type = BTYPE_HOOPER;
sc->sc_vmax_charged = 330;
sc->sc_vmax_charging = 365;
printf("[hooper]\n");
} else {
sc->sc_type = BTYPE_COMET;
sc->sc_vmax_charged = 189;
sc->sc_vmax_charging = 213;
printf("[comet]\n");
}
battery_update(sc, 1);
/* trigger a status update */
sc->sc_oflags = ~sc->sc_flags;
battery_setup_envsys(sc);
sc->sc_pmu_ops->register_callback(sc->sc_pmu_ops->cookie, battery_poll,
sc);
memset(&sc->sc_sm_acpower, 0, sizeof(struct sysmon_pswitch));
sc->sc_sm_acpower.smpsw_name = "AC Power";
sc->sc_sm_acpower.smpsw_type = PSWITCH_TYPE_ACADAPTER;
if (sysmon_pswitch_register(&sc->sc_sm_acpower) != 0)
printf("%s: unable to register AC power status with sysmon\n",
sc->sc_dev.dv_xname);
}
int main(void)
{
init();
sei();
if(wdt_wasReset())
resetError();
buzzer_buzz(200, TONE_4KHZ, VOL_UI);
led_flash(LED_GREEN, 50, 255);
watchface_setFace(watchface_normal);
watchface_loadFace();
/*
while(1)
{
buzzer_buzzb(200,TONE_5KHZ, VOL_UI);
buzzer_buzzb(200,TONE_4KHZ, VOL_UI);
buzzer_buzzb(200,TONE_2_5KHZ, VOL_UI);
buzzer_buzzb(200,TONE_2KHZ, VOL_UI);
buzzer_buzzb(200,TONE_4KHZ, VOL_UI);
buzzer_buzzb(200,TONE_5KHZ, VOL_UI);
buzzer_buzzb(200,TONE_2_5KHZ, VOL_UI);
buzzer_buzzb(200,TONE_2KHZ, VOL_UI);
buzzer_buzzb(200,TONE_3_5KHZ, VOL_UI);
buzzer_buzzb(200,TONE_4KHZ, VOL_UI);
buzzer_buzzb(200,TONE_3KHZ, VOL_UI);
buzzer_buzzb(250,TONE_2KHZ, VOL_UI);
buzzer_buzzb(250,TONE_2KHZ, VOL_UI);
buzzer_buzzb(200,TONE_4KHZ, VOL_UI);
buzzer_buzzb(200,TONE_4KHZ, VOL_UI);
}
*/
while(1)
{
bool timeUpt = time_update();
if(pwrmgr_userActive())
{
if(timeUpt && timeData.secs == 0)
battery_update();
buttons_update();
}
buzzer_update();
led_update();
stopwatch_update();
if(pwrmgr_userActive())
{
alarm_update();
display_update();
}
// freeRAM();
wdt_update();
pwrmgr_update();
}
}
battery *battery_get(int battery_number) {
GError * error = NULL;
const gchar *entry;
gchar *batt_name = NULL;
gchar *batt_path = NULL;
GDir * dir;
battery *b = NULL;
/* Try the expected path in sysfs first */
batt_name = g_strdup_printf(ACPI_BATTERY_DEVICE_NAME "%d", battery_number);
batt_path = g_strdup_printf(ACPI_PATH_SYS_POWER_SUPPLY "/%s", batt_name);
if (g_file_test(batt_path, G_FILE_TEST_IS_DIR) == TRUE) {
b = battery_new();
b->path = g_strdup( batt_name);
battery_update ( b );
if (!b->type_battery) {
g_warning( "Not a battery: %s", batt_path );
battery_free(b);
b = NULL;
}
}
g_free(batt_name);
g_free(batt_path);
if (b != NULL)
return b;
/*
* We didn't find the expected path in sysfs.
* Walk the dir and return any battery.
*/
dir = g_dir_open( ACPI_PATH_SYS_POWER_SUPPLY, 0, &error );
if ( dir == NULL )
{
g_warning( "NO ACPI/sysfs support in kernel: %s", error->message );
g_error_free(error);
return NULL;
}
while ( ( entry = g_dir_read_name (dir) ) != NULL )
{
b = battery_new();
b->path = g_strdup( entry );
battery_update ( b );
/* We're looking for a battery with the selected ID */
if (b->type_battery == TRUE) {
break;
}
battery_free(b);
b = NULL;
}
if (b != NULL)
g_warning( "Battery entry " ACPI_BATTERY_DEVICE_NAME "%d not found, using %s",
battery_number, b->path);
// FIXME: update config?
else
g_warning( "Battery %d not found", battery_number );
g_dir_close( dir );
return b;
}
