driver.h File Reference

#include "stddef.h"
#include <stdarg.h>
#include "windef.h"
#include "wingdi.h"
#include "winddi.h"
#include "devioctl.h"
#include "ntddvdeo.h"
#include "debug.h"

Include dependency graph for driver.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_PDEV

Macros
#define	MAX_CLUT_SIZE   (sizeof(VIDEO_CLUT) + (sizeof(ULONG) * 256))
#define	DRIVER_EXTRA_SIZE   0
#define	DLL_NAME   L"vga"
#define	STANDARD_DEBUG_PREFIX   "Vga risc: "
#define	ALLOC_TAG   'rgvD'
#define	VAL(data, px, pl, pos)   ((data) >> (((px) * 4) + (pl)) & 1) << (pos)
#define	SET_PLANE_DATA(x, y, a, b)    (x) |= VAL(y, (((-1 + ((((b) % 8) % 2) << 1) - (((b) % 8) + 1) + 8))), a, b)
#define	ALIGN_DOWN_BY(size, align)    ((ULONG_PTR)(size) & ~((ULONG_PTR)(align) - 1))
#define	ALIGN_UP_BY(size, align)    (ALIGN_DOWN_BY(((ULONG_PTR)(size) + align - 1), align))

Typedefs
typedef struct _PDEV	PDEV
typedef struct _PDEV *	PPDEV

Functions
DWORD	getAvailableModes (HANDLE, PVIDEO_MODE_INFORMATION *, DWORD *)
BOOL	bInitPDEV (PPDEV, PDEVMODEW, GDIINFO *, DEVINFO *)
BOOL	bInitSURF (PPDEV, BOOL)
BOOL	bInitPaletteInfo (PPDEV, DEVINFO *)
BOOL	bInitPointer (PPDEV, DEVINFO *)
BOOL	bInit256ColorPalette (PPDEV)
VOID	vDisablePalette (PPDEV)
VOID	vDisableSURF (PPDEV)

Macro Definition Documentation

ALIGN_DOWN_BY

#define ALIGN_DOWN_BY	(		size,
			align
	)		((ULONG_PTR)(size) & ~((ULONG_PTR)(align) - 1))

Definition at line 101 of file driver.h.

ALIGN_UP_BY

#define ALIGN_UP_BY	(		size,
			align
	)		(ALIGN_DOWN_BY(((ULONG_PTR)(size) + align - 1), align))

Definition at line 104 of file driver.h.

ALLOC_TAG

#define ALLOC_TAG   'rgvD'

Definition at line 78 of file driver.h.

DLL_NAME

#define DLL_NAME   L"vga"

Definition at line 76 of file driver.h.

DRIVER_EXTRA_SIZE

#define DRIVER_EXTRA_SIZE   0

Definition at line 73 of file driver.h.

MAX_CLUT_SIZE

#define MAX_CLUT_SIZE   (sizeof(VIDEO_CLUT) + (sizeof(ULONG) * 256))

Definition at line 66 of file driver.h.

SET_PLANE_DATA

#define SET_PLANE_DATA	(		x,
			y,
			a,
			b
	)		(x) |= VAL(y, (((-1 + ((((b) % 8) % 2) << 1) - (((b) % 8) + 1) + 8))), a, b)

Definition at line 97 of file driver.h.

STANDARD_DEBUG_PREFIX

#define STANDARD_DEBUG_PREFIX   "Vga risc: "

Definition at line 77 of file driver.h.

VAL

#define VAL	(		data,
			px,
			pl,
			pos
	)		((data) >> (((px) * 4) + (pl)) & 1) << (pos)

Definition at line 91 of file driver.h.

Typedef Documentation

PDEV

typedef struct _PDEV PDEV

PPDEV

typedef struct _PDEV * PPDEV

Function Documentation

bInit256ColorPalette()

BOOL bInit256ColorPalette

(

PPDEV

ppdev

)

Definition at line 226 of file palette.c.

{
    BYTE        ajClutSpace[MAX_CLUT_SIZE];
    PVIDEO_CLUT pScreenClut;
    ULONG       ulReturnedDataLength;
    ULONG       cColors;
    PVIDEO_CLUTDATA pScreenClutData;
 
    if (ppdev->ulBitCount == 8)
    {
        //
        // Fill in pScreenClut header info:
        //
 
        pScreenClut             = (PVIDEO_CLUT) ajClutSpace;
        pScreenClut->NumEntries = 256;
        pScreenClut->FirstEntry = 0;
 
        //
        // Copy colours in:
        //
 
        cColors = 256;
        pScreenClutData = (PVIDEO_CLUTDATA) (&(pScreenClut->LookupTable[0]));
 
        while(cColors--)
        {
            pScreenClutData[cColors].Red =    ppdev->pPal[cColors].peRed >>
                                              ppdev->cPaletteShift;
            pScreenClutData[cColors].Green =  ppdev->pPal[cColors].peGreen >>
                                              ppdev->cPaletteShift;
            pScreenClutData[cColors].Blue =   ppdev->pPal[cColors].peBlue >>
                                              ppdev->cPaletteShift;
            pScreenClutData[cColors].Unused = 0;
        }
 
        //
        // Set palette registers:
        //
 
        if (EngDeviceIoControl(ppdev->hDriver,
                               IOCTL_VIDEO_SET_COLOR_REGISTERS,
                               pScreenClut,
                               MAX_CLUT_SIZE,
                               NULL,
                               0,
                               &ulReturnedDataLength))
        {
            DISPDBG((0, "Failed bEnablePalette"));
            return(FALSE);
        }
    }
 
    DISPDBG((5, "Passed bEnablePalette"));
 
    return(TRUE);
}

Referenced by DrvEnableSurface().

bInitPaletteInfo()

BOOL bInitPaletteInfo	(	PPDEV	ppdev,
		DEVINFO *	pDevInfo
	)

Definition at line 67 of file palette.c.

{
    if (!bInitDefaultPalette(ppdev, pDevInfo))
        return(FALSE);
 
    return(TRUE);
}

Referenced by DrvEnablePDEV().

bInitPDEV()

BOOL bInitPDEV	(	PPDEV	,
		PDEVMODEW	,
		GDIINFO *	,
		DEVINFO *
	)

Referenced by DrvEnablePDEV().

bInitPointer()

BOOL bInitPointer	(	PPDEV	,
		DEVINFO *
	)

Referenced by DrvEnablePDEV().

bInitSURF()

BOOL bInitSURF	(	PPDEV	ppdev,
		BOOL	bFirst
	)

Definition at line 168 of file screen.c.

