rockbox/firmware/powermgmt.c

/***************************************************************************
 *             __________               __   ___.
 *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
 *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
 *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
 *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
 *                     \/            \/     \/    \/            \/
 * $Id$
 *
 * Copyright (C) 2002 by Heikki Hannikainen, Uwe Freese
 * Revisions copyright (C) 2005 by Gerald Van Baren
 *
 * All files in this archive are subject to the GNU General Public License.
 * See the file COPYING in the source tree root for full license agreement.
 *
 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
 * KIND, either express or implied.
 *
 ****************************************************************************/
#include "config.h"
#include "cpu.h"
#include "kernel.h"
#include "thread.h"
#include "system.h"
#include "debug.h"
#include "panic.h"
#include "adc.h"
#include "string.h"
#include "sprintf.h"
#include "ata.h"
#include "power.h"
#include "button.h"
#include "audio.h"
#include "mp3_playback.h"
#include "usb.h"
#include "powermgmt.h"
#include "backlight.h"
#include "lcd.h"
#include "rtc.h"
#if CONFIG_TUNER
#include "fmradio.h"
#endif
#include "sound.h"
#ifdef HAVE_LCD_BITMAP
#include "font.h"
#endif
#if defined(HAVE_RECORDING) && (CONFIG_CODEC == SWCODEC)
#include "pcm_record.h"
#endif
#include "logf.h"
#include "lcd-remote.h"
#ifdef SIMULATOR
#include <time.h>
#endif

#if (defined(IAUDIO_X5) || defined(IAUDIO_M5)) && !defined (SIMULATOR)
#include "pcf50606.h"
#include "lcd-remote-target.h"
#endif

/*
 * Define DEBUG_FILE to create a csv (spreadsheet) with battery information
 * in it (one sample per minute).  This is only for very low level debug.
 */
#undef  DEBUG_FILE
#if defined(DEBUG_FILE) && (CONFIG_CHARGING == CHARGING_CONTROL)
#include "file.h"
#define DEBUG_FILE_NAME   "/powermgmt.csv"
#define DEBUG_MESSAGE_LEN 133
static char debug_message[DEBUG_MESSAGE_LEN];
#define DEBUG_STACK ((0x1000)/sizeof(long))
static int fd;          /* write debug information to this file */
static int wrcount;
#else
#define DEBUG_STACK 0
#endif

static int shutdown_timeout = 0;

#ifdef SIMULATOR /***********************************************************/

#define BATT_MINCVOLT   250             /* minimum centivolts of battery */
#define BATT_MAXCVOLT   450             /* maximum centivolts of battery */
#define BATT_MAXRUNTIME (10 * 60)       /* maximum runtime with full battery in minutes */

static unsigned int batt_centivolts = (unsigned int)BATT_MAXCVOLT;
static int batt_level = 100;            /* battery capacity level in percent */
static int batt_time = BATT_MAXRUNTIME; /* estimated remaining time in minutes */
static time_t last_change = 0;

static void battery_status_update(void)
{
    time_t          now;

    time(&now);
    if (last_change < now) {
        last_change = now;

        /* change the values: */
        batt_centivolts -= (unsigned int)(BATT_MAXCVOLT - BATT_MINCVOLT) / 101;
        if (batt_centivolts < (unsigned int)BATT_MINCVOLT)
            batt_centivolts = (unsigned int)BATT_MAXCVOLT;

        batt_level = 100 * (batt_centivolts - BATT_MINCVOLT) / (BATT_MAXCVOLT - BATT_MINCVOLT);
        batt_time = batt_level * BATT_MAXRUNTIME / 100;
    }
}

void battery_read_info(int *adc, int *voltage, int *level)
{
    battery_status_update();

    if (adc)
        *adc = batt_centivolts; /* just return something */

    if (voltage)
        *voltage = batt_centivolts;

    if (level)
        *level = batt_level;
}

unsigned int battery_voltage(void)
{
    battery_status_update();
    return batt_centivolts;
}

int battery_level(void)
{
    battery_status_update();
    return batt_level;
}

int battery_time(void)
{
    battery_status_update();
    return batt_time;
}

bool battery_level_safe(void)
{
    return battery_level() >= 10;
}

void set_poweroff_timeout(int timeout)
{
    (void)timeout;
}

void set_battery_capacity(int capacity)
{
  (void)capacity;
}

void reset_poweroff_timer(void)
{
}


#else /* not SIMULATOR ******************************************************/

static const int poweroff_idle_timeout_value[15] =
{
    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 15, 30, 45, 60
};

static const unsigned int battery_level_dangerous[BATTERY_TYPES_COUNT] =
{
#if CONFIG_BATTERY == BATT_LIION2200    /* FM Recorder, LiIon */
    280
#elif CONFIG_BATTERY == BATT_3AAA       /* Ondio: Alkaline, NiHM */
    310, 345
#elif CONFIG_BATTERY == BATT_1AA        /* iRiver iFP: Alkaline, NiHM */
    105, 115
#elif CONFIG_BATTERY == BATT_LIPOL1300  /* iRiver H1x0: LiPolymer */
    338
#elif CONFIG_BATTERY == BATT_LIION300   /* ipod nano */
    333
#elif CONFIG_BATTERY == BATT_LIION400   /* iPOD Video 30GB */
    345
#elif CONFIG_BATTERY == BATT_LIION750   /* Sansa e200 */
    340
#elif CONFIG_BATTERY == BATT_LIION830   /* Gigabeat F */
    345
#elif CONFIG_BATTERY == BATT_IAUDIO_X5M5  /* iAudio X5 */
    354
#elif CONFIG_BATTERY == BATT_LPCS355385 /* iriver H10 20GB: LiPolymer*/
    376
#elif CONFIG_BATTERY == BATT_BP009      /* iriver H10 5/6GB: LiPolymer */
    372
#else                                   /* Player/recorder: NiMH */
    475
#endif
};

static const unsigned short battery_level_shutoff[BATTERY_TYPES_COUNT] =
{
#if   CONFIG_BATTERY == BATT_LIION2200  /* FM Recorder */
    258
#elif CONFIG_BATTERY == BATT_3AAA       /* Ondio */
    270, 280
#elif CONFIG_BATTERY == BATT_LIPOL1300  /* iRiver Hxxx */
    302
#elif CONFIG_BATTERY == BATT_LIION300   /* ipod nano */
    323
#elif CONFIG_BATTERY == BATT_LIION400   /* iPOD Video 30GB */
    345
#elif CONFIG_BATTERY == BATT_LIION750   /* Sansa e200 */
    330
#elif CONFIG_BATTERY == BATT_LIION830   /* Gigabeat F */
    340
#elif CONFIG_BATTERY == BATT_IAUDIO_X5M5  /* iAudio X5 */
    350
#elif CONFIG_BATTERY == BATT_LPCS355385 /* iriver H10 20GB */
    365
#elif CONFIG_BATTERY == BATT_BP009      /* iriver H10 5/6GB */
    365
#else                                   /* Player/recorder: NiMH */
    440
#endif
};

/* voltages (centivolt) of 0%, 10%, ... 100% when charging disabled */
static const unsigned short percent_to_volt_discharge[BATTERY_TYPES_COUNT][11] =
{
#if CONFIG_BATTERY == BATT_LIION2200
    /* measured values */
    { 260, 285, 295, 303, 311, 320, 330, 345, 360, 380, 400 }
#elif CONFIG_BATTERY == BATT_3AAA
    /* measured values */
    { 280, 325, 341, 353, 364, 374, 385, 395, 409, 427, 475 }, /* Alkaline */
    { 310, 355, 363, 369, 372, 374, 376, 378, 380, 386, 405 }  /* NiMH */
#elif CONFIG_BATTERY == BATT_LIPOL1300
    /* Below 337 the backlight starts flickering during HD access */
    { 337, 365, 370, 374, 378, 382, 387, 393, 400, 408, 416 }
#elif CONFIG_BATTERY == BATT_IAUDIO_X5M5
    /* average measured values from X5 and M5L */
    { 350, 365, 372, 374, 376, 379, 384, 390, 395, 404, 412 }
#elif CONFIG_BATTERY == BATT_LPCS355385
    /* iriver H10 20GB */
    { 376, 380, 385, 387, 390, 395, 402, 407, 411, 418, 424 }
#elif CONFIG_BATTERY == BATT_BP009
    /* iriver H10 5/6GB */
    { 372, 374, 380, 382, 384, 388, 394, 402, 406, 415, 424 }
#elif CONFIG_BATTERY == BATT_1AA
    /* These values are the same as for 3AAA divided by 3. */
    /* May need recalibration. */
    {  93, 108, 114, 118, 121, 125, 128, 132, 136, 142, 158 }, /* alkaline */
    { 103, 118, 121, 123, 124, 125, 126, 127, 128, 129, 135 }  /* NiMH */
#elif CONFIG_BATTERY == BATT_LIION830
    /* Toshiba Gigabeat Li Ion 830mAH figured from discharge curve */
    { 348, 355, 359, 361, 363, 365, 370, 376, 380, 391, 399 },
#elif CONFIG_BATTERY == BATT_LIION750
    /* Sansa Li Ion 750mAH FIXME this is a first linear approach */
    { 330, 339, 348, 357, 366, 375, 384, 393, 402, 411, 420 },
#elif CONFIG_BATTERY == BATT_LIION400  /* iPOD Video 30GB */
    /* iPOD Video 30GB Li-Ion 400mAh, first approach based upon measurements */
    { 345, 367, 371, 375, 379, 383, 387, 393, 401, 410, 418 },
#elif CONFIG_BATTERY == BATT_LIION300
    /* measured values */
    { 323, 362, 370, 373, 375, 378, 383, 389, 395, 403, 416 },
#else /* NiMH */
    /* original values were taken directly after charging, but it should show
       100% after turning off the device for some hours, too */
    { 450, 481, 491, 497, 503, 507, 512, 514, 517, 525, 540 }
                                            /* orig. values: ...,528,560 */
#endif
};

#if CONFIG_CHARGING
charger_input_state_type charger_input_state IDATA_ATTR;


/* voltages (centivolt) of 0%, 10%, ... 100% when charging enabled */
static const unsigned short percent_to_volt_charge[11] =
{
#if CONFIG_BATTERY == BATT_LIPOL1300
    /* values measured over one full charging cycle */
    354, 386, 393, 398, 400, 402, 404, 408, 413, 418, 423 /* LiPo */
#elif CONFIG_BATTERY == BATT_LIION300
    /* measured values */
    323, 362, 370, 373, 375, 378, 383, 389, 395, 403, 416
#elif CONFIG_BATTERY == BATT_LIION400
    /* iPOD Video 30GB Li-Ion 400mAh, first approach based upon measurements */
    345, 367, 371, 375, 379, 383, 387, 393, 401, 410, 418
#elif CONFIG_BATTERY == BATT_LIION750
    /* Sansa Li Ion 750mAH FIXME*/
    330, 339, 348, 357, 366, 375, 384, 393, 402, 411, 420 
#elif CONFIG_BATTERY == BATT_LIION830
    /* Toshiba Gigabeat Li Ion 830mAH */
    348, 355, 359, 361, 363, 365, 370, 376, 380, 391, 399
#elif CONFIG_BATTERY == BATT_LPCS355385
    /* iriver H10 20GB */
    399, 403, 406, 408, 410, 412, 415, 418, 422, 426, 431
#elif CONFIG_BATTERY == BATT_BP009
    /* iriver H10 5/6GB: Not yet calibrated */
    388, 392, 396, 400, 406, 410, 415, 419, 424, 428, 433
#else
    /* values guessed, see
       http://www.seattlerobotics.org/encoder/200210/LiIon2.pdf until someone
       measures voltages over a charging cycle */
    476, 544, 551, 556, 561, 564, 566, 576, 582, 584, 585 /* NiMH */
#endif
};
#endif /* CONFIG_CHARGING */

