driver.h File Reference

#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"framebuf"
#define	STANDARD_DEBUG_PREFIX   "FRAMEBUF: "
#define	ALLOC_TAG   'bfDD'

Typedefs
typedef struct _PDEV	PDEV
typedef struct _PDEV *	PPDEV

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

Macro Definition Documentation

ALLOC_TAG

#define ALLOC_TAG   'bfDD'

Definition at line 75 of file driver.h.

DLL_NAME

#define DLL_NAME   L"framebuf"

Definition at line 73 of file driver.h.

DRIVER_EXTRA_SIZE

#define DRIVER_EXTRA_SIZE   0

Definition at line 71 of file driver.h.

MAX_CLUT_SIZE

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

Definition at line 64 of file driver.h.

STANDARD_DEBUG_PREFIX

#define STANDARD_DEBUG_PREFIX   "FRAMEBUF: "

Definition at line 74 of file driver.h.

Typedef Documentation

PDEV

typedef struct _PDEV PDEV

PPDEV

typedef struct _PDEV * PPDEV

Function Documentation

bInit256ColorPalette()

BOOL NTAPI bInit256ColorPalette

(

PPDEV

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);
}

Referenced by DrvEnableSurface().

bInitPaletteInfo()

BOOL NTAPI bInitPaletteInfo	(	PPDEV	ppdev,
		DEVINFO *	pDevInfo
	)

Definition at line 50 of file palette.c.

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

Referenced by DrvEnablePDEV().

bInitPDEV()

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

Referenced by DrvEnablePDEV().

bInitPointer()

BOOL NTAPI bInitPointer	(	PPDEV	ppdev,
		DEVINFO *	pdevinfo
	)

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);
}

Referenced by DrvEnablePDEV().

bInitSURF()

BOOL NTAPI bInitSURF	(	PPDEV	ppdev,
		BOOL	bFirst
	)

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);
}

Referenced by DrvAssertMode(), and DrvEnableSurface().

getAvailableModes()

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

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 DrvGetModes().

vDisablePalette()

VOID NTAPI vDisablePalette

(

PPDEV

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);
}

Referenced by DrvDisablePDEV().

vDisableSURF()

VOID NTAPI vDisableSURF

(

PPDEV

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");
    }
}

Referenced by DrvDisableSurface().