?? gpeaccel.cpp
字號:
//**********************************************************************
//
// Filename: gpeaccel.cpp
//
// Description: Accelerated video driver for the EP9312.
//
// 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.
//
// Use of this source code is subject to the terms of the Cirrus end-user
// license agreement (EULA) under which you licensed this SOFTWARE PRODUCT.
// If you did not accept the terms of the EULA, you are not authorized to
// use this source code. For a copy of the EULA, please see the
// EULA.RTF on your install media.
//
// Copyright(c) Cirrus Logic Corporation 2002, All Rights Reserved
//
//**********************************************************************
#include "precomp.h"
#include "..\common\palette.h" // for 8Bpp we use the natural palette
INSTANTIATE_PALETTE
#ifdef DD_ENABLE
extern "C" void FlushDCache(void);
#endif
//
// Set up the debug zones.
//
INSTANTIATE_GPE_ZONES(0x0003,"Accelerated DDI Driver","Palette","unused2") // Start with errors and warnings
#define GPE_ZONE_PALETTE DEBUGZONE(14)
static GPE *gGPE = (GPE*)NULL;
// This prototype avoids problems exporting from .lib
BOOL APIENTRY GPEEnableDriver(ULONG engineVersion, ULONG cj, DRVENABLEDATA *data,
PENGCALLBACKS engineCallbacks);
//****************************************************************************
// DrvEnableDriver
//****************************************************************************
//
BOOL APIENTRY DrvEnableDriver(ULONG engineVersion, ULONG cj, DRVENABLEDATA *data,
PENGCALLBACKS engineCallbacks)
{
return GPEEnableDriver(engineVersion, cj, data, engineCallbacks);
}
#ifndef DD_ENABLE
void APIENTRY HALInit()
{
DEBUGMSG( 0,(TEXT("HALInit: Stub, Shouldn't have come in hereX\n")));
RETAILMSG( 0,(TEXT("HALInit: Stub, Shouldn't have come in hereX\n")));
}
#endif
//****************************************************************************
// GetGPE
//****************************************************************************
// Main entry point for a GPE-compliant driver
//
//
GPE *GetGPE(void)
{
if (!gGPE)
{
gGPE = new GPEAccel();
}
return gGPE;
}
//****************************************************************************
// GPEAccel::GPEAccel
//****************************************************************************
// GPEAccel Constructor
//
GPEAccel::GPEAccel (void)
{
DWORD oldMode;
SurfaceHeapV* pNode;
RETAILMSG(1,(TEXT("Init Raster engine\r\n")));
oldMode = SetKMode(TRUE);
//
// Read in the settings from the registry.
//
GetDisplayRegistrySettings(&m_Registry);
//
// Initialize the values that are being used.
//
#ifdef DD_ENABLE
m_VirtualFrameBuffer = FRAMEBUF_MEMORY_OFFSET | SDRAM_VIRTUAL_MEMORY;
#else
m_VirtualFrameBuffer = FRAMEBUF_VIRTUAL_MEMORY;
#endif
m_pvFlatFrameBuffer = FRAMEBUF_PHYSICAL_MEMORY;
m_ulColorDepth = m_Registry.ulColorDepth;
m_nScreenWidth = m_Registry.ulScreenWidth;
m_nScreenHeight = m_Registry.ulScreenHeight;
//
// If the flag Set Directly is used then take the Raster values directly
// from the registry.
//
if(m_Registry.ulSetDirectly)
{
//
// Use the values from the registry to setup the display.
//
GenericDisplaySetup(&m_Registry, m_pvFlatFrameBuffer, &m_StartStop);
}
else
{
//
// Use the generic CRT setup.
//
CRTVideoSetup
(
m_nScreenWidth,
m_nScreenHeight,
m_ulColorDepth,
m_Registry.ulFrequency,
m_pvFlatFrameBuffer,
&m_StartStop
);
}
//
// Save off the video attributes register.
//
m_ulVideoAttrib = *RASTER_VIDEOATTRIBS | VIDEOATTRIBS_SDSEL_CS3;
//
// Program the proper color depth settings.
//
switch(m_ulColorDepth)
{
case 8:
//
// Set up the Color Look up table. There are two LUT's in hardware.
// the lookup table that is visible is not the one that is accessable.
//
SetPalette(_rgbIdentity, 0 , PALETTE_SIZE);
//
// Set up the Pixel mode.
//
*RASTER_PIXELMODE = PIXELMODE_C_LUT | PIXELMODE_M_BLINKDISABLED |
PIXELMODE_S_MODE1 | PIXELMODE_P_8BITS;
m_ModeInfo.format = gpe8Bpp;
break;
case 16:
*RASTER_PIXELMODE = PIXELMODE_C_565 | PIXELMODE_M_BLINKDISABLED | PIXELMODE_S_MODE1 |
PIXELMODE_P_16BITS;
//
// Since we are not using a palette, setup red, green and blue masks.
//
m_RedMaskSize = 5;
m_RedMaskPosition = 11;
m_GreenMaskSize = 6;
m_GreenMaskPosition = 5;
m_BlueMaskSize = 5;
m_BlueMaskPosition = 0;
m_ModeInfo.format = gpe16Bpp;
break;
case 24:
*RASTER_PIXELMODE = PIXELMODE_C_TRIPLE8 | PIXELMODE_M_BLINKDISABLED | PIXELMODE_S_MODE1 |
PIXELMODE_P_24BITS;
//
// Since we are not using a palette, setup red, green and blue masks.
//
m_RedMaskSize = 8;
m_RedMaskPosition = 16;
m_GreenMaskSize = 8;
m_GreenMaskPosition = 8;
m_BlueMaskSize = 8;
m_BlueMaskPosition = 0;
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;
//
// Copy a few more variables.
//
m_cxPhysicalScreen = m_nScreenWidth;
m_cyPhysicalScreen = m_nScreenHeight;
m_cbScanLineLength = m_cxPhysicalScreen * (m_ulColorDepth /8);
//
// set rest of ModeInfo values
//
m_ModeInfo.modeId = 0;
m_ModeInfo.width = m_nScreenWidth;
m_ModeInfo.height = m_nScreenHeight;
m_ModeInfo.Bpp = m_ulColorDepth;
m_ModeInfo.frequency = m_Registry.ulFrequency;
//
// Clear the screen.
//
RETAILMSG(1,(TEXT("Clearing screen\r\n")));
memset ((void*)m_VirtualFrameBuffer, 0x0, FRAMEBUF_MEMORY_SIZE);
DEBUGMSG (GPE_ZONE_LINE,(TEXT("memset of video\r\n")));
m_pPrimarySurface = new GPE93xxSurf
(
m_nScreenWidth,
m_nScreenHeight,
(void*)FRAMEBUF_VIRTUAL_MEMORY,
m_cbScanLineLength,
m_ModeInfo.format,
FRAMEBUF_PHYSICAL_MEMORY
);
//
// Allocate Video Memory for BitBlt
//
m_VideoMemSize = FRAMEBUF_MEMORY_SIZE - m_cyPhysicalScreen * m_cbScanLineLength ;
m_VideoMemVirAddr = m_VirtualFrameBuffer + m_cyPhysicalScreen * m_cbScanLineLength;
m_VideoMemPhyAddr = m_pvFlatFrameBuffer + m_cyPhysicalScreen * m_cbScanLineLength;
DEBUGMSG (GPE_ZONE_LINE,(TEXT("FramBUffer Size %x VideoMemory Size %x\r\n"),m_cyPhysicalScreen * m_cbScanLineLength,m_VideoMemSize));
//
// Initialize Video Memory SurfaceHeap
//
m_VideoMemPhyOffet = m_VideoMemPhyAddr - m_VideoMemVirAddr;
m_pSurfHeap = new SurfaceHeapV(m_VideoMemSize, m_VideoMemVirAddr);
if( m_pSurfHeap != NULL )
{
DEBUGMSG (GPE_ZONE_LINE, (TEXT("Initializing Video Memory SurfaceHeap succeeded\r\n")));
}
else
{
DEBUGMSG (GPE_ZONE_LINE, (TEXT("Initializing Video Memory SurfaceHeap failed\r\n")));
return;
}
//
// Allocate Memory For hardware cursor.
//
pNode = m_pSurfHeap->Alloc(1024);
if( pNode == NULL )
{
DEBUGMSG (GPE_ZONE_LINE, (TEXT("Unable Allocate cursor memory.\r\n")));
return;
}
//
// Setup the cursor stuff.
//
m_dwPhysCursorAddress = pNode->Address() + m_VideoMemPhyOffet;
m_pCursor = (unsigned char*)pNode->Address();
*RASTER_CURSOR_ADR_START = *RASTER_CURSOR_ADR_RESET = m_dwPhysCursorAddress;
*RASTER_CURSORCOLOR1 = 0;
*RASTER_CURSORCOLOR2 = 0xFFFFFF ;
*RASTER_CURSORXYLOC = 0;
*RASTER_CURSOR_BLINK1 = 0;
*RASTER_CURSOR_BLINK2 = 0;
*RASTER_CURSOR_BLINK = 0;
m_bCursorEnabled = FALSE;
//m_bCursorInitialized = FALSE;
m_bCursorHasShape = FALSE;
memset(&m_CursorRect, sizeof(m_CursorRect), 0);
memset(&m_CursorSize, sizeof(m_CursorSize), 0);
memset(&m_CursorHotspot, sizeof(m_CursorHotspot),0);
SetKMode(oldMode);
RETAILMSG(1,(TEXT("Returning from DDI init\r\n")));
}
//****************************************************************************
// GPEAccel::SetMode
//****************************************************************************
// Sets the Graphics mode and the palette.
//
SCODE GPEAccel::SetMode (INT modeId, HPALETTE *palette)
{
DEBUGMSG (GPE_ZONE_LINE,(TEXT("GPEAccel::SetMode\r\n")));
if (modeId != 0)
{
DEBUGMSG (GPE_ZONE_LINE,(TEXT("GPEAccel::SetMode Want mode %d, only have mode 0\r\n"),modeId));
return E_INVALIDARG;
}
if (palette)
{
switch (m_ulColorDepth)
{
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;
}
//****************************************************************************
// GPEAccel::GetModeInfo
//****************************************************************************
//
//
SCODE GPEAccel::GetModeInfo(GPEMode *mode, INT modeNumber)
{
DEBUGMSG (GPE_ZONE_LINE, (TEXT("GPEAccel::GetModeInfo\r\n")));
if (modeNumber != 0)
{
return E_INVALIDARG;
}
*mode = m_ModeInfo;
return S_OK;
}
//****************************************************************************
// GPEAccel::NumModes
//****************************************************************************
// Only one graphics mode currently supported.
//
//
int GPEAccel::NumModes()
{
DEBUGMSG (GPE_ZONE_LINE, (TEXT("GPEAccel::NumModes\r\n")));
return 1;
}
//****************************************************************************
// GPEAccel::SetPointerShape
//****************************************************************************
// Set the pointer shape.
//
SCODE GPEAccel::SetPointerShape
(
GPESurf *pMask,
GPESurf *pColorSurf,
INT xHot,
INT yHot,
INT cX,
INT cY
)
{
char bAnd;
char bXor;
int row;
int col;
// int bitMask;
int i;
UCHAR *andPtr; // input pointer
UCHAR *xorPtr; // input pointer
ULONG ulCursorSize = 0;
USHORT usMask;
ULONG ulXYLOC;
BOOL bSizeChanged= FALSE;
if(!pMask)
{
if(m_bCursorHasShape)
{
m_bCursorHasShape = FALSE;
*RASTER_CURSORXYLOC = 0;
}
}
//
// Check to see if the size changed.
//
if(cX != m_CursorSize.x && cY != m_CursorSize.y)
{
bSizeChanged = TRUE;
}
//
// If the Size has changed then
//
?? 快捷鍵說明
復制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -