enable.c File Reference

#include "driver.h"

Include dependency graph for enable.c:

Go to the source code of this file.

Macros
#define	HOOKS_BMF8BPP   0
#define	HOOKS_BMF16BPP   0
#define	HOOKS_BMF24BPP   0
#define	HOOKS_BMF32BPP   0

Functions
BOOL NTAPI	DrvEnableDriver (ULONG iEngineVersion, ULONG cj, PDRVENABLEDATA pded)
DHPDEV NTAPI	DrvEnablePDEV (DEVMODEW *pDevmode, PWSTR pwszLogAddress, ULONG cPatterns, HSURF *ahsurfPatterns, ULONG cjGdiInfo, ULONG *pGdiInfo, ULONG cjDevInfo, DEVINFO *pDevInfo, HDEV hdev, PWSTR pwszDeviceName, HANDLE hDriver)
VOID NTAPI	DrvCompletePDEV (DHPDEV dhpdev, HDEV hdev)
VOID NTAPI	DrvDisablePDEV (DHPDEV dhpdev)
HSURF NTAPI	DrvEnableSurface (DHPDEV dhpdev)
VOID NTAPI	DrvDisableSurface (DHPDEV dhpdev)
BOOL NTAPI	DrvAssertMode (DHPDEV dhpdev, BOOL bEnable)
ULONG NTAPI	DrvGetModes (HANDLE hDriver, ULONG cjSize, DEVMODEW *pdm)

Variables
static DRVFN	gadrvfn []

Macro Definition Documentation

HOOKS_BMF16BPP

#define HOOKS_BMF16BPP   0

Definition at line 32 of file enable.c.

HOOKS_BMF24BPP

#define HOOKS_BMF24BPP   0

Definition at line 34 of file enable.c.

HOOKS_BMF32BPP

#define HOOKS_BMF32BPP   0

Definition at line 36 of file enable.c.

HOOKS_BMF8BPP

#define HOOKS_BMF8BPP   0

Definition at line 30 of file enable.c.

Function Documentation

DrvAssertMode()

BOOL NTAPI DrvAssertMode	(	DHPDEV	dhpdev,
		BOOL	bEnable
	)

Definition at line 302 of file enable.c.

{
    PPDEV   ppdev = (PPDEV) dhpdev;
    ULONG   ulReturn;
    PBYTE   pjScreen;

    if (bEnable)
    {
        //
        // The screen must be reenabled, reinitialize the device to clean state.
        //
// eVb: 1.6 [DDK Change] - Support new VGA Miniport behavior w.r.t updated framebuffer remapping
        pjScreen = ppdev->pjScreen;

        if (!bInitSURF(ppdev, FALSE))
        {
            DISPDBG((0, "DISP DrvAssertMode failed bInitSURF\n"));
            return FALSE;
        }

        if (pjScreen != ppdev->pjScreen) {

            if ( !EngModifySurface(ppdev->hsurfEng,
                                   ppdev->hdevEng,
                                   ppdev->flHooks | HOOK_SYNCHRONIZE,
                                   MS_NOTSYSTEMMEMORY,
                                   (DHSURF)ppdev,
                                   ppdev->pjScreen,
                                   ppdev->lDeltaScreen,
                                   NULL))
            {
                DISPDBG((0, "DISP DrvAssertMode failed EngModifySurface\n"));
                return FALSE;
            }
        }
// eVb: 1.6 [END]
        return TRUE;
    }
    else
    {
        //
        // We must give up the display.
        // Call the kernel driver to reset the device to a known state.
        //

        if (EngDeviceIoControl(ppdev->hDriver,
                               IOCTL_VIDEO_RESET_DEVICE,
                               NULL,
                               0,
                               NULL,
                               0,
                               &ulReturn))
        {
            RIP("DISP DrvAssertMode failed IOCTL");
            return FALSE;
        }
        else
        {
            return TRUE;
        }
    }
}

DrvCompletePDEV()

VOID NTAPI DrvCompletePDEV	(	DHPDEV	dhpdev,
		HDEV	hdev
	)

Definition at line 169 of file enable.c.

{
    ((PPDEV) dhpdev)->hdevEng = hdev;
}

DrvDisablePDEV()

VOID NTAPI DrvDisablePDEV

(

DHPDEV

dhpdev

)

Definition at line 184 of file enable.c.

{
    vDisablePalette((PPDEV) dhpdev);
    EngFreeMem(dhpdev);
}

DrvDisableSurface()

VOID NTAPI DrvDisableSurface

(

DHPDEV

dhpdev

)

Definition at line 287 of file enable.c.

{
    EngDeleteSurface(((PPDEV) dhpdev)->hsurfEng);
    vDisableSURF((PPDEV) dhpdev);
    ((PPDEV) dhpdev)->hsurfEng = NULL;
}

DrvEnableDriver()

BOOL NTAPI DrvEnableDriver	(	ULONG	iEngineVersion,
		ULONG	cj,
		PDRVENABLEDATA	pded
	)

Definition at line 45 of file enable.c.

{
// Engine Version is passed down so future drivers can support previous
// engine versions.  A next generation driver can support both the old
// and new engine conventions if told what version of engine it is
// working with.  For the first version the driver does nothing with it.
// eVb: 1.1 [DDK Change] - Remove bogus statement
    //iEngineVersion;
// eVb: 1.1 [END]
// Fill in as much as we can.

    if (cj >= sizeof(DRVENABLEDATA))
        pded->pdrvfn = gadrvfn;

    if (cj >= (sizeof(ULONG) * 2))
        pded->c = sizeof(gadrvfn) / sizeof(DRVFN);

// DDI version this driver was targeted for is passed back to engine.
// Future graphic's engine may break calls down to old driver format.

    if (cj >= sizeof(ULONG))
// eVb: 1.2 [DDK Change] - Use DDI_DRIVER_VERSION_NT4 instead of DDI_DRIVER_VERSION
        pded->iDriverVersion = DDI_DRIVER_VERSION_NT4;
// eVb: 1.2 [END]

    return TRUE;
}

DrvEnablePDEV()

DHPDEV NTAPI DrvEnablePDEV	(	DEVMODEW *	pDevmode,
		PWSTR	pwszLogAddress,
		ULONG	cPatterns,
		HSURF *	ahsurfPatterns,
		ULONG	cjGdiInfo,
		ULONG *	pGdiInfo,
		ULONG	cjDevInfo,
		DEVINFO *	pDevInfo,
		HDEV	hdev,
		PWSTR	pwszDeviceName,
		HANDLE	hDriver
	)

Definition at line 85 of file enable.c.

{
    GDIINFO GdiInfo;
    DEVINFO DevInfo;
    PPDEV   ppdev = NULL;

    UNREFERENCED_PARAMETER(pwszLogAddress);
    UNREFERENCED_PARAMETER(pwszDeviceName);

    // Allocate a physical device structure.

    ppdev = (PPDEV) EngAllocMem(0, sizeof(PDEV), ALLOC_TAG);

    if (ppdev == NULL)
    {
        RIP("DISP DrvEnablePDEV failed EngAllocMem\n");
        return NULL;
    }

    memset(ppdev, 0, sizeof(PDEV));

    // Save the screen handle in the PDEV.

    ppdev->hDriver = hDriver;

    // Get the current screen mode information.  Set up device caps and devinfo.

    if (!bInitPDEV(ppdev, pDevmode, &GdiInfo, &DevInfo))
    {
        DISPDBG((0,"DISP DrvEnablePDEV failed\n"));
        goto error_free;
    }

    // Initialize the cursor information.

    if (!bInitPointer(ppdev, &DevInfo))
    {
        // Not a fatal error...
        DISPDBG((0, "DrvEnablePDEV failed bInitPointer\n"));
    }

    // Initialize palette information.

    if (!bInitPaletteInfo(ppdev, &DevInfo))
    {
        RIP("DrvEnablePDEV failed bInitPalette\n");
        goto error_free;
    }

    // Copy the devinfo into the engine buffer.

    memcpy(pDevInfo, &DevInfo, min(sizeof(DEVINFO), cjDevInfo));

    // Set the pdevCaps with GdiInfo we have prepared to the list of caps for this
    // pdev.

    memcpy(pGdiInfo, &GdiInfo, min(cjGdiInfo, sizeof(GDIINFO)));

    return (DHPDEV)ppdev;

    // Error case for failure.
error_free:
    EngFreeMem(ppdev);
    return NULL;
}

