diff --git a/sdk/include/ddk/d3dkmddi.h b/sdk/include/ddk/d3dkmddi.h index d319665f113..07688bb0ac5 100644 --- a/sdk/include/ddk/d3dkmddi.h +++ b/sdk/include/ddk/d3dkmddi.h @@ -9,6 +9,293 @@ #define _D3DKMDDI_H_ #include +#include + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) +typedef enum _DXGK_PRESENT_DISPLAY_ONLY_PROGRESS_ID +{ + DXGK_PRESENT_DISPLAYONLY_PROGRESS_ID_COMPLETE = 0, + DXGK_PRESENT_DISPLAYONLY_PROGRESS_ID_FAILED = 1, +} DXGK_PRESENT_DISPLAY_ONLY_PROGRESS_ID; + +typedef struct _DXGKARGCB_PRESENT_DISPLAYONLY_PROGRESS +{ + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; + DXGK_PRESENT_DISPLAY_ONLY_PROGRESS_ID ProgressId; +} DXGKARGCB_PRESENT_DISPLAYONLY_PROGRESS; + +typedef +VOID +(APIENTRY *DXGKCB_PRESENT_DISPLAYONLY_PROGRESS)( + _In_ const HANDLE hAdapter, + _In_ const DXGKARGCB_PRESENT_DISPLAYONLY_PROGRESS* pArgs + ); + +typedef struct _DXGK_MULTIPLANE_OVERLAY_VSYNC_INFO DXGK_MULTIPLANE_OVERLAY_VSYNC_INFO; +#endif + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) + +typedef struct _D3DKMT_PRESENT_DISPLAY_ONLY_FLAGS +{ + union + { + struct + { + UINT Rotate : 1; + UINT Reserved : 31; + }; + UINT Value; + }; +} D3DKMT_PRESENT_DISPLAY_ONLY_FLAGS; + +typedef struct _DXGKARG_PRESENT_DISPLAYONLY +{ + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; + VOID* pSource; + ULONG BytesPerPixel; + LONG Pitch; + D3DKMT_PRESENT_DISPLAY_ONLY_FLAGS Flags; + ULONG NumMoves; + _Field_size_(NumMoves) D3DKMT_MOVE_RECT* pMoves; + ULONG NumDirtyRects; + _Field_size_(NumDirtyRects) RECT* pDirtyRect; + DXGKCB_PRESENT_DISPLAYONLY_PROGRESS pfnPresentDisplayOnlyProgress; +} DXGKARG_PRESENT_DISPLAYONLY; + +typedef +_Check_return_ +NTSTATUS +APIENTRY +DXGKDDI_PRESENTDISPLAYONLY( + _In_ const HANDLE hAdapter, + _In_ const DXGKARG_PRESENT_DISPLAYONLY* pPresentDisplayOnly + ); + +typedef DXGKDDI_PRESENTDISPLAYONLY *PDXGKDDI_PRESENTDISPLAYONLY; + +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) + +typedef struct _DXGKARG_ESCAPE +{ + HANDLE hDevice; + D3DDDI_ESCAPEFLAGS Flags; + VOID* pPrivateDriverData; + UINT PrivateDriverDataSize; + HANDLE hContext; + HANDLE hKmdProcessHandle; +} DXGKARG_ESCAPE, *PDXGKARG_ESCAPE; + +typedef +_Check_return_ +NTSTATUS +APIENTRY +DXGKDDI_ESCAPE( + _In_ const HANDLE hAdapter, + _In_ const DXGKARG_ESCAPE* pEscape + ); + +typedef DXGKDDI_ESCAPE *PDXGKDDI_ESCAPE; + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_1) +typedef struct _DXGK_MULTIPLANE_OVERLAY_VSYNC_INFO2 DXGK_MULTIPLANE_OVERLAY_VSYNC_INFO2; +#endif + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_9) +typedef struct _DXGK_MULTIPLANE_OVERLAY_VSYNC_INFO3 DXGK_MULTIPLANE_OVERLAY_VSYNC_INFO3; +#endif + +typedef enum _DXGK_HANDLE_TYPE +{ + DXGK_HANDLE_ALLOCATION = 1, + DXGK_HANDLE_RESOURCE = 2, +} DXGK_HANDLE_TYPE; + +typedef enum _DXGK_INTERRUPT_TYPE +{ + DXGK_INTERRUPT_DMA_COMPLETED = 1, + DXGK_INTERRUPT_DMA_PREEMPTED = 2, + DXGK_INTERRUPT_CRTC_VSYNC = 3, + DXGK_INTERRUPT_DMA_FAULTED = 4, + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) + DXGK_INTERRUPT_DISPLAYONLY_VSYNC = 5, + DXGK_INTERRUPT_DISPLAYONLY_PRESENT_PROGRESS = 6, + DXGK_INTERRUPT_CRTC_VSYNC_WITH_MULTIPLANE_OVERLAY = 7, +#endif // DXGKDDI_INTERFACE_VERSION + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM1_3) + DXGK_INTERRUPT_MICACAST_CHUNK_PROCESSING_COMPLETE = 8, +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM1_3) + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0) + DXGK_INTERRUPT_DMA_PAGE_FAULTED = 9, +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0) + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_1) + DXGK_INTERRUPT_CRTC_VSYNC_WITH_MULTIPLANE_OVERLAY2 = 10, +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_1) + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_2) + DXGK_INTERRUPT_MONITORED_FENCE_SIGNALED = 11, + DXGK_INTERRUPT_HWQUEUE_PAGE_FAULTED = 12, + DXGK_INTERRUPT_HWCONTEXTLIST_SWITCH_COMPLETED = 13, + DXGK_INTERRUPT_PERIODIC_MONITORED_FENCE_SIGNALED = 14, +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_2) + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_4) + DXGK_INTERRUPT_SCHEDULING_LOG_INTERRUPT = 15, + DXGK_INTERRUPT_GPU_ENGINE_TIMEOUT = 16, + DXGK_INTERRUPT_SUSPEND_CONTEXT_COMPLETED = 17, +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_4) + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_9) + DXGK_INTERRUPT_CRTC_VSYNC_WITH_MULTIPLANE_OVERLAY3 = 18, +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_9) + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM3_1) + DXGK_INTERRUPT_NATIVE_FENCE_SIGNALED = 19, + DXGK_INTERRUPT_GPU_ENGINE_STATE_CHANGE = 20 +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM3_1) + +} DXGK_INTERRUPT_TYPE; + +typedef enum _DXGK_MONITOR_INTERFACE_VERSION +{ + DXGK_MONITOR_INTERFACE_VERSION_UNINITIALIZED = 0, + DXGK_MONITOR_INTERFACE_VERSION_V1 = 1, + DXGK_MONITOR_INTERFACE_VERSION_V2 = 2, +} DXGK_MONITOR_INTERFACE_VERSION; + +typedef enum _DXGK_VIDPN_INTERFACE_VERSION +{ + DXGK_VIDPN_INTERFACE_VERSION_UNINITIALIZED = 0, + DXGK_VIDPN_INTERFACE_VERSION_V1 = 1, + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_9) + DXGK_VIDPN_INTERFACE_VERSION_V2 = 2, +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_9) +} DXGK_VIDPN_INTERFACE_VERSION; + +typedef enum _DXGK_ENGINE_STATE +{ + DXGK_ENGINE_STATE_ACTIVE = 0, + DXGK_ENGINE_STATE_IDLE = 1, + DXGK_ENGINE_STATE_HUNG = 2 +} DXGK_ENGINE_STATE; + +typedef enum _DXGK_QUERYADAPTERINFOTYPE +{ + DXGKQAITYPE_UMDRIVERPRIVATE = 0, + DXGKQAITYPE_DRIVERCAPS = 1, + DXGKQAITYPE_QUERYSEGMENT = 2, +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN7) + DXGKQAITYPE_RESERVED = 3, + DXGKQAITYPE_QUERYSEGMENT2 = 4, +#endif // DXGKDDI_INTERFACE_VERSION_WIN7 +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) + DXGKQAITYPE_QUERYSEGMENT3 = 5, + DXGKQAITYPE_NUMPOWERCOMPONENTS = 6, + DXGKQAITYPE_POWERCOMPONENTINFO = 7, + DXGKQAITYPE_PREFERREDGPUNODE = 8, +#endif // DXGKDDI_INTERFACE_VERSION_WIN8 +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM1_3) + DXGKQAITYPE_POWERCOMPONENTPSTATEINFO = 9, + DXGKQAITYPE_HISTORYBUFFERPRECISION = 10, +#endif // DXGKDDI_INTERFACE_VERSION_WDDM1_3 +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0) + DXGKQAITYPE_QUERYSEGMENT4 = 11, + DXGKQAITYPE_SEGMENTMEMORYSTATE = 12, + DXGKQAITYPE_GPUMMUCAPS = 13, + DXGKQAITYPE_PAGETABLELEVELDESC = 14, + DXGKQAITYPE_PHYSICALADAPTERCAPS = 15, + DXGKQAITYPE_DISPLAY_DRIVERCAPS_EXTENSION = 16, +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_0 +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_2) + DXGKQAITYPE_INTEGRATED_DISPLAY_DESCRIPTOR = 17, + DXGKQAITYPE_UEFIFRAMEBUFFERRANGES = 18, + DXGKQAITYPE_QUERYCOLORIMETRYOVERRIDES = 19, +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_2 +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_3) + DXGKQAITYPE_DISPLAYID_DESCRIPTOR = 20, +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_3 +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_4) + DXGKQAITYPE_FRAMEBUFFERSAVESIZE = 21, + DXGKQAITYPE_HARDWARERESERVEDRANGES = 22, + DXGKQAITYPE_INTEGRATED_DISPLAY_DESCRIPTOR2 = 23, + DXGKQAITYPE_NODEPERFDATA = 24, + DXGKQAITYPE_ADAPTERPERFDATA = 25, + DXGKQAITYPE_ADAPTERPERFDATA_CAPS = 26, + DXGKQAITYPE_GPUVERSION = 27, +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_4 +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_5) + DXGKQAITYPE_DEVICE_TYPE_CAPS = 28, +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_5 +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_6) + DXGKQAITYPE_WDDMDEVICECAPS = 29, + DXGKQAITYPE_GPUPCAPS = 30, + DXGKQAITYPE_QUERYTARGETGAMMACAPS = 31, + DXGKQAITYPE_SCANOUT_CAPS = 33, +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_6 +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_9) + DXGKQAITYPE_PHYSICAL_MEMORY_CAPS = 34, + DXGKQAITYPE_IOMMU_CAPS = 35, +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_9 +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM3_1) + DXGKQAITYPE_HARDWARERESERVEDRANGES2 = 36, + DXGKQAITYPE_NATIVE_FENCE_CAPS = 37, + DXGKQAITYPE_USERMODESUBMISSION_CAPS = 38, +#endif // DXGKDDI_INTERFACE_VERSION_WDDM3_1 + +} DXGK_QUERYADAPTERINFOTYPE; + +/* + * Driver capability structures used with DXGKQAITYPE_DRIVERCAPS and + * DXGKQAITYPE_DISPLAY_DRIVERCAPS_EXTENSION. + * ReactOS currently only needs a minimal subset for display-only bring-up. + */ + +typedef enum _DXGK_WDDMVERSION +{ + DXGKDDI_WDDMv1_0 = 0x1000, + DXGKDDI_WDDMv1_1 = 0x1100, + DXGKDDI_WDDMv1_2 = 0x1200, +} DXGK_WDDMVERSION; + +typedef struct _DXGK_DRIVERCAPS +{ + DXGK_WDDMVERSION WDDMVersion; + LARGE_INTEGER HighestAcceptableAddress; + BOOLEAN SupportNonVGA; + BOOLEAN SupportSmoothRotation; + UCHAR Reserved[2]; +} DXGK_DRIVERCAPS; + +typedef struct _DXGK_DISPLAY_DRIVERCAPS_EXTENSION +{ + union + { + struct + { + UINT VirtualModeSupport : 1; + UINT Reserved : 31; + }; + UINT Value; + }; +} DXGK_DISPLAY_DRIVERCAPS_EXTENSION; + +typedef struct _DXGKCB_GETHANDLEDATAFLAGS +{ + union + { + struct + { + UINT DeviceSpecific : 1; + UINT Reserved : 31; + }; + UINT Value; + }; +} DXGKCB_GETHANDLEDATAFLAGS; typedef struct _DXGK_ALLOCATIONINFOFLAGS_WDDM2_0 { @@ -238,4 +525,1550 @@ C_ASSERT(sizeof(DXGK_ALLOCATIONINFO) == 0x3C); #endif #endif +typedef struct _DXGK_CREATEALLOCATIONFLAGS +{ + union + { + struct + { + UINT Resource : 1; + UINT Reserved : 31; + }; + UINT Value; + }; +} DXGK_CREATEALLOCATIONFLAGS; + +typedef struct _DXGKARG_CREATEALLOCATION +{ + CONST VOID* pPrivateDriverData; + UINT PrivateDriverDataSize; + UINT NumAllocations; + DXGK_ALLOCATIONINFO* pAllocationInfo; + HANDLE hResource; + DXGK_CREATEALLOCATIONFLAGS Flags; +} DXGKARG_CREATEALLOCATION, *PDXGKARG_CREATEALLOCATION; + +typedef +_Check_return_ +NTSTATUS +APIENTRY +DXGKDDI_CREATEALLOCATION( + _In_ const HANDLE hAdapter, + _Inout_ PDXGKARG_CREATEALLOCATION pCreateAllocation + ); + +typedef DXGKDDI_CREATEALLOCATION *PDXGKDDI_CREATEALLOCATION; + +typedef struct _DXGKCB_NOTIFY_INTERRUPT_DATA_FLAGS +{ + union + { + struct + { + UINT ValidPhysicalAdapterMask : 1; +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_2) + UINT HsyncFlipCompletion : 1; + UINT Reserved : 30; +#else + UINT Reserved : 31; +#endif + }; + UINT Value; + }; +} DXGKCB_NOTIFY_INTERRUPT_DATA_FLAGS; + +typedef struct _DXGKARGCB_NOTIFY_INTERRUPT_DATA +{ + DXGK_INTERRUPT_TYPE InterruptType; + union + { + struct + { + UINT SubmissionFenceId; + UINT NodeOrdinal; + UINT EngineOrdinal; + } DmaCompleted; + struct + { + UINT PreemptionFenceId; + UINT LastCompletedFenceId; + UINT NodeOrdinal; + UINT EngineOrdinal; + } DmaPreempted; + struct + { + UINT FaultedFenceId; + NTSTATUS Status; + UINT NodeOrdinal; + UINT EngineOrdinal; + } DmaFaulted; + struct + { + D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId; + PHYSICAL_ADDRESS PhysicalAddress; + UINT PhysicalAdapterMask; + } CrtcVsync; +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) + struct + { + D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId; + } DisplayOnlyVsync; + struct + { + D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId; + UINT PhysicalAdapterMask; + UINT MultiPlaneOverlayVsyncInfoCount; + DXGK_MULTIPLANE_OVERLAY_VSYNC_INFO *pMultiPlaneOverlayVsyncInfo; + } CrtcVsyncWithMultiPlaneOverlay; + DXGKARGCB_PRESENT_DISPLAYONLY_PROGRESS DisplayOnlyPresentProgress; +#endif // DXGKDDI_INTERFACE_VERSION + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM1_3) + struct + { + D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId; + DXGK_MIRACAST_CHUNK_INFO ChunkInfo; + PVOID pPrivateDriverData; + UINT PrivateDataDriverSize; + NTSTATUS Status; + } MiracastEncodeChunkCompleted; +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM1_3) + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0) + struct + { + UINT FaultedFenceId; + UINT64 FaultedPrimitiveAPISequenceNumber; + DXGK_RENDER_PIPELINE_STAGE FaultedPipelineStage; + UINT FaultedBindTableEntry; + DXGK_PAGE_FAULT_FLAGS PageFaultFlags; + D3DGPU_VIRTUAL_ADDRESS FaultedVirtualAddress; + UINT NodeOrdinal; + UINT EngineOrdinal; + UINT PageTableLevel; + DXGK_FAULT_ERROR_CODE FaultErrorCode; + HANDLE FaultedProcessHandle; + } DmaPageFaulted; +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0) + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_1) + struct + { + D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId; + UINT PhysicalAdapterMask; + UINT MultiPlaneOverlayVsyncInfoCount; + _Field_size_(MultiPlaneOverlayVsyncInfoCount) DXGK_MULTIPLANE_OVERLAY_VSYNC_INFO2 *pMultiPlaneOverlayVsyncInfo; + ULONGLONG GpuFrequency; + ULONGLONG GpuClockCounter; + } CrtcVsyncWithMultiPlaneOverlay2; +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_1) + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_2) + struct + { + UINT NodeOrdinal; + UINT EngineOrdinal; + } MonitoredFenceSignaled; + struct + { + UINT NodeOrdinal; + UINT EngineOrdinal; + UINT64 ContextSwitchFence; + } HwContextListSwitchCompleted; + struct + { + UINT64 FaultedFenceId; + D3DGPU_VIRTUAL_ADDRESS FaultedVirtualAddress; + UINT64 FaultedPrimitiveAPISequenceNumber; + union + { + HANDLE FaultedHwQueue; + HANDLE FaultedHwContext; + HANDLE FaultedProcessHandle; + }; + UINT NodeOrdinal; + UINT EngineOrdinal; + DXGK_RENDER_PIPELINE_STAGE FaultedPipelineStage; + UINT FaultedBindTableEntry; + DXGK_PAGE_FAULT_FLAGS PageFaultFlags; + UINT PageTableLevel; + DXGK_FAULT_ERROR_CODE FaultErrorCode; + } HwQueuePageFaulted; + struct + { + D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId; + UINT NotificationID; + } PeriodicMonitoredFenceSignaled; +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_2) + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_4) + struct + { + UINT NodeOrdinal; + UINT EngineOrdinal; + } SchedulingLogInterrupt; + struct + { + UINT NodeOrdinal; + UINT EngineOrdinal; + } GpuEngineTimeout; + struct + { + HANDLE hContext; + UINT64 ContextSuspendFence; + } SuspendContextCompleted; +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_4) + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_9) + struct + { + D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId; + UINT PhysicalAdapterMask; + UINT MultiPlaneOverlayVsyncInfoCount; + _Field_size_(MultiPlaneOverlayVsyncInfoCount) DXGK_MULTIPLANE_OVERLAY_VSYNC_INFO3 *pMultiPlaneOverlayVsyncInfo; + ULONGLONG GpuFrequency; + ULONGLONG GpuClockCounter; + } CrtcVsyncWithMultiPlaneOverlay3; +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_9) + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM3_1) + struct + { + UINT NodeOrdinal; + UINT EngineOrdinal; + UINT SignaledNativeFenceCount; + _Field_size_(SignaledNativeFenceCount) HANDLE* pSignaledNativeFenceArray; + } NativeFenceSignaled; + struct + { + UINT NodeOrdinal; + UINT EngineOrdinal; + DXGK_ENGINE_STATE NewState; + } EngineStateChange; +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM3_1) + + struct + { + UINT Reserved[16]; + } Reserved; + }; + DXGKCB_NOTIFY_INTERRUPT_DATA_FLAGS Flags; +} DXGKARGCB_NOTIFY_INTERRUPT_DATA ,*PDXGKARGCB_NOTIFY_INTERRUPT_DATA; + +typedef struct _DXGKARGCB_GETHANDLEDATA +{ + D3DKMT_HANDLE hObject; + DXGK_HANDLE_TYPE Type; + DXGKCB_GETHANDLEDATAFLAGS Flags; +} DXGKARGCB_GETHANDLEDATA , *PDXGKARGCB_GETHANDLEDATA; + +typedef _In_ CONST DXGKARGCB_GETHANDLEDATA* IN_CONST_PDXGKARGCB_GETHANDLEDATA; + +typedef struct _DXGKARGCB_GETCAPTUREADDRESS +{ + D3DKMT_HANDLE hAllocation; + UINT SegmentId; + PHYSICAL_ADDRESS PhysicalAddress; +} DXGKARGCB_GETCAPTUREADDRESS, *PDXGKARGCB_GETCAPTUREADDRESS; + +typedef struct _DXGKARGCB_ENUMHANDLECHILDREN +{ + D3DKMT_HANDLE hObject; + UINT Index; +} DXGKARGCB_ENUMHANDLECHILDREN, *PDXGKARGCB_ENUMHANDLECHILDREN; + +typedef _In_ CONST DXGKARGCB_ENUMHANDLECHILDREN* IN_CONST_PDXGKARGCB_ENUMHANDLECHILDREN; + +typedef struct _DXGK_ENUM_PIVOT +{ + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; + D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId; +} DXGK_ENUM_PIVOT; + +typedef struct _DXGKARG_ENUMVIDPNCOFUNCMODALITY +{ + _In_ D3DKMDT_HVIDPN hConstrainingVidPn; + _In_ D3DKMDT_ENUMCOFUNCMODALITY_PIVOT_TYPE EnumPivotType; + _In_ DXGK_ENUM_PIVOT EnumPivot; +} DXGKARG_ENUMVIDPNCOFUNCMODALITY; + +typedef _In_ CONST DXGKARG_ENUMVIDPNCOFUNCMODALITY* CONST IN_CONST_PDXGKARG_ENUMVIDPNCOFUNCMODALITY_CONST; + +typedef struct _DXGK_SETPOINTERPOSITION_FLAGS +{ + union + { + struct + { + UINT Visible : 1; + UINT Reserved : 31; + }; + UINT Value; + }; +} DXGK_SETPOINTERPOSITION_FLAGS; + +typedef struct _DXGKARG_SETPOINTERPOSITION +{ + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; + DXGK_SETPOINTERPOSITION_FLAGS Flags; + POINT Position; +} DXGKARG_SETPOINTERPOSITION; + +typedef struct _DXGKARG_SETPOINTERSHAPE +{ + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; + UINT Width; + UINT Height; + UINT Pitch; + POINT HotSpot; + const VOID* pPixels; +} DXGKARG_SETPOINTERSHAPE; + +typedef struct _DXGKARG_ISSUPPORTEDVIDPN +{ + D3DKMDT_HVIDPN hDesiredVidPn; + BOOLEAN IsVidPnSupported; + UCHAR Reserved[3]; +} DXGKARG_ISSUPPORTEDVIDPN; + +typedef struct _DXGKARG_RECOMMENDFUNCTIONALVIDPN +{ + D3DKMDT_HVIDPN hRecommendedFunctionalVidPn; +} DXGKARG_RECOMMENDFUNCTIONALVIDPN; + +typedef struct _DXGKARG_RECOMMENDVIDPNTOPOLOGY +{ + D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology; +} DXGKARG_RECOMMENDVIDPNTOPOLOGY; + +typedef struct _DXGK_MONITORSOURCEMODESET_INTERFACE DXGK_MONITORSOURCEMODESET_INTERFACE; + +typedef struct _DXGKARG_RECOMMENDMONITORMODES +{ + D3DDDI_VIDEO_PRESENT_TARGET_ID VideoPresentTargetId; + D3DKMDT_HMONITORSOURCEMODESET hMonitorSourceModeSet; + const DXGK_MONITORSOURCEMODESET_INTERFACE* pMonitorSourceModeSetInterface; +} DXGKARG_RECOMMENDMONITORMODES; + +typedef struct _DXGKARG_SETVIDPNSOURCEVISIBILITY +{ + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; + BOOLEAN Visible; + UCHAR Reserved[3]; +} DXGKARG_SETVIDPNSOURCEVISIBILITY; + +typedef struct _DXGK_COMMITVIDPN_FLAGS +{ + union + { + struct + { + UINT PathPowerTransition : 1; + UINT PathPoweredOff : 1; + UINT Reserved : 30; + }; + UINT Value; + }; +} DXGK_COMMITVIDPN_FLAGS; + +typedef struct _DXGKARG_COMMITVIDPN +{ + D3DKMDT_HVIDPN hFunctionalVidPn; + D3DDDI_VIDEO_PRESENT_SOURCE_ID AffectedVidPnSourceId; + DXGK_COMMITVIDPN_FLAGS Flags; + HANDLE hPrimaryAllocation; + D3DKMDT_MONITOR_CONNECTIVITY_CHECKS MonitorConnectivityChecks; +} DXGKARG_COMMITVIDPN; + +typedef struct _DXGKARG_UPDATEACTIVEVIDPNPRESENTPATH +{ + D3DKMDT_VIDPN_PRESENT_PATH VidPnPresentPathInfo; +} DXGKARG_UPDATEACTIVEVIDPNPRESENTPATH; + +typedef struct _DXGK_SETVIDPNSOURCEADDRESS_FLAGS +{ + union + { + struct + { + UINT ModeChange : 1; + UINT FlipImmediate : 1; + UINT FlipOnNextVSync : 1; + UINT Reserved : 29; + }; + UINT Value; + }; +} DXGK_SETVIDPNSOURCEADDRESS_FLAGS; + +typedef struct _DXGKARG_SETVIDPNSOURCEADDRESS +{ + D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId; + UINT PrimarySegment; + PHYSICAL_ADDRESS PrimaryAddress; + HANDLE hAllocation; + UINT ContextCount; + HANDLE Context[1 + D3DDDI_MAX_BROADCAST_CONTEXT]; + DXGK_SETVIDPNSOURCEADDRESS_FLAGS Flags; +} DXGKARG_SETVIDPNSOURCEADDRESS; + +typedef _Inout_ DXGKARGCB_NOTIFY_INTERRUPT_DATA* IN_CONST_PDXGKARGCB_NOTIFY_INTERRUPT_DATA; + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_VIDPNSOURCEMODESET_GETNUMMODES)( + _In_ const D3DKMDT_HVIDPNSOURCEMODESET hVidPnSourceModeSet, + _Out_ SIZE_T* const pNumSourceModes); + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_VIDPNSOURCEMODESET_ACQUIREFIRSTMODEINFO)( + _In_ const D3DKMDT_HVIDPNSOURCEMODESET hVidPnSourceModeSet, + _Outptr_ const D3DKMDT_VIDPN_SOURCE_MODE** ppFirstVidPnSourceModeInfo); + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_VIDPNSOURCEMODESET_ACQUIRENEXTMODEINFO)( + _In_ const D3DKMDT_HVIDPNSOURCEMODESET hVidPnSourceModeSet, + _In_ const D3DKMDT_VIDPN_SOURCE_MODE* pVidPnSourceModeInfo, + _Outptr_ const D3DKMDT_VIDPN_SOURCE_MODE** ppNextVidPnSourceModeInfo); + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_VIDPNSOURCEMODESET_ACQUIREPINNEDMODEINFO)( + _In_ const D3DKMDT_HVIDPNSOURCEMODESET hVidPnSourceModeSet, + _Outptr_ const D3DKMDT_VIDPN_SOURCE_MODE** ppPinnedVidPnSourceModeInfo); + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_VIDPNSOURCEMODESET_RELEASEMODEINFO)( + _In_ const D3DKMDT_HVIDPNSOURCEMODESET hVidPnSourceModeSet, + _In_ const D3DKMDT_VIDPN_SOURCE_MODE* pVidPnSourceModeInfo); + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_VIDPNSOURCEMODESET_CREATENEWMODEINFO)( + _In_ const D3DKMDT_HVIDPNSOURCEMODESET hVidPnSourceModeSet, + _Outptr_ D3DKMDT_VIDPN_SOURCE_MODE** ppNewVidPnSourceModeInfo); + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_VIDPNSOURCEMODESET_ADDMODE)( + _In_ D3DKMDT_HVIDPNSOURCEMODESET hVidPnSourceModeSet, + _In_ D3DKMDT_VIDPN_SOURCE_MODE* pVidPnSourceModeInfo); + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_VIDPNSOURCEMODESET_PINMODE)( + _In_ D3DKMDT_HVIDPNSOURCEMODESET hVidPnSourceModeSet, + _In_ const D3DKMDT_VIDEO_PRESENT_SOURCE_MODE_ID VidPnSourceModeId); + +typedef struct _DXGK_VIDPNSOURCEMODESET_INTERFACE +{ + DXGKDDI_VIDPNSOURCEMODESET_GETNUMMODES pfnGetNumModes; + DXGKDDI_VIDPNSOURCEMODESET_ACQUIREFIRSTMODEINFO pfnAcquireFirstModeInfo; + DXGKDDI_VIDPNSOURCEMODESET_ACQUIRENEXTMODEINFO pfnAcquireNextModeInfo; + DXGKDDI_VIDPNSOURCEMODESET_ACQUIREPINNEDMODEINFO pfnAcquirePinnedModeInfo; + DXGKDDI_VIDPNSOURCEMODESET_RELEASEMODEINFO pfnReleaseModeInfo; + DXGKDDI_VIDPNSOURCEMODESET_CREATENEWMODEINFO pfnCreateNewModeInfo; + DXGKDDI_VIDPNSOURCEMODESET_ADDMODE pfnAddMode; + DXGKDDI_VIDPNSOURCEMODESET_PINMODE pfnPinMode; +} DXGK_VIDPNSOURCEMODESET_INTERFACE; + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_VIDPNTARGETMODESET_GETNUMMODES)( + _In_ const D3DKMDT_HVIDPNTARGETMODESET hVidPnTargetModeSet, + _Out_ SIZE_T* const pNumTargetModes); + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_VIDPNTARGETMODESET_ACQUIREFIRSTMODEINFO)( + _In_ const D3DKMDT_HVIDPNTARGETMODESET hVidPnTargetModeSet, + _Outptr_ const D3DKMDT_VIDPN_TARGET_MODE** ppFirstVidPnTargetModeInfo); + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_VIDPNTARGETMODESET_ACQUIRENEXTMODEINFO)( + _In_ const D3DKMDT_HVIDPNTARGETMODESET hVidPnTargetModeSet, + _In_ const D3DKMDT_VIDPN_TARGET_MODE* pVidPnTargetModeInfo, + _Outptr_ const D3DKMDT_VIDPN_TARGET_MODE** ppNextVidPnTargetModeInfo); + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_VIDPNTARGETMODESET_ACQUIREPINNEDMODEINFO)( + _In_ const D3DKMDT_HVIDPNTARGETMODESET hVidPnTargetModeSet, + _Outptr_ const D3DKMDT_VIDPN_TARGET_MODE** ppPinnedVidPnTargetModeInfo); + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_VIDPNTARGETMODESET_RELEASEMODEINFO)( + _In_ const D3DKMDT_HVIDPNTARGETMODESET hVidPnTargetModeSet, + _In_ const D3DKMDT_VIDPN_TARGET_MODE* pVidPnTargetModeInfo); + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_VIDPNTARGETMODESET_CREATENEWMODEINFO)( + _In_ const D3DKMDT_HVIDPNTARGETMODESET hVidPnTargetModeSet, + _Outptr_ D3DKMDT_VIDPN_TARGET_MODE** ppNewVidPnTargetModeInfo); + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_VIDPNTARGETMODESET_ADDMODE)( + _In_ D3DKMDT_HVIDPNTARGETMODESET hVidPnTargetModeSet, + _In_ D3DKMDT_VIDPN_TARGET_MODE* pVidPnTargetModeInfo); + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_VIDPNTARGETMODESET_PINMODE)( + _In_ D3DKMDT_HVIDPNTARGETMODESET hVidPnTargetModeSet, + _In_ const D3DKMDT_VIDEO_PRESENT_TARGET_MODE_ID VidPnTargetModeId); + +typedef struct _DXGK_VIDPNTARGETMODESET_INTERFACE +{ + DXGKDDI_VIDPNTARGETMODESET_GETNUMMODES pfnGetNumModes; + DXGKDDI_VIDPNTARGETMODESET_ACQUIREFIRSTMODEINFO pfnAcquireFirstModeInfo; + DXGKDDI_VIDPNTARGETMODESET_ACQUIRENEXTMODEINFO pfnAcquireNextModeInfo; + DXGKDDI_VIDPNTARGETMODESET_ACQUIREPINNEDMODEINFO pfnAcquirePinnedModeInfo; + DXGKDDI_VIDPNTARGETMODESET_RELEASEMODEINFO pfnReleaseModeInfo; + DXGKDDI_VIDPNTARGETMODESET_CREATENEWMODEINFO pfnCreateNewModeInfo; + DXGKDDI_VIDPNTARGETMODESET_ADDMODE pfnAddMode; + DXGKDDI_VIDPNTARGETMODESET_PINMODE pfnPinMode; +} DXGK_VIDPNTARGETMODESET_INTERFACE; + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_VIDPNTOPOLOGY_GETNUMPATHS)( + _In_ const D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology, + _Out_ PSIZE_T pNumPaths); + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_VIDPNTOPOLOGY_GETNUMPATHSFROMSOURCE)( + _In_ const D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology, + _In_ const D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, + _Out_ PSIZE_T pNumPathsFromSource); + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_VIDPNTOPOLOGY_ENUMPATHTARGETSFROMSOURCE)( + _In_ const D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology, + _In_ const D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, + _In_ const D3DKMDT_VIDPN_PRESENT_PATH_INDEX VidPnPresentPathIndex, + _Out_ D3DDDI_VIDEO_PRESENT_TARGET_ID* pVidPnTargetId); + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_VIDPNTOPOLOGY_GETPATHSOURCEFROMTARGET)( + _In_ const D3DKMDT_HVIDPNTOPOLOGY hVidTopology, + _In_ const D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId, + _Out_ D3DDDI_VIDEO_PRESENT_SOURCE_ID* pVidPnSourceId); + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_VIDPNTOPOLOGY_ACQUIREPATHINFO)( + _In_ const D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology, + _In_ const D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, + _In_ const D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId, + _Outptr_ const D3DKMDT_VIDPN_PRESENT_PATH** ppVidPnPresentPathInfo); + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_VIDPNTOPOLOGY_ACQUIREFIRSTPATHINFO)( + _In_ const D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology, + _Outptr_ const D3DKMDT_VIDPN_PRESENT_PATH** ppFirstVidPnPresentPathInfo); + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_VIDPNTOPOLOGY_ACQUIRENEXTPATHINFO)( + _In_ const D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology, + _In_ const D3DKMDT_VIDPN_PRESENT_PATH* pVidPnPresentPathInfo, + _Outptr_ const D3DKMDT_VIDPN_PRESENT_PATH** ppNextVidPnPresentPathInfo); + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_VIDPNTOPOLOGY_UPDATEPATHSUPPORTINFO)( + _In_ const D3DKMDT_HVIDPNTOPOLOGY i_hVidPnTopology, + _In_ const D3DKMDT_VIDPN_PRESENT_PATH* i_pVidPnPresentPathInfo); + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_VIDPNTOPOLOGY_RELEASEPATHINFO)( + _In_ const D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology, + _In_ const D3DKMDT_VIDPN_PRESENT_PATH* pVidPnPresentPathInfo); + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_VIDPNTOPOLOGY_CREATENEWPATHINFO)( + _In_ const D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology, + _Outptr_ D3DKMDT_VIDPN_PRESENT_PATH** ppNewVidPnPresentPathInfo); + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_VIDPNTOPOLOGY_ADDPATH)( + _In_ D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology, + _In_ D3DKMDT_VIDPN_PRESENT_PATH* pVidPnPresentPath); + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_VIDPNTOPOLOGY_REMOVEPATH)( + _In_ const D3DKMDT_HVIDPNTOPOLOGY hVidPnTopology, + _In_ const D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, + _In_ const D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId); + +typedef struct _DXGK_VIDPNTOPOLOGY_INTERFACE +{ + DXGKDDI_VIDPNTOPOLOGY_GETNUMPATHS pfnGetNumPaths; + DXGKDDI_VIDPNTOPOLOGY_GETNUMPATHSFROMSOURCE pfnGetNumPathsFromSource; + DXGKDDI_VIDPNTOPOLOGY_ENUMPATHTARGETSFROMSOURCE pfnEnumPathTargetsFromSource; + DXGKDDI_VIDPNTOPOLOGY_GETPATHSOURCEFROMTARGET pfnGetPathSourceFromTarget; + DXGKDDI_VIDPNTOPOLOGY_ACQUIREPATHINFO pfnAcquirePathInfo; + DXGKDDI_VIDPNTOPOLOGY_ACQUIREFIRSTPATHINFO pfnAcquireFirstPathInfo; + DXGKDDI_VIDPNTOPOLOGY_ACQUIRENEXTPATHINFO pfnAcquireNextPathInfo; + DXGKDDI_VIDPNTOPOLOGY_UPDATEPATHSUPPORTINFO pfnUpdatePathSupportInfo; + DXGKDDI_VIDPNTOPOLOGY_RELEASEPATHINFO pfnReleasePathInfo; + DXGKDDI_VIDPNTOPOLOGY_CREATENEWPATHINFO pfnCreateNewPathInfo; + DXGKDDI_VIDPNTOPOLOGY_ADDPATH pfnAddPath; + DXGKDDI_VIDPNTOPOLOGY_REMOVEPATH pfnRemovePath; +} DXGK_VIDPNTOPOLOGY_INTERFACE, *PDXGK_VIDPNTOPOLOGY_INTERFACE; + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_VIDPN_GETTOPOLOGY)( + _In_ const D3DKMDT_HVIDPN hVidPn, + _Out_ D3DKMDT_HVIDPNTOPOLOGY* phVidPnTopology, + _Outptr_ const DXGK_VIDPNTOPOLOGY_INTERFACE** ppVidPnTopologyInterface); + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_VIDPN_ACQUIRESOURCEMODESET)( + _In_ const D3DKMDT_HVIDPN hVidPn, + _In_ const D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, + _Out_ D3DKMDT_HVIDPNSOURCEMODESET * phVidPnSourceModeSet, + _Outptr_ const DXGK_VIDPNSOURCEMODESET_INTERFACE** ppVidPnSourceModeSetInterface); + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_VIDPN_RELEASESOURCEMODESET)( + _In_ const D3DKMDT_HVIDPN hVidPn, + _In_ const D3DKMDT_HVIDPNSOURCEMODESET hVidPnSourceModeSet); + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_VIDPN_CREATENEWSOURCEMODESET)( + _In_ const D3DKMDT_HVIDPN hVidPn, + _In_ const D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, + _Out_ D3DKMDT_HVIDPNSOURCEMODESET* phNewVidPnSourceModeSet, + _Outptr_ const DXGK_VIDPNSOURCEMODESET_INTERFACE** ppVidPnSourceModeSetInterface); + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_VIDPN_ASSIGNSOURCEMODESET)( + _In_ D3DKMDT_HVIDPN hVidPn, + _In_ const D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, + _In_ const D3DKMDT_HVIDPNSOURCEMODESET hVidPnSourceModeSet + ); + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_VIDPN_ASSIGNMULTISAMPLINGMETHODSET)( + _In_ D3DKMDT_HVIDPN hVidPn, + _In_ const D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, + _In_ const SIZE_T NumMethods, + _In_reads_(NumMethods) CONST D3DDDI_MULTISAMPLINGMETHOD* pSupportedMethodSet + ); + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_VIDPN_ACQUIRETARGETMODESET)( + _In_ const D3DKMDT_HVIDPN hVidPn, + _In_ const D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId, + _Out_ D3DKMDT_HVIDPNTARGETMODESET* phVidPnTargetModeSet, + _Outptr_ const DXGK_VIDPNTARGETMODESET_INTERFACE** ppVidPnTargetModeSetInterface + ); + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_VIDPN_RELEASETARGETMODESET)( + _In_ const D3DKMDT_HVIDPN hVidPn, + _In_ const D3DKMDT_HVIDPNTARGETMODESET hVidPnTargetModeSet + ); + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_VIDPN_CREATENEWTARGETMODESET)( + _In_ const D3DKMDT_HVIDPN hVidPn, + _In_ const D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId, + _Out_ D3DKMDT_HVIDPNTARGETMODESET* phNewVidPnTargetModeSet, + _Outptr_ const DXGK_VIDPNTARGETMODESET_INTERFACE** ppVidPnTargetModeSetInterace + ); + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_VIDPN_ASSIGNTARGETMODESET)( + _In_ D3DKMDT_HVIDPN hVidPn, + _In_ const D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId, + _In_ const D3DKMDT_HVIDPNTARGETMODESET hVidPnTargetModeSet); + +typedef struct _DXGK_VIDPN_INTERFACE +{ + DXGK_VIDPN_INTERFACE_VERSION Version; + DXGKDDI_VIDPN_GETTOPOLOGY pfnGetTopology; + DXGKDDI_VIDPN_ACQUIRESOURCEMODESET pfnAcquireSourceModeSet; + DXGKDDI_VIDPN_RELEASESOURCEMODESET pfnReleaseSourceModeSet; + DXGKDDI_VIDPN_CREATENEWSOURCEMODESET pfnCreateNewSourceModeSet; + DXGKDDI_VIDPN_ASSIGNSOURCEMODESET pfnAssignSourceModeSet; + DXGKDDI_VIDPN_ASSIGNMULTISAMPLINGMETHODSET pfnAssignMultisamplingMethodSet; + DXGKDDI_VIDPN_ACQUIRETARGETMODESET pfnAcquireTargetModeSet; + DXGKDDI_VIDPN_RELEASETARGETMODESET pfnReleaseTargetModeSet; + DXGKDDI_VIDPN_CREATENEWTARGETMODESET pfnCreateNewTargetModeSet; + DXGKDDI_VIDPN_ASSIGNTARGETMODESET pfnAssignTargetModeSet; +} DXGK_VIDPN_INTERFACE, *PDXGK_VIDPN_INTERFACE; + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_MONITORSOURCEMODESET_GETNUMMODES)( + _In_ const D3DKMDT_HMONITORSOURCEMODESET hMonitorSourceModeSet, + _Out_ const PSIZE_T pNumMonitorSourceModes); + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_MONITORSOURCEMODESET_ACQUIREPREFERREDMODEINFO)( + _In_ const D3DKMDT_HMONITORSOURCEMODESET hMonitorSourceModeSet, + _Outptr_ const D3DKMDT_MONITOR_SOURCE_MODE** ppFirstMonitorSourceModeInfo); + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_MONITORSOURCEMODESET_ACQUIREFIRSTMODEINFO)( + _In_ const D3DKMDT_HMONITORSOURCEMODESET hMonitorSourceModeSet, + _Outptr_ const D3DKMDT_MONITOR_SOURCE_MODE** ppFirstMonitorSourceModeInfo); + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_MONITORSOURCEMODESET_ACQUIRENEXTMODEINFO)( + _In_ const D3DKMDT_HMONITORSOURCEMODESET hMonitorSourceModeSet, + _In_ const D3DKMDT_MONITOR_SOURCE_MODE* pMonitorSourceModeInfo, + _Outptr_ const D3DKMDT_MONITOR_SOURCE_MODE** ppNextMonitorSourceModeInfo); + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_MONITORSOURCEMODESET_CREATENEWMODEINFO)( + _In_ const D3DKMDT_HMONITORSOURCEMODESET hMonitorSourceModeSet, + _Outptr_ D3DKMDT_MONITOR_SOURCE_MODE** ppNewMonitorSourceModeInfo); + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_MONITORSOURCEMODESET_ADDMODE)( + _In_ const D3DKMDT_HMONITORSOURCEMODESET hMonitorSourceModeSet, + _In_ const D3DKMDT_MONITOR_SOURCE_MODE* pMonitorSourceModeInfo); + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_MONITORSOURCEMODESET_RELEASEMODEINFO)( + _In_ const D3DKMDT_HMONITORSOURCEMODESET hMonitorSourceModeSet, + _In_ const D3DKMDT_MONITOR_SOURCE_MODE* pMonitorSourceModeInfo); + +typedef struct _DXGK_MONITORSOURCEMODESET_INTERFACE +{ + DXGKDDI_MONITORSOURCEMODESET_GETNUMMODES pfnGetNumModes; + DXGKDDI_MONITORSOURCEMODESET_ACQUIREPREFERREDMODEINFO pfnAcquirePreferredModeInfo; + DXGKDDI_MONITORSOURCEMODESET_ACQUIREFIRSTMODEINFO pfnAcquireFirstModeInfo; + DXGKDDI_MONITORSOURCEMODESET_ACQUIRENEXTMODEINFO pfnAcquireNextModeInfo; + DXGKDDI_MONITORSOURCEMODESET_CREATENEWMODEINFO pfnCreateNewModeInfo; + DXGKDDI_MONITORSOURCEMODESET_ADDMODE pfnAddMode; + DXGKDDI_MONITORSOURCEMODESET_RELEASEMODEINFO pfnReleaseModeInfo; +} DXGK_MONITORSOURCEMODESET_INTERFACE, *PDXGK_MONITORSOURCEMODESET_INTERFACE; + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_MONITORFREQUENCYRANGESET_GETNUMFREQUENCYRANGES)( + _In_ const D3DKMDT_HMONITORFREQUENCYRANGESET hMonitorFrequencyRangeSet, + _Out_ const PSIZE_T pNumMonitorFrequencyRanges); + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_MONITORFREQUENCYRANGESET_ACQUIREFIRSTFREQUENCYRANGEINFO)( + _In_ const D3DKMDT_HMONITORFREQUENCYRANGESET hMonitorFrequencyRangeSet, + _Outptr_ const D3DKMDT_MONITOR_FREQUENCY_RANGE** ppFirstMonitorFrequencyRangeInfo); + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_MONITORFREQUENCYRANGESET_ACQUIRENEXTFREQUENCYRANGEINFO)( + _In_ const D3DKMDT_HMONITORFREQUENCYRANGESET hMonitorFrequencyRangeSet, + _In_ const D3DKMDT_MONITOR_FREQUENCY_RANGE* pMonitorFrequencyRangeInfo, + _Outptr_ const D3DKMDT_MONITOR_FREQUENCY_RANGE** ppNextMonitorFrequencyRangeInfo); + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_MONITORFREQUENCYRANGESET_RELEASEFREQUENCYRANGEINFO)( + _In_ const D3DKMDT_HMONITORFREQUENCYRANGESET hMonitorFrequencyRangeSet, + _In_ const D3DKMDT_MONITOR_FREQUENCY_RANGE* pMonitorFrequencyRangeInfo); + +typedef struct _DXGK_MONITORFREQUENCYRANGESET_INTERFACE +{ + DXGKDDI_MONITORFREQUENCYRANGESET_GETNUMFREQUENCYRANGES pfnGetNumFrequencyRanges; + DXGKDDI_MONITORFREQUENCYRANGESET_ACQUIREFIRSTFREQUENCYRANGEINFO pfnAcquireFirstFrequencyRangeInfo; + DXGKDDI_MONITORFREQUENCYRANGESET_ACQUIRENEXTFREQUENCYRANGEINFO pfnAcquireNextFrequencyRangeInfo; + DXGKDDI_MONITORFREQUENCYRANGESET_RELEASEFREQUENCYRANGEINFO pfnReleaseFrequencyRangeInfo; +} DXGK_MONITORFREQUENCYRANGESET_INTERFACE, *PDXGK_MONITORFREQUENCYRANGESET_INTERFACE; + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_MONITORDESCRIPTORSET_GETNUMDESCRIPTORS)( + _In_ const D3DKMDT_HMONITORDESCRIPTORSET hMonitorDescriptorSet, + _Out_ const PSIZE_T pNumMonitorDescriptors); + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_MONITORDESCRIPTORSET_ACQUIREFIRSTDESCRIPTORINFO)( + _In_ const D3DKMDT_HMONITORDESCRIPTORSET hMonitorDescriptorSet, + _Outptr_ const D3DKMDT_MONITOR_DESCRIPTOR** ppFirstMonitorDescriptorInfo); + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_MONITORDESCRIPTORSET_ACQUIRENEXTDESCRIPTORINFO)( + _In_ const D3DKMDT_HMONITORDESCRIPTORSET hMonitorDescriptorSet, + _In_ const D3DKMDT_MONITOR_DESCRIPTOR* pMonitorDescriptorInfo, + _Outptr_ const D3DKMDT_MONITOR_DESCRIPTOR** ppNextMonitorDescriptorInfo); + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_MONITORDESCRIPTORSET_RELEASEDESCRIPTORINFO)( + _In_ const D3DKMDT_HMONITORDESCRIPTORSET hMonitorDescriptorSet, + _In_ const D3DKMDT_MONITOR_DESCRIPTOR* pMonitorDescriptorInfo); + +typedef struct _DXGK_MONITORDESCRIPTORSET_INTERFACE +{ + DXGKDDI_MONITORDESCRIPTORSET_GETNUMDESCRIPTORS pfnGetNumDescriptors; + DXGKDDI_MONITORDESCRIPTORSET_ACQUIREFIRSTDESCRIPTORINFO pfnAcquireFirstDescriptorInfo; + DXGKDDI_MONITORDESCRIPTORSET_ACQUIRENEXTDESCRIPTORINFO pfnAcquireNextDescriptorInfo; + DXGKDDI_MONITORDESCRIPTORSET_RELEASEDESCRIPTORINFO pfnReleaseDescriptorInfo; +} DXGK_MONITORDESCRIPTORSET_INTERFACE, *PDXGK_MONITORDESCRIPTORSET_INTERFACE; + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_MONITOR_ACQUIREMONITORSOURCEMODESET)( + _In_ const D3DKMDT_ADAPTER hAdapter, + _In_ const D3DDDI_VIDEO_PRESENT_TARGET_ID VideoPresentTargetId, + _Out_ D3DKMDT_HMONITORSOURCEMODESET* phMonitorSourceModeSet, + _Outptr_ const PDXGK_MONITORSOURCEMODESET_INTERFACE* ppMonitorSourceModeSetInterface); + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_MONITOR_RELEASEMONITORSOURCEMODESET)( + _In_ const D3DKMDT_ADAPTER hAdapter, + _In_ const D3DKMDT_HMONITORSOURCEMODESET hMonitorSourceModeSet); + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_MONITOR_GETMONITORFREQUENCYRANGESET)( + _In_ const D3DKMDT_ADAPTER hAdapter, + _In_ const D3DDDI_VIDEO_PRESENT_TARGET_ID VideoPresentTargetId, + _Out_ D3DKMDT_HMONITORFREQUENCYRANGESET* phMonitorFrequencyRangeSet, + _Outptr_ const PDXGK_MONITORFREQUENCYRANGESET_INTERFACE* ppMonitorFrequencyRangeSetInterface); + +typedef +NTSTATUS +(APIENTRY *DXGKDDI_MONITOR_GETMONITORDESCRIPTORSET)( + _In_ const D3DKMDT_ADAPTER hAdapter, + _In_ const D3DDDI_VIDEO_PRESENT_TARGET_ID VideoPresentTargetId, + _Out_ D3DKMDT_HMONITORDESCRIPTORSET* phMonitorDescriptorSet, + _Outptr_ const PDXGK_MONITORDESCRIPTORSET_INTERFACE* ppMonitorDescriptorSetInterface); + +typedef struct _DXGK_MONITOR_INTERFACE +{ + DXGK_MONITOR_INTERFACE_VERSION Version; + DXGKDDI_MONITOR_ACQUIREMONITORSOURCEMODESET pfnAcquireMonitorSourceModeSet; + DXGKDDI_MONITOR_RELEASEMONITORSOURCEMODESET pfnReleaseMonitorSourceModeSet; + DXGKDDI_MONITOR_GETMONITORFREQUENCYRANGESET pfnGetMonitorFrequencyRangeSet; + DXGKDDI_MONITOR_GETMONITORDESCRIPTORSET pfnGetMonitorDescriptorSet; +} DXGK_MONITOR_INTERFACE, *PDXGK_MONITOR_INTERFACE; + +typedef +VOID* +(APIENTRY *DXGKCB_GETHANDLEDATA)(IN_CONST_PDXGKARGCB_GETHANDLEDATA); + +typedef +D3DKMT_HANDLE +(APIENTRY *DXGKCB_GETHANDLEPARENT)(_In_ D3DKMT_HANDLE hAllocation); + +typedef +D3DKMT_HANDLE +(APIENTRY *DXGKCB_ENUMHANDLECHILDREN)(IN_CONST_PDXGKARGCB_ENUMHANDLECHILDREN); + +typedef +VOID +(APIENTRY *DXGKCB_NOTIFY_INTERRUPT)( + _In_ const HANDLE hAdapter, IN_CONST_PDXGKARGCB_NOTIFY_INTERRUPT_DATA); + +typedef +VOID +(APIENTRY *DXGKCB_NOTIFY_DPC)( + _In_ const HANDLE hAdapter); + +typedef +NTSTATUS +(APIENTRY *DXGKCB_QUERYVIDPNINTERFACE)( + _In_ const D3DKMDT_HVIDPN hVidPn, + _In_ const DXGK_VIDPN_INTERFACE_VERSION VidPnInterfaceVersion, + _Outptr_ const DXGK_VIDPN_INTERFACE** ppVidPnInterface); + +typedef +NTSTATUS +(APIENTRY *DXGKCB_QUERYMONITORINTERFACE)( + _In_ const HANDLE hAdapter, + _In_ const DXGK_MONITOR_INTERFACE_VERSION MonitorInterfaceVersion, + _Outptr_ const DXGK_MONITOR_INTERFACE** ppMonitorInterface); + +typedef +NTSTATUS +(APIENTRY *DXGKCB_GETCAPTUREADDRESS)(_Inout_ PDXGKARGCB_GETCAPTUREADDRESS); + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) + +typedef struct _DXGK_CREATECONTEXTALLOCATIONFLAGS +{ + union + { + struct + { + UINT SharedAcrossContexts : 1; +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0) + UINT MapGpuVirtualAddress : 1; + UINT Reserved : 30; +#else + UINT Reserved : 31; +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0) + }; + UINT Value; + }; +} DXGK_CREATECONTEXTALLOCATIONFLAGS; + +typedef struct _DXGKARGCB_CREATECONTEXTALLOCATION +{ + DXGK_CREATECONTEXTALLOCATIONFLAGS ContextAllocationFlags; + HANDLE hAdapter; + HANDLE hDevice; + HANDLE hContext; + HANDLE hDriverAllocation; + SIZE_T Size; + UINT Alignment; + UINT SupportedSegmentSet; + UINT EvictionSegmentSet; + DXGK_SEGMENTPREFERENCE PreferredSegment; + DXGK_SEGMENTBANKPREFERENCE HintedBank; + DXGK_ALLOCATIONINFOFLAGS Flags; + HANDLE hAllocation; +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0) + UINT PhysicalAdapterIndex; +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0) +} DXGKARGCB_CREATECONTEXTALLOCATION, *PDXGKARGCB_CREATECONTEXTALLOCATION; + +typedef +NTSTATUS +(APIENTRY *DXGKCB_CREATECONTEXTALLOCATION)( + _Inout_ PDXGKARGCB_CREATECONTEXTALLOCATION + ); + +typedef +NTSTATUS +(APIENTRY *DXGKCB_DESTROYCONTEXTALLOCATION)( + _In_ const HANDLE hAdapter, + _In_ const HANDLE hAllocation + ); + +typedef +VOID +(APIENTRY *DXGKCB_SETPOWERCOMPONENTACTIVE)( + _In_ const HANDLE hAdapter, + _In_ UINT ComponentIndex + ); + +typedef +NTSTATUS +(APIENTRY *DXGKCB_POWERRUNTIMECONTROLREQUEST)( + _In_ const HANDLE hAdapter, + _In_ const LPCGUID PowerControlCode, + _In_opt_ PVOID InBuffer, + _In_ SIZE_T InBufferSize, + _Out_opt_ PVOID OutBuffer, + _In_ SIZE_T OutBufferSize, + _Out_opt_ PSIZE_T BytesReturned + ); + +typedef +VOID +(APIENTRY *DXGKCB_SETPOWERCOMPONENTIDLE)( + _In_ const HANDLE hAdapter, + _In_ UINT ComponentIndex + ); + +typedef +VOID +(APIENTRY *DXGKCB_SETPOWERCOMPONENTLATENCY)( + _In_ const HANDLE hAdapter, + _In_ UINT ComponentIndex, + _In_ ULONGLONG Latency + ); + +typedef +VOID +(APIENTRY *DXGKCB_SETPOWERCOMPONENTRESIDENCY)( + _In_ const HANDLE hAdapter, + _In_ UINT ComponentIndex, + _In_ ULONGLONG Residency + ); + +typedef +VOID +(APIENTRY *DXGKCB_COMPLETEFSTATETRANSITION)( + _In_ const HANDLE hAdapter, + _In_ UINT ComponentIndex + ); + +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM1_3) + +typedef +VOID +(APIENTRY *DXGKCB_COMPLETEPSTATETRANSITION)( + _In_ const HANDLE hAdapter, + _In_ UINT ComponentIndex, + _In_ UINT CompletedPState + ); + +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM1_3) + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0) + +typedef VOID* DXGKARG_RELEASE_HANDLE; +typedef DXGKARG_RELEASE_HANDLE* PDXGKARG_RELEASE_HANDLE; + +typedef +VOID* +(APIENTRY *DXGKCB_ACQUIREHANDLEDATA)( + _In_ const PDXGKARGCB_GETHANDLEDATA pGetHandleData, + _Out_ PDXGKARG_RELEASE_HANDLE pReleaseHandle + ); + +typedef struct _DXGKARGCB_RELEASEHANDLEDATA +{ + DXGKARG_RELEASE_HANDLE ReleaseHandle; + DXGK_HANDLE_TYPE Type; +} DXGKARGCB_RELEASEHANDLEDATA; + +typedef +VOID +(APIENTRY *DXGKCB_RELEASEHANDLEDATA)( + _In_ const DXGKARGCB_RELEASEHANDLEDATA pArgs + ); + +typedef struct _DXGKARGCB_MAPCONTEXTALLOCATION +{ + D3DGPU_VIRTUAL_ADDRESS BaseAddress; + D3DGPU_VIRTUAL_ADDRESS MinimumAddress; + D3DGPU_VIRTUAL_ADDRESS MaximumAddress; + HANDLE hAllocation; + D3DGPU_SIZE_T OffsetInPages; + D3DGPU_SIZE_T SizeInPages; + D3DDDIGPUVIRTUALADDRESS_PROTECTION_TYPE Protection; + UINT64 DriverProtection; +} DXGKARGCB_MAPCONTEXTALLOCATION; + +typedef +D3DGPU_VIRTUAL_ADDRESS +(APIENTRY *DXGKCB_MAPCONTEXTALLOCATION)( + _In_ const HANDLE hAdapter, + _In_ const DXGKARGCB_MAPCONTEXTALLOCATION* pArgs + ); + +typedef struct _DXGKARGCB_UPDATECONTEXTALLOCATION +{ + HANDLE hAllocation; + PVOID pPrivateDriverData; + UINT PrivateDriverDataSize; +} DXGKARGCB_UPDATECONTEXTALLOCATION; + +typedef +NTSTATUS +(APIENTRY *DXGKCB_UPDATECONTEXTALLOCATION)( + _In_ const HANDLE hAdapter, + _In_ const DXGKARGCB_UPDATECONTEXTALLOCATION* pArgs + ); + +typedef struct _DXGKARGCB_RESERVEGPUVIRTUALADDRESSRANGE +{ + HANDLE hDxgkProcess; + UINT64 SizeInBytes; + UINT Alignment; + UINT64 StartVirtualAddress; + UINT64 BaseAddress; + union + { + struct + { + UINT AllowUserModeMapping : 1; + }; + UINT Flags; + }; +} DXGKARGCB_RESERVEGPUVIRTUALADDRESSRANGE; + +typedef +NTSTATUS +(APIENTRY *DXGKCB_RESERVEGPUVIRTUALADDRESSRANGE)( + _In_ const HANDLE hAdapter, + _Inout_ DXGKARGCB_RESERVEGPUVIRTUALADDRESSRANGE* pArgs + ); + +typedef enum _DXGK_HARDWARE_CONTENT_PROTECTION_TEARDOWN_FLAGS +{ + DXGK_HARDWARE_CONTENT_PROTECTION_TEARDOWN_FLAG_PREEMPTIVE = 1 +} DXGK_HARDWARE_CONTENT_PROTECTION_TEARDOWN_FLAGS; + +typedef +VOID +(APIENTRY *DXGKCB_HARDWARECONTENTPROTECTIONTEARDOWN)( + _In_ const HANDLE hAdapter, + _In_ UINT Flags + ); + +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0) + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_2) +typedef struct _DXGK_QUERYADAPTERINFOFLAGS +{ + union + { + struct + { + UINT VirtualMachineData : 1; + UINT SecureVirtualMachine : 1; + UINT Reserved : 30; + }; + UINT Value; + }; + } DXGK_QUERYADAPTERINFOFLAGS; + #endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_2) + +typedef struct _DXGKARG_QUERYADAPTERINFO +{ + DXGK_QUERYADAPTERINFOTYPE Type; + VOID* pInputData; + UINT InputDataSize; + VOID* pOutputData; + UINT OutputDataSize; +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_2) + DXGK_QUERYADAPTERINFOFLAGS Flags; +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_2) +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_4) + HANDLE hKmdProcessHandle; +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_4) +} DXGKARG_QUERYADAPTERINFO, *PDXGKARG_QUERYADAPTERINFO; + +typedef struct _DXGK_DEVICEINFOFLAGS +{ + union + { + struct + { + UINT GuaranteedDmaBufferContract : 1; + UINT Reserved : 31; + }; + UINT Value; + }; + } DXGK_DEVICEINFOFLAGS; + +typedef struct _DXGK_DEVICEINFO +{ + UINT DmaBufferSize; + UINT DmaBufferSegmentSet; + UINT DmaBufferPrivateDataSize; + UINT AllocationListSize; + UINT PatchLocationListSize; + DXGK_DEVICEINFOFLAGS Flags; +} DXGK_DEVICEINFO; + +typedef struct _DXGK_CREATEDEVICEFLAGS +{ + union + { + struct + { + UINT SystemDevice : 1; + UINT GdiDevice : 1; + UINT Reserved : 29; + UINT DXGK_DEVICE_RESERVED0 : 1; + }; + UINT Value; + }; +} DXGK_CREATEDEVICEFLAGS; + +typedef struct _DXGKARG_CREATEDEVICE +{ + HANDLE hDevice; + union + { + DXGK_CREATEDEVICEFLAGS Flags; + DXGK_DEVICEINFO* pInfo; + }; +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0) + ULONG Pasid; + HANDLE hKmdProcess; +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0) +} DXGKARG_CREATEDEVICE, *PDXGKARG_CREATEDEVICE; + +typedef +NTSTATUS +APIENTRY +DXGKDDI_QUERYADAPTERINFO( + _In_ const HANDLE hAdapter, + _In_ const DXGKARG_QUERYADAPTERINFO* pQueryAdapterInfo); + +typedef +NTSTATUS +APIENTRY +DXGKDDI_CREATEDEVICE( + _In_ const HANDLE hAdapter, + _Inout_ PDXGKARG_CREATEDEVICE pCreateDevice); + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN7) + +typedef struct _DXGKARG_QUERYVIDPNHWCAPABILITY +{ + _In_ D3DKMDT_HVIDPN hFunctionalVidPn; + _In_ D3DDDI_VIDEO_PRESENT_SOURCE_ID SourceId; + _In_ D3DDDI_VIDEO_PRESENT_TARGET_ID TargetId; + _Out_ D3DKMDT_VIDPN_HW_CAPABILITY VidPnHWCaps; +} DXGKARG_QUERYVIDPNHWCAPABILITY; + +typedef +_Check_return_ +NTSTATUS +APIENTRY +DXGKDDI_QUERYVIDPNHWCAPABILITY( + _In_ const HANDLE hAdapter, + _Inout_ DXGKARG_QUERYVIDPNHWCAPABILITY* pVidPnHWCaps); + +typedef DXGKDDI_QUERYVIDPNHWCAPABILITY *PDXGKDDI_QUERYVIDPNHWCAPABILITY; + +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN7) + +typedef DXGKDDI_QUERYADAPTERINFO *PDXGKDDI_QUERYADAPTERINFO; +typedef DXGKDDI_CREATEDEVICE *PDXGKDDI_CREATEDEVICE; +#if 0 +typedef DXGKDDI_DESTROYALLOCATION *PDXGKDDI_DESTROYALLOCATION; +typedef DXGKDDI_DESCRIBEALLOCATION *PDXGKDDI_DESCRIBEALLOCATION; +typedef DXGKDDI_GETSTANDARDALLOCATIONDRIVERDATA *PDXGKDDI_GETSTANDARDALLOCATIONDRIVERDATA; +typedef DXGKDDI_ACQUIRESWIZZLINGRANGE *PDXGKDDI_ACQUIRESWIZZLINGRANGE; +typedef DXGKDDI_RELEASESWIZZLINGRANGE *PDXGKDDI_RELEASESWIZZLINGRANGE; +typedef DXGKDDI_PATCH *PDXGKDDI_PATCH; +typedef DXGKDDI_SUBMITCOMMAND *PDXGKDDI_SUBMITCOMMAND; +typedef DXGKDDI_PREEMPTCOMMAND *PDXGKDDI_PREEMPTCOMMAND; +typedef DXGKDDI_CANCELCOMMAND *PDXGKDDI_CANCELCOMMAND; +typedef DXGKDDI_BUILDPAGINGBUFFER *PDXGKDDI_BUILDPAGINGBUFFER; +typedef DXGKDDI_SETPALETTE *PDXGKDDI_SETPALETTE; +typedef DXGKDDI_SETPOINTERPOSITION *PDXGKDDI_SETPOINTERPOSITION; +typedef DXGKDDI_SETPOINTERSHAPE *PDXGKDDI_SETPOINTERSHAPE; +typedef DXGKDDI_RESETFROMTIMEOUT *PDXGKDDI_RESETFROMTIMEOUT; +typedef DXGKDDI_RESTARTFROMTIMEOUT *PDXGKDDI_RESTARTFROMTIMEOUT; +typedef DXGKDDI_ESCAPE *PDXGKDDI_ESCAPE; +typedef DXGKDDI_COLLECTDBGINFO *PDXGKDDI_COLLECTDBGINFO; +typedef DXGKDDI_QUERYCURRENTFENCE *PDXGKDDI_QUERYCURRENTFENCE; +typedef DXGKDDI_ISSUPPORTEDVIDPN *PDXGKDDI_ISSUPPORTEDVIDPN; +typedef DXGKDDI_RECOMMENDFUNCTIONALVIDPN *PDXGKDDI_RECOMMENDFUNCTIONALVIDPN; +typedef DXGKDDI_ENUMVIDPNCOFUNCMODALITY *PDXGKDDI_ENUMVIDPNCOFUNCMODALITY; +typedef DXGKDDI_SETVIDPNSOURCEADDRESS *PDXGKDDI_SETVIDPNSOURCEADDRESS; +typedef DXGKDDI_SETVIDPNSOURCEVISIBILITY *PDXGKDDI_SETVIDPNSOURCEVISIBILITY; +typedef DXGKDDI_COMMITVIDPN *PDXGKDDI_COMMITVIDPN; +typedef DXGKDDI_UPDATEACTIVEVIDPNPRESENTPATH *PDXGKDDI_UPDATEACTIVEVIDPNPRESENTPATH; +typedef DXGKDDI_RECOMMENDMONITORMODES *PDXGKDDI_RECOMMENDMONITORMODES; +typedef DXGKDDI_RECOMMENDVIDPNTOPOLOGY *PDXGKDDI_RECOMMENDVIDPNTOPOLOGY; +typedef DXGKDDI_GETSCANLINE *PDXGKDDI_GETSCANLINE; +typedef DXGKDDI_STOPCAPTURE *PDXGKDDI_STOPCAPTURE; +typedef DXGKDDI_CONTROLINTERRUPT *PDXGKDDI_CONTROLINTERRUPT; +typedef DXGKDDI_CREATEOVERLAY *PDXGKDDI_CREATEOVERLAY; +typedef DXGKDDI_DESTROYDEVICE *PDXGKDDI_DESTROYDEVICE; +typedef DXGKDDI_OPENALLOCATIONINFO *PDXGKDDI_OPENALLOCATIONINFO; +typedef DXGKDDI_CLOSEALLOCATION *PDXGKDDI_CLOSEALLOCATION; +typedef DXGKDDI_RENDER *PDXGKDDI_RENDER; +typedef DXGKDDI_PRESENT *PDXGKDDI_PRESENT; +typedef DXGKDDI_UPDATEOVERLAY *PDXGKDDI_UPDATEOVERLAY; +typedef DXGKDDI_FLIPOVERLAY *PDXGKDDI_FLIPOVERLAY; +typedef DXGKDDI_DESTROYOVERLAY *PDXGKDDI_DESTROYOVERLAY; +typedef DXGKDDI_CREATECONTEXT *PDXGKDDI_CREATECONTEXT; +typedef DXGKDDI_DESTROYCONTEXT *PDXGKDDI_DESTROYCONTEXT; +typedef DXGKDDI_SETDISPLAYPRIVATEDRIVERFORMAT *PDXGKDDI_SETDISPLAYPRIVATEDRIVERFORMAT; +#endif +/* + * NOTE: + * dispmprt.h's DRIVER_INITIALIZATION_DATA relies on a large set of PDXGKDDI_* + * function pointer typedefs. + * + * Historically this header used UINT32* placeholders for many of these types. + * That is dangerous because it silently turns function pointers into data + * pointers, obscuring ABI and making debugging/interop harder (even if pointer + * sizes match on x64). + * + * Only keep placeholders for DDIs we truly don't model yet. For DDIs we do + * model (Escape, OpenAllocation, Present, CreateContext, DestroyContext, etc) + * we must NOT override the real prototypes. + */ + +typedef UINT32 *PDXGKDDI_DESTROYALLOCATION; +typedef UINT32 *PDXGKDDI_DESCRIBEALLOCATION; +typedef UINT32 *PDXGKDDI_GETSTANDARDALLOCATIONDRIVERDATA; +typedef UINT32 *PDXGKDDI_ACQUIRESWIZZLINGRANGE; +typedef UINT32 *PDXGKDDI_RELEASESWIZZLINGRANGE; +typedef UINT32 *PDXGKDDI_PATCH; +typedef UINT32 *PDXGKDDI_SUBMITCOMMAND; +typedef UINT32 *PDXGKDDI_PREEMPTCOMMAND; +typedef UINT32 *PDXGKDDI_CANCELCOMMAND; +typedef UINT32 *PDXGKDDI_BUILDPAGINGBUFFER; +typedef UINT32 *PDXGKDDI_SETPALETTE; + +typedef +_Check_return_ +NTSTATUS +(APIENTRY *PDXGKDDI_SETPOINTERPOSITION)( + _In_ const HANDLE hAdapter, + _In_ const DXGKARG_SETPOINTERPOSITION* pSetPointerPosition + ); + +typedef +_Check_return_ +NTSTATUS +(APIENTRY *PDXGKDDI_SETPOINTERSHAPE)( + _In_ const HANDLE hAdapter, + _In_ const DXGKARG_SETPOINTERSHAPE* pSetPointerShape + ); + +typedef UINT32 *PDXGKDDI_RESETFROMTIMEOUT; +typedef UINT32 *PDXGKDDI_RESTARTFROMTIMEOUT; +typedef UINT32 *PDXGKDDI_COLLECTDBGINFO; +typedef UINT32 *PDXGKDDI_QUERYCURRENTFENCE; + +typedef +_Check_return_ +NTSTATUS +(APIENTRY *PDXGKDDI_ISSUPPORTEDVIDPN)( + _In_ const HANDLE hAdapter, + _Inout_ DXGKARG_ISSUPPORTEDVIDPN* pIsSupportedVidPn + ); + +typedef +_Check_return_ +NTSTATUS +(APIENTRY *PDXGKDDI_RECOMMENDFUNCTIONALVIDPN)( + _In_ const HANDLE hAdapter, + _In_ const DXGKARG_RECOMMENDFUNCTIONALVIDPN* pRecommendFunctionalVidPn + ); + +typedef +_Check_return_ +NTSTATUS +(APIENTRY *PDXGKDDI_ENUMVIDPNCOFUNCMODALITY)( + _In_ const HANDLE hAdapter, + _In_ IN_CONST_PDXGKARG_ENUMVIDPNCOFUNCMODALITY_CONST pEnumCofuncModality + ); + +typedef +_Check_return_ +NTSTATUS +(APIENTRY *PDXGKDDI_SETVIDPNSOURCEADDRESS)( + _In_ const HANDLE hAdapter, + _In_ const DXGKARG_SETVIDPNSOURCEADDRESS* pSetVidPnSourceAddress + ); + +typedef +_Check_return_ +NTSTATUS +(APIENTRY *PDXGKDDI_SETVIDPNSOURCEVISIBILITY)( + _In_ const HANDLE hAdapter, + _In_ const DXGKARG_SETVIDPNSOURCEVISIBILITY* pSetVidPnSourceVisibility + ); + +typedef +_Check_return_ +NTSTATUS +(APIENTRY *PDXGKDDI_COMMITVIDPN)( + _In_ const HANDLE hAdapter, + _In_ const DXGKARG_COMMITVIDPN* pCommitVidPn + ); + +typedef +_Check_return_ +NTSTATUS +(APIENTRY *PDXGKDDI_UPDATEACTIVEVIDPNPRESENTPATH)( + _In_ const HANDLE hAdapter, + _In_ const DXGKARG_UPDATEACTIVEVIDPNPRESENTPATH* pUpdateActiveVidPnPresentPath + ); + +typedef +_Check_return_ +NTSTATUS +(APIENTRY *PDXGKDDI_RECOMMENDMONITORMODES)( + _In_ const HANDLE hAdapter, + _In_ const DXGKARG_RECOMMENDMONITORMODES* pRecommendMonitorModes + ); + +typedef +_Check_return_ +NTSTATUS +(APIENTRY *PDXGKDDI_RECOMMENDVIDPNTOPOLOGY)( + _In_ const HANDLE hAdapter, + _In_ const DXGKARG_RECOMMENDVIDPNTOPOLOGY* pRecommendVidPnTopology + ); + +typedef UINT32 *PDXGKDDI_GETSCANLINE; +typedef UINT32 *PDXGKDDI_STOPCAPTURE; +typedef UINT32 *PDXGKDDI_CONTROLINTERRUPT; +typedef UINT32 *PDXGKDDI_CREATEOVERLAY; +typedef UINT32 *PDXGKDDI_DESTROYDEVICE; +typedef UINT32 *PDXGKDDI_CLOSEALLOCATION; +typedef UINT32 *PDXGKDDI_UPDATEOVERLAY; +typedef UINT32 *PDXGKDDI_FLIPOVERLAY; +typedef UINT32 *PDXGKDDI_DESTROYOVERLAY; +typedef UINT32 *PDXGKDDI_SETDISPLAYPRIVATEDRIVERFORMAT; + +/* + * Real prototypes required by dispmprt.h's DRIVER_INITIALIZATION_DATA: + * Define these as function pointer types (NOT UINT32* placeholders). + * We only need forward declarations for the payload structs here. + */ + +typedef struct _DXGKARG_OPENALLOCATION DXGKARG_OPENALLOCATION; +typedef struct _DXGKARG_PRESENT DXGKARG_PRESENT; +typedef struct _DXGKARG_RENDER DXGKARG_RENDER; +typedef struct _DXGKARG_CREATECONTEXT DXGKARG_CREATECONTEXT; + +typedef +_Check_return_ +NTSTATUS +APIENTRY +DXGKDDI_OPENALLOCATIONINFO( + _In_ const HANDLE hDevice, + _In_ const DXGKARG_OPENALLOCATION* pOpenAllocation + ); +typedef DXGKDDI_OPENALLOCATIONINFO *PDXGKDDI_OPENALLOCATIONINFO; + +typedef +_Check_return_ +NTSTATUS +APIENTRY +DXGKDDI_PRESENT( + _In_ const HANDLE hContext, + _Inout_ DXGKARG_PRESENT* pPresent + ); +typedef DXGKDDI_PRESENT *PDXGKDDI_PRESENT; + +typedef +_Check_return_ +NTSTATUS +APIENTRY +DXGKDDI_RENDER( + _In_ const HANDLE hContext, + _Inout_ DXGKARG_RENDER* pRender + ); +typedef DXGKDDI_RENDER *PDXGKDDI_RENDER; +typedef DXGKDDI_RENDER *PDXGKDDI_RENDERKM; + +typedef +_Check_return_ +NTSTATUS +APIENTRY +DXGKDDI_CREATECONTEXT( + _In_ const HANDLE hDevice, + _Inout_ DXGKARG_CREATECONTEXT* pCreateContext + ); +typedef DXGKDDI_CREATECONTEXT *PDXGKDDI_CREATECONTEXT; + +typedef +_Check_return_ +NTSTATUS +APIENTRY +DXGKDDI_DESTROYCONTEXT( + _In_ const HANDLE hContext + ); +typedef DXGKDDI_DESTROYCONTEXT *PDXGKDDI_DESTROYCONTEXT; + +/* + * TODO: + * dispmprt.h's DRIVER_INITIALIZATION_DATA references a number of additional + * WDDM DDI entrypoints whose full prototypes are not yet declared yet. + */ + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) +typedef VOID* PDXGKDDISETPOWERCOMPONENTFSTATE; +typedef VOID* PDXGKDDI_QUERYDEPENDENTENGINEGROUP; +typedef VOID* PDXGKDDI_QUERYENGINESTATUS; +typedef VOID* PDXGKDDI_RESETENGINE; +typedef VOID* PDXGKDDIPOWERRUNTIMECONTROLREQUEST; +typedef VOID* PDXGKDDI_SETVIDPNSOURCEADDRESSWITHMULTIPLANEOVERLAY; +#endif + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM1_3) +typedef VOID* PDXGKDDI_GETNODEMETADATA; +typedef VOID* PDXGKDDISETPOWERPSTATE; +typedef VOID* PDXGKDDI_CONTROLINTERRUPT2; +typedef VOID* PDXGKDDI_CHECKMULTIPLANEOVERLAYSUPPORT; +typedef VOID* PDXGKDDI_CALIBRATEGPUCLOCK; +typedef VOID* PDXGKDDI_FORMATHISTORYBUFFER; +#endif + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0) +typedef VOID* PDXGKDDI_RENDERGDI; +typedef VOID* PDXGKDDI_SUBMITCOMMANDVIRTUAL; +typedef VOID* PDXGKDDI_SETROOTPAGETABLE; +typedef VOID* PDXGKDDI_GETROOTPAGETABLESIZE; +typedef VOID* PDXGKDDI_MAPCPUHOSTAPERTURE; +typedef VOID* PDXGKDDI_UNMAPCPUHOSTAPERTURE; +typedef VOID* PDXGKDDI_CHECKMULTIPLANEOVERLAYSUPPORT2; +typedef VOID* PDXGKDDI_CREATEPROCESS; +typedef VOID* PDXGKDDI_DESTROYPROCESS; +typedef VOID* PDXGKDDI_SETVIDPNSOURCEADDRESSWITHMULTIPLANEOVERLAY2; +typedef VOID* PDXGKDDI_POWERRUNTIMESETDEVICEHANDLE; +typedef VOID* PDXGKDDI_SETSTABLEPOWERSTATE; +typedef VOID* PDXGKDDI_SETVIDEOPROTECTEDREGION; +#endif + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_1) +typedef VOID* DXGKCB_MULTIPLANEOVERLAYDISABLED; +typedef VOID* DXGKCB_MITIGATEDRANGEUPDATE; +typedef VOID* PDXGKDDI_CHECKMULTIPLANEOVERLAYSUPPORT3; +typedef VOID* PDXGKDDI_SETVIDPNSOURCEADDRESSWITHMULTIPLANEOVERLAY3; +typedef VOID* PDXGKDDI_POSTMULTIPLANEOVERLAYPRESENT; +typedef VOID* PDXGKDDI_VALIDATEUPDATEALLOCATIONPROPERTY; +typedef VOID* PDXGKDDI_CONTROLMODEBEHAVIOR; +typedef VOID* PDXGKDDI_UPDATEMONITORLINKINFO; +#endif + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_2) +typedef VOID* DXGKCB_INVALIDATEHWCONTEXT; +typedef VOID* DXGKCB_INDICATE_CONNECTOR_CHANGE; +typedef VOID* DXGKCB_UNBLOCKUEFIFRAMEBUFFERRANGES; +typedef VOID* PDXGKDDI_CREATEHWCONTEXT; +typedef VOID* PDXGKDDI_DESTROYHWCONTEXT; +typedef VOID* PDXGKDDI_CREATEHWQUEUE; +typedef VOID* PDXGKDDI_DESTROYHWQUEUE; +typedef VOID* PDXGKDDI_SUBMITCOMMANDTOHWQUEUE; +typedef VOID* PDXGKDDI_SWITCHTOHWCONTEXTLIST; +typedef VOID* PDXGKDDI_RESETHWENGINE; +typedef VOID* PDXGKDDI_CREATEPERIODICFRAMENOTIFICATION; +typedef VOID* PDXGKDDI_DESTROYPERIODICFRAMENOTIFICATION; +typedef VOID* PDXGKDDI_SETTIMINGSFROMVIDPN; +typedef VOID* PDXGKDDI_SETTARGETGAMMA; +typedef VOID* PDXGKDDI_SETTARGETCONTENTTYPE; +typedef VOID* PDXGKDDI_SETTARGETANALOGCOPYPROTECTION; +typedef VOID* PDXGKDDI_DISPLAYDETECTCONTROL; +typedef VOID* PDXGKDDI_QUERYCONNECTIONCHANGE; +typedef VOID* PDXGKDDI_GETMULTIPLANEOVERLAYCAPS; +typedef VOID* PDXGKDDI_GETPOSTCOMPOSITIONCAPS; +#endif + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_3) +typedef VOID* DXGKCB_SETPROTECTEDSESSIONSTATUS; +typedef VOID* PDXGKDDI_UPDATEHWCONTEXTSTATE; +typedef VOID* PDXGKDDI_CREATEPROTECTEDSESSION; +typedef VOID* PDXGKDDI_DESTROYPROTECTEDSESSION; +#endif #endif // _D3DKMDDI_H_ diff --git a/sdk/include/ddk/dispmprt.h b/sdk/include/ddk/dispmprt.h new file mode 100644 index 00000000000..acb8351fd8a --- /dev/null +++ b/sdk/include/ddk/dispmprt.h @@ -0,0 +1,1754 @@ +/* + * PROJECT: ReactOS Display Driver Model + * LICENSE: Public Domain + * PURPOSE: Header file for WDDM style driver exports + * COPYRIGHT: Copyright 2024 Justin Miller + */ + +#ifndef _DISPMPRT_H_ +#define _DISPMPRT_H_ + +#ifndef _ACPIIOCT_H_ +#include +#endif + +#define _NTOSDEF_ + +#ifndef _NTOSP_ +#define _NTOSP_ + +typedef enum _EMULATOR_PORT_ACCESS_TYPE { + Uchar, + Ushort, + Ulong +} EMULATOR_PORT_ACCESS_TYPE, *PEMULATOR_PORT_ACCESS_TYPE; + +typedef struct _EMULATOR_ACCESS_ENTRY { + ULONG BasePort; + ULONG NumConsecutivePorts; + EMULATOR_PORT_ACCESS_TYPE AccessType; + UCHAR AccessMode; + UCHAR StringSupport; + PVOID Routine; +} EMULATOR_ACCESS_ENTRY, *PEMULATOR_ACCESS_ENTRY; + +#endif // _NTOSP_ + +typedef +VOID +(NTAPI *PBANKED_SECTION_ROUTINE)( + _In_ ULONG ReadBank, + _In_ ULONG WriteBank, + _In_ PVOID Context +); + +#include +#include +typedef unsigned int UINT; +typedef unsigned long DWORD; +typedef unsigned char BYTE; +#include + +#ifndef _D3DKMDT_H +#include +#endif +#ifndef _D3DKMDDI_H_ +#include +#endif + +#define DXGK_EXCLUDE_EVICT_ALL 0x00000001 +#define DXGK_EXCLUDE_CALL_SYNCHRONOUS 0x00000002 +#define DXGK_EXCLUDE_BRIDGE_ACCESS 0x00000004 +#define DXGK_EXCLUDE_EVICT_STANDBY 0x00000008 +#define DXGK_EXCLUDE_EVICT_HIBERNATE 0x00000010 +#define DXGK_EXCLUDE_EVICT_SHUTDOWN 0x00000020 +#define DXGK_EXCLUDE_D3_STATE_TRANSITION 0x00000040 + +#define DXGK_MAX_STRING_LEN 50 +#define DXGK_MAX_REG_SZ_LEN (DXGK_MAX_STRING_LEN + 1) + +#define DXGK_WHICHSPACE_CONFIG PCI_WHICHSPACE_CONFIG +#define DXGK_WHICHSPACE_ROM PCI_WHICHSPACE_ROM +#define DXGK_WHICHSPACE_MCH 0x80000000 +#define DXGK_WHICHSPACE_BRIDGE 0x80000001 + +#ifdef ENABLE_DXGK_SAL +#define _Function_class_DXGK_(param) _Function_class_(param) +#define _IRQL_requires_DXGK_(param) _IRQL_requires_(param) +#define _Field_size_bytes_DXGK_(param) _Field_size_bytes_(param) +#else +#define _Function_class_DXGK_(param) +#define _IRQL_requires_DXGK_(param) +#define _Field_size_bytes_DXGK_(param) +#endif + +typedef struct _LINKED_DEVICE { + ULONG ChainUid; + ULONG NumberOfLinksInChain; + BOOLEAN LeadLink; +} LINKED_DEVICE, *PLINKED_DEVICE; + +typedef enum _DXGK_EVENT_TYPE { + DxgkUndefinedEvent, + DxgkAcpiEvent, + DxgkPowerStateEvent, + DxgkDockingEvent, + DxgkChainedAcpiEvent +} DXGK_EVENT_TYPE, *PDXGK_EVENT_TYPE; + +typedef struct _DXGK_VIDEO_OUTPUT_CAPABILITIES { + D3DKMDT_VIDEO_OUTPUT_TECHNOLOGY InterfaceTechnology; + D3DKMDT_MONITOR_ORIENTATION_AWARENESS MonitorOrientationAwareness; + BOOLEAN SupportsSdtvModes; +} DXGK_VIDEO_OUTPUT_CAPABILITIES, *PDXGK_VIDEO_OUTPUT_CAPABILITIES; + +typedef struct _DXGK_INTEGRATED_DISPLAY_CHILD { + D3DKMDT_VIDEO_OUTPUT_TECHNOLOGY InterfaceTechnology; + USHORT DescriptorLength; +} DXGK_INTEGRATED_DISPLAY_CHILD, *PDXGK_INTEGRATED_DISPLAY_CHILD; + +typedef enum _DXGK_CHILD_DEVICE_TYPE { + TypeUninitialized, + TypeVideoOutput, + TypeOther, + TypeIntegratedDisplay +} DXGK_CHILD_DEVICE_TYPE, *PDXGK_CHILD_DEVICE_TYPE; + +typedef struct _DXGK_CHILD_CAPABILITIES { + union + { + DXGK_VIDEO_OUTPUT_CAPABILITIES VideoOutput; + struct + { + UINT MustBeZero; + } + Other; + DXGK_INTEGRATED_DISPLAY_CHILD IntegratedDisplayChild; + } Type; + DXGK_CHILD_DEVICE_HPD_AWARENESS HpdAwareness; +} DXGK_CHILD_CAPABILITIES, *PDXGK_CHILD_CAPABILITIES; + +typedef struct _DXGK_CHILD_DESCRIPTOR { + DXGK_CHILD_DEVICE_TYPE ChildDeviceType; + DXGK_CHILD_CAPABILITIES ChildCapabilities; + ULONG AcpiUid; + ULONG ChildUid; +} DXGK_CHILD_DESCRIPTOR, *PDXGK_CHILD_DESCRIPTOR; + +typedef struct _DXGK_DEVICE_DESCRIPTOR { + ULONG DescriptorOffset; + ULONG DescriptorLength; + _Field_size_bytes_DXGK_(DescriptorLength) PVOID DescriptorBuffer; +} DXGK_DEVICE_DESCRIPTOR, *PDXGK_DEVICE_DESCRIPTOR; + +typedef struct _DXGK_GENERIC_DESCRIPTOR { + WCHAR HardwareId[DXGK_MAX_REG_SZ_LEN]; + WCHAR InstanceId[DXGK_MAX_REG_SZ_LEN]; + WCHAR CompatibleId[DXGK_MAX_REG_SZ_LEN]; + WCHAR DeviceText[DXGK_MAX_REG_SZ_LEN]; +} DXGK_GENERIC_DESCRIPTOR, *PDXGK_GENERIC_DESCRIPTOR; + +typedef enum _DXGK_CHILD_STATUS_TYPE{ + StatusUninitialized, + StatusConnection, + StatusRotation, +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM1_3) + StatusMiracastConnection, +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM1_3) +} DXGK_CHILD_STATUS_TYPE, *PDXGK_CHILD_STATUS_TYPE; + +typedef struct _DXGK_CHILD_STATUS { + DXGK_CHILD_STATUS_TYPE Type; + ULONG ChildUid; + union { + struct { + BOOLEAN Connected; + } HotPlug; + struct { + UCHAR Angle; + } Rotation; +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM1_3) + struct { + BOOLEAN Connected; + D3DKMDT_VIDEO_OUTPUT_TECHNOLOGY MiracastMonitorType; + } Miracast; +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM1_3) + }; +} DXGK_CHILD_STATUS, *PDXGK_CHILD_STATUS; + +typedef enum { + DockStateUnsupported = 0, + DockStateUnDocked = 1, + DockStateDocked = 2, + DockStateUnknown = 3, +} DOCKING_STATE; + +typedef struct _DXGK_DEVICE_INFO { + PVOID MiniportDeviceContext; + PDEVICE_OBJECT PhysicalDeviceObject; + UNICODE_STRING DeviceRegistryPath; + PCM_RESOURCE_LIST TranslatedResourceList; + LARGE_INTEGER SystemMemorySize; + PHYSICAL_ADDRESS HighestPhysicalAddress; + PHYSICAL_ADDRESS AgpApertureBase; + SIZE_T AgpApertureSize; + DOCKING_STATE DockingState; +} DXGK_DEVICE_INFO, *PDXGK_DEVICE_INFO; + +typedef +_Function_class_DXGK_(DXGKDDI_PROTECTED_CALLBACK) +_IRQL_requires_DXGK_(PASSIVE_LEVEL) +VOID +(NTAPI *DXGKDDI_PROTECTED_CALLBACK)( + _In_ CONST PVOID MiniportDeviceContext, + _In_ PVOID ProtectedCallbackContext, + _In_ NTSTATUS ProtectionStatus +); + +DEFINE_GUID(GUID_DEVINTERFACE_I2C, 0x2564AA4F, 0xDDDB, 0x4495, 0xB4, 0x97, 0x6A, 0xD4, 0xA8, 0x41, 0x63, 0xD7); +DEFINE_GUID(GUID_DEVINTERFACE_OPM, 0xBF4672DE, 0x6B4E, 0x4BE4, 0xA3, 0x25, 0x68, 0xA9, 0x1E, 0xA4, 0x9C, 0x09); +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0) +DEFINE_GUID(GUID_DEVINTERFACE_OPM_2_JTP, 0xE929EEA4, 0xB9F1, 0x407B, 0xAA, 0xB9, 0xAB, 0x08, 0xBB, 0x44, 0xFB, 0xF4); +DEFINE_GUID(GUID_DEVINTERFACE_OPM_2, 0x7F098726, 0x2EBB, 0x4FF3, 0xA2, 0x7F, 0x10, 0x46, 0xB9, 0x5D, 0xC5, 0x17); +#endif +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_3) +DEFINE_GUID(GUID_DEVINTERFACE_OPM_3, 0x693a2cb1, 0x8c8d, 0x4ab6, 0x95, 0x55, 0x4b, 0x85, 0xef, 0x2c, 0x7c, 0x6b); +#endif +DEFINE_GUID(GUID_DEVINTERFACE_BRIGHTNESS, 0xFDE5BBA4, 0xB3F9, 0x46FB, 0xBD, 0xAA, 0x07, 0x28, 0xCE, 0x31, 0x00, 0xB4); +DEFINE_GUID(GUID_DEVINTERFACE_BRIGHTNESS_2, 0x148A3C98, 0x0ECD, 0x465A, 0xB6, 0x34, 0xB0, 0x5F, 0x19, 0x5F, 0x77, 0x39); +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM1_3) +DEFINE_GUID(GUID_DEVINTERFACE_MIRACAST_DISPLAY, 0xaf03f190, 0x22af, 0x48cb, 0x94, 0xbb, 0xb7, 0x8e, 0x76, 0xa2, 0x51, 0x7); +#endif + +#define DXGK_I2C_INTERFACE_VERSION_1 0x01 + +typedef +_Function_class_DXGK_(DXGKDDI_I2C_TRANSMIT_DATA_TO_DISPLAY) +_IRQL_requires_DXGK_(PASSIVE_LEVEL) +NTSTATUS +(NTAPI *DXGKDDI_I2C_TRANSMIT_DATA_TO_DISPLAY)( + _In_ PVOID MiniportDeviceContext, + _In_ D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId, + _In_ ULONG SevenBitI2CAddress, + _In_ ULONG DataLength, + _In_reads_bytes_(DataLength) CONST PVOID Data +); + +typedef +_Function_class_DXGK_(DXGKDDI_I2C_RECEIVE_DATA_FROM_DISPLAY) +_IRQL_requires_DXGK_(PASSIVE_LEVEL) +NTSTATUS +(NTAPI *DXGKDDI_I2C_RECEIVE_DATA_FROM_DISPLAY)( + _In_ PVOID MiniportDeviceContext, + _In_ D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId, + _In_ ULONG SevenBitI2CAddress, + _In_ ULONG Flags, + _In_ ULONG DataLength, + _Out_writes_bytes_(DataLength) PVOID Data +); + +typedef struct _DXGK_I2C_INTERFACE { + USHORT Size; + USHORT Version; + PVOID Context; + PINTERFACE_REFERENCE InterfaceReference; + PINTERFACE_DEREFERENCE InterfaceDereference; + DXGKDDI_I2C_TRANSMIT_DATA_TO_DISPLAY DxgkDdiI2CTransmitDataToDisplay; + DXGKDDI_I2C_RECEIVE_DATA_FROM_DISPLAY DxgkDdiI2CReceiveDataFromDisplay; +} DXGK_I2C_INTERFACE, *PDXGK_I2C_INTERFACE; + +#define DXGK_OPM_INTERFACE_VERSION_1 0x01 + +typedef +_Function_class_DXGK_(DXGKDDI_OPM_GET_CERTIFICATE_SIZE) +_IRQL_requires_DXGK_(PASSIVE_LEVEL) +NTSTATUS +(NTAPI *DXGKDDI_OPM_GET_CERTIFICATE_SIZE)( + _In_ PVOID MiniportDeviceContext, + _In_ DXGKMDT_CERTIFICATE_TYPE CertificateType, + _Out_ PULONG CertificateSize +); + +typedef +_Function_class_DXGK_(DXGKDDI_OPM_GET_CERTIFICATE) +_IRQL_requires_DXGK_(PASSIVE_LEVEL) +NTSTATUS +(NTAPI *DXGKDDI_OPM_GET_CERTIFICATE)( + _In_ PVOID MiniportDeviceContext, + _In_ DXGKMDT_CERTIFICATE_TYPE CertificateType, + _In_ ULONG CertificateSize, + _Out_writes_bytes_(CertificateSize) PVOID CertificateBuffer +); + +typedef +_Function_class_DXGK_(DXGKDDI_OPM_CREATE_PROTECTED_OUTPUT) +_IRQL_requires_DXGK_(PASSIVE_LEVEL) +NTSTATUS +(NTAPI *DXGKDDI_OPM_CREATE_PROTECTED_OUTPUT)( + _In_ PVOID MiniportDeviceContext, + _In_ D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId, + _In_ DXGKMDT_OPM_VIDEO_OUTPUT_SEMANTICS NewVideoOutputSemantics, + _Out_ PHANDLE NewProtectedOutputHandle +); + +typedef +_Function_class_DXGK_(DXGKDDI_OPM_GET_RANDOM_NUMBER) +_IRQL_requires_DXGK_(PASSIVE_LEVEL) +NTSTATUS +(NTAPI *DXGKDDI_OPM_GET_RANDOM_NUMBER)( + _In_ PVOID MiniportDeviceContext, + _In_ HANDLE ProtectedOutputHandle, + _Out_ PDXGKMDT_OPM_RANDOM_NUMBER RandomNumber +); + +typedef +_Function_class_DXGK_(DXGKDDI_OPM_SET_SIGNING_KEY_AND_SEQUENCE_NUMBERS) +_IRQL_requires_DXGK_(PASSIVE_LEVEL) +NTSTATUS +(NTAPI *DXGKDDI_OPM_SET_SIGNING_KEY_AND_SEQUENCE_NUMBERS)( + _In_ PVOID MiniportDeviceContext, + _In_ HANDLE ProtectedOutputHandle, + _In_ CONST PDXGKMDT_OPM_ENCRYPTED_PARAMETERS EncryptedParameters +); + +typedef +_Function_class_DXGK_(DXGKDDI_OPM_GET_INFORMATION) +_IRQL_requires_DXGK_(PASSIVE_LEVEL) +NTSTATUS +(NTAPI *DXGKDDI_OPM_GET_INFORMATION)( + _In_ PVOID MiniportDeviceContext, + _In_ HANDLE ProtectedOutputHandle, + _In_ CONST PDXGKMDT_OPM_GET_INFO_PARAMETERS Parameters, + _Out_ PDXGKMDT_OPM_REQUESTED_INFORMATION RequestedInformation +); + +typedef +_Function_class_DXGK_(DXGKDDI_OPM_GET_COPP_COMPATIBLE_INFORMATION) +_IRQL_requires_DXGK_(PASSIVE_LEVEL) +NTSTATUS +(NTAPI *DXGKDDI_OPM_GET_COPP_COMPATIBLE_INFORMATION)( + _In_ PVOID MiniportDeviceContext, + _In_ HANDLE ProtectedOutputHandle, + _In_ CONST PDXGKMDT_OPM_COPP_COMPATIBLE_GET_INFO_PARAMETERS Parameters, + _Out_ PDXGKMDT_OPM_REQUESTED_INFORMATION RequestedInformation +); + +typedef +_Function_class_DXGK_(DXGKDDI_OPM_CONFIGURE_PROTECTED_OUTPUT) +_IRQL_requires_DXGK_(PASSIVE_LEVEL) +NTSTATUS +(NTAPI *DXGKDDI_OPM_CONFIGURE_PROTECTED_OUTPUT)( + _In_ PVOID MiniportDeviceContext, + _In_ HANDLE ProtectedOutputHandle, + _In_ CONST PDXGKMDT_OPM_CONFIGURE_PARAMETERS Parameters, + _In_ ULONG AdditionalParametersSize, + _In_reads_bytes_(AdditionalParametersSize) CONST PVOID AdditionalParameters +); + +typedef +_Function_class_DXGK_(DXGKDDI_OPM_DESTROY_PROTECTED_OUTPUT) +_IRQL_requires_DXGK_(PASSIVE_LEVEL) +NTSTATUS +(NTAPI *DXGKDDI_OPM_DESTROY_PROTECTED_OUTPUT)( + _In_ PVOID MiniportDeviceContext, + _In_ HANDLE ProtectedOutputHandle +); + +typedef struct _DXGK_OPM_INTERFACE { + USHORT Size; + USHORT Version; + PVOID Context; + PINTERFACE_REFERENCE InterfaceReference; + PINTERFACE_DEREFERENCE InterfaceDereference; + DXGKDDI_OPM_GET_CERTIFICATE_SIZE DxgkDdiOPMGetCertificateSize; + DXGKDDI_OPM_GET_CERTIFICATE DxgkDdiOPMGetCertificate; + DXGKDDI_OPM_CREATE_PROTECTED_OUTPUT DxgkDdiOPMCreateProtectedOutput; + DXGKDDI_OPM_GET_RANDOM_NUMBER DxgkDdiOPMGetRandomNumber; + DXGKDDI_OPM_SET_SIGNING_KEY_AND_SEQUENCE_NUMBERS DxgkDdiOPMSetSigningKeyAndSequenceNumbers; + DXGKDDI_OPM_GET_INFORMATION DxgkDdiOPMGetInformation; + DXGKDDI_OPM_GET_COPP_COMPATIBLE_INFORMATION DxgkDdiOPMGetCOPPCompatibleInformation; + DXGKDDI_OPM_CONFIGURE_PROTECTED_OUTPUT DxgkDdiOPMConfigureProtectedOutput; + DXGKDDI_OPM_DESTROY_PROTECTED_OUTPUT DxgkDdiOPMDestroyProtectedOutput; +} DXGK_OPM_INTERFACE, *PDXGK_OPM_INTERFACE; + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0) +#define DXGK_OPM_INTERFACE_VERSION_2_JTP 0x02 + +typedef +_Function_class_DXGK_(DXGKDDI_OPM_CREATE_PROTECTED_OUTPUT_NONLOCAL_DISPLAY_JTP) +_IRQL_requires_DXGK_(PASSIVE_LEVEL) +NTSTATUS +(NTAPI *DXGKDDI_OPM_CREATE_PROTECTED_OUTPUT_NONLOCAL_DISPLAY_JTP)( + _In_ PVOID MiniportDeviceContext, + _In_ DXGKMDT_OPM_VIDEO_OUTPUT_SEMANTICS NewVideoOutputSemantics, + _In_ ULONG64 OPMEncoderContext, + _In_ DXGKMDT_OPM_ACTUAL_OUTPUT_FORMAT *pActualOutputFormat, + _In_ D3DDDI_VIDEO_PRESENT_TARGET_ID NonLocalOutputId, + _Out_ PHANDLE NewProtectedOutputHandle +); + +typedef +_Function_class_DXGK_(DXGKDDI_OPM_CREATE_PROTECTED_OUTPUT_VIRTUAL_MODE_JTP) +_IRQL_requires_DXGK_(PASSIVE_LEVEL) +NTSTATUS +(NTAPI *DXGKDDI_OPM_CREATE_PROTECTED_OUTPUT_VIRTUAL_MODE_JTP)( + _In_ PVOID MiniportDeviceContext, + _In_ D3DDDI_VIDEO_PRESENT_TARGET_ID VidPnTargetId, + _In_ DXGKMDT_OPM_VIDEO_OUTPUT_SEMANTICS NewVideoOutputSemantics, + _In_ DXGKMDT_OPM_ACTUAL_OUTPUT_FORMAT *pActualOutputFormat, + _Out_ PHANDLE NewProtectedOutputHandle +); + +typedef struct _DXGK_OPM_INTERFACE_2_JTP { + USHORT Size; + USHORT Version; + PVOID Context; + PINTERFACE_REFERENCE InterfaceReference; + PINTERFACE_DEREFERENCE InterfaceDereference; + DXGKDDI_OPM_GET_CERTIFICATE_SIZE DxgkDdiOPMGetCertificateSize; + DXGKDDI_OPM_GET_CERTIFICATE DxgkDdiOPMGetCertificate; + DXGKDDI_OPM_CREATE_PROTECTED_OUTPUT DxgkDdiOPMCreateProtectedOutput; + DXGKDDI_OPM_GET_RANDOM_NUMBER DxgkDdiOPMGetRandomNumber; + DXGKDDI_OPM_SET_SIGNING_KEY_AND_SEQUENCE_NUMBERS DxgkDdiOPMSetSigningKeyAndSequenceNumbers; + DXGKDDI_OPM_GET_INFORMATION DxgkDdiOPMGetInformation; + DXGKDDI_OPM_GET_COPP_COMPATIBLE_INFORMATION DxgkDdiOPMGetCOPPCompatibleInformation; + DXGKDDI_OPM_CONFIGURE_PROTECTED_OUTPUT DxgkDdiOPMConfigureProtectedOutput; + DXGKDDI_OPM_DESTROY_PROTECTED_OUTPUT DxgkDdiOPMDestroyProtectedOutput; + DXGKDDI_OPM_CREATE_PROTECTED_OUTPUT_VIRTUAL_MODE_JTP DxgkDdiOPMCreateProtectedOutputVirtualMode; + DXGKDDI_OPM_CREATE_PROTECTED_OUTPUT_NONLOCAL_DISPLAY_JTP DxgkDdiOPMCreateProtectedOutputNonLocalDisplay; +} DXGK_OPM_INTERFACE_2_JTP, *PDXGK_OPM_INTERFACE_2_JTP; + +#define DXGK_OPM_INTERFACE_VERSION_2 0x03 + +typedef +_Function_class_DXGK_(DXGKDDI_OPM_CREATE_PROTECTED_OUTPUT_NONLOCAL_DISPLAY) +_IRQL_requires_DXGK_(PASSIVE_LEVEL) +NTSTATUS +(NTAPI *DXGKDDI_OPM_CREATE_PROTECTED_OUTPUT_NONLOCAL_DISPLAY)( + _In_ PVOID MiniportDeviceContext, + _In_ DXGKMDT_OPM_VIDEO_OUTPUT_SEMANTICS NewVideoOutputSemantics, + _In_ UINT64 OPMEncoderContext, + _In_ DXGKMDT_OPM_ACTUAL_OUTPUT_FORMAT *pActualOutputFormat, + _In_ UINT64 NonLocalOutputId, + _In_ DXGKMDT_OPM_CONNECTOR_TYPE NonLocalConnectorType, + _Out_ PHANDLE NewProtectedOutputHandle +); + +typedef struct _DXGK_OPM_INTERFACE_2 { + USHORT Size; + USHORT Version; + PVOID Context; + PINTERFACE_REFERENCE InterfaceReference; + PINTERFACE_DEREFERENCE InterfaceDereference; + DXGKDDI_OPM_GET_CERTIFICATE_SIZE DxgkDdiOPMGetCertificateSize; + DXGKDDI_OPM_GET_CERTIFICATE DxgkDdiOPMGetCertificate; + DXGKDDI_OPM_CREATE_PROTECTED_OUTPUT DxgkDdiOPMCreateProtectedOutput; + DXGKDDI_OPM_GET_RANDOM_NUMBER DxgkDdiOPMGetRandomNumber; + DXGKDDI_OPM_SET_SIGNING_KEY_AND_SEQUENCE_NUMBERS DxgkDdiOPMSetSigningKeyAndSequenceNumbers; + DXGKDDI_OPM_GET_INFORMATION DxgkDdiOPMGetInformation; + DXGKDDI_OPM_GET_COPP_COMPATIBLE_INFORMATION DxgkDdiOPMGetCOPPCompatibleInformation; + DXGKDDI_OPM_CONFIGURE_PROTECTED_OUTPUT DxgkDdiOPMConfigureProtectedOutput; + DXGKDDI_OPM_DESTROY_PROTECTED_OUTPUT DxgkDdiOPMDestroyProtectedOutput; + DXGKDDI_OPM_CREATE_PROTECTED_OUTPUT_NONLOCAL_DISPLAY DxgkDdiOPMCreateProtectedOutputNonLocalDisplay; +} DXGK_OPM_INTERFACE_2, *PDXGK_OPM_INTERFACE_2; + +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0) + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_3) + +#define DXGK_OPM_INTERFACE_VERSION_3 0x04 + +typedef struct _DXGK_OPM_INTERFACE_3 { + USHORT Size; + USHORT Version; + PVOID Context; + PINTERFACE_REFERENCE InterfaceReference; + PINTERFACE_DEREFERENCE InterfaceDereference; + DXGKDDI_OPM_GET_CERTIFICATE_SIZE DxgkDdiOPMGetCertificateSize; + DXGKDDI_OPM_GET_CERTIFICATE DxgkDdiOPMGetCertificate; + DXGKDDI_OPM_CREATE_PROTECTED_OUTPUT DxgkDdiOPMCreateProtectedOutput; + DXGKDDI_OPM_GET_RANDOM_NUMBER DxgkDdiOPMGetRandomNumber; + DXGKDDI_OPM_SET_SIGNING_KEY_AND_SEQUENCE_NUMBERS DxgkDdiOPMSetSigningKeyAndSequenceNumbers; + DXGKDDI_OPM_GET_INFORMATION DxgkDdiOPMGetInformation; + DXGKDDI_OPM_GET_COPP_COMPATIBLE_INFORMATION DxgkDdiOPMGetCOPPCompatibleInformation; + DXGKDDI_OPM_CONFIGURE_PROTECTED_OUTPUT DxgkDdiOPMConfigureProtectedOutput; + DXGKDDI_OPM_DESTROY_PROTECTED_OUTPUT DxgkDdiOPMDestroyProtectedOutput; + DXGKDDI_OPM_CREATE_PROTECTED_OUTPUT_NONLOCAL_DISPLAY DxgkDdiOPMCreateProtectedOutputNonLocalDisplay; + DXGKDDI_OPM_CREATE_PROTECTED_OUTPUT_VIRTUAL_MODE_JTP DxgkDdiOPMCreateProtectedOutputVirtualMode; +} DXGK_OPM_INTERFACE_3, *PDXGK_OPM_INTERFACE_3; + +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_3) + +#define DXGK_BRIGHTNESS_INTERFACE_VERSION_1 0x01 + +typedef +_Function_class_DXGK_(DXGK_BRIGHTNESS_GET_POSSIBLE) +_IRQL_requires_DXGK_(PASSIVE_LEVEL) +NTSTATUS +(NTAPI *DXGK_BRIGHTNESS_GET_POSSIBLE)( + _In_ PVOID Context, + _In_ ULONG BufferSize, + _Out_ PUCHAR LevelCount, + _Out_writes_bytes_to_(BufferSize, *LevelCount) PUCHAR BrightnessLevels +); + +typedef +_Function_class_DXGK_(DXGK_BRIGHTNESS_SET) +_IRQL_requires_DXGK_(PASSIVE_LEVEL) +NTSTATUS +(NTAPI *DXGK_BRIGHTNESS_SET)( + _In_ PVOID Context, + _In_ UCHAR Brightness +); + +typedef +_Function_class_DXGK_(DXGK_BRIGHTNESS_GET) +_IRQL_requires_DXGK_(PASSIVE_LEVEL) +NTSTATUS +(NTAPI *DXGK_BRIGHTNESS_GET)( + _In_ PVOID Context, + _Out_ PUCHAR Brightness +); + +typedef struct { + USHORT Size; + USHORT Version; + PVOID Context; + PINTERFACE_REFERENCE InterfaceReference; + PINTERFACE_DEREFERENCE InterfaceDereference; + DXGK_BRIGHTNESS_GET_POSSIBLE GetPossibleBrightness; + DXGK_BRIGHTNESS_SET SetBrightness; + DXGK_BRIGHTNESS_GET GetBrightness; +} DXGK_BRIGHTNESS_INTERFACE, *PDXGK_BRIGHTNESS_INTERFACE; + +#define DXGK_BRIGHTNESS_INTERFACE_VERSION_2 0x02 + +typedef +_Function_class_DXGK_(DXGK_BRIGHTNESS_GET_CAPS) +_IRQL_requires_DXGK_(PASSIVE_LEVEL) +NTSTATUS +(NTAPI *DXGK_BRIGHTNESS_GET_CAPS)( + _In_ PVOID Context, + _Out_ DXGK_BRIGHTNESS_CAPS *BrightnessCaps +); + +typedef +_Function_class_DXGK_(DXGK_BRIGHTNESS_SET_STATE) +_IRQL_requires_DXGK_(PASSIVE_LEVEL) +NTSTATUS +(NTAPI *DXGK_BRIGHTNESS_SET_STATE)( + _In_ PVOID Context, + _In_ DXGK_BRIGHTNESS_STATE *BrightnessState +); + +typedef +_Function_class_DXGK_(DXGK_BRIGHTNESS_SET_BACKLIGHT_OPTIMIZATION) +_IRQL_requires_DXGK_(PASSIVE_LEVEL) +NTSTATUS +(NTAPI *DXGK_BRIGHTNESS_SET_BACKLIGHT_OPTIMIZATION)( + _In_ PVOID Context, + _In_ DXGK_BACKLIGHT_OPTIMIZATION_LEVEL OptimizationLevel +); + +typedef +_Function_class_DXGK_(DXGK_BRIGHTNESS_GET_BACKLIGHT_REDUCTION) +_IRQL_requires_DXGK_(PASSIVE_LEVEL) +NTSTATUS +(NTAPI *DXGK_BRIGHTNESS_GET_BACKLIGHT_REDUCTION)( + _In_ PVOID Context, + _Out_ DXGK_BACKLIGHT_INFO *BacklightInfo +); + +typedef struct { + USHORT Size; + USHORT Version; + PVOID Context; + PINTERFACE_REFERENCE InterfaceReference; + PINTERFACE_DEREFERENCE InterfaceDereference; + DXGK_BRIGHTNESS_GET_POSSIBLE GetPossibleBrightness; + DXGK_BRIGHTNESS_SET SetBrightness; + DXGK_BRIGHTNESS_GET GetBrightness; + DXGK_BRIGHTNESS_GET_CAPS GetBrightnessCaps; + DXGK_BRIGHTNESS_SET_STATE SetBrightnessState; + DXGK_BRIGHTNESS_SET_BACKLIGHT_OPTIMIZATION SetBacklightOptimization; + DXGK_BRIGHTNESS_GET_BACKLIGHT_REDUCTION GetBacklightReduction; +} DXGK_BRIGHTNESS_INTERFACE_2, *PDXGK_BRIGHTNESS_INTERFACE_2; + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM1_3) +#define DXGK_MIRACAST_DISPLAY_INTERFACE_VERSION_1 0x01 + +typedef struct _DXGK_MIRACAST_CAPS { + ULONG MaxChunkPrivateDriverDataSize; + union { + struct { + UINT HdcpSupport : 1; + UINT Reserved : 31; + }; + UINT Value; + } Flags; +} DXGK_MIRACAST_CAPS, *PDXGK_MIRACAST_CAPS; + +typedef +_Function_class_DXGK_(DXGKDDI_MIRACAST_QUERY_CAPS) +_IRQL_requires_DXGK_(PASSIVE_LEVEL) +NTSTATUS +(NTAPI *DXGKDDI_MIRACAST_QUERY_CAPS)( + _In_ PVOID DriverContext, + _In_ ULONG MiracastCapsSize, + _Out_ DXGK_MIRACAST_CAPS *MiracastCaps +); + +typedef +_Function_class_DXGK_(DXGKCB_MIRACAST_SEND_MESSAGE_CALLBACK) +_IRQL_requires_DXGK_(PASSIVE_LEVEL) +VOID +(NTAPI *DXGKCB_MIRACAST_SEND_MESSAGE_CALLBACK)( + _In_ PVOID CallbackContext, + _In_ PIO_STATUS_BLOCK IoStatusBlock +); + +typedef +_Function_class_DXGK_(DXGKCB_MIRACAST_SEND_MESSAGE) +_IRQL_requires_DXGK_(PASSIVE_LEVEL) +NTSTATUS +(NTAPI *DXGKCB_MIRACAST_SEND_MESSAGE)( + _In_ HANDLE MiracastHandle, + _In_ ULONG InputBufferSize, + _In_reads_bytes_(InputBufferSize) VOID *InputBuffer, + _In_ ULONG OutputBufferSize, + _Out_writes_bytes_(OutputBufferSize) VOID *OutputBuffer, + _In_opt_ DXGKCB_MIRACAST_SEND_MESSAGE_CALLBACK Callback, + _In_opt_ PVOID CallbackContext +); + +typedef +_Function_class_DXGK_(DXGKCB_MIRACAST_REPORT_CHUNK_INFO) +_IRQL_requires_DXGK_(DISPATCH_LEVEL) +NTSTATUS +(NTAPI *DXGKCB_MIRACAST_REPORT_CHUNK_INFO)( + _In_ HANDLE MiracastHandle, + _In_ DXGK_MIRACAST_CHUNK_INFO *ChunkInfo, + _In_ PVOID PrivateDriverData, + _In_ UINT PrivateDataDriverSize +); + +typedef struct _DXGK_MIRACAST_DISPLAY_CALLBACKS { + HANDLE MiracastHandle; + DXGKCB_MIRACAST_SEND_MESSAGE DxgkCbMiracastSendMessage; + DXGKCB_MIRACAST_REPORT_CHUNK_INFO DxgkCbReportChunkInfo; +} DXGK_MIRACAST_DISPLAY_CALLBACKS, *PDXGK_MIRACAST_DISPLAY_CALLBACKS; + +typedef +_Function_class_DXGK_(DXGKDDI_MIRACAST_CREATE_CONTEXT) +_IRQL_requires_DXGK_(PASSIVE_LEVEL) +NTSTATUS +(NTAPI *DXGKDDI_MIRACAST_CREATE_CONTEXT)( + _In_ PVOID DriverContext, + _In_ DXGK_MIRACAST_DISPLAY_CALLBACKS *MiracastCallbacks, + _Out_ PVOID *MiracastContext, + _Out_ ULONG *TargetId +); + +typedef +_Function_class_DXGK_(DXGKDDI_MIRACAST_DESTROY_CONTEXT) +_IRQL_requires_DXGK_(PASSIVE_LEVEL) +VOID +(NTAPI *DXGKDDI_MIRACAST_DESTROY_CONTEXT)( + _In_ PVOID DriverContext, + _In_ PVOID MiracastContext +); + +typedef +_Function_class_DXGK_(DXGKDDI_MIRACAST_HANDLE_IO_CONTROL) +_IRQL_requires_DXGK_(PASSIVE_LEVEL) +NTSTATUS +(NTAPI *DXGKDDI_MIRACAST_HANDLE_IO_CONTROL)( + _In_ PVOID DriverContext, + _In_ PVOID MiracastContext, + _In_ ULONG InputBufferSize, + _In_reads_bytes_(InputBufferSize) VOID *InputBuffer, + _In_ ULONG OutputBufferSize, + _Out_writes_bytes_(OutputBufferSize) VOID *OutputBuffer, + _Out_ ULONG *BytesReturned +); + +typedef struct _DXGK_MIRACAST_INTERFACE { + USHORT Size; + USHORT Version; + PVOID Context; + PINTERFACE_REFERENCE InterfaceReference; + PINTERFACE_DEREFERENCE InterfaceDereference; + DXGKDDI_MIRACAST_QUERY_CAPS DxgkDdiMiracastQueryCaps; + DXGKDDI_MIRACAST_CREATE_CONTEXT DxgkDdiMiracastCreateContext; + DXGKDDI_MIRACAST_HANDLE_IO_CONTROL DxgkDdiMiracastIoControl; + DXGKDDI_MIRACAST_DESTROY_CONTEXT DxgkDdiMiracastDestroyContext; +} DXGK_MIRACAST_DISPLAY_INTERFACE, *PDXGK_MIRACAST_DISPLAY_INTERFACE; +#endif /* DXGKDDI_INTERFACE_VERSION_WDDM1_3 */ + +typedef enum { + DxgkServicesAgp, + DxgkServicesDebugReport, + DxgkServicesTimedOperation, + DxgkServicesSPB, + DxgkServicesBDD, + DxgkServicesFirmwareTable, + DxgkServicesIDD, +} DXGK_SERVICES; + +#define DXGK_AGP_INTERFACE_VERSION_1 0x01 +#define DXGK_AGPCOMMAND_AGP1X 0x00001 +#define DXGK_AGPCOMMAND_AGP2X 0x00002 +#define DXGK_AGPCOMMAND_AGP4X 0x00004 +#define DXGK_AGPCOMMAND_AGP8X 0x00008 +#define DXGK_AGPCOMMAND_DISABLE_SBA 0x10000 +#define DXGK_AGPCOMMAND_DISABLE_FW 0x20000 + +typedef +_Function_class_DXGK_(DXGKCB_AGP_ALLOCATE_POOL) +_IRQL_requires_DXGK_(PASSIVE_LEVEL) +NTSTATUS +(APIENTRY *DXGKCB_AGP_ALLOCATE_POOL)( + _In_ HANDLE Context, + _In_ ULONG AllocationSize, + _In_ MEMORY_CACHING_TYPE CacheType, + _Out_ PPHYSICAL_ADDRESS PhysicalAddress, + _Out_ PVOID *VirtualAddress +); + +typedef +_Function_class_DXGK_(DXGKCB_AGP_FREE_POOL) +_IRQL_requires_DXGK_(PASSIVE_LEVEL) +NTSTATUS +(APIENTRY *DXGKCB_AGP_FREE_POOL)( + _In_ HANDLE Context, + _In_ PVOID VirtualAddress +); + +typedef +_Function_class_DXGK_(DXGKCB_AGP_SET_COMMAND) +_IRQL_requires_DXGK_(PASSIVE_LEVEL) +NTSTATUS +(APIENTRY *DXGKCB_AGP_SET_COMMAND)( + _In_ HANDLE Context, + _In_ ULONG Command +); + +typedef struct _DXGK_AGP_INTERFACE { + USHORT Size; + USHORT Version; + PVOID Context; + PINTERFACE_REFERENCE InterfaceReference; + PINTERFACE_DEREFERENCE InterfaceDereference; + DXGKCB_AGP_ALLOCATE_POOL AgpAllocatePool; + DXGKCB_AGP_FREE_POOL AgpFreePool; + DXGKCB_AGP_SET_COMMAND AgpSetCommand; +} DXGK_AGP_INTERFACE, *PDXGK_AGP_INTERFACE; + +DECLARE_HANDLE(DXGK_DEBUG_REPORT_HANDLE); +#define DXGK_DEBUG_REPORT_INTERFACE_VERSION_1 0x01 +#define DXGK_DEBUG_REPORT_MAX_SIZE 0xF800 + +typedef struct _DXGK_DEBUG_REPORT_INTERFACE { + USHORT Size; + USHORT Version; + PVOID Context; + PINTERFACE_REFERENCE InterfaceReference; + PINTERFACE_DEREFERENCE InterfaceDereference; + + _IRQL_requires_DXGK_(PASSIVE_LEVEL) + DXGK_DEBUG_REPORT_HANDLE (NTAPI *DbgReportCreate)( + _In_ HANDLE DeviceHandle, + _In_ ULONG Code, + _In_ ULONG_PTR Arg1, + _In_ ULONG_PTR Arg2, + _In_ ULONG_PTR Arg3, + _In_ ULONG_PTR Arg4 + ); + _IRQL_requires_DXGK_(PASSIVE_LEVEL) + _Success_(return != 0) + BOOLEAN (NTAPI *DbgReportSecondaryData)( + _Inout_ DXGK_DEBUG_REPORT_HANDLE Report, + _In_reads_bytes_(DataSize) PVOID Data, + _In_ ULONG DataSize + ); + _IRQL_requires_DXGK_(PASSIVE_LEVEL) + VOID (NTAPI *DbgReportComplete)( + _Inout_ DXGK_DEBUG_REPORT_HANDLE Report + ); +} DXGK_DEBUG_REPORT_INTERFACE, *PDXGK_DEBUG_REPORT_INTERFACE; + +#define DXGK_TIMED_OPERATION_INTERFACE_VERSION_1 0x01 +#define DXGK_TIMED_OPERATION_TIMEOUT_MAX_SECONDS 5 + +typedef struct _DXGK_TIMED_OPERATION { + USHORT Size; + ULONG_PTR OwnerTag; + BOOLEAN OsHandled; + BOOLEAN TimeoutTriggered; + LARGE_INTEGER Timeout; + LARGE_INTEGER StartTick; +} DXGK_TIMED_OPERATION, *PDXGK_TIMED_OPERATION; + +typedef struct _DXGK_TIMED_OPERATION_INTERFACE { + USHORT Size; + USHORT Version; + PVOID Context; + PINTERFACE_REFERENCE InterfaceReference; + PINTERFACE_DEREFERENCE InterfaceDereference; + + _IRQL_requires_DXGK_(PASSIVE_LEVEL) + NTSTATUS (NTAPI *TimedOperationStart)( + _Out_ DXGK_TIMED_OPERATION *Op, + _In_ const LARGE_INTEGER *Timeout, + _In_ BOOLEAN OsHandled + ); + _IRQL_requires_DXGK_(PASSIVE_LEVEL) + NTSTATUS (NTAPI *TimedOperationDelay)( + _Inout_ DXGK_TIMED_OPERATION *Op, + _In_ KPROCESSOR_MODE WaitMode, + _In_ BOOLEAN Alertable, + _In_opt_ const LARGE_INTEGER *Interval + ); + _IRQL_requires_DXGK_(PASSIVE_LEVEL) + NTSTATUS (NTAPI *TimedOperationWaitForSingleObject)( + _Inout_ DXGK_TIMED_OPERATION *Op, + _In_ PVOID Object, + _In_ KWAIT_REASON WaitReason, + _In_ KPROCESSOR_MODE WaitMode, + _In_ BOOLEAN Alertable, + _In_opt_ const LARGE_INTEGER *Timeout + ); +} DXGK_TIMED_OPERATION_INTERFACE, *PDXGK_TIMED_OPERATION_INTERFACE; + +#define DXGK_SPB_INTERFACE_VERSION_1 0x01 + +typedef struct _DXGK_SPB_INTERFACE { + USHORT Size; + USHORT Version; + PVOID Context; + PINTERFACE_REFERENCE InterfaceReference; + PINTERFACE_DEREFERENCE InterfaceDereference; + + _IRQL_requires_DXGK_(PASSIVE_LEVEL) + NTSTATUS (NTAPI *OpenSpbResource)( + _In_ HANDLE DeviceHandle, + _In_ LARGE_INTEGER SpbReourceId, + _In_opt_ UNICODE_STRING *SpbResourceSubName, + _In_ ACCESS_MASK DesiredAccess, + _In_ ULONG ShareAccess, + _In_ ULONG OpenOptions, + _Outptr_ VOID **SpbResource + ); + _IRQL_requires_DXGK_(PASSIVE_LEVEL) + NTSTATUS (NTAPI *CloseSpbResource)( + _In_ HANDLE DeviceHandle, + _In_ VOID *SpbResource + ); + _IRQL_requires_DXGK_(PASSIVE_LEVEL) + NTSTATUS (NTAPI *ReadSpbResource)( + _In_ HANDLE DeviceHandle, + _In_ VOID *SpbResource, + _In_ ULONG Length, + _Out_writes_bytes_(Length) VOID *Buffer, + _In_opt_ LARGE_INTEGER *ByteOffset, + _In_opt_ HANDLE EventHandle, + _Out_ IO_STATUS_BLOCK *IoStatusBlock + ); + _IRQL_requires_DXGK_(PASSIVE_LEVEL) + NTSTATUS (NTAPI *WriteSpbResource)( + _In_ HANDLE DeviceHandle, + _In_ VOID *SpbResource, + _In_ ULONG Length, + _In_reads_bytes_(Length) VOID *Buffer, + _In_opt_ LARGE_INTEGER *ByteOffset, + _In_opt_ HANDLE EventHandle, + _Out_ IO_STATUS_BLOCK *IoStatusBlock + ); + _IRQL_requires_DXGK_(PASSIVE_LEVEL) + NTSTATUS (NTAPI *SpbResourceIoControl)( + _In_ HANDLE DeviceHandle, + _In_ VOID *SpbResource, + _In_ ULONG IoControlCode, + _In_ ULONG InBufferSize, + _In_reads_bytes_(InBufferSize) VOID *InputBuffer, + _In_ ULONG OutBufferSize, + _Out_writes_bytes_(OutBufferSize) VOID *OutputBuffer, + _In_opt_ HANDLE EventHandle, + _Out_ IO_STATUS_BLOCK *IoStatusBlock + ); +} DXGK_SPB_INTERFACE, *PDXGK_SPB_INTERFACE; + +#define DXGK_FIRMWARE_TABLE_INTERFACE_VERSION_1 0x01 + +typedef struct _DXGK_FIRMWARE_TABLE_INTERFACE { + USHORT Size; + USHORT Version; + PVOID Context; + PINTERFACE_REFERENCE InterfaceReference; + PINTERFACE_DEREFERENCE InterfaceDereference; + + _IRQL_requires_DXGK_(PASSIVE_LEVEL) + _Success_(return >= 0 || return == STATUS_BUFFER_TOO_SMALL) + NTSTATUS (NTAPI *EnumSystemFirmwareTables)( + _In_ VOID *Context, + _In_ ULONG ProviderSignature, + _In_ ULONG BufferSize, + _Pre_opt_bytecap_(BufferSize) + _When_(return == STATUS_BUFFER_TOO_SMALL, _Post_equal_to_(_Old_(Buffer))) + _When_(return != STATUS_BUFFER_TOO_SMALL, _Post_valid_) + VOID *Buffer, + _Out_ ULONG *RequiredSize + ); + _IRQL_requires_DXGK_(PASSIVE_LEVEL) + _Success_(return >= 0 || return == STATUS_BUFFER_TOO_SMALL) + _When_(Buffer == NULL, _At_(BufferSize, _In_range_(==, 0))) + NTSTATUS (NTAPI *ReadSystemFirmwareTable)( + _In_ VOID *Context, + _In_ ULONG ProviderSignature, + _In_ ULONG TableId, + _In_ ULONG BufferSize, + _Pre_opt_bytecap_(BufferSize) + _When_(return == STATUS_BUFFER_TOO_SMALL, _Post_equal_to_(_Old_(Buffer))) + _When_(return != STATUS_BUFFER_TOO_SMALL, _Post_valid_) + VOID *Buffer, + _Out_ ULONG *RequiredSize + ); +} DXGK_FIRMWARE_TABLE_INTERFACE, *PDXGK_FIRMWARE_TABLE_INTERFACE; + +/* + * Passed from DxgKrnl -> Miniport + * Implemented by enumeration of the device. + */ +typedef struct _DXGK_START_INFO { + ULONG RequiredDmaQueueEntry; + GUID AdapterGuid; +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) + LUID AdapterLuid; +#endif // DXGKDDI_INTERFACE_VERSION_WIN8 +} DXGK_START_INFO, *PDXGK_START_INFO; + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) + +typedef +_Function_class_DXGK_(DXGKCB_ACQUIRE_POST_DISPLAY_OWNERSHIP) +_IRQL_requires_(PASSIVE_LEVEL) +NTSTATUS +(APIENTRY *DXGKCB_ACQUIRE_POST_DISPLAY_OWNERSHIP)( + _In_ HANDLE DeviceHandle, + _Out_ PDXGK_DISPLAY_INFORMATION DisplayInfo +); + +#endif // DXGKDDI_INTERFACE_VERSION_WIN8 + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_2) + +typedef enum _DXGK_FRAMEBUFFER_STATE { + FrameBufferStateUnknown = 0, + FrameBufferStateInitializedByFirmware = 1, + FrameBufferStateInitializedByDriver = 2, +} DXGK_FRAMEBUFFER_STATE; + +typedef struct _DXGK_DISPLAY_OWNERSHIP_FLAGS { + union { + struct { + DXGK_FRAMEBUFFER_STATE FrameBufferState : 4; + }; + UINT Value; + }; +} DXGK_DISPLAY_OWNERSHIP_FLAGS, *PDXGK_DISPLAY_OWNERSHIP_FLAGS; + +typedef +_Function_class_DXGK_(DXGKCB_ACQUIRE_POST_DISPLAY_OWNERSHIP2) +_IRQL_requires_(PASSIVE_LEVEL) +NTSTATUS +(APIENTRY *DXGKCB_ACQUIRE_POST_DISPLAY_OWNERSHIP2)( + _In_ HANDLE DeviceHandle, + _Out_ PDXGK_DISPLAY_INFORMATION DisplayInfo, + _Out_ PDXGK_DISPLAY_OWNERSHIP_FLAGS Flags +); + +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_2 + + +typedef +NTSTATUS +(APIENTRY *DXGKCB_EVAL_ACPI_METHOD)( + _In_ HANDLE DeviceHandle, + _In_ ULONG DeviceUid, + _In_reads_bytes_(AcpiInputSize) PACPI_EVAL_INPUT_BUFFER_COMPLEX AcpiInputBuffer, + _In_range_(>=, sizeof(ACPI_EVAL_INPUT_BUFFER_COMPLEX)) ULONG AcpiInputSize, + _Out_writes_bytes_(AcpiOutputSize) PACPI_EVAL_OUTPUT_BUFFER AcpiOutputBuffer, + _In_range_(>=, sizeof(ACPI_EVAL_OUTPUT_BUFFER)) ULONG AcpiOutputSize); + +typedef +NTSTATUS +(APIENTRY *DXGKCB_GET_DEVICE_INFORMATION)( + _In_ HANDLE DeviceHandle, + _Out_ PDXGK_DEVICE_INFO DeviceInfo); + +typedef +NTSTATUS +(APIENTRY *DXGKCB_INDICATE_CHILD_STATUS)( + _In_ HANDLE DeviceHandle, + _In_ PDXGK_CHILD_STATUS ChildStatus); + +typedef +NTSTATUS +(APIENTRY *DXGKCB_MAP_MEMORY)( + _In_ HANDLE DeviceHandle, + _In_ PHYSICAL_ADDRESS TranslatedAddress, + _In_ ULONG Length, + _In_ BOOLEAN InIoSpace, + _In_ BOOLEAN MapToUserMode, + _In_ MEMORY_CACHING_TYPE CacheType, + _Outptr_ PVOID *VirtualAddress); + +typedef +NTSTATUS +(APIENTRY *DXGKCB_QUERY_SERVICES)( + _In_ HANDLE DeviceHandle, + _In_ DXGK_SERVICES ServicesType, + _Inout_ PINTERFACE Interface); + +typedef +BOOLEAN +(APIENTRY *DXGKCB_QUEUE_DPC)( + _In_ HANDLE DeviceHandle); + +typedef +NTSTATUS +(APIENTRY *DXGKCB_READ_DEVICE_SPACE)( + _In_ HANDLE DeviceHandle, + _In_ ULONG DataType, + _Out_writes_bytes_to_(Length, *BytesRead) PVOID Buffer, + _In_ ULONG Offset, + _In_ ULONG Length, + _Out_ PULONG BytesRead); + +typedef +NTSTATUS +(APIENTRY *DXGKCB_SYNCHRONIZE_EXECUTION)( + _In_ HANDLE DeviceHandle, + _In_ PKSYNCHRONIZE_ROUTINE SynchronizeRoutine, + _In_ PVOID Context, + _In_ ULONG MessageNumber, + _Out_ PBOOLEAN ReturnValue); + +typedef +NTSTATUS +(APIENTRY *DXGKCB_UNMAP_MEMORY)( + _In_ HANDLE DeviceHandle, + _In_ PVOID VirtualAddress); + +typedef +NTSTATUS +(APIENTRY *DXGKCB_WRITE_DEVICE_SPACE)( + _In_ HANDLE DeviceHandle, + _In_ ULONG DataType, + _In_reads_bytes_(Length) PVOID Buffer, + _In_ ULONG Offset, + _In_ ULONG Length, + _Out_ _Out_range_(<=, Length) PULONG BytesWritten); + +typedef +NTSTATUS +(APIENTRY *DXGKCB_IS_DEVICE_PRESENT)( + _In_ HANDLE DeviceHandle, + _In_ PPCI_DEVICE_PRESENCE_PARAMETERS DevicePresenceParameters, + _Out_ PBOOLEAN DevicePresent); + +typedef +_Function_class_DXGK_(DXGKCB_LOG_ETW_EVENT) +_When_(EventBufferSize > 256, _IRQL_requires_DXGK_(PASSIVE_LEVEL)) +VOID +(APIENTRY *DXGKCB_LOG_ETW_EVENT)( + _In_ CONST LPCGUID EventGuid, + _In_ UCHAR Type, + _In_ USHORT EventBufferSize, + _In_reads_bytes_(EventBufferSize) PVOID EventBuffer +); + +typedef +_Function_class_DXGK_(DXGKCB_EXCLUDE_ADAPTER_ACCESS) +_IRQL_requires_(PASSIVE_LEVEL) +NTSTATUS +(APIENTRY *DXGKCB_EXCLUDE_ADAPTER_ACCESS)( + _In_ HANDLE DeviceHandle, + _In_ ULONG Attributes, + _In_ DXGKDDI_PROTECTED_CALLBACK DxgkProtectedCallback, + _In_ PVOID ProtectedCallbackContext +); + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) + +#endif // DXGKDDI_INTERFACE_VERSION_WIN8 + +/* + * Passed from DxgKrnl -> Miniport + * Implemented by DxgKrnl itself. + */ +typedef struct _DXGKRNL_INTERFACE { + ULONG Size; + ULONG Version; + HANDLE DeviceHandle; + DXGKCB_EVAL_ACPI_METHOD DxgkCbEvalAcpiMethod; + DXGKCB_GET_DEVICE_INFORMATION DxgkCbGetDeviceInformation; + DXGKCB_INDICATE_CHILD_STATUS DxgkCbIndicateChildStatus; + DXGKCB_MAP_MEMORY DxgkCbMapMemory; + DXGKCB_QUEUE_DPC DxgkCbQueueDpc; + DXGKCB_QUERY_SERVICES DxgkCbQueryServices; + DXGKCB_READ_DEVICE_SPACE DxgkCbReadDeviceSpace; + DXGKCB_SYNCHRONIZE_EXECUTION DxgkCbSynchronizeExecution; + DXGKCB_UNMAP_MEMORY DxgkCbUnmapMemory; + DXGKCB_WRITE_DEVICE_SPACE DxgkCbWriteDeviceSpace; + DXGKCB_IS_DEVICE_PRESENT DxgkCbIsDevicePresent; + DXGKCB_GETHANDLEDATA DxgkCbGetHandleData; + DXGKCB_GETHANDLEPARENT DxgkCbGetHandleParent; + DXGKCB_ENUMHANDLECHILDREN DxgkCbEnumHandleChildren; + DXGKCB_NOTIFY_INTERRUPT DxgkCbNotifyInterrupt; + DXGKCB_NOTIFY_DPC DxgkCbNotifyDpc; + DXGKCB_QUERYVIDPNINTERFACE DxgkCbQueryVidPnInterface; + DXGKCB_QUERYMONITORINTERFACE DxgkCbQueryMonitorInterface; + DXGKCB_GETCAPTUREADDRESS DxgkCbGetCaptureAddress; + DXGKCB_LOG_ETW_EVENT DxgkCbLogEtwEvent; + DXGKCB_EXCLUDE_ADAPTER_ACCESS DxgkCbExcludeAdapterAccess; +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) + DXGKCB_CREATECONTEXTALLOCATION DxgkCbCreateContextAllocation; + DXGKCB_DESTROYCONTEXTALLOCATION DxgkCbDestroyContextAllocation; + DXGKCB_SETPOWERCOMPONENTACTIVE DxgkCbSetPowerComponentActive; + DXGKCB_SETPOWERCOMPONENTIDLE DxgkCbSetPowerComponentIdle; + DXGKCB_ACQUIRE_POST_DISPLAY_OWNERSHIP DxgkCbAcquirePostDisplayOwnership; + DXGKCB_POWERRUNTIMECONTROLREQUEST DxgkCbPowerRuntimeControlRequest; + DXGKCB_SETPOWERCOMPONENTLATENCY DxgkCbSetPowerComponentLatency; + DXGKCB_SETPOWERCOMPONENTRESIDENCY DxgkCbSetPowerComponentResidency; + DXGKCB_COMPLETEFSTATETRANSITION DxgkCbCompleteFStateTransition; +#endif // DXGKDDI_INTERFACE_VERSION_WIN8 +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM1_3) + DXGKCB_COMPLETEPSTATETRANSITION DxgkCbCompletePStateTransition; +#endif // DXGKDDI_INTERFACE_VERSION_WDDM1_3 +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0) + DXGKCB_MAPCONTEXTALLOCATION DxgkCbMapContextAllocation; + DXGKCB_UPDATECONTEXTALLOCATION DxgkCbUpdateContextAllocation; + DXGKCB_RESERVEGPUVIRTUALADDRESSRANGE DxgkCbReserveGpuVirtualAddressRange; + DXGKCB_ACQUIREHANDLEDATA DxgkCbAcquireHandleData; + DXGKCB_RELEASEHANDLEDATA DxgkCbReleaseHandleData; + DXGKCB_HARDWARECONTENTPROTECTIONTEARDOWN DxgkCbHardwareContentProtectionTeardown; +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_0 +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_1) + DXGKCB_MULTIPLANEOVERLAYDISABLED DxgkCbMultiPlaneOverlayDisabled; + DXGKCB_MITIGATEDRANGEUPDATE DxgkCbMitigatedRangeUpdate; +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_1 +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_2) + DXGKCB_INVALIDATEHWCONTEXT DxgkCbInvalidateHwContext; + DXGKCB_INDICATE_CONNECTOR_CHANGE DxgkCbIndicateConnectorChange; + DXGKCB_UNBLOCKUEFIFRAMEBUFFERRANGES DxgkCbUnblockUEFIFrameBufferRanges; + DXGKCB_ACQUIRE_POST_DISPLAY_OWNERSHIP2 DxgkCbAcquirePostDisplayOwnership2; +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_2 +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_3) + DXGKCB_SETPROTECTEDSESSIONSTATUS DxgkCbSetProtectedSessionStatus; +#endif // DXGKDDI_INTERFACE_VERSION_WDDM2_3 +} DXGKRNL_INTERFACE, *PDXGKRNL_INTERFACE; + +typedef +_Check_return_ +_Function_class_DXGK_(DXGKDDI_ADD_DEVICE) +_IRQL_requires_DXGK_(PASSIVE_LEVEL) +NTSTATUS +APIENTRY +DXGKDDI_ADD_DEVICE( + _In_ CONST PDEVICE_OBJECT PhysicalDeviceObject, + _Out_ PVOID *MiniportDeviceContext +); + +typedef +_Check_return_ +_Function_class_DXGK_(DXGKDDI_START_DEVICE) +_IRQL_requires_DXGK_(PASSIVE_LEVEL) +NTSTATUS +APIENTRY +DXGKDDI_START_DEVICE( + _In_ CONST PVOID MiniportDeviceContext, + _In_ PDXGK_START_INFO DxgkStartInfo, + _In_ PDXGKRNL_INTERFACE DxgkInterface, + _Out_ PULONG NumberOfVideoPresentSources, + _Out_ PULONG NumberOfChildren +); + +typedef +_Check_return_ +_Function_class_DXGK_(DXGKDDI_STOP_DEVICE) +_IRQL_requires_DXGK_(PASSIVE_LEVEL) +NTSTATUS +APIENTRY +DXGKDDI_STOP_DEVICE( + _In_ CONST PVOID MiniportDeviceContext +); + +typedef +_Check_return_ +_Function_class_DXGK_(DXGKDDI_REMOVE_DEVICE) +_IRQL_requires_DXGK_(PASSIVE_LEVEL) +NTSTATUS +APIENTRY +DXGKDDI_REMOVE_DEVICE( + _In_ CONST PVOID MiniportDeviceContext +); + +typedef +_Check_return_ +_Function_class_DXGK_(DXGKDDI_DISPATCH_IO_REQUEST) +_IRQL_requires_DXGK_(PASSIVE_LEVEL) +NTSTATUS +APIENTRY +DXGKDDI_DISPATCH_IO_REQUEST( + _In_ CONST PVOID MiniportDeviceContext, + _In_ ULONG VidPnSourceId, + _In_ PVIDEO_REQUEST_PACKET VideoRequestPacket +); + +typedef +_Check_return_ +_Function_class_DXGK_(DXGKDDI_QUERY_CHILD_RELATIONS) +_IRQL_requires_DXGK_(PASSIVE_LEVEL) +NTSTATUS +APIENTRY +DXGKDDI_QUERY_CHILD_RELATIONS( + _In_ CONST PVOID MiniportDeviceContext, + _Inout_updates_bytes_(ChildRelationsSize) PDXGK_CHILD_DESCRIPTOR ChildRelations, + _In_ ULONG ChildRelationsSize +); + +typedef +_Check_return_ +_Function_class_DXGK_(DXGKDDI_QUERY_CHILD_STATUS) +_IRQL_requires_DXGK_(PASSIVE_LEVEL) +NTSTATUS +APIENTRY +DXGKDDI_QUERY_CHILD_STATUS( + _In_ CONST PVOID MiniportDeviceContext, + _Inout_ PDXGK_CHILD_STATUS ChildStatus, + _In_ BOOLEAN NonDestructiveOnly +); + +typedef +_Check_return_ +_Function_class_DXGK_(DXGKDDI_INTERRUPT_ROUTINE) +_IRQL_requires_DXGK_(HIGH_LEVEL) +BOOLEAN +APIENTRY +DXGKDDI_INTERRUPT_ROUTINE( + _In_ CONST PVOID MiniportDeviceContext, + _In_ ULONG MessageNumber +); + +typedef +_Function_class_DXGK_(DXGKDDI_DPC_ROUTINE) +_IRQL_requires_DXGK_(DISPATCH_LEVEL) +VOID +APIENTRY +DXGKDDI_DPC_ROUTINE( + _In_ CONST PVOID MiniportDeviceContext +); + +typedef +_Check_return_ +_Function_class_DXGK_(DXGKDDI_QUERY_DEVICE_DESCRIPTOR) +_IRQL_requires_DXGK_(PASSIVE_LEVEL) +NTSTATUS +APIENTRY +DXGKDDI_QUERY_DEVICE_DESCRIPTOR( + _In_ CONST PVOID MiniportDeviceContext, + _In_ ULONG ChildUid, + _Inout_ PDXGK_DEVICE_DESCRIPTOR DeviceDescriptor +); + +typedef +_Check_return_ +_Function_class_DXGK_(DXGKDDI_SET_POWER_STATE) +_IRQL_requires_DXGK_(PASSIVE_LEVEL) +NTSTATUS +APIENTRY +DXGKDDI_SET_POWER_STATE( + _In_ CONST PVOID MiniportDeviceContext, + _In_ ULONG DeviceUid, + _In_ DEVICE_POWER_STATE DevicePowerState, + _In_ POWER_ACTION ActionType +); + +typedef +_Check_return_ +_Function_class_DXGK_(DXGKDDI_NOTIFY_ACPI_EVENT) +_IRQL_requires_DXGK_(PASSIVE_LEVEL) +NTSTATUS +APIENTRY +DXGKDDI_NOTIFY_ACPI_EVENT( + _In_ CONST PVOID MiniportDeviceContext, + _In_ DXGK_EVENT_TYPE EventType, + _In_ ULONG Event, + _In_ PVOID Argument, + _Out_ PULONG AcpiFlags +); + +typedef +_Function_class_DXGK_(DXGKDDI_RESET_DEVICE) +VOID +APIENTRY +DXGKDDI_RESET_DEVICE( + _In_ CONST PVOID MiniportDeviceContext +); + +typedef +_Function_class_DXGK_(DXGKDDI_UNLOAD) +_IRQL_requires_DXGK_(PASSIVE_LEVEL) +VOID +APIENTRY +DXGKDDI_UNLOAD( + VOID +); + +typedef +_Check_return_ +_Function_class_DXGK_(DXGKDDI_QUERY_INTERFACE) +_IRQL_requires_DXGK_(PASSIVE_LEVEL) +NTSTATUS +APIENTRY +DXGKDDI_QUERY_INTERFACE( + _In_ CONST PVOID MiniportDeviceContext, + _In_ PQUERY_INTERFACE QueryInterface +); + +typedef +_Function_class_DXGK_(DXGKDDI_CONTROL_ETW_LOGGING) +_IRQL_requires_DXGK_(PASSIVE_LEVEL) +VOID +APIENTRY +DXGKDDI_CONTROL_ETW_LOGGING( + _In_ BOOLEAN Enable, + _In_ ULONG Flags, + _In_ UCHAR Level +); + +typedef +_Check_return_ +_Function_class_DXGK_(DXGKDDI_LINK_DEVICE) +_IRQL_requires_DXGK_(PASSIVE_LEVEL) +NTSTATUS +APIENTRY +DXGKDDI_LINK_DEVICE( + _In_ CONST PDEVICE_OBJECT PhysicalDeviceObject, + _In_ CONST PVOID MiniportDeviceContext, + _Inout_ PLINKED_DEVICE LinkedDevice +); + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_2) + +typedef struct _DXGK_PRE_START_INFO { + union { + struct { + UINT ReservedIn; + }; + UINT Input; + }; + union { + struct { + UINT SupportPreserveBootDisplay : 1; + UINT IsUEFIFrameBufferCpuAccessibleDuringStartup : 1; + UINT ReservedOut : 30; + }; + UINT Output; + }; +} DXGK_PRE_START_INFO, *PDXGK_PRE_START_INFO; + +typedef +_Check_return_ +_Function_class_DXGK_(DXGKDDI_EXCHANGEPRESTARTINFO) +_IRQL_requires_(PASSIVE_LEVEL) +NTSTATUS +APIENTRY +DXGKDDI_EXCHANGEPRESTARTINFO( + _In_ CONST HANDLE hAdapter, + _Inout_ PDXGK_PRE_START_INFO pPreStartInfo +); + +typedef +_Check_return_ +_Function_class_DXGK_(DXGKDDI_SETTARGETADJUSTEDCOLORIMETRY) +_IRQL_requires_(PASSIVE_LEVEL) +NTSTATUS +APIENTRY +DXGKDDI_SETTARGETADJUSTEDCOLORIMETRY( + _In_ CONST HANDLE hAdapter, + _In_ D3DDDI_VIDEO_PRESENT_TARGET_ID TargetId, + _In_ DXGK_COLORIMETRY AdjustedColorimetry +); + +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_2) + +typedef DXGKDDI_ADD_DEVICE *PDXGKDDI_ADD_DEVICE; +typedef DXGKDDI_START_DEVICE *PDXGKDDI_START_DEVICE; +typedef DXGKDDI_STOP_DEVICE *PDXGKDDI_STOP_DEVICE; +typedef DXGKDDI_REMOVE_DEVICE *PDXGKDDI_REMOVE_DEVICE; +typedef DXGKDDI_DISPATCH_IO_REQUEST *PDXGKDDI_DISPATCH_IO_REQUEST; +typedef DXGKDDI_QUERY_CHILD_RELATIONS *PDXGKDDI_QUERY_CHILD_RELATIONS; +typedef DXGKDDI_QUERY_CHILD_STATUS *PDXGKDDI_QUERY_CHILD_STATUS; +typedef DXGKDDI_INTERRUPT_ROUTINE *PDXGKDDI_INTERRUPT_ROUTINE; +typedef DXGKDDI_DPC_ROUTINE *PDXGKDDI_DPC_ROUTINE; +typedef DXGKDDI_QUERY_DEVICE_DESCRIPTOR *PDXGKDDI_QUERY_DEVICE_DESCRIPTOR; +typedef DXGKDDI_SET_POWER_STATE *PDXGKDDI_SET_POWER_STATE; +typedef DXGKDDI_NOTIFY_ACPI_EVENT *PDXGKDDI_NOTIFY_ACPI_EVENT; +typedef DXGKDDI_RESET_DEVICE *PDXGKDDI_RESET_DEVICE; +typedef DXGKDDI_UNLOAD *PDXGKDDI_UNLOAD; +typedef DXGKDDI_QUERY_INTERFACE *PDXGKDDI_QUERY_INTERFACE; +typedef DXGKDDI_CONTROL_ETW_LOGGING *PDXGKDDI_CONTROL_ETW_LOGGING; +typedef DXGKDDI_LINK_DEVICE *PDXGKDDI_LINK_DEVICE; +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_2) +typedef DXGKDDI_EXCHANGEPRESTARTINFO *PDXGKDDI_EXCHANGEPRESTARTINFO; +typedef DXGKDDI_SETTARGETADJUSTEDCOLORIMETRY *PDXGKDDI_SETTARGETADJUSTEDCOLORIMETRY; +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_2) + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) + +typedef +_Check_return_ +_Function_class_DXGK_(DXGKDDI_STOP_DEVICE_AND_RELEASE_POST_DISPLAY_OWNERSHIP) +_IRQL_requires_DXGK_(PASSIVE_LEVEL) +NTSTATUS +APIENTRY +DXGKDDI_STOP_DEVICE_AND_RELEASE_POST_DISPLAY_OWNERSHIP( + _In_ PVOID MiniportDeviceContext, + _In_ D3DDDI_VIDEO_PRESENT_TARGET_ID TargetId, + _Out_ PDXGK_DISPLAY_INFORMATION DisplayInfo +); + +typedef struct _DXGKARG_SYSTEM_DISPLAY_ENABLE_FLAGS +{ + union + { + struct + { + UINT Reserved : 32; + }; + UINT Value; + }; +} DXGKARG_SYSTEM_DISPLAY_ENABLE_FLAGS, *PDXGKARG_SYSTEM_DISPLAY_ENABLE_FLAGS; + +typedef +_Check_return_ +_Function_class_DXGK_(DXGKDDI_SYSTEM_DISPLAY_ENABLE) +NTSTATUS +APIENTRY +DXGKDDI_SYSTEM_DISPLAY_ENABLE( + _In_ PVOID MiniportDeviceContext, + _In_ D3DDDI_VIDEO_PRESENT_TARGET_ID TargetId, + _In_ PDXGKARG_SYSTEM_DISPLAY_ENABLE_FLAGS Flags, + _Out_ UINT* Width, + _Out_ UINT* Height, + _Out_ D3DDDIFORMAT* ColorFormat +); + +typedef +_Function_class_DXGK_(DXGKDDI_SYSTEM_DISPLAY_WRITE) +VOID +APIENTRY +DXGKDDI_SYSTEM_DISPLAY_WRITE( + _In_ PVOID MiniportDeviceContext, + _In_reads_bytes_(SourceHeight * SourceStride) PVOID Source, + _In_ UINT SourceWidth, + _In_ UINT SourceHeight, + _In_ UINT SourceStride, + _In_ UINT PositionX, + _In_ UINT PositionY +); + +typedef struct _DXGK_CHILD_CONTAINER_ID +{ + GUID ContainerId; + struct + { + ULONG64 PortId; + USHORT ManufacturerName; + USHORT ProductCode; + } EldInfo; +} DXGK_CHILD_CONTAINER_ID, *PDXGK_CHILD_CONTAINER_ID; + +typedef +_Check_return_ +_Function_class_DXGK_(DXGKDDI_GET_CHILD_CONTAINER_ID) +_IRQL_requires_DXGK_(PASSIVE_LEVEL) +NTSTATUS +APIENTRY +DXGKDDI_GET_CHILD_CONTAINER_ID( + _In_ PVOID MiniportDeviceContext, + _In_ ULONG ChildUid, + _Inout_ PDXGK_CHILD_CONTAINER_ID ContainerId +); + +typedef enum _DXGK_SURPRISE_REMOVAL_TYPE +{ + DxgkRemovalHibernation = 0, + DxgkRemovalPnPNotify = 1, +} DXGK_SURPRISE_REMOVAL_TYPE; + +typedef +_Check_return_ +_Function_class_DXGK_(DXGKDDI_NOTIFY_SURPRISE_REMOVAL) +_IRQL_requires_DXGK_(PASSIVE_LEVEL) +NTSTATUS +APIENTRY +DXGKDDI_NOTIFY_SURPRISE_REMOVAL( + _In_ PVOID MiniportDeviceContext, + _In_ DXGK_SURPRISE_REMOVAL_TYPE RemovalType +); + +typedef DXGKDDI_STOP_DEVICE_AND_RELEASE_POST_DISPLAY_OWNERSHIP *PDXGKDDI_STOP_DEVICE_AND_RELEASE_POST_DISPLAY_OWNERSHIP; +typedef DXGKDDI_SYSTEM_DISPLAY_ENABLE *PDXGKDDI_SYSTEM_DISPLAY_ENABLE; +typedef DXGKDDI_SYSTEM_DISPLAY_WRITE *PDXGKDDI_SYSTEM_DISPLAY_WRITE; +typedef DXGKDDI_GET_CHILD_CONTAINER_ID *PDXGKDDI_GET_CHILD_CONTAINER_ID; +typedef DXGKDDI_NOTIFY_SURPRISE_REMOVAL *PDXGKDDI_NOTIFY_SURPRISE_REMOVAL; + +#endif // DXGKDDI_INTERFACE_VERSION + +/* + * Passed from Miniport -> DxgKrnl + * Call backs Implemented by full WDDM drivers. + */ +typedef struct _DRIVER_INITIALIZATION_DATA { + ULONG Version; + PDXGKDDI_ADD_DEVICE DxgkDdiAddDevice; + PDXGKDDI_START_DEVICE DxgkDdiStartDevice; + PDXGKDDI_STOP_DEVICE DxgkDdiStopDevice; + PDXGKDDI_REMOVE_DEVICE DxgkDdiRemoveDevice; + PDXGKDDI_DISPATCH_IO_REQUEST DxgkDdiDispatchIoRequest; + PDXGKDDI_INTERRUPT_ROUTINE DxgkDdiInterruptRoutine; + PDXGKDDI_DPC_ROUTINE DxgkDdiDpcRoutine; + PDXGKDDI_QUERY_CHILD_RELATIONS DxgkDdiQueryChildRelations; + PDXGKDDI_QUERY_CHILD_STATUS DxgkDdiQueryChildStatus; + PDXGKDDI_QUERY_DEVICE_DESCRIPTOR DxgkDdiQueryDeviceDescriptor; + PDXGKDDI_SET_POWER_STATE DxgkDdiSetPowerState; + PDXGKDDI_NOTIFY_ACPI_EVENT DxgkDdiNotifyAcpiEvent; + PDXGKDDI_RESET_DEVICE DxgkDdiResetDevice; + PDXGKDDI_UNLOAD DxgkDdiUnload; + PDXGKDDI_QUERY_INTERFACE DxgkDdiQueryInterface; + PDXGKDDI_CONTROL_ETW_LOGGING DxgkDdiControlEtwLogging; + PDXGKDDI_QUERYADAPTERINFO DxgkDdiQueryAdapterInfo; + PDXGKDDI_CREATEDEVICE DxgkDdiCreateDevice; + PDXGKDDI_CREATEALLOCATION DxgkDdiCreateAllocation; + PDXGKDDI_DESTROYALLOCATION DxgkDdiDestroyAllocation; + PDXGKDDI_DESCRIBEALLOCATION DxgkDdiDescribeAllocation; + PDXGKDDI_GETSTANDARDALLOCATIONDRIVERDATA DxgkDdiGetStandardAllocationDriverData; + PDXGKDDI_ACQUIRESWIZZLINGRANGE DxgkDdiAcquireSwizzlingRange; + PDXGKDDI_RELEASESWIZZLINGRANGE DxgkDdiReleaseSwizzlingRange; + PDXGKDDI_PATCH DxgkDdiPatch; + PDXGKDDI_SUBMITCOMMAND DxgkDdiSubmitCommand; + PDXGKDDI_PREEMPTCOMMAND DxgkDdiPreemptCommand; + PDXGKDDI_BUILDPAGINGBUFFER DxgkDdiBuildPagingBuffer; + PDXGKDDI_SETPALETTE DxgkDdiSetPalette; + PDXGKDDI_SETPOINTERPOSITION DxgkDdiSetPointerPosition; + PDXGKDDI_SETPOINTERSHAPE DxgkDdiSetPointerShape; + PDXGKDDI_RESETFROMTIMEOUT DxgkDdiResetFromTimeout; + PDXGKDDI_RESTARTFROMTIMEOUT DxgkDdiRestartFromTimeout; + PDXGKDDI_ESCAPE DxgkDdiEscape; + PDXGKDDI_COLLECTDBGINFO DxgkDdiCollectDbgInfo; + PDXGKDDI_QUERYCURRENTFENCE DxgkDdiQueryCurrentFence; + PDXGKDDI_ISSUPPORTEDVIDPN DxgkDdiIsSupportedVidPn; + PDXGKDDI_RECOMMENDFUNCTIONALVIDPN DxgkDdiRecommendFunctionalVidPn; + PDXGKDDI_ENUMVIDPNCOFUNCMODALITY DxgkDdiEnumVidPnCofuncModality; + PDXGKDDI_SETVIDPNSOURCEADDRESS DxgkDdiSetVidPnSourceAddress; + PDXGKDDI_SETVIDPNSOURCEVISIBILITY DxgkDdiSetVidPnSourceVisibility; + PDXGKDDI_COMMITVIDPN DxgkDdiCommitVidPn; + PDXGKDDI_UPDATEACTIVEVIDPNPRESENTPATH DxgkDdiUpdateActiveVidPnPresentPath; + PDXGKDDI_RECOMMENDMONITORMODES DxgkDdiRecommendMonitorModes; + PDXGKDDI_RECOMMENDVIDPNTOPOLOGY DxgkDdiRecommendVidPnTopology; + PDXGKDDI_GETSCANLINE DxgkDdiGetScanLine; + PDXGKDDI_STOPCAPTURE DxgkDdiStopCapture; + PDXGKDDI_CONTROLINTERRUPT DxgkDdiControlInterrupt; + PDXGKDDI_CREATEOVERLAY DxgkDdiCreateOverlay; + PDXGKDDI_DESTROYDEVICE DxgkDdiDestroyDevice; + PDXGKDDI_OPENALLOCATIONINFO DxgkDdiOpenAllocation; + PDXGKDDI_CLOSEALLOCATION DxgkDdiCloseAllocation; + PDXGKDDI_RENDER DxgkDdiRender; + PDXGKDDI_PRESENT DxgkDdiPresent; + PDXGKDDI_UPDATEOVERLAY DxgkDdiUpdateOverlay; + PDXGKDDI_FLIPOVERLAY DxgkDdiFlipOverlay; + PDXGKDDI_DESTROYOVERLAY DxgkDdiDestroyOverlay; + PDXGKDDI_CREATECONTEXT DxgkDdiCreateContext; + PDXGKDDI_DESTROYCONTEXT DxgkDdiDestroyContext; + PDXGKDDI_LINK_DEVICE DxgkDdiLinkDevice; + PDXGKDDI_SETDISPLAYPRIVATEDRIVERFORMAT DxgkDdiSetDisplayPrivateDriverFormat; +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN7) + PVOID DxgkDdiDescribePageTable; + PVOID DxgkDdiUpdatePageTable; + PVOID DxgkDdiUpdatePageDirectory; + PVOID DxgkDdiMovePageDirectory; + PVOID DxgkDdiSubmitRender; + PVOID DxgkDdiCreateAllocation2; + PDXGKDDI_RENDER DxgkDdiRenderKm; + VOID* Reserved; + PDXGKDDI_QUERYVIDPNHWCAPABILITY DxgkDdiQueryVidPnHWCapability; +#endif // DXGKDDI_INTERFACE_VERSION +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) + PDXGKDDISETPOWERCOMPONENTFSTATE DxgkDdiSetPowerComponentFState; + PDXGKDDI_QUERYDEPENDENTENGINEGROUP DxgkDdiQueryDependentEngineGroup; + PDXGKDDI_QUERYENGINESTATUS DxgkDdiQueryEngineStatus; + PDXGKDDI_RESETENGINE DxgkDdiResetEngine; + PDXGKDDI_STOP_DEVICE_AND_RELEASE_POST_DISPLAY_OWNERSHIP DxgkDdiStopDeviceAndReleasePostDisplayOwnership; + PDXGKDDI_SYSTEM_DISPLAY_ENABLE DxgkDdiSystemDisplayEnable; + PDXGKDDI_SYSTEM_DISPLAY_WRITE DxgkDdiSystemDisplayWrite; + PDXGKDDI_CANCELCOMMAND DxgkDdiCancelCommand; + PDXGKDDI_GET_CHILD_CONTAINER_ID DxgkDdiGetChildContainerId; + PDXGKDDIPOWERRUNTIMECONTROLREQUEST DxgkDdiPowerRuntimeControlRequest; + PDXGKDDI_SETVIDPNSOURCEADDRESSWITHMULTIPLANEOVERLAY DxgkDdiSetVidPnSourceAddressWithMultiPlaneOverlay; + PDXGKDDI_NOTIFY_SURPRISE_REMOVAL DxgkDdiNotifySurpriseRemoval; +#endif // DXGKDDI_INTERFACE_VERSION +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM1_3) + PDXGKDDI_GETNODEMETADATA DxgkDdiGetNodeMetadata; + PDXGKDDISETPOWERPSTATE DxgkDdiSetPowerPState; + PDXGKDDI_CONTROLINTERRUPT2 DxgkDdiControlInterrupt2; + PDXGKDDI_CHECKMULTIPLANEOVERLAYSUPPORT DxgkDdiCheckMultiPlaneOverlaySupport; + PDXGKDDI_CALIBRATEGPUCLOCK DxgkDdiCalibrateGpuClock; + PDXGKDDI_FORMATHISTORYBUFFER DxgkDdiFormatHistoryBuffer; +#endif +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0) + PDXGKDDI_RENDERGDI DxgkDdiRenderGdi; + PDXGKDDI_SUBMITCOMMANDVIRTUAL DxgkDdiSubmitCommandVirtual; + PDXGKDDI_SETROOTPAGETABLE DxgkDdiSetRootPageTable; + PDXGKDDI_GETROOTPAGETABLESIZE DxgkDdiGetRootPageTableSize; + PDXGKDDI_MAPCPUHOSTAPERTURE DxgkDdiMapCpuHostAperture; + PDXGKDDI_UNMAPCPUHOSTAPERTURE DxgkDdiUnmapCpuHostAperture; + PDXGKDDI_CHECKMULTIPLANEOVERLAYSUPPORT2 DxgkDdiCheckMultiPlaneOverlaySupport2; + PDXGKDDI_CREATEPROCESS DxgkDdiCreateProcess; + PDXGKDDI_DESTROYPROCESS DxgkDdiDestroyProcess; + PDXGKDDI_SETVIDPNSOURCEADDRESSWITHMULTIPLANEOVERLAY2 DxgkDdiSetVidPnSourceAddressWithMultiPlaneOverlay2; + void* Reserved1; + void* Reserved2; + PDXGKDDI_POWERRUNTIMESETDEVICEHANDLE DxgkDdiPowerRuntimeSetDeviceHandle; + PDXGKDDI_SETSTABLEPOWERSTATE DxgkDdiSetStablePowerState; + PDXGKDDI_SETVIDEOPROTECTEDREGION DxgkDdiSetVideoProtectedRegion; +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0) +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_1) + PDXGKDDI_CHECKMULTIPLANEOVERLAYSUPPORT3 DxgkDdiCheckMultiPlaneOverlaySupport3; + PDXGKDDI_SETVIDPNSOURCEADDRESSWITHMULTIPLANEOVERLAY3 DxgkDdiSetVidPnSourceAddressWithMultiPlaneOverlay3; + PDXGKDDI_POSTMULTIPLANEOVERLAYPRESENT DxgkDdiPostMultiPlaneOverlayPresent; + PDXGKDDI_VALIDATEUPDATEALLOCATIONPROPERTY DxgkDdiValidateUpdateAllocationProperty; + PDXGKDDI_CONTROLMODEBEHAVIOR DxgkDdiControlModeBehavior; + PDXGKDDI_UPDATEMONITORLINKINFO DxgkDdiUpdateMonitorLinkInfo; +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_1) +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_2) + PDXGKDDI_CREATEHWCONTEXT DxgkDdiCreateHwContext; + PDXGKDDI_DESTROYHWCONTEXT DxgkDdiDestroyHwContext; + PDXGKDDI_CREATEHWQUEUE DxgkDdiCreateHwQueue; + PDXGKDDI_DESTROYHWQUEUE DxgkDdiDestroyHwQueue; + PDXGKDDI_SUBMITCOMMANDTOHWQUEUE DxgkDdiSubmitCommandToHwQueue; + PDXGKDDI_SWITCHTOHWCONTEXTLIST DxgkDdiSwitchToHwContextList; + PDXGKDDI_RESETHWENGINE DxgkDdiResetHwEngine; + PDXGKDDI_CREATEPERIODICFRAMENOTIFICATION DxgkDdiCreatePeriodicFrameNotification; + PDXGKDDI_DESTROYPERIODICFRAMENOTIFICATION DxgkDdiDestroyPeriodicFrameNotification; + PDXGKDDI_SETTIMINGSFROMVIDPN DxgkDdiSetTimingsFromVidPn; + PDXGKDDI_SETTARGETGAMMA DxgkDdiSetTargetGamma; + PDXGKDDI_SETTARGETCONTENTTYPE DxgkDdiSetTargetContentType; + PDXGKDDI_SETTARGETANALOGCOPYPROTECTION DxgkDdiSetTargetAnalogCopyProtection; + PDXGKDDI_SETTARGETADJUSTEDCOLORIMETRY DxgkDdiSetTargetAdjustedColorimetry; + PDXGKDDI_DISPLAYDETECTCONTROL DxgkDdiDisplayDetectControl; + PDXGKDDI_QUERYCONNECTIONCHANGE DxgkDdiQueryConnectionChange; + PDXGKDDI_EXCHANGEPRESTARTINFO DxgkDdiExchangePreStartInfo; + PDXGKDDI_GETMULTIPLANEOVERLAYCAPS DxgkDdiGetMultiPlaneOverlayCaps; + PDXGKDDI_GETPOSTCOMPOSITIONCAPS DxgkDdiGetPostCompositionCaps; +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_2) +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_3) + PDXGKDDI_UPDATEHWCONTEXTSTATE DxgkDdiUpdateHwContextState; + PDXGKDDI_CREATEPROTECTEDSESSION DxgkDdiCreateProtectedSession; + PDXGKDDI_DESTROYPROTECTEDSESSION DxgkDdiDestroyProtectedSession; +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_3) +} DRIVER_INITIALIZATION_DATA, *PDRIVER_INITIALIZATION_DATA; + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) +/* + * Passed from Miniport -> DxgKrnl + * Callbacks implemented by display-only drivers (KMDDOD). + */ +typedef struct _KMDDOD_INITIALIZATION_DATA { + ULONG Version; + PDXGKDDI_ADD_DEVICE DxgkDdiAddDevice; + PDXGKDDI_START_DEVICE DxgkDdiStartDevice; + PDXGKDDI_STOP_DEVICE DxgkDdiStopDevice; + PDXGKDDI_REMOVE_DEVICE DxgkDdiRemoveDevice; + PDXGKDDI_DISPATCH_IO_REQUEST DxgkDdiDispatchIoRequest; + PDXGKDDI_INTERRUPT_ROUTINE DxgkDdiInterruptRoutine; + PDXGKDDI_DPC_ROUTINE DxgkDdiDpcRoutine; + PDXGKDDI_QUERY_CHILD_RELATIONS DxgkDdiQueryChildRelations; + PDXGKDDI_QUERY_CHILD_STATUS DxgkDdiQueryChildStatus; + PDXGKDDI_QUERY_DEVICE_DESCRIPTOR DxgkDdiQueryDeviceDescriptor; + PDXGKDDI_SET_POWER_STATE DxgkDdiSetPowerState; + PDXGKDDI_NOTIFY_ACPI_EVENT DxgkDdiNotifyAcpiEvent; + PDXGKDDI_RESET_DEVICE DxgkDdiResetDevice; + PDXGKDDI_UNLOAD DxgkDdiUnload; + PDXGKDDI_QUERY_INTERFACE DxgkDdiQueryInterface; + PDXGKDDI_CONTROL_ETW_LOGGING DxgkDdiControlEtwLogging; + PDXGKDDI_QUERYADAPTERINFO DxgkDdiQueryAdapterInfo; + PDXGKDDI_SETPALETTE DxgkDdiSetPalette; + PDXGKDDI_SETPOINTERPOSITION DxgkDdiSetPointerPosition; + PDXGKDDI_SETPOINTERSHAPE DxgkDdiSetPointerShape; + PDXGKDDI_ESCAPE DxgkDdiEscape; + PDXGKDDI_COLLECTDBGINFO DxgkDdiCollectDbgInfo; + PDXGKDDI_ISSUPPORTEDVIDPN DxgkDdiIsSupportedVidPn; + PDXGKDDI_RECOMMENDFUNCTIONALVIDPN DxgkDdiRecommendFunctionalVidPn; + PDXGKDDI_ENUMVIDPNCOFUNCMODALITY DxgkDdiEnumVidPnCofuncModality; + PDXGKDDI_SETVIDPNSOURCEVISIBILITY DxgkDdiSetVidPnSourceVisibility; + PDXGKDDI_COMMITVIDPN DxgkDdiCommitVidPn; + PDXGKDDI_UPDATEACTIVEVIDPNPRESENTPATH DxgkDdiUpdateActiveVidPnPresentPath; + PDXGKDDI_RECOMMENDMONITORMODES DxgkDdiRecommendMonitorModes; + PDXGKDDI_GETSCANLINE DxgkDdiGetScanLine; + PDXGKDDI_QUERYVIDPNHWCAPABILITY DxgkDdiQueryVidPnHWCapability; + PDXGKDDI_PRESENTDISPLAYONLY DxgkDdiPresentDisplayOnly; + PDXGKDDI_STOP_DEVICE_AND_RELEASE_POST_DISPLAY_OWNERSHIP DxgkDdiStopDeviceAndReleasePostDisplayOwnership; + PDXGKDDI_SYSTEM_DISPLAY_ENABLE DxgkDdiSystemDisplayEnable; + PDXGKDDI_SYSTEM_DISPLAY_WRITE DxgkDdiSystemDisplayWrite; + PDXGKDDI_GET_CHILD_CONTAINER_ID DxgkDdiGetChildContainerId; + PDXGKDDISETPOWERCOMPONENTFSTATE DxgkDdiSetPowerComponentFState; + PDXGKDDIPOWERRUNTIMECONTROLREQUEST DxgkDdiPowerRuntimeControlRequest; + PDXGKDDI_NOTIFY_SURPRISE_REMOVAL DxgkDdiNotifySurpriseRemoval; +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0) + PDXGKDDI_POWERRUNTIMESETDEVICEHANDLE DxgkDdiPowerRuntimeSetDeviceHandle; +#endif +} KMDDOD_INITIALIZATION_DATA, *PKMDDOD_INITIALIZATION_DATA; +#endif // DXGKDDI_INTERFACE_VERSION_WIN8 + +/* + * DispLib exports + */ + +typedef enum _DEBUG_LEVEL { + DlDebugError, + DlDebugWarning, + DlDebugTrace, + DlDebugInfo +} DEBUG_LEVEL; + +NTSTATUS +DxgkInitialize( + _In_ PDRIVER_OBJECT DriverObject, + _In_ PUNICODE_STRING RegistryPath, + _In_ PDRIVER_INITIALIZATION_DATA DriverInitializationData +); + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) + +NTSTATUS +DxgkInitializeDisplayOnlyDriver( + _In_ PDRIVER_OBJECT DriverObject, + _In_ PUNICODE_STRING RegistryPath, + _In_ PKMDDOD_INITIALIZATION_DATA KmdDodInitializationData +); + +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WIN8) + +#if (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0) + +NTSTATUS +DxgkUnInitialize( + _In_ PDRIVER_OBJECT DriverObject +); + +#endif // (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_0) + +#endif // _DISPMPRT_H_ diff --git a/sdk/include/psdk/d3dukmdt.h b/sdk/include/psdk/d3dukmdt.h index 35b203657d7..3a37337a2d5 100644 --- a/sdk/include/psdk/d3dukmdt.h +++ b/sdk/include/psdk/d3dukmdt.h @@ -51,6 +51,7 @@ #define DXGKDDI_INTERFACE_VERSION_WDDM2_8 0xD001 #define DXGKDDI_INTERFACE_VERSION_WDDM2_9 0xE003 #define DXGKDDI_INTERFACE_VERSION_WDDM3_0 0xF003 +#define DXGKDDI_INTERFACE_VERSION_WDDM3_1 0x10002 #define IS_OFFICIAL_DDI_INTERFACE_VERSION(version) \ @@ -72,7 +73,8 @@ ((version) == DXGKDDI_INTERFACE_VERSION_WDDM2_7) || \ ((version) == DXGKDDI_INTERFACE_VERSION_WDDM2_8) || \ ((version) == DXGKDDI_INTERFACE_VERSION_WDDM2_9) || \ - ((version) == DXGKDDI_INTERFACE_VERSION_WDDM3_0) \ + ((version) == DXGKDDI_INTERFACE_VERSION_WDDM3_0) || \ + ((version) == DXGKDDI_INTERFACE_VERSION_WDDM3_1) \ ) #if !defined(DXGKDDI_INTERFACE_VERSION)