diff options
Diffstat (limited to '')
| -rw-r--r-- | public/sdk/inc/ntddvdeo.h | 1323 |
1 files changed, 1323 insertions, 0 deletions
diff --git a/public/sdk/inc/ntddvdeo.h b/public/sdk/inc/ntddvdeo.h new file mode 100644 index 000000000..223cdc095 --- /dev/null +++ b/public/sdk/inc/ntddvdeo.h @@ -0,0 +1,1323 @@ +/*++ BUILD Version: 0001 // Increment this if a change has global effects + +Copyright (c) 1990-1993 Microsoft Corporation + +Module Name: + + ddvdeo.h + +Abstract: + + This is the include file that defines all constants and types for + accessing the Video device. + +Author: + + Andre Vachon (andreva) 21-Jan-1992 + +Revision History: + +--*/ + +// +// VideoIoControlFile InputBuffer/OutputBuffer record structures for +// this device. +// + +// +// Name used to create the miniport logical device names +// + +#define VIDEO_DEVICE_NAME "DISPLAY%d" +#define WVIDEO_DEVICE_NAME L"DISPLAY%d" + + +// +// The first set of IOCTLs are handle by the port driver and never seen +// by the miniport. +// + +#define IOCTL_VIDEO_ENABLE_VDM \ + CTL_CODE(FILE_DEVICE_VIDEO, 0x00, METHOD_BUFFERED, FILE_ANY_ACCESS) +#define IOCTL_VIDEO_DISABLE_VDM \ + CTL_CODE(FILE_DEVICE_VIDEO, 0x01, METHOD_BUFFERED, FILE_ANY_ACCESS) +#define IOCTL_VIDEO_REGISTER_VDM \ + CTL_CODE(FILE_DEVICE_VIDEO, 0x02, METHOD_BUFFERED, FILE_ANY_ACCESS) + + +// +// All these IOCTL's must be both handled by the port and miniport since +// they require processing by both parties. +// +#define IOCTL_VIDEO_SAVE_HARDWARE_STATE \ + CTL_CODE(FILE_DEVICE_VIDEO, 0x80, METHOD_BUFFERED, FILE_ANY_ACCESS) +#define IOCTL_VIDEO_RESTORE_HARDWARE_STATE \ + CTL_CODE(FILE_DEVICE_VIDEO, 0x81, METHOD_BUFFERED, FILE_ANY_ACCESS) + + +// +// All these IOCTL's are public and must/can be handled by the miniport +// driver +// + +#define IOCTL_VIDEO_QUERY_AVAIL_MODES \ + CTL_CODE(FILE_DEVICE_VIDEO, 0x100, METHOD_BUFFERED, FILE_ANY_ACCESS) +#define IOCTL_VIDEO_QUERY_NUM_AVAIL_MODES \ + CTL_CODE(FILE_DEVICE_VIDEO, 0x101, METHOD_BUFFERED, FILE_ANY_ACCESS) +#define IOCTL_VIDEO_QUERY_CURRENT_MODE \ + CTL_CODE(FILE_DEVICE_VIDEO, 0x102, METHOD_BUFFERED, FILE_ANY_ACCESS) +#define IOCTL_VIDEO_SET_CURRENT_MODE \ + CTL_CODE(FILE_DEVICE_VIDEO, 0x103, METHOD_BUFFERED, FILE_ANY_ACCESS) +#define IOCTL_VIDEO_RESET_DEVICE \ + CTL_CODE(FILE_DEVICE_VIDEO, 0x104, METHOD_BUFFERED, FILE_ANY_ACCESS) + +#define IOCTL_VIDEO_LOAD_AND_SET_FONT \ + CTL_CODE(FILE_DEVICE_VIDEO, 0x105, METHOD_BUFFERED, FILE_ANY_ACCESS) + +#define IOCTL_VIDEO_SET_PALETTE_REGISTERS \ + CTL_CODE(FILE_DEVICE_VIDEO, 0x106, METHOD_BUFFERED, FILE_ANY_ACCESS) +#define IOCTL_VIDEO_SET_COLOR_REGISTERS \ + CTL_CODE(FILE_DEVICE_VIDEO, 0x107, METHOD_BUFFERED, FILE_ANY_ACCESS) + +#define IOCTL_VIDEO_ENABLE_CURSOR \ + CTL_CODE(FILE_DEVICE_VIDEO, 0x108, METHOD_BUFFERED, FILE_ANY_ACCESS) +#define IOCTL_VIDEO_DISABLE_CURSOR \ + CTL_CODE(FILE_DEVICE_VIDEO, 0x109, METHOD_BUFFERED, FILE_ANY_ACCESS) +#define IOCTL_VIDEO_SET_CURSOR_ATTR \ + CTL_CODE(FILE_DEVICE_VIDEO, 0x10a, METHOD_BUFFERED, FILE_ANY_ACCESS) +#define IOCTL_VIDEO_QUERY_CURSOR_ATTR \ + CTL_CODE(FILE_DEVICE_VIDEO, 0x10b, METHOD_BUFFERED, FILE_ANY_ACCESS) +#define IOCTL_VIDEO_SET_CURSOR_POSITION \ + CTL_CODE(FILE_DEVICE_VIDEO, 0x10c, METHOD_BUFFERED, FILE_ANY_ACCESS) +#define IOCTL_VIDEO_QUERY_CURSOR_POSITION \ + CTL_CODE(FILE_DEVICE_VIDEO, 0x10d, METHOD_BUFFERED, FILE_ANY_ACCESS) + +#define IOCTL_VIDEO_ENABLE_POINTER \ + CTL_CODE(FILE_DEVICE_VIDEO, 0x10e, METHOD_BUFFERED, FILE_ANY_ACCESS) +#define IOCTL_VIDEO_DISABLE_POINTER \ + CTL_CODE(FILE_DEVICE_VIDEO, 0x10f, METHOD_BUFFERED, FILE_ANY_ACCESS) +#define IOCTL_VIDEO_SET_POINTER_ATTR \ + CTL_CODE(FILE_DEVICE_VIDEO, 0x110, METHOD_BUFFERED, FILE_ANY_ACCESS) +#define IOCTL_VIDEO_QUERY_POINTER_ATTR \ + CTL_CODE(FILE_DEVICE_VIDEO, 0x111, METHOD_BUFFERED, FILE_ANY_ACCESS) +#define IOCTL_VIDEO_SET_POINTER_POSITION \ + CTL_CODE(FILE_DEVICE_VIDEO, 0x112, METHOD_BUFFERED, FILE_ANY_ACCESS) +#define IOCTL_VIDEO_QUERY_POINTER_POSITION \ + CTL_CODE(FILE_DEVICE_VIDEO, 0x113, METHOD_BUFFERED, FILE_ANY_ACCESS) +#define IOCTL_VIDEO_QUERY_POINTER_CAPABILITIES \ + CTL_CODE(FILE_DEVICE_VIDEO, 0x114, METHOD_BUFFERED, FILE_ANY_ACCESS) + +#define IOCTL_VIDEO_GET_BANK_SELECT_CODE \ + CTL_CODE(FILE_DEVICE_VIDEO, 0x115, METHOD_BUFFERED, FILE_ANY_ACCESS) + +#define IOCTL_VIDEO_MAP_VIDEO_MEMORY \ + CTL_CODE(FILE_DEVICE_VIDEO, 0x116, METHOD_BUFFERED, FILE_ANY_ACCESS) +#define IOCTL_VIDEO_UNMAP_VIDEO_MEMORY \ + CTL_CODE(FILE_DEVICE_VIDEO, 0x117, METHOD_BUFFERED, FILE_ANY_ACCESS) +#define IOCTL_VIDEO_QUERY_PUBLIC_ACCESS_RANGES \ + CTL_CODE(FILE_DEVICE_VIDEO, 0x118, METHOD_BUFFERED, FILE_ANY_ACCESS) +#define IOCTL_VIDEO_FREE_PUBLIC_ACCESS_RANGES \ + CTL_CODE(FILE_DEVICE_VIDEO, 0x119, METHOD_BUFFERED, FILE_ANY_ACCESS) + +#define IOCTL_VIDEO_QUERY_COLOR_CAPABILITIES \ + CTL_CODE(FILE_DEVICE_VIDEO, 0x11a, METHOD_BUFFERED, FILE_ANY_ACCESS) + +// +// New IOCTLs defined for product 1.0A +// + +#define IOCTL_VIDEO_SET_POWER_MANAGEMENT \ + CTL_CODE(FILE_DEVICE_VIDEO, 0x11b, METHOD_BUFFERED, FILE_ANY_ACCESS) +#define IOCTL_VIDEO_GET_POWER_MANAGEMENT \ + CTL_CODE(FILE_DEVICE_VIDEO, 0x11c, METHOD_BUFFERED, FILE_ANY_ACCESS) + +#define IOCTL_VIDEO_SHARE_VIDEO_MEMORY \ + CTL_CODE(FILE_DEVICE_VIDEO, 0x11d, METHOD_BUFFERED, FILE_ANY_ACCESS) +#define IOCTL_VIDEO_UNSHARE_VIDEO_MEMORY \ + CTL_CODE(FILE_DEVICE_VIDEO, 0x11e, METHOD_BUFFERED, FILE_ANY_ACCESS) + + +// +// Many of the video ICOTLs are modal. When ever the palette is set, or the +// cursor is set or queried, it is done for the current mode. +// +// Modal specifies that the operation is only valid within a mode. Once a +// set mode operation is performed, the state associated to the modal IOCTL +// has been destroyed or reinitialized. +// Non-modal IOCTLs have their state preserved across set-mode operations. +// +// Optional IOCTLs are IOCTLs the miniport can optionally support. If the +// miniport does not support the IOCTL, it should return the appropriate +// error status. +// Required IOCTLs must be implemented in a miniport in order for the system +// to system properly. +// +// IOCTL_VIDEO_ENABLE_VDM Non-Modal Private(1) +// IOCTL_VIDEO_DISABLE_VDM Non-Modal Private(1) +// IOCTL_VIDEO_REGISTER_VDM Non-Modal Private(1) +// +// IOCTL_VIDEO_SAVE_HARDWARE_STATE Non-Modal Required(2) +// IOCTL_VIDEO_RESTORE_HARDWARE_STATE Non-Modal Required(2) +// +// IOCTL_VIDEO_QUERY_AVAIL_MODES Non-Modal Required +// IOCTL_VIDEO_QUERY_NUM_AVAIL_MODES Non-Modal Required +// IOCTL_VIDEO_QUERY_CURRENT_MODE Modal Required +// IOCTL_VIDEO_SET_CURRENT_MODE Non-Modal Required +// IOCTL_VIDEO_RESET_DEVICE Non-Modal Required +// +// IOCTL_VIDEO_LOAD_AND_SET_FONT Modal Required(2) +// +// IOCTL_VIDEO_SET_PALETTE_REGISTERS Modal Required(2) +// IOCTL_VIDEO_SET_COLOR_REGISTERS Modal Required(3) +// +// IOCTL_VIDEO_ENABLE_CURSOR Modal Required(2) +// IOCTL_VIDEO_DISABLE_CURSOR Modal Required(2) +// IOCTL_VIDEO_SET_CURSOR_ATTR Modal Required(2) +// IOCTL_VIDEO_QUERY_CURSOR_ATTR Modal Required(2) +// IOCTL_VIDEO_SET_CURSOR_POSITION Modal Required(2) +// IOCTL_VIDEO_QUERY_CURSOR_POSITION Modal Required(2) +// +// IOCTL_VIDEO_ENABLE_POINTER Modal Optional +// IOCTL_VIDEO_DISABLE_POINTER Modal Optional +// IOCTL_VIDEO_SET_POINTER_ATTR Modal Optional +// IOCTL_VIDEO_QUERY_POINTER_ATTR Modal Optional +// IOCTL_VIDEO_SET_POINTER_POSITION Modal Optional +// IOCTL_VIDEO_QUERY_POINTER_POSITION Modal Optional +// IOCTL_VIDEO_QUERY_POINTER_CAPABILITIES Non-Modal Optional +// +// IOCTL_VIDEO_GET_BANK_SELECT_CODE Modal Required(2) +// +// IOCTL_VIDEO_MAP_VIDEO_MEMORY Special(4) Required +// IOCTL_VIDEO_UNMAP_VIDEO_MEMORY Non-Modal Required +// IOCTL_VIDEO_QUERY_PUBLIC_ACCESS_RANGES Non-Modal Optional +// IOCTL_VIDEO_FREE_PUBLIC_ACCESS_RANGES Non-Modal Optional +// +// IOCTL_VIDEO_QUERY_COLOR_CAPABILITIES Non-Modal Optional +// +// IOCTL_VIDEO_SET_POWER_MANAGEMENT Non-Modal Optional +// IOCTL_VIDEO_GET_POWER_MANAGEMENT Non-Modal Optional + +// +// (1) Private means the IOCTL is completely implemeted within the port driver +// and the miniport does not need to support it. +// +// (2) These Required functions are for "Vga Compatible" miniports. They are +// Optional for other, non vga-compatible (i.e frame buffers) drivers. +// VGA compatible means here that the miniport implements all the VGA +// functionality and that the VgaCompatible flag for the miniport in the +// registry parameters is turned on. +// +// (3) This IOCTL is required if the device has a color lookup table (also +// commonly called palette) the PALETTE IOCTL is used for VGA while the +// COLOR IOCTL is the more general IOCTL that is called by the display +// driver or application to set the colors in the devices internal +// lookup table +// +// (4) This IOCTL is both modal and non-modal. It should map all of video +// memory in the caller's address space. A set mode MUST NOT cause the +// video memory to change location - in this sense it is non-modal. +// However, this IOCTL returns the location size of the frame buffer within +// video memory, and the frame buffer size and location may vary from mode +// to mode - so that information is modal. +// + + +// +// Any IOCTL that returns information should return in the status block the +// size of the data returned. +// If the output buffer was too small, an error should be returned. +// +// +// +// + + + +// +// IOCTL_VIDEO_ENABLE_VDM +// IOCTL_VIDEO_DISABLE_VDM +// IOCTL_VIDEO_REGISTER_VDM +// +// These IOCTLs are used to enable or disable a VDM's access to the video +// hardware. This call will cause the real video frame buffer to be mapped +// into the VDM's address space and get the video validator connected to the +// V86 emulator for direct video register access. +// +// Information used by this function is passed using the following structure: +// + +typedef struct _VIDEO_VDM { + HANDLE ProcessHandle; +} VIDEO_VDM, *PVIDEO_VDM; + +// +//ProcessHandle - Handle to the process for which this request must be +// performed. This is required because the console calls the miniport on +// the behalf of the VDM process; we are not performing this request in +// the context of the current caller. +// + + +typedef struct _VIDEO_REGISTER_VDM { + ULONG MinimumStateSize; +} VIDEO_REGISTER_VDM, *PVIDEO_REGISTER_VDM; + +// +//MinimumStateSize - Output value determining the minimum size required to +// store the video hardware state when performing SAVE_HARDWARE_SATE or +// RESTORE_HARDWARE_STATE Ioctls. +// + + +// +// Second set of structures +// + +// +// These IOCTLs are used by the VDM and the console to communicate state +// changes between the VDM and the kernel video driver. +// +// IOCTL_VIDEO_SAVE_HARDWARE_STATE - +// IOCTL_VIDEO_RESTORE_HARDWARE_STATE - +// +// +// This structure is at the start of the block used when saving or restoring +// the state of the video hardware using ConsoleHardwareState(). +// the ULONG are offset to the location of the rest of the data. That data +// is stored within the same memory block pointed to by the +// VIDEO_HARDWARE_STATE structure, right after this header. +// +// Information used by this function is passed using the following structure: +// + +typedef struct _VIDEO_HARDWARE_STATE_HEADER { + ULONG Length; + UCHAR PortValue[0x30]; + ULONG AttribIndexDataState; + ULONG BasicSequencerOffset; + ULONG BasicCrtContOffset; + ULONG BasicGraphContOffset; + ULONG BasicAttribContOffset; + ULONG BasicDacOffset; + ULONG BasicLatchesOffset; + ULONG ExtendedSequencerOffset; + ULONG ExtendedCrtContOffset; + ULONG ExtendedGraphContOffset; + ULONG ExtendedAttribContOffset; + ULONG ExtendedDacOffset; + ULONG ExtendedValidatorStateOffset; + ULONG ExtendedMiscDataOffset; + ULONG PlaneLength; + ULONG Plane1Offset; + ULONG Plane2Offset; + ULONG Plane3Offset; + ULONG Plane4Offset; + ULONG VGAStateFlags; + ULONG DIBOffset; + ULONG DIBBitsPerPixel; + ULONG DIBXResolution; + ULONG DIBYResolution; + ULONG DIBXlatOffset; + ULONG DIBXlatLength; +} VIDEO_HARDWARE_STATE_HEADER, *PVIDEO_HARDWARE_STATE_HEADER; + +// +// defines for VGAStateFlags +// + +#define VIDEO_STATE_NON_STANDARD_VGA 0x00000001 +#define VIDEO_STATE_UNEMULATED_VGA_STATE 0x00000002 +#define VIDEO_STATE_PACKED_CHAIN4_MODE 0x00000004 + + +typedef struct _VIDEO_HARDWARE_STATE { + PVIDEO_HARDWARE_STATE_HEADER StateHeader; + ULONG StateLength; +} VIDEO_HARDWARE_STATE, *PVIDEO_HARDWARE_STATE; + +// +//Length - Length of the basic structure. Used for versioning purposes. The +// length field should be initialized to be equal to +// sizeof(VIDEO_HARDWARE_STATE_HEADER). +// +//PortValue - Array of entries containing the data values for port 3B0 through +// 3DF. +// +//AttribIndexDataState - State of the attribute index register. +// +//BasicSequencerOffset - Offset, in bytes, from the beginning of the structure, +// to an array of fields containing the register values for the basic +// sequencer register set of the VGA. +// +//BasicCrtContOffset - Offset, in bytes, from the beginning of the structure, +// to an array of fields containing the register values for the basic +// CRT register set of the VGA. +// +//BasicGraphContOffset - Offset, in bytes, from the beginning of the structure, +// to an array of fields containing the register values for the basic +// graphics controller register set of the VGA. +// +//BasicAttribContOffset - Offset, in bytes, from the beginning of the structure, +// to an array of fields containing the register values for the basic +// attribute controller register set of the VGA. +// +//BasicDacOffset - Offset, in bytes, from the beginning of the structure, +// to an array of fields containing the register values for the basic +// DAC registers of the VGA. +// +//BasicLatchesOffset - Offset, in bytes, from the beginning of the structure, +// to an array of fields containing the register values for the basic +// latches of the VGA. +// +//ExtendedSequencerOffset - Offset, in bytes, from the beginning of the structure, +// to an array of fields containing the registers values for the extended +// sequencer register set of the VGA. +// +//ExtendedCrtContOffset - Offset, in bytes, from the beginning of the structure, +// to an array of fields containing the registers values for the extended +// CRT register set of the VGA. +// +//ExtendedGraphContOffset - Offset, in bytes, from the beginning of the structure, +// to an array of fields containing the registers values for the extended +// graphics controller register set of the VGA. +// +//ExtendedAttribContOffset - Offset, in bytes, from the beginning of the structure, +// to an array of fields containing the registers values for the extended +// attribute controller register set of the VGA. +// +//ExtendedDacOffset - Offset, in bytes, from the beginning of the structure, +// to an array of fields containing the registers values for the extended +// DAC registers of the VGA. +// +//ExtendedValidatorStateOffset - Offset, in bytes, from the beginning of the +// structure, to an area reserved for the miniport to put the unemulated +// save state that the miniport uses to perform instruction validation for +// DOS apps. +// +//ExtendedMiscDataOffset - Offset, in bytes, from the beginning of the structure, +// to an area reserved for the use of the miniport. +// +//PlaneLength - Length of each of the following plane (if present) +// +//Plane1Offset - Offset, in bytes, from the beginning of the structure, to an +// array of fields containing the data of the first plane of video memory. +// +//Plane2Offset - Offset, in bytes, from the beginning of the structure, to an +// array of fields containing the data of the second plane of video memory. +// +//Plane3Offset - Offset, in bytes, from the beginning of the structure, to an +// array of fields containing the data of the third plane of video memory. +// +//Plane4Offset - Offset, in bytes, from the beginning of the structure, to an +// array of fields containing the data of the fourth plane of video memory. +// +//VGAStateFlags - Flags used for the interpretation of the VGA state. +// VIDEO_STATE_NON_STANDARD_VGA is set when the set of registers the VGA +// returns is not the basic set (all super vga's are not standard). +// The VDM should not emulate the saved state unless a specific VDD +// has been written for the device. +// VIDEO_STATE_UNEMULATED_VGA_STATE specified the miniport has stored +// informaiton in the ExtendedValidatorState field and the miniport +// should treat this as a frozen state, whatever the registers say. +// VIDEO_STATE_PACKED_CHAIN4_MODE indicates that in mode 13 (320x200x256). +// the data is stored in a packed pixel format in the plane, as +// opposed to the standard VGA format where the data is interleaved +// at every four bytes, and on every 16K boundary, offset by one +// extra byte. +// +//DIBOffset - Offset to the location of the DIB in the allocated data +// structure. If NULL, no translation is available. +// +//DIBBitsPerPixel - Format of the DIB. +// +//DIBXResolution - Width of the DIB in pixels. +// +//DIBYResolution - Height of the DIB in pixels. +// +//DIBXlatOffset - Offset to the location of the translation vector +// from DIB pixel values to 32-bit RGB (1 byte red, 1 byte green, 1 byte +// blue, 1 byte empty). Maximum length 256. If NULL, the standard +// VGA palette stored in this structure should be used. +// +//DIBXlatLength - Length of the RGB translation vector at DIBXlatOffset. +// +// For each of the offset fields, if an offset value is NULL, then there is +// no data for that offset. +// The length of a data area is: +// 1) the specific length given to it : plane length (planes) or XResolution * +// Yresolution * BitsPerPel (DIB) +// 2) otherwise, the length = next_non-null_offset_value - +// current_offset_value +// + +// +//StateHeader - Pointer to the VIDEO_HARDWARE_STATE_HEADER structure. +// +//StateLength - Size of the VIDEO_HARDWARE_STATE_HEADER structure. +// + +// +// IOCTL_VIDEO_QUERY_NUM_AVAIL_MODES - Returns number of different modes +// available on the controller. +// +// Information used by this function is passed using the following structure: +// + +typedef struct _VIDEO_NUM_MODES { + ULONG NumModes; + ULONG ModeInformationLength; +} VIDEO_NUM_MODES, *PVIDEO_NUM_MODES; + +// +//NumModes - Returns the number of modes supported by the kernel driver. +// +//ModeInformationLength - Length of the VIDEO_MODE_INFORMATION structure +// for the IOCTL_VIDEO QUERY_AVAILABLE_MODES IOCTL. + + +// +// IOCTL_VIDEO_SET_CURRENT_MODE - Is used to set the mode of the controller. +// +// Information used by this function is passed using the following structure: +// + +typedef struct _VIDEO_MODE { + ULONG RequestedMode; +} VIDEO_MODE, *PVIDEO_MODE; + +#define VIDEO_MODE_NO_ZERO_MEMORY 0x80000000 // High order bit of the mode + // determines if the set mode + // should (0) or should not (1) + // cause the video memory to be + // zeroed out simultaneously to + // the set mode operation. + +#define VIDEO_MODE_MAP_MEM_LINEAR 0x40000000 // Miniports which support this + // flag will set a linear mode + // if possible when this flag + // is set. Note: Some miniports + // may return a linear mode even + // if this flag is not set. + + +// +//RequestedMode - Indicates in which mode the adapter should be initialized. +// + + +// +// IOCTL_VIDEO_RESET_DEVICE - Is used to reset the mode of the adapter when GDI +// gives up control of the device to allow a VDM to +// access the hardware. x86 only. +// The default mode should be whatever is the +// default mode when the machine is booted +// +// No information is needed fo this function. +// + + + +// +// IOCTL_VIDEO_QUERY_AVAIL_MODES - Returns information about each available +// mode on the controller. +// +// IOCTL_VIDEO_QUERY_CURRENT_MODE - Returns the information for the current +// controller mode. +// +// Information used by this function is passed using the following structure: +// +// NOTE This structure is matched exactly with the DISP_MODE structure +// in winddi.h - every change to this structure MUST be made to the +// structure in winddi.h. +// + +typedef struct _VIDEO_MODE_INFORMATION { + ULONG Length; + ULONG ModeIndex; + ULONG VisScreenWidth; + ULONG VisScreenHeight; + ULONG ScreenStride; + ULONG NumberOfPlanes; + ULONG BitsPerPlane; + ULONG Frequency; + ULONG XMillimeter; + ULONG YMillimeter; + ULONG NumberRedBits; + ULONG NumberGreenBits; + ULONG NumberBlueBits; + ULONG RedMask; + ULONG GreenMask; + ULONG BlueMask; + ULONG AttributeFlags; + ULONG VideoMemoryBitmapWidth; + ULONG VideoMemoryBitmapHeight; + ULONG DriverSpecificAttributeFlags; +} VIDEO_MODE_INFORMATION, *PVIDEO_MODE_INFORMATION; + +// +// Bit definitions for Attribute Flags +// + +#define VIDEO_MODE_COLOR 0x0001 // 0 = Mono-compatible, 1 = Color +#define VIDEO_MODE_GRAPHICS 0x0002 // 0 = Text mode, 1 = Graphics +#define VIDEO_MODE_PALETTE_DRIVEN 0x0004 // 0 = Colors are direct + // 1 = Colors are index to a palette +#define VIDEO_MODE_MANAGED_PALETTE 0x0008 // 0 = Palette is fixed (must be + // queried from miniport + // 1 = Palette is settable. +#define VIDEO_MODE_INTERLACED 0x0010 // 1 = Mode is interlaced + // 0 = non-interlaced +#define VIDEO_MODE_NO_OFF_SCREEN 0x0020 // 1 = Offscreen memory CAN NOT be + // used to store information. + // 0 = Offscreen memory is available +#define VIDEO_MODE_NO_64_BIT_ACCESS 0x0040 // 1 = 64 bit memory writes to frame + // buffer are not handled properly. + // 0 = 64 bit memory writes to frame + // buffer are handled properly. + +// +//Length - Length of the structure in bytes. Also used to do verisioning. +// +//ModeIndex - Number used to set this mode when calling the miniport driver. +// +//VisScreenWidth - Number of visible horizontal pixels on a scan line +// +//VisScreenHeight - Number of visible lines (or scan lines) +// +//ScreenStride - Delta, in *BYTES*, between the start of two scan lines. +// +// NOTE: the width and height are in pixels, but the stride is in bytes !!! +// +//NumberOfPlanes - Number of separate planes combined by the device. +// +//BitsPerPlane - Number of bits per pixel on a plane. +// +//Frequency - Screen Frequency, in Hertz. +// +//XMillimeter - Size of the horizontal active region on the output device, +// in millimeters. +// +//YMillimeter - Size of the vertical active region on the output device, +// in millimeters. +// +//NumberRedBits - Number of bits in the red DAC. +// +//NumberGreenBits - Number of bits in the green DAC. +// +//NumberBlueBits - Number of bits in the blue DAC. +// +//RedMask - Red color Mask for device with direct color modes. Bits turned +// on indicate the bit is of color Red. +// +//GreenMask - Green color Mask for device with direct color modes. Bits +// turned on indicate the bit is of color Green. +// +//BlueMask - Blue color Mask for device with direct color modes. Bits +// turned on indicate the bit is of color Blue. +// +//AttributeFlags. Flags indicating certain behavior for the device. +// +//VideoMemoryBitmapWidth - Width of the video memory bitmap. +// VisScreenWidth <= VideoMemoryBitmapWidth <= ScreenStride +// +//VideoMemoryBitmapHeight - Height of the video memory bitmap. +// VisScreenHeight <= VideoMemoryBitmapHeight = VideoRamLength / ScreenStride +// +//DriverSpecificAttributeFlags - Flags indicating certain behavior for the +// device that are private to the miniport\display driver. +// + + +// +// IOCTL_VIDEO_LOAD_AND_SET_FONT - Is used to load a user-defined font. +// +// Information used by this function is passed using the following structure: +// + +typedef struct _VIDEO_LOAD_FONT_INFORMATION { + USHORT WidthInPixels; + USHORT HeightInPixels; + ULONG FontSize; + UCHAR Font[1]; +} VIDEO_LOAD_FONT_INFORMATION, *PVIDEO_LOAD_FONT_INFORMATION; + +// +//WidthInPixels - Width of the characters in the font, in pixels. +// +//HeigthInPixels - Heigth of the characters in the font, in pixels. +// +//FontSize - Size of the font buffer being passed in, in bytes. +// +//Font - Start of the font buffer. +// + + +// +// IOCTL_VIDEO_SET_PALETTE_REGISTERS - Takes buffer containing +// VIDEO_PALETTE_DATA where Colors[] +// specifies the array containing the +// color values for the palette registers. +// +// Information used by this function is passed using the following structure: +// +// NOTE: This should only be used by the VGA type drivers +// + +typedef struct _VIDEO_PALETTE_DATA { + USHORT NumEntries; + USHORT FirstEntry; + USHORT Colors[1]; +} VIDEO_PALETTE_DATA, *PVIDEO_PALETTE_DATA; + +// +//NumEntries - Number of entries in the array of color values. +// +//FirstEntry - Location in the device palette to which the first entry in the +// list of colors should be copied to. The other entries in the color list +// should be copied sequentially, from this starting point into the device's +// palette. +// +//Colors - Array of color entries to copy into the device's color palette. +// + +// +// IOCTL_VIDEO_SET_COLOR_REGISTERS - Takes buffer containing VIDEO_CLUT. +// +// Information used by this function is passed using the following structure: +// + +typedef struct _VIDEO_CLUTDATA { + UCHAR Red; + UCHAR Green; + UCHAR Blue; + UCHAR Unused; +} VIDEO_CLUTDATA, *PVIDEO_CLUTDATA; + +// +//Red - Bits to be put in the Red portion of the color registers. +// +//Green - Bits to be put in the Green portion of the color registers. +// +//Blue - Bits to be put in the Blue portion of the color registers. +// + +typedef struct { + USHORT NumEntries; + USHORT FirstEntry; + union { + VIDEO_CLUTDATA RgbArray; + ULONG RgbLong; + } LookupTable[1]; +} VIDEO_CLUT, *PVIDEO_CLUT; + +// +//NumEntries - Number of entries in the LookupTable of color values. +// +//FirstEntry - Location in the device palette to which the first entry in the +// LookupTable of colors should be copied to. The other entries in the +// LookupTable should be copied sequentially, from this starting point into +// the device's palette. +// +//LookupTable - Array of color entries to copy into the device's color +// registers/palette. The color entries can be accessed as a genric 32 bit +// value or as Red/Green/Blue/Unused fields. +// + +// +// NOTE: Cursor vs. Pointer: +// A cursor is a rectangular set of pixels which are used to indicate the +// location of input coming from the keyboard. +// +// A pointer is the set of pixels that are used to paint the shape +// associated with the mouse. +// + +// +// IOCTL_VIDEO_QUERY_CURSOR_POSITION - Returns the location of the cursor on +// the screen. +// +// IOCTL_VIDEO_SET_CURSOR_POSITION - Is used to set the location of the +// cursor on the screen. +// +// Information used by this function is passed using the following structure: +// + +typedef struct _VIDEO_CURSOR_POSITION { + SHORT Column; + SHORT Row; +} VIDEO_CURSOR_POSITION, *PVIDEO_CURSOR_POSITION; + +// +//Column - Column on which the cursor is located from the top left, in pixels. +// +//Row - Row on which the cusor is located from the top left, in pixels. +// + + +// +// IOCTL_VIDEO_QUERY_CURSOR_ATTR - Returns all attributes of the cursor. +// +// IOCTL_VIDEO_SET_CURSOR_ATTR - Is used to set the attributes of the cursor. +// +// Information used by this function is passed using the following structure: +// + +// +// For the VGA: +// TopScanLine will be stored in the height when an IOCTL is made +// BottomScanLine will be stored in the width when an IOCTL is made +// + +typedef struct _VIDEO_CURSOR_ATTRIBUTES { + USHORT Width; + USHORT Height; + SHORT Column; + SHORT Row; + UCHAR Rate; + UCHAR Enable; +} VIDEO_CURSOR_ATTRIBUTES, *PVIDEO_CURSOR_ATTRIBUTES; + +// +//Width - Width of the cursor, in pixels. +// +//Height - Height of the cursor, in scans. +// +//Column - Column on which the cursor is located from the top left, in pixels. +// +//Row - Row on which the cusor is located from the top left, in pixels. +// +//Rate - Rate at which the cursor whould flash. +// +//Enable - Non-zero to display cursor, 0 not to display. +// + +// +// IOCTL_VIDEO_QUERY_POINTER_POSITION - Returns the location of the pointer +// on the screen +// +// IOCTL_VIDEO_SET_POINTER_POSITION - Is used to set the location of the +// pointer on the screen. +// +// Information used by this function is passed using the following structure: +// + +typedef struct _VIDEO_POINTER_POSITION { + SHORT Column; + SHORT Row; +} VIDEO_POINTER_POSITION, *PVIDEO_POINTER_POSITION; + +// +//Column - Column on which the cursor is located from the top left, in pixels. +// +//Row - Row on which the cusor is located from the top left, in pixels. +// + + +// +// IOCTL_VIDEO_QUERY_POINTER_ATTR - Returns all attributes of the pointer. +// +// IOCTL_VIDEO_SET_POINTER_ATTR - Is used to set the attributes of the +// pointer. +// +// Information used by this function is passed using the following structure: +// + +typedef struct _VIDEO_POINTER_ATTRIBUTES { + ULONG Flags; + ULONG Width; + ULONG Height; + ULONG WidthInBytes; + ULONG Enable; + SHORT Column; + SHORT Row; + UCHAR Pixels[1]; +} VIDEO_POINTER_ATTRIBUTES, *PVIDEO_POINTER_ATTRIBUTES; + +// +//Flags - color or mono pointer, same as for query pointer capabilities. +// +//Width - Width of the pointer, in pixels. +// +//Height - Height of the pointer, in scans. +// +//WidthInBytes - Width of the pointer, in bytes. +// +//Enable - Non-zero to display pointer, 0 not to display. +// +//Column - Column on which the cursor is located from the top left, in pixels. +// +//Row - Row on which the cusor is located from the top left, in pixels. +// +//Pixels - Start of pointer data, in device-compatible DIB format. +// (Mask data is always in 1-bpp DIB format.) +// + + +// +// IOCTL_VIDEO_QUERY_POINTER_CAPABILITIES - Returns capabilities of miniport +// hardware cursor +// + +typedef struct _VIDEO_POINTER_CAPABILITIES { + ULONG Flags; + ULONG MaxWidth; + ULONG MaxHeight; + ULONG HWPtrBitmapStart; + ULONG HWPtrBitmapEnd; +} VIDEO_POINTER_CAPABILITIES, *PVIDEO_POINTER_CAPABILITIES; + +// +// Flag bit definitions +// + +#define VIDEO_MODE_ASYNC_POINTER 0x01 // 1 if the cursor can be updated + // asynchronously to drawing operations. +#define VIDEO_MODE_MONO_POINTER 0x02 // 1 if a monochrome hardware pointer + // is supported. +#define VIDEO_MODE_COLOR_POINTER 0x04 // 1 if a color hardware pointer is + // supported. +#define VIDEO_MODE_ANIMATE_START 0x08 // The pointer being passed down has +#define VIDEO_MODE_ANIMATE_UPDATE 0x10 // the same hotspot as the previous + // pointer + +// +//MaxWidth - Widest pointer bitmap the miniport should be requested to load +// for either monochrome or color pointer. +// +//MaxHeight - widest pointer bitmap the miniport should be requested to load +// for either monochrome color pointer handled. +// +//HWPtrBitmapStart = first offset in bitmap of memory used to store hardware +// pointer bitmap, in CPU-addressable units (-1 if not applicable). For +// planar modes (like VGA mode 12h), this is a planar offset; for linear +// modes (like VGA mode 13h), this is a linear offset. The CPU-addressable +// translation in HC planar mode is assumed to be linearaddress/4, +// because there are four planes at each address. +// +//HWPtrBitmapEnd = last offset in bitmap of memory used to store hardware +// pointer bitmap (-1 if not applicable). +// +// Note: Miniport has options to reject any call to set a pointer. +// + + +// +// IOCTL_VIDEO_GET_BANK_SELECT_CODE - Called by the Windows display driver +// to get a block of executable code used +// to perform bank-switching in high +// resolution SVGA drivers. +// +// Gets information needed to implement banking control for a selected mode. +// +// Information used by this function is passed using the following structures: +// + +// +// The input from the caller in the input buffer is a VIDEO_MODE structure, as +// described under IOCTL_VIDEO_SET_CURRENT_MODE. +// +// RequestedMode - mode index for which banking information is desired. +// + +// +// Returned in output buffer. +// + +typedef struct _VIDEO_BANK_SELECT { + ULONG Length; + ULONG Size; + ULONG BankingFlags; + ULONG BankingType; + ULONG PlanarHCBankingType; + ULONG BitmapWidthInBytes; + ULONG BitmapSize; + ULONG Granularity; + ULONG PlanarHCGranularity; + ULONG CodeOffset; + ULONG PlanarHCBankCodeOffset; + ULONG PlanarHCEnableCodeOffset; + ULONG PlanarHCDisableCodeOffset; +} VIDEO_BANK_SELECT, *PVIDEO_BANK_SELECT; + +// +// Stored in the BankType and PlanarHCBankintType fields +// + +typedef enum _VIDEO_BANK_TYPE { + VideoNotBanked = 0, + VideoBanked1RW, + VideoBanked1R1W, + VideoBanked2RW, + NumVideoBankTypes +} VIDEO_BANK_TYPE, *PVIDEO_BANK_TYPE; + +// +// Defines for BankingFlags. +// + +#define PLANAR_HC 0x00000001 + +// +//Note: planar high-color ("planar HC") mode is a special 8-bpp-and-up +// CPU addressing mode in which four bytes can be accessed at +// once by using the VGA's planar hardware. This mode is enabled +// by turning off the Chain4 bit (bit 3 in Sequence Controller +// register 4), so it is also known as non-Chain4 mode. Planar HC +// mode can greatly accelerate operations such as solid fills, +// some pattern fills, and some blits. +// +//Note: the term "CPU-addressable bytes" means offsets measured +// in bytes as accessed by the CPU. In 16-color modes, this +// merely means "measured in bytes" rather than "measured in +// pixels," where each byte contains 8 pixels, as usual. +// In normal high-color modes, "CPU-addressable bytes" +// is exactly what you'd expect; it's the number of pixels in 256 +// color modes, pixels*2 in 16-bpp modes, and so on. However, in +// planar HC modes, there are four display memory bytes at every CPU- +// addressable byte, because four planes are at each address, so +// in 256 color modes the number of CPU-addressable bytes is +// pixels/4, in 16-bpp modes CPU-addressable bytes = pixels/2, and +// so on. Basically, "CPU-addressable bytes" just means the +// offsets the CPU needs to address banks properly in the +// specified mode. +// +//Note: the start address must be set to 0 (displayed pixels must +// start at offset 0 in display memory), and the banking windows +// must fit within the 64K area starting at A000:0; no 128K +// mappings, please, because there may be a monochrome adapter +// in the system. +// +//Length - Length of the basic structure. Used for versioning by checking the +// Length of the struct is at least as large as the value given by sizeof(). +// +//Size - number of bytes required to hold all banking information for +// this mode, including the VIDEO_BANK_SELECT structure and all +// bank-switch code. This is the size of the buffer that +// VgaGetBankSelectCode requires in order properly to return info. +// +//BankingFlags - indicate the type of banking supported in this mode. +// PLANAR_HC - if set, indicates that planar high-color (HC) mode +// (non-Chain4 8-, 15-, 16-, 24-, and 32-bpp) is supported. +// If this bit is set, the following fields must be filled in: +// PlanarHCGranularity, pPlanarHCBankCode, +// pPlanarHCEnableCode, pPlanarHCDisableCode. +// This bit is ignored by the 16-color driver, as are the +// associated fields. +// +//BankingType - These are the banking types supported by the adapter +// when it is ina standard mode. +// +// VideoNotBanked - this mode does not support or require banking. +// VideoBanked1RW - this mode supports a single RW (readable and +// writable) banking window. The window is assumed to be +// 64K in size. +// VideoBanked1R1W - this mode supports a single window, but the +// window can be mapped to different areas of display memory +// for reads and for writes. The window is assumed to be +// 64K in size. +// VideoBanked2RW - this mode supports two independently mappable +// banking windows, each RW. Each window is assumed to be +// 32K in size. The second window is assumed +// to start immediately after the end of the first, at +// A000:8000. +// +//PlanarHCBankingType - These are the banking types supported by the +// adapter when it is in a PLANAR HC mode. +// +// See BankingType for defintions of each banking type. +// +// +//BitmapWidthInBytes - distance from start of one scan line to start +// of next, counted in CPU-addressable bytes (not pixels). The +// CPU-addressable distance from one scan line to the next is +// assumed to be BitmapWidthInBytes/4 in planar HC modes, because +// there are four planes at each address. +// +//BitmapSize - size of display memory in CPU-addressable bytes (for +// example, 256K on a 1 Mb SVGA in 16-color mode, because there +// are four bytes at each address). The CPU-addressable bitmap +// size is assumed to be BitmapSize/4 in planar HC modes, because +// there are four planes at each address. +// +//Granularity - granularity with which display memory may be mapped +// into a banking window. (That is, resolution with which the +// display memory address mapped to the start of a window may be +// set; anywhere from 1K to 64K, depending on the adapter. If +// Granularity < window size (either 64K or 32K), then adjacent +// banks can overlap, and broken rasters can always be avoided. +// If Granularity == window size, then banks are disjoint, and +// display memory is basically segmented into banks.) Granularity +// is measured in CPU-addressable bytes. +// +//PlanarHCGranularity - granularity with which display memory may be +// mapped into a banking window in planar HC mode. +// PlanarHCGranularity is measured in CPU-addressable bytes, and +// is typically but not always Granularity/4. Ignored in +// 16-color modes. +// +//CodeOffset - base of the code section in the structure. +// +//PlanarHCBankCodeOffset - offset from Code of executable code +// that performs planar HC mode bank switching. Ignored in +// 16-color modes. +// +//PlanarHCEnableCodeOffset - offset from Code of executable code +// that enables planar HC mode. Ignored in 16-color modes. +// +//PlanarHCDisableCodeOffset - offset from Code of executable code +// that disables planar HC mode. Ignored in 16-color modes. +// +//Specification for bank switch code at Code: +// Executes requested bank mappings. +// +// Input: +// EAX = bank number to which to map window #0 +// EDX = bank number to which to map window #1 +// interpreted according to BankingType as follows: +// VideoBanked1RW - the single window is mapped to bank EAX, +// EBX is ignored. +// VideoBanked1RW - the read window is mapped to bank EAX, +// the write window is mapped to bank EBX +// VideoBanked1R1W - the window at A000:0 is mapped to bank EAX, +// the window at A800:0 is mapped to bank EBX +// +// Output: none +// +// Note: the definition of "bank n" is the bank that starts at +// display memory offset Granularity*n. In other words, +// banks are assumed to start every Granularity CPU-addressable +// bytes, and are numbered from 0 to number of banks-1. +// +//Specification for planar HC executable code: +// ***To be filled in when we get to planar HC modes*** +// + + +// +// IOCTL_VIDEO_MAP_VIDEO_MEMORY - Maps the frame buffer into the callers +// address space. +// IOCTL_VIDEO_UNMAP_VIDEO_MEMORY - Unmaps the frame buffer from the callers +// address space. +// +// Information used by this function is passed using the following structure: +// + +typedef struct _VIDEO_MEMORY { + PVOID RequestedVirtualAddress; +} VIDEO_MEMORY, *PVIDEO_MEMORY; + +// +//RequestedVirtualAddress - For MAP: Requested virtual address for the video +// memory. This value is optional. If zero is specified, the operating +// system will choose an appropriate location. For UNMAP: Virtual Address +// of the base of video memory. The size is implicit since it can not +// change (you can not add video memory dynamically!). +// + +// IOCTL_VIDEO_SHARE_VIDEO_MEMORY - Maps the frame buffer to another process' +// address space. This IOCTL is initally +// defined to support DCI. +// IOCTL_VIDEO_UNSHARE_VIDEO_MEMORY - Unmaps a previously shared buffer. +// +// Note: for the MAP_VIDEO_MEMORY_IOCTL, the process handle is passed in +// the VirtualAddress filed, while for this IOCTL the handle is explicit. +// + +typedef struct _VIDEO_SHARE_MEMORY { + HANDLE ProcessHandle; + ULONG ViewOffset; + ULONG ViewSize; + PVOID RequestedVirtualAddress; +} VIDEO_SHARE_MEMORY, *PVIDEO_SHARE_MEMORY; + +typedef struct _VIDEO_SHARE_MEMORY_INFORMATION { + ULONG SharedViewOffset; + ULONG SharedViewSize; + PVOID VirtualAddress; +} VIDEO_SHARE_MEMORY_INFORMATION, *PVIDEO_SHARE_MEMORY_INFORMATION; + + +// +// IOCTL_VIDEO_MAP_VIDEO_MEMORY - Returns the virtual address and size of +// the frame buffer and video memory in the +// caller's address space. +// This IOCTL must be called after a call +// to the MAP IOCTL has been made. +// + +typedef struct _VIDEO_MEMORY_INFORMATION { + PVOID VideoRamBase; + ULONG VideoRamLength; + PVOID FrameBufferBase; + ULONG FrameBufferLength; +} VIDEO_MEMORY_INFORMATION, *PVIDEO_MEMORY_INFORMATION; + +// +//VideoRamBase - Virtual address of the Video RAM in the callers address space +// (only valid if the memory is mapped. +// +//VideoRamLength - Linear length of the Video RAM in the caller's virtual +// address space (memory accessible through a bank switch mechanism is not +// described by this value). +// This value must be equal to VideoMemoryBitmapHeight * ScreenStride +// +//FrameBufferBase - Virtual address of the Frame Buffer in the caller's +// address space. The Frame buffer is the actively displayed part of Video +// Ram. +// +//FrameBufferLength - Linear length of the Frame Buffer in the caller's +// virtual address space (memory accessible through a bank switch mechanism +// is not described by this value). +// This value must be equal to VisScreenWidth * ScreenStride +// + + +// +// IOCTL_VIDEO_QUERY_PUBLIC_ACCESS_RANGES - Returns the access range used to +// program the hardware directly. +// An array of these is returned if +// multiple ranges exist. +// +// IOCTL_VIDEO_FREE_PUBLIC_ACCESS_RANGES - Frees up the access ranges that were +// allocated by the QUERY_ACCESS_RANGES +// call. +// +// Information used by this function is passed using the following structure: +// + +typedef struct _VIDEO_PUBLIC_ACCESS_RANGES { + ULONG InIoSpace; + ULONG MappedInIoSpace; + PVOID VirtualAddress; +} VIDEO_PUBLIC_ACCESS_RANGES, *PVIDEO_PUBLIC_ACCESS_RANGES; + +// +//InIoSpace - Indicates if the hardware registers or ports are in IO space +// or in memory space. +// +//MappedInIoSpace - Indicates if under the current platform the registers or +// ports are mapped in IO Space or memory space. +// +//VirtualAddress - Location of the registers or IO ports as mapped under the +// current architecture. +// + + +// +// IOCTL_VIDEO_QUERY_COLOR_CAPABILITIES - Returns the color information +// found in the monitors VDDPs +// description file. +// +// NOTE: This structure must be filled out completely. A subset of the +// values can not be returned. +// + +typedef struct _VIDEO_COLOR_CAPABILITIES { + ULONG Length; + ULONG AttributeFlags; + LONG RedPhosphoreDecay; + LONG GreenPhosphoreDecay; + LONG BluePhosphoreDecay; + LONG WhiteChromaticity_x; + LONG WhiteChromaticity_y; + LONG WhiteChromaticity_Y; + LONG RedChromaticity_x; + LONG RedChromaticity_y; + LONG GreenChromaticity_x; + LONG GreenChromaticity_y; + LONG BlueChromaticity_x; + LONG BlueChromaticity_y; + LONG WhiteGamma; + LONG RedGamma; + LONG GreenGamma; + LONG BlueGamma; +} VIDEO_COLOR_CAPABILITIES, *PVIDEO_COLOR_CAPABILITIES; + +// +// Flag Bit definitions +// + +#define VIDEO_DEVICE_COLOR 0x1 // Is this device support color (1) + // or monochrome only +#define VIDEO_OPTIONAL_GAMMET_TABLE 0x2 // Indicates that a gammet table can + // be queried/set for the device + // use other IOCTLs for that purpose. +// +//Length - Length of the basic structure. Used for versioning by checking the +// Length of the struct is at least as large as the value given by sizeof(). +// +//AttributesFlag - List of falgs determining some of the properties of the +// device. +// +//See the VDDP documentation for the details on the various fields +// +//RedPhosphoreDecay +//GreenPhosphoreDecay +//BluePhosphoreDecay - +// +//WhiteChromaticity_x +//WhiteChromaticity_y +//WhiteChromaticity_Y - +// +//RedChromaticity_x +//RedChromaticity_y +//GreenChromaticity_x +//GreenChromaticity_y +//BlueChromaticity_x +//BlueChromaticity_y - +// +//WhiteGamma - +// +//RedGamma +//GreenGamma +//BlueGamma - +// +//All values returned in this structure are integers. +//The values returned must be floating point values * 10,000; i.e: +//a gamma of 2.34 would be returned as 23400. +// + + + +// +// IOCTL_VIDEO_SET_POWER_MANAGEMENT - Tells the device to change the power +// consumption level of the device to the +// new state. +// IOCTL_VIDEO_GET_POWER_MANAGEMENT - Return the current power consumption +// level of the device. +// +// NOTE: +// This IOCTL is based on the VESA DPMS proposal. +// Changes to the DPMS standard will be refelcted in this IOCTL. +// + +typedef enum _VIDEO_POWER_STATE { + VideoPowerOn = 1, + VideoPowerStandBy, + VideoPowerSuspend, + VideoPowerOff +} VIDEO_POWER_STATE, *PVIDEO_POWER_STATE; + + +typedef struct _VIDEO_POWER_MANAGEMENT { + ULONG Length; + ULONG DPMSVersion; + ULONG PowerState; +} VIDEO_POWER_MANAGEMENT, *PVIDEO_POWER_MANAGEMENT; + +// +//Length - Length of the structure in bytes. Also used to do verisioning. +// +//DPMSVersion - Version of the DPMS standard supported by the device. +// Only used in the "GET" IOCTL. +// +//PowerState - One of the power states listed in VIDEO_POWER_STATE. +// + +// +// Note: +// Once the power has been turned off to the device, all other IOCTLs made +// to the miniport will be intercepted by the port driver and will return +// failiure, until the power on the device has been turned back on. +// + |