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;
1234 power_supply_for_each_device(di->chargalg_psy, ab8500_chargalg_get_ext_psy_data);
1236 ab8500_chargalg_end_of_charge(di);
1237 ab8500_chargalg_check_temp(di);
1238 ab8500_chargalg_check_charger_voltage(di);
1240 charger_status = ab8500_chargalg_check_charger_connection(di);
1242 if (is_ab8500(di->parent)) {
1243 ret = ab8500_chargalg_check_charger_enable(di);
1245 dev_err(di->dev, "Checking charger is enabled error"
1255 (di->events.batt_unknown && !di->bm->chg_unknown_bat)) {
1256 if (di->charge_state != STATE_HANDHELD) {
1257 di->events.safety_timer_expired = false;
1258 ab8500_chargalg_state_to(di, STATE_HANDHELD_INIT);
1263 else if (di->events.safety_timer_expired) {
1264 if (di->charge_state != STATE_SAFETY_TIMER_EXPIRED)
1265 ab8500_chargalg_state_to(di,
1274 else if (di->events.batt_rem) {
1275 if (di->charge_state != STATE_BATT_REMOVED)
1276 ab8500_chargalg_state_to(di, STATE_BATT_REMOVED_INIT);
1279 else if (di->events.mainextchnotok || di->events.usbchargernotok) {
1284 if (di->charge_state != STATE_CHG_NOT_OK &&
1285 !di->events.vbus_collapsed)
1286 ab8500_chargalg_state_to(di, STATE_CHG_NOT_OK_INIT);
1289 else if (di->events.vbus_ovv ||
1290 di->events.main_ovv ||
1291 di->events.batt_ovv ||
1292 !di->chg_info.usb_chg_ok ||
1293 !di->chg_info.ac_chg_ok) {
1294 if (di->charge_state != STATE_OVV_PROTECT)
1295 ab8500_chargalg_state_to(di, STATE_OVV_PROTECT_INIT);
1298 else if (di->events.main_thermal_prot ||
1299 di->events.usb_thermal_prot) {
1300 if (di->charge_state != STATE_HW_TEMP_PROTECT)
1301 ab8500_chargalg_state_to(di,
1305 else if (di->events.btemp_underover) {
1306 if (di->charge_state != STATE_TEMP_UNDEROVER)
1307 ab8500_chargalg_state_to(di,
1311 else if (di->events.ac_wd_expired ||
1312 di->events.usb_wd_expired) {
1313 if (di->charge_state != STATE_WD_EXPIRED)
1314 ab8500_chargalg_state_to(di, STATE_WD_EXPIRED_INIT);
1317 else if (di->events.btemp_low || di->events.btemp_high) {
1318 if (di->charge_state != STATE_TEMP_LOWHIGH)
1319 ab8500_chargalg_state_to(di, STATE_TEMP_LOWHIGH_INIT);
1322 dev_dbg(di->dev,
1327 di->batt_data.volt_uv,
1328 di->batt_data.avg_curr_ua,
1329 di->batt_data.inst_curr_ua,
1330 di->batt_data.temp,
1331 di->batt_data.percent,
1332 di->maintenance_chg,
1333 states[di->charge_state],
1334 di->chg_info.charger_type,
1335 di->charge_status,
1336 di->chg_info.conn_chg & AC_CHG,
1337 di->chg_info.conn_chg & USB_CHG,
1338 di->chg_info.online_chg & AC_CHG,
1339 di->chg_info.online_chg & USB_CHG,
1340 di->events.ac_cv_active,
1341 di->events.usb_cv_active,
1342 di->chg_info.ac_curr_ua,
1343 di->chg_info.usb_curr_ua,
1344 di->chg_info.ac_vset_uv,
1345 di->chg_info.ac_iset_ua,
1346 di->chg_info.usb_vset_uv,
1347 di->chg_info.usb_iset_ua);
1349 switch (di->charge_state) {
1351 ab8500_chargalg_stop_charging(di);
1352 di->charge_status = POWER_SUPPLY_STATUS_DISCHARGING;
1353 ab8500_chargalg_state_to(di, STATE_HANDHELD);
1360 ab8500_chargalg_stop_charging(di);
1361 ab8500_chargalg_state_to(di, STATE_BATT_REMOVED);
1365 if (!di->events.batt_rem)
1366 ab8500_chargalg_state_to(di, STATE_NORMAL_INIT);
1370 ab8500_chargalg_stop_charging(di);
1371 ab8500_chargalg_state_to(di, STATE_HW_TEMP_PROTECT);
1375 if (!di->events.main_thermal_prot &&
1376 !di->events.usb_thermal_prot)
1377 ab8500_chargalg_state_to(di, STATE_NORMAL_INIT);
1381 ab8500_chargalg_stop_charging(di);
1382 ab8500_chargalg_state_to(di, STATE_OVV_PROTECT);
1386 if (!di->events.vbus_ovv &&
1387 !di->events.main_ovv &&
1388 !di->events.batt_ovv &&
1389 di->chg_info.usb_chg_ok &&
1390 di->chg_info.ac_chg_ok)
1391 ab8500_chargalg_state_to(di, STATE_NORMAL_INIT);
1395 ab8500_chargalg_stop_charging(di);
1396 ab8500_chargalg_state_to(di, STATE_CHG_NOT_OK);
1400 if (!di->events.mainextchnotok &&
1401 !di->events.usbchargernotok)
1402 ab8500_chargalg_state_to(di, STATE_NORMAL_INIT);
1406 ab8500_chargalg_stop_charging(di);
1407 ab8500_chargalg_state_to(di, STATE_SAFETY_TIMER_EXPIRED);
1417 ab8500_chargalg_stop_charging(di);
1419 ab8500_chargalg_start_charging(di,
1424 ab8500_chargalg_state_to(di, STATE_NORMAL);
1425 ab8500_chargalg_start_safety_timer(di);
1426 ab8500_chargalg_stop_maintenance_timer(di);
1427 init_maxim_chg_curr(di);
1428 di->charge_status = POWER_SUPPLY_STATUS_CHARGING;
1429 di->eoc_cnt = 0;
1430 di->maintenance_chg = false;
1431 power_supply_changed(di->chargalg_psy);
1436 handle_maxim_chg_curr(di);
1437 if (di->charge_status == POWER_SUPPLY_STATUS_FULL &&
1438 di->maintenance_chg) {
1445 ab8500_chargalg_state_to(di,
1448 ab8500_chargalg_state_to(di,
1455 ab8500_chargalg_hold_charging(di);
1456 ab8500_chargalg_state_to(di, STATE_WAIT_FOR_RECHARGE);
1460 if (ab8500_chargalg_time_to_restart(di))
1461 ab8500_chargalg_state_to(di, STATE_NORMAL_INIT);
1468 ab8500_chargalg_state_to(di, STATE_NORMAL_INIT);
1469 power_supply_changed(di->chargalg_psy);
1472 ab8500_chargalg_stop_safety_timer(di);
1473 ab8500_chargalg_start_maintenance_timer(di,
1475 ab8500_chargalg_start_charging(di,
1478 ab8500_chargalg_state_to(di, STATE_MAINTENANCE_A);
1479 power_supply_changed(di->chargalg_psy);
1483 if (di->events.maintenance_timer_expired) {
1484 ab8500_chargalg_stop_maintenance_timer(di);
1485 ab8500_chargalg_state_to(di, STATE_MAINTENANCE_B_INIT);
1491 if (ab8500_chargalg_time_to_restart(di)) {
1492 ab8500_chargalg_state_to(di, STATE_NORMAL_INIT);
1493 dev_info(di->dev, "restarted charging from maintenance state A - battery getting old?\n");
1501 ab8500_chargalg_state_to(di, STATE_NORMAL_INIT);
1502 power_supply_changed(di->chargalg_psy);
1505 ab8500_chargalg_start_maintenance_timer(di,
1507 ab8500_chargalg_start_charging(di,
1510 ab8500_chargalg_state_to(di, STATE_MAINTENANCE_B);
1511 power_supply_changed(di->chargalg_psy);
1515 if (di->events.maintenance_timer_expired) {
1516 ab8500_chargalg_stop_maintenance_timer(di);
1517 ab8500_chargalg_state_to(di, STATE_NORMAL_INIT);
1523 if (ab8500_chargalg_time_to_restart(di)) {
1524 ab8500_chargalg_state_to(di, STATE_NORMAL_INIT);
1525 dev_info(di->dev, "restarted charging from maintenance state B - battery getting old?\n");
1530 if (di->events.btemp_low) {
1531 ab8500_chargalg_start_charging(di,
1534 } else if (di->events.btemp_high) {
1535 ab8500_chargalg_start_charging(di,
1539 dev_err(di->dev, "neither low or high temp event occurred\n");
1540 ab8500_chargalg_state_to(di, STATE_NORMAL_INIT);
1543 ab8500_chargalg_stop_maintenance_timer(di);
1544 di->charge_status = POWER_SUPPLY_STATUS_CHARGING;
1545 ab8500_chargalg_state_to(di, STATE_TEMP_LOWHIGH);
1546 power_supply_changed(di->chargalg_psy);
1550 if (!di->events.btemp_low && !di->events.btemp_high)
1551 ab8500_chargalg_state_to(di, STATE_NORMAL_INIT);
1555 ab8500_chargalg_stop_charging(di);
1556 ab8500_chargalg_state_to(di, STATE_WD_EXPIRED);
1560 if (!di->events.ac_wd_expired &&
1561 !di->events.usb_wd_expired)
1562 ab8500_chargalg_state_to(di, STATE_NORMAL_INIT);
1566 ab8500_chargalg_stop_charging(di);
1567 ab8500_chargalg_state_to(di, STATE_TEMP_UNDEROVER);
1571 if (!di->events.btemp_underover)
1572 ab8500_chargalg_state_to(di, STATE_NORMAL_INIT);
1577 if (di->charge_state == STATE_NORMAL_INIT ||
1578 di->charge_state == STATE_MAINTENANCE_A_INIT ||
1579 di->charge_state == STATE_MAINTENANCE_B_INIT)
1580 queue_work(di->chargalg_wq, &di->chargalg_work);
1591 struct ab8500_chargalg *di = container_of(work,
1594 ab8500_chargalg_algorithm(di);
1600 if (di->chg_info.conn_chg)
1601 queue_delayed_work(di->chargalg_wq,
1602 &di->chargalg_periodic_work,
1603 di->bm->interval_charging * HZ);
1605 queue_delayed_work(di->chargalg_wq,
1606 &di->chargalg_periodic_work,
1607 di->bm->interval_not_charging * HZ);
1619 struct ab8500_chargalg *di = container_of(work,
1622 ret = ab8500_chargalg_kick_watchdog(di);
1624 dev_err(di->dev, "failed to kick watchdog\n");
1626 queue_delayed_work(di->chargalg_wq,
1627 &di->chargalg_wd_work, CHG_WD_INTERVAL);
1638 struct ab8500_chargalg *di = container_of(work,
1641 ab8500_chargalg_algorithm(di);
1660 struct ab8500_chargalg *di = power_supply_get_drvdata(psy);
1664 val->intval = di->charge_status;
1667 if (di->events.batt_ovv) {
1669 } else if (di->events.btemp_underover) {
1670 if (di->batt_data.temp <= di->bm->bi->temp_min)
1674 } else if (di->charge_state == STATE_SAFETY_TIMER_EXPIRED ||
1675 di->charge_state == STATE_SAFETY_TIMER_EXPIRED_INIT) {
1689 struct ab8500_chargalg *di = dev_get_drvdata(dev);
1692 if (di->chg_info.online_chg)
1693 queue_delayed_work(di->chargalg_wq, &di->chargalg_wd_work, 0);
1699 queue_delayed_work(di->chargalg_wq, &di->chargalg_periodic_work, 0);
1706 struct ab8500_chargalg *di = dev_get_drvdata(dev);
1708 if (di->chg_info.online_chg)
1709 cancel_delayed_work_sync(&di->chargalg_wd_work);
1711 cancel_delayed_work_sync(&di->chargalg_periodic_work);
1732 struct ab8500_chargalg *di = dev_get_drvdata(dev);
1735 di->chargalg_wq = alloc_ordered_workqueue("ab8500_chargalg_wq",
1737 if (di->chargalg_wq == NULL) {
1738 dev_err(di->dev, "failed to create work queue\n");
1743 queue_delayed_work(di->chargalg_wq, &di->chargalg_periodic_work, 0);
1751 struct ab8500_chargalg *di = dev_get_drvdata(dev);
1754 hrtimer_cancel(&di->safety_timer);
1755 hrtimer_cancel(&di->maintenance_timer);
1757 cancel_delayed_work_sync(&di->chargalg_periodic_work);
1758 cancel_delayed_work_sync(&di->chargalg_wd_work);
1759 cancel_work_sync(&di->chargalg_work);
1762 destroy_workqueue(di->chargalg_wq);
1774 struct ab8500_chargalg *di;
1776 di = devm_kzalloc(dev, sizeof(*di), GFP_KERNEL);
1777 if (!di)
1780 di->bm = &ab8500_bm_data;
1783 di->dev = dev;
1784 di->parent = dev_get_drvdata(pdev->dev.parent);
1788 psy_cfg.drv_data = di;
1791 hrtimer_init(&di->safety_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
1792 di->safety_timer.function = ab8500_chargalg_safety_timer_expired;
1795 hrtimer_init(&di->maintenance_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
1796 di->maintenance_timer.function =
1800 INIT_DEFERRABLE_WORK(&di->chargalg_periodic_work,
1802 INIT_DEFERRABLE_WORK(&di->chargalg_wd_work,
1806 INIT_WORK(&di->chargalg_work, ab8500_chargalg_work);
1809 di->chg_info.prev_conn_chg = -1;
1812 di->chargalg_psy = devm_power_supply_register(di->dev,
1815 if (IS_ERR(di->chargalg_psy)) {
1816 dev_err(di->dev, "failed to register chargalg psy\n");
1817 return PTR_ERR(di->chargalg_psy);
1820 platform_set_drvdata(pdev, di);
1822 dev_info(di->dev, "probe success\n");