📄 control.cpp
字号:
SetLastError (ERROR_INVALID_PARAMETER); /* no in buffer or too small */
ulRetVal = ESC_FAILED;
break;
}
}
else
{
if(psRefreshStructIn->bFullRefresh)
{
bSingleShot=FALSE;
}
else
{
bSingleShot=TRUE;
}
byUpdateRate=(BYTE)psRefreshStructIn->ui32RefreshDelay;
m_clDisplay.PDP_ReducedRefresh(&byUpdateRate,&bSingleShot,FALSE);
}
break;
}
case DRVESC_ACTIVE_RECT:
{
PDRVESC_ACTIVERECT_STRUCT psActiveRectIn;
psActiveRectIn=(PDRVESC_ACTIVERECT_STRUCT)pvIn;
if(ulSizeIn==sizeof(*psActiveRectIn))
{
m_clDisplay.PDP_ActiveRectangle ((PPDP_ACTIVERECT)pvIn,psActiveRectIn->bGet);
}
ulRetVal = ESC_SUCCESS;
break;
}
case DRVESC_PIXCLK:
{
PDRVESC_PIXCLOCK_STRUCT psPixClkIn;
psPixClkIn=(PDRVESC_PIXCLOCK_STRUCT)pvIn;
if(ulSizeIn==sizeof(*psPixClkIn))
{
m_clDisplay.PDP_PixelClock ( &psPixClkIn->ui32PixClock,psPixClkIn->bGet);
}
ulRetVal = ESC_SUCCESS;
break;
}
case DRVESC_DIRTY:
{
PBOOL pbOut;
pbOut=(PBOOL)pvOut;
ulRetVal = ESC_SUCCESS;
if(ulSizeOut!=sizeof(PBOOL)|| (!pvOut))
{
SetLastError (ERROR_INVALID_PARAMETER); /* no in buffer or too small */
ulRetVal = ESC_FAILED;
}
else
m_clDisplay.PDP_IsScreenDirty(pbOut);
break;
}
case DRVESC_FORCE_EXTERNAL_SECONDARY_FULLSCREEN:
{
DRVESC_FORCE_SECONDARY_EXT *psOut;
DRVESC_FORCE_SECONDARY_EXT *psIn;
psOut=(DRVESC_FORCE_SECONDARY_EXT*) pvOut;
psIn=(DRVESC_FORCE_SECONDARY_EXT*)pvIn;
ulRetVal = ESC_SUCCESS;
if(ulSizeIn!=sizeof(DRVESC_FORCE_SECONDARY_EXT)|| (!pvIn))
{
SetLastError (ERROR_INVALID_PARAMETER); /* no in buffer or too small */
ulRetVal = ESC_FAILED;
}
else
{
if(psIn->bGet)
{
if(ulSizeOut!=sizeof(DRVESC_FORCE_SECONDARY_EXT)|| (!pvOut))
{
SetLastError (ERROR_INVALID_PARAMETER); /* no in buffer or too small */
ulRetVal = ESC_FAILED;
}
else
{
psOut->bState=m_bForceSecondaryExtFullscreen;
psOut->ui32RotationAngle=m_ui32SecondaryRotationAngle;
}
}
else
{
if(m_bDualScreenIfaceLocked)
{
m_bForceSecondaryExtFullscreen=psIn->bState;
m_ui32SecondaryRotationAngle=psIn->ui32RotationAngle;
}
else
{
SetLastError (ERROR_INVALID_PARAMETER); /* no in buffer or too small */
ulRetVal = ESC_FAILED;
}
}
}
break;
}
case DRVESC_ACQUIRE_DUALDISPLAY:
{
DRVESC_ACQUIRE_LOCK *psOut;
DRVESC_ACQUIRE_LOCK *psIn;
psOut=(DRVESC_ACQUIRE_LOCK*) pvOut;
psIn=(DRVESC_ACQUIRE_LOCK*)pvIn;
ulRetVal = ESC_SUCCESS;
if(ulSizeIn!=sizeof(DRVESC_ACQUIRE_LOCK)|| (!pvIn))
{
SetLastError (ERROR_INVALID_PARAMETER); /* no in buffer or too small */
ulRetVal = ESC_FAILED;
}
else
{
if(psIn->bAcquire)
{
if(ulSizeOut!=sizeof(DRVESC_ACQUIRE_LOCK)|| (!pvOut))
{
SetLastError (ERROR_INVALID_PARAMETER); /* no in buffer or too small */
ulRetVal = ESC_FAILED;
}
else
{
if(m_bDualScreenIfaceLocked)
{
psOut->bSuccess=FALSE;
}
else
{
m_bDualScreenIfaceLocked=TRUE;
psOut->bSuccess=TRUE;
}
break;
}
}
if(psIn->bRelease)
{
if(ulSizeOut!=sizeof(DRVESC_ACQUIRE_LOCK)|| (!pvOut))
{
SetLastError (ERROR_INVALID_PARAMETER); /* no in buffer or too small */
ulRetVal = ESC_FAILED;
}
else
{
if(!m_bDualScreenIfaceLocked)
{
psOut->bSuccess=FALSE;
}
else
{
m_bDualScreenIfaceLocked=FALSE;
psOut->bSuccess=TRUE;
}
break;
}
}
}
break;
}
case DRVESC_READREG:
{
PDWORD pdwIn,pdwOut;
pdwOut=(PDWORD)pvOut;
pdwIn=(PDWORD)pvIn;
ulRetVal = ESC_SUCCESS;
if( (ulSizeIn!=sizeof(PDWORD)) || (ulSizeOut!=sizeof(PDWORD)) || (pvIn==NULL) || (pvOut==NULL) )
{
SetLastError (ERROR_INVALID_PARAMETER); /* no in buffer or too small */
ulRetVal = ESC_FAILED;
}
else
{
PDWORD pdwRegs;
pdwRegs=(PDWORD)m_sDevData.psDevInfoKM->sDevLocation.pvRegsBaseKM;
*pdwOut=pdwRegs[(*pdwIn)/sizeof(DWORD)];
}
break;
}
case DRVESC_WRITEREG:
{
PDWORD pdwIn;
pdwIn=(PDWORD)pvIn;
ulRetVal = ESC_SUCCESS;
if( (ulSizeIn!=sizeof(PDWORD)) || (pvIn==NULL) )
{
SetLastError (ERROR_INVALID_PARAMETER); /* no in buffer or too small */
ulRetVal = ESC_FAILED;
}
else
{
PDWORD pdwRegs;
pdwRegs=(PDWORD)m_sDevData.psDevInfoKM->sDevLocation.pvRegsBaseKM;
pdwRegs[(pdwIn[0])/sizeof(DWORD)]=pdwIn[1];
}
break;
}
#endif
case DRVESC_BACKLIGHT:
{
ULONG ulBrightness;
PDRVESC_BACKLIGHT_PARAMS psBkLightIn = (PDRVESC_BACKLIGHT_PARAMS)pvIn;
PDRVESC_BACKLIGHT_PARAMS psBkLightOut = (PDRVESC_BACKLIGHT_PARAMS)pvOut;
if ( (ulSizeIn != sizeof(DRVESC_BACKLIGHT_PARAMS)) || !psBkLightIn)
{
SetLastError (ERROR_INVALID_PARAMETER); /* no in buffer or too small */
ulRetVal = ESC_FAILED;
}
else if ( (psBkLightIn->bGet) &&
((ulSizeOut != sizeof(DRVESC_BACKLIGHT_PARAMS)) || !psBkLightOut) )
{
SetLastError (ERROR_INVALID_PARAMETER); /* not out buffer or too small */
ulRetVal = ESC_FAILED;
}
else if ((psBkLightIn->bGet == FALSE) &&
(psBkLightIn->dwBrightness > 100))
{
SetLastError (ERROR_INVALID_PARAMETER); /* ulBrightness too big */
ulRetVal = ESC_FAILED;
}
else
{
ulBrightness = psBkLightIn->dwBrightness;
m_clDisplay.PDP_BacklightControl (&ulBrightness, psBkLightIn->bGet);
if (psBkLightIn->bGet)
{
psBkLightOut->dwBrightness = ulBrightness;
}
}
break;
}
#ifdef LOCAL_MEMORY_SELF_REFRESH
case DRVESC_LOCAL_MEMORY:
{
PPVRSRV_DEV_INFO psDevInfo = m_sDevData.psDevInfoKM;
PSYS_SPECIFIC_DATA pMSysData = (PSYS_SPECIFIC_DATA)psDevInfo->pvSysDataPtr;
PDRVESC_LOCAL_MEMORY_SETTINGS psMemIn = (PDRVESC_LOCAL_MEMORY_SETTINGS)pvIn;
PDRVESC_LOCAL_MEMORY_SETTINGS psMemOut = (PDRVESC_LOCAL_MEMORY_SETTINGS)pvOut;
ulRetVal = ESC_SUCCESS;
if ( (ulSizeIn != sizeof(DRVESC_LOCAL_MEMORY_SETTINGS)) || !psMemIn)
{
SetLastError (ERROR_INVALID_PARAMETER); /* no in buffer or too small */
ulRetVal = ESC_FAILED;
}
else if ( (psMemIn->dwFlags & LOCAL_MEMORY_SETTINGS_SET) )
{
if(psMemIn->dwFlags & LOCAL_MEMORY_SETTINGS_FEATURE)
{
IMG_BOOL b = psMemIn->bTurnOnFeature ? IMG_TRUE : IMG_FALSE;
pMSysData->bUseLocalMemorySelfRefresh = b;
}
if(psMemIn->dwFlags & LOCAL_MEMORY_SETTINGS_TIMEOUT)
{
pMSysData->uiLocalMemoryTimeout = psMemIn->dwTimeout;
if(pMSysData->uiLocalMemoryTimeout < LOCAL_MEMORY_MINIMUM_DELAY)
{
pMSysData->uiLocalMemoryTimeout = LOCAL_MEMORY_MINIMUM_DELAY;
}
}
}
else
{
if ((ulSizeOut != sizeof(DRVESC_LOCAL_MEMORY_SETTINGS) || !psMemOut) )
{
SetLastError (ERROR_INVALID_PARAMETER); /* not out buffer or too small */
ulRetVal = ESC_FAILED;
}
else
{
psMemOut->bTurnOnFeature = pMSysData->bUseLocalMemorySelfRefresh;
psMemOut->dwTimeout = pMSysData->uiLocalMemoryTimeout;
}
}
break;
}
#endif // LOCAL_MEMORY_SELF_REFRESH
case DRVESC_CONFIG_DISPLAYSYSTEM:
{
#ifdef SUPPORT_MARATHON_DEVICE
// Connect the LCD panels to the requested outputs.
DRVESC_CONFIG_DISPLAY_SYSTEM sCurrentConfig;
DRVESC_CONFIG_DISPLAY_SYSTEM *pNewConfig;
PDP_SETMODE sCurMode;
BOOL bRestore = TRUE;
ulRetVal = ESC_SUCCESS;
if( (ulSizeIn!=sizeof(DRVESC_CONFIG_DISPLAY_SYSTEM)) || (!pvIn))
{
SetLastError (ERROR_INVALID_PARAMETER); /* no in buffer or too small */
ulRetVal = ESC_FAILED;
}
else
{
// get the current configuration.
sCurrentConfig.bSet = IMG_FALSE;
m_clDisplay.PDP_ConfigureDisplaySystem(&sCurrentConfig);
// get the Current Mode
m_clDisplay.PDP_SetMode (&sCurMode, TRUE);
pNewConfig = (DRVESC_CONFIG_DISPLAY_SYSTEM *) pvIn;
if (pNewConfig->bSet)
{
if(!m_bDualScreenIfaceLocked)
{
SetLastError (ERROR_INVALID_PARAMETER); /* no in buffer or too small */
ulRetVal = ESC_FAILED;
break;
}
// Start doing some work.
if(m_clDisplay.PDP_ConfigureDisplaySystem(pNewConfig) == PDP_ERROR_OK)
{
// Ok the switchbar is setup, now we want to setup the surfaces!
// The Surface can either be a secondary (which has to be have been created already!)
// or a primary, which presumably has been set up already so use it's params
// PDP is connected to the desktop so use it's params which we have stashed around somewhere
if(pNewConfig->sConnectSurface.eSurface == PVR_DESKTOP)
{
PDP_SETMODE sSetMode;
MBXSurf *pPSurf = (MBXSurf *)m_pPrimarySurface;
if ((pNewConfig->sConnectSurface.ui32PhysRotation == 0) ||
(pNewConfig->sConnectSurface.ui32PhysRotation == 180))
{
sSetMode.wDisplayX = (WORD) m_nScreenWidth;
sSetMode.wDisplayY = (WORD) m_nScreenHeight;
}
else
{
sSetMode.wDisplayY = (WORD) m_nScreenWidth;
sSetMode.wDisplayX = (WORD) m_nScreenHeight;
}
sSetMode.wStride = (WORD) (sSetMode.wDisplayX * m_sModeInfo.Bpp) >> 3;
sSetMode.wBitsPerPixel = (WORD) m_sModeInfo.Bpp;
sSetMode.psMemInfo = ((MBXSurf*)m_pPrimarySurface)->GetMemInfo();
if(m_clDisplay.PDP_SetMode (&sSetMode, FALSE) == PDP_ERROR_OK)
{
m_ulScanLineLength = sSetMode.wStride;
pPSurf->SetStride(m_ulScanLineLength);
#ifdef ROTATE_ENABLE
if (pNewConfig->sConnectSurface.ui32PhysRotation == 270)
{
m_nScreenHeightSave = m_ulPhysicalScreenY = m_nScreenWidth;
m_nScreenWidthSave = m_ulPhysicalScreenX = m_nScreenHeight;
m_iRotate = DMDO_270;
pPSurf->m_bIsRotated = TRUE;
}
else if (pNewConfig->sConnectSurface.ui32PhysRotation == 180)
{
m_nScreenWidthSave = m_ulPhysicalScreenX = m_nScreenWidth;
m_nScreenHeightSave = m_ulPhysicalScreenY = m_nScreenHeight;
m_iRotate = DMDO_180;
pPSurf->m_bIsRotated = TRUE;
}
else if (pNewConfig->sConnectSurface.ui32PhysRotation == 90)
{
m_nScreenHeightSave = m_ulPhysicalScreenY = m_nScreenWidth;
m_nScreenWidthSave = m_ulPhysicalScreenX = m_nScreenHeight;
m_iRotate = DMDO_90;
pPSurf->m_bIsRotated = TRUE;
}
else
{
m_nScreenWidthSave = m_ulPhysicalScreenX = m_nScreenWidth;
m_nScreenHeightSave = m_ulPhysicalScreenY = m_nScreenHeight;
m_iRotate = DMDO_0;
pPSurf->m_bIsRotated = FALSE;
}
m_lPrimaryRotation = pNewConfig->sConnectSurface.ui32PhysRotation;
pPSurf->m_lRotationAngle = m_lPrimaryRotation;
pPSurf->SetRotation(m_nScreenWidth, m_nScreenHeight, m_iRotate);
/* adjust cursor rotation */
m_clDisplay.PDP_SetCursorRotation(m_iRotate);
#else
m_ulPhysicalScreenX = m_nScreenWidth;
m_ulPhysicalScreenY = m_nScreenHeight;
#endif /* ROTATE_ENABLE */
if(m_eSecondarySurfaceState == eSurfInUse)
{
m_eSecondarySurfaceState=eSurfAllocated;
}
bRestore = FALSE;
}
}
else if(pNewConfig->sConnectSurface.eSurface == PVR_SECONDARYSURFACE)
{
PDP_SETMODE sSetMode;
if(m_eSecondarySurfaceState == eSurfAllocated)
{
// For the timebeing we will use the current primary params.
// These need to be replaced with the Secondary Surface params when we have them.
// Also need to check for the existance of the second surface.
sSetMode.wDisplayX = (WORD) m_wSecondSurfWidth;
sSetMode.wDisplayY = (WORD) m_wSecondSurfHeight;
sSetMode.wStride = (WORD) m_wSecondSurfStride;
sSetMode.wBitsPerPixel = (WORD) m_wSecondSurfBPP;
sSetMode.psMemInfo = m_psSecondaryMemInfo;
// sSetMode.dwFBBase = m_dwSecondaryPhys;
if(m_clDisplay.PDP_SetMode (&sSetMode, FALSE) == PDP_ERROR_OK)
{
m_eSecondarySurfaceState = eSurfInUse;
bRestore = FALSE;
}
}
}
}
if(bRestore) // Something went WRONG! restore the old setup (hoping it works!)
{
sCurrentConfig.bSet = IMG_TRUE;
m_clDisplay.PDP_ConfigureDisplaySystem(&sCurrentConfig);
m_clDisplay.PDP_SetMode (&sCurMode, FALSE);
ulRetVal = ESC_FAILED;
}
}
else
{
if( (ulSizeOut<sizeof(DRVESC_CONFIG_DISPLAY_SYSTEM)) || (!pvOut))
{
/* should really return error, but we're leaving this as
is used to be for compatibility with theoretically bad apps */
}
else
{
pNewConfig = (DRVESC_CONFIG_DISPLAY_SYSTEM *) pvOut;
}
/* get the current configuration. */
*pNewConfig = sCurrentConfig;
#ifdef ROTATE_ENABLE
pNewConfig->sConnectSurface.ui32PhysRotation = m_lPrimaryRotation;
#else
pNewConfig->sConnectSurface.ui32PhysRotation = 0;
#endif
}
}
#endif
break;
}
case DRVESC_CREATE_OFFSCREENSURFACE:
{
#ifdef SUPPORT_MARATHON_DEVICE
// Create an offscreen surface that will be used for the 2nd display.
DRVESC_CREATE_SURFACE *psCreate;
ulRetVal = ESC_SUCCESS;
if((pvIn)&&(ulSizeIn == sizeof(DRVESC_CREATE_SURFACE)))
{
if(!m_bDualScreenIfaceLocked)
{
SetLastError (ERROR_INVALID_PARAMETER); /* no in buffer or too small */
ulRetVal = ESC_FAILED;
break;
}
psCreate=(DRVESC_CREATE_SURFACE*)pvIn;
if(m_eSecondarySurfaceState==eSurfFree) // this is the only time it is valid to create a surface!
{
// setup the Internal members that we have to look for
m_eSecondarySurfaceState=eSurfRequested;
m_wSecondSurfWidth=psCreate->wWidth;
m_wSecondSurfHeight=psCreate->wHeight;
}
else
{
SetLastError (ERROR_INVALID_PARAMETER);
ulRetVal = ESC_FAILED;
}
}
#endif
break;
}
case DRVESC_GET_SURFACEINFO:
{
#ifdef SUPPORT_MARATHON_DEVICE
// return the info about the display surface.
DRVESC_GET_SURFACE_INFO *psSurfaceInfo;
DRVESC_GET_SURFACE_INFO *psDisplaySurfaceSelect;
ulRetVal = ESC_SUCCESS;
if((pvIn) && (pvOut) && (ulSizeIn == sizeof(DRVESC_GET_SURFACE_INFO))
&& (ulSizeOut == sizeof(DRVESC_GET_SURFACE_INFO)))
{
psDisplaySurfaceSelect = (DRVESC_GET_SURFACE_INFO*) pvIn;
psSurfaceInfo = (DRVESC_GET_SURFACE_INFO*) pvOut;
switch(psDisplaySurfaceSelect->eDisplaySurface)
{
#ifdef ROTATE_ENABLE
IMG_INT32 i32Rotation;
#endif
case PVR_DESKTOP:
psSurfaceInfo->sPhysSurfaceInfo.ui32PhysAddress = (IMG_UINT32)m_pbyFBPhysBase;
psSurfaceInfo->sPhysSurfaceInfo.ui32Width=m_nScreenWidth;
psSurfaceInfo->sPhysSurfaceInfo.ui32Height=m_nScreenHeight;
psSurfaceInfo->sPhysSurfaceInfo.ui32Stride = m_ulScanLineLength;
psSurfaceInfo->sPhysSurfaceInfo.ui32Bpp = m_sModeInfo.Bpp;
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -