/* SPDX-License-Identifier: GPL-2.0 */
/*
 * Copyright (c) 2019 MediaTek Inc.
*/
#include "goodix_cfg_bin.h"
#define CFG_TAG ""
int goodix_start_cfg_bin(struct goodix_ts_core *ts_core)
{
	struct task_struct *cfg_bin_thrd;
	/* create and run update thread */
	cfg_bin_thrd = kthread_run(goodix_cfg_bin_proc,
			ts_core, "goodix-parse_cfg_bin");
	if (IS_ERR_OR_NULL(cfg_bin_thrd)) {
		ts_err("Failed to create update thread:%ld",
				PTR_ERR(cfg_bin_thrd));
		return -EFAULT;
	}
	return 0;
}


int goodix_parse_cfg_bin(struct goodix_cfg_bin *cfg_bin)
{
	u8 checksum;
	int i, r;
	u16 offset1, offset2;

	if (!cfg_bin->bin_data || cfg_bin->bin_data_len == 0) {
		ts_err("NO cfg_bin data, cfg_bin data length:%d",
				cfg_bin->bin_data_len);
		r = -EINVAL;
		goto exit;
	}

	/* copy cfg_bin head info */
	if (cfg_bin->bin_data_len < sizeof(struct goodix_cfg_bin_head)) {
		ts_err("Invalid cfg_bin size:%d", cfg_bin->bin_data_len);
		r = -EINVAL;
		goto exit;
	}
	memcpy(&cfg_bin->head, cfg_bin->bin_data,
			sizeof(struct goodix_cfg_bin_head));
	cfg_bin->head.bin_len = le32_to_cpu(cfg_bin->head.bin_len);


	/*check length*/
	if (cfg_bin->bin_data_len != cfg_bin->head.bin_len) {
		ts_err("cfg_bin len error,cfg_bin len:%d\n,"
			CFG_TAG "len of firmware:%d\n"
			, cfg_bin->head.bin_len
			, cfg_bin->bin_data_len);
		r = -EINVAL;
		goto exit;
	}

	/*check cfg_bin valid*/
	checksum = 0;
	for (i = TS_BIN_VERSION_START_INDEX; i < cfg_bin->bin_data_len; i++)
		checksum += cfg_bin->bin_data[i];

	if (checksum != cfg_bin->head.checksum) {
		ts_err("cfg_bin checksum ERROR, checksum in cfg_bin:0x%02x,"
			CFG_TAG "checksum caculate:0x%02x"
			, cfg_bin->head.checksum, checksum);
		r = -EINVAL;
		goto exit;
	}

	/*allocate memory for cfg packages*/
	cfg_bin->cfg_pkgs =
	      kzalloc(sizeof(struct goodix_cfg_package) * cfg_bin->head.pkg_num,
			GFP_KERNEL);
	if (!cfg_bin->cfg_pkgs) {
		ts_err("cfg_pkgs, allocate memory ERROR");
		r = -ENOMEM;
		goto exit;
	}
	/*get cfg_pkg's info*/
	for (i = 0; i < cfg_bin->head.pkg_num; i++) {
		/*get cfg pkg length*/
		if (i == cfg_bin->head.pkg_num - 1) {
			offset1 = cfg_bin->bin_data[TS_CFG_BIN_HEAD_LEN +
							i * TS_CFG_OFFSET_LEN] +
				(cfg_bin->bin_data[TS_CFG_BIN_HEAD_LEN +
					       i * TS_CFG_OFFSET_LEN + 1] << 8);

			cfg_bin->cfg_pkgs[i].pkg_len = cfg_bin->bin_data_len
								- offset1;
		} else {
			offset1 = cfg_bin->bin_data[TS_CFG_BIN_HEAD_LEN +
						 i * TS_CFG_OFFSET_LEN] +
				(cfg_bin->bin_data[TS_CFG_BIN_HEAD_LEN +
				i * TS_CFG_OFFSET_LEN + 1] << 8);

			offset2 = cfg_bin->bin_data[TS_CFG_BIN_HEAD_LEN +
				 i * TS_CFG_OFFSET_LEN + 2] +
				(cfg_bin->bin_data[TS_CFG_BIN_HEAD_LEN +
				i * TS_CFG_OFFSET_LEN + 3] << 8);

			if (offset2 <= offset1) {
				ts_err("offset error,pkg:%d, offset1:%d,"
					CFG_TAG "offset2:%d"
					, i, offset1, offset2);
				r = -EINVAL;
				goto exit;
			}

			cfg_bin->cfg_pkgs[i].pkg_len = offset2 - offset1;
		}
		/*get cfg pkg head*/
		memcpy(&cfg_bin->cfg_pkgs[i].cnst_info,
				&cfg_bin->bin_data[offset1],
				TS_PKG_CONST_INFO_LEN);
		memcpy(&cfg_bin->cfg_pkgs[i].reg_info,
			&cfg_bin->bin_data[offset1 + TS_PKG_CONST_INFO_LEN],
				TS_PKG_REG_INFO_LEN);
		/*compatible little edition and big edition*/
		goodix_cfg_pkg_leToCpu(&cfg_bin->cfg_pkgs[i]);
		/*get configuration data*/
		cfg_bin->cfg_pkgs[i].cfg =
			&cfg_bin->bin_data[offset1 + TS_PKG_HEAD_LEN];
	}

	/*debug, print pkg information*/
	for (i = 0; i < cfg_bin->head.pkg_num; i++) {
		ts_info("---------------------------------------------");
		ts_info("------package:%d------", i + 1);
		ts_info("package len:%04x",
			cfg_bin->cfg_pkgs[i].cnst_info.pkg_len);
		ts_info("package ic_type:%s",
			cfg_bin->cfg_pkgs[i].cnst_info.ic_type);
		ts_info("package cfg_type:%01x",
			cfg_bin->cfg_pkgs[i].cnst_info.cfg_type);
		ts_info("package sensor_id:%01x",
			cfg_bin->cfg_pkgs[i].cnst_info.sensor_id);
		ts_info("package hw_pid:%s",
			cfg_bin->cfg_pkgs[i].cnst_info.hw_pid);
		ts_info("package hw_vid:%s",
			cfg_bin->cfg_pkgs[i].cnst_info.hw_vid);
		ts_info("package fw_mask_version:%s",
			cfg_bin->cfg_pkgs[i].cnst_info.fw_mask);
		ts_info("package fw_patch_version:%s",
			cfg_bin->cfg_pkgs[i].cnst_info.fw_patch);
		ts_info("package x_res_offset:%02x",
			cfg_bin->cfg_pkgs[i].cnst_info.x_res_offset);
		ts_info("package y_res_offset:%02x",
			cfg_bin->cfg_pkgs[i].cnst_info.y_res_offset);
		ts_info("package trigger_offset:%02x",
			cfg_bin->cfg_pkgs[i].cnst_info.trigger_offset);
		ts_info("");
		ts_info("send_cfg_flag reg:%02x",
			cfg_bin->cfg_pkgs[i].reg_info.cfg_send_flag.addr);
		ts_info("version base reg:%02x, len:%d",
			cfg_bin->cfg_pkgs[i].reg_info.version_base.addr,
			cfg_bin->cfg_pkgs[i].reg_info.version_base.reserved1);
		ts_info("pid reg:%02x", cfg_bin->cfg_pkgs[i].reg_info.pid.addr);
		ts_info("vid reg:%02x", cfg_bin->cfg_pkgs[i].reg_info.vid.addr);
		ts_info("sensor_id reg:%02x",
			cfg_bin->cfg_pkgs[i].reg_info.sensor_id.addr);
		ts_info("fw_status reg:%02x",
			cfg_bin->cfg_pkgs[i].reg_info.fw_status.addr);
		ts_info("cfg_addr reg:%02x",
			cfg_bin->cfg_pkgs[i].reg_info.cfg_addr.addr);
		ts_info("esd reg:%02x", cfg_bin->cfg_pkgs[i].reg_info.esd.addr);
		ts_info("command reg:%02x",
			cfg_bin->cfg_pkgs[i].reg_info.command.addr);
		ts_info("coor:%02x",
			cfg_bin->cfg_pkgs[i].reg_info.coor.addr);
		ts_info("gesture:%02x",
			cfg_bin->cfg_pkgs[i].reg_info.gesture.addr);
		ts_info("fw_request:%02x",
			cfg_bin->cfg_pkgs[i].reg_info.fw_request.addr);
		ts_info("proximity:%02x",
			cfg_bin->cfg_pkgs[i].reg_info.proximity.addr);
		ts_info("--------------------------------------------");
	}
	r = 0;
exit:
	return r;
}

