system.c

Go to the documentation of this file.

/*
 * File Name: system.c
 */

/*
 * This file is part of sysd.
 *
 * sysd 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.
 *
 * sysd 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, see <http://www.gnu.org/licenses/>.
 */

/**
 * Copyright (C) 2008 iRex Technologies B.V.
 * All rights reserved.
 */

//----------------------------------------------------------------------------
// Include Files
//----------------------------------------------------------------------------

#include "config.h" 

// system include files, between < >
#include <glib.h>
#include <hal/libhal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h> 
#include <unistd.h>
#include <dirent.h>
#include <fcntl.h>
#include <sys/statvfs.h>

// ereader include files, between < >
#include <liberipc/eripc.h>
#include <liberutils/display_utils.h>

// local include files, between " "
#include "log.h"
#include "connections.h"
#include "busy.h"
#include "conf.h"
#include "display.h"
#include "hal.h"
#include "ipc.h"
#include "wacom.h"
#include "xwindow.h"
#include "tasks.h"


//----------------------------------------------------------------------------
// Type Declarations
//----------------------------------------------------------------------------

enum state_usb
{
    STATE_USB_UNKNOWN = 0,
    STATE_USB_DISCONNECT_PENDING,
    STATE_USB_DISCONNECTED,
    STATE_USB_UNMOUNTED,
    STATE_USB_MOUNT_CONFIRM,
    STATE_USB_MOUNT_PENDING,
    STATE_USB_MOUNTED
};


//----------------------------------------------------------------------------
// Global Constants
//----------------------------------------------------------------------------

#define AUTOINSTALL_FILE            "autoinstall"
#define UPDATE_PATH                 MOUNTPOINT_CARD "/System/Update/"
#define UPDATE_FILE                 UPDATE_PATH "update.dat"
#define UPDATE_AUTO_FILE            UPDATE_PATH AUTOINSTALL_FILE
#define DRZ_PATH                    MOUNTPOINT_CARD "/System/drz/"
#define DRZ_AUTO_FILE               DRZ_PATH AUTOINSTALL_FILE

#define DEMO_FILE                   "slideshow.pdf"
#define DEMO_FLIP_INTERVAL          8

#define DRZINSTALL_TOOL             "/usr/bin/drzinstall"
#define MDB_INDEXER                 "/usr/bin/mdbindex"
#define ADOBE_SYNC                  "/usr/bin/adobe-sync.sh"

#define USB_DEVICE_POLL_INTERVAL    1
#define USB_DEVICE_POLL_TIMEOUT     8 * USB_DEVICE_POLL_INTERVAL
#define USB_DEVICE_ONLINE_DELAY     5

#define BATTERY_LOW_THRESHOLD       5
#define BATTERY_SHUTDOWN_THRESHOLD  2
#define BATTERY_FULL_THRESHOLD      100
 
#define IDLE_TIMEOUT_SEC            5
#define PREPARE_STANDBY_TIMEOUT_MS  2500
#define CHECK_STANDBY_TIMEOUT_MS    500
#define HOLDOFF_STANDBY_TIMEOUT     10

// Hardware Change bits
#define ST_HW_COVER    (1 << 4)
#define ST_HW_CARD     (1 << 6)
#define ST_HW_USB      (1 << 7)

// Wakeup reasons - taken from ionkdb-private.h
#define WAKEUP_NO_REASON       0  // unknown
#define WAKEUP_KEY             1  // sensor pressed
#define WAKEUP_PEN             2  // wacom pen detected
#define WAKEUP_TIMER           3  // standby timer
#define WAKEUP_BATTERY         4  // battery level update
#define WAKEUP_COVER           5  // cover state change
#define WAKEUP_CARD            6  // mmc card state change
#define WAKEUP_USB             7  // usb state change
#define WAKEUP_CHARGE_DETECTED 8  // charge state change

const char *sys_devices         = "/sys/devices";
const char *micro_device_name   = "serio";
const char *lun_device_name     = "gadget-lun";
const char *sysset_device_name  = "sysset0";
const char *power_device_name   = "ionpower";
const char *usb_device_name     = "fsl-usb2-udc";

static const gint SD_FREE_MB_WARN_LEVEL   = 10;

#define read_ionkbd(file, ...)      read_sysfs(g_serio,   file, __VA_ARGS__)
#define read_sysset(file, ...)      read_sysfs(g_sysset,  file, __VA_ARGS__)
#define read_power(file, ...)       read_sysfs(g_power,   file, __VA_ARGS__)
#define read_usb(file, ...)         read_sysfs(g_usb,     file, __VA_ARGS__)
#define read_lun(file, ...)         read_sysfs(g_lun,     file, __VA_ARGS__)
#define write_ionkbd(file, ...)     write_sysfs(g_serio,  file, __VA_ARGS__)
#define write_power(file, ...)      write_sysfs(g_power,  file, __VA_ARGS__)


//----------------------------------------------------------------------------
// Static Variables
//----------------------------------------------------------------------------

static enum state_device     device_state    = STATE_DEVICE_STARTING;
static enum state_charge     charge_state    = STATE_CHARGE_UNKNOWN;
static enum state_usb        usb_state       = STATE_USB_UNKNOWN;
static enum state_card       card_state      = STATE_CARD_UNKNOWN;
static enum state_power      power_state     = STATE_POWER_RUN;

static gint                  g_battery_level = 0;
static gchar                 *g_serio        = NULL;
static gchar                 *g_sysset       = NULL;
static gchar                 *g_power        = NULL;
static gchar                 *g_usb          = NULL;
static gchar                 *g_card_device  = NULL;
static gchar                 *g_lun          = NULL;

static enum rotate_direction    g_rotate_direction   = ROTATE_UNKOWN;
static enum display_orientation g_orientation        = ORIENTATION_PORTRAIT;

static gfloat                g_version_micro         = 0.0;
static gint                  g_sensor_disable_config = 0x07; 
static gboolean              g_sensor_locked         = FALSE;
static gboolean              g_sound_enabled         = FALSE;
static gboolean              g_popup_enabled         = TRUE;
static gboolean              g_idle_enabled          = TRUE;
static gboolean              g_standby_if_plugged    = TRUE;
static guint                 g_usb_device_source     = 0;
static guint                 g_volume_unmount_source = 0;
static guint                 g_idle_time_source      = 0;
static guint                 g_standby_timeout_sec   = 30*60;
static guint                 g_holdoff_standby       = 0;
static gboolean              g_index_splash_enabled  = TRUE;
static gboolean              g_index_with_metadata   = TRUE;
static gboolean              g_pageturn_inverted     = FALSE;
static gboolean              g_wallcharger_found     = FALSE;
static gboolean              g_demo_mode             = FALSE;
static gboolean              g_demo_invert_flipbar   = FALSE;


//============================================================================
// Local Function Definition
//============================================================================

static gint          read_sysfs                 (const char *device, const char *filename, const char *format, ...);
static gboolean      write_sysfs                (const char *device, const char *filename,  const char *buffer);
static gchar         *find_dir                  (const char *dir, const char *file, gboolean recurse);

static gboolean      usb_driver_load            (void);
static gboolean      usb_driver_unload          (void);
static void          usb_connection_finish      (void);
static void          usb_set_state              (enum state_usb new_state);
static void          on_usb_connected           (gpointer data);
static gboolean      on_usb_disconnected        (gpointer data);
static gboolean      on_usb_read_device_state   (gpointer data);
static gboolean      on_usb_read_online         (gpointer data);

#if MACHINE_IS_DR800SG || MACHINE_IS_DR800S || MACHINE_IS_DR800SW
static void          prepare_standby            (void);
static gboolean      on_standby                 (gpointer data);
#endif
static void          do_poweroff                (void);
static void          do_idle                    (void);
static void          set_idle_time              (gint time);
static gboolean      on_idle_timeout            (gpointer data);
static gint          get_wakeup_reason          (void);

static enum state_charge get_battery_state      (gint level, gint charging);
static void          update_battery_info        (gint cur_level, enum state_charge cur_state, gboolean force_send);
static gboolean      write_ionkbd_orientation   (gint orientation);
static gboolean      write_ionkbd_battery_alerts(gint l1, gint l2, gint l3, gint l4, gint l5);

static void          on_eject_continue          (gpointer data);
static void          on_poweroff_continue       (gpointer data);
static void          on_restart_continue        (gpointer data);
static void          on_install_drz_ready       (GPid pid, gint status, gpointer data);
static void          report_unmounting_volumes  (void);
static void          check_hardware             (void);
static gboolean      check_and_install_drz      (void);
static void          do_unmount                 (gboolean show_busy, const char *splash, 
                                                 gpointer callback_function, gpointer user_data);


//============================================================================
// Functions Implementation
//============================================================================

void sys_set_services(void)
{
    LOGPRINTF("entry");
    
    // find sysset partition
    //
    g_sysset = find_dir(sys_devices, sysset_device_name, TRUE);
    if (!g_sysset) 
    {
        ERRORPRINTF("%s not found or not unique", sysset_device_name);
    }
    else
    {
        LOGPRINTF("Sysset found at %s", g_sysset);
    }

    // find power
    //
    g_power = find_dir(sys_devices, power_device_name, TRUE);
    if (!g_power) 
    {
        ERRORPRINTF("%s not found or not unique", power_device_name);
    }
    else
    {
        LOGPRINTF("Ionpower found at %s", g_power);
    }
    
    // find micro driver
    //
    g_serio = find_dir(sys_devices, micro_device_name, FALSE);
    if (!g_serio) 
    {
        ERRORPRINTF("%s not found or not unique", micro_device_name);
    }
    else 
    {
        LOGPRINTF("Device micro found as %s", g_serio);
        
        read_ionkbd("micro_ver", "%f", &g_version_micro);
        LOGPRINTF("Micro version %.2f", g_version_micro);
        
        // set battery alert levels
        write_ionkbd_battery_alerts(BATTERY_LOW_THRESHOLD, 13, 38, 63, 88);

        // check battery state at startup
        sys_get_battery(&g_battery_level, &charge_state, NULL);
        
        // update led for battery state
        sys_update_rgb_led();
    }

    // set idle
#if MACHINE_IS_DR1000S || MACHINE_IS_DR1000SW
    if (g_version_micro < 0.34f)
    {
        g_idle_enabled = FALSE;
    }
#endif    
    if (sys_is_emulator())
    {
        g_idle_enabled = FALSE;
    }
    
    if (g_idle_enabled) 
    {
        g_idle_time_source = g_timeout_add_seconds(IDLE_TIMEOUT_SEC, on_idle_timeout, NULL);
    }
}


void sys_starting_finished()
{
    if ((card_state != STATE_CARD_MOUNTED) &&
        (card_state != STATE_CARD_INACCESSIBLE) &&
        (card_state != STATE_CARD_INDEXING))
    {
        ipc_show_splash("nosd");
    }
    
    conf_set_first_boot(FALSE);
    
    // now that everything is up and running, check for USB connection
    check_hardware();
}


void sys_set_idle_mode(gboolean idle_enabled)
{
#if MACHINE_IS_DR1000S || MACHINE_IS_DR1000SW    
    if (g_version_micro < 0.34f)
    {
        g_idle_enabled = FALSE;
    }
    else
#endif    
    if (sys_is_emulator())
    {
        g_idle_enabled = FALSE;
    }
    else
    {
        g_idle_enabled = idle_enabled;
    }
    
    if (g_idle_enabled)
    {
        // start idle timer
        sys_reset_idle_time();
    }
    else
    {
        if (g_idle_time_source)
        {
            g_source_remove(g_idle_time_source);
            g_idle_time_source = 0;
        }
    }
}


void sys_set_standby_time(guint time_sec)
{
    g_standby_timeout_sec = time_sec;
}


void sys_set_standby_mode(gboolean standby_if_plugged)
{
    g_standby_if_plugged = standby_if_plugged;
}


void sys_reset_idle_time()
{
    set_idle_time(0);
}


gboolean sys_set_beeper_config(gboolean use_sound)
{
    LOGPRINTF("entry");
    
    g_sound_enabled = use_sound;
    return TRUE;
}


gboolean sys_set_beeper(gint duration_ms, const char *tone)
{
    LOGPRINTF("entry");
    
    gboolean retval = FALSE;
    char *buffer    = NULL;
    gint beep_pitch = -1;
    
    if (!g_sound_enabled)
    {
        return FALSE;
    }
    
    if (g_ascii_strcasecmp(tone, "high") == 0)
    {
        beep_pitch = 1;
    }
    else if (g_ascii_strcasecmp(tone, "low") == 0)
    {
        beep_pitch = 0;
    }
    else
    {
        WARNPRINTF("Unknown tone: %s", tone);
    }

    if (beep_pitch != -1)
    {
        // Bits 0..6 are length of time to play tone (in units of 10ms)
        // Bit 7 sets high/low tone
        buffer = g_strdup_printf("%d", ((duration_ms / 10) & 0xEF) | ((beep_pitch & 0x01) << 7));
        retval = write_ionkbd("beeper", buffer);
        g_free(buffer);
    }
   
    return retval;
}


gboolean sys_set_rgb_led(enum led_color color, gint flash_ms)
{
    LOGPRINTF("entry");
    
    gboolean retval  = FALSE;
    gchar    *buffer = NULL;
    
    // LED Color values:
    // 0: off  4: red
    // 1: blue 5: magenta
    // 2: green   6: yellow
    // 3: cyan 7: white
    
    // Value 1: LED Color [0..7]
    // Value 2: LED Flash rate (in units of 500ms)

    buffer = g_strdup_printf("%d %d", (color & 0xFF), (flash_ms / 500) & 0xFF);
    retval = write_ionkbd("rgbled", buffer);
    g_free(buffer);
    
    return retval;
}


gboolean sys_set_index_with_metadata(gboolean with_metadata)
{
    LOGPRINTF("entry");

    g_index_with_metadata = with_metadata;
    
    return TRUE;
}

gboolean sys_set_pageturn_inverted(gboolean is_inverted)
{
    LOGPRINTF("entry");

    g_pageturn_inverted = is_inverted;
    
    ipc_send_changed_pageturn_inverted(g_pageturn_inverted);

    return TRUE;
}


gboolean sys_set_rotate_direction(const char *direction)
{
    LOGPRINTF("entry");
    
    g_return_val_if_fail(direction!=NULL, FALSE);
    
    if (strcmp(direction, "clockwise") == 0)
    {
        g_rotate_direction = ROTATE_CLOCKWISE;    
    }
    else
    {
        g_rotate_direction = ROTATE_ANTICLOCKWISE;    
    }        
    
    return TRUE;
}


static gboolean on_rotated(gpointer data)
{
    LOGPRINTF("entry");

    display_update_return_control(DM_HINT_FULL);
    
    // inform ionkbd
    write_ionkbd_orientation(g_orientation);
    
    // inform applications
    ipc_send_changed_orientation(g_orientation);
    
    return FALSE; // stop timer
}


gboolean sys_set_orientation(const char *orientation)
{
    LOGPRINTF("entry");
    
    g_return_val_if_fail(orientation!=NULL, FALSE);

    static gboolean is_portrait = TRUE;
    gboolean retval = FALSE;
    gboolean is_changed = FALSE;
  
    if (g_ascii_strcasecmp(orientation, "portrait") == 0)
    {
        if (!is_portrait)
        {
            is_portrait = TRUE;
            is_changed = TRUE;
        }
    }
    else if (g_ascii_strcasecmp(orientation, "landscape") == 0)
    {
        if (is_portrait)
        {
            is_portrait = FALSE;
            is_changed = TRUE;
        }
    }
    else if (g_ascii_strcasecmp(orientation, "toggle") == 0)
    {
        is_portrait = !is_portrait;
        is_changed = TRUE;
    }
    else 
    {
        WARNPRINTF("Unknown orientation: %s", orientation);
    }
    
    if (is_changed)
    {
        display_gain_control();

        if (is_portrait)
        {
            // rotate screen (xrandr)
            sys_spawn_sync("xrandr -display 0:0 --screen 0 --orientation normal");
            g_orientation = ORIENTATION_PORTRAIT;
        }
        else  
        {
            /*
             *  GConf Setting:
             *  +----------+--------------+--------------+
             *  | Portrait | LH Landscape | RH Landscape |
             *  +----------+--------------+--------------+
             *  | normal   | clockwise    | anticlockwise|
             *  +----------+--------------+--------------+
             *  
             *  Sensor Layouts:
             *  +----------+--------------+--------------+
             *  | Portrait | LH Landscape | RH Landscape |
             *  +----------+--------------+--------------+
             *  | 1     5  |      5A1     |     5B1      |
             *  | A     B  |    1         |         5    |
             *  | 5     1  |    C         |         C    |
             *  |   1C5    |    5         |         1    |
             *  |          |      1B5     |     1A5      |
             *  +----------+--------------+--------------+
             * 
             *  Xrandr Orientation:
             *  +----------+--------------+--------------+
             *  | Portrait | LH Landscape | RH Landscape |
             *  +----------+--------------+--------------+
             *  | normal   | left         | right        |
             *  +----------+--------------+--------------+
             */ 

            if (g_rotate_direction == ROTATE_CLOCKWISE)
            {
                // rotate screen (xrandr)
                sys_spawn_sync("xrandr -display 0:0 --screen 0 --orientation left");
                g_orientation = ORIENTATION_LANDSCAPE_CLOCKWISE;
            }
            else
            {
                // rotate screen (xrandr)
                sys_spawn_sync("xrandr -display 0:0 --screen 0 --orientation right");
                g_orientation = ORIENTATION_LANDSCAPE_ANTICLOCKWISE;
            }
        }
        
        // wait time to allow rotation
        g_timeout_add(800, (GSourceFunc)on_rotated, NULL);
    }

    return retval;
}


gboolean sys_set_sensor_feedback(gboolean use_light, gboolean use_sound)
{
    LOGPRINTF("entry");
    
    gboolean retval = FALSE;
    char *buffer    = NULL;
    
    // Value 1: bit 0 - buzzer enable, bit 1 - LED enable

    buffer = g_strdup_printf("%d", use_sound | (use_light << 1));
    retval = write_ionkbd("sensor_feedback", buffer);
    
    g_free(buffer);
    return retval;
}


