/*
 * Allwinner SoCs eink driver.
 *
 * Copyright (C) 2019 Allwinner.
 *
 * This file is licensed under the terms of the GNU General Public
 * License version 2.  This program is licensed "as is" without any
 * warranty of any kind, whether express or implied.
 */

#include "asm/cacheflush.h"
#include <linux/sunxi-gpio.h>
#include <linux/ion.h>
#include "include/eink_sys_source.h"
#include "include/eink_driver.h"

#define BYTE_ALIGN(x) (((x + (4 * 1024 - 1)) >> 12) << 12)

extern struct eink_driver_info g_eink_drvdata;


s32 eink_set_print_level(u32 level)
{
	EINK_INFO_MSG("print level = 0x%x\n", level);
	g_eink_drvdata.eink_dbg_info = level;

	return 0;
}

/* 0 -- no log
 * 8 -- print timer info
 * 7 -- capture DE WB BUF
 * 6 -- capture wavfile
 * 5 -- decode debug
 * 4 -- dump register
 * 3 -- print pipe and buf list
 * 2 -- reserve
 * 1 -- base debug info
 */

s32 eink_get_print_level(void)
{
	return g_eink_drvdata.eink_dbg_info;
}

s32 get_delt_ms_timer(struct timeval start_timer, struct timeval end_timer)
{
	return ((end_timer.tv_sec - start_timer.tv_sec) * 1000 + (end_timer.tv_usec - start_timer.tv_usec)/1000);
}

s32 get_delt_us_timer(struct timeval start_timer, struct timeval end_timer)
{
	return ((end_timer.tv_sec - start_timer.tv_sec) * 1000000 + (end_timer.tv_usec - start_timer.tv_usec));
}

bool is_upd_win_zero(struct upd_win update_area)
{
	if ((update_area.left == 0) && (update_area.right == 0) && (update_area.top == 0) && (update_area.bottom == 0))
		return true;
	else
		return false;
}

int atoi_float(char *buf)
{
	int num = 0;
	int i = 0;
	int point_pos = -1;
	int pow = 0;

	while (buf[i] != '\0') {
		if (buf[i] >= '0' && buf[i] <= '9')	{
			if ((point_pos < 0) || ((point_pos >= 0) && ((point_pos + 4) > i))) {
				num = num * 10 + (buf[i] - '0');
			} else {
				//drop the left char
				break;
			}
		}

		if (buf[i] == '.') {
			point_pos = i;
		}
		i++;
	}

	//auto *1000
	if ((point_pos >= 0) && ((point_pos + 4) > i)) {
		pow = (point_pos + 4 - i);
		while (pow > 0) {
			num = num * 10;
			pow--;
		}
	}

	if (buf[0] == '-')
		num = num * (-1);

	EINK_INFO_MSG("input str=%s, num=%d\n", buf, num);

	return num;
}

int eink_sys_pin_set_state(char *dev_name, char *name)
{
	char compat[32];
	u32 len = 0;
	struct device_node *node = NULL;
	struct platform_device *pdev = NULL;
	struct pinctrl *pctl = NULL;
	struct pinctrl_state *state = NULL;
	int ret = -1;

	len = sprintf(compat, "allwinner,sunxi-%s", dev_name);
	if (len > 32)
		pr_warn("size of mian_name is out of range\n");

	node = of_find_compatible_node(NULL, NULL, compat);
	if (!node) {
		pr_err("of_find_compatible_node %s fail\n", compat);
		goto exit;
	}

	pdev = of_find_device_by_node(node);
	if (!node) {
		pr_err("of_find_device_by_node for %s fail\n", compat);
		goto exit;
	}

	pctl = pinctrl_get(&pdev->dev);
	if (IS_ERR(pctl)) {
		/*not every eink need pin config*/
		pr_err("%s:pinctrl_get for %s fail\n", __func__, compat);
		ret = PTR_ERR(pctl);
		goto exit;
	}

	state = pinctrl_lookup_state(pctl, name);
	if (IS_ERR(state)) {
		pr_err("%s:pinctrl_lookup_state for %s fail\n", __func__, compat);
		ret = PTR_ERR(state);
		goto exit;
	}

	ret = pinctrl_select_state(pctl, state);
	if (ret < 0) {
		pr_err("%s:pinctrl_select_state(%s) for %s fail\n", __func__, name, compat);
		goto exit;
	}
	ret = 0;
exit:
	return ret;
}
EXPORT_SYMBOL(eink_sys_pin_set_state);

int eink_sys_power_enable(char *name)
{
	int ret = 0;
#if defined(CONFIG_AW_AXP) || defined(CONFIG_REGULATOR)
	struct regulator *regu = NULL;

#ifdef CONFIG_SUNXI_REGULATOR_DT
	regu = regulator_get(g_eink_drvdata.device, name);
#else
	regu = regulator_get(NULL, name);
#endif
	if (IS_ERR(regu)) {
		pr_err("some error happen, fail to get regulator %s\n", name);
		goto exit;
	}
	/* enalbe regulator */
	ret = regulator_enable(regu);
	if (ret != 0) {
		pr_err("some err happen, fail to enable regulator %s!\n", name);
		goto exit1;
	} else {
		pr_info("suceess to enable regulator %s!\n", name);
	}

exit1:
	/* put regulater, when module exit */
	regulator_put(regu);
exit:
#endif
	return ret;
}
EXPORT_SYMBOL(eink_sys_power_enable);

int eink_sys_power_disable(char *name)
{
	int ret = 0;
#if defined(CONFIG_AW_AXP) || defined(CONFIG_REGULATOR)
	struct regulator *regu = NULL;

#ifdef CONFIG_SUNXI_REGULATOR_DT
	regu = regulator_get(g_eink_drvdata.device, name);
#else
	regu = regulator_get(NULL, name);
#endif
	if (IS_ERR(regu)) {
		pr_err("some error happen, fail to get regulator %s\n", name);
		goto exit;
	}
	/* disalbe regulator */
	ret = regulator_disable(regu);
	if (ret != 0) {
		pr_err("some err happen, fail to disable regulator %s!\n", name);
		goto exit1;
	} else {
		pr_info("suceess to disable regulator %s!\n", name);
	}

exit1:
	/* put regulater, when module exit */
	regulator_put(regu);
exit:
#endif
	return ret;
}
EXPORT_SYMBOL(eink_sys_power_disable);

