kernel_samsung_a34x-permissive/drivers/battery/common/sec_battery_wc.c

/*
 *  sec_battery_wc.c
 *  Samsung Mobile Battery Driver
 *
 *  Copyright (C) 2020 Samsung Electronics
 *
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */
#include "sec_battery.h"
#include "sb_tx.h"

#if defined(CONFIG_SEC_KUNIT)
#include <kunit/mock.h>
#else
#define __visible_for_testing static
#endif

#if defined(CONFIG_WIRELESS_FIRMWARE_UPDATE)
bool sec_bat_check_boost_mfc_condition(struct sec_battery_info *battery, int mode)
{
	union power_supply_propval value = {0, };
	int boost_status = 0, wpc_det = 0, mst_pwr_en = 0;

	pr_info("%s\n", __func__);

	if (mode == SEC_WIRELESS_FW_UPDATE_AUTO_MODE) {
		psy_do_property(battery->pdata->wireless_charger_name, get,
			POWER_SUPPLY_EXT_PROP_WIRELESS_INITIAL_WC_CHECK, value);
		wpc_det = value.intval;
	}

	psy_do_property(battery->pdata->wireless_charger_name, get,
		POWER_SUPPLY_EXT_PROP_WIRELESS_MST_PWR_EN, value);
	mst_pwr_en = value.intval;

	psy_do_property(battery->pdata->charger_name, get,
		POWER_SUPPLY_EXT_PROP_CHARGE_BOOST, value);
	boost_status = value.intval;

	pr_info("%s wpc_det(%d), mst_pwr_en(%d), boost_status(%d)\n",
		__func__, wpc_det, mst_pwr_en, boost_status);

	if (!boost_status && !wpc_det && !mst_pwr_en)
		return true;
	return false;
}

void sec_bat_fw_update(struct sec_battery_info *battery, int mode)
{
	union power_supply_propval value = {0, };
	int ret = 0;

	pr_info("%s\n", __func__);

	__pm_wakeup_event(battery->vbus_ws, jiffies_to_msecs(HZ * 10));

	switch (mode) {
	case SEC_WIRELESS_FW_UPDATE_SDCARD_MODE:
	case SEC_WIRELESS_FW_UPDATE_BUILTIN_MODE:
	case SEC_WIRELESS_FW_UPDATE_AUTO_MODE:
	case SEC_WIRELESS_FW_UPDATE_SPU_MODE:
	case SEC_WIRELESS_FW_UPDATE_SPU_VERIFY_MODE:
		battery->mfc_fw_update = true;
		sec_vote(battery->chgen_vote, VOTER_FW, true, SEC_BAT_CHG_MODE_BUCK_OFF);
		msleep(500);
		sec_vote(battery->iv_vote, VOTER_FW, true, SEC_INPUT_VOLTAGE_5V);
#if IS_ENABLED(CONFIG_MUIC_NOTIFIER)
#if !defined(CONFIG_MTK_CHARGER) || !defined(CONFIG_AFC_CHARGER)
		muic_afc_request_voltage(AFC_REQUEST_MFC, SEC_INPUT_VOLTAGE_5V / 1000);
#endif
#endif
		msleep(2000);
		value.intval = mode;
		ret = psy_do_property(battery->pdata->wireless_charger_name, set,
				POWER_SUPPLY_EXT_PROP_CHARGE_POWERED_OTG_CONTROL, value);
		if (ret < 0) {
			battery->mfc_fw_update = false;
			sec_vote(battery->chgen_vote, VOTER_FW, false, 0);
			sec_vote(battery->iv_vote, VOTER_FW, false, 0);
#if IS_ENABLED(CONFIG_MUIC_NOTIFIER)
#if !defined(CONFIG_MTK_CHARGER) || !defined(CONFIG_AFC_CHARGER)
			muic_afc_request_voltage(AFC_REQUEST_MFC, SEC_INPUT_VOLTAGE_9V / 1000);
#endif
#endif
		}
		break;
	default:
		break;
	}
}
#endif

void sec_wireless_otg_control(struct sec_battery_info *battery, int enable)
{
	union power_supply_propval value = {0, };
	unsigned int vout_check_cnt = 0;

	if (battery->cable_type == SEC_BATTERY_CABLE_WIRELESS_MPP) // need to check scenario
		return;

	if (enable) {
		sec_bat_set_current_event(battery, SEC_BAT_CURRENT_EVENT_WPC_VOUT_LOCK,
			SEC_BAT_CURRENT_EVENT_WPC_VOUT_LOCK);
	} else {
		sec_bat_set_current_event(battery, 0,
			SEC_BAT_CURRENT_EVENT_WPC_VOUT_LOCK);
	}

	value.intval = enable;
	psy_do_property(battery->pdata->wireless_charger_name, set,
		POWER_SUPPLY_EXT_PROP_CHARGE_OTG_CONTROL, value);

	if (is_wireless_type(battery->cable_type)) {
		if (enable) {
			set_wireless_otg_input_current(battery);
			msleep(1500);
		}
		pr_info("%s: wireless vout %s with OTG(%d)\n",
			__func__, (enable) ? "4.7V" : "5.5V or HV", enable);
		mutex_lock(&battery->voutlock);
		if (is_hv_wireless_type(battery->cable_type))
			value.intval = (enable) ? WIRELESS_VOUT_OTG : battery->wpc_vout_level;
		else
			value.intval = (enable) ? WIRELESS_VOUT_OTG : WIRELESS_VOUT_CC_CV_VOUT;
		psy_do_property(battery->pdata->wireless_charger_name, set,
			POWER_SUPPLY_EXT_PROP_INPUT_VOLTAGE_REGULATION, value);
		mutex_unlock(&battery->voutlock);

		if (enable) {
			for (vout_check_cnt = 0; vout_check_cnt < 5; vout_check_cnt++) {
				msleep(100);
				psy_do_property(battery->pdata->wireless_charger_name, get,
					POWER_SUPPLY_PROP_ENERGY_NOW, value);
				if (value.intval < 5000) {
					pr_info("%s: wireless vout 4.7V done(%d)\n", __func__, value.intval);
					break;
				}
			}
		} else
			set_wireless_otg_input_current(battery);
	} else if (battery->wc_tx_enable && enable) {
		/* TX power should turn off during otg on */
		pr_info("@Tx_Mode %s: OTG is going to work, TX power should off\n", __func__);
		/* set tx event */
		sec_bat_set_tx_event(battery, BATT_TX_EVENT_WIRELESS_TX_OTG_ON, BATT_TX_EVENT_WIRELESS_TX_OTG_ON);
		sec_wireless_set_tx_enable(battery, false);
	}
}

unsigned int get_wc20_vout(unsigned int vout)
{
	unsigned int ret = 0;

	switch (vout) {
	case WIRELESS_VOUT_5V:
		ret = 5000;
		break;
	case WIRELESS_VOUT_9V:
		ret = 9000;
		break;
	case WIRELESS_VOUT_10V:
		ret = 10000;
		break;
	case WIRELESS_VOUT_11V:
		ret = 11000;
		break;
	case WIRELESS_VOUT_12V:
		ret = 12000;
		break;
	default:
		pr_info("%s vout(%d) is not supported\n", __func__, vout);
		return -1;
	}

	pr_info("%s vout(%d) - idx(%d)\n", __func__, vout, ret);
	return ret;
}

#if 0
unsigned int get_wc20_rx_power_idx(unsigned int rx_power)
{
	unsigned int ret = 0;

	switch (rx_power) {
	case 7500:
		ret = SEC_WIRELESS_RX_POWER_7_5W;
		break;
	case 12000:
		ret = SEC_WIRELESS_RX_POWER_12W;
		break;
	case 15000:
		ret = SEC_WIRELESS_RX_POWER_15W;
		break;
	default:
		pr_info("%s rx_power(%d) is not supported\n", __func__, rx_power);
		return -1;
	}

	pr_info("%s rx_power(%d) - idx(%d)\n", __func__, rx_power, ret);
	return ret;
}

unsigned int get_wc20_info_idx(sec_wireless_rx_power_info_t *wc20_info,
	unsigned int wc20_info_len, unsigned int vout, unsigned int rx_power)
{
	unsigned int idx = 0;

	for (idx = 0; idx < wc20_info_len; idx++) {
		if ((get_wc20_vout_idx(wc20_info[idx].vout) == vout) &&
			(get_wc20_rx_power_idx(wc20_info[idx].rx_power) == rx_power)) {
			pr_info("%s: Found! idx(%d), vout(%d), rx_power(%d)\n",
				__func__, idx, vout, rx_power);
			return idx;
		}
	}

	pr_info("%s: Not found! vout(%d), rx_power(%d)\n", __func__, vout, rx_power);
	return wc20_info_len - 1;
}
#endif

void sec_bat_set_wc20_current(struct sec_battery_info *battery)
{
	int icl = 0, fcc = 0;
	pr_info("%s: wc_status(%d), rx_power(%d), vout(%d)\n", __func__,
		battery->wc_status, battery->wc20_rx_power, battery->wc20_vout);

	if (is_pwr_nego_wireless_type(battery->wc_status)) {
		icl = (battery->wc20_rx_power / battery->wc20_vout);
		fcc = battery->pdata->charging_current[battery->wc_status].fast_charging_current;
		sec_bat_change_default_current(battery, battery->wc_status, icl, fcc);

		if (battery->wc_status != SEC_BATTERY_CABLE_WIRELESS_MPP) { // for test
			sec_vote(battery->input_vote, VOTER_CABLE, true, icl);
			sec_vote(battery->fcc_vote, VOTER_CABLE, true, fcc);
		}

		if (battery->wc20_rx_power <= 4500)
			battery->wc20_power_class = 0;
		else if (battery->wc20_rx_power <= 7500)
			battery->wc20_power_class = SEC_WIRELESS_RX_POWER_CLASS_1;
		else if (battery->wc20_rx_power <= 12000)
			battery->wc20_power_class = SEC_WIRELESS_RX_POWER_CLASS_2;
		else if (battery->wc20_rx_power <= 20000)
			battery->wc20_power_class = SEC_WIRELESS_RX_POWER_CLASS_3;
		else
			battery->wc20_power_class = SEC_WIRELESS_RX_POWER_CLASS_4;

		if (is_wired_type(battery->cable_type)) {
			int wl_power = battery->wc20_rx_power;

			pr_info("%s: check power(%d <--> %d)\n",
				__func__, battery->max_charge_power, wl_power);
			if (battery->max_charge_power < wl_power) {
				__pm_stay_awake(battery->cable_ws);
				queue_delayed_work(battery->monitor_wqueue,
					&battery->cable_work, 0);
			}
		} else {
			if (battery->wc_status != SEC_BATTERY_CABLE_WIRELESS_MPP) // for test
				sec_bat_set_charging_current(battery);
		}
	}
}

