| /*************************************************************************** |
| * __________ __ ___. |
| * 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" |
| #ifdef 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 <time.h> |
| #endif |
| |
| #if defined(IAUDIO_X5) && !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_LIION830 /* Gigabeat F */ |
| 345 |
| #elif CONFIG_BATTERY == BATT_IAUDIO_X5 /* 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_LIION830 /* Gigabeat F */ |
| 340 |
| #elif CONFIG_BATTERY == BATT_IAUDIO_X5 /* 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_X5 |
| /* 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 }, |
| #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 |
| }; |
| |
| #ifdef 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_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 defined(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(); |
| |
| #ifdef 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 defined(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 defined(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(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_ALARM_MOD |
| 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) { |
| |
| #ifdef 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() |
| #ifdef 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_ALARM_MOD |
| 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; |
| |
| #ifdef 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)); |
| } |
| |
| #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 (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 (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 |
| |
| mp3_shutdown(); |
| #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 */ |
| } |