{
    DWORD returnedDataLength;
    DWORD MaxWidth, MaxHeight;
    VIDEO_MEMORY videoMemory;
    VIDEO_MEMORY_INFORMATION videoMemoryInformation;
// eVb: 2.1 [DDK Change] - Support new VGA Miniport behavior w.r.t updated framebuffer remapping
    ULONG RemappingNeeded = 0;  
// eVb: 2.1 [END]
    //
    // Set the current mode into the hardware.
    //
 
    if (EngDeviceIoControl(ppdev->hDriver,
                           IOCTL_VIDEO_SET_CURRENT_MODE,
                           &(ppdev->ulMode),
                           sizeof(ULONG),
// eVb: 2.2 [DDK Change] - Support new VGA Miniport behavior w.r.t updated framebuffer remapping
                           &RemappingNeeded,
                           sizeof(ULONG),
// eVb: 2.2 [END]
                           &returnedDataLength))
    {
        RIP("DISP bInitSURF failed IOCTL_SET_MODE\n");
        return(FALSE);
    }
 
    //
    // If this is the first time we enable the surface we need to map in the
    // memory also.
    //
// eVb: 2.3 [DDK Change] - Support new VGA Miniport behavior w.r.t updated framebuffer remapping
    if (bFirst || RemappingNeeded)
    {
// eVb: 2.3 [END]
        videoMemory.RequestedVirtualAddress = NULL;
 
        if (EngDeviceIoControl(ppdev->hDriver,
                               IOCTL_VIDEO_MAP_VIDEO_MEMORY,
                               &videoMemory,
                               sizeof(VIDEO_MEMORY),
                               &videoMemoryInformation,
                               sizeof(VIDEO_MEMORY_INFORMATION),
                               &returnedDataLength))
        {
            RIP("DISP bInitSURF failed IOCTL_VIDEO_MAP\n");
            return(FALSE);
        }
 
        ppdev->pjScreen = (PBYTE)(videoMemoryInformation.FrameBufferBase);
 
        if (videoMemoryInformation.FrameBufferBase !=
            videoMemoryInformation.VideoRamBase)
        {
            RIP("VideoRamBase does not correspond to FrameBufferBase\n");
        }
// eVb: 2.4 [DDK Change] - Make sure frame buffer mapping worked
        //
        // Make sure we can access this video memory
        //
 
        *(PULONG)(ppdev->pjScreen) = 0xaa55aa55;
 
        if (*(PULONG)(ppdev->pjScreen) != 0xaa55aa55) {
 
            DISPDBG((1, "Frame buffer memory is not accessible.\n"));
            return(FALSE);
        }
// eVb: 2.4 [END]
        ppdev->cScreenSize = videoMemoryInformation.VideoRamLength;
 
        //
        // Initialize the head of the offscreen list to NULL.
        //
 
        ppdev->pOffscreenList = NULL;
 
        // It's a hardware pointer; set up pointer attributes.
 
        MaxHeight = ppdev->PointerCapabilities.MaxHeight;
 
        // Allocate space for two DIBs (data/mask) for the pointer. If this
        // device supports a color Pointer, we will allocate a larger bitmap.
        // If this is a color bitmap we allocate for the largest possible
        // bitmap because we have no idea of what the pixel depth might be.
 
        // Width rounded up to nearest byte multiple
 
        if (!(ppdev->PointerCapabilities.Flags & VIDEO_MODE_COLOR_POINTER))
        {
            MaxWidth = (ppdev->PointerCapabilities.MaxWidth + 7) / 8;
        }
        else
        {
            MaxWidth = ppdev->PointerCapabilities.MaxWidth * sizeof(DWORD);
        }
 
        ppdev->cjPointerAttributes =
                sizeof(VIDEO_POINTER_ATTRIBUTES) +
                ((sizeof(UCHAR) * MaxWidth * MaxHeight) * 2);
 
        ppdev->pPointerAttributes = (PVIDEO_POINTER_ATTRIBUTES)
                EngAllocMem(0, ppdev->cjPointerAttributes, ALLOC_TAG);
 
        if (ppdev->pPointerAttributes == NULL) {
 
            DISPDBG((0, "bInitPointer EngAllocMem failed\n"));
            return(FALSE);
        }
 
        ppdev->pPointerAttributes->Flags = ppdev->PointerCapabilities.Flags;
        ppdev->pPointerAttributes->WidthInBytes = MaxWidth;
        ppdev->pPointerAttributes->Width = ppdev->PointerCapabilities.MaxWidth;
        ppdev->pPointerAttributes->Height = MaxHeight;
        ppdev->pPointerAttributes->Column = 0;
        ppdev->pPointerAttributes->Row = 0;
        ppdev->pPointerAttributes->Enable = 0;
    }
 
    return(TRUE);
}

Referenced by DrvAssertMode(), and DrvEnableSurface().

getAvailableModes()

DWORD getAvailableModes	(	HANDLE	hDriver,
		PVIDEO_MODE_INFORMATION *	modeInformation,
		DWORD *	cbModeSize
	)

Definition at line 651 of file screen.c.