void set_wireless_otg_input_current(struct sec_battery_info *battery)
{
	pr_info("%s: is_otg_on=%s\n", __func__, battery->is_otg_on ? "ON" : "OFF");

	if (battery->is_otg_on)
		sec_vote(battery->input_vote, VOTER_OTG, true, battery->pdata->wireless_otg_input_current);
	else
		sec_vote(battery->input_vote, VOTER_OTG, false, 0);
	sec_vote(battery->input_vote, VOTER_AICL, false, 0);
}

void sec_bat_set_mfc_off(struct sec_battery_info *battery, char flag, bool need_ept)
{
	union power_supply_propval value = {0, };
	char wpc_en_status[2];

	if (need_ept) {
		psy_do_property(battery->pdata->wireless_charger_name, set,
			POWER_SUPPLY_PROP_ONLINE, value);

		msleep(300);
	}

	wpc_en_status[0] = flag;
	wpc_en_status[1] = false;
	value.strval = wpc_en_status;
	psy_do_property(battery->pdata->wireless_charger_name, set,
		POWER_SUPPLY_EXT_PROP_WPC_EN, value);

	pr_info("@DIS_MFC %s: WC CONTROL: Disable %d\n", __func__, flag);
}

void sec_bat_set_mfc_on(struct sec_battery_info *battery, char flag)
{
	union power_supply_propval value = {0, };
	char wpc_en_status[2];

	wpc_en_status[0] = flag;
	wpc_en_status[1] = true;
	value.strval = wpc_en_status;
	psy_do_property(battery->pdata->wireless_charger_name, set,
		POWER_SUPPLY_EXT_PROP_WPC_EN, value);

	pr_info("%s: WC CONTROL: Enable %d\n", __func__, flag);
}

void sec_bat_mfc_ldo_cntl(struct sec_battery_info *battery, bool en)
{
	union power_supply_propval value = {0, };

	battery->wc_need_ldo_on = !en;
	value.intval = en;
	psy_do_property(battery->pdata->wireless_charger_name, set,
		POWER_SUPPLY_PROP_CHARGE_EMPTY, value);

	if (battery->disable_mfc) {
		pr_info("%s : set mfc %s\n", __func__, (en ? "on" : "off"));
		if (en)
			sec_bat_set_mfc_on(battery, WPC_EN_CHARGING);
		else
			sec_bat_set_mfc_off(battery, WPC_EN_CHARGING, false);
	}
}

__visible_for_testing int sec_bat_get_wire_power(struct sec_battery_info *battery, int wr_sts)
{
	int wr_pwr = 0;
	int wr_icl = 0, wr_vol = 0;

	if (!is_wired_type(wr_sts))
		return 0;
	if (is_pd_wire_type(wr_sts))
		return battery->pd_max_charge_power;

	wr_icl = (wr_sts == SEC_BATTERY_CABLE_PREPARE_TA ?
			battery->pdata->charging_current[SEC_BATTERY_CABLE_TA].input_current_limit :
			battery->pdata->charging_current[wr_sts].input_current_limit);
	wr_vol = is_hv_wire_type(wr_sts) ?
		(wr_sts == SEC_BATTERY_CABLE_12V_TA ? SEC_INPUT_VOLTAGE_12V : SEC_INPUT_VOLTAGE_9V)
		: SEC_INPUT_VOLTAGE_5V;

	wr_pwr = mW_by_mVmA(wr_vol, wr_icl);
	pr_info("%s: wr_power(%d), wire_cable_type(%d)\n", __func__, wr_pwr, wr_sts);

	return wr_pwr;
}

__visible_for_testing int sec_bat_get_wireless_power(struct sec_battery_info *battery, int wrl_sts)
{
	int wrl_icl = 0, wrl_pwr = 0;

	if (wrl_sts == SEC_BATTERY_CABLE_PREPARE_WIRELESS_HV)
		wrl_sts = SEC_BATTERY_CABLE_HV_WIRELESS;
	else if (wrl_sts == SEC_BATTERY_CABLE_PREPARE_WIRELESS_20)
		wrl_sts = SEC_BATTERY_CABLE_HV_WIRELESS_20;

	wrl_icl = battery->pdata->charging_current[wrl_sts].input_current_limit;

	if (battery->sleep_mode)
		wrl_pwr = mW_by_mVmA(SEC_INPUT_VOLTAGE_5_5V, battery->pdata->sleep_mode_limit_current);
	else if (is_nv_wireless_type(wrl_sts) || (wrl_sts == SEC_BATTERY_CABLE_WIRELESS_FAKE))
		wrl_pwr = mW_by_mVmA(SEC_INPUT_VOLTAGE_5_5V, wrl_icl);
	else if (is_pwr_nego_wireless_type(wrl_sts))
		wrl_pwr = mW_by_mVmA(battery->wc20_vout, wrl_icl);
	else
		wrl_pwr = mW_by_mVmA(SEC_INPUT_VOLTAGE_10V, wrl_icl);

	return wrl_pwr;
}

__visible_for_testing void sec_bat_switch_to_wr(struct sec_battery_info *battery, int wrl_sts, int prev_ct)
{
	union power_supply_propval val = {0, };

	pr_info("%s\n", __func__);
	if (wrl_sts == SEC_BATTERY_CABLE_PREPARE_WIRELESS_20)
		wrl_sts = SEC_BATTERY_CABLE_HV_WIRELESS_20;
	/* limit charging current before change path between chgin and wcin */
	if (is_pwr_nego_wireless_type(prev_ct) &&
			is_pwr_nego_wireless_type(wrl_sts)) {
		/* limit charging current before change path between chgin and wcin */
		pr_info("%s: set charging current %dmA for a moment in case of TA OCP\n",
				__func__, battery->pdata->wpc_charging_limit_current);
		sec_vote(battery->fcc_vote, VOTER_CABLE, true, battery->pdata->wpc_charging_limit_current);
		msleep(100);
	}

	sec_bat_mfc_ldo_cntl(battery, MFC_LDO_OFF);
	/* Turn off TX to charge by cable charging having more power */
	if (wrl_sts == SEC_BATTERY_CABLE_WIRELESS_TX) {
		pr_info("@Tx_Mode %s: RX device with TA, notify TX device of this info\n",
				__func__);
		val.intval = true;
		psy_do_property(battery->pdata->wireless_charger_name, set,
				POWER_SUPPLY_EXT_PROP_WIRELESS_SWITCH, val);
	}

	sec_bat_change_default_current(battery, SEC_BATTERY_CABLE_WIRELESS_MPP,
			battery->pdata->default_mpp_input_current,
			battery->pdata->default_mpp_charging_current);
}

__visible_for_testing void sec_bat_switch_to_wrl(struct sec_battery_info *battery, int wr_sts, int prev_ct)
{
	pr_info("%s\n", __func__);
	if (!is_wireless_type(prev_ct)) {
		/* limit charging current before change path between chgin and wcin */
		pr_info("%s: set charging current %dmA for a moment in case of TA OCP\n",
				__func__, battery->pdata->wpc_charging_limit_current);
		sec_vote(battery->fcc_vote, VOTER_CABLE, true, battery->pdata->wpc_charging_limit_current);
		msleep(100);
	}
	/* turn on ldo when ldo was off because of TA, */
	/* ldo is supposed to turn on automatically except force off by sw. */
	/* do not turn on ldo every wireless connection just in case ldo re-toggle by ic */
	if (!is_nocharge_type(wr_sts)) {
		sec_bat_mfc_ldo_cntl(battery, MFC_LDO_ON);
	}
}

int sec_bat_choose_cable_type(struct sec_battery_info *battery)
{
	int wr_sts = battery->wire_status;
	int cur_ct = wr_sts;
	int prev_ct = battery->cable_type;
	int wrl_sts = battery->wc_status;
	union power_supply_propval value = {0, };

	if (wrl_sts != SEC_BATTERY_CABLE_NONE) {
		cur_ct = wrl_sts;
		if (!is_nocharge_type(wr_sts)) {
			int wrl_pwr, wr_pwr;

			wr_pwr = sec_bat_get_wire_power(battery, wr_sts);
			wrl_pwr = sec_bat_get_wireless_power(battery, wrl_sts);
			if (wrl_pwr <= wr_pwr)
				cur_ct = wr_sts;
			pr_info("%s: wrl_pwr(%d), wr_pwr(%d), wc_sts(%d), wr_sts(%d), cur_ct(%d)\n",
					__func__, wrl_pwr, wr_pwr, wrl_sts, wr_sts, cur_ct);
			if (is_wireless_type(cur_ct))
				sec_bat_switch_to_wrl(battery, wr_sts, prev_ct);
			else {
				if (is_hv_wireless_type(wrl_sts)) {
					value.intval = WIRELESS_VOUT_FORCE_9V;
					psy_do_property(battery->pdata->wireless_charger_name, set,
						POWER_SUPPLY_EXT_PROP_INPUT_VOLTAGE_REGULATION, value);
				}
				if (is_wireless_fake_type(prev_ct)) {
					msleep(200);
					sec_vote(battery->fcc_vote, VOTER_WL_TO_W, true, 300);
					msleep(200);
					sec_vote(battery->fcc_vote, VOTER_WL_TO_W, true, 100);
					msleep(200);
					sec_vote(battery->chgen_vote, VOTER_WL_TO_W, true, SEC_BAT_CHG_MODE_BUCK_OFF);
					value.intval = WL_TO_W;
					psy_do_property(battery->pdata->charger_name, set,
						POWER_SUPPLY_EXT_PROP_CHGINSEL, value);
				}
				sec_bat_switch_to_wr(battery, wrl_sts, prev_ct);
				sec_vote(battery->input_vote, VOTER_WPC_CUR, false, 0);
				sec_vote(battery->fcc_vote, VOTER_WL_TO_W, false, 0);
				sec_vote(battery->chgen_vote, VOTER_WL_TO_W, false, 0);
			}
		} else {
			if (battery->wc_need_ldo_on)
				sec_bat_mfc_ldo_cntl(battery, MFC_LDO_ON);
		}
	} else if (is_nocharge_type(wr_sts) && battery->disable_mfc) {
		pr_info("%s : sec_bat_set_mfc_on because of CABLE_NONE\n", __func__);
		sec_bat_set_mfc_on(battery, WPC_EN_CHARGING);
	}

	return cur_ct;
}

