Initial file dump from open source releaseHEADmaster

1 files changed, 1496 insertions, 0 deletions

diff --git a/drivers/power/rt5033_fuelgauge.c b/drivers/power/rt5033_fuelgauge.c
new file mode 100644
index 00000000..b2d1a9e7
--- /dev/null
+++ b/drivers/power/rt5033_fuelgauge.c
@@ -0,0 +1,1496 @@
+/* drivers/battery/rt5033_fuelgauge.c
 * RT5033 Voltage Tracking Fuelgauge Driver
+ *
+ * Copyright (C) 2013
+ * Author: Dongik Sin <dongik.sin@samsung.com>
+ * Modified by 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_fuelgauge.h>
+#include <linux/battery/fuelgauge/rt5033_fuelgauge.h>
+#include <linux/battery/fuelgauge/rt5033_fuelgauge_impl.h>
+#include <linux/uaccess.h>
+#include <linux/of.h>
+#include <linux/fs.h>
+#include <linux/math64.h>
+#include <linux/compiler.h>
+#define RT5033_FG_DEVICE_NAME "rt5033-fg"
+#define ALIAS_NAME "rt5033-fuelgauge"
+
+#define FG_DET_BAT_PRESENT 1
+#define MINVAL(a, b) ((a <= b) ? a : b)
+
+static int offset_li(int voltNR, int tempNR,
+		const data_point_t *mesh,
+		int volt, int temp);
+static vg_comp_data_t vgcomp_li(int voltNR, int tempNR,
+		const data_point_t *mesh,
+		int volt, int temp);
+
+static int rt5033_fg_get_offset(struct sec_fuelgauge_info *fuelgauge,
+		int state, int volt, int temp);
+
+static vg_comp_data_t rt5033_fg_get_vgcomp(
+		struct sec_fuelgauge_info *fuelgauge,
+		int state, int volt, int temp);
+
+static inline const data_point_t *get_mesh_data(
+		int i, int j,
+		const data_point_t *mesh, int xNR)
+{
+	return mesh + j * xNR + i;
+}
+
+typedef struct {
+	int x, y;
+	int order_x, order_y;
+	int xNR, yNR;
+	const data_point_t *mesh_src;
+} submask_condition_t;
+
+#define PRECISION_ENHANCE 5
+/* n-order 2D interpolation */
+static int offset_li(int xNR, int yNR, const data_point_t *mesh, int x, int y)
+{
+	long long retval = 0;
+	int i, j, k;
+	long long wM, wD;
+	const data_point_t *cache;
+	for (i = 0 ; i < xNR; ++i) {
+		for (j = 0; j < yNR; ++j) {
+			wM = wD = 1;
+			cache = get_mesh_data(i, j, mesh, xNR);
+			for (k = 0; k < xNR; ++k) {
+				if (i != k) {
+					wM *= (x - get_mesh_data(k, j, mesh, xNR)->x);
+					wD *= (cache->x - get_mesh_data(k, j, mesh, xNR)->x);
+				}
+			}
+			for (k = 0; k < yNR; ++k) {
+				if (j != k) {
+					wM *= (y - get_mesh_data(i, k, mesh, xNR)->y);
+					wD *= (cache->y - get_mesh_data(i, k, mesh, xNR)->y);
+				}
+			}
+			retval += div64_s64(((cache->z * wM) << PRECISION_ENHANCE), wD);
+		}
+	}
+	return (int)((retval + (1 << (PRECISION_ENHANCE - 1))) >> PRECISION_ENHANCE);
+}
+
+static int get_sub_mesh(data_point_t *mesh_buffer,
+		submask_condition_t *condition)
+{
+	int i, j, x, y;
+	BUG_ON(condition->order_x > condition->xNR);
+	BUG_ON(condition->order_y > condition->yNR);
+	x = condition->x;
+	y = condition->y;
+	for (i = 0; i < condition->xNR; ++i) {
+		if (get_mesh_data(i, 0, condition->mesh_src, condition->xNR)->x >= x)
+			break;
+	}
+	for ( ; i >= 0 && i < condition->xNR; --i) {
+		if (get_mesh_data(i, 0, condition->mesh_src, condition->xNR)->x <= x)
+			break;
+	}
+
+	for (j = 0; j < condition->yNR; ++j) {
+		if (get_mesh_data(0, j, condition->mesh_src, condition->xNR)->y >= y)
+			break;
+	}
+	for ( ; j >= 0 && j < condition->yNR; --j) {
+		if (get_mesh_data(0, j, condition->mesh_src, condition->xNR)->y <= y)
+			break;
+	}
+	i -= ((condition->order_x - 1) / 2);
+	j -= ((condition->order_y - 1) / 2);
+
+	if (i <= 0)
+		i = 0;
+	if (j <= 0)
+		j = 0;
+	if ((i + condition->order_x) > condition->xNR)
+		i = condition->xNR - condition->order_x;
+	if ((j + condition->order_y) > condition->yNR)
+		j = condition->yNR - condition->order_y;
+	for (y = 0; y < condition->order_y; ++y) {
+		for (x = 0; x < condition->order_x; ++x) {
+			*(mesh_buffer + y * condition->order_x + x)
+				= *get_mesh_data(i + x, j + y, condition->mesh_src, condition->xNR);
+		}
+	}
+	return 0;
+}
+
+/* n-order 2D interpolation */
+static vg_comp_data_t vgcomp_li(int xNR, int yNR, const data_point_t *mesh,
+		int x, int y)
+{
+	long long retval[] = { 0, 0, 0, 0};
+	vg_comp_data_t ret;
+	int i, j, k;
+	long long wM, wD;
+	const data_point_t *cache;
+	for (i = 0 ; i < xNR; ++i) {
+		for (j = 0; j < yNR; ++j) {
+			wM = wD = 1;
+			cache = get_mesh_data(i, j, mesh, xNR);
+			for (k = 0; k < xNR; ++k) {
+				if (i != k) {
+					wM *= (x - get_mesh_data(k, j, mesh, xNR)->x);
+					wD *= (cache->x - get_mesh_data(k, j, mesh, xNR)->x);
+				}
+			}
+			for (k = 0; k < yNR; ++k) {
+				if (j != k) {
+					wM *= (y - get_mesh_data(i, k, mesh, xNR)->y);
+					wD *= (cache->y - get_mesh_data(i, k, mesh, xNR)->y);
+				}
+			}
+			for (k = 0; k < ARRAY_SIZE(retval); ++k)
+				retval[k]  +=  div64_s64((cache->vg_comp.data[k] * wM) << PRECISION_ENHANCE, wD);
+		}
+	}
+	for (k = 0; k < ARRAY_SIZE(retval); ++k) {
+		ret.data[k] = (int)((retval[k] + (1 << (PRECISION_ENHANCE - 1))) >> PRECISION_ENHANCE);
+		if (unlikely(ret.data[k] < 0))
+			ret.data[k]  = 0;
+		else if (unlikely(ret.data[k] > 255))
+			ret.data[k] = 255;
+	}
+	return ret;
+}
+
+
+
+static inline int rt5033_fg_read_device(struct i2c_client *client,
+		int reg, int bytes, void *dest)
+{
+	int ret;
+
+	if (bytes > 1)
+		ret = i2c_smbus_read_i2c_block_data(client, reg, bytes, dest);
+	else {
+		ret = i2c_smbus_read_byte_data(client, reg);
+		if (ret < 0)
+			return ret;
+		*(unsigned char *)dest = (unsigned char)ret;
+	}
+	return ret;
+}
+
+static int32_t rt5033_fg_i2c_read_word(struct i2c_client *client,
+		uint8_t reg_addr)
+{
+	uint16_t data = 0;
+	int ret;
+	ret = rt5033_fg_read_device(client, reg_addr, 2, &data);
+	if (ret < 0)
+		return ret;
+	else
+		return (int32_t)be16_to_cpu(data);
+}
+
+static int32_t rt5033_fg_i2c_write_word(struct i2c_client *client,
+		uint8_t reg_addr, uint16_t data)
+{
+	int ret;
+
+	data = cpu_to_be16(data);
+	ret = i2c_smbus_write_i2c_block_data(client, reg_addr, 2, (uint8_t *)&data);
+	return ret;
+}
+
+static unsigned int fg_get_vbat(struct i2c_client *client);
+static unsigned int fg_get_avg_volt(struct i2c_client *client);
+static unsigned int fg_get_ocv(struct i2c_client *client);
+
+static void rt5033_pr_ver_info(struct i2c_client *client)
+{
+	dev_info(&client->dev, "RT5033 Fuel-Gauge Ver %s\n", FG_DRIVER_VER);
+}
+unsigned int fg_get_soc(struct i2c_client *client)
+{
+	struct sec_fuelgauge_info *fuelgauge = i2c_get_clientdata(client);
+	int ret;
+	unsigned int volt, ocv;
+	int temp;
+	int offset = 0, offset_chg_dischg = 0;
+	int crate;
+	int idle;
+	int chg_exist;
+	vg_comp_data_t vgcomp;
+	int soc_val;
+	crate = rt5033_fg_i2c_read_word(client, RT5033_CRATE) >> 8;
+	idle = (crate >= fuelgauge->info.crate_idle_thres) ? 1 : 0;
+	ret = rt5033_fg_i2c_read_word(client, RT5033_CONFIG_MSB);
+	/* disable real time battery presence detection &
+	 * sleep mode & battery type detection */
+	ret &= ~(0x0B01);
+	/* enable battery presence and set battery type*/
+	if (fuelgauge->info.battery_type >= 4350)
+		ret |= 0x0401;
+	else
+		ret |= 0x0400;
+	/* Enable battery real-time detection if TA/USB is exist*/
+	chg_exist = fuelgauge->info.flag_full_charge |
+		fuelgauge->info.flag_chg_status;
+	if (chg_exist)
+		ret |= 0x0800;
+	rt5033_fg_i2c_write_word(client, RT5033_CONFIG_MSB, ret);
+
+	// read rt5033 fg registers for debugging.
+	ret = fg_get_vbat(client);
+	pr_info("%s : FG_VBAT = %d\n", __func__, ret);
+	ret = rt5033_fg_i2c_read_word(client, RT5033_FG_IRQ_CTRL);
+	pr_info("%s : FG_IRQ_CTL_FLAG = 0x%04x\n", __func__, ret);
+	ret = rt5033_fg_i2c_read_word(client, RT5033_VOLT_ALRT_TH);
+	pr_info("%s : FG_VMIN_SMIN_FLAG = 0x%04x\n", __func__, ret);
+	ret = rt5033_fg_i2c_read_word(client, RT5033_CRATE);
+	pr_info("%s : FG_CRATE_DEVICEID = 0x%04x\n", __func__, ret);
+
+	/* clear ri */
+	ret = rt5033_fg_i2c_read_word(client, RT5033_CONFIG_MSB);
+
+	// read FG_CONFIG  for debugging.
+	pr_info("%s : FG_CONFIG = 0x%04x\n", __func__, ret);
+
+	if (ret & 0x0040) {
+		ret &= ~(0x0040);
+		rt5033_fg_i2c_write_word(client, RT5033_CONFIG_MSB, ret);
+	}
+
+	/* cvs */
+	temp = fuelgauge->info.temperature / 10;
+	if (temp < R5_TEMP)
+		rt5033_fg_i2c_write_word(client, RT5033_MFA_MSB, MFA_CMD_R5_LOW_TEMP);
+	else
+		rt5033_fg_i2c_write_word(client, RT5033_MFA_MSB, MFA_CMD_R5_DEFAULT);
+
+	rt5033_fg_i2c_write_word(client, RT5033_MFA_MSB, 0x8085);
+	ret = rt5033_fg_i2c_read_word(client, RT5033_MFA_MSB);
+	pr_info("%s : FG_CVS = 0x%04x\n", __func__, ret);
+
+	ocv = fg_get_ocv(client);
+	volt = fg_get_vbat(client);
+
+	/* report FG_OCV & FG_TEMP for debugging. */
+	pr_info("%s : FG_OCV = %d, FG_TEMP = %d, FG_VBAT = %d\n",
+			__func__, ocv, temp, volt);
+
+	vgcomp = rt5033_fg_get_vgcomp(fuelgauge,
+			idle ? VGCOMP_IDLE : VGCOMP_NORMAL,
+			ocv, fuelgauge->info.temperature);
+	ret = (vgcomp.data[0] << 8) | vgcomp.data[1];
+	rt5033_fg_i2c_write_word(client, RT5033_VGCOMP1, ret);
+
+	ret = (vgcomp.data[2] << 8) | vgcomp.data[3];
+	rt5033_fg_i2c_write_word(client, RT5033_VGCOMP3, ret);
+	pr_info("%s : VGCOMP(%s) = 0x%04x, 0x%04x\n", __func__,
+			idle ? "idle" : "normal",
+			(vgcomp.data[0] << 8) | vgcomp.data[1],
+			(vgcomp.data[2] << 8) | vgcomp.data[3]);
+	/* report VGCOMP1~4 for debugging. */
+	ret = rt5033_fg_i2c_read_word(client, RT5033_VGCOMP1);
+	pr_info("%s : FG_VGCOMP1_2 = 0x%04x\n", __func__, ret);
+	ret = rt5033_fg_i2c_read_word(client, RT5033_VGCOMP3);
+	pr_info("%s : FG_VGCOMP3_4 = 0x%04x\n", __func__, ret);
+
+
+	/* read soc */
+	ret = rt5033_fg_i2c_read_word(client, RT5033_SOC_MSB);
+	if (ret < 0) {
+		pr_err("%s: read soc reg fail", __func__);
+		soc_val = 500;
+	} else {
+		soc_val = ((ret) >> 8) * 10 + (ret & 0x00ff) * 10 / 256;
+	}
+	/* chg/dischg offset */
+	offset_chg_dischg = rt5033_fg_get_offset(fuelgauge, chg_exist ?
+			OFFSET_CHARGING : OFFSET_DISCHARGING,
+			soc_val, fuelgauge->info.temperature);
+
+	offset = rt5033_fg_get_offset(fuelgauge, OFFSET_LOW_POWER,
+			soc_val, fuelgauge->info.temperature);
+	soc_val = soc_val + offset_chg_dischg + offset;
+	/* report FG_SOC_RAW for debugging. */
+	pr_info("%s : FG_SOC_RAW = 0x%04x\n", __func__, ret);
+	pr_info("%s : CHG/DISCHG OFFSET  = %d\n", __func__, offset_chg_dischg);
+	pr_info("%s : FG_LOW_POWER_OFFS = %d\n", __func__, offset);
+
+	if (soc_val < 0) {
+		soc_val = 0;
+	}
+
+	fuelgauge->info.batt_soc = soc_val;
+	/* report FG_SOC for debugging. */
+	pr_info("%s : FG_SOC = %d\n", __func__, soc_val);
+
+	return soc_val;
+}
+
+static unsigned int fg_get_ocv(struct i2c_client *client)
+{
+	int ret;
+	unsigned int ocv;// = 3500; /*3500 means 3500mV*/
+	ret = rt5033_fg_i2c_read_word(client, RT5033_OCV_MSB);
+	if (ret < 0) {
+		pr_err("%s: read soc reg fail", __func__);
+		ocv = 4000;
+	} else {
+		ocv = (ret & 0xfff0) >> 4;
+		ocv = ocv * 125 / 100;
+	}
+	return ocv;
+}
+
+static unsigned int fg_get_vbat(struct i2c_client *client)
+{
+	int ret;
+	unsigned int vbat;/* = 3500; 3500 means 3500mV*/
+	ret = rt5033_fg_i2c_read_word(client, RT5033_VBAT_MSB);
+	if (ret < 0) {
+		pr_err("%s: read vbat fail", __func__);
+		vbat = 4000;
+	} else {
+		vbat = (ret & 0xfff0) >> 4;
+		vbat = vbat * 125 / 100;
+	}
+	return vbat;
+}
+
+static unsigned int fg_get_avg_volt(struct i2c_client *client)
+{
+	int ret;
+	unsigned int avg_volt;/* = 3500; 3500 means 3500mV*/
+	ret = rt5033_fg_i2c_read_word(client, RT5033_AVG_VOLT_MSB);
+	if (ret < 0) {
+		pr_err("%s: read vbat fail", __func__);
+		avg_volt = 4000;
+	} else {
+		avg_volt = (ret & 0xfff0) >> 4;
+		avg_volt = avg_volt * 125 / 100;
+	}
+	return avg_volt;
+}
+
+static unsigned int fg_get_device_id(struct i2c_client *client)
+{
+	int ret;
+	ret = rt5033_fg_i2c_read_word(client, RT5033_CRATE);
+	ret &= 0x00ff;
+	return ret;
+}
+
+static bool rt5033_fg_get_batt_present(struct i2c_client *client)
+{
+	int ret = rt5033_fg_i2c_read_word(client, RT5033_CONFIG_MSB);
+	if (ret < 0)
+		return false;
+	return (ret & 0x02) ? true : false;
+}
+
+static vg_comp_data_t rt5033_fg_get_vgcomp(
+		struct sec_fuelgauge_info *fuelgauge,
+		int state, int volt, int temp)
+{
+	const int ip_x = fuelgauge->info.vg_comp_interpolation_order[0];
+	const int ip_y = fuelgauge->info.vg_comp_interpolation_order[1];
+	data_point_t sub_mesh[ip_x * ip_y];
+	int xNR, yNR;
+	const vg_comp_data_t default_vgcomp = {
+		.data = { 0x32, 0x32, 0x32, 0x32, },
+	};
+	vg_comp_data_t retval;
+	vg_comp_table_t *vgcomp_table = NULL;
+	submask_condition_t condition = {
+		.x = volt,
+		.y = temp,
+	};
+	BUG_ON(state >= VGCOMP_NR);
+	mutex_lock(&fuelgauge->info.param_lock);
+	vgcomp_table = fuelgauge->info.vg_comp + state;
+	xNR = vgcomp_table->voltNR;
+	yNR = vgcomp_table->tempNR;
+	dev_dbg(&fuelgauge->client->dev,
+			"%s-%d: state = %d, xNR = %d, yNR = %d\n", __func__,
+			__LINE__, state, xNR, yNR);
+	if (xNR == 0 || yNR == 0) {
+		mutex_unlock(&fuelgauge->info.param_lock);
+		return default_vgcomp;
+	}
+	condition.order_x = MINVAL(ip_x, xNR);
+	condition.order_y = MINVAL(ip_y, yNR);
+	condition.xNR = xNR;
+	condition.yNR = yNR;
+	condition.mesh_src = vgcomp_table->vg_comp_data;
+	dev_dbg(&fuelgauge->client->dev, "%s-%d: order_x = %d, order_y = %d\n",
+			__func__, __LINE__, condition.order_x, condition.order_y);
+	get_sub_mesh(sub_mesh, &condition);
+	yNR = condition.order_x * condition.order_y;
+	retval = vgcomp_li(condition.order_x, condition.order_y, sub_mesh,
+			volt, temp);
+	mutex_unlock(&fuelgauge->info.param_lock);
+	dev_dbg(&fuelgauge->client->dev, "%d %d %d %d\n", retval.data[0],
+			retval.data[1], retval.data[2], retval.data[3]);
+	return retval;
+}
+
+#define OFFSET_INTERPOLATION_ORDER_X 2
+#define OFFSET_INTERPOLATION_ORDER_Y 2
+
+static int rt5033_fg_get_offset(struct sec_fuelgauge_info *fuelgauge,
+		int state, int volt, int temp)
+{
+	const int ip_x = fuelgauge->info.offset_interpolation_order[0];
+	const int ip_y = fuelgauge->info.offset_interpolation_order[1];
+	data_point_t sub_mesh[ip_x * ip_y];
+	int xNR, yNR;
+	int offset;
+	soc_offset_table_t *offset_table = NULL;
+	submask_condition_t condition = {
+		.x = volt,
+		.y = temp,
+	};
+	BUG_ON(state >= OFFSET_NR);
+	mutex_lock(&fuelgauge->info.param_lock);
+	offset_table = fuelgauge->info.soc_offset + state;
+	xNR = offset_table->soc_voltNR;
+	yNR = offset_table->tempNR;
+	dev_dbg(&fuelgauge->client->dev,
+			"%s-%d: state = %d, xNR = %d, yNR = %d\n", __func__,
+			__LINE__, state, xNR, yNR);
+	if (xNR == 0 || yNR == 0) {
+		mutex_unlock(&fuelgauge->info.param_lock);
+		return 0;
+	}
+	condition.order_x = MINVAL(ip_x, xNR);
+	condition.order_y = MINVAL(ip_y, yNR);
+	condition.xNR = xNR;
+	condition.yNR = yNR;
+	condition.mesh_src = offset_table->soc_offset_data;
+	get_sub_mesh(sub_mesh, &condition);
+	offset = offset_li(condition.order_x, condition.order_y, sub_mesh,
+			volt, temp);
+	mutex_unlock(&fuelgauge->info.param_lock);
+	return offset;
+}
+
+
+static bool rt5033_fg_init(struct i2c_client *client)
+{
+	int ret;
+	int ta_exist;
+	union power_supply_propval value;
+	struct sec_fuelgauge_info *fuelgauge = i2c_get_clientdata(client);
+
+	ret = rt5033_fg_i2c_read_word(client, RT5033_CONFIG_MSB);
+	if (ret < 0) {
+		pr_err("rt5033_fg_init : failed to do i2c read(%d)\n", ret);
+		return false;
+	}
+	/* Disable SHDN */
+	ret &= (~0x0080);
+	rt5033_fg_i2c_write_word(client, RT5033_CONFIG_MSB, ret);
+
+	/* disable hibernate mode */
+	if (ret & 0x8000) {
+		ret = rt5033_fg_i2c_write_word(client, RT5033_MFA_MSB, MFA_CMD_EXIT_HIB);
+		pr_err("rt5033_fg_init : failed to do i2c write(%d)\n", ret);
+		return false;
+	}
+	fg_get_device_id(client);
+	value.intval = POWER_SUPPLY_HEALTH_UNKNOWN;
+	psy_do_property("sec-charger", get,
+			POWER_SUPPLY_PROP_HEALTH, value);
+
+	ta_exist = (value.intval == POWER_SUPPLY_HEALTH_GOOD) |
+		fuelgauge->is_charging;
+	ret = rt5033_fg_i2c_read_word(client, RT5033_FG_IRQ_CTRL);
+	if (ret < 0) {
+		printk("rt5033_fg_init : failed to do i2c read(%d)\n", ret);
+		return false;
+	}
+	if ((ret & 0x04) != 0 && ta_exist) {
+		ret = rt5033_fg_i2c_read_word(client, RT5033_FG_IRQ_CTRL);
+		ret &= (~0x04);
+		rt5033_fg_i2c_write_word(client, RT5033_FG_IRQ_CTRL, ret);
+		msleep(1000);
+		/* send Quick Sensing command to 5033FG */
+		rt5033_fg_i2c_write_word(client, 0x06, 0x8000);
+	}
+	return true;
+}
+
+
+
+enum comp_offset_type {
+	NORMAL_VG_COMP = 0,
+	IDLE_VG_COMP,
+	SOC_OFFSET_CHARGING,
+	SOC_OFFSET_DISCHARGING,
+	SOC_OFFSET_SPECIAL,
+	SOC_OFFSET_LOW_POWER,
+
+};
+
+static void new_vgcomp_soc_offset_data(int type,
+		struct sec_fuelgauge_info *fuelgauge, int size_x, int size_y)
+{
+	struct device *dev = &fuelgauge->client->dev;
+	int index;
+
+	switch (type) {
+		case NORMAL_VG_COMP:
+		case IDLE_VG_COMP:
+			index = type - NORMAL_VG_COMP;
+			if (fuelgauge->info.vg_comp[index].vg_comp_data) {
+				devm_kfree(dev, fuelgauge->info.vg_comp[index].vg_comp_data);
+				fuelgauge->info.vg_comp[index].vg_comp_data = NULL;
+			}
+			if (size_x != 0 && size_y != 0)
+				fuelgauge->info.vg_comp[index].vg_comp_data =
+					devm_kzalloc(dev, size_x * size_y * sizeof(data_point_t),
+							GFP_KERNEL);
+			if (fuelgauge->info.vg_comp[index].vg_comp_data) {
+				fuelgauge->info.vg_comp[index].voltNR = size_x;
+				fuelgauge->info.vg_comp[index].tempNR = size_y;
+
+			} else {
+				fuelgauge->info.vg_comp[index].voltNR = 0;
+				fuelgauge->info.vg_comp[index].tempNR = 0;
+			}
+			break;
+		case SOC_OFFSET_CHARGING:
+		case SOC_OFFSET_DISCHARGING:
+		case SOC_OFFSET_SPECIAL:
+		case SOC_OFFSET_LOW_POWER:
+			index = type - SOC_OFFSET_CHARGING;
+			if (fuelgauge->info.soc_offset[index].soc_offset_data) {
+				devm_kfree(dev, fuelgauge->info.soc_offset[index].soc_offset_data);
+				fuelgauge->info.soc_offset[index].soc_offset_data = NULL;
+			}
+			if (size_x != 0 && size_y != 0)
+				fuelgauge->info.soc_offset[index].soc_offset_data =
+					devm_kzalloc(dev, size_x * size_y * sizeof(data_point_t),
+							GFP_KERNEL);
+			if (fuelgauge->info.soc_offset[index].soc_offset_data) {
+				fuelgauge->info.soc_offset[index].soc_voltNR = size_x;
+				fuelgauge->info.soc_offset[index].tempNR = size_y;
+
+			} else {
+				fuelgauge->info.soc_offset[index].soc_voltNR = 0;
+				fuelgauge->info.soc_offset[index].tempNR = 0;
+			}
+			break;
+		default:
+			BUG();
+	}
+}
+
+#ifdef CONFIG_OF
+static int get_battery_id(struct sec_fuelgauge_info *fuelgauge)
+{
+	// rt5033fg does not support this function
+	return 0;
+}
+#define PROPERTY_NAME_SIZE 128
+
+#define PINFO(format, args...) \
+	printk(KERN_INFO "%s() line-%d: " format, \
+			__func__, __LINE__, ## args)
+
+typedef struct {
+	int data[3];
+} dt_offset_params_t;
+
+#define DECL_PARAM_PROP(_id, _name) {.id = _id, .name = _name,}
+static struct {
+	int id;
+	const char *name;
+} param_props[] = {
+	DECL_PARAM_PROP(NORMAL_VG_COMP, "vg_comp_normal"),
+	DECL_PARAM_PROP(IDLE_VG_COMP, "vg_comp_idle"),
+	DECL_PARAM_PROP(SOC_OFFSET_CHARGING, "offset_charging"),
+	DECL_PARAM_PROP(SOC_OFFSET_DISCHARGING, "offset_discharging"),
+	DECL_PARAM_PROP(SOC_OFFSET_SPECIAL, "offset_special"),
+	DECL_PARAM_PROP(SOC_OFFSET_LOW_POWER, "offset_low_power"),
+};
+
+static int rt5033_fg_parse_dt(struct sec_fuelgauge_info *fuelgauge)
+{
+	struct device *dev = &fuelgauge->client->dev;
+	struct device_node *np = dev->of_node;
+	char prop_name[PROPERTY_NAME_SIZE];
+	int battery_id = -1;
+	int sizes[2];
+	int ret;
+	int i, j, index;
+	dt_offset_params_t *offset_params;
+
+	BUG_ON(dev == 0);
+	BUG_ON(np == 0);
+	np = of_find_node_by_name(of_node_get(np), "battery_params");
+	if (np == NULL) {
+		PINFO("Cannot find child node \"battery_params\"\n");
+		return -EINVAL;
+	}
+
+	if (of_property_read_u32(np, "battery,id", &battery_id) < 0)
+		PINFO("not battery,id property\n");
+
+	if (battery_id == -1)
+		battery_id = get_battery_id(fuelgauge);
+	PINFO("battery id = %d\n", battery_id);
+	snprintf(prop_name, PROPERTY_NAME_SIZE,
+			"battery%d,vg_comp_interpolation_order", battery_id);
+	ret = of_property_read_u32_array(np, prop_name,
+			fuelgauge->info.vg_comp_interpolation_order, 2);
+	if (ret < 0)
+		fuelgauge->info.vg_comp_interpolation_order[0] =
+			fuelgauge->info.vg_comp_interpolation_order[1] = 2;
+	PINFO("vg_comp interpolation order = <%d %d>\n",
+			fuelgauge->info.vg_comp_interpolation_order[0],
+			fuelgauge->info.vg_comp_interpolation_order[1]);
+
+	for (i = NORMAL_VG_COMP; i <= IDLE_VG_COMP; ++i) {
+		index = i - NORMAL_VG_COMP;
+		snprintf(prop_name, PROPERTY_NAME_SIZE,
+				"battery%d,%s_size", battery_id, param_props[i].name);
+		sizes[0] = sizes[1] = 0;
+		ret = of_property_read_u32_array(np, prop_name, sizes, 2);
+		if (ret < 0) {
+			PINFO("Can get prop %s (%d)\n", prop_name, ret);
+		}
+		PINFO("%s = <%d %d>\n", prop_name, sizes[0], sizes[1]);
+		new_vgcomp_soc_offset_data(i, fuelgauge, sizes[0], sizes[1]);
+		if (fuelgauge->info.vg_comp[index].vg_comp_data) {
+
+			snprintf(prop_name, PROPERTY_NAME_SIZE,
+					"battery%d,%s_data", battery_id, param_props[i].name);
+
+			of_property_read_u32_array(np, prop_name,
+					(u32 *)fuelgauge->info.vg_comp[index].vg_comp_data,
+					sizes[0] * sizes[1] * 6);
+
+			for (j = 0; j < sizes[0] * sizes[1]; ++j) {
+				PINFO("<%d %d 0x%x 0x%x 0x%x 0x%x>\n",
+						fuelgauge->info.vg_comp[index].vg_comp_data[j].x,
+						fuelgauge->info.vg_comp[index].vg_comp_data[j].y,
+						fuelgauge->info.vg_comp[index].vg_comp_data[j].data[0],
+						fuelgauge->info.vg_comp[index].vg_comp_data[j].data[1],
+						fuelgauge->info.vg_comp[index].vg_comp_data[j].data[2],
+						fuelgauge->info.vg_comp[index].vg_comp_data[j].data[3]);
+			}
+		}
+	}
+
+	snprintf(prop_name, PROPERTY_NAME_SIZE,
+			"battery%d,offset_interpolation_order", battery_id);
+	ret = of_property_read_u32_array(np, prop_name,
+			fuelgauge->info.offset_interpolation_order, 2);
+	if (ret < 0)
+		fuelgauge->info.offset_interpolation_order[0] =
+			fuelgauge->info.offset_interpolation_order[1] = 2;
+	PINFO("offset interpolation order = <%d %d>\n",
+			fuelgauge->info.offset_interpolation_order[0],
+			fuelgauge->info.offset_interpolation_order[1]);
+
+	for (i = SOC_OFFSET_CHARGING; i <= SOC_OFFSET_LOW_POWER; ++i) {
+		index = i - SOC_OFFSET_CHARGING;
+		snprintf(prop_name, PROPERTY_NAME_SIZE,
+				"battery%d,%s_size", battery_id, param_props[i].name);
+		sizes[0] = sizes[1] = 0;
+		ret = of_property_read_u32_array(np, prop_name, sizes, 2);
+		if (ret < 0) {
+			PINFO("Can get prop %s (%d)\n", prop_name, ret);
+		}
+		PINFO("%s = <%d %d>\n", prop_name, sizes[0], sizes[1]);
+		new_vgcomp_soc_offset_data(i, fuelgauge, sizes[0], sizes[1]);
+		if (fuelgauge->info.soc_offset[index].soc_offset_data) {
+			offset_params = devm_kzalloc(dev,
+					sizes[0] * sizes[1] *
+					sizeof(dt_offset_params_t),
+					GFP_KERNEL);
+			snprintf(prop_name, PROPERTY_NAME_SIZE,
+					"battery%d,%s_data", battery_id, param_props[i].name);
+
+			of_property_read_u32_array(np, prop_name,
+					(u32 *)offset_params, sizes[0] * sizes[1] * 3);
+			for (j = 0; j < sizes[0] * sizes[1]; ++j) {
+				PINFO("<%d %d %d>\n", offset_params[j].data[0],
+						offset_params[j].data[1], offset_params[j].data[2]);
+				fuelgauge->info.soc_offset[index].soc_offset_data[j].x =
+					offset_params[j].data[0];
+				fuelgauge->info.soc_offset[index].soc_offset_data[j].y =
+					offset_params[j].data[1];
+				fuelgauge->info.soc_offset[index].soc_offset_data[j].offset =
+					offset_params[j].data[2];
+			}
+			devm_kfree(dev, offset_params);
+		}
+	}
+
+	snprintf(prop_name, PROPERTY_NAME_SIZE,
+			"battery%d,crate_idle_thres", battery_id);
+	ret = of_property_read_u32_array(np, prop_name,
+			&fuelgauge->info.crate_idle_thres, 1);
+	if (ret < 0)
+		fuelgauge->info.crate_idle_thres = 256; /* disable*/
+	PINFO("crate idle threshold = <%d>\n",
+			fuelgauge->info.crate_idle_thres);
+
+	snprintf(prop_name, PROPERTY_NAME_SIZE,
+			"battery%d,battery_type", battery_id);
+	ret = of_property_read_u32_array(np, prop_name,
+			&fuelgauge->info.battery_type, 1);
+	if (ret < 0)
+		fuelgauge->info.battery_type = 4350; /* default use 4350mV*/
+	PINFO("battery_type = <%d>\n",
+			fuelgauge->info.battery_type);
+	return 0;
+}
+#else
+static int rt5033_fg_parse_dt(struct sec_fuelgauge_info *fuelgauge)
+{
+	return 0;
+}
+#endif
+
+#ifdef CONFIG_DEBUG_FS
+
+static int dentry_id_to_comp_offset_type[] = {
+	[RT5033FG_OFFSET_CHARGING_SIZE] = SOC_OFFSET_CHARGING,
+	[RT5033FG_OFFSET_CHARGING_DATA] = SOC_OFFSET_CHARGING,
+	[RT5033FG_OFFSET_DISCHARGING_SIZE] = SOC_OFFSET_DISCHARGING,
+	[RT5033FG_OFFSET_DISCHARGING_DATA] = SOC_OFFSET_DISCHARGING,
+	[RT5033FG_OFFSET_SPECIAL_SIZE] = SOC_OFFSET_SPECIAL,
+	[RT5033FG_OFFSET_SPECIAL_DATA] = SOC_OFFSET_SPECIAL,
+	[RT5033FG_OFFSET_LOW_POWER_SIZE] = SOC_OFFSET_LOW_POWER,
+	[RT5033FG_OFFSET_LOW_POWER_DATA] = SOC_OFFSET_LOW_POWER,
+	[RT5033FG_VGCOMP_NORMAL_SIZE] = NORMAL_VG_COMP,
+	[RT5033FG_VGCOMP_NORMAL_DATA] = NORMAL_VG_COMP,
+	[RT5033FG_VGCOMP_IDLE_SIZE] = IDLE_VG_COMP,
+	[RT5033FG_VGCOMP_IDLE_DATA] = IDLE_VG_COMP,
+	[RT5033FG_PARAM_LOCK] = -1, /* dummy */
+	[RT5033FG_VGCOMP_IP_ORDER] = -1, /* dummy */
+	[RT5033FG_OFFSET_IP_ORDER] = -1, /* dummy */
+	[RT5033FG_CRATE_IDLE_THRES] = -1, /* dummy */
+};
+
+static int get_parameters(char *buf, long int *param, int num_of_par)
+{
+	char *token;
+	int base, cnt;
+
+	token = strsep(&buf, " ");
+
+	for (cnt = 0; cnt < num_of_par; cnt++) {
+		if (token != NULL) {
+			if ((token[1] == 'x') || (token[1] == 'X'))
+				base = 16;
+			else
+				base = 10;
+
+			if (strict_strtol(token, base, &param[cnt]) != 0)
+				return -EINVAL;
+
+			token = strsep(&buf, " ");
+		} else
+			return -EINVAL;
+	}
+	return 0;
+}
+
+typedef struct {
+	struct sec_fuelgauge_info *fuelgague;
+	int id;
+	int counter;
+} rt5033_dbg_private_data_t;
+
+
+#define MAX_PARAMS 6
+
+
+static int rt5033_fg_debug_open(struct inode *inode, struct file *file)
+{
+	file->private_data = inode->i_private;
+	return 0;
+}
+
+static ssize_t rt5033_fg_debug_write(struct file *filp,
+		const char __user *ubuf, size_t cnt, loff_t *ppos)
+{
+	rt5033_dbg_private_data_t *prv_data = filp->private_data;
+	rt5033_dbg_private_data_t *prv_data_header;
+	struct sec_fuelgauge_info *fuelgauge = prv_data->fuelgague;
+	data_point_t *data;
+	char lbuf[128];
+	int rc;
+	int index;
+	int comp_offset_type;
+	long int param[MAX_PARAMS];
+	if (cnt > sizeof(lbuf) - 1)
+		return -EINVAL;
+	rc = copy_from_user(lbuf, ubuf, cnt);
+	if (rc)
+		return -EFAULT;
+	lbuf[cnt] = '\0';
+	comp_offset_type = dentry_id_to_comp_offset_type[prv_data->id];
+	prv_data_header = prv_data - prv_data->id;
+	switch(prv_data->id) {
+		case RT5033FG_OFFSET_CHARGING_SIZE:
+		case RT5033FG_OFFSET_DISCHARGING_SIZE:
+		case RT5033FG_OFFSET_SPECIAL_SIZE:
+		case RT5033FG_OFFSET_LOW_POWER_SIZE:
+		case RT5033FG_VGCOMP_NORMAL_SIZE:
+		case RT5033FG_VGCOMP_IDLE_SIZE:
+			rc = get_parameters(lbuf, param, 2);
+			if (rc < 0)
+				return rc;
+			new_vgcomp_soc_offset_data(comp_offset_type, fuelgauge,
+					param[0], param[1]);
+			prv_data_header[prv_data->id + 1].counter = 0;
+			break;
+		case RT5033FG_OFFSET_CHARGING_DATA:
+		case RT5033FG_OFFSET_DISCHARGING_DATA:
+		case RT5033FG_OFFSET_SPECIAL_DATA:
+		case RT5033FG_OFFSET_LOW_POWER_DATA:
+			index = comp_offset_type - SOC_OFFSET_CHARGING;
+			rc = get_parameters(lbuf, param, 3);
+			if (rc < 0)
+				return rc;
+			data = fuelgauge->info.soc_offset[index].soc_offset_data +
+				prv_data->counter;
+			data->voltage = param[0];
+			data->temperature = param[1];
+			data->offset = param[2];
+
+			prv_data->counter++;
+			break;
+		case RT5033FG_VGCOMP_NORMAL_DATA:
+		case RT5033FG_VGCOMP_IDLE_DATA:
+			index = comp_offset_type - NORMAL_VG_COMP;
+			rc = get_parameters(lbuf, param, 6);
+			if (rc < 0)
+				return rc;
+			data = fuelgauge->info.vg_comp[index].vg_comp_data +
+				prv_data->counter;
+			data->voltage = param[0];
+			data->temperature = param[1];
+			data->vg_comp.data[0] = param[2];
+			data->vg_comp.data[1] = param[3];
+			data->vg_comp.data[2] = param[4];
+			data->vg_comp.data[3] = param[5];
+			prv_data->counter++;
+			break;
+		case RT5033FG_PARAM_LOCK:
+			rc = get_parameters(lbuf, param, 1);
+			if (rc < 0)
+				return rc;
+			if (param[0]) {
+				if (prv_data->counter == 0)
+					mutex_lock(&fuelgauge->info.param_lock);
+				prv_data->counter = 1;
+			} else {
+				if (prv_data->counter == 1)
+					mutex_unlock(&fuelgauge->info.param_lock);
+				prv_data->counter = 0;
+			}
+			break;
+		case RT5033FG_VGCOMP_IP_ORDER:
+			rc = get_parameters(lbuf, param, 2);
+			if (rc < 0)
+				return rc;
+			fuelgauge->info.vg_comp_interpolation_order[0] = param[0];
+			fuelgauge->info.vg_comp_interpolation_order[1] = param[1];
+			break;
+		case RT5033FG_OFFSET_IP_ORDER:
+			rc = get_parameters(lbuf, param, 2);
+			if (rc < 0)
+				return rc;
+			fuelgauge->info.offset_interpolation_order[0] = param[0];
+			fuelgauge->info.offset_interpolation_order[1] = param[1];
+			break;
+		case RT5033FG_CRATE_IDLE_THRES:
+			rc = get_parameters(lbuf, param, 1);
+			if (rc < 0)
+				return rc;
+			fuelgauge->info.crate_idle_thres = param[0];
+			break;
+		default:
+			BUG();
+	}
+
+	return cnt;
+}
+
+static ssize_t rt5033_fg_debug_read(struct file *filp, char __user *ubuf,
+		size_t count, loff_t *ppos)
+{
+	rt5033_dbg_private_data_t *prv_data = filp->private_data;
+	rt5033_dbg_private_data_t *prv_data_header;
+	struct sec_fuelgauge_info *fuelgauge = prv_data->fuelgague;
+	data_point_t *data;
+	char *lbuf = fuelgauge->info.dbg_out_buffer;
+	int index;
+	int comp_offset_type;
+	int i = 0, j = 0;
+	int data_size;
+	lbuf[0] = '\0';
+	comp_offset_type = dentry_id_to_comp_offset_type[prv_data->id];
+	prv_data_header = prv_data - prv_data->id;
+	switch(prv_data->id) {
+		case RT5033FG_OFFSET_CHARGING_SIZE:
+		case RT5033FG_OFFSET_DISCHARGING_SIZE:
+		case RT5033FG_OFFSET_SPECIAL_SIZE:
+		case RT5033FG_OFFSET_LOW_POWER_SIZE:
+			index = comp_offset_type - SOC_OFFSET_CHARGING;
+			snprintf(lbuf, RT5033_DBG_OUT_BUF_SIZE, "%d %d\n",
+					fuelgauge->info.soc_offset[index].soc_voltNR,
+					fuelgauge->info.soc_offset[index].tempNR);
+
+			break;
+		case RT5033FG_VGCOMP_NORMAL_SIZE:
+		case RT5033FG_VGCOMP_IDLE_SIZE:
+			index = comp_offset_type - NORMAL_VG_COMP;
+			snprintf(lbuf, RT5033_DBG_OUT_BUF_SIZE, "%d %d\n",
+					fuelgauge->info.vg_comp[index].voltNR,
+					fuelgauge->info.vg_comp[index].tempNR);
+			break;
+		case RT5033FG_OFFSET_CHARGING_DATA:
+		case RT5033FG_OFFSET_DISCHARGING_DATA:
+		case RT5033FG_OFFSET_SPECIAL_DATA:
+		case RT5033FG_OFFSET_LOW_POWER_DATA:
+			index = comp_offset_type - SOC_OFFSET_CHARGING;
+			data_size = fuelgauge->info.soc_offset[index].soc_voltNR *
+				fuelgauge->info.soc_offset[index].tempNR;
+			if (data_size == 0)
+				snprintf(lbuf, RT5033_DBG_OUT_BUF_SIZE, "no data\n");
+
+			data = fuelgauge->info.soc_offset[index].soc_offset_data;
+			for (i = 0; i < data_size; i++, data++) {
+				j += snprintf(lbuf + j, RT5033_DBG_OUT_BUF_SIZE - j,
+						"%d %d %d\n", data->voltage,
+						data->temperature, data->offset);
+			}
+
+			break;
+		case RT5033FG_VGCOMP_NORMAL_DATA:
+		case RT5033FG_VGCOMP_IDLE_DATA:
+			index = comp_offset_type - NORMAL_VG_COMP;
+			data_size = fuelgauge->info.vg_comp[index].voltNR *
+				fuelgauge->info.vg_comp[index].tempNR;
+			data = fuelgauge->info.vg_comp[index].vg_comp_data;
+			if (data_size == 0)
+				snprintf(lbuf, RT5033_DBG_OUT_BUF_SIZE, "no data\n");
+			for (i = 0; i < data_size; i++, data++) {
+				j += snprintf(lbuf + j, RT5033_DBG_OUT_BUF_SIZE - j,
+						"%d %d 0x%x 0x%x 0x%x 0x%x\n",
+						data->voltage, data->temperature,
+						data->vg_comp.data[0],
+						data->vg_comp.data[1],
+						data->vg_comp.data[2],
+						data->vg_comp.data[3]);
+			}
+
+			break;
+		case RT5033FG_PARAM_LOCK:
+			snprintf(lbuf, RT5033_DBG_OUT_BUF_SIZE, "%d\n",
+					prv_data->counter);
+			break;
+		case RT5033FG_VGCOMP_IP_ORDER:
+			snprintf(lbuf, RT5033_DBG_OUT_BUF_SIZE, "%d %d\n",
+					fuelgauge->info.vg_comp_interpolation_order[0],
+					fuelgauge->info.vg_comp_interpolation_order[1]);
+			break;
+		case RT5033FG_OFFSET_IP_ORDER:
+			snprintf(lbuf, RT5033_DBG_OUT_BUF_SIZE, "%d %d\n",
+					fuelgauge->info.offset_interpolation_order[0],
+					fuelgauge->info.offset_interpolation_order[1]);
+			break;
+		case RT5033FG_CRATE_IDLE_THRES:
+			snprintf(lbuf, RT5033_DBG_OUT_BUF_SIZE, "%d\n",
+					fuelgauge->info.crate_idle_thres);
+			break;
+		default:
+			BUG();
+	}
+	return simple_read_from_buffer(ubuf, count, ppos, lbuf, strlen(lbuf));
+}
+
+static const struct file_operations rt5033_fg_debug_ops = {
+	.open = rt5033_fg_debug_open,
+	.write = rt5033_fg_debug_write,
+	.read = rt5033_fg_debug_read
+};
+
+static const char *dbgfs_names[] = {
+	[RT5033FG_OFFSET_CHARGING_SIZE] = "offset_chg_size",
+	[RT5033FG_OFFSET_CHARGING_DATA] = "offset_chg_data",
+	[RT5033FG_OFFSET_DISCHARGING_SIZE] = "offset_dischg_size",
+	[RT5033FG_OFFSET_DISCHARGING_DATA] = "offset_dischg_data",
+	[RT5033FG_OFFSET_SPECIAL_SIZE] = "offset_spcl_size",
+	[RT5033FG_OFFSET_SPECIAL_DATA] = "offset_spcl_data",
+	[RT5033FG_OFFSET_LOW_POWER_SIZE] = "offset_low_power_size",
+	[RT5033FG_OFFSET_LOW_POWER_DATA] = "offset_low_power_data",
+	[RT5033FG_VGCOMP_NORMAL_SIZE] = "vgcomp_normal_size",
+	[RT5033FG_VGCOMP_NORMAL_DATA] = "vgcomp_normal_data",
+	[RT5033FG_VGCOMP_IDLE_SIZE] = "vgcomp_idle_size",
+	[RT5033FG_VGCOMP_IDLE_DATA] = "vgcomp_idle_data",
+	[RT5033FG_PARAM_LOCK] = "param_lock",
+	[RT5033FG_VGCOMP_IP_ORDER] = "vgcomp_ip_order",
+	[RT5033FG_OFFSET_IP_ORDER] = "offset_ip_order",
+	[RT5033FG_CRATE_IDLE_THRES] = "crate_idle_thres",
+};
+
+#define DECL_RT5033FG_PRV_DATA(_id) [_id] = {.id = _id, .counter = 0,}
+static rt5033_dbg_private_data_t rt5033_dbg_private_data[] = {
+	DECL_RT5033FG_PRV_DATA(RT5033FG_OFFSET_CHARGING_SIZE),
+	DECL_RT5033FG_PRV_DATA(RT5033FG_OFFSET_CHARGING_DATA),
+	DECL_RT5033FG_PRV_DATA(RT5033FG_OFFSET_DISCHARGING_SIZE),
+	DECL_RT5033FG_PRV_DATA(RT5033FG_OFFSET_DISCHARGING_DATA),
+	DECL_RT5033FG_PRV_DATA(RT5033FG_OFFSET_SPECIAL_SIZE),
+	DECL_RT5033FG_PRV_DATA(RT5033FG_OFFSET_SPECIAL_DATA),
+	DECL_RT5033FG_PRV_DATA(RT5033FG_OFFSET_LOW_POWER_SIZE),
+	DECL_RT5033FG_PRV_DATA(RT5033FG_OFFSET_LOW_POWER_DATA),
+	DECL_RT5033FG_PRV_DATA(RT5033FG_VGCOMP_NORMAL_SIZE),
+	DECL_RT5033FG_PRV_DATA(RT5033FG_VGCOMP_NORMAL_DATA),
+	DECL_RT5033FG_PRV_DATA(RT5033FG_VGCOMP_IDLE_SIZE),
+	DECL_RT5033FG_PRV_DATA(RT5033FG_VGCOMP_IDLE_DATA),
+	DECL_RT5033FG_PRV_DATA(RT5033FG_PARAM_LOCK),
+	DECL_RT5033FG_PRV_DATA(RT5033FG_VGCOMP_IP_ORDER),
+	DECL_RT5033FG_PRV_DATA(RT5033FG_OFFSET_IP_ORDER),
+	DECL_RT5033FG_PRV_DATA(RT5033FG_CRATE_IDLE_THRES),
+};
+
+static void rt5033_fg_create_debug_files(struct sec_fuelgauge_info *fuelgauge)
+{
+	int i;
+	fuelgauge->info.dir_dentry = debugfs_create_dir("rt5033fg_dbg", 0);
+	if (IS_ERR(fuelgauge->info.dir_dentry)) {
+		pr_err("%s : cannot create rt5033fg_dbg\n", __func__);
+		return;
+	}
+	BUG_ON(ARRAY_SIZE(dbgfs_names) != ARRAY_SIZE(rt5033_dbg_private_data));
+	BUG_ON(ARRAY_SIZE(dbgfs_names) != RT5033FG_DENTRY_NR);
+	for (i = 0; i < ARRAY_SIZE(dbgfs_names); ++i) {
+		rt5033_dbg_private_data[i].fuelgague = fuelgauge;
+		fuelgauge->info.file_dentries[i] =
+			debugfs_create_file(dbgfs_names[i],
+					S_IFREG | S_IRUGO, fuelgauge->info.dir_dentry,
+					&rt5033_dbg_private_data[i], &rt5033_fg_debug_ops);
+	}
+}
+#endif /* #ifdef CONFIG_DEBUG_FS */
+
+bool sec_hal_fg_init(struct i2c_client *client)
+{
+	int size_x, size_y;
+	int i, index;
+	struct sec_fuelgauge_info *fuelgauge = i2c_get_clientdata(client);
+	struct battery_data_t *battery_data;
+	pr_info("rt5033 hal fg init...\n");
+	mutex_init(&fuelgauge->info.param_lock);
+	mutex_lock(&fuelgauge->info.param_lock);
+	if (client->dev.of_node) {
+		// Load battery data from DTS
+		rt5033_fg_parse_dt(fuelgauge);
+
+	} else {
+		// Copy battery data from platform data
+		battery_data = &get_battery_data(fuelgauge);
+		fuelgauge->info.crate_idle_thres =
+			battery_data->crate_idle_thres;
+		fuelgauge->info.battery_type =
+			battery_data->battery_type;
+		fuelgauge->info.vg_comp_interpolation_order[0] =
+			battery_data->vg_comp_interpolation_order[0];
+		fuelgauge->info.vg_comp_interpolation_order[1] =
+			battery_data->vg_comp_interpolation_order[1];
+		fuelgauge->info.offset_interpolation_order[0] =
+			battery_data->offset_interpolation_order[0];
+		fuelgauge->info.offset_interpolation_order[1] =
+			battery_data->offset_interpolation_order[1];
+		for (i = NORMAL_VG_COMP; i <= IDLE_VG_COMP; ++i) {
+			index = i - NORMAL_VG_COMP;
+			size_x = battery_data->vg_comp[index].voltNR;
+			size_y = battery_data->vg_comp[index].tempNR;
+			dev_dbg(&client->dev,
+					"%s line %d: index = %d, size_x = %d, size_y = %d\n",
+					__func__, __LINE__, index, size_x, size_y);
+			new_vgcomp_soc_offset_data(i, fuelgauge, size_x, size_y);
+			if (fuelgauge->info.vg_comp[index].vg_comp_data) {
+				memcpy(fuelgauge->info.vg_comp[index].vg_comp_data,
+						battery_data->vg_comp[index].vg_comp_data,
+						sizeof(data_point_t) * size_x * size_y);
+			}
+		}
+		for (i = SOC_OFFSET_CHARGING; i <= SOC_OFFSET_LOW_POWER; ++i) {
+			index = i - SOC_OFFSET_CHARGING;
+			size_x = battery_data->soc_offset[index].soc_voltNR;
+			size_y = battery_data->soc_offset[index].tempNR;
+			dev_dbg(&client->dev,
+					"%s line %d: index = %d, size_x = %d, size_y = %d\n",
+					__func__, __LINE__, index, size_x, size_y);
+			new_vgcomp_soc_offset_data(i, fuelgauge, size_x, size_y);
+			if (fuelgauge->info.soc_offset[index].soc_offset_data) {
+				memcpy(fuelgauge->info.soc_offset[index].soc_offset_data,
+						battery_data->soc_offset[index].soc_offset_data,
+						sizeof(data_point_t) * size_x * size_y);
+			}
+		}
+	}
+	//struct battery_data_t *battery_data = &get_battery_data(fuelgauge);
+
+	rt5033_fg_init(client);
+	rt5033_pr_ver_info(client);
+	fuelgauge->info.init_once = true;
+	fuelgauge->info.pre_soc = 50;
+	fuelgauge->info.move_avg_offset_cnt = 0;
+	fuelgauge->info.volt_alert_flag = false;
+	fuelgauge->info.soc_alert_flag = false;
+	fuelgauge->info.bat_pres_flag = true;
+	fuelgauge->info.offs_speci_case = false;
+	fuelgauge->info.temperature = 250;
+	fuelgauge->info.entry_suspend_flag = false;
+
+#ifdef CONFIG_DEBUG_FS
+	rt5033_fg_create_debug_files(fuelgauge);
+#endif
+	mutex_unlock(&fuelgauge->info.param_lock);
+	pr_info("rt5033 hal fg init OK\n");
+	return true;
+}
+
+bool sec_hal_fg_suspend(struct i2c_client *client)
+{
+
+	int volt_suspend;
+	int temp_suspend;
+	int ret;
+	vg_comp_data_t vgcomp;
+	struct sec_fuelgauge_info *fuelgauge = i2c_get_clientdata(client);
+	fuelgauge->info.entry_suspend_flag = true;
+	/* vgcomp */
+	volt_suspend = fg_get_avg_volt(client);
+	temp_suspend = fuelgauge->info.temperature / 10;
+
+	// report FG_AVG_VOLT & FG_TEMP for debugging.
+	pr_info("%s : FG_AVG_VOLT = %d, FG_TEMP = %d\n", __func__,
+			volt_suspend, fuelgauge->info.temperature);
+
+	vgcomp = rt5033_fg_get_vgcomp(fuelgauge, VGCOMP_IDLE,
+			volt_suspend, fuelgauge->info.temperature);
+	ret = (vgcomp.data[0] << 8) | vgcomp.data[1];
+	rt5033_fg_i2c_write_word(client, RT5033_VGCOMP1, ret);
+	ret = (vgcomp.data[2] << 8) | vgcomp.data[3];
+	rt5033_fg_i2c_write_word(client, RT5033_VGCOMP3, ret);
+
+	// report VGCOMP1 ~ 4 for debugging.
+	ret = rt5033_fg_i2c_read_word(client, RT5033_VGCOMP1);
+	pr_info("%s : FG_VGCOMP1_2_Idle = 0x%04x\n", __func__, ret);
+	ret = rt5033_fg_i2c_read_word(client, RT5033_VGCOMP3);
+	pr_info("%s : FG_VGCOMP3_4_Idle = 0x%04x\n", __func__, ret);
+
+	return true;
+}
+
+bool sec_hal_fg_resume(struct i2c_client *client)
+{
+	struct sec_fuelgauge_info *fuelgauge = i2c_get_clientdata(client);
+#if 0
+	int ret;
+	/* disable hibernate mode */
+	ret = rt5033_fg_i2c_read_word(client, RT5033_CONFIG_MSB);
+	if (ret & 0x8000)
+		rt5033_fg_i2c_write_word(client,
+				RT5033_MFA_MSB, MFA_CMD_EXIT_HIB);
+#endif
+	fuelgauge->info.init_once = true;
+	fuelgauge->info.entry_suspend_flag = false;
+	return true;
+}
+
+bool sec_hal_fg_fuelalert_init(struct i2c_client *client, int soc)
+{
+	struct sec_fuelgauge_info *fuelgauge = i2c_get_clientdata(client);
+	int ret;
+
+	ret = rt5033_fg_i2c_read_word(client, RT5033_FG_IRQ_CTRL);
+	/* enable volt, soc and battery presence alert irq; clear volt and soc alert status via i2c */
+	ret |= 0x1f00;
+	rt5033_fg_i2c_write_word(client, RT5033_FG_IRQ_CTRL, ret);
+	fuelgauge->info.irq_ctrl = ret;
+	/* set volt and soc alert threshold */
+	ret = 0;
+	ret = VOLT_ALRT_TH << 8;
+	ret += soc;
+	rt5033_fg_i2c_write_word(client, RT5033_VOLT_ALRT_TH, ret);
+
+	/* reset soc alert flag */
+	fuelgauge->info.soc_alert_flag = false;
+
+	return true;
+}
+
+bool sec_hal_fg_is_fuelalerted(struct i2c_client *client)
+{
+	int ret;
+	bool retval;
+	union power_supply_propval val;
+	struct sec_fuelgauge_info *fuelgauge = i2c_get_clientdata(client);
+
+	ret = rt5033_fg_i2c_read_word(client, RT5033_FG_IRQ_CTRL);
+	if (ret < 0) {
+		printk("rt5033 fg is alerted : i2c read error(%d)\n", ret);
+		return false;
+	}
+
+	retval = (ret & 0x03) ? true : false;
+	fuelgauge->info.irq_ctrl = ret & (~0x04);
+
+	if (ret & 0x04) { /* battery detection INT */
+		ret = rt5033_fg_i2c_read_word(client, RT5033_FG_IRQ_CTRL);
+		ret &= (~0x04);
+		rt5033_fg_i2c_write_word(client, RT5033_FG_IRQ_CTRL, ret);
+
+		ret = rt5033_fg_i2c_read_word(client, RT5033_CONFIG_MSB);
+		if (ret & 0x0002) /* battery inserted */
+			fuelgauge->info.bat_pres_flag = true;
+		else	/* battery removed */
+			fuelgauge->info.bat_pres_flag = false;
+
+		/* send Quick Sensing command to 5033FG */
+		if (fuelgauge->info.bat_pres_flag) {
+			dev_info(&client->dev, "%s: Battery Inserted! Do QS...\n",
+					__func__);
+			msleep(1000);
+			rt5033_fg_i2c_write_word(client, 0x06, 0x8000);
+		} else {
+			dev_info(&client->dev, "%s: Battery Removed !!!\n",
+					__func__);
+			if (fuelgauge->pdata->check_jig_status &&
+					!fuelgauge->pdata->check_jig_status()) {
+				/* Enable SHDN */
+				ret = rt5033_fg_i2c_read_word(client, RT5033_CONFIG_MSB);
+				ret |= 0x0080;
+				rt5033_fg_i2c_write_word(client, RT5033_CONFIG_MSB, ret);
+				val.intval = POWER_SUPPLY_TYPE_BATTERY;
+				psy_do_property("sec-charger", set,
+						POWER_SUPPLY_PROP_ONLINE, val);
+			}
+		}
+	}
+	return retval;
+}
+
+bool sec_hal_fg_fuelalert_process(void *irq_data, bool is_fuel_alerted)
+{
+
+	struct sec_fuelgauge_info *fuelgauge = irq_data;
+	struct i2c_client *client = fuelgauge->client;
+	int ret;
+	int ret2;
+	int temp;
+
+	ret = fuelgauge->info.irq_ctrl;
+
+	/* soc alert process */
+	if (ret & 0x01)	{
+		temp = ret;
+		// disable soc alert
+		ret2 = rt5033_fg_i2c_read_word(client, RT5033_VOLT_ALRT_TH);
+		ret2 &= 0xff00;
+		rt5033_fg_i2c_write_word(client, RT5033_VOLT_ALRT_TH, ret2);
+		// clear soc alert status
+		temp &= 0xfffe;
+		rt5033_fg_i2c_write_word(client, RT5033_FG_IRQ_CTRL, temp);
+		// set soc alert flag
+		fuelgauge->info.soc_alert_flag = true;
+	}
+
+	/* voltage alert process */
+	if (ret & 0x02)	{
+		temp = ret;
+		/* disable voltage alert */
+		ret2 = rt5033_fg_i2c_read_word(client, RT5033_VOLT_ALRT_TH);
+		ret2 &= 0x00ff;
+		rt5033_fg_i2c_write_word(client, RT5033_VOLT_ALRT_TH, ret2);
+		/* clear voltage alert status */
+		temp &= 0xfffd;
+		rt5033_fg_i2c_write_word(client, RT5033_FG_IRQ_CTRL, temp);
+		rt5033_fg_i2c_write_word(client, RT5033_MFA_MSB, MFA_CMD_VALRT_SOC);
+		fuelgauge->info.volt_alert_flag = true;
+	}
+	return true;
+}
+
+bool sec_hal_fg_full_charged(struct i2c_client *client)
+{
+	struct sec_fuelgauge_info *fuelgauge = i2c_get_clientdata(client);
+	fuelgauge->info.flag_full_charge = 1;
+	return true;
+}
+
+bool sec_hal_fg_reset(struct i2c_client *client)
+{
+	rt5033_fg_i2c_write_word(client, 0x06, 0x4000);
+	return true;
+}
+
+bool sec_hal_fg_get_property(struct i2c_client *client,
+		enum power_supply_property psp,
+		union power_supply_propval *val)
+{
+	union power_supply_propval value;
+	struct sec_fuelgauge_info *fuelgauge =
+		i2c_get_clientdata(client);
+
+	psy_do_property("sec-charger", get,
+			POWER_SUPPLY_PROP_STATUS, value);
+	fuelgauge->info.flag_full_charge =
+		(value.intval == POWER_SUPPLY_STATUS_FULL) ? 1 : 0;
+	fuelgauge->info.flag_chg_status =
+		(value.intval == POWER_SUPPLY_STATUS_CHARGING) ? 1 : 0;
+
+	switch (psp) {
+		/* Cell voltage (VCELL, mV) */
+		case POWER_SUPPLY_PROP_VOLTAGE_NOW:
+			val->intval = fg_get_vbat(client);
+			break;
+			/* Additional Voltage Information (mV) */
+		case POWER_SUPPLY_PROP_VOLTAGE_AVG:
+			switch (val->intval) {
+				case SEC_BATTEY_VOLTAGE_AVERAGE:
+					val->intval = fg_get_avg_volt(client);
+					break;
+				case SEC_BATTEY_VOLTAGE_OCV:
+					val->intval = fg_get_ocv(client);
+					break;
+			}
+			break;
+		case POWER_SUPPLY_PROP_PRESENT:
+			val->intval = rt5033_fg_get_batt_present(client);
+			break;
+			/* Current (mA) */
+		case POWER_SUPPLY_PROP_CURRENT_NOW:
+			/* Average Current (mA) */
+		case POWER_SUPPLY_PROP_CURRENT_AVG:
+			break;
+		case POWER_SUPPLY_PROP_CHARGE_FULL:
+			val->intval =
+				(fuelgauge->info.batt_soc >= 1000) ? true : false;
+			break;
+			/* SOC (%) */
+		case POWER_SUPPLY_PROP_CAPACITY:
+			/* RT5033 F/G unit is 0.1%, raw ==> convert the unit to 0.01% */
+			if (val->intval == SEC_FUELGAUGE_CAPACITY_TYPE_RAW)
+				val->intval = fg_get_soc(client) * 10;
+			else
+				val->intval = fg_get_soc(client);
+			break;
+			/* Battery Temperature */
+		case POWER_SUPPLY_PROP_TEMP:
+			/* Target Temperature */
+		case POWER_SUPPLY_PROP_TEMP_AMBIENT:
+			val->intval = fuelgauge->info.temperature;
+			break;
+		default:
+			return false;
+	}
+	return true;
+}
+
+bool sec_hal_fg_set_property(struct i2c_client *client,
+		enum power_supply_property psp,
+		const union power_supply_propval *val)
+{
+	struct sec_fuelgauge_info *fuelgauge = i2c_get_clientdata(client);
+	switch(psp) {
+		/* Battery Temperature */
+		case POWER_SUPPLY_PROP_TEMP:
+		case POWER_SUPPLY_PROP_TEMP_AMBIENT:
+			fuelgauge->info.temperature = val->intval;
+			break;
+		default:
+			return false;
+	}
+	return true;
+}
+
+ssize_t sec_hal_fg_show_attrs(struct device *dev,
+		const ptrdiff_t offset, char *buf)
+{
+
+	struct power_supply *psy = dev_get_drvdata(dev);
+	struct sec_fuelgauge_info *fg =
+		container_of(psy, struct sec_fuelgauge_info, psy_fg);
+	struct sec_fg_info *info = &fg->info;
+	int i = 0;
+
+	switch(offset) {
+		/*	case FG_REG: */
+		/*		break; */
+		case FG_DATA:
+			i += scnprintf(buf + i, PAGE_SIZE - i, "%02x%02x\n",
+					info->reg_data[1], info->reg_data[0]);
+			break;
+		default:
+			i = -EINVAL;
+			break;
+	}
+	return i;
+}
+
+ssize_t sec_hal_fg_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_fuelgauge_info *fg =
+		container_of(psy, struct sec_fuelgauge_info, psy_fg);
+	struct sec_fg_info *info = &fg->info;
+	int ret = 0;
+	int x = 0;
+	int data;
+
+	switch (offset) {
+		case FG_REG:
+			if (sscanf(buf, "%x\n", &x) == 1) {
+				info->reg_addr = x;
+				data = rt5033_fg_i2c_read_word(fg->client,
+						info->reg_addr);
+				info->reg_data[0] = data & 0xff;
+				info->reg_data[1] = (data >> 8) & 0xff;
+				dev_dbg(info->dev,
+						"%s: (read) addr = 0x%x, data = 0x%02x%02x\n",
+						__func__, info->reg_addr,
+						info->reg_data[1], info->reg_data[0]);
+				ret = count;
+			}
+			break;
+		case FG_DATA:
+			if (sscanf(buf, "%x\n", &x) == 1) {
+				info->reg_data[0] = (x & 0xFF00) >> 8;
+				info->reg_data[1] = (x & 0x00FF);
+				dev_dbg(info->dev,
+						"%s: (write) addr = 0x%x, data = 0x%02x%02x\n",
+						__func__, info->reg_addr, info->reg_data[1], info->reg_data[0]);
+
+				rt5033_fg_i2c_write_word(fg->client,
+						info->reg_addr, x);
+				ret = count;
+			}
+			break;
+		default:
+			ret = -EINVAL;
+			break;
+	}
+
+	return ret;
+}