firmware/powermgmt.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2002 by Heikki Hannikainen, Uwe Freese
  11  * Revisions copyright (C) 2005 by Gerald Van Baren
  12  *
  13  * This program is free software; you can redistribute it and/or
  14  * modify it under the terms of the GNU General Public License
  15  * as published by the Free Software Foundation; either version 2
  16  * of the License, or (at your option) any later version.
  17  *
  18  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  19  * KIND, either express or implied.
  20  *
  21  ****************************************************************************/
  22 #include "config.h"
  23 #include "system.h"
  24 #include "kernel.h"
  25 #include "thread.h"
  26 #include "debug.h"
  27 #include "adc.h"
  28 #include "string.h"
  29 #include "storage.h"
  30 #include "power.h"
  31 #include "audio.h"
  32 #include "mp3_playback.h"
  33 #include "usb.h"
  34 #include "powermgmt.h"
  35 #include "backlight.h"
  36 #include "lcd.h"
  37 #include "rtc.h"
  38 #if CONFIG_TUNER
  39 #include "fmradio.h"
  40 #endif
  41 #include "sound.h"
  42 #ifdef HAVE_LCD_BITMAP
  43 #include "font.h"
  44 #endif
  45 #include "logf.h"
  46 #include "lcd-remote.h"
  47 #ifdef SIMULATOR
  48 #include <time.h>
  49 #endif
  50
  51 #if (defined(IAUDIO_X5) || defined(IAUDIO_M5)) && !defined (SIMULATOR)
  52 #include "lcd-remote-target.h"
  53 #endif
  54 #if (defined(IAUDIO_X5) || defined(IAUDIO_M5) || defined(COWON_D2)) \
  55     && !defined (SIMULATOR)
  56 #include "pcf50606.h"
  57 #endif
  58
  59 /** Shared by sim **/
  60 int last_sent_battery_level = 100;
  61 /* battery level (0-100%) */
  62 int battery_percent = -1;
  63 void send_battery_level_event(void);
  64
  65 #if CONFIG_CHARGING
  66 /* State of the charger input as seen by the power thread */
  67 enum charger_input_state_type charger_input_state;
  68 /* Power inputs as seen by the power thread */
  69 unsigned int power_thread_inputs;
  70 #if CONFIG_CHARGING >= CHARGING_MONITOR
  71 /* Charging state (mode) as seen by the power thread */
  72 enum charge_state_type charge_state = DISCHARGING;
  73 #endif
  74 #endif /* CONFIG_CHARGING */
  75
  76 #ifndef SIMULATOR
  77 static int shutdown_timeout = 0;
  78 /*
  79  * Average battery voltage and charger voltage, filtered via a digital
  80  * exponential filter (aka. exponential moving average, scaled):
  81  * avgbat = y[n] = (N-1)/N*y[n-1] + x[n]. battery_millivolts = y[n] / N.
  82  */
  83 static unsigned int avgbat;
  84 /* filtered battery voltage, millivolts */
  85 static unsigned int battery_millivolts;
  86 /* default value, mAh */
  87 static int battery_capacity = BATTERY_CAPACITY_DEFAULT;
  88
  89
  90 #if BATTERY_TYPES_COUNT > 1
  91 static int battery_type = 0;
  92 #else
  93 #define battery_type 0
  94 #endif
  95
  96 /* Power history: power_history[0] is the newest sample */
  97 unsigned short power_history[POWER_HISTORY_LEN];
  98
  99 #if CONFIG_CPU == JZ4732 /* FIXME! */
 100 static char power_stack[DEFAULT_STACK_SIZE + POWERMGMT_DEBUG_STACK];
 101 #else
 102 static char power_stack[DEFAULT_STACK_SIZE/2 + POWERMGMT_DEBUG_STACK];
 103 #endif
 104 static const char power_thread_name[] = "power";
 105
 106 static int poweroff_timeout = 0;
 107 static int powermgmt_est_runningtime_min = -1;
 108
 109 static bool sleeptimer_active = false;
 110 static long sleeptimer_endtick;
 111
 112 static long last_event_tick;
 113
 114 static int voltage_to_battery_level(int battery_millivolts);
 115 static void battery_status_update(void);
 116 static int runcurrent(void);
 117
 118 void battery_read_info(int *voltage, int *level)
 119 {
 120     int millivolts = battery_adc_voltage();
 121
 122     if (voltage)
 123         *voltage = millivolts;
 124
 125     if (level)
 126         *level = voltage_to_battery_level(millivolts);
 127 }
 128
 129 void reset_poweroff_timer(void)
 130 {
 131     last_event_tick = current_tick;
 132 }
 133
 134 #if BATTERY_TYPES_COUNT > 1
 135 void set_battery_type(int type)
 136 {
 137     if (type != battery_type) {
 138         if ((unsigned)type >= BATTERY_TYPES_COUNT)
 139             type = 0;
 140
 141         battery_type = type;
 142         battery_status_update(); /* recalculate the battery status */
 143     }
 144 }
 145 #endif
 146
 147 void set_battery_capacity(int capacity)
 148 {
 149     if (capacity > BATTERY_CAPACITY_MAX)
 150         capacity = BATTERY_CAPACITY_MAX;
 151     if (capacity < BATTERY_CAPACITY_MIN)
 152         capacity = BATTERY_CAPACITY_MIN;
 153
 154     battery_capacity = capacity;
 155
 156     battery_status_update(); /* recalculate the battery status */
 157 }
 158
 159 int get_battery_capacity(void)
 160 {
 161     return battery_capacity;
 162 }
 163
 164 int battery_time(void)
 165 {
 166     return powermgmt_est_runningtime_min;
 167 }
 168
 169 /* Returns battery level in percent */
 170 int battery_level(void)
 171 {
 172 #ifdef HAVE_BATTERY_SWITCH
 173     if ((power_input_status() & POWER_INPUT_BATTERY) == 0)
 174         return -1;
 175 #endif
 176     return battery_percent;
 177 }
 178
 179 /* Returns filtered battery voltage [millivolts] */
 180 unsigned int battery_voltage(void)
 181 {
 182     return battery_millivolts;
 183 }
 184
 185 /* Tells if the battery level is safe for disk writes */
 186 bool battery_level_safe(void)
 187 {
 188 #if defined(NO_LOW_BATTERY_SHUTDOWN)
 189     return true;
 190 #elif defined(HAVE_BATTERY_SWITCH)
 191     /* Cannot rely upon the battery reading to be valid and the
 192      * device could be powered externally. */
 193     return input_millivolts() > battery_level_dangerous[battery_type];
 194 #else
 195     return battery_millivolts > battery_level_dangerous[battery_type];
 196 #endif
 197 }
 198
 199 void set_poweroff_timeout(int timeout)
 200 {
 201     poweroff_timeout = timeout;
 202 }
 203
 204 void set_sleep_timer(int seconds)
 205 {
 206     if (seconds) {
 207         sleeptimer_active  = true;
 208         sleeptimer_endtick = current_tick + seconds * HZ;
 209     }
 210     else {
 211         sleeptimer_active  = false;
 212         sleeptimer_endtick = 0;
 213     }
 214 }
 215
 216 int get_sleep_timer(void)
 217 {
 218     if (sleeptimer_active)
 219         return (sleeptimer_endtick - current_tick) / HZ;
 220     else
 221         return 0;
 222 }
 223
 224 /* look into the percent_to_volt_* table and get a realistic battery level */
 225 static int voltage_to_percent(int voltage, const short* table)
 226 {
 227     if (voltage <= table[0]) {
 228         return 0;
 229     }
 230     else if (voltage >= table[10]) {
 231         return 100;
 232     }
 233     else {
 234         /* search nearest value */
 235         int i = 0;
 236
 237         while (i < 10 && table[i+1] < voltage)
 238             i++;
 239
 240         /* interpolate linear between the smaller and greater value */
 241         /* Tens digit, 10% per entry,  ones digit: interpolated */
 242         return i*10 + (voltage - table[i])*10 / (table[i+1] - table[i]);
 243     }
 244 }
 245
 246 /* update battery level and estimated runtime, called once per minute or
 247  * when battery capacity / type settings are changed */
 248 static int voltage_to_battery_level(int battery_millivolts)
 249 {
 250     int level;
 251
 252 #if CONFIG_CHARGING >= CHARGING_MONITOR
 253     if (charging_state()) {
 254         /* battery level is defined to be < 100% until charging is finished */
 255         level = voltage_to_percent(battery_millivolts,
 256                                    percent_to_volt_charge);
 257         if (level > 99)
 258             level = 99;
 259     }
 260     else
 261 #endif /* CONFIG_CHARGING >= CHARGING_MONITOR */
 262     {
 263         /* DISCHARGING or error state */
 264         level = voltage_to_percent(battery_millivolts,
 265                                    percent_to_volt_discharge[battery_type]);
 266     }
 267
 268     return level;
 269 }
 270
 271 static void battery_status_update(void)
 272 {
 273     int level = voltage_to_battery_level(battery_millivolts);
 274
 275     /* calculate estimated remaining running time */
 276 #if CONFIG_CHARGING >= CHARGING_MONITOR
 277     if (charging_state()) {
 278         /* charging: remaining charging time */
 279         powermgmt_est_runningtime_min = (100 - level)*battery_capacity*60
 280                 / 100 / (CURRENT_MAX_CHG - runcurrent());
 281     }
 282     else
 283 #endif
 284     /* discharging: remaining running time */
 285     if ((battery_millivolts + 20) > percent_to_volt_discharge[0][0]) {
 286         powermgmt_est_runningtime_min = (level + battery_percent)*60
 287                 * battery_capacity / 200 / runcurrent();
 288     }
 289     else if (battery_millivolts <= battery_level_shutoff[0]) {
 290         powermgmt_est_runningtime_min = 0;
 291     }
 292     else {
 293         powermgmt_est_runningtime_min =
 294             (battery_millivolts - battery_level_shutoff[0]) / 2;
 295     }
 296
 297     battery_percent = level;
 298     send_battery_level_event();
 299 }
 300
 301 /*
 302  * We shut off in the following cases:
 303  * 1) The unit is idle, not playing music
 304  * 2) The unit is playing music, but is paused
 305  * 3) The battery level has reached shutdown limit
 306  *
 307  * We do not shut off in the following cases:
 308  * 1) The USB is connected
 309  * 2) The charger is connected
 310  * 3) We are recording, or recording with pause
 311  * 4) The radio is playing
 312  */
 313 static void handle_auto_poweroff(void)
 314 {
 315     long timeout = poweroff_timeout*60*HZ;
 316     int audio_stat = audio_status();
 317     long tick = current_tick;
 318
 319 #if CONFIG_CHARGING
 320     /*
 321      * Inhibit shutdown as long as the charger is plugged in.  If it is
 322      * unplugged, wait for a timeout period and then shut down.
 323      */
 324     if (charger_input_state == CHARGER || audio_stat == AUDIO_STATUS_PLAY) {
 325         last_event_tick = current_tick;
 326     }
 327 #endif
 328
 329     if (!shutdown_timeout && query_force_shutdown()) {
 330         backlight_on();
 331         sys_poweroff();
 332     }
 333
 334     if (timeout &&
 335 #if CONFIG_TUNER
 336         !(get_radio_status() & FMRADIO_PLAYING) &&
 337 #endif
 338         !usb_inserted() &&
 339         (audio_stat == 0 ||
 340          (audio_stat == (AUDIO_STATUS_PLAY | AUDIO_STATUS_PAUSE) &&
 341           !sleeptimer_active))) {
 342
 343         if (TIME_AFTER(tick, last_event_tick + timeout) &&
 344             TIME_AFTER(tick, storage_last_disk_activity() + timeout)) {
 345             sys_poweroff();
 346         }
 347     }
 348     else if (sleeptimer_active) {
 349         /* Handle sleeptimer */
 350         if (TIME_AFTER(tick, sleeptimer_endtick)) {
 351             audio_stop();
 352
 353             if (usb_inserted()
 354 #if CONFIG_CHARGING && !defined(HAVE_POWEROFF_WHILE_CHARGING)
 355                 || charger_input_state != NO_CHARGER
 356 #endif
 357             ) {
 358                 DEBUGF("Sleep timer timeout. Stopping...\n");
 359                 set_sleep_timer(0);
 360                 backlight_off(); /* Nighty, nighty... */
 361             }
 362             else {
 363                 DEBUGF("Sleep timer timeout. Shutting off...\n");
 364                 sys_poweroff();
 365             }
 366         }
 367     }
 368 }
 369
 370 /*
 371  * Estimate how much current we are drawing just to run.
 372  */
 373 static int runcurrent(void)
 374 {
 375     int current;
 376
 377 #if MEM == 8 && !(defined(ARCHOS_ONDIOSP) || defined(ARCHOS_ONDIOFM))
 378     /* assuming 192 kbps, the running time is 22% longer with 8MB */
 379     current = CURRENT_NORMAL*100 / 122;
 380 #else
 381     current = CURRENT_NORMAL;
 382 #endif /* MEM == 8 */
 383
 384 #ifndef BOOTLOADER
 385     if (usb_inserted()
 386 #ifdef HAVE_USB_POWER
 387     #if (CURRENT_USB < CURRENT_NORMAL)
 388        || usb_powered()
 389     #else
 390        && !usb_powered()
 391     #endif
 392 #endif
 393     ) {
 394         current = CURRENT_USB;
 395     }
 396
 397 #if defined(HAVE_BACKLIGHT)
 398     if (backlight_get_current_timeout() == 0) /* LED always on */
 399         current += CURRENT_BACKLIGHT;
 400 #endif
 401
 402 #if defined(HAVE_RECORDING) && defined(CURRENT_RECORD)
 403     if (audio_status() & AUDIO_STATUS_RECORD)
 404         current += CURRENT_RECORD;
 405 #endif
 406
 407 #ifdef HAVE_SPDIF_POWER
 408     if (spdif_powered())
 409         current += CURRENT_SPDIF_OUT;
 410 #endif
 411
 412 #ifdef HAVE_REMOTE_LCD
 413     if (remote_detect())
 414         current += CURRENT_REMOTE;
 415 #endif
 416 #endif /* BOOTLOADER */
 417
 418     return current;
 419 }
 420
 421
 422 /* Check to see whether or not we've received an alarm in the last second */
 423 #ifdef HAVE_RTC_ALARM
 424 static void power_thread_rtc_process(void)
 425 {
 426     if (rtc_check_alarm_flag())
 427         rtc_enable_alarm(false);
 428 }
 429 #endif
 430
 431 /* switch off unit if battery level is too low for reliable operation */
 432 bool query_force_shutdown(void)
 433 {
 434 #if defined(NO_LOW_BATTERY_SHUTDOWN)
 435     return false;
 436 #elif defined(HAVE_BATTERY_SWITCH)
 437     /* Cannot rely upon the battery reading to be valid and the
 438      * device could be powered externally. */
 439     return input_millivolts() < battery_level_shutoff[battery_type];
 440 #else
 441     return battery_millivolts < battery_level_shutoff[battery_type];
 442 #endif
 443 }
 444
 445 #if defined(HAVE_BATTERY_SWITCH) || defined(HAVE_RESET_BATTERY_FILTER)
 446 /*
 447  * Reset the battery voltage filter to a new value and update the
 448  * status.
 449  */
 450 void reset_battery_filter(int millivolts)
 451 {
 452     avgbat = millivolts * BATT_AVE_SAMPLES;
 453     battery_millivolts = millivolts;
 454     battery_status_update();
 455 }
 456 #endif /* HAVE_BATTERY_SWITCH */
 457
 458 /** Generic charging algorithms for common charging types **/
 459 #if CONFIG_CHARGING == 0 || CONFIG_CHARGING == CHARGING_SIMPLE
 460 static inline void powermgmt_init_target(void)
 461 {
 462     /* Nothing to do */
 463 }
 464
 465 static inline void charging_algorithm_step(void)
 466 {
 467     /* Nothing to do */
 468 }
 469
 470 static inline void charging_algorithm_close(void)
 471 {
 472     /* Nothing to do */
 473 }
 474 #elif CONFIG_CHARGING == CHARGING_MONITOR
 475 /*
 476  * Monitor CHARGING/DISCHARGING state.
 477  */
 478 static inline void powermgmt_init_target(void)
 479 {
 480     /* Nothing to do */
 481 }
 482
 483 static inline void charging_algorithm_step(void)
 484 {
 485     switch (charger_input_state)
 486     {
 487     case CHARGER_PLUGGED:
 488     case CHARGER:
 489         if (charging_state()) {
 490             charge_state = CHARGING;
 491             break;
 492         }
 493     /* Fallthrough */
 494     case CHARGER_UNPLUGGED:
 495     case NO_CHARGER:
 496         charge_state = DISCHARGING;
 497         break;
 498     }
 499 }
 500
 501 static inline void charging_algorithm_close(void)
 502 {
 503     /* Nothing to do */
 504 }
 505 #endif /* CONFIG_CHARGING == * */
 506
 507 #if CONFIG_CHARGING
 508 /* Shortcut function calls - compatibility, simplicity. */
 509
 510 /* Returns true if any power input is capable of charging. */
 511 bool charger_inserted(void)
 512 {
 513     return power_thread_inputs & POWER_INPUT_CHARGER;
 514 }
 515
 516 /* Returns true if any power input is connected - charging-capable
 517  * or not. */
 518 bool power_input_present(void)
 519 {
 520     return power_thread_inputs & POWER_INPUT;
 521 }
 522
 523 /*
 524  * Detect charger inserted. Return true if the state is transistional.
 525  */
 526 static inline bool detect_charger(unsigned int pwr)
 527 {
 528     /*
 529      * Detect charger plugged/unplugged transitions.  On a plugged or
 530      * unplugged event, we return immediately, run once through the main
 531      * loop (including the subroutines), and end up back here where we
 532      * transition to the appropriate steady state charger on/off state.
 533      */
 534     if (pwr & POWER_INPUT_CHARGER) {
 535         switch (charger_input_state)
 536         {
 537         case NO_CHARGER:
 538         case CHARGER_UNPLUGGED:
 539             charger_input_state = CHARGER_PLUGGED;
 540             break;
 541
 542         case CHARGER_PLUGGED:
 543             queue_broadcast(SYS_CHARGER_CONNECTED, 0);
 544             last_sent_battery_level = 0;
 545             charger_input_state = CHARGER;
 546             break;
 547
 548         case CHARGER:
 549             /* Steady state */
 550             return false;
 551         }
 552     }
 553     else {    /* charger not inserted */
 554         switch (charger_input_state)
 555         {
 556         case NO_CHARGER:
 557             /* Steady state */
 558             return false;
 559
 560         case CHARGER_UNPLUGGED:
 561             queue_broadcast(SYS_CHARGER_DISCONNECTED, 0);
 562             last_sent_battery_level = 100;
 563             charger_input_state = NO_CHARGER;
 564             break;
 565
 566         case CHARGER_PLUGGED:
 567         case CHARGER:
 568             charger_input_state = CHARGER_UNPLUGGED;
 569             break;
 570         }
 571     }
 572
 573     /* Transitional state */
 574     return true;
 575 }
 576 #endif /* CONFIG_CHARGING */
 577
 578 /*
 579  * Monitor the presence of a charger and perform critical frequent steps
 580  * such as running the battery voltage filter.
 581  */
 582 static inline void power_thread_step(void)
 583 {
 584     /* If the power off timeout expires, the main thread has failed
 585        to shut down the system, and we need to force a power off */
 586     if (shutdown_timeout) {
 587         shutdown_timeout -= POWER_THREAD_STEP_TICKS;
 588
 589         if (shutdown_timeout <= 0)
 590             power_off();
 591     }
 592
 593 #ifdef HAVE_RTC_ALARM
 594     power_thread_rtc_process();
 595 #endif
 596
 597     /*
 598      * Do a digital exponential filter.  We don't sample the battery if
 599      * the disk is spinning unless we are in USB mode (the disk will most
 600      * likely always be spinning in USB mode) or charging.
 601      */
 602     if (!storage_disk_is_active() || usb_inserted()
 603 #if CONFIG_CHARGING >= CHARGING_MONITOR
 604             || charger_input_state == CHARGER
 605 #endif
 606     ) {
 607         avgbat += battery_adc_voltage() - avgbat / BATT_AVE_SAMPLES;
 608         /*
 609          * battery_millivolts is the millivolt-scaled filtered battery value.
 610          */
 611         battery_millivolts = avgbat / BATT_AVE_SAMPLES;
 612
 613         /* update battery status every time an update is available */
 614         battery_status_update();
 615     }
 616     else if (battery_percent < 8) {
 617         /*
 618          * If battery is low, observe voltage during disk activity.
 619          * Shut down if voltage drops below shutoff level and we are not
 620          * using NiMH or Alkaline batteries.
 621          */
 622         battery_millivolts = (battery_adc_voltage() +
 623                               battery_millivolts + 1) / 2;
 624
 625         /* update battery status every time an update is available */
 626         battery_status_update();
 627
 628         if (!shutdown_timeout && query_force_shutdown()) {
 629             sys_poweroff();
 630         }
 631         else {
 632             avgbat += battery_millivolts - avgbat / BATT_AVE_SAMPLES;
 633         }
 634     }
 635 } /* power_thread_step */
 636
 637 static void power_thread(void)
 638 {
 639     long next_power_hist;
 640
 641     /* Delay reading the first battery level */
 642 #ifdef MROBE_100
 643     while (battery_adc_voltage() > 4200) /* gives false readings initially */
 644 #endif
 645     {
 646         sleep(HZ/100);
 647     }
 648
 649 #if CONFIG_CHARGING
 650     /* Initialize power input status before calling other routines. */
 651     power_thread_inputs = power_input_status();
 652 #endif
 653
 654     /* initialize the voltages for the exponential filter */
 655     avgbat = battery_adc_voltage() + 15;
 656
 657 #ifdef HAVE_DISK_STORAGE /* this adjustment is only needed for HD based */
 658     /* The battery voltage is usually a little lower directly after
 659        turning on, because the disk was used heavily. Raise it by 5% */
 660 #if CONFIG_CHARGING
 661     if (!charger_inserted()) /* only if charger not connected */
 662 #endif
 663     {
 664         avgbat += (percent_to_volt_discharge[battery_type][6] -
 665                    percent_to_volt_discharge[battery_type][5]) / 2;
 666     }
 667 #endif /* HAVE_DISK_STORAGE */
 668
 669     avgbat = avgbat * BATT_AVE_SAMPLES;
 670     battery_millivolts = avgbat / BATT_AVE_SAMPLES;
 671     power_history[0] = battery_millivolts;
 672
 673 #if CONFIG_CHARGING
 674     if (charger_inserted()) {
 675         battery_percent = voltage_to_percent(battery_millivolts,
 676                             percent_to_volt_charge);
 677     }
 678     else
 679 #endif
 680     {
 681         battery_percent = voltage_to_percent(battery_millivolts,
 682                             percent_to_volt_discharge[battery_type]);
 683         battery_percent += battery_percent < 100;
 684     }
 685
 686     powermgmt_init_target();
 687
 688     next_power_hist = current_tick + HZ*60;
 689
 690     while (1)
 691     {
 692 #if CONFIG_CHARGING
 693         unsigned int pwr = power_input_status();
 694 #ifdef HAVE_BATTERY_SWITCH
 695         if ((pwr ^ power_thread_inputs) & POWER_INPUT_BATTERY) {
 696             sleep(HZ/10);
 697             reset_battery_filter(battery_adc_voltage());
 698         }
 699 #endif
 700         power_thread_inputs = pwr;
 701
 702         if (!detect_charger(pwr))
 703 #endif /* CONFIG_CHARGING */
 704         {
 705             /* Steady state */
 706             sleep(POWER_THREAD_STEP_TICKS);
 707
 708             /* Do common power tasks */
 709             power_thread_step();
 710         }
 711
 712         /* Perform target tasks */
 713         charging_algorithm_step();
 714
 715         if (TIME_BEFORE(current_tick, next_power_hist))
 716             continue;
 717
 718         /* increment to ensure there is a record for every minute
 719          * rather than go forward from the current tick */
 720         next_power_hist += HZ*60;
 721
 722         /* rotate the power history */
 723         memmove(&power_history[1], &power_history[0],
 724                 sizeof(power_history) - sizeof(power_history[0]));
 725
 726         /* insert new value at the start, in millivolts 8-) */
 727         power_history[0] = battery_millivolts;
 728
 729         handle_auto_poweroff();
 730     }
 731 } /* power_thread */
 732
 733 void powermgmt_init(void)
 734 {
 735     /* init history to 0 */
 736     memset(power_history, 0, sizeof(power_history));
 737     create_thread(power_thread, power_stack, sizeof(power_stack), 0,
 738                   power_thread_name IF_PRIO(, PRIORITY_SYSTEM)
 739                   IF_COP(, CPU));
 740 }
 741
 742 /* Various hardware housekeeping tasks relating to shutting down the player */
 743 void shutdown_hw(void)
 744 {
 745     charging_algorithm_close();
 746     audio_stop();
 747
 748     if (battery_level_safe()) { /* do not save on critical battery */
 749 #ifdef HAVE_LCD_BITMAP
 750         glyph_cache_save();
 751 #endif
 752         if (storage_disk_is_active())
 753             storage_spindown(1);
 754     }
 755
 756     while (storage_disk_is_active())
 757         sleep(HZ/10);
 758
 759 #if CONFIG_CODEC == SWCODEC
 760     audiohw_close();
 761 #else
 762     mp3_shutdown();
 763 #endif
 764
 765     /* If HD is still active we try to wait for spindown, otherwise the
 766        shutdown_timeout in power_thread_step will force a power off */
 767     while (storage_disk_is_active())
 768         sleep(HZ/10);
 769
 770 #ifndef HAVE_LCD_COLOR
 771     lcd_set_contrast(0);
 772 #endif
 773 #ifdef HAVE_REMOTE_LCD
 774     lcd_remote_set_contrast(0);
 775 #endif
 776 #ifdef HAVE_LCD_SHUTDOWN
 777     lcd_shutdown();
 778 #endif
 779
 780     /* Small delay to make sure all HW gets time to flush. Especially
 781        eeprom chips are quite slow and might be still writing the last
 782        byte. */
 783     sleep(HZ/4);
 784     power_off();
 785 }
 786
 787 void sys_poweroff(void)
 788 {
 789 #ifndef BOOTLOADER
 790     logf("sys_poweroff()");
 791     /* If the main thread fails to shut down the system, we will force a
 792        power off after an 20 second timeout - 28 seconds if recording */
 793     if (shutdown_timeout == 0) {
 794 #if defined(IAUDIO_X5) || defined(IAUDIO_M5) || defined(COWON_D2)
 795         pcf50606_reset_timeout(); /* Reset timer on first attempt only */
 796 #endif
 797 #ifdef HAVE_RECORDING
 798         if (audio_status() & AUDIO_STATUS_RECORD)
 799             shutdown_timeout += HZ*8;
 800 #endif
 801         shutdown_timeout += HZ*20;
 802     }
 803
 804     queue_broadcast(SYS_POWEROFF, 0);
 805 #endif /* BOOTLOADER */
 806 }
 807
 808 void cancel_shutdown(void)
 809 {
 810     logf("cancel_shutdown()");
 811
 812 #if defined(IAUDIO_X5) || defined(IAUDIO_M5) || defined(COWON_D2)
 813     /* TODO: Move some things to target/ tree */
 814     if (shutdown_timeout)
 815         pcf50606_reset_timeout();
 816 #endif
 817
 818     shutdown_timeout = 0;
 819 }
 820 #endif /* SIMULATOR */
 821
 822 /* Send system battery level update events on reaching certain significant
 823    levels. This must be called after battery_percent has been updated. */
 824 void send_battery_level_event(void)
 825 {
 826     static const int levels[] = { 5, 15, 30, 50, 0 };
 827     const int *level = levels;
 828
 829     while (*level)
 830     {
 831         if (battery_percent <= *level && last_sent_battery_level > *level) {
 832             last_sent_battery_level = *level;
 833             queue_broadcast(SYS_BATTERY_UPDATE, last_sent_battery_level);
 834             break;
 835         }
 836
 837         level++;
 838     }
 839 }