haldd.cpp

WinCE 3.0 BSP, 包含Inter SA1110, Intel_815E, Advantech_PCM9574 等

/*
 * $Workfile: haldd.cpp $
 * $Revision: 4 $
 * $Date: 4/07/00 9:11a $
 * $Modtime: 4/07/00 8:59a $
 * $Author: Sarma $
 *
 * Copyright (c) 1998 National Semiconductor Corporation.
 * All Rights Reserved.
 *
 * This software is the confidential and proprietary information of National 
 * Semiconductor Corporation. ("Confidential Information").
 * You shall not disclose such Confidential Information and shall use it only
 * in accordance with the terms of the license agreement you entered into
 * with National Semiconductor Corporation.
 * This code is supplied as is.
 *
 */

/*
 *$Log: /CE/Platform/Nsc/Drivers/Video/gxvideo/ddraw/haldd.cpp $
 * 
 * 4     4/07/00 9:11a Sarma
 * Removed Cyrix Corporation from the legal/confidentail information. Also
 * added for files not containing this info.
 * 
 *$History: haldd.cpp $
 * 
 * *****************  Version 4  *****************
 * User: Sarma        Date: 4/07/00    Time: 9:11a
 * Updated in $/CE/Platform/Nsc/Drivers/Video/gxvideo/ddraw
 * Removed Cyrix Corporation from the legal/confidentail information. Also
 * added for files not containing this info.
 *
*/

#include "precomp.h"
#ifdef DD_SUPPORT

#include "gpevga.h"

extern unsigned long DDPalette[256];
extern unsigned char DDCurData[256];

#ifdef DEBUG
#ifndef HAL_ZONE_INIT
#define HAL_ZONE_INIT     GPE_ZONE_INIT
#endif
#endif

extern DDRAWDATA *pDriverData;
extern FLIPRECORD	unflipRecord;


DWORD WINAPI HalGetDriverInfo(LPDDHAL_GETDRIVERINFODATA lpInput)
{
    DWORD dwSize;
	DEBUGMSG(0,(TEXT("GetDriverInfo invoked !!\r\n")));

    lpInput->ddRVal = DDERR_CURRENTLYNOTAVAIL;

    if (IsEqualIID(lpInput->guidInfo, GUID_KernelCallbacks) )
    {
		DEBUGMSG(0,(TEXT("GUID_KernelCallbacks\r\n")));
        dwSize = min(lpInput->dwExpectedSize, sizeof(DDHAL_DDKERNELCALLBACKS));
        lpInput->dwActualSize = sizeof(DDHAL_DDKERNELCALLBACKS);

        memcpy(lpInput->lpvData, &KernelCallbacks, dwSize);
        lpInput->ddRVal = DD_OK;
    }
    else if (IsEqualIID(lpInput->guidInfo, GUID_HALMemory) )
    {
		DEBUGMSG(0,(TEXT("GUID_KernelCallbacks\r\n")));
        dwSize = min(lpInput->dwExpectedSize, sizeof(DDHAL_DDHALMEMORYCALLBACKS));
        lpInput->dwActualSize = sizeof(DDHAL_DDHALMEMORYCALLBACKS);

        memcpy(lpInput->lpvData, &HalMemoryCallbacks, dwSize);
        lpInput->ddRVal = DD_OK;
    }
    else if (IsEqualIID(lpInput->guidInfo, GUID_KernelCaps))
    {
		DEBUGMSG(0,(TEXT("GUID_KernelCaps\r\n")));
        dwSize = min(lpInput->dwExpectedSize, sizeof(DDKERNELCAPS));
        lpInput->dwActualSize = sizeof(DDHAL_DDKERNELCALLBACKS);

        memcpy(lpInput->lpvData, &KernelCaps, dwSize );
        lpInput->ddRVal = DD_OK;
    }
    else if (IsEqualIID(lpInput->guidInfo, GUID_ColorControlCallbacks) )
    {
		DEBUGMSG(0,(TEXT("GUID_ColorControlCallbacks\r\n")));
        dwSize = min(lpInput->dwExpectedSize, sizeof(DDHAL_DDCOLORCONTROLCALLBACKS));
        lpInput->dwActualSize = sizeof(DDHAL_DDCOLORCONTROLCALLBACKS);

        memcpy(lpInput->lpvData, &ColorControlCallbacks, dwSize);
        lpInput->ddRVal = DD_OK;
    }
    else if (IsEqualIID(lpInput->guidInfo, GUID_MiscellaneousCallbacks) )
    {
		DEBUGMSG(0,(TEXT("GUID_MiscellaneousCallbacks\r\n")));
        dwSize = min(lpInput->dwExpectedSize, sizeof(DDHAL_DDMISCELLANEOUSCALLBACKS));
        lpInput->dwActualSize = sizeof(DDHAL_DDMISCELLANEOUSCALLBACKS);

        memcpy(lpInput->lpvData, &MiscellaneousCallbacks, dwSize);
        lpInput->ddRVal = DD_OK;
    }
//#ifdef VIDEOPORT_SUPPORT
    else if (IsEqualIID(lpInput->guidInfo, GUID_VideoPortCallbacks) )
    {
		DEBUGMSG(0,(TEXT("GUID_VideoPortCallbacks\r\n")));
        dwSize = min(lpInput->dwExpectedSize, sizeof(DDHAL_DDVIDEOPORTCALLBACKS));
        lpInput->dwActualSize = sizeof(DDHAL_DDVIDEOPORTCALLBACKS);

        memcpy(lpInput->lpvData, &VideoPortCallbacks, dwSize);
        lpInput->ddRVal = DD_OK;
    }
    else if (IsEqualIID(lpInput->guidInfo, GUID_VideoPortCaps) )
    {
		DEBUGMSG(0,(TEXT("GUID_VideoPortCaps\r\n")));
        dwSize = min(lpInput->dwExpectedSize, sizeof(DDVIDEOPORTCAPS));
        lpInput->dwActualSize = sizeof(DDVIDEOPORTCAPS);

        memcpy(lpInput->lpvData, &VideoPortCaps, dwSize);
        lpInput->ddRVal = DD_OK;
    }
//#endif //VIDEOPORT_SUPPORT
#if 0
    else if (IsEqualIID(lpInput->guidInfo, GUID_NonLocalVidMemCaps) )
    {
		DEBUGMSG(0,(TEXT("GUID_NonLocalVidMemCaps\r\n")));
        dwSize = min(lpInput->dwExpectedSize, sizeof(DDHAL_DDCOLORCONTROLCALLBACKS));
        lpInput->dwActualSize = sizeof(DDHAL_DDCOLORCONTROLCALLBACKS);

        memcpy(lpInput->lpvData, &VideoPortCaps, dwSize);
        lpInput->ddRVal = DD_OK;
    }
#endif //0
#ifdef DIRECT3D_SUPPORT
    else if (IsEqualIID(lpInput->guidInfo, GUID_D3DCallbacks2) )
    {
		DEBUGMSG(0,(TEXT("GUID_D3DCallbacks2\r\n")));
		D3DHAL_CALLBACKS2 D3DCallbacks2;
		memset(&D3DCallbacks2, 0, sizeof(D3DCallbacks2));

		dwSize = min(lpInput->dwExpectedSize, sizeof(D3DHAL_CALLBACKS2));
		lpInput->dwActualSize = sizeof(D3DHAL_CALLBACKS2);

		D3DCallbacks2.dwSize = dwSize;
		// set up D3DCallbacks2 elements

		memcpy(lpInput->lpvData, &D3DCallbacks2, dwSize);
		lpInput->ddRVal = DD_OK;
    }
    else if (IsEqualIID(lpInput->guidInfo, GUID_D3DExtendedCaps) )
    {
		DEBUGMSG(0,(TEXT("GUID_D3DExtendedCaps\r\n")));
		D3DHAL_D3DEXTENDEDCAPS ec;
		memset(&ec, 0, sizeof(ec));
		dwSize = min(lpInput->dwExpectedSize, sizeof(D3DHAL_D3DEXTENDEDCAPS));
		ec.dwSize = sizeof(ec);

		// set up ec elements
		
		memcpy(lpInput->lpvData, &ec, dwSize);
		lpInput->ddRVal = DD_OK;
    }
#endif // DIRECT3D_SUPPORT

	if( lpInput->ddRVal != DD_OK )
	{
		DEBUGMSG(0,(TEXT("HalGetDriverInfo: Currently not available\r\n")));
	}

    return DDHAL_DRIVER_HANDLED;
}


//////////////////////////// DDHAL_DDCALLBACKS ////////////////////////////

DWORD WINAPI HalDestroyDriver( LPDDHAL_DESTROYDRIVERDATA pd )
{
	//DEBUGENTER( HalDestroyDriver );
	RETAILMSG(0,(TEXT("HalDestroyDriver\r\n")));
	/*
	typedef struct _DDHAL_DESTROYDRIVERDATA
	{
	    LPDDRAWI_DIRECTDRAW_GBL     lpDD;   		// driver struct
	    HRESULT                     ddRVal; 		// return value
	    LPDDHAL_DESTROYDRIVER       DestroyDriver;  // PRIVATE: ptr to callback
	} DDHAL_DESTROYDRIVERDATA;
	*/
	DDHAL_FLIPTOGDISURFACEDATA d;

	DDGPEFlipToGDISurface( &d );

    //Set the mode again
//    g_pGPE->SetMode(0, 0);

    //Recreate cursor pattern
    unsigned char * pCurData;
    pCurData = (unsigned char *) (pDriverData->FbLinear + 0x1FFF00);
	for(int i=0; i<256; i++ )
	{
        *pCurData++ = DDCurData[i];
	    //RETAILMSG(1,(TEXT("CurAddr = %X, CurData = %X\r\n"), pCurData, DDCurData[i]));
	}

    //Reprogram palette
    MEM_WRITE_32(pDriverData->RegLinear, DC_UNLOCK, 0x4758);  //unlock registers

	for(i=0; i<256; i++ )
	{
		WRITE_REG32(pDriverData->RegLinear, DC_PAL_ADDRESS, i);
    	WRITE_REG32(pDriverData->RegLinear, DC_PAL_DATA, DDPalette[i]);
	}
	RETAILMSG(0,(TEXT("Set DDPalette done %X\r\n"), DDPalette[i-1]));

    //Enable the cursor
    unsigned long temp = MEM_READ_32(pDriverData->RegLinear, DC_GENERAL_CFG);
	temp |= 0x00000002; //set cursor enable bit
    MEM_WRITE_32(pDriverData->RegLinear, DC_GENERAL_CFG, temp);

    MEM_WRITE_32(pDriverData->RegLinear, DC_UNLOCK, 0x0); //lock registers
    
	pd->ddRVal = DD_OK;
	return DDHAL_DRIVER_HANDLED;
}

// not to be confused with
// DWORD WINAPI HalSetColorKey( LPDDHAL_SETCOLORKEYDATA pd )
DWORD WINAPI HalSetColorKey( LPDDHAL_DRVSETCOLORKEYDATA pd )
{
	//DEBUGENTER( HalSetColorKey );
	/*
	typedef struct _DDHAL_DRVSETCOLORKEYDATA
	{
	    LPDDRAWI_DDRAWSURFACE_LCL   lpDDSurface;    // surface struct
	    DWORD                       dwFlags;        // flags
	    DDCOLORKEY                  ckNew;          // new color key
	    HRESULT                     ddRVal;         // return value
	    LPDDHAL_SETCOLORKEY         SetColorKey;    // PRIVATE: ptr to callback
	} DDHAL_DRVSETCOLORKEYDATA;
	*/
	
	pd->ddRVal = DD_OK;
	return DDHAL_DRIVER_HANDLED;
}

DWORD WINAPI HalSetMode( LPDDHAL_SETMODEDATA pd )
{
	//DEBUGENTER( HalSetMode );
	RETAILMSG(0,(TEXT("HalSetMode\r\n")));
	/*
	typedef struct _DDHAL_SETMODEDATA
	{
	    LPDDRAWI_DIRECTDRAW_GBL lpDD;               // driver struct
	    DWORD               dwModeIndex;    		// new mode
	    HRESULT             ddRVal;         		// return value
	    LPDDHAL_SETMODE     SetMode;        		// PRIVATE: ptr to callback
	    BOOL                inexcl;         		// in exclusive mode
	} DDHAL_SETMODEDATA;
	*/

//    g_pGPE->SetMode(0, 0);

	// implementation
	pd->ddRVal = DD_OK;

	return DDHAL_DRIVER_NOTHANDLED;   //ullas - NOTHANDLED; // We only support 1 mode
}

DWORD WINAPI HalWaitForVerticalBlank( LPDDHAL_WAITFORVERTICALBLANKDATA lpWaitForVerticalBlank )
{
//	DEBUGENTER( HalWaitForVerticalBlank );
	/*
	typedef struct _DDHAL_WAITFORVERTICALBLANKDATA
	{
	    LPDDRAWI_DIRECTDRAW_GBL	lpDD;           	// driver struct
	    DWORD					dwFlags;        	// flags
	    DWORD					bIsInVB;        	// is in vertical blank
	    DWORD					hEvent;         	// event
	    HRESUL					ddRVal;				// return value
	    LPDDHAL_WAITFORVERTICALBLANK WaitForVerticalBlank;
	    											// PRIVATE: ptr to callback
	} DDHAL_WAITFORVERTICALBLANKDATA;
	*/
    switch( lpWaitForVerticalBlank->dwFlags )
    {
    case DDWAITVB_I_TESTVB:
        /* 
         * if testvb is just a request for the current vertical blank status
         */
        lpWaitForVerticalBlank->ddRVal = DD_OK;
        lpWaitForVerticalBlank->bIsInVB = IN_VBLANK;
        return DDHAL_DRIVER_HANDLED;

    case DDWAITVB_BLOCKBEGIN:
        /* 
         * if blockbegin is requested we wait until the vertical blank
         * is over, and then wait for the display period to end.
         */
        while(IN_VBLANK);
        while(IN_DISPLAY);
        lpWaitForVerticalBlank->ddRVal = DD_OK;
        return DDHAL_DRIVER_HANDLED;

    case DDWAITVB_BLOCKEND:
        /* 
         * if blockend is requested we wait for the vblank interval to end.
         */
        if( IN_VBLANK )
        {
            while( IN_VBLANK );
        }
        else
        {
            while(IN_DISPLAY);
            while(IN_VBLANK);
        }
        unflipRecord.bFlipFlag = FALSE;           // no longer need to wait for flip
        lpWaitForVerticalBlank->ddRVal = DD_OK;
        return DDHAL_DRIVER_HANDLED;
    }

    return DDHAL_DRIVER_NOTHANDLED;

} /* WaitForVerticalBlank32 */

DWORD WINAPI HalGetScanLine( LPDDHAL_GETSCANLINEDATA pd )
{
//	DEBUGENTER( HalGetScanLine );
	/*
	typedef struct _DDHAL_GETSCANLINEDATA
	{
	    LPDDRAWI_DIRECTDRAW_GBL     lpDD;           // driver struct
	    DWORD                       dwScanLine;     // returned scan line
	    HRESULT                     ddRVal;         // return value
	    LPDDHAL_GETSCANLINE         GetScanLine;    // PRIVATE: ptr to callback
	} DDHAL_GETSCANLINEDATA;
	*/


	pd->dwScanLine = GetScanline();
	pd->ddRVal = DD_OK;
	return DDHAL_DRIVER_HANDLED;


//	pd->ddRVal = DDERR_UNSUPPORTED;
//	return DDHAL_DRIVER_HANDLED;
}

DWORD WINAPI HalSetExclusiveMode( LPDDHAL_SETEXCLUSIVEMODEDATA pd )
{
//	DEBUGENTER( HalSetExclusiveMode );

	RETAILMSG(0,(TEXT("HalSetExclusiveMode\r\n")));

	/*typedef struct _DDHAL_SETEXCLUSIVEMODEDATA
	{
		LPDDRAWI_DIRECTDRAW_GBL    lpDD;             // driver struct
		DWORD                      dwEnterExcl;      // TRUE if entering exclusive mode, FALSE is leaving
		DWORD                      dwReserved;       // reserved for future use
		HRESULT                    ddRVal;           // return value
		LPDDHAL_SETEXCLUSIVEMODE   SetExclusiveMode; // PRIVATE: ptr to callback
	} DDHAL_SETEXCLUSIVEMODEDATA;*/

    //g_pGPE->SetMode(0, 0);

	// implementation
	pd->ddRVal = DD_OK;

	return DDHAL_DRIVER_NOTHANDLED;   //ullas - HANDLED;
}

#endif //DD_SUPPORT