#if CONFIG_CHARGING >= CHARGING_MONITOR
charge_state_type charge_state;     /* charging mode */
#endif

#if CONFIG_CHARGING == CHARGING_CONTROL
int long_delta;                     /* long term delta battery voltage */
int short_delta;                    /* short term delta battery voltage */
bool disk_activity_last_cycle = false;         /* flag set to aid charger time
                                                * calculation */
char power_message[POWER_MESSAGE_LEN] = "";    /* message that's shown in
                                                  debug menu */
                                               /* percentage at which charging
                                                  starts */
int powermgmt_last_cycle_startstop_min = 0;    /* how many minutes ago was the
                                                  charging started or
                                                  stopped? */
int powermgmt_last_cycle_level = 0;            /* which level had the
                                                  batteries at this time? */
int trickle_sec = 0;                           /* how many seconds should the
                                                  charger be enabled per
                                                  minute for trickle
                                                  charging? */
int pid_p = 0;                      /* PID proportional term */
int pid_i = 0;                      /* PID integral term */
#endif /* CONFIG_CHARGING == CHARGING_CONTROL */

/*
 * Average battery voltage and charger voltage, filtered via a digital
 * exponential filter.
 */
static unsigned int avgbat;     /* average battery voltage (filtering) */
static unsigned int battery_centivolts;/* filtered battery voltage, centvolts */
#ifdef HAVE_CHARGE_CTRL
#define BATT_AVE_SAMPLES    32  /* filter constant / @ 2Hz sample rate */
#elif CONFIG_BATTERY == BATT_LIPOL1300
#define BATT_AVE_SAMPLES   128  /* slow filter for iriver */
#else
#define BATT_AVE_SAMPLES    64  /* medium filter constant for all others */
#endif

/* battery level (0-100%) of this minute, updated once per minute */
static int battery_percent  = -1;
static int battery_capacity = BATTERY_CAPACITY_DEFAULT; /* default value, mAh */
static int battery_type     = 0;

/* Power history: power_history[0] is the newest sample */
unsigned short power_history[POWER_HISTORY_LEN];

static char power_stack[DEFAULT_STACK_SIZE/2 + DEBUG_STACK];
static const char power_thread_name[] = "power";

static int poweroff_timeout = 0;
static int powermgmt_est_runningtime_min = -1;

static bool sleeptimer_active = false;
static long sleeptimer_endtick;

static long last_event_tick;

static int voltage_to_battery_level(int battery_centivolts);
static void battery_status_update(void);
static int runcurrent(void);

void battery_read_info(int *adc, int *voltage, int *level)
{
    int adc_battery = adc_read(ADC_UNREG_POWER);
    int centivolts  = adc_battery*BATTERY_SCALE_FACTOR / 10000;

    if (adc)
        *adc = adc_battery;

    if (voltage)
        *voltage = centivolts;

    if (level)
        *level = voltage_to_battery_level(centivolts);
}

void reset_poweroff_timer(void)
{
    last_event_tick = current_tick;
}

#if BATTERY_TYPES_COUNT > 1
void set_battery_type(int type)
{
    if (type != battery_type) {
        battery_type = type;
        battery_status_update();     /* recalculate the battery status */
    }
}
#endif

void set_battery_capacity(int capacity)
{
    battery_capacity = capacity;
    if (battery_capacity > BATTERY_CAPACITY_MAX)
        battery_capacity = BATTERY_CAPACITY_MAX;
    if (battery_capacity < BATTERY_CAPACITY_MIN)
        battery_capacity = BATTERY_CAPACITY_MIN;
    battery_status_update();     /* recalculate the battery status */
}

int battery_time(void)
{
    return powermgmt_est_runningtime_min;
}

/* Returns battery level in percent */
int battery_level(void)
{
    return battery_percent;
}

/* Returns filtered battery voltage [centivolts] */
unsigned int battery_voltage(void)
{
    return battery_centivolts;
}

/* Returns battery voltage from ADC [centivolts] */
int battery_adc_voltage(void)
{
    return (adc_read(ADC_UNREG_POWER) * BATTERY_SCALE_FACTOR + 5000) / 10000;
}

/* Tells if the battery level is safe for disk writes */
bool battery_level_safe(void)
{
    return battery_centivolts > battery_level_dangerous[battery_type];
}

void set_poweroff_timeout(int timeout)
{
    poweroff_timeout = timeout;
}

void set_sleep_timer(int seconds)
{
    if(seconds) {
        sleeptimer_active  = true;
        sleeptimer_endtick = current_tick + seconds * HZ;
    }
    else {
        sleeptimer_active  = false;
        sleeptimer_endtick = 0;
    }
}

int get_sleep_timer(void)
{
    if(sleeptimer_active)
        return (sleeptimer_endtick - current_tick) / HZ;
    else
        return 0;
}

/* look into the percent_to_volt_* table and get a realistic battery level */
static int voltage_to_percent(int voltage, const short* table)
{
    if (voltage <= table[0])
        return 0;
    else
        if (voltage >= table[10])
            return 100;
        else {
            /* search nearest value */
            int i = 0;
            while ((i < 10) && (table[i+1] < voltage))
                i++;
            /* interpolate linear between the smaller and greater value */
            return (i * 10) /* Tens digit, 10% per entry */
                + (((voltage - table[i]) * 10)
                   / (table[i+1] - table[i])); /* Ones digit: interpolated */
        }
}

/* update battery level and estimated runtime, called once per minute or
 * when battery capacity / type settings are changed */
