Lines Matching refs:di
265 struct ab8500_chargalg *di = container_of(timer, struct ab8500_chargalg,
267 dev_err(di->dev, "Safety timer expired\n");
268 di->events.safety_timer_expired = true;
271 queue_work(di->chargalg_wq, &di->chargalg_work);
288 struct ab8500_chargalg *di = container_of(timer, struct ab8500_chargalg,
291 dev_dbg(di->dev, "Maintenance timer expired\n");
292 di->events.maintenance_timer_expired = true;
295 queue_work(di->chargalg_wq, &di->chargalg_work);
302 * @di: pointer to the ab8500_chargalg structure
306 static void ab8500_chargalg_state_to(struct ab8500_chargalg *di,
309 dev_dbg(di->dev,
311 di->charge_state == state ? "NO" : "YES",
312 di->charge_state,
313 states[di->charge_state],
317 di->charge_state = state;
320 static int ab8500_chargalg_check_charger_enable(struct ab8500_chargalg *di)
322 struct power_supply_battery_info *bi = di->bm->bi;
324 switch (di->charge_state) {
333 if (di->chg_info.charger_type & USB_CHG) {
334 return di->usb_chg->ops.check_enable(di->usb_chg,
337 } else if (di->chg_info.charger_type & AC_CHG) {
338 return di->ac_chg->ops.check_enable(di->ac_chg,
347 * @di: pointer to the ab8500_chargalg structure
352 static int ab8500_chargalg_check_charger_connection(struct ab8500_chargalg *di)
354 if (di->chg_info.conn_chg != di->chg_info.prev_conn_chg) {
356 if (di->chg_info.conn_chg & AC_CHG) {
357 dev_info(di->dev, "Charging source is AC\n");
358 if (di->chg_info.charger_type != AC_CHG) {
359 di->chg_info.charger_type = AC_CHG;
360 ab8500_chargalg_state_to(di, STATE_NORMAL_INIT);
362 } else if (di->chg_info.conn_chg & USB_CHG) {
363 dev_info(di->dev, "Charging source is USB\n");
364 di->chg_info.charger_type = USB_CHG;
365 ab8500_chargalg_state_to(di, STATE_NORMAL_INIT);
367 dev_dbg(di->dev, "Charging source is OFF\n");
368 di->chg_info.charger_type = NO_CHG;
369 ab8500_chargalg_state_to(di, STATE_HANDHELD_INIT);
371 di->chg_info.prev_conn_chg = di->chg_info.conn_chg;
373 return di->chg_info.conn_chg;
378 * @di: pointer to the ab8500_chargalg structure
383 static void ab8500_chargalg_start_safety_timer(struct ab8500_chargalg *di)
388 switch (di->chg_info.charger_type) {
390 timer_expiration = di->bm->main_safety_tmr_h;
394 timer_expiration = di->bm->usb_safety_tmr_h;
398 dev_err(di->dev, "Unknown charger to charge from\n");
402 di->events.safety_timer_expired = false;
403 hrtimer_set_expires_range(&di->safety_timer,
406 hrtimer_start_expires(&di->safety_timer, HRTIMER_MODE_REL);
411 * @di: pointer to the ab8500_chargalg structure
415 static void ab8500_chargalg_stop_safety_timer(struct ab8500_chargalg *di)
417 if (hrtimer_try_to_cancel(&di->safety_timer) >= 0)
418 di->events.safety_timer_expired = false;
423 * @di: pointer to the ab8500_chargalg structure
430 static void ab8500_chargalg_start_maintenance_timer(struct ab8500_chargalg *di,
434 hrtimer_set_expires_range(&di->maintenance_timer,
437 di->events.maintenance_timer_expired = false;
438 hrtimer_start_expires(&di->maintenance_timer, HRTIMER_MODE_REL);
443 * @di: pointer to the ab8500_chargalg structure
448 static void ab8500_chargalg_stop_maintenance_timer(struct ab8500_chargalg *di)
450 if (hrtimer_try_to_cancel(&di->maintenance_timer) >= 0)
451 di->events.maintenance_timer_expired = false;
456 * @di: pointer to the ab8500_chargalg structure
461 static int ab8500_chargalg_kick_watchdog(struct ab8500_chargalg *di)
464 if (di->ac_chg && di->ac_chg->ops.kick_wd &&
465 di->chg_info.online_chg & AC_CHG) {
466 return di->ac_chg->ops.kick_wd(di->ac_chg);
467 } else if (di->usb_chg && di->usb_chg->ops.kick_wd &&
468 di->chg_info.online_chg & USB_CHG)
469 return di->usb_chg->ops.kick_wd(di->usb_chg);
476 * @di: pointer to the ab8500_chargalg structure
484 static int ab8500_chargalg_ac_en(struct ab8500_chargalg *di, int enable,
487 if (!di->ac_chg || !di->ac_chg->ops.enable)
491 if (di->ac_chg->max_out_volt_uv)
492 vset_uv = min(vset_uv, di->ac_chg->max_out_volt_uv);
493 if (di->ac_chg->max_out_curr_ua)
494 iset_ua = min(iset_ua, di->ac_chg->max_out_curr_ua);
496 di->chg_info.ac_iset_ua = iset_ua;
497 di->chg_info.ac_vset_uv = vset_uv;
499 return di->ac_chg->ops.enable(di->ac_chg, enable, vset_uv, iset_ua);
504 * @di: pointer to the ab8500_chargalg structure
512 static int ab8500_chargalg_usb_en(struct ab8500_chargalg *di, int enable,
515 if (!di->usb_chg || !di->usb_chg->ops.enable)
519 if (di->usb_chg->max_out_volt_uv)
520 vset_uv = min(vset_uv, di->usb_chg->max_out_volt_uv);
521 if (di->usb_chg->max_out_curr_ua)
522 iset_ua = min(iset_ua, di->usb_chg->max_out_curr_ua);
524 di->chg_info.usb_iset_ua = iset_ua;
525 di->chg_info.usb_vset_uv = vset_uv;
527 return di->usb_chg->ops.enable(di->usb_chg, enable, vset_uv, iset_ua);
532 * @di: pointer to the ab8500_chargalg structure
538 static int ab8500_chargalg_update_chg_curr(struct ab8500_chargalg *di,
542 if (di->ac_chg && di->ac_chg->ops.update_curr &&
543 di->chg_info.charger_type & AC_CHG) {
548 if (di->ac_chg->max_out_curr_ua)
549 iset_ua = min(iset_ua, di->ac_chg->max_out_curr_ua);
551 di->chg_info.ac_iset_ua = iset_ua;
553 return di->ac_chg->ops.update_curr(di->ac_chg, iset_ua);
554 } else if (di->usb_chg && di->usb_chg->ops.update_curr &&
555 di->chg_info.charger_type & USB_CHG) {
560 if (di->usb_chg->max_out_curr_ua)
561 iset_ua = min(iset_ua, di->usb_chg->max_out_curr_ua);
563 di->chg_info.usb_iset_ua = iset_ua;
565 return di->usb_chg->ops.update_curr(di->usb_chg, iset_ua);
573 * @di: pointer to the ab8500_chargalg structure
579 static void ab8500_chargalg_stop_charging(struct ab8500_chargalg *di)
581 ab8500_chargalg_ac_en(di, false, 0, 0);
582 ab8500_chargalg_usb_en(di, false, 0, 0);
583 ab8500_chargalg_stop_safety_timer(di);
584 ab8500_chargalg_stop_maintenance_timer(di);
585 di->charge_status = POWER_SUPPLY_STATUS_NOT_CHARGING;
586 di->maintenance_chg = false;
587 cancel_delayed_work(&di->chargalg_wd_work);
588 power_supply_changed(di->chargalg_psy);
593 * @di: pointer to the ab8500_chargalg structure
599 static void ab8500_chargalg_hold_charging(struct ab8500_chargalg *di)
601 ab8500_chargalg_ac_en(di, false, 0, 0);
602 ab8500_chargalg_usb_en(di, false, 0, 0);
603 ab8500_chargalg_stop_safety_timer(di);
604 ab8500_chargalg_stop_maintenance_timer(di);
605 di->charge_status = POWER_SUPPLY_STATUS_CHARGING;
606 di->maintenance_chg = false;
607 cancel_delayed_work(&di->chargalg_wd_work);
608 power_supply_changed(di->chargalg_psy);
613 * @di: pointer to the ab8500_chargalg structure
620 static void ab8500_chargalg_start_charging(struct ab8500_chargalg *di,
623 switch (di->chg_info.charger_type) {
625 dev_dbg(di->dev,
627 ab8500_chargalg_usb_en(di, false, 0, 0);
628 ab8500_chargalg_ac_en(di, true, vset_uv, iset_ua);
632 dev_dbg(di->dev,
634 ab8500_chargalg_ac_en(di, false, 0, 0);
635 ab8500_chargalg_usb_en(di, true, vset_uv, iset_ua);
639 dev_err(di->dev, "Unknown charger to charge from\n");
646 * @di: pointer to the ab8500_chargalg structure
651 static void ab8500_chargalg_check_temp(struct ab8500_chargalg *di)
653 struct power_supply_battery_info *bi = di->bm->bi;
655 if (di->batt_data.temp > (bi->temp_alert_min + di->t_hyst_norm) &&
656 di->batt_data.temp < (bi->temp_alert_max - di->t_hyst_norm)) {
658 di->events.btemp_underover = false;
659 di->events.btemp_low = false;
660 di->events.btemp_high = false;
661 di->t_hyst_norm = 0;
662 di->t_hyst_lowhigh = 0;
664 if ((di->batt_data.temp >= bi->temp_alert_max) &&
665 (di->batt_data.temp < (bi->temp_max - di->t_hyst_lowhigh))) {
667 di->events.btemp_underover = false;
668 di->events.btemp_high = true;
669 di->t_hyst_norm = di->bm->temp_hysteresis;
670 di->t_hyst_lowhigh = 0;
671 } else if ((di->batt_data.temp > (bi->temp_min + di->t_hyst_lowhigh)) &&
672 (di->batt_data.temp <= bi->temp_alert_min)) {
674 di->events.btemp_underover = false;
675 di->events.btemp_low = true;
676 di->t_hyst_norm = di->bm->temp_hysteresis;
677 di->t_hyst_lowhigh = 0;
678 } else if (di->batt_data.temp <= bi->temp_min ||
679 di->batt_data.temp >= bi->temp_max) {
681 di->events.btemp_underover = true;
682 di->events.btemp_low = false;
683 di->events.btemp_high = false;
684 di->t_hyst_norm = 0;
685 di->t_hyst_lowhigh = di->bm->temp_hysteresis;
688 dev_dbg(di->dev, "Within hysteresis limit temp: %d "
690 di->batt_data.temp, di->t_hyst_lowhigh,
691 di->t_hyst_norm);
698 * @di: pointer to the ab8500_chargalg structure
702 static void ab8500_chargalg_check_charger_voltage(struct ab8500_chargalg *di)
704 if (di->chg_info.usb_volt_uv > di->bm->chg_params->usb_volt_max_uv)
705 di->chg_info.usb_chg_ok = false;
707 di->chg_info.usb_chg_ok = true;
709 if (di->chg_info.ac_volt_uv > di->bm->chg_params->ac_volt_max_uv)
710 di->chg_info.ac_chg_ok = false;
712 di->chg_info.ac_chg_ok = true;
718 * @di: pointer to the ab8500_chargalg structure
724 static void ab8500_chargalg_end_of_charge(struct ab8500_chargalg *di)
726 if (di->charge_status == POWER_SUPPLY_STATUS_CHARGING &&
727 di->charge_state == STATE_NORMAL &&
728 !di->maintenance_chg && (di->batt_data.volt_uv >=
729 di->bm->bi->voltage_max_design_uv ||
730 di->events.usb_cv_active || di->events.ac_cv_active) &&
731 di->batt_data.avg_curr_ua <
732 di->bm->bi->charge_term_current_ua &&
733 di->batt_data.avg_curr_ua > 0) {
734 if (++di->eoc_cnt >= EOC_COND_CNT) {
735 di->eoc_cnt = 0;
736 di->charge_status = POWER_SUPPLY_STATUS_FULL;
737 di->maintenance_chg = true;
738 dev_dbg(di->dev, "EOC reached!\n");
739 power_supply_changed(di->chargalg_psy);
741 dev_dbg(di->dev,
744 di->eoc_cnt,
748 di->eoc_cnt = 0;
752 static void init_maxim_chg_curr(struct ab8500_chargalg *di)
754 struct power_supply_battery_info *bi = di->bm->bi;
756 di->ccm.original_iset_ua = bi->constant_charge_current_max_ua;
757 di->ccm.current_iset_ua = bi->constant_charge_current_max_ua;
758 di->ccm.max_current_ua = di->bm->maxi->chg_curr_ua;
759 di->ccm.condition_cnt = di->bm->maxi->wait_cycles;
760 di->ccm.level = 0;
766 * @di pointer to the ab8500_chargalg structure
772 static enum maxim_ret ab8500_chargalg_chg_curr_maxim(struct ab8500_chargalg *di)
775 if (!di->bm->maxi->ena_maxi)
778 if (di->events.vbus_collapsed) {
779 dev_dbg(di->dev, "Charger voltage has collapsed %d\n",
780 di->ccm.wait_cnt);
781 if (di->ccm.wait_cnt == 0) {
782 dev_dbg(di->dev, "lowering current\n");
783 di->ccm.wait_cnt++;
784 di->ccm.condition_cnt = di->bm->maxi->wait_cycles;
785 di->ccm.max_current_ua = di->ccm.current_iset_ua;
786 di->ccm.current_iset_ua = di->ccm.max_current_ua;
787 di->ccm.level--;
790 dev_dbg(di->dev, "waiting\n");
792 di->ccm.wait_cnt = (di->ccm.wait_cnt + 1) % 3;
797 di->ccm.wait_cnt = 0;
799 if (di->batt_data.inst_curr_ua > di->ccm.original_iset_ua) {
800 dev_dbg(di->dev, " Maximization Ibat (%duA) too high"
802 di->batt_data.inst_curr_ua, di->ccm.original_iset_ua,
803 di->ccm.current_iset_ua);
805 if (di->ccm.current_iset_ua == di->ccm.original_iset_ua)
808 di->ccm.condition_cnt = di->bm->maxi->wait_cycles;
809 di->ccm.current_iset_ua = di->ccm.original_iset_ua;
810 di->ccm.level = 0;
815 di->ccm.condition_cnt = di->bm->maxi->wait_cycles;
819 static void handle_maxim_chg_curr(struct ab8500_chargalg *di)
821 struct power_supply_battery_info *bi = di->bm->bi;
825 ret = ab8500_chargalg_chg_curr_maxim(di);
828 result = ab8500_chargalg_update_chg_curr(di,
829 di->ccm.current_iset_ua);
831 dev_err(di->dev, "failed to set chg curr\n");
834 result = ab8500_chargalg_update_chg_curr(di,
837 dev_err(di->dev, "failed to set chg curr\n");
852 struct ab8500_chargalg *di;
858 di = power_supply_get_drvdata(psy);
870 di->batt_data.percent = ret.intval;
882 if (!di->ac_chg &&
884 di->ac_chg = psy_to_ux500_charger(ext);
885 else if (!di->usb_chg &&
887 di->usb_chg = psy_to_ux500_charger(ext);
897 di->events.batt_rem = false;
900 di->events.batt_rem = true;
905 (di->chg_info.conn_chg & AC_CHG)) {
906 di->chg_info.prev_conn_chg =
907 di->chg_info.conn_chg;
908 di->chg_info.conn_chg &= ~AC_CHG;
912 !(di->chg_info.conn_chg & AC_CHG)) {
913 di->chg_info.prev_conn_chg =
914 di->chg_info.conn_chg;
915 di->chg_info.conn_chg |= AC_CHG;
921 (di->chg_info.conn_chg & USB_CHG)) {
922 di->chg_info.prev_conn_chg =
923 di->chg_info.conn_chg;
924 di->chg_info.conn_chg &= ~USB_CHG;
928 !(di->chg_info.conn_chg & USB_CHG)) {
929 di->chg_info.prev_conn_chg =
930 di->chg_info.conn_chg;
931 di->chg_info.conn_chg |= USB_CHG;
946 (di->chg_info.online_chg & AC_CHG)) {
947 di->chg_info.prev_online_chg =
948 di->chg_info.online_chg;
949 di->chg_info.online_chg &= ~AC_CHG;
953 !(di->chg_info.online_chg & AC_CHG)) {
954 di->chg_info.prev_online_chg =
955 di->chg_info.online_chg;
956 di->chg_info.online_chg |= AC_CHG;
957 queue_delayed_work(di->chargalg_wq,
958 &di->chargalg_wd_work, 0);
964 (di->chg_info.online_chg & USB_CHG)) {
965 di->chg_info.prev_online_chg =
966 di->chg_info.online_chg;
967 di->chg_info.online_chg &= ~USB_CHG;
971 !(di->chg_info.online_chg & USB_CHG)) {
972 di->chg_info.prev_online_chg =
973 di->chg_info.online_chg;
974 di->chg_info.online_chg |= USB_CHG;
975 queue_delayed_work(di->chargalg_wq,
976 &di->chargalg_wd_work, 0);
991 di->events.mainextchnotok = true;
992 di->events.main_thermal_prot = false;
993 di->events.main_ovv = false;
994 di->events.ac_wd_expired = false;
997 di->events.ac_wd_expired = true;
998 di->events.mainextchnotok = false;
999 di->events.main_ovv = false;
1000 di->events.main_thermal_prot = false;
1004 di->events.main_thermal_prot = true;
1005 di->events.mainextchnotok = false;
1006 di->events.main_ovv = false;
1007 di->events.ac_wd_expired = false;
1010 di->events.main_ovv = true;
1011 di->events.mainextchnotok = false;
1012 di->events.main_thermal_prot = false;
1013 di->events.ac_wd_expired = false;
1016 di->events.main_thermal_prot = false;
1017 di->events.mainextchnotok = false;
1018 di->events.main_ovv = false;
1019 di->events.ac_wd_expired = false;
1029 di->events.usbchargernotok = true;
1030 di->events.usb_thermal_prot = false;
1031 di->events.vbus_ovv = false;
1032 di->events.usb_wd_expired = false;
1035 di->events.usb_wd_expired = true;
1036 di->events.usbchargernotok = false;
1037 di->events.usb_thermal_prot = false;
1038 di->events.vbus_ovv = false;
1042 di->events.usb_thermal_prot = true;
1043 di->events.usbchargernotok = false;
1044 di->events.vbus_ovv = false;
1045 di->events.usb_wd_expired = false;
1048 di->events.vbus_ovv = true;
1049 di->events.usbchargernotok = false;
1050 di->events.usb_thermal_prot = false;
1051 di->events.usb_wd_expired = false;
1054 di->events.usbchargernotok = false;
1055 di->events.usb_thermal_prot = false;
1056 di->events.vbus_ovv = false;
1057 di->events.usb_wd_expired = false;
1071 di->batt_data.volt_uv = ret.intval;
1074 di->chg_info.ac_volt_uv = ret.intval;
1077 di->chg_info.usb_volt_uv = ret.intval;
1090 di->events.ac_cv_active = true;
1092 di->events.ac_cv_active = false;
1099 di->events.usb_cv_active = true;
1101 di->events.usb_cv_active = false;
1113 di->events.batt_unknown = false;
1115 di->events.batt_unknown = true;
1124 di->batt_data.temp = ret.intval / 10;
1130 di->chg_info.ac_curr_ua = ret.intval;
1133 di->chg_info.usb_curr_ua = ret.intval;
1136 di->batt_data.inst_curr_ua = ret.intval;
1146 di->batt_data.avg_curr_ua = ret.intval;
1150 di->events.vbus_collapsed = true;
1152 di->events.vbus_collapsed = false;
1160 di->batt_data.percent = ret.intval;
1180 struct ab8500_chargalg *di = power_supply_get_drvdata(psy);
1186 if (di->chargalg_wq)
1187 queue_work(di->chargalg_wq, &di->chargalg_work);
1192 * @di: charging algorithm state
1197 static bool ab8500_chargalg_time_to_restart(struct ab8500_chargalg *di)
1199 struct power_supply_battery_info *bi = di->bm->bi;
1202 if (!di->batt_data.volt_uv || !di->batt_data.percent)
1207 if (di->batt_data.volt_uv <= bi->charge_restart_voltage_uv)
1211 if (di->batt_data.percent <= AB8500_RECHARGE_CAP)
1220 * @di: pointer to the ab8500_chargalg structure
1226 static void ab8500_chargalg_algorithm(struct ab8500_chargalg *di)
1228 struct power_supply_battery_info *bi = di->bm->bi;
1235 di->chargalg_psy, ab8500_chargalg_get_ext_psy_data);
1237 ab8500_chargalg_end_of_charge(di);
1238 ab8500_chargalg_check_temp(di);
1239 ab8500_chargalg_check_charger_voltage(di);
1241 charger_status = ab8500_chargalg_check_charger_connection(di);
1243 if (is_ab8500(di->parent)) {
1244 ret = ab8500_chargalg_check_charger_enable(di);
1246 dev_err(di->dev, "Checking charger is enabled error"
1256 (di->events.batt_unknown && !di->bm->chg_unknown_bat)) {
1257 if (di->charge_state != STATE_HANDHELD) {
1258 di->events.safety_timer_expired = false;
1259 ab8500_chargalg_state_to(di, STATE_HANDHELD_INIT);
1264 else if (di->events.safety_timer_expired) {
1265 if (di->charge_state != STATE_SAFETY_TIMER_EXPIRED)
1266 ab8500_chargalg_state_to(di,
1275 else if (di->events.batt_rem) {
1276 if (di->charge_state != STATE_BATT_REMOVED)
1277 ab8500_chargalg_state_to(di, STATE_BATT_REMOVED_INIT);
1280 else if (di->events.mainextchnotok || di->events.usbchargernotok) {
1285 if (di->charge_state != STATE_CHG_NOT_OK &&
1286 !di->events.vbus_collapsed)
1287 ab8500_chargalg_state_to(di, STATE_CHG_NOT_OK_INIT);
1290 else if (di->events.vbus_ovv ||
1291 di->events.main_ovv ||
1292 di->events.batt_ovv ||
1293 !di->chg_info.usb_chg_ok ||
1294 !di->chg_info.ac_chg_ok) {
1295 if (di->charge_state != STATE_OVV_PROTECT)
1296 ab8500_chargalg_state_to(di, STATE_OVV_PROTECT_INIT);
1299 else if (di->events.main_thermal_prot ||
1300 di->events.usb_thermal_prot) {
1301 if (di->charge_state != STATE_HW_TEMP_PROTECT)
1302 ab8500_chargalg_state_to(di,
1306 else if (di->events.btemp_underover) {
1307 if (di->charge_state != STATE_TEMP_UNDEROVER)
1308 ab8500_chargalg_state_to(di,
1312 else if (di->events.ac_wd_expired ||
1313 di->events.usb_wd_expired) {
1314 if (di->charge_state != STATE_WD_EXPIRED)
1315 ab8500_chargalg_state_to(di, STATE_WD_EXPIRED_INIT);
1318 else if (di->events.btemp_low || di->events.btemp_high) {
1319 if (di->charge_state != STATE_TEMP_LOWHIGH)
1320 ab8500_chargalg_state_to(di, STATE_TEMP_LOWHIGH_INIT);
1323 dev_dbg(di->dev,
1328 di->batt_data.volt_uv,
1329 di->batt_data.avg_curr_ua,
1330 di->batt_data.inst_curr_ua,
1331 di->batt_data.temp,
1332 di->batt_data.percent,
1333 di->maintenance_chg,
1334 states[di->charge_state],
1335 di->chg_info.charger_type,
1336 di->charge_status,
1337 di->chg_info.conn_chg & AC_CHG,
1338 di->chg_info.conn_chg & USB_CHG,
1339 di->chg_info.online_chg & AC_CHG,
1340 di->chg_info.online_chg & USB_CHG,
1341 di->events.ac_cv_active,
1342 di->events.usb_cv_active,
1343 di->chg_info.ac_curr_ua,
1344 di->chg_info.usb_curr_ua,
1345 di->chg_info.ac_vset_uv,
1346 di->chg_info.ac_iset_ua,
1347 di->chg_info.usb_vset_uv,
1348 di->chg_info.usb_iset_ua);
1350 switch (di->charge_state) {
1352 ab8500_chargalg_stop_charging(di);
1353 di->charge_status = POWER_SUPPLY_STATUS_DISCHARGING;
1354 ab8500_chargalg_state_to(di, STATE_HANDHELD);
1361 ab8500_chargalg_stop_charging(di);
1362 ab8500_chargalg_state_to(di, STATE_BATT_REMOVED);
1366 if (!di->events.batt_rem)
1367 ab8500_chargalg_state_to(di, STATE_NORMAL_INIT);
1371 ab8500_chargalg_stop_charging(di);
1372 ab8500_chargalg_state_to(di, STATE_HW_TEMP_PROTECT);
1376 if (!di->events.main_thermal_prot &&
1377 !di->events.usb_thermal_prot)
1378 ab8500_chargalg_state_to(di, STATE_NORMAL_INIT);
1382 ab8500_chargalg_stop_charging(di);
1383 ab8500_chargalg_state_to(di, STATE_OVV_PROTECT);
1387 if (!di->events.vbus_ovv &&
1388 !di->events.main_ovv &&
1389 !di->events.batt_ovv &&
1390 di->chg_info.usb_chg_ok &&
1391 di->chg_info.ac_chg_ok)
1392 ab8500_chargalg_state_to(di, STATE_NORMAL_INIT);
1396 ab8500_chargalg_stop_charging(di);
1397 ab8500_chargalg_state_to(di, STATE_CHG_NOT_OK);
1401 if (!di->events.mainextchnotok &&
1402 !di->events.usbchargernotok)
1403 ab8500_chargalg_state_to(di, STATE_NORMAL_INIT);
1407 ab8500_chargalg_stop_charging(di);
1408 ab8500_chargalg_state_to(di, STATE_SAFETY_TIMER_EXPIRED);
1418 ab8500_chargalg_stop_charging(di);
1420 ab8500_chargalg_start_charging(di,
1425 ab8500_chargalg_state_to(di, STATE_NORMAL);
1426 ab8500_chargalg_start_safety_timer(di);
1427 ab8500_chargalg_stop_maintenance_timer(di);
1428 init_maxim_chg_curr(di);
1429 di->charge_status = POWER_SUPPLY_STATUS_CHARGING;
1430 di->eoc_cnt = 0;
1431 di->maintenance_chg = false;
1432 power_supply_changed(di->chargalg_psy);
1437 handle_maxim_chg_curr(di);
1438 if (di->charge_status == POWER_SUPPLY_STATUS_FULL &&
1439 di->maintenance_chg) {
1446 ab8500_chargalg_state_to(di,
1449 ab8500_chargalg_state_to(di,
1456 ab8500_chargalg_hold_charging(di);
1457 ab8500_chargalg_state_to(di, STATE_WAIT_FOR_RECHARGE);
1461 if (ab8500_chargalg_time_to_restart(di))
1462 ab8500_chargalg_state_to(di, STATE_NORMAL_INIT);
1469 ab8500_chargalg_state_to(di, STATE_NORMAL_INIT);
1470 power_supply_changed(di->chargalg_psy);
1473 ab8500_chargalg_stop_safety_timer(di);
1474 ab8500_chargalg_start_maintenance_timer(di,
1476 ab8500_chargalg_start_charging(di,
1479 ab8500_chargalg_state_to(di, STATE_MAINTENANCE_A);
1480 power_supply_changed(di->chargalg_psy);
1484 if (di->events.maintenance_timer_expired) {
1485 ab8500_chargalg_stop_maintenance_timer(di);
1486 ab8500_chargalg_state_to(di, STATE_MAINTENANCE_B_INIT);
1492 if (ab8500_chargalg_time_to_restart(di)) {
1493 ab8500_chargalg_state_to(di, STATE_NORMAL_INIT);
1494 dev_info(di->dev, "restarted charging from maintenance state A - battery getting old?\n");
1502 ab8500_chargalg_state_to(di, STATE_NORMAL_INIT);
1503 power_supply_changed(di->chargalg_psy);
1506 ab8500_chargalg_start_maintenance_timer(di,
1508 ab8500_chargalg_start_charging(di,
1511 ab8500_chargalg_state_to(di, STATE_MAINTENANCE_B);
1512 power_supply_changed(di->chargalg_psy);
1516 if (di->events.maintenance_timer_expired) {
1517 ab8500_chargalg_stop_maintenance_timer(di);
1518 ab8500_chargalg_state_to(di, STATE_NORMAL_INIT);
1524 if (ab8500_chargalg_time_to_restart(di)) {
1525 ab8500_chargalg_state_to(di, STATE_NORMAL_INIT);
1526 dev_info(di->dev, "restarted charging from maintenance state B - battery getting old?\n");
1531 if (di->events.btemp_low) {
1532 ab8500_chargalg_start_charging(di,
1535 } else if (di->events.btemp_high) {
1536 ab8500_chargalg_start_charging(di,
1540 dev_err(di->dev, "neither low or high temp event occurred\n");
1541 ab8500_chargalg_state_to(di, STATE_NORMAL_INIT);
1544 ab8500_chargalg_stop_maintenance_timer(di);
1545 di->charge_status = POWER_SUPPLY_STATUS_CHARGING;
1546 ab8500_chargalg_state_to(di, STATE_TEMP_LOWHIGH);
1547 power_supply_changed(di->chargalg_psy);
1551 if (!di->events.btemp_low && !di->events.btemp_high)
1552 ab8500_chargalg_state_to(di, STATE_NORMAL_INIT);
1556 ab8500_chargalg_stop_charging(di);
1557 ab8500_chargalg_state_to(di, STATE_WD_EXPIRED);
1561 if (!di->events.ac_wd_expired &&
1562 !di->events.usb_wd_expired)
1563 ab8500_chargalg_state_to(di, STATE_NORMAL_INIT);
1567 ab8500_chargalg_stop_charging(di);
1568 ab8500_chargalg_state_to(di, STATE_TEMP_UNDEROVER);
1572 if (!di->events.btemp_underover)
1573 ab8500_chargalg_state_to(di, STATE_NORMAL_INIT);
1578 if (di->charge_state == STATE_NORMAL_INIT ||
1579 di->charge_state == STATE_MAINTENANCE_A_INIT ||
1580 di->charge_state == STATE_MAINTENANCE_B_INIT)
1581 queue_work(di->chargalg_wq, &di->chargalg_work);
1592 struct ab8500_chargalg *di = container_of(work,
1595 ab8500_chargalg_algorithm(di);
1601 if (di->chg_info.conn_chg)
1602 queue_delayed_work(di->chargalg_wq,
1603 &di->chargalg_periodic_work,
1604 di->bm->interval_charging * HZ);
1606 queue_delayed_work(di->chargalg_wq,
1607 &di->chargalg_periodic_work,
1608 di->bm->interval_not_charging * HZ);
1620 struct ab8500_chargalg *di = container_of(work,
1623 ret = ab8500_chargalg_kick_watchdog(di);
1625 dev_err(di->dev, "failed to kick watchdog\n");
1627 queue_delayed_work(di->chargalg_wq,
1628 &di->chargalg_wd_work, CHG_WD_INTERVAL);
1639 struct ab8500_chargalg *di = container_of(work,
1642 ab8500_chargalg_algorithm(di);
1661 struct ab8500_chargalg *di = power_supply_get_drvdata(psy);
1665 val->intval = di->charge_status;
1668 if (di->events.batt_ovv) {
1670 } else if (di->events.btemp_underover) {
1671 if (di->batt_data.temp <= di->bm->bi->temp_min)
1675 } else if (di->charge_state == STATE_SAFETY_TIMER_EXPIRED ||
1676 di->charge_state == STATE_SAFETY_TIMER_EXPIRED_INIT) {
1690 struct ab8500_chargalg *di = dev_get_drvdata(dev);
1693 if (di->chg_info.online_chg)
1694 queue_delayed_work(di->chargalg_wq, &di->chargalg_wd_work, 0);
1700 queue_delayed_work(di->chargalg_wq, &di->chargalg_periodic_work, 0);
1707 struct ab8500_chargalg *di = dev_get_drvdata(dev);
1709 if (di->chg_info.online_chg)
1710 cancel_delayed_work_sync(&di->chargalg_wd_work);
1712 cancel_delayed_work_sync(&di->chargalg_periodic_work);
1733 struct ab8500_chargalg *di = dev_get_drvdata(dev);
1736 di->chargalg_wq = alloc_ordered_workqueue("ab8500_chargalg_wq",
1738 if (di->chargalg_wq == NULL) {
1739 dev_err(di->dev, "failed to create work queue\n");
1744 queue_delayed_work(di->chargalg_wq, &di->chargalg_periodic_work, 0);
1752 struct ab8500_chargalg *di = dev_get_drvdata(dev);
1755 hrtimer_cancel(&di->safety_timer);
1756 hrtimer_cancel(&di->maintenance_timer);
1758 cancel_delayed_work_sync(&di->chargalg_periodic_work);
1759 cancel_delayed_work_sync(&di->chargalg_wd_work);
1760 cancel_work_sync(&di->chargalg_work);
1763 destroy_workqueue(di->chargalg_wq);
1775 struct ab8500_chargalg *di;
1777 di = devm_kzalloc(dev, sizeof(*di), GFP_KERNEL);
1778 if (!di)
1781 di->bm = &ab8500_bm_data;
1784 di->dev = dev;
1785 di->parent = dev_get_drvdata(pdev->dev.parent);
1789 psy_cfg.drv_data = di;
1792 hrtimer_init(&di->safety_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
1793 di->safety_timer.function = ab8500_chargalg_safety_timer_expired;
1796 hrtimer_init(&di->maintenance_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
1797 di->maintenance_timer.function =
1801 INIT_DEFERRABLE_WORK(&di->chargalg_periodic_work,
1803 INIT_DEFERRABLE_WORK(&di->chargalg_wd_work,
1807 INIT_WORK(&di->chargalg_work, ab8500_chargalg_work);
1810 di->chg_info.prev_conn_chg = -1;
1813 di->chargalg_psy = devm_power_supply_register(di->dev,
1816 if (IS_ERR(di->chargalg_psy)) {
1817 dev_err(di->dev, "failed to register chargalg psy\n");
1818 return PTR_ERR(di->chargalg_psy);
1821 platform_set_drvdata(pdev, di);
1823 dev_info(di->dev, "probe success\n");