/*
 * s2mc501_direct_charger.c - S2MC501 Charger Driver
 *
 * Copyright (C) 2019 Samsung Electronics Co.Ltd
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 */
#include <linux/power/s2mc501_direct_charger.h>
#include <linux/power/s2m_chg_manager.h>
#include <linux/power_supply.h>
#include <linux/delay.h>
#include <linux/time.h>
#include <linux/ifconn/ifconn_notifier.h>

#ifdef CONFIG_USB_HOST_NOTIFY
#include <linux/usb_notify.h>
#endif

static char *s2mc501_supplied_to[] = {
	"battery",
};

static enum power_supply_property s2mc501_dc_props[] = {
	POWER_SUPPLY_PROP_ONLINE,
};

extern int s2mc501_pmeter_init(struct s2mc501_dc_data *charger);
static int s2mc501_dc_is_enable(struct s2mc501_dc_data *charger);
static void s2mc501_dc_enable(struct s2mc501_dc_data *charger, int onoff);
static void s2mc501_dc_pm_enable(struct s2mc501_dc_data *charger);
static int s2mc501_dc_get_float_voltage(struct s2mc501_dc_data *charger);
static void s2mc501_dc_set_float_voltage(struct s2mc501_dc_data *charger, int float_voltage);
static int s2mc501_dc_get_input_current(struct s2mc501_dc_data *charger);
static void s2mc501_dc_set_input_current(struct s2mc501_dc_data *charger, int input_current);
//static void s2mc501_dc_set_charging_current(struct s2mc501_dc_data *charger,
//				int charging_current, s2mc501_dc_cc_mode mode);
static int s2mc501_dc_irq_clear(struct s2mc501_dc_data *charger);
static void s2mc501_dc_state_manager(struct s2mc501_dc_data *charger, s2mc501_dc_trans_t trans);
static int s2mc501_dc_get_pmeter(struct s2mc501_dc_data *charger, s2mc501_pmeter_id_t id);
//static void s2mc501_dc_forced_enable(struct s2mc501_dc_data *charger, int onoff);
//static void s2mc501_dc_set_target_curr(struct s2mc501_dc_data *charger);
//static int s2mc501_dc_send_fenced_pps(struct s2mc501_dc_data *charger);
//static int s2mc501_dc_get_fg_value(struct s2mc501_dc_data *charger, enum power_supply_property prop);
static void s2mc501_dc_set_irq_unmask(struct s2mc501_dc_data *charger);
static void s2mc501_dc_state_trans_enqueue(struct s2mc501_dc_data *charger, s2mc501_dc_trans_t trans);
//static void s2mc501_dc_set_sc_prop(struct s2mc501_dc_data *charger, enum power_supply_property psp, int val);
//static int s2mc501_dc_send_verify(struct s2mc501_dc_data *charger);
//static void s2mc501_dc_refresh_auto_pps(struct s2mc501_dc_data *charger, unsigned int vol, unsigned int iin);
//static void s2mc501_dc_vchgin_compensation(struct s2mc501_dc_data *charger);

int s2mc501_read_reg(struct i2c_client *i2c, u8 reg, u8 *dest)
{
	struct s2mc501_dc_data *s2mc501 = i2c_get_clientdata(i2c);
	int ret;

	mutex_lock(&s2mc501->i2c_lock);
	ret = i2c_smbus_read_byte_data(i2c, reg);
	mutex_unlock(&s2mc501->i2c_lock);
	if (ret < 0) {
		pr_err("%s : reg(0x%x), ret(%d)\n", __func__, reg, ret);
		return ret;
	}

	ret &= 0xff;
	*dest = ret;
	return 0;
}
EXPORT_SYMBOL_GPL(s2mc501_read_reg);

int s2mc501_write_reg(struct i2c_client *i2c, u8 reg, u8 value)
{
	struct s2mc501_dc_data *s2mc501 = i2c_get_clientdata(i2c);
	int ret;

	mutex_lock(&s2mc501->i2c_lock);
	ret = i2c_smbus_write_byte_data(i2c, reg, value);
	mutex_unlock(&s2mc501->i2c_lock);
	if (ret < 0)
		pr_err("%s reg(0x%x), ret(%d)\n", __func__, reg, ret);

	return ret;
}
EXPORT_SYMBOL_GPL(s2mc501_write_reg);

int s2mc501_update_reg(struct i2c_client *i2c, u8 reg, u8 val, u8 mask)
{
	struct s2mc501_dc_data *s2mc501 = i2c_get_clientdata(i2c);
	int ret;
	u8 old_val, new_val;

	mutex_lock(&s2mc501->i2c_lock);
	ret = i2c_smbus_read_byte_data(i2c, reg);
	if (ret >= 0) {
		old_val = ret & 0xff;
		new_val = (val & mask) | (old_val & (~mask));
		ret = i2c_smbus_write_byte_data(i2c, reg, new_val);
	}
	mutex_unlock(&s2mc501->i2c_lock);
	return ret;
}
EXPORT_SYMBOL_GPL(s2mc501_update_reg);

static const char *pmeter_to_str(s2mc501_pmeter_id_t n)
{
	char *ret;
	switch (n) {
	CONV_STR(PMETER_ID_VDCIN, ret);
	CONV_STR(PMETER_ID_VOUT, ret);
	CONV_STR(PMETER_ID_VCELL, ret);
	CONV_STR(PMETER_ID_IIN, ret);
	CONV_STR(PMETER_ID_IINREV, ret);
	CONV_STR(PMETER_ID_TDIE, ret);
	default:
		return "invalid";
	}
	return ret;
}

static const char *state_to_str(s2mc501_dc_state_t n)
{
	char *ret;
	switch (n) {
	CONV_STR(DC_STATE_OFF, ret);
	CONV_STR(DC_STATE_CHECK_VBAT, ret);
	CONV_STR(DC_STATE_PRESET, ret);
//	CONV_STR(DC_STATE_START_CC, ret);
	CONV_STR(DC_STATE_CC, ret);
//	CONV_STR(DC_STATE_SLEEP_CC, ret);
//	CONV_STR(DC_STATE_ADJUSTED_CC, ret);
	CONV_STR(DC_STATE_CV, ret);
//	CONV_STR(DC_STATE_WAKEUP_CC, ret);
	CONV_STR(DC_STATE_DONE, ret);
	default:
		return "invalid";
	}
	return ret;
}

static const char *trans_to_str(s2mc501_dc_trans_t n)
{
	char *ret;
	switch (n) {
	CONV_STR(DC_TRANS_INVALID, ret);
	CONV_STR(DC_TRANS_NO_COND, ret);
	CONV_STR(DC_TRANS_VBATT_RETRY, ret);
	CONV_STR(DC_TRANS_WAKEUP_DONE, ret);
	CONV_STR(DC_TRANS_RAMPUP, ret);
	CONV_STR(DC_TRANS_RAMPUP_FINISHED, ret);
	CONV_STR(DC_TRANS_CHG_ENABLED, ret);
	CONV_STR(DC_TRANS_BATTERY_OK, ret);
	CONV_STR(DC_TRANS_BATTERY_NG, ret);
	CONV_STR(DC_TRANS_CHGIN_OKB_INT, ret);
	CONV_STR(DC_TRANS_CC_WAKEUP, ret);
	CONV_STR(DC_TRANS_BAT_OKB_INT, ret);
	CONV_STR(DC_TRANS_NORMAL_CHG_INT, ret);
	CONV_STR(DC_TRANS_DC_DONE_INT, ret);
	CONV_STR(DC_TRANS_CC_STABLED, ret);
	CONV_STR(DC_TRANS_DETACH, ret);
	CONV_STR(DC_TRANS_FAIL_INT, ret);
	CONV_STR(DC_TRANS_FLOAT_VBATT, ret);
	CONV_STR(DC_TRANS_RAMPUP_OVER_VBATT, ret);
	CONV_STR(DC_TRANS_RAMPUP_OVER_CURRENT, ret);
	CONV_STR(DC_TRANS_SET_CURRENT_MAX, ret);
	CONV_STR(DC_TRANS_TOP_OFF_CURRENT, ret);
	CONV_STR(DC_TRANS_DC_OFF_INT, ret);
	default:
		return "invalid";
	}
	return ret;
}

static const char *prop_to_str(enum power_supply_property n)
{
	char *ret;
	switch (n) {
	CONV_STR(POWER_SUPPLY_PROP_VOLTAGE_AVG, ret);
	CONV_STR(POWER_SUPPLY_PROP_CURRENT_AVG, ret);
	CONV_STR(POWER_SUPPLY_PROP_CURRENT_NOW, ret);
	CONV_STR(POWER_SUPPLY_PROP_CAPACITY, ret);
	default:
		return "invalid";
	}
	return ret;
}

static void s2mc501_dc_test_read(struct i2c_client *i2c)
{
	static int reg_list[] = {
		0x00, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10,
		0x11, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x2A, 0x30, 0x3A,
		0x3B, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
		0x5A, 0x5B, 0x5C, 0x70, 0x71, 0xF5
	};

	u8 data = 0;
	char str[1016] = {0,};
	int i = 0, reg_list_size = 0;

	reg_list_size = ARRAY_SIZE(reg_list);
	for (i = 0; i < reg_list_size; i++) {
                s2mc501_read_reg(i2c, reg_list[i], &data);
                sprintf(str+strlen(str), "0x%02x:0x%02x, ", reg_list[i], data);
        }

	/* print buffer */
	pr_info("[DC]%s: %s\n", __func__, str);

}

static int s2mc501_dc_is_enable(struct s2mc501_dc_data *charger)
{
	/* TODO : DC status? check */
	u8 data;
	int ret;

	ret = s2mc501_read_reg(charger->i2c, S2MC501_DC_ENABLE, &data);
	if (ret < 0)
		return ret;

	return (data & DC_EN_MASK) ? 1 : 0;
}

static void s2mc501_dc_enable(struct s2mc501_dc_data *charger, int onoff)
{
	if (onoff > 0) {
		pr_info("%s, direct charger enable\n", __func__);
		__pm_stay_awake(charger->ws);
		charger->is_charging = true;
		s2mc501_update_reg(charger->i2c, S2MC501_DC_ENABLE, DC_EN_MASK, DC_EN_MASK);
	} else {
		pr_info("%s, direct charger disable\n", __func__);
		s2mc501_update_reg(charger->i2c, S2MC501_DC_ENABLE, 0, DC_EN_MASK);
		charger->is_charging = false;
	}
}

static void s2mc501_dc_pm_enable(struct s2mc501_dc_data *charger)
{
#if 0
	union power_supply_propval value;

        value.intval = PM_TYPE_VCHGIN | PM_TYPE_VBAT | PM_TYPE_ICHGIN | PM_TYPE_TDIE |
                PM_TYPE_VWCIN | PM_TYPE_IWCIN | PM_TYPE_VBYP | PM_TYPE_VSYS |
                PM_TYPE_VCC1 | PM_TYPE_VCC2 | PM_TYPE_ICHGIN | PM_TYPE_ITX;
	psy_do_property(charger->pdata->pm_name, set,
				POWER_SUPPLY_PROP_CO_ENABLE, value);
#endif
}
#if 0
static int s2mc501_dc_get_topoff_current(struct s2mc501_dc_data *charger)
{
	u8 data = 0x00;
	int ret, topoff_current = 0;

	ret = s2mc501_read_reg(charger->i2c, S2MC501_DC_CTRL15, &data);
	if (ret < 0)
		return ret;
	data = (data & DC_TOPOFF_MASK) >> DC_TOPOFF_SHIFT;

	if (data > 0x0F)
		data = 0x0F;

	topoff_current = data * 100 + 500;
	pr_info("%s, topoff_current : %d(0x%2x)\n", __func__, topoff_current, data);

	return topoff_current;
}

static void s2mc501_dc_set_topoff_current(struct s2mc501_dc_data *charger, int topoff_current)
{
	u8 data = 0x00;

	if (topoff_current <= 500)
		data = 0x00;
	else if (topoff_current > 500 && topoff_current <= 2000)
		data = (topoff_current - 500) / 100;
	else
		data = 0x0F;

	pr_info("%s, topoff_current : %d(0x%2x)\n", __func__, topoff_current, data);

	s2mc501_update_reg(charger->i2c, S2MC501_DC_CTRL15,
				data << DC_TOPOFF_SHIFT, DC_TOPOFF_MASK);
}
#endif
static int s2mc501_dc_get_float_voltage(struct s2mc501_dc_data *charger)
{
	u8 data = 0x00;
	int ret, float_voltage = 0;

	ret = s2mc501_read_reg(charger->i2c, S2MC501_DC_CTRL1, &data);
	if (ret < 0)
		return data;

	data = data & SET_CV_MASK;

	if (data >= 0x7F)
		float_voltage = 4870;
	else if (data <= 0x00)
		float_voltage = 3600;
	else
		float_voltage = data * 10 + 3600;

	pr_info("%s, float_voltage : %d(0x%2x)\n", __func__, float_voltage, data);

	return float_voltage;
}

static void s2mc501_dc_set_float_voltage(struct s2mc501_dc_data *charger, int float_voltage)
{
	u8 data = 0x00;

	if (float_voltage <= 3600)
		data = 0x00;
	else if (float_voltage > 3600 && float_voltage <= 4870)
		data = (float_voltage - 3600) / 10;
	else
		data = 0x7F;

	pr_info("%s, float_voltage : %d(0x%2x)\n", __func__, float_voltage, data);
	charger->floatVol = float_voltage;

	s2mc501_update_reg(charger->i2c, S2MC501_DC_CTRL1,
				data << SET_CV_SHIFT, SET_CV_MASK);
}

static int s2mc501_dc_get_input_current(struct s2mc501_dc_data *charger)
{
	u8 data = 0x00;
	int ret, input_current = 0;

	ret = s2mc501_read_reg(charger->i2c, S2MC501_DC_CTRL0, &data);
	if (ret < 0)
		return data;
	data = data & DC_SET_CHGIN_ICHG_MASK;

	input_current = data * 50 + 50;

	pr_info("%s,input_current : %d(0x%2x)\n", __func__, input_current, data);
	return input_current;
}

static void s2mc501_dc_set_input_current(struct s2mc501_dc_data *charger, int input_current)
{
	u8 data = 0x00;
	data = (input_current - 50) / 50;
	if (data >= 0x3F)
		data = 0x3F;
	pr_info("%s, input_current : %d(0x%2x)\n", __func__, input_current, data);

	s2mc501_update_reg(charger->i2c, S2MC501_DC_CTRL0,
				data << DC_SET_CHGIN_ICHG_SHIFT, DC_SET_CHGIN_ICHG_MASK);
}

static int s2mc501_dc_get_rcp(struct s2mc501_dc_data *charger)
{
	u8 data = 0x00;
	int ret, rcp = 0;

	ret = s2mc501_read_reg(charger->i2c, S2MC501_DC_CTRL2, &data);
	if (ret < 0)
		return data;
	data = data & DC_RCP_MASK;

	if (data == 0x00)
		rcp = 100;
	else if (data <= 0x07)
		rcp = (data * 500) + 500;

	pr_info("%s, RCP : %dmA(0x%2x)\n", __func__, rcp, data);
	return rcp;
}

static void s2mc501_dc_set_rcp(struct s2mc501_dc_data *charger, int r_current)
{
	u8 data = 0x00;

	if (r_current <= 100)
		data = 0x00;
	else if (r_current > 4000)
		data = 0x07;
	else
		data = (r_current - 500) / 500 ;

	pr_info("%s, RCP : %d(0x%2x)\n", __func__, r_current, data);

	s2mc501_update_reg(charger->i2c, S2MC501_DC_CTRL2,
				data << DC_RCP_SHIFT, DC_RCP_MASK);
}

static void s2mc501_dc_set_irq_unmask(struct s2mc501_dc_data *charger)
{
	/* TODO : IRQ unmask */
	s2mc501_write_reg(charger->i2c, 0x04, 0x00);
	s2mc501_write_reg(charger->i2c, 0x05, 0x00);
	s2mc501_write_reg(charger->i2c, 0x06, 0x00);
}

static int s2mc501_dc_get_property(struct power_supply *psy,
		enum power_supply_property psp,
		union power_supply_propval *val)
{
	struct s2mc501_dc_data *charger = power_supply_get_drvdata(psy);
	enum s2m_power_supply_property s2m_psp = (enum s2m_power_supply_property) psp;
	union power_supply_propval value;
	int ret = 0;

	switch ((int)psp) {
	case POWER_SUPPLY_PROP_ONLINE:
		val->intval = charger->is_charging;
		break;
	case POWER_SUPPLY_PROP_STATUS:
		val->intval = charger->dc_chg_status;
		break;
	case POWER_SUPPLY_PROP_HEALTH:
		/* TODO : health check */
		pr_info("%s: health check & wdt clear\n", __func__);
		//s2mc501_dc_wdt_clear(charger);
//		if (charger->ps_health == POWER_SUPPLY_HEALTH_UNKNOWN)
//		charger->ps_health = POWER_SUPPLY_HEALTH_GOOD;
		val->intval = charger->ps_health;
		break;
	case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
		val->intval = s2mc501_dc_get_input_current(charger);
		break;
	case POWER_SUPPLY_PROP_TEMP:
		/* FG temp? PM temp? */
		if (!charger->psy_fg)
			return -EINVAL;
		ret = power_supply_get_property(charger->psy_fg, POWER_SUPPLY_PROP_TEMP, &value);
		if (ret < 0)
			pr_err("%s: Fail to execute property\n", __func__);

		val->intval = value.intval;
		break;
	case POWER_SUPPLY_PROP_CURRENT_MAX:
		val->intval = charger->step_iin_ma;
		break;
	case POWER_SUPPLY_PROP_CURRENT_NOW:
		val->intval = charger->step_iin_ma * 2;
		break;
	case POWER_SUPPLY_S2M_PROP_MIN ... POWER_SUPPLY_S2M_PROP_MAX:
		switch (s2m_psp) {
		case POWER_SUPPLY_S2M_PROP_CHARGING_ENABLED:
			val->intval = s2mc501_dc_is_enable(charger);
			break;
		default:
			ret = -ENODATA;
		}
		return ret;
	default:
		return -EINVAL;
	}

	return 0;
}

static int s2mc501_dc_set_property(struct power_supply *psy,
		enum power_supply_property psp,
		const union power_supply_propval *val)
{
	struct s2mc501_dc_data *charger = power_supply_get_drvdata(psy);
	enum s2m_power_supply_property s2m_psp = (enum s2m_power_supply_property) psp;
	union power_supply_propval value;
	int ret = 0;

	switch ((int)psp) {
	case POWER_SUPPLY_PROP_ONLINE:
		charger->cable_type = val->intval;
		break;
	case POWER_SUPPLY_PROP_CURRENT_MAX:
		/*
		 * todo :
		 * need to change top off current
		 * 1000 -> 500 mA by IIN.
		 */
		if (val->intval <= 1000)
			charger->step_iin_ma = 1050;
		else
			charger->step_iin_ma = val->intval;
		pr_info("%s, set iin : %d", __func__, charger->step_iin_ma);
		s2mc501_dc_state_trans_enqueue(charger, DC_TRANS_SET_CURRENT_MAX);
		break;
	case POWER_SUPPLY_PROP_CURRENT_AVG:
	case POWER_SUPPLY_PROP_CURRENT_NOW:
		/* Not Taking charging current orders from platform */
		//charger->charging_current = val->intval;
		//s2mc501_dc_set_charging_current(charger, val->intval);
		break;
	case POWER_SUPPLY_S2M_PROP_MIN ... POWER_SUPPLY_S2M_PROP_MAX:
		switch (s2m_psp) {
		case POWER_SUPPLY_S2M_PROP_CHARGING_ENABLED:
			if (val->intval == S2M_BAT_CHG_MODE_CHARGING_OFF) {
				charger->is_charging = false;
				if (charger->dc_state != DC_STATE_OFF)
					s2mc501_dc_state_manager(charger, DC_TRANS_DETACH);
			} else {
				if (charger->cable_type && (!charger->is_charging)) {
					charger->is_charging = true;
					charger->ps_health = POWER_SUPPLY_HEALTH_GOOD;
					s2mc501_dc_state_manager(charger, DC_TRANS_CHG_ENABLED);
				}
			}
			value.intval = charger->is_charging;
			power_supply_set_property(charger->psy_fg,
                (enum power_supply_property)s2m_psp, &value);
			break;
		default:
			ret = -ENODATA;
		}
		return ret;
	default:
		return -EINVAL;
	}

	return 0;
}

static void s2mc501_dc_cal_target_value(struct s2mc501_dc_data *charger)
{
	unsigned int vbat;
	unsigned int temp;
//	union power_supply_propval value;

//	power_supply_get_property(charger->psy_fg, POWER_SUPPLY_PROP_VOLTAGE_NOW, &value);
//	vbat = value.intval;

	vbat = s2mc501_dc_get_pmeter(charger, PMETER_ID_VOUT);

	temp = vbat * 2;
	charger->ppsVol = ((temp / DC_TA_VOL_STEP_MV) * DC_TA_VOL_STEP_MV) + 350;

//	temp = vbat * 2 * (1031);
//	charger->ppsVol = (((temp / 1000) / DC_TA_VOL_STEP_MV) * DC_TA_VOL_STEP_MV) + 200 + (charger->vchgin_okb_retry * DC_TA_VOL_STEP_MV);

	if (charger->ppsVol > charger->pd_data->taMaxVol) {
		charger->ppsVol = charger->pd_data->taMaxVol;
	}

	pr_info("%s ppsVol : %d\n", __func__, charger->ppsVol);
}

static int s2mc501_dc_get_fg_value(struct s2mc501_dc_data *charger, enum power_supply_property prop)
{
	union power_supply_propval value;
	u32 get = 0;
	int ret;

	if (!charger->psy_fg)
		return -EINVAL;
	ret = power_supply_get_property(charger->psy_fg, prop, &value);
	if (ret < 0)
		pr_err("%s: Fail to execute property\n", __func__);

	get = value.intval;
	pr_info("%s, %s : (%d)\n", __func__, prop_to_str(prop), get);
	return get;
}

static int s2mc501_dc_get_pmeter(struct s2mc501_dc_data *charger, s2mc501_pmeter_id_t id)
{
	struct power_supply *psy_pm;
	union power_supply_propval value;
	int ret = 0;

	psy_pm = power_supply_get_by_name(charger->pdata->pm_name);
	if (!psy_pm)
		return -EINVAL;

	switch (id) {
		case PMETER_ID_VDCIN:
			ret = power_supply_get_property(psy_pm, (enum power_supply_property)POWER_SUPPLY_S2M_PROP_VDCIN, &value);
			break;
		case PMETER_ID_VOUT:
			ret = power_supply_get_property(psy_pm, (enum power_supply_property)POWER_SUPPLY_S2M_PROP_VOUT, &value);
			break;
		case PMETER_ID_VCELL:
			ret = power_supply_get_property(psy_pm, (enum power_supply_property)POWER_SUPPLY_S2M_PROP_VCELL, &value);
			break;
		case PMETER_ID_IIN:
			ret = power_supply_get_property(psy_pm, (enum power_supply_property)POWER_SUPPLY_S2M_PROP_IIN, &value);
			break;
		case PMETER_ID_IINREV:
			ret = power_supply_get_property(psy_pm, (enum power_supply_property)POWER_SUPPLY_S2M_PROP_IINREV, &value);
			break;
		case PMETER_ID_TDIE:
			ret = power_supply_get_property(psy_pm, (enum power_supply_property)POWER_SUPPLY_S2M_PROP_TDIE, &value);
			break;
		default:
			break;
	}

	if (ret < 0) {
		pr_err("%s: fail to set power_suppy pmeter property(%d)\n",
				__func__, ret);
	} else {
		charger->pmeter[id] = value.intval;
		pr_info("%s pm[%s] : %d\n", __func__, pmeter_to_str(id), value.intval);
		return value.intval;
	}
	return -1;
}

#if 0
static void s2mc501_dc_vchgin_compensation(struct s2mc501_dc_data *charger)
{
	int vdiff;
	int vchgin = s2mc501_dc_get_pmeter(charger, PMETER_ID_VCHGIN);

	pr_info("%s enter, pps vol : %d, vchgin : %d\n", __func__, charger->ppsVol, vchgin);
	if (vchgin > charger->ppsVol + 150) {
		vdiff = ((vchgin - charger->ppsVol) / DC_TA_VOL_STEP_MV) * DC_TA_VOL_STEP_MV;
		charger->ppsVol -= vdiff;
		s2mc501_dc_send_verify(charger);
	} else if (vchgin < charger->ppsVol - 150) {
		vdiff = ((charger->ppsVol - vchgin) / DC_TA_VOL_STEP_MV) * DC_TA_VOL_STEP_MV;
		charger->ppsVol += vdiff;
		s2mc501_dc_send_verify(charger);
	} else {
		pr_info("%s ok, pps vol : %d, vchgin : %d\n", __func__, charger->ppsVol, vchgin);
	}
	s2mc501_dc_get_pmeter(charger, PMETER_ID_VCHGIN);
}

static void s2mc501_dc_set_target_curr(struct s2mc501_dc_data *charger)
{
	if (charger->step_iin_ma > charger->pd_data->taMaxCur)
		charger->step_iin_ma = charger->pd_data->taMaxCur;

	pr_info("%s step_iin_ma : %d\n", __func__, charger->step_iin_ma);
	charger->targetIIN = ((charger->step_iin_ma / DC_TA_CURR_STEP_MA) * DC_TA_CURR_STEP_MA) + DC_TA_CURR_STEP_MA;
	s2mc501_dc_set_charging_current(charger, (charger->targetIIN * 2), S2MC501_DC_MODE_TA_CC);
	return;
}

static void s2mc501_dc_refresh_auto_pps(struct s2mc501_dc_data *charger, unsigned int vol, unsigned int iin)
{
	mutex_lock(&charger->auto_pps_mutex);
	charger->ppsVol = vol;
	charger->targetIIN = iin;

	pr_info("%s vol : %d, iin : %d\n", __func__, vol, iin);
	sec_pps_enable(charger->pd_data->pdo_pos,
		charger->ppsVol, charger->targetIIN, S2MC501_DC_DISABLE);

	if (s2mc501_dc_delay(charger, 500))
		goto CANCEL_AUTO_PPS;

	charger->ppsVol = vol;
	charger->targetIIN = iin;
	s2mc501_dc_send_fenced_pps(charger);

	if (s2mc501_dc_delay(charger, 500))
		goto CANCEL_AUTO_PPS;

	charger->is_autopps_disabled = false;
	sec_pps_enable(charger->pd_data->pdo_pos,
		charger->ppsVol, charger->targetIIN, S2MC501_DC_EN);
CANCEL_AUTO_PPS:
	mutex_unlock(&charger->auto_pps_mutex);
}

#endif
#define DC_THRESH	1050


static void s2mc501_dc_platform_state_update(struct s2mc501_dc_data *charger)
{
        union power_supply_propval value;
        struct power_supply *psy;
        int state = -1, ret;

        psy = power_supply_get_by_name("dc-manager");
        if (!psy) {
                pr_err("%s, can't access power_supply", __func__);
                return;
        }
        switch (charger->dc_state) {
        case DC_STATE_OFF:
                state = S2M_DIRECT_CHG_MODE_OFF;
                break;
        case DC_STATE_CHECK_VBAT:
                state = S2M_DIRECT_CHG_MODE_CHECK_VBAT;
                break;
        case DC_STATE_PRESET:
                state = S2M_DIRECT_CHG_MODE_PRESET;
                break;
        case DC_STATE_CC:
		case DC_STATE_CV:
                state = S2M_DIRECT_CHG_MODE_ON;
				break;
        case DC_STATE_DONE:
                state = S2M_DIRECT_CHG_MODE_DONE;
                break;
        default:
                break;
        }

        if (state < 0) {
                pr_err("%s: Invalid state report.\n", __func__);
                return;
        }

        pr_info("%s, updated state : %d(%d)\n", __func__, state, charger->dc_state);
        ret = power_supply_get_property(psy, (enum power_supply_property)POWER_SUPPLY_S2M_PROP_DIRECT_CHARGER_MODE, &value);
        if (ret < 0)
                pr_err("%s: Fail to execute property\n", __func__);

        if (value.intval != state) {
                value.intval = state;
                ret = power_supply_set_property(psy,
                        (enum power_supply_property)POWER_SUPPLY_S2M_PROP_DIRECT_CHARGER_MODE, &value);
        }

}

static void s2mc501_dc_state_manager(struct s2mc501_dc_data *charger, s2mc501_dc_trans_t trans)
{
	s2mc501_dc_state_t next_state = DC_STATE_OFF;
	mutex_lock(&charger->dc_state_mutex);
	__pm_stay_awake(charger->state_manager_ws);

	pr_info("%s: %s --> %s", __func__,
		state_to_str(charger->dc_state), trans_to_str(trans));

	if (trans == DC_TRANS_DETACH || trans == DC_TRANS_FAIL_INT || trans == DC_TRANS_DC_OFF_INT) {
		if (charger->dc_state != DC_STATE_OFF) {
			next_state = DC_STATE_OFF;
			goto HNDL_DC_OFF;
		} else {
			goto SKIP_HNDL_DC_OFF;
		}
	}

	if (trans == DC_TRANS_DC_DONE_INT || trans == DC_TRANS_TOP_OFF_CURRENT) {
		if (charger->dc_state != DC_STATE_DONE) {
			next_state = DC_STATE_DONE;
			goto HNDL_DC_OFF;
		} else {
			goto SKIP_HNDL_DC_OFF;
		}
	}

	switch (charger->dc_state) {
	case DC_STATE_OFF:
		if (trans == DC_TRANS_CHG_ENABLED)
			next_state = DC_STATE_CHECK_VBAT;
		else
			goto ERR;
		break;
	case DC_STATE_CHECK_VBAT:
		if (trans == DC_TRANS_BATTERY_OK)
			next_state = DC_STATE_PRESET;
		else if (trans == DC_TRANS_BATTERY_NG)
			next_state = DC_STATE_CHECK_VBAT;
		else
			goto ERR;
		break;
	case DC_STATE_PRESET:
		if (trans == DC_TRANS_NORMAL_CHG_INT)
			next_state = DC_STATE_CC;
		else if (trans == DC_TRANS_BAT_OKB_INT)
			next_state = DC_STATE_CHECK_VBAT;
		else if (trans == DC_TRANS_CHGIN_OKB_INT)
			next_state = DC_STATE_CHECK_VBAT;
		else
			goto ERR;
		break;
	case DC_STATE_CC:
		if (trans == DC_TRANS_FLOAT_VBATT)
			next_state = DC_STATE_CV;
		else
			goto ERR;
		break;
	case DC_STATE_CV:
		if (trans == DC_TRANS_SET_CURRENT_MAX)
			next_state = DC_STATE_SLEEP_CC;
		else
			goto ERR;
		break;
	case DC_STATE_DONE:
		break;
	default:
		break;
	}

HNDL_DC_OFF:
	pr_info("%s: %s --> %s --> %s", __func__,
		state_to_str(charger->dc_state), trans_to_str(trans),
		state_to_str(next_state));

	/* Trigger state function */
	charger->dc_state = next_state;

	/* State update */
	schedule_delayed_work(&charger->update_wqueue, 0);

	charger->dc_state_fp[next_state]((void *)charger);
	__pm_relax(charger->state_manager_ws);
	mutex_unlock(&charger->dc_state_mutex);

	return;

SKIP_HNDL_DC_OFF:
	pr_info("%s: %s --> %s --> %s", __func__,
		state_to_str(charger->dc_state), trans_to_str(trans),
		state_to_str(next_state));

	/* Trigger state function */
	charger->dc_state = next_state;

	/* State update */
	schedule_delayed_work(&charger->update_wqueue, 0);

	msleep(50);
	__pm_relax(charger->state_manager_ws);
	mutex_unlock(&charger->dc_state_mutex);

	return;

ERR:
	pr_err("%s err occured, state now : %s\n", __func__,
		state_to_str(charger->dc_state));
	__pm_relax(charger->state_manager_ws);
	mutex_unlock(&charger->dc_state_mutex);

	return;
}

static void s2mc501_dc_state_trans_enqueue(struct s2mc501_dc_data *charger, s2mc501_dc_trans_t trans)
{
	mutex_lock(&charger->trans_mutex);
	charger->dc_trans = trans;
	schedule_delayed_work(&charger->state_manager_wqueue, msecs_to_jiffies(0));
	msleep(50);
	mutex_unlock(&charger->trans_mutex);
}

static void s2mc501_dc_state_check_vbat(void *data)
{
	struct s2mc501_dc_data *charger = (struct s2mc501_dc_data *)data;
	unsigned int vbat, soc, vcell;

	soc = s2mc501_dc_get_fg_value(charger, POWER_SUPPLY_PROP_CAPACITY);
	vbat = s2mc501_dc_get_fg_value(charger, POWER_SUPPLY_PROP_VOLTAGE_AVG);
	vcell = s2mc501_dc_get_pmeter(charger, PMETER_ID_VCELL);

	msleep(100);
	select_pdo(1);
	msleep(100);

	soc = soc / 10;

	pr_info("%s, soc : %d, vbat : %d, vcell %d\n", __func__, soc, vbat, vcell);

	if (vbat > (DC_MIN_VBAT + charger->chk_vbat_margin) && soc < DC_MAX_SOC) {
		if (charger->dc_sc_status == S2MC501_DC_SC_STATUS_CHARGE) {
			charger->dc_sc_status = S2MC501_DC_SC_STATUS_OFF;
		}
		pr_info("%s, soc : %d, vbat : %d, vcell %d\n", __func__, soc, vbat, vcell);
		s2mc501_dc_state_trans_enqueue(charger, DC_TRANS_BATTERY_OK);
	} else {
		charger->dc_sc_status = S2MC501_DC_SC_STATUS_CHARGE;
//		schedule_delayed_work(&charger->check_vbat_wqueue, msecs_to_jiffies(1000));
	}

	s2mc501_dc_state_trans_enqueue(charger, DC_TRANS_BATTERY_OK);
	s2mc501_dc_test_read(charger->i2c);
	return;
}

static void s2mc501_dc_state_preset(void *data)
{
	struct s2mc501_dc_data *charger = (struct s2mc501_dc_data *)data;
	union power_supply_propval value;

	unsigned int pdo_pos = 0;
	unsigned int taMaxVol = 4400 * 2;
	unsigned int taMaxCur;
	unsigned int taMaxPwr;
	int ret = 0;

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

	s2mc501_dc_test_read(charger->i2c);
	/* get APDO */
	pd_get_apdo_max_power(&pdo_pos, &taMaxVol, &taMaxCur, &taMaxPwr);
	charger->pd_data->pdo_pos	= pdo_pos;
	charger->pd_data->taMaxVol	= taMaxVol - 700;
	charger->pd_data->taMaxCur	= taMaxCur;
	charger->pd_data->taMaxPwr 	= taMaxPwr;

	/* Determine the Initial Voltage Here */
	s2mc501_dc_cal_target_value(charger);
	charger->minIIN		= DC_TA_MIN_PPS_CURRENT;
	charger->adjustIIN 	= ((charger->minIIN / DC_TA_CURR_STEP_MA) * DC_TA_CURR_STEP_MA) + DC_TA_CURR_STEP_MA;
	select_pps(charger->pd_data->pdo_pos, charger->ppsVol, charger->adjustIIN);

	value.intval = 1;
	ret = power_supply_set_property(charger->psy_top,
			(enum power_supply_property)POWER_SUPPLY_S2M_PROP_TOP_EN_STEP_CC, &value);

	/* ENB_CC, ENB_CV */
	s2mc501_update_reg(charger->i2c, S2MC501_DC_OTP7,
			DC_ENB_CC | DC_ENB_CV, DC_ENB_CC | DC_ENB_CV);

	/* RCP setting */
	s2mc501_update_reg(charger->i2c, S2MC501_DC_CTRL2,
			DC_RCP_100mA << DC_RCP_SHIFT, DC_RCP_MASK);

	msleep(200);

	/* PPS Setting */
	pd_pps_enable(charger->pd_data->pdo_pos,
		charger->ppsVol, charger->adjustIIN, S2MC501_DC_EN);

	/* RCP setting */
	s2mc501_update_reg(charger->i2c, S2MC501_DC_CTRL2,
			DC_RCP_100mA << DC_RCP_SHIFT, DC_RCP_MASK);

	/* RCP_DEB setting */
	s2mc501_update_reg(charger->i2c, S2MC501_DC_OTP8, DC_OTP_RCP_DEB, DC_OTP_RCP_DEB);

	s2mc501_dc_irq_clear(charger);

	/* DC CCR */
	s2mc501_dc_set_input_current(charger, 3000);

	/* Auto PPS*/
	value.intval = 1;
	ret = power_supply_set_property(charger->psy_top,
			(enum power_supply_property)POWER_SUPPLY_S2M_PROP_TOP_AUTO_PPS_START, &value);

	/* DC enable */
	s2mc501_dc_enable(charger, 1);

	/* CV */
	value.intval = DC_CV_4400mV;
	ret = power_supply_set_property(charger->psy_top,
			(enum power_supply_property)POWER_SUPPLY_S2M_PROP_TOP_DC_CV, &value);

	s2mc501_dc_test_read(charger->i2c);
	pr_info("%s End\n", __func__);

	s2mc501_dc_state_trans_enqueue(charger, DC_TRANS_NORMAL_CHG_INT);
	return;
}

static void s2mc501_dc_state_cc(void *data)
{
	struct s2mc501_dc_data *charger = (struct s2mc501_dc_data *)data;
	pr_info("%s\n", __func__);
	charger->dc_chg_status = POWER_SUPPLY_STATUS_CHARGING;
	s2mc501_dc_test_read(charger->i2c);
	return;
}

static void s2mc501_dc_state_cv(void *data)
{
	struct s2mc501_dc_data *charger = (struct s2mc501_dc_data *)data;
	pr_info("%s\n", __func__);
	s2mc501_dc_test_read(charger->i2c);
}

static void s2mc501_dc_state_done(void *data)
{
	struct s2mc501_dc_data *charger = (struct s2mc501_dc_data *)data;
	struct	power_supply *psy;
	union power_supply_propval value;
	pr_info("%s\n", __func__);
	charger->is_charging = false;
	charger->ps_health = POWER_SUPPLY_HEALTH_GOOD;
	charger->dc_chg_status = POWER_SUPPLY_STATUS_DISCHARGING;

	if (charger->pd_data->pdo_pos) {
		pd_pps_enable(charger->pd_data->pdo_pos,
			9000, charger->targetIIN, 0);
		charger->pd_data->pdo_pos = 0;

	}

	/* Auto PPS*/
	value.intval = 0;
	power_supply_set_property(charger->psy_top,
			(enum power_supply_property)POWER_SUPPLY_S2M_PROP_TOP_AUTO_PPS_START, &value);

	s2mc501_dc_enable(charger, 0);

	psy = power_supply_get_by_name("dc-manager");
	if (!psy) {
		pr_err("%s, can't access power_supply", __func__);
		return;
	}

	value.intval = 1;
    power_supply_set_property(psy,
    	(enum power_supply_property)POWER_SUPPLY_S2M_PROP_DIRECT_CHARGE_DONE, &value);

	s2mc501_dc_test_read(charger->i2c);
}

static void s2mc501_dc_state_off(void *data)
{
	struct s2mc501_dc_data *charger = (struct s2mc501_dc_data *)data;
	union power_supply_propval value;

	pr_info("%s\n", __func__);
	charger->is_charging = false;
	charger->ps_health = POWER_SUPPLY_HEALTH_GOOD;
	charger->dc_chg_status = POWER_SUPPLY_STATUS_DISCHARGING;

	if (charger->pd_data->pdo_pos) {
		pd_pps_enable(charger->pd_data->pdo_pos,
			9000, charger->targetIIN, 0);
		charger->pd_data->pdo_pos = 0;

	}

	s2mc501_dc_enable(charger, 0);
	/* Auto PPS*/
	value.intval = 0;
	power_supply_set_property(charger->psy_top,
			(enum power_supply_property)POWER_SUPPLY_S2M_PROP_TOP_AUTO_PPS_START, &value);

	s2mc501_dc_test_read(charger->i2c);
}
#if 0
static int s2mc501_dc_send_fenced_pps(struct s2mc501_dc_data *charger)
{
	if (charger->ppsVol > charger->pd_data->taMaxVol)
		charger->ppsVol = charger->pd_data->taMaxVol;

	if (charger->targetIIN > charger->pd_data->taMaxCur)
		charger->targetIIN = charger->pd_data->taMaxCur;

	if (charger->targetIIN < charger->minIIN)
		charger->targetIIN = charger->minIIN;

	pr_info("%s vol : %d, curr : %d, duration : %ld\n",
		__func__, charger->ppsVol, charger->targetIIN,
		s2mc501_dc_update_time_chk(charger));
	if (charger->is_charging)
		sec_pd_select_pps(charger->pd_data->pdo_pos,
			charger->ppsVol, charger->targetIIN);
	else
		return 0;

	s2mc501_dc_get_pmeter(charger, PMETER_ID_ICHGIN);
	s2mc501_dc_get_pmeter(charger, PMETER_ID_IWCIN);

	return 1;
}

static int s2mc501_dc_send_verify(struct s2mc501_dc_data *charger)
{
	int wait_ret = 0;
	s2mc501_dc_send_fenced_pps(charger);

	charger->is_pps_ready = false;
	wait_ret = wait_event_interruptible_timeout(charger->wait,
			charger->is_pps_ready,
			msecs_to_jiffies(500));
	pr_info("%s, wait %d ms.\n", __func__, wait_ret);
	return wait_ret;
}
#endif

static void s2mc501_dc_state_manager_work(struct work_struct *work)
{
	struct s2mc501_dc_data *charger = container_of(work, struct s2mc501_dc_data,
						 state_manager_wqueue.work);

	pr_info("%s\n", __func__);
	s2mc501_dc_state_manager(charger, charger->dc_trans);
}

static int s2mc501_dc_irq_clear(struct s2mc501_dc_data *charger)
{
	u8 data[3];

	s2mc501_read_reg(charger->i2c, S2MC501_DC_INT0, &data[0]);
	s2mc501_read_reg(charger->i2c, S2MC501_DC_INT1, &data[1]);
	s2mc501_read_reg(charger->i2c, S2MC501_DC_INT2, &data[2]);

	return 0;
}

static void s2mc501_isr_work(struct work_struct *work)
{
	struct s2mc501_dc_data *charger = container_of(work, struct s2mc501_dc_data, isr_work.work);
	u8 data[3];
	struct	power_supply *psy;
	union power_supply_propval value;

	s2mc501_read_reg(charger->i2c, S2MC501_DC_INT0, &data[0]);
	s2mc501_read_reg(charger->i2c, S2MC501_DC_INT1, &data[1]);
	s2mc501_read_reg(charger->i2c, S2MC501_DC_INT2, &data[2]);
	pr_info("%s : %02x, %02x, %02x\n", __func__, data[0], data[1], data[2]);


	if ((data[0] & DC_INT0_IN2OUTOVP) || (data[1] & DC_INT2_CFLY_OVP) ||
			(data[0] & DC_INT0_IN2OUTFAIL) || (data[0] & DC_INT0_DCOUTFAIL) ||
			(data[0] & DC_INT0_CLSHORT) || (data[0] & DC_INT0_FC_P_UVLO) ||
			(data[0] & DC_INT0_VOUTOVP) || (data[0] & DC_INT0_TSD) ||
			(data[1] & DC_INT1_DCINOVP) || (data[1] & DC_INT1_INPUTOCP) ||
			(data[2] & DC_INT2_RCP) || (data[2] & DC_INT2_CLSHORT) ||
			(data[2] & DC_INT2_CFLY_OVP)) {

		charger->ps_health = POWER_SUPPLY_S2M_HEALTH_DC_ERR;
		charger->is_charging = false;

		psy = power_supply_get_by_name("dc-manager");
		if (!psy) {
			pr_err("%s, can't access power_supply", __func__);
			return;
		}

		value.intval = charger->ps_health;
		power_supply_set_property(psy,
				(enum power_supply_property) POWER_SUPPLY_PROP_HEALTH, &value);

		s2mc501_dc_state_manager(charger, DC_TRANS_FAIL_INT);
	}
	else if (data[1] & DC_INT1_CHARGING) {
		pr_info("%s Normal Charger detected\n", __func__);
		usleep_range(10000,11000);
		s2mc501_dc_state_trans_enqueue(charger, DC_TRANS_NORMAL_CHG_INT);
		goto out;
	} else if (data[0] & DC_INT0_PLUGOUT) {
		s2mc501_dc_state_trans_enqueue(charger, DC_TRANS_DC_OFF_INT);
		goto out;
	}

	s2mc501_dc_test_read(charger->i2c);
out:
	mutex_unlock(&charger->irq_lock);
}

static irqreturn_t s2mc501_irq_thread(int irq, void *irq_data)
{
	struct s2mc501_dc_data *charger = irq_data;

	mutex_lock(&charger->irq_lock);
	schedule_delayed_work(&charger->isr_work, 0);

	return IRQ_HANDLED;
}

static void s2mc501_dc_update_work(struct work_struct *work)
{
	struct s2mc501_dc_data *charger = container_of(work, struct s2mc501_dc_data, update_wqueue.work);
	s2mc501_dc_platform_state_update(charger);
}

