gpeflat.cpp

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

/*++
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) 1995-2000 Microsoft Corporation.  All rights reserved.

Module Name:

Abstract:

Functions:

Notes:

--*/

#include	"precomp.h"
#include	"vga.h"
#include	"palette.h"	// for 8Bpp we use the natural palette
#include	"bootarg.h"

INSTANTIATE_PALETTE

INSTANTIATE_GPE_ZONES(0x3,"MGDI Driver","unused1","unused2")	// Start with errors and warnings

#ifdef	DD_ENABLE
DDGPE	*gGPE = (DDGPE *)NULL;
#else	// DD_ENABLE
static	GPE	*gGPE = (GPE *)NULL;
#endif	// DD_ENABLE

// This prototype avoids problems exporting from .lib
BOOL APIENTRY GPEEnableDriver(ULONG engineVersion, ULONG cj, DRVENABLEDATA *data,
							  PENGCALLBACKS  engineCallbacks);

BOOL APIENTRY DrvEnableDriver(ULONG engineVersion, ULONG cj, DRVENABLEDATA *data,
							  PENGCALLBACKS  engineCallbacks)
{
	return GPEEnableDriver(engineVersion, cj, data, engineCallbacks);
}

//
// Main entry point for a GPE-compliant driver
//

GPE *GetGPE(void)
{
	if (!gGPE)
	{
		gGPE = new GPEFlat();
	}

	return gGPE;
}


GPEFlat::GPEFlat (void)
{
	DWORD		oldMode;
	PBOOT_ARGS	args;
	ULONG		fbSize;
	ULONG		fbOffset;
	ULONG		offsetX, offsetY;

	DEBUGMSG(GPE_ZONE_INIT,(TEXT("GPEFlat::GPEFlat\r\n")));

	oldMode = SetKMode(TRUE);

	args = (PBOOT_ARGS)(*(PBYTE *)BOOT_ARG_PTR_LOCATION);

	if (args != 0)
	{
		args = (PBOOT_ARGS)((DWORD)args | 0x80000000);

		// copy needed params from boot args
		m_VesaMode = (DWORD)args->vesaMode;
		m_nScreenWidth = (DWORD)args->cxDisplayScreen;
		m_nScreenHeight = (DWORD)args->cyDisplayScreen;
		m_colorDepth = (DWORD)args->bppScreen;
		m_pvFlatFrameBuffer = args->pvFlatFrameBuffer;
		m_cbScanLineLength = (DWORD)args->cbScanLineLength;
		m_cxPhysicalScreen = (DWORD)args->cxPhysicalScreen;
		m_cyPhysicalScreen = (DWORD)args->cyPhysicalScreen;
		m_RedMaskSize = (DWORD)args->RedMaskSize;
		m_RedMaskPosition = (DWORD)args->RedMaskPosition;
		m_GreenMaskSize = (DWORD)args->GreenMaskSize;
		m_GreenMaskPosition = (DWORD)args->GreenMaskPosition;
		m_BlueMaskSize = (DWORD)args->BlueMaskSize;
		m_BlueMaskPosition = (DWORD)args->BlueMaskPosition;
	}
	else
	{
		DEBUGMSG(GPE_ZONE_ERROR,(TEXT("No Boot Args passed to driver\r\n")));
		m_VesaMode = 0;
		m_nScreenWidth = 320;
		m_nScreenHeight = 200;
		m_colorDepth = 8;
		m_cxPhysicalScreen = 320;
		m_cyPhysicalScreen = 200;
		m_pvFlatFrameBuffer = 0x800A0000;
		m_cbScanLineLength = 320;
	}

	SetKMode(oldMode);

	// set rest of ModeInfo values
	m_ModeInfo.modeId = 0;
	m_ModeInfo.width = m_nScreenWidth;
	m_ModeInfo.height = m_nScreenHeight;
	m_ModeInfo.Bpp = m_colorDepth;
	m_ModeInfo.frequency = 60;	// ?
	switch (m_colorDepth)
	{
		case	8:
			m_ModeInfo.format = gpe8Bpp;
			break;

		case	16:
			m_ModeInfo.format = gpe16Bpp;
			break;

		case	24:
			m_ModeInfo.format = gpe24Bpp;
			break;

		case	32:
			m_ModeInfo.format = gpe32Bpp;
			break;

		default:
			DEBUGMSG(GPE_ZONE_ERROR,(TEXT("Invalid BPP value passed to driver - %d\r\n"), m_ModeInfo.Bpp));
			m_ModeInfo.format = gpeUndefined;
			break;
	}
	m_pMode = &m_ModeInfo;

	// compute frame buffer displayable area offset
	offsetX = (m_cxPhysicalScreen - m_nScreenWidth) / 2;
	offsetY = (m_cyPhysicalScreen - m_nScreenHeight) / 2;
	fbOffset = (offsetY * m_cbScanLineLength) + offsetX;

	// compute physical frame buffer size
	fbSize = (((m_cyPhysicalScreen * m_cbScanLineLength) >> 20) + 1) << 20;		// set size to next highest 1MB boundary

    // Make sure to allocate at least 2 megabytes of virtual address to
    // insure that the address comes out of the shared space rather than
    // the GWES address space.

	m_VirtualFrameBuffer = (DWORD)VirtualAlloc(0, max(fbSize, 2097152), MEM_RESERVE, PAGE_NOACCESS);

    if (m_VesaMode != 0)
	{
		VirtualCopy((void *)m_VirtualFrameBuffer, (void *)(m_pvFlatFrameBuffer >> 8), fbSize, PAGE_READWRITE | PAGE_NOCACHE | PAGE_PHYSICAL);
	}
	else
	{
		VirtualCopy((void *)m_VirtualFrameBuffer, (void *)m_pvFlatFrameBuffer, fbSize, PAGE_READWRITE | PAGE_NOCACHE);
	}

#ifdef	DD_ENABLE
	m_pPrimarySurface = new DDGPESurf(m_nScreenWidth, m_nScreenHeight, (void*)(m_VirtualFrameBuffer + fbOffset), m_cbScanLineLength, m_ModeInfo.format);
#else	// DD_ENABLE
	m_pPrimarySurface = new GPESurf(m_nScreenWidth, m_nScreenHeight, (void*)(m_VirtualFrameBuffer + fbOffset), m_cbScanLineLength, m_ModeInfo.format);
#endif	// DD_ENABLE

	memset ((void*)m_VirtualFrameBuffer, 0x0, fbSize);

	m_CursorVisible = FALSE;
	m_CursorDisabled = TRUE;
	m_CursorForcedOff = FALSE;
	memset (&m_CursorRect, 0x0, sizeof(m_CursorRect));
	m_CursorBackingStore = NULL;
	m_CursorXorShape = NULL;
	m_CursorAndShape = NULL;
}

