Initial file dump from open source releaseHEADmaster

1 files changed, 1359 insertions, 0 deletions

diff --git a/drivers/power/rt5033_charger.c b/drivers/power/rt5033_charger.c
new file mode 100644
index 00000000..fe41958f
--- /dev/null
+++ b/drivers/power/rt5033_charger.c
@@ -0,0 +1,1359 @@
+/* drivers/battery/rt5033_charger.c
+ * RT5033 Charger Driver
+ *
+ * Copyright (C) 2013 Richtek Technology Corp.
+ * Author: Patrick Chang <patrick_chang@richtek.com>
+ *
+ * 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; either version 2
+ * of the License, or (at your option) any later version.
+ */
+
+#include <linux/battery/sec_charger.h>
+#ifdef CONFIG_USB_HOST_NOTIFY
+#include <linux/host_notify.h>
+#include <mach/usb3-drd.h>
+#endif
+
+#include <linux/mfd/rt5033.h>
+
+#ifdef CONFIG_FLED_RT5033
+#include <linux/leds/rt5033_fled.h>
+#include <linux/leds/rtfled.h>
+#endif /* CONFIG_FLED_RT5033 */
+#include <linux/version.h>
+
+#define ENABLE_MIVR 1
+
+#define EN_BAD_ADP_IRQ	1
+#define EN_OVP_IRQ 1
+#define EN_IEOC_IRQ 1
+#define EN_RECHG_REQ_IRQ 0
+#define EN_TR_IRQ 0
+#define EN_MIVR_SW_REGULATION 0
+#define EN_BST_IRQ 0
+#define MINVAL(a, b) ((a <= b) ? a : b)
+
+#define EOC_DEBOUNCE_CNT 3
+#define HEALTH_DEBOUNCE_CNT 3
+
+#define EOC_SLEEP 200
+/* Timeout setting should be larger than wakelock setting
+ * * to let CPU have enough time to go sleeping */
+#define EOC_TIMEOUT (10 * 1000)
+/* 9.9 second */
+#define BADADP_RESTART_TIMER	(9900)
+
+#ifndef EN_TEST_READ
+#define EN_TEST_READ 0
+#endif
+
+static int rt5033_reg_map[] = {
+	RT5033_CHG_STAT_CTRL,
+	RT5033_CHG_CTRL1,
+	RT5033_CHG_CTRL2,
+	RT5033_CHG_CTRL3,
+	RT5033_CHG_CTRL4,
+	RT5033_CHG_CTRL5,
+	RT5033_CHG_RESET,
+	RT5033_UUG,
+};
+
+typedef struct rt5033_charger_data {
+	rt5033_mfd_chip_t *rt5033;
+	struct power_supply psy_chg;
+	rt5033_charger_platform_data_t *pdata;
+	int eoc_cnt;
+	int charging_current;
+	int siop_level;
+	int cable_type;
+	bool is_charging;
+	struct mutex io_lock;
+	/* register programming */
+	int reg_addr;
+	int reg_data;
+
+	bool full_charged;
+	bool ovp;
+	int unhealth_cnt;
+	struct workqueue_struct *wq;
+	struct delayed_work eoc_timeout_work;
+#if EN_BAD_ADP_IRQ
+	struct delayed_work activate_bad_adp_work;
+#endif /* EN_BAD_ADP_IRQ */
+	int status;
+#ifdef CONFIG_FLED_RT5033
+	struct rt_fled_info *fled_info;
+#endif /* CONFIG_FLED_RT5033 */
+} rt5033_charger_data_t;
+
+static enum power_supply_property sec_charger_props[] = {
+	POWER_SUPPLY_PROP_STATUS,
+	POWER_SUPPLY_PROP_CHARGE_TYPE,
+	POWER_SUPPLY_PROP_HEALTH,
+	POWER_SUPPLY_PROP_ONLINE,
+	POWER_SUPPLY_PROP_CURRENT_MAX,
+	POWER_SUPPLY_PROP_CURRENT_AVG,
+	POWER_SUPPLY_PROP_CURRENT_NOW,
+	POWER_SUPPLY_PROP_CHARGE_OTG_CONTROL,
+};
+
+static int rt5033_get_charging_health(
+		struct rt5033_charger_data *charger);
+
+static void rt5033_read_regs(struct i2c_client *i2c, char *str)
+{
+	u8 data = 0;
+	int i = 0;
+	for (i = 0; i < ARRAY_SIZE(rt5033_reg_map); i++) {
+		data = rt5033_reg_read(i2c, rt5033_reg_map[i]);
+		sprintf(str + strlen(str), "0x%02x, ", data);
+	}
+}
+
+static void rt5033_test_read(struct i2c_client *i2c)
+{
+	int data = 0;
+	int i;
+	for (i = 0; i < ARRAY_SIZE(rt5033_reg_map); i++) {
+		data = rt5033_reg_read(i2c, rt5033_reg_map[i]);
+		pr_info("rt50333: c: 0x%02x(0x%02x)\n", i, data);
+	}
+}
+
+static void rt5033_charger_otg_control(struct rt5033_charger_data *charger,
+		bool enable)
+{
+	struct i2c_client *i2c = charger->rt5033->i2c_client;
+
+	pr_info("%s: called charger otg control : %s\n", __func__,
+			enable ? "on" : "off");
+
+	if (!enable) {
+		/* turn off OTG */
+		rt5033_clr_bits(i2c, RT5033_CHG_CTRL1, RT5033_OPAMODE_MASK);
+#ifdef CONFIG_FLED_RT5033
+		if (charger->fled_info == NULL)
+			charger->fled_info = rt_fled_get_info_by_name(NULL);
+		if (charger->fled_info)
+			rt5033_boost_notification(charger->fled_info, 0);
+#endif /* CONFIG_FLED_RT5033 */
+	} else {
+		/* Set OTG boost vout = 5V, turn on OTG */
+		rt5033_assign_bits(charger->rt5033->i2c_client,
+				RT5033_CHG_CTRL2, RT5033_VOREG_MASK,
+				0x37 << RT5033_VOREG_SHIFT);
+		rt5033_set_bits(charger->rt5033->i2c_client,
+				RT5033_CHG_CTRL1, RT5033_OPAMODE_MASK);
+		rt5033_clr_bits(charger->rt5033->i2c_client,
+				RT5033_CHG_CTRL1, RT5033_HZ_MASK);
+		charger->cable_type = POWER_SUPPLY_TYPE_OTG;
+#ifdef CONFIG_FLED_RT5033
+		if (charger->fled_info == NULL)
+			charger->fled_info = rt_fled_get_info_by_name(NULL);
+		if (charger->fled_info)
+			rt5033_boost_notification(charger->fled_info, 1);
+#endif /* CONFIG_FLED_RT5033 */
+	}
+}
+
+/* this function will work well on CHIP_REV = 3 or later */
+static void rt5033_enable_charger_switch(struct rt5033_charger_data *charger,
+		int onoff)
+{
+	int prev_charging_status = charger->is_charging;
+	struct i2c_client *iic = charger->rt5033->i2c_client;
+
+	charger->is_charging = onoff ? true : false;
+	if ((onoff > 0) && (prev_charging_status == false)) {
+		charger->full_charged = false;
+		pr_info("%s: turn on charger\n", __func__);
+#ifdef CONFIG_MFD_RT5033_EN_MRSTB
+		/* Disable Manual Reset */
+		rt5033_clr_bits(iic, 0x47, 1 << 3);
+#endif /* CONFIG_MFD_RT5033_EN_MRSTB */
+#ifdef CONFIG_FLED_RT5033
+		if (charger->fled_info == NULL)
+			charger->fled_info = rt_fled_get_info_by_name(NULL);
+		if (charger->fled_info)
+			rt5033_charger_notification(charger->fled_info, 1);
+#endif /* CONFIG_FLED_RT5033 */
+		rt5033_clr_bits(iic, RT5033_CHG_STAT_CTRL, RT5033_CHGENB_MASK);
+		rt5033_clr_bits(iic, RT5033_CHG_CTRL1, RT5033_HZ_MASK);
+		rt5033_set_bits(iic, RT5033_CHG_CTRL3, RT5033_COF_EN_MASK);
+		/* Reset EOC loop, and make it re-detect */
+		charger->eoc_cnt = 0;
+		rt5033_set_bits(iic, RT5033_EOC_CTRL, RT5033_EOC_RESET_MASK);
+		rt5033_clr_bits(iic, RT5033_EOC_CTRL, RT5033_EOC_RESET_MASK);
+	} else if (onoff == 0) {
+		charger->full_charged = false;
+		pr_info("%s: turn off charger\n", __func__);
+#ifdef CONFIG_MFD_RT5033_EN_MRSTB
+		/* Enable Manual Reset */
+		rt5033_set_bits(iic, 0x47, 1 << 3);
+#endif /* CONFIG_MFD_RT5033_EN_MRSTB */
+		charger->charging_current = 0;
+		charger->eoc_cnt = 0;
+#ifdef CONFIG_FLED_RT5033
+		if (charger->fled_info == NULL)
+			charger->fled_info = rt_fled_get_info_by_name(NULL);
+		if (charger->fled_info)
+			rt5033_charger_notification(charger->fled_info, 0);
+#endif /* CONFIG_FLED_RT5033 */
+		rt5033_set_bits(iic, RT5033_CHG_STAT_CTRL, RT5033_CHGENB_MASK);
+	} else {
+		pr_info("%s: repeated to set charger switch(%d), prev stat = %d\n",
+				__func__, onoff, prev_charging_status ? 1 : 0);
+	}
+}
+
+static void rt5033_enable_charging_termination(struct i2c_client *i2c,
+		int onoff)
+{
+	pr_info("%s:[BATT] Do termination set(%d)\n", __func__, onoff);
+	if (onoff)
+		rt5033_set_bits(i2c, RT5033_CHG_CTRL1, RT5033_TEEN_MASK);
+	else
+		rt5033_clr_bits(i2c, RT5033_CHG_CTRL1, RT5033_TEEN_MASK);
+}
+
+static int rt5033_input_current_limit[] = {
+	100,
+	500,
+	700,
+	900,
+	1000,
+	1500,
+	2000,
+};
+
+static int __r5033_current_limit_to_setting(int current_limit)
+{
+	int i = 0;
+
+	for (i = 0; i < ARRAY_SIZE(rt5033_input_current_limit); i++) {
+		if (current_limit <= rt5033_input_current_limit[i])
+			return i + 1;
+	}
+
+	return -EINVAL;
+}
+
+static void rt5033_set_input_current_limit(struct rt5033_charger_data *charger,
+		int current_limit)
+{
+	struct i2c_client *i2c = charger->rt5033->i2c_client;
+	int data = __r5033_current_limit_to_setting(current_limit);
+
+	if (data < 0)
+		data = 0;
+	mutex_lock(&charger->io_lock);
+	rt5033_assign_bits(i2c, RT5033_CHG_CTRL1, RT5033_AICR_LIMIT_MASK,
+			(data) << RT5033_AICR_LIMIT_SHIFT);
+	mutex_unlock(&charger->io_lock);
+}
+
+static int rt5033_get_input_current_limit(struct i2c_client *i2c)
+{
+	int ret;
+	ret = rt5033_reg_read(i2c, RT5033_CHG_CTRL1);
+	if (ret < 0)
+		return ret;
+	ret &= RT5033_AICR_LIMIT_MASK;
+	ret >>= RT5033_AICR_LIMIT_SHIFT;
+	if (ret == 0)
+		return 2000 + 1; // no limitation
+	return rt5033_input_current_limit[ret - 1];
+}
+
+static void rt5033_set_regulation_voltage(struct rt5033_charger_data *charger,
+		int float_voltage)
+{
+	struct i2c_client *i2c = charger->rt5033->i2c_client;
+	int data;
+
+	if (float_voltage < 3650)
+		data = 0;
+	else if (float_voltage >= 3650 && float_voltage <= 4400)
+		data = (float_voltage - 3650) / 25;
+	else
+		data = 0x3f;
+	mutex_lock(&charger->io_lock);
+	rt5033_assign_bits(i2c, RT5033_CHG_CTRL2, RT5033_VOREG_MASK,
+			data << RT5033_VOREG_SHIFT);
+	mutex_unlock(&charger->io_lock);
+}
+
+static void __rt5033_set_fast_charging_current(struct i2c_client *i2c,
+		int charging_current)
+{
+	int data;
+
+	if (charging_current < 700)
+		data = 0;
+	else if (charging_current >= 700 && charging_current <= 2000)
+		data = (charging_current - 700) / 100;
+	else
+		data = 0xd;
+
+	rt5033_assign_bits(i2c, RT5033_CHG_CTRL5, RT5033_ICHRG_MASK,
+			data << RT5033_ICHRG_SHIFT);
+}
+
+static int rt5033_eoc_level[] = {
+	0,
+	150,
+	200,
+	250,
+	300,
+	400,
+	500,
+	600,
+};
+
+static int rt5033_get_eoc_level(int eoc_current)
+{
+	int i;
+	for (i = 0; i < ARRAY_SIZE(rt5033_eoc_level); i++) {
+		if (eoc_current < rt5033_eoc_level[i]) {
+			if (i == 0)
+				return 0;
+			return i - 1;
+		}
+	}
+	return ARRAY_SIZE(rt5033_eoc_level) - 1;
+}
+
+static int rt5033_get_current_eoc_setting(struct rt5033_charger_data *charger)
+{
+	int ret;
+	mutex_lock(&charger->io_lock);
+	ret = rt5033_reg_read(charger->rt5033->i2c_client, RT5033_CHG_CTRL4);
+	mutex_unlock(&charger->io_lock);
+	if (ret < 0) {
+		pr_info("%s: warning --> fail to read i2c register(%d)\n", __func__, ret);
+		return ret;
+	}
+	return rt5033_eoc_level[(RT5033_IEOC_MASK & ret) >> RT5033_IEOC_SHIFT];
+}
+
+static int rt5033_get_fast_charging_current(struct i2c_client *i2c)
+{
+	int data = rt5033_reg_read(i2c, RT5033_CHG_CTRL5);
+	if (data < 0)
+		return data;
+
+	data = (data >> 4) & 0x0f;
+
+	if (data > 0xd)
+		data = 0xd;
+	return data * 100 + 700;
+}
+
+static void __rt5033_set_termination_current_limit(struct i2c_client *i2c,
+		int current_limit)
+{
+	int data = rt5033_get_eoc_level(current_limit);
+	int ret;
+
+	pr_info("%s : Set Termination\n", __func__);
+
+	ret = rt5033_assign_bits(i2c, RT5033_CHG_CTRL4, RT5033_IEOC_MASK,
+			data << RT5033_IEOC_SHIFT);
+}
+
+static void rt5033_set_charging_current(struct rt5033_charger_data *charger,
+		int eoc, int reset_eoc)
+{
+	int adj_current = 0;
+
+	adj_current = charger->charging_current * charger->siop_level / 100;
+	mutex_lock(&charger->io_lock);
+	__rt5033_set_fast_charging_current(charger->rt5033->i2c_client,
+			adj_current);
+	if (reset_eoc) {
+		__rt5033_set_termination_current_limit(
+				charger->rt5033->i2c_client, 0);
+		/* set EOC RESET */
+		rt5033_set_bits(charger->rt5033->i2c_client,
+				RT5033_EOC_CTRL, RT5033_EOC_RESET_MASK);
+		/* clear EOC RESET */
+		rt5033_clr_bits(charger->rt5033->i2c_client,
+				RT5033_EOC_CTRL, RT5033_EOC_RESET_MASK);
+	}
+
+	__rt5033_set_termination_current_limit(
+			charger->rt5033->i2c_client, eoc);
+	mutex_unlock(&charger->io_lock);
+
+}
+
+enum {
+	RT5033_MIVR_DISABLE = 0,
+	RT5033_MIVR_4200MV,
+	RT5033_MIVR_4300MV,
+	RT5033_MIVR_4400MV,
+	RT5033_MIVR_4500MV,
+	RT5033_MIVR_4600MV,
+	RT5033_MIVR_4700MV,
+	RT5033_MIVR_4800MV,
+};
+
+#if ENABLE_MIVR
+/* Dedicated charger (non-USB) device
+ * will use lower MIVR level to get better performance
+ */
+static void rt5033_set_mivr_level(struct rt5033_charger_data *charger)
+{
+	int mivr;
+
+	switch(charger->cable_type) {
+		case POWER_SUPPLY_TYPE_USB ... POWER_SUPPLY_TYPE_USB_ACA:
+			mivr = RT5033_MIVR_4600MV;
+			break;
+		default:
+			mivr = RT5033_MIVR_DISABLE;
+	}
+	mutex_lock(&charger->io_lock);
+	rt5033_assign_bits(charger->rt5033->i2c_client,
+			RT5033_CHG_CTRL4, RT5033_MIVR_MASK, mivr << RT5033_MIVR_SHIFT);
+	mutex_unlock(&charger->io_lock);
+}
+#endif /*ENABLE_MIVR*/
+
+static void rt5033_configure_charger(struct rt5033_charger_data *charger)
+{
+	int eoc;
+	union power_supply_propval val;
+
+	pr_info("%s : Set config charging\n", __func__);
+	if (charger->charging_current < 0) {
+		pr_info("%s : OTG is activated. Ignore command!\n",
+				__func__);
+		return;
+	}
+	/* Before configure charging setting,
+	 * * enable bad adaptor detection.
+	 * * Set Reg0x07[5] = 0 -> enable bad adaptor detection */
+	rt5033_clr_bits(charger->rt5033->i2c_client,
+			RT5033_EOC_CTRL, (1 << 5));
+#if ENABLE_MIVR
+	rt5033_set_mivr_level(charger);
+#endif /*DISABLE_MIVR*/
+	psy_do_property("battery", get,
+			POWER_SUPPLY_PROP_CHARGE_NOW, val);
+
+	/* Input current limit */
+	pr_info("%s : input current (%dmA)\n",
+			__func__, charger->pdata->charging_current_table
+			[charger->cable_type].input_current_limit);
+
+	rt5033_set_input_current_limit(charger,
+			charger->pdata->charging_current_table
+			[charger->cable_type].input_current_limit);
+
+	/* Float voltage */
+	pr_info("%s : float voltage (%dmV)\n",
+			__func__, charger->pdata->chg_float_voltage);
+
+	rt5033_set_regulation_voltage(charger,
+			charger->pdata->chg_float_voltage);
+
+	charger->charging_current = charger->pdata->charging_current_table
+		[charger->cable_type].fast_charging_current;
+	eoc = charger->pdata->charging_current_table
+		[charger->cable_type].full_check_current_1st;
+	/* Fast charge and Termination current */
+	pr_info("%s : fast charging current (%dmA)\n",
+			__func__, charger->charging_current);
+
+	pr_info("%s : termination current (%dmA)\n",
+			__func__, eoc);
+
+	rt5033_set_charging_current(charger, eoc, 1);
+	rt5033_enable_charger_switch(charger, 1);
+}
+
+int rt5033_chg_fled_init(struct i2c_client *client)
+{
+	int ret, rev_id;
+	rt5033_mfd_chip_t *chip = i2c_get_clientdata(client);
+	int is_750k_switching = 0;
+	int is_fixed_switching = 0;
+	struct rt5033_charger_data *charger = chip->charger;
+	/* if charger had loaded, we can get platform data */
+	if (charger) {
+		is_750k_switching = charger->pdata->is_fixed_switching;
+		is_fixed_switching = charger->pdata->is_750kHz_switching;
+		pr_info("rt5033 chg: is_750k_switching = %d, is_fixed_switching = %d\n",
+				is_750k_switching, is_fixed_switching);
+	}
+	rt5033_set_bits(client, 0x6b, 0x01);
+	usleep_range(100, 100); /* delay 100 us to wait for normal read (from e-fuse) */
+	ret = rt5033_reg_read(client, 0x03);
+	rt5033_clr_bits(client, 0x6b, 0x01);
+	if (ret < 0)
+		pr_err("%s : failed to read revision ID\n", __func__);
+	rev_id = ret & 0x0f;
+	if (rev_id >= 4) {
+		if (charger) {
+
+			if (is_fixed_switching)
+				ret = rt5033_set_bits(client, 0x22, 0x04);
+			else
+				ret = rt5033_clr_bits(client, 0x22, 0x04);
+			if (ret < 0)
+				goto rt5033_chg_fled_init_exit;
+			if (is_750k_switching)
+				ret = rt5033_set_bits(client, RT5033_CHG_CTRL1,
+						RT5033_SEL_SWFREQ_MASK);
+			else
+				ret = rt5033_clr_bits(client, RT5033_CHG_CTRL1,
+						RT5033_SEL_SWFREQ_MASK);
+			if (ret < 0)
+				goto rt5033_chg_fled_init_exit;
+		}
+		/* Enable charging CV High-GM, reg0x22 bit 5 */
+		ret = rt5033_set_bits(client, 0x22, 0x20);
+	} else {
+		/* Set switching frequency to 0.75MHz for old revision IC*/
+		ret = rt5033_set_bits(client, RT5033_CHG_CTRL1,
+				RT5033_SEL_SWFREQ_MASK);
+	}
+rt5033_chg_fled_init_exit:
+	return ret;
+}
+EXPORT_SYMBOL(rt5033_chg_fled_init);
+
+
+/* here is set init charger data */
+static bool rt5033_chg_init(struct rt5033_charger_data *charger)
+{
+	rt5033_mfd_chip_t *chip = i2c_get_clientdata(charger->rt5033->i2c_client);
+	chip->charger = charger;
+	rt5033_chg_fled_init(charger->rt5033->i2c_client);
+	/* Disable Timer function (Charging timeout fault) */
+	rt5033_clr_bits(charger->rt5033->i2c_client,
+			RT5033_CHG_CTRL3, RT5033_TIMEREN_MASK);
+	/* Disable TE */
+	rt5033_enable_charging_termination(charger->rt5033->i2c_client, 0);
+
+	/* Enable High-GM */
+	rt5033_set_bits(charger->rt5033->i2c_client,
+			0x07, 0xC0);
+
+	/* EMI improvement , let reg0x18 bit2~5 be 1100*/
+	rt5033_assign_bits(charger->rt5033->i2c_client, 0x18, 0x3C, 0x30);
+
+	/* MUST set correct regulation voltage first
+	 * Before MUIC pass cable type information to charger
+	 * charger would be already enabled (default setting)
+	 * it might cause EOC event by incorrect regulation voltage */
+	rt5033_set_regulation_voltage(charger,
+			charger->pdata->chg_float_voltage);
+
+#if !(ENABLE_MIVR)
+	rt5033_assign_bits(charger->rt5033->i2c_client,
+			RT5033_CHG_CTRL4, RT5033_MIVR_MASK,
+			RT5033_MIVR_DISABLE << RT5033_MIVR_SHIFT);
+#endif
+	/* Set Reg0x07[5] = 0 -> enable bad adaptor detection */
+	rt5033_clr_bits(charger->rt5033->i2c_client,
+			RT5033_EOC_CTRL, (1 << 5));
+	return true;
+}
+
+static int rt5033_get_charging_status(struct rt5033_charger_data *charger)
+{
+	int status = POWER_SUPPLY_STATUS_UNKNOWN;
+	int ret;
+
+#ifdef CONFIG_USB_HOST_NOTIFY
+	struct host_notifier_platform_data *host_noti_pdata =
+		host_notifier_device.dev.platform_data;
+#endif
+
+	ret = rt5033_reg_read(charger->rt5033->i2c_client, RT5033_CHG_STAT_CTRL);
+	if (ret < 0) {
+		pr_info("Error : can't get charging status (%d)\n", ret);
+
+	}
+
+	if (charger->full_charged)
+		return POWER_SUPPLY_STATUS_FULL;
+
+	switch (ret & 0x30) {
+		case 0x00:
+			status = POWER_SUPPLY_STATUS_DISCHARGING;
+			break;
+		case 0x20:
+		case 0x10: // Only use flag "full_charged"
+			status = POWER_SUPPLY_STATUS_CHARGING;
+			break;
+		case 0x30:
+			status = POWER_SUPPLY_STATUS_NOT_CHARGING;
+			break;
+	}
+
+	/* TEMP_TEST : when OTG is enabled(charging_current -1), handle OTG func. */
+	if (charger->charging_current < 0) {
+		/* For OTG mode, RT5033 would still report "charging" */
+		status = POWER_SUPPLY_STATUS_DISCHARGING;
+		ret = rt5033_reg_read(charger->rt5033->i2c_client, RT5033_CHG_IRQ3);
+		if (ret & 0x80) {
+			pr_info("%s: otg overcurrent limit\n", __func__);
+#ifdef CONFIG_USB_HOST_NOTIFY
+			host_state_notify(&host_noti_pdata->ndev,
+					NOTIFY_HOST_OVERCURRENT);
+#endif
+			rt5033_charger_otg_control(charger, false);
+		}
+
+	}
+
+	return status;
+}
+
+static int rt5033_get_charge_type(struct i2c_client *iic)
+{
+	int status = POWER_SUPPLY_CHARGE_TYPE_UNKNOWN;
+	int ret;
+
+	ret = rt5033_reg_read(iic, RT5033_CHG_STAT_CTRL);
+	if (ret < 0)
+		dev_err(&iic->dev, "%s fail\n", __func__);
+
+	switch (ret & 0x40) {
+		case 0x40:
+			status = POWER_SUPPLY_CHARGE_TYPE_FAST;
+			break;
+		default:
+			/* pre-charge mode */
+			status = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
+			break;
+	}
+
+	return status;
+}
+
+static int rt5033_get_charging_health(struct rt5033_charger_data *charger)
+{
+	int ret = rt5033_reg_read(charger->rt5033->i2c_client, RT5033_CHG_STAT_CTRL);
+
+	if (ret < 0)
+		return POWER_SUPPLY_HEALTH_UNKNOWN;
+
+	/* Boost mode = 1 or PWR ready = 1*/
+	if (ret & (0x03 << 2)) {
+		charger->ovp = false;
+		charger->unhealth_cnt = 0;
+		return POWER_SUPPLY_HEALTH_GOOD;
+	}
+	charger->unhealth_cnt++;
+	if (charger->unhealth_cnt < HEALTH_DEBOUNCE_CNT)
+		return POWER_SUPPLY_HEALTH_GOOD;
+
+	charger->unhealth_cnt = HEALTH_DEBOUNCE_CNT;
+	if (charger->ovp)
+		return POWER_SUPPLY_HEALTH_OVERVOLTAGE;
+	return POWER_SUPPLY_HEALTH_UNDERVOLTAGE;
+}
+
+static int sec_chg_get_property(struct power_supply *psy,
+		enum power_supply_property psp,
+		union power_supply_propval *val)
+{
+	int chg_curr, aicr;
+	struct rt5033_charger_data *charger =
+		container_of(psy, struct rt5033_charger_data, psy_chg);
+
+	switch (psp) {
+		case POWER_SUPPLY_PROP_ONLINE:
+			val->intval = charger->charging_current ? 1 : 0;
+			break;
+		case POWER_SUPPLY_PROP_STATUS:
+			val->intval = rt5033_get_charging_status(charger);
+			break;
+		case POWER_SUPPLY_PROP_HEALTH:
+			val->intval = rt5033_get_charging_health(charger);
+			break;
+		case POWER_SUPPLY_PROP_CURRENT_MAX:
+			val->intval = 2000;
+			break;
+		case POWER_SUPPLY_PROP_CURRENT_NOW:
+			if (charger->charging_current) {
+				aicr = rt5033_get_input_current_limit(charger->rt5033->i2c_client);
+				chg_curr = rt5033_get_fast_charging_current(charger->rt5033->i2c_client);
+				val->intval = MINVAL(aicr, chg_curr);
+			} else
+				val->intval = 0;
+			break;
+		case POWER_SUPPLY_PROP_CHARGE_TYPE:
+			val->intval = rt5033_get_charge_type(charger->rt5033->i2c_client);
+			break;
+		default:
+			return -EINVAL;
+	}
+
+	return 0;
+}
+
+static int sec_chg_set_property(struct power_supply *psy,
+		enum power_supply_property psp,
+		const union power_supply_propval *val)
+{
+	struct rt5033_charger_data *charger =
+		container_of(psy, struct rt5033_charger_data, psy_chg);
+
+	int eoc;
+	int previous_cable_type = charger->cable_type;
+
+	switch (psp) {
+		case POWER_SUPPLY_PROP_STATUS:
+			charger->status = val->intval;
+			break;
+			/* val->intval : type */
+		case POWER_SUPPLY_PROP_ONLINE:
+			charger->cable_type = val->intval;
+			if (charger->cable_type == POWER_SUPPLY_TYPE_BATTERY ||
+					charger->cable_type == POWER_SUPPLY_TYPE_UNKNOWN) {
+				pr_info("%s:[BATT] Type Battery\n", __func__);
+				rt5033_enable_charger_switch(charger, 0);
+
+				if (previous_cable_type == POWER_SUPPLY_TYPE_OTG)
+					rt5033_charger_otg_control(charger, false);
+			} else if (charger->cable_type == POWER_SUPPLY_TYPE_OTG) {
+				pr_info("%s: OTG mode\n", __func__);
+				rt5033_charger_otg_control(charger, true);
+			} else {
+				pr_info("%s:[BATT] Set charging"
+						", Cable type = %d\n", __func__, charger->cable_type);
+				/* Enable charger */
+				rt5033_configure_charger(charger);
+			}
+#if EN_TEST_READ
+			msleep(100);
+			rt5033_test_read(charger->rt5033->i2c_client);
+#endif
+			break;
+		case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
+		case POWER_SUPPLY_PROP_CURRENT_NOW:
+			/* set charging current */
+			if (charger->is_charging) {
+				/* decrease the charging current according to siop level */
+				charger->siop_level = val->intval;
+				pr_info("%s:SIOP level = %d, chg current = %d\n", __func__,
+						val->intval, charger->charging_current);
+				eoc = rt5033_get_current_eoc_setting(charger);
+				rt5033_set_charging_current(charger, eoc, 0);
+			}
+			break;
+		case POWER_SUPPLY_PROP_POWER_NOW:
+			eoc = rt5033_get_current_eoc_setting(charger);
+			pr_info("%s:Set Power Now -> chg current = %d mA, eoc = %d mA\n", __func__,
+					val->intval, eoc);
+			rt5033_set_charging_current(charger, eoc, 0);
+			break;
+		case POWER_SUPPLY_PROP_CHARGE_OTG_CONTROL:
+			rt5033_charger_otg_control(charger, val->intval);
+			break;
+		default:
+			return -EINVAL;
+	}
+
+	return 0;
+}
+
+ssize_t rt5033_chg_show_attrs(struct device *dev,
+		const ptrdiff_t offset, char *buf)
+{
+	struct power_supply *psy = dev_get_drvdata(dev);
+	struct rt5033_charger_data *charger =
+		container_of(psy, struct rt5033_charger_data, psy_chg);
+	int i = 0;
+	char *str = NULL;
+
+	switch (offset) {
+		case CHG_REG:
+			i += scnprintf(buf + i, PAGE_SIZE - i, "%x\n",
+					charger->reg_addr);
+			break;
+		case CHG_DATA:
+			i += scnprintf(buf + i, PAGE_SIZE - i, "%x\n",
+					charger->reg_data);
+			break;
+		case CHG_REGS:
+			str = kzalloc(sizeof(char) * 256, GFP_KERNEL);
+			if (!str)
+				return -ENOMEM;
+
+			rt5033_read_regs(charger->rt5033->i2c_client, str);
+			i += scnprintf(buf + i, PAGE_SIZE - i, "%s\n",
+					str);
+
+			kfree(str);
+			break;
+		default:
+			i = -EINVAL;
+			break;
+	}
+
+	return i;
+}
+
+ssize_t rt5033_chg_store_attrs(struct device *dev,
+		const ptrdiff_t offset,
+		const char *buf, size_t count)
+{
+	struct power_supply *psy = dev_get_drvdata(dev);
+	struct rt5033_charger_data *charger =
+		container_of(psy, struct rt5033_charger_data, psy_chg);
+
+	int ret = 0;
+	int x = 0;
+	uint8_t data = 0;
+
+	switch (offset) {
+		case CHG_REG:
+			if (sscanf(buf, "%x\n", &x) == 1) {
+				charger->reg_addr = x;
+				data = rt5033_reg_read(charger->rt5033->i2c_client,
+						charger->reg_addr);
+				charger->reg_data = data;
+				dev_dbg(dev, "%s: (read) addr = 0x%x, data = 0x%x\n",
+						__func__, charger->reg_addr, charger->reg_data);
+				ret = count;
+			}
+			break;
+		case CHG_DATA:
+			if (sscanf(buf, "%x\n", &x) == 1) {
+				data = (u8)x;
+
+				dev_dbg(dev, "%s: (write) addr = 0x%x, data = 0x%x\n",
+						__func__, charger->reg_addr, data);
+				ret = rt5033_reg_write(charger->rt5033->i2c_client,
+						charger->reg_addr, data);
+				if (ret < 0) {
+					dev_dbg(dev, "I2C write fail Reg0x%x = 0x%x\n",
+							(int)charger->reg_addr, (int)data);
+				}
+				ret = count;
+			}
+			break;
+		default:
+			ret = -EINVAL;
+			break;
+	}
+	return ret;
+}
+
+struct rt5033_chg_irq_handler {
+	char *name;
+	int irq_index;
+	irqreturn_t (*handler)(int irq, void *data);
+};
+
+#if EN_BAD_ADP_IRQ
+
+static void rt5033chg_activate_bad_adp(
+		struct work_struct *work)
+{
+	rt5033_charger_data_t *charger =
+		container_of(to_delayed_work(work),
+				rt5033_charger_data_t,
+				activate_bad_adp_work);
+#if ENABLE_MIVR
+	/* Restore MIVR setting */
+	rt5033_set_mivr_level(charger);
+#endif
+	/* Set Reg0x07[5] = 0 -> enable bad adaptor detection */
+	rt5033_clr_bits(charger->rt5033->i2c_client,
+			RT5033_EOC_CTRL, (1 << 5));
+}
+
+static irqreturn_t rt5033_chg_bad_adp_irq_handler(int irq,
+		void *data)
+{
+	struct rt5033_charger_data *info = data;
+	cancel_delayed_work(&info->activate_bad_adp_work);
+	pr_info("%s : Bad adaptor : enable MIVR temporarily\n",
+			__func__);
+	pr_info("%s : set MIVR = 4200mV\n", __func__);
+	rt5033_assign_bits(info->rt5033->i2c_client,
+			RT5033_CHG_CTRL4, RT5033_MIVR_MASK,
+			RT5033_MIVR_4200MV << RT5033_MIVR_SHIFT);
+	/* Disable bad adaptor detection */
+	rt5033_set_bits(info->rt5033->i2c_client,
+			RT5033_EOC_CTRL, (1 << 5));
+	queue_delayed_work(info->wq, &info->activate_bad_adp_work,
+			msecs_to_jiffies(BADADP_RESTART_TIMER));
+
+	return IRQ_HANDLED;
+}
+#endif /* EN_BAD_ADP_IRQ */
+
+#if EN_OVP_IRQ
+static irqreturn_t rt5033_chg_vin_ovp_irq_handler(int irq, void *data)
+{
+	struct rt5033_charger_data *info = data;
+	union power_supply_propval value;
+	int status;
+	/* Delay 100ms for debounce */
+	msleep(100);
+	status = rt5033_reg_read(info->rt5033->i2c_client,
+			RT5033_CHG_STAT_CTRL);
+
+	/* PWR ready = 0*/
+	if ((status & (0x04)) == 0) {
+		/* No need to disable charger,
+		 * * H/W will do it automatically */
+		info->unhealth_cnt = HEALTH_DEBOUNCE_CNT;
+		info->ovp = true;
+		pr_info("%s: OVP triggered\n", __func__);
+		value.intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
+		psy_do_property("battery", set,
+				POWER_SUPPLY_PROP_HEALTH, value);
+	} else {
+		info->unhealth_cnt = 0;
+		info->ovp = false;
+	}
+
+	return IRQ_HANDLED;
+}
+#endif /* EN_OVP_IRQ */
+
+#if EN_IEOC_IRQ
+static irqreturn_t rt5033_chg_ieoc_irq_handler(int irq, void *data)
+{
+	struct rt5033_charger_data *info = data;
+	struct i2c_client *iic = info->rt5033->i2c_client;
+	int eoc_reg;
+	union power_supply_propval value;
+	cancel_delayed_work(&info->eoc_timeout_work);
+	mutex_lock(&info->io_lock);
+	info->eoc_cnt++;
+	mutex_unlock(&info->io_lock);
+	pr_info("%s : EOC CNT = %d / %d\n", __func__,
+			info->eoc_cnt, EOC_DEBOUNCE_CNT);
+	if (info->eoc_cnt >= EOC_DEBOUNCE_CNT) {
+		/* set full charged flag
+		 * until TA/USB unplug event / stop charging by PSY
+		 * / recharging event
+		 */
+		pr_info("%s : Full charged\n", __func__);
+		info->full_charged = true;
+		info->eoc_cnt = 0;
+		value.intval = POWER_SUPPLY_STATUS_FULL;
+		psy_do_property("battery", set,
+				POWER_SUPPLY_PROP_STATUS, value);
+	} else {
+		pr_info("%s : Reset EOC detection\n", __func__);
+		msleep(10);
+		/* Reset EOC loop, and make it re-detect */
+		mutex_lock(&info->io_lock);
+		eoc_reg = rt5033_reg_read(iic, RT5033_CHG_CTRL4);
+		if (eoc_reg < 0)
+			pr_err("error : rt5033 i2c read failed...\n");
+		rt5033_set_bits(iic, RT5033_UUG, 0x80); // EN sinking
+		msleep(10); // 10ms
+		rt5033_clr_bits(iic, RT5033_UUG, 0x80); // DIS sinking
+		/* Disable EOC function */
+		rt5033_reg_write(iic, RT5033_CHG_CTRL4, (~RT5033_IEOC_MASK) & eoc_reg);
+		/* set EOC RESET */
+		rt5033_set_bits(iic, RT5033_EOC_CTRL, RT5033_EOC_RESET_MASK);
+		/* clear EOC RESET */
+		rt5033_clr_bits(iic, RT5033_EOC_CTRL, RT5033_EOC_RESET_MASK);
+		/* Restore EOC setting */
+		rt5033_reg_write(iic, RT5033_CHG_CTRL4, eoc_reg);
+		mutex_unlock(&info->io_lock);
+		msleep(EOC_SLEEP);
+		queue_delayed_work(info->wq, &info->eoc_timeout_work,
+				msecs_to_jiffies(EOC_TIMEOUT));
+	}
+	return IRQ_HANDLED;
+}
+#endif /* EN_IEOC_IRQ */
+
+#if EN_RECHG_REQ_IRQ
+static irqreturn_t rt5033_chg_rechg_request_irq_handler(int irq, void *data)
+{
+	struct rt5033_charger_data *info = data;
+	pr_info("%s: Recharging requesting\n", __func__);
+
+	info->full_charged = false;
+	info->eoc_cnt = 0;
+
+	return IRQ_HANDLED;
+}
+#endif /* EN_RECHG_REQ_IRQ */
+
+#if EN_TR_IRQ
+static irqreturn_t rt5033_chg_otp_tr_irq_handler(int irq, void *data)
+{
+	pr_info("%s : Over temperature : thermal regulation loop active\n",
+			__func__);
+	// if needs callback, do it here
+	return IRQ_HANDLED;
+}
+#endif
+
+const struct rt5033_chg_irq_handler rt5033_chg_irq_handlers[] = {
+#if EN_BAD_ADP_IRQ
+	{
+		.name = "BAD ADAPTOR",
+		.handler = rt5033_chg_bad_adp_irq_handler,
+		.irq_index = RT5033_ADPBAD_IRQ,
+	},
+#endif
+#if EN_OVP_IRQ
+	{
+		.name = "VIN_OVP",
+		.handler = rt5033_chg_vin_ovp_irq_handler,
+		.irq_index = RT5033_VINOVPI_IRQ,
+	},
+#endif /* EN_OVP_IRQ */
+#if EN_IEOC_IRQ
+	{
+		.name = "IEOC",
+		.handler = rt5033_chg_ieoc_irq_handler,
+		.irq_index = RT5033_IEOC_IRQ,
+	},
+#endif /* EN_IEOC_IRQ */
+#if EN_RECHG_REQ_IRQ
+	{
+		.name = "RECHG_RQUEST",
+		.handler = rt5033_chg_rechg_request_irq_handler,
+		.irq_index = RT5033_CHRCHGI_IRQ,
+	},
+#endif /* EN_RECHG_REQ_IRQ*/
+#if EN_TR_IRQ
+	{
+		.name = "OTP ThermalRegulation",
+		.handler = rt5033_chg_otp_tr_irq_handler,
+		.irq_index = RT5033_CHTREGI_IRQ,
+	},
+#endif /* EN_TR_IRQ */
+
+#if EN_BST_IRQ
+	{
+		.name = "OTG Low Batt",
+		.handler = rt5033_chg_otg_fail_irq_handler,
+		.irq_index = RT5033_BSTLOWVI_IRQ,
+	},
+	{
+		.name = "OTG Over Load",
+		.handler = rt5033_chg_otg_fail_irq_handler,
+		.irq_index = RT5033_BSTOLI_IRQ,
+	},
+	{
+		.name = "OTG OVP",
+		.handler = rt5033_chg_otg_fail_irq_handler,
+		.irq_index = RT5033_BSTVMIDOVP_IRQ,
+	},
+#endif /* EN_BST_IRQ */
+};
+
+static int register_irq(struct platform_device *pdev,
+		struct rt5033_charger_data *info)
+{
+	int irq;
+	int i, j;
+	int ret;
+	const struct rt5033_chg_irq_handler *irq_handler = rt5033_chg_irq_handlers;
+	const char *irq_name;
+	for (i = 0; i < ARRAY_SIZE(rt5033_chg_irq_handlers); i++) {
+		irq_name = rt5033_get_irq_name_by_index(irq_handler[i].irq_index);
+		irq = platform_get_irq_byname(pdev, irq_name);
+		ret = request_threaded_irq(irq, NULL, irq_handler[i].handler,
+				IRQF_ONESHOT | IRQF_TRIGGER_RISING |
+				IRQF_NO_SUSPEND, irq_name, info);
+		if (ret < 0) {
+			pr_err("%s : Failed to request IRQ (%s): #%d: %d\n",
+					__func__, irq_name, irq, ret);
+			goto err_irq;
+		}
+
+		pr_info("%s : Register IRQ%d(%s) successfully\n",
+				__func__, irq, irq_name);
+	}
+
+	return 0;
+err_irq:
+	for (j = 0; j < i; j++) {
+		irq_name = rt5033_get_irq_name_by_index(irq_handler[j].irq_index);
+		irq = platform_get_irq_byname(pdev, irq_name);
+		free_irq(irq, info);
+	}
+
+	return ret;
+}
+
+static void unregister_irq(struct platform_device *pdev,
+		struct rt5033_charger_data *info)
+{
+	int irq;
+	int i;
+	const char *irq_name;
+	const struct rt5033_chg_irq_handler *irq_handler = rt5033_chg_irq_handlers;
+
+	for (i = 0; i < ARRAY_SIZE(rt5033_chg_irq_handlers); i++) {
+		irq_name = rt5033_get_irq_name_by_index(irq_handler[i].irq_index);
+		irq = platform_get_irq_byname(pdev, irq_name);
+		free_irq(irq, info);
+	}
+}
+
+
+#ifdef CONFIG_OF
+static int sec_bat_read_u32_index_dt(const struct device_node *np,
+		const char *propname,
+		u32 index, u32 *out_value)
+{
+	struct property *prop = of_find_property(np, propname, NULL);
+	u32 len = (index + 1) * sizeof(*out_value);
+
+	if (!prop)
+		return (-EINVAL);
+	if (!prop->value)
+		return (-ENODATA);
+	if (len > prop->length)
+		return (-EOVERFLOW);
+
+	*out_value = be32_to_cpup(((__be32 *)prop->value) + index);
+
+	return 0;
+}
+
+static int rt5033_charger_parse_dt(struct device *dev,
+		struct rt5033_charger_platform_data *pdata)
+{
+	struct device_node *np = dev->of_node;
+	const u32 *p;
+	int ret, i, len;
+	const char *charger_name = "sec-charger";
+
+	if (of_find_property(np, "is_750kHz_switching", NULL))
+		pdata->is_750kHz_switching = 1;
+	if (of_find_property(np, "is_fixed_switching", NULL))
+		pdata->is_fixed_switching = 1;
+	pr_info("%s : is_750kHz_switching = %d\n", __func__,
+			pdata->is_750kHz_switching);
+	pr_info("%s : is_fixed_switching = %d\n", __func__,
+			pdata->is_fixed_switching);
+
+	np = of_find_node_by_name(NULL, "charger");
+	if (!np) {
+		pr_info("%s : np NULL\n", __func__);
+		return -ENODATA;
+	}
+	ret = of_property_read_u32(np, "battery,chg_float_voltage",
+			&pdata->chg_float_voltage);
+	if (ret < 0) {
+		pr_info("%s : cannot get chg float voltage\n", __func__);
+		return -ENODATA;
+	}
+
+	of_property_read_string(np, "battery,charger_name", &charger_name);
+	len = strlen(charger_name);
+	pdata->charger_name = devm_kzalloc(dev, len + 1, GFP_KERNEL);
+	strcpy(pdata->charger_name, charger_name);
+
+	p = of_get_property(np, "battery,input_current_limit", &len);
+
+	len = len / sizeof(u32);
+
+	pdata->charging_current_table =
+		kzalloc(sizeof(sec_charging_current_t) * len, GFP_KERNEL);
+
+	for (i = 0; i < len; i++) {
+		ret = sec_bat_read_u32_index_dt(np,
+				"battery,input_current_limit", i,
+				&pdata->charging_current_table[i].input_current_limit);
+		ret = sec_bat_read_u32_index_dt(np,
+				"battery,fast_charging_current", i,
+				&pdata->charging_current_table[i].fast_charging_current);
+		ret = sec_bat_read_u32_index_dt(np,
+				"battery,full_check_current_1st", i,
+				&pdata->charging_current_table[i].full_check_current_1st);
+		ret = sec_bat_read_u32_index_dt(np,
+				"battery,full_check_current_2nd", i,
+				&pdata->charging_current_table[i].full_check_current_2nd);
+	}
+	dev_info(dev, "rt5033 charger parse dt retval = %d\n", ret);
+	return ret;
+}
+
+static struct of_device_id rt5033_charger_match_table[] = {
+	{ .compatible = "richtek,rt5033-charger",},
+	{},
+};
+#else
+static int rt5033_charger_parse_dt(struct device *dev,
+		struct rt5033_charger_platform_data *pdata)
+{
+	return -ENOSYS;
+}
+#define rt5033_charger_match_table NULL
+#endif /* CONFIG_OF */
+
+static void rt5033chg_eoc_timeout_reset(
+		struct work_struct *work)
+{
+	rt5033_charger_data_t *charger =
+		container_of(to_delayed_work(work),
+				rt5033_charger_data_t,
+				eoc_timeout_work);
+	mutex_lock(&charger->io_lock);
+	charger->eoc_cnt = 0;
+	mutex_unlock(&charger->io_lock);
+}
+
+
+static int rt5033_charger_probe(struct platform_device *pdev)
+{
+	rt5033_mfd_chip_t *chip = dev_get_drvdata(pdev->dev.parent);
+	struct rt5033_mfd_platform_data *mfd_pdata = dev_get_platdata(chip->dev);
+	struct rt5033_charger_data *charger;
+	int ret = 0;
+	pr_info("%s:[BATT] RT5033 Charger driver probe\n", __func__);
+	charger = kzalloc(sizeof(*charger), GFP_KERNEL);
+	if (!charger)
+		return -ENOMEM;
+
+#ifdef CONFIG_OF
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(3,10,0))
+	if (pdev->dev.parent->of_node) {
+		pdev->dev.of_node = of_find_compatible_node(
+				of_node_get(pdev->dev.parent->of_node), NULL,
+				rt5033_charger_match_table[0].compatible);
+	}
+#endif
+#endif
+	mutex_init(&charger->io_lock);
+	charger->wq = create_workqueue("rt5033chg_workqueue");
+	INIT_DELAYED_WORK(&charger->eoc_timeout_work,
+			rt5033chg_eoc_timeout_reset);
+#if EN_BAD_ADP_IRQ
+	INIT_DELAYED_WORK(&charger->activate_bad_adp_work,
+			rt5033chg_activate_bad_adp);
+#endif /* EN_BAD_ADP_IRQ */
+	charger->rt5033 = chip;
+	if (pdev->dev.of_node) {
+		charger->pdata = devm_kzalloc(&pdev->dev, sizeof(*(charger->pdata)),
+				GFP_KERNEL);
+		if (!charger->pdata) {
+			dev_err(&pdev->dev, "Failed to allocate memory\n");
+			ret = -ENOMEM;
+			goto err_parse_dt_nomem;
+		}
+		ret = rt5033_charger_parse_dt(&pdev->dev, charger->pdata);
+		if (ret < 0)
+			goto err_parse_dt;
+	} else
+		charger->pdata = mfd_pdata->charger_platform_data;
+
+	platform_set_drvdata(pdev, charger);
+	if (charger->pdata->charger_name == NULL)
+		charger->pdata->charger_name = "sec-charger";
+
+	charger->psy_chg.name           = charger->pdata->charger_name;
+	charger->psy_chg.type           = POWER_SUPPLY_TYPE_UNKNOWN;
+	charger->psy_chg.get_property   = sec_chg_get_property;
+	charger->psy_chg.set_property   = sec_chg_set_property;
+	charger->psy_chg.properties     = sec_charger_props;
+	charger->psy_chg.num_properties = ARRAY_SIZE(sec_charger_props);
+
+	charger->siop_level = 100;
+	rt5033_chg_init(charger);
+
+	ret = power_supply_register(&pdev->dev, &charger->psy_chg);
+	if (ret) {
+		pr_err("%s: Failed to Register psy_chg\n", __func__);
+		goto err_power_supply_register;
+	}
+	ret = register_irq(pdev, charger);
+	if (ret < 0)
+		goto err_reg_irq;
+
+	rt5033_test_read(charger->rt5033->i2c_client);
+	pr_info("%s:[BATT] RT5033 charger driver loaded OK\n", __func__);
+
+	return 0;
+err_reg_irq:
+	power_supply_unregister(&charger->psy_chg);
+err_power_supply_register:
+err_parse_dt:
+err_parse_dt_nomem:
+	destroy_workqueue(charger->wq);
+	mutex_destroy(&charger->io_lock);
+	kfree(charger);
+	return ret;
+}
+
+static int rt5033_charger_remove(struct platform_device *pdev)
+{
+	struct rt5033_charger_data *charger =
+		platform_get_drvdata(pdev);
+	unregister_irq(pdev, charger);
+	power_supply_unregister(&charger->psy_chg);
+	destroy_workqueue(charger->wq);
+	mutex_destroy(&charger->io_lock);
+	kfree(charger);
+	return 0;
+}
+
+#if defined CONFIG_PM
+static int rt5033_charger_suspend(struct device *dev)
+{
+	return 0;
+}
+
+static int rt5033_charger_resume(struct device *dev)
+{
+	return 0;
+}
+#else
+#define rt5033_charger_suspend NULL
+#define rt5033_charger_resume NULL
+#endif
+
+static void rt5033_charger_shutdown(struct device *dev)
+{
+	pr_info("%s: RT5033 Charger driver shutdown\n", __func__);
+}
+
+static SIMPLE_DEV_PM_OPS(rt5033_charger_pm_ops, rt5033_charger_suspend,
+		rt5033_charger_resume);
+
+static struct platform_driver rt5033_charger_driver = {
+	.driver		= {
+		.name	= "rt5033-charger",
+		.owner	= THIS_MODULE,
+		.of_match_table = rt5033_charger_match_table,
+		.pm 	= &rt5033_charger_pm_ops,
+		.shutdown = rt5033_charger_shutdown,
+	},
+	.probe		= rt5033_charger_probe,
+	.remove		= rt5033_charger_remove,
+};
+
+static int __init rt5033_charger_init(void)
+{
+	int ret = 0;
+
+	ret = platform_driver_register(&rt5033_charger_driver);
+
+	return ret;
+}
+subsys_initcall(rt5033_charger_init);
+
+static void __exit rt5033_charger_exit(void)
+{
+	platform_driver_unregister(&rt5033_charger_driver);
+}
+module_exit(rt5033_charger_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Patrick Chang <patrick_chang@richtek.com");
+MODULE_DESCRIPTION("Charger driver for RT5033");