/******************************Module*Header*******************************\ * Module Name: driver.h * * Contains prototypes for the 64k color VGA driver. * * NOTE: Must mirror driver.inc! * * Copyright (c) 1992 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 // // Temporary buffer must be at least as large as a bank. // Must also be a multiple of 4. // #define TMP_BUFFER_SIZE (BANK_SIZE_1_WINDOW) /**************************************************************************\ * * Specifies desired justification for requested 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_USE_OFFSCREEN 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 /**************************************************************************\ * * 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 ulBitCount; // # of bits per pel -- can be only 16 GDIINFO* pGdiInfo; // Pointer to temporary buffer for GDIINFO struct DEVINFO* pDevInfo; // Pointer to temporary buffer for DEVINFO struct ULONG ulrm0_wmX; // Four values (one per byte) to set // GC5 to to select read mode 0 // together with write modes 0-3 // Off screen save stuff: HBITMAP hbmTmp; // Handle to temporary buffer SURFOBJ* psoTmp; // Temporary surface PVOID pvTmp; // Pointer to temporary buffer ULONG cyTmp; // # of scans in temporary surface // DCI stuff: BOOL bSupportDCI; // True if miniport supports DCI // 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 BOOLEAN BankIoctlSupported; // does the miniport support ioctl // based banking? }; /* pdev */ // 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"vga64k" // Name of the DLL in UNICODE #define STANDARD_DEBUG_PREFIX "VGA64K: " // All debug output is prefixed #define ALLOC_TAG '6gvD' // 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_BMF16BPP (HOOK_BITBLT | HOOK_TEXTOUT | HOOK_COPYBITS | \ HOOK_STROKEPATH | HOOK_PAINT) #define BB_RECT_LIMIT 50 typedef struct _BBENUM { ULONG c; RECTL arcl[BB_RECT_LIMIT]; } BBENUM; // Initialization stuff: BOOL bEnableBanking(PPDEV); VOID vDisableBanking(PPDEV); BOOL bInitPDEV(PPDEV,PDEVMODEW); BOOL bInitSURF(PPDEV,BOOL); VOID vDisableSURF(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*); // Other prototypes: VOID vPlanarCopyBits(PPDEV, RECTL*, POINTL*); BOOL bIntersectRect(RECTL*, RECTL*, RECTL*); VOID vSetWriteModes(ULONG *); #endif // _DRIVER_