s32 eink_panel_pin_cfg(u32 en)
{
	struct eink_manager *eink_mgr = get_eink_manager();
	char dev_name[25];

	if (eink_mgr == NULL) {
		DE_WRN("NULL hdl!\n");
		return -1;
	}
	EINK_INFO_MSG("eink pin config, state %s, %d\n", (en) ? "on" : "off", en);

	/* io-pad */
	if (en == 1) {
		if (!((!strcmp(eink_mgr->eink_pin_power, "")) ||
			(!strcmp(eink_mgr->eink_pin_power, "none"))))
			eink_sys_power_enable(eink_mgr->eink_pin_power);
	}

	sprintf(dev_name, "eink");
	eink_sys_pin_set_state(dev_name, (en == 1) ?
			EINK_PIN_STATE_ACTIVE : EINK_PIN_STATE_SLEEP);

	if (en == 0) {
		if (!((!strcmp(eink_mgr->eink_pin_power, "")) ||
			(!strcmp(eink_mgr->eink_pin_power, "none"))))
			eink_sys_power_disable(eink_mgr->eink_pin_power);
	}

	return 0;
}

int eink_sys_gpio_request(struct eink_gpio_cfg *gpio_list,
			  u32 group_count_max)
{
	int ret = 0;
	struct gpio_config pin_cfg;
	char pin_name[32];
	u32 config;
	char pintype[50] = SUNXI_PINCTRL;

	if (gpio_list == NULL) {
		pr_err("%s: gpio list is null\n", __func__);
		return 0;
	}

	pin_cfg.gpio = gpio_list->gpio;
	pin_cfg.mul_sel = gpio_list->mul_sel;
	pin_cfg.pull = gpio_list->pull;
	pin_cfg.drv_level = gpio_list->drv_level;
	pin_cfg.data = gpio_list->data;
	ret = gpio_request(pin_cfg.gpio, NULL);
	if (ret != 0) {
		pr_err("%s failed, gpio_name=%s, gpio=%d, ret=%d\n", __func__,
		      gpio_list->gpio_name, gpio_list->gpio, ret);
		return 0;
	}

	EINK_DEBUG_MSG("gpio_name=%s, gpio=%3d, <%d,%d,%d,%d> ret=%d\n",
				 gpio_list->gpio_name, gpio_list->gpio,
				 gpio_list->mul_sel, gpio_list->pull,
				 gpio_list->drv_level, gpio_list->data, ret);

	ret = pin_cfg.gpio;

	if (!IS_AXP_PIN(pin_cfg.gpio)) {
		/*
		 * valid pin of sunxi-pinctrl,
		 * config pin attributes individually.
		 */
		sunxi_gpio_to_name(pin_cfg.gpio, pin_name);
		config =
		    SUNXI_PINCFG_PACK(SUNXI_PINCFG_TYPE_FUNC, pin_cfg.mul_sel);
		ret = pin_config_set(pintype, pin_name, config);
		if (ret == -EINVAL) {
			/*try r_pio*/
			snprintf(pintype, 50, SUNXI_R_PINCTRL);
			ret = pin_config_set(pintype, pin_name, config);
		}
		if (pin_cfg.pull != GPIO_PULL_DEFAULT) {
			config =
			    SUNXI_PINCFG_PACK(SUNXI_PINCFG_TYPE_PUD,
					      pin_cfg.pull);
			pin_config_set(pintype, pin_name, config);
		}
		if (pin_cfg.drv_level != GPIO_DRVLVL_DEFAULT) {
			config =
			    SUNXI_PINCFG_PACK(SUNXI_PINCFG_TYPE_DRV,
					      pin_cfg.drv_level);
			pin_config_set(pintype, pin_name, config);
		}
		if (pin_cfg.data != GPIO_DATA_DEFAULT) {
			config =
			    SUNXI_PINCFG_PACK(SUNXI_PINCFG_TYPE_DAT,
					      pin_cfg.data);
			pin_config_set(pintype, pin_name, config);
		}
	} else if (IS_AXP_PIN(pin_cfg.gpio)) {
		/* valid pin of axp-pinctrl,
		* config pin attributes individually.
		*/
		sunxi_gpio_to_name(pin_cfg.gpio, pin_name);
		if (pin_cfg.data != GPIO_DATA_DEFAULT) {
			config = SUNXI_PINCFG_PACK(SUNXI_PINCFG_TYPE_DAT,
			    pin_cfg.data);
			pin_config_set(AXP_PINCTRL, pin_name, config);
		}
	} else {
		pr_warn("invalid pin [%d] from sys-config\n", pin_cfg.gpio);
	}

	return pin_cfg.gpio;
}
EXPORT_SYMBOL(eink_sys_gpio_request);

int eink_sys_gpio_release(int p_handler)
{
	if (p_handler)
		gpio_free(p_handler);
	else
		pr_warn("%s: hdl is NULL\n", __func__);

	return 0;
}
EXPORT_SYMBOL(eink_sys_gpio_release);

int eink_sys_gpio_set_value(u32 p_handler, u32 value_to_gpio,
			    const char *gpio_name)
{
	if (p_handler)
		__gpio_set_value(p_handler, value_to_gpio);
	else
		pr_warn("EINK_SET_GPIO, hdl is NULL\n");

	return 0;
}

