firmware/target/arm/imx31/gigabeat-s/powermgmt-gigabeat-s.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (c) 2008 by Michael Sevakis
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21 #include <stdlib.h>
  22 #include "config.h"
  23 #include "system.h"
  24 #include "thread.h"
  25 #include "mc13783.h"
  26 #include "adc.h"
  27 #include "powermgmt.h"
  28 #include "power.h"
  29 #include "power-gigabeat-s.h"
  30
  31 const unsigned short battery_level_dangerous[BATTERY_TYPES_COUNT] =
  32 {
  33     3659
  34 };
  35
  36 const unsigned short battery_level_shutoff[BATTERY_TYPES_COUNT] =
  37 {
  38     3650
  39 };
  40
  41 /* voltages (millivolt) of 0%, 10%, ... 100% when charging disabled */
  42 const unsigned short percent_to_volt_discharge[BATTERY_TYPES_COUNT][11] =
  43 {
  44     /* Toshiba Gigabeat S Li Ion 700mAH figured from discharge curve */
  45     { 3659, 3719, 3745, 3761, 3785, 3813, 3856, 3926, 3984, 4040, 4121 },
  46 };
  47
  48 /* voltages (millivolt) of 0%, 10%, ... 100% when charging enabled */
  49 const unsigned short percent_to_volt_charge[11] =
  50 {
  51     /* Toshiba Gigabeat S Li Ion 700mAH figured from charge curve */
  52     4028, 4063, 4087, 4111, 4135, 4156, 4173, 4185, 4194, 4202, 4208
  53 };
  54
  55 /* Returns battery voltage from ADC [millivolts] */
  56 unsigned int battery_adc_voltage(void)
  57 {
  58     /* ADC reading 0-1023 = 2400mV-4700mV */
  59     return ((adc_read(ADC_BATTERY) * 2303) >> 10) + 2400;
  60 }
  61
  62 /* Returns the application supply voltage from ADC [millvolts] */
  63 unsigned int application_supply_adc_voltage(void)
  64 {
  65     return ((adc_read(ADC_APPLICATION_SUPPLY) * 2303) >> 10) + 2400;
  66 }
  67
  68 unsigned int chrgraw_adc_voltage(void)
  69 {
  70     return (adc_read(ADC_CHARGER_VOLTAGE) * 23023) >> 10;
  71 }
  72
  73 /* Returns battery charge current from ADC [milliamps] */
  74 int battery_adc_charge_current(void)
  75 {
  76     /* Positive reading = charger to battery
  77      * Negative reading = battery to charger terminal
  78      * ADC reading -512-511 = -2875mA-2875mA */
  79     unsigned int value = adc_read(ADC_CHARGER_CURRENT);
  80     int I;
  81
  82     if (value == ADC_READ_ERROR)
  83         return INT_MIN;
  84
  85     I = ((((int32_t)value << 22) >> 22) * 2881) >> 9;
  86     return ILEVEL_ADJUST_IN(I);
  87 }
  88
  89 /* Estimate power dissipation in the charge path regulator in mW. */
  90 unsigned int cccv_regulator_dissipation(void)
  91 {
  92     /* BATTISNS is shorted to BATT so we don't need to use the
  93      * battery current reading. */
  94     int chrgraw = (adc_read(ADC_CHARGER_VOLTAGE) * 230225) >> 10;
  95     int batt = ((adc_read(ADC_BATTERY) * 23023) >> 10) + 24000;
  96     int ichrgsn = adc_read(ADC_CHARGER_CURRENT);
  97     ichrgsn = ((((int32_t)ichrgsn << 22) >> 22) * 2881) >> 9;
  98     ichrgsn = abs(ichrgsn);
  99
 100     return (chrgraw - ichrgsn - batt)*ILEVEL_ADJUST_IN(ichrgsn) / 10000;
 101 }
 102
 103 /* Returns battery temperature from ADC [deg-C] */
 104 int battery_adc_temp(void)
 105 {
 106     /* E[volts] = value * 2.3V / 1023
 107      * R[ohms] = E/I = E[volts] / 0.00002[A] (Thermistor bias current source)
 108      *
 109      * Steinhart-Hart thermistor equation:
 110      * [A + B*ln(R) + D*ln^3(R)] = 1 / T[°K]
 111      *
 112      * Coeffients that fit experimental data (one thermistor so far, one run):
 113      * A = 0.0013002631685462800
 114      * B = 0.0002000841932612330
 115      * D = 0.0000000640446750919
 116      */
 117     static const unsigned short ntc_table[] =
 118     {
 119 #if 0   /* These have degree deltas > 1  (except the final two) so leave them
 120          * out. 70 deg C upper limit is quite sufficient. */
 121            0, /* INF */   1, /* 171 */   2, /* 145 */   3, /* 130 */
 122            4, /* 121 */   5, /* 114 */   6, /* 108 */   7, /* 104 */
 123            8, /* 100 */   9, /*  96 */  10, /*  93 */  11, /*  91 */
 124           12, /*  88 */  13, /*  86 */  14, /*  84 */  15, /*  82 */
 125           16, /*  81 */  17, /*  79 */  18, /*  78 */  19, /*  76 */
 126           20, /*  75 */  21, /*  74 */  22, /*  72 */  23, /*  71 */
 127 #endif
 128           24, /*  70 */  25, /*  69 */  26, /*  68 */  27, /*  67 */
 129           28, /*  66 */  30, /*  65 */  31, /*  64 */  32, /*  63 */
 130           33, /*  62 */  35, /*  61 */  36, /*  60 */  38, /*  59 */
 131           39, /*  58 */  41, /*  57 */  43, /*  56 */  45, /*  55 */
 132           47, /*  54 */  49, /*  53 */  51, /*  52 */  53, /*  51 */
 133           56, /*  50 */  58, /*  49 */  61, /*  48 */  63, /*  47 */
 134           66, /*  46 */  69, /*  45 */  73, /*  44 */  76, /*  43 */
 135           80, /*  42 */  83, /*  41 */  87, /*  40 */  92, /*  39 */
 136           96, /*  38 */ 101, /*  37 */ 106, /*  36 */ 111, /*  35 */
 137          116, /*  34 */ 122, /*  33 */ 128, /*  32 */ 135, /*  31 */
 138          142, /*  30 */ 149, /*  29 */ 156, /*  28 */ 164, /*  27 */
 139          173, /*  26 */ 182, /*  25 */ 192, /*  24 */ 202, /*  23 */
 140          212, /*  22 */ 224, /*  21 */ 236, /*  20 */ 249, /*  19 */
 141          262, /*  18 */ 277, /*  17 */ 292, /*  16 */ 308, /*  15 */
 142          325, /*  14 */ 344, /*  13 */ 363, /*  12 */ 384, /*  11 */
 143          406, /*  10 */ 429, /*   9 */ 454, /*   8 */ 480, /*   7 */
 144          509, /*   6 */ 539, /*   5 */ 571, /*   4 */ 605, /*   3 */
 145          641, /*   2 */ 680, /*   1 */ 722, /*   0 */ 766, /*  -1 */
 146          813, /*  -2 */ 864, /*  -3 */ 918, /*  -4 */ 976, /*  -5 */
 147     };
 148
 149     unsigned int value = adc_read(ADC_BATTERY_TEMP);
 150
 151     if (value > 0)
 152     {
 153         unsigned i;
 154
 155         for (i = 1; i < ARRAYLEN(ntc_table); i++)
 156         {
 157             if (ntc_table[i] > value)
 158                 break;
 159         }
 160
 161         return 71 - i;
 162     }
 163
 164     return INT_MIN;
 165 }
 166
 167 /** Charger control **/
 168
 169 /* All code has a preference for the main charger being connected over
 170  * USB. USB is considered in the algorithm only if it is the sole source. */
 171 static uint32_t int_sense0 = 0;      /* Interrupt Sense 0 bits */
 172 static unsigned int last_inputs = POWER_INPUT_NONE; /* Detect input changes */
 173 static int charger_total_timer = 0;  /* Total allowed charging time */
 174 static int icharger_ave = 0;         /* Filtered charging current */
 175 static bool charger_close = false;   /* Shutdown notification */
 176 static bool service_wdt = true;      /* Service the watchdog timer, if things
 177                                         go very wrong, cease and shut down. */
 178 static uint32_t charger_setting = 0; /* Current ICHRG and VCHRG regulator
 179                                       * setting (register bits) */
 180 #define CHARGER_ADJUST ((uint32_t)-1)/* Force change in regulator setting */
 181 static int autorecharge_counter = 0 ; /* Battery < threshold debounce */
 182 static int chgcurr_timer = 0;        /* Countdown to CHGCURR error */
 183 #define AUTORECHARGE_COUNTDOWN (10*2) /* 10s debounce */
 184 #define WATCHDOG_TIMEOUT       (10*2) /* If not serviced, poweroff in 10s */
 185 #define CHGCURR_TIMEOUT        (4*2)  /* 4s debounce */
 186
 187 /* Temperature monitoring */
 188 static enum
 189 {
 190     TEMP_STATE_NORMAL = 0, /* Within range */
 191     TEMP_STATE_WAIT = 1,   /* Went out of range, wait to come back */
 192     TEMP_LOW_LIMIT = 0,    /* Min temp */
 193     TEMP_HIGH_LIMIT = 1,   /* Max temp */
 194 } temp_state = TEMP_STATE_NORMAL;
 195
 196 /* Set power thread priority for charging mode or not */
 197 static inline void charging_set_thread_priority(bool charging)
 198 {
 199 #ifdef HAVE_PRIORITY_SCHEDULING
 200     thread_set_priority(THREAD_ID_CURRENT,
 201                         charging ? PRIORITY_REALTIME : PRIORITY_SYSTEM);
 202 #endif
 203     (void)charging;
 204 }
 205
 206 /* Update filtered charger current - exponential moving average */
 207 static bool charger_current_filter_step(void)
 208 {
 209     int value = battery_adc_charge_current();
 210
 211     if (value == ADC_READ_ERROR)
 212         return false;
 213
 214     icharger_ave += value - (icharger_ave / ICHARGER_AVE_SAMPLES);
 215     return true;
 216 }
 217
 218 /* Return true if the main charger is connected. */
 219 static bool main_charger_connected(void)
 220 {
 221     return (last_inputs &
 222             POWER_INPUT_MAIN_CHARGER &
 223             POWER_INPUT_CHARGER) != 0;
 224 }
 225
 226 /* Return the voltage level which should automatically trigger
 227  * another recharge cycle based upon which power source is available.
 228  * Assumes at least one is. */
 229 static unsigned int auto_recharge_voltage(void)
 230 {
 231     if (main_charger_connected())
 232         return BATT_VAUTO_RECHARGE;
 233     else
 234         return BATT_USB_VAUTO_RECHARGE;
 235 }
 236
 237 /* Return greater of supply (BP) or filtered battery voltage. */
 238 unsigned int input_millivolts(void)
 239 {
 240     unsigned int app_millivolts = application_supply_adc_voltage();
 241     unsigned int bat_millivolts = battery_voltage();
 242
 243     return MAX(app_millivolts, bat_millivolts);
 244 }
 245
 246 /* Get smoothed readings for initializing filtered data. */
 247 static int stat_battery_reading(int type)
 248 {
 249     int high = INT_MIN, low = INT_MAX;
 250     int value = 0;
 251     int i;
 252
 253     for (i = 0; i < 7; i++)
 254     {
 255         int reading = ADC_READ_ERROR;
 256
 257         sleep(2); /* Get unique readings */
 258
 259         switch (type)
 260         {
 261         case ADC_BATTERY:
 262             reading = battery_adc_voltage();
 263             break;
 264
 265         case ADC_CHARGER_CURRENT:
 266             reading = battery_adc_charge_current();
 267             break;
 268         }
 269
 270         if (reading == ADC_READ_ERROR)
 271             return INT_MIN;
 272
 273         if (reading > high)
 274             high = reading;
 275
 276         if (reading < low)
 277             low = reading;
 278
 279         value += reading;
 280     }
 281
 282     /* Discard extremes */
 283     return (value - high - low) / 5;
 284 }
 285
 286 /* Update filtered battery voltage instead of waiting for filter
 287  * decay. */
 288 static bool update_filtered_battery_voltage(void)
 289 {
 290     int millivolts = stat_battery_reading(ADC_BATTERY);
 291
 292     if (millivolts != INT_MIN)
 293     {
 294         reset_battery_filter(millivolts);
 295         return true;
 296     }
 297
 298     return false;
 299 }
 300
 301 /* Sets the charge current limit based upon state. charge_state should be
 302  * set before calling. */
 303 static bool adjust_charger_current(void)
 304 {
 305     static const uint8_t charger_bits[][2] =
 306     {
 307         [DISCHARGING] =
 308         {
 309             /* These are actually zeros but reflect this setting */
 310             MC13783_ICHRG_0MA | MC13783_VCHRG_4_050V,
 311             MC13783_ICHRG_0MA | MC13783_VCHRG_4_050V,
 312         },
 313         /* Main(+USB): Charge slowly from the adapter until voltage is
 314          * sufficient for normal charging.
 315          *
 316          * USB: The truth is that things will probably not make it this far.
 317          * Cover the case, just in case the disk isn't used and it is
 318          * manageable. */
 319         [TRICKLE] =
 320         {
 321             BATTERY_ITRICKLE | BATTERY_VCHARGING,
 322             BATTERY_ITRICKLE_USB | BATTERY_VCHARGING
 323         },
 324         [TOPOFF] =
 325         {
 326             BATTERY_IFAST | BATTERY_VCHARGING,
 327             BATTERY_IFAST_USB | BATTERY_VCHARGING
 328         },
 329         [CHARGING] =
 330         {
 331             BATTERY_IFAST | BATTERY_VCHARGING,
 332             BATTERY_IFAST_USB | BATTERY_VCHARGING
 333         },
 334         /* Must maintain battery when on USB power only - utterly nasty
 335          * but true and something retailos does (it will even end up charging
 336          * the battery but not reporting that it is doing so).
 337          * Float lower than MAX - could end up slightly discharging after
 338          * a full charge but this is safer than maxing it out. */
 339         [CHARGING+1] =
 340         {
 341             BATTERY_IFLOAT_USB | BATTERY_VFLOAT_USB,
 342             BATTERY_IMAINTAIN_USB | BATTERY_VMAINTAIN_USB
 343         },
 344 #if 0
 345         /* Slower settings to so that the linear regulator doesn't dissipate
 346          * an excessive amount of power when coming out of precharge state. */
 347         [CHARGING+2] =
 348         {
 349             BATTERY_ISLOW | BATTERY_VCHARGING,
 350             BATTERY_ISLOW_USB | BATTEYR_VCHARGING
 351         },
 352 #endif
 353     };
 354
 355     bool success = false;
 356     int usb_select;
 357     uint32_t i;
 358
 359     usb_select = ((last_inputs & POWER_INPUT) == POWER_INPUT_USB)
 360                     ? 1 : 0;
 361
 362     if (charge_state == DISCHARGING && usb_select == 1)
 363     {
 364         /* USB-only, DISCHARGING, = maintaining battery */
 365         int select = (last_inputs & POWER_INPUT_CHARGER) ? 0 : 1;
 366         charger_setting = charger_bits[CHARGING+1][select];
 367     }
 368     else
 369     {
 370         /* Take very good care not to write garbage. */
 371         int state = charge_state;
 372
 373         if (state < DISCHARGING || state > CHARGING)
 374             state = DISCHARGING;
 375
 376         charger_setting = charger_bits[state][usb_select];
 377     }
 378
 379     if (charger_setting != 0)
 380     {
 381         if ((charger_setting & MC13783_VCHRG) > BATTERY_VCHARGING ||
 382             (charger_setting & MC13783_ICHRG) > BATTERY_IFAST)
 383         {
 384             /* Table is corrupted somehow. We shouldn't run at all.
 385              *
 386              * Explanation: On two occasions, even though this driver monitors
 387              *              the regulator register settings on each step and
 388              *              ensures that only valid table indexes are used,
 389              *              the current and voltage seem to be misregulated,
 390              *              resulting in excessively high battery voltage that
 391              *              will trip the battery protection. After careful
 392              *              review it seems that two possibilities exist:
 393              *              This code or data got trashed at some point or
 394              *              there really is a hardware bug of some sort. So
 395              *              far the cause is unknown. Voltage is also
 396              *              monitored in the CHARGING case for that reason.
 397              *              The solution for data or code corruption is to
 398              *              just panic and refuse to run the device. The
 399              *              solution for overvoltage due to hardware bug is to
 400              *              disable the charging. The action taken will reveal
 401              *              the true cause, thus _who_ is responsible.
 402              *              "Burning lithium is baaaad", so sayeth The Council
 403              *              of Seven Ascended Masters. */
 404             charge_state = CHARGE_STATE_DISABLED;
 405             service_wdt = false;
 406         }
 407         else
 408         {
 409             /* Turn on 5K pulldown. */
 410             i = mc13783_set(MC13783_CHARGER, MC13783_CHRGRAWPDEN);
 411
 412             if (i != MC13783_DATA_ERROR)
 413             {
 414                 charging_set_thread_priority(true);
 415
 416                 /* Turn regulator logically ON. Hardware may still override.
 417                  */
 418                 i = mc13783_write_masked(MC13783_CHARGER, charger_setting,
 419                                          MC13783_ICHRG | MC13783_VCHRG);
 420
 421                 if (i != MC13783_DATA_ERROR)
 422                 {
 423                     int icharger;
 424
 425                     /* Enable charge current conversion */
 426                     adc_enable_channel(ADC_CHARGER_CURRENT, true);
 427
 428                     /* Charge path regulator turn on takes ~100ms max. */
 429                     sleep(HZ/10);
 430
 431                     icharger = stat_battery_reading(ADC_CHARGER_CURRENT);
 432
 433                     if (icharger != INT_MIN)
 434                     {
 435                         icharger_ave = icharger * ICHARGER_AVE_SAMPLES;
 436
 437                         if (update_filtered_battery_voltage())
 438                             return true;
 439                     }
 440                 }
 441             }
 442
 443             /* Force regulator OFF. */
 444             charge_state = CHARGE_STATE_ERROR;
 445         }
 446     }
 447
 448     /* Turn regulator OFF. */
 449     icharger_ave = 0;
 450     i = mc13783_write_masked(MC13783_CHARGER,
 451                              MC13783_ICHRG_0MA | MC13783_VCHRG_4_050V,
 452                              MC13783_ICHRG | MC13783_VCHRG |
 453                              MC13783_CHRGRAWPDEN);
 454
 455     if (MC13783_DATA_ERROR == i)
 456     {
 457         /* Failed. Force poweroff by not servicing the watchdog. */
 458         service_wdt = false;
 459     }
 460     else if (0 == charger_setting)
 461     {
 462         /* Here because OFF was requested state */
 463         success = true;
 464     }
 465
 466     charger_setting = 0;
 467
 468     adc_enable_channel(ADC_CHARGER_CURRENT, false);
 469     update_filtered_battery_voltage();
 470     charging_set_thread_priority(false);
 471
 472     return success;
 473 }
 474
 475 /* Stop the charger - if USB only then the regulator will not really be
 476  * turned off. ERROR or DISABLED will turn it off however. */
 477 static void stop_charger(void)
 478 {
 479     charger_total_timer = 0;
 480
 481     if (charge_state > DISCHARGING)
 482         charge_state = DISCHARGING;
 483
 484     adjust_charger_current();
 485 }
 486
 487 /* Return OK if it is acceptable to start the regulator. */
 488 static bool charging_ok(void)
 489 {
 490     bool ok = charge_state >= DISCHARGING; /* Not an error condition? */
 491
 492     if (ok)
 493     {
 494         /* Is the battery even connected? */
 495         ok = (last_inputs & POWER_INPUT_BATTERY) != 0;
 496     }
 497
 498     if (ok)
 499     {
 500         /* No tolerance for any over/under temp - wait for it to
 501          * come back into safe range. */
 502         static const signed char temp_ranges[2][2] =
 503         {
 504             /* Temperature range before beginning charging */
 505             { BATTERY_CHARGE_MIN,
 506               BATTERY_CHARGE_MAX },
 507             /* Temperature range after out-of-range detected -
 508                charging will self-resume */
 509             { BATTERY_CHARGE_RESTART_MIN,
 510               BATTERY_CHARGE_RESTART_MAX },
 511         };
 512
 513         int temp = battery_adc_temp();
 514         const signed char *range = temp_ranges[temp_state];
 515
 516         ok = temp >= range[TEMP_LOW_LIMIT] &&
 517              temp <= range[TEMP_HIGH_LIMIT];
 518
 519         switch (temp_state)
 520         {
 521         case TEMP_STATE_NORMAL:
 522             if (!ok)
 523                 temp_state = TEMP_STATE_WAIT;
 524             break;
 525
 526         case TEMP_STATE_WAIT:
 527             if (ok)
 528                 temp_state = TEMP_STATE_NORMAL;
 529             break;
 530
 531         default:
 532             break;
 533         }
 534     }
 535
 536     if (ok)
 537     {
 538         /* Any events that should stop the regulator? */
 539
 540         /* Overvoltage at CHRGRAW? */
 541         ok = (int_sense0 & MC13783_CHGOVS) == 0;
 542
 543         if (ok)
 544         {
 545             /* CHGCURR sensed? */
 546             ok = (int_sense0 & MC13783_CHGCURRS) != 0;
 547
 548             if (!ok)
 549             {
 550                 /* Debounce transient states */
 551                 if (chgcurr_timer > 0)
 552                 {
 553                     chgcurr_timer--;
 554                     ok = true;
 555                 }
 556             }
 557             else
 558             {
 559                 chgcurr_timer = CHGCURR_TIMEOUT;
 560             }
 561         }
 562
 563         /* Charger may need to be reinserted */
 564         if (!ok)
 565             charge_state = CHARGE_STATE_ERROR;
 566     }
 567
 568     if (charger_setting != 0)
 569     {
 570         if (ok)
 571         {
 572             /* Protect against any conceivable overcharge/voltage condition
 573              * before hardware protection must intervene. Disable charger
 574              * until reboot. */
 575             ok = battery_voltage() < BATT_TOO_HIGH;
 576             if (!ok)
 577                 charge_state = CHARGE_STATE_DISABLED;
 578         }
 579
 580         if (ok)
 581         {
 582             /* Watch to not overheat FET (nothing should go over about 1012.7mW).
 583              * Trying a higher voltage AC adapter can work (up to 6.90V) but
 584              * we'll just reject that. Reducing current for adapters that bring
 585              * CHRGRAW to > 4.900V is another possible action. */
 586             ok = cccv_regulator_dissipation() < 1150;
 587             if (!ok)
 588                 charge_state = CHARGE_STATE_ERROR;
 589         }
 590
 591         if (!ok)
 592         {
 593             int state = charge_state;
 594
 595             if (state > DISCHARGING)
 596                 state = DISCHARGING;
 597
 598             /* Force off for all states including maintaining the battery level
 599              * on USB. */
 600             charge_state = CHARGE_STATE_ERROR;
 601             stop_charger();
 602             charge_state = state;
 603         }
 604     }
 605
 606     return ok;
 607 }
 608
 609 void powermgmt_init_target(void)
 610 {
 611     last_inputs = power_thread_inputs;
 612
 613 #ifdef IMX31_ALLOW_CHARGING
 614     const uint32_t regval_w =
 615         MC13783_VCHRG_4_050V | MC13783_ICHRG_0MA |
 616         MC13783_ICHRGTR_0MA | MC13783_OVCTRL_6_90V;
 617
 618     /* Use watchdog to shut system down if we lose control of the charging
 619      * hardware. */
 620     watchdog_init(WATCHDOG_TIMEOUT);
 621
 622     mc13783_write(MC13783_CHARGER, regval_w);
 623
 624     if (mc13783_read(MC13783_CHARGER) == regval_w)
 625     {
 626         /* Divide CHRGRAW input by 10 */
 627         mc13783_clear(MC13783_ADC0, MC13783_CHRGRAWDIV);
 628         /* Turn off BATTDETB. It's worthless on MESx0V since the battery
 629          * isn't removable (nor the thermistor). */
 630         mc13783_clear(MC13783_POWER_CONTROL0, MC13783_BATTDETEN);
 631     }
 632     else
 633     {
 634         /* Register has the wrong value - set error condition and disable
 635          * since something is wrong. */
 636         charge_state = CHARGE_STATE_DISABLED;
 637         stop_charger();
 638     }
 639 #else
 640     /* Disable charger use */
 641     charge_state = CHARGE_STATE_DISABLED;
 642 #endif
 643 }
 644
 645 /* Returns true if the unit is charging the batteries. */
 646 bool charging_state(void)
 647 {
 648     switch (charge_state)
 649     {
 650     case TRICKLE:
 651     case TOPOFF:
 652     case CHARGING:
 653         return true;
 654     default:
 655         return false;
 656     }
 657 }
 658
 659 /* Filtered battery charge current */
 660 int battery_charge_current(void)
 661 {
 662     return icharger_ave / ICHARGER_AVE_SAMPLES;
 663 }
 664
 665 static void charger_plugged(void)
 666 {
 667     adc_enable_channel(ADC_BATTERY_TEMP, true);
 668     autorecharge_counter = -1;
 669 }
 670
 671 static void charger_unplugged(void)
 672 {
 673     /* Charger pulled - turn off current sources (though hardware
 674      * will have done that anyway). */
 675     if (charge_state > CHARGE_STATE_DISABLED)
 676     {
 677         /* Reset state and clear any error. If disabled, the charger
 678          * will not have been started or will have been stopped already. */
 679         stop_charger();
 680         charge_state = DISCHARGING;
 681     }
 682
 683     /* Might need to reevaluate these bits in charger_none. */
 684     last_inputs &= ~(POWER_INPUT | POWER_INPUT_CHARGER);
 685     temp_state = TEMP_STATE_NORMAL;
 686     autorecharge_counter = 0;
 687     chgcurr_timer = 0;
 688
 689     adc_enable_channel(ADC_BATTERY_TEMP, false);
 690 }
 691
 692 static void charger_none(void)
 693 {
 694     unsigned int pwr = power_thread_inputs;
 695
 696     if (last_inputs != pwr)
 697     {
 698         last_inputs = pwr;
 699
 700         if (charge_state == CHARGE_STATE_DISABLED)
 701             return;
 702
 703         if ((pwr & (POWER_INPUT | POWER_INPUT_CHARGER)) == POWER_INPUT_USB)
 704         {
 705             /* USB connected but not configured. Maintain battery to the
 706              * greatest degree possible. It probably won't be enough but the
 707              * discharge won't be so severe. */
 708             charger_plugged();
 709             charger_setting = CHARGER_ADJUST;
 710         }
 711         else
 712         {
 713             charger_unplugged();
 714             last_inputs = pwr; /* Restore status */
 715         }
 716     }
 717     else if (charger_setting != 0)
 718     {
 719         /* Maintaining - keep filter going and check charge state */
 720         int_sense0 = mc13783_read(MC13783_INTERRUPT_SENSE0);
 721
 722         if (!charger_current_filter_step())
 723         {
 724             /* Failed to read current */
 725             charge_state = CHARGE_STATE_ERROR;
 726         }
 727
 728         charging_ok();
 729     }
 730 }
 731
 732 static void charger_control(void)
 733 {
 734     unsigned int pwr = power_thread_inputs;
 735
 736     if (last_inputs != pwr)
 737     {
 738         unsigned int changed = last_inputs ^ pwr;
 739
 740         last_inputs = pwr;
 741
 742         if (charger_setting != 0)
 743             charger_setting = CHARGER_ADJUST;
 744
 745         if (charge_state == DISCHARGING)
 746         {
 747             if (main_charger_connected())
 748             {
 749                 /* If main is connected, ignore USB plugs. */
 750                 if (changed & POWER_INPUT_MAIN_CHARGER)
 751                 {
 752                     /* Main charger plugged - try charge */
 753                     autorecharge_counter = -1;
 754                 }
 755             }
 756             else if (pwr & POWER_INPUT_USB_CHARGER
 757                         & POWER_INPUT_CHARGER)
 758             {
 759                 /* USB power only */
 760                 if (changed & POWER_INPUT_USB_CHARGER)
 761                 {
 762                     /* USB charger plugged - try charge */
 763                     autorecharge_counter = -1;
 764                 }
 765                 else if (changed & POWER_INPUT_MAIN_CHARGER)
 766                 {
 767                     /* Main charger pulled - go to battery maintenence. */
 768                     charger_setting = CHARGER_ADJUST;
 769                 }
 770             }
 771         }
 772     }
 773
 774     if (charger_setting != 0 && !charger_current_filter_step())
 775     {
 776         /* Failed to read current */
 777         charge_state = CHARGE_STATE_ERROR;
 778     }
 779
 780     int_sense0 = mc13783_read(MC13783_INTERRUPT_SENSE0);
 781
 782     if (!charging_ok())
 783         return;
 784
 785     switch (charge_state)
 786     {
 787     case DISCHARGING:
 788     {
 789         /* Battery voltage may have dropped and a charge cycle should
 790          * start again. Debounced. */
 791         if (autorecharge_counter < 0 &&
 792             battery_adc_voltage() < BATT_FULL_VOLTAGE)
 793         {
 794             /* Try starting a cycle now if battery isn't already topped
 795              * off to allow user to ensure the battery is full. */
 796         }
 797         else if (battery_voltage() > auto_recharge_voltage())
 798         {
 799             /* Still above threshold - reset counter */
 800             autorecharge_counter = AUTORECHARGE_COUNTDOWN;
 801             break;
 802         }
 803         else if (autorecharge_counter > 0)
 804         {
 805             /* Coundown to restart */
 806             autorecharge_counter--;
 807             break;
 808         }
 809
 810         autorecharge_counter = 0;
 811
 812         charging_set_thread_priority(true);
 813
 814         if (stat_battery_reading(ADC_BATTERY) < BATT_VTRICKLE_CHARGE)
 815         {
 816             /* Battery is deeply discharged - precharge at lower current. */
 817             charge_state = TRICKLE;
 818         }
 819         else
 820         {
 821             /* Ok for fast charge */
 822             charge_state = CHARGING;
 823         }
 824
 825         charger_setting = CHARGER_ADJUST;
 826         charger_total_timer = CHARGER_TOTAL_TIMER*60*2;
 827         break;
 828         } /* DISCHARGING: */
 829
 830     case TRICKLE: /* Very low - precharge */
 831     {
 832         if (battery_voltage() <= BATT_VTRICKLE_CHARGE)
 833             break;
 834
 835         /* Switch to normal charge mode. */
 836         charge_state = CHARGING;
 837         charger_setting = CHARGER_ADJUST;
 838         break;
 839         } /* TRICKLE: */
 840
 841     case CHARGING: /* Constant-current stage */
 842     case TOPOFF:   /* Constant-voltage stage */
 843     {
 844         /* Reg. mode is more informative than an operational necessity. */
 845         charge_state = (int_sense0 & MC13783_CCCVS) ? TOPOFF : CHARGING;
 846
 847         if (main_charger_connected())
 848         {
 849             /* Monitor and stop if current drops below threshold. */
 850             if (battery_charge_current() > BATTERY_ICHARGE_COMPLETE)
 851                 break;
 852         }
 853         else
 854         {
 855             /* Accurate I-level can't be determined since device also
 856              * powers through the I sense. This simply stops the reporting
 857              * of charging but the regulator remains on. */
 858             if (battery_voltage() <= BATT_USB_VSTOP)
 859                 break;
 860         }
 861
 862         stop_charger();
 863         break;
 864         } /* CHARGING: TOPOFF: */
 865
 866     default:
 867         break;
 868     } /* switch */
 869
 870     /* Check if charger timer expired and stop it if so. */
 871     if (charger_total_timer > 0 && --charger_total_timer == 0)
 872     {
 873         charge_state = CHARGE_STATE_ERROR;
 874         stop_charger(); /* Time ran out - error */
 875     }
 876 }
 877
 878 /* Main charging algorithm - called from powermgmt.c */
 879 void charging_algorithm_step(void)
 880 {
 881 #ifdef IMX31_ALLOW_CHARGING
 882     if (service_wdt)
 883         watchdog_service();
 884 #endif
 885
 886     /* Switch by input state */
 887     switch (charger_input_state)
 888     {
 889     case NO_CHARGER:
 890         charger_none();
 891         break;
 892
 893     case CHARGER_PLUGGED:
 894         charger_plugged();
 895         break;
 896
 897     case CHARGER:
 898         charger_control();
 899         break;
 900
 901     case CHARGER_UNPLUGGED:
 902         charger_unplugged();
 903         break;
 904     } /* switch */
 905
 906     if (charger_close)
 907     {
 908         if (charge_state != CHARGE_STATE_DISABLED)
 909         {
 910             /* Disable starts while shutting down */
 911             charge_state = CHARGE_STATE_DISABLED;
 912             stop_charger();
 913         }
 914
 915         charger_close = false;
 916         return;
 917     }
 918
 919     if (charger_setting != 0)
 920     {
 921         if ((mc13783_read(MC13783_CHARGER) & (MC13783_ICHRG | MC13783_VCHRG)) !=
 922             charger_setting)
 923         {
 924             /* The hardware setting doesn't match. It could have turned the
 925              * charger off in a race of plugging/unplugging or the setting
 926              * was changed in one of the calls. */
 927             adjust_charger_current();
 928         }
 929     }
 930 }
 931
 932 /* Disable the charger and prepare for poweroff - called off-thread so we
 933  * signal the charging thread to prepare to quit. */
 934 void charging_algorithm_close(void)
 935 {
 936     charger_close = true;
 937
 938     /* Power management thread will set it false again */
 939     while (charger_close)
 940         sleep(HZ/10);
 941 }