|
|
/******************************Module*Header*******************************\
* Module Name: driver.h** Contains prototypes for the display driver.** Copyright (c) 1992-1995 Microsoft Corporation\**************************************************************************/
//////////////////////////////////////////////////////////////////////
// Put all the conditional-compile constants here. There had better
// not be many!
// Multi-board support can be enabled by setting this to 1:
#define MULTI_BOARDS 0
// This is the maximum number of boards we'll support in a single
// virtual driver:
#if MULTI_BOARDS
#define MAX_BOARDS 16
#define IBOARD(ppdev) ((ppdev)->iBoard)
#else
#define MAX_BOARDS 1
#define IBOARD(ppdev) 0
#endif
//////////////////////////////////////////////////////////////////////
// Miscellaneous shared stuff
#define DLL_NAME L"ati" // Name of the DLL in UNICODE
#define STANDARD_DEBUG_PREFIX "ATI: " // All debug output is prefixed
// by this string
#define ALLOC_TAG ' ITA' // Four byte tag used for tracking
// memory allocations (characters
// are in reverse order)
#define CLIP_LIMIT 50 // We'll be taking 800 bytes of stack space
#define DRIVER_EXTRA_SIZE 0 // Size of the DriverExtra information in the
// DEVMODE structure
#define TMP_BUFFER_SIZE 8192 // Size in bytes of 'pvTmpBuffer'. Has to
// be at least enough to store an entire
// scan line (i.e., 6400 for 1600x1200x32).
#define ROUND8(x) (((x)+7)&~7)
typedef struct _CLIPENUM { LONG c; RECTL arcl[CLIP_LIMIT]; // Space for enumerating complex clipping
} CLIPENUM; /* ce, pce */
typedef struct _PDEV PDEV; // Handy forward declaration
// Basic Mach types:
typedef enum { MACH_IO_32, // Mach8 or Mach32
MACH_MM_32, // Mach32 capable of memory-mapped I/O
MACH_MM_64, // Mach64
} MACHTYPE;
// Specific ASIC types:
typedef enum { ASIC_38800_1, // Mach8
ASIC_68800_3, // Mach32
ASIC_68800_6, // Mach32
ASIC_68800AX, // Mach32
ASIC_88800GX, // Mach64
ASIC_COUNT} ASIC;
// Frame buffer aperture types:
typedef enum { APERTURE_NONE, APERTURE_FULL, APERTURE_PAGE_SINGLE, APERTURE_PAGE_DOUBLE, APERTURE_COUNT} APERTURE;
// NOTE: Must be kept in sync with miniport version of the structure!
#include "atint.h"
#if TARGET_BUILD > 351
#define AtiDeviceIoControl(handle,controlCode,inBuffer,inBufferSize,outBuffer,outBufferSize,bytesReturned) \
(!EngDeviceIoControl(handle,controlCode,inBuffer,inBufferSize,outBuffer,outBufferSize,bytesReturned))
#define AtiAllocMem(a,b,allocSize) EngAllocMem((b),allocSize,ALLOC_TAG)
#define AtiFreeMem(ptr) EngFreeMem(ptr)
#else
#define AtiDeviceIoControl(handle,controlCode,inBuffer,inBufferSize,outBuffer,outBufferSize,bytesReturned) \
DeviceIoControl(handle,controlCode,inBuffer,inBufferSize,outBuffer,outBufferSize,bytesReturned,NULL)
#define AtiAllocMem(a,b,allocSize) LocalAlloc((a),allocSize)
#define AtiFreeMem(ptr) LocalFree(ptr)
#endif
VOID vSetClipping(PDEV*, RECTL*);VOID vResetClipping(PDEV*);
//////////////////////////////////////////////////////////////////////
// Text stuff
#define GLYPH_CACHE_CX 64 // Maximal width of glyphs that we'll consider
// caching
#define GLYPH_CACHE_CY 64 // Maximum height of glyphs that we'll consider
// caching
#define GLYPH_ALLOC_SIZE 8100
// Do all cached glyph memory allocations
// in 8k chunks
#define HGLYPH_SENTINEL ((ULONG) -1)
// GDI will never give us a glyph with a
// handle value of 0xffffffff, so we can
// use this as a sentinel for the end of
// our linked lists
#define GLYPH_HASH_SIZE 256
#define GLYPH_HASH_FUNC(x) ((x) & (GLYPH_HASH_SIZE - 1))
typedef struct _CACHEDGLYPH CACHEDGLYPH;typedef struct _CACHEDGLYPH{ CACHEDGLYPH* pcgNext; // Points to next glyph that was assigned
// to the same hash table bucket
HGLYPH hg; // Handles in the bucket-list are kept in
// increasing order
POINTL ptlOrigin; // Origin of glyph bits
// Device specific fields below here:
LONG cx; // Width of the glyph
LONG cy; // Height of the glyph
LONG cxy; // Height and width encoded
LONG cw; // Number of words in glyph
LONG cd; // Number of dwords in glyph
// Glyph bits follow here:
ULONG ad[1]; // Start of glyph bits
} CACHEDGLYPH; /* cg, pcg */
typedef struct _GLYPHALLOC GLYPHALLOC;typedef struct _GLYPHALLOC{ GLYPHALLOC* pgaNext; // Points to next glyph structure that
// was allocated for this font
CACHEDGLYPH acg[1]; // This array is a bit misleading, because
// the CACHEDGLYPH structures are actually
// variable sized
} GLYPHAALLOC; /* ga, pga */
typedef struct _CACHEDFONT{ GLYPHALLOC* pgaChain; // Points to start of allocated memory list
CACHEDGLYPH* pcgNew; // Points to where in the current glyph
// allocation structure a new glyph should
// be placed
LONG cjAlloc; // Bytes remaining in current glyph allocation
// structure
CACHEDGLYPH cgSentinel; // Sentinel entry of the end of our bucket
// lists, with a handle of HGLYPH_SENTINEL
CACHEDGLYPH* apcg[GLYPH_HASH_SIZE]; // Hash table for glyphs
} CACHEDFONT; /* cf, pcf */
BOOL bEnableText(PDEV*);VOID vDisableText(PDEV*);VOID vAssertModeText(PDEV*, BOOL);
/////////////////////////////////////////////////////////////////////
// for overlay support
#if TARGET_BUILD > 351
// new stuff from overlay.c
#define UPDATEOVERLAY 0x01L
#define SETOVERLAYPOSITION 0x02L
#define DOUBLE_PITCH 0x04L
#define OVERLAY_ALLOCATED 0x08L
#define OVERLAY_VISIBLE 0x10L
#define CRTC_INTERLACE_EN 0x00000002L
#define CRTC_VLINE_CRNT_VLINE 0x04
#define CLOCK_CNTL 0x24
#define DD_RESERVED_DIFFERENTPIXELFORMAT 0x0001
typedef struct tagOVERLAYINFO16 { DWORD dwFlags; RECTL rSrc; RECTL rDst; RECTL rOverlay; DWORD dwBuf0Start; LONG lBuf0Pitch; DWORD dwBuf1Start; LONG lBuf1Pitch; DWORD dwOverlayKeyCntl; DWORD dwHInc; DWORD dwVInc; }OVERLAYINFO16;
/*****************************************************************************
VT - GT Registers
*****************************************************************************/
#define DD_OVERLAY_Y_X 0x00
#define DD_OVERLAY_Y_X_END 0x01
#define DD_OVERLAY_VIDEO_KEY_CLR 0x02
#define DD_OVERLAY_VIDEO_KEY_MSK 0x03
#define DD_OVERLAY_GRAPHICS_KEY_CLR 0x04
#define DD_OVERLAY_GRAPHICS_KEY_MSK 0x05
#define DD_OVERLAY_KEY_CNTL 0x06
#define DD_OVERLAY_SCALE_INC 0x08
#define DD_OVERLAY_SCALE_CNTL 0x09
#define DD_SCALER_HEIGHT_WIDTH 0x0A
#define DD_OVERLAY_TEST 0x0B
#define DD_SCALER_THRESHOLD 0x0C
#define DD_SCALER_BUF0_OFFSET 0x0D
#define DD_SCALER_BUF1_OFFSET 0x0E
#define DD_SCALER_BUF_PITCH 0x0F
#define DD_VIDEO_FORMAT 0x12
#define DD_VIDEO_CONFIG 0x13
#define DD_CAPTURE_CONFIG 0x14
#define DD_TRIG_CNTL 0x15
#define DD_VMC_CONFIG 0x18
#define DD_BUF0_OFFSET 0x20
#define DD_BUF0_PITCH 0x23
#define DD_BUF1_OFFSET 0x26
#define DD_BUF1_PITCH 0x29
// for RAGE III
#define DD_SCALER_COLOUR_CNTL 0x54
#define DD_SCALER_H_COEFF0 0x55
#define DD_SCALER_H_COEFF1 0x56
#define DD_SCALER_H_COEFF2 0x57
#define DD_SCALER_H_COEFF3 0x58
#define DD_SCALER_H_COEFF4 0x59
/*****************************************************************************/// stuff from overlay.c
#define MAKE_FOURCC( ch0, ch1, ch2, ch3 ) \
( (DWORD)(BYTE)(ch0) | ( (DWORD)(BYTE)(ch1) << 8 ) | \ ( (DWORD)(BYTE)(ch2) << 16 ) | ( (DWORD)(BYTE)(ch3) << 24 ) )
#define FOURCC_YUY2 MAKE_FOURCC('Y','U','Y','2')
#define FOURCC_UYVY MAKE_FOURCC('U','Y','V','Y')
#define FOURCC_YVYU MAKE_FOURCC('Y','V','Y','U')
// end overlay support
#endif
//////////////////////////////////////////////////////////////////////
// Dither stuff
// Describes a single colour tetrahedron vertex for dithering:
typedef struct _VERTEX_DATA { ULONG ulCount; // Number of pixels in this vertex
ULONG ulVertex; // Vertex number
} VERTEX_DATA; /* vd, pv */
VERTEX_DATA* vComputeSubspaces(ULONG, VERTEX_DATA*);VOID vDitherColor(ULONG*, VERTEX_DATA*, VERTEX_DATA*, ULONG);
//////////////////////////////////////////////////////////////////////
// Brush stuff
#define TOTAL_BRUSH_COUNT 8 // We'll keep room for 8 brushes in our
// Mach64 off-screen brush cache.
// Must be a power of two.
#define TOTAL_BRUSH_SIZE 64 // We'll only ever handle 8x8 patterns,
// and this is the number of pels
#define RBRUSH_2COLOR 1 // For RBRUSH flags
typedef struct _BRUSHENTRY BRUSHENTRY;typedef union _RBRUSH_COLOR RBRUSH_COLOR;
typedef VOID (FNFILL)(PDEV*, LONG, RECTL*, ULONG, RBRUSH_COLOR, POINTL*);
typedef struct _RBRUSH { FLONG fl; // Type flags
ULONG ulForeColor; // Foreground colour if 1bpp
ULONG ulBackColor; // Background colour if 1bpp
POINTL ptlBrush; // Monochrome brush's alignment
FNFILL* pfnFillPat; // Fill routine to be called for this brush
BRUSHENTRY* apbe[MAX_BOARDS];// Points to brush-entry that keeps track
// of the cached off-screen brush bits
ULONG aulPattern[1]; // Open-ended array for keeping copy of the
// Don't put anything // actual pattern bits in case the brush
// after here, or // origin changes, or someone else steals
// you'll be sorry! // our brush entry (declared as a ULONG
// for proper dword alignment)
} RBRUSH; /* rb, prb */
typedef struct _BRUSHENTRY { RBRUSH* prbVerify; // We never dereference this pointer to
// find a brush realization; it is only
// ever used in a compare to verify
// that for a given realized brush, our
// off-screen brush entry is still valid.
LONG x; // x-position of cached pattern
LONG y; // y-position of cached pattern
ULONG ulOffsetPitch; // Packed offset and pitch of cached brush
// in off-screen memory on the Mach64
} BRUSHENTRY; /* be, pbe */
typedef union _RBRUSH_COLOR { RBRUSH* prb; ULONG iSolidColor;} RBRUSH_COLOR; /* rbc, prbc */
BOOL bEnableBrushCache(PDEV*);VOID vDisableBrushCache(PDEV*);VOID vAssertModeBrushCache(PDEV*, BOOL);
//////////////////////////////////////////////////////////////////////
// Stretch stuff
typedef struct _STR_BLT { PDEV* ppdev; PBYTE pjSrcScan; LONG lDeltaSrc; LONG XSrcStart; PBYTE pjDstScan; LONG lDeltaDst; LONG XDstStart; LONG XDstEnd; LONG YDstStart; LONG YDstCount; ULONG ulXDstToSrcIntCeil; ULONG ulXDstToSrcFracCeil; ULONG ulYDstToSrcIntCeil; ULONG ulYDstToSrcFracCeil; ULONG ulXFracAccumulator; ULONG ulYFracAccumulator;} STR_BLT;
typedef VOID (*PFN_DIRSTRETCH)(STR_BLT*);typedef BOOL (FN_STRETCHDIB)(PDEV*, VOID*, LONG, RECTL*, VOID*, LONG, RECTL*, RECTL*);
VOID vDirectStretch8Narrow(STR_BLT*);VOID vM64DirectStretch8(STR_BLT*);VOID vM64DirectStretch16(STR_BLT*);VOID vM64DirectStretch32(STR_BLT*);VOID vM32DirectStretch8(STR_BLT*);VOID vM32DirectStretch16(STR_BLT*);VOID vI32DirectStretch8(STR_BLT*);VOID vI32DirectStretch16(STR_BLT*);
FN_STRETCHDIB bM64StretchDIB;FN_STRETCHDIB bM32StretchDIB;FN_STRETCHDIB bI32StretchDIB;
/////////////////////////////////////////////////////////////////////////
// Heap stuff
typedef enum { OH_FREE = 0, // The off-screen allocation is available for use
OH_DISCARDABLE, // The allocation is occupied by a discardable bitmap
// that may be moved out of off-screen memory
OH_PERMANENT, // The allocation is occupied by a permanent bitmap
// that cannot be moved out of off-screen memory
} OHSTATE;
typedef struct _DSURF DSURF;typedef struct _OH OH;typedef struct _OH{ OHSTATE ohState; // State of off-screen allocation
LONG x; // x-coordinate of left edge of allocation
LONG y; // y-coordinate of top edge of allocation
LONG cx; // Width in pixels of allocation
LONG cy; // Height in pixels of allocation
LONG cxReserved; // Dimensions of original reserved rectangle;
LONG cyReserved; // zero if rectangle is not 'reserved'
OH* pohNext; // When OH_FREE or OH_RESERVE, points to the next
// free node, in ascending cxcy value. This is
// kept as a circular doubly-linked list with a
// sentinel at the end.
// When OH_DISCARDABLE, points to the next most
// recently created allocation. This is kept as
// a circular doubly-linked list.
OH* pohPrev; // Opposite of 'pohNext'
ULONG cxcy; // Width and height in a dword for searching
OH* pohLeft; // Adjacent allocation when in-use or available
OH* pohUp; OH* pohRight; OH* pohDown; DSURF* pdsurf; // Points to our DSURF structure
VOID* pvScan0; // Points to start of first scan-line
}; /* oh, poh */
// This is the smallest structure used for memory allocations:
typedef struct _OHALLOC OHALLOC;typedef struct _OHALLOC{ OHALLOC* pohaNext; OH aoh[1];} OHALLOC; /* oha, poha */
typedef struct _HEAP{ LONG cxMax; // Largest possible free space by area
LONG cyMax; OH ohFree; // Head of the free list, containing those
// rectangles in off-screen memory that are
// available for use. pohNext points to
// hte smallest available rectangle, and pohPrev
// points to the largest available rectangle,
// sorted by cxcy.
OH ohDiscardable; // Head of the discardable list that contains all
// bitmaps located in offscreen memory that
// are eligible to be tossed out of the heap.
// It is kept in order of creation: pohNext
// points to the most recently created; pohPrev
// points to the least recently created.
OH ohPermanent; // List of permanently allocated rectangles
OH* pohFreeList; // List of OH node data structures available
OHALLOC* pohaChain; // Chain of allocations
} HEAP; /* heap, pheap */
typedef enum { DT_SCREEN, // Surface is kept in screen memory
DT_DIB // Surface is kept as a DIB
} DSURFTYPE; /* dt, pdt */
typedef struct _DSURF{ DSURFTYPE dt; // DSURF status (whether off-screen or in a DIB)
SIZEL sizl; // Size of the original bitmap (could be smaller
// than poh->sizl)
PDEV* ppdev; // Need this for deleting the bitmap
union { OH* poh; // If DT_SCREEN, points to off-screen heap node
SURFOBJ* pso; // If DT_DIB, points to locked GDI surface
};
// The following are used for DT_DIB only...
ULONG cBlt; // Counts down the number of blts necessary at
// the current uniqueness before we'll consider
// putting the DIB back into off-screen memory
ULONG iUniq; // Tells us whether there have been any heap
// 'free's since the last time we looked at
// this DIB
} DSURF; /* dsurf, pdsurf */
// GDI expects dword alignment for any bitmaps on which it is expected
// to draw. Since we occasionally ask GDI to draw directly on our off-
// screen bitmaps, this means that any off-screen bitmaps must be dword
// aligned in the frame buffer. We enforce this merely by ensuring that
// all off-screen bitmaps are four-pel aligned (we may waste a couple of
// pixels at the higher colour depths):
#define HEAP_X_ALIGNMENT 4
// Number of blts necessary before we'll consider putting a DIB DFB back
// into off-screen memory:
#define HEAP_COUNT_DOWN 6
// Flags for 'pohAllocate':
typedef enum { FLOH_ONLY_IF_ROOM = 0x0001, // Don't kick stuff out of off-
// screen memory to make room
FLOH_MAKE_PERMANENT = 0x0002, // Allocate a permanent entry
FLOH_RESERVE = 0x0004, // Allocate an off-screen entry,
// but let it be used by discardable
// bitmaps until it's needed
} FLOH;
// Publicly callable heap APIs:
OH* pohAllocate(PDEV*, POINTL*, LONG, LONG, FLOH);BOOL bOhCommit(PDEV*, OH*, BOOL);OH* pohFree(PDEV*, OH*);
OH* pohMoveOffscreenDfbToDib(PDEV*, OH*);BOOL bMoveDibToOffscreenDfbIfRoom(PDEV*, DSURF*);BOOL bMoveAllDfbsFromOffscreenToDibs(PDEV* ppdev);
BOOL bEnableOffscreenHeap(PDEV*);VOID vDisableOffscreenHeap(PDEV*);BOOL bAssertModeOffscreenHeap(PDEV*, BOOL);
/////////////////////////////////////////////////////////////////////////
// Bank manager stuff
#define BANK_DATA_SIZE 80 // Number of bytes to allocate for the
// miniport down-loaded bank code working
// space
typedef struct _BANK{ // Private data:
RECTL rclDraw; // Rectangle describing the remaining undrawn
// portion of the drawing operation
RECTL rclSaveBounds; // Saved from original CLIPOBJ for restoration
BYTE iSaveDComplexity; // Saved from original CLIPOBJ for restoration
BYTE fjSaveOptions; // Saved from original CLIPOBJ for restoration
LONG iBank; // Current bank
PDEV* ppdev; // Saved copy
// Public data:
SURFOBJ* pso; // Surface wrapped around the bank. Has to be
// passed as the surface in any banked call-
// back.
CLIPOBJ* pco; // Clip object that is the intersection of the
// original clip object with the bounds of the
// current bank. Has to be passed as the clip
// object in any banked call-back.
} BANK; /* bnk, pbnk */
// Note: BANK_MODE is duplicated in i386\strucs.inc!
typedef enum { BANK_OFF = 0, // We've finished using the memory aperture
BANK_ON, // We're about to use the memory aperture
BANK_ON_NO_WAIT, // We're about to use the memory aperture, and are
// doing our own hardware synchronization
BANK_DISABLE, // We're about to enter full-screen; shut down banking
BANK_ENABLE, // We've exited full-screen; re-enable banking
} BANK_MODE; /* bankm, pbankm */
typedef struct _BANKDATA { ULONG ulDumb; // !!!!!!!!
} BANKDATA; /* bd, pbd */
typedef VOID (FNBANKMAP)(PDEV*, BANKDATA*, LONG);typedef VOID (FNBANKSELECTMODE)(PDEV*, BANKDATA*, BANK_MODE);typedef VOID (FNBANKINITIALIZE)(PDEV*, BANKDATA*);typedef BOOL (FNBANKCOMPUTE)(PDEV*, RECTL*, RECTL*, LONG*, LONG*);
VOID vBankStart(PDEV*, RECTL*, CLIPOBJ*, BANK*);BOOL bBankEnum(BANK*);
FNBANKCOMPUTE bBankComputeNonPower2;FNBANKCOMPUTE bBankComputePower2;
BOOL bEnableBanking(PDEV*);VOID vDisableBanking(PDEV*);VOID vAssertModeBanking(PDEV*, BOOL);
/////////////////////////////////////////////////////////////////////////
// Pointer stuff
#define MONO_POINTER_UP 0x0001
#define NO_HARDWARE_CURSOR 0x0002
#define CURSOR_CY 64
#define CURSOR_CX 64
typedef struct _CUROBJ{ POINTL ptlHotSpot; // Pointer hot spot
SIZEL szlPointer; // Extent of the pointer
POINTL ptlLastPosition; // Last position of pointer
POINTL ptlLastOffset; // Last offset from 0,0 within cursor
ULONG flPointer; // Pointer specific flags.
ULONG mono_offset; // Hardware cursor offset
POINTL hwCursor;} CUROBJ, *PCUROBJ;
BOOL bEnablePointer(PDEV*);VOID vDisablePointer(PDEV*);VOID vAssertModePointer(PDEV*, BOOL);
/////////////////////////////////////////////////////////////////////////
// Palette stuff
BOOL bEnablePalette(PDEV*);VOID vDisablePalette(PDEV*);VOID vAssertModePalette(PDEV*, BOOL);
BOOL bInitializePalette(PDEV*, DEVINFO*);VOID vUninitializePalette(PDEV*);
#define MAX_CLUT_SIZE (sizeof(VIDEO_CLUT) + (sizeof(ULONG) * 256))
#define REDSHIFT ((ppdev->flRed & 1)? 0:((ppdev->flRed & 0x100)? 8:16))
#define GREENSHIFT ((ppdev->flGreen & 1)? 0:((ppdev->flGreen & 0x100)? 8:16))
#define BLUESHIFT ((ppdev->flBlue & 1)? 0:((ppdev->flBlue & 0x100)? 8:16))
//////////////////////////////////////////////////////////////////////
// Low-level blt function prototypes
typedef VOID (FNXFER)(PDEV*, LONG, RECTL*, ULONG, SURFOBJ*, POINTL*, RECTL*, XLATEOBJ*);typedef VOID (FNCOPY)(PDEV*, LONG, RECTL*, ULONG, POINTL*, RECTL*);typedef BOOL (FNTEXTOUT)(PDEV*, STROBJ*, FONTOBJ*, CLIPOBJ*, RECTL*, BRUSHOBJ*, BRUSHOBJ*);typedef VOID (FNLINETOTRIVIAL)(PDEV*, LONG, LONG, LONG, LONG, ULONG, MIX, RECTL*);typedef VOID (FNPATREALIZE)(PDEV*, RBRUSH*);
FNFILL vI32FillPatColor;FNFILL vI32FillPatMonochrome;FNFILL vI32FillSolid;FNXFER vI32Xfer1bpp;FNXFER vI32Xfer4bpp;FNXFER vI32Xfer8bpp;FNXFER vI32XferNative;FNCOPY vI32CopyBlt;FNLINETOTRIVIAL vI32LineToTrivial;FNTEXTOUT bI32TextOut;
FNFILL vM32FillPatColor;FNFILL vM32FillPatMonochrome;FNFILL vM32FillSolid;FNXFER vM32Xfer1bpp;FNXFER vM32Xfer4bpp;FNXFER vM32Xfer8bpp;FNXFER vM32XferNative;FNCOPY vM32CopyBlt;FNLINETOTRIVIAL vM32LineToTrivial;FNTEXTOUT bM32TextOut;
FNFILL vM64FillPatColor;FNFILL vM64FillPatMonochrome;FNFILL vM64FillSolid;FNXFER vM64Xfer1bpp;FNXFER vM64Xfer4bpp;FNXFER vM64Xfer8bpp;FNXFER vM64XferNative;FNCOPY vM64CopyBlt;FNCOPY vM64CopyBlt_VTA4;FNLINETOTRIVIAL vM64LineToTrivial;FNTEXTOUT bM64TextOut;FNPATREALIZE vM64PatColorRealize;
FNFILL vM64FillPatColor24;FNFILL vM64FillPatMonochrome24;FNFILL vM64FillSolid24;FNXFER vM64XferNative24;FNCOPY vM64CopyBlt24;FNCOPY vM64CopyBlt24_VTA4;FNLINETOTRIVIAL vM64LineToTrivial24;FNTEXTOUT bM64TextOut24;
typedef VOID (FNXFERBITS)(PDEV*, SURFOBJ*, RECTL*, POINTL*);
FNXFERBITS vPutBits;FNXFERBITS vGetBits;FNXFERBITS vI32PutBits;FNXFERBITS vI32GetBits;
//////////////////////////////////////////////////////////////////////
// Low-level hardware cursor function prototypes
typedef VOID (FNSETCURSOROFFSET)(PDEV*);typedef VOID (FNUPDATECURSOROFFSET)(PDEV*,LONG,LONG,LONG);typedef VOID (FNUPDATECURSORPOSITION)(PDEV*,LONG,LONG);typedef VOID (FNCURSOROFF)(PDEV*);typedef VOID (FNCURSORON)(PDEV*,LONG);typedef VOID (FNPOINTERBLIT)(PDEV*,LONG,LONG,LONG,LONG,BYTE*,LONG);
FNSETCURSOROFFSET vM64SetCursorOffset;FNUPDATECURSOROFFSET vM64UpdateCursorOffset;FNUPDATECURSORPOSITION vM64UpdateCursorPosition;FNCURSOROFF vM64CursorOff;FNCURSORON vM64CursorOn;FNSETCURSOROFFSET vM64SetCursorOffset_TVP;FNUPDATECURSOROFFSET vM64UpdateCursorOffset_TVP;FNUPDATECURSORPOSITION vM64UpdateCursorPosition_TVP;FNCURSOROFF vM64CursorOff_TVP;FNCURSORON vM64CursorOn_TVP;FNSETCURSOROFFSET vM64SetCursorOffset_IBM514;FNUPDATECURSOROFFSET vM64UpdateCursorOffset_IBM514;FNUPDATECURSORPOSITION vM64UpdateCursorPosition_IBM514;FNCURSOROFF vM64CursorOff_IBM514;FNCURSORON vM64CursorOn_IBM514;FNUPDATECURSOROFFSET vM64UpdateCursorOffset_CT;FNCURSOROFF vM64CursorOff_CT;FNCURSORON vM64CursorOn_CT;FNPOINTERBLIT vM64PointerBlit;FNPOINTERBLIT vM64PointerBlit_TVP;FNPOINTERBLIT vM64PointerBlit_IBM514;
FNSETCURSOROFFSET vI32SetCursorOffset;FNUPDATECURSOROFFSET vI32UpdateCursorOffset;FNUPDATECURSORPOSITION vI32UpdateCursorPosition;FNCURSOROFF vI32CursorOff;FNCURSORON vI32CursorOn;FNPOINTERBLIT vI32PointerBlit;
FNPOINTERBLIT vPointerBlitLFB;
#if TARGET_BUILD > 351
///////////////////////////////////////////////////////////////////////
// DirectDraw stuff
typedef struct _FLIPRECORD{ FLATPTR fpFlipFrom; LONGLONG liFlipTime; LONGLONG liFlipDuration; DWORD wFlipScanLine; BOOL bHaveEverCrossedVBlank; BOOL bWasEverInDisplay; BOOL bFlipFlag; WORD wstartOfVBlank;// only used in MACH32
} FLIPRECORD;typedef FLIPRECORD *LPFLIPRECORD;
#define ROUND_UP_TO_64K(x) (((ULONG)(x) + 0x10000 - 1) & ~(0x10000 - 1))
#define ROUND_DOWN_TO_64K(x) (((ULONG)(x) & 0xFFFF0000 ))
BOOL bEnableDirectDraw(PDEV*);VOID vDisableDirectDraw(PDEV*);VOID vAssertModeDirectDraw(PDEV*, BOOL);
#endif
////////////////////////////////////////////////////////////////////////
// Capabilities flags
typedef enum { CAPS_MONOCHROME_PATTERNS = 1, // Hardware has 8x8 monochrome pattern
// capability in this mode
CAPS_COLOR_PATTERNS = 2, // Capable of colour patterns. I.e.,
// running at 8bpp on Mach32, and
// a brush cache has been allocated
// on the Mach64
CAPS_LINEAR_FRAMEBUFFER = 4, // Frame buffer is mapped linearly
} CAPS;
// DIRECT_ACCESS returns TRUE if there is any sort of aperture that
// can be directly accessed:
#define DIRECT_ACCESS(ppdev) (ppdev->iAperture != APERTURE_NONE)
////////////////////////////////////////////////////////////////////////
// The Physical Device data structure
typedef struct _PDEV{#ifdef OGLMCD //start OGLMCD support
DWORD dwSize; // size of PDEV structure; used by atimcd.dll
// All the OpenGL MCD support in the PDEV must be at the begining of the structure
// because atimcd.dll and ati.dll don't have to be in sync, but any additions to PDEV
// that can affect the MCD used field's offset in the structure will break the MCD
// new fields for MCDOGL containing revision no.
BYTE MCDMajorRev; BYTE MCDMinorRev;
////////// This is only for OGL MCD support
//functions pointers to ALLOC and FREE functions from heap.c
// CJ PFN pohAllocate;
// CJ PFN pohFree;
OH* (*pohAllocate)(PDEV*, POINTL*, LONG, LONG, FLOH); OH* (*pohFree)(PDEV*, OH*);
ULONG iUniqueness; // display uniqueness for tracking
// resolution changes
LONG cDoubleBufferRef; // Reference count for current number
// of RC's that have active double-
// buffers
OH* pohBackBuffer; // Our 2-d heap allocation structure
// for the back-buffer
ULONG ulBackBuffer; // Byte offset in the frame buffer
// to the start of the back-buffer
LONG cZBufferRef; // Reference count for current number
// of RC's that have active z-buffers
// (which, on Athenta, is all RC's)
OH* pohZBuffer; // Our 2-d heap allocation structure
// for the z-buffer
ULONG ulFrontZBuffer; // Byte offset in the frame buffer
// to the start of the front z-buffer
// (the MGA sometimes has to have
// separate z-buffers for front and
// back)
ULONG ulBackZBuffer; // Byte offset in the frame buffer
// to the start of the back z-buffer
HANDLE hMCD; // Handle to MCD engine dll
MCDENGESCFILTERFUNC pMCDFilterFunc; // MCD engine filter function
HANDLE hMCD_ATI; // Handle to ATI MCD driver dll
PFN pMCDrvGetEntryPoints; // ATI MCD function for filling supported functions index
#endif // end OGLMCD
LONG xOffset; // Pixel offset from (0, 0) to current
LONG yOffset; // DFB located in off-screen memory
BYTE* pjMmBase; // Start of memory mapped I/O
BYTE* VideoRamBase; // fixup for pjMmBase so that vDisableHardware can free it
UCHAR* pjIoBase; // Start of I/O space (NULL on x86)
BYTE* pjScreen; // Points to base screen address
LONG lDelta; // Distance from one scan to the next.
LONG cPelSize; // 0 if 8bpp, 1 if 16bpp, 2 if 32bpp
LONG cjPelSize; // 1 if 8bpp, 2 if 16bpp, 3 if 24bpp,
// 4 if 32bpp
ULONG iBitmapFormat; // BMF_8BPP or BMF_16BPP or BMF_32BPP
// (our current colour depth)
LONG iBoard; // Logical multi-board identifier
// (zero by default)
// Important data for accessing the frame buffer.
VOID* pvBankData; // Points to aulBankData[0]
FNBANKSELECTMODE* pfnBankSelectMode; // Routine to enable or disable
// direct frame buffer access
BANK_MODE bankmOnOverlapped; // BANK_ON or BANK_ON_NO_WAIT,
// depending on whether card
// can handle simulataneous
// frame buffer and accelerator
// access
// -------------------------------------------------------------------
// NOTE: Changes up to here in the PDEV structure must be reflected in
// i386\strucs.inc (assuming you're on an x86, of course)!
ASIC iAsic; // Specific Mach ASIC type
APERTURE iAperture; // Aperture type
ULONG ulTearOffset; // For uneven scans in 1152 or 1280 in 24bpp, and 1600 in 16bpp (mach64 only)
ULONG ulVramOffset; // ulTearOffset / 8
ULONG ulScreenOffsetAndPitch; // Screen offset and pitch for primary
// display
ULONG ulMonoPixelWidth; // Default value of DP_PIX_WID register
ULONG SetGuiEngineDefault; // new feature for Rage II+ and above
CAPS flCaps; // Capabilities flags
BOOL bEnabled; // In graphics mode (not full-screen)
HANDLE hDriver; // Handle to \Device\Screen
HDEV hdevEng; // Engine's handle to PDEV
HSURF hsurfScreen; // Engine's handle to screen surface
DSURF* pdsurfScreen; // Our private DSURF for the screen
HSURF hsurfPunt; // Just for 24bpp mach32 with linear aperture
LONG cxScreen; // Visible screen width
LONG cyScreen; // Visible screen height
LONG cxMemory; // Width of Video RAM
LONG cyMemory; // Height of Video RAM
LONG cBitsPerPel; // Bits per pel (8, 15, 16, 24 or 32)
ULONG ulMode; // Mode the mini-port driver is in.
FLONG flHooks; // What we're hooking from GDI
ULONG ulWhite; // 0xff if 8bpp, 0xffff if 16bpp,
// 0xffffffff if 32bpp
VOID* pvTmpBuffer; // General purpose temporary buffer,
// TMP_BUFFER_SIZE bytes in size
// (Remember to synchronize if you
// use this for device bitmaps or
// async pointers)
MACHTYPE iMachType; // Type of I/O to do based on Mach type
ULONG FeatureFlags; // ENH_VERSION_NT FeatureFlags
ATI_MODE_INFO *pModeInfo; // ATI-specific mode information (see ATINT.H)
////////// Context stuff
BYTE *pjContextBase; ULONG ulContextCeiling; // Keep track of available contexts
ULONG iDefContext; // Used to initialize graphics operations
////////// Low-level blt function pointers:
FNFILL* pfnFillSolid; FNFILL* pfnFillPatColor; FNFILL* pfnFillPatMonochrome; FNXFER* pfnXfer1bpp; FNXFER* pfnXfer4bpp; FNXFER* pfnXfer8bpp; FNXFER* pfnXferNative; FNCOPY* pfnCopyBlt; FNTEXTOUT* pfnTextOut; FNLINETOTRIVIAL* pfnLineToTrivial;
FNXFERBITS* pfnGetBits; FNXFERBITS* pfnPutBits;
////////// Palette stuff:
PALETTEENTRY* pPal; // The palette if palette managed
HPALETTE hpalDefault; // GDI handle to the default palette.
FLONG flRed; // Red mask for 16/32bpp bitfields
FLONG flGreen; // Green mask for 16/32bpp bitfields
FLONG flBlue; // Blue mask for 16/32bpp bitfields
ULONG cPaletteShift; // number of bits the 8-8-8 palette must
// be shifted by to fit in the hardware
// palette.
////////// Heap stuff:
HEAP heap; // All our off-screen heap data
ULONG iHeapUniq; // Incremented every time room is freed
// in the off-screen heap
SURFOBJ* psoPunt; // Wrapper surface for having GDI draw
// on off-screen bitmaps
SURFOBJ* psoPunt2; // Another one for off-screen to off-
// screen blts
OH* pohScreen; // Off-screen heap structure for the
// visible screen
////////// Banking stuff:
LONG cjBank; // Size of a bank, in bytes
LONG cPower2ScansPerBank; // Used by 'bBankComputePower2'
LONG cPower2BankSizeInBytes; // Used by 'bBankComputePower2'
CLIPOBJ* pcoBank; // Clip object for banked call backs
SURFOBJ* psoBank; // Surface object for banked call backs
ULONG aulBankData[BANK_DATA_SIZE / 4]; // Private work area for downloaded
// miniport banking code
FNBANKMAP* pfnBankMap; FNBANKCOMPUTE* pfnBankCompute;
////////// Pointer stuff:
CUROBJ pointer1; // pointer double-buffering
CUROBJ pointer2; // pointer double-buffering
CUROBJ *ppointer; BOOL bAltPtrActive;
FNSETCURSOROFFSET* pfnSetCursorOffset; FNUPDATECURSOROFFSET* pfnUpdateCursorOffset; FNUPDATECURSORPOSITION* pfnUpdateCursorPosition; FNCURSOROFF* pfnCursorOff; FNCURSORON* pfnCursorOn; FNPOINTERBLIT* pfnPointerBlit;
////////// Brush stuff:
LONG iBrushCache; // Index for next brush to be allcoated
BRUSHENTRY abe[TOTAL_BRUSH_COUNT]; // Keeps track of off-screen brush
// cache
////////// Text stuff:
SURFOBJ* psoText; // 1bpp surface to which we will have
// GDI draw our glyphs for us
////////// Stretch stuff:
FN_STRETCHDIB* pfnStretchDIB;
BYTE* pjMmBase_Ext; // Start of memory mapped I/O
////////// Palindrome stuff:
#if PAL_SUPPORT
//structure specific for pal support
PPDEV_PAL_NT pal_str;#endif // PALINDROME_SUPPORT
////////// Palindrome and Overlay common stuff:
DWORD semph_overlay; // this semaphore is used for allocating the overlay resource:
// = 0 ; resource free
// = 1 ; in use by DDraw
// = 2 ; in use by Palindrome
#if TARGET_BUILD > 351
////////// DirectDraw stuff:
BOOL bPassVBlank; // flag used for detecting the VBlank hang on GX cards on high speed multiprocessors machines
FLIPRECORD flipRecord; // Used to track VBlank status
OH* pohDirectDraw; // Off-screen heap allocation for use
// by DirectDraw
// STUFF FOR OVERLAY SUPPORT
// this must be in ppdev
OVERLAYINFO16 OverlayInfo16; // the following variables maybe should be in ppdev
DWORD OverlayWidth,OverlayHeight; //the last updated overlay's width and height
DWORD OverlayScalingDown;
FLATPTR fpVisibleOverlay; // Frame buffer offset to currently
// visible overlay; will be zero if
// no overlay is visible
DWORD dwOverlayFlipOffset; // Overlay flip offset
// END STUFF FOR OVERLAY SUPP
#endif
} PDEV;
/////////////////////////////////////////////////////////////////////////
// Miscellaneous prototypes:
BOOL bIntersect(RECTL*, RECTL*, RECTL*);LONG cIntersect(RECTL*, RECTL*, LONG);DWORD getAvailableModes(HANDLE, PVIDEO_MODE_INFORMATION*, DWORD*);
BOOL bInitializeModeFields(PDEV*, GDIINFO*, DEVINFO*, DEVMODEW*);BOOL bFastFill(PDEV*, LONG, POINTFIX*, ULONG, ULONG, RBRUSH*, POINTL*, RECTL*);
BOOL bEnableHardware(PDEV*);VOID vDisableHardware(PDEV*);BOOL bAssertModeHardware(PDEV*, BOOL);
extern BYTE gaRop3FromMix[];extern ULONG gaul32HwMixFromMix[];extern ULONG gaul64HwMixFromMix[];extern ULONG gaul32HwMixFromRop2[];extern ULONG gaul64HwMixFromRop2[];
/////////////////////////////////////////////////////////////////////////
// The x86 C compiler insists on making a divide and modulus operation
// into two DIVs, when it can in fact be done in one. So we use this
// macro.
//
// Note: QUOTIENT_REMAINDER implicitly takes unsigned arguments.
#if defined(_X86_)
#define QUOTIENT_REMAINDER(ulNumerator, ulDenominator, ulQuotient, ulRemainder) \
{ \ __asm mov eax, ulNumerator \ __asm sub edx, edx \ __asm div ulDenominator \ __asm mov ulQuotient, eax \ __asm mov ulRemainder, edx \}
#else
#define QUOTIENT_REMAINDER(ulNumerator, ulDenominator, ulQuotient, ulRemainder) \
{ \ ulQuotient = (ULONG) ulNumerator / (ULONG) ulDenominator; \ ulRemainder = (ULONG) ulNumerator % (ULONG) ulDenominator; \}
#endif
/////////////////////////////////////////////////////////////////////////
// OVERLAP - Returns TRUE if the same-size lower-right exclusive
// rectangles defined by 'pptl' and 'prcl' overlap:
#define OVERLAP(prcl, pptl) \
(((prcl)->right > (pptl)->x) && \ ((prcl)->bottom > (pptl)->y) && \ ((prcl)->left < ((pptl)->x + (prcl)->right - (prcl)->left)) && \ ((prcl)->top < ((pptl)->y + (prcl)->bottom - (prcl)->top)))
/////////////////////////////////////////////////////////////////////////
// SWAP - Swaps the value of two variables, using a temporary variable
#define SWAP(a, b, tmp) { (tmp) = (a); (a) = (b); (b) = (tmp); }
//////////////////////////////////////////////////////////////////////
// These Mul prototypes are thunks for multi-board support:
ULONG MulGetModes(HANDLE, ULONG, DEVMODEW*);DHPDEV MulEnablePDEV(DEVMODEW*, PWSTR, ULONG, HSURF*, ULONG, ULONG*, ULONG, DEVINFO*, HDEV, PWSTR, HANDLE);VOID MulCompletePDEV(DHPDEV, HDEV);HSURF MulEnableSurface(DHPDEV);BOOL MulStrokePath(SURFOBJ*, PATHOBJ*, CLIPOBJ*, XFORMOBJ*, BRUSHOBJ*, POINTL*, LINEATTRS*, MIX);BOOL MulFillPath(SURFOBJ*, PATHOBJ*, CLIPOBJ*, BRUSHOBJ*, POINTL*, MIX, FLONG);BOOL MulBitBlt(SURFOBJ*, SURFOBJ*, SURFOBJ*, CLIPOBJ*, XLATEOBJ*, RECTL*, POINTL*, POINTL*, BRUSHOBJ*, POINTL*, ROP4);VOID MulDisablePDEV(DHPDEV);VOID MulDisableSurface(DHPDEV);BOOL MulAssertMode(DHPDEV, BOOL);VOID MulMovePointer(SURFOBJ*, LONG, LONG, RECTL*);ULONG MulSetPointerShape(SURFOBJ*, SURFOBJ*, SURFOBJ*, XLATEOBJ*, LONG, LONG, LONG, LONG, RECTL*, FLONG);ULONG MulDitherColor(DHPDEV, ULONG, ULONG, ULONG*);BOOL MulSetPalette(DHPDEV, PALOBJ*, FLONG, ULONG, ULONG);BOOL MulCopyBits(SURFOBJ*, SURFOBJ*, CLIPOBJ*, XLATEOBJ*, RECTL*, POINTL*);BOOL MulTextOut(SURFOBJ*, STROBJ*, FONTOBJ*, CLIPOBJ*, RECTL*, RECTL*, BRUSHOBJ*, BRUSHOBJ*, POINTL*, MIX);VOID MulDestroyFont(FONTOBJ*);BOOL MulPaint(SURFOBJ*, CLIPOBJ*, BRUSHOBJ*, POINTL*, MIX);BOOL MulRealizeBrush(BRUSHOBJ*, SURFOBJ*, SURFOBJ*, SURFOBJ*, XLATEOBJ*, ULONG);HBITMAP MulCreateDeviceBitmap(DHPDEV, SIZEL, ULONG);VOID MulDeleteDeviceBitmap(DHSURF);BOOL MulStretchBlt(SURFOBJ*, SURFOBJ*, SURFOBJ*, CLIPOBJ*, XLATEOBJ*, COLORADJUSTMENT*, POINTL*, RECTL*, RECTL*, POINTL*, ULONG);
// These Dbg prototypes are thunks for debugging:
VOID DbgDisableDriver(VOID);ULONG DbgGetModes(HANDLE, ULONG, DEVMODEW*);DHPDEV DbgEnablePDEV(DEVMODEW*, PWSTR, ULONG, HSURF*, ULONG, ULONG*, ULONG, DEVINFO*, HDEV, PWSTR, HANDLE);VOID DbgCompletePDEV(DHPDEV, HDEV);HSURF DbgEnableSurface(DHPDEV);BOOL DbgLineTo(SURFOBJ*, CLIPOBJ*, BRUSHOBJ*, LONG, LONG, LONG, LONG, RECTL*, MIX);BOOL DbgStrokePath(SURFOBJ*, PATHOBJ*, CLIPOBJ*, XFORMOBJ*, BRUSHOBJ*, POINTL*, LINEATTRS*, MIX);BOOL DbgFillPath(SURFOBJ*, PATHOBJ*, CLIPOBJ*, BRUSHOBJ*, POINTL*, MIX, FLONG);BOOL DbgBitBlt(SURFOBJ*, SURFOBJ*, SURFOBJ*, CLIPOBJ*, XLATEOBJ*, RECTL*, POINTL*, POINTL*, BRUSHOBJ*, POINTL*, ROP4);VOID DbgDisablePDEV(DHPDEV);VOID DbgDisableSurface(DHPDEV);#if TARGET_BUILD > 351
BOOL DbgAssertMode(DHPDEV, BOOL);#else
VOID DbgAssertMode(DHPDEV, BOOL);#endif
VOID DbgMovePointer(SURFOBJ*, LONG, LONG, RECTL*);ULONG DbgSetPointerShape(SURFOBJ*, SURFOBJ*, SURFOBJ*, XLATEOBJ*, LONG, LONG, LONG, LONG, RECTL*, FLONG);ULONG DbgDitherColor(DHPDEV, ULONG, ULONG, ULONG*);BOOL DbgSetPalette(DHPDEV, PALOBJ*, FLONG, ULONG, ULONG);BOOL DbgCopyBits(SURFOBJ*, SURFOBJ*, CLIPOBJ*, XLATEOBJ*, RECTL*, POINTL*);BOOL DbgTextOut(SURFOBJ*, STROBJ*, FONTOBJ*, CLIPOBJ*, RECTL*, RECTL*, BRUSHOBJ*, BRUSHOBJ*, POINTL*, MIX);VOID DbgDestroyFont(FONTOBJ*);BOOL DbgPaint(SURFOBJ*, CLIPOBJ*, BRUSHOBJ*, POINTL*, MIX);BOOL DbgRealizeBrush(BRUSHOBJ*, SURFOBJ*, SURFOBJ*, SURFOBJ*, XLATEOBJ*, ULONG);HBITMAP DbgCreateDeviceBitmap(DHPDEV, SIZEL, ULONG);VOID DbgDeleteDeviceBitmap(DHSURF);BOOL DbgStretchBlt(SURFOBJ*, SURFOBJ*, SURFOBJ*, CLIPOBJ*, XLATEOBJ*, COLORADJUSTMENT*, POINTL*, RECTL*, RECTL*, POINTL*, ULONG);ULONG DbgEscape(SURFOBJ*, ULONG, ULONG, VOID*, ULONG, VOID*);
|