/* type: 0:invalid, 1: int; 2:str, 3: gpio */
int eink_sys_script_get_item(char *main_name, char *sub_name, int value[],
			     int type)
{
	char compat[32];
	u32 len = 0;
	struct device_node *node;
	int ret = 0;
	struct gpio_config config;

	len = sprintf(compat, "allwinner,sunxi-%s", main_name);
	if (len > 32)
		pr_err("size of mian_name is out of range\n");

	node = of_find_compatible_node(NULL, NULL, compat);
	if (!node) {
		pr_err("of_find_compatible_node %s fail\n", compat);
		return ret;
	}

	if (type == 1) {
		if (of_property_read_u32_array(node, sub_name, value, 1))
			pr_info("of_property_read_u32_array %s.%s fail\n",
			      main_name, sub_name);
		else
			ret = type;
	} else if (type == 2) {
		const char *str;

		if (of_property_read_string(node, sub_name, &str))
			pr_info("of_property_read_string %s.%s fail\n", main_name,
			      sub_name);
		else {
			ret = type;
			memcpy((void *)value, str, strlen(str) + 1);
		}
	} else if (type == 3) {
		struct eink_gpio_cfg *gpio_info =
		    (struct eink_gpio_cfg *)value;
		int gpio;

		gpio =
		    of_get_named_gpio_flags(node, sub_name, 0,
					    (enum of_gpio_flags *)&config);
		if (!gpio_is_valid(gpio))
			goto exit;

		gpio_info->gpio = config.gpio;
		gpio_info->mul_sel = config.mul_sel;
		gpio_info->pull = config.pull;
		gpio_info->drv_level = config.drv_level;
		gpio_info->data = config.data;
		memcpy(gpio_info->gpio_name, sub_name, strlen(sub_name) + 1);
		__inf("%s.%s gpio=%d,mul_sel=%d,data:%d\n", main_name, sub_name,
		      gpio_info->gpio, gpio_info->mul_sel, gpio_info->data);
		ret = type;
	}

exit:
	return ret;
}
EXPORT_SYMBOL(eink_sys_script_get_item);

#if defined(CONFIG_ION_SUNXI) && defined(EINK_CACHE_MEM)
static int __eink_ion_alloc_coherent(struct ion_client *client, struct eink_ion_mem *mem)
{
	unsigned int flags = ION_FLAG_CACHED | ION_FLAG_CACHED_NEEDS_SYNC;
	struct scatterlist *sgl = NULL;
	int ret = -1;

	if (IS_ERR_OR_NULL(client) || (mem == NULL)) {
		pr_err("input param is null\n");
		return -1;
	}

#if defined(CONFIG_SUNXI_IOMMU)
	mem->handle = ion_alloc(client, mem->size, 0,
				(1 << ION_HEAP_TYPE_SYSTEM), flags);
#else
	mem->handle = ion_alloc(client, mem->size, PAGE_SIZE,
				((1<<ION_HEAP_TYPE_CARVEOUT) |
				(1 << ION_HEAP_TYPE_DMA)), flags);
#endif
	if (IS_ERR_OR_NULL(mem->handle)) {
		pr_err("ion_alloc failed, size=%lu!\n", (unsigned long)mem->size);
		return -2;
	}

	mem->vaddr = ion_map_kernel(client, mem->handle);
	if (IS_ERR_OR_NULL(mem->vaddr)) {
		pr_err("ion_map_kernel failed!!\n");
		goto err_map_kernel;
	}

#ifndef CONFIG_IOMMU_SUPPORT
	if (ion_phys(client, mem->handle, (ion_phys_addr_t *)&mem->paddr, &mem->size)) {
		pr_err("ion_phys failed!!\n");
		goto err_phys;
	}
#else
	sgl = mem->handle->buffer->sg_table->sgl;
	ret = dma_map_sg(g_eink_drvdata.device, sgl, 1, DMA_BIDIRECTIONAL);
	if (ret != 1) {
		pr_err("dma map sg fail, ret=%d\n", ret);
		goto err_phys;
	}
	mem->paddr = sg_dma_address(sgl);
#endif

	EINK_INFO_MSG("ion malloc size=0x%x, vaddr=%p, paddr=0x%08x\n",
			(unsigned int)mem->size, mem->vaddr, (unsigned int)mem->paddr);

	return 0;

err_phys:
	ion_unmap_kernel(client, mem->handle);
err_map_kernel:
	ion_free(client, mem->handle);
	return -ENOMEM;
}

static void __eink_ion_free_coherent(struct ion_client *client, struct eink_ion_mem *mem)
{
	if (IS_ERR_OR_NULL(client) || IS_ERR_OR_NULL(mem->handle) || IS_ERR_OR_NULL(mem->vaddr)) {
		pr_err("input param is null\n");
		return;
	}

	ion_unmap_kernel(client, mem->handle);
	ion_free(client, mem->handle);
	return;
}

static void __eink_ion_dump(void)
{
#ifdef ION_DEBUG_DUMP
	struct eink_ion_mgr *ion_mgr =  &(g_eink_drvdata.ion_mgr);
	struct ion_client *client = NULL;
	struct eink_ion_list_node *ion_node = NULL, *tmp_ion_node = NULL;
	struct eink_ion_mem *mem = NULL;
	unsigned int i = 0;

	if (ion_mgr == NULL) {
		pr_err("eink ion mgr is not initial yet\n");
		return;
	}

	client = ion_mgr->client;

	mutex_lock(&(ion_mgr->mlock));
	list_for_each_entry_safe(ion_node, tmp_ion_node, &ion_mgr->ion_list, node) {
		if (ion_node != NULL) {
			mem = &ion_node->mem;
			EINK_INFO_MSG("ion node %d: vaddr=0x%08x, paddr=0x%08x, size=%d\n",
				i, (unsigned int)mem->vaddr, (unsigned int)mem->paddr, mem->size);
			i++;
		}
	}
	mutex_unlock(&(ion_mgr->mlock));
#endif
	return;
}

static void *eink_ion_malloc(u32 num_bytes, void *phys_addr)
{
	struct eink_ion_mgr *ion_mgr =  &(g_eink_drvdata.ion_mgr);
	struct ion_client *client = NULL;
	struct eink_ion_list_node *ion_node = NULL;
	struct eink_ion_mem *mem = NULL;
	u32 *paddr = NULL;
	int ret = -1;

	if (ion_mgr == NULL) {
		pr_err("eink ion manager has not initial yet\n");
		return NULL;
	}

	ion_node = kmalloc(sizeof(*ion_node), GFP_KERNEL);
	if (ion_node == NULL) {
		pr_err("fail to alloc ion node, size=%u\n",
				(unsigned int)sizeof(*ion_node));
		return NULL;
	}

	mutex_lock(&(ion_mgr->mlock));
	client = ion_mgr->client;
	mem = &ion_node->mem;
	mem->size = BYTE_ALIGN(num_bytes);
	ret = __eink_ion_alloc_coherent(client, mem);
	if (ret != 0) {
		pr_err("fail to alloc ion, ret=%d\n", ret);
		goto err_hdl;
	}

	paddr = (u32 *)phys_addr;
	*paddr = (u32)mem->paddr;
	list_add_tail(&(ion_node->node), &(ion_mgr->ion_list));

	mutex_unlock(&(ion_mgr->mlock));

	__eink_ion_dump();

	return mem->vaddr;

err_hdl:
	kfree(ion_node);
	mutex_unlock(&(ion_mgr->mlock));

	return NULL;
}

static void eink_ion_free(void *virt_addr, void *phys_addr, u32 num_bytes)
{
	struct eink_ion_mgr *ion_mgr =  &(g_eink_drvdata.ion_mgr);
	struct ion_client *client = NULL;
	struct eink_ion_list_node *ion_node = NULL, *tmp_ion_node = NULL;
	struct eink_ion_mem *mem = NULL;
	bool found = false;

	if (ion_mgr == NULL) {
		pr_err("eink ion manager has not initial yet\n");
		return;
	}

	client = ion_mgr->client;

	mutex_lock(&(ion_mgr->mlock));
	list_for_each_entry_safe(ion_node, tmp_ion_node, &ion_mgr->ion_list, node) {
		if (ion_node != NULL) {
			mem = &ion_node->mem;
			if ((((unsigned long)mem->paddr) == ((unsigned long)phys_addr)) &&
				(((unsigned long)mem->vaddr) == ((unsigned long)virt_addr))) {
				__eink_ion_free_coherent(client, mem);
				__list_del_entry(&(ion_node->node));
				found = true;
				break;
			}
		}
	}
	mutex_unlock(&(ion_mgr->mlock));

	if (false == found) {
		pr_err("vaddr=0x%08x, paddr=0x%08x is not found in ion\n",
				*((unsigned int *)virt_addr), *((unsigned int *)phys_addr));
	}

	return;
}

int init_eink_ion_mgr(struct eink_ion_mgr *ion_mgr)
{
	if (ion_mgr == NULL) {
		pr_err("[%s]:input param is null\n", __func__);
		return -EINVAL;
	}

	mutex_init(&(ion_mgr->mlock));

	mutex_lock(&(ion_mgr->mlock));
	INIT_LIST_HEAD(&(ion_mgr->ion_list));
	ion_mgr->client = sunxi_ion_client_create("ion_eink");
	if (IS_ERR_OR_NULL(ion_mgr->client)) {
		mutex_unlock(&(ion_mgr->mlock));
		pr_err("[%s]:eink_ion client create failed!!", __func__);
		return -ENOMEM;
	} else {
		EINK_INFO_MSG("Init ion manager for EINK ok\n");
	}
	mutex_unlock(&(ion_mgr->mlock));

	return 0;

}

void deinit_eink_ion_mgr(struct eink_ion_mgr *ion_mgr)
{
	struct eink_ion_list_node *ion_node = NULL, *tmp_ion_node = NULL;
	struct eink_ion_mem *mem = NULL;
	struct ion_client *client = NULL;

	if (ion_mgr == NULL) {
		pr_err("[%s]:input param is null\n", __func__);
		return;
	}

	client = ion_mgr->client;
	mutex_lock(&(ion_mgr->mlock));
	list_for_each_entry_safe(ion_node, tmp_ion_node,
						&ion_mgr->ion_list, node) {
		if (ion_node != NULL) {
			// free all ion node
			mem = &ion_node->mem;
			__eink_ion_free_coherent(client, mem);
			__list_del_entry(&(ion_node->node));
			kfree(ion_node);
		}
	}
	ion_client_destroy(client);
	mutex_unlock(&(ion_mgr->mlock));
}

#else
void *eink_mem_malloc(u32 num_bytes, void *phys_addr)
{
	u32 actual_bytes;
	void *address = NULL;

	EINK_DEBUG_MSG("input!\n");
	if (num_bytes != 0) {
		actual_bytes = ALIGN(num_bytes, PAGE_SIZE);

		address =
		    dma_alloc_coherent(g_eink_drvdata.device, actual_bytes,
				       (dma_addr_t *) phys_addr, GFP_KERNEL);
		if (address) {
			EINK_INFO_MSG
			    ("dma_alloc_coherent ok, address=0x%p, size=0x%x\n",
			     (void *)(*(unsigned long *)phys_addr), num_bytes);
			return address;
		}

		pr_err("dma_alloc_coherent fail, size=0x%x\n", num_bytes);
		return NULL;
	}

	pr_warn("%s size is zero\n", __func__);

	return NULL;
}

void eink_mem_free(void *virt_addr, void *phys_addr, u32 num_bytes)
{
	u32 actual_bytes;

	actual_bytes = BYTE_ALIGN(num_bytes);
	if (phys_addr && virt_addr)
		dma_free_coherent(g_eink_drvdata.device, actual_bytes, virt_addr,
				  (dma_addr_t)phys_addr);
}
#endif

void *eink_malloc(u32 num_bytes, void *phys_addr)
{
#if defined(CONFIG_ION_SUNXI) && defined(EINK_CACHE_MEM)
	return eink_ion_malloc(num_bytes, phys_addr); /* cache */
#else
	return eink_mem_malloc(num_bytes, phys_addr); /* skip cache */
#endif
}
EXPORT_SYMBOL(eink_malloc);

