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

)

Definition at line 193 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);
}

bInitPaletteInfo()

BOOL bInitPaletteInfo	(	PPDEV	,
		DEVINFO *
	)

Definition at line 50 of file palette.c.

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

    return(TRUE);
}

bInitPDEV()

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

bInitPointer()

BOOL bInitPointer	(	PPDEV	,
		DEVINFO *
	)

Definition at line 400 of file pointer.c.

{
    DWORD    returnedDataLength;

    ppdev->pPointerAttributes = NULL;
    ppdev->cjPointerAttributes = 0; // initialized in screen.c

    //
    // Ask the miniport whether it provides pointer support.
    //

    if (EngDeviceIoControl(ppdev->hDriver,
                           IOCTL_VIDEO_QUERY_POINTER_CAPABILITIES,
                           NULL,
                           0,
                           &ppdev->PointerCapabilities,
                           sizeof(ppdev->PointerCapabilities),
                           &returnedDataLength))
    {
         return(FALSE);
    }

    //
    // If neither mono nor color hardware pointer is supported, there's no
    // hardware pointer support and we're done.
    //

    if ((!(ppdev->PointerCapabilities.Flags & VIDEO_MODE_MONO_POINTER)) &&
        (!(ppdev->PointerCapabilities.Flags & VIDEO_MODE_COLOR_POINTER)))
    {
        return(TRUE);
    }

    //
    // Note: The buffer itself is allocated after we set the
    // mode. At that time we know the pixel depth and we can
    // allocate the correct size for the color pointer if supported.
    //

    //
    // Set the asynchronous support status (async means miniport is capable of
    // drawing the Pointer at any time, with no interference with any ongoing
    // drawing operation)
    //

    if (ppdev->PointerCapabilities.Flags & VIDEO_MODE_ASYNC_POINTER)
    {
       pdevinfo->flGraphicsCaps |= GCAPS_ASYNCMOVE;
    }
    else
    {
       pdevinfo->flGraphicsCaps &= ~GCAPS_ASYNCMOVE;
    }

    return(TRUE);
}

bInitSURF()

BOOL bInitSURF	(	PPDEV	,
		BOOL
	)

Definition at line 43 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);
}

getAvailableModes()

DWORD getAvailableModes	(	HANDLE	,
		PVIDEO_MODE_INFORMATION *	,
		DWORD *
	)

Definition at line 507 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;

    //
    // Mode is rejected if it is not one plane, or not graphics, or is not
    // one of 8, 16 or 32 bits per pel.
    //

    while (ulTemp--)
    {
        if ((pVideoTemp->NumberOfPlanes != 1 ) ||
            !(pVideoTemp->AttributeFlags & VIDEO_MODE_GRAPHICS) ||
// eVb: 2.6 [DDK CHANGE] - Do not process banked video modes
             (pVideoTemp->AttributeFlags & VIDEO_MODE_BANKED) ||
// eVb: 2.6 [END]
            ((pVideoTemp->BitsPerPlane != 8) &&
             (pVideoTemp->BitsPerPlane != 16) &&
             (pVideoTemp->BitsPerPlane != 24) &&
             (pVideoTemp->BitsPerPlane != 32)))
        {
            pVideoTemp->Length = 0;
        }

        pVideoTemp = (PVIDEO_MODE_INFORMATION)
            (((PUCHAR)pVideoTemp) + modes.ModeInformationLength);
    }

    return modes.NumModes;

}

Referenced by bInitPDEV().

vDisablePalette()

VOID vDisablePalette

(

PPDEV

)

Definition at line 65 of file palette.c.

{
// Delete the default palette if we created one.

    if (ppdev->hpalDefault)
    {
        EngDeletePalette(ppdev->hpalDefault);
        ppdev->hpalDefault = NULL;
    }

    if (ppdev->pPal != NULL)
        EngFreeMem((PVOID)ppdev->pPal);
}

vDisableSURF()

VOID vDisableSURF

(

PPDEV

)

Definition at line 172 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");
    }
}