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