halvpe.cpp

Sm501 VGA芯片wince下驱动代码

	pd->dwNumEntries = MAX_SUPPORTED_DDVPTYPE;

    /*
     * If pd->lpGUIDs is NULL, simply return the number of GUIDS
     * supported
	 * Otherwise, copy the supported GUIDs into the specifed buffer.
	 * The HAL is guarenteed that the buffer is large enough to hold
	 * the GUIDs.
     */
    if (pcn) 
    {
		for (int i=0; i< MAX_SUPPORTED_DDVPTYPE; i++) 
		{
			pcn->dwSize			= sizeof(DDVIDEOPORTCONNECT);
			pcn->dwPortWidth	= 16;		// SMI ZV port is always 16 bits width
			memcpy(&pcn->guidTypeID, SupportedGUID[i], sizeof(GUID));
			pcn->dwFlags		= 	DDVPCONNECT_INVERTPOLARITY      |
      								DDVPCONNECT_DISCARDSVREFDATA    |
								    //DDVPCONNECT_HALFLINE            |
	 							    DDVPCONNECT_INTERLACED          |
      								//DDVPCONNECT_SHAREEVEN           |
      								//DDVPCONNECT_VACT                |
      								//DDVPCONNECT_DOUBLECLOCK         |
      								//DDVPCONNECT_SHAREODD            |              
      							  	0;
			pcn++;
		}
    }

	pd->ddRVal = DD_OK;
	return DDHAL_DRIVER_HANDLED;
};

// SMI Implemented
DWORD WINAPI HalDestroyVideoPort(LPDDHAL_DESTROYVPORTDATA pd) {
/*
typedef struct _DDHAL_DESTROYVPORTDATA {
	LPDDRAWI_DIRECTDRAW_LCL     lpDD;		    // driver struct
	LPDDRAWI_DDVIDEOPORT_LCL    lpVideoPort;	    // Video port object
	HRESULT 		    ddRVal;		    // return value
	LPDDHALVPORTCB_DESTROYVPORT DestroyVideoPort;	    // PRIVATE: ptr to callback
} DDHAL_DESTROYVPORTDATA;

*/

	DEBUGENTER(HalDestroyVideoPort);
#if (_WINCEOSVER < 600)
	((SMI *)g_pGPE)->VPE_Disable();
	((SMI *)g_pGPE)->VPE_DisableOverlayWindow();
#else
	((SMI *)GetDDGPE())->VPE_Disable();
	((SMI *)GetDDGPE())->VPE_DisableOverlayWindow();
#endif	
	bVPEWeave = FALSE;

	pd->ddRVal = DD_OK;
	return DDHAL_DRIVER_NOTHANDLED;
};

// SMI Implemented
DWORD WINAPI HalGetVideoPortFlipStatus(LPDDHAL_GETVPORTFLIPSTATUSDATA pd) 
{
/*
typedef struct _DDHAL_GETVPORTFLIPSTATUSDATA {
	LPDDRAWI_DIRECTDRAW_LCL     lpDD;		    // driver struct
	FLATPTR 		    fpSurface;		    // surface struct
	HRESULT 		    ddRVal;		    // return value
	LPDDHALVPORTCB_GETFLIPSTATUS GetVideoPortFlipStatus; // PRIVATE: ptr to callback
} DDHAL_GETVPORTFLIPSTATUSDATA;
*/

	DEBUGENTER(HalGetVideoPortFlipStatus);
	//DebugBreak();
#if (_WINCEOSVER < 600)
    DWORD dwBase = 	((SMI *)g_pGPE)->VPE_GetDst();
#else
	DWORD dwBase = 	((SMI *)GetDDGPE())->VPE_GetDst();
#endif

	if (dwBase == dwCurrentSurface)
	{
		pd->ddRVal = DD_OK;
	}
	else
	{
		pd->ddRVal = DDERR_WASSTILLDRAWING;
	}

	return DDHAL_DRIVER_HANDLED;
};

// SMI Implemented
DWORD WINAPI HalWaitForVideoPortSync(LPDDHAL_WAITFORVPORTSYNCDATA pd) 
{
/*
typedef struct _DDHAL_WAITFORVPORTSYNCDATA {
	LPDDRAWI_DIRECTDRAW_LCL     lpDD;		    // driver struct
	LPDDRAWI_DDVIDEOPORT_LCL    lpVideoPort;	    // Video port object
	DWORD			    dwFlags;		    // DDVPEVENT_XXXX
	DWORD			    dwLine;
	DWORD			    dwTimeOut;		    // Max time to wait before returning
	HRESULT 		    ddRVal;		    // return value
	LPDDHALVPORTCB_WAITFORSYNC  WaitForVideoPortSync;   // PRIVATE: ptr to callback
} DDHAL_WAITFORVPORTSYNCDATA;
*/
	DEBUGENTER(HalWaitForVideoPortSync);
//	DebugBreak();

	DWORD dwTime;
	if (pd->dwFlags == DDVPWAIT_BEGIN)
	{
		DEBUGMSG(GPE_ZONE_VPE,(TEXT("VPE_WaitForSync: DDVPWAIT_BEGIN\r\n")));

#ifndef DISABLE_INTERRUPT_MANAGEMENT
		pd->ddRVal = DDERR_VIDEONOTACTIVE;
#if (_WINCEOSVER < 600)
		if (((SMI *)g_pGPE)->VPE_WaitForVSync(pd->dwTimeOut))
#else
		if (((SMI *)GetDDGPE())->VPE_WaitForVSync(pd->dwTimeOut))
#endif
			pd->ddRVal = DD_OK;

		DEBUGMSG(GPE_ZONE_VPE,(TEXT("VPE_WaitForSync: DDVPWAIT_BEGIN---\r\n")));
#else
        // 
        // Wait for the beginning of the video VSYNC
        //
		dwTime = GetTickCount();
        if (((SMI *)GetDDGPE())->VPE_IsVsync())
        {
            // VSYNC is already active, wait till VSYNC inactive first.
            while (((SMI *)GetDDGPE())->VPE_IsVsync()) 
            {
                if (GetTickCount()-dwTime >= pd->dwTimeOut) 
                {
                    pd->ddRVal = DDERR_VIDEONOTACTIVE;
                    return DDHAL_DRIVER_HANDLED;
                }
            }
        }
            
        // now wait till vsync active.
        while (!(((SMI *)GetDDGPE())->VPE_IsVsync())) 
        {
            if (GetTickCount()-dwTime >= pd->dwTimeOut) 
            {
            	pd->ddRVal = DDERR_VIDEONOTACTIVE;
                return DDHAL_DRIVER_HANDLED;
            }
        }
        pd->ddRVal = DD_OK;
#endif
	}
	else if (pd->dwFlags == DDVPWAIT_END)
	{
		DEBUGMSG(GPE_ZONE_VPE,(TEXT("VPE_WaitForSync: DDVPWAIT_END\r\n")));

        // 
        // Wait for the end of the video VSYNC
        // 
		dwTime = GetTickCount();
#if (_WINCEOSVER < 600)
		if (!(((SMI *)g_pGPE)->VPE_IsVsync()))
#else
        if (!(((SMI *)GetDDGPE())->VPE_IsVsync()))
#endif
        {
            // VSYNC is already inactive, wait till VSYNC active first.
#if (_WINCEOSVER < 600)
			 while (!(((SMI *)g_pGPE)->VPE_IsVsync())) 
#else
            while (!(((SMI *)GetDDGPE())->VPE_IsVsync())) 
#endif
			{
                if (GetTickCount()-dwTime >= pd->dwTimeOut) 
                {
                    pd->ddRVal = DDERR_VIDEONOTACTIVE;
                    return DDHAL_DRIVER_HANDLED;
                }
            }
        }
        
        // now wait till vsync inactive.
#if (_WINCEOSVER < 600)
		while (((SMI *)g_pGPE)->VPE_IsVsync()) 
#else
        while (((SMI *)GetDDGPE())->VPE_IsVsync()) 
#endif
		{
            if (GetTickCount()-dwTime >= pd->dwTimeOut) {
            	pd->ddRVal = DDERR_VIDEONOTACTIVE;
                return DDHAL_DRIVER_HANDLED;
            }
        }
        pd->ddRVal = DD_OK;
	}
	else
	{
        pd->ddRVal = DDERR_UNSUPPORTED;
        return DDHAL_DRIVER_NOTHANDLED;
	}

    return DDHAL_DRIVER_HANDLED;
};

// SMI Implemented
DWORD WINAPI HalGetVideoSignalStatus(LPDDHAL_GETVPORTSIGNALDATA pd) 
{
/*
typedef struct _DDHAL_GETVPORTSIGNALDATA {
	LPDDRAWI_DIRECTDRAW_LCL     lpDD;		    // driver struct
	LPDDRAWI_DDVIDEOPORT_LCL    lpVideoPort;	    // Video port object
	DWORD			    dwStatus;		    // Video signal status
	HRESULT 		    ddRVal;		    // return value
	LPDDHALVPORTCB_GETSIGNALSTATUS GetVideoSignalStatus;// PRIVATE: ptr to callback
} DDHAL_GETVPORTSIGNALDATA;
*/

	DEBUGENTER(HalGetVideoSignalStatus);
//	DebugBreak();

	int wGUID = IsVPTypeSupported(&(pd->lpVideoPort->ddvpDesc.VideoPortType.guidTypeID));

    pd->ddRVal = DD_OK;
	if (wGUID == -1) {
		pd->dwStatus = DDVPSQ_NOSIGNAL;
		return DDHAL_DRIVER_HANDLED;
	}
#if (_WINCEOSVER < 600)
	else if (!(((SMI *)g_pGPE)->VPE_IsEnable()))
#else
	else if (!(((SMI *)GetDDGPE())->VPE_IsEnable())) 
#endif	
	{
		pd->dwStatus = DDVPSQ_NOSIGNAL;
		return DDHAL_DRIVER_HANDLED;
	}

	DWORD dwTimeOut = 2000; // 2 seconds
	DWORD dwTime = GetTickCount();
#if (_WINCEOSVER < 600)
	BOOL bVsync = ((SMI *)g_pGPE)->VPE_IsVsync();
	while (((SMI *)g_pGPE)->VPE_IsVsync() == bVsync)
#else
	BOOL bVsync = ((SMI *)GetDDGPE())->VPE_IsVsync();
	while (((SMI *)GetDDGPE())->VPE_IsVsync() == bVsync)
#endif	
	{
		if (GetTickCount()-dwTime >= dwTimeOut)
		{
			pd->dwStatus = DDVPSQ_NOSIGNAL;
			return DDHAL_DRIVER_HANDLED;
		}
	}

	pd->dwStatus = DDVPSQ_SIGNALOK;

	return DDHAL_DRIVER_HANDLED;	
};

// SMI Implemented
DWORD WINAPI HalColorControl(LPDDHAL_VPORTCOLORDATA pd) 
{
/*
typedef struct _DDHAL_VPORTCOLORDATA {
	LPDDRAWI_DIRECTDRAW_LCL     lpDD;		    // driver struct
	LPDDRAWI_DDVIDEOPORT_LCL    lpVideoPort;	    // Video port object
	DWORD			    dwFlags;		    // Video signal status
	LPDDCOLORCONTROL	    lpColorData;
	HRESULT 		    ddRVal;		    // return value
	LPDDHALVPORTCB_COLORCONTROL ColorControl;	    // PRIVATE: ptr to callback
} DDHAL_VPORTCOLORDATA;
*/
	DEBUGENTER(HalColorControl);
//	DebugBreak();

	return DDHAL_DRIVER_NOTHANDLED;
};

// SMI Implemented
DWORD WINAPI HalUpdateVideoPort(LPDDHAL_UPDATEVPORTDATA pd) 
{
/*
typedef struct _DDHAL_UPDATEVPORTDATA {
	LPDDRAWI_DIRECTDRAW_LCL     lpDD;		    // driver struct
	LPDDRAWI_DDVIDEOPORT_LCL    lpVideoPort;	    // Video port object
	LPDDRAWI_DDRAWSURFACE_INT   *lplpDDSurface;	    // surface struct
	LPDDRAWI_DDRAWSURFACE_INT   *lplpDDVBISurface;	    // VBI surface structure
	LPDDVIDEOPORTINFO	    lpVideoInfo;	    // Video information
	DWORD			    dwFlags;		    // DDRAWI_VPORTSTART, DDRAWI_VPORTSTOP, DDRAWI_VPORTUPDATE
	DWORD			    dwNumAutoflip;	    // # of autoflip surfaces. If > 1, lpDDSurface and lpDDVBISurface are arrays.
	DWORD			    dwNumVBIAutoflip;	    // # of autoflip surfaces. If > 1, lpDDSurface and lpDDVBISurface are arrays.
	HRESULT 		    ddRVal;		    // return value
	LPDDHALVPORTCB_UPDATE	    UpdateVideoPort;	    // PRIVATE: ptr to callback
} DDHAL_UPDATEVPORTDATA;
*/

	DEBUGENTER(HalUpdateVideoPort);
	//DebugBreak();

	if (pd->dwFlags == DDRAWI_VPORTSTOP) 
	{
		// Turn off Video Port
		DEBUGMSG(GPE_ZONE_VPE,(TEXT("SMI::HalUpdateVideoPort - VPE Stop\r\n")));
#if (_WINCEOSVER < 600)
	((SMI *)g_pGPE)->VPE_Disable();
#else
	((SMI *)GetDDGPE())->VPE_Disable();
#endif	
		pd->ddRVal = DD_OK;
		return DDHAL_DRIVER_HANDLED;
	}

	DWORD gate = FIELD_SET(0, CURRENT_POWER_GATE, ZVPORT, ENABLE);
	// Enable gate
#if (_WINCEOSVER < 600)
	((SMI *)g_pGPE)->setGate(gate, gate);
#else
	((SMI *)GetDDGPE())->setGate(gate, gate);
#endif
	

	DEBUGMSG(GPE_ZONE_VPE,(TEXT("dwVPFlags = 0x%08X\r\n"),pd->lpVideoInfo->dwVPFlags));

	BOOL bDoubleBuffer = FALSE;
	if (pd->lpVideoInfo->dwVPFlags & DDVP_AUTOFLIP)
    {
		DEBUGMSG(GPE_ZONE_VPE,(TEXT("SMI::HalUpdateVideoPort - DDVP_AUTOFLIP Set\r\n")));

		if (pd->dwNumAutoflip == 2)
		{
			if (!(pd->lpVideoInfo->dwVPFlags & DDVP_INTERLEAVE))
			{
				bDoubleBuffer = TRUE;
			}
			else
			{
				DEBUGMSG(GPE_ZONE_VPE,(TEXT("SMI::HalUpdateVideoPort - DDVP_INTERLEAVE Set - UNSUPPORTED!\r\n")));
				pd->ddRVal = DDERR_UNSUPPORTED;
				return DDHAL_DRIVER_HANDLED;
			}

		}
#if 0 //ndef DISABLE_INTERRUPT_MANAGEMENT
		else if (pd->dwNumAutoflip <= MAX_FLIP_ENTRIES)
		{

			if (!(pd->lpVideoInfo->dwVPFlags & DDVP_INTERLEAVE))
			{
				bDoubleBuffer = TRUE;

			    DWORD dwStride = pd->lplpDDSurface[0]->lpLcl->lpGbl->lPitch;
			    DWORD dwBytesPerPixel = dwStride / pd->lplpDDSurface[0]->lpLcl->lpGbl->wWidth;
			    DWORD dwBaseOffset = dwBytesPerPixel * pd->lpVideoInfo->dwOriginX + dwStride * pd->lpVideoInfo->dwOriginY;
        
			    DWORD dwBuffer[MAX_FLIP_ENTRIES];
			    
			    dwBuffer[0] = pd->dwNumAutoflip;
			    for(DWORD i=0; i<dwBuffer[0]; i++)
   			 	{
        			DWORD DstOfs = pd->lplpDDSurface[i]->lpLcl->lpGbl->fpVidMem - (DWORD)g_pVideoMemory;
        			DstOfs += dwBaseOffset;
        			dwBuffer[i+1] = DstOfs;
    			}

    			((SMI *)GetDDGPE())->VPE_InitSwAutoflip(dwBuffer);
    			((SMI *)GetDDGPE())->VPE_SetDst(dwBuffer[1]);
    			((SMI *)GetDDGPE())->VPE_SetDst2(dwBuffer[1]);
			}
			else
			{
				DEBUGMSG(GPE_ZONE_VPE,(TEXT("SMI::HalUpdateVideoPort - DDVP_INTERLEAVE Set - UNSUPPORTED!\r\n")));
				pd->ddRVal = DDERR_UNSUPPORTED;
				return DDHAL_DRIVER_HANDLED;
			}
		}
#endif
		else
		{
			DEBUGMSG(GPE_ZONE_VPE,(TEXT("SMI::HalUpdateVideoPort - Unsupported dwAutoflipNum!\r\n")));
			pd->ddRVal = DDERR_UNSUPPORTED;
			return DDHAL_DRIVER_HANDLED;

		}
    }

#if (_WINCEOSVER < 600)
	//when they STOP VIDEOPORT, lplpDDSurface is NULL :-)  LPDDRAWI_DDRAWSURFACE_LCL
	LPDDRAWI_DDRAWSURFACE_INT	pDstInt = *pd->lplpDDSurface;
	LPDDRAWI_DDRAWSURFACE_LCL	pDstSurfLcl = pDstInt->lpLcl;
	LPDDRAWI_DDRAWSURFACE_GBL	pDstSurfGbl = pDstSurfLcl->lpGbl;

	//WORD wDstBytePP = (WORD)(pd->lpVideoInfo->lpddpfInputFormat->dwYUVBitCount / 8);
	WORD wDstBytePP = 2;	//SMI VPE is always 16 bit width
    //WORD wDstStride = pDstSurfGbl->wWidth * wDstBytePP;
	WORD wDstPitch	= (WORD)pDstSurfGbl->lPitch;

	bVPEWeave = FALSE;
	if (pd->lpVideoInfo->dwVPFlags & DDVP_INTERLEAVE) 
	{
		// Special case - Double buffer for weave mode
		DEBUGMSG(GPE_ZONE_VPE,(TEXT("SMI::HalUpdateVideoPort - DDVP_INTERLEAVE Set\r\n")));
		bVPEWeave = TRUE;
	}

	if (pd->dwFlags != DDRAWI_VPORTUPDATE &&
		pd->dwFlags != DDRAWI_VPORTSTART) 
	{
		DEBUGMSG(GPE_ZONE_VPE,(TEXT("SMI::HalUpdateVideoPort - Unknown dwFlags\r\n")));
		pd->ddRVal = DDERR_UNSUPPORTED;
		return DDHAL_DRIVER_NOTHANDLED;
	}

	DWORD dwMode = 0;

	// Disable BOB mode interlaced
#if (_WINCEOSVER < 600)
	((SMI *)g_pGPE)->VPE_DisableBOB();
#else
	((SMI *)GetDDGPE())->VPE_DisableBOB();
#endif	
	
    if (pd->lpVideoPort->ddvpDesc.VideoPortType.dwFlags & DDVPCONNECT_INTERLACED) 
    {
		DEBUGMSG(GPE_ZONE_VPE,(TEXT("SMI::HalUpdateVideoPort - DDVPCONNECT_INTERLACED Set\r\n")));
		//dwMode = FIELD_SET(dwMode, CAPTURE_CONTROL, INTERLACE, ENABLE);
    }

    if (pd->lpVideoInfo->dwVPFlags & DDVP_SKIPEVENFIELDS)
    {
		DEBUGMSG(GPE_ZONE_VPE,(TEXT("SMI::HalUpdateVideoPort - DDVP_SKIPEVENFIELDS Set\r\n")));
        //dwMode |= VPE_CAP_SKIP_EVEN;
        //
        // some VPE client set both skip field and DoubleBuffer flag at the
        // same time. This violates VPE rules. We simply ignore the DoubleBuffer
	    // flag here and use only one hardware buffer.
        //
        bDoubleBuffer = FALSE;
    }
    if (pd->lpVideoInfo->dwVPFlags & DDVP_SKIPODDFIELDS)
    {
		DEBUGMSG(GPE_ZONE_VPE,(TEXT("SMI::HalUpdateVideoPort - DDVP_SKIPODDFIELDS Set\r\n")));
        //dwMode |= VPE_CAP_SKIP_ODD;
        //
        // some VPE client set both skip field and auto flip flag at the
        // same time. This violates VPE rules. We simply ignore the auto
        // flip flag here and use only one hardware buffer.
        //
       bDoubleBuffer = FALSE;
    }

	// Seems most VPE needs byte swap
	dwMode = FIELD_SET(dwMode, CAPTURE_CONTROL, BYTE_SWAP, ENABLE);	

    int wGUID = IsVPTypeSupported(&(pd->lpVideoPort->ddvpDesc.VideoPortType.guidTypeID));
	switch(wGUID)
	{
/*
		case VPE_CCIR656:
			DEBUGMSG(GPE_ZONE_VPE,(TEXT("SMI::HalUpdateVideoPort - DDVPTYPE_CCIR656\r\n")));
			break;
		case VPE_BROOKTREE: