vga.c File Reference

#include "vga.h"
#include <devioctl.h>

Include dependency graph for vga.c:

Go to the source code of this file.

Functions
VP_STATUS NTAPI	VgaFindAdapter (PVOID HwDeviceExtension, PVOID HwContext, PWSTR ArgumentString, PVIDEO_PORT_CONFIG_INFO ConfigInfo, PUCHAR Again)
BOOLEAN NTAPI	VgaInitialize (PVOID HwDeviceExtension)
BOOLEAN NTAPI	VgaStartIO (PVOID HwDeviceExtension, PVIDEO_REQUEST_PACKET RequestPacket)
VP_STATUS NTAPI	VgaQueryAvailableModes (PHW_DEVICE_EXTENSION HwDeviceExtension, PVIDEO_MODE_INFORMATION ModeInformation, ULONG ModeInformationSize, PULONG_PTR OutputSize)
VP_STATUS NTAPI	VgaQueryNumberOfAvailableModes (PHW_DEVICE_EXTENSION HwDeviceExtension, PVIDEO_NUM_MODES NumModes, ULONG NumModesSize, PULONG_PTR OutputSize)
VP_STATUS NTAPI	VgaQueryCurrentMode (PHW_DEVICE_EXTENSION HwDeviceExtension, PVIDEO_MODE_INFORMATION ModeInformation, ULONG ModeInformationSize, PULONG_PTR OutputSize)
VP_STATUS NTAPI	VgaSetMode (PHW_DEVICE_EXTENSION HwDeviceExtension, PVIDEO_MODE Mode, ULONG ModeSize, PULONG PhysPtrChange)
BOOLEAN NTAPI	VgaIsPresent (PHW_DEVICE_EXTENSION HwDeviceExtension)
VP_STATUS NTAPI	VgaInterpretCmdStream (PHW_DEVICE_EXTENSION HwDeviceExtension, PUSHORT pusCmdStream)
VP_STATUS NTAPI	VgaSetPaletteReg (PHW_DEVICE_EXTENSION HwDeviceExtension, PVIDEO_PALETTE_DATA PaletteBuffer, ULONG PaletteBufferSize)
VP_STATUS NTAPI	VgaSetColorLookup (PHW_DEVICE_EXTENSION HwDeviceExtension, PVIDEO_CLUT ClutBuffer, ULONG ClutBufferSize)
VP_STATUS NTAPI	GetDeviceDataCallback (PVOID HwDeviceExtension, PVOID Context, VIDEO_DEVICE_DATA_TYPE DeviceDataType, PVOID Identifier, ULONG IdentifierLength, PVOID ConfigurationData, ULONG ConfigurationDataLength, PVOID ComponentInformation, ULONG ComponentInformationLength)
VP_STATUS NTAPI	VgaAcquireResources (PHW_DEVICE_EXTENSION DeviceExtension)
ULONG NTAPI	DriverEntry (PVOID Context1, PVOID Context2)

Function Documentation

DriverEntry()

ULONG NTAPI DriverEntry	(	PVOID	Context1,
		PVOID	Context2
	)

Definition at line 153 of file vga.c.

{
 
    VIDEO_HW_INITIALIZATION_DATA hwInitData;
    ULONG status;
    ULONG initializationStatus = (ULONG) -1;
 
    //
    // Zero out structure.
    //
 
    VideoPortZeroMemory(&hwInitData, sizeof(VIDEO_HW_INITIALIZATION_DATA));
 
    //
    // Specify sizes of structure and extension.
    //
 
    hwInitData.HwInitDataSize = sizeof(VIDEO_HW_INITIALIZATION_DATA);
 
    //
    // Set entry points.
    //
 
    hwInitData.HwFindAdapter = VgaFindAdapter;
    hwInitData.HwInitialize = VgaInitialize;
    hwInitData.HwInterrupt = NULL;
    hwInitData.HwStartIO = VgaStartIO;
 
    //
    // Determine the size we require for the device extension.
    //
 
    hwInitData.HwDeviceExtensionSize = sizeof(HW_DEVICE_EXTENSION);
 
    //
    // Always start with parameters for device0 in this case.
    // We can leave it like this since we know we will only ever find one
    // VGA type adapter in a machine.
    //
 
    // hwInitData.StartingDeviceNumber = 0;
 
    //
    // Once all the relevant information has been stored, call the video
    // port driver to do the initialization.
    // For this device we will repeat this call three times, for ISA, EISA
    // and PCI.
    // We will return the minimum of all return values.
    //
 
    //
    // We will try the PCI bus first so that our ISA detection does'nt claim
    // PCI cards (since it is impossible to differentiate between the two
    // by looking at the registers).
    //
 
    //
    // NOTE: since this driver only supports one adapter, we will return
    // as soon as we find a device, without going on to the following buses.
    // Normally one would call for each bus type and return the smallest
    // value.
    //
 
#if !defined(_ALPHA_)
 
    //
    // Before we can enable this on ALPHA we need to find a way to map a
    // sparse view of a 4MB region successfully.
    //
 
    hwInitData.AdapterInterfaceType = PCIBus;
 
    initializationStatus = VideoPortInitialize(Context1,
                                               Context2,
                                               &hwInitData,
                                               NULL);
 
    if (initializationStatus == NO_ERROR)
    {
        return initializationStatus;
    }
 
#endif
 
    hwInitData.AdapterInterfaceType = MicroChannel;
 
    initializationStatus = VideoPortInitialize(Context1,
                                               Context2,
                                               &hwInitData,
                                               NULL);
 
    //
    // Return immediately instead of checkin for smallest return code.
    //
 
    if (initializationStatus == NO_ERROR)
    {
        return initializationStatus;
    }
 
 
    hwInitData.AdapterInterfaceType = Internal;
 
    initializationStatus = VideoPortInitialize(Context1,
                                               Context2,
                                               &hwInitData,
                                               NULL);
 
    if (initializationStatus == NO_ERROR)
    {
        return initializationStatus;
    }
 
 
    hwInitData.AdapterInterfaceType = Isa;
 
    initializationStatus = VideoPortInitialize(Context1,
                                               Context2,
                                               &hwInitData,
                                               NULL);
 
    if (initializationStatus == NO_ERROR)
    {
        return initializationStatus;
    }
 
 
 
    hwInitData.AdapterInterfaceType = Eisa;
 
    status = VideoPortInitialize(Context1,
                                 Context2,
                                 &hwInitData,
                                 NULL);
 
    if (initializationStatus > status) {
        initializationStatus = status;
    }
 
    return initializationStatus;
 
} // end DriverEntry()

GetDeviceDataCallback()

VP_STATUS NTAPI GetDeviceDataCallback	(	PVOID	HwDeviceExtension,
		PVOID	Context,
		VIDEO_DEVICE_DATA_TYPE	DeviceDataType,
		PVOID	Identifier,
		ULONG	IdentifierLength,
		PVOID	ConfigurationData,
		ULONG	ConfigurationDataLength,
		PVOID	ComponentInformation,
		ULONG	ComponentInformationLength
	)

Definition at line 1462 of file vga.c.

{
    VideoDebugPrint((Error, "Detected internal VGA chip on embedded board, todo\n"));
    while (TRUE);
    return NO_ERROR;
 
} //end GetDeviceDataCallback()

Referenced by VgaFindAdapter().

VgaAcquireResources()

VP_STATUS NTAPI VgaAcquireResources

(

PHW_DEVICE_EXTENSION

DeviceExtension

)

Definition at line 1522 of file vga.c.

{
    VP_STATUS Status = NO_ERROR;
    ULONG Ranges, i;
 
    //
    // Try exclusive ranges (vga + ati)
    //
 
    Ranges = NUM_VGA_ACCESS_RANGES;
    for (i = 0; i < Ranges; i++) VgaAccessRange[i].RangeShareable = FALSE;
    if (VideoPortVerifyAccessRanges(DeviceExtension, Ranges, VgaAccessRange) != NO_ERROR)
    {
        //
        // Not worked, try vga only
        //
 
        Ranges = 3;
        if (VideoPortVerifyAccessRanges(DeviceExtension, Ranges, VgaAccessRange) != NO_ERROR)
        {
            //
            // Still not, try shared ranges
            //
 
            for (i = 0; i < Ranges; i++) VgaAccessRange[i].RangeShareable = TRUE;
            Status = VideoPortVerifyAccessRanges(DeviceExtension, Ranges, VgaAccessRange);
            if (Status == NO_ERROR)
            {
                //
                // It did work
                //
 
                VideoPortVerifyAccessRanges(DeviceExtension, 0, 0);
                Status = NO_ERROR;
            }
        }
    }
 
    if (Status == NO_ERROR)
    {
        //
        // Worked with exclusive, also try shared
        //
 
        for (i = 0; i < Ranges; i++) VgaAccessRange[i].RangeShareable = TRUE;
        Status = VideoPortVerifyAccessRanges(DeviceExtension, Ranges, VgaAccessRange);
    }
 
    return Status;
}

Referenced by VgaFindAdapter().

VgaFindAdapter()

VP_STATUS NTAPI VgaFindAdapter	(	PVOID	HwDeviceExtension,
		PVOID	HwContext,
		PWSTR	ArgumentString,
		PVIDEO_PORT_CONFIG_INFO	ConfigInfo,
		PUCHAR	Again
	)

Definition at line 324 of file vga.c.

{
 
    PHW_DEVICE_EXTENSION hwDeviceExtension = HwDeviceExtension;
 
    //
    // Make sure the size of the structure is at least as large as what we
    // are expecting (check version of the config info structure).
    //
 
    if (ConfigInfo->Length < sizeof(VIDEO_PORT_CONFIG_INFO)) {
 
        return ERROR_INVALID_PARAMETER;
 
    }
// eVb: 1.4 [CIRRUS] - Remove CIRRUS-specific support
    //
    // Check internal VGA (MIPS and ARM systems)
    //
 
    if ((ConfigInfo->AdapterInterfaceType == Internal) &&
        (VideoPortGetDeviceData(HwDeviceExtension,
                                VpControllerData,
                                &GetDeviceDataCallback,
                                VgaAccessRange) != NO_ERROR))
    {
        return ERROR_INVALID_PARAMETER;
    }
// eVb: 1.4 [END]
    //
    // No interrupt information is necessary.
    //
 
    //
    // Check to see if there is a hardware resource conflict.
    //
// eVb: 1.5 [RESOURCE] - Use new function for acquiring VGA resources (I/O, memory)
    if (VgaAcquireResources(hwDeviceExtension) != NO_ERROR) return ERROR_INVALID_PARAMETER;
// eVb: 1.5 [END]
    //
    // Get logical IO port addresses.
    //
 
    if ((hwDeviceExtension->IOAddress =
         VideoPortGetDeviceBase(hwDeviceExtension,
         VgaAccessRange->RangeStart,
         VGA_MAX_IO_PORT - VGA_BASE_IO_PORT + 1,
         VgaAccessRange->RangeInIoSpace)) == NULL)
    {
        VideoDebugPrint((0, "VgaFindAdapter - Fail to get io address\n"));
 
        return ERROR_INVALID_PARAMETER;
    }
 
    //
    // Determine whether a VGA is present.
    //
 
    if (!VgaIsPresent(hwDeviceExtension)) {
 
        VideoDebugPrint((0, "VgaFindAdapter - VGA Failed\n"));
        return ERROR_DEV_NOT_EXIST;
    }
 
    //
    // Minimum size of the buffer required to store the hardware state
    // information returned by IOCTL_VIDEO_SAVE_HARDWARE_STATE.
    //
 
    ConfigInfo->HardwareStateSize = VGA_TOTAL_STATE_SIZE;
 
    //
    // Pass a pointer to the emulator range we are using.
    //
// eVb: 1.6 [VDM] - Disable VDM for now
    ConfigInfo->NumEmulatorAccessEntries = 0;
    ConfigInfo->EmulatorAccessEntries = NULL;
    ConfigInfo->EmulatorAccessEntriesContext = 0;
// eVb: 1.6 [END]
    //
    // BUGBUG
    //
    // There is really no reason to have the frame buffer mapped. On an
    // x86 we use if for save/restore (supposedly) but even then we
    // would only need to map a 64K window, not all 16 Meg!
    //
 
#ifdef _X86_
 
    //
    // Map the video memory into the system virtual address space so we can
    // clear it out and use it for save and restore.
    //
 
    if ( (hwDeviceExtension->VideoMemoryAddress =
              VideoPortGetDeviceBase(hwDeviceExtension,
                                     VgaAccessRange[2].RangeStart,
                                     VgaAccessRange[2].RangeLength,
                                     FALSE)) == NULL)
    {
        VideoDebugPrint((0, "VgaFindAdapter - Fail to get memory address\n"));
 
        return ERROR_INVALID_PARAMETER;
    }
 
    VideoDebugPrint((0, "vga mapped at %x\n", hwDeviceExtension->VideoMemoryAddress));
#endif
// eVb: 1.7 [VDM] - Disable VDM for now
    ConfigInfo->VdmPhysicalVideoMemoryAddress.QuadPart = 0;
    ConfigInfo->VdmPhysicalVideoMemoryLength = 0;
// eVb: 1.7 [END]
    //
    // Indicate we do not wish to be called again for another initialization.
    //
 
    *Again = 0;
 
    //
    // Indicate a successful completion status.
    //
 
    return NO_ERROR;
 
 
} // VgaFindAdapter()

Referenced by DriverEntry().

VgaInitialize()

BOOLEAN NTAPI VgaInitialize

(

PVOID

HwDeviceExtension

)

Definition at line 507 of file vga.c.

{
    PHW_DEVICE_EXTENSION hwDeviceExtension = HwDeviceExtension;
 
    //
    // set up the default cursor position and type.
    //
 
    hwDeviceExtension->CursorPosition.Column = 0;
    hwDeviceExtension->CursorPosition.Row = 0;
    hwDeviceExtension->CursorTopScanLine = 0;
    hwDeviceExtension->CursorBottomScanLine = 31;
    hwDeviceExtension->CursorEnable = TRUE;
 
// eVb: 1.8 [VBE] - Initialize VBE modes
    InitializeModeTable(hwDeviceExtension);
// eVb: 1.8 [END]
    return TRUE;
 
} // VgaInitialize()

Referenced by DriverEntry().

VgaInterpretCmdStream()

VP_STATUS NTAPI VgaInterpretCmdStream	(	PHW_DEVICE_EXTENSION	HwDeviceExtension,
		PUSHORT	pusCmdStream
	)

Definition at line 74 of file modeset.c.

