video.cpp

Xcale270Bsp包,wince平台

/* 
** INTEL CONFIDENTIAL
** Copyright 2000-2003 Intel Corporation All Rights Reserved.
**
** The source code contained or described herein and all documents
** related to the source code (Material) are owned by Intel Corporation
** or its suppliers or licensors.  Title to the Material remains with
** Intel Corporation or its suppliers and licensors. The Material contains
** trade secrets and proprietary and confidential information of Intel
** or its suppliers and licensors. The Material is protected by worldwide
** copyright and trade secret laws and treaty provisions. No part of the
** Material may be used, copied, reproduced, modified, published, uploaded,
** posted, transmitted, distributed, or disclosed in any way without Intel抯
** prior express written permission.

** No license under any patent, copyright, trade secret or other intellectual
** property right is granted to or conferred upon you by disclosure or
** delivery of the Materials, either expressly, by implication, inducement,
** estoppel or otherwise. Any license under such intellectual property rights
** must be express and approved by Intel in writing.
*/
#include <windows.h>
#include <types.h>

#include <nkintr.h>
#include <oalintr.h>

#include "xsc1.h"
#include "bcr.h"
#include "drv_glob.h"
#include "precomp.h"
#include "cursor.h"

extern "C" PVOID VirtualAllocCopy(unsigned size,char *str,PVOID pVirtualAddress);
extern "C" void DispDrvrSetPalette(const PALETTEENTRY *,USHORT,USHORT);
extern "C" void DisplayPageBuffer(int page);
extern "C" void *gFrameBuffer;
extern "C" volatile LCD_PALETTE *v_pPaletteBuffer;
extern "C" BOOL bAllowOSFrameBufferUpdates;
extern "C" void ScrollBuffer(int direction);

volatile SA2lcdregs	*v_pLcdRegs = NULL;
volatile GPIO_REGS	*v_pGPIORegs = NULL;


// Function pointer to the caller's vertical blank interrupt processing function.
void (*fnVerticalBlankInterrupt)(int page);

static GPE *pGPE = (GPE *)NULL;

// These masks are used to extract the color component for a 16 bit pixel value.  5 bits red, 6 bits green, 5 bits blue.
ulong BitMasks[] = {0xF800, 0x07E0, 0x001F};

INSTANTIATE_GPE_ZONES(0x3,"GDI Driver","unused1","unused2")	 /* Start with Errors, warnings, and temporary messages */

BOOL APIENTRY GPEEnableDriver(
	ULONG          iEngineVersion,
	ULONG          cj,
	DRVENABLEDATA *pded,
	PENGCALLBACKS  pEngCallbacks);

BOOL APIENTRY DrvEnableDriver(
	ULONG          iEngineVersion,
	ULONG          cj,
	DRVENABLEDATA *data,
	PENGCALLBACKS  pEngineCallbacks)
{
	GPEEnableDriver(iEngineVersion,cj,data,pEngineCallbacks);
	return TRUE;
}


// Main entry point for a GPE-compliant driver

GPE *GetGPE(void)
{
	if(!pGPE) {
		pGPE = new SA2Video();
	}
	return pGPE;
}