DrvEnableSurface()

HSURF NTAPI DrvEnableSurface

(

DHPDEV

dhpdev

)

Definition at line 200 of file enable.c.

{
    PPDEV ppdev;
    HSURF hsurf;
    SIZEL sizl;
    ULONG ulBitmapType;
    FLONG flHooks;

    // Create engine bitmap around frame buffer.

    ppdev = (PPDEV) dhpdev;

    if (!bInitSURF(ppdev, TRUE))
    {
        RIP("DISP DrvEnableSurface failed bInitSURF\n");
        return NULL;
    }

    sizl.cx = ppdev->cxScreen;
    sizl.cy = ppdev->cyScreen;

    if (ppdev->ulBitCount == 8)
    {
        if (!bInit256ColorPalette(ppdev)) {
            RIP("DISP DrvEnableSurface failed to init the 8bpp palette\n");
            return NULL;
        }
        ulBitmapType = BMF_8BPP;
        flHooks = HOOKS_BMF8BPP;
    }
    else if (ppdev->ulBitCount == 16)
    {
        ulBitmapType = BMF_16BPP;
        flHooks = HOOKS_BMF16BPP;
    }
    else if (ppdev->ulBitCount == 24)
    {
        ulBitmapType = BMF_24BPP;
        flHooks = HOOKS_BMF24BPP;
    }
    else
    {
        ulBitmapType = BMF_32BPP;
        flHooks = HOOKS_BMF32BPP;
    }
// eVb: 1.3 [DDK Change] - Support new VGA Miniport behavior w.r.t updated framebuffer remapping
    ppdev->flHooks = flHooks;
// eVb: 1.3 [END]
// eVb: 1.4 [DDK Change] - Use EngCreateDeviceSurface instead of EngCreateBitmap
    hsurf = (HSURF)EngCreateDeviceSurface((DHSURF)ppdev, 
                                           sizl,
                                           ulBitmapType);

    if (hsurf == NULL)
    {
        RIP("DISP DrvEnableSurface failed EngCreateDeviceSurface\n");
        return NULL;
    }
// eVb: 1.4 [END]

// eVb: 1.5 [DDK Change] - Use EngModifySurface instead of EngAssociateSurface
    if ( !EngModifySurface(hsurf,
                           ppdev->hdevEng,
                           ppdev->flHooks | HOOK_SYNCHRONIZE,
                           MS_NOTSYSTEMMEMORY,
                           (DHSURF)ppdev,
                           ppdev->pjScreen,
                           ppdev->lDeltaScreen,
                           NULL))
    {
        RIP("DISP DrvEnableSurface failed EngModifySurface\n");
        return NULL;
    }
// eVb: 1.5 [END]
    ppdev->hsurfEng = hsurf;

    return hsurf;
}

DrvGetModes()

ULONG NTAPI DrvGetModes	(	HANDLE	hDriver,
		ULONG	cjSize,
		DEVMODEW *	pdm
	)

Definition at line 374 of file enable.c.