static int voltage_to_battery_level(int battery_centivolts)
{
    int level;

#if defined(CONFIG_CHARGER) && CONFIG_BATTERY == BATT_LIPOL1300
    if (charger_input_state == NO_CHARGER) {
        /* discharging. calculate new battery level and average with last */
        level = voltage_to_percent(battery_centivolts,
                percent_to_volt_discharge[battery_type]);
        if (level != (battery_percent - 1))
            level = (level + battery_percent + 1) / 2;
    }
    else if (charger_input_state == CHARGER_UNPLUGGED) {
        /* just unplugged. adjust filtered values */
        battery_centivolts -= percent_to_volt_charge[battery_percent/10] -
                              percent_to_volt_discharge[0][battery_percent/10];
        avgbat = battery_centivolts * 10000 * BATT_AVE_SAMPLES;
        level  = battery_percent;
    }
    else if (charger_input_state == CHARGER_PLUGGED) {
        /* just plugged in. adjust battery values */
        battery_centivolts += percent_to_volt_charge[battery_percent/10] -
                              percent_to_volt_discharge[0][battery_percent/10];
        avgbat = battery_centivolts * 10000 * BATT_AVE_SAMPLES;
        level  = MIN(12 * battery_percent / 10, 99);
    }
    else { /* charging. calculate new battery level */
        level = voltage_to_percent(battery_centivolts,
                percent_to_volt_charge);
    }
#elif CONFIG_CHARGING >= CHARGING_MONITOR
    if (charge_state == DISCHARGING) {
        level = voltage_to_percent(battery_centivolts,
                    percent_to_volt_discharge[battery_type]);
    }
    else if (charge_state == CHARGING) {
        /* battery level is defined to be < 100% until charging is finished */
        level = MIN(voltage_to_percent(battery_centivolts,
                    percent_to_volt_charge), 99);
    }
    else { /* in topoff/trickle charge, battery is by definition 100% full */
        level = 100;
    }
#else
    /* always use the discharge table */
    level = voltage_to_percent(battery_centivolts,
                percent_to_volt_discharge[battery_type]);
#endif

    return level;
}

static void battery_status_update(void)
{
    int level = voltage_to_battery_level(battery_centivolts);


    /* calculate estimated remaining running time */
    /* discharging: remaining running time */
    /* charging:    remaining charging time */
#if CONFIG_CHARGING >= CHARGING_MONITOR
    if (charge_state == CHARGING) {
        powermgmt_est_runningtime_min = (100 - level) * battery_capacity * 60
                                      / 100 / (CURRENT_MAX_CHG - runcurrent());
    }
    else
#elif CONFIG_CHARGING && CONFIG_BATTERY == BATT_LIPOL1300
    if (charger_inserted()) {
#ifdef IRIVER_H300_SERIES
        /* H300_SERIES use CURRENT_MAX_CHG for basic charge time (80%)
         * plus 110 min top off charge time */
        powermgmt_est_runningtime_min = ((100-level) * battery_capacity * 80
                                         /100 / CURRENT_MAX_CHG) + 110;
#else
        /* H100_SERIES scaled for 160 min basic charge time (80%) on
         * 1600 mAh battery plus 110 min top off charge time */
        powermgmt_est_runningtime_min = ((100 - level) * battery_capacity
                                         / 993) + 110;
#endif
        level = (level * 80) / 100;
        if (level > 72) { /* > 91% */
            int i = POWER_HISTORY_LEN;
            int d = 1;
#ifdef HAVE_CHARGE_STATE
            if (charge_state == DISCHARGING)
                d = -2;
#endif
            while ((i > 2) && (d > 0)) /* search zero or neg. delta */
                d = power_history[0] - power_history[--i];
            if ((((d == 0) && (i > 6)) || (d == -1)) && (i < 118)) {
                /* top off charging */
                level = MIN(80 + (i*19 / 113), 99);  /* show 81% .. 99% */
                powermgmt_est_runningtime_min = MAX(116 - i, 0);
            }
            else if ((d < 0) || (i > 117)) {
                /* charging finished */
                level = 100;
                powermgmt_est_runningtime_min = battery_capacity * 60
                                                / runcurrent();
            }
        }
    }
    else
#endif /* BATT_LIPOL1300 */
    {
        if ((battery_centivolts + 2) > percent_to_volt_discharge[0][0])
            powermgmt_est_runningtime_min = (level + battery_percent) * 60 *
                                         battery_capacity / 200 / runcurrent();
        else
            powermgmt_est_runningtime_min = (battery_centivolts -
                                             battery_level_shutoff[0]) / 2;
    }

    battery_percent = level;
}

/*
 * We shut off in the following cases:
 * 1) The unit is idle, not playing music
 * 2) The unit is playing music, but is paused
 * 3) The battery level has reached shutdown limit
 *
 * We do not shut off in the following cases:
 * 1) The USB is connected
 * 2) The charger is connected
 * 3) We are recording, or recording with pause
 * 4) The radio is playing
 */
static void handle_auto_poweroff(void)
{
    long timeout = poweroff_idle_timeout_value[poweroff_timeout]*60*HZ;
    int  audio_stat = audio_status();

#if CONFIG_CHARGING
    /*
     * Inhibit shutdown as long as the charger is plugged in.  If it is
     * unplugged, wait for a timeout period and then shut down.
     */
    if(charger_input_state == CHARGER || audio_stat == AUDIO_STATUS_PLAY) {
        last_event_tick = current_tick;
    }
#endif

    /* switch off unit if battery level is too low for reliable operation */
#if (CONFIG_BATTERY!=BATT_4AA_NIMH) && (CONFIG_BATTERY!=BATT_3AAA)&& \
    (CONFIG_BATTERY!=BATT_1AA)
    if(battery_centivolts < battery_level_shutoff[battery_type]) {
        if(!shutdown_timeout) {
            backlight_on();
            sys_poweroff();
        }
    }
#endif

    if(timeout &&
#if CONFIG_TUNER && !defined(BOOTLOADER)
       (!(get_radio_status() & FMRADIO_PLAYING)) &&
#endif
       !usb_inserted() &&
       ((audio_stat == 0) ||
        ((audio_stat == (AUDIO_STATUS_PLAY | AUDIO_STATUS_PAUSE)) &&
         !sleeptimer_active)))
    {
        if(TIME_AFTER(current_tick, last_event_tick    + timeout) &&
           TIME_AFTER(current_tick, last_disk_activity + timeout))
        {
            sys_poweroff();
        }
    }
    else
    {
        /* Handle sleeptimer */
        if(sleeptimer_active && !usb_inserted())
        {
            if(TIME_AFTER(current_tick, sleeptimer_endtick))
            {
                audio_stop();
#if CONFIG_CHARGING && !defined(HAVE_POWEROFF_WHILE_CHARGING)
                if((charger_input_state == CHARGER) ||
                   (charger_input_state == CHARGER_PLUGGED))
                {
                    DEBUGF("Sleep timer timeout. Stopping...\n");
                    set_sleep_timer(0);
                    backlight_off(); /* Nighty, nighty... */
                }
                else
#endif
                {
                    DEBUGF("Sleep timer timeout. Shutting off...\n");
                    sys_poweroff();
                }
            }
        }
    }
}

