Initial file dump from open source releaseHEADmaster

1 files changed, 1154 insertions, 0 deletions

diff --git a/drivers/battery/sec_dt_init.c b/drivers/battery/sec_dt_init.c
new file mode 100644
index 00000000..70559605
--- /dev/null
+++ b/drivers/battery/sec_dt_init.c
@@ -0,0 +1,1154 @@
+/*
+ *  sec_dt_init.c
+ *  Samsung battery data parsing from device tree
+ *
+ *  Copyright (C) 2014 Samsung Electronics
+ *
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+
+#include <linux/of_device.h>
+#include <linux/of_gpio.h>
+#include <linux/of_irq.h>
+#include <soc/sprd/adc.h>
+#include <linux/battery/sec_battery.h>
+
+#include <soc/sprd/sci_glb_regs.h>
+#include <soc/sprd/sci.h>
+#include <soc/sprd/adi.h>
+#include <soc/sprd/arch_misc.h>
+#include <soc/sprd/hardware.h>
+#include <linux/delay.h>
+
+#ifdef CONFIG_MFD_RT8973
+#include <linux/mfd/rt8973.h>
+#endif
+#ifdef CONFIG_SM5502_MUIC
+#include <linux/mfd/sm5502-muic.h>
+#endif
+#ifdef CONFIG_MFD_SM5504
+#include <linux/mfd/sm5504.h>
+#endif
+#ifdef CONFIG_FUELGAUGE_SPRD4SAMSUNG27X3
+#include <linux/battery/fuelgauge/sprd27x3_fuelgauge4samsung.h>
+#endif
+
+#define BATT_DET_CURRENT 313
+
+static int current_cable_type = POWER_SUPPLY_TYPE_BATTERY;
+static u8 attached_cable;
+static bool is_jig_on;
+/* static unsigned int lpcharge; */
+/* EXPORT_SYMBOL(lpcharge); */
+unsigned int lpcharge;
+EXPORT_SYMBOL(lpcharge);
+static unsigned chg_irq;
+static int gpio_vbat_detect;
+
+#if defined(CONFIG_INPUT_TOUCHSCREEN)
+void (*tsp_charger_status_cb)(int);
+EXPORT_SYMBOL(tsp_charger_status_cb);
+#endif
+
+static bool sec_fg_gpio_init(void)
+{
+	return true;
+}
+
+static bool sec_fg_fuelalert_process(bool is_fuel_alerted) { return true; }
+
+static bool sec_bat_adc_none_init(struct platform_device *pdev) { return true; }
+static bool sec_bat_adc_none_exit(void) { return true; }
+static int sec_bat_adc_none_read(unsigned int channel) { return 0; }
+
+static bool sec_bat_adc_ap_init(struct platform_device *pdev) { return true; }
+static bool sec_bat_adc_ap_exit(void) { return true; }
+
+static bool sec_bat_adc_ic_init(struct platform_device *pdev) { return true; }
+static bool sec_bat_adc_ic_exit(void) { return true; }
+static int sec_bat_adc_ic_read(unsigned int channel) { return 0; }
+
+static sec_bat_adc_api_t adc_api[SEC_BATTERY_ADC_TYPE_NUM] = {
+	{
+		.init = sec_bat_adc_none_init,
+		.exit = sec_bat_adc_none_exit,
+		.read = sec_bat_adc_none_read
+	},
+	{
+		.init = sec_bat_adc_ap_init,
+		.exit = sec_bat_adc_ap_exit,
+	},
+	{
+		.init = sec_bat_adc_ic_init,
+		.exit = sec_bat_adc_ic_exit,
+		.read = sec_bat_adc_ic_read
+	}
+};
+
+static bool sec_chg_gpio_init(void)
+{
+	return true;
+}
+
+bool sec_bat_check_cable_result_callback(int cable_type)
+{
+	bool ret = true;
+	current_cable_type = cable_type;
+
+	switch (cable_type) {
+	case POWER_SUPPLY_TYPE_USB:
+		pr_info("%s set vbus applied\n",
+				__func__);
+		break;
+	case POWER_SUPPLY_TYPE_BATTERY:
+		pr_info("%s set vbus cut\n",
+				__func__);
+		break;
+	case POWER_SUPPLY_TYPE_MAINS:
+		break;
+	default:
+		pr_err("%s cable type (%d)\n",
+				__func__, cable_type);
+		ret = false;
+		break;
+	}
+
+	return ret;
+}
+
+static bool sec_bat_ovp_uvlo_result_callback(int health)
+{
+	return true;
+}
+
+/* Get LP charging mode state */
+static int sec_bat_is_lpm_check(char *str)
+{
+        if (strncmp(str, "charger", 7) == 0)
+                lpcharge = 1;
+
+        pr_info("%s: Low power charging mode: %d\n", __func__, lpcharge);
+
+        return lpcharge;
+}
+__setup("androidboot.mode=", sec_bat_is_lpm_check);
+
+bool sec_bat_is_lpm(void)
+{
+	return lpcharge == 1 ? true : false;
+}
+/*
+ * val.intval : temperature
+ */
+static bool sec_bat_get_temperature_callback(
+		enum power_supply_property psp,
+		union power_supply_propval *val)
+{
+	return true;
+}
+
+void check_jig_status(int status)
+{
+	if (status) {
+		pr_info("%s: JIG On so reset fuel gauge capacity\n", __func__);
+		is_jig_on = true;
+	}
+
+}
+
+bool sec_bat_check_jig_status(void)
+{
+	return is_jig_on;
+}
+
+//int sec_bat_check_cable_callback(void)
+int sec_bat_check_cable_callback(struct sec_battery_info *battery)
+{
+	int ta_nconnected;
+	union power_supply_propval value;
+	struct power_supply *psy = power_supply_get_by_name("battery");
+
+	ta_nconnected = gpio_get_value(chg_irq);
+
+	pr_info("%s : ta_nconnected : %d\n", __func__, ta_nconnected);
+
+	if (ta_nconnected)
+		current_cable_type = POWER_SUPPLY_TYPE_BATTERY;
+	else
+		current_cable_type = POWER_SUPPLY_TYPE_MAINS;
+
+#ifdef CONFIG_MFD_RT8973
+	if (attached_cable == MUIC_RT8973_CABLE_TYPE_0x1A) {
+		if (ta_nconnected)
+			current_cable_type = POWER_SUPPLY_TYPE_BATTERY;
+		else
+			current_cable_type = POWER_SUPPLY_TYPE_MISC;
+	} else
+		return current_cable_type;
+#endif
+
+#ifdef CONFIG_MFD_SM5504
+	if (attached_cable == MUIC_SM5504_CABLE_TYPE_0x1A) {
+		if (ta_nconnected)
+			current_cable_type = POWER_SUPPLY_TYPE_BATTERY;
+		else
+			current_cable_type = POWER_SUPPLY_TYPE_MISC;
+	} else
+		return current_cable_type;
+#endif
+	if (!psy || !psy->set_property)
+		pr_err("%s: fail to get battery psy\n", __func__);
+	else {
+		value.intval = current_cable_type;
+		psy->set_property(psy, POWER_SUPPLY_PROP_ONLINE, &value);
+	}
+
+	return current_cable_type;
+}
+
+void sec_bat_initial_check(void)
+{
+	union power_supply_propval value;
+
+	if (POWER_SUPPLY_TYPE_BATTERY < current_cable_type) {
+		value.intval = current_cable_type;
+		psy_do_property("battery", set,
+			POWER_SUPPLY_PROP_ONLINE, value);
+	} else {
+		psy_do_property("sec-charger", get,
+				POWER_SUPPLY_PROP_ONLINE, value);
+		if (value.intval == POWER_SUPPLY_TYPE_WPC) {
+			value.intval = POWER_SUPPLY_TYPE_WPC;
+			psy_do_property("battery", set,
+					POWER_SUPPLY_PROP_ONLINE, value);
+		}
+#if 0
+		else {
+			value.intval = POWER_SUPPLY_TYPE_BATTERY;
+				psy_do_property("sec-charger", set,
+					POWER_SUPPLY_PROP_ONLINE, value);
+		}
+#endif
+	}
+}
+
+static bool sec_bat_gpio_init(void)
+{
+	return true;
+}
+
+//static bool sec_bat_check_callback(void) { return true; }
+extern bool sec_bat_check_callback(struct sec_battery_info *battery){return true; }
+static bool sec_bat_check_result_callback(void) { return true; }
+
+/* callback for OVP/UVLO check
+ * return : int
+ * battery health
+ */
+static int sec_bat_ovp_uvlo_callback(void)
+{
+	int health;
+	health = POWER_SUPPLY_HEALTH_GOOD;
+
+	return health;
+}
+
+#if defined(CONFIG_SENSORS_GRIP_SX9500) && defined(CONFIG_MACH_DEGAS)
+extern void charger_status_cb(int status);
+#endif
+
+#ifdef CONFIG_MFD_RT8973
+void sec_charger_cb(u8 cable_type)
+{
+	union power_supply_propval value;
+	struct power_supply *psy = power_supply_get_by_name("battery");
+
+	pr_info("%s: cable type (0x%02x)\n", __func__, cable_type);
+
+	attached_cable = cable_type;
+
+	switch (cable_type) {
+	case MUIC_RT8973_CABLE_TYPE_NONE:
+	case MUIC_RT8973_CABLE_TYPE_JIG_UART_OFF:
+		current_cable_type = POWER_SUPPLY_TYPE_BATTERY;
+		break;
+	case MUIC_RT8973_CABLE_TYPE_USB:
+	case MUIC_RT8973_CABLE_TYPE_L_USB:
+	case MUIC_RT8973_CABLE_TYPE_CDP:
+	case MUIC_RT8973_CABLE_TYPE_JIG_USB_ON:
+	case MUIC_RT8973_CABLE_TYPE_JIG_USB_OFF:
+		current_cable_type = POWER_SUPPLY_TYPE_USB;
+		break;
+	case MUIC_RT8973_CABLE_TYPE_REGULAR_TA:
+	case MUIC_RT8973_CABLE_TYPE_ATT_TA:
+	case MUIC_RT8973_CABLE_TYPE_JIG_UART_OFF_WITH_VBUS:
+	case MUIC_RT8973_CABLE_TYPE_JIG_UART_ON_WITH_VBUS:
+	case MUIC_RT8973_CABLE_TYPE_TYPE1_CHARGER:
+		current_cable_type = POWER_SUPPLY_TYPE_MAINS;
+		break;
+	case MUIC_RT8973_CABLE_TYPE_OTG:
+		goto skip;
+	case MUIC_RT8973_CABLE_TYPE_0x15:
+	case MUIC_RT8973_CABLE_TYPE_0x1A:
+	//case MUIC_RT8973_CABLE_TYPE_0x1A_VBUS:
+		current_cable_type = POWER_SUPPLY_TYPE_MISC;
+		break;
+	default:
+		pr_err("%s: invalid type for charger:%d\n",
+			__func__, cable_type);
+		current_cable_type = POWER_SUPPLY_TYPE_UNKNOWN;
+		goto skip;
+	}
+
+	if (!psy || !psy->set_property)
+		pr_err("%s: fail to get battery psy\n", __func__);
+	else {
+		value.intval = current_cable_type;
+		psy->set_property(psy, POWER_SUPPLY_PROP_ONLINE, &value);
+
+#if defined(CONFIG_INPUT_TOUCHSCREEN)
+	/* for changing of tsp operation mode */
+		if (tsp_charger_status_cb)
+			tsp_charger_status_cb(current_cable_type);
+#endif
+	}
+
+skip:
+	return 0;
+}
+#endif
+
+#ifdef CONFIG_SM5502_MUIC
+void sec_charger_cb(u8 cable_type)
+{
+
+	union power_supply_propval value;
+	struct power_supply *psy = power_supply_get_by_name("battery");
+
+	pr_info("%s: cable type (0x%02x)\n", __func__, cable_type);
+
+	attached_cable = cable_type;
+	is_jig_on = false;
+
+	switch (cable_type) {
+	case CABLE_TYPE_NONE_MUIC:
+	case CABLE_TYPE2_DESKDOCK_MUIC:
+		current_cable_type = POWER_SUPPLY_TYPE_BATTERY;
+		break;
+	case CABLE_TYPE1_USB_MUIC:
+		current_cable_type = POWER_SUPPLY_TYPE_USB;
+		break;
+	case CABLE_TYPE1_TA_MUIC:
+	case CABLE_TYPE3_U200CHG_MUIC:
+	case CABLE_TYPE3_NONSTD_SDP_MUIC:
+		pr_info("%s: VBUS Online\n", __func__);
+		current_cable_type = POWER_SUPPLY_TYPE_MAINS;
+		break;
+	case CABLE_TYPE2_JIG_UART_OFF_VB_MUIC:
+	case CABLE_TYPE2_JIG_UART_ON_VB_MUIC:
+		is_jig_on = true;
+		current_cable_type = POWER_SUPPLY_TYPE_MAINS;
+		break;
+	case CABLE_TYPE1_OTG_MUIC:
+		goto skip;
+	case CABLE_TYPE2_JIG_UART_OFF_MUIC:
+		is_jig_on = true;
+		current_cable_type = POWER_SUPPLY_TYPE_BATTERY;
+		break;
+	case CABLE_TYPE2_JIG_USB_ON_MUIC:
+	case CABLE_TYPE2_JIG_USB_OFF_MUIC:
+		is_jig_on = true;
+		current_cable_type = POWER_SUPPLY_TYPE_USB;
+		break;
+	case CABLE_TYPE1_CARKIT_T1OR2_MUIC:
+		current_cable_type = POWER_SUPPLY_TYPE_USB;
+		break;
+	case CABLE_TYPE3_DESKDOCK_VB_MUIC:
+		current_cable_type = POWER_SUPPLY_TYPE_MISC;
+		break;
+	default:
+		pr_err("%s: invalid type for charger:%d\n",
+			__func__, cable_type);
+		current_cable_type = POWER_SUPPLY_TYPE_UNKNOWN;
+		goto skip;
+	}
+
+	if (!psy || !psy->set_property)
+		pr_err("%s: fail to get battery psy\n", __func__);
+	else {
+		value.intval = current_cable_type;
+		psy->set_property(psy, POWER_SUPPLY_PROP_ONLINE, &value);
+
+#if defined(CONFIG_INPUT_TOUCHSCREEN)
+	/* for changing of tsp operation mode */
+		if (tsp_charger_status_cb)
+			tsp_charger_status_cb(current_cable_type);
+#endif
+	}
+#if defined(CONFIG_SENSORS_GRIP_SX9500) && defined(CONFIG_MACH_DEGAS)
+	/* for grip sensor threshold change at TA/USB status - sx9500.c */
+	charger_status_cb(current_cable_type);
+#endif
+
+skip:
+	return;
+}
+#endif /* CONFIG_SM5502_MUIC */
+
+
+#ifdef CONFIG_MFD_SM5504
+void sec_charger_cb(u8 cable_type)
+{
+	union power_supply_propval value;
+	struct power_supply *psy = power_supply_get_by_name("battery");
+
+	pr_info("%s: cable type (0x%02x)\n", __func__, cable_type);
+
+	attached_cable = cable_type;
+
+	switch (cable_type) {
+	case MUIC_SM5504_CABLE_TYPE_NONE:
+	case MUIC_SM5504_CABLE_TYPE_JIG_UART_ON:
+	case MUIC_SM5504_CABLE_TYPE_JIG_UART_OFF:
+	case MUIC_SM5504_CABLE_TYPE_JIG_UART_ON_WITH_VBUS:
+		current_cable_type = POWER_SUPPLY_TYPE_BATTERY;
+		break;
+	case MUIC_SM5504_CABLE_TYPE_USB:
+	case MUIC_SM5504_CABLE_TYPE_CDP:
+	case MUIC_SM5504_CABLE_TYPE_L_USB:
+	case MUIC_SM5504_CABLE_TYPE_JIG_USB_ON:
+	case MUIC_SM5504_CABLE_TYPE_JIG_USB_OFF:
+		current_cable_type = POWER_SUPPLY_TYPE_USB;
+		break;
+	case MUIC_SM5504_CABLE_TYPE_REGULAR_TA:
+	case MUIC_SM5504_CABLE_TYPE_ATT_TA:
+	case MUIC_SM5504_CABLE_TYPE_JIG_UART_OFF_WITH_VBUS:
+	case MUIC_SM5504_CABLE_TYPE_TYPE1_CHARGER:
+		current_cable_type = POWER_SUPPLY_TYPE_MAINS;
+		break;
+	case MUIC_SM5504_CABLE_TYPE_UART:
+		current_cable_type = POWER_SUPPLY_TYPE_UNKNOWN;
+		break;
+	case MUIC_SM5504_CABLE_TYPE_OTG:
+	case MUIC_SM5504_CABLE_TYPE_OTG_WITH_VBUS:
+		current_cable_type = POWER_SUPPLY_TYPE_OTG;
+		break;
+	case MUIC_SM5504_CABLE_TYPE_0x15:
+	case MUIC_SM5504_CABLE_TYPE_0x1A:
+//	case MUIC_SM5504_CABLE_TYPE_0x1A_VBUS:
+		current_cable_type = POWER_SUPPLY_TYPE_MISC;
+		break;
+	default:
+		pr_err("%s: invalid type for charger:%d\n",
+			__func__, cable_type);
+		current_cable_type = POWER_SUPPLY_TYPE_UNKNOWN;
+		goto skip;
+	}
+
+	if (!psy || !psy->set_property)
+		pr_err("%s: fail to get battery psy\n", __func__);
+	else {
+		value.intval = current_cable_type;
+		psy->set_property(psy, POWER_SUPPLY_PROP_ONLINE, &value);
+
+#if defined(CONFIG_INPUT_TOUCHSCREEN)
+	/* for changing of tsp operation mode */
+		if (tsp_charger_status_cb)
+			tsp_charger_status_cb(current_cable_type);
+#endif
+	}
+
+skip:
+	return 0;
+
+}
+#endif /* CONFIG_MFD_SM5504 */
+
+int sec_vf_adc_current_check(void)
+{
+        int battery_on = 0;
+
+	sci_adi_set(ANA_REG_GLB_AUXAD_CTL,
+		(BIT_AUXAD_CURRENTSEN_EN | BITS_AUXAD_CURRENT_IBS(0x6)));
+	sci_adi_set(ANA_REG_GLB_BATDET_CUR_CTRL,
+		(BIT_BATDET_CUR_EN | BITS_BATDET_CUR_I(0x4)));
+	mdelay(5);
+
+        if (gpio_get_value(gpio_vbat_detect))
+        {
+                printk("%s : vbat good!\n", __func__);
+                battery_on = 1;
+        }
+        else
+        {
+                printk("%s : vbat is not connected!\n", __func__);
+                battery_on = 0;
+        }
+
+	sci_adi_clr(ANA_REG_GLB_AUXAD_CTL, BIT_AUXAD_CURRENTSEN_EN);
+	sci_adi_clr(ANA_REG_GLB_BATDET_CUR_CTRL, BIT_BATDET_CUR_EN);
+
+        return battery_on;
+}
+
+/* vf adc check, only for MUIC & young2dtv */
+int sec_vf_adc_check(void)
+{
+	int adc = 0;
+
+	adc = sci_adc_get_value(0, false);
+	pr_info("%s, vf adc : %d", __func__, adc);
+
+	if (adc > 500)
+		return 0;
+	else
+		return 1;
+}
+
+int sec_bat_dt_init(struct device_node *np,
+			 struct device *dev,
+			 sec_battery_platform_data_t *pdata)
+{
+	int ret, i, len;
+	unsigned int bat_irq_attr;
+        const u32 *p;
+
+	ret = of_property_read_string(np,
+		"battery,vendor", (char const **)&pdata->vendor);
+	if (ret)
+		pr_info("%s: Vendor is Empty\n", __func__);
+
+	ret = of_property_read_string(np,
+		"battery,charger_name", (char const **)&pdata->charger_name);
+	if (ret)
+		pr_info("%s: charger_name is Empty\n", __func__);
+
+	ret = of_property_read_string(np,
+		"battery,fuelgauge_name", (char const **)&pdata->fuelgauge_name);
+	if (ret)
+		pr_info("%s: fuelguage_name is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,technology",
+		&pdata->technology);
+	if (ret)
+		pr_info("%s : technology is Empty\n", __func__);
+
+	p = of_get_property(np, "battery,polling_time", &len);
+	if (!p)
+		return 1;
+
+	len = len / sizeof(u32);
+	pdata->polling_time = kzalloc(sizeof(*pdata->polling_time) * len, GFP_KERNEL);
+	ret = of_property_read_u32_array(np, "battery,polling_time",
+			pdata->polling_time, len);
+
+	p = of_get_property(np, "battery,temp_table_adc", &len);
+	if (!p)
+		return 1;
+
+	len = len / sizeof(u32);
+
+	pdata->temp_adc_table_size = len;
+	pdata->temp_amb_adc_table_size = len;
+
+	pdata->temp_adc_table =
+		kzalloc(sizeof(sec_bat_adc_table_data_t) *
+				pdata->temp_adc_table_size, GFP_KERNEL);
+	pdata->temp_amb_adc_table =
+		kzalloc(sizeof(sec_bat_adc_table_data_t) *
+				pdata->temp_adc_table_size, GFP_KERNEL);
+
+	for(i = 0; i < pdata->temp_adc_table_size; i++) {
+		ret = of_property_read_u32_index(np,
+				"battery,temp_table_adc", i,
+				&pdata->temp_adc_table[i].adc);
+		if (ret)
+			pr_info("%s : Temp_adc_table(adc) is Empty\n",
+					__func__);
+
+		ret = of_property_read_u32_index(np,
+				"battery,temp_table_data", i,
+				&pdata->temp_adc_table[i].temperature);
+		if (ret)
+			pr_info("%s : Temp_adc_table(data) is Empty\n",
+					__func__);
+
+		ret = of_property_read_u32_index(np,
+				"battery,temp_table_adc", i,
+				&pdata->temp_amb_adc_table[i].adc);
+		if (ret)
+			pr_info("%s : Temp_amb_adc_table(adc) is Empty\n",
+					__func__);
+
+		ret = of_property_read_u32_index(np,
+				"battery,temp_table_data", i,
+				&pdata->temp_amb_adc_table[i].temperature);
+		if (ret)
+			pr_info("%s : Temp_amb_adc_table(data) is Empty\n",
+					__func__);
+	}
+
+	p = of_get_property(np, "battery,input_current_limit", &len);
+	if (!p)
+		return 1;
+
+	len = len / sizeof(u32);
+
+	pdata->charging_current =
+		kzalloc(sizeof(sec_charging_current_t) * len,
+				GFP_KERNEL);
+
+	for(i = 0; i < len; i++) {
+		ret = of_property_read_u32_index(np,
+				"battery,input_current_limit", i,
+				&pdata->charging_current[i].input_current_limit);
+		if (ret)
+			pr_info("%s : Input_current_limit is Empty\n",
+					__func__);
+
+		ret = of_property_read_u32_index(np,
+				"battery,fast_charging_current", i,
+				&pdata->charging_current[i].fast_charging_current);
+		if (ret)
+			pr_info("%s : Fast charging current is Empty\n",
+					__func__);
+
+		ret = of_property_read_u32_index(np,
+				"battery,full_check_current_1st", i,
+				&pdata->charging_current[i].full_check_current_1st);
+		if (ret)
+			pr_info("%s : Full check current 1st is Empty\n",
+					__func__);
+
+		ret = of_property_read_u32_index(np,
+				"battery,full_check_current_2nd", i,
+				&pdata->charging_current[i].full_check_current_2nd);
+		if (ret)
+			pr_info("%s : Full check current 2nd is Empty\n",
+					__func__);
+	}
+
+	ret = of_property_read_u32(np, "battery,adc_check_count",
+			&pdata->adc_check_count);
+	if (ret)
+		pr_info("%s : Adc check count is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,cable_check_type",
+			&pdata->cable_check_type);
+	if (ret)
+		pr_info("%s : Cable check type is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,cable_source_type",
+			&pdata->cable_source_type);
+	if (ret)
+		pr_info("%s : Cable source type is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,event_waiting_time",
+			&pdata->event_waiting_time);
+	if (ret)
+		pr_info("%s : Event waiting time is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,polling_type",
+			&pdata->polling_type);
+	if (ret)
+		pr_info("%s : Polling type is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,monitor_initial_count",
+			&pdata->monitor_initial_count);
+	if (ret)
+		pr_info("%s : Monitor initial count is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,battery_check_type",
+			&pdata->battery_check_type);
+	if (ret)
+		pr_info("%s : Battery check type is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,check_count",
+			&pdata->check_count);
+
+	if (ret)
+		pr_info("%s : Check count is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,check_adc_max",
+			&pdata->check_adc_max);
+	if (ret)
+		pr_info("%s : Check adc max is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,check_adc_min",
+			&pdata->check_adc_min);
+	if (ret)
+		pr_info("%s : Check adc min is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,ovp_uvlo_check_type",
+			&pdata->ovp_uvlo_check_type);
+	if (ret)
+		pr_info("%s : Ovp Uvlo check type is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,thermal_source",
+			&pdata->thermal_source);
+	if (ret)
+		pr_info("%s : Thermal source is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,temp_check_type",
+			&pdata->temp_check_type);
+	if (ret)
+		pr_info("%s : Temp check type is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,temp_check_count",
+			&pdata->temp_check_count);
+	if (ret)
+		pr_info("%s : Temp check count is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,temp_high_recovery_event",
+			&pdata->temp_high_recovery_event);
+	if (ret)
+		pr_info("%s : Temp high recovery event is Empty\n", __func__);
+
+#if defined(CONFIG_MACH_DEGAS_USA)
+	pdata->temp_high_threshold_event = 550;
+	pdata->temp_high_recovery_event = 480;
+	pdata->temp_low_threshold_event = 20;
+	pdata->temp_low_recovery_event = 50;
+	pdata->temp_high_threshold_normal = 550;
+	pdata->temp_high_recovery_normal = 480;
+	pdata->temp_low_threshold_normal = 20;
+	pdata->temp_low_recovery_normal = 50;
+	pdata->temp_high_threshold_lpm = 550;
+	pdata->temp_high_recovery_lpm = 480;
+	pdata->temp_low_threshold_lpm = 20;
+	pdata->temp_low_recovery_lpm = 50;
+#elif defined(CONFIG_MACH_DEGAS_BMW)
+	pdata->temp_high_threshold_event = 450;
+	pdata->temp_high_recovery_event = 400;
+	pdata->temp_low_threshold_event = 0;
+	pdata->temp_low_recovery_event = 50;
+	pdata->temp_high_threshold_normal = 450;
+	pdata->temp_high_recovery_normal = 400;
+	pdata->temp_low_threshold_normal = 0;
+	pdata->temp_low_recovery_normal = 50;
+	pdata->temp_high_threshold_lpm = 450;
+	pdata->temp_high_recovery_lpm = 400;
+	pdata->temp_low_threshold_lpm = 0;
+	pdata->temp_low_recovery_lpm = 50;
+#else
+	ret = of_property_read_u32(np, "battery,temp_highlimit_threshold_event",
+		&pdata->temp_highlimit_threshold_event);
+	if (ret)
+		pr_info("%s : Temp highlimit threshold event is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,battery,temp_highlimit_recovery_event",
+		&pdata->temp_highlimit_recovery_event);
+	if (ret)
+		pr_info("%s : Temp highlimit threshold event recovery is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,temp_highlimit_threshold_normal",
+		&pdata->temp_highlimit_threshold_normal);
+	if (ret)
+		pr_info("%s : Temp highlimit threshold normal is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,temp_highlimit_recovery_normal",
+		&pdata->temp_highlimit_recovery_normal);
+	if (ret)
+		pr_info("%s : Temp highlimit threshold normal recovery is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,temp_highlimit_threshold_lpm",
+		&pdata->temp_highlimit_threshold_lpm);
+	if (ret)
+		pr_info("%s : Temp highlimit threshold lpm is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,temp_highlimit_recovery_lpm",
+		&pdata->temp_highlimit_recovery_lpm);
+	if (ret)
+		pr_info("%s : Temp highlimit threshold lpm recovery is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,temp_high_threshold_event",
+		&pdata->temp_high_threshold_event);
+	if (ret)
+		pr_info("%s : Temp high threshold event is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,temp_low_threshold_event",
+			&pdata->temp_low_threshold_event);
+	if (ret)
+		pr_info("%s : Temp low threshold event is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,temp_low_recovery_event",
+			&pdata->temp_low_recovery_event);
+	if (ret)
+		pr_info("%s : Temp low recovery event is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,temp_high_threshold_normal",
+			&pdata->temp_high_threshold_normal);
+	if (ret)
+		pr_info("%s : Temp high threshold normal is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,temp_high_recovery_normal",
+			&pdata->temp_high_recovery_normal);
+	if (ret)
+		pr_info("%s : Temp high recovery normal is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,temp_low_threshold_normal",
+			&pdata->temp_low_threshold_normal);
+	if (ret)
+		pr_info("%s : Temp low threshold normal is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,temp_low_recovery_normal",
+			&pdata->temp_low_recovery_normal);
+
+	if (ret)
+		pr_info("%s : Temp low recovery normal is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,temp_high_threshold_lpm",
+			&pdata->temp_high_threshold_lpm);
+	if (ret)
+		pr_info("%s : Temp high threshold lpm is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,temp_high_recovery_lpm",
+			&pdata->temp_high_recovery_lpm);
+	if (ret)
+		pr_info("%s : Temp high recovery lpm is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,temp_low_threshold_lpm",
+			&pdata->temp_low_threshold_lpm);
+	if (ret)
+		pr_info("%s : Temp low threshold lpm is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,temp_low_recovery_lpm",
+			&pdata->temp_low_recovery_lpm);
+	if (ret)
+		pr_info("%s : Temp low recovery lpm is Empty\n", __func__);
+#endif
+
+	ret = of_property_read_u32(np, "battery,full_check_type",
+			&pdata->full_check_type);
+	if (ret)
+		pr_info("%s : Full check type is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,full_check_type_2nd",
+			&pdata->full_check_type_2nd);
+	if (ret)
+		pr_info("%s : Full check type 2nd is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,full_check_count",
+			&pdata->full_check_count);
+	if (ret)
+		pr_info("%s : Full check count is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,chg_gpio_full_check",
+			&pdata->chg_gpio_full_check);
+	if (ret)
+		pr_info("%s : Chg gpio full check is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,chg_polarity_full_check",
+			&pdata->chg_polarity_full_check);
+	if (ret)
+		pr_info("%s : Chg polarity full check is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,full_condition_type",
+			&pdata->full_condition_type);
+	if (ret)
+		pr_info("%s : Full condition type is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,full_condition_soc",
+			&pdata->full_condition_soc);
+	if (ret)
+		pr_info("%s : Full condition soc is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,full_condition_vcell",
+			&pdata->full_condition_vcell);
+	if (ret)
+		pr_info("%s : Full condition vcell is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,recharge_check_count",
+			&pdata->recharge_check_count);
+	if (ret)
+		pr_info("%s : Recharge check count is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,recharge_condition_type",
+			&pdata->recharge_condition_type);
+	if (ret)
+		pr_info("%s : Recharge condition type is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,recharge_condition_soc",
+			&pdata->recharge_condition_soc);
+	if (ret)
+		pr_info("%s : Recharge condition soc is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,recharge_condition_vcell",
+			&pdata->recharge_condition_vcell);
+	if (ret)
+		pr_info("%s : Recharge condition vcell is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,recharge_condition_avgvcell",
+			&pdata->recharge_condition_avgvcell);
+	if (ret)
+		pr_info("%s : Recharge condition avgvcell is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,charging_total_time",
+			(unsigned int *)&pdata->charging_total_time);
+	if (ret)
+		pr_info("%s : Charging total time is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,recharging_total_time",
+			(unsigned int *)&pdata->recharging_total_time);
+	if (ret)
+		pr_info("%s : Recharging total time is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,charging_reset_time",
+			(unsigned int *)&pdata->charging_reset_time);
+	if (ret)
+		pr_info("%s : Charging reset time is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,charging_reset_time",
+			(unsigned int *)&pdata->charging_reset_time);
+	if (ret)
+		pr_info("%s : Charging reset time is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,bat-irq-attr", &bat_irq_attr);
+	if (ret)
+		pr_info("%s : Battery irq is Empty\n", __func__);
+
+	pdata->bat_gpio_init = sec_bat_gpio_init;
+	pdata->check_battery_callback =	sec_bat_check_callback;
+	pdata->check_battery_result_callback = sec_bat_check_result_callback;
+	pdata->check_cable_callback = sec_bat_check_cable_callback;
+	pdata->check_cable_result_callback =
+		sec_bat_check_cable_result_callback;
+	pdata->get_temperature_callback = sec_bat_get_temperature_callback;
+	pdata->initial_check = sec_bat_initial_check;
+	pdata->is_lpm = sec_bat_is_lpm;
+	pdata->ovp_uvlo_callback = sec_bat_ovp_uvlo_callback;
+	pdata->ovp_uvlo_result_callback = sec_bat_ovp_uvlo_result_callback;
+	pdata->check_jig_status = sec_bat_check_jig_status;
+
+	for (i = 0; i < SEC_BATTERY_ADC_TYPE_NUM; i++)
+		pdata->adc_api[i] = adc_api[i];
+
+	return 0;
+}
+
+int sec_chg_dt_init(struct device_node *np,
+			 struct device *dev,
+			 sec_battery_platform_data_t *pdata)
+{
+	int ret = 0, len = 0;
+	unsigned int chg_irq_attr = 0;
+	int chg_gpio_en = 0;
+	int chg_irq_gpio = 0;
+
+	if (!np)
+		return -EINVAL;
+
+	chg_gpio_en = of_get_named_gpio(np, "chgen-gpio", 0);
+	if (chg_gpio_en < 0) {
+		pr_err("%s: of_get_named_gpio failed: %d\n", __func__,
+							chg_gpio_en);
+		return chg_gpio_en;
+	}
+
+	ret = of_property_read_u32(np, "chg-irq-attr",
+					&chg_irq_attr);
+	if (ret) {
+		pr_info("%s chg_irq_attr request failed: %d\n", __func__, chg_irq_attr);
+	}
+
+	ret = gpio_request(chg_gpio_en, "chgen-gpio");
+	if (ret) {
+		pr_err("%s gpio_request failed: %d\n", __func__, chg_gpio_en);
+		return ret;
+	}
+
+	chg_irq_gpio = of_get_named_gpio(np, "chgirq-gpio", 0);
+	if (chg_irq_gpio < 0)
+		pr_err("%s: chgirq gpio get failed: %d\n", __func__, chg_irq_gpio);
+
+	ret = gpio_request(chg_irq_gpio, "chgirq-gpio");
+	if (ret)
+		pr_err("%s gpio_request failed: %d\n", __func__, chg_irq_gpio);
+
+	ret = of_property_read_u32(np, "chg-float-voltage",
+					&pdata->chg_float_voltage);
+	if (ret)
+		return ret;
+
+        np = of_find_node_by_name(NULL, "sec-battery");
+        if (!np) {
+                pr_err("%s np NULL\n", __func__);
+        }
+        else {
+                int i = 0;
+                const u32 *p;
+                p = of_get_property(np, "battery,input_current_limit", &len);
+                if (!p){
+
+                        pr_err("%s charger,input_current_limit is Empty\n", __func__);
+                        //	return 1;
+                }
+                else{
+
+                        len = len / sizeof(u32);
+
+                        pdata->charging_current = kzalloc(sizeof(sec_charging_current_t) * len,
+                                        GFP_KERNEL);
+
+                        for(i = 0; i < len; i++) {
+                                ret = of_property_read_u32_index(np,
+                                                "battery,input_current_limit", i,
+                                                &pdata->charging_current[i].input_current_limit);
+                                if (ret)
+                                        pr_info("%s : Input_current_limit is Empty\n",
+                                                        __func__);
+
+                                ret = of_property_read_u32_index(np,
+                                                "battery,fast_charging_current", i,
+                                                &pdata->charging_current[i].fast_charging_current);
+                                if (ret)
+                                        pr_info("%s : Fast charging current is Empty\n",
+                                                        __func__);
+
+                                ret = of_property_read_u32_index(np,
+                                                "battery,full_check_current_1st", i,
+                                                &pdata->charging_current[i].full_check_current_1st);
+                                if (ret)
+                                        pr_info("%s : Full check current 1st is Empty\n",
+                                                        __func__);
+
+                                ret = of_property_read_u32_index(np,
+                                                "battery,full_check_current_2nd", i,
+                                                &pdata->charging_current[i].full_check_current_2nd);
+                                if (ret)
+                                        pr_info("%s : Full check current 2nd is Empty\n",
+                                                        __func__);
+                        }
+                }
+        }
+
+	ret = of_property_read_u32(np, "battery,ovp_uvlo_check_type",
+			&pdata->ovp_uvlo_check_type);
+	if (ret)
+		pr_info("%s : Ovp Uvlo check type is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,full_check_type",
+			&pdata->full_check_type);
+	if (ret)
+		pr_info("%s : Full check type is Empty\n", __func__);
+
+	ret = of_property_read_u32(np, "battery,full_check_type_2nd",
+			&pdata->full_check_type_2nd);
+	if (ret)
+		pr_info("%s : Full check type 2nd is Empty\n", __func__);
+
+#if defined(CONFIG_MACH_PIKEAYOUNG2DTV)
+	gpio_vbat_detect = BATT_DET_CURRENT;
+
+	if (!gpio_is_valid(gpio_vbat_detect)) {
+                printk("%s: battery detect gpio %d failed\n", __func__, gpio_vbat_detect);
+                return 1;
+        }
+        gpio_request(gpio_vbat_detect, "battery-detect");
+        gpio_direction_input(gpio_vbat_detect);
+        printk("%s: battery detect gpio %d\n", __func__, gpio_vbat_detect);
+#endif
+
+	if (chg_irq_gpio > 0) {
+		pdata->chg_irq_attr = chg_irq_attr;
+		pdata->chg_irq = gpio_to_irq(chg_irq_gpio);
+	}
+	pdata->chg_gpio_en = chg_gpio_en;
+	pdata->chg_gpio_init = sec_chg_gpio_init;
+	pdata->check_cable_result_callback =
+		sec_bat_check_cable_result_callback;
+
+	return 0;
+}
+
+#ifdef CONFIG_FUELGAUGE_SPRD4SAMSUNG27X3
+struct battery_data_t bat_data;
+#endif
+
+int sec_fg_dt_init(struct device_node *np,
+			 struct device *dev,
+			 sec_battery_platform_data_t *pdata)
+{
+	int ret;
+	unsigned int fg_irq_attr;
+
+	ret = of_property_read_u32(np, "capacity-max", &pdata->capacity_max);
+	if (ret)
+		return ret;
+	ret = of_property_read_u32(np, "capacity-max-margin",
+			&pdata->capacity_max_margin);
+	if (ret)
+		return ret;
+	ret = of_property_read_u32(np, "capacity-min", &pdata->capacity_min);
+	if (ret)
+		return ret;
+	ret = of_property_read_u32(np, "fg-irq-attr", &fg_irq_attr);
+	if (ret)
+		return ret;
+	ret = of_property_read_u32(np, "fuel-alert-soc",
+			&pdata->fuel_alert_soc);
+	if (ret)
+		return ret;
+	if (of_find_property(np, "repeated-fuelalert", NULL))
+		pdata->repeated_fuelalert = true;
+
+	ret = of_property_read_u32(np, "temp_adc_channel",
+			&pdata->temp_adc_channel);
+	if (ret)
+		return ret;
+
+#ifdef CONFIG_FUELGAUGE_SPRD4SAMSUNG27X3
+	{
+		struct sprd_battery_platform_data *battery_data;
+		int len, i;
+		uint32_t cell_value;
+		struct device_node *temp_np = NULL;
+
+		battery_data = devm_kzalloc(dev, sizeof(*battery_data), GFP_KERNEL);
+		temp_np = of_get_child_by_name(np, "sprd_fgu");
+		if (!temp_np) {
+			return ERR_PTR(-EINVAL);
+		}
+		battery_data->irq_fgu = irq_of_parse_and_map(temp_np, 0);
+		of_property_read_u32(np, "chg_bat_safety_vol", &battery_data->chg_bat_safety_vol);
+		of_property_read_u32(np, "soft_vbat_uvlo", &battery_data->soft_vbat_uvlo);
+		of_property_read_u32(np, "vmod", &battery_data->fgu_mode);
+		of_property_read_u32(np, "alm_soc", &battery_data->alm_soc);
+		of_property_read_u32(np, "alm_vbat", &battery_data->alm_vol);
+		of_property_read_u32(np, "rint", &battery_data->rint);
+		of_property_read_u32(np, "cnom", &battery_data->cnom);
+		of_property_read_u32(np, "rsense_real", &battery_data->rsense_real);
+		of_property_read_u32(np, "rsense_spec", &battery_data->rsense_spec);
+		of_property_read_u32(np, "relax_current", &battery_data->relax_current);
+		of_property_read_u32(np, "cal_ajust", &battery_data->fgu_cal_ajust);
+		of_get_property(np, "ocv_table", &len);
+		len /= sizeof(u32);
+		battery_data->ocv_tab_size = len >> 1;
+		battery_data->ocv_tab = kzalloc(sizeof(struct sprdbat_table_data) *
+				 battery_data->ocv_tab_size, GFP_KERNEL);
+		for (i = 0; i < len; i++) {
+			of_property_read_u32_index(np, "ocv_table", i, &cell_value);
+                   if(i&0x1) {
+			    battery_data->ocv_tab[i >> 1].y = cell_value;
+                    } else {
+                        battery_data->ocv_tab[i >> 1].x = cell_value;
+                    }
+		}
+		bat_data.pdata = battery_data;
+		pdata->battery_data = &bat_data;
+	}
+#endif
+
+	pdata->fg_irq_attr = fg_irq_attr;
+	pdata->fuelalert_process = sec_fg_fuelalert_process;
+	pdata->fg_gpio_init = sec_fg_gpio_init;
+	pdata->capacity_calculation_type =
+			SEC_FUELGAUGE_CAPACITY_TYPE_RAW;
+	pdata->check_jig_status = sec_bat_check_jig_status;
+
+	return 0;
+}