drivers/battery/common/sec_battery_data.c - LeafOS-Devices/android_kernel_samsung_gta4xl - Gitiles

 /*
  *  sec_battery_data.c
  *  Samsung Mobile Battery 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.
  */

 #include <linux/slab.h>
 #include <linux/errno.h>
 #include <linux/fs.h>
 #include <linux/of.h>
 #include <linux/power_supply.h>

 enum battery_data_type {
 	BATTERY_DATA_TYPE_NONE = 0,
 	BATTERY_DATA_TYPE_INFO,
 	BATTERY_DATA_TYPE_VALUE,
 	BATTERY_DATA_TYPE_STRING,
 };

 enum battery_data_flag {
 	BATTERY_DATA_FLAG_NONE = 0,
 	BATTERY_DATA_FLAG_ADD,
 	BATTERY_DATA_FLAG_REMOVE,
 	BATTERY_DATA_FLAG_EDIT,
 };

 #define CHECK_ERROR_DATA(logical_test, return_value, error_value, action) { \
 	if (logical_test) { \
 		return_value = error_value; \
 		pr_err("%s: error!!! (ret = %d)\n", __func__, error_value); \
 		action; \
 	} else { \
 		return_value = 0; \
 	} \
 }

 #define NODE_NAME_SIZE		32
 #define PROPERTY_SIZE		68
 #define MAX_VALUE_SIZE		(5 * 1024)

 struct battery_data_info {
 	int version;
 	int hw_rev;
 	int prop_count;
 	int value_length;
 };

 struct battery_data {
 	unsigned int type;
 	unsigned int flag;
 	char node_name[NODE_NAME_SIZE];
 	char property[PROPERTY_SIZE];
 	unsigned int length;
 };

 struct battery_property {
 	struct property *property;
 	unsigned int type;
 	unsigned int flag;
 	char *new_value;
 	char *old_value;
 	int new_length;
 	int old_length;
 	struct battery_property *next;
 };

 struct battery_node {
 	char name[NODE_NAME_SIZE];
 	struct device_node *np;
 	struct battery_node *next;
 	struct battery_property *start_prop;
 };

 static struct battery_node *get_battery_node(
 					struct battery_node **start_node, char *name)
 {
 	struct battery_node *batt_node = NULL;
 	struct battery_node *temp_node = NULL;

 	if (name == NULL) {
 		pr_err("%s: name is invalid!!\n", __func__);
 		return NULL;
 	}

 	batt_node = *start_node;
 	while (batt_node) {
 		if (!strcmp(batt_node->name, name)) {
 			return batt_node;
 		} else {
 			temp_node = batt_node;
 			batt_node = batt_node->next;
 		}
 	}

 	batt_node = kzalloc(sizeof(struct battery_node), GFP_KERNEL);
 	if (!batt_node) {
 		pr_err("%s: nomem!!\n", __func__);
 		return NULL;
 	}
 	batt_node->np = of_find_node_by_name(NULL, name);
 	if (IS_ERR_OR_NULL(batt_node->np)) {
 		pr_err("%s: failed to find node(name=%s)\n", __func__, name);
 		kfree(batt_node);
 		return NULL;
 	}
 	strcpy(batt_node->name, name);
 	if (temp_node)
 		temp_node->next = batt_node;
 	batt_node->start_prop = NULL;
 	if (*start_node == NULL) *start_node = batt_node;
 	pr_info("%s: add battery_node(name = %s)\n", __func__, name);
 	return batt_node;
 }

 static int add_battery_property(	struct battery_node *batt_node,
 									struct battery_property *batt_prop)
 {
 	struct battery_property *start_prop = NULL;
 	struct battery_property *temp_prop = NULL;

 	if (!batt_node || !batt_prop) {
 		return -ENODATA;
 	}

 	start_prop = batt_node->start_prop;
 	while (start_prop) {
 		if (!strcmp(start_prop->property->name, batt_prop->property->name)) {
 			return 0;
 		} else {
 			temp_prop = start_prop;
 			start_prop = start_prop->next;
 		}
 	}

 	if (!temp_prop)
 		batt_node->start_prop = batt_prop;
 	else {
 		temp_prop->next = batt_prop;
 	}
 	return 0;
 }

 static void change_battery_pdata(
 				struct battery_node *start_node, bool is_valid)
 {
 	struct battery_node *temp_node = NULL;

 	temp_node = start_node;
 	pr_info("%s: start update(%d)\n", __func__, is_valid);
 	while (is_valid && temp_node) {
 		struct battery_property *batt_prop = NULL;
 		struct power_supply *psy = NULL;
 		union power_supply_propval value;

 		batt_prop = temp_node->start_prop;
 		while (batt_prop) {
 			if (batt_prop->flag != BATTERY_DATA_FLAG_REMOVE) {
 				batt_prop->property->value = batt_prop->new_value;
 				batt_prop->property->length = batt_prop->new_length;
 			}
 			batt_prop = batt_prop->next;
 		}

 		psy = power_supply_get_by_name(start_node->name);
 		if (psy) {
 			value.intval = 0;
 			psy->desc->set_property(psy, POWER_SUPPLY_PROP_POWER_DESIGN, &value);
 			power_supply_put(psy);
 		}

 		temp_node = temp_node->next;
 	}

 	pr_info("%s: release battery pdata\n", __func__);
 	while (start_node) {
 		struct battery_property *temp_batt_prop = NULL;
 		struct battery_property *batt_prop = NULL;

 		batt_prop = start_node->start_prop;
 		while (batt_prop) {
 			switch (batt_prop->flag) {
 			case BATTERY_DATA_FLAG_REMOVE:
 				pr_debug("%s: re-set property(ret=%d, flag=%d, name=%s)\n",
 					__func__, of_add_property(start_node->np, batt_prop->property),
 					batt_prop->flag, batt_prop->property->name);
 				break;
 			case BATTERY_DATA_FLAG_EDIT:
 				pr_debug("%s: re-set property(type=%d, flag=%d, name=%s)\n",
 					__func__, batt_prop->type,
 					batt_prop->flag, batt_prop->property->name);
 				if (!is_valid) {
 					kfree(batt_prop->new_value);
 				} else {
 					/* In normal case, String type should not free. */
 					if (batt_prop->type != BATTERY_DATA_TYPE_STRING) {
 						batt_prop->property->value = batt_prop->old_value;
 						batt_prop->property->length = batt_prop->old_length;
 						kfree(batt_prop->new_value);
 					}
 				}
 				break;
 			case BATTERY_DATA_FLAG_ADD:
 				pr_debug("%s: re-set property(ret=%d, flag=%d, name=%s)\n",
 					__func__, of_remove_property(start_node->np, batt_prop->property),
 					batt_prop->flag, batt_prop->property->name);
 				if (batt_prop->new_value &&	(!is_valid || batt_prop->type != BATTERY_DATA_TYPE_STRING)) {
 					kfree(batt_prop->new_value);
 				}
 				kfree(batt_prop->property->name);
 				kfree(batt_prop->property);
 				break;
 			}

 			temp_batt_prop = batt_prop;
 			batt_prop = batt_prop->next;
 			kfree(temp_batt_prop);
 		}

 		temp_node = start_node;
 		start_node = start_node->next;
 		kfree(temp_node);
 	}
 }

 static int sec_battery_check_info(struct file *fp,
 						struct battery_data_info *batt_info)
 {
 	struct device_node *np;
 	struct battery_data batt_data;
 	int dt_version, hw_rev, hw_rev_end;
 	int ret = 0, read_size;

 	read_size = fp->f_op->read(fp, (char*)&batt_data, sizeof(struct battery_data), &fp->f_pos);
 	CHECK_ERROR_DATA((read_size <= 0), ret, (-ENODATA), goto finish_check_info);
 	CHECK_ERROR_DATA((batt_data.type != BATTERY_DATA_TYPE_INFO), ret, (-EINVAL), goto finish_check_info);

 	read_size = fp->f_op->read(fp, (char*)batt_info, sizeof(struct battery_data_info), &fp->f_pos);
 	CHECK_ERROR_DATA((read_size <= 0 || read_size != batt_data.length), ret, (-ENODATA), goto finish_check_info);
 	CHECK_ERROR_DATA(
 		(batt_info->version < 0 || batt_info->hw_rev < 0 || batt_info->prop_count <= 0) ||
 		(batt_info->value_length < 0 || batt_info->value_length > MAX_VALUE_SIZE),
 		ret, (-EINVAL), goto finish_check_info);

 	np = of_find_node_by_name(NULL, batt_data.node_name);
 	ret = of_property_read_u32(np, "battery,batt_data_version", &dt_version);
 	if (ret) {
 		pr_info("%s : batt_data_version is Empty\n", __func__);
 		dt_version = 0;
 	}

 	np = of_find_all_nodes(NULL);
 	ret = of_property_read_u32(np, "model_info-hw_rev", &hw_rev);
 	if (ret) {
 		pr_info("%s: model_info-hw_rev is Empty\n", __func__);
 		hw_rev = 0;
 	}
 	ret = of_property_read_u32(np, "model_info-hw_rev_end", &hw_rev_end);
 	if (ret) {
 		pr_info("%s: model_info-hw_rev_end is Empty\n", __func__);
 		hw_rev_end = 99;
 	}

 	ret = (batt_info->version < dt_version) ? -1 :
 		((batt_info->hw_rev > hw_rev_end || batt_info->hw_rev < hw_rev) ? -2 : 0);

 	pr_info("%s: check info(ret=%d), version(%d <-> %d), hw_rev(%d ~ %d <-> %d), prop_count(%d), value_length(%d)\n",
 		__func__, ret,
 		dt_version, batt_info->version,
 		hw_rev, hw_rev_end, batt_info->hw_rev,
 		batt_info->prop_count, batt_info->value_length);

 finish_check_info:
 	return ret;
 }

 static int sec_battery_check_none(struct file *fp)
 {
 	struct battery_data batt_data;
 	int ret = 0, read_size;

 	read_size = fp->f_op->read(fp, (char*)&batt_data, sizeof(struct battery_data), &fp->f_pos);
 	CHECK_ERROR_DATA((read_size <= 0), ret, (-ENODATA), goto finish_check_none);

 	if (batt_data.type != BATTERY_DATA_TYPE_NONE) {
 		pr_info("%s: invalid type(%d)\n", __func__, batt_data.type);
 		ret = -EINVAL;
 	}

 finish_check_none:
 	return ret;
 }

 static char *sec_battery_check_value(struct file *fp,
 			struct battery_data_info *batt_info, struct battery_data *batt_data)
 {
 	char *temp_buf = NULL;
 	int read_size;

 	if (batt_data->length < 0 || batt_data->length > batt_info->value_length) {
 		pr_info("%s: length(%d) of data is invalid\n", __func__, batt_data->length);
 		return NULL;
 	} else if (batt_data->length == 0) {
 		pr_info("%s: skip alloc buffer(length=%d)\n", __func__, batt_data->length);
 		return NULL;
 	}

 	temp_buf = kzalloc(batt_data->length, GFP_KERNEL);
 	if (temp_buf) {
 		read_size = fp->f_op->read(fp, temp_buf, batt_data->length, &fp->f_pos);
 		if (read_size <= 0) {
 			pr_info("%s: failed to read value\n", __func__);
 			kfree(temp_buf);
 			temp_buf = NULL;
 		}
 	}

 	return temp_buf;
 }

 int sec_battery_update_data(const char* file_path)
 {
 	struct battery_node *batt_node = NULL;
 	struct battery_node *temp_node = NULL;
 	struct property *batt_property = NULL;
 	struct battery_data_info batt_info;
 	struct battery_property *batt_prop;
 	struct battery_data batt_data;
 	struct file* fp = NULL;
 	char *temp_buf = NULL;
 	int length, read_size;
 	int ret = 0;

 	fp = filp_open(file_path, O_RDONLY, 0);
 	CHECK_ERROR_DATA(IS_ERR(fp), ret, (int)(PTR_ERR(fp)), goto err_filp_open);

 	ret = sec_battery_check_info(fp, &batt_info);
 	CHECK_ERROR_DATA((ret), ret, (-EINVAL), goto skip_check_data);

 	while (batt_info.prop_count-- > 0) {
 		read_size = fp->f_op->read(fp, (char*)&batt_data, sizeof(struct battery_data), &fp->f_pos);
 		CHECK_ERROR_DATA((read_size <= 0), ret, (-ENODATA), goto finish_update_data);
 		pr_debug("%s: read batt_data(type=%d, flag=%d, node_name=%s, property=%s, length=%d)\n",
 			__func__, batt_data.type, batt_data.flag, batt_data.node_name, batt_data.property, batt_data.length);

 		temp_node = get_battery_node(&batt_node, batt_data.node_name);
 		CHECK_ERROR_DATA((!temp_node), ret, (-ENODEV), goto finish_update_data);

 		batt_prop = kzalloc(sizeof(struct battery_property), GFP_KERNEL);
 		CHECK_ERROR_DATA((!batt_prop), ret, (-ENOMEM), goto finish_update_data);

 		batt_property = of_find_property(temp_node->np, batt_data.property, &length);
 		switch (batt_data.flag) {
 		case BATTERY_DATA_FLAG_ADD:
 			if (IS_ERR_OR_NULL(batt_property)) {
 				temp_buf = sec_battery_check_value(fp, &batt_info, &batt_data);
 				CHECK_ERROR_DATA((!temp_buf && batt_data.length != 0), ret, (-ENOMEM),
 					{kfree(batt_prop); goto finish_update_data;});

 				batt_property = kzalloc(sizeof(struct property), GFP_KERNEL);
 				CHECK_ERROR_DATA((!batt_property), ret, (-ENOMEM),
 					{kfree(batt_prop); kfree(temp_buf); goto finish_update_data;});

 				batt_property->name = kzalloc(PROPERTY_SIZE, GFP_KERNEL);
 				CHECK_ERROR_DATA((!batt_property->name), ret, (-ENOMEM),
 					{kfree(batt_prop); kfree(temp_buf); kfree(batt_property); goto finish_update_data;});

 				memcpy(batt_property->name, batt_data.property, PROPERTY_SIZE);
 				ret = of_add_property(temp_node->np, batt_property);
 				CHECK_ERROR_DATA((ret), ret, ret,
 					{kfree(batt_prop); kfree(temp_buf); kfree(batt_property->name); kfree(batt_property); goto finish_update_data;});
 			} else {
 				pr_info("%s: invalid data(name=%s, property=%s, flag=%d)\n",
 					__func__, batt_data.node_name, batt_data.property, batt_data.flag);
 				ret = -EINVAL;
 				kfree(batt_prop);
 				goto finish_update_data;
 			}
 			break;
 		case BATTERY_DATA_FLAG_EDIT:
 			if (!IS_ERR_OR_NULL(batt_property)) {
 				temp_buf = sec_battery_check_value(fp, &batt_info, &batt_data);
 				CHECK_ERROR_DATA((!temp_buf), ret, (-ENOMEM),
 					{kfree(batt_prop); goto finish_update_data;});
 			} else {
 				pr_info("%s: invalid data(name=%s, property=%s, flag=%d)\n",
 					__func__, batt_data.node_name, batt_data.property, batt_data.flag);
 				ret = -EINVAL;
 				kfree(batt_prop);
 				goto finish_update_data;
 			}
 			break;
 		case BATTERY_DATA_FLAG_REMOVE:
 			if (!IS_ERR_OR_NULL(batt_property)) {
 				temp_buf = NULL;

 				ret = of_remove_property(temp_node->np, batt_property);
 				CHECK_ERROR_DATA((ret), ret, ret, {kfree(batt_prop); goto finish_update_data;});
 			} else {
 				pr_info("%s: invalid data(name=%s, property=%s, flag=%d)\n",
 					__func__, batt_data.node_name, batt_data.property, batt_data.flag);
 				ret = -EINVAL;
 				kfree(batt_prop);
 				goto finish_update_data;
 			}
 			break;
 		default:
 			pr_info("%s: invalid flag(%d)\n", __func__, batt_data.flag);
 			ret = -EINVAL;
 			kfree(batt_prop);
 			goto finish_update_data;
 		}

 		batt_prop->property = batt_property;
 		batt_prop->type = batt_data.type;
 		batt_prop->flag = batt_data.flag;
 		batt_prop->new_value = temp_buf;
 		batt_prop->old_value = batt_property->value;
 		batt_prop->new_length = batt_data.length;
 		batt_prop->old_length = batt_property->length;
 		add_battery_property(temp_node, batt_prop);
 	}
 	ret = sec_battery_check_none(fp);

 finish_update_data:
 	change_battery_pdata(batt_node, (ret == 0));
 skip_check_data:
 	filp_close(fp, NULL);
 err_filp_open:
 	return ret;
 }
	/*
	* sec_battery_data.c
	* Samsung Mobile Battery 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.
	*/

	#include <linux/slab.h>
	#include <linux/errno.h>
	#include <linux/fs.h>
	#include <linux/of.h>
	#include <linux/power_supply.h>

	enum battery_data_type {
	BATTERY_DATA_TYPE_NONE = 0,
	BATTERY_DATA_TYPE_INFO,
	BATTERY_DATA_TYPE_VALUE,
	BATTERY_DATA_TYPE_STRING,
	};

	enum battery_data_flag {
	BATTERY_DATA_FLAG_NONE = 0,
	BATTERY_DATA_FLAG_ADD,
	BATTERY_DATA_FLAG_REMOVE,
	BATTERY_DATA_FLAG_EDIT,
	};

	#define CHECK_ERROR_DATA(logical_test, return_value, error_value, action) { \
	if (logical_test) { \
	return_value = error_value; \
	pr_err("%s: error!!! (ret = %d)\n", __func__, error_value); \
	action; \
	} else { \
	return_value = 0; \
	} \
	}

	#define NODE_NAME_SIZE 32
	#define PROPERTY_SIZE 68
	#define MAX_VALUE_SIZE (5 * 1024)

	struct battery_data_info {
	int version;
	int hw_rev;
	int prop_count;
	int value_length;
	};

	struct battery_data {
	unsigned int type;
	unsigned int flag;
	char node_name[NODE_NAME_SIZE];
	char property[PROPERTY_SIZE];
	unsigned int length;
	};

	struct battery_property {
	struct property *property;
	unsigned int type;
	unsigned int flag;
	char *new_value;
	char *old_value;
	int new_length;
	int old_length;
	struct battery_property *next;
	};

	struct battery_node {
	char name[NODE_NAME_SIZE];
	struct device_node *np;
	struct battery_node *next;
	struct battery_property *start_prop;
	};

	static struct battery_node *get_battery_node(
	struct battery_node *start_node, char name)
	{
	struct battery_node *batt_node = NULL;
	struct battery_node *temp_node = NULL;

	if (name == NULL) {
	pr_err("%s: name is invalid!!\n", __func__);
	return NULL;
	}

	batt_node = *start_node;
	while (batt_node) {
	if (!strcmp(batt_node->name, name)) {
	return batt_node;
	} else {
	temp_node = batt_node;
	batt_node = batt_node->next;
	}
	}

	batt_node = kzalloc(sizeof(struct battery_node), GFP_KERNEL);
	if (!batt_node) {
	pr_err("%s: nomem!!\n", __func__);
	return NULL;
	}
	batt_node->np = of_find_node_by_name(NULL, name);
	if (IS_ERR_OR_NULL(batt_node->np)) {
	pr_err("%s: failed to find node(name=%s)\n", __func__, name);
	kfree(batt_node);
	return NULL;
	}
	strcpy(batt_node->name, name);
	if (temp_node)
	temp_node->next = batt_node;
	batt_node->start_prop = NULL;
	if (start_node == NULL) start_node = batt_node;
	pr_info("%s: add battery_node(name = %s)\n", __func__, name);
	return batt_node;
	}

	static int add_battery_property( struct battery_node *batt_node,
	struct battery_property *batt_prop)
	{
	struct battery_property *start_prop = NULL;
	struct battery_property *temp_prop = NULL;

	if (!batt_node \|\| !batt_prop) {
	return -ENODATA;
	}

	start_prop = batt_node->start_prop;
	while (start_prop) {
	if (!strcmp(start_prop->property->name, batt_prop->property->name)) {
	return 0;
	} else {
	temp_prop = start_prop;
	start_prop = start_prop->next;
	}
	}

	if (!temp_prop)
	batt_node->start_prop = batt_prop;
	else {
	temp_prop->next = batt_prop;
	}
	return 0;
	}

	static void change_battery_pdata(
	struct battery_node *start_node, bool is_valid)
	{
	struct battery_node *temp_node = NULL;

	temp_node = start_node;
	pr_info("%s: start update(%d)\n", __func__, is_valid);
	while (is_valid && temp_node) {
	struct battery_property *batt_prop = NULL;
	struct power_supply *psy = NULL;
	union power_supply_propval value;

	batt_prop = temp_node->start_prop;
	while (batt_prop) {
	if (batt_prop->flag != BATTERY_DATA_FLAG_REMOVE) {
	batt_prop->property->value = batt_prop->new_value;
	batt_prop->property->length = batt_prop->new_length;
	}
	batt_prop = batt_prop->next;
	}

	psy = power_supply_get_by_name(start_node->name);
	if (psy) {
	value.intval = 0;
	psy->desc->set_property(psy, POWER_SUPPLY_PROP_POWER_DESIGN, &value);
	power_supply_put(psy);
	}

	temp_node = temp_node->next;
	}

	pr_info("%s: release battery pdata\n", __func__);
	while (start_node) {
	struct battery_property *temp_batt_prop = NULL;
	struct battery_property *batt_prop = NULL;

	batt_prop = start_node->start_prop;
	while (batt_prop) {
	switch (batt_prop->flag) {
	case BATTERY_DATA_FLAG_REMOVE:
	pr_debug("%s: re-set property(ret=%d, flag=%d, name=%s)\n",
	__func__, of_add_property(start_node->np, batt_prop->property),
	batt_prop->flag, batt_prop->property->name);
	break;
	case BATTERY_DATA_FLAG_EDIT:
	pr_debug("%s: re-set property(type=%d, flag=%d, name=%s)\n",
	__func__, batt_prop->type,
	batt_prop->flag, batt_prop->property->name);
	if (!is_valid) {
	kfree(batt_prop->new_value);
	} else {
	/* In normal case, String type should not free. */
	if (batt_prop->type != BATTERY_DATA_TYPE_STRING) {
	batt_prop->property->value = batt_prop->old_value;
	batt_prop->property->length = batt_prop->old_length;
	kfree(batt_prop->new_value);
	}
	}
	break;
	case BATTERY_DATA_FLAG_ADD:
	pr_debug("%s: re-set property(ret=%d, flag=%d, name=%s)\n",
	__func__, of_remove_property(start_node->np, batt_prop->property),
	batt_prop->flag, batt_prop->property->name);
	if (batt_prop->new_value && (!is_valid \|\| batt_prop->type != BATTERY_DATA_TYPE_STRING)) {
	kfree(batt_prop->new_value);
	}
	kfree(batt_prop->property->name);
	kfree(batt_prop->property);
	break;
	}

	temp_batt_prop = batt_prop;
	batt_prop = batt_prop->next;
	kfree(temp_batt_prop);
	}

	temp_node = start_node;
	start_node = start_node->next;
	kfree(temp_node);
	}
	}

	static int sec_battery_check_info(struct file *fp,
	struct battery_data_info *batt_info)
	{
	struct device_node *np;
	struct battery_data batt_data;
	int dt_version, hw_rev, hw_rev_end;
	int ret = 0, read_size;

	read_size = fp->f_op->read(fp, (char*)&batt_data, sizeof(struct battery_data), &fp->f_pos);
	CHECK_ERROR_DATA((read_size <= 0), ret, (-ENODATA), goto finish_check_info);
	CHECK_ERROR_DATA((batt_data.type != BATTERY_DATA_TYPE_INFO), ret, (-EINVAL), goto finish_check_info);

	read_size = fp->f_op->read(fp, (char*)batt_info, sizeof(struct battery_data_info), &fp->f_pos);
	CHECK_ERROR_DATA((read_size <= 0 \|\| read_size != batt_data.length), ret, (-ENODATA), goto finish_check_info);
	CHECK_ERROR_DATA(
	(batt_info->version < 0 \|\| batt_info->hw_rev < 0 \|\| batt_info->prop_count <= 0) \|\|
	(batt_info->value_length < 0 \|\| batt_info->value_length > MAX_VALUE_SIZE),
	ret, (-EINVAL), goto finish_check_info);

	np = of_find_node_by_name(NULL, batt_data.node_name);
	ret = of_property_read_u32(np, "battery,batt_data_version", &dt_version);
	if (ret) {
	pr_info("%s : batt_data_version is Empty\n", __func__);
	dt_version = 0;
	}

	np = of_find_all_nodes(NULL);
	ret = of_property_read_u32(np, "model_info-hw_rev", &hw_rev);
	if (ret) {
	pr_info("%s: model_info-hw_rev is Empty\n", __func__);
	hw_rev = 0;
	}
	ret = of_property_read_u32(np, "model_info-hw_rev_end", &hw_rev_end);
	if (ret) {
	pr_info("%s: model_info-hw_rev_end is Empty\n", __func__);
	hw_rev_end = 99;
	}

	ret = (batt_info->version < dt_version) ? -1 :
	((batt_info->hw_rev > hw_rev_end \|\| batt_info->hw_rev < hw_rev) ? -2 : 0);

	pr_info("%s: check info(ret=%d), version(%d <-> %d), hw_rev(%d ~ %d <-> %d), prop_count(%d), value_length(%d)\n",
	__func__, ret,
	dt_version, batt_info->version,
	hw_rev, hw_rev_end, batt_info->hw_rev,
	batt_info->prop_count, batt_info->value_length);

	finish_check_info:
	return ret;
	}

	static int sec_battery_check_none(struct file *fp)
	{
	struct battery_data batt_data;
	int ret = 0, read_size;

	read_size = fp->f_op->read(fp, (char*)&batt_data, sizeof(struct battery_data), &fp->f_pos);
	CHECK_ERROR_DATA((read_size <= 0), ret, (-ENODATA), goto finish_check_none);

	if (batt_data.type != BATTERY_DATA_TYPE_NONE) {
	pr_info("%s: invalid type(%d)\n", __func__, batt_data.type);
	ret = -EINVAL;
	}

	finish_check_none:
	return ret;
	}

	static char sec_battery_check_value(struct file fp,
	struct battery_data_info batt_info, struct battery_data batt_data)
	{
	char *temp_buf = NULL;
	int read_size;

	if (batt_data->length < 0 \|\| batt_data->length > batt_info->value_length) {
	pr_info("%s: length(%d) of data is invalid\n", __func__, batt_data->length);
	return NULL;
	} else if (batt_data->length == 0) {
	pr_info("%s: skip alloc buffer(length=%d)\n", __func__, batt_data->length);
	return NULL;
	}

	temp_buf = kzalloc(batt_data->length, GFP_KERNEL);
	if (temp_buf) {
	read_size = fp->f_op->read(fp, temp_buf, batt_data->length, &fp->f_pos);
	if (read_size <= 0) {
	pr_info("%s: failed to read value\n", __func__);
	kfree(temp_buf);
	temp_buf = NULL;
	}
	}

	return temp_buf;
	}

	int sec_battery_update_data(const char* file_path)
	{
	struct battery_node *batt_node = NULL;
	struct battery_node *temp_node = NULL;
	struct property *batt_property = NULL;
	struct battery_data_info batt_info;
	struct battery_property *batt_prop;
	struct battery_data batt_data;
	struct file* fp = NULL;
	char *temp_buf = NULL;
	int length, read_size;
	int ret = 0;

	fp = filp_open(file_path, O_RDONLY, 0);
	CHECK_ERROR_DATA(IS_ERR(fp), ret, (int)(PTR_ERR(fp)), goto err_filp_open);

	ret = sec_battery_check_info(fp, &batt_info);
	CHECK_ERROR_DATA((ret), ret, (-EINVAL), goto skip_check_data);

	while (batt_info.prop_count-- > 0) {
	read_size = fp->f_op->read(fp, (char*)&batt_data, sizeof(struct battery_data), &fp->f_pos);
	CHECK_ERROR_DATA((read_size <= 0), ret, (-ENODATA), goto finish_update_data);
	pr_debug("%s: read batt_data(type=%d, flag=%d, node_name=%s, property=%s, length=%d)\n",
	__func__, batt_data.type, batt_data.flag, batt_data.node_name, batt_data.property, batt_data.length);

	temp_node = get_battery_node(&batt_node, batt_data.node_name);
	CHECK_ERROR_DATA((!temp_node), ret, (-ENODEV), goto finish_update_data);

	batt_prop = kzalloc(sizeof(struct battery_property), GFP_KERNEL);
	CHECK_ERROR_DATA((!batt_prop), ret, (-ENOMEM), goto finish_update_data);

	batt_property = of_find_property(temp_node->np, batt_data.property, &length);
	switch (batt_data.flag) {
	case BATTERY_DATA_FLAG_ADD:
	if (IS_ERR_OR_NULL(batt_property)) {
	temp_buf = sec_battery_check_value(fp, &batt_info, &batt_data);
	CHECK_ERROR_DATA((!temp_buf && batt_data.length != 0), ret, (-ENOMEM),
	{kfree(batt_prop); goto finish_update_data;});

	batt_property = kzalloc(sizeof(struct property), GFP_KERNEL);
	CHECK_ERROR_DATA((!batt_property), ret, (-ENOMEM),
	{kfree(batt_prop); kfree(temp_buf); goto finish_update_data;});

	batt_property->name = kzalloc(PROPERTY_SIZE, GFP_KERNEL);
	CHECK_ERROR_DATA((!batt_property->name), ret, (-ENOMEM),
	{kfree(batt_prop); kfree(temp_buf); kfree(batt_property); goto finish_update_data;});

	memcpy(batt_property->name, batt_data.property, PROPERTY_SIZE);
	ret = of_add_property(temp_node->np, batt_property);
	CHECK_ERROR_DATA((ret), ret, ret,
	{kfree(batt_prop); kfree(temp_buf); kfree(batt_property->name); kfree(batt_property); goto finish_update_data;});
	} else {
	pr_info("%s: invalid data(name=%s, property=%s, flag=%d)\n",
	__func__, batt_data.node_name, batt_data.property, batt_data.flag);
	ret = -EINVAL;
	kfree(batt_prop);
	goto finish_update_data;
	}
	break;
	case BATTERY_DATA_FLAG_EDIT:
	if (!IS_ERR_OR_NULL(batt_property)) {
	temp_buf = sec_battery_check_value(fp, &batt_info, &batt_data);
	CHECK_ERROR_DATA((!temp_buf), ret, (-ENOMEM),
	{kfree(batt_prop); goto finish_update_data;});
	} else {
	pr_info("%s: invalid data(name=%s, property=%s, flag=%d)\n",
	__func__, batt_data.node_name, batt_data.property, batt_data.flag);
	ret = -EINVAL;
	kfree(batt_prop);
	goto finish_update_data;
	}
	break;
	case BATTERY_DATA_FLAG_REMOVE:
	if (!IS_ERR_OR_NULL(batt_property)) {
	temp_buf = NULL;

	ret = of_remove_property(temp_node->np, batt_property);
	CHECK_ERROR_DATA((ret), ret, ret, {kfree(batt_prop); goto finish_update_data;});
	} else {
	pr_info("%s: invalid data(name=%s, property=%s, flag=%d)\n",
	__func__, batt_data.node_name, batt_data.property, batt_data.flag);
	ret = -EINVAL;
	kfree(batt_prop);
	goto finish_update_data;
	}
	break;
	default:
	pr_info("%s: invalid flag(%d)\n", __func__, batt_data.flag);
	ret = -EINVAL;
	kfree(batt_prop);
	goto finish_update_data;
	}

	batt_prop->property = batt_property;
	batt_prop->type = batt_data.type;
	batt_prop->flag = batt_data.flag;
	batt_prop->new_value = temp_buf;
	batt_prop->old_value = batt_property->value;
	batt_prop->new_length = batt_data.length;
	batt_prop->old_length = batt_property->length;
	add_battery_property(temp_node, batt_prop);
	}
	ret = sec_battery_check_none(fp);

	finish_update_data:
	change_battery_pdata(batt_node, (ret == 0));
	skip_check_data:
	filp_close(fp, NULL);
	err_filp_open:
	return ret;
	}