/*
 * Estimate how much current we are drawing just to run.
 */
static int runcurrent(void)
{
    int current;

#if MEM == 8 && !defined(HAVE_MMC)
    /* assuming 192 kbps, the running time is 22% longer with 8MB */
    current = (CURRENT_NORMAL*100/122);
#else
    current = CURRENT_NORMAL;
#endif /* MEM == 8 */

    if(usb_inserted()
#if defined(HAVE_USB_POWER)
  #if (CURRENT_USB < CURRENT_NORMAL)
       || usb_powered()
  #else
       && !usb_powered()
  #endif
#endif
    )
    {
        current = CURRENT_USB;
    }

#if defined(HAVE_BACKLIGHT) && !defined(BOOTLOADER)
    if (backlight_get_current_timeout() == 0) /* LED always on */
        current += CURRENT_BACKLIGHT;
#endif

#if defined(HAVE_RECORDING) && defined(CURRENT_RECORD)
    if (audio_status() & AUDIO_STATUS_RECORD)
        current += CURRENT_RECORD;
#endif

#ifdef HAVE_SPDIF_POWER
    if (spdif_powered())
        current += CURRENT_SPDIF_OUT;
#endif

#ifdef HAVE_REMOTE_LCD
    if (remote_detect())
        current += CURRENT_REMOTE;
#endif

    return(current);
}


/* Check to see whether or not we've received an alarm in the last second */
#ifdef HAVE_RTC_ALARM
static void power_thread_rtc_process(void)
{
    if (rtc_check_alarm_flag()) {
        rtc_enable_alarm(false);
    }
}
#endif

/*
 * This function is called to do the relativly long sleep waits from within the
 * main power_thread loop while at the same time servicing any other periodic
 * functions in the power thread which need to be called at a faster periodic
 * rate than the slow periodic rate of the main power_thread loop.
 *
 * While we are waiting for the time to expire, we average the battery
 * voltages.
 */
static void power_thread_sleep(int ticks)
{
    int small_ticks;

    while (ticks > 0) {

#if CONFIG_CHARGING
        /*
         * Detect charger plugged/unplugged transitions.  On a plugged or
         * unplugged event, we return immediately, run once through the main
         * loop (including the subroutines), and end up back here where we
         * transition to the appropriate steady state charger on/off state.
         */
        if(charger_inserted()
#ifdef HAVE_USB_POWER /* USB powered or USB inserted both provide power */
                || usb_powered()
#if CONFIG_CHARGING
                || (usb_inserted() && usb_charging_enabled())
#endif
#endif
                ) {
            switch(charger_input_state) {
                case NO_CHARGER:
                case CHARGER_UNPLUGGED:
                    charger_input_state = CHARGER_PLUGGED;
                    return;
                case CHARGER_PLUGGED:
                    queue_broadcast(SYS_CHARGER_CONNECTED, 0);
                    charger_input_state = CHARGER;
                    break;
                case CHARGER:
                    break;
            }
        } else {    /* charger not inserted */
            switch(charger_input_state) {
                case NO_CHARGER:
                    break;
                case CHARGER_UNPLUGGED:
                    queue_broadcast(SYS_CHARGER_DISCONNECTED, 0);
                    charger_input_state = NO_CHARGER;
                    break;
                case CHARGER_PLUGGED:
                case CHARGER:
                    charger_input_state = CHARGER_UNPLUGGED;
                    return;
            }
        }
#endif
#if CONFIG_CHARGING == CHARGING_MONITOR
        switch (charger_input_state) {
            case CHARGER_UNPLUGGED:
            case NO_CHARGER:
                charge_state = DISCHARGING;
                break;
            case CHARGER_PLUGGED:
            case CHARGER:
                if (charging_state()) {
                    charge_state = CHARGING;
                } else {
                    charge_state = DISCHARGING;
                }
                break;
        }

#endif /* CONFIG_CHARGING == CHARGING_MONITOR */

        small_ticks = MIN(HZ/2, ticks);
        sleep(small_ticks);
        ticks -= small_ticks;

        /* If the power off timeout expires, the main thread has failed
           to shut down the system, and we need to force a power off */
        if(shutdown_timeout) {
            shutdown_timeout -= small_ticks;
            if(shutdown_timeout <= 0)
                power_off();
        }

#ifdef HAVE_RTC_ALARM
        power_thread_rtc_process();
#endif

        /*
         * Do a digital exponential filter.  We don't sample the battery if
         * the disk is spinning unless we are in USB mode (the disk will most
         * likely always be spinning in USB mode).
         */
        if (!ata_disk_is_active() || usb_inserted()) {
            avgbat += adc_read(ADC_UNREG_POWER) * BATTERY_SCALE_FACTOR
                      - (avgbat / BATT_AVE_SAMPLES);
            /*
             * battery_centivolts is the centivolt-scaled filtered battery value.
             */
            battery_centivolts = (avgbat / BATT_AVE_SAMPLES + 5000) / 10000;

            /* update battery status every time an update is available */
            battery_status_update();
        }
        else if (battery_percent < 8) {
            /* If battery is low, observe voltage during disk activity.
             * Shut down if voltage drops below shutoff level and we are not
             * using NiMH or Alkaline batteries.
             */
            battery_centivolts = (battery_adc_voltage() +
                                  battery_centivolts + 1) / 2;

            /* update battery status every time an update is available */
            battery_status_update();

#if (CONFIG_BATTERY!=BATT_4AA_NIMH) && (CONFIG_BATTERY!=BATT_3AAA)&& \
    (CONFIG_BATTERY!=BATT_1AA)
            if (!shutdown_timeout &&
                (battery_centivolts < battery_level_shutoff[battery_type]))
                sys_poweroff();
            else
#endif
                avgbat += battery_centivolts * 10000
                          - (avgbat / BATT_AVE_SAMPLES);
        }

#if CONFIG_CHARGING == CHARGING_CONTROL
        if (ata_disk_is_active()) {
            /* flag hdd use for charging calculation */
            disk_activity_last_cycle = true;
        }
#endif
#if defined(DEBUG_FILE) && (CONFIG_CHARGING == CHARGING_CONTROL)
        /*
         * If we have a lot of pending writes or if the disk is spining,
         * fsync the debug log file.
         */
        if((wrcount > 10) || ((wrcount > 0) && ata_disk_is_active())) {
            fsync(fd);
            wrcount = 0;
        }
#endif
    }
}


