/* SPDX-License-Identifier: GPL-2.0 */
/*
 * Copyright (c) 2019 MediaTek Inc.
*/

#define LOG_TAG "ddp_manager"

#include <linux/slab.h>
#include <linux/mutex.h>

#include "disp_helper.h"
#include "lcm_drv.h"
#include "ddp_reg.h"
#include "ddp_path.h"
#include "ddp_irq.h"
#include "ddp_drv.h"
#include "ddp_debug.h"
#include "ddp_manager.h"
#include "ddp_rdma.h"
#include "ddp_rdma_ex.h"
#include "ddp_ovl.h"

#include "ddp_log.h"

/* #define __GED_NOTIFICATION_SUPPORT__ */
#ifdef __GED_NOTIFICATION_SUPPORT__
#include "ged.h"
#endif

static int ddp_manager_init;
#define DDP_MAX_MANAGER_HANDLE (DISP_MUTEX_DDP_COUNT + DISP_MUTEX_DDP_FIRST)

struct DPMGR_WQ_HANDLE {
	unsigned int init;
	enum DISP_PATH_EVENT event;
	wait_queue_head_t wq;
	unsigned long long data;
};

struct DDP_IRQ_EVENT_MAPPING {
	enum DDP_IRQ_BIT irq_bit;
};

struct ddp_path_handle {
	struct cmdqRecStruct *cmdqhandle;
	unsigned int hwmutexid;
	/* no need power_state now*/
	/* int power_state; */
	enum DDP_MODE mode;
	struct mutex mutex_lock;
	struct DDP_IRQ_EVENT_MAPPING irq_event_map[DISP_PATH_EVENT_NUM];
	struct DPMGR_WQ_HANDLE wq_list[DISP_PATH_EVENT_NUM];
	enum DDP_SCENARIO_ENUM scenario;
	enum DISP_MODULE_ENUM mem_module;
	struct disp_ddp_path_config last_config;
};

struct DDP_MANAGER_CONTEXT {
	int handle_cnt;
	int mutex_idx;
	int power_state;
	struct mutex mutex_lock;
	int module_usage_table[DISP_MODULE_NUM];
	struct ddp_path_handle *module_path_table[DISP_MODULE_NUM];
	struct ddp_path_handle *handle_pool[DDP_MAX_MANAGER_HANDLE];
};

#define DEFAULT_IRQ_EVENT_SCENARIO (4)
static struct DDP_IRQ_EVENT_MAPPING
ddp_irq_event_list[DEFAULT_IRQ_EVENT_SCENARIO][DISP_PATH_EVENT_NUM] = {
	{ /* ovl0 path */
		{DDP_IRQ_RDMA0_DONE},		/*FRAME_DONE */
		{DDP_IRQ_RDMA0_START},		/*FRAME_START */
		{DDP_IRQ_RDMA0_REG_UPDATE},	/*FRAME_REG_UPDATE */
		{DDP_IRQ_RDMA0_TARGET_LINE},	/*FRAME_TARGET_LINE */
		{DDP_IRQ_WDMA0_FRAME_COMPLETE},	/*FRAME_COMPLETE */
		{DDP_IRQ_RDMA0_TARGET_LINE},	/*FRAME_STOP */
		{DDP_IRQ_RDMA0_REG_UPDATE},	/*IF_CMD_DONE */
		{DDP_IRQ_DSI0_EXT_TE},		/*IF_VSYNC */
		{DDP_IRQ_UNKNOWN},		/*TRIGER*/
		{DDP_IRQ_AAL0_OUT_END_FRAME},	/*AAL_OUT_END_EVENT */
	},
	{ /* ovl1 path */
		{DDP_IRQ_RDMA1_DONE},		/*FRAME_DONE */
		{DDP_IRQ_RDMA1_START},		/*FRAME_START */
		{DDP_IRQ_RDMA1_REG_UPDATE},	/*FRAME_REG_UPDATE */
		{DDP_IRQ_RDMA1_TARGET_LINE},	/*FRAME_TARGET_LINE */
		{DDP_IRQ_WDMA0_FRAME_COMPLETE},	/*FRAME_COMPLETE */
		{DDP_IRQ_RDMA1_TARGET_LINE},	/*FRAME_STOP */
		{DDP_IRQ_RDMA1_REG_UPDATE},	/*IF_CMD_DONE */
		{DDP_IRQ_RDMA1_TARGET_LINE},	/*IF_VSYNC */
		{DDP_IRQ_UNKNOWN},		/*TRIGER*/
		{DDP_IRQ_AAL0_OUT_END_FRAME},	/*AAL_OUT_END_EVENT */
	},
	{ /* rdma path */
		{DDP_IRQ_RDMA1_DONE},		/*FRAME_DONE */
		{DDP_IRQ_RDMA1_START},		/*FRAME_START */
		{DDP_IRQ_RDMA1_REG_UPDATE},	/*FRAME_REG_UPDATE */
		{DDP_IRQ_RDMA1_TARGET_LINE},	/*FRAME_TARGET_LINE */
		{DDP_IRQ_UNKNOWN},		/*FRAME_COMPLETE */
		{DDP_IRQ_RDMA1_TARGET_LINE},	/*FRAME_STOP */
		{DDP_IRQ_RDMA1_REG_UPDATE},	/*IF_CMD_DONE */
		{DDP_IRQ_RDMA1_TARGET_LINE},	/*IF_VSYNC */
		{DDP_IRQ_UNKNOWN},		/*TRIGER*/
		{DDP_IRQ_UNKNOWN},		/*AAL_OUT_END_EVENT */
		},
	{ /* ovl0 path */
		{DDP_IRQ_RDMA0_DONE},		/*FRAME_DONE */
		{DDP_IRQ_MUTEX1_SOF},		/*FRAME_START */
		{DDP_IRQ_RDMA0_REG_UPDATE},	/*FRAME_REG_UPDATE */
		{DDP_IRQ_RDMA0_TARGET_LINE},	/*FRAME_TARGET_LINE */
		{DDP_IRQ_WDMA0_FRAME_COMPLETE},	/*FRAME_COMPLETE */
		{DDP_IRQ_RDMA0_TARGET_LINE},	/*FRAME_STOP */
		{DDP_IRQ_RDMA0_REG_UPDATE},	/*IF_CMD_DONE */
		{DDP_IRQ_DSI0_EXT_TE},		/*IF_VSYNC */
		{DDP_IRQ_UNKNOWN},		/*TRIGER*/
		{DDP_IRQ_AAL0_OUT_END_FRAME},	/*AAL_OUT_END_EVENT */
	}
};

static char *path_event_name(enum DISP_PATH_EVENT event)
{
	switch (event) {
	case DISP_PATH_EVENT_FRAME_START:
		return "FRAME_START";
	case DISP_PATH_EVENT_FRAME_DONE:
		return "FRAME_DONE";
	case DISP_PATH_EVENT_FRAME_REG_UPDATE:
		return "REG_UPDATE";
	case DISP_PATH_EVENT_FRAME_TARGET_LINE:
		return "TARGET_LINE";
	case DISP_PATH_EVENT_FRAME_COMPLETE:
		return "FRAME COMPLETE";
	case DISP_PATH_EVENT_FRAME_STOP:
		return "FRAME_STOP";
	case DISP_PATH_EVENT_IF_CMD_DONE:
		return "FRAME_STOP";
	case DISP_PATH_EVENT_IF_VSYNC:
		return "VSYNC";
	case DISP_PATH_EVENT_TRIGGER:
		return "TRIGGER";
	case DISP_PATH_EVENT_DELAYED_TRIGGER_33ms:
		return "DELAY_TRIG";
	default:
		return "unknown event";
	}
	return "unknown event";
}

static struct DDP_MANAGER_CONTEXT *_get_context(void)
{
	static int is_context_inited;
	static struct DDP_MANAGER_CONTEXT context;

	if (!is_context_inited) {
		memset((void *)&context, 0, sizeof(struct DDP_MANAGER_CONTEXT));
		context.mutex_idx = (1 << DISP_MUTEX_DDP_COUNT) - 1;
		mutex_init(&context.mutex_lock);
		is_context_inited = 1;
	}
	return &context;
}

void dpmgr_set_power_state(unsigned int state)
{
	ASSERT(_get_context()->power_state != state);
	_get_context()->power_state = state;
}

unsigned int dpmgr_get_power_state(void)
{
	return _get_context()->power_state;
}

static struct ddp_path_handle
*find_handle_by_module(enum DISP_MODULE_ENUM module)
{
	if ((module == DISP_MODULE_DSI0) &&
	    (!_get_context()->module_path_table[DISP_MODULE_DSI0]))
		return _get_context()->module_path_table[DISP_MODULE_DSIDUAL];

	return _get_context()->module_path_table[module];
}

int dpmgr_module_notify(enum DISP_MODULE_ENUM module,
			enum DISP_PATH_EVENT event)
{
	int ret = 0;

	struct ddp_path_handle *handle = find_handle_by_module(module);

	if (handle)
		ret = dpmgr_signal_event(handle, event);

	mmprofile_log_ex(ddp_mmp_get_events()->primary_display_aalod_trigger,
			 MMPROFILE_FLAG_PULSE, module, event);
	return ret;
}

static int assign_default_irqs_table(enum DDP_SCENARIO_ENUM scenario,
				     struct DDP_IRQ_EVENT_MAPPING *irq_events)
{
	int idx = 0;

	switch (scenario) {
	case DDP_SCENARIO_PRIMARY_DISP:
	case DDP_SCENARIO_PRIMARY_RDMA0_COLOR0_DISP:
	case DDP_SCENARIO_PRIMARY_RDMA0_DISP:
	case DDP_SCENARIO_PRIMARY_ALL:
		idx = 0;
		break;
	case DDP_SCENARIO_SUB_DISP:
	case DDP_SCENARIO_SUB_RDMA1_DISP:
	case DDP_SCENARIO_SUB_OVL_MEMOUT:
	case DDP_SCENARIO_SUB_ALL:
		idx = 1;
		break;
	case DDP_SCENARIO_PRIMARY_OVL_MEMOUT:
		idx = 3;
		break;
	default:
		DISP_LOG_E("unknown scenario %d\n", scenario);
	}
	memcpy(irq_events, ddp_irq_event_list[idx],
	       sizeof(ddp_irq_event_list[idx]));
	return 0;
}

#if 0 /* defined but not used */
static int acquire_free_bit(unsigned int total)
{
	int free_id = 0;

	while (total) {
		if (total & 0x1)
			return free_id;

		total >>= 1;
		++free_id;
	}
	return -1;
}
#endif

static int acquire_mutex(enum DDP_SCENARIO_ENUM scenario)
{
	/* primay use mutex 0 */
	int mutex_id = 0;
	int mutex_idx_free = 0;
	struct DDP_MANAGER_CONTEXT *c = _get_context();

	ASSERT(scenario >= 0 && scenario < DDP_SCENARIO_MAX);

	mutex_idx_free = c->mutex_idx;
	while (mutex_idx_free) {
		if (mutex_idx_free & 0x1) {
			c->mutex_idx &= (~(0x1 << mutex_id));
			mutex_id += DISP_MUTEX_DDP_FIRST;
			break;
		}
		mutex_idx_free >>= 1;
		++mutex_id;
	}
	ASSERT(mutex_id < (DISP_MUTEX_DDP_FIRST + DISP_MUTEX_DDP_COUNT));
	DDPDBG("scenario %s acquire mutex %d , left mutex 0x%x!\n",
	       ddp_get_scenario_name(scenario), mutex_id, c->mutex_idx);
	return mutex_id;
}

static int release_mutex(int mutex_idx)
{
	struct DDP_MANAGER_CONTEXT *c = _get_context();

	ASSERT(mutex_idx < (DISP_MUTEX_DDP_FIRST + DISP_MUTEX_DDP_COUNT));
	c->mutex_idx |= 1 << (mutex_idx - DISP_MUTEX_DDP_FIRST);
	DDPDBG("release mutex %d , left mutex 0x%x!\n",
		mutex_idx, c->mutex_idx);
	return 0;
}

int dpmgr_path_set_video_mode(disp_path_handle dp_handle, int is_vdo_mode)
{
	struct ddp_path_handle *phandle = NULL;

	ASSERT(dp_handle);
	if (!dp_handle)
		return 0;

	phandle = (struct ddp_path_handle *)dp_handle;
	phandle->mode = is_vdo_mode ? DDP_VIDEO_MODE : DDP_CMD_MODE;
	DDPDBG("set scenario %s mode: %s\n",
	       ddp_get_scenario_name(phandle->scenario),
	       is_vdo_mode ? "Video_Mode" : "Cmd_Mode");
	return 0;
}

disp_path_handle dpmgr_create_path(enum DDP_SCENARIO_ENUM scenario,
				   struct cmdqRecStruct *cmdq_handle)
{
	int i = 0;
	unsigned int m;
	struct ddp_path_handle *path_handle = NULL;
	int *list = ddp_get_scenario_list(scenario);
	int m_num = ddp_get_module_num(scenario);
	struct DDP_MANAGER_CONTEXT *c = _get_context();

	path_handle = kzalloc(sizeof(*path_handle), GFP_KERNEL);
	if (!path_handle) {
		DISP_LOG_E("Fail to create handle on scenario %s\n",
			   ddp_get_scenario_name(scenario));
		return path_handle;
	}

	path_handle->cmdqhandle = cmdq_handle;
	path_handle->scenario = scenario;
	path_handle->hwmutexid = acquire_mutex(scenario);
	path_handle->last_config.path_handle = path_handle;
	assign_default_irqs_table(scenario, path_handle->irq_event_map);

	DDPDBG("create handle %p on scenario %s\n",
	       path_handle, ddp_get_scenario_name(scenario));
	DDPDBG(" scenario %s include module: ",
	       ddp_get_scenario_name(scenario));
	for (i = 0; i < m_num; i++) {
		m = list[i];
		DDPDBG("%s\n", ddp_get_module_name(m));
		c->module_usage_table[m]++;
		c->module_path_table[m] = path_handle;
	}
	c->handle_cnt++;
	c->handle_pool[path_handle->hwmutexid] = path_handle;

	return path_handle;
}

int dpmgr_get_scenario(disp_path_handle dp_handle)
{
	struct ddp_path_handle *phandle = (struct ddp_path_handle *)dp_handle;
	if (!dp_handle)
		return 0;

	return phandle->scenario;
}

static int _dpmgr_path_connect(enum DDP_SCENARIO_ENUM scenario, void *qhandle)
{
	int i = 0, m;
	int *list = ddp_get_scenario_list(scenario);
	int m_num = ddp_get_module_num(scenario);
	struct DDP_MODULE_DRIVER *m_drv = NULL;

	ddp_connect_path(scenario, qhandle);

	for (i = 0; i < m_num; i++) {
		int prev = i == 0 ? DISP_MODULE_UNKNOWN : list[i - 1];
		int next = i == m_num - 1 ?  DISP_MODULE_UNKNOWN : list[i + 1];

		m = list[i];
		m_drv = ddp_get_module_driver(m);
		if (!(m_drv && m_drv->connect))
			continue;

		m_drv->connect(m, prev, next, 1, qhandle);
	}

	return 0;
}

static int _dpmgr_path_disconnect(enum DDP_SCENARIO_ENUM scenario,
				  void *qhandle)
{
	int i = 0, m;
	int *list = ddp_get_scenario_list(scenario);
	int m_num = ddp_get_module_num(scenario);
	struct DDP_MODULE_DRIVER *m_drv = NULL;

	ddp_disconnect_path(scenario, qhandle);

	for (i = 0; i < m_num; i++) {
		int prev = i == 0 ?  DISP_MODULE_UNKNOWN : list[i - 1];
		int next = i == m_num - 1 ?  DISP_MODULE_UNKNOWN : list[i + 1];

		m = list[i];
		m_drv = ddp_get_module_driver(m);
		if (!(m_drv && m_drv->connect))
			continue;

		m_drv->connect(m, prev, next, 1, qhandle);
	}

	return 0;
}

/**
 * NOTES: modify path should call API like this :
 *   old_scenario = dpmgr_get_scenario(handle);
 *   dpmgr_modify_path_power_on_new_modules();
 *   dpmgr_modify_path();
 *
 * after cmdq handle exec done:
 *   dpmgr_modify_path_power_off_old_modules();
 */
int dpmgr_modify_path(disp_path_handle dp_handle,
		      enum DDP_SCENARIO_ENUM new_scn,
		      struct cmdqRecStruct *cmdq_handle,
		      enum DDP_MODE mode, int sw_only)
{
	struct ddp_path_handle *phandle;
	enum DDP_SCENARIO_ENUM old_scn;

	ASSERT(dp_handle);
	if (!dp_handle)
		return 0;
	phandle = (struct ddp_path_handle *)dp_handle;
	old_scn = phandle->scenario;
	phandle->cmdqhandle = cmdq_handle;
	phandle->scenario = new_scn;
	DISP_LOG_I("modify handle %p from %s to %s\n",
		   phandle, ddp_get_scenario_name(old_scn),
		   ddp_get_scenario_name(new_scn));

	if (sw_only)
		return 0;

	/* mutex_set will clear old settings */
	ddp_mutex_set(phandle->hwmutexid, new_scn, mode, cmdq_handle);
	ddp_mutex_interrupt_enable(phandle->hwmutexid, cmdq_handle);
	/* disconnect old path first */
	_dpmgr_path_disconnect(old_scn, cmdq_handle);
	/* connect new path */
	_dpmgr_path_connect(new_scn, cmdq_handle);

	return 0;
}

int dpmgr_destroy_path_handle(disp_path_handle dp_handle)
{
	int i = 0;
	unsigned int m;
	struct ddp_path_handle *phandle;
	int *list;
	int m_num;
	struct DDP_MANAGER_CONTEXT *c;

	ASSERT(dp_handle);
	if (!dp_handle)
		return 0;
	phandle = (struct ddp_path_handle *)dp_handle;
	if (!phandle) {
		DDPERR("%s: error: path handle is NULL\n", __func__);
		return -EINVAL;
	}

	list = ddp_get_scenario_list(phandle->scenario);
	m_num = ddp_get_module_num(phandle->scenario);
	c = _get_context();

	DDPDBG("destroy path handle %p on scenario %s\n", phandle,
	       ddp_get_scenario_name(phandle->scenario));

	release_mutex(phandle->hwmutexid);
	for (i = 0; i < m_num; i++) {
		m = list[i];
		c->module_usage_table[m]--;
		c->module_path_table[m] = NULL;
	}
	c->handle_cnt--;
	ASSERT(c->handle_cnt >= 0);
	c->handle_pool[phandle->hwmutexid] = NULL;
	kfree(phandle);

	return 0;
}

int dpmgr_destroy_path(disp_path_handle dp_handle,
		       struct cmdqRecStruct *cmdq_handle)
{
	struct ddp_path_handle *phandle = (struct ddp_path_handle *)dp_handle;

	if (phandle)
		_dpmgr_path_disconnect(phandle->scenario, cmdq_handle);

	dpmgr_destroy_path_handle(dp_handle);
	return 0;
}

int dpmgr_path_memout_clock(disp_path_handle dp_handle, int clock_switch)
{
	return 0;
}

int dpmgr_path_add_memout(disp_path_handle dp_handle,
			  enum DISP_MODULE_ENUM engine, void *cmdq_handle)
{
	struct ddp_path_handle *phandle;
	enum DISP_MODULE_ENUM wdma;
	struct DDP_MANAGER_CONTEXT *c;
	struct DDP_MODULE_DRIVER *m_drv = NULL;

	ASSERT(dp_handle);
	if (!dp_handle)
		return 0;

	phandle = (struct ddp_path_handle *)dp_handle;
	ASSERT(phandle->scenario == DDP_SCENARIO_PRIMARY_DISP ||
		phandle->scenario == DDP_SCENARIO_SUB_DISP ||
		phandle->scenario == DDP_SCENARIO_PRIMARY_OVL_MEMOUT);

	wdma = DISP_MODULE_WDMA0;

	if (ddp_is_module_in_scenario(phandle->scenario, wdma) == 1) {
		DDPERR("%s: error, wdma is already in scenario=%s\n",
		       __func__, ddp_get_scenario_name(phandle->scenario));
		return -1;
	}
	/* update context */
	c = _get_context();
	c->module_usage_table[wdma]++;
	c->module_path_table[wdma] = phandle;
	if (engine == DISP_MODULE_OVL0) {
		phandle->scenario = DDP_SCENARIO_PRIMARY_ALL;
	} else {
		DISPERR("%s error: engine=%d\n", __func__, engine);
		ASSERT(0);
		return 0;
	}
	/* update connection */
	_dpmgr_path_connect(phandle->scenario, cmdq_handle);
	ddp_mutex_set(phandle->hwmutexid, phandle->scenario, phandle->mode,
		      cmdq_handle);

	/* wdma just needs to start */
	m_drv = ddp_get_module_driver(wdma);
	if (m_drv) {
		if (m_drv->init)
			m_drv->init(wdma, cmdq_handle);

		if (m_drv->start)
			m_drv->start(wdma, cmdq_handle);
	}
	return 0;
}

int dpmgr_path_remove_memout(disp_path_handle dp_handle, void *cmdq_handle)
{
	enum DDP_SCENARIO_ENUM old_scn;
	enum DDP_SCENARIO_ENUM new_scn;
	struct ddp_path_handle *phandle;
	enum DISP_MODULE_ENUM wdma;
	struct DDP_MANAGER_CONTEXT *c;
	struct DDP_MODULE_DRIVER *m_drv = NULL;

	ASSERT(dp_handle);
	if (!dp_handle)
		return 0;

	phandle = (struct ddp_path_handle *)dp_handle;
	ASSERT(phandle->scenario == DDP_SCENARIO_PRIMARY_DISP ||
		phandle->scenario == DDP_SCENARIO_PRIMARY_ALL ||
		phandle->scenario == DDP_SCENARIO_SUB_DISP ||
		phandle->scenario == DDP_SCENARIO_SUB_ALL);

	wdma = DISP_MODULE_WDMA0;

	if (ddp_is_module_in_scenario(phandle->scenario, wdma) == 0) {
		DDPERR("%s: error: wdma is not in scenario=%s\n", __func__,
		       ddp_get_scenario_name(phandle->scenario));
		return -1;
	}
	/* update context */
	c = _get_context();
	c->module_usage_table[wdma]--;
	c->module_path_table[wdma] = 0;
	/* wdma just need stop */
	m_drv = ddp_get_module_driver(wdma);
	if (m_drv) {
		if (m_drv->stop)
			m_drv->stop(wdma, cmdq_handle);

		if (m_drv->deinit)
			m_drv->deinit(wdma, cmdq_handle);
	}
	if (phandle->scenario == DDP_SCENARIO_PRIMARY_ALL) {
		old_scn = DDP_SCENARIO_PRIMARY_OVL_MEMOUT;
		new_scn = DDP_SCENARIO_PRIMARY_DISP;
	} else if (phandle->scenario == DDP_SCENARIO_SUB_ALL) {
		old_scn = DDP_SCENARIO_SUB_OVL_MEMOUT;
		new_scn = DDP_SCENARIO_SUB_DISP;
	} else {
		DISPERR("%s: error scenario =%s\n",
			__func__, ddp_get_scenario_name(phandle->scenario));
		ASSERT(0);
		return 0;
	}
	_dpmgr_path_disconnect(old_scn, cmdq_handle);
	phandle->scenario = new_scn;
	/* update connected */
	_dpmgr_path_connect(phandle->scenario, cmdq_handle);
	ddp_mutex_set(phandle->hwmutexid, phandle->scenario,
		      phandle->mode, cmdq_handle);

	return 0;
}

int dpmgr_path_set_dst_module(disp_path_handle dp_handle,
			      enum DISP_MODULE_ENUM dst_module)
{
	struct ddp_path_handle *phandle;

	ASSERT(dp_handle);
	if (!dp_handle)
		return 0;
	phandle = (struct ddp_path_handle *)dp_handle;
	ASSERT((phandle->scenario >= 0 &&
		phandle->scenario < DDP_SCENARIO_MAX));
	DDPDBG("set dst module on scenario %s, module %s\n",
	       ddp_get_scenario_name(phandle->scenario),
	       ddp_get_module_name(dst_module));
	return ddp_set_dst_module(phandle->scenario, dst_module);
}

int dpmgr_path_get_mutex(disp_path_handle dp_handle)
{
	struct ddp_path_handle *phandle = NULL;

	ASSERT(dp_handle);
	if (!dp_handle)
		return 0;
	phandle = (struct ddp_path_handle *)dp_handle;
	return phandle->hwmutexid;
}

enum DISP_MODULE_ENUM dpmgr_path_get_dst_module(disp_path_handle dp_handle)
{
	struct ddp_path_handle *phandle;
	enum DISP_MODULE_ENUM dst_module;

	ASSERT(dp_handle);
	if (!dp_handle)
		return 0;
	phandle = (struct ddp_path_handle *)dp_handle;
	ASSERT((phandle->scenario >= 0 &&
		phandle->scenario < DDP_SCENARIO_MAX));
	dst_module = ddp_get_dst_module(phandle->scenario);