gboolean sys_set_sensor_lock_config(gboolean lock_left, gboolean lock_right, gboolean lock_middle)
{
    LOGPRINTF("entry");
    
    // NOTE: the micro has a sensor_enable setting so we invert the 
    //       lock to enable logic here
    // NOTE: left appears to be Sensor B, right is Sensor A
    g_sensor_disable_config = !lock_right | (!lock_left << 1) | (!lock_middle << 2);

    // if lock is currently active, make new config effective
    sys_set_sensor_lock("update");
    
    return TRUE;
}


gboolean sys_set_sensor_lock(const char *lock_mode)
{
    LOGPRINTF("entry");
    
    g_return_val_if_fail(lock_mode!=NULL, FALSE);
    
    gboolean retval = FALSE;
    gboolean is_changed = FALSE;
    
    if (g_ascii_strcasecmp(lock_mode, "lock") == 0)
    {
        if (!g_sensor_locked)
        {
            g_sensor_locked  = TRUE;
            is_changed = TRUE;
        }
    }
    else if (g_ascii_strcasecmp(lock_mode, "unlock") == 0)
    {
        if (g_sensor_locked)
        {
            g_sensor_locked  = FALSE;
            is_changed = TRUE;
        }
    }
    else if (g_ascii_strcasecmp(lock_mode, "toggle") == 0)
    {
        g_sensor_locked  = !g_sensor_locked;
        is_changed = TRUE;
    }
    else if (g_ascii_strcasecmp(lock_mode, "update") == 0)
    {
        if (g_sensor_locked)
        {
            is_changed = TRUE;
        }
        
        if (g_sensor_disable_config == 7)
        {
            g_sensor_locked = FALSE;
        }
    }
    else
    {
        WARNPRINTF("Unknown lock mode: %s", lock_mode);
    }
  
    if (is_changed)
    {
        if (g_sensor_locked)
        {
            // inform ionkbd
            char *lock_config = g_strdup_printf("%d", g_sensor_disable_config);
            write_ionkbd("sensor_enable", lock_config);
            g_free(lock_config);
            
            // update menu and statusbar item
            ipc_menu_set_item_state("lock", "general", "selected");
            ipc_menu_set_statusitem_state("statusbar_lock", "locked");
        }
        else
        {
            // inform ionkbd
            write_ionkbd("sensor_enable", "7"); // enable all three sensors

            // update menu and statusbar item
            ipc_menu_set_item_state("lock", "general", "normal");
            ipc_menu_set_statusitem_state("statusbar_lock", "normal");
        }
    }

    return retval;
}


void sys_eject_card(gboolean silent)
{
    LOGPRINTF("entry");
    do_unmount(!silent, NULL, on_eject_continue, (gpointer) silent);
}


void sys_standby(void)
{
    LOGPRINTF("entry");

    // shutdown completely when standby switch is toggled during first boot of the device
    if ((device_state == STATE_DEVICE_STARTING) && conf_get_first_boot())
    {
        busy_add_background(0);                    
        sys_spawn_sync("shutdown -h now");
        return;
    }

    if ( usb_state == STATE_USB_MOUNT_PENDING ||
         usb_state == STATE_USB_MOUNTED || 
         card_state == STATE_CARD_INDEXING )
    {
        LOGPRINTF("System is connected to PC or indexing, don't enter standby");
        return;
    }
    
    if (g_holdoff_standby)
    {
        LOGPRINTF("Just back from standby, ignore key press");
        return;
    }
    
#if MACHINE_IS_DR800SG || MACHINE_IS_DR800S || MACHINE_IS_DR800SW
    prepare_standby();
#elif MACHINE_IS_DR1000S || MACHINE_IS_DR1000SW
    do_poweroff();
#else
#error Unhandled machine type
#endif
}


void sys_restart(void)
{
    LOGPRINTF("entry");
    
    device_state = STATE_DEVICE_STOPPING;
    busy_add_foreground(0, BUSY_DIALOG_NONE, NULL);
    do_unmount(TRUE, "restart", on_restart_continue, NULL);
}


static gboolean sys_check_and_install_firmware(void)
{
    LOGPRINTF("entry");

    if (card_state == STATE_CARD_MOUNTED)
    {
        if (g_file_test(UPDATE_FILE, G_FILE_TEST_IS_REGULAR))
        {
            LOGPRINTF("Update file found");

            if (g_file_test(UPDATE_AUTO_FILE, G_FILE_TEST_IS_REGULAR))
            {
                // don't prompt, install automatically
                LOGPRINTF("Autoinstall file found, restart device");
                sys_restart();
            }
            else
            {
                // prompt to restart & install
                ipc_confirm_install_update(TRUE);
            }
            return TRUE;
        }
    }
    return FALSE;
}


gboolean sys_usb_connect()
{
    gboolean retval = FALSE;

    LOGPRINTF("entry");

    if ((card_state == STATE_CARD_MOUNTED) &&
        (usb_state == STATE_USB_MOUNT_CONFIRM))
    {
        usb_set_state(STATE_USB_MOUNT_PENDING);
        do_unmount(TRUE, "usbconnect", on_usb_connected, NULL);
        retval = TRUE;
    }
    else
    {
        LOGPRINTF("no volume mounted or not confirmed");
    }

    return retval;
}


gboolean sys_spawn_async(const char *command)
{
    LOGPRINTF("entry");
    return sys_spawn_async_with_callback(command, NULL, NULL);
}


gboolean sys_spawn_async_with_callback(const char *command, GChildWatchFunc callback, gpointer data)
{
    LOGPRINTF("entry");

    g_return_val_if_fail(command!=NULL, FALSE);

    char *argv[4];
    gboolean retval = FALSE;
    GError *error = NULL;
    GPid child_pid;

    argv[0] = "/bin/sh";
    argv[1] = "-c";
    argv[2] = (char*) command;
    argv[3] = NULL;

    LOGPRINTF("Spawning: %s", argv[2]);
    
    if (callback)
    {
        retval = g_spawn_async(NULL, argv, NULL, G_SPAWN_DO_NOT_REAP_CHILD, NULL, NULL, &child_pid, &error);
    }
    else
    {
        retval = g_spawn_async(NULL, argv, NULL, 0, NULL, NULL, NULL, &error);
    }        
    
    if (error)
    {
        WARNPRINTF("Execution of '%s' failed with error: %s", command, error->message);
        g_error_free(error);
        return FALSE;
    }

    if (retval && callback)
    {
        LOGPRINTF("Add callback handler for pid [%d]", (gint) child_pid);
        g_child_watch_add(child_pid, (GChildWatchFunc) callback, data);
    }
    
    return retval;
}


gboolean sys_spawn_sync(const char *command)
{
    LOGPRINTF("entry");
    
    g_return_val_if_fail(command!=NULL, FALSE);

    char *argv[4];
    gboolean retval = FALSE;
    GError *error = NULL;
    
    argv[0] = "/bin/sh";
    argv[1] = "-c";
    argv[2] = (char*) command;
    argv[3] = NULL;

    LOGPRINTF("Spawning: %s", argv[2]);

    retval = g_spawn_sync(NULL, argv, NULL, 0, NULL, NULL, NULL, NULL, NULL, &error);
    
    if (error)
    {
        WARNPRINTF("Execution of '%s' failed with error: %s", command, error->message);
        g_error_free(error);
        return FALSE;
    }

    return retval;
}


gint sys_battery_level()
{
    int level;
    enum state_charge state;

    sys_get_battery(&level, &state, NULL);

    return level;
}


gboolean sys_get_battery(int *level, enum state_charge *state, int *timeleft)
{
    LOGPRINTF("entry");

    gboolean result = FALSE;
    gint cur_level = 0;
    gint charging  = 0;
    gint rc        = 0;
    
    if (sys_is_emulator())
    {
        *level = 100;
        *state = STATE_CHARGE_DISCHARGING;
        return TRUE;
    }

    rc = read_ionkbd("battery", "%d %d", &cur_level, &charging);
    
    if ((rc > 0) && (cur_level != 0xFF))
    {
        *level    = cur_level;
        *state    = get_battery_state(cur_level, charging);
        
        LOGPRINTF("battery level %d, charging %d", cur_level, charging);
        result = TRUE;
    }
    else
    {
        WARNPRINTF("Failed to read battery information");
    }

    return result;
}


void sys_update_battery(const char *battery)
{
    gint                  charging  = 0;
    gint                  cur_level = 0;
    enum state_charge     cur_state = STATE_CHARGE_UNKNOWN;
    
    LOGPRINTF("entry");
    
    sscanf(battery, "%d %d", &cur_level, &charging);
    cur_state = get_battery_state(cur_level, charging);
    update_battery_info(cur_level, cur_state, FALSE);
}


gfloat sys_get_display_vcom()
{
    LOGPRINTF("entry");
    gfloat vcom;

    read_sysset("display/vcom", "%f", &vcom);

    return vcom;
}


static void set_keypress_generation(int delay)
{
    int fd = open("/sys/devices/serio0/demo_mode", O_WRONLY);
    if (fd == -1) {
        perror("open");
        return;
    } else {
        char buffer[10];
        sprintf(buffer, "%d", delay);
        write(fd, buffer, strlen(buffer));
        close(fd);
    }

}


