Merge "power: Add snapshot of SMB1360 and QPNP Linear charger"

- qcom,config-hard-thresholds	This property indicates if cold and hot thresholds need be modified.

				If it's not defined, default temp thresholds will be used. If this

				defined, it's required to specify the "qcom,hot-bat-decidegc" and

				"qcom,cold-bat-decidegc" values.

- qcom,hot-bat-decidegc		Hot battery temperature in decidegC. This property must be

				out of range [0, 55].

- qcom,cold-bat-decidegc	Cold battery temperature in decidegC. This property must be

				out of range [0, 55].

				"qcom,cold-bat-decidegc" values. If this defined, the serial properties

				(qcom,otp-hard-jeita-config, qcom,otp-hot-bat-decidegc,

				qcom,otp-cold-bat-decidegc) mustn't be defined.

- qcom,hot-bat-decidegc		Hot battery temperature in decidegC. This property should only be

				defined when "qcom,config-hard-thresholds" defined, and the value

				must be out of range [0, 55].

- qcom,cold-bat-decidegc	Cold battery temperature in decidegC. This property should only be

				defined when "qcom,config-hard-thresholds" defined, and the value

				must be out of range [0, 55].

- qcom,otp-hard-jeita-config	This property indicates if cold and hot thresholds need be modified.

				If it's not defined, default temp thresholds [0, 55] will be used.

				If this defined, it's required to specify the "qcom,otp-hot-bat-decidegc"

				and "qcom,otp-cold-bat-decidegc" values. If this is defined, the serial

				properties (qcom,config-hard-thresholds, qcom,hot-bat-decidegc,

				qcom,cold-bat-decidegc) mustn't be defined.

- qcom,otp-hot-bat-decidegc	Hot battery temperature in decidegC. This property could only be

				defined when qcom,config-otp-hard-jeita exist.

- qcom,otp-cold-bat-decidegc	Cold battery temperature in decidegC. This property could only be

				defined when qcom,config-otp-hard-jeita exist.

- qcom,otp-hard-jeita-hysteresis This property contains two intergers to define the temperature

				hysteresis (in decidegC unit) for hard cold and hard hot.

				This property could only be defined when qcom,config-otp-hard-jeita exist.

- qcom,soft-jeita-supported	This property indicates whether soft jeita supported.

- qcom,warm-bat-decidegc	Warm battery temperature in decidegC. After hitting this threshold,

				"qcom,warm-bat-ma" defines maximum charging current and

			qcom,soft-jeita-supported;

			qcom,warm-bat-decidegc = <450>;

			qcom,cool-bat-decidegc = <100>;

			qcom,otp-hard-jeita-config;

			qcom,otp-hot-bat-decidegc = <550>;

			qcom,otp-cold-bat-decidegc = <0>;

			qcom,otp-hard-jeita-hysteresis = <0, 50>;

			qcom,warm-bat-mv = <4100>;

			qcom,cool-bat-mv = <4100>;

			qcom,warm-bat-ma = <750>;

/* USB CHARGER PATH peripheral register offsets */

#define USB_IN_VALID_MASK			BIT(1)

#define CHG_GONE_BIT				BIT(2)

#define USB_SUSP_REG				0x47

#define USB_SUSPEND_BIT				BIT(0)

#define USB_COMP_OVR1_REG			0xEA

#define USBIN_LLIMIT_OK_MASK			LBC_MASK(1, 0)

#define USBIN_LLIMIT_OK_NO_OVERRIDE		0x00

#define USBIN_LLIMIT_OK_OVERRIDE_1		0x03

#define USB_OVP_TST5_REG			0xE7

#define CHG_GONE_OK_EN_BIT			BIT(2)

/* CHARGER peripheral register offset */

#define CHG_OPTION_REG				0x08

#define CHG_PERPH_RESET_CTRL3_REG		0xDA

#define CHG_COMP_OVR1				0xEE

#define CHG_VBAT_DET_OVR_MASK			LBC_MASK(1, 0)

#define CHG_TEST_LOOP_REG			0xE5

#define VIN_MIN_LOOP_DISABLE_BIT		BIT(0)

#define OVERRIDE_0				0x2

#define OVERRIDE_NONE				0x0

	CURRENT = BIT(2),

	SOC	= BIT(3),

	PARALLEL = BIT(4),

	COLLAPSE = BIT(5),

};

enum bpd_type {

 * @cfg_charger_detect_eoc:	charger can detect end of charging

 * @cfg_disable_vbatdet_based_recharge:	keep VBATDET comparator overriden to

 *				low and VBATDET irq disabled.

 * @cfg_collapsible_chgr_support: support collapsible charger

 * @cfg_chgr_led_support:	support charger led work.

 * @cfg_safe_current:		battery safety current setting

 * @cfg_hot_batt_p:		hot battery threshold setting

	bool				fastchg_on;

	bool				cfg_use_external_charger;

	bool				cfg_chgr_led_support;

	bool				cfg_bms_controlled_charging;

	bool				non_collapsible_chgr_detected;

	unsigned int			cfg_warm_bat_chg_ma;

	unsigned int			cfg_cool_bat_chg_ma;

	unsigned int			cfg_safe_voltage_mv;

	unsigned int			cfg_charger_detect_eoc;

	unsigned int			cfg_disable_vbatdet_based_recharge;

	unsigned int			cfg_batt_weak_voltage_uv;

	unsigned int			cfg_collapsible_chgr_support;

	unsigned int			cfg_warm_bat_mv;

	unsigned int			cfg_cool_bat_mv;

	unsigned int			cfg_hot_batt_p;

	int				usb_psy_ma;

	int				delta_vddmax_uv;

	int				init_trim_uv;

	struct delayed_work		collapsible_detection_work;

	/* parallel-chg params */

	int				parallel_charging_enabled;

					return vddtrim_map[i + 1].trim_val;

			}

		}

		i = 0;

		break;

	case 1:

		for (i = TRIM_CENTER; i <= 7; i++) {

		for (i = TRIM_CENTER; i < ARRAY_SIZE(vddtrim_map); i++) {

			if (vddtrim_map[i].trim_uv < chip->delta_vddmax_uv) {

				delta_uv = AVG(vddtrim_map[i].trim_uv,

						vddtrim_map[i - 1].trim_uv);

					return vddtrim_map[i].trim_val;

			}

		}

		i = ARRAY_SIZE(vddtrim_map) - 1;

		break;

	}

	return (usbin_valid_rt_sts & USB_IN_VALID_MASK) ? 1 : 0;

}

static int qpnp_lbc_is_chg_gone(struct qpnp_lbc_chip *chip)

{

	u8 rt_sts;

	int rc;

	rc = qpnp_lbc_read(chip, chip->usb_chgpth_base + INT_RT_STS_REG,

				&rt_sts, 1);

	if (rc) {

		pr_err("spmi read failed: addr=0x%04x, rc=%d\n",

				chip->usb_chgpth_base + INT_RT_STS_REG, rc);

		return rc;

	}

	pr_debug("rt_sts 0x%x\n", rt_sts);

	return (rt_sts & CHG_GONE_BIT) ? 1 : 0;

}

static int qpnp_lbc_charger_enable(struct qpnp_lbc_chip *chip, int reason,

					int enable)

{

		mask |= BTC_COLD_MASK;

	}

	if (!chip->cfg_btc_disabled) {

	mask |= BTC_COMP_EN_MASK;

	if (!chip->cfg_btc_disabled)

		btc_cfg |= BTC_COMP_EN_MASK;

	}

	pr_debug("BTC configuration mask=%x\n", btc_cfg);

	return rc;

}

static int qpnp_chg_collapsible_chgr_config(struct qpnp_lbc_chip *chip,

		bool enable)

