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