static gboolean start_demo(gpointer data)
{
    set_keypress_generation(DEMO_FLIP_INTERVAL);
    return FALSE;
}


static void start_demo_mode()
{
    WARNPRINTF("found "DEMO_FILE", starting demo mode");
    if (g_demo_mode)
    {
        ERRORPRINTF("already in demo mode");
        return;
    }
    g_demo_invert_flipbar = g_pageturn_inverted;
    if (g_pageturn_inverted) {
        sys_set_pageturn_inverted(FALSE);
    }
    // disable wacom and lock all sensors
    wacom_disable();
    write_ionkbd("sensor_enable", "0");

    // open demo document
    ipc_send_demo_mode(TRUE);
    task_start("/usr/bin/uds "MOUNTPOINT_CARD"/"DEMO_FILE, MOUNTPOINT_CARD, "Slideshow", NULL, NULL, NULL);

    // start auto-keypress 5 seconds later (+ delay of pressing keys)
    g_timeout_add(5000, start_demo, NULL);
    g_demo_mode = TRUE;
}


static void stop_demo_mode()
{
    if (!g_demo_mode) return;

    WARNPRINTF("stopping demo mode");
    set_keypress_generation(0);
    if (g_demo_invert_flipbar) {
        sys_set_pageturn_inverted(TRUE);
    }
    ipc_send_demo_mode(FALSE);
    wacom_enable();
    if (g_sensor_locked) {
        char buf[20];
        sprintf(buf, "%d", g_sensor_disable_config);
        write_ionkbd("sensor_enable", buf);
    } else {
        write_ionkbd("sensor_enable", "7");

    }

    g_demo_mode = FALSE;
}


static void update_usb_state(gboolean connected)
{
    static gboolean last_connected = FALSE;


    if (usb_state != STATE_CHARGE_UNKNOWN
        && connected == last_connected) return;

    last_connected = connected;

    if (connected)
    {
        // usb cable connected
        usb_set_state(STATE_USB_UNMOUNTED);

        if (card_state == STATE_CARD_MOUNTED)
        {
            LOGPRINTF("SD/MMC available, load USB drivers check for host");
            if (usb_driver_load())
            {
                busy_add_background(0);
                g_usb_device_source = g_timeout_add_seconds(USB_DEVICE_POLL_INTERVAL, on_usb_read_device_state, NULL);
            }
        }
        else
        {
            LOGPRINTF("Card not mounted; don't connect to USB, card_state [%d]", card_state);
        }
    }
    else
    {
        // usb cable disconnected
        if (usb_state == STATE_USB_MOUNT_PENDING)
        {
            usb_set_state(STATE_USB_DISCONNECT_PENDING);
        }
        else
        {
            usb_set_state(STATE_USB_DISCONNECTED);
        }
    }
}


void sys_update_hardware(const char *hardware)
{
    LOGPRINTF("entry");
    
    static gint         old_state           = 0;
    gint                cur_state           = 0;
 
    sscanf(hardware, "%d", &cur_state);
    
    LOGPRINTF("old state [%d] cur state [%d]", old_state, cur_state);

    if ( ((old_state & ST_HW_CARD) != (cur_state & ST_HW_CARD))
         || 
         (card_state == STATE_CARD_UNKNOWN) )
    {
        // NOTE reversed logic: 0 card is inserted, 1 card ejected
        //
        if (!(cur_state & ST_HW_CARD))
        {
            // event not handled here as storage device and volume will be added through HAL 
            LOGPRINTF("SD/MMC card inserted");
        }
        else
        {
            // event not handled here as storage device and volume will be removed through HAL
            LOGPRINTF("SD/MMC card ejected");
            stop_demo_mode();
        }
    }

    update_usb_state(cur_state & ST_HW_USB);
    
    // keep device awake for a while as HAL events can follow
    sys_reset_idle_time();

    // store state
    old_state = cur_state;
}


gboolean sys_has_network(void)
{
    gboolean ignore          = FALSE;
    gboolean found_wifi      = FALSE;
    gboolean found_bluetooth = FALSE;
    gboolean found_3g        = FALSE;
    
    sys_get_device_capabilities(&ignore, &found_wifi, &found_bluetooth, &found_3g);
    
    return (found_wifi || found_bluetooth || found_3g);
}


gboolean sys_has_stylus(void)
{
    gboolean found_stylus    = FALSE;
    gboolean ignore          = FALSE;
    
    sys_get_device_capabilities(&found_stylus, &ignore, &ignore, &ignore);
    
    return (found_stylus);
}


gboolean sys_is_dr800(void)
{
    int type = 0;
    int rc = read_ionkbd("device_type", "%d", &type);
    if ((rc > 0) && ((type == 3) || (type == 4) || (type == 5)))
    {
        return TRUE;
    }
    
    return FALSE;
}


gboolean sys_is_emulator(void)
{
    char hostname[100] = {0};
    int rc = gethostname(hostname, sizeof(hostname));
    if ((rc == 0) && (strcmp(hostname, "qemuarm") == 0))
    {
        return TRUE;
    }
    return FALSE;
}


void sys_get_device_capabilities(gboolean *has_stylus, gboolean *has_wifi, gboolean *has_bluetooth, gboolean *has_3g)
{
    LOGPRINTF("entry");

    gboolean found_stylus    = FALSE;
    gboolean found_wifi      = FALSE;
    gboolean found_bluetooth = FALSE;
    gboolean found_3g        = FALSE;
    char data[64];
    
    bzero(data, sizeof(data));
    read_sysset("wacom/serial", "%s", &data);
    if ((data[0] != '\0') && (data[0] != '\xFF')) 
    {
        LOGPRINTF("data %s", data);
        if ((strlen(data) > 0) && (strtoul(data,NULL,16) != 0))
        {
            found_stylus = TRUE;
        }
    }

    bzero(data, sizeof(data));
    read_sysset("wifi/address", "%s", &data);
    if ((data[0] != '\0') && (data[0] != '\xFF')) 
    {
        if (strlen(data) > 0)
        {
            found_wifi = TRUE;
        }
    }

    bzero(data, sizeof(data));
    read_sysset("bluetooth/address", "%s", &data);
    if ((data[0] != '\0') && (data[0] != '\xFF')) 
    {
        if (strlen(data) > 0)
        {
            found_bluetooth = TRUE;
        }
    }

    bzero(data, sizeof(data));
    read_sysset("3g/imei", "%s", &data);
    if ((data[0] != '\0') && (data[0] != '\xFF')) 
    {
        if (strlen(data) > 0)
        {
            found_3g = TRUE;
        }
    }
    
    bzero(data, sizeof(data));
    read_sysset("3g/meid", "%s", &data);
    if ((data[0] != '\0') && (data[0] != '\xFF')) 
    {
        if (strlen(data) > 0)
        {
            found_3g = TRUE;
        }
    }
    
    if (sys_is_emulator())
    {
        found_stylus = TRUE;
        found_3g     = TRUE;
    }

    LOGPRINTF("capabilities from sysset: wacom %d, wifi %d, bluetooth %d, 3g %d", found_stylus, found_wifi, found_bluetooth, found_3g);
        
    *has_stylus    = found_stylus;
    *has_wifi      = found_wifi;
    *has_bluetooth = found_bluetooth;
    *has_3g        = found_3g;
}


static gboolean check_disk_free(void)
{
    LOGPRINTF("entry");

    if (card_state == STATE_CARD_MOUNTED)
    {
        // check available free space
        gint64      mbfree   = -1;
        
        LOGPRINTF("mbfree [%lld]", mbfree);
    
        struct statvfs s;
        if (statvfs(MOUNTPOINT_CARD, &s) == 0) 
        {
            mbfree   = s.f_frsize * s.f_bavail >> 20;
        }
        
        if (mbfree == -1)
        {
            ERRORPRINTF("failed to get free space from mount point [%s]", MOUNTPOINT_CARD);
        }
        else if (mbfree <= SD_FREE_MB_WARN_LEVEL)
        {
            WARNPRINTF("sdcard disk space low, free %lld Mb", mbfree);
            ipc_show_message("sdfullwarn", NULL, NULL);
            return TRUE;
        }
    }
    return FALSE;
}


static void on_card_indexed(GPid pid, gint status, gpointer data)
{
    LOGPRINTF("entry pid [%d] status [%d]", (gint) pid, status);

    g_spawn_close_pid(pid);
    
    busy_remove_foreground(0);

    sys_set_card(STATE_CARD_MOUNTED);
    
    if (g_index_splash_enabled)
    {
        ipc_show_splash("hide");
        gboolean do_drz = check_and_install_drz();
        gboolean do_firmware = sys_check_and_install_firmware();
        gboolean do_disk = check_disk_free();

        if (!(do_drz || do_firmware || do_disk)) {
            if (g_file_test(MOUNTPOINT_CARD"/"DEMO_FILE, G_FILE_TEST_EXISTS)) {
                start_demo_mode();
            }
        }
    }
    else
    {
        // enable splash again for next mount
        g_index_splash_enabled = TRUE;
    }
}


