1324 lines
48 KiB
C
1324 lines
48 KiB
C
/*++ 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.
|
||
//
|
||
|