BOOL SVE_remove_open_context(DWORD dwOpenContext)
{
SVEngineContext *pCtxt = SVE_get_context();
if (pCtxt->dwOpenCount > 0)
{
// Release H/W Resource
if (pCtxt->dwOccupantFIMD == dwOpenContext) pCtxt->dwOccupantFIMD = 0;
if (pCtxt->dwOccupantFIMDWindow[0] == dwOpenContext) pCtxt->dwOccupantFIMDWindow[0] = 0;
if (pCtxt->dwOccupantFIMDWindow[1] == dwOpenContext) pCtxt->dwOccupantFIMDWindow[1] = 0;
if (pCtxt->dwOccupantFIMDWindow[2] == dwOpenContext) pCtxt->dwOccupantFIMDWindow[2] = 0;
if (pCtxt->dwOccupantFIMDWindow[3] == dwOpenContext) pCtxt->dwOccupantFIMDWindow[3] = 0;
if (pCtxt->dwOccupantFIMDWindow[4] == dwOpenContext) pCtxt->dwOccupantFIMDWindow[4] = 0;
if (pCtxt->dwOccupantPost == dwOpenContext) pCtxt->dwOccupantPost = 0;
if (pCtxt->dwOccupantRotator == dwOpenContext) pCtxt->dwOccupantRotator = 0;
if (pCtxt->dwOccupantTVScalerTVEncoder == dwOpenContext) pCtxt->dwOccupantTVScalerTVEncoder = 0;
pCtxt->dwOpenCount--;
VDE_MSG((_T("[VDE] SVE_remove_open_context(0x%08x) : OpenCount = %d\r\n"), pCtxt->dwLastOpenContext, pCtxt->dwOpenCount));
return TRUE;
}
else
{
VDE_ERR((_T("[VDE:ERR] SVE_remove_open_context() : Current Open Count is 0 !!!\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_request_Rotator(DWORD dwOpenContext)
{
SVEngineContext *pCtxt = SVE_get_context();
SVEnginePowerContext *pPMCtxt = SVE_get_power_context();
if (pCtxt->dwOccupantRotator == 0)
{
pCtxt->dwOccupantRotator = dwOpenContext;
SVE_hw_power_control(HWPWR_ROTATOR_ON);
SVE_hw_clock_control(HWCLK_ROTATOR_ON);
pPMCtxt->bRotatorParam = TRUE;
VDE_MSG((_T("[VDE] SVE_resource_request_Rotator() : OpenContext[0x%08x] have resource\r\n"), dwOpenContext));
return TRUE;
}
else if (pCtxt->dwOccupantRotator == dwOpenContext)
{
DEBUGMSG(VDE_ZONE_TEMP,(_T("[VDE:ERR] SVE_resource_request_Rotator() : OpenContext[0x%08x] already have resource\r\n"), dwOpenContext));
return TRUE;
}
else
{
VDE_ERR((_T("[VDE:ERR] SVE_resource_request_Rotator() : Resource was occupied by other OpenContext\r\n")));
return FALSE;
}
}
void SVE_initialize_power_context(void)
{
SVEnginePowerContext *pPMCtxt;
VDE_MSG((_T("[VDE] SVE_initialize_context()\r\n")));
pPMCtxt = SVE_get_power_context();
memset(pPMCtxt, 0x0, sizeof(SVEnginePowerContext));
pPMCtxt->bPowerOn = TRUE; // Initially Power On
// Invalidate All Stored Values
pPMCtxt->bFIMDOutputParam = FALSE;
pPMCtxt->bFIMDOutputTV = FALSE;
pPMCtxt->bFIMDOutputEnable = FALSE;
pPMCtxt->bFIMDWinMode[DISP_WIN0] = FALSE;
pPMCtxt->bFIMDWinMode[DISP_WIN1] = FALSE;
pPMCtxt->bFIMDWinMode[DISP_WIN2] = FALSE;
pPMCtxt->bFIMDWinMode[DISP_WIN3] = FALSE;
pPMCtxt->bFIMDWinMode[DISP_WIN4] = FALSE;
pPMCtxt->bFIMDWinFBuffer[DISP_WIN0] = FALSE;
pPMCtxt->bFIMDWinFBuffer[DISP_WIN1] = FALSE;
pPMCtxt->bFIMDWinFBuffer[DISP_WIN2] = FALSE;
pPMCtxt->bFIMDWinFBuffer[DISP_WIN3] = FALSE;
pPMCtxt->bFIMDWinFBuffer[DISP_WIN4] = FALSE;
pPMCtxt->bFIMDColorKey[DISP_WIN0] = FALSE; // Never Used
pPMCtxt->bFIMDColorKey[DISP_WIN1] = FALSE;
pPMCtxt->bFIMDColorKey[DISP_WIN2] = FALSE;
pPMCtxt->bFIMDColorKey[DISP_WIN3] = FALSE;
pPMCtxt->bFIMDColorKey[DISP_WIN4] = FALSE;
pPMCtxt->bFIMDAlpha[DISP_WIN0] = FALSE; // Never Used
pPMCtxt->bFIMDAlpha[DISP_WIN1] = FALSE;
pPMCtxt->bFIMDAlpha[DISP_WIN2] = FALSE;
pPMCtxt->bFIMDAlpha[DISP_WIN3] = FALSE;
pPMCtxt->bFIMDAlpha[DISP_WIN4] = FALSE;
pPMCtxt->bFIMDWinEnable[DISP_WIN0] = FALSE;
pPMCtxt->bFIMDWinEnable[DISP_WIN1] = FALSE;
pPMCtxt->bFIMDWinEnable[DISP_WIN2] = FALSE;
pPMCtxt->bFIMDWinEnable[DISP_WIN3] = FALSE;
pPMCtxt->bFIMDWinEnable[DISP_WIN4] = FALSE;
pPMCtxt->bPostParam = FALSE;
pPMCtxt->bPostSrcBuffer = FALSE;
pPMCtxt->bPostDstBuffer = FALSE;
pPMCtxt->bPostStart = FALSE;
pPMCtxt->bLocalPathWin0Enable = FALSE;
pPMCtxt->bLocalPathWin1Enable = FALSE;
pPMCtxt->bLocalPathWin2Enable = FALSE;
pPMCtxt->bRotatorParam = FALSE;
pPMCtxt->bRotatorSrcBuffer = FALSE;
pPMCtxt->bRotatorDstBuffer = FALSE;
pPMCtxt->bRotatorStart = FALSE;
pPMCtxt->bTVSCParam = FALSE;
pPMCtxt->bTVSCSrcBuffer = FALSE;
pPMCtxt->bTVSCDstBuffer = FALSE;
pPMCtxt->bTVSCStart = FALSE;
pPMCtxt->bTVEncParam = FALSE;
pPMCtxt->bTVEncEnable = FALSE;
}
BOOL
WINAPI
DllEntry(HINSTANCE hinstDll, DWORD dwReason, LPVOID lpReserved)
{
if (dwReason == DLL_PROCESS_ATTACH)
{
DEBUGREGISTER(hinstDll);
RETAILREGISTERZONES(hinstDll);
//DisableThreadLibraryCalls ((HMODULE)hinstDll);
VDE_MSG((_T("[VDE] DllEntry() : Process Attach\r\n")));
}
else if (dwReason == DLL_PROCESS_DETACH)
{
VDE_MSG((_T("[VDE] DllEntry() : Process Detach\r\n")));
}
return TRUE;
}
BOOL
VDE_Deinit(
DWORD hDeviceContext
)
{
VDE_MSG((_T("[VDE] ++VDE_Deinit(0x%08x)\r\n"), hDeviceContext));
if (hDeviceContext != SVE_get_driver_signature())
{
VDE_ERR((_T("[VDE:ERR] VDE_Deinit() : Invalid Driver Handle[0x%08x]\r\n"), hDeviceContext));
return FALSE;
}
SVE_deinitialize_video_engine();
VDE_MSG((_T("[VDE] --VDE_Deinit()\r\n")));
return TRUE;
}
BOOL
VDE_Close(
DWORD hOpenContext
)
{
BOOL bRet;
VDE_MSG((_T("[VDE] ++VDE_Close(0x%08x)\r\n"), hOpenContext));
bRet = SVE_remove_open_context(hOpenContext);
if (!bRet)
{
VDE_ERR((_T("[VDE:ERR] VDE_Close() : Invalid Open Context !!!\r\n")));
}
VDE_MSG((_T("[VDE] --VDE_Close()\r\n")));
return bRet;
}
DWORD SVE_add_open_context(void)
{
SVEngineContext *pCtxt = SVE_get_context();
pCtxt->dwOpenCount++;
pCtxt->dwLastOpenContext++;
VDE_MSG((_T("[VDE] SVE_add_open_context() : OpenCount = %d, OpenContext = 0x%08x\r\n"), pCtxt->dwOpenCount, pCtxt->dwLastOpenContext));
return (pCtxt->dwLastOpenContext);
}
DWORD
VDE_Seek(
DWORD hOpenContext,
long Amount,
WORD Type
)
{
VDE_MSG((_T("[VDE] VDE_Seek(0x%08x, 0x%08x, 0x%08x)\r\n"), hOpenContext, Amount, Type));
return (DWORD)-1; // Failure
}
DWORD
VDE_Write(
DWORD hOpenContext,
LPCVOID pBuffer,
DWORD Count
)
{
VDE_MSG((_T("[VDE] VDE_Write(0x%08x, 0x%08x, 0x%08x)\r\n"), hOpenContext, pBuffer, Count));
return (0); // Number of Byte
}
DWORD
VDE_Read(
DWORD hOpenContext,
LPVOID pBuffer,
DWORD Count
)
{
VDE_MSG((_T("[VDE] VDE_Read(0x%08x, 0x%08x, 0x%08x)\r\n"), hOpenContext, pBuffer, Count));
return (0); // End of File
}
DWORD
VDE_Init(
LPCTSTR pContext
)
{
VDE_MSG((_T("[VDE] ++VDE_Init(0x%08x)\r\n"), pContext));
if (SVE_initialize_video_engine() == FALSE)
{
VDE_ERR((_T("[VDE:ERR] VDE_Init() : SVE_initialize_video_engine() Failed \n\r")));
goto CleanUp;
}
VDE_MSG((_T("[VDE] --VDE_Init()\r\n")));
return SVE_get_driver_signature(); // hDeviceContext
CleanUp:
VDE_ERR((_T("[VDE:ERR] --VDE_Init() : Failed\r\n")));
return 0;
}
BOOL SVE_resource_compare_FIMD_interface(DWORD dwOpenContext)
{
SVEngineContext *pCtxt = SVE_get_context();
if (pCtxt->dwOccupantFIMD == dwOpenContext)
{
VDE_MSG((_T("[VDE] SVE_resource_compare_FIMD_interface() : OpenContext[0x%08x] have resource\r\n"), dwOpenContext));
return TRUE;
}
else
{
VDE_ERR((_T("[VDE:ERR] SVE_resource_request_FIMD_interface() : Resource was occupied by OpenContext: 0x%x\r\n"), pCtxt->dwOccupantFIMD));
return FALSE;
}
}
BOOL SVE_resource_compare_TVScaler_TVEncoder(DWORD dwOpenContext)
{
SVEngineContext *pCtxt = SVE_get_context();
if (pCtxt->dwOccupantTVScalerTVEncoder == dwOpenContext)
{
VDE_MSG((_T("[VDE] SVE_resource_compare_TVScaler_TVEncoder() : OpenContext[0x%08x] have resource\r\n"), dwOpenContext));
return TRUE;
}
else
{
VDE_ERR((_T("[VDE:ERR] SVE_resource_compare_TVScaler_TVEncoder() : Resource was occupied by other OpenContext:0x%x\r\n"), pCtxt->dwOccupantTVScalerTVEncoder));
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_resource_request_FIMD_window(DWORD dwWinNum, DWORD dwOpenContext)
{
SVEngineContext *pCtxt = SVE_get_context();
if (pCtxt->dwOccupantFIMDWindow[dwWinNum] == 0)
{
pCtxt->dwOccupantFIMDWindow[dwWinNum] = dwOpenContext;
VDE_MSG((_T("[VDE] SVE_resource_request_FIMD_window() : OpenContext[0x%08x] have resource Win[%d]\r\n"), dwOpenContext, dwWinNum));
return TRUE;
}
else if (pCtxt->dwOccupantFIMDWindow[dwWinNum] == dwOpenContext)
{
DEBUGMSG(VDE_ZONE_TEMP,(_T("[VDE:ERR] SVE_resource_request_FIMD_window() : OpenContext[0x%08x] already have resource Win[%d]\r\n"), dwOpenContext, dwWinNum));
return TRUE;
}
else
{
VDE_ERR((_T("[VDE:ERR] SVE_resource_request_FIMD_window() : Resource Win[%d] was occupied by other OpenContext\r\n"), dwWinNum));
return FALSE;
}
}
BOOL SVE_TVEncoder_API_Proc(
DWORD hOpenContext,
DWORD dwCode,
PBYTE pBufIn,
DWORD dwLenIn,
PBYTE pBufOut,
DWORD dwLenOut,
PDWORD pdwActualOut
)
{
SVEngineContext *pCtxt;
SVEnginePowerContext *pPMCtxt;
BOOL bRet = TRUE;
VDE_MSG((_T("[VDE] ++SVE_TVEncoder_API_Proc()\n\r")));
pCtxt = SVE_get_context();
pPMCtxt = SVE_get_power_context();
//-------------------------------------------------------------
// Check OpenContext of Caller have the right to access to H/W Resource
//-------------------------------------------------------------
switch(dwCode)
{
case SVE_TVENC_SET_INTERFACE_PARAM:
case SVE_TVENC_SET_ENCODER_ON:
case SVE_TVENC_SET_ENCODER_OFF:
case SVE_TVENC_GET_INTERFACE_STATUS:
bRet = SVE_resource_compare_TVScaler_TVEncoder(hOpenContext);
if (!bRet)
{
VDE_ERR((_T("[VDE:ERR] SVE_TVEncoder_API_Proc(0x%08x) : No Right to Access to H/W Resource\r\n"), dwCode));
goto CleanUp;
}
break;
default:
DEBUGMSG(VDE_ZONE_ERROR, (TEXT("[VDE:ERR] Invalid IOCTL code\n")));
bRet = FALSE;
goto CleanUp;
}
//--------------------------------
// Processing IOCTL for TV Encoder
//--------------------------------
switch(dwCode)
{
case SVE_TVENC_SET_INTERFACE_PARAM:
{
SVEARG_TVENC_PARAMETER *pArg;
VDE_MSG((_T("[VDE] SVE_TVEncoder_API_Proc() : SVE_TVENC_SET_INTERFACE_PARAM\n\r")));
if(!pBufIn || dwLenIn < sizeof(SVEARG_TVENC_PARAMETER))
{
DEBUGMSG(VDE_ZONE_ERROR,(TEXT("Invalid Parameter : pBufIn:0x%x Length:%d\n"), pBufIn, dwLenIn));
bRet = FALSE;
break;
}
pArg = (SVEARG_TVENC_PARAMETER *)pBufIn;
if (pPMCtxt->bPowerOn)
{
if (TVEnc_get_output_state() == TVENC_ENCODER_ON) // TV Encoder Running
{
VDE_ERR((_T("[VDE:ERR] SVE_TVEncoder_API_Proc() : SVE_TVENC_SET_INTERFACE_PARAM : TV Encoder is Running\n\r")));
bRet = FALSE;
break;
}
TVEnc_initialize(pArg->dwOutputType, pArg->dwOutputStandard, pArg->dwMVisionPattern, pArg->dwSrcWidth, pArg->dwSrcHeight);
}
// Backup for PM
memcpy(&pPMCtxt->tTVEncParam, pArg, sizeof(SVEARG_TVENC_PARAMETER));
break;
}
case SVE_TVENC_SET_ENCODER_ON: // Start TV Scaler & Enable TV Encoder
{
VDE_MSG((_T("[VDE] SVE_TVEncoder_API_Proc() : SVE_TVENC_SET_ENCODER_ON\n\r")));
if (pPMCtxt->bPowerOn)
{
//------------------
// Enable TV Encoder
//------------------
if (TVEnc_get_output_state() == TVENC_ENCODER_ON) // TV Encoder Running
{
VDE_ERR((_T("[VDE:ERR] SVE_TVEncoder_API_Proc() : SVE_TVENC_SET_ENCODER_ON : TV Encoder is Running\n\r")));
//bRet = FALSE; // Treat this as Non-Error
}
else
{
//TVEnc_disable_interrupt();
TVEnc_output_onoff(TVENC_ENCODER_ON);
}
//--------------
// Start TV Scaler
//--------------
if (TVSC_get_processing_state() == TVSC_BUSY) // TV Scaler Running
{
VDE_ERR((_T("[VDE:ERR] SVE_TVEncoder_API_Proc() : SVE_TVENC_SET_ENCODER_ON : TV Scaler is Running\n\r")));
bRet = FALSE;
break;
}
TVSC_enable_interrupt();
TVSC_processing_start();
}
// Backup for PM
pPMCtxt->bTVEncEnable = TRUE;
break;
}
case SVE_TVENC_SET_ENCODER_OFF: // Stop TV Scaler & Disable TV Encoder
{
VDE_MSG((_T("[VDE] SVE_TVEncoder_API_Proc() : SVE_TVENC_SET_ENCODER_OFF\n\r")));
if (pPMCtxt->bPowerOn)
{
//----------------
// Stop TV Scaler
//----------------
TVSC_autoload_disable();
if (TVSC_get_processing_state() == TVSC_BUSY) // TV Scaler Running
{
// Wait for Current Frame Finished
if (WAIT_TIMEOUT == SVE_wait_tvsc_cmd_done())
{
if (TVSC_get_processing_state() == TVSC_IDLE)
{
// Time Out, But TV Scaler Finished
VDE_MSG((_T("[VDE] SVE_TVEncoder_API_Proc() : SVE_TVENC_SET_ENCODER_OFF : SVE_wait_tvsc_cmd_done() TimeOut, But TV Scaler Finished\n\r")));
}
else
{
VDE_INF((_T("[VDE:INF] SVE_TVEncoder_API_Proc() : SVE_TVENC_SET_ENCODER_OFF : SVE_wait_tvsc_cmd_done() TimeOut\n\r")));
TVSC_processing_stop();
}
}
}
//------------------
// Disable TV Encoder
//------------------
if (TVEnc_get_output_state() == TVENC_ENCODER_OFF) // TV Encoder Not Running
{
VDE_ERR((_T("[VDE:ERR] SVE_TVEncoder_API_Proc() : SVE_TVENC_SET_ENCODER_OFF : TV Encoder is Not Running\n\r")));
//bRet = FALSE; // Treat this as Non-Error
}
else
{
TVEnc_output_onoff(TVENC_ENCODER_OFF);
}
}
// Backup for PM
pPMCtxt->bTVEncEnable = FALSE;
break;
}
case SVE_TVENC_GET_INTERFACE_STATUS:
VDE_ERR((_T("[VDE:ERR] SVE_TVEncoder_API_Proc() : SVE_TVENC_GET_INTERFACE_STATUS : Not Implemented Yet...\n\r")));
bRet = FALSE;
break;
default: // This is filtered above switch statement
bRet = FALSE;
break;
}
CleanUp:
VDE_MSG((_T("[VDE] --SVE_TVEncoder_API_Proc()\n\r")));
return bRet;
}
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;
}
void SVE_deinitialize_power_context(void)
{
VDE_MSG((_T("[VDE] SVE_deinitialize_power_context()\r\n")));
return;
}
BOOL SVE_hw_power_control(HWPWR_GATING eParams)
{
SVEngineContext *pCtxt;
DWORD dwIPIndex, dwBytes;
BOOL bRet = TRUE;
VDE_MSG((_T("[VDE] ++SVE_hw_power_control(%d)\r\n"), eParams));
pCtxt = SVE_get_context();
switch(eParams)
{
case HWPWR_ALL_ON:
dwIPIndex = PWR_IP_DISPCON; // Power On Display Controller
if ( !DeviceIoControl(pCtxt->hPowerControl, IOCTL_PWRCON_SET_POWER_ON, &dwIPIndex, sizeof(DWORD), NULL, 0, &dwBytes, NULL) )
{
VDE_ERR((_T("[VDE:ERR] SVE_hw_power_control() : IOCTL_PWRCON_SET_POWER_ON Failed\n\r")));
bRet = FALSE;
}
dwIPIndex = PWR_IP_POST; // Power On Post Processor
if ( !DeviceIoControl(pCtxt->hPowerControl, IOCTL_PWRCON_SET_POWER_ON, &dwIPIndex, sizeof(DWORD), NULL, 0, &dwBytes, NULL) )
{
VDE_ERR((_T("[VDE:ERR] SVE_hw_power_control() : IOCTL_PWRCON_SET_POWER_ON Failed\n\r")));
bRet = FALSE;
}
dwIPIndex = PWR_IP_ROTATOR; // Power On Image Rotator
if ( !DeviceIoControl(pCtxt->hPowerControl, IOCTL_PWRCON_SET_POWER_ON, &dwIPIndex, sizeof(DWORD), NULL, 0, &dwBytes, NULL) )
{
VDE_ERR((_T("[VDE:ERR] SVE_hw_power_control() : IOCTL_PWRCON_SET_POWER_ON Failed\n\r")));
bRet = FALSE;
}
dwIPIndex = PWR_IP_TVENC; // Power On TV Encoder
if ( !DeviceIoControl(pCtxt->hPowerControl, IOCTL_PWRCON_SET_POWER_ON, &dwIPIndex, sizeof(DWORD), NULL, 0, &dwBytes, NULL) )
{
VDE_ERR((_T("[VDE:ERR] SVE_hw_power_control() : IOCTL_PWRCON_SET_POWER_ON Failed\n\r")));
bRet = FALSE;
}
dwIPIndex = PWR_IP_TVSC; // Power On TV Scaler
if ( !DeviceIoControl(pCtxt->hPowerControl, IOCTL_PWRCON_SET_POWER_ON, &dwIPIndex, sizeof(DWORD), NULL, 0, &dwBytes, NULL) )
{
VDE_ERR((_T("[VDE:ERR] SVE_hw_power_control() : IOCTL_PWRCON_SET_POWER_ON Failed\n\r")));
bRet = FALSE;
}
break;
case HWPWR_ALL_OFF:
dwIPIndex = PWR_IP_DISPCON; // Power Off Display Controller
if ( !DeviceIoControl(pCtxt->hPowerControl, IOCTL_PWRCON_SET_POWER_OFF, &dwIPIndex, sizeof(DWORD), NULL, 0, &dwBytes, NULL) )
{
VDE_ERR((_T("[VDE:ERR] SVE_hw_power_control() : IOCTL_PWRCON_SET_POWER_OFF Failed\n\r")));
bRet = FALSE;
}
dwIPIndex = PWR_IP_POST; // Power Off Post Processor
if ( !DeviceIoControl(pCtxt->hPowerControl, IOCTL_PWRCON_SET_POWER_OFF, &dwIPIndex, sizeof(DWORD), NULL, 0, &dwBytes, NULL) )
{
VDE_ERR((_T("[VDE:ERR] SVE_hw_power_control() : IOCTL_PWRCON_SET_POWER_OFF Failed\n\r")));
bRet = FALSE;
}
dwIPIndex = PWR_IP_ROTATOR; // Power Off Image Rotator
if ( !DeviceIoControl(pCtxt->hPowerControl, IOCTL_PWRCON_SET_POWER_OFF, &dwIPIndex, sizeof(DWORD), NULL, 0, &dwBytes, NULL) )
{
VDE_ERR((_T("[VDE:ERR] SVE_hw_power_control() : IOCTL_PWRCON_SET_POWER_OFF Failed\n\r")));
bRet = FALSE;
}
dwIPIndex = PWR_IP_TVENC; // Power Off TV Encoder
if ( !DeviceIoControl(pCtxt->hPowerControl, IOCTL_PWRCON_SET_POWER_OFF, &dwIPIndex, sizeof(DWORD), NULL, 0, &dwBytes, NULL) )
{
VDE_ERR((_T("[VDE:ERR] SVE_hw_power_control() : IOCTL_PWRCON_SET_POWER_OFF Failed\n\r")));
bRet = FALSE;
}
dwIPIndex = PWR_IP_TVSC; // Power Off TV Scaler
if ( !DeviceIoControl(pCtxt->hPowerControl, IOCTL_PWRCON_SET_POWER_OFF, &dwIPIndex, sizeof(DWORD), NULL, 0, &dwBytes, NULL) )
{
VDE_ERR((_T("[VDE:ERR] SVE_hw_power_control() : IOCTL_PWRCON_SET_POWER_OFF Failed\n\r")));
bRet = FALSE;
}
break;
case HWPWR_DISPLAY_ON:
dwIPIndex = PWR_IP_DISPCON; // Power On Display Controller
if ( !DeviceIoControl(pCtxt->hPowerControl, IOCTL_PWRCON_SET_POWER_ON, &dwIPIndex, sizeof(DWORD), NULL, 0, &dwBytes, NULL) )
{
VDE_ERR((_T("[VDE:ERR] SVE_hw_power_control() : IOCTL_PWRCON_SET_POWER_ON Failed\n\r")));
bRet = FALSE;
}
break;
case HWPWR_DISPLAY_OFF:
dwIPIndex = PWR_IP_DISPCON; // Power Off Display Controller
if ( !DeviceIoControl(pCtxt->hPowerControl, IOCTL_PWRCON_SET_POWER_OFF, &dwIPIndex, sizeof(DWORD), NULL, 0, &dwBytes, NULL) )
{
VDE_ERR((_T("[VDE:ERR] SVE_hw_power_control() : IOCTL_PWRCON_SET_POWER_OFF Failed\n\r")));
bRet = FALSE;
}
break;
case HWPWR_POST_ON:
dwIPIndex = PWR_IP_POST; // Power On Post Processor
if ( !DeviceIoControl(pCtxt->hPowerControl, IOCTL_PWRCON_SET_POWER_ON, &dwIPIndex, sizeof(DWORD), NULL, 0, &dwBytes, NULL) )
{
VDE_ERR((_T("[VDE:ERR] SVE_hw_power_control() : IOCTL_PWRCON_SET_POWER_ON Failed\n\r")));
bRet = FALSE;
}
break;
case HWPWR_POST_OFF:
dwIPIndex = PWR_IP_POST; // Power Off Post Processor
if ( !DeviceIoControl(pCtxt->hPowerControl, IOCTL_PWRCON_SET_POWER_OFF, &dwIPIndex, sizeof(DWORD), NULL, 0, &dwBytes, NULL) )
{
VDE_ERR((_T("[VDE:ERR] SVE_hw_power_control() : IOCTL_PWRCON_SET_POWER_OFF Failed\n\r")));
bRet = FALSE;
}
break;
case HWPWR_ROTATOR_ON:
dwIPIndex = PWR_IP_ROTATOR; // Power On Image Rotator
if ( !DeviceIoControl(pCtxt->hPowerControl, IOCTL_PWRCON_SET_POWER_ON, &dwIPIndex, sizeof(DWORD), NULL, 0, &dwBytes, NULL) )
{
VDE_ERR((_T("[VDE:ERR] SVE_hw_power_control() : IOCTL_PWRCON_SET_POWER_ON Failed\n\r")));
bRet = FALSE;
}
break;
case HWPWR_ROTATOR_OFF:
dwIPIndex = PWR_IP_ROTATOR; // Power Off Image Rotator
if ( !DeviceIoControl(pCtxt->hPowerControl, IOCTL_PWRCON_SET_POWER_OFF, &dwIPIndex, sizeof(DWORD), NULL, 0, &dwBytes, NULL) )
{
VDE_ERR((_T("[VDE:ERR] SVE_hw_power_control() : IOCTL_PWRCON_SET_POWER_OFF Failed\n\r")));
bRet = FALSE;
}
break;
case HWPWR_TV_ON:
dwIPIndex = PWR_IP_TVENC; // Power On TV Encoder
if ( !DeviceIoControl(pCtxt->hPowerControl, IOCTL_PWRCON_SET_POWER_ON, &dwIPIndex, sizeof(DWORD), NULL, 0, &dwBytes, NULL) )
{
VDE_ERR((_T("[VDE:ERR] SVE_hw_power_control() : IOCTL_PWRCON_SET_POWER_ON Failed\n\r")));
bRet = FALSE;
}
dwIPIndex = PWR_IP_TVSC; // Power On TV Scaler
if ( !DeviceIoControl(pCtxt->hPowerControl, IOCTL_PWRCON_SET_POWER_ON, &dwIPIndex, sizeof(DWORD), NULL, 0, &dwBytes, NULL) )
{
VDE_ERR((_T("[VDE:ERR] SVE_hw_power_control() : IOCTL_PWRCON_SET_POWER_ON Failed\n\r")));
bRet = FALSE;
}
break;
case HWPWR_TV_OFF:
dwIPIndex = PWR_IP_TVENC; // Power Off TV Encoder
if ( !DeviceIoControl(pCtxt->hPowerControl, IOCTL_PWRCON_SET_POWER_OFF, &dwIPIndex, sizeof(DWORD), NULL, 0, &dwBytes, NULL) )
{
VDE_ERR((_T("[VDE:ERR] SVE_hw_power_control() : IOCTL_PWRCON_SET_POWER_OFF Failed\n\r")));
bRet = FALSE;
}
dwIPIndex = PWR_IP_TVSC; // Power Off TV Scaler
if ( !DeviceIoControl(pCtxt->hPowerControl, IOCTL_PWRCON_SET_POWER_OFF, &dwIPIndex, sizeof(DWORD), NULL, 0, &dwBytes, NULL) )
{
VDE_ERR((_T("[VDE:ERR] SVE_hw_power_control() : IOCTL_PWRCON_SET_POWER_OFF Failed\n\r")));
bRet = FALSE;
}
break;
case HWPWR_2D_ON:
dwIPIndex = PWR_IP_2D; // Power On FIMG 2D
if ( !DeviceIoControl(pCtxt->hPowerControl, IOCTL_PWRCON_SET_POWER_ON, &dwIPIndex, sizeof(DWORD), NULL, 0, &dwBytes, NULL) )
{
VDE_ERR((_T("[VDE:ERR] SVE_hw_power_control() : IOCTL_PWRCON_SET_POWER_ON Failed\n\r")));
bRet = FALSE;
}
break;
case HWPWR_2D_OFF:
dwIPIndex = PWR_IP_2D; // Power Off FIMG 2D
if ( !DeviceIoControl(pCtxt->hPowerControl, IOCTL_PWRCON_SET_POWER_OFF, &dwIPIndex, sizeof(DWORD), NULL, 0, &dwBytes, NULL) )
{
VDE_ERR((_T("[VDE:ERR] SVE_hw_power_control() : IOCTL_PWRCON_SET_POWER_OFF Failed\n\r")));
bRet = FALSE;
}
break;
default:
VDE_ERR((_T("[VDE:ERR] SVE_hw_power_control() : Unknown Parameter = %d\n\r"), eParams));
break;
}
VDE_MSG((_T("[VDE] --SVE_hw_power_control()\n\r")));
return bRet;
}
BOOL SVE_hw_clock_control(HWCLK_GATING eParams)
{
SVEngineContext *pCtxt;
BOOL bRet = TRUE;
VDE_MSG((_T("[VDE] ++SVE_hw_clock_control(%d)\r\n"), eParams));
pCtxt = SVE_get_context();
switch(eParams)
{
case HWCLK_ALL_ON:
pCtxt->pSysConReg->HCLK_GATE |= (1<<15) // MSM I/F
|(1<<9) // TV Scaler
|(1<<8) // 2D
|(1<<7) // TV Encoder
|(1<<5) // Post Processor
|(1<<4) // Image Rotator
|(1<<3); // Display Controller
pCtxt->pSysConReg->SCLK_GATE |= (1<<19) // DAC 27MHz
|(1<<18) // TV Encoder 27MHz
//|(1<<17) // TV Scaler 27MHz
|(1<<16) // TV Scaler
|(1<<15) // Display Controller 27MHz
|(1<<14) // Display Controller
//|(1<<13) // Post Processor 1 27MHz
//|(1<<12) // Post Processor 0 27MHz
//|(1<<11) // Post Processor 1
|(1<<10); // Post Processor 0
break;
case HWCLK_ALL_OFF:
pCtxt->pSysConReg->HCLK_GATE &= ~((1<<15)|/*(1<<9)| */(1<<8)|(1<<7)|(1<<5)|(1<<4)|(1<<3));
pCtxt->pSysConReg->SCLK_GATE &= ~((1<<19)|(1<<18)|(1<<16)|(1<<15)|(1<<14)|(1<<10));
break;
case HWCLK_DISPLAY_ON:
pCtxt->pSysConReg->HCLK_GATE |= (1<<15) // MSM I/F
|(1<<3); // Display Controller
pCtxt->pSysConReg->SCLK_GATE |= (1<<14); // Display Controller
break;
case HWCLK_DISPLAY_OFF:
pCtxt->pSysConReg->HCLK_GATE &= ~((1<<15)|(1<<3));
pCtxt->pSysConReg->SCLK_GATE &= ~(1<<14);
break;
case HWCLK_MSMIF_ON:
pCtxt->pSysConReg->HCLK_GATE |= (1<<15); // MSM I/F
break;
case HWCLK_MSMIF_OFF:
pCtxt->pSysConReg->HCLK_GATE &= ~(1<<15); // MSM I/F
break;
case HWCLK_POST_ON:
pCtxt->pSysConReg->HCLK_GATE |= (1<<5); // Post Processor
pCtxt->pSysConReg->SCLK_GATE |= (1<<10); // Post Processor 0
break;
case HWCLK_POST_OFF:
pCtxt->pSysConReg->HCLK_GATE &= ~(1<<5); // Post Processor
pCtxt->pSysConReg->SCLK_GATE &= ~(1<<10); // Post Processor 0
break;
case HWCLK_ROTATOR_ON:
pCtxt->pSysConReg->HCLK_GATE |= (1<<4); // Image Rotator
break;
case HWCLK_ROTATOR_OFF:
pCtxt->pSysConReg->HCLK_GATE &= ~(1<<4); // Image Rotator
break;
case HWCLK_TV_ON:
pCtxt->pSysConReg->HCLK_GATE |= (1<<9) // TV Scaler
|(1<<7); // TV Encoder
pCtxt->pSysConReg->SCLK_GATE |= (1<<19) // DAC 27MHz
|(1<<18) // TV Encoder 27MHz
|(1<<16) // TV Scaler
|(1<<15); // Display Controller 27MHz
break;
case HWCLK_TV_OFF:
pCtxt->pSysConReg->HCLK_GATE &= ~((1<<9)|(1<<7));
pCtxt->pSysConReg->SCLK_GATE &= ~((1<<19)|(1<<18)|(1<<16)|(1<<15));
break;
case HWCLK_2D_ON:
pCtxt->pSysConReg->HCLK_GATE |= (1<<8); // FIMG 2D
break;
case HWCLK_2D_OFF:
pCtxt->pSysConReg->HCLK_GATE &= ~(1<<8); // FIMG 2D
break;
default:
VDE_ERR((_T("[VDE:ERR] SVE_hw_clock_control() : Unknown Parameter = %d\n\r"), eParams));
bRet = FALSE;
break;
}
VDE_MSG((_T("[VDE] --SVE_hw_clock_control()\n\r")));
return bRet;
}
BOOL SVE_map_device_address(void)
{
SVEngineContext *pCtxt;
PHYSICAL_ADDRESS ioPhysicalBase = { 0,0};
VDE_MSG((_T("[VDE] ++%s\r\n"),__func__));
pCtxt = SVE_get_context();
// Translate to System Address.
ioPhysicalBase.LowPart = S3C6410_BASE_REG_PA_DISPLAY;
pCtxt->pDispConReg = (S3C6410_DISPLAY_REG *)MmMapIoSpace(ioPhysicalBase, sizeof(S3C6410_DISPLAY_REG), FALSE);
if (pCtxt->pDispConReg == NULL)
{
goto CleanUp;
}
ioPhysicalBase.LowPart = S3C6410_BASE_REG_PA_POST;
pCtxt->pPostReg = (S3C6410_POST_REG *)MmMapIoSpace(ioPhysicalBase, sizeof(S3C6410_POST_REG), FALSE);
if (pCtxt->pPostReg == NULL)
{
goto CleanUp;
}
ioPhysicalBase.LowPart = S3C6410_BASE_REG_PA_ROTATOR;
pCtxt->pRotatorReg = (S3C6410_ROTATOR_REG *)MmMapIoSpace(ioPhysicalBase, sizeof(S3C6410_ROTATOR_REG), FALSE);
if (pCtxt->pRotatorReg == NULL)
{
goto CleanUp;
}
ioPhysicalBase.LowPart = S3C6410_BASE_REG_PA_TVSC;
pCtxt->pTVSCReg = (S3C6410_TVSC_REG *)MmMapIoSpace(ioPhysicalBase, sizeof(S3C6410_TVSC_REG), FALSE);
if (pCtxt->pTVSCReg == NULL)
{
goto CleanUp;
}
ioPhysicalBase.LowPart = S3C6410_BASE_REG_PA_TVENC;
pCtxt->pTVEncReg = (S3C6410_TVENC_REG *)MmMapIoSpace(ioPhysicalBase, sizeof(S3C6410_TVENC_REG), FALSE);
if (pCtxt->pTVEncReg == NULL)
{
goto CleanUp;
}
ioPhysicalBase.LowPart = S3C6410_BASE_REG_PA_MSMIF_SFR;
pCtxt->pMSMIFReg = (S3C6410_MSMIF_REG *)MmMapIoSpace(ioPhysicalBase, sizeof(S3C6410_MSMIF_REG), FALSE);
if (pCtxt->pMSMIFReg == NULL)
{
goto CleanUp;
}
ioPhysicalBase.LowPart = S3C6410_BASE_REG_PA_SYSCON;
pCtxt->pSysConReg = (S3C6410_SYSCON_REG *)MmMapIoSpace(ioPhysicalBase, sizeof(S3C6410_SYSCON_REG), FALSE);
if (pCtxt->pSysConReg == NULL)
{
goto CleanUp;
}
ioPhysicalBase.LowPart = S3C6410_BASE_REG_PA_GPIO;
pCtxt->pGPIOReg = (S3C6410_GPIO_REG *)MmMapIoSpace(ioPhysicalBase, sizeof(S3C6410_GPIO_REG), FALSE);
if (pCtxt->pGPIOReg == NULL)
{
goto CleanUp;
}
ioPhysicalBase.LowPart = S3C6410_BASE_REG_PA_SPI0;
pCtxt->pSPIReg = (S3C6410_SPI_REG *)MmMapIoSpace(ioPhysicalBase, sizeof(S3C6410_SPI_REG), FALSE);
if (pCtxt->pSPIReg == NULL)
{
goto CleanUp;
}
VDE_MSG((_T("[VDE] --%s\r\n"),__func__));
return TRUE;
CleanUp:
VDE_ERR((_T("[VDE:ERR] --%s : Failed, ioPhysicalBase(0x%x,0x%x)\r\n"), _T(__FUNCTION__), ioPhysicalBase.LowPart, ioPhysicalBase.HighPart));
return FALSE;
}
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_Rotator_API_Proc(
DWORD hOpenContext,
DWORD dwCode,
PBYTE pBufIn,
DWORD dwLenIn,
PBYTE pBufOut,
DWORD dwLenOut,
PDWORD pdwActualOut
)
{
SVEngineContext *pCtxt;
SVEnginePowerContext *pPMCtxt;
BOOL bRet = TRUE;
VDE_MSG((_T("[VDE] ++SVE_Rotator_API_Proc()\n\r")));
pCtxt = SVE_get_context();
pPMCtxt = SVE_get_power_context();
//-------------------------------------------------------------
// Check OpenContext of Caller have the right to access to H/W Resource
//-------------------------------------------------------------
switch(dwCode)
{
case SVE_ROTATOR_SET_OPERATION_PARAM:
case SVE_ROTATOR_SET_SOURCE_BUFFER:
case SVE_ROTATOR_SET_DESTINATION_BUFFER:
case SVE_ROTATOR_SET_OPERATION_START:
case SVE_ROTATOR_SET_OPERATION_STOP:
case SVE_ROTATOR_WAIT_OPERATION_DONE:
case SVE_ROTATOR_GET_STATUS:
bRet = SVE_resource_compare_Rotator(hOpenContext);
if (!bRet)
{
VDE_ERR((_T("[VDE:ERR] SVE_Rotator_API_Proc(0x%08x) : No Right to Access to H/W Resource\r\n"), dwCode));
goto CleanUp;
}
break;
default:
DEBUGMSG(VDE_ZONE_ERROR, (TEXT("[VDE:ERR] Invalid IOCTL code\n")));
bRet = FALSE;
goto CleanUp;
}
//--------------------------------
// Processing IOCTL for Image Rotator
//--------------------------------
switch(dwCode)
{
case SVE_ROTATOR_SET_OPERATION_PARAM:
{
SVEARG_ROTATOR_PARAMETER *pArg;
VDE_MSG((_T("[VDE] SVE_Rotator_API_Proc() : SVE_ROTATOR_SET_OPERATION_PARAM\n\r")));
if(!pBufIn || dwLenIn < sizeof(SVEARG_ROTATOR_PARAMETER))
{
DEBUGMSG(VDE_ZONE_ERROR,(TEXT("Invalid Parameter : pBufIn:0x%x Length:%d\n"), pBufIn, dwLenIn));
bRet = FALSE;
break;
}
pArg = (SVEARG_ROTATOR_PARAMETER *)pBufIn;
if (pPMCtxt->bPowerOn)
{
if (pCtxt->bRotatorBusy) // Check Rotator Running
{
VDE_ERR((_T("[VDE:ERR] SVE_Rotator_API_Proc() : SVE_ROTATOR_SET_OPERATION_PARAM : Image Rotator is Running\n\r")));
bRet = FALSE;
break;
}
Rotator_initialize(pArg->dwImgFormat, pArg->dwOpType, pArg->dwSrcWidth, pArg->dwSrcHeight);
}
// Backup for PM
memcpy(&pPMCtxt->tRotatorParam, pArg, sizeof(SVEARG_ROTATOR_PARAMETER));
break;
}
case SVE_ROTATOR_SET_SOURCE_BUFFER:
{
SVEARG_ROTATOR_BUFFER *pArg;
VDE_MSG((_T("[VDE] SVE_Rotator_API_Proc() : SVE_ROTATOR_SET_SOURCE_BUFFER\n\r")));
if(!pBufIn || dwLenIn < sizeof(SVEARG_ROTATOR_BUFFER))
{
DEBUGMSG(VDE_ZONE_ERROR,(TEXT("Invalid Parameter : pBufIn:0x%x Length:%d\n"), pBufIn, dwLenIn));
bRet = FALSE;
break;
}
pArg = (SVEARG_ROTATOR_BUFFER *)pBufIn;
if (pPMCtxt->bPowerOn)
{
if (pCtxt->bRotatorBusy) // Check Rotator Running
{
VDE_ERR((_T("[VDE:ERR] SVE_Rotator_API_Proc() : SVE_ROTATOR_SET_SOURCE_BUFFER : Image Rotator is Running\n\r")));
bRet = FALSE;
break;
}
Rotator_set_source_buffer(pArg->dwBufferRGBY, pArg->dwBufferCb, pArg->dwBufferCr);
}
// Backup for PM
memcpy(&pPMCtxt->tRotatorSrcBuffer, pArg, sizeof(SVEARG_ROTATOR_BUFFER));
pPMCtxt->bRotatorSrcBuffer = TRUE;
break;
}
case SVE_ROTATOR_SET_DESTINATION_BUFFER:
{
SVEARG_ROTATOR_BUFFER *pArg;
VDE_MSG((_T("[VDE] SVE_Rotator_API_Proc() : SVE_ROTATOR_SET_DESTINATION_BUFFER\n\r")));
if(!pBufIn || dwLenIn < sizeof(SVEARG_ROTATOR_BUFFER))
{
DEBUGMSG(VDE_ZONE_ERROR,(TEXT("Invalid Parameter : pBufIn:0x%x Length:%d\n"), pBufIn, dwLenIn));
bRet = FALSE;
break;
}
pArg = (SVEARG_ROTATOR_BUFFER *)pBufIn;
if (pPMCtxt->bPowerOn)
{
if (pCtxt->bRotatorBusy) // Check Rotator Running
{
VDE_ERR((_T("[VDE:ERR] SVE_Rotator_API_Proc() : SVE_ROTATOR_SET_DESTINATION_BUFFER : Image Rotator is Running\n\r")));
bRet = FALSE;
break;
}
Rotator_set_destination_buffer(pArg->dwBufferRGBY, pArg->dwBufferCb, pArg->dwBufferCr);
}
// Backup for PM
memcpy(&pPMCtxt->tRotatorDstBuffer, pArg, sizeof(SVEARG_ROTATOR_BUFFER));
pPMCtxt->bRotatorDstBuffer = TRUE;
break;
}
case SVE_ROTATOR_SET_OPERATION_START:
{
VDE_MSG((_T("[VDE] SVE_Rotator_API_Proc() : SVE_ROTATOR_SET_OPERATION_START\n\r")));
if (pPMCtxt->bPowerOn)
{
if (pCtxt->bRotatorBusy) // Check Rotator Running
{
VDE_ERR((_T("[VDE:ERR] SVE_Rotator_API_Proc() : SVE_ROTATOR_SET_OPERATION_START : Image Rotator is Running\n\r")));
bRet = FALSE;
break;
}
// Image Rotator Status Flag
pCtxt->bRotatorBusy = TRUE;
Rotator_enable_interrupt();
Rotator_start();
}
// Backup for PM
pPMCtxt->bRotatorStart = TRUE;
break;
}
case SVE_ROTATOR_SET_OPERATION_STOP:
{
VDE_MSG((_T("[VDE] SVE_Rotator_API_Proc() : SVE_ROTATOR_SET_OPERATION_STOP\n\r")));
if (pPMCtxt->bPowerOn)
{
if (pCtxt->bRotatorBusy) // Check Rotator Running
{
if (WAIT_TIMEOUT == SVE_wait_rotator_finish())
{
if (pCtxt->bRotatorBusy == FALSE)
{
// Time Out, But Rotator Finished...
VDE_MSG((_T("[VDE] SVE_Rotator_API_Proc() : SVE_ROTATOR_SET_OPERATION_STOP : SVE_wait_rotator_finish() TimeOut, But Rotator Finished\n\r")));
}
else
{
VDE_ERR((_T("[VDE:ERR] SVE_Rotator_API_Proc() : SVE_ROTATOR_SET_OPERATION_STOP : SVE_wait_rotator_finish() TimeOut\n\r")));
bRet = FALSE;
}
}
}
else
{
VDE_MSG((_T("[VDE] SVE_Rotator_API_Proc() : SVE_ROTATOR_SET_OPERATION_START : Image Rotator Already Stopped\n\r")));
}
}
// Backup for PM
pPMCtxt->bRotatorStart = FALSE;
break;
}
case SVE_ROTATOR_WAIT_OPERATION_DONE: // Actually Same with SVE_ROTATOR_SET_OPERATION_STOP API
{
VDE_MSG((_T("[VDE] SVE_Rotator_API_Proc() : SVE_ROTATOR_WAIT_OPERATION_DONE\n\r")));
if (pPMCtxt->bPowerOn)
{
if (pCtxt->bRotatorBusy) // Check Rotator Running
{
if (WAIT_TIMEOUT == SVE_wait_rotator_finish())
{
if (pCtxt->bRotatorBusy == FALSE)
{
// Time Out, But Rotator Finished...
VDE_MSG((_T("[VDE] SVE_Rotator_API_Proc() : SVE_ROTATOR_SET_OPERATION_STOP : SVE_wait_rotator_finish() TimeOut, But Rotator Finished\n\r")));
}
else
{
VDE_ERR((_T("[VDE:ERR] SVE_Rotator_API_Proc() : SVE_ROTATOR_SET_OPERATION_STOP : SVE_wait_rotator_finish() TimeOut\n\r")));
bRet = FALSE;
}
}
}
else
{
VDE_MSG((_T("[VDE] SVE_Rotator_API_Proc() : SVE_ROTATOR_WAIT_OPERATION_DONE : Image Rotator Already Stopped\n\r")));
}
}
// Backup for PM
pPMCtxt->bRotatorStart = FALSE;
break;
}
case SVE_ROTATOR_GET_STATUS:
VDE_ERR((_T("[VDE:ERR] SVE_Rotator_API_Proc() : SVE_ROTATOR_GET_STATUS : Not Implemented Yet...\n\r")));
bRet = FALSE;
break;
default: // This is filtered above switch statement
bRet = FALSE;
break;
}
CleanUp:
VDE_MSG((_T("[VDE] --SVE_Rotator_API_Proc()\n\r")));
return bRet;
}
BOOL SVE_TVScaler_API_Proc(
DWORD hOpenContext,
DWORD dwCode,
PBYTE pBufIn,
DWORD dwLenIn,
PBYTE pBufOut,
DWORD dwLenOut,
PDWORD pdwActualOut
)
{
SVEngineContext *pCtxt;
SVEnginePowerContext *pPMCtxt;
BOOL bRet = TRUE;
//VDE_MSG((_T("[VDE] SVE_TVScaler_API_Proc(0x%08x, 0x%08x, 0x%08x, 0x%08x, 0x%08x, 0x%08x, 0x%08x)\r\n"),
// hOpenContext, dwCode, pBufIn, dwLenIn, pBufOut, dwLenOut, pdwActualOut));
VDE_MSG((_T("[VDE] ++SVE_TVScaler_API_Proc()\n\r")));
pCtxt = SVE_get_context();
pPMCtxt = SVE_get_power_context();
//-------------------------------------------------------------
// Check OpenContext of Caller have the right to access to H/W Resource
//-------------------------------------------------------------
switch(dwCode)
{
case SVE_TVSC_SET_PROCESSING_PARAM:
case SVE_TVSC_SET_SOURCE_BUFFER:
case SVE_TVSC_SET_NEXT_SOURCE_BUFFER:
case SVE_TVSC_SET_DESTINATION_BUFFER:
case SVE_TVSC_SET_NEXT_DESTINATION_BUFFER:
case SVE_TVSC_SET_PROCESSING_START:
case SVE_TVSC_SET_PROCESSING_STOP:
case SVE_TVSC_WAIT_PROCESSING_DONE:
case SVE_TVSC_GET_PROCESSING_STATUS:
bRet = SVE_resource_compare_TVScaler_TVEncoder(hOpenContext);
if (!bRet)
{
VDE_ERR((_T("[VDE:ERR] SVE_TVScaler_API_Proc(0x%08x) : No Right to Access to H/W Resource\r\n"), dwCode));
goto CleanUp;
}
break;
default:
bRet = FALSE;
DEBUGMSG(VDE_ZONE_ERROR, (TEXT("[VDE:ERR] Invalid IOCTL code\n")));
goto CleanUp;
break;
}
//--------------------------------
// Processing IOCTL for TV Scaler
//--------------------------------
switch(dwCode)
{
case SVE_TVSC_SET_PROCESSING_PARAM:
{
SVEARG_TVSC_PARAMETER *pArg;
VDE_MSG((_T("[VDE] SVE_TVScaler_API_Proc() : SVE_TVSC_SET_PROCESSING_PARAM\n\r")));
if(!pBufIn)
{
DEBUGMSG(VDE_ZONE_ERROR,(TEXT("Invalid Buffer : pBufIn:0x%x\n"), pBufIn));
bRet = FALSE;
break;
}
pArg = (SVEARG_TVSC_PARAMETER *)pBufIn;
if (pPMCtxt->bPowerOn)
{
if (TVSC_get_processing_state() == TVSC_BUSY) // TV Scaler Running
{
VDE_ERR((_T("[VDE:ERR] SVE_TVScaler_API_Proc() : SVE_TVSC_SET_PROCESSING_START : TV Scaler is Running\n\r")));
bRet = FALSE;
break;
}
TVSC_initialize(pArg->dwOpMode, pArg->dwScanMode,
pArg->dwSrcType, pArg->dwSrcBaseWidth, pArg->dwSrcBaseHeight, pArg->dwSrcWidth, pArg->dwSrcHeight, pArg->dwSrcOffsetX, pArg->dwSrcOffsetY,
pArg->dwDstType, pArg->dwDstBaseWidth, pArg->dwDstBaseHeight, pArg->dwDstWidth, pArg->dwDstHeight, pArg->dwDstOffsetX, pArg->dwDstOffsetY);
}
// Backup for PM
memcpy(&pPMCtxt->tTVSCParam, pArg, sizeof(SVEARG_TVSC_PARAMETER));
break;
}
case SVE_TVSC_SET_SOURCE_BUFFER:
{
SVEARG_TVSC_BUFFER *pArg;
VDE_MSG((_T("[VDE] SVE_TVScaler_API_Proc() : SVE_TVSC_SET_SOURCE_BUFFER\n\r")));
pArg = (SVEARG_TVSC_BUFFER *)pBufIn;
if (pPMCtxt->bPowerOn)
{
if (TVSC_get_processing_state() == TVSC_BUSY) // TV Scaler Running
{
VDE_ERR((_T("[VDE:ERR] SVE_TVScaler_API_Proc() : SVE_TVSC_SET_SOURCE_BUFFER : TV Scaler is Running\n\r")));
bRet = FALSE;
break;
}
TVSC_set_source_buffer(pArg->dwBufferRGBY, pArg->dwBufferCb, pArg->dwBufferCr);
}
// Backup for PM
memcpy(&pPMCtxt->tTVSCSrcBuffer, pArg, sizeof(SVEARG_TVSC_BUFFER));
pPMCtxt->bTVSCSrcBuffer = TRUE;
break;
}
case SVE_TVSC_SET_NEXT_SOURCE_BUFFER:
{
SVEARG_TVSC_BUFFER *pArg;
VDE_MSG((_T("[VDE] SVE_TVScaler_API_Proc() : SVE_TVSC_SET_NEXT_SOURCE_BUFFER\n\r")));
pArg = (SVEARG_TVSC_BUFFER *)pBufIn;
if (pPMCtxt->bPowerOn)
{
if (TVSC_get_processing_state() == TVSC_BUSY) // TV Scaler Running
{
BOOL bRetry = TRUE;
while(bRetry)
{
if (pCtxt->TVSCCmdCtxt.bCmdSetSrcBuffer == FALSE)
{
EnterCriticalSection(&pCtxt->TVSCCmdCtxt.csCmd);
// We can change buffer address here...
// But, after interrupt occurs, It can take effect..
TVSC_set_next_source_buffer(pArg->dwBufferRGBY, pArg->dwBufferCb, pArg->dwBufferCr);
pCtxt->TVSCCmdCtxt.bCmdSetSrcBuffer = TRUE;
bRetry = FALSE;
LeaveCriticalSection(&pCtxt->TVSCCmdCtxt.csCmd);
}
if (bRetry || pArg->bWaitForVSync)
{
if (WAIT_TIMEOUT == SVE_wait_tvsc_cmd_done())
{
VDE_ERR((_T("[VDE:ERR] SVE_TVScaler_API_Proc() : SVE_TVSC_SET_NEXT_SOURCE_BUFFER : SVE_wait_tvsc_cmd_done() TimeOut\n\r")));
bRetry = FALSE;
bRet = FALSE;
}
}
}
}
else
{
TVSC_set_next_source_buffer(pArg->dwBufferRGBY, pArg->dwBufferCb, pArg->dwBufferCr);
}
}
// Backup for PM
memcpy(&pPMCtxt->tTVSCSrcBuffer, pArg, sizeof(SVEARG_TVSC_BUFFER));
pPMCtxt->bTVSCSrcBuffer = TRUE;
break;
}
case SVE_TVSC_SET_DESTINATION_BUFFER:
{
SVEARG_TVSC_BUFFER *pArg;
VDE_MSG((_T("[VDE] SVE_TVScaler_API_Proc() : SVE_TVSC_SET_DESTINATION_BUFFER\n\r")));
pArg = (SVEARG_TVSC_BUFFER *)pBufIn;
if (pPMCtxt->bPowerOn)
{
if (TVSC_get_processing_state() == TVSC_BUSY) // TV Scaler Running
{
VDE_ERR((_T("[VDE:ERR] SVE_TVScaler_API_Proc() : SVE_TVSC_SET_DESTINATION_BUFFER : TV Scaler is Running\n\r")));
bRet = FALSE;
break;
}
TVSC_set_destination_buffer(pArg->dwBufferRGBY, pArg->dwBufferCb, pArg->dwBufferCr);
}
// Backup for PM
memcpy(&pPMCtxt->tTVSCDstBuffer, pArg, sizeof(SVEARG_TVSC_BUFFER));
pPMCtxt->bTVSCDstBuffer = TRUE;
break;
}
case SVE_TVSC_SET_NEXT_DESTINATION_BUFFER:
{
SVEARG_TVSC_BUFFER *pArg;
VDE_MSG((_T("[VDE] SVE_TVScaler_API_Proc() : SVE_TVSC_SET_NEXT_DESTINATION_BUFFER\n\r")));
pArg = (SVEARG_TVSC_BUFFER *)pBufIn;
if (pPMCtxt->bPowerOn)
{
if (TVSC_get_processing_state() == TVSC_BUSY) // TV Scaler Running
{
BOOL bRetry = TRUE;
while(bRetry)
{
if (pCtxt->TVSCCmdCtxt.bCmdSetDstBuffer == FALSE)
{
EnterCriticalSection(&pCtxt->TVSCCmdCtxt.csCmd);
// We can change buffer address here...
// But, after interrupt occurs, It can take effect..
TVSC_set_next_destination_buffer(pArg->dwBufferRGBY, pArg->dwBufferCb, pArg->dwBufferCr);
pCtxt->TVSCCmdCtxt.bCmdSetDstBuffer = TRUE;
bRetry = FALSE;
LeaveCriticalSection(&pCtxt->TVSCCmdCtxt.csCmd);
}
if (bRetry || pArg->bWaitForVSync)
{
if (WAIT_TIMEOUT == SVE_wait_tvsc_cmd_done())
{
VDE_ERR((_T("[VDE:ERR] SVE_TVScaler_API_Proc() : SVE_TVSC_SET_NEXT_DESTINATION_BUFFER : SVE_wait_tvsc_cmd_done() TimeOut\n\r")));
bRetry = FALSE;
bRet = FALSE;
}
}
}
}
else
{
TVSC_set_next_destination_buffer(pArg->dwBufferRGBY, pArg->dwBufferCb, pArg->dwBufferCr);
}
}
// Backup for PM
memcpy(&pPMCtxt->tTVSCDstBuffer, pArg, sizeof(SVEARG_TVSC_BUFFER));
pPMCtxt->bTVSCDstBuffer = TRUE;
break;
}
case SVE_TVSC_SET_PROCESSING_START:
{
VDE_MSG((_T("[VDE] SVE_TVScaler_API_Proc() : SVE_TVSC_SET_PROCESSING_START\n\r")));
if (pPMCtxt->bPowerOn)
{
if (TVSC_get_processing_state() == TVSC_BUSY) // TV Scaler Running
{
VDE_ERR((_T("[VDE:ERR] SVE_TVScaler_API_Proc() : SVE_TVSC_SET_PROCESSING_START : TV Scaler is Running\n\r")));
bRet = FALSE;
break;
}
TVSC_enable_interrupt();
TVSC_processing_start();
}
// Backup for PM
pPMCtxt->bTVSCStart = TRUE;
break;
}
case SVE_TVSC_SET_PROCESSING_STOP:
{
VDE_MSG((_T("[VDE] SVE_TVScaler_API_Proc() : SVE_TVSC_SET_PROCESSING_STOP\n\r")));
if (pPMCtxt->bPowerOn)
{
TVSC_autoload_disable();
if (TVSC_get_processing_state() == TVSC_BUSY) // TV Scaler Running
{
// Wait for Current Frame Finished
if (WAIT_TIMEOUT == SVE_wait_tvsc_cmd_done())
{
if (TVSC_get_processing_state() == TVSC_IDLE)
{
// Time Out, But TV Scaler Finished
VDE_MSG((_T("[VDE] SVE_TVScaler_API_Proc() : SVE_TVSC_SET_PROCESSING_STOP : SVE_wait_tvsc_cmd_done() TimeOut, But TV Scaler Finished\n\r")));
}
else
{
VDE_INF((_T("[VDE:INF] SVE_TVScaler_API_Proc() : SVE_TVSC_SET_PROCESSING_STOP : SVE_wait_tvsc_cmd_done() TimeOut\n\r")));
TVSC_processing_stop();
}
}
}
}
// Backup for PM
pPMCtxt->bTVSCStart = FALSE;
break;
}
case SVE_TVSC_WAIT_PROCESSING_DONE:
{
VDE_MSG((_T("[VDE] SVE_TVScaler_API_Proc() : SVE_TVSC_WAIT_PROCESSING_DONE\n\r")));
if (pPMCtxt->bPowerOn)
{
if (TVSC_get_processing_state() == TVSC_BUSY) // TV Scaler Running
{
if (WAIT_TIMEOUT == SVE_wait_tvsc_cmd_done())
{
if (TVSC_get_processing_state() == TVSC_IDLE)
{
// Time Out, But TV Scaler Finished
VDE_MSG((_T("[VDE] SVE_TVScaler_API_Proc() : SVE_TVSC_WAIT_PROCESSING_DONE : SVE_wait_tvsc_cmd_done() TimeOut, But TV Scaler Finished\n\r")));
}
else
{
VDE_INF((_T("[VDE:INF] SVE_TVScaler_API_Proc() : SVE_TVSC_WAIT_PROCESSING_DONE : SVE_wait_tvsc_cmd_done() TimeOut\n\r")));
bRet = FALSE;
}
}
}
}
// Backup for PM
pPMCtxt->bTVSCStart = FALSE;
break;
}
case SVE_TVSC_GET_PROCESSING_STATUS:
{
DWORD *pArg;
VDE_MSG((_T("[VDE] SVE_TVScaler_API_Proc() : SVE_TVSC_GET_PROCESSING_STATUS\n\r")));
pArg = (DWORD *)pBufOut;
if (pPMCtxt->bPowerOn)
{
*pArg = TVSC_get_processing_state();
}
else
{
*pArg = TVSC_IDLE;
}
*pdwActualOut = sizeof(DWORD);
break;
}
default: // This is filtered above switch statement
bRet = FALSE;
break;
}
CleanUp:
VDE_MSG((_T("[VDE] --SVE_TVScaler_API_Proc()\n\r")));
return bRet;
}
BOOL SVE_Resource_API_Proc(
DWORD hOpenContext,
DWORD dwCode,
PBYTE pBufIn,
DWORD dwLenIn,
PBYTE pBufOut,
DWORD dwLenOut,
PDWORD pdwActualOut
)
{
BOOL bRet = TRUE;
VDE_MSG((_T("[VDE] ++SVE_Resource_API_Proc()\n\r")));
switch(dwCode)
{
case SVE_RSC_REQUEST_FIMD_INTERFACE:
bRet = SVE_resource_request_FIMD_interface(hOpenContext);
break;
case SVE_RSC_RELEASE_FIMD_INTERFACE:
bRet = SVE_resource_release_FIMD_interface(hOpenContext);
break;
case SVE_RSC_REQUEST_FIMD_WIN0:
bRet = SVE_resource_request_FIMD_window(DISP_WIN0, hOpenContext);
break;
case SVE_RSC_RELEASE_FIMD_WIN0:
bRet = SVE_resource_release_FIMD_window(DISP_WIN0, hOpenContext);
break;
case SVE_RSC_REQUEST_FIMD_WIN1:
bRet = SVE_resource_request_FIMD_window(DISP_WIN1, hOpenContext);
break;
case SVE_RSC_RELEASE_FIMD_WIN1:
bRet = SVE_resource_release_FIMD_window(DISP_WIN1, hOpenContext);
break;
case SVE_RSC_REQUEST_FIMD_WIN2:
bRet = SVE_resource_request_FIMD_window(DISP_WIN2, hOpenContext);
break;
case SVE_RSC_RELEASE_FIMD_WIN2:
bRet = SVE_resource_release_FIMD_window(DISP_WIN2, hOpenContext);
break;
case SVE_RSC_REQUEST_FIMD_WIN3:
bRet = SVE_resource_request_FIMD_window(DISP_WIN3, hOpenContext);
break;
case SVE_RSC_RELEASE_FIMD_WIN3:
bRet = SVE_resource_release_FIMD_window(DISP_WIN3, hOpenContext);
break;
case SVE_RSC_REQUEST_FIMD_WIN4:
bRet = SVE_resource_request_FIMD_window(DISP_WIN4, hOpenContext);
break;
case SVE_RSC_RELEASE_FIMD_WIN4:
bRet = SVE_resource_release_FIMD_window(DISP_WIN4, hOpenContext);
break;
case SVE_RSC_REQUEST_POST:
bRet = SVE_resource_request_Post(hOpenContext);
break;
case SVE_RSC_RELEASE_POST:
bRet = SVE_resource_release_Post(hOpenContext);
break;
case SVE_RSC_REQUEST_ROTATOR:
bRet = SVE_resource_request_Rotator(hOpenContext);
break;
case SVE_RSC_RELEASE_ROTATOR:
bRet = SVE_resource_release_Rotator(hOpenContext);
break;
case SVE_RSC_REQUEST_TVSCALER_TVENCODER:
bRet = SVE_resource_request_TVScaler_TVEncoder(hOpenContext);
break;
case SVE_RSC_RELEASE_TVSCALER_TVENCODER:
bRet = SVE_resource_release_TVScaler_TVEncoder(hOpenContext);
break;
}
if (bRet == FALSE)
{
VDE_ERR((_T("[VDE:ERR] SVE_Resource_API_Proc() : dwCode[0x%08x] Failed\n\r")));
}
return bRet;
}
void SVE_unmap_device_address(void)
{
SVEngineContext *pCtxt;
VDE_MSG((_T("[VDE] ++SVE_unmap_device_address()\r\n")));
pCtxt = SVE_get_context();
if (pCtxt->pDispConReg != NULL)
{
MmUnmapIoSpace((PVOID)pCtxt->pDispConReg, sizeof(S3C6410_DISPLAY_REG));
pCtxt->pDispConReg = NULL;
}
if (pCtxt->pPostReg != NULL)
{
MmUnmapIoSpace((PVOID)pCtxt->pPostReg, sizeof(S3C6410_POST_REG));
pCtxt->pPostReg = NULL;
}
if (pCtxt->pRotatorReg != NULL)
{
MmUnmapIoSpace((PVOID)pCtxt->pRotatorReg, sizeof(S3C6410_ROTATOR_REG));
pCtxt->pRotatorReg = NULL;
}
if (pCtxt->pTVSCReg != NULL)
{
MmUnmapIoSpace((PVOID)pCtxt->pTVSCReg, sizeof(S3C6410_TVSC_REG));
pCtxt->pTVSCReg = NULL;
}
if (pCtxt->pTVEncReg != NULL)
{
MmUnmapIoSpace((PVOID)pCtxt->pTVEncReg, sizeof(S3C6410_TVENC_REG));
pCtxt->pTVEncReg = NULL;
}
if (pCtxt->pMSMIFReg != NULL)
{
MmUnmapIoSpace((PVOID)pCtxt->pMSMIFReg, sizeof(S3C6410_MSMIF_REG));
pCtxt->pMSMIFReg = NULL;
}
if (pCtxt->pSysConReg != NULL)
{
MmUnmapIoSpace((PVOID)pCtxt->pSysConReg, sizeof(S3C6410_SYSCON_REG));
pCtxt->pSysConReg = NULL;
}
if (pCtxt->pGPIOReg != NULL)
{
MmUnmapIoSpace((PVOID)pCtxt->pGPIOReg, sizeof(S3C6410_GPIO_REG));
pCtxt->pGPIOReg = NULL;
}
if (pCtxt->pSPIReg != NULL)
{
MmUnmapIoSpace((PVOID)pCtxt->pSPIReg, sizeof(S3C6410_SPI_REG));
pCtxt->pSPIReg = NULL;
}
VDE_MSG((_T("[VDE] --SVE_unmap_device_address()\r\n")));
}
void SVE_initialize_context(void)
{
SVEngineContext *pCtxt;
int iWinNum;
VDE_MSG((_T("[VDE] ++SVE_initialize_context()\r\n")));
pCtxt = SVE_get_context();
// Clear Context
memset(pCtxt, 0x0, sizeof(SVEngineContext));
pCtxt->dwSignature = SVE_DRIVER_SIGNITURE;
pCtxt->dwLastOpenContext = SVE_DRIVER_SIGNITURE;
pCtxt->dwSysIntrDisp = SYSINTR_UNDEFINED;
pCtxt->dwSysIntrPost = SYSINTR_UNDEFINED;
pCtxt->dwSysIntrTVSC = SYSINTR_UNDEFINED;
pCtxt->dwSysIntrRotator = SYSINTR_UNDEFINED;
pCtxt->hPowerControl = INVALID_HANDLE_VALUE;
// Critical Section for IOCTL
InitializeCriticalSection(&pCtxt->csProc);
// Display Controller Command Context
for (iWinNum = DISP_WIN0; iWinNum < DISP_WIN_MAX; iWinNum ++)
{
InitializeCriticalSection(&pCtxt->DispCmdCtxt[iWinNum].csCmd);
pCtxt->DispCmdCtxt[iWinNum].bCmdSetBuffer = FALSE;
pCtxt->DispCmdCtxt[iWinNum].bCmdSetPosition = FALSE;
}
// Post Processor Command Context
InitializeCriticalSection(&pCtxt->PostCmdCtxt.csCmd);
pCtxt->PostCmdCtxt.bCmdSetSrcBuffer = FALSE;
pCtxt->PostCmdCtxt.bCmdSetDstBuffer = FALSE;
// Local Path Command Context
InitializeCriticalSection(&pCtxt->LocalPathCmdCtxt.csCmd);
pCtxt->LocalPathCmdCtxt.bCmdSetWin0Enable = FALSE; // Depricated
pCtxt->LocalPathCmdCtxt.bCmdSetWin0Disable = FALSE;
pCtxt->LocalPathCmdCtxt.bCmdSetWin1Enable = FALSE; // Depricated
pCtxt->LocalPathCmdCtxt.bCmdSetWin1Disable = FALSE;
pCtxt->LocalPathCmdCtxt.bCmdSetWin2Enable = FALSE; // Depricated
pCtxt->LocalPathCmdCtxt.bCmdSetWin2Disable = FALSE;
// TV Scaler Command Context
InitializeCriticalSection(&pCtxt->TVSCCmdCtxt.csCmd);
pCtxt->TVSCCmdCtxt.bCmdSetSrcBuffer = FALSE;
pCtxt->TVSCCmdCtxt.bCmdSetDstBuffer = FALSE;
// Command Event
pCtxt->hDispCmdDone = CreateEvent(NULL, TRUE, FALSE, NULL); // Manual Reset, You should call ResetEvent() or use PulseEvent() Only
pCtxt->hPostCmdDone = CreateEvent(NULL, TRUE, FALSE, NULL); // Manual Reset, You should call ResetEvent() or use PulseEvent() Only
pCtxt->hTVSCCmdDone = CreateEvent(NULL, TRUE, FALSE, NULL); // Manual Reset, You should call ResetEvent() or use PulseEvent() Only
// Operation Finish Event
pCtxt->hRotatorFinish = CreateEvent(NULL, TRUE, FALSE, NULL); // Manual Reset, You should call ResetEvent() or use PulseEvent() Only
VDE_MSG((_T("[VDE] --SVE_initialize_context()\r\n")));
}
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;
}
