Microsoft/xbox-kernel
Microsoft/xbox-kernel
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
xbox-kernel/private/ntos/video/inc/video.h
Microsoft 9eec575c13 First commit
2020-09-30 17:17:25 +02:00

2065 lines
50 KiB
C
Raw Permalink Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/*++
Copyright (c) 1991-1999 Microsoft Corporation
Module Name:
video.h
Abstract:
Contains all structure and routine definitions common to the video port
driver and the video miniport drivers.
Notes:
Revision History:
--*/
#ifndef __VIDEO_H__
#define __VIDEO_H__
#include <videoagp.h>
//
// Define port driver status code.
// The values for these are the Win32 error codes
//
typedef LONG VP_STATUS;
typedef VP_STATUS *PVP_STATUS;
//
// Defines for registry information and synchronization.
//
typedef enum VIDEO_SYNCHRONIZE_PRIORITY {
VpLowPriority,
VpMediumPriority,
VpHighPriority
} VIDEO_SYNCHRONIZE_PRIORITY, *PVIDEO_SYNCHRONIZE_PRIORITY;
//
// Opaque pointer type for miniport to be used to type PEVENTs received from
// display driver.
//
typedef struct _VIDEO_PORT_EVENT * PEVENT;
//
// Type of information requested with GetDeviceData
//
typedef enum _VIDEO_DEVICE_DATA_TYPE {
VpMachineData,
VpCmosData,
VpBusData,
VpControllerData,
VpMonitorData
} VIDEO_DEVICE_DATA_TYPE, *PVIDEO_DEVICE_DATA_TYPE;
//
// Data returned with VpControllerData
//
typedef struct _VIDEO_HARDWARE_CONFIGURATION_DATA {
INTERFACE_TYPE InterfaceType;
ULONG BusNumber;
USHORT Version;
USHORT Revision;
USHORT Irql;
USHORT Vector;
ULONG ControlBase;
ULONG ControlSize;
ULONG CursorBase;
ULONG CursorSize;
ULONG FrameBase;
ULONG FrameSize;
} VIDEO_HARDWARE_CONFIGURATION_DATA, *PVIDEO_HARDWARE_CONFIGURATION_DATA;
//
// Define structure used to call the BIOS int 10 function
//
typedef struct _VIDEO_X86_BIOS_ARGUMENTS {
ULONG Eax;
ULONG Ebx;
ULONG Ecx;
ULONG Edx;
ULONG Esi;
ULONG Edi;
ULONG Ebp;
} VIDEO_X86_BIOS_ARGUMENTS, *PVIDEO_X86_BIOS_ARGUMENTS;
#define SIZE_OF_NT4_VIDEO_PORT_CONFIG_INFO 0x42
#define SIZE_OF_NT4_VIDEO_HW_INITIALIZATION_DATA 0x28
//
// Debugging statements. This will remove all the debug information from the
// "free" version.
//
#if DBG
#define VideoDebugPrint(arg) VideoPortDebugPrint arg
#else
#define VideoDebugPrint(arg)
#endif
//
// Allows us to remove lots of unused code.
//
#ifndef _NTOSDEF_
#define ALLOC_PRAGMA 1
#define VIDEOPORT_API __declspec(dllimport)
#if DBG
#define PAGED_CODE() \
if (VideoPortGetCurrentIrql() > 1 /*APC_LEVEL*/) { \
VideoPortDebugPrint(0, "Video: Pageable code called at IRQL %d\n", VideoPortGetCurrentIrql() ); \
ASSERT(FALSE); \
}
#else
#define PAGED_CODE()
#endif
ULONG
DriverEntry(
PVOID Context1
);
#else
#define VIDEOPORT_API
#endif
#ifndef _NTOS_
//
// These are the various function prototypes of the routines that are
// provided by the kernel driver to hook out access to io ports.
//
typedef
VP_STATUS
(*PDRIVER_IO_PORT_UCHAR ) (
ULONG_PTR Context,
ULONG Port,
UCHAR AccessMode,
PUCHAR Data
);
typedef
VP_STATUS
(*PDRIVER_IO_PORT_UCHAR_STRING ) (
ULONG_PTR Context,
ULONG Port,
UCHAR AccessMode,
PUCHAR Data,
ULONG DataLength
);
typedef
VP_STATUS
(*PDRIVER_IO_PORT_USHORT ) (
ULONG_PTR Context,
ULONG Port,
UCHAR AccessMode,
PUSHORT Data
);
typedef
VP_STATUS
(*PDRIVER_IO_PORT_USHORT_STRING ) (
ULONG_PTR Context,
ULONG Port,
UCHAR AccessMode,
PUSHORT Data,
ULONG DataLength // number of words
);
typedef
VP_STATUS
(*PDRIVER_IO_PORT_ULONG ) (
ULONG_PTR Context,
ULONG Port,
UCHAR AccessMode,
PULONG Data
);
typedef
VP_STATUS
(*PDRIVER_IO_PORT_ULONG_STRING ) (
ULONG_PTR Context,
ULONG Port,
UCHAR AccessMode,
PULONG Data,
ULONG DataLength // number of dwords
);
#endif // _NTOS_
//
// Definition of the request packet sent from the port driver to the
// miniport driver. It reflects the parameters passed from the
// DeviceIOControl call made by the windows display driver.
//
// N.B. The definition of the STATUS_BLOCK must be the same as the
// the definition of IO_STATUS_BLOCK defined in ntioapi.h.
//
typedef struct _STATUS_BLOCK {
//
// Contains the status code of the operation.
// This value in one of the Win32 error codes that are defined for use
// in the video miniport drivers.
//
union {
VP_STATUS Status;
PVOID Pointer;
};
//
// Information returned to the callee.
// The meaning of the information varies from function to function. It
// is generally used to return the minimum size for the input buffer if
// the function takes an input buffer, or the amount of data transfered
// back to the caller if the operation returns output.
//
ULONG_PTR Information;
} STATUS_BLOCK, *PSTATUS_BLOCK;
typedef struct _VIDEO_REQUEST_PACKET {
//
// The IO control code passed to the DeviceIoControl function by the
// caller.
//
ULONG IoControlCode;
//
// Pointer to a status block provided by the caller. This should be
// filled out by the callee with the appropriate information.
//
PSTATUS_BLOCK StatusBlock;
//
// Pointer to an input buffer which contains the information passed in
// by the caller.
//
PVOID InputBuffer;
//
// Size of the input buffer
//
ULONG InputBufferLength;
//
// Pointer to an output buffer into which the data returned to the caller
// should be stored.
//
PVOID OutputBuffer;
//
// Length of the output buffer. This buffer can not be grown by the
// callee.
//
ULONG OutputBufferLength;
} VIDEO_REQUEST_PACKET, *PVIDEO_REQUEST_PACKET;
//
// typedef for scattergather array available via GET_VIDEO_SCATTERGATHER().
//
typedef struct __VRB_SG {
__int64 PhysicalAddress;
ULONG Length;
} VRB_SG, *PVRB_SG;
//
// Opaque type for dma handle
//
typedef struct __DMA_PARAMETERS * PDMA;
//
// The following macro returns in Address the 32 bit physical address of
// the VirtualAddress lying within the InputBuffer passed into EngDevIo
//
#define GET_VIDEO_PHYSICAL_ADDRESS(scatterList, VirtualAddress, InputBuffer, pLength, Address) \
\
do { \
ULONG_PTR byteOffset; \
\
byteOffset = (PCHAR) VirtualAddress - (PCHAR)InputBuffer; \
\
while (byteOffset >= scatterList->Length) { \
\
byteOffset -= scatterList->Length; \
scatterList++; \
} \
\
*pLength = scatterList->Length - byteOffset; \
\
Address = (ULONG_PTR) (scatterList->PhysicalAddress + byteOffset); \
\
} while (0)
#define GET_VIDEO_SCATTERGATHER(ppDma) (**(PVRB_SG **)ppDma)
#define VIDEO_RANGE_PASSIVE_DECODE 0x1
#define VIDEO_RANGE_10_BIT_DECODE 0x2
//
// The following structure is used to define access ranges. The ranges are
// used to indicate which ports and memory adresses are being used by the
// card.
//
typedef struct _VIDEO_ACCESS_RANGE {
//
// Indicates the starting memory address or port number of the range.
// This values should be stored before being transformed by
// VideoPortGetDeviceBase() which returns the logical address that must
// be used by the miniport driver when referencing physical addresses.
//
PHYSICAL_ADDRESS RangeStart;
//
// Indicates the length in bytes, or number of ports in the range. This
// value should indicate the range actually decoded by the adapter. For
// example, if the adapter uses 7 registers but responds to eight, the
// RangeLength should be set to 8.
ULONG RangeLength;
//
// Indicates if the range is in IO space (TRUE) or in memory space (FALSE).
//
UCHAR RangeInIoSpace;
//
// Indicates if the range should be visible by the Windows display driver.
// This is done so that a Windows display driver can access certain
// video ports directly. This will only be allowed if the caller has the
// required privileges (is a trusted subsystem) to access the range.
//
// Synchronization of access to ports or memory in the range must be
// done explicitly by the miniport driver and the user mode process so
// that they both don't try to program the device simultaneously.
//
// Non visible ranges should include video memory, ROM addresses, etc.
// which are not required to program the device for output purposes.
//
//
UCHAR RangeVisible;
//
// This field determines if the range can be shared with another device.
// The rule should be applied as follow.
//
// - If the range of memory or IO ports should be "owned" by this driver,
// and that any other driver trying to access this range may cause
// a problem, FALSE should be returned.
//
// - If the range can be shared with another co-operating device driver,
// then the share field should be set to TRUE.
//
// As a guideline, the VGA miniport driver will claim all of its resources
// as shareable so that it can be used as a VGA compatible device with
// any other driver (such as an S3 or XGA.
//
// Super VGA miniport drivers that implement all the VGA functionality
// (declared in the Registry as VGACOMPATIBLE=1) should claim the range
// as non-shareable since they don't want the VGA to run at the same time.
//
// Miniports for cards such as an S3 or XGA that have an XGA on the board
// but do not implement the VGA functionality will run with the VGA
// miniport loaded and should therefore claim all the resources shared
// with the VGA as shareable.
//
// Miniports for cards that work with a pass-through and that can be
// connected to any VGA/SVGA card should not be using any VGA ports or
// memory ranges ! ... but if they do they should not claim those
// resources since they will cause a conflict in the system because the
// SVGA cards will have claimed them as non-shareable ...
//
UCHAR RangeShareable;
//
// Indicates that the range is decoded by the hardware, but that the
// driver will never access this port.
//
UCHAR RangePassive;
} VIDEO_ACCESS_RANGE, *PVIDEO_ACCESS_RANGE;
typedef
PVOID
(*PVIDEO_PORT_GET_PROC_ADDRESS)(
IN PVOID HwDeviceExtension,
IN PUCHAR FunctionName
);
//
// This structure contains the specific configuration information about the
// device. The information is initialized by the port driver and it should
// be completed by the miniport driver.
// The information is used to setup the device, as weel as providing
// information to the port driver so it can perform some of the requests on
// behalf of the miniport driver.
//
typedef struct _VIDEO_PORT_CONFIG_INFO {
//
// Specifies the length of the PVIDEO_PORT_CONFIG_INFO structure as
// returned by sizeof(). Since this structure may grow in later
// releases, the miniport driver should check that the length of the
// structure is greater than or equal to the length it expects (since
// it is guaranteed that defined fields will not change).
//
// This field is always initialized by the port driver.
//
ULONG Length;
//
// Specifies which IO bus is tp be scanned. This field is used as a
// parameter to some VideoPortXXX calls.
//
// This field is always initialized by the port driver.
//
ULONG SystemIoBusNumber;
//
// Specifies the type of bus being scanned. This field is equal to the
// value being passed into VideoPortInitialize in the
// VIDEO_HW_INITIALIZATION_DATA structure.
//
// This field is always initialized by the port driver.
//
INTERFACE_TYPE AdapterInterfaceType;
//
// Specifies the bus interrupt request level. This level corresponds to
// the IRQL on ISA and MCA buses.
// This value is only used if the device supports interrupts, which is
// determined by the presence of an interrupt service routine in the
// VIDEO_HW_INITIALIZATION_DATA structure.
//
// The preset default value for this field is zero. Otherwise, it is the
// value found in the device configuration information.
//
ULONG BusInterruptLevel;
//
// Specifies the bus vector returned by the adapter. This is used for
// systems which have IO buses that use interrupt vectors. For ISA, MCA
// and EISA buses, this field is unused.
//
// The preset default value for this field is zero.
//
ULONG BusInterruptVector;
//
// Specifies whether this adapter uses latched or edge-triggered type
// interrupts.
//
// This field is always initialized by the port driver.
//
KINTERRUPT_MODE InterruptMode;
//
// Specifies the number of emulator access entries that the adapter
// uses. It indicates the number of array elements in the following field.
//
// This field can be reinitialized with the number of entries in the
// EmulatorAccessEntries structure if the structure is statically
// defined in the miniport driver. The EmulatorAccessEntries fields
// should also be updated.
//
ULONG NumEmulatorAccessEntries;
//
// Supplies a pointer to an array of EMULATOR_ACCESS_ENTRY structures.
// The number of elements in the array is indicated by the
// NumEmulatorAccessEntries field. The driver should fill out each entry
// for the adapter.
//
// The uninitialized value for the structure is NULL.
// EmulatorAccessEntries will be NULL if NumEmulatorAccessEntries is
// zero.
//
// A poiner to an array of emulator access entries can be passed back
// if such a structure is defined statically in the miniport driver. The
// NumEmulatorAccessEntries field should also be updated.
//
PVOID EmulatorAccessEntries;
//
// This is a context values that is passed with each call to the
// emulator/validator functions defined in the EmulatorAccessEntries
// defined above.
// This parameter should in general be a pointer to the miniports
// device extension or other such storage location.
//
// This pointer will allow the miniport to save some state temporarily
// to allow for the batching of IO requests.
//
ULONG_PTR EmulatorAccessEntriesContext;
//
// Physical address of the video memory that must be mapped into a VDM's
// address space for proper BIOS support
//
PHYSICAL_ADDRESS VdmPhysicalVideoMemoryAddress;
//
// Length of the video memory that must be mapped into a VDM's addres
// space for proper BIOS support.
//
ULONG VdmPhysicalVideoMemoryLength;
//
// Determines the minimum size required to store the hardware state
// information returned by IOCTL_VIDEO_SAVE_HARDWARE_STATE.
//
// The uninitialized value for this field is zero.
//
// If the field is left to zero, SAVE_HARDWARE_STATE will return an
// ERROR_INVALID_FUNCTION status code.
//
ULONG HardwareStateSize;
//
// New for version 3.5
//
//
// Optional DMA channel, if required by the device.
// 0 for the Channel and Port indicates DMA is not used by the device.
//
ULONG DmaChannel;
//
// Optional DMA channel, if required by the device.
// 0 for the Channel and Port indicates DMA is not used by the device.
//
ULONG DmaPort;
//
// Set to 1 if the DMA channel can be shared with another device.
// Set to 0 if the DMA channel must be owned exclusively by the driver.
//
UCHAR DmaShareable;
//
// Set to 1 if the interrupt can be shared with another device.
// Set to 0 if the interrupt must be owned exclusively by the driver.
//
UCHAR InterruptShareable;
//
// Start new dma stuff
//
//
// Set to TRUE if the DMA device is a busmaster, FALSE otherwise.
//
BOOLEAN Master;
//
// Set to number of bits wide. Consistent with DEVICE_DESCRIPTION.
// See ntioapi.h
//
DMA_WIDTH DmaWidth;
//
// Set to speed so miniport can set DEVICE_DESCRIPTION field.
// See ntioapi.h
//
DMA_SPEED DmaSpeed;
//
// Set to TRUE if the DMA device requires mapped buffers. Also
// a DEVICE_DESCRIPTION field.
//
BOOLEAN bMapBuffers;
//
// Set to TRUE if the DMA device requires physical addresses.
//
BOOLEAN NeedPhysicalAddresses;
//
// Set to TRUE if the DMA device supports demand mode, FALSE otherwise.
// Also DEVICE_DESCRIPTION support.
//
BOOLEAN DemandMode;
//
// Set to max transfer length the DMA device supports.
//
ULONG MaximumTransferLength;
//
// Set to max number of Physical breaks the DMA device supports.
//
ULONG NumberOfPhysicalBreaks;
//
// Set to TRUE if the DMA device supports scatter gather, FALSE otherwise.
//
BOOLEAN ScatterGather;
//
// Maximal Length in PVRB_SG returned measured in bytes. If the device
// has no maximum size, zero should be entered.
//
ULONG MaximumScatterGatherChunkSize;
//
// Allow for 4.0/5.0 compatibilty
//
PVIDEO_PORT_GET_PROC_ADDRESS VideoPortGetProcAddress;
//
// Provide a pointer to the device's registry path
//
PWSTR DriverRegistryPath;
//
// Indicates to a driver the amount of physical memory in the system
//
ULONGLONG SystemMemorySize;
} VIDEO_PORT_CONFIG_INFO, *PVIDEO_PORT_CONFIG_INFO;
//
// Video Adapter Dependent Routines.
//
typedef
VP_STATUS
(*PVIDEO_HW_FIND_ADAPTER) (
PVOID HwDeviceExtension,
PVOID HwContext,
PWSTR ArgumentString,
PVIDEO_PORT_CONFIG_INFO ConfigInfo,
PUCHAR Again
);
typedef
BOOLEAN
(*PVIDEO_HW_INITIALIZE) (
PVOID HwDeviceExtension
);
typedef
BOOLEAN
(*PVIDEO_HW_INTERRUPT) (
PVOID HwDeviceExtension
);
typedef
VOID
(*PVIDEO_HW_LEGACYRESOURCES) (
IN ULONG VendorId,
IN ULONG DeviceId,
IN OUT PVIDEO_ACCESS_RANGE *LegacyResourceList,
IN OUT PULONG LegacyResourceCount
);
//
// type to be returned by HwStartDma().
//
typedef enum _HW_DMA_RETURN {
DmaAsyncReturn,
DmaSyncReturn
} HW_DMA_RETURN, *PHW_DMA_RETURN;
typedef
HW_DMA_RETURN
(*PVIDEO_HW_START_DMA) (
PVOID HwDeviceExtension,
PDMA pDma
);
//
// Flags to be passed into VideoPortLockPages() or VideoPortDoDma().
//
//
// The flag VideoPortUnlockAfterDma tells the video port to unlock the pages
// after the miniport signals that the dma is complete via the
// pDmaCompletionEvent in HwStartDma. Failure to set this event at
// dma completion may cause the memory to be unlocked at randon times.
// This flag is best used when one wants to do one dma transfer which
// occurs infrequently. It allows locking, dmaing and unlocking to be performed
// in the context of 1 IOCTL.
//
//
// The flag VideoPortKeepPagesLocked tells the video port to leave the pages
// locked if possible.
//
//
// The flag VideoPortDmaInitOnly tells the Video Port to lock the pages, but don't
// call HwStartDma. Not applicable to VideoPortDoDma().
//
typedef enum {
VideoPortUnlockAfterDma = 1,
VideoPortKeepPagesLocked,
VideoPortDmaInitOnly
} DMA_FLAGS;
//
// DMA Event flags
//
typedef ULONG DMA_EVENT_FLAGS;
#define SET_USER_EVENT 0x01
#define SET_DISPLAY_EVENT 0x02
//
// Child Enumeration structure passed in to the PVIDEO_HW_GET_CHILD_DESCRIPTOR
// function.
//
// All these parameters are input parameters and must not be modified by the
// callee
//
// Size - Size of the structure. It can be used by the calle for versioning.
//
// ChildDescriptorSize - Size of the pChildDescriptor buffer passed in as the
// third parameter to PVIDEO_HW_GET_CHILD_DESCRIPTOR.
//
// ChildIndex - Index of the device to be enumerated. This field should be
// used to enumerate devices not enumerated by ACPI or other operating
// system components. If this field is set to 0 it indicates the ACPIHwId
// field.
//
// ACPIHwId - ID returned by the ACPI BIOS that represent the device being
// queried. The ACPIHwId returned by the firmware must match the HwIds
// returned by the driver. The System BIOS manufacturer and the graphics
// IHV must synchronize these IDs.
//
// ChildHwDeviceExtension - Pointer to a device extension specific to this
// child device. This field will only be filled in if the miniport driver
// filled the ChildHwDeviceExtensionSize to be non-NULL.
//
typedef struct _VIDEO_CHILD_ENUM_INFO {
ULONG Size;
ULONG ChildDescriptorSize;
ULONG ChildIndex;
ULONG ACPIHwId;
PVOID ChildHwDeviceExtension;
} VIDEO_CHILD_ENUM_INFO, *PVIDEO_CHILD_ENUM_INFO;
//
// VIDEO_CHILD_TYPE enum:
//
// 'Monitor' identifies a device which may have a DDC2 compliant EDID data
// structure. If the video miniport detects such a device, it is to extract
// the edid from the monitor and put that in the paged buffer provided by
// videoprt.sys in the callback to PVIDEO_HW_GET_CHILD_DESCRIPTOR and return
// this type in the the OUT PVIDEO_CHILD_TYPE parameter of that call. This
// EDID, if available, will be written to the registry. If the EDID is not
// available, nothing should be put in the buffer.
//
// 'NonPrimaryChip' identifies another VGA chip on the video board which
// is not the primary VGA chip. This type is to be used if and only if the
// miniport detects more than one VGA chip on the board. Such an identifier
// will cause the videoprt to create another DEVICE_EXTENSION and associated
// HW_DEVICE_EXTENSION to be associated with the chip so identified.
//
// 'Other' identifies some other video device attached to the video card. If
// the miniport detects such a device, it is to put a wide char string
// (WSTR) into the paged buffer provided by the videoprt.sys which is the
// PNP hardware identifier of the device. This string will be used to create
// a value of that name in the registry.
//
typedef enum {
Monitor = 1,
NonPrimaryChip,
VideoChip,
Other
} VIDEO_CHILD_TYPE, *PVIDEO_CHILD_TYPE;
//
// define a constant that represents the display adapter self query.
//
#define DISPLAY_ADAPTER_HW_ID 0xFFFFFFFF
typedef struct _VIDEO_CHILD_STATE {
ULONG Id;
ULONG State;
} VIDEO_CHILD_STATE, *PVIDEO_CHILD_STATE;
typedef struct _VIDEO_CHILD_STATE_CONFIGURATION {
ULONG Count;
VIDEO_CHILD_STATE ChildStateArray[ANYSIZE_ARRAY];
} VIDEO_CHILD_STATE_CONFIGURATION, *PVIDEO_CHILD_STATE_CONFIGURATION;
//
// The following routine should return TRUE if successful. It should:
// 1) put the type of the child device in VideoChildType.
// 2) put the information from the device in Buffer. This
// buffer is of size 256 bytes. If the type returned in
// PVideoChildType is Monitor, this buffer must contain the
// EDID of the monitor if readable. If the type returned in
// PVideoChildType is Other, a wide character string representing
// the PNP Device Id must be put in the buffer. This string will
// be used to create a key for the device if the buffer contains
// an EDID. Otherwise, it is used to obtain a PNP ID for the
// device.
// 3) Put a miniport determined HANDLE in HwId. This value will be
// passed back to the miniport for Power management operations,
// as well as other operations. This allows the miniport to define
// the contract between the system and the miniport which defines a
// particular device.
//
// It should only return FALSE if there are no devices attached to that
// display adapter connector.
//
typedef
ULONG
(*PVIDEO_HW_GET_CHILD_DESCRIPTOR) (
IN PVOID HwDeviceExtension,
IN PVIDEO_CHILD_ENUM_INFO ChildEnumInfo,
OUT PVIDEO_CHILD_TYPE VideoChildType,
OUT PUCHAR pChildDescriptor,
OUT PULONG UId,
OUT PULONG pUnused
);
//
// This routine is used to set the power on the graphics devices.
// These include all the Children enumerated by GET_CHILD_DESCRIPTOR callback
// as well as the graphics adapter itself.
//
// The HwDevice extension represent the adapter instance of the device.
//
// The HwId parameter is the unique ID as returned by the enumeration routine.
// The miniport will only be called to set the power on the devices it
// enumerated, as well as the graphics adapter itself. A HwId of 0xFFFFFFFF
// will be passed in to identify the graphics adapter itself.
// The miniport driver should never turn off the power to the graphics adapter
// unless specifically request to.
//
// The VideoPowerControl is the level to which the device shold be set.
// The videoport driver will manage these states.
//
typedef
VP_STATUS
(*PVIDEO_HW_POWER_SET) (
PVOID HwDeviceExtension,
ULONG HwId,
PVIDEO_POWER_MANAGEMENT VideoPowerControl
);
//
// This routine simply returns whether or not the device can support the
// requested state.
//
// See HW_POWER_SET for a description of the parameters.
//
typedef
VP_STATUS
(*PVIDEO_HW_POWER_GET) (
PVOID HwDeviceExtension,
ULONG HwId,
PVIDEO_POWER_MANAGEMENT VideoPowerControl
);
//
// This structure should match the QueryInterface struct defined
// in io.h.
//
typedef struct _INTERFACE {
USHORT Size;
USHORT Version;
PVOID Context;
PINTERFACE_REFERENCE InterfaceReference;
PINTERFACE_DEREFERENCE InterfaceDereference;
// interface specific entries go here
} INTERFACE, *PINTERFACE;
typedef struct _QUERY_INTERFACE {
CONST GUID *InterfaceType;
USHORT Size;
USHORT Version;
PINTERFACE Interface;
PVOID InterfaceSpecificData;
} QUERY_INTERFACE, *PQUERY_INTERFACE;
typedef
VP_STATUS
(*PVIDEO_HW_QUERY_INTERFACE) (
PVOID HwDeviceExtension,
PQUERY_INTERFACE QueryInterface
);
typedef
VP_STATUS
(*PVIDEO_HW_CHILD_CALLBACK) (
PVOID HwDeviceExtension,
PVOID ChildDeviceExtension
);
//
// Entry point for all IOCTL calls made to the miniport driver.
//
typedef
BOOLEAN
(*PVIDEO_HW_START_IO) (
PVOID HwDeviceExtension,
PVIDEO_REQUEST_PACKET RequestPacket
);
//
// The return value determines if the mode was completely programmed (TRUE)
// or if an int10 should be done by the HAL to complete the modeset (FALSE).
//
typedef
BOOLEAN
(*PVIDEO_HW_RESET_HW) (
PVOID HwDeviceExtension,
ULONG Columns,
ULONG Rows
);
//
// Timer routine called every second.
//
typedef
VOID
(*PVIDEO_HW_TIMER) (
PVOID HwDeviceExtension
);
//
// Structure passed by the miniport entry point to the video port
// initialization routine.
//
typedef struct _VIDEO_HW_INITIALIZATION_DATA {
//
// Supplies the size of the structure in bytes as determined by sizeof().
//
ULONG HwInitDataSize;
//
// Indicates the bus type the adapter works with, such as Eisa, Isa, MCA.
//
INTERFACE_TYPE AdapterInterfaceType;
//
// Supplies a pointer to the miniport driver's find adapter routine.
//
PVIDEO_HW_FIND_ADAPTER HwFindAdapter;
//
// Supplies a pointer to the miniport driver's initialization routine.
//
PVIDEO_HW_INITIALIZE HwInitialize;
//
// Supplies a pointer to the miniport driver's interrupt service routine.
//
PVIDEO_HW_INTERRUPT HwInterrupt;
//
// Supplies a pointer to the miniport driver's start io routine.
//
PVIDEO_HW_START_IO HwStartIO;
//
// Supplies the size in bytes required for the miniport driver's private
// device extension. This storage is used by the miniport driver to hold
// per-adapter information. A pointer to this storage is provided with
// every call made to the miniport driver. This data storage is
// initialized to zero by the port driver.
//
ULONG HwDeviceExtensionSize;
//
// Supplies the number with which device numbering should be started.
// The device numbering is used to determine which \DeviceX entry under
// the \Parameters section in the registry should be used for parameters
// to the miniport driver.
// The number is *automatically* incremented when the miniport is called
// back in it's FindAdapter routine due to an appropriate _Again_
// parameter.
//
ULONG StartingDeviceNumber;
//
// New for version 3.5
//
//
// Supplies a pointer to the miniport driver's HwResetHw routine.
//
// This function is called when the machine needs to bugchecks (go back
// to the blue screen).
//
// This function should reset the video adapter to a character mode,
// or at least to a state from which an int 10 can reset the card to
// a character mode.
//
// This routine CAN NOT call int10.
// It can only call Read\Write Port\Register functions from the port driver.
//
// The function must also be completely in non-paged pool since the IO\MM
// subsystems may have crashed.
//
PVIDEO_HW_RESET_HW HwResetHw;
//
// Pointer to a timer routine to be called every second.
//
PVIDEO_HW_TIMER HwTimer;
//
// Start of 5.0 stuff.
//
//
// Supplies a pointer to the miniport driver's start dma routine. This routine must
// return a HW_DMA_RETURN consistent with it's return behavior.
//
PVIDEO_HW_START_DMA HwStartDma;
//
// HW dependent Power management routines.
//
PVIDEO_HW_POWER_SET HwSetPowerState;
PVIDEO_HW_POWER_GET HwGetPowerState;
//
// Supplies a pointer to a miniport driver routine which can be called to
// enumerate devices physically attached to the graphics adapter.
//
PVIDEO_HW_GET_CHILD_DESCRIPTOR HwGetVideoChildDescriptor;
//
// Supplies a pointer to a miniport driver routine which can be called to
// query external programming interfaces supported in the miniport
// driver.
//
PVIDEO_HW_QUERY_INTERFACE HwQueryInterface;
//
// Size of the device extension associated with the display output device.
// This should only be set (to the approrpiate size) if the miniport driver
// needs to manage the monitor configuration data separately from the
// adapter board configuration (example - multiple output graphics devices).
//
ULONG HwChildDeviceExtensionSize;
//
// Allows the device to report legacy resources that should be
// associated with the Plug and Play device.
//
PVIDEO_ACCESS_RANGE HwLegacyResourceList;
//
// Number of elements in the legacy resource list.
//
ULONG HwLegacyResourceCount;
//
// Call this routine to allow a driver to specify it's
// legacy resources based on its device/vendor id.
//
PVIDEO_HW_LEGACYRESOURCES HwGetLegacyResources;
//
// Can HwGetVideoChildDescriptor be called before HwInitialize?
//
BOOLEAN AllowEarlyEnumeration;
} VIDEO_HW_INITIALIZATION_DATA, *PVIDEO_HW_INITIALIZATION_DATA;
//
// DDC help routines.
//
typedef
VOID
(*PVIDEO_WRITE_CLOCK_LINE)(
PVOID HwDeviceExtension,
UCHAR Data
);
typedef
VOID
(*PVIDEO_WRITE_DATA_LINE)(
PVOID HwDeviceExtension,
UCHAR Data
);
typedef
BOOLEAN
(*PVIDEO_READ_CLOCK_LINE)(
PVOID HwDeviceExtension
);
typedef
BOOLEAN
(*PVIDEO_READ_DATA_LINE)(
PVOID HwDeviceExtension
);
typedef
VOID
(*PVIDEO_WAIT_VSYNC_ACTIVE)(
PVOID HwDeviceExtension
);
//
// Data structures used I2C and DDC helper functions.
//
typedef struct _I2C_FNC_TABLE
{
ULONG Size;
PVIDEO_WRITE_CLOCK_LINE WriteClockLine;
PVIDEO_WRITE_DATA_LINE WriteDataLine;
PVIDEO_READ_CLOCK_LINE ReadClockLine;
PVIDEO_READ_DATA_LINE ReadDataLine;
PVIDEO_WAIT_VSYNC_ACTIVE WaitVsync;
PVOID Reserved;
} I2C_FNC_TABLE, *PI2C_FNC_TABLE;
typedef struct _I2C_CALLBACKS
{
PVIDEO_WRITE_CLOCK_LINE WriteClockLine;
PVIDEO_WRITE_DATA_LINE WriteDataLine;
PVIDEO_READ_CLOCK_LINE ReadClockLine;
PVIDEO_READ_DATA_LINE ReadDataLine;
} I2C_CALLBACKS, *PI2C_CALLBACKS;
typedef struct _DDC_CONTROL
{
ULONG Size;
I2C_CALLBACKS I2CCallbacks;
UCHAR EdidSegment;
} DDC_CONTROL, *PDDC_CONTROL;
//
// Types of services exported by the VideoPortQueryServices().
//
typedef enum
{
VideoPortServicesAGP = 1,
VideoPortServicesI2C
} VIDEO_PORT_SERVICES;
//
// AGP services interface.
//
typedef struct _VIDEO_PORT_AGP_INTERFACE
{
USHORT Size;
USHORT Version;
PVOID Context;
PINTERFACE_REFERENCE InterfaceReference;
PINTERFACE_DEREFERENCE InterfaceDereference;
PAGP_RESERVE_PHYSICAL AgpReservePhysical;
PAGP_RELEASE_PHYSICAL AgpReleasePhysical;
PAGP_COMMIT_PHYSICAL AgpCommitPhysical;
PAGP_FREE_PHYSICAL AgpFreePhysical;
PAGP_RESERVE_VIRTUAL AgpReserveVirtual;
PAGP_RELEASE_VIRTUAL AgpReleaseVirtual;
PAGP_COMMIT_VIRTUAL AgpCommitVirtual;
PAGP_FREE_VIRTUAL AgpFreeVirtual;
ULONGLONG AgpAllocationLimit;
} VIDEO_PORT_AGP_INTERFACE, *PVIDEO_PORT_AGP_INTERFACE;
//
// I2C helper routines exported via VideoPortQueryServices().
//
typedef
BOOLEAN
(*PI2C_START)(
IN PVOID HwDeviceExtension,
IN PI2C_CALLBACKS I2CCallbacks
);
typedef
BOOLEAN
(*PI2C_STOP)(
IN PVOID HwDeviceExtension,
IN PI2C_CALLBACKS I2CCallbacks
);
typedef
BOOLEAN
(*PI2C_WRITE)(
IN PVOID HwDeviceExtension,
IN PI2C_CALLBACKS I2CCallbacks,
IN PUCHAR Buffer,
IN ULONG Length
);
typedef
BOOLEAN
(*PI2C_READ)(
IN PVOID HwDeviceExtension,
IN PI2C_CALLBACKS I2CCallbacks,
OUT PUCHAR Buffer,
IN ULONG Length
);
//
// I2C services interface.
//
typedef struct _VIDEO_PORT_I2C_INTERFACE
{
USHORT Size;
USHORT Version;
PVOID Context;
PINTERFACE_REFERENCE InterfaceReference;
PINTERFACE_DEREFERENCE InterfaceDereference;
PI2C_START I2CStart;
PI2C_STOP I2CStop;
PI2C_WRITE I2CWrite;
PI2C_READ I2CRead;
} VIDEO_PORT_I2C_INTERFACE, *PVIDEO_PORT_I2C_INTERFACE;
//
// Flags that can be passed to VideoPortGetDeviceBase or VideoPortMapMemory.
//
#define VIDEO_MEMORY_SPACE_MEMORY 0x00 // Should not be set by display driver
#define VIDEO_MEMORY_SPACE_IO 0x01 // Should not be set by display driver
#define VIDEO_MEMORY_SPACE_USER_MODE 0x02 // Memory pointer for application use
#define VIDEO_MEMORY_SPACE_DENSE 0x04 // Mapped dense, linearly (ALPHA)
#define VIDEO_MEMORY_SPACE_P6CACHE 0x08 // P6 MTRR caching (kernel and user)
//
// Define status codes returned by HwGetVideoChildDescriptor()
// miniport enumaration routine.
//
// Note: For backword compatibility reasons these values match
// existing WINERROR codes.
//
//
// Call again (ACPI and non-ACPI devices will be enumerated).
//
#define VIDEO_ENUM_MORE_DEVICES ERROR_CONTINUE
//
// Stop enumeration.
//
#define VIDEO_ENUM_NO_MORE_DEVICES ERROR_NO_MORE_DEVICES
//
// Call again, device could not be enumerated.
//
#define VIDEO_ENUM_INVALID_DEVICE ERROR_INVALID_NAME
//
// Define the bits in VgaStatus.
//
#define DEVICE_VGA_ENABLED 1
//
// Port driver routines called by miniport driver and callbacks.
//
VIDEOPORT_API
VP_STATUS
VideoPortAllocateBuffer(
IN PVOID HwDeviceExtension,
IN ULONG Size,
OUT PVOID *Buffer
);
VIDEOPORT_API
VOID
VideoPortAcquireDeviceLock(
IN PVOID HwDeviceExtension
);
VIDEOPORT_API
ULONG
VideoPortCompareMemory(
PVOID Source1,
PVOID Source2,
ULONG Length
);
VIDEOPORT_API
BOOLEAN
VideoPortDDCMonitorHelper(
IN PVOID HwDeviceExtension,
IN PVOID DDCControl,
IN OUT PUCHAR EdidBuffer,
IN ULONG EdidBufferSize
);
VIDEOPORT_API
VOID
VideoPortDebugPrint(
ULONG DebugPrintLevel,
PCHAR DebugMessage,
...
);
VIDEOPORT_API
VP_STATUS
VideoPortDisableInterrupt(
PVOID HwDeviceExtension
);
VIDEOPORT_API
VP_STATUS
VideoPortEnableInterrupt(
PVOID HwDeviceExtension
);
VIDEOPORT_API
VP_STATUS
VideoPortEnumerateChildren(
IN PVOID HwDeviceExtension,
IN PVOID Reserved
);
VIDEOPORT_API
VOID
VideoPortFreeDeviceBase(
PVOID HwDeviceExtension,
PVOID MappedAddress
);
typedef
VP_STATUS
(*PMINIPORT_QUERY_DEVICE_ROUTINE)(
PVOID HwDeviceExtension,
PVOID Context,
VIDEO_DEVICE_DATA_TYPE DeviceDataType,
PVOID Identifier,
ULONG IdentiferLength,
PVOID ConfigurationData,
ULONG ConfigurationDataLength,
PVOID ComponentInformation,
ULONG ComponentInformationLength
);
VIDEOPORT_API
VP_STATUS
VideoPortGetAccessRanges(
PVOID HwDeviceExtension,
ULONG NumRequestedResources,
PIO_RESOURCE_DESCRIPTOR RequestedResources OPTIONAL,
ULONG NumAccessRanges,
PVIDEO_ACCESS_RANGE AccessRanges,
PVOID VendorId,
PVOID DeviceId,
PULONG Slot
);
VIDEOPORT_API
PVOID
VideoPortGetAssociatedDeviceExtension(
IN PVOID DeviceObject
);
VIDEOPORT_API
ULONG
VideoPortGetBusData(
PVOID HwDeviceExtension,
BUS_DATA_TYPE BusDataType,
ULONG SlotNumber,
PVOID Buffer,
ULONG Offset,
ULONG Length
);
VIDEOPORT_API
UCHAR
VideoPortGetCurrentIrql();
VIDEOPORT_API
PVOID
VideoPortGetDeviceBase(
PVOID HwDeviceExtension,
PHYSICAL_ADDRESS IoAddress,
ULONG NumberOfUchars,
UCHAR InIoSpace
);
VIDEOPORT_API
VP_STATUS
VideoPortGetDeviceData(
PVOID HwDeviceExtension,
VIDEO_DEVICE_DATA_TYPE DeviceDataType,
PMINIPORT_QUERY_DEVICE_ROUTINE CallbackRoutine,
PVOID Context
);
typedef
VP_STATUS
(*PMINIPORT_GET_REGISTRY_ROUTINE)(
PVOID HwDeviceExtension,
PVOID Context,
PWSTR ValueName,
PVOID ValueData,
ULONG ValueLength
);
VIDEOPORT_API
VP_STATUS
VideoPortGetRegistryParameters(
PVOID HwDeviceExtension,
PWSTR ParameterName,
UCHAR IsParameterFileName,
PMINIPORT_GET_REGISTRY_ROUTINE GetRegistryRoutine,
PVOID Context
);
VIDEOPORT_API
PVOID
VideoPortGetRomImage(
IN PVOID HwDeviceExtension,
IN PVOID Unused1,
IN ULONG Unused2,
IN ULONG Length
);
VIDEOPORT_API
VP_STATUS
VideoPortGetVgaStatus(
PVOID HwDeviceExtension,
OUT PULONG VgaStatus
);
VIDEOPORT_API
LONG
FASTCALL
VideoPortInterlockedDecrement(
IN PLONG Addend
);
VIDEOPORT_API
LONG
FASTCALL
VideoPortInterlockedIncrement(
IN PLONG Addend
);
VIDEOPORT_API
LONG
FASTCALL
VideoPortInterlockedExchange(
IN OUT PLONG Target,
IN LONG Value
);
VIDEOPORT_API
ULONG
VideoPortInitialize(
PVOID Argument1,
PVOID Argument2,
PVIDEO_HW_INITIALIZATION_DATA HwInitializationData,
PVOID HwContext
);
VIDEOPORT_API
VP_STATUS
VideoPortInt10(
PVOID HwDeviceExtension,
PVIDEO_X86_BIOS_ARGUMENTS BiosArguments
);
VIDEOPORT_API
VOID
VideoPortLogError(
PVOID HwDeviceExtension,
PVIDEO_REQUEST_PACKET Vrp OPTIONAL,
VP_STATUS ErrorCode,
ULONG UniqueId
);
VIDEOPORT_API
VP_STATUS
VideoPortMapMemory(
PVOID HwDeviceExtension,
PHYSICAL_ADDRESS PhysicalAddress,
PULONG Length,
PULONG InIoSpace,
PVOID *VirtualAddress
);
VIDEOPORT_API
VOID
VideoPortMoveMemory(
PVOID Destination,
PVOID Source,
ULONG Length
);
VIDEOPORT_API
VP_STATUS
VideoPortQueryServices(
IN PVOID HwDeviceExtension,
IN VIDEO_PORT_SERVICES ServicesType,
IN OUT PINTERFACE Interface
);
typedef
VOID
(*PMINIPORT_DPC_ROUTINE)(
IN PVOID HwDeviceExtension,
IN PVOID Context
);
VIDEOPORT_API
BOOLEAN
VideoPortQueueDpc(
IN PVOID HwDeviceExtension,
IN PMINIPORT_DPC_ROUTINE CallbackRoutine,
IN PVOID Context
);
VIDEOPORT_API
UCHAR
VideoPortReadPortUchar(
PUCHAR Port
);
VIDEOPORT_API
USHORT
VideoPortReadPortUshort(
PUSHORT Port
);
VIDEOPORT_API
ULONG
VideoPortReadPortUlong(
PULONG Port
);
VIDEOPORT_API
VOID
VideoPortReadPortBufferUchar(
PUCHAR Port,
PUCHAR Buffer,
ULONG Count
);
VIDEOPORT_API
VOID
VideoPortReadPortBufferUshort(
PUSHORT Port,
PUSHORT Buffer,
ULONG Count
);
VIDEOPORT_API
VOID
VideoPortReadPortBufferUlong(
PULONG Port,
PULONG Buffer,
ULONG Count
);
VIDEOPORT_API
UCHAR
VideoPortReadRegisterUchar(
PUCHAR Register
);
VIDEOPORT_API
USHORT
VideoPortReadRegisterUshort(
PUSHORT Register
);
VIDEOPORT_API
ULONG
VideoPortReadRegisterUlong(
PULONG Register
);
VIDEOPORT_API
VOID
VideoPortReadRegisterBufferUchar(
PUCHAR Register,
PUCHAR Buffer,
ULONG Count
);
VIDEOPORT_API
VOID
VideoPortReadRegisterBufferUshort(
PUSHORT Register,
PUSHORT Buffer,
ULONG Count
);
VIDEOPORT_API
VOID
VideoPortReadRegisterBufferUlong(
PULONG Register,
PULONG Buffer,
ULONG Count
);
VIDEOPORT_API
VOID
VideoPortReleaseBuffer(
IN PVOID HwDeviceExtension,
IN PVOID Buffer
);
VIDEOPORT_API
VOID
VideoPortReleaseDeviceLock(
IN PVOID HwDeviceExtension
);
VIDEOPORT_API
BOOLEAN
VideoPortScanRom(
PVOID HwDeviceExtension,
PUCHAR RomBase,
ULONG RomLength,
PUCHAR String
);
VIDEOPORT_API
ULONG
VideoPortSetBusData(
PVOID HwDeviceExtension,
BUS_DATA_TYPE BusDataType,
ULONG SlotNumber,
PVOID Buffer,
ULONG Offset,
ULONG Length
);
VIDEOPORT_API
VP_STATUS
VideoPortSetRegistryParameters(
PVOID HwDeviceExtension,
PWSTR ValueName,
PVOID ValueData,
ULONG ValueLength
);
VIDEOPORT_API
VP_STATUS
VideoPortSetTrappedEmulatorPorts(
PVOID HwDeviceExtension,
ULONG NumAccessRanges,
PVIDEO_ACCESS_RANGE AccessRange
);
VIDEOPORT_API
VOID
VideoPortStallExecution(
ULONG Microseconds
);
VIDEOPORT_API
VOID
VideoPortStartTimer(
PVOID HwDeviceExtension
);
VIDEOPORT_API
VOID
VideoPortStopTimer(
PVOID HwDeviceExtension
);
typedef
BOOLEAN
(*PMINIPORT_SYNCHRONIZE_ROUTINE)(
PVOID Context
);
BOOLEAN
VIDEOPORT_API
VideoPortSynchronizeExecution(
PVOID HwDeviceExtension,
VIDEO_SYNCHRONIZE_PRIORITY Priority,
PMINIPORT_SYNCHRONIZE_ROUTINE synchronizeRoutine,
PVOID Context
);
VIDEOPORT_API
VP_STATUS
VideoPortUnmapMemory(
PVOID HwDeviceExtension,
PVOID VirtualAddress,
HANDLE ProcessHandle
);
VIDEOPORT_API
VP_STATUS
VideoPortVerifyAccessRanges(
PVOID HwDeviceExtension,
ULONG NumAccessRanges,
PVIDEO_ACCESS_RANGE AccessRanges
);
VIDEOPORT_API
VOID
VideoPortWritePortUchar(
PUCHAR Port,
UCHAR Value
);
VIDEOPORT_API
VOID
VideoPortWritePortUshort(
PUSHORT Port,
USHORT Value
);
VIDEOPORT_API
VOID
VideoPortWritePortUlong(
PULONG Port,
ULONG Value
);
VIDEOPORT_API
VOID
VideoPortWritePortBufferUchar(
PUCHAR Port,
PUCHAR Buffer,
ULONG Count
);
VIDEOPORT_API
VOID
VideoPortWritePortBufferUshort(
PUSHORT Port,
PUSHORT Buffer,
ULONG Count
);
VIDEOPORT_API
VOID
VideoPortWritePortBufferUlong(
PULONG Port,
PULONG Buffer,
ULONG Count
);
VIDEOPORT_API
VOID
VideoPortWriteRegisterUchar(
PUCHAR Register,
UCHAR Value
);
VIDEOPORT_API
VOID
VideoPortWriteRegisterUshort(
PUSHORT Register,
USHORT Value
);
VIDEOPORT_API
VOID
VideoPortWriteRegisterUlong(
PULONG Register,
ULONG Value
);
VIDEOPORT_API
VOID
VideoPortWriteRegisterBufferUchar(
PUCHAR Register,
PUCHAR Buffer,
ULONG Count
);
VIDEOPORT_API
VOID
VideoPortWriteRegisterBufferUshort(
PUSHORT Register,
PUSHORT Buffer,
ULONG Count
);
VIDEOPORT_API
VOID
VideoPortWriteRegisterBufferUlong(
PULONG Register,
PULONG Buffer,
ULONG Count
);
VIDEOPORT_API
VOID
VideoPortZeroDeviceMemory(
PVOID Destination,
ULONG Length
);
VIDEOPORT_API
VOID
VideoPortZeroMemory(
PVOID Destination,
ULONG Length
);
//
// DMA support.
// TODO: Move to the separate module -- will be obsolete.
//
VIDEOPORT_API
PVOID
VideoPortAllocateContiguousMemory(
IN PVOID HwDeviceExtension,
IN ULONG NumberOfBytes,
IN PHYSICAL_ADDRESS HighestAcceptableAddress
);
VIDEOPORT_API
PVOID
VideoPortGetCommonBuffer(
IN PVOID HwDeviceExtension,
IN ULONG DesiredLength,
IN ULONG Alignment,
OUT PPHYSICAL_ADDRESS LogicalAddress,
OUT PULONG pActualLength,
IN BOOLEAN CacheEnabled
);
VIDEOPORT_API
VOID
VideoPortFreeCommonBuffer(
IN PVOID HwDeviceExtension,
IN ULONG Length,
IN PVOID VirtualAddress,
IN PHYSICAL_ADDRESS LogicalAddress,
IN BOOLEAN CacheEnabled
);
VIDEOPORT_API
PDMA
VideoPortDoDma(
IN PVOID HwDeviceExtension,
IN PDMA pDma,
IN DMA_FLAGS DmaFlags
);
VIDEOPORT_API
BOOLEAN
VideoPortLockPages(
IN PVOID HwDeviceExtension,
IN OUT PVIDEO_REQUEST_PACKET pVrp,
IN PEVENT pUEvent,
IN PEVENT pDisplayEvent,
IN DMA_FLAGS DmaFlags
);
VIDEOPORT_API
BOOLEAN
VideoPortUnlockPages(
PVOID hwDeviceExtension,
PDMA pDma
);
VIDEOPORT_API
BOOLEAN
VideoPortSignalDmaComplete(
IN PVOID HwDeviceExtension,
IN PDMA pDmaHandle
);
VIDEOPORT_API
BOOLEAN
VideoPortCompleteDma(
IN PVOID HwDeviceExtension,
IN PDMA pDmaHandle,
IN DMA_EVENT_FLAGS CompletionFlags
);
VIDEOPORT_API
PVOID
VideoPortGetMdl(
IN PVOID HwDeviceExtension,
IN PDMA pDma
);
VIDEOPORT_API
PVOID
VideoPortGetDmaContext(
IN PVOID HwDeviceExtension,
IN PDMA pDma
);
VIDEOPORT_API
VOID
VideoPortSetDmaContext(
IN PVOID HwDeviceExtension,
OUT PDMA pDma,
IN PVOID InstanceContext
);
VIDEOPORT_API
ULONG
VideoPortGetBytesUsed(
IN PVOID HwDeviceExtension,
IN PDMA pDma
);
VIDEOPORT_API
VOID
VideoPortSetBytesUsed(
IN PVOID HwDeviceExtension,
IN OUT PDMA pDma,
IN ULONG BytesUsed
);
VIDEOPORT_API
PDMA
VideoPortAssociateEventsWithDmaHandle(
IN PVOID HwDeviceExtension,
IN OUT PVIDEO_REQUEST_PACKET pVrp,
IN PVOID MappedUserEvent,
IN PVOID DisplayDriverEvent
);
VIDEOPORT_API
PDMA
VideoPortMapDmaMemory(
IN PVOID HwDeviceExtension,
IN PVIDEO_REQUEST_PACKET pVrp,
IN PHYSICAL_ADDRESS BoardAddress,
IN PULONG Length,
IN PULONG InIoSpace,
IN PVOID MappedUserEvent,
IN PVOID DisplayDriverEvent,
IN OUT PVOID * VirtualAddress
);
VIDEOPORT_API
BOOLEAN
VideoPortUnmapDmaMemory(
PVOID HwDeviceExtension,
PVOID VirtualAddress,
HANDLE ProcessHandle,
PDMA BoardMemoryHandle
);
//
// TODO: End of move block.
//
#endif // ifndef __VIDEO_H__
Reference in New Issue View Git Blame Copy Permalink