void sys_set_card(enum state_card new_state)
{
#if (LOGGING_ON)
    const gchar *state_str[] = { "UKNOWN", "INACCESSIBLE", "EJECTED", "UNMOUNTING", "UNMOUNTED", "INDEXING", "MOUNTED" };
    LOGPRINTF("prepare card_state %s > %s", state_str[card_state], state_str[new_state]);
#endif        
    
    switch (new_state)
    {
    case STATE_CARD_EJECTED:
        ipc_show_splash("nosd");

        // delete private settings from registry
        sys_spawn_async(ERCONFTOOL_DELETE);
    
        if (   (usb_state != STATE_USB_DISCONNECTED)
            && (usb_state != STATE_USB_UNMOUNTED) )
        {
            // set new state before unmounting USB
            LOGPRINTF("change card_state %s > %s", state_str[card_state], state_str[new_state]);
            card_state = new_state;
            usb_set_state(STATE_USB_UNMOUNTED);
        }
        break;
        
    case STATE_CARD_INDEXING:
    {
        busy_add_foreground(0, BUSY_DIALOG_NONE, NULL);
        if (g_index_splash_enabled)
        {
            ipc_show_splash("indexing");
        }
        sys_spawn_sync(ERCONFTOOL_IMPORT);
        
        // synchronize with Adobe Digital Editions
        sys_spawn_sync(ADOBE_SYNC);
        
        gchar *command = g_strdup_printf("%s %s %s", 
                                         MDB_INDEXER,
                                         MOUNTPOINT_CARD,
                                         g_index_with_metadata ? "" : "--quick");
        sys_spawn_async_with_callback(command, on_card_indexed, (gpointer) FALSE);
        g_free(command);
        // busy is reset by "on_card_indexed" callback
    }
    break;

    case STATE_CARD_MOUNTED:
        ipc_send_volume_mounted(MOUNTPOINT_CARD);
        g_card_device = hal_get_mountpoint_device();
        break;
    
    case STATE_CARD_INACCESSIBLE:
    case STATE_CARD_UNMOUNTED:
    default:
        break;
    }

    LOGPRINTF("change card_state %s > %s", state_str[card_state], state_str[new_state]);
    
    card_state = new_state;
}


enum state_card sys_get_card()
{
    return card_state;    
}


void sys_usb_no_connect()
{
    LOGPRINTF("entry");
    if (usb_state == STATE_USB_MOUNT_CONFIRM)
    {
        usb_set_state(STATE_USB_UNMOUNTED);
    }
}


gboolean sys_request_popup(const char *state)
{
    g_return_val_if_fail(state!=NULL, FALSE);
    
    if (strcmp(state, "localblock") == 0)
    {
        g_popup_enabled = FALSE;
    }
    else if (strcmp(state, "block") == 0)
    {
        g_popup_enabled = FALSE;
        ipc_show_popup(state);
    }
    else if (strcmp(state, "localunblock") == 0)
    {
        g_popup_enabled = TRUE;
    }
    else if (strcmp(state, "unblock") == 0)
    {
        g_popup_enabled = TRUE;
        ipc_show_popup(state);
    }
    else if (g_popup_enabled)
    {
        ipc_show_popup(state);
    }
    return TRUE;
}


gboolean sys_set_power(const char *device, gint mode)
{
    LOGPRINTF("entry");
    
    gboolean retval = FALSE;
    
    gchar *modestr = g_strdup_printf("%d", mode);
    retval = write_power(device, modestr);
    g_free(modestr);
    
    return retval;
}


gboolean sys_get_power(const char *device, gint *mode)
{
    LOGPRINTF("entry");
    
    gboolean retval = FALSE;
    retval = read_power(device, "%d", &mode);
    
    return retval;
}


guint sys_get_orientation(void)
{
    return g_orientation;
}


gboolean sys_get_pageturn_inverted(void)
{
    return g_pageturn_inverted; 
}


static void on_install_drz_ready(GPid pid, gint status, gpointer data)
{
    WARNPRINTF("pid [%d] exit status [%d]", (gint) pid, status);
    g_spawn_close_pid(pid);
}


void sys_install_drz(void)
{
    // NOTE installation of AdobeID account requires network connections (IPC) so
    //      this must be called asynchronous
    gchar *command = g_strdup_printf(DRZINSTALL_TOOL" -s %s", DRZ_PATH);
    sys_spawn_async_with_callback(command, on_install_drz_ready, NULL);
    g_free(command);
    return;
}


static gboolean check_and_install_drz(void)
{
    LOGPRINTF("entry");

    if (card_state == STATE_CARD_MOUNTED)
    {
        if (g_file_test(DRZ_PATH, G_FILE_TEST_IS_DIR))
        {
            LOGPRINTF("DRZ path found");

            if (g_file_test(DRZ_AUTO_FILE, G_FILE_TEST_IS_REGULAR))
            {
                // don't prompt, install automatically
                LOGPRINTF("Autoinstall file found, install DRZ");
                sys_install_drz();
            }
            else
            {
                // prompt to install
                ipc_confirm_install_drz(TRUE);
            }
            
            return TRUE;
        }
    }
    
    return FALSE;
}


enum state_device sys_get_device_state(void)
{
#if (LOGGING_ON)
        const gchar *state_str[] = { "UKNOWN", "STARTING", "STARTED", "STOPPING" };
        LOGPRINTF("device_state [%s]", state_str[device_state]);
#endif        
    return device_state;
}


enum state_power sys_get_power_state(void)
{
#if (LOGGING_ON)
//        const gchar *state_str[] = { "UKNOWN",  "OFF", "RUN", "IDLE", "STANDBY" };
//        LOGPRINTF("power_state [%s]", state_str[power_state]);
#endif        
    return power_state;
}


void sys_set_device_state(enum state_device new_state)
{
    LOGPRINTF("entry, new state: %d", new_state);

    device_state = new_state;
}


void sys_update_rgb_led()
{
    LOGPRINTF("entry");
    
    if (is_busy_foreground())
    {
        // Device Busy
        sys_set_rgb_led(COLOR_GREEN, 500);
        return;
    }
    
    if (conn_is_online())
    {
        // Connection Online
        sys_set_rgb_led(COLOR_BLUE, 0);
        return;
    }
    
    if (charge_state == STATE_CHARGE_CHARGING)
    {
        // Battery Charging
        sys_set_rgb_led(COLOR_YELLOW, 0);
        return;
    }
    else if (charge_state == STATE_CHARGE_FULL)
    {
        // Battery Fully Charged & USB attached
        if ((usb_state != STATE_USB_DISCONNECTED) && (usb_state != STATE_USB_UNKNOWN))
        {
            sys_set_rgb_led(COLOR_GREEN, 0);
            return;
        }
    }
    else if (charge_state == STATE_CHARGE_LOW)
    {
        // Battery Critically Low
        sys_set_rgb_led(COLOR_RED, 0);
        return;
    }
    
    // Device On -- default state
    sys_set_rgb_led(COLOR_OFF, 0);
}


gboolean sys_get_enable_index_splash(void)
{
    return g_index_splash_enabled;
}


void sys_set_enable_index_splash(gboolean value)
{
    g_index_splash_enabled = value; 
}


//============================================================================
// Local Function Implementation
//============================================================================

static gint read_sysfs(const char *device, const char *filename, const char *format, ...)
{
    va_list ap;
    gint    retval = 0;
    gchar   *file = NULL;
    gint    fd = 0;
    char    buffer[256 + 1] = {0};

    if (!device)
    {
        return retval;
    }
    va_start(ap, format);

    file = g_strconcat(device, "/", filename, NULL);
    
    fd = open(file, O_RDONLY);
    if (fd >= 0) 
    {
        retval = read(fd, buffer, sizeof(buffer));
        close(fd);
        
        if (retval > -1)
        {
//            LOGPRINTF("buffer: `%s`", buffer);
            retval = vsscanf(buffer, format, ap);
        }
        else 
        {
            WARNPRINTF("Could not read %s", file);
        }
    } 
    else 
    {
        WARNPRINTF("Could not open %s", file);
    }
    
    g_free(file);

    va_end(ap);
    
    return retval;
}


static gboolean write_ionkbd_orientation(gint orientation)
{
    LOGPRINTF("entry");
    
    gboolean retval = FALSE;
    
    switch (orientation)
    {
    case ORIENTATION_PORTRAIT:
        write_ionkbd("orientation", "portrait");
        retval = TRUE;
        break;
        
    case ORIENTATION_LANDSCAPE_CLOCKWISE:
        write_ionkbd("orientation", "lh-landscape");
        retval = TRUE;
        break;
            
    case ORIENTATION_LANDSCAPE_ANTICLOCKWISE:
        write_ionkbd("orientation", "rh-landscape");
        retval = TRUE;
        break;
    
    default:
        WARNPRINTF("Unknown orientation: %d", g_orientation);
        break;
    }
    
    return retval;
}


static gboolean write_ionkbd_battery_alerts(gint l1, gint l2, gint l3, gint l4, gint l5)
{
    LOGPRINTF("entry");
    
    gchar *message = g_strdup_printf("%d %d %d %d %d", l1, l2, l3, l4, l5);
    
    write_ionkbd("battery_alerts", message);
    
    g_free(message);
    
    return TRUE;
}