void eink_free(void *virt_addr, void *phys_addr, u32 num_bytes)
{
#if defined(CONFIG_ION_SUNXI) && defined(EINK_CACHE_MEM)
	return eink_ion_free(virt_addr, phys_addr, num_bytes);
#else
	return eink_mem_free(virt_addr, phys_addr, num_bytes);
#endif
}
EXPORT_SYMBOL(eink_free);

void eink_cache_sync(void *startAddr, int size)
{
#if defined(CONFIG_ION_SUNXI) && defined(EINK_CACHE_MEM)
	struct sunxi_cache_range range;

	range.start = (unsigned long)startAddr;
	range.end = (unsigned long)startAddr + size;

#ifdef CONFIG_ARM64
	__dma_flush_range((void *)range.start, range.end - range.start);
#else
	dmac_flush_range((void *)range.start, (void *)range.end);
#endif
	return;
#else
	return;
#endif
}
EXPORT_SYMBOL(eink_cache_sync);

int eink_dma_map_core(int fd, struct dmabuf_item *item)
{
	struct dma_buf *dmabuf;
	struct dma_buf_attachment *attachment;
	struct sg_table *sgt, *sgt_bak;
	struct scatterlist *sgl, *sgl_bak;
	s32 sg_count = 0;
	int ret = -1;
	int i;

	if (fd < 0) {
		pr_err("[EINK]dma_buf_id(%d) is invalid\n", fd);
		goto exit;
	}
	dmabuf = dma_buf_get(fd);
	if (IS_ERR(dmabuf)) {
		pr_err("[EINK]dma_buf_get failed, fd=%d\n", fd);
		goto exit;
	}

	attachment = dma_buf_attach(dmabuf, g_eink_drvdata.device);
	if (IS_ERR(attachment)) {
		pr_err("[EINK]dma_buf_attach failed\n");
		goto err_buf_put;
	}
	sgt = dma_buf_map_attachment(attachment, DMA_FROM_DEVICE);
	if (IS_ERR_OR_NULL(sgt)) {
		pr_err("[EINK]dma_buf_map_attachment failed\n");
		goto err_buf_detach;
	}

	/* create a private sgtable base on the given dmabuf */
	sgt_bak = kmalloc(sizeof(struct sg_table), GFP_KERNEL | __GFP_ZERO);
	if (sgt_bak == NULL) {
		pr_err("[EINK]alloc sgt fail\n");
		goto err_buf_unmap;
	}
	ret = sg_alloc_table(sgt_bak, sgt->nents, GFP_KERNEL);
	if (ret != 0) {
		pr_err("[EINK]alloc sgt fail\n");
		goto err_kfree;
	}
	sgl_bak = sgt_bak->sgl;
	for_each_sg(sgt->sgl, sgl, sgt->nents, i)  {
		sg_set_page(sgl_bak, sg_page(sgl), sgl->length, sgl->offset);
		sgl_bak = sg_next(sgl_bak);
	}

	sg_count = dma_map_sg_attrs(g_eink_drvdata.device, sgt_bak->sgl,
			      sgt_bak->nents, DMA_FROM_DEVICE,
			      DMA_ATTR_SKIP_CPU_SYNC);

	if (sg_count != 1) {
		pr_err("[EINK]dma_map_sg failed:%d\n", sg_count);
		goto err_sgt_free;
	}

	item->fd = fd;
	item->buf = dmabuf;
	item->sgt = sgt_bak;
	item->attachment = attachment;
	item->dma_addr = sg_dma_address(sgt_bak->sgl);
	ret = 0;

	goto exit;

err_sgt_free:
	sg_free_table(sgt_bak);
err_kfree:
	kfree(sgt_bak);
err_buf_unmap:
	/* unmap attachment sgt, not sgt_bak, because it's not alloc yet! */
	dma_buf_unmap_attachment(attachment, sgt, DMA_FROM_DEVICE);
err_buf_detach:
	dma_buf_detach(dmabuf, attachment);
err_buf_put:
	dma_buf_put(dmabuf);
exit:
	return ret;
}

void eink_dma_unmap_core(struct dmabuf_item *item)
{

	dma_unmap_sg_attrs(g_eink_drvdata.device, item->sgt->sgl,
			      item->sgt->nents, DMA_FROM_DEVICE,
			      DMA_ATTR_SKIP_CPU_SYNC);
	dma_buf_unmap_attachment(item->attachment, item->sgt, DMA_FROM_DEVICE);
	sg_free_table(item->sgt);
	kfree(item->sgt);
	dma_buf_detach(item->buf, item->attachment);
	dma_buf_put(item->buf);
}

struct dmabuf_item *eink_dma_map(int fd)
{
	struct dmabuf_item *item = NULL;

	EINK_INFO_MSG("Func intput!\n");
	item = kmalloc(sizeof(struct dmabuf_item),
			      GFP_KERNEL | __GFP_ZERO);

	if (item == NULL) {
		pr_err("malloc memory of size %d fail!\n",
		       (unsigned int)sizeof(struct dmabuf_item));
		goto exit;
	}
	if (eink_dma_map_core(fd, item) != 0) {
		kfree(item);
		item = NULL;
	}

exit:
	return item;
}

void eink_dma_unmap(struct dmabuf_item *item)
{
	eink_dma_unmap_core(item);
	kfree(item);
}

void eink_print_register(unsigned long start_addr, unsigned long end_addr)
{
	unsigned long start_addr_align = ALIGN(start_addr, 4);
	unsigned long end_addr_align = ALIGN(end_addr, 4);
	unsigned long addr = 0;
	unsigned char tmp_buf[50] = {0};
	unsigned char buf[256] = {0};

	pr_info("\n");
	pr_info("print reg: [0x%08x ~ 0x%08x]\n", (unsigned int)start_addr_align, (unsigned int)end_addr_align);
	for (addr = start_addr_align; addr <= end_addr_align; addr += 4) {
		if (0 == (addr & 0xf)) {
			memset(tmp_buf, 0, sizeof(tmp_buf));
			memset(buf, 0, sizeof(buf));
			snprintf(tmp_buf, sizeof(tmp_buf), "0x%08x: ", (unsigned int)addr);
			strncat(buf, tmp_buf, sizeof(tmp_buf));
		}

		memset(tmp_buf, 0, sizeof(tmp_buf));
		//snprintf(tmp_buf, sizeof(tmp_buf), "0x%08x ", readl((void __iomem *)(addr | 0xf0000000)));
		snprintf(tmp_buf, sizeof(tmp_buf), "0x%08x ", readl((void __iomem *)addr));
		strncat(buf, tmp_buf, sizeof(tmp_buf));
		if (0 == ((addr + 4) & 0xf)) {
			pr_info("%s\n", buf);
			msleep(5);
		}
	}
}

void print_free_pipe_list(struct pipe_manager *mgr)
{
	struct pipe_info_node *pipe, *tpipe;
	unsigned long flags = 0;
	unsigned int count = 0;

	spin_lock_irqsave(&mgr->list_lock, flags);
	if (list_empty(&mgr->pipe_free_list)) {
		EINK_INFO_MSG("FREE_LIST is empty\n");
		spin_unlock_irqrestore(&mgr->list_lock, flags);
		return;
	}

	list_for_each_entry_safe(pipe, tpipe, &mgr->pipe_free_list, node) {
#ifdef PIPELINE_DEBUG
		EINK_INFO_MSG("FREE_LIST: pipe %02d is free\n", pipe->pipe_id);
#endif
		count++;
	}

	EINK_INFO_MSG("[+++] %d Pipes are Free!\n", count);

	spin_unlock_irqrestore(&mgr->list_lock, flags);
}

void print_used_pipe_list(struct pipe_manager *mgr)
{
	struct pipe_info_node *pipe, *tpipe;
	unsigned long flags = 0;
	unsigned int count = 0;

	spin_lock_irqsave(&mgr->list_lock, flags);
	if (list_empty(&mgr->pipe_used_list)) {
		EINK_INFO_MSG("USED_LIST is empty\n");
		spin_unlock_irqrestore(&mgr->list_lock, flags);
		return;
	}

	list_for_each_entry_safe(pipe, tpipe, &mgr->pipe_used_list, node) {
#ifdef PIPELINE_DEBUG
		EINK_INFO_MSG("USED_LIST: pipe %02d is used\n", pipe->pipe_id);
#endif
		count++;
	}

	EINK_INFO_MSG("[+++] %d Pipes are Used!\n", count);

	spin_unlock_irqrestore(&mgr->list_lock, flags);
}

void print_coll_img_list(struct buf_manager *mgr)
{
	struct img_node *curnode = NULL, *tmpnode = NULL;

	mutex_lock(&mgr->mlock);
	if (list_empty(&mgr->img_collision_list)) {
		EINK_INFO_MSG("COLL_LIST is empty\n");
		mutex_unlock(&mgr->mlock);
		return;
	}

	list_for_each_entry_safe(curnode, tmpnode, &mgr->img_collision_list, node) {
		EINK_INFO_MSG("COLL_LIST: img [buf_id, order, state] [%d, %d, %d] is collision\n",
						curnode->buf_id, curnode->upd_order, curnode->img->state);
	}
	mutex_unlock(&mgr->mlock);
}

void print_used_img_list(struct buf_manager *mgr)
{
	struct img_node *curnode = NULL, *tmpnode = NULL;

	mutex_lock(&mgr->mlock);
	if (list_empty(&mgr->img_used_list)) {
		EINK_INFO_MSG("USED_LIST is empty\n");
		mutex_unlock(&mgr->mlock);
		return;
	}

	list_for_each_entry_safe(curnode, tmpnode, &mgr->img_used_list, node) {
		EINK_INFO_MSG("IMG_USED_LIST: img [buf_id, order, state] [%d, %d, %d] is used\n",
					curnode->buf_id, curnode->upd_order, curnode->img->state);
	}

	mutex_unlock(&mgr->mlock);
}

void print_free_img_list(struct buf_manager *mgr)
{
	struct img_node *curnode = NULL, *tmpnode = NULL;

	mutex_lock(&mgr->mlock);
	if (list_empty(&mgr->img_free_list)) {
		EINK_INFO_MSG("IMG_FREE_LIST is empty\n");
		mutex_unlock(&mgr->mlock);
		return;
	}

	list_for_each_entry_safe(curnode, tmpnode, &mgr->img_free_list, node) {
		EINK_INFO_MSG("FREE_LIST: img [buf_id, order, state] [%d, %d, %d] is free\n",
						curnode->buf_id, curnode->upd_order, curnode->img->state);
	}

	mutex_unlock(&mgr->mlock);
}

int save_as_bin_file(__u8 *buf, char *file_name, __u32 length, loff_t pos)
{
	struct file *fp = NULL;
	mm_segment_t old_fs;
	ssize_t ret = 0;

	if ((buf == NULL) || (file_name == NULL)) {
		pr_err("%s: buf or file_name is null\n", __func__);
		return -1;
	}

	fp = filp_open(file_name, O_RDWR | O_CREAT, 0644);
	if (IS_ERR(fp)) {
		pr_err("%s: fail to open file(%s), ret=%d\n",
					__func__, file_name, *((u32 *)fp));
		return -1;
	}

	old_fs = get_fs();
	set_fs(KERNEL_DS);

	ret = vfs_write(fp, buf, length, &pos);
	pr_info("%s: save %s done, len=%u, pos=%lld, ret=%d\n",
					__func__, file_name, length, pos, (unsigned int)ret);

	set_fs(old_fs);
	filp_close(fp, NULL);

	return ret;

}