int goodix_cfg_bin_proc(void *data)
{
	struct goodix_ts_core *core_data = data;
	struct goodix_ts_device *ts_dev = core_data->ts_dev;

	struct device *dev = ts_dev->dev;
	int r;
	struct goodix_cfg_bin *cfg_bin =
		kzalloc(sizeof(struct goodix_cfg_bin), GFP_KERNEL);

	if (!cfg_bin) {
		ts_err("Failed to alloc memory for cfg_bin");
		r = -ENOMEM;
		goto out;
	}

	cfg_bin->cfg_pkgs = NULL;
	/*get cfg_bin from file system*/
	r = goodix_read_cfg_bin(dev, cfg_bin);
	if (r < 0) {
		ts_err("read cfg_bin from /etc/firmware FAILED");
		goto exit;
	}
	/*parse cfg bin*/
	r = goodix_parse_cfg_bin(cfg_bin);
	if (!r) {
		ts_info("parse cfg bin SUCCESS");
	} else {
		ts_err("parse cfg bin FAILED");
		goto exit;
	}

	/*init i2c_set_doze_mode para*/
	ts_dev->doze_mode_set_count = 0;
	mutex_init(&ts_dev->doze_mode_lock);


	/*get register address and configuration from cfg bin*/
	r = goodix_get_reg_and_cfg(ts_dev, cfg_bin);
	if (!r) {
		ts_info("get reg and cfg from cfg_bin SUCCESS");
	} else {
		if (r != -EBUS) {
			ts_err("get reg and cfg from cfg_bin FAILED,"
				CFG_TAG "update fw then retry");
			goodix_modules.core_data = core_data;
			goodix_modules.core_exit = false;
			complete_all(&goodix_modules.core_comp);
			goto exit;
		} else {
			ts_err("get reg and cfg from cfg_bin FAILED,"
				CFG_TAG "I2C com ERROR");
			goto exit;
		}
	}

	/*debug*/
	ts_info("@@@@@@@@@");
	ts_info("cfg_send_flag:0x%04x", ts_dev->reg.cfg_send_flag);
	ts_info("pid:0x%04x", ts_dev->reg.pid);
	ts_info("vid:0x%04x", ts_dev->reg.vid);
	ts_info("sensor_id:0x%04x", ts_dev->reg.sensor_id);
	ts_info("fw_mask:0x%04x", ts_dev->reg.fw_mask);
	ts_info("fw_status:0x%04x", ts_dev->reg.fw_status);
	ts_info("cfg_addr:0x%04x", ts_dev->reg.cfg_addr);
	ts_info("esd:0x%04x", ts_dev->reg.esd);
	ts_info("command:0x%04x", ts_dev->reg.command);
	ts_info("coor:0x%04x", ts_dev->reg.coor);
	ts_info("gesture:0x%04x", ts_dev->reg.gesture);
	ts_info("fw_request:0x%04x", ts_dev->reg.fw_request);
	ts_info("proximity:0x%04x", ts_dev->reg.proximity);
	ts_info("@@@@@@@@@");


	/* initialize firmware */
	r = ts_dev->hw_ops->init(ts_dev);
	if (-EBUS == r)
		goto exit;

	/* alloc/config/register input device */
	r = goodix_ts_input_dev_config(core_data);
	if (r < 0)
		goto exit;

	/* request irq line */
	r = goodix_ts_irq_setup(core_data);
	if (r < 0)
		goto exit;

	/*set flag, prevent fwupdate module parse cfg_group again*/
	core_data->cfg_group_parsed = true;

	/* inform the external module manager that*/
	/* touch core layer is ready now */
	goodix_modules.core_data = core_data;
	goodix_modules.core_exit = false;
	/*complete_all(&goodix_modules.core_comp);*/

#ifdef CONFIG_FB
	core_data->fb_notifier.notifier_call = goodix_ts_fb_notifier_callback;
	if (fb_register_client(&core_data->fb_notifier))
		ts_err("Failed to register fb notifier client:%d", r);
#elif defined(CONFIG_HAS_EARLYSUSPEND)
	core_data->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
	core_data->early_suspend.resume = goodix_ts_lateresume;
	core_data->early_suspend.suspend = goodix_ts_earlysuspend;
	register_early_suspend(&core_data->early_suspend);
#endif

	/* esd protector */
#ifdef GT9886_ESD_ENABLE
	goodix_ts_esd_init(core_data);
#endif

	/* generic notifier callback */
	core_data->ts_notifier.notifier_call = goodix_generic_noti_callback;
	goodix_ts_register_notifier(&core_data->ts_notifier);

exit:
	complete_all(&goodix_modules.core_comp);

	if (cfg_bin->cfg_pkgs) {
		kfree(cfg_bin->cfg_pkgs);
		cfg_bin->cfg_pkgs = NULL;
	}

	if (cfg_bin->bin_data) {
		kfree(cfg_bin->bin_data);
		cfg_bin->bin_data = NULL;
	}
	kfree(cfg_bin);
out:
	return r;
}