	DISP_LOG_V("get dst module on scenario %s, module %s\n",
		   ddp_get_scenario_name(phandle->scenario),
		   ddp_get_module_name(dst_module));
	return dst_module;
}

enum dst_module_type dpmgr_path_get_dst_module_type(disp_path_handle dp_handle)
{
	enum DISP_MODULE_ENUM dst_module = dpmgr_path_get_dst_module(dp_handle);

	if (dst_module == DISP_MODULE_WDMA0)
		return DST_MOD_WDMA;

	return DST_MOD_REAL_TIME;
}

int dpmgr_path_connect(disp_path_handle dp_handle, int encmdq)
{
	struct ddp_path_handle *phandle;
	struct cmdqRecStruct *cmdqHandle;

	ASSERT(dp_handle);
	if (!dp_handle)
		return 0;
	phandle = (struct ddp_path_handle *)dp_handle;
	cmdqHandle = encmdq ? phandle->cmdqhandle : NULL;

	_dpmgr_path_connect(phandle->scenario, cmdqHandle);

	ddp_mutex_set(phandle->hwmutexid, phandle->scenario, phandle->mode,
		      cmdqHandle);
	ddp_mutex_interrupt_enable(phandle->hwmutexid, cmdqHandle);
	return 0;
}

int dpmgr_path_disconnect(disp_path_handle dp_handle, int encmdq)
{
	struct ddp_path_handle *phandle;
	struct cmdqRecStruct *cmdqHandle;

	ASSERT(dp_handle);
	if (!dp_handle)
		return 0;
	phandle = (struct ddp_path_handle *)dp_handle;
	cmdqHandle = encmdq ? phandle->cmdqhandle : NULL;

	DDPDBG("%s on scenario %s\n",
	       __func__, ddp_get_scenario_name(phandle->scenario));
	ddp_mutex_clear(phandle->hwmutexid, cmdqHandle);
	ddp_mutex_interrupt_disable(phandle->hwmutexid, cmdqHandle);
	_dpmgr_path_disconnect(phandle->scenario, cmdqHandle);
	return 0;
}

int dpmgr_path_init(disp_path_handle dp_handle, int encmdq)
{
	int i = 0;
	int m, m_num;
	struct ddp_path_handle *phandle;
	int *list;
	struct cmdqRecStruct *cmdqHandle;
	struct DDP_MODULE_DRIVER *m_drv = NULL;

	ASSERT(dp_handle);
	if (!dp_handle)
		return 0;

	phandle = (struct ddp_path_handle *)dp_handle;
	list = ddp_get_scenario_list(phandle->scenario);
	m_num = ddp_get_module_num(phandle->scenario);
	cmdqHandle = encmdq ? phandle->cmdqhandle : NULL;

	DDPDBG("path init on scenario %s\n",
	       ddp_get_scenario_name(phandle->scenario));
	/* open top clock */
	/* path_top_clock_on(); */
	/* seting mutex */
	ddp_mutex_set(phandle->hwmutexid, phandle->scenario, phandle->mode,
		      cmdqHandle);
	ddp_mutex_interrupt_enable(phandle->hwmutexid, cmdqHandle);
	/* connect path; */
	_dpmgr_path_connect(phandle->scenario, cmdqHandle);

	/* each module init */
	for (i = 0; i < m_num; i++) {
		m = list[i];
		m_drv = ddp_get_module_driver(m);
		if (!m_drv)
			continue;

		if (m_drv->init)
			m_drv->init(m, cmdqHandle);

		if (m_drv->set_listener != 0)
			m_drv->set_listener(m, dpmgr_module_notify);
	}
	/* after init this path will power on; */
	/* phandle->power_state = 1; */
	return 0;
}

int dpmgr_path_deinit(disp_path_handle dp_handle, int encmdq)
{
	int i = 0;
	int m, m_num;
	int *list;
	struct cmdqRecStruct *cmdqHandle;
	struct ddp_path_handle *phandle;
	struct DDP_MODULE_DRIVER *m_drv = NULL;

	ASSERT(dp_handle);
	if (!dp_handle)
		return 0;
	phandle = (struct ddp_path_handle *)dp_handle;
	list = ddp_get_scenario_list(phandle->scenario);
	m_num = ddp_get_module_num(phandle->scenario);
	cmdqHandle = encmdq ? phandle->cmdqhandle : NULL;

	DDPDBG("path deinit on scenario %s\n",
	       ddp_get_scenario_name(phandle->scenario));

	ddp_mutex_interrupt_disable(phandle->hwmutexid, cmdqHandle);
	ddp_mutex_clear(phandle->hwmutexid, cmdqHandle);
	_dpmgr_path_disconnect(phandle->scenario, cmdqHandle);
	for (i = 0; i < m_num; i++) {
		m = list[i];
		m_drv = ddp_get_module_driver(m);
		if (m_drv) {
			if (m_drv->deinit)
				m_drv->deinit(m, cmdqHandle);

			if (m_drv->set_listener)
				m_drv->set_listener(m, NULL);
		}
	}
	/* phandle->power_state = 0; */
	/* close top clock when last path init */
	/* path_top_clock_off(); */
	return 0;
}

int dpmgr_path_start(disp_path_handle dp_handle, int encmdq)
{
	int i = 0;
	int m, m_num;
	struct ddp_path_handle *phandle;
	int *list;
	struct DDP_MODULE_DRIVER *m_drv = NULL;
	struct cmdqRecStruct *cmdqHandle;

	ASSERT(dp_handle);
	if (!dp_handle)
		return 0;
	phandle = (struct ddp_path_handle *)dp_handle;
	list = ddp_get_scenario_list(phandle->scenario);
	m_num = ddp_get_module_num(phandle->scenario);
	cmdqHandle = encmdq ? phandle->cmdqhandle : NULL;

	DISP_LOG_I("path start on scenario %s\n",
		   ddp_get_scenario_name(phandle->scenario));

	for (i = 0; i < m_num; i++) {
		m = list[i];
		m_drv = ddp_get_module_driver(m);
		if (m_drv && m_drv->start)
			m_drv->start(m, cmdqHandle);
	}

	return 0;
}

int dpmgr_path_stop(disp_path_handle dp_handle, int encmdq)
{
	int i = 0;
	int m, m_num;
	struct ddp_path_handle *phandle;
	int *list;
	struct cmdqRecStruct *cmdqHandle;
	struct DDP_MODULE_DRIVER *m_drv;

	ASSERT(dp_handle);
	if (!dp_handle)
		return 0;
	phandle = (struct ddp_path_handle *)dp_handle;
	list = ddp_get_scenario_list(phandle->scenario);
	m_num = ddp_get_module_num(phandle->scenario);
	cmdqHandle = encmdq ? phandle->cmdqhandle : NULL;

	DISP_LOG_I("path stop on scenario %s\n",
		   ddp_get_scenario_name(phandle->scenario));
	for (i = m_num - 1; i >= 0; i--) {
		m = list[i];
		m_drv = ddp_get_module_driver(m);
		if (m_drv && m_drv->stop)
			m_drv->stop(m, cmdqHandle);
	}
	return 0;
}

int dpmgr_path_ioctl(disp_path_handle dp_handle, void *cmdq_handle,
		     enum DDP_IOCTL_NAME ioctl_cmd, void *params)
{
	int i = 0;
	int ret = 0;
	int m, m_num;
	int *list;
	struct ddp_path_handle *phandle;
	struct DDP_MODULE_DRIVER *m_drv;

	ASSERT(dp_handle);
	if (!dp_handle)
		return 0;
	phandle = (struct ddp_path_handle *)dp_handle;
	list = ddp_get_scenario_list(phandle->scenario);
	m_num = ddp_get_module_num(phandle->scenario);

	DDPDBG("path IOCTL(%s) on scenario %s\n",
	       ddp_get_ioctl_name(ioctl_cmd),
	       ddp_get_scenario_name(phandle->scenario));

	for (i = m_num - 1; i >= 0; i--) {
		m = list[i];
		m_drv = ddp_get_module_driver(m);
		if (m_drv && m_drv->ioctl)
			ret += m_drv->ioctl(m, cmdq_handle,
					    ioctl_cmd, params);
	}
	return ret;
}

int dpmgr_path_enable_irq(disp_path_handle dp_handle, void *cmdq_handle,
			  enum DDP_IRQ_LEVEL irq_level)
{
	int i = 0;
	int ret = 0;
	int m, m_num;
	struct ddp_path_handle *phandle;
	int *list;
	struct DDP_MODULE_DRIVER *m_drv;

