// SPDX-License-Identifier: GPL-2.0-only /* * Copyright (C) ST-Ericsson AB 2012 * * Main and Back-up battery management driver. * * Note: Backup battery management is required in case of Li-Ion battery and not * for capacitive battery. HREF boards have capacitive battery and hence backup * battery management is not used and the supported code is available in this * driver. * * Author: * Johan Palsson <johan.palsson@stericsson.com> * Karl Komierowski <karl.komierowski@stericsson.com> * Arun R Murthy <arun.murthy@stericsson.com>
*/
struct ab8500_fg_avg_cap { int avg; int samples[NBR_AVG_SAMPLES];
time64_t time_stamps[NBR_AVG_SAMPLES]; int pos; int nbr_samples; int sum;
};
struct ab8500_fg_cap_scaling { bool enable; int cap_to_scale[2]; int disable_cap_level; int scaled_cap;
};
struct ab8500_fg_battery_capacity { int max_mah_design; int max_mah; int mah; int permille; int level; int prev_mah; int prev_percent; int prev_level; int user_mah; struct ab8500_fg_cap_scaling cap_scale;
};
/** * struct ab8500_fg - ab8500 FG device information * @dev: Pointer to the structure device * @node: a list of AB8500 FGs, hence prepared for reentrance * @irq holds the CCEOC interrupt number * @vbat_uv: Battery voltage in uV * @vbat_nom_uv: Nominal battery voltage in uV * @inst_curr_ua: Instantenous battery current in uA * @avg_curr_ua: Average battery current in uA * @bat_temp battery temperature * @fg_samples: Number of samples used in the FG accumulation * @accu_charge: Accumulated charge from the last conversion * @recovery_cnt: Counter for recovery mode * @high_curr_cnt: Counter for high current mode * @init_cnt: Counter for init mode * @low_bat_cnt Counter for number of consecutive low battery measures * @nbr_cceoc_irq_cnt Counter for number of CCEOC irqs received since enabled * @recovery_needed: Indicate if recovery is needed * @high_curr_mode: Indicate if we're in high current mode * @init_capacity: Indicate if initial capacity measuring should be done * @turn_off_fg: True if fg was off before current measurement * @calib_state State during offset calibration * @discharge_state: Current discharge state * @charge_state: Current charge state * @ab8500_fg_started Completion struct used for the instant current start * @ab8500_fg_complete Completion struct used for the instant current reading * @flags: Structure for information about events triggered * @bat_cap: Structure for battery capacity specific parameters * @avg_cap: Average capacity filter * @parent: Pointer to the struct ab8500 * @main_bat_v: ADC channel for the main battery voltage * @bm: Platform specific battery management information * @fg_psy: Structure that holds the FG specific battery properties * @fg_wq: Work queue for running the FG algorithm * @fg_periodic_work: Work to run the FG algorithm periodically * @fg_low_bat_work: Work to check low bat condition * @fg_reinit_work Work used to reset and reinitialise the FG algorithm * @fg_work: Work to run the FG algorithm instantly * @fg_acc_cur_work: Work to read the FG accumulator * @fg_check_hw_failure_work: Work for checking HW state * @cc_lock: Mutex for locking the CC * @fg_kobject: Structure of type kobject
*/ struct ab8500_fg { struct device *dev; struct list_head node; int irq; int vbat_uv; int vbat_nom_uv; int inst_curr_ua; int avg_curr_ua; int bat_temp; int fg_samples; int accu_charge; int recovery_cnt; int high_curr_cnt; int init_cnt; int low_bat_cnt; int nbr_cceoc_irq_cnt;
u32 line_impedance_uohm; bool recovery_needed; bool high_curr_mode; bool init_capacity; bool turn_off_fg; enum ab8500_fg_calibration_state calib_state; enum ab8500_fg_discharge_state discharge_state; enum ab8500_fg_charge_state charge_state; struct completion ab8500_fg_started; struct completion ab8500_fg_complete; struct ab8500_fg_flags flags; struct ab8500_fg_battery_capacity bat_cap; struct ab8500_fg_avg_cap avg_cap; struct ab8500 *parent; struct iio_channel *main_bat_v; struct ab8500_bm_data *bm; struct power_supply *fg_psy; struct workqueue_struct *fg_wq; struct delayed_work fg_periodic_work; struct delayed_work fg_low_bat_work; struct delayed_work fg_reinit_work; struct work_struct fg_work; struct work_struct fg_acc_cur_work; struct delayed_work fg_check_hw_failure_work; struct mutex cc_lock; struct kobject fg_kobject;
}; static LIST_HEAD(ab8500_fg_list);
/** * ab8500_fg_get() - returns a reference to the primary AB8500 fuel gauge * (i.e. the first fuel gauge in the instance list)
*/ struct ab8500_fg *ab8500_fg_get(void)
{ return list_first_entry_or_null(&ab8500_fg_list, struct ab8500_fg,
node);
}
/* * This array maps the raw hex value to lowbat voltage used by the AB8500 * Values taken from the UM0836, in microvolts.
*/ staticint ab8500_fg_lowbat_voltage_map[] = {
2300000,
2325000,
2350000,
2375000,
2400000,
2425000,
2450000,
2475000,
2500000,
2525000,
2550000,
2575000,
2600000,
2625000,
2650000,
2675000,
2700000,
2725000,
2750000,
2775000,
2800000,
2825000,
2850000,
2875000,
2900000,
2925000,
2950000,
2975000,
3000000,
3025000,
3050000,
3075000,
3100000,
3125000,
3150000,
3175000,
3200000,
3225000,
3250000,
3275000,
3300000,
3325000,
3350000,
3375000,
3400000,
3425000,
3450000,
3475000,
3500000,
3525000,
3550000,
3575000,
3600000,
3625000,
3650000,
3675000,
3700000,
3725000,
3750000,
3775000,
3800000,
3825000,
3850000,
3850000,
};
static u8 ab8500_volt_to_regval(int voltage_uv)
{ int i;
if (voltage_uv < ab8500_fg_lowbat_voltage_map[0]) return 0;
for (i = 0; i < ARRAY_SIZE(ab8500_fg_lowbat_voltage_map); i++) { if (voltage_uv < ab8500_fg_lowbat_voltage_map[i]) return (u8) i - 1;
}
/* If not captured above, return index of last element */ return (u8) ARRAY_SIZE(ab8500_fg_lowbat_voltage_map) - 1;
}
/** * ab8500_fg_is_low_curr() - Low or high current mode * @di: pointer to the ab8500_fg structure * @curr_ua: the current to base or our decision on in microampere * * Low current mode if the current consumption is below a certain threshold
*/ staticint ab8500_fg_is_low_curr(struct ab8500_fg *di, int curr_ua)
{ /* * We want to know if we're in low current mode
*/ if (curr_ua > -di->bm->fg_params->high_curr_threshold_ua) returntrue; else returnfalse;
}
/** * ab8500_fg_add_cap_sample() - Add capacity to average filter * @di: pointer to the ab8500_fg structure * @sample: the capacity in mAh to add to the filter * * A capacity is added to the filter and a new mean capacity is calculated and * returned
*/ staticint ab8500_fg_add_cap_sample(struct ab8500_fg *di, int sample)
{
time64_t now = ktime_get_boottime_seconds(); struct ab8500_fg_avg_cap *avg = &di->avg_cap;
if (avg->nbr_samples < NBR_AVG_SAMPLES)
avg->nbr_samples++;
/* * Check the time stamp for each sample. If too old, * replace with latest sample
*/
} while (now - VALID_CAPACITY_SEC > avg->time_stamps[avg->pos]);
avg->avg = avg->sum / avg->nbr_samples;
return avg->avg;
}
/** * ab8500_fg_clear_cap_samples() - Clear average filter * @di: pointer to the ab8500_fg structure * * The capacity filter is reset to zero.
*/ staticvoid ab8500_fg_clear_cap_samples(struct ab8500_fg *di)
{ int i; struct ab8500_fg_avg_cap *avg = &di->avg_cap;
for (i = 0; i < NBR_AVG_SAMPLES; i++) {
avg->samples[i] = 0;
avg->time_stamps[i] = 0;
}
}
/** * ab8500_fg_fill_cap_sample() - Fill average filter * @di: pointer to the ab8500_fg structure * @sample: the capacity in mAh to fill the filter with * * The capacity filter is filled with a capacity in mAh
*/ staticvoid ab8500_fg_fill_cap_sample(struct ab8500_fg *di, int sample)
{ int i;
time64_t now; struct ab8500_fg_avg_cap *avg = &di->avg_cap;
now = ktime_get_boottime_seconds();
for (i = 0; i < NBR_AVG_SAMPLES; i++) {
avg->samples[i] = sample;
avg->time_stamps[i] = now;
}
/** * ab8500_fg_coulomb_counter() - enable coulomb counter * @di: pointer to the ab8500_fg structure * @enable: enable/disable * * Enable/Disable coulomb counter. * On failure returns negative value.
*/ staticint ab8500_fg_coulomb_counter(struct ab8500_fg *di, bool enable)
{ int ret = 0;
mutex_lock(&di->cc_lock); if (enable) { /* To be able to reprogram the number of samples, we have to
* first stop the CC and then enable it again */
ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
AB8500_RTC_CC_CONF_REG, 0x00); if (ret) goto cc_err;
/* Program the samples */
ret = abx500_set_register_interruptible(di->dev,
AB8500_GAS_GAUGE, AB8500_GASG_CC_NCOV_ACCU,
di->fg_samples); if (ret) goto cc_err;
/* Start the CC */
ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
AB8500_RTC_CC_CONF_REG,
(CC_DEEP_SLEEP_ENA | CC_PWR_UP_ENA)); if (ret) goto cc_err;
di->flags.fg_enabled = true;
} else { /* Clear any pending read requests */
ret = abx500_mask_and_set_register_interruptible(di->dev,
AB8500_GAS_GAUGE, AB8500_GASG_CC_CTRL_REG,
(RESET_ACCU | READ_REQ), 0); if (ret) goto cc_err;
ret = abx500_set_register_interruptible(di->dev,
AB8500_GAS_GAUGE, AB8500_GASG_CC_NCOV_ACCU_CTRL, 0); if (ret) goto cc_err;
/* Stop the CC */
ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
AB8500_RTC_CC_CONF_REG, 0); if (ret) goto cc_err;
di->flags.fg_enabled = false;
}
dev_dbg(di->dev, " CC enabled: %d Samples: %d\n",
enable, di->fg_samples);
/** * ab8500_fg_inst_curr_start() - start battery instantaneous current * @di: pointer to the ab8500_fg structure * * Returns 0 or error code * Note: This is part "one" and has to be called before * ab8500_fg_inst_curr_finalize()
*/ int ab8500_fg_inst_curr_start(struct ab8500_fg *di)
{
u8 reg_val; int ret;
mutex_lock(&di->cc_lock);
di->nbr_cceoc_irq_cnt = 0;
ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
AB8500_RTC_CC_CONF_REG, ®_val); if (ret < 0) goto fail;
/* Program the samples */
ret = abx500_set_register_interruptible(di->dev,
AB8500_GAS_GAUGE, AB8500_GASG_CC_NCOV_ACCU,
SEC_TO_SAMPLE(10)); if (ret) goto fail;
/* Start the CC */
ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
AB8500_RTC_CC_CONF_REG,
(CC_DEEP_SLEEP_ENA | CC_PWR_UP_ENA)); if (ret) goto fail;
} else {
di->turn_off_fg = false;
}
/* Return and WFI */
reinit_completion(&di->ab8500_fg_started);
reinit_completion(&di->ab8500_fg_complete);
enable_irq(di->irq);
/* Note: cc_lock is still locked */ return 0;
fail:
mutex_unlock(&di->cc_lock); return ret;
}
/** * ab8500_fg_inst_curr_started() - check if fg conversion has started * @di: pointer to the ab8500_fg structure * * Returns 1 if conversion started, 0 if still waiting
*/ int ab8500_fg_inst_curr_started(struct ab8500_fg *di)
{ return completion_done(&di->ab8500_fg_started);
}
/** * ab8500_fg_inst_curr_done() - check if fg conversion is done * @di: pointer to the ab8500_fg structure * * Returns 1 if conversion done, 0 if still waiting
*/ int ab8500_fg_inst_curr_done(struct ab8500_fg *di)
{ return completion_done(&di->ab8500_fg_complete);
}
/** * ab8500_fg_inst_curr_finalize() - battery instantaneous current * @di: pointer to the ab8500_fg structure * @curr_ua: battery instantenous current in microampere (on success) * * Returns 0 or an error code * Note: This is part "two" and has to be called at earliest 250 ms * after ab8500_fg_inst_curr_start()
*/ int ab8500_fg_inst_curr_finalize(struct ab8500_fg *di, int *curr_ua)
{
u8 low, high; int val; int ret; unsignedlong timeout;
if (!completion_done(&di->ab8500_fg_complete)) {
timeout = wait_for_completion_timeout(
&di->ab8500_fg_complete,
INS_CURR_TIMEOUT);
dev_dbg(di->dev, "Finalize time: %d ms\n",
jiffies_to_msecs(INS_CURR_TIMEOUT - timeout)); if (!timeout) {
ret = -ETIME;
disable_irq(di->irq);
di->nbr_cceoc_irq_cnt = 0;
dev_err(di->dev, "completion timed out [%d]\n",
__LINE__); goto fail;
}
}
disable_irq(di->irq);
di->nbr_cceoc_irq_cnt = 0;
ret = abx500_mask_and_set_register_interruptible(di->dev,
AB8500_GAS_GAUGE, AB8500_GASG_CC_CTRL_REG,
READ_REQ, READ_REQ);
/* 100uS between read request and read is needed */
usleep_range(100, 100);
/* Read CC Sample conversion value Low and high */
ret = abx500_get_register_interruptible(di->dev, AB8500_GAS_GAUGE,
AB8500_GASG_CC_SMPL_CNVL_REG, &low); if (ret < 0) goto fail;
ret = abx500_get_register_interruptible(di->dev, AB8500_GAS_GAUGE,
AB8500_GASG_CC_SMPL_CNVH_REG, &high); if (ret < 0) goto fail;
/* * negative value for Discharging * convert 2's complement into decimal
*/ if (high & 0x10)
val = (low | (high << 8) | 0xFFFFE000); else
val = (low | (high << 8));
/* * Convert to unit value in mA * Full scale input voltage is * 63.160mV => LSB = 63.160mV/(4096*res) = 1.542.000 uA * Given a 250ms conversion cycle time the LSB corresponds * to 107.1 nAh. Convert to current by dividing by the conversion * time in hours (250ms = 1 / (3600 * 4)h) * 107.1nAh assumes 10mOhm, but fg_res is in 0.1mOhm
*/
val = (val * QLSB_NANO_AMP_HOURS_X10 * 36 * 4) / di->bm->fg_res;
if (di->turn_off_fg) {
dev_dbg(di->dev, "%s Disable FG\n", __func__);
/* Clear any pending read requests */
ret = abx500_set_register_interruptible(di->dev,
AB8500_GAS_GAUGE, AB8500_GASG_CC_CTRL_REG, 0); if (ret) goto fail;
/* Stop the CC */
ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
AB8500_RTC_CC_CONF_REG, 0); if (ret) goto fail;
}
mutex_unlock(&di->cc_lock);
*curr_ua = val;
/** * ab8500_fg_inst_curr_blocking() - battery instantaneous current * @di: pointer to the ab8500_fg structure * * Returns battery instantenous current in microampere (on success) * else error code
*/ int ab8500_fg_inst_curr_blocking(struct ab8500_fg *di)
{ int ret; unsignedlong timeout; int curr_ua = 0;
ret = ab8500_fg_inst_curr_start(di); if (ret) {
dev_err(di->dev, "Failed to initialize fg_inst\n"); return 0;
}
/* Wait for CC to actually start */ if (!completion_done(&di->ab8500_fg_started)) {
timeout = wait_for_completion_timeout(
&di->ab8500_fg_started,
INS_CURR_TIMEOUT);
dev_dbg(di->dev, "Start time: %d ms\n",
jiffies_to_msecs(INS_CURR_TIMEOUT - timeout)); if (!timeout) {
ret = -ETIME;
dev_err(di->dev, "completion timed out [%d]\n",
__LINE__); goto fail;
}
}
ret = ab8500_fg_inst_curr_finalize(di, &curr_ua); if (ret) {
dev_err(di->dev, "Failed to finalize fg_inst\n"); return 0;
}
/** * ab8500_fg_acc_cur_work() - average battery current * @work: pointer to the work_struct structure * * Updated the average battery current obtained from the * coulomb counter.
*/ staticvoid ab8500_fg_acc_cur_work(struct work_struct *work)
{ int val; int ret;
u8 low, med, high;
mutex_lock(&di->cc_lock);
ret = abx500_set_register_interruptible(di->dev, AB8500_GAS_GAUGE,
AB8500_GASG_CC_NCOV_ACCU_CTRL, RD_NCONV_ACCU_REQ); if (ret) gotoexit;
ret = abx500_get_register_interruptible(di->dev, AB8500_GAS_GAUGE,
AB8500_GASG_CC_NCOV_ACCU_LOW, &low); if (ret < 0) gotoexit;
ret = abx500_get_register_interruptible(di->dev, AB8500_GAS_GAUGE,
AB8500_GASG_CC_NCOV_ACCU_MED, &med); if (ret < 0) gotoexit;
ret = abx500_get_register_interruptible(di->dev, AB8500_GAS_GAUGE,
AB8500_GASG_CC_NCOV_ACCU_HIGH, &high); if (ret < 0) gotoexit;
/* Check for sign bit in case of negative value, 2's complement */ if (high & 0x10)
val = (low | (med << 8) | (high << 16) | 0xFFE00000); else
val = (low | (med << 8) | (high << 16));
/* * Convert to uAh * Given a 250ms conversion cycle time the LSB corresponds * to 112.9 nAh. * 112.9nAh assumes 10mOhm, but fg_res is in 0.1mOhm
*/
di->accu_charge = (val * QLSB_NANO_AMP_HOURS_X10) /
(100 * di->bm->fg_res);
/* * Convert to unit value in uA * by dividing by the conversion * time in hours (= samples / (3600 * 4)h)
*/
di->avg_curr_ua = (val * QLSB_NANO_AMP_HOURS_X10 * 36) /
(di->bm->fg_res * (di->fg_samples / 4));
di->flags.conv_done = true;
mutex_unlock(&di->cc_lock);
queue_work(di->fg_wq, &di->fg_work);
dev_dbg(di->dev, "fg_res: %d, fg_samples: %d, gasg: %d, accu_charge: %d \n",
di->bm->fg_res, di->fg_samples, val, di->accu_charge); return; exit:
dev_err(di->dev, "Failed to read or write gas gauge registers\n");
mutex_unlock(&di->cc_lock);
queue_work(di->fg_wq, &di->fg_work);
}
/** * ab8500_fg_bat_voltage() - get battery voltage * @di: pointer to the ab8500_fg structure * * Returns battery voltage in microvolts (on success) else error code
*/ staticint ab8500_fg_bat_voltage(struct ab8500_fg *di)
{ int vbat, ret; staticint prev;
ret = iio_read_channel_processed(di->main_bat_v, &vbat); if (ret < 0) {
dev_err(di->dev, "%s ADC conversion failed, using previous value\n",
__func__); return prev;
}
/* IIO returns millivolts but we want microvolts */
vbat *= 1000;
prev = vbat; return vbat;
}
/** * ab8500_fg_volt_to_capacity() - Voltage based capacity * @di: pointer to the ab8500_fg structure * @voltage_uv: The voltage to convert to a capacity in microvolt * * Returns battery capacity in per mille based on voltage
*/ staticint ab8500_fg_volt_to_capacity(struct ab8500_fg *di, int voltage_uv)
{ struct power_supply_battery_info *bi = di->bm->bi;
/* Multiply by 10 because the capacity is tracked in per mille */ return power_supply_batinfo_ocv2cap(bi, voltage_uv, di->bat_temp) * 10;
}
/** * ab8500_fg_uncomp_volt_to_capacity() - Uncompensated voltage based capacity * @di: pointer to the ab8500_fg structure * * Returns battery capacity based on battery voltage that is not compensated * for the voltage drop due to the load
*/ staticint ab8500_fg_uncomp_volt_to_capacity(struct ab8500_fg *di)
{
di->vbat_uv = ab8500_fg_bat_voltage(di); return ab8500_fg_volt_to_capacity(di, di->vbat_uv);
}
/** * ab8500_fg_battery_resistance() - Returns the battery inner resistance * @di: pointer to the ab8500_fg structure * @vbat_uncomp_uv: Uncompensated VBAT voltage * * Returns battery inner resistance added with the fuel gauge resistor value * to get the total resistance in the whole link from gnd to bat+ node * in milliohm.
*/ staticint ab8500_fg_battery_resistance(struct ab8500_fg *di, int vbat_uncomp_uv)
{ struct power_supply_battery_info *bi = di->bm->bi; int resistance_percent = 0; int resistance;
/* * Determine the resistance at this voltage. First try VBAT-to-Ri else * just infer it from the surrounding temperature, if nothing works just * use the internal resistance.
*/ if (power_supply_supports_vbat2ri(bi)) {
resistance = power_supply_vbat2ri(bi, vbat_uncomp_uv, di->flags.charging); /* Convert to milliohm */
resistance = resistance / 1000;
} elseif (power_supply_supports_temp2ri(bi)) {
resistance_percent = power_supply_temp2resist_simple(bi->resist_table,
bi->resist_table_size,
di->bat_temp / 10); /* Convert to milliohm */
resistance = bi->factory_internal_resistance_uohm / 1000;
resistance = resistance * resistance_percent / 100;
} else { /* Last fallback */
resistance = bi->factory_internal_resistance_uohm / 1000;
}
/* Compensate for line impedance */
resistance += (di->line_impedance_uohm / 1000);
/* fg_res variable is in 0.1mOhm */
resistance += di->bm->fg_res / 10;
return resistance;
}
/** * ab8500_load_comp_fg_bat_voltage() - get load compensated battery voltage * @di: pointer to the ab8500_fg structure * @always: always return a voltage, also uncompensated * * Returns compensated battery voltage (on success) else error code. * If always is specified, we always return a voltage but it may be * uncompensated.
*/ staticint ab8500_load_comp_fg_bat_voltage(struct ab8500_fg *di, bool always)
{ int i = 0; int vbat_uv = 0; int rcomp;
/* Average the instant current to get a stable current measurement */
ab8500_fg_inst_curr_start(di);
do {
vbat_uv += ab8500_fg_bat_voltage(di);
i++;
usleep_range(5000, 6000);
} while (!ab8500_fg_inst_curr_done(di) &&
i <= WAIT_FOR_INST_CURRENT_MAX);
if (i > WAIT_FOR_INST_CURRENT_MAX) {
dev_err(di->dev, "TIMEOUT: return uncompensated measurement of VBAT\n");
di->vbat_uv = vbat_uv / i; return di->vbat_uv;
}
/* * If there is too high current dissipation, the compensation cannot be * trusted so return an error unless we must return something here, as * enforced by the "always" parameter.
*/ if (!always && di->inst_curr_ua < IGNORE_VBAT_HIGHCUR) return -EINVAL;
vbat_uv = vbat_uv / i;
/* Next we apply voltage compensation from internal resistance */
rcomp = ab8500_fg_battery_resistance(di, vbat_uv);
vbat_uv = vbat_uv - (di->inst_curr_ua * rcomp) / 1000;
/* Always keep this state at latest measurement */
di->vbat_uv = vbat_uv;
return vbat_uv;
}
/** * ab8500_fg_load_comp_volt_to_capacity() - Load compensated voltage based capacity * @di: pointer to the ab8500_fg structure * * Returns battery capacity based on battery voltage that is load compensated * for the voltage drop
*/ staticint ab8500_fg_load_comp_volt_to_capacity(struct ab8500_fg *di)
{ int vbat_comp_uv;
/** * ab8500_fg_convert_mah_to_permille() - Capacity in mAh to permille * @di: pointer to the ab8500_fg structure * @cap_mah: capacity in mAh * * Converts capacity in mAh to capacity in permille
*/ staticint ab8500_fg_convert_mah_to_permille(struct ab8500_fg *di, int cap_mah)
{ return (cap_mah * 1000) / di->bat_cap.max_mah_design;
}
/** * ab8500_fg_convert_permille_to_mah() - Capacity in permille to mAh * @di: pointer to the ab8500_fg structure * @cap_pm: capacity in permille * * Converts capacity in permille to capacity in mAh
*/ staticint ab8500_fg_convert_permille_to_mah(struct ab8500_fg *di, int cap_pm)
{ return cap_pm * di->bat_cap.max_mah_design / 1000;
}
/** * ab8500_fg_convert_mah_to_uwh() - Capacity in mAh to uWh * @di: pointer to the ab8500_fg structure * @cap_mah: capacity in mAh * * Converts capacity in mAh to capacity in uWh
*/ staticint ab8500_fg_convert_mah_to_uwh(struct ab8500_fg *di, int cap_mah)
{
u64 div_res;
u32 div_rem;
/* * Capacity is in milli ampere hours (10^-3)Ah * Nominal voltage is in microvolts (10^-6)V * divide by 1000000 after multiplication to get to mWh
*/
div_res = ((u64) cap_mah) * ((u64) di->vbat_nom_uv);
div_rem = do_div(div_res, 1000000);
/* Make sure to round upwards if necessary */ if (div_rem >= 1000000 / 2)
div_res++;
return (int) div_res;
}
/** * ab8500_fg_calc_cap_charging() - Calculate remaining capacity while charging * @di: pointer to the ab8500_fg structure * * Return the capacity in mAh based on previous calculated capcity and the FG * accumulator register value. The filter is filled with this capacity
*/ staticint ab8500_fg_calc_cap_charging(struct ab8500_fg *di)
{
dev_dbg(di->dev, "%s cap_mah %d accu_charge %d\n",
__func__,
di->bat_cap.mah,
di->accu_charge);
/* Capacity should not be less than 0 */ if (di->bat_cap.mah + di->accu_charge > 0)
di->bat_cap.mah += di->accu_charge; else
di->bat_cap.mah = 0; /* * We force capacity to 100% once when the algorithm * reports that it's full.
*/ if (di->bat_cap.mah >= di->bat_cap.max_mah_design ||
di->flags.force_full) {
di->bat_cap.mah = di->bat_cap.max_mah_design;
}
/* We need to update battery voltage and inst current when charging */
di->vbat_uv = ab8500_fg_bat_voltage(di);
di->inst_curr_ua = ab8500_fg_inst_curr_blocking(di);
return di->bat_cap.mah;
}
/** * ab8500_fg_calc_cap_discharge_voltage() - Capacity in discharge with voltage * @di: pointer to the ab8500_fg structure * * Return the capacity in mAh based on the load compensated battery voltage. * This value is added to the filter and a new mean value is calculated and * returned.
*/ staticint ab8500_fg_calc_cap_discharge_voltage(struct ab8500_fg *di)
{ int permille, mah;
/** * ab8500_fg_calc_cap_discharge_fg() - Capacity in discharge with FG * @di: pointer to the ab8500_fg structure * * Return the capacity in mAh based on previous calculated capcity and the FG * accumulator register value. This value is added to the filter and a * new mean value is calculated and returned.
*/ staticint ab8500_fg_calc_cap_discharge_fg(struct ab8500_fg *di)
{ int permille_volt, permille;
/* Capacity should not be less than 0 */ if (di->bat_cap.mah + di->accu_charge > 0)
di->bat_cap.mah += di->accu_charge; else
di->bat_cap.mah = 0;
if (di->bat_cap.mah >= di->bat_cap.max_mah_design)
di->bat_cap.mah = di->bat_cap.max_mah_design;
/* * Check against voltage based capacity. It can not be lower * than what the uncompensated voltage says
*/
permille = ab8500_fg_convert_mah_to_permille(di, di->bat_cap.mah);
permille_volt = ab8500_fg_uncomp_volt_to_capacity(di);
/** * ab8500_fg_capacity_level() - Get the battery capacity level * @di: pointer to the ab8500_fg structure * * Get the battery capacity level based on the capacity in percent
*/ staticint ab8500_fg_capacity_level(struct ab8500_fg *di)
{ int ret, percent;
if (percent <= di->bm->cap_levels->critical ||
di->flags.low_bat)
ret = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL; elseif (percent <= di->bm->cap_levels->low)
ret = POWER_SUPPLY_CAPACITY_LEVEL_LOW; elseif (percent <= di->bm->cap_levels->normal)
ret = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL; elseif (percent <= di->bm->cap_levels->high)
ret = POWER_SUPPLY_CAPACITY_LEVEL_HIGH; else
ret = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
return ret;
}
/** * ab8500_fg_calculate_scaled_capacity() - Capacity scaling * @di: pointer to the ab8500_fg structure * * Calculates the capacity to be shown to upper layers. Scales the capacity * to have 100% as a reference from the actual capacity upon removal of charger * when charging is in maintenance mode.
*/ staticint ab8500_fg_calculate_scaled_capacity(struct ab8500_fg *di)
{ struct ab8500_fg_cap_scaling *cs = &di->bat_cap.cap_scale; int capacity = di->bat_cap.prev_percent;
if (!cs->enable) return capacity;
/* * As long as we are in fully charge mode scale the capacity * to show 100%.
*/ if (di->flags.fully_charged) {
cs->cap_to_scale[0] = 100;
cs->cap_to_scale[1] =
max(capacity, di->bm->fg_params->maint_thres);
dev_dbg(di->dev, "Scale cap with %d/%d\n",
cs->cap_to_scale[0], cs->cap_to_scale[1]);
}
if (di->flags.charging) { if (capacity < cs->disable_cap_level) {
cs->disable_cap_level = capacity;
dev_dbg(di->dev, "Cap to stop scale lowered %d%%\n",
cs->disable_cap_level);
} elseif (!di->flags.fully_charged) { if (di->bat_cap.prev_percent >=
cs->disable_cap_level) {
dev_dbg(di->dev, "Disabling scaled capacity\n");
cs->enable = false;
capacity = di->bat_cap.prev_percent;
} else {
dev_dbg(di->dev, "Waiting in cap to level %d%%\n",
cs->disable_cap_level);
capacity = cs->disable_cap_level;
}
}
}
return capacity;
}
/** * ab8500_fg_update_cap_scalers() - Capacity scaling * @di: pointer to the ab8500_fg structure * * To be called when state change from charge<->discharge to update * the capacity scalers.
*/ staticvoid ab8500_fg_update_cap_scalers(struct ab8500_fg *di)
{ struct ab8500_fg_cap_scaling *cs = &di->bat_cap.cap_scale;
if (!cs->enable) return; if (di->flags.charging) {
di->bat_cap.cap_scale.disable_cap_level =
di->bat_cap.cap_scale.scaled_cap;
dev_dbg(di->dev, "Cap to stop scale at charge %d%%\n",
di->bat_cap.cap_scale.disable_cap_level);
} else { if (cs->scaled_cap != 100) {
cs->cap_to_scale[0] = cs->scaled_cap;
cs->cap_to_scale[1] = di->bat_cap.prev_percent;
} else {
cs->cap_to_scale[0] = 100;
cs->cap_to_scale[1] =
max(di->bat_cap.prev_percent,
di->bm->fg_params->maint_thres);
}
dev_dbg(di->dev, "Cap to scale at discharge %d/%d\n",
cs->cap_to_scale[0], cs->cap_to_scale[1]);
}
}
/** * ab8500_fg_check_capacity_limits() - Check if capacity has changed * @di: pointer to the ab8500_fg structure * @init: capacity is allowed to go up in init mode * * Check if capacity or capacity limit has changed and notify the system * about it using the power_supply framework
*/ staticvoid ab8500_fg_check_capacity_limits(struct ab8500_fg *di, bool init)
{ bool changed = false; int percent = DIV_ROUND_CLOSEST(di->bat_cap.permille, 10);
di->bat_cap.level = ab8500_fg_capacity_level(di);
if (di->bat_cap.level != di->bat_cap.prev_level) { /* * We do not allow reported capacity level to go up * unless we're charging or if we're in init
*/ if (!(!di->flags.charging && di->bat_cap.level >
di->bat_cap.prev_level) || init) {
dev_dbg(di->dev, "level changed from %d to %d\n",
di->bat_cap.prev_level,
di->bat_cap.level);
di->bat_cap.prev_level = di->bat_cap.level;
changed = true;
} else {
dev_dbg(di->dev, "level not allowed to go up " "since no charger is connected: %d to %d\n",
di->bat_cap.prev_level,
di->bat_cap.level);
}
}
/* * If we have received the LOW_BAT IRQ, set capacity to 0 to initiate * shutdown
*/ if (di->flags.low_bat) {
dev_dbg(di->dev, "Battery low, set capacity to 0\n");
di->bat_cap.prev_percent = 0;
di->bat_cap.permille = 0;
percent = 0;
di->bat_cap.prev_mah = 0;
di->bat_cap.mah = 0;
changed = true;
} elseif (di->flags.fully_charged) { /* * We report 100% if algorithm reported fully charged * and show 100% during maintenance charging (scaling).
*/ if (di->flags.force_full) {
di->bat_cap.prev_percent = percent;
di->bat_cap.prev_mah = di->bat_cap.mah;
changed = true;
}
} elseif (di->bat_cap.prev_percent != percent) { if (percent == 0) { /* * We will not report 0% unless we've got * the LOW_BAT IRQ, no matter what the FG * algorithm says.
*/
di->bat_cap.prev_percent = 1;
percent = 1;
changed = true;
} elseif (!(!di->flags.charging &&
percent > di->bat_cap.prev_percent) || init) { /* * We do not allow reported capacity to go up * unless we're charging or if we're in init
*/
dev_dbg(di->dev, "capacity changed from %d to %d (%d)\n",
di->bat_cap.prev_percent,
percent,
di->bat_cap.permille);
di->bat_cap.prev_percent = percent;
di->bat_cap.prev_mah = di->bat_cap.mah;
changed = true;
} else {
dev_dbg(di->dev, "capacity not allowed to go up since " "no charger is connected: %d to %d (%d)\n",
di->bat_cap.prev_percent,
percent,
di->bat_cap.permille);
}
}
if (changed) { if (di->bm->capacity_scaling) {
di->bat_cap.cap_scale.scaled_cap =
ab8500_fg_calculate_scaled_capacity(di);
staticvoid ab8500_fg_charge_state_to(struct ab8500_fg *di, enum ab8500_fg_charge_state new_state)
{
dev_dbg(di->dev, "Charge state from %d [%s] to %d [%s]\n",
di->charge_state,
charge_state[di->charge_state],
new_state,
charge_state[new_state]);
di->charge_state = new_state;
}
staticvoid ab8500_fg_discharge_state_to(struct ab8500_fg *di, enum ab8500_fg_discharge_state new_state)
{
dev_dbg(di->dev, "Discharge state from %d [%s] to %d [%s]\n",
di->discharge_state,
discharge_state[di->discharge_state],
new_state,
discharge_state[new_state]);
di->discharge_state = new_state;
}
/** * ab8500_fg_algorithm_charging() - FG algorithm for when charging * @di: pointer to the ab8500_fg structure * * Battery capacity calculation state machine for when we're charging
*/ staticvoid ab8500_fg_algorithm_charging(struct ab8500_fg *di)
{ /* * If we change to discharge mode * we should start with recovery
*/ if (di->discharge_state != AB8500_FG_DISCHARGE_INIT_RECOVERY)
ab8500_fg_discharge_state_to(di,
AB8500_FG_DISCHARGE_INIT_RECOVERY);
switch (di->charge_state) { case AB8500_FG_CHARGE_INIT:
di->fg_samples = SEC_TO_SAMPLE(
di->bm->fg_params->accu_charging);
case AB8500_FG_CHARGE_READOUT: /* * Read the FG and calculate the new capacity
*/
mutex_lock(&di->cc_lock); if (!di->flags.conv_done && !di->flags.force_full) { /* Wasn't the CC IRQ that got us here */
mutex_unlock(&di->cc_lock);
dev_dbg(di->dev, "%s CC conv not done\n",
__func__);
/* If within limits, use the saved capacity and exit estimation...*/ if (cap_permille > lower && cap_permille < upper) {
dev_dbg(di->dev, "OK! Using users cap %d uAh now\n", cap);
force_capacity(di); returntrue;
}
dev_dbg(di->dev, "Capacity from user out of limits, ignoring"); returnfalse;
}
/** * ab8500_fg_algorithm_discharging() - FG algorithm for when discharging * @di: pointer to the ab8500_fg structure * * Battery capacity calculation state machine for when we're discharging
*/ staticvoid ab8500_fg_algorithm_discharging(struct ab8500_fg *di)
{ int sleep_time;
/* If we change to charge mode we should start with init */ if (di->charge_state != AB8500_FG_CHARGE_INIT)
ab8500_fg_charge_state_to(di, AB8500_FG_CHARGE_INIT);
switch (di->discharge_state) { case AB8500_FG_DISCHARGE_INIT: /* We use the FG IRQ to work on */
di->init_cnt = 0;
di->fg_samples = SEC_TO_SAMPLE(di->bm->fg_params->init_timer);
ab8500_fg_coulomb_counter(di, true);
ab8500_fg_discharge_state_to(di,
AB8500_FG_DISCHARGE_INITMEASURING);
fallthrough; case AB8500_FG_DISCHARGE_INITMEASURING: /* * Discard a number of samples during startup. * After that, use compensated voltage for a few * samples to get an initial capacity. * Then go to READOUT
*/
sleep_time = di->bm->fg_params->init_timer;
/* Discard the first [x] seconds */ if (di->init_cnt > di->bm->fg_params->init_discard_time) {
ab8500_fg_calc_cap_discharge_voltage(di);
ab8500_fg_check_capacity_limits(di, true);
}
di->init_cnt += sleep_time; if (di->init_cnt > di->bm->fg_params->init_total_time)
ab8500_fg_discharge_state_to(di,
AB8500_FG_DISCHARGE_READOUT_INIT);
break;
case AB8500_FG_DISCHARGE_INIT_RECOVERY:
di->recovery_cnt = 0;
di->recovery_needed = true;
ab8500_fg_discharge_state_to(di,
AB8500_FG_DISCHARGE_RECOVERY);
fallthrough;
case AB8500_FG_DISCHARGE_RECOVERY:
sleep_time = di->bm->fg_params->recovery_sleep_timer;
/* * We should check the power consumption * If low, go to READOUT (after x min) or * RECOVERY_SLEEP if time left. * If high, go to READOUT
*/
di->inst_curr_ua = ab8500_fg_inst_curr_blocking(di);
ab8500_fg_calc_cap_discharge_voltage(di);
} else {
mutex_lock(&di->cc_lock); if (!di->flags.conv_done) { /* Wasn't the CC IRQ that got us here */
mutex_unlock(&di->cc_lock);
dev_dbg(di->dev, "%s CC conv not done\n",
__func__);
/** * ab8500_fg_algorithm_calibrate() - Internal columb counter offset calibration * @di: pointer to the ab8500_fg structure *
*/ staticvoid ab8500_fg_algorithm_calibrate(struct ab8500_fg *di)
{ int ret;
switch (di->calib_state) { case AB8500_FG_CALIB_INIT:
dev_dbg(di->dev, "Calibration ongoing...\n");
ret = abx500_mask_and_set_register_interruptible(di->dev,
AB8500_GAS_GAUGE, AB8500_GASG_CC_CTRL_REG,
CC_INT_CAL_N_AVG_MASK, CC_INT_CAL_SAMPLES_8); if (ret < 0) goto err;
ret = abx500_mask_and_set_register_interruptible(di->dev,
AB8500_GAS_GAUGE, AB8500_GASG_CC_CTRL_REG,
CC_INTAVGOFFSET_ENA, CC_INTAVGOFFSET_ENA); if (ret < 0) goto err;
di->calib_state = AB8500_FG_CALIB_WAIT; break; case AB8500_FG_CALIB_END:
ret = abx500_mask_and_set_register_interruptible(di->dev,
AB8500_GAS_GAUGE, AB8500_GASG_CC_CTRL_REG,
CC_MUXOFFSET, CC_MUXOFFSET); if (ret < 0) goto err;
di->flags.calibrate = false;
dev_dbg(di->dev, "Calibration done...\n");
queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0); break; case AB8500_FG_CALIB_WAIT:
dev_dbg(di->dev, "Calibration WFI\n"); break; default: break;
} return;
err: /* Something went wrong, don't calibrate then */
dev_err(di->dev, "failed to calibrate the CC\n");
di->flags.calibrate = false;
di->calib_state = AB8500_FG_CALIB_INIT;
queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
}
/** * ab8500_fg_algorithm() - Entry point for the FG algorithm * @di: pointer to the ab8500_fg structure * * Entry point for the battery capacity calculation state machine
*/ staticvoid ab8500_fg_algorithm(struct ab8500_fg *di)
{ if (di->flags.calibrate)
ab8500_fg_algorithm_calibrate(di); else { if (di->flags.charging)
ab8500_fg_algorithm_charging(di); else
ab8500_fg_algorithm_discharging(di);
}
/** * ab8500_fg_periodic_work() - Run the FG state machine periodically * @work: pointer to the work_struct structure * * Work queue function for periodic work
*/ staticvoid ab8500_fg_periodic_work(struct work_struct *work)
{ struct ab8500_fg *di = container_of(work, struct ab8500_fg,
fg_periodic_work.work);
if (di->init_capacity) { /* Get an initial capacity calculation */
ab8500_fg_calc_cap_discharge_voltage(di);
ab8500_fg_check_capacity_limits(di, true);
di->init_capacity = false;
/** * ab8500_fg_check_hw_failure_work() - Check OVV_BAT condition * @work: pointer to the work_struct structure * * Work queue function for checking the OVV_BAT condition
*/ staticvoid ab8500_fg_check_hw_failure_work(struct work_struct *work)
{ int ret;
u8 reg_value;
/* * If we have had a battery over-voltage situation, * check ovv-bit to see if it should be reset.
*/
ret = abx500_get_register_interruptible(di->dev,
AB8500_CHARGER, AB8500_CH_STAT_REG,
®_value); if (ret < 0) {
dev_err(di->dev, "%s ab8500 read failed\n", __func__); return;
} if ((reg_value & BATT_OVV) == BATT_OVV) { if (!di->flags.bat_ovv) {
dev_dbg(di->dev, "Battery OVV\n");
di->flags.bat_ovv = true;
power_supply_changed(di->fg_psy);
} /* Not yet recovered from ovv, reschedule this test */
queue_delayed_work(di->fg_wq, &di->fg_check_hw_failure_work,
HZ);
} else {
dev_dbg(di->dev, "Battery recovered from OVV\n");
di->flags.bat_ovv = false;
power_supply_changed(di->fg_psy);
}
}
/** * ab8500_fg_low_bat_work() - Check LOW_BAT condition * @work: pointer to the work_struct structure * * Work queue function for checking the LOW_BAT condition
*/ staticvoid ab8500_fg_low_bat_work(struct work_struct *work)
{ int vbat_uv;
/* Check if LOW_BAT still fulfilled */ if (vbat_uv < di->bm->fg_params->lowbat_threshold_uv) { /* Is it time to shut down? */ if (di->low_bat_cnt < 1) {
di->flags.low_bat = true;
dev_warn(di->dev, "Shut down pending...\n");
} else { /* * Else we need to re-schedule this check to be able to detect * if the voltage increases again during charging or * due to decreasing load.
*/
di->low_bat_cnt--;
dev_warn(di->dev, "Battery voltage still LOW\n");
queue_delayed_work(di->fg_wq, &di->fg_low_bat_work,
round_jiffies(LOW_BAT_CHECK_INTERVAL));
}
} else {
di->flags.low_bat_delay = false;
di->low_bat_cnt = 10;
dev_warn(di->dev, "Battery voltage OK again\n");
}
/* This is needed to dispatch LOW_BAT */
ab8500_fg_check_capacity_limits(di, false);
}
/** * ab8500_fg_battok_calc - calculate the bit pattern corresponding * to the target voltage. * @di: pointer to the ab8500_fg structure * @target: target voltage * * Returns bit pattern closest to the target voltage * valid return values are 0-14. (0-BATT_OK_MAX_NR_INCREMENTS)
*/
staticint ab8500_fg_battok_calc(struct ab8500_fg *di, int target)
{ if (target > BATT_OK_MIN +
(BATT_OK_INCREMENT * BATT_OK_MAX_NR_INCREMENTS)) return BATT_OK_MAX_NR_INCREMENTS; if (target < BATT_OK_MIN) return 0; return (target - BATT_OK_MIN) / BATT_OK_INCREMENT;
}
/** * ab8500_fg_battok_init_hw_register - init battok levels * @di: pointer to the ab8500_fg structure *
*/
staticint ab8500_fg_battok_init_hw_register(struct ab8500_fg *di)
{ int selected; int sel0; int sel1; int cbp_sel0; int cbp_sel1; int ret; int new_val;
/** * ab8500_fg_instant_work() - Run the FG state machine instantly * @work: pointer to the work_struct structure * * Work queue function for instant work
*/ staticvoid ab8500_fg_instant_work(struct work_struct *work)
{ struct ab8500_fg *di = container_of(work, struct ab8500_fg, fg_work);
ab8500_fg_algorithm(di);
}
/** * ab8500_fg_cc_data_end_handler() - end of data conversion isr. * @irq: interrupt number * @_di: pointer to the ab8500_fg structure * * Returns IRQ status(IRQ_HANDLED)
*/ static irqreturn_t ab8500_fg_cc_data_end_handler(int irq, void *_di)
{ struct ab8500_fg *di = _di; if (!di->nbr_cceoc_irq_cnt) {
di->nbr_cceoc_irq_cnt++;
complete(&di->ab8500_fg_started);
} else {
di->nbr_cceoc_irq_cnt = 0;
complete(&di->ab8500_fg_complete);
} return IRQ_HANDLED;
}
/** * ab8500_fg_cc_int_calib_handler () - end of calibration isr. * @irq: interrupt number * @_di: pointer to the ab8500_fg structure * * Returns IRQ status(IRQ_HANDLED)
*/ static irqreturn_t ab8500_fg_cc_int_calib_handler(int irq, void *_di)
{ struct ab8500_fg *di = _di;
di->calib_state = AB8500_FG_CALIB_END;
queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0); return IRQ_HANDLED;
}
/** * ab8500_fg_cc_convend_handler() - isr to get battery avg current. * @irq: interrupt number * @_di: pointer to the ab8500_fg structure * * Returns IRQ status(IRQ_HANDLED)
*/ static irqreturn_t ab8500_fg_cc_convend_handler(int irq, void *_di)
{ struct ab8500_fg *di = _di;
/* Schedule a new HW failure check */
queue_delayed_work(di->fg_wq, &di->fg_check_hw_failure_work, 0);
return IRQ_HANDLED;
}
/** * ab8500_fg_lowbatf_handler() - Battery voltage is below LOW threshold * @irq: interrupt number * @_di: pointer to the ab8500_fg structure * * Returns IRQ status(IRQ_HANDLED)
*/ static irqreturn_t ab8500_fg_lowbatf_handler(int irq, void *_di)
{ struct ab8500_fg *di = _di;
/* Initiate handling in ab8500_fg_low_bat_work() if not already initiated. */ if (!di->flags.low_bat_delay) {
dev_warn(di->dev, "Battery voltage is below LOW threshold\n");
di->flags.low_bat_delay = true; /* * Start a timer to check LOW_BAT again after some time * This is done to avoid shutdown on single voltage dips
*/
queue_delayed_work(di->fg_wq, &di->fg_low_bat_work,
round_jiffies(LOW_BAT_CHECK_INTERVAL));
} return IRQ_HANDLED;
}
/** * ab8500_fg_get_property() - get the fg properties * @psy: pointer to the power_supply structure * @psp: pointer to the power_supply_property structure * @val: pointer to the power_supply_propval union * * This function gets called when an application tries to get the * fg properties by reading the sysfs files. * voltage_now: battery voltage * current_now: battery instant current * current_avg: battery average current * charge_full_design: capacity where battery is considered full * charge_now: battery capacity in nAh * capacity: capacity in percent * capacity_level: capacity level * * Returns error code in case of failure else 0 on success
*/ staticint ab8500_fg_get_property(struct power_supply *psy, enum power_supply_property psp, union power_supply_propval *val)
{ struct ab8500_fg *di = power_supply_get_drvdata(psy);
/* * If battery is identified as unknown and charging of unknown * batteries is disabled, we always report 100% capacity and * capacity level UNKNOWN, since we can't calculate * remaining capacity
*/
switch (psp) { case POWER_SUPPLY_PROP_VOLTAGE_NOW: if (di->flags.bat_ovv)
val->intval = BATT_OVV_VALUE; else
val->intval = di->vbat_uv; break; case POWER_SUPPLY_PROP_CURRENT_NOW:
val->intval = di->inst_curr_ua; break; case POWER_SUPPLY_PROP_CURRENT_AVG:
val->intval = di->avg_curr_ua; break; case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
val->intval = ab8500_fg_convert_mah_to_uwh(di,
di->bat_cap.max_mah_design); break; case POWER_SUPPLY_PROP_ENERGY_FULL:
val->intval = ab8500_fg_convert_mah_to_uwh(di,
di->bat_cap.max_mah); break; case POWER_SUPPLY_PROP_ENERGY_NOW: if (di->flags.batt_unknown && !di->bm->chg_unknown_bat &&
di->flags.batt_id_received)
val->intval = ab8500_fg_convert_mah_to_uwh(di,
di->bat_cap.max_mah); else
val->intval = ab8500_fg_convert_mah_to_uwh(di,
di->bat_cap.prev_mah); break; case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
val->intval = di->bat_cap.max_mah_design; break; case POWER_SUPPLY_PROP_CHARGE_FULL:
val->intval = di->bat_cap.max_mah; break; case POWER_SUPPLY_PROP_CHARGE_NOW: if (di->flags.batt_unknown && !di->bm->chg_unknown_bat &&
di->flags.batt_id_received)
val->intval = di->bat_cap.max_mah; else
val->intval = di->bat_cap.prev_mah; break; case POWER_SUPPLY_PROP_CAPACITY: if (di->flags.batt_unknown && !di->bm->chg_unknown_bat &&
di->flags.batt_id_received)
val->intval = 100; else
val->intval = di->bat_cap.prev_percent; break; case POWER_SUPPLY_PROP_CAPACITY_LEVEL: if (di->flags.batt_unknown && !di->bm->chg_unknown_bat &&
di->flags.batt_id_received)
val->intval = POWER_SUPPLY_CAPACITY_LEVEL_UNKNOWN; else
val->intval = di->bat_cap.prev_level; break; default: return -EINVAL;
} return 0;
}
psy = (struct power_supply *)data;
di = power_supply_get_drvdata(psy);
bi = di->bm->bi;
/* * For all psy where the name of your driver * appears in any supplied_to
*/
j = match_string(supplicants, ext->num_supplicants, psy->desc->name); if (j < 0) return 0;
/* Go through all properties for the psy */ for (j = 0; j < ext->desc->num_properties; j++) { enum power_supply_property prop;
prop = ext->desc->properties[j];
if (power_supply_get_property(ext, prop, &ret)) continue;
switch (prop) { case POWER_SUPPLY_PROP_STATUS: switch (ext->desc->type) { case POWER_SUPPLY_TYPE_BATTERY: switch (ret.intval) { case POWER_SUPPLY_STATUS_UNKNOWN: case POWER_SUPPLY_STATUS_DISCHARGING: case POWER_SUPPLY_STATUS_NOT_CHARGING: if (!di->flags.charging) break;
di->flags.charging = false;
di->flags.fully_charged = false; if (di->bm->capacity_scaling)
ab8500_fg_update_cap_scalers(di);
queue_work(di->fg_wq, &di->fg_work); break; case POWER_SUPPLY_STATUS_FULL: if (di->flags.fully_charged) break;
di->flags.fully_charged = true;
di->flags.force_full = true; /* Save current capacity as maximum */
di->bat_cap.max_mah = di->bat_cap.mah;
queue_work(di->fg_wq, &di->fg_work); break; case POWER_SUPPLY_STATUS_CHARGING: if (di->flags.charging &&
!di->flags.fully_charged) break;
di->flags.charging = true;
di->flags.fully_charged = false; if (di->bm->capacity_scaling)
ab8500_fg_update_cap_scalers(di);
queue_work(di->fg_wq, &di->fg_work); break;
} break; default: break;
} break; case POWER_SUPPLY_PROP_TECHNOLOGY: switch (ext->desc->type) { case POWER_SUPPLY_TYPE_BATTERY: if (!di->flags.batt_id_received &&
(bi && (bi->technology !=
POWER_SUPPLY_TECHNOLOGY_UNKNOWN))) {
di->flags.batt_id_received = true;
if (ret.intval)
di->flags.batt_unknown = false; else
di->flags.batt_unknown = true; break; default: break;
} break; case POWER_SUPPLY_PROP_TEMP: switch (ext->desc->type) { case POWER_SUPPLY_TYPE_BATTERY: if (di->flags.batt_id_received)
di->bat_temp = ret.intval; break; default: break;
} break; default: break;
}
} return 0;
}
/** * ab8500_fg_init_hw_registers() - Set up FG related registers * @di: pointer to the ab8500_fg structure * * Set up battery OVV, low battery voltage registers
*/ staticint ab8500_fg_init_hw_registers(struct ab8500_fg *di)
{ int ret;
/* * Set VBAT OVV (overvoltage) threshold to 4.75V (typ) this is what * the hardware supports, nothing else can be configured in hardware. * See this as an "outer limit" where the charger will certainly * shut down. Other (lower) overvoltage levels need to be implemented * in software.
*/
ret = abx500_mask_and_set_register_interruptible(di->dev,
AB8500_CHARGER,
AB8500_BATT_OVV,
BATT_OVV_TH_4P75,
BATT_OVV_TH_4P75); if (ret) {
dev_err(di->dev, "failed to set BATT_OVV\n"); goto out;
}
/* Enable VBAT OVV detection */
ret = abx500_mask_and_set_register_interruptible(di->dev,
AB8500_CHARGER,
AB8500_BATT_OVV,
BATT_OVV_ENA,
BATT_OVV_ENA); if (ret) {
dev_err(di->dev, "failed to enable BATT_OVV\n"); goto out;
}
/* Low Battery Voltage */
ret = abx500_set_register_interruptible(di->dev,
AB8500_SYS_CTRL2_BLOCK,
AB8500_LOW_BAT_REG,
ab8500_volt_to_regval(
di->bm->fg_params->lowbat_threshold_uv) << 1 |
LOW_BAT_ENABLE); if (ret) {
dev_err(di->dev, "%s write failed\n", __func__); goto out;
}
/* Battery OK threshold */
ret = ab8500_fg_battok_init_hw_register(di); if (ret) {
dev_err(di->dev, "BattOk init write failed.\n"); goto out;
}
if (is_ab8505(di->parent)) {
ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
AB8505_RTC_PCUT_MAX_TIME_REG, di->bm->fg_params->pcut_max_time);
/** * ab8500_fg_external_power_changed() - callback for power supply changes * @psy: pointer to the structure power_supply * * This function is the entry point of the pointer external_power_changed * of the structure power_supply. * This function gets executed when there is a change in any external power * supply that this driver needs to be notified of.
*/ staticvoid ab8500_fg_external_power_changed(struct power_supply *psy)
{
power_supply_for_each_psy(psy, ab8500_fg_get_ext_psy_data);
}
/** * ab8500_fg_reinit_work() - work to reset the FG algorithm * @work: pointer to the work_struct structure * * Used to reset the current battery capacity to be able to * retrigger a new voltage base capacity calculation. For * test and verification purpose.
*/ staticvoid ab8500_fg_reinit_work(struct work_struct *work)
{ struct ab8500_fg *di = container_of(work, struct ab8500_fg,
fg_reinit_work.work);
if (!di->flags.calibrate) {
dev_dbg(di->dev, "Resetting FG state machine to init.\n");
ab8500_fg_clear_cap_samples(di);
ab8500_fg_calc_cap_discharge_voltage(di);
ab8500_fg_charge_state_to(di, AB8500_FG_CHARGE_INIT);
ab8500_fg_discharge_state_to(di, AB8500_FG_DISCHARGE_INIT);
queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
} else {
dev_err(di->dev, "Residual offset calibration ongoing " "retrying..\n"); /* Wait one second until next try*/
queue_delayed_work(di->fg_wq, &di->fg_reinit_work,
round_jiffies(1));
}
}
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.