SCODE	GPEFlat::SetMode (INT modeId, HPALETTE *palette)
{
	DEBUGMSG(GPE_ZONE_INIT,(TEXT("GPEFlat::SetMode\r\n")));

	if (modeId != 0)
	{
		DEBUGMSG(GPE_ZONE_ERROR,(TEXT("GPEFlat::SetMode Want mode %d, only have mode 0\r\n"),modeId));
		return	E_INVALIDARG;
	}

	if (palette)
	{
		switch (m_colorDepth)
		{
			case	8:
				*palette = EngCreatePalette (PAL_INDEXED,
											 PALETTE_SIZE,
											 (ULONG*)_rgbIdentity,
											 0,
											 0,
											 0);
				break;

			case	16:
			case	24:
			case	32:
				*palette = EngCreatePalette (PAL_BITFIELDS,
											 0,
											 NULL,
											 ((1 << m_RedMaskSize) - 1) << m_RedMaskPosition,
											 ((1 << m_GreenMaskSize) - 1) << m_GreenMaskPosition,
											 ((1 << m_BlueMaskSize) - 1) << m_BlueMaskPosition);
				break;
		}
	}

	return S_OK;
}

SCODE	GPEFlat::GetModeInfo(GPEMode *mode,	INT modeNumber)
{
	DEBUGMSG (GPE_ZONE_INIT, (TEXT("GPEFlat::GetModeInfo\r\n")));

	if (modeNumber != 0)
	{
		return E_INVALIDARG;
	}

	*mode = m_ModeInfo;

	return S_OK;
}

int		GPEFlat::NumModes()
{
	DEBUGMSG (GPE_ZONE_INIT, (TEXT("GPEFlat::NumModes\r\n")));
	return	1;
}

void	GPEFlat::CursorOn (void)
{
	UCHAR	*ptrScreen = (UCHAR*)m_pPrimarySurface->Buffer();
	UCHAR	*ptrLine;
	UCHAR	*cbsLine;
	UCHAR	*xorLine;
	UCHAR	*andLine;
	int		x, y;

	if (!m_CursorForcedOff && !m_CursorDisabled && !m_CursorVisible)
	{
		if (!m_CursorBackingStore)
		{
			DEBUGMSG (GPE_ZONE_ERROR, (TEXT("GPEFlat::CursorOn - No backing store available\r\n")));
			return;
		}

		for (y = m_CursorRect.top; y < m_CursorRect.bottom; y++)
		{
			if (y < 0)
			{
				continue;
			}
			if (y >= m_nScreenHeight)
			{
				break;
			}

			ptrLine = &ptrScreen[y * m_pPrimarySurface->Stride()];
			cbsLine = &m_CursorBackingStore[(y - m_CursorRect.top) * (m_CursorSize.x * (m_colorDepth >> 3))];
			xorLine = &m_CursorXorShape[(y - m_CursorRect.top) * m_CursorSize.x];
			andLine = &m_CursorAndShape[(y - m_CursorRect.top) * m_CursorSize.x];

			for (x = m_CursorRect.left; x < m_CursorRect.right; x++)
			{
				if (x < 0)
				{
					continue;
				}
				if (x >= m_nScreenWidth)
				{
					break;
				}

				cbsLine[(x - m_CursorRect.left) * (m_colorDepth >> 3)] = ptrLine[x * (m_colorDepth >> 3)];
				ptrLine[x * (m_colorDepth >> 3)] &= andLine[x - m_CursorRect.left];
				ptrLine[x * (m_colorDepth >> 3)] ^= xorLine[x - m_CursorRect.left];
				if (m_colorDepth > 8)
				{
					cbsLine[(x - m_CursorRect.left) * (m_colorDepth >> 3) + 1] = ptrLine[x * (m_colorDepth >> 3) + 1];
					ptrLine[x * (m_colorDepth >> 3) + 1] &= andLine[x - m_CursorRect.left];
					ptrLine[x * (m_colorDepth >> 3) + 1] ^= xorLine[x - m_CursorRect.left];
					if (m_colorDepth > 16)
					{
						cbsLine[(x - m_CursorRect.left) * (m_colorDepth >> 3) + 2] = ptrLine[x * (m_colorDepth >> 3) + 2];
						ptrLine[x * (m_colorDepth >> 3) + 2] &= andLine[x - m_CursorRect.left];
						ptrLine[x * (m_colorDepth >> 3) + 2] ^= xorLine[x - m_CursorRect.left];
					}
				}
			}
		}
		m_CursorVisible = TRUE;
	}
}

void	GPEFlat::CursorOff (void)
{
	UCHAR	*ptrScreen = (UCHAR*)m_pPrimarySurface->Buffer();
	UCHAR	*ptrLine;
	UCHAR	*cbsLine;
	int		x, y;

	if (!m_CursorForcedOff && !m_CursorDisabled && m_CursorVisible)
	{
		if (!m_CursorBackingStore)
		{
			DEBUGMSG (GPE_ZONE_ERROR, (TEXT("GPEFlat::CursorOff - No backing store available\r\n")));
			return;
		}

		for (y = m_CursorRect.top; y < m_CursorRect.bottom; y++)
		{
			// clip to displayable screen area (top/bottom)
			if (y < 0)
			{
				continue;
			}
			if (y >= m_nScreenHeight)
			{
				break;
			}

			ptrLine = &ptrScreen[y * m_pPrimarySurface->Stride()];
			cbsLine = &m_CursorBackingStore[(y - m_CursorRect.top) * (m_CursorSize.x * (m_colorDepth >> 3))];

			for (x = m_CursorRect.left; x < m_CursorRect.right; x++)
			{
				// clip to displayable screen area (left/right)
				if (x < 0)
				{
					continue;
				}
				if (x >= m_nScreenWidth)
				{
					break;
				}

				ptrLine[x * (m_colorDepth >> 3)] = cbsLine[(x - m_CursorRect.left) * (m_colorDepth >> 3)];
				if (m_colorDepth > 8)
				{
					ptrLine[x * (m_colorDepth >> 3) + 1] = cbsLine[(x - m_CursorRect.left) * (m_colorDepth >> 3) + 1];
					if (m_colorDepth > 16)
					{
						ptrLine[x * (m_colorDepth >> 3) + 2] = cbsLine[(x - m_CursorRect.left) * (m_colorDepth >> 3) + 2];
					}
				}
			}
		}
		m_CursorVisible = FALSE;
	}
}

SCODE	GPEFlat::SetPointerShape(GPESurf *pMask, GPESurf *pColorSurf, INT xHot, INT yHot, INT cX, INT cY)
{
	UCHAR	*andPtr;		// input pointer
	UCHAR	*xorPtr;		// input pointer
	UCHAR	*andLine;		// output pointer
	UCHAR	*xorLine;		// output pointer
	char	bAnd;
	char	bXor;
	int		row;
	int		col;
	int		i;
	int		bitMask;

	DEBUGMSG(GPE_ZONE_CURSOR,(TEXT("GPEFlat::SetPointerShape(0x%X, 0x%X, %d, %d, %d, %d)\r\n"),pMask, pColorSurf, xHot, yHot, cX, cY));

	// turn current cursor off
	CursorOff();

	// release memory associated with old cursor
	if (m_CursorBackingStore)
	{
		delete (void*)m_CursorBackingStore;
		m_CursorBackingStore = NULL;
	}
	if (m_CursorXorShape)
	{
		delete (void*)m_CursorXorShape;
        m_CursorXorShape = NULL;
	}
	if (m_CursorAndShape)
	{
		delete (void*)m_CursorAndShape;
        m_CursorAndShape = NULL;
	}

	if (!pMask)							// do we have a new cursor shape
	{
		m_CursorDisabled = TRUE;		// no, so tag as disabled