{
    ULONG ulCmd;
    ULONG_PTR ulPort;
    UCHAR jValue;
    USHORT usValue;
    ULONG culCount;
    ULONG ulIndex;
    ULONG_PTR ulBase;
 
    if (pusCmdStream == NULL) {
 
        VideoDebugPrint((1, "VgaInterpretCmdStream - Invalid pusCmdStream\n"));
        return TRUE;
    }
 
    ulBase = (ULONG_PTR)HwDeviceExtension->IOAddress;
 
    //
    // Now set the adapter to the desired mode.
    //
 
    while ((ulCmd = *pusCmdStream++) != EOD) {
 
        //
        // Determine major command type
        //
 
        switch (ulCmd & 0xF0) {
 
            //
            // Basic input/output command
            //
 
            case INOUT:
 
                //
                // Determine type of inout instruction
                //
 
                if (!(ulCmd & IO)) {
 
                    //
                    // Out instruction. Single or multiple outs?
                    //
 
                    if (!(ulCmd & MULTI)) {
 
                        //
                        // Single out. Byte or word out?
                        //
 
                        if (!(ulCmd & BW)) {
 
                            //
                            // Single byte out
                            //
 
                            ulPort = *pusCmdStream++;
                            jValue = (UCHAR) *pusCmdStream++;
                            VideoPortWritePortUchar((PUCHAR)(ulBase+ulPort),
                                    jValue);
 
                        } else {
 
                            //
                            // Single word out
                            //
 
                            ulPort = *pusCmdStream++;
                            usValue = *pusCmdStream++;
                            VideoPortWritePortUshort((PUSHORT)(ulBase+ulPort),
                                    usValue);
 
                        }
 
                    } else {
 
                        //
                        // Output a string of values
                        // Byte or word outs?
                        //
 
                        if (!(ulCmd & BW)) {
 
                            //
                            // String byte outs. Do in a loop; can't use
                            // VideoPortWritePortBufferUchar because the data
                            // is in USHORT form
                            //
 
                            ulPort = ulBase + *pusCmdStream++;
                            culCount = *pusCmdStream++;
 
                            while (culCount--) {
                                jValue = (UCHAR) *pusCmdStream++;
                                VideoPortWritePortUchar((PUCHAR)ulPort,
                                        jValue);
 
                            }
 
                        } else {
 
                            //
                            // String word outs
                            //
 
                            ulPort = *pusCmdStream++;
                            culCount = *pusCmdStream++;
                            VideoPortWritePortBufferUshort((PUSHORT)
                                    (ulBase + ulPort), pusCmdStream, culCount);
                            pusCmdStream += culCount;
 
                        }
                    }
 
                } else {
 
                    // In instruction
                    //
                    // Currently, string in instructions aren't supported; all
                    // in instructions are handled as single-byte ins
                    //
                    // Byte or word in?
                    //
 
                    if (!(ulCmd & BW)) {
                        //
                        // Single byte in
                        //
 
                        ulPort = *pusCmdStream++;
                        jValue = VideoPortReadPortUchar((PUCHAR)ulBase+ulPort);
 
                    } else {
 
                        //
                        // Single word in
                        //
 
                        ulPort = *pusCmdStream++;
                        usValue = VideoPortReadPortUshort((PUSHORT)
                                (ulBase+ulPort));
 
                    }
 
                }
 
                break;
 
            //
            // Higher-level input/output commands
            //
 
            case METAOUT:
 
                //
                // Determine type of metaout command, based on minor
                // command field
                //
                switch (ulCmd & 0x0F) {
 
                    //
                    // Indexed outs
                    //
 
                    case INDXOUT:
 
                        ulPort = ulBase + *pusCmdStream++;
                        culCount = *pusCmdStream++;
                        ulIndex = *pusCmdStream++;
 
                        while (culCount--) {
 
                            usValue = (USHORT) (ulIndex +
                                      (((ULONG)(*pusCmdStream++)) << 8));
                            VideoPortWritePortUshort((PUSHORT)ulPort, usValue);
 
                            ulIndex++;
 
                        }
 
                        break;
 
                    //
                    // Masked out (read, AND, XOR, write)
                    //
 
                    case MASKOUT:
 
                        ulPort = *pusCmdStream++;
                        jValue = VideoPortReadPortUchar((PUCHAR)ulBase+ulPort);
                        jValue &= *pusCmdStream++;
                        jValue ^= *pusCmdStream++;
                        VideoPortWritePortUchar((PUCHAR)ulBase + ulPort,
                                jValue);
                        break;
 
                    //
                    // Attribute Controller out
                    //
 
                    case ATCOUT:
 
                        ulPort = ulBase + *pusCmdStream++;
                        culCount = *pusCmdStream++;
                        ulIndex = *pusCmdStream++;
 
                        while (culCount--) {
 
                            // Write Attribute Controller index
                            VideoPortWritePortUchar((PUCHAR)ulPort,
                                    (UCHAR)ulIndex);
 
                            // Write Attribute Controller data
                            jValue = (UCHAR) *pusCmdStream++;
                            VideoPortWritePortUchar((PUCHAR)ulPort, jValue);
 
                            ulIndex++;
 
                        }
 
                        break;
 
                    //
                    // None of the above; error
                    //
                    default:
 
                        return FALSE;
 
                }
 
 
                break;
 
            //
            // NOP
            //
 
            case NCMD:
 
                break;
 
            //
            // Unknown command; error
            //
 
            default:
 
                return FALSE;
 
        }
 
    }
 
    return TRUE;
 
} // end VgaInterpretCmdStream()

Referenced by VgaSetMode(), and VgaZeroVideoMemory().

VgaIsPresent()

BOOLEAN NTAPI VgaIsPresent

(

PHW_DEVICE_EXTENSION

HwDeviceExtension

)

Definition at line 940 of file vga.c.

{
    UCHAR originalGCAddr;
    UCHAR originalSCAddr;
    UCHAR originalBitMask;
    UCHAR originalReadMap;
    UCHAR originalMemoryMode;
    UCHAR testMask;
    BOOLEAN returnStatus;
 
    //
    // Remember the original state of the Graphics Controller Address register.
    //
 
    originalGCAddr = VideoPortReadPortUchar(HwDeviceExtension->IOAddress +
            GRAPH_ADDRESS_PORT);
 
    //
    // Write the Read Map register with a known state so we can verify
    // that it isn't changed after we fool with the Bit Mask. This ensures
    // that we're dealing with indexed registers, since both the Read Map and
    // the Bit Mask are addressed at GRAPH_DATA_PORT.
    //
 
    VideoPortWritePortUchar(HwDeviceExtension->IOAddress +
            GRAPH_ADDRESS_PORT, IND_READ_MAP);
 
    //
    // If we can't read back the Graphics Address register setting we just
    // performed, it's not readable and this isn't a VGA.
    //
 
    if ((VideoPortReadPortUchar(HwDeviceExtension->IOAddress +
        GRAPH_ADDRESS_PORT) & GRAPH_ADDR_MASK) != IND_READ_MAP) {
 
        return FALSE;
    }
 
    //
    // Set the Read Map register to a known state.
    //
 
    originalReadMap = VideoPortReadPortUchar(HwDeviceExtension->IOAddress +
            GRAPH_DATA_PORT);
    VideoPortWritePortUchar(HwDeviceExtension->IOAddress +
            GRAPH_DATA_PORT, READ_MAP_TEST_SETTING);
 
    if (VideoPortReadPortUchar(HwDeviceExtension->IOAddress +
            GRAPH_DATA_PORT) != READ_MAP_TEST_SETTING) {
 
        //
        // The Read Map setting we just performed can't be read back; not a
        // VGA. Restore the default Read Map state.
        //
 
        VideoPortWritePortUchar(HwDeviceExtension->IOAddress +
                GRAPH_DATA_PORT, READ_MAP_DEFAULT);
 
        return FALSE;
    }
 
    //
    // Remember the original setting of the Bit Mask register.
    //
 
    VideoPortWritePortUchar(HwDeviceExtension->IOAddress +
            GRAPH_ADDRESS_PORT, IND_BIT_MASK);
    if ((VideoPortReadPortUchar(HwDeviceExtension->IOAddress +
                GRAPH_ADDRESS_PORT) & GRAPH_ADDR_MASK) != IND_BIT_MASK) {
 
        //
        // The Graphics Address register setting we just made can't be read
        // back; not a VGA. Restore the default Read Map state.
        //
 
        VideoPortWritePortUchar(HwDeviceExtension->IOAddress +
                GRAPH_ADDRESS_PORT, IND_READ_MAP);
        VideoPortWritePortUchar(HwDeviceExtension->IOAddress +
                GRAPH_DATA_PORT, READ_MAP_DEFAULT);
 
        return FALSE;
    }
 
    originalBitMask = VideoPortReadPortUchar(HwDeviceExtension->IOAddress +
            GRAPH_DATA_PORT);
 
    //
    // Set up the initial test mask we'll write to and read from the Bit Mask.
    //
 
    testMask = 0xBB;
 
    do {
 
        //
        // Write the test mask to the Bit Mask.
        //
 
        VideoPortWritePortUchar(HwDeviceExtension->IOAddress +
                GRAPH_DATA_PORT, testMask);
 
        //
        // Make sure the Bit Mask remembered the value.
        //
 
        if (VideoPortReadPortUchar(HwDeviceExtension->IOAddress +
                    GRAPH_DATA_PORT) != testMask) {
 
            //
            // The Bit Mask is not properly writable and readable; not a VGA.
            // Restore the Bit Mask and Read Map to their default states.
            //
 
            VideoPortWritePortUchar(HwDeviceExtension->IOAddress +
                    GRAPH_DATA_PORT, BIT_MASK_DEFAULT);
            VideoPortWritePortUchar(HwDeviceExtension->IOAddress +
                    GRAPH_ADDRESS_PORT, IND_READ_MAP);
            VideoPortWritePortUchar(HwDeviceExtension->IOAddress +
                    GRAPH_DATA_PORT, READ_MAP_DEFAULT);
 
            return FALSE;
        }
 
        //
        // Cycle the mask for next time.
        //
 
        testMask >>= 1;
 
    } while (testMask != 0);
 
    //
    // There's something readable at GRAPH_DATA_PORT; now switch back and
    // make sure that the Read Map register hasn't changed, to verify that
    // we're dealing with indexed registers.
    //
 
    VideoPortWritePortUchar(HwDeviceExtension->IOAddress +
            GRAPH_ADDRESS_PORT, IND_READ_MAP);
    if (VideoPortReadPortUchar(HwDeviceExtension->IOAddress +
                GRAPH_DATA_PORT) != READ_MAP_TEST_SETTING) {
 
        //
        // The Read Map is not properly writable and readable; not a VGA.
        // Restore the Bit Mask and Read Map to their default states, in case
        // this is an EGA, so subsequent writes to the screen aren't garbled.
        //
 
        VideoPortWritePortUchar(HwDeviceExtension->IOAddress +
                GRAPH_DATA_PORT, READ_MAP_DEFAULT);
        VideoPortWritePortUchar(HwDeviceExtension->IOAddress +
                GRAPH_ADDRESS_PORT, IND_BIT_MASK);
        VideoPortWritePortUchar(HwDeviceExtension->IOAddress +
                GRAPH_DATA_PORT, BIT_MASK_DEFAULT);
 
        return FALSE;
    }
 
    //
    // We've pretty surely verified the existence of the Bit Mask register.
    // Put the Graphics Controller back to the original state.
    //
 
    VideoPortWritePortUchar(HwDeviceExtension->IOAddress +
            GRAPH_DATA_PORT, originalReadMap);
    VideoPortWritePortUchar(HwDeviceExtension->IOAddress +
            GRAPH_ADDRESS_PORT, IND_BIT_MASK);
    VideoPortWritePortUchar(HwDeviceExtension->IOAddress +
            GRAPH_DATA_PORT, originalBitMask);
    VideoPortWritePortUchar(HwDeviceExtension->IOAddress +
            GRAPH_ADDRESS_PORT, originalGCAddr);
 
    //
    // Now, check for the existence of the Chain4 bit.
    //
 
    //
    // Remember the original states of the Sequencer Address and Memory Mode
    // registers.
    //
 
    originalSCAddr = VideoPortReadPortUchar(HwDeviceExtension->IOAddress +
            SEQ_ADDRESS_PORT);
    VideoPortWritePortUchar(HwDeviceExtension->IOAddress +
            SEQ_ADDRESS_PORT, IND_MEMORY_MODE);
    if ((VideoPortReadPortUchar(HwDeviceExtension->IOAddress +
            SEQ_ADDRESS_PORT) & SEQ_ADDR_MASK) != IND_MEMORY_MODE) {
 
        //
        // Couldn't read back the Sequencer Address register setting we just
        // performed.
        //
 
        return FALSE;
    }
    originalMemoryMode = VideoPortReadPortUchar(HwDeviceExtension->IOAddress +
            SEQ_DATA_PORT);
 
    //
    // Toggle the Chain4 bit and read back the result. This must be done during
    // sync reset, since we're changing the chaining state.
    //
 
    //
    // Begin sync reset.
    //
 
    VideoPortWritePortUshort((PUSHORT)(HwDeviceExtension->IOAddress +
             SEQ_ADDRESS_PORT),
             (IND_SYNC_RESET + (START_SYNC_RESET_VALUE << 8)));
 
    //
    // Toggle the Chain4 bit.
    //
 
    VideoPortWritePortUchar(HwDeviceExtension->IOAddress +
            SEQ_ADDRESS_PORT, IND_MEMORY_MODE);
    VideoPortWritePortUchar(HwDeviceExtension->IOAddress +
            SEQ_DATA_PORT, (UCHAR)(originalMemoryMode ^ CHAIN4_MASK));
 
    if (VideoPortReadPortUchar(HwDeviceExtension->IOAddress +
                SEQ_DATA_PORT) != (UCHAR) (originalMemoryMode ^ CHAIN4_MASK)) {
 
        //
        // Chain4 bit not there; not a VGA.
        // Set text mode default for Memory Mode register.
        //
 
        VideoPortWritePortUchar(HwDeviceExtension->IOAddress +
                SEQ_DATA_PORT, MEMORY_MODE_TEXT_DEFAULT);
        //
        // End sync reset.
        //
 
        VideoPortWritePortUshort((PUSHORT) (HwDeviceExtension->IOAddress +
                SEQ_ADDRESS_PORT),
                (IND_SYNC_RESET + (END_SYNC_RESET_VALUE << 8)));
 
        returnStatus = FALSE;
 
    } else {
 
        //
        // It's a VGA.
        //
 
        //
        // Restore the original Memory Mode setting.
        //
 
        VideoPortWritePortUchar(HwDeviceExtension->IOAddress +
                SEQ_DATA_PORT, originalMemoryMode);
 
        //
        // End sync reset.
        //
 
        VideoPortWritePortUshort((PUSHORT)(HwDeviceExtension->IOAddress +
                SEQ_ADDRESS_PORT),
                (USHORT)(IND_SYNC_RESET + (END_SYNC_RESET_VALUE << 8)));
 
        //
        // Restore the original Sequencer Address setting.
        //
 
        VideoPortWritePortUchar(HwDeviceExtension->IOAddress +
                SEQ_ADDRESS_PORT, originalSCAddr);
 
        returnStatus = TRUE;
    }
 
    return returnStatus;
 
} // VgaIsPresent()

Referenced by VgaFindAdapter().

VgaQueryAvailableModes()

VP_STATUS NTAPI VgaQueryAvailableModes	(	PHW_DEVICE_EXTENSION	HwDeviceExtension,
		PVIDEO_MODE_INFORMATION	ModeInformation,
		ULONG	ModeInformationSize,
		PULONG_PTR	OutputSize
	)

Definition at line 517 of file modeset.c.