/*
 * This power thread maintains a history of battery voltage
 * and implements a charging algorithm.
 * For a complete description of the charging algorithm read
 * docs/CHARGING_ALGORITHM.
 */

static void power_thread(void)
{
    int i;
    short *phps, *phpd;         /* power history rotation pointers */
#if CONFIG_CHARGING == CHARGING_CONTROL
    unsigned int target_voltage = TRICKLE_VOLTAGE;    /* desired topoff/trickle
                                       * voltage level */
    int charge_max_time_idle = 0;     /* max. charging duration, calculated at
                                       * beginning of charging */
    int charge_max_time_now = 0;      /* max. charging duration including
                                       * hdd activity */
    int minutes_disk_activity = 0;    /* count minutes of hdd use during
                                       * charging */
    int last_disk_activity = CHARGE_END_LONGD + 1; /* last hdd use x mins ago */
#endif

    /* initialize the voltages for the exponential filter */
    avgbat = adc_read(ADC_UNREG_POWER) * BATTERY_SCALE_FACTOR + 15000;

#ifndef HAVE_MMC  /* this adjustment is only needed for HD based */
        /* The battery voltage is usually a little lower directly after
           turning on, because the disk was used heavily. Raise it by 5% */
#ifdef HAVE_CHARGING
    if(!charger_inserted()) /* only if charger not connected */
#endif
        avgbat += (percent_to_volt_discharge[battery_type][6] -
                   percent_to_volt_discharge[battery_type][5]) * 5000;
#endif /* not HAVE_MMC */

    avgbat = avgbat * BATT_AVE_SAMPLES;
    battery_centivolts = avgbat / BATT_AVE_SAMPLES / 10000;

#if CONFIG_CHARGING
    if(charger_inserted()) {
        battery_percent  = voltage_to_percent(battery_centivolts,
                           percent_to_volt_charge);
#if CONFIG_BATTERY == BATT_LIPOL1300
        charger_input_state = CHARGER;
#endif
    } else
#endif
    {   battery_percent  = voltage_to_percent(battery_centivolts,
                           percent_to_volt_discharge[battery_type]);
        battery_percent += (battery_percent < 100);
    }

#if defined(DEBUG_FILE) && (CONFIG_CHARGING == CHARGING_CONTROL)
    fd      = -1;
    wrcount = 0;
#endif

    while (1)
    {
        /* rotate the power history */
        phpd = &power_history[POWER_HISTORY_LEN - 1];
        phps = phpd - 1;
        for (i = 0; i < POWER_HISTORY_LEN-1; i++)
            *phpd-- = *phps--;

        /* insert new value at the start, in centivolts 8-) */
        power_history[0] = battery_centivolts;

#if CONFIG_CHARGING == CHARGING_CONTROL
        if (charger_input_state == CHARGER_PLUGGED) {
            pid_p = 0;
            pid_i = 0;
            snprintf(power_message, POWER_MESSAGE_LEN, "Charger plugged in");
            /*
             * The charger was just plugged in.  If the battery level is
             * nearly charged, just trickle.  If the battery is low, start
             * a full charge cycle.  If the battery level is in between,
             * top-off and then trickle.
             */
            if(battery_percent > START_TOPOFF_CHG) {
                powermgmt_last_cycle_level = battery_percent;
                powermgmt_last_cycle_startstop_min = 0;
                if(battery_percent >= START_TRICKLE_CHG) {
                    charge_state = TRICKLE;
                    target_voltage = TRICKLE_VOLTAGE;
                } else {
                    charge_state = TOPOFF;
                    target_voltage = TOPOFF_VOLTAGE;
                }
            } else {
                /*
                 * Start the charger full strength
                 */
                i = CHARGE_MAX_TIME_1500 * battery_capacity / 1500;
                charge_max_time_idle =
                    i * (100 + 35 - battery_percent) / 100;
                if (charge_max_time_idle > i) {
                    charge_max_time_idle = i;
                }
                charge_max_time_now = charge_max_time_idle;

                snprintf(power_message, POWER_MESSAGE_LEN,
                         "ChgAt %d%% max %dm", battery_level(),
                         charge_max_time_now);

                /* enable the charger after the max time calc is done,
                   because battery_level depends on if the charger is
                   on */
                DEBUGF("power: charger inserted and battery"
                       " not full, charging\n");
                powermgmt_last_cycle_level = battery_percent;
                powermgmt_last_cycle_startstop_min = 0;
                trickle_sec  = 60;
                long_delta   = short_delta = 999999;
                charge_state = CHARGING;
            }
        }
        if (charge_state == CHARGING) {
            /* alter charge time max length with extra disk use */
            if (disk_activity_last_cycle) {
                minutes_disk_activity++;
                charge_max_time_now = charge_max_time_idle +
                                     (minutes_disk_activity * 2 / 5);
                disk_activity_last_cycle = false;
                last_disk_activity = 0;
            } else {
                last_disk_activity++;
            }
            /*
             * Check the delta voltage over the last X minutes so we can do
             * our end-of-charge logic based on the battery level change.
             *(no longer use minimum time as logic for charge end has 50
             * minutes minimum charge built in)
             */
            if (powermgmt_last_cycle_startstop_min > CHARGE_END_SHORTD) {
                short_delta = power_history[0] -
                              power_history[CHARGE_END_SHORTD - 1];
            }

            if (powermgmt_last_cycle_startstop_min > CHARGE_END_LONGD) {
            /*
             * Scan the history: the points where measurement is taken need to
             * be fairly static. (check prior to short delta 'area')
             * (also only check first and last 10 cycles - delta in middle OK)
             */
                long_delta = power_history[0] -
                             power_history[CHARGE_END_LONGD - 1];

                for(i = CHARGE_END_SHORTD; i < CHARGE_END_SHORTD + 10; i++) {
                    if(((power_history[i] - power_history[i+1]) >  5) ||
                       ((power_history[i] - power_history[i+1]) < -5)) {
                        long_delta = 777777;
                        break;
                    }
                }
                 for(i = CHARGE_END_LONGD - 11; i < CHARGE_END_LONGD - 1 ; i++) {
                    if(((power_history[i] - power_history[i+1]) >  5) ||
                       ((power_history[i] - power_history[i+1]) < -5)) {
                        long_delta = 888888;
                        break;
                    }
                }
            }

            snprintf(power_message, POWER_MESSAGE_LEN,
                     "Chg %dm, max %dm", powermgmt_last_cycle_startstop_min,
                     charge_max_time_now);
            /*
             * End of charge criteria (any qualify):
             * 1) Charged a long time
             * 2) DeltaV went negative for a short time ( & long delta static)
             * 3) DeltaV was negative over a longer period (no disk use only)
             * Note: short_delta and long_delta are centivolts
             */
            if ((powermgmt_last_cycle_startstop_min >= charge_max_time_now) ||
                (short_delta <= -5 && long_delta < 5 ) || (long_delta  < -2 &&
                last_disk_activity > CHARGE_END_LONGD)) {
                if (powermgmt_last_cycle_startstop_min > charge_max_time_now) {
                    DEBUGF("power: powermgmt_last_cycle_startstop_min > charge_max_time_now, "
                           "enough!\n");
                    /*
                     *have charged too long and deltaV detection did not
                     *work!
                     */
                     snprintf(power_message, POWER_MESSAGE_LEN,
                             "Chg tmout %d min", charge_max_time_now);
                    /*
                     * Switch to trickle charging.  We skip the top-off
                     * since we've effectively done the top-off operation
                     * already since we charged for the maximum full
                     * charge time.
                     */
                    powermgmt_last_cycle_level = battery_percent;
                    powermgmt_last_cycle_startstop_min = 0;
                    charge_state = TRICKLE;

                    /*
                     * set trickle charge target to a relative voltage instead
                     * of an arbitrary value - the fully charged voltage may
                     * vary according to ambient temp, battery condition etc
                     * trickle target is -0.15v from full voltage acheived
                     * topup target is -0.05v from full voltage
                     */
                    target_voltage = power_history[0] - 15;

                } else {
                    if(short_delta <= -5) {
                        DEBUGF("power: short-term negative"
                               " delta, enough!\n");
                        snprintf(power_message, POWER_MESSAGE_LEN,
                                 "end negd %d %dmin", short_delta,
                                 powermgmt_last_cycle_startstop_min);
                        target_voltage = power_history[CHARGE_END_SHORTD - 1]
                                         - 5;
                    } else {
                        DEBUGF("power: long-term small "
                               "positive delta, enough!\n");
                        snprintf(power_message, POWER_MESSAGE_LEN,
                                 "end lowd %d %dmin", long_delta,
                                 powermgmt_last_cycle_startstop_min);
                        target_voltage = power_history[CHARGE_END_LONGD - 1]
                                         - 5;
                    }
                    /*
                     * Switch to top-off charging.
                     */
                    powermgmt_last_cycle_level = battery_percent;
                    powermgmt_last_cycle_startstop_min = 0;
                    charge_state = TOPOFF;
                }
            }
        }
        else if (charge_state != DISCHARGING)  /* top off or trickle */
        {
            /*
             *Time to switch from topoff to trickle?
             */
            if ((charge_state == TOPOFF) &&
                (powermgmt_last_cycle_startstop_min > TOPOFF_MAX_TIME))
            {
                powermgmt_last_cycle_level = battery_percent;
                powermgmt_last_cycle_startstop_min = 0;
                charge_state = TRICKLE;
                target_voltage = target_voltage - 10;
            }
            /*
             * Adjust trickle charge time (proportional and integral terms).
             * Note: I considered setting the level higher if the USB is
             * plugged in, but it doesn't appear to be necessary and will
             * generate more heat [gvb].
             */

            pid_p = target_voltage - battery_centivolts;
            if((pid_p > PID_DEADZONE) || (pid_p < -PID_DEADZONE))
                pid_p = pid_p * PID_PCONST;
            else
                pid_p = 0;
            if((unsigned) battery_centivolts < target_voltage) {
                if(pid_i < 60) {
                    pid_i++;        /* limit so it doesn't "wind up" */
                }
            } else {
                if(pid_i > 0) {
                    pid_i--;        /* limit so it doesn't "wind up" */
                }
            }

            trickle_sec = pid_p + pid_i;

            if(trickle_sec > 60) {
                trickle_sec = 60;
            }
            if(trickle_sec < 0) {
                trickle_sec = 0;
            }

        } else if (charge_state == DISCHARGING) {
            trickle_sec = 0;
            /*
             * The charger is enabled here only in one case: if it was
             * turned on at boot time (power_init).  Turn it off now.
             */
            if (charger_enabled)
                charger_enable(false);
        }

        if (charger_input_state == CHARGER_UNPLUGGED) {
            /*
             * The charger was just unplugged.
             */
            DEBUGF("power: charger disconnected, disabling\n");

            charger_enable(false);
            powermgmt_last_cycle_level = battery_percent;
            powermgmt_last_cycle_startstop_min = 0;
            trickle_sec  = 0;
            pid_p        = 0;
            pid_i        = 0;
            charge_state = DISCHARGING;
            snprintf(power_message, POWER_MESSAGE_LEN, "Charger: discharge");
        }

#endif /* CONFIG_CHARGING == CHARGING_CONTROL */

        /* sleep for a minute */

#if CONFIG_CHARGING == CHARGING_CONTROL
        if(trickle_sec > 0) {
            charger_enable(true);
            power_thread_sleep(HZ * trickle_sec);
        }
        if(trickle_sec < 60)
            charger_enable(false);
        power_thread_sleep(HZ * (60 - trickle_sec));
#else
        power_thread_sleep(HZ * 60);
#endif

#if defined(DEBUG_FILE) && (CONFIG_CHARGING == CHARGING_CONTROL)
        if(usb_inserted()) {
            if(fd >= 0) {
                /* It is probably too late to close the file but we can try...*/
                close(fd);
                fd = -1;
            }
        } else {
            if(fd < 0) {
                fd = open(DEBUG_FILE_NAME, O_WRONLY | O_APPEND | O_CREAT);
                if(fd >= 0) {
                    snprintf(debug_message, DEBUG_MESSAGE_LEN,
                    "cycle_min, bat_centivolts, bat_percent, chgr_state, charge_state, pid_p, pid_i, trickle_sec\n");
                    write(fd, debug_message, strlen(debug_message));
                    wrcount = 99;   /* force a flush */
                }
            }
            if(fd >= 0) {
                snprintf(debug_message, DEBUG_MESSAGE_LEN,
                        "%d, %d, %d, %d, %d, %d, %d, %d\n",
                    powermgmt_last_cycle_startstop_min, battery_centivolts,
                    battery_percent, charger_input_state, charge_state,
                    pid_p, pid_i, trickle_sec);
                write(fd, debug_message, strlen(debug_message));
                wrcount++;
            }
        }
#endif
        handle_auto_poweroff();

#if CONFIG_CHARGING == CHARGING_CONTROL
        powermgmt_last_cycle_startstop_min++;
#endif
    }
}

