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 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 55 uint32_t PredicateEnable : BITFIELD_RANGE(8, 8); 56 uint32_t Reserved_9 : BITFIELD_RANGE(9, 9); 57 uint32_t IndirectParameterEnable : BITFIELD_RANGE(10, 10); 58 uint32_t Reserved_11 : BITFIELD_RANGE(11, 15); 59 uint32_t Subopcode : BITFIELD_RANGE(16, 23); 60 uint32_t MediaCommandOpcode : BITFIELD_RANGE(24, 26); 61 uint32_t Pipeline : BITFIELD_RANGE(27, 28); 62 uint32_t CommandType : BITFIELD_RANGE(29, 31); 63 uint32_t InterfaceDescriptorOffset : BITFIELD_RANGE(0, 5); 64 uint32_t Reserved_38 : BITFIELD_RANGE(6, 31); 65 uint32_t IndirectDataLength : BITFIELD_RANGE(0, 16); 66 uint32_t Reserved_81 : BITFIELD_RANGE(17, 31); 67 uint32_t Reserved_96 : BITFIELD_RANGE(0, 5); 68 uint32_t IndirectDataStartAddress : BITFIELD_RANGE(6, 31); 69 uint32_t ThreadWidthCounterMaximum : BITFIELD_RANGE(0, 5); 70 uint32_t Reserved_134 : BITFIELD_RANGE(6, 7); 71 uint32_t ThreadHeightCounterMaximum : BITFIELD_RANGE(8, 13); 72 uint32_t Reserved_142 : BITFIELD_RANGE(14, 15); 73 uint32_t ThreadDepthCounterMaximum : BITFIELD_RANGE(16, 21); 74 uint32_t Reserved_150 : BITFIELD_RANGE(22, 29); 75 uint32_t SimdSize : BITFIELD_RANGE(30, 31); 76 uint32_t ThreadGroupIdStartingX; 77 uint32_t Reserved_192; 78 uint32_t ThreadGroupIdXDimension; 79 uint32_t ThreadGroupIdStartingY; 80 uint32_t Reserved_288; 81 uint32_t ThreadGroupIdYDimension; 82 uint32_t ThreadGroupIdStartingResumeZ; 83 uint32_t ThreadGroupIdZDimension; 84 uint32_t RightExecutionMask; 85 uint32_t BottomExecutionMask; 86 } Common; 87 uint32_t RawData[15]; 88 } TheStructure; 89 typedef enum tagDWORD_LENGTH { 90 DWORD_LENGTH_DWORD_COUNT_N = 0xd, 91 } DWORD_LENGTH; 92 typedef enum tagSUBOPCODE { 93 SUBOPCODE_GPGPU_WALKER_SUBOP = 0x5, 94 } SUBOPCODE; 95 typedef enum tagMEDIA_COMMAND_OPCODE { 96 MEDIA_COMMAND_OPCODE_GPGPU_WALKER = 0x1, 97 } MEDIA_COMMAND_OPCODE; 98 typedef enum tagPIPELINE { 99 PIPELINE_MEDIA = 0x2, 100 } PIPELINE; 101 typedef enum tagCOMMAND_TYPE { 102 COMMAND_TYPE_GFXPIPE = 0x3, 103 } COMMAND_TYPE; 104 typedef enum tagSIMD_SIZE { 105 SIMD_SIZE_SIMD8 = 0x0, 106 SIMD_SIZE_SIMD16 = 0x1, 107 SIMD_SIZE_SIMD32 = 0x2, 108 } SIMD_SIZE; 109 typedef enum tagPATCH_CONSTANTS { 110 INDIRECTDATASTARTADDRESS_BYTEOFFSET = 0xc, 111 INDIRECTDATASTARTADDRESS_INDEX = 0x3, 112 } PATCH_CONSTANTS; 113 inline void init() { 114 memset(&TheStructure, 0, sizeof(TheStructure)); 115 TheStructure.Common.DwordLength = DWORD_LENGTH_DWORD_COUNT_N; 116 TheStructure.Common.Subopcode = SUBOPCODE_GPGPU_WALKER_SUBOP; 117 TheStructure.Common.MediaCommandOpcode = MEDIA_COMMAND_OPCODE_GPGPU_WALKER; 118 TheStructure.Common.Pipeline = PIPELINE_MEDIA; 119 TheStructure.Common.CommandType = COMMAND_TYPE_GFXPIPE; 120 TheStructure.Common.SimdSize = SIMD_SIZE_SIMD8; 121 } 122 static tagGPGPU_WALKER sInit() { 123 GPGPU_WALKER state; 124 state.init(); 125 return state; 126 } 127 inline uint32_t &getRawData(const uint32_t index) { 128 DEBUG_BREAK_IF(index >= 15); 129 return TheStructure.RawData[index]; 130 } 131 inline void setPredicateEnable(const bool value) { 132 TheStructure.Common.PredicateEnable = value; 133 } 134 inline bool getPredicateEnable() const { 135 return (TheStructure.Common.PredicateEnable); 136 } 137 inline void setIndirectParameterEnable(const bool value) { 138 TheStructure.Common.IndirectParameterEnable = value; 139 } 140 inline bool getIndirectParameterEnable() const { 141 return (TheStructure.Common.IndirectParameterEnable); 142 } 143 inline void setInterfaceDescriptorOffset(const uint32_t value) { 144 TheStructure.Common.InterfaceDescriptorOffset = value; 145 } 146 inline uint32_t getInterfaceDescriptorOffset() const { 147 return (TheStructure.Common.InterfaceDescriptorOffset); 148 } 149 inline void setIndirectDataLength(const uint32_t value) { 150 TheStructure.Common.IndirectDataLength = value; 151 } 152 inline uint32_t getIndirectDataLength() const { 153 return (TheStructure.Common.IndirectDataLength); 154 } 155 typedef enum tagINDIRECTDATASTARTADDRESS { 156 INDIRECTDATASTARTADDRESS_BIT_SHIFT = 0x6, 157 INDIRECTDATASTARTADDRESS_ALIGN_SIZE = 0x40, 158 } INDIRECTDATASTARTADDRESS; 159 inline void setIndirectDataStartAddress(const uint32_t value) { 160 TheStructure.Common.IndirectDataStartAddress = value >> INDIRECTDATASTARTADDRESS_BIT_SHIFT; 161 } 162 inline uint32_t getIndirectDataStartAddress() const { 163 return (TheStructure.Common.IndirectDataStartAddress << INDIRECTDATASTARTADDRESS_BIT_SHIFT); 164 } 165 inline void setThreadWidthCounterMaximum(const uint32_t value) { 166 TheStructure.Common.ThreadWidthCounterMaximum = value - 1; 167 } 168 inline uint32_t getThreadWidthCounterMaximum() const { 169 return (TheStructure.Common.ThreadWidthCounterMaximum + 1); 170 } 171 inline void setThreadHeightCounterMaximum(const uint32_t value) { 172 TheStructure.Common.ThreadHeightCounterMaximum = value - 1; 173 } 174 inline uint32_t getThreadHeightCounterMaximum() const { 175 return (TheStructure.Common.ThreadHeightCounterMaximum + 1); 176 } 177 inline void setThreadDepthCounterMaximum(const uint32_t value) { 178 TheStructure.Common.ThreadDepthCounterMaximum = value; 179 } 180 inline uint32_t getThreadDepthCounterMaximum() const { 181 return (TheStructure.Common.ThreadDepthCounterMaximum); 182 } 183 inline void setSimdSize(const SIMD_SIZE value) { 184 TheStructure.Common.SimdSize = value; 185 } 186 inline SIMD_SIZE getSimdSize() const { 187 return static_cast<SIMD_SIZE>(TheStructure.Common.SimdSize); 188 } 189 inline void setThreadGroupIdStartingX(const uint32_t value) { 190 TheStructure.Common.ThreadGroupIdStartingX = value; 191 } 192 inline uint32_t getThreadGroupIdStartingX() const { 193 return (TheStructure.Common.ThreadGroupIdStartingX); 194 } 195 inline void setThreadGroupIdXDimension(const uint32_t value) { 196 TheStructure.Common.ThreadGroupIdXDimension = value; 197 } 198 inline uint32_t getThreadGroupIdXDimension() const { 199 return (TheStructure.Common.ThreadGroupIdXDimension); 200 } 201 inline void setThreadGroupIdStartingY(const uint32_t value) { 202 TheStructure.Common.ThreadGroupIdStartingY = value; 203 } 204 inline uint32_t getThreadGroupIdStartingY() const { 205 return (TheStructure.Common.ThreadGroupIdStartingY); 206 } 207 inline void setThreadGroupIdYDimension(const uint32_t value) { 208 TheStructure.Common.ThreadGroupIdYDimension = value; 209 } 210 inline uint32_t getThreadGroupIdYDimension() const { 211 return (TheStructure.Common.ThreadGroupIdYDimension); 212 } 213 inline void setThreadGroupIdStartingResumeZ(const uint32_t value) { 214 TheStructure.Common.ThreadGroupIdStartingResumeZ = value; 215 } 216 inline uint32_t getThreadGroupIdStartingResumeZ() const { 217 return (TheStructure.Common.ThreadGroupIdStartingResumeZ); 218 } 219 inline void setThreadGroupIdZDimension(const uint32_t value) { 220 TheStructure.Common.ThreadGroupIdZDimension = value; 221 } 222 inline uint32_t getThreadGroupIdZDimension() const { 223 return (TheStructure.Common.ThreadGroupIdZDimension); 224 } 225 inline void setRightExecutionMask(const uint32_t value) { 226 TheStructure.Common.RightExecutionMask = value; 227 } 228 inline uint32_t getRightExecutionMask() const { 229 return (TheStructure.Common.RightExecutionMask); 230 } 231 inline void setBottomExecutionMask(const uint32_t value) { 232 TheStructure.Common.BottomExecutionMask = value; 233 } 234 inline uint32_t getBottomExecutionMask() const { 235 return (TheStructure.Common.BottomExecutionMask); 236 } 237} GPGPU_WALKER; 238STATIC_ASSERT(60 == sizeof(GPGPU_WALKER)); 239 240typedef struct tagINTERFACE_DESCRIPTOR_DATA { 241 union tagTheStructure { 242 struct tagCommon { 243 uint32_t Reserved_0 : BITFIELD_RANGE(0, 5); 244 uint32_t KernelStartPointer : BITFIELD_RANGE(6, 31); 245 uint32_t KernelStartPointerHigh : BITFIELD_RANGE(0, 15); 246 uint32_t Reserved_48 : BITFIELD_RANGE(16, 31); 247 uint32_t Reserved_64 : BITFIELD_RANGE(0, 6); 248 uint32_t SoftwareExceptionEnable : BITFIELD_RANGE(7, 7); 249 uint32_t Reserved_72 : BITFIELD_RANGE(8, 10); 250 uint32_t MaskStackExceptionEnable : BITFIELD_RANGE(11, 11); 251 uint32_t Reserved_76 : BITFIELD_RANGE(12, 12); 252 uint32_t IllegalOpcodeExceptionEnable : BITFIELD_RANGE(13, 13); 253 uint32_t Reserved_78 : BITFIELD_RANGE(14, 15); 254 uint32_t FloatingPointMode : BITFIELD_RANGE(16, 16); 255 uint32_t ThreadPriority : BITFIELD_RANGE(17, 17); 256 uint32_t SingleProgramFlow : BITFIELD_RANGE(18, 18); 257 uint32_t DenormMode : BITFIELD_RANGE(19, 19); 258 uint32_t Reserved_84 : BITFIELD_RANGE(20, 31); 259 uint32_t Reserved_96 : BITFIELD_RANGE(0, 1); 260 uint32_t SamplerCount : BITFIELD_RANGE(2, 4); 261 uint32_t SamplerStatePointer : BITFIELD_RANGE(5, 31); 262 uint32_t BindingTableEntryCount : BITFIELD_RANGE(0, 4); 263 uint32_t BindingTablePointer : BITFIELD_RANGE(5, 15); 264 uint32_t Reserved_144 : BITFIELD_RANGE(16, 31); 265 uint32_t ConstantUrbEntryReadOffset : BITFIELD_RANGE(0, 15); 266 uint32_t ConstantIndirectUrbEntryReadLength : BITFIELD_RANGE(16, 31); 267 uint32_t NumberOfThreadsInGpgpuThreadGroup : BITFIELD_RANGE(0, 9); 268 uint32_t Reserved_202 : BITFIELD_RANGE(10, 15); 269 uint32_t SharedLocalMemorySize : BITFIELD_RANGE(16, 20); 270 uint32_t BarrierEnable : BITFIELD_RANGE(21, 21); 271 uint32_t RoundingMode : BITFIELD_RANGE(22, 23); 272 uint32_t Reserved_216 : BITFIELD_RANGE(24, 31); 273 uint32_t Cross_ThreadConstantDataReadLength : BITFIELD_RANGE(0, 7); 274 uint32_t Reserved_232 : BITFIELD_RANGE(8, 31); 275 } Common; 276 uint32_t RawData[8]; 277 } TheStructure; 278 typedef enum tagFLOATING_POINT_MODE { 279 FLOATING_POINT_MODE_IEEE_754 = 0x0, 280 FLOATING_POINT_MODE_ALTERNATE = 0x1, 281 } FLOATING_POINT_MODE; 282 typedef enum tagTHREAD_PRIORITY { 283 THREAD_PRIORITY_NORMAL_PRIORITY = 0x0, 284 THREAD_PRIORITY_HIGH_PRIORITY = 0x1, 285 } THREAD_PRIORITY; 286 typedef enum tagSINGLE_PROGRAM_FLOW { 287 SINGLE_PROGRAM_FLOW_MULTIPLE = 0x0, 288 SINGLE_PROGRAM_FLOW_SINGLE = 0x1, 289 } SINGLE_PROGRAM_FLOW; 290 typedef enum tagDENORM_MODE { 291 DENORM_MODE_FTZ = 0x0, 292 DENORM_MODE_SETBYKERNEL = 0x1, 293 } DENORM_MODE; 294 typedef enum tagSAMPLER_COUNT { 295 SAMPLER_COUNT_NO_SAMPLERS_USED = 0x0, 296 SAMPLER_COUNT_BETWEEN_1_AND_4_SAMPLERS_USED = 0x1, 297 SAMPLER_COUNT_BETWEEN_5_AND_8_SAMPLERS_USED = 0x2, 298 SAMPLER_COUNT_BETWEEN_9_AND_12_SAMPLERS_USED = 0x3, 299 SAMPLER_COUNT_BETWEEN_13_AND_16_SAMPLERS_USED = 0x4, 300 } SAMPLER_COUNT; 301 typedef enum tagSHARED_LOCAL_MEMORY_SIZE { 302 SHARED_LOCAL_MEMORY_SIZE_ENCODES_0K = 0x0, 303 SHARED_LOCAL_MEMORY_SIZE_ENCODES_4K = 0x1, 304 SHARED_LOCAL_MEMORY_SIZE_ENCODES_8K = 0x2, 305 SHARED_LOCAL_MEMORY_SIZE_ENCODES_16K = 0x4, 306 SHARED_LOCAL_MEMORY_SIZE_ENCODES_32K = 0x8, 307 SHARED_LOCAL_MEMORY_SIZE_ENCODES_64K = 0x10, 308 } SHARED_LOCAL_MEMORY_SIZE; 309 typedef enum tagROUNDING_MODE { 310 ROUNDING_MODE_RTNE = 0x0, 311 ROUNDING_MODE_RU = 0x1, 312 ROUNDING_MODE_RD = 0x2, 313 ROUNDING_MODE_RTZ = 0x3, 314 } ROUNDING_MODE; 315 typedef enum tagPATCH_CONSTANTS { 316 KERNELSTARTPOINTER_BYTEOFFSET = 0x0, 317 KERNELSTARTPOINTER_INDEX = 0x0, 318 KERNELSTARTPOINTERHIGH_BYTEOFFSET = 0x4, 319 KERNELSTARTPOINTERHIGH_INDEX = 0x1, 320 SAMPLERSTATEPOINTER_BYTEOFFSET = 0xc, 321 SAMPLERSTATEPOINTER_INDEX = 0x3, 322 BINDINGTABLEPOINTER_BYTEOFFSET = 0x10, 323 BINDINGTABLEPOINTER_INDEX = 0x4, 324 } PATCH_CONSTANTS; 325 inline void init() { 326 memset(&TheStructure, 0, sizeof(TheStructure)); 327 TheStructure.Common.FloatingPointMode = FLOATING_POINT_MODE_IEEE_754; 328 TheStructure.Common.ThreadPriority = THREAD_PRIORITY_NORMAL_PRIORITY; 329 TheStructure.Common.SingleProgramFlow = SINGLE_PROGRAM_FLOW_MULTIPLE; 330 TheStructure.Common.DenormMode = DENORM_MODE_FTZ; 331 TheStructure.Common.SamplerCount = SAMPLER_COUNT_NO_SAMPLERS_USED; 332 TheStructure.Common.SharedLocalMemorySize = SHARED_LOCAL_MEMORY_SIZE_ENCODES_0K; 333 TheStructure.Common.RoundingMode = ROUNDING_MODE_RTNE; 334 } 335 static tagINTERFACE_DESCRIPTOR_DATA sInit() { 336 INTERFACE_DESCRIPTOR_DATA state; 337 state.init(); 338 return state; 339 } 340 inline uint32_t &getRawData(const uint32_t index) { 341 DEBUG_BREAK_IF(index >= 8); 342 return TheStructure.RawData[index]; 343 } 344 typedef enum tagKERNELSTARTPOINTER { 345 KERNELSTARTPOINTER_BIT_SHIFT = 0x6, 346 KERNELSTARTPOINTER_ALIGN_SIZE = 0x40, 347 } KERNELSTARTPOINTER; 348 inline void setKernelStartPointer(const uint64_t value) { 349 DEBUG_BREAK_IF(value >= 0x100000000); 350 TheStructure.Common.KernelStartPointer = (uint32_t)value >> KERNELSTARTPOINTER_BIT_SHIFT; 351 } 352 inline uint32_t getKernelStartPointer() const { 353 return (TheStructure.Common.KernelStartPointer << KERNELSTARTPOINTER_BIT_SHIFT); 354 } 355 inline void setKernelStartPointerHigh(const uint32_t value) { 356 TheStructure.Common.KernelStartPointerHigh = value; 357 } 358 inline uint32_t getKernelStartPointerHigh() const { 359 return (TheStructure.Common.KernelStartPointerHigh); 360 } 361 inline void setSoftwareExceptionEnable(const bool value) { 362 TheStructure.Common.SoftwareExceptionEnable = value; 363 } 364 inline bool getSoftwareExceptionEnable() const { 365 return (TheStructure.Common.SoftwareExceptionEnable); 366 } 367 inline void setMaskStackExceptionEnable(const bool value) { 368 TheStructure.Common.MaskStackExceptionEnable = value; 369 } 370 inline bool getMaskStackExceptionEnable() const { 371 return (TheStructure.Common.MaskStackExceptionEnable); 372 } 373 inline void setIllegalOpcodeExceptionEnable(const bool value) { 374 TheStructure.Common.IllegalOpcodeExceptionEnable = value; 375 } 376 inline bool getIllegalOpcodeExceptionEnable() const { 377 return (TheStructure.Common.IllegalOpcodeExceptionEnable); 378 } 379 inline void setFloatingPointMode(const FLOATING_POINT_MODE value) { 380 TheStructure.Common.FloatingPointMode = value; 381 } 382 inline FLOATING_POINT_MODE getFloatingPointMode() const { 383 return static_cast<FLOATING_POINT_MODE>(TheStructure.Common.FloatingPointMode); 384 } 385 inline void setThreadPriority(const THREAD_PRIORITY value) { 386 TheStructure.Common.ThreadPriority = value; 387 } 388 inline THREAD_PRIORITY getThreadPriority() const { 389 return static_cast<THREAD_PRIORITY>(TheStructure.Common.ThreadPriority); 390 } 391 inline void setSingleProgramFlow(const SINGLE_PROGRAM_FLOW value) { 392 TheStructure.Common.SingleProgramFlow = value; 393 } 394 inline SINGLE_PROGRAM_FLOW getSingleProgramFlow() const { 395 return static_cast<SINGLE_PROGRAM_FLOW>(TheStructure.Common.SingleProgramFlow); 396 } 397 inline void setDenormMode(const DENORM_MODE value) { 398 TheStructure.Common.DenormMode = value; 399 } 400 inline DENORM_MODE getDenormMode() const { 401 return static_cast<DENORM_MODE>(TheStructure.Common.DenormMode); 402 } 403 inline void setSamplerCount(const SAMPLER_COUNT value) { 404 TheStructure.Common.SamplerCount = value; 405 } 406 inline SAMPLER_COUNT getSamplerCount() const { 407 return static_cast<SAMPLER_COUNT>(TheStructure.Common.SamplerCount); 408 } 409 typedef enum tagSAMPLERSTATEPOINTER { 410 SAMPLERSTATEPOINTER_BIT_SHIFT = 0x5, 411 SAMPLERSTATEPOINTER_ALIGN_SIZE = 0x20, 412 } SAMPLERSTATEPOINTER; 413 inline void setSamplerStatePointer(const uint64_t value) { 414 DEBUG_BREAK_IF(value >= 0x100000000); 415 TheStructure.Common.SamplerStatePointer = (uint32_t)value >> SAMPLERSTATEPOINTER_BIT_SHIFT; 416 } 417 inline uint32_t getSamplerStatePointer() const { 418 return (TheStructure.Common.SamplerStatePointer << SAMPLERSTATEPOINTER_BIT_SHIFT); 419 } 420 inline void setBindingTableEntryCount(const uint32_t value) { 421 TheStructure.Common.BindingTableEntryCount = value; 422 } 423 inline uint32_t getBindingTableEntryCount() const { 424 return (TheStructure.Common.BindingTableEntryCount); 425 } 426 typedef enum tagBINDINGTABLEPOINTER { 427 BINDINGTABLEPOINTER_BIT_SHIFT = 0x5, 428 BINDINGTABLEPOINTER_ALIGN_SIZE = 0x20, 429 } BINDINGTABLEPOINTER; 430 inline void setBindingTablePointer(const uint64_t value) { 431 DEBUG_BREAK_IF(value >= 0x100000000); 432 TheStructure.Common.BindingTablePointer = (uint32_t)value >> BINDINGTABLEPOINTER_BIT_SHIFT; 433 } 434 inline uint32_t getBindingTablePointer() const { 435 return (TheStructure.Common.BindingTablePointer << BINDINGTABLEPOINTER_BIT_SHIFT); 436 } 437 inline void setConstantUrbEntryReadOffset(const uint32_t value) { 438 TheStructure.Common.ConstantUrbEntryReadOffset = value; 439 } 440 inline uint32_t getConstantUrbEntryReadOffset() const { 441 return (TheStructure.Common.ConstantUrbEntryReadOffset); 442 } 443 inline void setConstantIndirectUrbEntryReadLength(const uint32_t value) { 444 TheStructure.Common.ConstantIndirectUrbEntryReadLength = value; 445 } 446 inline uint32_t getConstantIndirectUrbEntryReadLength() const { 447 return (TheStructure.Common.ConstantIndirectUrbEntryReadLength); 448 } 449 inline void setNumberOfThreadsInGpgpuThreadGroup(const uint32_t value) { 450 TheStructure.Common.NumberOfThreadsInGpgpuThreadGroup = value; 451 } 452 inline uint32_t getNumberOfThreadsInGpgpuThreadGroup() const { 453 return (TheStructure.Common.NumberOfThreadsInGpgpuThreadGroup); 454 } 455 inline void setSharedLocalMemorySize(const SHARED_LOCAL_MEMORY_SIZE value) { 456 TheStructure.Common.SharedLocalMemorySize = value; 457 } 458 inline SHARED_LOCAL_MEMORY_SIZE getSharedLocalMemorySize() const { 459 return static_cast<SHARED_LOCAL_MEMORY_SIZE>(TheStructure.Common.SharedLocalMemorySize); 460 } 461 inline void setBarrierEnable(const uint32_t value) { 462 TheStructure.Common.BarrierEnable = (value > 0u) ? 1u : 0u; 463 } 464 inline bool getBarrierEnable() const { 465 return (TheStructure.Common.BarrierEnable); 466 } 467 inline void setRoundingMode(const ROUNDING_MODE value) { 468 TheStructure.Common.RoundingMode = value; 469 } 470 inline ROUNDING_MODE getRoundingMode() const { 471 return static_cast<ROUNDING_MODE>(TheStructure.Common.RoundingMode); 472 } 473 inline void setCrossThreadConstantDataReadLength(const uint32_t value) { 474 TheStructure.Common.Cross_ThreadConstantDataReadLength = value; 475 } 476 inline uint32_t getCrossThreadConstantDataReadLength() const { 477 return (TheStructure.Common.Cross_ThreadConstantDataReadLength); 478 } 479} INTERFACE_DESCRIPTOR_DATA; 480STATIC_ASSERT(32 == sizeof(INTERFACE_DESCRIPTOR_DATA)); 481 482typedef struct tagMEDIA_INTERFACE_DESCRIPTOR_LOAD { 483 union tagTheStructure { 484 struct tagCommon { 485 uint32_t DwordLength : BITFIELD_RANGE(0, 15); 486 uint32_t Subopcode : BITFIELD_RANGE(16, 23); 487 uint32_t MediaCommandOpcode : BITFIELD_RANGE(24, 26); 488 uint32_t Pipeline : BITFIELD_RANGE(27, 28); 489 uint32_t CommandType : BITFIELD_RANGE(29, 31); 490 uint32_t Reserved_32; 491 uint32_t InterfaceDescriptorTotalLength : BITFIELD_RANGE(0, 16); 492 uint32_t Reserved_81 : BITFIELD_RANGE(17, 31); 493 uint32_t InterfaceDescriptorDataStartAddress; 494 } Common; 495 uint32_t RawData[4]; 496 } TheStructure; 497 typedef enum tagDWORD_LENGTH { 498 DWORD_LENGTH_DWORD_COUNT_N = 0x2, 499 } DWORD_LENGTH; 500 typedef enum tagSUBOPCODE { 501 SUBOPCODE_MEDIA_INTERFACE_DESCRIPTOR_LOAD_SUBOP = 0x2, 502 } SUBOPCODE; 503 typedef enum tagMEDIA_COMMAND_OPCODE { 504 MEDIA_COMMAND_OPCODE_MEDIA_INTERFACE_DESCRIPTOR_LOAD = 0x0, 505 } MEDIA_COMMAND_OPCODE; 506 typedef enum tagPIPELINE { 507 PIPELINE_MEDIA = 0x2, 508 } PIPELINE; 509 typedef enum tagCOMMAND_TYPE { 510 COMMAND_TYPE_GFXPIPE = 0x3, 511 } COMMAND_TYPE; 512 typedef enum tagPATCH_CONSTANTS { 513 INTERFACEDESCRIPTORDATASTARTADDRESS_BYTEOFFSET = 0xc, 514 INTERFACEDESCRIPTORDATASTARTADDRESS_INDEX = 0x3, 515 } PATCH_CONSTANTS; 516 inline void init() { 517 memset(&TheStructure, 0, sizeof(TheStructure)); 518 TheStructure.Common.DwordLength = DWORD_LENGTH_DWORD_COUNT_N; 519 TheStructure.Common.Subopcode = SUBOPCODE_MEDIA_INTERFACE_DESCRIPTOR_LOAD_SUBOP; 520 TheStructure.Common.MediaCommandOpcode = MEDIA_COMMAND_OPCODE_MEDIA_INTERFACE_DESCRIPTOR_LOAD; 521 TheStructure.Common.Pipeline = PIPELINE_MEDIA; 522 TheStructure.Common.CommandType = COMMAND_TYPE_GFXPIPE; 523 } 524 static tagMEDIA_INTERFACE_DESCRIPTOR_LOAD sInit() { 525 MEDIA_INTERFACE_DESCRIPTOR_LOAD state; 526 state.init(); 527 return state; 528 } 529 inline uint32_t &getRawData(const uint32_t index) { 530 DEBUG_BREAK_IF(index >= 4); 531 return TheStructure.RawData[index]; 532 } 533 inline void setInterfaceDescriptorTotalLength(const uint32_t value) { 534 TheStructure.Common.InterfaceDescriptorTotalLength = value; 535 } 536 inline uint32_t getInterfaceDescriptorTotalLength() const { 537 return (TheStructure.Common.InterfaceDescriptorTotalLength); 538 } 539 inline void setInterfaceDescriptorDataStartAddress(const uint32_t value) { 540 TheStructure.Common.InterfaceDescriptorDataStartAddress = value; 541 } 542 inline uint32_t getInterfaceDescriptorDataStartAddress() const { 543 return (TheStructure.Common.InterfaceDescriptorDataStartAddress); 544 } 545} MEDIA_INTERFACE_DESCRIPTOR_LOAD; 546STATIC_ASSERT(16 == sizeof(MEDIA_INTERFACE_DESCRIPTOR_LOAD)); 547 548typedef struct tagMEDIA_STATE_FLUSH { 549 union tagTheStructure { 550 struct tagCommon { 551 uint32_t DwordLength : BITFIELD_RANGE(0, 15); 552 uint32_t Subopcode : BITFIELD_RANGE(16, 23); 553 uint32_t MediaCommandOpcode : BITFIELD_RANGE(24, 26); 554 uint32_t Pipeline : BITFIELD_RANGE(27, 28); 555 uint32_t CommandType : BITFIELD_RANGE(29, 31); 556 uint32_t InterfaceDescriptorOffset : BITFIELD_RANGE(0, 5); 557 uint32_t WatermarkRequired : BITFIELD_RANGE(6, 6); 558 uint32_t FlushToGo : BITFIELD_RANGE(7, 7); 559 uint32_t Reserved_40 : BITFIELD_RANGE(8, 31); 560 } Common; 561 uint32_t RawData[2]; 562 } TheStructure; 563 typedef enum tagDWORD_LENGTH { 564 DWORD_LENGTH_DWORD_COUNT_N = 0x0, 565 } DWORD_LENGTH; 566 typedef enum tagSUBOPCODE { 567 SUBOPCODE_MEDIA_STATE_FLUSH_SUBOP = 0x4, 568 } SUBOPCODE; 569 typedef enum tagMEDIA_COMMAND_OPCODE { 570 MEDIA_COMMAND_OPCODE_MEDIA_STATE_FLUSH = 0x0, 571 } MEDIA_COMMAND_OPCODE; 572 typedef enum tagPIPELINE { 573 PIPELINE_MEDIA = 0x2, 574 } PIPELINE; 575 typedef enum tagCOMMAND_TYPE { 576 COMMAND_TYPE_GFXPIPE = 0x3, 577 } COMMAND_TYPE; 578 inline void init() { 579 memset(&TheStructure, 0, sizeof(TheStructure)); 580 TheStructure.Common.DwordLength = DWORD_LENGTH_DWORD_COUNT_N; 581 TheStructure.Common.Subopcode = SUBOPCODE_MEDIA_STATE_FLUSH_SUBOP; 582 TheStructure.Common.MediaCommandOpcode = MEDIA_COMMAND_OPCODE_MEDIA_STATE_FLUSH; 583 TheStructure.Common.Pipeline = PIPELINE_MEDIA; 584 TheStructure.Common.CommandType = COMMAND_TYPE_GFXPIPE; 585 } 586 static tagMEDIA_STATE_FLUSH sInit() { 587 MEDIA_STATE_FLUSH state; 588 state.init(); 589 return state; 590 } 591 inline uint32_t &getRawData(const uint32_t index) { 592 DEBUG_BREAK_IF(index >= 2); 593 return TheStructure.RawData[index]; 594 } 595 inline void setInterfaceDescriptorOffset(const uint32_t value) { 596 TheStructure.Common.InterfaceDescriptorOffset = value; 597 } 598 inline uint32_t getInterfaceDescriptorOffset() const { 599 return (TheStructure.Common.InterfaceDescriptorOffset); 600 } 601 inline void setWatermarkRequired(const uint32_t value) { 602 TheStructure.Common.WatermarkRequired = value; 603 } 604 inline uint32_t getWatermarkRequired() const { 605 return (TheStructure.Common.WatermarkRequired); 606 } 607 inline void setFlushToGo(const bool value) { 608 TheStructure.Common.FlushToGo = value; 609 } 610 inline bool getFlushToGo() const { 611 return (TheStructure.Common.FlushToGo); 612 } 613} MEDIA_STATE_FLUSH; 614STATIC_ASSERT(8 == sizeof(MEDIA_STATE_FLUSH)); 615 616typedef struct tagMEDIA_VFE_STATE { 617 union tagTheStructure { 618 struct tagCommon { 619 uint32_t DwordLength : BITFIELD_RANGE(0, 15); 620 uint32_t Subopcode : BITFIELD_RANGE(16, 23); 621 uint32_t MediaCommandOpcode : BITFIELD_RANGE(24, 26); 622 uint32_t Pipeline : BITFIELD_RANGE(27, 28); 623 uint32_t CommandType : BITFIELD_RANGE(29, 31); 624 uint32_t PerThreadScratchSpace : BITFIELD_RANGE(0, 3); 625 uint32_t StackSize : BITFIELD_RANGE(4, 7); 626 uint32_t Reserved_40 : BITFIELD_RANGE(8, 9); 627 uint32_t ScratchSpaceBasePointer : BITFIELD_RANGE(10, 31); 628 uint32_t ScratchSpaceBasePointerHigh : BITFIELD_RANGE(0, 15); 629 uint32_t Reserved_80 : BITFIELD_RANGE(16, 31); 630 uint32_t Reserved_96 : BITFIELD_RANGE(0, 5); 631 uint32_t BypassGatewayControl : BITFIELD_RANGE(6, 6); 632 uint32_t ResetGatewayTimer : BITFIELD_RANGE(7, 7); 633 uint32_t NumberOfUrbEntries : BITFIELD_RANGE(8, 15); 634 uint32_t MaximumNumberOfThreads : BITFIELD_RANGE(16, 31); 635 uint32_t SliceDisable : BITFIELD_RANGE(0, 1); 636 uint32_t Reserved_130 : BITFIELD_RANGE(2, 31); 637 uint32_t CurbeAllocationSize : BITFIELD_RANGE(0, 15); 638 uint32_t UrbEntryAllocationSize : BITFIELD_RANGE(16, 31); 639 uint32_t ScoreboardMask : BITFIELD_RANGE(0, 7); 640 uint32_t Reserved_200 : BITFIELD_RANGE(8, 29); 641 uint32_t ScoreboardType : BITFIELD_RANGE(30, 30); 642 uint32_t ScoreboardEnable : BITFIELD_RANGE(31, 31); 643 uint32_t Scoreboard0DeltaX : BITFIELD_RANGE(0, 3); 644 uint32_t Scoreboard0DeltaY : BITFIELD_RANGE(4, 7); 645 uint32_t Scoreboard1DeltaX : BITFIELD_RANGE(8, 11); 646 uint32_t Scoreboard1DeltaY : BITFIELD_RANGE(12, 15); 647 uint32_t Scoreboard2DeltaX : BITFIELD_RANGE(16, 19); 648 uint32_t Scoreboard2DeltaY : BITFIELD_RANGE(20, 23); 649 uint32_t Scoreboard3DeltaX : BITFIELD_RANGE(24, 27); 650 uint32_t Scoreboard3DeltaY : BITFIELD_RANGE(28, 31); 651 uint32_t Scoreboard4DeltaX : BITFIELD_RANGE(0, 3); 652 uint32_t Scoreboard4DeltaY : BITFIELD_RANGE(4, 7); 653 uint32_t Scoreboard5DeltaX : BITFIELD_RANGE(8, 11); 654 uint32_t Scoreboard5DeltaY : BITFIELD_RANGE(12, 15); 655 uint32_t Scoreboard6DeltaX : BITFIELD_RANGE(16, 19); 656 uint32_t Scoreboard6DeltaY : BITFIELD_RANGE(20, 23); 657 uint32_t Scoreboard7DeltaX : BITFIELD_RANGE(24, 27); 658 uint32_t Scoreboard7DeltaY : BITFIELD_RANGE(28, 31); 659 } Common; 660 uint32_t RawData[9]; 661 } TheStructure; 662 typedef enum tagDWORD_LENGTH { 663 DWORD_LENGTH_DWORD_COUNT_N = 0x7, 664 } DWORD_LENGTH; 665 typedef enum tagSUBOPCODE { 666 SUBOPCODE_MEDIA_VFE_STATE_SUBOP = 0x0, 667 } SUBOPCODE; 668 typedef enum tagMEDIA_COMMAND_OPCODE { 669 MEDIA_COMMAND_OPCODE_MEDIA_VFE_STATE = 0x0, 670 } MEDIA_COMMAND_OPCODE; 671 typedef enum tagPIPELINE { 672 PIPELINE_MEDIA = 0x2, 673 } PIPELINE; 674 typedef enum tagCOMMAND_TYPE { 675 COMMAND_TYPE_GFXPIPE = 0x3, 676 } COMMAND_TYPE; 677 typedef enum tagBYPASS_GATEWAY_CONTROL { 678 BYPASS_GATEWAY_CONTROL_MAINTAINING_OPENGATEWAY_FORWARDMSG_CLOSEGATEWAY_PROTOCOL_LEGACY_MODE = 0x0, 679 BYPASS_GATEWAY_CONTROL_BYPASSING_OPENGATEWAY_CLOSEGATEWAY_PROTOCOL = 0x1, 680 } BYPASS_GATEWAY_CONTROL; 681 typedef enum tagRESET_GATEWAY_TIMER { 682 RESET_GATEWAY_TIMER_MAINTAINING_THE_EXISTING_TIMESTAMP_STATE = 0x0, 683 RESET_GATEWAY_TIMER_RESETTING_RELATIVE_TIMER_AND_LATCHING_THE_GLOBAL_TIMESTAMP = 0x1, 684 } RESET_GATEWAY_TIMER; 685 typedef enum tagSLICE_DISABLE { 686 SLICE_DISABLE_ALL_SUBSLICES_ENABLED = 0x0, 687 SLICE_DISABLE_ONLY_SLICE_0_ENABLED = 0x1, 688 SLICE_DISABLE_ONLY_SLICE_0_SUBSLICE_0_ENABLED = 0x3, 689 } SLICE_DISABLE; 690 typedef enum tagSCOREBOARD_TYPE { 691 SCOREBOARD_TYPE_STALLING_SCOREBOARD = 0x0, 692 SCOREBOARD_TYPE_NON_STALLING_SCOREBOARD = 0x1, 693 } SCOREBOARD_TYPE; 694 typedef enum tagPATCH_CONSTANTS { 695 SCRATCHSPACEBASEPOINTER_BYTEOFFSET = 0x4, 696 SCRATCHSPACEBASEPOINTER_INDEX = 0x1, 697 SCRATCHSPACEBASEPOINTERHIGH_BYTEOFFSET = 0x8, 698 SCRATCHSPACEBASEPOINTERHIGH_INDEX = 0x2, 699 } PATCH_CONSTANTS; 700 inline void init() { 701 memset(&TheStructure, 0, sizeof(TheStructure)); 702 TheStructure.Common.DwordLength = DWORD_LENGTH_DWORD_COUNT_N; 703 TheStructure.Common.Subopcode = SUBOPCODE_MEDIA_VFE_STATE_SUBOP; 704 TheStructure.Common.MediaCommandOpcode = MEDIA_COMMAND_OPCODE_MEDIA_VFE_STATE; 705 TheStructure.Common.Pipeline = PIPELINE_MEDIA; 706 TheStructure.Common.CommandType = COMMAND_TYPE_GFXPIPE; 707 TheStructure.Common.BypassGatewayControl = BYPASS_GATEWAY_CONTROL_MAINTAINING_OPENGATEWAY_FORWARDMSG_CLOSEGATEWAY_PROTOCOL_LEGACY_MODE; 708 TheStructure.Common.ResetGatewayTimer = RESET_GATEWAY_TIMER_MAINTAINING_THE_EXISTING_TIMESTAMP_STATE; 709 TheStructure.Common.SliceDisable = SLICE_DISABLE_ALL_SUBSLICES_ENABLED; 710 TheStructure.Common.ScoreboardType = SCOREBOARD_TYPE_STALLING_SCOREBOARD; 711 } 712 static tagMEDIA_VFE_STATE sInit() { 713 MEDIA_VFE_STATE state; 714 state.init(); 715 return state; 716 } 717 inline uint32_t &getRawData(const uint32_t index) { 718 DEBUG_BREAK_IF(index >= 9); 719 return TheStructure.RawData[index]; 720 } 721 inline void setPerThreadScratchSpace(const uint32_t value) { 722 TheStructure.Common.PerThreadScratchSpace = value; 723 } 724 inline uint32_t getPerThreadScratchSpace() const { 725 return (TheStructure.Common.PerThreadScratchSpace); 726 } 727 inline void setStackSize(const uint32_t value) { 728 TheStructure.Common.StackSize = value; 729 } 730 inline uint32_t getStackSize() const { 731 return (TheStructure.Common.StackSize); 732 } 733 typedef enum tagSCRATCHSPACEBASEPOINTER { 734 SCRATCHSPACEBASEPOINTER_BIT_SHIFT = 0xa, 735 SCRATCHSPACEBASEPOINTER_ALIGN_SIZE = 0x400, 736 } SCRATCHSPACEBASEPOINTER; 737 inline void setScratchSpaceBasePointer(const uint32_t value) { 738 TheStructure.Common.ScratchSpaceBasePointer = value >> SCRATCHSPACEBASEPOINTER_BIT_SHIFT; 739 } 740 inline uint32_t getScratchSpaceBasePointer() const { 741 return (TheStructure.Common.ScratchSpaceBasePointer << SCRATCHSPACEBASEPOINTER_BIT_SHIFT); 742 } 743 inline void setScratchSpaceBasePointerHigh(const uint32_t value) { 744 TheStructure.Common.ScratchSpaceBasePointerHigh = value; 745 } 746 inline uint32_t getScratchSpaceBasePointerHigh() const { 747 return (TheStructure.Common.ScratchSpaceBasePointerHigh); 748 } 749 inline void setBypassGatewayControl(const BYPASS_GATEWAY_CONTROL value) { 750 TheStructure.Common.BypassGatewayControl = value; 751 } 752 inline BYPASS_GATEWAY_CONTROL getBypassGatewayControl() const { 753 return static_cast<BYPASS_GATEWAY_CONTROL>(TheStructure.Common.BypassGatewayControl); 754 } 755 inline void setResetGatewayTimer(const RESET_GATEWAY_TIMER value) { 756 TheStructure.Common.ResetGatewayTimer = value; 757 } 758 inline RESET_GATEWAY_TIMER getResetGatewayTimer() const { 759 return static_cast<RESET_GATEWAY_TIMER>(TheStructure.Common.ResetGatewayTimer); 760 } 761 inline void setNumberOfUrbEntries(const uint32_t value) { 762 TheStructure.Common.NumberOfUrbEntries = value; 763 } 764 inline uint32_t getNumberOfUrbEntries() const { 765 return (TheStructure.Common.NumberOfUrbEntries); 766 } 767 inline void setMaximumNumberOfThreads(const uint32_t value) { 768 TheStructure.Common.MaximumNumberOfThreads = value - 1; 769 } 770 inline uint32_t getMaximumNumberOfThreads() const { 771 return (TheStructure.Common.MaximumNumberOfThreads + 1); 772 } 773 inline void setSliceDisable(const SLICE_DISABLE value) { 774 TheStructure.Common.SliceDisable = value; 775 } 776 inline SLICE_DISABLE getSliceDisable() const { 777 return static_cast<SLICE_DISABLE>(TheStructure.Common.SliceDisable); 778 } 779 inline void setCurbeAllocationSize(const uint32_t value) { 780 TheStructure.Common.CurbeAllocationSize = value; 781 } 782 inline uint32_t getCurbeAllocationSize() const { 783 return (TheStructure.Common.CurbeAllocationSize); 784 } 785 inline void setUrbEntryAllocationSize(const uint32_t value) { 786 TheStructure.Common.UrbEntryAllocationSize = value; 787 } 788 inline uint32_t getUrbEntryAllocationSize() const { 789 return (TheStructure.Common.UrbEntryAllocationSize); 790 } 791 inline void setScoreboardMask(const uint32_t value) { 792 TheStructure.Common.ScoreboardMask = value; 793 } 794 inline uint32_t getScoreboardMask() const { 795 return (TheStructure.Common.ScoreboardMask); 796 } 797 inline void setScoreboardType(const SCOREBOARD_TYPE value) { 798 TheStructure.Common.ScoreboardType = value; 799 } 800 inline SCOREBOARD_TYPE getScoreboardType() const { 801 return static_cast<SCOREBOARD_TYPE>(TheStructure.Common.ScoreboardType); 802 } 803 inline void setScoreboardEnable(const bool value) { 804 TheStructure.Common.ScoreboardEnable = value; 805 } 806 inline bool getScoreboardEnable() const { 807 return (TheStructure.Common.ScoreboardEnable); 808 } 809 inline void setScoreboard0DeltaX(const uint32_t value) { 810 TheStructure.Common.Scoreboard0DeltaX = value; 811 } 812 inline uint32_t getScoreboard0DeltaX() const { 813 return (TheStructure.Common.Scoreboard0DeltaX); 814 } 815 inline void setScoreboard0DeltaY(const uint32_t value) { 816 TheStructure.Common.Scoreboard0DeltaY = value; 817 } 818 inline uint32_t getScoreboard0DeltaY() const { 819 return (TheStructure.Common.Scoreboard0DeltaY); 820 } 821 inline void setScoreboard1DeltaX(const uint32_t value) { 822 TheStructure.Common.Scoreboard1DeltaX = value; 823 } 824 inline uint32_t getScoreboard1DeltaX() const { 825 return (TheStructure.Common.Scoreboard1DeltaX); 826 } 827 inline void setScoreboard1DeltaY(const uint32_t value) { 828 TheStructure.Common.Scoreboard1DeltaY = value; 829 } 830 inline uint32_t getScoreboard1DeltaY() const { 831 return (TheStructure.Common.Scoreboard1DeltaY); 832 } 833 inline void setScoreboard2DeltaX(const uint32_t value) { 834 TheStructure.Common.Scoreboard2DeltaX = value; 835 } 836 inline uint32_t getScoreboard2DeltaX() const { 837 return (TheStructure.Common.Scoreboard2DeltaX); 838 } 839 inline void setScoreboard2DeltaY(const uint32_t value) { 840 TheStructure.Common.Scoreboard2DeltaY = value; 841 } 842 inline uint32_t getScoreboard2DeltaY() const { 843 return (TheStructure.Common.Scoreboard2DeltaY); 844 } 845 inline void setScoreboard3DeltaX(const uint32_t value) { 846 TheStructure.Common.Scoreboard3DeltaX = value; 847 } 848 inline uint32_t getScoreboard3DeltaX() const { 849 return (TheStructure.Common.Scoreboard3DeltaX); 850 } 851 inline void setScoreboard3DeltaY(const uint32_t value) { 852 TheStructure.Common.Scoreboard3DeltaY = value; 853 } 854 inline uint32_t getScoreboard3DeltaY() const { 855 return (TheStructure.Common.Scoreboard3DeltaY); 856 } 857 inline void setScoreboard4DeltaX(const uint32_t value) { 858 TheStructure.Common.Scoreboard4DeltaX = value; 859 } 860 inline uint32_t getScoreboard4DeltaX() const { 861 return (TheStructure.Common.Scoreboard4DeltaX); 862 } 863 inline void setScoreboard4DeltaY(const uint32_t value) { 864 TheStructure.Common.Scoreboard4DeltaY = value; 865 } 866 inline uint32_t getScoreboard4DeltaY() const { 867 return (TheStructure.Common.Scoreboard4DeltaY); 868 } 869 inline void setScoreboard5DeltaX(const uint32_t value) { 870 TheStructure.Common.Scoreboard5DeltaX = value; 871 } 872 inline uint32_t getScoreboard5DeltaX() const { 873 return (TheStructure.Common.Scoreboard5DeltaX); 874 } 875 inline void setScoreboard5DeltaY(const uint32_t value) { 876 TheStructure.Common.Scoreboard5DeltaY = value; 877 } 878 inline uint32_t getScoreboard5DeltaY() const { 879 return (TheStructure.Common.Scoreboard5DeltaY); 880 } 881 inline void setScoreboard6DeltaX(const uint32_t value) { 882 TheStructure.Common.Scoreboard6DeltaX = value; 883 } 884 inline uint32_t getScoreboard6DeltaX() const { 885 return (TheStructure.Common.Scoreboard6DeltaX); 886 } 887 inline void setScoreboard6DeltaY(const uint32_t value) { 888 TheStructure.Common.Scoreboard6DeltaY = value; 889 } 890 inline uint32_t getScoreboard6DeltaY() const { 891 return (TheStructure.Common.Scoreboard6DeltaY); 892 } 893 inline void setScoreboard7DeltaX(const uint32_t value) { 894 TheStructure.Common.Scoreboard7DeltaX = value; 895 } 896 inline uint32_t getScoreboard7DeltaX() const { 897 return (TheStructure.Common.Scoreboard7DeltaX); 898 } 899 inline void setScoreboard7DeltaY(const uint32_t value) { 900 TheStructure.Common.Scoreboard7DeltaY = value; 901 } 902 inline uint32_t getScoreboard7DeltaY() const { 903 return (TheStructure.Common.Scoreboard7DeltaY); 904 } 905} MEDIA_VFE_STATE; 906STATIC_ASSERT(36 == sizeof(MEDIA_VFE_STATE)); 907 908typedef struct tagMI_ARB_CHECK { 909 union tagTheStructure { 910 struct tagCommon { 911 uint32_t Reserved_0 : BITFIELD_RANGE(0, 22); 912 uint32_t MiInstructionOpcode : BITFIELD_RANGE(23, 28); 913 uint32_t MiInstructionType : BITFIELD_RANGE(29, 31); 914 } Common; 915 uint32_t RawData[1]; 916 } TheStructure; 917 typedef enum tagMI_INSTRUCTION_OPCODE { 918 MI_INSTRUCTION_OPCODE_MI_ARB_CHECK = 0x5, 919 } MI_INSTRUCTION_OPCODE; 920 typedef enum tagMI_INSTRUCTION_TYPE { 921 MI_INSTRUCTION_TYPE_MI_INSTRUCTION = 0x0, 922 } MI_INSTRUCTION_TYPE; 923 inline void init() { 924 memset(&TheStructure, 0, sizeof(TheStructure)); 925 TheStructure.Common.MiInstructionOpcode = MI_INSTRUCTION_OPCODE_MI_ARB_CHECK; 926 TheStructure.Common.MiInstructionType = MI_INSTRUCTION_TYPE_MI_INSTRUCTION; 927 } 928 static tagMI_ARB_CHECK sInit() { 929 MI_ARB_CHECK state; 930 state.init(); 931 return state; 932 } 933 inline uint32_t &getRawData(const uint32_t index) { 934 DEBUG_BREAK_IF(index >= 1); 935 return TheStructure.RawData[index]; 936 } 937 inline void setMiInstructionOpcode(const MI_INSTRUCTION_OPCODE value) { 938 TheStructure.Common.MiInstructionOpcode = value; 939 } 940 inline MI_INSTRUCTION_OPCODE getMiInstructionOpcode() const { 941 return static_cast<MI_INSTRUCTION_OPCODE>(TheStructure.Common.MiInstructionOpcode); 942 } 943 inline void setMiInstructionType(const MI_INSTRUCTION_TYPE value) { 944 TheStructure.Common.MiInstructionType = value; 945 } 946 inline MI_INSTRUCTION_TYPE getMiInstructionType() const { 947 return static_cast<MI_INSTRUCTION_TYPE>(TheStructure.Common.MiInstructionType); 948 } 949} MI_ARB_CHECK; 950STATIC_ASSERT(4 == sizeof(MI_ARB_CHECK)); 951 952typedef struct tagMI_ATOMIC { 953 union tagTheStructure { 954 struct tagCommon { 955 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 956 uint32_t AtomicOpcode : BITFIELD_RANGE(8, 15); 957 uint32_t ReturnDataControl : BITFIELD_RANGE(16, 16); 958 uint32_t CsStall : BITFIELD_RANGE(17, 17); 959 uint32_t InlineData : BITFIELD_RANGE(18, 18); 960 uint32_t DataSize : BITFIELD_RANGE(19, 20); 961 uint32_t Post_SyncOperation : BITFIELD_RANGE(21, 21); 962 uint32_t MemoryType : BITFIELD_RANGE(22, 22); 963 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 964 uint32_t CommandType : BITFIELD_RANGE(29, 31); 965 uint32_t Reserved_32 : BITFIELD_RANGE(0, 1); 966 uint32_t MemoryAddress : BITFIELD_RANGE(2, 31); 967 uint32_t MemoryAddressHigh : BITFIELD_RANGE(0, 15); 968 uint32_t Reserved_80 : BITFIELD_RANGE(16, 31); 969 uint32_t Operand1DataDword0; 970 uint32_t Operand2DataDword0; 971 uint32_t Operand1DataDword1; 972 uint32_t Operand2DataDword1; 973 uint32_t Operand1DataDword2; 974 uint32_t Operand2DataDword2; 975 uint32_t Operand1DataDword3; 976 uint32_t Operand2DataDword3; 977 } Common; 978 uint32_t RawData[11]; 979 } TheStructure; 980 typedef enum tagDWORD_LENGTH { 981 DWORD_LENGTH_INLINE_DATA_0 = 0x1, 982 DWORD_LENGTH_INLINE_DATA_1 = 0x9, 983 } DWORD_LENGTH; 984 typedef enum tagDATA_SIZE { 985 DATA_SIZE_DWORD = 0x0, 986 DATA_SIZE_QWORD = 0x1, 987 DATA_SIZE_OCTWORD = 0x2, 988 } DATA_SIZE; 989 typedef enum tagPOST_SYNC_OPERATION { 990 POST_SYNC_OPERATION_NO_POST_SYNC_OPERATION = 0x0, 991 POST_SYNC_OPERATION_POST_SYNC_OPERATION = 0x1, 992 } POST_SYNC_OPERATION; 993 typedef enum tagMEMORY_TYPE { 994 MEMORY_TYPE_PER_PROCESS_GRAPHICS_ADDRESS = 0x0, 995 MEMORY_TYPE_GLOBAL_GRAPHICS_ADDRESS = 0x1, 996 } MEMORY_TYPE; 997 typedef enum tagMI_COMMAND_OPCODE { 998 MI_COMMAND_OPCODE_MI_ATOMIC = 0x2f, 999 } MI_COMMAND_OPCODE; 1000 typedef enum tagCOMMAND_TYPE { 1001 COMMAND_TYPE_MI_COMMAND = 0x0, 1002 } COMMAND_TYPE; 1003 typedef enum tagPATCH_CONSTANTS { 1004 MEMORYADDRESS_BYTEOFFSET = 0x4, 1005 MEMORYADDRESS_INDEX = 0x1, 1006 } PATCH_CONSTANTS; 1007 typedef enum tagATOMIC_OPCODES { 1008 ATOMIC_4B_MOVE = 0x4, 1009 ATOMIC_4B_INCREMENT = 0x5, 1010 ATOMIC_4B_DECREMENT = 0x6, 1011 ATOMIC_8B_MOVE = 0x24, 1012 ATOMIC_8B_INCREMENT = 0x25, 1013 ATOMIC_8B_DECREMENT = 0x26, 1014 } ATOMIC_OPCODES; 1015 inline void init() { 1016 memset(&TheStructure, 0, sizeof(TheStructure)); 1017 TheStructure.Common.DwordLength = DWORD_LENGTH_INLINE_DATA_0; 1018 TheStructure.Common.DataSize = DATA_SIZE_DWORD; 1019 TheStructure.Common.Post_SyncOperation = POST_SYNC_OPERATION_NO_POST_SYNC_OPERATION; 1020 TheStructure.Common.MemoryType = MEMORY_TYPE_PER_PROCESS_GRAPHICS_ADDRESS; 1021 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_ATOMIC; 1022 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 1023 } 1024 static tagMI_ATOMIC sInit() { 1025 MI_ATOMIC state; 1026 state.init(); 1027 return state; 1028 } 1029 inline uint32_t &getRawData(const uint32_t index) { 1030 DEBUG_BREAK_IF(index >= 11); 1031 return TheStructure.RawData[index]; 1032 } 1033 inline void setDwordLength(const DWORD_LENGTH value) { 1034 TheStructure.Common.DwordLength = value; 1035 } 1036 inline DWORD_LENGTH getDwordLength() const { 1037 return static_cast<DWORD_LENGTH>(TheStructure.Common.DwordLength); 1038 } 1039 inline void setAtomicOpcode(const uint32_t value) { 1040 TheStructure.Common.AtomicOpcode = value; 1041 } 1042 inline uint32_t getAtomicOpcode() const { 1043 return (TheStructure.Common.AtomicOpcode); 1044 } 1045 inline void setReturnDataControl(const uint32_t value) { 1046 TheStructure.Common.ReturnDataControl = value; 1047 } 1048 inline uint32_t getReturnDataControl() const { 1049 return (TheStructure.Common.ReturnDataControl); 1050 } 1051 inline void setCsStall(const uint32_t value) { 1052 TheStructure.Common.CsStall = value; 1053 } 1054 inline uint32_t getCsStall() const { 1055 return (TheStructure.Common.CsStall); 1056 } 1057 inline void setInlineData(const uint32_t value) { 1058 TheStructure.Common.InlineData = value; 1059 } 1060 inline uint32_t getInlineData() const { 1061 return (TheStructure.Common.InlineData); 1062 } 1063 inline void setDataSize(const DATA_SIZE value) { 1064 TheStructure.Common.DataSize = value; 1065 } 1066 inline DATA_SIZE getDataSize() const { 1067 return static_cast<DATA_SIZE>(TheStructure.Common.DataSize); 1068 } 1069 inline void setPostSyncOperation(const POST_SYNC_OPERATION value) { 1070 TheStructure.Common.Post_SyncOperation = value; 1071 } 1072 inline POST_SYNC_OPERATION getPostSyncOperation() const { 1073 return static_cast<POST_SYNC_OPERATION>(TheStructure.Common.Post_SyncOperation); 1074 } 1075 inline void setMemoryType(const MEMORY_TYPE value) { 1076 TheStructure.Common.MemoryType = value; 1077 } 1078 inline MEMORY_TYPE getMemoryType() const { 1079 return static_cast<MEMORY_TYPE>(TheStructure.Common.MemoryType); 1080 } 1081 typedef enum tagMEMORYADDRESS { 1082 MEMORYADDRESS_BIT_SHIFT = 0x2, 1083 MEMORYADDRESS_ALIGN_SIZE = 0x4, 1084 } MEMORYADDRESS; 1085 inline void setMemoryAddress(const uint32_t value) { 1086 TheStructure.Common.MemoryAddress = value >> MEMORYADDRESS_BIT_SHIFT; 1087 } 1088 inline uint32_t getMemoryAddress() const { 1089 return (TheStructure.Common.MemoryAddress << MEMORYADDRESS_BIT_SHIFT); 1090 } 1091 inline void setMemoryAddressHigh(const uint32_t value) { 1092 TheStructure.Common.MemoryAddressHigh = value; 1093 } 1094 inline uint32_t getMemoryAddressHigh() const { 1095 return (TheStructure.Common.MemoryAddressHigh); 1096 } 1097 inline void setOperand1DataDword0(const uint32_t value) { 1098 TheStructure.Common.Operand1DataDword0 = value; 1099 } 1100 inline uint32_t getOperand1DataDword0() const { 1101 return (TheStructure.Common.Operand1DataDword0); 1102 } 1103 inline void setOperand2DataDword0(const uint32_t value) { 1104 TheStructure.Common.Operand2DataDword0 = value; 1105 } 1106 inline uint32_t getOperand2DataDword0() const { 1107 return (TheStructure.Common.Operand2DataDword0); 1108 } 1109 inline void setOperand1DataDword1(const uint32_t value) { 1110 TheStructure.Common.Operand1DataDword1 = value; 1111 } 1112 inline uint32_t getOperand1DataDword1() const { 1113 return (TheStructure.Common.Operand1DataDword1); 1114 } 1115 inline void setOperand2DataDword1(const uint32_t value) { 1116 TheStructure.Common.Operand2DataDword1 = value; 1117 } 1118 inline uint32_t getOperand2DataDword1() const { 1119 return (TheStructure.Common.Operand2DataDword1); 1120 } 1121 inline void setOperand1DataDword2(const uint32_t value) { 1122 TheStructure.Common.Operand1DataDword2 = value; 1123 } 1124 inline uint32_t getOperand1DataDword2() const { 1125 return (TheStructure.Common.Operand1DataDword2); 1126 } 1127 inline void setOperand2DataDword2(const uint32_t value) { 1128 TheStructure.Common.Operand2DataDword2 = value; 1129 } 1130 inline uint32_t getOperand2DataDword2() const { 1131 return (TheStructure.Common.Operand2DataDword2); 1132 } 1133 inline void setOperand1DataDword3(const uint32_t value) { 1134 TheStructure.Common.Operand1DataDword3 = value; 1135 } 1136 inline uint32_t getOperand1DataDword3() const { 1137 return (TheStructure.Common.Operand1DataDword3); 1138 } 1139 inline void setOperand2DataDword3(const uint32_t value) { 1140 TheStructure.Common.Operand2DataDword3 = value; 1141 } 1142 inline uint32_t getOperand2DataDword3() const { 1143 return (TheStructure.Common.Operand2DataDword3); 1144 } 1145} MI_ATOMIC; 1146STATIC_ASSERT(44 == sizeof(MI_ATOMIC)); 1147 1148typedef struct tagMI_BATCH_BUFFER_END { 1149 union tagTheStructure { 1150 struct tagCommon { 1151 uint32_t Reserved_0 : BITFIELD_RANGE(0, 22); 1152 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 1153 uint32_t CommandType : BITFIELD_RANGE(29, 31); 1154 } Common; 1155 uint32_t RawData[1]; 1156 } TheStructure; 1157 typedef enum tagMI_COMMAND_OPCODE { 1158 MI_COMMAND_OPCODE_MI_BATCH_BUFFER_END = 0xa, 1159 } MI_COMMAND_OPCODE; 1160 typedef enum tagCOMMAND_TYPE { 1161 COMMAND_TYPE_MI_COMMAND = 0x0, 1162 } COMMAND_TYPE; 1163 inline void init() { 1164 memset(&TheStructure, 0, sizeof(TheStructure)); 1165 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_BATCH_BUFFER_END; 1166 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 1167 } 1168 static tagMI_BATCH_BUFFER_END sInit() { 1169 MI_BATCH_BUFFER_END state; 1170 state.init(); 1171 return state; 1172 } 1173 inline uint32_t &getRawData(const uint32_t index) { 1174 DEBUG_BREAK_IF(index >= 1); 1175 return TheStructure.RawData[index]; 1176 } 1177} MI_BATCH_BUFFER_END; 1178STATIC_ASSERT(4 == sizeof(MI_BATCH_BUFFER_END)); 1179 1180typedef struct tagMI_BATCH_BUFFER_START { 1181 union tagTheStructure { 1182 struct tagCommon { 1183 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 1184 uint32_t AddressSpaceIndicator : BITFIELD_RANGE(8, 8); 1185 uint32_t Reserved_9 : BITFIELD_RANGE(9, 21); 1186 uint32_t _2NdLevelBatchBuffer : BITFIELD_RANGE(22, 22); 1187 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 1188 uint32_t CommandType : BITFIELD_RANGE(29, 31); 1189 uint64_t Reserved_32 : BITFIELD_RANGE(0, 1); 1190 uint64_t BatchBufferStartAddress_Graphicsaddress47_2 : BITFIELD_RANGE(2, 47); 1191 uint64_t BatchBufferStartAddress_Reserved : BITFIELD_RANGE(48, 63); 1192 } Common; 1193 uint32_t RawData[3]; 1194 } TheStructure; 1195 typedef enum tagDWORD_LENGTH { 1196 DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x1, 1197 } DWORD_LENGTH; 1198 typedef enum tagADDRESS_SPACE_INDICATOR { 1199 ADDRESS_SPACE_INDICATOR_GGTT = 0x0, 1200 ADDRESS_SPACE_INDICATOR_PPGTT = 0x1, 1201 } ADDRESS_SPACE_INDICATOR; 1202 typedef enum tag_2ND_LEVEL_BATCH_BUFFER { 1203 _2ND_LEVEL_BATCH_BUFFER_1ST_LEVEL_BATCH = 0x0, 1204 _2ND_LEVEL_BATCH_BUFFER_2ND_LEVEL_BATCH = 0x1, 1205 } _2ND_LEVEL_BATCH_BUFFER; 1206 typedef enum tagMI_COMMAND_OPCODE { 1207 MI_COMMAND_OPCODE_MI_BATCH_BUFFER_START = 0x31, 1208 } MI_COMMAND_OPCODE; 1209 typedef enum tagCOMMAND_TYPE { 1210 COMMAND_TYPE_MI_COMMAND = 0x0, 1211 } COMMAND_TYPE; 1212 typedef enum tagPATCH_CONSTANTS { 1213 BATCHBUFFERSTARTADDRESS_BYTEOFFSET = 0x4, 1214 BATCHBUFFERSTARTADDRESS_INDEX = 0x1, 1215 BATCHBUFFERSTARTADDRESSHIGH_BYTEOFFSET = 0x8, 1216 BATCHBUFFERSTARTADDRESSHIGH_INDEX = 0x2, 1217 } PATCH_CONSTANTS; 1218 inline void init() { 1219 memset(&TheStructure, 0, sizeof(TheStructure)); 1220 TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1; 1221 TheStructure.Common.AddressSpaceIndicator = ADDRESS_SPACE_INDICATOR_GGTT; 1222 TheStructure.Common._2NdLevelBatchBuffer = _2ND_LEVEL_BATCH_BUFFER_1ST_LEVEL_BATCH; 1223 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_BATCH_BUFFER_START; 1224 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 1225 } 1226 static tagMI_BATCH_BUFFER_START sInit() { 1227 MI_BATCH_BUFFER_START state; 1228 state.init(); 1229 return state; 1230 } 1231 inline uint32_t &getRawData(const uint32_t index) { 1232 DEBUG_BREAK_IF(index >= 3); 1233 return TheStructure.RawData[index]; 1234 } 1235 inline void setAddressSpaceIndicator(const ADDRESS_SPACE_INDICATOR value) { 1236 TheStructure.Common.AddressSpaceIndicator = value; 1237 } 1238 inline ADDRESS_SPACE_INDICATOR getAddressSpaceIndicator() const { 1239 return static_cast<ADDRESS_SPACE_INDICATOR>(TheStructure.Common.AddressSpaceIndicator); 1240 } 1241 inline void set2NdLevelBatchBuffer(const _2ND_LEVEL_BATCH_BUFFER value) { 1242 TheStructure.Common._2NdLevelBatchBuffer = value; 1243 } 1244 inline _2ND_LEVEL_BATCH_BUFFER get2NdLevelBatchBuffer() const { 1245 return static_cast<_2ND_LEVEL_BATCH_BUFFER>(TheStructure.Common._2NdLevelBatchBuffer); 1246 } 1247 typedef enum tag_SECOND_LEVEL_BATCH_BUFFER { 1248 SECOND_LEVEL_BATCH_BUFFER_FIRST_LEVEL_BATCH = 0x0, 1249 SECOND_LEVEL_BATCH_BUFFER_SECOND_LEVEL_BATCH = 0x1, 1250 } SECOND_LEVEL_BATCH_BUFFER; 1251 inline void setSecondLevelBatchBuffer(const SECOND_LEVEL_BATCH_BUFFER value) { 1252 TheStructure.Common._2NdLevelBatchBuffer = (_2ND_LEVEL_BATCH_BUFFER)value; 1253 } 1254 inline SECOND_LEVEL_BATCH_BUFFER getSecondLevelBatchBuffer() const { 1255 return static_cast<SECOND_LEVEL_BATCH_BUFFER>(TheStructure.Common._2NdLevelBatchBuffer); 1256 } 1257 typedef enum tagBATCHBUFFERSTARTADDRESS_GRAPHICSADDRESS47_2 { 1258 BATCHBUFFERSTARTADDRESS_GRAPHICSADDRESS47_2_BIT_SHIFT = 0x2, 1259 BATCHBUFFERSTARTADDRESS_GRAPHICSADDRESS47_2_ALIGN_SIZE = 0x4, 1260 } BATCHBUFFERSTARTADDRESS_GRAPHICSADDRESS47_2; 1261 inline void setBatchBufferStartAddress(const uint64_t value) { 1262 TheStructure.Common.BatchBufferStartAddress_Graphicsaddress47_2 = value >> BATCHBUFFERSTARTADDRESS_GRAPHICSADDRESS47_2_BIT_SHIFT; 1263 } 1264 inline uint64_t getBatchBufferStartAddress() const { 1265 return (TheStructure.Common.BatchBufferStartAddress_Graphicsaddress47_2 << BATCHBUFFERSTARTADDRESS_GRAPHICSADDRESS47_2_BIT_SHIFT); 1266 } 1267 typedef enum tagBATCHBUFFERSTARTADDRESS_RESERVED { 1268 BATCHBUFFERSTARTADDRESS_RESERVED_BIT_SHIFT = 0x2, 1269 BATCHBUFFERSTARTADDRESS_RESERVED_ALIGN_SIZE = 0x4, 1270 } BATCHBUFFERSTARTADDRESS_RESERVED; 1271 inline void setBatchBufferStartAddressReserved(const uint64_t value) { 1272 TheStructure.Common.BatchBufferStartAddress_Reserved = value >> BATCHBUFFERSTARTADDRESS_RESERVED_BIT_SHIFT; 1273 } 1274 inline uint64_t getBatchBufferStartAddressReserved() const { 1275 return (TheStructure.Common.BatchBufferStartAddress_Reserved << BATCHBUFFERSTARTADDRESS_RESERVED_BIT_SHIFT); 1276 } 1277} MI_BATCH_BUFFER_START; 1278STATIC_ASSERT(12 == sizeof(MI_BATCH_BUFFER_START)); 1279 1280typedef struct tagMI_LOAD_REGISTER_IMM { 1281 union tagTheStructure { 1282 struct tagCommon { 1283 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 1284 uint32_t ByteWriteDisables : BITFIELD_RANGE(8, 11); 1285 uint32_t Reserved_12 : BITFIELD_RANGE(12, 22); 1286 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 1287 uint32_t CommandType : BITFIELD_RANGE(29, 31); 1288 uint32_t Reserved_32 : BITFIELD_RANGE(0, 1); 1289 uint32_t RegisterOffset : BITFIELD_RANGE(2, 22); 1290 uint32_t Reserved_55 : BITFIELD_RANGE(23, 31); 1291 uint32_t DataDword; 1292 } Common; 1293 uint32_t RawData[3]; 1294 } TheStructure; 1295 typedef enum tagDWORD_LENGTH { 1296 DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x1, 1297 } DWORD_LENGTH; 1298 typedef enum tagMI_COMMAND_OPCODE { 1299 MI_COMMAND_OPCODE_MI_LOAD_REGISTER_IMM = 0x22, 1300 } MI_COMMAND_OPCODE; 1301 typedef enum tagCOMMAND_TYPE { 1302 COMMAND_TYPE_MI_COMMAND = 0x0, 1303 } COMMAND_TYPE; 1304 inline void init() { 1305 memset(&TheStructure, 0, sizeof(TheStructure)); 1306 TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1; 1307 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_LOAD_REGISTER_IMM; 1308 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 1309 } 1310 static tagMI_LOAD_REGISTER_IMM sInit() { 1311 MI_LOAD_REGISTER_IMM state; 1312 state.init(); 1313 return state; 1314 } 1315 inline uint32_t &getRawData(const uint32_t index) { 1316 DEBUG_BREAK_IF(index >= 3); 1317 return TheStructure.RawData[index]; 1318 } 1319 inline void setByteWriteDisables(const uint32_t value) { 1320 TheStructure.Common.ByteWriteDisables = value; 1321 } 1322 inline uint32_t getByteWriteDisables() const { 1323 return (TheStructure.Common.ByteWriteDisables); 1324 } 1325 typedef enum tagREGISTEROFFSET { 1326 REGISTEROFFSET_BIT_SHIFT = 0x2, 1327 REGISTEROFFSET_ALIGN_SIZE = 0x4, 1328 } REGISTEROFFSET; 1329 inline void setRegisterOffset(const uint32_t value) { 1330 TheStructure.Common.RegisterOffset = value >> REGISTEROFFSET_BIT_SHIFT; 1331 } 1332 inline uint32_t getRegisterOffset() const { 1333 return (TheStructure.Common.RegisterOffset << REGISTEROFFSET_BIT_SHIFT); 1334 } 1335 inline void setDataDword(const uint32_t value) { 1336 TheStructure.Common.DataDword = value; 1337 } 1338 inline uint32_t getDataDword() const { 1339 return (TheStructure.Common.DataDword); 1340 } 1341} MI_LOAD_REGISTER_IMM; 1342STATIC_ASSERT(12 == sizeof(MI_LOAD_REGISTER_IMM)); 1343 1344typedef struct tagMI_LOAD_REGISTER_MEM { 1345 union tagTheStructure { 1346 struct tagCommon { 1347 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 1348 uint32_t Reserved_8 : BITFIELD_RANGE(8, 20); 1349 uint32_t AsyncModeEnable : BITFIELD_RANGE(21, 21); 1350 uint32_t UseGlobalGtt : BITFIELD_RANGE(22, 22); 1351 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 1352 uint32_t CommandType : BITFIELD_RANGE(29, 31); 1353 uint32_t Reserved_32 : BITFIELD_RANGE(0, 1); 1354 uint32_t RegisterAddress : BITFIELD_RANGE(2, 22); 1355 uint32_t Reserved_55 : BITFIELD_RANGE(23, 31); 1356 uint64_t Reserved_64 : BITFIELD_RANGE(0, 1); 1357 uint64_t MemoryAddress : BITFIELD_RANGE(2, 63); 1358 } Common; 1359 uint32_t RawData[4]; 1360 } TheStructure; 1361 typedef enum tagDWORD_LENGTH { 1362 DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x2, 1363 } DWORD_LENGTH; 1364 typedef enum tagMI_COMMAND_OPCODE { 1365 MI_COMMAND_OPCODE_MI_LOAD_REGISTER_MEM = 0x29, 1366 } MI_COMMAND_OPCODE; 1367 typedef enum tagCOMMAND_TYPE { 1368 COMMAND_TYPE_MI_COMMAND = 0x0, 1369 } COMMAND_TYPE; 1370 typedef enum tagPATCH_CONSTANTS { 1371 MEMORYADDRESS_BYTEOFFSET = 0x8, 1372 MEMORYADDRESS_INDEX = 0x2, 1373 } PATCH_CONSTANTS; 1374 inline void init() { 1375 memset(&TheStructure, 0, sizeof(TheStructure)); 1376 TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1; 1377 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_LOAD_REGISTER_MEM; 1378 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 1379 } 1380 static tagMI_LOAD_REGISTER_MEM sInit() { 1381 MI_LOAD_REGISTER_MEM state; 1382 state.init(); 1383 return state; 1384 } 1385 inline uint32_t &getRawData(const uint32_t index) { 1386 DEBUG_BREAK_IF(index >= 4); 1387 return TheStructure.RawData[index]; 1388 } 1389 inline void setAsyncModeEnable(const bool value) { 1390 TheStructure.Common.AsyncModeEnable = value; 1391 } 1392 inline bool getAsyncModeEnable() const { 1393 return (TheStructure.Common.AsyncModeEnable); 1394 } 1395 inline void setUseGlobalGtt(const bool value) { 1396 TheStructure.Common.UseGlobalGtt = value; 1397 } 1398 inline bool getUseGlobalGtt() const { 1399 return (TheStructure.Common.UseGlobalGtt); 1400 } 1401 typedef enum tagREGISTERADDRESS { 1402 REGISTERADDRESS_BIT_SHIFT = 0x2, 1403 REGISTERADDRESS_ALIGN_SIZE = 0x4, 1404 } REGISTERADDRESS; 1405 inline void setRegisterAddress(const uint32_t value) { 1406 TheStructure.Common.RegisterAddress = value >> REGISTERADDRESS_BIT_SHIFT; 1407 } 1408 inline uint32_t getRegisterAddress() const { 1409 return (TheStructure.Common.RegisterAddress << REGISTERADDRESS_BIT_SHIFT); 1410 } 1411 typedef enum tagMEMORYADDRESS { 1412 MEMORYADDRESS_BIT_SHIFT = 0x2, 1413 MEMORYADDRESS_ALIGN_SIZE = 0x4, 1414 } MEMORYADDRESS; 1415 inline void setMemoryAddress(const uint64_t value) { 1416 TheStructure.Common.MemoryAddress = value >> MEMORYADDRESS_BIT_SHIFT; 1417 } 1418 inline uint64_t getMemoryAddress() const { 1419 return (TheStructure.Common.MemoryAddress << MEMORYADDRESS_BIT_SHIFT); 1420 } 1421} MI_LOAD_REGISTER_MEM; 1422STATIC_ASSERT(16 == sizeof(MI_LOAD_REGISTER_MEM)); 1423 1424typedef struct tagMI_LOAD_REGISTER_REG { 1425 union tagTheStructure { 1426 struct tagCommon { 1427 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 1428 uint32_t Reserved_8 : BITFIELD_RANGE(8, 22); 1429 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 1430 uint32_t CommandType : BITFIELD_RANGE(29, 31); 1431 uint32_t Reserved_32 : BITFIELD_RANGE(0, 1); 1432 uint32_t SourceRegisterAddress : BITFIELD_RANGE(2, 22); 1433 uint32_t Reserved_55 : BITFIELD_RANGE(23, 31); 1434 uint32_t Reserved_64 : BITFIELD_RANGE(0, 1); 1435 uint32_t DestinationRegisterAddress : BITFIELD_RANGE(2, 22); 1436 uint32_t Reserved_87 : BITFIELD_RANGE(23, 31); 1437 } Common; 1438 uint32_t RawData[3]; 1439 } TheStructure; 1440 typedef enum tagDWORD_LENGTH { 1441 DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x1, 1442 } DWORD_LENGTH; 1443 typedef enum tagMI_COMMAND_OPCODE { 1444 MI_COMMAND_OPCODE_MI_LOAD_REGISTER_REG = 0x2a, 1445 } MI_COMMAND_OPCODE; 1446 typedef enum tagCOMMAND_TYPE { 1447 COMMAND_TYPE_MI_COMMAND = 0x0, 1448 } COMMAND_TYPE; 1449 inline void init() { 1450 memset(&TheStructure, 0, sizeof(TheStructure)); 1451 TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1; 1452 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_LOAD_REGISTER_REG; 1453 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 1454 } 1455 static tagMI_LOAD_REGISTER_REG sInit() { 1456 MI_LOAD_REGISTER_REG state; 1457 state.init(); 1458 return state; 1459 } 1460 inline uint32_t &getRawData(const uint32_t index) { 1461 DEBUG_BREAK_IF(index >= 3); 1462 return TheStructure.RawData[index]; 1463 } 1464 typedef enum tagSOURCEREGISTERADDRESS { 1465 SOURCEREGISTERADDRESS_BIT_SHIFT = 0x2, 1466 SOURCEREGISTERADDRESS_ALIGN_SIZE = 0x4, 1467 } SOURCEREGISTERADDRESS; 1468 inline void setSourceRegisterAddress(const uint32_t value) { 1469 TheStructure.Common.SourceRegisterAddress = value >> SOURCEREGISTERADDRESS_BIT_SHIFT; 1470 } 1471 inline uint32_t getSourceRegisterAddress() const { 1472 return (TheStructure.Common.SourceRegisterAddress << SOURCEREGISTERADDRESS_BIT_SHIFT); 1473 } 1474 typedef enum tagDESTINATIONREGISTERADDRESS { 1475 DESTINATIONREGISTERADDRESS_BIT_SHIFT = 0x2, 1476 DESTINATIONREGISTERADDRESS_ALIGN_SIZE = 0x4, 1477 } DESTINATIONREGISTERADDRESS; 1478 inline void setDestinationRegisterAddress(const uint32_t value) { 1479 TheStructure.Common.DestinationRegisterAddress = value >> DESTINATIONREGISTERADDRESS_BIT_SHIFT; 1480 } 1481 inline uint32_t getDestinationRegisterAddress() const { 1482 return (TheStructure.Common.DestinationRegisterAddress << DESTINATIONREGISTERADDRESS_BIT_SHIFT); 1483 } 1484} MI_LOAD_REGISTER_REG; 1485STATIC_ASSERT(12 == sizeof(MI_LOAD_REGISTER_REG)); 1486 1487typedef struct tagMI_NOOP { 1488 union tagTheStructure { 1489 struct tagCommon { 1490 uint32_t IdentificationNumber : BITFIELD_RANGE(0, 21); 1491 uint32_t IdentificationNumberRegisterWriteEnable : BITFIELD_RANGE(22, 22); 1492 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 1493 uint32_t CommandType : BITFIELD_RANGE(29, 31); 1494 } Common; 1495 uint32_t RawData[1]; 1496 } TheStructure; 1497 typedef enum tagMI_COMMAND_OPCODE { 1498 MI_COMMAND_OPCODE_MI_NOOP = 0x0, 1499 } MI_COMMAND_OPCODE; 1500 typedef enum tagCOMMAND_TYPE { 1501 COMMAND_TYPE_MI_COMMAND = 0x0, 1502 } COMMAND_TYPE; 1503 inline void init() { 1504 memset(&TheStructure, 0, sizeof(TheStructure)); 1505 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_NOOP; 1506 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 1507 } 1508 static tagMI_NOOP sInit() { 1509 MI_NOOP state; 1510 state.init(); 1511 return state; 1512 } 1513 inline uint32_t &getRawData(const uint32_t index) { 1514 DEBUG_BREAK_IF(index >= 1); 1515 return TheStructure.RawData[index]; 1516 } 1517 inline void setIdentificationNumber(const uint32_t value) { 1518 TheStructure.Common.IdentificationNumber = value; 1519 } 1520 inline uint32_t getIdentificationNumber() const { 1521 return (TheStructure.Common.IdentificationNumber); 1522 } 1523 inline void setIdentificationNumberRegisterWriteEnable(const bool value) { 1524 TheStructure.Common.IdentificationNumberRegisterWriteEnable = value; 1525 } 1526 inline bool getIdentificationNumberRegisterWriteEnable() const { 1527 return (TheStructure.Common.IdentificationNumberRegisterWriteEnable); 1528 } 1529} MI_NOOP; 1530STATIC_ASSERT(4 == sizeof(MI_NOOP)); 1531 1532typedef struct tagMI_STORE_REGISTER_MEM { 1533 union tagTheStructure { 1534 struct tagCommon { 1535 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 1536 uint32_t Reserved_8 : BITFIELD_RANGE(8, 20); 1537 uint32_t PredicateEnable : BITFIELD_RANGE(21, 21); 1538 uint32_t UseGlobalGtt : BITFIELD_RANGE(22, 22); 1539 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 1540 uint32_t CommandType : BITFIELD_RANGE(29, 31); 1541 uint32_t Reserved_32 : BITFIELD_RANGE(0, 1); 1542 uint32_t RegisterAddress : BITFIELD_RANGE(2, 22); 1543 uint32_t Reserved_55 : BITFIELD_RANGE(23, 31); 1544 uint64_t Reserved_64 : BITFIELD_RANGE(0, 1); 1545 uint64_t MemoryAddress : BITFIELD_RANGE(2, 63); 1546 } Common; 1547 uint32_t RawData[4]; 1548 } TheStructure; 1549 typedef enum tagDWORD_LENGTH { 1550 DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x2, 1551 } DWORD_LENGTH; 1552 typedef enum tagMI_COMMAND_OPCODE { 1553 MI_COMMAND_OPCODE_MI_STORE_REGISTER_MEM = 0x24, 1554 } MI_COMMAND_OPCODE; 1555 typedef enum tagCOMMAND_TYPE { 1556 COMMAND_TYPE_MI_COMMAND = 0x0, 1557 } COMMAND_TYPE; 1558 typedef enum tagPATCH_CONSTANTS { 1559 MEMORYADDRESS_BYTEOFFSET = 0x8, 1560 MEMORYADDRESS_INDEX = 0x2, 1561 } PATCH_CONSTANTS; 1562 inline void init() { 1563 memset(&TheStructure, 0, sizeof(TheStructure)); 1564 TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1; 1565 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_STORE_REGISTER_MEM; 1566 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 1567 } 1568 static tagMI_STORE_REGISTER_MEM sInit() { 1569 MI_STORE_REGISTER_MEM state; 1570 state.init(); 1571 return state; 1572 } 1573 inline uint32_t &getRawData(const uint32_t index) { 1574 DEBUG_BREAK_IF(index >= 4); 1575 return TheStructure.RawData[index]; 1576 } 1577 inline void setPredicateEnable(const uint32_t value) { 1578 TheStructure.Common.PredicateEnable = value; 1579 } 1580 inline uint32_t getPredicateEnable() const { 1581 return (TheStructure.Common.PredicateEnable); 1582 } 1583 inline void setUseGlobalGtt(const bool value) { 1584 TheStructure.Common.UseGlobalGtt = value; 1585 } 1586 inline bool getUseGlobalGtt() const { 1587 return (TheStructure.Common.UseGlobalGtt); 1588 } 1589 typedef enum tagREGISTERADDRESS { 1590 REGISTERADDRESS_BIT_SHIFT = 0x2, 1591 REGISTERADDRESS_ALIGN_SIZE = 0x4, 1592 } REGISTERADDRESS; 1593 inline void setRegisterAddress(const uint32_t value) { 1594 TheStructure.Common.RegisterAddress = value >> REGISTERADDRESS_BIT_SHIFT; 1595 } 1596 inline uint32_t getRegisterAddress() const { 1597 return (TheStructure.Common.RegisterAddress << REGISTERADDRESS_BIT_SHIFT); 1598 } 1599 typedef enum tagMEMORYADDRESS { 1600 MEMORYADDRESS_BIT_SHIFT = 0x2, 1601 MEMORYADDRESS_ALIGN_SIZE = 0x4, 1602 } MEMORYADDRESS; 1603 inline void setMemoryAddress(const uint64_t value) { 1604 TheStructure.Common.MemoryAddress = value >> MEMORYADDRESS_BIT_SHIFT; 1605 } 1606 inline uint64_t getMemoryAddress() const { 1607 return (TheStructure.Common.MemoryAddress << MEMORYADDRESS_BIT_SHIFT); 1608 } 1609} MI_STORE_REGISTER_MEM; 1610STATIC_ASSERT(16 == sizeof(MI_STORE_REGISTER_MEM)); 1611 1612typedef struct tagPIPELINE_SELECT { 1613 union tagTheStructure { 1614 struct tagCommon { 1615 uint32_t PipelineSelection : BITFIELD_RANGE(0, 1); 1616 uint32_t Reserved_2 : BITFIELD_RANGE(2, 15); 1617 uint32_t _3DCommandSubOpcode : BITFIELD_RANGE(16, 23); 1618 uint32_t _3DCommandOpcode : BITFIELD_RANGE(24, 26); 1619 uint32_t CommandSubtype : BITFIELD_RANGE(27, 28); 1620 uint32_t CommandType : BITFIELD_RANGE(29, 31); 1621 } Common; 1622 uint32_t RawData[1]; 1623 } TheStructure; 1624 typedef enum tagPIPELINE_SELECTION { 1625 PIPELINE_SELECTION_3D = 0x0, 1626 PIPELINE_SELECTION_MEDIA = 0x1, 1627 PIPELINE_SELECTION_GPGPU = 0x2, 1628 } PIPELINE_SELECTION; 1629 typedef enum tag_3D_COMMAND_SUB_OPCODE { 1630 _3D_COMMAND_SUB_OPCODE_PIPELINE_SELECT = 0x4, 1631 } _3D_COMMAND_SUB_OPCODE; 1632 typedef enum tag_3D_COMMAND_OPCODE { 1633 _3D_COMMAND_OPCODE_GFXPIPE_NONPIPELINED = 0x1, 1634 } _3D_COMMAND_OPCODE; 1635 typedef enum tagCOMMAND_SUBTYPE { 1636 COMMAND_SUBTYPE_GFXPIPE_SINGLE_DW = 0x1, 1637 } COMMAND_SUBTYPE; 1638 typedef enum tagCOMMAND_TYPE { 1639 COMMAND_TYPE_GFXPIPE = 0x3, 1640 } COMMAND_TYPE; 1641 inline void init() { 1642 memset(&TheStructure, 0, sizeof(TheStructure)); 1643 TheStructure.Common.PipelineSelection = PIPELINE_SELECTION_3D; 1644 TheStructure.Common._3DCommandSubOpcode = _3D_COMMAND_SUB_OPCODE_PIPELINE_SELECT; 1645 TheStructure.Common._3DCommandOpcode = _3D_COMMAND_OPCODE_GFXPIPE_NONPIPELINED; 1646 TheStructure.Common.CommandSubtype = COMMAND_SUBTYPE_GFXPIPE_SINGLE_DW; 1647 TheStructure.Common.CommandType = COMMAND_TYPE_GFXPIPE; 1648 } 1649 static tagPIPELINE_SELECT sInit() { 1650 PIPELINE_SELECT state; 1651 state.init(); 1652 return state; 1653 } 1654 inline uint32_t &getRawData(const uint32_t index) { 1655 DEBUG_BREAK_IF(index >= 1); 1656 return TheStructure.RawData[index]; 1657 } 1658 inline void setMaskBits(const uint32_t value) { 1659 } 1660 inline uint32_t getMaskBits() const { 1661 return 0x3; 1662 } 1663 inline void setPipelineSelection(const PIPELINE_SELECTION value) { 1664 TheStructure.Common.PipelineSelection = value; 1665 } 1666 inline PIPELINE_SELECTION getPipelineSelection() const { 1667 return static_cast<PIPELINE_SELECTION>(TheStructure.Common.PipelineSelection); 1668 } 1669} PIPELINE_SELECT; 1670STATIC_ASSERT(4 == sizeof(PIPELINE_SELECT)); 1671 1672typedef struct tagPIPE_CONTROL { 1673 union tagTheStructure { 1674 struct tagCommon { 1675 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 1676 uint32_t Reserved_8 : BITFIELD_RANGE(8, 15); 1677 uint32_t _3DCommandSubOpcode : BITFIELD_RANGE(16, 23); 1678 uint32_t _3DCommandOpcode : BITFIELD_RANGE(24, 26); 1679 uint32_t CommandSubtype : BITFIELD_RANGE(27, 28); 1680 uint32_t CommandType : BITFIELD_RANGE(29, 31); 1681 uint32_t DepthCacheFlushEnable : BITFIELD_RANGE(0, 0); 1682 uint32_t StallAtPixelScoreboard : BITFIELD_RANGE(1, 1); 1683 uint32_t StateCacheInvalidationEnable : BITFIELD_RANGE(2, 2); 1684 uint32_t ConstantCacheInvalidationEnable : BITFIELD_RANGE(3, 3); 1685 uint32_t VfCacheInvalidationEnable : BITFIELD_RANGE(4, 4); 1686 uint32_t DcFlushEnable : BITFIELD_RANGE(5, 5); 1687 uint32_t ProtectedMemoryApplicationId : BITFIELD_RANGE(6, 6); 1688 uint32_t PipeControlFlushEnable : BITFIELD_RANGE(7, 7); 1689 uint32_t NotifyEnable : BITFIELD_RANGE(8, 8); 1690 uint32_t IndirectStatePointersDisable : BITFIELD_RANGE(9, 9); 1691 uint32_t TextureCacheInvalidationEnable : BITFIELD_RANGE(10, 10); 1692 uint32_t InstructionCacheInvalidateEnable : BITFIELD_RANGE(11, 11); 1693 uint32_t RenderTargetCacheFlushEnable : BITFIELD_RANGE(12, 12); 1694 uint32_t DepthStallEnable : BITFIELD_RANGE(13, 13); 1695 uint32_t PostSyncOperation : BITFIELD_RANGE(14, 15); 1696 uint32_t GenericMediaStateClear : BITFIELD_RANGE(16, 16); 1697 uint32_t Reserved_49 : BITFIELD_RANGE(17, 17); 1698 uint32_t TlbInvalidate : BITFIELD_RANGE(18, 18); 1699 uint32_t GlobalSnapshotCountReset : BITFIELD_RANGE(19, 19); 1700 uint32_t CommandStreamerStallEnable : BITFIELD_RANGE(20, 20); 1701 uint32_t StoreDataIndex : BITFIELD_RANGE(21, 21); 1702 uint32_t Reserved_54 : BITFIELD_RANGE(22, 22); 1703 uint32_t LriPostSyncOperation : BITFIELD_RANGE(23, 23); 1704 uint32_t DestinationAddressType : BITFIELD_RANGE(24, 24); 1705 uint32_t Reserved_57 : BITFIELD_RANGE(25, 26); 1706 uint32_t ProtectedMemoryDisable : BITFIELD_RANGE(27, 27); 1707 uint32_t Reserved_60 : BITFIELD_RANGE(28, 31); 1708 uint32_t Reserved_64 : BITFIELD_RANGE(0, 1); 1709 uint32_t Address : BITFIELD_RANGE(2, 31); 1710 uint32_t AddressHigh; 1711 uint64_t ImmediateData; 1712 } Common; 1713 uint32_t RawData[6]; 1714 } TheStructure; 1715 typedef enum tagDWORD_LENGTH { 1716 DWORD_LENGTH_DWORD_COUNT_N = 0x4, 1717 } DWORD_LENGTH; 1718 typedef enum tag_3D_COMMAND_SUB_OPCODE { 1719 _3D_COMMAND_SUB_OPCODE_PIPE_CONTROL = 0x0, 1720 } _3D_COMMAND_SUB_OPCODE; 1721 typedef enum tag_3D_COMMAND_OPCODE { 1722 _3D_COMMAND_OPCODE_PIPE_CONTROL = 0x2, 1723 } _3D_COMMAND_OPCODE; 1724 typedef enum tagCOMMAND_SUBTYPE { 1725 COMMAND_SUBTYPE_GFXPIPE_3D = 0x3, 1726 } COMMAND_SUBTYPE; 1727 typedef enum tagCOMMAND_TYPE { 1728 COMMAND_TYPE_GFXPIPE = 0x3, 1729 } COMMAND_TYPE; 1730 typedef enum tagPOST_SYNC_OPERATION { 1731 POST_SYNC_OPERATION_NO_WRITE = 0x0, 1732 POST_SYNC_OPERATION_WRITE_IMMEDIATE_DATA = 0x1, 1733 POST_SYNC_OPERATION_WRITE_PS_DEPTH_COUNT = 0x2, 1734 POST_SYNC_OPERATION_WRITE_TIMESTAMP = 0x3, 1735 } POST_SYNC_OPERATION; 1736 typedef enum tagGLOBAL_SNAPSHOT_COUNT_RESET { 1737 GLOBAL_SNAPSHOT_COUNT_RESET_DON_T_RESET = 0x0, 1738 GLOBAL_SNAPSHOT_COUNT_RESET_RESET = 0x1, 1739 } GLOBAL_SNAPSHOT_COUNT_RESET; 1740 typedef enum tagLRI_POST_SYNC_OPERATION { 1741 LRI_POST_SYNC_OPERATION_NO_LRI_OPERATION = 0x0, 1742 LRI_POST_SYNC_OPERATION_MMIO_WRITE_IMMEDIATE_DATA = 0x1, 1743 } LRI_POST_SYNC_OPERATION; 1744 typedef enum tagDESTINATION_ADDRESS_TYPE { 1745 DESTINATION_ADDRESS_TYPE_PPGTT = 0x0, 1746 DESTINATION_ADDRESS_TYPE_GGTT = 0x1, 1747 } DESTINATION_ADDRESS_TYPE; 1748 typedef enum tagPATCH_CONSTANTS { 1749 ADDRESS_BYTEOFFSET = 0x8, 1750 ADDRESS_INDEX = 0x2, 1751 ADDRESSHIGH_BYTEOFFSET = 0xc, 1752 ADDRESSHIGH_INDEX = 0x3, 1753 } PATCH_CONSTANTS; 1754 inline void init() { 1755 memset(&TheStructure, 0, sizeof(TheStructure)); 1756 TheStructure.Common.DwordLength = DWORD_LENGTH_DWORD_COUNT_N; 1757 TheStructure.Common._3DCommandSubOpcode = _3D_COMMAND_SUB_OPCODE_PIPE_CONTROL; 1758 TheStructure.Common._3DCommandOpcode = _3D_COMMAND_OPCODE_PIPE_CONTROL; 1759 TheStructure.Common.CommandSubtype = COMMAND_SUBTYPE_GFXPIPE_3D; 1760 TheStructure.Common.CommandType = COMMAND_TYPE_GFXPIPE; 1761 TheStructure.Common.PostSyncOperation = POST_SYNC_OPERATION_NO_WRITE; 1762 TheStructure.Common.GlobalSnapshotCountReset = GLOBAL_SNAPSHOT_COUNT_RESET_DON_T_RESET; 1763 TheStructure.Common.LriPostSyncOperation = LRI_POST_SYNC_OPERATION_NO_LRI_OPERATION; 1764 TheStructure.Common.DestinationAddressType = DESTINATION_ADDRESS_TYPE_PPGTT; 1765 } 1766 static tagPIPE_CONTROL sInit() { 1767 PIPE_CONTROL state; 1768 state.init(); 1769 return state; 1770 } 1771 inline uint32_t &getRawData(const uint32_t index) { 1772 DEBUG_BREAK_IF(index >= 6); 1773 return TheStructure.RawData[index]; 1774 } 1775 inline void setDepthCacheFlushEnable(const bool value) { 1776 TheStructure.Common.DepthCacheFlushEnable = value; 1777 } 1778 inline bool getDepthCacheFlushEnable() const { 1779 return (TheStructure.Common.DepthCacheFlushEnable); 1780 } 1781 inline void setStallAtPixelScoreboard(const bool value) { 1782 TheStructure.Common.StallAtPixelScoreboard = value; 1783 } 1784 inline bool getStallAtPixelScoreboard() const { 1785 return (TheStructure.Common.StallAtPixelScoreboard); 1786 } 1787 inline void setStateCacheInvalidationEnable(const bool value) { 1788 TheStructure.Common.StateCacheInvalidationEnable = value; 1789 } 1790 inline bool getStateCacheInvalidationEnable() const { 1791 return (TheStructure.Common.StateCacheInvalidationEnable); 1792 } 1793 inline void setConstantCacheInvalidationEnable(const bool value) { 1794 TheStructure.Common.ConstantCacheInvalidationEnable = value; 1795 } 1796 inline bool getConstantCacheInvalidationEnable() const { 1797 return (TheStructure.Common.ConstantCacheInvalidationEnable); 1798 } 1799 inline void setVfCacheInvalidationEnable(const bool value) { 1800 TheStructure.Common.VfCacheInvalidationEnable = value; 1801 } 1802 inline bool getVfCacheInvalidationEnable() const { 1803 return (TheStructure.Common.VfCacheInvalidationEnable); 1804 } 1805 inline void setDcFlushEnable(const bool value) { 1806 TheStructure.Common.DcFlushEnable = value; 1807 } 1808 inline bool getDcFlushEnable() const { 1809 return (TheStructure.Common.DcFlushEnable); 1810 } 1811 inline void setProtectedMemoryApplicationId(const uint32_t value) { 1812 TheStructure.Common.ProtectedMemoryApplicationId = value; 1813 } 1814 inline uint32_t getProtectedMemoryApplicationId() const { 1815 return (TheStructure.Common.ProtectedMemoryApplicationId); 1816 } 1817 inline void setPipeControlFlushEnable(const bool value) { 1818 TheStructure.Common.PipeControlFlushEnable = value; 1819 } 1820 inline bool getPipeControlFlushEnable() const { 1821 return (TheStructure.Common.PipeControlFlushEnable); 1822 } 1823 inline void setNotifyEnable(const bool value) { 1824 TheStructure.Common.NotifyEnable = value; 1825 } 1826 inline bool getNotifyEnable() const { 1827 return (TheStructure.Common.NotifyEnable); 1828 } 1829 inline void setIndirectStatePointersDisable(const bool value) { 1830 TheStructure.Common.IndirectStatePointersDisable = value; 1831 } 1832 inline bool getIndirectStatePointersDisable() const { 1833 return (TheStructure.Common.IndirectStatePointersDisable); 1834 } 1835 inline void setTextureCacheInvalidationEnable(const bool value) { 1836 TheStructure.Common.TextureCacheInvalidationEnable = value; 1837 } 1838 inline bool getTextureCacheInvalidationEnable() const { 1839 return (TheStructure.Common.TextureCacheInvalidationEnable); 1840 } 1841 inline void setInstructionCacheInvalidateEnable(const bool value) { 1842 TheStructure.Common.InstructionCacheInvalidateEnable = value; 1843 } 1844 inline bool getInstructionCacheInvalidateEnable() const { 1845 return (TheStructure.Common.InstructionCacheInvalidateEnable); 1846 } 1847 inline void setRenderTargetCacheFlushEnable(const bool value) { 1848 TheStructure.Common.RenderTargetCacheFlushEnable = value; 1849 } 1850 inline bool getRenderTargetCacheFlushEnable() const { 1851 return (TheStructure.Common.RenderTargetCacheFlushEnable); 1852 } 1853 inline void setDepthStallEnable(const bool value) { 1854 TheStructure.Common.DepthStallEnable = value; 1855 } 1856 inline bool getDepthStallEnable() const { 1857 return (TheStructure.Common.DepthStallEnable); 1858 } 1859 inline void setPostSyncOperation(const POST_SYNC_OPERATION value) { 1860 TheStructure.Common.PostSyncOperation = value; 1861 } 1862 inline POST_SYNC_OPERATION getPostSyncOperation() const { 1863 return static_cast<POST_SYNC_OPERATION>(TheStructure.Common.PostSyncOperation); 1864 } 1865 inline void setGenericMediaStateClear(const bool value) { 1866 TheStructure.Common.GenericMediaStateClear = value; 1867 } 1868 inline bool getGenericMediaStateClear() const { 1869 return (TheStructure.Common.GenericMediaStateClear); 1870 } 1871 inline void setTlbInvalidate(const uint32_t value) { 1872 TheStructure.Common.TlbInvalidate = value; 1873 } 1874 inline uint32_t getTlbInvalidate() const { 1875 return (TheStructure.Common.TlbInvalidate); 1876 } 1877 inline void setGlobalSnapshotCountReset(const GLOBAL_SNAPSHOT_COUNT_RESET value) { 1878 TheStructure.Common.GlobalSnapshotCountReset = value; 1879 } 1880 inline GLOBAL_SNAPSHOT_COUNT_RESET getGlobalSnapshotCountReset() const { 1881 return static_cast<GLOBAL_SNAPSHOT_COUNT_RESET>(TheStructure.Common.GlobalSnapshotCountReset); 1882 } 1883 inline void setCommandStreamerStallEnable(const uint32_t value) { 1884 TheStructure.Common.CommandStreamerStallEnable = value; 1885 } 1886 inline uint32_t getCommandStreamerStallEnable() const { 1887 return (TheStructure.Common.CommandStreamerStallEnable); 1888 } 1889 inline void setStoreDataIndex(const uint32_t value) { 1890 TheStructure.Common.StoreDataIndex = value; 1891 } 1892 inline uint32_t getStoreDataIndex() const { 1893 return (TheStructure.Common.StoreDataIndex); 1894 } 1895 inline void setLriPostSyncOperation(const LRI_POST_SYNC_OPERATION value) { 1896 TheStructure.Common.LriPostSyncOperation = value; 1897 } 1898 inline LRI_POST_SYNC_OPERATION getLriPostSyncOperation() const { 1899 return static_cast<LRI_POST_SYNC_OPERATION>(TheStructure.Common.LriPostSyncOperation); 1900 } 1901 inline void setDestinationAddressType(const DESTINATION_ADDRESS_TYPE value) { 1902 TheStructure.Common.DestinationAddressType = value; 1903 } 1904 inline DESTINATION_ADDRESS_TYPE getDestinationAddressType() const { 1905 return static_cast<DESTINATION_ADDRESS_TYPE>(TheStructure.Common.DestinationAddressType); 1906 } 1907 inline void setProtectedMemoryDisable(const uint32_t value) { 1908 TheStructure.Common.ProtectedMemoryDisable = value; 1909 } 1910 inline uint32_t getProtectedMemoryDisable() const { 1911 return (TheStructure.Common.ProtectedMemoryDisable); 1912 } 1913 typedef enum tagADDRESS { 1914 ADDRESS_BIT_SHIFT = 0x2, 1915 ADDRESS_ALIGN_SIZE = 0x4, 1916 } ADDRESS; 1917 inline void setAddress(const uint32_t value) { 1918 TheStructure.Common.Address = value >> ADDRESS_BIT_SHIFT; 1919 } 1920 inline uint32_t getAddress() const { 1921 return (TheStructure.Common.Address << ADDRESS_BIT_SHIFT); 1922 } 1923 inline void setAddressHigh(const uint32_t value) { 1924 TheStructure.Common.AddressHigh = value; 1925 } 1926 inline uint32_t getAddressHigh() const { 1927 return (TheStructure.Common.AddressHigh); 1928 } 1929 inline void setImmediateData(const uint64_t value) { 1930 TheStructure.Common.ImmediateData = value; 1931 } 1932 inline uint64_t getImmediateData() const { 1933 return (TheStructure.Common.ImmediateData); 1934 } 1935} PIPE_CONTROL; 1936STATIC_ASSERT(24 == sizeof(PIPE_CONTROL)); 1937 1938typedef struct tagRENDER_SURFACE_STATE { 1939 union tagTheStructure { 1940 struct tagCommon { 1941 uint32_t Reserved_0 : BITFIELD_RANGE(0, 5); 1942 uint32_t MediaBoundaryPixelMode : BITFIELD_RANGE(6, 7); 1943 uint32_t RenderCacheReadWriteMode : BITFIELD_RANGE(8, 8); 1944 uint32_t SamplerL2OutOfOrderModeDisable : BITFIELD_RANGE(9, 9); 1945 uint32_t VerticalLineStrideOffset : BITFIELD_RANGE(10, 10); 1946 uint32_t VerticalLineStride : BITFIELD_RANGE(11, 11); 1947 uint32_t TileMode : BITFIELD_RANGE(12, 13); 1948 uint32_t SurfaceHorizontalAlignment : BITFIELD_RANGE(14, 15); 1949 uint32_t SurfaceVerticalAlignment : BITFIELD_RANGE(16, 17); 1950 uint32_t SurfaceFormat : BITFIELD_RANGE(18, 26); 1951 uint32_t Reserved_27 : BITFIELD_RANGE(27, 27); 1952 uint32_t SurfaceArray : BITFIELD_RANGE(28, 28); 1953 uint32_t SurfaceType : BITFIELD_RANGE(29, 31); 1954 uint32_t SurfaceQpitch : BITFIELD_RANGE(0, 14); 1955 uint32_t Reserved_47 : BITFIELD_RANGE(15, 18); 1956 uint32_t BaseMipLevel : BITFIELD_RANGE(19, 23); 1957 uint32_t MemoryObjectControlState_AgeForQuadlru : BITFIELD_RANGE(24, 25); 1958 uint32_t MemoryObjectControlState_Reserved : BITFIELD_RANGE(26, 26); 1959 uint32_t MemoryObjectControlState_TargetCache : BITFIELD_RANGE(27, 28); 1960 uint32_t MemoryObjectControlState_MemoryTypeLlcEllcCacheabilityControl : BITFIELD_RANGE(29, 30); 1961 uint32_t Reserved_63 : BITFIELD_RANGE(31, 31); 1962 uint32_t Width : BITFIELD_RANGE(0, 13); 1963 uint32_t Reserved_78 : BITFIELD_RANGE(14, 15); 1964 uint32_t Height : BITFIELD_RANGE(16, 29); 1965 uint32_t Reserved_94 : BITFIELD_RANGE(30, 31); 1966 uint32_t SurfacePitch : BITFIELD_RANGE(0, 17); 1967 uint32_t Reserved_114 : BITFIELD_RANGE(18, 20); 1968 uint32_t Depth : BITFIELD_RANGE(21, 31); 1969 uint32_t Reserved_128; 1970 uint32_t MipCountLod : BITFIELD_RANGE(0, 3); 1971 uint32_t SurfaceMinLod : BITFIELD_RANGE(4, 7); 1972 uint32_t Reserved_168 : BITFIELD_RANGE(8, 13); 1973 uint32_t CoherencyType : BITFIELD_RANGE(14, 14); 1974 uint32_t Reserved_175 : BITFIELD_RANGE(15, 19); 1975 uint32_t EwaDisableForCube : BITFIELD_RANGE(20, 20); 1976 uint32_t YOffset : BITFIELD_RANGE(21, 23); 1977 uint32_t Reserved_184 : BITFIELD_RANGE(24, 24); 1978 uint32_t XOffset : BITFIELD_RANGE(25, 31); 1979 uint32_t Reserved_192; 1980 uint32_t ResourceMinLod : BITFIELD_RANGE(0, 11); 1981 uint32_t Reserved_236 : BITFIELD_RANGE(12, 15); 1982 uint32_t ShaderChannelSelectAlpha : BITFIELD_RANGE(16, 18); 1983 uint32_t ShaderChannelSelectBlue : BITFIELD_RANGE(19, 21); 1984 uint32_t ShaderChannelSelectGreen : BITFIELD_RANGE(22, 24); 1985 uint32_t ShaderChannelSelectRed : BITFIELD_RANGE(25, 27); 1986 uint32_t AlphaClearColor : BITFIELD_RANGE(28, 28); 1987 uint32_t BlueClearColor : BITFIELD_RANGE(29, 29); 1988 uint32_t GreenClearColor : BITFIELD_RANGE(30, 30); 1989 uint32_t RedClearColor : BITFIELD_RANGE(31, 31); 1990 uint64_t SurfaceBaseAddress; 1991 uint64_t Reserved_320; 1992 uint32_t Reserved_384; 1993 uint32_t Reserved_416; 1994 uint32_t Reserved_448; 1995 uint32_t Reserved_480; 1996 } Common; 1997 struct tagSurfaceTypeIsnotSurftype_Cube { 1998 uint32_t Reserved_0; 1999 uint32_t Reserved_32; 2000 uint32_t Reserved_64; 2001 uint32_t Reserved_96; 2002 uint32_t Reserved_128; 2003 uint32_t Reserved_160; 2004 uint32_t Reserved_192; 2005 uint32_t Reserved_224; 2006 uint64_t Reserved_256; 2007 uint64_t Reserved_320; 2008 uint32_t Reserved_384; 2009 uint32_t Reserved_416; 2010 uint32_t Reserved_448; 2011 uint32_t Reserved_480; 2012 } SurfaceTypeIsnotSurftype_Cube; 2013 struct tagSurfaceTypeIsSurftype_Cube { 2014 uint32_t CubeFaceEnable_PositiveZ : BITFIELD_RANGE(0, 0); 2015 uint32_t CubeFaceEnable_NegativeZ : BITFIELD_RANGE(1, 1); 2016 uint32_t CubeFaceEnable_PositiveY : BITFIELD_RANGE(2, 2); 2017 uint32_t CubeFaceEnable_NegativeY : BITFIELD_RANGE(3, 3); 2018 uint32_t CubeFaceEnable_PositiveX : BITFIELD_RANGE(4, 4); 2019 uint32_t CubeFaceEnable_NegativeX : BITFIELD_RANGE(5, 5); 2020 uint32_t Reserved_6 : BITFIELD_RANGE(6, 31); 2021 uint32_t Reserved_32; 2022 uint32_t Reserved_64; 2023 uint32_t Reserved_96; 2024 uint32_t Reserved_128; 2025 uint32_t Reserved_160; 2026 uint32_t Reserved_192; 2027 uint32_t Reserved_224; 2028 uint64_t Reserved_256; 2029 uint64_t Reserved_320; 2030 uint32_t Reserved_384; 2031 uint32_t Reserved_416; 2032 uint32_t Reserved_448; 2033 uint32_t Reserved_480; 2034 } SurfaceTypeIsSurftype_Cube; 2035 struct tagSurfaceTypeIsnotSurftype_Strbuf { 2036 uint32_t Reserved_0; 2037 uint32_t Reserved_32; 2038 uint32_t Reserved_64; 2039 uint32_t Reserved_96; 2040 uint32_t MultisamplePositionPaletteIndex : BITFIELD_RANGE(0, 2); 2041 uint32_t NumberOfMultisamples : BITFIELD_RANGE(3, 5); 2042 uint32_t MultisampledSurfaceStorageFormat : BITFIELD_RANGE(6, 6); 2043 uint32_t RenderTargetViewExtent : BITFIELD_RANGE(7, 17); 2044 uint32_t MinimumArrayElement : BITFIELD_RANGE(18, 28); 2045 uint32_t RenderTargetAndSampleUnormRotation : BITFIELD_RANGE(29, 30); 2046 uint32_t Reserved_159 : BITFIELD_RANGE(31, 31); 2047 uint32_t Reserved_160; 2048 uint32_t Reserved_192; 2049 uint32_t Reserved_224; 2050 uint64_t Reserved_256; 2051 uint64_t Reserved_320; 2052 uint32_t Reserved_384; 2053 uint32_t Reserved_416; 2054 uint32_t Reserved_448; 2055 uint32_t Reserved_480; 2056 } SurfaceTypeIsnotSurftype_Strbuf; 2057 struct tagSurfaceTypeIsSurftype_Strbuf { 2058 uint32_t Reserved_0; 2059 uint32_t Reserved_32; 2060 uint32_t Reserved_64; 2061 uint32_t Reserved_96; 2062 uint32_t Reserved_128; 2063 uint32_t Reserved_160; 2064 uint32_t Reserved_192; 2065 uint32_t Reserved_224; 2066 uint64_t Reserved_256; 2067 uint64_t Reserved_320; 2068 uint32_t Reserved_384; 2069 uint32_t Reserved_416; 2070 uint32_t Reserved_448; 2071 uint32_t Reserved_480; 2072 } SurfaceTypeIsSurftype_Strbuf; 2073 struct tag_SurfaceFormatIsPlanar { 2074 uint32_t Reserved_0; 2075 uint32_t Reserved_32; 2076 uint32_t Reserved_64; 2077 uint32_t Reserved_96; 2078 uint32_t Reserved_128; 2079 uint32_t Reserved_160; 2080 uint32_t YOffsetForUOrUvPlane : BITFIELD_RANGE(0, 13); 2081 uint32_t Reserved_206 : BITFIELD_RANGE(14, 15); 2082 uint32_t XOffsetForUOrUvPlane : BITFIELD_RANGE(16, 29); 2083 uint32_t Reserved_222 : BITFIELD_RANGE(30, 30); 2084 uint32_t SeparateUvPlaneEnable : BITFIELD_RANGE(31, 31); 2085 uint32_t Reserved_224; 2086 uint64_t Reserved_256; 2087 uint64_t Reserved_320 : BITFIELD_RANGE(0, 31); 2088 uint64_t YOffsetForVPlane : BITFIELD_RANGE(32, 45); 2089 uint64_t Reserved_366 : BITFIELD_RANGE(46, 47); 2090 uint64_t XOffsetForVPlane : BITFIELD_RANGE(48, 61); 2091 uint64_t Reserved_382 : BITFIELD_RANGE(62, 63); 2092 uint32_t Reserved_384; 2093 uint32_t Reserved_416; 2094 uint32_t Reserved_448; 2095 uint32_t Reserved_480; 2096 } _SurfaceFormatIsPlanar; 2097 struct tag_SurfaceFormatIsnotPlanar { 2098 uint32_t Reserved_0; 2099 uint32_t Reserved_32; 2100 uint32_t Reserved_64; 2101 uint32_t Reserved_96; 2102 uint32_t Reserved_128; 2103 uint32_t Reserved_160; 2104 uint32_t AuxiliarySurfaceMode : BITFIELD_RANGE(0, 2); 2105 uint32_t AuxiliarySurfacePitch : BITFIELD_RANGE(3, 11); 2106 uint32_t Reserved_204 : BITFIELD_RANGE(12, 15); 2107 uint32_t AuxiliarySurfaceQpitch : BITFIELD_RANGE(16, 30); 2108 uint32_t Reserved_223 : BITFIELD_RANGE(31, 31); 2109 uint32_t Reserved_224; 2110 uint64_t Reserved_256; 2111 uint64_t Reserved_320; 2112 uint32_t Reserved_384; 2113 uint32_t Reserved_416; 2114 uint32_t Reserved_448; 2115 uint32_t Reserved_480; 2116 } _SurfaceFormatIsnotPlanar; 2117 struct tag_SurfaceFormatIsnotPlanarAndMemoryCompressionEnableIs0 { 2118 uint32_t Reserved_0; 2119 uint32_t Reserved_32; 2120 uint32_t Reserved_64; 2121 uint32_t Reserved_96; 2122 uint32_t Reserved_128; 2123 uint32_t Reserved_160; 2124 uint32_t Reserved_192; 2125 uint32_t Reserved_224; 2126 uint64_t Reserved_256; 2127 uint64_t Reserved_320 : BITFIELD_RANGE(0, 11); 2128 uint64_t AuxiliarySurfaceBaseAddress : BITFIELD_RANGE(12, 63); 2129 uint32_t Reserved_384; 2130 uint32_t Reserved_416; 2131 uint32_t Reserved_448; 2132 uint32_t Reserved_480; 2133 } _SurfaceFormatIsnotPlanarAndMemoryCompressionEnableIs0; 2134 struct tagMemoryCompressionEnableIs1 { 2135 uint32_t Reserved_0; 2136 uint32_t Reserved_32; 2137 uint32_t Reserved_64; 2138 uint32_t Reserved_96; 2139 uint32_t Reserved_128; 2140 uint32_t Reserved_160; 2141 uint32_t Reserved_192; 2142 uint32_t Reserved_224; 2143 uint64_t Reserved_256; 2144 uint64_t Reserved_320 : BITFIELD_RANGE(0, 20); 2145 uint64_t AuxiliaryTableIndexForMediaCompressedSurface : BITFIELD_RANGE(21, 31); 2146 uint64_t Reserved_352 : BITFIELD_RANGE(32, 63); 2147 uint32_t Reserved_384; 2148 uint32_t Reserved_416; 2149 uint32_t Reserved_448; 2150 uint32_t Reserved_480; 2151 } MemoryCompressionEnableIs1; 2152 struct tagAuxiliarySurfaceModeIsAux_Hiz { 2153 uint32_t Reserved_0; 2154 uint32_t Reserved_32; 2155 uint32_t Reserved_64; 2156 uint32_t Reserved_96; 2157 uint32_t Reserved_128; 2158 uint32_t Reserved_160; 2159 uint32_t Reserved_192; 2160 uint32_t Reserved_224; 2161 uint64_t Reserved_256; 2162 uint64_t Reserved_320; 2163 uint32_t Reserved_384; 2164 uint32_t Reserved_416; 2165 uint32_t Reserved_448; 2166 uint32_t Reserved_480; 2167 } AuxiliarySurfaceModeIsAux_Hiz; 2168 uint32_t RawData[16]; 2169 } TheStructure; 2170 typedef enum tagMEDIA_BOUNDARY_PIXEL_MODE { 2171 MEDIA_BOUNDARY_PIXEL_MODE_NORMAL_MODE = 0x0, 2172 MEDIA_BOUNDARY_PIXEL_MODE_PROGRESSIVE_FRAME = 0x2, 2173 MEDIA_BOUNDARY_PIXEL_MODE_INTERLACED_FRAME = 0x3, 2174 } MEDIA_BOUNDARY_PIXEL_MODE; 2175 typedef enum tagRENDER_CACHE_READ_WRITE_MODE { 2176 RENDER_CACHE_READ_WRITE_MODE_WRITE_ONLY_CACHE = 0x0, 2177 RENDER_CACHE_READ_WRITE_MODE_READ_WRITE_CACHE = 0x1, 2178 } RENDER_CACHE_READ_WRITE_MODE; 2179 typedef enum tagTILE_MODE { 2180 TILE_MODE_LINEAR = 0x0, 2181 TILE_MODE_WMAJOR = 0x1, 2182 TILE_MODE_XMAJOR = 0x2, 2183 TILE_MODE_YMAJOR = 0x3, 2184 } TILE_MODE; 2185 typedef enum tagSURFACE_HORIZONTAL_ALIGNMENT { 2186 SURFACE_HORIZONTAL_ALIGNMENT_HALIGN_4 = 0x1, 2187 SURFACE_HORIZONTAL_ALIGNMENT_HALIGN_8 = 0x2, 2188 SURFACE_HORIZONTAL_ALIGNMENT_HALIGN_16 = 0x3, 2189 } SURFACE_HORIZONTAL_ALIGNMENT; 2190 typedef enum tagSURFACE_VERTICAL_ALIGNMENT { 2191 SURFACE_VERTICAL_ALIGNMENT_VALIGN_4 = 0x1, 2192 SURFACE_VERTICAL_ALIGNMENT_VALIGN_8 = 0x2, 2193 SURFACE_VERTICAL_ALIGNMENT_VALIGN_16 = 0x3, 2194 } SURFACE_VERTICAL_ALIGNMENT; 2195 typedef enum tagSURFACE_FORMAT { 2196 SURFACE_FORMAT_R32G32B32A32_FLOAT = 0x0, 2197 SURFACE_FORMAT_R32G32B32A32_SINT = 0x1, 2198 SURFACE_FORMAT_R32G32B32A32_UINT = 0x2, 2199 SURFACE_FORMAT_R32G32B32A32_UNORM = 0x3, 2200 SURFACE_FORMAT_R32G32B32A32_SNORM = 0x4, 2201 SURFACE_FORMAT_R64G64_FLOAT = 0x5, 2202 SURFACE_FORMAT_R32G32B32X32_FLOAT = 0x6, 2203 SURFACE_FORMAT_R32G32B32A32_SSCALED = 0x7, 2204 SURFACE_FORMAT_R32G32B32A32_USCALED = 0x8, 2205 SURFACE_FORMAT_R32G32B32A32_SFIXED = 0x20, 2206 SURFACE_FORMAT_R64G64_PASSTHRU = 0x21, 2207 SURFACE_FORMAT_R32G32B32_FLOAT = 0x40, 2208 SURFACE_FORMAT_R32G32B32_SINT = 0x41, 2209 SURFACE_FORMAT_R32G32B32_UINT = 0x42, 2210 SURFACE_FORMAT_R32G32B32_UNORM = 0x43, 2211 SURFACE_FORMAT_R32G32B32_SNORM = 0x44, 2212 SURFACE_FORMAT_R32G32B32_SSCALED = 0x45, 2213 SURFACE_FORMAT_R32G32B32_USCALED = 0x46, 2214 SURFACE_FORMAT_R32G32B32_SFIXED = 0x50, 2215 SURFACE_FORMAT_R16G16B16A16_UNORM = 0x80, 2216 SURFACE_FORMAT_R16G16B16A16_SNORM = 0x81, 2217 SURFACE_FORMAT_R16G16B16A16_SINT = 0x82, 2218 SURFACE_FORMAT_R16G16B16A16_UINT = 0x83, 2219 SURFACE_FORMAT_R16G16B16A16_FLOAT = 0x84, 2220 SURFACE_FORMAT_R32G32_FLOAT = 0x85, 2221 SURFACE_FORMAT_R32G32_SINT = 0x86, 2222 SURFACE_FORMAT_R32G32_UINT = 0x87, 2223 SURFACE_FORMAT_R32_FLOAT_X8X24_TYPELESS = 0x88, 2224 SURFACE_FORMAT_X32_TYPELESS_G8X24_UINT = 0x89, 2225 SURFACE_FORMAT_L32A32_FLOAT = 0x8a, 2226 SURFACE_FORMAT_R32G32_UNORM = 0x8b, 2227 SURFACE_FORMAT_R32G32_SNORM = 0x8c, 2228 SURFACE_FORMAT_R64_FLOAT = 0x8d, 2229 SURFACE_FORMAT_R16G16B16X16_UNORM = 0x8e, 2230 SURFACE_FORMAT_R16G16B16X16_FLOAT = 0x8f, 2231 SURFACE_FORMAT_A32X32_FLOAT = 0x90, 2232 SURFACE_FORMAT_L32X32_FLOAT = 0x91, 2233 SURFACE_FORMAT_I32X32_FLOAT = 0x92, 2234 SURFACE_FORMAT_R16G16B16A16_SSCALED = 0x93, 2235 SURFACE_FORMAT_R16G16B16A16_USCALED = 0x94, 2236 SURFACE_FORMAT_R32G32_SSCALED = 0x95, 2237 SURFACE_FORMAT_R32G32_USCALED = 0x96, 2238 SURFACE_FORMAT_R32G32_SFIXED = 0xa0, 2239 SURFACE_FORMAT_R64_PASSTHRU = 0xa1, 2240 SURFACE_FORMAT_B8G8R8A8_UNORM = 0xc0, 2241 SURFACE_FORMAT_B8G8R8A8_UNORM_SRGB = 0xc1, 2242 SURFACE_FORMAT_R10G10B10A2_UNORM = 0xc2, 2243 SURFACE_FORMAT_R10G10B10A2_UNORM_SRGB = 0xc3, 2244 SURFACE_FORMAT_R10G10B10A2_UINT = 0xc4, 2245 SURFACE_FORMAT_R10G10B10_SNORM_A2_UNORM = 0xc5, 2246 SURFACE_FORMAT_R8G8B8A8_UNORM = 0xc7, 2247 SURFACE_FORMAT_R8G8B8A8_UNORM_SRGB = 0xc8, 2248 SURFACE_FORMAT_R8G8B8A8_SNORM = 0xc9, 2249 SURFACE_FORMAT_R8G8B8A8_SINT = 0xca, 2250 SURFACE_FORMAT_R8G8B8A8_UINT = 0xcb, 2251 SURFACE_FORMAT_R16G16_UNORM = 0xcc, 2252 SURFACE_FORMAT_R16G16_SNORM = 0xcd, 2253 SURFACE_FORMAT_R16G16_SINT = 0xce, 2254 SURFACE_FORMAT_R16G16_UINT = 0xcf, 2255 SURFACE_FORMAT_R16G16_FLOAT = 0xd0, 2256 SURFACE_FORMAT_B10G10R10A2_UNORM = 0xd1, 2257 SURFACE_FORMAT_B10G10R10A2_UNORM_SRGB = 0xd2, 2258 SURFACE_FORMAT_R11G11B10_FLOAT = 0xd3, 2259 SURFACE_FORMAT_R32_SINT = 0xd6, 2260 SURFACE_FORMAT_R32_UINT = 0xd7, 2261 SURFACE_FORMAT_R32_FLOAT = 0xd8, 2262 SURFACE_FORMAT_R24_UNORM_X8_TYPELESS = 0xd9, 2263 SURFACE_FORMAT_X24_TYPELESS_G8_UINT = 0xda, 2264 SURFACE_FORMAT_L32_UNORM = 0xdd, 2265 SURFACE_FORMAT_A32_UNORM = 0xde, 2266 SURFACE_FORMAT_L16A16_UNORM = 0xdf, 2267 SURFACE_FORMAT_I24X8_UNORM = 0xe0, 2268 SURFACE_FORMAT_L24X8_UNORM = 0xe1, 2269 SURFACE_FORMAT_A24X8_UNORM = 0xe2, 2270 SURFACE_FORMAT_I32_FLOAT = 0xe3, 2271 SURFACE_FORMAT_L32_FLOAT = 0xe4, 2272 SURFACE_FORMAT_A32_FLOAT = 0xe5, 2273 SURFACE_FORMAT_X8B8_UNORM_G8R8_SNORM = 0xe6, 2274 SURFACE_FORMAT_A8X8_UNORM_G8R8_SNORM = 0xe7, 2275 SURFACE_FORMAT_B8X8_UNORM_G8R8_SNORM = 0xe8, 2276 SURFACE_FORMAT_B8G8R8X8_UNORM = 0xe9, 2277 SURFACE_FORMAT_B8G8R8X8_UNORM_SRGB = 0xea, 2278 SURFACE_FORMAT_R8G8B8X8_UNORM = 0xeb, 2279 SURFACE_FORMAT_R8G8B8X8_UNORM_SRGB = 0xec, 2280 SURFACE_FORMAT_R9G9B9E5_SHAREDEXP = 0xed, 2281 SURFACE_FORMAT_B10G10R10X2_UNORM = 0xee, 2282 SURFACE_FORMAT_L16A16_FLOAT = 0xf0, 2283 SURFACE_FORMAT_R32_UNORM = 0xf1, 2284 SURFACE_FORMAT_R32_SNORM = 0xf2, 2285 SURFACE_FORMAT_R10G10B10X2_USCALED = 0xf3, 2286 SURFACE_FORMAT_R8G8B8A8_SSCALED = 0xf4, 2287 SURFACE_FORMAT_R8G8B8A8_USCALED = 0xf5, 2288 SURFACE_FORMAT_R16G16_SSCALED = 0xf6, 2289 SURFACE_FORMAT_R16G16_USCALED = 0xf7, 2290 SURFACE_FORMAT_R32_SSCALED = 0xf8, 2291 SURFACE_FORMAT_R32_USCALED = 0xf9, 2292 SURFACE_FORMAT_B5G6R5_UNORM = 0x100, 2293 SURFACE_FORMAT_B5G6R5_UNORM_SRGB = 0x101, 2294 SURFACE_FORMAT_B5G5R5A1_UNORM = 0x102, 2295 SURFACE_FORMAT_B5G5R5A1_UNORM_SRGB = 0x103, 2296 SURFACE_FORMAT_B4G4R4A4_UNORM = 0x104, 2297 SURFACE_FORMAT_B4G4R4A4_UNORM_SRGB = 0x105, 2298 SURFACE_FORMAT_R8G8_UNORM = 0x106, 2299 SURFACE_FORMAT_R8G8_SNORM = 0x107, 2300 SURFACE_FORMAT_R8G8_SINT = 0x108, 2301 SURFACE_FORMAT_R8G8_UINT = 0x109, 2302 SURFACE_FORMAT_R16_UNORM = 0x10a, 2303 SURFACE_FORMAT_R16_SNORM = 0x10b, 2304 SURFACE_FORMAT_R16_SINT = 0x10c, 2305 SURFACE_FORMAT_R16_UINT = 0x10d, 2306 SURFACE_FORMAT_R16_FLOAT = 0x10e, 2307 SURFACE_FORMAT_A8P8_UNORM_PALETTE0 = 0x10f, 2308 SURFACE_FORMAT_A8P8_UNORM_PALETTE1 = 0x110, 2309 SURFACE_FORMAT_I16_UNORM = 0x111, 2310 SURFACE_FORMAT_L16_UNORM = 0x112, 2311 SURFACE_FORMAT_A16_UNORM = 0x113, 2312 SURFACE_FORMAT_L8A8_UNORM = 0x114, 2313 SURFACE_FORMAT_I16_FLOAT = 0x115, 2314 SURFACE_FORMAT_L16_FLOAT = 0x116, 2315 SURFACE_FORMAT_A16_FLOAT = 0x117, 2316 SURFACE_FORMAT_L8A8_UNORM_SRGB = 0x118, 2317 SURFACE_FORMAT_R5G5_SNORM_B6_UNORM = 0x119, 2318 SURFACE_FORMAT_B5G5R5X1_UNORM = 0x11a, 2319 SURFACE_FORMAT_B5G5R5X1_UNORM_SRGB = 0x11b, 2320 SURFACE_FORMAT_R8G8_SSCALED = 0x11c, 2321 SURFACE_FORMAT_R8G8_USCALED = 0x11d, 2322 SURFACE_FORMAT_R16_SSCALED = 0x11e, 2323 SURFACE_FORMAT_R16_USCALED = 0x11f, 2324 SURFACE_FORMAT_P8A8_UNORM_PALETTE0 = 0x122, 2325 SURFACE_FORMAT_P8A8_UNORM_PALETTE1 = 0x123, 2326 SURFACE_FORMAT_A1B5G5R5_UNORM = 0x124, 2327 SURFACE_FORMAT_A4B4G4R4_UNORM = 0x125, 2328 SURFACE_FORMAT_L8A8_UINT = 0x126, 2329 SURFACE_FORMAT_L8A8_SINT = 0x127, 2330 SURFACE_FORMAT_R8_UNORM = 0x140, 2331 SURFACE_FORMAT_R8_SNORM = 0x141, 2332 SURFACE_FORMAT_R8_SINT = 0x142, 2333 SURFACE_FORMAT_R8_UINT = 0x143, 2334 SURFACE_FORMAT_A8_UNORM = 0x144, 2335 SURFACE_FORMAT_I8_UNORM = 0x145, 2336 SURFACE_FORMAT_L8_UNORM = 0x146, 2337 SURFACE_FORMAT_P4A4_UNORM_PALETTE0 = 0x147, 2338 SURFACE_FORMAT_A4P4_UNORM_PALETTE0 = 0x148, 2339 SURFACE_FORMAT_R8_SSCALED = 0x149, 2340 SURFACE_FORMAT_R8_USCALED = 0x14a, 2341 SURFACE_FORMAT_P8_UNORM_PALETTE0 = 0x14b, 2342 SURFACE_FORMAT_L8_UNORM_SRGB = 0x14c, 2343 SURFACE_FORMAT_P8_UNORM_PALETTE1 = 0x14d, 2344 SURFACE_FORMAT_P4A4_UNORM_PALETTE1 = 0x14e, 2345 SURFACE_FORMAT_A4P4_UNORM_PALETTE1 = 0x14f, 2346 SURFACE_FORMAT_Y8_UNORM = 0x150, 2347 SURFACE_FORMAT_L8_UINT = 0x152, 2348 SURFACE_FORMAT_L8_SINT = 0x153, 2349 SURFACE_FORMAT_I8_UINT = 0x154, 2350 SURFACE_FORMAT_I8_SINT = 0x155, 2351 SURFACE_FORMAT_DXT1_RGB_SRGB = 0x180, 2352 SURFACE_FORMAT_R1_UNORM = 0x181, 2353 SURFACE_FORMAT_YCRCB_NORMAL = 0x182, 2354 SURFACE_FORMAT_YCRCB_SWAPUVY = 0x183, 2355 SURFACE_FORMAT_P2_UNORM_PALETTE0 = 0x184, 2356 SURFACE_FORMAT_P2_UNORM_PALETTE1 = 0x185, 2357 SURFACE_FORMAT_BC1_UNORM = 0x186, 2358 SURFACE_FORMAT_BC2_UNORM = 0x187, 2359 SURFACE_FORMAT_BC3_UNORM = 0x188, 2360 SURFACE_FORMAT_BC4_UNORM = 0x189, 2361 SURFACE_FORMAT_BC5_UNORM = 0x18a, 2362 SURFACE_FORMAT_BC1_UNORM_SRGB = 0x18b, 2363 SURFACE_FORMAT_BC2_UNORM_SRGB = 0x18c, 2364 SURFACE_FORMAT_BC3_UNORM_SRGB = 0x18d, 2365 SURFACE_FORMAT_MONO8 = 0x18e, 2366 SURFACE_FORMAT_YCRCB_SWAPUV = 0x18f, 2367 SURFACE_FORMAT_YCRCB_SWAPY = 0x190, 2368 SURFACE_FORMAT_DXT1_RGB = 0x191, 2369 SURFACE_FORMAT_FXT1 = 0x192, 2370 SURFACE_FORMAT_R8G8B8_UNORM = 0x193, 2371 SURFACE_FORMAT_R8G8B8_SNORM = 0x194, 2372 SURFACE_FORMAT_R8G8B8_SSCALED = 0x195, 2373 SURFACE_FORMAT_R8G8B8_USCALED = 0x196, 2374 SURFACE_FORMAT_R64G64B64A64_FLOAT = 0x197, 2375 SURFACE_FORMAT_R64G64B64_FLOAT = 0x198, 2376 SURFACE_FORMAT_BC4_SNORM = 0x199, 2377 SURFACE_FORMAT_BC5_SNORM = 0x19a, 2378 SURFACE_FORMAT_R16G16B16_FLOAT = 0x19b, 2379 SURFACE_FORMAT_R16G16B16_UNORM = 0x19c, 2380 SURFACE_FORMAT_R16G16B16_SNORM = 0x19d, 2381 SURFACE_FORMAT_R16G16B16_SSCALED = 0x19e, 2382 SURFACE_FORMAT_R16G16B16_USCALED = 0x19f, 2383 SURFACE_FORMAT_BC6H_SF16 = 0x1a1, 2384 SURFACE_FORMAT_BC7_UNORM = 0x1a2, 2385 SURFACE_FORMAT_BC7_UNORM_SRGB = 0x1a3, 2386 SURFACE_FORMAT_BC6H_UF16 = 0x1a4, 2387 SURFACE_FORMAT_PLANAR_420_8 = 0x1a5, 2388 SURFACE_FORMAT_R8G8B8_UNORM_SRGB = 0x1a8, 2389 SURFACE_FORMAT_ETC1_RGB8 = 0x1a9, 2390 SURFACE_FORMAT_ETC2_RGB8 = 0x1aa, 2391 SURFACE_FORMAT_EAC_R11 = 0x1ab, 2392 SURFACE_FORMAT_EAC_RG11 = 0x1ac, 2393 SURFACE_FORMAT_EAC_SIGNED_R11 = 0x1ad, 2394 SURFACE_FORMAT_EAC_SIGNED_RG11 = 0x1ae, 2395 SURFACE_FORMAT_ETC2_SRGB8 = 0x1af, 2396 SURFACE_FORMAT_R16G16B16_UINT = 0x1b0, 2397 SURFACE_FORMAT_R16G16B16_SINT = 0x1b1, 2398 SURFACE_FORMAT_R32_SFIXED = 0x1b2, 2399 SURFACE_FORMAT_R10G10B10A2_SNORM = 0x1b3, 2400 SURFACE_FORMAT_R10G10B10A2_USCALED = 0x1b4, 2401 SURFACE_FORMAT_R10G10B10A2_SSCALED = 0x1b5, 2402 SURFACE_FORMAT_R10G10B10A2_SINT = 0x1b6, 2403 SURFACE_FORMAT_B10G10R10A2_SNORM = 0x1b7, 2404 SURFACE_FORMAT_B10G10R10A2_USCALED = 0x1b8, 2405 SURFACE_FORMAT_B10G10R10A2_SSCALED = 0x1b9, 2406 SURFACE_FORMAT_B10G10R10A2_UINT = 0x1ba, 2407 SURFACE_FORMAT_B10G10R10A2_SINT = 0x1bb, 2408 SURFACE_FORMAT_R64G64B64A64_PASSTHRU = 0x1bc, 2409 SURFACE_FORMAT_R64G64B64_PASSTHRU = 0x1bd, 2410 SURFACE_FORMAT_ETC2_RGB8_PTA = 0x1c0, 2411 SURFACE_FORMAT_ETC2_SRGB8_PTA = 0x1c1, 2412 SURFACE_FORMAT_ETC2_EAC_RGBA8 = 0x1c2, 2413 SURFACE_FORMAT_ETC2_EAC_SRGB8_A8 = 0x1c3, 2414 SURFACE_FORMAT_R8G8B8_UINT = 0x1c8, 2415 SURFACE_FORMAT_R8G8B8_SINT = 0x1c9, 2416 SURFACE_FORMAT_RAW = 0x1ff, 2417 } SURFACE_FORMAT; 2418 typedef enum tagSURFACE_TYPE { 2419 SURFACE_TYPE_SURFTYPE_1D = 0x0, 2420 SURFACE_TYPE_SURFTYPE_2D = 0x1, 2421 SURFACE_TYPE_SURFTYPE_3D = 0x2, 2422 SURFACE_TYPE_SURFTYPE_CUBE = 0x3, 2423 SURFACE_TYPE_SURFTYPE_BUFFER = 0x4, 2424 SURFACE_TYPE_SURFTYPE_STRBUF = 0x5, 2425 SURFACE_TYPE_SURFTYPE_NULL = 0x7, 2426 } SURFACE_TYPE; 2427 typedef enum tagNUMBER_OF_MULTISAMPLES { 2428 NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_1 = 0x0, 2429 NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_2 = 0x1, 2430 NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_4 = 0x2, 2431 NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_8 = 0x3, 2432 } NUMBER_OF_MULTISAMPLES; 2433 typedef enum tagMULTISAMPLED_SURFACE_STORAGE_FORMAT { 2434 MULTISAMPLED_SURFACE_STORAGE_FORMAT_MSS = 0x0, 2435 MULTISAMPLED_SURFACE_STORAGE_FORMAT_DEPTH_STENCIL = 0x1, 2436 } MULTISAMPLED_SURFACE_STORAGE_FORMAT; 2437 typedef enum tagRENDER_TARGET_AND_SAMPLE_UNORM_ROTATION { 2438 RENDER_TARGET_AND_SAMPLE_UNORM_ROTATION_0DEG = 0x0, 2439 RENDER_TARGET_AND_SAMPLE_UNORM_ROTATION_90DEG = 0x1, 2440 RENDER_TARGET_AND_SAMPLE_UNORM_ROTATION_270DEG = 0x3, 2441 } RENDER_TARGET_AND_SAMPLE_UNORM_ROTATION; 2442 typedef enum tagCOHERENCY_TYPE { 2443 COHERENCY_TYPE_GPU_COHERENT = 0x0, 2444 COHERENCY_TYPE_IA_COHERENT = 0x1, 2445 } COHERENCY_TYPE; 2446 typedef enum tagAUXILIARY_SURFACE_MODE { 2447 AUXILIARY_SURFACE_MODE_AUX_NONE = 0x0, 2448 AUXILIARY_SURFACE_MODE_AUX_MCS = 0x1, 2449 AUXILIARY_SURFACE_MODE_AUX_APPEND = 0x2, 2450 AUXILIARY_SURFACE_MODE_AUX_HIZ = 0x3, 2451 AUXILIARY_SURFACE_MODE_AUX_CCS_E = 0x5, 2452 } AUXILIARY_SURFACE_MODE; 2453 typedef enum tagSHADER_CHANNEL_SELECT { 2454 SHADER_CHANNEL_SELECT_ZERO = 0x0, 2455 SHADER_CHANNEL_SELECT_ONE = 0x1, 2456 SHADER_CHANNEL_SELECT_RED = 0x4, 2457 SHADER_CHANNEL_SELECT_GREEN = 0x5, 2458 SHADER_CHANNEL_SELECT_BLUE = 0x6, 2459 SHADER_CHANNEL_SELECT_ALPHA = 0x7, 2460 } SHADER_CHANNEL_SELECT; 2461 typedef enum tagALPHA_CLEAR_COLOR { 2462 ALPHA_CLEAR_COLOR_CC_ZERO = 0x0, 2463 ALPHA_CLEAR_COLOR_CC_ONE = 0x1, 2464 } ALPHA_CLEAR_COLOR; 2465 typedef enum tagBLUE_CLEAR_COLOR { 2466 BLUE_CLEAR_COLOR_CC_ZERO = 0x0, 2467 BLUE_CLEAR_COLOR_CC_ONE = 0x1, 2468 } BLUE_CLEAR_COLOR; 2469 typedef enum tagGREEN_CLEAR_COLOR { 2470 GREEN_CLEAR_COLOR_CC_ZERO = 0x0, 2471 GREEN_CLEAR_COLOR_CC_ONE = 0x1, 2472 } GREEN_CLEAR_COLOR; 2473 typedef enum tagRED_CLEAR_COLOR { 2474 RED_CLEAR_COLOR_CC_ZERO = 0x0, 2475 RED_CLEAR_COLOR_CC_ONE = 0x1, 2476 } RED_CLEAR_COLOR; 2477 typedef enum tagPATCH_CONSTANTS { 2478 SURFACEBASEADDRESS_BYTEOFFSET = 0x20, 2479 SURFACEBASEADDRESS_INDEX = 0x8, 2480 AUXILIARYSURFACEBASEADDRESS_BYTEOFFSET = 0x28, 2481 AUXILIARYSURFACEBASEADDRESS_INDEX = 0xa, 2482 } PATCH_CONSTANTS; 2483 inline void init() { 2484 memset(&TheStructure, 0, sizeof(TheStructure)); 2485 TheStructure.Common.MediaBoundaryPixelMode = MEDIA_BOUNDARY_PIXEL_MODE_NORMAL_MODE; 2486 TheStructure.Common.RenderCacheReadWriteMode = RENDER_CACHE_READ_WRITE_MODE_WRITE_ONLY_CACHE; 2487 TheStructure.Common.TileMode = TILE_MODE_LINEAR; 2488 TheStructure.Common.SurfaceHorizontalAlignment = SURFACE_HORIZONTAL_ALIGNMENT_HALIGN_4; 2489 TheStructure.Common.SurfaceVerticalAlignment = SURFACE_VERTICAL_ALIGNMENT_VALIGN_4; 2490 TheStructure.Common.SurfaceType = SURFACE_TYPE_SURFTYPE_1D; 2491 TheStructure.Common.CoherencyType = COHERENCY_TYPE_GPU_COHERENT; 2492 TheStructure.Common.ShaderChannelSelectAlpha = SHADER_CHANNEL_SELECT_ZERO; 2493 TheStructure.Common.ShaderChannelSelectBlue = SHADER_CHANNEL_SELECT_ZERO; 2494 TheStructure.Common.ShaderChannelSelectGreen = SHADER_CHANNEL_SELECT_ZERO; 2495 TheStructure.Common.ShaderChannelSelectRed = SHADER_CHANNEL_SELECT_ZERO; 2496 TheStructure.Common.AlphaClearColor = ALPHA_CLEAR_COLOR_CC_ZERO; 2497 TheStructure.Common.BlueClearColor = BLUE_CLEAR_COLOR_CC_ZERO; 2498 TheStructure.Common.GreenClearColor = GREEN_CLEAR_COLOR_CC_ZERO; 2499 TheStructure.Common.RedClearColor = RED_CLEAR_COLOR_CC_ZERO; 2500 TheStructure.SurfaceTypeIsnotSurftype_Strbuf.NumberOfMultisamples = NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_1; 2501 TheStructure.SurfaceTypeIsnotSurftype_Strbuf.MultisampledSurfaceStorageFormat = MULTISAMPLED_SURFACE_STORAGE_FORMAT_MSS; 2502 TheStructure.SurfaceTypeIsnotSurftype_Strbuf.RenderTargetAndSampleUnormRotation = RENDER_TARGET_AND_SAMPLE_UNORM_ROTATION_0DEG; 2503 TheStructure._SurfaceFormatIsnotPlanar.AuxiliarySurfaceMode = AUXILIARY_SURFACE_MODE_AUX_NONE; 2504 } 2505 static tagRENDER_SURFACE_STATE sInit() { 2506 RENDER_SURFACE_STATE state; 2507 state.init(); 2508 return state; 2509 } 2510 inline uint32_t &getRawData(const uint32_t index) { 2511 DEBUG_BREAK_IF(index >= 15); 2512 return TheStructure.RawData[index]; 2513 } 2514 inline void setMediaBoundaryPixelMode(const MEDIA_BOUNDARY_PIXEL_MODE value) { 2515 TheStructure.Common.MediaBoundaryPixelMode = value; 2516 } 2517 inline MEDIA_BOUNDARY_PIXEL_MODE getMediaBoundaryPixelMode() const { 2518 return static_cast<MEDIA_BOUNDARY_PIXEL_MODE>(TheStructure.Common.MediaBoundaryPixelMode); 2519 } 2520 inline void setRenderCacheReadWriteMode(const RENDER_CACHE_READ_WRITE_MODE value) { 2521 TheStructure.Common.RenderCacheReadWriteMode = value; 2522 } 2523 inline RENDER_CACHE_READ_WRITE_MODE getRenderCacheReadWriteMode() const { 2524 return static_cast<RENDER_CACHE_READ_WRITE_MODE>(TheStructure.Common.RenderCacheReadWriteMode); 2525 } 2526 inline void setSamplerL2OutOfOrderModeDisable(const bool value) { 2527 TheStructure.Common.SamplerL2OutOfOrderModeDisable = value; 2528 } 2529 inline bool getSamplerL2OutOfOrderModeDisable() const { 2530 return (TheStructure.Common.SamplerL2OutOfOrderModeDisable); 2531 } 2532 inline void setVerticalLineStrideOffset(const uint32_t value) { 2533 TheStructure.Common.VerticalLineStrideOffset = value; 2534 } 2535 inline uint32_t getVerticalLineStrideOffset() const { 2536 return (TheStructure.Common.VerticalLineStrideOffset); 2537 } 2538 inline void setVerticalLineStride(const uint32_t value) { 2539 TheStructure.Common.VerticalLineStride = value; 2540 } 2541 inline uint32_t getVerticalLineStride() const { 2542 return (TheStructure.Common.VerticalLineStride); 2543 } 2544 inline void setTileMode(const TILE_MODE value) { 2545 TheStructure.Common.TileMode = value; 2546 } 2547 inline TILE_MODE getTileMode() const { 2548 return static_cast<TILE_MODE>(TheStructure.Common.TileMode); 2549 } 2550 inline void setSurfaceHorizontalAlignment(const SURFACE_HORIZONTAL_ALIGNMENT value) { 2551 TheStructure.Common.SurfaceHorizontalAlignment = value; 2552 } 2553 inline SURFACE_HORIZONTAL_ALIGNMENT getSurfaceHorizontalAlignment() const { 2554 return static_cast<SURFACE_HORIZONTAL_ALIGNMENT>(TheStructure.Common.SurfaceHorizontalAlignment); 2555 } 2556 inline void setSurfaceVerticalAlignment(const SURFACE_VERTICAL_ALIGNMENT value) { 2557 TheStructure.Common.SurfaceVerticalAlignment = value; 2558 } 2559 inline SURFACE_VERTICAL_ALIGNMENT getSurfaceVerticalAlignment() const { 2560 return static_cast<SURFACE_VERTICAL_ALIGNMENT>(TheStructure.Common.SurfaceVerticalAlignment); 2561 } 2562 inline void setSurfaceFormat(const SURFACE_FORMAT value) { 2563 TheStructure.Common.SurfaceFormat = value; 2564 } 2565 inline SURFACE_FORMAT getSurfaceFormat() const { 2566 return static_cast<SURFACE_FORMAT>(TheStructure.Common.SurfaceFormat); 2567 } 2568 inline void setSurfaceArray(const bool value) { 2569 TheStructure.Common.SurfaceArray = value; 2570 } 2571 inline bool getSurfaceArray() const { 2572 return (TheStructure.Common.SurfaceArray); 2573 } 2574 inline void setSurfaceType(const SURFACE_TYPE value) { 2575 TheStructure.Common.SurfaceType = value; 2576 } 2577 inline SURFACE_TYPE getSurfaceType() const { 2578 return static_cast<SURFACE_TYPE>(TheStructure.Common.SurfaceType); 2579 } 2580 typedef enum tagSURFACEQPITCH { 2581 SURFACEQPITCH_BIT_SHIFT = 0x2, 2582 SURFACEQPITCH_ALIGN_SIZE = 0x4, 2583 } SURFACEQPITCH; 2584 inline void setSurfaceQpitch(const uint32_t value) { 2585 TheStructure.Common.SurfaceQpitch = value >> SURFACEQPITCH_BIT_SHIFT; 2586 } 2587 inline uint32_t getSurfaceQpitch() const { 2588 return (TheStructure.Common.SurfaceQpitch << SURFACEQPITCH_BIT_SHIFT); 2589 } 2590 inline void setBaseMipLevel(const uint32_t value) { 2591 TheStructure.Common.BaseMipLevel = value; 2592 } 2593 inline uint32_t getBaseMipLevel() const { 2594 return (TheStructure.Common.BaseMipLevel); 2595 } 2596 inline void setMemoryObjectControlStateAgeForQuadlru(const uint32_t value) { 2597 TheStructure.Common.MemoryObjectControlState_AgeForQuadlru = value; 2598 } 2599 inline uint32_t getMemoryObjectControlStateAgeForQuadlru() const { 2600 return (TheStructure.Common.MemoryObjectControlState_AgeForQuadlru); 2601 } 2602 inline void setMemoryObjectControlStateReserved(const uint32_t value) { 2603 TheStructure.Common.MemoryObjectControlState_Reserved = value; 2604 } 2605 inline uint32_t getMemoryObjectControlStateReserved() const { 2606 return (TheStructure.Common.MemoryObjectControlState_Reserved); 2607 } 2608 inline void setMemoryObjectControlStateTargetCache(const uint32_t value) { 2609 TheStructure.Common.MemoryObjectControlState_TargetCache = value; 2610 } 2611 inline uint32_t getMemoryObjectControlStateTargetCache() const { 2612 return (TheStructure.Common.MemoryObjectControlState_TargetCache); 2613 } 2614 inline void setMemoryObjectControlStateMemoryTypeLlcEllcCacheabilityControl(const uint32_t value) { 2615 TheStructure.Common.MemoryObjectControlState_MemoryTypeLlcEllcCacheabilityControl = value; 2616 } 2617 inline uint32_t getMemoryObjectControlStateMemoryTypeLlcEllcCacheabilityControl() const { 2618 return (TheStructure.Common.MemoryObjectControlState_MemoryTypeLlcEllcCacheabilityControl); 2619 } 2620 inline void setMemoryObjectControlState(const uint32_t value) { 2621 TheStructure.Common.MemoryObjectControlState_AgeForQuadlru = value; 2622 TheStructure.Common.MemoryObjectControlState_Reserved = (value >> 2); 2623 TheStructure.Common.MemoryObjectControlState_TargetCache = (value >> 3); 2624 TheStructure.Common.MemoryObjectControlState_MemoryTypeLlcEllcCacheabilityControl = (value >> 5); 2625 } 2626 inline uint32_t getMemoryObjectControlState() const { 2627 int32_t mocs = TheStructure.Common.MemoryObjectControlState_AgeForQuadlru; 2628 mocs |= (TheStructure.Common.MemoryObjectControlState_Reserved << 2); 2629 mocs |= (TheStructure.Common.MemoryObjectControlState_TargetCache << 3); 2630 mocs |= (TheStructure.Common.MemoryObjectControlState_MemoryTypeLlcEllcCacheabilityControl << 5); 2631 return (mocs); 2632 } 2633 inline void setWidth(const uint32_t value) { 2634 TheStructure.Common.Width = value - 1; 2635 } 2636 inline uint32_t getWidth() const { 2637 return (TheStructure.Common.Width + 1); 2638 } 2639 inline void setHeight(const uint32_t value) { 2640 TheStructure.Common.Height = value - 1; 2641 } 2642 inline uint32_t getHeight() const { 2643 return (TheStructure.Common.Height + 1); 2644 } 2645 inline void setSurfacePitch(const uint32_t value) { 2646 TheStructure.Common.SurfacePitch = value - 1; 2647 } 2648 inline uint32_t getSurfacePitch() const { 2649 return (TheStructure.Common.SurfacePitch + 1); 2650 } 2651 inline void setDepth(const uint32_t value) { 2652 TheStructure.Common.Depth = value - 1; 2653 } 2654 inline uint32_t getDepth() const { 2655 return (TheStructure.Common.Depth + 1); 2656 } 2657 inline void setMipCountLod(const uint32_t value) { 2658 TheStructure.Common.MipCountLod = value; 2659 } 2660 inline uint32_t getMipCountLod() const { 2661 return (TheStructure.Common.MipCountLod); 2662 } 2663 inline void setMipTailStartLod(const uint32_t value) { 2664 UNRECOVERABLE_IF(true); 2665 } 2666 inline uint32_t getMipTailStartLod() const { 2667 UNRECOVERABLE_IF(true); 2668 return 0; 2669 } 2670 inline void setSurfaceMinLod(const uint32_t value) { 2671 TheStructure.Common.SurfaceMinLod = value; 2672 } 2673 inline uint32_t getSurfaceMinLod() const { 2674 return (TheStructure.Common.SurfaceMinLod); 2675 } 2676 inline void setCoherencyType(const COHERENCY_TYPE value) { 2677 TheStructure.Common.CoherencyType = value; 2678 } 2679 inline COHERENCY_TYPE getCoherencyType() const { 2680 return static_cast<COHERENCY_TYPE>(TheStructure.Common.CoherencyType); 2681 } 2682 inline void setEwaDisableForCube(const bool value) { 2683 TheStructure.Common.EwaDisableForCube = value; 2684 } 2685 inline bool getEwaDisableForCube() const { 2686 return (TheStructure.Common.EwaDisableForCube); 2687 } 2688 typedef enum tagYOFFSET { 2689 YOFFSET_BIT_SHIFT = 0x2, 2690 YOFFSET_ALIGN_SIZE = 0x4, 2691 } YOFFSET; 2692 inline void setYOffset(const uint32_t value) { 2693 TheStructure.Common.YOffset = value >> YOFFSET_BIT_SHIFT; 2694 } 2695 inline uint32_t getYOffset() const { 2696 return (TheStructure.Common.YOffset << YOFFSET_BIT_SHIFT); 2697 } 2698 typedef enum tagXOFFSET { 2699 XOFFSET_BIT_SHIFT = 0x2, 2700 XOFFSET_ALIGN_SIZE = 0x4, 2701 } XOFFSET; 2702 inline void setXOffset(const uint32_t value) { 2703 TheStructure.Common.XOffset = value >> XOFFSET_BIT_SHIFT; 2704 } 2705 inline uint32_t getXOffset() const { 2706 return (TheStructure.Common.XOffset << XOFFSET_BIT_SHIFT); 2707 } 2708 inline void setResourceMinLod(const uint32_t value) { 2709 TheStructure.Common.ResourceMinLod = value; 2710 } 2711 inline uint32_t getResourceMinLod() const { 2712 return (TheStructure.Common.ResourceMinLod); 2713 } 2714 inline void setShaderChannelSelectAlpha(const SHADER_CHANNEL_SELECT value) { 2715 TheStructure.Common.ShaderChannelSelectAlpha = value; 2716 } 2717 inline SHADER_CHANNEL_SELECT getShaderChannelSelectAlpha() const { 2718 return static_cast<SHADER_CHANNEL_SELECT>(TheStructure.Common.ShaderChannelSelectAlpha); 2719 } 2720 inline void setShaderChannelSelectBlue(const SHADER_CHANNEL_SELECT value) { 2721 TheStructure.Common.ShaderChannelSelectBlue = value; 2722 } 2723 inline SHADER_CHANNEL_SELECT getShaderChannelSelectBlue() const { 2724 return static_cast<SHADER_CHANNEL_SELECT>(TheStructure.Common.ShaderChannelSelectBlue); 2725 } 2726 inline void setShaderChannelSelectGreen(const SHADER_CHANNEL_SELECT value) { 2727 TheStructure.Common.ShaderChannelSelectGreen = value; 2728 } 2729 inline SHADER_CHANNEL_SELECT getShaderChannelSelectGreen() const { 2730 return static_cast<SHADER_CHANNEL_SELECT>(TheStructure.Common.ShaderChannelSelectGreen); 2731 } 2732 inline void setShaderChannelSelectRed(const SHADER_CHANNEL_SELECT value) { 2733 TheStructure.Common.ShaderChannelSelectRed = value; 2734 } 2735 inline SHADER_CHANNEL_SELECT getShaderChannelSelectRed() const { 2736 return static_cast<SHADER_CHANNEL_SELECT>(TheStructure.Common.ShaderChannelSelectRed); 2737 } 2738 inline void setAlphaClearColor(const ALPHA_CLEAR_COLOR value) { 2739 TheStructure.Common.AlphaClearColor = value; 2740 } 2741 inline ALPHA_CLEAR_COLOR getAlphaClearColor() const { 2742 return static_cast<ALPHA_CLEAR_COLOR>(TheStructure.Common.AlphaClearColor); 2743 } 2744 inline void setBlueClearColor(const BLUE_CLEAR_COLOR value) { 2745 TheStructure.Common.BlueClearColor = value; 2746 } 2747 inline BLUE_CLEAR_COLOR getBlueClearColor() const { 2748 return static_cast<BLUE_CLEAR_COLOR>(TheStructure.Common.BlueClearColor); 2749 } 2750 inline void setGreenClearColor(const GREEN_CLEAR_COLOR value) { 2751 TheStructure.Common.GreenClearColor = value; 2752 } 2753 inline GREEN_CLEAR_COLOR getGreenClearColor() const { 2754 return static_cast<GREEN_CLEAR_COLOR>(TheStructure.Common.GreenClearColor); 2755 } 2756 inline void setRedClearColor(const RED_CLEAR_COLOR value) { 2757 TheStructure.Common.RedClearColor = value; 2758 } 2759 inline RED_CLEAR_COLOR getRedClearColor() const { 2760 return static_cast<RED_CLEAR_COLOR>(TheStructure.Common.RedClearColor); 2761 } 2762 inline void setSurfaceBaseAddress(const uint64_t value) { 2763 TheStructure.Common.SurfaceBaseAddress = value; 2764 } 2765 inline uint64_t getSurfaceBaseAddress() const { 2766 return (TheStructure.Common.SurfaceBaseAddress); 2767 } 2768 inline void setCubeFaceEnablePositiveZ(const bool value) { 2769 TheStructure.SurfaceTypeIsSurftype_Cube.CubeFaceEnable_PositiveZ = value; 2770 } 2771 inline bool getCubeFaceEnablePositiveZ() const { 2772 return (TheStructure.SurfaceTypeIsSurftype_Cube.CubeFaceEnable_PositiveZ); 2773 } 2774 inline void setCubeFaceEnableNegativeZ(const bool value) { 2775 TheStructure.SurfaceTypeIsSurftype_Cube.CubeFaceEnable_NegativeZ = value; 2776 } 2777 inline bool getCubeFaceEnableNegativeZ() const { 2778 return (TheStructure.SurfaceTypeIsSurftype_Cube.CubeFaceEnable_NegativeZ); 2779 } 2780 inline void setCubeFaceEnablePositiveY(const bool value) { 2781 TheStructure.SurfaceTypeIsSurftype_Cube.CubeFaceEnable_PositiveY = value; 2782 } 2783 inline bool getCubeFaceEnablePositiveY() const { 2784 return (TheStructure.SurfaceTypeIsSurftype_Cube.CubeFaceEnable_PositiveY); 2785 } 2786 inline void setCubeFaceEnableNegativeY(const bool value) { 2787 TheStructure.SurfaceTypeIsSurftype_Cube.CubeFaceEnable_NegativeY = value; 2788 } 2789 inline bool getCubeFaceEnableNegativeY() const { 2790 return (TheStructure.SurfaceTypeIsSurftype_Cube.CubeFaceEnable_NegativeY); 2791 } 2792 inline void setCubeFaceEnablePositiveX(const bool value) { 2793 TheStructure.SurfaceTypeIsSurftype_Cube.CubeFaceEnable_PositiveX = value; 2794 } 2795 inline bool getCubeFaceEnablePositiveX() const { 2796 return (TheStructure.SurfaceTypeIsSurftype_Cube.CubeFaceEnable_PositiveX); 2797 } 2798 inline void setCubeFaceEnableNegativeX(const bool value) { 2799 TheStructure.SurfaceTypeIsSurftype_Cube.CubeFaceEnable_NegativeX = value; 2800 } 2801 inline bool getCubeFaceEnableNegativeX() const { 2802 return (TheStructure.SurfaceTypeIsSurftype_Cube.CubeFaceEnable_NegativeX); 2803 } 2804 inline void setMultisamplePositionPaletteIndex(const uint32_t value) { 2805 TheStructure.SurfaceTypeIsnotSurftype_Strbuf.MultisamplePositionPaletteIndex = value; 2806 } 2807 inline uint32_t getMultisamplePositionPaletteIndex() const { 2808 return (TheStructure.SurfaceTypeIsnotSurftype_Strbuf.MultisamplePositionPaletteIndex); 2809 } 2810 inline void setNumberOfMultisamples(const NUMBER_OF_MULTISAMPLES value) { 2811 TheStructure.SurfaceTypeIsnotSurftype_Strbuf.NumberOfMultisamples = value; 2812 } 2813 inline NUMBER_OF_MULTISAMPLES getNumberOfMultisamples() const { 2814 return static_cast<NUMBER_OF_MULTISAMPLES>(TheStructure.SurfaceTypeIsnotSurftype_Strbuf.NumberOfMultisamples); 2815 } 2816 inline void setMultisampledSurfaceStorageFormat(const MULTISAMPLED_SURFACE_STORAGE_FORMAT value) { 2817 TheStructure.SurfaceTypeIsnotSurftype_Strbuf.MultisampledSurfaceStorageFormat = value; 2818 } 2819 inline MULTISAMPLED_SURFACE_STORAGE_FORMAT getMultisampledSurfaceStorageFormat() const { 2820 return static_cast<MULTISAMPLED_SURFACE_STORAGE_FORMAT>(TheStructure.SurfaceTypeIsnotSurftype_Strbuf.MultisampledSurfaceStorageFormat); 2821 } 2822 inline void setRenderTargetViewExtent(const uint32_t value) { 2823 TheStructure.SurfaceTypeIsnotSurftype_Strbuf.RenderTargetViewExtent = value - 1; 2824 } 2825 inline uint32_t getRenderTargetViewExtent() const { 2826 return (TheStructure.SurfaceTypeIsnotSurftype_Strbuf.RenderTargetViewExtent + 1); 2827 } 2828 inline void setMinimumArrayElement(const uint32_t value) { 2829 TheStructure.SurfaceTypeIsnotSurftype_Strbuf.MinimumArrayElement = value; 2830 } 2831 inline uint32_t getMinimumArrayElement() const { 2832 return (TheStructure.SurfaceTypeIsnotSurftype_Strbuf.MinimumArrayElement); 2833 } 2834 inline void setRenderTargetAndSampleUnormRotation(const RENDER_TARGET_AND_SAMPLE_UNORM_ROTATION value) { 2835 TheStructure.SurfaceTypeIsnotSurftype_Strbuf.RenderTargetAndSampleUnormRotation = value; 2836 } 2837 inline RENDER_TARGET_AND_SAMPLE_UNORM_ROTATION getRenderTargetAndSampleUnormRotation() const { 2838 return static_cast<RENDER_TARGET_AND_SAMPLE_UNORM_ROTATION>(TheStructure.SurfaceTypeIsnotSurftype_Strbuf.RenderTargetAndSampleUnormRotation); 2839 } 2840 inline void setYOffsetForUOrUvPlane(const uint32_t value) { 2841 TheStructure._SurfaceFormatIsPlanar.YOffsetForUOrUvPlane = value; 2842 } 2843 inline uint32_t getYOffsetForUOrUvPlane() const { 2844 return (TheStructure._SurfaceFormatIsPlanar.YOffsetForUOrUvPlane); 2845 } 2846 inline void setXOffsetForUOrUvPlane(const uint32_t value) { 2847 TheStructure._SurfaceFormatIsPlanar.XOffsetForUOrUvPlane = value; 2848 } 2849 inline uint32_t getXOffsetForUOrUvPlane() const { 2850 return (TheStructure._SurfaceFormatIsPlanar.XOffsetForUOrUvPlane); 2851 } 2852 inline void setSeparateUvPlaneEnable(const bool value) { 2853 TheStructure._SurfaceFormatIsPlanar.SeparateUvPlaneEnable = value; 2854 } 2855 inline bool getSeparateUvPlaneEnable() const { 2856 return (TheStructure._SurfaceFormatIsPlanar.SeparateUvPlaneEnable); 2857 } 2858 inline void setYOffsetForVPlane(const uint64_t value) { 2859 TheStructure._SurfaceFormatIsPlanar.YOffsetForVPlane = value; 2860 } 2861 inline uint64_t getYOffsetForVPlane() const { 2862 return (TheStructure._SurfaceFormatIsPlanar.YOffsetForVPlane); 2863 } 2864 inline void setXOffsetForVPlane(const uint64_t value) { 2865 TheStructure._SurfaceFormatIsPlanar.XOffsetForVPlane = value; 2866 } 2867 inline uint64_t getXOffsetForVPlane() const { 2868 return (TheStructure._SurfaceFormatIsPlanar.XOffsetForVPlane); 2869 } 2870 inline void setAuxiliarySurfaceMode(const AUXILIARY_SURFACE_MODE value) { 2871 TheStructure._SurfaceFormatIsnotPlanar.AuxiliarySurfaceMode = value; 2872 } 2873 inline AUXILIARY_SURFACE_MODE getAuxiliarySurfaceMode() const { 2874 return static_cast<AUXILIARY_SURFACE_MODE>(TheStructure._SurfaceFormatIsnotPlanar.AuxiliarySurfaceMode); 2875 } 2876 inline void setAuxiliarySurfacePitch(const uint32_t value) { 2877 TheStructure._SurfaceFormatIsnotPlanar.AuxiliarySurfacePitch = value - 1; 2878 } 2879 inline uint32_t getAuxiliarySurfacePitch() const { 2880 return (TheStructure._SurfaceFormatIsnotPlanar.AuxiliarySurfacePitch + 1); 2881 } 2882 typedef enum tagAUXILIARYSURFACEQPITCH { 2883 AUXILIARYSURFACEQPITCH_BIT_SHIFT = 0x2, 2884 AUXILIARYSURFACEQPITCH_ALIGN_SIZE = 0x4, 2885 } AUXILIARYSURFACEQPITCH; 2886 inline void setAuxiliarySurfaceQpitch(const uint32_t value) { 2887 TheStructure._SurfaceFormatIsnotPlanar.AuxiliarySurfaceQpitch = value >> AUXILIARYSURFACEQPITCH_BIT_SHIFT; 2888 } 2889 inline uint32_t getAuxiliarySurfaceQpitch() const { 2890 return (TheStructure._SurfaceFormatIsnotPlanar.AuxiliarySurfaceQpitch << AUXILIARYSURFACEQPITCH_BIT_SHIFT); 2891 } 2892 typedef enum tagAUXILIARYSURFACEBASEADDRESS { 2893 AUXILIARYSURFACEBASEADDRESS_BIT_SHIFT = 0xc, 2894 AUXILIARYSURFACEBASEADDRESS_ALIGN_SIZE = 0x1000, 2895 } AUXILIARYSURFACEBASEADDRESS; 2896 inline void setAuxiliarySurfaceBaseAddress(const uint64_t value) { 2897 TheStructure._SurfaceFormatIsnotPlanarAndMemoryCompressionEnableIs0.AuxiliarySurfaceBaseAddress = value >> AUXILIARYSURFACEBASEADDRESS_BIT_SHIFT; 2898 } 2899 inline uint64_t getAuxiliarySurfaceBaseAddress() const { 2900 return (TheStructure._SurfaceFormatIsnotPlanarAndMemoryCompressionEnableIs0.AuxiliarySurfaceBaseAddress << AUXILIARYSURFACEBASEADDRESS_BIT_SHIFT); 2901 } 2902 inline void setAuxiliaryTableIndexForMediaCompressedSurface(const uint64_t value) { 2903 TheStructure.MemoryCompressionEnableIs1.AuxiliaryTableIndexForMediaCompressedSurface = value; 2904 } 2905 inline uint64_t getAuxiliaryTableIndexForMediaCompressedSurface() const { 2906 return (TheStructure.MemoryCompressionEnableIs1.AuxiliaryTableIndexForMediaCompressedSurface); 2907 } 2908} RENDER_SURFACE_STATE; 2909STATIC_ASSERT(64 == sizeof(RENDER_SURFACE_STATE)); 2910 2911typedef struct tagSAMPLER_STATE { 2912 union tagTheStructure { 2913 struct tagCommon { 2914 uint32_t LodAlgorithm : BITFIELD_RANGE(0, 0); 2915 uint32_t TextureLodBias : BITFIELD_RANGE(1, 13); 2916 uint32_t MinModeFilter : BITFIELD_RANGE(14, 16); 2917 uint32_t MagModeFilter : BITFIELD_RANGE(17, 19); 2918 uint32_t MipModeFilter : BITFIELD_RANGE(20, 21); 2919 uint32_t BaseMipLevel : BITFIELD_RANGE(22, 26); 2920 uint32_t LodPreclampMode : BITFIELD_RANGE(27, 28); 2921 uint32_t TextureBorderColorMode : BITFIELD_RANGE(29, 29); 2922 uint32_t Reserved_30 : BITFIELD_RANGE(30, 30); 2923 uint32_t SamplerDisable : BITFIELD_RANGE(31, 31); 2924 uint32_t CubeSurfaceControlMode : BITFIELD_RANGE(0, 0); 2925 uint32_t ShadowFunction : BITFIELD_RANGE(1, 3); 2926 uint32_t ChromakeyMode : BITFIELD_RANGE(4, 4); 2927 uint32_t ChromakeyIndex : BITFIELD_RANGE(5, 6); 2928 uint32_t ChromakeyEnable : BITFIELD_RANGE(7, 7); 2929 uint32_t MaxLod : BITFIELD_RANGE(8, 19); 2930 uint32_t MinLod : BITFIELD_RANGE(20, 31); 2931 uint32_t LodClampMagnificationMode : BITFIELD_RANGE(0, 0); 2932 uint32_t Reserved_65 : BITFIELD_RANGE(1, 5); 2933 uint32_t IndirectStatePointer : BITFIELD_RANGE(6, 23); 2934 uint32_t Reserved_88 : BITFIELD_RANGE(24, 31); 2935 uint32_t TczAddressControlMode : BITFIELD_RANGE(0, 2); 2936 uint32_t TcyAddressControlMode : BITFIELD_RANGE(3, 5); 2937 uint32_t TcxAddressControlMode : BITFIELD_RANGE(6, 8); 2938 uint32_t Reserved_105 : BITFIELD_RANGE(9, 9); 2939 uint32_t Non_NormalizedCoordinateEnable : BITFIELD_RANGE(10, 10); 2940 uint32_t TrilinearFilterQuality : BITFIELD_RANGE(11, 12); 2941 uint32_t RAddressMinFilterRoundingEnable : BITFIELD_RANGE(13, 13); 2942 uint32_t RAddressMagFilterRoundingEnable : BITFIELD_RANGE(14, 14); 2943 uint32_t VAddressMinFilterRoundingEnable : BITFIELD_RANGE(15, 15); 2944 uint32_t VAddressMagFilterRoundingEnable : BITFIELD_RANGE(16, 16); 2945 uint32_t UAddressMinFilterRoundingEnable : BITFIELD_RANGE(17, 17); 2946 uint32_t UAddressMagFilterRoundingEnable : BITFIELD_RANGE(18, 18); 2947 uint32_t MaximumAnisotropy : BITFIELD_RANGE(19, 21); 2948 uint32_t Reserved_118 : BITFIELD_RANGE(22, 31); 2949 } Common; 2950 uint32_t RawData[4]; 2951 } TheStructure; 2952 typedef enum tagLOD_ALGORITHM { 2953 LOD_ALGORITHM_LEGACY = 0x0, 2954 LOD_ALGORITHM_EWA_APPROXIMATION = 0x1, 2955 } LOD_ALGORITHM; 2956 typedef enum tagMIN_MODE_FILTER { 2957 MIN_MODE_FILTER_NEAREST = 0x0, 2958 MIN_MODE_FILTER_LINEAR = 0x1, 2959 MIN_MODE_FILTER_ANISOTROPIC = 0x2, 2960 MIN_MODE_FILTER_MONO = 0x6, 2961 } MIN_MODE_FILTER; 2962 typedef enum tagMAG_MODE_FILTER { 2963 MAG_MODE_FILTER_NEAREST = 0x0, 2964 MAG_MODE_FILTER_LINEAR = 0x1, 2965 MAG_MODE_FILTER_ANISOTROPIC = 0x2, 2966 MAG_MODE_FILTER_MONO = 0x6, 2967 } MAG_MODE_FILTER; 2968 typedef enum tagMIP_MODE_FILTER { 2969 MIP_MODE_FILTER_NONE = 0x0, 2970 MIP_MODE_FILTER_NEAREST = 0x1, 2971 MIP_MODE_FILTER_LINEAR = 0x3, 2972 } MIP_MODE_FILTER; 2973 typedef enum tagLOD_PRECLAMP_MODE { 2974 LOD_PRECLAMP_MODE_NONE = 0x0, 2975 LOD_PRECLAMP_MODE_OGL = 0x2, 2976 } LOD_PRECLAMP_MODE; 2977 typedef enum tagTEXTURE_BORDER_COLOR_MODE { 2978 TEXTURE_BORDER_COLOR_MODE_DX10_OGL = 0x0, 2979 TEXTURE_BORDER_COLOR_MODE_DX9 = 0x1, 2980 } TEXTURE_BORDER_COLOR_MODE; 2981 typedef enum tagCUBE_SURFACE_CONTROL_MODE { 2982 CUBE_SURFACE_CONTROL_MODE_PROGRAMMED = 0x0, 2983 CUBE_SURFACE_CONTROL_MODE_OVERRIDE = 0x1, 2984 } CUBE_SURFACE_CONTROL_MODE; 2985 typedef enum tagSHADOW_FUNCTION { 2986 SHADOW_FUNCTION_PREFILTEROP_ALWAYS = 0x0, 2987 SHADOW_FUNCTION_PREFILTEROP_NEVER = 0x1, 2988 SHADOW_FUNCTION_PREFILTEROP_LESS = 0x2, 2989 SHADOW_FUNCTION_PREFILTEROP_EQUAL = 0x3, 2990 SHADOW_FUNCTION_PREFILTEROP_LEQUAL = 0x4, 2991 SHADOW_FUNCTION_PREFILTEROP_GREATER = 0x5, 2992 SHADOW_FUNCTION_PREFILTEROP_NOTEQUAL = 0x6, 2993 SHADOW_FUNCTION_PREFILTEROP_GEQUAL = 0x7, 2994 } SHADOW_FUNCTION; 2995 typedef enum tagCHROMAKEY_MODE { 2996 CHROMAKEY_MODE_KEYFILTER_KILL_ON_ANY_MATCH = 0x0, 2997 CHROMAKEY_MODE_KEYFILTER_REPLACE_BLACK = 0x1, 2998 } CHROMAKEY_MODE; 2999 typedef enum tagLOD_CLAMP_MAGNIFICATION_MODE { 3000 LOD_CLAMP_MAGNIFICATION_MODE_MIPNONE = 0x0, 3001 LOD_CLAMP_MAGNIFICATION_MODE_MIPFILTER = 0x1, 3002 } LOD_CLAMP_MAGNIFICATION_MODE; 3003 typedef enum tagTEXTURE_COORDINATE_MODE { 3004 TEXTURE_COORDINATE_MODE_WRAP = 0x0, 3005 TEXTURE_COORDINATE_MODE_MIRROR = 0x1, 3006 TEXTURE_COORDINATE_MODE_CLAMP = 0x2, 3007 TEXTURE_COORDINATE_MODE_CUBE = 0x3, 3008 TEXTURE_COORDINATE_MODE_CLAMP_BORDER = 0x4, 3009 TEXTURE_COORDINATE_MODE_MIRROR_ONCE = 0x5, 3010 TEXTURE_COORDINATE_MODE_HALF_BORDER = 0x6, 3011 TEXTURE_COORDINATE_MODE_MIRROR_101 = 0x7, 3012 } TEXTURE_COORDINATE_MODE; 3013 typedef enum tagTRILINEAR_FILTER_QUALITY { 3014 TRILINEAR_FILTER_QUALITY_FULL = 0x0, 3015 TRILINEAR_FILTER_QUALITY_TRIQUAL_HIGH_MAG_CLAMP_MIPFILTER = 0x1, 3016 TRILINEAR_FILTER_QUALITY_MED = 0x2, 3017 TRILINEAR_FILTER_QUALITY_LOW = 0x3, 3018 } TRILINEAR_FILTER_QUALITY; 3019 typedef enum tagMAXIMUM_ANISOTROPY { 3020 MAXIMUM_ANISOTROPY_RATIO_21 = 0x0, 3021 MAXIMUM_ANISOTROPY_RATIO_41 = 0x1, 3022 MAXIMUM_ANISOTROPY_RATIO_61 = 0x2, 3023 MAXIMUM_ANISOTROPY_RATIO_81 = 0x3, 3024 MAXIMUM_ANISOTROPY_RATIO_101 = 0x4, 3025 MAXIMUM_ANISOTROPY_RATIO_121 = 0x5, 3026 MAXIMUM_ANISOTROPY_RATIO_141 = 0x6, 3027 MAXIMUM_ANISOTROPY_RATIO_161 = 0x7, 3028 } MAXIMUM_ANISOTROPY; 3029 inline void init() { 3030 memset(&TheStructure, 0, sizeof(TheStructure)); 3031 TheStructure.Common.LodAlgorithm = LOD_ALGORITHM_LEGACY; 3032 TheStructure.Common.MinModeFilter = MIN_MODE_FILTER_NEAREST; 3033 TheStructure.Common.MagModeFilter = MAG_MODE_FILTER_NEAREST; 3034 TheStructure.Common.MipModeFilter = MIP_MODE_FILTER_NONE; 3035 TheStructure.Common.LodPreclampMode = LOD_PRECLAMP_MODE_NONE; 3036 TheStructure.Common.TextureBorderColorMode = TEXTURE_BORDER_COLOR_MODE_DX10_OGL; 3037 TheStructure.Common.CubeSurfaceControlMode = CUBE_SURFACE_CONTROL_MODE_PROGRAMMED; 3038 TheStructure.Common.ShadowFunction = SHADOW_FUNCTION_PREFILTEROP_ALWAYS; 3039 TheStructure.Common.ChromakeyMode = CHROMAKEY_MODE_KEYFILTER_KILL_ON_ANY_MATCH; 3040 TheStructure.Common.LodClampMagnificationMode = LOD_CLAMP_MAGNIFICATION_MODE_MIPNONE; 3041 TheStructure.Common.TczAddressControlMode = TEXTURE_COORDINATE_MODE_WRAP; 3042 TheStructure.Common.TcyAddressControlMode = TEXTURE_COORDINATE_MODE_WRAP; 3043 TheStructure.Common.TcxAddressControlMode = TEXTURE_COORDINATE_MODE_WRAP; 3044 TheStructure.Common.TrilinearFilterQuality = TRILINEAR_FILTER_QUALITY_FULL; 3045 TheStructure.Common.MaximumAnisotropy = MAXIMUM_ANISOTROPY_RATIO_21; 3046 } 3047 static tagSAMPLER_STATE sInit() { 3048 SAMPLER_STATE state; 3049 state.init(); 3050 return state; 3051 } 3052 inline uint32_t &getRawData(const uint32_t index) { 3053 DEBUG_BREAK_IF(index >= 4); 3054 return TheStructure.RawData[index]; 3055 } 3056 inline void setLodAlgorithm(const LOD_ALGORITHM value) { 3057 TheStructure.Common.LodAlgorithm = value; 3058 } 3059 inline LOD_ALGORITHM getLodAlgorithm() const { 3060 return static_cast<LOD_ALGORITHM>(TheStructure.Common.LodAlgorithm); 3061 } 3062 inline void setTextureLodBias(const uint32_t value) { 3063 TheStructure.Common.TextureLodBias = value; 3064 } 3065 inline uint32_t getTextureLodBias() const { 3066 return (TheStructure.Common.TextureLodBias); 3067 } 3068 inline void setMinModeFilter(const MIN_MODE_FILTER value) { 3069 TheStructure.Common.MinModeFilter = value; 3070 } 3071 inline MIN_MODE_FILTER getMinModeFilter() const { 3072 return static_cast<MIN_MODE_FILTER>(TheStructure.Common.MinModeFilter); 3073 } 3074 inline void setMagModeFilter(const MAG_MODE_FILTER value) { 3075 TheStructure.Common.MagModeFilter = value; 3076 } 3077 inline MAG_MODE_FILTER getMagModeFilter() const { 3078 return static_cast<MAG_MODE_FILTER>(TheStructure.Common.MagModeFilter); 3079 } 3080 inline void setMipModeFilter(const MIP_MODE_FILTER value) { 3081 TheStructure.Common.MipModeFilter = value; 3082 } 3083 inline MIP_MODE_FILTER getMipModeFilter() const { 3084 return static_cast<MIP_MODE_FILTER>(TheStructure.Common.MipModeFilter); 3085 } 3086 inline void setBaseMipLevel(const uint32_t value) { 3087 TheStructure.Common.BaseMipLevel = value; 3088 } 3089 inline uint32_t getBaseMipLevel() const { 3090 return (TheStructure.Common.BaseMipLevel); 3091 } 3092 inline void setLodPreclampMode(const LOD_PRECLAMP_MODE value) { 3093 TheStructure.Common.LodPreclampMode = value; 3094 } 3095 inline LOD_PRECLAMP_MODE getLodPreclampMode() const { 3096 return static_cast<LOD_PRECLAMP_MODE>(TheStructure.Common.LodPreclampMode); 3097 } 3098 inline void setTextureBorderColorMode(const TEXTURE_BORDER_COLOR_MODE value) { 3099 TheStructure.Common.TextureBorderColorMode = value; 3100 } 3101 inline TEXTURE_BORDER_COLOR_MODE getTextureBorderColorMode() const { 3102 return static_cast<TEXTURE_BORDER_COLOR_MODE>(TheStructure.Common.TextureBorderColorMode); 3103 } 3104 inline void setSamplerDisable(const bool value) { 3105 TheStructure.Common.SamplerDisable = value; 3106 } 3107 inline bool getSamplerDisable() const { 3108 return (TheStructure.Common.SamplerDisable); 3109 } 3110 inline void setCubeSurfaceControlMode(const CUBE_SURFACE_CONTROL_MODE value) { 3111 TheStructure.Common.CubeSurfaceControlMode = value; 3112 } 3113 inline CUBE_SURFACE_CONTROL_MODE getCubeSurfaceControlMode() const { 3114 return static_cast<CUBE_SURFACE_CONTROL_MODE>(TheStructure.Common.CubeSurfaceControlMode); 3115 } 3116 inline void setShadowFunction(const SHADOW_FUNCTION value) { 3117 TheStructure.Common.ShadowFunction = value; 3118 } 3119 inline SHADOW_FUNCTION getShadowFunction() const { 3120 return static_cast<SHADOW_FUNCTION>(TheStructure.Common.ShadowFunction); 3121 } 3122 inline void setChromakeyMode(const CHROMAKEY_MODE value) { 3123 TheStructure.Common.ChromakeyMode = value; 3124 } 3125 inline CHROMAKEY_MODE getChromakeyMode() const { 3126 return static_cast<CHROMAKEY_MODE>(TheStructure.Common.ChromakeyMode); 3127 } 3128 inline void setChromakeyIndex(const uint32_t value) { 3129 TheStructure.Common.ChromakeyIndex = value; 3130 } 3131 inline uint32_t getChromakeyIndex() const { 3132 return (TheStructure.Common.ChromakeyIndex); 3133 } 3134 inline void setChromakeyEnable(const bool value) { 3135 TheStructure.Common.ChromakeyEnable = value; 3136 } 3137 inline bool getChromakeyEnable() const { 3138 return (TheStructure.Common.ChromakeyEnable); 3139 } 3140 inline void setMaxLod(const uint32_t value) { 3141 TheStructure.Common.MaxLod = value; 3142 } 3143 inline uint32_t getMaxLod() const { 3144 return (TheStructure.Common.MaxLod); 3145 } 3146 inline void setMinLod(const uint32_t value) { 3147 TheStructure.Common.MinLod = value; 3148 } 3149 inline uint32_t getMinLod() const { 3150 return (TheStructure.Common.MinLod); 3151 } 3152 inline void setLodClampMagnificationMode(const LOD_CLAMP_MAGNIFICATION_MODE value) { 3153 TheStructure.Common.LodClampMagnificationMode = value; 3154 } 3155 inline LOD_CLAMP_MAGNIFICATION_MODE getLodClampMagnificationMode() const { 3156 return static_cast<LOD_CLAMP_MAGNIFICATION_MODE>(TheStructure.Common.LodClampMagnificationMode); 3157 } 3158 typedef enum tagINDIRECTSTATEPOINTER { 3159 INDIRECTSTATEPOINTER_BIT_SHIFT = 0x6, 3160 INDIRECTSTATEPOINTER_ALIGN_SIZE = 0x40, 3161 } INDIRECTSTATEPOINTER; 3162 inline uint32_t getIndirectStatePointer() const { 3163 return (uint32_t)TheStructure.Common.IndirectStatePointer << INDIRECTSTATEPOINTER_BIT_SHIFT; 3164 } 3165 inline void setIndirectStatePointer(const uint32_t indirectStatePointerValue) { 3166 TheStructure.Common.IndirectStatePointer = indirectStatePointerValue >> INDIRECTSTATEPOINTER_BIT_SHIFT; 3167 } 3168 inline void setTczAddressControlMode(const TEXTURE_COORDINATE_MODE value) { 3169 TheStructure.Common.TczAddressControlMode = value; 3170 } 3171 inline TEXTURE_COORDINATE_MODE getTczAddressControlMode() const { 3172 return static_cast<TEXTURE_COORDINATE_MODE>(TheStructure.Common.TczAddressControlMode); 3173 } 3174 inline void setTcyAddressControlMode(const TEXTURE_COORDINATE_MODE value) { 3175 TheStructure.Common.TcyAddressControlMode = value; 3176 } 3177 inline TEXTURE_COORDINATE_MODE getTcyAddressControlMode() const { 3178 return static_cast<TEXTURE_COORDINATE_MODE>(TheStructure.Common.TcyAddressControlMode); 3179 } 3180 inline void setTcxAddressControlMode(const TEXTURE_COORDINATE_MODE value) { 3181 TheStructure.Common.TcxAddressControlMode = value; 3182 } 3183 inline TEXTURE_COORDINATE_MODE getTcxAddressControlMode() const { 3184 return static_cast<TEXTURE_COORDINATE_MODE>(TheStructure.Common.TcxAddressControlMode); 3185 } 3186 inline void setNonNormalizedCoordinateEnable(const bool value) { 3187 TheStructure.Common.Non_NormalizedCoordinateEnable = value; 3188 } 3189 inline bool getNonNormalizedCoordinateEnable() const { 3190 return (TheStructure.Common.Non_NormalizedCoordinateEnable); 3191 } 3192 inline void setTrilinearFilterQuality(const TRILINEAR_FILTER_QUALITY value) { 3193 TheStructure.Common.TrilinearFilterQuality = value; 3194 } 3195 inline TRILINEAR_FILTER_QUALITY getTrilinearFilterQuality() const { 3196 return static_cast<TRILINEAR_FILTER_QUALITY>(TheStructure.Common.TrilinearFilterQuality); 3197 } 3198 inline void setRAddressMinFilterRoundingEnable(const bool value) { 3199 TheStructure.Common.RAddressMinFilterRoundingEnable = value; 3200 } 3201 inline bool getRAddressMinFilterRoundingEnable() const { 3202 return (TheStructure.Common.RAddressMinFilterRoundingEnable); 3203 } 3204 inline void setRAddressMagFilterRoundingEnable(const bool value) { 3205 TheStructure.Common.RAddressMagFilterRoundingEnable = value; 3206 } 3207 inline bool getRAddressMagFilterRoundingEnable() const { 3208 return (TheStructure.Common.RAddressMagFilterRoundingEnable); 3209 } 3210 inline void setVAddressMinFilterRoundingEnable(const bool value) { 3211 TheStructure.Common.VAddressMinFilterRoundingEnable = value; 3212 } 3213 inline bool getVAddressMinFilterRoundingEnable() const { 3214 return (TheStructure.Common.VAddressMinFilterRoundingEnable); 3215 } 3216 inline void setVAddressMagFilterRoundingEnable(const bool value) { 3217 TheStructure.Common.VAddressMagFilterRoundingEnable = value; 3218 } 3219 inline bool getVAddressMagFilterRoundingEnable() const { 3220 return (TheStructure.Common.VAddressMagFilterRoundingEnable); 3221 } 3222 inline void setUAddressMinFilterRoundingEnable(const bool value) { 3223 TheStructure.Common.UAddressMinFilterRoundingEnable = value; 3224 } 3225 inline bool getUAddressMinFilterRoundingEnable() const { 3226 return (TheStructure.Common.UAddressMinFilterRoundingEnable); 3227 } 3228 inline void setUAddressMagFilterRoundingEnable(const bool value) { 3229 TheStructure.Common.UAddressMagFilterRoundingEnable = value; 3230 } 3231 inline bool getUAddressMagFilterRoundingEnable() const { 3232 return (TheStructure.Common.UAddressMagFilterRoundingEnable); 3233 } 3234 inline void setMaximumAnisotropy(const MAXIMUM_ANISOTROPY value) { 3235 TheStructure.Common.MaximumAnisotropy = value; 3236 } 3237 inline MAXIMUM_ANISOTROPY getMaximumAnisotropy() const { 3238 return static_cast<MAXIMUM_ANISOTROPY>(TheStructure.Common.MaximumAnisotropy); 3239 } 3240} SAMPLER_STATE; 3241STATIC_ASSERT(16 == sizeof(SAMPLER_STATE)); 3242 3243typedef struct tagSTATE_BASE_ADDRESS { 3244 union tagTheStructure { 3245 struct tagCommon { 3246 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 3247 uint32_t Reserved_8 : BITFIELD_RANGE(8, 15); 3248 uint32_t _3DCommandSubOpcode : BITFIELD_RANGE(16, 23); 3249 uint32_t _3DCommandOpcode : BITFIELD_RANGE(24, 26); 3250 uint32_t CommandSubtype : BITFIELD_RANGE(27, 28); 3251 uint32_t CommandType : BITFIELD_RANGE(29, 31); 3252 uint64_t GeneralStateBaseAddressModifyEnable : BITFIELD_RANGE(0, 0); 3253 uint64_t Reserved_33 : BITFIELD_RANGE(1, 3); 3254 uint64_t GeneralStateMemoryObjectControlState_AgeForQuadlru : BITFIELD_RANGE(4, 5); 3255 uint64_t GeneralStateMemoryObjectControlState_Reserved : BITFIELD_RANGE(6, 6); 3256 uint64_t GeneralStateMemoryObjectControlState_TargetCache : BITFIELD_RANGE(7, 8); 3257 uint64_t GeneralStateMemoryObjectControlState_MemoryTypeLlcEllcCacheabilityControl : BITFIELD_RANGE(9, 10); 3258 uint64_t Reserved_43 : BITFIELD_RANGE(11, 11); 3259 uint64_t GeneralStateBaseAddress : BITFIELD_RANGE(12, 63); 3260 uint32_t Reserved_96 : BITFIELD_RANGE(0, 15); 3261 uint32_t StatelessDataPortAccessMemoryObjectControlState_AgeForQuadlru : BITFIELD_RANGE(16, 17); 3262 uint32_t StatelessDataPortAccessMemoryObjectControlState_Reserved : BITFIELD_RANGE(18, 18); 3263 uint32_t StatelessDataPortAccessMemoryObjectControlState_TargetCache : BITFIELD_RANGE(19, 20); 3264 uint32_t StatelessDataPortAccessMemoryObjectControlState_MemoryTypeLlcEllcCacheabilityControl : BITFIELD_RANGE(21, 22); 3265 uint32_t Reserved_119 : BITFIELD_RANGE(23, 31); 3266 uint64_t SurfaceStateBaseAddressModifyEnable : BITFIELD_RANGE(0, 0); 3267 uint64_t Reserved_129 : BITFIELD_RANGE(1, 3); 3268 uint64_t SurfaceStateMemoryObjectControlState_AgeForQuadlru : BITFIELD_RANGE(4, 5); 3269 uint64_t SurfaceStateMemoryObjectControlState_Reserved : BITFIELD_RANGE(6, 6); 3270 uint64_t SurfaceStateMemoryObjectControlState_TargetCache : BITFIELD_RANGE(7, 8); 3271 uint64_t SurfaceStateMemoryObjectControlState_MemoryTypeLlcEllcCacheabilityControl : BITFIELD_RANGE(9, 10); 3272 uint64_t Reserved_139 : BITFIELD_RANGE(11, 11); 3273 uint64_t SurfaceStateBaseAddress : BITFIELD_RANGE(12, 63); 3274 uint64_t DynamicStateBaseAddressModifyEnable : BITFIELD_RANGE(0, 0); 3275 uint64_t Reserved_193 : BITFIELD_RANGE(1, 3); 3276 uint64_t DynamicStateMemoryObjectControlState_AgeForQuadlru : BITFIELD_RANGE(4, 5); 3277 uint64_t DynamicStateMemoryObjectControlState_Reserved : BITFIELD_RANGE(6, 6); 3278 uint64_t DynamicStateMemoryObjectControlState_TargetCache : BITFIELD_RANGE(7, 8); 3279 uint64_t DynamicStateMemoryObjectControlState_MemoryTypeLlcEllcCacheabilityControl : BITFIELD_RANGE(9, 10); 3280 uint64_t Reserved_203 : BITFIELD_RANGE(11, 11); 3281 uint64_t DynamicStateBaseAddress : BITFIELD_RANGE(12, 63); 3282 uint64_t IndirectObjectBaseAddressModifyEnable : BITFIELD_RANGE(0, 0); 3283 uint64_t Reserved_257 : BITFIELD_RANGE(1, 3); 3284 uint64_t IndirectObjectMemoryObjectControlState_AgeForQuadlru : BITFIELD_RANGE(4, 5); 3285 uint64_t IndirectObjectMemoryObjectControlState_Reserved : BITFIELD_RANGE(6, 6); 3286 uint64_t IndirectObjectMemoryObjectControlState_TargetCache : BITFIELD_RANGE(7, 8); 3287 uint64_t IndirectObjectMemoryObjectControlState_MemoryTypeLlcEllcCacheabilityControl : BITFIELD_RANGE(9, 10); 3288 uint64_t Reserved_267 : BITFIELD_RANGE(11, 11); 3289 uint64_t IndirectObjectBaseAddress : BITFIELD_RANGE(12, 63); 3290 uint64_t InstructionBaseAddressModifyEnable : BITFIELD_RANGE(0, 0); 3291 uint64_t Reserved_321 : BITFIELD_RANGE(1, 3); 3292 uint64_t InstructionMemoryObjectControlState_AgeForQuadlru : BITFIELD_RANGE(4, 5); 3293 uint64_t InstructionMemoryObjectControlState_Reserved : BITFIELD_RANGE(6, 6); 3294 uint64_t InstructionMemoryObjectControlState_TargetCache : BITFIELD_RANGE(7, 8); 3295 uint64_t InstructionMemoryObjectControlState_MemoryTypeLlcEllcCacheabilityControl : BITFIELD_RANGE(9, 10); 3296 uint64_t Reserved_331 : BITFIELD_RANGE(11, 11); 3297 uint64_t InstructionBaseAddress : BITFIELD_RANGE(12, 63); 3298 uint32_t GeneralStateBufferSizeModifyEnable : BITFIELD_RANGE(0, 0); 3299 uint32_t Reserved_385 : BITFIELD_RANGE(1, 11); 3300 uint32_t GeneralStateBufferSize : BITFIELD_RANGE(12, 31); 3301 uint32_t DynamicStateBufferSizeModifyEnable : BITFIELD_RANGE(0, 0); 3302 uint32_t Reserved_417 : BITFIELD_RANGE(1, 11); 3303 uint32_t DynamicStateBufferSize : BITFIELD_RANGE(12, 31); 3304 uint32_t IndirectObjectBufferSizeModifyEnable : BITFIELD_RANGE(0, 0); 3305 uint32_t Reserved_449 : BITFIELD_RANGE(1, 11); 3306 uint32_t IndirectObjectBufferSize : BITFIELD_RANGE(12, 31); 3307 uint32_t InstructionBufferSizeModifyEnable : BITFIELD_RANGE(0, 0); 3308 uint32_t Reserved_481 : BITFIELD_RANGE(1, 11); 3309 uint32_t InstructionBufferSize : BITFIELD_RANGE(12, 31); 3310 } Common; 3311 uint32_t RawData[16]; 3312 } TheStructure; 3313 typedef enum tagDWORD_LENGTH { 3314 DWORD_LENGTH_DWORD_COUNT_N = 0xe, 3315 } DWORD_LENGTH; 3316 typedef enum tag_3D_COMMAND_SUB_OPCODE { 3317 _3D_COMMAND_SUB_OPCODE_STATE_BASE_ADDRESS = 0x1, 3318 } _3D_COMMAND_SUB_OPCODE; 3319 typedef enum tag_3D_COMMAND_OPCODE { 3320 _3D_COMMAND_OPCODE_GFXPIPE_NONPIPELINED = 0x1, 3321 } _3D_COMMAND_OPCODE; 3322 typedef enum tagCOMMAND_SUBTYPE { 3323 COMMAND_SUBTYPE_GFXPIPE_COMMON = 0x0, 3324 } COMMAND_SUBTYPE; 3325 typedef enum tagCOMMAND_TYPE { 3326 COMMAND_TYPE_GFXPIPE = 0x3, 3327 } COMMAND_TYPE; 3328 typedef enum tagPATCH_CONSTANTS { 3329 GENERALSTATEBASEADDRESS_BYTEOFFSET = 0x4, 3330 GENERALSTATEBASEADDRESS_INDEX = 0x1, 3331 SURFACESTATEBASEADDRESS_BYTEOFFSET = 0x10, 3332 SURFACESTATEBASEADDRESS_INDEX = 0x4, 3333 DYNAMICSTATEBASEADDRESS_BYTEOFFSET = 0x18, 3334 DYNAMICSTATEBASEADDRESS_INDEX = 0x6, 3335 INDIRECTOBJECTBASEADDRESS_BYTEOFFSET = 0x20, 3336 INDIRECTOBJECTBASEADDRESS_INDEX = 0x8, 3337 INSTRUCTIONBASEADDRESS_BYTEOFFSET = 0x28, 3338 INSTRUCTIONBASEADDRESS_INDEX = 0xa, 3339 } PATCH_CONSTANTS; 3340 inline void init() { 3341 memset(&TheStructure, 0, sizeof(TheStructure)); 3342 TheStructure.Common.DwordLength = DWORD_LENGTH_DWORD_COUNT_N; 3343 TheStructure.Common._3DCommandSubOpcode = _3D_COMMAND_SUB_OPCODE_STATE_BASE_ADDRESS; 3344 TheStructure.Common._3DCommandOpcode = _3D_COMMAND_OPCODE_GFXPIPE_NONPIPELINED; 3345 TheStructure.Common.CommandSubtype = COMMAND_SUBTYPE_GFXPIPE_COMMON; 3346 TheStructure.Common.CommandType = COMMAND_TYPE_GFXPIPE; 3347 } 3348 static tagSTATE_BASE_ADDRESS sInit() { 3349 STATE_BASE_ADDRESS state; 3350 state.init(); 3351 return state; 3352 } 3353 inline uint32_t &getRawData(const uint32_t index) { 3354 DEBUG_BREAK_IF(index >= 16); 3355 return TheStructure.RawData[index]; 3356 } 3357 inline void setGeneralStateBaseAddressModifyEnable(const bool value) { 3358 TheStructure.Common.GeneralStateBaseAddressModifyEnable = value; 3359 } 3360 inline bool getGeneralStateBaseAddressModifyEnable() const { 3361 return (TheStructure.Common.GeneralStateBaseAddressModifyEnable); 3362 } 3363 inline void setGeneralStateMemoryObjectControlStateAgeForQuadlru(const uint64_t value) { 3364 TheStructure.Common.GeneralStateMemoryObjectControlState_AgeForQuadlru = value; 3365 } 3366 inline uint64_t getGeneralStateMemoryObjectControlStateAgeForQuadlru() const { 3367 return (TheStructure.Common.GeneralStateMemoryObjectControlState_AgeForQuadlru); 3368 } 3369 inline void setGeneralStateMemoryObjectControlStateReserved(const uint64_t value) { 3370 TheStructure.Common.GeneralStateMemoryObjectControlState_Reserved = value; 3371 } 3372 inline uint64_t getGeneralStateMemoryObjectControlStateReserved() const { 3373 return (TheStructure.Common.GeneralStateMemoryObjectControlState_Reserved); 3374 } 3375 inline void setGeneralStateMemoryObjectControlStateTargetCache(const uint64_t value) { 3376 TheStructure.Common.GeneralStateMemoryObjectControlState_TargetCache = value; 3377 } 3378 inline uint64_t getGeneralStateMemoryObjectControlStateTargetCache() const { 3379 return (TheStructure.Common.GeneralStateMemoryObjectControlState_TargetCache); 3380 } 3381 inline void setGeneralStateMemoryObjectControlStateMemoryTypeLlcEllcCacheabilityControl(const uint64_t value) { 3382 TheStructure.Common.GeneralStateMemoryObjectControlState_MemoryTypeLlcEllcCacheabilityControl = value; 3383 } 3384 inline uint64_t getGeneralStateMemoryObjectControlStateMemoryTypeLlcEllcCacheabilityControl() const { 3385 return (TheStructure.Common.GeneralStateMemoryObjectControlState_MemoryTypeLlcEllcCacheabilityControl); 3386 } 3387 typedef enum tagGENERALSTATEBASEADDRESS { 3388 GENERALSTATEBASEADDRESS_BIT_SHIFT = 0xc, 3389 GENERALSTATEBASEADDRESS_ALIGN_SIZE = 0x1000, 3390 } GENERALSTATEBASEADDRESS; 3391 inline void setGeneralStateBaseAddress(const uint64_t value) { 3392 TheStructure.Common.GeneralStateBaseAddress = value >> GENERALSTATEBASEADDRESS_BIT_SHIFT; 3393 } 3394 inline uint64_t getGeneralStateBaseAddress() const { 3395 return (TheStructure.Common.GeneralStateBaseAddress << GENERALSTATEBASEADDRESS_BIT_SHIFT); 3396 } 3397 inline void setStatelessDataPortAccessMemoryObjectControlStateAgeForQuadlru(const uint32_t value) { 3398 TheStructure.Common.StatelessDataPortAccessMemoryObjectControlState_AgeForQuadlru = value; 3399 } 3400 inline uint32_t getStatelessDataPortAccessMemoryObjectControlStateAgeForQuadlru() const { 3401 return (TheStructure.Common.StatelessDataPortAccessMemoryObjectControlState_AgeForQuadlru); 3402 } 3403 inline void setStatelessDataPortAccessMemoryObjectControlStateReserved(const uint32_t value) { 3404 TheStructure.Common.StatelessDataPortAccessMemoryObjectControlState_Reserved = value; 3405 } 3406 inline uint32_t getStatelessDataPortAccessMemoryObjectControlStateReserved() const { 3407 return (TheStructure.Common.StatelessDataPortAccessMemoryObjectControlState_Reserved); 3408 } 3409 inline void setStatelessDataPortAccessMemoryObjectControlStateTargetCache(const uint32_t value) { 3410 TheStructure.Common.StatelessDataPortAccessMemoryObjectControlState_TargetCache = value; 3411 } 3412 inline uint32_t getStatelessDataPortAccessMemoryObjectControlStateTargetCache() const { 3413 return (TheStructure.Common.StatelessDataPortAccessMemoryObjectControlState_TargetCache); 3414 } 3415 inline void setStatelessDataPortAccessMemoryObjectControlStateMemoryTypeLlcEllcCacheabilityControl(const uint32_t value) { 3416 TheStructure.Common.StatelessDataPortAccessMemoryObjectControlState_MemoryTypeLlcEllcCacheabilityControl = value; 3417 } 3418 inline uint32_t getStatelessDataPortAccessMemoryObjectControlStateMemoryTypeLlcEllcCacheabilityControl() const { 3419 return (TheStructure.Common.StatelessDataPortAccessMemoryObjectControlState_MemoryTypeLlcEllcCacheabilityControl); 3420 } 3421 inline void setStatelessDataPortAccessMemoryObjectControlState(const uint32_t value) { 3422 TheStructure.Common.StatelessDataPortAccessMemoryObjectControlState_AgeForQuadlru = value; 3423 TheStructure.Common.StatelessDataPortAccessMemoryObjectControlState_Reserved = (value >> 2); 3424 TheStructure.Common.StatelessDataPortAccessMemoryObjectControlState_TargetCache = (value >> 3); 3425 TheStructure.Common.StatelessDataPortAccessMemoryObjectControlState_MemoryTypeLlcEllcCacheabilityControl = (value >> 5); 3426 } 3427 inline uint32_t getStatelessDataPortAccessMemoryObjectControlState() const { 3428 int32_t mocs = TheStructure.Common.StatelessDataPortAccessMemoryObjectControlState_AgeForQuadlru; 3429 mocs |= (TheStructure.Common.StatelessDataPortAccessMemoryObjectControlState_Reserved << 2); 3430 mocs |= (TheStructure.Common.StatelessDataPortAccessMemoryObjectControlState_TargetCache << 3); 3431 mocs |= (TheStructure.Common.StatelessDataPortAccessMemoryObjectControlState_MemoryTypeLlcEllcCacheabilityControl << 5); 3432 return (mocs); 3433 } 3434 inline void setSurfaceStateBaseAddressModifyEnable(const bool value) { 3435 TheStructure.Common.SurfaceStateBaseAddressModifyEnable = value; 3436 } 3437 inline bool getSurfaceStateBaseAddressModifyEnable() const { 3438 return (TheStructure.Common.SurfaceStateBaseAddressModifyEnable); 3439 } 3440 inline void setSurfaceStateMemoryObjectControlStateAgeForQuadlru(const uint64_t value) { 3441 TheStructure.Common.SurfaceStateMemoryObjectControlState_AgeForQuadlru = value; 3442 } 3443 inline uint64_t getSurfaceStateMemoryObjectControlStateAgeForQuadlru() const { 3444 return (TheStructure.Common.SurfaceStateMemoryObjectControlState_AgeForQuadlru); 3445 } 3446 inline void setSurfaceStateMemoryObjectControlStateReserved(const uint64_t value) { 3447 TheStructure.Common.SurfaceStateMemoryObjectControlState_Reserved = value; 3448 } 3449 inline uint64_t getSurfaceStateMemoryObjectControlStateReserved() const { 3450 return (TheStructure.Common.SurfaceStateMemoryObjectControlState_Reserved); 3451 } 3452 inline void setSurfaceStateMemoryObjectControlStateTargetCache(const uint64_t value) { 3453 TheStructure.Common.SurfaceStateMemoryObjectControlState_TargetCache = value; 3454 } 3455 inline uint64_t getSurfaceStateMemoryObjectControlStateTargetCache() const { 3456 return (TheStructure.Common.SurfaceStateMemoryObjectControlState_TargetCache); 3457 } 3458 inline void setSurfaceStateMemoryObjectControlStateMemoryTypeLlcEllcCacheabilityControl(const uint64_t value) { 3459 TheStructure.Common.SurfaceStateMemoryObjectControlState_MemoryTypeLlcEllcCacheabilityControl = value; 3460 } 3461 inline uint64_t getSurfaceStateMemoryObjectControlStateMemoryTypeLlcEllcCacheabilityControl() const { 3462 return (TheStructure.Common.SurfaceStateMemoryObjectControlState_MemoryTypeLlcEllcCacheabilityControl); 3463 } 3464 typedef enum tagSURFACESTATEBASEADDRESS { 3465 SURFACESTATEBASEADDRESS_BIT_SHIFT = 0xc, 3466 SURFACESTATEBASEADDRESS_ALIGN_SIZE = 0x1000, 3467 } SURFACESTATEBASEADDRESS; 3468 inline void setSurfaceStateBaseAddress(const uint64_t value) { 3469 TheStructure.Common.SurfaceStateBaseAddress = value >> SURFACESTATEBASEADDRESS_BIT_SHIFT; 3470 } 3471 inline uint64_t getSurfaceStateBaseAddress() const { 3472 return (TheStructure.Common.SurfaceStateBaseAddress << SURFACESTATEBASEADDRESS_BIT_SHIFT); 3473 } 3474 inline void setDynamicStateBaseAddressModifyEnable(const bool value) { 3475 TheStructure.Common.DynamicStateBaseAddressModifyEnable = value; 3476 } 3477 inline bool getDynamicStateBaseAddressModifyEnable() const { 3478 return (TheStructure.Common.DynamicStateBaseAddressModifyEnable); 3479 } 3480 inline void setDynamicStateMemoryObjectControlStateAgeForQuadlru(const uint64_t value) { 3481 TheStructure.Common.DynamicStateMemoryObjectControlState_AgeForQuadlru = value; 3482 } 3483 inline uint64_t getDynamicStateMemoryObjectControlStateAgeForQuadlru() const { 3484 return (TheStructure.Common.DynamicStateMemoryObjectControlState_AgeForQuadlru); 3485 } 3486 inline void setDynamicStateMemoryObjectControlStateReserved(const uint64_t value) { 3487 TheStructure.Common.DynamicStateMemoryObjectControlState_Reserved = value; 3488 } 3489 inline uint64_t getDynamicStateMemoryObjectControlStateReserved() const { 3490 return (TheStructure.Common.DynamicStateMemoryObjectControlState_Reserved); 3491 } 3492 inline void setDynamicStateMemoryObjectControlStateTargetCache(const uint64_t value) { 3493 TheStructure.Common.DynamicStateMemoryObjectControlState_TargetCache = value; 3494 } 3495 inline uint64_t getDynamicStateMemoryObjectControlStateTargetCache() const { 3496 return (TheStructure.Common.DynamicStateMemoryObjectControlState_TargetCache); 3497 } 3498 inline void setDynamicStateMemoryObjectControlStateMemoryTypeLlcEllcCacheabilityControl(const uint64_t value) { 3499 TheStructure.Common.DynamicStateMemoryObjectControlState_MemoryTypeLlcEllcCacheabilityControl = value; 3500 } 3501 inline uint64_t getDynamicStateMemoryObjectControlStateMemoryTypeLlcEllcCacheabilityControl() const { 3502 return (TheStructure.Common.DynamicStateMemoryObjectControlState_MemoryTypeLlcEllcCacheabilityControl); 3503 } 3504 typedef enum tagDYNAMICSTATEBASEADDRESS { 3505 DYNAMICSTATEBASEADDRESS_BIT_SHIFT = 0xc, 3506 DYNAMICSTATEBASEADDRESS_ALIGN_SIZE = 0x1000, 3507 } DYNAMICSTATEBASEADDRESS; 3508 inline void setDynamicStateBaseAddress(const uint64_t value) { 3509 TheStructure.Common.DynamicStateBaseAddress = value >> DYNAMICSTATEBASEADDRESS_BIT_SHIFT; 3510 } 3511 inline uint64_t getDynamicStateBaseAddress() const { 3512 return (TheStructure.Common.DynamicStateBaseAddress << DYNAMICSTATEBASEADDRESS_BIT_SHIFT); 3513 } 3514 inline void setIndirectObjectBaseAddressModifyEnable(const bool value) { 3515 TheStructure.Common.IndirectObjectBaseAddressModifyEnable = value; 3516 } 3517 inline bool getIndirectObjectBaseAddressModifyEnable() const { 3518 return (TheStructure.Common.IndirectObjectBaseAddressModifyEnable); 3519 } 3520 inline void setIndirectObjectMemoryObjectControlStateAgeForQuadlru(const uint64_t value) { 3521 TheStructure.Common.IndirectObjectMemoryObjectControlState_AgeForQuadlru = value; 3522 } 3523 inline uint64_t getIndirectObjectMemoryObjectControlStateAgeForQuadlru() const { 3524 return (TheStructure.Common.IndirectObjectMemoryObjectControlState_AgeForQuadlru); 3525 } 3526 inline void setIndirectObjectMemoryObjectControlStateReserved(const uint64_t value) { 3527 TheStructure.Common.IndirectObjectMemoryObjectControlState_Reserved = value; 3528 } 3529 inline uint64_t getIndirectObjectMemoryObjectControlStateReserved() const { 3530 return (TheStructure.Common.IndirectObjectMemoryObjectControlState_Reserved); 3531 } 3532 inline void setIndirectObjectMemoryObjectControlStateTargetCache(const uint64_t value) { 3533 TheStructure.Common.IndirectObjectMemoryObjectControlState_TargetCache = value; 3534 } 3535 inline uint64_t getIndirectObjectMemoryObjectControlStateTargetCache() const { 3536 return (TheStructure.Common.IndirectObjectMemoryObjectControlState_TargetCache); 3537 } 3538 inline void setIndirectObjectMemoryObjectControlStateMemoryTypeLlcEllcCacheabilityControl(const uint64_t value) { 3539 TheStructure.Common.IndirectObjectMemoryObjectControlState_MemoryTypeLlcEllcCacheabilityControl = value; 3540 } 3541 inline uint64_t getIndirectObjectMemoryObjectControlStateMemoryTypeLlcEllcCacheabilityControl() const { 3542 return (TheStructure.Common.IndirectObjectMemoryObjectControlState_MemoryTypeLlcEllcCacheabilityControl); 3543 } 3544 typedef enum tagINDIRECTOBJECTBASEADDRESS { 3545 INDIRECTOBJECTBASEADDRESS_BIT_SHIFT = 0xc, 3546 INDIRECTOBJECTBASEADDRESS_ALIGN_SIZE = 0x1000, 3547 } INDIRECTOBJECTBASEADDRESS; 3548 inline void setIndirectObjectBaseAddress(const uint64_t value) { 3549 TheStructure.Common.IndirectObjectBaseAddress = value >> INDIRECTOBJECTBASEADDRESS_BIT_SHIFT; 3550 } 3551 inline uint64_t getIndirectObjectBaseAddress() const { 3552 return (TheStructure.Common.IndirectObjectBaseAddress << INDIRECTOBJECTBASEADDRESS_BIT_SHIFT); 3553 } 3554 inline void setInstructionBaseAddressModifyEnable(const bool value) { 3555 TheStructure.Common.InstructionBaseAddressModifyEnable = value; 3556 } 3557 inline bool getInstructionBaseAddressModifyEnable() const { 3558 return (TheStructure.Common.InstructionBaseAddressModifyEnable); 3559 } 3560 inline void setInstructionMemoryObjectControlStateAgeForQuadlru(const uint64_t value) { 3561 TheStructure.Common.InstructionMemoryObjectControlState_AgeForQuadlru = value; 3562 } 3563 inline uint64_t getInstructionMemoryObjectControlStateAgeForQuadlru() const { 3564 return (TheStructure.Common.InstructionMemoryObjectControlState_AgeForQuadlru); 3565 } 3566 inline void setInstructionMemoryObjectControlStateReserved(const uint64_t value) { 3567 TheStructure.Common.InstructionMemoryObjectControlState_Reserved = value; 3568 } 3569 inline uint64_t getInstructionMemoryObjectControlStateReserved() const { 3570 return (TheStructure.Common.InstructionMemoryObjectControlState_Reserved); 3571 } 3572 inline void setInstructionMemoryObjectControlStateTargetCache(const uint64_t value) { 3573 TheStructure.Common.InstructionMemoryObjectControlState_TargetCache = value; 3574 } 3575 inline uint64_t getInstructionMemoryObjectControlStateTargetCache() const { 3576 return (TheStructure.Common.InstructionMemoryObjectControlState_TargetCache); 3577 } 3578 inline void setInstructionMemoryObjectControlStateMemoryTypeLlcEllcCacheabilityControl(const uint64_t value) { 3579 TheStructure.Common.InstructionMemoryObjectControlState_MemoryTypeLlcEllcCacheabilityControl = value; 3580 } 3581 inline uint64_t getInstructionMemoryObjectControlStateMemoryTypeLlcEllcCacheabilityControl() const { 3582 return (TheStructure.Common.InstructionMemoryObjectControlState_MemoryTypeLlcEllcCacheabilityControl); 3583 } 3584 typedef enum tagINSTRUCTIONBASEADDRESS { 3585 INSTRUCTIONBASEADDRESS_BIT_SHIFT = 0xc, 3586 INSTRUCTIONBASEADDRESS_ALIGN_SIZE = 0x1000, 3587 } INSTRUCTIONBASEADDRESS; 3588 inline void setInstructionBaseAddress(const uint64_t value) { 3589 TheStructure.Common.InstructionBaseAddress = value >> INSTRUCTIONBASEADDRESS_BIT_SHIFT; 3590 } 3591 inline uint64_t getInstructionBaseAddress() const { 3592 return (TheStructure.Common.InstructionBaseAddress << INSTRUCTIONBASEADDRESS_BIT_SHIFT); 3593 } 3594 inline void setGeneralStateBufferSizeModifyEnable(const bool value) { 3595 TheStructure.Common.GeneralStateBufferSizeModifyEnable = value; 3596 } 3597 inline bool getGeneralStateBufferSizeModifyEnable() const { 3598 return (TheStructure.Common.GeneralStateBufferSizeModifyEnable); 3599 } 3600 inline void setGeneralStateBufferSize(const uint32_t value) { 3601 TheStructure.Common.GeneralStateBufferSize = value; 3602 } 3603 inline uint32_t getGeneralStateBufferSize() const { 3604 return (TheStructure.Common.GeneralStateBufferSize); 3605 } 3606 inline void setDynamicStateBufferSizeModifyEnable(const bool value) { 3607 TheStructure.Common.DynamicStateBufferSizeModifyEnable = value; 3608 } 3609 inline bool getDynamicStateBufferSizeModifyEnable() const { 3610 return (TheStructure.Common.DynamicStateBufferSizeModifyEnable); 3611 } 3612 inline void setDynamicStateBufferSize(const uint32_t value) { 3613 TheStructure.Common.DynamicStateBufferSize = value; 3614 } 3615 inline uint32_t getDynamicStateBufferSize() const { 3616 return (TheStructure.Common.DynamicStateBufferSize); 3617 } 3618 inline void setIndirectObjectBufferSizeModifyEnable(const bool value) { 3619 TheStructure.Common.IndirectObjectBufferSizeModifyEnable = value; 3620 } 3621 inline bool getIndirectObjectBufferSizeModifyEnable() const { 3622 return (TheStructure.Common.IndirectObjectBufferSizeModifyEnable); 3623 } 3624 inline void setIndirectObjectBufferSize(const uint32_t value) { 3625 TheStructure.Common.IndirectObjectBufferSize = value; 3626 } 3627 inline uint32_t getIndirectObjectBufferSize() const { 3628 return (TheStructure.Common.IndirectObjectBufferSize); 3629 } 3630 inline void setInstructionBufferSizeModifyEnable(const bool value) { 3631 TheStructure.Common.InstructionBufferSizeModifyEnable = value; 3632 } 3633 inline bool getInstructionBufferSizeModifyEnable() const { 3634 return (TheStructure.Common.InstructionBufferSizeModifyEnable); 3635 } 3636 inline void setInstructionBufferSize(const uint32_t value) { 3637 TheStructure.Common.InstructionBufferSize = value; 3638 } 3639 inline uint32_t getInstructionBufferSize() const { 3640 return (TheStructure.Common.InstructionBufferSize); 3641 } 3642 inline void setInstructionMemoryObjectControlState(const uint32_t value) { 3643 TheStructure.Common.InstructionMemoryObjectControlState_AgeForQuadlru = value; 3644 TheStructure.Common.InstructionMemoryObjectControlState_Reserved = (value >> 2); 3645 TheStructure.Common.InstructionMemoryObjectControlState_TargetCache = (value >> 3); 3646 TheStructure.Common.InstructionMemoryObjectControlState_MemoryTypeLlcEllcCacheabilityControl = (value >> 5); 3647 } 3648 inline uint32_t getInstructionMemoryObjectControlState() const { 3649 int32_t mocs = TheStructure.Common.InstructionMemoryObjectControlState_AgeForQuadlru; 3650 mocs |= (TheStructure.Common.InstructionMemoryObjectControlState_Reserved << 2); 3651 mocs |= (TheStructure.Common.InstructionMemoryObjectControlState_TargetCache << 3); 3652 mocs |= (TheStructure.Common.InstructionMemoryObjectControlState_MemoryTypeLlcEllcCacheabilityControl << 5); 3653 return (mocs); 3654 } 3655} STATE_BASE_ADDRESS; 3656STATIC_ASSERT(64 == sizeof(STATE_BASE_ADDRESS)); 3657 3658typedef struct tagMI_REPORT_PERF_COUNT { 3659 union tagTheStructure { 3660 struct tagCommon { 3661 uint32_t DwordLength : BITFIELD_RANGE(0, 5); 3662 uint32_t Reserved_6 : BITFIELD_RANGE(6, 22); 3663 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 3664 uint32_t CommandType : BITFIELD_RANGE(29, 31); 3665 uint64_t UseGlobalGtt : BITFIELD_RANGE(0, 0); 3666 uint64_t Reserved_33 : BITFIELD_RANGE(1, 3); 3667 uint64_t CoreModeEnable : BITFIELD_RANGE(4, 4); 3668 uint64_t Reserved_37 : BITFIELD_RANGE(5, 5); 3669 uint64_t MemoryAddress : BITFIELD_RANGE(6, 63); 3670 uint32_t ReportId; 3671 } Common; 3672 uint32_t RawData[4]; 3673 } TheStructure; 3674 typedef enum tagDWORD_LENGTH { 3675 DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x2, 3676 } DWORD_LENGTH; 3677 typedef enum tagMI_COMMAND_OPCODE { 3678 MI_COMMAND_OPCODE_MI_REPORT_PERF_COUNT = 0x28, 3679 } MI_COMMAND_OPCODE; 3680 typedef enum tagCOMMAND_TYPE { 3681 COMMAND_TYPE_MI_COMMAND = 0x0, 3682 } COMMAND_TYPE; 3683 typedef enum tagPATCH_CONSTANTS { 3684 MEMORYADDRESS_BYTEOFFSET = 0x4, 3685 MEMORYADDRESS_INDEX = 0x1, 3686 } PATCH_CONSTANTS; 3687 inline void init() { 3688 memset(&TheStructure, 0, sizeof(TheStructure)); 3689 TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1; 3690 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_REPORT_PERF_COUNT; 3691 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 3692 } 3693 static tagMI_REPORT_PERF_COUNT sInit() { 3694 MI_REPORT_PERF_COUNT state; 3695 state.init(); 3696 return state; 3697 } 3698 inline uint32_t &getRawData(const uint32_t index) { 3699 DEBUG_BREAK_IF(index >= 4); 3700 return TheStructure.RawData[index]; 3701 } 3702 inline void setUseGlobalGtt(const bool value) { 3703 TheStructure.Common.UseGlobalGtt = value; 3704 } 3705 inline bool getUseGlobalGtt() const { 3706 return (TheStructure.Common.UseGlobalGtt); 3707 } 3708 inline void setCoreModeEnable(const uint64_t value) { 3709 TheStructure.Common.CoreModeEnable = value; 3710 } 3711 inline uint64_t getCoreModeEnable() const { 3712 return (TheStructure.Common.CoreModeEnable); 3713 } 3714 typedef enum tagMEMORYADDRESS { 3715 MEMORYADDRESS_BIT_SHIFT = 0x6, 3716 MEMORYADDRESS_ALIGN_SIZE = 0x40, 3717 } MEMORYADDRESS; 3718 inline void setMemoryAddress(const uint64_t value) { 3719 TheStructure.Common.MemoryAddress = value >> MEMORYADDRESS_BIT_SHIFT; 3720 } 3721 inline uint64_t getMemoryAddress() const { 3722 return (TheStructure.Common.MemoryAddress << MEMORYADDRESS_BIT_SHIFT); 3723 } 3724 inline void setReportId(const uint32_t value) { 3725 TheStructure.Common.ReportId = value; 3726 } 3727 inline uint32_t getReportId() const { 3728 return (TheStructure.Common.ReportId); 3729 } 3730} MI_REPORT_PERF_COUNT; 3731STATIC_ASSERT(16 == sizeof(MI_REPORT_PERF_COUNT)); 3732 3733struct MI_USER_INTERRUPT { 3734 union tagTheStructure { 3735 struct tagCommon { 3736 uint32_t Reserved_0 : BITFIELD_RANGE(0, 22); 3737 uint32_t MICommandOpcode : BITFIELD_RANGE(23, 28); 3738 uint32_t CommandType : BITFIELD_RANGE(29, 31); 3739 } Common; 3740 uint32_t RawData[1]; 3741 } TheStructure; 3742 enum MI_COMMAND_OPCODE { 3743 MI_COMMAND_OPCODE_MI_USER_INTERRUPT = 2, 3744 }; 3745 enum COMMAND_TYPE { 3746 COMMAND_TYPE_MI_COMMAND = 0, 3747 }; 3748 inline void init() { 3749 memset(&TheStructure, 0, sizeof(TheStructure)); 3750 TheStructure.Common.MICommandOpcode = MI_COMMAND_OPCODE_MI_USER_INTERRUPT; 3751 } 3752 static MI_USER_INTERRUPT sInit() { 3753 MI_USER_INTERRUPT state; 3754 state.init(); 3755 return state; 3756 } 3757 inline uint32_t &getRawData(const uint32_t index) { 3758 return TheStructure.RawData[index]; 3759 } 3760}; 3761STATIC_ASSERT(4 == sizeof(MI_USER_INTERRUPT)); 3762 3763typedef struct tagMI_FLUSH_DW { 3764 union tagTheStructure { 3765 struct tagCommon { 3766 // DWORD 0 3767 uint32_t DwordLength : BITFIELD_RANGE(0, 5); 3768 uint32_t Reserved_6 : BITFIELD_RANGE(6, 7); 3769 uint32_t NotifyEnable : BITFIELD_RANGE(8, 8); 3770 uint32_t Reserved_9 : BITFIELD_RANGE(9, 9); 3771 uint32_t Reserved_10 : BITFIELD_RANGE(10, 13); 3772 uint32_t PostSyncOperation : BITFIELD_RANGE(14, 15); 3773 uint32_t Reserved_16 : BITFIELD_RANGE(16, 16); 3774 uint32_t Reserved_17 : BITFIELD_RANGE(17, 17); 3775 uint32_t TlbInvalidate : BITFIELD_RANGE(18, 18); 3776 uint32_t Reserved_19 : BITFIELD_RANGE(19, 20); 3777 uint32_t StoreDataIndex : BITFIELD_RANGE(21, 21); 3778 uint32_t Reserved_22 : BITFIELD_RANGE(22, 22); 3779 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 3780 uint32_t CommandType : BITFIELD_RANGE(29, 31); 3781 // DWORD 1-2 3782 uint64_t Reserved_32 : BITFIELD_RANGE(0, 1); 3783 uint64_t DestinationAddressType : BITFIELD_RANGE(2, 2); 3784 uint64_t DestinationAddress : BITFIELD_RANGE(3, 47); 3785 uint64_t Reserved_80 : BITFIELD_RANGE(48, 63); 3786 // DWORD 3-4 3787 uint64_t ImmediateData; 3788 } Common; 3789 uint32_t RawData[5]; 3790 } TheStructure; 3791 typedef enum tagDWORD_LENGTH { 3792 DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x3, 3793 } DWORD_LENGTH; 3794 typedef enum tagPOST_SYNC_OPERATION { 3795 POST_SYNC_OPERATION_NO_WRITE = 0x0, 3796 POST_SYNC_OPERATION_WRITE_IMMEDIATE_DATA_QWORD = 0x1, 3797 POST_SYNC_OPERATION_WRITE_TIMESTAMP_REGISTER = 0x3, 3798 } POST_SYNC_OPERATION; 3799 typedef enum tagMI_COMMAND_OPCODE { 3800 MI_COMMAND_OPCODE_MI_FLUSH_DW = 0x26, 3801 } MI_COMMAND_OPCODE; 3802 typedef enum tagCOMMAND_TYPE { 3803 COMMAND_TYPE_MI_COMMAND = 0x0, 3804 } COMMAND_TYPE; 3805 typedef enum tagDESTINATION_ADDRESS_TYPE { 3806 DESTINATION_ADDRESS_TYPE_PPGTT = 0x0, 3807 DESTINATION_ADDRESS_TYPE_GGTT = 0x1, 3808 } DESTINATION_ADDRESS_TYPE; 3809 inline void init() { 3810 memset(&TheStructure, 0, sizeof(TheStructure)); 3811 TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1; 3812 TheStructure.Common.PostSyncOperation = POST_SYNC_OPERATION_NO_WRITE; 3813 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_FLUSH_DW; 3814 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 3815 TheStructure.Common.DestinationAddressType = DESTINATION_ADDRESS_TYPE_PPGTT; 3816 } 3817 static tagMI_FLUSH_DW sInit() { 3818 MI_FLUSH_DW state; 3819 state.init(); 3820 return state; 3821 } 3822 inline uint32_t &getRawData(const uint32_t index) { 3823 UNRECOVERABLE_IF(index >= 5); 3824 return TheStructure.RawData[index]; 3825 } 3826 inline void setNotifyEnable(const bool value) { 3827 TheStructure.Common.NotifyEnable = value; 3828 } 3829 inline bool getNotifyEnable() const { 3830 return TheStructure.Common.NotifyEnable; 3831 } 3832 inline void setPostSyncOperation(const POST_SYNC_OPERATION value) { 3833 TheStructure.Common.PostSyncOperation = value; 3834 } 3835 inline POST_SYNC_OPERATION getPostSyncOperation() const { 3836 return static_cast<POST_SYNC_OPERATION>(TheStructure.Common.PostSyncOperation); 3837 } 3838 inline void setTlbInvalidate(const bool value) { 3839 TheStructure.Common.TlbInvalidate = value; 3840 } 3841 inline bool getTlbInvalidate() const { 3842 return TheStructure.Common.TlbInvalidate; 3843 } 3844 inline void setStoreDataIndex(const bool value) { 3845 TheStructure.Common.StoreDataIndex = value; 3846 } 3847 inline bool getStoreDataIndex() const { 3848 return TheStructure.Common.StoreDataIndex; 3849 } 3850 inline void setDestinationAddressType(const DESTINATION_ADDRESS_TYPE value) { 3851 TheStructure.Common.DestinationAddressType = value; 3852 } 3853 inline DESTINATION_ADDRESS_TYPE getDestinationAddressType() const { 3854 return static_cast<DESTINATION_ADDRESS_TYPE>(TheStructure.Common.DestinationAddressType); 3855 } 3856 typedef enum tagDESTINATIONADDRESS { 3857 DESTINATIONADDRESS_BIT_SHIFT = 0x3, 3858 DESTINATIONADDRESS_ALIGN_SIZE = 0x8, 3859 } DESTINATIONADDRESS; 3860 inline void setDestinationAddress(const uint64_t value) { 3861 UNRECOVERABLE_IF(value > 0xfffffffffff8L); 3862 TheStructure.Common.DestinationAddress = value >> DESTINATIONADDRESS_BIT_SHIFT; 3863 } 3864 inline uint64_t getDestinationAddress() const { 3865 return TheStructure.Common.DestinationAddress << DESTINATIONADDRESS_BIT_SHIFT; 3866 } 3867 inline void setImmediateData(const uint64_t value) { 3868 TheStructure.Common.ImmediateData = value; 3869 } 3870 inline uint64_t getImmediateData() const { 3871 return TheStructure.Common.ImmediateData; 3872 } 3873} MI_FLUSH_DW; 3874STATIC_ASSERT(20 == sizeof(MI_FLUSH_DW)); 3875 3876typedef struct tagXY_SRC_COPY_BLT { 3877 union tagTheStructure { 3878 struct tagCommon { 3879 // DWORD 0 3880 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 3881 uint32_t Reserved_8 : BITFIELD_RANGE(8, 10); 3882 uint32_t DestTilingEnable : BITFIELD_RANGE(11, 11); 3883 uint32_t Reserved_12 : BITFIELD_RANGE(12, 14); 3884 uint32_t SrcTilingEnable : BITFIELD_RANGE(15, 15); 3885 uint32_t Reserved_16 : BITFIELD_RANGE(16, 19); 3886 uint32_t _32BppByteMask : BITFIELD_RANGE(20, 21); 3887 uint32_t InstructionTarget_Opcode : BITFIELD_RANGE(22, 28); 3888 uint32_t Client : BITFIELD_RANGE(29, 31); 3889 // DWORD 1 3890 uint32_t DestinationPitch : BITFIELD_RANGE(0, 15); 3891 uint32_t RasterOperation : BITFIELD_RANGE(16, 23); 3892 uint32_t ColorDepth : BITFIELD_RANGE(24, 25); 3893 uint32_t Reserved_58 : BITFIELD_RANGE(26, 29); 3894 uint32_t ClippingEnabled : BITFIELD_RANGE(30, 30); 3895 uint32_t Reserved_63 : BITFIELD_RANGE(31, 31); 3896 // DWORD 2 3897 uint32_t DestinationX1Coordinate_Left : BITFIELD_RANGE(0, 15); 3898 uint32_t DestinationY1Coordinate_Top : BITFIELD_RANGE(16, 31); 3899 // DWORD 3 3900 uint32_t DestinationX2Coordinate_Right : BITFIELD_RANGE(0, 15); 3901 uint32_t DestinationY2Coordinate_Bottom : BITFIELD_RANGE(16, 31); 3902 // DWORD 4-5 3903 uint64_t DestinationBaseAddress; 3904 // DWORD 6 3905 uint32_t SourceX1Coordinate_Left : BITFIELD_RANGE(0, 15); 3906 uint32_t SourceY1Coordinate_Top : BITFIELD_RANGE(16, 31); 3907 // DWORD 7 3908 uint32_t SourcePitch : BITFIELD_RANGE(0, 15); 3909 uint32_t Reserved_240 : BITFIELD_RANGE(16, 31); 3910 // DWORD 8-9 3911 uint64_t SourceBaseAddress; 3912 } Common; 3913 uint32_t RawData[10]; 3914 } TheStructure; 3915 typedef enum tagDEST_TILING_ENABLE { 3916 DEST_TILING_ENABLE_TILING_DISABLED_LINEAR_BLIT = 0x0, 3917 DEST_TILING_ENABLE_TILING_ENABLED = 0x1, 3918 } DEST_TILING_ENABLE; 3919 typedef enum tagSRC_TILING_ENABLE { 3920 SRC_TILING_ENABLE_TILING_DISABLED_LINEAR = 0x0, 3921 SRC_TILING_ENABLE_TILING_ENABLED = 0x1, 3922 } SRC_TILING_ENABLE; 3923 typedef enum tag_32BPP_BYTE_MASK { 3924 _32BPP_BYTE_MASK_WRITE_RGB_CHANNEL = 0x1, 3925 _32BPP_BYTE_MASK_WRITE_ALPHA_CHANNEL = 0x2, 3926 } _32BPP_BYTE_MASK; 3927 typedef enum tagCLIENT { 3928 CLIENT_2D_PROCESSOR = 0x2, 3929 } CLIENT; 3930 typedef enum tagCOLOR_DEPTH { 3931 COLOR_DEPTH_8_BIT_COLOR = 0x0, 3932 COLOR_DEPTH_16_BIT_COLOR565 = 0x1, 3933 COLOR_DEPTH_16_BIT_COLOR1555 = 0x2, 3934 COLOR_DEPTH_32_BIT_COLOR = 0x3, 3935 } COLOR_DEPTH; 3936 typedef enum tagCLIPPING_ENABLED { 3937 CLIPPING_ENABLED_DISABLED = 0x0, 3938 CLIPPING_ENABLED_ENABLED = 0x1, 3939 } CLIPPING_ENABLED; 3940 typedef enum tagINSTRUCTIONTARGET_OPCODE { 3941 INSTRUCTIONTARGET_OPCODE_OPCODE = 0x53, 3942 } INSTRUCTIONTARGET_OPCODE; 3943 typedef enum tagDWORD_LENGTH { 3944 DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x8, 3945 } DWORD_LENGTH; 3946 inline void init() { 3947 memset(&TheStructure, 0, sizeof(TheStructure)); 3948 TheStructure.Common.DestTilingEnable = DEST_TILING_ENABLE_TILING_DISABLED_LINEAR_BLIT; 3949 TheStructure.Common.SrcTilingEnable = SRC_TILING_ENABLE_TILING_DISABLED_LINEAR; 3950 TheStructure.Common.Client = CLIENT_2D_PROCESSOR; 3951 TheStructure.Common.ColorDepth = COLOR_DEPTH_8_BIT_COLOR; 3952 TheStructure.Common.ClippingEnabled = CLIPPING_ENABLED_DISABLED; 3953 TheStructure.Common.InstructionTarget_Opcode = INSTRUCTIONTARGET_OPCODE_OPCODE; 3954 TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1; 3955 TheStructure.Common.RasterOperation = 0xCC; 3956 } 3957 static tagXY_SRC_COPY_BLT sInit() { 3958 XY_SRC_COPY_BLT state; 3959 state.init(); 3960 return state; 3961 } 3962 inline uint32_t &getRawData(const uint32_t index) { 3963 UNRECOVERABLE_IF(index >= 10); 3964 return TheStructure.RawData[index]; 3965 } 3966 inline void setDestTilingEnable(const DEST_TILING_ENABLE value) { 3967 TheStructure.Common.DestTilingEnable = value; 3968 } 3969 inline DEST_TILING_ENABLE getDestTilingEnable() const { 3970 return static_cast<DEST_TILING_ENABLE>(TheStructure.Common.DestTilingEnable); 3971 } 3972 inline void setSrcTilingEnable(const SRC_TILING_ENABLE value) { 3973 TheStructure.Common.SrcTilingEnable = value; 3974 } 3975 inline SRC_TILING_ENABLE getSrcTilingEnable() const { 3976 return static_cast<SRC_TILING_ENABLE>(TheStructure.Common.SrcTilingEnable); 3977 } 3978 inline void set32BppByteMask(const _32BPP_BYTE_MASK value) { 3979 TheStructure.Common._32BppByteMask = value; 3980 } 3981 inline _32BPP_BYTE_MASK get32BppByteMask() const { 3982 return static_cast<_32BPP_BYTE_MASK>(TheStructure.Common._32BppByteMask); 3983 } 3984 inline void setInstructionTargetOpcode(const uint32_t value) { 3985 UNRECOVERABLE_IF(value > 0x1fc00000); 3986 TheStructure.Common.InstructionTarget_Opcode = value; 3987 } 3988 inline uint32_t getInstructionTargetOpcode() const { 3989 return TheStructure.Common.InstructionTarget_Opcode; 3990 } 3991 inline void setClient(const CLIENT value) { 3992 TheStructure.Common.Client = value; 3993 } 3994 inline CLIENT getClient() const { 3995 return static_cast<CLIENT>(TheStructure.Common.Client); 3996 } 3997 inline void setDestinationPitch(const uint32_t value) { 3998 UNRECOVERABLE_IF(value > 0xffff); 3999 TheStructure.Common.DestinationPitch = value; 4000 } 4001 inline uint32_t getDestinationPitch() const { 4002 return TheStructure.Common.DestinationPitch; 4003 } 4004 inline void setRasterOperation(const uint32_t value) { 4005 UNRECOVERABLE_IF(value > 0xff0000); 4006 TheStructure.Common.RasterOperation = value; 4007 } 4008 inline uint32_t getRasterOperation() const { 4009 return TheStructure.Common.RasterOperation; 4010 } 4011 inline void setColorDepth(const COLOR_DEPTH value) { 4012 TheStructure.Common.ColorDepth = value; 4013 } 4014 inline COLOR_DEPTH getColorDepth() const { 4015 return static_cast<COLOR_DEPTH>(TheStructure.Common.ColorDepth); 4016 } 4017 inline void setClippingEnabled(const CLIPPING_ENABLED value) { 4018 TheStructure.Common.ClippingEnabled = value; 4019 } 4020 inline CLIPPING_ENABLED getClippingEnabled() const { 4021 return static_cast<CLIPPING_ENABLED>(TheStructure.Common.ClippingEnabled); 4022 } 4023 inline void setDestinationX1CoordinateLeft(const uint32_t value) { 4024 UNRECOVERABLE_IF(value > 0xffff); 4025 TheStructure.Common.DestinationX1Coordinate_Left = value; 4026 } 4027 inline uint32_t getDestinationX1CoordinateLeft() const { 4028 return TheStructure.Common.DestinationX1Coordinate_Left; 4029 } 4030 inline void setDestinationY1CoordinateTop(const uint32_t value) { 4031 UNRECOVERABLE_IF(value > 0xffff0000); 4032 TheStructure.Common.DestinationY1Coordinate_Top = value; 4033 } 4034 inline uint32_t getDestinationY1CoordinateTop() const { 4035 return TheStructure.Common.DestinationY1Coordinate_Top; 4036 } 4037 inline void setDestinationX2CoordinateRight(const uint32_t value) { 4038 UNRECOVERABLE_IF(value > 0xffff); 4039 TheStructure.Common.DestinationX2Coordinate_Right = value; 4040 } 4041 inline uint32_t getDestinationX2CoordinateRight() const { 4042 return TheStructure.Common.DestinationX2Coordinate_Right; 4043 } 4044 inline void setDestinationY2CoordinateBottom(const uint32_t value) { 4045 UNRECOVERABLE_IF(value > 0xffff0000); 4046 TheStructure.Common.DestinationY2Coordinate_Bottom = value; 4047 } 4048 inline uint32_t getDestinationY2CoordinateBottom() const { 4049 return TheStructure.Common.DestinationY2Coordinate_Bottom; 4050 } 4051 inline void setDestinationBaseAddress(const uint64_t value) { 4052 TheStructure.Common.DestinationBaseAddress = value; 4053 } 4054 inline uint64_t getDestinationBaseAddress() const { 4055 return TheStructure.Common.DestinationBaseAddress; 4056 } 4057 inline void setSourceX1CoordinateLeft(const uint32_t value) { 4058 UNRECOVERABLE_IF(value > 0xffff); 4059 TheStructure.Common.SourceX1Coordinate_Left = value; 4060 } 4061 inline uint32_t getSourceX1CoordinateLeft() const { 4062 return TheStructure.Common.SourceX1Coordinate_Left; 4063 } 4064 inline void setSourceY1CoordinateTop(const uint32_t value) { 4065 UNRECOVERABLE_IF(value > 0xffff0000); 4066 TheStructure.Common.SourceY1Coordinate_Top = value; 4067 } 4068 inline uint32_t getSourceY1CoordinateTop() const { 4069 return TheStructure.Common.SourceY1Coordinate_Top; 4070 } 4071 inline void setSourcePitch(const uint32_t value) { 4072 UNRECOVERABLE_IF(value > 0xffff); 4073 TheStructure.Common.SourcePitch = value; 4074 } 4075 inline uint32_t getSourcePitch() const { 4076 return TheStructure.Common.SourcePitch; 4077 } 4078 inline void setSourceBaseAddress(const uint64_t value) { 4079 TheStructure.Common.SourceBaseAddress = value; 4080 } 4081 inline uint64_t getSourceBaseAddress() const { 4082 return TheStructure.Common.SourceBaseAddress; 4083 } 4084} XY_SRC_COPY_BLT; 4085STATIC_ASSERT(40 == sizeof(XY_SRC_COPY_BLT)); 4086 4087typedef struct tagXY_COLOR_BLT { 4088 union tagTheStructure { 4089 struct tagCommon { 4090 // DWORD 0 4091 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 4092 uint32_t Reserved_8 : BITFIELD_RANGE(8, 10); 4093 uint32_t DestTilingEnable : BITFIELD_RANGE(11, 11); 4094 uint32_t Reserved_12 : BITFIELD_RANGE(12, 19); 4095 uint32_t _32BppByteMask : BITFIELD_RANGE(20, 21); 4096 uint32_t InstructionTarget_Opcode : BITFIELD_RANGE(22, 28); 4097 uint32_t Client : BITFIELD_RANGE(29, 31); 4098 // DWORD 1 4099 uint32_t DestinationPitch : BITFIELD_RANGE(0, 15); 4100 uint32_t RasterOperation : BITFIELD_RANGE(16, 23); 4101 uint32_t ColorDepth : BITFIELD_RANGE(24, 25); 4102 uint32_t Reserved_58 : BITFIELD_RANGE(26, 29); 4103 uint32_t ClippingEnabled : BITFIELD_RANGE(30, 30); 4104 uint32_t Reserved_63 : BITFIELD_RANGE(31, 31); 4105 // DWORD 2 4106 uint32_t DestinationX1Coordinate_Left : BITFIELD_RANGE(0, 15); 4107 uint32_t DestinationY1Coordinate_Top : BITFIELD_RANGE(16, 31); 4108 // DWORD 3 4109 uint32_t DestinationX2Coordinate_Right : BITFIELD_RANGE(0, 15); 4110 uint32_t DestinationY2Coordinate_Bottom : BITFIELD_RANGE(16, 31); 4111 // DWORD 4-5 4112 uint64_t DestinationBaseAddress; 4113 // DWORD 6 4114 uint32_t SolidPaternColor; 4115 } Common; 4116 uint32_t RawData[7]; 4117 } TheStructure; 4118 typedef enum tagDEST_TILING_ENABLE { 4119 DEST_TILING_ENABLE_TILING_DISABLED_LINEAR_BLIT = 0x0, 4120 DEST_TILING_ENABLE_TILING_ENABLED = 0x1, 4121 } DEST_TILING_ENABLE; 4122 typedef enum tag_32BPP_BYTE_MASK { 4123 _32BPP_BYTE_MASK_WRITE_RGB_CHANNEL = 0x1, 4124 _32BPP_BYTE_MASK_WRITE_ALPHA_CHANNEL = 0x2, 4125 _32BPP_BYTE_MASK_WRITE_RGBA_CHANNEL = 0x3 4126 } _32BPP_BYTE_MASK; 4127 typedef enum tagCLIENT { 4128 CLIENT_2D_PROCESSOR = 0x2, 4129 } CLIENT; 4130 typedef enum tagCOLOR_DEPTH { 4131 COLOR_DEPTH_8_BIT_COLOR = 0x0, 4132 COLOR_DEPTH_16_BIT_COLOR565 = 0x1, 4133 COLOR_DEPTH_16_BIT_COLOR1555 = 0x2, 4134 COLOR_DEPTH_32_BIT_COLOR = 0x3, 4135 } COLOR_DEPTH; 4136 typedef enum tagCLIPPING_ENABLED { 4137 CLIPPING_ENABLED_DISABLED = 0x0, 4138 CLIPPING_ENABLED_ENABLED = 0x1, 4139 } CLIPPING_ENABLED; 4140 typedef enum tagINSTRUCTIONTARGET_OPCODE { 4141 INSTRUCTIONTARGET_OPCODE_OPCODE = 0x50, 4142 } INSTRUCTIONTARGET_OPCODE; 4143 typedef enum tagDWORD_LENGTH { 4144 DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x5, 4145 } DWORD_LENGTH; 4146 inline void init() { 4147 memset(&TheStructure, 0, sizeof(TheStructure)); 4148 TheStructure.Common.DestTilingEnable = DEST_TILING_ENABLE_TILING_DISABLED_LINEAR_BLIT; 4149 TheStructure.Common.Client = CLIENT_2D_PROCESSOR; 4150 TheStructure.Common.ColorDepth = COLOR_DEPTH_8_BIT_COLOR; 4151 TheStructure.Common.ClippingEnabled = CLIPPING_ENABLED_DISABLED; 4152 TheStructure.Common.InstructionTarget_Opcode = INSTRUCTIONTARGET_OPCODE_OPCODE; 4153 TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1; 4154 TheStructure.Common.RasterOperation = 0xF0; 4155 } 4156 static tagXY_COLOR_BLT sInit() { 4157 XY_COLOR_BLT state; 4158 state.init(); 4159 return state; 4160 } 4161 inline uint32_t &getRawData(const uint32_t index) { 4162 UNRECOVERABLE_IF(index >= 10); 4163 return TheStructure.RawData[index]; 4164 } 4165 inline void setDestTilingEnable(const DEST_TILING_ENABLE value) { 4166 TheStructure.Common.DestTilingEnable = value; 4167 } 4168 inline DEST_TILING_ENABLE getDestTilingEnable() const { 4169 return static_cast<DEST_TILING_ENABLE>(TheStructure.Common.DestTilingEnable); 4170 } 4171 inline void set32BppByteMask(const _32BPP_BYTE_MASK value) { 4172 TheStructure.Common._32BppByteMask = value; 4173 } 4174 inline _32BPP_BYTE_MASK get32BppByteMask() const { 4175 return static_cast<_32BPP_BYTE_MASK>(TheStructure.Common._32BppByteMask); 4176 } 4177 inline void setInstructionTargetOpcode(const uint32_t value) { 4178 UNRECOVERABLE_IF(value > 0x1fc00000); 4179 TheStructure.Common.InstructionTarget_Opcode = value; 4180 } 4181 inline uint32_t getInstructionTargetOpcode() const { 4182 return TheStructure.Common.InstructionTarget_Opcode; 4183 } 4184 inline void setClient(const CLIENT value) { 4185 TheStructure.Common.Client = value; 4186 } 4187 inline CLIENT getClient() const { 4188 return static_cast<CLIENT>(TheStructure.Common.Client); 4189 } 4190 inline void setDestinationPitch(const uint32_t value) { 4191 UNRECOVERABLE_IF(value > 0xffff); 4192 TheStructure.Common.DestinationPitch = value; 4193 } 4194 inline uint32_t getDestinationPitch() const { 4195 return TheStructure.Common.DestinationPitch; 4196 } 4197 inline void setRasterOperation(const uint32_t value) { 4198 UNRECOVERABLE_IF(value > 0xff0000); 4199 TheStructure.Common.RasterOperation = value; 4200 } 4201 inline uint32_t getRasterOperation() const { 4202 return TheStructure.Common.RasterOperation; 4203 } 4204 inline void setColorDepth(const COLOR_DEPTH value) { 4205 TheStructure.Common.ColorDepth = value; 4206 } 4207 inline COLOR_DEPTH getColorDepth() const { 4208 return static_cast<COLOR_DEPTH>(TheStructure.Common.ColorDepth); 4209 } 4210 inline void setClippingEnabled(const CLIPPING_ENABLED value) { 4211 TheStructure.Common.ClippingEnabled = value; 4212 } 4213 inline CLIPPING_ENABLED getClippingEnabled() const { 4214 return static_cast<CLIPPING_ENABLED>(TheStructure.Common.ClippingEnabled); 4215 } 4216 inline void setDestinationX1CoordinateLeft(const uint32_t value) { 4217 UNRECOVERABLE_IF(value > 0xffff); 4218 TheStructure.Common.DestinationX1Coordinate_Left = value; 4219 } 4220 inline uint32_t getDestinationX1CoordinateLeft() const { 4221 return TheStructure.Common.DestinationX1Coordinate_Left; 4222 } 4223 inline void setDestinationY1CoordinateTop(const uint32_t value) { 4224 UNRECOVERABLE_IF(value > 0xffff0000); 4225 TheStructure.Common.DestinationY1Coordinate_Top = value; 4226 } 4227 inline uint32_t getDestinationY1CoordinateTop() const { 4228 return TheStructure.Common.DestinationY1Coordinate_Top; 4229 } 4230 inline void setDestinationX2CoordinateRight(const uint32_t value) { 4231 UNRECOVERABLE_IF(value > 0xffff); 4232 TheStructure.Common.DestinationX2Coordinate_Right = value; 4233 } 4234 inline uint32_t getDestinationX2CoordinateRight() const { 4235 return TheStructure.Common.DestinationX2Coordinate_Right; 4236 } 4237 inline void setDestinationY2CoordinateBottom(const uint32_t value) { 4238 UNRECOVERABLE_IF(value > 0xffff0000); 4239 TheStructure.Common.DestinationY2Coordinate_Bottom = value; 4240 } 4241 inline uint32_t getDestinationY2CoordinateBottom() const { 4242 return TheStructure.Common.DestinationY2Coordinate_Bottom; 4243 } 4244 inline void setDestinationBaseAddress(const uint64_t value) { 4245 TheStructure.Common.DestinationBaseAddress = value; 4246 } 4247 inline uint64_t getDestinationBaseAddress() const { 4248 return TheStructure.Common.DestinationBaseAddress; 4249 } 4250 inline void setFillColor(const uint32_t *value) { 4251 TheStructure.Common.SolidPaternColor = *value; 4252 } 4253} XY_COLOR_BLT; 4254STATIC_ASSERT(28 == sizeof(XY_COLOR_BLT)); 4255 4256typedef struct tagGRF { 4257 union tagTheStructure { 4258 float fRegs[8]; 4259 uint32_t dwRegs[8]; 4260 uint16_t wRegs[16]; 4261 uint32_t RawData[8]; 4262 } TheStructure; 4263} GRF; 4264STATIC_ASSERT(32 == sizeof(GRF)); 4265 4266typedef struct tagMEDIA_SURFACE_STATE { 4267 union tagTheStructure { 4268 struct tagCommon { 4269 uint32_t Reserved_0; 4270 uint32_t Cr_VCb_UPixelOffsetVDirection : BITFIELD_RANGE(0, 1); 4271 uint32_t PictureStructure : BITFIELD_RANGE(2, 3); 4272 uint32_t Width : BITFIELD_RANGE(4, 17); 4273 uint32_t Height : BITFIELD_RANGE(18, 31); 4274 uint32_t TileMode : BITFIELD_RANGE(0, 1); 4275 uint32_t HalfPitchForChroma : BITFIELD_RANGE(2, 2); 4276 uint32_t SurfacePitch : BITFIELD_RANGE(3, 20); 4277 uint32_t AddressControl : BITFIELD_RANGE(21, 21); 4278 uint32_t Reserved_86 : BITFIELD_RANGE(22, 25); 4279 uint32_t InterleaveChroma : BITFIELD_RANGE(26, 26); 4280 uint32_t SurfaceFormat : BITFIELD_RANGE(27, 31); 4281 uint32_t YOffsetForU_Cb : BITFIELD_RANGE(0, 13); 4282 uint32_t Reserved_110 : BITFIELD_RANGE(14, 15); 4283 uint32_t XOffsetForU_Cb : BITFIELD_RANGE(16, 29); 4284 uint32_t Reserved_126 : BITFIELD_RANGE(30, 31); 4285 uint32_t Reserved_128; 4286 uint32_t SurfaceMemoryObjectControlState_AgeForQuadlru : BITFIELD_RANGE(0, 1); 4287 uint32_t SurfaceMemoryObjectControlState_Reserved : BITFIELD_RANGE(2, 2); 4288 uint32_t SurfaceMemoryObjectControlState_TargetCache : BITFIELD_RANGE(3, 4); 4289 uint32_t SurfaceMemoryObjectControlState_MemoryTypeLlcEllcCacheabilityControl : BITFIELD_RANGE(5, 6); 4290 uint32_t Reserved_167 : BITFIELD_RANGE(7, 29); 4291 uint32_t VerticalLineStrideOffset : BITFIELD_RANGE(30, 30); 4292 uint32_t VerticalLineStride : BITFIELD_RANGE(31, 31); 4293 uint32_t SurfaceBaseAddressLow; 4294 uint32_t SurfaceBaseAddressHigh : BITFIELD_RANGE(0, 15); 4295 uint32_t Reserved_240 : BITFIELD_RANGE(16, 31); 4296 } Common; 4297 struct tag_SurfaceFormatIsOneOfPlanarAnd_InterleaveChromaIs0 { 4298 uint32_t Reserved_0; 4299 uint32_t Reserved_32; 4300 uint32_t Reserved_64; 4301 uint32_t Reserved_96; 4302 uint32_t YOffsetForV_Cr : BITFIELD_RANGE(0, 14); 4303 uint32_t Reserved_143 : BITFIELD_RANGE(15, 15); 4304 uint32_t XOffsetForV_Cr : BITFIELD_RANGE(16, 29); 4305 uint32_t Reserved_158 : BITFIELD_RANGE(30, 31); 4306 uint32_t Reserved_160; 4307 uint32_t Reserved_192; 4308 uint32_t Reserved_224; 4309 } _SurfaceFormatIsOneOfPlanarAnd_InterleaveChromaIs0; 4310 uint32_t RawData[8]; 4311 } TheStructure; 4312 typedef enum tagPICTURE_STRUCTURE { 4313 PICTURE_STRUCTURE_FRAME_PICTURE = 0x0, 4314 PICTURE_STRUCTURE_TOP_FIELD_PICTURE = 0x1, 4315 PICTURE_STRUCTURE_BOTTOM_FIELD_PICTURE = 0x2, 4316 PICTURE_STRUCTURE_INVALID_NOT_ALLOWED = 0x3, 4317 } PICTURE_STRUCTURE; 4318 typedef enum tagTILE_MODE { 4319 TILE_MODE_TILEMODE_LINEAR = 0x0, 4320 TILE_MODE_TILEMODE_XMAJOR = 0x2, 4321 TILE_MODE_TILEMODE_YMAJOR = 0x3, 4322 } TILE_MODE; 4323 typedef enum tagADDRESS_CONTROL { 4324 ADDRESS_CONTROL_CLAMP = 0x0, 4325 ADDRESS_CONTROL_MIRROR = 0x1, 4326 } ADDRESS_CONTROL; 4327 typedef enum tagSURFACE_FORMAT { 4328 SURFACE_FORMAT_YCRCB_NORMAL = 0x0, 4329 SURFACE_FORMAT_YCRCB_SWAPUVY = 0x1, 4330 SURFACE_FORMAT_YCRCB_SWAPUV = 0x2, 4331 SURFACE_FORMAT_YCRCB_SWAPY = 0x3, 4332 SURFACE_FORMAT_PLANAR_420_8 = 0x4, 4333 SURFACE_FORMAT_Y8_UNORM_VA = 0x5, 4334 SURFACE_FORMAT_Y16_SNORM = 0x6, 4335 SURFACE_FORMAT_Y16_UNORM_VA = 0x7, 4336 SURFACE_FORMAT_R10G10B10A2_UNORM = 0x8, 4337 SURFACE_FORMAT_R8G8B8A8_UNORM = 0x9, 4338 SURFACE_FORMAT_R8B8_UNORM_CRCB = 0xa, 4339 SURFACE_FORMAT_R8_UNORM_CR_CB = 0xb, 4340 SURFACE_FORMAT_Y8_UNORM = 0xc, 4341 SURFACE_FORMAT_A8Y8U8V8_UNORM = 0xd, 4342 SURFACE_FORMAT_B8G8R8A8_UNORM = 0xe, 4343 SURFACE_FORMAT_R16G16B16A16 = 0xf, 4344 SURFACE_FORMAT_Y1_UNORM = 0x10, 4345 SURFACE_FORMAT_Y32_UNORM = 0x11, 4346 } SURFACE_FORMAT; 4347 typedef enum tagSURFACE_MEMORY_OBJECT_CONTROL_STATE { 4348 SURFACE_MEMORY_OBJECT_CONTROL_STATE_DEFAULTVAUEDESC = 0x0, 4349 } SURFACE_MEMORY_OBJECT_CONTROL_STATE; 4350 typedef enum tagPATCH_CONSTANTS { 4351 SURFACEBASEADDRESS_BYTEOFFSET = 0x18, 4352 SURFACEBASEADDRESS_INDEX = 0x6, 4353 SURFACEBASEADDRESSHIGH_BYTEOFFSET = 0x1c, 4354 SURFACEBASEADDRESSHIGH_INDEX = 0x7, 4355 } PATCH_CONSTANTS; 4356 inline void init() { 4357 memset(&TheStructure, 0, sizeof(TheStructure)); 4358 TheStructure.Common.PictureStructure = PICTURE_STRUCTURE_FRAME_PICTURE; 4359 TheStructure.Common.TileMode = TILE_MODE_TILEMODE_LINEAR; 4360 TheStructure.Common.AddressControl = ADDRESS_CONTROL_CLAMP; 4361 TheStructure.Common.SurfaceFormat = SURFACE_FORMAT_YCRCB_NORMAL; 4362 } 4363 static tagMEDIA_SURFACE_STATE sInit() { 4364 MEDIA_SURFACE_STATE state; 4365 state.init(); 4366 return state; 4367 } 4368 inline uint32_t &getRawData(const uint32_t index) { 4369 DEBUG_BREAK_IF(index >= 8); 4370 return TheStructure.RawData[index]; 4371 } 4372 inline void setCrVCbUPixelOffsetVDirection(const uint32_t value) { 4373 TheStructure.Common.Cr_VCb_UPixelOffsetVDirection = value; 4374 } 4375 inline uint32_t getCrVCbUPixelOffsetVDirection() const { 4376 return (TheStructure.Common.Cr_VCb_UPixelOffsetVDirection); 4377 } 4378 inline void setPictureStructure(const PICTURE_STRUCTURE value) { 4379 TheStructure.Common.PictureStructure = value; 4380 } 4381 inline PICTURE_STRUCTURE getPictureStructure() const { 4382 return static_cast<PICTURE_STRUCTURE>(TheStructure.Common.PictureStructure); 4383 } 4384 inline void setWidth(const uint32_t value) { 4385 TheStructure.Common.Width = value - 1; 4386 } 4387 inline uint32_t getWidth() const { 4388 return (TheStructure.Common.Width + 1); 4389 } 4390 inline void setHeight(const uint32_t value) { 4391 TheStructure.Common.Height = value - 1; 4392 } 4393 inline uint32_t getHeight() const { 4394 return (TheStructure.Common.Height + 1); 4395 } 4396 inline void setTileMode(const TILE_MODE value) { 4397 TheStructure.Common.TileMode = value; 4398 } 4399 inline TILE_MODE getTileMode() const { 4400 return static_cast<TILE_MODE>(TheStructure.Common.TileMode); 4401 } 4402 inline void setHalfPitchForChroma(const bool value) { 4403 TheStructure.Common.HalfPitchForChroma = value; 4404 } 4405 inline bool getHalfPitchForChroma() const { 4406 return (TheStructure.Common.HalfPitchForChroma); 4407 } 4408 inline void setSurfacePitch(const uint32_t value) { 4409 TheStructure.Common.SurfacePitch = value - 1; 4410 } 4411 inline uint32_t getSurfacePitch() const { 4412 return (TheStructure.Common.SurfacePitch + 1); 4413 } 4414 inline void setAddressControl(const ADDRESS_CONTROL value) { 4415 TheStructure.Common.AddressControl = value; 4416 } 4417 inline ADDRESS_CONTROL getAddressControl() const { 4418 return static_cast<ADDRESS_CONTROL>(TheStructure.Common.AddressControl); 4419 } 4420 inline void setInterleaveChroma(const bool value) { 4421 TheStructure.Common.InterleaveChroma = value; 4422 } 4423 inline bool getInterleaveChroma() const { 4424 return (TheStructure.Common.InterleaveChroma); 4425 } 4426 inline void setSurfaceFormat(const SURFACE_FORMAT value) { 4427 TheStructure.Common.SurfaceFormat = value; 4428 } 4429 inline SURFACE_FORMAT getSurfaceFormat() const { 4430 return static_cast<SURFACE_FORMAT>(TheStructure.Common.SurfaceFormat); 4431 } 4432 inline void setYOffsetForUCb(const uint32_t value) { 4433 TheStructure.Common.YOffsetForU_Cb = value; 4434 } 4435 inline uint32_t getYOffsetForUCb() const { 4436 return (TheStructure.Common.YOffsetForU_Cb); 4437 } 4438 inline void setXOffsetForUCb(const uint32_t value) { 4439 TheStructure.Common.XOffsetForU_Cb = value; 4440 } 4441 inline uint32_t getXOffsetForUCb() const { 4442 return (TheStructure.Common.XOffsetForU_Cb); 4443 } 4444 inline void setSurfaceMemoryObjectControlStateAgeForQuadlru(const uint32_t value) { 4445 TheStructure.Common.SurfaceMemoryObjectControlState_AgeForQuadlru = value; 4446 } 4447 inline uint32_t getSurfaceMemoryObjectControlStateAgeForQuadlru() const { 4448 return (TheStructure.Common.SurfaceMemoryObjectControlState_AgeForQuadlru); 4449 } 4450 inline void setSurfaceMemoryObjectControlStateReserved(const uint32_t value) { 4451 TheStructure.Common.SurfaceMemoryObjectControlState_Reserved = value; 4452 } 4453 inline uint32_t getSurfaceMemoryObjectControlStateReserved() const { 4454 return (TheStructure.Common.SurfaceMemoryObjectControlState_Reserved); 4455 } 4456 inline void setSurfaceMemoryObjectControlStateTargetCache(const uint32_t value) { 4457 TheStructure.Common.SurfaceMemoryObjectControlState_TargetCache = value; 4458 } 4459 inline uint32_t getSurfaceMemoryObjectControlStateTargetCache() const { 4460 return (TheStructure.Common.SurfaceMemoryObjectControlState_TargetCache); 4461 } 4462 inline void setSurfaceMemoryObjectControlStateMemoryTypeLlcEllcCacheabilityControl(const uint32_t value) { 4463 TheStructure.Common.SurfaceMemoryObjectControlState_MemoryTypeLlcEllcCacheabilityControl = value; 4464 } 4465 inline uint32_t getSurfaceMemoryObjectControlStateMemoryTypeLlcEllcCacheabilityControl() const { 4466 return (TheStructure.Common.SurfaceMemoryObjectControlState_MemoryTypeLlcEllcCacheabilityControl); 4467 } 4468 inline void setVerticalLineStrideOffset(const uint32_t value) { 4469 TheStructure.Common.VerticalLineStrideOffset = value; 4470 } 4471 inline uint32_t getVerticalLineStrideOffset() const { 4472 return (TheStructure.Common.VerticalLineStrideOffset); 4473 } 4474 inline void setVerticalLineStride(const uint32_t value) { 4475 TheStructure.Common.VerticalLineStride = value; 4476 } 4477 inline uint32_t getVerticalLineStride() const { 4478 return (TheStructure.Common.VerticalLineStride); 4479 } 4480 inline void setSurfaceBaseAddress(const uint64_t value) { 4481 TheStructure.Common.SurfaceBaseAddressLow = static_cast<uint32_t>(value); 4482 TheStructure.Common.SurfaceBaseAddressHigh = value >> 32; 4483 } 4484 inline uint64_t getSurfaceBaseAddress() const { 4485 return (TheStructure.Common.SurfaceBaseAddressLow | 4486 static_cast<uint64_t>(TheStructure.Common.SurfaceBaseAddressHigh) << 32); 4487 } 4488 inline void setSurfaceBaseAddressHigh(const uint32_t value) { 4489 TheStructure.Common.SurfaceBaseAddressHigh = value; 4490 } 4491 inline uint32_t getSurfaceBaseAddressHigh() const { 4492 return (TheStructure.Common.SurfaceBaseAddressHigh); 4493 } 4494 inline void setYOffsetForVCr(const uint32_t value) { 4495 TheStructure._SurfaceFormatIsOneOfPlanarAnd_InterleaveChromaIs0.YOffsetForV_Cr = value; 4496 } 4497 inline uint32_t getYOffsetForVCr() const { 4498 return (TheStructure._SurfaceFormatIsOneOfPlanarAnd_InterleaveChromaIs0.YOffsetForV_Cr); 4499 } 4500 inline void setXOffsetForVCr(const uint32_t value) { 4501 TheStructure._SurfaceFormatIsOneOfPlanarAnd_InterleaveChromaIs0.XOffsetForV_Cr = value; 4502 } 4503 inline uint32_t getXOffsetForVCr() const { 4504 return (TheStructure._SurfaceFormatIsOneOfPlanarAnd_InterleaveChromaIs0.XOffsetForV_Cr); 4505 } 4506} MEDIA_SURFACE_STATE; 4507STATIC_ASSERT(32 == sizeof(MEDIA_SURFACE_STATE)); 4508 4509typedef struct tagMI_MATH { 4510 union _DW0 { 4511 struct _BitField { 4512 uint32_t DwordLength : BITFIELD_RANGE(0, 5); 4513 uint32_t Reserved : BITFIELD_RANGE(6, 22); 4514 uint32_t InstructionOpcode : BITFIELD_RANGE(23, 28); 4515 uint32_t InstructionType : BITFIELD_RANGE(29, 31); 4516 } BitField; 4517 uint32_t Value; 4518 } DW0; 4519 typedef enum tagMI_COMMAND_OPCODE { 4520 MI_COMMAND_OPCODE_MI_MATH = 0x1A, 4521 } MI_COMMAND_OPCODE; 4522 typedef enum tagCOMMAND_TYPE { 4523 COMMAND_TYPE_MI_COMMAND = 0x0, 4524 } COMMAND_TYPE; 4525} MI_MATH; 4526typedef struct tagMI_MATH_ALU_INST_INLINE { 4527 union _DW0 { 4528 struct _BitField { 4529 uint32_t Operand2 : BITFIELD_RANGE(0, 9); 4530 uint32_t Operand1 : BITFIELD_RANGE(10, 19); 4531 uint32_t ALUOpcode : BITFIELD_RANGE(20, 31); 4532 } BitField; 4533 uint32_t Value; 4534 } DW0; 4535} MI_MATH_ALU_INST_INLINE; 4536typedef struct tagMI_SEMAPHORE_WAIT { 4537 union tagTheStructure { 4538 struct tagCommon { 4539 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 4540 uint32_t Reserved_8 : BITFIELD_RANGE(8, 11); 4541 uint32_t CompareOperation : BITFIELD_RANGE(12, 14); 4542 uint32_t WaitMode : BITFIELD_RANGE(15, 15); 4543 uint32_t Reserved_16 : BITFIELD_RANGE(16, 21); 4544 uint32_t MemoryType : BITFIELD_RANGE(22, 22); 4545 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 4546 uint32_t CommandType : BITFIELD_RANGE(29, 31); 4547 uint32_t SemaphoreDataDword; 4548 uint64_t Reserved_64 : BITFIELD_RANGE(0, 1); 4549 uint64_t SemaphoreAddress_Graphicsaddress : BITFIELD_RANGE(2, 47); 4550 uint64_t SemaphoreAddress_Reserved : BITFIELD_RANGE(48, 63); 4551 } Common; 4552 uint32_t RawData[4]; 4553 } TheStructure; 4554 typedef enum tagDWORD_LENGTH { 4555 DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x2, 4556 } DWORD_LENGTH; 4557 typedef enum tagCOMPARE_OPERATION { 4558 COMPARE_OPERATION_SAD_GREATER_THAN_SDD = 0x0, 4559 COMPARE_OPERATION_SAD_GREATER_THAN_OR_EQUAL_SDD = 0x1, 4560 COMPARE_OPERATION_SAD_LESS_THAN_SDD = 0x2, 4561 COMPARE_OPERATION_SAD_LESS_THAN_OR_EQUAL_SDD = 0x3, 4562 COMPARE_OPERATION_SAD_EQUAL_SDD = 0x4, 4563 COMPARE_OPERATION_SAD_NOT_EQUAL_SDD = 0x5, 4564 } COMPARE_OPERATION; 4565 typedef enum tagWAIT_MODE { 4566 WAIT_MODE_SIGNAL_MODE = 0x0, 4567 WAIT_MODE_POLLING_MODE = 0x1, 4568 } WAIT_MODE; 4569 typedef enum tagMEMORY_TYPE { 4570 MEMORY_TYPE_PER_PROCESS_GRAPHICS_ADDRESS = 0x0, 4571 MEMORY_TYPE_GLOBAL_GRAPHICS_ADDRESS = 0x1, 4572 } MEMORY_TYPE; 4573 typedef enum tagMI_COMMAND_OPCODE { 4574 MI_COMMAND_OPCODE_MI_SEMAPHORE_WAIT = 0x1c, 4575 } MI_COMMAND_OPCODE; 4576 typedef enum tagCOMMAND_TYPE { 4577 COMMAND_TYPE_MI_COMMAND = 0x0, 4578 } COMMAND_TYPE; 4579 inline void init() { 4580 memset(&TheStructure, 0, sizeof(TheStructure)); 4581 TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1; 4582 TheStructure.Common.CompareOperation = COMPARE_OPERATION_SAD_GREATER_THAN_SDD; 4583 TheStructure.Common.WaitMode = WAIT_MODE_SIGNAL_MODE; 4584 TheStructure.Common.MemoryType = MEMORY_TYPE_PER_PROCESS_GRAPHICS_ADDRESS; 4585 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_SEMAPHORE_WAIT; 4586 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 4587 } 4588 static tagMI_SEMAPHORE_WAIT sInit() { 4589 MI_SEMAPHORE_WAIT state; 4590 state.init(); 4591 return state; 4592 } 4593 inline uint32_t &getRawData(const uint32_t index) { 4594 DEBUG_BREAK_IF(index >= 4); 4595 return TheStructure.RawData[index]; 4596 } 4597 inline void setCompareOperation(const COMPARE_OPERATION value) { 4598 TheStructure.Common.CompareOperation = value; 4599 } 4600 inline COMPARE_OPERATION getCompareOperation() const { 4601 return static_cast<COMPARE_OPERATION>(TheStructure.Common.CompareOperation); 4602 } 4603 inline void setWaitMode(const WAIT_MODE value) { 4604 TheStructure.Common.WaitMode = value; 4605 } 4606 inline WAIT_MODE getWaitMode() const { 4607 return static_cast<WAIT_MODE>(TheStructure.Common.WaitMode); 4608 } 4609 inline void setMemoryType(const MEMORY_TYPE value) { 4610 TheStructure.Common.MemoryType = value; 4611 } 4612 inline MEMORY_TYPE getMemoryType() const { 4613 return static_cast<MEMORY_TYPE>(TheStructure.Common.MemoryType); 4614 } 4615 inline void setSemaphoreDataDword(const uint32_t value) { 4616 TheStructure.Common.SemaphoreDataDword = value; 4617 } 4618 inline uint32_t getSemaphoreDataDword() const { 4619 return (TheStructure.Common.SemaphoreDataDword); 4620 } 4621 typedef enum tagSEMAPHOREADDRESS_GRAPHICSADDRESS { 4622 SEMAPHOREADDRESS_GRAPHICSADDRESS_BIT_SHIFT = 0x2, 4623 SEMAPHOREADDRESS_GRAPHICSADDRESS_ALIGN_SIZE = 0x4, 4624 } SEMAPHOREADDRESS_GRAPHICSADDRESS; 4625 inline void setSemaphoreGraphicsAddress(const uint64_t value) { 4626 TheStructure.Common.SemaphoreAddress_Graphicsaddress = value >> SEMAPHOREADDRESS_GRAPHICSADDRESS_BIT_SHIFT; 4627 } 4628 inline uint64_t getSemaphoreGraphicsAddress() const { 4629 return (TheStructure.Common.SemaphoreAddress_Graphicsaddress << SEMAPHOREADDRESS_GRAPHICSADDRESS_BIT_SHIFT); 4630 } 4631 typedef enum tagSEMAPHOREADDRESS_RESERVED { 4632 SEMAPHOREADDRESS_RESERVED_BIT_SHIFT = 0x2, 4633 SEMAPHOREADDRESS_RESERVED_ALIGN_SIZE = 0x4, 4634 } SEMAPHOREADDRESS_RESERVED; 4635 inline void setSemaphoreAddressReserved(const uint64_t value) { 4636 TheStructure.Common.SemaphoreAddress_Reserved = value >> SEMAPHOREADDRESS_RESERVED_BIT_SHIFT; 4637 } 4638 inline uint64_t getSemaphoreAddressReserved() const { 4639 return (TheStructure.Common.SemaphoreAddress_Reserved << SEMAPHOREADDRESS_RESERVED_BIT_SHIFT); 4640 } 4641} MI_SEMAPHORE_WAIT; 4642STATIC_ASSERT(16 == sizeof(MI_SEMAPHORE_WAIT)); 4643 4644typedef struct tagMI_STORE_DATA_IMM { 4645 union tagTheStructure { 4646 struct tagCommon { 4647 uint32_t DwordLength : BITFIELD_RANGE(0, 9); 4648 uint32_t Reserved_10 : BITFIELD_RANGE(10, 20); 4649 uint32_t StoreQword : BITFIELD_RANGE(21, 21); 4650 uint32_t UseGlobalGtt : BITFIELD_RANGE(22, 22); 4651 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 4652 uint32_t CommandType : BITFIELD_RANGE(29, 31); 4653 uint32_t Reserved_32 : BITFIELD_RANGE(0, 1); 4654 uint32_t Address : BITFIELD_RANGE(2, 31); 4655 uint32_t AddressHigh : BITFIELD_RANGE(0, 15); 4656 uint32_t Reserved_80 : BITFIELD_RANGE(16, 31); 4657 uint32_t DataDword0; 4658 uint32_t DataDword1; 4659 } Common; 4660 uint32_t RawData[5]; 4661 } TheStructure; 4662 typedef enum tagDWORD_LENGTH { 4663 DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x0, 4664 DWORD_LENGTH_STORE_DWORD = 0x2, 4665 DWORD_LENGTH_STORE_QWORD = 0x3, 4666 } DWORD_LENGTH; 4667 typedef enum tagMI_COMMAND_OPCODE { 4668 MI_COMMAND_OPCODE_MI_STORE_DATA_IMM = 0x20, 4669 } MI_COMMAND_OPCODE; 4670 typedef enum tagCOMMAND_TYPE { 4671 COMMAND_TYPE_MI_COMMAND = 0x0, 4672 } COMMAND_TYPE; 4673 typedef enum tagPATCH_CONSTANTS { 4674 ADDRESS_BYTEOFFSET = 0x4, 4675 ADDRESS_INDEX = 0x1, 4676 ADDRESSHIGH_BYTEOFFSET = 0x8, 4677 ADDRESSHIGH_INDEX = 0x2, 4678 } PATCH_CONSTANTS; 4679 inline void init() { 4680 memset(&TheStructure, 0, sizeof(TheStructure)); 4681 TheStructure.Common.DwordLength = DWORD_LENGTH_STORE_DWORD; 4682 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_STORE_DATA_IMM; 4683 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 4684 } 4685 static tagMI_STORE_DATA_IMM sInit() { 4686 MI_STORE_DATA_IMM state; 4687 state.init(); 4688 return state; 4689 } 4690 inline uint32_t &getRawData(const uint32_t index) { 4691 DEBUG_BREAK_IF(index >= 5); 4692 return TheStructure.RawData[index]; 4693 } 4694 inline void setDwordLength(const DWORD_LENGTH value) { 4695 TheStructure.Common.DwordLength = value; 4696 } 4697 inline DWORD_LENGTH getDwordLength() const { 4698 return static_cast<DWORD_LENGTH>(TheStructure.Common.DwordLength); 4699 } 4700 inline void setStoreQword(const bool value) { 4701 TheStructure.Common.StoreQword = value; 4702 } 4703 inline bool getStoreQword() const { 4704 return TheStructure.Common.StoreQword; 4705 } 4706 inline void setUseGlobalGtt(const uint32_t value) { 4707 TheStructure.Common.UseGlobalGtt = value; 4708 } 4709 inline uint32_t getUseGlobalGtt() const { 4710 return (TheStructure.Common.UseGlobalGtt); 4711 } 4712 typedef enum tagADDRESS { 4713 ADDRESS_BIT_SHIFT = 0x2, 4714 ADDRESS_ALIGN_SIZE = 0x4, 4715 } ADDRESS; 4716 inline void setAddress(const uint64_t value) { 4717 setAddressLow(static_cast<uint32_t>(value & 0x0000FFFFFFFFULL)); 4718 setAddressHigh(static_cast<uint32_t>(value >> 32)); 4719 } 4720 inline uint64_t getAddress() const { 4721 return (static_cast<uint64_t>(getAddressHigh()) << 32) | static_cast<uint64_t>(getAddressLow()); 4722 } 4723 inline void setAddressLow(const uint32_t value) { 4724 TheStructure.Common.Address = value >> ADDRESS_BIT_SHIFT; 4725 } 4726 inline uint32_t getAddressLow() const { 4727 return (TheStructure.Common.Address << ADDRESS_BIT_SHIFT); 4728 } 4729 inline void setAddressHigh(const uint32_t value) { 4730 TheStructure.Common.AddressHigh = value; 4731 } 4732 inline uint32_t getAddressHigh() const { 4733 return (TheStructure.Common.AddressHigh); 4734 } 4735 inline void setDataDword0(const uint32_t value) { 4736 TheStructure.Common.DataDword0 = value; 4737 } 4738 inline uint32_t getDataDword0() const { 4739 return (TheStructure.Common.DataDword0); 4740 } 4741 inline void setDataDword1(const uint32_t value) { 4742 TheStructure.Common.DataDword1 = value; 4743 } 4744 inline uint32_t getDataDword1() const { 4745 return (TheStructure.Common.DataDword1); 4746 } 4747} MI_STORE_DATA_IMM; 4748STATIC_ASSERT(20 == sizeof(MI_STORE_DATA_IMM)); 4749 4750typedef struct tagSTATE_SIP { 4751 union tagTheStructure { 4752 struct tagCommon { 4753 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 4754 uint32_t Reserved_8 : BITFIELD_RANGE(8, 15); 4755 uint32_t _3DCommandSubOpcode : BITFIELD_RANGE(16, 23); 4756 uint32_t _3DCommandOpcode : BITFIELD_RANGE(24, 26); 4757 uint32_t CommandSubtype : BITFIELD_RANGE(27, 28); 4758 uint32_t CommandType : BITFIELD_RANGE(29, 31); 4759 uint64_t Reserved_32 : BITFIELD_RANGE(0, 3); 4760 uint64_t SystemInstructionPointer : BITFIELD_RANGE(4, 63); 4761 } Common; 4762 uint32_t RawData[3]; 4763 } TheStructure; 4764 typedef enum tagDWORD_LENGTH { 4765 DWORD_LENGTH_DWORD_COUNT_N = 0x1, 4766 } DWORD_LENGTH; 4767 typedef enum tag_3D_COMMAND_SUB_OPCODE { 4768 _3D_COMMAND_SUB_OPCODE_STATE_SIP = 0x2, 4769 } _3D_COMMAND_SUB_OPCODE; 4770 typedef enum tag_3D_COMMAND_OPCODE { 4771 _3D_COMMAND_OPCODE_GFXPIPE_NONPIPELINED = 0x1, 4772 } _3D_COMMAND_OPCODE; 4773 typedef enum tagCOMMAND_SUBTYPE { 4774 COMMAND_SUBTYPE_GFXPIPE_COMMON = 0x0, 4775 } COMMAND_SUBTYPE; 4776 typedef enum tagCOMMAND_TYPE { 4777 COMMAND_TYPE_GFXPIPE = 0x3, 4778 } COMMAND_TYPE; 4779 typedef enum tagPATCH_CONSTANTS { 4780 SYSTEMINSTRUCTIONPOINTER_BYTEOFFSET = 0x4, 4781 SYSTEMINSTRUCTIONPOINTER_INDEX = 0x1, 4782 } PATCH_CONSTANTS; 4783 void init() { 4784 memset(&TheStructure, 0, sizeof(TheStructure)); 4785 TheStructure.Common.DwordLength = DWORD_LENGTH_DWORD_COUNT_N; 4786 TheStructure.Common._3DCommandSubOpcode = _3D_COMMAND_SUB_OPCODE_STATE_SIP; 4787 TheStructure.Common._3DCommandOpcode = _3D_COMMAND_OPCODE_GFXPIPE_NONPIPELINED; 4788 TheStructure.Common.CommandSubtype = COMMAND_SUBTYPE_GFXPIPE_COMMON; 4789 TheStructure.Common.CommandType = COMMAND_TYPE_GFXPIPE; 4790 } 4791 static tagSTATE_SIP sInit() { 4792 STATE_SIP state; 4793 state.init(); 4794 return state; 4795 } 4796 inline uint32_t &getRawData(uint32_t const index) { 4797 DEBUG_BREAK_IF(index >= 3); 4798 return TheStructure.RawData[index]; 4799 } 4800 typedef enum tagSYSTEMINSTRUCTIONPOINTER { 4801 SYSTEMINSTRUCTIONPOINTER_BIT_SHIFT = 0x4, 4802 SYSTEMINSTRUCTIONPOINTER_ALIGN_SIZE = 0x10, 4803 } SYSTEMINSTRUCTIONPOINTER; 4804 inline uint64_t getSystemInstructionPointer() const { 4805 return (uint64_t)TheStructure.Common.SystemInstructionPointer << SYSTEMINSTRUCTIONPOINTER_BIT_SHIFT; 4806 } 4807 inline void setSystemInstructionPointer(uint64_t value) { 4808 TheStructure.Common.SystemInstructionPointer = value >> SYSTEMINSTRUCTIONPOINTER_BIT_SHIFT; 4809 } 4810} STATE_SIP; 4811STATIC_ASSERT(12 == sizeof(STATE_SIP)); 4812 4813typedef struct tagGPGPU_CSR_BASE_ADDRESS { 4814 union tagTheStructure { 4815 struct tagCommon { 4816 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 4817 uint32_t Reserved_8 : BITFIELD_RANGE(8, 15); 4818 uint32_t _3DCommandSubOpcode : BITFIELD_RANGE(16, 23); 4819 uint32_t _3DCommandOpcode : BITFIELD_RANGE(24, 26); 4820 uint32_t CommandSubtype : BITFIELD_RANGE(27, 28); 4821 uint32_t CommandType : BITFIELD_RANGE(29, 31); 4822 uint64_t Reserved_32 : BITFIELD_RANGE(0, 11); 4823 uint64_t GpgpuCsrBaseAddress : BITFIELD_RANGE(12, 63); 4824 } Common; 4825 uint32_t RawData[3]; 4826 } TheStructure; 4827 typedef enum tagDWORD_LENGTH { 4828 DWORD_LENGTH_UNNAMED_1 = 0x1, 4829 } DWORD_LENGTH; 4830 typedef enum tag_3D_COMMAND_SUB_OPCODE { 4831 _3D_COMMAND_SUB_OPCODE_GPGPU_CSR_BASE_ADDRESS = 0x4, 4832 } _3D_COMMAND_SUB_OPCODE; 4833 typedef enum tag_3D_COMMAND_OPCODE { 4834 _3D_COMMAND_OPCODE_GFXPIPE_NONPIPELINED = 0x1, 4835 } _3D_COMMAND_OPCODE; 4836 typedef enum tagCOMMAND_SUBTYPE { 4837 COMMAND_SUBTYPE_GFXPIPE_COMMON = 0x0, 4838 } COMMAND_SUBTYPE; 4839 typedef enum tagCOMMAND_TYPE { 4840 COMMAND_TYPE_GFXPIPE = 0x3, 4841 } COMMAND_TYPE; 4842 typedef enum tagPATCH_CONSTANTS { 4843 GPGPUCSRBASEADDRESS_BYTEOFFSET = 0x4, 4844 GPGPUCSRBASEADDRESS_INDEX = 0x1, 4845 } PATCH_CONSTANTS; 4846 inline void init() { 4847 memset(&TheStructure, 0, sizeof(TheStructure)); 4848 TheStructure.Common.DwordLength = DWORD_LENGTH_UNNAMED_1; 4849 TheStructure.Common._3DCommandSubOpcode = _3D_COMMAND_SUB_OPCODE_GPGPU_CSR_BASE_ADDRESS; 4850 TheStructure.Common._3DCommandOpcode = _3D_COMMAND_OPCODE_GFXPIPE_NONPIPELINED; 4851 TheStructure.Common.CommandSubtype = COMMAND_SUBTYPE_GFXPIPE_COMMON; 4852 TheStructure.Common.CommandType = COMMAND_TYPE_GFXPIPE; 4853 } 4854 static tagGPGPU_CSR_BASE_ADDRESS sInit() { 4855 GPGPU_CSR_BASE_ADDRESS state; 4856 state.init(); 4857 return state; 4858 } 4859 inline uint32_t &getRawData(uint32_t const index) { 4860 DEBUG_BREAK_IF(index >= 3); 4861 return TheStructure.RawData[index]; 4862 } 4863 typedef enum tagGPGPUCSRBASEADDRESS { 4864 GPGPUCSRBASEADDRESS_BIT_SHIFT = 0xC, 4865 GPGPUCSRBASEADDRESS_ALIGN_SIZE = 0x1000, 4866 } GPGPUCSRBASEADDRESS; 4867 inline uint64_t getGpgpuCsrBaseAddress() const { 4868 return (uint64_t)TheStructure.Common.GpgpuCsrBaseAddress << GPGPUCSRBASEADDRESS_BIT_SHIFT; 4869 } 4870 inline void setGpgpuCsrBaseAddress(uint64_t value) { 4871 TheStructure.Common.GpgpuCsrBaseAddress = value >> GPGPUCSRBASEADDRESS_BIT_SHIFT; 4872 } 4873} GPGPU_CSR_BASE_ADDRESS; 4874STATIC_ASSERT(12 == sizeof(GPGPU_CSR_BASE_ADDRESS)); 4875 4876typedef struct tagSAMPLER_BORDER_COLOR_STATE { 4877 union tagTheStructure { 4878 struct tagCommon { 4879 // DWORD 0 4880 float BorderColorRed; 4881 // DWORD 1 4882 float BorderColorGreen; 4883 // DWORD 2 4884 float BorderColorBlue; 4885 // DWORD 3 4886 float BorderColorAlpha; 4887 } Common; 4888 uint32_t RawData[4]; 4889 } TheStructure; 4890 inline void init() { 4891 memset(&TheStructure, 0, sizeof(TheStructure)); 4892 TheStructure.Common.BorderColorRed = 0.0; 4893 TheStructure.Common.BorderColorGreen = 0.0; 4894 TheStructure.Common.BorderColorBlue = 0.0; 4895 TheStructure.Common.BorderColorAlpha = 0.0; 4896 } 4897 static tagSAMPLER_BORDER_COLOR_STATE sInit() { 4898 SAMPLER_BORDER_COLOR_STATE state; 4899 state.init(); 4900 return state; 4901 } 4902 inline uint32_t &getRawData(const uint32_t index) { 4903 UNRECOVERABLE_IF(index >= 4); 4904 return TheStructure.RawData[index]; 4905 } 4906 inline void setBorderColorRed(const float value) { 4907 TheStructure.Common.BorderColorRed = value; 4908 } 4909 inline float getBorderColorRed() const { 4910 return TheStructure.Common.BorderColorRed; 4911 } 4912 inline void setBorderColorGreen(const float value) { 4913 TheStructure.Common.BorderColorGreen = value; 4914 } 4915 inline float getBorderColorGreen() const { 4916 return TheStructure.Common.BorderColorGreen; 4917 } 4918 inline void setBorderColorBlue(const float value) { 4919 TheStructure.Common.BorderColorBlue = value; 4920 } 4921 inline float getBorderColorBlue() const { 4922 return TheStructure.Common.BorderColorBlue; 4923 } 4924 inline void setBorderColorAlpha(const float value) { 4925 TheStructure.Common.BorderColorAlpha = value; 4926 } 4927 inline float getBorderColorAlpha() const { 4928 return TheStructure.Common.BorderColorAlpha; 4929 } 4930} SAMPLER_BORDER_COLOR_STATE; 4931STATIC_ASSERT(16 == sizeof(SAMPLER_BORDER_COLOR_STATE)); 4932 4933#pragma pack() 4934