static int s2mc501_dc_irq_init(struct s2mc501_dc_data *charger)
{
	int ret = 0;
	pr_info("%s: s2mc501 irq = %d\n", __func__, charger->irq_gpio);

	if (charger->pdata->irq_gpio > 0) {
		charger->irq_gpio = gpio_to_irq(charger->pdata->irq_gpio);
		pr_info("%s: s2mc501 irq = %d\n", __func__, charger->irq_gpio);
		if (charger->irq_gpio > 0) {
			ret = request_threaded_irq(charger->irq_gpio,
					NULL, s2mc501_irq_thread,
					IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING | IRQF_ONESHOT,
					"s2mc501-irq", charger);
			if (ret) {
				pr_err("%s: Failed to Request IRQ\n", __func__);

			}

			ret = enable_irq_wake(charger->irq_gpio);
			if (ret < 0)
				pr_err("%s: Failed to Enable Wakeup Source(%d)\n", __func__, ret);
		} else {
			pr_err("%s: Failed gpio_to_irq(%d)\n", __func__, charger->irq_gpio);
		}
	}

	s2mc501_write_reg(charger->i2c, S2MC501_DC_INT0_MASK, 0x00);
	s2mc501_write_reg(charger->i2c, S2MC501_DC_INT1_MASK, 0x00);
	s2mc501_write_reg(charger->i2c, S2MC501_DC_INT2_MASK, 0x00);
	s2mc501_dc_set_irq_unmask(charger);

	INIT_DELAYED_WORK(&charger->isr_work, s2mc501_isr_work);

	return 0;
}


static bool s2mc501_dc_init(struct s2mc501_dc_data *charger)
{
	int float_voltage, input_current, rev_current;

	/* enable */
	gpio_request(charger->pdata->enable_gpio, "s2mc501_enable");
	gpio_direction_output(charger->pdata->enable_gpio, 1);
	msleep(500);

	/* DC EN */
	s2mc501_update_reg(charger->i2c, S2MC501_DC_CHIP_SET,
					DC_EN_MASK, DC_EN_MASK);

	msleep(20);
	/* DC CLK EN */
	s2mc501_update_reg(charger->i2c, S2MC501_DC_CHIP_SET,
					SYSCLK_EN_MASK, SYSCLK_EN_MASK);
	msleep(500);

	s2mc501_update_reg(charger->i2c, S2MC501_CD_OTP0, 0x00, 0x84);

	float_voltage = s2mc501_dc_get_float_voltage(charger);
	input_current = s2mc501_dc_get_input_current(charger);
	rev_current	= s2mc501_dc_get_rcp(charger);

	s2mc501_dc_set_float_voltage(charger, float_voltage);
	s2mc501_dc_set_input_current(charger, input_current);
	s2mc501_dc_set_rcp(charger, rev_current);
	s2mc501_dc_is_enable(charger);
	s2mc501_dc_pm_enable(charger);
	s2mc501_dc_enable(charger, 0);

	charger->dc_state = DC_STATE_OFF;
	charger->dc_state_fp[DC_STATE_OFF]	 	= s2mc501_dc_state_off;
	charger->dc_state_fp[DC_STATE_CHECK_VBAT] 	= s2mc501_dc_state_check_vbat;
	charger->dc_state_fp[DC_STATE_PRESET] 		= s2mc501_dc_state_preset;
	charger->dc_state_fp[DC_STATE_CC] 		= s2mc501_dc_state_cc;
	charger->dc_state_fp[DC_STATE_CV]		= s2mc501_dc_state_cv;
	charger->dc_state_fp[DC_STATE_DONE] 		= s2mc501_dc_state_done;
	charger->vchgin_okb_retry = 0;

	charger->is_pps_ready = false;
	charger->rise_speed_dly_ms = 10;
	charger->step_vbatt_mv = 4150;
	charger->step_iin_ma = 2000;
	charger->step_cv_cnt = 0;
	charger->mon_chk_time = 0;
	charger->ps_health = POWER_SUPPLY_HEALTH_GOOD;
	charger->dc_chg_status = POWER_SUPPLY_STATUS_DISCHARGING;
	charger->dc_sc_status = S2MC501_DC_SC_STATUS_OFF;
	charger->chk_vbat_margin = 0;
	charger->is_rampup_adjusted = false;
	charger->is_plugout_mask = false;
	charger->is_autopps_disabled = false;
	charger->chk_vbat_charged = 0;
	charger->chk_vbat_prev = 0;
	charger->chk_iin_prev = 0;

	return true;
}

static int s2mc501_dc_parse_dt(struct device *dev,
		struct s2mc501_dc_platform_data *pdata)
{
	struct device_node *np = of_find_node_by_name(NULL, "s2mc501-direct-charger");
	int ret = 0;

	if (!np) {
		pr_err("%s np NULL(s2mc501-direct-charger)\n", __func__);
		ret = -1;
		goto err;
	}

	ret = of_property_read_string(np, "dc,direct_charger_name",
				(char const **)&pdata->dc_name);
	if (ret < 0)
		pr_info("%s: Direct Charger name is Empty\n", __func__);

	ret = of_property_read_u32(np, "dc,input_current_limit",
			&pdata->input_current_limit);
	if (ret) {
		pr_info("%s: dc,input_current_limit Empty default 4000\n", __func__);
		pdata->input_current_limit = DC_MAX_INPUT_CURRENT_MA;
	}

	ret = of_property_read_u32(np, "dc,topoff_current",
			&pdata->topoff_current);
	if (ret) {
		pr_info("%s: dc,topoff_current Empty default 2000\n", __func__);
		pdata->topoff_current = DC_TOPOFF_CURRENT_MA;
	}

	ret = of_get_named_gpio(np, "s2mc501,irq-gpio", 0);
	if (!gpio_is_valid(ret))
		return ret;
	pdata->irq_gpio = ret;

	ret = of_get_named_gpio(np, "s2mc501,enable-gpio", 0);
	if (!gpio_is_valid(ret))
		return ret;
	pdata->enable_gpio = ret;

	pr_info("%s DT file parsed succesfully\n", __func__);
	return 0;

err:
	pr_info("%s, direct charger parsing failed\n", __func__);
	return -1;
}

/* if need to set s2mc501 pdata */
static const struct of_device_id s2mc501_direct_charger_match_table[] = {
	{ .compatible = "samsung,s2mc501-direct-charger",},
	{},
};

static int s2mc501_direct_charger_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
	struct s2mc501_dc_data *charger;
	struct power_supply_config psy_cfg = {};
	int ret = 0;
	union power_supply_propval value;
	s2mc501_dc_pd_data_t *pd_data;

	pr_info("%s: S2MC501 Direct Charger driver probe\n", __func__);
	charger = kzalloc(sizeof(*charger), GFP_KERNEL);
	if (!charger)
		return -ENOMEM;

	pd_data = kzalloc(sizeof(*pd_data), GFP_KERNEL);
	if (unlikely(!pd_data)) {
		pr_err("%s: failed to allocate driver data\n", __func__);
		ret = -ENOMEM;
		goto err_pd_data_alloc;
	}
	charger->pd_data = pd_data;
	charger->i2c = client;

	mutex_init(&charger->dc_state_mutex);
	mutex_init(&charger->dc_mutex);
	mutex_init(&charger->i2c_lock);
	mutex_init(&charger->irq_lock);
	mutex_init(&charger->trans_mutex);
//	battery_wakeup_source_init(&client->dev, &charger->state_manager_ws, "state_man_wake");

	charger->dev = &client->dev;
	charger->i2c = client;
