BOOL SVE_resource_request_TVScaler_TVEncoder(DWORD dwOpenContext)
{
SVEngineContext *pCtxt = SVE_get_context();
SVEnginePowerContext *pPMCtxt = SVE_get_power_context();
if (pCtxt->dwOccupantTVScalerTVEncoder == 0)
{
pCtxt->dwOccupantTVScalerTVEncoder = dwOpenContext;
SVE_hw_power_control(HWPWR_TV_ON);
SVE_hw_clock_control(HWCLK_TV_ON);
pPMCtxt->bTVSCParam = TRUE;
pPMCtxt->bTVEncParam = TRUE;
VDE_MSG((_T("[VDE] SVE_resource_request_TVScaler_TVEncoder() : OpenContext[0x%08x] have resource\r\n"), dwOpenContext));
return TRUE;
}
else if (pCtxt->dwOccupantTVScalerTVEncoder == dwOpenContext)
{
DEBUGMSG(VDE_ZONE_TEMP, (_T("[VDE:ERR] SVE_resource_request_TVScaler_TVEncoder() : OpenContext[0x%08x] already have resource\r\n"), dwOpenContext));
return TRUE;
}
else
{
VDE_ERR((_T("[VDE:ERR] SVE_resource_request_TVScaler_TVEncoder() : Resource was occupied by other OpenContext\r\n")));
return FALSE;
}
}
BOOL SVE_resource_request_FIMD_interface(DWORD dwOpenContext)
{
SVEngineContext *pCtxt = SVE_get_context();
SVEnginePowerContext *pPMCtxt = SVE_get_power_context();
if (pCtxt->dwOccupantFIMD == 0)
{
pCtxt->dwOccupantFIMD = dwOpenContext;
SVE_hw_power_control(HWPWR_DISPLAY_ON);
SVE_hw_clock_control(HWCLK_DISPLAY_ON);
pPMCtxt->bFIMDOutputParam = TRUE;
VDE_MSG((_T("[VDE] SVE_resource_request_FIMD_interface() : OpenContext[0x%08x] have resource\r\n"), dwOpenContext));
return TRUE;
}
else if (pCtxt->dwOccupantFIMD == dwOpenContext)
{
DEBUGMSG(VDE_ZONE_ERROR, (_T("[VDE:ERR] SVE_resource_request_FIMD_interface() : OpenContext[0x%08x] already have resource\r\n"), dwOpenContext));
return TRUE;
}
else
{
VDE_ERR((_T("[VDE:ERR] SVE_resource_request_FIMD_interface() : Resource was occupied by other OpenContext\r\n")));
return FALSE;
}
}
BOOL SVE_resource_release_Rotator(DWORD dwOpenContext)
{
SVEngineContext *pCtxt = SVE_get_context();
SVEnginePowerContext *pPMCtxt = SVE_get_power_context();
if (pCtxt->dwOccupantRotator == dwOpenContext)
{
pCtxt->dwOccupantRotator = 0;
SVE_hw_power_control(HWPWR_ROTATOR_OFF);
SVE_hw_clock_control(HWCLK_ROTATOR_OFF);
pPMCtxt->bRotatorParam = FALSE;
VDE_MSG((_T("[VDE] SVE_resource_release_Rotator() : OpenContext[0x%08x] release resource\r\n"), dwOpenContext));
return TRUE;
}
else
{
VDE_ERR((_T("[VDE:ERR] SVE_resource_release_Rotator() : Resource was occupied by other OpenContext\r\n")));
return FALSE;
}
}
BOOL SVE_video_engine_power_on(void)
{
SVEngineContext *pCtxt;
SVEnginePowerContext *pPMCtxt;
BOOL bRet = TRUE;
int iWinCnt;
VDE_MSG((_T("[VDE] ++SVE_video_engine_power_on()\r\n")));
pCtxt = SVE_get_context();
pPMCtxt = SVE_get_power_context();
if (pPMCtxt->bPowerOn)
{
VDE_INF((_T("[VDE:INF] SVE_video_engine_power_on() : Video Engine is Already Power On\r\n")));
goto CleanUp;
}
//-------------------------------
// HW Block Power On and Clock On
//-------------------------------
//SVE_hw_power_control(HWPWR_ALL_ON);
SVE_hw_power_control(HWPWR_DISPLAY_ON);
SVE_hw_power_control(HWPWR_2D_ON);
//SVE_hw_clock_control(HWCLK_ALL_ON);
SVE_hw_clock_control(HWCLK_DISPLAY_ON);
SVE_hw_clock_control(HWCLK_2D_ON);
//-------------------
// FIMD Reconfiguration
//-------------------
if (pPMCtxt->bFIMDOutputParam)
{
Disp_set_output_device_information(&pPMCtxt->tFIMDOutputParam.tRGBDevInfo);
Disp_set_output_TV_information(pPMCtxt->tFIMDOutputParam.dwTVOutScreenWidth, pPMCtxt->tFIMDOutputParam.dwTVOutScreenHeight);
if (pPMCtxt->bFIMDOutputTV)
{
Disp_initialize_output_interface(DISP_VIDOUT_TVENCODER);
}
else
{
Disp_initialize_output_interface(DISP_VIDOUT_RGBIF);
}
}
//---------------------------
// FIMD Window Reconfiguration
//---------------------------
for (iWinCnt=DISP_WIN0; iWinCnt< DISP_WIN_MAX; iWinCnt++)
{
if (pPMCtxt->bFIMDWinMode[iWinCnt])
{
Disp_set_window_mode(pPMCtxt->tFIMDWinMode[iWinCnt].dwWinMode, pPMCtxt->tFIMDWinMode[iWinCnt].dwBPP,
pPMCtxt->tFIMDWinMode[iWinCnt].dwWidth, pPMCtxt->tFIMDWinMode[iWinCnt].dwHeight,
pPMCtxt->tFIMDWinMode[iWinCnt].dwOffsetX, pPMCtxt->tFIMDWinMode[iWinCnt].dwOffsetY);
}
if (pPMCtxt->bFIMDWinFBuffer[iWinCnt])
{
Disp_set_framebuffer(iWinCnt, pPMCtxt->tFIMDWinFBuffer[iWinCnt].dwFrameBuffer);
}
if (pPMCtxt->bFIMDColorKey[iWinCnt])
{
Disp_set_color_key(iWinCnt, pPMCtxt->tFIMDColorKey[iWinCnt].bOnOff, pPMCtxt->tFIMDColorKey[iWinCnt].dwDirection,
pPMCtxt->tFIMDColorKey[iWinCnt].dwColorKey, pPMCtxt->tFIMDColorKey[iWinCnt].dwCompareKey);
}
if (pPMCtxt->bFIMDAlpha[iWinCnt])
{
Disp_set_alpha_blending(iWinCnt, pPMCtxt->tFIMDAlpha[iWinCnt].dwMethod,
pPMCtxt->tFIMDAlpha[iWinCnt].dwAlpha0, pPMCtxt->tFIMDAlpha[iWinCnt].dwAlpha1);
}
if (pPMCtxt->bFIMDWinEnable[iWinCnt])
{
Disp_window_onfoff(iWinCnt, DISP_WINDOW_ON);
pCtxt->bWindowEnable[iWinCnt] = TRUE;
}
}
//---------------------------
// Post Processor Reconfiguration
//---------------------------
if (pPMCtxt->bPostParam)
{
SVE_hw_power_control(HWPWR_POST_ON);
SVE_hw_clock_control(HWCLK_POST_ON);
Post_initialize(pPMCtxt->tPostParam.dwOpMode, pPMCtxt->tPostParam.dwScanMode,
pPMCtxt->tPostParam.dwSrcType,
pPMCtxt->tPostParam.dwSrcBaseWidth, pPMCtxt->tPostParam.dwSrcBaseHeight,
pPMCtxt->tPostParam.dwSrcWidth, pPMCtxt->tPostParam.dwSrcHeight,
pPMCtxt->tPostParam.dwSrcOffsetX, pPMCtxt->tPostParam.dwSrcOffsetY,
pPMCtxt->tPostParam.dwDstType,
pPMCtxt->tPostParam.dwDstBaseWidth, pPMCtxt->tPostParam.dwDstBaseHeight,
pPMCtxt->tPostParam.dwDstWidth, pPMCtxt->tPostParam.dwDstHeight,
pPMCtxt->tPostParam.dwDstOffsetX, pPMCtxt->tPostParam.dwDstOffsetY);
if (pPMCtxt->bPostSrcBuffer)
{
Post_set_source_buffer(pPMCtxt->tPostSrcBuffer.dwBufferRGBY,
pPMCtxt->tPostSrcBuffer.dwBufferCb,
pPMCtxt->tPostSrcBuffer.dwBufferCr);
Post_set_next_source_buffer(pPMCtxt->tPostSrcBuffer.dwBufferRGBY,
pPMCtxt->tPostSrcBuffer.dwBufferCb,
pPMCtxt->tPostSrcBuffer.dwBufferCr);
}
if (pPMCtxt->bPostDstBuffer)
{
Post_set_destination_buffer(pPMCtxt->tPostDstBuffer.dwBufferRGBY,
pPMCtxt->tPostDstBuffer.dwBufferCb,
pPMCtxt->tPostDstBuffer.dwBufferCr);
Post_set_next_destination_buffer(pPMCtxt->tPostDstBuffer.dwBufferRGBY,
pPMCtxt->tPostDstBuffer.dwBufferCb,
pPMCtxt->tPostDstBuffer.dwBufferCr);
}
if (pPMCtxt->bPostStart)
{
pPMCtxt->bTVSCStart = FALSE; // for Trigger Once
Post_enable_interrupt();
Post_processing_start();
}
}
//-----------------------
// TV Scaler Reconfiguration
//-----------------------
if (pPMCtxt->bTVSCParam)
{
SVE_hw_power_control(HWPWR_TV_ON);
SVE_hw_clock_control(HWCLK_TV_ON);
TVSC_initialize(pPMCtxt->tTVSCParam.dwOpMode, pPMCtxt->tTVSCParam.dwScanMode,
pPMCtxt->tTVSCParam.dwSrcType,
pPMCtxt->tTVSCParam.dwSrcBaseWidth, pPMCtxt->tTVSCParam.dwSrcBaseHeight,
pPMCtxt->tTVSCParam.dwSrcWidth, pPMCtxt->tTVSCParam.dwSrcHeight,
pPMCtxt->tTVSCParam.dwSrcOffsetX, pPMCtxt->tTVSCParam.dwSrcOffsetY,
pPMCtxt->tTVSCParam.dwDstType,
pPMCtxt->tTVSCParam.dwDstBaseWidth, pPMCtxt->tTVSCParam.dwDstBaseHeight,
pPMCtxt->tTVSCParam.dwDstWidth, pPMCtxt->tTVSCParam.dwDstHeight,
pPMCtxt->tTVSCParam.dwDstOffsetX, pPMCtxt->tTVSCParam.dwDstOffsetY);
if (pPMCtxt->bTVSCSrcBuffer)
{
TVSC_set_source_buffer(pPMCtxt->tTVSCSrcBuffer.dwBufferRGBY,
pPMCtxt->tTVSCSrcBuffer.dwBufferCb,
pPMCtxt->tTVSCSrcBuffer.dwBufferCr);
TVSC_set_next_source_buffer(pPMCtxt->tTVSCSrcBuffer.dwBufferRGBY,
pPMCtxt->tTVSCSrcBuffer.dwBufferCb,
pPMCtxt->tTVSCSrcBuffer.dwBufferCr);
}
if (pPMCtxt->bTVSCDstBuffer)
{
TVSC_set_destination_buffer(pPMCtxt->tTVSCDstBuffer.dwBufferRGBY,
pPMCtxt->tTVSCDstBuffer.dwBufferCb,
pPMCtxt->tTVSCDstBuffer.dwBufferCr);
TVSC_set_next_destination_buffer(pPMCtxt->tTVSCDstBuffer.dwBufferRGBY,
pPMCtxt->tTVSCDstBuffer.dwBufferCb,
pPMCtxt->tTVSCDstBuffer.dwBufferCr);
}
if (pPMCtxt->bTVSCStart)
{
pPMCtxt->bTVSCStart = FALSE;
TVSC_enable_interrupt();
TVSC_processing_start();
}
}
//---------------------------
// Local Path Reconfiguration
//---------------------------
if (pPMCtxt->bLocalPathWin0Enable)
{
Post_enable_interrupt();
Post_processing_start();
Disp_set_framebuffer(DISP_WIN0, IMAGE_FRAMEBUFFER_PA_START); // Safe Frame Bufer Address for Local Path
Disp_window_onfoff(DISP_WIN0, DISP_WINDOW_ON);
pCtxt->bWindowEnable[DISP_WIN0] = TRUE;
}
if (pPMCtxt->bLocalPathWin1Enable)
{
// TODO: Enable CamIF MSDMA or TV Scaler
pCtxt->bWindowEnable[DISP_WIN1] = TRUE;
}
if (pPMCtxt->bLocalPathWin2Enable)
{
// TODO: Enable CamIF MSDMA or TV Scaler
pCtxt->bWindowEnable[DISP_WIN2] = TRUE;
}
//---------------------------
// Image Rotator Reconfiguration
//---------------------------
if (pPMCtxt->bRotatorParam)
{
SVE_hw_power_control(HWPWR_ROTATOR_ON);
SVE_hw_clock_control(HWCLK_ROTATOR_ON);
Rotator_initialize(pPMCtxt->tRotatorParam.dwImgFormat,
pPMCtxt->tRotatorParam.dwOpType,
pPMCtxt->tRotatorParam.dwSrcWidth,
pPMCtxt->tRotatorParam.dwSrcHeight);
if (pPMCtxt->bRotatorSrcBuffer)
{
Rotator_set_source_buffer(pPMCtxt->tRotatorSrcBuffer.dwBufferRGBY,
pPMCtxt->tRotatorSrcBuffer.dwBufferCb,
pPMCtxt->tRotatorSrcBuffer.dwBufferCr);
}
if (pPMCtxt->bRotatorDstBuffer)
{
Rotator_set_destination_buffer(pPMCtxt->tRotatorDstBuffer.dwBufferRGBY,
pPMCtxt->tRotatorDstBuffer.dwBufferCb,
pPMCtxt->tRotatorDstBuffer.dwBufferCr);
}
if (pPMCtxt->bRotatorStart)
{
pPMCtxt->bRotatorStart = FALSE;
pCtxt->bRotatorBusy = TRUE;
Rotator_enable_interrupt();
Rotator_start();
}
}
//---------------------------
// TV Encoder Reconfiguration
//---------------------------
if (pPMCtxt->bTVEncParam)
{
TVEnc_initialize(pPMCtxt->tTVEncParam.dwOutputType,
pPMCtxt->tTVEncParam.dwOutputStandard, pPMCtxt->tTVEncParam.dwMVisionPattern,
pPMCtxt->tTVEncParam.dwSrcWidth, pPMCtxt->tTVEncParam.dwSrcHeight);
}
//-------------------
// Enable Video Output
//-------------------
if (pPMCtxt->bTVEncEnable)
{
// TV Encoder On
TVEnc_output_onoff(TVENC_ENCODER_ON);
// TV Scaler Start
TVSC_enable_interrupt();
TVSC_processing_start();
}
if (pPMCtxt->bFIMDOutputEnable)
{
// Enable Interrupt
Disp_set_frame_interrupt(DISP_FRMINT_FRONTPORCH);
Disp_enable_frame_interrupt();
// Video Output Enable
Disp_envid_onoff(DISP_ENVID_ON);
pCtxt->bVideoEnable = TRUE;
}
//-------------------
// Update Power State
//-------------------
pPMCtxt->bPowerOn = TRUE;
CleanUp:
VDE_MSG((_T("[VDE] --SVE_video_engine_power_on()\r\n")));
return bRet;
}
BOOL SVE_video_engine_power_off(void)
{
SVEngineContext *pCtxt;
SVEnginePowerContext *pPMCtxt;
BOOL bRet = TRUE;
VDE_MSG((_T("[VDE] ++SVE_video_engine_power_off()\r\n")));
pCtxt = SVE_get_context();
pPMCtxt = SVE_get_power_context();
if (!pPMCtxt->bPowerOn)
{
VDE_INF((_T("[VDE:INF] SVE_video_engine_power_off() : Video Engine is Already Power Off\r\n")));
goto CleanUp;
}
//-----------------------
// Disable Video Engine HW
//-----------------------
// Disable All Interrupt
Disp_disable_frame_interrupt();
Post_disable_interrupt();
Rotator_disable_interrupt();
TVSC_disable_interrupt();
// Clear All Interrupt Pending
Disp_clear_interrupt_pending();
Post_clear_interrupt_pending();
Rotator_clear_interrupt_pending();
TVSC_clear_interrupt_pending();
// Disable FIMD output
Disp_envid_onoff(DISP_ENVID_DIRECT_OFF);
pCtxt->bVideoEnable = FALSE;
pCtxt->bWindowEnable[DISP_WIN0] = FALSE;
pCtxt->bWindowEnable[DISP_WIN1] = FALSE;
pCtxt->bWindowEnable[DISP_WIN2] = FALSE;
pCtxt->bWindowEnable[DISP_WIN3] = FALSE;
pCtxt->bWindowEnable[DISP_WIN4] = FALSE;
// Disable TV Scaler Operation
TVSC_processing_stop();
// Disable TV Encoder Operation
TVEnc_output_onoff(TVENC_ENCODER_OFF);
// Disable Post Processor Operation
Post_processing_stop();
// Disable Rotator Operation
Rotator_stop();
pCtxt->bRotatorBusy = FALSE;
//----------------------
// Clear Command Context
//----------------------
pCtxt->DispCmdCtxt[DISP_WIN0].bCmdSetBuffer = FALSE;
pCtxt->DispCmdCtxt[DISP_WIN0].bCmdSetPosition = FALSE;
pCtxt->DispCmdCtxt[DISP_WIN1].bCmdSetBuffer = FALSE;
pCtxt->DispCmdCtxt[DISP_WIN1].bCmdSetPosition = FALSE;
pCtxt->DispCmdCtxt[DISP_WIN2].bCmdSetBuffer = FALSE;
pCtxt->DispCmdCtxt[DISP_WIN2].bCmdSetPosition = FALSE;
pCtxt->DispCmdCtxt[DISP_WIN3].bCmdSetBuffer = FALSE;
pCtxt->DispCmdCtxt[DISP_WIN3].bCmdSetPosition = FALSE;
pCtxt->DispCmdCtxt[DISP_WIN4].bCmdSetBuffer = FALSE;
pCtxt->DispCmdCtxt[DISP_WIN4].bCmdSetPosition = FALSE;
pCtxt->PostCmdCtxt.bCmdSetSrcBuffer = FALSE;
pCtxt->PostCmdCtxt.bCmdSetDstBuffer = FALSE;
pCtxt->LocalPathCmdCtxt.bCmdSetWin0Disable = FALSE;
pCtxt->LocalPathCmdCtxt.bCmdSetWin1Disable = FALSE;
pCtxt->LocalPathCmdCtxt.bCmdSetWin2Disable = FALSE;
pCtxt->TVSCCmdCtxt.bCmdSetSrcBuffer = FALSE;
pCtxt->TVSCCmdCtxt.bCmdSetDstBuffer = FALSE;
//-------------------------------
// HW Clock Off and Block Power Off
//-------------------------------
SVE_hw_clock_control(HWCLK_ALL_OFF);
SVE_hw_power_control(HWPWR_ALL_OFF);
//-------------------
// Update Power State
//-------------------
pPMCtxt->bPowerOn = FALSE;
CleanUp:
VDE_MSG((_T("[VDE] --SVE_video_engine_power_off()\r\n")));
return bRet;
}
BOOL SVE_initialize_video_engine(void)
{
SVEngineContext *pCtxt;
VDE_MSG((_T("[VDE] ++SVE_initialize_video_engine()\r\n")));
pCtxt = SVE_get_context();
// Clear Context
SVE_initialize_context();
SVE_initialize_power_context();
// map device SFR address
if (SVE_map_device_address() == FALSE)
{
VDE_ERR((_T("[VDE:ERR] SVE_initialize_video_engine() : SVE_map_device_address() Failed\r\n")));
goto CleanUp;
}
// Intialize interrupt
if (SVE_initialize_interrupt() == FALSE)
{
VDE_ERR((_T("[VDE:ERR] SVE_initialize_video_engine() : SVE_intialize_interrupt() Failed\r\n")));
goto CleanUp;
}
// Create Interrupt Thread
if (SVE_initialize_thread() == FALSE)
{
VDE_ERR((_T("[VDE:ERR] SVE_initialize_video_engine() : SVE_initialize_thread() Failed\r\n")));
goto CleanUp;
}
// Open Power Control Driver
if (SVE_initialize_power_control() == FALSE)
{
VDE_ERR((_T("[VDE:ERR] SVE_initialize_video_engine() : SVE_initialize_power_control() Failed\r\n")));
goto CleanUp;
}
// Initialize SFR Address of Sub Module
LDI_initialize_register_address((void *)pCtxt->pSPIReg, (void *)pCtxt->pDispConReg, (void *)pCtxt->pGPIOReg);
Disp_initialize_register_address((void *)pCtxt->pDispConReg, (void *)pCtxt->pMSMIFReg, (void *)pCtxt->pGPIOReg);
Post_initialize_register_address((void *)pCtxt->pPostReg);
Rotator_initialize_register_address((void *)pCtxt->pRotatorReg);
TVSC_initialize_register_address((void *)pCtxt->pTVSCReg);
TVEnc_initialize_register_address((void *)pCtxt->pTVEncReg, (void *)pCtxt->pGPIOReg);
SVE_hw_power_control(HWPWR_DISPLAY_ON);
SVE_hw_power_control(HWPWR_2D_ON);
SVE_hw_clock_control(HWCLK_DISPLAY_ON);
SVE_hw_clock_control(HWCLK_2D_ON);
VDE_MSG((_T("[VDE] --SVE_initialize_video_engine()\r\n")));
return TRUE;
CleanUp:
SVE_deinitialize_video_engine();
VDE_ERR((_T("[VDE:ERR] --SVE_initialize_video_engine() : Failed\r\n")));
return FALSE;
}