s32 save_gray_image_as_bmp(u8 *buf, char *file_name, u32 scn_w, u32 scn_h)
{
	int ret = -1;
	ES_FILE *fd = NULL;
	mm_segment_t old_fs;
	loff_t pos = 0;
	BMP_FILE_HEADER st_file_header;
	BMP_INFO_HEADER st_info_header;
	char *src_buf = buf;
	char *path = file_name;
	BMP_INFO dest_info;
	u32 bit_count = 0;
	ST_RGB *dest_buf = NULL;
	ST_ARGB color_table[256];
	u32 i  = 0;

	if ((path == NULL) || (src_buf == NULL)) {
		pr_err("%s: input param is null\n", __func__);
		return -1;
	}

	fd = filp_open(path, O_RDWR | O_CREAT, 0644);
	if (IS_ERR(fd)) {
		pr_err("%s: create bmp file(%s) error\n", __func__, path);
		return -2;
	}

	bit_count = 8;
	memset(&dest_info, 0, sizeof(BMP_INFO));
	dest_info.width = scn_w;
	dest_info.height = scn_h;
	dest_info.bit_count = 8;
	dest_info.color_tbl_size = 0;
	dest_info.image_size = (dest_info.width * dest_info.height * dest_info.bit_count)/8;

	st_file_header.bfType[0] = 'B';
	st_file_header.bfType[1] = 'M';
	st_file_header.bfOffBits = BMP_IMAGE_DATA_OFFSET;
	st_file_header.bfSize = st_file_header.bfOffBits + dest_info.image_size;
	st_file_header.bfReserved1 = 0;
	st_file_header.bfReserved2 = 0;

	st_info_header.biSize = sizeof(BMP_INFO_HEADER);
	st_info_header.biWidth = dest_info.width;
	st_info_header.biHeight = dest_info.height;
	st_info_header.biPlanes = 1;
	st_info_header.biBitCount = dest_info.bit_count;
	st_info_header.biCompress = 0;
	st_info_header.biSizeImage = dest_info.image_size;
	st_info_header.biXPelsPerMeter = 0;
	st_info_header.biYPelsPerMeter = 0;
	st_info_header.biClrUsed = 0;
	st_info_header.biClrImportant = 0;

	for (i = 0; i < 256; i++) {
		color_table[i].reserved = 0;
		color_table[i].r = i;
		color_table[i].g = i;
		color_table[i].b = i;
	}

	dest_buf = (ST_RGB *)src_buf;

	old_fs = get_fs();
	set_fs(KERNEL_DS);

	ret = vfs_write(fd, (u8 *)(&st_file_header), BMP_FILE_HEADER_SIZE, &pos);
	EINK_INFO_MSG("save file header, len=%u, pos=%d, ret=%d\n", (unsigned int)BMP_FILE_HEADER_SIZE, (int)pos, ret);

	ret = vfs_write(fd, (u8 *)(&st_info_header), BMP_INFO_HEADER_SIZE, &pos);
	EINK_INFO_MSG("save file header, len=%u, pos=%d, ret=%d\n", (unsigned int)BMP_INFO_HEADER_SIZE, (int)pos, ret);

	ret = vfs_write(fd, (u8 *)(color_table), BMP_COLOR_SIZE, &pos);
	EINK_INFO_MSG("save file header, len=%u, pos=%d, ret=%d\n", (unsigned int)BMP_COLOR_SIZE, (int)pos, ret);

	ret = vfs_write(fd, (u8 *)(dest_buf), dest_info.image_size, &pos);
	EINK_INFO_MSG("save file header, len=%u, pos=%d, ret=%d\n", dest_info.image_size, (int)pos, ret);

	set_fs(old_fs);

	ret = 0;

	if (!IS_ERR(fd)) {
		filp_close(fd, NULL);
	}

	return ret;
}

void save_upd_rmi_buffer(u32 order, u8 *buf, u32 len)
{
	char file_name[256] = {0};

	if (buf == NULL) {
		pr_err("%s:input param is null\n", __func__);
		return;
	}

	memset(file_name, 0, sizeof(file_name));
	snprintf(file_name, sizeof(file_name), "/tmp/rmi_buf%d.bin", order);
	save_as_bin_file(buf, file_name, len, 0);
}

void eink_put_gray_to_mem(u32 order, char *buf, u32 width, u32 height)
{
	char file_name[256] = {0};

	if (buf == NULL) {
		pr_err("input param is null\n");
		return;
	}

	memset(file_name, 0, sizeof(file_name));
	snprintf(file_name, sizeof(file_name), "/tmp/eink_image%d.bmp", order);
	save_gray_image_as_bmp((u8 *)buf, file_name, width, height);
}

void eink_save_last_img(char *buf, u32 width, u32 height)
{
	char file_name[256] = {0};
	static int order;

	if (buf == NULL) {
		pr_err("input param is null\n");
		return;
	}

	pr_info("[%s]: ", __func__);
	memset(file_name, 0, sizeof(file_name));
	snprintf(file_name, sizeof(file_name), "/tmp/last_img%d.bmp", order);
	save_gray_image_as_bmp((u8 *)buf, file_name, width, height);
	order++;
}

void eink_save_current_img(char *buf, u32 width, u32 height)
{
	char file_name[256] = {0};
	static int order;

	if (buf == NULL) {
		pr_err("input param is null\n");
		return;
	}

	pr_info("[%s]: ", __func__);
	memset(file_name, 0, sizeof(file_name));
	snprintf(file_name, sizeof(file_name), "/tmp/cur_img%d.bmp", order);
	save_gray_image_as_bmp((u8 *)buf, file_name, width, height);
	order++;
}

int eink_get_default_file_from_mem(__u8 *buf, char *file_name, __u32 length, loff_t pos)
{
	struct file *fp = NULL;
	mm_segment_t fs;
	__s32 read_len = 0;
	ssize_t ret = 0;

	if ((buf == NULL) || (file_name == NULL)) {
		pr_err("%s: buf or file_name is null\n", __func__);
		return -1;
	}

	EINK_INFO_MSG("\n");
	fp = filp_open(file_name, O_RDONLY, 0);
	if (IS_ERR(fp)) {
		pr_err("%s: fail to open file(%s), ret=0x%p\n",
				__func__, file_name, fp);
		return -1;
	}
	fs = get_fs();
	set_fs(KERNEL_DS);

	read_len = vfs_read(fp, buf, length, &pos);
	if (read_len != length) {
		pr_err("maybe miss some data(read=%d byte, file=%d byte)\n",
				read_len, length);
		ret = -EAGAIN;
	}
	set_fs(fs);
	filp_close(fp, NULL);

	return ret;
}

void save_waveform_to_mem(u32 order, u8 *buf, u32 frames, u32 bit_num)
{
	char file_name[256] = {0};
	u32 len = 0, per_size = 0;

	if (buf == NULL) {
		pr_err("%s:input param is null\n", __func__);
		return;
	}
	if (bit_num == 5)
		per_size = 1024;
	else
		per_size = 256;

	len = frames * per_size;

	pr_info("[%s] size = (%d x %d) = %d\n", __func__, frames, bit_num, len);
	memset(file_name, 0, sizeof(file_name));
	snprintf(file_name, sizeof(file_name), "/tmp/waveform%d.bin", order);
	save_as_bin_file(buf, file_name, len, 0);
}

void save_rearray_waveform_to_mem(u8 *buf, u32 len)
{
	char file_name[256] = {0};

	if (buf == NULL) {
		pr_err("%s:input param is null\n", __func__);
		return;
	}
	pr_info("%s:len is %d\n", __func__, len);

	memset(file_name, 0, sizeof(file_name));
	snprintf(file_name, sizeof(file_name), "/tmp/waveform_rearray.bin");
	save_as_bin_file(buf, file_name, len, 0);
}

#ifdef OFFLINE_SINGLE_MODE
void save_one_wavedata_buffer(u8 *buf, bool is_edma)
{
	struct wavedata_queue *queue = NULL;
	/* u8 *buf = NULL; */
	char file_name[256] = {0};
	static u32 dec_id = 0, edma_id;
	u32 data_len = 0;
	u32 vsync = 0, hsync = 0;
	struct eink_manager *mgr = get_eink_manager();
	struct pipe_manager *pipe_mgr = get_pipeline_manager();

	if (pipe_mgr == NULL) {
		pr_err("%s;pipe mgr is NULL\n", __func__);
		return;
	}

	hsync = mgr->timing_info.lbl + mgr->timing_info.lsl + mgr->timing_info.ldl + mgr->timing_info.lel;
	vsync = mgr->timing_info.fbl + mgr->timing_info.fsl + mgr->timing_info.fdl + mgr->timing_info.fel;

	if (mgr->panel_info.data_len == 8) {
		data_len = hsync * vsync;
	} else {
		data_len = hsync * vsync * 2;
	}

	queue = &pipe_mgr->wavedata_ring_buffer;
	memset(file_name, 0, sizeof(file_name));
	if (is_edma) {
		snprintf(file_name, sizeof(file_name), "/tmp/edma_wf_data%d.bin", edma_id);
		/* buf = (void*)queue->wavedata_vaddr[0]; */
		edma_id++;
	} else {
		snprintf(file_name, sizeof(file_name), "/tmp/dc_wf_data%d.bin", dec_id);
		/* buf = (void*)queue->wavedata_vaddr[0]; */
		dec_id++;
	}

	save_as_bin_file(buf, file_name, data_len, 0);
}

#if 0
static void dump_wavedata_buffer(struct wavedata_queue *queue)
{
	int i = 0;
	unsigned long flags = 0;
	unsigned int head = 0, tail = 0, tmp_tail = 0, tmp_head = 0;
	enum wv_buffer_state buffer_state[WAVE_DATA_BUF_NUM];

	spin_lock_irqsave(&queue->slock, flags);
	head = queue->head;
	tail = queue->tail;
	tmp_tail = queue->tmp_tail;
	tmp_head = queue->tmp_head;

	for (i = 0; i < WAVE_DATA_BUF_NUM; i++)
		buffer_state[i] = queue->buffer_state[i];
	spin_unlock_irqrestore(&queue->slock, flags);

	EINK_INFO_MSG("head=%d, tail=%d, tmp_head=%d, tmp_tail=%d\n", head, tail, tmp_head, tmp_tail);
	for (i = 0; i < WAVE_DATA_BUF_NUM; i++) {
		if (buffer_state[i] != WV_INIT_STATE) {
			printk("miss buffer %d, state=%d\n", i, buffer_state[i]);
		}
	}
}
#endif

void save_all_wavedata_buffer(struct eink_manager *mgr, u32 all_total_frames)
{
	struct wavedata_queue *queue = NULL;
	u8 *buf = NULL;
	char file_name[256] = {0};
	u32 id = 0;
	u32 data_len = 0;
	u32 vsync = 0, hsync = 0;
	struct pipe_manager *pipe_mgr = get_pipeline_manager();

	if (pipe_mgr == NULL) {
		pr_err("%s;pipe mgr is NULL\n", __func__);
		return;
	}

	if (all_total_frames > WAVE_DATA_BUF_NUM) {
		pr_err("too many frames(%d), not to save\n ", all_total_frames);
		return;
	}

	hsync = mgr->timing_info.lbl + mgr->timing_info.lsl + mgr->timing_info.ldl + mgr->timing_info.lel;
	vsync = mgr->timing_info.fbl + mgr->timing_info.fsl + mgr->timing_info.fdl + mgr->timing_info.fel;

	if (mgr->panel_info.data_len == 8) {
		data_len = hsync * vsync;
	} else {
		data_len = hsync * vsync * 2;
	}

	EINK_INFO_MSG("save wavedata, total_frames=%d\n", all_total_frames);
	queue = &pipe_mgr->wavedata_ring_buffer;
	for (id = 0; id < all_total_frames; id++) {
		memset(file_name, 0, sizeof(file_name));
		snprintf(file_name, sizeof(file_name), "/tmp/wvdata_%d.bin", id);
		buf = (void *)queue->wavedata_vaddr[id];
		save_as_bin_file(buf, file_name, data_len, 0);
	}
}
#endif