int goodix_get_reg_and_cfg(struct goodix_ts_device *ts_dev,
				struct goodix_cfg_bin *cfg_bin)
{
	int i;
	u16 addr;
	u8 read_len;
	struct goodix_cfg_package *normal_pkg, *high_sense_pkg;
	char temp_sensor_id = -1;
	u8 temp_fw_mask[TS_CFG_BLOCK_FW_MASK_LEN] = {0x00};
	u8 temp_pid[TS_CFG_BLOCK_PID_LEN] = {0x00};
	int r = -EINVAL;

	normal_pkg = NULL;
	high_sense_pkg = NULL;

	if (!cfg_bin->head.pkg_num || !cfg_bin->cfg_pkgs) {
		ts_err("there is none cfg package, pkg_num:%d",
				cfg_bin->head.pkg_num);
		r = -EINVAL;
		goto exit;
	}

	/*select suitable cfg packages*/
	for (i = 0; i < cfg_bin->head.pkg_num; i++) {
		/*get ic type*/
		if (!strncmp(cfg_bin->cfg_pkgs[i].cnst_info.ic_type, "nanjing",
				sizeof(cfg_bin->cfg_pkgs[i].cnst_info.ic_type)))
			ts_dev->ic_type = IC_TYPE_NANJING;
		else if (!strncmp(cfg_bin->cfg_pkgs[i].cnst_info.ic_type,
				"normandy",
				sizeof(cfg_bin->cfg_pkgs[i].cnst_info.ic_type)))
			ts_dev->ic_type = IC_TYPE_NORMANDY;
		else
			ts_err("get ic type FAILED,"
				CFG_TAG "unknown ic type from cfg_bin:%s",
				cfg_bin->cfg_pkgs[i].cnst_info.ic_type);


		ts_info("ic_type:%d", ts_dev->ic_type);

		/*contrast sensor id*/
		addr = cfg_bin->cfg_pkgs[i].reg_info.sensor_id.addr;
		if (!addr) {
			ts_info("pkg:%d, sensor_id reg is NULL", i);
			continue;
		}

		r = goodix_i2c_read(ts_dev, addr,
				&temp_sensor_id, 1);
		if (r < 0) {
			ts_err("read sensor id FAILED,I2C ERROR, pkg:%d,"
				CFG_TAG "sensor_id reg:0x%02x", i, addr);
			goto exit;
		} else {
			/*sensor.reserved1 is a mask, if it's not ZERO, use it*/
			if (cfg_bin->cfg_pkgs[i].reg_info.sensor_id.reserved1
			!= 0)
				temp_sensor_id &=
			      cfg_bin->cfg_pkgs[i].reg_info.sensor_id.reserved1;

			if (temp_sensor_id !=
			cfg_bin->cfg_pkgs[i].cnst_info.sensor_id) {
				ts_err("pkg:%d, sensor id contrast FAILED,"
					CFG_TAG "reg:0x%02x", i, addr);
				ts_err("sensor_id from i2c:%d, sensor_id of cfg"
					CFG_TAG "bin:%d", temp_sensor_id,
				cfg_bin->cfg_pkgs[i].cnst_info.sensor_id);
				continue;
			}
		}

		/*contrast fw_mask, if this reg is null, skip this step*/
		addr = cfg_bin->cfg_pkgs[i].reg_info.fw_mask.addr;
		if (!addr || !cfg_bin->cfg_pkgs[i].cnst_info.fw_mask[0]) {
			ts_err("pkg:%d, fw_mask of cfg bin is NULL, Skip!!", i);
		} else {
			r = goodix_i2c_read(ts_dev, addr, temp_fw_mask,
						sizeof(temp_fw_mask));
			if (r < 0) {
				ts_err("read fw_mask FAILED, I2C ERROR,pkg:"
				CFG_TAG "%d, fw_mask reg:0x%02x", i, addr);
				goto exit;
			} else if (strncmp(temp_fw_mask,
				cfg_bin->cfg_pkgs[i].cnst_info.fw_mask,
				sizeof(temp_fw_mask))) {
				ts_err("pkg:%d, fw_mask contrast FAILED,"
					CFG_TAG "reg:0x%02x,", i, addr);
				ts_err("mask from i2c:%s, mask of cfg bin:%s",
					temp_fw_mask,
					cfg_bin->cfg_pkgs[i].cnst_info.fw_mask);
				continue;
			}
		}

		/*contrast pid*/
		addr = cfg_bin->cfg_pkgs[i].reg_info.pid.addr;
		read_len = cfg_bin->cfg_pkgs[i].reg_info.pid.reserved1;
		if (!addr) {
			ts_err("pkg:%d, pid reg is NULL", i);
			continue;
		}
		if (read_len <= 0 || read_len > TS_CFG_BLOCK_PID_LEN) {
			ts_err("pkg:%d, hw_pid len ERROR, len:%d", i, read_len);
			continue;
		}
		r = goodix_i2c_read(ts_dev, addr, temp_pid, read_len);
		if (r < 0) {
			ts_err("read pid FAILED, I2C ERROR, pkg: %d,"
				CFG_TAG "pid reg:0x%02x", i, addr);
			goto exit;
		} else if (strncmp(temp_pid,\
		  cfg_bin->cfg_pkgs[i].cnst_info.hw_pid, read_len)) {
				ts_err("pkg:%d, pid contrast FAILED,"
					CFG_TAG "reg:0x%02x", i, addr);
				ts_err("pid from i2c:%s, pid of cfg bin:%s"
					, temp_pid,
					cfg_bin->cfg_pkgs[i].cnst_info.hw_pid);
				continue;
		}

		/*contrast success, cfg_type*/
		if (cfg_bin->cfg_pkgs[i].cnst_info.cfg_type == TS_NORMAL_CFG) {
			ts_info("find normal cfg_pkg SUCCESS");
			r = 0;
			normal_pkg = &cfg_bin->cfg_pkgs[i];
		}
		if (cfg_bin->cfg_pkgs[i].cnst_info.cfg_type ==
		TS_HIGH_SENSE_CFG) {
			ts_info("find high sense cfg_pkg SUCCESS");
			high_sense_pkg = &cfg_bin->cfg_pkgs[i];
		}
	}

