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