void sec_bat_get_wireless_current(struct sec_battery_info *battery)
{
	int incurr = INT_MAX;
	union power_supply_propval value = {0, };

	if (battery->cable_type == SEC_BATTERY_CABLE_WIRELESS_MPP)
		return;

	/* WPC_SLEEP_MODE */
	if (is_hv_wireless_type(battery->cable_type) && battery->sleep_mode) {
		if (incurr > battery->pdata->sleep_mode_limit_current)
			incurr = battery->pdata->sleep_mode_limit_current;
		pr_info("%s: sleep_mode = %d, chg_limit = %d, in_curr = %d\n",
				__func__, battery->sleep_mode, battery->chg_limit, incurr);

		if (!battery->auto_mode) {
			/* send cmd once */
			battery->auto_mode = true;
			value.intval = WIRELESS_SLEEP_MODE_ENABLE;
			psy_do_property(battery->pdata->wireless_charger_name, set,
					POWER_SUPPLY_EXT_PROP_WIRELESS_RX_CONTROL, value);
		}
	}

	/* WPC_TEMP_MODE */
	if (is_wireless_type(battery->cable_type) && battery->chg_limit) {
		if ((battery->siop_level >= 100 && !battery->lcd_status) &&
				(incurr > battery->pdata->wpc_input_limit_current)) {
			if (battery->cable_type == SEC_BATTERY_CABLE_WIRELESS_TX &&
				battery->pdata->wpc_input_limit_by_tx_check)
				incurr = battery->pdata->wpc_input_limit_current_by_tx;
			else
				incurr = battery->pdata->wpc_input_limit_current;
		} else if ((battery->siop_level < 100 || battery->lcd_status) &&
				(incurr > battery->pdata->wpc_lcd_on_input_limit_current))
			incurr = battery->pdata->wpc_lcd_on_input_limit_current;
	}

	/* Display flicker W/A */
	if (battery->pdata->wpc_vout_ctrl_lcd_on && battery->wpc_vout_ctrl_mode && battery->lcd_status) {
		if (is_wireless_type(battery->cable_type) && battery->pdata->wpc_flicker_wa_input_limit_current) {
			psy_do_property(battery->pdata->wireless_charger_name, get,
				POWER_SUPPLY_EXT_PROP_WIRELESS_TX_ID, value);
			if ((value.intval != WC_PAD_ID_UNKNOWN) &&
				(value.intval != WC_PAD_ID_SNGL_DREAM) &&
				(value.intval != WC_PAD_ID_STAND_DREAM)) {
				pr_info("%s: trigger flicker wa\n", __func__);
				if (incurr > battery->pdata->wpc_flicker_wa_input_limit_current)
					incurr = battery->pdata->wpc_flicker_wa_input_limit_current;
			}
		}
	}

	/* Full-Additional state */
	if (battery->status == POWER_SUPPLY_STATUS_FULL && battery->charging_mode == SEC_BATTERY_CHARGING_2ND) {
		if (incurr > battery->pdata->siop_hv_wpc_icl)
			incurr = battery->pdata->siop_hv_wpc_icl;
	}

	/* Hero Stand Pad CV */
	if (battery->capacity >= battery->pdata->wc_hero_stand_cc_cv) {
		if (battery->cable_type == SEC_BATTERY_CABLE_WIRELESS_STAND) {
			if (incurr > battery->pdata->wc_hero_stand_cv_current)
				incurr = battery->pdata->wc_hero_stand_cv_current;
		} else if (battery->cable_type == SEC_BATTERY_CABLE_WIRELESS_HV_STAND) {
			if (battery->chg_limit &&
					incurr > battery->pdata->wc_hero_stand_cv_current) {
				incurr = battery->pdata->wc_hero_stand_cv_current;
			} else if (!battery->chg_limit &&
					incurr > battery->pdata->wc_hero_stand_hv_cv_current) {
				incurr = battery->pdata->wc_hero_stand_hv_cv_current;
			}
		}
	}

	/* Full-None state && SIOP_LEVEL 100 */
	if ((battery->siop_level >= 100 && !battery->lcd_status) &&
		battery->status == POWER_SUPPLY_STATUS_FULL && battery->charging_mode == SEC_BATTERY_CHARGING_NONE) {
		incurr = battery->pdata->wc_full_input_limit_current;
	}

	if (incurr != INT_MAX)
		sec_vote(battery->input_vote, VOTER_WPC_CUR, true, incurr);
	else
		sec_vote(battery->input_vote, VOTER_WPC_CUR, false, incurr);
}

int sec_bat_check_wc_available(struct sec_battery_info *battery)
{
	mutex_lock(&battery->wclock);
	if (!battery->wc_enable) {
		pr_info("%s: wc_enable(%d), cnt(%d)\n", __func__, battery->wc_enable, battery->wc_enable_cnt);
		if (battery->wc_enable_cnt > battery->wc_enable_cnt_value) {
			union power_supply_propval val = {0, };
			char wpc_en_status[2];

			battery->wc_enable = true;
			battery->wc_enable_cnt = 0;
			wpc_en_status[0] = WPC_EN_SYSFS;
			wpc_en_status[1] = true;
			val.strval = wpc_en_status;
			psy_do_property(battery->pdata->wireless_charger_name, set,
					POWER_SUPPLY_EXT_PROP_WPC_EN, val);
			pr_info("%s: WC CONTROL: Enable\n", __func__);
		}
		battery->wc_enable_cnt++;
	}
	mutex_unlock(&battery->wclock);

	return 0;
}

/* OTG during HV wireless charging or sleep mode have 4.5W normal wireless charging UI */
bool sec_bat_hv_wc_normal_mode_check(struct sec_battery_info *battery)
{
	union power_supply_propval value = {0, };

	psy_do_property(battery->pdata->charger_name, get,
			POWER_SUPPLY_EXT_PROP_CHARGE_OTG_CONTROL, value);
	if (value.intval || battery->sleep_mode) {
		pr_info("%s: otg(%d), sleep_mode(%d)\n", __func__, value.intval, battery->sleep_mode);
		return true;
	}
	return false;
}
EXPORT_SYMBOL_KUNIT(sec_bat_hv_wc_normal_mode_check);

void sec_bat_ext_event_work_content(struct sec_battery_info *battery)
{
	union power_supply_propval value = {0, };

	if (battery->wc_tx_enable) { /* TX ON state */
		if (battery->ext_event & BATT_EXT_EVENT_CAMERA) {
			pr_info("@Tx_Mode %s: Camera ON, TX OFF\n", __func__);
			sec_bat_set_tx_event(battery,
					BATT_TX_EVENT_WIRELESS_TX_CAMERA_ON, BATT_TX_EVENT_WIRELESS_TX_CAMERA_ON);
			sec_wireless_set_tx_enable(battery, false);
		} else if (battery->ext_event & BATT_EXT_EVENT_DEX) {
			pr_info("@Tx_Mode %s: Dex ON, TX OFF\n", __func__);
			sec_bat_set_tx_event(battery,
					BATT_TX_EVENT_WIRELESS_TX_OTG_ON, BATT_TX_EVENT_WIRELESS_TX_OTG_ON);
			sec_wireless_set_tx_enable(battery, false);
		} else if (battery->ext_event & BATT_EXT_EVENT_CALL) {
			pr_info("@Tx_Mode %s: Call ON, TX OFF\n", __func__);
			battery->tx_retry_case |= SEC_BAT_TX_RETRY_CALL;
			/* clear tx all event */
			sec_bat_set_tx_event(battery, 0, BATT_TX_EVENT_WIRELESS_ALL_MASK);
			sec_wireless_set_tx_enable(battery, false);
		}
	} else { /* TX OFF state, it has only call scenario */
		if (battery->ext_event & BATT_EXT_EVENT_CALL) {
			pr_info("@Tx_Mode %s: Call ON\n", __func__);

			value.intval = BATT_EXT_EVENT_CALL;
			psy_do_property(battery->pdata->wireless_charger_name, set,
							POWER_SUPPLY_EXT_PROP_CALL_EVENT, value);

#if !defined(CONFIG_WIRELESS_RX_PHM_CTRL)
			if (battery->cable_type == SEC_BATTERY_CABLE_WIRELESS_PACK ||
				battery->cable_type == SEC_BATTERY_CABLE_WIRELESS_HV_PACK ||
				battery->cable_type == SEC_BATTERY_CABLE_WIRELESS_TX) {
				pr_info("%s: Call is on during Wireless Pack or TX\n", __func__);
				battery->wc_rx_phm_mode = true;
			}
#endif
			if (battery->tx_retry_case != SEC_BAT_TX_RETRY_NONE) {
				pr_info("@Tx_Mode %s: TX OFF because of other reason(retry:0x%x), save call retry case\n",
					__func__, battery->tx_retry_case);
				battery->tx_retry_case |= SEC_BAT_TX_RETRY_CALL;
			}
		} else if (!(battery->ext_event & BATT_EXT_EVENT_CALL)) {
			pr_info("@Tx_Mode %s: Call OFF\n", __func__);

			value.intval = BATT_EXT_EVENT_NONE;
			psy_do_property(battery->pdata->wireless_charger_name, set,
							POWER_SUPPLY_EXT_PROP_CALL_EVENT, value);

			/* check the diff between current and previous ext_event state */
			if (battery->tx_retry_case & SEC_BAT_TX_RETRY_CALL) {
				battery->tx_retry_case &= ~SEC_BAT_TX_RETRY_CALL;
				if (!battery->tx_retry_case) {
					pr_info("@Tx_Mode %s: Call OFF, TX Retry\n", __func__);
					sec_bat_set_tx_event(battery,
							BATT_TX_EVENT_WIRELESS_TX_RETRY,
							BATT_TX_EVENT_WIRELESS_TX_RETRY);
				}
			}
#if !defined(CONFIG_WIRELESS_RX_PHM_CTRL)
			/* process escape phm */
			if (battery->wc_rx_phm_mode) {
				pr_info("%s: ESCAPE PHM STEP 1\n", __func__);
				sec_bat_set_mfc_on(battery, WPC_EN_CHARGING);
				msleep(100);

				pr_info("%s: ESCAPE PHM STEP 2\n", __func__);
				sec_bat_set_mfc_off(battery, WPC_EN_CHARGING, false);
				msleep(510);

				pr_info("%s: ESCAPE PHM STEP 3\n", __func__);
				sec_bat_set_mfc_on(battery, WPC_EN_CHARGING);
			}
			battery->wc_rx_phm_mode = false;
#endif
		}
	}

	__pm_relax(battery->ext_event_ws);
}

