You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
447 lines
18 KiB
447 lines
18 KiB
/******************************Module*Header*******************************\
|
|
* Module Name: driver.h
|
|
*
|
|
* Contains prototypes for the 256 colour VGA driver.
|
|
*
|
|
* NOTE: Must mirror driver.inc!
|
|
*
|
|
* Copyright (c) 1992-1995 Microsoft Corporation
|
|
\**************************************************************************/
|
|
|
|
#ifndef _DRIVER_
|
|
#define _DRIVER_
|
|
|
|
#include "stdlib.h"
|
|
#include "stddef.h"
|
|
#include "windows.h"
|
|
#include "winddi.h"
|
|
#include "devioctl.h"
|
|
#include "ntddvdeo.h"
|
|
|
|
#include "debug.h"
|
|
|
|
typedef struct _PDEV PDEV, *PPDEV;
|
|
|
|
//
|
|
// A mode requires broken rasters if the stride is a power of 2 and the video ram
|
|
// accessed is greater than 64K.
|
|
//
|
|
|
|
#define POW2(stride) (!((stride) & ((stride)-1))) // TRUE if stride is power of 2
|
|
#define BROKEN_RASTERS(stride,cy) ((!(POW2(stride))) && ((stride*cy) > 0x10000))
|
|
|
|
//
|
|
// Sizes assumed for 1-window and 2 RW-window banks.
|
|
//
|
|
|
|
#define BANK_SIZE_1_WINDOW 0x10000L
|
|
#define BANK_SIZE_2RW_WINDOW 0x08000L
|
|
|
|
//
|
|
// This will be used by everyone who needs a temporary working buffer
|
|
//
|
|
|
|
#define PAGE_SIZE 4096
|
|
#define NUM_GLOBAL_PAGES 2
|
|
#define GLOBAL_BUFFER_SIZE (PAGE_SIZE * NUM_GLOBAL_PAGES)
|
|
|
|
#define PELS_PER_DWORD 4
|
|
|
|
|
|
/**************************************************************************\
|
|
*
|
|
* Specifies desired justification for requestion scan line within bank window
|
|
*
|
|
\**************************************************************************/
|
|
|
|
typedef enum {
|
|
JustifyTop = 0,
|
|
JustifyBottom,
|
|
} BANK_JUST;
|
|
|
|
/**************************************************************************\
|
|
*
|
|
* Specifies which window is to be mapped by two-window bank handler.
|
|
*
|
|
\**************************************************************************/
|
|
|
|
typedef enum {
|
|
MapSourceBank = 0,
|
|
MapDestBank,
|
|
} BANK_JUST;
|
|
|
|
/**************************************************************************\
|
|
*
|
|
* Bank clipping info
|
|
*
|
|
\**************************************************************************/
|
|
|
|
typedef struct {
|
|
RECTL rclBankBounds; // describes pixels addressable in this bank
|
|
ULONG ulBankOffset; // offset of bank start from bitmap start, if
|
|
// the bitmap were linearly addressable
|
|
} BANK_INFO, *PBANK_INFO;
|
|
|
|
/**************************************************************************\
|
|
*
|
|
* Bank control function vector
|
|
*
|
|
\**************************************************************************/
|
|
|
|
typedef VOID (*PFN_PlanarEnable)();
|
|
typedef VOID (*PFN_PlanarDisable)();
|
|
typedef VOID (*PFN_PlanarControl)(PPDEV, ULONG, BANK_JUST);
|
|
typedef VOID (*PFN_PlanarControl2)(PPDEV, ULONG, BANK_JUST, ULONG);
|
|
typedef VOID (*PFN_PlanarNext)(PPDEV);
|
|
typedef VOID (*PFN_PlanarNext2)(PPDEV, ULONG);
|
|
typedef VOID (*PFN_BankControl)(PPDEV, ULONG, BANK_JUST);
|
|
typedef VOID (*PFN_BankControl2)(PPDEV, ULONG, BANK_JUST, ULONG);
|
|
typedef VOID (*PFN_BankNext)(PPDEV);
|
|
typedef VOID (*PFN_BankNext2)(PPDEV, ULONG);
|
|
|
|
/**************************************************************************\
|
|
*
|
|
* Miscellaneous driver flags
|
|
*
|
|
\**************************************************************************/
|
|
|
|
#define DRIVER_PLANAR_CAPABLE 0x01L
|
|
#define DRIVER_OFFSCREEN_REFRESHED 0x02L // if not set, don't use offscreen
|
|
// memory for long operations
|
|
// (because the memory won't be
|
|
// refreshed)
|
|
#define DRIVER_HAS_OFFSCREEN 0x04L // if not set, can't use any offscreen
|
|
// memory
|
|
|
|
/**************************************************************************\
|
|
*
|
|
* Bank status flags
|
|
*
|
|
\**************************************************************************/
|
|
|
|
#define BANK_BROKEN_RASTER1 0x01L // If bank1 or read bank has broken raster
|
|
#define BANK_BROKEN_RASTER2 0x02L // If bank2 or write bank has broken raster
|
|
#define BANK_BROKEN_RASTERS (BANK_BROKEN_RASTER1 | BANK_BROKEN_RASTER2)
|
|
#define BANK_PLANAR 0x04L // If in planar mode
|
|
|
|
/**************************************************************************\
|
|
*
|
|
* Structure for maintaining a realized brush:
|
|
*
|
|
\**************************************************************************/
|
|
|
|
extern const ULONG gaaulPlanarPat[][8]; // Hatch brushes in preferred format
|
|
|
|
#define RBRUSH_BLACKWHITE 0x001L // Black and white brush
|
|
#define RBRUSH_2COLOR 0x002L // 2 color brush
|
|
#define RBRUSH_NCOLOR 0x004L // n color brush
|
|
#define RBRUSH_4PELS_WIDE 0x008L // Brush is 4xN
|
|
|
|
#define BRUSH_SIZE 64 // An 8x8 8bpp brush needs 64 bytes
|
|
#define BRUSH_MAX_CACHE_SCANS 2 // Maximum # of scans used by brush cache
|
|
|
|
typedef struct _RBRUSH
|
|
{
|
|
FLONG fl; // Flags
|
|
LONG xBrush; // Realized brush's x brush origin
|
|
|
|
// Info for 2 color brushes:
|
|
|
|
ULONG ulFgColor; // Foreground color
|
|
ULONG ulBkColor; // Background color
|
|
|
|
// Info for n color brushes:
|
|
|
|
LONG cy; // Height of pattern
|
|
LONG cyLog2; // log2 of the height
|
|
LONG iCache; // Cache entry index. Zero is not
|
|
// a valid index.
|
|
|
|
// Pattern in preferred format:
|
|
|
|
ULONG aulPattern[BRUSH_SIZE / sizeof(ULONG)];
|
|
|
|
} RBRUSH; /* rb */
|
|
|
|
typedef struct _BRUSHCACHEENTRY
|
|
{
|
|
RBRUSH* prbVerifyRealization; // We never dereference this pointer
|
|
// to find a brush realization;
|
|
// it is only ever used in a compare
|
|
// to verify that for a realized brush,
|
|
// its off-screen cache entry is still
|
|
// valid.
|
|
LONG yCache; // Scan where entry's bits live
|
|
LONG ulCache; // Offset to cache entry from screen
|
|
// start (assuming planar format --
|
|
// if you want the non-planar offset,
|
|
// multiply by 4)
|
|
|
|
} BRUSHCACHEENTRY; /* bce */
|
|
|
|
/**************************************************************************\
|
|
*
|
|
* Physical device data structure
|
|
*
|
|
\**************************************************************************/
|
|
|
|
// ***********************************************************
|
|
// *** MUST match the assembler version in i386\driver.inc ***
|
|
// ***********************************************************
|
|
|
|
typedef struct _PDEV
|
|
{
|
|
FLONG fl; // Driver flags (DRIVER_xxx)
|
|
HANDLE hDriver; // Handle to \Device\Screen
|
|
HDEV hdevEng; // Engine's handle to PDEV
|
|
HSURF hsurfEng; // Engine's handle to surface
|
|
HANDLE hsurfBm; // Handle to the "punt" surface
|
|
SURFOBJ* pSurfObj; // pointer to the locked "punt" surface
|
|
|
|
HPALETTE hpalDefault; // Handle to the default palette for device.
|
|
|
|
PBYTE pjScreen; // This is pointer to base screen address
|
|
ULONG cxScreen; // Visible screen width
|
|
ULONG cyScreen; // Visible screen height
|
|
ULONG ulMode; // Mode the mini-port driver is in.
|
|
LONG lDeltaScreen; // Distance from one scan to the next.
|
|
|
|
FLONG flRed; // For bitfields device, Red Mask
|
|
FLONG flGreen; // For bitfields device, Green Mask
|
|
FLONG flBlue; // For bitfields device, Blue Mask
|
|
ULONG cPaletteShift; // number of bits the 8-8-8 palette must
|
|
// be shifted by to fit in the hardware
|
|
// palette.
|
|
ULONG ulBitCount; // # of bits per pel -- can be only 8
|
|
|
|
ULONG ulrm0_wmX; // Four values (one per byte) to set
|
|
// GC5 to to select read mode 0
|
|
// together with write modes 0-3
|
|
|
|
BYTE* pjGlyphFlipTableBase; // Base allocated address for flip
|
|
// table; the pointer we use is this
|
|
// pointer rounded up to the nearest
|
|
// 256-byte boundary
|
|
BYTE* pjGlyphFlipTable; // Pointer to table used to flip glyph
|
|
// bits 0-3 and 4-7
|
|
PALETTEENTRY* pPal; // If this is pal managed, this is the pal
|
|
|
|
HBITMAP hbmTmp; // Handle to temporary buffer
|
|
SURFOBJ* psoTmp; // Temporary surface
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// DCI stuff:
|
|
|
|
BOOL bSupportDCI; // True if miniport supports DCI
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// Off screen stuff:
|
|
|
|
// Brush cache:
|
|
|
|
LONG iCache; // Index for next brush to be allocated
|
|
LONG iCacheLast; // Last valid cache index (so the
|
|
// number of entries in cache is
|
|
// iCacheLast + 1)
|
|
BRUSHCACHEENTRY* pbceCache; // Pointer to allocated cache
|
|
|
|
// Saved screen bits stuff
|
|
|
|
RECTL rclSavedBitsRight; // right rect of vga memory that's
|
|
// not visible
|
|
RECTL rclSavedBitsBottom; // bottom rect of vga memory that's
|
|
// not visible
|
|
BOOL bBitsSaved; // TRUE if bits are currently saved
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// Bank manager stuff common between planar and non-planar modes:
|
|
|
|
LONG cTotalScans; // Number of usable on and off-screen
|
|
// scans
|
|
PVIDEO_BANK_SELECT pBankInfo; // Bank info for current mode returned
|
|
// by miniport
|
|
|
|
FLONG flBank; // Flags for current bank state
|
|
|
|
ULONG ulBitmapSize; // Length of bitmap if there were no
|
|
// banking, in CPU addressable bytes
|
|
ULONG ulWindowBank[2]; // Current banks mapped into windows
|
|
// 0 & 1
|
|
PVOID pvBitmapStart; // Single-window bitmap start pointer
|
|
// (adjusted as necessary to make
|
|
// window map in at proper offset)
|
|
PVOID pvBitmapStart2Window[2];// Double-window window 0 and 1 bitmap
|
|
// start
|
|
|
|
// Non-planar mode specific bank management control stuff:
|
|
|
|
VIDEO_BANK_TYPE vbtBankingType; // Type of banking
|
|
PFN pfnBankSwitchCode; // Pointer to bank switch code
|
|
|
|
LONG lNextScan; // Offset to next bank in bytes
|
|
BYTE* pjJustifyTopBank; // Pointer to lookup table for
|
|
// converting scans to banks
|
|
BANK_INFO* pbiBankInfo; // Array of bank clip info
|
|
ULONG ulJustifyBottomOffset; // # of scans from top to bottom
|
|
// of bank, for bottom justifying
|
|
ULONG iLastBank; // Index of last valid bank in
|
|
// pbiBankInfo table
|
|
ULONG ulBank2RWSkip; // Offset from one bank index to next
|
|
// to make two 32K banks appear to be
|
|
// one seamless 64K bank
|
|
|
|
PFN_BankControl pfnBankControl; // Pointer to bank control function
|
|
PFN_BankControl2 pfnBankControl2Window; // Pointer to double-window bank
|
|
// control function
|
|
PFN_BankNext pfnBankNext; // Pointer to next bank function
|
|
PFN_BankNext2 pfnBankNext2Window; // Pointer to double-window next
|
|
// bank function
|
|
|
|
RECTL rcl1WindowClip; // Single-window banking clip rect
|
|
RECTL rcl2WindowClip[2]; // Double-window banking clip rects for
|
|
// windows 0 & 1
|
|
|
|
// Planar mode specific bank management control stuff:
|
|
|
|
VIDEO_BANK_TYPE vbtPlanarType; // Type of planar banking
|
|
|
|
PFN pfnPlanarSwitchCode; // Pointer to planar bank switch
|
|
// code
|
|
|
|
LONG lPlanarNextScan; // Offset to next planar bank in
|
|
// bytes
|
|
BYTE* pjJustifyTopPlanar; // Pointer to lookup table for
|
|
// converting scans to banks
|
|
BANK_INFO* pbiPlanarInfo; // Array of bank clip info
|
|
ULONG ulPlanarBottomOffset;// # of scans from top to bottom
|
|
// of bank, for bottom justifying
|
|
ULONG iLastPlanar; // Index of last valid bank in
|
|
// pbiPlanarInfo table
|
|
ULONG ulPlanar2RWSkip; // Offset from one bank index to next
|
|
// to make two 32K banks appear to be
|
|
// one seamless 64K bank
|
|
|
|
PFN_PlanarControl pfnPlanarControl; // Planar one window bank control
|
|
PFN_PlanarControl2 pfnPlanarControl2; // Planar two window bank control
|
|
|
|
PFN_PlanarNext pfnPlanarNext; // Planar one window next bank
|
|
PFN_PlanarNext2 pfnPlanarNext2; // Planar two window next bank
|
|
|
|
RECTL rcl1PlanarClip; // Single-window banking clip rect
|
|
RECTL rcl2PlanarClip[2]; // Double-window banking clip rects for
|
|
// windows 0 & 1
|
|
|
|
PFN_PlanarEnable pfnPlanarEnable; // Function to enable planar mode
|
|
PFN_PlanarDisable pfnPlanarDisable; // Function to disable planar mode
|
|
|
|
// Smart bank manager stuff:
|
|
|
|
LONG iLastScan; // Last scan we want to enumerate
|
|
PVOID pvSaveScan0; // Surface's original pvScan0
|
|
RECTL rclSaveBounds; // Clip Object's original bounds
|
|
CLIPOBJ* pcoNull; // Points to an empty clip object
|
|
// we can use when we're given a
|
|
// NULL CLIPOBJ pointer
|
|
BYTE iSaveDComplexity; // Clip Object's original complexity
|
|
BYTE fjSaveOptions; // Clip Object's original flags
|
|
BYTE ajFiller[2]; // Pack dword alignment
|
|
|
|
PVOID pvTmpBuf; // Ptr to buffer attached to pdev
|
|
|
|
BOOLEAN BankIoctlSupported; // Does the miniport support ioclt
|
|
// based banking?
|
|
}; /* pdev */
|
|
|
|
// Palette stuff:
|
|
|
|
#define MAX_CLUT_SIZE (sizeof(VIDEO_CLUT) + (sizeof(ULONG) * 256))
|
|
|
|
// Size of the driver extra information in the DEVMODe structure passed
|
|
// to and from the display driver
|
|
|
|
#define DRIVER_EXTRA_SIZE 0
|
|
|
|
#define DLL_NAME L"VGA256" // Name of the DLL in UNICODE
|
|
#define STANDARD_DEBUG_PREFIX "VGA256: " // All debug output is prefixed
|
|
#define ALLOC_TAG '2gvD' // 4 byte TAG for memory allocations
|
|
|
|
// When calling vEnumStart, make sure you set bAll to FALSE. This will tell
|
|
// the Engine to only enumerate rectangles in rclBounds.
|
|
|
|
// Hooks and Driver function table.
|
|
|
|
#define HOOKS_BMF8BPP (HOOK_BITBLT | HOOK_TEXTOUT | HOOK_FILLPATH | \
|
|
HOOK_COPYBITS | HOOK_STROKEPATH | HOOK_PAINT | \
|
|
HOOK_STRETCHBLT)
|
|
|
|
#define BB_RECT_LIMIT 50
|
|
|
|
typedef struct _BBENUM
|
|
{
|
|
ULONG c;
|
|
RECTL arcl[BB_RECT_LIMIT];
|
|
} BBENUM;
|
|
|
|
#define TO_RECT_LIMIT 20
|
|
|
|
typedef struct _TEXTENUM
|
|
{
|
|
ULONG c;
|
|
RECTL arcl[TO_RECT_LIMIT];
|
|
} TEXTENUM;
|
|
|
|
// Initialization stuff:
|
|
|
|
BOOL bEnableBanking(PPDEV);
|
|
VOID vDisableBanking(PPDEV);
|
|
BOOL bInitPDEV(PPDEV,PDEVMODEW,GDIINFO *, DEVINFO *);
|
|
BOOL bInitSURF(PPDEV,BOOL);
|
|
BOOL bInitPaletteInfo(PPDEV, DEVINFO *);
|
|
BOOL bInit256ColorPalette(PPDEV);
|
|
BOOL bInitPatterns(PPDEV, INT);
|
|
VOID vInitBrushCache(PPDEV);
|
|
VOID vInitSavedBits(PPDEV);
|
|
VOID vDisablePalette(PPDEV);
|
|
VOID vDisablePatterns(PPDEV);
|
|
VOID vDisableSURF(PPDEV);
|
|
VOID vDisableBrushCache(PPDEV);
|
|
VOID vResetBrushCache(PPDEV);
|
|
VOID vInitRegs(PPDEV);
|
|
DWORD getAvailableModes(HANDLE, PVIDEO_MODE_INFORMATION *, DWORD *);
|
|
|
|
// Smart bank manager stuff:
|
|
|
|
CLIPOBJ* pcoBankStart(PPDEV, RECTL*, SURFOBJ*, CLIPOBJ*);
|
|
BOOL bBankEnum(PPDEV, SURFOBJ*, CLIPOBJ*);
|
|
VOID vBankStartBltSrc(PPDEV, SURFOBJ*, POINTL*, RECTL*, POINTL*, RECTL*);
|
|
BOOL bBankEnumBltSrc(PPDEV, SURFOBJ*, POINTL*, RECTL*, POINTL*, RECTL*);
|
|
VOID vBankStartBltDest(PPDEV, SURFOBJ*, POINTL*, RECTL*, POINTL*, RECTL*);
|
|
BOOL bBankEnumBltDest(PPDEV, SURFOBJ*, POINTL*, RECTL*, POINTL*, RECTL*);
|
|
|
|
// Fill routines:
|
|
|
|
typedef union _RBRUSH_COLOR {
|
|
RBRUSH* prb;
|
|
ULONG iSolidColor;
|
|
} RBRUSH_COLOR; /* rbc */
|
|
|
|
typedef VOID (*PFNFILL)(PPDEV, ULONG, PRECTL, MIX, RBRUSH_COLOR, POINTL*);
|
|
|
|
VOID vTrgBlt(PPDEV, ULONG, PRECTL, MIX, RBRUSH_COLOR, POINTL*);
|
|
VOID vMonoPat(PPDEV, ULONG, PRECTL, MIX, RBRUSH_COLOR, POINTL*);
|
|
VOID vColorPat(PPDEV, ULONG, PRECTL, MIX, RBRUSH_COLOR, POINTL*);
|
|
|
|
// Other prototypes:
|
|
|
|
BOOL b2ColorBrush(ULONG* pvBits, BYTE* pjFgColor, BYTE* pjBkColor);
|
|
VOID vPlanarCopyBits(PPDEV, RECTL*, POINTL*);
|
|
BOOL bIntersectRect(RECTL*, RECTL*, RECTL*);
|
|
VOID vSetWriteModes(ULONG *);
|
|
VOID vClearMemDword(PULONG * pulBuffer, ULONG ulDwordCount);
|
|
VOID vSrcCopy8bpp(PPDEV, RECTL*, POINTL*, LONG, VOID*);
|
|
VOID vFastLine(PPDEV, PATHOBJ*, LONG, ULONG);
|
|
|
|
#endif // _DRIVER_
|