	ASSERT(dp_handle);
	if (!dp_handle)
		return 0;
	phandle = (struct ddp_path_handle *)dp_handle;
	list = ddp_get_scenario_list(phandle->scenario);
	m_num = ddp_get_module_num(phandle->scenario);

	DDPDBG("path enable irq on scenario %s, level %d\n",
	       ddp_get_scenario_name(phandle->scenario), irq_level);

	if (irq_level != DDP_IRQ_LEVEL_ALL)
		ddp_mutex_interrupt_disable(phandle->hwmutexid, cmdq_handle);
	else
		ddp_mutex_interrupt_enable(phandle->hwmutexid, cmdq_handle);

	for (i = m_num - 1; i >= 0; i--) {
		m = list[i];
		m_drv = ddp_get_module_driver(m);
		if (m_drv && m_drv->enable_irq) {
			DDPDBG("scenario %s, module %s enable irq level %d\n",
			       ddp_get_scenario_name(phandle->scenario),
			       ddp_get_module_name(m), irq_level);
			ret += m_drv->enable_irq(m, cmdq_handle, irq_level);
		}
	}
	return ret;
}

int dpmgr_path_reset(disp_path_handle dp_handle, int encmdq)
{
	int i = 0;
	int ret = 0;
	int error = 0;
	int m, m_num;
	int *list;
	struct ddp_path_handle *phandle;
	struct cmdqRecStruct *cmdqHandle;
	struct DDP_MODULE_DRIVER *m_drv;

	ASSERT(dp_handle);
	if (!dp_handle)
		return 0;
	phandle = (struct ddp_path_handle *)dp_handle;
	list = ddp_get_scenario_list(phandle->scenario);
	m_num = ddp_get_module_num(phandle->scenario);
	cmdqHandle = encmdq ? phandle->cmdqhandle : NULL;

	DISP_LOG_I("path reset on scenario %s\n",
		   ddp_get_scenario_name(phandle->scenario));
	/* first reset mutex */
	ddp_mutex_reset(phandle->hwmutexid, cmdqHandle);

	for (i = 0; i < m_num; i++) {
		m = list[i];
		m_drv = ddp_get_module_driver(m);
		if (m_drv && m_drv->reset) {
			ret = m_drv->reset(m, cmdqHandle);
			if (ret)
				error++;
		}
	}
	return error > 0 ? -1 : 0;
}

static unsigned int dpmgr_is_PQ(enum DISP_MODULE_ENUM module)
{
	unsigned int isPQ = 0;

	switch (module) {
	case DISP_MODULE_COLOR0:
	case DISP_MODULE_CCORR0:
	case DISP_MODULE_AAL0:
	case DISP_MODULE_GAMMA0:
	case DISP_MODULE_DITHER0:
		isPQ = 1;
		break;
	default:
		isPQ = 0;
	}

	return isPQ;
}

int dpmgr_path_update_partial_roi(disp_path_handle dp_handle,
				  struct disp_rect partial, void *cmdq_handle)
{
	return dpmgr_path_ioctl(dp_handle, cmdq_handle, DDP_PARTIAL_UPDATE,
				&partial);
}

int dpmgr_path_config(disp_path_handle dp_handle,
		      struct disp_ddp_path_config *config, void *cmdq_handle)
{
	int i = 0;
	int m, m_num;
	struct ddp_path_handle *phandle;
	int *list;
	struct DDP_MODULE_DRIVER *m_drv;

	ASSERT(dp_handle);
	if (!dp_handle)
		return 0;
	phandle = (struct ddp_path_handle *)dp_handle;
	list = ddp_get_scenario_list(phandle->scenario);
	m_num = ddp_get_module_num(phandle->scenario);

	DDPDBG("path config ovl %d, rdma %d, wdma %d, dst %d on handle %p scenario %s\n",
		   config->ovl_dirty, config->rdma_dirty,
		   config->wdma_dirty, config->dst_dirty, phandle,
		   ddp_get_scenario_name(phandle->scenario));

	memcpy(&phandle->last_config, config, sizeof(*config));
	for (i = 0; i < m_num; i++) {
		m = list[i];
		m_drv = ddp_get_module_driver(m);
		if (!m_drv)
			continue;

		if (m_drv->config)
			m_drv->config(m, config, cmdq_handle);

		if (disp_helper_get_option(DISP_OPT_BYPASS_PQ) &&
		    dpmgr_is_PQ(m) == 1) {
			if (m_drv->bypass)
				m_drv->bypass(m, 1);
			pr_debug("bypss module is %s\n",
				 ddp_get_module_dtname(m));
		}
	}
	return 0;
}

struct disp_ddp_path_config
*dpmgr_path_get_last_config_notclear(disp_path_handle dp_handle)
{
	struct ddp_path_handle *phandle = (struct ddp_path_handle *)dp_handle;

	ASSERT(dp_handle);
	if (!dp_handle)
		return NULL;
	return &phandle->last_config;
}

struct disp_ddp_path_config
*dpmgr_path_get_last_config(disp_path_handle dp_handle)
{
	struct ddp_path_handle *phandle = (struct ddp_path_handle *)dp_handle;

	ASSERT(dp_handle);
	if (!dp_handle)
		return NULL;
	phandle->last_config.ovl_dirty = 0;
	phandle->last_config.rdma_dirty = 0;
	phandle->last_config.wdma_dirty = 0;
	phandle->last_config.dst_dirty = 0;
	phandle->last_config.ovl_layer_dirty = 0;
	phandle->last_config.ovl_layer_scanned = 0;
	phandle->last_config.ovl_partial_dirty = 0;
	return &phandle->last_config;
}

void dpmgr_get_input_address(disp_path_handle dp_handle, unsigned long *addr)
{
	struct ddp_path_handle *phandle = (struct ddp_path_handle *)dp_handle;
	int *list = ddp_get_scenario_list(phandle->scenario);

	if (list[0] == DISP_MODULE_OVL0 || list[0] == DISP_MODULE_OVL1_2L)
		ovl_get_address(list[0], addr);
	else if (list[0] == DISP_MODULE_RDMA0 || list[0] == DISP_MODULE_RDMA1)
		rdma_get_address(list[0], addr);
}

int dpmgr_path_build_cmdq(disp_path_handle dp_handle, void *trigger_loop_handle,
			  enum CMDQ_STATE state, int reverse)
{
	int ret = 0;
	int i = 0;
	int m, m_num;
	struct ddp_path_handle *phandle;
	int *list;
	struct DDP_MODULE_DRIVER *m_drv;

	ASSERT(dp_handle);
	if (!dp_handle)
		return 0;
	phandle = (struct ddp_path_handle *)dp_handle;
	list = ddp_get_scenario_list(phandle->scenario);
	m_num = ddp_get_module_num(phandle->scenario);

	if (reverse) {
		for (i = m_num - 1; i >= 0; i--) {
			m = list[i];
			m_drv = ddp_get_module_driver(m);
			if (!(m_drv && m_drv->build_cmdq))
				continue;

			ret = m_drv->build_cmdq(m, trigger_loop_handle, state);
		}
	} else {
		for (i = 0; i < m_num; i++) {
			m = list[i];
			m_drv = ddp_get_module_driver(m);
			if (!(m_drv && m_drv->build_cmdq))
				continue;

			ret = m_drv->build_cmdq(m, trigger_loop_handle, state);
		}
	}
	return ret;
}

int dpmgr_path_trigger(disp_path_handle dp_handle, void *trigger_loop_handle,
		       int encmdq)
{
	struct ddp_path_handle *phandle;
	int *list;
	int m_num, m;
	int i;
	struct DDP_MODULE_DRIVER *m_drv;

	ASSERT(dp_handle);
	if (!dp_handle)
		return 0;
	phandle = (struct ddp_path_handle *)dp_handle;
	DISP_LOG_I("%s on scenario %s\n",
		   __func__, ddp_get_scenario_name(phandle->scenario));
	list = ddp_get_scenario_list(phandle->scenario);
	m_num = ddp_get_module_num(phandle->scenario);

	ddp_mutex_enable(phandle->hwmutexid, phandle->scenario, phandle->mode,
			 trigger_loop_handle);
	for (i = 0; i < m_num; i++) {
		m = list[i];
		m_drv = ddp_get_module_driver(m);
		if (!(m_drv && m_drv->trigger))
			continue;

		m_drv->trigger(m, trigger_loop_handle);
	}
	return 0;
}