void powermgmt_init(void)
{
    /* init history to 0 */
    memset(power_history, 0x00, sizeof(power_history));
    create_thread(power_thread, power_stack, sizeof(power_stack),
                  power_thread_name IF_PRIO(, PRIORITY_SYSTEM)
		  IF_COP(, CPU, false));
}

#endif /* SIMULATOR */

void sys_poweroff(void)
{
    logf("sys_poweroff()");
    /* If the main thread fails to shut down the system, we will force a
       power off after an 20 second timeout - 28 seconds if recording */
    if (shutdown_timeout == 0)
    {
#if (defined(IAUDIO_X5) || defined(IAUDIO_M5)) && !defined (SIMULATOR)
        pcf50606_reset_timeout(); /* Reset timer on first attempt only */
#endif
#ifdef HAVE_RECORDING
        if (audio_status() & AUDIO_STATUS_RECORD)
            shutdown_timeout += HZ*8;
#endif
        shutdown_timeout += HZ*20;
    }

    queue_broadcast(SYS_POWEROFF, 0);
}

void cancel_shutdown(void)
{
    logf("sys_cancel_shutdown()");

#if (defined(IAUDIO_X5) || defined(IAUDIO_M5)) && !defined (SIMULATOR)
    /* TODO: Move some things to target/ tree */
    if (shutdown_timeout)
        pcf50606_reset_timeout();
#endif

    shutdown_timeout = 0;
}

