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  * All files in this archive are subject to the GNU General Public License.
  14  * See the file COPYING in the source tree root for full license agreement.
  15  *
  16  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  17  * KIND, either express or implied.
  18  *
  19  ****************************************************************************/
  20 #include "config.h"
  21 #include "cpu.h"
  22 #include "kernel.h"
  23 #include "thread.h"
  24 #include "system.h"
  25 #include "debug.h"
  26 #include "panic.h"
  27 #include "adc.h"
  28 #include "string.h"
  29 #include "sprintf.h"
  30 #include "ata.h"
  31 #include "power.h"
  32 #include "button.h"
  33 #include "audio.h"
  34 #include "mp3_playback.h"
  35 #include "usb.h"
  36 #include "powermgmt.h"
  37 #include "backlight.h"
  38 #include "lcd.h"
  39 #include "rtc.h"
  40 #if CONFIG_TUNER
  41 #include "fmradio.h"
  42 #endif
  43 #include "sound.h"
  44 #ifdef HAVE_LCD_BITMAP
  45 #include "font.h"
  46 #endif
  47 #if defined(HAVE_RECORDING) && (CONFIG_CODEC == SWCODEC)
  48 #include "pcm_record.h"
  49 #endif
  50 #include "logf.h"
  51 #include "lcd-remote.h"
  52 #ifdef SIMULATOR
  53 #include <time.h>
  54 #endif
  55
  56 #if (defined(IAUDIO_X5) || defined(IAUDIO_M5)) && !defined (SIMULATOR)
  57 #include "pcf50606.h"
  58 #include "lcd-remote-target.h"
  59 #endif
  60
  61 /*
  62  * Define DEBUG_FILE to create a csv (spreadsheet) with battery information
  63  * in it (one sample per minute).  This is only for very low level debug.
  64  */
  65 #undef  DEBUG_FILE
  66 #if defined(DEBUG_FILE) && (CONFIG_CHARGING == CHARGING_CONTROL)
  67 #include "file.h"
  68 #define DEBUG_FILE_NAME   "/powermgmt.csv"
  69 #define DEBUG_MESSAGE_LEN 133
  70 static char debug_message[DEBUG_MESSAGE_LEN];
  71 #define DEBUG_STACK ((0x1000)/sizeof(long))
  72 static int fd = -1;          /* write debug information to this file */
  73 static int wrcount = 0;
  74 #else
  75 #define DEBUG_STACK 0
  76 #endif
  77
  78 static int shutdown_timeout = 0;
  79 #if CONFIG_CHARGING >= CHARGING_MONITOR
  80 charge_state_type charge_state;     /* charging mode */
  81 #endif
  82
  83 static void send_battery_level_event(void);
  84 static int last_sent_battery_level = 100;
  85
  86 #if CONFIG_CHARGING
  87 charger_input_state_type charger_input_state IDATA_ATTR;
  88 #endif
  89
  90 #ifdef SIMULATOR /***********************************************************/
  91
  92 #define BATT_MINMVOLT   2500            /* minimum millivolts of battery */
  93 #define BATT_MAXMVOLT   4500            /* maximum millivolts of battery */
  94 #define BATT_MAXRUNTIME (10 * 60)       /* maximum runtime with full battery in minutes */
  95
  96 static unsigned int battery_millivolts = (unsigned int)BATT_MAXMVOLT;
  97 static int battery_percent = 100;       /* battery capacity level in percent */
  98 static int powermgmt_est_runningtime_min = BATT_MAXRUNTIME; /* estimated remaining time in minutes */
  99
 100 static void battery_status_update(void)
 101 {
 102     static time_t last_change = 0;
 103     static bool charging = false;
 104     time_t now;
 105
 106     time(&now);
 107     if (last_change < now)
 108     {
 109         last_change = now;
 110
 111         /* change the values: */
 112         if (charging)
 113         {
 114             if (battery_millivolts >= BATT_MAXMVOLT)
 115             {
 116                 /* Pretend the charger was disconnected */
 117                 charging = false;
 118                 queue_broadcast(SYS_CHARGER_DISCONNECTED, 0);
 119                 last_sent_battery_level = 100;
 120             }
 121         }
 122         else
 123         {
 124             if (battery_millivolts <= BATT_MINMVOLT)
 125             {
 126                 /* Pretend the charger was connected */
 127                 charging = true;
 128                 queue_broadcast(SYS_CHARGER_CONNECTED, 0);
 129                 last_sent_battery_level = 0;
 130             }
 131         }
 132         if (charging)
 133             battery_millivolts += (BATT_MAXMVOLT - BATT_MINMVOLT) / 50;
 134         else
 135             battery_millivolts -= (BATT_MAXMVOLT - BATT_MINMVOLT) / 100;
 136
 137         battery_percent = 100 * (battery_millivolts - BATT_MINMVOLT) /
 138                             (BATT_MAXMVOLT - BATT_MINMVOLT);
 139         powermgmt_est_runningtime_min = battery_percent * BATT_MAXRUNTIME / 100;
 140     }
 141     send_battery_level_event();
 142 }
 143
 144 void battery_read_info(int *voltage, int *level)
 145 {
 146     battery_status_update();
 147
 148     if (voltage)
 149         *voltage = battery_millivolts;
 150
 151     if (level)
 152         *level = battery_percent;
 153 }
 154
 155 unsigned int battery_voltage(void)
 156 {
 157     battery_status_update();
 158     return battery_millivolts;
 159 }
 160
 161 int battery_level(void)
 162 {
 163     battery_status_update();
 164     return battery_percent;
 165 }
 166
 167 int battery_time(void)
 168 {
 169     battery_status_update();
 170     return powermgmt_est_runningtime_min;
 171 }
 172
 173 bool battery_level_safe(void)
 174 {
 175     return battery_level() >= 10;
 176 }
 177
 178 void set_poweroff_timeout(int timeout)
 179 {
 180     (void)timeout;
 181 }
 182
 183 void set_battery_capacity(int capacity)
 184 {
 185   (void)capacity;
 186 }
 187
 188 #if BATTERY_TYPES_COUNT > 1
 189 void set_battery_type(int type)
 190 {
 191     (void)type;
 192 }
 193 #endif
 194
 195 void reset_poweroff_timer(void)
 196 {
 197 }
 198
 199 #ifdef HAVE_ACCESSORY_SUPPLY
 200 void accessory_supply_set(bool enable)
 201 {
 202     (void)enable;
 203 }
 204 #endif
 205
 206 #else /* not SIMULATOR ******************************************************/
 207
 208 static void power_thread_sleep(int ticks);
 209
 210 /*
 211  * Average battery voltage and charger voltage, filtered via a digital
 212  * exponential filter (aka. exponential moving average, scaled):
 213  * avgbat = y[n] = (N-1)/N*y[n-1] + x[n]. battery_millivolts = y[n] / N.
 214  */
 215 static unsigned int avgbat;     /* average battery voltage (filtering) */
 216 static unsigned int battery_millivolts;/* filtered battery voltage, millivolts */
 217
 218 /* battery level (0-100%) of this minute, updated once per minute */
 219 static int battery_percent  = -1;
 220 static int battery_capacity = BATTERY_CAPACITY_DEFAULT; /* default value, mAh */
 221 #if BATTERY_TYPES_COUNT > 1
 222 static int battery_type     = 0;
 223 #else
 224 #define battery_type 0
 225 #endif
 226
 227 /* Power history: power_history[0] is the newest sample */
 228 unsigned short power_history[POWER_HISTORY_LEN];
 229
 230 static char power_stack[DEFAULT_STACK_SIZE/2 + DEBUG_STACK];
 231 static const char power_thread_name[] = "power";
 232
 233 static int poweroff_timeout = 0;
 234 static int powermgmt_est_runningtime_min = -1;
 235
 236 static bool sleeptimer_active = false;
 237 static long sleeptimer_endtick;
 238
 239 static long last_event_tick;
 240
 241 static int voltage_to_battery_level(int battery_millivolts);
 242 static void battery_status_update(void);
 243 static int runcurrent(void);
 244
 245 void battery_read_info(int *voltage, int *level)
 246 {
 247     int millivolts = battery_adc_voltage();
 248
 249     if (voltage)
 250         *voltage = millivolts;
 251
 252     if (level)
 253         *level = voltage_to_battery_level(millivolts);
 254 }
 255
 256 void reset_poweroff_timer(void)
 257 {
 258     last_event_tick = current_tick;
 259 }
 260
 261 #if BATTERY_TYPES_COUNT > 1
 262 void set_battery_type(int type)
 263 {
 264     if (type != battery_type) {
 265         battery_type = type;
 266         battery_status_update();     /* recalculate the battery status */
 267     }
 268 }
 269 #endif
 270
 271 void set_battery_capacity(int capacity)
 272 {
 273     battery_capacity = capacity;
 274     if (battery_capacity > BATTERY_CAPACITY_MAX)
 275         battery_capacity = BATTERY_CAPACITY_MAX;
 276     if (battery_capacity < BATTERY_CAPACITY_MIN)
 277         battery_capacity = BATTERY_CAPACITY_MIN;
 278     battery_status_update();     /* recalculate the battery status */
 279 }
 280
 281 int battery_time(void)
 282 {
 283     return powermgmt_est_runningtime_min;
 284 }
 285
 286 /* Returns battery level in percent */
 287 int battery_level(void)
 288 {
 289     return battery_percent;
 290 }
 291
 292 /* Returns filtered battery voltage [millivolts] */
 293 unsigned int battery_voltage(void)
 294 {
 295     return battery_millivolts;
 296 }
 297
 298 /* Tells if the battery level is safe for disk writes */
 299 bool battery_level_safe(void)
 300 {
 301     return battery_millivolts > battery_level_dangerous[battery_type];
 302 }
 303
 304 void set_poweroff_timeout(int timeout)
 305 {
 306     poweroff_timeout = timeout;
 307 }
 308
 309 void set_sleep_timer(int seconds)
 310 {
 311     if(seconds) {
 312         sleeptimer_active  = true;
 313         sleeptimer_endtick = current_tick + seconds * HZ;
 314     }
 315     else {
 316         sleeptimer_active  = false;
 317         sleeptimer_endtick = 0;
 318     }
 319 }
 320
 321 int get_sleep_timer(void)
 322 {
 323     if(sleeptimer_active)
 324         return (sleeptimer_endtick - current_tick) / HZ;
 325     else
 326         return 0;
 327 }
 328
 329 /* look into the percent_to_volt_* table and get a realistic battery level */
 330 static int voltage_to_percent(int voltage, const short* table)
 331 {
 332     if (voltage <= table[0])
 333         return 0;
 334     else
 335         if (voltage >= table[10])
 336             return 100;
 337         else {
 338             /* search nearest value */
 339             int i = 0;
 340             while ((i < 10) && (table[i+1] < voltage))
 341                 i++;
 342             /* interpolate linear between the smaller and greater value */
 343             return (i * 10) /* Tens digit, 10% per entry */
 344                 + (((voltage - table[i]) * 10)
 345                    / (table[i+1] - table[i])); /* Ones digit: interpolated */
 346         }
 347 }
 348
 349 /* update battery level and estimated runtime, called once per minute or
 350  * when battery capacity / type settings are changed */
 351 static int voltage_to_battery_level(int battery_millivolts)
 352 {
 353     int level;
 354
 355 #if CONFIG_CHARGING >= CHARGING_MONITOR
 356     if (charge_state == DISCHARGING) {
 357         level = voltage_to_percent(battery_millivolts,
 358                     percent_to_volt_discharge[battery_type]);
 359     }
 360     else if (charge_state == CHARGING) {
 361         /* battery level is defined to be < 100% until charging is finished */
 362         level = MIN(voltage_to_percent(battery_millivolts,
 363                     percent_to_volt_charge), 99);
 364     }
 365     else { /* in topoff/trickle charge, battery is by definition 100% full */
 366         level = 100;
 367     }
 368 #else
 369     /* always use the discharge table */
 370     level = voltage_to_percent(battery_millivolts,
 371                 percent_to_volt_discharge[battery_type]);
 372 #endif /* CONFIG_CHARGING ... */
 373
 374     return level;
 375 }
 376
 377 static void battery_status_update(void)
 378 {
 379     int level = voltage_to_battery_level(battery_millivolts);
 380
 381     /* calculate estimated remaining running time */
 382     /* discharging: remaining running time */
 383     /* charging:    remaining charging time */
 384 #if CONFIG_CHARGING >= CHARGING_MONITOR
 385     if (charge_state == CHARGING) {
 386         powermgmt_est_runningtime_min = (100 - level) * battery_capacity * 60
 387                                       / 100 / (CURRENT_MAX_CHG - runcurrent());
 388     }
 389     else
 390 #endif
 391     {
 392         if ((battery_millivolts + 20) > percent_to_volt_discharge[0][0])
 393             powermgmt_est_runningtime_min = (level + battery_percent) * 60 *
 394                                          battery_capacity / 200 / runcurrent();
 395
 396         else if (battery_millivolts <= battery_level_shutoff[0])
 397             powermgmt_est_runningtime_min = 0;
 398
 399         else
 400             powermgmt_est_runningtime_min = (battery_millivolts -
 401                                              battery_level_shutoff[0]) / 2;
 402     }
 403
 404     battery_percent = level;
 405     send_battery_level_event();
 406 }
 407
 408 /*
 409  * We shut off in the following cases:
 410  * 1) The unit is idle, not playing music
 411  * 2) The unit is playing music, but is paused
 412  * 3) The battery level has reached shutdown limit
 413  *
 414  * We do not shut off in the following cases:
 415  * 1) The USB is connected
 416  * 2) The charger is connected
 417  * 3) We are recording, or recording with pause
 418  * 4) The radio is playing
 419  */
 420 static void handle_auto_poweroff(void)
 421 {
 422     long timeout = poweroff_timeout*60*HZ;
 423     int  audio_stat = audio_status();
 424
 425 #if CONFIG_CHARGING
 426     /*
 427      * Inhibit shutdown as long as the charger is plugged in.  If it is
 428      * unplugged, wait for a timeout period and then shut down.
 429      */
 430     if(charger_input_state == CHARGER || audio_stat == AUDIO_STATUS_PLAY) {
 431         last_event_tick = current_tick;
 432     }
 433 #endif
 434
 435 #ifndef NO_LOW_BATTERY_SHUTDOWN
 436     /* switch off unit if battery level is too low for reliable operation */
 437     if(battery_millivolts < battery_level_shutoff[battery_type]) {
 438         if(!shutdown_timeout) {
 439             backlight_on();
 440             sys_poweroff();
 441         }
 442     }
 443 #endif
 444
 445     if(timeout &&
 446 #if CONFIG_TUNER && !defined(BOOTLOADER)
 447        (!(get_radio_status() & FMRADIO_PLAYING)) &&
 448 #endif
 449        !usb_inserted() &&
 450        ((audio_stat == 0) ||
 451         ((audio_stat == (AUDIO_STATUS_PLAY | AUDIO_STATUS_PAUSE)) &&
 452          !sleeptimer_active)))
 453     {
 454         if(TIME_AFTER(current_tick, last_event_tick    + timeout) &&
 455            TIME_AFTER(current_tick, last_disk_activity + timeout))
 456         {
 457             sys_poweroff();
 458         }
 459     }
 460     else
 461     {
 462         /* Handle sleeptimer */
 463         if(sleeptimer_active && !usb_inserted())
 464         {
 465             if(TIME_AFTER(current_tick, sleeptimer_endtick))
 466             {
 467                 audio_stop();
 468 #if CONFIG_CHARGING && !defined(HAVE_POWEROFF_WHILE_CHARGING)
 469                 if((charger_input_state == CHARGER) ||
 470                    (charger_input_state == CHARGER_PLUGGED))
 471                 {
 472                     DEBUGF("Sleep timer timeout. Stopping...\n");
 473                     set_sleep_timer(0);
 474                     backlight_off(); /* Nighty, nighty... */
 475                 }
 476                 else
 477 #endif
 478                 {
 479                     DEBUGF("Sleep timer timeout. Shutting off...\n");
 480                     sys_poweroff();
 481                 }
 482             }
 483         }
 484     }
 485 }
 486
 487 /*
 488  * Estimate how much current we are drawing just to run.
 489  */
 490 static int runcurrent(void)
 491 {
 492     int current;
 493
 494 #if MEM == 8 && !defined(HAVE_MMC)
 495     /* assuming 192 kbps, the running time is 22% longer with 8MB */
 496     current = (CURRENT_NORMAL*100/122);
 497 #else
 498     current = CURRENT_NORMAL;
 499 #endif /* MEM == 8 */
 500
 501     if(usb_inserted()
 502 #if defined(HAVE_USB_POWER)
 503   #if (CURRENT_USB < CURRENT_NORMAL)
 504        || usb_powered()
 505   #else
 506        && !usb_powered()
 507   #endif
 508 #endif
 509     )
 510     {
 511         current = CURRENT_USB;
 512     }
 513
 514 #if defined(HAVE_BACKLIGHT) && !defined(BOOTLOADER)
 515     if (backlight_get_current_timeout() == 0) /* LED always on */
 516         current += CURRENT_BACKLIGHT;
 517 #endif
 518
 519 #if defined(HAVE_RECORDING) && defined(CURRENT_RECORD)
 520     if (audio_status() & AUDIO_STATUS_RECORD)
 521         current += CURRENT_RECORD;
 522 #endif
 523
 524 #ifdef HAVE_SPDIF_POWER
 525     if (spdif_powered())
 526         current += CURRENT_SPDIF_OUT;
 527 #endif
 528
 529 #ifdef HAVE_REMOTE_LCD
 530     if (remote_detect())
 531         current += CURRENT_REMOTE;
 532 #endif
 533
 534     return(current);
 535 }
 536
 537
 538 /* Check to see whether or not we've received an alarm in the last second */
 539 #ifdef HAVE_RTC_ALARM
 540 static void power_thread_rtc_process(void)
 541 {
 542     if (rtc_check_alarm_flag()) {
 543         rtc_enable_alarm(false);
 544     }
 545 }
 546 #endif
 547
 548 /*
 549  * This power thread maintains a history of battery voltage
 550  * and implements a charging algorithm.
 551  */
 552 #if CONFIG_CHARGING == CHARGING_CONTROL
 553 #define BATT_AVE_SAMPLES    32  /* filter constant / @ 2Hz sample rate */
 554
 555 /*
 556  * For a complete description of the charging algorithm read
 557  * docs/CHARGING_ALGORITHM.
 558  */
 559 int long_delta;                     /* long term delta battery voltage */
 560 int short_delta;                    /* short term delta battery voltage */
 561 bool disk_activity_last_cycle = false;  /* flag set to aid charger time
 562                                          * calculation */
 563 char power_message[POWER_MESSAGE_LEN] = ""; /* message that's shown in
 564                                            debug menu */
 565                                         /* percentage at which charging
 566                                            starts */
 567 int powermgmt_last_cycle_startstop_min = 0; /* how many minutes ago was the
 568                                            charging started or
 569                                            stopped? */
 570 int powermgmt_last_cycle_level = 0;     /* which level had the
 571                                            batteries at this time? */
 572 int trickle_sec = 0;                    /* how many seconds should the
 573                                            charger be enabled per
 574                                            minute for trickle
 575                                            charging? */
 576 int pid_p = 0;                      /* PID proportional term */
 577 int pid_i = 0;                      /* PID integral term */
 578
 579 static inline void charging_algorithm_small_step(void)
 580 {
 581     if (ata_disk_is_active()) {
 582         /* flag hdd use for charging calculation */
 583         disk_activity_last_cycle = true;
 584     }
 585
 586 #if defined(DEBUG_FILE)
 587     /*
 588      * If we have a lot of pending writes or if the disk is spining,
 589      * fsync the debug log file.
 590      */
 591     if((wrcount > 10) || ((wrcount > 0) && ata_disk_is_active())) {
 592         fsync(fd);
 593         wrcount = 0;
 594     }
 595 #endif /* defined(DEBUG_FILE) */
 596 }
 597
 598 static inline void charging_algorithm_big_step(void)
 599 {
 600     static unsigned int target_voltage = TRICKLE_VOLTAGE; /* desired topoff/trickle
 601                                                            * voltage level */
 602     static int charge_max_time_idle = 0; /* max. charging duration, calculated at
 603                                           * beginning of charging */
 604     static int charge_max_time_now = 0; /* max. charging duration including
 605                                          * hdd activity */
 606     static int minutes_disk_activity = 0; /* count minutes of hdd use during
 607                                            * charging */
 608     static int last_disk_activity = CHARGE_END_LONGD + 1; /* last hdd use x mins ago */
 609     int i;
 610
 611     if (charger_input_state == CHARGER_PLUGGED) {
 612         pid_p = 0;
 613         pid_i = 0;
 614         snprintf(power_message, POWER_MESSAGE_LEN, "Charger plugged in");
 615         /*
 616          * The charger was just plugged in.  If the battery level is
 617          * nearly charged, just trickle.  If the battery is low, start
 618          * a full charge cycle.  If the battery level is in between,
 619          * top-off and then trickle.
 620          */
 621         if(battery_percent > START_TOPOFF_CHG) {
 622             powermgmt_last_cycle_level = battery_percent;
 623             powermgmt_last_cycle_startstop_min = 0;
 624             if(battery_percent >= START_TRICKLE_CHG) {
 625                 charge_state = TRICKLE;
 626                 target_voltage = TRICKLE_VOLTAGE;
 627             } else {
 628                 charge_state = TOPOFF;
 629                 target_voltage = TOPOFF_VOLTAGE;
 630             }
 631         } else {
 632             /*
 633              * Start the charger full strength
 634              */
 635             i = CHARGE_MAX_TIME_1500 * battery_capacity / 1500;
 636             charge_max_time_idle =
 637                 i * (100 + 35 - battery_percent) / 100;
 638             if (charge_max_time_idle > i) {
 639                 charge_max_time_idle = i;
 640             }
 641             charge_max_time_now = charge_max_time_idle;
 642
 643             snprintf(power_message, POWER_MESSAGE_LEN,
 644                      "ChgAt %d%% max %dm", battery_level(),
 645                      charge_max_time_now);
 646
 647             /* enable the charger after the max time calc is done,
 648                because battery_level depends on if the charger is
 649                on */
 650             DEBUGF("power: charger inserted and battery"
 651                    " not full, charging\n");
 652             powermgmt_last_cycle_level = battery_percent;
 653             powermgmt_last_cycle_startstop_min = 0;
 654             trickle_sec  = 60;
 655             long_delta   = short_delta = 999999;
 656             charge_state = CHARGING;
 657         }
 658     }
 659
 660     if (charge_state == CHARGING) {
 661         /* alter charge time max length with extra disk use */
 662         if (disk_activity_last_cycle) {
 663             minutes_disk_activity++;
 664             charge_max_time_now = charge_max_time_idle +
 665                                  (minutes_disk_activity * 2 / 5);
 666             disk_activity_last_cycle = false;
 667             last_disk_activity = 0;
 668         } else {
 669             last_disk_activity++;
 670         }
 671         /*
 672          * Check the delta voltage over the last X minutes so we can do
 673          * our end-of-charge logic based on the battery level change.
 674          *(no longer use minimum time as logic for charge end has 50
 675          * minutes minimum charge built in)
 676          */
 677         if (powermgmt_last_cycle_startstop_min > CHARGE_END_SHORTD) {
 678             short_delta = power_history[0] -
 679                           power_history[CHARGE_END_SHORTD - 1];
 680         }
 681
 682         if (powermgmt_last_cycle_startstop_min > CHARGE_END_LONGD) {
 683         /*
 684          * Scan the history: the points where measurement is taken need to
 685          * be fairly static. (check prior to short delta 'area')
 686          * (also only check first and last 10 cycles - delta in middle OK)
 687          */
 688             long_delta = power_history[0] -
 689                          power_history[CHARGE_END_LONGD - 1];
 690
 691             for(i = CHARGE_END_SHORTD; i < CHARGE_END_SHORTD + 10; i++) {
 692                 if(((power_history[i] - power_history[i+1]) >  50) ||
 693                    ((power_history[i] - power_history[i+1]) < -50)) {
 694                     long_delta = 777777;
 695                     break;
 696                 }
 697             }
 698              for(i = CHARGE_END_LONGD - 11; i < CHARGE_END_LONGD - 1 ; i++) {
 699                 if(((power_history[i] - power_history[i+1]) >  50) ||
 700                    ((power_history[i] - power_history[i+1]) < -50)) {
 701                     long_delta = 888888;
 702                     break;
 703                 }
 704             }
 705         }
 706
 707         snprintf(power_message, POWER_MESSAGE_LEN,
 708                  "Chg %dm, max %dm", powermgmt_last_cycle_startstop_min,
 709                  charge_max_time_now);
 710         /*
 711          * End of charge criteria (any qualify):
 712          * 1) Charged a long time
 713          * 2) DeltaV went negative for a short time ( & long delta static)
 714          * 3) DeltaV was negative over a longer period (no disk use only)
 715          * Note: short_delta and long_delta are millivolts
 716          */
 717         if ((powermgmt_last_cycle_startstop_min >= charge_max_time_now) ||
 718             (short_delta <= -50 && long_delta < 50 ) || (long_delta  < -20 &&
 719             last_disk_activity > CHARGE_END_LONGD)) {
 720             if (powermgmt_last_cycle_startstop_min > charge_max_time_now) {
 721                 DEBUGF("power: powermgmt_last_cycle_startstop_min > charge_max_time_now, "
 722                        "enough!\n");
 723                 /*
 724                  *have charged too long and deltaV detection did not
 725                  *work!
 726                  */
 727                  snprintf(power_message, POWER_MESSAGE_LEN,
 728                          "Chg tmout %d min", charge_max_time_now);
 729                 /*
 730                  * Switch to trickle charging.  We skip the top-off
 731                  * since we've effectively done the top-off operation
 732                  * already since we charged for the maximum full
 733                  * charge time.
 734                  */
 735                 powermgmt_last_cycle_level = battery_percent;
 736                 powermgmt_last_cycle_startstop_min = 0;
 737                 charge_state = TRICKLE;
 738
 739                 /*
 740                  * set trickle charge target to a relative voltage instead
 741                  * of an arbitrary value - the fully charged voltage may
 742                  * vary according to ambient temp, battery condition etc
 743                  * trickle target is -0.15v from full voltage acheived
 744                  * topup target is -0.05v from full voltage
 745                  */
 746                 target_voltage = power_history[0] - 150;
 747
 748             } else {
 749                 if(short_delta <= -5) {
 750                     DEBUGF("power: short-term negative"
 751                            " delta, enough!\n");
 752                     snprintf(power_message, POWER_MESSAGE_LEN,
 753                              "end negd %d %dmin", short_delta,
 754                              powermgmt_last_cycle_startstop_min);
 755                     target_voltage = power_history[CHARGE_END_SHORTD - 1]
 756                                      - 50;
 757                 } else {
 758                     DEBUGF("power: long-term small "
 759                            "positive delta, enough!\n");
 760                     snprintf(power_message, POWER_MESSAGE_LEN,
 761                              "end lowd %d %dmin", long_delta,
 762                              powermgmt_last_cycle_startstop_min);
 763                     target_voltage = power_history[CHARGE_END_LONGD - 1]
 764                                      - 50;
 765                 }
 766                 /*
 767                  * Switch to top-off charging.
 768                  */
 769                 powermgmt_last_cycle_level = battery_percent;
 770                 powermgmt_last_cycle_startstop_min = 0;
 771                 charge_state = TOPOFF;
 772             }
 773         }
 774     }
 775     else if (charge_state != DISCHARGING)  /* top off or trickle */
 776     {
 777         /*
 778          *Time to switch from topoff to trickle?
 779          */
 780         if ((charge_state == TOPOFF) &&
 781             (powermgmt_last_cycle_startstop_min > TOPOFF_MAX_TIME))
 782         {
 783             powermgmt_last_cycle_level = battery_percent;
 784             powermgmt_last_cycle_startstop_min = 0;
 785             charge_state = TRICKLE;
 786             target_voltage = target_voltage - 100;
 787         }
 788         /*
 789          * Adjust trickle charge time (proportional and integral terms).
 790          * Note: I considered setting the level higher if the USB is
 791          * plugged in, but it doesn't appear to be necessary and will
 792          * generate more heat [gvb].
 793          */
 794
 795         pid_p = ((signed)target_voltage - (signed)battery_millivolts) / 5;
 796         if((pid_p <= PID_DEADZONE) && (pid_p >= -PID_DEADZONE))
 797             pid_p = 0;
 798
 799         if((unsigned) battery_millivolts < target_voltage) {
 800             if(pid_i < 60) {
 801                 pid_i++;        /* limit so it doesn't "wind up" */
 802             }
 803         } else {
 804             if(pid_i > 0) {
 805                 pid_i--;        /* limit so it doesn't "wind up" */
 806             }
 807         }
 808
 809         trickle_sec = pid_p + pid_i;
 810
 811         if(trickle_sec > 60) {
 812             trickle_sec = 60;
 813         }
 814         if(trickle_sec < 0) {
 815             trickle_sec = 0;
 816         }
 817
 818     } else if (charge_state == DISCHARGING) {
 819         trickle_sec = 0;
 820         /*
 821          * The charger is enabled here only in one case: if it was
 822          * turned on at boot time (power_init).  Turn it off now.
 823          */
 824         if (charger_enabled)
 825             charger_enable(false);
 826     }
 827
 828     if (charger_input_state == CHARGER_UNPLUGGED) {
 829         /*
 830          * The charger was just unplugged.
 831          */
 832         DEBUGF("power: charger disconnected, disabling\n");
 833
 834         charger_enable(false);
 835         powermgmt_last_cycle_level = battery_percent;
 836         powermgmt_last_cycle_startstop_min = 0;
 837         trickle_sec  = 0;
 838         pid_p        = 0;
 839         pid_i        = 0;
 840         charge_state = DISCHARGING;
 841         snprintf(power_message, POWER_MESSAGE_LEN, "Charger: discharge");
 842     }
 843
 844     /* sleep for a minute */
 845     if(trickle_sec > 0) {
 846         charger_enable(true);
 847         power_thread_sleep(HZ * trickle_sec);
 848     }
 849     if(trickle_sec < 60)
 850         charger_enable(false);
 851     power_thread_sleep(HZ * (60 - trickle_sec));
 852
 853 #if defined(DEBUG_FILE)
 854     if(usb_inserted()) {
 855         if(fd >= 0) {
 856             /* It is probably too late to close the file but we can try...*/
 857             close(fd);
 858             fd = -1;
 859         }
 860     } else {
 861         if(fd < 0) {
 862             fd = open(DEBUG_FILE_NAME, O_WRONLY | O_APPEND | O_CREAT);
 863             if(fd >= 0) {
 864                 snprintf(debug_message, DEBUG_MESSAGE_LEN,
 865                 "cycle_min, bat_millivolts, bat_percent, chgr_state"
 866                 " ,charge_state, pid_p, pid_i, trickle_sec\n");
 867                 write(fd, debug_message, strlen(debug_message));
 868                 wrcount = 99;   /* force a flush */
 869             }
 870         }
 871         if(fd >= 0) {
 872             snprintf(debug_message, DEBUG_MESSAGE_LEN,
 873                     "%d, %d, %d, %d, %d, %d, %d, %d\n",
 874                 powermgmt_last_cycle_startstop_min, battery_millivolts,
 875                 battery_percent, charger_input_state, charge_state,
 876                 pid_p, pid_i, trickle_sec);
 877             write(fd, debug_message, strlen(debug_message));
 878             wrcount++;
 879         }
 880     }
 881 #endif /* defined(DEBUG_FILE) */
 882
 883     powermgmt_last_cycle_startstop_min++;
 884 }
 885
 886 /*
 887  * Prepare charging for poweroff
 888  */
 889 static inline void charging_algorithm_close(void)
 890 {
 891 #if defined(DEBUG_FILE)
 892     if(fd >= 0) {
 893         close(fd);
 894         fd = -1;
 895     }
 896 #endif
 897 }
 898 #else
 899 #define BATT_AVE_SAMPLES   128  /* slw filter constant for all others */
 900
 901 static inline void charging_algorithm_small_step(void)
 902 {
 903 #if CONFIG_CHARGING == CHARGING_MONITOR
 904     switch (charger_input_state)
 905     {
 906         case CHARGER_UNPLUGGED:
 907         case NO_CHARGER:
 908             charge_state = DISCHARGING;
 909             break;
 910         case CHARGER_PLUGGED:
 911         case CHARGER:
 912             if (charging_state()) {
 913                 charge_state = CHARGING;
 914             } else {
 915                 charge_state = DISCHARGING;
 916             }
 917             break;
 918     }
 919 #endif /* CONFIG_CHARGING == CHARGING_MONITOR */
 920 }
 921
 922 static inline void charging_algorithm_big_step(void)
 923 {
 924     /* sleep for a minute */
 925     power_thread_sleep(HZ * 60);
 926 }
 927
 928 /*
 929  * Prepare charging for poweroff
 930  */
 931 static inline void charging_algorithm_close(void)
 932 {
 933     /* Nothing to do */
 934 }
 935 #endif /* CONFIG_CHARGING == CHARGING_CONTROL */
 936
 937 /*
 938  * This function is called to do the relativly long sleep waits from within the
 939  * main power_thread loop while at the same time servicing any other periodic
 940  * functions in the power thread which need to be called at a faster periodic
 941  * rate than the slow periodic rate of the main power_thread loop.
 942  *
 943  * While we are waiting for the time to expire, we average the battery
 944  * voltages.
 945  */
 946 static void power_thread_sleep(int ticks)
 947 {
 948     int small_ticks;
 949
 950     while (ticks > 0) {
 951
 952 #if CONFIG_CHARGING
 953         /*
 954          * Detect charger plugged/unplugged transitions.  On a plugged or
 955          * unplugged event, we return immediately, run once through the main
 956          * loop (including the subroutines), and end up back here where we
 957          * transition to the appropriate steady state charger on/off state.
 958          */
 959         if(charger_inserted()
 960 #ifdef HAVE_USB_POWER /* USB powered or USB inserted both provide power */
 961                 || usb_powered()
 962                 || (usb_inserted() && usb_charging_enabled())
 963 #endif
 964                 ) {
 965             switch(charger_input_state) {
 966                 case NO_CHARGER:
 967                 case CHARGER_UNPLUGGED:
 968                     charger_input_state = CHARGER_PLUGGED;
 969                     return;
 970                 case CHARGER_PLUGGED:
 971                     queue_broadcast(SYS_CHARGER_CONNECTED, 0);
 972                     last_sent_battery_level = 0;
 973                     charger_input_state = CHARGER;
 974                     break;
 975                 case CHARGER:
 976                     break;
 977             }
 978         } else {    /* charger not inserted */
 979             switch(charger_input_state) {
 980                 case NO_CHARGER:
 981                     break;
 982                 case CHARGER_UNPLUGGED:
 983                     queue_broadcast(SYS_CHARGER_DISCONNECTED, 0);
 984                     last_sent_battery_level = 100;
 985                     charger_input_state = NO_CHARGER;
 986                     break;
 987                 case CHARGER_PLUGGED:
 988                 case CHARGER:
 989                     charger_input_state = CHARGER_UNPLUGGED;
 990                     return;
 991             }
 992         }
 993 #endif /* CONFIG_CHARGING */
 994
 995         small_ticks = MIN(HZ/2, ticks);
 996         sleep(small_ticks);
 997         ticks -= small_ticks;
 998
 999         /* If the power off timeout expires, the main thread has failed
1000            to shut down the system, and we need to force a power off */
1001         if(shutdown_timeout) {
1002             shutdown_timeout -= small_ticks;
1003             if(shutdown_timeout <= 0)
1004                 power_off();
1005         }
1006
1007 #ifdef HAVE_RTC_ALARM
1008         power_thread_rtc_process();
1009 #endif
1010
1011         /*
1012          * Do a digital exponential filter.  We don't sample the battery if
1013          * the disk is spinning unless we are in USB mode (the disk will most
1014          * likely always be spinning in USB mode).
1015          */
1016         if (!ata_disk_is_active() || usb_inserted()) {
1017             avgbat += battery_adc_voltage() - (avgbat / BATT_AVE_SAMPLES);
1018             /*
1019              * battery_millivolts is the millivolt-scaled filtered battery value.
1020              */
1021             battery_millivolts = avgbat / BATT_AVE_SAMPLES;
1022
1023             /* update battery status every time an update is available */
1024             battery_status_update();
1025         }
1026         else if (battery_percent < 8) {
1027             /* If battery is low, observe voltage during disk activity.
1028              * Shut down if voltage drops below shutoff level and we are not
1029              * using NiMH or Alkaline batteries.
1030              */
1031             battery_millivolts = (battery_adc_voltage() +
1032                                   battery_millivolts + 1) / 2;
1033
1034             /* update battery status every time an update is available */
1035             battery_status_update();
1036
1037 #ifndef NO_LOW_BATTERY_SHUTDOWN
1038             if (!shutdown_timeout &&
1039                 (battery_millivolts < battery_level_shutoff[battery_type]))
1040                 sys_poweroff();
1041             else
1042 #endif
1043                 avgbat += battery_millivolts - (avgbat / BATT_AVE_SAMPLES);
1044         }
1045
1046         charging_algorithm_small_step();
1047     }
1048 }
1049
1050 static void power_thread(void)
1051 {
1052     /* Delay reading the first battery level */
1053 #ifdef MROBE_100
1054     while(battery_adc_voltage()>4200)  /* gives false readings initially */
1055 #endif
1056     sleep(HZ/100);
1057
1058     /* initialize the voltages for the exponential filter */
1059     avgbat = battery_adc_voltage() + 15;
1060
1061 #ifndef HAVE_MMC  /* this adjustment is only needed for HD based */
1062         /* The battery voltage is usually a little lower directly after
1063            turning on, because the disk was used heavily. Raise it by 5% */
1064 #ifdef HAVE_CHARGING
1065     if(!charger_inserted()) /* only if charger not connected */
1066 #endif
1067         avgbat += (percent_to_volt_discharge[battery_type][6] -
1068                    percent_to_volt_discharge[battery_type][5]) / 2;
1069 #endif /* not HAVE_MMC */
1070
1071     avgbat = avgbat * BATT_AVE_SAMPLES;
1072     battery_millivolts = avgbat / BATT_AVE_SAMPLES;
1073
1074 #if CONFIG_CHARGING
1075     if(charger_inserted()) {
1076         battery_percent  = voltage_to_percent(battery_millivolts,
1077                            percent_to_volt_charge);
1078     } else
1079 #endif
1080     {   battery_percent  = voltage_to_percent(battery_millivolts,
1081                            percent_to_volt_discharge[battery_type]);
1082         battery_percent += (battery_percent < 100);
1083     }
1084
1085     while (1)
1086     {
1087         /* rotate the power history */
1088         memmove(power_history + 1, power_history,
1089                 sizeof(power_history) - sizeof(power_history[0]));
1090
1091         /* insert new value at the start, in millivolts 8-) */
1092         power_history[0] = battery_millivolts;
1093
1094         charging_algorithm_big_step();
1095
1096         handle_auto_poweroff();
1097     }
1098 }
1099
1100 void powermgmt_init(void)
1101 {
1102     /* init history to 0 */
1103     memset(power_history, 0x00, sizeof(power_history));
1104     create_thread(power_thread, power_stack, sizeof(power_stack), 0,
1105                   power_thread_name IF_PRIO(, PRIORITY_SYSTEM)
1106                   IF_COP(, CPU));
1107 }
1108
1109 #endif /* SIMULATOR */
1110
1111 void sys_poweroff(void)
1112 {
1113     logf("sys_poweroff()");
1114     /* If the main thread fails to shut down the system, we will force a
1115        power off after an 20 second timeout - 28 seconds if recording */
1116     if (shutdown_timeout == 0)
1117     {
1118 #if (defined(IAUDIO_X5) || defined(IAUDIO_M5)) && !defined (SIMULATOR)
1119         pcf50606_reset_timeout(); /* Reset timer on first attempt only */
1120 #endif
1121 #ifdef HAVE_RECORDING
1122         if (audio_status() & AUDIO_STATUS_RECORD)
1123             shutdown_timeout += HZ*8;
1124 #endif
1125         shutdown_timeout += HZ*20;
1126     }
1127
1128     queue_broadcast(SYS_POWEROFF, 0);
1129 }
1130
1131 void cancel_shutdown(void)
1132 {
1133     logf("sys_cancel_shutdown()");
1134
1135 #if (defined(IAUDIO_X5) || defined(IAUDIO_M5)) && !defined (SIMULATOR)
1136     /* TODO: Move some things to target/ tree */
1137     if (shutdown_timeout)
1138         pcf50606_reset_timeout();
1139 #endif
1140
1141     shutdown_timeout = 0;
1142 }
1143
1144 /* Various hardware housekeeping tasks relating to shutting down the jukebox */
1145 void shutdown_hw(void)
1146 {
1147 #ifndef SIMULATOR
1148     charging_algorithm_close();
1149     audio_stop();
1150     if (battery_level_safe()) { /* do not save on critical battery */
1151 #ifdef HAVE_LCD_BITMAP
1152         glyph_cache_save();
1153 #endif
1154         if(ata_disk_is_active())
1155             ata_spindown(1);
1156     }
1157     while(ata_disk_is_active())
1158         sleep(HZ/10);
1159
1160 #if CONFIG_CODEC != SWCODEC
1161     mp3_shutdown();
1162 #else
1163     audiohw_close();
1164 #endif
1165
1166     /* If HD is still active we try to wait for spindown, otherwise the
1167        shutdown_timeout in power_thread_sleep will force a power off */
1168     while(ata_disk_is_active())
1169         sleep(HZ/10);
1170 #ifndef IAUDIO_X5
1171     lcd_set_contrast(0);
1172 #endif /* IAUDIO_X5 */
1173 #ifdef HAVE_REMOTE_LCD
1174     lcd_remote_set_contrast(0);
1175 #endif
1176
1177 #ifdef HAVE_LCD_SHUTDOWN
1178     lcd_shutdown();
1179 #endif
1180
1181     /* Small delay to make sure all HW gets time to flush. Especially
1182        eeprom chips are quite slow and might be still writing the last
1183        byte. */
1184     sleep(HZ/4);
1185     power_off();
1186 #endif /* #ifndef SIMULATOR */
1187 }
1188
1189 /* Send system battery level update events on reaching certain significant
1190    levels.  This must be called after battery_percent has been updated. */
1191 static void send_battery_level_event(void)
1192 {
1193     static const int levels[] = { 5, 15, 30, 50, 0 };
1194     const int *level = levels;
1195     while (*level)
1196     {
1197         if (battery_percent <= *level && last_sent_battery_level > *level)
1198         {
1199             last_sent_battery_level = *level;
1200             queue_broadcast(SYS_BATTERY_UPDATE, last_sent_battery_level);
1201             break;
1202         }
1203         level++;
1204     }
1205 }