sa_lcd2.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"
extern DWORD dwLCDBaseVirtual;
extern DWORD dwGPIOBaseVirtaul;
extern DWORD dwLCDVirtualFrameBase;
extern DWORD dwLCDPhysicalFrameBase;

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

static	GPE		*gGPE = (GPE*)NULL;
static	ulong	gBitMasks[] = { 0xF800, 0x07E0, 0x001F };		// 565 MODE

// 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 SA_LCD2();
	}

	return gGPE;
}

WORD	TempBuffer[241][320];

SA_LCD2::SA_LCD2 (void)
{
	DEBUGMSG(GPE_ZONE_INIT,(TEXT("SA_LCD2::SA_LCD2\r\n")));

	// setup up display mode related constants
	m_nScreenWidth = 320;
	m_nScreenHeight = 240;
	m_colorDepth = 16;
	m_cbScanLineLength = m_nScreenWidth * 2;
	m_FrameBufferSize = m_nScreenHeight * m_cbScanLineLength;

	// setup ModeInfo structure
	m_ModeInfo.modeId = 0;
	m_ModeInfo.width = m_nScreenWidth;
	m_ModeInfo.height = m_nScreenHeight;
	m_ModeInfo.Bpp = m_colorDepth;
	m_ModeInfo.format = gpe16Bpp;
	m_ModeInfo.frequency = 60;	// ?
	m_pMode = &m_ModeInfo;

	// memory map register access window, frame buffer, and program LCD controller
	InitializeHardware();
//	m_VirtualFrameBuffer = (DWORD)TempBuffer;

	// allocate primary display surface
	m_pPrimarySurface = new GPESurf(m_nScreenWidth, m_nScreenHeight, (void*)(m_VirtualFrameBuffer + 32), m_cbScanLineLength, m_ModeInfo.format);
	memset ((void*)m_pPrimarySurface->Buffer(), 0x0, m_FrameBufferSize);

	// init cursor related vars
	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;
}