int dpmgr_path_flush(disp_path_handle dp_handle, int encmdq)
{
	struct ddp_path_handle *phandle;
	struct cmdqRecStruct *cmdqHandle;

	ASSERT(dp_handle);
	if (!dp_handle)
		return 0;
	phandle = (struct ddp_path_handle *)dp_handle;
	cmdqHandle = encmdq ? phandle->cmdqhandle : NULL;
	DDPDBG("path flush on scenario %s\n",
	       ddp_get_scenario_name(phandle->scenario));
	return ddp_mutex_enable(phandle->hwmutexid, phandle->scenario,
				phandle->mode, cmdqHandle);
}

int dpmgr_path_power_off(disp_path_handle dp_handle, enum CMDQ_SWITCH encmdq)
{
	int i = 0;
	int m, m_num;
	struct ddp_path_handle *phandle;
	int *list;
	struct DDP_MODULE_DRIVER *m_drv;

	ASSERT(dp_handle);
	if (!dp_handle)
		return 0;
	phandle = (struct ddp_path_handle *)dp_handle;
	list = ddp_get_scenario_list(phandle->scenario);
	m_num = ddp_get_module_num(phandle->scenario);

	DISP_LOG_I("path power off on scenario %s\n",
		   ddp_get_scenario_name(phandle->scenario));

	for (i = 0; i < m_num; i++) {
		m = list[i];
		m_drv = ddp_get_module_driver(m);
		if (!(m_drv && m_drv->power_off))
			continue;

		m_drv->power_off(m, encmdq ? phandle->cmdqhandle : NULL);
	}
	/* phandle->power_state = 0; */
	/* path_top_clock_off(); */
	return 0;
}

int dpmgr_path_power_on(disp_path_handle dp_handle, enum CMDQ_SWITCH encmdq)
{
	int i = 0;
	int m, m_num;
	int *list;
	struct ddp_path_handle *phandle;
	struct DDP_MODULE_DRIVER *m_drv;

	ASSERT(dp_handle);
	if (!dp_handle)
		return 0;
	phandle = (struct ddp_path_handle *)dp_handle;
	list = ddp_get_scenario_list(phandle->scenario);
	m_num = ddp_get_module_num(phandle->scenario);

	DISP_LOG_I("path power on scenario %s\n",
		   ddp_get_scenario_name(phandle->scenario));
	/* path_top_clock_on(); */
	for (i = 0; i < m_num; i++) {
		m = list[i];
		m_drv = ddp_get_module_driver(m);
		if (!(m_drv && m_drv->power_on))
			continue;

		m_drv->power_on(m, encmdq ? phandle->cmdqhandle : NULL);
	}
	/* modules on this path will resume power on; */
	/* phandle->power_state = 1; */
	return 0;
}

int dpmgr_path_power_off_bypass_pwm(disp_path_handle dp_handle,
				    enum CMDQ_SWITCH encmdq)
{
	int i = 0;
	int m, m_num;
	struct ddp_path_handle *phandle;
	int *list;
	struct DDP_MODULE_DRIVER *m_drv;

	ASSERT(dp_handle);
	if (!dp_handle)
		return 0;
	phandle = (struct ddp_path_handle *)dp_handle;
	list = ddp_get_scenario_list(phandle->scenario);
	m_num = ddp_get_module_num(phandle->scenario);

	DISP_LOG_I("path power off on scenario %s\n",
		   ddp_get_scenario_name(phandle->scenario));

	for (i = 0; i < m_num; i++) {
		m = list[i];
		m_drv = ddp_get_module_driver(m);
		if (!(m_drv && m_drv->power_off))
			continue;

		if (m == DISP_MODULE_PWM0) {
			DDPMSG(" %s power off -- bypass\n",
			       ddp_get_module_name(m));
			continue;
		}

		m_drv->power_off(m, encmdq ? phandle->cmdqhandle : NULL);
	}
	/* phandle->power_state = 0; */
	/* path_top_clock_off(); */
	return 0;
}

int dpmgr_path_power_on_bypass_pwm(disp_path_handle dp_handle,
				   enum CMDQ_SWITCH encmdq)
{
	int i = 0;
	int m, m_num;
	int *list;
	struct ddp_path_handle *phandle;
	struct DDP_MODULE_DRIVER *m_drv;

	ASSERT(dp_handle);
	if (!dp_handle)
		return 0;
	phandle = (struct ddp_path_handle *)dp_handle;
	list = ddp_get_scenario_list(phandle->scenario);
	m_num = ddp_get_module_num(phandle->scenario);

	DISP_LOG_I("path power on scenario %s\n",
		   ddp_get_scenario_name(phandle->scenario));
	/* path_top_clock_on(); */
	for (i = 0; i < m_num; i++) {
		m = list[i];
		m_drv = ddp_get_module_driver(m);
		if (!m_drv || !m_drv->power_on)
			continue;

		if (m == DISP_MODULE_PWM0) {
			DDPMSG(" %s power on -- bypass\n",
			       ddp_get_module_name(m));
			continue;
		}

		m_drv->power_on(m, encmdq ? phandle->cmdqhandle : NULL);
	}
	/* modules on this path will resume power on; */
	/* phandle->power_state = 1; */
	return 0;
}

static int is_module_in_path(enum DISP_MODULE_ENUM module,
			     struct ddp_path_handle *phandle)
{
	struct DDP_MANAGER_CONTEXT *c = _get_context();
	unsigned int idx = (unsigned int)module;

	ASSERT(module < DISP_MODULE_UNKNOWN);
	if (c->module_path_table[idx] == phandle)
		return 1;

	return 0;
}

int dpmgr_path_user_cmd(disp_path_handle dp_handle, unsigned int msg,
			unsigned long arg, void *cmdqhandle)
{
	int ret = -1;
	enum DISP_MODULE_ENUM dst = DISP_MODULE_UNKNOWN;
	struct ddp_path_handle *phandle = NULL;
	struct DDP_MODULE_DRIVER *m_drv = NULL;

	ASSERT(dp_handle);
	if (!dp_handle)
		return 0;
	phandle = (struct ddp_path_handle *)dp_handle;
	/* DISP_LOG_W("dpmgr_path_user_cmd msg 0x%08x\n",msg); */

	switch (msg) {
	case DISP_IOCTL_AAL_EVENTCTL:
	case DISP_IOCTL_AAL_GET_HIST:
	case DISP_IOCTL_AAL_INIT_REG:
	case DISP_IOCTL_AAL_SET_PARAM:
		/* TODO: just for verify rootcause, will be removed soon */
#ifndef CONFIG_FOR_SOURCE_PQ
		if (!is_module_in_path(DISP_MODULE_AAL0, phandle))
			break;

		m_drv = ddp_get_module_driver(DISP_MODULE_AAL0);
		if (!m_drv || !m_drv->cmd)
			break;

		ret = m_drv->cmd(DISP_MODULE_AAL0, msg, arg, cmdqhandle);
#endif
		break;
	case DISP_IOCTL_SET_GAMMALUT:
		m_drv = ddp_get_module_driver(DISP_MODULE_GAMMA0);
		if (!m_drv || !m_drv->cmd)
			break;

		ret = m_drv->cmd(DISP_MODULE_GAMMA0, msg, arg, cmdqhandle);
		break;
	case DISP_IOCTL_SET_CCORR:
	case DISP_IOCTL_CCORR_EVENTCTL:
	case DISP_IOCTL_CCORR_GET_IRQ:
	case DISP_IOCTL_SUPPORT_COLOR_TRANSFORM:
		m_drv = ddp_get_module_driver(DISP_MODULE_CCORR0);
		if (!m_drv || !m_drv->cmd)
			break;

		ret = m_drv->cmd(DISP_MODULE_CCORR0, msg, arg, cmdqhandle);
		break;
	case DISP_IOCTL_SET_PQPARAM:
	case DISP_IOCTL_GET_PQPARAM:
	case DISP_IOCTL_SET_PQINDEX:
	case DISP_IOCTL_GET_PQINDEX:
	case DISP_IOCTL_SET_COLOR_REG:
	case DISP_IOCTL_SET_TDSHPINDEX:
	case DISP_IOCTL_GET_TDSHPINDEX:
	case DISP_IOCTL_SET_PQ_CAM_PARAM:
	case DISP_IOCTL_GET_PQ_CAM_PARAM:
	case DISP_IOCTL_SET_PQ_GAL_PARAM:
	case DISP_IOCTL_GET_PQ_GAL_PARAM:
	case DISP_IOCTL_PQ_SET_BYPASS_COLOR:
	case DISP_IOCTL_PQ_SET_WINDOW:
	case DISP_IOCTL_WRITE_REG:
	case DISP_IOCTL_READ_REG:
	case DISP_IOCTL_MUTEX_CONTROL:
	case DISP_IOCTL_PQ_GET_TDSHP_FLAG:
	case DISP_IOCTL_PQ_SET_TDSHP_FLAG:
	case DISP_IOCTL_PQ_GET_DC_PARAM:
	case DISP_IOCTL_PQ_SET_DC_PARAM:
	case DISP_IOCTL_PQ_GET_DS_PARAM:
	case DISP_IOCTL_PQ_GET_MDP_COLOR_CAP:
	case DISP_IOCTL_PQ_GET_MDP_TDSHP_REG:
	case DISP_IOCTL_WRITE_SW_REG:
	case DISP_IOCTL_READ_SW_REG:
		if (is_module_in_path(DISP_MODULE_COLOR0, phandle))
			dst = DISP_MODULE_COLOR0;
		else
			DISP_LOG_W("%s color is not on this path\n", __func__);

		if (dst != DISP_MODULE_UNKNOWN) {
			m_drv = ddp_get_module_driver(dst);
			if (!m_drv || !m_drv->cmd)
				break;
			ret = m_drv->cmd(dst, msg, arg, cmdqhandle);
		}
		break;
	default:
		DISP_LOG_W("%s io not supported\n", __func__);
		break;
	}
	return ret;
}