BOOL SA2Video::IsrThreadProc()
{
/*
	struct lcsrBits lcsr;

	v_pLcdRegs = (struct lcdregs *)VirtualAllocCopy(0x1000,"DispDrvrInitialize : v_pLcdRegs",(PVOID)(LCD_BASE_VIRTUAL));
	v_pGPIORegs = (struct gpioreg *)VirtualAllocCopy(0x1000,"DispDrvrInitialize : v_pGPIORegs",(PVOID)(GPIO_BASE_VIRTUAL));
	RETAILMSG(1,(TEXT("Launching LCD ISR thread. \r\n")));
	IOW_REG_BITWRITE (struct gpioregBits, &v_pGPIORegs->gpcr, gp17,1);  //set L3Clock bit High

	SetThreadPriority(GetCurrentThread(),THREAD_PRIORITY_HIGHEST);
	if (m_hevInterrupt = CreateEvent(NULL,FALSE,FALSE,NULL)) {
		if (InterruptInitialize(SYSINTR_LCD,m_hevInterrupt,NULL,0)) {
			while (1) 
			{
				//set_BCRVal(0x2000 | 0x4000,NOMASK, 1); // set green and red to turn them off
				IOW_REG_BITWRITE (struct gpioregBits, &v_pGPIORegs->gpsr, gp17,1);  //set L3Clock bit High
				WaitForSingleObject(m_hevInterrupt,INFINITE);
				//RETAILMSG(1,(TEXT("LCD ISR Detected\r\n")));
				//RETAILMSG(1,(TEXT("LCD status register is: 0x%x \r\n"), v_pLcdRegs->lcsr));

				if (v_pLcdRegs->lcsr.oul == 1)
				{
//					set_BCRVal(NOMASK,0x4000, 1); // clear green to turn it on
					IOW_REG_BITWRITE (struct gpioregBits, &v_pGPIORegs->gpcr, gp17,1);  //set L3Clock bit High
					WRITE_BITFIELD(struct lcsrBits, &v_pLcdRegs->lcsr,oul,1);
					v_pLcdRegs->lcsr.oul = 1;
				}
				if (v_pLcdRegs->lcsr.ouu == 1)
				{
//					set_BCRVal(NOMASK,0x2000, 1); // clear red to turn it on
					IOW_REG_BITWRITE (struct gpioregBits, &v_pGPIORegs->gpcr, gp17,1);  //set L3Clock bit High
					WRITE_BITFIELD(struct lcsrBits, &v_pLcdRegs->lcsr,ouu,1);
				}

				InterruptDone(SYSINTR_LCD);
			}
		}
	}
*/
	return TRUE;
}

DWORD LCDIsrThread(SA2Video *p)
{
	p->IsrThreadProc();
	return 0;
}

BOOL SA2Video::IsrThreadStart()
{
	HANDLE	hthrd;
	hthrd = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)LCDIsrThread,this,0,NULL);
	CloseHandle(hthrd);
	return TRUE;
}


VOID SA2Video::PowerHandler(BOOL bOff)
{
    DispDrvrPowerHandler(bOff);
}

SA2Video::SA2Video(void)
{
	int i;
	volatile char *fb;

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


	// Determine the display type
	// Setup the LCD controller for that display
	// Power up and enable the display
	DispDrvrInitialize();

	
	m_ModeInfo.modeId = 0;
	m_ModeInfo.width = m_nScreenWidth = DispDrvr_cxScreen;
	m_ModeInfo.height = m_nScreenHeight = DispDrvr_cyScreen;
	m_ModeInfo.Bpp = bpp;
	m_ModeInfo.frequency = 60;
	m_ModeInfo.format = bpp == 8 ? gpe8Bpp : gpe16Bpp;
	m_pMode = &m_ModeInfo;
	if(DispDrvrPhysicalFrameBuffer == NULL) 
	{
		// The GPE will allocate a virtual frame buffer and draw to that.
		// The driver will copy this virtual frame buffer to the physical frame buffer
		// using the dirty rectangle algorithm.
		m_pPrimarySurface = new GPESurf(m_nScreenWidth,m_nScreenHeight,m_ModeInfo.format);
		
		// Clear the video memory
		memset(m_pPrimarySurface->Buffer(),0,m_pPrimarySurface->Height()*m_pPrimarySurface->Width());
		DispDrvrSetDibBuffer(m_pPrimarySurface->Buffer());
	} else 
	{
		// The GPE will draw directly to the physical frame buffer.
		m_pVirtualFrameBuffer = gFrameBuffer;
		// Init the frame buffer to color pattern - 
	    m_pPrimarySurface = new GPESurf(m_nScreenWidth,m_nScreenHeight,m_pVirtualFrameBuffer,
			 DispDrvr_cdwStride * 4,m_ModeInfo.format);
	}
	// Invoke the Interrupt Service Thread if desired (for debug purposes)
	//IsrThreadStart();

}

