1/* 2 * Copyright (C) 2019-2021 Intel Corporation 3 * 4 * SPDX-License-Identifier: MIT 5 * 6 */ 7 8#pragma pack(1) 9typedef struct tagBINDING_TABLE_STATE { 10 union tagTheStructure { 11 struct tagCommon { 12 uint32_t Reserved_0 : BITFIELD_RANGE(0, 5); 13 uint32_t SurfaceStatePointer : BITFIELD_RANGE(6, 31); 14 } Common; 15 uint32_t RawData[1]; 16 } TheStructure; 17 typedef enum tagPATCH_CONSTANTS { 18 SURFACESTATEPOINTER_BYTEOFFSET = 0x0, 19 SURFACESTATEPOINTER_INDEX = 0x0, 20 } PATCH_CONSTANTS; 21 inline void init() { 22 memset(&TheStructure, 0, sizeof(TheStructure)); 23 } 24 static tagBINDING_TABLE_STATE sInit() { 25 BINDING_TABLE_STATE state; 26 state.init(); 27 return state; 28 } 29 inline uint32_t &getRawData(const uint32_t index) { 30 DEBUG_BREAK_IF(index >= 1); 31 return TheStructure.RawData[index]; 32 } 33 inline const uint32_t &getRawData(const uint32_t index) const { 34 DEBUG_BREAK_IF(index >= 1); 35 return TheStructure.RawData[index]; 36 } 37 typedef enum tagSURFACESTATEPOINTER { 38 SURFACESTATEPOINTER_BIT_SHIFT = 0x6, 39 SURFACESTATEPOINTER_ALIGN_SIZE = 0x40, 40 } SURFACESTATEPOINTER; 41 inline void setSurfaceStatePointer(const uint64_t value) { 42 DEBUG_BREAK_IF(value >= 0x100000000); 43 TheStructure.Common.SurfaceStatePointer = (uint32_t)value >> SURFACESTATEPOINTER_BIT_SHIFT; 44 } 45 inline uint32_t getSurfaceStatePointer() const { 46 return (TheStructure.Common.SurfaceStatePointer << SURFACESTATEPOINTER_BIT_SHIFT); 47 } 48} BINDING_TABLE_STATE; 49STATIC_ASSERT(4 == sizeof(BINDING_TABLE_STATE)); 50 51typedef struct tagGPGPU_WALKER { 52 union tagTheStructure { 53 struct tagCommon { 54 // DWORD 0 55 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 56 uint32_t PredicateEnable : BITFIELD_RANGE(8, 8); 57 uint32_t Reserved_9 : BITFIELD_RANGE(9, 9); 58 uint32_t IndirectParameterEnable : BITFIELD_RANGE(10, 10); 59 uint32_t Reserved_11 : BITFIELD_RANGE(11, 15); 60 uint32_t Subopcode : BITFIELD_RANGE(16, 23); 61 uint32_t MediaCommandOpcode : BITFIELD_RANGE(24, 26); 62 uint32_t Pipeline : BITFIELD_RANGE(27, 28); 63 uint32_t CommandType : BITFIELD_RANGE(29, 31); 64 // DWORD 1 65 uint32_t InterfaceDescriptorOffset : BITFIELD_RANGE(0, 5); 66 uint32_t Reserved_38 : BITFIELD_RANGE(6, 31); 67 // DWORD 2 68 uint32_t IndirectDataLength : BITFIELD_RANGE(0, 16); 69 uint32_t Reserved_81 : BITFIELD_RANGE(17, 31); 70 // DWORD 3 71 uint32_t Reserved_96 : BITFIELD_RANGE(0, 5); 72 uint32_t IndirectDataStartAddress : BITFIELD_RANGE(6, 31); 73 // DWORD 4 74 uint32_t ThreadWidthCounterMaximum : BITFIELD_RANGE(0, 5); 75 uint32_t Reserved_134 : BITFIELD_RANGE(6, 7); 76 uint32_t ThreadHeightCounterMaximum : BITFIELD_RANGE(8, 13); 77 uint32_t Reserved_142 : BITFIELD_RANGE(14, 15); 78 uint32_t ThreadDepthCounterMaximum : BITFIELD_RANGE(16, 21); 79 uint32_t Reserved_150 : BITFIELD_RANGE(22, 29); 80 uint32_t SimdSize : BITFIELD_RANGE(30, 31); 81 // DWORD 5 82 uint32_t ThreadGroupIdStartingX; 83 // DWORD 6 84 uint32_t Reserved_192; 85 // DWORD 7 86 uint32_t ThreadGroupIdXDimension; 87 // DWORD 8 88 uint32_t ThreadGroupIdStartingY; 89 // DWORD 9 90 uint32_t Reserved_288; 91 // DWORD 10 92 uint32_t ThreadGroupIdYDimension; 93 // DWORD 11 94 uint32_t ThreadGroupIdStartingResumeZ; 95 // DWORD 12 96 uint32_t ThreadGroupIdZDimension; 97 // DWORD 13 98 uint32_t RightExecutionMask; 99 // DWORD 14 100 uint32_t BottomExecutionMask; 101 } Common; 102 uint32_t RawData[15]; 103 } TheStructure; 104 typedef enum tagDWORD_LENGTH { 105 DWORD_LENGTH_DWORD_COUNT_N = 0xd, 106 } DWORD_LENGTH; 107 typedef enum tagSUBOPCODE { 108 SUBOPCODE_GPGPU_WALKER_SUBOP = 0x5, 109 } SUBOPCODE; 110 typedef enum tagMEDIA_COMMAND_OPCODE { 111 MEDIA_COMMAND_OPCODE_GPGPU_WALKER = 0x1, 112 } MEDIA_COMMAND_OPCODE; 113 typedef enum tagPIPELINE { 114 PIPELINE_MEDIA = 0x2, 115 } PIPELINE; 116 typedef enum tagCOMMAND_TYPE { 117 COMMAND_TYPE_GFXPIPE = 0x3, 118 } COMMAND_TYPE; 119 typedef enum tagSIMD_SIZE { 120 SIMD_SIZE_SIMD8 = 0x0, 121 SIMD_SIZE_SIMD16 = 0x1, 122 SIMD_SIZE_SIMD32 = 0x2, 123 } SIMD_SIZE; 124 inline void init() { 125 memset(&TheStructure, 0, sizeof(TheStructure)); 126 TheStructure.Common.DwordLength = DWORD_LENGTH_DWORD_COUNT_N; 127 TheStructure.Common.Subopcode = SUBOPCODE_GPGPU_WALKER_SUBOP; 128 TheStructure.Common.MediaCommandOpcode = MEDIA_COMMAND_OPCODE_GPGPU_WALKER; 129 TheStructure.Common.Pipeline = PIPELINE_MEDIA; 130 TheStructure.Common.CommandType = COMMAND_TYPE_GFXPIPE; 131 TheStructure.Common.SimdSize = SIMD_SIZE_SIMD8; 132 } 133 static tagGPGPU_WALKER sInit() { 134 GPGPU_WALKER state; 135 state.init(); 136 return state; 137 } 138 inline uint32_t &getRawData(const uint32_t index) { 139 return TheStructure.RawData[index]; 140 } 141 inline void setPredicateEnable(const bool value) { 142 TheStructure.Common.PredicateEnable = value; 143 } 144 inline bool getPredicateEnable() const { 145 return TheStructure.Common.PredicateEnable; 146 } 147 inline void setIndirectParameterEnable(const bool value) { 148 TheStructure.Common.IndirectParameterEnable = value; 149 } 150 inline bool getIndirectParameterEnable() const { 151 return TheStructure.Common.IndirectParameterEnable; 152 } 153 inline void setInterfaceDescriptorOffset(const uint32_t value) { 154 TheStructure.Common.InterfaceDescriptorOffset = value; 155 } 156 inline uint32_t getInterfaceDescriptorOffset() const { 157 return TheStructure.Common.InterfaceDescriptorOffset; 158 } 159 inline void setIndirectDataLength(const uint32_t value) { 160 TheStructure.Common.IndirectDataLength = value; 161 } 162 inline uint32_t getIndirectDataLength() const { 163 return TheStructure.Common.IndirectDataLength; 164 } 165 typedef enum tagINDIRECTDATASTARTADDRESS { 166 INDIRECTDATASTARTADDRESS_BIT_SHIFT = 0x6, 167 INDIRECTDATASTARTADDRESS_ALIGN_SIZE = 0x40, 168 } INDIRECTDATASTARTADDRESS; 169 inline void setIndirectDataStartAddress(const uint32_t value) { 170 TheStructure.Common.IndirectDataStartAddress = value >> INDIRECTDATASTARTADDRESS_BIT_SHIFT; 171 } 172 inline uint32_t getIndirectDataStartAddress() const { 173 return TheStructure.Common.IndirectDataStartAddress << INDIRECTDATASTARTADDRESS_BIT_SHIFT; 174 } 175 inline void setThreadWidthCounterMaximum(const uint32_t value) { 176 TheStructure.Common.ThreadWidthCounterMaximum = value - 1; 177 } 178 inline uint32_t getThreadWidthCounterMaximum() const { 179 return TheStructure.Common.ThreadWidthCounterMaximum + 1; 180 } 181 inline void setThreadHeightCounterMaximum(const uint32_t value) { 182 TheStructure.Common.ThreadHeightCounterMaximum = value - 1; 183 } 184 inline uint32_t getThreadHeightCounterMaximum() const { 185 return TheStructure.Common.ThreadHeightCounterMaximum + 1; 186 } 187 inline void setThreadDepthCounterMaximum(const uint32_t value) { 188 TheStructure.Common.ThreadDepthCounterMaximum = value; 189 } 190 inline uint32_t getThreadDepthCounterMaximum() const { 191 return TheStructure.Common.ThreadDepthCounterMaximum; 192 } 193 inline void setSimdSize(const SIMD_SIZE value) { 194 TheStructure.Common.SimdSize = value; 195 } 196 inline SIMD_SIZE getSimdSize() const { 197 return static_cast<SIMD_SIZE>(TheStructure.Common.SimdSize); 198 } 199 inline void setThreadGroupIdStartingX(const uint32_t value) { 200 TheStructure.Common.ThreadGroupIdStartingX = value; 201 } 202 inline uint32_t getThreadGroupIdStartingX() const { 203 return TheStructure.Common.ThreadGroupIdStartingX; 204 } 205 inline void setThreadGroupIdXDimension(const uint32_t value) { 206 TheStructure.Common.ThreadGroupIdXDimension = value; 207 } 208 inline uint32_t getThreadGroupIdXDimension() const { 209 return TheStructure.Common.ThreadGroupIdXDimension; 210 } 211 inline void setThreadGroupIdStartingY(const uint32_t value) { 212 TheStructure.Common.ThreadGroupIdStartingY = value; 213 } 214 inline uint32_t getThreadGroupIdStartingY() const { 215 return TheStructure.Common.ThreadGroupIdStartingY; 216 } 217 inline void setThreadGroupIdYDimension(const uint32_t value) { 218 TheStructure.Common.ThreadGroupIdYDimension = value; 219 } 220 inline uint32_t getThreadGroupIdYDimension() const { 221 return TheStructure.Common.ThreadGroupIdYDimension; 222 } 223 inline void setThreadGroupIdStartingResumeZ(const uint32_t value) { 224 TheStructure.Common.ThreadGroupIdStartingResumeZ = value; 225 } 226 inline uint32_t getThreadGroupIdStartingResumeZ() const { 227 return TheStructure.Common.ThreadGroupIdStartingResumeZ; 228 } 229 inline void setThreadGroupIdZDimension(const uint32_t value) { 230 TheStructure.Common.ThreadGroupIdZDimension = value; 231 } 232 inline uint32_t getThreadGroupIdZDimension() const { 233 return TheStructure.Common.ThreadGroupIdZDimension; 234 } 235 inline void setRightExecutionMask(const uint32_t value) { 236 TheStructure.Common.RightExecutionMask = value; 237 } 238 inline uint32_t getRightExecutionMask() const { 239 return TheStructure.Common.RightExecutionMask; 240 } 241 inline void setBottomExecutionMask(const uint32_t value) { 242 TheStructure.Common.BottomExecutionMask = value; 243 } 244 inline uint32_t getBottomExecutionMask() const { 245 return TheStructure.Common.BottomExecutionMask; 246 } 247} GPGPU_WALKER; 248STATIC_ASSERT(60 == sizeof(GPGPU_WALKER)); 249 250typedef struct tagINTERFACE_DESCRIPTOR_DATA { 251 union tagTheStructure { 252 struct tagCommon { 253 // DWORD 0 254 uint32_t Reserved_0 : BITFIELD_RANGE(0, 5); 255 uint32_t KernelStartPointer : BITFIELD_RANGE(6, 31); 256 // DWORD 1 257 uint32_t KernelStartPointerHigh : BITFIELD_RANGE(0, 15); 258 uint32_t Reserved_48 : BITFIELD_RANGE(16, 31); 259 // DWORD 2 260 uint32_t Reserved_64 : BITFIELD_RANGE(0, 6); 261 uint32_t SoftwareExceptionEnable : BITFIELD_RANGE(7, 7); 262 uint32_t Reserved_72 : BITFIELD_RANGE(8, 10); 263 uint32_t MaskStackExceptionEnable : BITFIELD_RANGE(11, 11); 264 uint32_t Reserved_76 : BITFIELD_RANGE(12, 12); 265 uint32_t IllegalOpcodeExceptionEnable : BITFIELD_RANGE(13, 13); 266 uint32_t Reserved_78 : BITFIELD_RANGE(14, 15); 267 uint32_t FloatingPointMode : BITFIELD_RANGE(16, 16); 268 uint32_t ThreadPriority : BITFIELD_RANGE(17, 17); 269 uint32_t SingleProgramFlow : BITFIELD_RANGE(18, 18); 270 uint32_t DenormMode : BITFIELD_RANGE(19, 19); 271 uint32_t ThreadPreemptionDisable : BITFIELD_RANGE(20, 20); 272 uint32_t Reserved_85 : BITFIELD_RANGE(21, 31); 273 // DWORD 3 274 uint32_t Reserved_96 : BITFIELD_RANGE(0, 1); 275 uint32_t SamplerCount : BITFIELD_RANGE(2, 4); 276 uint32_t SamplerStatePointer : BITFIELD_RANGE(5, 31); 277 // DWORD 4 278 uint32_t BindingTableEntryCount : BITFIELD_RANGE(0, 4); 279 uint32_t BindingTablePointer : BITFIELD_RANGE(5, 15); 280 uint32_t Reserved_144 : BITFIELD_RANGE(16, 31); 281 // DWORD 5 282 uint32_t ConstantUrbEntryReadOffset : BITFIELD_RANGE(0, 15); 283 uint32_t ConstantIndirectUrbEntryReadLength : BITFIELD_RANGE(16, 31); 284 // DWORD 6 285 uint32_t NumberOfThreadsInGpgpuThreadGroup : BITFIELD_RANGE(0, 9); 286 uint32_t Reserved_202 : BITFIELD_RANGE(10, 12); 287 uint32_t OverDispatchControl : BITFIELD_RANGE(13, 14); 288 uint32_t Reserved_207 : BITFIELD_RANGE(15, 15); 289 uint32_t SharedLocalMemorySize : BITFIELD_RANGE(16, 20); 290 uint32_t BarrierEnable : BITFIELD_RANGE(21, 21); 291 uint32_t RoundingMode : BITFIELD_RANGE(22, 23); 292 uint32_t Reserved_216 : BITFIELD_RANGE(24, 31); 293 // DWORD 7 294 uint32_t CrossThreadConstantDataReadLength : BITFIELD_RANGE(0, 7); 295 uint32_t Reserved_232 : BITFIELD_RANGE(8, 31); 296 } Common; 297 uint32_t RawData[8]; 298 } TheStructure; 299 typedef enum tagFLOATING_POINT_MODE { 300 FLOATING_POINT_MODE_IEEE_754 = 0x0, 301 FLOATING_POINT_MODE_ALTERNATE = 0x1, 302 } FLOATING_POINT_MODE; 303 typedef enum tagTHREAD_PRIORITY { 304 THREAD_PRIORITY_NORMAL_PRIORITY = 0x0, 305 THREAD_PRIORITY_HIGH_PRIORITY = 0x1, 306 } THREAD_PRIORITY; 307 typedef enum tagSINGLE_PROGRAM_FLOW { 308 SINGLE_PROGRAM_FLOW_MULTIPLE = 0x0, 309 SINGLE_PROGRAM_FLOW_SINGLE = 0x1, 310 } SINGLE_PROGRAM_FLOW; 311 typedef enum tagDENORM_MODE { 312 DENORM_MODE_FTZ = 0x0, 313 DENORM_MODE_SETBYKERNEL = 0x1, 314 } DENORM_MODE; 315 typedef enum tagTHREAD_PREEMPTION_DISABLE { 316 THREAD_PREEMPTION_DISABLE_DISABLE = 0x0, 317 THREAD_PREEMPTION_DISABLE_ENABLE = 0x1, 318 } THREAD_PREEMPTION_DISABLE; 319 typedef enum tagSAMPLER_COUNT { 320 SAMPLER_COUNT_NO_SAMPLERS_USED = 0x0, 321 SAMPLER_COUNT_BETWEEN_1_AND_4_SAMPLERS_USED = 0x1, 322 SAMPLER_COUNT_BETWEEN_5_AND_8_SAMPLERS_USED = 0x2, 323 SAMPLER_COUNT_BETWEEN_9_AND_12_SAMPLERS_USED = 0x3, 324 SAMPLER_COUNT_BETWEEN_13_AND_16_SAMPLERS_USED = 0x4, 325 } SAMPLER_COUNT; 326 typedef enum tagOVER_DISPATCH_CONTROL { 327 OVER_DISPATCH_CONTROL_NONE = 0x0, 328 OVER_DISPATCH_CONTROL_LOW = 0x1, 329 OVER_DISPATCH_CONTROL_HIGH = 0x2, 330 OVER_DISPATCH_CONTROL_NORMAL = 0x3, 331 } OVER_DISPATCH_CONTROL; 332 typedef enum tagSHARED_LOCAL_MEMORY_SIZE { 333 SHARED_LOCAL_MEMORY_SIZE_ENCODES_0K = 0x0, 334 SHARED_LOCAL_MEMORY_SIZE_ENCODES_1K = 0x1, 335 SHARED_LOCAL_MEMORY_SIZE_ENCODES_2K = 0x2, 336 SHARED_LOCAL_MEMORY_SIZE_ENCODES_4K = 0x3, 337 SHARED_LOCAL_MEMORY_SIZE_ENCODES_8K = 0x4, 338 SHARED_LOCAL_MEMORY_SIZE_ENCODES_16K = 0x5, 339 SHARED_LOCAL_MEMORY_SIZE_ENCODES_32K = 0x6, 340 SHARED_LOCAL_MEMORY_SIZE_ENCODES_64K = 0x7, 341 } SHARED_LOCAL_MEMORY_SIZE; 342 typedef enum tagROUNDING_MODE { 343 ROUNDING_MODE_RTNE = 0x0, 344 ROUNDING_MODE_RU = 0x1, 345 ROUNDING_MODE_RD = 0x2, 346 ROUNDING_MODE_RTZ = 0x3, 347 } ROUNDING_MODE; 348 inline void init() { 349 memset(&TheStructure, 0, sizeof(TheStructure)); 350 TheStructure.Common.FloatingPointMode = FLOATING_POINT_MODE_IEEE_754; 351 TheStructure.Common.ThreadPriority = THREAD_PRIORITY_NORMAL_PRIORITY; 352 TheStructure.Common.SingleProgramFlow = SINGLE_PROGRAM_FLOW_MULTIPLE; 353 TheStructure.Common.DenormMode = DENORM_MODE_FTZ; 354 TheStructure.Common.ThreadPreemptionDisable = THREAD_PREEMPTION_DISABLE_DISABLE; 355 TheStructure.Common.SamplerCount = SAMPLER_COUNT_NO_SAMPLERS_USED; 356 TheStructure.Common.OverDispatchControl = OVER_DISPATCH_CONTROL_NONE; 357 TheStructure.Common.SharedLocalMemorySize = SHARED_LOCAL_MEMORY_SIZE_ENCODES_0K; 358 TheStructure.Common.RoundingMode = ROUNDING_MODE_RTNE; 359 } 360 static tagINTERFACE_DESCRIPTOR_DATA sInit() { 361 INTERFACE_DESCRIPTOR_DATA state; 362 state.init(); 363 return state; 364 } 365 inline uint32_t &getRawData(const uint32_t index) { 366 return TheStructure.RawData[index]; 367 } 368 typedef enum tagKERNELSTARTPOINTER { 369 KERNELSTARTPOINTER_BIT_SHIFT = 0x6, 370 KERNELSTARTPOINTER_ALIGN_SIZE = 0x40, 371 } KERNELSTARTPOINTER; 372 inline void setKernelStartPointer(const uint64_t value) { 373 DEBUG_BREAK_IF(value >= 0x100000000); 374 TheStructure.Common.KernelStartPointer = static_cast<uint32_t>(value) >> KERNELSTARTPOINTER_BIT_SHIFT; 375 } 376 inline uint32_t getKernelStartPointer() const { 377 return TheStructure.Common.KernelStartPointer << KERNELSTARTPOINTER_BIT_SHIFT; 378 } 379 inline void setKernelStartPointerHigh(const uint32_t value) { 380 TheStructure.Common.KernelStartPointerHigh = static_cast<uint32_t>(value); 381 } 382 inline uint32_t getKernelStartPointerHigh() const { 383 return TheStructure.Common.KernelStartPointerHigh; 384 } 385 inline void setSoftwareExceptionEnable(const bool value) { 386 TheStructure.Common.SoftwareExceptionEnable = value; 387 } 388 inline bool getSoftwareExceptionEnable() const { 389 return TheStructure.Common.SoftwareExceptionEnable; 390 } 391 inline void setMaskStackExceptionEnable(const bool value) { 392 TheStructure.Common.MaskStackExceptionEnable = value; 393 } 394 inline bool getMaskStackExceptionEnable() const { 395 return TheStructure.Common.MaskStackExceptionEnable; 396 } 397 inline void setIllegalOpcodeExceptionEnable(const bool value) { 398 TheStructure.Common.IllegalOpcodeExceptionEnable = value; 399 } 400 inline bool getIllegalOpcodeExceptionEnable() const { 401 return TheStructure.Common.IllegalOpcodeExceptionEnable; 402 } 403 inline void setFloatingPointMode(const FLOATING_POINT_MODE value) { 404 TheStructure.Common.FloatingPointMode = value; 405 } 406 inline FLOATING_POINT_MODE getFloatingPointMode() const { 407 return static_cast<FLOATING_POINT_MODE>(TheStructure.Common.FloatingPointMode); 408 } 409 inline void setThreadPriority(const THREAD_PRIORITY value) { 410 TheStructure.Common.ThreadPriority = value; 411 } 412 inline THREAD_PRIORITY getThreadPriority() const { 413 return static_cast<THREAD_PRIORITY>(TheStructure.Common.ThreadPriority); 414 } 415 inline void setSingleProgramFlow(const SINGLE_PROGRAM_FLOW value) { 416 TheStructure.Common.SingleProgramFlow = value; 417 } 418 inline SINGLE_PROGRAM_FLOW getSingleProgramFlow() const { 419 return static_cast<SINGLE_PROGRAM_FLOW>(TheStructure.Common.SingleProgramFlow); 420 } 421 inline void setDenormMode(const DENORM_MODE value) { 422 TheStructure.Common.DenormMode = value; 423 } 424 inline DENORM_MODE getDenormMode() const { 425 return static_cast<DENORM_MODE>(TheStructure.Common.DenormMode); 426 } 427 inline void setThreadPreemptionDisable(const THREAD_PREEMPTION_DISABLE value) { 428 TheStructure.Common.ThreadPreemptionDisable = value; 429 } 430 inline THREAD_PREEMPTION_DISABLE getThreadPreemptionDisable() const { 431 return static_cast<THREAD_PREEMPTION_DISABLE>(TheStructure.Common.ThreadPreemptionDisable); 432 } 433 inline void setSamplerCount(const SAMPLER_COUNT value) { 434 TheStructure.Common.SamplerCount = value; 435 } 436 inline SAMPLER_COUNT getSamplerCount() const { 437 return static_cast<SAMPLER_COUNT>(TheStructure.Common.SamplerCount); 438 } 439 typedef enum tagSAMPLERSTATEPOINTER { 440 SAMPLERSTATEPOINTER_BIT_SHIFT = 0x5, 441 SAMPLERSTATEPOINTER_ALIGN_SIZE = 0x20, 442 } SAMPLERSTATEPOINTER; 443 inline void setSamplerStatePointer(const uint32_t value) { 444 TheStructure.Common.SamplerStatePointer = static_cast<uint32_t>(value) >> SAMPLERSTATEPOINTER_BIT_SHIFT; 445 } 446 inline uint32_t getSamplerStatePointer() const { 447 return TheStructure.Common.SamplerStatePointer << SAMPLERSTATEPOINTER_BIT_SHIFT; 448 } 449 inline void setBindingTableEntryCount(const uint32_t value) { 450 TheStructure.Common.BindingTableEntryCount = value; 451 } 452 inline uint32_t getBindingTableEntryCount() const { 453 return TheStructure.Common.BindingTableEntryCount; 454 } 455 typedef enum tagBINDINGTABLEPOINTER { 456 BINDINGTABLEPOINTER_BIT_SHIFT = 0x5, 457 BINDINGTABLEPOINTER_ALIGN_SIZE = 0x20, 458 } BINDINGTABLEPOINTER; 459 inline void setBindingTablePointer(const uint32_t value) { 460 TheStructure.Common.BindingTablePointer = static_cast<uint32_t>(value) >> BINDINGTABLEPOINTER_BIT_SHIFT; 461 } 462 inline uint32_t getBindingTablePointer() const { 463 return TheStructure.Common.BindingTablePointer << BINDINGTABLEPOINTER_BIT_SHIFT; 464 } 465 inline void setConstantUrbEntryReadOffset(const uint32_t value) { 466 TheStructure.Common.ConstantUrbEntryReadOffset = value; 467 } 468 inline uint32_t getConstantUrbEntryReadOffset() const { 469 return TheStructure.Common.ConstantUrbEntryReadOffset; 470 } 471 inline void setConstantIndirectUrbEntryReadLength(const uint32_t value) { 472 TheStructure.Common.ConstantIndirectUrbEntryReadLength = value; 473 } 474 inline uint32_t getConstantIndirectUrbEntryReadLength() const { 475 return TheStructure.Common.ConstantIndirectUrbEntryReadLength; 476 } 477 inline void setNumberOfThreadsInGpgpuThreadGroup(const uint32_t value) { 478 TheStructure.Common.NumberOfThreadsInGpgpuThreadGroup = value; 479 } 480 inline uint32_t getNumberOfThreadsInGpgpuThreadGroup() const { 481 return TheStructure.Common.NumberOfThreadsInGpgpuThreadGroup; 482 } 483 inline void setOverDispatchControl(const OVER_DISPATCH_CONTROL value) { 484 TheStructure.Common.OverDispatchControl = value; 485 } 486 inline OVER_DISPATCH_CONTROL getOverDispatchControl() const { 487 return static_cast<OVER_DISPATCH_CONTROL>(TheStructure.Common.OverDispatchControl); 488 } 489 inline void setSharedLocalMemorySize(const SHARED_LOCAL_MEMORY_SIZE value) { 490 TheStructure.Common.SharedLocalMemorySize = value; 491 } 492 inline SHARED_LOCAL_MEMORY_SIZE getSharedLocalMemorySize() const { 493 return static_cast<SHARED_LOCAL_MEMORY_SIZE>(TheStructure.Common.SharedLocalMemorySize); 494 } 495 inline void setBarrierEnable(const uint32_t value) { 496 TheStructure.Common.BarrierEnable = (value > 0u) ? 1u : 0u; 497 } 498 inline bool getBarrierEnable() const { 499 return TheStructure.Common.BarrierEnable; 500 } 501 inline void setRoundingMode(const ROUNDING_MODE value) { 502 TheStructure.Common.RoundingMode = value; 503 } 504 inline ROUNDING_MODE getRoundingMode() const { 505 return static_cast<ROUNDING_MODE>(TheStructure.Common.RoundingMode); 506 } 507 inline void setCrossThreadConstantDataReadLength(const uint32_t value) { 508 TheStructure.Common.CrossThreadConstantDataReadLength = value; 509 } 510 inline uint32_t getCrossThreadConstantDataReadLength() const { 511 return TheStructure.Common.CrossThreadConstantDataReadLength; 512 } 513} INTERFACE_DESCRIPTOR_DATA; 514STATIC_ASSERT(32 == sizeof(INTERFACE_DESCRIPTOR_DATA)); 515 516typedef struct tagMEDIA_INTERFACE_DESCRIPTOR_LOAD { 517 union tagTheStructure { 518 struct tagCommon { 519 // DWORD 0 520 uint32_t DwordLength : BITFIELD_RANGE(0, 15); 521 uint32_t Subopcode : BITFIELD_RANGE(16, 23); 522 uint32_t MediaCommandOpcode : BITFIELD_RANGE(24, 26); 523 uint32_t Pipeline : BITFIELD_RANGE(27, 28); 524 uint32_t CommandType : BITFIELD_RANGE(29, 31); 525 // DWORD 1 526 uint32_t Reserved_32; 527 // DWORD 2 528 uint32_t InterfaceDescriptorTotalLength : BITFIELD_RANGE(0, 16); 529 uint32_t Reserved_81 : BITFIELD_RANGE(17, 31); 530 // DWORD 3 531 uint32_t InterfaceDescriptorDataStartAddress; 532 } Common; 533 uint32_t RawData[4]; 534 } TheStructure; 535 typedef enum tagDWORD_LENGTH { 536 DWORD_LENGTH_DWORD_COUNT_N = 0x2, 537 } DWORD_LENGTH; 538 typedef enum tagSUBOPCODE { 539 SUBOPCODE_MEDIA_INTERFACE_DESCRIPTOR_LOAD_SUBOP = 0x2, 540 } SUBOPCODE; 541 typedef enum tagMEDIA_COMMAND_OPCODE { 542 MEDIA_COMMAND_OPCODE_MEDIA_INTERFACE_DESCRIPTOR_LOAD = 0x0, 543 } MEDIA_COMMAND_OPCODE; 544 typedef enum tagPIPELINE { 545 PIPELINE_MEDIA = 0x2, 546 } PIPELINE; 547 typedef enum tagCOMMAND_TYPE { 548 COMMAND_TYPE_GFXPIPE = 0x3, 549 } COMMAND_TYPE; 550 typedef enum tagINTERFACE_DESCRIPTOR_TOTAL_LENGTH { 551 INTERFACE_DESCRIPTOR_TOTAL_LENGTH_1_64_INTERFACE_DESCRIPTOR_ENTRIES_MIN = 0x20, 552 INTERFACE_DESCRIPTOR_TOTAL_LENGTH_1_64_INTERFACE_DESCRIPTOR_ENTRIES_MAX = 0x800, 553 } INTERFACE_DESCRIPTOR_TOTAL_LENGTH; 554 inline void init() { 555 memset(&TheStructure, 0, sizeof(TheStructure)); 556 TheStructure.Common.DwordLength = DWORD_LENGTH_DWORD_COUNT_N; 557 TheStructure.Common.Subopcode = SUBOPCODE_MEDIA_INTERFACE_DESCRIPTOR_LOAD_SUBOP; 558 TheStructure.Common.MediaCommandOpcode = MEDIA_COMMAND_OPCODE_MEDIA_INTERFACE_DESCRIPTOR_LOAD; 559 TheStructure.Common.Pipeline = PIPELINE_MEDIA; 560 TheStructure.Common.CommandType = COMMAND_TYPE_GFXPIPE; 561 } 562 static tagMEDIA_INTERFACE_DESCRIPTOR_LOAD sInit() { 563 MEDIA_INTERFACE_DESCRIPTOR_LOAD state; 564 state.init(); 565 return state; 566 } 567 inline uint32_t &getRawData(const uint32_t index) { 568 return TheStructure.RawData[index]; 569 } 570 inline void setInterfaceDescriptorTotalLength(const uint32_t value) { 571 TheStructure.Common.InterfaceDescriptorTotalLength = value; 572 } 573 inline uint32_t getInterfaceDescriptorTotalLength() const { 574 return TheStructure.Common.InterfaceDescriptorTotalLength; 575 } 576 inline void setInterfaceDescriptorDataStartAddress(const uint32_t value) { 577 TheStructure.Common.InterfaceDescriptorDataStartAddress = value; 578 } 579 inline uint32_t getInterfaceDescriptorDataStartAddress() const { 580 return TheStructure.Common.InterfaceDescriptorDataStartAddress; 581 } 582} MEDIA_INTERFACE_DESCRIPTOR_LOAD; 583STATIC_ASSERT(16 == sizeof(MEDIA_INTERFACE_DESCRIPTOR_LOAD)); 584 585typedef struct tagMEDIA_STATE_FLUSH { 586 union tagTheStructure { 587 struct tagCommon { 588 // DWORD 0 589 uint32_t DwordLength : BITFIELD_RANGE(0, 15); 590 uint32_t Subopcode : BITFIELD_RANGE(16, 23); 591 uint32_t MediaCommandOpcode : BITFIELD_RANGE(24, 26); 592 uint32_t Pipeline : BITFIELD_RANGE(27, 28); 593 uint32_t CommandType : BITFIELD_RANGE(29, 31); 594 // DWORD 1 595 uint32_t InterfaceDescriptorOffset : BITFIELD_RANGE(0, 5); 596 uint32_t Reserved_38 : BITFIELD_RANGE(6, 6); 597 uint32_t FlushToGo : BITFIELD_RANGE(7, 7); 598 uint32_t Reserved_40 : BITFIELD_RANGE(8, 31); 599 } Common; 600 uint32_t RawData[2]; 601 } TheStructure; 602 typedef enum tagDWORD_LENGTH { 603 DWORD_LENGTH_DWORD_COUNT_N = 0x0, 604 } DWORD_LENGTH; 605 typedef enum tagSUBOPCODE { 606 SUBOPCODE_MEDIA_STATE_FLUSH_SUBOP = 0x4, 607 } SUBOPCODE; 608 typedef enum tagMEDIA_COMMAND_OPCODE { 609 MEDIA_COMMAND_OPCODE_MEDIA_STATE_FLUSH = 0x0, 610 } MEDIA_COMMAND_OPCODE; 611 typedef enum tagPIPELINE { 612 PIPELINE_MEDIA = 0x2, 613 } PIPELINE; 614 typedef enum tagCOMMAND_TYPE { 615 COMMAND_TYPE_GFXPIPE = 0x3, 616 } COMMAND_TYPE; 617 inline void init() { 618 memset(&TheStructure, 0, sizeof(TheStructure)); 619 TheStructure.Common.DwordLength = DWORD_LENGTH_DWORD_COUNT_N; 620 TheStructure.Common.Subopcode = SUBOPCODE_MEDIA_STATE_FLUSH_SUBOP; 621 TheStructure.Common.MediaCommandOpcode = MEDIA_COMMAND_OPCODE_MEDIA_STATE_FLUSH; 622 TheStructure.Common.Pipeline = PIPELINE_MEDIA; 623 TheStructure.Common.CommandType = COMMAND_TYPE_GFXPIPE; 624 } 625 static tagMEDIA_STATE_FLUSH sInit() { 626 MEDIA_STATE_FLUSH state; 627 state.init(); 628 return state; 629 } 630 inline uint32_t &getRawData(const uint32_t index) { 631 return TheStructure.RawData[index]; 632 } 633 inline void setInterfaceDescriptorOffset(const uint32_t value) { 634 TheStructure.Common.InterfaceDescriptorOffset = value; 635 } 636 inline uint32_t getInterfaceDescriptorOffset() const { 637 return TheStructure.Common.InterfaceDescriptorOffset; 638 } 639 inline void setFlushToGo(const bool value) { 640 TheStructure.Common.FlushToGo = value; 641 } 642 inline bool getFlushToGo() const { 643 return TheStructure.Common.FlushToGo; 644 } 645} MEDIA_STATE_FLUSH; 646STATIC_ASSERT(8 == sizeof(MEDIA_STATE_FLUSH)); 647 648typedef struct tagMEDIA_VFE_STATE { 649 union tagTheStructure { 650 struct tagCommon { 651 uint32_t DwordLength : BITFIELD_RANGE(0, 15); 652 uint32_t Subopcode : BITFIELD_RANGE(16, 23); 653 uint32_t MediaCommandOpcode : BITFIELD_RANGE(24, 26); 654 uint32_t Pipeline : BITFIELD_RANGE(27, 28); 655 uint32_t CommandType : BITFIELD_RANGE(29, 31); 656 uint32_t PerThreadScratchSpace : BITFIELD_RANGE(0, 3); 657 uint32_t StackSize : BITFIELD_RANGE(4, 7); 658 uint32_t Reserved_40 : BITFIELD_RANGE(8, 9); 659 uint32_t ScratchSpaceBasePointer : BITFIELD_RANGE(10, 31); 660 uint32_t ScratchSpaceBasePointerHigh : BITFIELD_RANGE(0, 15); 661 uint32_t Reserved_80 : BITFIELD_RANGE(16, 31); 662 uint32_t Reserved_96 : BITFIELD_RANGE(0, 1); 663 uint32_t DispatchLoadBalance : BITFIELD_RANGE(2, 2); 664 uint32_t Reserved_99 : BITFIELD_RANGE(3, 5); 665 uint32_t DisableSlice0Subslice2 : BITFIELD_RANGE(6, 6); 666 uint32_t Reserved_103 : BITFIELD_RANGE(7, 7); 667 uint32_t NumberOfUrbEntries : BITFIELD_RANGE(8, 15); 668 uint32_t MaximumNumberOfThreads : BITFIELD_RANGE(16, 31); 669 uint32_t MaximumNumberOfDual_Subslices : BITFIELD_RANGE(0, 7); 670 uint32_t Reserved_136 : BITFIELD_RANGE(8, 31); 671 uint32_t CurbeAllocationSize : BITFIELD_RANGE(0, 15); 672 uint32_t UrbEntryAllocationSize : BITFIELD_RANGE(16, 31); 673 uint32_t Reserved_192; 674 uint32_t Reserved_224; 675 uint32_t Reserved_256; 676 } Common; 677 uint32_t RawData[9]; 678 } TheStructure; 679 typedef enum tagDWORD_LENGTH { 680 DWORD_LENGTH_DWORD_COUNT_N = 0x7, 681 } DWORD_LENGTH; 682 typedef enum tagSUBOPCODE { 683 SUBOPCODE_MEDIA_VFE_STATE_SUBOP = 0x0, 684 } SUBOPCODE; 685 typedef enum tagMEDIA_COMMAND_OPCODE { 686 MEDIA_COMMAND_OPCODE_MEDIA_VFE_STATE = 0x0, 687 } MEDIA_COMMAND_OPCODE; 688 typedef enum tagPIPELINE { 689 PIPELINE_MEDIA = 0x2, 690 } PIPELINE; 691 typedef enum tagCOMMAND_TYPE { 692 COMMAND_TYPE_GFXPIPE = 0x3, 693 } COMMAND_TYPE; 694 typedef enum tagDISPATCH_LOAD_BALANCE { 695 DISPATCH_LOAD_BALANCE_LEAST_LOADED = 0x0, 696 DISPATCH_LOAD_BALANCE_COLOR_LSB = 0x1, 697 } DISPATCH_LOAD_BALANCE; 698 typedef enum tagPATCH_CONSTANTS { 699 SCRATCHSPACEBASEPOINTER_BYTEOFFSET = 0x4, 700 SCRATCHSPACEBASEPOINTER_INDEX = 0x1, 701 SCRATCHSPACEBASEPOINTERHIGH_BYTEOFFSET = 0x8, 702 SCRATCHSPACEBASEPOINTERHIGH_INDEX = 0x2, 703 } PATCH_CONSTANTS; 704 inline void init() { 705 memset(&TheStructure, 0, sizeof(TheStructure)); 706 TheStructure.Common.DwordLength = DWORD_LENGTH_DWORD_COUNT_N; 707 TheStructure.Common.Subopcode = SUBOPCODE_MEDIA_VFE_STATE_SUBOP; 708 TheStructure.Common.MediaCommandOpcode = MEDIA_COMMAND_OPCODE_MEDIA_VFE_STATE; 709 TheStructure.Common.Pipeline = PIPELINE_MEDIA; 710 TheStructure.Common.CommandType = COMMAND_TYPE_GFXPIPE; 711 TheStructure.Common.DispatchLoadBalance = DISPATCH_LOAD_BALANCE_LEAST_LOADED; 712 } 713 static tagMEDIA_VFE_STATE sInit() { 714 MEDIA_VFE_STATE state; 715 state.init(); 716 return state; 717 } 718 inline uint32_t &getRawData(const uint32_t index) { 719 DEBUG_BREAK_IF(index >= 9); 720 return TheStructure.RawData[index]; 721 } 722 inline void setPerThreadScratchSpace(const uint32_t value) { 723 TheStructure.Common.PerThreadScratchSpace = value; 724 } 725 inline uint32_t getPerThreadScratchSpace() const { 726 return (TheStructure.Common.PerThreadScratchSpace); 727 } 728 inline void setStackSize(const uint32_t value) { 729 TheStructure.Common.StackSize = value; 730 } 731 inline uint32_t getStackSize() const { 732 return (TheStructure.Common.StackSize); 733 } 734 typedef enum tagSCRATCHSPACEBASEPOINTER { 735 SCRATCHSPACEBASEPOINTER_BIT_SHIFT = 0xa, 736 SCRATCHSPACEBASEPOINTER_ALIGN_SIZE = 0x400, 737 } SCRATCHSPACEBASEPOINTER; 738 inline void setScratchSpaceBasePointer(const uint32_t value) { 739 TheStructure.Common.ScratchSpaceBasePointer = value >> SCRATCHSPACEBASEPOINTER_BIT_SHIFT; 740 } 741 inline uint32_t getScratchSpaceBasePointer() const { 742 return (TheStructure.Common.ScratchSpaceBasePointer << SCRATCHSPACEBASEPOINTER_BIT_SHIFT); 743 } 744 inline void setScratchSpaceBasePointerHigh(const uint32_t value) { 745 TheStructure.Common.ScratchSpaceBasePointerHigh = value; 746 } 747 inline uint32_t getScratchSpaceBasePointerHigh() const { 748 return (TheStructure.Common.ScratchSpaceBasePointerHigh); 749 } 750 inline void setDispatchLoadBalance(const DISPATCH_LOAD_BALANCE value) { 751 TheStructure.Common.DispatchLoadBalance = value; 752 } 753 inline DISPATCH_LOAD_BALANCE getDispatchLoadBalance() const { 754 return static_cast<DISPATCH_LOAD_BALANCE>(TheStructure.Common.DispatchLoadBalance); 755 } 756 inline void setDisableSlice0Subslice2(const bool value) { 757 TheStructure.Common.DisableSlice0Subslice2 = value; 758 } 759 inline bool getDisableSlice0Subslice2() const { 760 return (TheStructure.Common.DisableSlice0Subslice2); 761 } 762 inline void setNumberOfUrbEntries(const uint32_t value) { 763 TheStructure.Common.NumberOfUrbEntries = value; 764 } 765 inline uint32_t getNumberOfUrbEntries() const { 766 return (TheStructure.Common.NumberOfUrbEntries); 767 } 768 inline void setMaximumNumberOfThreads(const uint32_t value) { 769 TheStructure.Common.MaximumNumberOfThreads = value - 1; 770 } 771 inline uint32_t getMaximumNumberOfThreads() const { 772 return (TheStructure.Common.MaximumNumberOfThreads + 1); 773 } 774 inline void setMaximumNumberOfDualSubslices(const uint32_t value) { 775 TheStructure.Common.MaximumNumberOfDual_Subslices = value; 776 } 777 inline uint32_t getMaximumNumberOfDualSubslices() const { 778 return (TheStructure.Common.MaximumNumberOfDual_Subslices); 779 } 780 inline void setCurbeAllocationSize(const uint32_t value) { 781 TheStructure.Common.CurbeAllocationSize = value; 782 } 783 inline uint32_t getCurbeAllocationSize() const { 784 return (TheStructure.Common.CurbeAllocationSize); 785 } 786 inline void setUrbEntryAllocationSize(const uint32_t value) { 787 TheStructure.Common.UrbEntryAllocationSize = value; 788 } 789 inline uint32_t getUrbEntryAllocationSize() const { 790 return (TheStructure.Common.UrbEntryAllocationSize); 791 } 792} MEDIA_VFE_STATE; 793STATIC_ASSERT(36 == sizeof(MEDIA_VFE_STATE)); 794 795typedef struct tagMI_ARB_CHECK { 796 union tagTheStructure { 797 struct tagCommon { 798 // DWORD 0 799 uint32_t PreParserDisable : BITFIELD_RANGE(0, 0); 800 uint32_t Reserved_1 : BITFIELD_RANGE(1, 7); 801 uint32_t MaskBits : BITFIELD_RANGE(8, 15); 802 uint32_t Reserved_16 : BITFIELD_RANGE(16, 22); 803 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 804 uint32_t CommandType : BITFIELD_RANGE(29, 31); 805 } Common; 806 uint32_t RawData[1]; 807 } TheStructure; 808 typedef enum tagMI_COMMAND_OPCODE { 809 MI_COMMAND_OPCODE_MI_ARB_CHECK = 0x5, 810 } MI_COMMAND_OPCODE; 811 typedef enum tagCOMMAND_TYPE { 812 COMMAND_TYPE_MI_COMMAND = 0x0, 813 } COMMAND_TYPE; 814 inline void init() { 815 memset(&TheStructure, 0, sizeof(TheStructure)); 816 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_ARB_CHECK; 817 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 818 } 819 static tagMI_ARB_CHECK sInit() { 820 MI_ARB_CHECK state; 821 state.init(); 822 return state; 823 } 824 inline uint32_t &getRawData(const uint32_t index) { 825 UNRECOVERABLE_IF(index >= 1); 826 return TheStructure.RawData[index]; 827 } 828 inline void setPreParserDisable(const bool value) { 829 TheStructure.Common.PreParserDisable = value; 830 } 831 inline bool getPreParserDisable() const { 832 return TheStructure.Common.PreParserDisable; 833 } 834 inline void setMaskBits(const uint32_t value) { 835 UNRECOVERABLE_IF(value > 0xff); 836 TheStructure.Common.MaskBits = value; 837 } 838 inline uint32_t getMaskBits() const { 839 return TheStructure.Common.MaskBits; 840 } 841} MI_ARB_CHECK; 842STATIC_ASSERT(4 == sizeof(MI_ARB_CHECK)); 843 844typedef struct tagMI_ATOMIC { 845 union tagTheStructure { 846 struct tagCommon { 847 // DWORD 0 848 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 849 uint32_t AtomicOpcode : BITFIELD_RANGE(8, 15); 850 uint32_t ReturnDataControl : BITFIELD_RANGE(16, 16); 851 uint32_t CsStall : BITFIELD_RANGE(17, 17); 852 uint32_t InlineData : BITFIELD_RANGE(18, 18); 853 uint32_t DataSize : BITFIELD_RANGE(19, 20); 854 uint32_t PostSyncOperation : BITFIELD_RANGE(21, 21); 855 uint32_t MemoryType : BITFIELD_RANGE(22, 22); 856 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 857 uint32_t CommandType : BITFIELD_RANGE(29, 31); 858 // DWORD 1 859 uint32_t Reserved_32 : BITFIELD_RANGE(0, 1); 860 uint32_t MemoryAddress : BITFIELD_RANGE(2, 31); 861 // DWORD 2 862 uint32_t MemoryAddressHigh : BITFIELD_RANGE(0, 15); 863 uint32_t Reserved_80 : BITFIELD_RANGE(16, 31); 864 // DWORD 3 865 uint32_t Operand1DataDword0; 866 // DWORD 4 867 uint32_t Operand2DataDword0; 868 // DWORD 5 869 uint32_t Operand1DataDword1; 870 // DWORD 6 871 uint32_t Operand2DataDword1; 872 // DWORD 7 873 uint32_t Operand1DataDword2; 874 // DWORD 8 875 uint32_t Operand2DataDword2; 876 // DWORD 9 877 uint32_t Operand1DataDword3; 878 // DWORD 10 879 uint32_t Operand2DataDword3; 880 } Common; 881 uint32_t RawData[11]; 882 } TheStructure; 883 typedef enum tagDWORD_LENGTH { 884 DWORD_LENGTH_INLINE_DATA_0 = 0x1, 885 DWORD_LENGTH_INLINE_DATA_1 = 0x9, 886 } DWORD_LENGTH; 887 typedef enum tagDATA_SIZE { 888 DATA_SIZE_DWORD = 0x0, 889 DATA_SIZE_QWORD = 0x1, 890 DATA_SIZE_OCTWORD = 0x2, 891 } DATA_SIZE; 892 typedef enum tagPOST_SYNC_OPERATION { 893 POST_SYNC_OPERATION_NO_POST_SYNC_OPERATION = 0x0, 894 POST_SYNC_OPERATION_POST_SYNC_OPERATION = 0x1, 895 } POST_SYNC_OPERATION; 896 typedef enum tagMEMORY_TYPE { 897 MEMORY_TYPE_PER_PROCESS_GRAPHICS_ADDRESS = 0x0, 898 MEMORY_TYPE_GLOBAL_GRAPHICS_ADDRESS = 0x1, 899 } MEMORY_TYPE; 900 typedef enum tagMI_COMMAND_OPCODE { 901 MI_COMMAND_OPCODE_MI_ATOMIC = 0x2f, 902 } MI_COMMAND_OPCODE; 903 typedef enum tagCOMMAND_TYPE { 904 COMMAND_TYPE_MI_COMMAND = 0x0, 905 } COMMAND_TYPE; 906 typedef enum tagATOMIC_OPCODES { 907 ATOMIC_4B_MOVE = 0x4, 908 ATOMIC_4B_INCREMENT = 0x5, 909 ATOMIC_4B_DECREMENT = 0x6, 910 ATOMIC_8B_MOVE = 0x24, 911 ATOMIC_8B_INCREMENT = 0x25, 912 ATOMIC_8B_DECREMENT = 0x26, 913 } ATOMIC_OPCODES; 914 inline void init() { 915 memset(&TheStructure, 0, sizeof(TheStructure)); 916 TheStructure.Common.DwordLength = DWORD_LENGTH_INLINE_DATA_0; 917 TheStructure.Common.DataSize = DATA_SIZE_DWORD; 918 TheStructure.Common.PostSyncOperation = POST_SYNC_OPERATION_NO_POST_SYNC_OPERATION; 919 TheStructure.Common.MemoryType = MEMORY_TYPE_PER_PROCESS_GRAPHICS_ADDRESS; 920 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_ATOMIC; 921 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 922 } 923 static tagMI_ATOMIC sInit() { 924 MI_ATOMIC state; 925 state.init(); 926 return state; 927 } 928 inline uint32_t &getRawData(const uint32_t index) { 929 UNRECOVERABLE_IF(index >= 11); 930 return TheStructure.RawData[index]; 931 } 932 inline void setDwordLength(const DWORD_LENGTH value) { 933 TheStructure.Common.DwordLength = value; 934 } 935 inline DWORD_LENGTH getDwordLength() const { 936 return static_cast<DWORD_LENGTH>(TheStructure.Common.DwordLength); 937 } 938 inline void setAtomicOpcode(const uint32_t value) { 939 UNRECOVERABLE_IF(value > 0xff); 940 TheStructure.Common.AtomicOpcode = value; 941 } 942 inline uint32_t getAtomicOpcode() const { 943 return TheStructure.Common.AtomicOpcode; 944 } 945 inline void setReturnDataControl(const bool value) { 946 TheStructure.Common.ReturnDataControl = value; 947 } 948 inline bool getReturnDataControl() const { 949 return TheStructure.Common.ReturnDataControl; 950 } 951 inline void setCsStall(const bool value) { 952 TheStructure.Common.CsStall = value; 953 } 954 inline bool getCsStall() const { 955 return TheStructure.Common.CsStall; 956 } 957 inline void setInlineData(const bool value) { 958 TheStructure.Common.InlineData = value; 959 } 960 inline bool getInlineData() const { 961 return TheStructure.Common.InlineData; 962 } 963 inline void setDataSize(const DATA_SIZE value) { 964 TheStructure.Common.DataSize = value; 965 } 966 inline DATA_SIZE getDataSize() const { 967 return static_cast<DATA_SIZE>(TheStructure.Common.DataSize); 968 } 969 inline void setPostSyncOperation(const POST_SYNC_OPERATION value) { 970 TheStructure.Common.PostSyncOperation = value; 971 } 972 inline POST_SYNC_OPERATION getPostSyncOperation() const { 973 return static_cast<POST_SYNC_OPERATION>(TheStructure.Common.PostSyncOperation); 974 } 975 inline void setMemoryType(const MEMORY_TYPE value) { 976 TheStructure.Common.MemoryType = value; 977 } 978 inline MEMORY_TYPE getMemoryType() const { 979 return static_cast<MEMORY_TYPE>(TheStructure.Common.MemoryType); 980 } 981 typedef enum tagMEMORYADDRESS { 982 MEMORYADDRESS_BIT_SHIFT = 0x2, 983 MEMORYADDRESS_ALIGN_SIZE = 0x4, 984 } MEMORYADDRESS; 985 inline void setMemoryAddress(const uint32_t value) { 986 UNRECOVERABLE_IF(value > 0xffffffff); 987 TheStructure.Common.MemoryAddress = value >> MEMORYADDRESS_BIT_SHIFT; 988 } 989 inline uint32_t getMemoryAddress() const { 990 return TheStructure.Common.MemoryAddress << MEMORYADDRESS_BIT_SHIFT; 991 } 992 inline void setMemoryAddressHigh(const uint32_t value) { 993 UNRECOVERABLE_IF(value > 0xffff); 994 TheStructure.Common.MemoryAddressHigh = value; 995 } 996 inline uint32_t getMemoryAddressHigh() const { 997 return TheStructure.Common.MemoryAddressHigh; 998 } 999 inline void setOperand1DataDword0(const uint32_t value) { 1000 TheStructure.Common.Operand1DataDword0 = value; 1001 } 1002 inline uint32_t getOperand1DataDword0() const { 1003 return TheStructure.Common.Operand1DataDword0; 1004 } 1005 inline void setOperand2DataDword0(const uint32_t value) { 1006 TheStructure.Common.Operand2DataDword0 = value; 1007 } 1008 inline uint32_t getOperand2DataDword0() const { 1009 return TheStructure.Common.Operand2DataDword0; 1010 } 1011 inline void setOperand1DataDword1(const uint32_t value) { 1012 TheStructure.Common.Operand1DataDword1 = value; 1013 } 1014 inline uint32_t getOperand1DataDword1() const { 1015 return TheStructure.Common.Operand1DataDword1; 1016 } 1017 inline void setOperand2DataDword1(const uint32_t value) { 1018 TheStructure.Common.Operand2DataDword1 = value; 1019 } 1020 inline uint32_t getOperand2DataDword1() const { 1021 return TheStructure.Common.Operand2DataDword1; 1022 } 1023 inline void setOperand1DataDword2(const uint32_t value) { 1024 TheStructure.Common.Operand1DataDword2 = value; 1025 } 1026 inline uint32_t getOperand1DataDword2() const { 1027 return TheStructure.Common.Operand1DataDword2; 1028 } 1029 inline void setOperand2DataDword2(const uint32_t value) { 1030 TheStructure.Common.Operand2DataDword2 = value; 1031 } 1032 inline uint32_t getOperand2DataDword2() const { 1033 return TheStructure.Common.Operand2DataDword2; 1034 } 1035 inline void setOperand1DataDword3(const uint32_t value) { 1036 TheStructure.Common.Operand1DataDword3 = value; 1037 } 1038 inline uint32_t getOperand1DataDword3() const { 1039 return TheStructure.Common.Operand1DataDword3; 1040 } 1041 inline void setOperand2DataDword3(const uint32_t value) { 1042 TheStructure.Common.Operand2DataDword3 = value; 1043 } 1044 inline uint32_t getOperand2DataDword3() const { 1045 return TheStructure.Common.Operand2DataDword3; 1046 } 1047} MI_ATOMIC; 1048STATIC_ASSERT(44 == sizeof(MI_ATOMIC)); 1049 1050typedef struct tagMI_BATCH_BUFFER_END { 1051 union tagTheStructure { 1052 struct tagCommon { 1053 // DWORD 0 1054 uint32_t EndContext : BITFIELD_RANGE(0, 0); 1055 uint32_t Reserved_1 : BITFIELD_RANGE(1, 22); 1056 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 1057 uint32_t CommandType : BITFIELD_RANGE(29, 31); 1058 } Common; 1059 uint32_t RawData[1]; 1060 } TheStructure; 1061 typedef enum tagMI_COMMAND_OPCODE { 1062 MI_COMMAND_OPCODE_MI_BATCH_BUFFER_END = 0xa, 1063 } MI_COMMAND_OPCODE; 1064 typedef enum tagCOMMAND_TYPE { 1065 COMMAND_TYPE_MI_COMMAND = 0x0, 1066 } COMMAND_TYPE; 1067 inline void init() { 1068 memset(&TheStructure, 0, sizeof(TheStructure)); 1069 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_BATCH_BUFFER_END; 1070 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 1071 } 1072 static tagMI_BATCH_BUFFER_END sInit() { 1073 MI_BATCH_BUFFER_END state; 1074 state.init(); 1075 return state; 1076 } 1077 inline uint32_t &getRawData(const uint32_t index) { 1078 UNRECOVERABLE_IF(index >= 1); 1079 return TheStructure.RawData[index]; 1080 } 1081 inline void setEndContext(const bool value) { 1082 TheStructure.Common.EndContext = value; 1083 } 1084 inline bool getEndContext() const { 1085 return TheStructure.Common.EndContext; 1086 } 1087} MI_BATCH_BUFFER_END; 1088STATIC_ASSERT(4 == sizeof(MI_BATCH_BUFFER_END)); 1089 1090typedef struct tagMI_BATCH_BUFFER_START { 1091 union tagTheStructure { 1092 struct tagCommon { 1093 // DWORD 0 1094 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 1095 uint32_t AddressSpaceIndicator : BITFIELD_RANGE(8, 8); 1096 uint32_t Reserved_9 : BITFIELD_RANGE(9, 14); 1097 uint32_t PredicationEnable : BITFIELD_RANGE(15, 15); 1098 uint32_t Reserved_16 : BITFIELD_RANGE(16, 18); 1099 uint32_t EnableCommandCache : BITFIELD_RANGE(19, 19); 1100 uint32_t PoshEnable : BITFIELD_RANGE(20, 20); 1101 uint32_t PoshStart : BITFIELD_RANGE(21, 21); 1102 uint32_t Reserved_22 : BITFIELD_RANGE(22, 22); 1103 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 1104 uint32_t CommandType : BITFIELD_RANGE(29, 31); 1105 // DWORD 1 1106 uint64_t Reserved_32 : BITFIELD_RANGE(0, 1); 1107 uint64_t BatchBufferStartAddress : BITFIELD_RANGE(2, 63); 1108 } Common; 1109 struct tagMi_Mode_Nestedbatchbufferenableis0 { 1110 // DWORD 0 1111 uint32_t Reserved_0 : BITFIELD_RANGE(0, 21); 1112 uint32_t SecondLevelBatchBuffer : BITFIELD_RANGE(22, 22); 1113 uint32_t Reserved_23 : BITFIELD_RANGE(23, 31); 1114 // DWORD 1 1115 uint64_t Reserved_32; 1116 } Mi_Mode_Nestedbatchbufferenableis0; 1117 struct tagMi_Mode_Nestedbatchbufferenableis1 { 1118 // DWORD 0 1119 uint32_t Reserved_0 : BITFIELD_RANGE(0, 21); 1120 uint32_t NestedLevelBatchBuffer : BITFIELD_RANGE(22, 22); 1121 uint32_t Reserved_23 : BITFIELD_RANGE(23, 31); 1122 // DWORD 1 1123 uint64_t Reserved_32; 1124 } Mi_Mode_Nestedbatchbufferenableis1; 1125 uint32_t RawData[3]; 1126 } TheStructure; 1127 typedef enum tagDWORD_LENGTH { 1128 DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x1, 1129 } DWORD_LENGTH; 1130 typedef enum tagADDRESS_SPACE_INDICATOR { 1131 ADDRESS_SPACE_INDICATOR_GGTT = 0x0, 1132 ADDRESS_SPACE_INDICATOR_PPGTT = 0x1, 1133 } ADDRESS_SPACE_INDICATOR; 1134 typedef enum tagNESTED_LEVEL_BATCH_BUFFER { 1135 NESTED_LEVEL_BATCH_BUFFER_CHAIN = 0x0, 1136 NESTED_LEVEL_BATCH_BUFFER_NESTED = 0x1, 1137 } NESTED_LEVEL_BATCH_BUFFER; 1138 typedef enum tagSECOND_LEVEL_BATCH_BUFFER { 1139 SECOND_LEVEL_BATCH_BUFFER_FIRST_LEVEL_BATCH = 0x0, 1140 SECOND_LEVEL_BATCH_BUFFER_SECOND_LEVEL_BATCH = 0x1, 1141 } SECOND_LEVEL_BATCH_BUFFER; 1142 typedef enum tagMI_COMMAND_OPCODE { 1143 MI_COMMAND_OPCODE_MI_BATCH_BUFFER_START = 0x31, 1144 } MI_COMMAND_OPCODE; 1145 typedef enum tagCOMMAND_TYPE { 1146 COMMAND_TYPE_MI_COMMAND = 0x0, 1147 } COMMAND_TYPE; 1148 inline void init() { 1149 memset(&TheStructure, 0, sizeof(TheStructure)); 1150 TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1; 1151 TheStructure.Common.AddressSpaceIndicator = ADDRESS_SPACE_INDICATOR_GGTT; 1152 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_BATCH_BUFFER_START; 1153 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 1154 TheStructure.Mi_Mode_Nestedbatchbufferenableis0.SecondLevelBatchBuffer = SECOND_LEVEL_BATCH_BUFFER_FIRST_LEVEL_BATCH; 1155 TheStructure.Mi_Mode_Nestedbatchbufferenableis1.NestedLevelBatchBuffer = NESTED_LEVEL_BATCH_BUFFER_CHAIN; 1156 } 1157 static tagMI_BATCH_BUFFER_START sInit() { 1158 MI_BATCH_BUFFER_START state; 1159 state.init(); 1160 return state; 1161 } 1162 inline uint32_t &getRawData(const uint32_t index) { 1163 UNRECOVERABLE_IF(index >= 3); 1164 return TheStructure.RawData[index]; 1165 } 1166 inline void setAddressSpaceIndicator(const ADDRESS_SPACE_INDICATOR value) { 1167 TheStructure.Common.AddressSpaceIndicator = value; 1168 } 1169 inline ADDRESS_SPACE_INDICATOR getAddressSpaceIndicator() const { 1170 return static_cast<ADDRESS_SPACE_INDICATOR>(TheStructure.Common.AddressSpaceIndicator); 1171 } 1172 inline void setPredicationEnable(const bool value) { 1173 TheStructure.Common.PredicationEnable = value; 1174 } 1175 inline bool getPredicationEnable() const { 1176 return TheStructure.Common.PredicationEnable; 1177 } 1178 inline void setEnableCommandCache(const bool value) { 1179 TheStructure.Common.EnableCommandCache = value; 1180 } 1181 inline bool getEnableCommandCache() const { 1182 return TheStructure.Common.EnableCommandCache; 1183 } 1184 inline void setPoshEnable(const bool value) { 1185 TheStructure.Common.PoshEnable = value; 1186 } 1187 inline bool getPoshEnable() const { 1188 return TheStructure.Common.PoshEnable; 1189 } 1190 inline void setPoshStart(const bool value) { 1191 TheStructure.Common.PoshStart = value; 1192 } 1193 inline bool getPoshStart() const { 1194 return TheStructure.Common.PoshStart; 1195 } 1196 typedef enum tagBATCHBUFFERSTARTADDRESS { 1197 BATCHBUFFERSTARTADDRESS_BIT_SHIFT = 0x2, 1198 BATCHBUFFERSTARTADDRESS_ALIGN_SIZE = 0x4, 1199 } BATCHBUFFERSTARTADDRESS; 1200 inline void setBatchBufferStartAddress(const uint64_t value) { 1201 TheStructure.Common.BatchBufferStartAddress = value >> BATCHBUFFERSTARTADDRESS_BIT_SHIFT; 1202 } 1203 inline uint64_t getBatchBufferStartAddress() const { 1204 return TheStructure.Common.BatchBufferStartAddress << BATCHBUFFERSTARTADDRESS_BIT_SHIFT; 1205 } 1206 inline void setSecondLevelBatchBuffer(const SECOND_LEVEL_BATCH_BUFFER value) { 1207 TheStructure.Mi_Mode_Nestedbatchbufferenableis0.SecondLevelBatchBuffer = value; 1208 } 1209 inline SECOND_LEVEL_BATCH_BUFFER getSecondLevelBatchBuffer() const { 1210 return static_cast<SECOND_LEVEL_BATCH_BUFFER>(TheStructure.Mi_Mode_Nestedbatchbufferenableis0.SecondLevelBatchBuffer); 1211 } 1212 inline void setNestedLevelBatchBuffer(const NESTED_LEVEL_BATCH_BUFFER value) { 1213 TheStructure.Mi_Mode_Nestedbatchbufferenableis1.NestedLevelBatchBuffer = value; 1214 } 1215 inline NESTED_LEVEL_BATCH_BUFFER getNestedLevelBatchBuffer() const { 1216 return static_cast<NESTED_LEVEL_BATCH_BUFFER>(TheStructure.Mi_Mode_Nestedbatchbufferenableis1.NestedLevelBatchBuffer); 1217 } 1218} MI_BATCH_BUFFER_START; 1219STATIC_ASSERT(12 == sizeof(MI_BATCH_BUFFER_START)); 1220 1221typedef struct tagMI_LOAD_REGISTER_IMM { 1222 union tagTheStructure { 1223 struct tagCommon { 1224 // DWORD 0 1225 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 1226 uint32_t ByteWriteDisables : BITFIELD_RANGE(8, 11); 1227 uint32_t Reserved_12 : BITFIELD_RANGE(12, 16); 1228 uint32_t MmioRemapEnable : BITFIELD_RANGE(17, 17); 1229 uint32_t Reserved_18 : BITFIELD_RANGE(18, 18); 1230 uint32_t AddCsMmioStartOffset : BITFIELD_RANGE(19, 19); 1231 uint32_t Reserved_20 : BITFIELD_RANGE(20, 22); 1232 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 1233 uint32_t CommandType : BITFIELD_RANGE(29, 31); 1234 // DWORD 1 1235 uint64_t Reserved_32 : BITFIELD_RANGE(0, 1); 1236 uint64_t RegisterOffset : BITFIELD_RANGE(2, 22); 1237 uint64_t Reserved_55 : BITFIELD_RANGE(23, 31); 1238 // DWORD 2 1239 uint64_t DataDword : BITFIELD_RANGE(32, 63); 1240 } Common; 1241 uint32_t RawData[3]; 1242 } TheStructure; 1243 typedef enum tagDWORD_LENGTH { 1244 DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x1, 1245 } DWORD_LENGTH; 1246 typedef enum tagMI_COMMAND_OPCODE { 1247 MI_COMMAND_OPCODE_MI_LOAD_REGISTER_IMM = 0x22, 1248 } MI_COMMAND_OPCODE; 1249 typedef enum tagCOMMAND_TYPE { 1250 COMMAND_TYPE_MI_COMMAND = 0x0, 1251 } COMMAND_TYPE; 1252 inline void init() { 1253 memset(&TheStructure, 0, sizeof(TheStructure)); 1254 TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1; 1255 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_LOAD_REGISTER_IMM; 1256 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 1257 TheStructure.Common.MmioRemapEnable = true; // this field is manually set 1258 } 1259 static tagMI_LOAD_REGISTER_IMM sInit() { 1260 MI_LOAD_REGISTER_IMM state; 1261 state.init(); 1262 return state; 1263 } 1264 inline uint32_t &getRawData(const uint32_t index) { 1265 UNRECOVERABLE_IF(index >= 3); 1266 return TheStructure.RawData[index]; 1267 } 1268 inline void setByteWriteDisables(const uint32_t value) { 1269 UNRECOVERABLE_IF(value > 0xf); 1270 TheStructure.Common.ByteWriteDisables = value; 1271 } 1272 inline uint32_t getByteWriteDisables() const { 1273 return TheStructure.Common.ByteWriteDisables; 1274 } 1275 inline void setMmioRemapEnable(const bool value) { 1276 TheStructure.Common.MmioRemapEnable = value; 1277 } 1278 inline bool getMmioRemapEnable() const { 1279 return TheStructure.Common.MmioRemapEnable; 1280 } 1281 inline void setAddCsMmioStartOffset(const bool value) { 1282 TheStructure.Common.AddCsMmioStartOffset = value; 1283 } 1284 inline bool getAddCsMmioStartOffset() const { 1285 return TheStructure.Common.AddCsMmioStartOffset; 1286 } 1287 typedef enum tagREGISTEROFFSET { 1288 REGISTEROFFSET_BIT_SHIFT = 0x2, 1289 REGISTEROFFSET_ALIGN_SIZE = 0x4, 1290 } REGISTEROFFSET; 1291 inline void setRegisterOffset(const uint64_t value) { 1292 UNRECOVERABLE_IF(value > 0x7fffffL); 1293 TheStructure.Common.RegisterOffset = value >> REGISTEROFFSET_BIT_SHIFT; 1294 } 1295 inline uint64_t getRegisterOffset() const { 1296 return TheStructure.Common.RegisterOffset << REGISTEROFFSET_BIT_SHIFT; 1297 } 1298 inline void setDataDword(const uint64_t value) { 1299 TheStructure.Common.DataDword = value; 1300 } 1301 inline uint64_t getDataDword() const { 1302 return TheStructure.Common.DataDword; 1303 } 1304} MI_LOAD_REGISTER_IMM; 1305STATIC_ASSERT(12 == sizeof(MI_LOAD_REGISTER_IMM)); 1306 1307typedef struct tagMI_LOAD_REGISTER_MEM { 1308 union tagTheStructure { 1309 struct tagCommon { 1310 // DWORD 0 1311 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 1312 uint32_t Reserved_8 : BITFIELD_RANGE(8, 16); 1313 uint32_t MmioRemapEnable : BITFIELD_RANGE(17, 17); 1314 uint32_t Reserved_18 : BITFIELD_RANGE(18, 18); 1315 uint32_t AddCsMmioStartOffset : BITFIELD_RANGE(19, 19); 1316 uint32_t Reserved_20 : BITFIELD_RANGE(20, 20); 1317 uint32_t AsyncModeEnable : BITFIELD_RANGE(21, 21); 1318 uint32_t UseGlobalGtt : BITFIELD_RANGE(22, 22); 1319 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 1320 uint32_t CommandType : BITFIELD_RANGE(29, 31); 1321 // DWORD 1 1322 uint32_t Reserved_32 : BITFIELD_RANGE(0, 1); 1323 uint32_t RegisterAddress : BITFIELD_RANGE(2, 22); 1324 uint32_t Reserved_55 : BITFIELD_RANGE(23, 31); 1325 // DWORD 2 1326 uint64_t Reserved_64 : BITFIELD_RANGE(0, 1); 1327 uint64_t MemoryAddress : BITFIELD_RANGE(2, 63); 1328 } Common; 1329 uint32_t RawData[4]; 1330 } TheStructure; 1331 typedef enum tagDWORD_LENGTH { 1332 DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x2, 1333 } DWORD_LENGTH; 1334 typedef enum tagMI_COMMAND_OPCODE { 1335 MI_COMMAND_OPCODE_MI_LOAD_REGISTER_MEM = 0x29, 1336 } MI_COMMAND_OPCODE; 1337 typedef enum tagCOMMAND_TYPE { 1338 COMMAND_TYPE_MI_COMMAND = 0x0, 1339 } COMMAND_TYPE; 1340 inline void init() { 1341 memset(&TheStructure, 0, sizeof(TheStructure)); 1342 TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1; 1343 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_LOAD_REGISTER_MEM; 1344 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 1345 } 1346 static tagMI_LOAD_REGISTER_MEM sInit() { 1347 MI_LOAD_REGISTER_MEM state; 1348 state.init(); 1349 return state; 1350 } 1351 inline uint32_t &getRawData(const uint32_t index) { 1352 UNRECOVERABLE_IF(index >= 4); 1353 return TheStructure.RawData[index]; 1354 } 1355 inline void setMmioRemapEnable(const bool value) { 1356 TheStructure.Common.MmioRemapEnable = value; 1357 } 1358 inline bool getMmioRemapEnable() const { 1359 return TheStructure.Common.MmioRemapEnable; 1360 } 1361 inline void setAddCsMmioStartOffset(const bool value) { 1362 TheStructure.Common.AddCsMmioStartOffset = value; 1363 } 1364 inline bool getAddCsMmioStartOffset() const { 1365 return TheStructure.Common.AddCsMmioStartOffset; 1366 } 1367 inline void setAsyncModeEnable(const bool value) { 1368 TheStructure.Common.AsyncModeEnable = value; 1369 } 1370 inline bool getAsyncModeEnable() const { 1371 return TheStructure.Common.AsyncModeEnable; 1372 } 1373 inline void setUseGlobalGtt(const bool value) { 1374 TheStructure.Common.UseGlobalGtt = value; 1375 } 1376 inline bool getUseGlobalGtt() const { 1377 return TheStructure.Common.UseGlobalGtt; 1378 } 1379 typedef enum tagREGISTERADDRESS { 1380 REGISTERADDRESS_BIT_SHIFT = 0x2, 1381 REGISTERADDRESS_ALIGN_SIZE = 0x4, 1382 } REGISTERADDRESS; 1383 inline void setRegisterAddress(const uint32_t value) { 1384 UNRECOVERABLE_IF(value > 0x7fffff); 1385 TheStructure.Common.RegisterAddress = value >> REGISTERADDRESS_BIT_SHIFT; 1386 } 1387 inline uint32_t getRegisterAddress() const { 1388 return TheStructure.Common.RegisterAddress << REGISTERADDRESS_BIT_SHIFT; 1389 } 1390 typedef enum tagMEMORYADDRESS { 1391 MEMORYADDRESS_BIT_SHIFT = 0x2, 1392 MEMORYADDRESS_ALIGN_SIZE = 0x4, 1393 } MEMORYADDRESS; 1394 inline void setMemoryAddress(const uint64_t value) { 1395 UNRECOVERABLE_IF(value > 0xffffffffffffffffL); 1396 TheStructure.Common.MemoryAddress = value >> MEMORYADDRESS_BIT_SHIFT; 1397 } 1398 inline uint64_t getMemoryAddress() const { 1399 return TheStructure.Common.MemoryAddress << MEMORYADDRESS_BIT_SHIFT; 1400 } 1401} MI_LOAD_REGISTER_MEM; 1402STATIC_ASSERT(16 == sizeof(MI_LOAD_REGISTER_MEM)); 1403 1404typedef struct tagMI_LOAD_REGISTER_REG { 1405 union tagTheStructure { 1406 struct tagCommon { 1407 // DWORD 0 1408 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 1409 uint32_t Reserved_8 : BITFIELD_RANGE(8, 15); 1410 uint32_t MmioRemapEnableSource : BITFIELD_RANGE(16, 16); 1411 uint32_t MmioRemapEnableDestination : BITFIELD_RANGE(17, 17); 1412 uint32_t AddCsMmioStartOffsetSource : BITFIELD_RANGE(18, 18); 1413 uint32_t AddCsMmioStartOffsetDestination : BITFIELD_RANGE(19, 19); 1414 uint32_t Reserved_20 : BITFIELD_RANGE(20, 22); 1415 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 1416 uint32_t CommandType : BITFIELD_RANGE(29, 31); 1417 // DWORD 1 1418 uint32_t Reserved_32 : BITFIELD_RANGE(0, 1); 1419 uint32_t SourceRegisterAddress : BITFIELD_RANGE(2, 22); 1420 uint32_t Reserved_55 : BITFIELD_RANGE(23, 31); 1421 // DWORD 2 1422 uint32_t Reserved_64 : BITFIELD_RANGE(0, 1); 1423 uint32_t DestinationRegisterAddress : BITFIELD_RANGE(2, 22); 1424 uint32_t Reserved_87 : BITFIELD_RANGE(23, 31); 1425 } Common; 1426 uint32_t RawData[3]; 1427 } TheStructure; 1428 typedef enum tagDWORD_LENGTH { 1429 DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x1, 1430 } DWORD_LENGTH; 1431 typedef enum tagMI_COMMAND_OPCODE { 1432 MI_COMMAND_OPCODE_MI_LOAD_REGISTER_REG = 0x2a, 1433 } MI_COMMAND_OPCODE; 1434 typedef enum tagCOMMAND_TYPE { 1435 COMMAND_TYPE_MI_COMMAND = 0x0, 1436 } COMMAND_TYPE; 1437 inline void init() { 1438 memset(&TheStructure, 0, sizeof(TheStructure)); 1439 TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1; 1440 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_LOAD_REGISTER_REG; 1441 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 1442 } 1443 static tagMI_LOAD_REGISTER_REG sInit() { 1444 MI_LOAD_REGISTER_REG state; 1445 state.init(); 1446 return state; 1447 } 1448 inline uint32_t &getRawData(const uint32_t index) { 1449 UNRECOVERABLE_IF(index >= 3); 1450 return TheStructure.RawData[index]; 1451 } 1452 inline void setMmioRemapEnableSource(const bool value) { 1453 TheStructure.Common.MmioRemapEnableSource = value; 1454 } 1455 inline bool getMmioRemapEnableSource() const { 1456 return TheStructure.Common.MmioRemapEnableSource; 1457 } 1458 inline void setMmioRemapEnableDestination(const bool value) { 1459 TheStructure.Common.MmioRemapEnableDestination = value; 1460 } 1461 inline bool getMmioRemapEnableDestination() const { 1462 return TheStructure.Common.MmioRemapEnableDestination; 1463 } 1464 inline void setAddCsMmioStartOffsetSource(const bool value) { 1465 TheStructure.Common.AddCsMmioStartOffsetSource = value; 1466 } 1467 inline bool getAddCsMmioStartOffsetSource() const { 1468 return TheStructure.Common.AddCsMmioStartOffsetSource; 1469 } 1470 inline void setAddCsMmioStartOffsetDestination(const bool value) { 1471 TheStructure.Common.AddCsMmioStartOffsetDestination = value; 1472 } 1473 inline bool getAddCsMmioStartOffsetDestination() const { 1474 return TheStructure.Common.AddCsMmioStartOffsetDestination; 1475 } 1476 typedef enum tagSOURCEREGISTERADDRESS { 1477 SOURCEREGISTERADDRESS_BIT_SHIFT = 0x2, 1478 SOURCEREGISTERADDRESS_ALIGN_SIZE = 0x4, 1479 } SOURCEREGISTERADDRESS; 1480 inline void setSourceRegisterAddress(const uint32_t value) { 1481 UNRECOVERABLE_IF(value > 0x7fffff); 1482 TheStructure.Common.SourceRegisterAddress = value >> SOURCEREGISTERADDRESS_BIT_SHIFT; 1483 } 1484 inline uint32_t getSourceRegisterAddress() const { 1485 return TheStructure.Common.SourceRegisterAddress << SOURCEREGISTERADDRESS_BIT_SHIFT; 1486 } 1487 typedef enum tagDESTINATIONREGISTERADDRESS { 1488 DESTINATIONREGISTERADDRESS_BIT_SHIFT = 0x2, 1489 DESTINATIONREGISTERADDRESS_ALIGN_SIZE = 0x4, 1490 } DESTINATIONREGISTERADDRESS; 1491 inline void setDestinationRegisterAddress(const uint32_t value) { 1492 UNRECOVERABLE_IF(value > 0x7fffff); 1493 TheStructure.Common.DestinationRegisterAddress = value >> DESTINATIONREGISTERADDRESS_BIT_SHIFT; 1494 } 1495 inline uint32_t getDestinationRegisterAddress() const { 1496 return TheStructure.Common.DestinationRegisterAddress << DESTINATIONREGISTERADDRESS_BIT_SHIFT; 1497 } 1498} MI_LOAD_REGISTER_REG; 1499STATIC_ASSERT(12 == sizeof(MI_LOAD_REGISTER_REG)); 1500 1501typedef struct tagMI_NOOP { 1502 union tagTheStructure { 1503 struct tagCommon { 1504 // DWORD 0 1505 uint32_t IdentificationNumber : BITFIELD_RANGE(0, 21); 1506 uint32_t IdentificationNumberRegisterWriteEnable : BITFIELD_RANGE(22, 22); 1507 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 1508 uint32_t CommandType : BITFIELD_RANGE(29, 31); 1509 } Common; 1510 uint32_t RawData[1]; 1511 } TheStructure; 1512 typedef enum tagMI_COMMAND_OPCODE { 1513 MI_COMMAND_OPCODE_MI_NOOP = 0x0, 1514 } MI_COMMAND_OPCODE; 1515 typedef enum tagCOMMAND_TYPE { 1516 COMMAND_TYPE_MI_COMMAND = 0x0, 1517 } COMMAND_TYPE; 1518 inline void init() { 1519 memset(&TheStructure, 0, sizeof(TheStructure)); 1520 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_NOOP; 1521 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 1522 } 1523 static tagMI_NOOP sInit() { 1524 MI_NOOP state; 1525 state.init(); 1526 return state; 1527 } 1528 inline uint32_t &getRawData(const uint32_t index) { 1529 UNRECOVERABLE_IF(index >= 1); 1530 return TheStructure.RawData[index]; 1531 } 1532 inline void setIdentificationNumber(const uint32_t value) { 1533 UNRECOVERABLE_IF(value > 0x3fffff); 1534 TheStructure.Common.IdentificationNumber = value; 1535 } 1536 inline uint32_t getIdentificationNumber() const { 1537 return TheStructure.Common.IdentificationNumber; 1538 } 1539 inline void setIdentificationNumberRegisterWriteEnable(const bool value) { 1540 TheStructure.Common.IdentificationNumberRegisterWriteEnable = value; 1541 } 1542 inline bool getIdentificationNumberRegisterWriteEnable() const { 1543 return TheStructure.Common.IdentificationNumberRegisterWriteEnable; 1544 } 1545} MI_NOOP; 1546STATIC_ASSERT(4 == sizeof(MI_NOOP)); 1547 1548typedef struct tagMI_STORE_REGISTER_MEM { 1549 union tagTheStructure { 1550 struct tagCommon { 1551 // DWORD 0 1552 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 1553 uint32_t Reserved_8 : BITFIELD_RANGE(8, 16); 1554 uint32_t MmioRemapEnable : BITFIELD_RANGE(17, 17); 1555 uint32_t Reserved_18 : BITFIELD_RANGE(18, 18); 1556 uint32_t AddCsMmioStartOffset : BITFIELD_RANGE(19, 19); 1557 uint32_t Reserved_20 : BITFIELD_RANGE(20, 20); 1558 uint32_t PredicateEnable : BITFIELD_RANGE(21, 21); 1559 uint32_t UseGlobalGtt : BITFIELD_RANGE(22, 22); 1560 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 1561 uint32_t CommandType : BITFIELD_RANGE(29, 31); 1562 // DWORD 1 1563 uint32_t Reserved_32 : BITFIELD_RANGE(0, 1); 1564 uint32_t RegisterAddress : BITFIELD_RANGE(2, 22); 1565 uint32_t Reserved_55 : BITFIELD_RANGE(23, 31); 1566 // DWORD 2 1567 uint64_t Reserved_64 : BITFIELD_RANGE(0, 1); 1568 uint64_t MemoryAddress : BITFIELD_RANGE(2, 63); 1569 } Common; 1570 uint32_t RawData[4]; 1571 } TheStructure; 1572 typedef enum tagDWORD_LENGTH { 1573 DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x2, 1574 } DWORD_LENGTH; 1575 typedef enum tagMI_COMMAND_OPCODE { 1576 MI_COMMAND_OPCODE_MI_STORE_REGISTER_MEM = 0x24, 1577 } MI_COMMAND_OPCODE; 1578 typedef enum tagCOMMAND_TYPE { 1579 COMMAND_TYPE_MI_COMMAND = 0x0, 1580 } COMMAND_TYPE; 1581 inline void init() { 1582 memset(&TheStructure, 0, sizeof(TheStructure)); 1583 TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1; 1584 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_STORE_REGISTER_MEM; 1585 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 1586 } 1587 static tagMI_STORE_REGISTER_MEM sInit() { 1588 MI_STORE_REGISTER_MEM state; 1589 state.init(); 1590 return state; 1591 } 1592 inline uint32_t &getRawData(const uint32_t index) { 1593 UNRECOVERABLE_IF(index >= 4); 1594 return TheStructure.RawData[index]; 1595 } 1596 inline void setMmioRemapEnable(const bool value) { 1597 TheStructure.Common.MmioRemapEnable = value; 1598 } 1599 inline bool getMmioRemapEnable() const { 1600 return TheStructure.Common.MmioRemapEnable; 1601 } 1602 inline void setAddCsMmioStartOffset(const bool value) { 1603 TheStructure.Common.AddCsMmioStartOffset = value; 1604 } 1605 inline bool getAddCsMmioStartOffset() const { 1606 return TheStructure.Common.AddCsMmioStartOffset; 1607 } 1608 inline void setPredicateEnable(const bool value) { 1609 TheStructure.Common.PredicateEnable = value; 1610 } 1611 inline bool getPredicateEnable() const { 1612 return TheStructure.Common.PredicateEnable; 1613 } 1614 inline void setUseGlobalGtt(const bool value) { 1615 TheStructure.Common.UseGlobalGtt = value; 1616 } 1617 inline bool getUseGlobalGtt() const { 1618 return TheStructure.Common.UseGlobalGtt; 1619 } 1620 typedef enum tagREGISTERADDRESS { 1621 REGISTERADDRESS_BIT_SHIFT = 0x2, 1622 REGISTERADDRESS_ALIGN_SIZE = 0x4, 1623 } REGISTERADDRESS; 1624 inline void setRegisterAddress(const uint32_t value) { 1625 UNRECOVERABLE_IF(value > 0x7fffff); 1626 TheStructure.Common.RegisterAddress = value >> REGISTERADDRESS_BIT_SHIFT; 1627 } 1628 inline uint32_t getRegisterAddress() const { 1629 return TheStructure.Common.RegisterAddress << REGISTERADDRESS_BIT_SHIFT; 1630 } 1631 typedef enum tagMEMORYADDRESS { 1632 MEMORYADDRESS_BIT_SHIFT = 0x2, 1633 MEMORYADDRESS_ALIGN_SIZE = 0x4, 1634 } MEMORYADDRESS; 1635 inline void setMemoryAddress(const uint64_t value) { 1636 UNRECOVERABLE_IF(value > 0xffffffffffffffffL); 1637 TheStructure.Common.MemoryAddress = value >> MEMORYADDRESS_BIT_SHIFT; 1638 } 1639 inline uint64_t getMemoryAddress() const { 1640 return TheStructure.Common.MemoryAddress << MEMORYADDRESS_BIT_SHIFT; 1641 } 1642} MI_STORE_REGISTER_MEM; 1643STATIC_ASSERT(16 == sizeof(MI_STORE_REGISTER_MEM)); 1644 1645typedef struct tagPIPELINE_SELECT { 1646 union tagTheStructure { 1647 struct tagCommon { 1648 // DWORD 0 1649 uint32_t PipelineSelection : BITFIELD_RANGE(0, 1); 1650 uint32_t RenderSliceCommonPowerGateEnable : BITFIELD_RANGE(2, 2); 1651 uint32_t RenderSamplerPowerGateEnable : BITFIELD_RANGE(3, 3); 1652 uint32_t MediaSamplerDopClockGateEnable : BITFIELD_RANGE(4, 4); 1653 uint32_t Reserved_5 : BITFIELD_RANGE(5, 5); 1654 uint32_t MediaSamplerPowerClockGateDisable : BITFIELD_RANGE(6, 6); 1655 uint32_t SpecialModeEnable : BITFIELD_RANGE(7, 7); // ADL-only, patched 1656 uint32_t MaskBits : BITFIELD_RANGE(8, 15); 1657 uint32_t _3DCommandSubOpcode : BITFIELD_RANGE(16, 23); 1658 uint32_t _3DCommandOpcode : BITFIELD_RANGE(24, 26); 1659 uint32_t CommandSubtype : BITFIELD_RANGE(27, 28); 1660 uint32_t CommandType : BITFIELD_RANGE(29, 31); 1661 } Common; 1662 uint32_t RawData[1]; 1663 } TheStructure; 1664 typedef enum tagPIPELINE_SELECTION { 1665 PIPELINE_SELECTION_3D = 0x0, 1666 PIPELINE_SELECTION_MEDIA = 0x1, 1667 PIPELINE_SELECTION_GPGPU = 0x2, 1668 } PIPELINE_SELECTION; 1669 typedef enum tag_3D_COMMAND_SUB_OPCODE { 1670 _3D_COMMAND_SUB_OPCODE_PIPELINE_SELECT = 0x4, 1671 } _3D_COMMAND_SUB_OPCODE; 1672 typedef enum tag_3D_COMMAND_OPCODE { 1673 _3D_COMMAND_OPCODE_GFXPIPE_NONPIPELINED = 0x1, 1674 } _3D_COMMAND_OPCODE; 1675 typedef enum tagCOMMAND_SUBTYPE { 1676 COMMAND_SUBTYPE_GFXPIPE_SINGLE_DW = 0x1, 1677 } COMMAND_SUBTYPE; 1678 typedef enum tagCOMMAND_TYPE { 1679 COMMAND_TYPE_GFXPIPE = 0x3, 1680 } COMMAND_TYPE; 1681 inline void init() { 1682 memset(&TheStructure, 0, sizeof(TheStructure)); 1683 TheStructure.Common.PipelineSelection = PIPELINE_SELECTION_3D; 1684 TheStructure.Common._3DCommandSubOpcode = _3D_COMMAND_SUB_OPCODE_PIPELINE_SELECT; 1685 TheStructure.Common._3DCommandOpcode = _3D_COMMAND_OPCODE_GFXPIPE_NONPIPELINED; 1686 TheStructure.Common.CommandSubtype = COMMAND_SUBTYPE_GFXPIPE_SINGLE_DW; 1687 TheStructure.Common.CommandType = COMMAND_TYPE_GFXPIPE; 1688 } 1689 static tagPIPELINE_SELECT sInit() { 1690 PIPELINE_SELECT state; 1691 state.init(); 1692 return state; 1693 } 1694 inline uint32_t &getRawData(const uint32_t index) { 1695 UNRECOVERABLE_IF(index >= 1); 1696 return TheStructure.RawData[index]; 1697 } 1698 inline void setPipelineSelection(const PIPELINE_SELECTION value) { 1699 TheStructure.Common.PipelineSelection = value; 1700 } 1701 inline PIPELINE_SELECTION getPipelineSelection() const { 1702 return static_cast<PIPELINE_SELECTION>(TheStructure.Common.PipelineSelection); 1703 } 1704 inline void setRenderSliceCommonPowerGateEnable(const bool value) { 1705 TheStructure.Common.RenderSliceCommonPowerGateEnable = value; 1706 } 1707 inline bool getRenderSliceCommonPowerGateEnable() const { 1708 return TheStructure.Common.RenderSliceCommonPowerGateEnable; 1709 } 1710 inline void setRenderSamplerPowerGateEnable(const bool value) { 1711 TheStructure.Common.RenderSamplerPowerGateEnable = value; 1712 } 1713 inline bool getRenderSamplerPowerGateEnable() const { 1714 return TheStructure.Common.RenderSamplerPowerGateEnable; 1715 } 1716 inline void setMediaSamplerDopClockGateEnable(const bool value) { 1717 TheStructure.Common.MediaSamplerDopClockGateEnable = value; 1718 } 1719 inline bool getMediaSamplerDopClockGateEnable() const { 1720 return TheStructure.Common.MediaSamplerDopClockGateEnable; 1721 } 1722 inline void setMediaSamplerPowerClockGateDisable(const bool value) { 1723 TheStructure.Common.MediaSamplerPowerClockGateDisable = value; 1724 } 1725 inline bool getMediaSamplerPowerClockGateDisable() const { 1726 return TheStructure.Common.MediaSamplerPowerClockGateDisable; 1727 } 1728 inline void setSpecialModeEnable(const bool value) { 1729 TheStructure.Common.SpecialModeEnable = value; 1730 } 1731 inline bool getSpecialModeEnable() const { 1732 return TheStructure.Common.SpecialModeEnable; 1733 } 1734 inline void setMaskBits(const uint32_t value) { 1735 UNRECOVERABLE_IF(value > 0xff); 1736 TheStructure.Common.MaskBits = value; 1737 } 1738 inline uint32_t getMaskBits() const { 1739 return TheStructure.Common.MaskBits; 1740 } 1741} PIPELINE_SELECT; 1742STATIC_ASSERT(4 == sizeof(PIPELINE_SELECT)); 1743 1744typedef struct tagRENDER_SURFACE_STATE { 1745 union tagTheStructure { 1746 struct tagCommon { 1747 // DWORD 0 1748 uint32_t CubeFaceEnablePositiveZ : BITFIELD_RANGE(0, 0); 1749 uint32_t CubeFaceEnableNegativeZ : BITFIELD_RANGE(1, 1); 1750 uint32_t CubeFaceEnablePositiveY : BITFIELD_RANGE(2, 2); 1751 uint32_t CubeFaceEnableNegativeY : BITFIELD_RANGE(3, 3); 1752 uint32_t CubeFaceEnablePositiveX : BITFIELD_RANGE(4, 4); 1753 uint32_t CubeFaceEnableNegativeX : BITFIELD_RANGE(5, 5); 1754 uint32_t MediaBoundaryPixelMode : BITFIELD_RANGE(6, 7); 1755 uint32_t RenderCacheReadWriteMode : BITFIELD_RANGE(8, 8); 1756 uint32_t SamplerL2OutOfOrderModeDisable : BITFIELD_RANGE(9, 9); 1757 uint32_t VerticalLineStrideOffset : BITFIELD_RANGE(10, 10); 1758 uint32_t VerticalLineStride : BITFIELD_RANGE(11, 11); 1759 uint32_t TileMode : BITFIELD_RANGE(12, 13); 1760 uint32_t SurfaceHorizontalAlignment : BITFIELD_RANGE(14, 15); 1761 uint32_t SurfaceVerticalAlignment : BITFIELD_RANGE(16, 17); 1762 uint32_t SurfaceFormat : BITFIELD_RANGE(18, 26); 1763 uint32_t AstcEnable : BITFIELD_RANGE(27, 27); 1764 uint32_t SurfaceArray : BITFIELD_RANGE(28, 28); 1765 uint32_t SurfaceType : BITFIELD_RANGE(29, 31); 1766 // DWORD 1 1767 uint32_t SurfaceQpitch : BITFIELD_RANGE(0, 14); 1768 uint32_t SampleTapDiscardDisable : BITFIELD_RANGE(15, 15); 1769 uint32_t Reserved_48 : BITFIELD_RANGE(16, 16); 1770 uint32_t DoubleFetchDisable : BITFIELD_RANGE(17, 17); 1771 uint32_t CornerTexelMode : BITFIELD_RANGE(18, 18); 1772 uint32_t BaseMipLevel : BITFIELD_RANGE(19, 23); 1773 uint32_t MemoryObjectControlStateReserved_56 : BITFIELD_RANGE(24, 24); 1774 uint32_t MemoryObjectControlStateIndexToMocsTables : BITFIELD_RANGE(25, 30); 1775 uint32_t EnableUnormPathInColorPipe : BITFIELD_RANGE(31, 31); 1776 // DWORD 2 1777 uint32_t Width : BITFIELD_RANGE(0, 13); 1778 uint32_t Reserved_78 : BITFIELD_RANGE(14, 15); 1779 uint32_t Height : BITFIELD_RANGE(16, 29); 1780 uint32_t Reserved_94 : BITFIELD_RANGE(30, 30); 1781 uint32_t DepthStencilResource : BITFIELD_RANGE(31, 31); 1782 // DWORD 3 1783 uint32_t SurfacePitch : BITFIELD_RANGE(0, 17); 1784 uint32_t NullProbingEnable : BITFIELD_RANGE(18, 18); 1785 uint32_t StandardTilingModeExtensions : BITFIELD_RANGE(19, 19); 1786 uint32_t TileAddressMappingMode : BITFIELD_RANGE(20, 20); 1787 uint32_t Depth : BITFIELD_RANGE(21, 31); 1788 // DWORD 4 1789 uint32_t MultisamplePositionPaletteIndex : BITFIELD_RANGE(0, 2); 1790 uint32_t NumberOfMultisamples : BITFIELD_RANGE(3, 5); 1791 uint32_t MultisampledSurfaceStorageFormat : BITFIELD_RANGE(6, 6); 1792 uint32_t RenderTargetViewExtent : BITFIELD_RANGE(7, 17); 1793 uint32_t MinimumArrayElement : BITFIELD_RANGE(18, 28); 1794 uint32_t RenderTargetAndSampleUnormRotation : BITFIELD_RANGE(29, 30); 1795 uint32_t Reserved_159 : BITFIELD_RANGE(31, 31); 1796 // DWORD 5 1797 uint32_t MipCountLod : BITFIELD_RANGE(0, 3); 1798 uint32_t SurfaceMinLod : BITFIELD_RANGE(4, 7); 1799 uint32_t MipTailStartLod : BITFIELD_RANGE(8, 11); 1800 uint32_t Reserved_172 : BITFIELD_RANGE(12, 13); 1801 uint32_t CoherencyType : BITFIELD_RANGE(14, 14); 1802 uint32_t Reserved_175 : BITFIELD_RANGE(15, 17); 1803 uint32_t TiledResourceMode : BITFIELD_RANGE(18, 19); 1804 uint32_t EwaDisableForCube : BITFIELD_RANGE(20, 20); 1805 uint32_t YOffset : BITFIELD_RANGE(21, 23); 1806 uint32_t Reserved_184 : BITFIELD_RANGE(24, 24); 1807 uint32_t XOffset : BITFIELD_RANGE(25, 31); 1808 // DWORD 6 1809 uint32_t Reserved_192 : BITFIELD_RANGE(0, 14); 1810 uint32_t YuvInterpolationEnable : BITFIELD_RANGE(15, 15); 1811 uint32_t Reserved_208 : BITFIELD_RANGE(16, 31); 1812 // DWORD 7 1813 uint32_t ResourceMinLod : BITFIELD_RANGE(0, 11); 1814 uint32_t Reserved_236 : BITFIELD_RANGE(12, 15); 1815 uint32_t ShaderChannelSelectAlpha : BITFIELD_RANGE(16, 18); 1816 uint32_t ShaderChannelSelectBlue : BITFIELD_RANGE(19, 21); 1817 uint32_t ShaderChannelSelectGreen : BITFIELD_RANGE(22, 24); 1818 uint32_t ShaderChannelSelectRed : BITFIELD_RANGE(25, 27); 1819 uint32_t Reserved_252 : BITFIELD_RANGE(28, 29); 1820 uint32_t MemoryCompressionEnable : BITFIELD_RANGE(30, 30); 1821 uint32_t MemoryCompressionMode : BITFIELD_RANGE(31, 31); 1822 // DWORD 8-9 1823 uint64_t SurfaceBaseAddress; 1824 // DWORD 10-11 1825 uint64_t QuiltWidth : BITFIELD_RANGE(0, 4); 1826 uint64_t QuiltHeight : BITFIELD_RANGE(5, 9); 1827 uint64_t ClearValueAddressEnable : BITFIELD_RANGE(10, 10); 1828 uint64_t ProceduralTexture : BITFIELD_RANGE(11, 11); 1829 uint64_t Reserved_332 : BITFIELD_RANGE(12, 63); 1830 // DWORD 12 1831 uint32_t Reserved_384 : BITFIELD_RANGE(0, 5); 1832 uint32_t ClearAddressLow : BITFIELD_RANGE(6, 31); 1833 // DWORD 13 1834 uint32_t ClearAddressHigh : BITFIELD_RANGE(0, 15); 1835 uint32_t Reserved_432 : BITFIELD_RANGE(16, 31); 1836 // DWORD 14 1837 uint32_t Reserved_448; 1838 // DWORD 15 1839 uint32_t Reserved_480; 1840 } Common; 1841 struct tag_SurfaceFormatIsPlanar { 1842 // DWORD 0 1843 uint32_t Reserved_0; 1844 // DWORD 1 1845 uint32_t Reserved_32; 1846 // DWORD 2 1847 uint32_t Reserved_64; 1848 // DWORD 3 1849 uint32_t Reserved_96; 1850 // DWORD 4 1851 uint32_t Reserved_128; 1852 // DWORD 5 1853 uint32_t Reserved_160; 1854 // DWORD 6 1855 uint32_t YOffsetForUOrUvPlane : BITFIELD_RANGE(0, 13); 1856 uint32_t Reserved_206 : BITFIELD_RANGE(14, 15); 1857 uint32_t XOffsetForUOrUvPlane : BITFIELD_RANGE(16, 29); 1858 uint32_t HalfPitchForChroma : BITFIELD_RANGE(30, 30); 1859 uint32_t SeparateUvPlaneEnable : BITFIELD_RANGE(31, 31); 1860 // DWORD 7 1861 uint32_t Reserved_224; 1862 // DWORD 8-9 1863 uint64_t Reserved_256; 1864 // DWORD 10 1865 uint64_t Reserved_320 : BITFIELD_RANGE(0, 11); 1866 uint64_t Reserved_332 : BITFIELD_RANGE(12, 31); 1867 // DWORD 11 1868 uint64_t YOffsetForVPlane : BITFIELD_RANGE(32, 45); 1869 uint64_t Reserved_366 : BITFIELD_RANGE(46, 47); 1870 uint64_t XOffsetForVPlane : BITFIELD_RANGE(48, 61); 1871 uint64_t Reserved_382 : BITFIELD_RANGE(62, 63); 1872 // DWORD 12 1873 uint32_t Reserved_384; 1874 // DWORD 13 1875 uint32_t Reserved_416; 1876 // DWORD 14 1877 uint32_t Reserved_448; 1878 // DWORD 15 1879 uint32_t Reserved_480; 1880 } _SurfaceFormatIsPlanar; 1881 struct tag_SurfaceFormatIsnotPlanar { 1882 // DWORD 0 1883 uint32_t Reserved_0; 1884 // DWORD 1 1885 uint32_t Reserved_32; 1886 // DWORD 2 1887 uint32_t Reserved_64; 1888 // DWORD 3 1889 uint32_t Reserved_96; 1890 // DWORD 4 1891 uint32_t Reserved_128; 1892 // DWORD 5 1893 uint32_t Reserved_160; 1894 // DWORD 6 1895 uint32_t AuxiliarySurfaceMode : BITFIELD_RANGE(0, 2); 1896 uint32_t AuxiliarySurfacePitch : BITFIELD_RANGE(3, 11); 1897 uint32_t Reserved_204 : BITFIELD_RANGE(12, 13); 1898 uint32_t Reserved_206 : BITFIELD_RANGE(14, 15); 1899 uint32_t AuxiliarySurfaceQpitch : BITFIELD_RANGE(16, 30); 1900 uint32_t Reserved_223 : BITFIELD_RANGE(31, 31); 1901 // DWORD 7 1902 uint32_t Reserved_224; 1903 // DWORD 8-9 1904 uint64_t Reserved_256; 1905 // DWORD 10-11 1906 uint64_t Reserved_320; 1907 // DWORD 12 1908 uint32_t Reserved_384; 1909 // DWORD 13 1910 uint32_t Reserved_416; 1911 // DWORD 14 1912 uint32_t Reserved_448; 1913 // DWORD 15 1914 uint32_t Reserved_480; 1915 } _SurfaceFormatIsnotPlanar; 1916 struct tag_SurfaceFormatIsnotPlanarAndMemoryCompressionEnableIs0 { 1917 // DWORD 0 1918 uint32_t Reserved_0; 1919 // DWORD 1 1920 uint32_t Reserved_32; 1921 // DWORD 2 1922 uint32_t Reserved_64; 1923 // DWORD 3 1924 uint32_t Reserved_96; 1925 // DWORD 4 1926 uint32_t Reserved_128; 1927 // DWORD 5 1928 uint32_t Reserved_160; 1929 // DWORD 6 1930 uint32_t Reserved_192; 1931 // DWORD 7 1932 uint32_t Reserved_224; 1933 // DWORD 8-9 1934 uint64_t Reserved_256; 1935 // DWORD 10-11 1936 uint64_t Reserved_320 : BITFIELD_RANGE(0, 11); 1937 uint64_t AuxiliarySurfaceBaseAddress : BITFIELD_RANGE(12, 63); 1938 // DWORD 12 1939 uint32_t Reserved_384; 1940 // DWORD 13 1941 uint32_t Reserved_416; 1942 // DWORD 14 1943 uint32_t Reserved_448; 1944 // DWORD 15 1945 uint32_t Reserved_480; 1946 } _SurfaceFormatIsnotPlanarAndMemoryCompressionEnableIs0; 1947 uint32_t RawData[16]; 1948 } TheStructure; 1949 typedef enum tagMEDIA_BOUNDARY_PIXEL_MODE { 1950 MEDIA_BOUNDARY_PIXEL_MODE_NORMAL_MODE = 0x0, 1951 MEDIA_BOUNDARY_PIXEL_MODE_PROGRESSIVE_FRAME = 0x2, 1952 MEDIA_BOUNDARY_PIXEL_MODE_INTERLACED_FRAME = 0x3, 1953 } MEDIA_BOUNDARY_PIXEL_MODE; 1954 typedef enum tagRENDER_CACHE_READ_WRITE_MODE { 1955 RENDER_CACHE_READ_WRITE_MODE_WRITE_ONLY_CACHE = 0x0, 1956 RENDER_CACHE_READ_WRITE_MODE_READ_WRITE_CACHE = 0x1, 1957 } RENDER_CACHE_READ_WRITE_MODE; 1958 typedef enum tagTILE_MODE { 1959 TILE_MODE_LINEAR = 0x0, 1960 TILE_MODE_XMAJOR = 0x2, 1961 TILE_MODE_YMAJOR = 0x3, 1962 } TILE_MODE; 1963 typedef enum tagSURFACE_HORIZONTAL_ALIGNMENT { 1964 SURFACE_HORIZONTAL_ALIGNMENT_HALIGN_4 = 0x1, 1965 SURFACE_HORIZONTAL_ALIGNMENT_HALIGN_8 = 0x2, 1966 SURFACE_HORIZONTAL_ALIGNMENT_HALIGN_16 = 0x3, 1967 } SURFACE_HORIZONTAL_ALIGNMENT; 1968 typedef enum tagSURFACE_VERTICAL_ALIGNMENT { 1969 SURFACE_VERTICAL_ALIGNMENT_VALIGN_4 = 0x1, 1970 SURFACE_VERTICAL_ALIGNMENT_VALIGN_8 = 0x2, 1971 SURFACE_VERTICAL_ALIGNMENT_VALIGN_16 = 0x3, 1972 } SURFACE_VERTICAL_ALIGNMENT; 1973 typedef enum tagSURFACE_FORMAT { 1974 SURFACE_FORMAT_R32G32B32A32_FLOAT = 0x0, 1975 SURFACE_FORMAT_R32G32B32A32_SINT = 0x1, 1976 SURFACE_FORMAT_R32G32B32A32_UINT = 0x2, 1977 SURFACE_FORMAT_R32G32B32A32_UNORM = 0x3, 1978 SURFACE_FORMAT_R32G32B32A32_SNORM = 0x4, 1979 SURFACE_FORMAT_R64G64_FLOAT = 0x5, 1980 SURFACE_FORMAT_R32G32B32X32_FLOAT = 0x6, 1981 SURFACE_FORMAT_R32G32B32A32_SSCALED = 0x7, 1982 SURFACE_FORMAT_R32G32B32A32_USCALED = 0x8, 1983 SURFACE_FORMAT_R32G32B32A32_SFIXED = 0x20, 1984 SURFACE_FORMAT_R64G64_PASSTHRU = 0x21, 1985 SURFACE_FORMAT_R32G32B32_FLOAT = 0x40, 1986 SURFACE_FORMAT_R32G32B32_SINT = 0x41, 1987 SURFACE_FORMAT_R32G32B32_UINT = 0x42, 1988 SURFACE_FORMAT_R32G32B32_UNORM = 0x43, 1989 SURFACE_FORMAT_R32G32B32_SNORM = 0x44, 1990 SURFACE_FORMAT_R32G32B32_SSCALED = 0x45, 1991 SURFACE_FORMAT_R32G32B32_USCALED = 0x46, 1992 SURFACE_FORMAT_R32G32B32_SFIXED = 0x50, 1993 SURFACE_FORMAT_R16G16B16A16_UNORM = 0x80, 1994 SURFACE_FORMAT_R16G16B16A16_SNORM = 0x81, 1995 SURFACE_FORMAT_R16G16B16A16_SINT = 0x82, 1996 SURFACE_FORMAT_R16G16B16A16_UINT = 0x83, 1997 SURFACE_FORMAT_R16G16B16A16_FLOAT = 0x84, 1998 SURFACE_FORMAT_R32G32_FLOAT = 0x85, 1999 SURFACE_FORMAT_R32G32_SINT = 0x86, 2000 SURFACE_FORMAT_R32G32_UINT = 0x87, 2001 SURFACE_FORMAT_R32_FLOAT_X8X24_TYPELESS = 0x88, 2002 SURFACE_FORMAT_X32_TYPELESS_G8X24_UINT = 0x89, 2003 SURFACE_FORMAT_L32A32_FLOAT = 0x8a, 2004 SURFACE_FORMAT_R32G32_UNORM = 0x8b, 2005 SURFACE_FORMAT_R32G32_SNORM = 0x8c, 2006 SURFACE_FORMAT_R64_FLOAT = 0x8d, 2007 SURFACE_FORMAT_R16G16B16X16_UNORM = 0x8e, 2008 SURFACE_FORMAT_R16G16B16X16_FLOAT = 0x8f, 2009 SURFACE_FORMAT_A32X32_FLOAT = 0x90, 2010 SURFACE_FORMAT_L32X32_FLOAT = 0x91, 2011 SURFACE_FORMAT_I32X32_FLOAT = 0x92, 2012 SURFACE_FORMAT_R16G16B16A16_SSCALED = 0x93, 2013 SURFACE_FORMAT_R16G16B16A16_USCALED = 0x94, 2014 SURFACE_FORMAT_R32G32_SSCALED = 0x95, 2015 SURFACE_FORMAT_R32G32_USCALED = 0x96, 2016 SURFACE_FORMAT_R32G32_SFIXED = 0xa0, 2017 SURFACE_FORMAT_R64_PASSTHRU = 0xa1, 2018 SURFACE_FORMAT_B8G8R8A8_UNORM = 0xc0, 2019 SURFACE_FORMAT_B8G8R8A8_UNORM_SRGB = 0xc1, 2020 SURFACE_FORMAT_R10G10B10A2_UNORM = 0xc2, 2021 SURFACE_FORMAT_R10G10B10A2_UNORM_SRGB = 0xc3, 2022 SURFACE_FORMAT_R10G10B10A2_UINT = 0xc4, 2023 SURFACE_FORMAT_R10G10B10_SNORM_A2_UNORM = 0xc5, 2024 SURFACE_FORMAT_R8G8B8A8_UNORM = 0xc7, 2025 SURFACE_FORMAT_R8G8B8A8_UNORM_SRGB = 0xc8, 2026 SURFACE_FORMAT_R8G8B8A8_SNORM = 0xc9, 2027 SURFACE_FORMAT_R8G8B8A8_SINT = 0xca, 2028 SURFACE_FORMAT_R8G8B8A8_UINT = 0xcb, 2029 SURFACE_FORMAT_R16G16_UNORM = 0xcc, 2030 SURFACE_FORMAT_R16G16_SNORM = 0xcd, 2031 SURFACE_FORMAT_R16G16_SINT = 0xce, 2032 SURFACE_FORMAT_R16G16_UINT = 0xcf, 2033 SURFACE_FORMAT_R16G16_FLOAT = 0xd0, 2034 SURFACE_FORMAT_B10G10R10A2_UNORM = 0xd1, 2035 SURFACE_FORMAT_B10G10R10A2_UNORM_SRGB = 0xd2, 2036 SURFACE_FORMAT_R11G11B10_FLOAT = 0xd3, 2037 SURFACE_FORMAT_R10G10B10_FLOAT_A2_UNORM = 0xd5, 2038 SURFACE_FORMAT_R32_SINT = 0xd6, 2039 SURFACE_FORMAT_R32_UINT = 0xd7, 2040 SURFACE_FORMAT_R32_FLOAT = 0xd8, 2041 SURFACE_FORMAT_R24_UNORM_X8_TYPELESS = 0xd9, 2042 SURFACE_FORMAT_X24_TYPELESS_G8_UINT = 0xda, 2043 SURFACE_FORMAT_L32_UNORM = 0xdd, 2044 SURFACE_FORMAT_A32_UNORM = 0xde, 2045 SURFACE_FORMAT_L16A16_UNORM = 0xdf, 2046 SURFACE_FORMAT_I24X8_UNORM = 0xe0, 2047 SURFACE_FORMAT_L24X8_UNORM = 0xe1, 2048 SURFACE_FORMAT_A24X8_UNORM = 0xe2, 2049 SURFACE_FORMAT_I32_FLOAT = 0xe3, 2050 SURFACE_FORMAT_L32_FLOAT = 0xe4, 2051 SURFACE_FORMAT_A32_FLOAT = 0xe5, 2052 SURFACE_FORMAT_X8B8_UNORM_G8R8_SNORM = 0xe6, 2053 SURFACE_FORMAT_A8X8_UNORM_G8R8_SNORM = 0xe7, 2054 SURFACE_FORMAT_B8X8_UNORM_G8R8_SNORM = 0xe8, 2055 SURFACE_FORMAT_B8G8R8X8_UNORM = 0xe9, 2056 SURFACE_FORMAT_B8G8R8X8_UNORM_SRGB = 0xea, 2057 SURFACE_FORMAT_R8G8B8X8_UNORM = 0xeb, 2058 SURFACE_FORMAT_R8G8B8X8_UNORM_SRGB = 0xec, 2059 SURFACE_FORMAT_R9G9B9E5_SHAREDEXP = 0xed, 2060 SURFACE_FORMAT_B10G10R10X2_UNORM = 0xee, 2061 SURFACE_FORMAT_L16A16_FLOAT = 0xf0, 2062 SURFACE_FORMAT_R32_UNORM = 0xf1, 2063 SURFACE_FORMAT_R32_SNORM = 0xf2, 2064 SURFACE_FORMAT_R10G10B10X2_USCALED = 0xf3, 2065 SURFACE_FORMAT_R8G8B8A8_SSCALED = 0xf4, 2066 SURFACE_FORMAT_R8G8B8A8_USCALED = 0xf5, 2067 SURFACE_FORMAT_R16G16_SSCALED = 0xf6, 2068 SURFACE_FORMAT_R16G16_USCALED = 0xf7, 2069 SURFACE_FORMAT_R32_SSCALED = 0xf8, 2070 SURFACE_FORMAT_R32_USCALED = 0xf9, 2071 SURFACE_FORMAT_B5G6R5_UNORM = 0x100, 2072 SURFACE_FORMAT_B5G6R5_UNORM_SRGB = 0x101, 2073 SURFACE_FORMAT_B5G5R5A1_UNORM = 0x102, 2074 SURFACE_FORMAT_B5G5R5A1_UNORM_SRGB = 0x103, 2075 SURFACE_FORMAT_B4G4R4A4_UNORM = 0x104, 2076 SURFACE_FORMAT_B4G4R4A4_UNORM_SRGB = 0x105, 2077 SURFACE_FORMAT_R8G8_UNORM = 0x106, 2078 SURFACE_FORMAT_R8G8_SNORM = 0x107, 2079 SURFACE_FORMAT_R8G8_SINT = 0x108, 2080 SURFACE_FORMAT_R8G8_UINT = 0x109, 2081 SURFACE_FORMAT_R16_UNORM = 0x10a, 2082 SURFACE_FORMAT_R16_SNORM = 0x10b, 2083 SURFACE_FORMAT_R16_SINT = 0x10c, 2084 SURFACE_FORMAT_R16_UINT = 0x10d, 2085 SURFACE_FORMAT_R16_FLOAT = 0x10e, 2086 SURFACE_FORMAT_A8P8_UNORM_PALETTE0 = 0x10f, 2087 SURFACE_FORMAT_A8P8_UNORM_PALETTE1 = 0x110, 2088 SURFACE_FORMAT_I16_UNORM = 0x111, 2089 SURFACE_FORMAT_L16_UNORM = 0x112, 2090 SURFACE_FORMAT_A16_UNORM = 0x113, 2091 SURFACE_FORMAT_L8A8_UNORM = 0x114, 2092 SURFACE_FORMAT_I16_FLOAT = 0x115, 2093 SURFACE_FORMAT_L16_FLOAT = 0x116, 2094 SURFACE_FORMAT_A16_FLOAT = 0x117, 2095 SURFACE_FORMAT_L8A8_UNORM_SRGB = 0x118, 2096 SURFACE_FORMAT_R5G5_SNORM_B6_UNORM = 0x119, 2097 SURFACE_FORMAT_B5G5R5X1_UNORM = 0x11a, 2098 SURFACE_FORMAT_B5G5R5X1_UNORM_SRGB = 0x11b, 2099 SURFACE_FORMAT_R8G8_SSCALED = 0x11c, 2100 SURFACE_FORMAT_R8G8_USCALED = 0x11d, 2101 SURFACE_FORMAT_R16_SSCALED = 0x11e, 2102 SURFACE_FORMAT_R16_USCALED = 0x11f, 2103 SURFACE_FORMAT_P8A8_UNORM_PALETTE0 = 0x122, 2104 SURFACE_FORMAT_P8A8_UNORM_PALETTE1 = 0x123, 2105 SURFACE_FORMAT_A1B5G5R5_UNORM = 0x124, 2106 SURFACE_FORMAT_A4B4G4R4_UNORM = 0x125, 2107 SURFACE_FORMAT_L8A8_UINT = 0x126, 2108 SURFACE_FORMAT_L8A8_SINT = 0x127, 2109 SURFACE_FORMAT_R8_UNORM = 0x140, 2110 SURFACE_FORMAT_R8_SNORM = 0x141, 2111 SURFACE_FORMAT_R8_SINT = 0x142, 2112 SURFACE_FORMAT_R8_UINT = 0x143, 2113 SURFACE_FORMAT_A8_UNORM = 0x144, 2114 SURFACE_FORMAT_I8_UNORM = 0x145, 2115 SURFACE_FORMAT_L8_UNORM = 0x146, 2116 SURFACE_FORMAT_P4A4_UNORM_PALETTE0 = 0x147, 2117 SURFACE_FORMAT_A4P4_UNORM_PALETTE0 = 0x148, 2118 SURFACE_FORMAT_R8_SSCALED = 0x149, 2119 SURFACE_FORMAT_R8_USCALED = 0x14a, 2120 SURFACE_FORMAT_P8_UNORM_PALETTE0 = 0x14b, 2121 SURFACE_FORMAT_L8_UNORM_SRGB = 0x14c, 2122 SURFACE_FORMAT_P8_UNORM_PALETTE1 = 0x14d, 2123 SURFACE_FORMAT_P4A4_UNORM_PALETTE1 = 0x14e, 2124 SURFACE_FORMAT_A4P4_UNORM_PALETTE1 = 0x14f, 2125 SURFACE_FORMAT_Y8_UNORM = 0x150, 2126 SURFACE_FORMAT_L8_UINT = 0x152, 2127 SURFACE_FORMAT_L8_SINT = 0x153, 2128 SURFACE_FORMAT_I8_UINT = 0x154, 2129 SURFACE_FORMAT_I8_SINT = 0x155, 2130 SURFACE_FORMAT_DXT1_RGB_SRGB = 0x180, 2131 SURFACE_FORMAT_R1_UNORM = 0x181, 2132 SURFACE_FORMAT_YCRCB_NORMAL = 0x182, 2133 SURFACE_FORMAT_YCRCB_SWAPUVY = 0x183, 2134 SURFACE_FORMAT_P2_UNORM_PALETTE0 = 0x184, 2135 SURFACE_FORMAT_P2_UNORM_PALETTE1 = 0x185, 2136 SURFACE_FORMAT_BC1_UNORM = 0x186, 2137 SURFACE_FORMAT_BC2_UNORM = 0x187, 2138 SURFACE_FORMAT_BC3_UNORM = 0x188, 2139 SURFACE_FORMAT_BC4_UNORM = 0x189, 2140 SURFACE_FORMAT_BC5_UNORM = 0x18a, 2141 SURFACE_FORMAT_BC1_UNORM_SRGB = 0x18b, 2142 SURFACE_FORMAT_BC2_UNORM_SRGB = 0x18c, 2143 SURFACE_FORMAT_BC3_UNORM_SRGB = 0x18d, 2144 SURFACE_FORMAT_MONO8 = 0x18e, 2145 SURFACE_FORMAT_YCRCB_SWAPUV = 0x18f, 2146 SURFACE_FORMAT_YCRCB_SWAPY = 0x190, 2147 SURFACE_FORMAT_DXT1_RGB = 0x191, 2148 SURFACE_FORMAT_R8G8B8_UNORM = 0x193, 2149 SURFACE_FORMAT_R8G8B8_SNORM = 0x194, 2150 SURFACE_FORMAT_R8G8B8_SSCALED = 0x195, 2151 SURFACE_FORMAT_R8G8B8_USCALED = 0x196, 2152 SURFACE_FORMAT_R64G64B64A64_FLOAT = 0x197, 2153 SURFACE_FORMAT_R64G64B64_FLOAT = 0x198, 2154 SURFACE_FORMAT_BC4_SNORM = 0x199, 2155 SURFACE_FORMAT_BC5_SNORM = 0x19a, 2156 SURFACE_FORMAT_R16G16B16_FLOAT = 0x19b, 2157 SURFACE_FORMAT_R16G16B16_UNORM = 0x19c, 2158 SURFACE_FORMAT_R16G16B16_SNORM = 0x19d, 2159 SURFACE_FORMAT_R16G16B16_SSCALED = 0x19e, 2160 SURFACE_FORMAT_R16G16B16_USCALED = 0x19f, 2161 SURFACE_FORMAT_BC6H_SF16 = 0x1a1, 2162 SURFACE_FORMAT_BC7_UNORM = 0x1a2, 2163 SURFACE_FORMAT_BC7_UNORM_SRGB = 0x1a3, 2164 SURFACE_FORMAT_BC6H_UF16 = 0x1a4, 2165 SURFACE_FORMAT_PLANAR_420_8 = 0x1a5, 2166 SURFACE_FORMAT_PLANAR_420_16 = 0x1a6, 2167 SURFACE_FORMAT_R8G8B8_UNORM_SRGB = 0x1a8, 2168 SURFACE_FORMAT_ETC1_RGB8 = 0x1a9, 2169 SURFACE_FORMAT_ETC2_RGB8 = 0x1aa, 2170 SURFACE_FORMAT_EAC_R11 = 0x1ab, 2171 SURFACE_FORMAT_EAC_RG11 = 0x1ac, 2172 SURFACE_FORMAT_EAC_SIGNED_R11 = 0x1ad, 2173 SURFACE_FORMAT_EAC_SIGNED_RG11 = 0x1ae, 2174 SURFACE_FORMAT_ETC2_SRGB8 = 0x1af, 2175 SURFACE_FORMAT_R16G16B16_UINT = 0x1b0, 2176 SURFACE_FORMAT_R16G16B16_SINT = 0x1b1, 2177 SURFACE_FORMAT_R32_SFIXED = 0x1b2, 2178 SURFACE_FORMAT_R10G10B10A2_SNORM = 0x1b3, 2179 SURFACE_FORMAT_R10G10B10A2_USCALED = 0x1b4, 2180 SURFACE_FORMAT_R10G10B10A2_SSCALED = 0x1b5, 2181 SURFACE_FORMAT_R10G10B10A2_SINT = 0x1b6, 2182 SURFACE_FORMAT_B10G10R10A2_SNORM = 0x1b7, 2183 SURFACE_FORMAT_B10G10R10A2_USCALED = 0x1b8, 2184 SURFACE_FORMAT_B10G10R10A2_SSCALED = 0x1b9, 2185 SURFACE_FORMAT_B10G10R10A2_UINT = 0x1ba, 2186 SURFACE_FORMAT_B10G10R10A2_SINT = 0x1bb, 2187 SURFACE_FORMAT_R64G64B64A64_PASSTHRU = 0x1bc, 2188 SURFACE_FORMAT_R64G64B64_PASSTHRU = 0x1bd, 2189 SURFACE_FORMAT_ETC2_RGB8_PTA = 0x1c0, 2190 SURFACE_FORMAT_ETC2_SRGB8_PTA = 0x1c1, 2191 SURFACE_FORMAT_ETC2_EAC_RGBA8 = 0x1c2, 2192 SURFACE_FORMAT_ETC2_EAC_SRGB8_A8 = 0x1c3, 2193 SURFACE_FORMAT_R8G8B8_UINT = 0x1c8, 2194 SURFACE_FORMAT_R8G8B8_SINT = 0x1c9, 2195 SURFACE_FORMAT_RAW = 0x1ff, 2196 } SURFACE_FORMAT; 2197 typedef enum tagSURFACE_TYPE { 2198 SURFACE_TYPE_SURFTYPE_1D = 0x0, 2199 SURFACE_TYPE_SURFTYPE_2D = 0x1, 2200 SURFACE_TYPE_SURFTYPE_3D = 0x2, 2201 SURFACE_TYPE_SURFTYPE_CUBE = 0x3, 2202 SURFACE_TYPE_SURFTYPE_BUFFER = 0x4, 2203 SURFACE_TYPE_SURFTYPE_NULL = 0x7, 2204 } SURFACE_TYPE; 2205 typedef enum tagSAMPLE_TAP_DISCARD_DISABLE { 2206 SAMPLE_TAP_DISCARD_DISABLE_DISABLE = 0x0, 2207 SAMPLE_TAP_DISCARD_DISABLE_ENABLE = 0x1, 2208 } SAMPLE_TAP_DISCARD_DISABLE; 2209 typedef enum tagNULL_PROBING_ENABLE { 2210 NULL_PROBING_ENABLE_DISABLE = 0x0, 2211 NULL_PROBING_ENABLE_ENABLE = 0x1, 2212 } NULL_PROBING_ENABLE; 2213 typedef enum tagSTANDARD_TILING_MODE_EXTENSIONS { 2214 STANDARD_TILING_MODE_EXTENSIONS_DISABLE = 0x0, 2215 STANDARD_TILING_MODE_EXTENSIONS_ENABLE = 0x1, 2216 } STANDARD_TILING_MODE_EXTENSIONS; 2217 typedef enum tagTILE_ADDRESS_MAPPING_MODE { 2218 TILE_ADDRESS_MAPPING_MODE_GEN9 = 0x0, 2219 TILE_ADDRESS_MAPPING_MODE_GEN10 = 0x1, 2220 } TILE_ADDRESS_MAPPING_MODE; 2221 typedef enum tagNUMBER_OF_MULTISAMPLES { 2222 NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_1 = 0x0, 2223 NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_2 = 0x1, 2224 NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_4 = 0x2, 2225 NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_8 = 0x3, 2226 NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_16 = 0x4, 2227 } NUMBER_OF_MULTISAMPLES; 2228 typedef enum tagMULTISAMPLED_SURFACE_STORAGE_FORMAT { 2229 MULTISAMPLED_SURFACE_STORAGE_FORMAT_MSS = 0x0, 2230 MULTISAMPLED_SURFACE_STORAGE_FORMAT_DEPTH_STENCIL = 0x1, 2231 } MULTISAMPLED_SURFACE_STORAGE_FORMAT; 2232 typedef enum tagRENDER_TARGET_AND_SAMPLE_UNORM_ROTATION { 2233 RENDER_TARGET_AND_SAMPLE_UNORM_ROTATION_0DEG = 0x0, 2234 RENDER_TARGET_AND_SAMPLE_UNORM_ROTATION_90DEG = 0x1, 2235 RENDER_TARGET_AND_SAMPLE_UNORM_ROTATION_180DEG = 0x2, 2236 RENDER_TARGET_AND_SAMPLE_UNORM_ROTATION_270DEG = 0x3, 2237 } RENDER_TARGET_AND_SAMPLE_UNORM_ROTATION; 2238 typedef enum tagCOHERENCY_TYPE { 2239 COHERENCY_TYPE_GPU_COHERENT = 0x0, 2240 COHERENCY_TYPE_IA_COHERENT = 0x1, 2241 } COHERENCY_TYPE; 2242 typedef enum tagTILED_RESOURCE_MODE { 2243 TILED_RESOURCE_MODE_NONE = 0x0, 2244 TILED_RESOURCE_MODE_4KB = 0x1, 2245 TILED_RESOURCE_MODE_TILEYF = 0x1, 2246 TILED_RESOURCE_MODE_64KB = 0x2, 2247 TILED_RESOURCE_MODE_TILEYS = 0x2, 2248 } TILED_RESOURCE_MODE; 2249 typedef enum tagAUXILIARY_SURFACE_MODE { 2250 AUXILIARY_SURFACE_MODE_AUX_NONE = 0x0, 2251 AUXILIARY_SURFACE_MODE_AUX_CCS_D = 0x1, 2252 AUXILIARY_SURFACE_MODE_AUX_APPEND = 0x2, 2253 AUXILIARY_SURFACE_MODE_AUX_MCS_LCE = 0x4, 2254 AUXILIARY_SURFACE_MODE_AUX_CCS_E = 0x5, 2255 } AUXILIARY_SURFACE_MODE; 2256 typedef enum tagHALF_PITCH_FOR_CHROMA { 2257 HALF_PITCH_FOR_CHROMA_DISABLE = 0x0, 2258 HALF_PITCH_FOR_CHROMA_ENABLE = 0x1, 2259 } HALF_PITCH_FOR_CHROMA; 2260 typedef enum tagSHADER_CHANNEL_SELECT { 2261 SHADER_CHANNEL_SELECT_ZERO = 0x0, 2262 SHADER_CHANNEL_SELECT_ONE = 0x1, 2263 SHADER_CHANNEL_SELECT_RED = 0x4, 2264 SHADER_CHANNEL_SELECT_GREEN = 0x5, 2265 SHADER_CHANNEL_SELECT_BLUE = 0x6, 2266 SHADER_CHANNEL_SELECT_ALPHA = 0x7, 2267 } SHADER_CHANNEL_SELECT; 2268 typedef enum tagMEMORY_COMPRESSION_MODE { 2269 MEMORY_COMPRESSION_MODE_HORIZONTAL = 0x0, 2270 } MEMORY_COMPRESSION_MODE; 2271 inline void init() { 2272 memset(&TheStructure, 0, sizeof(TheStructure)); 2273 TheStructure.Common.MediaBoundaryPixelMode = MEDIA_BOUNDARY_PIXEL_MODE_NORMAL_MODE; 2274 TheStructure.Common.RenderCacheReadWriteMode = RENDER_CACHE_READ_WRITE_MODE_WRITE_ONLY_CACHE; 2275 TheStructure.Common.TileMode = TILE_MODE_LINEAR; 2276 TheStructure.Common.SurfaceHorizontalAlignment = SURFACE_HORIZONTAL_ALIGNMENT_HALIGN_16; 2277 TheStructure.Common.SurfaceVerticalAlignment = SURFACE_VERTICAL_ALIGNMENT_VALIGN_4; 2278 TheStructure.Common.SurfaceType = SURFACE_TYPE_SURFTYPE_1D; 2279 TheStructure.Common.SampleTapDiscardDisable = SAMPLE_TAP_DISCARD_DISABLE_DISABLE; 2280 TheStructure.Common.NullProbingEnable = NULL_PROBING_ENABLE_DISABLE; 2281 TheStructure.Common.StandardTilingModeExtensions = STANDARD_TILING_MODE_EXTENSIONS_DISABLE; 2282 TheStructure.Common.TileAddressMappingMode = TILE_ADDRESS_MAPPING_MODE_GEN9; 2283 TheStructure.Common.NumberOfMultisamples = NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_1; 2284 TheStructure.Common.MultisampledSurfaceStorageFormat = MULTISAMPLED_SURFACE_STORAGE_FORMAT_MSS; 2285 TheStructure.Common.RenderTargetAndSampleUnormRotation = RENDER_TARGET_AND_SAMPLE_UNORM_ROTATION_0DEG; 2286 TheStructure.Common.CoherencyType = COHERENCY_TYPE_GPU_COHERENT; 2287 TheStructure.Common.TiledResourceMode = TILED_RESOURCE_MODE_NONE; 2288 TheStructure.Common.MemoryCompressionMode = MEMORY_COMPRESSION_MODE_HORIZONTAL; 2289 TheStructure.Common.ShaderChannelSelectAlpha = SHADER_CHANNEL_SELECT_ZERO; 2290 TheStructure.Common.ShaderChannelSelectBlue = SHADER_CHANNEL_SELECT_ZERO; 2291 TheStructure.Common.ShaderChannelSelectGreen = SHADER_CHANNEL_SELECT_ZERO; 2292 TheStructure.Common.ShaderChannelSelectRed = SHADER_CHANNEL_SELECT_ZERO; 2293 TheStructure.Common.MemoryCompressionMode = MEMORY_COMPRESSION_MODE_HORIZONTAL; 2294 TheStructure._SurfaceFormatIsPlanar.HalfPitchForChroma = HALF_PITCH_FOR_CHROMA_DISABLE; 2295 TheStructure._SurfaceFormatIsnotPlanar.AuxiliarySurfaceMode = AUXILIARY_SURFACE_MODE_AUX_NONE; 2296 } 2297 static tagRENDER_SURFACE_STATE sInit() { 2298 RENDER_SURFACE_STATE state; 2299 state.init(); 2300 return state; 2301 } 2302 inline uint32_t &getRawData(const uint32_t index) { 2303 DEBUG_BREAK_IF(index >= 16); 2304 return TheStructure.RawData[index]; 2305 } 2306 inline void setCubeFaceEnablePositiveZ(const bool value) { 2307 TheStructure.Common.CubeFaceEnablePositiveZ = value; 2308 } 2309 inline bool getCubeFaceEnablePositiveZ() const { 2310 return TheStructure.Common.CubeFaceEnablePositiveZ; 2311 } 2312 inline void setCubeFaceEnableNegativeZ(const bool value) { 2313 TheStructure.Common.CubeFaceEnableNegativeZ = value; 2314 } 2315 inline bool getCubeFaceEnableNegativeZ() const { 2316 return TheStructure.Common.CubeFaceEnableNegativeZ; 2317 } 2318 inline void setCubeFaceEnablePositiveY(const bool value) { 2319 TheStructure.Common.CubeFaceEnablePositiveY = value; 2320 } 2321 inline bool getCubeFaceEnablePositiveY() const { 2322 return TheStructure.Common.CubeFaceEnablePositiveY; 2323 } 2324 inline void setCubeFaceEnableNegativeY(const bool value) { 2325 TheStructure.Common.CubeFaceEnableNegativeY = value; 2326 } 2327 inline bool getCubeFaceEnableNegativeY() const { 2328 return TheStructure.Common.CubeFaceEnableNegativeY; 2329 } 2330 inline void setCubeFaceEnablePositiveX(const bool value) { 2331 TheStructure.Common.CubeFaceEnablePositiveX = value; 2332 } 2333 inline bool getCubeFaceEnablePositiveX() const { 2334 return TheStructure.Common.CubeFaceEnablePositiveX; 2335 } 2336 inline void setCubeFaceEnableNegativeX(const bool value) { 2337 TheStructure.Common.CubeFaceEnableNegativeX = value; 2338 } 2339 inline bool getCubeFaceEnableNegativeX() const { 2340 return TheStructure.Common.CubeFaceEnableNegativeX; 2341 } 2342 inline void setMediaBoundaryPixelMode(const MEDIA_BOUNDARY_PIXEL_MODE value) { 2343 TheStructure.Common.MediaBoundaryPixelMode = value; 2344 } 2345 inline MEDIA_BOUNDARY_PIXEL_MODE getMediaBoundaryPixelMode() const { 2346 return static_cast<MEDIA_BOUNDARY_PIXEL_MODE>(TheStructure.Common.MediaBoundaryPixelMode); 2347 } 2348 inline void setRenderCacheReadWriteMode(const RENDER_CACHE_READ_WRITE_MODE value) { 2349 TheStructure.Common.RenderCacheReadWriteMode = value; 2350 } 2351 inline RENDER_CACHE_READ_WRITE_MODE getRenderCacheReadWriteMode() const { 2352 return static_cast<RENDER_CACHE_READ_WRITE_MODE>(TheStructure.Common.RenderCacheReadWriteMode); 2353 } 2354 inline void setSamplerL2OutOfOrderModeDisable(const bool value) { 2355 TheStructure.Common.SamplerL2OutOfOrderModeDisable = value; 2356 } 2357 inline bool getSamplerL2OutOfOrderModeDisable() const { 2358 return TheStructure.Common.SamplerL2OutOfOrderModeDisable; 2359 } 2360 inline void setVerticalLineStrideOffset(const bool value) { 2361 TheStructure.Common.VerticalLineStrideOffset = value; 2362 } 2363 inline bool getVerticalLineStrideOffset() const { 2364 return TheStructure.Common.VerticalLineStrideOffset; 2365 } 2366 inline void setVerticalLineStride(const bool value) { 2367 TheStructure.Common.VerticalLineStride = value; 2368 } 2369 inline bool getVerticalLineStride() const { 2370 return TheStructure.Common.VerticalLineStride; 2371 } 2372 inline void setTileMode(const TILE_MODE value) { 2373 TheStructure.Common.TileMode = value; 2374 } 2375 inline TILE_MODE getTileMode() const { 2376 return static_cast<TILE_MODE>(TheStructure.Common.TileMode); 2377 } 2378 inline void setSurfaceHorizontalAlignment(const SURFACE_HORIZONTAL_ALIGNMENT value) { 2379 TheStructure.Common.SurfaceHorizontalAlignment = value; 2380 } 2381 inline SURFACE_HORIZONTAL_ALIGNMENT getSurfaceHorizontalAlignment() const { 2382 return static_cast<SURFACE_HORIZONTAL_ALIGNMENT>(TheStructure.Common.SurfaceHorizontalAlignment); 2383 } 2384 inline void setSurfaceVerticalAlignment(const SURFACE_VERTICAL_ALIGNMENT value) { 2385 TheStructure.Common.SurfaceVerticalAlignment = value; 2386 } 2387 inline SURFACE_VERTICAL_ALIGNMENT getSurfaceVerticalAlignment() const { 2388 return static_cast<SURFACE_VERTICAL_ALIGNMENT>(TheStructure.Common.SurfaceVerticalAlignment); 2389 } 2390 inline void setSurfaceFormat(const SURFACE_FORMAT value) { 2391 TheStructure.Common.SurfaceFormat = value; 2392 } 2393 inline SURFACE_FORMAT getSurfaceFormat() const { 2394 return static_cast<SURFACE_FORMAT>(TheStructure.Common.SurfaceFormat); 2395 } 2396 inline void setAstcEnable(const bool value) { 2397 TheStructure.Common.AstcEnable = value; 2398 } 2399 inline bool getAstcEnable() const { 2400 return TheStructure.Common.AstcEnable; 2401 } 2402 inline void setSurfaceArray(const bool value) { 2403 TheStructure.Common.SurfaceArray = value; 2404 } 2405 inline bool getSurfaceArray() const { 2406 return TheStructure.Common.SurfaceArray; 2407 } 2408 inline void setSurfaceType(const SURFACE_TYPE value) { 2409 TheStructure.Common.SurfaceType = value; 2410 } 2411 inline SURFACE_TYPE getSurfaceType() const { 2412 return static_cast<SURFACE_TYPE>(TheStructure.Common.SurfaceType); 2413 } 2414 typedef enum tagSURFACEQPITCH { 2415 SURFACEQPITCH_BIT_SHIFT = 0x2, 2416 SURFACEQPITCH_ALIGN_SIZE = 0x4, 2417 } SURFACEQPITCH; 2418 inline void setSurfaceQpitch(const uint32_t value) { 2419 DEBUG_BREAK_IF(value > 0x7fff); 2420 TheStructure.Common.SurfaceQpitch = value >> SURFACEQPITCH_BIT_SHIFT; 2421 } 2422 inline uint32_t getSurfaceQpitch() const { 2423 return TheStructure.Common.SurfaceQpitch << SURFACEQPITCH_BIT_SHIFT; 2424 } 2425 inline void setSampleTapDiscardDisable(const SAMPLE_TAP_DISCARD_DISABLE value) { 2426 TheStructure.Common.SampleTapDiscardDisable = value; 2427 } 2428 inline SAMPLE_TAP_DISCARD_DISABLE getSampleTapDiscardDisable() const { 2429 return static_cast<SAMPLE_TAP_DISCARD_DISABLE>(TheStructure.Common.SampleTapDiscardDisable); 2430 } 2431 inline void setDoubleFetchDisable(const bool value) { 2432 TheStructure.Common.DoubleFetchDisable = value; 2433 } 2434 inline bool getDoubleFetchDisable() const { 2435 return TheStructure.Common.DoubleFetchDisable; 2436 } 2437 inline void setCornerTexelMode(const bool value) { 2438 TheStructure.Common.CornerTexelMode = value; 2439 } 2440 inline bool getCornerTexelMode() const { 2441 return TheStructure.Common.CornerTexelMode; 2442 } 2443 inline void setBaseMipLevel(const uint32_t value) { 2444 DEBUG_BREAK_IF(value > 0xf80000); 2445 TheStructure.Common.BaseMipLevel = value; 2446 } 2447 inline uint32_t getBaseMipLevel() const { 2448 return TheStructure.Common.BaseMipLevel; 2449 } 2450 inline void setMemoryObjectControlStateReserved(const uint32_t value) { 2451 TheStructure.Common.MemoryObjectControlStateReserved_56 = value; 2452 } 2453 inline uint32_t getMemoryObjectControlStateReserved() const { 2454 return (TheStructure.Common.MemoryObjectControlStateReserved_56); 2455 } 2456 inline void setMemoryObjectControlState(const uint32_t value) { 2457 TheStructure.Common.MemoryObjectControlStateReserved_56 = value; 2458 TheStructure.Common.MemoryObjectControlStateIndexToMocsTables = (value >> 1); 2459 } 2460 inline uint32_t getMemoryObjectControlState() const { 2461 uint32_t mocs = TheStructure.Common.MemoryObjectControlStateReserved_56; 2462 mocs |= (TheStructure.Common.MemoryObjectControlStateIndexToMocsTables << 1); 2463 return (mocs); 2464 } 2465 inline void setEnableUnormPathInColorPipe(const bool value) { 2466 TheStructure.Common.EnableUnormPathInColorPipe = value; 2467 } 2468 inline bool getEnableUnormPathInColorPipe() const { 2469 return TheStructure.Common.EnableUnormPathInColorPipe; 2470 } 2471 inline void setWidth(const uint32_t value) { 2472 DEBUG_BREAK_IF(value > 0x4000); 2473 TheStructure.Common.Width = value - 1; 2474 } 2475 inline uint32_t getWidth() const { 2476 return TheStructure.Common.Width + 1; 2477 } 2478 inline void setHeight(const uint32_t value) { 2479 DEBUG_BREAK_IF(value > 0x3fff0000); 2480 TheStructure.Common.Height = value - 1; 2481 } 2482 inline uint32_t getHeight() const { 2483 return TheStructure.Common.Height + 1; 2484 } 2485 inline void setDepthStencilResource(const bool value) { 2486 TheStructure.Common.DepthStencilResource = value; 2487 } 2488 inline bool getDepthStencilResource() const { 2489 return TheStructure.Common.DepthStencilResource; 2490 } 2491 inline void setSurfacePitch(const uint32_t value) { 2492 DEBUG_BREAK_IF(value > 0x3ffff); 2493 TheStructure.Common.SurfacePitch = value - 1; 2494 } 2495 inline uint32_t getSurfacePitch() const { 2496 return TheStructure.Common.SurfacePitch + 1; 2497 } 2498 inline void setNullProbingEnable(const NULL_PROBING_ENABLE value) { 2499 TheStructure.Common.NullProbingEnable = value; 2500 } 2501 inline NULL_PROBING_ENABLE getNullProbingEnable() const { 2502 return static_cast<NULL_PROBING_ENABLE>(TheStructure.Common.NullProbingEnable); 2503 } 2504 inline void setStandardTilingModeExtensions(const STANDARD_TILING_MODE_EXTENSIONS value) { 2505 TheStructure.Common.StandardTilingModeExtensions = value; 2506 } 2507 inline STANDARD_TILING_MODE_EXTENSIONS getStandardTilingModeExtensions() const { 2508 return static_cast<STANDARD_TILING_MODE_EXTENSIONS>(TheStructure.Common.StandardTilingModeExtensions); 2509 } 2510 inline void setTileAddressMappingMode(const TILE_ADDRESS_MAPPING_MODE value) { 2511 TheStructure.Common.TileAddressMappingMode = value; 2512 } 2513 inline TILE_ADDRESS_MAPPING_MODE getTileAddressMappingMode() const { 2514 return static_cast<TILE_ADDRESS_MAPPING_MODE>(TheStructure.Common.TileAddressMappingMode); 2515 } 2516 inline void setDepth(const uint32_t value) { 2517 DEBUG_BREAK_IF(value > 0xffe00000L); 2518 TheStructure.Common.Depth = value - 1; 2519 } 2520 inline uint32_t getDepth() const { 2521 return TheStructure.Common.Depth + 1; 2522 } 2523 inline void setMultisamplePositionPaletteIndex(const uint32_t value) { 2524 DEBUG_BREAK_IF(value > 0x7); 2525 TheStructure.Common.MultisamplePositionPaletteIndex = value; 2526 } 2527 inline uint32_t getMultisamplePositionPaletteIndex() const { 2528 return TheStructure.Common.MultisamplePositionPaletteIndex; 2529 } 2530 inline void setNumberOfMultisamples(const NUMBER_OF_MULTISAMPLES value) { 2531 TheStructure.Common.NumberOfMultisamples = value; 2532 } 2533 inline NUMBER_OF_MULTISAMPLES getNumberOfMultisamples() const { 2534 return static_cast<NUMBER_OF_MULTISAMPLES>(TheStructure.Common.NumberOfMultisamples); 2535 } 2536 inline void setMultisampledSurfaceStorageFormat(const MULTISAMPLED_SURFACE_STORAGE_FORMAT value) { 2537 TheStructure.Common.MultisampledSurfaceStorageFormat = value; 2538 } 2539 inline MULTISAMPLED_SURFACE_STORAGE_FORMAT getMultisampledSurfaceStorageFormat() const { 2540 return static_cast<MULTISAMPLED_SURFACE_STORAGE_FORMAT>(TheStructure.Common.MultisampledSurfaceStorageFormat); 2541 } 2542 inline void setRenderTargetViewExtent(const uint32_t value) { 2543 DEBUG_BREAK_IF(value > 0x7ff); 2544 TheStructure.Common.RenderTargetViewExtent = value - 1; 2545 } 2546 inline uint32_t getRenderTargetViewExtent() const { 2547 return TheStructure.Common.RenderTargetViewExtent + 1; 2548 } 2549 inline void setMinimumArrayElement(const uint32_t value) { 2550 DEBUG_BREAK_IF(value > 0x7ff); 2551 TheStructure.Common.MinimumArrayElement = value; 2552 } 2553 inline uint32_t getMinimumArrayElement() const { 2554 return TheStructure.Common.MinimumArrayElement; 2555 } 2556 inline void setRenderTargetAndSampleUnormRotation(const RENDER_TARGET_AND_SAMPLE_UNORM_ROTATION value) { 2557 TheStructure.Common.RenderTargetAndSampleUnormRotation = value; 2558 } 2559 inline RENDER_TARGET_AND_SAMPLE_UNORM_ROTATION getRenderTargetAndSampleUnormRotation() const { 2560 return static_cast<RENDER_TARGET_AND_SAMPLE_UNORM_ROTATION>(TheStructure.Common.RenderTargetAndSampleUnormRotation); 2561 } 2562 inline void setMipCountLod(const uint32_t value) { 2563 DEBUG_BREAK_IF(value > 0xf); 2564 TheStructure.Common.MipCountLod = value; 2565 } 2566 inline uint32_t getMipCountLod() const { 2567 return TheStructure.Common.MipCountLod; 2568 } 2569 inline void setSurfaceMinLod(const uint32_t value) { 2570 DEBUG_BREAK_IF(value > 0xf0); 2571 TheStructure.Common.SurfaceMinLod = value; 2572 } 2573 inline uint32_t getSurfaceMinLod() const { 2574 return TheStructure.Common.SurfaceMinLod; 2575 } 2576 inline void setMipTailStartLod(const uint32_t value) { 2577 DEBUG_BREAK_IF(value > 0xf00); 2578 TheStructure.Common.MipTailStartLod = value; 2579 } 2580 inline uint32_t getMipTailStartLod() const { 2581 return TheStructure.Common.MipTailStartLod; 2582 } 2583 inline void setCoherencyType(const COHERENCY_TYPE value) { 2584 TheStructure.Common.CoherencyType = value; 2585 } 2586 inline COHERENCY_TYPE getCoherencyType() const { 2587 return static_cast<COHERENCY_TYPE>(TheStructure.Common.CoherencyType); 2588 } 2589 inline void setTiledResourceMode(const TILED_RESOURCE_MODE value) { 2590 TheStructure.Common.TiledResourceMode = value; 2591 } 2592 inline TILED_RESOURCE_MODE getTiledResourceMode() const { 2593 return static_cast<TILED_RESOURCE_MODE>(TheStructure.Common.TiledResourceMode); 2594 } 2595 inline void setEwaDisableForCube(const bool value) { 2596 TheStructure.Common.EwaDisableForCube = value; 2597 } 2598 inline bool getEwaDisableForCube() const { 2599 return TheStructure.Common.EwaDisableForCube; 2600 } 2601 typedef enum tagYOFFSET { 2602 YOFFSET_BIT_SHIFT = 0x2, 2603 YOFFSET_ALIGN_SIZE = 0x4, 2604 } YOFFSET; 2605 inline void setYOffset(const uint32_t value) { 2606 DEBUG_BREAK_IF(value > 0xe00000); 2607 TheStructure.Common.YOffset = value >> YOFFSET_BIT_SHIFT; 2608 } 2609 inline uint32_t getYOffset() const { 2610 return TheStructure.Common.YOffset << YOFFSET_BIT_SHIFT; 2611 } 2612 typedef enum tagXOFFSET { 2613 XOFFSET_BIT_SHIFT = 0x2, 2614 XOFFSET_ALIGN_SIZE = 0x4, 2615 } XOFFSET; 2616 inline void setXOffset(const uint32_t value) { 2617 DEBUG_BREAK_IF(value > 0xfe000000L); 2618 TheStructure.Common.XOffset = value >> XOFFSET_BIT_SHIFT; 2619 } 2620 inline uint32_t getXOffset() const { 2621 return TheStructure.Common.XOffset << XOFFSET_BIT_SHIFT; 2622 } 2623 inline void setYuvInterpolationEnable(const bool value) { 2624 TheStructure.Common.YuvInterpolationEnable = value; 2625 } 2626 inline bool getYuvInterpolationEnable() const { 2627 return TheStructure.Common.YuvInterpolationEnable; 2628 } 2629 inline void setResourceMinLod(const uint32_t value) { 2630 DEBUG_BREAK_IF(value > 0xfff); 2631 TheStructure.Common.ResourceMinLod = value; 2632 } 2633 inline uint32_t getResourceMinLod() const { 2634 return TheStructure.Common.ResourceMinLod; 2635 } 2636 inline void setShaderChannelSelectAlpha(const SHADER_CHANNEL_SELECT value) { 2637 TheStructure.Common.ShaderChannelSelectAlpha = value; 2638 } 2639 inline SHADER_CHANNEL_SELECT getShaderChannelSelectAlpha() const { 2640 return static_cast<SHADER_CHANNEL_SELECT>(TheStructure.Common.ShaderChannelSelectAlpha); 2641 } 2642 inline void setShaderChannelSelectBlue(const SHADER_CHANNEL_SELECT value) { 2643 TheStructure.Common.ShaderChannelSelectBlue = value; 2644 } 2645 inline SHADER_CHANNEL_SELECT getShaderChannelSelectBlue() const { 2646 return static_cast<SHADER_CHANNEL_SELECT>(TheStructure.Common.ShaderChannelSelectBlue); 2647 } 2648 inline void setShaderChannelSelectGreen(const SHADER_CHANNEL_SELECT value) { 2649 TheStructure.Common.ShaderChannelSelectGreen = value; 2650 } 2651 inline SHADER_CHANNEL_SELECT getShaderChannelSelectGreen() const { 2652 return static_cast<SHADER_CHANNEL_SELECT>(TheStructure.Common.ShaderChannelSelectGreen); 2653 } 2654 inline void setShaderChannelSelectRed(const SHADER_CHANNEL_SELECT value) { 2655 TheStructure.Common.ShaderChannelSelectRed = value; 2656 } 2657 inline SHADER_CHANNEL_SELECT getShaderChannelSelectRed() const { 2658 return static_cast<SHADER_CHANNEL_SELECT>(TheStructure.Common.ShaderChannelSelectRed); 2659 } 2660 inline void setMemoryCompressionEnable(const bool value) { 2661 TheStructure.Common.MemoryCompressionEnable = value; 2662 } 2663 inline bool getMemoryCompressionEnable() const { 2664 return TheStructure.Common.MemoryCompressionEnable; 2665 } 2666 inline void setMemoryCompressionMode(const MEMORY_COMPRESSION_MODE value) { 2667 TheStructure.Common.MemoryCompressionMode = value; 2668 } 2669 inline MEMORY_COMPRESSION_MODE getMemoryCompressionMode() const { 2670 return static_cast<MEMORY_COMPRESSION_MODE>(TheStructure.Common.MemoryCompressionMode); 2671 } 2672 inline void setSurfaceBaseAddress(const uint64_t value) { 2673 TheStructure.Common.SurfaceBaseAddress = value; 2674 } 2675 inline uint64_t getSurfaceBaseAddress() const { 2676 return TheStructure.Common.SurfaceBaseAddress; 2677 } 2678 inline void setQuiltWidth(const uint64_t value) { 2679 DEBUG_BREAK_IF(value > 0x1f); 2680 TheStructure.Common.QuiltWidth = value; 2681 } 2682 inline uint64_t getQuiltWidth() const { 2683 return TheStructure.Common.QuiltWidth; 2684 } 2685 inline void setQuiltHeight(const uint64_t value) { 2686 DEBUG_BREAK_IF(value > 0x3e0); 2687 TheStructure.Common.QuiltHeight = value; 2688 } 2689 inline uint64_t getQuiltHeight() const { 2690 return TheStructure.Common.QuiltHeight; 2691 } 2692 inline void setClearValueAddressEnable(const bool value) { 2693 TheStructure.Common.ClearValueAddressEnable = value; 2694 } 2695 inline bool getClearValueAddressEnable() const { 2696 return TheStructure.Common.ClearValueAddressEnable; 2697 } 2698 inline void setProceduralTexture(const bool value) { 2699 TheStructure.Common.ProceduralTexture = value; 2700 } 2701 inline bool getProceduralTexture() const { 2702 return TheStructure.Common.ProceduralTexture; 2703 } 2704 typedef enum tagCLEARADDRESSLOW { 2705 CLEARADDRESSLOW_BIT_SHIFT = 0x6, 2706 CLEARADDRESSLOW_ALIGN_SIZE = 0x40, 2707 } CLEARADDRESSLOW; 2708 inline void setClearColorAddress(const uint32_t value) { 2709 DEBUG_BREAK_IF(value > 0xffffffc0L); 2710 TheStructure.Common.ClearAddressLow = value >> CLEARADDRESSLOW_BIT_SHIFT; 2711 } 2712 inline uint32_t getClearColorAddress() const { 2713 return TheStructure.Common.ClearAddressLow << CLEARADDRESSLOW_BIT_SHIFT; 2714 } 2715 inline void setClearColorAddressHigh(const uint32_t value) { 2716 UNRECOVERABLE_IF(value > 0xffff); 2717 TheStructure.Common.ClearAddressHigh = value; 2718 } 2719 inline uint32_t getClearColorAddressHigh() const { 2720 return TheStructure.Common.ClearAddressHigh; 2721 } 2722 inline void setYOffsetForUOrUvPlane(const uint32_t value) { 2723 DEBUG_BREAK_IF(value > 0x3fff); 2724 TheStructure._SurfaceFormatIsPlanar.YOffsetForUOrUvPlane = value; 2725 } 2726 inline uint32_t getYOffsetForUOrUvPlane() const { 2727 return TheStructure._SurfaceFormatIsPlanar.YOffsetForUOrUvPlane; 2728 } 2729 inline void setXOffsetForUOrUvPlane(const uint32_t value) { 2730 DEBUG_BREAK_IF(value > 0x3fff0000); 2731 TheStructure._SurfaceFormatIsPlanar.XOffsetForUOrUvPlane = value; 2732 } 2733 inline uint32_t getXOffsetForUOrUvPlane() const { 2734 return TheStructure._SurfaceFormatIsPlanar.XOffsetForUOrUvPlane; 2735 } 2736 inline void setHalfPitchForChroma(const HALF_PITCH_FOR_CHROMA value) { 2737 TheStructure._SurfaceFormatIsPlanar.HalfPitchForChroma = value; 2738 } 2739 inline HALF_PITCH_FOR_CHROMA getHalfPitchForChroma() const { 2740 return static_cast<HALF_PITCH_FOR_CHROMA>(TheStructure._SurfaceFormatIsPlanar.HalfPitchForChroma); 2741 } 2742 inline void setSeparateUvPlaneEnable(const bool value) { 2743 TheStructure._SurfaceFormatIsPlanar.SeparateUvPlaneEnable = value; 2744 } 2745 inline bool getSeparateUvPlaneEnable() const { 2746 return TheStructure._SurfaceFormatIsPlanar.SeparateUvPlaneEnable; 2747 } 2748 inline void setYOffsetForVPlane(const uint64_t value) { 2749 DEBUG_BREAK_IF(value > 0x3fff00000000L); 2750 TheStructure._SurfaceFormatIsPlanar.YOffsetForVPlane = value; 2751 } 2752 inline uint64_t getYOffsetForVPlane() const { 2753 return TheStructure._SurfaceFormatIsPlanar.YOffsetForVPlane; 2754 } 2755 inline void setXOffsetForVPlane(const uint64_t value) { 2756 DEBUG_BREAK_IF(value > 0x3fff000000000000L); 2757 TheStructure._SurfaceFormatIsPlanar.XOffsetForVPlane = value; 2758 } 2759 inline uint64_t getXOffsetForVPlane() const { 2760 return TheStructure._SurfaceFormatIsPlanar.XOffsetForVPlane; 2761 } 2762 inline void setAuxiliarySurfaceMode(const AUXILIARY_SURFACE_MODE value) { 2763 TheStructure._SurfaceFormatIsnotPlanar.AuxiliarySurfaceMode = value; 2764 } 2765 inline AUXILIARY_SURFACE_MODE getAuxiliarySurfaceMode() const { 2766 return static_cast<AUXILIARY_SURFACE_MODE>(TheStructure._SurfaceFormatIsnotPlanar.AuxiliarySurfaceMode); 2767 } 2768 inline void setAuxiliarySurfacePitch(const uint32_t value) { 2769 DEBUG_BREAK_IF(value > 0xff8); 2770 TheStructure._SurfaceFormatIsnotPlanar.AuxiliarySurfacePitch = value - 1; 2771 } 2772 inline uint32_t getAuxiliarySurfacePitch() const { 2773 return TheStructure._SurfaceFormatIsnotPlanar.AuxiliarySurfacePitch + 1; 2774 } 2775 typedef enum tagAUXILIARYSURFACEQPITCH { 2776 AUXILIARYSURFACEQPITCH_BIT_SHIFT = 0x2, 2777 AUXILIARYSURFACEQPITCH_ALIGN_SIZE = 0x4, 2778 } AUXILIARYSURFACEQPITCH; 2779 inline void setAuxiliarySurfaceQpitch(const uint32_t value) { 2780 DEBUG_BREAK_IF(value > 0x7fff0000L); 2781 TheStructure._SurfaceFormatIsnotPlanar.AuxiliarySurfaceQpitch = value >> AUXILIARYSURFACEQPITCH_BIT_SHIFT; 2782 } 2783 inline uint32_t getAuxiliarySurfaceQpitch() const { 2784 return TheStructure._SurfaceFormatIsnotPlanar.AuxiliarySurfaceQpitch << AUXILIARYSURFACEQPITCH_BIT_SHIFT; 2785 } 2786 typedef enum tagAUXILIARYSURFACEBASEADDRESS { 2787 AUXILIARYSURFACEBASEADDRESS_BIT_SHIFT = 0xc, 2788 AUXILIARYSURFACEBASEADDRESS_ALIGN_SIZE = 0x1000, 2789 } AUXILIARYSURFACEBASEADDRESS; 2790 inline void setAuxiliarySurfaceBaseAddress(const uint64_t value) { 2791 DEBUG_BREAK_IF(value > 0xfffffffffffff000L); 2792 TheStructure._SurfaceFormatIsnotPlanarAndMemoryCompressionEnableIs0.AuxiliarySurfaceBaseAddress = value >> AUXILIARYSURFACEBASEADDRESS_BIT_SHIFT; 2793 } 2794 inline uint64_t getAuxiliarySurfaceBaseAddress() const { 2795 return TheStructure._SurfaceFormatIsnotPlanarAndMemoryCompressionEnableIs0.AuxiliarySurfaceBaseAddress << AUXILIARYSURFACEBASEADDRESS_BIT_SHIFT; 2796 } 2797} RENDER_SURFACE_STATE; 2798STATIC_ASSERT(64 == sizeof(RENDER_SURFACE_STATE)); 2799 2800typedef struct tagSAMPLER_STATE { 2801 union tagTheStructure { 2802 struct tagCommon { 2803 // DWORD 0 2804 uint32_t LodAlgorithm : BITFIELD_RANGE(0, 0); 2805 uint32_t TextureLodBias : BITFIELD_RANGE(1, 13); 2806 uint32_t MinModeFilter : BITFIELD_RANGE(14, 16); 2807 uint32_t MagModeFilter : BITFIELD_RANGE(17, 19); 2808 uint32_t MipModeFilter : BITFIELD_RANGE(20, 21); 2809 uint32_t Reserved_22 : BITFIELD_RANGE(22, 25); 2810 uint32_t LowQualityCubeCornerMode : BITFIELD_RANGE(26, 26); 2811 uint32_t LodPreclampMode : BITFIELD_RANGE(27, 28); 2812 uint32_t TextureBorderColorMode : BITFIELD_RANGE(29, 29); 2813 uint32_t CpsLodCompensationEnable : BITFIELD_RANGE(30, 30); 2814 uint32_t SamplerDisable : BITFIELD_RANGE(31, 31); 2815 // DWORD 1 2816 uint32_t CubeSurfaceControlMode : BITFIELD_RANGE(0, 0); 2817 uint32_t ShadowFunction : BITFIELD_RANGE(1, 3); 2818 uint32_t ChromakeyMode : BITFIELD_RANGE(4, 4); 2819 uint32_t ChromakeyIndex : BITFIELD_RANGE(5, 6); 2820 uint32_t ChromakeyEnable : BITFIELD_RANGE(7, 7); 2821 uint32_t MaxLod : BITFIELD_RANGE(8, 19); 2822 uint32_t MinLod : BITFIELD_RANGE(20, 31); 2823 // DWORD 2 2824 uint32_t LodClampMagnificationMode : BITFIELD_RANGE(0, 0); 2825 uint32_t SrgbDecode : BITFIELD_RANGE(1, 1); 2826 uint32_t ReturnFilterWeightForNullTexels : BITFIELD_RANGE(2, 2); 2827 uint32_t ReturnFilterWeightForBorderTexels : BITFIELD_RANGE(3, 3); 2828 uint32_t Reserved_68 : BITFIELD_RANGE(4, 4); 2829 uint32_t ForceGather4Behavior : BITFIELD_RANGE(5, 5); 2830 uint32_t IndirectStatePointer : BITFIELD_RANGE(6, 23); 2831 uint32_t ExtendedIndirectStatePointer : BITFIELD_RANGE(24, 31); 2832 // DWORD 3 2833 uint32_t TczAddressControlMode : BITFIELD_RANGE(0, 2); 2834 uint32_t TcyAddressControlMode : BITFIELD_RANGE(3, 5); 2835 uint32_t TcxAddressControlMode : BITFIELD_RANGE(6, 8); 2836 uint32_t ReductionTypeEnable : BITFIELD_RANGE(9, 9); 2837 uint32_t NonNormalizedCoordinateEnable : BITFIELD_RANGE(10, 10); 2838 uint32_t MipLinearFilterQuality : BITFIELD_RANGE(11, 12); 2839 uint32_t RAddressMinFilterRoundingEnable : BITFIELD_RANGE(13, 13); 2840 uint32_t RAddressMagFilterRoundingEnable : BITFIELD_RANGE(14, 14); 2841 uint32_t VAddressMinFilterRoundingEnable : BITFIELD_RANGE(15, 15); 2842 uint32_t VAddressMagFilterRoundingEnable : BITFIELD_RANGE(16, 16); 2843 uint32_t UAddressMinFilterRoundingEnable : BITFIELD_RANGE(17, 17); 2844 uint32_t UAddressMagFilterRoundingEnable : BITFIELD_RANGE(18, 18); 2845 uint32_t MaximumAnisotropy : BITFIELD_RANGE(19, 21); 2846 uint32_t ReductionType : BITFIELD_RANGE(22, 23); 2847 uint32_t AllowLowQualityLodCalculation : BITFIELD_RANGE(24, 24); 2848 uint32_t Reserved_121 : BITFIELD_RANGE(25, 25); 2849 uint32_t LowQualityFilter : BITFIELD_RANGE(26, 26); 2850 uint32_t Reserved_123 : BITFIELD_RANGE(27, 31); 2851 } Common; 2852 uint32_t RawData[4]; 2853 } TheStructure; 2854 typedef enum tagLOD_ALGORITHM { 2855 LOD_ALGORITHM_LEGACY = 0x0, 2856 LOD_ALGORITHM_EWA_APPROXIMATION = 0x1, 2857 } LOD_ALGORITHM; 2858 typedef enum tagMIN_MODE_FILTER { 2859 MIN_MODE_FILTER_NEAREST = 0x0, 2860 MIN_MODE_FILTER_LINEAR = 0x1, 2861 MIN_MODE_FILTER_ANISOTROPIC = 0x2, 2862 MIN_MODE_FILTER_MONO = 0x6, 2863 } MIN_MODE_FILTER; 2864 typedef enum tagMAG_MODE_FILTER { 2865 MAG_MODE_FILTER_NEAREST = 0x0, 2866 MAG_MODE_FILTER_LINEAR = 0x1, 2867 MAG_MODE_FILTER_ANISOTROPIC = 0x2, 2868 MAG_MODE_FILTER_MONO = 0x6, 2869 } MAG_MODE_FILTER; 2870 typedef enum tagMIP_MODE_FILTER { 2871 MIP_MODE_FILTER_NONE = 0x0, 2872 MIP_MODE_FILTER_NEAREST = 0x1, 2873 MIP_MODE_FILTER_LINEAR = 0x3, 2874 } MIP_MODE_FILTER; 2875 typedef enum tagLOW_QUALITY_CUBE_CORNER_MODE { 2876 LOW_QUALITY_CUBE_CORNER_MODE_DISABLE = 0x0, 2877 LOW_QUALITY_CUBE_CORNER_MODE_ENABLE = 0x1, 2878 } LOW_QUALITY_CUBE_CORNER_MODE; 2879 typedef enum tagLOD_PRECLAMP_MODE { 2880 LOD_PRECLAMP_MODE_NONE = 0x0, 2881 LOD_PRECLAMP_MODE_OGL = 0x2, 2882 } LOD_PRECLAMP_MODE; 2883 typedef enum tagTEXTURE_BORDER_COLOR_MODE { 2884 TEXTURE_BORDER_COLOR_MODE_OGL = 0x0, 2885 TEXTURE_BORDER_COLOR_MODE_8BIT = 0x1, 2886 } TEXTURE_BORDER_COLOR_MODE; 2887 typedef enum tagCUBE_SURFACE_CONTROL_MODE { 2888 CUBE_SURFACE_CONTROL_MODE_PROGRAMMED = 0x0, 2889 CUBE_SURFACE_CONTROL_MODE_OVERRIDE = 0x1, 2890 } CUBE_SURFACE_CONTROL_MODE; 2891 typedef enum tagSHADOW_FUNCTION { 2892 SHADOW_FUNCTION_PREFILTEROP_ALWAYS = 0x0, 2893 SHADOW_FUNCTION_PREFILTEROP_NEVER = 0x1, 2894 SHADOW_FUNCTION_PREFILTEROP_LESS = 0x2, 2895 SHADOW_FUNCTION_PREFILTEROP_EQUAL = 0x3, 2896 SHADOW_FUNCTION_PREFILTEROP_LEQUAL = 0x4, 2897 SHADOW_FUNCTION_PREFILTEROP_GREATER = 0x5, 2898 SHADOW_FUNCTION_PREFILTEROP_NOTEQUAL = 0x6, 2899 SHADOW_FUNCTION_PREFILTEROP_GEQUAL = 0x7, 2900 } SHADOW_FUNCTION; 2901 typedef enum tagCHROMAKEY_MODE { 2902 CHROMAKEY_MODE_KEYFILTER_KILL_ON_ANY_MATCH = 0x0, 2903 CHROMAKEY_MODE_KEYFILTER_REPLACE_BLACK = 0x1, 2904 } CHROMAKEY_MODE; 2905 typedef enum tagLOD_CLAMP_MAGNIFICATION_MODE { 2906 LOD_CLAMP_MAGNIFICATION_MODE_MIPNONE = 0x0, 2907 LOD_CLAMP_MAGNIFICATION_MODE_MIPFILTER = 0x1, 2908 } LOD_CLAMP_MAGNIFICATION_MODE; 2909 typedef enum tagSRGB_DECODE { 2910 SRGB_DECODE_DECODE_EXT = 0x0, 2911 SRGB_DECODE_SKIP_DECODE_EXT = 0x1, 2912 } SRGB_DECODE; 2913 typedef enum tagRETURN_FILTER_WEIGHT_FOR_NULL_TEXELS { 2914 RETURN_FILTER_WEIGHT_FOR_NULL_TEXELS_DISABLE = 0x0, 2915 RETURN_FILTER_WEIGHT_FOR_NULL_TEXELS_ENABLE = 0x1, 2916 } RETURN_FILTER_WEIGHT_FOR_NULL_TEXELS; 2917 typedef enum tagRETURN_FILTER_WEIGHT_FOR_BORDER_TEXELS { 2918 RETURN_FILTER_WEIGHT_FOR_BORDER_TEXELS_DISABLE = 0x0, 2919 RETURN_FILTER_WEIGHT_FOR_BORDER_TEXELS_ENABLE = 0x1, 2920 } RETURN_FILTER_WEIGHT_FOR_BORDER_TEXELS; 2921 typedef enum tagTEXTURE_COORDINATE_MODE { 2922 TEXTURE_COORDINATE_MODE_WRAP = 0x0, 2923 TEXTURE_COORDINATE_MODE_MIRROR = 0x1, 2924 TEXTURE_COORDINATE_MODE_CLAMP = 0x2, 2925 TEXTURE_COORDINATE_MODE_CUBE = 0x3, 2926 TEXTURE_COORDINATE_MODE_CLAMP_BORDER = 0x4, 2927 TEXTURE_COORDINATE_MODE_MIRROR_ONCE = 0x5, 2928 TEXTURE_COORDINATE_MODE_HALF_BORDER = 0x6, 2929 TEXTURE_COORDINATE_MODE_MIRROR_101 = 0x7, 2930 } TEXTURE_COORDINATE_MODE; 2931 typedef enum tagMIP_LINEAR_FILTER_QUALITY { 2932 MIP_LINEAR_FILTER_QUALITY_FULL_QUALITY = 0x0, 2933 MIP_LINEAR_FILTER_QUALITY_HIGH_QUALITY = 0x1, 2934 MIP_LINEAR_FILTER_QUALITY_MEDIUM_QUALITY = 0x2, 2935 MIP_LINEAR_FILTER_QUALITY_LOW_QUALITY = 0x3, 2936 } MIP_LINEAR_FILTER_QUALITY; 2937 typedef enum tagMAXIMUM_ANISOTROPY { 2938 MAXIMUM_ANISOTROPY_RATIO_21 = 0x0, 2939 MAXIMUM_ANISOTROPY_RATIO_41 = 0x1, 2940 MAXIMUM_ANISOTROPY_RATIO_61 = 0x2, 2941 MAXIMUM_ANISOTROPY_RATIO_81 = 0x3, 2942 MAXIMUM_ANISOTROPY_RATIO_101 = 0x4, 2943 MAXIMUM_ANISOTROPY_RATIO_121 = 0x5, 2944 MAXIMUM_ANISOTROPY_RATIO_141 = 0x6, 2945 MAXIMUM_ANISOTROPY_RATIO_161 = 0x7, 2946 } MAXIMUM_ANISOTROPY; 2947 typedef enum tagREDUCTION_TYPE { 2948 REDUCTION_TYPE_STD_FILTER = 0x0, 2949 REDUCTION_TYPE_COMPARISON = 0x1, 2950 REDUCTION_TYPE_MINIMUM = 0x2, 2951 REDUCTION_TYPE_MAXIMUM = 0x3, 2952 } REDUCTION_TYPE; 2953 typedef enum tagLOW_QUALITY_FILTER { 2954 LOW_QUALITY_FILTER_DISABLE = 0x0, 2955 LOW_QUALITY_FILTER_ENABLE = 0x1, 2956 } LOW_QUALITY_FILTER; 2957 inline void init() { 2958 memset(&TheStructure, 0, sizeof(TheStructure)); 2959 TheStructure.Common.LodAlgorithm = LOD_ALGORITHM_LEGACY; 2960 TheStructure.Common.MinModeFilter = MIN_MODE_FILTER_NEAREST; 2961 TheStructure.Common.MagModeFilter = MAG_MODE_FILTER_NEAREST; 2962 TheStructure.Common.MipModeFilter = MIP_MODE_FILTER_NONE; 2963 TheStructure.Common.LowQualityCubeCornerMode = LOW_QUALITY_CUBE_CORNER_MODE_ENABLE; 2964 TheStructure.Common.LodPreclampMode = LOD_PRECLAMP_MODE_NONE; 2965 TheStructure.Common.TextureBorderColorMode = TEXTURE_BORDER_COLOR_MODE_OGL; 2966 TheStructure.Common.CubeSurfaceControlMode = CUBE_SURFACE_CONTROL_MODE_PROGRAMMED; 2967 TheStructure.Common.ShadowFunction = SHADOW_FUNCTION_PREFILTEROP_ALWAYS; 2968 TheStructure.Common.ChromakeyMode = CHROMAKEY_MODE_KEYFILTER_KILL_ON_ANY_MATCH; 2969 TheStructure.Common.LodClampMagnificationMode = LOD_CLAMP_MAGNIFICATION_MODE_MIPNONE; 2970 TheStructure.Common.SrgbDecode = SRGB_DECODE_DECODE_EXT; 2971 TheStructure.Common.ReturnFilterWeightForNullTexels = RETURN_FILTER_WEIGHT_FOR_NULL_TEXELS_DISABLE; 2972 TheStructure.Common.ReturnFilterWeightForBorderTexels = RETURN_FILTER_WEIGHT_FOR_BORDER_TEXELS_DISABLE; 2973 TheStructure.Common.MipLinearFilterQuality = MIP_LINEAR_FILTER_QUALITY_FULL_QUALITY; 2974 TheStructure.Common.MaximumAnisotropy = MAXIMUM_ANISOTROPY_RATIO_21; 2975 TheStructure.Common.ReductionType = REDUCTION_TYPE_STD_FILTER; 2976 TheStructure.Common.LowQualityFilter = LOW_QUALITY_FILTER_DISABLE; 2977 } 2978 static tagSAMPLER_STATE sInit() { 2979 SAMPLER_STATE state; 2980 state.init(); 2981 return state; 2982 } 2983 inline uint32_t &getRawData(const uint32_t index) { 2984 UNRECOVERABLE_IF(index >= 4); 2985 return TheStructure.RawData[index]; 2986 } 2987 inline void setLodAlgorithm(const LOD_ALGORITHM value) { 2988 TheStructure.Common.LodAlgorithm = value; 2989 } 2990 inline LOD_ALGORITHM getLodAlgorithm() const { 2991 return static_cast<LOD_ALGORITHM>(TheStructure.Common.LodAlgorithm); 2992 } 2993 inline void setTextureLodBias(const uint32_t value) { 2994 UNRECOVERABLE_IF(value > 0x1fff); 2995 TheStructure.Common.TextureLodBias = value; 2996 } 2997 inline uint32_t getTextureLodBias() const { 2998 return TheStructure.Common.TextureLodBias; 2999 } 3000 inline void setMinModeFilter(const MIN_MODE_FILTER value) { 3001 TheStructure.Common.MinModeFilter = value; 3002 } 3003 inline MIN_MODE_FILTER getMinModeFilter() const { 3004 return static_cast<MIN_MODE_FILTER>(TheStructure.Common.MinModeFilter); 3005 } 3006 inline void setMagModeFilter(const MAG_MODE_FILTER value) { 3007 TheStructure.Common.MagModeFilter = value; 3008 } 3009 inline MAG_MODE_FILTER getMagModeFilter() const { 3010 return static_cast<MAG_MODE_FILTER>(TheStructure.Common.MagModeFilter); 3011 } 3012 inline void setMipModeFilter(const MIP_MODE_FILTER value) { 3013 TheStructure.Common.MipModeFilter = value; 3014 } 3015 inline MIP_MODE_FILTER getMipModeFilter() const { 3016 return static_cast<MIP_MODE_FILTER>(TheStructure.Common.MipModeFilter); 3017 } 3018 inline void setLowQualityCubeCornerMode(const LOW_QUALITY_CUBE_CORNER_MODE value) { 3019 TheStructure.Common.LowQualityCubeCornerMode = value; 3020 } 3021 inline LOW_QUALITY_CUBE_CORNER_MODE getLowQualityCubeCornerMode() const { 3022 return static_cast<LOW_QUALITY_CUBE_CORNER_MODE>(TheStructure.Common.LowQualityCubeCornerMode); 3023 } 3024 inline void setLodPreclampMode(const LOD_PRECLAMP_MODE value) { 3025 TheStructure.Common.LodPreclampMode = value; 3026 } 3027 inline LOD_PRECLAMP_MODE getLodPreclampMode() const { 3028 return static_cast<LOD_PRECLAMP_MODE>(TheStructure.Common.LodPreclampMode); 3029 } 3030 inline void setTextureBorderColorMode(const TEXTURE_BORDER_COLOR_MODE value) { 3031 TheStructure.Common.TextureBorderColorMode = value; 3032 } 3033 inline TEXTURE_BORDER_COLOR_MODE getTextureBorderColorMode() const { 3034 return static_cast<TEXTURE_BORDER_COLOR_MODE>(TheStructure.Common.TextureBorderColorMode); 3035 } 3036 inline void setCpsLodCompensationEnable(const bool value) { 3037 TheStructure.Common.CpsLodCompensationEnable = value; 3038 } 3039 inline bool getCpsLodCompensationEnable() const { 3040 return TheStructure.Common.CpsLodCompensationEnable; 3041 } 3042 inline void setSamplerDisable(const bool value) { 3043 TheStructure.Common.SamplerDisable = value; 3044 } 3045 inline bool getSamplerDisable() const { 3046 return TheStructure.Common.SamplerDisable; 3047 } 3048 inline void setCubeSurfaceControlMode(const CUBE_SURFACE_CONTROL_MODE value) { 3049 TheStructure.Common.CubeSurfaceControlMode = value; 3050 } 3051 inline CUBE_SURFACE_CONTROL_MODE getCubeSurfaceControlMode() const { 3052 return static_cast<CUBE_SURFACE_CONTROL_MODE>(TheStructure.Common.CubeSurfaceControlMode); 3053 } 3054 inline void setShadowFunction(const SHADOW_FUNCTION value) { 3055 TheStructure.Common.ShadowFunction = value; 3056 } 3057 inline SHADOW_FUNCTION getShadowFunction() const { 3058 return static_cast<SHADOW_FUNCTION>(TheStructure.Common.ShadowFunction); 3059 } 3060 inline void setChromakeyMode(const CHROMAKEY_MODE value) { 3061 TheStructure.Common.ChromakeyMode = value; 3062 } 3063 inline CHROMAKEY_MODE getChromakeyMode() const { 3064 return static_cast<CHROMAKEY_MODE>(TheStructure.Common.ChromakeyMode); 3065 } 3066 inline void setChromakeyIndex(const uint32_t value) { 3067 UNRECOVERABLE_IF(value > 0x3); 3068 TheStructure.Common.ChromakeyIndex = value; 3069 } 3070 inline uint32_t getChromakeyIndex() const { 3071 return TheStructure.Common.ChromakeyIndex; 3072 } 3073 inline void setChromakeyEnable(const bool value) { 3074 TheStructure.Common.ChromakeyEnable = value; 3075 } 3076 inline bool getChromakeyEnable() const { 3077 return TheStructure.Common.ChromakeyEnable; 3078 } 3079 inline void setMaxLod(const uint32_t value) { 3080 UNRECOVERABLE_IF(value > 0xfff); 3081 TheStructure.Common.MaxLod = value; 3082 } 3083 inline uint32_t getMaxLod() const { 3084 return TheStructure.Common.MaxLod; 3085 } 3086 inline void setMinLod(const uint32_t value) { 3087 UNRECOVERABLE_IF(value > 0xfff); 3088 TheStructure.Common.MinLod = value; 3089 } 3090 inline uint32_t getMinLod() const { 3091 return TheStructure.Common.MinLod; 3092 } 3093 inline void setLodClampMagnificationMode(const LOD_CLAMP_MAGNIFICATION_MODE value) { 3094 TheStructure.Common.LodClampMagnificationMode = value; 3095 } 3096 inline LOD_CLAMP_MAGNIFICATION_MODE getLodClampMagnificationMode() const { 3097 return static_cast<LOD_CLAMP_MAGNIFICATION_MODE>(TheStructure.Common.LodClampMagnificationMode); 3098 } 3099 inline void setSrgbDecode(const SRGB_DECODE value) { 3100 TheStructure.Common.SrgbDecode = value; 3101 } 3102 inline SRGB_DECODE getSrgbDecode() const { 3103 return static_cast<SRGB_DECODE>(TheStructure.Common.SrgbDecode); 3104 } 3105 inline void setReturnFilterWeightForNullTexels(const RETURN_FILTER_WEIGHT_FOR_NULL_TEXELS value) { 3106 TheStructure.Common.ReturnFilterWeightForNullTexels = value; 3107 } 3108 inline RETURN_FILTER_WEIGHT_FOR_NULL_TEXELS getReturnFilterWeightForNullTexels() const { 3109 return static_cast<RETURN_FILTER_WEIGHT_FOR_NULL_TEXELS>(TheStructure.Common.ReturnFilterWeightForNullTexels); 3110 } 3111 inline void setReturnFilterWeightForBorderTexels(const RETURN_FILTER_WEIGHT_FOR_BORDER_TEXELS value) { 3112 TheStructure.Common.ReturnFilterWeightForBorderTexels = value; 3113 } 3114 inline RETURN_FILTER_WEIGHT_FOR_BORDER_TEXELS getReturnFilterWeightForBorderTexels() const { 3115 return static_cast<RETURN_FILTER_WEIGHT_FOR_BORDER_TEXELS>(TheStructure.Common.ReturnFilterWeightForBorderTexels); 3116 } 3117 inline void setForceGather4Behavior(const bool value) { 3118 TheStructure.Common.ForceGather4Behavior = value; 3119 } 3120 inline bool getForceGather4Behavior() const { 3121 return TheStructure.Common.ForceGather4Behavior; 3122 } 3123 typedef enum tagINDIRECTSTATEPOINTER { 3124 INDIRECTSTATEPOINTER_BIT_SHIFT = 0x6, 3125 INDIRECTSTATEPOINTER_ALIGN_SIZE = 0x40, 3126 } INDIRECTSTATEPOINTER; 3127 inline void setIndirectStatePointer(const uint32_t value) { 3128 UNRECOVERABLE_IF(value > 0xffffff); 3129 TheStructure.Common.IndirectStatePointer = static_cast<uint32_t>(value) >> INDIRECTSTATEPOINTER_BIT_SHIFT; 3130 } 3131 inline uint32_t getIndirectStatePointer() const { 3132 return TheStructure.Common.IndirectStatePointer << INDIRECTSTATEPOINTER_BIT_SHIFT; 3133 } 3134 inline void setExtendedIndirectStatePointer(const uint32_t value) { 3135 UNRECOVERABLE_IF(value > 0xff); 3136 TheStructure.Common.ExtendedIndirectStatePointer = value; 3137 } 3138 inline uint32_t getExtendedIndirectStatePointer() const { 3139 return TheStructure.Common.ExtendedIndirectStatePointer; 3140 } 3141 inline void setTczAddressControlMode(const TEXTURE_COORDINATE_MODE value) { 3142 TheStructure.Common.TczAddressControlMode = value; 3143 } 3144 inline TEXTURE_COORDINATE_MODE getTczAddressControlMode() const { 3145 return static_cast<TEXTURE_COORDINATE_MODE>(TheStructure.Common.TczAddressControlMode); 3146 } 3147 inline void setTcyAddressControlMode(const TEXTURE_COORDINATE_MODE value) { 3148 TheStructure.Common.TcyAddressControlMode = value; 3149 } 3150 inline TEXTURE_COORDINATE_MODE getTcyAddressControlMode() const { 3151 return static_cast<TEXTURE_COORDINATE_MODE>(TheStructure.Common.TcyAddressControlMode); 3152 } 3153 inline void setTcxAddressControlMode(const TEXTURE_COORDINATE_MODE value) { 3154 TheStructure.Common.TcxAddressControlMode = value; 3155 } 3156 inline TEXTURE_COORDINATE_MODE getTcxAddressControlMode() const { 3157 return static_cast<TEXTURE_COORDINATE_MODE>(TheStructure.Common.TcxAddressControlMode); 3158 } 3159 inline void setReductionTypeEnable(const bool value) { 3160 TheStructure.Common.ReductionTypeEnable = value; 3161 } 3162 inline bool getReductionTypeEnable() const { 3163 return TheStructure.Common.ReductionTypeEnable; 3164 } 3165 inline void setNonNormalizedCoordinateEnable(const bool value) { 3166 TheStructure.Common.NonNormalizedCoordinateEnable = value; 3167 } 3168 inline bool getNonNormalizedCoordinateEnable() const { 3169 return TheStructure.Common.NonNormalizedCoordinateEnable; 3170 } 3171 inline void setMipLinearFilterQuality(const MIP_LINEAR_FILTER_QUALITY value) { 3172 TheStructure.Common.MipLinearFilterQuality = value; 3173 } 3174 inline MIP_LINEAR_FILTER_QUALITY getMipLinearFilterQuality() const { 3175 return static_cast<MIP_LINEAR_FILTER_QUALITY>(TheStructure.Common.MipLinearFilterQuality); 3176 } 3177 inline void setRAddressMinFilterRoundingEnable(const bool value) { 3178 TheStructure.Common.RAddressMinFilterRoundingEnable = value; 3179 } 3180 inline bool getRAddressMinFilterRoundingEnable() const { 3181 return TheStructure.Common.RAddressMinFilterRoundingEnable; 3182 } 3183 inline void setRAddressMagFilterRoundingEnable(const bool value) { 3184 TheStructure.Common.RAddressMagFilterRoundingEnable = value; 3185 } 3186 inline bool getRAddressMagFilterRoundingEnable() const { 3187 return TheStructure.Common.RAddressMagFilterRoundingEnable; 3188 } 3189 inline void setVAddressMinFilterRoundingEnable(const bool value) { 3190 TheStructure.Common.VAddressMinFilterRoundingEnable = value; 3191 } 3192 inline bool getVAddressMinFilterRoundingEnable() const { 3193 return TheStructure.Common.VAddressMinFilterRoundingEnable; 3194 } 3195 inline void setVAddressMagFilterRoundingEnable(const bool value) { 3196 TheStructure.Common.VAddressMagFilterRoundingEnable = value; 3197 } 3198 inline bool getVAddressMagFilterRoundingEnable() const { 3199 return TheStructure.Common.VAddressMagFilterRoundingEnable; 3200 } 3201 inline void setUAddressMinFilterRoundingEnable(const bool value) { 3202 TheStructure.Common.UAddressMinFilterRoundingEnable = value; 3203 } 3204 inline bool getUAddressMinFilterRoundingEnable() const { 3205 return TheStructure.Common.UAddressMinFilterRoundingEnable; 3206 } 3207 inline void setUAddressMagFilterRoundingEnable(const bool value) { 3208 TheStructure.Common.UAddressMagFilterRoundingEnable = value; 3209 } 3210 inline bool getUAddressMagFilterRoundingEnable() const { 3211 return TheStructure.Common.UAddressMagFilterRoundingEnable; 3212 } 3213 inline void setMaximumAnisotropy(const MAXIMUM_ANISOTROPY value) { 3214 TheStructure.Common.MaximumAnisotropy = value; 3215 } 3216 inline MAXIMUM_ANISOTROPY getMaximumAnisotropy() const { 3217 return static_cast<MAXIMUM_ANISOTROPY>(TheStructure.Common.MaximumAnisotropy); 3218 } 3219 inline void setReductionType(const REDUCTION_TYPE value) { 3220 TheStructure.Common.ReductionType = value; 3221 } 3222 inline REDUCTION_TYPE getReductionType() const { 3223 return static_cast<REDUCTION_TYPE>(TheStructure.Common.ReductionType); 3224 } 3225 inline void setLowQualityFilter(const LOW_QUALITY_FILTER value) { 3226 TheStructure.Common.LowQualityFilter = value; 3227 } 3228 inline LOW_QUALITY_FILTER getLowQualityFilter() const { 3229 return static_cast<LOW_QUALITY_FILTER>(TheStructure.Common.LowQualityFilter); 3230 } 3231 inline void setAllowLowQualityLodCalculation(const bool value) { 3232 TheStructure.Common.AllowLowQualityLodCalculation = value; 3233 } 3234 inline bool getAllowLowQualityLodCalculation() const { 3235 return TheStructure.Common.AllowLowQualityLodCalculation; 3236 } 3237} SAMPLER_STATE; 3238STATIC_ASSERT(16 == sizeof(SAMPLER_STATE)); 3239 3240typedef struct tagSTATE_BASE_ADDRESS { 3241 union tagTheStructure { 3242 struct tagCommon { 3243 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 3244 uint32_t Reserved_8 : BITFIELD_RANGE(8, 15); 3245 uint32_t _3DCommandSubOpcode : BITFIELD_RANGE(16, 23); 3246 uint32_t _3DCommandOpcode : BITFIELD_RANGE(24, 26); 3247 uint32_t CommandSubtype : BITFIELD_RANGE(27, 28); 3248 uint32_t CommandType : BITFIELD_RANGE(29, 31); 3249 uint64_t GeneralStateBaseAddressModifyEnable : BITFIELD_RANGE(0, 0); 3250 uint64_t Reserved_33 : BITFIELD_RANGE(1, 3); 3251 uint64_t GeneralStateMemoryObjectControlState_Reserved : BITFIELD_RANGE(4, 4); 3252 uint64_t GeneralStateMemoryObjectControlState_IndexToMocsTables : BITFIELD_RANGE(5, 10); 3253 uint64_t Reserved_43 : BITFIELD_RANGE(11, 11); 3254 uint64_t GeneralStateBaseAddress : BITFIELD_RANGE(12, 63); 3255 uint32_t Reserved_96 : BITFIELD_RANGE(0, 15); 3256 uint32_t StatelessDataPortAccessMemoryObjectControlState_Reserved : BITFIELD_RANGE(16, 16); 3257 uint32_t StatelessDataPortAccessMemoryObjectControlState_IndexToMocsTables : BITFIELD_RANGE(17, 22); 3258 uint32_t Reserved_119 : BITFIELD_RANGE(23, 31); 3259 uint64_t SurfaceStateBaseAddressModifyEnable : BITFIELD_RANGE(0, 0); 3260 uint64_t Reserved_129 : BITFIELD_RANGE(1, 3); 3261 uint64_t SurfaceStateMemoryObjectControlState_Reserved : BITFIELD_RANGE(4, 4); 3262 uint64_t SurfaceStateMemoryObjectControlState_IndexToMocsTables : BITFIELD_RANGE(5, 10); 3263 uint64_t Reserved_139 : BITFIELD_RANGE(11, 11); 3264 uint64_t SurfaceStateBaseAddress : BITFIELD_RANGE(12, 63); 3265 uint64_t DynamicStateBaseAddressModifyEnable : BITFIELD_RANGE(0, 0); 3266 uint64_t Reserved_193 : BITFIELD_RANGE(1, 3); 3267 uint64_t DynamicStateMemoryObjectControlState_Reserved : BITFIELD_RANGE(4, 4); 3268 uint64_t DynamicStateMemoryObjectControlState_IndexToMocsTables : BITFIELD_RANGE(5, 10); 3269 uint64_t Reserved_203 : BITFIELD_RANGE(11, 11); 3270 uint64_t DynamicStateBaseAddress : BITFIELD_RANGE(12, 63); 3271 uint64_t IndirectObjectBaseAddressModifyEnable : BITFIELD_RANGE(0, 0); 3272 uint64_t Reserved_257 : BITFIELD_RANGE(1, 3); 3273 uint64_t IndirectObjectMemoryObjectControlState_Reserved : BITFIELD_RANGE(4, 4); 3274 uint64_t IndirectObjectMemoryObjectControlState_IndexToMocsTables : BITFIELD_RANGE(5, 10); 3275 uint64_t Reserved_267 : BITFIELD_RANGE(11, 11); 3276 uint64_t IndirectObjectBaseAddress : BITFIELD_RANGE(12, 63); 3277 uint64_t InstructionBaseAddressModifyEnable : BITFIELD_RANGE(0, 0); 3278 uint64_t Reserved_321 : BITFIELD_RANGE(1, 3); 3279 uint64_t InstructionMemoryObjectControlState_Reserved : BITFIELD_RANGE(4, 4); 3280 uint64_t InstructionMemoryObjectControlState_IndexToMocsTables : BITFIELD_RANGE(5, 10); 3281 uint64_t Reserved_331 : BITFIELD_RANGE(11, 11); 3282 uint64_t InstructionBaseAddress : BITFIELD_RANGE(12, 63); 3283 uint32_t GeneralStateBufferSizeModifyEnable : BITFIELD_RANGE(0, 0); 3284 uint32_t Reserved_385 : BITFIELD_RANGE(1, 11); 3285 uint32_t GeneralStateBufferSize : BITFIELD_RANGE(12, 31); 3286 uint32_t DynamicStateBufferSizeModifyEnable : BITFIELD_RANGE(0, 0); 3287 uint32_t Reserved_417 : BITFIELD_RANGE(1, 11); 3288 uint32_t DynamicStateBufferSize : BITFIELD_RANGE(12, 31); 3289 uint32_t IndirectObjectBufferSizeModifyEnable : BITFIELD_RANGE(0, 0); 3290 uint32_t Reserved_449 : BITFIELD_RANGE(1, 11); 3291 uint32_t IndirectObjectBufferSize : BITFIELD_RANGE(12, 31); 3292 uint32_t InstructionBufferSizeModifyEnable : BITFIELD_RANGE(0, 0); 3293 uint32_t Reserved_481 : BITFIELD_RANGE(1, 11); 3294 uint32_t InstructionBufferSize : BITFIELD_RANGE(12, 31); 3295 uint64_t BindlessSurfaceStateBaseAddressModifyEnable : BITFIELD_RANGE(0, 0); 3296 uint64_t Reserved_513 : BITFIELD_RANGE(1, 3); 3297 uint64_t BindlessSurfaceStateMemoryObjectControlState_Reserved : BITFIELD_RANGE(4, 4); 3298 uint64_t BindlessSurfaceStateMemoryObjectControlState_IndexToMocsTables : BITFIELD_RANGE(5, 10); 3299 uint64_t Reserved_523 : BITFIELD_RANGE(11, 11); 3300 uint64_t BindlessSurfaceStateBaseAddress : BITFIELD_RANGE(12, 63); 3301 uint32_t Reserved_576 : BITFIELD_RANGE(0, 11); 3302 uint32_t BindlessSurfaceStateSize : BITFIELD_RANGE(12, 31); 3303 uint64_t BindlessSamplerStateBaseAddressModifyEnable : BITFIELD_RANGE(0, 0); 3304 uint64_t Reserved_609 : BITFIELD_RANGE(1, 3); 3305 uint64_t BindlessSamplerStateMemoryObjectControlState_Reserved : BITFIELD_RANGE(4, 4); 3306 uint64_t BindlessSamplerStateMemoryObjectControlState_IndexToMocsTables : BITFIELD_RANGE(5, 10); 3307 uint64_t Reserved_619 : BITFIELD_RANGE(11, 11); 3308 uint64_t BindlessSamplerStateBaseAddress : BITFIELD_RANGE(12, 63); 3309 uint32_t Reserved_672 : BITFIELD_RANGE(0, 11); 3310 uint32_t BindlessSamplerStateBufferSize : BITFIELD_RANGE(12, 31); 3311 } Common; 3312 uint32_t RawData[22]; 3313 } TheStructure; 3314 typedef enum tagDWORD_LENGTH { 3315 DWORD_LENGTH_DWORD_COUNT_N = 0x14, 3316 } DWORD_LENGTH; 3317 typedef enum tag_3D_COMMAND_SUB_OPCODE { 3318 _3D_COMMAND_SUB_OPCODE_STATE_BASE_ADDRESS = 0x1, 3319 } _3D_COMMAND_SUB_OPCODE; 3320 typedef enum tag_3D_COMMAND_OPCODE { 3321 _3D_COMMAND_OPCODE_GFXPIPE_NONPIPELINED = 0x1, 3322 } _3D_COMMAND_OPCODE; 3323 typedef enum tagCOMMAND_SUBTYPE { 3324 COMMAND_SUBTYPE_GFXPIPE_COMMON = 0x0, 3325 } COMMAND_SUBTYPE; 3326 typedef enum tagCOMMAND_TYPE { 3327 COMMAND_TYPE_GFXPIPE = 0x3, 3328 } COMMAND_TYPE; 3329 typedef enum tagPATCH_CONSTANTS { 3330 GENERALSTATEBASEADDRESS_BYTEOFFSET = 0x4, 3331 GENERALSTATEBASEADDRESS_INDEX = 0x1, 3332 SURFACESTATEBASEADDRESS_BYTEOFFSET = 0x10, 3333 SURFACESTATEBASEADDRESS_INDEX = 0x4, 3334 DYNAMICSTATEBASEADDRESS_BYTEOFFSET = 0x18, 3335 DYNAMICSTATEBASEADDRESS_INDEX = 0x6, 3336 INDIRECTOBJECTBASEADDRESS_BYTEOFFSET = 0x20, 3337 INDIRECTOBJECTBASEADDRESS_INDEX = 0x8, 3338 INSTRUCTIONBASEADDRESS_BYTEOFFSET = 0x28, 3339 INSTRUCTIONBASEADDRESS_INDEX = 0xa, 3340 BINDLESSSURFACESTATEBASEADDRESS_BYTEOFFSET = 0x40, 3341 BINDLESSSURFACESTATEBASEADDRESS_INDEX = 0x10, 3342 BINDLESSSAMPLERSTATEBASEADDRESS_BYTEOFFSET = 0x4c, 3343 BINDLESSSAMPLERSTATEBASEADDRESS_INDEX = 0x13, 3344 } PATCH_CONSTANTS; 3345 inline void init() { 3346 memset(&TheStructure, 0, sizeof(TheStructure)); 3347 TheStructure.Common.DwordLength = DWORD_LENGTH_DWORD_COUNT_N; 3348 TheStructure.Common._3DCommandSubOpcode = _3D_COMMAND_SUB_OPCODE_STATE_BASE_ADDRESS; 3349 TheStructure.Common._3DCommandOpcode = _3D_COMMAND_OPCODE_GFXPIPE_NONPIPELINED; 3350 TheStructure.Common.CommandSubtype = COMMAND_SUBTYPE_GFXPIPE_COMMON; 3351 TheStructure.Common.CommandType = COMMAND_TYPE_GFXPIPE; 3352 } 3353 static tagSTATE_BASE_ADDRESS sInit() { 3354 STATE_BASE_ADDRESS state; 3355 state.init(); 3356 return state; 3357 } 3358 inline uint32_t &getRawData(const uint32_t index) { 3359 DEBUG_BREAK_IF(index >= 22); 3360 return TheStructure.RawData[index]; 3361 } 3362 inline void setGeneralStateBaseAddressModifyEnable(const bool value) { 3363 TheStructure.Common.GeneralStateBaseAddressModifyEnable = value; 3364 } 3365 inline bool getGeneralStateBaseAddressModifyEnable() const { 3366 return (TheStructure.Common.GeneralStateBaseAddressModifyEnable); 3367 } 3368 inline void setGeneralStateMemoryObjectControlStateReserved(const uint64_t value) { 3369 TheStructure.Common.GeneralStateMemoryObjectControlState_Reserved = value; 3370 } 3371 inline uint64_t getGeneralStateMemoryObjectControlStateReserved() const { 3372 return (TheStructure.Common.GeneralStateMemoryObjectControlState_Reserved); 3373 } 3374 inline void setGeneralStateMemoryObjectControlState(const uint64_t value) { 3375 TheStructure.Common.GeneralStateMemoryObjectControlState_IndexToMocsTables = value >> 1; 3376 } 3377 inline uint64_t getGeneralStateMemoryObjectControlState() const { 3378 return (TheStructure.Common.GeneralStateMemoryObjectControlState_IndexToMocsTables << 1); 3379 } 3380 typedef enum tagGENERALSTATEBASEADDRESS { 3381 GENERALSTATEBASEADDRESS_BIT_SHIFT = 0xc, 3382 GENERALSTATEBASEADDRESS_ALIGN_SIZE = 0x1000, 3383 } GENERALSTATEBASEADDRESS; 3384 inline void setGeneralStateBaseAddress(const uint64_t value) { 3385 TheStructure.Common.GeneralStateBaseAddress = value >> GENERALSTATEBASEADDRESS_BIT_SHIFT; 3386 } 3387 inline uint64_t getGeneralStateBaseAddress() const { 3388 return (TheStructure.Common.GeneralStateBaseAddress << GENERALSTATEBASEADDRESS_BIT_SHIFT); 3389 } 3390 inline void setStatelessDataPortAccessMemoryObjectControlStateReserved(const uint32_t value) { 3391 TheStructure.Common.StatelessDataPortAccessMemoryObjectControlState_Reserved = value; 3392 } 3393 inline uint32_t getStatelessDataPortAccessMemoryObjectControlStateReserved() const { 3394 return (TheStructure.Common.StatelessDataPortAccessMemoryObjectControlState_Reserved); 3395 } 3396 inline void setStatelessDataPortAccessMemoryObjectControlState(const uint32_t value) { 3397 TheStructure.Common.StatelessDataPortAccessMemoryObjectControlState_Reserved = value; 3398 TheStructure.Common.StatelessDataPortAccessMemoryObjectControlState_IndexToMocsTables = (value >> 1); 3399 } 3400 inline uint32_t getStatelessDataPortAccessMemoryObjectControlState() const { 3401 uint32_t mocs = TheStructure.Common.StatelessDataPortAccessMemoryObjectControlState_Reserved; 3402 mocs |= (TheStructure.Common.StatelessDataPortAccessMemoryObjectControlState_IndexToMocsTables << 1); 3403 return (mocs); 3404 } 3405 inline void setSurfaceStateBaseAddressModifyEnable(const bool value) { 3406 TheStructure.Common.SurfaceStateBaseAddressModifyEnable = value; 3407 } 3408 inline bool getSurfaceStateBaseAddressModifyEnable() const { 3409 return (TheStructure.Common.SurfaceStateBaseAddressModifyEnable); 3410 } 3411 inline void setSurfaceStateMemoryObjectControlStateReserved(const uint64_t value) { 3412 TheStructure.Common.SurfaceStateMemoryObjectControlState_Reserved = value; 3413 } 3414 inline uint64_t getSurfaceStateMemoryObjectControlStateReserved() const { 3415 return (TheStructure.Common.SurfaceStateMemoryObjectControlState_Reserved); 3416 } 3417 inline void setSurfaceStateMemoryObjectControlState(const uint64_t value) { 3418 TheStructure.Common.SurfaceStateMemoryObjectControlState_IndexToMocsTables = value >> 1; 3419 } 3420 inline uint64_t getSurfaceStateMemoryObjectControlState() const { 3421 return (TheStructure.Common.SurfaceStateMemoryObjectControlState_IndexToMocsTables << 1); 3422 } 3423 typedef enum tagSURFACESTATEBASEADDRESS { 3424 SURFACESTATEBASEADDRESS_BIT_SHIFT = 0xc, 3425 SURFACESTATEBASEADDRESS_ALIGN_SIZE = 0x1000, 3426 } SURFACESTATEBASEADDRESS; 3427 inline void setSurfaceStateBaseAddress(const uint64_t value) { 3428 TheStructure.Common.SurfaceStateBaseAddress = value >> SURFACESTATEBASEADDRESS_BIT_SHIFT; 3429 } 3430 inline uint64_t getSurfaceStateBaseAddress() const { 3431 return (TheStructure.Common.SurfaceStateBaseAddress << SURFACESTATEBASEADDRESS_BIT_SHIFT); 3432 } 3433 inline void setDynamicStateBaseAddressModifyEnable(const bool value) { 3434 TheStructure.Common.DynamicStateBaseAddressModifyEnable = value; 3435 } 3436 inline bool getDynamicStateBaseAddressModifyEnable() const { 3437 return (TheStructure.Common.DynamicStateBaseAddressModifyEnable); 3438 } 3439 inline void setDynamicStateMemoryObjectControlStateReserved(const uint64_t value) { 3440 TheStructure.Common.DynamicStateMemoryObjectControlState_Reserved = value; 3441 } 3442 inline uint64_t getDynamicStateMemoryObjectControlStateReserved() const { 3443 return (TheStructure.Common.DynamicStateMemoryObjectControlState_Reserved); 3444 } 3445 inline void setDynamicStateMemoryObjectControlState(const uint64_t value) { 3446 TheStructure.Common.DynamicStateMemoryObjectControlState_IndexToMocsTables = value >> 1; 3447 } 3448 inline uint64_t getDynamicStateMemoryObjectControlState() const { 3449 return (TheStructure.Common.DynamicStateMemoryObjectControlState_IndexToMocsTables << 1); 3450 } 3451 typedef enum tagDYNAMICSTATEBASEADDRESS { 3452 DYNAMICSTATEBASEADDRESS_BIT_SHIFT = 0xc, 3453 DYNAMICSTATEBASEADDRESS_ALIGN_SIZE = 0x1000, 3454 } DYNAMICSTATEBASEADDRESS; 3455 inline void setDynamicStateBaseAddress(const uint64_t value) { 3456 TheStructure.Common.DynamicStateBaseAddress = value >> DYNAMICSTATEBASEADDRESS_BIT_SHIFT; 3457 } 3458 inline uint64_t getDynamicStateBaseAddress() const { 3459 return (TheStructure.Common.DynamicStateBaseAddress << DYNAMICSTATEBASEADDRESS_BIT_SHIFT); 3460 } 3461 inline void setIndirectObjectBaseAddressModifyEnable(const bool value) { 3462 TheStructure.Common.IndirectObjectBaseAddressModifyEnable = value; 3463 } 3464 inline bool getIndirectObjectBaseAddressModifyEnable() const { 3465 return (TheStructure.Common.IndirectObjectBaseAddressModifyEnable); 3466 } 3467 inline void setIndirectObjectMemoryObjectControlStateReserved(const uint64_t value) { 3468 TheStructure.Common.IndirectObjectMemoryObjectControlState_Reserved = value; 3469 } 3470 inline uint64_t getIndirectObjectMemoryObjectControlStateReserved() const { 3471 return (TheStructure.Common.IndirectObjectMemoryObjectControlState_Reserved); 3472 } 3473 inline void setIndirectObjectMemoryObjectControlState(const uint64_t value) { 3474 TheStructure.Common.IndirectObjectMemoryObjectControlState_IndexToMocsTables = value >> 1; 3475 } 3476 inline uint64_t getIndirectObjectMemoryObjectControlState() const { 3477 return (TheStructure.Common.IndirectObjectMemoryObjectControlState_IndexToMocsTables << 1); 3478 } 3479 typedef enum tagINDIRECTOBJECTBASEADDRESS { 3480 INDIRECTOBJECTBASEADDRESS_BIT_SHIFT = 0xc, 3481 INDIRECTOBJECTBASEADDRESS_ALIGN_SIZE = 0x1000, 3482 } INDIRECTOBJECTBASEADDRESS; 3483 inline void setIndirectObjectBaseAddress(const uint64_t value) { 3484 TheStructure.Common.IndirectObjectBaseAddress = value >> INDIRECTOBJECTBASEADDRESS_BIT_SHIFT; 3485 } 3486 inline uint64_t getIndirectObjectBaseAddress() const { 3487 return (TheStructure.Common.IndirectObjectBaseAddress << INDIRECTOBJECTBASEADDRESS_BIT_SHIFT); 3488 } 3489 inline void setInstructionBaseAddressModifyEnable(const bool value) { 3490 TheStructure.Common.InstructionBaseAddressModifyEnable = value; 3491 } 3492 inline bool getInstructionBaseAddressModifyEnable() const { 3493 return (TheStructure.Common.InstructionBaseAddressModifyEnable); 3494 } 3495 inline void setInstructionMemoryObjectControlStateReserved(const uint64_t value) { 3496 TheStructure.Common.InstructionMemoryObjectControlState_Reserved = value; 3497 } 3498 inline uint64_t getInstructionMemoryObjectControlStateReserved() const { 3499 return (TheStructure.Common.InstructionMemoryObjectControlState_Reserved); 3500 } 3501 inline void setInstructionMemoryObjectControlState(const uint32_t value) { 3502 uint64_t val = static_cast<uint64_t>(value); 3503 TheStructure.Common.InstructionMemoryObjectControlState_Reserved = val; 3504 TheStructure.Common.InstructionMemoryObjectControlState_IndexToMocsTables = (val >> 1); 3505 } 3506 inline uint32_t getInstructionMemoryObjectControlState() const { 3507 uint64_t mocs = TheStructure.Common.InstructionMemoryObjectControlState_Reserved; 3508 mocs |= (TheStructure.Common.InstructionMemoryObjectControlState_IndexToMocsTables << 1); 3509 return static_cast<uint32_t>(mocs); 3510 } 3511 typedef enum tagINSTRUCTIONBASEADDRESS { 3512 INSTRUCTIONBASEADDRESS_BIT_SHIFT = 0xc, 3513 INSTRUCTIONBASEADDRESS_ALIGN_SIZE = 0x1000, 3514 } INSTRUCTIONBASEADDRESS; 3515 inline void setInstructionBaseAddress(const uint64_t value) { 3516 TheStructure.Common.InstructionBaseAddress = value >> INSTRUCTIONBASEADDRESS_BIT_SHIFT; 3517 } 3518 inline uint64_t getInstructionBaseAddress() const { 3519 return (TheStructure.Common.InstructionBaseAddress << INSTRUCTIONBASEADDRESS_BIT_SHIFT); 3520 } 3521 inline void setGeneralStateBufferSizeModifyEnable(const bool value) { 3522 TheStructure.Common.GeneralStateBufferSizeModifyEnable = value; 3523 } 3524 inline bool getGeneralStateBufferSizeModifyEnable() const { 3525 return (TheStructure.Common.GeneralStateBufferSizeModifyEnable); 3526 } 3527 inline void setGeneralStateBufferSize(const uint32_t value) { 3528 TheStructure.Common.GeneralStateBufferSize = value; 3529 } 3530 inline uint32_t getGeneralStateBufferSize() const { 3531 return (TheStructure.Common.GeneralStateBufferSize); 3532 } 3533 inline void setDynamicStateBufferSizeModifyEnable(const bool value) { 3534 TheStructure.Common.DynamicStateBufferSizeModifyEnable = value; 3535 } 3536 inline bool getDynamicStateBufferSizeModifyEnable() const { 3537 return (TheStructure.Common.DynamicStateBufferSizeModifyEnable); 3538 } 3539 inline void setDynamicStateBufferSize(const uint32_t value) { 3540 TheStructure.Common.DynamicStateBufferSize = value; 3541 } 3542 inline uint32_t getDynamicStateBufferSize() const { 3543 return (TheStructure.Common.DynamicStateBufferSize); 3544 } 3545 inline void setIndirectObjectBufferSizeModifyEnable(const bool value) { 3546 TheStructure.Common.IndirectObjectBufferSizeModifyEnable = value; 3547 } 3548 inline bool getIndirectObjectBufferSizeModifyEnable() const { 3549 return (TheStructure.Common.IndirectObjectBufferSizeModifyEnable); 3550 } 3551 inline void setIndirectObjectBufferSize(const uint32_t value) { 3552 TheStructure.Common.IndirectObjectBufferSize = value; 3553 } 3554 inline uint32_t getIndirectObjectBufferSize() const { 3555 return (TheStructure.Common.IndirectObjectBufferSize); 3556 } 3557 inline void setInstructionBufferSizeModifyEnable(const bool value) { 3558 TheStructure.Common.InstructionBufferSizeModifyEnable = value; 3559 } 3560 inline bool getInstructionBufferSizeModifyEnable() const { 3561 return (TheStructure.Common.InstructionBufferSizeModifyEnable); 3562 } 3563 inline void setInstructionBufferSize(const uint32_t value) { 3564 TheStructure.Common.InstructionBufferSize = value; 3565 } 3566 inline uint32_t getInstructionBufferSize() const { 3567 return (TheStructure.Common.InstructionBufferSize); 3568 } 3569 inline void setBindlessSurfaceStateBaseAddressModifyEnable(const bool value) { 3570 TheStructure.Common.BindlessSurfaceStateBaseAddressModifyEnable = value; 3571 } 3572 inline bool getBindlessSurfaceStateBaseAddressModifyEnable() const { 3573 return (TheStructure.Common.BindlessSurfaceStateBaseAddressModifyEnable); 3574 } 3575 inline void setBindlessSurfaceStateMemoryObjectControlStateReserved(const uint64_t value) { 3576 TheStructure.Common.BindlessSurfaceStateMemoryObjectControlState_Reserved = value; 3577 } 3578 inline uint64_t getBindlessSurfaceStateMemoryObjectControlStateReserved() const { 3579 return (TheStructure.Common.BindlessSurfaceStateMemoryObjectControlState_Reserved); 3580 } 3581 inline void setBindlessSurfaceStateMemoryObjectControlState(const uint64_t value) { 3582 TheStructure.Common.BindlessSurfaceStateMemoryObjectControlState_IndexToMocsTables = value >> 1; 3583 } 3584 inline uint64_t getBindlessSurfaceStateMemoryObjectControlState() const { 3585 return (TheStructure.Common.BindlessSurfaceStateMemoryObjectControlState_IndexToMocsTables << 1); 3586 } 3587 typedef enum tagBINDLESSSURFACESTATEBASEADDRESS { 3588 BINDLESSSURFACESTATEBASEADDRESS_BIT_SHIFT = 0xc, 3589 BINDLESSSURFACESTATEBASEADDRESS_ALIGN_SIZE = 0x1000, 3590 } BINDLESSSURFACESTATEBASEADDRESS; 3591 inline void setBindlessSurfaceStateBaseAddress(const uint64_t value) { 3592 TheStructure.Common.BindlessSurfaceStateBaseAddress = value >> BINDLESSSURFACESTATEBASEADDRESS_BIT_SHIFT; 3593 } 3594 inline uint64_t getBindlessSurfaceStateBaseAddress() const { 3595 return (TheStructure.Common.BindlessSurfaceStateBaseAddress << BINDLESSSURFACESTATEBASEADDRESS_BIT_SHIFT); 3596 } 3597 inline void setBindlessSurfaceStateSize(const uint32_t value) { 3598 TheStructure.Common.BindlessSurfaceStateSize = value; 3599 } 3600 inline uint32_t getBindlessSurfaceStateSize() const { 3601 return (TheStructure.Common.BindlessSurfaceStateSize); 3602 } 3603 inline void setBindlessSamplerStateBaseAddressModifyEnable(const bool value) { 3604 TheStructure.Common.BindlessSamplerStateBaseAddressModifyEnable = value; 3605 } 3606 inline bool getBindlessSamplerStateBaseAddressModifyEnable() const { 3607 return (TheStructure.Common.BindlessSamplerStateBaseAddressModifyEnable); 3608 } 3609 inline void setBindlessSamplerStateMemoryObjectControlStateReserved(const uint64_t value) { 3610 TheStructure.Common.BindlessSamplerStateMemoryObjectControlState_Reserved = value; 3611 } 3612 inline uint64_t getBindlessSamplerStateMemoryObjectControlStateReserved() const { 3613 return (TheStructure.Common.BindlessSamplerStateMemoryObjectControlState_Reserved); 3614 } 3615 inline void setBindlessSamplerStateMemoryObjectControlState(const uint64_t value) { 3616 TheStructure.Common.BindlessSamplerStateMemoryObjectControlState_IndexToMocsTables = value >> 1; 3617 } 3618 inline uint64_t getBindlessSamplerStateMemoryObjectControlState() const { 3619 return (TheStructure.Common.BindlessSamplerStateMemoryObjectControlState_IndexToMocsTables << 1); 3620 } 3621 typedef enum tagBINDLESSSAMPLERSTATEBASEADDRESS { 3622 BINDLESSSAMPLERSTATEBASEADDRESS_BIT_SHIFT = 0xc, 3623 BINDLESSSAMPLERSTATEBASEADDRESS_ALIGN_SIZE = 0x1000, 3624 } BINDLESSSAMPLERSTATEBASEADDRESS; 3625 inline void setBindlessSamplerStateBaseAddress(const uint64_t value) { 3626 TheStructure.Common.BindlessSamplerStateBaseAddress = value >> BINDLESSSAMPLERSTATEBASEADDRESS_BIT_SHIFT; 3627 } 3628 inline uint64_t getBindlessSamplerStateBaseAddress() const { 3629 return (TheStructure.Common.BindlessSamplerStateBaseAddress << BINDLESSSAMPLERSTATEBASEADDRESS_BIT_SHIFT); 3630 } 3631 inline void setBindlessSamplerStateBufferSize(const uint32_t value) { 3632 TheStructure.Common.BindlessSamplerStateBufferSize = value; 3633 } 3634 inline uint32_t getBindlessSamplerStateBufferSize() const { 3635 return (TheStructure.Common.BindlessSamplerStateBufferSize); 3636 } 3637} STATE_BASE_ADDRESS; 3638STATIC_ASSERT(88 == sizeof(STATE_BASE_ADDRESS)); 3639 3640typedef struct tagMI_REPORT_PERF_COUNT { 3641 union tagTheStructure { 3642 struct tagCommon { 3643 // DWORD 0 3644 uint32_t DwordLength : BITFIELD_RANGE(0, 5); 3645 uint32_t Reserved_6 : BITFIELD_RANGE(6, 22); 3646 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 3647 uint32_t CommandType : BITFIELD_RANGE(29, 31); 3648 // DWORD 1 3649 uint64_t UseGlobalGtt : BITFIELD_RANGE(0, 0); 3650 uint64_t Reserved_33 : BITFIELD_RANGE(1, 3); 3651 uint64_t CoreModeEnable : BITFIELD_RANGE(4, 4); 3652 uint64_t Reserved_37 : BITFIELD_RANGE(5, 5); 3653 uint64_t MemoryAddress : BITFIELD_RANGE(6, 63); 3654 // DWORD 3 3655 uint32_t ReportId; 3656 } Common; 3657 uint32_t RawData[4]; 3658 } TheStructure; 3659 typedef enum tagDWORD_LENGTH { 3660 DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x2, 3661 } DWORD_LENGTH; 3662 typedef enum tagMI_COMMAND_OPCODE { 3663 MI_COMMAND_OPCODE_MI_REPORT_PERF_COUNT = 0x28, 3664 } MI_COMMAND_OPCODE; 3665 typedef enum tagCOMMAND_TYPE { 3666 COMMAND_TYPE_MI_COMMAND = 0x0, 3667 } COMMAND_TYPE; 3668 inline void init() { 3669 memset(&TheStructure, 0, sizeof(TheStructure)); 3670 TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1; 3671 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_REPORT_PERF_COUNT; 3672 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 3673 } 3674 static tagMI_REPORT_PERF_COUNT sInit() { 3675 MI_REPORT_PERF_COUNT state; 3676 state.init(); 3677 return state; 3678 } 3679 inline uint32_t &getRawData(const uint32_t index) { 3680 UNRECOVERABLE_IF(index >= 4); 3681 return TheStructure.RawData[index]; 3682 } 3683 inline void setUseGlobalGtt(const bool value) { 3684 TheStructure.Common.UseGlobalGtt = value; 3685 } 3686 inline bool getUseGlobalGtt() const { 3687 return TheStructure.Common.UseGlobalGtt; 3688 } 3689 inline void setCoreModeEnable(const bool value) { 3690 TheStructure.Common.CoreModeEnable = value; 3691 } 3692 inline bool getCoreModeEnable() const { 3693 return TheStructure.Common.CoreModeEnable; 3694 } 3695 typedef enum tagMEMORYADDRESS { 3696 MEMORYADDRESS_BIT_SHIFT = 0x6, 3697 MEMORYADDRESS_ALIGN_SIZE = 0x40, 3698 } MEMORYADDRESS; 3699 inline void setMemoryAddress(const uint64_t value) { 3700 UNRECOVERABLE_IF(value > 0xffffffffffffffffL); 3701 TheStructure.Common.MemoryAddress = value >> MEMORYADDRESS_BIT_SHIFT; 3702 } 3703 inline uint64_t getMemoryAddress() const { 3704 return TheStructure.Common.MemoryAddress << MEMORYADDRESS_BIT_SHIFT; 3705 } 3706 inline void setReportId(const uint32_t value) { 3707 TheStructure.Common.ReportId = value; 3708 } 3709 inline uint32_t getReportId() const { 3710 return TheStructure.Common.ReportId; 3711 } 3712} MI_REPORT_PERF_COUNT; 3713STATIC_ASSERT(16 == sizeof(MI_REPORT_PERF_COUNT)); 3714 3715typedef struct tagSTATE_COMPUTE_MODE { 3716 union tagTheStructure { 3717 struct tagCommon { 3718 // DWORD 0 3719 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 3720 uint32_t Reserved_8 : BITFIELD_RANGE(8, 15); 3721 uint32_t _3DCommandSubOpcode : BITFIELD_RANGE(16, 23); 3722 uint32_t _3DCommandOpcode : BITFIELD_RANGE(24, 26); 3723 uint32_t CommandSubtype : BITFIELD_RANGE(27, 28); 3724 uint32_t CommandType : BITFIELD_RANGE(29, 31); 3725 // DWORD 1 3726 uint32_t Reserved_32 : BITFIELD_RANGE(0, 2); 3727 uint32_t ForceNonCoherent : BITFIELD_RANGE(3, 4); 3728 uint32_t Reserved_37 : BITFIELD_RANGE(5, 9); 3729 uint32_t BindingTableAlignment : BITFIELD_RANGE(10, 10); 3730 uint32_t Reserved_43 : BITFIELD_RANGE(11, 11); 3731 uint32_t CoherentAccessL1CacheDisable : BITFIELD_RANGE(12, 12); 3732 uint32_t DisableL1InvalidateForNonL1CacheableWrites : BITFIELD_RANGE(13, 13); 3733 uint32_t Reserved_46 : BITFIELD_RANGE(14, 15); 3734 uint32_t Mask : BITFIELD_RANGE(16, 31); 3735 } Common; 3736 uint32_t RawData[2]; 3737 } TheStructure; 3738 typedef enum tagDWORD_LENGTH { 3739 DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x0, 3740 } DWORD_LENGTH; 3741 typedef enum tag_3D_COMMAND_SUB_OPCODE { 3742 _3D_COMMAND_SUB_OPCODE_STATE_COMPUTE_MODE = 0x5, 3743 } _3D_COMMAND_SUB_OPCODE; 3744 typedef enum tag_3D_COMMAND_OPCODE { 3745 _3D_COMMAND_OPCODE_GFXPIPE_NONPIPELINED = 0x1, 3746 } _3D_COMMAND_OPCODE; 3747 typedef enum tagCOMMAND_SUBTYPE { 3748 COMMAND_SUBTYPE_GFXPIPE_COMMON = 0x0, 3749 } COMMAND_SUBTYPE; 3750 typedef enum tagCOMMAND_TYPE { 3751 COMMAND_TYPE_GFXPIPE = 0x3, 3752 } COMMAND_TYPE; 3753 typedef enum tagFORCE_NON_COHERENT { 3754 FORCE_NON_COHERENT_FORCE_DISABLED = 0x0, 3755 FORCE_NON_COHERENT_FORCE_GPU_NON_COHERENT = 0x2, 3756 } FORCE_NON_COHERENT; 3757 typedef enum tagBINDING_TABLE_ALIGNMENT { 3758 BINDING_TABLE_ALIGNMENT_LEGACY = 0x0, 3759 } BINDING_TABLE_ALIGNMENT; 3760 inline void init() { 3761 memset(&TheStructure, 0, sizeof(TheStructure)); 3762 TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1; 3763 TheStructure.Common._3DCommandSubOpcode = _3D_COMMAND_SUB_OPCODE_STATE_COMPUTE_MODE; 3764 TheStructure.Common._3DCommandOpcode = _3D_COMMAND_OPCODE_GFXPIPE_NONPIPELINED; 3765 TheStructure.Common.CommandSubtype = COMMAND_SUBTYPE_GFXPIPE_COMMON; 3766 TheStructure.Common.CommandType = COMMAND_TYPE_GFXPIPE; 3767 TheStructure.Common.ForceNonCoherent = FORCE_NON_COHERENT_FORCE_DISABLED; 3768 TheStructure.Common.BindingTableAlignment = BINDING_TABLE_ALIGNMENT_LEGACY; 3769 } 3770 static tagSTATE_COMPUTE_MODE sInit() { 3771 STATE_COMPUTE_MODE state; 3772 state.init(); 3773 return state; 3774 } 3775 inline uint32_t &getRawData(const uint32_t index) { 3776 UNRECOVERABLE_IF(index >= 2); 3777 return TheStructure.RawData[index]; 3778 } 3779 inline void setForceNonCoherent(const FORCE_NON_COHERENT value) { 3780 TheStructure.Common.ForceNonCoherent = value; 3781 } 3782 inline FORCE_NON_COHERENT getForceNonCoherent() const { 3783 return static_cast<FORCE_NON_COHERENT>(TheStructure.Common.ForceNonCoherent); 3784 } 3785 inline void setBindingTableAlignment(const BINDING_TABLE_ALIGNMENT value) { 3786 TheStructure.Common.BindingTableAlignment = value; 3787 } 3788 inline BINDING_TABLE_ALIGNMENT getBindingTableAlignment() const { 3789 return static_cast<BINDING_TABLE_ALIGNMENT>(TheStructure.Common.BindingTableAlignment); 3790 } 3791 inline void setCoherentAccessL1CacheDisable(const bool value) { 3792 TheStructure.Common.CoherentAccessL1CacheDisable = value; 3793 } 3794 inline bool getCoherentAccessL1CacheDisable() const { 3795 return TheStructure.Common.CoherentAccessL1CacheDisable; 3796 } 3797 inline void setDisableL1InvalidateForNonL1CacheableWrites(const bool value) { 3798 TheStructure.Common.DisableL1InvalidateForNonL1CacheableWrites = value; 3799 } 3800 inline bool getDisableL1InvalidateForNonL1CacheableWrites() const { 3801 return TheStructure.Common.DisableL1InvalidateForNonL1CacheableWrites; 3802 } 3803 inline void setMaskBits(const uint32_t value) { 3804 UNRECOVERABLE_IF(value > 0xffff); 3805 TheStructure.Common.Mask = value; 3806 } 3807 inline uint32_t getMaskBits() const { 3808 return TheStructure.Common.Mask; 3809 } 3810} STATE_COMPUTE_MODE; 3811STATIC_ASSERT(8 == sizeof(STATE_COMPUTE_MODE)); 3812 3813typedef struct tagMI_USER_INTERRUPT { 3814 union tagTheStructure { 3815 struct tagCommon { 3816 // DWORD 0 3817 uint32_t Reserved_0 : BITFIELD_RANGE(0, 22); 3818 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 3819 uint32_t CommandType : BITFIELD_RANGE(29, 31); 3820 } Common; 3821 uint32_t RawData[1]; 3822 } TheStructure; 3823 typedef enum tagMI_COMMAND_OPCODE { 3824 MI_COMMAND_OPCODE_MI_USER_INTERRUPT = 0x2, 3825 } MI_COMMAND_OPCODE; 3826 typedef enum tagCOMMAND_TYPE { 3827 COMMAND_TYPE_MI_COMMAND = 0x0, 3828 } COMMAND_TYPE; 3829 inline void init() { 3830 memset(&TheStructure, 0, sizeof(TheStructure)); 3831 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_USER_INTERRUPT; 3832 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 3833 } 3834 static tagMI_USER_INTERRUPT sInit() { 3835 MI_USER_INTERRUPT state; 3836 state.init(); 3837 return state; 3838 } 3839 inline uint32_t &getRawData(const uint32_t index) { 3840 UNRECOVERABLE_IF(index >= 1); 3841 return TheStructure.RawData[index]; 3842 } 3843} MI_USER_INTERRUPT; 3844STATIC_ASSERT(4 == sizeof(MI_USER_INTERRUPT)); 3845 3846typedef struct tagXY_SRC_COPY_BLT { 3847 union tagTheStructure { 3848 struct tagCommon { 3849 // DWORD 0 3850 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 3851 uint32_t Reserved_8 : BITFIELD_RANGE(8, 10); 3852 uint32_t DestTilingEnable : BITFIELD_RANGE(11, 11); 3853 uint32_t Reserved_12 : BITFIELD_RANGE(12, 14); 3854 uint32_t SrcTilingEnable : BITFIELD_RANGE(15, 15); 3855 uint32_t Reserved_16 : BITFIELD_RANGE(16, 19); 3856 uint32_t _32BppByteMask : BITFIELD_RANGE(20, 21); 3857 uint32_t InstructionTarget_Opcode : BITFIELD_RANGE(22, 28); 3858 uint32_t Client : BITFIELD_RANGE(29, 31); 3859 // DWORD 1 3860 uint32_t DestinationPitch : BITFIELD_RANGE(0, 15); 3861 uint32_t RasterOperation : BITFIELD_RANGE(16, 23); 3862 uint32_t ColorDepth : BITFIELD_RANGE(24, 25); 3863 uint32_t Reserved_58 : BITFIELD_RANGE(26, 29); 3864 uint32_t ClippingEnabled : BITFIELD_RANGE(30, 30); 3865 uint32_t Reserved_63 : BITFIELD_RANGE(31, 31); 3866 // DWORD 2 3867 uint32_t DestinationX1Coordinate_Left : BITFIELD_RANGE(0, 15); 3868 uint32_t DestinationY1Coordinate_Top : BITFIELD_RANGE(16, 31); 3869 // DWORD 3 3870 uint32_t DestinationX2Coordinate_Right : BITFIELD_RANGE(0, 15); 3871 uint32_t DestinationY2Coordinate_Bottom : BITFIELD_RANGE(16, 31); 3872 // DWORD 4-5 3873 uint64_t DestinationBaseAddress; 3874 // DWORD 6 3875 uint32_t SourceX1Coordinate_Left : BITFIELD_RANGE(0, 15); 3876 uint32_t SourceY1Coordinate_Top : BITFIELD_RANGE(16, 31); 3877 // DWORD 7 3878 uint32_t SourcePitch : BITFIELD_RANGE(0, 15); 3879 uint32_t Reserved_240 : BITFIELD_RANGE(16, 31); 3880 // DWORD 8-9 3881 uint64_t SourceBaseAddress; 3882 } Common; 3883 uint32_t RawData[10]; 3884 } TheStructure; 3885 typedef enum tagDEST_TILING_ENABLE { 3886 DEST_TILING_ENABLE_TILING_DISABLED_LINEAR_BLIT = 0x0, 3887 DEST_TILING_ENABLE_TILING_ENABLED = 0x1, 3888 } DEST_TILING_ENABLE; 3889 typedef enum tagSRC_TILING_ENABLE { 3890 SRC_TILING_ENABLE_TILING_DISABLED_LINEAR = 0x0, 3891 SRC_TILING_ENABLE_TILING_ENABLED = 0x1, 3892 } SRC_TILING_ENABLE; 3893 typedef enum tag_32BPP_BYTE_MASK { 3894 _32BPP_BYTE_MASK_WRITE_RGB_CHANNEL = 0x1, 3895 _32BPP_BYTE_MASK_WRITE_ALPHA_CHANNEL = 0x2, 3896 } _32BPP_BYTE_MASK; 3897 typedef enum tagCLIENT { 3898 CLIENT_2D_PROCESSOR = 0x2, 3899 } CLIENT; 3900 typedef enum tagCOLOR_DEPTH { 3901 COLOR_DEPTH_8_BIT_COLOR = 0x0, 3902 COLOR_DEPTH_16_BIT_COLOR565 = 0x1, 3903 COLOR_DEPTH_16_BIT_COLOR1555 = 0x2, 3904 COLOR_DEPTH_32_BIT_COLOR = 0x3, 3905 } COLOR_DEPTH; 3906 typedef enum tagCLIPPING_ENABLED { 3907 CLIPPING_ENABLED_DISABLED = 0x0, 3908 CLIPPING_ENABLED_ENABLED = 0x1, 3909 } CLIPPING_ENABLED; 3910 typedef enum tagINSTRUCTIONTARGET_OPCODE { 3911 INSTRUCTIONTARGET_OPCODE_OPCODE = 0x53, 3912 } INSTRUCTIONTARGET_OPCODE; 3913 typedef enum tagDWORD_LENGTH { 3914 DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x8, 3915 } DWORD_LENGTH; 3916 inline void init() { 3917 memset(&TheStructure, 0, sizeof(TheStructure)); 3918 TheStructure.Common.DestTilingEnable = DEST_TILING_ENABLE_TILING_DISABLED_LINEAR_BLIT; 3919 TheStructure.Common.SrcTilingEnable = SRC_TILING_ENABLE_TILING_DISABLED_LINEAR; 3920 TheStructure.Common.Client = CLIENT_2D_PROCESSOR; 3921 TheStructure.Common.ColorDepth = COLOR_DEPTH_8_BIT_COLOR; 3922 TheStructure.Common.ClippingEnabled = CLIPPING_ENABLED_DISABLED; 3923 TheStructure.Common.InstructionTarget_Opcode = INSTRUCTIONTARGET_OPCODE_OPCODE; 3924 TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1; 3925 TheStructure.Common.RasterOperation = 0xCC; 3926 } 3927 static tagXY_SRC_COPY_BLT sInit() { 3928 XY_SRC_COPY_BLT state; 3929 state.init(); 3930 return state; 3931 } 3932 inline uint32_t &getRawData(const uint32_t index) { 3933 UNRECOVERABLE_IF(index >= 10); 3934 return TheStructure.RawData[index]; 3935 } 3936 inline void setDestTilingEnable(const DEST_TILING_ENABLE value) { 3937 TheStructure.Common.DestTilingEnable = value; 3938 } 3939 inline DEST_TILING_ENABLE getDestTilingEnable() const { 3940 return static_cast<DEST_TILING_ENABLE>(TheStructure.Common.DestTilingEnable); 3941 } 3942 inline void setSrcTilingEnable(const SRC_TILING_ENABLE value) { 3943 TheStructure.Common.SrcTilingEnable = value; 3944 } 3945 inline SRC_TILING_ENABLE getSrcTilingEnable() const { 3946 return static_cast<SRC_TILING_ENABLE>(TheStructure.Common.SrcTilingEnable); 3947 } 3948 inline void set32BppByteMask(const _32BPP_BYTE_MASK value) { 3949 TheStructure.Common._32BppByteMask = value; 3950 } 3951 inline _32BPP_BYTE_MASK get32BppByteMask() const { 3952 return static_cast<_32BPP_BYTE_MASK>(TheStructure.Common._32BppByteMask); 3953 } 3954 inline void setInstructionTargetOpcode(const uint32_t value) { 3955 UNRECOVERABLE_IF(value > 0x7f); 3956 TheStructure.Common.InstructionTarget_Opcode = value; 3957 } 3958 inline uint32_t getInstructionTargetOpcode() const { 3959 return TheStructure.Common.InstructionTarget_Opcode; 3960 } 3961 inline void setClient(const CLIENT value) { 3962 TheStructure.Common.Client = value; 3963 } 3964 inline CLIENT getClient() const { 3965 return static_cast<CLIENT>(TheStructure.Common.Client); 3966 } 3967 inline void setDestinationPitch(const uint32_t value) { 3968 UNRECOVERABLE_IF(value > 0xffff); 3969 TheStructure.Common.DestinationPitch = value; 3970 } 3971 inline uint32_t getDestinationPitch() const { 3972 return TheStructure.Common.DestinationPitch; 3973 } 3974 inline void setRasterOperation(const uint32_t value) { 3975 UNRECOVERABLE_IF(value > 0xff); 3976 TheStructure.Common.RasterOperation = value; 3977 } 3978 inline uint32_t getRasterOperation() const { 3979 return TheStructure.Common.RasterOperation; 3980 } 3981 inline void setColorDepth(const COLOR_DEPTH value) { 3982 TheStructure.Common.ColorDepth = value; 3983 } 3984 inline COLOR_DEPTH getColorDepth() const { 3985 return static_cast<COLOR_DEPTH>(TheStructure.Common.ColorDepth); 3986 } 3987 inline void setClippingEnabled(const CLIPPING_ENABLED value) { 3988 TheStructure.Common.ClippingEnabled = value; 3989 } 3990 inline CLIPPING_ENABLED getClippingEnabled() const { 3991 return static_cast<CLIPPING_ENABLED>(TheStructure.Common.ClippingEnabled); 3992 } 3993 inline void setDestinationX1CoordinateLeft(const uint32_t value) { 3994 UNRECOVERABLE_IF(value > 0xffff); 3995 TheStructure.Common.DestinationX1Coordinate_Left = value; 3996 } 3997 inline uint32_t getDestinationX1CoordinateLeft() const { 3998 return TheStructure.Common.DestinationX1Coordinate_Left; 3999 } 4000 inline void setDestinationY1CoordinateTop(const uint32_t value) { 4001 UNRECOVERABLE_IF(value > 0xffff); 4002 TheStructure.Common.DestinationY1Coordinate_Top = value; 4003 } 4004 inline uint32_t getDestinationY1CoordinateTop() const { 4005 return TheStructure.Common.DestinationY1Coordinate_Top; 4006 } 4007 inline void setDestinationX2CoordinateRight(const uint32_t value) { 4008 UNRECOVERABLE_IF(value > 0xffff); 4009 TheStructure.Common.DestinationX2Coordinate_Right = value; 4010 } 4011 inline uint32_t getDestinationX2CoordinateRight() const { 4012 return TheStructure.Common.DestinationX2Coordinate_Right; 4013 } 4014 inline void setDestinationY2CoordinateBottom(const uint32_t value) { 4015 UNRECOVERABLE_IF(value > 0xffff); 4016 TheStructure.Common.DestinationY2Coordinate_Bottom = value; 4017 } 4018 inline uint32_t getDestinationY2CoordinateBottom() const { 4019 return TheStructure.Common.DestinationY2Coordinate_Bottom; 4020 } 4021 inline void setDestinationBaseAddress(const uint64_t value) { 4022 TheStructure.Common.DestinationBaseAddress = value; 4023 } 4024 inline uint64_t getDestinationBaseAddress() const { 4025 return TheStructure.Common.DestinationBaseAddress; 4026 } 4027 inline void setSourceX1CoordinateLeft(const uint32_t value) { 4028 UNRECOVERABLE_IF(value > 0xffff); 4029 TheStructure.Common.SourceX1Coordinate_Left = value; 4030 } 4031 inline uint32_t getSourceX1CoordinateLeft() const { 4032 return TheStructure.Common.SourceX1Coordinate_Left; 4033 } 4034 inline void setSourceY1CoordinateTop(const uint32_t value) { 4035 UNRECOVERABLE_IF(value > 0xffff); 4036 TheStructure.Common.SourceY1Coordinate_Top = value; 4037 } 4038 inline uint32_t getSourceY1CoordinateTop() const { 4039 return TheStructure.Common.SourceY1Coordinate_Top; 4040 } 4041 inline void setSourcePitch(const uint32_t value) { 4042 UNRECOVERABLE_IF(value > 0xffff); 4043 TheStructure.Common.SourcePitch = value; 4044 } 4045 inline uint32_t getSourcePitch() const { 4046 return TheStructure.Common.SourcePitch; 4047 } 4048 inline void setSourceBaseAddress(const uint64_t value) { 4049 TheStructure.Common.SourceBaseAddress = value; 4050 } 4051 inline uint64_t getSourceBaseAddress() const { 4052 return TheStructure.Common.SourceBaseAddress; 4053 } 4054} XY_SRC_COPY_BLT; 4055STATIC_ASSERT(40 == sizeof(XY_SRC_COPY_BLT)); 4056 4057typedef struct tagMI_FLUSH_DW { 4058 union tagTheStructure { 4059 struct tagCommon { 4060 // DWORD 0 4061 uint32_t DwordLength : BITFIELD_RANGE(0, 5); 4062 uint32_t Reserved_6 : BITFIELD_RANGE(6, 7); 4063 uint32_t NotifyEnable : BITFIELD_RANGE(8, 8); 4064 uint32_t FlushLlc : BITFIELD_RANGE(9, 9); 4065 uint32_t Reserved_10 : BITFIELD_RANGE(10, 13); 4066 uint32_t PostSyncOperation : BITFIELD_RANGE(14, 15); 4067 uint32_t Reserved_16 : BITFIELD_RANGE(16, 17); 4068 uint32_t TlbInvalidate : BITFIELD_RANGE(18, 18); 4069 uint32_t Reserved_19 : BITFIELD_RANGE(19, 20); 4070 uint32_t StoreDataIndex : BITFIELD_RANGE(21, 21); 4071 uint32_t Reserved_22 : BITFIELD_RANGE(22, 22); 4072 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 4073 uint32_t CommandType : BITFIELD_RANGE(29, 31); 4074 /// DWORD 1..2 4075 uint64_t Reserved_32 : BITFIELD_RANGE(0, 1); 4076 uint64_t DestinationAddressType : BITFIELD_RANGE(2, 2); 4077 uint64_t DestinationAddress : BITFIELD_RANGE(3, 47); 4078 uint64_t Reserved_80 : BITFIELD_RANGE(48, 63); 4079 /// DWORD 3..4 4080 uint64_t ImmediateData; 4081 } Common; 4082 uint32_t RawData[5]; 4083 } TheStructure; 4084 typedef enum tagDWORD_LENGTH { 4085 DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x3, 4086 } DWORD_LENGTH; 4087 typedef enum tagPOST_SYNC_OPERATION { 4088 POST_SYNC_OPERATION_NO_WRITE = 0x0, 4089 POST_SYNC_OPERATION_WRITE_IMMEDIATE_DATA_QWORD = 0x1, 4090 POST_SYNC_OPERATION_WRITE_TIMESTAMP_REGISTER = 0x3, 4091 } POST_SYNC_OPERATION; 4092 typedef enum tagMI_COMMAND_OPCODE { 4093 MI_COMMAND_OPCODE_MI_FLUSH_DW = 0x26, 4094 } MI_COMMAND_OPCODE; 4095 typedef enum tagCOMMAND_TYPE { 4096 COMMAND_TYPE_MI_COMMAND = 0x0, 4097 } COMMAND_TYPE; 4098 typedef enum tagDESTINATION_ADDRESS_TYPE { 4099 DESTINATION_ADDRESS_TYPE_PPGTT = 0x0, 4100 DESTINATION_ADDRESS_TYPE_GGTT = 0x1, 4101 } DESTINATION_ADDRESS_TYPE; 4102 inline void init() { 4103 memset(&TheStructure, 0, sizeof(TheStructure)); 4104 TheStructure.Common.DwordLength = DWORD_LENGTH::DWORD_LENGTH_EXCLUDES_DWORD_0_1; 4105 TheStructure.Common.PostSyncOperation = POST_SYNC_OPERATION_NO_WRITE; 4106 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_FLUSH_DW; 4107 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 4108 TheStructure.Common.DestinationAddressType = DESTINATION_ADDRESS_TYPE_PPGTT; 4109 } 4110 static tagMI_FLUSH_DW sInit() { 4111 MI_FLUSH_DW state; 4112 state.init(); 4113 return state; 4114 } 4115 inline uint32_t &getRawData(const uint32_t index) { 4116 UNRECOVERABLE_IF(index >= 5); 4117 return TheStructure.RawData[index]; 4118 } 4119 inline void setNotifyEnable(const bool value) { 4120 TheStructure.Common.NotifyEnable = value; 4121 } 4122 inline bool getNotifyEnable() const { 4123 return TheStructure.Common.NotifyEnable; 4124 } 4125 inline void setFlushLlc(const bool value) { 4126 TheStructure.Common.FlushLlc = value; 4127 } 4128 inline bool getFlushLlc() const { 4129 return TheStructure.Common.FlushLlc; 4130 } 4131 inline void setPostSyncOperation(const POST_SYNC_OPERATION value) { 4132 TheStructure.Common.PostSyncOperation = value; 4133 } 4134 inline POST_SYNC_OPERATION getPostSyncOperation() const { 4135 return static_cast<POST_SYNC_OPERATION>(TheStructure.Common.PostSyncOperation); 4136 } 4137 inline void setTlbInvalidate(const bool value) { 4138 TheStructure.Common.TlbInvalidate = value; 4139 } 4140 inline bool getTlbInvalidate() const { 4141 return TheStructure.Common.TlbInvalidate; 4142 } 4143 inline void setStoreDataIndex(const bool value) { 4144 TheStructure.Common.StoreDataIndex = value; 4145 } 4146 inline bool getStoreDataIndex() const { 4147 return TheStructure.Common.StoreDataIndex; 4148 } 4149 inline void setDestinationAddressType(const DESTINATION_ADDRESS_TYPE value) { 4150 TheStructure.Common.DestinationAddressType = value; 4151 } 4152 inline DESTINATION_ADDRESS_TYPE getDestinationAddressType() const { 4153 return static_cast<DESTINATION_ADDRESS_TYPE>(TheStructure.Common.DestinationAddressType); 4154 } 4155 typedef enum tagDESTINATIONADDRESS { 4156 DESTINATIONADDRESS_BIT_SHIFT = 0x3, 4157 DESTINATIONADDRESS_ALIGN_SIZE = 0x8, 4158 } DESTINATIONADDRESS; 4159 inline void setDestinationAddress(const uint64_t value) { 4160 UNRECOVERABLE_IF(value > 0xffffffffffffL); 4161 TheStructure.Common.DestinationAddress = value >> DESTINATIONADDRESS_BIT_SHIFT; 4162 } 4163 inline uint64_t getDestinationAddress() const { 4164 return TheStructure.Common.DestinationAddress << DESTINATIONADDRESS_BIT_SHIFT; 4165 } 4166 inline void setImmediateData(const uint64_t value) { 4167 TheStructure.Common.ImmediateData = value; 4168 } 4169 inline uint64_t getImmediateData() const { 4170 return TheStructure.Common.ImmediateData; 4171 } 4172} MI_FLUSH_DW; 4173STATIC_ASSERT(20 == sizeof(MI_FLUSH_DW)); 4174 4175typedef struct tagGRF { 4176 union tagTheStructure { 4177 float fRegs[8]; 4178 uint32_t dwRegs[8]; 4179 uint16_t wRegs[16]; 4180 uint32_t RawData[8]; 4181 } TheStructure; 4182} GRF; 4183STATIC_ASSERT(32 == sizeof(GRF)); 4184 4185typedef struct tagMEDIA_SURFACE_STATE { 4186 union tagTheStructure { 4187 struct tagCommon { 4188 // DWORD 0 4189 uint32_t Reserved_0 : BITFIELD_RANGE(0, 29); 4190 uint32_t Rotation : BITFIELD_RANGE(30, 31); 4191 // DWORD 1 4192 uint32_t Cr_VCb_UPixelOffsetVDirection : BITFIELD_RANGE(0, 1); 4193 uint32_t PictureStructure : BITFIELD_RANGE(2, 3); 4194 uint32_t Width : BITFIELD_RANGE(4, 17); 4195 uint32_t Height : BITFIELD_RANGE(18, 31); 4196 // DWORD 2 4197 uint32_t TileMode : BITFIELD_RANGE(0, 1); 4198 uint32_t HalfPitchForChroma : BITFIELD_RANGE(2, 2); 4199 uint32_t SurfacePitch : BITFIELD_RANGE(3, 20); 4200 uint32_t AddressControl : BITFIELD_RANGE(21, 21); 4201 uint32_t MemoryCompressionEnable : BITFIELD_RANGE(22, 22); 4202 uint32_t MemoryCompressionType : BITFIELD_RANGE(23, 23); 4203 uint32_t Cr_VCb_UPixelOffsetVDirectionMsb : BITFIELD_RANGE(24, 24); 4204 uint32_t Cr_VCb_UPixelOffsetUDirection : BITFIELD_RANGE(25, 25); 4205 uint32_t InterleaveChroma : BITFIELD_RANGE(26, 26); 4206 uint32_t SurfaceFormat : BITFIELD_RANGE(27, 31); 4207 // DWORD 3 4208 uint32_t YOffsetForU_Cb : BITFIELD_RANGE(0, 13); 4209 uint32_t Reserved_110 : BITFIELD_RANGE(14, 15); 4210 uint32_t XOffsetForU_Cb : BITFIELD_RANGE(16, 29); 4211 uint32_t Reserved_126 : BITFIELD_RANGE(30, 31); 4212 // DWORD 4 4213 uint32_t Reserved_128; 4214 // DWORD 5 4215 uint32_t SurfaceMemoryObjectControlStateReserved_160 : BITFIELD_RANGE(0, 0); 4216 uint32_t SurfaceMemoryObjectControlStateIndexToMocsTables : BITFIELD_RANGE(1, 6); 4217 uint32_t Reserved_167 : BITFIELD_RANGE(7, 17); 4218 uint32_t TiledResourceMode : BITFIELD_RANGE(18, 19); 4219 uint32_t Reserved_180 : BITFIELD_RANGE(20, 29); 4220 uint32_t VerticalLineStrideOffset : BITFIELD_RANGE(30, 30); 4221 uint32_t VerticalLineStride : BITFIELD_RANGE(31, 31); 4222 // DWORD 6 4223 uint32_t SurfaceBaseAddressLow; 4224 // DWORD 7 4225 uint32_t SurfaceBaseAddressHigh : BITFIELD_RANGE(0, 15); 4226 uint32_t Reserved_240 : BITFIELD_RANGE(16, 31); 4227 } Common; 4228 struct tagSurfaceFormatIsOneOfPlanarFormats { 4229 // DWORD 0 4230 uint32_t Reserved_0 : BITFIELD_RANGE(0, 15); 4231 uint32_t YOffset : BITFIELD_RANGE(16, 19); 4232 uint32_t XOffset : BITFIELD_RANGE(20, 26); 4233 uint32_t Reserved_27 : BITFIELD_RANGE(27, 31); 4234 // DWORD 1 4235 uint32_t Reserved_32; 4236 // DWORD 2 4237 uint32_t Reserved_64; 4238 // DWORD 3 4239 uint32_t Reserved_96; 4240 // DWORD 4 4241 uint32_t Reserved_128; 4242 // DWORD 5 4243 uint32_t Reserved_160; 4244 // DWORD 6 4245 uint32_t Reserved_192; 4246 // DWORD 7 4247 uint32_t Reserved_224; 4248 } SurfaceFormatIsOneOfPlanarFormats; 4249 struct tag_SurfaceFormatIsOneOfPlanarAnd_InterleaveChromaIs0 { 4250 // DWORD 0 4251 uint32_t Reserved_0; 4252 // DWORD 1 4253 uint32_t Reserved_32; 4254 // DWORD 2 4255 uint32_t Reserved_64; 4256 // DWORD 3 4257 uint32_t Reserved_96; 4258 // DWORD 4 4259 uint32_t YOffsetForV_Cr : BITFIELD_RANGE(0, 14); 4260 uint32_t Reserved_143 : BITFIELD_RANGE(15, 15); 4261 uint32_t XOffsetForV_Cr : BITFIELD_RANGE(16, 29); 4262 uint32_t Reserved_158 : BITFIELD_RANGE(30, 31); 4263 // DWORD 5 4264 uint32_t Reserved_160; 4265 // DWORD 6 4266 uint32_t Reserved_192; 4267 // DWORD 7 4268 uint32_t Reserved_224; 4269 } _SurfaceFormatIsOneOfPlanarAnd_InterleaveChromaIs0; 4270 uint32_t RawData[8]; 4271 } TheStructure; 4272 typedef enum tagROTATION { 4273 ROTATION_NO_ROTATION_OR_0_DEGREE = 0x0, 4274 ROTATION_90_DEGREE_ROTATION = 0x1, 4275 ROTATION_180_DEGREE_ROTATION = 0x2, 4276 ROTATION_270_DEGREE_ROTATION = 0x3, 4277 } ROTATION; 4278 typedef enum tagPICTURE_STRUCTURE { 4279 PICTURE_STRUCTURE_FRAME_PICTURE = 0x0, 4280 PICTURE_STRUCTURE_TOP_FIELD_PICTURE = 0x1, 4281 PICTURE_STRUCTURE_BOTTOM_FIELD_PICTURE = 0x2, 4282 PICTURE_STRUCTURE_INVALID_NOT_ALLOWED = 0x3, 4283 } PICTURE_STRUCTURE; 4284 typedef enum tagTILE_MODE { 4285 TILE_MODE_TILEMODE_LINEAR = 0x0, 4286 TILE_MODE_TILEMODE_XMAJOR = 0x2, 4287 TILE_MODE_TILEMODE_YMAJOR = 0x3, 4288 } TILE_MODE; 4289 typedef enum tagADDRESS_CONTROL { 4290 ADDRESS_CONTROL_CLAMP = 0x0, 4291 ADDRESS_CONTROL_MIRROR = 0x1, 4292 } ADDRESS_CONTROL; 4293 typedef enum tagMEMORY_COMPRESSION_TYPE { 4294 MEMORY_COMPRESSION_TYPE_MEDIA_COMPRESSION = 0x0, 4295 MEMORY_COMPRESSION_TYPE_RENDER_COMPRESSION = 0x1, 4296 } MEMORY_COMPRESSION_TYPE; 4297 typedef enum tagSURFACE_FORMAT { 4298 SURFACE_FORMAT_YCRCB_NORMAL = 0x0, 4299 SURFACE_FORMAT_YCRCB_SWAPUVY = 0x1, 4300 SURFACE_FORMAT_YCRCB_SWAPUV = 0x2, 4301 SURFACE_FORMAT_YCRCB_SWAPY = 0x3, 4302 SURFACE_FORMAT_PLANAR_420_8 = 0x4, 4303 SURFACE_FORMAT_Y8_UNORM_VA = 0x5, 4304 SURFACE_FORMAT_R10G10B10A2_UNORM = 0x8, 4305 SURFACE_FORMAT_R8G8B8A8_UNORM = 0x9, 4306 SURFACE_FORMAT_R8B8_UNORM_CRCB = 0xa, 4307 SURFACE_FORMAT_R8_UNORM_CRCB = 0xb, 4308 SURFACE_FORMAT_Y8_UNORM = 0xc, 4309 SURFACE_FORMAT_A8Y8U8V8_UNORM = 0xd, 4310 SURFACE_FORMAT_B8G8R8A8_UNORM = 0xe, 4311 SURFACE_FORMAT_R16G16B16A16 = 0xf, 4312 SURFACE_FORMAT_Y1_UNORM = 0x10, 4313 SURFACE_FORMAT_PLANAR_422_8 = 0x12, 4314 SURFACE_FORMAT_PLANAR_420_16 = 0x17, 4315 SURFACE_FORMAT_R16B16_UNORM_CRCB = 0x18, 4316 SURFACE_FORMAT_R16_UNORM_CRCB = 0x19, 4317 SURFACE_FORMAT_Y16_UNORM = 0x1a, 4318 } SURFACE_FORMAT; 4319 typedef enum tagTILED_RESOURCE_MODE { 4320 TILED_RESOURCE_MODE_TRMODE_NONE = 0x0, 4321 TILED_RESOURCE_MODE_TRMODE_TILEYF = 0x1, 4322 TILED_RESOURCE_MODE_TRMODE_TILEYS = 0x2, 4323 } TILED_RESOURCE_MODE; 4324 inline void init() { 4325 memset(&TheStructure, 0, sizeof(TheStructure)); 4326 TheStructure.Common.Rotation = ROTATION_NO_ROTATION_OR_0_DEGREE; 4327 TheStructure.Common.PictureStructure = PICTURE_STRUCTURE_FRAME_PICTURE; 4328 TheStructure.Common.TileMode = TILE_MODE_TILEMODE_LINEAR; 4329 TheStructure.Common.AddressControl = ADDRESS_CONTROL_CLAMP; 4330 TheStructure.Common.MemoryCompressionType = MEMORY_COMPRESSION_TYPE_MEDIA_COMPRESSION; 4331 TheStructure.Common.SurfaceFormat = SURFACE_FORMAT_YCRCB_NORMAL; 4332 TheStructure.Common.TiledResourceMode = TILED_RESOURCE_MODE_TRMODE_NONE; 4333 } 4334 static tagMEDIA_SURFACE_STATE sInit() { 4335 MEDIA_SURFACE_STATE state; 4336 state.init(); 4337 return state; 4338 } 4339 inline uint32_t &getRawData(const uint32_t index) { 4340 UNRECOVERABLE_IF(index >= 8); 4341 return TheStructure.RawData[index]; 4342 } 4343 inline void setRotation(const ROTATION value) { 4344 TheStructure.Common.Rotation = value; 4345 } 4346 inline ROTATION getRotation() const { 4347 return static_cast<ROTATION>(TheStructure.Common.Rotation); 4348 } 4349 inline void setCrVCbUPixelOffsetVDirection(const uint32_t value) { 4350 UNRECOVERABLE_IF(value > 0x3); 4351 TheStructure.Common.Cr_VCb_UPixelOffsetVDirection = value; 4352 } 4353 inline uint32_t getCrVCbUPixelOffsetVDirection() const { 4354 return TheStructure.Common.Cr_VCb_UPixelOffsetVDirection; 4355 } 4356 inline void setPictureStructure(const PICTURE_STRUCTURE value) { 4357 TheStructure.Common.PictureStructure = value; 4358 } 4359 inline PICTURE_STRUCTURE getPictureStructure() const { 4360 return static_cast<PICTURE_STRUCTURE>(TheStructure.Common.PictureStructure); 4361 } 4362 inline void setWidth(const uint32_t value) { 4363 UNRECOVERABLE_IF(value > 0x3fff); 4364 TheStructure.Common.Width = value - 1; 4365 } 4366 inline uint32_t getWidth() const { 4367 return TheStructure.Common.Width + 1; 4368 } 4369 inline void setHeight(const uint32_t value) { 4370 UNRECOVERABLE_IF(value > 0x3fff); 4371 TheStructure.Common.Height = value - 1; 4372 } 4373 inline uint32_t getHeight() const { 4374 return TheStructure.Common.Height + 1; 4375 } 4376 inline void setTileMode(const TILE_MODE value) { 4377 TheStructure.Common.TileMode = value; 4378 } 4379 inline TILE_MODE getTileMode() const { 4380 return static_cast<TILE_MODE>(TheStructure.Common.TileMode); 4381 } 4382 inline void setHalfPitchForChroma(const bool value) { 4383 TheStructure.Common.HalfPitchForChroma = value; 4384 } 4385 inline bool getHalfPitchForChroma() const { 4386 return TheStructure.Common.HalfPitchForChroma; 4387 } 4388 inline void setSurfacePitch(const uint32_t value) { 4389 UNRECOVERABLE_IF(value > 0x3ffff); 4390 TheStructure.Common.SurfacePitch = value - 1; 4391 } 4392 inline uint32_t getSurfacePitch() const { 4393 return TheStructure.Common.SurfacePitch + 1; 4394 } 4395 inline void setAddressControl(const ADDRESS_CONTROL value) { 4396 TheStructure.Common.AddressControl = value; 4397 } 4398 inline ADDRESS_CONTROL getAddressControl() const { 4399 return static_cast<ADDRESS_CONTROL>(TheStructure.Common.AddressControl); 4400 } 4401 inline void setMemoryCompressionEnable(const bool value) { 4402 TheStructure.Common.MemoryCompressionEnable = value; 4403 } 4404 inline bool getMemoryCompressionEnable() const { 4405 return TheStructure.Common.MemoryCompressionEnable; 4406 } 4407 inline void setMemoryCompressionType(const MEMORY_COMPRESSION_TYPE value) { 4408 TheStructure.Common.MemoryCompressionType = value; 4409 } 4410 inline MEMORY_COMPRESSION_TYPE getMemoryCompressionType() const { 4411 return static_cast<MEMORY_COMPRESSION_TYPE>(TheStructure.Common.MemoryCompressionType); 4412 } 4413 inline void setCrVCbUPixelOffsetVDirectionMsb(const bool value) { 4414 TheStructure.Common.Cr_VCb_UPixelOffsetVDirectionMsb = value; 4415 } 4416 inline bool getCrVCbUPixelOffsetVDirectionMsb() const { 4417 return TheStructure.Common.Cr_VCb_UPixelOffsetVDirectionMsb; 4418 } 4419 inline void setCrVCbUPixelOffsetUDirection(const bool value) { 4420 TheStructure.Common.Cr_VCb_UPixelOffsetUDirection = value; 4421 } 4422 inline bool getCrVCbUPixelOffsetUDirection() const { 4423 return TheStructure.Common.Cr_VCb_UPixelOffsetUDirection; 4424 } 4425 inline void setInterleaveChroma(const bool value) { 4426 TheStructure.Common.InterleaveChroma = value; 4427 } 4428 inline bool getInterleaveChroma() const { 4429 return TheStructure.Common.InterleaveChroma; 4430 } 4431 inline void setSurfaceFormat(const SURFACE_FORMAT value) { 4432 TheStructure.Common.SurfaceFormat = value; 4433 } 4434 inline SURFACE_FORMAT getSurfaceFormat() const { 4435 return static_cast<SURFACE_FORMAT>(TheStructure.Common.SurfaceFormat); 4436 } 4437 inline void setYOffsetForUCb(const uint32_t value) { 4438 UNRECOVERABLE_IF(value > 0x3fff); 4439 TheStructure.Common.YOffsetForU_Cb = value; 4440 } 4441 inline uint32_t getYOffsetForUCb() const { 4442 return TheStructure.Common.YOffsetForU_Cb; 4443 } 4444 inline void setXOffsetForUCb(const uint32_t value) { 4445 UNRECOVERABLE_IF(value > 0x3fff); 4446 TheStructure.Common.XOffsetForU_Cb = value; 4447 } 4448 inline uint32_t getXOffsetForUCb() const { 4449 return TheStructure.Common.XOffsetForU_Cb; 4450 } 4451 inline void setSurfaceMemoryObjectControlState(const uint32_t value) { 4452 UNRECOVERABLE_IF(value > 0x3f); 4453 TheStructure.Common.SurfaceMemoryObjectControlStateIndexToMocsTables = value >> 1; 4454 } 4455 inline uint32_t getSurfaceMemoryObjectControlState() const { 4456 return TheStructure.Common.SurfaceMemoryObjectControlStateIndexToMocsTables << 1; 4457 } 4458 inline void setTiledResourceMode(const TILED_RESOURCE_MODE value) { 4459 TheStructure.Common.TiledResourceMode = value; 4460 } 4461 inline TILED_RESOURCE_MODE getTiledResourceMode() const { 4462 return static_cast<TILED_RESOURCE_MODE>(TheStructure.Common.TiledResourceMode); 4463 } 4464 inline void setVerticalLineStrideOffset(const bool value) { 4465 TheStructure.Common.VerticalLineStrideOffset = value; 4466 } 4467 inline bool getVerticalLineStrideOffset() const { 4468 return TheStructure.Common.VerticalLineStrideOffset; 4469 } 4470 inline void setVerticalLineStride(const bool value) { 4471 TheStructure.Common.VerticalLineStride = value; 4472 } 4473 inline bool getVerticalLineStride() const { 4474 return TheStructure.Common.VerticalLineStride; 4475 } 4476 inline void setSurfaceBaseAddress(const uint64_t value) { 4477 TheStructure.Common.SurfaceBaseAddressLow = static_cast<uint32_t>(value & 0xffffffff); 4478 TheStructure.Common.SurfaceBaseAddressHigh = (value >> 32) & 0xffffffff; 4479 } 4480 inline uint64_t getSurfaceBaseAddress() const { 4481 return (TheStructure.Common.SurfaceBaseAddressLow | 4482 static_cast<uint64_t>(TheStructure.Common.SurfaceBaseAddressHigh) << 32); 4483 } 4484 inline void setSurfaceBaseAddressHigh(const uint32_t value) { 4485 UNRECOVERABLE_IF(value > 0xffff); 4486 TheStructure.Common.SurfaceBaseAddressHigh = value; 4487 } 4488 inline uint32_t getSurfaceBaseAddressHigh() const { 4489 return TheStructure.Common.SurfaceBaseAddressHigh; 4490 } 4491 inline void setYOffset(const uint32_t value) { 4492 UNRECOVERABLE_IF(value > 0xf); 4493 TheStructure.SurfaceFormatIsOneOfPlanarFormats.YOffset = value; 4494 } 4495 inline uint32_t getYOffset() const { 4496 return TheStructure.SurfaceFormatIsOneOfPlanarFormats.YOffset; 4497 } 4498 inline void setXOffset(const uint32_t value) { 4499 UNRECOVERABLE_IF(value > 0x7f); 4500 TheStructure.SurfaceFormatIsOneOfPlanarFormats.XOffset = value; 4501 } 4502 inline uint32_t getXOffset() const { 4503 return TheStructure.SurfaceFormatIsOneOfPlanarFormats.XOffset; 4504 } 4505 inline void setYOffsetForVCr(const uint32_t value) { 4506 UNRECOVERABLE_IF(value > 0x7fff); 4507 TheStructure._SurfaceFormatIsOneOfPlanarAnd_InterleaveChromaIs0.YOffsetForV_Cr = value; 4508 } 4509 inline uint32_t getYOffsetForVCr() const { 4510 return TheStructure._SurfaceFormatIsOneOfPlanarAnd_InterleaveChromaIs0.YOffsetForV_Cr; 4511 } 4512 inline void setXOffsetForVCr(const uint32_t value) { 4513 UNRECOVERABLE_IF(value > 0x3fff); 4514 TheStructure._SurfaceFormatIsOneOfPlanarAnd_InterleaveChromaIs0.XOffsetForV_Cr = value; 4515 } 4516 inline uint32_t getXOffsetForVCr() const { 4517 return TheStructure._SurfaceFormatIsOneOfPlanarAnd_InterleaveChromaIs0.XOffsetForV_Cr; 4518 } 4519} MEDIA_SURFACE_STATE; 4520STATIC_ASSERT(32 == sizeof(MEDIA_SURFACE_STATE)); 4521 4522typedef struct tagMI_MATH { 4523 union _DW0 { 4524 struct _BitField { 4525 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 4526 uint32_t Reserved : BITFIELD_RANGE(8, 22); 4527 uint32_t InstructionOpcode : BITFIELD_RANGE(23, 28); 4528 uint32_t InstructionType : BITFIELD_RANGE(29, 31); 4529 } BitField; 4530 uint32_t Value; 4531 } DW0; 4532 typedef enum tagMI_COMMAND_OPCODE { 4533 MI_COMMAND_OPCODE_MI_MATH = 0x1A, 4534 } MI_COMMAND_OPCODE; 4535 typedef enum tagCOMMAND_TYPE { 4536 COMMAND_TYPE_MI_COMMAND = 0x0, 4537 } COMMAND_TYPE; 4538} MI_MATH; 4539 4540typedef struct tagMI_MATH_ALU_INST_INLINE { 4541 union _DW0 { 4542 struct _BitField { 4543 uint32_t Operand2 : BITFIELD_RANGE(0, 9); 4544 uint32_t Operand1 : BITFIELD_RANGE(10, 19); 4545 uint32_t ALUOpcode : BITFIELD_RANGE(20, 31); 4546 } BitField; 4547 uint32_t Value; 4548 } DW0; 4549} MI_MATH_ALU_INST_INLINE; 4550 4551typedef struct tagPIPE_CONTROL { 4552 union tagTheStructure { 4553 struct tagCommon { 4554 // DWORD 0 4555 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 4556 uint32_t Reserved_8 : BITFIELD_RANGE(8, 8); 4557 uint32_t HdcPipelineFlush : BITFIELD_RANGE(9, 9); 4558 uint32_t Reserved_10 : BITFIELD_RANGE(10, 15); 4559 uint32_t _3DCommandSubOpcode : BITFIELD_RANGE(16, 23); 4560 uint32_t _3DCommandOpcode : BITFIELD_RANGE(24, 26); 4561 uint32_t CommandSubtype : BITFIELD_RANGE(27, 28); 4562 uint32_t CommandType : BITFIELD_RANGE(29, 31); 4563 // DWORD 1 4564 uint32_t DepthCacheFlushEnable : BITFIELD_RANGE(0, 0); 4565 uint32_t StallAtPixelScoreboard : BITFIELD_RANGE(1, 1); 4566 uint32_t StateCacheInvalidationEnable : BITFIELD_RANGE(2, 2); 4567 uint32_t ConstantCacheInvalidationEnable : BITFIELD_RANGE(3, 3); 4568 uint32_t VfCacheInvalidationEnable : BITFIELD_RANGE(4, 4); 4569 uint32_t DcFlushEnable : BITFIELD_RANGE(5, 5); 4570 uint32_t ProtectedMemoryApplicationId : BITFIELD_RANGE(6, 6); 4571 uint32_t PipeControlFlushEnable : BITFIELD_RANGE(7, 7); 4572 uint32_t NotifyEnable : BITFIELD_RANGE(8, 8); 4573 uint32_t IndirectStatePointersDisable : BITFIELD_RANGE(9, 9); 4574 uint32_t TextureCacheInvalidationEnable : BITFIELD_RANGE(10, 10); 4575 uint32_t InstructionCacheInvalidateEnable : BITFIELD_RANGE(11, 11); 4576 uint32_t RenderTargetCacheFlushEnable : BITFIELD_RANGE(12, 12); 4577 uint32_t DepthStallEnable : BITFIELD_RANGE(13, 13); 4578 uint32_t PostSyncOperation : BITFIELD_RANGE(14, 15); 4579 uint32_t GenericMediaStateClear : BITFIELD_RANGE(16, 16); 4580 uint32_t PsdSyncEnable : BITFIELD_RANGE(17, 17); 4581 uint32_t TlbInvalidate : BITFIELD_RANGE(18, 18); 4582 uint32_t GlobalSnapshotCountReset : BITFIELD_RANGE(19, 19); 4583 uint32_t CommandStreamerStallEnable : BITFIELD_RANGE(20, 20); 4584 uint32_t StoreDataIndex : BITFIELD_RANGE(21, 21); 4585 uint32_t Reserved_54 : BITFIELD_RANGE(22, 22); 4586 uint32_t LriPostSyncOperation : BITFIELD_RANGE(23, 23); 4587 uint32_t DestinationAddressType : BITFIELD_RANGE(24, 24); 4588 uint32_t AmfsFlushEnable : BITFIELD_RANGE(25, 25); 4589 uint32_t FlushLlc : BITFIELD_RANGE(26, 26); 4590 uint32_t ProtectedMemoryDisable : BITFIELD_RANGE(27, 27); 4591 uint32_t TileCacheFlushEnable : BITFIELD_RANGE(28, 28); 4592 uint32_t CommandCacheInvalidateEnable : BITFIELD_RANGE(29, 29); 4593 uint32_t L3FabricFlush : BITFIELD_RANGE(30, 30); 4594 uint32_t Reserved_63 : BITFIELD_RANGE(31, 31); 4595 // DWORD 2 4596 uint32_t Reserved_64 : BITFIELD_RANGE(0, 1); 4597 uint32_t Address : BITFIELD_RANGE(2, 31); 4598 // DWORD 3 4599 uint32_t AddressHigh; 4600 // DWORD 4-5 4601 uint64_t ImmediateData; 4602 } Common; 4603 uint32_t RawData[6]; 4604 } TheStructure; 4605 typedef enum tagDWORD_LENGTH { 4606 DWORD_LENGTH_DWORD_COUNT_N = 0x4, 4607 } DWORD_LENGTH; 4608 typedef enum tag_3D_COMMAND_SUB_OPCODE { 4609 _3D_COMMAND_SUB_OPCODE_PIPE_CONTROL = 0x0, 4610 } _3D_COMMAND_SUB_OPCODE; 4611 typedef enum tag_3D_COMMAND_OPCODE { 4612 _3D_COMMAND_OPCODE_PIPE_CONTROL = 0x2, 4613 } _3D_COMMAND_OPCODE; 4614 typedef enum tagCOMMAND_SUBTYPE { 4615 COMMAND_SUBTYPE_GFXPIPE_3D = 0x3, 4616 } COMMAND_SUBTYPE; 4617 typedef enum tagCOMMAND_TYPE { 4618 COMMAND_TYPE_GFXPIPE = 0x3, 4619 } COMMAND_TYPE; 4620 typedef enum tagPOST_SYNC_OPERATION { 4621 POST_SYNC_OPERATION_NO_WRITE = 0x0, 4622 POST_SYNC_OPERATION_WRITE_IMMEDIATE_DATA = 0x1, 4623 POST_SYNC_OPERATION_WRITE_PS_DEPTH_COUNT = 0x2, 4624 POST_SYNC_OPERATION_WRITE_TIMESTAMP = 0x3, 4625 } POST_SYNC_OPERATION; 4626 typedef enum tagGLOBAL_SNAPSHOT_COUNT_RESET { 4627 GLOBAL_SNAPSHOT_COUNT_RESET_DONT_RESET = 0x0, 4628 GLOBAL_SNAPSHOT_COUNT_RESET_RESET = 0x1, 4629 } GLOBAL_SNAPSHOT_COUNT_RESET; 4630 typedef enum tagLRI_POST_SYNC_OPERATION { 4631 LRI_POST_SYNC_OPERATION_NO_LRI_OPERATION = 0x0, 4632 LRI_POST_SYNC_OPERATION_MMIO_WRITE_IMMEDIATE_DATA = 0x1, 4633 } LRI_POST_SYNC_OPERATION; 4634 typedef enum tagDESTINATION_ADDRESS_TYPE { 4635 DESTINATION_ADDRESS_TYPE_PPGTT = 0x0, 4636 DESTINATION_ADDRESS_TYPE_GGTT = 0x1, 4637 } DESTINATION_ADDRESS_TYPE; 4638 inline void init() { 4639 memset(&TheStructure, 0, sizeof(TheStructure)); 4640 TheStructure.Common.DwordLength = DWORD_LENGTH_DWORD_COUNT_N; 4641 TheStructure.Common._3DCommandSubOpcode = _3D_COMMAND_SUB_OPCODE_PIPE_CONTROL; 4642 TheStructure.Common._3DCommandOpcode = _3D_COMMAND_OPCODE_PIPE_CONTROL; 4643 TheStructure.Common.CommandSubtype = COMMAND_SUBTYPE_GFXPIPE_3D; 4644 TheStructure.Common.CommandType = COMMAND_TYPE_GFXPIPE; 4645 TheStructure.Common.PostSyncOperation = POST_SYNC_OPERATION_NO_WRITE; 4646 TheStructure.Common.GlobalSnapshotCountReset = GLOBAL_SNAPSHOT_COUNT_RESET_DONT_RESET; 4647 TheStructure.Common.LriPostSyncOperation = LRI_POST_SYNC_OPERATION_NO_LRI_OPERATION; 4648 TheStructure.Common.DestinationAddressType = DESTINATION_ADDRESS_TYPE_PPGTT; 4649 TheStructure.Common.CommandStreamerStallEnable = 1u; 4650 } 4651 static tagPIPE_CONTROL sInit() { 4652 PIPE_CONTROL state; 4653 state.init(); 4654 return state; 4655 } 4656 inline uint32_t &getRawData(const uint32_t index) { 4657 UNRECOVERABLE_IF(index >= 6); 4658 return TheStructure.RawData[index]; 4659 } 4660 inline void setHdcPipelineFlush(const bool value) { 4661 TheStructure.Common.HdcPipelineFlush = value; 4662 } 4663 inline bool getHdcPipelineFlush() const { 4664 return TheStructure.Common.HdcPipelineFlush; 4665 } 4666 inline void setDepthCacheFlushEnable(const bool value) { 4667 TheStructure.Common.DepthCacheFlushEnable = value; 4668 } 4669 inline bool getDepthCacheFlushEnable() const { 4670 return TheStructure.Common.DepthCacheFlushEnable; 4671 } 4672 inline void setStallAtPixelScoreboard(const bool value) { 4673 TheStructure.Common.StallAtPixelScoreboard = value; 4674 } 4675 inline bool getStallAtPixelScoreboard() const { 4676 return TheStructure.Common.StallAtPixelScoreboard; 4677 } 4678 inline void setStateCacheInvalidationEnable(const bool value) { 4679 TheStructure.Common.StateCacheInvalidationEnable = value; 4680 } 4681 inline bool getStateCacheInvalidationEnable() const { 4682 return TheStructure.Common.StateCacheInvalidationEnable; 4683 } 4684 inline void setConstantCacheInvalidationEnable(const bool value) { 4685 TheStructure.Common.ConstantCacheInvalidationEnable = value; 4686 } 4687 inline bool getConstantCacheInvalidationEnable() const { 4688 return TheStructure.Common.ConstantCacheInvalidationEnable; 4689 } 4690 inline void setVfCacheInvalidationEnable(const bool value) { 4691 TheStructure.Common.VfCacheInvalidationEnable = value; 4692 } 4693 inline bool getVfCacheInvalidationEnable() const { 4694 return TheStructure.Common.VfCacheInvalidationEnable; 4695 } 4696 inline void setDcFlushEnable(const bool value) { 4697 TheStructure.Common.DcFlushEnable = value; 4698 } 4699 inline bool getDcFlushEnable() const { 4700 return TheStructure.Common.DcFlushEnable; 4701 } 4702 inline void setProtectedMemoryApplicationId(const uint32_t value) { 4703 TheStructure.Common.ProtectedMemoryApplicationId = value; 4704 } 4705 inline uint32_t getProtectedMemoryApplicationId() const { 4706 return (TheStructure.Common.ProtectedMemoryApplicationId); 4707 } 4708 inline void setPipeControlFlushEnable(const bool value) { 4709 TheStructure.Common.PipeControlFlushEnable = value; 4710 } 4711 inline bool getPipeControlFlushEnable() const { 4712 return TheStructure.Common.PipeControlFlushEnable; 4713 } 4714 inline void setNotifyEnable(const bool value) { 4715 TheStructure.Common.NotifyEnable = value; 4716 } 4717 inline bool getNotifyEnable() const { 4718 return TheStructure.Common.NotifyEnable; 4719 } 4720 inline void setIndirectStatePointersDisable(const bool value) { 4721 TheStructure.Common.IndirectStatePointersDisable = value; 4722 } 4723 inline bool getIndirectStatePointersDisable() const { 4724 return TheStructure.Common.IndirectStatePointersDisable; 4725 } 4726 inline void setTextureCacheInvalidationEnable(const bool value) { 4727 TheStructure.Common.TextureCacheInvalidationEnable = value; 4728 } 4729 inline bool getTextureCacheInvalidationEnable() const { 4730 return TheStructure.Common.TextureCacheInvalidationEnable; 4731 } 4732 inline void setInstructionCacheInvalidateEnable(const bool value) { 4733 TheStructure.Common.InstructionCacheInvalidateEnable = value; 4734 } 4735 inline bool getInstructionCacheInvalidateEnable() const { 4736 return TheStructure.Common.InstructionCacheInvalidateEnable; 4737 } 4738 inline void setRenderTargetCacheFlushEnable(const bool value) { 4739 TheStructure.Common.RenderTargetCacheFlushEnable = value; 4740 } 4741 inline bool getRenderTargetCacheFlushEnable() const { 4742 return TheStructure.Common.RenderTargetCacheFlushEnable; 4743 } 4744 inline void setDepthStallEnable(const bool value) { 4745 TheStructure.Common.DepthStallEnable = value; 4746 } 4747 inline bool getDepthStallEnable() const { 4748 return TheStructure.Common.DepthStallEnable; 4749 } 4750 inline void setPostSyncOperation(const POST_SYNC_OPERATION value) { 4751 TheStructure.Common.PostSyncOperation = value; 4752 } 4753 inline POST_SYNC_OPERATION getPostSyncOperation() const { 4754 return static_cast<POST_SYNC_OPERATION>(TheStructure.Common.PostSyncOperation); 4755 } 4756 inline void setGenericMediaStateClear(const bool value) { 4757 TheStructure.Common.GenericMediaStateClear = value; 4758 } 4759 inline bool getGenericMediaStateClear() const { 4760 return TheStructure.Common.GenericMediaStateClear; 4761 } 4762 inline void setPsdSyncEnable(const bool value) { 4763 TheStructure.Common.PsdSyncEnable = value; 4764 } 4765 inline bool getPsdSyncEnable() const { 4766 return TheStructure.Common.PsdSyncEnable; 4767 } 4768 inline void setTlbInvalidate(const bool value) { 4769 TheStructure.Common.TlbInvalidate = value; 4770 } 4771 inline bool getTlbInvalidate() const { 4772 return TheStructure.Common.TlbInvalidate; 4773 } 4774 inline void setGlobalSnapshotCountReset(const GLOBAL_SNAPSHOT_COUNT_RESET value) { 4775 TheStructure.Common.GlobalSnapshotCountReset = value; 4776 } 4777 inline GLOBAL_SNAPSHOT_COUNT_RESET getGlobalSnapshotCountReset() const { 4778 return static_cast<GLOBAL_SNAPSHOT_COUNT_RESET>(TheStructure.Common.GlobalSnapshotCountReset); 4779 } 4780 inline void setCommandStreamerStallEnable(const bool value) { 4781 TheStructure.Common.CommandStreamerStallEnable = value; 4782 } 4783 inline bool getCommandStreamerStallEnable() const { 4784 return TheStructure.Common.CommandStreamerStallEnable; 4785 } 4786 inline void setStoreDataIndex(const bool value) { 4787 TheStructure.Common.StoreDataIndex = value; 4788 } 4789 inline bool getStoreDataIndex() const { 4790 return TheStructure.Common.StoreDataIndex; 4791 } 4792 inline void setLriPostSyncOperation(const LRI_POST_SYNC_OPERATION value) { 4793 TheStructure.Common.LriPostSyncOperation = value; 4794 } 4795 inline LRI_POST_SYNC_OPERATION getLriPostSyncOperation() const { 4796 return static_cast<LRI_POST_SYNC_OPERATION>(TheStructure.Common.LriPostSyncOperation); 4797 } 4798 inline void setDestinationAddressType(const DESTINATION_ADDRESS_TYPE value) { 4799 TheStructure.Common.DestinationAddressType = value; 4800 } 4801 inline DESTINATION_ADDRESS_TYPE getDestinationAddressType() const { 4802 return static_cast<DESTINATION_ADDRESS_TYPE>(TheStructure.Common.DestinationAddressType); 4803 } 4804 inline void setAmfsFlushEnable(const bool value) { 4805 TheStructure.Common.AmfsFlushEnable = value; 4806 } 4807 inline bool getAmfsFlushEnable() const { 4808 return TheStructure.Common.AmfsFlushEnable; 4809 } 4810 inline void setFlushLlc(const bool value) { 4811 TheStructure.Common.FlushLlc = value; 4812 } 4813 inline bool getFlushLlc() const { 4814 return TheStructure.Common.FlushLlc; 4815 } 4816 inline void setProtectedMemoryDisable(const uint32_t value) { 4817 TheStructure.Common.ProtectedMemoryDisable = value; 4818 } 4819 inline uint32_t getProtectedMemoryDisable() const { 4820 return (TheStructure.Common.ProtectedMemoryDisable); 4821 } 4822 inline void setTileCacheFlushEnable(const bool value) { 4823 TheStructure.Common.TileCacheFlushEnable = value; 4824 } 4825 inline bool getTileCacheFlushEnable() const { 4826 return TheStructure.Common.TileCacheFlushEnable; 4827 } 4828 inline void setCommandCacheInvalidateEnable(const bool value) { 4829 TheStructure.Common.CommandCacheInvalidateEnable = value; 4830 } 4831 inline bool getCommandCacheInvalidateEnable() const { 4832 return TheStructure.Common.CommandCacheInvalidateEnable; 4833 } 4834 inline void setL3FabricFlush(const bool value) { 4835 TheStructure.Common.L3FabricFlush = value; 4836 } 4837 inline bool getL3FabricFlush() const { 4838 return TheStructure.Common.L3FabricFlush; 4839 } 4840 typedef enum tagADDRESS { 4841 ADDRESS_BIT_SHIFT = 0x2, 4842 ADDRESS_ALIGN_SIZE = 0x4, 4843 } ADDRESS; 4844 inline void setAddress(const uint32_t value) { 4845 UNRECOVERABLE_IF(value > 0xffffffff); 4846 TheStructure.Common.Address = value >> ADDRESS_BIT_SHIFT; 4847 } 4848 inline uint32_t getAddress() const { 4849 return TheStructure.Common.Address << ADDRESS_BIT_SHIFT; 4850 } 4851 inline void setAddressHigh(const uint32_t value) { 4852 TheStructure.Common.AddressHigh = value; 4853 } 4854 inline uint32_t getAddressHigh() const { 4855 return TheStructure.Common.AddressHigh; 4856 } 4857 inline void setImmediateData(const uint64_t value) { 4858 TheStructure.Common.ImmediateData = value; 4859 } 4860 inline uint64_t getImmediateData() const { 4861 return TheStructure.Common.ImmediateData; 4862 } 4863} PIPE_CONTROL; 4864STATIC_ASSERT(24 == sizeof(PIPE_CONTROL)); 4865 4866typedef struct tagMI_SEMAPHORE_WAIT { 4867 union tagTheStructure { 4868 struct tagCommon { 4869 // DWORD 0 4870 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 4871 uint32_t Reserved_8 : BITFIELD_RANGE(8, 11); 4872 uint32_t CompareOperation : BITFIELD_RANGE(12, 14); 4873 uint32_t WaitMode : BITFIELD_RANGE(15, 15); 4874 uint32_t RegisterPollMode : BITFIELD_RANGE(16, 16); 4875 uint32_t Reserved_17 : BITFIELD_RANGE(17, 21); 4876 uint32_t MemoryType : BITFIELD_RANGE(22, 22); 4877 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 4878 uint32_t CommandType : BITFIELD_RANGE(29, 31); 4879 // DWORD 1 4880 uint32_t SemaphoreDataDword; 4881 // DWORD 2-3 4882 uint64_t Reserved_64 : BITFIELD_RANGE(0, 1); 4883 uint64_t SemaphoreAddress : BITFIELD_RANGE(2, 63); 4884 // DWORD 4 4885 uint32_t Reserved_128 : BITFIELD_RANGE(0, 4); 4886 uint32_t WaitTokenNumber : BITFIELD_RANGE(5, 9); 4887 uint32_t Reserved_138 : BITFIELD_RANGE(10, 31); 4888 } Common; 4889 uint32_t RawData[5]; 4890 } TheStructure; 4891 typedef enum tagDWORD_LENGTH { 4892 DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x3, 4893 } DWORD_LENGTH; 4894 typedef enum tagCOMPARE_OPERATION { 4895 COMPARE_OPERATION_SAD_GREATER_THAN_SDD = 0x0, 4896 COMPARE_OPERATION_SAD_GREATER_THAN_OR_EQUAL_SDD = 0x1, 4897 COMPARE_OPERATION_SAD_LESS_THAN_SDD = 0x2, 4898 COMPARE_OPERATION_SAD_LESS_THAN_OR_EQUAL_SDD = 0x3, 4899 COMPARE_OPERATION_SAD_EQUAL_SDD = 0x4, 4900 COMPARE_OPERATION_SAD_NOT_EQUAL_SDD = 0x5, 4901 } COMPARE_OPERATION; 4902 typedef enum tagWAIT_MODE { 4903 WAIT_MODE_SIGNAL_MODE = 0x0, 4904 WAIT_MODE_POLLING_MODE = 0x1, 4905 } WAIT_MODE; 4906 typedef enum tagREGISTER_POLL_MODE { 4907 REGISTER_POLL_MODE_MEMORY_POLL = 0x0, 4908 REGISTER_POLL_MODE_REGISTER_POLL = 0x1, 4909 } REGISTER_POLL_MODE; 4910 typedef enum tagMEMORY_TYPE { 4911 MEMORY_TYPE_PER_PROCESS_GRAPHICS_ADDRESS = 0x0, 4912 MEMORY_TYPE_GLOBAL_GRAPHICS_ADDRESS = 0x1, 4913 } MEMORY_TYPE; 4914 typedef enum tagMI_COMMAND_OPCODE { 4915 MI_COMMAND_OPCODE_MI_SEMAPHORE_WAIT = 0x1c, 4916 } MI_COMMAND_OPCODE; 4917 typedef enum tagCOMMAND_TYPE { 4918 COMMAND_TYPE_MI_COMMAND = 0x0, 4919 } COMMAND_TYPE; 4920 inline void init() { 4921 memset(&TheStructure, 0, sizeof(TheStructure)); 4922 TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1; 4923 TheStructure.Common.CompareOperation = COMPARE_OPERATION_SAD_GREATER_THAN_SDD; 4924 TheStructure.Common.WaitMode = WAIT_MODE_SIGNAL_MODE; 4925 TheStructure.Common.RegisterPollMode = REGISTER_POLL_MODE_MEMORY_POLL; 4926 TheStructure.Common.MemoryType = MEMORY_TYPE_PER_PROCESS_GRAPHICS_ADDRESS; 4927 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_SEMAPHORE_WAIT; 4928 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 4929 } 4930 static tagMI_SEMAPHORE_WAIT sInit() { 4931 MI_SEMAPHORE_WAIT state; 4932 state.init(); 4933 return state; 4934 } 4935 inline uint32_t &getRawData(const uint32_t index) { 4936 UNRECOVERABLE_IF(index >= 5); 4937 return TheStructure.RawData[index]; 4938 } 4939 inline void setCompareOperation(const COMPARE_OPERATION value) { 4940 TheStructure.Common.CompareOperation = value; 4941 } 4942 inline COMPARE_OPERATION getCompareOperation() const { 4943 return static_cast<COMPARE_OPERATION>(TheStructure.Common.CompareOperation); 4944 } 4945 inline void setWaitMode(const WAIT_MODE value) { 4946 TheStructure.Common.WaitMode = value; 4947 } 4948 inline WAIT_MODE getWaitMode() const { 4949 return static_cast<WAIT_MODE>(TheStructure.Common.WaitMode); 4950 } 4951 inline void setRegisterPollMode(const REGISTER_POLL_MODE value) { 4952 TheStructure.Common.RegisterPollMode = value; 4953 } 4954 inline REGISTER_POLL_MODE getRegisterPollMode() const { 4955 return static_cast<REGISTER_POLL_MODE>(TheStructure.Common.RegisterPollMode); 4956 } 4957 inline void setMemoryType(const MEMORY_TYPE value) { 4958 TheStructure.Common.MemoryType = value; 4959 } 4960 inline MEMORY_TYPE getMemoryType() const { 4961 return static_cast<MEMORY_TYPE>(TheStructure.Common.MemoryType); 4962 } 4963 inline void setSemaphoreDataDword(const uint32_t value) { 4964 TheStructure.Common.SemaphoreDataDword = value; 4965 } 4966 inline uint32_t getSemaphoreDataDword() const { 4967 return TheStructure.Common.SemaphoreDataDword; 4968 } 4969 typedef enum tagSEMAPHOREADDRESS { 4970 SEMAPHOREADDRESS_BIT_SHIFT = 0x2, 4971 SEMAPHOREADDRESS_ALIGN_SIZE = 0x4, 4972 } SEMAPHOREADDRESS; 4973 inline void setSemaphoreGraphicsAddress(const uint64_t value) { 4974 TheStructure.Common.SemaphoreAddress = value >> SEMAPHOREADDRESS_BIT_SHIFT; 4975 } 4976 inline uint64_t getSemaphoreGraphicsAddress() const { 4977 return TheStructure.Common.SemaphoreAddress << SEMAPHOREADDRESS_BIT_SHIFT; 4978 } 4979 inline void setWaitTokenNumber(const uint32_t value) { 4980 UNRECOVERABLE_IF(value > 0x1f); 4981 TheStructure.Common.WaitTokenNumber = value; 4982 } 4983 inline uint32_t getWaitTokenNumber() const { 4984 return TheStructure.Common.WaitTokenNumber; 4985 } 4986} MI_SEMAPHORE_WAIT; 4987STATIC_ASSERT(20 == sizeof(MI_SEMAPHORE_WAIT)); 4988 4989typedef struct tagMI_STORE_DATA_IMM { 4990 union tagTheStructure { 4991 struct tagCommon { 4992 // DWORD 0 4993 uint32_t DwordLength : BITFIELD_RANGE(0, 9); 4994 uint32_t Reserved_10 : BITFIELD_RANGE(10, 20); 4995 uint32_t StoreQword : BITFIELD_RANGE(21, 21); 4996 uint32_t UseGlobalGtt : BITFIELD_RANGE(22, 22); 4997 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 4998 uint32_t CommandType : BITFIELD_RANGE(29, 31); 4999 // DWORD 1-2 5000 uint64_t CoreModeEnable : BITFIELD_RANGE(0, 0); 5001 uint64_t Reserved_33 : BITFIELD_RANGE(1, 1); 5002 uint64_t Address : BITFIELD_RANGE(2, 63); 5003 // DWORD 3 5004 uint32_t DataDword0; 5005 // DWORD 4 5006 uint32_t DataDword1; 5007 } Common; 5008 uint32_t RawData[5]; 5009 } TheStructure; 5010 typedef enum tagDWORD_LENGTH { 5011 DWORD_LENGTH_STORE_DWORD = 0x2, 5012 DWORD_LENGTH_STORE_QWORD = 0x3, 5013 } DWORD_LENGTH; 5014 typedef enum tagMI_COMMAND_OPCODE { 5015 MI_COMMAND_OPCODE_MI_STORE_DATA_IMM = 0x20, 5016 } MI_COMMAND_OPCODE; 5017 typedef enum tagCOMMAND_TYPE { 5018 COMMAND_TYPE_MI_COMMAND = 0x0, 5019 } COMMAND_TYPE; 5020 inline void init() { 5021 memset(&TheStructure, 0, sizeof(TheStructure)); 5022 TheStructure.Common.DwordLength = DWORD_LENGTH_STORE_DWORD; 5023 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_STORE_DATA_IMM; 5024 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 5025 } 5026 static tagMI_STORE_DATA_IMM sInit() { 5027 MI_STORE_DATA_IMM state; 5028 state.init(); 5029 return state; 5030 } 5031 inline uint32_t &getRawData(const uint32_t index) { 5032 UNRECOVERABLE_IF(index >= 5); 5033 return TheStructure.RawData[index]; 5034 } 5035 inline void setDwordLength(const DWORD_LENGTH value) { 5036 TheStructure.Common.DwordLength = value; 5037 } 5038 inline DWORD_LENGTH getDwordLength() const { 5039 return static_cast<DWORD_LENGTH>(TheStructure.Common.DwordLength); 5040 } 5041 inline void setStoreQword(const bool value) { 5042 TheStructure.Common.StoreQword = value; 5043 } 5044 inline bool getStoreQword() const { 5045 return TheStructure.Common.StoreQword; 5046 } 5047 inline void setUseGlobalGtt(const bool value) { 5048 TheStructure.Common.UseGlobalGtt = value; 5049 } 5050 inline bool getUseGlobalGtt() const { 5051 return TheStructure.Common.UseGlobalGtt; 5052 } 5053 inline void setCoreModeEnable(const bool value) { 5054 TheStructure.Common.CoreModeEnable = value; 5055 } 5056 inline bool getCoreModeEnable() const { 5057 return TheStructure.Common.CoreModeEnable; 5058 } 5059 typedef enum tagADDRESS { 5060 ADDRESS_BIT_SHIFT = 0x2, 5061 ADDRESS_ALIGN_SIZE = 0x4, 5062 } ADDRESS; 5063 inline void setAddress(const uint64_t value) { 5064 UNRECOVERABLE_IF(value > 0x3fffffffffffffffL); 5065 TheStructure.Common.Address = value >> ADDRESS_BIT_SHIFT; 5066 } 5067 inline uint64_t getAddress() const { 5068 return TheStructure.Common.Address << ADDRESS_BIT_SHIFT; 5069 } 5070 inline void setDataDword0(const uint32_t value) { 5071 TheStructure.Common.DataDword0 = value; 5072 } 5073 inline uint32_t getDataDword0() const { 5074 return TheStructure.Common.DataDword0; 5075 } 5076 inline void setDataDword1(const uint32_t value) { 5077 TheStructure.Common.DataDword1 = value; 5078 } 5079 inline uint32_t getDataDword1() const { 5080 return TheStructure.Common.DataDword1; 5081 } 5082} MI_STORE_DATA_IMM; 5083STATIC_ASSERT(20 == sizeof(MI_STORE_DATA_IMM)); 5084 5085typedef struct tagSTATE_SIP { 5086 union tagTheStructure { 5087 struct tagCommon { 5088 // DWORD 0 5089 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 5090 uint32_t Reserved_8 : BITFIELD_RANGE(8, 15); 5091 uint32_t _3DCommandSubOpcode : BITFIELD_RANGE(16, 23); 5092 uint32_t _3DCommandOpcode : BITFIELD_RANGE(24, 26); 5093 uint32_t CommandSubtype : BITFIELD_RANGE(27, 28); 5094 uint32_t CommandType : BITFIELD_RANGE(29, 31); 5095 // DWORD 1-2 5096 uint64_t Reserved_32 : BITFIELD_RANGE(0, 3); 5097 uint64_t SystemInstructionPointer : BITFIELD_RANGE(4, 63); 5098 } Common; 5099 uint32_t RawData[3]; 5100 } TheStructure; 5101 typedef enum tagDWORD_LENGTH { 5102 DWORD_LENGTH_DWORD_COUNT_N = 0x1, 5103 } DWORD_LENGTH; 5104 typedef enum tag_3D_COMMAND_SUB_OPCODE { 5105 _3D_COMMAND_SUB_OPCODE_STATE_SIP = 0x2, 5106 } _3D_COMMAND_SUB_OPCODE; 5107 typedef enum tag_3D_COMMAND_OPCODE { 5108 _3D_COMMAND_OPCODE_GFXPIPE_NONPIPELINED = 0x1, 5109 } _3D_COMMAND_OPCODE; 5110 typedef enum tagCOMMAND_SUBTYPE { 5111 COMMAND_SUBTYPE_GFXPIPE_COMMON = 0x0, 5112 } COMMAND_SUBTYPE; 5113 typedef enum tagCOMMAND_TYPE { 5114 COMMAND_TYPE_GFXPIPE = 0x3, 5115 } COMMAND_TYPE; 5116 inline void init() { 5117 memset(&TheStructure, 0, sizeof(TheStructure)); 5118 TheStructure.Common.DwordLength = DWORD_LENGTH_DWORD_COUNT_N; 5119 TheStructure.Common._3DCommandSubOpcode = _3D_COMMAND_SUB_OPCODE_STATE_SIP; 5120 TheStructure.Common._3DCommandOpcode = _3D_COMMAND_OPCODE_GFXPIPE_NONPIPELINED; 5121 TheStructure.Common.CommandSubtype = COMMAND_SUBTYPE_GFXPIPE_COMMON; 5122 TheStructure.Common.CommandType = COMMAND_TYPE_GFXPIPE; 5123 } 5124 static tagSTATE_SIP sInit() { 5125 STATE_SIP state; 5126 state.init(); 5127 return state; 5128 } 5129 inline uint32_t &getRawData(const uint32_t index) { 5130 UNRECOVERABLE_IF(index >= 3); 5131 return TheStructure.RawData[index]; 5132 } 5133 typedef enum tagSYSTEMINSTRUCTIONPOINTER { 5134 SYSTEMINSTRUCTIONPOINTER_BIT_SHIFT = 0x4, 5135 SYSTEMINSTRUCTIONPOINTER_ALIGN_SIZE = 0x10, 5136 } SYSTEMINSTRUCTIONPOINTER; 5137 inline void setSystemInstructionPointer(const uint64_t value) { 5138 UNRECOVERABLE_IF(value > 0xffffffffffffffffL); 5139 TheStructure.Common.SystemInstructionPointer = value >> SYSTEMINSTRUCTIONPOINTER_BIT_SHIFT; 5140 } 5141 inline uint64_t getSystemInstructionPointer() const { 5142 return (uint64_t)TheStructure.Common.SystemInstructionPointer << SYSTEMINSTRUCTIONPOINTER_BIT_SHIFT; 5143 } 5144} STATE_SIP; 5145STATIC_ASSERT(12 == sizeof(STATE_SIP)); 5146 5147typedef struct tagGPGPU_CSR_BASE_ADDRESS { 5148 union tagTheStructure { 5149 struct tagCommon { 5150 // DWORD 0 5151 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 5152 uint32_t Reserved_8 : BITFIELD_RANGE(8, 15); 5153 uint32_t _3DCommandSubOpcode : BITFIELD_RANGE(16, 23); 5154 uint32_t _3DCommandOpcode : BITFIELD_RANGE(24, 26); 5155 uint32_t CommandSubtype : BITFIELD_RANGE(27, 28); 5156 uint32_t CommandType : BITFIELD_RANGE(29, 31); 5157 // DWORD 1-2 5158 uint64_t Reserved_32 : BITFIELD_RANGE(0, 11); 5159 uint64_t GpgpuCsrBaseAddress : BITFIELD_RANGE(12, 63); 5160 } Common; 5161 uint32_t RawData[3]; 5162 } TheStructure; 5163 typedef enum tagDWORD_LENGTH { 5164 DWORD_LENGTH_LENGTH_1 = 0x1, 5165 } DWORD_LENGTH; 5166 typedef enum tag_3D_COMMAND_SUB_OPCODE { 5167 _3D_COMMAND_SUB_OPCODE_GPGPU_CSR_BASE_ADDRESS = 0x4, 5168 } _3D_COMMAND_SUB_OPCODE; 5169 typedef enum tag_3D_COMMAND_OPCODE { 5170 _3D_COMMAND_OPCODE_GFXPIPE_NONPIPELINED = 0x1, 5171 } _3D_COMMAND_OPCODE; 5172 typedef enum tagCOMMAND_SUBTYPE { 5173 COMMAND_SUBTYPE_GFXPIPE_COMMON = 0x0, 5174 } COMMAND_SUBTYPE; 5175 typedef enum tagCOMMAND_TYPE { 5176 COMMAND_TYPE_GFXPIPE = 0x3, 5177 } COMMAND_TYPE; 5178 inline void init() { 5179 memset(&TheStructure, 0, sizeof(TheStructure)); 5180 TheStructure.Common.DwordLength = DWORD_LENGTH_LENGTH_1; 5181 TheStructure.Common._3DCommandSubOpcode = _3D_COMMAND_SUB_OPCODE_GPGPU_CSR_BASE_ADDRESS; 5182 TheStructure.Common._3DCommandOpcode = _3D_COMMAND_OPCODE_GFXPIPE_NONPIPELINED; 5183 TheStructure.Common.CommandSubtype = COMMAND_SUBTYPE_GFXPIPE_COMMON; 5184 TheStructure.Common.CommandType = COMMAND_TYPE_GFXPIPE; 5185 } 5186 static tagGPGPU_CSR_BASE_ADDRESS sInit() { 5187 GPGPU_CSR_BASE_ADDRESS state; 5188 state.init(); 5189 return state; 5190 } 5191 inline uint32_t &getRawData(const uint32_t index) { 5192 UNRECOVERABLE_IF(index >= 3); 5193 return TheStructure.RawData[index]; 5194 } 5195 typedef enum tagGPGPUCSRBASEADDRESS { 5196 GPGPUCSRBASEADDRESS_BIT_SHIFT = 0xc, 5197 GPGPUCSRBASEADDRESS_ALIGN_SIZE = 0x1000, 5198 } GPGPUCSRBASEADDRESS; 5199 inline void setGpgpuCsrBaseAddress(const uint64_t value) { 5200 UNRECOVERABLE_IF(value > 0xffffffffffffffffL); 5201 TheStructure.Common.GpgpuCsrBaseAddress = value >> GPGPUCSRBASEADDRESS_BIT_SHIFT; 5202 } 5203 inline uint64_t getGpgpuCsrBaseAddress() const { 5204 return (uint64_t)TheStructure.Common.GpgpuCsrBaseAddress << GPGPUCSRBASEADDRESS_BIT_SHIFT; 5205 } 5206} GPGPU_CSR_BASE_ADDRESS; 5207STATIC_ASSERT(12 == sizeof(GPGPU_CSR_BASE_ADDRESS)); 5208 5209typedef struct tagL3_FLUSH_ADDRESS_RANGE { 5210 union tagTheStructure { 5211 struct tagCommon { 5212 uint64_t Reserved_0 : BITFIELD_RANGE(0, 2); 5213 uint64_t AddressMask : BITFIELD_RANGE(3, 8); 5214 uint64_t Reserved_9 : BITFIELD_RANGE(9, 11); 5215 uint64_t AddressLow : BITFIELD_RANGE(12, 31); 5216 uint64_t AddressHigh : BITFIELD_RANGE(32, 47); 5217 uint64_t Reserved_48 : BITFIELD_RANGE(48, 59); 5218 uint64_t L3FlushEvictionPolicy : BITFIELD_RANGE(60, 61); 5219 uint64_t Reserved_62 : BITFIELD_RANGE(62, 63); 5220 } Common; 5221 struct tagCommonA0Stepping { 5222 uint64_t AddressHigh : BITFIELD_RANGE(0, 15); 5223 uint64_t Reserved_0 : BITFIELD_RANGE(16, 27); 5224 uint64_t L3FlushEvictionPolicy : BITFIELD_RANGE(28, 29); 5225 uint64_t Reserved_9 : BITFIELD_RANGE(30, 34); 5226 uint64_t AddressMask : BITFIELD_RANGE(35, 40); 5227 uint64_t Reserved_48 : BITFIELD_RANGE(41, 43); 5228 uint64_t AddressLow : BITFIELD_RANGE(44, 63); 5229 } CommonA0Stepping; 5230 uint32_t RawData[2]; 5231 } TheStructure; 5232 5233 typedef enum tagL3_FLUSH_EVICTION_POLICY { 5234 L3_FLUSH_EVICTION_POLICY_FLUSH_L3_WITH_EVICTION = 0x0, 5235 } L3_FLUSH_EVICTION_POLICY; 5236 inline void init() { 5237 memset(&TheStructure, 0, sizeof(TheStructure)); 5238 } 5239 static tagL3_FLUSH_ADDRESS_RANGE sInit() { 5240 L3_FLUSH_ADDRESS_RANGE state; 5241 state.init(); 5242 return state; 5243 } 5244 inline uint32_t &getRawData(const uint32_t index) { 5245 UNRECOVERABLE_IF(index >= 2); 5246 return TheStructure.RawData[index]; 5247 } 5248 5249 typedef enum tagADDRESSLOW { 5250 ADDRESSLOW_BIT_SHIFT = 0xC, 5251 ADDRESSLOW_ALIGN_SIZE = 0x1000, 5252 } ADDRESSLOW; 5253 5254 inline void setAddressLow(const uint64_t value, bool isA0Stepping) { 5255 if (isA0Stepping) { 5256 TheStructure.CommonA0Stepping.AddressLow = value >> ADDRESSLOW_BIT_SHIFT; 5257 } else { 5258 TheStructure.Common.AddressLow = value >> ADDRESSLOW_BIT_SHIFT; 5259 } 5260 } 5261 5262 inline uint64_t getAddressLow(bool isA0Stepping) const { 5263 if (isA0Stepping) { 5264 return (TheStructure.CommonA0Stepping.AddressLow << ADDRESSLOW_BIT_SHIFT) & uint64_t(0xffffffff); 5265 } else { 5266 return (TheStructure.Common.AddressLow << ADDRESSLOW_BIT_SHIFT); 5267 } 5268 } 5269 5270 inline void setAddressHigh(const uint64_t value, bool isA0Stepping) { 5271 if (isA0Stepping) { 5272 TheStructure.CommonA0Stepping.AddressHigh = value; 5273 } else { 5274 TheStructure.Common.AddressHigh = value; 5275 } 5276 } 5277 5278 inline uint64_t getAddressHigh(bool isA0Stepping) const { 5279 if (isA0Stepping) { 5280 return (TheStructure.CommonA0Stepping.AddressHigh); 5281 } else { 5282 return (TheStructure.Common.AddressHigh); 5283 } 5284 } 5285 5286 inline void setAddress(const uint64_t value, bool isA0Stepping) { 5287 setAddressLow(static_cast<uint32_t>(value), isA0Stepping); 5288 setAddressHigh(static_cast<uint32_t>(value >> 32), isA0Stepping); 5289 } 5290 5291 inline uint64_t getAddress(bool isA0Stepping) const { 5292 return static_cast<uint64_t>(getAddressLow(isA0Stepping)) | (static_cast<uint64_t>(getAddressHigh(isA0Stepping)) << 32); 5293 } 5294 5295 inline void setL3FlushEvictionPolicy(const L3_FLUSH_EVICTION_POLICY value, bool isA0Stepping) { 5296 if (isA0Stepping) { 5297 TheStructure.CommonA0Stepping.L3FlushEvictionPolicy = value; 5298 } else { 5299 TheStructure.Common.L3FlushEvictionPolicy = value; 5300 } 5301 } 5302 inline L3_FLUSH_EVICTION_POLICY getL3FlushEvictionPolicy(bool isA0Stepping) const { 5303 if (isA0Stepping) { 5304 return static_cast<L3_FLUSH_EVICTION_POLICY>(TheStructure.CommonA0Stepping.L3FlushEvictionPolicy); 5305 } else { 5306 return static_cast<L3_FLUSH_EVICTION_POLICY>(TheStructure.Common.L3FlushEvictionPolicy); 5307 } 5308 } 5309 inline void setAddressMask(const uint64_t value, bool isA0Stepping) { 5310 if (isA0Stepping) { 5311 TheStructure.CommonA0Stepping.AddressMask = value; 5312 } else { 5313 UNRECOVERABLE_IF(value > 0x1f8); 5314 TheStructure.Common.AddressMask = value; 5315 } 5316 } 5317 inline uint32_t getAddressMask(bool isA0Stepping) const { 5318 if (isA0Stepping) { 5319 return TheStructure.CommonA0Stepping.AddressMask; 5320 } else { 5321 return TheStructure.Common.AddressMask; 5322 } 5323 } 5324} L3_FLUSH_ADDRESS_RANGE; 5325STATIC_ASSERT(8 == sizeof(L3_FLUSH_ADDRESS_RANGE)); 5326 5327struct L3_CONTROL_BASE { 5328 union tagTheStructure { 5329 struct tagCommon { 5330 uint32_t Length : BITFIELD_RANGE(0, 7); 5331 uint32_t DepthCacheFlush : BITFIELD_RANGE(8, 8); 5332 uint32_t RenderTargetCacheFlushEnable : BITFIELD_RANGE(9, 9); 5333 uint32_t HdcPipelineFlush : BITFIELD_RANGE(10, 10); 5334 uint32_t Reserved_11 : BITFIELD_RANGE(11, 13); 5335 uint32_t PostSyncOperation : BITFIELD_RANGE(14, 14); 5336 uint32_t PostSyncOperationL3CacheabilityControl : BITFIELD_RANGE(15, 15); // removed on DG1 5337 uint32_t Reserved_16 : BITFIELD_RANGE(16, 19); 5338 uint32_t CommandStreamerStallEnable : BITFIELD_RANGE(20, 20); 5339 uint32_t DestinationAddressType : BITFIELD_RANGE(21, 21); 5340 uint32_t Reserved_22 : BITFIELD_RANGE(22, 22); 5341 uint32_t _3DCommandSubOpcode : BITFIELD_RANGE(23, 23); 5342 uint32_t _3DCommandOpcode : BITFIELD_RANGE(24, 26); 5343 uint32_t CommandSubtype : BITFIELD_RANGE(27, 28); 5344 uint32_t Type : BITFIELD_RANGE(29, 31); 5345 } Common; 5346 uint32_t RawData[1]; 5347 } TheStructure; 5348 5349 typedef enum tagLENGTH { 5350 LENGTH_POST_SYNC_OPERATION_DISABLED = 1, 5351 LENGTH_POST_SYNC_OPERATION_ENABLED = 5, 5352 } LENGTH; 5353 typedef enum tagPOST_SYNC_OPERATION { 5354 POST_SYNC_OPERATION_NO_WRITE = 0x0, 5355 POST_SYNC_OPERATION_WRITE_IMMEDIATE_DATA = 0x1, 5356 } POST_SYNC_OPERATION; 5357 typedef enum tagPOST_SYNC_OPERATION_L3_CACHEABILITY_CONTROL { 5358 POST_SYNC_OPERATION_L3_CACHEABILITY_CONTROL_DEFAULT_MOCS = 0x0, 5359 POST_SYNC_OPERATION_L3_CACHEABILITY_CONTROL_CACHEABLE_MOCS = 0x1, 5360 } POST_SYNC_OPERATION_L3_CACHEABILITY_CONTROL; 5361 typedef enum tagDESTINATION_ADDRESS_TYPE { 5362 DESTINATION_ADDRESS_TYPE_PPGTT = 0x0, 5363 DESTINATION_ADDRESS_TYPE_GGTT = 0x1, 5364 } DESTINATION_ADDRESS_TYPE; 5365 typedef enum tag_3D_COMMAND_SUB_OPCODE { 5366 _3D_COMMAND_SUB_OPCODE_L3_CONTROL = 0x1, 5367 } _3D_COMMAND_SUB_OPCODE; 5368 typedef enum tag_3D_COMMAND_OPCODE { 5369 _3D_COMMAND_OPCODE_L3_CONTROL = 0x5, 5370 } _3D_COMMAND_OPCODE; 5371 typedef enum tagCOMMAND_SUBTYPE { 5372 COMMAND_SUBTYPE_GFXPIPE_3D = 0x3, 5373 } COMMAND_SUBTYPE; 5374 typedef enum tagTYPE { 5375 TYPE_GFXPIPE = 0x3, 5376 } TYPE; 5377 inline void init() { 5378 memset(&TheStructure, 0, sizeof(TheStructure)); 5379 TheStructure.Common.PostSyncOperation = POST_SYNC_OPERATION_NO_WRITE; 5380 TheStructure.Common.PostSyncOperationL3CacheabilityControl = POST_SYNC_OPERATION_L3_CACHEABILITY_CONTROL_DEFAULT_MOCS; 5381 TheStructure.Common.DestinationAddressType = DESTINATION_ADDRESS_TYPE_PPGTT; 5382 TheStructure.Common._3DCommandSubOpcode = _3D_COMMAND_SUB_OPCODE_L3_CONTROL; 5383 TheStructure.Common._3DCommandOpcode = _3D_COMMAND_OPCODE_L3_CONTROL; 5384 TheStructure.Common.CommandSubtype = COMMAND_SUBTYPE_GFXPIPE_3D; 5385 TheStructure.Common.Type = TYPE_GFXPIPE; 5386 } 5387 static L3_CONTROL_BASE sInit() { 5388 L3_CONTROL_BASE state; 5389 state.init(); 5390 return state; 5391 } 5392 inline uint32_t &getRawData(const uint32_t index) { 5393 UNRECOVERABLE_IF(index >= 7); 5394 return TheStructure.RawData[index]; 5395 } 5396 inline void setLength(const LENGTH value) { 5397 TheStructure.Common.Length = value; 5398 } 5399 inline LENGTH getLength() const { 5400 return (LENGTH)TheStructure.Common.Length; 5401 } 5402 inline void setDepthCacheFlush(const bool value) { 5403 TheStructure.Common.DepthCacheFlush = value; 5404 } 5405 inline bool getDepthCacheFlush() const { 5406 return TheStructure.Common.DepthCacheFlush; 5407 } 5408 inline void setRenderTargetCacheFlushEnable(const bool value) { 5409 TheStructure.Common.RenderTargetCacheFlushEnable = value; 5410 } 5411 inline bool getRenderTargetCacheFlushEnable() const { 5412 return TheStructure.Common.RenderTargetCacheFlushEnable; 5413 } 5414 inline void setHdcPipelineFlush(const bool value) { 5415 TheStructure.Common.HdcPipelineFlush = value; 5416 } 5417 inline bool getHdcPipelineFlush() const { 5418 return TheStructure.Common.HdcPipelineFlush; 5419 } 5420 inline void setPostSyncOperation(const POST_SYNC_OPERATION value) { 5421 TheStructure.Common.PostSyncOperation = value; 5422 } 5423 inline POST_SYNC_OPERATION getPostSyncOperation() const { 5424 return static_cast<POST_SYNC_OPERATION>(TheStructure.Common.PostSyncOperation); 5425 } 5426 inline void setPostSyncOperationL3CacheabilityControl(const POST_SYNC_OPERATION_L3_CACHEABILITY_CONTROL value) { 5427 TheStructure.Common.PostSyncOperationL3CacheabilityControl = value; 5428 } 5429 inline POST_SYNC_OPERATION_L3_CACHEABILITY_CONTROL getPostSyncOperationL3CacheabilityControl() const { 5430 return static_cast<POST_SYNC_OPERATION_L3_CACHEABILITY_CONTROL>(TheStructure.Common.PostSyncOperationL3CacheabilityControl); 5431 } 5432 inline void setCommandStreamerStallEnable(const bool value) { 5433 TheStructure.Common.CommandStreamerStallEnable = value; 5434 } 5435 inline bool getCommandStreamerStallEnable() const { 5436 return TheStructure.Common.CommandStreamerStallEnable; 5437 } 5438 inline void setDestinationAddressType(const DESTINATION_ADDRESS_TYPE value) { 5439 TheStructure.Common.DestinationAddressType = value; 5440 } 5441 inline DESTINATION_ADDRESS_TYPE getDestinationAddressType() const { 5442 return static_cast<DESTINATION_ADDRESS_TYPE>(TheStructure.Common.DestinationAddressType); 5443 } 5444 inline void setType(const TYPE value) { 5445 TheStructure.Common.Type = value; 5446 } 5447 inline TYPE getType() const { 5448 return static_cast<TYPE>(TheStructure.Common.Type); 5449 } 5450}; 5451 5452struct L3_CONTROL_POST_SYNC_DATA { 5453 union tagTheStructure { 5454 struct tagCommon { 5455 uint64_t Reserved_96 : BITFIELD_RANGE(0, 2); 5456 uint64_t Address : BITFIELD_RANGE(3, 47); 5457 uint64_t Reserved_144 : BITFIELD_RANGE(48, 63); 5458 uint64_t ImmediateData; 5459 } Common; 5460 uint32_t RawData[4]; 5461 } TheStructure; 5462 5463 inline void init() { 5464 memset(&TheStructure, 0, sizeof(TheStructure)); 5465 } 5466 5467 typedef enum tagADDRESS { 5468 ADDRESS_BIT_SHIFT = 0x3, 5469 ADDRESS_ALIGN_SIZE = 0x8, 5470 } ADDRESS; 5471 inline void setAddress(const uint64_t value) { 5472 UNRECOVERABLE_IF(value > 0xfffffffffff8L); 5473 TheStructure.Common.Address = value >> ADDRESS_BIT_SHIFT; 5474 } 5475 inline uint64_t getAddress() const { 5476 return TheStructure.Common.Address << ADDRESS_BIT_SHIFT; 5477 } 5478 inline void setImmediateData(const uint64_t value) { 5479 TheStructure.Common.ImmediateData = value; 5480 } 5481 inline uint64_t getImmediateData() const { 5482 return TheStructure.Common.ImmediateData; 5483 } 5484}; 5485 5486struct L3_CONTROL { 5487 union tagTheStructure { 5488 struct tagCommon { 5489 L3_CONTROL_BASE Base; 5490 L3_CONTROL_POST_SYNC_DATA PostSyncData; 5491 L3_FLUSH_ADDRESS_RANGE L3FlushAddressRange; 5492 } Common; 5493 uint32_t RawData[7]; 5494 } TheStructure; 5495 5496 inline void init() { 5497 memset(&TheStructure, 0, sizeof(TheStructure)); 5498 getBase().init(); 5499 getPostSyncData().init(); 5500 getBase().setLength(L3_CONTROL_BASE::LENGTH_POST_SYNC_OPERATION_ENABLED); 5501 TheStructure.Common.L3FlushAddressRange.init(); 5502 } 5503 5504 inline void setL3FlushAddressRange(const L3_FLUSH_ADDRESS_RANGE &value) { 5505 TheStructure.Common.L3FlushAddressRange = value; 5506 } 5507 inline L3_FLUSH_ADDRESS_RANGE &getL3FlushAddressRange() { 5508 return TheStructure.Common.L3FlushAddressRange; 5509 } 5510 inline const L3_FLUSH_ADDRESS_RANGE &getL3FlushAddressRange() const { 5511 return TheStructure.Common.L3FlushAddressRange; 5512 } 5513 5514 static L3_CONTROL sInit() { 5515 L3_CONTROL state; 5516 state.init(); 5517 return state; 5518 } 5519 inline uint32_t &getRawData(const uint32_t index) { 5520 UNRECOVERABLE_IF(index >= 7); 5521 return TheStructure.RawData[index]; 5522 } 5523 5524 L3_CONTROL_BASE &getBase() { 5525 return TheStructure.Common.Base; 5526 } 5527 5528 const L3_CONTROL_BASE &getBase() const { 5529 return TheStructure.Common.Base; 5530 } 5531 5532 L3_CONTROL_POST_SYNC_DATA &getPostSyncData() { 5533 return TheStructure.Common.PostSyncData; 5534 } 5535 5536 const L3_CONTROL_POST_SYNC_DATA &getPostSyncData() const { 5537 return TheStructure.Common.PostSyncData; 5538 } 5539 5540 inline void setPostSyncAddress(const uint64_t value) { 5541 getPostSyncData().setAddress(value); 5542 } 5543 5544 inline uint64_t getPostSyncAddress() const { 5545 return getPostSyncData().getAddress(); 5546 } 5547 5548 inline void setPostSyncImmediateData(const uint64_t value) { 5549 getPostSyncData().setImmediateData(value); 5550 } 5551 5552 inline uint64_t getPostSyncImmediateData() const { 5553 return getPostSyncData().getImmediateData(); 5554 } 5555}; 5556 5557STATIC_ASSERT(28 == sizeof(L3_CONTROL)); 5558STATIC_ASSERT(std::is_pod<L3_CONTROL>::value); 5559 5560typedef struct tagXY_BLOCK_COPY_BLT { 5561 union tagTheStructure { 5562 struct tagCommon { 5563 // DWORD 0 5564 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 5565 uint32_t Reserved_8 : BITFIELD_RANGE(8, 18); 5566 uint32_t ColorDepth : BITFIELD_RANGE(19, 21); 5567 uint32_t InstructionTarget_Opcode : BITFIELD_RANGE(22, 28); 5568 uint32_t Client : BITFIELD_RANGE(29, 31); 5569 // DWORD 1 5570 uint32_t DestinationPitch : BITFIELD_RANGE(0, 17); 5571 uint32_t Reserved_50 : BITFIELD_RANGE(18, 20); 5572 uint32_t DestinationMOCS : BITFIELD_RANGE(21, 27); 5573 uint32_t Reserved_60 : BITFIELD_RANGE(28, 29); 5574 uint32_t DestinationTiling : BITFIELD_RANGE(30, 31); 5575 // DWORD 2 5576 uint32_t DestinationX1Coordinate_Left : BITFIELD_RANGE(0, 15); 5577 uint32_t DestinationY1Coordinate_Top : BITFIELD_RANGE(16, 31); 5578 // DWORD 3 5579 uint32_t DestinationX2Coordinate_Right : BITFIELD_RANGE(0, 15); 5580 uint32_t DestinationY2Coordinate_Bottom : BITFIELD_RANGE(16, 31); 5581 // DWORD 4 5582 uint64_t DestinationBaseAddress; 5583 // DWORD 6 5584 uint32_t DestinationXOffset : BITFIELD_RANGE(0, 13); 5585 uint32_t Reserved_206 : BITFIELD_RANGE(14, 15); 5586 uint32_t DestinationYOffset : BITFIELD_RANGE(16, 29); 5587 uint32_t Reserved_222 : BITFIELD_RANGE(30, 31); 5588 // DWORD 7 5589 uint32_t SourceX1Coordinate_Left : BITFIELD_RANGE(0, 15); 5590 uint32_t SourceY1Coordinate_Top : BITFIELD_RANGE(16, 31); 5591 // DWORD 8 5592 uint32_t SourcePitch : BITFIELD_RANGE(0, 17); 5593 uint32_t Reserved_274 : BITFIELD_RANGE(18, 20); 5594 uint32_t SourceMocs : BITFIELD_RANGE(21, 27); 5595 uint32_t Reserved_284 : BITFIELD_RANGE(28, 29); 5596 uint32_t SourceTiling : BITFIELD_RANGE(30, 31); 5597 // DWORD 9 5598 uint64_t SourceBaseAddress; 5599 // DWORD 11 5600 uint32_t SourceXOffset : BITFIELD_RANGE(0, 13); 5601 uint32_t Reserved_366 : BITFIELD_RANGE(14, 15); 5602 uint32_t SourceYOffset : BITFIELD_RANGE(16, 29); 5603 uint32_t Reserved_382 : BITFIELD_RANGE(30, 31); 5604 } Common; 5605 uint32_t RawData[12]; 5606 } TheStructure; 5607 typedef enum tagDWORD_LENGTH { 5608 DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0xa, 5609 } DWORD_LENGTH; 5610 typedef enum tagCOLOR_DEPTH { 5611 COLOR_DEPTH_8_BIT_COLOR = 0x0, 5612 COLOR_DEPTH_16_BIT_COLOR = 0x1, 5613 COLOR_DEPTH_32_BIT_COLOR = 0x2, 5614 COLOR_DEPTH_64_BIT_COLOR = 0x3, 5615 COLOR_DEPTH_96_BIT_COLOR_ONLY_LINEAR_CASE_IS_SUPPORTED = 0x4, 5616 COLOR_DEPTH_128_BIT_COLOR = 0x5, 5617 } COLOR_DEPTH; 5618 typedef enum tagCLIENT { 5619 CLIENT_2D_PROCESSOR = 0x2, 5620 } CLIENT; 5621 typedef enum tagDESTINATION_TILING { 5622 DESTINATION_TILING_LINEAR = 0x0, 5623 DESTINATION_TILING_YMAJOR = 0x1, 5624 } DESTINATION_TILING; 5625 typedef enum tagSOURCE_TILING { 5626 SOURCE_TILING_LINEAR = 0x0, 5627 SOURCE_TILING_YMAJOR = 0x1, 5628 } SOURCE_TILING; 5629 enum INSTRUCTIONTARGET_OPCODE { 5630 INSTRUCTIONTARGET_OPCODE_OPCODE = 0x41, 5631 }; 5632 inline void init() { 5633 memset(&TheStructure, 0, sizeof(TheStructure)); 5634 TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1; 5635 TheStructure.Common.ColorDepth = COLOR_DEPTH_8_BIT_COLOR; 5636 TheStructure.Common.InstructionTarget_Opcode = INSTRUCTIONTARGET_OPCODE_OPCODE; 5637 TheStructure.Common.Client = CLIENT_2D_PROCESSOR; 5638 TheStructure.Common.DestinationTiling = DESTINATION_TILING_LINEAR; 5639 TheStructure.Common.SourceTiling = SOURCE_TILING_LINEAR; 5640 } 5641 static tagXY_BLOCK_COPY_BLT sInit() { 5642 XY_BLOCK_COPY_BLT state; 5643 state.init(); 5644 return state; 5645 } 5646 inline uint32_t &getRawData(const uint32_t index) { 5647 UNRECOVERABLE_IF(index >= 13); 5648 return TheStructure.RawData[index]; 5649 } 5650 5651 inline void setColorDepth(const COLOR_DEPTH value) { 5652 TheStructure.Common.ColorDepth = value; 5653 } 5654 inline COLOR_DEPTH getColorDepth() const { 5655 return static_cast<COLOR_DEPTH>(TheStructure.Common.ColorDepth); 5656 } 5657 inline void setInstructionTargetOpcode(const uint32_t value) { 5658 UNRECOVERABLE_IF(value > 0x7f); 5659 TheStructure.Common.InstructionTarget_Opcode = value; 5660 } 5661 inline uint32_t getInstructionTargetOpcode() const { 5662 return TheStructure.Common.InstructionTarget_Opcode; 5663 } 5664 inline void setClient(const CLIENT value) { 5665 TheStructure.Common.Client = value; 5666 } 5667 inline CLIENT getClient() const { 5668 return static_cast<CLIENT>(TheStructure.Common.Client); 5669 } 5670 inline void setDestinationPitch(const uint32_t value) { 5671 UNRECOVERABLE_IF(value > 0x3ffff); 5672 TheStructure.Common.DestinationPitch = value - 1; 5673 } 5674 inline uint32_t getDestinationPitch() const { 5675 return TheStructure.Common.DestinationPitch + 1; 5676 } 5677 inline void setDestinationMOCS(const uint32_t value) { 5678 UNRECOVERABLE_IF(value > 0x7f); 5679 TheStructure.Common.DestinationMOCS = value; 5680 } 5681 inline uint32_t getDestinationMOCS() const { 5682 return TheStructure.Common.DestinationMOCS; 5683 } 5684 inline void setDestinationTiling(const DESTINATION_TILING value) { 5685 TheStructure.Common.DestinationTiling = value; 5686 } 5687 inline DESTINATION_TILING getDestinationTiling() const { 5688 return static_cast<DESTINATION_TILING>(TheStructure.Common.DestinationTiling); 5689 } 5690 inline void setDestinationX1CoordinateLeft(const uint32_t value) { 5691 UNRECOVERABLE_IF(value > 0xffff); 5692 TheStructure.Common.DestinationX1Coordinate_Left = value; 5693 } 5694 inline uint32_t getDestinationX1CoordinateLeft() const { 5695 return TheStructure.Common.DestinationX1Coordinate_Left; 5696 } 5697 inline void setDestinationY1CoordinateTop(const uint32_t value) { 5698 UNRECOVERABLE_IF(value > 0xffff); 5699 TheStructure.Common.DestinationY1Coordinate_Top = value; 5700 } 5701 inline uint32_t getDestinationY1CoordinateTop() const { 5702 return TheStructure.Common.DestinationY1Coordinate_Top; 5703 } 5704 inline void setDestinationX2CoordinateRight(const uint32_t value) { 5705 UNRECOVERABLE_IF(value > 0xffff); 5706 TheStructure.Common.DestinationX2Coordinate_Right = value; 5707 } 5708 inline uint32_t getDestinationX2CoordinateRight() const { 5709 return TheStructure.Common.DestinationX2Coordinate_Right; 5710 } 5711 inline void setDestinationY2CoordinateBottom(const uint32_t value) { 5712 UNRECOVERABLE_IF(value > 0xffff); 5713 TheStructure.Common.DestinationY2Coordinate_Bottom = value; 5714 } 5715 inline uint32_t getDestinationY2CoordinateBottom() const { 5716 return TheStructure.Common.DestinationY2Coordinate_Bottom; 5717 } 5718 inline void setDestinationBaseAddress(const uint64_t value) { 5719 TheStructure.Common.DestinationBaseAddress = value; 5720 } 5721 inline uint64_t getDestinationBaseAddress() const { 5722 return TheStructure.Common.DestinationBaseAddress; 5723 } 5724 inline void setDestinationXOffset(const uint32_t value) { 5725 UNRECOVERABLE_IF(value > 0x3fff); 5726 TheStructure.Common.DestinationXOffset = value; 5727 } 5728 inline uint32_t getDestinationXOffset() const { 5729 return TheStructure.Common.DestinationXOffset; 5730 } 5731 inline void setDestinationYOffset(const uint32_t value) { 5732 UNRECOVERABLE_IF(value > 0x3fff); 5733 TheStructure.Common.DestinationYOffset = value; 5734 } 5735 inline uint32_t getDestinationYOffset() const { 5736 return TheStructure.Common.DestinationYOffset; 5737 } 5738 inline void setSourceX1CoordinateLeft(const uint32_t value) { 5739 UNRECOVERABLE_IF(value > 0xffff); 5740 TheStructure.Common.SourceX1Coordinate_Left = value; 5741 } 5742 inline uint32_t getSourceX1CoordinateLeft() const { 5743 return TheStructure.Common.SourceX1Coordinate_Left; 5744 } 5745 inline void setSourceY1CoordinateTop(const uint32_t value) { 5746 UNRECOVERABLE_IF(value > 0xffff); 5747 TheStructure.Common.SourceY1Coordinate_Top = value; 5748 } 5749 inline uint32_t getSourceY1CoordinateTop() const { 5750 return TheStructure.Common.SourceY1Coordinate_Top; 5751 } 5752 inline void setSourcePitch(const uint32_t value) { 5753 UNRECOVERABLE_IF(value > 0x3ffff); 5754 TheStructure.Common.SourcePitch = value - 1; 5755 } 5756 inline uint32_t getSourcePitch() const { 5757 return TheStructure.Common.SourcePitch + 1; 5758 } 5759 inline void setSourceMocs(const uint32_t value) { 5760 UNRECOVERABLE_IF(value > 0x7f); 5761 TheStructure.Common.SourceMocs = value; 5762 } 5763 inline uint32_t getSourceMocs() const { 5764 return TheStructure.Common.SourceMocs; 5765 } 5766 inline void setSourceTiling(const SOURCE_TILING value) { 5767 TheStructure.Common.SourceTiling = value; 5768 } 5769 inline SOURCE_TILING getSourceTiling() const { 5770 return static_cast<SOURCE_TILING>(TheStructure.Common.SourceTiling); 5771 } 5772 inline void setSourceBaseAddress(const uint64_t value) { 5773 TheStructure.Common.SourceBaseAddress = value; 5774 } 5775 inline uint64_t getSourceBaseAddress() const { 5776 return TheStructure.Common.SourceBaseAddress; 5777 } 5778 inline void setSourceXOffset(const uint32_t value) { 5779 UNRECOVERABLE_IF(value > 0x3fff); 5780 TheStructure.Common.SourceXOffset = value; 5781 } 5782 inline uint32_t getSourceXOffset() const { 5783 return TheStructure.Common.SourceXOffset; 5784 } 5785 inline void setSourceYOffset(const uint32_t value) { 5786 UNRECOVERABLE_IF(value > 0x3fff); 5787 TheStructure.Common.SourceYOffset = value; 5788 } 5789 inline uint32_t getSourceYOffset() const { 5790 return TheStructure.Common.SourceYOffset; 5791 } 5792} XY_BLOCK_COPY_BLT; 5793STATIC_ASSERT(48 == sizeof(XY_BLOCK_COPY_BLT)); 5794 5795typedef struct tagXY_FAST_COLOR_BLT { 5796 union tagTheStructure { 5797 struct tagCommon { 5798 // DWORD 0 5799 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 5800 uint32_t Reserved_8 : BITFIELD_RANGE(8, 18); 5801 uint32_t ColorDepth : BITFIELD_RANGE(19, 21); 5802 uint32_t InstructionTarget_Opcode : BITFIELD_RANGE(22, 28); 5803 uint32_t Client : BITFIELD_RANGE(29, 31); 5804 // DWORD 1 5805 uint32_t DestinationPitch : BITFIELD_RANGE(0, 17); 5806 uint32_t Reserved_50 : BITFIELD_RANGE(18, 20); 5807 uint32_t DestinationMOCS : BITFIELD_RANGE(21, 27); 5808 uint32_t Reserved_60 : BITFIELD_RANGE(28, 29); 5809 uint32_t DestinationTiling : BITFIELD_RANGE(30, 31); 5810 // DWORD 2 5811 uint32_t DestinationX1Coordinate_Left : BITFIELD_RANGE(0, 15); 5812 uint32_t DestinationY1Coordinate_Top : BITFIELD_RANGE(16, 31); 5813 // DWORD 3 5814 uint32_t DestinationX2Coordinate_Right : BITFIELD_RANGE(0, 15); 5815 uint32_t DestinationY2Coordinate_Bottom : BITFIELD_RANGE(16, 31); 5816 // DWORD 4 5817 uint64_t DestinationBaseAddress; 5818 // DWORD 6 5819 uint32_t DestinationXOffset : BITFIELD_RANGE(0, 13); 5820 uint32_t Reserved_206 : BITFIELD_RANGE(14, 15); 5821 uint32_t DestinationYOffset : BITFIELD_RANGE(16, 29); 5822 uint32_t Reserved_222 : BITFIELD_RANGE(30, 31); 5823 // DWORD 7 5824 uint32_t FillColor[4]; 5825 // DWORD 11 5826 uint32_t DestinationClearAddressHigh : BITFIELD_RANGE(0, 15); 5827 uint32_t Reserved_368 : BITFIELD_RANGE(16, 31); 5828 } Common; 5829 uint32_t RawData[12]; 5830 } TheStructure; 5831 typedef enum tagDWORD_LENGTH { 5832 DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x9, 5833 } DWORD_LENGTH; 5834 typedef enum tagCOLOR_DEPTH { 5835 COLOR_DEPTH_8_BIT_COLOR = 0x0, 5836 COLOR_DEPTH_16_BIT_COLOR = 0x1, 5837 COLOR_DEPTH_32_BIT_COLOR = 0x2, 5838 COLOR_DEPTH_64_BIT_COLOR = 0x3, 5839 COLOR_DEPTH_96_BIT_COLOR_ONLY_SUPPORTED_FOR_LINEAR_CASE = 0x4, 5840 COLOR_DEPTH_128_BIT_COLOR = 0x5, 5841 } COLOR_DEPTH; 5842 typedef enum tagCLIENT { 5843 CLIENT_2D_PROCESSOR = 0x2, 5844 } CLIENT; 5845 typedef enum tagDESTINATION_TILING { 5846 DESTINATION_TILING_YMAJOR = 0x1, 5847 } DESTINATION_TILING; 5848 typedef enum tagINSTRUCTIONTARGET_OPCODE { 5849 INSTRUCTIONTARGET_OPCODE_OPCODE = 0x44, 5850 } INSTRUCTIONTARGET_OPCODE; 5851 inline void init() { 5852 memset(&TheStructure, 0, sizeof(TheStructure)); 5853 TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1; 5854 TheStructure.Common.ColorDepth = COLOR_DEPTH_8_BIT_COLOR; 5855 TheStructure.Common.Client = CLIENT_2D_PROCESSOR; 5856 TheStructure.Common.InstructionTarget_Opcode = INSTRUCTIONTARGET_OPCODE::INSTRUCTIONTARGET_OPCODE_OPCODE; 5857 } 5858 static tagXY_FAST_COLOR_BLT sInit() { 5859 XY_FAST_COLOR_BLT state; 5860 state.init(); 5861 return state; 5862 } 5863 inline uint32_t &getRawData(const uint32_t index) { 5864 UNRECOVERABLE_IF(index >= 12); 5865 return TheStructure.RawData[index]; 5866 } 5867 inline void setColorDepth(const COLOR_DEPTH value) { 5868 TheStructure.Common.ColorDepth = value; 5869 } 5870 inline COLOR_DEPTH getColorDepth() const { 5871 return static_cast<COLOR_DEPTH>(TheStructure.Common.ColorDepth); 5872 } 5873 inline void setInstructionTargetOpcode(const uint32_t value) { 5874 UNRECOVERABLE_IF(value > 0x7f); 5875 TheStructure.Common.InstructionTarget_Opcode = value; 5876 } 5877 inline uint32_t getInstructionTargetOpcode() const { 5878 return TheStructure.Common.InstructionTarget_Opcode; 5879 } 5880 inline void setClient(const CLIENT value) { 5881 TheStructure.Common.Client = value; 5882 } 5883 inline CLIENT getClient() const { 5884 return static_cast<CLIENT>(TheStructure.Common.Client); 5885 } 5886 inline void setDestinationPitch(const uint32_t value) { 5887 TheStructure.Common.DestinationPitch = value - 1; 5888 } 5889 inline uint32_t getDestinationPitch() const { 5890 return TheStructure.Common.DestinationPitch + 1; 5891 } 5892 inline void setDestinationMOCS(const uint32_t value) { 5893 UNRECOVERABLE_IF(value > 0x7f); 5894 TheStructure.Common.DestinationMOCS = value; 5895 } 5896 inline uint32_t getDestinationMOCS() const { 5897 return TheStructure.Common.DestinationMOCS; 5898 } 5899 inline void setDestinationTiling(const DESTINATION_TILING value) { 5900 TheStructure.Common.DestinationTiling = value; 5901 } 5902 inline DESTINATION_TILING getDestinationTiling() const { 5903 return static_cast<DESTINATION_TILING>(TheStructure.Common.DestinationTiling); 5904 } 5905 inline void setDestinationX1CoordinateLeft(const uint32_t value) { 5906 UNRECOVERABLE_IF(value > 0xffff); 5907 TheStructure.Common.DestinationX1Coordinate_Left = value; 5908 } 5909 inline uint32_t getDestinationX1CoordinateLeft() const { 5910 return TheStructure.Common.DestinationX1Coordinate_Left; 5911 } 5912 inline void setDestinationY1CoordinateTop(const uint32_t value) { 5913 UNRECOVERABLE_IF(value > 0xffff); 5914 TheStructure.Common.DestinationY1Coordinate_Top = value; 5915 } 5916 inline uint32_t getDestinationY1CoordinateTop() const { 5917 return TheStructure.Common.DestinationY1Coordinate_Top; 5918 } 5919 inline void setDestinationX2CoordinateRight(const uint32_t value) { 5920 UNRECOVERABLE_IF(value > 0xffff); 5921 TheStructure.Common.DestinationX2Coordinate_Right = value; 5922 } 5923 inline uint32_t getDestinationX2CoordinateRight() const { 5924 return TheStructure.Common.DestinationX2Coordinate_Right; 5925 } 5926 inline void setDestinationY2CoordinateBottom(const uint32_t value) { 5927 UNRECOVERABLE_IF(value > 0xffff); 5928 TheStructure.Common.DestinationY2Coordinate_Bottom = value; 5929 } 5930 inline uint32_t getDestinationY2CoordinateBottom() const { 5931 return TheStructure.Common.DestinationY2Coordinate_Bottom; 5932 } 5933 inline void setDestinationBaseAddress(const uint64_t value) { 5934 TheStructure.Common.DestinationBaseAddress = value; 5935 } 5936 inline uint64_t getDestinationBaseAddress() const { 5937 return TheStructure.Common.DestinationBaseAddress; 5938 } 5939 inline void setDestinationXOffset(const uint32_t value) { 5940 UNRECOVERABLE_IF(value > 0x3fff); 5941 TheStructure.Common.DestinationXOffset = value; 5942 } 5943 inline uint32_t getDestinationXOffset() const { 5944 return TheStructure.Common.DestinationXOffset; 5945 } 5946 inline void setDestinationYOffset(const uint32_t value) { 5947 UNRECOVERABLE_IF(value > 0x3fff); 5948 TheStructure.Common.DestinationYOffset = value; 5949 } 5950 inline uint32_t getDestinationYOffset() const { 5951 return TheStructure.Common.DestinationYOffset; 5952 } 5953 inline void setFillColor(const uint32_t *value) { 5954 TheStructure.Common.FillColor[0] = value[0]; 5955 TheStructure.Common.FillColor[1] = value[1]; 5956 TheStructure.Common.FillColor[2] = value[2]; 5957 TheStructure.Common.FillColor[3] = value[3]; 5958 } 5959 inline void setDestinationClearAddressHigh(const uint32_t value) { 5960 UNRECOVERABLE_IF(value > 0xffff); 5961 TheStructure.Common.DestinationClearAddressHigh = value; 5962 } 5963 inline uint32_t getDestinationClearAddressHigh() const { 5964 return TheStructure.Common.DestinationClearAddressHigh; 5965 } 5966} XY_FAST_COLOR_BLT; 5967STATIC_ASSERT(48 == sizeof(XY_FAST_COLOR_BLT)); 5968 5969typedef struct tagSAMPLER_BORDER_COLOR_STATE { 5970 union tagTheStructure { 5971 struct tagCommon { 5972 // DWORD 0 5973 float BorderColorRed; 5974 // DWORD 1 5975 float BorderColorGreen; 5976 // DWORD 2 5977 float BorderColorBlue; 5978 // DWORD 3 5979 float BorderColorAlpha; 5980 } Common; 5981 uint32_t RawData[4]; 5982 } TheStructure; 5983 inline void init() { 5984 memset(&TheStructure, 0, sizeof(TheStructure)); 5985 TheStructure.Common.BorderColorRed = 0.0; 5986 TheStructure.Common.BorderColorGreen = 0.0; 5987 TheStructure.Common.BorderColorBlue = 0.0; 5988 TheStructure.Common.BorderColorAlpha = 0.0; 5989 } 5990 static tagSAMPLER_BORDER_COLOR_STATE sInit() { 5991 SAMPLER_BORDER_COLOR_STATE state; 5992 state.init(); 5993 return state; 5994 } 5995 inline uint32_t &getRawData(const uint32_t index) { 5996 UNRECOVERABLE_IF(index >= 4); 5997 return TheStructure.RawData[index]; 5998 } 5999 inline void setBorderColorRed(const float value) { 6000 TheStructure.Common.BorderColorRed = value; 6001 } 6002 inline float getBorderColorRed() const { 6003 return TheStructure.Common.BorderColorRed; 6004 } 6005 inline void setBorderColorGreen(const float value) { 6006 TheStructure.Common.BorderColorGreen = value; 6007 } 6008 inline float getBorderColorGreen() const { 6009 return TheStructure.Common.BorderColorGreen; 6010 } 6011 inline void setBorderColorBlue(const float value) { 6012 TheStructure.Common.BorderColorBlue = value; 6013 } 6014 inline float getBorderColorBlue() const { 6015 return TheStructure.Common.BorderColorBlue; 6016 } 6017 inline void setBorderColorAlpha(const float value) { 6018 TheStructure.Common.BorderColorAlpha = value; 6019 } 6020 inline float getBorderColorAlpha() const { 6021 return TheStructure.Common.BorderColorAlpha; 6022 } 6023} SAMPLER_BORDER_COLOR_STATE; 6024STATIC_ASSERT(16 == sizeof(SAMPLER_BORDER_COLOR_STATE)); 6025 6026#pragma pack() 6027