void sec_bat_wireless_minduty_cntl(struct sec_battery_info *battery, unsigned int duty_val)
{
	union power_supply_propval value = {0, };

	if (duty_val != battery->tx_minduty) {
		value.intval = duty_val;
		psy_do_property(battery->pdata->wireless_charger_name, set,
				POWER_SUPPLY_EXT_PROP_WIRELESS_MIN_DUTY, value);

		pr_info("@Tx_Mode %s: Min duty changed (%d -> %d)\n", __func__, battery->tx_minduty, duty_val);
		battery->tx_minduty = duty_val;
	}
}

void sec_bat_wireless_set_ping_duty(struct sec_battery_info *battery, unsigned int ping_duty_val)
{
	union power_supply_propval value = {0, };

	if (ping_duty_val != battery->tx_ping_duty) {
		value.intval = ping_duty_val;
		psy_do_property(battery->pdata->wireless_charger_name, set,
				POWER_SUPPLY_EXT_PROP_WIRELESS_PING_DUTY, value);

		pr_info("@Tx_Mode %s: Ping duty changed (%d -> %d)\n",
			__func__, battery->tx_ping_duty, ping_duty_val);
		battery->tx_ping_duty = ping_duty_val;
	}
}

void sec_bat_wireless_uno_cntl(struct sec_battery_info *battery, bool en)
{
	union power_supply_propval value = {0, };

	value.intval = en;
	battery->uno_en = en;
	pr_info("@Tx_Mode %s: Uno control %d\n", __func__, en);

	psy_do_property(battery->pdata->wireless_charger_name, set,
			POWER_SUPPLY_EXT_PROP_WIRELESS_TX_ENABLE, value);

	sb_tx_set_enable(en, 0);
}

void sec_bat_wireless_iout_cntl(struct sec_battery_info *battery, int uno_iout, int mfc_iout)
{
	union power_supply_propval value = {0, };

	if (battery->tx_uno_iout != uno_iout) {
		pr_info("@Tx_Mode %s: set uno iout(%d) -> (%d)\n", __func__, battery->tx_uno_iout, uno_iout);
		value.intval = battery->tx_uno_iout = uno_iout;
		psy_do_property("otg", set,
				POWER_SUPPLY_EXT_PROP_WIRELESS_TX_IOUT, value);
	} else {
		pr_info("@Tx_Mode %s: Already set Uno Iout(%d == %d)\n", __func__, battery->tx_uno_iout, uno_iout);
	}

#if !defined(CONFIG_SEC_FACTORY)
	if (battery->lcd_status && (mfc_iout == battery->pdata->tx_mfc_iout_phone)) {
		pr_info("@Tx_Mode %s: Reduce Tx MFC Iout. LCD ON\n", __func__);
		mfc_iout = battery->pdata->tx_mfc_iout_lcd_on;
	}
#endif

	if (battery->tx_mfc_iout != mfc_iout) {
		pr_info("@Tx_Mode %s: set mfc iout(%d) -> (%d)\n", __func__, battery->tx_mfc_iout, mfc_iout);
		value.intval = battery->tx_mfc_iout = mfc_iout;
		psy_do_property(battery->pdata->wireless_charger_name, set,
				POWER_SUPPLY_EXT_PROP_WIRELESS_TX_IOUT, value);
	} else {
		pr_info("@Tx_Mode %s: Already set MFC Iout(%d == %d)\n", __func__, battery->tx_mfc_iout, mfc_iout);
	}
}

void sec_bat_wireless_vout_cntl(struct sec_battery_info *battery, int vout_now)
{
	union power_supply_propval value = {0, };

	pr_info("@Tx_Mode %s: set uno & mfc vout (%dmV -> %dmV)\n", __func__, battery->wc_tx_vout, vout_now);

	if (battery->wc_tx_vout >= vout_now) {
		battery->wc_tx_vout = value.intval = vout_now;
		psy_do_property(battery->pdata->wireless_charger_name, set,
				POWER_SUPPLY_EXT_PROP_WIRELESS_TX_VOUT, value);
		psy_do_property("otg", set,
				POWER_SUPPLY_EXT_PROP_WIRELESS_TX_VOUT, value);
	} else if (vout_now > battery->wc_tx_vout) {
		battery->wc_tx_vout = value.intval = vout_now;
		psy_do_property("otg", set,
				POWER_SUPPLY_EXT_PROP_WIRELESS_TX_VOUT, value);
		psy_do_property(battery->pdata->wireless_charger_name, set,
				POWER_SUPPLY_EXT_PROP_WIRELESS_TX_VOUT, value);
	}

}

#if defined(CONFIG_WIRELESS_TX_MODE)
#if !defined(CONFIG_SEC_FACTORY)
static void sec_bat_check_tx_battery_drain(struct sec_battery_info *battery)
{
	if (battery->capacity <= battery->pdata->tx_stop_capacity &&
		is_nocharge_type(battery->cable_type)) {
		pr_info("@Tx_Mode %s: battery level is drained, TX mode should turn off\n", __func__);
		/* set tx event */
		sec_bat_set_tx_event(battery, BATT_TX_EVENT_WIRELESS_TX_SOC_DRAIN, BATT_TX_EVENT_WIRELESS_TX_SOC_DRAIN);
		sec_wireless_set_tx_enable(battery, false);
	}
}

static void sec_bat_check_tx_current(struct sec_battery_info *battery)
{
	if (battery->lcd_status && (battery->tx_mfc_iout > battery->pdata->tx_mfc_iout_lcd_on)) {
		sec_bat_wireless_iout_cntl(battery, battery->pdata->tx_uno_iout, battery->pdata->tx_mfc_iout_lcd_on);
		pr_info("@Tx_Mode %s: Reduce Tx MFC Iout. LCD ON\n", __func__);
	} else if (!battery->lcd_status && (battery->tx_mfc_iout == battery->pdata->tx_mfc_iout_lcd_on)) {
		union power_supply_propval value = {0, };

		sec_bat_wireless_iout_cntl(battery, battery->pdata->tx_uno_iout, battery->pdata->tx_mfc_iout_phone);
		pr_info("@Tx_Mode %s: Recovery Tx MFC Iout. LCD OFF\n", __func__);

		value.intval = true;
		psy_do_property(battery->pdata->wireless_charger_name, set,
			POWER_SUPPLY_EXT_PROP_WIRELESS_SEND_FSK, value);
	}
}
#endif

static void sec_bat_check_tx_switch_mode(struct sec_battery_info *battery)
{
	union power_supply_propval value = {0, };

	/* temporary mode */
	if (battery->tx_switch_mode == TX_SWITCH_GEAR_PPS) {
		pr_info("@Tx_mode %s: skip routine in gear pps mode.\n", __func__);
		return;
	}

	if (battery->current_event & SEC_BAT_CURRENT_EVENT_AFC)	{
		pr_info("@Tx_mode %s: Do not switch switch mode! AFC Event set\n", __func__);
		return;
	}

	value.intval = SEC_FUELGAUGE_CAPACITY_TYPE_CAPACITY_POINT;
	psy_do_property(battery->pdata->fuelgauge_name, get,
			POWER_SUPPLY_PROP_CAPACITY, value);

	if ((battery->tx_switch_mode == TX_SWITCH_UNO_ONLY) && (!battery->buck_cntl_by_tx)) {
		battery->buck_cntl_by_tx = true;
		sec_vote(battery->chgen_vote, VOTER_WC_TX, true, SEC_BAT_CHG_MODE_BUCK_OFF);

		sec_bat_wireless_iout_cntl(battery, battery->pdata->tx_uno_iout, battery->pdata->tx_mfc_iout_phone);
		sec_bat_wireless_vout_cntl(battery, battery->pdata->tx_uno_vout);
		sec_bat_wireless_minduty_cntl(battery, battery->pdata->tx_minduty_default);
	} else if ((battery->tx_switch_mode == TX_SWITCH_CHG_ONLY) && (battery->buck_cntl_by_tx)) {
		sec_bat_wireless_iout_cntl(battery, battery->pdata->tx_uno_iout, battery->pdata->tx_mfc_iout_phone_5v);
		sec_bat_wireless_vout_cntl(battery, battery->pdata->tx_ping_vout);
		sec_bat_wireless_minduty_cntl(battery, battery->pdata->tx_minduty_5V);

		battery->buck_cntl_by_tx = false;
		sec_vote(battery->chgen_vote, VOTER_WC_TX, false, 0);
	}

	if (battery->status == POWER_SUPPLY_STATUS_FULL) {
		if (battery->charging_mode == SEC_BATTERY_CHARGING_NONE) {
			if (battery->tx_switch_mode == TX_SWITCH_CHG_ONLY)
				battery->tx_switch_mode_change = true;
		} else {
			if (battery->tx_switch_mode == TX_SWITCH_UNO_ONLY) {
				if (battery->tx_switch_start_soc >= 100) {
					if (battery->capacity < 99 || (battery->capacity == 99 && value.intval <= 1))
						battery->tx_switch_mode_change = true;
				} else {
					if ((battery->capacity == battery->tx_switch_start_soc && value.intval <= 1) ||
					(battery->capacity < battery->tx_switch_start_soc))
						battery->tx_switch_mode_change = true;
				}
			} else if (battery->tx_switch_mode == TX_SWITCH_CHG_ONLY) {
				if (battery->capacity >= 100)
					battery->tx_switch_mode_change = true;
			}
		}
	} else {
		if (battery->tx_switch_mode == TX_SWITCH_UNO_ONLY) {
			if (((battery->capacity == battery->tx_switch_start_soc) && (value.intval <= 1)) ||
				(battery->capacity < battery->tx_switch_start_soc))
				battery->tx_switch_mode_change = true;

		} else if (battery->tx_switch_mode == TX_SWITCH_CHG_ONLY) {
			if (((battery->capacity == (battery->tx_switch_start_soc + 1)) && (value.intval >= 8)) ||
				(battery->capacity > (battery->tx_switch_start_soc + 1)))
				battery->tx_switch_mode_change = true;
		}
	}
	pr_info("@Tx_mode Tx mode(%d) tx_switch_mode_change(%d) start soc(%d) now soc(%d.%d)\n",
		battery->tx_switch_mode, battery->tx_switch_mode_change,
		battery->tx_switch_start_soc, battery->capacity, value.intval);
}
#endif

void sec_bat_txpower_calc(struct sec_battery_info *battery)
{
	if (delayed_work_pending(&battery->wpc_txpower_calc_work)) {
		pr_info("%s: keep average tx power(%5d mA)\n", __func__, battery->tx_avg_curr);
	} else if (battery->wc_tx_enable) {
		int tx_vout = 0, tx_iout = 0, vbatt = 0;
		union power_supply_propval value = {0, };

		psy_do_property(battery->pdata->wireless_charger_name, get,
			POWER_SUPPLY_EXT_PROP_WIRELESS_TX_UNO_VIN, value);
		tx_vout = value.intval;

		psy_do_property(battery->pdata->wireless_charger_name, get,
			POWER_SUPPLY_EXT_PROP_WIRELESS_TX_UNO_IIN, value);
		tx_iout = value.intval;

		value.intval = SEC_BATTERY_VOLTAGE_MV;
		psy_do_property(battery->pdata->fuelgauge_name, get,
			POWER_SUPPLY_PROP_VOLTAGE_NOW, value);
		vbatt = value.intval;

		battery->tx_time_cnt++;

		/* AVG curr will be calculated only when the battery is discharged */
		if (battery->current_avg <= 0 && vbatt > 0 && tx_vout > 0 && tx_iout > 0)
			tx_iout = (tx_vout / vbatt) * tx_iout;
		else
			tx_iout = 0;

		/* monitor work will be scheduled every 10s when wc_tx_enable is true */
		battery->tx_avg_curr =
			((battery->tx_avg_curr * battery->tx_time_cnt) + tx_iout) / (battery->tx_time_cnt + 1);
		battery->tx_total_power =
			(battery->tx_avg_curr * battery->tx_time_cnt) / (60 * 60 / 10);

		if (battery->tx_total_power > ((battery->pdata->battery_full_capacity * 7) / 10)) {
			pr_info("%s: tx_total_power(%dmAh) is wrong\n", __func__, battery->tx_total_power);
			battery->tx_total_power = (battery->pdata->battery_full_capacity * 7) / 10;
		}

		pr_info("%s: tx_time_cnt(%ds), UNO_Vin(%dV), UNO_Iin(%dmA), tx_avg_curr(%dmA), tx_total_power(%dmAh)\n",
				__func__, battery->tx_time_cnt * 10, tx_vout, tx_iout, battery->tx_avg_curr, battery->tx_total_power);
	}
}

void sec_bat_tx_off_by_misalign_ocp(struct sec_battery_info *battery)
{
	battery->tx_retry_case &= ~(SEC_BAT_TX_RETRY_MISALIGN | SEC_BAT_TX_RETRY_OCP);
	battery->tx_misalign_start_time = 0;
	battery->tx_misalign_cnt = 0;
	battery->tx_ocp_start_time = 0;
	battery->tx_ocp_cnt = 0;
}

void sec_bat_handle_tx_misalign(struct sec_battery_info *battery, bool trigger_misalign)
{
	struct timespec64 ts = {0, };

	if (trigger_misalign && battery->wc_tx_enable) {
		if (battery->tx_misalign_start_time == 0) {
			ts = ktime_to_timespec64(ktime_get_boottime());
			battery->tx_misalign_start_time = ts.tv_sec;
		}
		pr_info("@Tx_Mode %s: misalign is triggered!!(%d)\n", __func__, ++battery->tx_misalign_cnt);
		/* Attention!! in this case, 0x00(TX_OFF)  is sent first */
		/* and then 0x8000(RETRY) is sent */
		if (battery->tx_misalign_cnt < MISALIGN_TX_TRY_CNT) {
			battery->tx_retry_case |= SEC_BAT_TX_RETRY_MISALIGN;
			sec_wireless_set_tx_enable(battery, false);
			msleep(1000);
			/* clear tx all event */
			sec_bat_set_tx_event(battery, 0, BATT_TX_EVENT_WIRELESS_ALL_MASK);
			sec_bat_set_tx_event(battery,
				BATT_TX_EVENT_WIRELESS_TX_RETRY, BATT_TX_EVENT_WIRELESS_TX_RETRY);
			msleep(1000);
		} else {
			pr_info("@Tx_Mode %s: Misalign over %d times, TX OFF (cancel misalign)\n",
				__func__, MISALIGN_TX_TRY_CNT);
			sec_bat_tx_off_by_misalign_ocp(battery);
			sec_bat_set_tx_event(battery,
				BATT_TX_EVENT_WIRELESS_TX_MISALIGN, BATT_TX_EVENT_WIRELESS_TX_MISALIGN);
			sec_wireless_set_tx_enable(battery, false);
		}
	} else if (battery->tx_retry_case & SEC_BAT_TX_RETRY_MISALIGN) {
		ts = ktime_to_timespec64(ktime_get_boottime());
		if (ts.tv_sec >= battery->tx_misalign_start_time) {
			battery->tx_misalign_passed_time = ts.tv_sec - battery->tx_misalign_start_time;
		} else {
			battery->tx_misalign_passed_time = 0xFFFFFFFF - battery->tx_misalign_start_time
				+ ts.tv_sec;
		}
		pr_info("@Tx_Mode %s: already misaligned, passed time(%ld)\n",
				__func__, battery->tx_misalign_passed_time);

		if (battery->tx_misalign_passed_time >= 60) {
			pr_info("@Tx_Mode %s: after 1min\n", __func__);
			if (battery->wc_tx_enable) {
				if (battery->wc_rx_connected) {
					pr_info("@Tx_Mode %s: RX Dev, Keep TX ON status (cancel misalign)\n", __func__);
				} else {
					pr_info("@Tx_Mode %s: NO RX Dev, TX OFF (cancel misalign)\n", __func__);
					sec_bat_tx_off_by_misalign_ocp(battery);
					sec_bat_set_tx_event(battery,
						BATT_TX_EVENT_WIRELESS_TX_MISALIGN, BATT_TX_EVENT_WIRELESS_TX_MISALIGN);
					sec_wireless_set_tx_enable(battery, false);
				}
			} else {
				pr_info("@Tx_Mode %s: Keep TX OFF status (cancel misalign)\n", __func__);
			}
			battery->tx_retry_case &= ~SEC_BAT_TX_RETRY_MISALIGN;
			battery->tx_misalign_start_time = 0;
			battery->tx_misalign_cnt = 0;
		}
	}
}
EXPORT_SYMBOL_KUNIT(sec_bat_handle_tx_misalign);

void sec_bat_handle_tx_ocp(struct sec_battery_info *battery, bool trigger_ocp)
{
	struct timespec64 ts = {0, };

	if (trigger_ocp && battery->wc_tx_enable) {
		if (battery->tx_ocp_start_time == 0) {
			ts = ktime_to_timespec64(ktime_get_boottime());
			battery->tx_ocp_start_time = ts.tv_sec;
		}
		pr_info("@Tx_Mode %s: ocp is triggered!!(%d)\n", __func__, ++battery->tx_ocp_cnt);
		/* Attention!! in this case, 0x00(TX_OFF)  is sent first */
		/* and then 0x8000(RETRY) is sent */
		if (battery->tx_ocp_cnt < 3) {
			battery->tx_retry_case |= SEC_BAT_TX_RETRY_OCP;
			sec_wireless_set_tx_enable(battery, false);
			msleep(1000);
			/* clear tx all event */
			sec_bat_set_tx_event(battery, 0, BATT_TX_EVENT_WIRELESS_ALL_MASK);
			sec_bat_set_tx_event(battery,
				BATT_TX_EVENT_WIRELESS_TX_RETRY, BATT_TX_EVENT_WIRELESS_TX_RETRY);
			msleep(1000);
		} else {
			pr_info("@Tx_Mode %s: ocp over 3 times, TX OFF (cancel ocp)\n", __func__);
			sec_bat_tx_off_by_misalign_ocp(battery);
			sec_bat_set_tx_event(battery,
				BATT_TX_EVENT_WIRELESS_TX_OCP, BATT_TX_EVENT_WIRELESS_TX_OCP);
			sec_wireless_set_tx_enable(battery, false);
		}
	} else if (battery->tx_retry_case & SEC_BAT_TX_RETRY_OCP) {
		ts = ktime_to_timespec64(ktime_get_boottime());
		if (ts.tv_sec >= battery->tx_ocp_start_time) {
			battery->tx_ocp_passed_time = ts.tv_sec - battery->tx_ocp_start_time;
		} else {
			battery->tx_ocp_passed_time = 0xFFFFFFFF - battery->tx_ocp_start_time
				+ ts.tv_sec;
		}
		pr_info("@Tx_Mode %s: already ocp, passed time(%ld)\n",
				__func__, battery->tx_ocp_passed_time);

		if (battery->tx_ocp_passed_time >= 60) {
			pr_info("@Tx_Mode %s: after 1min\n", __func__);
			if (battery->wc_tx_enable) {
				if (battery->wc_rx_connected) {
					pr_info("@Tx_Mode %s: RX Dev, Keep TX ON status (cancel ocp)\n", __func__);
				} else {
					pr_info("@Tx_Mode %s: NO RX Dev, TX OFF (cancel ocp)\n", __func__);
					sec_bat_tx_off_by_misalign_ocp(battery);
					sec_bat_set_tx_event(battery,
						BATT_TX_EVENT_WIRELESS_TX_OCP, BATT_TX_EVENT_WIRELESS_TX_OCP);
					sec_wireless_set_tx_enable(battery, false);
				}
			} else {
				pr_info("@Tx_Mode %s: Keep TX OFF status (cancel ocp)\n", __func__);
			}
			battery->tx_retry_case &= ~SEC_BAT_TX_RETRY_OCP;
			battery->tx_ocp_start_time = 0;
			battery->tx_ocp_cnt = 0;
		}
	}
}

