1/* 2 * Copyright (C) 2021 Intel Corporation 3 * 4 * SPDX-License-Identifier: MIT 5 * 6 */ 7 8#pragma pack(1) 9 10typedef struct tagBINDING_TABLE_STATE { 11 union tagTheStructure { 12 struct tagCommon { 13 uint32_t Reserved_0 : BITFIELD_RANGE(0, 5); 14 uint32_t SurfaceStatePointer : BITFIELD_RANGE(6, 31); 15 } Common; 16 uint32_t RawData[1]; 17 } TheStructure; 18 typedef enum tagPATCH_CONSTANTS { 19 SURFACESTATEPOINTER_BYTEOFFSET = 0x0, 20 SURFACESTATEPOINTER_INDEX = 0x0, 21 } PATCH_CONSTANTS; 22 inline void init() { 23 memset(&TheStructure, 0, sizeof(TheStructure)); 24 } 25 static tagBINDING_TABLE_STATE sInit() { 26 BINDING_TABLE_STATE state; 27 state.init(); 28 return state; 29 } 30 inline uint32_t &getRawData(const uint32_t index) { 31 DEBUG_BREAK_IF(index >= 1); 32 return TheStructure.RawData[index]; 33 } 34 inline const uint32_t &getRawData(const uint32_t index) const { 35 DEBUG_BREAK_IF(index >= 1); 36 return TheStructure.RawData[index]; 37 } 38 typedef enum tagSURFACESTATEPOINTER { 39 SURFACESTATEPOINTER_BIT_SHIFT = 0x6, 40 SURFACESTATEPOINTER_ALIGN_SIZE = 0x40, 41 } SURFACESTATEPOINTER; 42 inline void setSurfaceStatePointer(const uint64_t value) { 43 DEBUG_BREAK_IF(value >= 0x100000000); 44 TheStructure.Common.SurfaceStatePointer = (uint32_t)value >> SURFACESTATEPOINTER_BIT_SHIFT; 45 } 46 inline uint32_t getSurfaceStatePointer() const { 47 return (TheStructure.Common.SurfaceStatePointer << SURFACESTATEPOINTER_BIT_SHIFT); 48 } 49} BINDING_TABLE_STATE; 50STATIC_ASSERT(4 == sizeof(BINDING_TABLE_STATE)); 51 52typedef struct tagMEDIA_SURFACE_STATE { 53 union tagTheStructure { 54 struct tagCommon { 55 uint32_t Reserved_0 : BITFIELD_RANGE(0, 29); 56 uint32_t Rotation : BITFIELD_RANGE(30, 31); 57 uint32_t Cr_VCb_UPixelOffsetVDirection : BITFIELD_RANGE(0, 1); 58 uint32_t PictureStructure : BITFIELD_RANGE(2, 3); 59 uint32_t Width : BITFIELD_RANGE(4, 17); 60 uint32_t Height : BITFIELD_RANGE(18, 31); 61 uint32_t TileMode : BITFIELD_RANGE(0, 1); 62 uint32_t HalfPitchForChroma : BITFIELD_RANGE(2, 2); 63 uint32_t SurfacePitch : BITFIELD_RANGE(3, 20); 64 uint32_t AddressControl : BITFIELD_RANGE(21, 21); 65 uint32_t MemoryCompressionEnable : BITFIELD_RANGE(22, 22); 66 uint32_t MemoryCompressionMode : BITFIELD_RANGE(23, 23); 67 uint32_t Cr_VCb_UPixelOffsetVDirectionMsb : BITFIELD_RANGE(24, 24); 68 uint32_t Cr_VCb_UPixelOffsetUDirection : BITFIELD_RANGE(25, 25); 69 uint32_t InterleaveChroma : BITFIELD_RANGE(26, 26); 70 uint32_t SurfaceFormat : BITFIELD_RANGE(27, 31); 71 uint32_t YOffsetForU_Cb : BITFIELD_RANGE(0, 13); 72 uint32_t Reserved_110 : BITFIELD_RANGE(14, 15); 73 uint32_t XOffsetForU_Cb : BITFIELD_RANGE(16, 29); 74 uint32_t Reserved_126 : BITFIELD_RANGE(30, 31); 75 uint32_t Reserved_128; 76 uint32_t SurfaceMemoryObjectControlState_Reserved : BITFIELD_RANGE(0, 0); 77 uint32_t SurfaceMemoryObjectControlState_IndexToMocsTables : BITFIELD_RANGE(1, 6); 78 uint32_t Reserved_167 : BITFIELD_RANGE(7, 17); 79 uint32_t TiledResourceMode : BITFIELD_RANGE(18, 19); 80 uint32_t Depth : BITFIELD_RANGE(20, 23); 81 uint32_t Reserved_184 : BITFIELD_RANGE(24, 29); 82 uint32_t VerticalLineStrideOffset : BITFIELD_RANGE(30, 30); 83 uint32_t VerticalLineStride : BITFIELD_RANGE(31, 31); 84 uint32_t SurfaceBaseAddressLow; 85 uint32_t SurfaceBaseAddressHigh : BITFIELD_RANGE(0, 15); 86 uint32_t Reserved_240 : BITFIELD_RANGE(16, 31); 87 } Common; 88 struct tagSurfaceFormatIsNotOneOfPlanarFormats { 89 uint32_t Reserved_0; 90 uint32_t Reserved_32; 91 uint32_t Reserved_64; 92 uint32_t Reserved_96; 93 uint32_t Reserved_128; 94 uint32_t Reserved_160; 95 uint32_t Reserved_192; 96 uint32_t Reserved_224; 97 } SurfaceFormatIsNotOneOfPlanarFormats; 98 struct tagSurfaceFormatIsOneOfPlanarFormats { 99 uint32_t Reserved_0 : BITFIELD_RANGE(0, 15); 100 uint32_t YOffset : BITFIELD_RANGE(16, 19); 101 uint32_t XOffset : BITFIELD_RANGE(20, 26); 102 uint32_t Reserved_27 : BITFIELD_RANGE(27, 31); 103 uint32_t Reserved_32; 104 uint32_t Reserved_64; 105 uint32_t Reserved_96; 106 uint32_t Reserved_128; 107 uint32_t Reserved_160; 108 uint32_t Reserved_192; 109 uint32_t Reserved_224; 110 } SurfaceFormatIsOneOfPlanarFormats; 111 struct tag_SurfaceFormatIsOneOfPlanarAnd_InterleaveChromaIs0 { 112 uint32_t Reserved_0; 113 uint32_t Reserved_32; 114 uint32_t Reserved_64; 115 uint32_t Reserved_96; 116 uint32_t YOffsetForV_Cr : BITFIELD_RANGE(0, 14); 117 uint32_t Reserved_143 : BITFIELD_RANGE(15, 15); 118 uint32_t XOffsetForV_Cr : BITFIELD_RANGE(16, 29); 119 uint32_t Reserved_158 : BITFIELD_RANGE(30, 31); 120 uint32_t Reserved_160; 121 uint32_t Reserved_192; 122 uint32_t Reserved_224; 123 } _SurfaceFormatIsOneOfPlanarAnd_InterleaveChromaIs0; 124 uint32_t RawData[8]; 125 } TheStructure; 126 typedef enum tagROTATION { 127 ROTATION_NO_ROTATION_OR_0_DEGREE = 0x0, 128 ROTATION_90_DEGREE_ROTATION = 0x1, 129 ROTATION_180_DEGREE_ROTATION = 0x2, 130 ROTATION_270_DEGREE_ROTATION = 0x3, 131 } ROTATION; 132 typedef enum tagPICTURE_STRUCTURE { 133 PICTURE_STRUCTURE_FRAME_PICTURE = 0x0, 134 PICTURE_STRUCTURE_TOP_FIELD_PICTURE = 0x1, 135 PICTURE_STRUCTURE_BOTTOM_FIELD_PICTURE = 0x2, 136 PICTURE_STRUCTURE_INVALID_NOT_ALLOWED = 0x3, 137 } PICTURE_STRUCTURE; 138 typedef enum tagTILE_MODE { 139 TILE_MODE_TILEMODE_LINEAR = 0x0, 140 TILE_MODE_TILEMODE_XMAJOR = 0x2, 141 TILE_MODE_TILEMODE_YMAJOR = 0x3, 142 } TILE_MODE; 143 typedef enum tagADDRESS_CONTROL { 144 ADDRESS_CONTROL_CLAMP = 0x0, 145 ADDRESS_CONTROL_MIRROR = 0x1, 146 } ADDRESS_CONTROL; 147 typedef enum tagMEMORY_COMPRESSION_MODE { 148 MEMORY_COMPRESSION_MODE_HORIZONTAL_COMPRESSION_MODE = 0x0, 149 MEMORY_COMPRESSION_MODE_VERTICAL_COMPRESSION_MODE = 0x1, 150 } MEMORY_COMPRESSION_MODE; 151 typedef enum tagSURFACE_FORMAT { 152 SURFACE_FORMAT_YCRCB_NORMAL = 0x0, 153 SURFACE_FORMAT_YCRCB_SWAPUVY = 0x1, 154 SURFACE_FORMAT_YCRCB_SWAPUV = 0x2, 155 SURFACE_FORMAT_YCRCB_SWAPY = 0x3, 156 SURFACE_FORMAT_PLANAR_420_8 = 0x4, 157 SURFACE_FORMAT_Y8_UNORM_VA = 0x5, 158 SURFACE_FORMAT_Y16_SNORM = 0x6, 159 SURFACE_FORMAT_Y16_UNORM_VA = 0x7, 160 SURFACE_FORMAT_R10G10B10A2_UNORM = 0x8, 161 SURFACE_FORMAT_R8G8B8A8_UNORM = 0x9, 162 SURFACE_FORMAT_R8B8_UNORM_CRCB = 0xa, 163 SURFACE_FORMAT_R8_UNORM_CR_CB = 0xb, 164 SURFACE_FORMAT_Y8_UNORM = 0xc, 165 SURFACE_FORMAT_A8Y8U8V8_UNORM = 0xd, 166 SURFACE_FORMAT_B8G8R8A8_UNORM = 0xe, 167 SURFACE_FORMAT_R16G16B16A16 = 0xf, 168 SURFACE_FORMAT_Y1_UNORM = 0x10, 169 SURFACE_FORMAT_Y32_UNORM = 0x11, 170 SURFACE_FORMAT_PLANAR_422_8 = 0x12, 171 SURFACE_FORMAT_FM_STRBUF_Y1 = 0x13, 172 SURFACE_FORMAT_FM_STRBUF_Y8 = 0x14, 173 SURFACE_FORMAT_FM_STRBUF_Y16 = 0x15, 174 SURFACE_FORMAT_FM_STRBUF_Y32 = 0x16, 175 SURFACE_FORMAT_PLANAR_420_16 = 0x17, 176 SURFACE_FORMAT_R16B16_UNORM_CRCB = 0x18, 177 SURFACE_FORMAT_R16_UNORM_CR_CB = 0x19, 178 SURFACE_FORMAT_Y16_UNORM = 0x1a, 179 } SURFACE_FORMAT; 180 typedef enum tagSURFACE_MEMORY_OBJECT_CONTROL_STATE { 181 SURFACE_MEMORY_OBJECT_CONTROL_STATE_DEFAULTVAUEDESC = 0x0, 182 } SURFACE_MEMORY_OBJECT_CONTROL_STATE; 183 typedef enum tagTILED_RESOURCE_MODE { 184 TILED_RESOURCE_MODE_TRMODE_NONE = 0x0, 185 TILED_RESOURCE_MODE_TRMODE_TILEYF = 0x1, 186 TILED_RESOURCE_MODE_TRMODE_TILEYS = 0x2, 187 } TILED_RESOURCE_MODE; 188 typedef enum tagPATCH_CONSTANTS { 189 SURFACEBASEADDRESS_BYTEOFFSET = 0x18, 190 SURFACEBASEADDRESS_INDEX = 0x6, 191 SURFACEBASEADDRESSHIGH_BYTEOFFSET = 0x1c, 192 SURFACEBASEADDRESSHIGH_INDEX = 0x7, 193 } PATCH_CONSTANTS; 194 inline void init() { 195 memset(&TheStructure, 0, sizeof(TheStructure)); 196 TheStructure.Common.Rotation = ROTATION_NO_ROTATION_OR_0_DEGREE; 197 TheStructure.Common.PictureStructure = PICTURE_STRUCTURE_FRAME_PICTURE; 198 TheStructure.Common.TileMode = TILE_MODE_TILEMODE_LINEAR; 199 TheStructure.Common.AddressControl = ADDRESS_CONTROL_CLAMP; 200 TheStructure.Common.MemoryCompressionMode = MEMORY_COMPRESSION_MODE_HORIZONTAL_COMPRESSION_MODE; 201 TheStructure.Common.SurfaceFormat = SURFACE_FORMAT_YCRCB_NORMAL; 202 TheStructure.Common.TiledResourceMode = TILED_RESOURCE_MODE_TRMODE_NONE; 203 } 204 static tagMEDIA_SURFACE_STATE sInit() { 205 MEDIA_SURFACE_STATE state; 206 state.init(); 207 return state; 208 } 209 inline uint32_t &getRawData(const uint32_t index) { 210 DEBUG_BREAK_IF(index >= 8); 211 return TheStructure.RawData[index]; 212 } 213 inline void setRotation(const ROTATION value) { 214 TheStructure.Common.Rotation = value; 215 } 216 inline ROTATION getRotation() const { 217 return static_cast<ROTATION>(TheStructure.Common.Rotation); 218 } 219 inline void setCrVCbUPixelOffsetVDirection(const uint32_t value) { 220 TheStructure.Common.Cr_VCb_UPixelOffsetVDirection = value; 221 } 222 inline uint32_t getCrVCbUPixelOffsetVDirection() const { 223 return (TheStructure.Common.Cr_VCb_UPixelOffsetVDirection); 224 } 225 inline void setPictureStructure(const PICTURE_STRUCTURE value) { 226 TheStructure.Common.PictureStructure = value; 227 } 228 inline PICTURE_STRUCTURE getPictureStructure() const { 229 return static_cast<PICTURE_STRUCTURE>(TheStructure.Common.PictureStructure); 230 } 231 inline void setWidth(const uint32_t value) { 232 TheStructure.Common.Width = value - 1; 233 } 234 inline uint32_t getWidth() const { 235 return (TheStructure.Common.Width + 1); 236 } 237 inline void setHeight(const uint32_t value) { 238 TheStructure.Common.Height = value - 1; 239 } 240 inline uint32_t getHeight() const { 241 return (TheStructure.Common.Height + 1); 242 } 243 inline void setTileMode(const TILE_MODE value) { 244 TheStructure.Common.TileMode = value; 245 } 246 inline TILE_MODE getTileMode() const { 247 return static_cast<TILE_MODE>(TheStructure.Common.TileMode); 248 } 249 inline void setHalfPitchForChroma(const bool value) { 250 TheStructure.Common.HalfPitchForChroma = value; 251 } 252 inline bool getHalfPitchForChroma() const { 253 return (TheStructure.Common.HalfPitchForChroma); 254 } 255 inline void setSurfacePitch(const uint32_t value) { 256 TheStructure.Common.SurfacePitch = value - 1; 257 } 258 inline uint32_t getSurfacePitch() const { 259 return (TheStructure.Common.SurfacePitch + 1); 260 } 261 inline void setAddressControl(const ADDRESS_CONTROL value) { 262 TheStructure.Common.AddressControl = value; 263 } 264 inline ADDRESS_CONTROL getAddressControl() const { 265 return static_cast<ADDRESS_CONTROL>(TheStructure.Common.AddressControl); 266 } 267 inline void setMemoryCompressionEnable(const bool value) { 268 TheStructure.Common.MemoryCompressionEnable = value; 269 } 270 inline bool getMemoryCompressionEnable() const { 271 return (TheStructure.Common.MemoryCompressionEnable); 272 } 273 inline void setMemoryCompressionMode(const MEMORY_COMPRESSION_MODE value) { 274 TheStructure.Common.MemoryCompressionMode = value; 275 } 276 inline MEMORY_COMPRESSION_MODE getMemoryCompressionMode() const { 277 return static_cast<MEMORY_COMPRESSION_MODE>(TheStructure.Common.MemoryCompressionMode); 278 } 279 inline void setCrVCbUPixelOffsetVDirectionMsb(const uint32_t value) { 280 TheStructure.Common.Cr_VCb_UPixelOffsetVDirectionMsb = value; 281 } 282 inline uint32_t getCrVCbUPixelOffsetVDirectionMsb() const { 283 return (TheStructure.Common.Cr_VCb_UPixelOffsetVDirectionMsb); 284 } 285 inline void setCrVCbUPixelOffsetUDirection(const uint32_t value) { 286 TheStructure.Common.Cr_VCb_UPixelOffsetUDirection = value; 287 } 288 inline uint32_t getCrVCbUPixelOffsetUDirection() const { 289 return (TheStructure.Common.Cr_VCb_UPixelOffsetUDirection); 290 } 291 inline void setInterleaveChroma(const bool value) { 292 TheStructure.Common.InterleaveChroma = value; 293 } 294 inline bool getInterleaveChroma() const { 295 return (TheStructure.Common.InterleaveChroma); 296 } 297 inline void setSurfaceFormat(const SURFACE_FORMAT value) { 298 TheStructure.Common.SurfaceFormat = value; 299 } 300 inline SURFACE_FORMAT getSurfaceFormat() const { 301 return static_cast<SURFACE_FORMAT>(TheStructure.Common.SurfaceFormat); 302 } 303 inline void setYOffsetForUCb(const uint32_t value) { 304 TheStructure.Common.YOffsetForU_Cb = value; 305 } 306 inline uint32_t getYOffsetForUCb() const { 307 return (TheStructure.Common.YOffsetForU_Cb); 308 } 309 inline void setXOffsetForUCb(const uint32_t value) { 310 TheStructure.Common.XOffsetForU_Cb = value; 311 } 312 inline uint32_t getXOffsetForUCb() const { 313 return (TheStructure.Common.XOffsetForU_Cb); 314 } 315 inline void setSurfaceMemoryObjectControlStateReserved(const uint32_t value) { 316 TheStructure.Common.SurfaceMemoryObjectControlState_Reserved = value; 317 } 318 inline uint32_t getSurfaceMemoryObjectControlStateReserved() const { 319 return (TheStructure.Common.SurfaceMemoryObjectControlState_Reserved); 320 } 321 inline void setSurfaceMemoryObjectControlState(const uint32_t value) { 322 TheStructure.Common.SurfaceMemoryObjectControlState_IndexToMocsTables = value >> 1; 323 } 324 inline uint32_t getSurfaceMemoryObjectControlState() const { 325 return (TheStructure.Common.SurfaceMemoryObjectControlState_IndexToMocsTables << 1); 326 } 327 inline void setTiledResourceMode(const TILED_RESOURCE_MODE value) { 328 TheStructure.Common.TiledResourceMode = value; 329 } 330 inline TILED_RESOURCE_MODE getTiledResourceMode() const { 331 return static_cast<TILED_RESOURCE_MODE>(TheStructure.Common.TiledResourceMode); 332 } 333 inline void setDepth(const uint32_t value) { 334 TheStructure.Common.Depth = value; 335 } 336 inline uint32_t getDepth() const { 337 return (TheStructure.Common.Depth); 338 } 339 inline void setVerticalLineStrideOffset(const uint32_t value) { 340 TheStructure.Common.VerticalLineStrideOffset = value; 341 } 342 inline uint32_t getVerticalLineStrideOffset() const { 343 return (TheStructure.Common.VerticalLineStrideOffset); 344 } 345 inline void setVerticalLineStride(const uint32_t value) { 346 TheStructure.Common.VerticalLineStride = value; 347 } 348 inline uint32_t getVerticalLineStride() const { 349 return (TheStructure.Common.VerticalLineStride); 350 } 351 inline void setSurfaceBaseAddress(const uint64_t value) { 352 TheStructure.Common.SurfaceBaseAddressLow = static_cast<uint32_t>(value & 0xffffffff); 353 TheStructure.Common.SurfaceBaseAddressHigh = (value >> 32) & 0xffffffff; 354 } 355 inline uint64_t getSurfaceBaseAddress() const { 356 return (TheStructure.Common.SurfaceBaseAddressLow | 357 static_cast<uint64_t>(TheStructure.Common.SurfaceBaseAddressHigh) << 32); 358 } 359 inline void setSurfaceBaseAddressHigh(const uint32_t value) { 360 TheStructure.Common.SurfaceBaseAddressHigh = value; 361 } 362 inline uint32_t getSurfaceBaseAddressHigh() const { 363 return (TheStructure.Common.SurfaceBaseAddressHigh); 364 } 365 typedef enum tagYOFFSET { 366 YOFFSET_BIT_SHIFT = 0x2, 367 YOFFSET_ALIGN_SIZE = 0x4, 368 } YOFFSET; 369 inline void setYOffset(const uint32_t value) { 370 TheStructure.SurfaceFormatIsOneOfPlanarFormats.YOffset = value >> YOFFSET_BIT_SHIFT; 371 } 372 inline uint32_t getYOffset() const { 373 return (TheStructure.SurfaceFormatIsOneOfPlanarFormats.YOffset << YOFFSET_BIT_SHIFT); 374 } 375 typedef enum tagXOFFSET { 376 XOFFSET_BIT_SHIFT = 0x2, 377 XOFFSET_ALIGN_SIZE = 0x4, 378 } XOFFSET; 379 inline void setXOffset(const uint32_t value) { 380 TheStructure.SurfaceFormatIsOneOfPlanarFormats.XOffset = value >> XOFFSET_BIT_SHIFT; 381 } 382 inline uint32_t getXOffset() const { 383 return (TheStructure.SurfaceFormatIsOneOfPlanarFormats.XOffset << XOFFSET_BIT_SHIFT); 384 } 385 inline void setYOffsetForVCr(const uint32_t value) { 386 TheStructure._SurfaceFormatIsOneOfPlanarAnd_InterleaveChromaIs0.YOffsetForV_Cr = value; 387 } 388 inline uint32_t getYOffsetForVCr() const { 389 return (TheStructure._SurfaceFormatIsOneOfPlanarAnd_InterleaveChromaIs0.YOffsetForV_Cr); 390 } 391 inline void setXOffsetForVCr(const uint32_t value) { 392 TheStructure._SurfaceFormatIsOneOfPlanarAnd_InterleaveChromaIs0.XOffsetForV_Cr = value; 393 } 394 inline uint32_t getXOffsetForVCr() const { 395 return (TheStructure._SurfaceFormatIsOneOfPlanarAnd_InterleaveChromaIs0.XOffsetForV_Cr); 396 } 397} MEDIA_SURFACE_STATE; 398STATIC_ASSERT(32 == sizeof(MEDIA_SURFACE_STATE)); 399 400typedef struct tagMI_MATH { 401 union _DW0 { 402 struct _BitField { 403 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 404 uint32_t Reserved : BITFIELD_RANGE(8, 22); 405 uint32_t InstructionOpcode : BITFIELD_RANGE(23, 28); 406 uint32_t InstructionType : BITFIELD_RANGE(29, 31); 407 } BitField; 408 uint32_t Value; 409 } DW0; 410 typedef enum tagMI_COMMAND_OPCODE { 411 MI_COMMAND_OPCODE_MI_MATH = 0x1A, 412 } MI_COMMAND_OPCODE; 413 typedef enum tagCOMMAND_TYPE { 414 COMMAND_TYPE_MI_COMMAND = 0x0, 415 } COMMAND_TYPE; 416} MI_MATH; 417 418typedef struct tagMI_MATH_ALU_INST_INLINE { 419 union _DW0 { 420 struct _BitField { 421 uint32_t Operand2 : BITFIELD_RANGE(0, 9); 422 uint32_t Operand1 : BITFIELD_RANGE(10, 19); 423 uint32_t ALUOpcode : BITFIELD_RANGE(20, 31); 424 } BitField; 425 uint32_t Value; 426 } DW0; 427} MI_MATH_ALU_INST_INLINE; 428 429typedef struct tagPIPE_CONTROL { 430 union tagTheStructure { 431 struct tagCommon { 432 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 433 uint32_t PredicateEnable : BITFIELD_RANGE(8, 8); 434 uint32_t HdcPipelineFlush : BITFIELD_RANGE(9, 9); 435 uint32_t Reserved_10 : BITFIELD_RANGE(10, 12); 436 uint32_t CompressionControlSurfaceCcsFlush : BITFIELD_RANGE(13, 13); 437 uint32_t WorkloadPartitionIdOffsetEnable : BITFIELD_RANGE(14, 14); 438 uint32_t Reserved_15 : BITFIELD_RANGE(15, 15); 439 uint32_t _3DCommandSubOpcode : BITFIELD_RANGE(16, 23); 440 uint32_t _3DCommandOpcode : BITFIELD_RANGE(24, 26); 441 uint32_t CommandSubtype : BITFIELD_RANGE(27, 28); 442 uint32_t CommandType : BITFIELD_RANGE(29, 31); 443 uint32_t DepthCacheFlushEnable : BITFIELD_RANGE(0, 0); 444 uint32_t StallAtPixelScoreboard : BITFIELD_RANGE(1, 1); 445 uint32_t StateCacheInvalidationEnable : BITFIELD_RANGE(2, 2); 446 uint32_t ConstantCacheInvalidationEnable : BITFIELD_RANGE(3, 3); 447 uint32_t VfCacheInvalidationEnable : BITFIELD_RANGE(4, 4); 448 uint32_t DcFlushEnable : BITFIELD_RANGE(5, 5); 449 uint32_t ProtectedMemoryApplicationId : BITFIELD_RANGE(6, 6); 450 uint32_t PipeControlFlushEnable : BITFIELD_RANGE(7, 7); 451 uint32_t NotifyEnable : BITFIELD_RANGE(8, 8); 452 uint32_t IndirectStatePointersDisable : BITFIELD_RANGE(9, 9); 453 uint32_t TextureCacheInvalidationEnable : BITFIELD_RANGE(10, 10); 454 uint32_t InstructionCacheInvalidateEnable : BITFIELD_RANGE(11, 11); 455 uint32_t RenderTargetCacheFlushEnable : BITFIELD_RANGE(12, 12); 456 uint32_t DepthStallEnable : BITFIELD_RANGE(13, 13); 457 uint32_t PostSyncOperation : BITFIELD_RANGE(14, 15); 458 uint32_t GenericMediaStateClear : BITFIELD_RANGE(16, 16); 459 uint32_t PssStallSyncEnable : BITFIELD_RANGE(17, 17); 460 uint32_t TlbInvalidate : BITFIELD_RANGE(18, 18); 461 uint32_t DepthStallSyncEnable : BITFIELD_RANGE(19, 19); 462 uint32_t CommandStreamerStallEnable : BITFIELD_RANGE(20, 20); 463 uint32_t StoreDataIndex : BITFIELD_RANGE(21, 21); 464 uint32_t ProtectedMemoryEnable : BITFIELD_RANGE(22, 22); 465 uint32_t LriPostSyncOperation : BITFIELD_RANGE(23, 23); 466 uint32_t DestinationAddressType : BITFIELD_RANGE(24, 24); 467 uint32_t AmfsFlushEnable : BITFIELD_RANGE(25, 25); 468 uint32_t FlushLlc : BITFIELD_RANGE(26, 26); 469 uint32_t ProtectedMemoryDisable : BITFIELD_RANGE(27, 27); 470 uint32_t TileCacheFlushEnable : BITFIELD_RANGE(28, 28); 471 uint32_t Reserved_61 : BITFIELD_RANGE(29, 29); 472 uint32_t L3FabricFlush : BITFIELD_RANGE(30, 30); 473 uint32_t TbimrForceBatchClosure : BITFIELD_RANGE(31, 31); 474 uint32_t Reserved_64 : BITFIELD_RANGE(0, 1); 475 uint32_t Address : BITFIELD_RANGE(2, 31); 476 uint32_t AddressHigh; 477 uint64_t ImmediateData; 478 } Common; 479 uint32_t RawData[6]; 480 } TheStructure; 481 typedef enum tagDWORD_LENGTH { 482 DWORD_LENGTH_DWORD_COUNT_N = 0x4, 483 } DWORD_LENGTH; 484 typedef enum tag_3D_COMMAND_SUB_OPCODE { 485 _3D_COMMAND_SUB_OPCODE_PIPE_CONTROL = 0x0, 486 } _3D_COMMAND_SUB_OPCODE; 487 typedef enum tag_3D_COMMAND_OPCODE { 488 _3D_COMMAND_OPCODE_PIPE_CONTROL = 0x2, 489 } _3D_COMMAND_OPCODE; 490 typedef enum tagCOMMAND_SUBTYPE { 491 COMMAND_SUBTYPE_GFXPIPE_3D = 0x3, 492 } COMMAND_SUBTYPE; 493 typedef enum tagCOMMAND_TYPE { 494 COMMAND_TYPE_GFXPIPE = 0x3, 495 } COMMAND_TYPE; 496 typedef enum tagPOST_SYNC_OPERATION { 497 POST_SYNC_OPERATION_NO_WRITE = 0x0, 498 POST_SYNC_OPERATION_WRITE_IMMEDIATE_DATA = 0x1, 499 POST_SYNC_OPERATION_WRITE_PS_DEPTH_COUNT = 0x2, 500 POST_SYNC_OPERATION_WRITE_TIMESTAMP = 0x3, 501 } POST_SYNC_OPERATION; 502 typedef enum tagLRI_POST_SYNC_OPERATION { 503 LRI_POST_SYNC_OPERATION_NO_LRI_OPERATION = 0x0, 504 LRI_POST_SYNC_OPERATION_MMIO_WRITE_IMMEDIATE_DATA = 0x1, 505 } LRI_POST_SYNC_OPERATION; 506 typedef enum tagDESTINATION_ADDRESS_TYPE { 507 DESTINATION_ADDRESS_TYPE_PPGTT = 0x0, 508 DESTINATION_ADDRESS_TYPE_GGTT = 0x1, 509 } DESTINATION_ADDRESS_TYPE; 510 typedef enum tagTBIMR_FORCE_BATCH_CLOSURE { 511 TBIMR_FORCE_BATCH_CLOSURE_NO_BATCH_CLOSURE = 0x0, 512 TBIMR_FORCE_BATCH_CLOSURE_CLOSE_BATCH = 0x1, 513 } TBIMR_FORCE_BATCH_CLOSURE; 514 inline void init() { 515 memset(&TheStructure, 0, sizeof(TheStructure)); 516 TheStructure.Common.DwordLength = DWORD_LENGTH_DWORD_COUNT_N; 517 TheStructure.Common._3DCommandSubOpcode = _3D_COMMAND_SUB_OPCODE_PIPE_CONTROL; 518 TheStructure.Common._3DCommandOpcode = _3D_COMMAND_OPCODE_PIPE_CONTROL; 519 TheStructure.Common.CommandSubtype = COMMAND_SUBTYPE_GFXPIPE_3D; 520 TheStructure.Common.CommandType = COMMAND_TYPE_GFXPIPE; 521 TheStructure.Common.PostSyncOperation = POST_SYNC_OPERATION_NO_WRITE; 522 TheStructure.Common.LriPostSyncOperation = LRI_POST_SYNC_OPERATION_NO_LRI_OPERATION; 523 TheStructure.Common.DestinationAddressType = DESTINATION_ADDRESS_TYPE_PPGTT; 524 TheStructure.Common.TbimrForceBatchClosure = TBIMR_FORCE_BATCH_CLOSURE_NO_BATCH_CLOSURE; 525 TheStructure.Common.CommandStreamerStallEnable = 1; 526 } 527 static tagPIPE_CONTROL sInit() { 528 PIPE_CONTROL state; 529 state.init(); 530 return state; 531 } 532 inline uint32_t &getRawData(const uint32_t index) { 533 UNRECOVERABLE_IF(index >= 6); 534 return TheStructure.RawData[index]; 535 } 536 inline void setPredicateEnable(const bool value) { 537 TheStructure.Common.PredicateEnable = value; 538 } 539 inline bool getPredicateEnable() const { 540 return TheStructure.Common.PredicateEnable; 541 } 542 inline void setHdcPipelineFlush(const bool value) { 543 TheStructure.Common.HdcPipelineFlush = value; 544 } 545 inline bool getHdcPipelineFlush() const { 546 return TheStructure.Common.HdcPipelineFlush; 547 } 548 inline void setCompressionControlSurfaceCcsFlush(const bool value) { 549 TheStructure.Common.CompressionControlSurfaceCcsFlush = value; 550 } 551 inline bool getCompressionControlSurfaceCcsFlush() const { 552 return TheStructure.Common.CompressionControlSurfaceCcsFlush; 553 } 554 inline void setWorkloadPartitionIdOffsetEnable(const bool value) { 555 TheStructure.Common.WorkloadPartitionIdOffsetEnable = value; 556 } 557 inline bool getWorkloadPartitionIdOffsetEnable() const { 558 return TheStructure.Common.WorkloadPartitionIdOffsetEnable; 559 } 560 inline void setDepthCacheFlushEnable(const bool value) { 561 TheStructure.Common.DepthCacheFlushEnable = value; 562 } 563 inline bool getDepthCacheFlushEnable() const { 564 return TheStructure.Common.DepthCacheFlushEnable; 565 } 566 inline void setStallAtPixelScoreboard(const bool value) { 567 TheStructure.Common.StallAtPixelScoreboard = value; 568 } 569 inline bool getStallAtPixelScoreboard() const { 570 return TheStructure.Common.StallAtPixelScoreboard; 571 } 572 inline void setStateCacheInvalidationEnable(const bool value) { 573 TheStructure.Common.StateCacheInvalidationEnable = value; 574 } 575 inline bool getStateCacheInvalidationEnable() const { 576 return TheStructure.Common.StateCacheInvalidationEnable; 577 } 578 inline void setConstantCacheInvalidationEnable(const bool value) { 579 TheStructure.Common.ConstantCacheInvalidationEnable = value; 580 } 581 inline bool getConstantCacheInvalidationEnable() const { 582 return TheStructure.Common.ConstantCacheInvalidationEnable; 583 } 584 inline void setVfCacheInvalidationEnable(const bool value) { 585 TheStructure.Common.VfCacheInvalidationEnable = value; 586 } 587 inline bool getVfCacheInvalidationEnable() const { 588 return TheStructure.Common.VfCacheInvalidationEnable; 589 } 590 inline void setDcFlushEnable(const bool value) { 591 TheStructure.Common.DcFlushEnable = value; 592 } 593 inline bool getDcFlushEnable() const { 594 return TheStructure.Common.DcFlushEnable; 595 } 596 inline void setProtectedMemoryApplicationId(const bool value) { 597 TheStructure.Common.ProtectedMemoryApplicationId = value; 598 } 599 inline bool getProtectedMemoryApplicationId() const { 600 return TheStructure.Common.ProtectedMemoryApplicationId; 601 } 602 inline void setPipeControlFlushEnable(const bool value) { 603 TheStructure.Common.PipeControlFlushEnable = value; 604 } 605 inline bool getPipeControlFlushEnable() const { 606 return TheStructure.Common.PipeControlFlushEnable; 607 } 608 inline void setNotifyEnable(const bool value) { 609 TheStructure.Common.NotifyEnable = value; 610 } 611 inline bool getNotifyEnable() const { 612 return TheStructure.Common.NotifyEnable; 613 } 614 inline void setIndirectStatePointersDisable(const bool value) { 615 TheStructure.Common.IndirectStatePointersDisable = value; 616 } 617 inline bool getIndirectStatePointersDisable() const { 618 return TheStructure.Common.IndirectStatePointersDisable; 619 } 620 inline void setTextureCacheInvalidationEnable(const bool value) { 621 TheStructure.Common.TextureCacheInvalidationEnable = value; 622 } 623 inline bool getTextureCacheInvalidationEnable() const { 624 return TheStructure.Common.TextureCacheInvalidationEnable; 625 } 626 inline void setInstructionCacheInvalidateEnable(const bool value) { 627 TheStructure.Common.InstructionCacheInvalidateEnable = value; 628 } 629 inline bool getInstructionCacheInvalidateEnable() const { 630 return TheStructure.Common.InstructionCacheInvalidateEnable; 631 } 632 inline void setRenderTargetCacheFlushEnable(const bool value) { 633 TheStructure.Common.RenderTargetCacheFlushEnable = value; 634 } 635 inline bool getRenderTargetCacheFlushEnable() const { 636 return TheStructure.Common.RenderTargetCacheFlushEnable; 637 } 638 inline void setDepthStallEnable(const bool value) { 639 TheStructure.Common.DepthStallEnable = value; 640 } 641 inline bool getDepthStallEnable() const { 642 return TheStructure.Common.DepthStallEnable; 643 } 644 inline void setPostSyncOperation(const POST_SYNC_OPERATION value) { 645 TheStructure.Common.PostSyncOperation = value; 646 } 647 inline POST_SYNC_OPERATION getPostSyncOperation() const { 648 return static_cast<POST_SYNC_OPERATION>(TheStructure.Common.PostSyncOperation); 649 } 650 inline void setGenericMediaStateClear(const bool value) { 651 TheStructure.Common.GenericMediaStateClear = value; 652 } 653 inline bool getGenericMediaStateClear() const { 654 return TheStructure.Common.GenericMediaStateClear; 655 } 656 inline void setPssStallSyncEnable(const bool value) { 657 TheStructure.Common.PssStallSyncEnable = value; 658 } 659 inline bool getPssStallSyncEnable() const { 660 return TheStructure.Common.PssStallSyncEnable; 661 } 662 inline void setTlbInvalidate(const bool value) { 663 TheStructure.Common.TlbInvalidate = value; 664 } 665 inline bool getTlbInvalidate() const { 666 return TheStructure.Common.TlbInvalidate; 667 } 668 inline void setDepthStallSyncEnable(const bool value) { 669 TheStructure.Common.DepthStallSyncEnable = value; 670 } 671 inline bool getDepthStallSyncEnable() const { 672 return TheStructure.Common.DepthStallSyncEnable; 673 } 674 inline void setCommandStreamerStallEnable(const uint32_t value) { 675 TheStructure.Common.CommandStreamerStallEnable = value; 676 } 677 inline uint32_t getCommandStreamerStallEnable() const { 678 return TheStructure.Common.CommandStreamerStallEnable; 679 } 680 inline void setStoreDataIndex(const bool value) { 681 TheStructure.Common.StoreDataIndex = value; 682 } 683 inline bool getStoreDataIndex() const { 684 return TheStructure.Common.StoreDataIndex; 685 } 686 inline void setProtectedMemoryEnable(const bool value) { 687 TheStructure.Common.ProtectedMemoryEnable = value; 688 } 689 inline bool getProtectedMemoryEnable() const { 690 return TheStructure.Common.ProtectedMemoryEnable; 691 } 692 inline void setLriPostSyncOperation(const LRI_POST_SYNC_OPERATION value) { 693 TheStructure.Common.LriPostSyncOperation = value; 694 } 695 inline LRI_POST_SYNC_OPERATION getLriPostSyncOperation() const { 696 return static_cast<LRI_POST_SYNC_OPERATION>(TheStructure.Common.LriPostSyncOperation); 697 } 698 inline void setDestinationAddressType(const DESTINATION_ADDRESS_TYPE value) { 699 TheStructure.Common.DestinationAddressType = value; 700 } 701 inline DESTINATION_ADDRESS_TYPE getDestinationAddressType() const { 702 return static_cast<DESTINATION_ADDRESS_TYPE>(TheStructure.Common.DestinationAddressType); 703 } 704 inline void setAmfsFlushEnable(const bool value) { 705 TheStructure.Common.AmfsFlushEnable = value; 706 } 707 inline bool getAmfsFlushEnable() const { 708 return TheStructure.Common.AmfsFlushEnable; 709 } 710 inline void setFlushLlc(const bool value) { 711 TheStructure.Common.FlushLlc = value; 712 } 713 inline bool getFlushLlc() const { 714 return TheStructure.Common.FlushLlc; 715 } 716 inline void setProtectedMemoryDisable(const bool value) { 717 TheStructure.Common.ProtectedMemoryDisable = value; 718 } 719 inline bool getProtectedMemoryDisable() const { 720 return TheStructure.Common.ProtectedMemoryDisable; 721 } 722 inline void setTileCacheFlushEnable(const bool value) { 723 TheStructure.Common.TileCacheFlushEnable = value; 724 } 725 inline bool getTileCacheFlushEnable() const { 726 return TheStructure.Common.TileCacheFlushEnable; 727 } 728 inline void setL3FabricFlush(const bool value) { 729 TheStructure.Common.L3FabricFlush = value; 730 } 731 inline bool getL3FabricFlush() const { 732 return TheStructure.Common.L3FabricFlush; 733 } 734 inline void setTbimrForceBatchClosure(const TBIMR_FORCE_BATCH_CLOSURE value) { 735 TheStructure.Common.TbimrForceBatchClosure = value; 736 } 737 inline TBIMR_FORCE_BATCH_CLOSURE getTbimrForceBatchClosure() const { 738 return static_cast<TBIMR_FORCE_BATCH_CLOSURE>(TheStructure.Common.TbimrForceBatchClosure); 739 } 740 typedef enum tagADDRESS { 741 ADDRESS_BIT_SHIFT = 0x2, 742 ADDRESS_ALIGN_SIZE = 0x4, 743 } ADDRESS; 744 inline void setAddress(const uint32_t value) { 745 UNRECOVERABLE_IF(value > 0xfffffffc); 746 TheStructure.Common.Address = value >> ADDRESS_BIT_SHIFT; 747 } 748 inline uint32_t getAddress() const { 749 return TheStructure.Common.Address << ADDRESS_BIT_SHIFT; 750 } 751 inline void setAddressHigh(const uint32_t value) { 752 TheStructure.Common.AddressHigh = value; 753 } 754 inline uint32_t getAddressHigh() const { 755 return TheStructure.Common.AddressHigh; 756 } 757 inline void setImmediateData(const uint64_t value) { 758 TheStructure.Common.ImmediateData = value; 759 } 760 inline uint64_t getImmediateData() const { 761 return TheStructure.Common.ImmediateData; 762 } 763} PIPE_CONTROL; 764STATIC_ASSERT(24 == sizeof(PIPE_CONTROL)); 765 766typedef struct tagMI_ATOMIC { 767 union tagTheStructure { 768 struct tagCommon { 769 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 770 uint32_t AtomicOpcode : BITFIELD_RANGE(8, 15); 771 uint32_t ReturnDataControl : BITFIELD_RANGE(16, 16); 772 uint32_t CsStall : BITFIELD_RANGE(17, 17); 773 uint32_t InlineData : BITFIELD_RANGE(18, 18); 774 uint32_t DataSize : BITFIELD_RANGE(19, 20); 775 uint32_t PostSyncOperation : BITFIELD_RANGE(21, 21); 776 uint32_t MemoryType : BITFIELD_RANGE(22, 22); 777 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 778 uint32_t CommandType : BITFIELD_RANGE(29, 31); 779 uint32_t WorkloadPartitionIdOffsetEnable : BITFIELD_RANGE(0, 0); 780 uint32_t Reserved_33 : BITFIELD_RANGE(1, 1); 781 uint32_t MemoryAddress : BITFIELD_RANGE(2, 31); 782 uint32_t MemoryAddressHigh : BITFIELD_RANGE(0, 15); 783 uint32_t Reserved_80 : BITFIELD_RANGE(16, 31); 784 uint32_t Operand1DataDword0; 785 uint32_t Operand2DataDword0; 786 uint32_t Operand1DataDword1; 787 uint32_t Operand2DataDword1; 788 uint32_t Operand1DataDword2; 789 uint32_t Operand2DataDword2; 790 uint32_t Operand1DataDword3; 791 uint32_t Operand2DataDword3; 792 } Common; 793 uint32_t RawData[11]; 794 } TheStructure; 795 typedef enum tagDWORD_LENGTH { 796 DWORD_LENGTH_INLINE_DATA_0 = 0x1, 797 DWORD_LENGTH_INLINE_DATA_1 = 0x9, 798 } DWORD_LENGTH; 799 typedef enum tagDATA_SIZE { 800 DATA_SIZE_DWORD = 0x0, 801 DATA_SIZE_QWORD = 0x1, 802 DATA_SIZE_OCTWORD = 0x2, 803 } DATA_SIZE; 804 typedef enum tagPOST_SYNC_OPERATION { 805 POST_SYNC_OPERATION_NO_POST_SYNC_OPERATION = 0x0, 806 POST_SYNC_OPERATION_POST_SYNC_OPERATION = 0x1, 807 } POST_SYNC_OPERATION; 808 typedef enum tagMEMORY_TYPE { 809 MEMORY_TYPE_PER_PROCESS_GRAPHICS_ADDRESS = 0x0, 810 MEMORY_TYPE_GLOBAL_GRAPHICS_ADDRESS = 0x1, 811 } MEMORY_TYPE; 812 typedef enum tagMI_COMMAND_OPCODE { 813 MI_COMMAND_OPCODE_MI_ATOMIC = 0x2f, 814 } MI_COMMAND_OPCODE; 815 typedef enum tagCOMMAND_TYPE { 816 COMMAND_TYPE_MI_COMMAND = 0x0, 817 } COMMAND_TYPE; 818 typedef enum tagATOMIC_OPCODES { 819 ATOMIC_4B_MOVE = 0x4, 820 ATOMIC_4B_INCREMENT = 0x5, 821 ATOMIC_4B_DECREMENT = 0x6, 822 ATOMIC_8B_MOVE = 0x24, 823 ATOMIC_8B_INCREMENT = 0x25, 824 ATOMIC_8B_DECREMENT = 0x26, 825 } ATOMIC_OPCODES; 826 inline void init() { 827 memset(&TheStructure, 0, sizeof(TheStructure)); 828 TheStructure.Common.DwordLength = DWORD_LENGTH_INLINE_DATA_0; 829 TheStructure.Common.DataSize = DATA_SIZE_DWORD; 830 TheStructure.Common.PostSyncOperation = 831 POST_SYNC_OPERATION_NO_POST_SYNC_OPERATION; 832 TheStructure.Common.MemoryType = MEMORY_TYPE_PER_PROCESS_GRAPHICS_ADDRESS; 833 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_ATOMIC; 834 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 835 } 836 static tagMI_ATOMIC sInit() { 837 MI_ATOMIC state; 838 state.init(); 839 return state; 840 } 841 inline uint32_t &getRawData(const uint32_t index) { 842 DEBUG_BREAK_IF(index >= 11); 843 return TheStructure.RawData[index]; 844 } 845 inline void setDwordLength(const DWORD_LENGTH value) { 846 TheStructure.Common.DwordLength = value; 847 } 848 inline DWORD_LENGTH getDwordLength() const { 849 return static_cast<DWORD_LENGTH>(TheStructure.Common.DwordLength); 850 } 851 inline void setAtomicOpcode(const uint32_t value) { 852 DEBUG_BREAK_IF(value > 0xff00); 853 TheStructure.Common.AtomicOpcode = value; 854 } 855 inline uint32_t getAtomicOpcode() const { 856 return TheStructure.Common.AtomicOpcode; 857 } 858 inline void setReturnDataControl(const uint32_t value) { 859 TheStructure.Common.ReturnDataControl = value; 860 } 861 inline uint32_t getReturnDataControl() const { 862 return TheStructure.Common.ReturnDataControl; 863 } 864 inline void setCsStall(const uint32_t value) { 865 TheStructure.Common.CsStall = value; 866 } 867 inline uint32_t getCsStall() const { return TheStructure.Common.CsStall; } 868 inline void setInlineData(const uint32_t value) { 869 TheStructure.Common.InlineData = value; 870 } 871 inline uint32_t getInlineData() const { 872 return TheStructure.Common.InlineData; 873 } 874 inline void setDataSize(const DATA_SIZE value) { 875 TheStructure.Common.DataSize = value; 876 } 877 inline DATA_SIZE getDataSize() const { 878 return static_cast<DATA_SIZE>(TheStructure.Common.DataSize); 879 } 880 inline void setPostSyncOperation(const POST_SYNC_OPERATION value) { 881 TheStructure.Common.PostSyncOperation = value; 882 } 883 inline POST_SYNC_OPERATION getPostSyncOperation() const { 884 return static_cast<POST_SYNC_OPERATION>( 885 TheStructure.Common.PostSyncOperation); 886 } 887 inline void setMemoryType(const MEMORY_TYPE value) { 888 TheStructure.Common.MemoryType = value; 889 } 890 inline MEMORY_TYPE getMemoryType() const { 891 return static_cast<MEMORY_TYPE>(TheStructure.Common.MemoryType); 892 } 893 inline void setWorkloadPartitionIdOffsetEnable(const bool value) { 894 TheStructure.Common.WorkloadPartitionIdOffsetEnable = value; 895 } 896 inline bool getWorkloadPartitionIdOffsetEnable() const { 897 return TheStructure.Common.WorkloadPartitionIdOffsetEnable; 898 } 899 typedef enum tagMEMORYADDRESS { 900 MEMORYADDRESS_BIT_SHIFT = 0x2, 901 MEMORYADDRESS_ALIGN_SIZE = 0x4, 902 } MEMORYADDRESS; 903 inline void setMemoryAddress(const uint32_t value) { 904 DEBUG_BREAK_IF(value > 0xfffffffcL); 905 TheStructure.Common.MemoryAddress = value >> MEMORYADDRESS_BIT_SHIFT; 906 } 907 inline uint32_t getMemoryAddress() const { 908 return TheStructure.Common.MemoryAddress << MEMORYADDRESS_BIT_SHIFT; 909 } 910 inline void setMemoryAddressHigh(const uint32_t value) { 911 TheStructure.Common.MemoryAddressHigh = value; 912 } 913 inline uint32_t getMemoryAddressHigh() const { 914 return TheStructure.Common.MemoryAddressHigh; 915 } 916 inline void setOperand1DataDword0(const uint32_t value) { 917 TheStructure.Common.Operand1DataDword0 = value; 918 } 919 inline uint32_t getOperand1DataDword0() const { 920 return TheStructure.Common.Operand1DataDword0; 921 } 922 inline void setOperand2DataDword0(const uint32_t value) { 923 TheStructure.Common.Operand2DataDword0 = value; 924 } 925 inline uint32_t getOperand2DataDword0() const { 926 return TheStructure.Common.Operand2DataDword0; 927 } 928 inline void setOperand1DataDword1(const uint32_t value) { 929 TheStructure.Common.Operand1DataDword1 = value; 930 } 931 inline uint32_t getOperand1DataDword1() const { 932 return TheStructure.Common.Operand1DataDword1; 933 } 934 inline void setOperand2DataDword1(const uint32_t value) { 935 TheStructure.Common.Operand2DataDword1 = value; 936 } 937 inline uint32_t getOperand2DataDword1() const { 938 return TheStructure.Common.Operand2DataDword1; 939 } 940 inline void setOperand1DataDword2(const uint32_t value) { 941 TheStructure.Common.Operand1DataDword2 = value; 942 } 943 inline uint32_t getOperand1DataDword2() const { 944 return TheStructure.Common.Operand1DataDword2; 945 } 946 inline void setOperand2DataDword2(const uint32_t value) { 947 TheStructure.Common.Operand2DataDword2 = value; 948 } 949 inline uint32_t getOperand2DataDword2() const { 950 return TheStructure.Common.Operand2DataDword2; 951 } 952 inline void setOperand1DataDword3(const uint32_t value) { 953 TheStructure.Common.Operand1DataDword3 = value; 954 } 955 inline uint32_t getOperand1DataDword3() const { 956 return TheStructure.Common.Operand1DataDword3; 957 } 958 inline void setOperand2DataDword3(const uint32_t value) { 959 TheStructure.Common.Operand2DataDword3 = value; 960 } 961 inline uint32_t getOperand2DataDword3() const { 962 return TheStructure.Common.Operand2DataDword3; 963 } 964} MI_ATOMIC; 965STATIC_ASSERT(44 == sizeof(MI_ATOMIC)); 966 967typedef struct tagMI_BATCH_BUFFER_END { 968 union tagTheStructure { 969 struct tagCommon { 970 uint32_t EndContext : BITFIELD_RANGE(0, 0); 971 uint32_t Reserved_1 : BITFIELD_RANGE(1, 22); 972 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 973 uint32_t CommandType : BITFIELD_RANGE(29, 31); 974 } Common; 975 uint32_t RawData[1]; 976 } TheStructure; 977 typedef enum tagMI_COMMAND_OPCODE { 978 MI_COMMAND_OPCODE_MI_BATCH_BUFFER_END = 0xa, 979 } MI_COMMAND_OPCODE; 980 typedef enum tagCOMMAND_TYPE { 981 COMMAND_TYPE_MI_COMMAND = 0x0, 982 } COMMAND_TYPE; 983 inline void init() { 984 memset(&TheStructure, 0, sizeof(TheStructure)); 985 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_BATCH_BUFFER_END; 986 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 987 } 988 static tagMI_BATCH_BUFFER_END sInit() { 989 MI_BATCH_BUFFER_END state; 990 state.init(); 991 return state; 992 } 993 inline uint32_t &getRawData(const uint32_t index) { 994 DEBUG_BREAK_IF(index >= 1); 995 return TheStructure.RawData[index]; 996 } 997 inline void setEndContext(const bool value) { 998 TheStructure.Common.EndContext = value; 999 } 1000 inline bool getEndContext() const { 1001 return (TheStructure.Common.EndContext); 1002 } 1003} MI_BATCH_BUFFER_END; 1004STATIC_ASSERT(4 == sizeof(MI_BATCH_BUFFER_END)); 1005 1006typedef struct tagMI_LOAD_REGISTER_IMM { 1007 union tagTheStructure { 1008 struct tagCommon { 1009 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 1010 uint32_t ByteWriteDisables : BITFIELD_RANGE(8, 11); 1011 uint32_t Reserved_12 : BITFIELD_RANGE(12, 16); 1012 uint32_t MmioRemapEnable : BITFIELD_RANGE(17, 17); 1013 uint32_t Reserved_13 : BITFIELD_RANGE(18, 18); 1014 uint32_t AddCsMmioStartOffset : BITFIELD_RANGE(19, 19); 1015 uint32_t Reserved_20 : BITFIELD_RANGE(20, 22); 1016 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 1017 uint32_t CommandType : BITFIELD_RANGE(29, 31); 1018 uint32_t Reserved_32 : BITFIELD_RANGE(0, 1); 1019 uint32_t RegisterOffset : BITFIELD_RANGE(2, 22); 1020 uint32_t Reserved_55 : BITFIELD_RANGE(23, 31); 1021 uint32_t DataDword; 1022 } Common; 1023 uint32_t RawData[3]; 1024 } TheStructure; 1025 typedef enum tagDWORD_LENGTH { 1026 DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x1, 1027 } DWORD_LENGTH; 1028 typedef enum tagMI_COMMAND_OPCODE { 1029 MI_COMMAND_OPCODE_MI_LOAD_REGISTER_IMM = 0x22, 1030 } MI_COMMAND_OPCODE; 1031 typedef enum tagCOMMAND_TYPE { 1032 COMMAND_TYPE_MI_COMMAND = 0x0, 1033 } COMMAND_TYPE; 1034 inline void init() { 1035 memset(&TheStructure, 0, sizeof(TheStructure)); 1036 TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1; 1037 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_LOAD_REGISTER_IMM; 1038 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 1039 } 1040 static tagMI_LOAD_REGISTER_IMM sInit() { 1041 MI_LOAD_REGISTER_IMM state; 1042 state.init(); 1043 return state; 1044 } 1045 inline uint32_t &getRawData(const uint32_t index) { 1046 DEBUG_BREAK_IF(index >= 3); 1047 return TheStructure.RawData[index]; 1048 } 1049 inline void setByteWriteDisables(const uint32_t value) { 1050 TheStructure.Common.ByteWriteDisables = value; 1051 } 1052 inline uint32_t getByteWriteDisables() const { 1053 return (TheStructure.Common.ByteWriteDisables); 1054 } 1055 inline void setAddCsMmioStartOffset(const uint32_t value) { 1056 TheStructure.Common.AddCsMmioStartOffset = value; 1057 } 1058 inline uint32_t getAddCsMmioStartOffset() const { 1059 return (TheStructure.Common.AddCsMmioStartOffset); 1060 } 1061 typedef enum tagREGISTEROFFSET { 1062 REGISTEROFFSET_BIT_SHIFT = 0x2, 1063 REGISTEROFFSET_ALIGN_SIZE = 0x4, 1064 } REGISTEROFFSET; 1065 inline void setRegisterOffset(const uint32_t value) { 1066 TheStructure.Common.RegisterOffset = value >> REGISTEROFFSET_BIT_SHIFT; 1067 } 1068 inline uint32_t getRegisterOffset() const { 1069 return (TheStructure.Common.RegisterOffset << REGISTEROFFSET_BIT_SHIFT); 1070 } 1071 inline void setDataDword(const uint32_t value) { 1072 TheStructure.Common.DataDword = value; 1073 } 1074 inline uint32_t getDataDword() const { 1075 return (TheStructure.Common.DataDword); 1076 } 1077 inline void setMmioRemapEnable(const bool value) { 1078 TheStructure.Common.MmioRemapEnable = value; 1079 } 1080 inline bool getMmioRemapEnable() const { 1081 return TheStructure.Common.MmioRemapEnable; 1082 } 1083} MI_LOAD_REGISTER_IMM; 1084STATIC_ASSERT(12 == sizeof(MI_LOAD_REGISTER_IMM)); 1085 1086typedef struct tagMI_NOOP { 1087 union tagTheStructure { 1088 struct tagCommon { 1089 uint32_t IdentificationNumber : BITFIELD_RANGE(0, 21); 1090 uint32_t IdentificationNumberRegisterWriteEnable : BITFIELD_RANGE(22, 22); 1091 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 1092 uint32_t CommandType : BITFIELD_RANGE(29, 31); 1093 } Common; 1094 uint32_t RawData[1]; 1095 } TheStructure; 1096 typedef enum tagMI_COMMAND_OPCODE { 1097 MI_COMMAND_OPCODE_MI_NOOP = 0x0, 1098 } MI_COMMAND_OPCODE; 1099 typedef enum tagCOMMAND_TYPE { 1100 COMMAND_TYPE_MI_COMMAND = 0x0, 1101 } COMMAND_TYPE; 1102 inline void init() { 1103 memset(&TheStructure, 0, sizeof(TheStructure)); 1104 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_NOOP; 1105 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 1106 } 1107 static tagMI_NOOP sInit() { 1108 MI_NOOP state; 1109 state.init(); 1110 return state; 1111 } 1112 inline uint32_t &getRawData(const uint32_t index) { 1113 DEBUG_BREAK_IF(index >= 1); 1114 return TheStructure.RawData[index]; 1115 } 1116 inline void setIdentificationNumber(const uint32_t value) { 1117 TheStructure.Common.IdentificationNumber = value; 1118 } 1119 inline uint32_t getIdentificationNumber() const { 1120 return (TheStructure.Common.IdentificationNumber); 1121 } 1122 inline void setIdentificationNumberRegisterWriteEnable(const bool value) { 1123 TheStructure.Common.IdentificationNumberRegisterWriteEnable = value; 1124 } 1125 inline bool getIdentificationNumberRegisterWriteEnable() const { 1126 return (TheStructure.Common.IdentificationNumberRegisterWriteEnable); 1127 } 1128} MI_NOOP; 1129STATIC_ASSERT(4 == sizeof(MI_NOOP)); 1130 1131typedef struct tagRENDER_SURFACE_STATE { 1132 union tagTheStructure { 1133 struct tagCommon { 1134 // DWORD 0 1135 uint32_t CubeFaceEnablePositiveZ : BITFIELD_RANGE(0, 0); 1136 uint32_t CubeFaceEnableNegativeZ : BITFIELD_RANGE(1, 1); 1137 uint32_t CubeFaceEnablePositiveY : BITFIELD_RANGE(2, 2); 1138 uint32_t CubeFaceEnableNegativeY : BITFIELD_RANGE(3, 3); 1139 uint32_t CubeFaceEnablePositiveX : BITFIELD_RANGE(4, 4); 1140 uint32_t CubeFaceEnableNegativeX : BITFIELD_RANGE(5, 5); 1141 uint32_t MediaBoundaryPixelMode : BITFIELD_RANGE(6, 7); 1142 uint32_t RenderCacheReadWriteMode : BITFIELD_RANGE(8, 8); 1143 uint32_t SamplerL2OutOfOrderModeDisable : BITFIELD_RANGE(9, 9); 1144 uint32_t VerticalLineStrideOffset : BITFIELD_RANGE(10, 10); 1145 uint32_t VerticalLineStride : BITFIELD_RANGE(11, 11); 1146 uint32_t TileMode : BITFIELD_RANGE(12, 13); 1147 uint32_t SurfaceHorizontalAlignment : BITFIELD_RANGE(14, 15); 1148 uint32_t SurfaceVerticalAlignment : BITFIELD_RANGE(16, 17); 1149 uint32_t SurfaceFormat : BITFIELD_RANGE(18, 26); 1150 uint32_t AstcEnable : BITFIELD_RANGE(27, 27); 1151 uint32_t SurfaceArray : BITFIELD_RANGE(28, 28); 1152 uint32_t SurfaceType : BITFIELD_RANGE(29, 31); 1153 // DWORD 1 1154 uint32_t SurfaceQpitch : BITFIELD_RANGE(0, 14); 1155 uint32_t SampleTapDiscardDisable : BITFIELD_RANGE(15, 15); 1156 uint32_t Reserved_48 : BITFIELD_RANGE(16, 16); 1157 uint32_t DoubleFetchDisable : BITFIELD_RANGE(17, 17); 1158 uint32_t CornerTexelMode : BITFIELD_RANGE(18, 18); 1159 uint32_t BaseMipLevel : BITFIELD_RANGE(19, 23); 1160 uint32_t MemoryObjectControlStateEncryptedData : BITFIELD_RANGE(24, 24); 1161 uint32_t MemoryObjectControlStateIndexToMocsTables : BITFIELD_RANGE(25, 30); 1162 uint32_t EnableUnormPathInColorPipe : BITFIELD_RANGE(31, 31); 1163 // DWORD 2 1164 uint32_t Width : BITFIELD_RANGE(0, 13); 1165 uint32_t Reserved_78 : BITFIELD_RANGE(14, 15); 1166 uint32_t Height : BITFIELD_RANGE(16, 29); 1167 uint32_t Reserved_94 : BITFIELD_RANGE(30, 30); 1168 uint32_t DepthStencilResource : BITFIELD_RANGE(31, 31); 1169 // DWORD 3 1170 uint32_t SurfacePitch : BITFIELD_RANGE(0, 17); 1171 uint32_t NullProbingEnable : BITFIELD_RANGE(18, 18); 1172 uint32_t Reserved_115 : BITFIELD_RANGE(19, 19); 1173 uint32_t Reserved_116 : BITFIELD_RANGE(20, 20); 1174 uint32_t Depth : BITFIELD_RANGE(21, 31); 1175 // DWORD 4 1176 uint32_t MultisamplePositionPaletteIndex : BITFIELD_RANGE(0, 2); 1177 uint32_t NumberOfMultisamples : BITFIELD_RANGE(3, 5); 1178 uint32_t MultisampledSurfaceStorageFormat : BITFIELD_RANGE(6, 6); 1179 uint32_t RenderTargetViewExtent : BITFIELD_RANGE(7, 17); 1180 uint32_t MinimumArrayElement : BITFIELD_RANGE(18, 28); 1181 uint32_t RenderTargetAndSampleUnormRotation : BITFIELD_RANGE(29, 30); 1182 uint32_t Reserved_159 : BITFIELD_RANGE(31, 31); 1183 // DWORD 5 1184 uint32_t MipCountLod : BITFIELD_RANGE(0, 3); 1185 uint32_t SurfaceMinLod : BITFIELD_RANGE(4, 7); 1186 uint32_t MipTailStartLod : BITFIELD_RANGE(8, 11); 1187 uint32_t Reserved_172 : BITFIELD_RANGE(12, 13); 1188 uint32_t CoherencyType : BITFIELD_RANGE(14, 14); 1189 uint32_t Reserved_175 : BITFIELD_RANGE(15, 19); 1190 uint32_t EwaDisableForCube : BITFIELD_RANGE(20, 20); 1191 uint32_t YOffset : BITFIELD_RANGE(21, 23); 1192 uint32_t Reserved_184 : BITFIELD_RANGE(24, 24); 1193 uint32_t XOffset : BITFIELD_RANGE(25, 31); 1194 // DWORD 6 1195 uint32_t Reserved_192 : BITFIELD_RANGE(0, 2); 1196 uint32_t Reserved_195 : BITFIELD_RANGE(3, 12); 1197 uint32_t Reserved_205 : BITFIELD_RANGE(13, 14); 1198 uint32_t Reserved_207 : BITFIELD_RANGE(15, 15); 1199 uint32_t Reserved_208 : BITFIELD_RANGE(16, 29); 1200 uint32_t Reserved_222 : BITFIELD_RANGE(30, 30); 1201 uint32_t Reserved_223 : BITFIELD_RANGE(31, 31); 1202 // DWORD 7 1203 uint32_t ResourceMinLod : BITFIELD_RANGE(0, 11); 1204 uint32_t Reserved_236 : BITFIELD_RANGE(12, 13); 1205 uint32_t DisableSupportForMultiGpuAtomics : BITFIELD_RANGE(14, 14); 1206 uint32_t DisableSupportForMultiGpuPartialWrites : BITFIELD_RANGE(15, 15); 1207 uint32_t ShaderChannelSelectAlpha : BITFIELD_RANGE(16, 18); 1208 uint32_t ShaderChannelSelectBlue : BITFIELD_RANGE(19, 21); 1209 uint32_t ShaderChannelSelectGreen : BITFIELD_RANGE(22, 24); 1210 uint32_t ShaderChannelSelectRed : BITFIELD_RANGE(25, 27); 1211 uint32_t Reserved_252 : BITFIELD_RANGE(28, 28); 1212 uint32_t Reserved_253 : BITFIELD_RANGE(29, 29); 1213 uint32_t MemoryCompressionEnable : BITFIELD_RANGE(30, 30); 1214 uint32_t MemoryCompressionMode : BITFIELD_RANGE(31, 31); 1215 // DWORD 8, 9 1216 uint64_t SurfaceBaseAddress; 1217 // DWORD 10, 11 1218 uint64_t QuiltWidth : BITFIELD_RANGE(0, 4); 1219 uint64_t QuiltHeight : BITFIELD_RANGE(5, 9); 1220 uint64_t ClearValueAddressEnable : BITFIELD_RANGE(10, 10); 1221 uint64_t ProceduralTexture : BITFIELD_RANGE(11, 11); 1222 uint64_t Reserved_332 : BITFIELD_RANGE(12, 63); 1223 // DWORD 12 1224 uint32_t CompressionFormat : BITFIELD_RANGE(0, 4); 1225 uint32_t Reserved_389 : BITFIELD_RANGE(5, 5); 1226 uint32_t ClearColorAddress : BITFIELD_RANGE(6, 31); 1227 // DWORD 13 1228 uint32_t ClearColorAddressHigh : BITFIELD_RANGE(0, 15); 1229 uint32_t Reserved_432 : BITFIELD_RANGE(16, 30); 1230 uint32_t DisallowLowQualityFlitering : BITFIELD_RANGE(31, 31); 1231 // DWORD 14 1232 uint32_t Reserved_448; 1233 // DWORD 15 1234 uint32_t Reserved_480; 1235 } Common; 1236 struct tag_SurfaceFormatIsnotPlanar { 1237 // DWORD 0 1238 uint32_t Reserved_0 : BITFIELD_RANGE(0, 0); 1239 uint32_t Reserved_1 : BITFIELD_RANGE(1, 1); 1240 uint32_t Reserved_2 : BITFIELD_RANGE(2, 2); 1241 uint32_t Reserved_3 : BITFIELD_RANGE(3, 3); 1242 uint32_t Reserved_4 : BITFIELD_RANGE(4, 4); 1243 uint32_t Reserved_5 : BITFIELD_RANGE(5, 5); 1244 uint32_t Reserved_6 : BITFIELD_RANGE(6, 7); 1245 uint32_t Reserved_8 : BITFIELD_RANGE(8, 8); 1246 uint32_t Reserved_9 : BITFIELD_RANGE(9, 9); 1247 uint32_t Reserved_10 : BITFIELD_RANGE(10, 10); 1248 uint32_t Reserved_11 : BITFIELD_RANGE(11, 11); 1249 uint32_t Reserved_12 : BITFIELD_RANGE(12, 13); 1250 uint32_t Reserved_14 : BITFIELD_RANGE(14, 15); 1251 uint32_t Reserved_16 : BITFIELD_RANGE(16, 17); 1252 uint32_t Reserved_18 : BITFIELD_RANGE(18, 26); 1253 uint32_t Reserved_27 : BITFIELD_RANGE(27, 27); 1254 uint32_t Reserved_28 : BITFIELD_RANGE(28, 28); 1255 uint32_t Reserved_29 : BITFIELD_RANGE(29, 31); 1256 // DWORD 1 1257 uint32_t Reserved_32 : BITFIELD_RANGE(0, 14); 1258 uint32_t Reserved_47 : BITFIELD_RANGE(15, 15); 1259 uint32_t Reserved_48 : BITFIELD_RANGE(16, 16); 1260 uint32_t Reserved_49 : BITFIELD_RANGE(17, 17); 1261 uint32_t Reserved_50 : BITFIELD_RANGE(18, 18); 1262 uint32_t Reserved_51 : BITFIELD_RANGE(19, 23); 1263 uint32_t Reserved_56 : BITFIELD_RANGE(24, 24); 1264 uint32_t Reserved_57 : BITFIELD_RANGE(25, 30); 1265 uint32_t Reserved_63 : BITFIELD_RANGE(31, 31); 1266 // DWORD 2 1267 uint32_t Reserved_64 : BITFIELD_RANGE(0, 13); 1268 uint32_t Reserved_78 : BITFIELD_RANGE(14, 15); 1269 uint32_t Reserved_80 : BITFIELD_RANGE(16, 29); 1270 uint32_t Reserved_94 : BITFIELD_RANGE(30, 30); 1271 uint32_t Reserved_95 : BITFIELD_RANGE(31, 31); 1272 // DWORD 3 1273 uint32_t Reserved_96 : BITFIELD_RANGE(0, 17); 1274 uint32_t Reserved_114 : BITFIELD_RANGE(18, 18); 1275 uint32_t Reserved_115 : BITFIELD_RANGE(19, 19); 1276 uint32_t Reserved_116 : BITFIELD_RANGE(20, 20); 1277 uint32_t Reserved_117 : BITFIELD_RANGE(21, 31); 1278 // DWORD 4 1279 uint32_t Reserved_128 : BITFIELD_RANGE(0, 2); 1280 uint32_t Reserved_131 : BITFIELD_RANGE(3, 5); 1281 uint32_t Reserved_134 : BITFIELD_RANGE(6, 6); 1282 uint32_t Reserved_135 : BITFIELD_RANGE(7, 17); 1283 uint32_t Reserved_146 : BITFIELD_RANGE(18, 28); 1284 uint32_t Reserved_157 : BITFIELD_RANGE(29, 30); 1285 uint32_t Reserved_159 : BITFIELD_RANGE(31, 31); 1286 // DWORD 5 1287 uint32_t Reserved_160 : BITFIELD_RANGE(0, 3); 1288 uint32_t Reserved_164 : BITFIELD_RANGE(4, 7); 1289 uint32_t Reserved_168 : BITFIELD_RANGE(8, 11); 1290 uint32_t Reserved_172 : BITFIELD_RANGE(12, 13); 1291 uint32_t Reserved_174 : BITFIELD_RANGE(14, 14); 1292 uint32_t Reserved_175 : BITFIELD_RANGE(15, 15); 1293 uint32_t Reserved_176 : BITFIELD_RANGE(16, 17); 1294 uint32_t Reserved_178 : BITFIELD_RANGE(18, 19); 1295 uint32_t Reserved_180 : BITFIELD_RANGE(20, 20); 1296 uint32_t Reserved_181 : BITFIELD_RANGE(21, 23); 1297 uint32_t Reserved_184 : BITFIELD_RANGE(24, 24); 1298 uint32_t Reserved_185 : BITFIELD_RANGE(25, 31); 1299 // DWORD 6 1300 uint32_t AuxiliarySurfaceMode : BITFIELD_RANGE(0, 2); 1301 uint32_t AuxiliarySurfacePitch : BITFIELD_RANGE(3, 12); 1302 uint32_t Reserved_205 : BITFIELD_RANGE(13, 14); 1303 uint32_t Reserved_207 : BITFIELD_RANGE(15, 15); 1304 uint32_t AuxiliarySurfaceQpitch : BITFIELD_RANGE(16, 30); 1305 uint32_t Reserved_223 : BITFIELD_RANGE(31, 31); 1306 // DWORD 7 1307 uint32_t Reserved_224 : BITFIELD_RANGE(0, 11); 1308 uint32_t Reserved_236 : BITFIELD_RANGE(12, 13); 1309 uint32_t Reserved_238 : BITFIELD_RANGE(14, 15); 1310 uint32_t Reserved_240 : BITFIELD_RANGE(16, 18); 1311 uint32_t Reserved_243 : BITFIELD_RANGE(19, 21); 1312 uint32_t Reserved_246 : BITFIELD_RANGE(22, 24); 1313 uint32_t Reserved_249 : BITFIELD_RANGE(25, 27); 1314 uint32_t Reserved_252 : BITFIELD_RANGE(28, 28); 1315 uint32_t Reserved_253 : BITFIELD_RANGE(29, 29); 1316 uint32_t Reserved_254 : BITFIELD_RANGE(30, 30); 1317 uint32_t Reserved_255 : BITFIELD_RANGE(31, 31); 1318 // DWORD 8, 9 1319 uint64_t Reserved_256; 1320 // DWORD 10, 11 1321 uint64_t Reserved_320 : BITFIELD_RANGE(0, 4); 1322 uint64_t Reserved_325 : BITFIELD_RANGE(5, 9); 1323 uint64_t Reserved_330 : BITFIELD_RANGE(10, 10); 1324 uint64_t Reserved_331 : BITFIELD_RANGE(11, 11); 1325 uint64_t Reserved_332 : BITFIELD_RANGE(12, 63); 1326 // DWORD 12 1327 uint32_t Reserved_384 : BITFIELD_RANGE(0, 4); 1328 uint32_t Reserved_389 : BITFIELD_RANGE(5, 5); 1329 uint32_t Reserved_390 : BITFIELD_RANGE(6, 31); 1330 // DWORD 13 1331 uint32_t Reserved_416 : BITFIELD_RANGE(0, 15); 1332 uint32_t Reserved_432 : BITFIELD_RANGE(16, 31); 1333 // DWORD 14 1334 uint32_t Reserved_448; 1335 // DWORD 15 1336 uint32_t Reserved_480; 1337 } _SurfaceFormatIsnotPlanar; 1338 struct tag_SurfaceFormatIsPlanar { 1339 // DWORD 0 1340 uint32_t Reserved_0 : BITFIELD_RANGE(0, 0); 1341 uint32_t Reserved_1 : BITFIELD_RANGE(1, 1); 1342 uint32_t Reserved_2 : BITFIELD_RANGE(2, 2); 1343 uint32_t Reserved_3 : BITFIELD_RANGE(3, 3); 1344 uint32_t Reserved_4 : BITFIELD_RANGE(4, 4); 1345 uint32_t Reserved_5 : BITFIELD_RANGE(5, 5); 1346 uint32_t Reserved_6 : BITFIELD_RANGE(6, 7); 1347 uint32_t Reserved_8 : BITFIELD_RANGE(8, 8); 1348 uint32_t Reserved_9 : BITFIELD_RANGE(9, 9); 1349 uint32_t Reserved_10 : BITFIELD_RANGE(10, 10); 1350 uint32_t Reserved_11 : BITFIELD_RANGE(11, 11); 1351 uint32_t Reserved_12 : BITFIELD_RANGE(12, 13); 1352 uint32_t Reserved_14 : BITFIELD_RANGE(14, 15); 1353 uint32_t Reserved_16 : BITFIELD_RANGE(16, 17); 1354 uint32_t Reserved_18 : BITFIELD_RANGE(18, 26); 1355 uint32_t Reserved_27 : BITFIELD_RANGE(27, 27); 1356 uint32_t Reserved_28 : BITFIELD_RANGE(28, 28); 1357 uint32_t Reserved_29 : BITFIELD_RANGE(29, 31); 1358 // DWORD 1 1359 uint32_t Reserved_32 : BITFIELD_RANGE(0, 14); 1360 uint32_t Reserved_47 : BITFIELD_RANGE(15, 15); 1361 uint32_t Reserved_48 : BITFIELD_RANGE(16, 16); 1362 uint32_t Reserved_49 : BITFIELD_RANGE(17, 17); 1363 uint32_t Reserved_50 : BITFIELD_RANGE(18, 18); 1364 uint32_t Reserved_51 : BITFIELD_RANGE(19, 23); 1365 uint32_t Reserved_56 : BITFIELD_RANGE(24, 24); 1366 uint32_t Reserved_57 : BITFIELD_RANGE(25, 30); 1367 uint32_t Reserved_63 : BITFIELD_RANGE(31, 31); 1368 // DWORD 2 1369 uint32_t Reserved_64 : BITFIELD_RANGE(0, 13); 1370 uint32_t Reserved_78 : BITFIELD_RANGE(14, 15); 1371 uint32_t Reserved_80 : BITFIELD_RANGE(16, 29); 1372 uint32_t Reserved_94 : BITFIELD_RANGE(30, 30); 1373 uint32_t Reserved_95 : BITFIELD_RANGE(31, 31); 1374 // DWORD 3 1375 uint32_t Reserved_96 : BITFIELD_RANGE(0, 17); 1376 uint32_t Reserved_114 : BITFIELD_RANGE(18, 18); 1377 uint32_t Reserved_115 : BITFIELD_RANGE(19, 19); 1378 uint32_t Reserved_116 : BITFIELD_RANGE(20, 20); 1379 uint32_t Reserved_117 : BITFIELD_RANGE(21, 31); 1380 // DWORD 4 1381 uint32_t Reserved_128 : BITFIELD_RANGE(0, 2); 1382 uint32_t Reserved_131 : BITFIELD_RANGE(3, 5); 1383 uint32_t Reserved_134 : BITFIELD_RANGE(6, 6); 1384 uint32_t Reserved_135 : BITFIELD_RANGE(7, 17); 1385 uint32_t Reserved_146 : BITFIELD_RANGE(18, 28); 1386 uint32_t Reserved_157 : BITFIELD_RANGE(29, 30); 1387 uint32_t Reserved_159 : BITFIELD_RANGE(31, 31); 1388 // DWORD 5 1389 uint32_t Reserved_160 : BITFIELD_RANGE(0, 3); 1390 uint32_t Reserved_164 : BITFIELD_RANGE(4, 7); 1391 uint32_t Reserved_168 : BITFIELD_RANGE(8, 11); 1392 uint32_t Reserved_172 : BITFIELD_RANGE(12, 13); 1393 uint32_t Reserved_174 : BITFIELD_RANGE(14, 14); 1394 uint32_t Reserved_175 : BITFIELD_RANGE(15, 15); 1395 uint32_t Reserved_176 : BITFIELD_RANGE(16, 17); 1396 uint32_t Reserved_178 : BITFIELD_RANGE(18, 19); 1397 uint32_t Reserved_180 : BITFIELD_RANGE(20, 20); 1398 uint32_t Reserved_181 : BITFIELD_RANGE(21, 23); 1399 uint32_t Reserved_184 : BITFIELD_RANGE(24, 24); 1400 uint32_t Reserved_185 : BITFIELD_RANGE(25, 31); 1401 // DWORD 6 1402 uint32_t YOffsetForUOrUvPlane : BITFIELD_RANGE(0, 13); 1403 uint32_t Reserved_206 : BITFIELD_RANGE(14, 14); 1404 uint32_t Reserved_207 : BITFIELD_RANGE(15, 15); 1405 uint32_t XOffsetForUOrUvPlane : BITFIELD_RANGE(16, 29); 1406 uint32_t HalfPitchForChroma : BITFIELD_RANGE(30, 30); 1407 uint32_t SeparateUvPlaneEnable : BITFIELD_RANGE(31, 31); 1408 // DWORD 7 1409 uint32_t Reserved_224 : BITFIELD_RANGE(0, 11); 1410 uint32_t Reserved_236 : BITFIELD_RANGE(12, 13); 1411 uint32_t Reserved_238 : BITFIELD_RANGE(14, 15); 1412 uint32_t Reserved_240 : BITFIELD_RANGE(16, 18); 1413 uint32_t Reserved_243 : BITFIELD_RANGE(19, 21); 1414 uint32_t Reserved_246 : BITFIELD_RANGE(22, 24); 1415 uint32_t Reserved_249 : BITFIELD_RANGE(25, 27); 1416 uint32_t Reserved_252 : BITFIELD_RANGE(28, 28); 1417 uint32_t Reserved_253 : BITFIELD_RANGE(29, 29); 1418 uint32_t Reserved_254 : BITFIELD_RANGE(30, 30); 1419 uint32_t Reserved_255 : BITFIELD_RANGE(31, 31); 1420 // DWORD 8, 9 1421 uint64_t Reserved_256; 1422 // DWORD 10, 11 1423 uint64_t Reserved_320 : BITFIELD_RANGE(0, 4); 1424 uint64_t Reserved_325 : BITFIELD_RANGE(5, 9); 1425 uint64_t Reserved_330 : BITFIELD_RANGE(10, 10); 1426 uint64_t Reserved_331 : BITFIELD_RANGE(11, 11); 1427 uint64_t Reserved_332 : BITFIELD_RANGE(12, 31); 1428 uint64_t YOffsetForVPlane : BITFIELD_RANGE(32, 45); 1429 uint64_t Reserved_366 : BITFIELD_RANGE(46, 47); 1430 uint64_t XOffsetForVPlane : BITFIELD_RANGE(48, 61); 1431 uint64_t Reserved_382 : BITFIELD_RANGE(62, 63); 1432 // DWORD 12 1433 uint32_t Reserved_384 : BITFIELD_RANGE(0, 4); 1434 uint32_t Reserved_389 : BITFIELD_RANGE(5, 5); 1435 uint32_t Reserved_390 : BITFIELD_RANGE(6, 31); 1436 // DWORD 13 1437 uint32_t Reserved_416 : BITFIELD_RANGE(0, 15); 1438 uint32_t Reserved_432 : BITFIELD_RANGE(16, 31); 1439 // DWORD 14 1440 uint32_t Reserved_448; 1441 // DWORD 15 1442 uint32_t Reserved_480; 1443 } _SurfaceFormatIsPlanar; 1444 struct tag_SurfaceFormatIsnotPlanarAndMemoryCompressionEnableIs0 { 1445 // DWORD 0 1446 uint32_t Reserved_0 : BITFIELD_RANGE(0, 0); 1447 uint32_t Reserved_1 : BITFIELD_RANGE(1, 1); 1448 uint32_t Reserved_2 : BITFIELD_RANGE(2, 2); 1449 uint32_t Reserved_3 : BITFIELD_RANGE(3, 3); 1450 uint32_t Reserved_4 : BITFIELD_RANGE(4, 4); 1451 uint32_t Reserved_5 : BITFIELD_RANGE(5, 5); 1452 uint32_t Reserved_6 : BITFIELD_RANGE(6, 7); 1453 uint32_t Reserved_8 : BITFIELD_RANGE(8, 8); 1454 uint32_t Reserved_9 : BITFIELD_RANGE(9, 9); 1455 uint32_t Reserved_10 : BITFIELD_RANGE(10, 10); 1456 uint32_t Reserved_11 : BITFIELD_RANGE(11, 11); 1457 uint32_t Reserved_12 : BITFIELD_RANGE(12, 13); 1458 uint32_t Reserved_14 : BITFIELD_RANGE(14, 15); 1459 uint32_t Reserved_16 : BITFIELD_RANGE(16, 17); 1460 uint32_t Reserved_18 : BITFIELD_RANGE(18, 26); 1461 uint32_t Reserved_27 : BITFIELD_RANGE(27, 27); 1462 uint32_t Reserved_28 : BITFIELD_RANGE(28, 28); 1463 uint32_t Reserved_29 : BITFIELD_RANGE(29, 31); 1464 // DWORD 1 1465 uint32_t Reserved_32 : BITFIELD_RANGE(0, 14); 1466 uint32_t Reserved_47 : BITFIELD_RANGE(15, 15); 1467 uint32_t Reserved_48 : BITFIELD_RANGE(16, 16); 1468 uint32_t Reserved_49 : BITFIELD_RANGE(17, 17); 1469 uint32_t Reserved_50 : BITFIELD_RANGE(18, 18); 1470 uint32_t Reserved_51 : BITFIELD_RANGE(19, 23); 1471 uint32_t Reserved_56 : BITFIELD_RANGE(24, 24); 1472 uint32_t Reserved_57 : BITFIELD_RANGE(25, 30); 1473 uint32_t Reserved_63 : BITFIELD_RANGE(31, 31); 1474 // DWORD 2 1475 uint32_t Reserved_64 : BITFIELD_RANGE(0, 13); 1476 uint32_t Reserved_78 : BITFIELD_RANGE(14, 15); 1477 uint32_t Reserved_80 : BITFIELD_RANGE(16, 29); 1478 uint32_t Reserved_94 : BITFIELD_RANGE(30, 30); 1479 uint32_t Reserved_95 : BITFIELD_RANGE(31, 31); 1480 // DWORD 3 1481 uint32_t Reserved_96 : BITFIELD_RANGE(0, 17); 1482 uint32_t Reserved_114 : BITFIELD_RANGE(18, 18); 1483 uint32_t Reserved_115 : BITFIELD_RANGE(19, 19); 1484 uint32_t Reserved_116 : BITFIELD_RANGE(20, 20); 1485 uint32_t Reserved_117 : BITFIELD_RANGE(21, 31); 1486 // DWORD 4 1487 uint32_t Reserved_128 : BITFIELD_RANGE(0, 2); 1488 uint32_t Reserved_131 : BITFIELD_RANGE(3, 5); 1489 uint32_t Reserved_134 : BITFIELD_RANGE(6, 6); 1490 uint32_t Reserved_135 : BITFIELD_RANGE(7, 17); 1491 uint32_t Reserved_146 : BITFIELD_RANGE(18, 28); 1492 uint32_t Reserved_157 : BITFIELD_RANGE(29, 30); 1493 uint32_t Reserved_159 : BITFIELD_RANGE(31, 31); 1494 // DWORD 5 1495 uint32_t Reserved_160 : BITFIELD_RANGE(0, 3); 1496 uint32_t Reserved_164 : BITFIELD_RANGE(4, 7); 1497 uint32_t Reserved_168 : BITFIELD_RANGE(8, 11); 1498 uint32_t Reserved_172 : BITFIELD_RANGE(12, 13); 1499 uint32_t Reserved_174 : BITFIELD_RANGE(14, 14); 1500 uint32_t Reserved_175 : BITFIELD_RANGE(15, 15); 1501 uint32_t Reserved_176 : BITFIELD_RANGE(16, 17); 1502 uint32_t Reserved_178 : BITFIELD_RANGE(18, 19); 1503 uint32_t Reserved_180 : BITFIELD_RANGE(20, 20); 1504 uint32_t Reserved_181 : BITFIELD_RANGE(21, 23); 1505 uint32_t Reserved_184 : BITFIELD_RANGE(24, 24); 1506 uint32_t Reserved_185 : BITFIELD_RANGE(25, 31); 1507 // DWORD 6 1508 uint32_t Reserved_192 : BITFIELD_RANGE(0, 2); 1509 uint32_t Reserved_195 : BITFIELD_RANGE(3, 12); 1510 uint32_t Reserved_205 : BITFIELD_RANGE(13, 14); 1511 uint32_t Reserved_207 : BITFIELD_RANGE(15, 15); 1512 uint32_t Reserved_208 : BITFIELD_RANGE(16, 29); 1513 uint32_t Reserved_222 : BITFIELD_RANGE(30, 30); 1514 uint32_t Reserved_223 : BITFIELD_RANGE(31, 31); 1515 // DWORD 7 1516 uint32_t Reserved_224 : BITFIELD_RANGE(0, 11); 1517 uint32_t Reserved_236 : BITFIELD_RANGE(12, 13); 1518 uint32_t Reserved_238 : BITFIELD_RANGE(14, 15); 1519 uint32_t Reserved_240 : BITFIELD_RANGE(16, 18); 1520 uint32_t Reserved_243 : BITFIELD_RANGE(19, 21); 1521 uint32_t Reserved_246 : BITFIELD_RANGE(22, 24); 1522 uint32_t Reserved_249 : BITFIELD_RANGE(25, 27); 1523 uint32_t Reserved_252 : BITFIELD_RANGE(28, 28); 1524 uint32_t Reserved_253 : BITFIELD_RANGE(29, 29); 1525 uint32_t Reserved_254 : BITFIELD_RANGE(30, 30); 1526 uint32_t Reserved_255 : BITFIELD_RANGE(31, 31); 1527 // DWORD 8, 9 1528 uint64_t Reserved_256; 1529 // DWORD 10, 11 1530 uint64_t Reserved_320 : BITFIELD_RANGE(0, 4); 1531 uint64_t Reserved_325 : BITFIELD_RANGE(5, 9); 1532 uint64_t Reserved_330 : BITFIELD_RANGE(10, 10); 1533 uint64_t Reserved_331 : BITFIELD_RANGE(11, 11); 1534 uint64_t AuxiliarySurfaceBaseAddress : BITFIELD_RANGE(12, 63); 1535 // DWORD 12 1536 uint32_t Reserved_384 : BITFIELD_RANGE(0, 4); 1537 uint32_t Reserved_389 : BITFIELD_RANGE(5, 5); 1538 uint32_t Reserved_390 : BITFIELD_RANGE(6, 31); 1539 // DWORD 13 1540 uint32_t Reserved_416 : BITFIELD_RANGE(0, 15); 1541 uint32_t Reserved_432 : BITFIELD_RANGE(16, 31); 1542 // DWORD 14 1543 uint32_t Reserved_448; 1544 // DWORD 15 1545 uint32_t Reserved_480; 1546 } _SurfaceFormatIsnotPlanarAndMemoryCompressionEnableIs0; 1547 uint32_t RawData[16]; 1548 } TheStructure; 1549 typedef enum tagMEDIA_BOUNDARY_PIXEL_MODE { 1550 MEDIA_BOUNDARY_PIXEL_MODE_NORMAL_MODE = 0x0, 1551 MEDIA_BOUNDARY_PIXEL_MODE_PROGRESSIVE_FRAME = 0x2, 1552 MEDIA_BOUNDARY_PIXEL_MODE_INTERLACED_FRAME = 0x3, 1553 } MEDIA_BOUNDARY_PIXEL_MODE; 1554 typedef enum tagRENDER_CACHE_READ_WRITE_MODE { 1555 RENDER_CACHE_READ_WRITE_MODE_WRITE_ONLY_CACHE = 0x0, 1556 RENDER_CACHE_READ_WRITE_MODE_READ_WRITE_CACHE = 0x1, 1557 } RENDER_CACHE_READ_WRITE_MODE; 1558 typedef enum tagTILE_MODE { 1559 TILE_MODE_LINEAR = 0x0, 1560 TILE_MODE_WMAJOR = 0x1, 1561 TILE_MODE_XMAJOR = 0x2, 1562 TILE_MODE_YMAJOR = 0x3, 1563 } TILE_MODE; 1564 typedef enum tagSURFACE_HORIZONTAL_ALIGNMENT { 1565 SURFACE_HORIZONTAL_ALIGNMENT_HALIGN_4 = 0x1, 1566 SURFACE_HORIZONTAL_ALIGNMENT_HALIGN_8 = 0x2, 1567 SURFACE_HORIZONTAL_ALIGNMENT_HALIGN_16 = 0x3, 1568 } SURFACE_HORIZONTAL_ALIGNMENT; 1569 typedef enum tagSURFACE_VERTICAL_ALIGNMENT { 1570 SURFACE_VERTICAL_ALIGNMENT_VALIGN_4 = 0x1, 1571 SURFACE_VERTICAL_ALIGNMENT_VALIGN_8 = 0x2, 1572 SURFACE_VERTICAL_ALIGNMENT_VALIGN_16 = 0x3, 1573 } SURFACE_VERTICAL_ALIGNMENT; 1574 typedef enum tagSURFACE_FORMAT { 1575 SURFACE_FORMAT_R32G32B32A32_FLOAT = 0x0, 1576 SURFACE_FORMAT_R32G32B32A32_SINT = 0x1, 1577 SURFACE_FORMAT_R32G32B32A32_UINT = 0x2, 1578 SURFACE_FORMAT_R32G32B32A32_UNORM = 0x3, 1579 SURFACE_FORMAT_R32G32B32A32_SNORM = 0x4, 1580 SURFACE_FORMAT_R64G64_FLOAT = 0x5, 1581 SURFACE_FORMAT_R32G32B32X32_FLOAT = 0x6, 1582 SURFACE_FORMAT_R32G32B32A32_SSCALED = 0x7, 1583 SURFACE_FORMAT_R32G32B32A32_USCALED = 0x8, 1584 SURFACE_FORMAT_PLANAR_422_8_P208 = 0xc, 1585 SURFACE_FORMAT_PLANAR_420_8_SAMPLE_8X8 = 0xd, 1586 SURFACE_FORMAT_PLANAR_411_8 = 0xe, 1587 SURFACE_FORMAT_PLANAR_422_8 = 0xf, 1588 SURFACE_FORMAT_R8G8B8A8_UNORM_VDI = 0x10, 1589 SURFACE_FORMAT_YCRCB_NORMAL_SAMPLE_8X8 = 0x11, 1590 SURFACE_FORMAT_YCRCB_SWAPUVY_SAMPLE_8X8 = 0x12, 1591 SURFACE_FORMAT_YCRCB_SWAPUV_SAMPLE_8X8 = 0x13, 1592 SURFACE_FORMAT_YCRCB_SWAPY_SAMPLE_8X8 = 0x14, 1593 SURFACE_FORMAT_R32G32B32A32_FLOAT_LD = 0x15, 1594 SURFACE_FORMAT_PLANAR_420_16_SAMPLE_8X8 = 0x16, 1595 SURFACE_FORMAT_R16B16_UNORM_SAMPLE_8X8 = 0x17, 1596 SURFACE_FORMAT_Y16_UNORM_SAMPLE_8X8 = 0x18, 1597 SURFACE_FORMAT_PLANAR_Y32_UNORM = 0x19, 1598 SURFACE_FORMAT_R32G32B32A32_SFIXED = 0x20, 1599 SURFACE_FORMAT_R64G64_PASSTHRU = 0x21, 1600 SURFACE_FORMAT_R32G32B32_FLOAT = 0x40, 1601 SURFACE_FORMAT_R32G32B32_SINT = 0x41, 1602 SURFACE_FORMAT_R32G32B32_UINT = 0x42, 1603 SURFACE_FORMAT_R32G32B32_UNORM = 0x43, 1604 SURFACE_FORMAT_R32G32B32_SNORM = 0x44, 1605 SURFACE_FORMAT_R32G32B32_SSCALED = 0x45, 1606 SURFACE_FORMAT_R32G32B32_USCALED = 0x46, 1607 SURFACE_FORMAT_R32G32B32_FLOAT_LD = 0x47, 1608 SURFACE_FORMAT_R32G32B32_SFIXED = 0x50, 1609 SURFACE_FORMAT_R16G16B16A16_UNORM = 0x80, 1610 SURFACE_FORMAT_R16G16B16A16_SNORM = 0x81, 1611 SURFACE_FORMAT_R16G16B16A16_SINT = 0x82, 1612 SURFACE_FORMAT_R16G16B16A16_UINT = 0x83, 1613 SURFACE_FORMAT_R16G16B16A16_FLOAT = 0x84, 1614 SURFACE_FORMAT_R32G32_FLOAT = 0x85, 1615 SURFACE_FORMAT_R32G32_SINT = 0x86, 1616 SURFACE_FORMAT_R32G32_UINT = 0x87, 1617 SURFACE_FORMAT_R32_FLOAT_X8X24_TYPELESS = 0x88, 1618 SURFACE_FORMAT_X32_TYPELESS_G8X24_UINT = 0x89, 1619 SURFACE_FORMAT_L32A32_FLOAT = 0x8a, 1620 SURFACE_FORMAT_R32G32_UNORM = 0x8b, 1621 SURFACE_FORMAT_R32G32_SNORM = 0x8c, 1622 SURFACE_FORMAT_R64_FLOAT = 0x8d, 1623 SURFACE_FORMAT_R16G16B16X16_UNORM = 0x8e, 1624 SURFACE_FORMAT_R16G16B16X16_FLOAT = 0x8f, 1625 SURFACE_FORMAT_A32X32_FLOAT = 0x90, 1626 SURFACE_FORMAT_L32X32_FLOAT = 0x91, 1627 SURFACE_FORMAT_I32X32_FLOAT = 0x92, 1628 SURFACE_FORMAT_R16G16B16A16_SSCALED = 0x93, 1629 SURFACE_FORMAT_R16G16B16A16_USCALED = 0x94, 1630 SURFACE_FORMAT_R32G32_SSCALED = 0x95, 1631 SURFACE_FORMAT_R32G32_USCALED = 0x96, 1632 SURFACE_FORMAT_R32G32_FLOAT_LD = 0x97, 1633 SURFACE_FORMAT_R32_FLOAT_X8X24_TYPELESS_LD = 0x98, 1634 SURFACE_FORMAT_R32G32_SFIXED = 0xa0, 1635 SURFACE_FORMAT_R64_PASSTHRU = 0xa1, 1636 SURFACE_FORMAT_B8G8R8A8_UNORM = 0xc0, 1637 SURFACE_FORMAT_B8G8R8A8_UNORM_SRGB = 0xc1, 1638 SURFACE_FORMAT_R10G10B10A2_UNORM = 0xc2, 1639 SURFACE_FORMAT_R10G10B10A2_UNORM_SRGB = 0xc3, 1640 SURFACE_FORMAT_R10G10B10A2_UINT = 0xc4, 1641 SURFACE_FORMAT_R10G10B10_SNORM_A2_UNORM = 0xc5, 1642 SURFACE_FORMAT_R10G10B10A2_UNORM_SAMPLE_8X8 = 0xc6, 1643 SURFACE_FORMAT_R8G8B8A8_UNORM = 0xc7, 1644 SURFACE_FORMAT_R8G8B8A8_UNORM_SRGB = 0xc8, 1645 SURFACE_FORMAT_R8G8B8A8_SNORM = 0xc9, 1646 SURFACE_FORMAT_R8G8B8A8_SINT = 0xca, 1647 SURFACE_FORMAT_R8G8B8A8_UINT = 0xcb, 1648 SURFACE_FORMAT_R16G16_UNORM = 0xcc, 1649 SURFACE_FORMAT_R16G16_SNORM = 0xcd, 1650 SURFACE_FORMAT_R16G16_SINT = 0xce, 1651 SURFACE_FORMAT_R16G16_UINT = 0xcf, 1652 SURFACE_FORMAT_R16G16_FLOAT = 0xd0, 1653 SURFACE_FORMAT_B10G10R10A2_UNORM = 0xd1, 1654 SURFACE_FORMAT_B10G10R10A2_UNORM_SRGB = 0xd2, 1655 SURFACE_FORMAT_R11G11B10_FLOAT = 0xd3, 1656 SURFACE_FORMAT_R10G10B10_FLOAT_A2_UNORM = 0xd5, 1657 SURFACE_FORMAT_R32_SINT = 0xd6, 1658 SURFACE_FORMAT_R32_UINT = 0xd7, 1659 SURFACE_FORMAT_R32_FLOAT = 0xd8, 1660 SURFACE_FORMAT_R24_UNORM_X8_TYPELESS = 0xd9, 1661 SURFACE_FORMAT_X24_TYPELESS_G8_UINT = 0xda, 1662 SURFACE_FORMAT_R32_FLOAT_LD = 0xdb, 1663 SURFACE_FORMAT_R24_UNORM_X8_TYPELESS_LD = 0xdc, 1664 SURFACE_FORMAT_L32_UNORM = 0xdd, 1665 SURFACE_FORMAT_A32_UNORM = 0xde, 1666 SURFACE_FORMAT_L16A16_UNORM = 0xdf, 1667 SURFACE_FORMAT_I24X8_UNORM = 0xe0, 1668 SURFACE_FORMAT_L24X8_UNORM = 0xe1, 1669 SURFACE_FORMAT_A24X8_UNORM = 0xe2, 1670 SURFACE_FORMAT_I32_FLOAT = 0xe3, 1671 SURFACE_FORMAT_L32_FLOAT = 0xe4, 1672 SURFACE_FORMAT_A32_FLOAT = 0xe5, 1673 SURFACE_FORMAT_X8B8_UNORM_G8R8_SNORM = 0xe6, 1674 SURFACE_FORMAT_A8X8_UNORM_G8R8_SNORM = 0xe7, 1675 SURFACE_FORMAT_B8X8_UNORM_G8R8_SNORM = 0xe8, 1676 SURFACE_FORMAT_B8G8R8X8_UNORM = 0xe9, 1677 SURFACE_FORMAT_B8G8R8X8_UNORM_SRGB = 0xea, 1678 SURFACE_FORMAT_R8G8B8X8_UNORM = 0xeb, 1679 SURFACE_FORMAT_R8G8B8X8_UNORM_SRGB = 0xec, 1680 SURFACE_FORMAT_R9G9B9E5_SHAREDEXP = 0xed, 1681 SURFACE_FORMAT_B10G10R10X2_UNORM = 0xee, 1682 SURFACE_FORMAT_L16A16_FLOAT = 0xf0, 1683 SURFACE_FORMAT_R32_UNORM = 0xf1, 1684 SURFACE_FORMAT_R32_SNORM = 0xf2, 1685 SURFACE_FORMAT_R10G10B10X2_USCALED = 0xf3, 1686 SURFACE_FORMAT_R8G8B8A8_SSCALED = 0xf4, 1687 SURFACE_FORMAT_R8G8B8A8_USCALED = 0xf5, 1688 SURFACE_FORMAT_R16G16_SSCALED = 0xf6, 1689 SURFACE_FORMAT_R16G16_USCALED = 0xf7, 1690 SURFACE_FORMAT_R32_SSCALED = 0xf8, 1691 SURFACE_FORMAT_R32_USCALED = 0xf9, 1692 SURFACE_FORMAT_R8B8G8A8_UNORM = 0xfa, 1693 SURFACE_FORMAT_R8G8B8A8_SINT_NOA = 0xfb, 1694 SURFACE_FORMAT_R8G8B8A8_UINT_NOA = 0xfc, 1695 SURFACE_FORMAT_R8G8B8A8_UNORM_YUV = 0xfd, 1696 SURFACE_FORMAT_R8G8B8A8_UNORM_SNCK = 0xfe, 1697 SURFACE_FORMAT_R8G8B8A8_UNORM_NOA = 0xff, 1698 SURFACE_FORMAT_B5G6R5_UNORM = 0x100, 1699 SURFACE_FORMAT_B5G6R5_UNORM_SRGB = 0x101, 1700 SURFACE_FORMAT_B5G5R5A1_UNORM = 0x102, 1701 SURFACE_FORMAT_B5G5R5A1_UNORM_SRGB = 0x103, 1702 SURFACE_FORMAT_B4G4R4A4_UNORM = 0x104, 1703 SURFACE_FORMAT_B4G4R4A4_UNORM_SRGB = 0x105, 1704 SURFACE_FORMAT_R8G8_UNORM = 0x106, 1705 SURFACE_FORMAT_R8G8_SNORM = 0x107, 1706 SURFACE_FORMAT_R8G8_SINT = 0x108, 1707 SURFACE_FORMAT_R8G8_UINT = 0x109, 1708 SURFACE_FORMAT_R16_UNORM = 0x10a, 1709 SURFACE_FORMAT_R16_SNORM = 0x10b, 1710 SURFACE_FORMAT_R16_SINT = 0x10c, 1711 SURFACE_FORMAT_R16_UINT = 0x10d, 1712 SURFACE_FORMAT_R16_FLOAT = 0x10e, 1713 SURFACE_FORMAT_A8P8_UNORM_PALETTE0 = 0x10f, 1714 SURFACE_FORMAT_A8P8_UNORM_PALETTE1 = 0x110, 1715 SURFACE_FORMAT_I16_UNORM = 0x111, 1716 SURFACE_FORMAT_L16_UNORM = 0x112, 1717 SURFACE_FORMAT_A16_UNORM = 0x113, 1718 SURFACE_FORMAT_L8A8_UNORM = 0x114, 1719 SURFACE_FORMAT_I16_FLOAT = 0x115, 1720 SURFACE_FORMAT_L16_FLOAT = 0x116, 1721 SURFACE_FORMAT_A16_FLOAT = 0x117, 1722 SURFACE_FORMAT_L8A8_UNORM_SRGB = 0x118, 1723 SURFACE_FORMAT_R5G5_SNORM_B6_UNORM = 0x119, 1724 SURFACE_FORMAT_B5G5R5X1_UNORM = 0x11a, 1725 SURFACE_FORMAT_B5G5R5X1_UNORM_SRGB = 0x11b, 1726 SURFACE_FORMAT_R8G8_SSCALED = 0x11c, 1727 SURFACE_FORMAT_R8G8_USCALED = 0x11d, 1728 SURFACE_FORMAT_R16_SSCALED = 0x11e, 1729 SURFACE_FORMAT_R16_USCALED = 0x11f, 1730 SURFACE_FORMAT_R8G8_SNORM_DX9 = 0x120, 1731 SURFACE_FORMAT_R16_FLOAT_DX9 = 0x121, 1732 SURFACE_FORMAT_P8A8_UNORM_PALETTE0 = 0x122, 1733 SURFACE_FORMAT_P8A8_UNORM_PALETTE1 = 0x123, 1734 SURFACE_FORMAT_A1B5G5R5_UNORM = 0x124, 1735 SURFACE_FORMAT_A4B4G4R4_UNORM = 0x125, 1736 SURFACE_FORMAT_L8A8_UINT = 0x126, 1737 SURFACE_FORMAT_L8A8_SINT = 0x127, 1738 SURFACE_FORMAT_R8_UNORM = 0x140, 1739 SURFACE_FORMAT_R8_SNORM = 0x141, 1740 SURFACE_FORMAT_R8_SINT = 0x142, 1741 SURFACE_FORMAT_R8_UINT = 0x143, 1742 SURFACE_FORMAT_A8_UNORM = 0x144, 1743 SURFACE_FORMAT_I8_UNORM = 0x145, 1744 SURFACE_FORMAT_L8_UNORM = 0x146, 1745 SURFACE_FORMAT_P4A4_UNORM_PALETTE0 = 0x147, 1746 SURFACE_FORMAT_A4P4_UNORM_PALETTE0 = 0x148, 1747 SURFACE_FORMAT_R8_SSCALED = 0x149, 1748 SURFACE_FORMAT_R8_USCALED = 0x14a, 1749 SURFACE_FORMAT_P8_UNORM_PALETTE0 = 0x14b, 1750 SURFACE_FORMAT_L8_UNORM_SRGB = 0x14c, 1751 SURFACE_FORMAT_P8_UNORM_PALETTE1 = 0x14d, 1752 SURFACE_FORMAT_P4A4_UNORM_PALETTE1 = 0x14e, 1753 SURFACE_FORMAT_A4P4_UNORM_PALETTE1 = 0x14f, 1754 SURFACE_FORMAT_Y8_UNORM = 0x150, 1755 SURFACE_FORMAT_L8_UINT = 0x152, 1756 SURFACE_FORMAT_L8_SINT = 0x153, 1757 SURFACE_FORMAT_I8_UINT = 0x154, 1758 SURFACE_FORMAT_I8_SINT = 0x155, 1759 SURFACE_FORMAT_DXT1_RGB_SRGB = 0x180, 1760 SURFACE_FORMAT_R1_UNORM = 0x181, 1761 SURFACE_FORMAT_YCRCB_NORMAL = 0x182, 1762 SURFACE_FORMAT_YCRCB_SWAPUVY = 0x183, 1763 SURFACE_FORMAT_P2_UNORM_PALETTE0 = 0x184, 1764 SURFACE_FORMAT_P2_UNORM_PALETTE1 = 0x185, 1765 SURFACE_FORMAT_BC1_UNORM = 0x186, 1766 SURFACE_FORMAT_BC2_UNORM = 0x187, 1767 SURFACE_FORMAT_BC3_UNORM = 0x188, 1768 SURFACE_FORMAT_BC4_UNORM = 0x189, 1769 SURFACE_FORMAT_BC5_UNORM = 0x18a, 1770 SURFACE_FORMAT_BC1_UNORM_SRGB = 0x18b, 1771 SURFACE_FORMAT_BC2_UNORM_SRGB = 0x18c, 1772 SURFACE_FORMAT_BC3_UNORM_SRGB = 0x18d, 1773 SURFACE_FORMAT_MONO8 = 0x18e, 1774 SURFACE_FORMAT_YCRCB_SWAPUV = 0x18f, 1775 SURFACE_FORMAT_YCRCB_SWAPY = 0x190, 1776 SURFACE_FORMAT_DXT1_RGB = 0x191, 1777 SURFACE_FORMAT_FXT1 = 0x192, 1778 SURFACE_FORMAT_R8G8B8_UNORM = 0x193, 1779 SURFACE_FORMAT_R8G8B8_SNORM = 0x194, 1780 SURFACE_FORMAT_R8G8B8_SSCALED = 0x195, 1781 SURFACE_FORMAT_R8G8B8_USCALED = 0x196, 1782 SURFACE_FORMAT_R64G64B64A64_FLOAT = 0x197, 1783 SURFACE_FORMAT_R64G64B64_FLOAT = 0x198, 1784 SURFACE_FORMAT_BC4_SNORM = 0x199, 1785 SURFACE_FORMAT_BC5_SNORM = 0x19a, 1786 SURFACE_FORMAT_R16G16B16_FLOAT = 0x19b, 1787 SURFACE_FORMAT_R16G16B16_UNORM = 0x19c, 1788 SURFACE_FORMAT_R16G16B16_SNORM = 0x19d, 1789 SURFACE_FORMAT_R16G16B16_SSCALED = 0x19e, 1790 SURFACE_FORMAT_R16G16B16_USCALED = 0x19f, 1791 SURFACE_FORMAT_R8B8_UNORM = 0x1a0, 1792 SURFACE_FORMAT_BC6H_SF16 = 0x1a1, 1793 SURFACE_FORMAT_BC7_UNORM = 0x1a2, 1794 SURFACE_FORMAT_BC7_UNORM_SRGB = 0x1a3, 1795 SURFACE_FORMAT_BC6H_UF16 = 0x1a4, 1796 SURFACE_FORMAT_PLANAR_420_8 = 0x1a5, 1797 SURFACE_FORMAT_PLANAR_420_16 = 0x1a6, 1798 SURFACE_FORMAT_R8G8B8_UNORM_SRGB = 0x1a8, 1799 SURFACE_FORMAT_ETC1_RGB8 = 0x1a9, 1800 SURFACE_FORMAT_ETC2_RGB8 = 0x1aa, 1801 SURFACE_FORMAT_EAC_R11 = 0x1ab, 1802 SURFACE_FORMAT_EAC_RG11 = 0x1ac, 1803 SURFACE_FORMAT_EAC_SIGNED_R11 = 0x1ad, 1804 SURFACE_FORMAT_EAC_SIGNED_RG11 = 0x1ae, 1805 SURFACE_FORMAT_ETC2_SRGB8 = 0x1af, 1806 SURFACE_FORMAT_R16G16B16_UINT = 0x1b0, 1807 SURFACE_FORMAT_R16G16B16_SINT = 0x1b1, 1808 SURFACE_FORMAT_R32_SFIXED = 0x1b2, 1809 SURFACE_FORMAT_R10G10B10A2_SNORM = 0x1b3, 1810 SURFACE_FORMAT_R10G10B10A2_USCALED = 0x1b4, 1811 SURFACE_FORMAT_R10G10B10A2_SSCALED = 0x1b5, 1812 SURFACE_FORMAT_R10G10B10A2_SINT = 0x1b6, 1813 SURFACE_FORMAT_B10G10R10A2_SNORM = 0x1b7, 1814 SURFACE_FORMAT_B10G10R10A2_USCALED = 0x1b8, 1815 SURFACE_FORMAT_B10G10R10A2_SSCALED = 0x1b9, 1816 SURFACE_FORMAT_B10G10R10A2_UINT = 0x1ba, 1817 SURFACE_FORMAT_B10G10R10A2_SINT = 0x1bb, 1818 SURFACE_FORMAT_R64G64B64A64_PASSTHRU = 0x1bc, 1819 SURFACE_FORMAT_R64G64B64_PASSTHRU = 0x1bd, 1820 SURFACE_FORMAT_ETC2_RGB8_PTA = 0x1c0, 1821 SURFACE_FORMAT_ETC2_SRGB8_PTA = 0x1c1, 1822 SURFACE_FORMAT_ETC2_EAC_RGBA8 = 0x1c2, 1823 SURFACE_FORMAT_ETC2_EAC_SRGB8_A8 = 0x1c3, 1824 SURFACE_FORMAT_R8G8B8_UINT = 0x1c8, 1825 SURFACE_FORMAT_R8G8B8_SINT = 0x1c9, 1826 SURFACE_FORMAT_RAW = 0x1ff, 1827 } SURFACE_FORMAT; 1828 typedef enum tagSURFACE_TYPE { 1829 SURFACE_TYPE_SURFTYPE_1D = 0x0, 1830 SURFACE_TYPE_SURFTYPE_2D = 0x1, 1831 SURFACE_TYPE_SURFTYPE_3D = 0x2, 1832 SURFACE_TYPE_SURFTYPE_CUBE = 0x3, 1833 SURFACE_TYPE_SURFTYPE_BUFFER = 0x4, 1834 SURFACE_TYPE_SURFTYPE_STRBUF = 0x5, 1835 SURFACE_TYPE_SURFTYPE_SCRATCH = 0x6, 1836 SURFACE_TYPE_SURFTYPE_NULL = 0x7, 1837 } SURFACE_TYPE; 1838 typedef enum tagSAMPLE_TAP_DISCARD_DISABLE { 1839 SAMPLE_TAP_DISCARD_DISABLE_DISABLE = 0x0, 1840 SAMPLE_TAP_DISCARD_DISABLE_ENABLE = 0x1, 1841 } SAMPLE_TAP_DISCARD_DISABLE; 1842 typedef enum tagNULL_PROBING_ENABLE { 1843 NULL_PROBING_ENABLE_DISABLE = 0x0, 1844 NULL_PROBING_ENABLE_ENABLE = 0x1, 1845 } NULL_PROBING_ENABLE; 1846 typedef enum tagNUMBER_OF_MULTISAMPLES { 1847 NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_1 = 0x0, 1848 NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_2 = 0x1, 1849 NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_4 = 0x2, 1850 NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_8 = 0x3, 1851 NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_16 = 0x4, 1852 } NUMBER_OF_MULTISAMPLES; 1853 typedef enum tagMULTISAMPLED_SURFACE_STORAGE_FORMAT { 1854 MULTISAMPLED_SURFACE_STORAGE_FORMAT_MSS = 0x0, 1855 MULTISAMPLED_SURFACE_STORAGE_FORMAT_DEPTH_STENCIL = 0x1, 1856 } MULTISAMPLED_SURFACE_STORAGE_FORMAT; 1857 typedef enum tagRENDER_TARGET_AND_SAMPLE_UNORM_ROTATION { 1858 RENDER_TARGET_AND_SAMPLE_UNORM_ROTATION_0DEG = 0x0, 1859 RENDER_TARGET_AND_SAMPLE_UNORM_ROTATION_90DEG = 0x1, 1860 RENDER_TARGET_AND_SAMPLE_UNORM_ROTATION_180DEG = 0x2, 1861 RENDER_TARGET_AND_SAMPLE_UNORM_ROTATION_270DEG = 0x3, 1862 } RENDER_TARGET_AND_SAMPLE_UNORM_ROTATION; 1863 typedef enum tagCOHERENCY_TYPE { 1864 COHERENCY_TYPE_GPU_COHERENT = 0x0, 1865 COHERENCY_TYPE_IA_COHERENT = 0x1, 1866 } COHERENCY_TYPE; 1867 typedef enum tagTILED_RESOURCE_MODE { 1868 TILED_RESOURCE_MODE_NONE = 0x0, 1869 TILED_RESOURCE_MODE_4KB = 0x1, 1870 TILED_RESOURCE_MODE_TILEYF = 0x1, 1871 TILED_RESOURCE_MODE_64KB = 0x2, 1872 TILED_RESOURCE_MODE_TILEYS = 0x2, 1873 } TILED_RESOURCE_MODE; 1874 typedef enum tagAUXILIARY_SURFACE_MODE { 1875 AUXILIARY_SURFACE_MODE_AUX_NONE = 0x0, 1876 AUXILIARY_SURFACE_MODE_AUX_CCS_D = 0x1, 1877 AUXILIARY_SURFACE_MODE_AUX_APPEND = 0x2, 1878 AUXILIARY_SURFACE_MODE_AUX_MCS_LCE = 0x4, 1879 AUXILIARY_SURFACE_MODE_AUX_CCS_E = 0x5, 1880 } AUXILIARY_SURFACE_MODE; 1881 typedef enum tagHALF_PITCH_FOR_CHROMA { 1882 HALF_PITCH_FOR_CHROMA_DISABLE = 0x0, 1883 HALF_PITCH_FOR_CHROMA_ENABLE = 0x1, 1884 } HALF_PITCH_FOR_CHROMA; 1885 typedef enum tagSHADER_CHANNEL_SELECT { 1886 SHADER_CHANNEL_SELECT_ZERO = 0x0, 1887 SHADER_CHANNEL_SELECT_ONE = 0x1, 1888 SHADER_CHANNEL_SELECT_RED = 0x4, 1889 SHADER_CHANNEL_SELECT_GREEN = 0x5, 1890 SHADER_CHANNEL_SELECT_BLUE = 0x6, 1891 SHADER_CHANNEL_SELECT_ALPHA = 0x7, 1892 } SHADER_CHANNEL_SELECT; 1893 typedef enum tagMEMORY_COMPRESSION_MODE { 1894 MEMORY_COMPRESSION_MODE_HORIZONTAL = 0x0, 1895 } MEMORY_COMPRESSION_MODE; 1896 inline void init() { 1897 memset(&TheStructure, 0, sizeof(TheStructure)); 1898 TheStructure.Common.MediaBoundaryPixelMode = MEDIA_BOUNDARY_PIXEL_MODE_NORMAL_MODE; 1899 TheStructure.Common.RenderCacheReadWriteMode = RENDER_CACHE_READ_WRITE_MODE_WRITE_ONLY_CACHE; 1900 TheStructure.Common.TileMode = TILE_MODE_LINEAR; 1901 TheStructure.Common.SurfaceHorizontalAlignment = SURFACE_HORIZONTAL_ALIGNMENT_HALIGN_16; 1902 TheStructure.Common.SurfaceVerticalAlignment = SURFACE_VERTICAL_ALIGNMENT_VALIGN_4; 1903 TheStructure.Common.SurfaceType = SURFACE_TYPE_SURFTYPE_1D; 1904 TheStructure.Common.SampleTapDiscardDisable = SAMPLE_TAP_DISCARD_DISABLE_DISABLE; 1905 TheStructure.Common.NullProbingEnable = NULL_PROBING_ENABLE_DISABLE; 1906 TheStructure.Common.NumberOfMultisamples = NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_1; 1907 TheStructure.Common.MultisampledSurfaceStorageFormat = MULTISAMPLED_SURFACE_STORAGE_FORMAT_MSS; 1908 TheStructure.Common.RenderTargetAndSampleUnormRotation = RENDER_TARGET_AND_SAMPLE_UNORM_ROTATION_0DEG; 1909 TheStructure.Common.CoherencyType = COHERENCY_TYPE_GPU_COHERENT; 1910 TheStructure.Common.MemoryCompressionMode = MEMORY_COMPRESSION_MODE_HORIZONTAL; 1911 TheStructure._SurfaceFormatIsnotPlanar.AuxiliarySurfaceMode = AUXILIARY_SURFACE_MODE_AUX_NONE; 1912 TheStructure._SurfaceFormatIsPlanar.HalfPitchForChroma = HALF_PITCH_FOR_CHROMA_DISABLE; 1913 TheStructure.Common.DisableSupportForMultiGpuAtomics = 1; 1914 TheStructure.Common.DisableSupportForMultiGpuPartialWrites = 1; 1915 } 1916 static tagRENDER_SURFACE_STATE sInit() { 1917 RENDER_SURFACE_STATE state; 1918 state.init(); 1919 return state; 1920 } 1921 inline uint32_t &getRawData(const uint32_t index) { 1922 UNRECOVERABLE_IF(index >= 16); 1923 return TheStructure.RawData[index]; 1924 } 1925 inline void setCubeFaceEnablePositiveZ(const bool value) { 1926 TheStructure.Common.CubeFaceEnablePositiveZ = value; 1927 } 1928 inline bool getCubeFaceEnablePositiveZ() const { 1929 return TheStructure.Common.CubeFaceEnablePositiveZ; 1930 } 1931 inline void setCubeFaceEnableNegativeZ(const bool value) { 1932 TheStructure.Common.CubeFaceEnableNegativeZ = value; 1933 } 1934 inline bool getCubeFaceEnableNegativeZ() const { 1935 return TheStructure.Common.CubeFaceEnableNegativeZ; 1936 } 1937 inline void setCubeFaceEnablePositiveY(const bool value) { 1938 TheStructure.Common.CubeFaceEnablePositiveY = value; 1939 } 1940 inline bool getCubeFaceEnablePositiveY() const { 1941 return TheStructure.Common.CubeFaceEnablePositiveY; 1942 } 1943 inline void setCubeFaceEnableNegativeY(const bool value) { 1944 TheStructure.Common.CubeFaceEnableNegativeY = value; 1945 } 1946 inline bool getCubeFaceEnableNegativeY() const { 1947 return TheStructure.Common.CubeFaceEnableNegativeY; 1948 } 1949 inline void setCubeFaceEnablePositiveX(const bool value) { 1950 TheStructure.Common.CubeFaceEnablePositiveX = value; 1951 } 1952 inline bool getCubeFaceEnablePositiveX() const { 1953 return TheStructure.Common.CubeFaceEnablePositiveX; 1954 } 1955 inline void setCubeFaceEnableNegativeX(const bool value) { 1956 TheStructure.Common.CubeFaceEnableNegativeX = value; 1957 } 1958 inline bool getCubeFaceEnableNegativeX() const { 1959 return TheStructure.Common.CubeFaceEnableNegativeX; 1960 } 1961 inline void setMediaBoundaryPixelMode(const MEDIA_BOUNDARY_PIXEL_MODE value) { 1962 TheStructure.Common.MediaBoundaryPixelMode = value; 1963 } 1964 inline MEDIA_BOUNDARY_PIXEL_MODE getMediaBoundaryPixelMode() const { 1965 return static_cast<MEDIA_BOUNDARY_PIXEL_MODE>(TheStructure.Common.MediaBoundaryPixelMode); 1966 } 1967 inline void setRenderCacheReadWriteMode(const RENDER_CACHE_READ_WRITE_MODE value) { 1968 TheStructure.Common.RenderCacheReadWriteMode = value; 1969 } 1970 inline RENDER_CACHE_READ_WRITE_MODE getRenderCacheReadWriteMode() const { 1971 return static_cast<RENDER_CACHE_READ_WRITE_MODE>(TheStructure.Common.RenderCacheReadWriteMode); 1972 } 1973 inline void setSamplerL2OutOfOrderModeDisable(const bool value) { 1974 TheStructure.Common.SamplerL2OutOfOrderModeDisable = value; 1975 } 1976 inline bool getSamplerL2OutOfOrderModeDisable() const { 1977 return TheStructure.Common.SamplerL2OutOfOrderModeDisable; 1978 } 1979 inline void setVerticalLineStrideOffset(const bool value) { 1980 TheStructure.Common.VerticalLineStrideOffset = value; 1981 } 1982 inline bool getVerticalLineStrideOffset() const { 1983 return TheStructure.Common.VerticalLineStrideOffset; 1984 } 1985 inline void setVerticalLineStride(const bool value) { 1986 TheStructure.Common.VerticalLineStride = value; 1987 } 1988 inline bool getVerticalLineStride() const { 1989 return TheStructure.Common.VerticalLineStride; 1990 } 1991 inline void setTileMode(const TILE_MODE value) { 1992 TheStructure.Common.TileMode = value; 1993 } 1994 inline TILE_MODE getTileMode() const { 1995 return static_cast<TILE_MODE>(TheStructure.Common.TileMode); 1996 } 1997 inline void setSurfaceHorizontalAlignment(const SURFACE_HORIZONTAL_ALIGNMENT value) { 1998 TheStructure.Common.SurfaceHorizontalAlignment = value; 1999 } 2000 inline SURFACE_HORIZONTAL_ALIGNMENT getSurfaceHorizontalAlignment() const { 2001 return static_cast<SURFACE_HORIZONTAL_ALIGNMENT>(TheStructure.Common.SurfaceHorizontalAlignment); 2002 } 2003 inline void setSurfaceVerticalAlignment(const SURFACE_VERTICAL_ALIGNMENT value) { 2004 TheStructure.Common.SurfaceVerticalAlignment = value; 2005 } 2006 inline SURFACE_VERTICAL_ALIGNMENT getSurfaceVerticalAlignment() const { 2007 return static_cast<SURFACE_VERTICAL_ALIGNMENT>(TheStructure.Common.SurfaceVerticalAlignment); 2008 } 2009 inline void setSurfaceFormat(const SURFACE_FORMAT value) { 2010 TheStructure.Common.SurfaceFormat = value; 2011 } 2012 inline SURFACE_FORMAT getSurfaceFormat() const { 2013 return static_cast<SURFACE_FORMAT>(TheStructure.Common.SurfaceFormat); 2014 } 2015 inline void setAstcEnable(const bool value) { 2016 TheStructure.Common.AstcEnable = value; 2017 } 2018 inline bool getAstcEnable() const { 2019 return TheStructure.Common.AstcEnable; 2020 } 2021 inline void setSurfaceArray(const bool value) { 2022 TheStructure.Common.SurfaceArray = value; 2023 } 2024 inline bool getSurfaceArray() const { 2025 return TheStructure.Common.SurfaceArray; 2026 } 2027 inline void setSurfaceType(const SURFACE_TYPE value) { 2028 TheStructure.Common.SurfaceType = value; 2029 } 2030 inline SURFACE_TYPE getSurfaceType() const { 2031 return static_cast<SURFACE_TYPE>(TheStructure.Common.SurfaceType); 2032 } 2033 typedef enum tagSURFACEQPITCH { 2034 SURFACEQPITCH_BIT_SHIFT = 0x2, 2035 SURFACEQPITCH_ALIGN_SIZE = 0x4, 2036 } SURFACEQPITCH; 2037 inline void setSurfaceQpitch(const uint32_t value) { 2038 DEBUG_BREAK_IF(value > 0x7fff); 2039 TheStructure.Common.SurfaceQpitch = value >> SURFACEQPITCH_BIT_SHIFT; 2040 } 2041 inline uint32_t getSurfaceQpitch() const { 2042 return TheStructure.Common.SurfaceQpitch << SURFACEQPITCH_BIT_SHIFT; 2043 } 2044 inline void setSampleTapDiscardDisable(const SAMPLE_TAP_DISCARD_DISABLE value) { 2045 TheStructure.Common.SampleTapDiscardDisable = value; 2046 } 2047 inline SAMPLE_TAP_DISCARD_DISABLE getSampleTapDiscardDisable() const { 2048 return static_cast<SAMPLE_TAP_DISCARD_DISABLE>(TheStructure.Common.SampleTapDiscardDisable); 2049 } 2050 inline void setDoubleFetchDisable(const bool value) { 2051 TheStructure.Common.DoubleFetchDisable = value; 2052 } 2053 inline bool getDoubleFetchDisable() const { 2054 return TheStructure.Common.DoubleFetchDisable; 2055 } 2056 inline void setCornerTexelMode(const bool value) { 2057 TheStructure.Common.CornerTexelMode = value; 2058 } 2059 inline bool getCornerTexelMode() const { 2060 return TheStructure.Common.CornerTexelMode; 2061 } 2062 inline void setBaseMipLevel(const uint32_t value) { 2063 UNRECOVERABLE_IF(value > 0xf80000); 2064 TheStructure.Common.BaseMipLevel = value; 2065 } 2066 inline uint32_t getBaseMipLevel() const { 2067 return TheStructure.Common.BaseMipLevel; 2068 } 2069 inline void setMemoryObjectControlState(const uint32_t value) { 2070 TheStructure.Common.MemoryObjectControlStateEncryptedData = value; 2071 TheStructure.Common.MemoryObjectControlStateIndexToMocsTables = (value >> 1); 2072 } 2073 inline uint32_t getMemoryObjectControlState() const { 2074 uint32_t mocs = TheStructure.Common.MemoryObjectControlStateEncryptedData; 2075 mocs |= (TheStructure.Common.MemoryObjectControlStateIndexToMocsTables << 1); 2076 return (mocs); 2077 } 2078 inline void setEnableUnormPathInColorPipe(const bool value) { 2079 TheStructure.Common.EnableUnormPathInColorPipe = value; 2080 } 2081 inline bool getEnableUnormPathInColorPipe() const { 2082 return TheStructure.Common.EnableUnormPathInColorPipe; 2083 } 2084 inline void setWidth(const uint32_t value) { 2085 UNRECOVERABLE_IF(value > (0x3fff + 1)); 2086 TheStructure.Common.Width = value - 1; 2087 } 2088 inline uint32_t getWidth() const { 2089 return TheStructure.Common.Width + 1; 2090 } 2091 inline void setHeight(const uint32_t value) { 2092 UNRECOVERABLE_IF(value > (0x3fff0000 + 1)); 2093 TheStructure.Common.Height = value - 1; 2094 } 2095 inline uint32_t getHeight() const { 2096 return TheStructure.Common.Height + 1; 2097 } 2098 inline void setDepthStencilResource(const bool value) { 2099 TheStructure.Common.DepthStencilResource = value; 2100 } 2101 inline bool getDepthStencilResource() const { 2102 return TheStructure.Common.DepthStencilResource; 2103 } 2104 inline void setSurfacePitch(const uint32_t value) { 2105 UNRECOVERABLE_IF(value > (0x3ffff + 1)); 2106 TheStructure.Common.SurfacePitch = value - 1; 2107 } 2108 inline uint32_t getSurfacePitch() const { 2109 return TheStructure.Common.SurfacePitch + 1; 2110 } 2111 inline void setNullProbingEnable(const NULL_PROBING_ENABLE value) { 2112 TheStructure.Common.NullProbingEnable = value; 2113 } 2114 inline NULL_PROBING_ENABLE getNullProbingEnable() const { 2115 return static_cast<NULL_PROBING_ENABLE>(TheStructure.Common.NullProbingEnable); 2116 } 2117 inline void setDepth(const uint32_t value) { 2118 UNRECOVERABLE_IF(value > (0xffe00000 + 1)); 2119 TheStructure.Common.Depth = value - 1; 2120 } 2121 inline uint32_t getDepth() const { 2122 return TheStructure.Common.Depth + 1; 2123 } 2124 inline void setMultisamplePositionPaletteIndex(const uint32_t value) { 2125 UNRECOVERABLE_IF(value > 0x7); 2126 TheStructure.Common.MultisamplePositionPaletteIndex = value; 2127 } 2128 inline uint32_t getMultisamplePositionPaletteIndex() const { 2129 return TheStructure.Common.MultisamplePositionPaletteIndex; 2130 } 2131 inline void setNumberOfMultisamples(const NUMBER_OF_MULTISAMPLES value) { 2132 TheStructure.Common.NumberOfMultisamples = value; 2133 } 2134 inline NUMBER_OF_MULTISAMPLES getNumberOfMultisamples() const { 2135 return static_cast<NUMBER_OF_MULTISAMPLES>(TheStructure.Common.NumberOfMultisamples); 2136 } 2137 inline void setMultisampledSurfaceStorageFormat(const MULTISAMPLED_SURFACE_STORAGE_FORMAT value) { 2138 TheStructure.Common.MultisampledSurfaceStorageFormat = value; 2139 } 2140 inline MULTISAMPLED_SURFACE_STORAGE_FORMAT getMultisampledSurfaceStorageFormat() const { 2141 return static_cast<MULTISAMPLED_SURFACE_STORAGE_FORMAT>(TheStructure.Common.MultisampledSurfaceStorageFormat); 2142 } 2143 inline void setRenderTargetViewExtent(const uint32_t value) { 2144 UNRECOVERABLE_IF(value > (0x3ff80 + 1)); 2145 TheStructure.Common.RenderTargetViewExtent = value - 1; 2146 } 2147 inline uint32_t getRenderTargetViewExtent() const { 2148 return TheStructure.Common.RenderTargetViewExtent + 1; 2149 } 2150 inline void setMinimumArrayElement(const uint32_t value) { 2151 UNRECOVERABLE_IF(value > 0x1ffc0000); 2152 TheStructure.Common.MinimumArrayElement = value; 2153 } 2154 inline uint32_t getMinimumArrayElement() const { 2155 return TheStructure.Common.MinimumArrayElement; 2156 } 2157 inline void setRenderTargetAndSampleUnormRotation(const RENDER_TARGET_AND_SAMPLE_UNORM_ROTATION value) { 2158 TheStructure.Common.RenderTargetAndSampleUnormRotation = value; 2159 } 2160 inline RENDER_TARGET_AND_SAMPLE_UNORM_ROTATION getRenderTargetAndSampleUnormRotation() const { 2161 return static_cast<RENDER_TARGET_AND_SAMPLE_UNORM_ROTATION>(TheStructure.Common.RenderTargetAndSampleUnormRotation); 2162 } 2163 inline void setMipCountLod(const uint32_t value) { 2164 UNRECOVERABLE_IF(value > 0xf); 2165 TheStructure.Common.MipCountLod = value; 2166 } 2167 inline uint32_t getMipCountLod() const { 2168 return TheStructure.Common.MipCountLod; 2169 } 2170 inline void setSurfaceMinLod(const uint32_t value) { 2171 UNRECOVERABLE_IF(value > 0xf0); 2172 TheStructure.Common.SurfaceMinLod = value; 2173 } 2174 inline uint32_t getSurfaceMinLod() const { 2175 return TheStructure.Common.SurfaceMinLod; 2176 } 2177 inline void setMipTailStartLod(const uint32_t value) { 2178 UNRECOVERABLE_IF(value > 0xf00); 2179 TheStructure.Common.MipTailStartLod = value; 2180 } 2181 inline uint32_t getMipTailStartLod() const { 2182 return TheStructure.Common.MipTailStartLod; 2183 } 2184 inline void setCoherencyType(const COHERENCY_TYPE value) { 2185 TheStructure.Common.CoherencyType = value; 2186 } 2187 inline COHERENCY_TYPE getCoherencyType() const { 2188 return static_cast<COHERENCY_TYPE>(TheStructure.Common.CoherencyType); 2189 } 2190 inline void setEwaDisableForCube(const bool value) { 2191 TheStructure.Common.EwaDisableForCube = value; 2192 } 2193 inline bool getEwaDisableForCube() const { 2194 return TheStructure.Common.EwaDisableForCube; 2195 } 2196 typedef enum tagYOFFSET { 2197 YOFFSET_BIT_SHIFT = 0x2, 2198 YOFFSET_ALIGN_SIZE = 0x4, 2199 } YOFFSET; 2200 inline void setYOffset(const uint32_t value) { 2201 UNRECOVERABLE_IF(value > 0xe00000); 2202 TheStructure.Common.YOffset = value >> YOFFSET_BIT_SHIFT; 2203 } 2204 inline uint32_t getYOffset() const { 2205 return TheStructure.Common.YOffset << YOFFSET_BIT_SHIFT; 2206 } 2207 typedef enum tagXOFFSET { 2208 XOFFSET_BIT_SHIFT = 0x2, 2209 XOFFSET_ALIGN_SIZE = 0x4, 2210 } XOFFSET; 2211 inline void setXOffset(const uint32_t value) { 2212 UNRECOVERABLE_IF(value > 0xfe000000); 2213 TheStructure.Common.XOffset = value >> XOFFSET_BIT_SHIFT; 2214 } 2215 inline uint32_t getXOffset() const { 2216 return TheStructure.Common.XOffset << XOFFSET_BIT_SHIFT; 2217 } 2218 inline void setResourceMinLod(const uint32_t value) { 2219 UNRECOVERABLE_IF(value > 0xfff); 2220 TheStructure.Common.ResourceMinLod = value; 2221 } 2222 inline uint32_t getResourceMinLod() const { 2223 return TheStructure.Common.ResourceMinLod; 2224 } 2225 inline void setDisableSupportForMultiGpuAtomics(const bool value) { 2226 TheStructure.Common.DisableSupportForMultiGpuAtomics = value; 2227 } 2228 inline bool getDisableSupportForMultiGpuAtomics() const { 2229 return TheStructure.Common.DisableSupportForMultiGpuAtomics; 2230 } 2231 inline void setDisableSupportForMultiGpuPartialWrites(const bool value) { 2232 TheStructure.Common.DisableSupportForMultiGpuPartialWrites = value; 2233 } 2234 inline bool getDisableSupportForMultiGpuPartialWrites() const { 2235 return TheStructure.Common.DisableSupportForMultiGpuPartialWrites; 2236 } 2237 inline void setShaderChannelSelectAlpha(const SHADER_CHANNEL_SELECT value) { 2238 TheStructure.Common.ShaderChannelSelectAlpha = value; 2239 } 2240 inline SHADER_CHANNEL_SELECT getShaderChannelSelectAlpha() const { 2241 return static_cast<SHADER_CHANNEL_SELECT>(TheStructure.Common.ShaderChannelSelectAlpha); 2242 } 2243 inline void setShaderChannelSelectBlue(const SHADER_CHANNEL_SELECT value) { 2244 TheStructure.Common.ShaderChannelSelectBlue = value; 2245 } 2246 inline SHADER_CHANNEL_SELECT getShaderChannelSelectBlue() const { 2247 return static_cast<SHADER_CHANNEL_SELECT>(TheStructure.Common.ShaderChannelSelectBlue); 2248 } 2249 inline void setShaderChannelSelectGreen(const SHADER_CHANNEL_SELECT value) { 2250 TheStructure.Common.ShaderChannelSelectGreen = value; 2251 } 2252 inline SHADER_CHANNEL_SELECT getShaderChannelSelectGreen() const { 2253 return static_cast<SHADER_CHANNEL_SELECT>(TheStructure.Common.ShaderChannelSelectGreen); 2254 } 2255 inline void setShaderChannelSelectRed(const SHADER_CHANNEL_SELECT value) { 2256 TheStructure.Common.ShaderChannelSelectRed = value; 2257 } 2258 inline SHADER_CHANNEL_SELECT getShaderChannelSelectRed() const { 2259 return static_cast<SHADER_CHANNEL_SELECT>(TheStructure.Common.ShaderChannelSelectRed); 2260 } 2261 inline void setMemoryCompressionEnable(const bool value) { 2262 TheStructure.Common.MemoryCompressionEnable = value; 2263 } 2264 inline bool getMemoryCompressionEnable() const { 2265 return TheStructure.Common.MemoryCompressionEnable; 2266 } 2267 inline void setMemoryCompressionMode(const MEMORY_COMPRESSION_MODE value) { 2268 TheStructure.Common.MemoryCompressionMode = value; 2269 } 2270 inline MEMORY_COMPRESSION_MODE getMemoryCompressionMode() const { 2271 return static_cast<MEMORY_COMPRESSION_MODE>(TheStructure.Common.MemoryCompressionMode); 2272 } 2273 inline void setCompressionFormat(uint32_t compressionFormat) { 2274 UNRECOVERABLE_IF(compressionFormat > 0x1F); 2275 TheStructure.Common.CompressionFormat = compressionFormat; 2276 } 2277 inline uint32_t getCompressionFormat() const { 2278 return TheStructure.Common.CompressionFormat; 2279 } 2280 inline void setSurfaceBaseAddress(const uint64_t value) { 2281 TheStructure.Common.SurfaceBaseAddress = value; 2282 } 2283 inline uint64_t getSurfaceBaseAddress() const { 2284 return TheStructure.Common.SurfaceBaseAddress; 2285 } 2286 inline void setQuiltWidth(const uint64_t value) { 2287 UNRECOVERABLE_IF(value > 0x1fL); 2288 TheStructure.Common.QuiltWidth = value; 2289 } 2290 inline uint64_t getQuiltWidth() const { 2291 return TheStructure.Common.QuiltWidth; 2292 } 2293 inline void setQuiltHeight(const uint64_t value) { 2294 UNRECOVERABLE_IF(value > 0x3e0L); 2295 TheStructure.Common.QuiltHeight = value; 2296 } 2297 inline uint64_t getQuiltHeight() const { 2298 return TheStructure.Common.QuiltHeight; 2299 } 2300 inline void setClearValueAddressEnable(const bool value) { 2301 TheStructure.Common.ClearValueAddressEnable = value; 2302 } 2303 inline bool getClearValueAddressEnable() const { 2304 return TheStructure.Common.ClearValueAddressEnable; 2305 } 2306 inline void setProceduralTexture(const bool value) { 2307 TheStructure.Common.ProceduralTexture = value; 2308 } 2309 inline bool getProceduralTexture() const { 2310 return TheStructure.Common.ProceduralTexture; 2311 } 2312 typedef enum tagCLEARADDRESSLOW { 2313 CLEARADDRESSLOW_BIT_SHIFT = 0x6, 2314 CLEARADDRESSLOW_ALIGN_SIZE = 0x40, 2315 } CLEARADDRESSLOW; 2316 inline void setClearColorAddress(const uint32_t value) { 2317 UNRECOVERABLE_IF(value > 0xffffffc0); 2318 TheStructure.Common.ClearColorAddress = value >> CLEARADDRESSLOW_BIT_SHIFT; 2319 } 2320 inline uint32_t getClearColorAddress() const { 2321 return TheStructure.Common.ClearColorAddress << CLEARADDRESSLOW_BIT_SHIFT; 2322 } 2323 inline void setClearColorAddressHigh(const uint32_t value) { 2324 UNRECOVERABLE_IF(value > 0xffff); 2325 TheStructure.Common.ClearColorAddressHigh = value; 2326 } 2327 inline uint32_t getClearColorAddressHigh() const { 2328 return TheStructure.Common.ClearColorAddressHigh; 2329 } 2330 inline void setDisallowLowQualityFlitering(const bool value) { 2331 TheStructure.Common.DisallowLowQualityFlitering = value; 2332 } 2333 inline bool getDisallowLowQualityFlitering() const { 2334 return TheStructure.Common.DisallowLowQualityFlitering; 2335 } 2336 inline void setAuxiliarySurfaceMode(const AUXILIARY_SURFACE_MODE value) { 2337 TheStructure._SurfaceFormatIsnotPlanar.AuxiliarySurfaceMode = value; 2338 } 2339 inline AUXILIARY_SURFACE_MODE getAuxiliarySurfaceMode() const { 2340 return static_cast<AUXILIARY_SURFACE_MODE>(TheStructure._SurfaceFormatIsnotPlanar.AuxiliarySurfaceMode); 2341 } 2342 inline void setAuxiliarySurfacePitch(const uint32_t value) { 2343 UNRECOVERABLE_IF(value > (0x1ff8 + 1)); 2344 TheStructure._SurfaceFormatIsnotPlanar.AuxiliarySurfacePitch = value - 1; 2345 } 2346 inline uint32_t getAuxiliarySurfacePitch() const { 2347 return TheStructure._SurfaceFormatIsnotPlanar.AuxiliarySurfacePitch + 1; 2348 } 2349 typedef enum tagAUXILIARYSURFACEQPITCH { 2350 AUXILIARYSURFACEQPITCH_BIT_SHIFT = 0x2, 2351 AUXILIARYSURFACEQPITCH_ALIGN_SIZE = 0x4, 2352 } AUXILIARYSURFACEQPITCH; 2353 inline void setAuxiliarySurfaceQpitch(const uint32_t value) { 2354 UNRECOVERABLE_IF(value > 0x7fff0000); 2355 TheStructure._SurfaceFormatIsnotPlanar.AuxiliarySurfaceQpitch = value >> AUXILIARYSURFACEQPITCH_BIT_SHIFT; 2356 } 2357 inline uint32_t getAuxiliarySurfaceQpitch() const { 2358 return TheStructure._SurfaceFormatIsnotPlanar.AuxiliarySurfaceQpitch << AUXILIARYSURFACEQPITCH_BIT_SHIFT; 2359 } 2360 inline void setYOffsetForUOrUvPlane(const uint32_t value) { 2361 UNRECOVERABLE_IF(value > 0x3fff); 2362 TheStructure._SurfaceFormatIsPlanar.YOffsetForUOrUvPlane = value; 2363 } 2364 inline uint32_t getYOffsetForUOrUvPlane() const { 2365 return TheStructure._SurfaceFormatIsPlanar.YOffsetForUOrUvPlane; 2366 } 2367 inline void setXOffsetForUOrUvPlane(const uint32_t value) { 2368 UNRECOVERABLE_IF(value > 0x3fff0000); 2369 TheStructure._SurfaceFormatIsPlanar.XOffsetForUOrUvPlane = value; 2370 } 2371 inline uint32_t getXOffsetForUOrUvPlane() const { 2372 return TheStructure._SurfaceFormatIsPlanar.XOffsetForUOrUvPlane; 2373 } 2374 inline void setHalfPitchForChroma(const HALF_PITCH_FOR_CHROMA value) { 2375 TheStructure._SurfaceFormatIsPlanar.HalfPitchForChroma = value; 2376 } 2377 inline HALF_PITCH_FOR_CHROMA getHalfPitchForChroma() const { 2378 return static_cast<HALF_PITCH_FOR_CHROMA>(TheStructure._SurfaceFormatIsPlanar.HalfPitchForChroma); 2379 } 2380 inline void setSeparateUvPlaneEnable(const bool value) { 2381 TheStructure._SurfaceFormatIsPlanar.SeparateUvPlaneEnable = value; 2382 } 2383 inline bool getSeparateUvPlaneEnable() const { 2384 return TheStructure._SurfaceFormatIsPlanar.SeparateUvPlaneEnable; 2385 } 2386 inline void setYOffsetForVPlane(const uint64_t value) { 2387 UNRECOVERABLE_IF(value > 0x3fff00000000L); 2388 TheStructure._SurfaceFormatIsPlanar.YOffsetForVPlane = value; 2389 } 2390 inline uint64_t getYOffsetForVPlane() const { 2391 return TheStructure._SurfaceFormatIsPlanar.YOffsetForVPlane; 2392 } 2393 inline void setXOffsetForVPlane(const uint64_t value) { 2394 UNRECOVERABLE_IF(value > 0x3fff000000000000L); 2395 TheStructure._SurfaceFormatIsPlanar.XOffsetForVPlane = value; 2396 } 2397 inline uint64_t getXOffsetForVPlane() const { 2398 return TheStructure._SurfaceFormatIsPlanar.XOffsetForVPlane; 2399 } 2400 typedef enum tagAUXILIARYSURFACEBASEADDRESS { 2401 AUXILIARYSURFACEBASEADDRESS_BIT_SHIFT = 0xc, 2402 AUXILIARYSURFACEBASEADDRESS_ALIGN_SIZE = 0x1000, 2403 } AUXILIARYSURFACEBASEADDRESS; 2404 inline void setAuxiliarySurfaceBaseAddress(const uint64_t value) { 2405 UNRECOVERABLE_IF(value > 0xfffffffffffff000L); 2406 TheStructure._SurfaceFormatIsnotPlanarAndMemoryCompressionEnableIs0.AuxiliarySurfaceBaseAddress = value >> AUXILIARYSURFACEBASEADDRESS_BIT_SHIFT; 2407 } 2408 inline uint64_t getAuxiliarySurfaceBaseAddress() const { 2409 return TheStructure._SurfaceFormatIsnotPlanarAndMemoryCompressionEnableIs0.AuxiliarySurfaceBaseAddress << AUXILIARYSURFACEBASEADDRESS_BIT_SHIFT; 2410 } 2411} RENDER_SURFACE_STATE; 2412STATIC_ASSERT(64 == sizeof(RENDER_SURFACE_STATE)); 2413 2414typedef struct tagSAMPLER_STATE { 2415 union tagTheStructure { 2416 struct tagCommon { 2417 uint32_t LodAlgorithm : BITFIELD_RANGE(0, 0); 2418 uint32_t TextureLodBias : BITFIELD_RANGE(1, 13); 2419 uint32_t MinModeFilter : BITFIELD_RANGE(14, 16); 2420 uint32_t MagModeFilter : BITFIELD_RANGE(17, 19); 2421 uint32_t MipModeFilter : BITFIELD_RANGE(20, 21); 2422 uint32_t CoarseLodQualityMode : BITFIELD_RANGE(22, 26); 2423 uint32_t LodPreclampMode : BITFIELD_RANGE(27, 28); 2424 uint32_t TextureBorderColorMode : BITFIELD_RANGE(29, 29); 2425 uint32_t CpsLodCompensationEnable : BITFIELD_RANGE(30, 30); 2426 uint32_t SamplerDisable : BITFIELD_RANGE(31, 31); 2427 uint32_t CubeSurfaceControlMode : BITFIELD_RANGE(0, 0); 2428 uint32_t ShadowFunction : BITFIELD_RANGE(1, 3); 2429 uint32_t ChromakeyMode : BITFIELD_RANGE(4, 4); 2430 uint32_t ChromakeyIndex : BITFIELD_RANGE(5, 6); 2431 uint32_t ChromakeyEnable : BITFIELD_RANGE(7, 7); 2432 uint32_t MaxLod : BITFIELD_RANGE(8, 19); 2433 uint32_t MinLod : BITFIELD_RANGE(20, 31); 2434 uint32_t LodClampMagnificationMode : BITFIELD_RANGE(0, 0); 2435 uint32_t SrgbDecode : BITFIELD_RANGE(1, 1); 2436 uint32_t ReturnFilterWeightForNullTexels : BITFIELD_RANGE(2, 2); 2437 uint32_t ReturnFilterWeightForBorderTexels : BITFIELD_RANGE(3, 3); 2438 uint32_t Reserved_68 : BITFIELD_RANGE(4, 5); 2439 uint32_t IndirectStatePointer : BITFIELD_RANGE(6, 23); 2440 uint32_t Reserved_88 : BITFIELD_RANGE(24, 31); 2441 uint32_t TczAddressControlMode : BITFIELD_RANGE(0, 2); 2442 uint32_t TcyAddressControlMode : BITFIELD_RANGE(3, 5); 2443 uint32_t TcxAddressControlMode : BITFIELD_RANGE(6, 8); 2444 uint32_t ReductionTypeEnable : BITFIELD_RANGE(9, 9); 2445 uint32_t NonNormalizedCoordinateEnable : BITFIELD_RANGE(10, 10); 2446 uint32_t TrilinearFilterQuality : BITFIELD_RANGE(11, 12); 2447 uint32_t RAddressMinFilterRoundingEnable : BITFIELD_RANGE(13, 13); 2448 uint32_t RAddressMagFilterRoundingEnable : BITFIELD_RANGE(14, 14); 2449 uint32_t VAddressMinFilterRoundingEnable : BITFIELD_RANGE(15, 15); 2450 uint32_t VAddressMagFilterRoundingEnable : BITFIELD_RANGE(16, 16); 2451 uint32_t UAddressMinFilterRoundingEnable : BITFIELD_RANGE(17, 17); 2452 uint32_t UAddressMagFilterRoundingEnable : BITFIELD_RANGE(18, 18); 2453 uint32_t MaximumAnisotropy : BITFIELD_RANGE(19, 21); 2454 uint32_t ReductionType : BITFIELD_RANGE(22, 23); 2455 uint32_t AllowLowQualityLodCalculation : BITFIELD_RANGE(24, 24); 2456 uint32_t Reserved_121 : BITFIELD_RANGE(25, 25); 2457 uint32_t LowQualityFilter : BITFIELD_RANGE(26, 26); 2458 uint32_t Reserved_123 : BITFIELD_RANGE(27, 31); 2459 } Common; 2460 uint32_t RawData[4]; 2461 } TheStructure; 2462 typedef enum tagLOD_ALGORITHM { 2463 LOD_ALGORITHM_LEGACY = 0x0, 2464 LOD_ALGORITHM_EWA_APPROXIMATION = 0x1, 2465 } LOD_ALGORITHM; 2466 typedef enum tagMIN_MODE_FILTER { 2467 MIN_MODE_FILTER_NEAREST = 0x0, 2468 MIN_MODE_FILTER_LINEAR = 0x1, 2469 MIN_MODE_FILTER_ANISOTROPIC = 0x2, 2470 MIN_MODE_FILTER_MONO = 0x6, 2471 } MIN_MODE_FILTER; 2472 typedef enum tagMAG_MODE_FILTER { 2473 MAG_MODE_FILTER_NEAREST = 0x0, 2474 MAG_MODE_FILTER_LINEAR = 0x1, 2475 MAG_MODE_FILTER_ANISOTROPIC = 0x2, 2476 MAG_MODE_FILTER_MONO = 0x6, 2477 } MAG_MODE_FILTER; 2478 typedef enum tagMIP_MODE_FILTER { 2479 MIP_MODE_FILTER_NONE = 0x0, 2480 MIP_MODE_FILTER_NEAREST = 0x1, 2481 MIP_MODE_FILTER_LINEAR = 0x3, 2482 } MIP_MODE_FILTER; 2483 typedef enum tagCOARSE_LOD_QUALITY_MODE { 2484 COARSE_LOD_QUALITY_MODE_DISABLED = 0x0, 2485 } COARSE_LOD_QUALITY_MODE; 2486 typedef enum tagLOD_PRECLAMP_MODE { 2487 LOD_PRECLAMP_MODE_NONE = 0x0, 2488 LOD_PRECLAMP_MODE_OGL = 0x2, 2489 } LOD_PRECLAMP_MODE; 2490 typedef enum tagTEXTURE_BORDER_COLOR_MODE { 2491 TEXTURE_BORDER_COLOR_MODE_OGL = 0x0, 2492 TEXTURE_BORDER_COLOR_MODE_8BIT = 0x1, 2493 } TEXTURE_BORDER_COLOR_MODE; 2494 typedef enum tagCUBE_SURFACE_CONTROL_MODE { 2495 CUBE_SURFACE_CONTROL_MODE_PROGRAMMED = 0x0, 2496 CUBE_SURFACE_CONTROL_MODE_OVERRIDE = 0x1, 2497 } CUBE_SURFACE_CONTROL_MODE; 2498 typedef enum tagSHADOW_FUNCTION { 2499 SHADOW_FUNCTION_PREFILTEROP_ALWAYS = 0x0, 2500 SHADOW_FUNCTION_PREFILTEROP_NEVER = 0x1, 2501 SHADOW_FUNCTION_PREFILTEROP_LESS = 0x2, 2502 SHADOW_FUNCTION_PREFILTEROP_EQUAL = 0x3, 2503 SHADOW_FUNCTION_PREFILTEROP_LEQUAL = 0x4, 2504 SHADOW_FUNCTION_PREFILTEROP_GREATER = 0x5, 2505 SHADOW_FUNCTION_PREFILTEROP_NOTEQUAL = 0x6, 2506 SHADOW_FUNCTION_PREFILTEROP_GEQUAL = 0x7, 2507 } SHADOW_FUNCTION; 2508 typedef enum tagCHROMAKEY_MODE { 2509 CHROMAKEY_MODE_KEYFILTER_KILL_ON_ANY_MATCH = 0x0, 2510 CHROMAKEY_MODE_KEYFILTER_REPLACE_BLACK = 0x1, 2511 } CHROMAKEY_MODE; 2512 typedef enum tagLOD_CLAMP_MAGNIFICATION_MODE { 2513 LOD_CLAMP_MAGNIFICATION_MODE_MIPNONE = 0x0, 2514 LOD_CLAMP_MAGNIFICATION_MODE_MIPFILTER = 0x1, 2515 } LOD_CLAMP_MAGNIFICATION_MODE; 2516 typedef enum tagSRGB_DECODE { 2517 SRGB_DECODE_DECODE_EXT = 0x0, 2518 SRGB_DECODE_SKIP_DECODE_EXT = 0x1, 2519 } SRGB_DECODE; 2520 typedef enum tagRETURN_FILTER_WEIGHT_FOR_NULL_TEXELS { 2521 RETURN_FILTER_WEIGHT_FOR_NULL_TEXELS_DISABLE = 0x0, 2522 RETURN_FILTER_WEIGHT_FOR_NULL_TEXELS_ENABLE = 0x1, 2523 } RETURN_FILTER_WEIGHT_FOR_NULL_TEXELS; 2524 typedef enum tagRETURN_FILTER_WEIGHT_FOR_BORDER_TEXELS { 2525 RETURN_FILTER_WEIGHT_FOR_BORDER_TEXELS_DISABLE = 0x0, 2526 RETURN_FILTER_WEIGHT_FOR_BORDER_TEXELS_ENABLE = 0x1, 2527 } RETURN_FILTER_WEIGHT_FOR_BORDER_TEXELS; 2528 typedef enum tagTEXTURE_COORDINATE_MODE { 2529 TEXTURE_COORDINATE_MODE_WRAP = 0x0, 2530 TEXTURE_COORDINATE_MODE_MIRROR = 0x1, 2531 TEXTURE_COORDINATE_MODE_CLAMP = 0x2, 2532 TEXTURE_COORDINATE_MODE_CUBE = 0x3, 2533 TEXTURE_COORDINATE_MODE_CLAMP_BORDER = 0x4, 2534 TEXTURE_COORDINATE_MODE_MIRROR_ONCE = 0x5, 2535 TEXTURE_COORDINATE_MODE_HALF_BORDER = 0x6, 2536 TEXTURE_COORDINATE_MODE_MIRROR_101 = 0x7, 2537 } TEXTURE_COORDINATE_MODE; 2538 typedef enum tagTRILINEAR_FILTER_QUALITY { 2539 TRILINEAR_FILTER_QUALITY_FULL = 0x0, 2540 TRILINEAR_FILTER_QUALITY_TRIQUAL_HIGHMAG_CLAMP_MIPFILTER = 0x1, 2541 TRILINEAR_FILTER_QUALITY_MED = 0x2, 2542 TRILINEAR_FILTER_QUALITY_LOW = 0x3, 2543 } TRILINEAR_FILTER_QUALITY; 2544 typedef enum tagMAXIMUM_ANISOTROPY { 2545 MAXIMUM_ANISOTROPY_RATIO_21 = 0x0, 2546 MAXIMUM_ANISOTROPY_RATIO_41 = 0x1, 2547 MAXIMUM_ANISOTROPY_RATIO_61 = 0x2, 2548 MAXIMUM_ANISOTROPY_RATIO_81 = 0x3, 2549 MAXIMUM_ANISOTROPY_RATIO_101 = 0x4, 2550 MAXIMUM_ANISOTROPY_RATIO_121 = 0x5, 2551 MAXIMUM_ANISOTROPY_RATIO_141 = 0x6, 2552 MAXIMUM_ANISOTROPY_RATIO_161 = 0x7, 2553 } MAXIMUM_ANISOTROPY; 2554 typedef enum tagREDUCTION_TYPE { 2555 REDUCTION_TYPE_STD_FILTER = 0x0, 2556 REDUCTION_TYPE_COMPARISON = 0x1, 2557 REDUCTION_TYPE_MINIMUM = 0x2, 2558 REDUCTION_TYPE_MAXIMUM = 0x3, 2559 } REDUCTION_TYPE; 2560 typedef enum tagLOW_QUALITY_FILTER { 2561 LOW_QUALITY_FILTER_DISABLE = 0x0, 2562 LOW_QUALITY_FILTER_ENABLE = 0x1, 2563 } LOW_QUALITY_FILTER; 2564 inline void init() { 2565 memset(&TheStructure, 0, sizeof(TheStructure)); 2566 TheStructure.Common.LodAlgorithm = LOD_ALGORITHM_LEGACY; 2567 TheStructure.Common.MinModeFilter = MIN_MODE_FILTER_NEAREST; 2568 TheStructure.Common.MagModeFilter = MAG_MODE_FILTER_NEAREST; 2569 TheStructure.Common.MipModeFilter = MIP_MODE_FILTER_NONE; 2570 TheStructure.Common.CoarseLodQualityMode = COARSE_LOD_QUALITY_MODE_DISABLED; 2571 TheStructure.Common.LodPreclampMode = LOD_PRECLAMP_MODE_NONE; 2572 TheStructure.Common.TextureBorderColorMode = TEXTURE_BORDER_COLOR_MODE_OGL; 2573 TheStructure.Common.CubeSurfaceControlMode = CUBE_SURFACE_CONTROL_MODE_PROGRAMMED; 2574 TheStructure.Common.ShadowFunction = SHADOW_FUNCTION_PREFILTEROP_ALWAYS; 2575 TheStructure.Common.ChromakeyMode = CHROMAKEY_MODE_KEYFILTER_KILL_ON_ANY_MATCH; 2576 TheStructure.Common.LodClampMagnificationMode = LOD_CLAMP_MAGNIFICATION_MODE_MIPNONE; 2577 TheStructure.Common.SrgbDecode = SRGB_DECODE_DECODE_EXT; 2578 TheStructure.Common.ReturnFilterWeightForNullTexels = RETURN_FILTER_WEIGHT_FOR_NULL_TEXELS_DISABLE; 2579 TheStructure.Common.ReturnFilterWeightForBorderTexels = RETURN_FILTER_WEIGHT_FOR_BORDER_TEXELS_DISABLE; 2580 TheStructure.Common.TczAddressControlMode = TEXTURE_COORDINATE_MODE_WRAP; 2581 TheStructure.Common.TcyAddressControlMode = TEXTURE_COORDINATE_MODE_WRAP; 2582 TheStructure.Common.TcxAddressControlMode = TEXTURE_COORDINATE_MODE_WRAP; 2583 TheStructure.Common.TrilinearFilterQuality = TRILINEAR_FILTER_QUALITY_FULL; 2584 TheStructure.Common.MaximumAnisotropy = MAXIMUM_ANISOTROPY_RATIO_21; 2585 TheStructure.Common.ReductionType = REDUCTION_TYPE_STD_FILTER; 2586 TheStructure.Common.LowQualityFilter = LOW_QUALITY_FILTER_DISABLE; 2587 } 2588 static tagSAMPLER_STATE sInit() { 2589 SAMPLER_STATE state; 2590 state.init(); 2591 return state; 2592 } 2593 inline uint32_t &getRawData(const uint32_t index) { 2594 DEBUG_BREAK_IF(index >= 4); 2595 return TheStructure.RawData[index]; 2596 } 2597 inline void setLodAlgorithm(const LOD_ALGORITHM value) { 2598 TheStructure.Common.LodAlgorithm = value; 2599 } 2600 inline LOD_ALGORITHM getLodAlgorithm() const { 2601 return static_cast<LOD_ALGORITHM>(TheStructure.Common.LodAlgorithm); 2602 } 2603 inline void setTextureLodBias(const uint32_t value) { 2604 DEBUG_BREAK_IF(value > 0x3ffe); 2605 TheStructure.Common.TextureLodBias = value; 2606 } 2607 inline uint32_t getTextureLodBias() const { 2608 return TheStructure.Common.TextureLodBias; 2609 } 2610 inline void setMinModeFilter(const MIN_MODE_FILTER value) { 2611 TheStructure.Common.MinModeFilter = value; 2612 } 2613 inline MIN_MODE_FILTER getMinModeFilter() const { 2614 return static_cast<MIN_MODE_FILTER>(TheStructure.Common.MinModeFilter); 2615 } 2616 inline void setMagModeFilter(const MAG_MODE_FILTER value) { 2617 TheStructure.Common.MagModeFilter = value; 2618 } 2619 inline MAG_MODE_FILTER getMagModeFilter() const { 2620 return static_cast<MAG_MODE_FILTER>(TheStructure.Common.MagModeFilter); 2621 } 2622 inline void setMipModeFilter(const MIP_MODE_FILTER value) { 2623 TheStructure.Common.MipModeFilter = value; 2624 } 2625 inline MIP_MODE_FILTER getMipModeFilter() const { 2626 return static_cast<MIP_MODE_FILTER>(TheStructure.Common.MipModeFilter); 2627 } 2628 inline void setCoarseLodQualityMode(const COARSE_LOD_QUALITY_MODE value) { 2629 TheStructure.Common.CoarseLodQualityMode = value; 2630 } 2631 inline COARSE_LOD_QUALITY_MODE getCoarseLodQualityMode() const { 2632 return static_cast<COARSE_LOD_QUALITY_MODE>(TheStructure.Common.CoarseLodQualityMode); 2633 } 2634 inline void setLodPreclampMode(const LOD_PRECLAMP_MODE value) { 2635 TheStructure.Common.LodPreclampMode = value; 2636 } 2637 inline LOD_PRECLAMP_MODE getLodPreclampMode() const { 2638 return static_cast<LOD_PRECLAMP_MODE>(TheStructure.Common.LodPreclampMode); 2639 } 2640 inline void setTextureBorderColorMode(const TEXTURE_BORDER_COLOR_MODE value) { 2641 TheStructure.Common.TextureBorderColorMode = value; 2642 } 2643 inline TEXTURE_BORDER_COLOR_MODE getTextureBorderColorMode() const { 2644 return static_cast<TEXTURE_BORDER_COLOR_MODE>(TheStructure.Common.TextureBorderColorMode); 2645 } 2646 inline void setCpsLodCompensationEnable(const bool value) { 2647 TheStructure.Common.CpsLodCompensationEnable = value; 2648 } 2649 inline bool getCpsLodCompensationEnable() const { 2650 return TheStructure.Common.CpsLodCompensationEnable; 2651 } 2652 inline void setSamplerDisable(const bool value) { 2653 TheStructure.Common.SamplerDisable = value; 2654 } 2655 inline bool getSamplerDisable() const { 2656 return TheStructure.Common.SamplerDisable; 2657 } 2658 inline void setCubeSurfaceControlMode(const CUBE_SURFACE_CONTROL_MODE value) { 2659 TheStructure.Common.CubeSurfaceControlMode = value; 2660 } 2661 inline CUBE_SURFACE_CONTROL_MODE getCubeSurfaceControlMode() const { 2662 return static_cast<CUBE_SURFACE_CONTROL_MODE>(TheStructure.Common.CubeSurfaceControlMode); 2663 } 2664 inline void setShadowFunction(const SHADOW_FUNCTION value) { 2665 TheStructure.Common.ShadowFunction = value; 2666 } 2667 inline SHADOW_FUNCTION getShadowFunction() const { 2668 return static_cast<SHADOW_FUNCTION>(TheStructure.Common.ShadowFunction); 2669 } 2670 inline void setChromakeyMode(const CHROMAKEY_MODE value) { 2671 TheStructure.Common.ChromakeyMode = value; 2672 } 2673 inline CHROMAKEY_MODE getChromakeyMode() const { 2674 return static_cast<CHROMAKEY_MODE>(TheStructure.Common.ChromakeyMode); 2675 } 2676 inline void setChromakeyIndex(const uint32_t value) { 2677 DEBUG_BREAK_IF(value > 0x60); 2678 TheStructure.Common.ChromakeyIndex = value; 2679 } 2680 inline uint32_t getChromakeyIndex() const { 2681 return TheStructure.Common.ChromakeyIndex; 2682 } 2683 inline void setChromakeyEnable(const bool value) { 2684 TheStructure.Common.ChromakeyEnable = value; 2685 } 2686 inline bool getChromakeyEnable() const { 2687 return TheStructure.Common.ChromakeyEnable; 2688 } 2689 inline void setMaxLod(const uint32_t value) { 2690 DEBUG_BREAK_IF(value > 0xfff00); 2691 TheStructure.Common.MaxLod = value; 2692 } 2693 inline uint32_t getMaxLod() const { 2694 return TheStructure.Common.MaxLod; 2695 } 2696 inline void setMinLod(const uint32_t value) { 2697 DEBUG_BREAK_IF(value > 0xfff00000L); 2698 TheStructure.Common.MinLod = value; 2699 } 2700 inline uint32_t getMinLod() const { 2701 return TheStructure.Common.MinLod; 2702 } 2703 inline void setLodClampMagnificationMode(const LOD_CLAMP_MAGNIFICATION_MODE value) { 2704 TheStructure.Common.LodClampMagnificationMode = value; 2705 } 2706 inline LOD_CLAMP_MAGNIFICATION_MODE getLodClampMagnificationMode() const { 2707 return static_cast<LOD_CLAMP_MAGNIFICATION_MODE>(TheStructure.Common.LodClampMagnificationMode); 2708 } 2709 inline void setSrgbDecode(const SRGB_DECODE value) { 2710 TheStructure.Common.SrgbDecode = value; 2711 } 2712 inline SRGB_DECODE getSrgbDecode() const { 2713 return static_cast<SRGB_DECODE>(TheStructure.Common.SrgbDecode); 2714 } 2715 inline void setReturnFilterWeightForNullTexels(const RETURN_FILTER_WEIGHT_FOR_NULL_TEXELS value) { 2716 TheStructure.Common.ReturnFilterWeightForNullTexels = value; 2717 } 2718 inline RETURN_FILTER_WEIGHT_FOR_NULL_TEXELS getReturnFilterWeightForNullTexels() const { 2719 return static_cast<RETURN_FILTER_WEIGHT_FOR_NULL_TEXELS>(TheStructure.Common.ReturnFilterWeightForNullTexels); 2720 } 2721 inline void setReturnFilterWeightForBorderTexels(const RETURN_FILTER_WEIGHT_FOR_BORDER_TEXELS value) { 2722 TheStructure.Common.ReturnFilterWeightForBorderTexels = value; 2723 } 2724 inline RETURN_FILTER_WEIGHT_FOR_BORDER_TEXELS getReturnFilterWeightForBorderTexels() const { 2725 return static_cast<RETURN_FILTER_WEIGHT_FOR_BORDER_TEXELS>(TheStructure.Common.ReturnFilterWeightForBorderTexels); 2726 } 2727 typedef enum tagINDIRECTSTATEPOINTER { 2728 INDIRECTSTATEPOINTER_BIT_SHIFT = 0x6, 2729 INDIRECTSTATEPOINTER_ALIGN_SIZE = 0x40, 2730 } INDIRECTSTATEPOINTER; 2731 inline void setIndirectStatePointer(const uint32_t value) { 2732 DEBUG_BREAK_IF(value > 0xffffc0); 2733 TheStructure.Common.IndirectStatePointer = static_cast<uint32_t>(value) >> INDIRECTSTATEPOINTER_BIT_SHIFT; 2734 } 2735 inline uint32_t getIndirectStatePointer() const { 2736 return TheStructure.Common.IndirectStatePointer << INDIRECTSTATEPOINTER_BIT_SHIFT; 2737 } 2738 inline void setTczAddressControlMode(const TEXTURE_COORDINATE_MODE value) { 2739 TheStructure.Common.TczAddressControlMode = value; 2740 } 2741 inline TEXTURE_COORDINATE_MODE getTczAddressControlMode() const { 2742 return static_cast<TEXTURE_COORDINATE_MODE>(TheStructure.Common.TczAddressControlMode); 2743 } 2744 inline void setTcyAddressControlMode(const TEXTURE_COORDINATE_MODE value) { 2745 TheStructure.Common.TcyAddressControlMode = value; 2746 } 2747 inline TEXTURE_COORDINATE_MODE getTcyAddressControlMode() const { 2748 return static_cast<TEXTURE_COORDINATE_MODE>(TheStructure.Common.TcyAddressControlMode); 2749 } 2750 inline void setTcxAddressControlMode(const TEXTURE_COORDINATE_MODE value) { 2751 TheStructure.Common.TcxAddressControlMode = value; 2752 } 2753 inline TEXTURE_COORDINATE_MODE getTcxAddressControlMode() const { 2754 return static_cast<TEXTURE_COORDINATE_MODE>(TheStructure.Common.TcxAddressControlMode); 2755 } 2756 inline void setReductionTypeEnable(const bool value) { 2757 TheStructure.Common.ReductionTypeEnable = value; 2758 } 2759 inline bool getReductionTypeEnable() const { 2760 return TheStructure.Common.ReductionTypeEnable; 2761 } 2762 inline void setNonNormalizedCoordinateEnable(const bool value) { 2763 TheStructure.Common.NonNormalizedCoordinateEnable = value; 2764 } 2765 inline bool getNonNormalizedCoordinateEnable() const { 2766 return TheStructure.Common.NonNormalizedCoordinateEnable; 2767 } 2768 inline void setTrilinearFilterQuality(const TRILINEAR_FILTER_QUALITY value) { 2769 TheStructure.Common.TrilinearFilterQuality = value; 2770 } 2771 inline TRILINEAR_FILTER_QUALITY getTrilinearFilterQuality() const { 2772 return static_cast<TRILINEAR_FILTER_QUALITY>(TheStructure.Common.TrilinearFilterQuality); 2773 } 2774 inline void setRAddressMinFilterRoundingEnable(const bool value) { 2775 TheStructure.Common.RAddressMinFilterRoundingEnable = value; 2776 } 2777 inline bool getRAddressMinFilterRoundingEnable() const { 2778 return TheStructure.Common.RAddressMinFilterRoundingEnable; 2779 } 2780 inline void setRAddressMagFilterRoundingEnable(const bool value) { 2781 TheStructure.Common.RAddressMagFilterRoundingEnable = value; 2782 } 2783 inline bool getRAddressMagFilterRoundingEnable() const { 2784 return TheStructure.Common.RAddressMagFilterRoundingEnable; 2785 } 2786 inline void setVAddressMinFilterRoundingEnable(const bool value) { 2787 TheStructure.Common.VAddressMinFilterRoundingEnable = value; 2788 } 2789 inline bool getVAddressMinFilterRoundingEnable() const { 2790 return TheStructure.Common.VAddressMinFilterRoundingEnable; 2791 } 2792 inline void setVAddressMagFilterRoundingEnable(const bool value) { 2793 TheStructure.Common.VAddressMagFilterRoundingEnable = value; 2794 } 2795 inline bool getVAddressMagFilterRoundingEnable() const { 2796 return TheStructure.Common.VAddressMagFilterRoundingEnable; 2797 } 2798 inline void setUAddressMinFilterRoundingEnable(const bool value) { 2799 TheStructure.Common.UAddressMinFilterRoundingEnable = value; 2800 } 2801 inline bool getUAddressMinFilterRoundingEnable() const { 2802 return TheStructure.Common.UAddressMinFilterRoundingEnable; 2803 } 2804 inline void setUAddressMagFilterRoundingEnable(const bool value) { 2805 TheStructure.Common.UAddressMagFilterRoundingEnable = value; 2806 } 2807 inline bool getUAddressMagFilterRoundingEnable() const { 2808 return TheStructure.Common.UAddressMagFilterRoundingEnable; 2809 } 2810 inline void setMaximumAnisotropy(const MAXIMUM_ANISOTROPY value) { 2811 TheStructure.Common.MaximumAnisotropy = value; 2812 } 2813 inline MAXIMUM_ANISOTROPY getMaximumAnisotropy() const { 2814 return static_cast<MAXIMUM_ANISOTROPY>(TheStructure.Common.MaximumAnisotropy); 2815 } 2816 inline void setReductionType(const REDUCTION_TYPE value) { 2817 TheStructure.Common.ReductionType = value; 2818 } 2819 inline REDUCTION_TYPE getReductionType() const { 2820 return static_cast<REDUCTION_TYPE>(TheStructure.Common.ReductionType); 2821 } 2822 inline void setLowQualityFilter(const LOW_QUALITY_FILTER value) { 2823 TheStructure.Common.LowQualityFilter = value; 2824 } 2825 inline LOW_QUALITY_FILTER getLowQualityFilter() const { 2826 return static_cast<LOW_QUALITY_FILTER>(TheStructure.Common.LowQualityFilter); 2827 } 2828 inline void setAllowLowQualityLodCalculation(const bool value) { 2829 TheStructure.Common.AllowLowQualityLodCalculation = value; 2830 } 2831 inline bool getAllowLowQualityLodCalculation() const { 2832 return TheStructure.Common.AllowLowQualityLodCalculation; 2833 } 2834} SAMPLER_STATE; 2835STATIC_ASSERT(16 == sizeof(SAMPLER_STATE)); 2836 2837typedef struct tagSTATE_BASE_ADDRESS { 2838 union tagTheStructure { 2839 struct tagCommon { 2840 // DWORD 0 2841 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 2842 uint32_t Reserved_8 : BITFIELD_RANGE(8, 15); 2843 uint32_t _3DCommandSubOpcode : BITFIELD_RANGE(16, 23); 2844 uint32_t _3DCommandOpcode : BITFIELD_RANGE(24, 26); 2845 uint32_t CommandSubtype : BITFIELD_RANGE(27, 28); 2846 uint32_t CommandType : BITFIELD_RANGE(29, 31); 2847 // DWORD 1-2 2848 uint64_t GeneralStateBaseAddressModifyEnable : BITFIELD_RANGE(0, 0); 2849 uint64_t Reserved_33 : BITFIELD_RANGE(1, 3); 2850 uint64_t GeneralStateMemoryObjectControlState_Reserved : BITFIELD_RANGE(4, 4); 2851 uint64_t GeneralStateMemoryObjectControlState_IndexToMocsTables : BITFIELD_RANGE(5, 10); 2852 uint64_t Reserved_43 : BITFIELD_RANGE(11, 11); 2853 uint64_t GeneralStateBaseAddress : BITFIELD_RANGE(12, 63); 2854 // DWORD 3 2855 uint32_t Reserved_96 : BITFIELD_RANGE(0, 12); 2856 uint32_t EnableMemoryCompressionForAllStatelessAccesses : BITFIELD_RANGE(13, 13); 2857 uint32_t DisableSupportForMultiGpuAtomicsForStatelessAccesses : BITFIELD_RANGE(14, 14); 2858 uint32_t DisableSupportForMultiGpuPartialWritesForStatelessMessages : BITFIELD_RANGE(15, 15); 2859 uint32_t StatelessDataPortAccessMemoryObjectControlState_Reserved : BITFIELD_RANGE(16, 16); 2860 uint32_t StatelessDataPortAccessMemoryObjectControlState_IndexToMocsTables : BITFIELD_RANGE(17, 22); 2861 uint32_t Reserved_119 : BITFIELD_RANGE(23, 31); 2862 // DWORD 4-5 2863 uint64_t SurfaceStateBaseAddressModifyEnable : BITFIELD_RANGE(0, 0); 2864 uint64_t Reserved_129 : BITFIELD_RANGE(1, 3); 2865 uint64_t SurfaceStateMemoryObjectControlState_Reserved : BITFIELD_RANGE(4, 4); 2866 uint64_t SurfaceStateMemoryObjectControlState_IndexToMocsTables : BITFIELD_RANGE(5, 10); 2867 uint64_t Reserved_139 : BITFIELD_RANGE(11, 11); 2868 uint64_t SurfaceStateBaseAddress : BITFIELD_RANGE(12, 63); 2869 // DWORD 6-7 2870 uint64_t DynamicStateBaseAddressModifyEnable : BITFIELD_RANGE(0, 0); 2871 uint64_t Reserved_193 : BITFIELD_RANGE(1, 3); 2872 uint64_t DynamicStateMemoryObjectControlState_Reserved : BITFIELD_RANGE(4, 4); 2873 uint64_t DynamicStateMemoryObjectControlState_IndexToMocsTables : BITFIELD_RANGE(5, 10); 2874 uint64_t Reserved_203 : BITFIELD_RANGE(11, 11); 2875 uint64_t DynamicStateBaseAddress : BITFIELD_RANGE(12, 63); 2876 // DWORD 8-9 2877 uint64_t Reserved8 : BITFIELD_RANGE(0, 63); 2878 // DWORD 10-11 2879 uint64_t InstructionBaseAddressModifyEnable : BITFIELD_RANGE(0, 0); 2880 uint64_t Reserved_321 : BITFIELD_RANGE(1, 3); 2881 uint64_t InstructionMemoryObjectControlState_Reserved : BITFIELD_RANGE(4, 4); 2882 uint64_t InstructionMemoryObjectControlState_IndexToMocsTables : BITFIELD_RANGE(5, 10); 2883 uint64_t Reserved_331 : BITFIELD_RANGE(11, 11); 2884 uint64_t InstructionBaseAddress : BITFIELD_RANGE(12, 63); 2885 // DWORD 12 2886 uint32_t GeneralStateBufferSizeModifyEnable : BITFIELD_RANGE(0, 0); 2887 uint32_t Reserved_385 : BITFIELD_RANGE(1, 11); 2888 uint32_t GeneralStateBufferSize : BITFIELD_RANGE(12, 31); 2889 // DWORD 13 2890 uint32_t DynamicStateBufferSizeModifyEnable : BITFIELD_RANGE(0, 0); 2891 uint32_t Reserved_417 : BITFIELD_RANGE(1, 11); 2892 uint32_t DynamicStateBufferSize : BITFIELD_RANGE(12, 31); 2893 // DWORD 14 2894 uint32_t IndirectObjectBufferSizeModifyEnable : BITFIELD_RANGE(0, 0); 2895 uint32_t Reserved_449 : BITFIELD_RANGE(1, 11); 2896 uint32_t IndirectObjectBufferSize : BITFIELD_RANGE(12, 31); 2897 // DWORD 15 2898 uint32_t InstructionBufferSizeModifyEnable : BITFIELD_RANGE(0, 0); 2899 uint32_t Reserved_481 : BITFIELD_RANGE(1, 11); 2900 uint32_t InstructionBufferSize : BITFIELD_RANGE(12, 31); 2901 // DWORD 16-17 2902 uint64_t BindlessSurfaceStateBaseAddressModifyEnable : BITFIELD_RANGE(0, 0); 2903 uint64_t Reserved_513 : BITFIELD_RANGE(1, 3); 2904 uint64_t BindlessSurfaceStateMemoryObjectControlState_Reserved : BITFIELD_RANGE(4, 4); 2905 uint64_t BindlessSurfaceStateMemoryObjectControlState_IndexToMocsTables : BITFIELD_RANGE(5, 10); 2906 uint64_t Reserved_523 : BITFIELD_RANGE(11, 11); 2907 uint64_t BindlessSurfaceStateBaseAddress : BITFIELD_RANGE(12, 63); 2908 // DWORD 18 2909 uint32_t BindlessSurfaceStateSize; 2910 // DWORD 19-20 2911 uint64_t BindlessSamplerStateBaseAddressModifyEnable : BITFIELD_RANGE(0, 0); 2912 uint64_t Reserved_609 : BITFIELD_RANGE(1, 3); 2913 uint64_t BindlessSamplerStateMemoryObjectControlState_Reserved : BITFIELD_RANGE(4, 4); 2914 uint64_t BindlessSamplerStateMemoryObjectControlState_IndexToMocsTables : BITFIELD_RANGE(5, 10); 2915 uint64_t Reserved_619 : BITFIELD_RANGE(11, 11); 2916 uint64_t BindlessSamplerStateBaseAddress : BITFIELD_RANGE(12, 63); 2917 // DWORD 21 2918 uint32_t Reserved_672 : BITFIELD_RANGE(0, 11); 2919 uint32_t BindlessSamplerStateBufferSize : BITFIELD_RANGE(12, 31); 2920 } Common; 2921 uint32_t RawData[22]; 2922 } TheStructure; 2923 typedef enum tagDWORD_LENGTH { 2924 DWORD_LENGTH_DWORD_COUNT_N = 0x14, 2925 } DWORD_LENGTH; 2926 typedef enum tag_3D_COMMAND_SUB_OPCODE { 2927 _3D_COMMAND_SUB_OPCODE_STATE_BASE_ADDRESS = 0x1, 2928 } _3D_COMMAND_SUB_OPCODE; 2929 typedef enum tag_3D_COMMAND_OPCODE { 2930 _3D_COMMAND_OPCODE_GFXPIPE_NONPIPELINED = 0x1, 2931 } _3D_COMMAND_OPCODE; 2932 typedef enum tagCOMMAND_SUBTYPE { 2933 COMMAND_SUBTYPE_GFXPIPE_COMMON = 0x0, 2934 } COMMAND_SUBTYPE; 2935 typedef enum tagCOMMAND_TYPE { 2936 COMMAND_TYPE_GFXPIPE = 0x3, 2937 } COMMAND_TYPE; 2938 typedef enum tagENABLE_MEMORY_COMPRESSION_FOR_ALL_STATELESS_ACCESSES { 2939 ENABLE_MEMORY_COMPRESSION_FOR_ALL_STATELESS_ACCESSES_DISABLED = 0x0, 2940 ENABLE_MEMORY_COMPRESSION_FOR_ALL_STATELESS_ACCESSES_ENABLED = 0x1, 2941 } ENABLE_MEMORY_COMPRESSION_FOR_ALL_STATELESS_ACCESSES; 2942 typedef enum tagPATCH_CONSTANTS { 2943 GENERALSTATEBASEADDRESS_BYTEOFFSET = 0x4, 2944 GENERALSTATEBASEADDRESS_INDEX = 0x1, 2945 SURFACESTATEBASEADDRESS_BYTEOFFSET = 0x10, 2946 SURFACESTATEBASEADDRESS_INDEX = 0x4, 2947 DYNAMICSTATEBASEADDRESS_BYTEOFFSET = 0x18, 2948 DYNAMICSTATEBASEADDRESS_INDEX = 0x6, 2949 INSTRUCTIONBASEADDRESS_BYTEOFFSET = 0x28, 2950 INSTRUCTIONBASEADDRESS_INDEX = 0xa, 2951 BINDLESSSURFACESTATEBASEADDRESS_BYTEOFFSET = 0x40, 2952 BINDLESSSURFACESTATEBASEADDRESS_INDEX = 0x10, 2953 BINDLESSSAMPLERSTATEBASEADDRESS_BYTEOFFSET = 0x4c, 2954 BINDLESSSAMPLERSTATEBASEADDRESS_INDEX = 0x13, 2955 } PATCH_CONSTANTS; 2956 inline void init() { 2957 memset(&TheStructure, 0, sizeof(TheStructure)); 2958 TheStructure.Common.DwordLength = DWORD_LENGTH_DWORD_COUNT_N; 2959 TheStructure.Common._3DCommandSubOpcode = _3D_COMMAND_SUB_OPCODE_STATE_BASE_ADDRESS; 2960 TheStructure.Common._3DCommandOpcode = _3D_COMMAND_OPCODE_GFXPIPE_NONPIPELINED; 2961 TheStructure.Common.CommandSubtype = COMMAND_SUBTYPE_GFXPIPE_COMMON; 2962 TheStructure.Common.CommandType = COMMAND_TYPE_GFXPIPE; 2963 TheStructure.Common.EnableMemoryCompressionForAllStatelessAccesses = ENABLE_MEMORY_COMPRESSION_FOR_ALL_STATELESS_ACCESSES_DISABLED; 2964 TheStructure.Common.DisableSupportForMultiGpuAtomicsForStatelessAccesses = 1; 2965 TheStructure.Common.DisableSupportForMultiGpuPartialWritesForStatelessMessages = 1; 2966 } 2967 static tagSTATE_BASE_ADDRESS sInit() { 2968 STATE_BASE_ADDRESS state; 2969 state.init(); 2970 return state; 2971 } 2972 inline uint32_t &getRawData(const uint32_t index) { 2973 DEBUG_BREAK_IF(index >= 22); 2974 return TheStructure.RawData[index]; 2975 } 2976 inline void setGeneralStateBaseAddressModifyEnable(const bool value) { 2977 TheStructure.Common.GeneralStateBaseAddressModifyEnable = value; 2978 } 2979 inline bool getGeneralStateBaseAddressModifyEnable() const { 2980 return (TheStructure.Common.GeneralStateBaseAddressModifyEnable); 2981 } 2982 inline void setGeneralStateMemoryObjectControlStateReserved(const uint64_t value) { 2983 TheStructure.Common.GeneralStateMemoryObjectControlState_Reserved = value; 2984 } 2985 inline uint64_t getGeneralStateMemoryObjectControlStateReserved() const { 2986 return (TheStructure.Common.GeneralStateMemoryObjectControlState_Reserved); 2987 } 2988 inline void setGeneralStateMemoryObjectControlState(const uint64_t value) { 2989 TheStructure.Common.GeneralStateMemoryObjectControlState_IndexToMocsTables = value >> 1; 2990 } 2991 inline uint64_t getGeneralStateMemoryObjectControlState() const { 2992 return (TheStructure.Common.GeneralStateMemoryObjectControlState_IndexToMocsTables << 1); 2993 } 2994 typedef enum tagGENERALSTATEBASEADDRESS { 2995 GENERALSTATEBASEADDRESS_BIT_SHIFT = 0xc, 2996 GENERALSTATEBASEADDRESS_ALIGN_SIZE = 0x1000, 2997 } GENERALSTATEBASEADDRESS; 2998 inline void setGeneralStateBaseAddress(const uint64_t value) { 2999 TheStructure.Common.GeneralStateBaseAddress = value >> GENERALSTATEBASEADDRESS_BIT_SHIFT; 3000 } 3001 inline uint64_t getGeneralStateBaseAddress() const { 3002 return (TheStructure.Common.GeneralStateBaseAddress << GENERALSTATEBASEADDRESS_BIT_SHIFT); 3003 } 3004 inline void setEnableMemoryCompressionForAllStatelessAccesses(const ENABLE_MEMORY_COMPRESSION_FOR_ALL_STATELESS_ACCESSES value) { 3005 TheStructure.Common.EnableMemoryCompressionForAllStatelessAccesses = value; 3006 } 3007 inline ENABLE_MEMORY_COMPRESSION_FOR_ALL_STATELESS_ACCESSES getEnableMemoryCompressionForAllStatelessAccesses() const { 3008 return static_cast<ENABLE_MEMORY_COMPRESSION_FOR_ALL_STATELESS_ACCESSES>(TheStructure.Common.EnableMemoryCompressionForAllStatelessAccesses); 3009 } 3010 inline void setDisableSupportForMultiGpuAtomicsForStatelessAccesses(const bool value) { 3011 TheStructure.Common.DisableSupportForMultiGpuAtomicsForStatelessAccesses = value; 3012 } 3013 inline bool getDisableSupportForMultiGpuAtomicsForStatelessAccesses() const { 3014 return (TheStructure.Common.DisableSupportForMultiGpuAtomicsForStatelessAccesses); 3015 } 3016 inline void setDisableSupportForMultiGpuPartialWritesForStatelessMessages(const bool value) { 3017 TheStructure.Common.DisableSupportForMultiGpuPartialWritesForStatelessMessages = value; 3018 } 3019 inline bool getDisableSupportForMultiGpuPartialWritesForStatelessMessages() const { 3020 return (TheStructure.Common.DisableSupportForMultiGpuPartialWritesForStatelessMessages); 3021 } 3022 inline void setStatelessDataPortAccessMemoryObjectControlStateReserved(const uint32_t value) { 3023 TheStructure.Common.StatelessDataPortAccessMemoryObjectControlState_Reserved = value; 3024 } 3025 inline uint32_t getStatelessDataPortAccessMemoryObjectControlStateReserved() const { 3026 return (TheStructure.Common.StatelessDataPortAccessMemoryObjectControlState_Reserved); 3027 } 3028 inline void setStatelessDataPortAccessMemoryObjectControlState(const uint32_t value) { 3029 TheStructure.Common.StatelessDataPortAccessMemoryObjectControlState_Reserved = value; 3030 TheStructure.Common.StatelessDataPortAccessMemoryObjectControlState_IndexToMocsTables = (value >> 1); 3031 } 3032 inline uint32_t getStatelessDataPortAccessMemoryObjectControlState() const { 3033 uint32_t mocs = TheStructure.Common.StatelessDataPortAccessMemoryObjectControlState_Reserved; 3034 mocs |= (TheStructure.Common.StatelessDataPortAccessMemoryObjectControlState_IndexToMocsTables << 1); 3035 return (mocs); 3036 } 3037 inline void setSurfaceStateBaseAddressModifyEnable(const bool value) { 3038 TheStructure.Common.SurfaceStateBaseAddressModifyEnable = value; 3039 } 3040 inline bool getSurfaceStateBaseAddressModifyEnable() const { 3041 return (TheStructure.Common.SurfaceStateBaseAddressModifyEnable); 3042 } 3043 inline void setSurfaceStateMemoryObjectControlStateReserved(const uint64_t value) { 3044 TheStructure.Common.SurfaceStateMemoryObjectControlState_Reserved = value; 3045 } 3046 inline uint64_t getSurfaceStateMemoryObjectControlStateReserved() const { 3047 return (TheStructure.Common.SurfaceStateMemoryObjectControlState_Reserved); 3048 } 3049 inline void setSurfaceStateMemoryObjectControlState(const uint64_t value) { 3050 TheStructure.Common.SurfaceStateMemoryObjectControlState_IndexToMocsTables = value >> 1; 3051 } 3052 inline uint64_t getSurfaceStateMemoryObjectControlState() const { 3053 return (TheStructure.Common.SurfaceStateMemoryObjectControlState_IndexToMocsTables << 1); 3054 } 3055 typedef enum tagSURFACESTATEBASEADDRESS { 3056 SURFACESTATEBASEADDRESS_BIT_SHIFT = 0xc, 3057 SURFACESTATEBASEADDRESS_ALIGN_SIZE = 0x1000, 3058 } SURFACESTATEBASEADDRESS; 3059 inline void setSurfaceStateBaseAddress(const uint64_t value) { 3060 TheStructure.Common.SurfaceStateBaseAddress = value >> SURFACESTATEBASEADDRESS_BIT_SHIFT; 3061 } 3062 inline uint64_t getSurfaceStateBaseAddress() const { 3063 return (TheStructure.Common.SurfaceStateBaseAddress << SURFACESTATEBASEADDRESS_BIT_SHIFT); 3064 } 3065 inline void setDynamicStateBaseAddressModifyEnable(const bool value) { 3066 TheStructure.Common.DynamicStateBaseAddressModifyEnable = value; 3067 } 3068 inline bool getDynamicStateBaseAddressModifyEnable() const { 3069 return (TheStructure.Common.DynamicStateBaseAddressModifyEnable); 3070 } 3071 inline void setDynamicStateMemoryObjectControlStateReserved(const uint64_t value) { 3072 TheStructure.Common.DynamicStateMemoryObjectControlState_Reserved = value; 3073 } 3074 inline uint64_t getDynamicStateMemoryObjectControlStateReserved() const { 3075 return (TheStructure.Common.DynamicStateMemoryObjectControlState_Reserved); 3076 } 3077 inline void setDynamicStateMemoryObjectControlState(const uint64_t value) { 3078 TheStructure.Common.DynamicStateMemoryObjectControlState_IndexToMocsTables = value >> 1; 3079 } 3080 inline uint64_t getDynamicStateMemoryObjectControlState() const { 3081 return (TheStructure.Common.DynamicStateMemoryObjectControlState_IndexToMocsTables << 1); 3082 } 3083 typedef enum tagDYNAMICSTATEBASEADDRESS { 3084 DYNAMICSTATEBASEADDRESS_BIT_SHIFT = 0xc, 3085 DYNAMICSTATEBASEADDRESS_ALIGN_SIZE = 0x1000, 3086 } DYNAMICSTATEBASEADDRESS; 3087 inline void setDynamicStateBaseAddress(const uint64_t value) { 3088 TheStructure.Common.DynamicStateBaseAddress = value >> DYNAMICSTATEBASEADDRESS_BIT_SHIFT; 3089 } 3090 inline uint64_t getDynamicStateBaseAddress() const { 3091 return (TheStructure.Common.DynamicStateBaseAddress << DYNAMICSTATEBASEADDRESS_BIT_SHIFT); 3092 } 3093 inline void setInstructionBaseAddressModifyEnable(const bool value) { 3094 TheStructure.Common.InstructionBaseAddressModifyEnable = value; 3095 } 3096 inline bool getInstructionBaseAddressModifyEnable() const { 3097 return (TheStructure.Common.InstructionBaseAddressModifyEnable); 3098 } 3099 inline void setInstructionMemoryObjectControlStateReserved(const uint64_t value) { 3100 TheStructure.Common.InstructionMemoryObjectControlState_Reserved = value; 3101 } 3102 inline uint64_t getInstructionMemoryObjectControlStateReserved() const { 3103 return (TheStructure.Common.InstructionMemoryObjectControlState_Reserved); 3104 } 3105 inline void setInstructionMemoryObjectControlState(const uint32_t value) { 3106 uint64_t val = static_cast<uint64_t>(value); 3107 TheStructure.Common.InstructionMemoryObjectControlState_Reserved = val; 3108 TheStructure.Common.InstructionMemoryObjectControlState_IndexToMocsTables = (val >> 1); 3109 } 3110 inline uint32_t getInstructionMemoryObjectControlState() const { 3111 uint64_t mocs = TheStructure.Common.InstructionMemoryObjectControlState_Reserved; 3112 mocs |= (TheStructure.Common.InstructionMemoryObjectControlState_IndexToMocsTables << 1); 3113 return static_cast<uint32_t>(mocs); 3114 } 3115 typedef enum tagINSTRUCTIONBASEADDRESS { 3116 INSTRUCTIONBASEADDRESS_BIT_SHIFT = 0xc, 3117 INSTRUCTIONBASEADDRESS_ALIGN_SIZE = 0x1000, 3118 } INSTRUCTIONBASEADDRESS; 3119 inline void setInstructionBaseAddress(const uint64_t value) { 3120 TheStructure.Common.InstructionBaseAddress = value >> INSTRUCTIONBASEADDRESS_BIT_SHIFT; 3121 } 3122 inline uint64_t getInstructionBaseAddress() const { 3123 return (TheStructure.Common.InstructionBaseAddress << INSTRUCTIONBASEADDRESS_BIT_SHIFT); 3124 } 3125 inline void setGeneralStateBufferSizeModifyEnable(const bool value) { 3126 TheStructure.Common.GeneralStateBufferSizeModifyEnable = value; 3127 } 3128 inline bool getGeneralStateBufferSizeModifyEnable() const { 3129 return (TheStructure.Common.GeneralStateBufferSizeModifyEnable); 3130 } 3131 inline void setGeneralStateBufferSize(const uint32_t value) { 3132 TheStructure.Common.GeneralStateBufferSize = value; 3133 } 3134 inline uint32_t getGeneralStateBufferSize() const { 3135 return (TheStructure.Common.GeneralStateBufferSize); 3136 } 3137 inline void setDynamicStateBufferSizeModifyEnable(const bool value) { 3138 TheStructure.Common.DynamicStateBufferSizeModifyEnable = value; 3139 } 3140 inline bool getDynamicStateBufferSizeModifyEnable() const { 3141 return (TheStructure.Common.DynamicStateBufferSizeModifyEnable); 3142 } 3143 inline void setDynamicStateBufferSize(const uint32_t value) { 3144 TheStructure.Common.DynamicStateBufferSize = value; 3145 } 3146 inline uint32_t getDynamicStateBufferSize() const { 3147 return (TheStructure.Common.DynamicStateBufferSize); 3148 } 3149 inline void setIndirectObjectBufferSizeModifyEnable(const bool value) { 3150 TheStructure.Common.IndirectObjectBufferSizeModifyEnable = value; 3151 } 3152 inline bool getIndirectObjectBufferSizeModifyEnable() const { 3153 return (TheStructure.Common.IndirectObjectBufferSizeModifyEnable); 3154 } 3155 inline void setIndirectObjectBufferSize(const uint32_t value) { 3156 TheStructure.Common.IndirectObjectBufferSize = value; 3157 } 3158 inline uint32_t getIndirectObjectBufferSize() const { 3159 return (TheStructure.Common.IndirectObjectBufferSize); 3160 } 3161 inline void setInstructionBufferSizeModifyEnable(const bool value) { 3162 TheStructure.Common.InstructionBufferSizeModifyEnable = value; 3163 } 3164 inline bool getInstructionBufferSizeModifyEnable() const { 3165 return (TheStructure.Common.InstructionBufferSizeModifyEnable); 3166 } 3167 inline void setInstructionBufferSize(const uint32_t value) { 3168 TheStructure.Common.InstructionBufferSize = value; 3169 } 3170 inline uint32_t getInstructionBufferSize() const { 3171 return (TheStructure.Common.InstructionBufferSize); 3172 } 3173 inline void setBindlessSurfaceStateBaseAddressModifyEnable(const bool value) { 3174 TheStructure.Common.BindlessSurfaceStateBaseAddressModifyEnable = value; 3175 } 3176 inline bool getBindlessSurfaceStateBaseAddressModifyEnable() const { 3177 return (TheStructure.Common.BindlessSurfaceStateBaseAddressModifyEnable); 3178 } 3179 inline void setBindlessSurfaceStateMemoryObjectControlStateReserved(const uint64_t value) { 3180 TheStructure.Common.BindlessSurfaceStateMemoryObjectControlState_Reserved = value; 3181 } 3182 inline uint64_t getBindlessSurfaceStateMemoryObjectControlStateReserved() const { 3183 return (TheStructure.Common.BindlessSurfaceStateMemoryObjectControlState_Reserved); 3184 } 3185 inline void setBindlessSurfaceStateMemoryObjectControlState(const uint64_t value) { 3186 TheStructure.Common.BindlessSurfaceStateMemoryObjectControlState_IndexToMocsTables = value >> 1; 3187 } 3188 inline uint64_t getBindlessSurfaceStateMemoryObjectControlState() const { 3189 return (TheStructure.Common.BindlessSurfaceStateMemoryObjectControlState_IndexToMocsTables << 1); 3190 } 3191 typedef enum tagBINDLESSSURFACESTATEBASEADDRESS { 3192 BINDLESSSURFACESTATEBASEADDRESS_BIT_SHIFT = 0xc, 3193 BINDLESSSURFACESTATEBASEADDRESS_ALIGN_SIZE = 0x1000, 3194 } BINDLESSSURFACESTATEBASEADDRESS; 3195 inline void setBindlessSurfaceStateBaseAddress(const uint64_t value) { 3196 TheStructure.Common.BindlessSurfaceStateBaseAddress = value >> BINDLESSSURFACESTATEBASEADDRESS_BIT_SHIFT; 3197 } 3198 inline uint64_t getBindlessSurfaceStateBaseAddress() const { 3199 return (TheStructure.Common.BindlessSurfaceStateBaseAddress << BINDLESSSURFACESTATEBASEADDRESS_BIT_SHIFT); 3200 } 3201 inline void setBindlessSurfaceStateSize(const uint32_t value) { 3202 TheStructure.Common.BindlessSurfaceStateSize = value; 3203 } 3204 inline uint32_t getBindlessSurfaceStateSize() const { 3205 return TheStructure.Common.BindlessSurfaceStateSize; 3206 } 3207 inline void setBindlessSamplerStateBaseAddressModifyEnable(const bool value) { 3208 TheStructure.Common.BindlessSamplerStateBaseAddressModifyEnable = value; 3209 } 3210 inline bool getBindlessSamplerStateBaseAddressModifyEnable() const { 3211 return (TheStructure.Common.BindlessSamplerStateBaseAddressModifyEnable); 3212 } 3213 inline void setBindlessSamplerStateMemoryObjectControlStateReserved(const uint64_t value) { 3214 TheStructure.Common.BindlessSamplerStateMemoryObjectControlState_Reserved = value; 3215 } 3216 inline uint64_t getBindlessSamplerStateMemoryObjectControlStateReserved() const { 3217 return (TheStructure.Common.BindlessSamplerStateMemoryObjectControlState_Reserved); 3218 } 3219 inline void setBindlessSamplerStateMemoryObjectControlState(const uint64_t value) { 3220 TheStructure.Common.BindlessSamplerStateMemoryObjectControlState_IndexToMocsTables = value >> 1; 3221 } 3222 inline uint64_t getBindlessSamplerStateMemoryObjectControlState() const { 3223 return (TheStructure.Common.BindlessSamplerStateMemoryObjectControlState_IndexToMocsTables << 1); 3224 } 3225 typedef enum tagBINDLESSSAMPLERSTATEBASEADDRESS { 3226 BINDLESSSAMPLERSTATEBASEADDRESS_BIT_SHIFT = 0xc, 3227 BINDLESSSAMPLERSTATEBASEADDRESS_ALIGN_SIZE = 0x1000, 3228 } BINDLESSSAMPLERSTATEBASEADDRESS; 3229 inline void setBindlessSamplerStateBaseAddress(const uint64_t value) { 3230 TheStructure.Common.BindlessSamplerStateBaseAddress = value >> BINDLESSSAMPLERSTATEBASEADDRESS_BIT_SHIFT; 3231 } 3232 inline uint64_t getBindlessSamplerStateBaseAddress() const { 3233 return (TheStructure.Common.BindlessSamplerStateBaseAddress << BINDLESSSAMPLERSTATEBASEADDRESS_BIT_SHIFT); 3234 } 3235 inline void setBindlessSamplerStateBufferSize(const uint32_t value) { 3236 TheStructure.Common.BindlessSamplerStateBufferSize = value; 3237 } 3238 inline uint32_t getBindlessSamplerStateBufferSize() const { 3239 return (TheStructure.Common.BindlessSamplerStateBufferSize); 3240 } 3241} STATE_BASE_ADDRESS; 3242STATIC_ASSERT(88 == sizeof(STATE_BASE_ADDRESS)); 3243 3244typedef struct tagMI_REPORT_PERF_COUNT { 3245 union tagTheStructure { 3246 struct tagCommon { 3247 uint32_t DwordLength : BITFIELD_RANGE(0, 5); 3248 uint32_t Reserved_6 : BITFIELD_RANGE(6, 22); 3249 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 3250 uint32_t CommandType : BITFIELD_RANGE(29, 31); 3251 uint64_t UseGlobalGtt : BITFIELD_RANGE(0, 0); 3252 uint64_t Reserved_33 : BITFIELD_RANGE(1, 3); 3253 uint64_t CoreModeEnable : BITFIELD_RANGE(4, 4); 3254 uint64_t Reserved_37 : BITFIELD_RANGE(5, 5); 3255 uint64_t MemoryAddress : BITFIELD_RANGE(6, 63); 3256 uint32_t ReportId; 3257 } Common; 3258 uint32_t RawData[4]; 3259 } TheStructure; 3260 typedef enum tagDWORD_LENGTH { 3261 DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x2, 3262 } DWORD_LENGTH; 3263 typedef enum tagMI_COMMAND_OPCODE { 3264 MI_COMMAND_OPCODE_MI_REPORT_PERF_COUNT = 0x28, 3265 } MI_COMMAND_OPCODE; 3266 typedef enum tagCOMMAND_TYPE { 3267 COMMAND_TYPE_MI_COMMAND = 0x0, 3268 } COMMAND_TYPE; 3269 typedef enum tagPATCH_CONSTANTS { 3270 MEMORYADDRESS_BYTEOFFSET = 0x4, 3271 MEMORYADDRESS_INDEX = 0x1, 3272 } PATCH_CONSTANTS; 3273 inline void init() { 3274 memset(&TheStructure, 0, sizeof(TheStructure)); 3275 TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1; 3276 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_REPORT_PERF_COUNT; 3277 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 3278 } 3279 static tagMI_REPORT_PERF_COUNT sInit() { 3280 MI_REPORT_PERF_COUNT state; 3281 state.init(); 3282 return state; 3283 } 3284 inline uint32_t &getRawData(const uint32_t index) { 3285 DEBUG_BREAK_IF(index >= 4); 3286 return TheStructure.RawData[index]; 3287 } 3288 inline void setUseGlobalGtt(const bool value) { 3289 TheStructure.Common.UseGlobalGtt = value; 3290 } 3291 inline bool getUseGlobalGtt() const { 3292 return (TheStructure.Common.UseGlobalGtt); 3293 } 3294 inline void setCoreModeEnable(const uint64_t value) { 3295 TheStructure.Common.CoreModeEnable = value; 3296 } 3297 inline uint64_t getCoreModeEnable() const { 3298 return (TheStructure.Common.CoreModeEnable); 3299 } 3300 typedef enum tagMEMORYADDRESS { 3301 MEMORYADDRESS_BIT_SHIFT = 0x6, 3302 MEMORYADDRESS_ALIGN_SIZE = 0x40, 3303 } MEMORYADDRESS; 3304 inline void setMemoryAddress(const uint64_t value) { 3305 TheStructure.Common.MemoryAddress = value >> MEMORYADDRESS_BIT_SHIFT; 3306 } 3307 inline uint64_t getMemoryAddress() const { 3308 return (TheStructure.Common.MemoryAddress << MEMORYADDRESS_BIT_SHIFT); 3309 } 3310 inline void setReportId(const uint32_t value) { 3311 TheStructure.Common.ReportId = value; 3312 } 3313 inline uint32_t getReportId() const { 3314 return (TheStructure.Common.ReportId); 3315 } 3316} MI_REPORT_PERF_COUNT; 3317STATIC_ASSERT(16 == sizeof(MI_REPORT_PERF_COUNT)); 3318 3319struct MI_USER_INTERRUPT { 3320 union tagTheStructure { 3321 struct tagCommon { 3322 uint32_t Reserved_0 : BITFIELD_RANGE(0, 22); 3323 uint32_t MICommandOpcode : BITFIELD_RANGE(23, 28); 3324 uint32_t CommandType : BITFIELD_RANGE(29, 31); 3325 } Common; 3326 uint32_t RawData[1]; 3327 } TheStructure; 3328 enum MI_COMMAND_OPCODE { 3329 MI_COMMAND_OPCODE_MI_USER_INTERRUPT = 2, 3330 }; 3331 enum COMMAND_TYPE { 3332 COMMAND_TYPE_MI_COMMAND = 0, 3333 }; 3334 inline void init() { 3335 memset(&TheStructure, 0, sizeof(TheStructure)); 3336 TheStructure.Common.MICommandOpcode = MI_COMMAND_OPCODE_MI_USER_INTERRUPT; 3337 } 3338 static MI_USER_INTERRUPT sInit() { 3339 MI_USER_INTERRUPT state; 3340 state.init(); 3341 return state; 3342 } 3343 inline uint32_t &getRawData(const uint32_t index) { 3344 return TheStructure.RawData[index]; 3345 } 3346}; 3347STATIC_ASSERT(4 == sizeof(MI_USER_INTERRUPT)); 3348 3349typedef struct tagMI_SET_PREDICATE { 3350 union tagTheStructure { 3351 struct tagCommon { 3352 uint32_t PredicateEnable : BITFIELD_RANGE(0, 3); 3353 uint32_t PredicateEnableWparid : BITFIELD_RANGE(4, 5); 3354 uint32_t Reserved_6 : BITFIELD_RANGE(6, 22); 3355 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 3356 uint32_t CommandType : BITFIELD_RANGE(29, 31); 3357 } Common; 3358 uint32_t RawData[1]; 3359 } TheStructure; 3360 typedef enum tagPREDICATE_ENABLE { 3361 PREDICATE_ENABLE_PREDICATE_DISABLE = 0x0, 3362 PREDICATE_ENABLE_PREDICATE_ON_CLEAR = 0x1, 3363 PREDICATE_ENABLE_PREDICATE_ON_SET = 0x2, 3364 PREDICATE_ENABLE_NOOP_ALWAYS = 0xf, 3365 } PREDICATE_ENABLE; 3366 typedef enum tagPREDICATE_ENABLE_WPARID { 3367 PREDICATE_ENABLE_WPARID_NOOP_NEVER = 0x0, 3368 PREDICATE_ENABLE_WPARID_NOOP_ON_ZERO_VALUE = 0x1, 3369 PREDICATE_ENABLE_WPARID_NOOP_ON_NON_ZERO_VALUE = 0x2, 3370 } PREDICATE_ENABLE_WPARID; 3371 typedef enum tagMI_COMMAND_OPCODE { 3372 MI_COMMAND_OPCODE_MI_SET_PREDICATE = 0x1, 3373 } MI_COMMAND_OPCODE; 3374 typedef enum tagCOMMAND_TYPE { 3375 COMMAND_TYPE_MI_COMMAND = 0x0, 3376 } COMMAND_TYPE; 3377 inline void init() { 3378 memset(&TheStructure, 0, sizeof(TheStructure)); 3379 TheStructure.Common.PredicateEnable = PREDICATE_ENABLE_PREDICATE_DISABLE; 3380 TheStructure.Common.PredicateEnableWparid = PREDICATE_ENABLE_WPARID_NOOP_NEVER; 3381 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_SET_PREDICATE; 3382 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 3383 } 3384 static tagMI_SET_PREDICATE sInit() { 3385 MI_SET_PREDICATE state; 3386 state.init(); 3387 return state; 3388 } 3389 inline uint32_t &getRawData(const uint32_t index) { 3390 UNRECOVERABLE_IF(index >= 1); 3391 return TheStructure.RawData[index]; 3392 } 3393 inline void setPredicateEnable(const PREDICATE_ENABLE value) { 3394 TheStructure.Common.PredicateEnable = value; 3395 } 3396 inline PREDICATE_ENABLE getPredicateEnable() const { 3397 return static_cast<PREDICATE_ENABLE>(TheStructure.Common.PredicateEnable); 3398 } 3399 inline void setPredicateEnableWparid(const PREDICATE_ENABLE_WPARID value) { 3400 TheStructure.Common.PredicateEnableWparid = value; 3401 } 3402 inline PREDICATE_ENABLE_WPARID getPredicateEnableWparid() const { 3403 return static_cast<PREDICATE_ENABLE_WPARID>(TheStructure.Common.PredicateEnableWparid); 3404 } 3405} MI_SET_PREDICATE; 3406STATIC_ASSERT(4 == sizeof(MI_SET_PREDICATE)); 3407 3408typedef struct tagMI_CONDITIONAL_BATCH_BUFFER_END { 3409 union tagTheStructure { 3410 struct tagCommon { 3411 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 3412 uint32_t Reserved_8 : BITFIELD_RANGE(8, 11); 3413 uint32_t CompareOperation : BITFIELD_RANGE(12, 14); 3414 uint32_t PredicateEnable : BITFIELD_RANGE(15, 15); 3415 uint32_t Reserved_16 : BITFIELD_RANGE(16, 17); 3416 uint32_t EndCurrentBatchBufferLevel : BITFIELD_RANGE(18, 18); 3417 uint32_t CompareMaskMode : BITFIELD_RANGE(19, 19); 3418 uint32_t Reserved_20 : BITFIELD_RANGE(20, 20); 3419 uint32_t CompareSemaphore : BITFIELD_RANGE(21, 21); 3420 uint32_t UseGlobalGtt : BITFIELD_RANGE(22, 22); 3421 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 3422 uint32_t CommandType : BITFIELD_RANGE(29, 31); 3423 uint32_t CompareDataDword; 3424 uint64_t Reserved_64 : BITFIELD_RANGE(0, 2); 3425 uint64_t CompareAddress : BITFIELD_RANGE(3, 47); 3426 uint64_t CompareAddressReserved_112 : BITFIELD_RANGE(48, 63); 3427 } Common; 3428 uint32_t RawData[4]; 3429 } TheStructure; 3430 typedef enum tagDWORD_LENGTH { 3431 DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x2, 3432 } DWORD_LENGTH; 3433 typedef enum tagCOMPARE_OPERATION { 3434 COMPARE_OPERATION_MAD_GREATER_THAN_IDD = 0x0, 3435 COMPARE_OPERATION_MAD_GREATER_THAN_OR_EQUAL_IDD = 0x1, 3436 COMPARE_OPERATION_MAD_LESS_THAN_IDD = 0x2, 3437 COMPARE_OPERATION_MAD_LESS_THAN_OR_EQUAL_IDD = 0x3, 3438 COMPARE_OPERATION_MAD_EQUAL_IDD = 0x4, 3439 COMPARE_OPERATION_MAD_NOT_EQUAL_IDD = 0x5, 3440 } COMPARE_OPERATION; 3441 typedef enum tagCOMPARE_MASK_MODE { 3442 COMPARE_MASK_MODE_COMPARE_MASK_MODE_DISABLED = 0x0, 3443 COMPARE_MASK_MODE_COMPARE_MASK_MODE_ENABLED = 0x1, 3444 } COMPARE_MASK_MODE; 3445 typedef enum tagMI_COMMAND_OPCODE { 3446 MI_COMMAND_OPCODE_MI_CONDITIONAL_BATCH_BUFFER_END = 0x36, 3447 } MI_COMMAND_OPCODE; 3448 typedef enum tagCOMMAND_TYPE { 3449 COMMAND_TYPE_MI_COMMAND = 0x0, 3450 } COMMAND_TYPE; 3451 inline void init() { 3452 memset(&TheStructure, 0, sizeof(TheStructure)); 3453 TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1; 3454 TheStructure.Common.CompareOperation = COMPARE_OPERATION_MAD_GREATER_THAN_IDD; 3455 TheStructure.Common.CompareMaskMode = COMPARE_MASK_MODE_COMPARE_MASK_MODE_DISABLED; 3456 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_CONDITIONAL_BATCH_BUFFER_END; 3457 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 3458 } 3459 static tagMI_CONDITIONAL_BATCH_BUFFER_END sInit() { 3460 MI_CONDITIONAL_BATCH_BUFFER_END state; 3461 state.init(); 3462 return state; 3463 } 3464 inline uint32_t &getRawData(const uint32_t index) { 3465 UNRECOVERABLE_IF(index >= 4); 3466 return TheStructure.RawData[index]; 3467 } 3468 inline void setCompareOperation(const COMPARE_OPERATION value) { 3469 TheStructure.Common.CompareOperation = value; 3470 } 3471 inline COMPARE_OPERATION getCompareOperation() const { 3472 return static_cast<COMPARE_OPERATION>(TheStructure.Common.CompareOperation); 3473 } 3474 inline void setPredicateEnable(const bool value) { 3475 TheStructure.Common.PredicateEnable = value; 3476 } 3477 inline bool getPredicateEnable() const { 3478 return TheStructure.Common.PredicateEnable; 3479 } 3480 inline void setEndCurrentBatchBufferLevel(const bool value) { 3481 TheStructure.Common.EndCurrentBatchBufferLevel = value; 3482 } 3483 inline bool getEndCurrentBatchBufferLevel() const { 3484 return TheStructure.Common.EndCurrentBatchBufferLevel; 3485 } 3486 inline void setCompareMaskMode(const COMPARE_MASK_MODE value) { 3487 TheStructure.Common.CompareMaskMode = value; 3488 } 3489 inline COMPARE_MASK_MODE getCompareMaskMode() const { 3490 return static_cast<COMPARE_MASK_MODE>(TheStructure.Common.CompareMaskMode); 3491 } 3492 inline void setCompareSemaphore(const bool value) { 3493 TheStructure.Common.CompareSemaphore = value; 3494 } 3495 inline bool getCompareSemaphore() const { 3496 return TheStructure.Common.CompareSemaphore; 3497 } 3498 inline void setUseGlobalGtt(const bool value) { 3499 TheStructure.Common.UseGlobalGtt = value; 3500 } 3501 inline bool getUseGlobalGtt() const { 3502 return TheStructure.Common.UseGlobalGtt; 3503 } 3504 inline void setCompareDataDword(const uint32_t value) { 3505 TheStructure.Common.CompareDataDword = value; 3506 } 3507 inline uint32_t getCompareDataDword() const { 3508 return TheStructure.Common.CompareDataDword; 3509 } 3510 typedef enum tagCOMPAREADDRESS { 3511 COMPAREADDRESS_BIT_SHIFT = 0x3, 3512 COMPAREADDRESS_ALIGN_SIZE = 0x8, 3513 } COMPAREADDRESS; 3514 inline void setCompareAddress(const uint64_t value) { 3515 TheStructure.Common.CompareAddress = value >> COMPAREADDRESS_BIT_SHIFT; 3516 } 3517 inline uint64_t getCompareAddress() const { 3518 return TheStructure.Common.CompareAddress << COMPAREADDRESS_BIT_SHIFT; 3519 } 3520} MI_CONDITIONAL_BATCH_BUFFER_END; 3521STATIC_ASSERT(16 == sizeof(MI_CONDITIONAL_BATCH_BUFFER_END)); 3522 3523struct XY_BLOCK_COPY_BLT { 3524 union tagTheStructure { 3525 struct tagCommon { 3526 /// DWORD 0 3527 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 3528 uint32_t Reserved_8 : BITFIELD_RANGE(8, 8); 3529 uint32_t NumberofMultisamples : BITFIELD_RANGE(9, 11); 3530 uint32_t SpecialModeofOperation : BITFIELD_RANGE(12, 13); 3531 uint32_t Reserved_14 : BITFIELD_RANGE(14, 18); 3532 uint32_t ColorDepth : BITFIELD_RANGE(19, 21); 3533 uint32_t InstructionTarget_Opcode : BITFIELD_RANGE(22, 28); 3534 uint32_t Client : BITFIELD_RANGE(29, 31); 3535 3536 /// DWORD 1 3537 uint32_t DestinationPitch : BITFIELD_RANGE(0, 17); 3538 uint32_t DestinationAuxiliarysurfacemode : BITFIELD_RANGE(18, 20); 3539 uint32_t DestinationMOCS : BITFIELD_RANGE(21, 27); 3540 uint32_t DestinationCompressionType : BITFIELD_RANGE(28, 28); 3541 uint32_t DestinationCompressionEnable : BITFIELD_RANGE(29, 29); 3542 uint32_t DestinationTiling : BITFIELD_RANGE(30, 31); 3543 3544 /// DWORD 2 3545 uint32_t DestinationX1Coordinate_Left : BITFIELD_RANGE(0, 15); 3546 uint32_t DestinationY1Coordinate_Top : BITFIELD_RANGE(16, 31); 3547 3548 /// DWORD 3 3549 uint32_t DestinationX2Coordinate_Right : BITFIELD_RANGE(0, 15); 3550 uint32_t DestinationY2Coordinate_Bottom : BITFIELD_RANGE(16, 31); 3551 3552 /// DWORD 4..5 3553 uint64_t DestinationBaseAddress; 3554 3555 /// DWORD 6 3556 uint32_t DestinationXoffset : BITFIELD_RANGE(0, 13); 3557 uint32_t Reserved_206 : BITFIELD_RANGE(14, 15); 3558 uint32_t DestinationYoffset : BITFIELD_RANGE(16, 29); 3559 uint32_t Reserved_222 : BITFIELD_RANGE(30, 30); 3560 uint32_t DestinationTargetMemory : BITFIELD_RANGE(31, 31); 3561 3562 /// DWORD 7 3563 uint32_t SourceX1Coordinate_Left : BITFIELD_RANGE(0, 15); 3564 uint32_t SourceY1Coordinate_Top : BITFIELD_RANGE(16, 31); 3565 3566 /// DWORD 8 3567 uint32_t SourcePitch : BITFIELD_RANGE(0, 17); 3568 uint32_t SourceAuxiliarysurfacemode : BITFIELD_RANGE(18, 20); 3569 uint32_t SourceMOCS : BITFIELD_RANGE(21, 27); 3570 uint32_t SourceCompressionType : BITFIELD_RANGE(28, 28); 3571 uint32_t SourceCompressionEnable : BITFIELD_RANGE(29, 29); 3572 uint32_t SourceTiling : BITFIELD_RANGE(30, 31); 3573 3574 /// DWORD 9..10 3575 uint64_t SourceBaseAddress; 3576 3577 /// DWORD 11 3578 uint32_t SourceXoffset : BITFIELD_RANGE(0, 13); 3579 uint32_t Reserved_366 : BITFIELD_RANGE(14, 15); 3580 uint32_t SourceYoffset : BITFIELD_RANGE(16, 29); 3581 uint32_t Reserved_382 : BITFIELD_RANGE(30, 30); 3582 uint32_t SourceTargetMemory : BITFIELD_RANGE(31, 31); 3583 3584 /// DWORD 12 3585 uint32_t SourceCompressionFormat : BITFIELD_RANGE(0, 4); 3586 uint32_t SourceClearValueEnable : BITFIELD_RANGE(5, 5); 3587 uint32_t SourceClearAddressLow : BITFIELD_RANGE(6, 31); 3588 3589 /// DWORD 13 3590 uint32_t SourceClearAddressHigh : BITFIELD_RANGE(0, 15); 3591 uint32_t Reserved_432 : BITFIELD_RANGE(16, 31); 3592 3593 /// DWORD 14 3594 uint32_t DestinationCompressionFormat : BITFIELD_RANGE(0, 4); 3595 uint32_t DestinationClearValueEnable : BITFIELD_RANGE(5, 5); 3596 uint32_t DestinationClearAddressLow : BITFIELD_RANGE(6, 31); 3597 3598 /// DWORD 15 3599 uint32_t DestinationClearAddressHigh : BITFIELD_RANGE(0, 15); 3600 uint32_t Reserved_496 : BITFIELD_RANGE(16, 31); 3601 3602 /// DWORD 16 3603 uint32_t DestinationSurfaceHeight : BITFIELD_RANGE(0, 13); 3604 uint32_t DestinationSurfaceWidth : BITFIELD_RANGE(14, 27); 3605 uint32_t Reserved_540 : BITFIELD_RANGE(28, 28); 3606 uint32_t DestinationSurfaceType : BITFIELD_RANGE(29, 31); 3607 3608 /// DWORD 17 3609 uint32_t DestinationLOD : BITFIELD_RANGE(0, 3); 3610 uint32_t DestinationSurfaceQpitch : BITFIELD_RANGE(4, 20); 3611 uint32_t DestinationSurfaceDepth : BITFIELD_RANGE(21, 31); 3612 3613 /// DWORD 18 3614 uint32_t DestinationHorizontalAlign : BITFIELD_RANGE(0, 1); 3615 uint32_t Reserved_578 : BITFIELD_RANGE(2, 2); 3616 uint32_t DestinationVerticalAlign : BITFIELD_RANGE(3, 4); 3617 uint32_t DestinationSSID : BITFIELD_RANGE(5, 7); 3618 uint32_t DestinationMipTailStartLOD : BITFIELD_RANGE(8, 11); 3619 uint32_t Reserved_588 : BITFIELD_RANGE(12, 17); 3620 uint32_t DestinationDepthStencilResource : BITFIELD_RANGE(18, 18); 3621 uint32_t Reserved_595 : BITFIELD_RANGE(19, 20); 3622 uint32_t DestinationArrayIndex : BITFIELD_RANGE(21, 31); 3623 3624 /// DWORD 19 3625 uint32_t SourceSurfaceHeight : BITFIELD_RANGE(0, 13); 3626 uint32_t SourceSurfaceWidth : BITFIELD_RANGE(14, 27); 3627 uint32_t Reserved_636 : BITFIELD_RANGE(28, 28); 3628 uint32_t SourceSurfaceType : BITFIELD_RANGE(29, 31); 3629 3630 /// DWORD 20 3631 uint32_t SourceLOD : BITFIELD_RANGE(0, 3); 3632 uint32_t SourceSurfaceQpitch : BITFIELD_RANGE(4, 20); 3633 uint32_t SourceSurfaceDepth : BITFIELD_RANGE(21, 31); 3634 3635 /// DWORD 21 3636 uint32_t SourceHorizontalAlign : BITFIELD_RANGE(0, 1); 3637 uint32_t Reserved_674 : BITFIELD_RANGE(2, 2); 3638 uint32_t SourceVerticalAlign : BITFIELD_RANGE(3, 4); 3639 uint32_t SourceSSID : BITFIELD_RANGE(5, 7); 3640 uint32_t SourceMipTailStartLOD : BITFIELD_RANGE(8, 11); 3641 uint32_t Reserved_684 : BITFIELD_RANGE(12, 17); 3642 uint32_t SourceDepthStencilResource : BITFIELD_RANGE(18, 18); 3643 uint32_t Reserved_691 : BITFIELD_RANGE(19, 20); 3644 uint32_t SourceArrayIndex : BITFIELD_RANGE(21, 31); 3645 3646 } Common; 3647 uint32_t RawData[22]; 3648 } TheStructure; 3649 3650 enum DWORD_LENGTH { 3651 DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 20, 3652 }; 3653 3654 enum NUMBER_OF_MULTISAMPLES { 3655 NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_1 = 0, 3656 NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_2 = 1, 3657 NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_4 = 2, 3658 NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_8 = 3, 3659 NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_16 = 4, 3660 }; 3661 3662 enum SPECIAL_MODE_OF_OPERATION { 3663 SPECIAL_MODE_OF_OPERATION_NONE = 0, 3664 SPECIAL_MODE_OF_OPERATION_FULL_RESOLVE = 1, 3665 SPECIAL_MODE_OF_OPERATION_PARTIAL_RESOLVE = 2, 3666 }; 3667 3668 enum COLOR_DEPTH { 3669 COLOR_DEPTH_8_BIT_COLOR = 0, 3670 COLOR_DEPTH_16_BIT_COLOR = 1, 3671 COLOR_DEPTH_32_BIT_COLOR = 2, 3672 COLOR_DEPTH_64_BIT_COLOR = 3, 3673 COLOR_DEPTH_96_BIT_COLOR_ONLY_LINEAR_CASE_IS_SUPPORTED = 4, 3674 COLOR_DEPTH_128_BIT_COLOR = 5, 3675 }; 3676 3677 enum CLIENT { 3678 CLIENT_2D_PROCESSOR = 2, 3679 }; 3680 3681 enum AUXILIARY_SURFACE_MODE { 3682 AUXILIARY_SURFACE_MODE_AUX_NONE = 0, 3683 AUXILIARY_SURFACE_MODE_AUX_CCS_E = 5, 3684 }; 3685 3686 enum COMPRESSION_TYPE { 3687 COMPRESSION_TYPE_3D_COMPRESSION = 0, 3688 COMPRESSION_TYPE_MEDIA_COMPRESSION = 1, 3689 }; 3690 3691 enum COMPRESSION_ENABLE { 3692 COMPRESSION_ENABLE_COMPRESSION_DISABLE = 0, 3693 COMPRESSION_ENABLE_COMPRESSION_ENABLE = 1, 3694 }; 3695 3696 enum TILING { 3697 TILING_LINEAR = 0, 3698 TILING_TILE4 = 2, 3699 TILING_TILE64 = 3, 3700 }; 3701 3702 enum TARGET_MEMORY { 3703 TARGET_MEMORY_LOCAL_MEM = 0, 3704 TARGET_MEMORY_SYSTEM_MEM = 1, 3705 }; 3706 3707 enum CLEAR_VALUE_ENABLE { 3708 CLEAR_VALUE_ENABLE_DISABLE = 0, 3709 CLEAR_VALUE_ENABLE_ENABLE = 1, 3710 }; 3711 3712 enum SURFACE_TYPE { 3713 SURFACE_TYPE_SURFTYPE_1D = 0, 3714 SURFACE_TYPE_SURFTYPE_2D = 1, 3715 SURFACE_TYPE_SURFTYPE_3D = 2, 3716 SURFACE_TYPE_SURFTYPE_CUBE = 3, 3717 SURFACE_TYPE_SURFTYPE_BUFFER = 4, 3718 SURFACE_TYPE_SURFTYPE_STRBUF = 5, 3719 SURFACE_TYPE_SURFTYPE_NULL = 7, 3720 }; 3721 3722 enum INSTRUCTIONTARGET_OPCODE { 3723 INSTRUCTIONTARGET_OPCODE_OPCODE = 0x41, 3724 }; 3725 3726 inline void init() { 3727 memset(&TheStructure, 0, sizeof(TheStructure)); 3728 TheStructure.Common.DwordLength = DWORD_LENGTH::DWORD_LENGTH_EXCLUDES_DWORD_0_1; 3729 TheStructure.Common.InstructionTarget_Opcode = INSTRUCTIONTARGET_OPCODE_OPCODE; 3730 TheStructure.Common.Client = CLIENT::CLIENT_2D_PROCESSOR; 3731 } 3732 3733 static XY_BLOCK_COPY_BLT sInit() { 3734 XY_BLOCK_COPY_BLT state; 3735 state.init(); 3736 return state; 3737 } 3738 3739 inline uint32_t &getRawData(const uint32_t index) { 3740 UNRECOVERABLE_IF(index < 22); 3741 return TheStructure.RawData[index]; 3742 } 3743 3744 inline void setNumberofMultisamples(const NUMBER_OF_MULTISAMPLES value) { 3745 TheStructure.Common.NumberofMultisamples = value; 3746 } 3747 3748 inline NUMBER_OF_MULTISAMPLES getNumberofMultisamples() const { 3749 return static_cast<NUMBER_OF_MULTISAMPLES>(TheStructure.Common.NumberofMultisamples); 3750 } 3751 3752 inline void setSpecialModeofOperation(const SPECIAL_MODE_OF_OPERATION value) { 3753 TheStructure.Common.SpecialModeofOperation = value; 3754 } 3755 3756 inline SPECIAL_MODE_OF_OPERATION getSpecialModeofOperation() const { 3757 return static_cast<SPECIAL_MODE_OF_OPERATION>(TheStructure.Common.SpecialModeofOperation); 3758 } 3759 3760 inline void setColorDepth(const COLOR_DEPTH value) { 3761 TheStructure.Common.ColorDepth = value; 3762 } 3763 3764 inline COLOR_DEPTH getColorDepth() const { 3765 return static_cast<COLOR_DEPTH>(TheStructure.Common.ColorDepth); 3766 } 3767 3768 inline void setInstructionTargetOpcode(const uint32_t value) { 3769 TheStructure.Common.InstructionTarget_Opcode = value; 3770 } 3771 3772 inline uint32_t getInstructionTargetOpcode() const { 3773 return (TheStructure.Common.InstructionTarget_Opcode); 3774 } 3775 3776 inline void setClient(const CLIENT value) { 3777 TheStructure.Common.Client = value; 3778 } 3779 3780 inline CLIENT getClient() const { 3781 return static_cast<CLIENT>(TheStructure.Common.Client); 3782 } 3783 3784 inline void setDestinationPitch(const uint32_t value) { 3785 TheStructure.Common.DestinationPitch = value - 1; 3786 } 3787 3788 inline uint32_t getDestinationPitch() const { 3789 return (TheStructure.Common.DestinationPitch + 1); 3790 } 3791 3792 inline void setDestinationAuxiliarysurfacemode(const AUXILIARY_SURFACE_MODE value) { 3793 TheStructure.Common.DestinationAuxiliarysurfacemode = value; 3794 } 3795 3796 inline AUXILIARY_SURFACE_MODE getDestinationAuxiliarysurfacemode() const { 3797 return static_cast<AUXILIARY_SURFACE_MODE>(TheStructure.Common.DestinationAuxiliarysurfacemode); 3798 } 3799 3800 inline void setDestinationMOCS(const uint32_t value) { 3801 TheStructure.Common.DestinationMOCS = value; 3802 } 3803 3804 inline uint32_t getDestinationMOCS() const { 3805 return (TheStructure.Common.DestinationMOCS); 3806 } 3807 3808 inline void setDestinationCompressionType(const COMPRESSION_TYPE value) { 3809 TheStructure.Common.DestinationCompressionType = value; 3810 } 3811 3812 inline COMPRESSION_TYPE getDestinationCompressionType() const { 3813 return static_cast<COMPRESSION_TYPE>(TheStructure.Common.DestinationCompressionType); 3814 } 3815 3816 inline void setDestinationCompressionEnable(const COMPRESSION_ENABLE value) { 3817 TheStructure.Common.DestinationCompressionEnable = value; 3818 } 3819 3820 inline COMPRESSION_ENABLE getDestinationCompressionEnable() const { 3821 return static_cast<COMPRESSION_ENABLE>(TheStructure.Common.DestinationCompressionEnable); 3822 } 3823 3824 inline void setDestinationTiling(const TILING value) { 3825 TheStructure.Common.DestinationTiling = value; 3826 } 3827 3828 inline TILING getDestinationTiling() const { 3829 return static_cast<TILING>(TheStructure.Common.DestinationTiling); 3830 } 3831 3832 inline void setDestinationX1CoordinateLeft(const uint32_t value) { 3833 TheStructure.Common.DestinationX1Coordinate_Left = value; 3834 } 3835 3836 inline uint32_t getDestinationX1CoordinateLeft() const { 3837 return (TheStructure.Common.DestinationX1Coordinate_Left); 3838 } 3839 3840 inline void setDestinationY1CoordinateTop(const uint32_t value) { 3841 TheStructure.Common.DestinationY1Coordinate_Top = value; 3842 } 3843 3844 inline uint32_t getDestinationY1CoordinateTop() const { 3845 return (TheStructure.Common.DestinationY1Coordinate_Top); 3846 } 3847 3848 inline void setDestinationX2CoordinateRight(const uint32_t value) { 3849 TheStructure.Common.DestinationX2Coordinate_Right = value; 3850 } 3851 3852 inline uint32_t getDestinationX2CoordinateRight() const { 3853 return (TheStructure.Common.DestinationX2Coordinate_Right); 3854 } 3855 3856 inline void setDestinationY2CoordinateBottom(const uint32_t value) { 3857 TheStructure.Common.DestinationY2Coordinate_Bottom = value; 3858 } 3859 3860 inline uint32_t getDestinationY2CoordinateBottom() const { 3861 return (TheStructure.Common.DestinationY2Coordinate_Bottom); 3862 } 3863 3864 inline void setDestinationBaseAddress(const uint64_t value) { 3865 TheStructure.Common.DestinationBaseAddress = value; 3866 } 3867 3868 inline uint64_t getDestinationBaseAddress() const { 3869 return (TheStructure.Common.DestinationBaseAddress); 3870 } 3871 3872 inline void setDestinationXoffset(const uint32_t value) { 3873 TheStructure.Common.DestinationXoffset = value; 3874 } 3875 3876 inline uint32_t getDestinationXoffset() const { 3877 return (TheStructure.Common.DestinationXoffset); 3878 } 3879 3880 inline void setDestinationYoffset(const uint32_t value) { 3881 TheStructure.Common.DestinationYoffset = value; 3882 } 3883 3884 inline uint32_t getDestinationYoffset() const { 3885 return (TheStructure.Common.DestinationYoffset); 3886 } 3887 3888 inline void setDestinationTargetMemory(const TARGET_MEMORY value) { 3889 TheStructure.Common.DestinationTargetMemory = value; 3890 } 3891 3892 inline TARGET_MEMORY getDestinationTargetMemory() const { 3893 return static_cast<TARGET_MEMORY>(TheStructure.Common.DestinationTargetMemory); 3894 } 3895 3896 inline void setSourceX1CoordinateLeft(const uint32_t value) { 3897 TheStructure.Common.SourceX1Coordinate_Left = value; 3898 } 3899 3900 inline uint32_t getSourceX1CoordinateLeft() const { 3901 return (TheStructure.Common.SourceX1Coordinate_Left); 3902 } 3903 3904 inline void setSourceY1CoordinateTop(const uint32_t value) { 3905 TheStructure.Common.SourceY1Coordinate_Top = value; 3906 } 3907 3908 inline uint32_t getSourceY1CoordinateTop() const { 3909 return (TheStructure.Common.SourceY1Coordinate_Top); 3910 } 3911 3912 inline void setSourcePitch(const uint32_t value) { 3913 TheStructure.Common.SourcePitch = value - 1; 3914 } 3915 3916 inline uint32_t getSourcePitch() const { 3917 return (TheStructure.Common.SourcePitch + 1); 3918 } 3919 3920 inline void setSourceAuxiliarysurfacemode(const AUXILIARY_SURFACE_MODE value) { 3921 TheStructure.Common.SourceAuxiliarysurfacemode = value; 3922 } 3923 3924 inline AUXILIARY_SURFACE_MODE getSourceAuxiliarysurfacemode() const { 3925 return static_cast<AUXILIARY_SURFACE_MODE>(TheStructure.Common.SourceAuxiliarysurfacemode); 3926 } 3927 3928 inline void setSourceMOCS(const uint32_t value) { 3929 TheStructure.Common.SourceMOCS = value; 3930 } 3931 3932 inline uint32_t getSourceMOCS() const { 3933 return (TheStructure.Common.SourceMOCS); 3934 } 3935 3936 inline void setSourceCompressionType(const COMPRESSION_TYPE value) { 3937 TheStructure.Common.SourceCompressionType = value; 3938 } 3939 3940 inline COMPRESSION_TYPE getSourceCompressionType() const { 3941 return static_cast<COMPRESSION_TYPE>(TheStructure.Common.SourceCompressionType); 3942 } 3943 3944 inline void setSourceCompressionEnable(const COMPRESSION_ENABLE value) { 3945 TheStructure.Common.SourceCompressionEnable = value; 3946 } 3947 3948 inline COMPRESSION_ENABLE getSourceCompressionEnable() const { 3949 return static_cast<COMPRESSION_ENABLE>(TheStructure.Common.SourceCompressionEnable); 3950 } 3951 3952 inline void setSourceTiling(const TILING value) { 3953 TheStructure.Common.SourceTiling = value; 3954 } 3955 3956 inline TILING getSourceTiling() const { 3957 return static_cast<TILING>(TheStructure.Common.SourceTiling); 3958 } 3959 3960 inline void setSourceBaseAddress(const uint64_t value) { 3961 TheStructure.Common.SourceBaseAddress = value; 3962 } 3963 3964 inline uint64_t getSourceBaseAddress() const { 3965 return (TheStructure.Common.SourceBaseAddress); 3966 } 3967 3968 inline void setSourceXoffset(const uint32_t value) { 3969 TheStructure.Common.SourceXoffset = value; 3970 } 3971 3972 inline uint32_t getSourceXoffset() const { 3973 return (TheStructure.Common.SourceXoffset); 3974 } 3975 3976 inline void setSourceYoffset(const uint32_t value) { 3977 TheStructure.Common.SourceYoffset = value; 3978 } 3979 3980 inline uint32_t getSourceYoffset() const { 3981 return (TheStructure.Common.SourceYoffset); 3982 } 3983 3984 inline void setSourceTargetMemory(const TARGET_MEMORY value) { 3985 TheStructure.Common.SourceTargetMemory = value; 3986 } 3987 3988 inline TARGET_MEMORY getSourceTargetMemory() const { 3989 return static_cast<TARGET_MEMORY>(TheStructure.Common.SourceTargetMemory); 3990 } 3991 3992 inline void setSourceCompressionFormat(const uint32_t value) { 3993 TheStructure.Common.SourceCompressionFormat = value; 3994 } 3995 3996 inline uint32_t getSourceCompressionFormat() const { 3997 return (TheStructure.Common.SourceCompressionFormat); 3998 } 3999 4000 inline void setSourceClearValueEnable(const CLEAR_VALUE_ENABLE value) { 4001 TheStructure.Common.SourceClearValueEnable = value; 4002 } 4003 4004 inline CLEAR_VALUE_ENABLE getSourceClearValueEnable() const { 4005 return static_cast<CLEAR_VALUE_ENABLE>(TheStructure.Common.SourceClearValueEnable); 4006 } 4007 4008 typedef enum tagCLEARADDRESSLOW { 4009 CLEARADDRESSLOW_BIT_SHIFT = 6, 4010 CLEARADDRESSLOW_ALIGN_SIZE = 64, 4011 } CLEARADDRESSLOW; 4012 4013 inline void setSourceClearAddressLow(const uint32_t value) { 4014 TheStructure.Common.SourceClearAddressLow = value >> CLEARADDRESSLOW_BIT_SHIFT; 4015 } 4016 4017 inline uint32_t getSourceClearAddressLow() const { 4018 return (TheStructure.Common.SourceClearAddressLow << CLEARADDRESSLOW_BIT_SHIFT); 4019 } 4020 4021 inline void setSourceClearAddressHigh(const uint32_t value) { 4022 TheStructure.Common.SourceClearAddressHigh = value; 4023 } 4024 4025 inline uint32_t getSourceClearAddressHigh() const { 4026 return (TheStructure.Common.SourceClearAddressHigh); 4027 } 4028 4029 inline void setDestinationCompressionFormat(const uint32_t value) { 4030 TheStructure.Common.DestinationCompressionFormat = value; 4031 } 4032 4033 inline uint32_t getDestinationCompressionFormat() const { 4034 return (TheStructure.Common.DestinationCompressionFormat); 4035 } 4036 4037 inline void setDestinationClearValueEnable(const CLEAR_VALUE_ENABLE value) { 4038 TheStructure.Common.DestinationClearValueEnable = value; 4039 } 4040 4041 inline CLEAR_VALUE_ENABLE getDestinationClearValueEnable() const { 4042 return static_cast<CLEAR_VALUE_ENABLE>(TheStructure.Common.DestinationClearValueEnable); 4043 } 4044 4045 inline void setDestinationClearAddressLow(const uint32_t value) { 4046 TheStructure.Common.DestinationClearAddressLow = value >> CLEARADDRESSLOW_BIT_SHIFT; 4047 } 4048 4049 inline uint32_t getDestinationClearAddressLow() const { 4050 return (TheStructure.Common.DestinationClearAddressLow << CLEARADDRESSLOW_BIT_SHIFT); 4051 } 4052 4053 inline void setDestinationClearAddressHigh(const uint32_t value) { 4054 TheStructure.Common.DestinationClearAddressHigh = value; 4055 } 4056 4057 inline uint32_t getDestinationClearAddressHigh() const { 4058 return (TheStructure.Common.DestinationClearAddressHigh); 4059 } 4060 4061 inline void setDestinationSurfaceHeight(const uint32_t value) { 4062 TheStructure.Common.DestinationSurfaceHeight = value - 1; 4063 } 4064 4065 inline uint32_t getDestinationSurfaceHeight() const { 4066 return (TheStructure.Common.DestinationSurfaceHeight + 1); 4067 } 4068 4069 inline void setDestinationSurfaceWidth(const uint32_t value) { 4070 TheStructure.Common.DestinationSurfaceWidth = value - 1; 4071 } 4072 4073 inline uint32_t getDestinationSurfaceWidth() const { 4074 return (TheStructure.Common.DestinationSurfaceWidth + 1); 4075 } 4076 4077 inline void setDestinationSurfaceType(const SURFACE_TYPE value) { 4078 TheStructure.Common.DestinationSurfaceType = value; 4079 } 4080 4081 inline SURFACE_TYPE getDestinationSurfaceType() const { 4082 return static_cast<SURFACE_TYPE>(TheStructure.Common.DestinationSurfaceType); 4083 } 4084 4085 inline void setDestinationLOD(const uint32_t value) { 4086 TheStructure.Common.DestinationLOD = value; 4087 } 4088 4089 inline uint32_t getDestinationLOD() const { 4090 return (TheStructure.Common.DestinationLOD); 4091 } 4092 4093 inline void setDestinationSurfaceQpitch(const uint32_t value) { 4094 TheStructure.Common.DestinationSurfaceQpitch = value; 4095 } 4096 4097 inline uint32_t getDestinationSurfaceQpitch() const { 4098 return (TheStructure.Common.DestinationSurfaceQpitch); 4099 } 4100 4101 inline void setDestinationSurfaceDepth(const uint32_t value) { 4102 TheStructure.Common.DestinationSurfaceDepth = value - 1; 4103 } 4104 4105 inline uint32_t getDestinationSurfaceDepth() const { 4106 return (TheStructure.Common.DestinationSurfaceDepth + 1); 4107 } 4108 4109 inline void setDestinationHorizontalAlign(const uint32_t value) { 4110 TheStructure.Common.DestinationHorizontalAlign = value; 4111 } 4112 4113 inline uint32_t getDestinationHorizontalAlign() const { 4114 return (TheStructure.Common.DestinationHorizontalAlign); 4115 } 4116 4117 inline void setDestinationVerticalAlign(const uint32_t value) { 4118 TheStructure.Common.DestinationVerticalAlign = value; 4119 } 4120 4121 inline uint32_t getDestinationVerticalAlign() const { 4122 return (TheStructure.Common.DestinationVerticalAlign); 4123 } 4124 4125 inline void setDestinationSSID(const uint32_t value) { 4126 TheStructure.Common.DestinationSSID = value; 4127 } 4128 4129 inline uint32_t getDestinationSSID() const { 4130 return (TheStructure.Common.DestinationSSID); 4131 } 4132 4133 inline void setDestinationMipTailStartLOD(const uint32_t value) { 4134 TheStructure.Common.DestinationMipTailStartLOD = value; 4135 } 4136 4137 inline uint32_t getDestinationMipTailStartLOD() const { 4138 return (TheStructure.Common.DestinationMipTailStartLOD); 4139 } 4140 4141 inline void setDestinationDepthStencilResource(const uint32_t value) { 4142 TheStructure.Common.DestinationDepthStencilResource = value; 4143 } 4144 4145 inline uint32_t getDestinationDepthStencilResource() const { 4146 return (TheStructure.Common.DestinationDepthStencilResource); 4147 } 4148 4149 inline void setDestinationArrayIndex(const uint32_t value) { 4150 TheStructure.Common.DestinationArrayIndex = value - 1; 4151 } 4152 4153 inline uint32_t getDestinationArrayIndex() const { 4154 return (TheStructure.Common.DestinationArrayIndex + 1); 4155 } 4156 4157 inline void setSourceSurfaceHeight(const uint32_t value) { 4158 TheStructure.Common.SourceSurfaceHeight = value - 1; 4159 } 4160 4161 inline uint32_t getSourceSurfaceHeight() const { 4162 return (TheStructure.Common.SourceSurfaceHeight + 1); 4163 } 4164 4165 inline void setSourceSurfaceWidth(const uint32_t value) { 4166 TheStructure.Common.SourceSurfaceWidth = value - 1; 4167 } 4168 4169 inline uint32_t getSourceSurfaceWidth() const { 4170 return (TheStructure.Common.SourceSurfaceWidth + 1); 4171 } 4172 4173 inline void setSourceSurfaceType(const SURFACE_TYPE value) { 4174 TheStructure.Common.SourceSurfaceType = value; 4175 } 4176 4177 inline SURFACE_TYPE getSourceSurfaceType() const { 4178 return static_cast<SURFACE_TYPE>(TheStructure.Common.SourceSurfaceType); 4179 } 4180 4181 inline void setSourceLOD(const uint32_t value) { 4182 TheStructure.Common.SourceLOD = value; 4183 } 4184 4185 inline uint32_t getSourceLOD() const { 4186 return (TheStructure.Common.SourceLOD); 4187 } 4188 4189 inline void setSourceSurfaceQpitch(const uint32_t value) { 4190 TheStructure.Common.SourceSurfaceQpitch = value; 4191 } 4192 4193 inline uint32_t getSourceSurfaceQpitch() const { 4194 return (TheStructure.Common.SourceSurfaceQpitch); 4195 } 4196 4197 inline void setSourceSurfaceDepth(const uint32_t value) { 4198 TheStructure.Common.SourceSurfaceDepth = value - 1; 4199 } 4200 4201 inline uint32_t getSourceSurfaceDepth() const { 4202 return (TheStructure.Common.SourceSurfaceDepth + 1); 4203 } 4204 4205 inline void setSourceHorizontalAlign(const uint32_t value) { 4206 TheStructure.Common.SourceHorizontalAlign = value; 4207 } 4208 4209 inline uint32_t getSourceHorizontalAlign() const { 4210 return (TheStructure.Common.SourceHorizontalAlign); 4211 } 4212 4213 inline void setSourceVerticalAlign(const uint32_t value) { 4214 TheStructure.Common.SourceVerticalAlign = value; 4215 } 4216 4217 inline uint32_t getSourceVerticalAlign() const { 4218 return (TheStructure.Common.SourceVerticalAlign); 4219 } 4220 4221 inline void setSourceSSID(const uint32_t value) { 4222 TheStructure.Common.SourceSSID = value; 4223 } 4224 4225 inline uint32_t getSourceSSID() const { 4226 return (TheStructure.Common.SourceSSID); 4227 } 4228 4229 inline void setSourceMipTailStartLOD(const uint32_t value) { 4230 TheStructure.Common.SourceMipTailStartLOD = value; 4231 } 4232 4233 inline uint32_t getSourceMipTailStartLOD() const { 4234 return (TheStructure.Common.SourceMipTailStartLOD); 4235 } 4236 4237 inline void setSourceDepthStencilResource(const uint32_t value) { 4238 TheStructure.Common.SourceDepthStencilResource = value; 4239 } 4240 4241 inline uint32_t getSourceDepthStencilResource() const { 4242 return (TheStructure.Common.SourceDepthStencilResource); 4243 } 4244 4245 inline void setSourceArrayIndex(const uint32_t value) { 4246 TheStructure.Common.SourceArrayIndex = value - 1; 4247 } 4248 4249 inline uint32_t getSourceArrayIndex() const { 4250 return (TheStructure.Common.SourceArrayIndex + 1); 4251 } 4252}; 4253STATIC_ASSERT(88 == sizeof(XY_BLOCK_COPY_BLT)); 4254 4255struct XY_FAST_COLOR_BLT { 4256 union tagTheStructure { 4257 struct tagCommon { 4258 /// DWORD 0 4259 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 4260 uint32_t Reserved_8 : BITFIELD_RANGE(8, 8); 4261 uint32_t NumberofMultisamples : BITFIELD_RANGE(9, 11); 4262 uint32_t SpecialModeofOperation : BITFIELD_RANGE(12, 13); 4263 uint32_t Reserved_14 : BITFIELD_RANGE(14, 18); 4264 uint32_t ColorDepth : BITFIELD_RANGE(19, 21); 4265 uint32_t InstructionTarget_Opcode : BITFIELD_RANGE(22, 28); 4266 uint32_t Client : BITFIELD_RANGE(29, 31); 4267 4268 /// DWORD 1 4269 uint32_t DestinationPitch : BITFIELD_RANGE(0, 17); 4270 uint32_t DestinationAuxiliarysurfacemode : BITFIELD_RANGE(18, 20); 4271 uint32_t DestinationMOCS : BITFIELD_RANGE(21, 27); 4272 uint32_t DestinationCompressionType : BITFIELD_RANGE(28, 28); 4273 uint32_t DestinationCompressionEnable : BITFIELD_RANGE(29, 29); 4274 uint32_t DestinationTiling : BITFIELD_RANGE(30, 31); 4275 4276 /// DWORD 2 4277 uint32_t DestinationX1Coordinate_Left : BITFIELD_RANGE(0, 15); 4278 uint32_t DestinationY1Coordinate_Top : BITFIELD_RANGE(16, 31); 4279 4280 /// DWORD 3 4281 uint32_t DestinationX2Coordinate_Right : BITFIELD_RANGE(0, 15); 4282 uint32_t DestinationY2Coordinate_Bottom : BITFIELD_RANGE(16, 31); 4283 4284 /// DWORD 4..5 4285 uint64_t DestinationBaseAddress; 4286 4287 /// DWORD 6 4288 uint32_t DestinationXoffset : BITFIELD_RANGE(0, 13); 4289 uint32_t Reserved_206 : BITFIELD_RANGE(14, 15); 4290 uint32_t DestinationYoffset : BITFIELD_RANGE(16, 29); 4291 uint32_t Reserved_222 : BITFIELD_RANGE(30, 30); 4292 uint32_t DestinationTargetMemory : BITFIELD_RANGE(31, 31); 4293 4294 /// DWORD 7 - 10 4295 uint32_t FillColor[4]; 4296 4297 // DWORD 11 4298 uint32_t DestinationCompressionFormat : BITFIELD_RANGE(0, 4); 4299 uint32_t DestinationClearValueEnable : BITFIELD_RANGE(5, 5); 4300 uint32_t DestinationClearAddressLow : BITFIELD_RANGE(6, 31); 4301 4302 // DWORD 12 4303 uint32_t DestinationClearAddressHigh : BITFIELD_RANGE(0, 15); 4304 uint32_t Reserved1 : BITFIELD_RANGE(16, 31); 4305 4306 // DWORD 13 4307 uint32_t DestinationSurfaceHeight : BITFIELD_RANGE(0, 13); 4308 uint32_t DestinationSurfaceWidth : BITFIELD_RANGE(14, 27); 4309 uint32_t Reserved2 : BITFIELD_RANGE(28, 28); 4310 uint32_t DestinationSurfaceType : BITFIELD_RANGE(29, 31); 4311 4312 // DWORD 14 4313 uint32_t DestinationLOD : BITFIELD_RANGE(0, 3); 4314 uint32_t DestinationSurfaceQpitch : BITFIELD_RANGE(4, 18); 4315 uint32_t Reserved3 : BITFIELD_RANGE(19, 20); 4316 uint32_t DestinationSurfaceDepth : BITFIELD_RANGE(21, 31); 4317 4318 // DWORD 15 4319 uint32_t DestinationHorizontalAlign : BITFIELD_RANGE(0, 1); 4320 uint32_t Reserved4 : BITFIELD_RANGE(2, 2); 4321 uint32_t DestinationVerticalAlign : BITFIELD_RANGE(3, 4); 4322 uint32_t Reserved5 : BITFIELD_RANGE(5, 7); 4323 uint32_t DestinationMipTailStartLOD : BITFIELD_RANGE(8, 11); 4324 uint32_t Reserved6 : BITFIELD_RANGE(12, 17); 4325 uint32_t DestinationDepthStencilResource : BITFIELD_RANGE(18, 18); 4326 uint32_t Reserved7 : BITFIELD_RANGE(19, 20); 4327 uint32_t DestinationArrayIndex : BITFIELD_RANGE(21, 31); 4328 } Common; 4329 uint32_t RawData[15]; 4330 } TheStructure; 4331 4332 enum DWORD_LENGTH { 4333 DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0xE, 4334 }; 4335 4336 enum NUMBER_OF_MULTISAMPLES { 4337 NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_1 = 0, 4338 NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_2 = 1, 4339 NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_4 = 2, 4340 NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_8 = 3, 4341 NUMBER_OF_MULTISAMPLES_MULTISAMPLECOUNT_16 = 4, 4342 }; 4343 4344 enum SPECIAL_MODE_OF_OPERATION { 4345 SPECIAL_MODE_OF_OPERATION_NONE = 0, 4346 SPECIAL_MODE_OF_OPERATION_FULL_RESOLVE = 1, 4347 SPECIAL_MODE_OF_OPERATION_PARTIAL_RESOLVE = 2, 4348 }; 4349 4350 enum COLOR_DEPTH { 4351 COLOR_DEPTH_8_BIT_COLOR = 0, 4352 COLOR_DEPTH_16_BIT_COLOR = 1, 4353 COLOR_DEPTH_32_BIT_COLOR = 2, 4354 COLOR_DEPTH_64_BIT_COLOR = 3, 4355 COLOR_DEPTH_96_BIT_COLOR_ONLY_LINEAR_CASE_IS_SUPPORTED = 4, 4356 COLOR_DEPTH_128_BIT_COLOR = 5, 4357 }; 4358 4359 enum CLIENT { 4360 CLIENT_2D_PROCESSOR = 2, 4361 }; 4362 4363 enum DESTINATION_AUXILIARY_SURFACE_MODE { 4364 DESTINATION_AUXILIARY_SURFACE_MODE_AUX_NONE = 0, 4365 DESTINATION_AUXILIARY_SURFACE_MODE_AUX_CCS_E = 5, 4366 }; 4367 4368 enum DESTINATION_CLEAR_VALUE_ENABLE { 4369 DESTINATION_CLEAR_VALUE_ENABLE_DISABLE = 0, 4370 DESTINATION_CLEAR_VALUE_ENABLE_ENABLE = 1, 4371 }; 4372 4373 enum DESTINATION_COMPRESSION_TYPE { 4374 DESTINATION_COMPRESSION_TYPE_3D_COMPRESSION = 0, 4375 DESTINATION_COMPRESSION_TYPE_MEDIA_COMPRESSION = 1, 4376 }; 4377 4378 enum DESTINATION_COMPRESSION_ENABLE { 4379 DESTINATION_COMPRESSION_ENABLE_COMPRESSION_DISABLE = 0, 4380 DESTINATION_COMPRESSION_ENABLE_COMPRESSION_ENABLE = 1, 4381 }; 4382 4383 enum DESTINATION_TILING { 4384 DESTINATION_TILING_LINEAR = 0, 4385 DESTINATION_TILING_TILE4 = 2, 4386 DESTINATION_TILING_TILE64 = 3, 4387 }; 4388 4389 enum DESTINATION_TARGET_MEMORY { 4390 DESTINATION_TARGET_MEMORY_LOCAL_MEM = 0, 4391 DESTINATION_TARGET_MEMORY_SYSTEM_MEM = 1, 4392 }; 4393 4394 enum DESTINATION_SURFACE_TYPE { 4395 DESTINATION_SURFACE_TYPE_1D = 0, 4396 DESTINATION_SURFACE_TYPE_2D = 1, 4397 DESTINATION_SURFACE_TYPE_3D = 2, 4398 DESTINATION_SURFACE_TYPE_CUBE = 3, 4399 }; 4400 enum INSTRUCTIONTARGET_OPCODE { 4401 INSTRUCTIONTARGET_OPCODE_OPCODE = 0x44, 4402 }; 4403 4404 inline void init() { 4405 memset(&TheStructure, 0, sizeof(TheStructure)); 4406 TheStructure.Common.DwordLength = DWORD_LENGTH::DWORD_LENGTH_EXCLUDES_DWORD_0_1; 4407 TheStructure.Common.InstructionTarget_Opcode = INSTRUCTIONTARGET_OPCODE::INSTRUCTIONTARGET_OPCODE_OPCODE; 4408 TheStructure.Common.Client = CLIENT::CLIENT_2D_PROCESSOR; 4409 } 4410 4411 static XY_FAST_COLOR_BLT sInit() { 4412 XY_FAST_COLOR_BLT state; 4413 state.init(); 4414 return state; 4415 } 4416 4417 inline uint32_t &getRawData(const uint32_t index) { 4418 UNRECOVERABLE_IF(index < 22); 4419 return TheStructure.RawData[index]; 4420 } 4421 4422 inline void setNumberofMultisamples(const NUMBER_OF_MULTISAMPLES value) { 4423 TheStructure.Common.NumberofMultisamples = value; 4424 } 4425 4426 inline NUMBER_OF_MULTISAMPLES getNumberofMultisamples() const { 4427 return static_cast<NUMBER_OF_MULTISAMPLES>(TheStructure.Common.NumberofMultisamples); 4428 } 4429 4430 inline void setSpecialModeofOperation(const SPECIAL_MODE_OF_OPERATION value) { 4431 TheStructure.Common.SpecialModeofOperation = value; 4432 } 4433 4434 inline SPECIAL_MODE_OF_OPERATION getSpecialModeofOperation() const { 4435 return static_cast<SPECIAL_MODE_OF_OPERATION>(TheStructure.Common.SpecialModeofOperation); 4436 } 4437 4438 inline void setColorDepth(const COLOR_DEPTH value) { 4439 TheStructure.Common.ColorDepth = value; 4440 } 4441 4442 inline COLOR_DEPTH getColorDepth() const { 4443 return static_cast<COLOR_DEPTH>(TheStructure.Common.ColorDepth); 4444 } 4445 4446 inline void setInstructionTargetOpcode(const uint32_t value) { 4447 TheStructure.Common.InstructionTarget_Opcode = value; 4448 } 4449 4450 inline uint32_t getInstructionTargetOpcode() const { 4451 return (TheStructure.Common.InstructionTarget_Opcode); 4452 } 4453 4454 inline void setClient(const CLIENT value) { 4455 TheStructure.Common.Client = value; 4456 } 4457 4458 inline CLIENT getClient() const { 4459 return static_cast<CLIENT>(TheStructure.Common.Client); 4460 } 4461 4462 inline void setDestinationPitch(const uint32_t value) { 4463 TheStructure.Common.DestinationPitch = value - 1; 4464 } 4465 4466 inline uint32_t getDestinationPitch() const { 4467 return (TheStructure.Common.DestinationPitch + 1); 4468 } 4469 4470 inline void setDestinationAuxiliarysurfacemode(const DESTINATION_AUXILIARY_SURFACE_MODE value) { 4471 TheStructure.Common.DestinationAuxiliarysurfacemode = value; 4472 } 4473 4474 inline DESTINATION_AUXILIARY_SURFACE_MODE getDestinationAuxiliarysurfacemode() const { 4475 return static_cast<DESTINATION_AUXILIARY_SURFACE_MODE>(TheStructure.Common.DestinationAuxiliarysurfacemode); 4476 } 4477 4478 inline void setDestinationMOCS(const uint32_t value) { 4479 TheStructure.Common.DestinationMOCS = value; 4480 } 4481 4482 inline uint32_t getDestinationMOCS() const { 4483 return (TheStructure.Common.DestinationMOCS); 4484 } 4485 4486 inline void setDestinationCompressionType(const DESTINATION_COMPRESSION_TYPE value) { 4487 TheStructure.Common.DestinationCompressionType = value; 4488 } 4489 4490 inline DESTINATION_COMPRESSION_TYPE getDestinationCompressionType() const { 4491 return static_cast<DESTINATION_COMPRESSION_TYPE>(TheStructure.Common.DestinationCompressionType); 4492 } 4493 4494 inline void setDestinationCompressionEnable(const DESTINATION_COMPRESSION_ENABLE value) { 4495 TheStructure.Common.DestinationCompressionEnable = value; 4496 } 4497 4498 inline DESTINATION_COMPRESSION_ENABLE getDestinationCompressionEnable() const { 4499 return static_cast<DESTINATION_COMPRESSION_ENABLE>(TheStructure.Common.DestinationCompressionEnable); 4500 } 4501 4502 inline void setDestinationTiling(const DESTINATION_TILING value) { 4503 TheStructure.Common.DestinationTiling = value; 4504 } 4505 4506 inline DESTINATION_TILING getDestinationTiling() const { 4507 return static_cast<DESTINATION_TILING>(TheStructure.Common.DestinationTiling); 4508 } 4509 4510 inline void setDestinationX1CoordinateLeft(const uint32_t value) { 4511 TheStructure.Common.DestinationX1Coordinate_Left = value; 4512 } 4513 4514 inline uint32_t getDestinationX1CoordinateLeft() const { 4515 return (TheStructure.Common.DestinationX1Coordinate_Left); 4516 } 4517 4518 inline void setDestinationY1CoordinateTop(const uint32_t value) { 4519 TheStructure.Common.DestinationY1Coordinate_Top = value; 4520 } 4521 4522 inline uint32_t getDestinationY1CoordinateTop() const { 4523 return (TheStructure.Common.DestinationY1Coordinate_Top); 4524 } 4525 4526 inline void setDestinationX2CoordinateRight(const uint32_t value) { 4527 TheStructure.Common.DestinationX2Coordinate_Right = value; 4528 } 4529 4530 inline uint32_t getDestinationX2CoordinateRight() const { 4531 return (TheStructure.Common.DestinationX2Coordinate_Right); 4532 } 4533 4534 inline void setDestinationY2CoordinateBottom(const uint32_t value) { 4535 TheStructure.Common.DestinationY2Coordinate_Bottom = value; 4536 } 4537 4538 inline uint32_t getDestinationY2CoordinateBottom() const { 4539 return (TheStructure.Common.DestinationY2Coordinate_Bottom); 4540 } 4541 4542 inline void setDestinationBaseAddress(const uint64_t value) { 4543 TheStructure.Common.DestinationBaseAddress = value; 4544 } 4545 4546 inline uint64_t getDestinationBaseAddress() const { 4547 return (TheStructure.Common.DestinationBaseAddress); 4548 } 4549 4550 inline void setDestinationXoffset(const uint32_t value) { 4551 TheStructure.Common.DestinationXoffset = value; 4552 } 4553 4554 inline uint32_t getDestinationXoffset() const { 4555 return (TheStructure.Common.DestinationXoffset); 4556 } 4557 4558 inline void setDestinationYoffset(const uint32_t value) { 4559 TheStructure.Common.DestinationYoffset = value; 4560 } 4561 4562 inline uint32_t getDestinationYoffset() const { 4563 return (TheStructure.Common.DestinationYoffset); 4564 } 4565 4566 inline void setDestinationTargetMemory(const DESTINATION_TARGET_MEMORY value) { 4567 TheStructure.Common.DestinationTargetMemory = value; 4568 } 4569 4570 inline DESTINATION_TARGET_MEMORY getDestinationTargetMemory() const { 4571 return static_cast<DESTINATION_TARGET_MEMORY>(TheStructure.Common.DestinationTargetMemory); 4572 } 4573 4574 inline void setFillColor(const uint32_t *value) { 4575 TheStructure.Common.FillColor[0] = value[0]; 4576 TheStructure.Common.FillColor[1] = value[1]; 4577 TheStructure.Common.FillColor[2] = value[2]; 4578 TheStructure.Common.FillColor[3] = value[3]; 4579 } 4580 4581 inline void setDestinationCompressionFormat(const uint32_t value) { 4582 TheStructure.Common.DestinationCompressionFormat = value; 4583 } 4584 4585 inline uint32_t getDestinationCompressionFormat() const { 4586 return (TheStructure.Common.DestinationCompressionFormat); 4587 } 4588 4589 inline void setDestinationClearValueEnable(const DESTINATION_CLEAR_VALUE_ENABLE value) { 4590 TheStructure.Common.DestinationClearValueEnable = value; 4591 } 4592 4593 inline DESTINATION_CLEAR_VALUE_ENABLE getDestinationClearValueEnable() const { 4594 return static_cast<DESTINATION_CLEAR_VALUE_ENABLE>(TheStructure.Common.DestinationClearValueEnable); 4595 } 4596 4597 typedef enum tagDESTINATIONCLEARADDRESSLOW { 4598 DESTINATIONCLEARADDRESSLOW_BIT_SHIFT = 6, 4599 DESTINATIONCLEARADDRESSLOW_ALIGN_SIZE = 64, 4600 } DESTINATIONCLEARADDRESSLOW; 4601 4602 inline void setDestinationClearAddressLow(const uint32_t value) { 4603 TheStructure.Common.DestinationClearAddressLow = value >> DESTINATIONCLEARADDRESSLOW_BIT_SHIFT; 4604 } 4605 4606 inline uint32_t getDestinationClearAddressLow() const { 4607 return (TheStructure.Common.DestinationClearAddressLow << DESTINATIONCLEARADDRESSLOW_BIT_SHIFT); 4608 } 4609 4610 inline void setDestinationClearAddressHigh(const uint32_t value) { 4611 TheStructure.Common.DestinationClearAddressHigh = value; 4612 } 4613 4614 inline uint32_t getDestinationClearAddressHigh() const { 4615 return (TheStructure.Common.DestinationClearAddressHigh); 4616 } 4617 4618 inline void setDestinationSurfaceHeight(const uint32_t value) { 4619 TheStructure.Common.DestinationSurfaceHeight = value - 1; 4620 } 4621 4622 inline uint32_t getDestinationSurfaceHeight() const { 4623 return (TheStructure.Common.DestinationSurfaceHeight + 1); 4624 } 4625 4626 inline void setDestinationSurfaceWidth(const uint32_t value) { 4627 TheStructure.Common.DestinationSurfaceWidth = value - 1; 4628 } 4629 4630 inline uint32_t getDestinationSurfaceWidth() const { 4631 return (TheStructure.Common.DestinationSurfaceWidth + 1); 4632 } 4633 4634 inline void setDestinationSurfaceType(const DESTINATION_SURFACE_TYPE value) { 4635 TheStructure.Common.DestinationSurfaceType = value; 4636 } 4637 4638 inline DESTINATION_SURFACE_TYPE getDestinationSurfaceType() const { 4639 return static_cast<DESTINATION_SURFACE_TYPE>(TheStructure.Common.DestinationSurfaceType); 4640 } 4641 4642 inline void setDestinationLOD(const uint32_t value) { 4643 TheStructure.Common.DestinationLOD = value; 4644 } 4645 4646 inline uint32_t getDestinationLOD() const { 4647 return (TheStructure.Common.DestinationLOD); 4648 } 4649 4650 inline void setDestinationSurfaceQpitch(const uint32_t value) { 4651 TheStructure.Common.DestinationSurfaceQpitch = value; 4652 } 4653 4654 inline uint32_t getDestinationSurfaceQpitch() const { 4655 return (TheStructure.Common.DestinationSurfaceQpitch); 4656 } 4657 4658 inline void setDestinationSurfaceDepth(const uint32_t value) { 4659 TheStructure.Common.DestinationSurfaceDepth = value; 4660 } 4661 4662 inline uint32_t getDestinationSurfaceDepth() const { 4663 return (TheStructure.Common.DestinationSurfaceDepth); 4664 } 4665 4666 inline void setDestinationHorizontalAlign(const uint32_t value) { 4667 TheStructure.Common.DestinationHorizontalAlign = value; 4668 } 4669 4670 inline uint32_t getDestinationHorizontalAlign() const { 4671 return (TheStructure.Common.DestinationHorizontalAlign); 4672 } 4673 4674 inline void setDestinationVerticalAlign(const uint32_t value) { 4675 TheStructure.Common.DestinationVerticalAlign = value; 4676 } 4677 4678 inline uint32_t getDestinationVerticalAlign() const { 4679 return (TheStructure.Common.DestinationVerticalAlign); 4680 } 4681 4682 inline void setDestinationMipTailStartLOD(const uint32_t value) { 4683 TheStructure.Common.DestinationMipTailStartLOD = value; 4684 } 4685 4686 inline uint32_t getDestinationMipTailStartLOD() const { 4687 return (TheStructure.Common.DestinationMipTailStartLOD); 4688 } 4689 4690 inline void setDestinationDepthStencilResource(const uint32_t value) { 4691 TheStructure.Common.DestinationDepthStencilResource = value; 4692 } 4693 4694 inline uint32_t getDestinationDepthStencilResource() const { 4695 return (TheStructure.Common.DestinationDepthStencilResource); 4696 } 4697 4698 inline void setDestinationArrayIndex(const uint32_t value) { 4699 TheStructure.Common.DestinationArrayIndex = value - 1; 4700 } 4701 4702 inline uint32_t getDestinationArrayIndex() const { 4703 return (TheStructure.Common.DestinationArrayIndex + 1); 4704 } 4705}; 4706 4707STATIC_ASSERT(64 == sizeof(XY_FAST_COLOR_BLT)); 4708 4709struct MI_FLUSH_DW { 4710 union tagData { 4711 struct tagCommon { 4712 /// DWORD 0 4713 uint32_t DwordLength : BITFIELD_RANGE(0, 5); 4714 uint32_t Reserved_6 : BITFIELD_RANGE(6, 7); 4715 uint32_t NotifyEnable : BITFIELD_RANGE(8, 8); 4716 uint32_t FlushLlc : BITFIELD_RANGE(9, 9); 4717 uint32_t Reserved_10 : BITFIELD_RANGE(10, 13); 4718 uint32_t PostSyncOperation : BITFIELD_RANGE(14, 15); 4719 uint32_t FlushCcs : BITFIELD_RANGE(16, 16); 4720 uint32_t Reserved_17 : BITFIELD_RANGE(17, 17); 4721 uint32_t TlbInvalidate : BITFIELD_RANGE(18, 18); 4722 uint32_t Reserved_19 : BITFIELD_RANGE(19, 20); 4723 uint32_t StoreDataIndex : BITFIELD_RANGE(21, 21); 4724 uint32_t Reserved_22 : BITFIELD_RANGE(22, 22); 4725 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 4726 uint32_t CommandType : BITFIELD_RANGE(29, 31); 4727 4728 /// DWORD 1..2 4729 uint64_t Reserved_32 : BITFIELD_RANGE(0, 1); 4730 uint64_t DestinationAddress : BITFIELD_RANGE(2, 47); 4731 uint64_t Reserved_80 : BITFIELD_RANGE(48, 63); 4732 4733 /// DWORD 3..4 4734 uint64_t ImmediateData; 4735 4736 } Common; 4737 uint32_t RawData[5]; 4738 } TheStructure; 4739 4740 enum DWORD_LENGTH { 4741 DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 3, 4742 }; 4743 4744 enum POST_SYNC_OPERATION { 4745 POST_SYNC_OPERATION_NO_WRITE = 0, 4746 POST_SYNC_OPERATION_WRITE_IMMEDIATE_DATA_QWORD = 1, 4747 POST_SYNC_OPERATION_WRITE_TIMESTAMP_REGISTER = 3, 4748 }; 4749 4750 enum MI_COMMAND_OPCODE { 4751 MI_COMMAND_OPCODE_MI_FLUSH_DW = 38, 4752 }; 4753 4754 enum COMMAND_TYPE { 4755 COMMAND_TYPE_MI_COMMAND = 0, 4756 }; 4757 4758 inline void init() { 4759 memset(&TheStructure, 0, sizeof(TheStructure)); 4760 TheStructure.Common.DwordLength = DWORD_LENGTH::DWORD_LENGTH_EXCLUDES_DWORD_0_1; 4761 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE::MI_COMMAND_OPCODE_MI_FLUSH_DW; 4762 } 4763 4764 static MI_FLUSH_DW sInit() { 4765 MI_FLUSH_DW state; 4766 state.init(); 4767 return state; 4768 } 4769 4770 inline uint32_t &getRawData(const uint32_t index) { 4771 UNRECOVERABLE_IF(index < 5); 4772 return TheStructure.RawData[index]; 4773 } 4774 4775 inline void setNotifyEnable(const uint32_t value) { 4776 TheStructure.Common.NotifyEnable = value; 4777 } 4778 4779 inline uint32_t getNotifyEnable() const { 4780 return (TheStructure.Common.NotifyEnable); 4781 } 4782 4783 inline void setFlushLlc(const uint32_t value) { 4784 TheStructure.Common.FlushLlc = value; 4785 } 4786 4787 inline uint32_t getFlushLlc() const { 4788 return (TheStructure.Common.FlushLlc); 4789 } 4790 4791 inline void setFlushCcs(const uint32_t value) { 4792 TheStructure.Common.FlushCcs = value; 4793 } 4794 4795 inline uint32_t getFlushCcs() const { 4796 return (TheStructure.Common.FlushCcs); 4797 } 4798 4799 inline void setPostSyncOperation(const POST_SYNC_OPERATION value) { 4800 TheStructure.Common.PostSyncOperation = value; 4801 } 4802 4803 inline POST_SYNC_OPERATION getPostSyncOperation() const { 4804 return static_cast<POST_SYNC_OPERATION>(TheStructure.Common.PostSyncOperation); 4805 } 4806 4807 inline void setTlbInvalidate(const uint32_t value) { 4808 TheStructure.Common.TlbInvalidate = value; 4809 } 4810 4811 inline uint32_t getTlbInvalidate() const { 4812 return (TheStructure.Common.TlbInvalidate); 4813 } 4814 4815 inline void setStoreDataIndex(const uint32_t value) { 4816 TheStructure.Common.StoreDataIndex = value; 4817 } 4818 4819 inline uint32_t getStoreDataIndex() const { 4820 return (TheStructure.Common.StoreDataIndex); 4821 } 4822 4823 typedef enum tagDESTINATIONADDRESS { 4824 DESTINATIONADDRESS_BIT_SHIFT = 2, 4825 DESTINATIONADDRESS_ALIGN_SIZE = 4, 4826 } DESTINATIONADDRESS; 4827 4828 inline void setDestinationAddress(const uint64_t value) { 4829 TheStructure.Common.DestinationAddress = value >> DESTINATIONADDRESS_BIT_SHIFT; 4830 } 4831 4832 inline uint64_t getDestinationAddress() const { 4833 return (TheStructure.Common.DestinationAddress << DESTINATIONADDRESS_BIT_SHIFT); 4834 } 4835 4836 inline void setImmediateData(const uint64_t value) { 4837 TheStructure.Common.ImmediateData = value; 4838 } 4839 4840 inline uint64_t getImmediateData() const { 4841 return (TheStructure.Common.ImmediateData); 4842 } 4843}; 4844STATIC_ASSERT(20 == sizeof(MI_FLUSH_DW)); 4845 4846typedef struct tag_3DSTATE_BTD_BODY { 4847 union tagTheStructure { 4848 struct tagCommon { 4849 // DWORD 0 4850 uint32_t DispatchTimeoutCounter : BITFIELD_RANGE(0, 1); 4851 uint32_t Reserved_2 : BITFIELD_RANGE(2, 2); 4852 uint32_t AmfsMode : BITFIELD_RANGE(3, 4); 4853 uint32_t Reserved_5 : BITFIELD_RANGE(5, 31); 4854 // DWORD 1 4855 uint64_t PerDssMemoryBackedBufferSize : BITFIELD_RANGE(0, 2); 4856 uint64_t Reserved_35 : BITFIELD_RANGE(3, 9); 4857 uint64_t MemoryBackedBufferBasePointer : BITFIELD_RANGE(10, 63); 4858 // DWORD 3 4859 uint64_t PerThreadScratchSpace : BITFIELD_RANGE(0, 3); 4860 uint64_t Reserved_100 : BITFIELD_RANGE(4, 9); 4861 uint64_t BtdScratchSpaceBasePointer : BITFIELD_RANGE(10, 31); 4862 // DWORD 4 4863 uint64_t Reserved_128 : BITFIELD_RANGE(32, 63); 4864 } Common; 4865 uint32_t RawData[5]; 4866 } TheStructure; 4867 typedef enum tagAMFS_MODE { 4868 AMFS_MODE_NORMAL_MODE = 0x0, 4869 AMFS_MODE_TOUCH_MODE = 0x1, 4870 AMFS_MODE_BACKFILL_MODE = 0x2, 4871 AMFS_MODE_FALLBACK_MODE = 0x3, 4872 } AMFS_MODE; 4873 typedef enum tagPER_DSS_MEMORY_BACKED_BUFFER_SIZE { 4874 PER_DSS_MEMORY_BACKED_BUFFER_SIZE_2KB = 0x0, 4875 PER_DSS_MEMORY_BACKED_BUFFER_SIZE_4KB = 0x1, 4876 PER_DSS_MEMORY_BACKED_BUFFER_SIZE_8KB = 0x2, 4877 PER_DSS_MEMORY_BACKED_BUFFER_SIZE_16KB = 0x3, 4878 PER_DSS_MEMORY_BACKED_BUFFER_SIZE_32KB = 0x4, 4879 PER_DSS_MEMORY_BACKED_BUFFER_SIZE_64KB = 0x5, 4880 PER_DSS_MEMORY_BACKED_BUFFER_SIZE_128KB = 0x6, 4881 } PER_DSS_MEMORY_BACKED_BUFFER_SIZE; 4882 inline void init() { 4883 memset(&TheStructure, 0, sizeof(TheStructure)); 4884 TheStructure.Common.AmfsMode = AMFS_MODE_NORMAL_MODE; 4885 TheStructure.Common.PerDssMemoryBackedBufferSize = PER_DSS_MEMORY_BACKED_BUFFER_SIZE_128KB; 4886 } 4887 static tag_3DSTATE_BTD_BODY sInit() { 4888 _3DSTATE_BTD_BODY state; 4889 state.init(); 4890 return state; 4891 } 4892 inline uint32_t &getRawData(const uint32_t index) { 4893 UNRECOVERABLE_IF(index >= 5); 4894 return TheStructure.RawData[index]; 4895 } 4896 inline void setDispatchTimeoutCounter(const uint32_t value) { 4897 UNRECOVERABLE_IF(value > 0x3); 4898 TheStructure.Common.DispatchTimeoutCounter = value; 4899 } 4900 inline uint32_t getDispatchTimeoutCounter() const { 4901 return TheStructure.Common.DispatchTimeoutCounter; 4902 } 4903 inline void setAmfsMode(const AMFS_MODE value) { 4904 TheStructure.Common.AmfsMode = value; 4905 } 4906 inline AMFS_MODE getAmfsMode() const { 4907 return static_cast<AMFS_MODE>(TheStructure.Common.AmfsMode); 4908 } 4909 inline void setPerDssMemoryBackedBufferSize(const PER_DSS_MEMORY_BACKED_BUFFER_SIZE value) { 4910 TheStructure.Common.PerDssMemoryBackedBufferSize = value; 4911 } 4912 inline PER_DSS_MEMORY_BACKED_BUFFER_SIZE getPerDssMemoryBackedBufferSize() const { 4913 return static_cast<PER_DSS_MEMORY_BACKED_BUFFER_SIZE>(TheStructure.Common.PerDssMemoryBackedBufferSize); 4914 } 4915 typedef enum tagMEMORYBACKEDBUFFERBASEPOINTER { 4916 MEMORYBACKEDBUFFERBASEPOINTER_BIT_SHIFT = 0xa, 4917 MEMORYBACKEDBUFFERBASEPOINTER_ALIGN_SIZE = 0x400, 4918 } MEMORYBACKEDBUFFERBASEPOINTER; 4919 inline void setMemoryBackedBufferBasePointer(const uint64_t value) { 4920 UNRECOVERABLE_IF(value > 0xffffffffffffffffL); 4921 TheStructure.Common.MemoryBackedBufferBasePointer = value >> MEMORYBACKEDBUFFERBASEPOINTER_BIT_SHIFT; 4922 } 4923 inline uint64_t getMemoryBackedBufferBasePointer() const { 4924 return TheStructure.Common.MemoryBackedBufferBasePointer << MEMORYBACKEDBUFFERBASEPOINTER_BIT_SHIFT; 4925 } 4926 inline void setPerThreadScratchSpace(const uint64_t value) { 4927 UNRECOVERABLE_IF(value > 0xfL); 4928 TheStructure.Common.PerThreadScratchSpace = value; 4929 } 4930 inline uint64_t getPerThreadScratchSpace() const { 4931 return TheStructure.Common.PerThreadScratchSpace; 4932 } 4933 typedef enum tagBTDSCRATCHSPACEBASEPOINTER { 4934 BTDSCRATCHSPACEBASEPOINTER_BIT_SHIFT = 0xa, 4935 BTDSCRATCHSPACEBASEPOINTER_ALIGN_SIZE = 0x400, 4936 } BTDSCRATCHSPACEBASEPOINTER; 4937 inline void setBtdScratchSpaceBasePointer(const uint64_t value) { 4938 UNRECOVERABLE_IF(value > 0xffffffffL); 4939 TheStructure.Common.BtdScratchSpaceBasePointer = value >> BTDSCRATCHSPACEBASEPOINTER_BIT_SHIFT; 4940 } 4941 inline uint64_t getBtdScratchSpaceBasePointer() const { 4942 return TheStructure.Common.BtdScratchSpaceBasePointer << BTDSCRATCHSPACEBASEPOINTER_BIT_SHIFT; 4943 } 4944} _3DSTATE_BTD_BODY; 4945STATIC_ASSERT(20 == sizeof(_3DSTATE_BTD_BODY)); 4946 4947typedef struct tag_3DSTATE_BTD { 4948 union tagTheStructure { 4949 struct tagCommon { 4950 // DWORD 0 4951 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 4952 uint32_t Reserved_8 : BITFIELD_RANGE(8, 15); 4953 uint32_t _3DCommandSubOpcode : BITFIELD_RANGE(16, 23); 4954 uint32_t _3DCommandOpcode : BITFIELD_RANGE(24, 26); 4955 uint32_t CommandSubtype : BITFIELD_RANGE(27, 28); 4956 uint32_t CommandType : BITFIELD_RANGE(29, 31); 4957 // DWORD 1 4958 _3DSTATE_BTD_BODY BtdStateBody; 4959 } Common; 4960 uint32_t RawData[6]; 4961 } TheStructure; 4962 typedef enum tagDWORD_LENGTH { 4963 DWORD_LENGTH_DWORD_COUNT_N = 0x4, 4964 } DWORD_LENGTH; 4965 typedef enum tag_3D_COMMAND_SUB_OPCODE { 4966 _3D_COMMAND_SUB_OPCODE_3DSTATE_BTD = 0x6, 4967 } _3D_COMMAND_SUB_OPCODE; 4968 typedef enum tag_3D_COMMAND_OPCODE { 4969 _3D_COMMAND_OPCODE_GFXPIPE_NONPIPELINED = 0x1, 4970 } _3D_COMMAND_OPCODE; 4971 typedef enum tagCOMMAND_SUBTYPE { 4972 COMMAND_SUBTYPE_GFXPIPE_COMMON = 0x0, 4973 } COMMAND_SUBTYPE; 4974 typedef enum tagCOMMAND_TYPE { 4975 COMMAND_TYPE_GFXPIPE = 0x3, 4976 } COMMAND_TYPE; 4977 inline void init() { 4978 memset(&TheStructure, 0, sizeof(TheStructure)); 4979 TheStructure.Common.DwordLength = DWORD_LENGTH_DWORD_COUNT_N; 4980 TheStructure.Common._3DCommandSubOpcode = _3D_COMMAND_SUB_OPCODE_3DSTATE_BTD; 4981 TheStructure.Common._3DCommandOpcode = _3D_COMMAND_OPCODE_GFXPIPE_NONPIPELINED; 4982 TheStructure.Common.CommandSubtype = COMMAND_SUBTYPE_GFXPIPE_COMMON; 4983 TheStructure.Common.CommandType = COMMAND_TYPE_GFXPIPE; 4984 TheStructure.Common.BtdStateBody.init(); 4985 } 4986 static tag_3DSTATE_BTD sInit() { 4987 _3DSTATE_BTD state; 4988 state.init(); 4989 return state; 4990 } 4991 inline uint32_t &getRawData(const uint32_t index) { 4992 UNRECOVERABLE_IF(index >= 6); 4993 return TheStructure.RawData[index]; 4994 } 4995 inline void setBtdStateBody(const _3DSTATE_BTD_BODY &value) { 4996 TheStructure.Common.BtdStateBody = value; 4997 } 4998 inline _3DSTATE_BTD_BODY &getBtdStateBody() { 4999 return TheStructure.Common.BtdStateBody; 5000 } 5001} _3DSTATE_BTD; 5002STATIC_ASSERT(24 == sizeof(_3DSTATE_BTD)); 5003STATIC_ASSERT(std::is_pod<_3DSTATE_BTD>::value); 5004 5005typedef struct tagGRF { 5006 union tagTheStructure { 5007 float fRegs[8]; 5008 uint32_t dwRegs[8]; 5009 uint16_t wRegs[16]; 5010 uint32_t RawData[8]; 5011 } TheStructure; 5012} GRF; 5013STATIC_ASSERT(32 == sizeof(GRF)); 5014 5015typedef struct tagPOSTSYNC_DATA { 5016 union tagTheStructure { 5017 struct tagCommon { 5018 // DWORD 0 5019 uint32_t Operation : BITFIELD_RANGE(0, 1); 5020 uint32_t DataportPipelineFlush : BITFIELD_RANGE(2, 2); 5021 uint32_t Reserved_3 : BITFIELD_RANGE(3, 3); 5022 uint32_t MocsReserved_4 : BITFIELD_RANGE(4, 4); 5023 uint32_t MocsIndexToMocsTables : BITFIELD_RANGE(5, 10); 5024 uint32_t Reserved_13 : BITFIELD_RANGE(11, 31); 5025 // DWORD 1 5026 uint64_t DestinationAddress; 5027 // DWORD 3 5028 uint64_t ImmediateData; 5029 } Common; 5030 uint32_t RawData[5]; 5031 } TheStructure; 5032 typedef enum tagOPERATION { 5033 OPERATION_NO_WRITE = 0x0, 5034 OPERATION_WRITE_IMMEDIATE_DATA = 0x1, 5035 OPERATION_WRITE_TIMESTAMP = 0x3, 5036 } OPERATION; 5037 inline void init() { 5038 memset(&TheStructure, 0, sizeof(TheStructure)); 5039 TheStructure.Common.Operation = OPERATION_NO_WRITE; 5040 } 5041 static tagPOSTSYNC_DATA sInit() { 5042 POSTSYNC_DATA state; 5043 state.init(); 5044 return state; 5045 } 5046 inline uint32_t &getRawData(const uint32_t index) { 5047 UNRECOVERABLE_IF(index >= 5); 5048 return TheStructure.RawData[index]; 5049 } 5050 inline void setOperation(const OPERATION value) { 5051 TheStructure.Common.Operation = value; 5052 } 5053 inline OPERATION getOperation() const { 5054 return static_cast<OPERATION>(TheStructure.Common.Operation); 5055 } 5056 inline void setDataportPipelineFlush(const bool value) { 5057 TheStructure.Common.DataportPipelineFlush = value; 5058 } 5059 inline bool getDataportPipelineFlush() const { 5060 return TheStructure.Common.DataportPipelineFlush; 5061 } 5062 inline void setMocs(const uint32_t value) { // patched 5063 UNRECOVERABLE_IF(value > 0x7f); 5064 TheStructure.Common.MocsReserved_4 = value; 5065 TheStructure.Common.MocsIndexToMocsTables = value >> 1; 5066 } 5067 inline uint32_t getMocs() const { // patched 5068 return (TheStructure.Common.MocsIndexToMocsTables << 1) | TheStructure.Common.MocsReserved_4; 5069 } 5070 inline void setDestinationAddress(const uint64_t value) { 5071 TheStructure.Common.DestinationAddress = value; 5072 } 5073 inline uint64_t getDestinationAddress() const { 5074 return TheStructure.Common.DestinationAddress; 5075 } 5076 inline void setImmediateData(const uint64_t value) { 5077 TheStructure.Common.ImmediateData = value; 5078 } 5079 inline uint64_t getImmediateData() const { 5080 return TheStructure.Common.ImmediateData; 5081 } 5082} POSTSYNC_DATA; 5083STATIC_ASSERT(20 == sizeof(POSTSYNC_DATA)); 5084 5085typedef struct tagINTERFACE_DESCRIPTOR_DATA { 5086 union tagTheStructure { 5087 struct tagCommon { 5088 uint32_t Reserved_0_0_5 : BITFIELD_RANGE(0, 5); 5089 uint32_t KernelStartPointer : BITFIELD_RANGE(6, 31); 5090 5091 uint32_t KernelStartPointerHigh : BITFIELD_RANGE(0, 15); 5092 uint32_t Reserved_1_16_31 : BITFIELD_RANGE(16, 31); 5093 5094 uint32_t Reserved_2_0_6 : BITFIELD_RANGE(0, 6); 5095 uint32_t SoftwareExceptionEnable : BITFIELD_RANGE(7, 7); 5096 uint32_t Reserved_2_8_10 : BITFIELD_RANGE(8, 10); 5097 uint32_t MaskStackExceptionEnable : BITFIELD_RANGE(11, 11); 5098 uint32_t Reserved_2_12_12 : BITFIELD_RANGE(12, 12); 5099 uint32_t IllegalOpcodeExceptionEnable : BITFIELD_RANGE(13, 13); 5100 uint32_t Reserved_2_14_15 : BITFIELD_RANGE(14, 15); 5101 uint32_t FloatingPointMode : BITFIELD_RANGE(16, 16); 5102 uint32_t Reserved_2_17_17 : BITFIELD_RANGE(17, 17); 5103 uint32_t SingleProgramFlow : BITFIELD_RANGE(18, 18); 5104 uint32_t DenormMode : BITFIELD_RANGE(19, 19); 5105 uint32_t ThreadPreemptionDisable : BITFIELD_RANGE(20, 20); 5106 uint32_t Reserved_2_21_31 : BITFIELD_RANGE(21, 31); 5107 5108 uint32_t Reserved_3_0_1 : BITFIELD_RANGE(0, 1); 5109 uint32_t SamplerCount : BITFIELD_RANGE(2, 4); 5110 uint32_t SamplerStatePointer : BITFIELD_RANGE(5, 31); 5111 5112 uint32_t BindingTableEntryCount : BITFIELD_RANGE(0, 4); 5113 uint32_t BindingTablePointer : BITFIELD_RANGE(5, 20); 5114 uint32_t Reserved_4_21_31 : BITFIELD_RANGE(21, 31); 5115 5116 uint32_t NumberOfThreadsInGpgpuThreadGroup : BITFIELD_RANGE(0, 9); 5117 uint32_t Reserved_5_10_15 : BITFIELD_RANGE(10, 15); 5118 uint32_t SharedLocalMemorySize : BITFIELD_RANGE(16, 20); 5119 uint32_t BarrierEnable : BITFIELD_RANGE(21, 21); 5120 uint32_t RoundingMode : BITFIELD_RANGE(22, 23); 5121 uint32_t Reserved_5_24_25 : BITFIELD_RANGE(24, 25); 5122 uint32_t ThreadGroupDispatchSize : BITFIELD_RANGE(26, 27); 5123 uint32_t Reserved_5_28_31 : BITFIELD_RANGE(28, 31); 5124 5125 uint32_t Reserved_6_0_31 : BITFIELD_RANGE(0, 31); 5126 5127 uint32_t Reserved_7; 5128 } Common; 5129 uint32_t RawData[8]; 5130 } TheStructure; 5131 typedef enum tagFLOATING_POINT_MODE { 5132 FLOATING_POINT_MODE_IEEE_754 = 0x0, 5133 FLOATING_POINT_MODE_ALTERNATE = 0x1, 5134 } FLOATING_POINT_MODE; 5135 typedef enum tagSINGLE_PROGRAM_FLOW { 5136 SINGLE_PROGRAM_FLOW_MULTIPLE = 0x0, 5137 SINGLE_PROGRAM_FLOW_SINGLE = 0x1, 5138 } SINGLE_PROGRAM_FLOW; 5139 typedef enum tagDENORM_MODE { 5140 DENORM_MODE_FTZ = 0x0, 5141 DENORM_MODE_SETBYKERNEL = 0x1, 5142 } DENORM_MODE; 5143 typedef enum tagTHREAD_PREEMPTION_DISABLE { 5144 THREAD_PREEMPTION_DISABLE_DISABLE = 0x0, 5145 THREAD_PREEMPTION_DISABLE_ENABLE = 0x1, 5146 } THREAD_PREEMPTION_DISABLE; 5147 typedef enum tagSAMPLER_COUNT { 5148 SAMPLER_COUNT_NO_SAMPLERS_USED = 0x0, 5149 SAMPLER_COUNT_BETWEEN_1_AND_4_SAMPLERS_USED = 0x1, 5150 SAMPLER_COUNT_BETWEEN_5_AND_8_SAMPLERS_USED = 0x2, 5151 SAMPLER_COUNT_BETWEEN_9_AND_12_SAMPLERS_USED = 0x3, 5152 SAMPLER_COUNT_BETWEEN_13_AND_16_SAMPLERS_USED = 0x4, 5153 } SAMPLER_COUNT; 5154 typedef enum tagSHARED_LOCAL_MEMORY_SIZE { 5155 SHARED_LOCAL_MEMORY_SIZE_ENCODES_0K = 0x0, 5156 SHARED_LOCAL_MEMORY_SIZE_ENCODES_1K = 0x1, 5157 SHARED_LOCAL_MEMORY_SIZE_ENCODES_2K = 0x2, 5158 SHARED_LOCAL_MEMORY_SIZE_ENCODES_4K = 0x3, 5159 SHARED_LOCAL_MEMORY_SIZE_ENCODES_8K = 0x4, 5160 SHARED_LOCAL_MEMORY_SIZE_ENCODES_16K = 0x5, 5161 SHARED_LOCAL_MEMORY_SIZE_ENCODES_32K = 0x6, 5162 SHARED_LOCAL_MEMORY_SIZE_ENCODES_64K = 0x7, 5163 } SHARED_LOCAL_MEMORY_SIZE; 5164 typedef enum tagROUNDING_MODE { 5165 ROUNDING_MODE_RTNE = 0x0, 5166 ROUNDING_MODE_RU = 0x1, 5167 ROUNDING_MODE_RD = 0x2, 5168 ROUNDING_MODE_RTZ = 0x3, 5169 } ROUNDING_MODE; 5170 5171 inline void init() { 5172 memset(&TheStructure, 0, sizeof(TheStructure)); 5173 TheStructure.Common.FloatingPointMode = FLOATING_POINT_MODE_IEEE_754; 5174 TheStructure.Common.SingleProgramFlow = SINGLE_PROGRAM_FLOW_MULTIPLE; 5175 TheStructure.Common.DenormMode = DENORM_MODE_FTZ; 5176 TheStructure.Common.ThreadPreemptionDisable = 5177 THREAD_PREEMPTION_DISABLE_DISABLE; 5178 TheStructure.Common.SamplerCount = SAMPLER_COUNT_NO_SAMPLERS_USED; 5179 TheStructure.Common.SharedLocalMemorySize = 5180 SHARED_LOCAL_MEMORY_SIZE_ENCODES_0K; 5181 TheStructure.Common.RoundingMode = ROUNDING_MODE_RTNE; 5182 } 5183 static tagINTERFACE_DESCRIPTOR_DATA sInit() { 5184 INTERFACE_DESCRIPTOR_DATA state; 5185 state.init(); 5186 return state; 5187 } 5188 inline uint32_t &getRawData(const uint32_t index) { 5189 DEBUG_BREAK_IF(index >= 8); 5190 return TheStructure.RawData[index]; 5191 } 5192 typedef enum tagKERNELSTARTPOINTER { 5193 KERNELSTARTPOINTER_BIT_SHIFT = 0x6, 5194 KERNELSTARTPOINTER_ALIGN_SIZE = 0x40, 5195 } KERNELSTARTPOINTER; 5196 inline void setKernelStartPointer(const uint64_t value) { 5197 DEBUG_BREAK_IF(value >= 0x100000000); 5198 TheStructure.Common.KernelStartPointer = (uint32_t)value >> KERNELSTARTPOINTER_BIT_SHIFT; 5199 } 5200 inline uint32_t getKernelStartPointer() const { 5201 return (TheStructure.Common.KernelStartPointer << KERNELSTARTPOINTER_BIT_SHIFT); 5202 } 5203 inline void setKernelStartPointerHigh(const uint32_t value) { 5204 TheStructure.Common.KernelStartPointerHigh = value; 5205 } 5206 inline uint32_t getKernelStartPointerHigh() const { 5207 return (TheStructure.Common.KernelStartPointerHigh); 5208 } 5209 inline void setSoftwareExceptionEnable(const uint32_t value) { 5210 TheStructure.Common.SoftwareExceptionEnable = value; 5211 } 5212 inline uint32_t getSoftwareExceptionEnable() const { 5213 return (TheStructure.Common.SoftwareExceptionEnable); 5214 } 5215 inline void setMaskStackExceptionEnable(const uint32_t value) { 5216 TheStructure.Common.MaskStackExceptionEnable = value; 5217 } 5218 inline uint32_t getMaskStackExceptionEnable() const { 5219 return (TheStructure.Common.MaskStackExceptionEnable); 5220 } 5221 inline void setIllegalOpcodeExceptionEnable(const uint32_t value) { 5222 TheStructure.Common.IllegalOpcodeExceptionEnable = value; 5223 } 5224 inline uint32_t getIllegalOpcodeExceptionEnable() const { 5225 return (TheStructure.Common.IllegalOpcodeExceptionEnable); 5226 } 5227 inline void setFloatingPointMode(const FLOATING_POINT_MODE value) { 5228 TheStructure.Common.FloatingPointMode = value; 5229 } 5230 inline FLOATING_POINT_MODE getFloatingPointMode() const { 5231 return static_cast<FLOATING_POINT_MODE>(TheStructure.Common.FloatingPointMode); 5232 } 5233 inline void setSingleProgramFlow(const SINGLE_PROGRAM_FLOW value) { 5234 TheStructure.Common.SingleProgramFlow = value; 5235 } 5236 inline SINGLE_PROGRAM_FLOW getSingleProgramFlow() const { 5237 return static_cast<SINGLE_PROGRAM_FLOW>(TheStructure.Common.SingleProgramFlow); 5238 } 5239 inline void setDenormMode(const DENORM_MODE value) { 5240 TheStructure.Common.DenormMode = value; 5241 } 5242 inline DENORM_MODE getDenormMode() const { 5243 return static_cast<DENORM_MODE>(TheStructure.Common.DenormMode); 5244 } 5245 inline void setThreadPreemptionDisable(const THREAD_PREEMPTION_DISABLE value) { 5246 TheStructure.Common.ThreadPreemptionDisable = value; 5247 } 5248 inline THREAD_PREEMPTION_DISABLE getThreadPreemptionDisable() const { 5249 return static_cast<THREAD_PREEMPTION_DISABLE>(TheStructure.Common.ThreadPreemptionDisable); 5250 } 5251 inline void setSamplerCount(const SAMPLER_COUNT value) { 5252 TheStructure.Common.SamplerCount = value; 5253 } 5254 inline SAMPLER_COUNT getSamplerCount() const { 5255 return static_cast<SAMPLER_COUNT>(TheStructure.Common.SamplerCount); 5256 } 5257 typedef enum tagSAMPLERSTATEPOINTER { 5258 SAMPLERSTATEPOINTER_BIT_SHIFT = 0x5, 5259 SAMPLERSTATEPOINTER_ALIGN_SIZE = 0x20, 5260 } SAMPLERSTATEPOINTER; 5261 inline void setSamplerStatePointer(const uint64_t value) { 5262 DEBUG_BREAK_IF(value >= 0x100000000); 5263 TheStructure.Common.SamplerStatePointer = (uint32_t)value >> SAMPLERSTATEPOINTER_BIT_SHIFT; 5264 } 5265 inline uint32_t getSamplerStatePointer() const { 5266 return (TheStructure.Common.SamplerStatePointer << SAMPLERSTATEPOINTER_BIT_SHIFT); 5267 } 5268 inline void setBindingTableEntryCount(const uint32_t value) { 5269 TheStructure.Common.BindingTableEntryCount = value; 5270 } 5271 inline uint32_t getBindingTableEntryCount() const { 5272 return (TheStructure.Common.BindingTableEntryCount); 5273 } 5274 typedef enum tagBINDINGTABLEPOINTER { 5275 BINDINGTABLEPOINTER_BIT_SHIFT = 0x5, 5276 BINDINGTABLEPOINTER_ALIGN_SIZE = 0x20, 5277 } BINDINGTABLEPOINTER; 5278 inline void setBindingTablePointer(const uint64_t value) { 5279 DEBUG_BREAK_IF(value >= 0x100000000); 5280 TheStructure.Common.BindingTablePointer = (uint32_t)value >> BINDINGTABLEPOINTER_BIT_SHIFT; 5281 } 5282 inline uint32_t getBindingTablePointer() const { 5283 return (TheStructure.Common.BindingTablePointer << BINDINGTABLEPOINTER_BIT_SHIFT); 5284 } 5285 inline void setNumberOfThreadsInGpgpuThreadGroup(const uint32_t value) { 5286 TheStructure.Common.NumberOfThreadsInGpgpuThreadGroup = value; 5287 } 5288 inline uint32_t getNumberOfThreadsInGpgpuThreadGroup() const { 5289 return (TheStructure.Common.NumberOfThreadsInGpgpuThreadGroup); 5290 } 5291 inline void setSharedLocalMemorySize(const SHARED_LOCAL_MEMORY_SIZE value) { 5292 TheStructure.Common.SharedLocalMemorySize = value; 5293 } 5294 inline SHARED_LOCAL_MEMORY_SIZE getSharedLocalMemorySize() const { 5295 return static_cast<SHARED_LOCAL_MEMORY_SIZE>(TheStructure.Common.SharedLocalMemorySize); 5296 } 5297 inline void setBarrierEnable(const uint32_t value) { 5298 TheStructure.Common.BarrierEnable = (value > 0u) ? 1u : 0u; 5299 } 5300 inline bool getBarrierEnable() const { 5301 return (TheStructure.Common.BarrierEnable); 5302 } 5303 inline void setRoundingMode(const ROUNDING_MODE value) { 5304 TheStructure.Common.RoundingMode = value; 5305 } 5306 inline ROUNDING_MODE getRoundingMode() const { 5307 return static_cast<ROUNDING_MODE>(TheStructure.Common.RoundingMode); 5308 } 5309 inline void setThreadGroupDispatchSize(const uint32_t value) { 5310 TheStructure.Common.ThreadGroupDispatchSize = value; 5311 } 5312 inline uint32_t getThreadGroupDispatchSize() const { 5313 return (TheStructure.Common.ThreadGroupDispatchSize); 5314 } 5315} INTERFACE_DESCRIPTOR_DATA; 5316STATIC_ASSERT(32 == sizeof(INTERFACE_DESCRIPTOR_DATA)); 5317 5318typedef struct tagINLINE_DATA { 5319 uint32_t RawData[8]; 5320} INLINE_DATA; 5321STATIC_ASSERT(32 == sizeof(INLINE_DATA)); 5322 5323typedef struct tagCOMPUTE_WALKER { 5324 union tagTheStructure { 5325 struct tagCommon { 5326 // DWORD 0 5327 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 5328 uint32_t PredicateEnable : BITFIELD_RANGE(8, 8); 5329 uint32_t WorkloadPartitionEnable : BITFIELD_RANGE(9, 9); 5330 uint32_t IndirectParameterEnable : BITFIELD_RANGE(10, 10); 5331 uint32_t UavWaitToProduce : BITFIELD_RANGE(11, 11); 5332 uint32_t UavProducer : BITFIELD_RANGE(12, 12); 5333 uint32_t UavConsumer : BITFIELD_RANGE(13, 13); 5334 uint32_t SystolicModeEnable : BITFIELD_RANGE(14, 14); 5335 uint32_t Reserved_15 : BITFIELD_RANGE(15, 15); 5336 uint32_t CfeSubopcodeVariant : BITFIELD_RANGE(16, 17); 5337 uint32_t CfeSubopcode : BITFIELD_RANGE(18, 23); 5338 uint32_t ComputeCommandOpcode : BITFIELD_RANGE(24, 26); 5339 uint32_t Pipeline : BITFIELD_RANGE(27, 28); 5340 uint32_t CommandType : BITFIELD_RANGE(29, 31); 5341 // DWORD 1 5342 uint32_t Reserved_32 : BITFIELD_RANGE(0, 7); 5343 uint32_t Reserved_40 : BITFIELD_RANGE(8, 31); 5344 // DWORD 2 5345 uint32_t IndirectDataLength : BITFIELD_RANGE(0, 16); 5346 uint32_t Reserved_82 : BITFIELD_RANGE(17, 29); 5347 uint32_t PartitionType : BITFIELD_RANGE(30, 31); 5348 // DWORD 3 5349 uint32_t Reserved_96 : BITFIELD_RANGE(0, 5); 5350 uint32_t IndirectDataStartAddress : BITFIELD_RANGE(6, 31); 5351 // DWORD 4 5352 uint32_t Reserved_128 : BITFIELD_RANGE(0, 16); 5353 uint32_t MessageSimd : BITFIELD_RANGE(17, 18); 5354 uint32_t TileLayout : BITFIELD_RANGE(19, 21); 5355 uint32_t WalkOrder : BITFIELD_RANGE(22, 24); 5356 uint32_t EmitInlineParameter : BITFIELD_RANGE(25, 25); 5357 uint32_t EmitLocalId : BITFIELD_RANGE(26, 28); 5358 uint32_t GenerateLocalId : BITFIELD_RANGE(29, 29); 5359 uint32_t SimdSize : BITFIELD_RANGE(30, 31); 5360 // DWORD 5 5361 uint32_t ExecutionMask; 5362 // DWORD 6 5363 uint32_t LocalXMaximum : BITFIELD_RANGE(0, 9); 5364 uint32_t LocalYMaximum : BITFIELD_RANGE(10, 19); 5365 uint32_t LocalZMaximum : BITFIELD_RANGE(20, 29); 5366 uint32_t Reserved_222 : BITFIELD_RANGE(30, 31); 5367 // DWORD 7 5368 uint32_t ThreadGroupIdXDimension; 5369 // DWORD 8 5370 uint32_t ThreadGroupIdYDimension; 5371 // DWORD 9 5372 uint32_t ThreadGroupIdZDimension; 5373 // DWORD 10 5374 uint32_t ThreadGroupIdStartingX; 5375 // DWORD 11 5376 uint32_t ThreadGroupIdStartingY; 5377 // DWORD 12 5378 uint32_t ThreadGroupIdStartingZ; 5379 // DWORD 13 5380 uint64_t PartitionId : BITFIELD_RANGE(0, 31); 5381 // DWORD 14 5382 uint64_t PartitionSize : BITFIELD_RANGE(32, 63); 5383 // DWORD 15 5384 uint32_t PreemptX; 5385 // DWORD 16 5386 uint32_t PreemptY; 5387 // DWORD 17 5388 uint32_t PreemptZ; 5389 // DWORD 18 5390 INTERFACE_DESCRIPTOR_DATA InterfaceDescriptor; 5391 // DWORD 26 5392 POSTSYNC_DATA PostSync; 5393 // DWORD 31 5394 INLINE_DATA InlineData; 5395 } Common; 5396 uint32_t RawData[31]; 5397 } TheStructure; 5398 typedef enum tagDWORD_LENGTH { 5399 DWORD_LENGTH_FIXED_SIZE = 0x25, 5400 } DWORD_LENGTH; 5401 typedef enum tagCFE_SUBOPCODE_VARIANT { 5402 CFE_SUBOPCODE_VARIANT_STANDARD = 0x0, 5403 } CFE_SUBOPCODE_VARIANT; 5404 typedef enum tagCFE_SUBOPCODE { 5405 CFE_SUBOPCODE_COMPUTE_WALKER = 0x2, 5406 } CFE_SUBOPCODE; 5407 typedef enum tagCOMPUTE_COMMAND_OPCODE { 5408 COMPUTE_COMMAND_OPCODE_NEW_CFE_COMMAND = 0x2, 5409 } COMPUTE_COMMAND_OPCODE; 5410 typedef enum tagPIPELINE { 5411 PIPELINE_COMPUTE = 0x2, 5412 } PIPELINE; 5413 typedef enum tagCOMMAND_TYPE { 5414 COMMAND_TYPE_GFXPIPE = 0x3, 5415 } COMMAND_TYPE; 5416 typedef enum tagPARTITION_TYPE { 5417 PARTITION_TYPE_DISABLED = 0x0, 5418 PARTITION_TYPE_X = 0x1, 5419 PARTITION_TYPE_Y = 0x2, 5420 PARTITION_TYPE_Z = 0x3, 5421 } PARTITION_TYPE; 5422 typedef enum tagSIMD_SIZE { 5423 SIMD_SIZE_SIMD8 = 0x0, 5424 SIMD_SIZE_SIMD16 = 0x1, 5425 SIMD_SIZE_SIMD32 = 0x2, 5426 } SIMD_SIZE; 5427 typedef enum tagPARTITION_ID { 5428 PARTITION_ID_SUPPORTED_MIN = 0x0, 5429 PARTITION_ID_SUPPORTED_MAX = 0xf, 5430 } PARTITION_ID; 5431 inline void init() { 5432 memset(&TheStructure, 0, sizeof(TheStructure)); 5433 TheStructure.Common.DwordLength = DWORD_LENGTH_FIXED_SIZE; 5434 TheStructure.Common.CfeSubopcodeVariant = CFE_SUBOPCODE_VARIANT_STANDARD; 5435 TheStructure.Common.CfeSubopcode = CFE_SUBOPCODE_COMPUTE_WALKER; 5436 TheStructure.Common.ComputeCommandOpcode = COMPUTE_COMMAND_OPCODE_NEW_CFE_COMMAND; 5437 TheStructure.Common.Pipeline = PIPELINE_COMPUTE; 5438 TheStructure.Common.CommandType = COMMAND_TYPE_GFXPIPE; 5439 TheStructure.Common.PartitionType = PARTITION_TYPE_DISABLED; 5440 TheStructure.Common.SimdSize = SIMD_SIZE_SIMD8; 5441 TheStructure.Common.InterfaceDescriptor.init(); 5442 TheStructure.Common.PostSync.init(); 5443 } 5444 static tagCOMPUTE_WALKER sInit() { 5445 COMPUTE_WALKER state; 5446 state.init(); 5447 return state; 5448 } 5449 inline uint32_t &getRawData(const uint32_t index) { 5450 UNRECOVERABLE_IF(index >= 39); 5451 return TheStructure.RawData[index]; 5452 } 5453 inline void setDwordLength(const DWORD_LENGTH value) { 5454 TheStructure.Common.DwordLength = value; 5455 } 5456 inline DWORD_LENGTH getDwordLength() const { 5457 return static_cast<DWORD_LENGTH>(TheStructure.Common.DwordLength); 5458 } 5459 inline void setPredicateEnable(const bool value) { 5460 TheStructure.Common.PredicateEnable = value; 5461 } 5462 inline bool getPredicateEnable() const { 5463 return TheStructure.Common.PredicateEnable; 5464 } 5465 inline void setWorkloadPartitionEnable(const bool value) { 5466 TheStructure.Common.WorkloadPartitionEnable = value; 5467 } 5468 inline bool getWorkloadPartitionEnable() const { 5469 return TheStructure.Common.WorkloadPartitionEnable; 5470 } 5471 inline void setIndirectParameterEnable(const bool value) { 5472 TheStructure.Common.IndirectParameterEnable = value; 5473 } 5474 inline bool getIndirectParameterEnable() const { 5475 return TheStructure.Common.IndirectParameterEnable; 5476 } 5477 inline void setUavWaitToProduce(const bool value) { 5478 TheStructure.Common.UavWaitToProduce = value; 5479 } 5480 inline bool getUavWaitToProduce() const { 5481 return TheStructure.Common.UavWaitToProduce; 5482 } 5483 inline void setUavProducer(const bool value) { 5484 TheStructure.Common.UavProducer = value; 5485 } 5486 inline bool getUavProducer() const { 5487 return TheStructure.Common.UavProducer; 5488 } 5489 inline void setUavConsumer(const bool value) { 5490 TheStructure.Common.UavConsumer = value; 5491 } 5492 inline bool getUavConsumer() const { 5493 return TheStructure.Common.UavConsumer; 5494 } 5495 inline void setSystolicModeEnable(const bool value) { 5496 TheStructure.Common.SystolicModeEnable = value; 5497 } 5498 inline bool getSystolicModeEnable() const { 5499 return TheStructure.Common.SystolicModeEnable; 5500 } 5501 inline void setCfeSubopcodeVariant(const CFE_SUBOPCODE_VARIANT value) { 5502 TheStructure.Common.CfeSubopcodeVariant = value; 5503 } 5504 inline CFE_SUBOPCODE_VARIANT getCfeSubopcodeVariant() const { 5505 return static_cast<CFE_SUBOPCODE_VARIANT>(TheStructure.Common.CfeSubopcodeVariant); 5506 } 5507 inline void setCfeSubopcode(const CFE_SUBOPCODE value) { 5508 TheStructure.Common.CfeSubopcode = value; 5509 } 5510 inline CFE_SUBOPCODE getCfeSubopcode() const { 5511 return static_cast<CFE_SUBOPCODE>(TheStructure.Common.CfeSubopcode); 5512 } 5513 inline void setComputeCommandOpcode(const COMPUTE_COMMAND_OPCODE value) { 5514 TheStructure.Common.ComputeCommandOpcode = value; 5515 } 5516 inline COMPUTE_COMMAND_OPCODE getComputeCommandOpcode() const { 5517 return static_cast<COMPUTE_COMMAND_OPCODE>(TheStructure.Common.ComputeCommandOpcode); 5518 } 5519 inline void setIndirectDataLength(const uint32_t value) { 5520 UNRECOVERABLE_IF(value > 0x1ffff); 5521 TheStructure.Common.IndirectDataLength = value; 5522 } 5523 inline uint32_t getIndirectDataLength() const { 5524 return TheStructure.Common.IndirectDataLength; 5525 } 5526 inline void setPartitionType(const PARTITION_TYPE value) { 5527 TheStructure.Common.PartitionType = value; 5528 } 5529 inline PARTITION_TYPE getPartitionType() const { 5530 return static_cast<PARTITION_TYPE>(TheStructure.Common.PartitionType); 5531 } 5532 typedef enum tagINDIRECTDATASTARTADDRESS { 5533 INDIRECTDATASTARTADDRESS_BIT_SHIFT = 0x6, 5534 INDIRECTDATASTARTADDRESS_ALIGN_SIZE = 0x40, 5535 } INDIRECTDATASTARTADDRESS; 5536 inline void setIndirectDataStartAddress(const uint32_t value) { 5537 UNRECOVERABLE_IF(value > 0xffffffc0); 5538 TheStructure.Common.IndirectDataStartAddress = value >> INDIRECTDATASTARTADDRESS_BIT_SHIFT; 5539 } 5540 inline uint32_t getIndirectDataStartAddress() const { 5541 return TheStructure.Common.IndirectDataStartAddress << INDIRECTDATASTARTADDRESS_BIT_SHIFT; 5542 } 5543 inline void setMessageSimd(const uint32_t value) { 5544 TheStructure.Common.MessageSimd = value; 5545 } 5546 inline uint32_t getMessageSimd() const { 5547 return (TheStructure.Common.MessageSimd); 5548 } 5549 inline void setTileLayout(const uint32_t value) { 5550 TheStructure.Common.TileLayout = value; 5551 } 5552 inline uint32_t getTileLayout() const { 5553 return (TheStructure.Common.TileLayout); 5554 } 5555 inline void setWalkOrder(const uint32_t value) { 5556 TheStructure.Common.WalkOrder = value; 5557 } 5558 inline uint32_t getWalkOrder() const { 5559 return (TheStructure.Common.WalkOrder); 5560 } 5561 inline void setEmitInlineParameter(const uint32_t value) { 5562 TheStructure.Common.EmitInlineParameter = value; 5563 } 5564 inline uint32_t getEmitInlineParameter() const { 5565 return (TheStructure.Common.EmitInlineParameter); 5566 } 5567 inline void setEmitLocalId(const uint32_t value) { 5568 TheStructure.Common.EmitLocalId = value; 5569 } 5570 inline uint32_t getEmitLocalId() const { 5571 return (TheStructure.Common.EmitLocalId); 5572 } 5573 inline void setGenerateLocalId(const uint32_t value) { 5574 TheStructure.Common.GenerateLocalId = value; 5575 } 5576 inline uint32_t getGenerateLocalId() const { 5577 return (TheStructure.Common.GenerateLocalId); 5578 } 5579 inline void setSimdSize(const SIMD_SIZE value) { 5580 TheStructure.Common.SimdSize = value; 5581 } 5582 inline SIMD_SIZE getSimdSize() const { 5583 return static_cast<SIMD_SIZE>(TheStructure.Common.SimdSize); 5584 } 5585 inline void setExecutionMask(const uint32_t value) { 5586 TheStructure.Common.ExecutionMask = value; 5587 } 5588 inline uint32_t getExecutionMask() const { 5589 return TheStructure.Common.ExecutionMask; 5590 } 5591 inline void setLocalXMaximum(const uint32_t value) { 5592 TheStructure.Common.LocalXMaximum = value; 5593 } 5594 inline uint32_t getLocalXMaximum() const { 5595 return (TheStructure.Common.LocalXMaximum); 5596 } 5597 inline void setLocalYMaximum(const uint32_t value) { 5598 TheStructure.Common.LocalYMaximum = value; 5599 } 5600 inline uint32_t getLocalYMaximum() const { 5601 return (TheStructure.Common.LocalYMaximum); 5602 } 5603 inline void setLocalZMaximum(const uint32_t value) { 5604 TheStructure.Common.LocalZMaximum = value; 5605 } 5606 inline uint32_t getLocalZMaximum() const { 5607 return (TheStructure.Common.LocalZMaximum); 5608 } 5609 inline void setThreadGroupIdXDimension(const uint32_t value) { 5610 TheStructure.Common.ThreadGroupIdXDimension = value; 5611 } 5612 inline uint32_t getThreadGroupIdXDimension() const { 5613 return TheStructure.Common.ThreadGroupIdXDimension; 5614 } 5615 inline void setThreadGroupIdYDimension(const uint32_t value) { 5616 TheStructure.Common.ThreadGroupIdYDimension = value; 5617 } 5618 inline uint32_t getThreadGroupIdYDimension() const { 5619 return TheStructure.Common.ThreadGroupIdYDimension; 5620 } 5621 inline void setThreadGroupIdZDimension(const uint32_t value) { 5622 TheStructure.Common.ThreadGroupIdZDimension = value; 5623 } 5624 inline uint32_t getThreadGroupIdZDimension() const { 5625 return TheStructure.Common.ThreadGroupIdZDimension; 5626 } 5627 inline void setThreadGroupIdStartingX(const uint32_t value) { 5628 TheStructure.Common.ThreadGroupIdStartingX = value; 5629 } 5630 inline uint32_t getThreadGroupIdStartingX() const { 5631 return TheStructure.Common.ThreadGroupIdStartingX; 5632 } 5633 inline void setThreadGroupIdStartingY(const uint32_t value) { 5634 TheStructure.Common.ThreadGroupIdStartingY = value; 5635 } 5636 inline uint32_t getThreadGroupIdStartingY() const { 5637 return TheStructure.Common.ThreadGroupIdStartingY; 5638 } 5639 inline void setThreadGroupIdStartingZ(const uint32_t value) { 5640 TheStructure.Common.ThreadGroupIdStartingZ = value; 5641 } 5642 inline uint32_t getThreadGroupIdStartingZ() const { 5643 return TheStructure.Common.ThreadGroupIdStartingZ; 5644 } 5645 inline void setPartitionId(const uint64_t value) { 5646 TheStructure.Common.PartitionId = value; 5647 } 5648 inline uint64_t getPartitionId() const { 5649 return TheStructure.Common.PartitionId; 5650 } 5651 inline void setPartitionSize(const uint64_t value) { 5652 TheStructure.Common.PartitionSize = value; 5653 } 5654 inline uint64_t getPartitionSize() const { 5655 return TheStructure.Common.PartitionSize; 5656 } 5657 inline void setPreemptX(const uint32_t value) { 5658 TheStructure.Common.PreemptX = value; 5659 } 5660 inline uint32_t getPreemptX() const { 5661 return TheStructure.Common.PreemptX; 5662 } 5663 inline void setPreemptY(const uint32_t value) { 5664 TheStructure.Common.PreemptY = value; 5665 } 5666 inline uint32_t getPreemptY() const { 5667 return TheStructure.Common.PreemptY; 5668 } 5669 inline void setPreemptZ(const uint32_t value) { 5670 TheStructure.Common.PreemptZ = value; 5671 } 5672 inline uint32_t getPreemptZ() const { 5673 return TheStructure.Common.PreemptZ; 5674 } 5675 inline void setInterfaceDescriptor(const INTERFACE_DESCRIPTOR_DATA &value) { 5676 TheStructure.Common.InterfaceDescriptor = value; 5677 } 5678 inline INTERFACE_DESCRIPTOR_DATA &getInterfaceDescriptor() { 5679 return TheStructure.Common.InterfaceDescriptor; 5680 } 5681 inline void setPostSync(const POSTSYNC_DATA &value) { 5682 TheStructure.Common.PostSync = value; 5683 } 5684 inline POSTSYNC_DATA &getPostSync() { 5685 return TheStructure.Common.PostSync; 5686 } 5687 inline uint32_t *getInlineDataPointer() { 5688 return reinterpret_cast<uint32_t *>(&TheStructure.Common.InlineData); 5689 } 5690} COMPUTE_WALKER; 5691STATIC_ASSERT(156 == sizeof(COMPUTE_WALKER)); 5692 5693typedef struct tagCFE_STATE { 5694 union tagTheStructure { 5695 struct tagCommon { 5696 // DWORD 0 5697 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 5698 uint32_t Reserved_8 : BITFIELD_RANGE(8, 15); 5699 uint32_t CfeSubopcodeVariant : BITFIELD_RANGE(16, 17); 5700 uint32_t CfeSubopcode : BITFIELD_RANGE(18, 23); 5701 uint32_t ComputeCommandOpcode : BITFIELD_RANGE(24, 26); 5702 uint32_t Pipeline : BITFIELD_RANGE(27, 28); 5703 uint32_t CommandType : BITFIELD_RANGE(29, 31); 5704 // DWORD 1 5705 uint64_t Reserved_32 : BITFIELD_RANGE(0, 7); 5706 uint64_t Reserved_40 : BITFIELD_RANGE(8, 9); 5707 uint64_t ScratchSpaceBuffer : BITFIELD_RANGE(10, 31); 5708 // DWORD 2 5709 uint64_t Reserved_64 : BITFIELD_RANGE(32, 63); 5710 // DWORD 3 5711 uint32_t Reserved_96 : BITFIELD_RANGE(0, 2); 5712 uint32_t NumberOfWalkers : BITFIELD_RANGE(3, 5); 5713 uint32_t FusedEuDispatch : BITFIELD_RANGE(6, 6); 5714 uint32_t Reserved_103 : BITFIELD_RANGE(7, 9); 5715 uint32_t LargeGRFThreadAdjustDisable : BITFIELD_RANGE(10, 10); 5716 uint32_t ComputeOverdispatchDisable : BITFIELD_RANGE(11, 11); 5717 uint32_t WeightedDispatchModeDisable : BITFIELD_RANGE(12, 12); 5718 uint32_t SingleSliceDispatchCcsMode : BITFIELD_RANGE(13, 13); 5719 uint32_t OverDispatchControl : BITFIELD_RANGE(14, 15); 5720 uint32_t MaximumNumberOfThreads : BITFIELD_RANGE(16, 31); 5721 // DWORD 4 5722 uint32_t Reserved_128; 5723 // DWORD 5 5724 uint32_t Reserved_160 : BITFIELD_RANGE(0, 0); 5725 uint32_t Reserved_161 : BITFIELD_RANGE(1, 10); 5726 uint32_t Reserved_171 : BITFIELD_RANGE(11, 31); 5727 } Common; 5728 uint32_t RawData[6]; 5729 } TheStructure; 5730 typedef enum tagDWORD_LENGTH { 5731 DWORD_LENGTH_DWORD_COUNT_N = 0x4, 5732 } DWORD_LENGTH; 5733 typedef enum tagCFE_SUBOPCODE_VARIANT { 5734 CFE_SUBOPCODE_VARIANT_STANDARD = 0x0, 5735 } CFE_SUBOPCODE_VARIANT; 5736 typedef enum tagCFE_SUBOPCODE { 5737 CFE_SUBOPCODE_CFE_STATE = 0x0, 5738 } CFE_SUBOPCODE; 5739 typedef enum tagCOMPUTE_COMMAND_OPCODE { 5740 COMPUTE_COMMAND_OPCODE_NEW_CFE_COMMAND = 0x2, 5741 } COMPUTE_COMMAND_OPCODE; 5742 typedef enum tagPIPELINE { 5743 PIPELINE_COMPUTE = 0x2, 5744 } PIPELINE; 5745 typedef enum tagCOMMAND_TYPE { 5746 COMMAND_TYPE_GFXPIPE = 0x3, 5747 } COMMAND_TYPE; 5748 typedef enum tagOVER_DISPATCH_CONTROL { 5749 OVER_DISPATCH_CONTROL_NONE = 0x0, 5750 OVER_DISPATCH_CONTROL_LOW = 0x1, 5751 OVER_DISPATCH_CONTROL_NORMAL = 0x2, 5752 OVER_DISPATCH_CONTROL_HIGH = 0x3, 5753 } OVER_DISPATCH_CONTROL; 5754 inline void init() { 5755 memset(&TheStructure, 0, sizeof(TheStructure)); 5756 TheStructure.Common.DwordLength = DWORD_LENGTH_DWORD_COUNT_N; 5757 TheStructure.Common.CfeSubopcodeVariant = CFE_SUBOPCODE_VARIANT_STANDARD; 5758 TheStructure.Common.CfeSubopcode = CFE_SUBOPCODE_CFE_STATE; 5759 TheStructure.Common.ComputeCommandOpcode = COMPUTE_COMMAND_OPCODE_NEW_CFE_COMMAND; 5760 TheStructure.Common.Pipeline = PIPELINE_COMPUTE; 5761 TheStructure.Common.CommandType = COMMAND_TYPE_GFXPIPE; 5762 TheStructure.Common.OverDispatchControl = OVER_DISPATCH_CONTROL_NORMAL; 5763 } 5764 static tagCFE_STATE sInit() { 5765 CFE_STATE state; 5766 state.init(); 5767 return state; 5768 } 5769 inline uint32_t &getRawData(const uint32_t index) { 5770 UNRECOVERABLE_IF(index >= 6); 5771 return TheStructure.RawData[index]; 5772 } 5773 inline void setCfeSubopcodeVariant(const CFE_SUBOPCODE_VARIANT value) { 5774 TheStructure.Common.CfeSubopcodeVariant = value; 5775 } 5776 inline CFE_SUBOPCODE_VARIANT getCfeSubopcodeVariant() const { 5777 return static_cast<CFE_SUBOPCODE_VARIANT>(TheStructure.Common.CfeSubopcodeVariant); 5778 } 5779 inline void setCfeSubopcode(const CFE_SUBOPCODE value) { 5780 TheStructure.Common.CfeSubopcode = value; 5781 } 5782 inline CFE_SUBOPCODE getCfeSubopcode() const { 5783 return static_cast<CFE_SUBOPCODE>(TheStructure.Common.CfeSubopcode); 5784 } 5785 inline void setComputeCommandOpcode(const COMPUTE_COMMAND_OPCODE value) { 5786 TheStructure.Common.ComputeCommandOpcode = value; 5787 } 5788 inline COMPUTE_COMMAND_OPCODE getComputeCommandOpcode() const { 5789 return static_cast<COMPUTE_COMMAND_OPCODE>(TheStructure.Common.ComputeCommandOpcode); 5790 } 5791 typedef enum tagSCRATCHSPACEBUFFER { 5792 SCRATCHSPACEBUFFER_BIT_SHIFT = 0x6, 5793 SCRATCHSPACEBUFFER_ALIGN_SIZE = 0x40, 5794 } SCRATCHSPACEBUFFER; 5795 inline void setScratchSpaceBuffer(const uint64_t value) { 5796 UNRECOVERABLE_IF(value > 0xfffffc00L); 5797 TheStructure.Common.ScratchSpaceBuffer = static_cast<uint32_t>(value) >> SCRATCHSPACEBUFFER_BIT_SHIFT; 5798 } 5799 inline uint64_t getScratchSpaceBuffer() const { 5800 return TheStructure.Common.ScratchSpaceBuffer << SCRATCHSPACEBUFFER_BIT_SHIFT; 5801 } 5802 inline void setNumberOfWalkers(const uint32_t value) { 5803 UNRECOVERABLE_IF(value > 0x38); 5804 TheStructure.Common.NumberOfWalkers = value - 1; 5805 } 5806 inline uint32_t getNumberOfWalkers() const { 5807 return TheStructure.Common.NumberOfWalkers + 1; 5808 } 5809 inline void setFusedEuDispatch(const bool value) { 5810 TheStructure.Common.FusedEuDispatch = value; 5811 } 5812 inline bool getFusedEuDispatch() const { 5813 return TheStructure.Common.FusedEuDispatch; 5814 } 5815 inline void setLargeGRFThreadAdjustDisable(const bool value) { 5816 TheStructure.Common.LargeGRFThreadAdjustDisable = value; 5817 } 5818 inline bool getLargeGRFThreadAdjustDisable() const { 5819 return TheStructure.Common.LargeGRFThreadAdjustDisable; 5820 } 5821 inline void setComputeOverdispatchDisable(const bool value) { 5822 TheStructure.Common.ComputeOverdispatchDisable = value; 5823 } 5824 inline bool getComputeOverdispatchDisable() const { 5825 return TheStructure.Common.ComputeOverdispatchDisable; 5826 } 5827 inline void setWeightedDispatchModeDisable(const bool value) { 5828 TheStructure.Common.WeightedDispatchModeDisable = value; 5829 } 5830 inline bool getWeightedDispatchModeDisable() const { 5831 return TheStructure.Common.WeightedDispatchModeDisable; 5832 } 5833 inline void setSingleSliceDispatchCcsMode(const bool value) { 5834 TheStructure.Common.SingleSliceDispatchCcsMode = value; 5835 } 5836 inline bool getSingleSliceDispatchCcsMode() const { 5837 return TheStructure.Common.SingleSliceDispatchCcsMode; 5838 } 5839 inline void setOverDispatchControl(const OVER_DISPATCH_CONTROL value) { 5840 TheStructure.Common.OverDispatchControl = value; 5841 } 5842 inline OVER_DISPATCH_CONTROL getOverDispatchControl() const { 5843 return static_cast<OVER_DISPATCH_CONTROL>(TheStructure.Common.OverDispatchControl); 5844 } 5845 inline void setMaximumNumberOfThreads(const uint32_t value) { 5846 UNRECOVERABLE_IF(value > 0xffff0000); 5847 TheStructure.Common.MaximumNumberOfThreads = value; 5848 } 5849 inline uint32_t getMaximumNumberOfThreads() const { 5850 return TheStructure.Common.MaximumNumberOfThreads; 5851 } 5852} CFE_STATE; 5853STATIC_ASSERT(24 == sizeof(CFE_STATE)); 5854 5855typedef struct tagMI_ARB_CHECK { 5856 union tagTheStructure { 5857 struct tagCommon { 5858 uint32_t Pre_FetchDisable : BITFIELD_RANGE(0, 0); 5859 uint32_t Reserved_1 : BITFIELD_RANGE(1, 7); 5860 uint32_t MaskBits : BITFIELD_RANGE(8, 15); 5861 uint32_t Reserved_16 : BITFIELD_RANGE(16, 22); 5862 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 5863 uint32_t CommandType : BITFIELD_RANGE(29, 31); 5864 } Common; 5865 uint32_t RawData[1]; 5866 } TheStructure; 5867 typedef enum tagMI_COMMAND_OPCODE { 5868 MI_COMMAND_OPCODE_MI_ARB_CHECK = 0x5, 5869 } MI_COMMAND_OPCODE; 5870 typedef enum tagCOMMAND_TYPE { 5871 COMMAND_TYPE_MI_COMMAND = 0x0, 5872 } COMMAND_TYPE; 5873 inline void init() { 5874 memset(&TheStructure, 0, sizeof(TheStructure)); 5875 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_ARB_CHECK; 5876 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 5877 } 5878 static tagMI_ARB_CHECK sInit() { 5879 MI_ARB_CHECK state; 5880 state.init(); 5881 return state; 5882 } 5883 inline uint32_t &getRawData(const uint32_t index) { 5884 DEBUG_BREAK_IF(index >= 1); 5885 return TheStructure.RawData[index]; 5886 } 5887 inline void setPreFetchDisable(const uint32_t value) { 5888 TheStructure.Common.Pre_FetchDisable = value; 5889 TheStructure.Common.MaskBits = 1 << 0; //PreFetchDisable is at bit0, so set bit0 of mask to 1 5890 } 5891 inline uint32_t getPreFetchDisable() const { 5892 return TheStructure.Common.Pre_FetchDisable; 5893 } 5894 inline void setMaskBits(const uint32_t value) { 5895 DEBUG_BREAK_IF(value > 0xff00); 5896 TheStructure.Common.MaskBits = value; 5897 } 5898 inline uint32_t getMaskBits() const { 5899 return TheStructure.Common.MaskBits; 5900 } 5901} MI_ARB_CHECK; 5902STATIC_ASSERT(4 == sizeof(MI_ARB_CHECK)); 5903 5904typedef struct tagMI_BATCH_BUFFER_START { 5905 union tagTheStructure { 5906 struct tagCommon { 5907 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 5908 uint32_t AddressSpaceIndicator : BITFIELD_RANGE(8, 8); 5909 uint32_t Reserved_9 : BITFIELD_RANGE(9, 9); 5910 uint32_t ResourceStreamerEnable : BITFIELD_RANGE(10, 10); 5911 uint32_t Reserved_11 : BITFIELD_RANGE(11, 14); 5912 uint32_t PredicationEnable : BITFIELD_RANGE(15, 15); 5913 uint32_t AddOffsetEnable : BITFIELD_RANGE(16, 16); 5914 uint32_t Reserved_17 : BITFIELD_RANGE(17, 18); 5915 uint32_t EnableCommandCache : BITFIELD_RANGE(19, 19); 5916 uint32_t PoshEnable : BITFIELD_RANGE(20, 20); 5917 uint32_t PoshStart : BITFIELD_RANGE(21, 21); 5918 uint32_t SecondLevelBatchBuffer : BITFIELD_RANGE(22, 22); 5919 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 5920 uint32_t CommandType : BITFIELD_RANGE(29, 31); 5921 uint64_t Reserved_32 : BITFIELD_RANGE(0, 1); 5922 uint64_t BatchBufferStartAddress : BITFIELD_RANGE(2, 47); 5923 uint64_t BatchBufferStartAddress_Reserved_80 : BITFIELD_RANGE(48, 63); 5924 } Common; 5925 struct tagMi_Mode_Nestedbatchbufferenableis0 { 5926 uint32_t Reserved_0 : BITFIELD_RANGE(0, 21); 5927 uint32_t SecondLevelBatchBuffer : BITFIELD_RANGE(22, 22); 5928 uint32_t Reserved_23 : BITFIELD_RANGE(23, 31); 5929 uint64_t Reserved_32 : BITFIELD_RANGE(0, 47); 5930 uint64_t Reserved_80 : BITFIELD_RANGE(48, 63); 5931 } Mi_Mode_Nestedbatchbufferenableis0; 5932 struct tagMi_Mode_Nestedbatchbufferenableis1 { 5933 uint32_t Reserved_0 : BITFIELD_RANGE(0, 21); 5934 uint32_t NestedLevelBatchBuffer : BITFIELD_RANGE(22, 22); 5935 uint32_t Reserved_23 : BITFIELD_RANGE(23, 31); 5936 uint64_t Reserved_32 : BITFIELD_RANGE(0, 47); 5937 uint64_t Reserved_80 : BITFIELD_RANGE(48, 63); 5938 } Mi_Mode_Nestedbatchbufferenableis1; 5939 uint32_t RawData[3]; 5940 } TheStructure; 5941 typedef enum tagDWORD_LENGTH { 5942 DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x1, 5943 } DWORD_LENGTH; 5944 typedef enum tagADDRESS_SPACE_INDICATOR { 5945 ADDRESS_SPACE_INDICATOR_GGTT = 0x0, 5946 ADDRESS_SPACE_INDICATOR_PPGTT = 0x1, 5947 } ADDRESS_SPACE_INDICATOR; 5948 typedef enum tagNESTED_LEVEL_BATCH_BUFFER { 5949 NESTED_LEVEL_BATCH_BUFFER_CHAIN = 0x0, 5950 NESTED_LEVEL_BATCH_BUFFER_NESTED = 0x1, 5951 } NESTED_LEVEL_BATCH_BUFFER; 5952 typedef enum tagSECOND_LEVEL_BATCH_BUFFER { 5953 SECOND_LEVEL_BATCH_BUFFER_FIRST_LEVEL_BATCH = 0x0, 5954 SECOND_LEVEL_BATCH_BUFFER_SECOND_LEVEL_BATCH = 0x1, 5955 } SECOND_LEVEL_BATCH_BUFFER; 5956 typedef enum tagMI_COMMAND_OPCODE { 5957 MI_COMMAND_OPCODE_MI_BATCH_BUFFER_START = 0x31, 5958 } MI_COMMAND_OPCODE; 5959 typedef enum tagCOMMAND_TYPE { 5960 COMMAND_TYPE_MI_COMMAND = 0x0, 5961 } COMMAND_TYPE; 5962 inline void init() { 5963 memset(&TheStructure, 0, sizeof(TheStructure)); 5964 TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1; 5965 TheStructure.Common.AddressSpaceIndicator = ADDRESS_SPACE_INDICATOR_PPGTT; 5966 TheStructure.Common.SecondLevelBatchBuffer = SECOND_LEVEL_BATCH_BUFFER_FIRST_LEVEL_BATCH; 5967 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_BATCH_BUFFER_START; 5968 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 5969 TheStructure.Mi_Mode_Nestedbatchbufferenableis1.NestedLevelBatchBuffer = NESTED_LEVEL_BATCH_BUFFER_CHAIN; 5970 } 5971 static tagMI_BATCH_BUFFER_START sInit() { 5972 MI_BATCH_BUFFER_START state; 5973 state.init(); 5974 return state; 5975 } 5976 inline uint32_t &getRawData(const uint32_t index) { 5977 DEBUG_BREAK_IF(index >= 3); 5978 return TheStructure.RawData[index]; 5979 } 5980 inline void setAddressSpaceIndicator(const ADDRESS_SPACE_INDICATOR value) { 5981 TheStructure.Common.AddressSpaceIndicator = value; 5982 } 5983 inline ADDRESS_SPACE_INDICATOR getAddressSpaceIndicator() const { 5984 return static_cast<ADDRESS_SPACE_INDICATOR>(TheStructure.Common.AddressSpaceIndicator); 5985 } 5986 inline void setResourceStreamerEnable(const bool value) { 5987 TheStructure.Common.ResourceStreamerEnable = value; 5988 } 5989 inline bool getResourceStreamerEnable() const { 5990 return TheStructure.Common.ResourceStreamerEnable; 5991 } 5992 inline void setPredicationEnable(const uint32_t value) { 5993 TheStructure.Common.PredicationEnable = value; 5994 } 5995 inline uint32_t getPredicationEnable() const { 5996 return TheStructure.Common.PredicationEnable; 5997 } 5998 inline void setAddOffsetEnable(const bool value) { 5999 TheStructure.Common.AddOffsetEnable = value; 6000 } 6001 inline bool getAddOffsetEnable() const { 6002 return TheStructure.Common.AddOffsetEnable; 6003 } 6004 inline void setEnableCommandCache(const uint32_t value) { 6005 TheStructure.Common.EnableCommandCache = value; 6006 } 6007 inline uint32_t getEnableCommandCache() const { 6008 return TheStructure.Common.EnableCommandCache; 6009 } 6010 inline void setPoshEnable(const uint32_t value) { 6011 TheStructure.Common.PoshEnable = value; 6012 } 6013 inline uint32_t getPoshEnable() const { 6014 return TheStructure.Common.PoshEnable; 6015 } 6016 inline void setPoshStart(const uint32_t value) { 6017 TheStructure.Common.PoshStart = value; 6018 } 6019 inline uint32_t getPoshStart() const { 6020 return TheStructure.Common.PoshStart; 6021 } 6022 inline void setSecondLevelBatchBuffer(const SECOND_LEVEL_BATCH_BUFFER value) { 6023 TheStructure.Common.SecondLevelBatchBuffer = value; 6024 } 6025 inline SECOND_LEVEL_BATCH_BUFFER getSecondLevelBatchBuffer() const { 6026 return static_cast<SECOND_LEVEL_BATCH_BUFFER>(TheStructure.Common.SecondLevelBatchBuffer); 6027 } 6028 typedef enum tagBATCHBUFFERSTARTADDRESS { 6029 BATCHBUFFERSTARTADDRESS_BIT_SHIFT = 0x2, 6030 BATCHBUFFERSTARTADDRESS_ALIGN_SIZE = 0x4, 6031 } BATCHBUFFERSTARTADDRESS; 6032 inline void setBatchBufferStartAddress(const uint64_t value) { 6033 TheStructure.Common.BatchBufferStartAddress = value >> BATCHBUFFERSTARTADDRESS_BIT_SHIFT; 6034 } 6035 inline uint64_t getBatchBufferStartAddress() const { 6036 return TheStructure.Common.BatchBufferStartAddress << BATCHBUFFERSTARTADDRESS_BIT_SHIFT; 6037 } 6038 inline void setNestedLevelBatchBuffer(const NESTED_LEVEL_BATCH_BUFFER value) { 6039 TheStructure.Mi_Mode_Nestedbatchbufferenableis1.NestedLevelBatchBuffer = value; 6040 } 6041 inline NESTED_LEVEL_BATCH_BUFFER getNestedLevelBatchBuffer() const { 6042 return static_cast<NESTED_LEVEL_BATCH_BUFFER>(TheStructure.Mi_Mode_Nestedbatchbufferenableis1.NestedLevelBatchBuffer); 6043 } 6044} MI_BATCH_BUFFER_START; 6045STATIC_ASSERT(12 == sizeof(MI_BATCH_BUFFER_START)); 6046 6047typedef struct tagMI_LOAD_REGISTER_MEM { 6048 union tagTheStructure { 6049 struct tagCommon { 6050 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 6051 uint32_t MemoryObjectControlStateReserved_8 : BITFIELD_RANGE(8, 8); 6052 uint32_t MemoryObjectControlStateIndexToMocsTables 6053 : BITFIELD_RANGE(9, 14); 6054 uint32_t MemoryObjectControlStateEnable : BITFIELD_RANGE(15, 15); 6055 uint32_t VirtualEngineIdOffsetEnable : BITFIELD_RANGE(16, 16); 6056 uint32_t MmioRemapEnable : BITFIELD_RANGE(17, 17); 6057 uint32_t Reserved_18 : BITFIELD_RANGE(18, 18); 6058 uint32_t AddCsMmioStartOffset : BITFIELD_RANGE(19, 19); 6059 uint32_t Reserved_20 : BITFIELD_RANGE(20, 20); 6060 uint32_t AsyncModeEnable : BITFIELD_RANGE(21, 21); 6061 uint32_t UseGlobalGtt : BITFIELD_RANGE(22, 22); 6062 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 6063 uint32_t CommandType : BITFIELD_RANGE(29, 31); 6064 uint32_t Reserved_32 : BITFIELD_RANGE(0, 1); 6065 uint32_t RegisterAddress : BITFIELD_RANGE(2, 22); 6066 uint32_t Reserved_55 : BITFIELD_RANGE(23, 31); 6067 uint64_t Reserved_64 : BITFIELD_RANGE(0, 1); 6068 uint64_t MemoryAddress : BITFIELD_RANGE(2, 63); 6069 } Common; 6070 uint32_t RawData[4]; 6071 } TheStructure; 6072 typedef enum tagDWORD_LENGTH { 6073 DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x2, 6074 } DWORD_LENGTH; 6075 typedef enum tagMI_COMMAND_OPCODE { 6076 MI_COMMAND_OPCODE_MI_LOAD_REGISTER_MEM = 0x29, 6077 } MI_COMMAND_OPCODE; 6078 typedef enum tagCOMMAND_TYPE { 6079 COMMAND_TYPE_MI_COMMAND = 0x0, 6080 } COMMAND_TYPE; 6081 inline void init() { 6082 memset(&TheStructure, 0, sizeof(TheStructure)); 6083 TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1; 6084 TheStructure.Common.MiCommandOpcode = 6085 MI_COMMAND_OPCODE_MI_LOAD_REGISTER_MEM; 6086 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 6087 } 6088 static tagMI_LOAD_REGISTER_MEM sInit() { 6089 MI_LOAD_REGISTER_MEM state; 6090 state.init(); 6091 return state; 6092 } 6093 inline uint32_t &getRawData(const uint32_t index) { 6094 DEBUG_BREAK_IF(index >= 4); 6095 return TheStructure.RawData[index]; 6096 } 6097 inline void 6098 setMemoryObjectControlState(const uint32_t value) { 6099 DEBUG_BREAK_IF(value > 0x7e00); 6100 TheStructure.Common.MemoryObjectControlStateIndexToMocsTables = value >> 1; 6101 } 6102 inline uint32_t getMemoryObjectControlState() const { 6103 return (TheStructure.Common.MemoryObjectControlStateIndexToMocsTables << 1); 6104 } 6105 inline void setMemoryObjectControlStateEnable(const bool value) { 6106 TheStructure.Common.MemoryObjectControlStateEnable = value; 6107 } 6108 inline bool getMemoryObjectControlStateEnable() const { 6109 return TheStructure.Common.MemoryObjectControlStateEnable; 6110 } 6111 inline void setVirtualEngineIdOffsetEnable(const bool value) { 6112 TheStructure.Common.VirtualEngineIdOffsetEnable = value; 6113 } 6114 inline bool getVirtualEngineIdOffsetEnable() const { 6115 return TheStructure.Common.VirtualEngineIdOffsetEnable; 6116 } 6117 inline void setMmioRemapEnable(const bool value) { 6118 TheStructure.Common.MmioRemapEnable = value; 6119 } 6120 inline bool getMmioRemapEnable() const { 6121 return TheStructure.Common.MmioRemapEnable; 6122 } 6123 inline void setAddCsMmioStartOffset(const uint32_t value) { 6124 TheStructure.Common.AddCsMmioStartOffset = value; 6125 } 6126 inline uint32_t getAddCsMmioStartOffset() const { 6127 return TheStructure.Common.AddCsMmioStartOffset; 6128 } 6129 inline void setAsyncModeEnable(const bool value) { 6130 TheStructure.Common.AsyncModeEnable = value; 6131 } 6132 inline bool getAsyncModeEnable() const { 6133 return TheStructure.Common.AsyncModeEnable; 6134 } 6135 inline void setUseGlobalGtt(const bool value) { 6136 TheStructure.Common.UseGlobalGtt = value; 6137 } 6138 inline bool getUseGlobalGtt() const { 6139 return TheStructure.Common.UseGlobalGtt; 6140 } 6141 typedef enum tagREGISTERADDRESS { 6142 REGISTERADDRESS_BIT_SHIFT = 0x2, 6143 REGISTERADDRESS_ALIGN_SIZE = 0x4, 6144 } REGISTERADDRESS; 6145 inline void setRegisterAddress(const uint32_t value) { 6146 DEBUG_BREAK_IF(value > 0x7ffffc); 6147 TheStructure.Common.RegisterAddress = value >> REGISTERADDRESS_BIT_SHIFT; 6148 } 6149 inline uint32_t getRegisterAddress() const { 6150 return TheStructure.Common.RegisterAddress << REGISTERADDRESS_BIT_SHIFT; 6151 } 6152 typedef enum tagMEMORYADDRESS { 6153 MEMORYADDRESS_BIT_SHIFT = 0x2, 6154 MEMORYADDRESS_ALIGN_SIZE = 0x4, 6155 } MEMORYADDRESS; 6156 inline void setMemoryAddress(const uint64_t value) { 6157 DEBUG_BREAK_IF(value > 0xfffffffffffffffcL); 6158 TheStructure.Common.MemoryAddress = value >> MEMORYADDRESS_BIT_SHIFT; 6159 } 6160 inline uint64_t getMemoryAddress() const { 6161 return TheStructure.Common.MemoryAddress << MEMORYADDRESS_BIT_SHIFT; 6162 } 6163} MI_LOAD_REGISTER_MEM; 6164STATIC_ASSERT(16 == sizeof(MI_LOAD_REGISTER_MEM)); 6165 6166typedef struct tagMI_LOAD_REGISTER_REG { 6167 union tagTheStructure { 6168 struct tagCommon { 6169 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 6170 uint32_t Reserved_8 : BITFIELD_RANGE(8, 15); 6171 uint32_t MmioRemapEnableSource : BITFIELD_RANGE(16, 16); 6172 uint32_t MmioRemapEnableDestination : BITFIELD_RANGE(17, 17); 6173 uint32_t AddCsMmioStartOffsetSource : BITFIELD_RANGE(18, 18); 6174 uint32_t AddCsMmioStartOffsetDestination : BITFIELD_RANGE(19, 19); 6175 uint32_t Reserved_20 : BITFIELD_RANGE(20, 22); 6176 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 6177 uint32_t CommandType : BITFIELD_RANGE(29, 31); 6178 uint32_t Reserved_32 : BITFIELD_RANGE(0, 1); 6179 uint32_t SourceRegisterAddress : BITFIELD_RANGE(2, 22); 6180 uint32_t Reserved_55 : BITFIELD_RANGE(23, 31); 6181 uint32_t Reserved_64 : BITFIELD_RANGE(0, 1); 6182 uint32_t DestinationRegisterAddress : BITFIELD_RANGE(2, 22); 6183 uint32_t Reserved_87 : BITFIELD_RANGE(23, 31); 6184 } Common; 6185 uint32_t RawData[3]; 6186 } TheStructure; 6187 typedef enum tagDWORD_LENGTH { 6188 DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x1, 6189 } DWORD_LENGTH; 6190 typedef enum tagMI_COMMAND_OPCODE { 6191 MI_COMMAND_OPCODE_MI_LOAD_REGISTER_REG = 0x2a, 6192 } MI_COMMAND_OPCODE; 6193 typedef enum tagCOMMAND_TYPE { 6194 COMMAND_TYPE_MI_COMMAND = 0x0, 6195 } COMMAND_TYPE; 6196 inline void init() { 6197 memset(&TheStructure, 0, sizeof(TheStructure)); 6198 TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1; 6199 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_LOAD_REGISTER_REG; 6200 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 6201 } 6202 static tagMI_LOAD_REGISTER_REG sInit() { 6203 MI_LOAD_REGISTER_REG state; 6204 state.init(); 6205 return state; 6206 } 6207 inline uint32_t &getRawData(const uint32_t index) { 6208 DEBUG_BREAK_IF(index >= 3); 6209 return TheStructure.RawData[index]; 6210 } 6211 inline void setMmioRemapEnableSource(const bool value) { 6212 TheStructure.Common.MmioRemapEnableSource = value; 6213 } 6214 inline bool getMmioRemapEnableSource() const { 6215 return TheStructure.Common.MmioRemapEnableSource; 6216 } 6217 inline void setMmioRemapEnableDestination(const bool value) { 6218 TheStructure.Common.MmioRemapEnableDestination = value; 6219 } 6220 inline bool getMmioRemapEnableDestination() const { 6221 return TheStructure.Common.MmioRemapEnableDestination; 6222 } 6223 inline void setAddCsMmioStartOffsetSource(const uint32_t value) { 6224 TheStructure.Common.AddCsMmioStartOffsetSource = value; 6225 } 6226 inline uint32_t getAddCsMmioStartOffsetSource() const { 6227 return TheStructure.Common.AddCsMmioStartOffsetSource; 6228 } 6229 inline void setAddCsMmioStartOffsetDestination(const uint32_t value) { 6230 TheStructure.Common.AddCsMmioStartOffsetDestination = value; 6231 } 6232 inline uint32_t getAddCsMmioStartOffsetDestination() const { 6233 return TheStructure.Common.AddCsMmioStartOffsetDestination; 6234 } 6235 typedef enum tagSOURCEREGISTERADDRESS { 6236 SOURCEREGISTERADDRESS_BIT_SHIFT = 0x2, 6237 SOURCEREGISTERADDRESS_ALIGN_SIZE = 0x4, 6238 } SOURCEREGISTERADDRESS; 6239 inline void setSourceRegisterAddress(const uint32_t value) { 6240 DEBUG_BREAK_IF(value > 0x7ffffc); 6241 TheStructure.Common.SourceRegisterAddress = value >> SOURCEREGISTERADDRESS_BIT_SHIFT; 6242 } 6243 inline uint32_t getSourceRegisterAddress() const { 6244 return TheStructure.Common.SourceRegisterAddress << SOURCEREGISTERADDRESS_BIT_SHIFT; 6245 } 6246 typedef enum tagDESTINATIONREGISTERADDRESS { 6247 DESTINATIONREGISTERADDRESS_BIT_SHIFT = 0x2, 6248 DESTINATIONREGISTERADDRESS_ALIGN_SIZE = 0x4, 6249 } DESTINATIONREGISTERADDRESS; 6250 inline void setDestinationRegisterAddress(const uint32_t value) { 6251 DEBUG_BREAK_IF(value > 0x7ffffc); 6252 TheStructure.Common.DestinationRegisterAddress = value >> DESTINATIONREGISTERADDRESS_BIT_SHIFT; 6253 } 6254 inline uint32_t getDestinationRegisterAddress() const { 6255 return TheStructure.Common.DestinationRegisterAddress << DESTINATIONREGISTERADDRESS_BIT_SHIFT; 6256 } 6257} MI_LOAD_REGISTER_REG; 6258STATIC_ASSERT(12 == sizeof(MI_LOAD_REGISTER_REG)); 6259 6260typedef struct tagMI_SEMAPHORE_WAIT { 6261 union tagTheStructure { 6262 struct tagCommon { 6263 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 6264 uint32_t Reserved_8 : BITFIELD_RANGE(8, 11); 6265 uint32_t CompareOperation : BITFIELD_RANGE(12, 14); 6266 uint32_t WaitMode : BITFIELD_RANGE(15, 15); 6267 uint32_t RegisterPollMode : BITFIELD_RANGE(16, 16); 6268 uint32_t Reserved_17 : BITFIELD_RANGE(17, 17); 6269 uint32_t WorkloadPartitionIdOffsetEnable : BITFIELD_RANGE(18, 18); 6270 uint32_t Reserved_19 : BITFIELD_RANGE(19, 21); 6271 uint32_t MemoryType : BITFIELD_RANGE(22, 22); 6272 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 6273 uint32_t CommandType : BITFIELD_RANGE(29, 31); 6274 uint32_t SemaphoreDataDword; 6275 uint64_t Reserved_64 : BITFIELD_RANGE(0, 1); 6276 uint64_t SemaphoreAddress : BITFIELD_RANGE(2, 63); 6277 uint32_t Reserved_192 : BITFIELD_RANGE(0, 4); 6278 uint32_t WaitTokenNumber : BITFIELD_RANGE(5, 9); 6279 uint32_t Reserved_202 : BITFIELD_RANGE(10, 31); 6280 } Common; 6281 uint32_t RawData[5]; 6282 } TheStructure; 6283 typedef enum tagDWORD_LENGTH { 6284 DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x3, 6285 } DWORD_LENGTH; 6286 typedef enum tagCOMPARE_OPERATION { 6287 COMPARE_OPERATION_SAD_GREATER_THAN_SDD = 0x0, 6288 COMPARE_OPERATION_SAD_GREATER_THAN_OR_EQUAL_SDD = 0x1, 6289 COMPARE_OPERATION_SAD_LESS_THAN_SDD = 0x2, 6290 COMPARE_OPERATION_SAD_LESS_THAN_OR_EQUAL_SDD = 0x3, 6291 COMPARE_OPERATION_SAD_EQUAL_SDD = 0x4, 6292 COMPARE_OPERATION_SAD_NOT_EQUAL_SDD = 0x5, 6293 } COMPARE_OPERATION; 6294 typedef enum tagWAIT_MODE { 6295 WAIT_MODE_SIGNAL_MODE = 0x0, 6296 WAIT_MODE_POLLING_MODE = 0x1, 6297 } WAIT_MODE; 6298 typedef enum tagREGISTER_POLL_MODE { 6299 REGISTER_POLL_MODE_MEMORY_POLL = 0x0, 6300 REGISTER_POLL_MODE_REGISTER_POLL = 0x1, 6301 } REGISTER_POLL_MODE; 6302 typedef enum tagMEMORY_TYPE { 6303 MEMORY_TYPE_PER_PROCESS_GRAPHICS_ADDRESS = 0x0, 6304 MEMORY_TYPE_GLOBAL_GRAPHICS_ADDRESS = 0x1, 6305 } MEMORY_TYPE; 6306 typedef enum tagMI_COMMAND_OPCODE { 6307 MI_COMMAND_OPCODE_MI_SEMAPHORE_WAIT = 0x1c, 6308 } MI_COMMAND_OPCODE; 6309 typedef enum tagCOMMAND_TYPE { 6310 COMMAND_TYPE_MI_COMMAND = 0x0, 6311 } COMMAND_TYPE; 6312 inline void init() { 6313 memset(&TheStructure, 0, sizeof(TheStructure)); 6314 TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1; 6315 TheStructure.Common.CompareOperation = 6316 COMPARE_OPERATION_SAD_GREATER_THAN_SDD; 6317 TheStructure.Common.WaitMode = WAIT_MODE_SIGNAL_MODE; 6318 TheStructure.Common.RegisterPollMode = REGISTER_POLL_MODE_MEMORY_POLL; 6319 TheStructure.Common.MemoryType = MEMORY_TYPE_PER_PROCESS_GRAPHICS_ADDRESS; 6320 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_SEMAPHORE_WAIT; 6321 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 6322 } 6323 static tagMI_SEMAPHORE_WAIT sInit() { 6324 MI_SEMAPHORE_WAIT state; 6325 state.init(); 6326 return state; 6327 } 6328 inline uint32_t &getRawData(const uint32_t index) { 6329 DEBUG_BREAK_IF(index >= 6); 6330 return TheStructure.RawData[index]; 6331 } 6332 inline void setCompareOperation(const COMPARE_OPERATION value) { 6333 TheStructure.Common.CompareOperation = value; 6334 } 6335 inline COMPARE_OPERATION getCompareOperation() const { 6336 return static_cast<COMPARE_OPERATION>(TheStructure.Common.CompareOperation); 6337 } 6338 inline void setWaitMode(const WAIT_MODE value) { 6339 TheStructure.Common.WaitMode = value; 6340 } 6341 inline WAIT_MODE getWaitMode() const { 6342 return static_cast<WAIT_MODE>(TheStructure.Common.WaitMode); 6343 } 6344 inline void setRegisterPollMode(const REGISTER_POLL_MODE value) { 6345 TheStructure.Common.RegisterPollMode = value; 6346 } 6347 inline REGISTER_POLL_MODE getRegisterPollMode() const { 6348 return static_cast<REGISTER_POLL_MODE>( 6349 TheStructure.Common.RegisterPollMode); 6350 } 6351 inline void setWorkloadPartitionIdOffsetEnable(const bool value) { 6352 TheStructure.Common.WorkloadPartitionIdOffsetEnable = value; 6353 } 6354 inline bool getWorkloadPartitionIdOffsetEnable() const { 6355 return TheStructure.Common.WorkloadPartitionIdOffsetEnable; 6356 } 6357 inline void setMemoryType(const MEMORY_TYPE value) { 6358 TheStructure.Common.MemoryType = value; 6359 } 6360 inline MEMORY_TYPE getMemoryType() const { 6361 return static_cast<MEMORY_TYPE>(TheStructure.Common.MemoryType); 6362 } 6363 inline void setSemaphoreDataDword(const uint32_t value) { 6364 TheStructure.Common.SemaphoreDataDword = value; 6365 } 6366 inline uint32_t getSemaphoreDataDword() const { 6367 return TheStructure.Common.SemaphoreDataDword; 6368 } 6369 typedef enum tagSEMAPHOREADDRESS { 6370 SEMAPHOREADDRESS_BIT_SHIFT = 0x2, 6371 SEMAPHOREADDRESS_ALIGN_SIZE = 0x4, 6372 } SEMAPHOREADDRESS; 6373 inline void setSemaphoreGraphicsAddress(const uint64_t value) { 6374 TheStructure.Common.SemaphoreAddress = value >> SEMAPHOREADDRESS_BIT_SHIFT; 6375 } 6376 inline uint64_t getSemaphoreGraphicsAddress() const { 6377 return TheStructure.Common.SemaphoreAddress << SEMAPHOREADDRESS_BIT_SHIFT; 6378 } 6379 inline void setWaitTokenNumber(const uint32_t value) { 6380 DEBUG_BREAK_IF(value > 0x3e0); 6381 TheStructure.Common.WaitTokenNumber = value; 6382 } 6383 inline uint32_t getWaitTokenNumber() const { 6384 return TheStructure.Common.WaitTokenNumber; 6385 } 6386} MI_SEMAPHORE_WAIT; 6387STATIC_ASSERT(20 == sizeof(MI_SEMAPHORE_WAIT)); 6388 6389typedef struct tagMI_STORE_DATA_IMM { 6390 union tagTheStructure { 6391 struct tagCommon { 6392 uint32_t DwordLength : BITFIELD_RANGE(0, 9); 6393 uint32_t Reserved_10 : BITFIELD_RANGE(10, 10); 6394 uint32_t WorkloadPartitionIdOffsetEnable : BITFIELD_RANGE(11, 11); 6395 uint32_t Reserved_12 : BITFIELD_RANGE(12, 13); 6396 uint32_t MemoryObjectControlStateIndexToMocsTables 6397 : BITFIELD_RANGE(14, 19); 6398 uint32_t MemoryObjectControlStateEnable : BITFIELD_RANGE(20, 20); 6399 uint32_t StoreQword : BITFIELD_RANGE(21, 21); 6400 uint32_t UseGlobalGtt : BITFIELD_RANGE(22, 22); 6401 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 6402 uint32_t CommandType : BITFIELD_RANGE(29, 31); 6403 uint64_t CoreModeEnable : BITFIELD_RANGE(0, 0); 6404 uint64_t Reserved_33 : BITFIELD_RANGE(1, 1); 6405 uint64_t Address : BITFIELD_RANGE(2, 47); 6406 uint64_t AddressReserved_80 : BITFIELD_RANGE(48, 63); 6407 uint32_t DataDword0; 6408 uint32_t DataDword1; 6409 } Common; 6410 uint32_t RawData[5]; 6411 } TheStructure; 6412 typedef enum tagDWORD_LENGTH { 6413 DWORD_LENGTH_STORE_DWORD = 0x2, 6414 DWORD_LENGTH_STORE_QWORD = 0x3, 6415 } DWORD_LENGTH; 6416 typedef enum tagMI_COMMAND_OPCODE { 6417 MI_COMMAND_OPCODE_MI_STORE_DATA_IMM = 0x20, 6418 } MI_COMMAND_OPCODE; 6419 typedef enum tagCOMMAND_TYPE { 6420 COMMAND_TYPE_MI_COMMAND = 0x0, 6421 } COMMAND_TYPE; 6422 inline void init() { 6423 memset(&TheStructure, 0, sizeof(TheStructure)); 6424 TheStructure.Common.DwordLength = DWORD_LENGTH_STORE_DWORD; 6425 TheStructure.Common.MiCommandOpcode = MI_COMMAND_OPCODE_MI_STORE_DATA_IMM; 6426 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 6427 } 6428 static tagMI_STORE_DATA_IMM sInit() { 6429 MI_STORE_DATA_IMM state; 6430 state.init(); 6431 return state; 6432 } 6433 inline uint32_t &getRawData(const uint32_t index) { 6434 DEBUG_BREAK_IF(index >= 5); 6435 return TheStructure.RawData[index]; 6436 } 6437 inline void setDwordLength(const DWORD_LENGTH value) { 6438 TheStructure.Common.DwordLength = value; 6439 } 6440 inline DWORD_LENGTH getDwordLength() const { 6441 return static_cast<DWORD_LENGTH>(TheStructure.Common.DwordLength); 6442 } 6443 inline void setWorkloadPartitionIdOffsetEnable(const bool value) { 6444 TheStructure.Common.WorkloadPartitionIdOffsetEnable = value; 6445 } 6446 inline bool getWorkloadPartitionIdOffsetEnable() const { 6447 return TheStructure.Common.WorkloadPartitionIdOffsetEnable; 6448 } 6449 inline void 6450 setMemoryObjectControlState(const uint32_t value) { 6451 DEBUG_BREAK_IF(value > 0xfc000); 6452 TheStructure.Common.MemoryObjectControlStateIndexToMocsTables = value >> 1; 6453 } 6454 inline uint32_t getMemoryObjectControlState() const { 6455 return (TheStructure.Common.MemoryObjectControlStateIndexToMocsTables << 1); 6456 } 6457 inline void setMemoryObjectControlStateEnable(const bool value) { 6458 TheStructure.Common.MemoryObjectControlStateEnable = value; 6459 } 6460 inline bool getMemoryObjectControlStateEnable() const { 6461 return TheStructure.Common.MemoryObjectControlStateEnable; 6462 } 6463 inline void setStoreQword(const bool value) { 6464 TheStructure.Common.StoreQword = value; 6465 } 6466 inline bool getStoreQword() const { 6467 return TheStructure.Common.StoreQword; 6468 } 6469 inline void setUseGlobalGtt(const bool value) { 6470 TheStructure.Common.UseGlobalGtt = value; 6471 } 6472 inline bool getUseGlobalGtt() const { 6473 return TheStructure.Common.UseGlobalGtt; 6474 } 6475 inline void setCoreModeEnable(const uint64_t value) { 6476 TheStructure.Common.CoreModeEnable = value; 6477 } 6478 inline uint64_t getCoreModeEnable() const { 6479 return TheStructure.Common.CoreModeEnable; 6480 } 6481 typedef enum tagADDRESS { 6482 ADDRESS_BIT_SHIFT = 0x2, 6483 ADDRESS_ALIGN_SIZE = 0x4, 6484 } ADDRESS; 6485 inline void setAddress(const uint64_t value) { 6486 DEBUG_BREAK_IF(value > 0xfffffffffffcL); 6487 TheStructure.Common.Address = value >> ADDRESS_BIT_SHIFT; 6488 } 6489 inline uint64_t getAddress() const { 6490 return TheStructure.Common.Address << ADDRESS_BIT_SHIFT; 6491 } 6492 inline void setDataDword0(const uint32_t value) { 6493 TheStructure.Common.DataDword0 = value; 6494 } 6495 inline uint32_t getDataDword0() const { 6496 return TheStructure.Common.DataDword0; 6497 } 6498 inline void setDataDword1(const uint32_t value) { 6499 TheStructure.Common.DataDword1 = value; 6500 } 6501 inline uint32_t getDataDword1() const { 6502 return TheStructure.Common.DataDword1; 6503 } 6504} MI_STORE_DATA_IMM; 6505STATIC_ASSERT(20 == sizeof(MI_STORE_DATA_IMM)); 6506 6507typedef struct tagMI_STORE_REGISTER_MEM { 6508 union tagTheStructure { 6509 struct tagCommon { 6510 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 6511 uint32_t MemoryObjectControlStateReserved_8 : BITFIELD_RANGE(8, 8); 6512 uint32_t MemoryObjectControlStateIndexToMocsTables 6513 : BITFIELD_RANGE(9, 14); 6514 uint32_t MemoryObjectControlStateEnable : BITFIELD_RANGE(15, 15); 6515 uint32_t WorkloadPartitionIdOffsetEnable : BITFIELD_RANGE(16, 16); 6516 uint32_t MmioRemapEnable : BITFIELD_RANGE(17, 17); 6517 uint32_t Reserved_18 : BITFIELD_RANGE(18, 18); 6518 uint32_t AddCsMmioStartOffset : BITFIELD_RANGE(19, 19); 6519 uint32_t Reserved_20 : BITFIELD_RANGE(20, 20); 6520 uint32_t PredicateEnable : BITFIELD_RANGE(21, 21); 6521 uint32_t UseGlobalGtt : BITFIELD_RANGE(22, 22); 6522 uint32_t MiCommandOpcode : BITFIELD_RANGE(23, 28); 6523 uint32_t CommandType : BITFIELD_RANGE(29, 31); 6524 uint32_t Reserved_32 : BITFIELD_RANGE(0, 1); 6525 uint32_t RegisterAddress : BITFIELD_RANGE(2, 22); 6526 uint32_t Reserved_55 : BITFIELD_RANGE(23, 31); 6527 uint64_t Reserved_64 : BITFIELD_RANGE(0, 1); 6528 uint64_t MemoryAddress : BITFIELD_RANGE(2, 63); 6529 } Common; 6530 uint32_t RawData[4]; 6531 } TheStructure; 6532 typedef enum tagDWORD_LENGTH { 6533 DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x2, 6534 } DWORD_LENGTH; 6535 typedef enum tagMI_COMMAND_OPCODE { 6536 MI_COMMAND_OPCODE_MI_STORE_REGISTER_MEM = 0x24, 6537 } MI_COMMAND_OPCODE; 6538 typedef enum tagCOMMAND_TYPE { 6539 COMMAND_TYPE_MI_COMMAND = 0x0, 6540 } COMMAND_TYPE; 6541 inline void init() { 6542 memset(&TheStructure, 0, sizeof(TheStructure)); 6543 TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1; 6544 TheStructure.Common.MiCommandOpcode = 6545 MI_COMMAND_OPCODE_MI_STORE_REGISTER_MEM; 6546 TheStructure.Common.CommandType = COMMAND_TYPE_MI_COMMAND; 6547 } 6548 static tagMI_STORE_REGISTER_MEM sInit() { 6549 MI_STORE_REGISTER_MEM state; 6550 state.init(); 6551 return state; 6552 } 6553 inline uint32_t &getRawData(const uint32_t index) { 6554 DEBUG_BREAK_IF(index >= 4); 6555 return TheStructure.RawData[index]; 6556 } 6557 inline void 6558 setMemoryObjectControlState(const uint32_t value) { 6559 DEBUG_BREAK_IF(value > 0x7e00); 6560 TheStructure.Common.MemoryObjectControlStateIndexToMocsTables = value >> 1; 6561 } 6562 inline uint32_t getMemoryObjectControlState() const { 6563 return (TheStructure.Common.MemoryObjectControlStateIndexToMocsTables << 1); 6564 } 6565 inline void setMemoryObjectControlStateEnable(const bool value) { 6566 TheStructure.Common.MemoryObjectControlStateEnable = value; 6567 } 6568 inline bool getMemoryObjectControlStateEnable() const { 6569 return TheStructure.Common.MemoryObjectControlStateEnable; 6570 } 6571 inline void setWorkloadPartitionIdOffsetEnable(const bool value) { 6572 TheStructure.Common.WorkloadPartitionIdOffsetEnable = value; 6573 } 6574 inline bool getWorkloadPartitionIdOffsetEnable() const { 6575 return TheStructure.Common.WorkloadPartitionIdOffsetEnable; 6576 } 6577 inline void setMmioRemapEnable(const bool value) { 6578 TheStructure.Common.MmioRemapEnable = value; 6579 } 6580 inline bool getMmioRemapEnable() const { 6581 return TheStructure.Common.MmioRemapEnable; 6582 } 6583 inline void setAddCsMmioStartOffset(const uint32_t value) { 6584 TheStructure.Common.AddCsMmioStartOffset = value; 6585 } 6586 inline uint32_t getAddCsMmioStartOffset() const { 6587 return TheStructure.Common.AddCsMmioStartOffset; 6588 } 6589 inline void setPredicateEnable(const bool value) { 6590 TheStructure.Common.PredicateEnable = value; 6591 } 6592 inline bool getPredicateEnable() const { 6593 return TheStructure.Common.PredicateEnable; 6594 } 6595 inline void setUseGlobalGtt(const bool value) { 6596 TheStructure.Common.UseGlobalGtt = value; 6597 } 6598 inline bool getUseGlobalGtt() const { 6599 return TheStructure.Common.UseGlobalGtt; 6600 } 6601 typedef enum tagREGISTERADDRESS { 6602 REGISTERADDRESS_BIT_SHIFT = 0x2, 6603 REGISTERADDRESS_ALIGN_SIZE = 0x4, 6604 } REGISTERADDRESS; 6605 inline void setRegisterAddress(const uint32_t value) { 6606 DEBUG_BREAK_IF(value > 0x7ffffc); 6607 TheStructure.Common.RegisterAddress = value >> REGISTERADDRESS_BIT_SHIFT; 6608 } 6609 inline uint32_t getRegisterAddress() const { 6610 return TheStructure.Common.RegisterAddress << REGISTERADDRESS_BIT_SHIFT; 6611 } 6612 typedef enum tagMEMORYADDRESS { 6613 MEMORYADDRESS_BIT_SHIFT = 0x2, 6614 MEMORYADDRESS_ALIGN_SIZE = 0x4, 6615 } MEMORYADDRESS; 6616 inline void setMemoryAddress(const uint64_t value) { 6617 DEBUG_BREAK_IF(value > 0xfffffffffffffffcL); 6618 TheStructure.Common.MemoryAddress = value >> MEMORYADDRESS_BIT_SHIFT; 6619 } 6620 inline uint64_t getMemoryAddress() const { 6621 return TheStructure.Common.MemoryAddress << MEMORYADDRESS_BIT_SHIFT; 6622 } 6623} MI_STORE_REGISTER_MEM; 6624STATIC_ASSERT(16 == sizeof(MI_STORE_REGISTER_MEM)); 6625 6626typedef struct tagPIPELINE_SELECT { 6627 union tagTheStructure { 6628 struct tagCommon { 6629 uint32_t PipelineSelection : BITFIELD_RANGE(0, 1); 6630 uint32_t RenderSliceCommonPowerGateEnable : BITFIELD_RANGE(2, 2); 6631 uint32_t RenderSamplerPowerGateEnable : BITFIELD_RANGE(3, 3); 6632 uint32_t MediaSamplerDopClockGateEnable : BITFIELD_RANGE(4, 4); 6633 uint32_t Reserved_5 : BITFIELD_RANGE(5, 5); 6634 uint32_t MediaSamplerPowerClockGateDisable : BITFIELD_RANGE(6, 6); 6635 uint32_t SystolicModeEnable : BITFIELD_RANGE(7, 7); 6636 uint32_t MaskBits : BITFIELD_RANGE(8, 15); 6637 uint32_t _3DCommandSubOpcode : BITFIELD_RANGE(16, 23); 6638 uint32_t _3DCommandOpcode : BITFIELD_RANGE(24, 26); 6639 uint32_t CommandSubtype : BITFIELD_RANGE(27, 28); 6640 uint32_t CommandType : BITFIELD_RANGE(29, 31); 6641 } Common; 6642 uint32_t RawData[1]; 6643 } TheStructure; 6644 typedef enum tagPIPELINE_SELECTION { 6645 PIPELINE_SELECTION_3D = 0x0, 6646 PIPELINE_SELECTION_MEDIA = 0x1, 6647 PIPELINE_SELECTION_GPGPU = 0x2, 6648 } PIPELINE_SELECTION; 6649 typedef enum tag_3D_COMMAND_SUB_OPCODE { 6650 _3D_COMMAND_SUB_OPCODE_PIPELINE_SELECT = 0x4, 6651 } _3D_COMMAND_SUB_OPCODE; 6652 typedef enum tag_3D_COMMAND_OPCODE { 6653 _3D_COMMAND_OPCODE_GFXPIPE_NONPIPELINED = 0x1, 6654 } _3D_COMMAND_OPCODE; 6655 typedef enum tagCOMMAND_SUBTYPE { 6656 COMMAND_SUBTYPE_GFXPIPE_SINGLE_DW = 0x1, 6657 } COMMAND_SUBTYPE; 6658 typedef enum tagCOMMAND_TYPE { 6659 COMMAND_TYPE_GFXPIPE = 0x3, 6660 } COMMAND_TYPE; 6661 inline void init() { 6662 memset(&TheStructure, 0, sizeof(TheStructure)); 6663 TheStructure.Common.PipelineSelection = PIPELINE_SELECTION_3D; 6664 TheStructure.Common._3DCommandSubOpcode = 6665 _3D_COMMAND_SUB_OPCODE_PIPELINE_SELECT; 6666 TheStructure.Common._3DCommandOpcode = 6667 _3D_COMMAND_OPCODE_GFXPIPE_NONPIPELINED; 6668 TheStructure.Common.CommandSubtype = COMMAND_SUBTYPE_GFXPIPE_SINGLE_DW; 6669 TheStructure.Common.CommandType = COMMAND_TYPE_GFXPIPE; 6670 } 6671 static tagPIPELINE_SELECT sInit() { 6672 PIPELINE_SELECT state; 6673 state.init(); 6674 return state; 6675 } 6676 inline uint32_t &getRawData(const uint32_t index) { 6677 DEBUG_BREAK_IF(index >= 1); 6678 return TheStructure.RawData[index]; 6679 } 6680 inline void setPipelineSelection(const PIPELINE_SELECTION value) { 6681 TheStructure.Common.PipelineSelection = value; 6682 } 6683 inline PIPELINE_SELECTION getPipelineSelection() const { 6684 return static_cast<PIPELINE_SELECTION>( 6685 TheStructure.Common.PipelineSelection); 6686 } 6687 inline void setRenderSliceCommonPowerGateEnable(const bool value) { 6688 TheStructure.Common.RenderSliceCommonPowerGateEnable = value; 6689 } 6690 inline bool getRenderSliceCommonPowerGateEnable() const { 6691 return TheStructure.Common.RenderSliceCommonPowerGateEnable; 6692 } 6693 inline void setRenderSamplerPowerGateEnable(const bool value) { 6694 TheStructure.Common.RenderSamplerPowerGateEnable = value; 6695 } 6696 inline bool getRenderSamplerPowerGateEnable() const { 6697 return TheStructure.Common.RenderSamplerPowerGateEnable; 6698 } 6699 inline void setMediaSamplerDopClockGateEnable(const bool value) { 6700 TheStructure.Common.MediaSamplerDopClockGateEnable = value; 6701 } 6702 inline bool getMediaSamplerDopClockGateEnable() const { 6703 return TheStructure.Common.MediaSamplerDopClockGateEnable; 6704 } 6705 inline void setMediaSamplerPowerClockGateDisable(const bool value) { 6706 TheStructure.Common.MediaSamplerPowerClockGateDisable = value; 6707 } 6708 inline bool getMediaSamplerPowerClockGateDisable() const { 6709 return TheStructure.Common.MediaSamplerPowerClockGateDisable; 6710 } 6711 inline void setSystolicModeEnable(const bool value) { 6712 TheStructure.Common.SystolicModeEnable = value; 6713 } 6714 inline bool getSystolicModeEnable() const { 6715 return TheStructure.Common.SystolicModeEnable; 6716 } 6717 inline void setMaskBits(const uint32_t value) { 6718 DEBUG_BREAK_IF(value > 0xff00); 6719 TheStructure.Common.MaskBits = value; 6720 } 6721 inline uint32_t getMaskBits() const { 6722 return TheStructure.Common.MaskBits; 6723 } 6724} PIPELINE_SELECT; 6725STATIC_ASSERT(4 == sizeof(PIPELINE_SELECT)); 6726 6727typedef struct tagSTATE_COMPUTE_MODE { 6728 union tagTheStructure { 6729 struct tagCommon { 6730 // DWORD 0 6731 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 6732 uint32_t Reserved_8 : BITFIELD_RANGE(8, 15); 6733 uint32_t _3DCommandSubOpcode : BITFIELD_RANGE(16, 23); 6734 uint32_t _3DCommandOpcode : BITFIELD_RANGE(24, 26); 6735 uint32_t CommandSubtype : BITFIELD_RANGE(27, 28); 6736 uint32_t CommandType : BITFIELD_RANGE(29, 31); 6737 // DWORD 1 6738 uint32_t DisableSupportForMultiGpuFence : BITFIELD_RANGE(0, 0); 6739 uint32_t ForceDisableSupportForMultiGpuAtomics : BITFIELD_RANGE(1, 1); 6740 uint32_t ForceDisableSupportForMultiGpuPartialWrites : BITFIELD_RANGE(2, 2); 6741 uint32_t ForceNonCoherent : BITFIELD_RANGE(3, 4); 6742 uint32_t FastClearDisabledOnCompressedSurface : BITFIELD_RANGE(5, 5); 6743 uint32_t DisableSlmReadMergeOptimization : BITFIELD_RANGE(6, 6); 6744 uint32_t Reserved_39 : BITFIELD_RANGE(7, 10); 6745 uint32_t DisableAtomicOnClearData : BITFIELD_RANGE(11, 11); 6746 uint32_t Reserved_44 : BITFIELD_RANGE(12, 12); 6747 uint32_t DisableL1InvalidateForNonL1CacheableWrites : BITFIELD_RANGE(13, 13); 6748 uint32_t Reserved_46 : BITFIELD_RANGE(14, 14); 6749 uint32_t LargeGrfMode : BITFIELD_RANGE(15, 15); 6750 uint32_t MaskBits : BITFIELD_RANGE(16, 31); 6751 } Common; 6752 uint32_t RawData[2]; 6753 } TheStructure; 6754 typedef enum tagDWORD_LENGTH { 6755 DWORD_LENGTH_EXCLUDES_DWORD_0_1 = 0x0, 6756 } DWORD_LENGTH; 6757 typedef enum tag_3D_COMMAND_SUB_OPCODE { 6758 _3D_COMMAND_SUB_OPCODE_STATE_COMPUTE_MODE = 0x5, 6759 } _3D_COMMAND_SUB_OPCODE; 6760 typedef enum tag_3D_COMMAND_OPCODE { 6761 _3D_COMMAND_OPCODE_GFXPIPE_NONPIPELINED = 0x1, 6762 } _3D_COMMAND_OPCODE; 6763 typedef enum tagCOMMAND_SUBTYPE { 6764 COMMAND_SUBTYPE_GFXPIPE_COMMON = 0x0, 6765 } COMMAND_SUBTYPE; 6766 typedef enum tagCOMMAND_TYPE { 6767 COMMAND_TYPE_GFXPIPE = 0x3, 6768 } COMMAND_TYPE; 6769 typedef enum tagFORCE_NON_COHERENT { 6770 FORCE_NON_COHERENT_FORCE_DISABLED = 0x0, 6771 FORCE_NON_COHERENT_FORCE_CPU_NON_COHERENT = 0x1, 6772 FORCE_NON_COHERENT_FORCE_GPU_NON_COHERENT = 0x2, 6773 } FORCE_NON_COHERENT; 6774 typedef enum tagFAST_CLEAR_DISABLED_ON_COMPRESSED_SURFACE { 6775 FAST_CLEAR_DISABLED_ON_COMPRESSED_SURFACE_ENABLED = 0x0, 6776 FAST_CLEAR_DISABLED_ON_COMPRESSED_SURFACE_DISABLED = 0x1, 6777 } FAST_CLEAR_DISABLED_ON_COMPRESSED_SURFACE; 6778 typedef enum tagDISABLE_SLM_READ_MERGE_OPTIMIZATION { 6779 DISABLE_SLM_READ_MERGE_OPTIMIZATION_ENABLED = 0x0, 6780 DISABLE_SLM_READ_MERGE_OPTIMIZATION_DISABLED = 0x1, 6781 } DISABLE_SLM_READ_MERGE_OPTIMIZATION; 6782 typedef enum tagDISABLE_ATOMIC_ON_CLEAR_DATA { 6783 DISABLE_ATOMIC_ON_CLEAR_DATA_ENABLE = 0x0, 6784 DISABLE_ATOMIC_ON_CLEAR_DATA_DISABLE = 0x1, 6785 } DISABLE_ATOMIC_ON_CLEAR_DATA; 6786 inline void init() { 6787 memset(&TheStructure, 0, sizeof(TheStructure)); 6788 TheStructure.Common.DwordLength = DWORD_LENGTH_EXCLUDES_DWORD_0_1; 6789 TheStructure.Common._3DCommandSubOpcode = _3D_COMMAND_SUB_OPCODE_STATE_COMPUTE_MODE; 6790 TheStructure.Common._3DCommandOpcode = _3D_COMMAND_OPCODE_GFXPIPE_NONPIPELINED; 6791 TheStructure.Common.CommandSubtype = COMMAND_SUBTYPE_GFXPIPE_COMMON; 6792 TheStructure.Common.CommandType = COMMAND_TYPE_GFXPIPE; 6793 TheStructure.Common.ForceNonCoherent = FORCE_NON_COHERENT_FORCE_DISABLED; 6794 TheStructure.Common.FastClearDisabledOnCompressedSurface = FAST_CLEAR_DISABLED_ON_COMPRESSED_SURFACE_ENABLED; 6795 TheStructure.Common.DisableSlmReadMergeOptimization = DISABLE_SLM_READ_MERGE_OPTIMIZATION_ENABLED; 6796 TheStructure.Common.DisableAtomicOnClearData = DISABLE_ATOMIC_ON_CLEAR_DATA_ENABLE; 6797 } 6798 static tagSTATE_COMPUTE_MODE sInit() { 6799 STATE_COMPUTE_MODE state; 6800 state.init(); 6801 return state; 6802 } 6803 inline uint32_t &getRawData(const uint32_t index) { 6804 UNRECOVERABLE_IF(index >= 2); 6805 return TheStructure.RawData[index]; 6806 } 6807 inline void setDisableSupportForMultiGpuFence(const bool value) { 6808 TheStructure.Common.DisableSupportForMultiGpuFence = value; 6809 } 6810 inline bool getDisableSupportForMultiGpuFence() const { 6811 return TheStructure.Common.DisableSupportForMultiGpuFence; 6812 } 6813 inline void setForceDisableSupportForMultiGpuAtomics(const bool value) { 6814 TheStructure.Common.ForceDisableSupportForMultiGpuAtomics = value; 6815 } 6816 inline bool getForceDisableSupportForMultiGpuAtomics() const { 6817 return TheStructure.Common.ForceDisableSupportForMultiGpuAtomics; 6818 } 6819 inline void setForceDisableSupportForMultiGpuPartialWrites(const bool value) { 6820 TheStructure.Common.ForceDisableSupportForMultiGpuPartialWrites = value; 6821 } 6822 inline bool getForceDisableSupportForMultiGpuPartialWrites() const { 6823 return TheStructure.Common.ForceDisableSupportForMultiGpuPartialWrites; 6824 } 6825 inline void setForceNonCoherent(const FORCE_NON_COHERENT value) { 6826 TheStructure.Common.ForceNonCoherent = value; 6827 } 6828 inline FORCE_NON_COHERENT getForceNonCoherent() const { 6829 return static_cast<FORCE_NON_COHERENT>(TheStructure.Common.ForceNonCoherent); 6830 } 6831 inline void setFastClearDisabledOnCompressedSurface(const FAST_CLEAR_DISABLED_ON_COMPRESSED_SURFACE value) { 6832 TheStructure.Common.FastClearDisabledOnCompressedSurface = value; 6833 } 6834 inline FAST_CLEAR_DISABLED_ON_COMPRESSED_SURFACE getFastClearDisabledOnCompressedSurface() const { 6835 return static_cast<FAST_CLEAR_DISABLED_ON_COMPRESSED_SURFACE>(TheStructure.Common.FastClearDisabledOnCompressedSurface); 6836 } 6837 inline void setDisableSlmReadMergeOptimization(const DISABLE_SLM_READ_MERGE_OPTIMIZATION value) { 6838 TheStructure.Common.DisableSlmReadMergeOptimization = value; 6839 } 6840 inline DISABLE_SLM_READ_MERGE_OPTIMIZATION getDisableSlmReadMergeOptimization() const { 6841 return static_cast<DISABLE_SLM_READ_MERGE_OPTIMIZATION>(TheStructure.Common.DisableSlmReadMergeOptimization); 6842 } 6843 inline void setDisableAtomicOnClearData(const DISABLE_ATOMIC_ON_CLEAR_DATA value) { 6844 TheStructure.Common.DisableAtomicOnClearData = value; 6845 } 6846 inline DISABLE_ATOMIC_ON_CLEAR_DATA getDisableAtomicOnClearData() const { 6847 return static_cast<DISABLE_ATOMIC_ON_CLEAR_DATA>(TheStructure.Common.DisableAtomicOnClearData); 6848 } 6849 inline void setDisableL1InvalidateForNonL1CacheableWrites(const bool value) { 6850 TheStructure.Common.DisableL1InvalidateForNonL1CacheableWrites = value; 6851 } 6852 inline bool getDisableL1InvalidateForNonL1CacheableWrites() const { 6853 return TheStructure.Common.DisableL1InvalidateForNonL1CacheableWrites; 6854 } 6855 inline void setLargeGrfMode(const bool value) { 6856 TheStructure.Common.LargeGrfMode = value; 6857 } 6858 inline bool getLargeGrfMode() const { 6859 return TheStructure.Common.LargeGrfMode; 6860 } 6861 inline void setMaskBits(const uint32_t value) { 6862 UNRECOVERABLE_IF(value > 0xffff); 6863 TheStructure.Common.MaskBits = value; 6864 } 6865 inline uint32_t getMaskBits() const { 6866 return TheStructure.Common.MaskBits; 6867 } 6868} STATE_COMPUTE_MODE; 6869STATIC_ASSERT(8 == sizeof(STATE_COMPUTE_MODE)); 6870 6871typedef struct tag_3DSTATE_BINDING_TABLE_POOL_ALLOC { 6872 union tagTheStructure { 6873 struct tagCommon { 6874 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 6875 uint32_t Reserved_8 : BITFIELD_RANGE(8, 15); 6876 uint32_t _3DCommandSubOpcode : BITFIELD_RANGE(16, 23); 6877 uint32_t _3DCommandOpcode : BITFIELD_RANGE(24, 26); 6878 uint32_t CommandSubtype : BITFIELD_RANGE(27, 28); 6879 uint32_t CommandType : BITFIELD_RANGE(29, 31); 6880 uint64_t SurfaceObjectControlStateEncryptedData : BITFIELD_RANGE(0, 0); 6881 uint64_t SurfaceObjectControlStateIndexToMocsTables : BITFIELD_RANGE(1, 6); 6882 uint64_t Reserved_39 : BITFIELD_RANGE(7, 9); 6883 uint64_t Reserved_42 : BITFIELD_RANGE(10, 10); 6884 uint64_t Reserved_43 : BITFIELD_RANGE(11, 11); 6885 uint64_t BindingTablePoolBaseAddress : BITFIELD_RANGE(12, 47); 6886 uint64_t BindingTablePoolBaseAddressReserved_80 : BITFIELD_RANGE(48, 63); 6887 uint32_t Reserved_96 : BITFIELD_RANGE(0, 11); 6888 uint32_t BindingTablePoolBufferSize : BITFIELD_RANGE(12, 31); 6889 } Common; 6890 uint32_t RawData[4]; 6891 } TheStructure; 6892 typedef enum tagDWORD_LENGTH { 6893 DWORD_LENGTH_DWORD_COUNT_N = 0x2, 6894 } DWORD_LENGTH; 6895 typedef enum tag_3D_COMMAND_SUB_OPCODE { 6896 _3D_COMMAND_SUB_OPCODE_3DSTATE_BINDING_TABLE_POOL_ALLOC = 0x19, 6897 } _3D_COMMAND_SUB_OPCODE; 6898 typedef enum tag_3D_COMMAND_OPCODE { 6899 _3D_COMMAND_OPCODE_3DSTATE_NONPIPELINED = 0x1, 6900 } _3D_COMMAND_OPCODE; 6901 typedef enum tagCOMMAND_SUBTYPE { 6902 COMMAND_SUBTYPE_GFXPIPE_3D = 0x3, 6903 } COMMAND_SUBTYPE; 6904 typedef enum tagCOMMAND_TYPE { 6905 COMMAND_TYPE_GFXPIPE = 0x3, 6906 } COMMAND_TYPE; 6907 6908 inline void init() { 6909 memset(&TheStructure, 0, sizeof(TheStructure)); 6910 TheStructure.Common.DwordLength = DWORD_LENGTH_DWORD_COUNT_N; 6911 TheStructure.Common._3DCommandSubOpcode = _3D_COMMAND_SUB_OPCODE_3DSTATE_BINDING_TABLE_POOL_ALLOC; 6912 TheStructure.Common._3DCommandOpcode = _3D_COMMAND_OPCODE_3DSTATE_NONPIPELINED; 6913 TheStructure.Common.CommandSubtype = COMMAND_SUBTYPE_GFXPIPE_3D; 6914 TheStructure.Common.CommandType = COMMAND_TYPE_GFXPIPE; 6915 TheStructure.Common.BindingTablePoolBufferSize = 0; 6916 } 6917 static tag_3DSTATE_BINDING_TABLE_POOL_ALLOC sInit() { 6918 _3DSTATE_BINDING_TABLE_POOL_ALLOC state; 6919 state.init(); 6920 return state; 6921 } 6922 inline uint32_t &getRawData(const uint32_t index) { 6923 UNRECOVERABLE_IF(index >= 4); 6924 return TheStructure.RawData[index]; 6925 } 6926 inline void setSurfaceObjectControlStateEncryptedData(const bool value) { 6927 TheStructure.Common.SurfaceObjectControlStateEncryptedData = value; 6928 } 6929 inline bool getSurfaceObjectControlStateEncryptedData() const { 6930 return TheStructure.Common.SurfaceObjectControlStateEncryptedData; 6931 } 6932 inline void setSurfaceObjectControlStateIndexToMocsTables(const uint64_t value) { 6933 UNRECOVERABLE_IF(value > 0x7eL); 6934 TheStructure.Common.SurfaceObjectControlStateIndexToMocsTables = value >> 1; 6935 } 6936 inline uint64_t getSurfaceObjectControlStateIndexToMocsTables() const { 6937 return (TheStructure.Common.SurfaceObjectControlStateIndexToMocsTables << 1); 6938 } 6939 typedef enum tagBINDINGTABLEPOOLBASEADDRESS { 6940 BINDINGTABLEPOOLBASEADDRESS_BIT_SHIFT = 0xc, 6941 BINDINGTABLEPOOLBASEADDRESS_ALIGN_SIZE = 0x1000, 6942 } BINDINGTABLEPOOLBASEADDRESS; 6943 inline void setBindingTablePoolBaseAddress(const uint64_t value) { 6944 TheStructure.Common.BindingTablePoolBaseAddress = value >> BINDINGTABLEPOOLBASEADDRESS_BIT_SHIFT; 6945 } 6946 inline uint64_t getBindingTablePoolBaseAddress() const { 6947 return TheStructure.Common.BindingTablePoolBaseAddress << BINDINGTABLEPOOLBASEADDRESS_BIT_SHIFT; 6948 } 6949 inline void setBindingTablePoolBufferSize(const uint32_t value) { TheStructure.Common.BindingTablePoolBufferSize = value; } 6950 inline uint32_t getBindingTablePoolBufferSize() const { return TheStructure.Common.BindingTablePoolBufferSize; } 6951} _3DSTATE_BINDING_TABLE_POOL_ALLOC; 6952STATIC_ASSERT(16 == sizeof(_3DSTATE_BINDING_TABLE_POOL_ALLOC)); 6953 6954typedef struct tagL3_FLUSH_ADDRESS_RANGE { 6955 union tagTheStructure { 6956 struct tagCommon { 6957 uint64_t Reserved_0 : BITFIELD_RANGE(0, 2); 6958 uint64_t AddressMask : BITFIELD_RANGE(3, 8); 6959 uint64_t Reserved_9 : BITFIELD_RANGE(9, 11); 6960 uint64_t AddressLow : BITFIELD_RANGE(12, 31); 6961 uint64_t AddressHigh : BITFIELD_RANGE(32, 47); 6962 uint64_t Reserved_48 : BITFIELD_RANGE(48, 59); 6963 uint64_t L3FlushEvictionPolicy : BITFIELD_RANGE(60, 61); 6964 uint64_t Reserved_62 : BITFIELD_RANGE(62, 63); 6965 } Common; 6966 uint32_t RawData[2]; 6967 } TheStructure; 6968 typedef enum tagL3_FLUSH_EVICTION_POLICY { 6969 L3_FLUSH_EVICTION_POLICY_FLUSH_L3_WITH_EVICTION = 0x0, 6970 L3_FLUSH_EVICTION_POLICY_FLUSH_L3_WITH_OUT_EVICTION = 0x1, 6971 L3_FLUSH_EVICTION_POLICY_DISCARD = 0x2, 6972 } L3_FLUSH_EVICTION_POLICY; 6973 inline void init() { 6974 memset(&TheStructure, 0, sizeof(TheStructure)); 6975 TheStructure.Common.L3FlushEvictionPolicy = L3_FLUSH_EVICTION_POLICY_FLUSH_L3_WITH_EVICTION; 6976 } 6977 static tagL3_FLUSH_ADDRESS_RANGE sInit() { 6978 L3_FLUSH_ADDRESS_RANGE state; 6979 state.init(); 6980 return state; 6981 } 6982 inline uint32_t &getRawData(const uint32_t index) { 6983 UNRECOVERABLE_IF(index >= 2); 6984 return TheStructure.RawData[index]; 6985 } 6986 6987 typedef enum tagADDRESSLOW { 6988 ADDRESSLOW_BIT_SHIFT = 0xC, 6989 ADDRESSLOW_ALIGN_SIZE = 0x1000, 6990 } ADDRESSLOW; 6991 6992 inline void setAddressLow(const uint64_t value) { 6993 TheStructure.Common.AddressLow = value >> ADDRESSLOW_BIT_SHIFT; 6994 } 6995 6996 inline uint64_t getAddressLow() const { 6997 return (TheStructure.Common.AddressLow << ADDRESSLOW_BIT_SHIFT); 6998 } 6999 7000 inline void setAddressHigh(const uint64_t value) { 7001 TheStructure.Common.AddressHigh = value; 7002 } 7003 7004 inline uint64_t getAddressHigh() const { 7005 return (TheStructure.Common.AddressHigh); 7006 } 7007 7008 inline void setAddress(const uint64_t value) { 7009 setAddressLow(static_cast<uint32_t>(value)); 7010 setAddressHigh(static_cast<uint32_t>(value >> 32)); 7011 } 7012 7013 inline uint64_t getAddress() const { 7014 return static_cast<uint64_t>(getAddressLow()) | (static_cast<uint64_t>(getAddressHigh()) << 32); 7015 } 7016 7017 inline void setL3FlushEvictionPolicy(const L3_FLUSH_EVICTION_POLICY value) { 7018 TheStructure.Common.L3FlushEvictionPolicy = value; 7019 } 7020 inline L3_FLUSH_EVICTION_POLICY getL3FlushEvictionPolicy() const { 7021 return static_cast<L3_FLUSH_EVICTION_POLICY>(TheStructure.Common.L3FlushEvictionPolicy); 7022 } 7023 inline void setAddressMask(const uint64_t value) { 7024 UNRECOVERABLE_IF(value > 0x1f8); 7025 TheStructure.Common.AddressMask = value; 7026 } 7027 inline uint32_t getAddressMask() const { 7028 return TheStructure.Common.AddressMask; 7029 } 7030} L3_FLUSH_ADDRESS_RANGE; 7031STATIC_ASSERT(8 == sizeof(L3_FLUSH_ADDRESS_RANGE)); 7032 7033struct L3_CONTROL_POST_SYNC_DATA { 7034 union tagTheStructure { 7035 struct tagCommon { 7036 uint64_t Reserved_96 : BITFIELD_RANGE(0, 2); 7037 uint64_t Address : BITFIELD_RANGE(3, 47); 7038 uint64_t Reserved_144 : BITFIELD_RANGE(48, 63); 7039 uint64_t ImmediateData; 7040 } Common; 7041 uint32_t RawData[4]; 7042 } TheStructure; 7043 7044 inline void init() { 7045 memset(&TheStructure, 0, sizeof(TheStructure)); 7046 } 7047 7048 typedef enum tagADDRESS { 7049 ADDRESS_BIT_SHIFT = 0x3, 7050 ADDRESS_ALIGN_SIZE = 0x8, 7051 } ADDRESS; 7052 inline void setAddress(const uint64_t value) { 7053 TheStructure.Common.Address = value >> ADDRESS_BIT_SHIFT; 7054 } 7055 inline uint64_t getAddress() const { 7056 return TheStructure.Common.Address << ADDRESS_BIT_SHIFT; 7057 } 7058 inline void setImmediateData(const uint64_t value) { 7059 TheStructure.Common.ImmediateData = value; 7060 } 7061 inline uint64_t getImmediateData() const { 7062 return TheStructure.Common.ImmediateData; 7063 } 7064}; 7065 7066struct L3_CONTROL { 7067 union tagTheStructure { 7068 struct tagCommon { 7069 uint32_t Length : BITFIELD_RANGE(0, 7); 7070 uint32_t DepthCacheFlush : BITFIELD_RANGE(8, 8); 7071 uint32_t RenderTargetCacheFlushEnable : BITFIELD_RANGE(9, 9); 7072 uint32_t HdcPipelineFlush : BITFIELD_RANGE(10, 10); 7073 uint32_t Reserved_11 : BITFIELD_RANGE(11, 13); 7074 uint32_t PostSyncOperation : BITFIELD_RANGE(14, 14); 7075 uint32_t PostSyncOperationL3CacheabilityControl : BITFIELD_RANGE(15, 15); // removed on DG1 7076 uint32_t Reserved_16 : BITFIELD_RANGE(16, 19); 7077 uint32_t CommandStreamerStallEnable : BITFIELD_RANGE(20, 20); 7078 uint32_t DestinationAddressType : BITFIELD_RANGE(21, 21); 7079 uint32_t Reserved_22 : BITFIELD_RANGE(22, 22); 7080 uint32_t _3DCommandSubOpcode : BITFIELD_RANGE(23, 23); 7081 uint32_t _3DCommandOpcode : BITFIELD_RANGE(24, 26); 7082 uint32_t CommandSubtype : BITFIELD_RANGE(27, 28); 7083 uint32_t Type : BITFIELD_RANGE(29, 31); 7084 L3_CONTROL_POST_SYNC_DATA PostSyncData; 7085 } Common; 7086 uint32_t RawData[5]; 7087 } TheStructure; 7088 7089 typedef enum tagRENDER_TARGET_CACHE_FLUSH_ENABLE { 7090 RENDER_TARGET_CACHE_FLUSH_DISABLED = 0x0, 7091 RENDER_TARGET_CACHE_FLUSH_ENABLED = 0x1, 7092 } RENDER_TARGET_CACHE_FLUSH_ENABLE; 7093 typedef enum tagPOST_SYNC_OPERATION { 7094 POST_SYNC_OPERATION_NO_WRITE = 0x0, 7095 POST_SYNC_OPERATION_WRITE_IMMEDIATE_DATA = 0x1, 7096 } POST_SYNC_OPERATION; 7097 typedef enum tagPOST_SYNC_OPERATION_L3_CACHEABILITY_CONTROL { 7098 POST_SYNC_OPERATION_L3_CACHEABILITY_CONTROL_DEFAULT_MOCS = 0x0, 7099 POST_SYNC_OPERATION_L3_CACHEABILITY_CONTROL_CACHEABLE_MOCS = 0x1, 7100 } POST_SYNC_OPERATION_L3_CACHEABILITY_CONTROL; 7101 typedef enum tagDESTINATION_ADDRESS_TYPE { 7102 DESTINATION_ADDRESS_TYPE_PPGTT = 0x0, 7103 DESTINATION_ADDRESS_TYPE_GGTT = 0x1, 7104 } DESTINATION_ADDRESS_TYPE; 7105 typedef enum tag_3D_COMMAND_SUB_OPCODE { 7106 _3D_COMMAND_SUB_OPCODE_L3_CONTROL = 0x1, 7107 } _3D_COMMAND_SUB_OPCODE; 7108 typedef enum tag_3D_COMMAND_OPCODE { 7109 _3D_COMMAND_OPCODE_L3_CONTROL = 0x5, 7110 } _3D_COMMAND_OPCODE; 7111 typedef enum tagCOMMAND_SUBTYPE { 7112 COMMAND_SUBTYPE_GFXPIPE_3D = 0x3, 7113 } COMMAND_SUBTYPE; 7114 typedef enum tagTYPE { 7115 TYPE_GFXPIPE = 0x3, 7116 } TYPE; 7117 inline void init() { 7118 memset(&TheStructure, 0, sizeof(TheStructure)); 7119 TheStructure.Common.RenderTargetCacheFlushEnable = RENDER_TARGET_CACHE_FLUSH_ENABLED; 7120 TheStructure.Common.PostSyncOperation = POST_SYNC_OPERATION_NO_WRITE; 7121 TheStructure.Common.PostSyncOperationL3CacheabilityControl = POST_SYNC_OPERATION_L3_CACHEABILITY_CONTROL_DEFAULT_MOCS; 7122 TheStructure.Common.DestinationAddressType = DESTINATION_ADDRESS_TYPE_PPGTT; 7123 TheStructure.Common._3DCommandSubOpcode = _3D_COMMAND_SUB_OPCODE_L3_CONTROL; 7124 TheStructure.Common._3DCommandOpcode = _3D_COMMAND_OPCODE_L3_CONTROL; 7125 TheStructure.Common.CommandSubtype = COMMAND_SUBTYPE_GFXPIPE_3D; 7126 TheStructure.Common.Type = TYPE_GFXPIPE; 7127 TheStructure.Common.PostSyncData.init(); 7128 } 7129 static L3_CONTROL sInit() { 7130 L3_CONTROL state; 7131 state.init(); 7132 return state; 7133 } 7134 inline uint32_t &getRawData(const uint32_t index) { 7135 UNRECOVERABLE_IF(index >= 7); 7136 return TheStructure.RawData[index]; 7137 } 7138 inline void setLength(const uint32_t value) { 7139 TheStructure.Common.Length = value; 7140 } 7141 inline uint32_t getLength() const { 7142 return TheStructure.Common.Length; 7143 } 7144 inline void setDepthCacheFlush(const bool value) { 7145 TheStructure.Common.DepthCacheFlush = value; 7146 } 7147 inline bool getDepthCacheFlush() const { 7148 return TheStructure.Common.DepthCacheFlush; 7149 } 7150 inline void setRenderTargetCacheFlushEnable(const bool value) { 7151 TheStructure.Common.RenderTargetCacheFlushEnable = value; 7152 } 7153 inline bool getRenderTargetCacheFlushEnable() const { 7154 return TheStructure.Common.RenderTargetCacheFlushEnable; 7155 } 7156 inline void setHdcPipelineFlush(const bool value) { 7157 TheStructure.Common.HdcPipelineFlush = value; 7158 } 7159 inline bool getHdcPipelineFlush() const { 7160 return TheStructure.Common.HdcPipelineFlush; 7161 } 7162 inline void setPostSyncOperation(const POST_SYNC_OPERATION value) { 7163 TheStructure.Common.PostSyncOperation = value; 7164 } 7165 inline POST_SYNC_OPERATION getPostSyncOperation() const { 7166 return static_cast<POST_SYNC_OPERATION>(TheStructure.Common.PostSyncOperation); 7167 } 7168 inline void setPostSyncOperationL3CacheabilityControl(const POST_SYNC_OPERATION_L3_CACHEABILITY_CONTROL value) { 7169 TheStructure.Common.PostSyncOperationL3CacheabilityControl = value; 7170 } 7171 inline POST_SYNC_OPERATION_L3_CACHEABILITY_CONTROL getPostSyncOperationL3CacheabilityControl() const { 7172 return static_cast<POST_SYNC_OPERATION_L3_CACHEABILITY_CONTROL>(TheStructure.Common.PostSyncOperationL3CacheabilityControl); 7173 } 7174 inline void setCommandStreamerStallEnable(const bool value) { 7175 TheStructure.Common.CommandStreamerStallEnable = value; 7176 } 7177 inline bool getCommandStreamerStallEnable() const { 7178 return TheStructure.Common.CommandStreamerStallEnable; 7179 } 7180 inline void setDestinationAddressType(const DESTINATION_ADDRESS_TYPE value) { 7181 TheStructure.Common.DestinationAddressType = value; 7182 } 7183 inline DESTINATION_ADDRESS_TYPE getDestinationAddressType() const { 7184 return static_cast<DESTINATION_ADDRESS_TYPE>(TheStructure.Common.DestinationAddressType); 7185 } 7186 inline void setType(const TYPE value) { 7187 TheStructure.Common.Type = value; 7188 } 7189 inline TYPE getType() const { 7190 return static_cast<TYPE>(TheStructure.Common.Type); 7191 } 7192 L3_CONTROL_POST_SYNC_DATA &getPostSyncData() { 7193 return TheStructure.Common.PostSyncData; 7194 } 7195 7196 const L3_CONTROL_POST_SYNC_DATA &getPostSyncData() const { 7197 return TheStructure.Common.PostSyncData; 7198 } 7199 7200 inline void setPostSyncAddress(const uint64_t value) { 7201 getPostSyncData().setAddress(value); 7202 } 7203 7204 inline uint64_t getPostSyncAddress() const { 7205 return getPostSyncData().getAddress(); 7206 } 7207 7208 inline void setPostSyncImmediateData(const uint64_t value) { 7209 getPostSyncData().setImmediateData(value); 7210 } 7211 7212 inline uint64_t getPostSyncImmediateData() const { 7213 return getPostSyncData().getImmediateData(); 7214 } 7215}; 7216STATIC_ASSERT(20 == sizeof(L3_CONTROL)); 7217STATIC_ASSERT(std::is_pod<L3_CONTROL>::value); 7218 7219typedef struct tagSTATE_SIP { 7220 union tagTheStructure { 7221 struct tagCommon { 7222 // DWORD 0 7223 uint32_t DwordLength : BITFIELD_RANGE(0, 7); 7224 uint32_t Reserved_8 : BITFIELD_RANGE(8, 15); 7225 uint32_t _3DCommandSubOpcode : BITFIELD_RANGE(16, 23); 7226 uint32_t _3DCommandOpcode : BITFIELD_RANGE(24, 26); 7227 uint32_t CommandSubtype : BITFIELD_RANGE(27, 28); 7228 uint32_t CommandType : BITFIELD_RANGE(29, 31); 7229 // DWORD 1 7230 uint64_t Reserved_32 : BITFIELD_RANGE(0, 3); 7231 uint64_t SystemInstructionPointer : BITFIELD_RANGE(4, 63); 7232 } Common; 7233 uint32_t RawData[3]; 7234 } TheStructure; 7235 typedef enum tagDWORD_LENGTH { 7236 DWORD_LENGTH_DWORD_COUNT_N = 0x1, 7237 } DWORD_LENGTH; 7238 typedef enum tag_3D_COMMAND_SUB_OPCODE { 7239 _3D_COMMAND_SUB_OPCODE_STATE_SIP = 0x2, 7240 } _3D_COMMAND_SUB_OPCODE; 7241 typedef enum tag_3D_COMMAND_OPCODE { 7242 _3D_COMMAND_OPCODE_GFXPIPE_NONPIPELINED = 0x1, 7243 } _3D_COMMAND_OPCODE; 7244 typedef enum tagCOMMAND_SUBTYPE { 7245 COMMAND_SUBTYPE_GFXPIPE_COMMON = 0x0, 7246 } COMMAND_SUBTYPE; 7247 typedef enum tagCOMMAND_TYPE { 7248 COMMAND_TYPE_GFXPIPE = 0x3, 7249 } COMMAND_TYPE; 7250 inline void init() { 7251 memset(&TheStructure, 0, sizeof(TheStructure)); 7252 TheStructure.Common.DwordLength = DWORD_LENGTH_DWORD_COUNT_N; 7253 TheStructure.Common._3DCommandSubOpcode = _3D_COMMAND_SUB_OPCODE_STATE_SIP; 7254 TheStructure.Common._3DCommandOpcode = _3D_COMMAND_OPCODE_GFXPIPE_NONPIPELINED; 7255 TheStructure.Common.CommandSubtype = COMMAND_SUBTYPE_GFXPIPE_COMMON; 7256 TheStructure.Common.CommandType = COMMAND_TYPE_GFXPIPE; 7257 } 7258 static tagSTATE_SIP sInit() { 7259 STATE_SIP state; 7260 state.init(); 7261 return state; 7262 } 7263 inline uint32_t &getRawData(const uint32_t index) { 7264 UNRECOVERABLE_IF(index >= 3); 7265 return TheStructure.RawData[index]; 7266 } 7267 typedef enum tagSYSTEMINSTRUCTIONPOINTER { 7268 SYSTEMINSTRUCTIONPOINTER_BIT_SHIFT = 0x4, 7269 SYSTEMINSTRUCTIONPOINTER_ALIGN_SIZE = 0x10, 7270 } SYSTEMINSTRUCTIONPOINTER; 7271 inline void setSystemInstructionPointer(const uint64_t value) { 7272 UNRECOVERABLE_IF(value > 0xffffffffffffffffL); 7273 TheStructure.Common.SystemInstructionPointer = value >> SYSTEMINSTRUCTIONPOINTER_BIT_SHIFT; 7274 } 7275 inline uint64_t getSystemInstructionPointer() const { 7276 return TheStructure.Common.SystemInstructionPointer << SYSTEMINSTRUCTIONPOINTER_BIT_SHIFT; 7277 } 7278} STATE_SIP; 7279STATIC_ASSERT(12 == sizeof(STATE_SIP)); 7280 7281typedef struct tagSAMPLER_BORDER_COLOR_STATE { 7282 union tagTheStructure { 7283 struct tagCommon { 7284 // DWORD 0 7285 float BorderColorRed; 7286 // DWORD 1 7287 float BorderColorGreen; 7288 // DWORD 2 7289 float BorderColorBlue; 7290 // DWORD 3 7291 float BorderColorAlpha; 7292 } Common; 7293 uint32_t RawData[4]; 7294 } TheStructure; 7295 inline void init() { 7296 memset(&TheStructure, 0, sizeof(TheStructure)); 7297 TheStructure.Common.BorderColorRed = 0.0; 7298 TheStructure.Common.BorderColorGreen = 0.0; 7299 TheStructure.Common.BorderColorBlue = 0.0; 7300 TheStructure.Common.BorderColorAlpha = 0.0; 7301 } 7302 static tagSAMPLER_BORDER_COLOR_STATE sInit() { 7303 SAMPLER_BORDER_COLOR_STATE state; 7304 state.init(); 7305 return state; 7306 } 7307 inline uint32_t &getRawData(const uint32_t index) { 7308 UNRECOVERABLE_IF(index >= 4); 7309 return TheStructure.RawData[index]; 7310 } 7311 inline void setBorderColorRed(const float value) { 7312 TheStructure.Common.BorderColorRed = value; 7313 } 7314 inline float getBorderColorRed() const { 7315 return TheStructure.Common.BorderColorRed; 7316 } 7317 inline void setBorderColorGreen(const float value) { 7318 TheStructure.Common.BorderColorGreen = value; 7319 } 7320 inline float getBorderColorGreen() const { 7321 return TheStructure.Common.BorderColorGreen; 7322 } 7323 inline void setBorderColorBlue(const float value) { 7324 TheStructure.Common.BorderColorBlue = value; 7325 } 7326 inline float getBorderColorBlue() const { 7327 return TheStructure.Common.BorderColorBlue; 7328 } 7329 inline void setBorderColorAlpha(const float value) { 7330 TheStructure.Common.BorderColorAlpha = value; 7331 } 7332 inline float getBorderColorAlpha() const { 7333 return TheStructure.Common.BorderColorAlpha; 7334 } 7335} SAMPLER_BORDER_COLOR_STATE; 7336STATIC_ASSERT(16 == sizeof(SAMPLER_BORDER_COLOR_STATE)); 7337 7338#pragma pack() 7339