Lines Matching refs:di
359 * @di: pointer to the ab8500_fg structure
364 static int ab8500_fg_is_low_curr(struct ab8500_fg *di, int curr_ua)
369 if (curr_ua > -di->bm->fg_params->high_curr_threshold_ua)
377 * @di: pointer to the ab8500_fg structure
383 static int ab8500_fg_add_cap_sample(struct ab8500_fg *di, int sample)
386 struct ab8500_fg_avg_cap *avg = &di->avg_cap;
413 * @di: pointer to the ab8500_fg structure
417 static void ab8500_fg_clear_cap_samples(struct ab8500_fg *di)
420 struct ab8500_fg_avg_cap *avg = &di->avg_cap;
435 * @di: pointer to the ab8500_fg structure
440 static void ab8500_fg_fill_cap_sample(struct ab8500_fg *di, int sample)
444 struct ab8500_fg_avg_cap *avg = &di->avg_cap;
461 * @di: pointer to the ab8500_fg structure
467 static int ab8500_fg_coulomb_counter(struct ab8500_fg *di, bool enable)
470 mutex_lock(&di->cc_lock);
474 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
480 ret = abx500_set_register_interruptible(di->dev,
482 di->fg_samples);
487 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
493 di->flags.fg_enabled = true;
496 ret = abx500_mask_and_set_register_interruptible(di->dev,
502 ret = abx500_set_register_interruptible(di->dev,
508 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
513 di->flags.fg_enabled = false;
516 dev_dbg(di->dev, " CC enabled: %d Samples: %d\n",
517 enable, di->fg_samples);
519 mutex_unlock(&di->cc_lock);
523 dev_err(di->dev, "%s Enabling coulomb counter failed\n", __func__);
524 mutex_unlock(&di->cc_lock);
530 * @di: pointer to the ab8500_fg structure
536 int ab8500_fg_inst_curr_start(struct ab8500_fg *di)
541 mutex_lock(&di->cc_lock);
543 di->nbr_cceoc_irq_cnt = 0;
544 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
550 dev_dbg(di->dev, "%s Enable FG\n", __func__);
551 di->turn_off_fg = true;
554 ret = abx500_set_register_interruptible(di->dev,
561 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
567 di->turn_off_fg = false;
571 reinit_completion(&di->ab8500_fg_started);
572 reinit_completion(&di->ab8500_fg_complete);
573 enable_irq(di->irq);
578 mutex_unlock(&di->cc_lock);
584 * @di: pointer to the ab8500_fg structure
588 int ab8500_fg_inst_curr_started(struct ab8500_fg *di)
590 return completion_done(&di->ab8500_fg_started);
595 * @di: pointer to the ab8500_fg structure
599 int ab8500_fg_inst_curr_done(struct ab8500_fg *di)
601 return completion_done(&di->ab8500_fg_complete);
606 * @di: pointer to the ab8500_fg structure
613 int ab8500_fg_inst_curr_finalize(struct ab8500_fg *di, int *curr_ua)
620 if (!completion_done(&di->ab8500_fg_complete)) {
622 &di->ab8500_fg_complete,
624 dev_dbg(di->dev, "Finalize time: %d ms\n",
628 disable_irq(di->irq);
629 di->nbr_cceoc_irq_cnt = 0;
630 dev_err(di->dev, "completion timed out [%d]\n",
636 disable_irq(di->irq);
637 di->nbr_cceoc_irq_cnt = 0;
639 ret = abx500_mask_and_set_register_interruptible(di->dev,
647 ret = abx500_get_register_interruptible(di->dev, AB8500_GAS_GAUGE,
652 ret = abx500_get_register_interruptible(di->dev, AB8500_GAS_GAUGE,
675 val = (val * QLSB_NANO_AMP_HOURS_X10 * 36 * 4) / di->bm->fg_res;
677 if (di->turn_off_fg) {
678 dev_dbg(di->dev, "%s Disable FG\n", __func__);
681 ret = abx500_set_register_interruptible(di->dev,
687 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
692 mutex_unlock(&di->cc_lock);
697 mutex_unlock(&di->cc_lock);
703 * @di: pointer to the ab8500_fg structure
708 int ab8500_fg_inst_curr_blocking(struct ab8500_fg *di)
714 ret = ab8500_fg_inst_curr_start(di);
716 dev_err(di->dev, "Failed to initialize fg_inst\n");
721 if (!completion_done(&di->ab8500_fg_started)) {
723 &di->ab8500_fg_started,
725 dev_dbg(di->dev, "Start time: %d ms\n",
729 dev_err(di->dev, "completion timed out [%d]\n",
735 ret = ab8500_fg_inst_curr_finalize(di, &curr_ua);
737 dev_err(di->dev, "Failed to finalize fg_inst\n");
741 dev_dbg(di->dev, "%s instant current: %d uA", __func__, curr_ua);
744 disable_irq(di->irq);
745 mutex_unlock(&di->cc_lock);
762 struct ab8500_fg *di = container_of(work,
765 mutex_lock(&di->cc_lock);
766 ret = abx500_set_register_interruptible(di->dev, AB8500_GAS_GAUGE,
771 ret = abx500_get_register_interruptible(di->dev, AB8500_GAS_GAUGE,
776 ret = abx500_get_register_interruptible(di->dev, AB8500_GAS_GAUGE,
781 ret = abx500_get_register_interruptible(di->dev, AB8500_GAS_GAUGE,
798 di->accu_charge = (val * QLSB_NANO_AMP_HOURS_X10) /
799 (100 * di->bm->fg_res);
806 di->avg_curr_ua = (val * QLSB_NANO_AMP_HOURS_X10 * 36) /
807 (di->bm->fg_res * (di->fg_samples / 4));
809 di->flags.conv_done = true;
811 mutex_unlock(&di->cc_lock);
813 queue_work(di->fg_wq, &di->fg_work);
815 dev_dbg(di->dev, "fg_res: %d, fg_samples: %d, gasg: %d, accu_charge: %d \n",
816 di->bm->fg_res, di->fg_samples, val, di->accu_charge);
819 dev_err(di->dev,
821 mutex_unlock(&di->cc_lock);
822 queue_work(di->fg_wq, &di->fg_work);
827 * @di: pointer to the ab8500_fg structure
831 static int ab8500_fg_bat_voltage(struct ab8500_fg *di)
836 ret = iio_read_channel_processed(di->main_bat_v, &vbat);
838 dev_err(di->dev,
852 * @di: pointer to the ab8500_fg structure
857 static int ab8500_fg_volt_to_capacity(struct ab8500_fg *di, int voltage_uv)
859 struct power_supply_battery_info *bi = di->bm->bi;
862 return power_supply_batinfo_ocv2cap(bi, voltage_uv, di->bat_temp) * 10;
867 * @di: pointer to the ab8500_fg structure
872 static int ab8500_fg_uncomp_volt_to_capacity(struct ab8500_fg *di)
874 di->vbat_uv = ab8500_fg_bat_voltage(di);
875 return ab8500_fg_volt_to_capacity(di, di->vbat_uv);
880 * @di: pointer to the ab8500_fg structure
887 static int ab8500_fg_battery_resistance(struct ab8500_fg *di, int vbat_uncomp_uv)
889 struct power_supply_battery_info *bi = di->bm->bi;
899 resistance = power_supply_vbat2ri(bi, vbat_uncomp_uv, di->flags.charging);
905 di->bat_temp / 10);
915 resistance += (di->line_impedance_uohm / 1000);
917 dev_dbg(di->dev, "%s Temp: %d battery internal resistance: %d"
919 __func__, di->bat_temp, resistance, di->bm->fg_res / 10,
920 (di->bm->fg_res / 10) + resistance);
923 resistance += di->bm->fg_res / 10;
930 * @di: pointer to the ab8500_fg structure
937 static int ab8500_load_comp_fg_bat_voltage(struct ab8500_fg *di, bool always)
944 ab8500_fg_inst_curr_start(di);
947 vbat_uv += ab8500_fg_bat_voltage(di);
950 } while (!ab8500_fg_inst_curr_done(di) &&
954 dev_err(di->dev,
956 di->vbat_uv = vbat_uv / i;
957 return di->vbat_uv;
960 ab8500_fg_inst_curr_finalize(di, &di->inst_curr_ua);
967 if (!always && di->inst_curr_ua < IGNORE_VBAT_HIGHCUR)
973 rcomp = ab8500_fg_battery_resistance(di, vbat_uv);
974 vbat_uv = vbat_uv - (di->inst_curr_ua * rcomp) / 1000;
977 di->vbat_uv = vbat_uv;
984 * @di: pointer to the ab8500_fg structure
989 static int ab8500_fg_load_comp_volt_to_capacity(struct ab8500_fg *di)
993 vbat_comp_uv = ab8500_load_comp_fg_bat_voltage(di, true);
995 return ab8500_fg_volt_to_capacity(di, vbat_comp_uv);
1000 * @di: pointer to the ab8500_fg structure
1005 static int ab8500_fg_convert_mah_to_permille(struct ab8500_fg *di, int cap_mah)
1007 return (cap_mah * 1000) / di->bat_cap.max_mah_design;
1012 * @di: pointer to the ab8500_fg structure
1017 static int ab8500_fg_convert_permille_to_mah(struct ab8500_fg *di, int cap_pm)
1019 return cap_pm * di->bat_cap.max_mah_design / 1000;
1024 * @di: pointer to the ab8500_fg structure
1029 static int ab8500_fg_convert_mah_to_uwh(struct ab8500_fg *di, int cap_mah)
1039 div_res = ((u64) cap_mah) * ((u64) di->vbat_nom_uv);
1051 * @di: pointer to the ab8500_fg structure
1056 static int ab8500_fg_calc_cap_charging(struct ab8500_fg *di)
1058 dev_dbg(di->dev, "%s cap_mah %d accu_charge %d\n",
1060 di->bat_cap.mah,
1061 di->accu_charge);
1064 if (di->bat_cap.mah + di->accu_charge > 0)
1065 di->bat_cap.mah += di->accu_charge;
1067 di->bat_cap.mah = 0;
1072 if (di->bat_cap.mah >= di->bat_cap.max_mah_design ||
1073 di->flags.force_full) {
1074 di->bat_cap.mah = di->bat_cap.max_mah_design;
1077 ab8500_fg_fill_cap_sample(di, di->bat_cap.mah);
1078 di->bat_cap.permille =
1079 ab8500_fg_convert_mah_to_permille(di, di->bat_cap.mah);
1082 di->vbat_uv = ab8500_fg_bat_voltage(di);
1083 di->inst_curr_ua = ab8500_fg_inst_curr_blocking(di);
1085 return di->bat_cap.mah;
1090 * @di: pointer to the ab8500_fg structure
1096 static int ab8500_fg_calc_cap_discharge_voltage(struct ab8500_fg *di)
1100 permille = ab8500_fg_load_comp_volt_to_capacity(di);
1102 mah = ab8500_fg_convert_permille_to_mah(di, permille);
1104 di->bat_cap.mah = ab8500_fg_add_cap_sample(di, mah);
1105 di->bat_cap.permille =
1106 ab8500_fg_convert_mah_to_permille(di, di->bat_cap.mah);
1108 return di->bat_cap.mah;
1113 * @di: pointer to the ab8500_fg structure
1119 static int ab8500_fg_calc_cap_discharge_fg(struct ab8500_fg *di)
1123 dev_dbg(di->dev, "%s cap_mah %d accu_charge %d\n",
1125 di->bat_cap.mah,
1126 di->accu_charge);
1129 if (di->bat_cap.mah + di->accu_charge > 0)
1130 di->bat_cap.mah += di->accu_charge;
1132 di->bat_cap.mah = 0;
1134 if (di->bat_cap.mah >= di->bat_cap.max_mah_design)
1135 di->bat_cap.mah = di->bat_cap.max_mah_design;
1141 permille = ab8500_fg_convert_mah_to_permille(di, di->bat_cap.mah);
1142 permille_volt = ab8500_fg_uncomp_volt_to_capacity(di);
1145 di->bat_cap.permille = permille_volt;
1146 di->bat_cap.mah = ab8500_fg_convert_permille_to_mah(di,
1147 di->bat_cap.permille);
1149 dev_dbg(di->dev, "%s voltage based: perm %d perm_volt %d\n",
1154 ab8500_fg_fill_cap_sample(di, di->bat_cap.mah);
1156 ab8500_fg_fill_cap_sample(di, di->bat_cap.mah);
1157 di->bat_cap.permille =
1158 ab8500_fg_convert_mah_to_permille(di, di->bat_cap.mah);
1161 return di->bat_cap.mah;
1166 * @di: pointer to the ab8500_fg structure
1170 static int ab8500_fg_capacity_level(struct ab8500_fg *di)
1174 percent = DIV_ROUND_CLOSEST(di->bat_cap.permille, 10);
1176 if (percent <= di->bm->cap_levels->critical ||
1177 di->flags.low_bat)
1179 else if (percent <= di->bm->cap_levels->low)
1181 else if (percent <= di->bm->cap_levels->normal)
1183 else if (percent <= di->bm->cap_levels->high)
1193 * @di: pointer to the ab8500_fg structure
1199 static int ab8500_fg_calculate_scaled_capacity(struct ab8500_fg *di)
1201 struct ab8500_fg_cap_scaling *cs = &di->bat_cap.cap_scale;
1202 int capacity = di->bat_cap.prev_percent;
1211 if (di->flags.fully_charged) {
1214 max(capacity, di->bm->fg_params->maint_thres);
1215 dev_dbg(di->dev, "Scale cap with %d/%d\n",
1223 DIV_ROUND_CLOSEST(di->bat_cap.prev_percent *
1227 if (di->flags.charging) {
1230 dev_dbg(di->dev, "Cap to stop scale lowered %d%%\n",
1232 } else if (!di->flags.fully_charged) {
1233 if (di->bat_cap.prev_percent >=
1235 dev_dbg(di->dev, "Disabling scaled capacity\n");
1237 capacity = di->bat_cap.prev_percent;
1239 dev_dbg(di->dev,
1252 * @di: pointer to the ab8500_fg structure
1257 static void ab8500_fg_update_cap_scalers(struct ab8500_fg *di)
1259 struct ab8500_fg_cap_scaling *cs = &di->bat_cap.cap_scale;
1263 if (di->flags.charging) {
1264 di->bat_cap.cap_scale.disable_cap_level =
1265 di->bat_cap.cap_scale.scaled_cap;
1266 dev_dbg(di->dev, "Cap to stop scale at charge %d%%\n",
1267 di->bat_cap.cap_scale.disable_cap_level);
1271 cs->cap_to_scale[1] = di->bat_cap.prev_percent;
1275 max(di->bat_cap.prev_percent,
1276 di->bm->fg_params->maint_thres);
1279 dev_dbg(di->dev, "Cap to scale at discharge %d/%d\n",
1286 * @di: pointer to the ab8500_fg structure
1292 static void ab8500_fg_check_capacity_limits(struct ab8500_fg *di, bool init)
1295 int percent = DIV_ROUND_CLOSEST(di->bat_cap.permille, 10);
1297 di->bat_cap.level = ab8500_fg_capacity_level(di);
1299 if (di->bat_cap.level != di->bat_cap.prev_level) {
1304 if (!(!di->flags.charging && di->bat_cap.level >
1305 di->bat_cap.prev_level) || init) {
1306 dev_dbg(di->dev, "level changed from %d to %d\n",
1307 di->bat_cap.prev_level,
1308 di->bat_cap.level);
1309 di->bat_cap.prev_level = di->bat_cap.level;
1312 dev_dbg(di->dev, "level not allowed to go up "
1314 di->bat_cap.prev_level,
1315 di->bat_cap.level);
1323 if (di->flags.low_bat) {
1324 dev_dbg(di->dev, "Battery low, set capacity to 0\n");
1325 di->bat_cap.prev_percent = 0;
1326 di->bat_cap.permille = 0;
1328 di->bat_cap.prev_mah = 0;
1329 di->bat_cap.mah = 0;
1331 } else if (di->flags.fully_charged) {
1336 if (di->flags.force_full) {
1337 di->bat_cap.prev_percent = percent;
1338 di->bat_cap.prev_mah = di->bat_cap.mah;
1342 if (!di->bat_cap.cap_scale.enable &&
1343 di->bm->capacity_scaling) {
1344 di->bat_cap.cap_scale.enable = true;
1345 di->bat_cap.cap_scale.cap_to_scale[0] = 100;
1346 di->bat_cap.cap_scale.cap_to_scale[1] =
1347 di->bat_cap.prev_percent;
1348 di->bat_cap.cap_scale.disable_cap_level = 100;
1350 } else if (di->bat_cap.prev_percent != percent) {
1351 dev_dbg(di->dev,
1355 di->bat_cap.prev_percent = percent;
1356 di->bat_cap.prev_mah = di->bat_cap.mah;
1360 } else if (di->bat_cap.prev_percent != percent) {
1367 di->bat_cap.prev_percent = 1;
1371 } else if (!(!di->flags.charging &&
1372 percent > di->bat_cap.prev_percent) || init) {
1377 dev_dbg(di->dev,
1379 di->bat_cap.prev_percent,
1381 di->bat_cap.permille);
1382 di->bat_cap.prev_percent = percent;
1383 di->bat_cap.prev_mah = di->bat_cap.mah;
1387 dev_dbg(di->dev, "capacity not allowed to go up since "
1389 di->bat_cap.prev_percent,
1391 di->bat_cap.permille);
1396 if (di->bm->capacity_scaling) {
1397 di->bat_cap.cap_scale.scaled_cap =
1398 ab8500_fg_calculate_scaled_capacity(di);
1400 dev_info(di->dev, "capacity=%d (%d)\n",
1401 di->bat_cap.prev_percent,
1402 di->bat_cap.cap_scale.scaled_cap);
1404 power_supply_changed(di->fg_psy);
1405 if (di->flags.fully_charged && di->flags.force_full) {
1406 dev_dbg(di->dev, "Battery full, notifying.\n");
1407 di->flags.force_full = false;
1408 sysfs_notify(&di->fg_kobject, NULL, "charge_full");
1410 sysfs_notify(&di->fg_kobject, NULL, "charge_now");
1414 static void ab8500_fg_charge_state_to(struct ab8500_fg *di,
1417 dev_dbg(di->dev, "Charge state from %d [%s] to %d [%s]\n",
1418 di->charge_state,
1419 charge_state[di->charge_state],
1423 di->charge_state = new_state;
1426 static void ab8500_fg_discharge_state_to(struct ab8500_fg *di,
1429 dev_dbg(di->dev, "Discharge state from %d [%s] to %d [%s]\n",
1430 di->discharge_state,
1431 discharge_state[di->discharge_state],
1435 di->discharge_state = new_state;
1440 * @di: pointer to the ab8500_fg structure
1444 static void ab8500_fg_algorithm_charging(struct ab8500_fg *di)
1450 if (di->discharge_state != AB8500_FG_DISCHARGE_INIT_RECOVERY)
1451 ab8500_fg_discharge_state_to(di,
1454 switch (di->charge_state) {
1456 di->fg_samples = SEC_TO_SAMPLE(
1457 di->bm->fg_params->accu_charging);
1459 ab8500_fg_coulomb_counter(di, true);
1460 ab8500_fg_charge_state_to(di, AB8500_FG_CHARGE_READOUT);
1468 mutex_lock(&di->cc_lock);
1469 if (!di->flags.conv_done && !di->flags.force_full) {
1471 mutex_unlock(&di->cc_lock);
1472 dev_dbg(di->dev, "%s CC conv not done\n",
1477 di->flags.conv_done = false;
1478 mutex_unlock(&di->cc_lock);
1480 ab8500_fg_calc_cap_charging(di);
1489 ab8500_fg_check_capacity_limits(di, false);
1492 static void force_capacity(struct ab8500_fg *di)
1496 ab8500_fg_clear_cap_samples(di);
1497 cap = di->bat_cap.user_mah;
1498 if (cap > di->bat_cap.max_mah_design) {
1499 dev_dbg(di->dev, "Remaining cap %d can't be bigger than total"
1500 " %d\n", cap, di->bat_cap.max_mah_design);
1501 cap = di->bat_cap.max_mah_design;
1503 ab8500_fg_fill_cap_sample(di, di->bat_cap.user_mah);
1504 di->bat_cap.permille = ab8500_fg_convert_mah_to_permille(di, cap);
1505 di->bat_cap.mah = cap;
1506 ab8500_fg_check_capacity_limits(di, true);
1509 static bool check_sysfs_capacity(struct ab8500_fg *di)
1514 cap = di->bat_cap.user_mah;
1516 cap_permille = ab8500_fg_convert_mah_to_permille(di,
1517 di->bat_cap.user_mah);
1519 lower = di->bat_cap.permille - di->bm->fg_params->user_cap_limit * 10;
1520 upper = di->bat_cap.permille + di->bm->fg_params->user_cap_limit * 10;
1528 dev_dbg(di->dev, "Capacity limits:"
1530 lower, cap_permille, upper, cap, di->bat_cap.mah);
1534 dev_dbg(di->dev, "OK! Using users cap %d uAh now\n", cap);
1535 force_capacity(di);
1538 dev_dbg(di->dev, "Capacity from user out of limits, ignoring");
1544 * @di: pointer to the ab8500_fg structure
1548 static void ab8500_fg_algorithm_discharging(struct ab8500_fg *di)
1553 if (di->charge_state != AB8500_FG_CHARGE_INIT)
1554 ab8500_fg_charge_state_to(di, AB8500_FG_CHARGE_INIT);
1556 switch (di->discharge_state) {
1559 di->init_cnt = 0;
1560 di->fg_samples = SEC_TO_SAMPLE(di->bm->fg_params->init_timer);
1561 ab8500_fg_coulomb_counter(di, true);
1562 ab8500_fg_discharge_state_to(di,
1573 sleep_time = di->bm->fg_params->init_timer;
1576 if (di->init_cnt > di->bm->fg_params->init_discard_time) {
1577 ab8500_fg_calc_cap_discharge_voltage(di);
1579 ab8500_fg_check_capacity_limits(di, true);
1582 di->init_cnt += sleep_time;
1583 if (di->init_cnt > di->bm->fg_params->init_total_time)
1584 ab8500_fg_discharge_state_to(di,
1590 di->recovery_cnt = 0;
1591 di->recovery_needed = true;
1592 ab8500_fg_discharge_state_to(di,
1598 sleep_time = di->bm->fg_params->recovery_sleep_timer;
1606 di->inst_curr_ua = ab8500_fg_inst_curr_blocking(di);
1608 if (ab8500_fg_is_low_curr(di, di->inst_curr_ua)) {
1609 if (di->recovery_cnt >
1610 di->bm->fg_params->recovery_total_time) {
1611 di->fg_samples = SEC_TO_SAMPLE(
1612 di->bm->fg_params->accu_high_curr);
1613 ab8500_fg_coulomb_counter(di, true);
1614 ab8500_fg_discharge_state_to(di,
1616 di->recovery_needed = false;
1618 queue_delayed_work(di->fg_wq,
1619 &di->fg_periodic_work,
1622 di->recovery_cnt += sleep_time;
1624 di->fg_samples = SEC_TO_SAMPLE(
1625 di->bm->fg_params->accu_high_curr);
1626 ab8500_fg_coulomb_counter(di, true);
1627 ab8500_fg_discharge_state_to(di,
1633 di->fg_samples = SEC_TO_SAMPLE(
1634 di->bm->fg_params->accu_high_curr);
1635 ab8500_fg_coulomb_counter(di, true);
1636 ab8500_fg_discharge_state_to(di,
1641 di->inst_curr_ua = ab8500_fg_inst_curr_blocking(di);
1643 if (ab8500_fg_is_low_curr(di, di->inst_curr_ua)) {
1645 if (di->high_curr_mode) {
1646 di->high_curr_mode = false;
1647 di->high_curr_cnt = 0;
1650 if (di->recovery_needed) {
1651 ab8500_fg_discharge_state_to(di,
1654 queue_delayed_work(di->fg_wq,
1655 &di->fg_periodic_work, 0);
1660 ab8500_fg_calc_cap_discharge_voltage(di);
1662 mutex_lock(&di->cc_lock);
1663 if (!di->flags.conv_done) {
1665 mutex_unlock(&di->cc_lock);
1666 dev_dbg(di->dev, "%s CC conv not done\n",
1671 di->flags.conv_done = false;
1672 mutex_unlock(&di->cc_lock);
1675 if (!di->high_curr_mode) {
1676 di->high_curr_mode = true;
1677 di->high_curr_cnt = 0;
1680 di->high_curr_cnt +=
1681 di->bm->fg_params->accu_high_curr;
1682 if (di->high_curr_cnt >
1683 di->bm->fg_params->high_curr_time)
1684 di->recovery_needed = true;
1686 ab8500_fg_calc_cap_discharge_fg(di);
1689 ab8500_fg_check_capacity_limits(di, false);
1694 ab8500_fg_calc_cap_discharge_voltage(di);
1696 di->fg_samples = SEC_TO_SAMPLE(
1697 di->bm->fg_params->accu_high_curr);
1698 ab8500_fg_coulomb_counter(di, true);
1699 ab8500_fg_discharge_state_to(di,
1702 ab8500_fg_check_capacity_limits(di, false);
1713 * @di: pointer to the ab8500_fg structure
1716 static void ab8500_fg_algorithm_calibrate(struct ab8500_fg *di)
1720 switch (di->calib_state) {
1722 dev_dbg(di->dev, "Calibration ongoing...\n");
1724 ret = abx500_mask_and_set_register_interruptible(di->dev,
1730 ret = abx500_mask_and_set_register_interruptible(di->dev,
1735 di->calib_state = AB8500_FG_CALIB_WAIT;
1738 ret = abx500_mask_and_set_register_interruptible(di->dev,
1743 di->flags.calibrate = false;
1744 dev_dbg(di->dev, "Calibration done...\n");
1745 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
1748 dev_dbg(di->dev, "Calibration WFI\n");
1756 dev_err(di->dev, "failed to calibrate the CC\n");
1757 di->flags.calibrate = false;
1758 di->calib_state = AB8500_FG_CALIB_INIT;
1759 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
1764 * @di: pointer to the ab8500_fg structure
1768 static void ab8500_fg_algorithm(struct ab8500_fg *di)
1770 if (di->flags.calibrate)
1771 ab8500_fg_algorithm_calibrate(di);
1773 if (di->flags.charging)
1774 ab8500_fg_algorithm_charging(di);
1776 ab8500_fg_algorithm_discharging(di);
1779 dev_dbg(di->dev, "[FG_DATA] %d %d %d %d %d %d %d %d %d %d "
1781 di->bat_cap.max_mah_design,
1782 di->bat_cap.max_mah,
1783 di->bat_cap.mah,
1784 di->bat_cap.permille,
1785 di->bat_cap.level,
1786 di->bat_cap.prev_mah,
1787 di->bat_cap.prev_percent,
1788 di->bat_cap.prev_level,
1789 di->vbat_uv,
1790 di->inst_curr_ua,
1791 di->avg_curr_ua,
1792 di->accu_charge,
1793 di->flags.charging,
1794 di->charge_state,
1795 di->discharge_state,
1796 di->high_curr_mode,
1797 di->recovery_needed);
1808 struct ab8500_fg *di = container_of(work, struct ab8500_fg,
1811 if (di->init_capacity) {
1813 ab8500_fg_calc_cap_discharge_voltage(di);
1814 ab8500_fg_check_capacity_limits(di, true);
1815 di->init_capacity = false;
1817 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
1818 } else if (di->flags.user_cap) {
1819 if (check_sysfs_capacity(di)) {
1820 ab8500_fg_check_capacity_limits(di, true);
1821 if (di->flags.charging)
1822 ab8500_fg_charge_state_to(di,
1825 ab8500_fg_discharge_state_to(di,
1828 di->flags.user_cap = false;
1829 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
1831 ab8500_fg_algorithm(di);
1846 struct ab8500_fg *di = container_of(work, struct ab8500_fg,
1853 ret = abx500_get_register_interruptible(di->dev,
1857 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
1861 if (!di->flags.bat_ovv) {
1862 dev_dbg(di->dev, "Battery OVV\n");
1863 di->flags.bat_ovv = true;
1864 power_supply_changed(di->fg_psy);
1867 queue_delayed_work(di->fg_wq, &di->fg_check_hw_failure_work,
1870 dev_dbg(di->dev, "Battery recovered from OVV\n");
1871 di->flags.bat_ovv = false;
1872 power_supply_changed(di->fg_psy);
1886 struct ab8500_fg *di = container_of(work, struct ab8500_fg,
1889 vbat_uv = ab8500_fg_bat_voltage(di);
1892 if (vbat_uv < di->bm->fg_params->lowbat_threshold_uv) {
1894 if (di->low_bat_cnt < 1) {
1895 di->flags.low_bat = true;
1896 dev_warn(di->dev, "Shut down pending...\n");
1903 di->low_bat_cnt--;
1904 dev_warn(di->dev, "Battery voltage still LOW\n");
1905 queue_delayed_work(di->fg_wq, &di->fg_low_bat_work,
1909 di->flags.low_bat_delay = false;
1910 di->low_bat_cnt = 10;
1911 dev_warn(di->dev, "Battery voltage OK again\n");
1915 ab8500_fg_check_capacity_limits(di, false);
1921 * @di: pointer to the ab8500_fg structure
1928 static int ab8500_fg_battok_calc(struct ab8500_fg *di, int target)
1940 * @di: pointer to the ab8500_fg structure
1944 static int ab8500_fg_battok_init_hw_register(struct ab8500_fg *di)
1954 sel0 = di->bm->fg_params->battok_falling_th_sel0;
1955 sel1 = di->bm->fg_params->battok_raising_th_sel1;
1957 cbp_sel0 = ab8500_fg_battok_calc(di, sel0);
1958 cbp_sel1 = ab8500_fg_battok_calc(di, sel1);
1963 dev_warn(di->dev, "Invalid voltage step:%d, using %d %d\n",
1969 dev_warn(di->dev, "Invalid voltage step:%d, using %d %d\n",
1974 dev_dbg(di->dev, "using: %x %d %d\n", new_val, cbp_sel0, cbp_sel1);
1975 ret = abx500_set_register_interruptible(di->dev, AB8500_SYS_CTRL2_BLOCK,
1988 struct ab8500_fg *di = container_of(work, struct ab8500_fg, fg_work);
1990 ab8500_fg_algorithm(di);
2002 struct ab8500_fg *di = _di;
2003 if (!di->nbr_cceoc_irq_cnt) {
2004 di->nbr_cceoc_irq_cnt++;
2005 complete(&di->ab8500_fg_started);
2007 di->nbr_cceoc_irq_cnt = 0;
2008 complete(&di->ab8500_fg_complete);
2022 struct ab8500_fg *di = _di;
2023 di->calib_state = AB8500_FG_CALIB_END;
2024 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
2037 struct ab8500_fg *di = _di;
2039 queue_work(di->fg_wq, &di->fg_acc_cur_work);
2053 struct ab8500_fg *di = _di;
2055 dev_dbg(di->dev, "Battery OVV\n");
2058 queue_delayed_work(di->fg_wq, &di->fg_check_hw_failure_work, 0);
2072 struct ab8500_fg *di = _di;
2075 if (!di->flags.low_bat_delay) {
2076 dev_warn(di->dev, "Battery voltage is below LOW threshold\n");
2077 di->flags.low_bat_delay = true;
2082 queue_delayed_work(di->fg_wq, &di->fg_low_bat_work,
2110 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2121 if (di->flags.bat_ovv)
2124 val->intval = di->vbat_uv;
2127 val->intval = di->inst_curr_ua;
2130 val->intval = di->avg_curr_ua;
2133 val->intval = ab8500_fg_convert_mah_to_uwh(di,
2134 di->bat_cap.max_mah_design);
2137 val->intval = ab8500_fg_convert_mah_to_uwh(di,
2138 di->bat_cap.max_mah);
2141 if (di->flags.batt_unknown && !di->bm->chg_unknown_bat &&
2142 di->flags.batt_id_received)
2143 val->intval = ab8500_fg_convert_mah_to_uwh(di,
2144 di->bat_cap.max_mah);
2146 val->intval = ab8500_fg_convert_mah_to_uwh(di,
2147 di->bat_cap.prev_mah);
2150 val->intval = di->bat_cap.max_mah_design;
2153 val->intval = di->bat_cap.max_mah;
2156 if (di->flags.batt_unknown && !di->bm->chg_unknown_bat &&
2157 di->flags.batt_id_received)
2158 val->intval = di->bat_cap.max_mah;
2160 val->intval = di->bat_cap.prev_mah;
2163 if (di->flags.batt_unknown && !di->bm->chg_unknown_bat &&
2164 di->flags.batt_id_received)
2167 val->intval = di->bat_cap.prev_percent;
2170 if (di->flags.batt_unknown && !di->bm->chg_unknown_bat &&
2171 di->flags.batt_id_received)
2174 val->intval = di->bat_cap.prev_level;
2187 struct ab8500_fg *di;
2193 di = power_supply_get_drvdata(psy);
2194 bi = di->bm->bi;
2220 if (!di->flags.charging)
2222 di->flags.charging = false;
2223 di->flags.fully_charged = false;
2224 if (di->bm->capacity_scaling)
2225 ab8500_fg_update_cap_scalers(di);
2226 queue_work(di->fg_wq, &di->fg_work);
2229 if (di->flags.fully_charged)
2231 di->flags.fully_charged = true;
2232 di->flags.force_full = true;
2234 di->bat_cap.max_mah = di->bat_cap.mah;
2235 queue_work(di->fg_wq, &di->fg_work);
2238 if (di->flags.charging &&
2239 !di->flags.fully_charged)
2241 di->flags.charging = true;
2242 di->flags.fully_charged = false;
2243 if (di->bm->capacity_scaling)
2244 ab8500_fg_update_cap_scalers(di);
2245 queue_work(di->fg_wq, &di->fg_work);
2256 if (!di->flags.batt_id_received &&
2259 di->flags.batt_id_received = true;
2261 di->bat_cap.max_mah_design =
2262 di->bm->bi->charge_full_design_uah;
2264 di->bat_cap.max_mah =
2265 di->bat_cap.max_mah_design;
2267 di->vbat_nom_uv =
2268 di->bm->bi->voltage_max_design_uv;
2272 di->flags.batt_unknown = false;
2274 di->flags.batt_unknown = true;
2283 if (di->flags.batt_id_received)
2284 di->bat_temp = ret.intval;
2299 * @di: pointer to the ab8500_fg structure
2303 static int ab8500_fg_init_hw_registers(struct ab8500_fg *di)
2314 ret = abx500_mask_and_set_register_interruptible(di->dev,
2320 dev_err(di->dev, "failed to set BATT_OVV\n");
2325 ret = abx500_mask_and_set_register_interruptible(di->dev,
2331 dev_err(di->dev, "failed to enable BATT_OVV\n");
2336 ret = abx500_set_register_interruptible(di->dev,
2340 di->bm->fg_params->lowbat_threshold_uv) << 1 |
2343 dev_err(di->dev, "%s write failed\n", __func__);
2348 ret = ab8500_fg_battok_init_hw_register(di);
2350 dev_err(di->dev, "BattOk init write failed.\n");
2354 if (is_ab8505(di->parent)) {
2355 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2356 AB8505_RTC_PCUT_MAX_TIME_REG, di->bm->fg_params->pcut_max_time);
2359 dev_err(di->dev, "%s write failed AB8505_RTC_PCUT_MAX_TIME_REG\n", __func__);
2363 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2364 AB8505_RTC_PCUT_FLAG_TIME_REG, di->bm->fg_params->pcut_flag_time);
2367 dev_err(di->dev, "%s write failed AB8505_RTC_PCUT_FLAG_TIME_REG\n", __func__);
2371 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2372 AB8505_RTC_PCUT_RESTART_REG, di->bm->fg_params->pcut_max_restart);
2375 dev_err(di->dev, "%s write failed AB8505_RTC_PCUT_RESTART_REG\n", __func__);
2379 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2380 AB8505_RTC_PCUT_DEBOUNCE_REG, di->bm->fg_params->pcut_debounce_time);
2383 dev_err(di->dev, "%s write failed AB8505_RTC_PCUT_DEBOUNCE_REG\n", __func__);
2387 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2388 AB8505_RTC_PCUT_CTL_STATUS_REG, di->bm->fg_params->pcut_enable);
2391 dev_err(di->dev, "%s write failed AB8505_RTC_PCUT_CTL_STATUS_REG\n", __func__);
2424 struct ab8500_fg *di = container_of(work, struct ab8500_fg,
2427 if (!di->flags.calibrate) {
2428 dev_dbg(di->dev, "Resetting FG state machine to init.\n");
2429 ab8500_fg_clear_cap_samples(di);
2430 ab8500_fg_calc_cap_discharge_voltage(di);
2431 ab8500_fg_charge_state_to(di, AB8500_FG_CHARGE_INIT);
2432 ab8500_fg_discharge_state_to(di, AB8500_FG_DISCHARGE_INIT);
2433 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
2436 dev_err(di->dev, "Residual offset calibration ongoing "
2439 queue_delayed_work(di->fg_wq, &di->fg_reinit_work,
2452 static ssize_t charge_full_show(struct ab8500_fg *di, char *buf)
2454 return sysfs_emit(buf, "%d\n", di->bat_cap.max_mah);
2457 static ssize_t charge_full_store(struct ab8500_fg *di, const char *buf,
2467 di->bat_cap.max_mah = (int) charge_full;
2471 static ssize_t charge_now_show(struct ab8500_fg *di, char *buf)
2473 return sysfs_emit(buf, "%d\n", di->bat_cap.prev_mah);
2476 static ssize_t charge_now_store(struct ab8500_fg *di, const char *buf,
2486 di->bat_cap.user_mah = (int) charge_now;
2487 di->flags.user_cap = true;
2488 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
2502 struct ab8500_fg *di;
2505 di = container_of(kobj, struct ab8500_fg, fg_kobject);
2510 return entry->show(di, buf);
2517 struct ab8500_fg *di;
2520 di = container_of(kobj, struct ab8500_fg, fg_kobject);
2525 return entry->store(di, buf, count);
2547 * @di: pointer to the struct ab8500_chargalg
2551 static void ab8500_fg_sysfs_exit(struct ab8500_fg *di)
2553 kobject_del(&di->fg_kobject);
2558 * @di: pointer to the struct ab8500_chargalg
2563 static int ab8500_fg_sysfs_init(struct ab8500_fg *di)
2567 ret = kobject_init_and_add(&di->fg_kobject,
2571 kobject_put(&di->fg_kobject);
2572 dev_err(di->dev, "failed to create sysfs entry\n");
2585 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2587 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
2608 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2618 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2635 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2637 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
2659 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2669 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2686 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2688 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
2709 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2719 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2737 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2739 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
2760 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2762 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
2783 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2785 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
2804 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2814 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2832 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2834 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
2855 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2857 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
2878 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2888 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2905 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2907 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
2940 static int ab8500_fg_sysfs_psy_create_attrs(struct ab8500_fg *di)
2944 if (is_ab8505(di->parent)) {
2946 if (device_create_file(&di->fg_psy->dev,
2952 dev_err(&di->fg_psy->dev, "Failed creating sysfs psy attrs for ab8505.\n");
2954 device_remove_file(&di->fg_psy->dev,
2960 static void ab8500_fg_sysfs_psy_remove_attrs(struct ab8500_fg *di)
2964 if (is_ab8505(di->parent)) {
2966 (void)device_remove_file(&di->fg_psy->dev,
2975 struct ab8500_fg *di = dev_get_drvdata(dev);
2981 if (!di->flags.charging) {
2982 ab8500_fg_discharge_state_to(di, AB8500_FG_DISCHARGE_WAKEUP);
2983 queue_work(di->fg_wq, &di->fg_work);
2991 struct ab8500_fg *di = dev_get_drvdata(dev);
2993 flush_delayed_work(&di->fg_periodic_work);
2994 flush_work(&di->fg_work);
2995 flush_work(&di->fg_acc_cur_work);
2996 flush_delayed_work(&di->fg_reinit_work);
2997 flush_delayed_work(&di->fg_low_bat_work);
2998 flush_delayed_work(&di->fg_check_hw_failure_work);
3004 if (di->flags.fg_enabled && !di->flags.charging)
3005 ab8500_fg_coulomb_counter(di, false);
3036 struct ab8500_fg *di = dev_get_drvdata(dev);
3038 di->bat_cap.max_mah_design = di->bm->bi->charge_full_design_uah;
3039 di->bat_cap.max_mah = di->bat_cap.max_mah_design;
3040 di->vbat_nom_uv = di->bm->bi->voltage_max_design_uv;
3043 ab8500_fg_coulomb_counter(di, true);
3045 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
3053 struct ab8500_fg *di = dev_get_drvdata(dev);
3057 ret = ab8500_fg_coulomb_counter(di, false);
3061 flush_workqueue(di->fg_wq);
3073 struct ab8500_fg *di;
3077 di = devm_kzalloc(dev, sizeof(*di), GFP_KERNEL);
3078 if (!di)
3081 di->bm = &ab8500_bm_data;
3083 mutex_init(&di->cc_lock);
3086 di->dev = dev;
3087 di->parent = dev_get_drvdata(pdev->dev.parent);
3089 di->main_bat_v = devm_iio_channel_get(dev, "main_bat_v");
3090 if (IS_ERR(di->main_bat_v)) {
3091 ret = dev_err_probe(dev, PTR_ERR(di->main_bat_v),
3097 &di->line_impedance_uohm))
3099 di->line_impedance_uohm);
3103 psy_cfg.drv_data = di;
3105 di->init_capacity = true;
3107 ab8500_fg_charge_state_to(di, AB8500_FG_CHARGE_INIT);
3108 ab8500_fg_discharge_state_to(di, AB8500_FG_DISCHARGE_INIT);
3111 di->fg_wq = alloc_ordered_workqueue("ab8500_fg_wq", WQ_MEM_RECLAIM);
3112 if (di->fg_wq == NULL) {
3118 INIT_WORK(&di->fg_work, ab8500_fg_instant_work);
3121 INIT_WORK(&di->fg_acc_cur_work, ab8500_fg_acc_cur_work);
3124 INIT_DEFERRABLE_WORK(&di->fg_reinit_work,
3128 INIT_DEFERRABLE_WORK(&di->fg_periodic_work,
3132 INIT_DEFERRABLE_WORK(&di->fg_low_bat_work,
3136 INIT_DEFERRABLE_WORK(&di->fg_check_hw_failure_work,
3140 di->flags.low_bat = false;
3143 di->low_bat_cnt = 10;
3146 ret = ab8500_fg_init_hw_registers(di);
3149 destroy_workqueue(di->fg_wq);
3154 di->flags.batt_unknown = true;
3155 di->flags.batt_id_received = false;
3158 di->fg_psy = devm_power_supply_register(dev, &ab8500_fg_desc, &psy_cfg);
3159 if (IS_ERR(di->fg_psy)) {
3161 destroy_workqueue(di->fg_wq);
3162 return PTR_ERR(di->fg_psy);
3165 di->fg_samples = SEC_TO_SAMPLE(di->bm->fg_params->init_timer);
3171 init_completion(&di->ab8500_fg_started);
3172 init_completion(&di->ab8500_fg_complete);
3178 destroy_workqueue(di->fg_wq);
3185 ab8500_fg_irq[i].name, di);
3190 destroy_workqueue(di->fg_wq);
3197 di->irq = platform_get_irq_byname(pdev, "CCEOC");
3198 disable_irq(di->irq);
3199 di->nbr_cceoc_irq_cnt = 0;
3201 platform_set_drvdata(pdev, di);
3203 ret = ab8500_fg_sysfs_init(di);
3206 destroy_workqueue(di->fg_wq);
3210 ret = ab8500_fg_sysfs_psy_create_attrs(di);
3213 ab8500_fg_sysfs_exit(di);
3214 destroy_workqueue(di->fg_wq);
3219 di->flags.calibrate = true;
3220 di->calib_state = AB8500_FG_CALIB_INIT;
3223 di->bat_temp = 210;
3225 list_add_tail(&di->node, &ab8500_fg_list);
3232 struct ab8500_fg *di = platform_get_drvdata(pdev);
3234 destroy_workqueue(di->fg_wq);
3236 list_del(&di->node);
3237 ab8500_fg_sysfs_exit(di);
3238 ab8500_fg_sysfs_psy_remove_attrs(di);