void _g2d_command_handler(g2d_command_t *cmd)
{
G2D_DBG("start to handle command (0x%04x)\n", cmd->ctx.flag);
switch (cmd->ctx.flag)
{
case G2D_FLAG_END_OF_FRAME:
g2d_drv_fb_queue_buffer(cmd->ctx.fb_id);
break;
case G2D_FLAG_FLUSH:
break;
case G2D_FLAG_MIRROR_FRONT_FB:
if (g2d_drv_fb_fill_mirror_cmd(&cmd->ctx) != 0) break;
default:
{
#ifdef G2D_PROFILE
struct timeval t1, t2;
do_gettimeofday(&t1);
#endif
g2d_drv_power_on();
g2d_drv_run(&cmd->ctx);
while (g2d_drv_get_status())
{
wait_event_interruptible_timeout(isr_wait_queue, !g2d_drv_get_status(), (30 * HZ / 1000));
if (g2d_drv_get_status()) G2D_ERR("TIMEOUT: G2D is still busy");
}
#ifdef G2D_PROFILE
do_gettimeofday(&t2);
G2D_INF("process time (%u)\n", (t2.tv_sec - t1.tv_sec) * 1000000 + (t2.tv_usec - t1.tv_usec));
#endif
#ifdef G2D_DEBUG
_g2d_reg_dump();
#endif
g2d_drv_reset();
g2d_drv_power_off();
}
break;
}
G2D_DBG("handle command (0x%04x) W2M(0x%08x) L0(0x%08x) L1(0x%08x) L2(0x%08x) L3(0x%08x) done\n", cmd->ctx.flag, ioread32(0xF20C5044), ioread32(0xF20C5084), ioread32(0xF20C50C4), ioread32(0xF20C5104), ioread32(0xF20C5144));
memset(&cmd->ctx, 0, sizeof(g2d_context_t));
#ifdef G2D_QUEUE
if (cmd->sync_cmd)
{
cmd->sync_cmd = false;
up(&cmd->sync);
}
up(&cmd->lock);
#endif
}
G2D_STATUS_ENUM g2dInit(void)
{
#if (defined(G2D_HW_SUPPORT) || defined(G2D_HW_SHARE_WITH_GOVL_SUPPORT))
#if defined(__MTK_TARGET__)
if (NULL == g2d_state_mutex)
{
g2d_state_mutex = kal_create_mutex("G2D State");
ASSERT(g2d_state_mutex != NULL);
g2d_mutex_init(&g2d_mutex);
}
#endif
/// we can't call mutex before task being initialized
/// kal_take_mutex(g2d_state_mutex);
/// kal_give_mutex(g2d_state_mutex);
#if defined(__MTK_TARGET__) || defined(G2D_FPGA)
g2d_drv_power_on();
g2d_drv_init();
g2d_drv_power_off();
#endif
#endif
#if defined(__MTK_TARGET__)
/* register bb reg dump */
g2d_dump.regions = (kal_uint32*)g2d_dump_regions;
g2d_dump.num = sizeof(g2d_dump_regions) / (sizeof(kal_uint32) * 3);
g2d_dump.bbreg_dump_callback = NULL;
EX_REGISTER_BBREG_DUMP(&g2d_dump);
#endif /* __MTK_TARGET__ */
return G2D_STATUS_OK;
}
void _g2d_command_handler(g2d_command_t *cmd)
{
G2D_DBG("start to handle command\n");
#ifdef G2D_QUEUE
if (cmd->ctx.end_of_frame)
{
g2d_drv_fb_queue_buffer(cmd->ctx.fb_id);
up(&cmd->lock);
return;
}
#endif
g2d_drv_power_on();
g2d_drv_run(&cmd->ctx);
wait_event_interruptible(isr_wait_queue, !g2d_drv_get_status());
#ifdef G2D_DEBUG
_g2d_reg_dump();
#endif
g2d_drv_power_off();
G2D_DBG("handle command done\n");
#ifdef G2D_QUEUE
up(&cmd->lock);
#endif
}
G2D_STATUS_ENUM g2dReleaseHandle(G2D_HANDLE_STRUCT *handle)
{
switch (handle->type)
{
case G2D_CODEC_TYPE_HW:
#if (defined(G2D_HW_SUPPORT) || defined(G2D_HW_SHARE_WITH_GOVL_SUPPORT))
{
#if defined(__DYNAMIC_SWITCH_CACHEABILITY__) && defined(__MTK_TARGET__)
{
kal_int32 colorSize, colorSizeMax;
G2D_CANVAS_INFO_STRUCT *dstCanvas = &(handle->dstCanvas);
if (GFX_CACHE_SWITCH_BEHAVIOR_TRY_SWITCH == handle->dstCanvasCacheSwitchBehavior)
{
if(G2D_MEMORY_TYPE_SWITCH_TO_NONCACHEABLE == (handle->dstCanvasType))
{
G2D_CANVAS_INFO_STRUCT *dstCanvas = &(handle->dstCanvas);
drv_gfx_dynamic_switch_cacheable(&(dstCanvas->RGBBufferAddr), dstCanvas->RGBBufferSize, KAL_FALSE);
handle->dstCanvasType = G2D_MEMORY_TYPE_NO_SWITCH;
}
}
if (GFX_CACHE_SWITCH_BEHAVIOR_TRY_SWITCH == handle->srcCanvasCacheSwitchBehavior)
{
#if defined(G2D_HW_SUPPORT)
if(G2D_MEMORY_TYPE_SWITCH_TO_NONCACHEABLE == (handle->srcBitbltRGBCanvasType))
{
G2D_CANVAS_INFO_STRUCT *srcCanvas = &(handle->bitbltFunc.srcCanvas);
drv_gfx_dynamic_switch_cacheable(&(srcCanvas->RGBBufferAddr), srcCanvas->RGBBufferSize, KAL_FALSE);
handle->srcBitbltRGBCanvasType = G2D_MEMORY_TYPE_NO_SWITCH;
}
#endif
if(G2D_MEMORY_TYPE_SWITCH_TO_NONCACHEABLE == (handle->srcRectFillOverlayRGBCanvasType))
{
G2D_CANVAS_INFO_STRUCT *srcCanvas = &(handle->rectFillFunc.srcCanvas);
drv_gfx_dynamic_switch_cacheable(&(srcCanvas->RGBBufferAddr), srcCanvas->RGBBufferSize, KAL_FALSE);
handle->srcRectFillOverlayRGBCanvasType = G2D_MEMORY_TYPE_NO_SWITCH;
}
if(G2D_MEMORY_TYPE_SWITCH_TO_NONCACHEABLE == (handle->srcLtRGBCanvasType))
{
G2D_CANVAS_INFO_STRUCT *srcCanvas = &(handle->ltFunc.srcCanvas);
drv_gfx_dynamic_switch_cacheable(&(srcCanvas->RGBBufferAddr), srcCanvas->RGBBufferSize, KAL_FALSE);
handle->srcLtRGBCanvasType = G2D_MEMORY_TYPE_NO_SWITCH;
}
if(G2D_COLOR_FORMAT_UYVY422 == handle->ltFunc.srcCanvas.colorFormat)
{
colorSizeMax = 1;
}
else
{
colorSizeMax = 3;
}
for(colorSize = 0; colorSize < colorSizeMax; colorSize++)
{
if(G2D_MEMORY_TYPE_SWITCH_TO_NONCACHEABLE == (handle->srcLtYUVCanvasType[colorSize]))
{
G2D_CANVAS_INFO_STRUCT *srcCanvas = &(handle->ltFunc.srcCanvas);
if(0 != (srcCanvas->YUVBufferSize[colorSize]))
{
drv_gfx_dynamic_switch_cacheable(&(srcCanvas->YUVBufferAddr[colorSize]), srcCanvas->YUVBufferSize[colorSize], KAL_FALSE);
handle->srcLtYUVCanvasType[colorSize] = G2D_MEMORY_TYPE_NO_SWITCH;
}
}
}
}
}
#endif
#if defined(__MTK_TARGET__)
if(g2dGetStatus(handle))
return G2D_STATUS_BUSY;
g2d_drv_power_off();
if (KAL_TRUE != INT_QueryExceptionStatus())
{
handle->g2dState = G2D_STATE_IDLE;
g2d_mutex_unlock(&g2d_mutex);
}
else
{
handle->g2dState = G2D_STATE_IDLE;
}
g2d_mutex_wakeup_wait_task();
#else
handle->g2dState = G2D_STATE_IDLE;
#endif
}
break;
#else
return G2D_STATUS_NOT_SUPPORT;
#endif /// G2D_HW_SUPPORT
#if !defined(G2D_FPGA)
case G2D_CODEC_TYPE_SW:
free(handle);
break;
#endif
default:
ASSERT(0);
break;
}
return G2D_STATUS_OK;
}