int dpmgr_path_set_parameter(disp_path_handle dp_handle, int io_evnet,
			     void *data)
{
	return 0;
}

int dpmgr_path_get_parameter(disp_path_handle dp_handle, int io_evnet,
			     void *data)
{
	return 0;
}

int dpmgr_path_is_idle(disp_path_handle dp_handle)
{
	ASSERT(dp_handle);
	return !dpmgr_path_is_busy(dp_handle);
}

int dpmgr_path_is_busy(disp_path_handle dp_handle)
{
	int i = 0;
	int m, m_num;
	struct ddp_path_handle *phandle;
	int *list;
	struct DDP_MODULE_DRIVER *m_drv;

	ASSERT(dp_handle);
	if (!dp_handle)
		return 0;
	phandle = (struct ddp_path_handle *)dp_handle;
	list = ddp_get_scenario_list(phandle->scenario);
	m_num = ddp_get_module_num(phandle->scenario);

	DISP_LOG_V("path check busy on scenario %s\n",
		   ddp_get_scenario_name(phandle->scenario));
	for (i = m_num - 1; i >= 0; i--) {
		m = list[i];
		m_drv = ddp_get_module_driver(m);
		if (!m_drv || !m_drv->is_busy)
			continue;

		if (m_drv->is_busy(m)) {
			DISP_LOG_V("%s is busy\n", ddp_get_module_name(m));
			return 1;
		}
	}
	return 0;
}

int dpmgr_set_lcm_utils(disp_path_handle dp_handle, void *lcm_drv)
{
	int i = 0;
	int m, m_num;
	int *list;
	struct ddp_path_handle *phandle;
	struct DDP_MODULE_DRIVER *m_drv;

	ASSERT(dp_handle);
	if (!dp_handle)
		return 0;
	phandle = (struct ddp_path_handle *)dp_handle;
	list = ddp_get_scenario_list(phandle->scenario);
	m_num = ddp_get_module_num(phandle->scenario);

	DISP_LOG_V("path set lcm drv handle %p\n", phandle);
	for (i = 0; i < m_num; i++) {
		m = list[i];
		m_drv = ddp_get_module_driver(m);
		if (!m_drv || !m_drv->set_lcm_utils || !lcm_drv)
			continue;

		DDPDBG("%s set lcm utils\n", ddp_get_module_name(m));
		m_drv->set_lcm_utils(m, lcm_drv);
	}
	return 0;
}

int dpmgr_enable_event(disp_path_handle dp_handle, enum DISP_PATH_EVENT event)
{
	struct ddp_path_handle *phandle;
	struct DPMGR_WQ_HANDLE *wq_handle;
	unsigned int idx = (unsigned int)event;

	ASSERT(dp_handle);
	if (!dp_handle)
		return 0;
	phandle = (struct ddp_path_handle *)dp_handle;
	wq_handle = &phandle->wq_list[idx];

	DDPDBG("enable event %s on scenario %s, irtbit 0x%x\n",
	       path_event_name(event), ddp_get_scenario_name(phandle->scenario),
	       phandle->irq_event_map[idx].irq_bit);

	if (!wq_handle->init) {
		init_waitqueue_head(&(wq_handle->wq));
		wq_handle->init = 1;
		wq_handle->data = 0;
		wq_handle->event = event;
	}
	return 0;
}

int dpmgr_map_event_to_irq(disp_path_handle dp_handle,
			   enum DISP_PATH_EVENT event, enum DDP_IRQ_BIT irq_bit)
{
	struct ddp_path_handle *phandle;
	struct DDP_IRQ_EVENT_MAPPING *irq_table;

	ASSERT(dp_handle);
	if (!dp_handle)
		return 0;
	phandle = (struct ddp_path_handle *)dp_handle;
	irq_table = phandle->irq_event_map;

	if (event < DISP_PATH_EVENT_NUM) {
		DDPDBG("map event %s to irq 0x%x on scenario %s\n",
		       path_event_name(event), irq_bit,
		       ddp_get_scenario_name(phandle->scenario));
		irq_table[event].irq_bit = irq_bit;
		return 0;
	}
	DISP_LOG_E("fail to map event %s to irq 0x%x on scenario %s\n",
		   path_event_name(event), irq_bit,
		   ddp_get_scenario_name(phandle->scenario));
	return -1;
}

int dpmgr_disable_event(disp_path_handle dp_handle, enum DISP_PATH_EVENT event)
{
	struct ddp_path_handle *phandle;
	struct DPMGR_WQ_HANDLE *wq_handle;

	ASSERT(dp_handle);
	if (!dp_handle)
		return 0;
	phandle = (struct ddp_path_handle *)dp_handle;

	DDPDBG("disable event %s on scenario %s\n", path_event_name(event),
	       ddp_get_scenario_name(phandle->scenario));

	wq_handle = &phandle->wq_list[event];
	wq_handle->init = 0;
	wq_handle->data = 0;
	return 0;
}

int dpmgr_check_status_by_scenario(enum DDP_SCENARIO_ENUM scenario)
{
	int i = 0;
	int *list = ddp_get_scenario_list(scenario);
	int m_num = ddp_get_module_num(scenario);
	struct DDP_MANAGER_CONTEXT *c = _get_context();

	DDPDUMP("--> check status on scenario %s\n",
		ddp_get_scenario_name(scenario));

	if (!c->power_state) {
		DDPDUMP("cannot check ddp status due to already power off\n");
		return 0;
	}

	ddp_check_path(scenario);

	DDPDUMP("path:\n");
	for (i = 0; i < m_num; i++)
		DDPDUMP("%s-\n", ddp_get_module_name(list[i]));

	DDPDUMP("\n");

	for (i = 0; i < m_num; i++)
		ddp_dump_analysis(list[i]);

	for (i = 0; i < m_num; i++)
		ddp_dump_reg(list[i]);

	return 0;
}

int dpmgr_check_status(disp_path_handle dp_handle)
{
	int i = 0;
	int *list;
	int m_num;
	struct ddp_path_handle *phandle;
	struct DDP_MANAGER_CONTEXT *c = _get_context();

	ASSERT(dp_handle);
	if (!dp_handle)
		return 0;
	phandle = (struct ddp_path_handle *)dp_handle;
	list = ddp_get_scenario_list(phandle->scenario);
	m_num = ddp_get_module_num(phandle->scenario);

	DDPDUMP("--> check status on scenario %s\n",
		ddp_get_scenario_name(phandle->scenario));

	if (!c->power_state) {
		DDPDUMP("cannot check ddp status due to already power off\n");
		return 0;
	}

	ddp_dump_analysis(DISP_MODULE_CONFIG);
	ddp_check_path(phandle->scenario);
	ddp_check_mutex(phandle->hwmutexid, phandle->scenario, phandle->mode);

	DDPDUMP("path:\n");
	for (i = 0; i < m_num; i++)
		DDPDUMP("%s-\n", ddp_get_module_name(list[i]));

	DDPDUMP("\n");

	ddp_dump_analysis(DISP_MODULE_MUTEX);

	for (i = 0; i < m_num; i++)
		ddp_dump_analysis(list[i]);

	for (i = 0; i < m_num; i++)
		ddp_dump_reg(list[i]);

	ddp_dump_reg(DISP_MODULE_CONFIG);
	ddp_dump_reg(DISP_MODULE_MUTEX);

	return 0;
}