void	SA_LCD2::InitializeHardware (void)
{
	WORD	*ptr;

	// map LCD register access window into process space memory
//	m_LCDRegs = (struct lcdregs *)VirtualAlloc (0, 0x1000, MEM_RESERVE, PAGE_NOACCESS);
//	VirtualCopy ((void*)m_LCDRegs, (void*)LCD_BASE_VIRTUAL, 0x1000, PAGE_READWRITE | PAGE_NOCACHE);
	m_LCDRegs = (struct lcdregs *)VirtualAllocCopy(0x1000, NULL, (PVOID)(dwLCDBaseVirtual));

	// map GPIO register access window into process space memory
//	m_GPIORegs = (struct gpioreg *)VirtualAlloc (0, 0x1000, MEM_RESERVE, PAGE_NOACCESS);
//	VirtualCopy ((void*)m_GPIORegs, (void*)GPIO_BASE_VIRTUAL, 0x1000, PAGE_READWRITE | PAGE_NOCACHE);
	m_GPIORegs = (struct gpioreg *)VirtualAllocCopy(0x1000, NULL, (PVOID)(dwGPIOBaseVirtaul));

	// map frame buffer into process space memory
//	m_VirtualFrameBuffer = (DWORD)VirtualAlloc(0, 0x48000, MEM_RESERVE, PAGE_NOACCESS);
//	VirtualCopy((void*)m_VirtualFrameBuffer, (void *)LCD_VIRTUAL_FRAME_BASE, 0x48000, PAGE_READWRITE | PAGE_NOCACHE);
	m_VirtualFrameBuffer = (DWORD)VirtualAllocCopy(0x48000, NULL, (PVOID)(dwLCDVirtualFrameBase));

	// init "palette" area - just has some flags for 16bpp active display mode
	ptr = (WORD*)m_VirtualFrameBuffer;
	ptr[0] = 0x2000;
	for(int index = 1; index < 16; index++)
	{
		ptr[index] = 0x00000000;
	}

	// clear rest of frame buffer out
	for(index = 0; index < 320*240; index++)
	{
		if(index < 3200)
		{
			ptr[index + 16] = 0xf800;
		}
		else if(index < 6400)
		{
			ptr[index + 16] = 0x07e0;
		}
		else if(index < 9600)
		{
			ptr[index + 16] = 0x001f;
		}
		else
		{
			ptr[index + 16] = 0xffff;
		}
	}


	// Set Board Control Register (BCR) for Sharp LCD mode
	set_BCRVal (BCR_LCD_LQ039Q2DS01_16BPP | BCR_LCD_POWER_ON, NOMASK, INPOWERHANDLER);

	RETAILMSG(1, (L"m_LCDRegs = %8.8x\nm_GPIORegs = %8.8x\nm_VirtualFrameBuffer = %8.8x\n", m_LCDRegs, m_GPIORegs, m_VirtualFrameBuffer));

	// Program GPIO register to enable GPIO lines 2 - 9 for use by the LCD controller
	WRITE_BITFIELD(struct gpioregBits,&m_GPIORegs->gpdr,gp02,1);
	WRITE_BITFIELD(struct gpioregBits,&m_GPIORegs->gpdr,gp03,1);
	WRITE_BITFIELD(struct gpioregBits,&m_GPIORegs->gpdr,gp04,1);
	WRITE_BITFIELD(struct gpioregBits,&m_GPIORegs->gpdr,gp05,1);
	WRITE_BITFIELD(struct gpioregBits,&m_GPIORegs->gpdr,gp06,1);
	WRITE_BITFIELD(struct gpioregBits,&m_GPIORegs->gpdr,gp07,1);
	WRITE_BITFIELD(struct gpioregBits,&m_GPIORegs->gpdr,gp08,1);
	WRITE_BITFIELD(struct gpioregBits,&m_GPIORegs->gpdr,gp09,1);
	WRITE_BITFIELD(struct gpioregBits,&m_GPIORegs->gafr,gp02,1);
	WRITE_BITFIELD(struct gpioregBits,&m_GPIORegs->gafr,gp03,1);
	WRITE_BITFIELD(struct gpioregBits,&m_GPIORegs->gafr,gp04,1);
	WRITE_BITFIELD(struct gpioregBits,&m_GPIORegs->gafr,gp05,1);
	WRITE_BITFIELD(struct gpioregBits,&m_GPIORegs->gafr,gp06,1);
	WRITE_BITFIELD(struct gpioregBits,&m_GPIORegs->gafr,gp07,1);
	WRITE_BITFIELD(struct gpioregBits,&m_GPIORegs->gafr,gp08,1);
	WRITE_BITFIELD(struct gpioregBits,&m_GPIORegs->gafr,gp09,1);

	// disable LCD controller
	WRITE_BITFIELD(struct lccr0Bits,&m_LCDRegs->lccr0,len,0);

	WRITE_BITFIELD(struct lccr0Bits,&m_LCDRegs->lccr0,cms,0);
	WRITE_BITFIELD(struct lccr0Bits,&m_LCDRegs->lccr0,sds,0);
	WRITE_BITFIELD(struct lccr0Bits,&m_LCDRegs->lccr0,bam,1);
	WRITE_BITFIELD(struct lccr0Bits,&m_LCDRegs->lccr0,ldm,1);
	WRITE_BITFIELD(struct lccr0Bits,&m_LCDRegs->lccr0,erm,1);
	WRITE_BITFIELD(struct lccr0Bits,&m_LCDRegs->lccr0,pas,1);
	WRITE_BITFIELD(struct lccr0Bits,&m_LCDRegs->lccr0,ble,0);
	WRITE_BITFIELD(struct lccr0Bits,&m_LCDRegs->lccr0,dpd,0);
	WRITE_BITFIELD(struct lccr0Bits,&m_LCDRegs->lccr0,pdd,0);

	m_LCDRegs->dbar1 = dwLCDPhysicalFrameBase;

	WRITE_BITFIELD(struct lccr2Bits,&m_LCDRegs->lccr2,efw,0x0);
	WRITE_BITFIELD(struct lccr3Bits,&m_LCDRegs->lccr3,acb,0);
	WRITE_BITFIELD(struct lccr3Bits,&m_LCDRegs->lccr3,api,0);
	WRITE_BITFIELD(struct lccr3Bits,&m_LCDRegs->lccr3,vsp,0);
	WRITE_BITFIELD(struct lccr3Bits,&m_LCDRegs->lccr3,hsp,0);
	WRITE_BITFIELD(struct lccr3Bits,&m_LCDRegs->lccr3,pcp,0);
	WRITE_BITFIELD(struct lccr3Bits,&m_LCDRegs->lccr3,oep,0);

	WRITE_BITFIELD(struct lccr2Bits,&m_LCDRegs->lccr2,vsw,0x1);
	WRITE_BITFIELD(struct lccr1Bits,&m_LCDRegs->lccr1,hsw,0x3e);
	WRITE_BITFIELD(struct lccr1Bits,&m_LCDRegs->lccr1,elw,0x12);
	WRITE_BITFIELD(struct lccr1Bits,&m_LCDRegs->lccr1,blw,0x39);

	WRITE_BITFIELD(struct lccr1Bits,&m_LCDRegs->lccr1,ppl,0x130);
	WRITE_BITFIELD(struct lccr2Bits,&m_LCDRegs->lccr2,lpp,0x0ef);
	WRITE_BITFIELD(struct lccr2Bits,&m_LCDRegs->lccr2,bfw,0x3);
	WRITE_BITFIELD(struct lccr3Bits,&m_LCDRegs->lccr3,pcd,0xC);
	
	// clear LCD Status Register
	WRITE_BITFIELD(struct lcsrBits,&m_LCDRegs->lcsr,ber,1);
	WRITE_BITFIELD(struct lcsrBits,&m_LCDRegs->lcsr,abc,1);
	WRITE_BITFIELD(struct lcsrBits,&m_LCDRegs->lcsr,iol,1);
	WRITE_BITFIELD(struct lcsrBits,&m_LCDRegs->lcsr,iul,1);
	WRITE_BITFIELD(struct lcsrBits,&m_LCDRegs->lcsr,iou,1);
	WRITE_BITFIELD(struct lcsrBits,&m_LCDRegs->lcsr,iuu,1);
	WRITE_BITFIELD(struct lcsrBits,&m_LCDRegs->lcsr,ool,1);
	WRITE_BITFIELD(struct lcsrBits,&m_LCDRegs->lcsr,oul,1);
	WRITE_BITFIELD(struct lcsrBits,&m_LCDRegs->lcsr,oou,1);
	WRITE_BITFIELD(struct lcsrBits,&m_LCDRegs->lcsr,ouu,1);

	// enable LCD controller
	WRITE_BITFIELD(struct lccr0Bits,&m_LCDRegs->lccr0,len,1);
}

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

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

	if (palette)
	{
		*palette = EngCreatePalette (PAL_BITFIELDS, 0, NULL, gBitMasks[0], gBitMasks[1], gBitMasks[2]);
	}

	return S_OK;
}

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

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

	*mode = m_ModeInfo;

	return S_OK;
}

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

void	SA_LCD2::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("SA_LCD2::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	SA_LCD2::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("SA_LCD2::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;
	}