Initial file dump from open source releaseHEADmaster

1 files changed, 2022 insertions, 0 deletions

diff --git a/drivers/battery/smb358_charger.c b/drivers/battery/smb358_charger.c
new file mode 100755
index 00000000..a6b0117b
--- /dev/null
+++ b/drivers/battery/smb358_charger.c
@@ -0,0 +1,2022 @@
+/*
+ *  smb358_charger.c
+ *  Samsung SMB358 Charger Driver
+ *
+ *  Copyright (C) 2012 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.
+ */
+
+#define DEBUG
+
+#include <linux/battery/sec_charger.h>
+
+#include <linux/debugfs.h>
+#include <linux/seq_file.h>
+#include <linux/of_gpio.h>
+
+#ifndef SLOW_CHARGING_CURRENT_STANDARD
+
+#if defined(CONFIG_MACH_HEAT_AIO)
+#define SLOW_CHARGING_CURRENT_STANDARD 400
+#else
+#define SLOW_CHARGING_CURRENT_STANDARD 1000
+#endif
+
+#endif
+
+static int smb358_i2c_write(struct i2c_client *client,
+				int reg, u8 *buf)
+{
+	int ret;
+	ret = i2c_smbus_write_i2c_block_data(client, reg, 1, buf);
+	if (ret < 0)
+		dev_err(&client->dev, "%s: Error(%d)\n", __func__, ret);
+	return ret;
+}
+
+static int smb358_i2c_read(struct i2c_client *client,
+				int reg, u8 *buf)
+{
+	int ret;
+	ret = i2c_smbus_read_i2c_block_data(client, reg, 1, buf);
+	if (ret < 0)
+		dev_err(&client->dev, "%s: Error(%d)\n", __func__, ret);
+	return ret;
+}
+
+/*static void smb358_i2c_write_array(struct i2c_client *client,
+				u8 *buf, int size)
+{
+	int i;
+	for (i = 0; i < size; i += 3)
+		smb358_i2c_write(client, (u8) (*(buf + i)), (buf + i) + 1);
+}*/
+
+static int smb358_update_reg(struct i2c_client *client, int reg, u8 data)
+{
+	int ret;
+	u8 r_data = 0;
+	u8 w_data = 0;
+	u8 o_data = data;
+
+	ret = smb358_i2c_read(client, reg, &r_data);
+	if (ret < 0) {
+		dev_err(&client->dev, "%s: error - read(%d)\n", __func__, ret);
+		goto error;
+	}
+
+	w_data  = r_data | data;
+	ret = smb358_i2c_write(client, reg, &w_data);
+	if (ret < 0) {
+		dev_err(&client->dev, "%s: error - write(%d)\n", __func__, ret);
+		goto error;
+	}
+
+	ret = smb358_i2c_read(client, reg, &data);
+	if (ret < 0) {
+		dev_err(&client->dev, "%s: error - read(%d)\n", __func__, ret);
+		goto error;
+	}
+
+	dev_dbg(&client->dev,
+		"%s: reg(0x%02x) 0x%02x : 0x%02x -> 0x%02x -> 0x%02x\n",
+		__func__, reg, o_data, r_data, w_data, data);
+
+error:
+	return ret;
+}
+
+static int smb358_clear_reg(struct i2c_client *client, int reg, u8 data)
+{
+	int ret;
+	u8 r_data = 0;
+	u8 w_data = 0;
+	u8 o_data = data;
+
+	ret = smb358_i2c_read(client, reg, &r_data);
+	if (ret < 0) {
+		dev_err(&client->dev, "%s: error - read(%d)\n", __func__, ret);
+		goto error;
+	}
+
+	w_data  = r_data & (~data);
+	ret = smb358_i2c_write(client, reg, &w_data);
+	if (ret < 0) {
+		dev_err(&client->dev, "%s: error - write(%d)\n", __func__, ret);
+		goto error;
+	}
+
+	ret = smb358_i2c_read(client, reg, &data);
+	if (ret < 0) {
+		dev_err(&client->dev, "%s: error - read(%d)\n", __func__, ret);
+		goto error;
+	}
+
+	dev_dbg(&client->dev,
+		"%s: reg(0x%02x)- 0x%02x : 0x%02x -> 0x%02x -> 0x%02x\n",
+		__func__, reg, o_data, r_data, w_data, data);
+
+error:
+	return ret;
+}
+
+static int smb358_volatile_writes(struct i2c_client *client, u8 value)
+{
+	int ret = 0;
+
+	if (value == SMB358_ENABLE_WRITE) {
+		ret = smb358_update_reg(client, SMB358_COMMAND_A, 0x80);
+		if (ret < 0) {
+			dev_err(&client->dev, "%s: error(%d)\n", __func__, ret);
+			goto error;
+		}
+		dev_dbg(&client->dev, "%s: ENABLED\n", __func__);
+	} else {
+		ret = smb358_clear_reg(client, SMB358_COMMAND_A, 0x80);
+		if (ret < 0) {
+			dev_err(&client->dev, "%s: error(%d)\n", __func__, ret);
+			goto error;
+		}
+		dev_dbg(&client->dev, "%s: DISABLED\n", __func__);
+	}
+
+error:
+	return ret;
+}
+
+static void smb358_set_command(struct i2c_client *client,
+				int reg, u8 datum)
+{
+	int val;
+	u8 after_data;
+
+	if (smb358_i2c_write(client, reg, &datum) < 0)
+		dev_err(&client->dev,
+			"%s : error!\n", __func__);
+
+	val = smb358_i2c_read(client, reg, &after_data);
+	if (val >= 0)
+		dev_info(&client->dev,
+			"%s : reg(0x%02x) 0x%02x => 0x%02x\n",
+			__func__, reg, datum, after_data);
+	else
+		dev_err(&client->dev, "%s : error!\n", __func__);
+}
+
+#if 0
+static void smb358_test_read(struct i2c_client *client)
+{
+	u8 data = 0;
+	u32 addr = 0;
+	for (addr = 0; addr <= 0x0f; addr++) {
+		smb358_i2c_read(client, addr, &data);
+		dev_dbg(&client->dev,
+			"%s : smb358 addr : 0x%02x data : 0x%02x\n",
+						__func__, addr, data);
+	}
+	for (addr = 0x30; addr <= 0x3f; addr++) {
+		smb358_i2c_read(client, addr, &data);
+		dev_dbg(&client->dev,
+			"%s : smb358 addr : 0x%02x data : 0x%02x\n",
+						__func__, addr, data);
+	}
+}
+#endif
+
+static void smb358_read_regs(struct i2c_client *client, char *str)
+{
+	u8 data = 0;
+	u32 addr = 0;
+
+	for (addr = 0; addr <= 0x0f; addr++) {
+		smb358_i2c_read(client, addr, &data);
+		sprintf(str+strlen(str), "0x%x, ", data);
+	}
+
+	/* "#" considered as new line in application */
+	sprintf(str+strlen(str), "#");
+
+	for (addr = 0x30; addr <= 0x3f; addr++) {
+		smb358_i2c_read(client, addr, &data);
+		sprintf(str+strlen(str), "0x%x, ", data);
+	}
+}
+
+static int smb358_get_aicl_current(u8 aicl_current)
+{
+	int data;
+
+	if (aicl_current <= 0x10)
+		data = 300;
+	else if (aicl_current <= 0x11)
+		data = 500;
+	else if (aicl_current <= 0x12)
+		data = 700;
+	else if (aicl_current <= 0x13)
+		data = 1000;
+	else if (aicl_current <= 0x14)
+		data = 1200;
+	else if (aicl_current <= 0x15)
+		data = 1300;
+	else if (aicl_current <= 0x16)
+		data = 1800;
+	else
+		data = 2000;
+
+	return data;
+}
+
+static int smb358_get_charging_status(struct i2c_client *client)
+{
+	int status = POWER_SUPPLY_STATUS_UNKNOWN;
+	u8 data_a = 0;
+	u8 data_b = 0;
+	u8 data_c = 0;
+	u8 data_d = 0;
+	u8 data_e = 0;
+	u8 therm_control_a = 0;
+	u8 other_control_a = 0;
+
+
+	/*smb358_test_read(client);*/
+
+	smb358_i2c_read(client, SMB358_STATUS_A, &data_a);
+	dev_dbg(&client->dev,
+		"%s : charger status A(0x%02x)\n", __func__, data_a);
+	smb358_i2c_read(client, SMB358_STATUS_B, &data_b);
+	dev_dbg(&client->dev,
+		"%s : charger status B(0x%02x)\n", __func__, data_b);
+	smb358_i2c_read(client, SMB358_STATUS_C, &data_c);
+	dev_dbg(&client->dev,
+		"%s : charger status C(0x%02x)\n", __func__, data_c);
+	smb358_i2c_read(client, SMB358_STATUS_D, &data_d);
+	dev_dbg(&client->dev,
+		"%s : charger status D(0x%02x)\n", __func__, data_d);
+	smb358_i2c_read(client, SMB358_STATUS_E, &data_e);
+	dev_dbg(&client->dev,
+		"%s : charger status E(0x%02x)\n", __func__, data_e);
+	smb358_i2c_read(client, SMB358_THERM_CONTROL_A, &therm_control_a);
+	dev_dbg(&client->dev,
+		"%s : THERM_CONTROL_A(0x%02x)\n", __func__, therm_control_a);
+	smb358_i2c_read(client, SMB358_OTHER_CONTROL_A, &other_control_a);
+	dev_dbg(&client->dev,
+		"%s : OTHER_CONTROL_A(0x%02x)\n", __func__, other_control_a);
+	/* At least one charge cycle terminated,
+	 * Charge current < Termination Current
+	 */
+	if (data_c & 0x20) {
+		/* top-off by full charging */
+		status = POWER_SUPPLY_STATUS_FULL;
+		goto charging_status_end;
+	}
+
+	/* Is enabled ? */
+	if (data_c & 0x01) {
+		/* check for 0x06 : no charging (0b00) */
+		/* not charging */
+		if (!(data_c & 0x06)) {
+			status = POWER_SUPPLY_STATUS_NOT_CHARGING;
+			goto charging_status_end;
+		} else {
+			status = POWER_SUPPLY_STATUS_CHARGING;
+			goto charging_status_end;
+		}
+	} else
+		status = POWER_SUPPLY_STATUS_DISCHARGING;
+
+charging_status_end:
+	return (int)status;
+}
+
+static int smb358_get_charging_health(struct i2c_client *client)
+{
+	int health = POWER_SUPPLY_HEALTH_GOOD;
+	u8 data_a = 0;
+	u8 data_b = 0;
+	u8 data_c = 0;
+	u8 data_d = 0;
+	u8 data_e = 0;
+
+	smb358_i2c_read(client, SMB358_STATUS_A, &data_a);
+	dev_dbg(&client->dev,
+		"%s : charger status A(0x%02x)\n", __func__, data_a);
+	smb358_i2c_read(client, SMB358_STATUS_B, &data_b);
+	dev_dbg(&client->dev,
+		"%s : charger status B(0x%02x)\n", __func__, data_b);
+	smb358_i2c_read(client, SMB358_STATUS_C, &data_c);
+	dev_dbg(&client->dev,
+		"%s : charger status C(0x%02x)\n", __func__, data_c);
+	smb358_i2c_read(client, SMB358_STATUS_D, &data_d);
+	dev_dbg(&client->dev,
+		"%s : charger status D(0x%02x)\n", __func__, data_d);
+	smb358_i2c_read(client, SMB358_STATUS_E, &data_e);
+	dev_dbg(&client->dev,
+		"%s : charger status E(0x%02x)\n", __func__, data_e);
+	smb358_i2c_read(client, SMB358_INTERRUPT_STATUS_E, &data_e);
+	dev_dbg(&client->dev,
+		"%s : charger interrupt status E(0x%02x)\n", __func__, data_e);
+
+	if (data_e & 0x01)
+		health = POWER_SUPPLY_HEALTH_UNDERVOLTAGE;
+	else if (data_e & 0x04)
+		health = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
+
+	return (int)health;
+}
+
+/*static void smb358_allow_volatile_writes(struct i2c_client *client)
+{
+	int val, reg;
+	u8 data;
+	reg = SMB358_COMMAND_A;
+	val = smb358_i2c_read(client, reg, &data);
+	if ((val >= 0) && !(data & 0x80)) {
+		dev_dbg(&client->dev,
+			"%s : reg(0x%02x): 0x%02x", __func__, reg, data);
+		data |= (0x1 << 7);
+		if (smb358_i2c_write(client, reg, &data) < 0)
+			dev_err(&client->dev, "%s : error!\n", __func__);
+		val = smb358_i2c_read(client, reg, &data);
+		if (val >= 0) {
+			data = (u8) data;
+			dev_dbg(&client->dev, " => 0x%02x\n", data);
+		}
+	}
+}*/
+
+static u8 smb358_get_float_voltage_data(int float_voltage)
+{
+	u8 data;
+
+	if (float_voltage < 3500)
+		data = 0;
+	else if(float_voltage <= 4340)
+		data = (float_voltage - 3500) / 20;
+	else if(float_voltage == 4350)
+		data = 0x2B; /* (4340 -3500)/20 + 1 */
+	else if(float_voltage <= 4500)
+		data = (float_voltage - 3500) / 20 + 1;
+	else
+		data = 51;
+
+	return data;
+}
+
+static u8 smb358_get_input_current_limit_data(
+			struct sec_charger_info *charger, int input_current)
+{
+	u8 data;
+
+	if (input_current <= 300)
+		data = 0x00;
+	else if (input_current <= 500)
+		data = 0x01;
+	else if (input_current <= 700)
+		data = 0x02;
+	else if (input_current <= 1000)
+		data = 0x03;
+	else if (input_current <= 1200)
+		data = 0x04;
+	else if (input_current <= 1500)
+		data = 0x05;
+	else if (input_current <= 1800)
+		data = 0x06;
+	else
+		data = 0x07;	/* set input current to 2000mA */
+
+	return (data << 4);
+}
+
+static u8 smb358_get_term_current_limit_data(
+			int termination_current)
+{
+	u8 data;
+
+	if (termination_current <= 30)
+		data = 0x00;
+	else if (termination_current <= 40)
+		data = 0x01;
+	else if (termination_current <= 60)
+		data = 0x02;
+	else if (termination_current <= 80)
+		data = 0x03;
+	else if (termination_current <= 100)
+		data = 0x04;
+	else if (termination_current <= 125)
+		data = 0x05;
+	else if (termination_current <= 150)
+		data = 0x06;
+	else
+		data = 0x07;	/* set termination current limit to 200mA */
+
+	return data;
+}
+
+static u8 smb358_get_fast_charging_current_data(
+			int fast_charging_current)
+{
+	u8 data;
+
+	if (fast_charging_current <= 200)
+		data = 0x00;
+	else if (fast_charging_current <= 450)
+		data = 0x01;
+	else if (fast_charging_current <= 600)
+		data = 0x02;
+	else if (fast_charging_current <= 900)
+		data = 0x03;
+	else if (fast_charging_current <= 1300)
+		data = 0x04;
+	else if (fast_charging_current <= 1500)
+		data = 0x05;
+	else if (fast_charging_current <= 1800)
+		data = 0x06;
+	else
+		data = 0x07;	/* set fast charging current to 2000mA */
+
+	return data << 5;
+}
+
+static void smb358_enter_suspend(struct i2c_client *client)
+{
+	u8 data = 0;
+
+	pr_info("%s: ENTER SUSPEND\n", __func__);
+	smb358_update_reg(client, SMB358_COMMAND_A, 0x80);
+	smb358_set_command(client, SMB358_PIN_ENABLE_CONTROL, 0x18);
+	data = (data | 0x4);
+	smb358_set_command(client, SMB358_COMMAND_A, data);
+}
+
+#if 0
+#if (defined(CONFIG_MACH_MILLET3G_EUR) || defined(CONFIG_MACH_MATISSE3G_OPEN) || defined(CONFIG_MACH_BERLUTI3G_EUR))
+static void smb358_aicl_calibrate(struct i2c_client *client)
+{
+
+	struct sec_charger_info *charger = i2c_get_clientdata(client);
+	int ret = 0;
+	u8 data = 0;
+	u8 count = 0;
+	u8 current_initial = 0;
+	u8 current_final = 0;
+
+	ret = smb358_i2c_read(client, SMB358_STATUS_E, &data);
+	if (ret < 0) {
+		dev_err(&client->dev, "%s: error - read(%d)\n", __func__, ret);
+	}
+
+	/* check If AICL complete */
+	if(data & 0x10){
+		current_initial = (data & 0x0F);
+
+		if((current_initial >= 0x04) && (current_initial <= 0x05)){
+			/* set 1000mA */
+			ret = smb358_i2c_read(client, SMB358_INPUT_CURRENTLIMIT, &data);
+			data = data & 0x0F;
+			data = data | 0x30;
+			smb358_set_command(client,SMB358_INPUT_CURRENTLIMIT, data);
+		}else{
+			/* set 1800mA */
+			ret = smb358_i2c_read(client, SMB358_INPUT_CURRENTLIMIT, &data);
+			data = data & 0x0F;
+			data = data | 0x60;
+			smb358_set_command(client,SMB358_INPUT_CURRENTLIMIT, data);
+		}
+
+		smb358_i2c_read(client, SMB358_INPUT_CURRENTLIMIT, &data);
+		current_final = (data & 0x0F);
+
+		dev_err(&charger->client->dev,
+			"%s: AICL calibration success! input current (%dmA) -> (%dmA) ! \n",
+			__func__,current_initial,current_final);
+		return;
+
+        }else{
+        /* Incase of AICL not complete check three times */
+		for(count=0 ;count < 3;count++)
+		{
+			msleep(300);
+			ret = smb358_i2c_read(client, SMB358_STATUS_E, &data);
+			if (ret < 0) {
+				dev_err(&client->dev, "%s: error - read(%d)\n", __func__, ret);
+			}
+
+			if(data & 0x10){
+				current_initial = (data & 0x0F);
+
+				if((current_initial >= 0x04) && (current_initial <= 0x05)){
+				/* set 1000mA */
+					ret = smb358_i2c_read(client, SMB358_INPUT_CURRENTLIMIT, &data);
+					data = data & 0x0F;
+					data = data | 0x30;
+					smb358_set_command(client,SMB358_INPUT_CURRENTLIMIT, data);
+				}else{
+				/* set 1800mA */
+					ret = smb358_i2c_read(client, SMB358_INPUT_CURRENTLIMIT, &data);
+					data = data & 0x0F;
+					data = data | 0x60;
+					smb358_set_command(client,SMB358_INPUT_CURRENTLIMIT, data);
+				}
+
+				smb358_i2c_read(client, SMB358_INPUT_CURRENTLIMIT, &data);
+				current_final = (data & 0x0F);
+
+				dev_err(&charger->client->dev,
+					"%s: AICL calibration success! input current (%dmA) -> (%dmA) ! \n",
+					__func__,current_initial,current_final);
+				return;
+			}else{
+				dev_err(&charger->client->dev,
+                                        "%s: AICL not complete \n",__func__);
+			}
+		}
+	}
+
+	dev_err(&charger->client->dev,
+		"%s: AICL calibration Failed! current (%dmA) ! \n",__func__,current_initial);
+	return;
+
+}
+#endif
+#endif
+
+static void smb358_check_slow_charging(struct work_struct *work)
+{
+	struct sec_charger_info *charger =
+		container_of(work, struct sec_charger_info, slow_work.work);
+
+	u8 i, aicl_data;
+	int aicl_current = 0;
+	union power_supply_propval val;
+
+	if (charger->pdata->chg_functions_setting &
+			SEC_CHARGER_NO_GRADUAL_CHARGING_CURRENT) {
+		pr_err("%s: aicl is disabled\n", __func__);
+		return;
+	}
+	if (charger->pdata->charging_current
+				[charger->cable_type].input_current_limit <= SLOW_CHARGING_CURRENT_STANDARD) {
+			charger->is_slow_charging = true;
+	} else {
+		for(i = 0; i < 20; i++) {
+			if (charger->cable_type ==
+					POWER_SUPPLY_TYPE_BATTERY) {
+				pr_info("%s: cable is removed\n", __func__);
+				return;
+			}
+			msleep(200);
+			smb358_i2c_read(charger->client, SMB358_STATUS_E, &aicl_data);
+			if (aicl_data & 0x10) { /* check AICL complete */
+				break;
+			}
+			if (i == 10) {
+				pr_info("%s: aicl not complete, retry\n", __func__);
+				/* disable AICL */
+				smb358_set_command(charger->client,
+						SMB358_VARIOUS_FUNCTIONS, 0x81);
+				/* enable AICL */
+				smb358_set_command(charger->client,
+						SMB358_VARIOUS_FUNCTIONS, 0x95);
+			}
+		}
+
+		aicl_data &= 0xF; /* get only AICL result field */
+		switch (aicl_data) {
+		case 0: /* AICL result 300mA */
+			aicl_current = 300;
+			break;
+		case 1: /* AICL result 500mA */
+			aicl_current = 500;
+			break;
+		case 2: /* AICL result 700mA */
+			aicl_current = 700;
+			break;
+		case 3: /* AICL result 1000mA */
+			aicl_current = 1000;
+			break;
+		case 4: /* AICL result 1200mA */
+			aicl_current = 1200;
+			break;
+		case 5: /* AICL result 1300mA */
+			aicl_current = 1300;
+			break;
+		case 6: /* AICL result 1800mA */
+			aicl_current = 1800;
+			break;
+		case 7: /* AICL result 2000mA */
+			aicl_current = 2000;
+			break;
+		default: /* etc */
+			aicl_current = 2000;
+			break;
+		}
+		if (aicl_current <= SLOW_CHARGING_CURRENT_STANDARD)
+			charger->is_slow_charging = true;
+		else
+			charger->is_slow_charging = false;
+	}
+
+	pr_info("%s: Slow(%d), aicl_current(%d), input_current(%d)\n",
+		__func__, charger->is_slow_charging, aicl_current, charger->pdata->charging_current
+			[charger->cable_type].input_current_limit);
+
+	psy_do_property("battery", set,
+		POWER_SUPPLY_PROP_CHARGE_TYPE, val);
+
+}
+static void smb358_charger_function_control(
+				struct i2c_client *client)
+{
+	struct sec_charger_info *charger = i2c_get_clientdata(client);
+	union power_supply_propval val, input_value;
+	int status;
+	u8 data;
+
+	psy_do_property("battery", get,
+		POWER_SUPPLY_PROP_STATUS, input_value);
+	status = input_value.intval;
+
+	charger->charging_current_max =
+		charger->pdata->charging_current[
+		charger->cable_type].input_current_limit;
+
+	charger->charging_current =
+		charger->pdata->charging_current[
+		charger->cable_type].fast_charging_current;
+
+	if (charger->charging_current < 0) {
+		dev_dbg(&client->dev,
+			"%s : OTG is activated. Ignore command!\n", __func__);
+		return;
+	}
+
+	psy_do_property("battery", get,
+		POWER_SUPPLY_PROP_HEALTH, input_value);
+	if (input_value.intval ==
+		POWER_SUPPLY_HEALTH_UNSPEC_FAILURE) {
+		pr_info("[SMB358] Unspec_failure, charger suspend\n");
+		smb358_enter_suspend(client);
+	}
+	else if (charger->cable_type ==
+		POWER_SUPPLY_TYPE_BATTERY) {
+		/* Charger Disabled */
+		smb358_set_command(client, SMB358_COMMAND_A, 0xc0);
+		if ((status == POWER_SUPPLY_STATUS_FULL) ||\
+			(input_value.intval == POWER_SUPPLY_HEALTH_OVERHEAT) ||\
+			(input_value.intval == POWER_SUPPLY_HEALTH_COLD))
+			return;
+		pr_info("[SMB358] Set the registers to the default configuration\n");
+		/* Set the registers to the default configuration */
+		smb358_set_command(client, SMB358_CHARGE_CURRENT, 0xFE);
+		smb358_set_command(client, SMB358_INPUT_CURRENTLIMIT, 0x74);
+		smb358_set_command(client, SMB358_VARIOUS_FUNCTIONS, 0xD7);
+		data = 0x00;
+		data |= smb358_get_float_voltage_data(charger->pdata->chg_float_voltage);
+		smb358_set_command(client, SMB358_FLOAT_VOLTAGE, data);
+		/* Disable Automatic Recharge */
+		smb358_set_command(client, SMB358_CHARGE_CONTROL, 0x84);
+		smb358_set_command(client, SMB358_PIN_ENABLE_CONTROL, 0x09);
+		smb358_set_command(client, SMB358_THERM_CONTROL_A, 0xF0);
+		smb358_set_command(client, SMB358_SYSOK_USB30_SELECTION, 0x08);
+		smb358_set_command(client, SMB358_OTHER_CONTROL_A, 0x01);
+		smb358_set_command(client, SMB358_OTG_TLIM_THERM_CONTROL, 0xF6);
+		smb358_set_command(client, SMB358_LIMIT_CELL_TEMPERATURE_MONITOR, 0xA5);
+		smb358_set_command(client, SMB358_STATUS_INTERRUPT, 0x00);
+		smb358_set_command(client, SMB358_COMMAND_B, 0x00);
+		if (charger->pdata->chg_irq) {
+			smb358_set_command(client, SMB358_STAT_TIMERS_CONTROL, 0x1F);
+			smb358_set_command(client, SMB358_FAULT_INTERRUPT, 0x0C);
+		} else {
+			smb358_set_command(client, SMB358_STAT_TIMERS_CONTROL, 0x0F);
+			smb358_set_command(client, SMB358_FAULT_INTERRUPT, 0x00);
+		}
+
+	} else {
+		int full_check_type;
+		psy_do_property("battery", get,
+			POWER_SUPPLY_PROP_CHARGE_NOW, val);
+		if (val.intval == SEC_BATTERY_CHARGING_1ST)
+			full_check_type = charger->pdata->full_check_type;
+		else
+			full_check_type = charger->pdata->full_check_type_2nd;
+
+		smb358_i2c_read(client, SMB358_COMMAND_A, &data);
+
+		if ((data & 0x10) && charger->pdata->vbus_ctrl_gpio) {
+			int level;
+			/* disable otg & charging */
+			smb358_clear_reg(client, SMB358_COMMAND_A, 0x12);
+
+			/* turn off vbus */
+			gpio_set_value(charger->pdata->vbus_ctrl_gpio, 1);
+			msleep(30);
+
+			level = gpio_get_value_cansleep(charger->pdata->vbus_ctrl_gpio);
+			pr_info("[SMB358] vbus ctrl gpio %d level %d\n", charger->pdata->vbus_ctrl_gpio, level);
+
+			/* turn on vbus */
+			gpio_set_value(charger->pdata->vbus_ctrl_gpio, 0);
+		}
+		/* [STEP - 1] ================================================
+                 * Volatile write permission(bit 7) - allow(1)
+                 * Charging Enable(bit 1) - Disabled(0, default)
+                 * STAT Output(bit 0) - Enabled(0)
+                */
+		if (data & 0x02) {
+			u8 status_c;
+			u8 status_e;
+			smb358_i2c_read(client, SMB358_STATUS_C, &status_c);
+			smb358_i2c_read(client, SMB358_STATUS_E, &status_e);
+			pr_info("[SMB358] status_c: 0x%x, status_e: 0x%x\n", status_c, status_e);
+
+			/* no charge or aicl not complete*/
+			if (((status_c & 0x06) == 0) || (status_e & 0x10) == 0)
+				smb358_set_command(client,
+						SMB358_COMMAND_A, 0xC0);
+		}
+
+                /* [STEP - 2] ================================================
+                 * USB 5/1(9/1.5) Mode(bit 1) - USB1/USB1.5(0), USB5/USB9(1)
+                 * USB/HC Mode(bit 0) - USB5/1 or USB9/1.5 Mode(0)
+                 *                      High-Current Mode(1)
+                */
+                switch (charger->cable_type) {
+		case POWER_SUPPLY_TYPE_UNKNOWN:
+		case POWER_SUPPLY_TYPE_MAINS:
+		case POWER_SUPPLY_TYPE_USB_CDP:
+		case POWER_SUPPLY_TYPE_MISC:
+		case POWER_SUPPLY_TYPE_WIRELESS:
+		case POWER_SUPPLY_TYPE_CARDOCK:
+		case POWER_SUPPLY_TYPE_UARTOFF:
+		case POWER_SUPPLY_TYPE_LAN_HUB:
+		case POWER_SUPPLY_TYPE_MHL_900:
+		case POWER_SUPPLY_TYPE_MHL_1500:
+		case POWER_SUPPLY_TYPE_SMART_NOTG:
+                    /* High-current mode */
+                    data = 0x03;
+			break;
+		case POWER_SUPPLY_TYPE_UPS:
+		case POWER_SUPPLY_TYPE_USB:
+		case POWER_SUPPLY_TYPE_USB_DCP:
+		case POWER_SUPPLY_TYPE_USB_ACA:
+		case POWER_SUPPLY_TYPE_MHL_500:
+		case POWER_SUPPLY_TYPE_MHL_USB:
+		case POWER_SUPPLY_TYPE_SMART_OTG:
+		case POWER_SUPPLY_TYPE_POWER_SHARING:
+			/* USB5 */
+			data = 0x02;
+			break;
+		default:
+			/* USB1 */
+			data = 0x00;
+			break;
+		}
+		smb358_set_command(client,
+			SMB358_COMMAND_B, data);
+
+
+		/* [STEP 3] Charge Current(0x00) ===============================
+		 * Set pre-charge current(bit 4:3) - 450mA(11)
+		 * Set fast charge current(bit 7:5)
+		 * Set termination current(bit 2:0)
+		*/
+		if (charger->siop_level < 100) {
+			charger->charging_current =
+				charger->charging_current * charger->siop_level / 100;
+		}
+		dev_info(&client->dev,
+			"%s : fast charging current (%dmA)\n",
+			__func__, charger->charging_current);
+
+		data = 0x18;
+		data |= smb358_get_fast_charging_current_data(
+			charger->charging_current);
+		switch (full_check_type) {
+		case SEC_BATTERY_FULLCHARGED_CHGGPIO:
+		case SEC_BATTERY_FULLCHARGED_CHGINT:
+		case SEC_BATTERY_FULLCHARGED_CHGPSY:
+			if (val.intval == SEC_BATTERY_CHARGING_1ST) {
+				dev_info(&client->dev,
+					"%s : termination current (%dmA)\n",
+					__func__, charger->pdata->charging_current[
+					charger->cable_type].full_check_current_1st);
+				data |= smb358_get_term_current_limit_data(
+					charger->pdata->charging_current[
+					charger->cable_type].full_check_current_1st);
+			} else {
+				dev_info(&client->dev,
+					"%s : termination current (%dmA)\n",
+					__func__, charger->pdata->charging_current[
+					charger->cable_type].full_check_current_2nd);
+				data |= smb358_get_term_current_limit_data(
+					charger->pdata->charging_current[
+					charger->cable_type].full_check_current_2nd);
+			}
+			break;
+		}
+		smb358_set_command(client,
+			SMB358_CHARGE_CURRENT, data);
+
+		/* [STEP - 4] =================================================
+		 * Enable(EN) Pin Control(bit 6) - i2c(0), Pin(1)
+		 * Pin control(bit 5) - active high(0), active low(1)
+		 * USB5/1/HC input State(bit3) - Dual-state input(1)
+		 * USB Input Pre-bias(bit 0) - Enable(1)
+		*/
+		data = 0x09;
+		if (charger->pdata->chg_gpio_en)
+			data |= 0x40;
+		if (charger->pdata->chg_polarity_en)
+			data |= 0x20;
+		smb358_set_command(client,
+			SMB358_PIN_ENABLE_CONTROL, data);
+
+		/* [STEP - 5] =============================================== */
+		dev_info(&client->dev, "%s : input current (%dmA)\n",
+			__func__, charger->pdata->charging_current
+			[charger->cable_type].input_current_limit);
+		/* Input current limit */
+		data = 0x00;
+		data |= smb358_get_input_current_limit_data(
+			charger,
+			charger->pdata->charging_current
+			[charger->cable_type].input_current_limit);
+		smb358_set_command(client,
+			SMB358_INPUT_CURRENTLIMIT, data);
+
+		/* [STEP - 6] =================================================
+		 * Input to System FET(bit 7) - Controlled by Register(1)
+		 * Max System voltage(bit 5) -  Vflt + 0.1v(0)
+		 * AICL(bit 4) - Enabled(1)
+		 * VCHG Function(bit 0) - Enabled(1)
+		 */
+		if (charger->pdata->chg_functions_setting &
+			SEC_CHARGER_NO_GRADUAL_CHARGING_CURRENT)
+			/* disable AICL */
+			smb358_set_command(client,
+				SMB358_VARIOUS_FUNCTIONS, 0x81);
+		else {
+			/* disable AICL */
+			smb358_set_command(client,
+				SMB358_VARIOUS_FUNCTIONS, 0x81);
+			/* enable AICL */
+			smb358_set_command(client,
+				SMB358_VARIOUS_FUNCTIONS, 0x95);
+		}
+
+		/* [STEP - 7] =================================================
+		 * Pre-charged to Fast-charge Voltage Threshold(Bit 7:6) - 2.3V
+		 * Float Voltage(bit 5:0)
+		*/
+		dev_dbg(&client->dev, "%s : float voltage (%dmV)\n",
+				__func__, charger->pdata->chg_float_voltage);
+		data = 0x00;
+		data |= smb358_get_float_voltage_data(
+			charger->pdata->chg_float_voltage);
+		smb358_set_command(client,
+			SMB358_FLOAT_VOLTAGE, data);
+
+		/* [STEP - 8] =================================================
+		 * Charge control
+		 * Automatic Recharge disable(bit 7),
+		 * Current Termination disable(bit 6),
+		 * BMD disable(bit 5:4),
+		 * INOK Output Configuration : Push-pull(bit 3)
+		 * AICL glitch filter duration : 20msec(bit 0)
+		 * APSD disable
+		*/
+		data = 0xC0;
+
+		switch (full_check_type) {
+		case SEC_BATTERY_FULLCHARGED_CHGGPIO:
+		case SEC_BATTERY_FULLCHARGED_CHGINT:
+		case SEC_BATTERY_FULLCHARGED_CHGPSY:
+			/* Enable Current Termination */
+			data &= 0xBF;
+			break;
+		}
+		smb358_set_command(client,
+			SMB358_CHARGE_CONTROL, data);
+
+		/* [STEP - 9] =================================================
+		 *  STAT active low(bit 7),
+		 *  Complete charge Timeout(bit 3:2) - Disabled(11)
+		 *  Pre-charge Timeout(bit 1:0) - Disable(11)
+		*/
+		smb358_set_command(client,
+			SMB358_STAT_TIMERS_CONTROL, 0x1F);
+
+#if defined(CONFIG_MACH_MATISSELTE_VZW)
+		/* [STEP - 10] =================================================
+		 * Mininum System Voltage(bit 6) - 3.15v(0)
+		 * Therm monitor(bit 4) - Disabled(1)
+		 * Soft Cold/Hot Temp Limit Behavior(bit 3:2, bit 1:0) -
+		 *   Charger Current + Float voltage Compensation(11)
+		*/
+		smb358_set_command(client,
+			SMB358_THERM_CONTROL_A, 0xB0);
+
+		/* [STEP - 11] ================================================
+		 * OTG/ID Pin Control(bit 7:6) - RID Disabled, OTG I2c(00)
+		 * Minimum System Voltage(bit 4) - 3.15V(0)
+		 * Low-Battery/SYSOK Voltage threshold(bit 3:0) - 2.5V(0001)
+		 *    if this bit is disabled,
+		 *    input current for system will be disabled
+		 */
+		smb358_set_command(client,
+			SMB358_OTHER_CONTROL_A, 0x11);
+#elif defined(CONFIG_MACH_CHAGALL_USC)
+		/* [STEP - 10] =================================================
+		 * Mininum System Voltage(bit 6) - 3.45v(0)
+		 * Therm monitor(bit 4) - Disabled(1)
+		 * Soft Cold/Hot Temp Limit Behavior(bit 3:2, bit 1:0) -
+		 *   Charger Current + Float voltage Compensation(11)
+		 */
+		smb358_set_command(client,
+				SMB358_THERM_CONTROL_A, 0xB0);
+
+		/* [STEP - 11] ================================================
+		 * OTG/ID Pin Control(bit 7:6) - RID Disabled, OTG I2c(00)
+		 * Minimum System Voltage(bit 4) - 3.45V(0)
+		 * Low-Battery/SYSOK Voltage threshold(bit 3:0) - 2.5V(0001)
+		 *    if this bit is disabled,
+		 *    input current for system will be disabled
+		 */
+		smb358_set_command(client,
+				SMB358_OTHER_CONTROL_A, 0x01);
+#else
+{
+		u8 therm_control_a, other_control_a;
+		/* [STEP - 10] =================================================
+		* Mininum System Voltage(bit 6)
+		* 3.15V(0), 3.45V(0), 3.60V(1), 3.75V(1)
+		* Therm monitor(bit 4) - Disabled(1)
+		* Soft Cold/Hot Temp Limit Behavior(bit 3:2, bit 1:0) -
+		*   Charger Current + Float voltage Compensation(11)
+		*/
+		smb358_i2c_read(client, SMB358_THERM_CONTROL_A, &therm_control_a);
+		pr_info("%s : THERM_CONTROL_A(0x%02x)\n", __func__, therm_control_a);
+		smb358_i2c_read(client, SMB358_OTHER_CONTROL_A, &other_control_a);
+		pr_info("%s : OTHER_CONTROL_A(0x%02x)\n", __func__, other_control_a);
+
+		pr_info("%s: chg_min_system_voltage(%d)\n", __func__, charger->pdata->chg_min_system_voltage);
+
+		if (charger->pdata->chg_min_system_voltage <= 3150) {
+			therm_control_a &= ~(0x1 << 6);
+			other_control_a |=  0x1 << 4;
+		} else if (charger->pdata->chg_min_system_voltage <= 3450) {
+			therm_control_a &= ~(0x1 << 6);
+			other_control_a &= ~(0x1 << 4);
+		} else if (charger->pdata->chg_min_system_voltage <= 3600) {
+			therm_control_a |= 0x1 << 6;
+			other_control_a &= ~(0x1 << 4);
+		} else {
+			therm_control_a |= 0x1 << 6;
+			other_control_a |= 0x1 << 4;
+		}
+
+		pr_info("%s: therm_control_a(0x%02x)\n", __func__, therm_control_a);
+		pr_info("%s: other_control_a(0x%02x)\n", __func__, other_control_a);
+
+		smb358_set_command(client,
+			SMB358_THERM_CONTROL_A, therm_control_a);
+
+		/* [STEP - 11] ================================================
+		 * OTG/ID Pin Control(bit 7:6) - RID Disabled, OTG I2c(00)
+		 * Minimum System Voltage(bit 4)
+		 * 3.15V(1), 3.45V(0), 3.60V(0), 3.75(1)
+		 * Low-Battery/SYSOK Voltage threshold(bit 3:0) - 2.5V(0001)
+		 *   if this bit is disabled,
+		 *   input current for system will be disabled
+		 */
+		smb358_set_command(client,
+			SMB358_OTHER_CONTROL_A, other_control_a);
+}
+#endif
+
+		/* [STEP - 12] ================================================
+		 * Charge Current Compensation(bit 7:6) - 200mA(00)
+		 * Digital Thermal Regulation Threshold(bit 5:4) - 130c
+		 * OTG current Limit at USBIN(Bit 3:2) - 900mA(11)
+		 * OTG Battery UVLO Threshold(Bit 1:0) - 3.3V(11)
+		*/
+		smb358_set_command(client,
+			SMB358_OTG_TLIM_THERM_CONTROL, 0x3F);
+
+		/* [STEP - 13] ================================================
+		 * Hard/Soft Limit Cell temp monitor
+		*/
+		smb358_set_command(client,
+			SMB358_LIMIT_CELL_TEMPERATURE_MONITOR, 0x01);
+
+		/* [STEP - 14] ================================================
+		 * FAULT interrupt - Disabled for non chg_irq, OVP enabled for chg_irq
+		*/
+		if (charger->pdata->chg_irq) {
+			smb358_set_command(client,
+				SMB358_FAULT_INTERRUPT, 0x0C);
+		} else {
+			smb358_set_command(client,
+				SMB358_FAULT_INTERRUPT, 0x00);
+		}
+
+		/* [STEP - 15] ================================================
+		 * STATUS interrupt - Clear
+		*/
+		smb358_set_command(client,
+			SMB358_STATUS_INTERRUPT, 0x00);
+
+		/* [STEP - 16] ================================================
+		 * Volatile write permission(bit 7) - allowed(1)
+		 * Charging Enable(bit 1) - Enabled(1)
+		 * STAT Output(bit 0) - Enabled(0)
+		*/
+		smb358_set_command(client,
+			SMB358_COMMAND_A, 0xC2);
+
+		schedule_delayed_work(&charger->slow_work, 0);
+	}
+#if 0
+#if (defined(CONFIG_MACH_MILLET3G_EUR) || defined(CONFIG_MACH_MATISSE3G_OPEN) || defined(CONFIG_MACH_BERLUTI3G_EUR))
+	/* Allow time for AICL to complete */
+	msleep(1000);
+	smb358_aicl_calibrate(client);
+#endif
+#endif
+}
+
+static void smb358_charger_otg_control(
+				struct i2c_client *client)
+{
+	struct sec_charger_info *charger = i2c_get_clientdata(client);
+
+	if (charger->cable_type ==
+		POWER_SUPPLY_TYPE_BATTERY) {
+		dev_info(&client->dev, "%s : turn off OTG\n", __func__);
+
+		/* disable otg */
+		smb358_clear_reg(client, SMB358_COMMAND_A, 0x10);
+	} else {
+		/* Change "OTG output current limit" to 250mA */
+		smb358_clear_reg(client, SMB358_OTG_TLIM_THERM_CONTROL, 0x0C);
+
+		/* OTG Enabled*/
+		smb358_update_reg(client, SMB358_COMMAND_A, 0x10);
+
+		dev_info(&client->dev, "%s : turn on OTG\n", __func__);
+		smb358_set_command(client, SMB358_COMMAND_B, 0x00);
+
+		/* Change "OTG output current limit" to 500mA */
+		smb358_update_reg(client, SMB358_OTG_TLIM_THERM_CONTROL, 0x84);
+	}
+
+}
+
+static void smb358_set_charging_current(
+		struct i2c_client *client, int charging_current)
+{
+	u8 data;
+
+	smb358_clear_reg(client, SMB358_COMMAND_A, 0x02);
+
+	if (!charging_current)
+		return;
+
+	smb358_i2c_read(client, SMB358_CHARGE_CURRENT, &data);
+	data &= 0x1f;
+	data |= smb358_get_fast_charging_current_data(charging_current);
+	smb358_set_command(client, SMB358_CHARGE_CURRENT, data);
+
+	smb358_update_reg(client, SMB358_COMMAND_A, 0x02);
+}
+
+static void smb358_set_charging_input_current_limit(
+		struct i2c_client *client, int input_current_limit)
+{
+	struct sec_charger_info *charger = i2c_get_clientdata(client);
+	u8 data;
+
+	/* Input current limit */
+	data = 0;
+	data = smb358_get_input_current_limit_data(
+		charger, input_current_limit);
+	smb358_set_command(client, SMB358_INPUT_CURRENTLIMIT, data);
+}
+
+void smb358_charger_shutdown(struct i2c_client *client)
+{
+	pr_info("%s: smb358 Charging Disabled\n", __func__);
+
+	smb358_set_command(client, SMB358_THERM_CONTROL_A, 0xF0);
+	smb358_set_command(client, SMB358_COMMAND_A, 0x80);
+	smb358_volatile_writes(client, SMB358_DISABLE_WRITE);
+}
+
+static int smb358_debugfs_show(struct seq_file *s, void *data)
+{
+	struct sec_charger_info *charger = s->private;
+	u8 reg;
+	u8 reg_data;
+
+	seq_printf(s, "SMB CHARGER IC :\n");
+	seq_printf(s, "==================\n");
+	for (reg = 0x00; reg <= 0x0E; reg++) {
+		smb358_i2c_read(charger->client, reg, &reg_data);
+		seq_printf(s, "0x%02x:\t0x%02x\n", reg, reg_data);
+	}
+
+	for (reg = 0x30; reg <= 0x3F; reg++) {
+		smb358_i2c_read(charger->client, reg, &reg_data);
+		seq_printf(s, "0x%02x:\t0x%02x\n", reg, reg_data);
+	}
+
+	seq_printf(s, "\n");
+	return 0;
+}
+
+static int smb358_debugfs_open(struct inode *inode, struct file *file)
+{
+	return single_open(file, smb358_debugfs_show, inode->i_private);
+}
+
+static const struct file_operations smb358_debugfs_fops = {
+	.open           = smb358_debugfs_open,
+	.read           = seq_read,
+	.llseek         = seq_lseek,
+	.release        = single_release,
+};
+
+bool smb358_hal_chg_init(struct i2c_client *client)
+{
+	struct sec_charger_info *charger = i2c_get_clientdata(client);
+
+	dev_info(&client->dev,
+		"%s: SMB358 Charger init(Start)!!\n", __func__);
+
+	smb358_volatile_writes(client, SMB358_ENABLE_WRITE);
+
+	/*smb358_test_read(client);*/
+	(void) debugfs_create_file("smb358_regs",
+		S_IRUGO, NULL, (void *)charger, &smb358_debugfs_fops);
+
+	return true;
+}
+
+bool smb358_hal_chg_suspend(struct i2c_client *client)
+{
+	return true;
+}
+
+bool smb358_hal_chg_resume(struct i2c_client *client)
+{
+	return true;
+}
+
+bool smb358_hal_chg_get_property(struct i2c_client *client,
+			      enum power_supply_property psp,
+			      union power_supply_propval *val)
+{
+	struct sec_charger_info *charger = i2c_get_clientdata(client);
+	u8 data;
+	switch (psp) {
+	case POWER_SUPPLY_PROP_STATUS:
+		val->intval = smb358_get_charging_status(client);
+		break;
+
+	case POWER_SUPPLY_PROP_CHARGE_TYPE:
+		if (charger->is_charging) {
+			val->intval = POWER_SUPPLY_CHARGE_TYPE_FAST;
+			if (charger->is_slow_charging) {
+				val->intval = POWER_SUPPLY_CHARGE_TYPE_SLOW;
+				pr_info("%s: slow-charging mode\n", __func__);
+			}
+		}
+		else
+			val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE;
+		break;
+
+	case POWER_SUPPLY_PROP_HEALTH:
+		val->intval = smb358_get_charging_health(client);
+		break;
+	/* calculated input current limit value */
+	case POWER_SUPPLY_PROP_CURRENT_NOW:
+	case POWER_SUPPLY_PROP_CURRENT_AVG:	/* charging current */
+		if (charger->charging_current) {
+			smb358_i2c_read(client, SMB358_STATUS_B, &data);
+			if (data & 0x20)
+				switch (data & 0x07) {
+				case 0:
+					val->intval = 100;
+					break;
+				case 1:
+					val->intval = 200;
+					break;
+				case 2:
+					val->intval = 450;
+					break;
+				case 3:
+					val->intval = 600;
+					break;
+				case 4:
+					val->intval = 900;
+					break;
+				case 5:
+					val->intval = 1300;
+					break;
+				case 6:
+					val->intval = 1500;
+					break;
+				case 7:
+					val->intval = 1800;
+					break;
+				}
+			else
+				switch ((data & 0x18) >> 3) {
+				case 0:
+					val->intval = 100;
+					break;
+				case 1:
+					val->intval = 150;
+					break;
+				case 2:
+					val->intval = 200;
+					break;
+				case 3:
+					val->intval = 250;
+					break;
+				}
+		} else
+			val->intval = 0;
+		dev_dbg(&client->dev,
+			"%s : set-current(%dmA), current now(%dmA)\n",
+			__func__, charger->charging_current, val->intval);
+		break;
+	default:
+		return false;
+	}
+	return true;
+}
+
+bool smb358_hal_chg_set_property(struct i2c_client *client,
+			      enum power_supply_property psp,
+			      const union power_supply_propval *val)
+{
+	struct sec_charger_info *charger = i2c_get_clientdata(client);
+
+	switch (psp) {
+	/* val->intval : type */
+	case POWER_SUPPLY_PROP_ONLINE:
+		if (val->intval == POWER_SUPPLY_TYPE_POWER_SHARING) {
+			union power_supply_propval ps_status;
+			psy_do_property("ps", get,
+				POWER_SUPPLY_PROP_STATUS, ps_status);
+			if (ps_status.intval) {
+				charger->cable_type = POWER_SUPPLY_TYPE_OTG;
+				pr_info("%s: ps enable\n", __func__);
+			} else {
+				charger->cable_type = POWER_SUPPLY_TYPE_BATTERY;
+				pr_info("%s: ps disable\n", __func__);
+			}
+		}
+		if (charger->cable_type == POWER_SUPPLY_TYPE_OTG) {
+			smb358_charger_otg_control(client);
+		} else if (charger->cable_type == POWER_SUPPLY_TYPE_BATTERY) {
+			smb358_charger_function_control(client);
+			smb358_charger_otg_control(client);
+		} else {
+			smb358_charger_function_control(client);
+		}
+		/* smb358_test_read(client); */
+		break;
+	case POWER_SUPPLY_PROP_CURRENT_MAX:	/* input current limit set */
+	/* calculated input current limit value */
+	case POWER_SUPPLY_PROP_CURRENT_NOW:
+		smb358_set_charging_input_current_limit(client, val->intval);
+		break;
+	/* val->intval : charging current */
+	case POWER_SUPPLY_PROP_CURRENT_AVG:
+		smb358_set_charging_current(client, val->intval);
+		break;
+	default:
+		return false;
+	}
+	return true;
+}
+
+ssize_t smb358_hal_chg_show_attrs(struct device *dev,
+				const ptrdiff_t offset, char *buf)
+{
+	struct power_supply *psy = dev_get_drvdata(dev);
+	struct sec_charger_info *chg =
+		container_of(psy, struct sec_charger_info, psy_chg);
+	int i = 0;
+	char *str = NULL;
+
+	switch (offset) {
+	case CHG_DATA:
+		i += scnprintf(buf + i, PAGE_SIZE - i, "%x\n",
+			chg->reg_data);
+		break;
+	case CHG_REGS:
+		str = kzalloc(sizeof(char)*1024, GFP_KERNEL);
+		if (!str)
+			return -ENOMEM;
+
+		smb358_read_regs(chg->client, str);
+		i += scnprintf(buf + i, PAGE_SIZE - i, "%s\n",
+			str);
+
+		kfree(str);
+		break;
+	default:
+		i = -EINVAL;
+		break;
+	}
+
+	return i;
+}
+
+ssize_t smb358_hal_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 sec_charger_info *chg =
+		container_of(psy, struct sec_charger_info, psy_chg);
+	int ret = 0;
+	int x = 0;
+	u8 data = 0;
+
+	switch (offset) {
+	case CHG_REG:
+		if (sscanf(buf, "%x\n", &x) == 1) {
+			chg->reg_addr = x;
+			smb358_i2c_read(chg->client,
+				chg->reg_addr, &data);
+			chg->reg_data = data;
+			dev_dbg(dev, "%s: (read) addr = 0x%x, data = 0x%x\n",
+				__func__, chg->reg_addr, chg->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__, chg->reg_addr, data);
+			smb358_i2c_write(chg->client,
+				chg->reg_addr, &data);
+			ret = count;
+		}
+		break;
+	default:
+		ret = -EINVAL;
+		break;
+	}
+
+	return ret;
+}
+
+static struct device_attribute smb358_charger_attrs[] = {
+	SMB358_CHARGER_ATTR(reg),
+	SMB358_CHARGER_ATTR(data),
+	SMB358_CHARGER_ATTR(regs),
+};
+
+static enum power_supply_property smb358_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_FULL_DESIGN,
+};
+
+static int smb358_chg_get_property(struct power_supply *psy,
+			    enum power_supply_property psp,
+			    union power_supply_propval *val)
+{
+	struct sec_charger_info *charger =
+		container_of(psy, struct sec_charger_info, psy_chg);
+	u8 data = 0;
+
+	switch (psp) {
+	case POWER_SUPPLY_PROP_CURRENT_MAX:	/* input current limit set */
+		smb358_i2c_read(charger->client, SMB358_STATUS_E, &data);
+		if (data & 0x10) {
+			int aicl_result = smb358_get_aicl_current(data);
+			dev_info(&charger->client->dev,
+				"%s : AICL completed (%dmA)\n", __func__, aicl_result);
+			charger->charging_current_max = aicl_result;
+		} else {
+			dev_info(&charger->client->dev,
+				"%s : AICL is not completed \n", __func__);
+			charger->charging_current_max = 300;
+		}
+		val->intval = charger->charging_current_max;
+		break;
+
+	case POWER_SUPPLY_PROP_ONLINE:
+	case POWER_SUPPLY_PROP_STATUS:
+	case POWER_SUPPLY_PROP_CHARGE_TYPE:
+	case POWER_SUPPLY_PROP_HEALTH:
+	case POWER_SUPPLY_PROP_CURRENT_AVG:	/* charging current */
+	/* calculated input current limit value */
+	case POWER_SUPPLY_PROP_CURRENT_NOW:
+		if (!smb358_hal_chg_get_property(charger->client, psp, val))
+			return -EINVAL;
+		break;
+	default:
+		return -EINVAL;
+	}
+	return 0;
+}
+
+static int smb358_chg_set_property(struct power_supply *psy,
+			    enum power_supply_property psp,
+			    const union power_supply_propval *val)
+{
+	struct sec_charger_info *charger =
+		container_of(psy, struct sec_charger_info, psy_chg);
+	union power_supply_propval input_value;
+
+	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 (val->intval == POWER_SUPPLY_TYPE_BATTERY || \
+				val->intval == POWER_SUPPLY_TYPE_OTG || \
+				val->intval == POWER_SUPPLY_TYPE_POWER_SHARING) {
+			charger->is_charging = false;
+			charger->is_slow_charging = false;
+		}
+		else
+			charger->is_charging = true;
+
+		if (!smb358_hal_chg_set_property(charger->client, psp, val))
+			return -EINVAL;
+		break;
+
+	/* val->intval : input current limit set */
+	case POWER_SUPPLY_PROP_CURRENT_MAX:
+		charger->charging_current_max = val->intval;
+	/* to control charging current,
+	 * use input current limit and set charging current as much as possible
+	 * so we only control input current limit to control charge current
+	 */
+	case POWER_SUPPLY_PROP_CURRENT_NOW:
+		if (!smb358_hal_chg_set_property(charger->client, psp, val))
+			return -EINVAL;
+		break;
+
+	/* val->intval : charging current */
+	case POWER_SUPPLY_PROP_CURRENT_AVG:
+		charger->charging_current = val->intval;
+
+		if (!smb358_hal_chg_set_property(charger->client, psp, val))
+			return -EINVAL;
+		break;
+
+	/* val->intval : SIOP level (%)
+	 * SIOP charging current setting
+	 */
+	case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
+		charger->siop_level = val->intval;
+		if (charger->is_charging) {
+			/* change val as charging current by SIOP level
+			* do NOT change initial charging current setting
+			*/
+			input_value.intval =
+					charger->pdata->charging_current[
+					charger->cable_type].fast_charging_current * val->intval / 100;
+
+			/* charging current should be over than USB charging current */
+			if (charger->pdata->chg_functions_setting &
+				SEC_CHARGER_MINIMUM_SIOP_CHARGING_CURRENT) {
+				if (input_value.intval > 0 &&
+					input_value.intval <
+					charger->pdata->charging_current[
+					POWER_SUPPLY_TYPE_USB].fast_charging_current)
+					input_value.intval =
+					charger->pdata->charging_current[
+					POWER_SUPPLY_TYPE_USB].fast_charging_current;
+			}
+
+			/* set charging current as new value */
+			if (!smb358_hal_chg_set_property(charger->client,
+				POWER_SUPPLY_PROP_CURRENT_AVG, &input_value))
+				return -EINVAL;
+		}
+		break;
+
+	default:
+		return -EINVAL;
+	}
+	return 0;
+}
+
+static void smb358_chg_isr_work(struct work_struct *work)
+{
+	struct sec_charger_info *charger =
+		container_of(work, struct sec_charger_info, isr_work.work);
+	union power_supply_propval val;
+	int full_check_type;
+
+	dev_info(&charger->client->dev,
+		"%s: Charger Interrupt\n", __func__);
+
+	psy_do_property("battery", get,
+		POWER_SUPPLY_PROP_CHARGE_NOW, val);
+	if (val.intval == SEC_BATTERY_CHARGING_1ST)
+		full_check_type = charger->pdata->full_check_type;
+	else
+		full_check_type = charger->pdata->full_check_type_2nd;
+
+	if (full_check_type == SEC_BATTERY_FULLCHARGED_CHGINT) {
+		if (!smb358_hal_chg_get_property(charger->client,
+			POWER_SUPPLY_PROP_STATUS, &val))
+			return;
+
+		switch (val.intval) {
+		case POWER_SUPPLY_STATUS_DISCHARGING:
+			dev_err(&charger->client->dev,
+				"%s: Interrupted but Discharging\n", __func__);
+			break;
+
+		case POWER_SUPPLY_STATUS_NOT_CHARGING:
+			dev_err(&charger->client->dev,
+				"%s: Interrupted but NOT Charging\n", __func__);
+			break;
+
+		case POWER_SUPPLY_STATUS_FULL:
+			dev_info(&charger->client->dev,
+				"%s: Interrupted by Full\n", __func__);
+			psy_do_property("battery", set,
+				POWER_SUPPLY_PROP_STATUS, val);
+			break;
+
+		case POWER_SUPPLY_STATUS_CHARGING:
+			dev_err(&charger->client->dev,
+				"%s: Interrupted but Charging\n", __func__);
+			break;
+
+		case POWER_SUPPLY_STATUS_UNKNOWN:
+		default:
+			dev_err(&charger->client->dev,
+				"%s: Invalid Charger Status\n", __func__);
+			break;
+		}
+	}
+
+	if (charger->pdata->ovp_uvlo_check_type ==
+		SEC_BATTERY_OVP_UVLO_CHGINT) {
+		if (!smb358_hal_chg_get_property(charger->client,
+			POWER_SUPPLY_PROP_HEALTH, &val))
+			return;
+
+		switch (val.intval) {
+		case POWER_SUPPLY_HEALTH_OVERHEAT:
+		case POWER_SUPPLY_HEALTH_COLD:
+			dev_err(&charger->client->dev,
+				"%s: Interrupted but Hot/Cold\n", __func__);
+			break;
+
+		case POWER_SUPPLY_HEALTH_DEAD:
+			dev_err(&charger->client->dev,
+				"%s: Interrupted but Dead\n", __func__);
+			break;
+
+		case POWER_SUPPLY_HEALTH_OVERVOLTAGE:
+		case POWER_SUPPLY_HEALTH_UNDERVOLTAGE:
+			dev_info(&charger->client->dev,
+				"%s: Interrupted by OVP/UVLO\n", __func__);
+			/* Do not set POWER_SUPPLY_PROP_HEALTH
+			* excute monitor work again.
+			* ovp/uvlo is checked by polling
+			*/
+			psy_do_property("battery", set,
+				POWER_SUPPLY_PROP_CHARGE_TYPE, val);
+			break;
+
+		case POWER_SUPPLY_HEALTH_UNSPEC_FAILURE:
+			dev_err(&charger->client->dev,
+				"%s: Interrupted but Unspec\n", __func__);
+			break;
+
+		case POWER_SUPPLY_HEALTH_GOOD:
+			dev_err(&charger->client->dev,
+				"%s: Interrupted but Good\n", __func__);
+			/* Do not set POWER_SUPPLY_PROP_HEALTH
+			* excute monitor work again.
+			* ovp/uvlo is checked by polling
+			*/
+			psy_do_property("battery", set,
+				POWER_SUPPLY_PROP_CHARGE_TYPE, val);
+			break;
+
+		case POWER_SUPPLY_HEALTH_UNKNOWN:
+		default:
+			dev_err(&charger->client->dev,
+				"%s: Invalid Charger Health\n", __func__);
+			break;
+		}
+	}
+
+	if (charger->pdata->cable_check_type & SEC_BATTERY_CABLE_CHECK_CHGINT) {
+		if (!smb358_hal_chg_get_property(charger->client,
+			POWER_SUPPLY_PROP_ONLINE, &val))
+			return;
+
+		/* use SEC_BATTERY_CABLE_SOURCE_EXTERNAL for cable_source_type
+		 * charger would call battery driver to set ONLINE property
+		 * check battery driver loaded or not
+		 */
+		if (get_power_supply_by_name("battery")) {
+			psy_do_property("battery", set,
+				POWER_SUPPLY_PROP_ONLINE, val);
+		} else {
+			if (charger->pdata->check_cable_result_callback)
+				charger->pdata->check_cable_result_callback(val.intval);
+		}
+	}
+}
+
+static irqreturn_t smb358_chg_irq_thread(int irq, void *irq_data)
+{
+	struct sec_charger_info *charger = irq_data;
+
+	schedule_delayed_work(&charger->isr_work, 0);
+
+	return IRQ_HANDLED;
+}
+
+static int smb358_chg_create_attrs(struct device *dev)
+{
+	int i, rc;
+
+	for (i = 0; i < ARRAY_SIZE(smb358_charger_attrs); i++) {
+		rc = device_create_file(dev, &smb358_charger_attrs[i]);
+		if (rc)
+			goto create_attrs_failed;
+	}
+	goto create_attrs_succeed;
+
+create_attrs_failed:
+	dev_err(dev, "%s: failed (%d)\n", __func__, rc);
+	while (i--)
+		device_remove_file(dev, &smb358_charger_attrs[i]);
+create_attrs_succeed:
+	return rc;
+}
+
+ssize_t smb358_chg_show_attrs(struct device *dev,
+				struct device_attribute *attr, char *buf)
+{
+	const ptrdiff_t offset = attr - smb358_charger_attrs;
+	int i = 0;
+
+	switch (offset) {
+	case CHG_REG:
+	case CHG_DATA:
+	case CHG_REGS:
+		i = smb358_hal_chg_show_attrs(dev, offset, buf);
+		break;
+	default:
+		i = -EINVAL;
+		break;
+	}
+
+	return i;
+}
+
+ssize_t smb358_chg_store_attrs(struct device *dev,
+				struct device_attribute *attr,
+				const char *buf, size_t count)
+{
+	const ptrdiff_t offset = attr - smb358_charger_attrs;
+	int ret = 0;
+
+	switch (offset) {
+	case CHG_REG:
+	case CHG_DATA:
+		ret = smb358_hal_chg_store_attrs(dev, offset, buf, count);
+		break;
+	default:
+		ret = -EINVAL;
+		break;
+	}
+
+	return ret;
+}
+#ifdef CONFIG_OF
+static int smb358_charger_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;
+}
+extern unsigned int system_rev;
+static int smb358_charger_parse_dt(struct device *dev,
+	struct sec_charger_info *charger)
+{
+	struct device_node *np = dev->of_node;
+	sec_battery_platform_data_t *pdata = charger->pdata;
+	int ret = 0;
+	int i, len;
+	const u32 *p;
+
+	if (np == NULL) {
+		pr_err("%s np NULL\n", __func__);
+		return -1;
+	} else {
+#if defined(CONFIG_MACH_VIENNAVZW) || defined(CONFIG_MACH_VIENNAATT)
+	if (system_rev >= 0xC)
+		pdata->vbus_ctrl_gpio = 28;
+	else
+		pdata->vbus_ctrl_gpio = 0;
+	pr_info("%s reading vbus_ctrl_gpio = %d\n",
+		__func__, pdata->vbus_ctrl_gpio);
+#else
+		ret = of_get_named_gpio(np, "charger,vbus_ctrl_gpio", 0);
+		if (ret > 0) {
+			pdata->vbus_ctrl_gpio = ret;
+			pr_info("%s reading vbus_ctrl_gpio = %d\n", __func__, ret);
+		} else {
+			pdata->vbus_ctrl_gpio = 0;
+			pr_info("%s vbus_ctrl_gpio read fail\n", __func__);
+		}
+#endif
+
+		np = of_find_node_by_name(NULL, "sec-battery");
+        	if (!np) {
+                	pr_err("%s np NULL\n", __func__);
+        	}
+		ret = of_property_read_u32(np, "battery,chg_float_voltage",
+					&pdata->chg_float_voltage);
+		if (ret < 0)
+			pr_err("%s: chg_float_voltage read failed (%d)\n", __func__, ret);
+
+		ret = of_property_read_u32(np, "battery,chg_min_system_voltage",
+					&pdata->chg_min_system_voltage);
+		if (ret < 0) {
+			pr_err("%s: chg_min_system_voltage read failed (%d)\n", __func__, ret);
+			pdata->chg_min_system_voltage = 3750;
+			pr_err("%s: chg_min_system_voltage is used as default setting (%d)\n",
+					__func__, pdata->chg_min_system_voltage);
+		}
+
+		ret = of_property_read_u32(np, "battery,ovp_uvlo_check_type",
+					&pdata->ovp_uvlo_check_type);
+		if (ret < 0)
+			pr_err("%s: ovp_uvlo_check_type read failed (%d)\n", __func__, ret);
+
+		ret = of_get_named_gpio(np, "battery,chg_int", 0);
+		if (ret > 0) {
+			pdata->chg_irq = gpio_to_irq(ret);
+			pr_info("%s reading chg_int_gpio = %d\n", __func__, ret);
+		} else {
+			pr_info("%s reading chg_int_gpio is empty\n", __func__);
+		}
+
+		ret = of_property_read_u32(np, "battery,chg_irq_attr",
+					(unsigned int *)&pdata->chg_irq_attr);
+		if (ret)
+			pr_info("%s: chg_irq_attr is Empty\n", __func__);
+
+		ret = of_property_read_u32(np, "battery,full_check_type",
+					&pdata->full_check_type);
+		if (ret < 0)
+			pr_err("%s: full_check_type read failed (%d)\n", __func__, ret);
+
+		p = of_get_property(np, "battery,input_current_limit", &len);
+		len = len / sizeof(u32);
+		pdata->charging_current = kzalloc(sizeof(sec_charging_current_t) * len,
+						  GFP_KERNEL);
+
+		for(i = 0; i < len; i++) {
+			ret = smb358_charger_read_u32_index_dt(np,
+					 "battery,input_current_limit", i,
+					 &pdata->charging_current[i].input_current_limit);
+			ret = smb358_charger_read_u32_index_dt(np,
+					 "battery,fast_charging_current", i,
+					 &pdata->charging_current[i].fast_charging_current);
+			ret = smb358_charger_read_u32_index_dt(np,
+					 "battery,full_check_current_1st", i,
+					 &pdata->charging_current[i].full_check_current_1st);
+			ret = smb358_charger_read_u32_index_dt(np,
+					 "battery,full_check_current_2nd", i,
+					 &pdata->charging_current[i].full_check_current_2nd);
+		}
+	}
+	return ret;
+}
+#else
+static int smb358_charger_parse_dt(struct max77803_charger_data *charger)
+{
+	return 0;
+}
+#endif
+
+static int smb358_charger_probe(
+						struct i2c_client *client,
+						const struct i2c_device_id *id)
+{
+	struct i2c_adapter *adapter =
+		to_i2c_adapter(client->dev.parent);
+	struct sec_charger_info *charger;
+	int ret = 0;
+
+	dev_info(&client->dev,
+		"%s: SMB358 Charger Driver Loading\n", __func__);
+
+	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE))
+		return -EIO;
+
+	charger = kzalloc(sizeof(*charger), GFP_KERNEL);
+	if (!charger)
+		return -ENOMEM;
+
+	charger->client = client;
+	if (client->dev.of_node) {
+		void * pdata = kzalloc(sizeof(sec_battery_platform_data_t), GFP_KERNEL);
+		if (!pdata)
+			goto err_free1;
+		charger->pdata = pdata;
+		if (smb358_charger_parse_dt(&client->dev, charger))
+			dev_err(&client->dev,
+				"%s : Failed to get charger dt\n", __func__);
+	} else
+		charger->pdata = client->dev.platform_data;
+
+	i2c_set_clientdata(client, charger);
+
+	charger->siop_level = 100;
+	charger->psy_chg.name		= "sec-charger";
+	charger->psy_chg.type		= POWER_SUPPLY_TYPE_UNKNOWN;
+	charger->psy_chg.get_property	= smb358_chg_get_property;
+	charger->psy_chg.set_property	= smb358_chg_set_property;
+	charger->psy_chg.properties	= smb358_charger_props;
+	charger->psy_chg.num_properties	= ARRAY_SIZE(smb358_charger_props);
+	charger->is_slow_charging = false;
+
+	if (charger->pdata->chg_gpio_init) {
+		if (!charger->pdata->chg_gpio_init()) {
+			dev_err(&client->dev,
+					"%s: Failed to Initialize GPIO\n", __func__);
+			goto err_free;
+		}
+	}
+
+	if (!smb358_hal_chg_init(charger->client)) {
+		dev_err(&client->dev,
+			"%s: Failed to Initialize Charger\n", __func__);
+		goto err_free;
+	}
+
+	ret = power_supply_register(&client->dev, &charger->psy_chg);
+	if (ret) {
+		dev_err(&client->dev,
+			"%s: Failed to Register psy_chg\n", __func__);
+		goto err_free;
+	}
+
+	INIT_DELAYED_WORK(&charger->slow_work,
+		smb358_check_slow_charging);
+
+	if (charger->pdata->chg_irq) {
+		INIT_DELAYED_WORK(
+			&charger->isr_work, smb358_chg_isr_work);
+
+		ret = request_threaded_irq(charger->pdata->chg_irq,
+				NULL, smb358_chg_irq_thread,
+				charger->pdata->chg_irq_attr,
+				"charger-irq", charger);
+		if (ret) {
+			dev_err(&client->dev,
+				"%s: Failed to Reqeust IRQ\n", __func__);
+			goto err_supply_unreg;
+		}
+
+		ret = enable_irq_wake(charger->pdata->chg_irq);
+		if (ret < 0)
+			dev_err(&client->dev,
+				"%s: Failed to Enable Wakeup Source(%d)\n",
+				__func__, ret);
+	}
+
+	ret = smb358_chg_create_attrs(charger->psy_chg.dev);
+	if (ret) {
+		dev_err(&client->dev,
+			"%s : Failed to create_attrs\n", __func__);
+		goto err_req_irq;
+	}
+
+	dev_info(&client->dev,
+		"%s: SMB358 Charger Driver Loaded\n", __func__);
+	return 0;
+
+err_req_irq:
+	if (charger->pdata->chg_irq)
+		free_irq(charger->pdata->chg_irq, charger);
+err_supply_unreg:
+	power_supply_unregister(&charger->psy_chg);
+err_free:
+	kfree(charger->pdata);
+err_free1:
+	kfree(charger);
+
+	return ret;
+}
+
+static int smb358_charger_remove(
+						struct i2c_client *client)
+{
+	return 0;
+}
+
+static int smb358_charger_suspend(struct i2c_client *client,
+				pm_message_t state)
+{
+	if (!smb358_hal_chg_suspend(client))
+		dev_err(&client->dev,
+			"%s: Failed to Suspend Charger\n", __func__);
+
+	return 0;
+}
+
+static int smb358_charger_resume(struct i2c_client *client)
+{
+	dev_info(&client->dev,"%s: start\n", __func__);
+
+	if (!smb358_hal_chg_resume(client))
+		dev_err(&client->dev,
+			"%s: Failed to Resume Charger\n", __func__);
+
+	return 0;
+}
+
+static const struct i2c_device_id smb358_charger_id[] = {
+	{"smb358", 0},
+	{}
+};
+
+MODULE_DEVICE_TABLE(i2c, smb358_charger_id);
+static struct of_device_id smb358_i2c_match_table[] = {
+	{ .compatible = "smb358,i2c", },
+	{ },
+};
+MODULE_DEVICE_TABLE(i2c, smb358_i2c_match_table);
+
+static struct i2c_driver smb358_charger_driver = {
+	.driver = {
+		.name	= "smb358",
+		.owner = THIS_MODULE,
+		.of_match_table = smb358_i2c_match_table,
+	},
+	.probe	= smb358_charger_probe,
+	.remove	= smb358_charger_remove,
+	.suspend	= smb358_charger_suspend,
+	.resume		= smb358_charger_resume,
+	.shutdown	= smb358_charger_shutdown,
+	.id_table	= smb358_charger_id,
+};
+
+static int __init smb358_charger_init(void)
+{
+	return i2c_add_driver(&smb358_charger_driver);
+}
+
+static void __exit smb358_charger_exit(void)
+{
+	i2c_del_driver(&smb358_charger_driver);
+}
+
+module_init(smb358_charger_init);
+module_exit(smb358_charger_exit);
+
+MODULE_DESCRIPTION("Samsung SMB358 Charger Driver");
+MODULE_AUTHOR("Samsung Electronics");
+MODULE_LICENSE("GPL");
+