{
    PVIDEO_MODE_INFORMATION videoModes = ModeInformation;
    ULONG i;
 
    //
    // Find out the size of the data to be put in the buffer and return
    // that in the status information (whether or not the information is
    // there). If the buffer passed in is not large enough return an
    // appropriate error code.
    //
 
    if (ModeInformationSize < (*OutputSize =
// eVb: 2.10 [VBE] - We store VBE/VGA mode count in this global, not in DevExt like Cirrus
            NumVideoModes *
// eVb: 2.10 [END]
            sizeof(VIDEO_MODE_INFORMATION)) ) {
 
        return ERROR_INSUFFICIENT_BUFFER;
 
    }
 
    //
    // For each mode supported by the card, store the mode characteristics
    // in the output buffer.
    //
 
    for (i = 0; i < NumVideoModes; i++)
    {
        videoModes->Length = sizeof(VIDEO_MODE_INFORMATION);
        videoModes->ModeIndex  = i;
// eVb: 2.11 [VBE] - Use dynamic VBE mode list instead of hard-coded VGA list
        videoModes->VisScreenWidth = VgaModeList[i].hres;
        videoModes->ScreenStride = VgaModeList[i].wbytes;
        videoModes->VisScreenHeight = VgaModeList[i].vres;
        videoModes->NumberOfPlanes = VgaModeList[i].numPlanes;
        videoModes->BitsPerPlane = VgaModeList[i].bitsPerPlane;
        videoModes->Frequency = VgaModeList[i].Frequency;
        videoModes->XMillimeter = 320;        // temporary hardcoded constant
        videoModes->YMillimeter = 240;        // temporary hardcoded constant
        videoModes->AttributeFlags = VgaModeList[i].fbType;
// eVb: 2.11 [END]
 
        if ((VgaModeList[i].bitsPerPlane == 32) ||
            (VgaModeList[i].bitsPerPlane == 24))
        {
 
            videoModes->NumberRedBits = 8;
            videoModes->NumberGreenBits = 8;
            videoModes->NumberBlueBits = 8;
            videoModes->RedMask = 0xff0000;
            videoModes->GreenMask = 0x00ff00;
            videoModes->BlueMask = 0x0000ff;
 
        }
        else if (VgaModeList[i].bitsPerPlane == 16)
        {
 
            videoModes->NumberRedBits = 6;
            videoModes->NumberGreenBits = 6;
            videoModes->NumberBlueBits = 6;
            videoModes->RedMask = 0x1F << 11;
            videoModes->GreenMask = 0x3F << 5;
            videoModes->BlueMask = 0x1F;
 
        }
// eVb: 2.12 [VGA] - Add support for 15bpp modes, which Cirrus doesn't support
        else if (VgaModeList[i].bitsPerPlane == 15)
        {
 
            videoModes->NumberRedBits = 6;
            videoModes->NumberGreenBits = 6;
            videoModes->NumberBlueBits = 6;
            videoModes->RedMask = 0x3E << 9;
            videoModes->GreenMask = 0x1F << 5;
            videoModes->BlueMask = 0x1F;
        }
// eVb: 2.12 [END]
        else
        {
 
            videoModes->NumberRedBits = 6;
            videoModes->NumberGreenBits = 6;
            videoModes->NumberBlueBits = 6;
            videoModes->RedMask = 0;
            videoModes->GreenMask = 0;
            videoModes->BlueMask = 0;
        }
 
// eVb: 2.13 [VGA] - All modes are palette managed/driven, unlike Cirrus
        videoModes->AttributeFlags |= VIDEO_MODE_PALETTE_DRIVEN |
             VIDEO_MODE_MANAGED_PALETTE;
// eVb: 2.13 [END]
        videoModes++;
 
    }
 
    return NO_ERROR;
 
} // end VgaGetAvailableModes()

Referenced by VgaStartIO().

VgaQueryCurrentMode()

VP_STATUS NTAPI VgaQueryCurrentMode	(	PHW_DEVICE_EXTENSION	HwDeviceExtension,
		PVIDEO_MODE_INFORMATION	ModeInformation,
		ULONG	ModeInformationSize,
		PULONG_PTR	OutputSize
	)

Definition at line 719 of file modeset.c.

{
    //
    // check if a mode has been set
    //
 
    if (HwDeviceExtension->CurrentMode == NULL ) {
 
        return ERROR_INVALID_FUNCTION;
 
    }
 
    //
    // Find out the size of the data to be put in the the buffer and return
    // that in the status information (whether or not the information is
    // there). If the buffer passed in is not large enough return an
    // appropriate error code.
    //
 
    if (ModeInformationSize < (*OutputSize = sizeof(VIDEO_MODE_INFORMATION))) {
 
        return ERROR_INSUFFICIENT_BUFFER;
 
    }
 
    //
    // Store the characteristics of the current mode into the buffer.
    //
 
    ModeInformation->Length = sizeof(VIDEO_MODE_INFORMATION);
    ModeInformation->ModeIndex = HwDeviceExtension->ModeIndex;
    ModeInformation->VisScreenWidth = HwDeviceExtension->CurrentMode->hres;
    ModeInformation->ScreenStride = HwDeviceExtension->CurrentMode->wbytes;
    ModeInformation->VisScreenHeight = HwDeviceExtension->CurrentMode->vres;
    ModeInformation->NumberOfPlanes = HwDeviceExtension->CurrentMode->numPlanes;
    ModeInformation->BitsPerPlane = HwDeviceExtension->CurrentMode->bitsPerPlane;
    ModeInformation->Frequency = HwDeviceExtension->CurrentMode->Frequency;
    ModeInformation->XMillimeter = 320;        // temporary hardcoded constant
    ModeInformation->YMillimeter = 240;        // temporary hardcoded constant
 
    ModeInformation->AttributeFlags = HwDeviceExtension->CurrentMode->fbType;
 
    if ((ModeInformation->BitsPerPlane == 32) ||
        (ModeInformation->BitsPerPlane == 24))
    {
 
        ModeInformation->NumberRedBits = 8;
        ModeInformation->NumberGreenBits = 8;
        ModeInformation->NumberBlueBits = 8;
        ModeInformation->RedMask = 0xff0000;
        ModeInformation->GreenMask = 0x00ff00;
        ModeInformation->BlueMask = 0x0000ff;
 
    }
    else if (ModeInformation->BitsPerPlane == 16)
    {
 
        ModeInformation->NumberRedBits = 6;
        ModeInformation->NumberGreenBits = 6;
        ModeInformation->NumberBlueBits = 6;
        ModeInformation->RedMask = 0x1F << 11;
        ModeInformation->GreenMask = 0x3F << 5;
        ModeInformation->BlueMask = 0x1F;
 
    }
// eVb: 2.12 [VGA] - Add support for 15bpp modes, which Cirrus doesn't support
    else if (ModeInformation->BitsPerPlane == 15)
    {
 
        ModeInformation->NumberRedBits = 6;
        ModeInformation->NumberGreenBits = 6;
        ModeInformation->NumberBlueBits = 6;
        ModeInformation->RedMask = 0x3E << 9;
        ModeInformation->GreenMask = 0x1F << 5;
        ModeInformation->BlueMask = 0x1F;
    }
// eVb: 2.12 [END]
    else
    {
 
        ModeInformation->NumberRedBits = 6;
        ModeInformation->NumberGreenBits = 6;
        ModeInformation->NumberBlueBits = 6;
        ModeInformation->RedMask = 0;
        ModeInformation->GreenMask = 0;
        ModeInformation->BlueMask = 0;
    }
 
// eVb: 2.13 [VGA] - All modes are palette managed/driven, unlike Cirrus
    ModeInformation->AttributeFlags |= VIDEO_MODE_PALETTE_DRIVEN |
         VIDEO_MODE_MANAGED_PALETTE;
// eVb: 2.13 [END]
 
    return NO_ERROR;
 
} // end VgaQueryCurrentMode()

Referenced by VgaStartIO().

VgaQueryNumberOfAvailableModes()

VP_STATUS NTAPI VgaQueryNumberOfAvailableModes	(	PHW_DEVICE_EXTENSION	HwDeviceExtension,
		PVIDEO_NUM_MODES	NumModes,
		ULONG	NumModesSize,
		PULONG_PTR	OutputSize
	)

Definition at line 655 of file modeset.c.

