📄 control.cpp
字号:
#ifdef ROTATE_ENABLE
/* Get the surface rotation angle. */
switch (m_iRotate)
{
case DMDO_0:
i32Rotation = 0;
break;
case DMDO_90:
i32Rotation = 90;
break;
case DMDO_180:
i32Rotation = 180;
break;
case DMDO_270:
i32Rotation = 270;
break;
}
psSurfaceInfo->sPhysSurfaceInfo.int32PhysicalRotation = i32Rotation;
/* Note: The DRVESC_GET_SURFACE_INFO member bDriverRealigned is set by the dual display
control application, when it detects that the default desktop display angle has
been modified by the driver. */
#else//ROTATE_ENABLE
psSurfaceInfo->sPhysSurfaceInfo.int32PhysicalRotation = 0;
#endif//ROTATE_ENABLE
break;
case PVR_SECONDARYSURFACE:
if(m_eSecondarySurfaceState>=eSurfAllocated)
{
/* Get frame buffer address as seen from the XScale address space. */
psSurfaceInfo->sPhysSurfaceInfo.ui32PhysAddress = ((IMG_UINT32) m_pbyFBPhysBase) + m_psSecondaryMemInfo->uiDevAddr.uiAddr;
psSurfaceInfo->sPhysSurfaceInfo.ui32Width=m_wSecondSurfWidth;
psSurfaceInfo->sPhysSurfaceInfo.ui32Height=m_wSecondSurfHeight;
psSurfaceInfo->sPhysSurfaceInfo.ui32Stride=m_wSecondSurfStride;
psSurfaceInfo->sPhysSurfaceInfo.ui32Bpp=m_wSecondSurfBPP;
psSurfaceInfo->sPhysSurfaceInfo.bDriverRealigned=IMG_FALSE;
psSurfaceInfo->sPhysSurfaceInfo.int32PhysicalRotation=0;
}
else
{
SetLastError (ERROR_INVALID_PARAMETER);
ulRetVal = ESC_FAILED;
}
break;
default:
SetLastError (ERROR_INVALID_PARAMETER);
ulRetVal = ESC_FAILED;
break;
}
}
else
{
SetLastError (ERROR_INVALID_PARAMETER);
ulRetVal = ESC_FAILED;
}
#endif /* SUPPORT_MARATHON_DEVICE */
break;
}
/* only called when PORepaint in Wince410\public\commom\oak\files\common.reg is set to 3 */
case DRVESC_RESTOREVIDEOMEM: //set video mem to sys mem
DPFINFO((L"DRVESC_RESTOREVIDEOMEM"));
#ifdef LOCAL_MEMORY_SELF_REFRESH
SysLocalMemoryEnable(m_sDevData.psDevInfoKM);
#endif // LOCAL_MEMORY_SELF_REFRESH
ulRetVal = m_cl2DMemNodes.RestoreSystemMemtoSurf();
RestoreGapiSurf();
#ifdef LOCAL_MEMORY_SELF_REFRESH
SysLocalMemoryDisable(m_sDevData.psDevInfoKM);
#endif // LOCAL_MEMORY_SELF_REFRESH
break;
/* only called when PORepaint in Wince410\public\commom\oak\files\control.reg is set to 3 */
case DRVESC_SAVEVIDEOMEM: // copy video mem to sys mem
DPFINFO((L"DRVESC_SAVEVIDEOMEM"));
#ifdef LOCAL_MEMORY_SELF_REFRESH
SysLocalMemoryEnable(m_sDevData.psDevInfoKM);
#endif // LOCAL_MEMORY_SELF_REFRESH
ulRetVal = m_cl2DMemNodes.SaveSurfToSystemMem();
SaveGapiSurf();
#ifdef LOCAL_MEMORY_SELF_REFRESH
SysLocalMemoryDisable(m_sDevData.psDevInfoKM);
#endif // LOCAL_MEMORY_SELF_REFRESH
break;
case DRVESC_QUERYVIDEOMEMUSED:
{
ULONG ui32Total, ui32Free, ui32LargestBlock;
PVRSRV_ERROR eError;
if (pvIn != NULL && ulSizeIn == sizeof(PPVRSRV_DEV_INFO))
{
m_sDevData.psDevInfoKM = (PPVRSRV_DEV_INFO)pvIn;
eError = PVRSRVGetFreeDeviceMem ( &m_sDevData,
0,//ui32Flags,
&ui32Total,// IMG_UINT32 *pui32Total,
&ui32Free,//IMG_UINT32 *pui32Free,
&ui32LargestBlock);//IMG_UINT32 *pui32LargestBlock);
}
if (eError == PVRSRV_OK)
{
*(long *)pvOut = ui32Free;
ulRetVal = ESC_SUCCESS;
}
else
{
ulRetVal = 0;
DPFERROR((L"Error getting free video memory from services layer"));
DebugBreak();
}
break;
}
case SETPOWERMANAGEMENT:
DPFINFO((L"SetPowerManagement"));
if( (ulSizeIn >= sizeof(VIDEO_POWER_MANAGEMENT)) && (pvIn != NULL) )
{
PVIDEO_POWER_MANAGEMENT pvpm = (PVIDEO_POWER_MANAGEMENT)pvIn;
if (pvpm->Length >= sizeof(VIDEO_POWER_MANAGEMENT))
{
#ifdef SUPPORT_POWER_STATE
if (SetPowerState((VIDEO_POWER_STATE)pvpm->PowerState))
{
ulRetVal = ESC_SUCCESS;
break;
}
#else
DPFWARNING((L"****** Power Management is disabled ******"));
DPFWARNING((L"****** Ignoring switch to power state %u ******", pvpm->PowerState));
#endif
}
}
SetLastError (ERROR_INVALID_PARAMETER);
ulRetVal = ESC_FAILED;
break;
case GETPOWERMANAGEMENT:
DPFINFO((L"GETPOWERMANAGEMENT"));
if( (ulSizeOut >= sizeof(VIDEO_POWER_MANAGEMENT)) && (pvOut != NULL) )
{
PVIDEO_POWER_MANAGEMENT pvpm = (PVIDEO_POWER_MANAGEMENT)pvOut;
pvpm->Length = sizeof(VIDEO_POWER_MANAGEMENT);
pvpm->DPMSVersion = 0;
#ifdef SUPPORT_POWER_STATE
pvpm->PowerState = m_ePowerState;
#else
pvpm->PowerState = VideoPowerOn;
#endif
ulRetVal = ESC_SUCCESS;
}
else
{
SetLastError (ERROR_INVALID_PARAMETER);
ulRetVal = ESC_FAILED;
}
break;
case IOCTL_POWER_CAPABILITIES:
// tell the power manager about ourselves
DPFINFO((L"IOCTL_POWER_CAPABILITIES"));
ulRetVal = ESC_FAILED;
if (pvOut != NULL && ulSizeOut == sizeof (POWER_CAPABILITIES))
{
__try
{
PPOWER_CAPABILITIES PowerCaps = (PPOWER_CAPABILITIES)pvOut;
// Right now MBX supports D0, D1, D2 and D4 only.
memset(PowerCaps, 0, sizeof(*PowerCaps));
PowerCaps->DeviceDx = 0x17;
ulRetVal = ESC_SUCCESS;
}
__except(EXCEPTION_EXECUTE_HANDLER)
{
DPFWARNING((L"exception in Escape ioctl"));
}
}
break;
case IOCTL_POWER_QUERY:
ulRetVal = ESC_FAILED;
if (pvOut != NULL && ulSizeOut == sizeof(CEDEVICE_POWER_STATE))
{
// Return a good status on any valid query, since we are always ready to
// change power states.
__try
{
CEDEVICE_POWER_STATE NewDx = *(PCEDEVICE_POWER_STATE)pvOut;
if (VALID_DX(NewDx))
{
// This is a valid Dx state so return a good status.
ulRetVal = ESC_SUCCESS;
}
DPFINFO((L"IOCTL_POWER_QUERY %u %s", NewDx, ulRetVal == ESC_SUCCESS ? L"succeeded" : L"failed"));
}
__except(EXCEPTION_EXECUTE_HANDLER)
{
DPFWARNING((L"exception in Escape ioctl"));
}
}
break;
case IOCTL_POWER_SET:
ulRetVal = ESC_FAILED;
if (pvOut != NULL && ulSizeOut == sizeof(CEDEVICE_POWER_STATE))
{
__try
{
CEDEVICE_POWER_STATE NewDx;
NewDx = *(PCEDEVICE_POWER_STATE)pvOut;
#ifdef SUPPORT_POWER_STATE
if (VALID_DX(NewDx))
{
SetPowerState(NewDx);
ulRetVal = ESC_SUCCESS;
DPFWARNING((L"IOCTL_POWER_SET %u: passing back %u", NewDx, GetPowerState()));
}
else
{
DPFWARNING((L"Invalid state request %u", NewDx));
}
#else
DPFWARNING((L"****** Power Management is disabled ******"));
DPFWARNING((L"****** Ignoring switch to power state %u ******", NewDx));
#endif
}
__except(EXCEPTION_EXECUTE_HANDLER)
{
DPFWARNING((L"Exception in Escape ioctl"));
}
}
break;
case IOCTL_POWER_GET:
ulRetVal = ESC_FAILED;
if (pvOut != NULL && ulSizeOut == sizeof(CEDEVICE_POWER_STATE))
{
#ifdef SUPPORT_POWER_STATE
__try
{
CEDEVICE_POWER_STATE CurrentDx = GetPowerState();
*(PCEDEVICE_POWER_STATE)pvOut = CurrentDx;
ulRetVal = ESC_SUCCESS;
DPFINFO((L"IOCTL_POWER_GET: passing back %u", CurrentDx));
}
__except(EXCEPTION_EXECUTE_HANDLER)
{
DPFWARNING((L"exception in Escape ioctl"));
}
#endif
}
break;
case DRVESC_RESMAN_THREAD_TERMINATED:
{
ulRetVal = ESC_FAILED;
if(pvOut != NULL && ulSizeOut == sizeof(DRVESC_RESMAN_THREAD_TERMINATED_PARAMS))
{
ulRetVal = ResManTermintateProcessRequest((DRVESC_RESMAN_THREAD_TERMINATED_PARAMS *) pvOut);
}
}
break;
#ifdef SUPPORT_M24VA
case DRVESC_M24VA_ACQUIRE:
{
DWORD dwError;
DPFINFO ((L"M24VA_ACQUIRE"));
dwError = AcquireM24VA((DRVESC_M24VA_ACQUIRE_PARAMS *) pvOut);
if(dwError == ERROR_SUCCESS)
{
ulRetVal = ESC_SUCCESS;
}
else
{
SetLastError (dwError);
ulRetVal = ESC_FAILED;
}
break;
}
case DRVESC_OVERLAY_ATTRIBUTE:
if(ulSizeIn == sizeof(PDP_OVERLAYATTRIBS))
{
m_bOverlayUsed = TRUE;
m_clDisplay.PDP_SetOverlayAttributes((PPDP_OVERLAYATTRIBS)pvIn);
}
ulRetVal = ESC_SUCCESS;
break;
case DRVESC_OVERLAY_FLIP:
if(ulSizeIn == sizeof(PDP_OVERLAY))
{
m_bOverlayUsed = TRUE;
m_clDisplay.PDP_FlipOverlaySurface((PPDP_OVERLAY)pvIn);
}
ulRetVal = ESC_SUCCESS;
break;
case DRVESC_PREPARE_OVERLAY_FLIP:
if(ulSizeIn == sizeof(PDP_PREPARE_FLIP))
{
PDP_PREPARE_FLIP* psPrepareFlip = (PDP_PREPARE_FLIP*) pvIn;
m_bOverlayUsed = TRUE;
m_clDisplay.PDP_PrepareOverlayFlip(psPrepareFlip->psOverlay,
&psPrepareFlip->pui32OverlayConfig,
&psPrepareFlip->ui32OverlayConfigSize);
}
ulRetVal = ESC_SUCCESS;
break;
#endif
#ifndef DEBUG
case DRVESC_GET_EXCEPTION_COUNTS:
ulRetVal = ESC_FAILED;
if (pvOut != NULL && ulSizeOut == sizeof (DRVESC_EXCEPTION_COUNTS))
{
PDRVESC_EXCEPTION_COUNTS psCounters = (PDRVESC_EXCEPTION_COUNTS)pvOut;
psCounters->ulStandard = m_ulEmulatedBltExceptions;
psCounters->ulRotated = m_ulEmulatedBltRotateExceptions;
ulRetVal = ESC_SUCCESS;
};
break;
#endif
// PocketPC GAPI driver extensions.
case GETGXINFO:
{
if ( (ulSizeOut >= sizeof(GXDeviceInfo))
&& (pvOut != NULL)
&& (((GXDeviceInfo *) pvOut)->idVersion == kidVersion100)
)
{
GapiGetGxInfo((GXDeviceInfo*) pvOut); // gapi.cpp
ulRetVal = ESC_SUCCESS;
}
else
{
SetLastError (ERROR_INVALID_PARAMETER);
ulRetVal = ESC_FAILED;
}
break;
}// case GETGXINFO
#if defined(GETRAWFRAMEBUFFER)
// GAPI PocketPC Ozone driver escape.
case GETRAWFRAMEBUFFER:
{
if ((ulSizeOut >= sizeof(RawFrameBufferInfo)) && (pvOut != NULL) )
{
GapiGetRawFramebuffer((RawFrameBufferInfo*) pvOut); // gapi.cpp
ulRetVal = ESC_SUCCESS;
}
else
{
SetLastError (ERROR_INVALID_PARAMETER);
ulRetVal = ESC_FAILED;
}
break;
}//GETRAWFRAMEBUFFER
#endif
case PVRSRV_BRIDGE_CONNECT_SERVICES :
{
IMG_BOOL bConnecting = *((IMG_BOOL *) pvOut);
if(bConnecting)
{
ResManConnectProcess();
}
break;
}
case PVRSRV_BRIDGE_ENUM_DEVICES :
{
PVRSRV_BRIDGE_OUT_ENUMDEVICE *psOut;
psOut = (PVRSRV_BRIDGE_OUT_ENUMDEVICE *)pvOut;
psOut->eError = PVRSRVEnumerateDevices ((IMG_HANDLE)0,//FIXME????
&psOut->ui32NumDevices,
psOut->asDeviceIdentifier);
break;
}
case PVRSRV_BRIDGE_ACQUIRE_DEVICEINFO :
{
PVRSRV_BRIDGE_IN_ACQUIRE_DEVICEINFO *pAcquireDeviceInfo;
PVRSRV_BRIDGE_OUT_ACQUIRE_DEVICEINFO *pAcquireOUT;
pAcquireDeviceInfo = (PVRSRV_BRIDGE_IN_ACQUIRE_DEVICEINFO *) pvIn;
pAcquireOUT = (PVRSRV_BRIDGE_OUT_ACQUIRE_DEVICEINFO *) pvOut;
pAcquireOUT->eError = PVRSRVAcquireDeviceData ((IMG_HANDLE)0,
pAcquireDeviceInfo->uiDevIndex,
&pAcquireOUT->sDevData,
pAcquireDeviceInfo->eDeviceType);
break;
}
case PVRSRV_BRIDGE_RELEASE_DEVICEINFO :
{
psRet = (PVRSRV_BRIDGE_RETURN*)pvOut;
psRet->eError = PVRSRVReleaseDeviceData((PPVRSRV_DEV_DATA) pvIn);
break;
}
case PVRSRV_BRIDGE_ALLOC_DEVICEMEM :
{
PVRSRV_DEV_DATA sDevData;
PVRSRV_BRIDGE_IN_ALLOCDEVICEMEM *psBridgeIn;
PVRSRV_MEM_INFO *psMemInfo;
psBridgeIn = (PVRSRV_BRIDGE_IN_ALLOCDEVICEMEM*)pvIn;
psRet = (PVRSRV_BRIDGE_RETURN*)pvOut;
sDevData.psDevInfoKM = psBridgeIn->psDevInfo;
psRet->eError = PVRSRVAllocDeviceMem (&sDevData,
psBridgeIn->ui32Flags,
psBridgeIn->ui32Size,
psBridgeIn->ui32Alignment,
&psMemInfo);
psRet->pvData = psMemInfo;
break;
}
case PVRSRV_BRIDGE_FREE_DEVICEMEM :
{
PVRSRV_DEV_DATA sDevData;
PVRSRV_BRIDGE_IN_FREEDEVICEMEM *psBridgeIn;
psBridgeIn = (PVRSRV_BRIDGE_IN_FREEDEVICEMEM*)pvIn;
psRet = (PVRSRV_BRIDGE_RETURN*)pvOut;
sDevData.psDevInfoKM = psBridgeIn->psDevInfo;
psRet->eError = PVRSRVFreeDeviceMem (&sDevData,
psBridgeIn->psMemInfo);
break;
}
case PVRSRV_BRIDGE_GETFREE_DEVICEMEM :
{
PVRSRV_DEV_DATA sDevData;
PVRSRV_BRIDGE_IN_GETFREEDEVICEMEM *psBridgeIn;
PVRSRV_BRIDGE_OUT_GETFREEDEVICEMEM *psBridgeOut;
psBridgeIn = (PVRSRV_BRIDGE_IN_GETFREEDEVICEMEM*)pvIn;
psBridgeOut = (PVRSRV_BRIDGE_OUT_GETFREEDEVICEMEM*)pvOut;
sDevData.psDevInfoKM = psBridgeIn->psDevInfo;
psBridgeOut->eError = PVRSRVGetFreeDeviceMem( &sDevData,
psBridgeIn->ui32Flags,
&psBridgeOut->ui32Total,
&psBridgeOut->ui32Free,
&psBridgeOut->ui32LargestBlock);
break;
}
case PVRSRV_BRIDGE_CREATE_PARAMBUFF :
{
PVRSRV_DEV_DATA sDevData;
PVRSRV_BRIDGE_IN_CREATEPARAMBUFF *psBridgeIn;
psBridgeIn = (PVRSRV_BRIDGE_IN_CREATEPARAMBUFF*)pvIn;
psRet = (PVRSRV_BRIDGE_RETURN*)pvOut;
sDevData.psDevInfoKM = psBridgeIn->psDevInfo;
psRet->eError = PVRSRVCreateParameterBuffer (&sDevData,
psBridgeIn->ui32ParamBuffSize);
break;
}
case PVRSRV_BRIDGE_DESTROY_PARAMBUFF :
{
PVRSRV_DEV_DATA sDevData;
psRet = (PVRSRV_BRIDGE_RETURN*)pvOut;
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -