haldd.cpp

AU1100嵌入式处理器lcd显示驱动程序

// -----------------------------------------------------------------------------
//
//  THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
//  ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
//  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
//  PARTICULAR PURPOSE.
//
//  Copyright (c) 1997-2000 Microsoft Corporation. All Rights Reserved.
//  COPYRIGHT (C) 1999-2000 IGS TECHNOLOGIES, INC. (iGST)
//
// -----------------------------------------------------------------------------

#ifdef DDRAW_ENABLE

#include "headers.h"

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

DWORD WINAPI HalGetDriverInfo(LPDDHAL_GETDRIVERINFODATA lpInput) {

    DWORD dwSize;
	DEBUGMSG(HAL_ZONE_INIT,(TEXT("GetDriverInfo invoked !!\r\n")));

    lpInput->ddRVal = DDERR_CURRENTLYNOTAVAIL;

    if (IsEqualIID(lpInput->guidInfo, GUID_KernelCallbacks) ) {
		DEBUGMSG(HAL_ZONE_INIT,(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(HAL_ZONE_INIT,(TEXT("GUID_HALMemory\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(HAL_ZONE_INIT,(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(HAL_ZONE_INIT,(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(HAL_ZONE_INIT,(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;
    }

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

    return DDHAL_DRIVER_HANDLED;
}


//////////////////////////// DDHAL_DDCALLBACKS ////////////////////////////
DWORD WINAPI HalDestroyDriver( LPDDHAL_DESTROYDRIVERDATA pd )
{
	DEBUGENTER( HalDestroyDriver );
	/*
	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 );

	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 );
	/*
	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;
	*/

	// implementation
	pd->ddRVal = DD_OK;

	return DDHAL_DRIVER_NOTHANDLED; // We only support 1 mode
}

DWORD WINAPI HalWaitForVerticalBlank( LPDDHAL_WAITFORVERTICALBLANKDATA pd )
{
	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 (pd->dwFlags) {
	case DDWAITVB_I_TESTVB:
		// If TESTVB, it's just a request for the current vertical blank
		// status:
		pd->bIsInVB = IN_VBLANK;
		break;
	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_VBLANK);
		break;
	case DDWAITVB_BLOCKEND:
		// If BLOCKEND is requested, we wait for the vblank interval to end:
        if( IN_VBLANK )
        {
            while( IN_VBLANK );
        }
        else
        {
            while(!IN_VBLANK);
            while(IN_VBLANK);
        }
		break;

	default: // anything else is an error
	case DDWAITVB_BLOCKBEGINEVENT:
		// we don't support this
		return DDHAL_DRIVER_NOTHANDLED;
    }

	pd->ddRVal = DD_OK;
	return DDHAL_DRIVER_HANDLED;
}


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->ddRVal = DDERR_UNSUPPORTED;
	return DDHAL_DRIVER_HANDLED;
}


DWORD WINAPI HalSetExclusiveMode( LPDDHAL_SETEXCLUSIVEMODEDATA pd )
{
	DEBUGENTER( HalSetExclusiveMode );
	/*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;*/

	// implementation
	pd->ddRVal = DD_OK;

	return DDHAL_DRIVER_HANDLED;
}

#endif DDRAW_ENABLE