/*++ Copyright (c) Microsoft Corporation. All rights reserved. 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 // // 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; typedef struct _VIDEO_PORT_SPIN_LOCK *PSPIN_LOCK; // // 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; typedef enum _VP_POOL_TYPE { VpNonPagedPool, VpPagedPool, VpNonPagedPoolCacheAligned = 4, VpPagedPoolCacheAligned } VP_POOL_TYPE, *PVP_POOL_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; typedef struct _INT10_BIOS_ARGUMENTS { ULONG Eax; ULONG Ebx; ULONG Ecx; ULONG Edx; ULONG Esi; ULONG Edi; ULONG Ebp; USHORT SegDs; USHORT SegEs; } INT10_BIOS_ARGUMENTS, *PINT10_BIOS_ARGUMENTS; #define SIZE_OF_NT4_VIDEO_PORT_CONFIG_INFO 0x42 #define SIZE_OF_NT4_VIDEO_HW_INITIALIZATION_DATA 0x28 #define SIZE_OF_W2K_VIDEO_HW_INITIALIZATION_DATA 0x50 // // 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 typedef enum VIDEO_DEBUG_LEVEL { Error = 0, Warn, Trace, Info } VIDEO_DEBUG_LEVEL, *PVIDEO_DEBUG_LEVEL; // // Allows us to remove lots of unused code. // #ifndef _NTOSDEF_ //don't pickup ntosp version #ifdef PAGED_CODE #undef PAGED_CODE #endif #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, PVOID Context2 ); #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) // // Opaque type for PVP_DMA_ADAPTER // typedef struct __VP_DMA_ADAPTER *PVP_DMA_ADAPTER; typedef enum _VP_LOCK_OPERATION { VpReadAccess, VpWriteAccess, VpModifyAccess } VP_LOCK_OPERATION; typedef struct _VP_DEVICE_DESCRIPTION { BOOLEAN ScatterGather; BOOLEAN Dma32BitAddresses; BOOLEAN Dma64BitAddresses; ULONG MaximumLength; } VP_DEVICE_DESCRIPTION, *PVP_DEVICE_DESCRIPTION; typedef struct _VP_SCATTER_GATHER_ELEMENT { PHYSICAL_ADDRESS Address; ULONG Length; ULONG_PTR Reserved; } VP_SCATTER_GATHER_ELEMENT, *PVP_SCATTER_GATHER_ELEMENT; #pragma warning(disable:4200) typedef struct _VP_SCATTER_GATHER_LIST { ULONG NumberOfElements; ULONG_PTR Reserved; VP_SCATTER_GATHER_ELEMENT Elements[]; } VP_SCATTER_GATHER_LIST, *PVP_SCATTER_GATHER_LIST; #pragma warning(default:4200) #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. // PEMULATOR_ACCESS_ENTRY 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 ); typedef VOID (*PEXECUTE_DMA)( PVOID HwDeviceExtension, PVP_DMA_ADAPTER VpDmaAdapter, PVP_SCATTER_GATHER_LIST SGList, PVOID Context ); // // 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; // // Event flags // typedef ULONG DMA_EVENT_FLAGS; #define SET_USER_EVENT 0x01 #define SET_DISPLAY_EVENT 0x02 #define EVENT_TYPE_MASK 1 #define SYNCHRONIZATION_EVENT 0 #define NOTIFICATION_EVENT 1 #define INITIAL_EVENT_STATE_MASK 2 #define INITIAL_EVENT_NOT_SIGNALED 0 #define INITIAL_EVENT_SIGNALED 2 // // 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 // // Define invalid child device id (needed for failure return value). // #define VIDEO_INVALID_CHILD_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 VP_STATUS (*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 _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; // // Obselete. Don't set it. // 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; // // Start of 5.1 stuff. // ULONG Reserved; } 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 { IN ULONG Size; IN PVIDEO_WRITE_CLOCK_LINE WriteClockLine; IN PVIDEO_WRITE_DATA_LINE WriteDataLine; IN PVIDEO_READ_CLOCK_LINE ReadClockLine; IN PVIDEO_READ_DATA_LINE ReadDataLine; IN PVIDEO_WAIT_VSYNC_ACTIVE WaitVsync; PVOID Reserved; } I2C_FNC_TABLE, *PI2C_FNC_TABLE; typedef struct _I2C_CALLBACKS { IN PVIDEO_WRITE_CLOCK_LINE WriteClockLine; IN PVIDEO_WRITE_DATA_LINE WriteDataLine; IN PVIDEO_READ_CLOCK_LINE ReadClockLine; IN PVIDEO_READ_DATA_LINE ReadDataLine; } I2C_CALLBACKS, *PI2C_CALLBACKS; typedef struct _DDC_CONTROL { IN ULONG Size; IN I2C_CALLBACKS I2CCallbacks; IN UCHAR EdidSegment; } DDC_CONTROL, *PDDC_CONTROL; typedef struct _VIDEO_I2C_CONTROL { IN PVIDEO_WRITE_CLOCK_LINE WriteClockLine; IN PVIDEO_WRITE_DATA_LINE WriteDataLine; IN PVIDEO_READ_CLOCK_LINE ReadClockLine; IN PVIDEO_READ_DATA_LINE ReadDataLine; IN ULONG I2CDelay; // 100ns units } VIDEO_I2C_CONTROL, *PVIDEO_I2C_CONTROL; // // Types of services exported by the VideoPortQueryServices(). // typedef enum { VideoPortServicesAGP = 1, VideoPortServicesI2C, VideoPortServicesHeadless, VideoPortServicesInt10 } VIDEO_PORT_SERVICES; // // AGP services interface. // #define VIDEO_PORT_AGP_INTERFACE_VERSION_1 1 typedef struct _VIDEO_PORT_AGP_INTERFACE { IN USHORT Size; IN USHORT Version; OUT PVOID Context; OUT PINTERFACE_REFERENCE InterfaceReference; OUT PINTERFACE_DEREFERENCE InterfaceDereference; OUT PAGP_RESERVE_PHYSICAL AgpReservePhysical; OUT PAGP_RELEASE_PHYSICAL AgpReleasePhysical; OUT PAGP_COMMIT_PHYSICAL AgpCommitPhysical; OUT PAGP_FREE_PHYSICAL AgpFreePhysical; OUT PAGP_RESERVE_VIRTUAL AgpReserveVirtual; OUT PAGP_RELEASE_VIRTUAL AgpReleaseVirtual; OUT PAGP_COMMIT_VIRTUAL AgpCommitVirtual; OUT PAGP_FREE_VIRTUAL AgpFreeVirtual; OUT ULONGLONG AgpAllocationLimit; } VIDEO_PORT_AGP_INTERFACE, *PVIDEO_PORT_AGP_INTERFACE; #define VIDEO_PORT_AGP_INTERFACE_VERSION_2 2 typedef struct _VIDEO_PORT_AGP_INTERFACE_2 { IN USHORT Size; IN USHORT Version; OUT PVOID Context; OUT PINTERFACE_REFERENCE InterfaceReference; OUT PINTERFACE_DEREFERENCE InterfaceDereference; OUT PAGP_RESERVE_PHYSICAL AgpReservePhysical; OUT PAGP_RELEASE_PHYSICAL AgpReleasePhysical; OUT PAGP_COMMIT_PHYSICAL AgpCommitPhysical; OUT PAGP_FREE_PHYSICAL AgpFreePhysical; OUT PAGP_RESERVE_VIRTUAL AgpReserveVirtual; OUT PAGP_RELEASE_VIRTUAL AgpReleaseVirtual; OUT PAGP_COMMIT_VIRTUAL AgpCommitVirtual; OUT PAGP_FREE_VIRTUAL AgpFreeVirtual; OUT ULONGLONG AgpAllocationLimit; OUT PAGP_SET_RATE AgpSetRate; } VIDEO_PORT_AGP_INTERFACE_2, *PVIDEO_PORT_AGP_INTERFACE_2; // // 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. // #define VIDEO_PORT_I2C_INTERFACE_VERSION_1 1 typedef struct _VIDEO_PORT_I2C_INTERFACE { IN USHORT Size; IN USHORT Version; OUT PVOID Context; OUT PINTERFACE_REFERENCE InterfaceReference; OUT PINTERFACE_DEREFERENCE InterfaceDereference; OUT PI2C_START I2CStart; OUT PI2C_STOP I2CStop; OUT PI2C_WRITE I2CWrite; OUT PI2C_READ I2CRead; } VIDEO_PORT_I2C_INTERFACE, *PVIDEO_PORT_I2C_INTERFACE; // // I2C helper routines exported via VideoPortQueryServices() // for I2C interface version 2. // typedef BOOLEAN (*PI2C_START_2)( IN PVOID HwDeviceExtension, IN PVIDEO_I2C_CONTROL I2CControl ); typedef BOOLEAN (*PI2C_STOP_2)( IN PVOID HwDeviceExtension, IN PVIDEO_I2C_CONTROL I2CControl ); typedef BOOLEAN (*PI2C_WRITE_2)( IN PVOID HwDeviceExtension, IN PVIDEO_I2C_CONTROL I2CControl, IN PUCHAR Buffer, IN ULONG Length ); typedef BOOLEAN (*PI2C_READ_2)( IN PVOID HwDeviceExtension, IN PVIDEO_I2C_CONTROL I2CControl, OUT PUCHAR Buffer, IN ULONG Length, IN BOOLEAN EndOfRead ); // // I2C services interface version 2. // #define VIDEO_PORT_I2C_INTERFACE_VERSION_2 2 typedef struct _VIDEO_PORT_I2C_INTERFACE_2 { IN USHORT Size; IN USHORT Version; OUT PVOID Context; OUT PINTERFACE_REFERENCE InterfaceReference; OUT PINTERFACE_DEREFERENCE InterfaceDereference; OUT PI2C_START_2 I2CStart; OUT PI2C_STOP_2 I2CStop; OUT PI2C_WRITE_2 I2CWrite; OUT PI2C_READ_2 I2CRead; } VIDEO_PORT_I2C_INTERFACE_2, *PVIDEO_PORT_I2C_INTERFACE_2; typedef VP_STATUS (*PINT10_ALLOCATE_BUFFER)( IN PVOID Context, OUT PUSHORT Seg, OUT PUSHORT Off, IN OUT PULONG Length ); typedef VP_STATUS (*PINT10_FREE_BUFFER)( IN PVOID Context, IN USHORT Seg, IN USHORT Off ); typedef VP_STATUS (*PINT10_READ_MEMORY)( IN PVOID Context, IN USHORT Seg, IN USHORT Off, OUT PVOID Buffer, IN ULONG Length ); typedef VP_STATUS (*PINT10_WRITE_MEMORY)( IN PVOID Context, IN USHORT Seg, IN USHORT Off, IN PVOID Buffer, IN ULONG Length ); typedef VP_STATUS (*PINT10_CALL_BIOS)( PVOID Context, PINT10_BIOS_ARGUMENTS BiosArguments ); #define VIDEO_PORT_INT10_INTERFACE_VERSION_1 1 typedef struct _VIDEO_PORT_INT10_INTERFACE { IN USHORT Size; IN USHORT Version; OUT PVOID Context; OUT PINTERFACE_REFERENCE InterfaceReference; OUT PINTERFACE_DEREFERENCE InterfaceDereference; OUT PINT10_ALLOCATE_BUFFER Int10AllocateBuffer; OUT PINT10_FREE_BUFFER Int10FreeBuffer; OUT PINT10_READ_MEMORY Int10ReadMemory; OUT PINT10_WRITE_MEMORY Int10WriteMemory; OUT PINT10_CALL_BIOS Int10CallBios; } VIDEO_PORT_INT10_INTERFACE, *PVIDEO_PORT_INT10_INTERFACE; typedef struct _VPOSVERSIONINFO { IN ULONG Size; OUT ULONG MajorVersion; OUT ULONG MinorVersion; OUT ULONG BuildNumber; OUT USHORT ServicePackMajor; OUT USHORT ServicePackMinor; } VPOSVERSIONINFO, *PVPOSVERSIONINFO; // // 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( VIDEO_DEBUG_LEVEL 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 VideoPortMapBankedMemory( PVOID HwDeviceExtension, PHYSICAL_ADDRESS PhysicalAddress, PULONG Length, PULONG InIoSpace, PVOID *VirtualAddress, ULONG BankLength, UCHAR ReadWriteBank, PBANKED_SECTION_ROUTINE BankRoutine, PVOID Context ); 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 LONGLONG VideoPortQueryPerformanceCounter( IN PVOID HwDeviceExtension, OUT PLONGLONG PerformanceFrequency OPTIONAL ); 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 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 ); VIDEOPORT_API VP_STATUS VideoPortCreateSecondaryDisplay( IN PVOID HwDeviceExtension, IN OUT PVOID *SecondaryDeviceExtension, IN ULONG ulFlag ); VIDEOPORT_API PVP_DMA_ADAPTER VideoPortGetDmaAdapter( IN PVOID HwDeviceExtension, IN PVP_DEVICE_DESCRIPTION VpDeviceDescription ); VIDEOPORT_API VOID VideoPortPutDmaAdapter( IN PVOID HwDeviceExtension, IN PVP_DMA_ADAPTER VpDmaAdapter ); VIDEOPORT_API PVOID VideoPortAllocateCommonBuffer( IN PVOID HwDeviceExtension, IN PVP_DMA_ADAPTER VpDmaAdapter, IN ULONG DesiredLength, OUT PPHYSICAL_ADDRESS LogicalAddress, IN BOOLEAN CacheEnabled, OUT PVOID Reserved ); VIDEOPORT_API VOID VideoPortReleaseCommonBuffer( IN PVOID HwDeviceExtension, IN PVP_DMA_ADAPTER VpDmaAdapter, IN ULONG Length, IN PHYSICAL_ADDRESS LogicalAddress, IN PVOID VirtualAddress, IN BOOLEAN CacheEnabled ); VIDEOPORT_API PVOID VideoPortLockBuffer( IN PVOID HwDeviceExtension, IN PVOID BaseAddress, IN ULONG Length, IN VP_LOCK_OPERATION Operation ); VIDEOPORT_API VOID VideoPortUnlockBuffer( IN PVOID HwDeviceExtension, IN PVOID Mdl ); VIDEOPORT_API VP_STATUS VideoPortStartDma( IN PVOID HwDeviceExtension, IN PVP_DMA_ADAPTER VpDmaAdapter, IN PVOID Mdl, IN ULONG Offset, IN OUT PULONG pLength, IN PEXECUTE_DMA ExecuteDmaRoutine, IN PVOID Context, IN BOOLEAN WriteToDevice ); VIDEOPORT_API VP_STATUS VideoPortCompleteDma( IN PVOID HwDeviceExtension, IN PVP_DMA_ADAPTER VpDmaAdapter, IN PVP_SCATTER_GATHER_LIST VpScatterGather, IN BOOLEAN WriteToDevice ); VIDEOPORT_API VP_STATUS VideoPortCreateEvent( IN PVOID HwDeviceExtension, IN ULONG EventFlag, IN PVOID Unused, OUT PEVENT *ppEvent ); VIDEOPORT_API VP_STATUS VideoPortDeleteEvent( IN PVOID HwDeviceExtension, IN PEVENT pEvent ); VIDEOPORT_API LONG VideoPortSetEvent( IN PVOID HwDeviceExtension, IN PEVENT pEvent ); VIDEOPORT_API VOID VideoPortClearEvent( IN PVOID HwDeviceExtension, IN PEVENT pEvent ); VIDEOPORT_API LONG VideoPortReadStateEvent( IN PVOID HwDeviceExtension, IN PEVENT pEvent ); VIDEOPORT_API VP_STATUS VideoPortWaitForSingleObject( IN PVOID HwDeviceExtension, IN PVOID Object, IN PLARGE_INTEGER Timeout ); VIDEOPORT_API PVOID VideoPortAllocatePool( IN PVOID HwDeviceExtension, IN VP_POOL_TYPE PoolType, IN SIZE_T NumberOfBytes, IN ULONG Tag ); VIDEOPORT_API VOID VideoPortFreePool( IN PVOID HwDeviceExtension, IN PVOID Ptr ); VIDEOPORT_API VP_STATUS VideoPortCreateSpinLock( IN PVOID HwDeviceExtension, OUT PSPIN_LOCK *SpinLock ); VIDEOPORT_API VP_STATUS VideoPortDeleteSpinLock( IN PVOID HwDeviceExtension, IN PSPIN_LOCK SpinLock ); VIDEOPORT_API VOID VideoPortAcquireSpinLock( IN PVOID HwDeviceExtension, IN PSPIN_LOCK SpinLock, OUT PUCHAR OldIrql ); VIDEOPORT_API VOID VideoPortAcquireSpinLockAtDpcLevel( IN PVOID HwDeviceExtension, IN PSPIN_LOCK SpinLock ); VIDEOPORT_API VOID VideoPortReleaseSpinLock( IN PVOID HwDeviceExtension, IN PSPIN_LOCK SpinLock, IN UCHAR NewIrql ); VIDEOPORT_API VOID VideoPortReleaseSpinLockFromDpcLevel( IN PVOID HwDeviceExtension, IN PSPIN_LOCK SpinLock ); VIDEOPORT_API VOID VideoPortQuerySystemTime( OUT PLARGE_INTEGER CurrentTime ); #define CDE_USE_SUBSYSTEM_IDS 0x00000001 #define CDE_USE_REVISION 0x00000002 VIDEOPORT_API BOOLEAN VideoPortCheckForDeviceExistence( IN PVOID HwDeviceExtension, IN USHORT VendorId, IN USHORT DeviceId, IN UCHAR RevisionId, IN USHORT SubVendorId, IN USHORT SubSystemId, IN ULONG Flags ); VIDEOPORT_API ULONG VideoPortGetAssociatedDeviceID( IN PVOID DeviceObject ); VIDEOPORT_API VP_STATUS VideoPortFlushRegistry( PVOID HwDeviceExtension ); VIDEOPORT_API VP_STATUS VideoPortGetVersion( IN PVOID HwDeviceExtension, IN OUT PVPOSVERSIONINFO pVpOsVersionInfo ); VIDEOPORT_API BOOLEAN VideoPortIsNoVesa( VOID ); // // TODO: End of move block. // // // Support for bugcheck reason callbacks // #define BUGCHECK_DATA_SIZE_RESERVED 48 typedef VOID (*PVIDEO_BUGCHECK_CALLBACK) ( IN PVOID HwDeviceExtension, IN ULONG BugcheckCode, IN PUCHAR Buffer, IN ULONG BufferSize ); VIDEOPORT_API VP_STATUS VideoPortRegisterBugcheckCallback( IN PVOID HwDeviceExtension, IN ULONG BugcheckCode, IN PVIDEO_BUGCHECK_CALLBACK Callback, IN ULONG BugcheckDataSize ); #endif // ifndef __VIDEO_H__