{
    //
    // Find out the size of the data to be put in the the buffer and return
    // that in the status information (whether or not the information is
    // there). If the buffer passed in is not large enough return an
    // appropriate error code.
    //
 
    if (NumModesSize < (*OutputSize = sizeof(VIDEO_NUM_MODES)) ) {
 
        return ERROR_INSUFFICIENT_BUFFER;
 
    }
 
    //
    // Store the number of modes into the buffer.
    //
 
// eVb: 2.14 [VBE] - We store VBE/VGA mode count in this global, not in DevExt like Cirrus
    NumModes->NumModes = NumVideoModes;
// eVb: 2.14 [END]
    NumModes->ModeInformationLength = sizeof(VIDEO_MODE_INFORMATION);
 
    return NO_ERROR;
 
} // end VgaGetNumberOfAvailableModes()

Referenced by VgaStartIO().

VgaSetColorLookup()

VP_STATUS NTAPI VgaSetColorLookup	(	PHW_DEVICE_EXTENSION	HwDeviceExtension,
		PVIDEO_CLUT	ClutBuffer,
		ULONG	ClutBufferSize
	)

Definition at line 1356 of file vga.c.

{
    PVIDEOMODE CurrentMode = HwDeviceExtension->CurrentMode;
    USHORT i;
 
    //
    // Check if the size of the data in the input buffer is large enough.
    //
 
    if ( (ClutBufferSize < sizeof(VIDEO_CLUT) - sizeof(ULONG)) ||
         (ClutBufferSize < sizeof(VIDEO_CLUT) +
                     (sizeof(ULONG) * (ClutBuffer->NumEntries - 1)) ) ) {
 
        return ERROR_INSUFFICIENT_BUFFER;
 
    }
 
    //
    // Check to see if the parameters are valid.
    //
 
    if ( (ClutBuffer->NumEntries == 0) ||
         (ClutBuffer->FirstEntry > VIDEO_MAX_COLOR_REGISTER) ||
         (ClutBuffer->FirstEntry + ClutBuffer->NumEntries >
             VIDEO_MAX_COLOR_REGISTER + 1) ) {
 
        return ERROR_INVALID_PARAMETER;
 
    }
// eVb: 1.14 [VBE] - Add VBE color support
    //
    // Check SVGA mode
    //
 
    if (CurrentMode->bitsPerPlane >= 8) return VbeSetColorLookup(HwDeviceExtension, ClutBuffer);
// eVb: 1.14 [END]
    //
    // Path for VGA mode
    //
// eVb: 1.15 [VBE] - Add VBE support for non-VGA-compatible detected modes
    if (!CurrentMode->NonVgaMode)
    {
// eVb: 1.15 [END]
        //
        //  Set CLUT registers directly on the hardware
        //
 
        VideoPortWritePortUchar(HwDeviceExtension->IOAddress +
                DAC_ADDRESS_WRITE_PORT, (UCHAR) ClutBuffer->FirstEntry);
 
        for (i = 0; i < ClutBuffer->NumEntries; i++) {
            VideoPortWritePortUchar(HwDeviceExtension->IOAddress +
                                    DAC_ADDRESS_WRITE_PORT,
                                    (UCHAR)(i + ClutBuffer->FirstEntry));
 
            VideoPortWritePortUchar(HwDeviceExtension->IOAddress +
                                    DAC_DATA_REG_PORT,
                                    ClutBuffer->LookupTable[i].RgbArray.Red);
 
            VideoPortWritePortUchar(HwDeviceExtension->IOAddress +
                                    DAC_DATA_REG_PORT,
                                    ClutBuffer->LookupTable[i].RgbArray.Green);
 
            VideoPortWritePortUchar(HwDeviceExtension->IOAddress +
                                    DAC_DATA_REG_PORT,
                                    ClutBuffer->LookupTable[i].RgbArray.Blue);
        }
        return NO_ERROR;
    }
 
    return ERROR_INVALID_PARAMETER;
 
} // end VgaSetColorLookup()

Referenced by VgaStartIO().

VgaSetMode()

VP_STATUS NTAPI VgaSetMode	(	PHW_DEVICE_EXTENSION	HwDeviceExtension,
		PVIDEO_MODE	Mode,
		ULONG	ModeSize,
		PULONG	PhysPtrChange
	)

Definition at line 361 of file modeset.c.

{
    PVIDEOMODE pRequestedMode;
    VP_STATUS status;
    ULONG RequestedModeNum;
// eVb: 2.3 [SET MODE] - Add new output parameter for framebuffer update functionality
    *PhysPtrChange = FALSE;
// eVb: 2.3 [END]
    //
    // Check if the size of the data in the input buffer is large enough.
    //
 
    if (ModeSize < sizeof(VIDEO_MODE))
    {
        return ERROR_INSUFFICIENT_BUFFER;
    }
 
    //
    // Extract the clear memory, and map linear bits.
    //
 
    RequestedModeNum = Mode->RequestedMode &
        ~(VIDEO_MODE_NO_ZERO_MEMORY | VIDEO_MODE_MAP_MEM_LINEAR);
 
 
    if (!(Mode->RequestedMode & VIDEO_MODE_NO_ZERO_MEMORY))
    {
#if defined(_X86_)
        VgaZeroVideoMemory(HwDeviceExtension);
#endif
    }
 
    //
    // Check to see if we are requesting a valid mode
    //
// eVb: 2.4 [CIRRUS] - Remove Cirrus-specific check for valid mode
    if ( (RequestedModeNum >= NumVideoModes) )
// eVb: 2.4 [END]
    {
        VideoDebugPrint((0, "Invalide Mode Number = %d!\n", RequestedModeNum));
 
        return ERROR_INVALID_PARAMETER;
    }
 
    VideoDebugPrint((2, "Attempting to set mode %d\n",
                        RequestedModeNum));
// eVb: 2.5 [VBE] - Use dynamic VBE mode list instead of hard-coded VGA list
    pRequestedMode = &VgaModeList[RequestedModeNum];
// eVb: 2.5 [END]
    VideoDebugPrint((2, "Info on Requested Mode:\n"
                        "\tResolution: %dx%d\n",
                        pRequestedMode->hres,
                        pRequestedMode->vres ));
 
    //
    // VESA BIOS mode switch
    //
// eVb: 2.6 [VBE] - VBE Mode Switch Support 
    status = VbeSetMode(HwDeviceExtension, pRequestedMode, PhysPtrChange);
    if (status == ERROR_INVALID_FUNCTION)
    {
        //
        // VGA mode switch
        //
 
        if (!pRequestedMode->CmdStream) return ERROR_INVALID_FUNCTION;
        if (!VgaInterpretCmdStream(HwDeviceExtension, pRequestedMode->CmdStream)) return ERROR_INVALID_FUNCTION;
        goto Cleanup;
    }
    else if (status != NO_ERROR) return status;
// eVb: 2.6 [END]
// eVb: 2.7 [MODE-X] - Windows VGA Miniport Supports Mode-X, we should too
    //
    // ModeX check
    //
    
    if (pRequestedMode->hres == 320)
    {
        VideoDebugPrint((0, "ModeX not support!!!\n"));
        return ERROR_INVALID_PARAMETER;
    }
// eVb: 2.7 [END]
    //
    // Text mode check
    //
    
    if (!(pRequestedMode->fbType & VIDEO_MODE_GRAPHICS))
    {
// eVb: 2.8 [TODO] - This code path is not implemented yet
        VideoDebugPrint((0, "Text-mode not support!!!\n"));
        return ERROR_INVALID_PARAMETER;
// eVb: 2.8 [END]
    }
 
Cleanup:
    //
    // Update the location of the physical frame buffer within video memory.
    //
// eVb: 2.9 [VBE] - Linear and banked support is unified in VGA, unlike Cirrus
    HwDeviceExtension->PhysicalVideoMemoryBase.LowPart = pRequestedMode->PhysBase;
    HwDeviceExtension->PhysicalVideoMemoryLength = pRequestedMode->PhysSize;
 
    HwDeviceExtension->PhysicalFrameLength =
            pRequestedMode->FrameBufferSize;
 
    HwDeviceExtension->PhysicalFrameOffset.LowPart =
            pRequestedMode->FrameBufferBase;
// eVb: 2.9 [END]
 
    //
    // Store the new mode value.
    //
 
    HwDeviceExtension->CurrentMode = pRequestedMode;
    HwDeviceExtension->ModeIndex = Mode->RequestedMode;
 
    return NO_ERROR;
 
} //end VgaSetMode()

