Lines Matching refs:di
356 * @di: pointer to the ab8500_fg structure
361 static int ab8500_fg_is_low_curr(struct ab8500_fg *di, int curr)
366 if (curr > -di->bm->fg_params->high_curr_threshold)
374 * @di: pointer to the ab8500_fg structure
380 static int ab8500_fg_add_cap_sample(struct ab8500_fg *di, int sample)
383 struct ab8500_fg_avg_cap *avg = &di->avg_cap;
410 * @di: pointer to the ab8500_fg structure
414 static void ab8500_fg_clear_cap_samples(struct ab8500_fg *di)
417 struct ab8500_fg_avg_cap *avg = &di->avg_cap;
432 * @di: pointer to the ab8500_fg structure
437 static void ab8500_fg_fill_cap_sample(struct ab8500_fg *di, int sample)
441 struct ab8500_fg_avg_cap *avg = &di->avg_cap;
458 * @di: pointer to the ab8500_fg structure
464 static int ab8500_fg_coulomb_counter(struct ab8500_fg *di, bool enable)
467 mutex_lock(&di->cc_lock);
471 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
477 ret = abx500_set_register_interruptible(di->dev,
479 di->fg_samples);
484 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
490 di->flags.fg_enabled = true;
493 ret = abx500_mask_and_set_register_interruptible(di->dev,
499 ret = abx500_set_register_interruptible(di->dev,
505 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
510 di->flags.fg_enabled = false;
513 dev_dbg(di->dev, " CC enabled: %d Samples: %d\n",
514 enable, di->fg_samples);
516 mutex_unlock(&di->cc_lock);
520 dev_err(di->dev, "%s Enabling coulomb counter failed\n", __func__);
521 mutex_unlock(&di->cc_lock);
527 * @di: pointer to the ab8500_fg structure
533 int ab8500_fg_inst_curr_start(struct ab8500_fg *di)
538 mutex_lock(&di->cc_lock);
540 di->nbr_cceoc_irq_cnt = 0;
541 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
547 dev_dbg(di->dev, "%s Enable FG\n", __func__);
548 di->turn_off_fg = true;
551 ret = abx500_set_register_interruptible(di->dev,
558 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
564 di->turn_off_fg = false;
568 reinit_completion(&di->ab8500_fg_started);
569 reinit_completion(&di->ab8500_fg_complete);
570 enable_irq(di->irq);
575 mutex_unlock(&di->cc_lock);
581 * @di: pointer to the ab8500_fg structure
585 int ab8500_fg_inst_curr_started(struct ab8500_fg *di)
587 return completion_done(&di->ab8500_fg_started);
592 * @di: pointer to the ab8500_fg structure
596 int ab8500_fg_inst_curr_done(struct ab8500_fg *di)
598 return completion_done(&di->ab8500_fg_complete);
603 * @di: pointer to the ab8500_fg structure
610 int ab8500_fg_inst_curr_finalize(struct ab8500_fg *di, int *res)
617 if (!completion_done(&di->ab8500_fg_complete)) {
619 &di->ab8500_fg_complete,
621 dev_dbg(di->dev, "Finalize time: %d ms\n",
625 disable_irq(di->irq);
626 di->nbr_cceoc_irq_cnt = 0;
627 dev_err(di->dev, "completion timed out [%d]\n",
633 disable_irq(di->irq);
634 di->nbr_cceoc_irq_cnt = 0;
636 ret = abx500_mask_and_set_register_interruptible(di->dev,
644 ret = abx500_get_register_interruptible(di->dev, AB8500_GAS_GAUGE,
649 ret = abx500_get_register_interruptible(di->dev, AB8500_GAS_GAUGE,
673 (1000 * di->bm->fg_res);
675 if (di->turn_off_fg) {
676 dev_dbg(di->dev, "%s Disable FG\n", __func__);
679 ret = abx500_set_register_interruptible(di->dev,
685 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
690 mutex_unlock(&di->cc_lock);
695 mutex_unlock(&di->cc_lock);
701 * @di: pointer to the ab8500_fg structure
706 int ab8500_fg_inst_curr_blocking(struct ab8500_fg *di)
712 ret = ab8500_fg_inst_curr_start(di);
714 dev_err(di->dev, "Failed to initialize fg_inst\n");
719 if (!completion_done(&di->ab8500_fg_started)) {
721 &di->ab8500_fg_started,
723 dev_dbg(di->dev, "Start time: %d ms\n",
727 dev_err(di->dev, "completion timed out [%d]\n",
733 ret = ab8500_fg_inst_curr_finalize(di, &res);
735 dev_err(di->dev, "Failed to finalize fg_inst\n");
739 dev_dbg(di->dev, "%s instant current: %d", __func__, res);
742 disable_irq(di->irq);
743 mutex_unlock(&di->cc_lock);
760 struct ab8500_fg *di = container_of(work,
763 mutex_lock(&di->cc_lock);
764 ret = abx500_set_register_interruptible(di->dev, AB8500_GAS_GAUGE,
769 ret = abx500_get_register_interruptible(di->dev, AB8500_GAS_GAUGE,
774 ret = abx500_get_register_interruptible(di->dev, AB8500_GAS_GAUGE,
779 ret = abx500_get_register_interruptible(di->dev, AB8500_GAS_GAUGE,
796 di->accu_charge = (val * QLSB_NANO_AMP_HOURS_X10) /
797 (100 * di->bm->fg_res);
805 di->avg_curr = (val * QLSB_NANO_AMP_HOURS_X10 * 36) /
806 (1000 * di->bm->fg_res * (di->fg_samples / 4));
808 di->flags.conv_done = true;
810 mutex_unlock(&di->cc_lock);
812 queue_work(di->fg_wq, &di->fg_work);
814 dev_dbg(di->dev, "fg_res: %d, fg_samples: %d, gasg: %d, accu_charge: %d \n",
815 di->bm->fg_res, di->fg_samples, val, di->accu_charge);
818 dev_err(di->dev,
820 mutex_unlock(&di->cc_lock);
821 queue_work(di->fg_wq, &di->fg_work);
826 * @di: pointer to the ab8500_fg structure
830 static int ab8500_fg_bat_voltage(struct ab8500_fg *di)
835 ret = iio_read_channel_processed(di->main_bat_v, &vbat);
837 dev_err(di->dev,
849 * @di: pointer to the ab8500_fg structure
854 static int ab8500_fg_volt_to_capacity(struct ab8500_fg *di, int voltage)
860 tbl = di->bm->bat_type[di->bm->batt_id].v_to_cap_tbl,
861 tbl_size = di->bm->bat_type[di->bm->batt_id].n_v_cap_tbl_elements;
880 dev_dbg(di->dev, "%s Vbat: %d, Cap: %d per mille",
888 * @di: pointer to the ab8500_fg structure
893 static int ab8500_fg_uncomp_volt_to_capacity(struct ab8500_fg *di)
895 di->vbat = ab8500_fg_bat_voltage(di);
896 return ab8500_fg_volt_to_capacity(di, di->vbat);
901 * @di: pointer to the ab8500_fg structure
906 static int ab8500_fg_battery_resistance(struct ab8500_fg *di)
912 tbl = di->bm->bat_type[di->bm->batt_id].batres_tbl;
913 tbl_size = di->bm->bat_type[di->bm->batt_id].n_batres_tbl_elements;
916 if (di->bat_temp / 10 > tbl[i].temp)
921 resist = interpolate(di->bat_temp / 10,
932 dev_dbg(di->dev, "%s Temp: %d battery internal resistance: %d"
934 __func__, di->bat_temp, resist, di->bm->fg_res / 10,
935 (di->bm->fg_res / 10) + resist);
938 resist += di->bm->fg_res / 10;
945 * @di: pointer to the ab8500_fg structure
950 static int ab8500_fg_load_comp_volt_to_capacity(struct ab8500_fg *di)
956 ab8500_fg_inst_curr_start(di);
959 vbat += ab8500_fg_bat_voltage(di);
962 } while (!ab8500_fg_inst_curr_done(di));
964 ab8500_fg_inst_curr_finalize(di, &di->inst_curr);
966 di->vbat = vbat / i;
967 res = ab8500_fg_battery_resistance(di);
970 vbat_comp = di->vbat - (di->inst_curr * res) / 1000;
972 dev_dbg(di->dev, "%s Measured Vbat: %dmV,Compensated Vbat %dmV, "
974 __func__, di->vbat, vbat_comp, res, di->inst_curr, i);
976 return ab8500_fg_volt_to_capacity(di, vbat_comp);
981 * @di: pointer to the ab8500_fg structure
986 static int ab8500_fg_convert_mah_to_permille(struct ab8500_fg *di, int cap_mah)
988 return (cap_mah * 1000) / di->bat_cap.max_mah_design;
993 * @di: pointer to the ab8500_fg structure
998 static int ab8500_fg_convert_permille_to_mah(struct ab8500_fg *di, int cap_pm)
1000 return cap_pm * di->bat_cap.max_mah_design / 1000;
1005 * @di: pointer to the ab8500_fg structure
1010 static int ab8500_fg_convert_mah_to_uwh(struct ab8500_fg *di, int cap_mah)
1015 div_res = ((u64) cap_mah) * ((u64) di->vbat_nom);
1027 * @di: pointer to the ab8500_fg structure
1032 static int ab8500_fg_calc_cap_charging(struct ab8500_fg *di)
1034 dev_dbg(di->dev, "%s cap_mah %d accu_charge %d\n",
1036 di->bat_cap.mah,
1037 di->accu_charge);
1040 if (di->bat_cap.mah + di->accu_charge > 0)
1041 di->bat_cap.mah += di->accu_charge;
1043 di->bat_cap.mah = 0;
1048 if (di->bat_cap.mah >= di->bat_cap.max_mah_design ||
1049 di->flags.force_full) {
1050 di->bat_cap.mah = di->bat_cap.max_mah_design;
1053 ab8500_fg_fill_cap_sample(di, di->bat_cap.mah);
1054 di->bat_cap.permille =
1055 ab8500_fg_convert_mah_to_permille(di, di->bat_cap.mah);
1058 di->vbat = ab8500_fg_bat_voltage(di);
1059 di->inst_curr = ab8500_fg_inst_curr_blocking(di);
1061 return di->bat_cap.mah;
1066 * @di: pointer to the ab8500_fg structure
1073 static int ab8500_fg_calc_cap_discharge_voltage(struct ab8500_fg *di, bool comp)
1078 permille = ab8500_fg_load_comp_volt_to_capacity(di);
1080 permille = ab8500_fg_uncomp_volt_to_capacity(di);
1082 mah = ab8500_fg_convert_permille_to_mah(di, permille);
1084 di->bat_cap.mah = ab8500_fg_add_cap_sample(di, mah);
1085 di->bat_cap.permille =
1086 ab8500_fg_convert_mah_to_permille(di, di->bat_cap.mah);
1088 return di->bat_cap.mah;
1093 * @di: pointer to the ab8500_fg structure
1099 static int ab8500_fg_calc_cap_discharge_fg(struct ab8500_fg *di)
1103 dev_dbg(di->dev, "%s cap_mah %d accu_charge %d\n",
1105 di->bat_cap.mah,
1106 di->accu_charge);
1109 if (di->bat_cap.mah + di->accu_charge > 0)
1110 di->bat_cap.mah += di->accu_charge;
1112 di->bat_cap.mah = 0;
1114 if (di->bat_cap.mah >= di->bat_cap.max_mah_design)
1115 di->bat_cap.mah = di->bat_cap.max_mah_design;
1121 permille = ab8500_fg_convert_mah_to_permille(di, di->bat_cap.mah);
1122 permille_volt = ab8500_fg_uncomp_volt_to_capacity(di);
1125 di->bat_cap.permille = permille_volt;
1126 di->bat_cap.mah = ab8500_fg_convert_permille_to_mah(di,
1127 di->bat_cap.permille);
1129 dev_dbg(di->dev, "%s voltage based: perm %d perm_volt %d\n",
1134 ab8500_fg_fill_cap_sample(di, di->bat_cap.mah);
1136 ab8500_fg_fill_cap_sample(di, di->bat_cap.mah);
1137 di->bat_cap.permille =
1138 ab8500_fg_convert_mah_to_permille(di, di->bat_cap.mah);
1141 return di->bat_cap.mah;
1146 * @di: pointer to the ab8500_fg structure
1150 static int ab8500_fg_capacity_level(struct ab8500_fg *di)
1154 percent = DIV_ROUND_CLOSEST(di->bat_cap.permille, 10);
1156 if (percent <= di->bm->cap_levels->critical ||
1157 di->flags.low_bat)
1159 else if (percent <= di->bm->cap_levels->low)
1161 else if (percent <= di->bm->cap_levels->normal)
1163 else if (percent <= di->bm->cap_levels->high)
1173 * @di: pointer to the ab8500_fg structure
1179 static int ab8500_fg_calculate_scaled_capacity(struct ab8500_fg *di)
1181 struct ab8500_fg_cap_scaling *cs = &di->bat_cap.cap_scale;
1182 int capacity = di->bat_cap.prev_percent;
1191 if (di->flags.fully_charged) {
1194 max(capacity, di->bm->fg_params->maint_thres);
1195 dev_dbg(di->dev, "Scale cap with %d/%d\n",
1203 DIV_ROUND_CLOSEST(di->bat_cap.prev_percent *
1207 if (di->flags.charging) {
1210 dev_dbg(di->dev, "Cap to stop scale lowered %d%%\n",
1212 } else if (!di->flags.fully_charged) {
1213 if (di->bat_cap.prev_percent >=
1215 dev_dbg(di->dev, "Disabling scaled capacity\n");
1217 capacity = di->bat_cap.prev_percent;
1219 dev_dbg(di->dev,
1232 * @di: pointer to the ab8500_fg structure
1237 static void ab8500_fg_update_cap_scalers(struct ab8500_fg *di)
1239 struct ab8500_fg_cap_scaling *cs = &di->bat_cap.cap_scale;
1243 if (di->flags.charging) {
1244 di->bat_cap.cap_scale.disable_cap_level =
1245 di->bat_cap.cap_scale.scaled_cap;
1246 dev_dbg(di->dev, "Cap to stop scale at charge %d%%\n",
1247 di->bat_cap.cap_scale.disable_cap_level);
1251 cs->cap_to_scale[1] = di->bat_cap.prev_percent;
1255 max(di->bat_cap.prev_percent,
1256 di->bm->fg_params->maint_thres);
1259 dev_dbg(di->dev, "Cap to scale at discharge %d/%d\n",
1266 * @di: pointer to the ab8500_fg structure
1272 static void ab8500_fg_check_capacity_limits(struct ab8500_fg *di, bool init)
1275 int percent = DIV_ROUND_CLOSEST(di->bat_cap.permille, 10);
1277 di->bat_cap.level = ab8500_fg_capacity_level(di);
1279 if (di->bat_cap.level != di->bat_cap.prev_level) {
1284 if (!(!di->flags.charging && di->bat_cap.level >
1285 di->bat_cap.prev_level) || init) {
1286 dev_dbg(di->dev, "level changed from %d to %d\n",
1287 di->bat_cap.prev_level,
1288 di->bat_cap.level);
1289 di->bat_cap.prev_level = di->bat_cap.level;
1292 dev_dbg(di->dev, "level not allowed to go up "
1294 di->bat_cap.prev_level,
1295 di->bat_cap.level);
1303 if (di->flags.low_bat) {
1304 dev_dbg(di->dev, "Battery low, set capacity to 0\n");
1305 di->bat_cap.prev_percent = 0;
1306 di->bat_cap.permille = 0;
1308 di->bat_cap.prev_mah = 0;
1309 di->bat_cap.mah = 0;
1311 } else if (di->flags.fully_charged) {
1316 if (di->flags.force_full) {
1317 di->bat_cap.prev_percent = percent;
1318 di->bat_cap.prev_mah = di->bat_cap.mah;
1322 if (!di->bat_cap.cap_scale.enable &&
1323 di->bm->capacity_scaling) {
1324 di->bat_cap.cap_scale.enable = true;
1325 di->bat_cap.cap_scale.cap_to_scale[0] = 100;
1326 di->bat_cap.cap_scale.cap_to_scale[1] =
1327 di->bat_cap.prev_percent;
1328 di->bat_cap.cap_scale.disable_cap_level = 100;
1330 } else if (di->bat_cap.prev_percent != percent) {
1331 dev_dbg(di->dev,
1335 di->bat_cap.prev_percent = percent;
1336 di->bat_cap.prev_mah = di->bat_cap.mah;
1340 } else if (di->bat_cap.prev_percent != percent) {
1347 di->bat_cap.prev_percent = 1;
1351 } else if (!(!di->flags.charging &&
1352 percent > di->bat_cap.prev_percent) || init) {
1357 dev_dbg(di->dev,
1359 di->bat_cap.prev_percent,
1361 di->bat_cap.permille);
1362 di->bat_cap.prev_percent = percent;
1363 di->bat_cap.prev_mah = di->bat_cap.mah;
1367 dev_dbg(di->dev, "capacity not allowed to go up since "
1369 di->bat_cap.prev_percent,
1371 di->bat_cap.permille);
1376 if (di->bm->capacity_scaling) {
1377 di->bat_cap.cap_scale.scaled_cap =
1378 ab8500_fg_calculate_scaled_capacity(di);
1380 dev_info(di->dev, "capacity=%d (%d)\n",
1381 di->bat_cap.prev_percent,
1382 di->bat_cap.cap_scale.scaled_cap);
1384 power_supply_changed(di->fg_psy);
1385 if (di->flags.fully_charged && di->flags.force_full) {
1386 dev_dbg(di->dev, "Battery full, notifying.\n");
1387 di->flags.force_full = false;
1388 sysfs_notify(&di->fg_kobject, NULL, "charge_full");
1390 sysfs_notify(&di->fg_kobject, NULL, "charge_now");
1394 static void ab8500_fg_charge_state_to(struct ab8500_fg *di,
1397 dev_dbg(di->dev, "Charge state from %d [%s] to %d [%s]\n",
1398 di->charge_state,
1399 charge_state[di->charge_state],
1403 di->charge_state = new_state;
1406 static void ab8500_fg_discharge_state_to(struct ab8500_fg *di,
1409 dev_dbg(di->dev, "Discharge state from %d [%s] to %d [%s]\n",
1410 di->discharge_state,
1411 discharge_state[di->discharge_state],
1415 di->discharge_state = new_state;
1420 * @di: pointer to the ab8500_fg structure
1424 static void ab8500_fg_algorithm_charging(struct ab8500_fg *di)
1430 if (di->discharge_state != AB8500_FG_DISCHARGE_INIT_RECOVERY)
1431 ab8500_fg_discharge_state_to(di,
1434 switch (di->charge_state) {
1436 di->fg_samples = SEC_TO_SAMPLE(
1437 di->bm->fg_params->accu_charging);
1439 ab8500_fg_coulomb_counter(di, true);
1440 ab8500_fg_charge_state_to(di, AB8500_FG_CHARGE_READOUT);
1448 mutex_lock(&di->cc_lock);
1449 if (!di->flags.conv_done && !di->flags.force_full) {
1451 mutex_unlock(&di->cc_lock);
1452 dev_dbg(di->dev, "%s CC conv not done\n",
1457 di->flags.conv_done = false;
1458 mutex_unlock(&di->cc_lock);
1460 ab8500_fg_calc_cap_charging(di);
1469 ab8500_fg_check_capacity_limits(di, false);
1472 static void force_capacity(struct ab8500_fg *di)
1476 ab8500_fg_clear_cap_samples(di);
1477 cap = di->bat_cap.user_mah;
1478 if (cap > di->bat_cap.max_mah_design) {
1479 dev_dbg(di->dev, "Remaining cap %d can't be bigger than total"
1480 " %d\n", cap, di->bat_cap.max_mah_design);
1481 cap = di->bat_cap.max_mah_design;
1483 ab8500_fg_fill_cap_sample(di, di->bat_cap.user_mah);
1484 di->bat_cap.permille = ab8500_fg_convert_mah_to_permille(di, cap);
1485 di->bat_cap.mah = cap;
1486 ab8500_fg_check_capacity_limits(di, true);
1489 static bool check_sysfs_capacity(struct ab8500_fg *di)
1494 cap = di->bat_cap.user_mah;
1496 cap_permille = ab8500_fg_convert_mah_to_permille(di,
1497 di->bat_cap.user_mah);
1499 lower = di->bat_cap.permille - di->bm->fg_params->user_cap_limit * 10;
1500 upper = di->bat_cap.permille + di->bm->fg_params->user_cap_limit * 10;
1508 dev_dbg(di->dev, "Capacity limits:"
1510 lower, cap_permille, upper, cap, di->bat_cap.mah);
1514 dev_dbg(di->dev, "OK! Using users cap %d uAh now\n", cap);
1515 force_capacity(di);
1518 dev_dbg(di->dev, "Capacity from user out of limits, ignoring");
1524 * @di: pointer to the ab8500_fg structure
1528 static void ab8500_fg_algorithm_discharging(struct ab8500_fg *di)
1533 if (di->charge_state != AB8500_FG_CHARGE_INIT)
1534 ab8500_fg_charge_state_to(di, AB8500_FG_CHARGE_INIT);
1536 switch (di->discharge_state) {
1539 di->init_cnt = 0;
1540 di->fg_samples = SEC_TO_SAMPLE(di->bm->fg_params->init_timer);
1541 ab8500_fg_coulomb_counter(di, true);
1542 ab8500_fg_discharge_state_to(di,
1553 sleep_time = di->bm->fg_params->init_timer;
1556 if (di->init_cnt > di->bm->fg_params->init_discard_time) {
1557 ab8500_fg_calc_cap_discharge_voltage(di, true);
1559 ab8500_fg_check_capacity_limits(di, true);
1562 di->init_cnt += sleep_time;
1563 if (di->init_cnt > di->bm->fg_params->init_total_time)
1564 ab8500_fg_discharge_state_to(di,
1570 di->recovery_cnt = 0;
1571 di->recovery_needed = true;
1572 ab8500_fg_discharge_state_to(di,
1578 sleep_time = di->bm->fg_params->recovery_sleep_timer;
1586 di->inst_curr = ab8500_fg_inst_curr_blocking(di);
1588 if (ab8500_fg_is_low_curr(di, di->inst_curr)) {
1589 if (di->recovery_cnt >
1590 di->bm->fg_params->recovery_total_time) {
1591 di->fg_samples = SEC_TO_SAMPLE(
1592 di->bm->fg_params->accu_high_curr);
1593 ab8500_fg_coulomb_counter(di, true);
1594 ab8500_fg_discharge_state_to(di,
1596 di->recovery_needed = false;
1598 queue_delayed_work(di->fg_wq,
1599 &di->fg_periodic_work,
1602 di->recovery_cnt += sleep_time;
1604 di->fg_samples = SEC_TO_SAMPLE(
1605 di->bm->fg_params->accu_high_curr);
1606 ab8500_fg_coulomb_counter(di, true);
1607 ab8500_fg_discharge_state_to(di,
1613 di->fg_samples = SEC_TO_SAMPLE(
1614 di->bm->fg_params->accu_high_curr);
1615 ab8500_fg_coulomb_counter(di, true);
1616 ab8500_fg_discharge_state_to(di,
1621 di->inst_curr = ab8500_fg_inst_curr_blocking(di);
1623 if (ab8500_fg_is_low_curr(di, di->inst_curr)) {
1625 if (di->high_curr_mode) {
1626 di->high_curr_mode = false;
1627 di->high_curr_cnt = 0;
1630 if (di->recovery_needed) {
1631 ab8500_fg_discharge_state_to(di,
1634 queue_delayed_work(di->fg_wq,
1635 &di->fg_periodic_work, 0);
1640 ab8500_fg_calc_cap_discharge_voltage(di, true);
1642 mutex_lock(&di->cc_lock);
1643 if (!di->flags.conv_done) {
1645 mutex_unlock(&di->cc_lock);
1646 dev_dbg(di->dev, "%s CC conv not done\n",
1651 di->flags.conv_done = false;
1652 mutex_unlock(&di->cc_lock);
1655 if (!di->high_curr_mode) {
1656 di->high_curr_mode = true;
1657 di->high_curr_cnt = 0;
1660 di->high_curr_cnt +=
1661 di->bm->fg_params->accu_high_curr;
1662 if (di->high_curr_cnt >
1663 di->bm->fg_params->high_curr_time)
1664 di->recovery_needed = true;
1666 ab8500_fg_calc_cap_discharge_fg(di);
1669 ab8500_fg_check_capacity_limits(di, false);
1674 ab8500_fg_calc_cap_discharge_voltage(di, true);
1676 di->fg_samples = SEC_TO_SAMPLE(
1677 di->bm->fg_params->accu_high_curr);
1678 ab8500_fg_coulomb_counter(di, true);
1679 ab8500_fg_discharge_state_to(di,
1682 ab8500_fg_check_capacity_limits(di, false);
1693 * @di: pointer to the ab8500_fg structure
1696 static void ab8500_fg_algorithm_calibrate(struct ab8500_fg *di)
1700 switch (di->calib_state) {
1702 dev_dbg(di->dev, "Calibration ongoing...\n");
1704 ret = abx500_mask_and_set_register_interruptible(di->dev,
1710 ret = abx500_mask_and_set_register_interruptible(di->dev,
1715 di->calib_state = AB8500_FG_CALIB_WAIT;
1718 ret = abx500_mask_and_set_register_interruptible(di->dev,
1723 di->flags.calibrate = false;
1724 dev_dbg(di->dev, "Calibration done...\n");
1725 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
1728 dev_dbg(di->dev, "Calibration WFI\n");
1735 dev_err(di->dev, "failed to calibrate the CC\n");
1736 di->flags.calibrate = false;
1737 di->calib_state = AB8500_FG_CALIB_INIT;
1738 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
1743 * @di: pointer to the ab8500_fg structure
1747 static void ab8500_fg_algorithm(struct ab8500_fg *di)
1749 if (di->flags.calibrate)
1750 ab8500_fg_algorithm_calibrate(di);
1752 if (di->flags.charging)
1753 ab8500_fg_algorithm_charging(di);
1755 ab8500_fg_algorithm_discharging(di);
1758 dev_dbg(di->dev, "[FG_DATA] %d %d %d %d %d %d %d %d %d %d "
1760 di->bat_cap.max_mah_design,
1761 di->bat_cap.max_mah,
1762 di->bat_cap.mah,
1763 di->bat_cap.permille,
1764 di->bat_cap.level,
1765 di->bat_cap.prev_mah,
1766 di->bat_cap.prev_percent,
1767 di->bat_cap.prev_level,
1768 di->vbat,
1769 di->inst_curr,
1770 di->avg_curr,
1771 di->accu_charge,
1772 di->flags.charging,
1773 di->charge_state,
1774 di->discharge_state,
1775 di->high_curr_mode,
1776 di->recovery_needed);
1787 struct ab8500_fg *di = container_of(work, struct ab8500_fg,
1790 if (di->init_capacity) {
1792 ab8500_fg_calc_cap_discharge_voltage(di, true);
1793 ab8500_fg_check_capacity_limits(di, true);
1794 di->init_capacity = false;
1796 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
1797 } else if (di->flags.user_cap) {
1798 if (check_sysfs_capacity(di)) {
1799 ab8500_fg_check_capacity_limits(di, true);
1800 if (di->flags.charging)
1801 ab8500_fg_charge_state_to(di,
1804 ab8500_fg_discharge_state_to(di,
1807 di->flags.user_cap = false;
1808 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
1810 ab8500_fg_algorithm(di);
1825 struct ab8500_fg *di = container_of(work, struct ab8500_fg,
1832 ret = abx500_get_register_interruptible(di->dev,
1836 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
1840 if (!di->flags.bat_ovv) {
1841 dev_dbg(di->dev, "Battery OVV\n");
1842 di->flags.bat_ovv = true;
1843 power_supply_changed(di->fg_psy);
1846 queue_delayed_work(di->fg_wq, &di->fg_check_hw_failure_work,
1849 dev_dbg(di->dev, "Battery recovered from OVV\n");
1850 di->flags.bat_ovv = false;
1851 power_supply_changed(di->fg_psy);
1865 struct ab8500_fg *di = container_of(work, struct ab8500_fg,
1868 vbat = ab8500_fg_bat_voltage(di);
1871 if (vbat < di->bm->fg_params->lowbat_threshold) {
1873 if (di->low_bat_cnt < 1) {
1874 di->flags.low_bat = true;
1875 dev_warn(di->dev, "Shut down pending...\n");
1882 di->low_bat_cnt--;
1883 dev_warn(di->dev, "Battery voltage still LOW\n");
1884 queue_delayed_work(di->fg_wq, &di->fg_low_bat_work,
1888 di->flags.low_bat_delay = false;
1889 di->low_bat_cnt = 10;
1890 dev_warn(di->dev, "Battery voltage OK again\n");
1894 ab8500_fg_check_capacity_limits(di, false);
1900 * @di: pointer to the ab8500_fg structure
1907 static int ab8500_fg_battok_calc(struct ab8500_fg *di, int target)
1919 * @di: pointer to the ab8500_fg structure
1923 static int ab8500_fg_battok_init_hw_register(struct ab8500_fg *di)
1933 sel0 = di->bm->fg_params->battok_falling_th_sel0;
1934 sel1 = di->bm->fg_params->battok_raising_th_sel1;
1936 cbp_sel0 = ab8500_fg_battok_calc(di, sel0);
1937 cbp_sel1 = ab8500_fg_battok_calc(di, sel1);
1942 dev_warn(di->dev, "Invalid voltage step:%d, using %d %d\n",
1948 dev_warn(di->dev, "Invalid voltage step:%d, using %d %d\n",
1953 dev_dbg(di->dev, "using: %x %d %d\n", new_val, cbp_sel0, cbp_sel1);
1954 ret = abx500_set_register_interruptible(di->dev, AB8500_SYS_CTRL2_BLOCK,
1967 struct ab8500_fg *di = container_of(work, struct ab8500_fg, fg_work);
1969 ab8500_fg_algorithm(di);
1981 struct ab8500_fg *di = _di;
1982 if (!di->nbr_cceoc_irq_cnt) {
1983 di->nbr_cceoc_irq_cnt++;
1984 complete(&di->ab8500_fg_started);
1986 di->nbr_cceoc_irq_cnt = 0;
1987 complete(&di->ab8500_fg_complete);
2001 struct ab8500_fg *di = _di;
2002 di->calib_state = AB8500_FG_CALIB_END;
2003 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
2016 struct ab8500_fg *di = _di;
2018 queue_work(di->fg_wq, &di->fg_acc_cur_work);
2032 struct ab8500_fg *di = _di;
2034 dev_dbg(di->dev, "Battery OVV\n");
2037 queue_delayed_work(di->fg_wq, &di->fg_check_hw_failure_work, 0);
2051 struct ab8500_fg *di = _di;
2054 if (!di->flags.low_bat_delay) {
2055 dev_warn(di->dev, "Battery voltage is below LOW threshold\n");
2056 di->flags.low_bat_delay = true;
2061 queue_delayed_work(di->fg_wq, &di->fg_low_bat_work,
2089 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2100 if (di->flags.bat_ovv)
2103 val->intval = di->vbat * 1000;
2106 val->intval = di->inst_curr * 1000;
2109 val->intval = di->avg_curr * 1000;
2112 val->intval = ab8500_fg_convert_mah_to_uwh(di,
2113 di->bat_cap.max_mah_design);
2116 val->intval = ab8500_fg_convert_mah_to_uwh(di,
2117 di->bat_cap.max_mah);
2120 if (di->flags.batt_unknown && !di->bm->chg_unknown_bat &&
2121 di->flags.batt_id_received)
2122 val->intval = ab8500_fg_convert_mah_to_uwh(di,
2123 di->bat_cap.max_mah);
2125 val->intval = ab8500_fg_convert_mah_to_uwh(di,
2126 di->bat_cap.prev_mah);
2129 val->intval = di->bat_cap.max_mah_design;
2132 val->intval = di->bat_cap.max_mah;
2135 if (di->flags.batt_unknown && !di->bm->chg_unknown_bat &&
2136 di->flags.batt_id_received)
2137 val->intval = di->bat_cap.max_mah;
2139 val->intval = di->bat_cap.prev_mah;
2142 if (di->flags.batt_unknown && !di->bm->chg_unknown_bat &&
2143 di->flags.batt_id_received)
2146 val->intval = di->bat_cap.prev_percent;
2149 if (di->flags.batt_unknown && !di->bm->chg_unknown_bat &&
2150 di->flags.batt_id_received)
2153 val->intval = di->bat_cap.prev_level;
2166 struct ab8500_fg *di;
2171 di = power_supply_get_drvdata(psy);
2197 if (!di->flags.charging)
2199 di->flags.charging = false;
2200 di->flags.fully_charged = false;
2201 if (di->bm->capacity_scaling)
2202 ab8500_fg_update_cap_scalers(di);
2203 queue_work(di->fg_wq, &di->fg_work);
2206 if (di->flags.fully_charged)
2208 di->flags.fully_charged = true;
2209 di->flags.force_full = true;
2211 di->bat_cap.max_mah = di->bat_cap.mah;
2212 queue_work(di->fg_wq, &di->fg_work);
2215 if (di->flags.charging &&
2216 !di->flags.fully_charged)
2218 di->flags.charging = true;
2219 di->flags.fully_charged = false;
2220 if (di->bm->capacity_scaling)
2221 ab8500_fg_update_cap_scalers(di);
2222 queue_work(di->fg_wq, &di->fg_work);
2232 if (!di->flags.batt_id_received &&
2233 di->bm->batt_id != BATTERY_UNKNOWN) {
2236 b = &(di->bm->bat_type[di->bm->batt_id]);
2238 di->flags.batt_id_received = true;
2240 di->bat_cap.max_mah_design =
2244 di->bat_cap.max_mah =
2245 di->bat_cap.max_mah_design;
2247 di->vbat_nom = b->nominal_voltage;
2251 di->flags.batt_unknown = false;
2253 di->flags.batt_unknown = true;
2262 if (di->flags.batt_id_received)
2263 di->bat_temp = ret.intval;
2278 * @di: pointer to the ab8500_fg structure
2282 static int ab8500_fg_init_hw_registers(struct ab8500_fg *di)
2287 ret = abx500_mask_and_set_register_interruptible(di->dev,
2293 dev_err(di->dev, "failed to set BATT_OVV\n");
2298 ret = abx500_mask_and_set_register_interruptible(di->dev,
2304 dev_err(di->dev, "failed to enable BATT_OVV\n");
2309 ret = abx500_set_register_interruptible(di->dev,
2313 di->bm->fg_params->lowbat_threshold) << 1 |
2316 dev_err(di->dev, "%s write failed\n", __func__);
2321 ret = ab8500_fg_battok_init_hw_register(di);
2323 dev_err(di->dev, "BattOk init write failed.\n");
2327 if (is_ab8505(di->parent)) {
2328 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2329 AB8505_RTC_PCUT_MAX_TIME_REG, di->bm->fg_params->pcut_max_time);
2332 dev_err(di->dev, "%s write failed AB8505_RTC_PCUT_MAX_TIME_REG\n", __func__);
2336 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2337 AB8505_RTC_PCUT_FLAG_TIME_REG, di->bm->fg_params->pcut_flag_time);
2340 dev_err(di->dev, "%s write failed AB8505_RTC_PCUT_FLAG_TIME_REG\n", __func__);
2344 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2345 AB8505_RTC_PCUT_RESTART_REG, di->bm->fg_params->pcut_max_restart);
2348 dev_err(di->dev, "%s write failed AB8505_RTC_PCUT_RESTART_REG\n", __func__);
2352 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2353 AB8505_RTC_PCUT_DEBOUNCE_REG, di->bm->fg_params->pcut_debounce_time);
2356 dev_err(di->dev, "%s write failed AB8505_RTC_PCUT_DEBOUNCE_REG\n", __func__);
2360 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2361 AB8505_RTC_PCUT_CTL_STATUS_REG, di->bm->fg_params->pcut_enable);
2364 dev_err(di->dev, "%s write failed AB8505_RTC_PCUT_CTL_STATUS_REG\n", __func__);
2397 struct ab8500_fg *di = container_of(work, struct ab8500_fg,
2400 if (!di->flags.calibrate) {
2401 dev_dbg(di->dev, "Resetting FG state machine to init.\n");
2402 ab8500_fg_clear_cap_samples(di);
2403 ab8500_fg_calc_cap_discharge_voltage(di, true);
2404 ab8500_fg_charge_state_to(di, AB8500_FG_CHARGE_INIT);
2405 ab8500_fg_discharge_state_to(di, AB8500_FG_DISCHARGE_INIT);
2406 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
2409 dev_err(di->dev, "Residual offset calibration ongoing "
2412 queue_delayed_work(di->fg_wq, &di->fg_reinit_work,
2425 static ssize_t charge_full_show(struct ab8500_fg *di, char *buf)
2427 return sprintf(buf, "%d\n", di->bat_cap.max_mah);
2430 static ssize_t charge_full_store(struct ab8500_fg *di, const char *buf,
2440 di->bat_cap.max_mah = (int) charge_full;
2444 static ssize_t charge_now_show(struct ab8500_fg *di, char *buf)
2446 return sprintf(buf, "%d\n", di->bat_cap.prev_mah);
2449 static ssize_t charge_now_store(struct ab8500_fg *di, const char *buf,
2459 di->bat_cap.user_mah = (int) charge_now;
2460 di->flags.user_cap = true;
2461 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
2475 struct ab8500_fg *di;
2478 di = container_of(kobj, struct ab8500_fg, fg_kobject);
2483 return entry->show(di, buf);
2490 struct ab8500_fg *di;
2493 di = container_of(kobj, struct ab8500_fg, fg_kobject);
2498 return entry->store(di, buf, count);
2519 * @di: pointer to the struct ab8500_chargalg
2523 static void ab8500_fg_sysfs_exit(struct ab8500_fg *di)
2525 kobject_del(&di->fg_kobject);
2530 * @di: pointer to the struct ab8500_chargalg
2535 static int ab8500_fg_sysfs_init(struct ab8500_fg *di)
2539 ret = kobject_init_and_add(&di->fg_kobject,
2543 kobject_put(&di->fg_kobject);
2544 dev_err(di->dev, "failed to create sysfs entry\n");
2557 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2559 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
2580 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2590 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2607 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2609 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
2631 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2641 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2658 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2660 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
2681 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2691 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2709 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2711 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
2732 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2734 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
2755 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2757 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
2776 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2786 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2804 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2806 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
2827 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2829 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
2850 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2860 ret = abx500_set_register_interruptible(di->dev, AB8500_RTC,
2877 struct ab8500_fg *di = power_supply_get_drvdata(psy);
2879 ret = abx500_get_register_interruptible(di->dev, AB8500_RTC,
2912 static int ab8500_fg_sysfs_psy_create_attrs(struct ab8500_fg *di)
2916 if (is_ab8505(di->parent)) {
2918 if (device_create_file(&di->fg_psy->dev,
2924 dev_err(&di->fg_psy->dev, "Failed creating sysfs psy attrs for ab8505.\n");
2926 device_remove_file(&di->fg_psy->dev,
2932 static void ab8500_fg_sysfs_psy_remove_attrs(struct ab8500_fg *di)
2936 if (is_ab8505(di->parent)) {
2938 (void)device_remove_file(&di->fg_psy->dev,
2948 struct ab8500_fg *di = platform_get_drvdata(pdev);
2954 if (!di->flags.charging) {
2955 ab8500_fg_discharge_state_to(di, AB8500_FG_DISCHARGE_WAKEUP);
2956 queue_work(di->fg_wq, &di->fg_work);
2965 struct ab8500_fg *di = platform_get_drvdata(pdev);
2967 flush_delayed_work(&di->fg_periodic_work);
2968 flush_work(&di->fg_work);
2969 flush_work(&di->fg_acc_cur_work);
2970 flush_delayed_work(&di->fg_reinit_work);
2971 flush_delayed_work(&di->fg_low_bat_work);
2972 flush_delayed_work(&di->fg_check_hw_failure_work);
2978 if (di->flags.fg_enabled && !di->flags.charging)
2979 ab8500_fg_coulomb_counter(di, false);
2991 struct ab8500_fg *di = platform_get_drvdata(pdev);
2993 list_del(&di->node);
2996 ret = ab8500_fg_coulomb_counter(di, false);
2998 dev_err(di->dev, "failed to disable coulomb counter\n");
3000 destroy_workqueue(di->fg_wq);
3001 ab8500_fg_sysfs_exit(di);
3004 ab8500_fg_sysfs_psy_remove_attrs(di);
3005 power_supply_unregister(di->fg_psy);
3040 struct ab8500_fg *di;
3044 di = devm_kzalloc(&pdev->dev, sizeof(*di), GFP_KERNEL);
3045 if (!di) {
3054 di->bm = plat;
3057 ret = ab8500_bm_of_probe(&pdev->dev, np, di->bm);
3064 mutex_init(&di->cc_lock);
3067 di->dev = &pdev->dev;
3068 di->parent = dev_get_drvdata(pdev->dev.parent);
3070 di->main_bat_v = devm_iio_channel_get(&pdev->dev, "main_bat_v");
3071 if (IS_ERR(di->main_bat_v)) {
3072 if (PTR_ERR(di->main_bat_v) == -ENODEV)
3075 return PTR_ERR(di->main_bat_v);
3080 psy_cfg.drv_data = di;
3082 di->bat_cap.max_mah_design = MILLI_TO_MICRO *
3083 di->bm->bat_type[di->bm->batt_id].charge_full_design;
3085 di->bat_cap.max_mah = di->bat_cap.max_mah_design;
3087 di->vbat_nom = di->bm->bat_type[di->bm->batt_id].nominal_voltage;
3089 di->init_capacity = true;
3091 ab8500_fg_charge_state_to(di, AB8500_FG_CHARGE_INIT);
3092 ab8500_fg_discharge_state_to(di, AB8500_FG_DISCHARGE_INIT);
3095 di->fg_wq = alloc_ordered_workqueue("ab8500_fg_wq", WQ_MEM_RECLAIM);
3096 if (di->fg_wq == NULL) {
3097 dev_err(di->dev, "failed to create work queue\n");
3102 INIT_WORK(&di->fg_work, ab8500_fg_instant_work);
3105 INIT_WORK(&di->fg_acc_cur_work, ab8500_fg_acc_cur_work);
3108 INIT_DEFERRABLE_WORK(&di->fg_reinit_work,
3112 INIT_DEFERRABLE_WORK(&di->fg_periodic_work,
3116 INIT_DEFERRABLE_WORK(&di->fg_low_bat_work,
3120 INIT_DEFERRABLE_WORK(&di->fg_check_hw_failure_work,
3124 di->flags.low_bat = false;
3127 di->low_bat_cnt = 10;
3130 ret = ab8500_fg_init_hw_registers(di);
3132 dev_err(di->dev, "failed to initialize registers\n");
3137 di->flags.batt_unknown = true;
3138 di->flags.batt_id_received = false;
3141 di->fg_psy = power_supply_register(di->dev, &ab8500_fg_desc, &psy_cfg);
3142 if (IS_ERR(di->fg_psy)) {
3143 dev_err(di->dev, "failed to register FG psy\n");
3144 ret = PTR_ERR(di->fg_psy);
3148 di->fg_samples = SEC_TO_SAMPLE(di->bm->fg_params->init_timer);
3149 ab8500_fg_coulomb_counter(di, true);
3155 init_completion(&di->ab8500_fg_started);
3156 init_completion(&di->ab8500_fg_complete);
3168 ab8500_fg_irq_th[i].name, di);
3171 dev_err(di->dev, "failed to request %s IRQ %d: %d\n",
3175 dev_dbg(di->dev, "Requested %s IRQ %d: %d\n",
3188 ab8500_fg_irq_bh[0].name, di);
3191 dev_err(di->dev, "failed to request %s IRQ %d: %d\n",
3195 dev_dbg(di->dev, "Requested %s IRQ %d: %d\n",
3198 di->irq = platform_get_irq_byname(pdev, "CCEOC");
3199 disable_irq(di->irq);
3200 di->nbr_cceoc_irq_cnt = 0;
3202 platform_set_drvdata(pdev, di);
3204 ret = ab8500_fg_sysfs_init(di);
3206 dev_err(di->dev, "failed to create sysfs entry\n");
3210 ret = ab8500_fg_sysfs_psy_create_attrs(di);
3212 dev_err(di->dev, "failed to create FG psy\n");
3213 ab8500_fg_sysfs_exit(di);
3218 di->flags.calibrate = true;
3219 di->calib_state = AB8500_FG_CALIB_INIT;
3222 di->bat_temp = 210;
3225 queue_delayed_work(di->fg_wq, &di->fg_periodic_work, 0);
3227 list_add_tail(&di->node, &ab8500_fg_list);
3234 free_irq(irq, di);
3239 free_irq(irq, di);
3242 power_supply_unregister(di->fg_psy);
3244 destroy_workqueue(di->fg_wq);