static gboolean write_sysfs(const char *device, const char *filename, const char *buffer)
{
    LOGPRINTF("entry");
    
    gboolean retval = FALSE;
    char *file = NULL;
    gint fd = 0;
    gint result = 0;
    
    if (!device)
    {
        return FALSE;
    }
    
    file = g_strconcat(device, "/", filename, NULL);
    
    fd = open(file, O_WRONLY);
    if (fd >= 0)
    {
        result = write(fd, buffer, strlen(buffer));
        close(fd);
        
        if (result > -1)
        {
            retval = TRUE;
        }
        else
        {
            WARNPRINTF("Could not write to `%s` (%d), %s", file, errno, strerror(errno));
        }
    }
    else
    {
        WARNPRINTF("Could not open %s", filename);
    }
    
    g_free(file);
    
    return retval;
}


static char *find_dir(const char *dir, const char *name, gboolean recurse)
{
    LOGPRINTF("entry: [%s] [%s]", dir, name);
    
    struct  dirent **namelist;
    char   *full_name = NULL;
    int     i         = 0;
    int     count     = 0;

    count = scandir(dir, &namelist, 0, alphasort);
    for(i = 0; i < count; i++) 
    {
        char *filename = namelist[i]->d_name;
        
        if (filename && (strcmp(filename, ".") != 0) && (strcmp(filename, "..") != 0)) 
        {
            char fullpath[512] = "";
            strcat(fullpath, dir);
            strcat(fullpath, "/");
            strcat(fullpath, filename);

            struct stat attributs;
            if (lstat(fullpath, &attributs) == -1)
            {
                WARNPRINTF("Error reading attributes of '%s'", fullpath);
            }

            if S_ISDIR(attributs.st_mode)
            {
                if (name != NULL)
                {
                    if (strncmp(filename, name, strlen(name)) == 0)
                    {
                        // dir found
                        full_name = g_strdup(fullpath);
                        break;
                    }
                    else if (recurse && name != NULL) 
                    {
                        // recursive search 
                        full_name = find_dir(fullpath, name, recurse);
                        if (full_name)
                        {
                            // dir found
                            break;
                        }
                        g_free(full_name);
                    }
                }
            } 
        }
    }
    
    g_free(namelist);
    return full_name;
}


static void report_unmounting_volumes()
{
    LOGPRINTF("entry");
    
    hal_device *device = hal_device_list_get_root();
    hal_device_property *property;

    while (device != NULL)
    {
        property = hal_device_list_get_property("volume.mount_point", device);
        if ((property != NULL) && (*property->values != NULL) && ((*property->values)[0] != '\0'))
        {
            LOGPRINTF("about to unmount: %s", *property->values);
            ipc_send_prepare_unmount(*property->values);            
        }
        device = device->next;
    }
}


static enum state_charge get_battery_state(gint level, gint charging)
{
    LOGPRINTF("entry");

    enum state_charge cur_state;
    
    if (charging == 1)
    {
#if MACHINE_IS_DR800SG || MACHINE_IS_DR800S || MACHINE_IS_DR800SW
        if (level >= BATTERY_FULL_THRESHOLD)
        {
            cur_state = STATE_CHARGE_FULL;
        }
        else
#endif
        {
            cur_state = STATE_CHARGE_CHARGING;
        }
    }
    else
    {
#if MACHINE_IS_DR1000S || MACHINE_IS_DR1000SW
        if (level >= BATTERY_FULL_THRESHOLD)
        {
            cur_state = STATE_CHARGE_FULL;
        }
        else
#endif
        if (level <= BATTERY_LOW_THRESHOLD)
        {
            cur_state = STATE_CHARGE_LOW;
        }
        else 
        {
            cur_state = STATE_CHARGE_DISCHARGING;
        }
    }

    LOGPRINTF("returns %d", cur_state);
    return cur_state;
}


static void check_hardware()
{
    LOGPRINTF("entry");

    char hardware[5] = {0};
    gint rc = 0;
    
    rc = read_ionkbd("hardware_state", "%s", &hardware);
    if (rc > 0)
    {
        LOGPRINTF("hardware: %s", hardware);
        sys_update_hardware(hardware);
    }
}


static void update_battery_info(gint cur_level, enum state_charge cur_state, gboolean force_send)
{
    LOGPRINTF("entry");
    
    enum state_charge     old_state = charge_state;
    
    // update battery information when:
    // - forced by argument in call
    // - charge state changed
    // - value has changed
    if ( (force_send == TRUE) ||
         (cur_state != old_state) ||
         (g_battery_level != cur_level)
       )
    {
        // save level and state for later
        g_battery_level = cur_level;
        charge_state = cur_state;
        
        ipc_send_battery_state(cur_level, cur_state, -1);

        // if cur_state != "low" then any splash screen is removed during
        // charge/discharge of battery.
        switch (old_state)
        {
            case STATE_CHARGE_LOW:
                if ( cur_state == STATE_CHARGE_CHARGING )
                {   
                    ipc_show_splash("hide");
                    break;
                }
                if ( cur_state == STATE_CHARGE_LOW )
                {
                    ipc_show_splash("batterylow");
                    break;
                }
            case STATE_CHARGE_CHARGING:
            case STATE_CHARGE_DISCHARGING:
                if ( cur_state == STATE_CHARGE_LOW )
                {
                    ipc_show_splash("batterylow");
                }
                break;
            default:
                // do nothing
                break;
        }

        // update led to new state
        sys_update_rgb_led();
    }
    
    if ( (charge_state == STATE_CHARGE_LOW) && (cur_level <= BATTERY_SHUTDOWN_THRESHOLD) )
    {
        if (g_standby_if_plugged || (usb_state == STATE_USB_DISCONNECTED) || (usb_state == STATE_USB_UNKNOWN))
        {
            LOGPRINTF("Power off now");
            do_poweroff();
            return;
        }
        else
        {
            LOGPRINTF("Don't power off as device is plugged in. usb_state [%d] if_plugged [%d]", usb_state, g_standby_if_plugged);
        }
    }
    
    conn_check_battery(cur_level);
}


static void usb_set_state(enum state_usb new_state)
{
#if (LOGGING_ON)
    static const gchar *state_str[] =
    {
        [STATE_USB_UNKNOWN]             = "STATE_USB_UNKNOWN",
        [STATE_USB_DISCONNECT_PENDING]  = "STATE_USB_DISCONNECT_PENDING",
        [STATE_USB_DISCONNECTED]        = "STATE_USB_DISCONNECTED",
        [STATE_USB_UNMOUNTED]           = "STATE_USB_UNMOUNTED",
        [STATE_USB_MOUNT_CONFIRM]       = "STATE_USB_MOUNT_CONFIRM",
        [STATE_USB_MOUNT_PENDING]       = "STATE_USB_MOUNT_PENDING",
        [STATE_USB_MOUNTED]             = "STATE_USB_MOUNTED",
    };
#endif
    enum state_usb old_state = usb_state;
    if (old_state == new_state)
    {
        WARNPRINTF("huh? already in state [%d]", new_state);
        return;
    }
    usb_state = new_state;
    LOGPRINTF("change usb_state %s > %s", state_str[old_state],  state_str[new_state]);

    if (new_state == STATE_USB_DISCONNECTED || new_state == STATE_USB_UNMOUNTED)
    {
        if (old_state == STATE_USB_MOUNT_CONFIRM)
        {
            // remove confirmation dialog
            ipc_confirm_usbconnect(FALSE);
        }

        if (   (old_state == STATE_USB_MOUNT_CONFIRM) 
            || (old_state == STATE_USB_DISCONNECT_PENDING) 
            || (old_state == STATE_USB_MOUNTED)
            || (old_state == STATE_USB_UNMOUNTED) )
        {
            // unload volume and drivers
            usb_driver_unload();
            g_wallcharger_found = FALSE;
        }
            
        if (   (old_state == STATE_USB_MOUNTED)
            || (old_state == STATE_USB_DISCONNECT_PENDING))
        {
            if (card_state == STATE_CARD_EJECTED)
            {
                // don't try to remount volume(s) 
                usb_connection_finish();
                ipc_show_splash("nosd");
            }
            else
            {
                // remount volume(s)
                hal_remount_all_volumes(on_usb_disconnected, NULL);
            }
        }   
    }

    switch (new_state)
    {
    case STATE_USB_UNKNOWN:
        break;
    case STATE_USB_DISCONNECTED:
        ipc_send_usb_state("disconnected");
        break;
    case STATE_USB_UNMOUNTED:
        ipc_send_usb_state("unmounted");
        break;
    case STATE_USB_MOUNT_CONFIRM:
#if MACHINE_IS_DR1000S || MACHINE_IS_DR1000SW
        // ask user to confirm USB export if not in demo mode
        if (!g_demo_mode)
        {
            ipc_confirm_usbconnect(TRUE);
        }
        else
#endif
        {
            // don't ask confirmation from user, connect immediately
            sys_usb_connect();
        }
        break;
    case STATE_USB_DISCONNECT_PENDING:
    case STATE_USB_MOUNT_PENDING:
        break;
    case STATE_USB_MOUNTED:
        ipc_send_usb_state("mounted");
        break;
    }
}


