static void _cmdq_set_config_handle_dirty(void)
{
if(!ext_disp_is_video_mode())
{
// only command mode need to set dirty
cmdqRecSetEventToken(pgc->cmdq_handle_config, CMDQ_SYNC_TOKEN_CONFIG_DIRTY);
///dprec_event_op(DPREC_EVENT_CMDQ_SET_DIRTY);
}
}
int32_t cmdqRecBackupUpdateSlot(cmdqRecHandle handle,
cmdqBackupSlotHandle hBackupSlot,
uint32_t slotIndex, uint32_t value)
{
#ifdef CMDQ_GPR_SUPPORT
const CMDQ_DATA_REGISTER_ENUM valueRegId = CMDQ_DATA_REG_DEBUG;
const CMDQ_DATA_REGISTER_ENUM destRegId = CMDQ_DATA_REG_DEBUG_DST;
const CMDQ_EVENT_ENUM regAccessToken = CMDQ_SYNC_TOKEN_GPR_SET_4;
const dma_addr_t dramAddr = hBackupSlot + slotIndex * sizeof(uint32_t);
/* lock GPR because we may access it in multiple CMDQ HW threads */
cmdqRecWait(handle, regAccessToken);
/* Assign 32-bit GRP with value */
cmdq_append_command(
handle,
CMDQ_CODE_RAW,
(CMDQ_CODE_MOVE << 24) | (valueRegId << 16) | (4 << 21), /* argA is GPR */
value);
/* Note that <MOVE> argB is 48-bit */
/* so writeAddress is split into 2 parts */
/* and we store address in 64-bit GPR (P0-P7) */
cmdq_append_command(handle, CMDQ_CODE_MOVE,
#ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
((dramAddr >> 32) & 0xffff) |
#endif
((destRegId & 0x1f) << 16) | (4 << 21), (uint32_t) dramAddr);
/* write value in GPR to memory pointed by GPR */
cmdq_append_command(
handle,
CMDQ_CODE_RAW,
(CMDQ_CODE_WRITE << 24) | (0 & 0xffff) | ((destRegId & 0x1f) << 16) | (6 << 21),
valueRegId);
/* release the GPR lock */
cmdqRecSetEventToken(handle, regAccessToken);
return 0;
#else
CMDQ_ERR("func:%s failed since CMDQ dosen't support GPR\n", __func__);
return -EFAULT;
#endif /* CMDQ_GPR_SUPPORT */
}
int ddp_insert_config_dirty_rec(void *handle)
{
int ret = 0;
if(handle == NULL)
{
ASSERT(0);
}
if(primary_display_is_video_mode())
// TODO: modify this
{
//do nothing
}
else
{
ret = cmdqRecSetEventToken(handle, CMDQ_SYNC_TOKEN_CONFIG_DIRTY);
}
return ret;
}
int32_t cmdqRecBackupWriteRegisterFromSlot(cmdqRecHandle handle,
cmdqBackupSlotHandle hBackupSlot,
uint32_t slotIndex, uint32_t addr)
{
#ifdef CMDQ_GPR_SUPPORT
const CMDQ_DATA_REGISTER_ENUM valueRegId = CMDQ_DATA_REG_DEBUG;
const CMDQ_DATA_REGISTER_ENUM addrRegId = CMDQ_DATA_REG_DEBUG_DST;
const CMDQ_EVENT_ENUM regAccessToken = CMDQ_SYNC_TOKEN_GPR_SET_4;
const dma_addr_t dramAddr = hBackupSlot + slotIndex * sizeof(uint32_t);
/* lock GPR because we may access it in multiple CMDQ HW threads */
cmdqRecWait(handle, regAccessToken);
/* 1. MOVE slot address to addr GPR */
/* Note that <MOVE> argB is 48-bit */
/* so writeAddress is split into 2 parts */
/* and we store address in 64-bit GPR (P0-P7) */
cmdq_append_command(handle, CMDQ_CODE_MOVE,
#ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
((dramAddr >> 32) & 0xffff) |
#endif
((addrRegId & 0x1f) << 16) | (4 << 21), (uint32_t) dramAddr); /* argA is GPR */
/* 2. read value from src address, which is stroed in GPR, to valueRegId */
cmdq_append_command(handle, CMDQ_CODE_RAW,
(CMDQ_CODE_READ << 24) | (0 & 0xffff) | ((addrRegId & 0x1f) << 16) | (6 << 21),
valueRegId);
/* 3. write from data register */
cmdqRecWriteFromDataRegister(handle, valueRegId, addr);
/* release the GPR lock */
cmdqRecSetEventToken(handle, regAccessToken);
return 0;
#else
CMDQ_ERR("func:%s failed since CMDQ dosen't support GPR\n", __func__);
return -EFAULT;
#endif /* CMDQ_GPR_SUPPORT */
}
static void _cmdq_build_trigger_loop(void)
{
int ret = 0;
cmdqRecCreate(CMDQ_SCENARIO_TRIGGER_LOOP, &(pgc->cmdq_handle_trigger));
EXT_DISP_LOG("ext_disp path trigger thread cmd handle=%p\n", pgc->cmdq_handle_trigger);
cmdqRecReset(pgc->cmdq_handle_trigger);
if(ext_disp_is_video_mode())
{
// wait and clear stream_done, HW will assert mutex enable automatically in frame done reset.
// todo: should let dpmanager to decide wait which mutex's eof.
ret = cmdqRecWait(pgc->cmdq_handle_trigger, dpmgr_path_get_mutex(pgc->dpmgr_handle) + CMDQ_EVENT_MUTEX0_STREAM_EOF); ///dpmgr_path_get_mutex(pgc->dpmgr_handle)
// for some module(like COLOR) to read hw register to GPR after frame done
dpmgr_path_build_cmdq(pgc->dpmgr_handle, pgc->cmdq_handle_trigger,CMDQ_AFTER_STREAM_EOF);
}
else
{
// DSI command mode doesn't have mutex_stream_eof, need use CMDQ token instead
ret = cmdqRecWait(pgc->cmdq_handle_trigger, CMDQ_SYNC_TOKEN_CONFIG_DIRTY);
//ret = cmdqRecWait(pgc->cmdq_handle_trigger, CMDQ_EVENT_MDP_DSI0_TE_SOF);
// for operations before frame transfer, such as waiting for DSI TE
dpmgr_path_build_cmdq(pgc->dpmgr_handle, pgc->cmdq_handle_trigger,CMDQ_BEFORE_STREAM_SOF);
// cleat frame done token, now the config thread will not allowed to config registers.
// remember that config thread's priority is higher than trigger thread, so all the config queued before will be applied then STREAM_EOF token be cleared
// this is what CMDQ did as "Merge"
ret = cmdqRecClearEventToken(pgc->cmdq_handle_trigger, CMDQ_SYNC_TOKEN_STREAM_EOF);
// enable mutex, only cmd mode need this
// this is what CMDQ did as "Trigger"
dpmgr_path_trigger(pgc->dpmgr_handle, pgc->cmdq_handle_trigger, CMDQ_ENABLE);
//ret = cmdqRecWrite(pgc->cmdq_handle_trigger, (unsigned int)(DISP_REG_CONFIG_MUTEX_EN(0))&0x1fffffff, 1, ~0);
// waiting for frame done, because we can't use mutex stream eof here, so need to let dpmanager help to decide which event to wait
// most time we wait rdmax frame done event.
ret = cmdqRecWait(pgc->cmdq_handle_trigger, CMDQ_EVENT_DISP_RDMA1_EOF);
dpmgr_path_build_cmdq(pgc->dpmgr_handle, pgc->cmdq_handle_trigger,CMDQ_WAIT_STREAM_EOF_EVENT);
// dsi is not idle rightly after rdma frame done, so we need to polling about 1us for dsi returns to idle
// do not polling dsi idle directly which will decrease CMDQ performance
dpmgr_path_build_cmdq(pgc->dpmgr_handle, pgc->cmdq_handle_trigger,CMDQ_CHECK_IDLE_AFTER_STREAM_EOF);
// for some module(like COLOR) to read hw register to GPR after frame done
dpmgr_path_build_cmdq(pgc->dpmgr_handle, pgc->cmdq_handle_trigger,CMDQ_AFTER_STREAM_EOF);
// polling DSI idle
//ret = cmdqRecPoll(pgc->cmdq_handle_trigger, 0x1401b00c, 0, 0x80000000);
// polling wdma frame done
//ret = cmdqRecPoll(pgc->cmdq_handle_trigger, 0x140060A0, 1, 0x1);
// now frame done, config thread is allowed to config register now
ret = cmdqRecSetEventToken(pgc->cmdq_handle_trigger, CMDQ_SYNC_TOKEN_STREAM_EOF);
// RUN forever!!!!
BUG_ON(ret < 0);
}
// dump trigger loop instructions to check whether dpmgr_path_build_cmdq works correctly
cmdqRecDumpCommand(pgc->cmdq_handle_trigger);
EXT_DISP_LOG("ext display BUILD cmdq trigger loop finished\n");
return;
}
