Lines Matching refs:di
348 static void ab8500_enable_disable_sw_fallback(struct ab8500_charger *di,
357 dev_dbg(di->dev, "SW Fallback: %d\n", fallback);
359 if (is_ab8500(di->parent)) {
370 ret = abx500_get_register_interruptible(di->dev, bank, reg, &val);
372 dev_err(di->dev, "%d read failed\n", __LINE__);
376 if (is_ab8500(di->parent)) {
378 ret = abx500_set_register_interruptible(di->dev, 0x11, 0x00, 0x2);
380 dev_err(di->dev, "%d write failed\n", __LINE__);
391 ret = abx500_set_register_interruptible(di->dev, bank, reg, val);
393 dev_err(di->dev, "%d write failed\n", __LINE__);
397 if (is_ab8500(di->parent)) {
399 ret = abx500_set_register_interruptible(di->dev, 0x11, 0x00, 0x0);
401 dev_err(di->dev, "%d write failed\n", __LINE__);
409 * @di: pointer to the ab8500_charger structure
413 static void ab8500_power_supply_changed(struct ab8500_charger *di,
424 if (di->autopower_cfg) {
425 if (!di->usb.charger_connected &&
426 !di->ac.charger_connected &&
427 di->autopower) {
428 di->autopower = false;
429 ab8500_enable_disable_sw_fallback(di, false);
430 } else if (!di->autopower &&
431 (di->ac.charger_connected ||
432 di->usb.charger_connected)) {
433 di->autopower = true;
434 ab8500_enable_disable_sw_fallback(di, true);
440 static void ab8500_charger_set_usb_connected(struct ab8500_charger *di,
443 if (connected != di->usb.charger_connected) {
444 dev_dbg(di->dev, "USB connected:%i\n", connected);
445 di->usb.charger_connected = connected;
448 di->flags.vbus_drop_end = false;
455 if (di->usb_chg.psy) {
456 sysfs_notify(&di->usb_chg.psy->dev.kobj, NULL,
461 mutex_lock(&di->charger_attached_mutex);
462 mutex_unlock(&di->charger_attached_mutex);
464 if (is_ab8500(di->parent))
465 queue_delayed_work(di->charger_wq,
466 &di->usb_charger_attached_work,
469 cancel_delayed_work_sync(&di->usb_charger_attached_work);
470 mutex_lock(&di->charger_attached_mutex);
471 mutex_unlock(&di->charger_attached_mutex);
478 * @di: pointer to the ab8500_charger structure
482 static int ab8500_charger_get_ac_voltage(struct ab8500_charger *di)
487 if (di->ac.charger_connected) {
488 ret = iio_read_channel_processed(di->adc_main_charger_v, &vch);
490 dev_err(di->dev, "%s ADC conv failed,\n", __func__);
499 * @di: pointer to the ab8500_charger structure
503 static int ab8500_charger_ac_cv(struct ab8500_charger *di)
509 if (di->ac.charger_online) {
510 ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
513 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
528 * @di: pointer to the ab8500_charger structure
533 static int ab8500_charger_get_vbus_voltage(struct ab8500_charger *di)
538 if (di->usb.charger_connected) {
539 ret = iio_read_channel_processed(di->adc_vbus_v, &vch);
541 dev_err(di->dev, "%s ADC conv failed,\n", __func__);
550 * @di: pointer to the ab8500_charger structure
555 static int ab8500_charger_get_usb_current(struct ab8500_charger *di)
560 if (di->usb.charger_online) {
561 ret = iio_read_channel_processed(di->adc_usb_charger_c, &ich);
563 dev_err(di->dev, "%s ADC conv failed,\n", __func__);
572 * @di: pointer to the ab8500_charger structure
577 static int ab8500_charger_get_ac_current(struct ab8500_charger *di)
582 if (di->ac.charger_online) {
583 ret = iio_read_channel_processed(di->adc_main_charger_c, &ich);
585 dev_err(di->dev, "%s ADC conv failed,\n", __func__);
594 * @di: pointer to the ab8500_charger structure
598 static int ab8500_charger_usb_cv(struct ab8500_charger *di)
604 if (di->usb.charger_online) {
605 ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
608 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
625 * @di: pointer to the ab8500_charger structure
640 static int ab8500_charger_detect_chargers(struct ab8500_charger *di, bool probe)
647 ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
650 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
668 ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
671 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
674 dev_dbg(di->dev,
685 * @di: pointer to the ab8500_charger structure
692 static int ab8500_charger_max_usb_curr(struct ab8500_charger *di,
697 di->usb_device_is_unrecognised = false;
710 dev_dbg(di->dev, "USB Type - Standard host is "
712 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_0P5;
713 di->is_aca_rid = 0;
716 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_0P5;
717 di->is_aca_rid = 0;
720 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_0P5;
721 di->is_aca_rid = 0;
724 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_0P9;
725 di->is_aca_rid = 0;
732 dev_dbg(di->dev, "USB_STAT_ACA_RID_A detected\n");
733 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_0P5;
734 di->is_aca_rid = 1;
741 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_1P3;
742 dev_dbg(di->dev, "USB Type - 0x%02x MaxCurr: %d", link_status,
743 di->max_usb_in_curr.usb_type_max);
744 di->is_aca_rid = 1;
747 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_0P5;
748 di->is_aca_rid = 0;
751 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_1P5;
752 di->is_aca_rid = 0;
756 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_1P5;
757 di->is_aca_rid = 1;
760 if (di->vbus_detected) {
761 di->usb_device_is_unrecognised = true;
762 dev_dbg(di->dev, "USB Type - Legacy charger.\n");
763 di->max_usb_in_curr.usb_type_max =
769 dev_err(di->dev, "USB Type - Charging not allowed\n");
770 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_0P05;
774 if (is_ab8500(di->parent)) {
775 di->flags.vbus_collapse = true;
776 dev_err(di->dev, "USB Type - USB_STAT_RESERVED "
781 dev_dbg(di->dev, "USB Type - Charging not allowed\n");
782 di->max_usb_in_curr.usb_type_max =
784 dev_dbg(di->dev, "USB Type - 0x%02x MaxCurr: %d",
786 di->max_usb_in_curr.usb_type_max);
794 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_0P5;
795 dev_dbg(di->dev, "USB Type - 0x%02x MaxCurr: %d", link_status,
796 di->max_usb_in_curr.usb_type_max);
799 dev_err(di->dev, "USB Type invalid - try charging anyway\n");
800 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_0P5;
804 dev_err(di->dev, "USB Type - Unknown\n");
805 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_0P05;
810 di->max_usb_in_curr.set_max = di->max_usb_in_curr.usb_type_max;
811 dev_dbg(di->dev, "USB Type - 0x%02x MaxCurr: %d",
812 link_status, di->max_usb_in_curr.set_max);
819 * @di: pointer to the ab8500_charger structure
824 static int ab8500_charger_read_usb_type(struct ab8500_charger *di)
829 ret = abx500_get_register_interruptible(di->dev,
832 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
835 if (is_ab8500(di->parent))
836 ret = abx500_get_register_interruptible(di->dev, AB8500_USB,
839 ret = abx500_get_register_interruptible(di->dev,
842 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
847 if (is_ab8500(di->parent))
851 ret = ab8500_charger_max_usb_curr(di,
859 * @di: pointer to the ab8500_charger structure
864 static int ab8500_charger_detect_usb_type(struct ab8500_charger *di)
876 ret = abx500_get_register_interruptible(di->dev,
879 dev_dbg(di->dev, "%s AB8500_IT_SOURCE21_REG %x\n",
882 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
886 if (is_ab8500(di->parent))
887 ret = abx500_get_register_interruptible(di->dev,
890 ret = abx500_get_register_interruptible(di->dev,
893 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
896 dev_dbg(di->dev, "%s AB8500_USB_LINE_STAT_REG %x\n", __func__,
905 if (is_ab8500(di->parent))
914 ret = ab8500_charger_max_usb_curr(di,
1026 static int ab8500_current_to_regval(struct ab8500_charger *di, int curr)
1030 if (curr < di->bm->chg_output_curr[0])
1033 for (i = 0; i < di->bm->n_chg_out_curr; i++) {
1034 if (curr < di->bm->chg_output_curr[i])
1039 i = di->bm->n_chg_out_curr - 1;
1040 if (curr == di->bm->chg_output_curr[i])
1046 static int ab8500_vbus_in_curr_to_regval(struct ab8500_charger *di, int curr)
1050 if (curr < di->bm->chg_input_curr[0])
1053 for (i = 0; i < di->bm->n_chg_in_curr; i++) {
1054 if (curr < di->bm->chg_input_curr[i])
1059 i = di->bm->n_chg_in_curr - 1;
1060 if (curr == di->bm->chg_input_curr[i])
1068 * @di: pointer to the ab8500_charger structre
1075 static int ab8500_charger_get_usb_cur(struct ab8500_charger *di)
1078 switch (di->usb_state.usb_current) {
1080 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_0P09;
1083 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_0P19;
1086 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_0P29;
1089 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_0P38;
1092 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_0P5;
1095 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_0P05;
1099 di->max_usb_in_curr.set_max = di->max_usb_in_curr.usb_type_max;
1105 * @di: pointer to the ab8500_charger structure
1112 static bool ab8500_charger_check_continue_stepping(struct ab8500_charger *di,
1116 return !di->flags.vbus_drop_end;
1123 * @di: pointer to the ab8500_charger structure
1134 static int ab8500_charger_set_current(struct ab8500_charger *di,
1143 atomic_inc(&di->current_stepping_sessions);
1145 ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
1148 dev_err(di->dev, "%s read failed\n", __func__);
1156 curr_index = ab8500_current_to_regval(di, ich);
1158 if (!di->ac.charger_connected)
1164 curr_index = ab8500_vbus_in_curr_to_regval(di, ich);
1167 if (!di->usb.charger_connected)
1173 curr_index = ab8500_current_to_regval(di, ich);
1178 if (!di->usb.charger_connected && !di->ac.charger_connected)
1183 dev_err(di->dev, "%s current register not valid\n", __func__);
1189 dev_err(di->dev, "requested current limit out-of-range\n");
1196 dev_dbg(di->dev, "%s current not changed for reg: 0x%02x\n",
1202 dev_dbg(di->dev, "%s set charger current: %d mA for reg: 0x%02x\n",
1206 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1209 dev_err(di->dev, "%s write failed\n", __func__);
1212 dev_dbg(di->dev, "curr change_1 to: %x for 0x%02x\n",
1214 ret = abx500_set_register_interruptible(di->dev,
1217 dev_err(di->dev, "%s write failed\n", __func__);
1226 dev_dbg(di->dev, "curr change_2 to: %x for 0x%02x\n",
1228 ret = abx500_set_register_interruptible(di->dev,
1231 dev_err(di->dev, "%s write failed\n", __func__);
1237 allow = ab8500_charger_check_continue_stepping(di, reg);
1242 atomic_dec(&di->current_stepping_sessions);
1249 * @di: pointer to the ab8500_charger structure
1255 static int ab8500_charger_set_vbus_in_curr(struct ab8500_charger *di,
1262 min_value = min(di->bm->chg_params->usb_curr_max, ich_in);
1263 if (di->max_usb_in_curr.set_max > 0)
1264 min_value = min(di->max_usb_in_curr.set_max, min_value);
1266 if (di->usb_state.usb_current >= 0)
1267 min_value = min(di->usb_state.usb_current, min_value);
1271 if (di->vbat < VBAT_TRESH_IP_CUR_RED)
1275 if (di->vbat < VBAT_TRESH_IP_CUR_RED)
1282 dev_info(di->dev, "VBUS input current limit set to %d mA\n", min_value);
1284 mutex_lock(&di->usb_ipt_crnt_lock);
1285 ret = ab8500_charger_set_current(di, min_value,
1287 mutex_unlock(&di->usb_ipt_crnt_lock);
1294 * @di: pointer to the ab8500_charger structure
1300 static int ab8500_charger_set_main_in_curr(struct ab8500_charger *di,
1303 return ab8500_charger_set_current(di, ich_in,
1309 * @di: pointer to the ab8500_charger structure
1315 static int ab8500_charger_set_output_curr(struct ab8500_charger *di,
1318 return ab8500_charger_set_current(di, ich_out,
1324 * @di: pointer to the ab8500_charger structure
1330 static int ab8500_charger_led_en(struct ab8500_charger *di, int on)
1336 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1340 dev_err(di->dev, "Power ON LED failed\n");
1344 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1348 dev_err(di->dev, "Set LED PWM duty cycle failed\n");
1353 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1357 dev_err(di->dev, "Power-off LED failed\n");
1367 * @di: pointer to the ab8500_charger structure
1384 struct ab8500_charger *di = to_ab8500_charger_ac_device_info(charger);
1388 if (!di->ac.charger_connected) {
1389 dev_err(di->dev, "AC charger not connected\n");
1394 dev_dbg(di->dev, "Enable AC: %dmV %dmA\n", vset, iset);
1406 if (!di->vddadc_en_ac) {
1407 ret = regulator_enable(di->regu);
1409 dev_warn(di->dev,
1412 di->vddadc_en_ac = true;
1417 curr_index = ab8500_current_to_regval(di, iset);
1418 input_curr_index = ab8500_current_to_regval(di,
1419 di->bm->chg_params->ac_curr_max);
1421 dev_err(di->dev,
1428 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1431 dev_err(di->dev, "%s write failed\n", __func__);
1435 ret = ab8500_charger_set_main_in_curr(di,
1436 di->bm->chg_params->ac_curr_max);
1438 dev_err(di->dev, "%s Failed to set MainChInputCurr\n",
1443 ret = ab8500_charger_set_output_curr(di, iset);
1445 dev_err(di->dev, "%s "
1452 if (!di->bm->enable_overshoot)
1456 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1459 dev_err(di->dev, "%s write failed\n", __func__);
1464 ret = ab8500_charger_led_en(di, true);
1466 dev_err(di->dev, "failed to enable LED\n");
1468 di->ac.charger_online = 1;
1471 if (is_ab8500_1p1_or_earlier(di->parent)) {
1482 if (di->ac_conn) {
1483 queue_delayed_work(di->charger_wq,
1484 &di->kick_wd_work,
1495 ret = abx500_set_register_interruptible(di->dev,
1499 dev_err(di->dev,
1504 ret = ab8500_charger_set_output_curr(di, 0);
1506 dev_err(di->dev, "%s "
1512 ret = abx500_set_register_interruptible(di->dev,
1516 dev_err(di->dev,
1522 ret = ab8500_charger_led_en(di, false);
1524 dev_err(di->dev, "failed to disable LED\n");
1526 di->ac.charger_online = 0;
1527 di->ac.wd_expired = false;
1530 if (di->vddadc_en_ac) {
1531 regulator_disable(di->regu);
1532 di->vddadc_en_ac = false;
1535 dev_dbg(di->dev, "%s Disabled AC charging\n", __func__);
1537 ab8500_power_supply_changed(di, di->ac_chg.psy);
1544 * @di: pointer to the ab8500_charger structure
1560 struct ab8500_charger *di = to_ab8500_charger_usb_device_info(charger);
1564 if (!di->usb.charger_connected) {
1565 dev_err(di->dev, "USB charger not connected\n");
1579 if (!di->vddadc_en_usb) {
1580 ret = regulator_enable(di->regu);
1582 dev_warn(di->dev,
1585 di->vddadc_en_usb = true;
1589 dev_dbg(di->dev, "Enable USB: %dmV %dmA\n", vset, ich_out);
1593 curr_index = ab8500_current_to_regval(di, ich_out);
1595 dev_err(di->dev,
1605 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1608 dev_err(di->dev, "%s write failed\n", __func__);
1612 if (!di->bm->enable_overshoot)
1616 dev_dbg(di->dev,
1618 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1621 dev_err(di->dev, "%s write failed\n", __func__);
1626 ret = ab8500_charger_led_en(di, true);
1628 dev_err(di->dev, "failed to enable LED\n");
1630 di->usb.charger_online = 1;
1633 ret = ab8500_charger_set_vbus_in_curr(di,
1634 di->max_usb_in_curr.usb_type_max);
1636 dev_err(di->dev, "setting USBChInputCurr failed\n");
1641 ret = ab8500_charger_set_output_curr(di, ich_out);
1643 dev_err(di->dev, "%s "
1649 queue_delayed_work(di->charger_wq, &di->check_vbat_work, HZ);
1653 dev_dbg(di->dev, "%s Disabled USB charging\n", __func__);
1654 ret = abx500_set_register_interruptible(di->dev,
1658 dev_err(di->dev,
1663 ret = ab8500_charger_led_en(di, false);
1665 dev_err(di->dev, "failed to disable LED\n");
1667 ret = ab8500_charger_set_vbus_in_curr(di, 0);
1669 dev_err(di->dev, "setting USBChInputCurr failed\n");
1674 ret = ab8500_charger_set_output_curr(di, 0);
1676 dev_err(di->dev, "%s "
1681 di->usb.charger_online = 0;
1682 di->usb.wd_expired = false;
1685 if (di->vddadc_en_usb) {
1686 regulator_disable(di->regu);
1687 di->vddadc_en_usb = false;
1690 dev_dbg(di->dev, "%s Disabled USB charging\n", __func__);
1693 cancel_delayed_work(&di->check_vbat_work);
1696 ab8500_power_supply_changed(di, di->usb_chg.psy);
1739 struct ab8500_charger *di = to_ab8500_charger_usb_device_info(charger);
1741 if (!di->usb.charger_connected)
1744 ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
1747 dev_err(di->dev, "ab8500 read failed %d\n", __LINE__);
1750 dev_dbg(di->dev, "USB charger ctrl: 0x%02x\n", usbch_ctrl1);
1753 dev_info(di->dev, "Charging has been disabled abnormally and will be re-enabled\n");
1755 ret = abx500_mask_and_set_register_interruptible(di->dev,
1759 dev_err(di->dev, "ab8500 write failed %d\n", __LINE__);
1763 ret = ab8500_charger_usb_en(&di->usb_chg, true, vset, iset);
1765 dev_err(di->dev, "Failed to enable VBUS charger %d\n",
1788 struct ab8500_charger *di = to_ab8500_charger_ac_device_info(charger);
1790 if (!di->ac.charger_connected)
1793 ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
1796 dev_err(di->dev, "ab8500 read failed %d\n", __LINE__);
1799 dev_dbg(di->dev, "AC charger ctrl: 0x%02x\n", mainch_ctrl1);
1802 dev_info(di->dev, "Charging has been disabled abnormally and will be re-enabled\n");
1804 ret = abx500_mask_and_set_register_interruptible(di->dev,
1809 dev_err(di->dev, "ab8500 write failed %d\n", __LINE__);
1813 ret = ab8500_charger_ac_en(&di->usb_chg, true, vset, iset);
1815 dev_err(di->dev, "failed to enable AC charger %d\n",
1825 * @di: pointer to the ab8500_charger structure
1833 struct ab8500_charger *di;
1836 di = to_ab8500_charger_ac_device_info(charger);
1838 di = to_ab8500_charger_usb_device_info(charger);
1842 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1845 dev_err(di->dev, "Failed to kick WD!\n");
1852 * @di: pointer to the ab8500_charger structure
1861 struct ab8500_charger *di;
1864 di = to_ab8500_charger_ac_device_info(charger);
1866 di = to_ab8500_charger_usb_device_info(charger);
1870 ret = ab8500_charger_set_output_curr(di, ich_out);
1872 dev_err(di->dev, "%s "
1879 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1882 dev_err(di->dev, "%s write failed\n", __func__);
1894 struct ab8500_charger *di;
1902 di = to_ab8500_charger_usb_device_info(usb_chg);
1921 di->vbat = ret.intval / 1000;
1946 struct ab8500_charger *di = container_of(work,
1950 di->usb_chg.psy, ab8500_charger_get_ext_psy_data);
1953 if (di->old_vbat == 0)
1954 di->old_vbat = di->vbat;
1956 if (!((di->old_vbat <= VBAT_TRESH_IP_CUR_RED &&
1957 di->vbat <= VBAT_TRESH_IP_CUR_RED) ||
1958 (di->old_vbat > VBAT_TRESH_IP_CUR_RED &&
1959 di->vbat > VBAT_TRESH_IP_CUR_RED))) {
1961 dev_dbg(di->dev, "Vbat did cross threshold, curr: %d, new: %d,"
1962 " old: %d\n", di->max_usb_in_curr.usb_type_max,
1963 di->vbat, di->old_vbat);
1964 ab8500_charger_set_vbus_in_curr(di,
1965 di->max_usb_in_curr.usb_type_max);
1966 power_supply_changed(di->usb_chg.psy);
1969 di->old_vbat = di->vbat;
1975 if (di->vbat < (VBAT_TRESH_IP_CUR_RED + 100) &&
1976 (di->vbat > (VBAT_TRESH_IP_CUR_RED - 100)))
1979 queue_delayed_work(di->charger_wq, &di->check_vbat_work, t * HZ);
1993 struct ab8500_charger *di = container_of(work,
1997 if (di->flags.mainextchnotok) {
1998 ret = abx500_get_register_interruptible(di->dev,
2001 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
2005 di->flags.mainextchnotok = false;
2006 ab8500_power_supply_changed(di, di->ac_chg.psy);
2009 if (di->flags.vbus_ovv) {
2010 ret = abx500_get_register_interruptible(di->dev,
2014 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
2018 di->flags.vbus_ovv = false;
2019 ab8500_power_supply_changed(di, di->usb_chg.psy);
2023 if (di->flags.mainextchnotok || di->flags.vbus_ovv) {
2024 queue_delayed_work(di->charger_wq,
2025 &di->check_hw_failure_work, round_jiffies(HZ));
2047 struct ab8500_charger *di = container_of(work,
2050 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
2053 dev_err(di->dev, "Failed to kick WD!\n");
2056 queue_delayed_work(di->charger_wq,
2057 &di->kick_wd_work, round_jiffies(WD_KICK_INTERVAL));
2070 struct ab8500_charger *di = container_of(work,
2078 ret = ab8500_charger_detect_chargers(di, false);
2083 di->ac.charger_connected = 1;
2084 di->ac_conn = true;
2086 di->ac.charger_connected = 0;
2089 ab8500_power_supply_changed(di, di->ac_chg.psy);
2090 sysfs_notify(&di->ac_chg.psy->dev.kobj, NULL, "present");
2095 struct ab8500_charger *di = container_of(work,
2103 ret = abx500_get_register_interruptible(di->dev,
2108 dev_err(di->dev, "ab8500 read failed %d\n", __LINE__);
2117 ab8500_charger_usb_en(&di->usb_chg, 0, 0, 0);
2119 mutex_lock(&di->charger_attached_mutex);
2120 mutex_unlock(&di->charger_attached_mutex);
2125 queue_delayed_work(di->charger_wq,
2126 &di->usb_charger_attached_work,
2133 struct ab8500_charger *di = container_of(work,
2142 ret = abx500_get_register_interruptible(di->dev,
2147 dev_err(di->dev, "ab8500 read failed %d\n", __LINE__);
2157 ab8500_charger_ac_en(&di->ac_chg, 0, 0, 0);
2158 queue_work(di->charger_wq, &di->ac_work);
2160 mutex_lock(&di->charger_attached_mutex);
2161 mutex_unlock(&di->charger_attached_mutex);
2166 queue_delayed_work(di->charger_wq,
2167 &di->ac_charger_attached_work,
2181 struct ab8500_charger *di = container_of(work,
2189 ret = ab8500_charger_detect_chargers(di, false);
2194 dev_dbg(di->dev, "%s di->vbus_detected = false\n", __func__);
2195 di->vbus_detected = false;
2196 ab8500_charger_set_usb_connected(di, false);
2197 ab8500_power_supply_changed(di, di->usb_chg.psy);
2199 dev_dbg(di->dev, "%s di->vbus_detected = true\n", __func__);
2200 di->vbus_detected = true;
2202 if (is_ab8500_1p1_or_earlier(di->parent)) {
2203 ret = ab8500_charger_detect_usb_type(di);
2205 ab8500_charger_set_usb_connected(di, true);
2206 ab8500_power_supply_changed(di,
2207 di->usb_chg.psy);
2217 if (di->vbus_detected_start) {
2218 di->vbus_detected_start = false;
2219 ret = ab8500_charger_detect_usb_type(di);
2221 ab8500_charger_set_usb_connected(di,
2223 ab8500_power_supply_changed(di,
2224 di->usb_chg.psy);
2239 struct ab8500_charger *di =
2244 if (!di->usb.charger_online) {
2245 ret = ab8500_charger_set_vbus_in_curr(di,
2246 di->max_usb_in_curr.usb_type_max);
2251 ab8500_charger_set_usb_connected(di, true);
2252 ab8500_power_supply_changed(di, di->usb_chg.psy);
2268 struct ab8500_charger *di = container_of(work,
2276 detected_chargers = ab8500_charger_detect_chargers(di, false);
2286 if (is_ab8500(di->parent))
2287 ret = abx500_get_register_interruptible(di->dev, AB8500_USB,
2290 ret = abx500_get_register_interruptible(di->dev, AB8500_USB,
2294 dev_dbg(di->dev, "UsbLineStatus register = 0x%02x\n", val);
2296 dev_dbg(di->dev, "Error reading USB link status\n");
2298 if (is_ab8500(di->parent))
2306 di->invalid_charger_detect_state == 0) {
2307 dev_dbg(di->dev,
2310 abx500_mask_and_set_register_interruptible(di->dev,
2314 abx500_mask_and_set_register_interruptible(di->dev,
2317 di->invalid_charger_detect_state = 1;
2322 if (di->invalid_charger_detect_state == 1) {
2323 dev_dbg(di->dev,
2326 abx500_mask_and_set_register_interruptible(di->dev,
2330 if (is_ab8500(di->parent))
2331 ret = abx500_get_register_interruptible(di->dev,
2335 ret = abx500_get_register_interruptible(di->dev,
2339 dev_dbg(di->dev, "USB link status= 0x%02x\n",
2341 di->invalid_charger_detect_state = 2;
2344 di->invalid_charger_detect_state = 0;
2348 di->vbus_detected = false;
2349 ab8500_charger_set_usb_connected(di, false);
2350 ab8500_power_supply_changed(di, di->usb_chg.psy);
2354 dev_dbg(di->dev,"%s di->vbus_detected = true\n",__func__);
2355 di->vbus_detected = true;
2356 ret = ab8500_charger_read_usb_type(di);
2360 ab8500_charger_set_usb_connected(di, false);
2361 ab8500_power_supply_changed(di, di->usb_chg.psy);
2366 if (di->usb_device_is_unrecognised) {
2367 dev_dbg(di->dev,
2372 queue_delayed_work(di->charger_wq,
2373 &di->attach_work,
2375 } else if (di->is_aca_rid == 1) {
2377 di->is_aca_rid++;
2378 dev_dbg(di->dev,
2381 queue_delayed_work(di->charger_wq,
2382 &di->attach_work,
2385 queue_delayed_work(di->charger_wq,
2386 &di->attach_work,
2396 struct ab8500_charger *di = container_of(work,
2399 if (!di->vbus_detected) {
2400 dev_dbg(di->dev,
2401 "%s !di->vbus_detected\n",
2406 spin_lock_irqsave(&di->usb_state.usb_lock, flags);
2407 di->usb_state.state = di->usb_state.state_tmp;
2408 di->usb_state.usb_current = di->usb_state.usb_current_tmp;
2409 spin_unlock_irqrestore(&di->usb_state.usb_lock, flags);
2411 dev_dbg(di->dev, "%s USB state: 0x%02x mA: %d\n",
2412 __func__, di->usb_state.state, di->usb_state.usb_current);
2414 switch (di->usb_state.state) {
2419 ab8500_charger_set_usb_connected(di, false);
2420 ab8500_power_supply_changed(di, di->usb_chg.psy);
2435 if (!ab8500_charger_get_usb_cur(di)) {
2437 ret = ab8500_charger_set_vbus_in_curr(di,
2438 di->max_usb_in_curr.usb_type_max);
2442 ab8500_charger_set_usb_connected(di, true);
2443 ab8500_power_supply_changed(di, di->usb_chg.psy);
2464 struct ab8500_charger *di = container_of(work,
2468 ret = abx500_get_register_interruptible(di->dev,
2471 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
2474 prev_status = di->flags.usbchargernotok;
2477 di->flags.usbchargernotok = true;
2479 queue_delayed_work(di->charger_wq,
2480 &di->check_usbchgnotok_work, HZ);
2482 di->flags.usbchargernotok = false;
2483 di->flags.vbus_collapse = false;
2486 if (prev_status != di->flags.usbchargernotok)
2487 ab8500_power_supply_changed(di, di->usb_chg.psy);
2502 struct ab8500_charger *di = container_of(work,
2506 ret = abx500_get_register_interruptible(di->dev,
2509 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
2513 di->flags.main_thermal_prot = true;
2515 di->flags.main_thermal_prot = false;
2517 ab8500_power_supply_changed(di, di->ac_chg.psy);
2532 struct ab8500_charger *di = container_of(work,
2536 ret = abx500_get_register_interruptible(di->dev,
2539 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
2543 di->flags.usb_thermal_prot = true;
2545 di->flags.usb_thermal_prot = false;
2547 ab8500_power_supply_changed(di, di->usb_chg.psy);
2559 struct ab8500_charger *di = _di;
2561 dev_dbg(di->dev, "Main charger unplugged\n");
2562 queue_work(di->charger_wq, &di->ac_work);
2564 cancel_delayed_work_sync(&di->ac_charger_attached_work);
2565 mutex_lock(&di->charger_attached_mutex);
2566 mutex_unlock(&di->charger_attached_mutex);
2580 struct ab8500_charger *di = _di;
2582 dev_dbg(di->dev, "Main charger plugged\n");
2583 queue_work(di->charger_wq, &di->ac_work);
2585 mutex_lock(&di->charger_attached_mutex);
2586 mutex_unlock(&di->charger_attached_mutex);
2588 if (is_ab8500(di->parent))
2589 queue_delayed_work(di->charger_wq,
2590 &di->ac_charger_attached_work,
2604 struct ab8500_charger *di = _di;
2606 dev_dbg(di->dev, "Main charger not ok\n");
2607 di->flags.mainextchnotok = true;
2608 ab8500_power_supply_changed(di, di->ac_chg.psy);
2611 queue_delayed_work(di->charger_wq, &di->check_hw_failure_work, 0);
2626 struct ab8500_charger *di = _di;
2628 dev_dbg(di->dev,
2630 queue_work(di->charger_wq, &di->check_main_thermal_prot_work);
2645 struct ab8500_charger *di = _di;
2647 dev_dbg(di->dev,
2649 queue_work(di->charger_wq, &di->check_main_thermal_prot_work);
2656 struct ab8500_charger *di = container_of(work,
2661 di->flags.vbus_drop_end = false;
2664 abx500_set_register_interruptible(di->dev,
2667 ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
2670 dev_err(di->dev, "%s read failed\n", __func__);
2674 curr = di->bm->chg_input_curr[
2677 if (di->max_usb_in_curr.calculated_max != curr) {
2679 di->max_usb_in_curr.calculated_max = curr;
2680 dev_dbg(di->dev,
2682 di->max_usb_in_curr.calculated_max);
2688 di->max_usb_in_curr.set_max =
2689 di->max_usb_in_curr.calculated_max;
2690 dev_dbg(di->dev,
2692 di->max_usb_in_curr.set_max);
2695 if (di->usb.charger_connected)
2696 ab8500_charger_set_vbus_in_curr(di,
2697 di->max_usb_in_curr.usb_type_max);
2709 struct ab8500_charger *di = _di;
2711 di->vbus_detected = false;
2712 dev_dbg(di->dev, "VBUS falling detected\n");
2713 queue_work(di->charger_wq, &di->detect_usb_type_work);
2727 struct ab8500_charger *di = _di;
2729 di->vbus_detected = true;
2730 dev_dbg(di->dev, "VBUS rising detected\n");
2732 queue_work(di->charger_wq, &di->detect_usb_type_work);
2746 struct ab8500_charger *di = _di;
2748 dev_dbg(di->dev, "USB link status changed\n");
2750 queue_work(di->charger_wq, &di->usb_link_status_work);
2765 struct ab8500_charger *di = _di;
2767 dev_dbg(di->dev,
2769 queue_work(di->charger_wq, &di->check_usb_thermal_prot_work);
2784 struct ab8500_charger *di = _di;
2786 dev_dbg(di->dev,
2788 queue_work(di->charger_wq, &di->check_usb_thermal_prot_work);
2802 struct ab8500_charger *di = _di;
2804 dev_dbg(di->dev, "Not allowed USB charger detected\n");
2805 queue_delayed_work(di->charger_wq, &di->check_usbchgnotok_work, 0);
2819 struct ab8500_charger *di = _di;
2821 dev_dbg(di->dev, "Charger watchdog expired\n");
2827 if (di->ac.charger_online) {
2828 di->ac.wd_expired = true;
2829 ab8500_power_supply_changed(di, di->ac_chg.psy);
2831 if (di->usb.charger_online) {
2832 di->usb.wd_expired = true;
2833 ab8500_power_supply_changed(di, di->usb_chg.psy);
2848 struct ab8500_charger *di = _di;
2850 dev_dbg(di->dev, "VBUS charger drop ended\n");
2851 di->flags.vbus_drop_end = true;
2857 queue_delayed_work(di->charger_wq, &di->vbus_drop_end_work,
2872 struct ab8500_charger *di = _di;
2874 dev_dbg(di->dev, "VBUS overvoltage detected\n");
2875 di->flags.vbus_ovv = true;
2876 ab8500_power_supply_changed(di, di->usb_chg.psy);
2879 queue_delayed_work(di->charger_wq, &di->check_hw_failure_work, 0);
2902 struct ab8500_charger *di;
2905 di = to_ab8500_charger_ac_device_info(psy_to_ux500_charger(psy));
2909 if (di->flags.mainextchnotok)
2911 else if (di->ac.wd_expired || di->usb.wd_expired)
2913 else if (di->flags.main_thermal_prot)
2919 val->intval = di->ac.charger_online;
2922 val->intval = di->ac.charger_connected;
2925 ret = ab8500_charger_get_ac_voltage(di);
2927 di->ac.charger_voltage = ret;
2929 val->intval = di->ac.charger_voltage * 1000;
2936 di->ac.cv_active = ab8500_charger_ac_cv(di);
2937 val->intval = di->ac.cv_active;
2940 ret = ab8500_charger_get_ac_current(di);
2942 di->ac.charger_current = ret;
2943 val->intval = di->ac.charger_current * 1000;
2969 struct ab8500_charger *di;
2972 di = to_ab8500_charger_usb_device_info(psy_to_ux500_charger(psy));
2976 if (di->flags.usbchargernotok)
2978 else if (di->ac.wd_expired || di->usb.wd_expired)
2980 else if (di->flags.usb_thermal_prot)
2982 else if (di->flags.vbus_ovv)
2988 val->intval = di->usb.charger_online;
2991 val->intval = di->usb.charger_connected;
2994 ret = ab8500_charger_get_vbus_voltage(di);
2996 di->usb.charger_voltage = ret;
2997 val->intval = di->usb.charger_voltage * 1000;
3004 di->usb.cv_active = ab8500_charger_usb_cv(di);
3005 val->intval = di->usb.cv_active;
3008 ret = ab8500_charger_get_usb_current(di);
3010 di->usb.charger_current = ret;
3011 val->intval = di->usb.charger_current * 1000;
3018 if (di->flags.vbus_collapse)
3031 * @di: pointer to the ab8500_charger structure
3036 static int ab8500_charger_init_hw_registers(struct ab8500_charger *di)
3041 if (!is_ab8500_1p1_or_earlier(di->parent)) {
3042 ret = abx500_set_register_interruptible(di->dev,
3046 dev_err(di->dev,
3051 ret = abx500_set_register_interruptible(di->dev,
3055 dev_err(di->dev,
3061 if (is_ab8505_2p0(di->parent))
3062 ret = abx500_mask_and_set_register_interruptible(di->dev,
3071 ret = abx500_set_register_interruptible(di->dev,
3076 dev_err(di->dev,
3082 ret = abx500_set_register_interruptible(di->dev,
3085 dev_err(di->dev, "failed to enable main WD in OTP\n");
3090 ret = abx500_set_register_interruptible(di->dev,
3094 dev_err(di->dev, "failed to enable main watchdog\n");
3107 ret = abx500_set_register_interruptible(di->dev,
3112 dev_err(di->dev, "failed to kick main watchdog\n");
3117 ret = abx500_set_register_interruptible(di->dev,
3121 dev_err(di->dev, "failed to disable main watchdog\n");
3126 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
3129 dev_err(di->dev, "failed to set charger watchdog timeout\n");
3133 ret = ab8500_charger_led_en(di, false);
3135 dev_err(di->dev, "failed to disable LED\n");
3139 ret = abx500_set_register_interruptible(di->dev,
3142 (di->bm->bkup_bat_v & 0x3) | di->bm->bkup_bat_i);
3144 dev_err(di->dev, "failed to setup backup battery charging\n");
3149 ret = abx500_mask_and_set_register_interruptible(di->dev,
3153 dev_err(di->dev, "%s mask and set failed\n", __func__);
3184 struct ab8500_charger *di =
3189 if (!di)
3193 dev_dbg(di->dev, "not a standard host, returning\n");
3200 if ((di->usb_state.usb_current == 2) && (mA > 2))
3211 dev_dbg(di->dev, "%s usb_state: 0x%02x mA: %d\n",
3214 spin_lock(&di->usb_state.usb_lock);
3215 di->usb_state.state_tmp = bm_usb_state;
3216 di->usb_state.usb_current_tmp = mA;
3217 spin_unlock(&di->usb_state.usb_lock);
3223 queue_delayed_work(di->charger_wq, &di->usb_state_changed_work, HZ/2);
3232 struct ab8500_charger *di = platform_get_drvdata(pdev);
3243 if (di->ac_conn && is_ab8500_1p1_or_earlier(di->parent)) {
3244 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
3247 dev_err(di->dev, "Failed to kick WD!\n");
3250 queue_delayed_work(di->charger_wq, &di->kick_wd_work,
3255 if (di->flags.mainextchnotok || di->flags.vbus_ovv) {
3256 queue_delayed_work(di->charger_wq,
3257 &di->check_hw_failure_work, 0);
3260 if (di->flags.vbus_drop_end)
3261 queue_delayed_work(di->charger_wq, &di->vbus_drop_end_work, 0);
3269 struct ab8500_charger *di = platform_get_drvdata(pdev);
3272 cancel_delayed_work(&di->check_hw_failure_work);
3273 cancel_delayed_work(&di->vbus_drop_end_work);
3275 flush_delayed_work(&di->attach_work);
3276 flush_delayed_work(&di->usb_charger_attached_work);
3277 flush_delayed_work(&di->ac_charger_attached_work);
3278 flush_delayed_work(&di->check_usbchgnotok_work);
3279 flush_delayed_work(&di->check_vbat_work);
3280 flush_delayed_work(&di->kick_wd_work);
3282 flush_work(&di->usb_link_status_work);
3283 flush_work(&di->ac_work);
3284 flush_work(&di->detect_usb_type_work);
3286 if (atomic_read(&di->current_stepping_sessions))
3302 struct ab8500_charger *di = platform_get_drvdata(pdev);
3306 ab8500_charger_ac_en(&di->ac_chg, false, 0, 0);
3309 ab8500_charger_usb_en(&di->usb_chg, false, 0, 0);
3314 free_irq(irq, di);
3318 ret = abx500_mask_and_set_register_interruptible(di->dev,
3321 dev_err(di->dev, "%s mask and set failed\n", __func__);
3323 usb_unregister_notifier(di->usb_phy, &di->nb);
3324 usb_put_phy(di->usb_phy);
3327 destroy_workqueue(di->charger_wq);
3330 if (!di->ac_chg.enabled)
3335 if (di->usb_chg.enabled)
3336 power_supply_unregister(di->usb_chg.psy);
3338 if (di->ac_chg.enabled && !di->ac_chg.external)
3339 power_supply_unregister(di->ac_chg.psy);
3371 struct ab8500_charger *di;
3374 di = devm_kzalloc(&pdev->dev, sizeof(*di), GFP_KERNEL);
3375 if (!di) {
3384 di->bm = plat;
3387 ret = ab8500_bm_of_probe(&pdev->dev, np, di->bm);
3392 di->autopower_cfg = of_property_read_bool(np, "autopower_cfg");
3394 di->autopower_cfg = false;
3397 di->dev = &pdev->dev;
3398 di->parent = dev_get_drvdata(pdev->dev.parent);
3401 di->adc_main_charger_v = devm_iio_channel_get(&pdev->dev,
3403 if (IS_ERR(di->adc_main_charger_v)) {
3404 if (PTR_ERR(di->adc_main_charger_v) == -ENODEV)
3407 return PTR_ERR(di->adc_main_charger_v);
3409 di->adc_main_charger_c = devm_iio_channel_get(&pdev->dev,
3411 if (IS_ERR(di->adc_main_charger_c)) {
3412 if (PTR_ERR(di->adc_main_charger_c) == -ENODEV)
3415 return PTR_ERR(di->adc_main_charger_c);
3417 di->adc_vbus_v = devm_iio_channel_get(&pdev->dev, "vbus_v");
3418 if (IS_ERR(di->adc_vbus_v)) {
3419 if (PTR_ERR(di->adc_vbus_v) == -ENODEV)
3422 return PTR_ERR(di->adc_vbus_v);
3424 di->adc_usb_charger_c = devm_iio_channel_get(&pdev->dev,
3426 if (IS_ERR(di->adc_usb_charger_c)) {
3427 if (PTR_ERR(di->adc_usb_charger_c) == -ENODEV)
3430 return PTR_ERR(di->adc_usb_charger_c);
3434 spin_lock_init(&di->usb_state.usb_lock);
3435 mutex_init(&di->usb_ipt_crnt_lock);
3437 di->autopower = false;
3438 di->invalid_charger_detect_state = 0;
3443 ac_psy_cfg.drv_data = &di->ac_chg;
3446 usb_psy_cfg.drv_data = &di->usb_chg;
3450 di->ac_chg.ops.enable = &ab8500_charger_ac_en;
3451 di->ac_chg.ops.check_enable = &ab8500_charger_ac_check_enable;
3452 di->ac_chg.ops.kick_wd = &ab8500_charger_watchdog_kick;
3453 di->ac_chg.ops.update_curr = &ab8500_charger_update_charger_current;
3454 di->ac_chg.max_out_volt = ab8500_charger_voltage_map[
3456 di->ac_chg.max_out_curr =
3457 di->bm->chg_output_curr[di->bm->n_chg_out_curr - 1];
3458 di->ac_chg.wdt_refresh = CHG_WD_INTERVAL;
3459 di->ac_chg.enabled = di->bm->ac_enabled;
3460 di->ac_chg.external = false;
3463 if (!di->ac_chg.enabled)
3469 di->usb_chg.ops.enable = &ab8500_charger_usb_en;
3470 di->usb_chg.ops.check_enable = &ab8500_charger_usb_check_enable;
3471 di->usb_chg.ops.kick_wd = &ab8500_charger_watchdog_kick;
3472 di->usb_chg.ops.update_curr = &ab8500_charger_update_charger_current;
3473 di->usb_chg.max_out_volt = ab8500_charger_voltage_map[
3475 di->usb_chg.max_out_curr =
3476 di->bm->chg_output_curr[di->bm->n_chg_out_curr - 1];
3477 di->usb_chg.wdt_refresh = CHG_WD_INTERVAL;
3478 di->usb_chg.enabled = di->bm->usb_enabled;
3479 di->usb_chg.external = false;
3480 di->usb_state.usb_current = -1;
3483 di->charger_wq = alloc_ordered_workqueue("ab8500_charger_wq",
3485 if (di->charger_wq == NULL) {
3486 dev_err(di->dev, "failed to create work queue\n");
3490 mutex_init(&di->charger_attached_mutex);
3493 INIT_DEFERRABLE_WORK(&di->check_hw_failure_work,
3495 INIT_DEFERRABLE_WORK(&di->check_usbchgnotok_work,
3498 INIT_DELAYED_WORK(&di->ac_charger_attached_work,
3500 INIT_DELAYED_WORK(&di->usb_charger_attached_work,
3512 INIT_DEFERRABLE_WORK(&di->kick_wd_work,
3515 INIT_DEFERRABLE_WORK(&di->check_vbat_work,
3518 INIT_DELAYED_WORK(&di->attach_work,
3521 INIT_DELAYED_WORK(&di->usb_state_changed_work,
3524 INIT_DELAYED_WORK(&di->vbus_drop_end_work,
3528 INIT_WORK(&di->usb_link_status_work,
3530 INIT_WORK(&di->ac_work, ab8500_charger_ac_work);
3531 INIT_WORK(&di->detect_usb_type_work,
3535 INIT_WORK(&di->check_main_thermal_prot_work,
3537 INIT_WORK(&di->check_usb_thermal_prot_work,
3545 di->regu = devm_regulator_get(di->dev, "vddadc");
3546 if (IS_ERR(di->regu)) {
3547 ret = PTR_ERR(di->regu);
3548 dev_err(di->dev, "failed to get vddadc regulator\n");
3554 ret = ab8500_charger_init_hw_registers(di);
3556 dev_err(di->dev, "failed to initialize ABB registers\n");
3561 if (di->ac_chg.enabled) {
3562 di->ac_chg.psy = power_supply_register(di->dev,
3565 if (IS_ERR(di->ac_chg.psy)) {
3566 dev_err(di->dev, "failed to register AC charger\n");
3567 ret = PTR_ERR(di->ac_chg.psy);
3573 if (di->usb_chg.enabled) {
3574 di->usb_chg.psy = power_supply_register(di->dev,
3577 if (IS_ERR(di->usb_chg.psy)) {
3578 dev_err(di->dev, "failed to register USB charger\n");
3579 ret = PTR_ERR(di->usb_chg.psy);
3584 di->usb_phy = usb_get_phy(USB_PHY_TYPE_USB2);
3585 if (IS_ERR_OR_NULL(di->usb_phy)) {
3586 dev_err(di->dev, "failed to get usb transceiver\n");
3590 di->nb.notifier_call = ab8500_charger_usb_notifier_call;
3591 ret = usb_register_notifier(di->usb_phy, &di->nb);
3593 dev_err(di->dev, "failed to register usb notifier\n");
3598 charger_status = ab8500_charger_detect_chargers(di, true);
3600 di->ac.charger_connected = 1;
3601 di->ac_conn = true;
3602 ab8500_power_supply_changed(di, di->ac_chg.psy);
3603 sysfs_notify(&di->ac_chg.psy->dev.kobj, NULL, "present");
3607 di->vbus_detected = true;
3608 di->vbus_detected_start = true;
3609 queue_work(di->charger_wq,
3610 &di->detect_usb_type_work);
3623 ab8500_charger_irq[i].name, di);
3626 dev_err(di->dev, "failed to request %s IRQ %d: %d\n"
3630 dev_dbg(di->dev, "Requested %s IRQ %d: %d\n",
3634 platform_set_drvdata(pdev, di);
3636 mutex_lock(&di->charger_attached_mutex);
3638 ch_stat = ab8500_charger_detect_chargers(di, false);
3641 if (is_ab8500(di->parent))
3642 queue_delayed_work(di->charger_wq,
3643 &di->ac_charger_attached_work,
3647 if (is_ab8500(di->parent))
3648 queue_delayed_work(di->charger_wq,
3649 &di->usb_charger_attached_work,
3653 mutex_unlock(&di->charger_attached_mutex);
3658 usb_unregister_notifier(di->usb_phy, &di->nb);
3663 free_irq(irq, di);
3666 usb_put_phy(di->usb_phy);
3668 if (di->usb_chg.enabled)
3669 power_supply_unregister(di->usb_chg.psy);
3671 if (di->ac_chg.enabled)
3672 power_supply_unregister(di->ac_chg.psy);
3674 destroy_workqueue(di->charger_wq);