static gboolean usb_driver_load()
{
    LOGPRINTF("entry");
    
    // wait a bit to let USB settle
    g_usleep(G_USEC_PER_SEC * 2);

    gboolean retval = sys_spawn_sync("modprobe g_file_storage removable=y");
    if (retval)
    {
        // find usb device
        if (g_usb) g_free(g_usb);
        g_usb = find_dir(sys_devices, usb_device_name, TRUE);
        if (!g_usb) 
        {
            ERRORPRINTF("%s not found or not unique", usb_device_name);
            retval = FALSE;            
        }
    }
    return retval;
}


static gboolean usb_driver_unload()
{
    LOGPRINTF("entry");
    
    gboolean retval = sys_spawn_sync("modprobe -r g_file_storage");
    if (retval)
    {
        g_usb = NULL;
    }
    return retval;
}


static gboolean usb_connect()
{
    gboolean retval = FALSE;

    LOGPRINTF("entry");

    if (g_volume_unmount_source)
    {
        g_source_remove(g_volume_unmount_source);
    }
    
    // find usb gadget lun
    if (g_lun) g_free(g_lun);
    g_lun = find_dir(sys_devices, lun_device_name, TRUE);
    if (g_lun) 
    {
        // mount device for gadget
        if (g_card_device)
        {
            write_sysfs(g_lun, "file", g_card_device);
            
            // set poll timer to check connection
            busy_add_background(0);                    
            g_usb_device_source = g_timeout_add_seconds(USB_DEVICE_POLL_INTERVAL, on_usb_read_online, NULL);

            usb_set_state(STATE_USB_MOUNTED);
            retval = TRUE;
        }
        else
        {
            ERRORPRINTF("device of mountpoint not found");
        }
    }
    else
    {
        ERRORPRINTF("%s not found or not unique", lun_device_name);
    }
    
    return retval;
}


static void on_usb_connected(gpointer data)
{
    LOGPRINTF("entry");
    
    if (usb_state == STATE_USB_MOUNT_PENDING)
    {
        usb_connect();
    }
    else if (usb_state == STATE_USB_DISCONNECT_PENDING)
    {
        usb_set_state(STATE_USB_DISCONNECTED);
    }
    
    busy_remove_foreground(0);
}


static gboolean on_usb_disconnected(gpointer data)
{
    LOGPRINTF("entry");
    
    usb_connection_finish();
    
    if (usb_state == STATE_USB_MOUNTED)
    {
        usb_set_state(STATE_USB_UNMOUNTED);
    }

    // stop timeout
    return FALSE;
}


static void usb_connection_finish()
{
    LOGPRINTF("entry");
    
    // stop polling for usb state
    if (g_usb_device_source)
    {
        g_source_remove(g_usb_device_source);
        g_usb_device_source = 0;
    }
}


static gboolean on_usb_read_device_state(gpointer data)
{
    static gint count = 0;
    gboolean continue_polling = TRUE;
    gboolean host_available   = FALSE;
    
    char state[80] = {0};
    read_usb("device_state", "%*d:%s", &state);
    LOGPRINTF("device_state [%s]", state);

    if (strcmp(state, "address") == 0)
    {
        host_available = TRUE;
    }
    
    if (usb_state == STATE_USB_UNMOUNTED)
    {
        if ((host_available) && (card_state == STATE_CARD_MOUNTED))
        {
            LOGPRINTF("USB host found, connect immediately");
            usb_set_state(STATE_USB_MOUNT_CONFIRM);
            continue_polling = FALSE;
        }
        else if (count > USB_DEVICE_POLL_TIMEOUT)
        {
            LOGPRINTF("USB not host found (is charger), stop polling and unload");
            usb_driver_unload();

            g_wallcharger_found = TRUE;
            continue_polling = FALSE;
        }
    }
    else
    {
        if (!host_available)
        {
            if (usb_state != STATE_USB_DISCONNECTED)
            {
                LOGPRINTF("USB suspended, remove dialog and disconnect");
                usb_set_state(STATE_USB_UNMOUNTED);
            }
            continue_polling = FALSE;
        }
    }
    
    if (continue_polling)    
    {
        count++;
    }
    else
    {
        busy_remove_background(0);
        g_usb_device_source = 0;
        count = 0;
    }
    
    return continue_polling;
}


static gboolean on_usb_read_online(gpointer data)
{
    static gint count = 0;
    gboolean continue_polling = TRUE;

    gint state = -1;
    read_lun("online", "%d", &state);
    LOGPRINTF("online [%d]", state);

    if (state == 0 && count > USB_DEVICE_ONLINE_DELAY)
    {
        if (usb_state != STATE_USB_DISCONNECTED)
        {
            LOGPRINTF("OFFLINE, remove dialog and disconnect");
            usb_set_state(STATE_USB_UNMOUNTED);
        }
        continue_polling = FALSE;
    }
    else if (state == -1)
    {
        LOGPRINTF("Can't read OFFLINE state, gadget probably unloaded");
        continue_polling = FALSE;
    }

    if (continue_polling)    
    {
        count++;
    }
    else
    {
        busy_remove_background(0);
        g_usb_device_source = 0;
        count = 0;
    }
    
    return continue_polling;
}


static void on_poweroff_continue(gpointer data)
{
    LOGPRINTF("entry");

    // enable/unlock all three sensors before power off
    write_ionkbd("sensor_enable", "7"); 

    // power off and wait
    sys_spawn_sync("shutdown -h now");

    while (1)
    {
        g_usleep(G_USEC_PER_SEC * 1);
    }

    WARNPRINTF("this should never be reached");
}


static void on_restart_continue(gpointer data)
{
    LOGPRINTF("entry");

    // cold reboot 
    sys_spawn_sync("reboot");
}


static void on_eject_continue(gpointer data)
{
    LOGPRINTF("entry");
    
    gboolean silent = (gboolean) data;
    
    busy_remove_foreground(0);

    if (!silent)
    {
        ipc_show_splash("safelyremove");
    }
}


static void set_idle_time(gint time)
{
    if (!g_idle_enabled)
    {
        return;
    }
    
    if ((power_state == STATE_POWER_IDLE) || (power_state == STATE_POWER_STANDBY))
    {
        if (g_idle_time_source)
        {
            // stop idle time when preparing for idle or standby
            LOGPRINTF("stop idle time when preparing for idle or standby");
            g_source_remove(g_idle_time_source);
            g_idle_time_source = 0;
        }
        return;
    }

#if (LOGGING_ON)
    GTimeVal curtime;
    g_get_current_time(&curtime);
    LOGPRINTF(" %ld:%3ld Reset idle >>> STATE_POWER_RUN", curtime.tv_sec, curtime.tv_usec / 1000);
#endif
    
    power_state = STATE_POWER_RUN;

    if (time <= 0)
    {
        time = IDLE_TIMEOUT_SEC;
    }
    
    if (g_idle_time_source)
    {
        g_source_remove(g_idle_time_source);
    }
    g_idle_time_source = g_timeout_add_seconds(time, on_idle_timeout, NULL);
}


static gboolean on_idle_timeout(gpointer data)
{
    LOGPRINTF("entry");

#if (LOGGING_ON)
    GTimeVal curtime;
    g_get_current_time(&curtime);
    LOGPRINTF(" %ld:%3ld Idle for %d seconds, idle pending >>> STATE_POWER_IDLE", 
              curtime.tv_sec, curtime.tv_usec / 1000, IDLE_TIMEOUT_SEC);
#endif
    
    if (!g_idle_enabled)
    {
        return FALSE;
    }

    if ( is_busy_background() ||
         conn_is_online() || conn_is_initialising() || 
         (usb_state    == STATE_USB_MOUNT_CONFIRM) || (usb_state    == STATE_USB_MOUNT_PENDING) || (usb_state  == STATE_USB_MOUNTED ) || 
         (device_state == STATE_DEVICE_STOPPING) ||
         (power_state  == STATE_POWER_IDLE) )
    {
        LOGPRINTF("Don't idle as system is busy (bgbusy [%d] online [%d] usb_state [%d] device_state [%d] power_state [%d])", 
                   is_busy_background(), conn_is_online(), usb_state, device_state, power_state);
        return TRUE;
    }
    else 
    {
        gint x_idle = window_get_idle_time();
        
        if ((x_idle != -1) && (x_idle < IDLE_TIMEOUT_SEC))
        {
            LOGPRINTF("Don't idle as X is idle for %d sec, wait %d sec more", x_idle, IDLE_TIMEOUT_SEC-x_idle);
            set_idle_time(IDLE_TIMEOUT_SEC-x_idle);
        }
        else
        {
            do_idle();
        }
    }
    
    // stop timer
    return FALSE;
}


static void do_unmount(gboolean show_busy, const char *splash, gpointer callback_function, gpointer user_data)
{
    LOGPRINTF("entry");
    
    if (show_busy)
    {
        busy_add_foreground(0, BUSY_DIALOG_DIRECT, NULL);
    }
   
    if (splash)
    {
        ipc_show_splash(splash);
    }

    // stop optional demo mode
    stop_demo_mode();

    // have applications close their files
    report_unmounting_volumes();

    // run export settings and wait
    sys_spawn_sync(ERCONFTOOL_EXPORT);

    // synchronize with Adobe Digital Editions
    sys_spawn_sync(ADOBE_SYNC);

    // unmount volumes
    hal_unmount_all_volumes(callback_function, user_data);
}