{
    ULONG ulTemp;
    VIDEO_NUM_MODES modes;
    PVIDEO_MODE_INFORMATION pVideoTemp;
 
    //
    // Get the number of modes supported by the mini-port
    //
 
    if (EngDeviceIoControl(hDriver,
                           IOCTL_VIDEO_QUERY_NUM_AVAIL_MODES,
                           NULL,
                           0,
                           &modes,
                           sizeof(VIDEO_NUM_MODES),
                           &ulTemp))
    {
        DISPDBG((0, "getAvailableModes failed VIDEO_QUERY_NUM_AVAIL_MODES\n"));
        return 0;
    }
 
    *cbModeSize = modes.ModeInformationLength;
 
    //
    // Allocate the buffer for the mini-port to write the modes in.
    //
 
    *modeInformation = (PVIDEO_MODE_INFORMATION)
                        EngAllocMem(0, modes.NumModes *
                                    modes.ModeInformationLength, ALLOC_TAG);
 
    if (*modeInformation == NULL)
    {
        DISPDBG((0, "getAvailableModes failed EngAllocMem\n"));
 
        return 0;
    }
 
    //
    // Ask the mini-port to fill in the available modes.
    //
 
    if (EngDeviceIoControl(hDriver,
                           IOCTL_VIDEO_QUERY_AVAIL_MODES,
                           NULL,
                           0,
                           *modeInformation,
                           modes.NumModes * modes.ModeInformationLength,
                           &ulTemp))
    {
 
        DISPDBG((0, "getAvailableModes failed VIDEO_QUERY_AVAIL_MODES\n"));
 
        EngFreeMem(*modeInformation);
        *modeInformation = 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;
 
// eVb: 2.5 [VGARISC CHANGE] - Add correct mode checks for VGA
    //
    // Mode is rejected if it is not 4 planes, or not graphics, or is not
    // one of 1 bits per pel.
    //
 
    while (ulTemp--)
    {
        if ((pVideoTemp->NumberOfPlanes != 4 ) ||
            !(pVideoTemp->AttributeFlags & VIDEO_MODE_GRAPHICS) ||
            ((pVideoTemp->BitsPerPlane != 1) ||
             (pVideoTemp->VisScreenWidth > 800)))
// eVb: 2.5 [END]
        {
            pVideoTemp->Length = 0;
        }
 
        pVideoTemp = (PVIDEO_MODE_INFORMATION)
            (((PUCHAR)pVideoTemp) + modes.ModeInformationLength);
    }
 
    return modes.NumModes;
 
}

vDisablePalette()

VOID vDisablePalette

(

PPDEV

ppdev

)

Definition at line 82 of file palette.c.

{
// Delete the default palette if we created one.
 
    if (ppdev->hpalDefault)
    {
        EngDeletePalette(ppdev->hpalDefault);
        ppdev->hpalDefault = NULL;
    }
 
// eVb: 4.2 [VGARISC Change] - VGA Palette is static, no need to free
#if 0
    if (ppdev->pPal != NULL)
        EngFreeMem((PVOID)ppdev->pPal);
#endif
// eVb: 4.2 [END]
}

Referenced by DrvDisablePDEV().

vDisableSURF()

VOID vDisableSURF

(

PPDEV

ppdev

)

Definition at line 297 of file screen.c.

{
    DWORD returnedDataLength;
    VIDEO_MEMORY videoMemory;
 
    videoMemory.RequestedVirtualAddress = (PVOID) ppdev->pjScreen;
 
    if (EngDeviceIoControl(ppdev->hDriver,
                           IOCTL_VIDEO_UNMAP_VIDEO_MEMORY,
                           &videoMemory,
                           sizeof(VIDEO_MEMORY),
                           NULL,
                           0,
                           &returnedDataLength))
    {
        RIP("DISP vDisableSURF failed IOCTL_VIDEO_UNMAP\n");
    }
}

Referenced by DrvDisableSurface().