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; }