/*************************************************************************** * __________ __ ___. * 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 #ifdef HAVE_UDA1380 #include "uda1380.h" #elif defined(HAVE_TLV320) #include "tlv320.h" #elif defined(HAVE_WM8758) #include "wm8758.h" #elif defined(HAVE_WM8975) #include "wm8975.h" #elif defined(HAVE_WM8731) #include "wm8731l.h" #endif #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 #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; } bool battery_level_critical(void) { return false; } 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_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_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 /* iAudio x5 series - still experimenting with best curve */ // Lithium ion discharge curve { 355, 356, 357, 359, 362, 365, 369, 374, 380, 387, 395 } // Linear // { 355, 360, 364, 369, 373, 378, 382, 387, 391, 390, 400 } // { 355, 359, 363, 367, 371, 375, 379, 383, 387, 391, 395 } #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 */ { 354, 357, 359, 361, 364, 366, 372, 381, 377, 381, 394 }, #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 }, #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_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 */ 354, 357, 359, 361, 364, 366, 372, 381, 377, 381, 394 #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]; } /* Tells if the battery is in critical powersaving state */ bool battery_level_critical(void) { return ((battery_capacity * battery_percent / BATTERY_CAPACITY_MIN) < 10); } 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 CONFIG_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_post(&button_queue, 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_critical()) { /* 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); #ifndef IAUDIO_X5 #if defined(HAVE_BACKLIGHT_PWM_FADING) && !defined(SIMULATOR) backlight_set_fade_out(0); #endif backlight_off(); #endif /* IAUDIO_X5 */ #ifdef HAVE_REMOTE_LCD remote_backlight_off(); #endif #if CONFIG_CODEC != SWCODEC mp3_shutdown(); #endif #ifdef HAVE_UDA1380 audiohw_close(); #elif defined(HAVE_TLV320) audiohw_close(); #elif defined(HAVE_WM8758) || defined(HAVE_WM8975) | defined(HAVE_WM8731) 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 */ }