	/*get register address from normal_pkg*/
	if (!normal_pkg) {
		ts_err("ERROR, none suitable normal_pkg exist in cfg_bin");
		/*ts_dev->ic_type = IC_TYPE_NONE;*/
		r = -EINVAL;
		goto exit;
	} else {
		/*get ic type*/
		if (!strncmp(normal_pkg->cnst_info.ic_type, "nanjing",
					sizeof(normal_pkg->cnst_info.ic_type)))
			ts_dev->ic_type = IC_TYPE_NANJING;
		else if (!strncmp(normal_pkg->cnst_info.ic_type, "normandy",
					sizeof(normal_pkg->cnst_info.ic_type)))
			ts_dev->ic_type = IC_TYPE_NORMANDY;
		else
			ts_err("get ic type FAILED, unknown ic type from"
				CFG_TAG "cfg_bin:%s"
				, normal_pkg->cnst_info.ic_type);

		/*get register info*/
		ts_dev->reg.cfg_send_flag =
				normal_pkg->reg_info.cfg_send_flag.addr;

		ts_dev->reg.version_base =
				normal_pkg->reg_info.version_base.addr;
		ts_dev->reg.version_len =
				normal_pkg->reg_info.version_base.reserved1;

		ts_dev->reg.pid = normal_pkg->reg_info.pid.addr;
		ts_dev->reg.pid_len = normal_pkg->reg_info.pid.reserved1;

		ts_dev->reg.vid = normal_pkg->reg_info.vid.addr;
		ts_dev->reg.vid_len = normal_pkg->reg_info.vid.reserved1;

		ts_dev->reg.sensor_id = normal_pkg->reg_info.sensor_id.addr;
		ts_dev->reg.sensor_id_mask =
				normal_pkg->reg_info.sensor_id.reserved1;

		ts_dev->reg.fw_mask = normal_pkg->reg_info.fw_mask.addr;
		ts_dev->reg.fw_status = normal_pkg->reg_info.fw_status.addr;
		ts_dev->reg.cfg_addr = normal_pkg->reg_info.cfg_addr.addr;
		ts_dev->reg.esd = normal_pkg->reg_info.esd.addr;
		ts_dev->reg.command = normal_pkg->reg_info.command.addr;
		ts_dev->reg.coor = normal_pkg->reg_info.coor.addr;
		ts_dev->reg.gesture = normal_pkg->reg_info.gesture.addr;
		ts_dev->reg.fw_request = normal_pkg->reg_info.fw_request.addr;
		ts_dev->reg.proximity = normal_pkg->reg_info.proximity.addr;
	}

	/*get configuration from pkgs*/
	if (normal_pkg) {
		ts_info("normal cfg is found!");
		if (!ts_dev->normal_cfg) {
			ts_dev->normal_cfg = devm_kzalloc(ts_dev->dev,
				sizeof(*ts_dev->normal_cfg), GFP_KERNEL);
			if (!ts_dev->normal_cfg) {
				ts_err("Failed to alloc memory for normal cfg");
				return -ENOMEM;
			}
			mutex_init(&ts_dev->normal_cfg->lock);
		}

		ts_dev->normal_cfg->length = normal_pkg->pkg_len -
			TS_PKG_CONST_INFO_LEN - TS_PKG_REG_INFO_LEN;
		memcpy(ts_dev->normal_cfg->data, normal_pkg->cfg
				, ts_dev->normal_cfg->length);
	}

	if (high_sense_pkg) {
		ts_info("high sense cfg is found!");
		if (!ts_dev->highsense_cfg) {
			ts_dev->highsense_cfg = devm_kzalloc(ts_dev->dev,
				sizeof(*ts_dev->highsense_cfg), GFP_KERNEL);
			if (!ts_dev->highsense_cfg) {
				ts_err("Failed to alloc"
					CFG_TAG " memory for high sense cfg");
				return -ENOMEM;
			}
			mutex_init(&ts_dev->highsense_cfg->lock);
		}

		ts_dev->highsense_cfg->length = high_sense_pkg->pkg_len -
			TS_PKG_CONST_INFO_LEN - TS_PKG_REG_INFO_LEN;
		memcpy(ts_dev->highsense_cfg->data,
				high_sense_pkg->cfg,
				ts_dev->highsense_cfg->length);
	}

exit:
	return r;
}


int goodix_read_cfg_bin(struct device *dev, struct goodix_cfg_bin *cfg_bin)
{
	int r;
	const struct firmware *firmware = NULL;
	char cfg_bin_name[32] = {0};
	int i = 0;

	/*get cfg_bin_name*/
	r = snprintf(cfg_bin_name, sizeof(cfg_bin_name), "%s%s.bin",
		TS_DEFAULT_CFG_BIN, gt9886_config_buf);
	if (r >= sizeof(cfg_bin_name)) {
		ts_err("get cfg_bin name FAILED!!!");
		goto exit;
	}
	ts_info("cfg_bin_name:%s", cfg_bin_name);

	for (i = 0; i < TS_RQST_FW_RETRY_TIMES; i++) {
		r = request_firmware(&firmware, cfg_bin_name, dev);
		if (r < 0) {
			ts_err("Cfg_bin image [%s] not available,error:%d,"
				CFG_TAG"try_times:%d", cfg_bin_name, r, i + 1);

			msleep(3000);
		} else {
			ts_info("Cfg_bin image [%s] is ready, try_times:%d",
					cfg_bin_name, i + 1);
			break;
		}
	}
	if (i >= TS_RQST_FW_RETRY_TIMES) {
		ts_err("get cfg_bin FAILED");
		goto exit;
	}

	if (firmware->size <= 0) {
		ts_err("request_firmware, cfg_bin length ERROR,len:%zu",
				firmware->size);
		r = -EINVAL;
		goto exit;
	}

	cfg_bin->bin_data_len = firmware->size;
	/*allocate memory for cfg_bin->bin_data*/
	cfg_bin->bin_data = kzalloc(cfg_bin->bin_data_len, GFP_KERNEL);
	if (!cfg_bin->bin_data) {
		ts_err("Allocate memory for cfg_bin->bin_data FAILED");
		r = -ENOMEM;
		goto exit;
	}
	memcpy(cfg_bin->bin_data, firmware->data, cfg_bin->bin_data_len);

	r = 0;
exit:
	if (firmware) {
		release_firmware(firmware);
		firmware = NULL;
	}
	return r;
}

int goodix_read_cfg_bin_from_dts(struct device_node *node,
					struct goodix_cfg_bin *cfg_bin)
{
	unsigned int len = 0;
	struct property *prop = NULL;

	prop = of_find_property(node, "goodix_cfg_bin", &len);
	if (!prop || !prop->value || len == 0) {
		ts_err("Invalid cfg type, size:%u",  len);
		return -EINVAL;
	}

	cfg_bin->bin_data_len = len;
	/*allocate memory for cfg_bin->bin_data*/
	cfg_bin->bin_data = kzalloc(cfg_bin->bin_data_len, GFP_KERNEL);
	if (!cfg_bin->bin_data) {
		ts_err("Allocate memory for cfg_bin->bin_data FAILED");
		return -ENOMEM;
	}
	memcpy(cfg_bin->bin_data, prop->value, cfg_bin->bin_data_len);

	return 0;
}

void goodix_cfg_pkg_leToCpu(struct goodix_cfg_package *pkg)
{
	if (!pkg) {
		ts_err("cfg package is NULL");
		return;
	}
	/*package const_info*/
	pkg->cnst_info.pkg_len = le32_to_cpu(pkg->cnst_info.pkg_len);
	pkg->cnst_info.x_res_offset = le16_to_cpu(pkg->cnst_info.x_res_offset);
	pkg->cnst_info.y_res_offset = le16_to_cpu(pkg->cnst_info.y_res_offset);
	pkg->cnst_info.trigger_offset =
				le16_to_cpu(pkg->cnst_info.trigger_offset);

	/*package reg_info*/
	pkg->reg_info.cfg_send_flag.addr =
				le16_to_cpu(pkg->reg_info.cfg_send_flag.addr);
	pkg->reg_info.pid.addr = le16_to_cpu(pkg->reg_info.pid.addr);
	pkg->reg_info.vid.addr = le16_to_cpu(pkg->reg_info.vid.addr);
	pkg->reg_info.sensor_id.addr =
				le16_to_cpu(pkg->reg_info.sensor_id.addr);
	pkg->reg_info.fw_status.addr =
				le16_to_cpu(pkg->reg_info.fw_status.addr);
	pkg->reg_info.cfg_addr.addr = le16_to_cpu(pkg->reg_info.cfg_addr.addr);
	pkg->reg_info.esd.addr = le16_to_cpu(pkg->reg_info.esd.addr);
	pkg->reg_info.command.addr = le16_to_cpu(pkg->reg_info.command.addr);
	pkg->reg_info.coor.addr = le16_to_cpu(pkg->reg_info.coor.addr);
	pkg->reg_info.gesture.addr = le16_to_cpu(pkg->reg_info.gesture.addr);
	pkg->reg_info.fw_request.addr =
				le16_to_cpu(pkg->reg_info.fw_request.addr);
	pkg->reg_info.proximity.addr =
				le16_to_cpu(pkg->reg_info.proximity.addr);
}