//	charger->rev_id = s2mc501->pmic_rev;

	if (client->dev.of_node) {
		charger->pdata = devm_kzalloc(&client->dev, sizeof(*(charger->pdata)), GFP_KERNEL);
		if (!charger->pdata) {
			ret = -ENOMEM;
			goto err_parse_dt_nomem;
		}

		ret = s2mc501_dc_parse_dt(&client->dev, charger->pdata);
		if (ret < 0) {
			dev_err(&client->dev,
				"%s: Failed to get direct charger dt\n", __func__);
			ret = -EINVAL;
			goto err_parse_dt;
		}
	} else {
		charger->pdata = client->dev.platform_data;
	}

	i2c_set_clientdata(client, charger);

	if (charger->pdata->dc_name == NULL)
		charger->pdata->dc_name = "s2mc501-direct-charger";

	if (charger->pdata->pm_name == NULL)
		charger->pdata->pm_name = "s2mc501-pmeter";

	if (charger->pdata->fg_name == NULL)
		charger->pdata->fg_name = "s2mf301-fuelgauge";

	if (charger->pdata->sc_name == NULL)
		charger->pdata->sc_name = "s2mf301-charger";

	if (charger->pdata->sec_dc_name == NULL)
		charger->pdata->sec_dc_name = "dc-manager";

	if (charger->pdata->top_name == NULL)
		charger->pdata->top_name = "s2mf301-top";

	charger->psy_dc_desc.name           = charger->pdata->dc_name;
	charger->psy_dc_desc.type           = POWER_SUPPLY_TYPE_UNKNOWN;
	charger->psy_dc_desc.get_property   = s2mc501_dc_get_property;
	charger->psy_dc_desc.set_property   = s2mc501_dc_set_property;
	charger->psy_dc_desc.properties     = s2mc501_dc_props;
	charger->psy_dc_desc.num_properties = ARRAY_SIZE(s2mc501_dc_props);

	s2mc501_dc_init(charger);
	s2mc501_pmeter_init(charger);

	charger->psy_pmeter = power_supply_get_by_name(charger->pdata->pm_name);
	if (!charger->psy_pmeter) {
		pr_err("%s: Fail to get pmeter\n", __func__);
		goto err_get_pmeter;
	}

	charger->psy_top = power_supply_get_by_name(charger->pdata->top_name);
	if (!charger->psy_top) {
		pr_err("%s: Fail to get top\n", __func__);
		goto err_get_pmeter;
	}

	/* Auto PPS*/
	value.intval = 0;
	power_supply_set_property(charger->psy_top,
			(enum power_supply_property)POWER_SUPPLY_S2M_PROP_TOP_AUTO_PPS_START, &value);

	psy_cfg.drv_data = charger;
	psy_cfg.supplied_to = s2mc501_supplied_to;
	psy_cfg.num_supplicants = ARRAY_SIZE(s2mc501_supplied_to);

	charger->psy_dc = power_supply_register(&client->dev, &charger->psy_dc_desc, &psy_cfg);
	if (IS_ERR(charger->psy_dc)) {
		pr_err("%s: Failed to Register psy_dc\n", __func__);
		ret = PTR_ERR(charger->psy_dc);
		goto err_power_supply_register;
	}

	charger->psy_fg = power_supply_get_by_name(charger->pdata->fg_name);
	if (!charger->psy_fg)
		goto err_get_psy;

	charger->psy_sc = power_supply_get_by_name(charger->pdata->sc_name);
	if (!charger->psy_sc)
		goto err_get_psy;

	INIT_DELAYED_WORK(&charger->state_manager_wqueue, s2mc501_dc_state_manager_work);
	INIT_DELAYED_WORK(&charger->update_wqueue, s2mc501_dc_update_work);
	s2mc501_dc_irq_init(charger);

#if EN_TEST_READ
	s2mc501_dc_test_read(charger->i2c);
#endif
//	ret = s2mc501_dc_create_attrs(&charger->psy_dc->dev);
//	if (ret) {
//		dev_err(charger->dev,
//			"%s : Failed to create_attrs\n", __func__);
//	}
	pr_info("%s: S2MC501 Direct Charger driver loaded OK\n", __func__);

	return 0;

#if defined(BRINGUP)
err_create_wq:
#endif
err_get_psy:
	power_supply_unregister(charger->psy_dc);
err_power_supply_register:
err_get_pmeter:
err_parse_dt:
err_parse_dt_nomem:
	mutex_destroy(&charger->dc_mutex);
	mutex_destroy(&charger->dc_state_mutex);
	mutex_destroy(&charger->i2c_lock);
	mutex_destroy(&charger->irq_lock);
	wakeup_source_unregister(charger->state_manager_ws);
	kfree(charger->pd_data);
err_pd_data_alloc:
	kfree(charger);
	return ret;
}

static int s2mc501_direct_charger_remove(struct i2c_client *client)
{
	struct s2mc501_dc_data *charger = i2c_get_clientdata(client);

	power_supply_unregister(charger->psy_dc);
	mutex_destroy(&charger->dc_mutex);
	mutex_destroy(&charger->dc_state_mutex);
	mutex_destroy(&charger->i2c_lock);
	mutex_destroy(&charger->irq_lock);
	wakeup_source_unregister(charger->state_manager_ws);
	kfree(charger->pd_data);
	kfree(charger);
	return 0;
}

#if defined CONFIG_PM
static int s2mc501_direct_charger_prepare(struct device *dev)
{
	return 0;
}

static int s2mc501_direct_charger_suspend(struct device *dev)
{
	return 0;
}

static int s2mc501_direct_charger_resume(struct device *dev)
{
	return 0;
}

static void s2mc501_direct_charger_complete(struct device *dev)
{
	return;
}

#else
#define s2mc501_direct_charger_suspend NULL
#define s2mc501_direct_charger_resume NULL
#endif

static void s2mc501_direct_charger_shutdown(struct i2c_client *client)
{
	struct s2mc501_dc_data *charger = i2c_get_clientdata(client);
	union power_supply_propval value;
	pr_info("%s: S2MC501 Direct Charger driver shutdown\n", __func__);
	if (charger->pd_data->pdo_pos) {
		pd_pps_enable(charger->pd_data->pdo_pos,
			5000, charger->targetIIN, 0);
		charger->pd_data->pdo_pos = 0;

	}

	s2mc501_dc_enable(charger, 0);
	/* Auto PPS*/
	value.intval = 0;
	power_supply_set_property(charger->psy_top,
			(enum power_supply_property)POWER_SUPPLY_S2M_PROP_TOP_AUTO_PPS_START, &value);
}

static const struct dev_pm_ops s2mc501_direct_charger_pm_ops = {
	.prepare = s2mc501_direct_charger_prepare,
	.suspend = s2mc501_direct_charger_suspend,
	.resume = s2mc501_direct_charger_resume,
	.complete = s2mc501_direct_charger_complete,
};

static struct i2c_driver s2mc501_direct_charger_driver = {
	.driver         = {
		.name   = "s2mc501-direct-charger",
		.owner  = THIS_MODULE,
		.of_match_table = s2mc501_direct_charger_match_table,
		.pm     = &s2mc501_direct_charger_pm_ops,
	},
	.probe          = s2mc501_direct_charger_probe,
	.remove		= s2mc501_direct_charger_remove,
	.shutdown   =   s2mc501_direct_charger_shutdown,
};

static int __init s2mc501_direct_charger_init(void)
{
	int ret = 0;
	pr_info("%s start\n", __func__);
	ret = i2c_add_driver(&s2mc501_direct_charger_driver);

	return ret;
}
module_init(s2mc501_direct_charger_init);

static void __exit s2mc501_direct_charger_exit(void)
{
	i2c_del_driver(&s2mc501_direct_charger_driver);
}
module_exit(s2mc501_direct_charger_exit);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Charger driver for S2MC501");
MODULE_SOFTDEP("pre: i2c-exynos5 post: s2m_chg_manager");