Referenced by VgaStartIO().

VgaSetPaletteReg()

VP_STATUS NTAPI VgaSetPaletteReg	(	PHW_DEVICE_EXTENSION	HwDeviceExtension,
		PVIDEO_PALETTE_DATA	PaletteBuffer,
		ULONG	PaletteBufferSize
	)

Definition at line 1266 of file vga.c.

{
    USHORT i;
 
    //
    // Check if the size of the data in the input buffer is large enough.
    //
 
    if ((PaletteBufferSize) < (sizeof(VIDEO_PALETTE_DATA)) ||
        (PaletteBufferSize < (sizeof(VIDEO_PALETTE_DATA) +
                (sizeof(USHORT) * (PaletteBuffer->NumEntries -1)) ))) {
 
        return ERROR_INSUFFICIENT_BUFFER;
 
    }
 
    //
    // Check to see if the parameters are valid.
    //
 
    if ( (PaletteBuffer->FirstEntry > VIDEO_MAX_COLOR_REGISTER ) ||
         (PaletteBuffer->NumEntries == 0) ||
         (PaletteBuffer->FirstEntry + PaletteBuffer->NumEntries >
             VIDEO_MAX_PALETTE_REGISTER + 1 ) ) {
 
        return ERROR_INVALID_PARAMETER;
 
    }
 
    //
    // Reset ATC to index mode
    //
 
    VideoPortReadPortUchar(HwDeviceExtension->IOAddress +
                           ATT_INITIALIZE_PORT_COLOR);
 
    //
    // Blast out our palette values.
    //
 
    for (i = 0; i < PaletteBuffer->NumEntries; i++) {
 
        VideoPortWritePortUchar(HwDeviceExtension->IOAddress + ATT_ADDRESS_PORT,
                                (UCHAR)(i+PaletteBuffer->FirstEntry));
 
        VideoPortWritePortUchar(HwDeviceExtension->IOAddress +
                                    ATT_DATA_WRITE_PORT,
                                (UCHAR)PaletteBuffer->Colors[i]);
    }
 
    VideoPortWritePortUchar(HwDeviceExtension->IOAddress + ATT_ADDRESS_PORT,
                            VIDEO_ENABLE);
 
    return NO_ERROR;
 
} // end VgaSetPaletteReg()

Referenced by VgaStartIO().

VgaStartIO()

BOOLEAN NTAPI VgaStartIO	(	PVOID	HwDeviceExtension,
		PVIDEO_REQUEST_PACKET	RequestPacket
	)

Definition at line 550 of file vga.c.

{
    PHW_DEVICE_EXTENSION hwDeviceExtension = HwDeviceExtension;
    VP_STATUS status;
    VIDEO_MODE videoMode;
    PVIDEO_MEMORY_INFORMATION memoryInformation;
    ULONG inIoSpace;
    ULONG Result;
 
    //
    // Switch on the IoContolCode in the RequestPacket. It indicates which
    // function must be performed by the driver.
    //
// eVb: 1.9 [IOCTL] - Remove IOCTLs not needed yet
    switch (RequestPacket->IoControlCode)
    {
    case IOCTL_VIDEO_SHARE_VIDEO_MEMORY:
 
        VideoDebugPrint((2, "VgaStartIO - ShareVideoMemory\n"));
 
         status = ERROR_INVALID_FUNCTION;
 
         break;
 
    case IOCTL_VIDEO_UNSHARE_VIDEO_MEMORY:
 
        VideoDebugPrint((2, "VgaStartIO - UnshareVideoMemory\n"));
 
        status = ERROR_INVALID_FUNCTION;
 
        break;
 
 
    case IOCTL_VIDEO_MAP_VIDEO_MEMORY:
 
        VideoDebugPrint((2, "VgaStartIO - MapVideoMemory\n"));
 
        if ( (RequestPacket->OutputBufferLength <
              (RequestPacket->StatusBlock->Information =
                                     sizeof(VIDEO_MEMORY_INFORMATION))) ||
             (RequestPacket->InputBufferLength < sizeof(VIDEO_MEMORY)) )
        {
            status = ERROR_INSUFFICIENT_BUFFER;
        }
 
        memoryInformation = RequestPacket->OutputBuffer;
 
        memoryInformation->VideoRamBase = ((PVIDEO_MEMORY)
                (RequestPacket->InputBuffer))->RequestedVirtualAddress;
 
        //
        // We reserved 16 meg for the frame buffer, however, it makes
        // no sense to map more memory than there is on the card.  So
        // only map the amount of memory we have on the card.
        //
// eVb: 1.10 [CIRRUS] - On VGA, we have VRAM size since boot, use it
        memoryInformation->VideoRamLength =
                hwDeviceExtension->PhysicalVideoMemoryLength;
// eVb: 1.10 [END]
        //
        // If you change to using a dense space frame buffer, make this
        // value a 4 for the ALPHA.
        //
 
        inIoSpace = 0;
 
        status = VideoPortMapMemory(hwDeviceExtension,
                                    hwDeviceExtension->PhysicalVideoMemoryBase,
// eVb: 1.11 [CIRRUS] - On VGA, we have VRAM size since boot, use it
                                    &memoryInformation->VideoRamLength,
// eVb: 1.11 [END]
                                    &inIoSpace,
                                    &(memoryInformation->VideoRamBase));
 
        if (status != NO_ERROR) {
            VideoDebugPrint((0, "VgaStartIO - IOCTL_VIDEO_MAP_VIDEO_MEMORY failed VideoPortMapMemory (%x)\n", status));
        }
 
        memoryInformation->FrameBufferBase =
            ((PUCHAR) (memoryInformation->VideoRamBase)) +
            hwDeviceExtension->PhysicalFrameOffset.LowPart;
 
        memoryInformation->FrameBufferLength =
            hwDeviceExtension->PhysicalFrameLength ?
            hwDeviceExtension->PhysicalFrameLength :
            memoryInformation->VideoRamLength;
 
 
        VideoDebugPrint((2, "physical VideoMemoryBase %08lx\n", hwDeviceExtension->PhysicalVideoMemoryBase));
        VideoDebugPrint((2, "physical VideoMemoryLength %08lx\n", hwDeviceExtension->PhysicalVideoMemoryLength));
        VideoDebugPrint((2, "VideoMemoryBase %08lx\n", memoryInformation->VideoRamBase));
        VideoDebugPrint((2, "VideoMemoryLength %08lx\n", memoryInformation->VideoRamLength));
 
        VideoDebugPrint((2, "physical framebuf offset %08lx\n", hwDeviceExtension->PhysicalFrameOffset.LowPart));
        VideoDebugPrint((2, "framebuf base %08lx\n", memoryInformation->FrameBufferBase));
        VideoDebugPrint((2, "physical framebuf len %08lx\n", hwDeviceExtension->PhysicalFrameLength));
        VideoDebugPrint((2, "framebuf length %08lx\n", memoryInformation->FrameBufferLength));
 
        break;
 
    case IOCTL_VIDEO_UNMAP_VIDEO_MEMORY:
 
        VideoDebugPrint((2, "VgaStartIO - UnMapVideoMemory\n"));
 
        status = ERROR_INVALID_FUNCTION;
 
        break;
 
 
    case IOCTL_VIDEO_QUERY_AVAIL_MODES:
 
        VideoDebugPrint((2, "VgaStartIO - QueryAvailableModes\n"));
 
        status = VgaQueryAvailableModes(HwDeviceExtension,
                                        (PVIDEO_MODE_INFORMATION)
                                            RequestPacket->OutputBuffer,
                                        RequestPacket->OutputBufferLength,
                                        &RequestPacket->StatusBlock->Information);
 
        break;
 
 
    case IOCTL_VIDEO_QUERY_NUM_AVAIL_MODES:
 
        VideoDebugPrint((2, "VgaStartIO - QueryNumAvailableModes\n"));
 
        status = VgaQueryNumberOfAvailableModes(HwDeviceExtension,
                                                (PVIDEO_NUM_MODES)
                                                    RequestPacket->OutputBuffer,
                                                RequestPacket->OutputBufferLength,
                                                &RequestPacket->StatusBlock->Information);
 
        break;
 
 
    case IOCTL_VIDEO_QUERY_CURRENT_MODE:
 
        VideoDebugPrint((2, "VgaStartIO - QueryCurrentMode\n"));
 
        status = VgaQueryCurrentMode(HwDeviceExtension,
                                     (PVIDEO_MODE_INFORMATION) RequestPacket->OutputBuffer,
                                     RequestPacket->OutputBufferLength,
                                     &RequestPacket->StatusBlock->Information);
 
        break;
 
 
    case IOCTL_VIDEO_SET_CURRENT_MODE:
 
        VideoDebugPrint((2, "VgaStartIO - SetCurrentModes\n"));
 
        status = VgaSetMode(HwDeviceExtension,
                              (PVIDEO_MODE) RequestPacket->InputBuffer,
                              RequestPacket->InputBufferLength,
// eVb: 1.12 [SET MODE] - Use new output parameter for framebuffer update functionality
                              &Result);
// eVb: 1.12 [END]
 
        break;
 
 
    case IOCTL_VIDEO_RESET_DEVICE:
 
        VideoDebugPrint((2, "VgaStartIO - Reset Device\n"));
 
        videoMode.RequestedMode = 0;
 
        VgaSetMode(HwDeviceExtension,
                        (PVIDEO_MODE) &videoMode,
                        sizeof(videoMode),
// eVb: 1.13 [SET MODE] - Use new output parameter for framebuffer update functionality
                        &Result);
// eVb: 1.13 [END]
 
        //
        // Always return success since settings the text mode will fail on
        // non-x86.
        //
        // Also, failure to set the text mode is not fatal in any way, since
        // this operation must be followed by another set mode operation.
        //
 
        status = NO_ERROR;
 
        break;
 
 
    case IOCTL_VIDEO_LOAD_AND_SET_FONT:
 
        VideoDebugPrint((2, "VgaStartIO - LoadAndSetFont\n"));
 
        status = ERROR_INVALID_FUNCTION;
 
        break;
 
 
    case IOCTL_VIDEO_QUERY_CURSOR_POSITION:
 
        VideoDebugPrint((2, "VgaStartIO - QueryCursorPosition\n"));
 
        status = ERROR_INVALID_FUNCTION;
 
        break;
 
 
    case IOCTL_VIDEO_SET_CURSOR_POSITION:
 
        VideoDebugPrint((2, "VgaStartIO - SetCursorPosition\n"));
 
        status = ERROR_INVALID_FUNCTION;
 
        break;
 
 
    case IOCTL_VIDEO_QUERY_CURSOR_ATTR:
 
        VideoDebugPrint((2, "VgaStartIO - QueryCursorAttributes\n"));
 
        status = ERROR_INVALID_FUNCTION;
 
        break;
 
 
    case IOCTL_VIDEO_SET_CURSOR_ATTR:
 
        VideoDebugPrint((2, "VgaStartIO - SetCursorAttributes\n"));
 
        status = ERROR_INVALID_FUNCTION;
 
        break;
 
 
    case IOCTL_VIDEO_SET_PALETTE_REGISTERS:
 
        VideoDebugPrint((2, "VgaStartIO - SetPaletteRegs\n"));
 
        status = VgaSetPaletteReg(HwDeviceExtension,
                                  (PVIDEO_PALETTE_DATA) RequestPacket->InputBuffer,
                                  RequestPacket->InputBufferLength);
 
        break;
 
 
    case IOCTL_VIDEO_SET_COLOR_REGISTERS:
 
        VideoDebugPrint((2, "VgaStartIO - SetColorRegs\n"));
 
        status = VgaSetColorLookup(HwDeviceExtension,
                                   (PVIDEO_CLUT) RequestPacket->InputBuffer,
                                   RequestPacket->InputBufferLength);
 
        break;
 
 
    case IOCTL_VIDEO_ENABLE_VDM:
 
        VideoDebugPrint((2, "VgaStartIO - EnableVDM\n"));
 
        status = ERROR_INVALID_FUNCTION;
 
        break;
 
 
    case IOCTL_VIDEO_RESTORE_HARDWARE_STATE:
 
        VideoDebugPrint((2, "VgaStartIO - RestoreHardwareState\n"));
 
        status = ERROR_INVALID_FUNCTION;
 
        break;
 
 
    case IOCTL_VIDEO_SAVE_HARDWARE_STATE:
 
        VideoDebugPrint((2, "VgaStartIO - SaveHardwareState\n"));
 
        status = ERROR_INVALID_FUNCTION;
 
        break;
 
    case IOCTL_VIDEO_GET_BANK_SELECT_CODE:
 
        VideoDebugPrint((2, "VgaStartIO - GetBankSelectCode\n"));
 
        status = ERROR_INVALID_FUNCTION;
        break;
 
    case IOCTL_VIDEO_QUERY_PUBLIC_ACCESS_RANGES:
        {
            PVIDEO_PUBLIC_ACCESS_RANGES portAccess;
            ULONG physicalPortLength;
 
            VideoDebugPrint((2, "VgaStartIO - Query Public Address Ranges\n"));
 
            if (RequestPacket->OutputBufferLength <
                sizeof(VIDEO_PUBLIC_ACCESS_RANGES))
            {
                status = ERROR_INSUFFICIENT_BUFFER;
                break;
            }
 
            RequestPacket->StatusBlock->Information =
                sizeof(VIDEO_PUBLIC_ACCESS_RANGES);
 
            portAccess = RequestPacket->OutputBuffer;
 
            //
            // The first public access range is the IO ports.
            //
 
            portAccess->VirtualAddress  = (PVOID) NULL;
            portAccess->InIoSpace       = TRUE;
            portAccess->MappedInIoSpace = portAccess->InIoSpace;
            physicalPortLength = VGA_MAX_IO_PORT - VGA_BASE_IO_PORT + 1;
 
            status =  VideoPortMapMemory(hwDeviceExtension,
                                         VgaAccessRange->RangeStart,
                                         &physicalPortLength,
                                         &(portAccess->MappedInIoSpace),
                                         &(portAccess->VirtualAddress));
// eVb: 1.17 [GCG] - Fix lvalue error
            portAccess->VirtualAddress = (PVOID)((ULONG_PTR)portAccess->VirtualAddress - VGA_BASE_IO_PORT);
// eVb: 1.17 [END]
            VideoDebugPrint((2, "VgaStartIO - mapping ports to (%x)\n", portAccess->VirtualAddress));
        }
 
        break;
 
    case IOCTL_VIDEO_FREE_PUBLIC_ACCESS_RANGES:
 
        VideoDebugPrint((2, "VgaStartIO - Free Public Access Ranges\n"));
 
        status = ERROR_INVALID_FUNCTION;
        break;
 
    //
    // if we get here, an invalid IoControlCode was specified.
    //
 
    default:
 
        VideoDebugPrint((0, "Fell through vga startIO routine - invalid command\n"));
 
        status = ERROR_INVALID_FUNCTION;
 
        break;
 
    }
// eVb: 1.9 [END]
    RequestPacket->StatusBlock->Status = status;
 
    return TRUE;
 
} // VgaStartIO()

Referenced by DriverEntry().