diff options
Diffstat (limited to 'firmware/powermgmt.c')
| -rw-r--r-- | firmware/powermgmt.c | 252 |
1 files changed, 169 insertions, 83 deletions
diff --git a/firmware/powermgmt.c b/firmware/powermgmt.c index 008e4a45cb..b4f8aab815 100644 --- a/firmware/powermgmt.c +++ b/firmware/powermgmt.c @@ -86,7 +86,14 @@ void handle_auto_poweroff(void); static int poweroff_timeout = 0; static long last_event_tick = 0; -#if (CONFIG_PLATFORM & PLATFORM_NATIVE) || defined(SAMSUNG_YPR0) +#if (CONFIG_BATTERY_MEASURE & PERCENTAGE_MEASURE) == PERCENTAGE_MEASURE +int _battery_voltage(void) { return -1; } + +const unsigned short percent_to_volt_discharge[BATTERY_TYPES_COUNT][11]; +const unsigned short percent_to_volt_charge[11]; + +#elif (CONFIG_BATTERY_MEASURE & VOLTAGE_MEASURE) == VOLTAGE_MEASURE +int _battery_level(void) { return -1; } /* * Average battery voltage and charger voltage, filtered via a digital * exponential filter (aka. exponential moving average, scaled): @@ -95,10 +102,22 @@ static long last_event_tick = 0; static unsigned int avgbat; /* filtered battery voltage, millivolts */ static unsigned int battery_millivolts; +#elif (CONFIG_BATTERY_MEASURE == 0) +int _battery_voltage(void) { return -1; } +int _battery_level(void) { return -1; } + +const unsigned short percent_to_volt_discharge[BATTERY_TYPES_COUNT][11]; +const unsigned short percent_to_volt_charge[11]; +#endif + +#if !(CONFIG_BATTERY_MEASURE & TIME_MEASURE) +static int powermgmt_est_runningtime_min; +int _battery_time(void) { return powermgmt_est_runningtime_min; } +#endif + /* default value, mAh */ static int battery_capacity = BATTERY_CAPACITY_DEFAULT; - #if BATTERY_TYPES_COUNT > 1 static int battery_type = 0; #else @@ -115,7 +134,6 @@ static char power_stack[DEFAULT_STACK_SIZE/2 + POWERMGMT_DEBUG_STACK]; #endif static const char power_thread_name[] = "power"; -static int powermgmt_est_runningtime_min = -1; static int voltage_to_battery_level(int battery_millivolts); static void battery_status_update(void); @@ -126,13 +144,18 @@ static int runcurrent(void); void battery_read_info(int *voltage, int *level) { - int millivolts = battery_adc_voltage(); + int millivolts = _battery_voltage(); + int percent; if (voltage) *voltage = millivolts; - if (level) - *level = voltage_to_battery_level(millivolts); + if (level) { + percent = voltage_to_battery_level(millivolts); + if (percent < 0) + percent = _battery_level(); + *level = percent; + } } #if BATTERY_TYPES_COUNT > 1 @@ -148,6 +171,7 @@ void set_battery_type(int type) } #endif +#ifdef BATTERY_CAPACITY_MIN void set_battery_capacity(int capacity) { if (capacity > BATTERY_CAPACITY_MAX) @@ -159,6 +183,7 @@ void set_battery_capacity(int capacity) battery_status_update(); /* recalculate the battery status */ } +#endif int get_battery_capacity(void) { @@ -167,7 +192,16 @@ int get_battery_capacity(void) int battery_time(void) { - return powermgmt_est_runningtime_min; +#if ((CONFIG_BATTERY_MEASURE & TIME_MEASURE) == 0) + +#ifndef CURRENT_NORMAL /* no estimation without current */ + return -1; +#endif + if (battery_capacity <= 0) /* nor without capacity */ + return -1; + +#endif + return _battery_time(); } /* Returns battery level in percent */ @@ -180,17 +214,13 @@ int battery_level(void) return battery_percent; } -/* Returns filtered battery voltage [millivolts] */ -unsigned int battery_voltage(void) -{ - return battery_millivolts; -} - /* Tells if the battery level is safe for disk writes */ bool battery_level_safe(void) { #if defined(NO_LOW_BATTERY_SHUTDOWN) return true; +#elif (CONFIG_BATTERY_MEASURE & PERCENTAGE_MEASURE) + return (battery_percent > 0); #elif defined(HAVE_BATTERY_SWITCH) /* Cannot rely upon the battery reading to be valid and the * device could be powered externally. */ @@ -228,6 +258,9 @@ static int voltage_to_battery_level(int battery_millivolts) { int level; + if (battery_millivolts < 0) + return -1; + #if CONFIG_CHARGING >= CHARGING_MONITOR if (charging_state()) { /* battery level is defined to be < 100% until charging is finished */ @@ -249,7 +282,8 @@ static int voltage_to_battery_level(int battery_millivolts) static void battery_status_update(void) { - int level = voltage_to_battery_level(battery_millivolts); + int millivolt, level; + battery_read_info(&millivolt, &level); #ifdef CURRENT_NORMAL /*don't try to estimate run or charge time without normal current defined*/ @@ -264,7 +298,8 @@ static void battery_status_update(void) #endif /* discharging: remaining running time */ - if (battery_millivolts > percent_to_volt_discharge[0][0]) { + if (level > 0 && (millivolt > percent_to_volt_discharge[battery_type][0] + || millivolt < 0)) { /* linear extrapolation */ powermgmt_est_runningtime_min = (level + battery_percent)*60 * battery_capacity / 200 / runcurrent(); @@ -272,8 +307,6 @@ static void battery_status_update(void) if (0 > powermgmt_est_runningtime_min) { powermgmt_est_runningtime_min = 0; } -#else - powermgmt_est_runningtime_min=-1; #endif battery_percent = level; @@ -348,6 +381,8 @@ bool query_force_shutdown(void) { #if defined(NO_LOW_BATTERY_SHUTDOWN) return false; +#elif CONFIG_BATTERY_MEASURE & PERCENTAGE_MEASURE + return battery_percent == 0; #elif defined(HAVE_BATTERY_SWITCH) /* Cannot rely upon the battery reading to be valid and the * device could be powered externally. */ @@ -490,6 +525,101 @@ static inline bool detect_charger(unsigned int pwr) } #endif /* CONFIG_CHARGING */ + +#if CONFIG_BATTERY_MEASURE & VOLTAGE_MEASURE +/* Returns filtered battery voltage [millivolts] */ +int battery_voltage(void) +{ + return battery_millivolts; +} + +static void average_init(void) +{ + /* initialize the voltages for the exponential filter */ + avgbat = _battery_voltage() + 15; + +#ifdef HAVE_DISK_STORAGE /* this adjustment is only needed for HD based */ + /* The battery voltage is usually a little lower directly after + turning on, because the disk was used heavily. Raise it by 5% */ +#if CONFIG_CHARGING + if (!charger_inserted()) /* only if charger not connected */ +#endif + { + avgbat += (percent_to_volt_discharge[battery_type][6] - + percent_to_volt_discharge[battery_type][5]) / 2; + } +#endif /* HAVE_DISK_STORAGE */ + + avgbat = avgbat * BATT_AVE_SAMPLES; + battery_millivolts = power_history[0] = avgbat / BATT_AVE_SAMPLES; +} + +static void average_step(void) +{ + avgbat += _battery_voltage() - avgbat / BATT_AVE_SAMPLES; + /* + * battery_millivolts is the millivolt-scaled filtered battery value. + */ + battery_millivolts = avgbat / BATT_AVE_SAMPLES; +} + +static void average_step_low(void) +{ + battery_millivolts = (_battery_voltage() + battery_millivolts + 1) / 2; + avgbat += battery_millivolts - avgbat / BATT_AVE_SAMPLES; +} + +static void init_battery_percent(void) +{ +#if CONFIG_CHARGING + if (charger_inserted()) { + battery_percent = voltage_to_percent(battery_millivolts, + percent_to_volt_charge); + } + else +#endif + { + battery_percent = voltage_to_percent(battery_millivolts, + percent_to_volt_discharge[battery_type]); + battery_percent += battery_percent < 100; + } + +} + +static int power_hist_item(void) +{ + return battery_millivolts; +} +#define power_history_unit() battery_millivolts + +#else +int battery_voltage(void) +{ + return -1; +} + +static void average_init(void) {} +static void average_step(void) {} +static void average_step_low(void) {} +static void init_battery_percent(void) +{ + battery_percent = _battery_level(); +} + +static int power_hist_item(void) +{ + return battery_percent; +} +#endif + +static void collect_power_history(void) +{ + /* rotate the power history */ + memmove(&power_history[1], &power_history[0], + sizeof(power_history) - sizeof(power_history[0])); + power_history[0] = power_hist_item(); +} + /* * Monitor the presence of a charger and perform critical frequent steps * such as running the battery voltage filter. @@ -519,33 +649,23 @@ static inline void power_thread_step(void) || charger_input_state == CHARGER #endif ) { - avgbat += battery_adc_voltage() - avgbat / BATT_AVE_SAMPLES; - /* - * battery_millivolts is the millivolt-scaled filtered battery value. - */ - battery_millivolts = avgbat / BATT_AVE_SAMPLES; - + average_step(); /* update battery status every time an update is available */ battery_status_update(); } else if (battery_percent < 8) { + average_step_low(); + /* update battery status every time an update is available */ + battery_status_update(); + /* * If battery is low, observe voltage during disk activity. * Shut down if voltage drops below shutoff level and we are not * using NiMH or Alkaline batteries. */ - battery_millivolts = (battery_adc_voltage() + - battery_millivolts + 1) / 2; - - /* update battery status every time an update is available */ - battery_status_update(); - if (!shutdown_timeout && query_force_shutdown()) { sys_poweroff(); } - else { - avgbat += battery_millivolts - avgbat / BATT_AVE_SAMPLES; - } } } /* power_thread_step */ @@ -555,7 +675,7 @@ static void power_thread(void) /* Delay reading the first battery level */ #ifdef MROBE_100 - while (battery_adc_voltage() > 4200) /* gives false readings initially */ + while (_battery_voltage() > 4200) /* gives false readings initially */ #endif { sleep(HZ/100); @@ -566,38 +686,13 @@ static void power_thread(void) power_thread_inputs = power_input_status(); #endif - /* initialize the voltages for the exponential filter */ - avgbat = battery_adc_voltage() + 15; - -#ifdef HAVE_DISK_STORAGE /* this adjustment is only needed for HD based */ - /* The battery voltage is usually a little lower directly after - turning on, because the disk was used heavily. Raise it by 5% */ -#if CONFIG_CHARGING - if (!charger_inserted()) /* only if charger not connected */ -#endif - { - avgbat += (percent_to_volt_discharge[battery_type][6] - - percent_to_volt_discharge[battery_type][5]) / 2; - } -#endif /* HAVE_DISK_STORAGE */ - - avgbat = avgbat * BATT_AVE_SAMPLES; - battery_millivolts = avgbat / BATT_AVE_SAMPLES; - power_history[0] = battery_millivolts; - -#if CONFIG_CHARGING - if (charger_inserted()) { - battery_percent = voltage_to_percent(battery_millivolts, - percent_to_volt_charge); - } - else -#endif - { - battery_percent = voltage_to_percent(battery_millivolts, - percent_to_volt_discharge[battery_type]); - battery_percent += battery_percent < 100; - } - + /* initialize voltage averaging (if available) */ + average_init(); + /* get initial battery level value (in %) */ + init_battery_percent(); + /* get some initial data for the power curve */ + collect_power_history(); + /* call target specific init now */ powermgmt_init_target(); next_power_hist = current_tick + HZ*60; @@ -609,7 +704,7 @@ static void power_thread(void) #ifdef HAVE_BATTERY_SWITCH if ((pwr ^ power_thread_inputs) & POWER_INPUT_BATTERY) { sleep(HZ/10); - reset_battery_filter(battery_adc_voltage()); + reset_battery_filter(_battery_voltage()); } #endif power_thread_inputs = pwr; @@ -627,21 +722,15 @@ static void power_thread(void) /* Perform target tasks */ charging_algorithm_step(); - if (TIME_BEFORE(current_tick, next_power_hist)) - continue; - - /* increment to ensure there is a record for every minute - * rather than go forward from the current tick */ - next_power_hist += HZ*60; - - /* rotate the power history */ - memmove(&power_history[1], &power_history[0], - sizeof(power_history) - sizeof(power_history[0])); - - /* insert new value at the start, in millivolts 8-) */ - power_history[0] = battery_millivolts; - + /* check if some idle or sleep timer wears off */ handle_auto_poweroff(); + + if (TIME_AFTER(current_tick, next_power_hist)) { + /* increment to ensure there is a record for every minute + * rather than go forward from the current tick */ + next_power_hist += HZ*60; + collect_power_history(); + } } } /* power_thread */ @@ -701,7 +790,6 @@ void shutdown_hw(void) sleep(HZ/4); power_off(); } -#endif /* PLATFORM_NATIVE */ void set_poweroff_timeout(int timeout) { @@ -855,12 +943,10 @@ void handle_auto_poweroff(void) last_event_tick = current_tick; } -#if (CONFIG_PLATFORM & PLATFORM_NATIVE) || defined(SAMSUNG_YPR0) if (!shutdown_timeout && query_force_shutdown()) { backlight_on(); sys_poweroff(); } -#endif if (timeout && #if CONFIG_TUNER |