{

    DWORD cModes;
    DWORD cbOutputSize;
    PVIDEO_MODE_INFORMATION pVideoModeInformation, pVideoTemp;
    DWORD cOutputModes = cjSize / (sizeof(DEVMODEW) + DRIVER_EXTRA_SIZE);
    DWORD cbModeSize;

    DISPDBG((3, "DrvGetModes\n"));

    cModes = getAvailableModes(hDriver,
                               (PVIDEO_MODE_INFORMATION *) &pVideoModeInformation,
                               &cbModeSize);

    if (cModes == 0)
    {
        DISPDBG((0, "DrvGetModes failed to get mode information"));
        return 0;
    }

    if (pdm == NULL)
    {
        cbOutputSize = cModes * (sizeof(DEVMODEW) + DRIVER_EXTRA_SIZE);
    }
    else
    {
        //
        // Now copy the information for the supported modes back into the output
        // buffer
        //

        cbOutputSize = 0;

        pVideoTemp = pVideoModeInformation;

        do
        {
            if (pVideoTemp->Length != 0)
            {
                if (cOutputModes == 0)
                {
                    break;
                }

                //
                // Zero the entire structure to start off with.
                //

                memset(pdm, 0, sizeof(DEVMODEW));

                //
                // Set the name of the device to the name of the DLL.
                //

                memcpy(pdm->dmDeviceName, DLL_NAME, sizeof(DLL_NAME));

                pdm->dmSpecVersion      = DM_SPECVERSION;
                pdm->dmDriverVersion    = DM_SPECVERSION;
                pdm->dmSize             = sizeof(DEVMODEW);
                pdm->dmDriverExtra      = DRIVER_EXTRA_SIZE;

                pdm->dmBitsPerPel       = pVideoTemp->NumberOfPlanes *
                                          pVideoTemp->BitsPerPlane;
                pdm->dmPelsWidth        = pVideoTemp->VisScreenWidth;
                pdm->dmPelsHeight       = pVideoTemp->VisScreenHeight;
                pdm->dmDisplayFrequency = pVideoTemp->Frequency;
                pdm->dmDisplayFlags     = 0;

                pdm->dmFields           = DM_BITSPERPEL       |
                                          DM_PELSWIDTH        |
                                          DM_PELSHEIGHT       |
                                          DM_DISPLAYFREQUENCY |
                                          DM_DISPLAYFLAGS     ;

                //
                // Go to the next DEVMODE entry in the buffer.
                //

                cOutputModes--;

                pdm = (LPDEVMODEW) ( ((ULONG_PTR)pdm) + sizeof(DEVMODEW) +
                                                   DRIVER_EXTRA_SIZE);

                cbOutputSize += (sizeof(DEVMODEW) + DRIVER_EXTRA_SIZE);

            }

            pVideoTemp = (PVIDEO_MODE_INFORMATION)
                (((PUCHAR)pVideoTemp) + cbModeSize);

        } while (--cModes);
    }

    EngFreeMem(pVideoModeInformation);

    return cbOutputSize;

}

Variable Documentation

gadrvfn

DRVFN gadrvfn[]

static

Initial value:

=
{
    {   INDEX_DrvEnablePDEV,            (PFN) DrvEnablePDEV         },
    {   INDEX_DrvCompletePDEV,          (PFN) DrvCompletePDEV       },
    {   INDEX_DrvDisablePDEV,           (PFN) DrvDisablePDEV        },
    {   INDEX_DrvEnableSurface,         (PFN) DrvEnableSurface      },
    {   INDEX_DrvDisableSurface,        (PFN) DrvDisableSurface     },
    {   INDEX_DrvAssertMode,            (PFN) DrvAssertMode         },
    {   INDEX_DrvSetPalette,            (PFN) DrvSetPalette         },
    {   INDEX_DrvMovePointer,           (PFN) DrvMovePointer        },
    {   INDEX_DrvSetPointerShape,       (PFN) DrvSetPointerShape    },
    {   INDEX_DrvGetModes,              (PFN) DrvGetModes           }
}

Definition at line 14 of file enable.c.

Referenced by DrvEnableDriver().