SCODE SA2Video::SetMode(int modeId,HPALETTE *pPalette)
{
	if(modeId != 0)
		return E_INVALIDARG;
	// Here, we use EngCreatePalette to create a palette that that MGDI will use as a
	// stock palette
	if(pPalette) {
        *pPalette = EngCreatePalette(PAL_BITFIELDS,0,NULL,BitMasks[0],BitMasks[1],BitMasks[2]);
	}
	return S_OK;
}

SCODE SA2Video::GetModeInfo(GPEMode *pMode,int modeNumber)
{
	if(modeNumber != 0)
		return E_INVALIDARG;
	*pMode = m_ModeInfo;
	return S_OK;
}

int SA2Video::NumModes(void)
{
	return 1;
}

SCODE SA2Video::SetPointerShape(GPESurf *pMask,GPESurf *pColorSurf,int xHot,int yHot,int cX,int cY)
{
	int			row,colByte;
	BYTE		*pAND;
	BYTE		*pXOR;
	BYTE		bitMask;
	unsigned	i;

	if (!pMask) {		// Turn off the cursor.
		memset((BYTE *)gCursorMask,0xFF,sizeof(gCursorMask));
		memset((BYTE *)gCursorData,0x00,sizeof(gCursorData));
	} else 
	{
		i=0;
		for (row=0;row<cY;row++) 
		{
			for (colByte=0;colByte<cX/8;colByte++) 
			{
				pAND=(unsigned char *)pMask->Buffer()+(row*pMask->Stride())+colByte;
				pXOR=pAND+(cY*pMask->Stride());
				for (bitMask=0x0080;bitMask;bitMask>>=1) 
				{
					gCursorMask[i] = (*pAND & bitMask) ? 0xFFFF : 0x0000;
					gCursorData[i] = (*pXOR & bitMask) ? 0xFFFF : 0x0000;
					i++;
				}
			}
		}
		gxHot=xHot;
		gyHot=yHot;
	}
	return S_OK;
}

SCODE SA2Video::MovePointer(int xPosition,int yPosition)
{
	if(xPosition == -1) 
	{
		// disable cursor
		DispDrvrMoveCursor(DispDrvr_cxScreen,DispDrvr_cyScreen);		
	} else 
	{
		// enable cursor
		DispDrvrMoveCursor(xPosition,yPosition);
	}
	return S_OK;
}

void SA2Video::WaitForNotBusy(void)
{
	return;
}

int SA2Video::IsBusy(void)
{
	return 0;	// Never busy as there is no acceleration
}

void SA2Video::GetPhysicalVideoMemory(unsigned long *pPhysicalMemoryBase,unsigned long *pVideoMemorySize)
{
	*pPhysicalMemoryBase = (ULONG)FRAME_BUFFER_0_BASE_VIRTUAL;
	// cdwStride is in DWORDs, convert to bytes
	*pVideoMemorySize = DispDrvr_cdwStride * DispDrvr_cyScreen * 4;
}

SCODE SA2Video::AllocSurface(GPESurf **surface,INT width,INT height,EGPEFormat format,INT surfaceFlags)
{
	if (surfaceFlags & GPE_REQUIRE_VIDEO_MEMORY) {
        // Can't allocate video-memory surfaces in the SA2Video environment
		return E_OUTOFMEMORY;
	}
	// Allocate from system memory
	*surface = new GPESurf(width,height,format);
	if (*surface != NULL) {
		// Check that the bits were allocated succesfully
		if (((*surface)->Buffer()) == NULL) 
		{
			delete *surface;
		} else 
		{
			return S_OK;
		}
	}
	return E_OUTOFMEMORY;
}

SCODE SA2Video::WrappedEmulatedLine(GPELineParms *pParms)
{
	SCODE code = EmulatedLine(pParms);	// Draw to the backup framebuffer
	if(FAILED(code))
		return code;
	// Now, calculate the dirty-rect to refresh to the actual hardware
	RECT bounds;
	int N_plus_1;			// Minor length of bounding rect + 1