{

	u8 reg_val;

	int rc;

	pr_debug("Configure for %scollapsible charger\n",

			enable ? "" : "non-");

	/*

	 * The flow to enable/disable the collapsible charger configuration:

	 *	Enable:  Override USBIN_LLIMIT_OK -->

	 *		 Disable VIN_MIN comparator -->

	 *		 Enable CHG_GONE comparator

	 *	Disable: Enable VIN_MIN comparator -->

	 *		 Enable USBIN_LLIMIT_OK -->

	 *		 Disable CHG_GONE comparator

	 */

	if (enable) {

		/* Override USBIN_LLIMIT_OK */

		reg_val = USBIN_LLIMIT_OK_OVERRIDE_1;

		rc = __qpnp_lbc_secure_masked_write(chip->spmi,

				chip->usb_chgpth_base,

				USB_COMP_OVR1_REG,

				USBIN_LLIMIT_OK_MASK, reg_val);

		if (rc) {

			pr_err("Failed to override USB_LLIMIT_OK rc = %d\n",

							rc);

			return rc;

		}

	}

	/* Configure VIN_MIN comparator */

	rc = __qpnp_lbc_secure_masked_write(chip->spmi,

			chip->chgr_base, CHG_TEST_LOOP_REG,

			VIN_MIN_LOOP_DISABLE_BIT,

			enable ? VIN_MIN_LOOP_DISABLE_BIT : 0);

	if (rc) {

		pr_err("Failed to %s VIN_MIN comparator rc = %d\n",

				enable ? "disable" : "enable", rc);

		return rc;

	}

	if (!enable) {

		/* Enable USBIN_LLIMIT_OK */

		reg_val = USBIN_LLIMIT_OK_NO_OVERRIDE;

		rc = __qpnp_lbc_secure_masked_write(chip->spmi,

				chip->usb_chgpth_base,

				USB_COMP_OVR1_REG,

				USBIN_LLIMIT_OK_MASK, reg_val);

		if (rc) {

			pr_err("Failed to override USB_LLIMIT_OK rc = %d\n",

							rc);

			return rc;

		}

	}

	/* Configure CHG_GONE comparator */

	reg_val = enable ? CHG_GONE_OK_EN_BIT : 0;

	rc = __qpnp_lbc_secure_masked_write(chip->spmi,

			chip->usb_chgpth_base, USB_OVP_TST5_REG,

			CHG_GONE_OK_EN_BIT, reg_val);

	if (rc) {

		pr_err("Failed to write CHG_GONE comparator rc = %d\n", rc);

		return rc;

	}

	return 0;

}

#define QPNP_LBC_VBATWEAK_MIN_UV        3000000

#define QPNP_LBC_VBATWEAK_MAX_UV        3581250

#define QPNP_LBC_VBATWEAK_STEP_UV       18750

static int get_prop_capacity(struct qpnp_lbc_chip *chip)