static void do_poweroff(void)
{
    LOGPRINTF("entry");
    
    if (device_state != STATE_DEVICE_STOPPING)
    {
        device_state = STATE_DEVICE_STOPPING;
        busy_add_foreground(0, BUSY_DIALOG_NONE, NULL);
        if (card_state == STATE_CARD_MOUNTED)
        {
            do_unmount(TRUE, "shutdown", on_poweroff_continue, NULL);
        }
        else
        {
            // skip unmounting, power off immediately
            on_poweroff_continue(NULL);
        }
    }
}


static gint get_wakeup_reason()
{
    // get reason
    gint reason = WAKEUP_NO_REASON;
    gint rc = 0;
       
    g_usleep(75*1000); // wait while micro driver reads new values from microcontroller
    rc = read_ionkbd("wakeup_reason", "%d", &reason);
    if (rc <= 0)
    {
        reason = WAKEUP_NO_REASON;
    }
        
#if (LOGGING_ON)
    const gchar *reason_str[] = { "NO_REASON", "KEY", "PEN", "TIMER (standby)", "BATTERY", "COVER", "CARD", "USB", "CHARGE_DETECTED" };
    LOGPRINTF("Wakeup reason: %s", reason_str[reason]);
#endif        
    
    return reason;
}    


#if MACHINE_IS_DR800SG || MACHINE_IS_DR800S  || MACHINE_IS_DR800SW
static gboolean on_check_standby(gpointer data)
{
    LOGPRINTF("entry");

    g_timeout_add(CHECK_STANDBY_TIMEOUT_MS, on_standby, NULL);
    return FALSE;
}


static void prepare_standby()
{
    LOGPRINTF("entry");

    if ( (device_state == STATE_DEVICE_STOPPING) ||                               /* preparing power off */
         (power_state == STATE_POWER_STANDBY) ||                                  /* preparing standby */
         (power_state == STATE_POWER_IDLE) ||                                     /* preparing idle */
         ((usb_state == STATE_USB_UNMOUNTED) && (g_usb_device_source != 0)) )     /* polling for USB charger/host */
    {
        LOGPRINTF("Don't enter standby now! (device_state [%d] power_state [%d] usb_state [%d][%d])", 
          device_state, power_state, usb_state, g_usb_device_source);
        return;
    }
    
    power_state = STATE_POWER_STANDBY;

    LOGPRINTF("Prepare standby");

    // suppress all updates and erase display
    display_splash_lock();
    display_blank();

    // stop optional demo mode
    stop_demo_mode();

    // let application prepare for standby
    ipc_send_prepare_standby();
    conn_stop();

    g_timeout_add(PREPARE_STANDBY_TIMEOUT_MS, on_check_standby, NULL);
}


static gboolean on_holdoff_timeout(gpointer data)
{
    g_holdoff_standby = 0;
    return FALSE;
}


static gboolean on_standby(gpointer data)
{
    LOGPRINTF("entry");
    
    gint cur_level = 0;
    gint retval = 0;
    enum state_charge cur_state = STATE_CHARGE_UNKNOWN;

    if (device_state == STATE_DEVICE_STOPPING)
    {
        WARNPRINTF("Device is stopping, don't enter standby now!");
        return FALSE;
    }
    
    // call standby script and wait for it to return
    
    LOGPRINTF("Enter standby");
    
    // export gconf to INI here so changes made during "prepare standby" as saved
    sys_spawn_sync(ERCONFTOOL_EXPORT);

    // commit buffer cache to disk
    sync();
    
    // suspend wacom to save power
    gboolean wacom_enabled = wacom_is_enabled();
    if (wacom_enabled)
    {
        wacom_disable();
    }

    // do any connection related suspend work
    conn_on_enter_standby();

    if (g_wallcharger_found)
    {
        // enable fast-fast charge
        // will be reset in standby.sh
        write_ionkbd("fastcharge", "1");
    }
    
    sys_spawn_sync("standby.sh");
   
    //
    // Back from standby
    //
    
    LOGPRINTF("Back from standby");

    gint reason = get_wakeup_reason();
    if ( reason == WAKEUP_BATTERY )
    {
        WARNPRINTF("Low battery, power off now");
        do_poweroff();
        return FALSE;
    }

    // reinitialize delta
    display_init();
    display_set_vcom(sys_get_display_vcom());
    display_set_waveforms();
    
    // redraw screen
    display_splash_unlock();
    display_update_return_control(DM_HINT_FULL);

    // check hardware state as it might have changed during standby
    check_hardware();
    
    // check battery state as it might have changed during standby
    retval = sys_get_battery(&cur_level, &cur_state, NULL);
    if (retval == TRUE)
    {                    
        // wakeup to update battery, force!
        update_battery_info(cur_level, cur_state, TRUE);
    }

    sys_update_rgb_led();
        
    power_state = STATE_POWER_RUN;
    // dislay updates are resumed from here

    sys_reset_idle_time();

    // power on wacom again
    if (wacom_enabled)
    {
        wacom_enable();
    }

    g_holdoff_standby = g_timeout_add_seconds(HOLDOFF_STANDBY_TIMEOUT, on_holdoff_timeout, NULL);
    
    gboolean do_drz = check_and_install_drz();
    gboolean do_firmware = sys_check_and_install_firmware();
    gboolean do_disk = check_disk_free();

    conn_on_leave_standby();

    if (!(do_drz || do_firmware || do_disk)) {
        if (g_file_test(MOUNTPOINT_CARD"/"DEMO_FILE, G_FILE_TEST_EXISTS)) {
            start_demo_mode();
        }
    }

    return FALSE;
}

#endif


static void do_idle()
{
    LOGPRINTF("entry");

    gint cur_level = 0;
    gint retval = 0;
    static glong standby_time = 0;
    enum state_charge cur_state = STATE_CHARGE_UNKNOWN;
    
    if (!g_idle_enabled)
    {
        return;
    }

    if ((device_state == STATE_DEVICE_STOPPING) || (power_state == STATE_POWER_STANDBY))
    {
        LOGPRINTF("Don't enter idle now! (device_state [%d] power_state [%d])",
                    device_state, power_state);
        return;
    }
    
    power_state = STATE_POWER_IDLE;
    // dislay updates are resumed from here

    // suspend wacom to save power
    if (wacom_is_enabled())
    {
        wacom_suspend();
    }

    if ( (g_standby_timeout_sec > 0) 
        && (g_standby_if_plugged || (usb_state == STATE_USB_DISCONNECTED)) )
    {
        // calculate and set standby time
        GTimeVal curtime;
        g_get_current_time(&curtime);
        
        if ((standby_time == 0) || (standby_time <= curtime.tv_sec))
        {
            standby_time = curtime.tv_sec + g_standby_timeout_sec;
        }

        gint min_before_standby = (standby_time - curtime.tv_sec) / 60;
        
        LOGPRINTF("Minutes before standby: %d, standby time: %ld, now: %ld",
                  min_before_standby, standby_time, curtime.tv_sec); 
            
        if (min_before_standby > 0)
        {
            // call idle script and wait for it to return
            gchar *command = g_strdup_printf("idle.sh %d", min_before_standby);
            sys_spawn_sync(command);
            g_free(command);
        }
        else
        {
            WARNPRINTF("Go to standby immediately");
            sys_standby();
            return;
        }
    }
    else
    {
        // call idle script and wait for it to return
        LOGPRINTF("Enter idle without standby");
        sys_spawn_sync("idle.sh");
    }

    //
    // Back from idle
    //
    
    LOGPRINTF("Back from idle");

    gint reason = get_wakeup_reason();
    if ( (reason == WAKEUP_TIMER) && 
         (g_standby_if_plugged || (usb_state == STATE_USB_DISCONNECTED)) )
    {
        WARNPRINTF("Idle timed out, go to standby now");
        standby_time = 0;
        power_state = STATE_POWER_RUN;
        sys_standby();
    }
    else
    {
        // check hardware state as it might have changed during idle
        if (reason == WAKEUP_USB)
        {
            check_hardware();
        }
        
        // check battery state as it might have changed during idle
        retval = sys_get_battery(&cur_level, &cur_state, NULL);
        if (retval == TRUE)
        {                    
            // reflect new battery/charge state
            if (reason == WAKEUP_BATTERY)                
            {
                // wakeup to update battery, force!
                update_battery_info(cur_level, cur_state, TRUE);
            }
            else
            {
                update_battery_info(cur_level, cur_state, FALSE);
            }
        }

        sys_update_rgb_led();
            
        standby_time = 0;
        power_state = STATE_POWER_RUN;
        sys_reset_idle_time(); 

        if (wacom_is_enabled())
        {
            if (reason == WAKEUP_PEN)
            {
                // resume Wacom from suspend
                wacom_resume();
            }
            else
            {
                // reset Wacom hardware as it may be stuck
                wacom_reset();
            }
        }
    }
}