kernel_samsung_sm7125/drivers/battery_v2/sec_battery_data.c

/*
 *  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;
}