Lines Matching refs:di
350 static void ab8500_enable_disable_sw_fallback(struct ab8500_charger *di,
359 dev_dbg(di->dev, "SW Fallback: %d\n", fallback);
361 if (is_ab8500(di->parent)) {
372 ret = abx500_get_register_interruptible(di->dev, bank, reg, &val);
374 dev_err(di->dev, "%d read failed\n", __LINE__);
378 if (is_ab8500(di->parent)) {
380 ret = abx500_set_register_interruptible(di->dev, 0x11, 0x00, 0x2);
382 dev_err(di->dev, "%d write failed\n", __LINE__);
393 ret = abx500_set_register_interruptible(di->dev, bank, reg, val);
395 dev_err(di->dev, "%d write failed\n", __LINE__);
399 if (is_ab8500(di->parent)) {
401 ret = abx500_set_register_interruptible(di->dev, 0x11, 0x00, 0x0);
403 dev_err(di->dev, "%d write failed\n", __LINE__);
411 * @di: pointer to the ab8500_charger structure
415 static void ab8500_power_supply_changed(struct ab8500_charger *di,
426 if (di->autopower_cfg) {
427 if (!di->usb.charger_connected &&
428 !di->ac.charger_connected &&
429 di->autopower) {
430 di->autopower = false;
431 ab8500_enable_disable_sw_fallback(di, false);
432 } else if (!di->autopower &&
433 (di->ac.charger_connected ||
434 di->usb.charger_connected)) {
435 di->autopower = true;
436 ab8500_enable_disable_sw_fallback(di, true);
442 static void ab8500_charger_set_usb_connected(struct ab8500_charger *di,
445 if (connected != di->usb.charger_connected) {
446 dev_dbg(di->dev, "USB connected:%i\n", connected);
447 di->usb.charger_connected = connected;
450 di->flags.vbus_drop_end = false;
457 if (di->usb_chg.psy) {
458 sysfs_notify(&di->usb_chg.psy->dev.kobj, NULL,
463 mutex_lock(&di->charger_attached_mutex);
464 mutex_unlock(&di->charger_attached_mutex);
466 if (is_ab8500(di->parent))
467 queue_delayed_work(di->charger_wq,
468 &di->usb_charger_attached_work,
471 cancel_delayed_work_sync(&di->usb_charger_attached_work);
472 mutex_lock(&di->charger_attached_mutex);
473 mutex_unlock(&di->charger_attached_mutex);
480 * @di: pointer to the ab8500_charger structure
484 static int ab8500_charger_get_ac_voltage(struct ab8500_charger *di)
489 if (di->ac.charger_connected) {
490 ret = iio_read_channel_processed(di->adc_main_charger_v, &vch);
492 dev_err(di->dev, "%s ADC conv failed,\n", __func__);
502 * @di: pointer to the ab8500_charger structure
506 static int ab8500_charger_ac_cv(struct ab8500_charger *di)
512 if (di->ac.charger_online) {
513 ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
516 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
531 * @di: pointer to the ab8500_charger structure
536 static int ab8500_charger_get_vbus_voltage(struct ab8500_charger *di)
541 if (di->usb.charger_connected) {
542 ret = iio_read_channel_processed(di->adc_vbus_v, &vch);
544 dev_err(di->dev, "%s ADC conv failed,\n", __func__);
554 * @di: pointer to the ab8500_charger structure
559 static int ab8500_charger_get_usb_current(struct ab8500_charger *di)
564 if (di->usb.charger_online) {
565 ret = iio_read_channel_processed(di->adc_usb_charger_c, &ich);
567 dev_err(di->dev, "%s ADC conv failed,\n", __func__);
577 * @di: pointer to the ab8500_charger structure
582 static int ab8500_charger_get_ac_current(struct ab8500_charger *di)
587 if (di->ac.charger_online) {
588 ret = iio_read_channel_processed(di->adc_main_charger_c, &ich);
590 dev_err(di->dev, "%s ADC conv failed,\n", __func__);
600 * @di: pointer to the ab8500_charger structure
604 static int ab8500_charger_usb_cv(struct ab8500_charger *di)
610 if (di->usb.charger_online) {
611 ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
614 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
631 * @di: pointer to the ab8500_charger structure
646 static int ab8500_charger_detect_chargers(struct ab8500_charger *di, bool probe)
653 ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
656 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
674 ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
677 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
680 dev_dbg(di->dev,
691 * @di: pointer to the ab8500_charger structure
698 static int ab8500_charger_max_usb_curr(struct ab8500_charger *di,
703 di->usb_device_is_unrecognised = false;
716 dev_dbg(di->dev, "USB Type - Standard host is "
718 di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P5;
719 di->is_aca_rid = 0;
722 di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P5;
723 di->is_aca_rid = 0;
726 di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P5;
727 di->is_aca_rid = 0;
730 di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P9;
731 di->is_aca_rid = 0;
738 dev_dbg(di->dev, "USB_STAT_ACA_RID_A detected\n");
739 di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P5;
740 di->is_aca_rid = 1;
747 di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_1P3;
748 dev_dbg(di->dev, "USB Type - 0x%02x MaxCurr: %d", link_status,
749 di->max_usb_in_curr.usb_type_max_ua);
750 di->is_aca_rid = 1;
753 di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P5;
754 di->is_aca_rid = 0;
757 di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_1P5;
758 di->is_aca_rid = 0;
762 di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_1P5;
763 di->is_aca_rid = 1;
766 if (di->vbus_detected) {
767 di->usb_device_is_unrecognised = true;
768 dev_dbg(di->dev, "USB Type - Legacy charger.\n");
769 di->max_usb_in_curr.usb_type_max_ua =
775 dev_err(di->dev, "USB Type - Charging not allowed\n");
776 di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P05;
780 if (is_ab8500(di->parent)) {
781 di->flags.vbus_collapse = true;
782 dev_err(di->dev, "USB Type - USB_STAT_RESERVED "
787 dev_dbg(di->dev, "USB Type - Charging not allowed\n");
788 di->max_usb_in_curr.usb_type_max_ua =
790 dev_dbg(di->dev, "USB Type - 0x%02x MaxCurr: %d",
792 di->max_usb_in_curr.usb_type_max_ua);
800 di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P5;
801 dev_dbg(di->dev, "USB Type - 0x%02x MaxCurr: %d", link_status,
802 di->max_usb_in_curr.usb_type_max_ua);
805 dev_err(di->dev, "USB Type invalid - try charging anyway\n");
806 di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P5;
810 dev_err(di->dev, "USB Type - Unknown\n");
811 di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P05;
816 di->max_usb_in_curr.set_max_ua = di->max_usb_in_curr.usb_type_max_ua;
817 dev_dbg(di->dev, "USB Type - 0x%02x MaxCurr: %d",
818 link_status, di->max_usb_in_curr.set_max_ua);
825 * @di: pointer to the ab8500_charger structure
830 static int ab8500_charger_read_usb_type(struct ab8500_charger *di)
835 ret = abx500_get_register_interruptible(di->dev,
838 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
841 if (is_ab8500(di->parent))
842 ret = abx500_get_register_interruptible(di->dev, AB8500_USB,
845 ret = abx500_get_register_interruptible(di->dev,
848 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
853 if (is_ab8500(di->parent))
857 ret = ab8500_charger_max_usb_curr(di,
865 * @di: pointer to the ab8500_charger structure
870 static int ab8500_charger_detect_usb_type(struct ab8500_charger *di)
882 ret = abx500_get_register_interruptible(di->dev,
885 dev_dbg(di->dev, "%s AB8500_IT_SOURCE21_REG %x\n",
888 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
892 if (is_ab8500(di->parent))
893 ret = abx500_get_register_interruptible(di->dev,
896 ret = abx500_get_register_interruptible(di->dev,
899 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
902 dev_dbg(di->dev, "%s AB8500_USB_LINE_STAT_REG %x\n", __func__,
911 if (is_ab8500(di->parent))
920 ret = ab8500_charger_max_usb_curr(di,
1044 static int ab8500_current_to_regval(struct ab8500_charger *di, int curr_ua)
1064 static int ab8500_vbus_in_curr_to_regval(struct ab8500_charger *di, int curr_ua)
1086 * @di: pointer to the ab8500_charger structure
1093 static int ab8500_charger_get_usb_cur(struct ab8500_charger *di)
1096 switch (di->usb_state.usb_current_ua) {
1098 di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P09;
1101 di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P19;
1104 di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P29;
1107 di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P38;
1110 di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P5;
1113 di->max_usb_in_curr.usb_type_max_ua = USB_CH_IP_CUR_LVL_0P05;
1117 di->max_usb_in_curr.set_max_ua = di->max_usb_in_curr.usb_type_max_ua;
1123 * @di: pointer to the ab8500_charger structure
1130 static bool ab8500_charger_check_continue_stepping(struct ab8500_charger *di,
1134 return !di->flags.vbus_drop_end;
1141 * @di: pointer to the ab8500_charger structure
1152 static int ab8500_charger_set_current(struct ab8500_charger *di,
1161 atomic_inc(&di->current_stepping_sessions);
1163 ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
1166 dev_err(di->dev, "%s read failed\n", __func__);
1174 curr_index = ab8500_current_to_regval(di, ich_ua);
1176 if (!di->ac.charger_connected)
1182 curr_index = ab8500_vbus_in_curr_to_regval(di, ich_ua);
1185 if (!di->usb.charger_connected)
1191 curr_index = ab8500_current_to_regval(di, ich_ua);
1196 if (!di->usb.charger_connected && !di->ac.charger_connected)
1201 dev_err(di->dev, "%s current register not valid\n", __func__);
1207 dev_err(di->dev, "requested current limit out-of-range\n");
1214 dev_dbg(di->dev, "%s current not changed for reg: 0x%02x\n",
1220 dev_dbg(di->dev, "%s set charger current: %d uA for reg: 0x%02x\n",
1224 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1227 dev_err(di->dev, "%s write failed\n", __func__);
1230 dev_dbg(di->dev, "curr change_1 to: %x for 0x%02x\n",
1232 ret = abx500_set_register_interruptible(di->dev,
1235 dev_err(di->dev, "%s write failed\n", __func__);
1244 dev_dbg(di->dev, "curr change_2 to: %x for 0x%02x\n",
1246 ret = abx500_set_register_interruptible(di->dev,
1249 dev_err(di->dev, "%s write failed\n", __func__);
1255 allow = ab8500_charger_check_continue_stepping(di, reg);
1260 atomic_dec(&di->current_stepping_sessions);
1267 * @di: pointer to the ab8500_charger structure
1273 static int ab8500_charger_set_vbus_in_curr(struct ab8500_charger *di,
1280 min_value = min(di->bm->chg_params->usb_curr_max_ua, ich_in_ua);
1281 if (di->max_usb_in_curr.set_max_ua > 0)
1282 min_value = min(di->max_usb_in_curr.set_max_ua, min_value);
1284 if (di->usb_state.usb_current_ua >= 0)
1285 min_value = min(di->usb_state.usb_current_ua, min_value);
1289 if (di->vbat < VBAT_TRESH_IP_CUR_RED)
1293 if (di->vbat < VBAT_TRESH_IP_CUR_RED)
1300 dev_info(di->dev, "VBUS input current limit set to %d uA\n", min_value);
1302 mutex_lock(&di->usb_ipt_crnt_lock);
1303 ret = ab8500_charger_set_current(di, min_value,
1305 mutex_unlock(&di->usb_ipt_crnt_lock);
1312 * @di: pointer to the ab8500_charger structure
1318 static int ab8500_charger_set_main_in_curr(struct ab8500_charger *di,
1321 return ab8500_charger_set_current(di, ich_in_ua,
1327 * @di: pointer to the ab8500_charger structure
1333 static int ab8500_charger_set_output_curr(struct ab8500_charger *di,
1336 return ab8500_charger_set_current(di, ich_out_ua,
1342 * @di: pointer to the ab8500_charger structure
1348 static int ab8500_charger_led_en(struct ab8500_charger *di, int on)
1354 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1358 dev_err(di->dev, "Power ON LED failed\n");
1362 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1366 dev_err(di->dev, "Set LED PWM duty cycle failed\n");
1371 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1375 dev_err(di->dev, "Power-off LED failed\n");
1385 * @di: pointer to the ab8500_charger structure
1402 struct ab8500_charger *di = to_ab8500_charger_ac_device_info(charger);
1406 if (!di->ac.charger_connected) {
1407 dev_err(di->dev, "AC charger not connected\n");
1412 dev_dbg(di->dev, "Enable AC: %duV %duA\n", vset_uv, iset_ua);
1424 if (!di->vddadc_en_ac) {
1425 ret = regulator_enable(di->regu);
1427 dev_warn(di->dev,
1430 di->vddadc_en_ac = true;
1435 curr_index = ab8500_current_to_regval(di, iset_ua);
1436 input_curr_index = ab8500_current_to_regval(di,
1437 di->bm->chg_params->ac_curr_max_ua);
1439 dev_err(di->dev,
1446 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1449 dev_err(di->dev, "%s write failed\n", __func__);
1453 ret = ab8500_charger_set_main_in_curr(di,
1454 di->bm->chg_params->ac_curr_max_ua);
1456 dev_err(di->dev, "%s Failed to set MainChInputCurr\n",
1461 ret = ab8500_charger_set_output_curr(di, iset_ua);
1463 dev_err(di->dev, "%s "
1470 if (!di->bm->enable_overshoot)
1474 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1477 dev_err(di->dev, "%s write failed\n", __func__);
1482 ret = ab8500_charger_led_en(di, true);
1484 dev_err(di->dev, "failed to enable LED\n");
1486 di->ac.charger_online = 1;
1489 if (is_ab8500_1p1_or_earlier(di->parent)) {
1500 if (di->ac_conn) {
1501 queue_delayed_work(di->charger_wq,
1502 &di->kick_wd_work,
1513 ret = abx500_set_register_interruptible(di->dev,
1517 dev_err(di->dev,
1522 ret = ab8500_charger_set_output_curr(di, 0);
1524 dev_err(di->dev, "%s "
1530 ret = abx500_set_register_interruptible(di->dev,
1534 dev_err(di->dev,
1540 ret = ab8500_charger_led_en(di, false);
1542 dev_err(di->dev, "failed to disable LED\n");
1544 di->ac.charger_online = 0;
1545 di->ac.wd_expired = false;
1548 if (di->vddadc_en_ac) {
1549 regulator_disable(di->regu);
1550 di->vddadc_en_ac = false;
1553 dev_dbg(di->dev, "%s Disabled AC charging\n", __func__);
1555 ab8500_power_supply_changed(di, di->ac_chg.psy);
1562 * @di: pointer to the ab8500_charger structure
1578 struct ab8500_charger *di = to_ab8500_charger_usb_device_info(charger);
1582 if (!di->usb.charger_connected) {
1583 dev_err(di->dev, "USB charger not connected\n");
1597 if (!di->vddadc_en_usb) {
1598 ret = regulator_enable(di->regu);
1600 dev_warn(di->dev,
1603 di->vddadc_en_usb = true;
1607 dev_dbg(di->dev, "Enable USB: %d uV %d uA\n", vset_uv, ich_out_ua);
1611 curr_index = ab8500_current_to_regval(di, ich_out_ua);
1613 dev_err(di->dev,
1623 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1626 dev_err(di->dev, "%s write failed\n", __func__);
1630 if (!di->bm->enable_overshoot)
1634 dev_dbg(di->dev,
1636 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1639 dev_err(di->dev, "%s write failed\n", __func__);
1644 ret = ab8500_charger_led_en(di, true);
1646 dev_err(di->dev, "failed to enable LED\n");
1648 di->usb.charger_online = 1;
1651 ret = ab8500_charger_set_vbus_in_curr(di,
1652 di->max_usb_in_curr.usb_type_max_ua);
1654 dev_err(di->dev, "setting USBChInputCurr failed\n");
1659 ret = ab8500_charger_set_output_curr(di, ich_out_ua);
1661 dev_err(di->dev, "%s "
1667 queue_delayed_work(di->charger_wq, &di->check_vbat_work, HZ);
1671 dev_dbg(di->dev, "%s Disabled USB charging\n", __func__);
1672 ret = abx500_set_register_interruptible(di->dev,
1676 dev_err(di->dev,
1681 ret = ab8500_charger_led_en(di, false);
1683 dev_err(di->dev, "failed to disable LED\n");
1685 ret = ab8500_charger_set_vbus_in_curr(di, 0);
1687 dev_err(di->dev, "setting USBChInputCurr failed\n");
1692 ret = ab8500_charger_set_output_curr(di, 0);
1694 dev_err(di->dev, "%s "
1699 di->usb.charger_online = 0;
1700 di->usb.wd_expired = false;
1703 if (di->vddadc_en_usb) {
1704 regulator_disable(di->regu);
1705 di->vddadc_en_usb = false;
1708 dev_dbg(di->dev, "%s Disabled USB charging\n", __func__);
1711 cancel_delayed_work(&di->check_vbat_work);
1714 ab8500_power_supply_changed(di, di->usb_chg.psy);
1734 struct ab8500_charger *di = to_ab8500_charger_usb_device_info(charger);
1736 if (!di->usb.charger_connected)
1739 ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
1742 dev_err(di->dev, "ab8500 read failed %d\n", __LINE__);
1745 dev_dbg(di->dev, "USB charger ctrl: 0x%02x\n", usbch_ctrl1);
1748 dev_info(di->dev, "Charging has been disabled abnormally and will be re-enabled\n");
1750 ret = abx500_mask_and_set_register_interruptible(di->dev,
1754 dev_err(di->dev, "ab8500 write failed %d\n", __LINE__);
1758 ret = ab8500_charger_usb_en(&di->usb_chg, true, vset_uv, iset_ua);
1760 dev_err(di->dev, "Failed to enable VBUS charger %d\n",
1783 struct ab8500_charger *di = to_ab8500_charger_ac_device_info(charger);
1785 if (!di->ac.charger_connected)
1788 ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
1791 dev_err(di->dev, "ab8500 read failed %d\n", __LINE__);
1794 dev_dbg(di->dev, "AC charger ctrl: 0x%02x\n", mainch_ctrl1);
1797 dev_info(di->dev, "Charging has been disabled abnormally and will be re-enabled\n");
1799 ret = abx500_mask_and_set_register_interruptible(di->dev,
1804 dev_err(di->dev, "ab8500 write failed %d\n", __LINE__);
1808 ret = ab8500_charger_ac_en(&di->usb_chg, true, vset_uv, iset_ua);
1810 dev_err(di->dev, "failed to enable AC charger %d\n",
1820 * @di: pointer to the ab8500_charger structure
1828 struct ab8500_charger *di;
1831 di = to_ab8500_charger_ac_device_info(charger);
1833 di = to_ab8500_charger_usb_device_info(charger);
1837 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1840 dev_err(di->dev, "Failed to kick WD!\n");
1857 struct ab8500_charger *di;
1860 di = to_ab8500_charger_ac_device_info(charger);
1862 di = to_ab8500_charger_usb_device_info(charger);
1866 ret = ab8500_charger_set_output_curr(di, ich_out_ua);
1868 dev_err(di->dev, "%s "
1875 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1878 dev_err(di->dev, "%s write failed\n", __func__);
1890 struct ab8500_charger *di;
1898 di = to_ab8500_charger_usb_device_info(usb_chg);
1922 dev_dbg(di->dev, "get VBAT from %s\n",
1924 di->vbat = ret.intval;
1949 struct ab8500_charger *di = container_of(work,
1953 &di->usb_chg, ab8500_charger_get_ext_psy_data);
1956 if (di->old_vbat == 0)
1957 di->old_vbat = di->vbat;
1959 if (!((di->old_vbat <= VBAT_TRESH_IP_CUR_RED &&
1960 di->vbat <= VBAT_TRESH_IP_CUR_RED) ||
1961 (di->old_vbat > VBAT_TRESH_IP_CUR_RED &&
1962 di->vbat > VBAT_TRESH_IP_CUR_RED))) {
1964 dev_dbg(di->dev, "Vbat did cross threshold, curr: %d, new: %d,"
1965 " old: %d\n", di->max_usb_in_curr.usb_type_max_ua,
1966 di->vbat, di->old_vbat);
1967 ab8500_charger_set_vbus_in_curr(di,
1968 di->max_usb_in_curr.usb_type_max_ua);
1969 power_supply_changed(di->usb_chg.psy);
1972 di->old_vbat = di->vbat;
1978 if (di->vbat < (VBAT_TRESH_IP_CUR_RED + 100000) &&
1979 (di->vbat > (VBAT_TRESH_IP_CUR_RED - 100000)))
1982 queue_delayed_work(di->charger_wq, &di->check_vbat_work, t * HZ);
1996 struct ab8500_charger *di = container_of(work,
2000 if (di->flags.mainextchnotok) {
2001 ret = abx500_get_register_interruptible(di->dev,
2004 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
2008 di->flags.mainextchnotok = false;
2009 ab8500_power_supply_changed(di, di->ac_chg.psy);
2012 if (di->flags.vbus_ovv) {
2013 ret = abx500_get_register_interruptible(di->dev,
2017 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
2021 di->flags.vbus_ovv = false;
2022 ab8500_power_supply_changed(di, di->usb_chg.psy);
2026 if (di->flags.mainextchnotok || di->flags.vbus_ovv) {
2027 queue_delayed_work(di->charger_wq,
2028 &di->check_hw_failure_work, round_jiffies(HZ));
2050 struct ab8500_charger *di = container_of(work,
2053 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
2056 dev_err(di->dev, "Failed to kick WD!\n");
2059 queue_delayed_work(di->charger_wq,
2060 &di->kick_wd_work, round_jiffies(WD_KICK_INTERVAL));
2073 struct ab8500_charger *di = container_of(work,
2081 ret = ab8500_charger_detect_chargers(di, false);
2086 di->ac.charger_connected = 1;
2087 di->ac_conn = true;
2089 di->ac.charger_connected = 0;
2092 ab8500_power_supply_changed(di, di->ac_chg.psy);
2093 sysfs_notify(&di->ac_chg.psy->dev.kobj, NULL, "present");
2098 struct ab8500_charger *di = container_of(work,
2106 ret = abx500_get_register_interruptible(di->dev,
2111 dev_err(di->dev, "ab8500 read failed %d\n", __LINE__);
2120 ab8500_charger_usb_en(&di->usb_chg, 0, 0, 0);
2122 mutex_lock(&di->charger_attached_mutex);
2123 mutex_unlock(&di->charger_attached_mutex);
2128 queue_delayed_work(di->charger_wq,
2129 &di->usb_charger_attached_work,
2136 struct ab8500_charger *di = container_of(work,
2145 ret = abx500_get_register_interruptible(di->dev,
2150 dev_err(di->dev, "ab8500 read failed %d\n", __LINE__);
2160 ab8500_charger_ac_en(&di->ac_chg, 0, 0, 0);
2161 queue_work(di->charger_wq, &di->ac_work);
2163 mutex_lock(&di->charger_attached_mutex);
2164 mutex_unlock(&di->charger_attached_mutex);
2169 queue_delayed_work(di->charger_wq,
2170 &di->ac_charger_attached_work,
2184 struct ab8500_charger *di = container_of(work,
2192 ret = ab8500_charger_detect_chargers(di, false);
2197 dev_dbg(di->dev, "%s di->vbus_detected = false\n", __func__);
2198 di->vbus_detected = false;
2199 ab8500_charger_set_usb_connected(di, false);
2200 ab8500_power_supply_changed(di, di->usb_chg.psy);
2202 dev_dbg(di->dev, "%s di->vbus_detected = true\n", __func__);
2203 di->vbus_detected = true;
2205 if (is_ab8500_1p1_or_earlier(di->parent)) {
2206 ret = ab8500_charger_detect_usb_type(di);
2208 ab8500_charger_set_usb_connected(di, true);
2209 ab8500_power_supply_changed(di,
2210 di->usb_chg.psy);
2220 if (di->vbus_detected_start) {
2221 di->vbus_detected_start = false;
2222 ret = ab8500_charger_detect_usb_type(di);
2224 ab8500_charger_set_usb_connected(di,
2226 ab8500_power_supply_changed(di,
2227 di->usb_chg.psy);
2242 struct ab8500_charger *di =
2247 if (!di->usb.charger_online) {
2248 ret = ab8500_charger_set_vbus_in_curr(di,
2249 di->max_usb_in_curr.usb_type_max_ua);
2254 ab8500_charger_set_usb_connected(di, true);
2255 ab8500_power_supply_changed(di, di->usb_chg.psy);
2271 struct ab8500_charger *di = container_of(work,
2279 detected_chargers = ab8500_charger_detect_chargers(di, false);
2289 if (is_ab8500(di->parent))
2290 ret = abx500_get_register_interruptible(di->dev, AB8500_USB,
2293 ret = abx500_get_register_interruptible(di->dev, AB8500_USB,
2297 dev_dbg(di->dev, "UsbLineStatus register = 0x%02x\n", val);
2299 dev_dbg(di->dev, "Error reading USB link status\n");
2301 if (is_ab8500(di->parent))
2309 di->invalid_charger_detect_state == 0) {
2310 dev_dbg(di->dev,
2313 abx500_mask_and_set_register_interruptible(di->dev,
2317 abx500_mask_and_set_register_interruptible(di->dev,
2320 di->invalid_charger_detect_state = 1;
2325 if (di->invalid_charger_detect_state == 1) {
2326 dev_dbg(di->dev,
2329 abx500_mask_and_set_register_interruptible(di->dev,
2333 if (is_ab8500(di->parent))
2334 ret = abx500_get_register_interruptible(di->dev,
2338 ret = abx500_get_register_interruptible(di->dev,
2342 dev_dbg(di->dev, "USB link status= 0x%02x\n",
2344 di->invalid_charger_detect_state = 2;
2347 di->invalid_charger_detect_state = 0;
2351 di->vbus_detected = false;
2352 ab8500_charger_set_usb_connected(di, false);
2353 ab8500_power_supply_changed(di, di->usb_chg.psy);
2357 dev_dbg(di->dev,"%s di->vbus_detected = true\n",__func__);
2358 di->vbus_detected = true;
2359 ret = ab8500_charger_read_usb_type(di);
2363 ab8500_charger_set_usb_connected(di, false);
2364 ab8500_power_supply_changed(di, di->usb_chg.psy);
2369 if (di->usb_device_is_unrecognised) {
2370 dev_dbg(di->dev,
2375 queue_delayed_work(di->charger_wq,
2376 &di->attach_work,
2378 } else if (di->is_aca_rid == 1) {
2380 di->is_aca_rid++;
2381 dev_dbg(di->dev,
2384 queue_delayed_work(di->charger_wq,
2385 &di->attach_work,
2388 queue_delayed_work(di->charger_wq,
2389 &di->attach_work,
2399 struct ab8500_charger *di = container_of(work,
2402 if (!di->vbus_detected) {
2403 dev_dbg(di->dev,
2404 "%s !di->vbus_detected\n",
2409 spin_lock_irqsave(&di->usb_state.usb_lock, flags);
2410 di->usb_state.state = di->usb_state.state_tmp;
2411 di->usb_state.usb_current_ua = di->usb_state.usb_current_tmp_ua;
2412 spin_unlock_irqrestore(&di->usb_state.usb_lock, flags);
2414 dev_dbg(di->dev, "%s USB state: 0x%02x uA: %d\n",
2415 __func__, di->usb_state.state, di->usb_state.usb_current_ua);
2417 switch (di->usb_state.state) {
2422 ab8500_charger_set_usb_connected(di, false);
2423 ab8500_power_supply_changed(di, di->usb_chg.psy);
2438 if (!ab8500_charger_get_usb_cur(di)) {
2440 ret = ab8500_charger_set_vbus_in_curr(di,
2441 di->max_usb_in_curr.usb_type_max_ua);
2445 ab8500_charger_set_usb_connected(di, true);
2446 ab8500_power_supply_changed(di, di->usb_chg.psy);
2467 struct ab8500_charger *di = container_of(work,
2471 ret = abx500_get_register_interruptible(di->dev,
2474 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
2477 prev_status = di->flags.usbchargernotok;
2480 di->flags.usbchargernotok = true;
2482 queue_delayed_work(di->charger_wq,
2483 &di->check_usbchgnotok_work, HZ);
2485 di->flags.usbchargernotok = false;
2486 di->flags.vbus_collapse = false;
2489 if (prev_status != di->flags.usbchargernotok)
2490 ab8500_power_supply_changed(di, di->usb_chg.psy);
2505 struct ab8500_charger *di = container_of(work,
2509 ret = abx500_get_register_interruptible(di->dev,
2512 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
2516 di->flags.main_thermal_prot = true;
2518 di->flags.main_thermal_prot = false;
2520 ab8500_power_supply_changed(di, di->ac_chg.psy);
2535 struct ab8500_charger *di = container_of(work,
2539 ret = abx500_get_register_interruptible(di->dev,
2542 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
2546 di->flags.usb_thermal_prot = true;
2548 di->flags.usb_thermal_prot = false;
2550 ab8500_power_supply_changed(di, di->usb_chg.psy);
2562 struct ab8500_charger *di = _di;
2564 dev_dbg(di->dev, "Main charger unplugged\n");
2565 queue_work(di->charger_wq, &di->ac_work);
2567 cancel_delayed_work_sync(&di->ac_charger_attached_work);
2568 mutex_lock(&di->charger_attached_mutex);
2569 mutex_unlock(&di->charger_attached_mutex);
2583 struct ab8500_charger *di = _di;
2585 dev_dbg(di->dev, "Main charger plugged\n");
2586 queue_work(di->charger_wq, &di->ac_work);
2588 mutex_lock(&di->charger_attached_mutex);
2589 mutex_unlock(&di->charger_attached_mutex);
2591 if (is_ab8500(di->parent))
2592 queue_delayed_work(di->charger_wq,
2593 &di->ac_charger_attached_work,
2607 struct ab8500_charger *di = _di;
2609 dev_dbg(di->dev, "Main charger not ok\n");
2610 di->flags.mainextchnotok = true;
2611 ab8500_power_supply_changed(di, di->ac_chg.psy);
2614 queue_delayed_work(di->charger_wq, &di->check_hw_failure_work, 0);
2629 struct ab8500_charger *di = _di;
2631 dev_dbg(di->dev,
2633 queue_work(di->charger_wq, &di->check_main_thermal_prot_work);
2648 struct ab8500_charger *di = _di;
2650 dev_dbg(di->dev,
2652 queue_work(di->charger_wq, &di->check_main_thermal_prot_work);
2659 struct ab8500_charger *di = container_of(work,
2664 di->flags.vbus_drop_end = false;
2667 abx500_set_register_interruptible(di->dev,
2670 ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
2673 dev_err(di->dev, "%s read failed\n", __func__);
2680 if (di->max_usb_in_curr.calculated_max_ua != curr_ua) {
2682 di->max_usb_in_curr.calculated_max_ua = curr_ua;
2683 dev_dbg(di->dev,
2685 di->max_usb_in_curr.calculated_max_ua);
2691 di->max_usb_in_curr.set_max_ua =
2692 di->max_usb_in_curr.calculated_max_ua;
2693 dev_dbg(di->dev,
2695 di->max_usb_in_curr.set_max_ua);
2698 if (di->usb.charger_connected)
2699 ab8500_charger_set_vbus_in_curr(di,
2700 di->max_usb_in_curr.usb_type_max_ua);
2712 struct ab8500_charger *di = _di;
2714 di->vbus_detected = false;
2715 dev_dbg(di->dev, "VBUS falling detected\n");
2716 queue_work(di->charger_wq, &di->detect_usb_type_work);
2730 struct ab8500_charger *di = _di;
2732 di->vbus_detected = true;
2733 dev_dbg(di->dev, "VBUS rising detected\n");
2735 queue_work(di->charger_wq, &di->detect_usb_type_work);
2749 struct ab8500_charger *di = _di;
2751 dev_dbg(di->dev, "USB link status changed\n");
2753 queue_work(di->charger_wq, &di->usb_link_status_work);
2768 struct ab8500_charger *di = _di;
2770 dev_dbg(di->dev,
2772 queue_work(di->charger_wq, &di->check_usb_thermal_prot_work);
2787 struct ab8500_charger *di = _di;
2789 dev_dbg(di->dev,
2791 queue_work(di->charger_wq, &di->check_usb_thermal_prot_work);
2805 struct ab8500_charger *di = _di;
2807 dev_dbg(di->dev, "Not allowed USB charger detected\n");
2808 queue_delayed_work(di->charger_wq, &di->check_usbchgnotok_work, 0);
2822 struct ab8500_charger *di = _di;
2824 dev_dbg(di->dev, "Charger watchdog expired\n");
2830 if (di->ac.charger_online) {
2831 di->ac.wd_expired = true;
2832 ab8500_power_supply_changed(di, di->ac_chg.psy);
2834 if (di->usb.charger_online) {
2835 di->usb.wd_expired = true;
2836 ab8500_power_supply_changed(di, di->usb_chg.psy);
2851 struct ab8500_charger *di = _di;
2853 dev_dbg(di->dev, "VBUS charger drop ended\n");
2854 di->flags.vbus_drop_end = true;
2860 queue_delayed_work(di->charger_wq, &di->vbus_drop_end_work,
2875 struct ab8500_charger *di = _di;
2877 dev_dbg(di->dev, "VBUS overvoltage detected\n");
2878 di->flags.vbus_ovv = true;
2879 ab8500_power_supply_changed(di, di->usb_chg.psy);
2882 queue_delayed_work(di->charger_wq, &di->check_hw_failure_work, 0);
2905 struct ab8500_charger *di;
2908 di = to_ab8500_charger_ac_device_info(psy_to_ux500_charger(psy));
2912 if (di->flags.mainextchnotok)
2914 else if (di->ac.wd_expired || di->usb.wd_expired)
2916 else if (di->flags.main_thermal_prot)
2922 val->intval = di->ac.charger_online;
2925 val->intval = di->ac.charger_connected;
2928 ret = ab8500_charger_get_ac_voltage(di);
2930 di->ac.charger_voltage_uv = ret;
2932 val->intval = di->ac.charger_voltage_uv;
2939 di->ac.cv_active = ab8500_charger_ac_cv(di);
2940 val->intval = di->ac.cv_active;
2943 ret = ab8500_charger_get_ac_current(di);
2945 di->ac.charger_current_ua = ret;
2946 val->intval = di->ac.charger_current_ua;
2972 struct ab8500_charger *di;
2975 di = to_ab8500_charger_usb_device_info(psy_to_ux500_charger(psy));
2979 if (di->flags.usbchargernotok)
2981 else if (di->ac.wd_expired || di->usb.wd_expired)
2983 else if (di->flags.usb_thermal_prot)
2985 else if (di->flags.vbus_ovv)
2991 val->intval = di->usb.charger_online;
2994 val->intval = di->usb.charger_connected;
2997 ret = ab8500_charger_get_vbus_voltage(di);
2999 di->usb.charger_voltage_uv = ret;
3000 val->intval = di->usb.charger_voltage_uv;
3007 di->usb.cv_active = ab8500_charger_usb_cv(di);
3008 val->intval = di->usb.cv_active;
3011 ret = ab8500_charger_get_usb_current(di);
3013 di->usb.charger_current_ua = ret;
3014 val->intval = di->usb.charger_current_ua;
3021 if (di->flags.vbus_collapse)
3034 * @di: pointer to the ab8500_charger structure
3039 static int ab8500_charger_init_hw_registers(struct ab8500_charger *di)
3044 if (!is_ab8500_1p1_or_earlier(di->parent)) {
3045 ret = abx500_set_register_interruptible(di->dev,
3049 dev_err(di->dev,
3054 ret = abx500_set_register_interruptible(di->dev,
3058 dev_err(di->dev,
3064 if (is_ab8505_2p0(di->parent))
3065 ret = abx500_mask_and_set_register_interruptible(di->dev,
3074 ret = abx500_set_register_interruptible(di->dev,
3079 dev_err(di->dev,
3085 ret = abx500_set_register_interruptible(di->dev,
3088 dev_err(di->dev, "failed to enable main WD in OTP\n");
3093 ret = abx500_set_register_interruptible(di->dev,
3097 dev_err(di->dev, "failed to enable main watchdog\n");
3110 ret = abx500_set_register_interruptible(di->dev,
3115 dev_err(di->dev, "failed to kick main watchdog\n");
3120 ret = abx500_set_register_interruptible(di->dev,
3124 dev_err(di->dev, "failed to disable main watchdog\n");
3129 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
3132 dev_err(di->dev, "failed to set charger watchdog timeout\n");
3136 ret = ab8500_charger_led_en(di, false);
3138 dev_err(di->dev, "failed to disable LED\n");
3142 ret = abx500_set_register_interruptible(di->dev,
3145 (di->bm->bkup_bat_v & 0x3) | di->bm->bkup_bat_i);
3147 dev_err(di->dev, "failed to setup backup battery charging\n");
3152 ret = abx500_mask_and_set_register_interruptible(di->dev,
3156 dev_err(di->dev, "%s mask and set failed\n", __func__);
3187 struct ab8500_charger *di =
3198 dev_dbg(di->dev, "not a standard host, returning\n");
3205 if ((di->usb_state.usb_current_ua == 2000) && (mA > 2))
3216 dev_dbg(di->dev, "%s usb_state: 0x%02x mA: %d\n",
3219 spin_lock(&di->usb_state.usb_lock);
3220 di->usb_state.state_tmp = bm_usb_state;
3222 di->usb_state.usb_current_tmp_ua = mA * 1000;
3223 spin_unlock(&di->usb_state.usb_lock);
3229 queue_delayed_work(di->charger_wq, &di->usb_state_changed_work, HZ/2);
3237 struct ab8500_charger *di = dev_get_drvdata(dev);
3248 if (di->ac_conn && is_ab8500_1p1_or_earlier(di->parent)) {
3249 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
3252 dev_err(di->dev, "Failed to kick WD!\n");
3255 queue_delayed_work(di->charger_wq, &di->kick_wd_work,
3260 if (di->flags.mainextchnotok || di->flags.vbus_ovv) {
3261 queue_delayed_work(di->charger_wq,
3262 &di->check_hw_failure_work, 0);
3265 if (di->flags.vbus_drop_end)
3266 queue_delayed_work(di->charger_wq, &di->vbus_drop_end_work, 0);
3273 struct ab8500_charger *di = dev_get_drvdata(dev);
3276 cancel_delayed_work(&di->check_hw_failure_work);
3277 cancel_delayed_work(&di->vbus_drop_end_work);
3279 flush_delayed_work(&di->attach_work);
3280 flush_delayed_work(&di->usb_charger_attached_work);
3281 flush_delayed_work(&di->ac_charger_attached_work);
3282 flush_delayed_work(&di->check_usbchgnotok_work);
3283 flush_delayed_work(&di->check_vbat_work);
3284 flush_delayed_work(&di->kick_wd_work);
3286 flush_work(&di->usb_link_status_work);
3287 flush_work(&di->ac_work);
3288 flush_work(&di->detect_usb_type_work);
3290 if (atomic_read(&di->current_stepping_sessions))
3320 struct ab8500_charger *di = dev_get_drvdata(dev);
3325 di->charger_wq = alloc_ordered_workqueue("ab8500_charger_wq",
3327 if (di->charger_wq == NULL) {
3332 ch_stat = ab8500_charger_detect_chargers(di, false);
3335 if (is_ab8500(di->parent))
3336 queue_delayed_work(di->charger_wq,
3337 &di->ac_charger_attached_work,
3341 if (is_ab8500(di->parent))
3342 queue_delayed_work(di->charger_wq,
3343 &di->usb_charger_attached_work,
3345 di->vbus_detected = true;
3346 di->vbus_detected_start = true;
3347 queue_work(di->charger_wq,
3348 &di->detect_usb_type_work);
3351 ret = component_bind_all(dev, di);
3354 destroy_workqueue(di->charger_wq);
3363 struct ab8500_charger *di = dev_get_drvdata(dev);
3367 ab8500_charger_ac_en(&di->ac_chg, false, 0, 0);
3370 ab8500_charger_usb_en(&di->usb_chg, false, 0, 0);
3373 ret = abx500_mask_and_set_register_interruptible(di->dev,
3376 dev_err(di->dev, "%s mask and set failed\n", __func__);
3379 destroy_workqueue(di->charger_wq);
3382 component_unbind_all(dev, di);
3402 struct ab8500_charger *di;
3407 di = devm_kzalloc(dev, sizeof(*di), GFP_KERNEL);
3408 if (!di)
3411 di->bm = &ab8500_bm_data;
3413 di->autopower_cfg = of_property_read_bool(np, "autopower_cfg");
3416 di->dev = dev;
3417 di->parent = dev_get_drvdata(pdev->dev.parent);
3420 if (!is_ab8505(di->parent)) {
3421 di->adc_main_charger_v = devm_iio_channel_get(dev, "main_charger_v");
3422 if (IS_ERR(di->adc_main_charger_v)) {
3423 ret = dev_err_probe(dev, PTR_ERR(di->adc_main_charger_v),
3427 di->adc_main_charger_c = devm_iio_channel_get(dev, "main_charger_c");
3428 if (IS_ERR(di->adc_main_charger_c)) {
3429 ret = dev_err_probe(dev, PTR_ERR(di->adc_main_charger_c),
3434 di->adc_vbus_v = devm_iio_channel_get(dev, "vbus_v");
3435 if (IS_ERR(di->adc_vbus_v)) {
3436 ret = dev_err_probe(dev, PTR_ERR(di->adc_vbus_v),
3440 di->adc_usb_charger_c = devm_iio_channel_get(dev, "usb_charger_c");
3441 if (IS_ERR(di->adc_usb_charger_c)) {
3442 ret = dev_err_probe(dev, PTR_ERR(di->adc_usb_charger_c),
3452 di->regu = devm_regulator_get(dev, "vddadc");
3453 if (IS_ERR(di->regu)) {
3454 ret = PTR_ERR(di->regu);
3468 ab8500_charger_irq[i].name, di);
3480 spin_lock_init(&di->usb_state.usb_lock);
3481 mutex_init(&di->usb_ipt_crnt_lock);
3483 di->autopower = false;
3484 di->invalid_charger_detect_state = 0;
3490 ac_psy_cfg.drv_data = &di->ac_chg;
3494 usb_psy_cfg.drv_data = &di->usb_chg;
3498 di->ac_chg.ops.enable = &ab8500_charger_ac_en;
3499 di->ac_chg.ops.check_enable = &ab8500_charger_ac_check_enable;
3500 di->ac_chg.ops.kick_wd = &ab8500_charger_watchdog_kick;
3501 di->ac_chg.ops.update_curr = &ab8500_charger_update_charger_current;
3502 di->ac_chg.max_out_volt_uv = ab8500_charger_voltage_map[
3504 di->ac_chg.max_out_curr_ua =
3506 di->ac_chg.wdt_refresh = CHG_WD_INTERVAL;
3513 if (!is_ab8505(di->parent))
3514 di->ac_chg.enabled = true;
3518 di->usb_chg.ops.enable = &ab8500_charger_usb_en;
3519 di->usb_chg.ops.check_enable = &ab8500_charger_usb_check_enable;
3520 di->usb_chg.ops.kick_wd = &ab8500_charger_watchdog_kick;
3521 di->usb_chg.ops.update_curr = &ab8500_charger_update_charger_current;
3522 di->usb_chg.max_out_volt_uv = ab8500_charger_voltage_map[
3524 di->usb_chg.max_out_curr_ua =
3526 di->usb_chg.wdt_refresh = CHG_WD_INTERVAL;
3527 di->usb_state.usb_current_ua = -1;
3529 mutex_init(&di->charger_attached_mutex);
3532 INIT_DEFERRABLE_WORK(&di->check_hw_failure_work,
3534 INIT_DEFERRABLE_WORK(&di->check_usbchgnotok_work,
3537 INIT_DELAYED_WORK(&di->ac_charger_attached_work,
3539 INIT_DELAYED_WORK(&di->usb_charger_attached_work,
3551 INIT_DEFERRABLE_WORK(&di->kick_wd_work,
3554 INIT_DEFERRABLE_WORK(&di->check_vbat_work,
3557 INIT_DELAYED_WORK(&di->attach_work,
3560 INIT_DELAYED_WORK(&di->usb_state_changed_work,
3563 INIT_DELAYED_WORK(&di->vbus_drop_end_work,
3567 INIT_WORK(&di->usb_link_status_work,
3569 INIT_WORK(&di->ac_work, ab8500_charger_ac_work);
3570 INIT_WORK(&di->detect_usb_type_work,
3574 INIT_WORK(&di->check_main_thermal_prot_work,
3576 INIT_WORK(&di->check_usb_thermal_prot_work,
3581 ret = ab8500_charger_init_hw_registers(di);
3588 if (di->ac_chg.enabled) {
3589 di->ac_chg.psy = devm_power_supply_register(dev,
3592 if (IS_ERR(di->ac_chg.psy)) {
3594 return PTR_ERR(di->ac_chg.psy);
3599 di->usb_chg.psy = devm_power_supply_register(dev,
3602 if (IS_ERR(di->usb_chg.psy)) {
3604 return PTR_ERR(di->usb_chg.psy);
3611 ret = ab8500_bm_of_probe(di->usb_chg.psy, di->bm);
3617 charger_status = ab8500_charger_detect_chargers(di, true);
3619 di->ac.charger_connected = 1;
3620 di->ac_conn = true;
3621 ab8500_power_supply_changed(di, di->ac_chg.psy);
3622 sysfs_notify(&di->ac_chg.psy->dev.kobj, NULL, "present");
3625 platform_set_drvdata(pdev, di);
3650 di->usb_phy = usb_get_phy(USB_PHY_TYPE_USB2);
3651 if (IS_ERR_OR_NULL(di->usb_phy)) {
3656 di->nb.notifier_call = ab8500_charger_usb_notifier_call;
3657 ret = usb_register_notifier(di->usb_phy, &di->nb);
3674 usb_unregister_notifier(di->usb_phy, &di->nb);
3676 usb_put_phy(di->usb_phy);
3678 ab8500_bm_of_remove(di->usb_chg.psy, di->bm);
3684 struct ab8500_charger *di = platform_get_drvdata(pdev);
3688 usb_unregister_notifier(di->usb_phy, &di->nb);
3689 ab8500_bm_of_remove(di->usb_chg.psy, di->bm);
3690 usb_put_phy(di->usb_phy);