|
|
/******************************************************************************\
** $Workfile: enable.c $** This module contains the functions that enable and disable the driver, the* pdev, and the surface.** Copyright (c) 1992-1997 Microsoft Corporation.* Copyright (c) 1996-1997 Cirrus Logic, Inc.,** $Log: S:/projects/drivers/ntsrc/display/enable.c_v $ * * Rev 1.21 Apr 03 1997 15:38:50 unknown * * * Rev 1.20 28 Mar 1997 16:08:40 PLCHU * * * Rev 1.12 Jan 15 1997 09:41:32 unknown * Change to Version 4.0.5 * * Rev 1.11 Jan 14 1997 18:00:32 unknown * disable command list due to performance drop. * * Rev 1.10 Jan 14 1997 15:14:02 unknown * Change to version V4.0.4 * * Rev 1.8 Jan 08 1997 11:22:34 unknown * Change to V4.0.3 * * Rev 1.7 18 Dec 1996 13:44:08 PLCHU * * * Rev 1.6 Dec 13 1996 12:15:48 unknown * update bandwith equation for DDraw. * * Rev 1.6 Nov 27 1996 15:07:28 unknown * turn on second apertue for 5480 * * Rev 1.5 Nov 07 1996 16:48:00 unknown * * * Rev 1.4 Nov 06 1996 15:55:10 unknown * Turn off second aperture * * Rev 1.3 Nov 05 1996 14:49:00 unknown * Turn on second aperture feature for 5480 * * Rev 1.1 Oct 10 1996 15:36:38 unknown *** Rev 1.9 12 Aug 1996 16:52:42 frido* Removed unaccessed local variables.* Added NT 3.5x/4.0 auto detection.* Renamned vMmPatternBlt into vMmFillPat36.** Rev 1.8 08 Aug 1996 16:20:54 frido* Added vMmCopyBlt36 routine.** Rev 1.7 01 Aug 1996 00:09:28 frido* Fixed a type causing havoc in new pitch in 24-bpp.** Rev 1.6 26 Jul 1996 17:46:30 frido* Added new solid fill routine for 54x6 chips.** Rev 1.5 26 Jul 1996 14:16:40 frido* Added new pattern blit routine.** Rev 1.4 20 Jul 1996 13:48:12 frido* Hooked DrvDestroyFont.** Rev 1.3 10 Jul 1996 17:54:50 frido* Cosmetic change in the flHooks variable.** Rev 1.2 09 Jul 1996 17:58:24 frido* Added LineTo code.** Rev 1.1 03 Jul 1996 13:38:30 frido* Added DirectDraw support.** sge01 10-23-96 Add second aperture maping* sge02 10-29-96 Merge port and register access* for VGA relocatable and MMIO registers.* myf0 08-19-96 added 85hz supported* myf1 08-20-96 supported panning scrolling* myf2 08-20-96 fixed hardware save/restore state bug for matterhorn* myf3 09-01-96 Added IOCTL_CIRRUS_PRIVATE_BIOS_CALL for TV supported* myf4 09-01-96 patch Viking BIOS bug, PDR #4287, begin* myf5 09-01-96 Fixed PDR #4365 keep all default refresh rate* myf6 09-17-96 Merged Desktop SRC100�1 & MINI10�2* myf7 09-19-96 Fixed exclude 60Hz refresh rate selected* myf8 *09-21-96* May be need change CheckandUpdateDDC2BMonitor --keystring[]* myf9 09-21-96 8x6 panel in 6x4x256 mode, cursor can't move to bottom scrn* ms0809 09-25-96 fixed dstn panel icon corrupted* ms923 09-25-96 merge MS-923 Disp.zip code* myf10 09-26-96 Fixed DSTN reserved half-frame buffer bug.* myf11 09-26-96 Fixed 755x CE chip HW bug, access ramdac before disable HW* icons and cursor* myf12 10-01-96 Supported Hot Key switch display* myf13 10-05-96 Fixed /w panning scrolling, vertical expension on bug* myf14 10-15-96 Fixed PDR#6917, 6x4 panel can't panning scrolling for 754x* myf15 10-16-96 Fixed disable memory mapped IO for 754x, 755x* myf16 10-22-96 Fixed PDR #6933,panel type set different demo board setting* sge01 10-28-96 Map the ports before we use it and free it in bInitializeModeFields* myf17 11-04-96 Added special escape code must be use 11/5/96 later NTCTRL,* and added Matterhorn LF Device ID==0x4C* myf18 11-04-96 Fixed PDR #7075,* myf19 11-06-96 Fixed Vinking can't work problem, because DEVICEID = 0x30* is different from data book (CR27=0x2C)* myf20 11-11-96 Fixed PDR#5501 pop-up icon crash problem* myf21 11-21-96 Change CAPS_IS_7555 to check ppdev->ulChipID* chu01 12-16-96 Enable color correction* chu02 02-07-97 Disable command list for 24 bpp modes* jl01 02-11-97 Fix 542x VLB banking issue* myf29 02-12-97 Support Gamma Correction for 755x* pat04 :12-05-96 : Set default Panel bootup mode = 640x480x256colors if* current resolution not supported.* pat08 : : Put in changes that didn't make in 1.11 driver* myf33 : 03-21-97 Fixed 6x4x256 TV on, font cut bug,*\******************************************************************************/
#include "precomp.h"
#define DBG_LVL_CAPS 0
#define CIRRUSVERSION 21
//crus
//myf17 #define PANNING_SCROLL //myf1
BOOL bGetChipIDandRev(BOOL bRetInfo, PPDEV ppdev);
//crus begin
#ifdef PANNING_SCROLL //myf1
VOIDCirrusLaptopViewPoint(PDEV* ppdev,PVIDEO_MODE_INFORMATION pVideoModeInfo);#endif
//crus end
/******************************Public*Structure****************************\
* GDIINFO ggdiDefault** This contains the default GDIINFO fields that are passed back to GDI* during DrvEnablePDEV.** NOTE: This structure defaults to values for an 8bpp palette device.* Some fields are overwritten for different colour depths.\**************************************************************************/
GDIINFO ggdiDefault = {// GDI_DRIVER_VERSION, // ulVersion
GDI_DRIVER_VERSION+CIRRUSVERSION, // ulVersion, sge01
DT_RASDISPLAY, // ulTechnology
0, // ulHorzSize (filled in later)
0, // ulVertSize (filled in later)
0, // ulHorzRes (filled in later)
0, // ulVertRes (filled in later)
0, // cBitsPixel (filled in later)
0, // cPlanes (filled in later)
20, // ulNumColors (palette managed)
0, // flRaster (DDI reserved field)
0, // ulLogPixelsX (filled in later)
0, // ulLogPixelsY (filled in later)
TC_RA_ABLE /* | TC_SCROLLBLT */, // flTextCaps --
// Setting TC_SCROLLBLT tells console to scroll
// by repainting the entire window. Otherwise,
// scrolls are done by calling the driver to
// do screen to screen copies.
0, // ulDACRed (filled in later)
0, // ulDACGreen (filled in later)
0, // ulDACBlue (filled in later)
0x0024, // ulAspectX
0x0024, // ulAspectY
0x0033, // ulAspectXY (one-to-one aspect ratio)
1, // xStyleStep
1, // yStyleSte;
3, // denStyleStep -- Styles have a one-to-one aspect
// ratio, and every 'dot' is 3 pixels long
{ 0, 0 }, // ptlPhysOffset
{ 0, 0 }, // szlPhysSize
256, // ulNumPalReg
// These fields are for halftone initialization. The actual values are
// a bit magic, but seem to work well on our display.
{ // ciDevice
{ 6700, 3300, 0 }, // Red
{ 2100, 7100, 0 }, // Green
{ 1400, 800, 0 }, // Blue
{ 1750, 3950, 0 }, // Cyan
{ 4050, 2050, 0 }, // Magenta
{ 4400, 5200, 0 }, // Yellow
{ 3127, 3290, 0 }, // AlignmentWhite
20000, // RedGamma
20000, // GreenGamma
20000, // BlueGamma
0, 0, 0, 0, 0, 0 // No dye correction for raster displays
},
0, // ulDevicePelsDPI (for printers only)
PRIMARY_ORDER_CBA, // ulPrimaryOrder
HT_PATSIZE_4x4_M, // ulHTPatternSize
HT_FORMAT_8BPP, // ulHTOutputFormat
HT_FLAG_ADDITIVE_PRIMS, // flHTFlags
0, // ulVRefresh (filled in later)
#if (NT_VERSION < 0x0400)
0, // ulDesktopHorzRes (filled in later)
0, // ulDesktopVertRes (filled in later)
0, // ulBltAlignment
#else
0, // ulBltAlignment
0, // ulPanningHorzRes (filled in later)
0, // ulPanningVertRes (filled in later)
#endif
};
/******************************Public*Structure****************************\
* DEVINFO gdevinfoDefault** This contains the default DEVINFO fields that are passed back to GDI* during DrvEnablePDEV.** NOTE: This structure defaults to values for an 8bpp palette device.* Some fields are overwritten for different colour depths.\**************************************************************************/
#define SYSTM_LOGFONT {16,7,0,0,700,0,0,0,ANSI_CHARSET,OUT_DEFAULT_PRECIS,\
CLIP_DEFAULT_PRECIS,DEFAULT_QUALITY,\ VARIABLE_PITCH | FF_DONTCARE,L"System"}#define HELVE_LOGFONT {12,9,0,0,400,0,0,0,ANSI_CHARSET,OUT_DEFAULT_PRECIS,\
CLIP_STROKE_PRECIS,PROOF_QUALITY,\ VARIABLE_PITCH | FF_DONTCARE,L"MS Sans Serif"}#define COURI_LOGFONT {12,9,0,0,400,0,0,0,ANSI_CHARSET,OUT_DEFAULT_PRECIS,\
CLIP_STROKE_PRECIS,PROOF_QUALITY,\ FIXED_PITCH | FF_DONTCARE, L"Courier"}
DEVINFO gdevinfoDefault = {
(GCAPS_OPAQUERECT | GCAPS_DITHERONREALIZE | GCAPS_PALMANAGED | GCAPS_ALTERNATEFILL | GCAPS_WINDINGFILL | GCAPS_MONO_DITHER | GCAPS_COLOR_DITHER#if DIRECTDRAW
| GCAPS_DIRECTDRAW#endif
//crus
#if (NT_VERSION >= 0x0400)
#ifdef PANNING_SCROLL //myf1
| GCAPS_PANNING#endif
#endif
// This driver can't handle GCAPS_ASYNCMOVE because some of the pointer
// moves, where the pointer image must be rotated at the left edge,
// require the blt hardware to download a new pointer shape.
), // NOTE: Only enable GCAPS_ASYNCMOVE if your code
// and hardware can handle DrvMovePointer
// calls at any time, even while another
// thread is in the middle of a drawing
// call such as DrvBitBlt.
// flGraphicsFlags
SYSTM_LOGFONT, // lfDefaultFont
HELVE_LOGFONT, // lfAnsiVarFont
COURI_LOGFONT, // lfAnsiFixFont
0, // cFonts
BMF_8BPP, // iDitherFormat
8, // cxDither
8, // cyDither
0 // hpalDefault (filled in later)
};
/******************************Public*Structure****************************\
* DFVFN gadrvfn[]** Build the driver function table gadrvfn with function index/address* pairs. This table tells GDI which DDI calls we support, and their* location (GDI does an indirect call through this table to call us).** Why haven't we implemented DrvSaveScreenBits? To save code.** When the driver doesn't hook DrvSaveScreenBits, USER simulates on-* the-fly by creating a temporary device-format-bitmap, and explicitly* calling DrvCopyBits to save/restore the bits. Since we already hook* DrvCreateDeviceBitmap, we'll end up using off-screen memory to store* the bits anyway (which would have been the main reason for implementing* DrvSaveScreenBits). So we may as well save some working set.\**************************************************************************/
#if DBG
// On Checked builds, or when we have to synchronize access, thunk
// everything through Dbg calls...
DRVFN gadrvfn[] = { { INDEX_DrvEnablePDEV, (PFN) DbgEnablePDEV }, { INDEX_DrvCompletePDEV, (PFN) DbgCompletePDEV }, { INDEX_DrvDisablePDEV, (PFN) DbgDisablePDEV }, { INDEX_DrvEnableSurface, (PFN) DbgEnableSurface }, { INDEX_DrvDisableSurface, (PFN) DbgDisableSurface }, { INDEX_DrvAssertMode, (PFN) DbgAssertMode }, { INDEX_DrvCopyBits, (PFN) DbgCopyBits }, { INDEX_DrvBitBlt, (PFN) DbgBitBlt }, { INDEX_DrvTextOut, (PFN) DbgTextOut }, { INDEX_DrvSynchronize, (PFN) DrvSynchronize },#if 1 // Font cache.
{ INDEX_DrvDestroyFont, (PFN) DbgDestroyFont },#endif
{ INDEX_DrvGetModes, (PFN) DbgGetModes }, { INDEX_DrvStrokePath, (PFN) DbgStrokePath }, { INDEX_DrvSetPalette, (PFN) DbgSetPalette }, { INDEX_DrvDitherColor, (PFN) DbgDitherColor }, { INDEX_DrvFillPath, (PFN) DbgFillPath },#if DIRECTDRAW
{ INDEX_DrvGetDirectDrawInfo, (PFN) DbgGetDirectDrawInfo }, { INDEX_DrvEnableDirectDraw, (PFN) DbgEnableDirectDraw }, { INDEX_DrvDisableDirectDraw, (PFN) DbgDisableDirectDraw },#endif
#if LINETO
{ INDEX_DrvLineTo, (PFN) DbgLineTo },#endif
#if !DRIVER_PUNT_ALL
#if !DRIVER_PUNT_STRETCH
{ INDEX_DrvStretchBlt, (PFN) DbgStretchBlt }, #endif
#if !DRIVER_PUNT_PTR
{ INDEX_DrvMovePointer, (PFN) DbgMovePointer }, { INDEX_DrvSetPointerShape, (PFN) DbgSetPointerShape }, #endif
{ INDEX_DrvCreateDeviceBitmap, (PFN) DbgCreateDeviceBitmap }, { INDEX_DrvDeleteDeviceBitmap, (PFN) DbgDeleteDeviceBitmap }, #if !DRIVER_PUNT_BRUSH
{ INDEX_DrvRealizeBrush, (PFN) DbgRealizeBrush }, #endif
#endif
};
#else
// On Free builds, directly call the appropriate functions...
DRVFN gadrvfn[] = { { INDEX_DrvEnablePDEV, (PFN) DrvEnablePDEV }, { INDEX_DrvCompletePDEV, (PFN) DrvCompletePDEV }, { INDEX_DrvDisablePDEV, (PFN) DrvDisablePDEV }, { INDEX_DrvEnableSurface, (PFN) DrvEnableSurface }, { INDEX_DrvDisableSurface, (PFN) DrvDisableSurface }, { INDEX_DrvAssertMode, (PFN) DrvAssertMode }, { INDEX_DrvCopyBits, (PFN) DrvCopyBits }, { INDEX_DrvBitBlt, (PFN) DrvBitBlt }, { INDEX_DrvTextOut, (PFN) DrvTextOut }, { INDEX_DrvSynchronize, (PFN) DrvSynchronize },#if 1 // Font cache.
{ INDEX_DrvDestroyFont, (PFN) DrvDestroyFont },#endif
{ INDEX_DrvGetModes, (PFN) DrvGetModes }, { INDEX_DrvStrokePath, (PFN) DrvStrokePath }, { INDEX_DrvSetPalette, (PFN) DrvSetPalette }, { INDEX_DrvDitherColor, (PFN) DrvDitherColor }, { INDEX_DrvFillPath, (PFN) DrvFillPath },#if DIRECTDRAW
{ INDEX_DrvGetDirectDrawInfo, (PFN) DrvGetDirectDrawInfo }, { INDEX_DrvEnableDirectDraw, (PFN) DrvEnableDirectDraw }, { INDEX_DrvDisableDirectDraw, (PFN) DrvDisableDirectDraw },#endif
#if LINETO
{ INDEX_DrvLineTo, (PFN) DrvLineTo },#endif
#if !DRIVER_PUNT_ALL
#if !DRIVER_PUNT_STRETCH
{ INDEX_DrvStretchBlt, (PFN) DrvStretchBlt }, #endif
#if !DRIVER_PUNT_PTR
{ INDEX_DrvMovePointer, (PFN) DrvMovePointer }, { INDEX_DrvSetPointerShape, (PFN) DrvSetPointerShape }, #endif
{ INDEX_DrvCreateDeviceBitmap, (PFN) DrvCreateDeviceBitmap }, { INDEX_DrvDeleteDeviceBitmap, (PFN) DrvDeleteDeviceBitmap }, #if !DRIVER_PUNT_BRUSH
{ INDEX_DrvRealizeBrush, (PFN) DrvRealizeBrush }, #endif
#endif
};
#endif
ULONG gcdrvfn = sizeof(gadrvfn) / sizeof(DRVFN);
//
// Merge port and register access for
// VGA relocatable and MMIO registers.
//
// sge02 begin
#if defined(_X86_)
UCHAR CirrusREAD_PORT_UCHAR(PVOID Port);USHORT CirrusREAD_PORT_USHORT(PVOID Port);ULONG CirrusREAD_PORT_ULONG(PVOID Port);VOID CirrusWRITE_PORT_UCHAR(PVOID Port,UCHAR Value);VOID CirrusWRITE_PORT_USHORT(PVOID Port, USHORT Value);VOID CirrusWRITE_PORT_ULONG(PVOID Port, ULONG Value);
UCHAR CirrusREAD_REGISTER_UCHAR(PVOID Register);USHORT CirrusREAD_REGISTER_USHORT(PVOID Register);ULONG CirrusREAD_REGISTER_ULONG(PVOID Register);VOID CirrusWRITE_REGISTER_UCHAR(PVOID Register,UCHAR Value);VOID CirrusWRITE_REGISTER_USHORT(PVOID Register, USHORT Value);VOID CirrusWRITE_REGISTER_ULONG(PVOID Register, ULONG Value);
UCHAR CirrusREAD_PORT_UCHAR(PVOID Port){ return((UCHAR)inp(Port));}USHORT CirrusREAD_PORT_USHORT(PVOID Port){ return(inpw(Port));}ULONG CirrusREAD_PORT_ULONG(PVOID Port){ return(inpd(Port));}VOID CirrusWRITE_PORT_UCHAR(PVOID Port,UCHAR Value){ outp(Port, Value);}VOID CirrusWRITE_PORT_USHORT(PVOID Port, USHORT Value){ outpw(Port, Value);}VOID CirrusWRITE_PORT_ULONG(PVOID Port, ULONG Value){ outpd(Port, Value);}
UCHAR CirrusREAD_REGISTER_UCHAR(PVOID Register){ return(*(volatile UCHAR *)(Register));}USHORT CirrusREAD_REGISTER_USHORT(PVOID Register){ return(*(volatile USHORT *)(Register));}ULONG CirrusREAD_REGISTER_ULONG(PVOID Register){ return(*(volatile ULONG *)(Register));}VOID CirrusWRITE_REGISTER_UCHAR(PVOID Register,UCHAR Value){ *(volatile UCHAR *)(Register) = (Value);}VOID CirrusWRITE_REGISTER_USHORT(PVOID Register, USHORT Value){ *(volatile USHORT *)(Register) = (Value);}VOID CirrusWRITE_REGISTER_ULONG(PVOID Register, ULONG Value){ *(volatile ULONG *)(Register) = (Value);}#endif
//sge02 end
/******************************Public*Routine******************************\
* BOOL DrvEnableDriver** Enables the driver by retrieving the drivers function table and version.*\**************************************************************************/
BOOL DrvEnableDriver(ULONG iEngineVersion,ULONG cj,DRVENABLEDATA* pded){ DISPDBG((2, "---- DrvEnableDriver"));
// Engine Version is passed down so future drivers can support previous
// engine versions. A next generation driver can support both the old
// and new engine conventions if told what version of engine it is
// working with. For the first version the driver does nothing with it.
// Fill in as much as we can.
if (cj >= sizeof(DRVENABLEDATA)) pded->pdrvfn = gadrvfn;
if (cj >= (sizeof(ULONG) * 2)) pded->c = gcdrvfn;
// DDI version this driver was targeted for is passed back to engine.
// Future graphic's engine may break calls down to old driver format.
if (cj >= sizeof(ULONG)) pded->iDriverVersion = DDI_DRIVER_VERSION_NT4;
return(TRUE);}
/******************************Public*Routine******************************\
* VOID DrvDisableDriver** Tells the driver it is being disabled. Release any resources allocated in* DrvEnableDriver.*\**************************************************************************/
VOID DrvDisableDriver(VOID){ return;}
/******************************Public*Routine******************************\
* DHPDEV DrvEnablePDEV** Initializes a bunch of fields for GDI, based on the mode we've been asked* to do. This is the first thing called after DrvEnableDriver, when GDI* wants to get some information about us.** (This function mostly returns back information; DrvEnableSurface is used* for initializing the hardware and driver components.)*\**************************************************************************/
DHPDEV DrvEnablePDEV(DEVMODEW* pdm, // Contains data pertaining to requested mode
PWSTR pwszLogAddr, // Logical address
ULONG cPat, // Count of standard patterns
HSURF* phsurfPatterns, // Buffer for standard patterns
ULONG cjCaps, // Size of buffer for device caps 'pdevcaps'
ULONG* pdevcaps, // Buffer for device caps, also known as 'gdiinfo'
ULONG cjDevInfo, // Number of bytes in device info 'pdi'
DEVINFO* pdi, // Device information
#if (NT_VERSION < 0x0400)
PWSTR pwszDataFile, // DataFile - not used
#else
HDEV hdev, // HDEV, used for callbacks
#endif
PWSTR pwszDeviceName, // Device name
HANDLE hDriver) // Kernel driver handle
{ PDEV* ppdev;
// Future versions of NT had better supply 'devcaps' and 'devinfo'
// structures that are the same size or larger than the current
// structures:
DISPDBG((2, "---- DrvEnablePDEV"));
if ((cjCaps < sizeof(GDIINFO)) || (cjDevInfo < sizeof(DEVINFO))) { DISPDBG((0, "DrvEnablePDEV - Buffer size too small")); goto ReturnFailure0; }
// Allocate a physical device structure. Note that we definitely
// rely on the zero initialization:
ppdev = (PDEV*) ALLOC(sizeof(PDEV)); if (ppdev == NULL) { DISPDBG((0, "DrvEnablePDEV - Failed EngAllocMem")); goto ReturnFailure0; }
ppdev->hDriver = hDriver;
// Get the current screen mode information. Set up device caps and devinfo.
if (!bInitializeModeFields(ppdev, (GDIINFO*) pdevcaps, pdi, pdm)) { goto ReturnFailure1; }
// Initialize palette information.
if (!bInitializePalette(ppdev, pdi)) { DISPDBG((0, "DrvEnablePDEV - Failed bInitializePalette")); goto ReturnFailure1; }
return((DHPDEV) ppdev);
ReturnFailure1: DrvDisablePDEV((DHPDEV) ppdev);
ReturnFailure0: DISPDBG((0, "Failed DrvEnablePDEV")); return(0);}
/******************************Public*Routine******************************\
* DrvDisablePDEV** Release the resources allocated in DrvEnablePDEV. If a surface has been* enabled DrvDisableSurface will have already been called.** Note that this function will be called when previewing modes in the* Display Applet, but not at system shutdown. If you need to reset the* hardware at shutdown, you can do it in the miniport by providing a* 'HwResetHw' entry point in the VIDEO_HW_INITIALIZATION_DATA structure.** Note: In an error, we may call this before DrvEnablePDEV is done.*\**************************************************************************/
VOID DrvDisablePDEV(DHPDEV dhpdev){ PDEV* ppdev;
ppdev = (PDEV*) dhpdev;
vUninitializePalette(ppdev); FREE(ppdev);}
/******************************Public*Routine******************************\
* VOID DrvCompletePDEV** Store the HPDEV, the engines handle for this PDEV, in the DHPDEV.*\**************************************************************************/
VOID DrvCompletePDEV(DHPDEV dhpdev,HDEV hdev){ ((PDEV*) dhpdev)->hdevEng = hdev;}
/******************************Public*Routine******************************\
* HSURF DrvEnableSurface** Creates the drawing surface, initializes the hardware, and initializes* driver components. This function is called after DrvEnablePDEV, and* performs the final device initialization.*\**************************************************************************/
HSURF DrvEnableSurface(DHPDEV dhpdev){ PDEV* ppdev; HSURF hsurf; SIZEL sizl; DSURF* pdsurf; VOID* pvTmpBuffer; SURFOBJ* pso; ppdev = (PDEV*) dhpdev;
DISPDBG((2, "---- DrvEnableSurface"));
/////////////////////////////////////////////////////////////////////
// First, enable all the subcomponents.
//
// Note that the order in which these 'Enable' functions are called
// may be significant in low off-screen memory conditions, because
// the off-screen heap manager may fail some of the later
// allocations...
if (!bEnableHardware(ppdev)) goto ReturnFailure;
if (!bEnableBanking(ppdev)) goto ReturnFailure;
if (!bEnableOffscreenHeap(ppdev)) goto ReturnFailure;
if (!bEnablePointer(ppdev)) goto ReturnFailure;
if (!bEnableText(ppdev)) goto ReturnFailure;
if (!bEnableBrushCache(ppdev)) goto ReturnFailure;
if (!bEnablePalette(ppdev)) goto ReturnFailure;
#if DIRECTDRAW
if (!bEnableDirectDraw(ppdev)) goto ReturnFailure;#endif
/////////////////////////////////////////////////////////////////////
// Now create our private surface structure.
//
// Whenever we get a call to draw directly to the screen, we'll get
// passed a pointer to a SURFOBJ whose 'dhpdev' field will point
// to our PDEV structure, and whose 'dhsurf' field will point to the
// following DSURF structure.
//
// Every device bitmap we create in DrvCreateDeviceBitmap will also
// have its own unique DSURF structure allocated (but will share the
// same PDEV). To make our code more polymorphic for handling drawing
// to either the screen or an off-screen bitmap, we have the same
// structure for both.
pdsurf = ALLOC(sizeof(DSURF)); if (pdsurf == NULL) { DISPDBG((0, "DrvEnableSurface - Failed pdsurf EngAllocMem")); goto ReturnFailure; }
ppdev->pdsurfScreen = pdsurf; // Remember it for clean-up
pdsurf->poh = ppdev->pohScreen; // The screen is a surface, too
pdsurf->dt = DT_SCREEN; // Not to be confused with a DIB
pdsurf->sizl.cx = ppdev->cxScreen; pdsurf->sizl.cy = ppdev->cyScreen; pdsurf->ppdev = ppdev;
/////////////////////////////////////////////////////////////////////
// Next, have GDI create the actual SURFOBJ.
//
// Our drawing surface is going to be 'device-managed', meaning that
// GDI cannot draw on the framebuffer bits directly, and as such we
// create the surface via EngCreateDeviceSurface. By doing this, we ensure
// that GDI will only ever access the bitmaps bits via the Drv calls
// that we've HOOKed.
//
// If we could map the entire framebuffer linearly into main memory
// (i.e., we didn't have to go through a 64k aperture), it would be
// beneficial to create the surface via EngCreateBitmap, giving GDI a
// pointer to the framebuffer bits. When we pass a call on to GDI
// where it can't directly read/write to the surface bits because the
// surface is device managed, it has to create a temporary bitmap and
// call our DrvCopyBits routine to get/set a copy of the affected bits.
// For example, the OpenGL component prefers to be able to write on the
// framebuffer bits directly.
//
// The check for CAPS_AUTOSTART rules out chipsets (like the 7543) that
// can't be written to directly.
sizl.cx = ppdev->cxScreen; sizl.cy = ppdev->cyScreen;
if ((ppdev->bLinearMode && DIRECT_ACCESS(ppdev)) && (ppdev->flCaps & CAPS_ENGINEMANAGED)) {
// Engine-managed surface:
hsurf = (HSURF) EngCreateBitmap(sizl, ppdev->lDelta, ppdev->iBitmapFormat, BMF_TOPDOWN, ppdev->pjScreen); if (hsurf == 0) { DISPDBG((0, "DrvEnableSurface - Failed EngCreateBitmap")); goto ReturnFailure; }
pso = EngLockSurface(hsurf); if (pso == NULL) { DISPDBG((0, "DrvEnableSurface - Couldn't lock our surface")); goto ReturnFailure; } pso->dhsurf = (DHSURF) pdsurf; EngUnlockSurface(pso); } else { // Device managed surface
hsurf = EngCreateDeviceSurface((DHSURF) pdsurf, sizl, ppdev->iBitmapFormat); if (hsurf == 0) { DISPDBG((0, "DrvEnableSurface - Failed EngCreateDeviceSurface")); goto ReturnFailure; } }
/////////////////////////////////////////////////////////////////////
// Now associate the surface and the PDEV.
//
// We have to associate the surface we just created with our physical
// device so that GDI can get information related to the PDEV when
// it's drawing to the surface (such as, for example, the length of
// styles on the device when simulating styled lines).
//
if (!EngAssociateSurface(hsurf, ppdev->hdevEng, ppdev->flHooks)) { DISPDBG((0, "DrvEnableSurface - Failed EngAssociateSurface 2")); goto ReturnFailure; }
ppdev->hsurfScreen = hsurf; // Remember it for clean-up
ppdev->bEnabled = TRUE; // We'll soon be in graphics mode
// Create our generic temporary buffer, which may be used by any
// component.
pvTmpBuffer = ALLOC(TMP_BUFFER_SIZE); if (pvTmpBuffer == NULL) { DISPDBG((0, "DrvEnableSurface - Failed EngAllocMem")); goto ReturnFailure; }
ppdev->pvTmpBuffer = pvTmpBuffer;
DISPDBG((5, "Passed DrvEnableSurface"));
ppdev->hbmTmpMono = EngCreateBitmap(sizl, sizl.cx, BMF_1BPP, 0, ppdev->pvTmpBuffer); if (ppdev->hbmTmpMono == (HBITMAP) 0) { DISPDBG((0, "Couldn't create temporary 1bpp bitmap")); goto ReturnFailure; }
ppdev->psoTmpMono = EngLockSurface((HSURF) ppdev->hbmTmpMono); if (ppdev->psoTmpMono == (SURFOBJ*) NULL) { DISPDBG((0,"Couldn't lock temporary 1bpp surface")); goto ReturnFailure; }
return(hsurf);
ReturnFailure: DrvDisableSurface((DHPDEV) ppdev);
DISPDBG((0, "Failed DrvEnableSurface"));
return(0);}
VOIDDrvSynchronize( IN DHPDEV dhpdev, IN RECTL *prcl ){ PDEV *ppdev = (PDEV *) dhpdev;
//
// We need to do a wait for blt complete before we
// let the engine party on our frame buffer
//
if (ppdev->flCaps & CAPS_MM_IO) { CP_MM_WAIT_FOR_BLT_COMPLETE(ppdev, ppdev->pjBase); } else { CP_IO_WAIT_FOR_BLT_COMPLETE(ppdev, ppdev->pjPorts); }}
/******************************Public*Routine******************************\
* VOID DrvDisableSurface** Free resources allocated by DrvEnableSurface. Release the surface.** Note that this function will be called when previewing modes in th* Display Applet, but not at system shutdown. If you need to reset the* hardware at shutdown, you can do it in the miniport by providing a* 'HwResetHw' entry point in the VIDEO_HW_INITIALIZATION_DATA structure.** Note: In an error case, we may call this before DrvEnableSurface is* completely done.*\**************************************************************************/
VOID DrvDisableSurface(DHPDEV dhpdev){ PDEV* ppdev;
ppdev = (PDEV*) dhpdev;
// Note: In an error case, some of the following relies on the
// fact that the PDEV is zero-initialized, so fields like
// 'hsurfScreen' will be zero unless the surface has been
// sucessfully initialized, and makes the assumption that
// EngDeleteSurface can take '0' as a parameter.
#if DIRECTDRAW
vDisableDirectDraw(ppdev);#endif
vDisablePalette(ppdev); vDisableBrushCache(ppdev); vDisableText(ppdev);
vDisablePointer(ppdev); vDisableOffscreenHeap(ppdev);
vDisableBanking(ppdev); vDisableHardware(ppdev);
EngUnlockSurface(ppdev->psoTmpMono); EngDeleteSurface((HSURF) ppdev->hbmTmpMono); FREE(ppdev->pvTmpBuffer); EngDeleteSurface(ppdev->hsurfScreen); FREE(ppdev->pdsurfScreen);}
/******************************Public*Routine******************************\
* VOID DrvAssertMode** This asks the device to reset itself to the mode of the pdev passed in.*\**************************************************************************/
#if (NT_VERSION < 0x0400)
VOID#else
BOOL#endif
DrvAssertMode(DHPDEV dhpdev, BOOL bEnable){ PDEV* ppdev = (PDEV*) dhpdev;
if (!bEnable) { //////////////////////////////////////////////////////////////
// Disable - Switch to full-screen mode
#if DIRECTDRAW
vAssertModeDirectDraw(ppdev, FALSE);#endif
vAssertModePalette(ppdev, FALSE);
vAssertModeBrushCache(ppdev, FALSE);
vAssertModeText(ppdev, FALSE);
vAssertModePointer(ppdev, FALSE);
if (bAssertModeOffscreenHeap(ppdev, FALSE)) { vAssertModeBanking(ppdev, FALSE);
if (bAssertModeHardware(ppdev, FALSE)) { ppdev->bEnabled = FALSE;
#if (NT_VERSION >= 0x0400)
return (TRUE);#else
return;#endif
}
//////////////////////////////////////////////////////////
// We failed to switch to full-screen. So undo everything:
vAssertModeBanking(ppdev, TRUE);
bAssertModeOffscreenHeap(ppdev, TRUE); // We don't need to check
} // return code with TRUE
vAssertModePointer(ppdev, TRUE);
vAssertModeText(ppdev, TRUE);
vAssertModeBrushCache(ppdev, TRUE);
vAssertModePalette(ppdev, TRUE);
} else { //////////////////////////////////////////////////////////////
// Enable - Switch back to graphics mode
// We have to enable every subcomponent in the reverse order
// in which it was disabled:
if (bAssertModeHardware(ppdev, TRUE)) {
vAssertModeBanking(ppdev, TRUE);
bAssertModeOffscreenHeap(ppdev, TRUE); // We don't need to check
// return code with TRUE
vAssertModePointer(ppdev, TRUE);
vAssertModeText(ppdev, TRUE);
vAssertModeBrushCache(ppdev, TRUE);
vAssertModePalette(ppdev, TRUE);
#if DIRECTDRAW
vAssertModeDirectDraw(ppdev, TRUE);#endif
//
// chu01 begin
//
#ifdef GAMMACORRECT
{ BYTE ajClutSpace[MAX_CLUT_SIZE]; PVIDEO_CLUT pScreenClut; PALETTEENTRY* ppalFrom; PALETTEENTRY* ppalTo; PALETTEENTRY* ppalEnd; BOOL status; ULONG ulReturn;
if (ppdev->flCaps & CAPS_GAMMA_CORRECT) { pScreenClut = (PVIDEO_CLUT) ajClutSpace; pScreenClut->NumEntries = 256; pScreenClut->FirstEntry = 0;
ppalFrom = ppdev->pPal; ppalTo = (PALETTEENTRY*) pScreenClut->LookupTable; ppalEnd = &ppalTo[256];
for (; ppalTo < ppalEnd; ppalFrom++, ppalTo++) { ppalTo->peRed = ppalFrom->peRed ; ppalTo->peGreen = ppalFrom->peGreen ; ppalTo->peBlue = ppalFrom->peBlue ; ppalTo->peFlags = 0 ; }
//myf29 begin
if (ppdev->ulChipID == 0xBC) status = bEnableGammaCorrect(ppdev) ; else if ((ppdev->ulChipID == 0x40) || (ppdev->ulChipID ==0x4C)) status = bEnableGamma755x(ppdev) ;//myf29 end
CalculateGamma( ppdev, pScreenClut, 256 ) ;
// Set palette registers:
if (!IOCONTROL(ppdev->hDriver, IOCTL_VIDEO_SET_COLOR_REGISTERS, pScreenClut, MAX_CLUT_SIZE, NULL, 0, &ulReturn)) { DISPDBG((0, "Failed bEnablePalette")); }
}}#endif // GAMMACORRECT
//chu01
ppdev->bEnabled = TRUE;
#if (NT_VERSION >= 0x0400)
return(TRUE);#endif
} }
#if (NT_VERSION >= 0x0400)
return(FALSE);#endif
}
/******************************Public*Routine******************************\
* ULONG DrvGetModes** Returns the list of available modes for the device.*\**************************************************************************/
ULONG DrvGetModes(HANDLE hDriver,ULONG cjSize,DEVMODEW* pdm){
DWORD cModes; DWORD cbOutputSize; PVIDEO_MODE_INFORMATION pVideoModeInformation; PVIDEO_MODE_INFORMATION pVideoTemp; DWORD cOutputModes = cjSize / (sizeof(DEVMODEW) + DRIVER_EXTRA_SIZE); DWORD cbModeSize;
cModes = getAvailableModes(hDriver, (PVIDEO_MODE_INFORMATION *) &pVideoModeInformation, &cbModeSize); if (cModes == 0) { DISPDBG((0, "DrvGetModes failed to get mode information")); return(0); }
if (pdm == NULL) { cbOutputSize = cModes * (sizeof(DEVMODEW) + DRIVER_EXTRA_SIZE); } else { //
// Now copy the information for the supported modes back into the
// output buffer
//
cbOutputSize = 0;
pVideoTemp = pVideoModeInformation;
do { if (pVideoTemp->Length != 0) { if (cOutputModes == 0) { break; }
//
// Zero the entire structure to start off with.
//
memset(pdm, 0, sizeof(DEVMODEW));
//
// Set the name of the device to the name of the DLL.
//
memcpy(pdm->dmDeviceName, DLL_NAME, sizeof(DLL_NAME));
pdm->dmSpecVersion = DM_SPECVERSION; pdm->dmDriverVersion = DM_SPECVERSION; pdm->dmSize = sizeof(DEVMODEW); pdm->dmDriverExtra = DRIVER_EXTRA_SIZE;
pdm->dmBitsPerPel = pVideoTemp->NumberOfPlanes * pVideoTemp->BitsPerPlane; pdm->dmPelsWidth = pVideoTemp->VisScreenWidth; pdm->dmPelsHeight = pVideoTemp->VisScreenHeight; pdm->dmDisplayFrequency = pVideoTemp->Frequency; pdm->dmDisplayFlags = 0;
pdm->dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT | DM_DISPLAYFREQUENCY | DM_DISPLAYFLAGS ;
#if (NT_VERSION < 0x0400)
if (pVideoTemp->AttributeFlags & VIDEO_MODE_INTERLACED) { pdm->dmDisplayFlags |= DM_INTERLACED; }#endif
//
// Go to the next DEVMODE entry in the buffer.
//
cOutputModes--;
pdm = (LPDEVMODEW) ( ((ULONG_PTR)pdm) + sizeof(DEVMODEW) + DRIVER_EXTRA_SIZE);
cbOutputSize += (sizeof(DEVMODEW) + DRIVER_EXTRA_SIZE);
}
pVideoTemp = (PVIDEO_MODE_INFORMATION) (((PUCHAR)pVideoTemp) + cbModeSize);
} while (--cModes); }
FREE(pVideoModeInformation);
return(cbOutputSize);}
/******************************Public*Routine******************************\
* BOOL bAssertModeHardware** Sets the appropriate hardware state for graphics mode or full-screen.*\**************************************************************************/
BOOL bAssertModeHardware(PDEV* ppdev,BOOL bEnable){ DWORD ReturnedDataLength; ULONG ulReturn; VIDEO_MODE_INFORMATION VideoModeInfo; LONG cjEndOfFrameBuffer; LONG cjPointerOffset; LONG lDelta; ULONG ulMode; ULONG pFirstCL, pSecondCL;
if (bEnable) { // Call the miniport via an IOCTL to set the graphics mode.
ulMode = ppdev->ulMode;
if (ppdev->bLinearMode) { ulMode |= VIDEO_MODE_MAP_MEM_LINEAR; }
if (!IOCONTROL(ppdev->hDriver, IOCTL_VIDEO_SET_CURRENT_MODE, &ulMode, // input buffer
sizeof(DWORD), NULL, 0, &ReturnedDataLength)) { DISPDBG((0, "bAssertModeHardware - Failed VIDEO_SET_CURRENT_MODE")); goto ReturnFalse; }
//
// This driver requires that extended write modes be enabled.
// Normally, we would put code like this into the miniport, but
// unfortunately the VGA drivers do not expect extended write
// modes to be enabled, and thus we have to put the code here.
//
#define ENABLE_EXTENDED_WRITE_MODES 0x4
{ BYTE j;
CP_OUT_BYTE(ppdev->pjPorts, INDEX_REG, 0x0B); j = CP_IN_BYTE(ppdev->pjPorts, DATA_REG); DISPDBG((3, "Mode extensions register was (%x)", j)); j &= 0x20; j |= ENABLE_EXTENDED_WRITE_MODES; CP_OUT_BYTE(ppdev->pjPorts, DATA_REG, j); DISPDBG((3, "Mode extensions register now (%x)", j)); }
CP_IO_XPAR_COLOR_MASK(ppdev, ppdev->pjPorts, 0);
if (!IOCONTROL(ppdev->hDriver, IOCTL_VIDEO_QUERY_CURRENT_MODE, NULL, 0, &VideoModeInfo, sizeof(VideoModeInfo), &ReturnedDataLength)) { DISPDBG((0, "bAssertModeHardware - failed VIDEO_QUERY_CURRENT_MODE")); goto ReturnFalse; }
//crus
//myf1, begin
#ifdef PANNING_SCROLL
if ((ppdev->ulChipID == 0x38) || (ppdev->ulChipID == 0x2C) || (ppdev->ulChipID == 0x30) || (ppdev->ulChipID == 0x34) || //myf19
(ppdev->ulChipID == 0x40) || (ppdev->ulChipID == 0x4C)) //myf17
{ CirrusLaptopViewPoint(ppdev, &VideoModeInfo); }#endif
//myf1, end
#if DEBUG_HEAP
VideoModeInfo.VideoMemoryBitmapWidth = VideoModeInfo.VisScreenWidth; VideoModeInfo.VideoMemoryBitmapHeight = VideoModeInfo.VisScreenHeight; #endif
// The following variables are determined only after the initial
// modeset:
ppdev->lDelta = VideoModeInfo.ScreenStride; ppdev->flCaps = VideoModeInfo.DriverSpecificAttributeFlags;
DISPDBG((1,"ppdev->flCaps = %x",ppdev->flCaps)); //2
#if 1 // Check for 5446 chip.
CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, 0x27); ppdev->ulChipID = CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA) & 0xFC; //
// add chip flags for 5446BE and 5480
//
//sge01 begin
if ((ppdev->ulChipID == 0xB8) || (ppdev->ulChipID == 0xBC)) { ppdev->flCaps |= CAPS_VIDEO; if (ppdev->ulChipID == 0xBC) { ppdev->flCaps |= CAPS_SECOND_APERTURE; } else { // get revision ID
CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, 0x25); ppdev->ulChipNum = CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA); if (ppdev->ulChipNum==0x45) ppdev->flCaps |= CAPS_SECOND_APERTURE; } }//myf30 begin
else if ((ppdev->ulChipID == 0x40) || (ppdev->ulChipID == 0x4C)) {#if (_WIN32_WINNT >= 0x0400)
ppdev->flCaps |= CAPS_VIDEO;#endif
}//myf30 end
#endif
//sge01 end
// Set up the shift factor for the banking code.
if (ppdev->flCaps & CAPS_IS_542x) { ppdev->ulBankShiftFactor = 12; } else { ppdev->ulBankShiftFactor = 10; }
ppdev->cxMemory = VideoModeInfo.VideoMemoryBitmapWidth; ppdev->cyMemory = VideoModeInfo.VideoMemoryBitmapHeight;
//pat04, begin
//#if 0
#if (_WIN32_WINNT < 0x0400)
ppdev->cxScreen = VideoModeInfo.VisScreenWidth; ppdev->cyScreen = VideoModeInfo.VisScreenHeight;#endif
//#endif
//pat04, end
//crus begin
//ms0809, begin
/********************************************************************
* * If we are on a DSTN panel, then the hardware needs 128K for the * half frame accelerator. * ********************************************************************/
if ((ppdev->flCaps & CAPS_DSTN_PANEL) && ((ppdev->ulChipID == 0x38) || (ppdev->ulChipID == 0x2C) || (ppdev->ulChipID == 0x30) || (ppdev->ulChipID == 0x34) || //myf19
(ppdev->ulChipID == 0x40) || (ppdev->ulChipID == 0x4C)) ) //myf17
{ // figure out how much cyMemory needs to be decremented by
// to reserve 128K.
// =====================================================
// if Matterhorn 2M/4M board needs to be decremented by
// to reserve 152K+16k(h/w icon)=168K.
// =====================================================
// I need to make sure that if there is a remainder that I
// remove an additional scan. What is the best way to do
// this? Is this the memory the DSTN is using? Will it ever
// use more?
if ((ppdev->ulChipID == 0x38) || (ppdev->ulChipID == 0x2C) || (ppdev->ulChipID == 0x30) || (ppdev->ulChipID == 0x34)) //myf19
ppdev->cyMemory -= (0x24000 / ppdev->cxMemory); //myf
else if ((ppdev->ulChipID == 0x40) || (ppdev->ulChipID == 0x4C))//myf17
ppdev->cyMemory -= (0x2A000 / ppdev->cxMemory); //myf
}// else if (!(ppdev->flCaps & CAPS_DSTN_PANEL) &&
else if (((ppdev->ulChipID == 0x38) || (ppdev->ulChipID == 0x2C) || //myf20
(ppdev->ulChipID == 0x30) || (ppdev->ulChipID == 0x34) || //myf19
(ppdev->ulChipID == 0x40) || (ppdev->ulChipID == 0x4C))) //myf17
{ // figure out how much cyMemory needs to be decremented by
// to reserve 16K for H/W icon & cursor
// =====================================================
ppdev->cyMemory -= (0x4000 / ppdev->cxMemory); //myf
}//ms0809, end
//crus end
//sge01 begin
if (!(ppdev->flCaps & CAPS_BLT_SUPPORT)) { DISPDBG((1, "Cirrus chip doesn't support BLT's")); goto ReturnFalse; }//sge01 end
//
// Check to see if we have a non-zero value for pjBase. If so, we
// can support memory mapped IO.
//
if (ppdev->pjBase) { CP_ENABLE_MM_IO(ppdev, ppdev->pjPorts); CP_MM_START_REG(ppdev, ppdev->pjBase, BLT_RESET);
if (ppdev->flCaps & CAPS_AUTOSTART) { //
// enable second aperture for 5480 and 5446BE
//
// sge01 begin
if (ppdev->flCaps & CAPS_SECOND_APERTURE) { CP_MM_START_REG(ppdev, ppdev->pjBase, BLT_AUTO_START | BLT_SECOND_APERTURE); } else //sge01 end
{ CP_MM_START_REG(ppdev, ppdev->pjBase, BLT_AUTO_START); }
} } else { CP_DISABLE_MM_IO(ppdev, ppdev->pjPorts); CP_IO_START_REG(ppdev, ppdev->pjPorts, BLT_RESET);
if (ppdev->flCaps & CAPS_AUTOSTART) { //
// enable second aperture for 5480 and 5446BE
//
// sge01 begin
if (ppdev->flCaps & CAPS_SECOND_APERTURE) { CP_IO_START_REG(ppdev, ppdev->pjBase, BLT_AUTO_START | BLT_SECOND_APERTURE); } else //sge 01 end
{ CP_IO_START_REG(ppdev, ppdev->pjBase, BLT_AUTO_START); }
} }
/********************************************************************
* * If we're using the hardware pointer, reserve the last scan of * the frame buffer to store the pointer shape. The pointer MUST be * stored in the last 256 bytes of video memory. * ********************************************************************/
// #pat08 start
//#if 0
#if (_WIN32_WINNT < 0x0400)
#ifdef PANNING_SCROLL
// allocate without test
// if ((ppdev->ulChipID != CL7541_ID) && (ppdev->ulChipID != CL7543_ID) &&
// (ppdev->ulChipID != CL7542_ID) && (ppdev->ulChipID != CL7548_ID) &&
// (ppdev->ulChipID != CL7555_ID) && (ppdev->ulChipID != CL7556_ID))
// if (!(ppdev->flCaps & (CAPS_SW_POINTER)))
// else
// ;
#else
if (!(ppdev->flCaps & (CAPS_SW_POINTER))) #endif
#else // NT 4.0 code
if (!(ppdev->flCaps & (CAPS_SW_POINTER)))#endif
//#endif //0,pat08
// #pat08 end
//pat08 if (!(ppdev->flCaps & (CAPS_SW_POINTER)))
{ // We'll reserve the end of off-screen memory for the hardware
// pointer shape.
cjPointerOffset = (ppdev->ulMemSize - SPRITE_BUFFER_SIZE);
// Figure out the coordinate where the pointer shape starts:
lDelta = ppdev->lDelta;
ppdev->cjPointerOffset = cjPointerOffset; ppdev->yPointerShape = (cjPointerOffset / lDelta); ppdev->xPointerShape = (cjPointerOffset % lDelta) / ppdev->cBpp;
if (ppdev->yPointerShape >= ppdev->cyScreen) { // There's enough room for the pointer shape at the
// bottom of off-screen memory; reserve its room by
// lying about how much off-screen memory there is:
ppdev->cyMemory = min(ppdev->yPointerShape, ppdev->cyMemory); } else { // There's not enough room for the pointer shape in
// off-screen memory; we'll have to simulate:
DISPDBG((2,"Not enough room for HW pointer...\n" "\tppdev->yPointerShape(%d)\n" "\tppdev->cyScreen(%d)\n" "\tcjPointerOffset(%d)", ppdev->yPointerShape, ppdev->cyScreen,cjPointerOffset));
ppdev->flCaps |= CAPS_SW_POINTER; } }
// !!! No room for a transfer buffer, as in the 1280x1024 case on
// a 2 MB card. This case should go away when the miniport
// is fixed to return non-power-of-2 screen strides.
if ((ppdev->cyMemory == ppdev->cyScreen) || (ppdev->flCaps & CAPS_NO_HOST_XFER)) { //
// disable host xfer buffer
//
ppdev->lXferBank = 0; ppdev->pulXfer = NULL; DISPDBG((2,"Host transfers disabled")); } else { //
// for chips do not have second aperture
//
// sge01 begin
if (!(ppdev->flCaps & CAPS_SECOND_APERTURE)) { if (ppdev->flCaps & CAPS_AUTOSTART) { (BYTE*)ppdev->pulXfer = ppdev->pjScreen; } else { //
// enable host xfer buffer
//
ASSERTDD(ppdev->cyMemory > ppdev->cyScreen, "No scans left for blt xfer buffer"); ppdev->cyMemory--; cjEndOfFrameBuffer = ppdev->cyMemory * ppdev->lDelta; ppdev->lXferBank = cjEndOfFrameBuffer / ppdev->cjBank; (BYTE*)ppdev->pulXfer = ppdev->pjScreen + (cjEndOfFrameBuffer % ppdev->cjBank);
DISPDBG((2, "ppdev->cyMemory = %x", ppdev->cyMemory)) ; DISPDBG((2, "ppdev->lDelta = %x", ppdev->lDelta)) ; DISPDBG((2, "cjBank: %lx", ppdev->cjBank)) ; DISPDBG((2, "pulXfer = %x", ppdev->pulXfer)) ; DISPDBG((2, "Host transfers enabled")) ; } }#if 0 // D5480
//
// allocate command list buffer
//
if ((ppdev->flCaps & CAPS_COMMAND_LIST) && FALSE) { ppdev->cyMemory -= (COMMAND_BUFFER_SIZE + COMMAND_BUFFER_ALIGN + ppdev->lDelta / 2 ) / ppdev->lDelta; cjEndOfFrameBuffer = ppdev->cyMemory * ppdev->lDelta; pFirstCL = (ULONG)(((ULONG_PTR)ppdev->pjScreen + cjEndOfFrameBuffer + COMMAND_BUFFER_ALIGN) & ~COMMAND_BUFFER_ALIGN); pSecondCL = pFirstCL + (COMMAND_BUFFER_SIZE >> 1);
ppdev->pCLFirst = (ULONG_PTR*) pFirstCL; ppdev->pCLSecond = (ULONG_PTR*) pSecondCL; ppdev->pCommandList = ppdev->pCLFirst; }#endif // endif D5480
//
// Make sure we don't try to use command lists.
//
ppdev->pCommandList = NULL; }
DISPDBG((2, "ppdev->cxMemory = %x", ppdev->cxMemory)) ; DISPDBG((2, "ppdev->cyMemory = %x", ppdev->cyMemory)) ; DISPDBG((2, "ppdev->cxScreen = %x", ppdev->cxScreen)) ; DISPDBG((2, "ppdev->cyScreen = %x", ppdev->cyScreen)) ; DISPDBG((2, "ppdev->lDelta = %x", ppdev->lDelta)) ; DISPDBG((2, "cjBank: %lx", ppdev->cjBank)) ; DISPDBG((2,"pulXfer = %x", ppdev->pulXfer)) ;
// Do some paramater checking on the values that the miniport
// returned to us:
ASSERTDD(ppdev->cxMemory >= ppdev->cxScreen, "Invalid cxMemory"); ASSERTDD(ppdev->cyMemory >= ppdev->cyScreen, "Invalid cyMemory"); } else { CP_DISABLE_MM_IO(ppdev, ppdev->pjPorts);
// Call the kernel driver to reset the device to a known state.
// NTVDM will take things from there:
if (!IOCONTROL(ppdev->hDriver, IOCTL_VIDEO_RESET_DEVICE, NULL, 0, NULL, 0, &ulReturn)) { DISPDBG((0, "bAssertModeHardware - Failed reset IOCTL")); return FALSE; } }
DISPDBG((5, "Passed bAssertModeHardware"));
return(TRUE);
ReturnFalse:
DISPDBG((0, "Failed bAssertModeHardware"));
return(FALSE);}
/******************************Public*Routine******************************\
* BOOL bEnableHardware** Puts the hardware in the requested mode and initializes it.** Note: Should be called before any access is done to the hardware from* the display driver.*\**************************************************************************/
BOOL bEnableHardware(PDEV* ppdev){ VIDEO_PUBLIC_ACCESS_RANGES VideoAccessRange[2]; VIDEO_MEMORY VideoMemory;//sge01 VIDEO_MEMORY_INFORMATION VideoMemoryInfo;
VIDEO_MEMORY_INFORMATION VideoMemoryInfo[2]; // sge01
DWORD ReturnedDataLength; BYTE* pjPorts = ppdev->pjPorts; ULONG ulMode; BOOL bRet;
//
// Check the last field in the PDEV to make sure that the compiler
// didn't generate unaligned fields following BYTE fields.
//
ASSERTDD(!(((ULONG_PTR)(&ppdev->ulLastField)) & 3), "PDEV alignment screwed up... BYTE fields mishandled?");
// Map the ports.
bRet = IOCONTROL(ppdev->hDriver, IOCTL_VIDEO_QUERY_PUBLIC_ACCESS_RANGES, NULL, // input buffer
0, (PVOID) &VideoAccessRange, // output buffer
sizeof (VideoAccessRange), &ReturnedDataLength); if (bRet == FALSE) { DISPDBG((0, "bEnableHardware - Error mapping ports")); goto ReturnFalse; }
// Set a convienent pointer to the registers in the pdev.
ppdev->pjPorts = VideoAccessRange[0].VirtualAddress; ppdev->pjBase = VideoAccessRange[1].VirtualAddress;
//
// Merge port and register access for
// VGA relocatable and MMIO registers.
//
// sge02 begin
#if defined(_X86_)
if (VideoAccessRange[0].InIoSpace) { ppdev->pfnREAD_PORT_UCHAR = CirrusREAD_PORT_UCHAR; ppdev->pfnREAD_PORT_USHORT = CirrusREAD_PORT_USHORT; ppdev->pfnREAD_PORT_ULONG = CirrusREAD_PORT_ULONG; ppdev->pfnWRITE_PORT_UCHAR = CirrusWRITE_PORT_UCHAR; ppdev->pfnWRITE_PORT_USHORT = CirrusWRITE_PORT_USHORT; ppdev->pfnWRITE_PORT_ULONG = CirrusWRITE_PORT_ULONG; } else { ppdev->pfnREAD_PORT_UCHAR = CirrusREAD_REGISTER_UCHAR; ppdev->pfnREAD_PORT_USHORT = CirrusREAD_REGISTER_USHORT; ppdev->pfnREAD_PORT_ULONG = CirrusREAD_REGISTER_ULONG; ppdev->pfnWRITE_PORT_UCHAR = CirrusWRITE_REGISTER_UCHAR; ppdev->pfnWRITE_PORT_USHORT = CirrusWRITE_REGISTER_USHORT; ppdev->pfnWRITE_PORT_ULONG = CirrusWRITE_REGISTER_ULONG; }#elif defined(_ALPHA_)
if (VideoAccessRange[0].InIoSpace) { ppdev->pfnREAD_PORT_UCHAR = READ_PORT_UCHAR; ppdev->pfnREAD_PORT_USHORT = READ_PORT_USHORT; ppdev->pfnREAD_PORT_ULONG = READ_PORT_ULONG; ppdev->pfnWRITE_PORT_UCHAR = WRITE_PORT_UCHAR; ppdev->pfnWRITE_PORT_USHORT = WRITE_PORT_USHORT; ppdev->pfnWRITE_PORT_ULONG = WRITE_PORT_ULONG; } else { ppdev->pfnREAD_PORT_UCHAR = READ_REGISTER_UCHAR; ppdev->pfnREAD_PORT_USHORT = READ_REGISTER_USHORT; ppdev->pfnREAD_PORT_ULONG = READ_REGISTER_ULONG; ppdev->pfnWRITE_PORT_UCHAR = (FnWRITE_PORT_UCHAR)WRITE_REGISTER_UCHAR; ppdev->pfnWRITE_PORT_USHORT = (FnWRITE_PORT_USHORT)WRITE_REGISTER_USHORT; ppdev->pfnWRITE_PORT_ULONG = (FnWRITE_PORT_ULONG)WRITE_REGISTER_ULONG; }#endif
//sge02 end
//
// Try to get the miniport to give us a mode with a linear frame buffer.
//
ulMode = ppdev->ulMode | VIDEO_MODE_MAP_MEM_LINEAR;
if (!IOCONTROL(ppdev->hDriver, IOCTL_VIDEO_SET_CURRENT_MODE, &ulMode, // input buffer
sizeof(DWORD), NULL, 0, &ReturnedDataLength)) { //
// We could not set this mode with a linear frame buffer, so lets try
// again banked.
//
ulMode &= ~VIDEO_MODE_MAP_MEM_LINEAR;
if (!IOCONTROL(ppdev->hDriver, IOCTL_VIDEO_SET_CURRENT_MODE, &ulMode, // input buffer
sizeof(DWORD), NULL, 0, &ReturnedDataLength)) { DISPDBG((0, "bEnableHardware - Failed VIDEO_SET_CURRENT_MODE")); goto ReturnFalse; } }
ppdev->bLinearMode = (ulMode & VIDEO_MODE_MAP_MEM_LINEAR) ? TRUE : FALSE;
// Get the linear memory address range.
VideoMemory.RequestedVirtualAddress = NULL;
if (!IOCONTROL(ppdev->hDriver, IOCTL_VIDEO_MAP_VIDEO_MEMORY, &VideoMemory, // input buffer
sizeof(VIDEO_MEMORY), &VideoMemoryInfo, // output buffer
sizeof(VideoMemoryInfo), &ReturnedDataLength)) { DISPDBG((0, "bEnableHardware - Error mapping video buffer")); goto ReturnFalse; }
//myfr, 2
DISPDBG((2, "FrameBufferBase(ie. pjScreen) %lx", VideoMemoryInfo[0].FrameBufferBase)); DISPDBG((2, "FrameBufferLength %d", VideoMemoryInfo[0].FrameBufferLength)); DISPDBG((2, "VideoRamLength(ie. ulMemSize) %d", VideoMemoryInfo[0].VideoRamLength));
// Record the Frame Buffer Linear Address.
//sge01
ppdev->pjScreen = (BYTE*) VideoMemoryInfo[0].FrameBufferBase; ppdev->cjBank = VideoMemoryInfo[0].FrameBufferLength; ppdev->ulMemSize = VideoMemoryInfo[0].VideoRamLength;
// Now we can set the mode and unlock the accelerator.
if (!bAssertModeHardware(ppdev, TRUE)) { goto ReturnFalse; }
//sge01 begin
if ((ppdev->flCaps & CAPS_SECOND_APERTURE) && !(ppdev->flCaps & CAPS_NO_HOST_XFER)) { ppdev->pulXfer = VideoMemoryInfo[1].VideoRamBase; } //sge01 end
if (ppdev->flCaps & CAPS_MM_IO) { DISPDBG((1,"Memory mapped IO enabled"));#if 1 // D5480
if ((ppdev->flCaps & CAPS_COMMAND_LIST) && (ppdev->pCommandList != NULL)) { //
// Bitmap functions
//
ppdev->pfnXfer1bpp = vMmXfer1bpp80; ppdev->pfnXfer4bpp = vMmXfer4bpp; ppdev->pfnXferNative = vMmXferNative80;
//
// Pattern functions
//
//
// chu02 : This is due to hardware error for 24bpp,
// GR2f[4..0] != 0, non-color expandsion and 8x8 pattern
// copy.
//
ppdev->pfnFillPat = (ppdev->cBpp == 3) ? vMmFillPat36 : vMmFillPat80; ppdev->pfnFillSolid = vMmFillSolid80; ppdev->pfnCopyBlt = vMmCopyBlt80;
//
// Text functions
//
ppdev->pfnGlyphOut = vMmGlyphOut80; ppdev->pfnGlyphOutClip = vMmGlyphOutClip80; } else if(ppdev->flCaps & CAPS_AUTOSTART) { // bitmap functions
ppdev->pfnXfer1bpp = vMmXfer1bpp; ppdev->pfnXfer4bpp = vMmXfer4bpp; ppdev->pfnXferNative = vMmXferNative; // Pattern functions
ppdev->pfnFillPat = vMmFillPat36; ppdev->pfnFillSolid = vMmFillSolid36; ppdev->pfnCopyBlt = vMmCopyBlt36; // Text functions
ppdev->pfnGlyphOut = vMmGlyphOut; ppdev->pfnGlyphOutClip = vMmGlyphOutClip; } else { // bitmap functions
ppdev->pfnXfer1bpp = vMmXfer1bpp; ppdev->pfnXfer4bpp = vMmXfer4bpp; ppdev->pfnXferNative = vMmXferNative; // Pattern functions
ppdev->pfnFillPat = vMmFillPat; ppdev->pfnFillSolid = vMmFillSolid; ppdev->pfnCopyBlt = vMmCopyBlt; // Text functions
ppdev->pfnGlyphOut = vMmGlyphOut; ppdev->pfnGlyphOutClip = vMmGlyphOutClip; } ppdev->pfnFastPatRealize = vMmFastPatRealize;#if LINETO
ppdev->pfnLineTo = bMmLineTo;#endif
#endif // endif D5480
} else { DISPDBG((1,"Memory mapped IO disabled"));
ppdev->pfnXfer1bpp = vIoXfer1bpp; ppdev->pfnXfer4bpp = vIoXfer4bpp; ppdev->pfnXferNative = vIoXferNative; ppdev->pfnFillSolid = vIoFillSolid; ppdev->pfnFillPat = vIoFillPat; ppdev->pfnCopyBlt = vIoCopyBlt; ppdev->pfnFastPatRealize = vIoFastPatRealize;#if LINETO
ppdev->pfnLineTo = bIoLineTo;#endif
}
/////////////////////////////////////////////////////////////
// Fill in pfns specific to linear vs banked frame buffer
if (ppdev->bLinearMode) { ppdev->pfnGetBits = vGetBitsLinear; ppdev->pfnPutBits = vPutBitsLinear; } else { ppdev->pfnGetBits = vGetBits; ppdev->pfnPutBits = vPutBits; }
DISPDBG((5, "Passed bEnableHardware"));
return(TRUE);
ReturnFalse:
DISPDBG((0, "Failed bEnableHardware"));
return(FALSE);}
/******************************Public*Routine******************************\
* VOID vDisableHardware** Undoes anything done in bEnableHardware.** Note: In an error case, we may call this before bEnableHardware is* completely done.*\**************************************************************************/
VOID vDisableHardware(PDEV* ppdev){ //
// It is possible that we reached this point without
// actually mapping memory. (i.e. if the SET_CURRENT_MODE
// failed which occurs before we map memory)
//
// If this is the case, we should not try to free the
// memory, because it hasn't been mapped!
//
if (ppdev->pjScreen) { DWORD ReturnedDataLength; VIDEO_MEMORY VideoMemory;
VideoMemory.RequestedVirtualAddress = ppdev->pjScreen;
if (!IOCONTROL(ppdev->hDriver, IOCTL_VIDEO_UNMAP_VIDEO_MEMORY, &VideoMemory, sizeof(VIDEO_MEMORY), NULL, 0, &ReturnedDataLength)) { DISPDBG((0, "vDisableHardware failed IOCTL_VIDEO_UNMAP_VIDEO")); } }}
/******************************Public*Routine******************************\
* BOOL bInitializeModeFields** Initializes a bunch of fields in the pdev, devcaps (aka gdiinfo), and* devinfo based on the requested mode.*\**************************************************************************/
BOOL bInitializeModeFields(PDEV* ppdev,GDIINFO* pgdi,DEVINFO* pdi,DEVMODEW* pdm){ ULONG cModes; PVIDEO_MODE_INFORMATION pVideoBuffer; PVIDEO_MODE_INFORMATION pVideoModeSelected; PVIDEO_MODE_INFORMATION pVideoTemp; BOOL bSelectDefault; VIDEO_MODE_INFORMATION VideoModeInformation; ULONG cbModeSize;
// crus
VIDEO_PUBLIC_ACCESS_RANGES VideoAccessRange[2]; VIDEO_MEMORY VideoMemory; DWORD ReturnedDataLength; BOOL bRet;
DISPDBG((2, "bInitializeModeFields"));
// crus
bRet = IOCONTROL(ppdev->hDriver, IOCTL_VIDEO_QUERY_PUBLIC_ACCESS_RANGES, NULL, // input buffer
0, (PVOID) &VideoAccessRange, // output buffer
sizeof (VideoAccessRange), &ReturnedDataLength); if (bRet == FALSE) { DISPDBG((0, "bInitializeModeFields - Error mapping ports")); goto ReturnFalse; }
// Set a convienent pointer to the registers in the pdev.
ppdev->pjPorts = VideoAccessRange[0].VirtualAddress; ppdev->pjBase = VideoAccessRange[1].VirtualAddress; //sge01 end
//
// Merge port and register access for
// VGA relocatable and MMIO registers.
//
// crus
#if defined(_X86_)
if (VideoAccessRange[0].InIoSpace) { ppdev->pfnREAD_PORT_UCHAR = CirrusREAD_PORT_UCHAR; ppdev->pfnREAD_PORT_USHORT = CirrusREAD_PORT_USHORT; ppdev->pfnREAD_PORT_ULONG = CirrusREAD_PORT_ULONG; ppdev->pfnWRITE_PORT_UCHAR = CirrusWRITE_PORT_UCHAR; ppdev->pfnWRITE_PORT_USHORT = CirrusWRITE_PORT_USHORT; ppdev->pfnWRITE_PORT_ULONG = CirrusWRITE_PORT_ULONG; } else { ppdev->pfnREAD_PORT_UCHAR = CirrusREAD_REGISTER_UCHAR; ppdev->pfnREAD_PORT_USHORT = CirrusREAD_REGISTER_USHORT; ppdev->pfnREAD_PORT_ULONG = CirrusREAD_REGISTER_ULONG; ppdev->pfnWRITE_PORT_UCHAR = CirrusWRITE_REGISTER_UCHAR; ppdev->pfnWRITE_PORT_USHORT = CirrusWRITE_REGISTER_USHORT; ppdev->pfnWRITE_PORT_ULONG = CirrusWRITE_REGISTER_ULONG; }#elif defined(_ALPHA_)
if (VideoAccessRange[0].InIoSpace) { ppdev->pfnREAD_PORT_UCHAR = READ_PORT_UCHAR; ppdev->pfnREAD_PORT_USHORT = READ_PORT_USHORT; ppdev->pfnREAD_PORT_ULONG = READ_PORT_ULONG; ppdev->pfnWRITE_PORT_UCHAR = WRITE_PORT_UCHAR; ppdev->pfnWRITE_PORT_USHORT = WRITE_PORT_USHORT; ppdev->pfnWRITE_PORT_ULONG = WRITE_PORT_ULONG; } else { ppdev->pfnREAD_PORT_UCHAR = READ_REGISTER_UCHAR; ppdev->pfnREAD_PORT_USHORT = READ_REGISTER_USHORT; ppdev->pfnREAD_PORT_ULONG = READ_REGISTER_ULONG; ppdev->pfnWRITE_PORT_UCHAR = (FnWRITE_PORT_UCHAR)WRITE_REGISTER_UCHAR; ppdev->pfnWRITE_PORT_USHORT = (FnWRITE_PORT_USHORT)WRITE_REGISTER_USHORT; ppdev->pfnWRITE_PORT_ULONG = (FnWRITE_PORT_ULONG)WRITE_REGISTER_ULONG; }#endif
//crus
CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, 0x27); ppdev->ulChipID = CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA) & 0xFC;
// Call the miniport to get mode information
cModes = getAvailableModes(ppdev->hDriver, &pVideoBuffer, &cbModeSize);
if (cModes == 0) { DISPDBG((2, "getAvailableModes returned 0")); goto ReturnFalse; }
// Now see if the requested mode has a match in that table.
pVideoModeSelected = NULL; pVideoTemp = pVideoBuffer;
if ((pdm->dmPelsWidth == 0) && (pdm->dmPelsHeight == 0) && (pdm->dmBitsPerPel == 0) && (pdm->dmDisplayFrequency == 0)) { DISPDBG((2, "Default mode requested")); bSelectDefault = TRUE; } else { DISPDBG((2, "Requested mode...")); DISPDBG((2, " Screen width -- %li", pdm->dmPelsWidth)); DISPDBG((2, " Screen height -- %li", pdm->dmPelsHeight)); DISPDBG((2, " Bits per pel -- %li", pdm->dmBitsPerPel)); DISPDBG((2, " Frequency -- %li", pdm->dmDisplayFrequency)); bSelectDefault = FALSE; }
while (cModes--) { if (pVideoTemp->Length != 0) {//myfr, 2->0
DISPDBG((2, "Checking against miniport mode:")); DISPDBG((2, " Screen width -- %li", pVideoTemp->VisScreenWidth)); DISPDBG((2, " Screen height -- %li", pVideoTemp->VisScreenHeight)); DISPDBG((2, " Bits per pel -- %li", pVideoTemp->BitsPerPlane * pVideoTemp->NumberOfPlanes)); DISPDBG((2, " Frequency -- %li", pVideoTemp->Frequency));
//pat04, begin
//#if 0
#if (_WIN32_WINNT < 0x0400)
if ((ppdev->ulChipID == CL7541_ID) || (ppdev->ulChipID == CL7543_ID) || (ppdev->ulChipID == CL7542_ID) || (ppdev->ulChipID == CL7548_ID) || (ppdev->ulChipID == CL7555_ID) || (ppdev->ulChipID == CL7556_ID)) { if ((pVideoTemp->VisScreenWidth == 640) && (pVideoTemp->VisScreenHeight == 480) && (pVideoTemp->BitsPerPlane * pVideoTemp->NumberOfPlanes == 8) && (pVideoTemp->Frequency == 60)) { pVideoModeSelected = pVideoTemp; } // default mode = 640x480x256 ! //#pat4
}#endif
//#endif //0, pat04
//pat04, end
if (bSelectDefault || ((pVideoTemp->VisScreenWidth == pdm->dmPelsWidth) && (pVideoTemp->VisScreenHeight == pdm->dmPelsHeight) && (pVideoTemp->BitsPerPlane * pVideoTemp->NumberOfPlanes == pdm->dmBitsPerPel) && (pVideoTemp->Frequency == pdm->dmDisplayFrequency))) { pVideoModeSelected = pVideoTemp; DISPDBG((2, "...Found a mode match!")); break; } } pVideoTemp = (PVIDEO_MODE_INFORMATION) (((PUCHAR)pVideoTemp) + cbModeSize); }
// If no mode has been found, return an error
if (pVideoModeSelected == NULL) { DISPDBG((2, "...Couldn't find a mode match!")); FREE(pVideoBuffer); //ms923
goto ReturnFalse; }
// We have chosen the one we want. Save it in a stack buffer and
// get rid of allocated memory before we forget to free it.
VideoModeInformation = *pVideoModeSelected; FREE(pVideoBuffer);
#if DEBUG_HEAP
VideoModeInformation.VisScreenWidth = 640; VideoModeInformation.VisScreenHeight = 480;#endif
// Set up screen information from the mini-port:
ppdev->ulMode = VideoModeInformation.ModeIndex; ppdev->cxScreen = VideoModeInformation.VisScreenWidth; ppdev->cyScreen = VideoModeInformation.VisScreenHeight;
DISPDBG((2, "ScreenStride: %lx", VideoModeInformation.ScreenStride));
//crus
#ifdef PANNING_SCROLL
if ((ppdev->ulChipID == 0x38) || (ppdev->ulChipID == 0x2C) || (ppdev->ulChipID == 0x30) || (ppdev->ulChipID == 0x34) || //myf19
(ppdev->ulChipID == 0x40) || (ppdev->ulChipID == 0x4C)) //myf17
{ CirrusLaptopViewPoint(ppdev, &VideoModeInformation); }#endif
// Setting the SYNCHRONIZEACCESS flag tells GDI that we
// want all drawing to the bitmaps to be synchronized (GDI
// is multi-threaded and by default does not synchronize
// device bitmap drawing -- it would be a Bad Thing for us
// to have multiple threads using the accelerator at the
// same time):
ppdev->flHooks = HOOK_SYNCHRONIZEACCESS | HOOK_FILLPATH | HOOK_BITBLT | HOOK_TEXTOUT | HOOK_COPYBITS | HOOK_STROKEPATH | HOOK_SYNCHRONIZE#if LINETO
| HOOK_LINETO#endif
#if !DRIVER_PUNT_ALL
#if !DRIVER_PUNT_STRETCH
| HOOK_STRETCHBLT#endif
#endif
;
// Fill in the GDIINFO data structure with the default 8bpp values:
*pgdi = ggdiDefault;
// Now overwrite the defaults with the relevant information returned
// from the kernel driver:
pgdi->ulHorzSize = VideoModeInformation.XMillimeter; pgdi->ulVertSize = VideoModeInformation.YMillimeter;
pgdi->ulHorzRes = VideoModeInformation.VisScreenWidth; pgdi->ulVertRes = VideoModeInformation.VisScreenHeight;
#if (NT_VERSION < 0x0400)
pgdi->ulDesktopHorzRes = VideoModeInformation.VisScreenWidth; pgdi->ulDesktopVertRes = VideoModeInformation.VisScreenHeight;#else
pgdi->ulPanningHorzRes = VideoModeInformation.VisScreenWidth; pgdi->ulPanningVertRes = VideoModeInformation.VisScreenHeight;#endif
pgdi->cBitsPixel = VideoModeInformation.BitsPerPlane; pgdi->cPlanes = VideoModeInformation.NumberOfPlanes; pgdi->ulVRefresh = VideoModeInformation.Frequency;
pgdi->ulDACRed = VideoModeInformation.NumberRedBits; pgdi->ulDACGreen = VideoModeInformation.NumberGreenBits; pgdi->ulDACBlue = VideoModeInformation.NumberBlueBits;
pgdi->ulLogPixelsX = pdm->dmLogPixels; pgdi->ulLogPixelsY = pdm->dmLogPixels;
// Fill in the devinfo structure with the default 8bpp values:
*pdi = gdevinfoDefault;
// Several MIPS machines are broken in that 64 bit accesses to the
// framebuffer don't work.
#ifdef GCAPS_NO64BITMEMACCESS
if (VideoModeInformation.AttributeFlags & VIDEO_MODE_NO_64_BIT_ACCESS) { DISPDBG((2, "Disable 64 bit access on this device !\n")); pdi->flGraphicsCaps |= GCAPS_NO64BITMEMACCESS; }#endif
if (VideoModeInformation.BitsPerPlane == 8) { ppdev->cBpp = 1; ppdev->cBitsPerPixel = 8; ppdev->iBitmapFormat = BMF_8BPP; ppdev->jModeColor = 0; ppdev->ulWhite = 0xff; } else if ((VideoModeInformation.BitsPerPlane == 16) || (VideoModeInformation.BitsPerPlane == 15)) { ppdev->cBpp = 2; ppdev->cBitsPerPixel = 16; ppdev->iBitmapFormat = BMF_16BPP; ppdev->jModeColor = SET_16BPP_COLOR; ppdev->ulWhite = 0xffff; ppdev->flRed = VideoModeInformation.RedMask; ppdev->flGreen = VideoModeInformation.GreenMask; ppdev->flBlue = VideoModeInformation.BlueMask;
pgdi->ulNumColors = (ULONG) -1; pgdi->ulNumPalReg = 0; pgdi->ulHTOutputFormat = HT_FORMAT_16BPP;
pdi->iDitherFormat = BMF_16BPP; pdi->flGraphicsCaps &= ~(GCAPS_PALMANAGED | GCAPS_COLOR_DITHER); } else if (VideoModeInformation.BitsPerPlane == 24) {
ppdev->cBpp = 3; ppdev->cBitsPerPixel = 24; ppdev->iBitmapFormat = BMF_24BPP; ppdev->jModeColor = SET_24BPP_COLOR; ppdev->ulWhite = 0xffffff; ppdev->flRed = VideoModeInformation.RedMask; ppdev->flGreen = VideoModeInformation.GreenMask; ppdev->flBlue = VideoModeInformation.BlueMask;
pgdi->ulNumColors = (ULONG) -1; pgdi->ulNumPalReg = 0; pgdi->ulHTOutputFormat = HT_FORMAT_24BPP;
pdi->iDitherFormat = BMF_24BPP; pdi->flGraphicsCaps &= ~(GCAPS_PALMANAGED | GCAPS_COLOR_DITHER); } else { ASSERTDD(VideoModeInformation.BitsPerPlane == 32, "This driver supports only 8, 16, 24 and 32bpp");
ppdev->cBpp = 4; ppdev->cBitsPerPixel = 32; ppdev->iBitmapFormat = BMF_32BPP; ppdev->jModeColor = SET_32BPP_COLOR; ppdev->ulWhite = 0xffffffff; ppdev->flRed = VideoModeInformation.RedMask; ppdev->flGreen = VideoModeInformation.GreenMask; ppdev->flBlue = VideoModeInformation.BlueMask;
pgdi->ulNumColors = (ULONG) -1; pgdi->ulNumPalReg = 0; pgdi->ulHTOutputFormat = HT_FORMAT_32BPP;
pdi->iDitherFormat = BMF_32BPP; pdi->flGraphicsCaps &= ~(GCAPS_PALMANAGED | GCAPS_COLOR_DITHER); }
DISPDBG((5, "Passed bInitializeModeFields")); return(TRUE);
ReturnFalse:
DISPDBG((0, "Failed bInitializeModeFields")); return(FALSE);}
/******************************Public*Routine******************************\
* DWORD getAvailableModes** Calls the miniport to get the list of modes supported by the kernel driver,* and returns the list of modes supported by the diplay driver among those** returns the number of entries in the videomode buffer.* 0 means no modes are supported by the miniport or that an error occured.** NOTE: the buffer must be freed up by the caller.*\**************************************************************************/
DWORD getAvailableModes(HANDLE hDriver,PVIDEO_MODE_INFORMATION* modeInformation,DWORD* cbModeSize){ ULONG ulTemp; VIDEO_NUM_MODES modes; PVIDEO_MODE_INFORMATION pVideoTemp;
//
// Get the number of modes supported by the mini-port
//
if (!IOCONTROL(hDriver, IOCTL_VIDEO_QUERY_NUM_AVAIL_MODES, NULL, 0, &modes, sizeof(VIDEO_NUM_MODES), &ulTemp)) { DISPDBG((0, "getAvailableModes - Failed VIDEO_QUERY_NUM_AVAIL_MODES")); return(0); }
*cbModeSize = modes.ModeInformationLength;
//
// Allocate the buffer for the mini-port to write the modes in.
//
*modeInformation = (PVIDEO_MODE_INFORMATION) ALLOC(modes.NumModes * modes.ModeInformationLength);
if (*modeInformation == (PVIDEO_MODE_INFORMATION) NULL) { DISPDBG((0, "getAvailableModes - Failed EngAllocMem")); return 0; }
//
// Ask the mini-port to fill in the available modes.
//
if (!IOCONTROL(hDriver, IOCTL_VIDEO_QUERY_AVAIL_MODES, NULL, 0, *modeInformation, modes.NumModes * modes.ModeInformationLength, &ulTemp)) {
DISPDBG((0, "getAvailableModes - Failed VIDEO_QUERY_AVAIL_MODES"));
FREE(*modeInformation); *modeInformation = (PVIDEO_MODE_INFORMATION) NULL;
return(0); }
//
// Now see which of these modes are supported by the display driver.
// As an internal mechanism, set the length to 0 for the modes we
// DO NOT support.
//
ulTemp = modes.NumModes; pVideoTemp = *modeInformation;
//
// Mode is rejected if it is not one plane, or not graphics, or is not
// one of 8, 15, 16, 24 or 32 bits per pel.
//
while (ulTemp--) { if ((pVideoTemp->NumberOfPlanes != 1 ) || !(pVideoTemp->AttributeFlags & VIDEO_MODE_GRAPHICS) ||//ms923 added
!(pVideoTemp->DriverSpecificAttributeFlags & CAPS_BLT_SUPPORT)|| ((pVideoTemp->BitsPerPlane != 8) && (pVideoTemp->BitsPerPlane != 15) && (pVideoTemp->BitsPerPlane != 16) && (pVideoTemp->BitsPerPlane != 24) && (pVideoTemp->BitsPerPlane != 32))) { DISPDBG((2, "Rejecting miniport mode:")); pVideoTemp->Length = 0; } else { DISPDBG((2, "Accepting miniport mode:")); }
pVideoTemp = (PVIDEO_MODE_INFORMATION) (((PUCHAR)pVideoTemp) + modes.ModeInformationLength); }
return(modes.NumModes);}
//crus begin
//myf1, begin
#ifdef PANNING_SCROLL
VOIDCirrusLaptopViewPoint(PDEV* ppdev,PVIDEO_MODE_INFORMATION pVideoModeInfo){ UCHAR ChipID; UCHAR savSEQidx, Panel_Type, LCD;
// Panning Scrolling Supported for TI
//myf16 savSEQidx = CP_IN_BYTE(ppdev->pjPorts, SR_INDEX);
//myf16 CP_OUT_BYTE(ppdev->pjPorts, SR_INDEX, 0x09);
//myf16 Panel_Type = (CP_IN_BYTE(ppdev->pjPorts, SR_DATA) & 0x70) >> 4;
//myf16 CP_OUT_BYTE(ppdev->pjPorts, SR_INDEX, savSEQidx);
savSEQidx = CP_IN_BYTE(ppdev->pjPorts, CRTC_INDEX); CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, 0x27); ChipID = (CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA) & 0xFC) >> 2;
if ((ChipID == 0x0E) || (ChipID == 0x0B) || (ChipID == 0x0C)) //7548/7543/7541
{ CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, 0x20); LCD = CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA) & 0x20; } else if ((ChipID == 0x10) || (ChipID == 0x13)) //myf17
{ CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, 0x80); LCD = CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA) & 0x01; } CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, savSEQidx);
if ((ChipID == 0x0E) || (ChipID == 0x0B) || (ChipID == 0x0C) || (ChipID == 0x10) || (ChipID == 0x13)) //myf17
{ if ((LCD) && //myf33
!(pVideoModeInfo->DriverSpecificAttributeFlags & CAPS_TV_ON) && (pVideoModeInfo->DriverSpecificAttributeFlags & CAPS_SVGA_PANEL)) { ppdev->Hres = 800; ppdev->Vres = 600; } else if ((LCD) && //myf33
!(pVideoModeInfo->DriverSpecificAttributeFlags & CAPS_TV_ON) && (pVideoModeInfo->DriverSpecificAttributeFlags & CAPS_VGA_PANEL)) { ppdev->Hres = 640; ppdev->Vres = 480; } else if ((LCD) && //myf33
!(pVideoModeInfo->DriverSpecificAttributeFlags & CAPS_TV_ON) && (pVideoModeInfo->DriverSpecificAttributeFlags & CAPS_XGA_PANEL)) { ppdev->Hres = 1024; ppdev->Vres = 768; } else { ppdev->Hres = pVideoModeInfo->VisScreenWidth; ppdev->Vres = pVideoModeInfo->VisScreenHeight; }
ppdev->min_Xscreen = 0; ppdev->max_Xscreen = ppdev->Hres - 1; ppdev->min_Yscreen = 0; ppdev->max_Yscreen = ppdev->Vres - 1; DISPDBG((2,"INIT- PANNING SCROLLING : %x\t:%x, %x, \n %x, %x, %x, %x\n", ppdev->ulMode,ppdev->Hres, ppdev->Vres, ppdev->min_Xscreen, ppdev->max_Xscreen, ppdev->min_Yscreen, ppdev->max_Yscreen)); } ppdev->flCaps = pVideoModeInfo->DriverSpecificAttributeFlags; //myf33
}#endif
//myf1, end
//crus end
|