void dpmgr_debug_path_status(int mutex_id)
{
	int i = 0;
	struct DDP_MANAGER_CONTEXT *c = _get_context();
	disp_path_handle phandle = NULL;

	if (mutex_id >= DISP_MUTEX_DDP_FIRST &&
	    mutex_id < (DISP_MUTEX_DDP_FIRST + DISP_MUTEX_DDP_COUNT)) {
		phandle = (disp_path_handle)c->handle_pool[mutex_id];
		if (phandle)
			dpmgr_check_status(phandle);
	} else {
		for (i = DISP_MUTEX_DDP_FIRST;
		     i < (DISP_MUTEX_DDP_FIRST + DISP_MUTEX_DDP_COUNT); i++) {
			phandle = (disp_path_handle)c->handle_pool[i];
			if (phandle)
				dpmgr_check_status(phandle);
		}
	}
}

int dpmgr_wait_event_timeout(disp_path_handle dp_handle,
			     enum DISP_PATH_EVENT event, int timeout)
{
	int ret = -1;
	struct ddp_path_handle *phandle;
	struct DPMGR_WQ_HANDLE *wq_handle;
	unsigned long long cur_time;

	ASSERT(dp_handle);
	if (!dp_handle)
		return 0;
	phandle = (struct ddp_path_handle *)dp_handle;
	wq_handle = &phandle->wq_list[event];

	if (!wq_handle->init) {
		DISP_LOG_E("wait event %s not initialized on scenario %s\n",
			   path_event_name(event),
			   ddp_get_scenario_name(phandle->scenario));
		return ret;
	}

	cur_time = ktime_to_ns(ktime_get());

	ret = wait_event_interruptible_timeout(wq_handle->wq,
					cur_time < wq_handle->data, timeout);
	if (ret == 0) {
		DISP_LOG_E("wait %s timeout on scenario %s\n",
			   path_event_name(event),
			   ddp_get_scenario_name(phandle->scenario));
		/* dpmgr_check_status(dp_handle); */
	} else if (ret < 0) {
		DISP_LOG_E("wait %s interrupt by other timeleft %d on scenario %s\n",
			   path_event_name(event), ret,
			   ddp_get_scenario_name(phandle->scenario));
	} else {
		DISP_LOG_V("received event %s timeleft %d on scenario %s\n",
			   path_event_name(event), ret,
			   ddp_get_scenario_name(phandle->scenario));
	}
	return ret;
}

int _dpmgr_wait_event(disp_path_handle dp_handle, enum DISP_PATH_EVENT event,
		      unsigned long long *event_ts)
{
	int ret = -1;
	struct ddp_path_handle *phandle;
	struct DPMGR_WQ_HANDLE *wq_handle;
	unsigned long long cur_time;

	ASSERT(dp_handle);
	if (!dp_handle)
		return 0;
	phandle = (struct ddp_path_handle *)dp_handle;
	wq_handle = &phandle->wq_list[event];

	if (!wq_handle->init) {
		DISP_LOG_E("wait event %s not initialized on scenario %s\n",
			   path_event_name(event),
			   ddp_get_scenario_name(phandle->scenario));
		return -2;
	}

	cur_time = ktime_to_ns(ktime_get());

	ret = wait_event_interruptible(wq_handle->wq,
				       cur_time < wq_handle->data);
	if (ret < 0) {
		DISP_LOG_E("wait %s interrupt by other ret %d on scenario %s\n",
			   path_event_name(event), ret,
			   ddp_get_scenario_name(phandle->scenario));
	}
	if (event_ts)
		*event_ts = wq_handle->data;

	return ret;
}

int dpmgr_wait_event(disp_path_handle dp_handle, enum DISP_PATH_EVENT event)
{
	return _dpmgr_wait_event(dp_handle, event, NULL);
}

int dpmgr_wait_event_ts(disp_path_handle dp_handle, enum DISP_PATH_EVENT event,
			unsigned long long *event_ts)
{
	return _dpmgr_wait_event(dp_handle, event, event_ts);
}

int dpmgr_signal_event(disp_path_handle dp_handle, enum DISP_PATH_EVENT event)
{
	struct ddp_path_handle *phandle;
	struct DPMGR_WQ_HANDLE *wq_handle;
	unsigned int idx = (unsigned int)event;

	ASSERT(dp_handle);
	if (!dp_handle)
		return 0;
	phandle = (struct ddp_path_handle *)dp_handle;
	wq_handle = &phandle->wq_list[idx];

	if (phandle->wq_list[idx].init) {
		wq_handle->data = ktime_to_ns(ktime_get());
		wake_up_interruptible(&(phandle->wq_list[idx].wq));
	}
	return 0;
}

static void dpmgr_irq_handler(enum DISP_MODULE_ENUM module,
			      unsigned int regvalue)
{
	int i = 0, j = 0;
	int irq_bits_num = 0;
	int irq_bit = 0;
	struct ddp_path_handle *phandle = NULL;

	phandle = find_handle_by_module(module);
	if (!phandle)
		return;

	irq_bits_num = ddp_get_module_max_irq_bit(module);
	for (i = 0; i <= irq_bits_num; i++) {
		if (!(regvalue & (0x1 << i)))
			continue;

		irq_bit = MAKE_DDP_IRQ_BIT(module, i);
		dprec_stub_irq(irq_bit);
		for (j = 0; j < DISP_PATH_EVENT_NUM; j++) {
			if (!phandle->wq_list[j].init ||
			    irq_bit != phandle->irq_event_map[j].irq_bit)
				continue;

			dprec_stub_event(j);
			DDPIRQ("irq signal event %s on cycle %llu on scenario %s\n",
			       path_event_name(j), phandle->wq_list[j].data,
			       ddp_get_scenario_name(phandle->scenario));

			dpmgr_signal_event(phandle, j);
		}
	}
}

int dpmgr_init(void)
{
	DISP_LOG_I("ddp manager init\n");
	if (ddp_manager_init)
		return 0;

	ddp_manager_init = 1;
	ddp_debug_init();
	disp_init_irq();
	disp_register_irq_callback(dpmgr_irq_handler);
	return 0;
}

/**
 * dpmgr_factory_mode_test
 *  dpmgr_factory_mode_reset
 *  to be implemented in dsi driver
 *  these two functions are used for external display factory mode
 */
int dpmgr_factory_mode_test(int m, void *cmdqhandle, void *config)
{
	struct DDP_MODULE_DRIVER *m_drv = NULL;

	m_drv = ddp_get_module_driver(m);
	if (!m_drv || !m_drv->ioctl)
		return 0;

	DISP_LOG_I(" %s factory_mode_test\n",
		   ddp_get_module_name(DISP_MODULE_DSI1));

	/*m_drv->ioctl(m, cmdqhandle, DDP_DPI_FACTORY_TEST, config);*/
	return 0;
}

int dpmgr_factory_mode_reset(int m, void *cmdqhandle, void *config)
{
	struct DDP_MODULE_DRIVER *m_drv = NULL;

	m_drv = ddp_get_module_driver(m);
	if (!m_drv || !m_drv->ioctl)
		return 0;

	DISP_LOG_I(" %s factory_mode_test\n",
		   ddp_get_module_name(DISP_MODULE_DSI1));

	/* m_drv = ddp_get_module_driver(DISP_MODULE_DSI1)
	 * m_drv->ioctl(m, cmdqhandle, config);
	 */

	return 0;
}

int dpmgr_wait_ovl_available(int ovl_num)
{
	int ret = 1;

	return ret;
}

int switch_module_to_nonsec(disp_path_handle dp_handle, void *cmdqhandle,
			    const char *caller)
{

	int i = 0;
	int m, m_num;
	struct ddp_path_handle *phandle;
	int *list;
	struct DDP_MODULE_DRIVER *m_drv;

	ASSERT(dp_handle);
	if (!dp_handle)
		return 0;
	phandle = (struct ddp_path_handle *)dp_handle;
	list = ddp_get_scenario_list(phandle->scenario);
	m_num = ddp_get_module_num(phandle->scenario);
	DDPMSG("[SVP] switch module to nonsec on scenario %s, caller=%s\n",
	       ddp_get_scenario_name(phandle->scenario), caller);

	for (i = m_num - 1; i >= 0; i--) {
		m = list[i];
		m_drv = ddp_get_module_driver(m);
		if (!m_drv || !m_drv->switch_to_nonsec)
			continue;

		m_drv->switch_to_nonsec(m, cmdqhandle);
	}
	return 0;
}