void sec_bat_check_wc_re_auth(struct sec_battery_info *battery)
{
	union power_supply_propval value = {0, };

	int tx_id = 0, auth_stat = 0;

	psy_do_property(battery->pdata->wireless_charger_name, get,
		POWER_SUPPLY_EXT_PROP_WIRELESS_TX_ID, value);
	tx_id = value.intval;

	psy_do_property(battery->pdata->wireless_charger_name, get,
		POWER_SUPPLY_EXT_PROP_WIRELESS_AUTH_ADT_STATUS, value);
	auth_stat = value.intval;

	pr_info("%s %s: tx_id(0x%x), cable(%d), soc(%d), auth_stat(%d)\n", WC_AUTH_MSG, __func__,
		tx_id, battery->cable_type, battery->capacity, auth_stat);

	if ((auth_stat == WIRELESS_AUTH_FAIL) && (battery->capacity >= 5)) {
		pr_info("%s %s: EPT Unknown for re-auth\n", WC_AUTH_MSG, __func__);
		value.intval = 1;
		psy_do_property(battery->pdata->wireless_charger_name, set,
			POWER_SUPPLY_EXT_PROP_WC_EPT_UNKNOWN, value);
		battery->wc_auth_retried = true;
	} else if (auth_stat == WIRELESS_AUTH_PASS) {
		pr_info("%s %s: auth success\n", WC_AUTH_MSG, __func__);
		battery->wc_auth_retried = true;
	} else if (((tx_id != 0) && (tx_id < WC_PAD_ID_AUTH_PAD))
		|| (tx_id > WC_PAD_ID_AUTH_PAD_END)
		|| ((tx_id == 0) && is_hv_wireless_type(battery->cable_type) &&
			(battery->cable_type != SEC_BATTERY_CABLE_WIRELESS_MPP) &&
			(battery->cable_type != SEC_BATTERY_CABLE_WIRELESS_EPP))) {
		pr_info("%s %s: re-auth is unnecessary\n", WC_AUTH_MSG, __func__);
		battery->wc_auth_retried = true;
	}
}

#if defined(CONFIG_WIRELESS_TX_MODE)
void sec_bat_check_tx_mode(struct sec_battery_info *battery)
{

	if (battery->wc_tx_enable) {
		pr_info("@Tx_Mode %s: tx_retry(0x%x), tx_switch(0x%x)",
			__func__, battery->tx_retry_case, battery->tx_switch_mode);
#if !defined(CONFIG_SEC_FACTORY)
		sec_bat_check_tx_battery_drain(battery);
		sec_bat_check_tx_temperature(battery);

		if ((battery->wc_rx_type == SS_PHONE) ||
				(battery->wc_rx_type == OTHER_DEV) ||
				(battery->wc_rx_type == SS_BUDS))
			sec_bat_check_tx_current(battery);
#endif
		sec_bat_txpower_calc(battery);
		sec_bat_handle_tx_misalign(battery, false);
		sec_bat_handle_tx_ocp(battery, false);
		battery->tx_retry_case &= ~SEC_BAT_TX_RETRY_AC_MISSING;

		if (battery->tx_switch_mode != TX_SWITCH_MODE_OFF && battery->tx_switch_start_soc != 0)
			sec_bat_check_tx_switch_mode(battery);

	} else if (battery->tx_retry_case != SEC_BAT_TX_RETRY_NONE) {
		pr_info("@Tx_Mode %s: tx_retry(0x%x)", __func__, battery->tx_retry_case);
#if !defined(CONFIG_SEC_FACTORY)
		sec_bat_check_tx_temperature(battery);
#endif
		sec_bat_handle_tx_misalign(battery, false);
		sec_bat_handle_tx_ocp(battery, false);
		battery->tx_retry_case &= ~SEC_BAT_TX_RETRY_AC_MISSING;
	}
}
#endif

void sec_bat_wc_cv_mode_check(struct sec_battery_info *battery)
{
	union power_supply_propval value = {0, };
	int is_otg_on = 0;

	psy_do_property(battery->pdata->charger_name, get,
			POWER_SUPPLY_EXT_PROP_CHARGE_OTG_CONTROL, value);
	is_otg_on = value.intval;

	pr_info("%s: battery->wc_cv_mode = %d, otg(%d), cable_type(%d)\n", __func__,
		battery->wc_cv_mode, is_otg_on, battery->cable_type);

	if (battery->capacity >= battery->pdata->wireless_cc_cv && !is_otg_on) {
		battery->wc_cv_mode = true;
		if (is_nv_wireless_type(battery->cable_type)) {
			if ((battery->cable_type == SEC_BATTERY_CABLE_WIRELESS ||
				battery->cable_type == SEC_BATTERY_CABLE_WIRELESS_STAND ||
				battery->cable_type == SEC_BATTERY_CABLE_WIRELESS_TX)) {
				value.intval = WIRELESS_CLAMP_ENABLE;
				psy_do_property(battery->pdata->wireless_charger_name, set,
					POWER_SUPPLY_EXT_PROP_WIRELESS_RX_CONTROL, value);
			}
		}
		/* Change FOD values for CV mode */
		value.intval = POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE;
		psy_do_property(battery->pdata->wireless_charger_name, set,
			POWER_SUPPLY_PROP_STATUS, value);

		/* Change Vrect headroom for CV mode */
		if (battery->pdata->p2p_cv_headroom && battery->cable_type == SEC_BATTERY_CABLE_WIRELESS_TX) {
			value.intval = WIRELESS_VRECT_ADJ_ROOM_2;
			psy_do_property(battery->pdata->wireless_charger_name, set,
				POWER_SUPPLY_EXT_PROP_WIRELESS_RX_CONTROL, value);
		}
	}
}
EXPORT_SYMBOL_KUNIT(sec_bat_wc_cv_mode_check);

static int is_5v_charger(struct sec_battery_info *battery, int wr_sts)
{
	if ((is_pd_wire_type(wr_sts) && battery->pd_list.max_pd_count > 1)
			|| is_hv_wire_12v_type(wr_sts)
			|| is_hv_wire_type(wr_sts)
			|| (wr_sts == SEC_BATTERY_CABLE_HV_TA_CHG_LIMIT)
			|| (wr_sts == SEC_BATTERY_CABLE_PREPARE_TA)
			|| (battery->current_event & SEC_BAT_CURRENT_EVENT_AFC))
		return false;
	else if (is_wired_type(wr_sts))
		return true;

	return false;
}

void sec_bat_run_wpc_tx_work(struct sec_battery_info *battery, int work_delay)
{
	if (delayed_work_pending(&battery->wpc_tx_work)) {
		pr_info("%s: did not push the tx_work because of already in queue.\n", __func__);
		return;
	}

	cancel_delayed_work(&battery->wpc_tx_work);
	__pm_stay_awake(battery->wpc_tx_ws);
	queue_delayed_work(battery->monitor_wqueue,
		&battery->wpc_tx_work, msecs_to_jiffies(work_delay));
}

static void sec_bat_wpc_tx_iv(struct sec_vote *target_vote, int target_voltage, bool need_refresh)
{
	int voter_val = get_sec_vote_result(target_vote);

	pr_info("@Tx_mode %s : present iv = %d. target iv = %d\n", __func__, voter_val, target_voltage);

	sec_vote(target_vote, VOTER_WC_TX, true, target_voltage);

	if (need_refresh && (voter_val == target_voltage))
		sec_vote_refresh(target_vote);
}

static void sec_bat_tx_work_nodev(struct sec_battery_info *battery)
{
	if (battery->pdata->fcc_by_tx)
		sec_vote(battery->fcc_vote, VOTER_WC_TX, true,
				battery->pdata->fcc_by_tx);

	if (is_hv_wire_type(battery->wire_status) ||
		(is_pd_wire_type(battery->wire_status) && battery->hv_pdo)) {
		sec_bat_wpc_tx_iv(battery->iv_vote, SEC_INPUT_VOLTAGE_5V, true);
		return;
	}
	battery->buck_cntl_by_tx = true;
	sec_vote(battery->chgen_vote, VOTER_WC_TX, true, SEC_BAT_CHG_MODE_BUCK_OFF);
	if (!battery->uno_en)
		sec_bat_wireless_uno_cntl(battery, true);

	sec_bat_wireless_vout_cntl(battery, battery->pdata->tx_ping_vout);
	sec_bat_wireless_iout_cntl(battery, battery->pdata->tx_uno_iout_aov_gear, battery->pdata->tx_mfc_iout_aov_gear);
	sec_bat_wireless_minduty_cntl(battery, battery->pdata->tx_minduty_default);
}

static void sec_bat_tx_work_with_nv_charger(struct sec_battery_info *battery)
{
	union power_supply_propval value = {0, };

	if (battery->pdata->tx_5v_disable)
		return;

	if (battery->current_event & SEC_BAT_CURRENT_EVENT_AFC) {
		if (!battery->buck_cntl_by_tx) {
			battery->buck_cntl_by_tx = true;
			sec_vote(battery->chgen_vote, VOTER_WC_TX, true, SEC_BAT_CHG_MODE_BUCK_OFF);
		}
		battery->tx_switch_mode = TX_SWITCH_MODE_OFF;
		battery->tx_switch_start_soc = 0;
		battery->tx_switch_mode_change = false;

		sec_bat_wireless_iout_cntl(battery,
				battery->pdata->tx_uno_iout, battery->pdata->tx_mfc_iout_phone);
		sec_bat_wireless_vout_cntl(battery, battery->pdata->tx_uno_vout);
		sec_bat_wireless_minduty_cntl(battery, battery->pdata->tx_minduty_default);
	} else if (battery->tx_switch_mode == TX_SWITCH_MODE_OFF) {
		battery->tx_switch_mode = TX_SWITCH_UNO_ONLY;
		battery->tx_switch_start_soc = battery->capacity;
		if (!battery->buck_cntl_by_tx) {
			battery->buck_cntl_by_tx = true;
			sec_vote(battery->chgen_vote, VOTER_WC_TX, true, SEC_BAT_CHG_MODE_BUCK_OFF);
		}
		sec_bat_wireless_iout_cntl(battery,
				battery->pdata->tx_uno_iout, battery->pdata->tx_mfc_iout_phone);
		sec_bat_wireless_vout_cntl(battery, battery->pdata->tx_uno_vout);
		sec_bat_wireless_minduty_cntl(battery, battery->pdata->tx_minduty_default);

	} else if (battery->tx_switch_mode_change == true) {
		battery->tx_switch_start_soc = battery->capacity;

		pr_info("@Tx_mode: Switch Mode Change(%d -> %d)\n",
				battery->tx_switch_mode,
				battery->tx_switch_mode == TX_SWITCH_UNO_ONLY ?
				TX_SWITCH_CHG_ONLY : TX_SWITCH_UNO_ONLY);

		if (battery->tx_switch_mode == TX_SWITCH_UNO_ONLY) {
			battery->tx_switch_mode = TX_SWITCH_CHG_ONLY;

			sec_bat_wireless_iout_cntl(battery,
					battery->pdata->tx_uno_iout,
					battery->pdata->tx_mfc_iout_phone_5v);
			sec_bat_wireless_vout_cntl(battery, battery->pdata->tx_ping_vout);
			sec_bat_wireless_minduty_cntl(battery, battery->pdata->tx_minduty_5V);

			if (battery->buck_cntl_by_tx) {
				battery->buck_cntl_by_tx = false;
				sec_vote(battery->chgen_vote, VOTER_WC_TX, false, 0);
			}

		} else if (battery->tx_switch_mode == TX_SWITCH_CHG_ONLY) {
			battery->tx_switch_mode = TX_SWITCH_UNO_ONLY;

			if (!battery->buck_cntl_by_tx) {
				battery->buck_cntl_by_tx = true;
				sec_vote(battery->chgen_vote,
						VOTER_WC_TX, true, SEC_BAT_CHG_MODE_BUCK_OFF);
			}
			sec_bat_wireless_iout_cntl(battery,
					battery->pdata->tx_uno_iout,
					battery->pdata->tx_mfc_iout_phone);
			sec_bat_wireless_vout_cntl(battery, battery->pdata->tx_uno_vout);
			sec_bat_wireless_minduty_cntl(battery, battery->pdata->tx_minduty_default);

			value.intval = true;
			psy_do_property(battery->pdata->wireless_charger_name, set,
					POWER_SUPPLY_EXT_PROP_WIRELESS_SEND_FSK, value);
		}
		battery->tx_switch_mode_change = false;
	}
}

void sec_bat_wireless_proc_ping_duty(struct sec_battery_info *battery, int wr_sts)
{
	if (wr_sts != SEC_BATTERY_CABLE_NONE)
		sec_bat_wireless_set_ping_duty(battery, battery->pdata->tx_ping_duty_default);
	else
		sec_bat_wireless_set_ping_duty(battery, battery->pdata->tx_ping_duty_no_ta);
}

void sec_bat_wpc_tx_work_content(struct sec_battery_info *battery)
{
	int wr_sts = battery->wire_status;
	unsigned int tx_uno_vout = battery->pdata->tx_uno_vout;

	if (battery->wc_rx_type == SS_GEAR)
		tx_uno_vout = battery->pdata->tx_gear_vout;
	else if (battery->wc_rx_type == SS_BUDS)
		tx_uno_vout = battery->pdata->tx_buds_vout;

	dev_info(battery->dev, "@Tx_Mode %s: Start: %d\n", __func__, battery->wc_rx_type);
	if (!battery->wc_tx_enable) {
		pr_info("@Tx_Mode %s : exit wpc_tx_work. Because Tx is already off\n", __func__);
		goto end_of_tx_work;
	}
	if (battery->pdata->tx_5v_disable && is_5v_charger(battery, wr_sts)) {
		pr_info("@Tx_Mode %s : 5V charger(%d) connected, disable TX\n", __func__, battery->cable_type);
		sec_bat_set_tx_event(battery, BATT_TX_EVENT_WIRELESS_TX_5V_TA, BATT_TX_EVENT_WIRELESS_TX_5V_TA);
		sec_wireless_set_tx_enable(battery, false);
		goto end_of_tx_work;
	}

	if (battery->uno_en) {
		sec_bat_wireless_proc_ping_duty(battery, wr_sts);
	}

	switch (battery->wc_rx_type) {
	case NO_DEV:
		sec_bat_tx_work_nodev(battery);
		sec_bat_wireless_proc_ping_duty(battery, wr_sts);
		sb_tx_init_aov();
		break;
	case SS_GEAR:
	{
		if (battery->pdata->icl_by_tx_gear)
			sec_vote(battery->input_vote, VOTER_WC_TX, true,
				battery->pdata->icl_by_tx_gear);
		if (battery->pdata->fcc_by_tx_gear)
			sec_vote(battery->fcc_vote, VOTER_WC_TX, true,
				battery->pdata->fcc_by_tx_gear);

		if (sb_tx_is_aov_enabled(battery->wire_status)) {
			sb_tx_monitor_aov(battery->wc_tx_vout, battery->wc_tx_phm_mode);
			battery->buck_cntl_by_tx = false;

			battery->tx_switch_mode = TX_SWITCH_GEAR_PPS;
			battery->tx_switch_mode_change = true;

			sec_bat_wireless_iout_cntl(battery, battery->pdata->tx_uno_iout_aov_gear,
				battery->pdata->tx_mfc_iout_aov_gear);

			if (delayed_work_pending(&battery->wpc_tx_work))
				return;
			break;
		} else {
			if (battery->pdata->phm_vout_ctrl_dev & SEC_WIRELESS_PHM_VOUT_CTRL_GEAR) {
				if (battery->wc_tx_phm_mode) {
					if (is_hv_wire_type(battery->wire_status) ||
					(is_pd_wire_type(battery->wire_status) && battery->hv_pdo)) {
						pr_info("@Tx_Mode %s : change iv(9V -> 5V).\n", __func__);
						sec_bat_wireless_vout_cntl(battery, WC_TX_VOUT_5000MV);
						sec_bat_wpc_tx_iv(battery->iv_vote, SEC_INPUT_VOLTAGE_5V, true);
						break;
					}
				} else {
					if ((battery->wire_status == SEC_BATTERY_CABLE_HV_TA_CHG_LIMIT) ||
					(is_pd_wire_type(battery->wire_status) && !battery->hv_pdo)) {
						pr_info("@Tx_Mode %s : charging voltage change(5V -> 9V)\n", __func__);
						/* prevent ocp */
						if (!battery->buck_cntl_by_tx) {
							sec_bat_wireless_vout_cntl(battery, WC_TX_VOUT_5000MV);
							sec_bat_wireless_iout_cntl(battery, battery->pdata->tx_uno_iout_gear, 1000);
							battery->buck_cntl_by_tx = true;
							sec_vote(battery->chgen_vote, VOTER_WC_TX,
								true, SEC_BAT_CHG_MODE_BUCK_OFF);
							sec_bat_run_wpc_tx_work(battery, 500);
							return;
						} else if (battery->wc_tx_vout < WC_TX_VOUT_8500MV) {
							sec_bat_wireless_vout_cntl(battery,
								battery->wc_tx_vout + WC_TX_VOUT_STEP_AOV);
							sec_bat_run_wpc_tx_work(battery, 500);
							return;
						}
						sec_bat_wpc_tx_iv(battery->iv_vote, SEC_INPUT_VOLTAGE_9V, true);
						break;
					}
				}
			} else {
				if (is_hv_wire_type(battery->wire_status) ||
					(is_pd_wire_type(battery->wire_status) && battery->hv_pdo)) {
					pr_info("@Tx_Mode %s : change iv(9V -> 5V).\n", __func__);
					sec_bat_wireless_vout_cntl(battery, WC_TX_VOUT_5000MV);
					sec_bat_wpc_tx_iv(battery->iv_vote, SEC_INPUT_VOLTAGE_5V, true);
					break;
				}
			}
		}

		if (is_wired_type(battery->wire_status) && battery->buck_cntl_by_tx) {
			battery->buck_cntl_by_tx = false;
			sec_vote(battery->chgen_vote, VOTER_WC_TX, false, 0);
		} else if ((battery->wire_status == SEC_BATTERY_CABLE_NONE) && (!battery->buck_cntl_by_tx)) {
			battery->buck_cntl_by_tx = true;
			sec_vote(battery->chgen_vote, VOTER_WC_TX, true, SEC_BAT_CHG_MODE_BUCK_OFF);
		}

		sec_bat_wireless_vout_cntl(battery, tx_uno_vout);
		sec_bat_wireless_iout_cntl(battery, battery->pdata->tx_uno_iout_gear,
			battery->pdata->tx_mfc_iout_gear);
	}
		break;
	default: /* SS_BUDS, SS_PHONE, OTHER_DEV */
		if (battery->pdata->phm_vout_ctrl_dev & SEC_WIRELESS_PHM_VOUT_CTRL_BUDS) {
			if (battery->wc_tx_phm_mode) {
				pr_info("@Tx_Mode %s : phm on status.\n", __func__);

				sec_bat_wireless_vout_cntl(battery, WC_TX_VOUT_5000MV);
				if (is_hv_wire_type(battery->wire_status) ||
					(is_pd_wire_type(battery->wire_status) && battery->hv_pdo)) {
					pr_info("@Tx_Mode %s : change iv(9V -> 5V).\n", __func__);
					sec_bat_wpc_tx_iv(battery->iv_vote, SEC_INPUT_VOLTAGE_5V, true);
				} else {
					pr_info("@Tx_Mode %s : change iv(%dV -> 5V).\n",
						__func__, battery->pdata->tx_uno_vout);
				}
				battery->prev_tx_phm_mode = battery->wc_tx_phm_mode;
				break;
			} else {
				if (battery->prev_tx_phm_mode) {
					pr_info("@Tx_Mode %s : keep phm off status concept before tx off\n", __func__);
					break;
				}
			}
		}

		if ((battery->wire_status == SEC_BATTERY_CABLE_HV_TA_CHG_LIMIT) ||
			(is_pd_wire_type(battery->wire_status) && !battery->hv_pdo)) {
			if (battery->wc_tx_vout < tx_uno_vout) {
				sec_bat_wireless_vout_cntl(battery, tx_uno_vout);
				if (!battery->buck_cntl_by_tx) {
					battery->buck_cntl_by_tx = true;
					sec_vote(battery->chgen_vote, VOTER_WC_TX,
						true, SEC_BAT_CHG_MODE_BUCK_OFF);
				}
				sec_bat_run_wpc_tx_work(battery, 500);
				return;
			}
			pr_info("@Tx_Mode %s : change iv(5V -> 9V)\n", __func__);
			sec_bat_wpc_tx_iv(battery->iv_vote, SEC_INPUT_VOLTAGE_9V, true);
			break;
		}

		if (battery->wire_status == SEC_BATTERY_CABLE_NONE) {
			battery->tx_switch_mode = TX_SWITCH_MODE_OFF;
			battery->tx_switch_start_soc = 0;
			battery->tx_switch_mode_change = false;

			if (!battery->buck_cntl_by_tx) {
				battery->buck_cntl_by_tx = true;
				sec_vote(battery->chgen_vote, VOTER_WC_TX, true, SEC_BAT_CHG_MODE_BUCK_OFF);
			}
			sec_bat_wireless_vout_cntl(battery, tx_uno_vout);
			sec_bat_wireless_iout_cntl(battery,
					battery->pdata->tx_uno_iout, battery->pdata->tx_mfc_iout_phone);
			sec_bat_wireless_minduty_cntl(battery, battery->pdata->tx_minduty_default);
		} else if (is_hv_wire_type(battery->wire_status) ||
				(is_pd_wire_type(battery->wire_status) && battery->hv_pdo)) {
			battery->tx_switch_mode = TX_SWITCH_MODE_OFF;
			battery->tx_switch_start_soc = 0;
			battery->tx_switch_mode_change = false;

			if (battery->buck_cntl_by_tx) {
				battery->buck_cntl_by_tx = false;
				sec_vote(battery->chgen_vote, VOTER_WC_TX, false, 0);
			}
			sec_bat_wireless_iout_cntl(battery,
					battery->pdata->tx_uno_iout, battery->pdata->tx_mfc_iout_phone);
			sec_bat_wireless_minduty_cntl(battery, battery->pdata->tx_minduty_default);
		} else if (is_pd_wire_type(battery->wire_status) && battery->hv_pdo) {
			pr_info("@Tx_Mode %s: PD cable attached. HV PDO(%d)\n", __func__, battery->hv_pdo);

			battery->tx_switch_mode = TX_SWITCH_MODE_OFF;
			battery->tx_switch_start_soc = 0;
			battery->tx_switch_mode_change = false;

			if (battery->buck_cntl_by_tx) {
				battery->buck_cntl_by_tx = false;
				sec_vote(battery->chgen_vote, VOTER_WC_TX, false, 0);
			}
			sec_bat_wireless_iout_cntl(battery,
					battery->pdata->tx_uno_iout, battery->pdata->tx_mfc_iout_phone);
			sec_bat_wireless_minduty_cntl(battery, battery->pdata->tx_minduty_default);
		} else if (is_wired_type(battery->wire_status) && !is_hv_wire_type(battery->wire_status) &&
				(battery->wire_status != SEC_BATTERY_CABLE_HV_TA_CHG_LIMIT)) {
			sec_bat_tx_work_with_nv_charger(battery);
		}
		break;
	}
end_of_tx_work:
	dev_info(battery->dev, "@Tx_Mode %s End\n", __func__);
	__pm_relax(battery->wpc_tx_ws);
}