/* Various hardware housekeeping tasks relating to shutting down the jukebox */
void shutdown_hw(void)
{
#ifndef SIMULATOR
#if defined(DEBUG_FILE) && (CONFIG_CHARGING == CHARGING_CONTROL)
    if(fd >= 0) {
        close(fd);
        fd = -1;
    }
#endif
    audio_stop();
    if (battery_level_safe()) { /* do not save on critical battery */
#ifdef HAVE_LCD_BITMAP
        glyph_cache_save();
#endif
        if(ata_disk_is_active())
            ata_spindown(1);
    }
    while(ata_disk_is_active())
        sleep(HZ/10);

#if !defined (IAUDIO_X5) && !defined (SANSA_E200)
#if defined(HAVE_BACKLIGHT_PWM_FADING) && !defined(SIMULATOR)
    backlight_set_fade_out(0);
#endif
    backlight_off();
#endif /* IAUDIO_X5, SANSA_E200 */
#ifdef HAVE_REMOTE_LCD
    remote_backlight_off();
#endif

#if CONFIG_CODEC != SWCODEC
    mp3_shutdown();
#else
    audiohw_close();
#endif

    /* If HD is still active we try to wait for spindown, otherwise the
       shutdown_timeout in power_thread_sleep will force a power off */
    while(ata_disk_is_active())
        sleep(HZ/10);
#ifndef IAUDIO_X5
    lcd_set_contrast(0);
#endif /* IAUDIO_X5 */
#ifdef HAVE_REMOTE_LCD
    lcd_remote_set_contrast(0);
#endif

    /* Small delay to make sure all HW gets time to flush. Especially
       eeprom chips are quite slow and might be still writing the last
       byte. */
    sleep(HZ/4);
    power_off();
#endif /* #ifndef SIMULATOR */
}