{

	union power_supply_propval ret = {0,};

	int soc, battery_status, charger_in;

	int soc;

	if (chip->fake_battery_soc >= 0)

		return chip->fake_battery_soc;

	if (chip->bms_psy) {

		chip->bms_psy->get_property(chip->bms_psy,

				POWER_SUPPLY_PROP_CAPACITY, &ret);

		mutex_lock(&chip->chg_enable_lock);

		if (chip->chg_done)

			chip->bms_psy->get_property(chip->bms_psy,

					POWER_SUPPLY_PROP_CAPACITY, &ret);

		battery_status = get_prop_batt_status(chip);

		charger_in = qpnp_lbc_is_usb_chg_plugged_in(chip);

		/* reset chg_done flag if capacity not 100% */

		if (ret.intval < 100 && chip->chg_done) {

			chip->chg_done = false;

			power_supply_changed(&chip->batt_psy);

		}

		if (battery_status != POWER_SUPPLY_STATUS_CHARGING

				&& charger_in

				&& !chip->cfg_charging_disabled

				&& chip->cfg_soc_resume_limit

				&& ret.intval <= chip->cfg_soc_resume_limit

				&& !chip->cfg_bms_controlled_charging) {

			pr_debug("resuming charging at %d%% soc\n",

					ret.intval);

			if (!chip->cfg_disable_vbatdet_based_recharge)

				qpnp_lbc_vbatdet_override(chip, OVERRIDE_0);

			qpnp_lbc_charger_enable(chip, SOC, 1);

		}

		mutex_unlock(&chip->chg_enable_lock);

		soc = ret.intval;

		if (soc == 0) {

			if (!qpnp_lbc_is_usb_chg_plugged_in(chip))

	switch (psp) {

	case POWER_SUPPLY_PROP_STATUS:

		mutex_lock(&chip->chg_enable_lock);

		if (val->intval == POWER_SUPPLY_STATUS_FULL &&

				!chip->cfg_float_charge) {

		switch (val->intval) {

		case POWER_SUPPLY_STATUS_FULL:

			if (chip->cfg_float_charge)

				break;

			/* Disable charging */

			rc = qpnp_lbc_charger_enable(chip, SOC, 0);

			if (rc)

					qpnp_lbc_enable_irq(chip,

						&chip->irqs[CHG_VBAT_DET_LO]);

			}

		}

		if (chip->cfg_bms_controlled_charging) {

			switch (val->intval) {

			break;

		case POWER_SUPPLY_STATUS_CHARGING:

			chip->chg_done = false;

			pr_debug("resuming charging by bms\n");

			if (!chip->cfg_disable_vbatdet_based_recharge)

					qpnp_lbc_vbatdet_override(chip,

								OVERRIDE_0);

				qpnp_lbc_vbatdet_override(chip, OVERRIDE_0);

			qpnp_lbc_charger_enable(chip, SOC, 1);

			break;

		case POWER_SUPPLY_STATUS_DISCHARGING:

		default:

			break;

		}

		}

		mutex_unlock(&chip->chg_enable_lock);

		break;

	case POWER_SUPPLY_PROP_COOL_TEMP:

			"cfg_use_fake_battery\t=\t%d\n"

			"cfg_use_external_charger\t=\t%d\n"

			"cfg_chgr_led_support\t=\t%d\n"

			"cfg_bms_controlled_charging\t=\t%d\n"

			"cfg_warm_bat_chg_ma\t=\t%d\n"

			"cfg_cool_bat_chg_ma\t=\t%d\n"

			"cfg_safe_voltage_mv\t=\t%d\n"

			"cfg_min_voltage_mv\t=\t%d\n"

			"cfg_charger_detect_eoc\t=\t%d\n"

			"cfg_disable_vbatdet_based_recharge\t=\t%d\n"

			"cfg_collapsible_chgr_support\t=\t%d\n"

			"cfg_batt_weak_voltage_uv\t=\t%d\n"

			"cfg_warm_bat_mv\t=\t%d\n"

			"cfg_cool_bat_mv\t=\t%d\n"

			chip->cfg_use_fake_battery,

			chip->cfg_use_external_charger,

			chip->cfg_chgr_led_support,

			chip->cfg_bms_controlled_charging,

			chip->cfg_warm_bat_chg_ma,

			chip->cfg_cool_bat_chg_ma,

			chip->cfg_safe_voltage_mv,

			chip->cfg_min_voltage_mv,

			chip->cfg_charger_detect_eoc,

			chip->cfg_disable_vbatdet_based_recharge,

			chip->cfg_collapsible_chgr_support,

			chip->cfg_batt_weak_voltage_uv,

			chip->cfg_warm_bat_mv,

			chip->cfg_cool_bat_mv,

			of_property_read_bool(chip->spmi->dev.of_node,

					"qcom,chgr-led-support");

	chip->cfg_bms_controlled_charging =

	/* Get the collapsible charger support property */

	chip->cfg_collapsible_chgr_support =

			of_property_read_bool(chip->spmi->dev.of_node,

					"qcom,bms-controlled-charging");

					"qcom,collapsible-chgr-support");

	/* Disable charging when faking battery values */

	if (chip->cfg_use_fake_battery)

			chip->cfg_charging_disabled,

			chip->cfg_use_fake_battery,

			chip->cfg_float_charge);

	pr_debug("charger-detect-eoc=%d, disable-vbatdet-based-recharge=%d, chgr-led-support=%d, bms-controlled-charging=%d\n",

	pr_debug("charger-detect-eoc=%d, disable-vbatdet-based-recharge=%d, chgr-led-support=%d\n",

			chip->cfg_charger_detect_eoc,

			chip->cfg_disable_vbatdet_based_recharge,

			chip->cfg_chgr_led_support,

			chip->cfg_bms_controlled_charging);

	pr_debug("use-external-charger=%d, thermal_levels=%d\n",

			chip->cfg_chgr_led_support);

	pr_debug("collapsible-chg-support=%d, use-external-charger=%d, thermal_levels=%d\n",

			chip->cfg_collapsible_chgr_support,

			chip->cfg_use_external_charger,

			chip->cfg_thermal_levels);

	return rc;

}

#define CHG_REMOVAL_DETECT_DLY_MS	300

static irqreturn_t qpnp_lbc_chg_gone_irq_handler(int irq, void *_chip)

{

	struct qpnp_lbc_chip *chip = _chip;

	int chg_gone;

	if (chip->cfg_collapsible_chgr_support) {

		chg_gone = qpnp_lbc_is_chg_gone(chip);

		pr_debug("chg-gone triggered, rt_sts: %d\n", chg_gone);

		if (chg_gone) {

			/*

			 * Disable charger to prevent fastchg irq storming

			 * if a non-collapsible charger is being used.

			 */

			pr_debug("disable charging for non-collapsbile charger\n");

			qpnp_lbc_charger_enable(chip, COLLAPSE, 0);

			qpnp_lbc_disable_irq(chip, &chip->irqs[USBIN_VALID]);

			qpnp_lbc_disable_irq(chip, &chip->irqs[USB_CHG_GONE]);

			qpnp_chg_collapsible_chgr_config(chip, 0);

			/*

			 * Check after a delay if the charger is still

			 * inserted. It decides if a non-collapsible

			 * charger is being used, or charger has been

			 * removed.

			 */

			schedule_delayed_work(&chip->collapsible_detection_work,

				msecs_to_jiffies(CHG_REMOVAL_DETECT_DLY_MS));

		}

	}

	return IRQ_HANDLED;

}

static irqreturn_t qpnp_lbc_usbin_valid_irq_handler(int irq, void *_chip)

{

	struct qpnp_lbc_chip *chip = _chip;

			qpnp_lbc_set_appropriate_current(chip);

			spin_unlock_irqrestore(&chip->ibat_change_lock,

								flags);

			if (chip->cfg_collapsible_chgr_support)

				chip->non_collapsible_chgr_detected = false;

			if (chip->supported_feature_flag & VDD_TRIM_SUPPORTED)

				alarm_try_to_cancel(&chip->vddtrim_alarm);

		} else {

			/*

			 * Override VBAT_DET comparator to start charging

			if (!chip->cfg_disable_vbatdet_based_recharge)

				qpnp_lbc_vbatdet_override(chip, OVERRIDE_0);

			/*

			 * If collapsible charger supported, enable chgr_gone

			 * irq, and configure for collapsible charger.

			 */

			if (chip->cfg_collapsible_chgr_support &&

					!chip->non_collapsible_chgr_detected) {

				qpnp_lbc_enable_irq(chip,

						&chip->irqs[USB_CHG_GONE]);

				qpnp_chg_collapsible_chgr_config(chip, 1);

			}

			/*

			 * Enable SOC based charging to make sure

			 * charging gets enabled on USB insertion

	SPMI_REQUEST_IRQ(chip, USBIN_VALID, rc, usbin_valid, 0,

			IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, 1);

	SPMI_REQUEST_IRQ(chip, USB_CHG_GONE, rc, chg_gone, 0,

			IRQF_TRIGGER_RISING, 1);

	SPMI_REQUEST_IRQ(chip, USB_OVER_TEMP, rc, usb_overtemp, 0,

			IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, 0);

						USBIN_VALID, usbin-valid);

		SPMI_GET_IRQ_RESOURCE(chip, rc, spmi_resource,

						USB_OVER_TEMP, usb-over-temp);

		SPMI_GET_IRQ_RESOURCE(chip, rc, spmi_resource,

						USB_CHG_GONE, chg-gone);

		break;

	};

	 * Set USB psy online to avoid userspace from shutting down if battery

	 * capacity is at zero and no chargers online.

	 */

	if (chip->usb_present)

	if (chip->usb_present) {

		if (chip->cfg_collapsible_chgr_support &&

				!chip->non_collapsible_chgr_detected) {

			qpnp_lbc_enable_irq(chip,

					&chip->irqs[USB_CHG_GONE]);

			qpnp_chg_collapsible_chgr_config(chip, 1);

		}

		power_supply_set_online(chip->usb_psy, 1);

	}

}

static void qpnp_lbc_collapsible_detection_work(struct work_struct *work)

{

	struct delayed_work *dwork = to_delayed_work(work);

	struct qpnp_lbc_chip *chip = container_of(dwork,

			struct qpnp_lbc_chip,

			collapsible_detection_work);

	if (qpnp_lbc_is_usb_chg_plugged_in(chip)) {

		chip->non_collapsible_chgr_detected = true;

		pr_debug("Non-collapsible charger detected\n");

	} else {

		chip->non_collapsible_chgr_detected = false;

		pr_debug("Charger removal detected\n");

	}

	qpnp_lbc_charger_enable(chip, COLLAPSE, 1);

	qpnp_lbc_enable_irq(chip, &chip->irqs[USBIN_VALID]);

}

#define IBAT_TRIM			-300

static void qpnp_lbc_vddtrim_work_fn(struct work_struct *work)

	spin_lock_init(&chip->irq_lock);

	INIT_WORK(&chip->vddtrim_work, qpnp_lbc_vddtrim_work_fn);

	alarm_init(&chip->vddtrim_alarm, ALARM_REALTIME, vddtrim_callback);

	INIT_DELAYED_WORK(&chip->collapsible_detection_work,

			qpnp_lbc_collapsible_detection_work);

	/* Get all device-tree properties */

	rc = qpnp_charger_read_dt_props(chip);

		alarm_cancel(&chip->vddtrim_alarm);

		cancel_work_sync(&chip->vddtrim_work);

	}

	cancel_delayed_work_sync(&chip->collapsible_detection_work);

	debugfs_remove_recursive(chip->debug_root);

	if (chip->bat_if_base)

		power_supply_unregister(&chip->batt_psy);

#include <linux/qpnp/qpnp-adc.h>

#include <linux/of_batterydata.h>

#include <linux/batterydata-interface.h>

#include <linux/qpnp-revid.h>

#include <linux/qpnp/qpnp-revid.h>

#include <uapi/linux/vm_bms.h>

#define _BMS_MASK(BITS, POS) \

	u16				charge_cycles;

	unsigned int			start_soc;

	unsigned int			end_soc;

	unsigned int			chg_start_soc;

	struct bms_battery_data		*batt_data;

	struct bms_dt_cfg		dt;

	if (chip->batt_data->ibat_acc_lut) {

		/* Apply  ACC logic only if we discharging */

		if (!is_battery_charging(chip) && chip->current_now > 0) {

		if (chip->current_now > 0) {

			/*

			 * IBAT averaging is disabled at low temp.

	 * avoid overflows when charging continues for extended periods

	 */

	if (charging && chip->last_soc != -EINVAL) {

		if (chip->charge_start_tm_sec == 0) {

		if (chip->charge_start_tm_sec == 0 ||

			(chip->catch_up_time_sec == 0 &&

				(abs(soc - chip->last_soc) >= MIN_SOC_UUC))) {

			/*

			 * calculating soc for the first time

			 * after start of chg. Initialize catchup time

			else

				chip->catch_up_time_sec = SOC_CATCHUP_SEC_MAX;

			chip->chg_start_soc = chip->last_soc;

			if (chip->catch_up_time_sec < 0)

				chip->catch_up_time_sec = 0;

			chip->charge_start_tm_sec = last_change_sec;

			pr_debug("chg_start_soc=%d charge_start_tm_sec=%d catch_up_time_sec=%d\n",

				chip->chg_start_soc, chip->charge_start_tm_sec,

						chip->catch_up_time_sec);

		}

		charge_time_sec = min(SOC_CATCHUP_SEC_MAX, (int)last_change_sec

				- chip->charge_start_tm_sec);

		/* end catchup if calculated soc and last soc are same */

		if (chip->last_soc == soc)

		if (chip->last_soc == soc) {

			chip->catch_up_time_sec = 0;

			chip->chg_start_soc = chip->last_soc;

		}

	}

	if (chip->last_soc != -EINVAL) {

		else if (chip->last_soc < soc && soc != 100)

			soc = scale_soc_while_chg(chip, charge_time_sec,

					chip->catch_up_time_sec,

					soc, chip->last_soc);

					soc, chip->chg_start_soc);

		/*

		 * if the battery is close to cutoff or if the batt_temp

{

	union power_supply_propval ret = {0,};

	if (chip->last_soc < 0) {

		pr_debug("last_soc is not ready, return\n");

		return;

	}

	if (chip->reported_soc > chip->last_soc) {

		/*send DISCHARGING status if the reported_soc drops from 100 */

		if (chip->reported_soc == 100) {

	}

}

static void battery_voltage_check(struct qpnp_bms_chip *chip)

{

	int rc, vbat_uv = 0;

	rc = get_battery_voltage(chip, &vbat_uv);

	if (rc < 0) {

		pr_err("Failed to read battery-voltage rc=%d\n", rc);

	} else {

		very_low_voltage_check(chip, vbat_uv);

		cv_voltage_check(chip, vbat_uv);

	}

}

#define UI_SOC_CATCHUP_TIME	(60)

static void monitor_soc_work(struct work_struct *work)

{

	struct qpnp_bms_chip *chip = container_of(work,

				struct qpnp_bms_chip,

				monitor_soc_work.work);

	int rc, vbat_uv = 0, new_soc = 0, batt_temp;

	int rc, new_soc = 0, batt_temp;

	bms_stay_awake(&chip->vbms_soc_wake_source);

		chip->last_soc = -EINVAL;

		new_soc = 100;

	} else {

		rc = get_battery_voltage(chip, &vbat_uv);

		if (rc < 0) {

			pr_err("Failed to read battery-voltage rc=%d\n", rc);

		} else {

			very_low_voltage_check(chip, vbat_uv);

			cv_voltage_check(chip, vbat_uv);

		}

		battery_voltage_check(chip);

		if (chip->dt.cfg_use_voltage_soc) {

			calculate_soc_from_voltage(chip);

				pr_debug("SOC changed! new_soc=%d prev_soc=%d\n",

						new_soc, chip->calculated_soc);

				chip->calculated_soc = new_soc;

				/*

				 * To recalculate the catch-up time, clear it

				 * when SOC changes.

				 */

				chip->catch_up_time_sec = 0;

				if (chip->calculated_soc == 100)