#define EN_RETRY_DELAY 100
#define EN_RETRY_CNT 20
void sec_bat_wpc_tx_en_work_content(struct sec_battery_info *battery)
{
	int wr_sts = battery->wire_status;
	int selected_pdo;
	static unsigned int cnt;

	pr_info("@Tx_Mode %s: tx %s\n", __func__,
		battery->wc_tx_enable ? "on" : "off");

	battery->tx_minduty = battery->pdata->tx_minduty_default;
	battery->tx_switch_mode = TX_SWITCH_MODE_OFF;
	battery->tx_switch_start_soc = 0;
	battery->tx_switch_mode_change = false;
	battery->tx_ping_duty = 0;

	if (battery->wc_tx_enable) {
		/* set tx event */
		sec_bat_set_tx_event(battery, BATT_TX_EVENT_WIRELESS_TX_STATUS,
			(BATT_TX_EVENT_WIRELESS_TX_STATUS | BATT_TX_EVENT_WIRELESS_TX_RETRY));

		if (is_pd_wire_type(wr_sts)) {
			sec_pd_get_selected_pdo(&selected_pdo);
			if (selected_pdo == battery->sink_status.current_pdo_num) {
				if (battery->sink_status.power_list[battery->sink_status.current_pdo_num].max_voltage
					== SEC_INPUT_VOLTAGE_5V) {
					pr_info("@Tx_Mode %s: 5V PDO. Tx Start\n", __func__);
					sec_bat_wpc_tx_iv(battery->iv_vote, SEC_INPUT_VOLTAGE_5V, false);
					sec_bat_run_wpc_tx_work(battery, 0);
				} else {
					pr_info("@Tx_Mode %s: Wait to decrease 5V (%d / %d)\n",
						__func__, ++cnt, EN_RETRY_CNT);
					sec_bat_wpc_tx_iv(battery->iv_vote, SEC_INPUT_VOLTAGE_5V, false);
					__pm_stay_awake(battery->wpc_tx_en_ws);
					queue_delayed_work(battery->monitor_wqueue,
						&battery->wpc_tx_en_work, msecs_to_jiffies(EN_RETRY_DELAY));
					return;
				}
			} else {
				if (cnt >= EN_RETRY_CNT) {
					pr_info("@Tx_Mode %s: No response for 5V. Error case\n", __func__);
					cnt = 0;
				} else {
					pr_info("@Tx_Mode %s: Wait to decrease 5V (%d / %d)\n",
						__func__, ++cnt, EN_RETRY_CNT);
					__pm_stay_awake(battery->wpc_tx_en_ws);
					queue_delayed_work(battery->monitor_wqueue,
						&battery->wpc_tx_en_work, msecs_to_jiffies(EN_RETRY_DELAY));
					return;
				}
			}
		} else if (is_hv_wire_type(wr_sts)) {
			if (cnt >= EN_RETRY_CNT) {
				pr_info("@Tx_Mode %s: No response for 5V. Error case\n", __func__);
				cnt = 0;
			} else {
				pr_info("@Tx_Mode %s: Wait to decrease 5V (%d / %d)\n",
					__func__, ++cnt, EN_RETRY_CNT);
				sec_bat_wpc_tx_iv(battery->iv_vote, SEC_INPUT_VOLTAGE_5V, false);
				__pm_stay_awake(battery->wpc_tx_en_ws);
				queue_delayed_work(battery->monitor_wqueue,
					&battery->wpc_tx_en_work, msecs_to_jiffies(EN_RETRY_DELAY));
				return;
			}
		} else {
			pr_info("@Tx_Mode %s: 5V AFC. Tx Start\n", __func__);
			sec_bat_wpc_tx_iv(battery->iv_vote, SEC_INPUT_VOLTAGE_5V, false);
			sec_bat_run_wpc_tx_work(battery, 0);
		}

		pr_info("@Tx_Mode %s: TX Power Calculation start.\n", __func__);
		queue_delayed_work(battery->monitor_wqueue,
				&battery->wpc_txpower_calc_work, 0);
	} else {
		cancel_delayed_work(&battery->wpc_tx_work);
		cancel_delayed_work(&battery->wpc_txpower_calc_work);
		__pm_relax(battery->wpc_tx_ws);

		sec_bat_wireless_minduty_cntl(battery, battery->pdata->tx_minduty_default);
		battery->wc_rx_type = NO_DEV;
		battery->wc_rx_connected = false;
		battery->tx_uno_iout = 0;
		battery->tx_mfc_iout = 0;
		battery->buck_cntl_by_tx = false;
		sec_bat_wireless_uno_cntl(battery, false);
		sec_bat_wireless_vout_cntl(battery, WC_TX_VOUT_5000MV);
		sec_vote(battery->chgen_vote, VOTER_WC_TX, false, 0);
		sec_vote(battery->fcc_vote, VOTER_WC_TX, false, 0);
		sec_vote(battery->input_vote, VOTER_WC_TX, false, 0);
		/* for 1) not supporting DC and charging bia PD20/DC on Tx */
		/*     2) supporting DC and charging bia PD20 on Tx */
		/*	   3) During retrying, maintain iv_vote */
		if (battery->tx_retry_case == SEC_BAT_TX_RETRY_NONE)
			sec_vote(battery->iv_vote, VOTER_WC_TX, false, 0);
		cnt = 0;
	}

	pr_info("@Tx_Mode %s Done\n", __func__);
	__pm_relax(battery->wpc_tx_en_ws);
}

void sec_wireless_set_tx_enable(struct sec_battery_info *battery, bool wc_tx_enable)
{
	int wr_sts = battery->wire_status;
	pr_info("@Tx_Mode %s: TX Power enable ? (%d)\n", __func__, wc_tx_enable);

	if (battery->pdata->tx_5v_disable && wc_tx_enable && is_5v_charger(battery, wr_sts)) {
		pr_info("@Tx_Mode %s : 5V charger(%d) connected, do not turn on TX\n", __func__, wr_sts);
		sec_bat_set_tx_event(battery, BATT_TX_EVENT_WIRELESS_TX_5V_TA, BATT_TX_EVENT_WIRELESS_TX_5V_TA);
		return;
	}

	/* temporary code */
	sb_tx_init(battery, battery->pdata->wireless_charger_name);
	sb_tx_init_aov();

	battery->wc_tx_enable = wc_tx_enable;
	battery->wc_tx_phm_mode = false;
	battery->prev_tx_phm_mode = false;

	/* FPDO DC concept */
	if (wr_sts == SEC_BATTERY_CABLE_FPDO_DC && battery->wc_tx_enable) {
		union power_supply_propval value = {0, };

		value.intval = 0;
		psy_do_property(battery->pdata->charger_name, set,
				POWER_SUPPLY_EXT_PROP_REFRESH_CHARGING_SOURCE, value);

	}

	cancel_delayed_work(&battery->wpc_tx_en_work);
	__pm_stay_awake(battery->wpc_tx_en_ws);
	queue_delayed_work(battery->monitor_wqueue,
		&battery->wpc_tx_en_work, 0);
}
EXPORT_SYMBOL(sec_wireless_set_tx_enable);