power: qpnp-smbcharger: co-locate interrupt handlers (be7dc2af) · Commits · e / devices / android_kernel_xiaomi_markw

drivers/power/qpnp-smbcharger.c

+355 −355

Original line number	Diff line number	Diff line
		@@ -4035,6 +4035,310 @@ static int smbchg_charging_status_change(struct smbchg_chip *chip)
		return 0;
		}

		static void smbchg_hvdcp_det_work(struct work_struct *work)
		{
		struct smbchg_chip *chip = container_of(work,
		struct smbchg_chip,
		hvdcp_det_work.work);
		int rc;
		u8 reg, hvdcp_sel;

		rc = smbchg_read(chip, &reg,
		chip->usb_chgpth_base + USBIN_HVDCP_STS, 1);
		if (rc < 0) {
		dev_err(chip->dev, "Couldn't read hvdcp status rc = %d\n", rc);
		return;
		}

		pr_smb(PR_STATUS, "HVDCP_STS = 0x%02x\n", reg);
		/*
		* If a valid HVDCP is detected, notify it to the usb_psy only
		* if USB is still present.
		*/
		if (chip->schg_version == QPNP_SCHG_LITE)
		hvdcp_sel = SCHG_LITE_USBIN_HVDCP_SEL_BIT;
		else
		hvdcp_sel = USBIN_HVDCP_SEL_BIT;

		if ((reg & hvdcp_sel) && is_usb_present(chip)) {
		pr_smb(PR_MISC, "setting usb psy type = %d\n",
		POWER_SUPPLY_TYPE_USB_HVDCP);
		power_supply_set_supply_type(chip->usb_psy,
		POWER_SUPPLY_TYPE_USB_HVDCP);
		if (chip->psy_registered)
		power_supply_changed(&chip->batt_psy);
		smbchg_aicl_deglitch_wa_check(chip);
		}
		}

		static void handle_usb_removal(struct smbchg_chip *chip)
		{
		struct power_supply *parallel_psy = get_parallel_psy(chip);
		int rc;

		pr_smb(PR_STATUS, "triggered\n");
		smbchg_aicl_deglitch_wa_check(chip);
		if (chip->force_aicl_rerun && !chip->very_weak_charger) {
		rc = smbchg_hw_aicl_rerun_en(chip, true);
		if (rc)
		pr_err("Error enabling AICL rerun rc= %d\n",
		rc);
		}
		/* Clear the OV detected status set before */
		if (chip->usb_ov_det)
		chip->usb_ov_det = false;
		if (chip->usb_psy) {
		pr_smb(PR_MISC, "setting usb psy type = %d\n",
		POWER_SUPPLY_TYPE_UNKNOWN);
		power_supply_set_supply_type(chip->usb_psy,
		POWER_SUPPLY_TYPE_UNKNOWN);
		pr_smb(PR_MISC, "setting usb psy present = %d\n",
		chip->usb_present);
		power_supply_set_present(chip->usb_psy, chip->usb_present);
		pr_smb(PR_MISC, "setting usb psy allow detection 0\n");
		power_supply_set_allow_detection(chip->usb_psy, 0);
		schedule_work(&chip->usb_set_online_work);
		rc = power_supply_set_health_state(chip->usb_psy,
		POWER_SUPPLY_HEALTH_UNKNOWN);
		if (rc)
		pr_smb(PR_STATUS,
		"usb psy does not allow updating prop %d rc = %d\n",
		POWER_SUPPLY_HEALTH_UNKNOWN, rc);
		}
		if (parallel_psy && chip->parallel_charger_detected)
		power_supply_set_present(parallel_psy, false);
		if (chip->parallel.avail && chip->aicl_done_irq
		&& chip->enable_aicl_wake) {
		disable_irq_wake(chip->aicl_done_irq);
		chip->enable_aicl_wake = false;
		}
		chip->parallel.enabled_once = false;
		chip->vbat_above_headroom = false;
		rc = smbchg_masked_write(chip, chip->usb_chgpth_base + CMD_IL,
		ICL_OVERRIDE_BIT, 0);
		if (rc < 0)
		pr_err("Couldn't set override rc = %d\n", rc);
		}

		static bool is_src_detect_high(struct smbchg_chip *chip)
		{
		int rc;
		u8 reg;

		rc = smbchg_read(chip, &reg, chip->usb_chgpth_base + RT_STS, 1);
		if (rc < 0) {
		dev_err(chip->dev, "Couldn't read usb rt status rc = %d\n", rc);
		return false;
		}
		return reg &= USBIN_SRC_DET_BIT;
		}

		#define HVDCP_NOTIFY_MS 2500
		static void handle_usb_insertion(struct smbchg_chip *chip)
		{
		struct power_supply *parallel_psy = get_parallel_psy(chip);
		enum power_supply_type usb_supply_type;
		int rc;
		char *usb_type_name = "null";

		pr_smb(PR_STATUS, "triggered\n");
		/* usb inserted */
		read_usb_type(chip, &usb_type_name, &usb_supply_type);
		pr_smb(PR_STATUS,
		"inserted type = %d (%s)", usb_supply_type, usb_type_name);

		smbchg_aicl_deglitch_wa_check(chip);
		if (chip->usb_psy) {
		pr_smb(PR_MISC, "setting usb psy type = %d\n",
		usb_supply_type);
		power_supply_set_supply_type(chip->usb_psy, usb_supply_type);
		pr_smb(PR_MISC, "setting usb psy present = %d\n",
		chip->usb_present);
		power_supply_set_present(chip->usb_psy, chip->usb_present);
		/* Notify the USB psy if OV condition is not present */
		if (!chip->usb_ov_det) {
		/*
		* Note that this could still be a very weak charger
		* if the handle_usb_insertion was triggered from
		* the falling edge of an USBIN_OV interrupt
		*/
		rc = power_supply_set_health_state(chip->usb_psy,
		chip->very_weak_charger
		? POWER_SUPPLY_HEALTH_UNSPEC_FAILURE
		: POWER_SUPPLY_HEALTH_GOOD);
		if (rc)
		pr_smb(PR_STATUS,
		"usb psy does not allow updating prop %d rc = %d\n",
		POWER_SUPPLY_HEALTH_GOOD, rc);
		}
		schedule_work(&chip->usb_set_online_work);
		}

		if (usb_supply_type == POWER_SUPPLY_TYPE_USB_DCP)
		schedule_delayed_work(&chip->hvdcp_det_work,
		msecs_to_jiffies(HVDCP_NOTIFY_MS));
		if (parallel_psy) {
		rc = power_supply_set_present(parallel_psy, true);
		chip->parallel_charger_detected = rc ? false : true;
		if (rc)
		pr_debug("parallel-charger absent rc=%d\n", rc);
		}

		if (chip->parallel.avail && chip->aicl_done_irq
		&& !chip->enable_aicl_wake) {
		rc = enable_irq_wake(chip->aicl_done_irq);
		chip->enable_aicl_wake = true;
		}
		}

		void update_usb_status(struct smbchg_chip *chip, bool usb_present, bool force)
		{
		mutex_lock(&chip->usb_status_lock);
		if (force) {
		chip->usb_present = usb_present;
		chip->usb_present ? handle_usb_insertion(chip)
		: handle_usb_removal(chip);
		goto unlock;
		}
		if (!chip->usb_present && usb_present) {
		chip->usb_present = usb_present;
		handle_usb_insertion(chip);
		} else if (chip->usb_present && !usb_present) {
		chip->usb_present = usb_present;
		handle_usb_removal(chip);
		}
		unlock:
		mutex_unlock(&chip->usb_status_lock);
		}

		static int otg_oc_reset(struct smbchg_chip *chip)
		{
		int rc;

		rc = smbchg_masked_write(chip, chip->bat_if_base + CMD_CHG_REG,
		OTG_EN_BIT, 0);
		if (rc)
		pr_err("Failed to disable OTG rc=%d\n", rc);

		msleep(20);
		rc = smbchg_masked_write(chip, chip->bat_if_base + CMD_CHG_REG,
		OTG_EN_BIT, OTG_EN_BIT);
		if (rc)
		pr_err("Failed to re-enable OTG rc=%d\n", rc);

		return rc;
		}

		static int get_current_time(unsigned long *now_tm_sec)
		{
		struct rtc_time tm;
		struct rtc_device *rtc;
		int rc;

		rtc = rtc_class_open(CONFIG_RTC_HCTOSYS_DEVICE);
		if (rtc == NULL) {
		pr_err("%s: unable to open rtc device (%s)\n",
		__FILE__, CONFIG_RTC_HCTOSYS_DEVICE);
		return -EINVAL;
		}

		rc = rtc_read_time(rtc, &tm);
		if (rc) {
		pr_err("Error reading rtc device (%s) : %d\n",
		CONFIG_RTC_HCTOSYS_DEVICE, rc);
		goto close_time;
		}

		rc = rtc_valid_tm(&tm);
		if (rc) {
		pr_err("Invalid RTC time (%s): %d\n",
		CONFIG_RTC_HCTOSYS_DEVICE, rc);
		goto close_time;
		}
		rtc_tm_to_time(&tm, now_tm_sec);

		close_time:
		rtc_class_close(rtc);
		return rc;
		}

		#define AICL_IRQ_LIMIT_SECONDS 60
		#define AICL_IRQ_LIMIT_COUNT 25
		static void increment_aicl_count(struct smbchg_chip *chip)
		{
		bool bad_charger = false;
		int rc;
		u8 reg;
		long elapsed_seconds;
		unsigned long now_seconds;

		pr_smb(PR_INTERRUPT, "aicl count c:%d dgltch:%d first:%ld\n",
		chip->aicl_irq_count, chip->aicl_deglitch_short,
		chip->first_aicl_seconds);

		rc = smbchg_read(chip, &reg,
		chip->usb_chgpth_base + ICL_STS_1_REG, 1);
		if (!rc)
		chip->aicl_complete = reg & AICL_STS_BIT;
		else
		chip->aicl_complete = false;

		if (chip->aicl_deglitch_short \|\| chip->force_aicl_rerun) {
		if (!chip->aicl_irq_count)
		get_current_time(&chip->first_aicl_seconds);
		get_current_time(&now_seconds);
		elapsed_seconds = now_seconds
		- chip->first_aicl_seconds;

		if (elapsed_seconds > AICL_IRQ_LIMIT_SECONDS) {
		pr_smb(PR_INTERRUPT,
		"resetting: elp:%ld first:%ld now:%ld c=%d\n",
		elapsed_seconds, chip->first_aicl_seconds,
		now_seconds, chip->aicl_irq_count);
		chip->aicl_irq_count = 1;
		get_current_time(&chip->first_aicl_seconds);
		return;
		}
		chip->aicl_irq_count++;

		if (chip->aicl_irq_count > AICL_IRQ_LIMIT_COUNT) {
		pr_smb(PR_INTERRUPT, "elp:%ld first:%ld now:%ld c=%d\n",
		elapsed_seconds, chip->first_aicl_seconds,
		now_seconds, chip->aicl_irq_count);
		pr_smb(PR_INTERRUPT, "Disable AICL rerun\n");
		/*
		* Disable AICL rerun since many interrupts were
		* triggered in a short time
		*/
		chip->very_weak_charger = true;
		rc = smbchg_hw_aicl_rerun_en(chip, false);
		if (rc)
		pr_err("could not enable aicl reruns: %d", rc);
		bad_charger = true;
		chip->aicl_irq_count = 0;
		} else if ((get_prop_charge_type(chip) ==
		POWER_SUPPLY_CHARGE_TYPE_FAST) &&
		(reg & AICL_SUSP_BIT)) {
		/*
		* If the AICL_SUSP_BIT is on, then AICL reruns have
		* already been disabled. Set the very weak charger
		* flag so that the driver reports a bad charger
		* and does not reenable AICL reruns.
		*/
		chip->very_weak_charger = true;
		bad_charger = true;
		}
		if (bad_charger) {
		rc = power_supply_set_health_state(chip->usb_psy,
		POWER_SUPPLY_HEALTH_UNSPEC_FAILURE);
		if (rc)
		pr_err("Couldn't set health on usb psy rc:%d\n",
		rc);
		schedule_work(&chip->usb_set_online_work);
		}
		}
		}

		#define HOT_BAT_HARD_BIT BIT(0)
		#define HOT_BAT_SOFT_BIT BIT(1)
		#define COLD_BAT_HARD_BIT BIT(2)
		@@ -4164,42 +4468,6 @@ static irqreturn_t chg_hot_handler(int irq, void *_chip)
		return IRQ_HANDLED;
		}

		static void smbchg_hvdcp_det_work(struct work_struct *work)
		{
		struct smbchg_chip *chip = container_of(work,
		struct smbchg_chip,
		hvdcp_det_work.work);
		int rc;
		u8 reg, hvdcp_sel;

		rc = smbchg_read(chip, &reg,
		chip->usb_chgpth_base + USBIN_HVDCP_STS, 1);
		if (rc < 0) {
		dev_err(chip->dev, "Couldn't read hvdcp status rc = %d\n", rc);
		return;
		}

		pr_smb(PR_STATUS, "HVDCP_STS = 0x%02x\n", reg);
		/*
		* If a valid HVDCP is detected, notify it to the usb_psy only
		* if USB is still present.
		*/
		if (chip->schg_version == QPNP_SCHG_LITE)
		hvdcp_sel = SCHG_LITE_USBIN_HVDCP_SEL_BIT;
		else
		hvdcp_sel = USBIN_HVDCP_SEL_BIT;

		if ((reg & hvdcp_sel) && is_usb_present(chip)) {
		pr_smb(PR_MISC, "setting usb psy type = %d\n",
		POWER_SUPPLY_TYPE_USB_HVDCP);
		power_supply_set_supply_type(chip->usb_psy,
		POWER_SUPPLY_TYPE_USB_HVDCP);
		if (chip->psy_registered)
		power_supply_changed(&chip->batt_psy);
		smbchg_aicl_deglitch_wa_check(chip);
		}
		}

		static irqreturn_t chg_term_handler(int irq, void *_chip)
		{
		struct smbchg_chip *chip = _chip;
		@@ -4237,215 +4505,75 @@ static irqreturn_t recharge_handler(int irq, void *_chip)
		u8 reg = 0;

		smbchg_read(chip, &reg, chip->chgr_base + RT_STS, 1);
		pr_smb(PR_INTERRUPT, "triggered: 0x%02x\n", reg);
		smbchg_parallel_usb_check_ok(chip);
		if (chip->psy_registered)
		power_supply_changed(&chip->batt_psy);
		smbchg_charging_status_change(chip);
		return IRQ_HANDLED;
		}

		static irqreturn_t safety_timeout_handler(int irq, void *_chip)
		{
		struct smbchg_chip *chip = _chip;
		u8 reg = 0;

		smbchg_read(chip, &reg, chip->misc_base + RT_STS, 1);
		pr_warn_ratelimited("safety timeout rt_stat = 0x%02x\n", reg);
		if (chip->psy_registered)
		power_supply_changed(&chip->batt_psy);
		smbchg_charging_status_change(chip);
		return IRQ_HANDLED;
		}

		/**
		* power_ok_handler() - called when the switcher turns on or turns off
		* @chip: pointer to smbchg_chip
		* @rt_stat: the status bit indicating switcher turning on or off
		*/
		static irqreturn_t power_ok_handler(int irq, void *_chip)
		{
		struct smbchg_chip *chip = _chip;
		u8 reg = 0;

		smbchg_read(chip, &reg, chip->misc_base + RT_STS, 1);
		pr_smb(PR_INTERRUPT, "triggered: 0x%02x\n", reg);
		return IRQ_HANDLED;
		}

		/**
		* dcin_uv_handler() - called when the dc voltage crosses the uv threshold
		* @chip: pointer to smbchg_chip
		* @rt_stat: the status bit indicating whether dc voltage is uv
		*/
		#define DCIN_UNSUSPEND_DELAY_MS 1000
		static irqreturn_t dcin_uv_handler(int irq, void *_chip)
		{
		struct smbchg_chip *chip = _chip;
		bool dc_present = is_dc_present(chip);
		int rc;

		pr_smb(PR_STATUS, "chip->dc_present = %d dc_present = %d\n",
		chip->dc_present, dc_present);

		if (chip->dc_present != dc_present) {
		/* dc changed */
		chip->dc_present = dc_present;
		if (chip->dc_psy_type != -EINVAL && chip->psy_registered)
		power_supply_changed(&chip->dc_psy);
		smbchg_charging_status_change(chip);
		smbchg_aicl_deglitch_wa_check(chip);
		if (chip->force_aicl_rerun && !dc_present) {
		rc = smbchg_hw_aicl_rerun_en(chip, true);
		if (rc)
		pr_err("Error enabling AICL rerun rc= %d\n",
		rc);
		}
		chip->vbat_above_headroom = false;
		}

		smbchg_wipower_check(chip);
		return IRQ_HANDLED;
		}

		static void handle_usb_removal(struct smbchg_chip *chip)
		{
		struct power_supply *parallel_psy = get_parallel_psy(chip);
		int rc;

		pr_smb(PR_STATUS, "triggered\n");
		smbchg_aicl_deglitch_wa_check(chip);
		if (chip->force_aicl_rerun && !chip->very_weak_charger) {
		rc = smbchg_hw_aicl_rerun_en(chip, true);
		if (rc)
		pr_err("Error enabling AICL rerun rc= %d\n",
		rc);
		}
		/* Clear the OV detected status set before */
		if (chip->usb_ov_det)
		chip->usb_ov_det = false;
		if (chip->usb_psy) {
		pr_smb(PR_MISC, "setting usb psy type = %d\n",
		POWER_SUPPLY_TYPE_UNKNOWN);
		power_supply_set_supply_type(chip->usb_psy,
		POWER_SUPPLY_TYPE_UNKNOWN);
		pr_smb(PR_MISC, "setting usb psy present = %d\n",
		chip->usb_present);
		power_supply_set_present(chip->usb_psy, chip->usb_present);
		pr_smb(PR_MISC, "setting usb psy allow detection 0\n");
		power_supply_set_allow_detection(chip->usb_psy, 0);
		schedule_work(&chip->usb_set_online_work);
		rc = power_supply_set_health_state(chip->usb_psy,
		POWER_SUPPLY_HEALTH_UNKNOWN);
		if (rc)
		pr_smb(PR_STATUS,
		"usb psy does not allow updating prop %d rc = %d\n",
		POWER_SUPPLY_HEALTH_UNKNOWN, rc);
		}
		if (parallel_psy && chip->parallel_charger_detected)
		power_supply_set_present(parallel_psy, false);
		if (chip->parallel.avail && chip->aicl_done_irq
		&& chip->enable_aicl_wake) {
		disable_irq_wake(chip->aicl_done_irq);
		chip->enable_aicl_wake = false;
		}
		chip->parallel.enabled_once = false;
		chip->vbat_above_headroom = false;
		rc = smbchg_masked_write(chip, chip->usb_chgpth_base + CMD_IL,
		ICL_OVERRIDE_BIT, 0);
		if (rc < 0)
		pr_err("Couldn't set override rc = %d\n", rc);
		pr_smb(PR_INTERRUPT, "triggered: 0x%02x\n", reg);
		smbchg_parallel_usb_check_ok(chip);
		if (chip->psy_registered)
		power_supply_changed(&chip->batt_psy);
		smbchg_charging_status_change(chip);
		return IRQ_HANDLED;
		}

		static bool is_src_detect_high(struct smbchg_chip *chip)
		static irqreturn_t safety_timeout_handler(int irq, void *_chip)
		{
		int rc;
		u8 reg;
		struct smbchg_chip *chip = _chip;
		u8 reg = 0;

		rc = smbchg_read(chip, &reg, chip->usb_chgpth_base + RT_STS, 1);
		if (rc < 0) {
		dev_err(chip->dev, "Couldn't read usb rt status rc = %d\n", rc);
		return false;
		smbchg_read(chip, &reg, chip->misc_base + RT_STS, 1);
		pr_warn_ratelimited("safety timeout rt_stat = 0x%02x\n", reg);
		if (chip->psy_registered)
		power_supply_changed(&chip->batt_psy);
		smbchg_charging_status_change(chip);
		return IRQ_HANDLED;
		}
		return reg &= USBIN_SRC_DET_BIT;

		/**
		* power_ok_handler() - called when the switcher turns on or turns off
		* @chip: pointer to smbchg_chip
		* @rt_stat: the status bit indicating switcher turning on or off
		*/
		static irqreturn_t power_ok_handler(int irq, void *_chip)
		{
		struct smbchg_chip *chip = _chip;
		u8 reg = 0;

		smbchg_read(chip, &reg, chip->misc_base + RT_STS, 1);
		pr_smb(PR_INTERRUPT, "triggered: 0x%02x\n", reg);
		return IRQ_HANDLED;
		}

		#define HVDCP_NOTIFY_MS 2500
		static void handle_usb_insertion(struct smbchg_chip *chip)
		/**
		* dcin_uv_handler() - called when the dc voltage crosses the uv threshold
		* @chip: pointer to smbchg_chip
		* @rt_stat: the status bit indicating whether dc voltage is uv
		*/
		#define DCIN_UNSUSPEND_DELAY_MS 1000
		static irqreturn_t dcin_uv_handler(int irq, void *_chip)
		{
		struct power_supply *parallel_psy = get_parallel_psy(chip);
		enum power_supply_type usb_supply_type;
		struct smbchg_chip *chip = _chip;
		bool dc_present = is_dc_present(chip);
		int rc;
		char *usb_type_name = "null";

		pr_smb(PR_STATUS, "triggered\n");
		/* usb inserted */
		read_usb_type(chip, &usb_type_name, &usb_supply_type);
		pr_smb(PR_STATUS,
		"inserted type = %d (%s)", usb_supply_type, usb_type_name);
		pr_smb(PR_STATUS, "chip->dc_present = %d dc_present = %d\n",
		chip->dc_present, dc_present);

		if (chip->dc_present != dc_present) {
		/* dc changed */
		chip->dc_present = dc_present;
		if (chip->dc_psy_type != -EINVAL && chip->psy_registered)
		power_supply_changed(&chip->dc_psy);
		smbchg_charging_status_change(chip);
		smbchg_aicl_deglitch_wa_check(chip);
		if (chip->usb_psy) {
		pr_smb(PR_MISC, "setting usb psy type = %d\n",
		usb_supply_type);
		power_supply_set_supply_type(chip->usb_psy, usb_supply_type);
		pr_smb(PR_MISC, "setting usb psy present = %d\n",
		chip->usb_present);
		power_supply_set_present(chip->usb_psy, chip->usb_present);
		/* Notify the USB psy if OV condition is not present */
		if (!chip->usb_ov_det) {
		/*
		* Note that this could still be a very weak charger
		* if the handle_usb_insertion was triggered from
		* the falling edge of an USBIN_OV interrupt
		*/
		rc = power_supply_set_health_state(chip->usb_psy,
		chip->very_weak_charger
		? POWER_SUPPLY_HEALTH_UNSPEC_FAILURE
		: POWER_SUPPLY_HEALTH_GOOD);
		if (rc)
		pr_smb(PR_STATUS,
		"usb psy does not allow updating prop %d rc = %d\n",
		POWER_SUPPLY_HEALTH_GOOD, rc);
		}
		schedule_work(&chip->usb_set_online_work);
		}

		if (usb_supply_type == POWER_SUPPLY_TYPE_USB_DCP)
		schedule_delayed_work(&chip->hvdcp_det_work,
		msecs_to_jiffies(HVDCP_NOTIFY_MS));
		if (parallel_psy) {
		rc = power_supply_set_present(parallel_psy, true);
		chip->parallel_charger_detected = rc ? false : true;
		if (chip->force_aicl_rerun && !dc_present) {
		rc = smbchg_hw_aicl_rerun_en(chip, true);
		if (rc)
		pr_debug("parallel-charger absent rc=%d\n", rc);
		}

		if (chip->parallel.avail && chip->aicl_done_irq
		&& !chip->enable_aicl_wake) {
		rc = enable_irq_wake(chip->aicl_done_irq);
		chip->enable_aicl_wake = true;
		pr_err("Error enabling AICL rerun rc= %d\n",
		rc);
		}
		chip->vbat_above_headroom = false;
		}

		void update_usb_status(struct smbchg_chip *chip, bool usb_present, bool force)
		{
		mutex_lock(&chip->usb_status_lock);
		if (force) {
		chip->usb_present = usb_present;
		chip->usb_present ? handle_usb_insertion(chip)
		: handle_usb_removal(chip);
		goto unlock;
		}
		if (!chip->usb_present && usb_present) {
		chip->usb_present = usb_present;
		handle_usb_insertion(chip);
		} else if (chip->usb_present && !usb_present) {
		chip->usb_present = usb_present;
		handle_usb_removal(chip);
		}
		unlock:
		mutex_unlock(&chip->usb_status_lock);
		smbchg_wipower_check(chip);
		return IRQ_HANDLED;
		}

		/**
		@@ -4602,24 +4730,6 @@ static irqreturn_t src_detect_handler(int irq, void *_chip)
		return IRQ_HANDLED;
		}

		static int otg_oc_reset(struct smbchg_chip *chip)
		{
		int rc;

		rc = smbchg_masked_write(chip, chip->bat_if_base + CMD_CHG_REG,
		OTG_EN_BIT, 0);
		if (rc)
		pr_err("Failed to disable OTG rc=%d\n", rc);

		msleep(20);
		rc = smbchg_masked_write(chip, chip->bat_if_base + CMD_CHG_REG,
		OTG_EN_BIT, OTG_EN_BIT);
		if (rc)
		pr_err("Failed to re-enable OTG rc=%d\n", rc);

		return rc;
		}

		/**
		* otg_oc_handler() - called when the usb otg goes over current
		*/
		@@ -4675,116 +4785,6 @@ static irqreturn_t otg_fail_handler(int irq, void *_chip)
		return IRQ_HANDLED;
		}

		static int get_current_time(unsigned long *now_tm_sec)
		{
		struct rtc_time tm;
		struct rtc_device *rtc;
		int rc;

		rtc = rtc_class_open(CONFIG_RTC_HCTOSYS_DEVICE);
		if (rtc == NULL) {
		pr_err("%s: unable to open rtc device (%s)\n",
		__FILE__, CONFIG_RTC_HCTOSYS_DEVICE);
		return -EINVAL;
		}

		rc = rtc_read_time(rtc, &tm);
		if (rc) {
		pr_err("Error reading rtc device (%s) : %d\n",
		CONFIG_RTC_HCTOSYS_DEVICE, rc);
		goto close_time;
		}

		rc = rtc_valid_tm(&tm);
		if (rc) {
		pr_err("Invalid RTC time (%s): %d\n",
		CONFIG_RTC_HCTOSYS_DEVICE, rc);
		goto close_time;
		}
		rtc_tm_to_time(&tm, now_tm_sec);

		close_time:
		rtc_class_close(rtc);
		return rc;
		}

		#define AICL_IRQ_LIMIT_SECONDS 60
		#define AICL_IRQ_LIMIT_COUNT 25
		static void increment_aicl_count(struct smbchg_chip *chip)
		{
		bool bad_charger = false;
		int rc;
		u8 reg;
		long elapsed_seconds;
		unsigned long now_seconds;

		pr_smb(PR_INTERRUPT, "aicl count c:%d dgltch:%d first:%ld\n",
		chip->aicl_irq_count, chip->aicl_deglitch_short,
		chip->first_aicl_seconds);

		rc = smbchg_read(chip, &reg,
		chip->usb_chgpth_base + ICL_STS_1_REG, 1);
		if (!rc)
		chip->aicl_complete = reg & AICL_STS_BIT;
		else
		chip->aicl_complete = false;

		if (chip->aicl_deglitch_short \|\| chip->force_aicl_rerun) {
		if (!chip->aicl_irq_count)
		get_current_time(&chip->first_aicl_seconds);
		get_current_time(&now_seconds);
		elapsed_seconds = now_seconds
		- chip->first_aicl_seconds;

		if (elapsed_seconds > AICL_IRQ_LIMIT_SECONDS) {
		pr_smb(PR_INTERRUPT,
		"resetting: elp:%ld first:%ld now:%ld c=%d\n",
		elapsed_seconds, chip->first_aicl_seconds,
		now_seconds, chip->aicl_irq_count);
		chip->aicl_irq_count = 1;
		get_current_time(&chip->first_aicl_seconds);
		return;
		}
		chip->aicl_irq_count++;

		if (chip->aicl_irq_count > AICL_IRQ_LIMIT_COUNT) {
		pr_smb(PR_INTERRUPT, "elp:%ld first:%ld now:%ld c=%d\n",
		elapsed_seconds, chip->first_aicl_seconds,
		now_seconds, chip->aicl_irq_count);
		pr_smb(PR_INTERRUPT, "Disable AICL rerun\n");
		/*
		* Disable AICL rerun since many interrupts were
		* triggered in a short time
		*/
		chip->very_weak_charger = true;
		rc = smbchg_hw_aicl_rerun_en(chip, false);
		if (rc)
		pr_err("could not enable aicl reruns: %d", rc);
		bad_charger = true;
		chip->aicl_irq_count = 0;
		} else if ((get_prop_charge_type(chip) ==
		POWER_SUPPLY_CHARGE_TYPE_FAST) &&
		(reg & AICL_SUSP_BIT)) {
		/*
		* If the AICL_SUSP_BIT is on, then AICL reruns have
		* already been disabled. Set the very weak charger
		* flag so that the driver reports a bad charger
		* and does not reenable AICL reruns.
		*/
		chip->very_weak_charger = true;
		bad_charger = true;
		}
		if (bad_charger) {
		rc = power_supply_set_health_state(chip->usb_psy,
		POWER_SUPPLY_HEALTH_UNSPEC_FAILURE);
		if (rc)
		pr_err("Couldn't set health on usb psy rc:%d\n",
		rc);
		schedule_work(&chip->usb_set_online_work);
		}
		}
		}

		/**
		* aicl_done_handler() - called when the usb AICL algorithm is finished
		* and a current is set.