gen8_pack.h revision b8e80941
1/* 2 * Copyright (C) 2016 Intel Corporation 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a 5 * copy of this software and associated documentation files (the "Software"), 6 * to deal in the Software without restriction, including without limitation 7 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 * and/or sell copies of the Software, and to permit persons to whom the 9 * Software is furnished to do so, subject to the following conditions: 10 * 11 * The above copyright notice and this permission notice (including the next 12 * paragraph) shall be included in all copies or substantial portions of the 13 * Software. 14 * 15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS 21 * IN THE SOFTWARE. 22 */ 23 24 25/* Instructions, enums and structures for BDW. 26 * 27 * This file has been generated, do not hand edit. 28 */ 29 30#ifndef GEN8_PACK_H 31#define GEN8_PACK_H 32 33#include <stdio.h> 34#include <stdint.h> 35#include <stdbool.h> 36#include <assert.h> 37#include <math.h> 38 39#ifndef __gen_validate_value 40#define __gen_validate_value(x) 41#endif 42 43#ifndef __gen_field_functions 44#define __gen_field_functions 45 46#ifdef NDEBUG 47#define NDEBUG_UNUSED __attribute__((unused)) 48#else 49#define NDEBUG_UNUSED 50#endif 51 52union __gen_value { 53 float f; 54 uint32_t dw; 55}; 56 57static inline uint64_t 58__gen_mbo(uint32_t start, uint32_t end) 59{ 60 return (~0ull >> (64 - (end - start + 1))) << start; 61} 62 63static inline uint64_t 64__gen_uint(uint64_t v, uint32_t start, NDEBUG_UNUSED uint32_t end) 65{ 66 __gen_validate_value(v); 67 68#ifndef NDEBUG 69 const int width = end - start + 1; 70 if (width < 64) { 71 const uint64_t max = (1ull << width) - 1; 72 assert(v <= max); 73 } 74#endif 75 76 return v << start; 77} 78 79static inline uint64_t 80__gen_sint(int64_t v, uint32_t start, uint32_t end) 81{ 82 const int width = end - start + 1; 83 84 __gen_validate_value(v); 85 86#ifndef NDEBUG 87 if (width < 64) { 88 const int64_t max = (1ll << (width - 1)) - 1; 89 const int64_t min = -(1ll << (width - 1)); 90 assert(min <= v && v <= max); 91 } 92#endif 93 94 const uint64_t mask = ~0ull >> (64 - width); 95 96 return (v & mask) << start; 97} 98 99static inline uint64_t 100__gen_offset(uint64_t v, NDEBUG_UNUSED uint32_t start, NDEBUG_UNUSED uint32_t end) 101{ 102 __gen_validate_value(v); 103#ifndef NDEBUG 104 uint64_t mask = (~0ull >> (64 - (end - start + 1))) << start; 105 106 assert((v & ~mask) == 0); 107#endif 108 109 return v; 110} 111 112static inline uint32_t 113__gen_float(float v) 114{ 115 __gen_validate_value(v); 116 return ((union __gen_value) { .f = (v) }).dw; 117} 118 119static inline uint64_t 120__gen_sfixed(float v, uint32_t start, uint32_t end, uint32_t fract_bits) 121{ 122 __gen_validate_value(v); 123 124 const float factor = (1 << fract_bits); 125 126#ifndef NDEBUG 127 const float max = ((1 << (end - start)) - 1) / factor; 128 const float min = -(1 << (end - start)) / factor; 129 assert(min <= v && v <= max); 130#endif 131 132 const int64_t int_val = llroundf(v * factor); 133 const uint64_t mask = ~0ull >> (64 - (end - start + 1)); 134 135 return (int_val & mask) << start; 136} 137 138static inline uint64_t 139__gen_ufixed(float v, uint32_t start, NDEBUG_UNUSED uint32_t end, uint32_t fract_bits) 140{ 141 __gen_validate_value(v); 142 143 const float factor = (1 << fract_bits); 144 145#ifndef NDEBUG 146 const float max = ((1 << (end - start + 1)) - 1) / factor; 147 const float min = 0.0f; 148 assert(min <= v && v <= max); 149#endif 150 151 const uint64_t uint_val = llroundf(v * factor); 152 153 return uint_val << start; 154} 155 156#ifndef __gen_address_type 157#error #define __gen_address_type before including this file 158#endif 159 160#ifndef __gen_user_data 161#error #define __gen_combine_address before including this file 162#endif 163 164#undef NDEBUG_UNUSED 165 166#endif 167 168 169enum GEN8_3D_Color_Buffer_Blend_Factor { 170 BLENDFACTOR_ONE = 1, 171 BLENDFACTOR_SRC_COLOR = 2, 172 BLENDFACTOR_SRC_ALPHA = 3, 173 BLENDFACTOR_DST_ALPHA = 4, 174 BLENDFACTOR_DST_COLOR = 5, 175 BLENDFACTOR_SRC_ALPHA_SATURATE = 6, 176 BLENDFACTOR_CONST_COLOR = 7, 177 BLENDFACTOR_CONST_ALPHA = 8, 178 BLENDFACTOR_SRC1_COLOR = 9, 179 BLENDFACTOR_SRC1_ALPHA = 10, 180 BLENDFACTOR_ZERO = 17, 181 BLENDFACTOR_INV_SRC_COLOR = 18, 182 BLENDFACTOR_INV_SRC_ALPHA = 19, 183 BLENDFACTOR_INV_DST_ALPHA = 20, 184 BLENDFACTOR_INV_DST_COLOR = 21, 185 BLENDFACTOR_INV_CONST_COLOR = 23, 186 BLENDFACTOR_INV_CONST_ALPHA = 24, 187 BLENDFACTOR_INV_SRC1_COLOR = 25, 188 BLENDFACTOR_INV_SRC1_ALPHA = 26, 189}; 190 191enum GEN8_3D_Color_Buffer_Blend_Function { 192 BLENDFUNCTION_ADD = 0, 193 BLENDFUNCTION_SUBTRACT = 1, 194 BLENDFUNCTION_REVERSE_SUBTRACT = 2, 195 BLENDFUNCTION_MIN = 3, 196 BLENDFUNCTION_MAX = 4, 197}; 198 199enum GEN8_3D_Compare_Function { 200 COMPAREFUNCTION_ALWAYS = 0, 201 COMPAREFUNCTION_NEVER = 1, 202 COMPAREFUNCTION_LESS = 2, 203 COMPAREFUNCTION_EQUAL = 3, 204 COMPAREFUNCTION_LEQUAL = 4, 205 COMPAREFUNCTION_GREATER = 5, 206 COMPAREFUNCTION_NOTEQUAL = 6, 207 COMPAREFUNCTION_GEQUAL = 7, 208}; 209 210enum GEN8_3D_Logic_Op_Function { 211 LOGICOP_CLEAR = 0, 212 LOGICOP_NOR = 1, 213 LOGICOP_AND_INVERTED = 2, 214 LOGICOP_COPY_INVERTED = 3, 215 LOGICOP_AND_REVERSE = 4, 216 LOGICOP_INVERT = 5, 217 LOGICOP_XOR = 6, 218 LOGICOP_NAND = 7, 219 LOGICOP_AND = 8, 220 LOGICOP_EQUIV = 9, 221 LOGICOP_NOOP = 10, 222 LOGICOP_OR_INVERTED = 11, 223 LOGICOP_COPY = 12, 224 LOGICOP_OR_REVERSE = 13, 225 LOGICOP_OR = 14, 226 LOGICOP_SET = 15, 227}; 228 229enum GEN8_3D_Prim_Topo_Type { 230 _3DPRIM_POINTLIST = 1, 231 _3DPRIM_LINELIST = 2, 232 _3DPRIM_LINESTRIP = 3, 233 _3DPRIM_TRILIST = 4, 234 _3DPRIM_TRISTRIP = 5, 235 _3DPRIM_TRIFAN = 6, 236 _3DPRIM_QUADLIST = 7, 237 _3DPRIM_QUADSTRIP = 8, 238 _3DPRIM_LINELIST_ADJ = 9, 239 _3DPRIM_LINESTRIP_ADJ = 10, 240 _3DPRIM_TRILIST_ADJ = 11, 241 _3DPRIM_TRISTRIP_ADJ = 12, 242 _3DPRIM_TRISTRIP_REVERSE = 13, 243 _3DPRIM_POLYGON = 14, 244 _3DPRIM_RECTLIST = 15, 245 _3DPRIM_LINELOOP = 16, 246 _3DPRIM_POINTLIST_BF = 17, 247 _3DPRIM_LINESTRIP_CONT = 18, 248 _3DPRIM_LINESTRIP_BF = 19, 249 _3DPRIM_LINESTRIP_CONT_BF = 20, 250 _3DPRIM_TRIFAN_NOSTIPPLE = 22, 251 _3DPRIM_PATCHLIST_1 = 32, 252 _3DPRIM_PATCHLIST_2 = 33, 253 _3DPRIM_PATCHLIST_3 = 34, 254 _3DPRIM_PATCHLIST_4 = 35, 255 _3DPRIM_PATCHLIST_5 = 36, 256 _3DPRIM_PATCHLIST_6 = 37, 257 _3DPRIM_PATCHLIST_7 = 38, 258 _3DPRIM_PATCHLIST_8 = 39, 259 _3DPRIM_PATCHLIST_9 = 40, 260 _3DPRIM_PATCHLIST_10 = 41, 261 _3DPRIM_PATCHLIST_11 = 42, 262 _3DPRIM_PATCHLIST_12 = 43, 263 _3DPRIM_PATCHLIST_13 = 44, 264 _3DPRIM_PATCHLIST_14 = 45, 265 _3DPRIM_PATCHLIST_15 = 46, 266 _3DPRIM_PATCHLIST_16 = 47, 267 _3DPRIM_PATCHLIST_17 = 48, 268 _3DPRIM_PATCHLIST_18 = 49, 269 _3DPRIM_PATCHLIST_19 = 50, 270 _3DPRIM_PATCHLIST_20 = 51, 271 _3DPRIM_PATCHLIST_21 = 52, 272 _3DPRIM_PATCHLIST_22 = 53, 273 _3DPRIM_PATCHLIST_23 = 54, 274 _3DPRIM_PATCHLIST_24 = 55, 275 _3DPRIM_PATCHLIST_25 = 56, 276 _3DPRIM_PATCHLIST_26 = 57, 277 _3DPRIM_PATCHLIST_27 = 58, 278 _3DPRIM_PATCHLIST_28 = 59, 279 _3DPRIM_PATCHLIST_29 = 60, 280 _3DPRIM_PATCHLIST_30 = 61, 281 _3DPRIM_PATCHLIST_31 = 62, 282 _3DPRIM_PATCHLIST_32 = 63, 283}; 284 285enum GEN8_3D_Stencil_Operation { 286 STENCILOP_KEEP = 0, 287 STENCILOP_ZERO = 1, 288 STENCILOP_REPLACE = 2, 289 STENCILOP_INCRSAT = 3, 290 STENCILOP_DECRSAT = 4, 291 STENCILOP_INCR = 5, 292 STENCILOP_DECR = 6, 293 STENCILOP_INVERT = 7, 294}; 295 296enum GEN8_3D_Vertex_Component_Control { 297 VFCOMP_NOSTORE = 0, 298 VFCOMP_STORE_SRC = 1, 299 VFCOMP_STORE_0 = 2, 300 VFCOMP_STORE_1_FP = 3, 301 VFCOMP_STORE_1_INT = 4, 302 VFCOMP_STORE_PID = 7, 303}; 304 305enum GEN8_ClearColor { 306 CC_ZERO = 0, 307 CC_ONE = 1, 308}; 309 310enum GEN8_ShaderChannelSelect { 311 SCS_ZERO = 0, 312 SCS_ONE = 1, 313 SCS_RED = 4, 314 SCS_GREEN = 5, 315 SCS_BLUE = 6, 316 SCS_ALPHA = 7, 317}; 318 319enum GEN8_TextureCoordinateMode { 320 TCM_WRAP = 0, 321 TCM_MIRROR = 1, 322 TCM_CLAMP = 2, 323 TCM_CUBE = 3, 324 TCM_CLAMP_BORDER = 4, 325 TCM_MIRROR_ONCE = 5, 326 TCM_HALF_BORDER = 6, 327}; 328 329enum GEN8_WRAP_SHORTEST_ENABLE { 330 WSE_X = 1, 331 WSE_Y = 2, 332 WSE_XY = 3, 333 WSE_Z = 4, 334 WSE_XZ = 5, 335 WSE_YZ = 6, 336 WSE_XYZ = 7, 337 WSE_W = 8, 338 WSE_XW = 9, 339 WSE_YW = 10, 340 WSE_XYW = 11, 341 WSE_ZW = 12, 342 WSE_XZW = 13, 343 WSE_YZW = 14, 344 WSE_XYZW = 15, 345}; 346 347#define GEN8_3DSTATE_CONSTANT_BODY_length 10 348struct GEN8_3DSTATE_CONSTANT_BODY { 349 uint32_t ReadLength[4]; 350 __gen_address_type Buffer[4]; 351}; 352 353static inline void 354GEN8_3DSTATE_CONSTANT_BODY_pack(__attribute__((unused)) __gen_user_data *data, 355 __attribute__((unused)) void * restrict dst, 356 __attribute__((unused)) const struct GEN8_3DSTATE_CONSTANT_BODY * restrict values) 357{ 358 uint32_t * restrict dw = (uint32_t * restrict) dst; 359 360 dw[0] = 361 __gen_uint(values->ReadLength[0], 0, 15) | 362 __gen_uint(values->ReadLength[1], 16, 31); 363 364 dw[1] = 365 __gen_uint(values->ReadLength[2], 0, 15) | 366 __gen_uint(values->ReadLength[3], 16, 31); 367 368 const uint64_t v2_address = 369 __gen_combine_address(data, &dw[2], values->Buffer[0], 0); 370 dw[2] = v2_address; 371 dw[3] = v2_address >> 32; 372 373 const uint64_t v4_address = 374 __gen_combine_address(data, &dw[4], values->Buffer[1], 0); 375 dw[4] = v4_address; 376 dw[5] = v4_address >> 32; 377 378 const uint64_t v6_address = 379 __gen_combine_address(data, &dw[6], values->Buffer[2], 0); 380 dw[6] = v6_address; 381 dw[7] = v6_address >> 32; 382 383 const uint64_t v8_address = 384 __gen_combine_address(data, &dw[8], values->Buffer[3], 0); 385 dw[8] = v8_address; 386 dw[9] = v8_address >> 32; 387} 388 389#define GEN8_BINDING_TABLE_EDIT_ENTRY_length 1 390struct GEN8_BINDING_TABLE_EDIT_ENTRY { 391 uint64_t SurfaceStatePointer; 392 uint32_t BindingTableIndex; 393}; 394 395static inline void 396GEN8_BINDING_TABLE_EDIT_ENTRY_pack(__attribute__((unused)) __gen_user_data *data, 397 __attribute__((unused)) void * restrict dst, 398 __attribute__((unused)) const struct GEN8_BINDING_TABLE_EDIT_ENTRY * restrict values) 399{ 400 uint32_t * restrict dw = (uint32_t * restrict) dst; 401 402 dw[0] = 403 __gen_offset(values->SurfaceStatePointer, 0, 15) | 404 __gen_uint(values->BindingTableIndex, 16, 23); 405} 406 407#define GEN8_BINDING_TABLE_STATE_length 1 408struct GEN8_BINDING_TABLE_STATE { 409 uint64_t SurfaceStatePointer; 410}; 411 412static inline void 413GEN8_BINDING_TABLE_STATE_pack(__attribute__((unused)) __gen_user_data *data, 414 __attribute__((unused)) void * restrict dst, 415 __attribute__((unused)) const struct GEN8_BINDING_TABLE_STATE * restrict values) 416{ 417 uint32_t * restrict dw = (uint32_t * restrict) dst; 418 419 dw[0] = 420 __gen_offset(values->SurfaceStatePointer, 6, 31); 421} 422 423#define GEN8_BLEND_STATE_ENTRY_length 2 424struct GEN8_BLEND_STATE_ENTRY { 425 bool WriteDisableBlue; 426 bool WriteDisableGreen; 427 bool WriteDisableRed; 428 bool WriteDisableAlpha; 429 enum GEN8_3D_Color_Buffer_Blend_Function AlphaBlendFunction; 430 enum GEN8_3D_Color_Buffer_Blend_Factor DestinationAlphaBlendFactor; 431 enum GEN8_3D_Color_Buffer_Blend_Factor SourceAlphaBlendFactor; 432 enum GEN8_3D_Color_Buffer_Blend_Function ColorBlendFunction; 433 enum GEN8_3D_Color_Buffer_Blend_Factor DestinationBlendFactor; 434 enum GEN8_3D_Color_Buffer_Blend_Factor SourceBlendFactor; 435 bool ColorBufferBlendEnable; 436 bool PostBlendColorClampEnable; 437 bool PreBlendColorClampEnable; 438 uint32_t ColorClampRange; 439#define COLORCLAMP_UNORM 0 440#define COLORCLAMP_SNORM 1 441#define COLORCLAMP_RTFORMAT 2 442 bool PreBlendSourceOnlyClampEnable; 443 enum GEN8_3D_Logic_Op_Function LogicOpFunction; 444 bool LogicOpEnable; 445}; 446 447static inline void 448GEN8_BLEND_STATE_ENTRY_pack(__attribute__((unused)) __gen_user_data *data, 449 __attribute__((unused)) void * restrict dst, 450 __attribute__((unused)) const struct GEN8_BLEND_STATE_ENTRY * restrict values) 451{ 452 uint32_t * restrict dw = (uint32_t * restrict) dst; 453 454 dw[0] = 455 __gen_uint(values->WriteDisableBlue, 0, 0) | 456 __gen_uint(values->WriteDisableGreen, 1, 1) | 457 __gen_uint(values->WriteDisableRed, 2, 2) | 458 __gen_uint(values->WriteDisableAlpha, 3, 3) | 459 __gen_uint(values->AlphaBlendFunction, 5, 7) | 460 __gen_uint(values->DestinationAlphaBlendFactor, 8, 12) | 461 __gen_uint(values->SourceAlphaBlendFactor, 13, 17) | 462 __gen_uint(values->ColorBlendFunction, 18, 20) | 463 __gen_uint(values->DestinationBlendFactor, 21, 25) | 464 __gen_uint(values->SourceBlendFactor, 26, 30) | 465 __gen_uint(values->ColorBufferBlendEnable, 31, 31); 466 467 dw[1] = 468 __gen_uint(values->PostBlendColorClampEnable, 0, 0) | 469 __gen_uint(values->PreBlendColorClampEnable, 1, 1) | 470 __gen_uint(values->ColorClampRange, 2, 3) | 471 __gen_uint(values->PreBlendSourceOnlyClampEnable, 4, 4) | 472 __gen_uint(values->LogicOpFunction, 27, 30) | 473 __gen_uint(values->LogicOpEnable, 31, 31); 474} 475 476#define GEN8_BLEND_STATE_length 1 477struct GEN8_BLEND_STATE { 478 uint32_t YDitherOffset; 479 uint32_t XDitherOffset; 480 bool ColorDitherEnable; 481 enum GEN8_3D_Compare_Function AlphaTestFunction; 482 bool AlphaTestEnable; 483 bool AlphaToCoverageDitherEnable; 484 bool AlphaToOneEnable; 485 bool IndependentAlphaBlendEnable; 486 bool AlphaToCoverageEnable; 487 /* variable length fields follow */ 488}; 489 490static inline void 491GEN8_BLEND_STATE_pack(__attribute__((unused)) __gen_user_data *data, 492 __attribute__((unused)) void * restrict dst, 493 __attribute__((unused)) const struct GEN8_BLEND_STATE * restrict values) 494{ 495 uint32_t * restrict dw = (uint32_t * restrict) dst; 496 497 dw[0] = 498 __gen_uint(values->YDitherOffset, 19, 20) | 499 __gen_uint(values->XDitherOffset, 21, 22) | 500 __gen_uint(values->ColorDitherEnable, 23, 23) | 501 __gen_uint(values->AlphaTestFunction, 24, 26) | 502 __gen_uint(values->AlphaTestEnable, 27, 27) | 503 __gen_uint(values->AlphaToCoverageDitherEnable, 28, 28) | 504 __gen_uint(values->AlphaToOneEnable, 29, 29) | 505 __gen_uint(values->IndependentAlphaBlendEnable, 30, 30) | 506 __gen_uint(values->AlphaToCoverageEnable, 31, 31); 507} 508 509#define GEN8_CC_VIEWPORT_length 2 510struct GEN8_CC_VIEWPORT { 511 float MinimumDepth; 512 float MaximumDepth; 513}; 514 515static inline void 516GEN8_CC_VIEWPORT_pack(__attribute__((unused)) __gen_user_data *data, 517 __attribute__((unused)) void * restrict dst, 518 __attribute__((unused)) const struct GEN8_CC_VIEWPORT * restrict values) 519{ 520 uint32_t * restrict dw = (uint32_t * restrict) dst; 521 522 dw[0] = 523 __gen_float(values->MinimumDepth); 524 525 dw[1] = 526 __gen_float(values->MaximumDepth); 527} 528 529#define GEN8_COLOR_CALC_STATE_length 6 530struct GEN8_COLOR_CALC_STATE { 531 uint32_t AlphaTestFormat; 532#define ALPHATEST_UNORM8 0 533#define ALPHATEST_FLOAT32 1 534 bool RoundDisableFunctionDisable; 535 uint32_t BackfaceStencilReferenceValue; 536 uint32_t StencilReferenceValue; 537 uint32_t AlphaReferenceValueAsUNORM8; 538 float AlphaReferenceValueAsFLOAT32; 539 float BlendConstantColorRed; 540 float BlendConstantColorGreen; 541 float BlendConstantColorBlue; 542 float BlendConstantColorAlpha; 543}; 544 545static inline void 546GEN8_COLOR_CALC_STATE_pack(__attribute__((unused)) __gen_user_data *data, 547 __attribute__((unused)) void * restrict dst, 548 __attribute__((unused)) const struct GEN8_COLOR_CALC_STATE * restrict values) 549{ 550 uint32_t * restrict dw = (uint32_t * restrict) dst; 551 552 dw[0] = 553 __gen_uint(values->AlphaTestFormat, 0, 0) | 554 __gen_uint(values->RoundDisableFunctionDisable, 15, 15) | 555 __gen_uint(values->BackfaceStencilReferenceValue, 16, 23) | 556 __gen_uint(values->StencilReferenceValue, 24, 31); 557 558 dw[1] = 559 __gen_uint(values->AlphaReferenceValueAsUNORM8, 0, 31) | 560 __gen_float(values->AlphaReferenceValueAsFLOAT32); 561 562 dw[2] = 563 __gen_float(values->BlendConstantColorRed); 564 565 dw[3] = 566 __gen_float(values->BlendConstantColorGreen); 567 568 dw[4] = 569 __gen_float(values->BlendConstantColorBlue); 570 571 dw[5] = 572 __gen_float(values->BlendConstantColorAlpha); 573} 574 575#define GEN8_FILTER_COEFFICIENT_length 1 576struct GEN8_FILTER_COEFFICIENT { 577 float FilterCoefficient; 578}; 579 580static inline void 581GEN8_FILTER_COEFFICIENT_pack(__attribute__((unused)) __gen_user_data *data, 582 __attribute__((unused)) void * restrict dst, 583 __attribute__((unused)) const struct GEN8_FILTER_COEFFICIENT * restrict values) 584{ 585 uint32_t * restrict dw = (uint32_t * restrict) dst; 586 587 dw[0] = 588 __gen_sfixed(values->FilterCoefficient, 0, 7, 6); 589} 590 591#define GEN8_GATHER_CONSTANT_ENTRY_length 1 592struct GEN8_GATHER_CONSTANT_ENTRY { 593 uint32_t BindingTableIndexOffset; 594 uint32_t ChannelMask; 595 uint64_t ConstantBufferOffset; 596}; 597 598static inline void 599GEN8_GATHER_CONSTANT_ENTRY_pack(__attribute__((unused)) __gen_user_data *data, 600 __attribute__((unused)) void * restrict dst, 601 __attribute__((unused)) const struct GEN8_GATHER_CONSTANT_ENTRY * restrict values) 602{ 603 uint32_t * restrict dw = (uint32_t * restrict) dst; 604 605 dw[0] = 606 __gen_uint(values->BindingTableIndexOffset, 0, 3) | 607 __gen_uint(values->ChannelMask, 4, 7) | 608 __gen_offset(values->ConstantBufferOffset, 8, 15); 609} 610 611#define GEN8_INLINE_DATA_DESCRIPTION_FOR_MFD_AVC_BSD_OBJECT_length 3 612struct GEN8_INLINE_DATA_DESCRIPTION_FOR_MFD_AVC_BSD_OBJECT { 613 bool MBErrorConcealmentPSliceWeightPredictionDisable; 614 bool MBErrorConcealmentPSliceMotionVectorsOverrideDisable; 615 bool MBErrorConcealmentBSpatialWeightPredictionDisable; 616 bool MBErrorConcealmentBSpatialMotionVectorsOverrideDisable; 617 uint32_t MBErrorConcealmentBSpatialPredictionMode; 618 bool MBHeaderErrorHandling; 619 bool EntropyErrorHandling; 620 bool MPRErrorHandling; 621 bool BSDPrematureCompleteErrorHandling; 622 uint32_t ConcealmentPictureID; 623 bool MBErrorConcealmentBTemporalWeightPredictionDisable; 624 bool MBErrorConcealmentBTemporalMotionVectorsOverrideEnable; 625 uint32_t MBErrorConcealmentBTemporalPredictionMode; 626 bool IntraPredMode4x48x8LumaErrorControl; 627 bool InitCurrentMBNumber; 628 uint32_t ConcealmentMethod; 629 uint32_t FirstMBBitOffset; 630 bool LastSlice; 631 bool EmulationPreventionBytePresent; 632 bool FixPrevMBSkipped; 633 uint32_t FirstMBByteOffsetofSliceDataorSliceHeader; 634 bool IntraPredictionErrorControl; 635 bool Intra8x84x4PredictionErrorConcealmentControl; 636 uint32_t BSliceTemporalInterConcealmentMode; 637 uint32_t BSliceSpatialInterConcealmentMode; 638 uint32_t BSliceInterDirectTypeConcealmentMode; 639 uint32_t BSliceConcealmentMode; 640#define IntraConcealment 1 641#define InterConcealment 0 642 uint32_t PSliceInterConcealmentMode; 643 uint32_t PSliceConcealmentMode; 644#define IntraConcealment 1 645#define InterConcealment 0 646 uint32_t ConcealmentReferencePictureFieldBit; 647 uint32_t ISliceConcealmentMode; 648#define IntraConcealment 1 649#define InterConcealment 0 650}; 651 652static inline void 653GEN8_INLINE_DATA_DESCRIPTION_FOR_MFD_AVC_BSD_OBJECT_pack(__attribute__((unused)) __gen_user_data *data, 654 __attribute__((unused)) void * restrict dst, 655 __attribute__((unused)) const struct GEN8_INLINE_DATA_DESCRIPTION_FOR_MFD_AVC_BSD_OBJECT * restrict values) 656{ 657 uint32_t * restrict dw = (uint32_t * restrict) dst; 658 659 dw[0] = 660 __gen_uint(values->MBErrorConcealmentPSliceWeightPredictionDisable, 0, 0) | 661 __gen_uint(values->MBErrorConcealmentPSliceMotionVectorsOverrideDisable, 1, 1) | 662 __gen_uint(values->MBErrorConcealmentBSpatialWeightPredictionDisable, 3, 3) | 663 __gen_uint(values->MBErrorConcealmentBSpatialMotionVectorsOverrideDisable, 4, 4) | 664 __gen_uint(values->MBErrorConcealmentBSpatialPredictionMode, 6, 7) | 665 __gen_uint(values->MBHeaderErrorHandling, 8, 8) | 666 __gen_uint(values->EntropyErrorHandling, 10, 10) | 667 __gen_uint(values->MPRErrorHandling, 12, 12) | 668 __gen_uint(values->BSDPrematureCompleteErrorHandling, 14, 14) | 669 __gen_uint(values->ConcealmentPictureID, 16, 21) | 670 __gen_uint(values->MBErrorConcealmentBTemporalWeightPredictionDisable, 24, 24) | 671 __gen_uint(values->MBErrorConcealmentBTemporalMotionVectorsOverrideEnable, 25, 25) | 672 __gen_uint(values->MBErrorConcealmentBTemporalPredictionMode, 27, 28) | 673 __gen_uint(values->IntraPredMode4x48x8LumaErrorControl, 29, 29) | 674 __gen_uint(values->InitCurrentMBNumber, 30, 30) | 675 __gen_uint(values->ConcealmentMethod, 31, 31); 676 677 dw[1] = 678 __gen_uint(values->FirstMBBitOffset, 0, 2) | 679 __gen_uint(values->LastSlice, 3, 3) | 680 __gen_uint(values->EmulationPreventionBytePresent, 4, 4) | 681 __gen_uint(values->FixPrevMBSkipped, 7, 7) | 682 __gen_uint(values->FirstMBByteOffsetofSliceDataorSliceHeader, 16, 31); 683 684 dw[2] = 685 __gen_uint(values->IntraPredictionErrorControl, 0, 0) | 686 __gen_uint(values->Intra8x84x4PredictionErrorConcealmentControl, 1, 1) | 687 __gen_uint(values->BSliceTemporalInterConcealmentMode, 4, 6) | 688 __gen_uint(values->BSliceSpatialInterConcealmentMode, 8, 10) | 689 __gen_uint(values->BSliceInterDirectTypeConcealmentMode, 12, 13) | 690 __gen_uint(values->BSliceConcealmentMode, 15, 15) | 691 __gen_uint(values->PSliceInterConcealmentMode, 16, 18) | 692 __gen_uint(values->PSliceConcealmentMode, 23, 23) | 693 __gen_uint(values->ConcealmentReferencePictureFieldBit, 24, 29) | 694 __gen_uint(values->ISliceConcealmentMode, 31, 31); 695} 696 697#define GEN8_INTERFACE_DESCRIPTOR_DATA_length 8 698struct GEN8_INTERFACE_DESCRIPTOR_DATA { 699 uint64_t KernelStartPointer; 700 bool SoftwareExceptionEnable; 701 bool MaskStackExceptionEnable; 702 bool IllegalOpcodeExceptionEnable; 703 uint32_t FloatingPointMode; 704#define IEEE754 0 705#define Alternate 1 706 uint32_t ThreadPriority; 707#define NormalPriority 0 708#define HighPriority 1 709 bool SingleProgramFlow; 710 uint32_t DenormMode; 711#define Ftz 0 712#define SetByKernel 1 713 uint32_t SamplerCount; 714#define Nosamplersused 0 715#define Between1and4samplersused 1 716#define Between5and8samplersused 2 717#define Between9and12samplersused 3 718#define Between13and16samplersused 4 719 uint64_t SamplerStatePointer; 720 uint32_t BindingTableEntryCount; 721 uint64_t BindingTablePointer; 722 uint32_t ConstantURBEntryReadOffset; 723 uint32_t ConstantURBEntryReadLength; 724 uint32_t NumberofThreadsinGPGPUThreadGroup; 725 uint32_t SharedLocalMemorySize; 726#define Encodes0k 0 727#define Encodes4k 1 728#define Encodes8k 2 729#define Encodes16k 4 730#define Encodes32k 8 731#define Encodes64k 16 732 bool BarrierEnable; 733 uint32_t RoundingMode; 734#define RTNE 0 735#define RU 1 736#define RD 2 737#define RTZ 3 738 uint32_t CrossThreadConstantDataReadLength; 739}; 740 741static inline void 742GEN8_INTERFACE_DESCRIPTOR_DATA_pack(__attribute__((unused)) __gen_user_data *data, 743 __attribute__((unused)) void * restrict dst, 744 __attribute__((unused)) const struct GEN8_INTERFACE_DESCRIPTOR_DATA * restrict values) 745{ 746 uint32_t * restrict dw = (uint32_t * restrict) dst; 747 748 const uint64_t v0 = 749 __gen_offset(values->KernelStartPointer, 6, 47); 750 dw[0] = v0; 751 dw[1] = v0 >> 32; 752 753 dw[2] = 754 __gen_uint(values->SoftwareExceptionEnable, 7, 7) | 755 __gen_uint(values->MaskStackExceptionEnable, 11, 11) | 756 __gen_uint(values->IllegalOpcodeExceptionEnable, 13, 13) | 757 __gen_uint(values->FloatingPointMode, 16, 16) | 758 __gen_uint(values->ThreadPriority, 17, 17) | 759 __gen_uint(values->SingleProgramFlow, 18, 18) | 760 __gen_uint(values->DenormMode, 19, 19); 761 762 dw[3] = 763 __gen_uint(values->SamplerCount, 2, 4) | 764 __gen_offset(values->SamplerStatePointer, 5, 31); 765 766 dw[4] = 767 __gen_uint(values->BindingTableEntryCount, 0, 4) | 768 __gen_offset(values->BindingTablePointer, 5, 15); 769 770 dw[5] = 771 __gen_uint(values->ConstantURBEntryReadOffset, 0, 15) | 772 __gen_uint(values->ConstantURBEntryReadLength, 16, 31); 773 774 dw[6] = 775 __gen_uint(values->NumberofThreadsinGPGPUThreadGroup, 0, 9) | 776 __gen_uint(values->SharedLocalMemorySize, 16, 20) | 777 __gen_uint(values->BarrierEnable, 21, 21) | 778 __gen_uint(values->RoundingMode, 22, 23); 779 780 dw[7] = 781 __gen_uint(values->CrossThreadConstantDataReadLength, 0, 7); 782} 783 784#define GEN8_MEMORYADDRESSATTRIBUTES_length 1 785struct GEN8_MEMORYADDRESSATTRIBUTES { 786 uint32_t AgeforQUADLRU; 787 uint32_t TargetCache; 788#define eLLCOnly 0 789#define LLCOnly 1 790#define LLCeLLC 2 791#define L3LLCeLLC 3 792 uint32_t ArbitrationPriorityControl; 793}; 794 795static inline void 796GEN8_MEMORYADDRESSATTRIBUTES_pack(__attribute__((unused)) __gen_user_data *data, 797 __attribute__((unused)) void * restrict dst, 798 __attribute__((unused)) const struct GEN8_MEMORYADDRESSATTRIBUTES * restrict values) 799{ 800 uint32_t * restrict dw = (uint32_t * restrict) dst; 801 802 dw[0] = 803 __gen_uint(values->AgeforQUADLRU, 0, 1) | 804 __gen_uint(values->TargetCache, 3, 4) | 805 __gen_uint(values->ArbitrationPriorityControl, 7, 8); 806} 807 808#define GEN8_MEMORY_OBJECT_CONTROL_STATE_length 1 809struct GEN8_MEMORY_OBJECT_CONTROL_STATE { 810 uint32_t AgeforQUADLRU; 811 uint32_t TargetCache; 812#define eLLCOnlywheneDRAMispresentelsegetsallocatedinLLC 0 813#define LLCOnly 1 814#define LLCeLLCAllowed 2 815#define L3DefertoPATforLLCeLLCselection 3 816 uint32_t MemoryTypeLLCeLLCCacheabilityControl; 817#define UCwithFenceifcoherentcycle 0 818#define UCUncacheable 1 819#define WT 2 820#define WB 3 821}; 822 823static inline void 824GEN8_MEMORY_OBJECT_CONTROL_STATE_pack(__attribute__((unused)) __gen_user_data *data, 825 __attribute__((unused)) void * restrict dst, 826 __attribute__((unused)) const struct GEN8_MEMORY_OBJECT_CONTROL_STATE * restrict values) 827{ 828 uint32_t * restrict dw = (uint32_t * restrict) dst; 829 830 dw[0] = 831 __gen_uint(values->AgeforQUADLRU, 0, 1) | 832 __gen_uint(values->TargetCache, 3, 4) | 833 __gen_uint(values->MemoryTypeLLCeLLCCacheabilityControl, 5, 6); 834} 835 836#define GEN8_MFD_MPEG2_BSD_OBJECT_INLINE_DATA_DESCRIPTION_length 2 837struct GEN8_MFD_MPEG2_BSD_OBJECT_INLINE_DATA_DESCRIPTION { 838 uint32_t FirstMBBitOffset; 839 bool LastMB; 840 bool LastPicSlice; 841 uint32_t SliceConcealmentType; 842 uint32_t SliceConcealmentOverride; 843 uint32_t MBCount; 844 uint32_t SliceVerticalPosition; 845 uint32_t SliceHorizontalPosition; 846 uint32_t NextSliceHorizontalPosition; 847 uint32_t NextSliceVerticalPosition; 848 uint32_t QuantizerScaleCode; 849}; 850 851static inline void 852GEN8_MFD_MPEG2_BSD_OBJECT_INLINE_DATA_DESCRIPTION_pack(__attribute__((unused)) __gen_user_data *data, 853 __attribute__((unused)) void * restrict dst, 854 __attribute__((unused)) const struct GEN8_MFD_MPEG2_BSD_OBJECT_INLINE_DATA_DESCRIPTION * restrict values) 855{ 856 uint32_t * restrict dw = (uint32_t * restrict) dst; 857 858 dw[0] = 859 __gen_uint(values->FirstMBBitOffset, 0, 2) | 860 __gen_uint(values->LastMB, 3, 3) | 861 __gen_uint(values->LastPicSlice, 5, 5) | 862 __gen_uint(values->SliceConcealmentType, 6, 6) | 863 __gen_uint(values->SliceConcealmentOverride, 7, 7) | 864 __gen_uint(values->MBCount, 8, 15) | 865 __gen_uint(values->SliceVerticalPosition, 16, 23) | 866 __gen_uint(values->SliceHorizontalPosition, 24, 31); 867 868 dw[1] = 869 __gen_uint(values->NextSliceHorizontalPosition, 0, 7) | 870 __gen_uint(values->NextSliceVerticalPosition, 8, 16) | 871 __gen_uint(values->QuantizerScaleCode, 24, 28); 872} 873 874#define GEN8_MI_MATH_ALU_INSTRUCTION_length 1 875struct GEN8_MI_MATH_ALU_INSTRUCTION { 876 uint32_t Operand2; 877#define MI_ALU_REG0 0 878#define MI_ALU_REG1 1 879#define MI_ALU_REG2 2 880#define MI_ALU_REG3 3 881#define MI_ALU_REG4 4 882#define MI_ALU_REG5 5 883#define MI_ALU_REG6 6 884#define MI_ALU_REG7 7 885#define MI_ALU_REG8 8 886#define MI_ALU_REG9 9 887#define MI_ALU_REG10 10 888#define MI_ALU_REG11 11 889#define MI_ALU_REG12 12 890#define MI_ALU_REG13 13 891#define MI_ALU_REG14 14 892#define MI_ALU_REG15 15 893#define MI_ALU_SRCA 32 894#define MI_ALU_SRCB 33 895#define MI_ALU_ACCU 49 896#define MI_ALU_ZF 50 897#define MI_ALU_CF 51 898 uint32_t Operand1; 899#define MI_ALU_REG0 0 900#define MI_ALU_REG1 1 901#define MI_ALU_REG2 2 902#define MI_ALU_REG3 3 903#define MI_ALU_REG4 4 904#define MI_ALU_REG5 5 905#define MI_ALU_REG6 6 906#define MI_ALU_REG7 7 907#define MI_ALU_REG8 8 908#define MI_ALU_REG9 9 909#define MI_ALU_REG10 10 910#define MI_ALU_REG11 11 911#define MI_ALU_REG12 12 912#define MI_ALU_REG13 13 913#define MI_ALU_REG14 14 914#define MI_ALU_REG15 15 915#define MI_ALU_SRCA 32 916#define MI_ALU_SRCB 33 917#define MI_ALU_ACCU 49 918#define MI_ALU_ZF 50 919#define MI_ALU_CF 51 920 uint32_t ALUOpcode; 921#define MI_ALU_NOOP 0 922#define MI_ALU_LOAD 128 923#define MI_ALU_LOADINV 1152 924#define MI_ALU_LOAD0 129 925#define MI_ALU_LOAD1 1153 926#define MI_ALU_ADD 256 927#define MI_ALU_SUB 257 928#define MI_ALU_AND 258 929#define MI_ALU_OR 259 930#define MI_ALU_XOR 260 931#define MI_ALU_STORE 384 932#define MI_ALU_STOREINV 1408 933}; 934 935static inline void 936GEN8_MI_MATH_ALU_INSTRUCTION_pack(__attribute__((unused)) __gen_user_data *data, 937 __attribute__((unused)) void * restrict dst, 938 __attribute__((unused)) const struct GEN8_MI_MATH_ALU_INSTRUCTION * restrict values) 939{ 940 uint32_t * restrict dw = (uint32_t * restrict) dst; 941 942 dw[0] = 943 __gen_uint(values->Operand2, 0, 9) | 944 __gen_uint(values->Operand1, 10, 19) | 945 __gen_uint(values->ALUOpcode, 20, 31); 946} 947 948#define GEN8_PALETTE_ENTRY_length 1 949struct GEN8_PALETTE_ENTRY { 950 uint32_t Blue; 951 uint32_t Green; 952 uint32_t Red; 953 uint32_t Alpha; 954}; 955 956static inline void 957GEN8_PALETTE_ENTRY_pack(__attribute__((unused)) __gen_user_data *data, 958 __attribute__((unused)) void * restrict dst, 959 __attribute__((unused)) const struct GEN8_PALETTE_ENTRY * restrict values) 960{ 961 uint32_t * restrict dw = (uint32_t * restrict) dst; 962 963 dw[0] = 964 __gen_uint(values->Blue, 0, 7) | 965 __gen_uint(values->Green, 8, 15) | 966 __gen_uint(values->Red, 16, 23) | 967 __gen_uint(values->Alpha, 24, 31); 968} 969 970#define GEN8_RENDER_SURFACE_STATE_length 16 971struct GEN8_RENDER_SURFACE_STATE { 972 bool CubeFaceEnablePositiveZ; 973 bool CubeFaceEnableNegativeZ; 974 bool CubeFaceEnablePositiveY; 975 bool CubeFaceEnableNegativeY; 976 bool CubeFaceEnablePositiveX; 977 bool CubeFaceEnableNegativeX; 978 uint32_t MediaBoundaryPixelMode; 979#define NORMAL_MODE 0 980#define PROGRESSIVE_FRAME 2 981#define INTERLACED_FRAME 3 982 uint32_t RenderCacheReadWriteMode; 983#define WriteOnlyCache 0 984#define ReadWriteCache 1 985 bool SamplerL2BypassModeDisable; 986 uint32_t VerticalLineStrideOffset; 987 uint32_t VerticalLineStride; 988 uint32_t TileMode; 989#define LINEAR 0 990#define WMAJOR 1 991#define XMAJOR 2 992#define YMAJOR 3 993 uint32_t SurfaceHorizontalAlignment; 994#define HALIGN4 1 995#define HALIGN8 2 996#define HALIGN16 3 997 uint32_t SurfaceVerticalAlignment; 998#define VALIGN4 1 999#define VALIGN8 2 1000#define VALIGN16 3 1001 uint32_t SurfaceFormat; 1002 bool SurfaceArray; 1003 uint32_t SurfaceType; 1004#define SURFTYPE_1D 0 1005#define SURFTYPE_2D 1 1006#define SURFTYPE_3D 2 1007#define SURFTYPE_CUBE 3 1008#define SURFTYPE_BUFFER 4 1009#define SURFTYPE_STRBUF 5 1010#define SURFTYPE_NULL 7 1011 uint32_t SurfaceQPitch; 1012 float BaseMipLevel; 1013 uint32_t MOCS; 1014 uint32_t Width; 1015 uint32_t Height; 1016 uint32_t SurfacePitch; 1017 uint32_t Depth; 1018 uint32_t MultisamplePositionPaletteIndex; 1019 uint32_t NumberofMultisamples; 1020#define MULTISAMPLECOUNT_1 0 1021#define MULTISAMPLECOUNT_2 1 1022#define MULTISAMPLECOUNT_4 2 1023#define MULTISAMPLECOUNT_8 3 1024 uint32_t MultisampledSurfaceStorageFormat; 1025#define MSFMT_MSS 0 1026#define MSFMT_DEPTH_STENCIL 1 1027 uint32_t RenderTargetViewExtent; 1028 uint32_t MinimumArrayElement; 1029 uint32_t RenderTargetAndSampleUnormRotation; 1030#define _0DEG 0 1031#define _90DEG 1 1032#define _270DEG 3 1033 uint32_t MIPCountLOD; 1034 uint32_t SurfaceMinLOD; 1035 uint32_t CoherencyType; 1036#define GPUcoherent 0 1037#define IAcoherent 1 1038 bool EWADisableForCube; 1039 uint32_t YOffset; 1040 uint32_t XOffset; 1041 uint32_t AuxiliarySurfaceMode; 1042#define AUX_NONE 0 1043#define AUX_MCS 1 1044#define AUX_APPEND 2 1045#define AUX_HIZ 3 1046 uint32_t YOffsetforUorUVPlane; 1047 uint32_t AuxiliarySurfacePitch; 1048 uint32_t AuxiliarySurfaceQPitch; 1049 uint32_t XOffsetforUorUVPlane; 1050 bool SeparateUVPlaneEnable; 1051 float ResourceMinLOD; 1052 enum GEN8_ShaderChannelSelect ShaderChannelSelectAlpha; 1053 enum GEN8_ShaderChannelSelect ShaderChannelSelectBlue; 1054 enum GEN8_ShaderChannelSelect ShaderChannelSelectGreen; 1055 enum GEN8_ShaderChannelSelect ShaderChannelSelectRed; 1056 enum GEN8_ClearColor AlphaClearColor; 1057 enum GEN8_ClearColor BlueClearColor; 1058 enum GEN8_ClearColor GreenClearColor; 1059 enum GEN8_ClearColor RedClearColor; 1060 __gen_address_type SurfaceBaseAddress; 1061 __gen_address_type AuxiliarySurfaceBaseAddress; 1062 uint32_t AuxiliaryTableIndexforMediaCompressedSurface; 1063 uint32_t YOffsetforVPlane; 1064 uint32_t XOffsetforVPlane; 1065}; 1066 1067static inline void 1068GEN8_RENDER_SURFACE_STATE_pack(__attribute__((unused)) __gen_user_data *data, 1069 __attribute__((unused)) void * restrict dst, 1070 __attribute__((unused)) const struct GEN8_RENDER_SURFACE_STATE * restrict values) 1071{ 1072 uint32_t * restrict dw = (uint32_t * restrict) dst; 1073 1074 dw[0] = 1075 __gen_uint(values->CubeFaceEnablePositiveZ, 0, 0) | 1076 __gen_uint(values->CubeFaceEnableNegativeZ, 1, 1) | 1077 __gen_uint(values->CubeFaceEnablePositiveY, 2, 2) | 1078 __gen_uint(values->CubeFaceEnableNegativeY, 3, 3) | 1079 __gen_uint(values->CubeFaceEnablePositiveX, 4, 4) | 1080 __gen_uint(values->CubeFaceEnableNegativeX, 5, 5) | 1081 __gen_uint(values->MediaBoundaryPixelMode, 6, 7) | 1082 __gen_uint(values->RenderCacheReadWriteMode, 8, 8) | 1083 __gen_uint(values->SamplerL2BypassModeDisable, 9, 9) | 1084 __gen_uint(values->VerticalLineStrideOffset, 10, 10) | 1085 __gen_uint(values->VerticalLineStride, 11, 11) | 1086 __gen_uint(values->TileMode, 12, 13) | 1087 __gen_uint(values->SurfaceHorizontalAlignment, 14, 15) | 1088 __gen_uint(values->SurfaceVerticalAlignment, 16, 17) | 1089 __gen_uint(values->SurfaceFormat, 18, 26) | 1090 __gen_uint(values->SurfaceArray, 28, 28) | 1091 __gen_uint(values->SurfaceType, 29, 31); 1092 1093 dw[1] = 1094 __gen_uint(values->SurfaceQPitch, 0, 14) | 1095 __gen_ufixed(values->BaseMipLevel, 19, 23, 1) | 1096 __gen_uint(values->MOCS, 24, 30); 1097 1098 dw[2] = 1099 __gen_uint(values->Width, 0, 13) | 1100 __gen_uint(values->Height, 16, 29); 1101 1102 dw[3] = 1103 __gen_uint(values->SurfacePitch, 0, 17) | 1104 __gen_uint(values->Depth, 21, 31); 1105 1106 dw[4] = 1107 __gen_uint(values->MultisamplePositionPaletteIndex, 0, 2) | 1108 __gen_uint(values->NumberofMultisamples, 3, 5) | 1109 __gen_uint(values->MultisampledSurfaceStorageFormat, 6, 6) | 1110 __gen_uint(values->RenderTargetViewExtent, 7, 17) | 1111 __gen_uint(values->MinimumArrayElement, 18, 28) | 1112 __gen_uint(values->RenderTargetAndSampleUnormRotation, 29, 30); 1113 1114 dw[5] = 1115 __gen_uint(values->MIPCountLOD, 0, 3) | 1116 __gen_uint(values->SurfaceMinLOD, 4, 7) | 1117 __gen_uint(values->CoherencyType, 14, 14) | 1118 __gen_uint(values->EWADisableForCube, 20, 20) | 1119 __gen_uint(values->YOffset, 21, 23) | 1120 __gen_uint(values->XOffset, 25, 31); 1121 1122 dw[6] = 1123 __gen_uint(values->AuxiliarySurfaceMode, 0, 2) | 1124 __gen_uint(values->YOffsetforUorUVPlane, 0, 13) | 1125 __gen_uint(values->AuxiliarySurfacePitch, 3, 11) | 1126 __gen_uint(values->AuxiliarySurfaceQPitch, 16, 30) | 1127 __gen_uint(values->XOffsetforUorUVPlane, 16, 29) | 1128 __gen_uint(values->SeparateUVPlaneEnable, 31, 31); 1129 1130 dw[7] = 1131 __gen_ufixed(values->ResourceMinLOD, 0, 11, 8) | 1132 __gen_uint(values->ShaderChannelSelectAlpha, 16, 18) | 1133 __gen_uint(values->ShaderChannelSelectBlue, 19, 21) | 1134 __gen_uint(values->ShaderChannelSelectGreen, 22, 24) | 1135 __gen_uint(values->ShaderChannelSelectRed, 25, 27) | 1136 __gen_uint(values->AlphaClearColor, 28, 28) | 1137 __gen_uint(values->BlueClearColor, 29, 29) | 1138 __gen_uint(values->GreenClearColor, 30, 30) | 1139 __gen_uint(values->RedClearColor, 31, 31); 1140 1141 const uint64_t v8_address = 1142 __gen_combine_address(data, &dw[8], values->SurfaceBaseAddress, 0); 1143 dw[8] = v8_address; 1144 dw[9] = v8_address >> 32; 1145 1146 const uint64_t v10 = 1147 __gen_uint(values->AuxiliaryTableIndexforMediaCompressedSurface, 21, 31) | 1148 __gen_uint(values->YOffsetforVPlane, 32, 45) | 1149 __gen_uint(values->XOffsetforVPlane, 48, 61); 1150 const uint64_t v10_address = 1151 __gen_combine_address(data, &dw[10], values->AuxiliarySurfaceBaseAddress, v10); 1152 dw[10] = v10_address; 1153 dw[11] = (v10_address >> 32) | (v10 >> 32); 1154 1155 dw[12] = 0; 1156 1157 dw[13] = 0; 1158 1159 dw[14] = 0; 1160 1161 dw[15] = 0; 1162} 1163 1164#define GEN8_SAMPLER_BORDER_COLOR_STATE_length 4 1165struct GEN8_SAMPLER_BORDER_COLOR_STATE { 1166 float BorderColorFloatRed; 1167 uint32_t BorderColor32bitRed; 1168 float BorderColorFloatGreen; 1169 uint32_t BorderColor32bitGreen; 1170 float BorderColorFloatBlue; 1171 uint32_t BorderColor32bitBlue; 1172 float BorderColorFloatAlpha; 1173 uint32_t BorderColor32bitAlpha; 1174}; 1175 1176static inline void 1177GEN8_SAMPLER_BORDER_COLOR_STATE_pack(__attribute__((unused)) __gen_user_data *data, 1178 __attribute__((unused)) void * restrict dst, 1179 __attribute__((unused)) const struct GEN8_SAMPLER_BORDER_COLOR_STATE * restrict values) 1180{ 1181 uint32_t * restrict dw = (uint32_t * restrict) dst; 1182 1183 dw[0] = 1184 __gen_float(values->BorderColorFloatRed) | 1185 __gen_uint(values->BorderColor32bitRed, 0, 31); 1186 1187 dw[1] = 1188 __gen_float(values->BorderColorFloatGreen) | 1189 __gen_uint(values->BorderColor32bitGreen, 0, 31); 1190 1191 dw[2] = 1192 __gen_float(values->BorderColorFloatBlue) | 1193 __gen_uint(values->BorderColor32bitBlue, 0, 31); 1194 1195 dw[3] = 1196 __gen_float(values->BorderColorFloatAlpha) | 1197 __gen_uint(values->BorderColor32bitAlpha, 0, 31); 1198} 1199 1200#define GEN8_SAMPLER_STATE_length 4 1201struct GEN8_SAMPLER_STATE { 1202 uint32_t AnisotropicAlgorithm; 1203#define LEGACY 0 1204#define EWAApproximation 1 1205 float TextureLODBias; 1206 uint32_t MinModeFilter; 1207#define MAPFILTER_NEAREST 0 1208#define MAPFILTER_LINEAR 1 1209#define MAPFILTER_ANISOTROPIC 2 1210#define MAPFILTER_MONO 6 1211 uint32_t MagModeFilter; 1212#define MAPFILTER_NEAREST 0 1213#define MAPFILTER_LINEAR 1 1214#define MAPFILTER_ANISOTROPIC 2 1215#define MAPFILTER_MONO 6 1216 uint32_t MipModeFilter; 1217#define MIPFILTER_NONE 0 1218#define MIPFILTER_NEAREST 1 1219#define MIPFILTER_LINEAR 3 1220 float BaseMipLevel; 1221 uint32_t LODPreClampMode; 1222#define CLAMP_MODE_NONE 0 1223#define CLAMP_MODE_OGL 2 1224 uint32_t TextureBorderColorMode; 1225#define DX10OGL 0 1226#define DX9 1 1227 bool SamplerDisable; 1228 uint32_t CubeSurfaceControlMode; 1229#define PROGRAMMED 0 1230#define OVERRIDE 1 1231 uint32_t ShadowFunction; 1232#define PREFILTEROPALWAYS 0 1233#define PREFILTEROPNEVER 1 1234#define PREFILTEROPLESS 2 1235#define PREFILTEROPEQUAL 3 1236#define PREFILTEROPLEQUAL 4 1237#define PREFILTEROPGREATER 5 1238#define PREFILTEROPNOTEQUAL 6 1239#define PREFILTEROPGEQUAL 7 1240 uint32_t ChromaKeyMode; 1241#define KEYFILTER_KILL_ON_ANY_MATCH 0 1242#define KEYFILTER_REPLACE_BLACK 1 1243 uint32_t ChromaKeyIndex; 1244 bool ChromaKeyEnable; 1245 float MaxLOD; 1246 float MinLOD; 1247 uint32_t LODClampMagnificationMode; 1248#define MIPNONE 0 1249#define MIPFILTER 1 1250 uint64_t BorderColorPointer; 1251 enum GEN8_TextureCoordinateMode TCZAddressControlMode; 1252 enum GEN8_TextureCoordinateMode TCYAddressControlMode; 1253 enum GEN8_TextureCoordinateMode TCXAddressControlMode; 1254 bool NonnormalizedCoordinateEnable; 1255 uint32_t TrilinearFilterQuality; 1256#define FULL 0 1257#define HIGH 1 1258#define MED 2 1259#define LOW 3 1260 bool RAddressMinFilterRoundingEnable; 1261 bool RAddressMagFilterRoundingEnable; 1262 bool VAddressMinFilterRoundingEnable; 1263 bool VAddressMagFilterRoundingEnable; 1264 bool UAddressMinFilterRoundingEnable; 1265 bool UAddressMagFilterRoundingEnable; 1266 uint32_t MaximumAnisotropy; 1267#define RATIO21 0 1268#define RATIO41 1 1269#define RATIO61 2 1270#define RATIO81 3 1271#define RATIO101 4 1272#define RATIO121 5 1273#define RATIO141 6 1274#define RATIO161 7 1275}; 1276 1277static inline void 1278GEN8_SAMPLER_STATE_pack(__attribute__((unused)) __gen_user_data *data, 1279 __attribute__((unused)) void * restrict dst, 1280 __attribute__((unused)) const struct GEN8_SAMPLER_STATE * restrict values) 1281{ 1282 uint32_t * restrict dw = (uint32_t * restrict) dst; 1283 1284 dw[0] = 1285 __gen_uint(values->AnisotropicAlgorithm, 0, 0) | 1286 __gen_sfixed(values->TextureLODBias, 1, 13, 8) | 1287 __gen_uint(values->MinModeFilter, 14, 16) | 1288 __gen_uint(values->MagModeFilter, 17, 19) | 1289 __gen_uint(values->MipModeFilter, 20, 21) | 1290 __gen_ufixed(values->BaseMipLevel, 22, 26, 1) | 1291 __gen_uint(values->LODPreClampMode, 27, 28) | 1292 __gen_uint(values->TextureBorderColorMode, 29, 29) | 1293 __gen_uint(values->SamplerDisable, 31, 31); 1294 1295 dw[1] = 1296 __gen_uint(values->CubeSurfaceControlMode, 0, 0) | 1297 __gen_uint(values->ShadowFunction, 1, 3) | 1298 __gen_uint(values->ChromaKeyMode, 4, 4) | 1299 __gen_uint(values->ChromaKeyIndex, 5, 6) | 1300 __gen_uint(values->ChromaKeyEnable, 7, 7) | 1301 __gen_ufixed(values->MaxLOD, 8, 19, 8) | 1302 __gen_ufixed(values->MinLOD, 20, 31, 8); 1303 1304 dw[2] = 1305 __gen_uint(values->LODClampMagnificationMode, 0, 0) | 1306 __gen_offset(values->BorderColorPointer, 6, 23); 1307 1308 dw[3] = 1309 __gen_uint(values->TCZAddressControlMode, 0, 2) | 1310 __gen_uint(values->TCYAddressControlMode, 3, 5) | 1311 __gen_uint(values->TCXAddressControlMode, 6, 8) | 1312 __gen_uint(values->NonnormalizedCoordinateEnable, 10, 10) | 1313 __gen_uint(values->TrilinearFilterQuality, 11, 12) | 1314 __gen_uint(values->RAddressMinFilterRoundingEnable, 13, 13) | 1315 __gen_uint(values->RAddressMagFilterRoundingEnable, 14, 14) | 1316 __gen_uint(values->VAddressMinFilterRoundingEnable, 15, 15) | 1317 __gen_uint(values->VAddressMagFilterRoundingEnable, 16, 16) | 1318 __gen_uint(values->UAddressMinFilterRoundingEnable, 17, 17) | 1319 __gen_uint(values->UAddressMagFilterRoundingEnable, 18, 18) | 1320 __gen_uint(values->MaximumAnisotropy, 19, 21); 1321} 1322 1323#define GEN8_SAMPLER_STATE_8X8_AVS_COEFFICIENTS_length 8 1324struct GEN8_SAMPLER_STATE_8X8_AVS_COEFFICIENTS { 1325 float Table0XFilterCoefficientn0; 1326 float Table0YFilterCoefficientn0; 1327 float Table0XFilterCoefficientn1; 1328 float Table0YFilterCoefficientn1; 1329 float Table0XFilterCoefficientn2; 1330 float Table0YFilterCoefficientn2; 1331 float Table0XFilterCoefficientn3; 1332 float Table0YFilterCoefficientn3; 1333 float Table0XFilterCoefficientn4; 1334 float Table0YFilterCoefficientn4; 1335 float Table0XFilterCoefficientn5; 1336 float Table0YFilterCoefficientn5; 1337 float Table0XFilterCoefficientn6; 1338 float Table0YFilterCoefficientn6; 1339 float Table0XFilterCoefficientn7; 1340 float Table0YFilterCoefficientn7; 1341 float Table1XFilterCoefficientn2; 1342 float Table1XFilterCoefficientn3; 1343 float Table1XFilterCoefficientn4; 1344 float Table1XFilterCoefficientn5; 1345 float Table1YFilterCoefficientn2; 1346 float Table1YFilterCoefficientn3; 1347 float Table1YFilterCoefficientn4; 1348 float Table1YFilterCoefficientn5; 1349}; 1350 1351static inline void 1352GEN8_SAMPLER_STATE_8X8_AVS_COEFFICIENTS_pack(__attribute__((unused)) __gen_user_data *data, 1353 __attribute__((unused)) void * restrict dst, 1354 __attribute__((unused)) const struct GEN8_SAMPLER_STATE_8X8_AVS_COEFFICIENTS * restrict values) 1355{ 1356 uint32_t * restrict dw = (uint32_t * restrict) dst; 1357 1358 dw[0] = 1359 __gen_sfixed(values->Table0XFilterCoefficientn0, 0, 7, 6) | 1360 __gen_sfixed(values->Table0YFilterCoefficientn0, 8, 15, 6) | 1361 __gen_sfixed(values->Table0XFilterCoefficientn1, 16, 23, 6) | 1362 __gen_sfixed(values->Table0YFilterCoefficientn1, 24, 31, 6); 1363 1364 dw[1] = 1365 __gen_sfixed(values->Table0XFilterCoefficientn2, 0, 7, 6) | 1366 __gen_sfixed(values->Table0YFilterCoefficientn2, 8, 15, 6) | 1367 __gen_sfixed(values->Table0XFilterCoefficientn3, 16, 23, 6) | 1368 __gen_sfixed(values->Table0YFilterCoefficientn3, 24, 31, 6); 1369 1370 dw[2] = 1371 __gen_sfixed(values->Table0XFilterCoefficientn4, 0, 7, 6) | 1372 __gen_sfixed(values->Table0YFilterCoefficientn4, 8, 15, 6) | 1373 __gen_sfixed(values->Table0XFilterCoefficientn5, 16, 23, 6) | 1374 __gen_sfixed(values->Table0YFilterCoefficientn5, 24, 31, 6); 1375 1376 dw[3] = 1377 __gen_sfixed(values->Table0XFilterCoefficientn6, 0, 7, 6) | 1378 __gen_sfixed(values->Table0YFilterCoefficientn6, 8, 15, 6) | 1379 __gen_sfixed(values->Table0XFilterCoefficientn7, 16, 23, 6) | 1380 __gen_sfixed(values->Table0YFilterCoefficientn7, 24, 31, 6); 1381 1382 dw[4] = 1383 __gen_sfixed(values->Table1XFilterCoefficientn2, 16, 23, 6) | 1384 __gen_sfixed(values->Table1XFilterCoefficientn3, 24, 31, 6); 1385 1386 dw[5] = 1387 __gen_sfixed(values->Table1XFilterCoefficientn4, 0, 7, 6) | 1388 __gen_sfixed(values->Table1XFilterCoefficientn5, 8, 15, 6); 1389 1390 dw[6] = 1391 __gen_sfixed(values->Table1YFilterCoefficientn2, 16, 23, 6) | 1392 __gen_sfixed(values->Table1YFilterCoefficientn3, 24, 31, 6); 1393 1394 dw[7] = 1395 __gen_sfixed(values->Table1YFilterCoefficientn4, 0, 7, 6) | 1396 __gen_sfixed(values->Table1YFilterCoefficientn5, 8, 15, 6); 1397} 1398 1399#define GEN8_SCISSOR_RECT_length 2 1400struct GEN8_SCISSOR_RECT { 1401 uint32_t ScissorRectangleXMin; 1402 uint32_t ScissorRectangleYMin; 1403 uint32_t ScissorRectangleXMax; 1404 uint32_t ScissorRectangleYMax; 1405}; 1406 1407static inline void 1408GEN8_SCISSOR_RECT_pack(__attribute__((unused)) __gen_user_data *data, 1409 __attribute__((unused)) void * restrict dst, 1410 __attribute__((unused)) const struct GEN8_SCISSOR_RECT * restrict values) 1411{ 1412 uint32_t * restrict dw = (uint32_t * restrict) dst; 1413 1414 dw[0] = 1415 __gen_uint(values->ScissorRectangleXMin, 0, 15) | 1416 __gen_uint(values->ScissorRectangleYMin, 16, 31); 1417 1418 dw[1] = 1419 __gen_uint(values->ScissorRectangleXMax, 0, 15) | 1420 __gen_uint(values->ScissorRectangleYMax, 16, 31); 1421} 1422 1423#define GEN8_SF_CLIP_VIEWPORT_length 16 1424struct GEN8_SF_CLIP_VIEWPORT { 1425 float ViewportMatrixElementm00; 1426 float ViewportMatrixElementm11; 1427 float ViewportMatrixElementm22; 1428 float ViewportMatrixElementm30; 1429 float ViewportMatrixElementm31; 1430 float ViewportMatrixElementm32; 1431 float XMinClipGuardband; 1432 float XMaxClipGuardband; 1433 float YMinClipGuardband; 1434 float YMaxClipGuardband; 1435 float XMinViewPort; 1436 float XMaxViewPort; 1437 float YMinViewPort; 1438 float YMaxViewPort; 1439}; 1440 1441static inline void 1442GEN8_SF_CLIP_VIEWPORT_pack(__attribute__((unused)) __gen_user_data *data, 1443 __attribute__((unused)) void * restrict dst, 1444 __attribute__((unused)) const struct GEN8_SF_CLIP_VIEWPORT * restrict values) 1445{ 1446 uint32_t * restrict dw = (uint32_t * restrict) dst; 1447 1448 dw[0] = 1449 __gen_float(values->ViewportMatrixElementm00); 1450 1451 dw[1] = 1452 __gen_float(values->ViewportMatrixElementm11); 1453 1454 dw[2] = 1455 __gen_float(values->ViewportMatrixElementm22); 1456 1457 dw[3] = 1458 __gen_float(values->ViewportMatrixElementm30); 1459 1460 dw[4] = 1461 __gen_float(values->ViewportMatrixElementm31); 1462 1463 dw[5] = 1464 __gen_float(values->ViewportMatrixElementm32); 1465 1466 dw[6] = 0; 1467 1468 dw[7] = 0; 1469 1470 dw[8] = 1471 __gen_float(values->XMinClipGuardband); 1472 1473 dw[9] = 1474 __gen_float(values->XMaxClipGuardband); 1475 1476 dw[10] = 1477 __gen_float(values->YMinClipGuardband); 1478 1479 dw[11] = 1480 __gen_float(values->YMaxClipGuardband); 1481 1482 dw[12] = 1483 __gen_float(values->XMinViewPort); 1484 1485 dw[13] = 1486 __gen_float(values->XMaxViewPort); 1487 1488 dw[14] = 1489 __gen_float(values->YMinViewPort); 1490 1491 dw[15] = 1492 __gen_float(values->YMaxViewPort); 1493} 1494 1495#define GEN8_SF_OUTPUT_ATTRIBUTE_DETAIL_length 1 1496struct GEN8_SF_OUTPUT_ATTRIBUTE_DETAIL { 1497 uint32_t SourceAttribute; 1498 uint32_t SwizzleSelect; 1499#define INPUTATTR 0 1500#define INPUTATTR_FACING 1 1501#define INPUTATTR_W 2 1502#define INPUTATTR_FACING_W 3 1503 uint32_t ConstantSource; 1504#define CONST_0000 0 1505#define CONST_0001_FLOAT 1 1506#define CONST_1111_FLOAT 2 1507#define PRIM_ID 3 1508 uint32_t SwizzleControlMode; 1509 bool ComponentOverrideX; 1510 bool ComponentOverrideY; 1511 bool ComponentOverrideZ; 1512 bool ComponentOverrideW; 1513}; 1514 1515static inline void 1516GEN8_SF_OUTPUT_ATTRIBUTE_DETAIL_pack(__attribute__((unused)) __gen_user_data *data, 1517 __attribute__((unused)) void * restrict dst, 1518 __attribute__((unused)) const struct GEN8_SF_OUTPUT_ATTRIBUTE_DETAIL * restrict values) 1519{ 1520 uint32_t * restrict dw = (uint32_t * restrict) dst; 1521 1522 dw[0] = 1523 __gen_uint(values->SourceAttribute, 0, 4) | 1524 __gen_uint(values->SwizzleSelect, 6, 7) | 1525 __gen_uint(values->ConstantSource, 9, 10) | 1526 __gen_uint(values->SwizzleControlMode, 11, 11) | 1527 __gen_uint(values->ComponentOverrideX, 12, 12) | 1528 __gen_uint(values->ComponentOverrideY, 13, 13) | 1529 __gen_uint(values->ComponentOverrideZ, 14, 14) | 1530 __gen_uint(values->ComponentOverrideW, 15, 15); 1531} 1532 1533#define GEN8_SO_DECL_length 1 1534struct GEN8_SO_DECL { 1535 uint32_t ComponentMask; 1536 uint32_t RegisterIndex; 1537 uint32_t HoleFlag; 1538 uint32_t OutputBufferSlot; 1539}; 1540 1541static inline void 1542GEN8_SO_DECL_pack(__attribute__((unused)) __gen_user_data *data, 1543 __attribute__((unused)) void * restrict dst, 1544 __attribute__((unused)) const struct GEN8_SO_DECL * restrict values) 1545{ 1546 uint32_t * restrict dw = (uint32_t * restrict) dst; 1547 1548 dw[0] = 1549 __gen_uint(values->ComponentMask, 0, 3) | 1550 __gen_uint(values->RegisterIndex, 4, 9) | 1551 __gen_uint(values->HoleFlag, 11, 11) | 1552 __gen_uint(values->OutputBufferSlot, 12, 13); 1553} 1554 1555#define GEN8_SO_DECL_ENTRY_length 2 1556struct GEN8_SO_DECL_ENTRY { 1557 struct GEN8_SO_DECL Stream0Decl; 1558 struct GEN8_SO_DECL Stream1Decl; 1559 struct GEN8_SO_DECL Stream2Decl; 1560 struct GEN8_SO_DECL Stream3Decl; 1561}; 1562 1563static inline void 1564GEN8_SO_DECL_ENTRY_pack(__attribute__((unused)) __gen_user_data *data, 1565 __attribute__((unused)) void * restrict dst, 1566 __attribute__((unused)) const struct GEN8_SO_DECL_ENTRY * restrict values) 1567{ 1568 uint32_t * restrict dw = (uint32_t * restrict) dst; 1569 1570 uint32_t v0_0; 1571 GEN8_SO_DECL_pack(data, &v0_0, &values->Stream0Decl); 1572 1573 uint32_t v0_1; 1574 GEN8_SO_DECL_pack(data, &v0_1, &values->Stream1Decl); 1575 1576 dw[0] = 1577 __gen_uint(v0_0, 0, 15) | 1578 __gen_uint(v0_1, 16, 31); 1579 1580 uint32_t v1_0; 1581 GEN8_SO_DECL_pack(data, &v1_0, &values->Stream2Decl); 1582 1583 uint32_t v1_1; 1584 GEN8_SO_DECL_pack(data, &v1_1, &values->Stream3Decl); 1585 1586 dw[1] = 1587 __gen_uint(v1_0, 0, 15) | 1588 __gen_uint(v1_1, 16, 31); 1589} 1590 1591#define GEN8_VERTEX_BUFFER_STATE_length 4 1592struct GEN8_VERTEX_BUFFER_STATE { 1593 uint32_t BufferPitch; 1594 bool NullVertexBuffer; 1595 bool AddressModifyEnable; 1596 uint32_t MOCS; 1597 uint32_t VertexBufferIndex; 1598 __gen_address_type BufferStartingAddress; 1599 uint32_t BufferSize; 1600}; 1601 1602static inline void 1603GEN8_VERTEX_BUFFER_STATE_pack(__attribute__((unused)) __gen_user_data *data, 1604 __attribute__((unused)) void * restrict dst, 1605 __attribute__((unused)) const struct GEN8_VERTEX_BUFFER_STATE * restrict values) 1606{ 1607 uint32_t * restrict dw = (uint32_t * restrict) dst; 1608 1609 dw[0] = 1610 __gen_uint(values->BufferPitch, 0, 11) | 1611 __gen_uint(values->NullVertexBuffer, 13, 13) | 1612 __gen_uint(values->AddressModifyEnable, 14, 14) | 1613 __gen_uint(values->MOCS, 16, 22) | 1614 __gen_uint(values->VertexBufferIndex, 26, 31); 1615 1616 const uint64_t v1_address = 1617 __gen_combine_address(data, &dw[1], values->BufferStartingAddress, 0); 1618 dw[1] = v1_address; 1619 dw[2] = v1_address >> 32; 1620 1621 dw[3] = 1622 __gen_uint(values->BufferSize, 0, 31); 1623} 1624 1625#define GEN8_VERTEX_ELEMENT_STATE_length 2 1626struct GEN8_VERTEX_ELEMENT_STATE { 1627 uint32_t SourceElementOffset; 1628 bool EdgeFlagEnable; 1629 uint32_t SourceElementFormat; 1630 bool Valid; 1631 uint32_t VertexBufferIndex; 1632 enum GEN8_3D_Vertex_Component_Control Component3Control; 1633 enum GEN8_3D_Vertex_Component_Control Component2Control; 1634 enum GEN8_3D_Vertex_Component_Control Component1Control; 1635 enum GEN8_3D_Vertex_Component_Control Component0Control; 1636}; 1637 1638static inline void 1639GEN8_VERTEX_ELEMENT_STATE_pack(__attribute__((unused)) __gen_user_data *data, 1640 __attribute__((unused)) void * restrict dst, 1641 __attribute__((unused)) const struct GEN8_VERTEX_ELEMENT_STATE * restrict values) 1642{ 1643 uint32_t * restrict dw = (uint32_t * restrict) dst; 1644 1645 dw[0] = 1646 __gen_uint(values->SourceElementOffset, 0, 11) | 1647 __gen_uint(values->EdgeFlagEnable, 15, 15) | 1648 __gen_uint(values->SourceElementFormat, 16, 24) | 1649 __gen_uint(values->Valid, 25, 25) | 1650 __gen_uint(values->VertexBufferIndex, 26, 31); 1651 1652 dw[1] = 1653 __gen_uint(values->Component3Control, 16, 18) | 1654 __gen_uint(values->Component2Control, 20, 22) | 1655 __gen_uint(values->Component1Control, 24, 26) | 1656 __gen_uint(values->Component0Control, 28, 30); 1657} 1658 1659#define GEN8_3DPRIMITIVE_length 7 1660#define GEN8_3DPRIMITIVE_length_bias 2 1661#define GEN8_3DPRIMITIVE_header \ 1662 .DWordLength = 5, \ 1663 ._3DCommandSubOpcode = 0, \ 1664 ._3DCommandOpcode = 3, \ 1665 .CommandSubType = 3, \ 1666 .CommandType = 3 1667 1668struct GEN8_3DPRIMITIVE { 1669 uint32_t DWordLength; 1670 bool PredicateEnable; 1671 bool UAVCoherencyRequired; 1672 bool IndirectParameterEnable; 1673 uint32_t _3DCommandSubOpcode; 1674 uint32_t _3DCommandOpcode; 1675 uint32_t CommandSubType; 1676 uint32_t CommandType; 1677 enum GEN8_3D_Prim_Topo_Type PrimitiveTopologyType; 1678 uint32_t VertexAccessType; 1679#define SEQUENTIAL 0 1680#define RANDOM 1 1681 bool EndOffsetEnable; 1682 uint32_t VertexCountPerInstance; 1683 uint32_t StartVertexLocation; 1684 uint32_t InstanceCount; 1685 uint32_t StartInstanceLocation; 1686 int32_t BaseVertexLocation; 1687}; 1688 1689static inline void 1690GEN8_3DPRIMITIVE_pack(__attribute__((unused)) __gen_user_data *data, 1691 __attribute__((unused)) void * restrict dst, 1692 __attribute__((unused)) const struct GEN8_3DPRIMITIVE * restrict values) 1693{ 1694 uint32_t * restrict dw = (uint32_t * restrict) dst; 1695 1696 dw[0] = 1697 __gen_uint(values->DWordLength, 0, 7) | 1698 __gen_uint(values->PredicateEnable, 8, 8) | 1699 __gen_uint(values->UAVCoherencyRequired, 9, 9) | 1700 __gen_uint(values->IndirectParameterEnable, 10, 10) | 1701 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 1702 __gen_uint(values->_3DCommandOpcode, 24, 26) | 1703 __gen_uint(values->CommandSubType, 27, 28) | 1704 __gen_uint(values->CommandType, 29, 31); 1705 1706 dw[1] = 1707 __gen_uint(values->PrimitiveTopologyType, 0, 5) | 1708 __gen_uint(values->VertexAccessType, 8, 8) | 1709 __gen_uint(values->EndOffsetEnable, 9, 9); 1710 1711 dw[2] = 1712 __gen_uint(values->VertexCountPerInstance, 0, 31); 1713 1714 dw[3] = 1715 __gen_uint(values->StartVertexLocation, 0, 31); 1716 1717 dw[4] = 1718 __gen_uint(values->InstanceCount, 0, 31); 1719 1720 dw[5] = 1721 __gen_uint(values->StartInstanceLocation, 0, 31); 1722 1723 dw[6] = 1724 __gen_sint(values->BaseVertexLocation, 0, 31); 1725} 1726 1727#define GEN8_3DSTATE_AA_LINE_PARAMETERS_length 3 1728#define GEN8_3DSTATE_AA_LINE_PARAMETERS_length_bias 2 1729#define GEN8_3DSTATE_AA_LINE_PARAMETERS_header \ 1730 .DWordLength = 1, \ 1731 ._3DCommandSubOpcode = 10, \ 1732 ._3DCommandOpcode = 1, \ 1733 .CommandSubType = 3, \ 1734 .CommandType = 3 1735 1736struct GEN8_3DSTATE_AA_LINE_PARAMETERS { 1737 uint32_t DWordLength; 1738 uint32_t _3DCommandSubOpcode; 1739 uint32_t _3DCommandOpcode; 1740 uint32_t CommandSubType; 1741 uint32_t CommandType; 1742 float AACoverageSlope; 1743 float AAPointCoverageSlope; 1744 float AACoverageBias; 1745 float AAPointCoverageBias; 1746 float AACoverageEndCapSlope; 1747 float AAPointCoverageEndCapSlope; 1748 float AACoverageEndCapBias; 1749 float AAPointCoverageEndCapBias; 1750}; 1751 1752static inline void 1753GEN8_3DSTATE_AA_LINE_PARAMETERS_pack(__attribute__((unused)) __gen_user_data *data, 1754 __attribute__((unused)) void * restrict dst, 1755 __attribute__((unused)) const struct GEN8_3DSTATE_AA_LINE_PARAMETERS * restrict values) 1756{ 1757 uint32_t * restrict dw = (uint32_t * restrict) dst; 1758 1759 dw[0] = 1760 __gen_uint(values->DWordLength, 0, 7) | 1761 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 1762 __gen_uint(values->_3DCommandOpcode, 24, 26) | 1763 __gen_uint(values->CommandSubType, 27, 28) | 1764 __gen_uint(values->CommandType, 29, 31); 1765 1766 dw[1] = 1767 __gen_ufixed(values->AACoverageSlope, 0, 7, 8) | 1768 __gen_ufixed(values->AAPointCoverageSlope, 8, 15, 8) | 1769 __gen_ufixed(values->AACoverageBias, 16, 23, 8) | 1770 __gen_ufixed(values->AAPointCoverageBias, 24, 31, 8); 1771 1772 dw[2] = 1773 __gen_ufixed(values->AACoverageEndCapSlope, 0, 7, 8) | 1774 __gen_ufixed(values->AAPointCoverageEndCapSlope, 8, 15, 8) | 1775 __gen_ufixed(values->AACoverageEndCapBias, 16, 23, 8) | 1776 __gen_ufixed(values->AAPointCoverageEndCapBias, 24, 31, 8); 1777} 1778 1779#define GEN8_3DSTATE_BINDING_TABLE_EDIT_DS_length_bias 2 1780#define GEN8_3DSTATE_BINDING_TABLE_EDIT_DS_header\ 1781 .DWordLength = 0, \ 1782 ._3DCommandSubOpcode = 70, \ 1783 ._3DCommandOpcode = 0, \ 1784 .CommandSubType = 3, \ 1785 .CommandType = 3 1786 1787struct GEN8_3DSTATE_BINDING_TABLE_EDIT_DS { 1788 uint32_t DWordLength; 1789 uint32_t _3DCommandSubOpcode; 1790 uint32_t _3DCommandOpcode; 1791 uint32_t CommandSubType; 1792 uint32_t CommandType; 1793 uint32_t BindingTableEditTarget; 1794#define AllCores 3 1795#define Core1 2 1796#define Core0 1 1797 uint32_t BindingTableBlockClear; 1798 /* variable length fields follow */ 1799}; 1800 1801static inline void 1802GEN8_3DSTATE_BINDING_TABLE_EDIT_DS_pack(__attribute__((unused)) __gen_user_data *data, 1803 __attribute__((unused)) void * restrict dst, 1804 __attribute__((unused)) const struct GEN8_3DSTATE_BINDING_TABLE_EDIT_DS * restrict values) 1805{ 1806 uint32_t * restrict dw = (uint32_t * restrict) dst; 1807 1808 dw[0] = 1809 __gen_uint(values->DWordLength, 0, 8) | 1810 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 1811 __gen_uint(values->_3DCommandOpcode, 24, 26) | 1812 __gen_uint(values->CommandSubType, 27, 28) | 1813 __gen_uint(values->CommandType, 29, 31); 1814 1815 dw[1] = 1816 __gen_uint(values->BindingTableEditTarget, 0, 1) | 1817 __gen_uint(values->BindingTableBlockClear, 16, 31); 1818} 1819 1820#define GEN8_3DSTATE_BINDING_TABLE_EDIT_GS_length_bias 2 1821#define GEN8_3DSTATE_BINDING_TABLE_EDIT_GS_header\ 1822 .DWordLength = 0, \ 1823 ._3DCommandSubOpcode = 68, \ 1824 ._3DCommandOpcode = 0, \ 1825 .CommandSubType = 3, \ 1826 .CommandType = 3 1827 1828struct GEN8_3DSTATE_BINDING_TABLE_EDIT_GS { 1829 uint32_t DWordLength; 1830 uint32_t _3DCommandSubOpcode; 1831 uint32_t _3DCommandOpcode; 1832 uint32_t CommandSubType; 1833 uint32_t CommandType; 1834 uint32_t BindingTableEditTarget; 1835#define AllCores 3 1836#define Core1 2 1837#define Core0 1 1838 uint32_t BindingTableBlockClear; 1839 /* variable length fields follow */ 1840}; 1841 1842static inline void 1843GEN8_3DSTATE_BINDING_TABLE_EDIT_GS_pack(__attribute__((unused)) __gen_user_data *data, 1844 __attribute__((unused)) void * restrict dst, 1845 __attribute__((unused)) const struct GEN8_3DSTATE_BINDING_TABLE_EDIT_GS * restrict values) 1846{ 1847 uint32_t * restrict dw = (uint32_t * restrict) dst; 1848 1849 dw[0] = 1850 __gen_uint(values->DWordLength, 0, 8) | 1851 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 1852 __gen_uint(values->_3DCommandOpcode, 24, 26) | 1853 __gen_uint(values->CommandSubType, 27, 28) | 1854 __gen_uint(values->CommandType, 29, 31); 1855 1856 dw[1] = 1857 __gen_uint(values->BindingTableEditTarget, 0, 1) | 1858 __gen_uint(values->BindingTableBlockClear, 16, 31); 1859} 1860 1861#define GEN8_3DSTATE_BINDING_TABLE_EDIT_HS_length_bias 2 1862#define GEN8_3DSTATE_BINDING_TABLE_EDIT_HS_header\ 1863 .DWordLength = 0, \ 1864 ._3DCommandSubOpcode = 69, \ 1865 ._3DCommandOpcode = 0, \ 1866 .CommandSubType = 3, \ 1867 .CommandType = 3 1868 1869struct GEN8_3DSTATE_BINDING_TABLE_EDIT_HS { 1870 uint32_t DWordLength; 1871 uint32_t _3DCommandSubOpcode; 1872 uint32_t _3DCommandOpcode; 1873 uint32_t CommandSubType; 1874 uint32_t CommandType; 1875 uint32_t BindingTableEditTarget; 1876#define AllCores 3 1877#define Core1 2 1878#define Core0 1 1879 uint32_t BindingTableBlockClear; 1880 /* variable length fields follow */ 1881}; 1882 1883static inline void 1884GEN8_3DSTATE_BINDING_TABLE_EDIT_HS_pack(__attribute__((unused)) __gen_user_data *data, 1885 __attribute__((unused)) void * restrict dst, 1886 __attribute__((unused)) const struct GEN8_3DSTATE_BINDING_TABLE_EDIT_HS * restrict values) 1887{ 1888 uint32_t * restrict dw = (uint32_t * restrict) dst; 1889 1890 dw[0] = 1891 __gen_uint(values->DWordLength, 0, 8) | 1892 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 1893 __gen_uint(values->_3DCommandOpcode, 24, 26) | 1894 __gen_uint(values->CommandSubType, 27, 28) | 1895 __gen_uint(values->CommandType, 29, 31); 1896 1897 dw[1] = 1898 __gen_uint(values->BindingTableEditTarget, 0, 1) | 1899 __gen_uint(values->BindingTableBlockClear, 16, 31); 1900} 1901 1902#define GEN8_3DSTATE_BINDING_TABLE_EDIT_PS_length_bias 2 1903#define GEN8_3DSTATE_BINDING_TABLE_EDIT_PS_header\ 1904 .DWordLength = 0, \ 1905 ._3DCommandSubOpcode = 71, \ 1906 ._3DCommandOpcode = 0, \ 1907 .CommandSubType = 3, \ 1908 .CommandType = 3 1909 1910struct GEN8_3DSTATE_BINDING_TABLE_EDIT_PS { 1911 uint32_t DWordLength; 1912 uint32_t _3DCommandSubOpcode; 1913 uint32_t _3DCommandOpcode; 1914 uint32_t CommandSubType; 1915 uint32_t CommandType; 1916 uint32_t BindingTableEditTarget; 1917#define AllCores 3 1918#define Core1 2 1919#define Core0 1 1920 uint32_t BindingTableBlockClear; 1921 /* variable length fields follow */ 1922}; 1923 1924static inline void 1925GEN8_3DSTATE_BINDING_TABLE_EDIT_PS_pack(__attribute__((unused)) __gen_user_data *data, 1926 __attribute__((unused)) void * restrict dst, 1927 __attribute__((unused)) const struct GEN8_3DSTATE_BINDING_TABLE_EDIT_PS * restrict values) 1928{ 1929 uint32_t * restrict dw = (uint32_t * restrict) dst; 1930 1931 dw[0] = 1932 __gen_uint(values->DWordLength, 0, 8) | 1933 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 1934 __gen_uint(values->_3DCommandOpcode, 24, 26) | 1935 __gen_uint(values->CommandSubType, 27, 28) | 1936 __gen_uint(values->CommandType, 29, 31); 1937 1938 dw[1] = 1939 __gen_uint(values->BindingTableEditTarget, 0, 1) | 1940 __gen_uint(values->BindingTableBlockClear, 16, 31); 1941} 1942 1943#define GEN8_3DSTATE_BINDING_TABLE_EDIT_VS_length_bias 2 1944#define GEN8_3DSTATE_BINDING_TABLE_EDIT_VS_header\ 1945 .DWordLength = 0, \ 1946 ._3DCommandSubOpcode = 67, \ 1947 ._3DCommandOpcode = 0, \ 1948 .CommandSubType = 3, \ 1949 .CommandType = 3 1950 1951struct GEN8_3DSTATE_BINDING_TABLE_EDIT_VS { 1952 uint32_t DWordLength; 1953 uint32_t _3DCommandSubOpcode; 1954 uint32_t _3DCommandOpcode; 1955 uint32_t CommandSubType; 1956 uint32_t CommandType; 1957 uint32_t BindingTableEditTarget; 1958#define AllCores 3 1959#define Core1 2 1960#define Core0 1 1961 uint32_t BindingTableBlockClear; 1962 /* variable length fields follow */ 1963}; 1964 1965static inline void 1966GEN8_3DSTATE_BINDING_TABLE_EDIT_VS_pack(__attribute__((unused)) __gen_user_data *data, 1967 __attribute__((unused)) void * restrict dst, 1968 __attribute__((unused)) const struct GEN8_3DSTATE_BINDING_TABLE_EDIT_VS * restrict values) 1969{ 1970 uint32_t * restrict dw = (uint32_t * restrict) dst; 1971 1972 dw[0] = 1973 __gen_uint(values->DWordLength, 0, 8) | 1974 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 1975 __gen_uint(values->_3DCommandOpcode, 24, 26) | 1976 __gen_uint(values->CommandSubType, 27, 28) | 1977 __gen_uint(values->CommandType, 29, 31); 1978 1979 dw[1] = 1980 __gen_uint(values->BindingTableEditTarget, 0, 1) | 1981 __gen_uint(values->BindingTableBlockClear, 16, 31); 1982} 1983 1984#define GEN8_3DSTATE_BINDING_TABLE_POINTERS_DS_length 2 1985#define GEN8_3DSTATE_BINDING_TABLE_POINTERS_DS_length_bias 2 1986#define GEN8_3DSTATE_BINDING_TABLE_POINTERS_DS_header\ 1987 .DWordLength = 0, \ 1988 ._3DCommandSubOpcode = 40, \ 1989 ._3DCommandOpcode = 0, \ 1990 .CommandSubType = 3, \ 1991 .CommandType = 3 1992 1993struct GEN8_3DSTATE_BINDING_TABLE_POINTERS_DS { 1994 uint32_t DWordLength; 1995 uint32_t _3DCommandSubOpcode; 1996 uint32_t _3DCommandOpcode; 1997 uint32_t CommandSubType; 1998 uint32_t CommandType; 1999 uint64_t PointertoDSBindingTable; 2000}; 2001 2002static inline void 2003GEN8_3DSTATE_BINDING_TABLE_POINTERS_DS_pack(__attribute__((unused)) __gen_user_data *data, 2004 __attribute__((unused)) void * restrict dst, 2005 __attribute__((unused)) const struct GEN8_3DSTATE_BINDING_TABLE_POINTERS_DS * restrict values) 2006{ 2007 uint32_t * restrict dw = (uint32_t * restrict) dst; 2008 2009 dw[0] = 2010 __gen_uint(values->DWordLength, 0, 7) | 2011 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 2012 __gen_uint(values->_3DCommandOpcode, 24, 26) | 2013 __gen_uint(values->CommandSubType, 27, 28) | 2014 __gen_uint(values->CommandType, 29, 31); 2015 2016 dw[1] = 2017 __gen_offset(values->PointertoDSBindingTable, 5, 15); 2018} 2019 2020#define GEN8_3DSTATE_BINDING_TABLE_POINTERS_GS_length 2 2021#define GEN8_3DSTATE_BINDING_TABLE_POINTERS_GS_length_bias 2 2022#define GEN8_3DSTATE_BINDING_TABLE_POINTERS_GS_header\ 2023 .DWordLength = 0, \ 2024 ._3DCommandSubOpcode = 41, \ 2025 ._3DCommandOpcode = 0, \ 2026 .CommandSubType = 3, \ 2027 .CommandType = 3 2028 2029struct GEN8_3DSTATE_BINDING_TABLE_POINTERS_GS { 2030 uint32_t DWordLength; 2031 uint32_t _3DCommandSubOpcode; 2032 uint32_t _3DCommandOpcode; 2033 uint32_t CommandSubType; 2034 uint32_t CommandType; 2035 uint64_t PointertoGSBindingTable; 2036}; 2037 2038static inline void 2039GEN8_3DSTATE_BINDING_TABLE_POINTERS_GS_pack(__attribute__((unused)) __gen_user_data *data, 2040 __attribute__((unused)) void * restrict dst, 2041 __attribute__((unused)) const struct GEN8_3DSTATE_BINDING_TABLE_POINTERS_GS * restrict values) 2042{ 2043 uint32_t * restrict dw = (uint32_t * restrict) dst; 2044 2045 dw[0] = 2046 __gen_uint(values->DWordLength, 0, 7) | 2047 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 2048 __gen_uint(values->_3DCommandOpcode, 24, 26) | 2049 __gen_uint(values->CommandSubType, 27, 28) | 2050 __gen_uint(values->CommandType, 29, 31); 2051 2052 dw[1] = 2053 __gen_offset(values->PointertoGSBindingTable, 5, 15); 2054} 2055 2056#define GEN8_3DSTATE_BINDING_TABLE_POINTERS_HS_length 2 2057#define GEN8_3DSTATE_BINDING_TABLE_POINTERS_HS_length_bias 2 2058#define GEN8_3DSTATE_BINDING_TABLE_POINTERS_HS_header\ 2059 .DWordLength = 0, \ 2060 ._3DCommandSubOpcode = 39, \ 2061 ._3DCommandOpcode = 0, \ 2062 .CommandSubType = 3, \ 2063 .CommandType = 3 2064 2065struct GEN8_3DSTATE_BINDING_TABLE_POINTERS_HS { 2066 uint32_t DWordLength; 2067 uint32_t _3DCommandSubOpcode; 2068 uint32_t _3DCommandOpcode; 2069 uint32_t CommandSubType; 2070 uint32_t CommandType; 2071 uint64_t PointertoHSBindingTable; 2072}; 2073 2074static inline void 2075GEN8_3DSTATE_BINDING_TABLE_POINTERS_HS_pack(__attribute__((unused)) __gen_user_data *data, 2076 __attribute__((unused)) void * restrict dst, 2077 __attribute__((unused)) const struct GEN8_3DSTATE_BINDING_TABLE_POINTERS_HS * restrict values) 2078{ 2079 uint32_t * restrict dw = (uint32_t * restrict) dst; 2080 2081 dw[0] = 2082 __gen_uint(values->DWordLength, 0, 7) | 2083 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 2084 __gen_uint(values->_3DCommandOpcode, 24, 26) | 2085 __gen_uint(values->CommandSubType, 27, 28) | 2086 __gen_uint(values->CommandType, 29, 31); 2087 2088 dw[1] = 2089 __gen_offset(values->PointertoHSBindingTable, 5, 15); 2090} 2091 2092#define GEN8_3DSTATE_BINDING_TABLE_POINTERS_PS_length 2 2093#define GEN8_3DSTATE_BINDING_TABLE_POINTERS_PS_length_bias 2 2094#define GEN8_3DSTATE_BINDING_TABLE_POINTERS_PS_header\ 2095 .DWordLength = 0, \ 2096 ._3DCommandSubOpcode = 42, \ 2097 ._3DCommandOpcode = 0, \ 2098 .CommandSubType = 3, \ 2099 .CommandType = 3 2100 2101struct GEN8_3DSTATE_BINDING_TABLE_POINTERS_PS { 2102 uint32_t DWordLength; 2103 uint32_t _3DCommandSubOpcode; 2104 uint32_t _3DCommandOpcode; 2105 uint32_t CommandSubType; 2106 uint32_t CommandType; 2107 uint64_t PointertoPSBindingTable; 2108}; 2109 2110static inline void 2111GEN8_3DSTATE_BINDING_TABLE_POINTERS_PS_pack(__attribute__((unused)) __gen_user_data *data, 2112 __attribute__((unused)) void * restrict dst, 2113 __attribute__((unused)) const struct GEN8_3DSTATE_BINDING_TABLE_POINTERS_PS * restrict values) 2114{ 2115 uint32_t * restrict dw = (uint32_t * restrict) dst; 2116 2117 dw[0] = 2118 __gen_uint(values->DWordLength, 0, 7) | 2119 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 2120 __gen_uint(values->_3DCommandOpcode, 24, 26) | 2121 __gen_uint(values->CommandSubType, 27, 28) | 2122 __gen_uint(values->CommandType, 29, 31); 2123 2124 dw[1] = 2125 __gen_offset(values->PointertoPSBindingTable, 5, 15); 2126} 2127 2128#define GEN8_3DSTATE_BINDING_TABLE_POINTERS_VS_length 2 2129#define GEN8_3DSTATE_BINDING_TABLE_POINTERS_VS_length_bias 2 2130#define GEN8_3DSTATE_BINDING_TABLE_POINTERS_VS_header\ 2131 .DWordLength = 0, \ 2132 ._3DCommandSubOpcode = 38, \ 2133 ._3DCommandOpcode = 0, \ 2134 .CommandSubType = 3, \ 2135 .CommandType = 3 2136 2137struct GEN8_3DSTATE_BINDING_TABLE_POINTERS_VS { 2138 uint32_t DWordLength; 2139 uint32_t _3DCommandSubOpcode; 2140 uint32_t _3DCommandOpcode; 2141 uint32_t CommandSubType; 2142 uint32_t CommandType; 2143 uint64_t PointertoVSBindingTable; 2144}; 2145 2146static inline void 2147GEN8_3DSTATE_BINDING_TABLE_POINTERS_VS_pack(__attribute__((unused)) __gen_user_data *data, 2148 __attribute__((unused)) void * restrict dst, 2149 __attribute__((unused)) const struct GEN8_3DSTATE_BINDING_TABLE_POINTERS_VS * restrict values) 2150{ 2151 uint32_t * restrict dw = (uint32_t * restrict) dst; 2152 2153 dw[0] = 2154 __gen_uint(values->DWordLength, 0, 7) | 2155 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 2156 __gen_uint(values->_3DCommandOpcode, 24, 26) | 2157 __gen_uint(values->CommandSubType, 27, 28) | 2158 __gen_uint(values->CommandType, 29, 31); 2159 2160 dw[1] = 2161 __gen_offset(values->PointertoVSBindingTable, 5, 15); 2162} 2163 2164#define GEN8_3DSTATE_BINDING_TABLE_POOL_ALLOC_length 4 2165#define GEN8_3DSTATE_BINDING_TABLE_POOL_ALLOC_length_bias 2 2166#define GEN8_3DSTATE_BINDING_TABLE_POOL_ALLOC_header\ 2167 .DWordLength = 2, \ 2168 ._3DCommandSubOpcode = 25, \ 2169 ._3DCommandOpcode = 1, \ 2170 .CommandSubType = 3, \ 2171 .CommandType = 3 2172 2173struct GEN8_3DSTATE_BINDING_TABLE_POOL_ALLOC { 2174 uint32_t DWordLength; 2175 uint32_t _3DCommandSubOpcode; 2176 uint32_t _3DCommandOpcode; 2177 uint32_t CommandSubType; 2178 uint32_t CommandType; 2179 uint32_t MOCS; 2180 uint32_t BindingTablePoolEnable; 2181 __gen_address_type BindingTablePoolBaseAddress; 2182 uint32_t BindingTablePoolBufferSize; 2183#define NoValidData 0 2184}; 2185 2186static inline void 2187GEN8_3DSTATE_BINDING_TABLE_POOL_ALLOC_pack(__attribute__((unused)) __gen_user_data *data, 2188 __attribute__((unused)) void * restrict dst, 2189 __attribute__((unused)) const struct GEN8_3DSTATE_BINDING_TABLE_POOL_ALLOC * restrict values) 2190{ 2191 uint32_t * restrict dw = (uint32_t * restrict) dst; 2192 2193 dw[0] = 2194 __gen_uint(values->DWordLength, 0, 7) | 2195 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 2196 __gen_uint(values->_3DCommandOpcode, 24, 26) | 2197 __gen_uint(values->CommandSubType, 27, 28) | 2198 __gen_uint(values->CommandType, 29, 31); 2199 2200 const uint64_t v1 = 2201 __gen_uint(values->MOCS, 0, 6) | 2202 __gen_uint(values->BindingTablePoolEnable, 11, 11); 2203 const uint64_t v1_address = 2204 __gen_combine_address(data, &dw[1], values->BindingTablePoolBaseAddress, v1); 2205 dw[1] = v1_address; 2206 dw[2] = (v1_address >> 32) | (v1 >> 32); 2207 2208 dw[3] = 2209 __gen_uint(values->BindingTablePoolBufferSize, 12, 31); 2210} 2211 2212#define GEN8_3DSTATE_BLEND_STATE_POINTERS_length 2 2213#define GEN8_3DSTATE_BLEND_STATE_POINTERS_length_bias 2 2214#define GEN8_3DSTATE_BLEND_STATE_POINTERS_header\ 2215 .DWordLength = 0, \ 2216 ._3DCommandSubOpcode = 36, \ 2217 ._3DCommandOpcode = 0, \ 2218 .CommandSubType = 3, \ 2219 .CommandType = 3 2220 2221struct GEN8_3DSTATE_BLEND_STATE_POINTERS { 2222 uint32_t DWordLength; 2223 uint32_t _3DCommandSubOpcode; 2224 uint32_t _3DCommandOpcode; 2225 uint32_t CommandSubType; 2226 uint32_t CommandType; 2227 bool BlendStatePointerValid; 2228 uint64_t BlendStatePointer; 2229}; 2230 2231static inline void 2232GEN8_3DSTATE_BLEND_STATE_POINTERS_pack(__attribute__((unused)) __gen_user_data *data, 2233 __attribute__((unused)) void * restrict dst, 2234 __attribute__((unused)) const struct GEN8_3DSTATE_BLEND_STATE_POINTERS * restrict values) 2235{ 2236 uint32_t * restrict dw = (uint32_t * restrict) dst; 2237 2238 dw[0] = 2239 __gen_uint(values->DWordLength, 0, 7) | 2240 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 2241 __gen_uint(values->_3DCommandOpcode, 24, 26) | 2242 __gen_uint(values->CommandSubType, 27, 28) | 2243 __gen_uint(values->CommandType, 29, 31); 2244 2245 dw[1] = 2246 __gen_uint(values->BlendStatePointerValid, 0, 0) | 2247 __gen_offset(values->BlendStatePointer, 6, 31); 2248} 2249 2250#define GEN8_3DSTATE_CC_STATE_POINTERS_length 2 2251#define GEN8_3DSTATE_CC_STATE_POINTERS_length_bias 2 2252#define GEN8_3DSTATE_CC_STATE_POINTERS_header \ 2253 .DWordLength = 0, \ 2254 ._3DCommandSubOpcode = 14, \ 2255 ._3DCommandOpcode = 0, \ 2256 .CommandSubType = 3, \ 2257 .CommandType = 3 2258 2259struct GEN8_3DSTATE_CC_STATE_POINTERS { 2260 uint32_t DWordLength; 2261 uint32_t _3DCommandSubOpcode; 2262 uint32_t _3DCommandOpcode; 2263 uint32_t CommandSubType; 2264 uint32_t CommandType; 2265 bool ColorCalcStatePointerValid; 2266 uint64_t ColorCalcStatePointer; 2267}; 2268 2269static inline void 2270GEN8_3DSTATE_CC_STATE_POINTERS_pack(__attribute__((unused)) __gen_user_data *data, 2271 __attribute__((unused)) void * restrict dst, 2272 __attribute__((unused)) const struct GEN8_3DSTATE_CC_STATE_POINTERS * restrict values) 2273{ 2274 uint32_t * restrict dw = (uint32_t * restrict) dst; 2275 2276 dw[0] = 2277 __gen_uint(values->DWordLength, 0, 7) | 2278 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 2279 __gen_uint(values->_3DCommandOpcode, 24, 26) | 2280 __gen_uint(values->CommandSubType, 27, 28) | 2281 __gen_uint(values->CommandType, 29, 31); 2282 2283 dw[1] = 2284 __gen_uint(values->ColorCalcStatePointerValid, 0, 0) | 2285 __gen_offset(values->ColorCalcStatePointer, 6, 31); 2286} 2287 2288#define GEN8_3DSTATE_CHROMA_KEY_length 4 2289#define GEN8_3DSTATE_CHROMA_KEY_length_bias 2 2290#define GEN8_3DSTATE_CHROMA_KEY_header \ 2291 .DWordLength = 2, \ 2292 ._3DCommandSubOpcode = 4, \ 2293 ._3DCommandOpcode = 1, \ 2294 .CommandSubType = 3, \ 2295 .CommandType = 3 2296 2297struct GEN8_3DSTATE_CHROMA_KEY { 2298 uint32_t DWordLength; 2299 uint32_t _3DCommandSubOpcode; 2300 uint32_t _3DCommandOpcode; 2301 uint32_t CommandSubType; 2302 uint32_t CommandType; 2303 uint32_t ChromaKeyTableIndex; 2304 uint32_t ChromaKeyLowValue; 2305 uint32_t ChromaKeyHighValue; 2306}; 2307 2308static inline void 2309GEN8_3DSTATE_CHROMA_KEY_pack(__attribute__((unused)) __gen_user_data *data, 2310 __attribute__((unused)) void * restrict dst, 2311 __attribute__((unused)) const struct GEN8_3DSTATE_CHROMA_KEY * restrict values) 2312{ 2313 uint32_t * restrict dw = (uint32_t * restrict) dst; 2314 2315 dw[0] = 2316 __gen_uint(values->DWordLength, 0, 7) | 2317 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 2318 __gen_uint(values->_3DCommandOpcode, 24, 26) | 2319 __gen_uint(values->CommandSubType, 27, 28) | 2320 __gen_uint(values->CommandType, 29, 31); 2321 2322 dw[1] = 2323 __gen_uint(values->ChromaKeyTableIndex, 30, 31); 2324 2325 dw[2] = 2326 __gen_uint(values->ChromaKeyLowValue, 0, 31); 2327 2328 dw[3] = 2329 __gen_uint(values->ChromaKeyHighValue, 0, 31); 2330} 2331 2332#define GEN8_3DSTATE_CLEAR_PARAMS_length 3 2333#define GEN8_3DSTATE_CLEAR_PARAMS_length_bias 2 2334#define GEN8_3DSTATE_CLEAR_PARAMS_header \ 2335 .DWordLength = 1, \ 2336 ._3DCommandSubOpcode = 4, \ 2337 ._3DCommandOpcode = 0, \ 2338 .CommandSubType = 3, \ 2339 .CommandType = 3 2340 2341struct GEN8_3DSTATE_CLEAR_PARAMS { 2342 uint32_t DWordLength; 2343 uint32_t _3DCommandSubOpcode; 2344 uint32_t _3DCommandOpcode; 2345 uint32_t CommandSubType; 2346 uint32_t CommandType; 2347 float DepthClearValue; 2348 bool DepthClearValueValid; 2349}; 2350 2351static inline void 2352GEN8_3DSTATE_CLEAR_PARAMS_pack(__attribute__((unused)) __gen_user_data *data, 2353 __attribute__((unused)) void * restrict dst, 2354 __attribute__((unused)) const struct GEN8_3DSTATE_CLEAR_PARAMS * restrict values) 2355{ 2356 uint32_t * restrict dw = (uint32_t * restrict) dst; 2357 2358 dw[0] = 2359 __gen_uint(values->DWordLength, 0, 7) | 2360 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 2361 __gen_uint(values->_3DCommandOpcode, 24, 26) | 2362 __gen_uint(values->CommandSubType, 27, 28) | 2363 __gen_uint(values->CommandType, 29, 31); 2364 2365 dw[1] = 2366 __gen_float(values->DepthClearValue); 2367 2368 dw[2] = 2369 __gen_uint(values->DepthClearValueValid, 0, 0); 2370} 2371 2372#define GEN8_3DSTATE_CLIP_length 4 2373#define GEN8_3DSTATE_CLIP_length_bias 2 2374#define GEN8_3DSTATE_CLIP_header \ 2375 .DWordLength = 2, \ 2376 ._3DCommandSubOpcode = 18, \ 2377 ._3DCommandOpcode = 0, \ 2378 .CommandSubType = 3, \ 2379 .CommandType = 3 2380 2381struct GEN8_3DSTATE_CLIP { 2382 uint32_t DWordLength; 2383 uint32_t _3DCommandSubOpcode; 2384 uint32_t _3DCommandOpcode; 2385 uint32_t CommandSubType; 2386 uint32_t CommandType; 2387 uint32_t UserClipDistanceCullTestEnableBitmask; 2388 bool StatisticsEnable; 2389 bool ForceClipMode; 2390 bool ForceUserClipDistanceClipTestEnableBitmask; 2391 bool EarlyCullEnable; 2392 uint32_t VertexSubPixelPrecisionSelect; 2393#define _8Bit 0 2394#define _4Bit 1 2395 bool ForceUserClipDistanceCullTestEnableBitmask; 2396 uint32_t TriangleFanProvokingVertexSelect; 2397 uint32_t LineStripListProvokingVertexSelect; 2398 uint32_t TriangleStripListProvokingVertexSelect; 2399 bool NonPerspectiveBarycentricEnable; 2400 bool PerspectiveDivideDisable; 2401 uint32_t ClipMode; 2402#define CLIPMODE_NORMAL 0 2403#define CLIPMODE_REJECT_ALL 3 2404#define CLIPMODE_ACCEPT_ALL 4 2405 uint32_t UserClipDistanceClipTestEnableBitmask; 2406 bool GuardbandClipTestEnable; 2407 bool ViewportXYClipTestEnable; 2408 uint32_t APIMode; 2409#define APIMODE_OGL 0 2410#define APIMODE_D3D 1 2411 bool ClipEnable; 2412 uint32_t MaximumVPIndex; 2413 bool ForceZeroRTAIndexEnable; 2414 float MaximumPointWidth; 2415 float MinimumPointWidth; 2416}; 2417 2418static inline void 2419GEN8_3DSTATE_CLIP_pack(__attribute__((unused)) __gen_user_data *data, 2420 __attribute__((unused)) void * restrict dst, 2421 __attribute__((unused)) const struct GEN8_3DSTATE_CLIP * restrict values) 2422{ 2423 uint32_t * restrict dw = (uint32_t * restrict) dst; 2424 2425 dw[0] = 2426 __gen_uint(values->DWordLength, 0, 7) | 2427 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 2428 __gen_uint(values->_3DCommandOpcode, 24, 26) | 2429 __gen_uint(values->CommandSubType, 27, 28) | 2430 __gen_uint(values->CommandType, 29, 31); 2431 2432 dw[1] = 2433 __gen_uint(values->UserClipDistanceCullTestEnableBitmask, 0, 7) | 2434 __gen_uint(values->StatisticsEnable, 10, 10) | 2435 __gen_uint(values->ForceClipMode, 16, 16) | 2436 __gen_uint(values->ForceUserClipDistanceClipTestEnableBitmask, 17, 17) | 2437 __gen_uint(values->EarlyCullEnable, 18, 18) | 2438 __gen_uint(values->VertexSubPixelPrecisionSelect, 19, 19) | 2439 __gen_uint(values->ForceUserClipDistanceCullTestEnableBitmask, 20, 20); 2440 2441 dw[2] = 2442 __gen_uint(values->TriangleFanProvokingVertexSelect, 0, 1) | 2443 __gen_uint(values->LineStripListProvokingVertexSelect, 2, 3) | 2444 __gen_uint(values->TriangleStripListProvokingVertexSelect, 4, 5) | 2445 __gen_uint(values->NonPerspectiveBarycentricEnable, 8, 8) | 2446 __gen_uint(values->PerspectiveDivideDisable, 9, 9) | 2447 __gen_uint(values->ClipMode, 13, 15) | 2448 __gen_uint(values->UserClipDistanceClipTestEnableBitmask, 16, 23) | 2449 __gen_uint(values->GuardbandClipTestEnable, 26, 26) | 2450 __gen_uint(values->ViewportXYClipTestEnable, 28, 28) | 2451 __gen_uint(values->APIMode, 30, 30) | 2452 __gen_uint(values->ClipEnable, 31, 31); 2453 2454 dw[3] = 2455 __gen_uint(values->MaximumVPIndex, 0, 3) | 2456 __gen_uint(values->ForceZeroRTAIndexEnable, 5, 5) | 2457 __gen_ufixed(values->MaximumPointWidth, 6, 16, 3) | 2458 __gen_ufixed(values->MinimumPointWidth, 17, 27, 3); 2459} 2460 2461#define GEN8_3DSTATE_CONSTANT_DS_length 11 2462#define GEN8_3DSTATE_CONSTANT_DS_length_bias 2 2463#define GEN8_3DSTATE_CONSTANT_DS_header \ 2464 .DWordLength = 9, \ 2465 ._3DCommandSubOpcode = 26, \ 2466 ._3DCommandOpcode = 0, \ 2467 .CommandSubType = 3, \ 2468 .CommandType = 3 2469 2470struct GEN8_3DSTATE_CONSTANT_DS { 2471 uint32_t DWordLength; 2472 uint32_t MOCS; 2473 uint32_t _3DCommandSubOpcode; 2474 uint32_t _3DCommandOpcode; 2475 uint32_t CommandSubType; 2476 uint32_t CommandType; 2477 struct GEN8_3DSTATE_CONSTANT_BODY ConstantBody; 2478}; 2479 2480static inline void 2481GEN8_3DSTATE_CONSTANT_DS_pack(__attribute__((unused)) __gen_user_data *data, 2482 __attribute__((unused)) void * restrict dst, 2483 __attribute__((unused)) const struct GEN8_3DSTATE_CONSTANT_DS * restrict values) 2484{ 2485 uint32_t * restrict dw = (uint32_t * restrict) dst; 2486 2487 dw[0] = 2488 __gen_uint(values->DWordLength, 0, 7) | 2489 __gen_uint(values->MOCS, 8, 14) | 2490 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 2491 __gen_uint(values->_3DCommandOpcode, 24, 26) | 2492 __gen_uint(values->CommandSubType, 27, 28) | 2493 __gen_uint(values->CommandType, 29, 31); 2494 2495 GEN8_3DSTATE_CONSTANT_BODY_pack(data, &dw[1], &values->ConstantBody); 2496} 2497 2498#define GEN8_3DSTATE_CONSTANT_GS_length 11 2499#define GEN8_3DSTATE_CONSTANT_GS_length_bias 2 2500#define GEN8_3DSTATE_CONSTANT_GS_header \ 2501 .DWordLength = 9, \ 2502 ._3DCommandSubOpcode = 22, \ 2503 ._3DCommandOpcode = 0, \ 2504 .CommandSubType = 3, \ 2505 .CommandType = 3 2506 2507struct GEN8_3DSTATE_CONSTANT_GS { 2508 uint32_t DWordLength; 2509 uint32_t MOCS; 2510 uint32_t _3DCommandSubOpcode; 2511 uint32_t _3DCommandOpcode; 2512 uint32_t CommandSubType; 2513 uint32_t CommandType; 2514 struct GEN8_3DSTATE_CONSTANT_BODY ConstantBody; 2515}; 2516 2517static inline void 2518GEN8_3DSTATE_CONSTANT_GS_pack(__attribute__((unused)) __gen_user_data *data, 2519 __attribute__((unused)) void * restrict dst, 2520 __attribute__((unused)) const struct GEN8_3DSTATE_CONSTANT_GS * restrict values) 2521{ 2522 uint32_t * restrict dw = (uint32_t * restrict) dst; 2523 2524 dw[0] = 2525 __gen_uint(values->DWordLength, 0, 7) | 2526 __gen_uint(values->MOCS, 8, 14) | 2527 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 2528 __gen_uint(values->_3DCommandOpcode, 24, 26) | 2529 __gen_uint(values->CommandSubType, 27, 28) | 2530 __gen_uint(values->CommandType, 29, 31); 2531 2532 GEN8_3DSTATE_CONSTANT_BODY_pack(data, &dw[1], &values->ConstantBody); 2533} 2534 2535#define GEN8_3DSTATE_CONSTANT_HS_length 11 2536#define GEN8_3DSTATE_CONSTANT_HS_length_bias 2 2537#define GEN8_3DSTATE_CONSTANT_HS_header \ 2538 .DWordLength = 9, \ 2539 ._3DCommandSubOpcode = 25, \ 2540 ._3DCommandOpcode = 0, \ 2541 .CommandSubType = 3, \ 2542 .CommandType = 3 2543 2544struct GEN8_3DSTATE_CONSTANT_HS { 2545 uint32_t DWordLength; 2546 uint32_t MOCS; 2547 uint32_t _3DCommandSubOpcode; 2548 uint32_t _3DCommandOpcode; 2549 uint32_t CommandSubType; 2550 uint32_t CommandType; 2551 struct GEN8_3DSTATE_CONSTANT_BODY ConstantBody; 2552}; 2553 2554static inline void 2555GEN8_3DSTATE_CONSTANT_HS_pack(__attribute__((unused)) __gen_user_data *data, 2556 __attribute__((unused)) void * restrict dst, 2557 __attribute__((unused)) const struct GEN8_3DSTATE_CONSTANT_HS * restrict values) 2558{ 2559 uint32_t * restrict dw = (uint32_t * restrict) dst; 2560 2561 dw[0] = 2562 __gen_uint(values->DWordLength, 0, 7) | 2563 __gen_uint(values->MOCS, 8, 14) | 2564 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 2565 __gen_uint(values->_3DCommandOpcode, 24, 26) | 2566 __gen_uint(values->CommandSubType, 27, 28) | 2567 __gen_uint(values->CommandType, 29, 31); 2568 2569 GEN8_3DSTATE_CONSTANT_BODY_pack(data, &dw[1], &values->ConstantBody); 2570} 2571 2572#define GEN8_3DSTATE_CONSTANT_PS_length 11 2573#define GEN8_3DSTATE_CONSTANT_PS_length_bias 2 2574#define GEN8_3DSTATE_CONSTANT_PS_header \ 2575 .DWordLength = 9, \ 2576 ._3DCommandSubOpcode = 23, \ 2577 ._3DCommandOpcode = 0, \ 2578 .CommandSubType = 3, \ 2579 .CommandType = 3 2580 2581struct GEN8_3DSTATE_CONSTANT_PS { 2582 uint32_t DWordLength; 2583 uint32_t MOCS; 2584 uint32_t _3DCommandSubOpcode; 2585 uint32_t _3DCommandOpcode; 2586 uint32_t CommandSubType; 2587 uint32_t CommandType; 2588 struct GEN8_3DSTATE_CONSTANT_BODY ConstantBody; 2589}; 2590 2591static inline void 2592GEN8_3DSTATE_CONSTANT_PS_pack(__attribute__((unused)) __gen_user_data *data, 2593 __attribute__((unused)) void * restrict dst, 2594 __attribute__((unused)) const struct GEN8_3DSTATE_CONSTANT_PS * restrict values) 2595{ 2596 uint32_t * restrict dw = (uint32_t * restrict) dst; 2597 2598 dw[0] = 2599 __gen_uint(values->DWordLength, 0, 7) | 2600 __gen_uint(values->MOCS, 8, 14) | 2601 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 2602 __gen_uint(values->_3DCommandOpcode, 24, 26) | 2603 __gen_uint(values->CommandSubType, 27, 28) | 2604 __gen_uint(values->CommandType, 29, 31); 2605 2606 GEN8_3DSTATE_CONSTANT_BODY_pack(data, &dw[1], &values->ConstantBody); 2607} 2608 2609#define GEN8_3DSTATE_CONSTANT_VS_length 11 2610#define GEN8_3DSTATE_CONSTANT_VS_length_bias 2 2611#define GEN8_3DSTATE_CONSTANT_VS_header \ 2612 .DWordLength = 9, \ 2613 ._3DCommandSubOpcode = 21, \ 2614 ._3DCommandOpcode = 0, \ 2615 .CommandSubType = 3, \ 2616 .CommandType = 3 2617 2618struct GEN8_3DSTATE_CONSTANT_VS { 2619 uint32_t DWordLength; 2620 uint32_t MOCS; 2621 uint32_t _3DCommandSubOpcode; 2622 uint32_t _3DCommandOpcode; 2623 uint32_t CommandSubType; 2624 uint32_t CommandType; 2625 struct GEN8_3DSTATE_CONSTANT_BODY ConstantBody; 2626}; 2627 2628static inline void 2629GEN8_3DSTATE_CONSTANT_VS_pack(__attribute__((unused)) __gen_user_data *data, 2630 __attribute__((unused)) void * restrict dst, 2631 __attribute__((unused)) const struct GEN8_3DSTATE_CONSTANT_VS * restrict values) 2632{ 2633 uint32_t * restrict dw = (uint32_t * restrict) dst; 2634 2635 dw[0] = 2636 __gen_uint(values->DWordLength, 0, 7) | 2637 __gen_uint(values->MOCS, 8, 14) | 2638 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 2639 __gen_uint(values->_3DCommandOpcode, 24, 26) | 2640 __gen_uint(values->CommandSubType, 27, 28) | 2641 __gen_uint(values->CommandType, 29, 31); 2642 2643 GEN8_3DSTATE_CONSTANT_BODY_pack(data, &dw[1], &values->ConstantBody); 2644} 2645 2646#define GEN8_3DSTATE_DEPTH_BUFFER_length 8 2647#define GEN8_3DSTATE_DEPTH_BUFFER_length_bias 2 2648#define GEN8_3DSTATE_DEPTH_BUFFER_header \ 2649 .DWordLength = 6, \ 2650 ._3DCommandSubOpcode = 5, \ 2651 ._3DCommandOpcode = 0, \ 2652 .CommandSubType = 3, \ 2653 .CommandType = 3 2654 2655struct GEN8_3DSTATE_DEPTH_BUFFER { 2656 uint32_t DWordLength; 2657 uint32_t _3DCommandSubOpcode; 2658 uint32_t _3DCommandOpcode; 2659 uint32_t CommandSubType; 2660 uint32_t CommandType; 2661 uint32_t SurfacePitch; 2662 uint32_t SurfaceFormat; 2663#define D32_FLOAT 1 2664#define D24_UNORM_X8_UINT 3 2665#define D16_UNORM 5 2666 bool HierarchicalDepthBufferEnable; 2667 bool StencilWriteEnable; 2668 bool DepthWriteEnable; 2669 uint32_t SurfaceType; 2670#define SURFTYPE_1D 0 2671#define SURFTYPE_2D 1 2672#define SURFTYPE_3D 2 2673#define SURFTYPE_CUBE 3 2674#define SURFTYPE_NULL 7 2675 __gen_address_type SurfaceBaseAddress; 2676 uint32_t LOD; 2677 uint32_t Width; 2678 uint32_t Height; 2679 uint32_t MOCS; 2680 uint32_t MinimumArrayElement; 2681 uint32_t Depth; 2682 uint32_t SurfaceQPitch; 2683 uint32_t RenderTargetViewExtent; 2684}; 2685 2686static inline void 2687GEN8_3DSTATE_DEPTH_BUFFER_pack(__attribute__((unused)) __gen_user_data *data, 2688 __attribute__((unused)) void * restrict dst, 2689 __attribute__((unused)) const struct GEN8_3DSTATE_DEPTH_BUFFER * restrict values) 2690{ 2691 uint32_t * restrict dw = (uint32_t * restrict) dst; 2692 2693 dw[0] = 2694 __gen_uint(values->DWordLength, 0, 7) | 2695 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 2696 __gen_uint(values->_3DCommandOpcode, 24, 26) | 2697 __gen_uint(values->CommandSubType, 27, 28) | 2698 __gen_uint(values->CommandType, 29, 31); 2699 2700 dw[1] = 2701 __gen_uint(values->SurfacePitch, 0, 17) | 2702 __gen_uint(values->SurfaceFormat, 18, 20) | 2703 __gen_uint(values->HierarchicalDepthBufferEnable, 22, 22) | 2704 __gen_uint(values->StencilWriteEnable, 27, 27) | 2705 __gen_uint(values->DepthWriteEnable, 28, 28) | 2706 __gen_uint(values->SurfaceType, 29, 31); 2707 2708 const uint64_t v2_address = 2709 __gen_combine_address(data, &dw[2], values->SurfaceBaseAddress, 0); 2710 dw[2] = v2_address; 2711 dw[3] = v2_address >> 32; 2712 2713 dw[4] = 2714 __gen_uint(values->LOD, 0, 3) | 2715 __gen_uint(values->Width, 4, 17) | 2716 __gen_uint(values->Height, 18, 31); 2717 2718 dw[5] = 2719 __gen_uint(values->MOCS, 0, 6) | 2720 __gen_uint(values->MinimumArrayElement, 10, 20) | 2721 __gen_uint(values->Depth, 21, 31); 2722 2723 dw[6] = 0; 2724 2725 dw[7] = 2726 __gen_uint(values->SurfaceQPitch, 0, 14) | 2727 __gen_uint(values->RenderTargetViewExtent, 21, 31); 2728} 2729 2730#define GEN8_3DSTATE_DRAWING_RECTANGLE_length 4 2731#define GEN8_3DSTATE_DRAWING_RECTANGLE_length_bias 2 2732#define GEN8_3DSTATE_DRAWING_RECTANGLE_header \ 2733 .DWordLength = 2, \ 2734 ._3DCommandSubOpcode = 0, \ 2735 ._3DCommandOpcode = 1, \ 2736 .CommandSubType = 3, \ 2737 .CommandType = 3 2738 2739struct GEN8_3DSTATE_DRAWING_RECTANGLE { 2740 uint32_t DWordLength; 2741 uint32_t CoreModeSelect; 2742#define Legacy 0 2743#define Core0Enabled 1 2744#define Core1Enabled 2 2745 uint32_t _3DCommandSubOpcode; 2746 uint32_t _3DCommandOpcode; 2747 uint32_t CommandSubType; 2748 uint32_t CommandType; 2749 uint32_t ClippedDrawingRectangleXMin; 2750 uint32_t ClippedDrawingRectangleYMin; 2751 uint32_t ClippedDrawingRectangleXMax; 2752 uint32_t ClippedDrawingRectangleYMax; 2753 int32_t DrawingRectangleOriginX; 2754 int32_t DrawingRectangleOriginY; 2755}; 2756 2757static inline void 2758GEN8_3DSTATE_DRAWING_RECTANGLE_pack(__attribute__((unused)) __gen_user_data *data, 2759 __attribute__((unused)) void * restrict dst, 2760 __attribute__((unused)) const struct GEN8_3DSTATE_DRAWING_RECTANGLE * restrict values) 2761{ 2762 uint32_t * restrict dw = (uint32_t * restrict) dst; 2763 2764 dw[0] = 2765 __gen_uint(values->DWordLength, 0, 7) | 2766 __gen_uint(values->CoreModeSelect, 14, 15) | 2767 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 2768 __gen_uint(values->_3DCommandOpcode, 24, 26) | 2769 __gen_uint(values->CommandSubType, 27, 28) | 2770 __gen_uint(values->CommandType, 29, 31); 2771 2772 dw[1] = 2773 __gen_uint(values->ClippedDrawingRectangleXMin, 0, 15) | 2774 __gen_uint(values->ClippedDrawingRectangleYMin, 16, 31); 2775 2776 dw[2] = 2777 __gen_uint(values->ClippedDrawingRectangleXMax, 0, 15) | 2778 __gen_uint(values->ClippedDrawingRectangleYMax, 16, 31); 2779 2780 dw[3] = 2781 __gen_sint(values->DrawingRectangleOriginX, 0, 15) | 2782 __gen_sint(values->DrawingRectangleOriginY, 16, 31); 2783} 2784 2785#define GEN8_3DSTATE_DS_length 9 2786#define GEN8_3DSTATE_DS_length_bias 2 2787#define GEN8_3DSTATE_DS_header \ 2788 .DWordLength = 7, \ 2789 ._3DCommandSubOpcode = 29, \ 2790 ._3DCommandOpcode = 0, \ 2791 .CommandSubType = 3, \ 2792 .CommandType = 3 2793 2794struct GEN8_3DSTATE_DS { 2795 uint32_t DWordLength; 2796 uint32_t _3DCommandSubOpcode; 2797 uint32_t _3DCommandOpcode; 2798 uint32_t CommandSubType; 2799 uint32_t CommandType; 2800 uint64_t KernelStartPointer; 2801 bool SoftwareExceptionEnable; 2802 bool IllegalOpcodeExceptionEnable; 2803 bool AccessesUAV; 2804 uint32_t FloatingPointMode; 2805#define IEEE754 0 2806#define Alternate 1 2807 uint32_t ThreadDispatchPriority; 2808#define High 1 2809 uint32_t BindingTableEntryCount; 2810 uint32_t SamplerCount; 2811#define NoSamplers 0 2812#define _14Samplers 1 2813#define _58Samplers 2 2814#define _912Samplers 3 2815#define _1316Samplers 4 2816 bool VectorMaskEnable; 2817 uint32_t SingleDomainPointDispatch; 2818 uint32_t PerThreadScratchSpace; 2819 __gen_address_type ScratchSpaceBasePointer; 2820 uint32_t PatchURBEntryReadOffset; 2821 uint32_t PatchURBEntryReadLength; 2822 uint32_t DispatchGRFStartRegisterForURBData; 2823 bool Enable; 2824 bool CacheDisable; 2825 bool ComputeWCoordinateEnable; 2826 uint32_t DispatchMode; 2827#define DISPATCH_MODE_SIMD4X2 0 2828#define DISPATCH_MODE_SIMD8_SINGLE_PATCH 1 2829 bool StatisticsEnable; 2830 uint32_t MaximumNumberofThreads; 2831 uint32_t UserClipDistanceCullTestEnableBitmask; 2832 uint32_t UserClipDistanceClipTestEnableBitmask; 2833 uint32_t VertexURBEntryOutputLength; 2834 uint32_t VertexURBEntryOutputReadOffset; 2835}; 2836 2837static inline void 2838GEN8_3DSTATE_DS_pack(__attribute__((unused)) __gen_user_data *data, 2839 __attribute__((unused)) void * restrict dst, 2840 __attribute__((unused)) const struct GEN8_3DSTATE_DS * restrict values) 2841{ 2842 uint32_t * restrict dw = (uint32_t * restrict) dst; 2843 2844 dw[0] = 2845 __gen_uint(values->DWordLength, 0, 7) | 2846 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 2847 __gen_uint(values->_3DCommandOpcode, 24, 26) | 2848 __gen_uint(values->CommandSubType, 27, 28) | 2849 __gen_uint(values->CommandType, 29, 31); 2850 2851 const uint64_t v1 = 2852 __gen_offset(values->KernelStartPointer, 6, 63); 2853 dw[1] = v1; 2854 dw[2] = v1 >> 32; 2855 2856 dw[3] = 2857 __gen_uint(values->SoftwareExceptionEnable, 7, 7) | 2858 __gen_uint(values->IllegalOpcodeExceptionEnable, 13, 13) | 2859 __gen_uint(values->AccessesUAV, 14, 14) | 2860 __gen_uint(values->FloatingPointMode, 16, 16) | 2861 __gen_uint(values->ThreadDispatchPriority, 17, 17) | 2862 __gen_uint(values->BindingTableEntryCount, 18, 25) | 2863 __gen_uint(values->SamplerCount, 27, 29) | 2864 __gen_uint(values->VectorMaskEnable, 30, 30) | 2865 __gen_uint(values->SingleDomainPointDispatch, 31, 31); 2866 2867 const uint64_t v4 = 2868 __gen_uint(values->PerThreadScratchSpace, 0, 3); 2869 const uint64_t v4_address = 2870 __gen_combine_address(data, &dw[4], values->ScratchSpaceBasePointer, v4); 2871 dw[4] = v4_address; 2872 dw[5] = (v4_address >> 32) | (v4 >> 32); 2873 2874 dw[6] = 2875 __gen_uint(values->PatchURBEntryReadOffset, 4, 9) | 2876 __gen_uint(values->PatchURBEntryReadLength, 11, 17) | 2877 __gen_uint(values->DispatchGRFStartRegisterForURBData, 20, 24); 2878 2879 dw[7] = 2880 __gen_uint(values->Enable, 0, 0) | 2881 __gen_uint(values->CacheDisable, 1, 1) | 2882 __gen_uint(values->ComputeWCoordinateEnable, 2, 2) | 2883 __gen_uint(values->DispatchMode, 3, 3) | 2884 __gen_uint(values->StatisticsEnable, 10, 10) | 2885 __gen_uint(values->MaximumNumberofThreads, 21, 29); 2886 2887 dw[8] = 2888 __gen_uint(values->UserClipDistanceCullTestEnableBitmask, 0, 7) | 2889 __gen_uint(values->UserClipDistanceClipTestEnableBitmask, 8, 15) | 2890 __gen_uint(values->VertexURBEntryOutputLength, 16, 20) | 2891 __gen_uint(values->VertexURBEntryOutputReadOffset, 21, 26); 2892} 2893 2894#define GEN8_3DSTATE_GATHER_CONSTANT_DS_length_bias 2 2895#define GEN8_3DSTATE_GATHER_CONSTANT_DS_header \ 2896 .DWordLength = 1, \ 2897 ._3DCommandSubOpcode = 55, \ 2898 ._3DCommandOpcode = 0, \ 2899 .CommandSubType = 3, \ 2900 .CommandType = 3 2901 2902struct GEN8_3DSTATE_GATHER_CONSTANT_DS { 2903 uint32_t DWordLength; 2904 uint32_t _3DCommandSubOpcode; 2905 uint32_t _3DCommandOpcode; 2906 uint32_t CommandSubType; 2907 uint32_t CommandType; 2908 uint32_t ConstantBufferBindingTableBlock; 2909 uint32_t ConstantBufferValid; 2910 bool ConstantBufferDx9GenerateStall; 2911 uint64_t GatherBufferOffset; 2912 /* variable length fields follow */ 2913}; 2914 2915static inline void 2916GEN8_3DSTATE_GATHER_CONSTANT_DS_pack(__attribute__((unused)) __gen_user_data *data, 2917 __attribute__((unused)) void * restrict dst, 2918 __attribute__((unused)) const struct GEN8_3DSTATE_GATHER_CONSTANT_DS * restrict values) 2919{ 2920 uint32_t * restrict dw = (uint32_t * restrict) dst; 2921 2922 dw[0] = 2923 __gen_uint(values->DWordLength, 0, 7) | 2924 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 2925 __gen_uint(values->_3DCommandOpcode, 24, 26) | 2926 __gen_uint(values->CommandSubType, 27, 28) | 2927 __gen_uint(values->CommandType, 29, 31); 2928 2929 dw[1] = 2930 __gen_uint(values->ConstantBufferBindingTableBlock, 12, 15) | 2931 __gen_uint(values->ConstantBufferValid, 16, 31); 2932 2933 dw[2] = 2934 __gen_uint(values->ConstantBufferDx9GenerateStall, 5, 5) | 2935 __gen_offset(values->GatherBufferOffset, 6, 22); 2936} 2937 2938#define GEN8_3DSTATE_GATHER_CONSTANT_GS_length_bias 2 2939#define GEN8_3DSTATE_GATHER_CONSTANT_GS_header \ 2940 .DWordLength = 1, \ 2941 ._3DCommandSubOpcode = 53, \ 2942 ._3DCommandOpcode = 0, \ 2943 .CommandSubType = 3, \ 2944 .CommandType = 3 2945 2946struct GEN8_3DSTATE_GATHER_CONSTANT_GS { 2947 uint32_t DWordLength; 2948 uint32_t _3DCommandSubOpcode; 2949 uint32_t _3DCommandOpcode; 2950 uint32_t CommandSubType; 2951 uint32_t CommandType; 2952 uint32_t ConstantBufferBindingTableBlock; 2953 uint32_t ConstantBufferValid; 2954 bool ConstantBufferDx9GenerateStall; 2955 uint64_t GatherBufferOffset; 2956 /* variable length fields follow */ 2957}; 2958 2959static inline void 2960GEN8_3DSTATE_GATHER_CONSTANT_GS_pack(__attribute__((unused)) __gen_user_data *data, 2961 __attribute__((unused)) void * restrict dst, 2962 __attribute__((unused)) const struct GEN8_3DSTATE_GATHER_CONSTANT_GS * restrict values) 2963{ 2964 uint32_t * restrict dw = (uint32_t * restrict) dst; 2965 2966 dw[0] = 2967 __gen_uint(values->DWordLength, 0, 7) | 2968 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 2969 __gen_uint(values->_3DCommandOpcode, 24, 26) | 2970 __gen_uint(values->CommandSubType, 27, 28) | 2971 __gen_uint(values->CommandType, 29, 31); 2972 2973 dw[1] = 2974 __gen_uint(values->ConstantBufferBindingTableBlock, 12, 15) | 2975 __gen_uint(values->ConstantBufferValid, 16, 31); 2976 2977 dw[2] = 2978 __gen_uint(values->ConstantBufferDx9GenerateStall, 5, 5) | 2979 __gen_offset(values->GatherBufferOffset, 6, 22); 2980} 2981 2982#define GEN8_3DSTATE_GATHER_CONSTANT_HS_length_bias 2 2983#define GEN8_3DSTATE_GATHER_CONSTANT_HS_header \ 2984 .DWordLength = 1, \ 2985 ._3DCommandSubOpcode = 54, \ 2986 ._3DCommandOpcode = 0, \ 2987 .CommandSubType = 3, \ 2988 .CommandType = 3 2989 2990struct GEN8_3DSTATE_GATHER_CONSTANT_HS { 2991 uint32_t DWordLength; 2992 uint32_t _3DCommandSubOpcode; 2993 uint32_t _3DCommandOpcode; 2994 uint32_t CommandSubType; 2995 uint32_t CommandType; 2996 uint32_t ConstantBufferBindingTableBlock; 2997 uint32_t ConstantBufferValid; 2998 bool ConstantBufferDx9GenerateStall; 2999 uint64_t GatherBufferOffset; 3000 /* variable length fields follow */ 3001}; 3002 3003static inline void 3004GEN8_3DSTATE_GATHER_CONSTANT_HS_pack(__attribute__((unused)) __gen_user_data *data, 3005 __attribute__((unused)) void * restrict dst, 3006 __attribute__((unused)) const struct GEN8_3DSTATE_GATHER_CONSTANT_HS * restrict values) 3007{ 3008 uint32_t * restrict dw = (uint32_t * restrict) dst; 3009 3010 dw[0] = 3011 __gen_uint(values->DWordLength, 0, 7) | 3012 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 3013 __gen_uint(values->_3DCommandOpcode, 24, 26) | 3014 __gen_uint(values->CommandSubType, 27, 28) | 3015 __gen_uint(values->CommandType, 29, 31); 3016 3017 dw[1] = 3018 __gen_uint(values->ConstantBufferBindingTableBlock, 12, 15) | 3019 __gen_uint(values->ConstantBufferValid, 16, 31); 3020 3021 dw[2] = 3022 __gen_uint(values->ConstantBufferDx9GenerateStall, 5, 5) | 3023 __gen_offset(values->GatherBufferOffset, 6, 22); 3024} 3025 3026#define GEN8_3DSTATE_GATHER_CONSTANT_PS_length_bias 2 3027#define GEN8_3DSTATE_GATHER_CONSTANT_PS_header \ 3028 .DWordLength = 1, \ 3029 ._3DCommandSubOpcode = 56, \ 3030 ._3DCommandOpcode = 0, \ 3031 .CommandSubType = 3, \ 3032 .CommandType = 3 3033 3034struct GEN8_3DSTATE_GATHER_CONSTANT_PS { 3035 uint32_t DWordLength; 3036 uint32_t _3DCommandSubOpcode; 3037 uint32_t _3DCommandOpcode; 3038 uint32_t CommandSubType; 3039 uint32_t CommandType; 3040 uint32_t ConstantBufferBindingTableBlock; 3041 uint32_t ConstantBufferValid; 3042 bool ConstantBufferDx9Enable; 3043 bool ConstantBufferDx9GenerateStall; 3044 uint64_t GatherBufferOffset; 3045 /* variable length fields follow */ 3046}; 3047 3048static inline void 3049GEN8_3DSTATE_GATHER_CONSTANT_PS_pack(__attribute__((unused)) __gen_user_data *data, 3050 __attribute__((unused)) void * restrict dst, 3051 __attribute__((unused)) const struct GEN8_3DSTATE_GATHER_CONSTANT_PS * restrict values) 3052{ 3053 uint32_t * restrict dw = (uint32_t * restrict) dst; 3054 3055 dw[0] = 3056 __gen_uint(values->DWordLength, 0, 7) | 3057 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 3058 __gen_uint(values->_3DCommandOpcode, 24, 26) | 3059 __gen_uint(values->CommandSubType, 27, 28) | 3060 __gen_uint(values->CommandType, 29, 31); 3061 3062 dw[1] = 3063 __gen_uint(values->ConstantBufferBindingTableBlock, 12, 15) | 3064 __gen_uint(values->ConstantBufferValid, 16, 31); 3065 3066 dw[2] = 3067 __gen_uint(values->ConstantBufferDx9Enable, 4, 4) | 3068 __gen_uint(values->ConstantBufferDx9GenerateStall, 5, 5) | 3069 __gen_offset(values->GatherBufferOffset, 6, 22); 3070} 3071 3072#define GEN8_3DSTATE_GATHER_CONSTANT_VS_length_bias 2 3073#define GEN8_3DSTATE_GATHER_CONSTANT_VS_header \ 3074 .DWordLength = 0, \ 3075 ._3DCommandSubOpcode = 52, \ 3076 ._3DCommandOpcode = 0, \ 3077 .CommandSubType = 3, \ 3078 .CommandType = 3 3079 3080struct GEN8_3DSTATE_GATHER_CONSTANT_VS { 3081 uint32_t DWordLength; 3082 uint32_t _3DCommandSubOpcode; 3083 uint32_t _3DCommandOpcode; 3084 uint32_t CommandSubType; 3085 uint32_t CommandType; 3086 uint32_t ConstantBufferBindingTableBlock; 3087 uint32_t ConstantBufferValid; 3088 bool ConstantBufferDx9Enable; 3089 bool ConstantBufferDx9GenerateStall; 3090 uint64_t GatherBufferOffset; 3091 /* variable length fields follow */ 3092}; 3093 3094static inline void 3095GEN8_3DSTATE_GATHER_CONSTANT_VS_pack(__attribute__((unused)) __gen_user_data *data, 3096 __attribute__((unused)) void * restrict dst, 3097 __attribute__((unused)) const struct GEN8_3DSTATE_GATHER_CONSTANT_VS * restrict values) 3098{ 3099 uint32_t * restrict dw = (uint32_t * restrict) dst; 3100 3101 dw[0] = 3102 __gen_uint(values->DWordLength, 0, 7) | 3103 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 3104 __gen_uint(values->_3DCommandOpcode, 24, 26) | 3105 __gen_uint(values->CommandSubType, 27, 28) | 3106 __gen_uint(values->CommandType, 29, 31); 3107 3108 dw[1] = 3109 __gen_uint(values->ConstantBufferBindingTableBlock, 12, 15) | 3110 __gen_uint(values->ConstantBufferValid, 16, 31); 3111 3112 dw[2] = 3113 __gen_uint(values->ConstantBufferDx9Enable, 4, 4) | 3114 __gen_uint(values->ConstantBufferDx9GenerateStall, 5, 5) | 3115 __gen_offset(values->GatherBufferOffset, 6, 22); 3116} 3117 3118#define GEN8_3DSTATE_GATHER_POOL_ALLOC_length 4 3119#define GEN8_3DSTATE_GATHER_POOL_ALLOC_length_bias 2 3120#define GEN8_3DSTATE_GATHER_POOL_ALLOC_header \ 3121 .DWordLength = 2, \ 3122 ._3DCommandSubOpcode = 26, \ 3123 ._3DCommandOpcode = 1, \ 3124 .CommandSubType = 3, \ 3125 .CommandType = 3 3126 3127struct GEN8_3DSTATE_GATHER_POOL_ALLOC { 3128 uint32_t DWordLength; 3129 uint32_t _3DCommandSubOpcode; 3130 uint32_t _3DCommandOpcode; 3131 uint32_t CommandSubType; 3132 uint32_t CommandType; 3133 uint32_t MOCS; 3134 bool GatherPoolEnable; 3135 __gen_address_type GatherPoolBaseAddress; 3136 uint32_t GatherPoolBufferSize; 3137}; 3138 3139static inline void 3140GEN8_3DSTATE_GATHER_POOL_ALLOC_pack(__attribute__((unused)) __gen_user_data *data, 3141 __attribute__((unused)) void * restrict dst, 3142 __attribute__((unused)) const struct GEN8_3DSTATE_GATHER_POOL_ALLOC * restrict values) 3143{ 3144 uint32_t * restrict dw = (uint32_t * restrict) dst; 3145 3146 dw[0] = 3147 __gen_uint(values->DWordLength, 0, 7) | 3148 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 3149 __gen_uint(values->_3DCommandOpcode, 24, 26) | 3150 __gen_uint(values->CommandSubType, 27, 28) | 3151 __gen_uint(values->CommandType, 29, 31); 3152 3153 const uint64_t v1 = 3154 __gen_uint(values->MOCS, 0, 6) | 3155 __gen_uint(values->GatherPoolEnable, 11, 11); 3156 const uint64_t v1_address = 3157 __gen_combine_address(data, &dw[1], values->GatherPoolBaseAddress, v1); 3158 dw[1] = v1_address; 3159 dw[2] = (v1_address >> 32) | (v1 >> 32); 3160 3161 dw[3] = 3162 __gen_uint(values->GatherPoolBufferSize, 12, 31); 3163} 3164 3165#define GEN8_3DSTATE_GS_length 10 3166#define GEN8_3DSTATE_GS_length_bias 2 3167#define GEN8_3DSTATE_GS_header \ 3168 .DWordLength = 8, \ 3169 ._3DCommandSubOpcode = 17, \ 3170 ._3DCommandOpcode = 0, \ 3171 .CommandSubType = 3, \ 3172 .CommandType = 3 3173 3174struct GEN8_3DSTATE_GS { 3175 uint32_t DWordLength; 3176 uint32_t _3DCommandSubOpcode; 3177 uint32_t _3DCommandOpcode; 3178 uint32_t CommandSubType; 3179 uint32_t CommandType; 3180 uint64_t KernelStartPointer; 3181 uint32_t ExpectedVertexCount; 3182 bool SoftwareExceptionEnable; 3183 bool MaskStackExceptionEnable; 3184 bool AccessesUAV; 3185 bool IllegalOpcodeExceptionEnable; 3186 uint32_t FloatingPointMode; 3187#define IEEE754 0 3188#define Alternate 1 3189 uint32_t ThreadDispatchPriority; 3190#define High 1 3191 uint32_t BindingTableEntryCount; 3192 uint32_t SamplerCount; 3193#define NoSamplers 0 3194#define _14Samplers 1 3195#define _58Samplers 2 3196#define _912Samplers 3 3197#define _1316Samplers 4 3198 bool VectorMaskEnable; 3199 bool SingleProgramFlow; 3200 uint32_t PerThreadScratchSpace; 3201 __gen_address_type ScratchSpaceBasePointer; 3202 uint32_t DispatchGRFStartRegisterForURBData; 3203 uint32_t VertexURBEntryReadOffset; 3204 bool IncludeVertexHandles; 3205 uint32_t VertexURBEntryReadLength; 3206 enum GEN8_3D_Prim_Topo_Type OutputTopology; 3207 uint32_t OutputVertexSize; 3208 bool Enable; 3209 bool DiscardAdjacency; 3210 uint32_t ReorderMode; 3211#define LEADING 0 3212#define TRAILING 1 3213 uint32_t Hint; 3214 bool IncludePrimitiveID; 3215 uint32_t InvocationsIncrementValue; 3216 bool StatisticsEnable; 3217 uint32_t DispatchMode; 3218#define DISPATCH_MODE_DualInstance 1 3219#define DISPATCH_MODE_DualObject 2 3220#define DISPATCH_MODE_SIMD8 3 3221 uint32_t DefaultStreamId; 3222 uint32_t InstanceControl; 3223 uint32_t ControlDataHeaderSize; 3224 uint32_t MaximumNumberofThreads; 3225 uint32_t StaticOutputVertexCount; 3226 bool StaticOutput; 3227 uint32_t ControlDataFormat; 3228#define CUT 0 3229#define SID 1 3230 uint32_t UserClipDistanceCullTestEnableBitmask; 3231 uint32_t UserClipDistanceClipTestEnableBitmask; 3232 uint32_t VertexURBEntryOutputLength; 3233 uint32_t VertexURBEntryOutputReadOffset; 3234}; 3235 3236static inline void 3237GEN8_3DSTATE_GS_pack(__attribute__((unused)) __gen_user_data *data, 3238 __attribute__((unused)) void * restrict dst, 3239 __attribute__((unused)) const struct GEN8_3DSTATE_GS * restrict values) 3240{ 3241 uint32_t * restrict dw = (uint32_t * restrict) dst; 3242 3243 dw[0] = 3244 __gen_uint(values->DWordLength, 0, 7) | 3245 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 3246 __gen_uint(values->_3DCommandOpcode, 24, 26) | 3247 __gen_uint(values->CommandSubType, 27, 28) | 3248 __gen_uint(values->CommandType, 29, 31); 3249 3250 const uint64_t v1 = 3251 __gen_offset(values->KernelStartPointer, 6, 63); 3252 dw[1] = v1; 3253 dw[2] = v1 >> 32; 3254 3255 dw[3] = 3256 __gen_uint(values->ExpectedVertexCount, 0, 5) | 3257 __gen_uint(values->SoftwareExceptionEnable, 7, 7) | 3258 __gen_uint(values->MaskStackExceptionEnable, 11, 11) | 3259 __gen_uint(values->AccessesUAV, 12, 12) | 3260 __gen_uint(values->IllegalOpcodeExceptionEnable, 13, 13) | 3261 __gen_uint(values->FloatingPointMode, 16, 16) | 3262 __gen_uint(values->ThreadDispatchPriority, 17, 17) | 3263 __gen_uint(values->BindingTableEntryCount, 18, 25) | 3264 __gen_uint(values->SamplerCount, 27, 29) | 3265 __gen_uint(values->VectorMaskEnable, 30, 30) | 3266 __gen_uint(values->SingleProgramFlow, 31, 31); 3267 3268 const uint64_t v4 = 3269 __gen_uint(values->PerThreadScratchSpace, 0, 3); 3270 const uint64_t v4_address = 3271 __gen_combine_address(data, &dw[4], values->ScratchSpaceBasePointer, v4); 3272 dw[4] = v4_address; 3273 dw[5] = (v4_address >> 32) | (v4 >> 32); 3274 3275 dw[6] = 3276 __gen_uint(values->DispatchGRFStartRegisterForURBData, 0, 3) | 3277 __gen_uint(values->VertexURBEntryReadOffset, 4, 9) | 3278 __gen_uint(values->IncludeVertexHandles, 10, 10) | 3279 __gen_uint(values->VertexURBEntryReadLength, 11, 16) | 3280 __gen_uint(values->OutputTopology, 17, 22) | 3281 __gen_uint(values->OutputVertexSize, 23, 28); 3282 3283 dw[7] = 3284 __gen_uint(values->Enable, 0, 0) | 3285 __gen_uint(values->DiscardAdjacency, 1, 1) | 3286 __gen_uint(values->ReorderMode, 2, 2) | 3287 __gen_uint(values->Hint, 3, 3) | 3288 __gen_uint(values->IncludePrimitiveID, 4, 4) | 3289 __gen_uint(values->InvocationsIncrementValue, 5, 9) | 3290 __gen_uint(values->StatisticsEnable, 10, 10) | 3291 __gen_uint(values->DispatchMode, 11, 12) | 3292 __gen_uint(values->DefaultStreamId, 13, 14) | 3293 __gen_uint(values->InstanceControl, 15, 19) | 3294 __gen_uint(values->ControlDataHeaderSize, 20, 23) | 3295 __gen_uint(values->MaximumNumberofThreads, 24, 31); 3296 3297 dw[8] = 3298 __gen_uint(values->StaticOutputVertexCount, 16, 26) | 3299 __gen_uint(values->StaticOutput, 30, 30) | 3300 __gen_uint(values->ControlDataFormat, 31, 31); 3301 3302 dw[9] = 3303 __gen_uint(values->UserClipDistanceCullTestEnableBitmask, 0, 7) | 3304 __gen_uint(values->UserClipDistanceClipTestEnableBitmask, 8, 15) | 3305 __gen_uint(values->VertexURBEntryOutputLength, 16, 20) | 3306 __gen_uint(values->VertexURBEntryOutputReadOffset, 21, 26); 3307} 3308 3309#define GEN8_3DSTATE_HIER_DEPTH_BUFFER_length 5 3310#define GEN8_3DSTATE_HIER_DEPTH_BUFFER_length_bias 2 3311#define GEN8_3DSTATE_HIER_DEPTH_BUFFER_header \ 3312 .DWordLength = 3, \ 3313 ._3DCommandSubOpcode = 7, \ 3314 ._3DCommandOpcode = 0, \ 3315 .CommandSubType = 3, \ 3316 .CommandType = 3 3317 3318struct GEN8_3DSTATE_HIER_DEPTH_BUFFER { 3319 uint32_t DWordLength; 3320 uint32_t _3DCommandSubOpcode; 3321 uint32_t _3DCommandOpcode; 3322 uint32_t CommandSubType; 3323 uint32_t CommandType; 3324 uint32_t SurfacePitch; 3325 uint32_t MOCS; 3326 __gen_address_type SurfaceBaseAddress; 3327 uint32_t SurfaceQPitch; 3328}; 3329 3330static inline void 3331GEN8_3DSTATE_HIER_DEPTH_BUFFER_pack(__attribute__((unused)) __gen_user_data *data, 3332 __attribute__((unused)) void * restrict dst, 3333 __attribute__((unused)) const struct GEN8_3DSTATE_HIER_DEPTH_BUFFER * restrict values) 3334{ 3335 uint32_t * restrict dw = (uint32_t * restrict) dst; 3336 3337 dw[0] = 3338 __gen_uint(values->DWordLength, 0, 7) | 3339 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 3340 __gen_uint(values->_3DCommandOpcode, 24, 26) | 3341 __gen_uint(values->CommandSubType, 27, 28) | 3342 __gen_uint(values->CommandType, 29, 31); 3343 3344 dw[1] = 3345 __gen_uint(values->SurfacePitch, 0, 16) | 3346 __gen_uint(values->MOCS, 25, 31); 3347 3348 const uint64_t v2_address = 3349 __gen_combine_address(data, &dw[2], values->SurfaceBaseAddress, 0); 3350 dw[2] = v2_address; 3351 dw[3] = v2_address >> 32; 3352 3353 dw[4] = 3354 __gen_uint(values->SurfaceQPitch, 0, 14); 3355} 3356 3357#define GEN8_3DSTATE_HS_length 9 3358#define GEN8_3DSTATE_HS_length_bias 2 3359#define GEN8_3DSTATE_HS_header \ 3360 .DWordLength = 7, \ 3361 ._3DCommandSubOpcode = 27, \ 3362 ._3DCommandOpcode = 0, \ 3363 .CommandSubType = 3, \ 3364 .CommandType = 3 3365 3366struct GEN8_3DSTATE_HS { 3367 uint32_t DWordLength; 3368 uint32_t _3DCommandSubOpcode; 3369 uint32_t _3DCommandOpcode; 3370 uint32_t CommandSubType; 3371 uint32_t CommandType; 3372 bool SoftwareExceptionEnable; 3373 bool IllegalOpcodeExceptionEnable; 3374 uint32_t FloatingPointMode; 3375#define IEEE754 0 3376#define alternate 1 3377 uint32_t ThreadDispatchPriority; 3378#define High 1 3379 uint32_t BindingTableEntryCount; 3380 uint32_t SamplerCount; 3381#define NoSamplers 0 3382#define _14Samplers 1 3383#define _58Samplers 2 3384#define _912Samplers 3 3385#define _1316Samplers 4 3386 uint32_t InstanceCount; 3387 uint32_t MaximumNumberofThreads; 3388 bool StatisticsEnable; 3389 bool Enable; 3390 uint64_t KernelStartPointer; 3391 uint32_t PerThreadScratchSpace; 3392 __gen_address_type ScratchSpaceBasePointer; 3393 uint32_t VertexURBEntryReadOffset; 3394 uint32_t VertexURBEntryReadLength; 3395 uint32_t DispatchGRFStartRegisterForURBData; 3396 bool IncludeVertexHandles; 3397 bool AccessesUAV; 3398 bool VectorMaskEnable; 3399 bool SingleProgramFlow; 3400}; 3401 3402static inline void 3403GEN8_3DSTATE_HS_pack(__attribute__((unused)) __gen_user_data *data, 3404 __attribute__((unused)) void * restrict dst, 3405 __attribute__((unused)) const struct GEN8_3DSTATE_HS * restrict values) 3406{ 3407 uint32_t * restrict dw = (uint32_t * restrict) dst; 3408 3409 dw[0] = 3410 __gen_uint(values->DWordLength, 0, 7) | 3411 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 3412 __gen_uint(values->_3DCommandOpcode, 24, 26) | 3413 __gen_uint(values->CommandSubType, 27, 28) | 3414 __gen_uint(values->CommandType, 29, 31); 3415 3416 dw[1] = 3417 __gen_uint(values->SoftwareExceptionEnable, 12, 12) | 3418 __gen_uint(values->IllegalOpcodeExceptionEnable, 13, 13) | 3419 __gen_uint(values->FloatingPointMode, 16, 16) | 3420 __gen_uint(values->ThreadDispatchPriority, 17, 17) | 3421 __gen_uint(values->BindingTableEntryCount, 18, 25) | 3422 __gen_uint(values->SamplerCount, 27, 29); 3423 3424 dw[2] = 3425 __gen_uint(values->InstanceCount, 0, 3) | 3426 __gen_uint(values->MaximumNumberofThreads, 8, 16) | 3427 __gen_uint(values->StatisticsEnable, 29, 29) | 3428 __gen_uint(values->Enable, 31, 31); 3429 3430 const uint64_t v3 = 3431 __gen_offset(values->KernelStartPointer, 6, 63); 3432 dw[3] = v3; 3433 dw[4] = v3 >> 32; 3434 3435 const uint64_t v5 = 3436 __gen_uint(values->PerThreadScratchSpace, 0, 3); 3437 const uint64_t v5_address = 3438 __gen_combine_address(data, &dw[5], values->ScratchSpaceBasePointer, v5); 3439 dw[5] = v5_address; 3440 dw[6] = (v5_address >> 32) | (v5 >> 32); 3441 3442 dw[7] = 3443 __gen_uint(values->VertexURBEntryReadOffset, 4, 9) | 3444 __gen_uint(values->VertexURBEntryReadLength, 11, 16) | 3445 __gen_uint(values->DispatchGRFStartRegisterForURBData, 19, 23) | 3446 __gen_uint(values->IncludeVertexHandles, 24, 24) | 3447 __gen_uint(values->AccessesUAV, 25, 25) | 3448 __gen_uint(values->VectorMaskEnable, 26, 26) | 3449 __gen_uint(values->SingleProgramFlow, 27, 27); 3450 3451 dw[8] = 0; 3452} 3453 3454#define GEN8_3DSTATE_INDEX_BUFFER_length 5 3455#define GEN8_3DSTATE_INDEX_BUFFER_length_bias 2 3456#define GEN8_3DSTATE_INDEX_BUFFER_header \ 3457 .DWordLength = 3, \ 3458 ._3DCommandSubOpcode = 10, \ 3459 ._3DCommandOpcode = 0, \ 3460 .CommandSubType = 3, \ 3461 .CommandType = 3 3462 3463struct GEN8_3DSTATE_INDEX_BUFFER { 3464 uint32_t DWordLength; 3465 uint32_t _3DCommandSubOpcode; 3466 uint32_t _3DCommandOpcode; 3467 uint32_t CommandSubType; 3468 uint32_t CommandType; 3469 uint32_t MOCS; 3470 uint32_t IndexFormat; 3471#define INDEX_BYTE 0 3472#define INDEX_WORD 1 3473#define INDEX_DWORD 2 3474 __gen_address_type BufferStartingAddress; 3475 uint32_t BufferSize; 3476}; 3477 3478static inline void 3479GEN8_3DSTATE_INDEX_BUFFER_pack(__attribute__((unused)) __gen_user_data *data, 3480 __attribute__((unused)) void * restrict dst, 3481 __attribute__((unused)) const struct GEN8_3DSTATE_INDEX_BUFFER * restrict values) 3482{ 3483 uint32_t * restrict dw = (uint32_t * restrict) dst; 3484 3485 dw[0] = 3486 __gen_uint(values->DWordLength, 0, 7) | 3487 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 3488 __gen_uint(values->_3DCommandOpcode, 24, 26) | 3489 __gen_uint(values->CommandSubType, 27, 28) | 3490 __gen_uint(values->CommandType, 29, 31); 3491 3492 dw[1] = 3493 __gen_uint(values->MOCS, 0, 6) | 3494 __gen_uint(values->IndexFormat, 8, 9); 3495 3496 const uint64_t v2_address = 3497 __gen_combine_address(data, &dw[2], values->BufferStartingAddress, 0); 3498 dw[2] = v2_address; 3499 dw[3] = v2_address >> 32; 3500 3501 dw[4] = 3502 __gen_uint(values->BufferSize, 0, 31); 3503} 3504 3505#define GEN8_3DSTATE_LINE_STIPPLE_length 3 3506#define GEN8_3DSTATE_LINE_STIPPLE_length_bias 2 3507#define GEN8_3DSTATE_LINE_STIPPLE_header \ 3508 .DWordLength = 1, \ 3509 ._3DCommandSubOpcode = 8, \ 3510 ._3DCommandOpcode = 1, \ 3511 .CommandSubType = 3, \ 3512 .CommandType = 3 3513 3514struct GEN8_3DSTATE_LINE_STIPPLE { 3515 uint32_t DWordLength; 3516 uint32_t _3DCommandSubOpcode; 3517 uint32_t _3DCommandOpcode; 3518 uint32_t CommandSubType; 3519 uint32_t CommandType; 3520 uint32_t LineStipplePattern; 3521 uint32_t CurrentStippleIndex; 3522 uint32_t CurrentRepeatCounter; 3523 bool ModifyEnableCurrentRepeatCounterCurrentStippleIndex; 3524 uint32_t LineStippleRepeatCount; 3525 float LineStippleInverseRepeatCount; 3526}; 3527 3528static inline void 3529GEN8_3DSTATE_LINE_STIPPLE_pack(__attribute__((unused)) __gen_user_data *data, 3530 __attribute__((unused)) void * restrict dst, 3531 __attribute__((unused)) const struct GEN8_3DSTATE_LINE_STIPPLE * restrict values) 3532{ 3533 uint32_t * restrict dw = (uint32_t * restrict) dst; 3534 3535 dw[0] = 3536 __gen_uint(values->DWordLength, 0, 7) | 3537 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 3538 __gen_uint(values->_3DCommandOpcode, 24, 26) | 3539 __gen_uint(values->CommandSubType, 27, 28) | 3540 __gen_uint(values->CommandType, 29, 31); 3541 3542 dw[1] = 3543 __gen_uint(values->LineStipplePattern, 0, 15) | 3544 __gen_uint(values->CurrentStippleIndex, 16, 19) | 3545 __gen_uint(values->CurrentRepeatCounter, 21, 29) | 3546 __gen_uint(values->ModifyEnableCurrentRepeatCounterCurrentStippleIndex, 31, 31); 3547 3548 dw[2] = 3549 __gen_uint(values->LineStippleRepeatCount, 0, 8) | 3550 __gen_ufixed(values->LineStippleInverseRepeatCount, 15, 31, 16); 3551} 3552 3553#define GEN8_3DSTATE_MONOFILTER_SIZE_length 2 3554#define GEN8_3DSTATE_MONOFILTER_SIZE_length_bias 2 3555#define GEN8_3DSTATE_MONOFILTER_SIZE_header \ 3556 .DWordLength = 0, \ 3557 ._3DCommandSubOpcode = 17, \ 3558 ._3DCommandOpcode = 1, \ 3559 .CommandSubType = 3, \ 3560 .CommandType = 3 3561 3562struct GEN8_3DSTATE_MONOFILTER_SIZE { 3563 uint32_t DWordLength; 3564 uint32_t _3DCommandSubOpcode; 3565 uint32_t _3DCommandOpcode; 3566 uint32_t CommandSubType; 3567 uint32_t CommandType; 3568 uint32_t MonochromeFilterHeight; 3569 uint32_t MonochromeFilterWidth; 3570}; 3571 3572static inline void 3573GEN8_3DSTATE_MONOFILTER_SIZE_pack(__attribute__((unused)) __gen_user_data *data, 3574 __attribute__((unused)) void * restrict dst, 3575 __attribute__((unused)) const struct GEN8_3DSTATE_MONOFILTER_SIZE * restrict values) 3576{ 3577 uint32_t * restrict dw = (uint32_t * restrict) dst; 3578 3579 dw[0] = 3580 __gen_uint(values->DWordLength, 0, 7) | 3581 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 3582 __gen_uint(values->_3DCommandOpcode, 24, 26) | 3583 __gen_uint(values->CommandSubType, 27, 28) | 3584 __gen_uint(values->CommandType, 29, 31); 3585 3586 dw[1] = 3587 __gen_uint(values->MonochromeFilterHeight, 0, 2) | 3588 __gen_uint(values->MonochromeFilterWidth, 3, 5); 3589} 3590 3591#define GEN8_3DSTATE_MULTISAMPLE_length 2 3592#define GEN8_3DSTATE_MULTISAMPLE_length_bias 2 3593#define GEN8_3DSTATE_MULTISAMPLE_header \ 3594 .DWordLength = 0, \ 3595 ._3DCommandSubOpcode = 13, \ 3596 ._3DCommandOpcode = 0, \ 3597 .CommandSubType = 3, \ 3598 .CommandType = 3 3599 3600struct GEN8_3DSTATE_MULTISAMPLE { 3601 uint32_t DWordLength; 3602 uint32_t _3DCommandSubOpcode; 3603 uint32_t _3DCommandOpcode; 3604 uint32_t CommandSubType; 3605 uint32_t CommandType; 3606 uint32_t NumberofMultisamples; 3607 uint32_t PixelLocation; 3608#define CENTER 0 3609#define UL_CORNER 1 3610 bool PixelPositionOffsetEnable; 3611}; 3612 3613static inline void 3614GEN8_3DSTATE_MULTISAMPLE_pack(__attribute__((unused)) __gen_user_data *data, 3615 __attribute__((unused)) void * restrict dst, 3616 __attribute__((unused)) const struct GEN8_3DSTATE_MULTISAMPLE * restrict values) 3617{ 3618 uint32_t * restrict dw = (uint32_t * restrict) dst; 3619 3620 dw[0] = 3621 __gen_uint(values->DWordLength, 0, 7) | 3622 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 3623 __gen_uint(values->_3DCommandOpcode, 24, 26) | 3624 __gen_uint(values->CommandSubType, 27, 28) | 3625 __gen_uint(values->CommandType, 29, 31); 3626 3627 dw[1] = 3628 __gen_uint(values->NumberofMultisamples, 1, 3) | 3629 __gen_uint(values->PixelLocation, 4, 4) | 3630 __gen_uint(values->PixelPositionOffsetEnable, 5, 5); 3631} 3632 3633#define GEN8_3DSTATE_POLY_STIPPLE_OFFSET_length 2 3634#define GEN8_3DSTATE_POLY_STIPPLE_OFFSET_length_bias 2 3635#define GEN8_3DSTATE_POLY_STIPPLE_OFFSET_header \ 3636 .DWordLength = 0, \ 3637 ._3DCommandSubOpcode = 6, \ 3638 ._3DCommandOpcode = 1, \ 3639 .CommandSubType = 3, \ 3640 .CommandType = 3 3641 3642struct GEN8_3DSTATE_POLY_STIPPLE_OFFSET { 3643 uint32_t DWordLength; 3644 uint32_t _3DCommandSubOpcode; 3645 uint32_t _3DCommandOpcode; 3646 uint32_t CommandSubType; 3647 uint32_t CommandType; 3648 uint32_t PolygonStippleYOffset; 3649 uint32_t PolygonStippleXOffset; 3650}; 3651 3652static inline void 3653GEN8_3DSTATE_POLY_STIPPLE_OFFSET_pack(__attribute__((unused)) __gen_user_data *data, 3654 __attribute__((unused)) void * restrict dst, 3655 __attribute__((unused)) const struct GEN8_3DSTATE_POLY_STIPPLE_OFFSET * restrict values) 3656{ 3657 uint32_t * restrict dw = (uint32_t * restrict) dst; 3658 3659 dw[0] = 3660 __gen_uint(values->DWordLength, 0, 7) | 3661 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 3662 __gen_uint(values->_3DCommandOpcode, 24, 26) | 3663 __gen_uint(values->CommandSubType, 27, 28) | 3664 __gen_uint(values->CommandType, 29, 31); 3665 3666 dw[1] = 3667 __gen_uint(values->PolygonStippleYOffset, 0, 4) | 3668 __gen_uint(values->PolygonStippleXOffset, 8, 12); 3669} 3670 3671#define GEN8_3DSTATE_POLY_STIPPLE_PATTERN_length 33 3672#define GEN8_3DSTATE_POLY_STIPPLE_PATTERN_length_bias 2 3673#define GEN8_3DSTATE_POLY_STIPPLE_PATTERN_header\ 3674 .DWordLength = 31, \ 3675 ._3DCommandSubOpcode = 7, \ 3676 ._3DCommandOpcode = 1, \ 3677 .CommandSubType = 3, \ 3678 .CommandType = 3 3679 3680struct GEN8_3DSTATE_POLY_STIPPLE_PATTERN { 3681 uint32_t DWordLength; 3682 uint32_t _3DCommandSubOpcode; 3683 uint32_t _3DCommandOpcode; 3684 uint32_t CommandSubType; 3685 uint32_t CommandType; 3686 uint32_t PatternRow[32]; 3687}; 3688 3689static inline void 3690GEN8_3DSTATE_POLY_STIPPLE_PATTERN_pack(__attribute__((unused)) __gen_user_data *data, 3691 __attribute__((unused)) void * restrict dst, 3692 __attribute__((unused)) const struct GEN8_3DSTATE_POLY_STIPPLE_PATTERN * restrict values) 3693{ 3694 uint32_t * restrict dw = (uint32_t * restrict) dst; 3695 3696 dw[0] = 3697 __gen_uint(values->DWordLength, 0, 7) | 3698 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 3699 __gen_uint(values->_3DCommandOpcode, 24, 26) | 3700 __gen_uint(values->CommandSubType, 27, 28) | 3701 __gen_uint(values->CommandType, 29, 31); 3702 3703 dw[1] = 3704 __gen_uint(values->PatternRow[0], 0, 31); 3705 3706 dw[2] = 3707 __gen_uint(values->PatternRow[1], 0, 31); 3708 3709 dw[3] = 3710 __gen_uint(values->PatternRow[2], 0, 31); 3711 3712 dw[4] = 3713 __gen_uint(values->PatternRow[3], 0, 31); 3714 3715 dw[5] = 3716 __gen_uint(values->PatternRow[4], 0, 31); 3717 3718 dw[6] = 3719 __gen_uint(values->PatternRow[5], 0, 31); 3720 3721 dw[7] = 3722 __gen_uint(values->PatternRow[6], 0, 31); 3723 3724 dw[8] = 3725 __gen_uint(values->PatternRow[7], 0, 31); 3726 3727 dw[9] = 3728 __gen_uint(values->PatternRow[8], 0, 31); 3729 3730 dw[10] = 3731 __gen_uint(values->PatternRow[9], 0, 31); 3732 3733 dw[11] = 3734 __gen_uint(values->PatternRow[10], 0, 31); 3735 3736 dw[12] = 3737 __gen_uint(values->PatternRow[11], 0, 31); 3738 3739 dw[13] = 3740 __gen_uint(values->PatternRow[12], 0, 31); 3741 3742 dw[14] = 3743 __gen_uint(values->PatternRow[13], 0, 31); 3744 3745 dw[15] = 3746 __gen_uint(values->PatternRow[14], 0, 31); 3747 3748 dw[16] = 3749 __gen_uint(values->PatternRow[15], 0, 31); 3750 3751 dw[17] = 3752 __gen_uint(values->PatternRow[16], 0, 31); 3753 3754 dw[18] = 3755 __gen_uint(values->PatternRow[17], 0, 31); 3756 3757 dw[19] = 3758 __gen_uint(values->PatternRow[18], 0, 31); 3759 3760 dw[20] = 3761 __gen_uint(values->PatternRow[19], 0, 31); 3762 3763 dw[21] = 3764 __gen_uint(values->PatternRow[20], 0, 31); 3765 3766 dw[22] = 3767 __gen_uint(values->PatternRow[21], 0, 31); 3768 3769 dw[23] = 3770 __gen_uint(values->PatternRow[22], 0, 31); 3771 3772 dw[24] = 3773 __gen_uint(values->PatternRow[23], 0, 31); 3774 3775 dw[25] = 3776 __gen_uint(values->PatternRow[24], 0, 31); 3777 3778 dw[26] = 3779 __gen_uint(values->PatternRow[25], 0, 31); 3780 3781 dw[27] = 3782 __gen_uint(values->PatternRow[26], 0, 31); 3783 3784 dw[28] = 3785 __gen_uint(values->PatternRow[27], 0, 31); 3786 3787 dw[29] = 3788 __gen_uint(values->PatternRow[28], 0, 31); 3789 3790 dw[30] = 3791 __gen_uint(values->PatternRow[29], 0, 31); 3792 3793 dw[31] = 3794 __gen_uint(values->PatternRow[30], 0, 31); 3795 3796 dw[32] = 3797 __gen_uint(values->PatternRow[31], 0, 31); 3798} 3799 3800#define GEN8_3DSTATE_PS_length 12 3801#define GEN8_3DSTATE_PS_length_bias 2 3802#define GEN8_3DSTATE_PS_header \ 3803 .DWordLength = 10, \ 3804 ._3DCommandSubOpcode = 32, \ 3805 ._3DCommandOpcode = 0, \ 3806 .CommandSubType = 3, \ 3807 .CommandType = 3 3808 3809struct GEN8_3DSTATE_PS { 3810 uint32_t DWordLength; 3811 uint32_t _3DCommandSubOpcode; 3812 uint32_t _3DCommandOpcode; 3813 uint32_t CommandSubType; 3814 uint32_t CommandType; 3815 uint64_t KernelStartPointer0; 3816 bool SoftwareExceptionEnable; 3817 bool MaskStackExceptionEnable; 3818 bool IllegalOpcodeExceptionEnable; 3819 uint32_t RoundingMode; 3820#define RTNE 0 3821#define RU 1 3822#define RD 2 3823#define RTZ 3 3824 uint32_t FloatingPointMode; 3825#define IEEE754 0 3826#define Alternate 1 3827 uint32_t ThreadDispatchPriority; 3828#define High 1 3829 uint32_t BindingTableEntryCount; 3830 uint32_t SinglePrecisionDenormalMode; 3831#define FlushedtoZero 0 3832#define Retained 1 3833 uint32_t SamplerCount; 3834#define NoSamplers 0 3835#define _14Samplers 1 3836#define _58Samplers 2 3837#define _912Samplers 3 3838#define _1316Samplers 4 3839 bool VectorMaskEnable; 3840 bool SingleProgramFlow; 3841 uint32_t PerThreadScratchSpace; 3842 __gen_address_type ScratchSpaceBasePointer; 3843 bool _8PixelDispatchEnable; 3844 bool _16PixelDispatchEnable; 3845 bool _32PixelDispatchEnable; 3846 uint32_t PositionXYOffsetSelect; 3847#define POSOFFSET_NONE 0 3848#define POSOFFSET_CENTROID 2 3849#define POSOFFSET_SAMPLE 3 3850 bool RenderTargetResolveEnable; 3851 bool RenderTargetFastClearEnable; 3852 bool PushConstantEnable; 3853 uint32_t MaximumNumberofThreadsPerPSD; 3854 uint32_t DispatchGRFStartRegisterForConstantSetupData2; 3855 uint32_t DispatchGRFStartRegisterForConstantSetupData1; 3856 uint32_t DispatchGRFStartRegisterForConstantSetupData0; 3857 uint64_t KernelStartPointer1; 3858 uint64_t KernelStartPointer2; 3859}; 3860 3861static inline void 3862GEN8_3DSTATE_PS_pack(__attribute__((unused)) __gen_user_data *data, 3863 __attribute__((unused)) void * restrict dst, 3864 __attribute__((unused)) const struct GEN8_3DSTATE_PS * restrict values) 3865{ 3866 uint32_t * restrict dw = (uint32_t * restrict) dst; 3867 3868 dw[0] = 3869 __gen_uint(values->DWordLength, 0, 7) | 3870 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 3871 __gen_uint(values->_3DCommandOpcode, 24, 26) | 3872 __gen_uint(values->CommandSubType, 27, 28) | 3873 __gen_uint(values->CommandType, 29, 31); 3874 3875 const uint64_t v1 = 3876 __gen_offset(values->KernelStartPointer0, 6, 63); 3877 dw[1] = v1; 3878 dw[2] = v1 >> 32; 3879 3880 dw[3] = 3881 __gen_uint(values->SoftwareExceptionEnable, 7, 7) | 3882 __gen_uint(values->MaskStackExceptionEnable, 11, 11) | 3883 __gen_uint(values->IllegalOpcodeExceptionEnable, 13, 13) | 3884 __gen_uint(values->RoundingMode, 14, 15) | 3885 __gen_uint(values->FloatingPointMode, 16, 16) | 3886 __gen_uint(values->ThreadDispatchPriority, 17, 17) | 3887 __gen_uint(values->BindingTableEntryCount, 18, 25) | 3888 __gen_uint(values->SinglePrecisionDenormalMode, 26, 26) | 3889 __gen_uint(values->SamplerCount, 27, 29) | 3890 __gen_uint(values->VectorMaskEnable, 30, 30) | 3891 __gen_uint(values->SingleProgramFlow, 31, 31); 3892 3893 const uint64_t v4 = 3894 __gen_uint(values->PerThreadScratchSpace, 0, 3); 3895 const uint64_t v4_address = 3896 __gen_combine_address(data, &dw[4], values->ScratchSpaceBasePointer, v4); 3897 dw[4] = v4_address; 3898 dw[5] = (v4_address >> 32) | (v4 >> 32); 3899 3900 dw[6] = 3901 __gen_uint(values->_8PixelDispatchEnable, 0, 0) | 3902 __gen_uint(values->_16PixelDispatchEnable, 1, 1) | 3903 __gen_uint(values->_32PixelDispatchEnable, 2, 2) | 3904 __gen_uint(values->PositionXYOffsetSelect, 3, 4) | 3905 __gen_uint(values->RenderTargetResolveEnable, 6, 6) | 3906 __gen_uint(values->RenderTargetFastClearEnable, 8, 8) | 3907 __gen_uint(values->PushConstantEnable, 11, 11) | 3908 __gen_uint(values->MaximumNumberofThreadsPerPSD, 23, 31); 3909 3910 dw[7] = 3911 __gen_uint(values->DispatchGRFStartRegisterForConstantSetupData2, 0, 6) | 3912 __gen_uint(values->DispatchGRFStartRegisterForConstantSetupData1, 8, 14) | 3913 __gen_uint(values->DispatchGRFStartRegisterForConstantSetupData0, 16, 22); 3914 3915 const uint64_t v8 = 3916 __gen_offset(values->KernelStartPointer1, 6, 63); 3917 dw[8] = v8; 3918 dw[9] = v8 >> 32; 3919 3920 const uint64_t v10 = 3921 __gen_offset(values->KernelStartPointer2, 6, 63); 3922 dw[10] = v10; 3923 dw[11] = v10 >> 32; 3924} 3925 3926#define GEN8_3DSTATE_PS_BLEND_length 2 3927#define GEN8_3DSTATE_PS_BLEND_length_bias 2 3928#define GEN8_3DSTATE_PS_BLEND_header \ 3929 .DWordLength = 0, \ 3930 ._3DCommandSubOpcode = 77, \ 3931 ._3DCommandOpcode = 0, \ 3932 .CommandSubType = 3, \ 3933 .CommandType = 3 3934 3935struct GEN8_3DSTATE_PS_BLEND { 3936 uint32_t DWordLength; 3937 uint32_t _3DCommandSubOpcode; 3938 uint32_t _3DCommandOpcode; 3939 uint32_t CommandSubType; 3940 uint32_t CommandType; 3941 bool IndependentAlphaBlendEnable; 3942 bool AlphaTestEnable; 3943 uint32_t DestinationBlendFactor; 3944 uint32_t SourceBlendFactor; 3945 uint32_t DestinationAlphaBlendFactor; 3946 uint32_t SourceAlphaBlendFactor; 3947 bool ColorBufferBlendEnable; 3948 bool HasWriteableRT; 3949 bool AlphaToCoverageEnable; 3950}; 3951 3952static inline void 3953GEN8_3DSTATE_PS_BLEND_pack(__attribute__((unused)) __gen_user_data *data, 3954 __attribute__((unused)) void * restrict dst, 3955 __attribute__((unused)) const struct GEN8_3DSTATE_PS_BLEND * restrict values) 3956{ 3957 uint32_t * restrict dw = (uint32_t * restrict) dst; 3958 3959 dw[0] = 3960 __gen_uint(values->DWordLength, 0, 7) | 3961 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 3962 __gen_uint(values->_3DCommandOpcode, 24, 26) | 3963 __gen_uint(values->CommandSubType, 27, 28) | 3964 __gen_uint(values->CommandType, 29, 31); 3965 3966 dw[1] = 3967 __gen_uint(values->IndependentAlphaBlendEnable, 7, 7) | 3968 __gen_uint(values->AlphaTestEnable, 8, 8) | 3969 __gen_uint(values->DestinationBlendFactor, 9, 13) | 3970 __gen_uint(values->SourceBlendFactor, 14, 18) | 3971 __gen_uint(values->DestinationAlphaBlendFactor, 19, 23) | 3972 __gen_uint(values->SourceAlphaBlendFactor, 24, 28) | 3973 __gen_uint(values->ColorBufferBlendEnable, 29, 29) | 3974 __gen_uint(values->HasWriteableRT, 30, 30) | 3975 __gen_uint(values->AlphaToCoverageEnable, 31, 31); 3976} 3977 3978#define GEN8_3DSTATE_PS_EXTRA_length 2 3979#define GEN8_3DSTATE_PS_EXTRA_length_bias 2 3980#define GEN8_3DSTATE_PS_EXTRA_header \ 3981 .DWordLength = 0, \ 3982 ._3DCommandSubOpcode = 79, \ 3983 ._3DCommandOpcode = 0, \ 3984 .CommandSubType = 3, \ 3985 .CommandType = 3 3986 3987struct GEN8_3DSTATE_PS_EXTRA { 3988 uint32_t DWordLength; 3989 uint32_t _3DCommandSubOpcode; 3990 uint32_t _3DCommandOpcode; 3991 uint32_t CommandSubType; 3992 uint32_t CommandType; 3993 bool PixelShaderUsesInputCoverageMask; 3994 bool PixelShaderHasUAV; 3995 bool PixelShaderIsPerSample; 3996 bool PixelShaderDisablesAlphaToCoverage; 3997 bool AttributeEnable; 3998 bool PixelShaderUsesSourceW; 3999 bool PixelShaderUsesSourceDepth; 4000 bool ForceComputedDepth; 4001 uint32_t PixelShaderComputedDepthMode; 4002#define PSCDEPTH_OFF 0 4003#define PSCDEPTH_ON 1 4004#define PSCDEPTH_ON_GE 2 4005#define PSCDEPTH_ON_LE 3 4006 bool PixelShaderKillsPixel; 4007 bool oMaskPresenttoRenderTarget; 4008 bool PixelShaderDoesnotwritetoRT; 4009 bool PixelShaderValid; 4010}; 4011 4012static inline void 4013GEN8_3DSTATE_PS_EXTRA_pack(__attribute__((unused)) __gen_user_data *data, 4014 __attribute__((unused)) void * restrict dst, 4015 __attribute__((unused)) const struct GEN8_3DSTATE_PS_EXTRA * restrict values) 4016{ 4017 uint32_t * restrict dw = (uint32_t * restrict) dst; 4018 4019 dw[0] = 4020 __gen_uint(values->DWordLength, 0, 7) | 4021 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 4022 __gen_uint(values->_3DCommandOpcode, 24, 26) | 4023 __gen_uint(values->CommandSubType, 27, 28) | 4024 __gen_uint(values->CommandType, 29, 31); 4025 4026 dw[1] = 4027 __gen_uint(values->PixelShaderUsesInputCoverageMask, 1, 1) | 4028 __gen_uint(values->PixelShaderHasUAV, 2, 2) | 4029 __gen_uint(values->PixelShaderIsPerSample, 6, 6) | 4030 __gen_uint(values->PixelShaderDisablesAlphaToCoverage, 7, 7) | 4031 __gen_uint(values->AttributeEnable, 8, 8) | 4032 __gen_uint(values->PixelShaderUsesSourceW, 23, 23) | 4033 __gen_uint(values->PixelShaderUsesSourceDepth, 24, 24) | 4034 __gen_uint(values->ForceComputedDepth, 25, 25) | 4035 __gen_uint(values->PixelShaderComputedDepthMode, 26, 27) | 4036 __gen_uint(values->PixelShaderKillsPixel, 28, 28) | 4037 __gen_uint(values->oMaskPresenttoRenderTarget, 29, 29) | 4038 __gen_uint(values->PixelShaderDoesnotwritetoRT, 30, 30) | 4039 __gen_uint(values->PixelShaderValid, 31, 31); 4040} 4041 4042#define GEN8_3DSTATE_PUSH_CONSTANT_ALLOC_DS_length 2 4043#define GEN8_3DSTATE_PUSH_CONSTANT_ALLOC_DS_length_bias 2 4044#define GEN8_3DSTATE_PUSH_CONSTANT_ALLOC_DS_header\ 4045 .DWordLength = 0, \ 4046 ._3DCommandSubOpcode = 20, \ 4047 ._3DCommandOpcode = 1, \ 4048 .CommandSubType = 3, \ 4049 .CommandType = 3 4050 4051struct GEN8_3DSTATE_PUSH_CONSTANT_ALLOC_DS { 4052 uint32_t DWordLength; 4053 uint32_t _3DCommandSubOpcode; 4054 uint32_t _3DCommandOpcode; 4055 uint32_t CommandSubType; 4056 uint32_t CommandType; 4057 uint32_t ConstantBufferSize; 4058 uint32_t ConstantBufferOffset; 4059}; 4060 4061static inline void 4062GEN8_3DSTATE_PUSH_CONSTANT_ALLOC_DS_pack(__attribute__((unused)) __gen_user_data *data, 4063 __attribute__((unused)) void * restrict dst, 4064 __attribute__((unused)) const struct GEN8_3DSTATE_PUSH_CONSTANT_ALLOC_DS * restrict values) 4065{ 4066 uint32_t * restrict dw = (uint32_t * restrict) dst; 4067 4068 dw[0] = 4069 __gen_uint(values->DWordLength, 0, 7) | 4070 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 4071 __gen_uint(values->_3DCommandOpcode, 24, 26) | 4072 __gen_uint(values->CommandSubType, 27, 28) | 4073 __gen_uint(values->CommandType, 29, 31); 4074 4075 dw[1] = 4076 __gen_uint(values->ConstantBufferSize, 0, 5) | 4077 __gen_uint(values->ConstantBufferOffset, 16, 20); 4078} 4079 4080#define GEN8_3DSTATE_PUSH_CONSTANT_ALLOC_GS_length 2 4081#define GEN8_3DSTATE_PUSH_CONSTANT_ALLOC_GS_length_bias 2 4082#define GEN8_3DSTATE_PUSH_CONSTANT_ALLOC_GS_header\ 4083 .DWordLength = 0, \ 4084 ._3DCommandSubOpcode = 21, \ 4085 ._3DCommandOpcode = 1, \ 4086 .CommandSubType = 3, \ 4087 .CommandType = 3 4088 4089struct GEN8_3DSTATE_PUSH_CONSTANT_ALLOC_GS { 4090 uint32_t DWordLength; 4091 uint32_t _3DCommandSubOpcode; 4092 uint32_t _3DCommandOpcode; 4093 uint32_t CommandSubType; 4094 uint32_t CommandType; 4095 uint32_t ConstantBufferSize; 4096 uint32_t ConstantBufferOffset; 4097}; 4098 4099static inline void 4100GEN8_3DSTATE_PUSH_CONSTANT_ALLOC_GS_pack(__attribute__((unused)) __gen_user_data *data, 4101 __attribute__((unused)) void * restrict dst, 4102 __attribute__((unused)) const struct GEN8_3DSTATE_PUSH_CONSTANT_ALLOC_GS * restrict values) 4103{ 4104 uint32_t * restrict dw = (uint32_t * restrict) dst; 4105 4106 dw[0] = 4107 __gen_uint(values->DWordLength, 0, 7) | 4108 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 4109 __gen_uint(values->_3DCommandOpcode, 24, 26) | 4110 __gen_uint(values->CommandSubType, 27, 28) | 4111 __gen_uint(values->CommandType, 29, 31); 4112 4113 dw[1] = 4114 __gen_uint(values->ConstantBufferSize, 0, 5) | 4115 __gen_uint(values->ConstantBufferOffset, 16, 20); 4116} 4117 4118#define GEN8_3DSTATE_PUSH_CONSTANT_ALLOC_HS_length 2 4119#define GEN8_3DSTATE_PUSH_CONSTANT_ALLOC_HS_length_bias 2 4120#define GEN8_3DSTATE_PUSH_CONSTANT_ALLOC_HS_header\ 4121 .DWordLength = 0, \ 4122 ._3DCommandSubOpcode = 19, \ 4123 ._3DCommandOpcode = 1, \ 4124 .CommandSubType = 3, \ 4125 .CommandType = 3 4126 4127struct GEN8_3DSTATE_PUSH_CONSTANT_ALLOC_HS { 4128 uint32_t DWordLength; 4129 uint32_t _3DCommandSubOpcode; 4130 uint32_t _3DCommandOpcode; 4131 uint32_t CommandSubType; 4132 uint32_t CommandType; 4133 uint32_t ConstantBufferSize; 4134 uint32_t ConstantBufferOffset; 4135}; 4136 4137static inline void 4138GEN8_3DSTATE_PUSH_CONSTANT_ALLOC_HS_pack(__attribute__((unused)) __gen_user_data *data, 4139 __attribute__((unused)) void * restrict dst, 4140 __attribute__((unused)) const struct GEN8_3DSTATE_PUSH_CONSTANT_ALLOC_HS * restrict values) 4141{ 4142 uint32_t * restrict dw = (uint32_t * restrict) dst; 4143 4144 dw[0] = 4145 __gen_uint(values->DWordLength, 0, 7) | 4146 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 4147 __gen_uint(values->_3DCommandOpcode, 24, 26) | 4148 __gen_uint(values->CommandSubType, 27, 28) | 4149 __gen_uint(values->CommandType, 29, 31); 4150 4151 dw[1] = 4152 __gen_uint(values->ConstantBufferSize, 0, 5) | 4153 __gen_uint(values->ConstantBufferOffset, 16, 20); 4154} 4155 4156#define GEN8_3DSTATE_PUSH_CONSTANT_ALLOC_PS_length 2 4157#define GEN8_3DSTATE_PUSH_CONSTANT_ALLOC_PS_length_bias 2 4158#define GEN8_3DSTATE_PUSH_CONSTANT_ALLOC_PS_header\ 4159 .DWordLength = 0, \ 4160 ._3DCommandSubOpcode = 22, \ 4161 ._3DCommandOpcode = 1, \ 4162 .CommandSubType = 3, \ 4163 .CommandType = 3 4164 4165struct GEN8_3DSTATE_PUSH_CONSTANT_ALLOC_PS { 4166 uint32_t DWordLength; 4167 uint32_t _3DCommandSubOpcode; 4168 uint32_t _3DCommandOpcode; 4169 uint32_t CommandSubType; 4170 uint32_t CommandType; 4171 uint32_t ConstantBufferSize; 4172 uint32_t ConstantBufferOffset; 4173}; 4174 4175static inline void 4176GEN8_3DSTATE_PUSH_CONSTANT_ALLOC_PS_pack(__attribute__((unused)) __gen_user_data *data, 4177 __attribute__((unused)) void * restrict dst, 4178 __attribute__((unused)) const struct GEN8_3DSTATE_PUSH_CONSTANT_ALLOC_PS * restrict values) 4179{ 4180 uint32_t * restrict dw = (uint32_t * restrict) dst; 4181 4182 dw[0] = 4183 __gen_uint(values->DWordLength, 0, 7) | 4184 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 4185 __gen_uint(values->_3DCommandOpcode, 24, 26) | 4186 __gen_uint(values->CommandSubType, 27, 28) | 4187 __gen_uint(values->CommandType, 29, 31); 4188 4189 dw[1] = 4190 __gen_uint(values->ConstantBufferSize, 0, 5) | 4191 __gen_uint(values->ConstantBufferOffset, 16, 20); 4192} 4193 4194#define GEN8_3DSTATE_PUSH_CONSTANT_ALLOC_VS_length 2 4195#define GEN8_3DSTATE_PUSH_CONSTANT_ALLOC_VS_length_bias 2 4196#define GEN8_3DSTATE_PUSH_CONSTANT_ALLOC_VS_header\ 4197 .DWordLength = 0, \ 4198 ._3DCommandSubOpcode = 18, \ 4199 ._3DCommandOpcode = 1, \ 4200 .CommandSubType = 3, \ 4201 .CommandType = 3 4202 4203struct GEN8_3DSTATE_PUSH_CONSTANT_ALLOC_VS { 4204 uint32_t DWordLength; 4205 uint32_t _3DCommandSubOpcode; 4206 uint32_t _3DCommandOpcode; 4207 uint32_t CommandSubType; 4208 uint32_t CommandType; 4209 uint32_t ConstantBufferSize; 4210 uint32_t ConstantBufferOffset; 4211}; 4212 4213static inline void 4214GEN8_3DSTATE_PUSH_CONSTANT_ALLOC_VS_pack(__attribute__((unused)) __gen_user_data *data, 4215 __attribute__((unused)) void * restrict dst, 4216 __attribute__((unused)) const struct GEN8_3DSTATE_PUSH_CONSTANT_ALLOC_VS * restrict values) 4217{ 4218 uint32_t * restrict dw = (uint32_t * restrict) dst; 4219 4220 dw[0] = 4221 __gen_uint(values->DWordLength, 0, 7) | 4222 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 4223 __gen_uint(values->_3DCommandOpcode, 24, 26) | 4224 __gen_uint(values->CommandSubType, 27, 28) | 4225 __gen_uint(values->CommandType, 29, 31); 4226 4227 dw[1] = 4228 __gen_uint(values->ConstantBufferSize, 0, 5) | 4229 __gen_uint(values->ConstantBufferOffset, 16, 20); 4230} 4231 4232#define GEN8_3DSTATE_RASTER_length 5 4233#define GEN8_3DSTATE_RASTER_length_bias 2 4234#define GEN8_3DSTATE_RASTER_header \ 4235 .DWordLength = 3, \ 4236 ._3DCommandSubOpcode = 80, \ 4237 ._3DCommandOpcode = 0, \ 4238 .CommandSubType = 3, \ 4239 .CommandType = 3 4240 4241struct GEN8_3DSTATE_RASTER { 4242 uint32_t DWordLength; 4243 uint32_t _3DCommandSubOpcode; 4244 uint32_t _3DCommandOpcode; 4245 uint32_t CommandSubType; 4246 uint32_t CommandType; 4247 bool ViewportZClipTestEnable; 4248 bool ScissorRectangleEnable; 4249 bool AntialiasingEnable; 4250 uint32_t BackFaceFillMode; 4251#define FILL_MODE_SOLID 0 4252#define FILL_MODE_WIREFRAME 1 4253#define FILL_MODE_POINT 2 4254 uint32_t FrontFaceFillMode; 4255#define FILL_MODE_SOLID 0 4256#define FILL_MODE_WIREFRAME 1 4257#define FILL_MODE_POINT 2 4258 bool GlobalDepthOffsetEnablePoint; 4259 bool GlobalDepthOffsetEnableWireframe; 4260 bool GlobalDepthOffsetEnableSolid; 4261 uint32_t DXMultisampleRasterizationMode; 4262#define MSRASTMODE_OFF_PIXEL 0 4263#define MSRASTMODE_OFF_PATTERN 1 4264#define MSRASTMODE_ON_PIXEL 2 4265#define MSRASTMODE_ON_PATTERN 3 4266 bool DXMultisampleRasterizationEnable; 4267 bool SmoothPointEnable; 4268 uint32_t ForceMultisampling; 4269 uint32_t CullMode; 4270#define CULLMODE_BOTH 0 4271#define CULLMODE_NONE 1 4272#define CULLMODE_FRONT 2 4273#define CULLMODE_BACK 3 4274 uint32_t ForcedSampleCount; 4275#define FSC_NUMRASTSAMPLES_0 0 4276#define FSC_NUMRASTSAMPLES_1 1 4277#define FSC_NUMRASTSAMPLES_2 2 4278#define FSC_NUMRASTSAMPLES_4 3 4279#define FSC_NUMRASTSAMPLES_8 4 4280#define FSC_NUMRASTSAMPLES_16 5 4281 uint32_t FrontWinding; 4282#define Clockwise 0 4283#define CounterClockwise 1 4284 uint32_t APIMode; 4285#define DX9OGL 0 4286#define DX100 1 4287#define DX101 2 4288 float GlobalDepthOffsetConstant; 4289 float GlobalDepthOffsetScale; 4290 float GlobalDepthOffsetClamp; 4291}; 4292 4293static inline void 4294GEN8_3DSTATE_RASTER_pack(__attribute__((unused)) __gen_user_data *data, 4295 __attribute__((unused)) void * restrict dst, 4296 __attribute__((unused)) const struct GEN8_3DSTATE_RASTER * restrict values) 4297{ 4298 uint32_t * restrict dw = (uint32_t * restrict) dst; 4299 4300 dw[0] = 4301 __gen_uint(values->DWordLength, 0, 7) | 4302 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 4303 __gen_uint(values->_3DCommandOpcode, 24, 26) | 4304 __gen_uint(values->CommandSubType, 27, 28) | 4305 __gen_uint(values->CommandType, 29, 31); 4306 4307 dw[1] = 4308 __gen_uint(values->ViewportZClipTestEnable, 0, 0) | 4309 __gen_uint(values->ScissorRectangleEnable, 1, 1) | 4310 __gen_uint(values->AntialiasingEnable, 2, 2) | 4311 __gen_uint(values->BackFaceFillMode, 3, 4) | 4312 __gen_uint(values->FrontFaceFillMode, 5, 6) | 4313 __gen_uint(values->GlobalDepthOffsetEnablePoint, 7, 7) | 4314 __gen_uint(values->GlobalDepthOffsetEnableWireframe, 8, 8) | 4315 __gen_uint(values->GlobalDepthOffsetEnableSolid, 9, 9) | 4316 __gen_uint(values->DXMultisampleRasterizationMode, 10, 11) | 4317 __gen_uint(values->DXMultisampleRasterizationEnable, 12, 12) | 4318 __gen_uint(values->SmoothPointEnable, 13, 13) | 4319 __gen_uint(values->ForceMultisampling, 14, 14) | 4320 __gen_uint(values->CullMode, 16, 17) | 4321 __gen_uint(values->ForcedSampleCount, 18, 20) | 4322 __gen_uint(values->FrontWinding, 21, 21) | 4323 __gen_uint(values->APIMode, 22, 23); 4324 4325 dw[2] = 4326 __gen_float(values->GlobalDepthOffsetConstant); 4327 4328 dw[3] = 4329 __gen_float(values->GlobalDepthOffsetScale); 4330 4331 dw[4] = 4332 __gen_float(values->GlobalDepthOffsetClamp); 4333} 4334 4335#define GEN8_3DSTATE_SAMPLER_PALETTE_LOAD0_length_bias 2 4336#define GEN8_3DSTATE_SAMPLER_PALETTE_LOAD0_header\ 4337 ._3DCommandSubOpcode = 2, \ 4338 ._3DCommandOpcode = 1, \ 4339 .CommandSubType = 3, \ 4340 .CommandType = 3 4341 4342struct GEN8_3DSTATE_SAMPLER_PALETTE_LOAD0 { 4343 uint32_t DWordLength; 4344 uint32_t _3DCommandSubOpcode; 4345 uint32_t _3DCommandOpcode; 4346 uint32_t CommandSubType; 4347 uint32_t CommandType; 4348 /* variable length fields follow */ 4349}; 4350 4351static inline void 4352GEN8_3DSTATE_SAMPLER_PALETTE_LOAD0_pack(__attribute__((unused)) __gen_user_data *data, 4353 __attribute__((unused)) void * restrict dst, 4354 __attribute__((unused)) const struct GEN8_3DSTATE_SAMPLER_PALETTE_LOAD0 * restrict values) 4355{ 4356 uint32_t * restrict dw = (uint32_t * restrict) dst; 4357 4358 dw[0] = 4359 __gen_uint(values->DWordLength, 0, 7) | 4360 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 4361 __gen_uint(values->_3DCommandOpcode, 24, 26) | 4362 __gen_uint(values->CommandSubType, 27, 28) | 4363 __gen_uint(values->CommandType, 29, 31); 4364} 4365 4366#define GEN8_3DSTATE_SAMPLER_PALETTE_LOAD1_length_bias 2 4367#define GEN8_3DSTATE_SAMPLER_PALETTE_LOAD1_header\ 4368 .DWordLength = 0, \ 4369 ._3DCommandSubOpcode = 12, \ 4370 ._3DCommandOpcode = 1, \ 4371 .CommandSubType = 3, \ 4372 .CommandType = 3 4373 4374struct GEN8_3DSTATE_SAMPLER_PALETTE_LOAD1 { 4375 uint32_t DWordLength; 4376 uint32_t _3DCommandSubOpcode; 4377 uint32_t _3DCommandOpcode; 4378 uint32_t CommandSubType; 4379 uint32_t CommandType; 4380 /* variable length fields follow */ 4381}; 4382 4383static inline void 4384GEN8_3DSTATE_SAMPLER_PALETTE_LOAD1_pack(__attribute__((unused)) __gen_user_data *data, 4385 __attribute__((unused)) void * restrict dst, 4386 __attribute__((unused)) const struct GEN8_3DSTATE_SAMPLER_PALETTE_LOAD1 * restrict values) 4387{ 4388 uint32_t * restrict dw = (uint32_t * restrict) dst; 4389 4390 dw[0] = 4391 __gen_uint(values->DWordLength, 0, 7) | 4392 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 4393 __gen_uint(values->_3DCommandOpcode, 24, 26) | 4394 __gen_uint(values->CommandSubType, 27, 28) | 4395 __gen_uint(values->CommandType, 29, 31); 4396} 4397 4398#define GEN8_3DSTATE_SAMPLER_STATE_POINTERS_DS_length 2 4399#define GEN8_3DSTATE_SAMPLER_STATE_POINTERS_DS_length_bias 2 4400#define GEN8_3DSTATE_SAMPLER_STATE_POINTERS_DS_header\ 4401 .DWordLength = 0, \ 4402 ._3DCommandSubOpcode = 45, \ 4403 ._3DCommandOpcode = 0, \ 4404 .CommandSubType = 3, \ 4405 .CommandType = 3 4406 4407struct GEN8_3DSTATE_SAMPLER_STATE_POINTERS_DS { 4408 uint32_t DWordLength; 4409 uint32_t _3DCommandSubOpcode; 4410 uint32_t _3DCommandOpcode; 4411 uint32_t CommandSubType; 4412 uint32_t CommandType; 4413 uint64_t PointertoDSSamplerState; 4414}; 4415 4416static inline void 4417GEN8_3DSTATE_SAMPLER_STATE_POINTERS_DS_pack(__attribute__((unused)) __gen_user_data *data, 4418 __attribute__((unused)) void * restrict dst, 4419 __attribute__((unused)) const struct GEN8_3DSTATE_SAMPLER_STATE_POINTERS_DS * restrict values) 4420{ 4421 uint32_t * restrict dw = (uint32_t * restrict) dst; 4422 4423 dw[0] = 4424 __gen_uint(values->DWordLength, 0, 7) | 4425 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 4426 __gen_uint(values->_3DCommandOpcode, 24, 26) | 4427 __gen_uint(values->CommandSubType, 27, 28) | 4428 __gen_uint(values->CommandType, 29, 31); 4429 4430 dw[1] = 4431 __gen_offset(values->PointertoDSSamplerState, 5, 31); 4432} 4433 4434#define GEN8_3DSTATE_SAMPLER_STATE_POINTERS_GS_length 2 4435#define GEN8_3DSTATE_SAMPLER_STATE_POINTERS_GS_length_bias 2 4436#define GEN8_3DSTATE_SAMPLER_STATE_POINTERS_GS_header\ 4437 .DWordLength = 0, \ 4438 ._3DCommandSubOpcode = 46, \ 4439 ._3DCommandOpcode = 0, \ 4440 .CommandSubType = 3, \ 4441 .CommandType = 3 4442 4443struct GEN8_3DSTATE_SAMPLER_STATE_POINTERS_GS { 4444 uint32_t DWordLength; 4445 uint32_t _3DCommandSubOpcode; 4446 uint32_t _3DCommandOpcode; 4447 uint32_t CommandSubType; 4448 uint32_t CommandType; 4449 uint64_t PointertoGSSamplerState; 4450}; 4451 4452static inline void 4453GEN8_3DSTATE_SAMPLER_STATE_POINTERS_GS_pack(__attribute__((unused)) __gen_user_data *data, 4454 __attribute__((unused)) void * restrict dst, 4455 __attribute__((unused)) const struct GEN8_3DSTATE_SAMPLER_STATE_POINTERS_GS * restrict values) 4456{ 4457 uint32_t * restrict dw = (uint32_t * restrict) dst; 4458 4459 dw[0] = 4460 __gen_uint(values->DWordLength, 0, 7) | 4461 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 4462 __gen_uint(values->_3DCommandOpcode, 24, 26) | 4463 __gen_uint(values->CommandSubType, 27, 28) | 4464 __gen_uint(values->CommandType, 29, 31); 4465 4466 dw[1] = 4467 __gen_offset(values->PointertoGSSamplerState, 5, 31); 4468} 4469 4470#define GEN8_3DSTATE_SAMPLER_STATE_POINTERS_HS_length 2 4471#define GEN8_3DSTATE_SAMPLER_STATE_POINTERS_HS_length_bias 2 4472#define GEN8_3DSTATE_SAMPLER_STATE_POINTERS_HS_header\ 4473 .DWordLength = 0, \ 4474 ._3DCommandSubOpcode = 44, \ 4475 ._3DCommandOpcode = 0, \ 4476 .CommandSubType = 3, \ 4477 .CommandType = 3 4478 4479struct GEN8_3DSTATE_SAMPLER_STATE_POINTERS_HS { 4480 uint32_t DWordLength; 4481 uint32_t _3DCommandSubOpcode; 4482 uint32_t _3DCommandOpcode; 4483 uint32_t CommandSubType; 4484 uint32_t CommandType; 4485 uint64_t PointertoHSSamplerState; 4486}; 4487 4488static inline void 4489GEN8_3DSTATE_SAMPLER_STATE_POINTERS_HS_pack(__attribute__((unused)) __gen_user_data *data, 4490 __attribute__((unused)) void * restrict dst, 4491 __attribute__((unused)) const struct GEN8_3DSTATE_SAMPLER_STATE_POINTERS_HS * restrict values) 4492{ 4493 uint32_t * restrict dw = (uint32_t * restrict) dst; 4494 4495 dw[0] = 4496 __gen_uint(values->DWordLength, 0, 7) | 4497 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 4498 __gen_uint(values->_3DCommandOpcode, 24, 26) | 4499 __gen_uint(values->CommandSubType, 27, 28) | 4500 __gen_uint(values->CommandType, 29, 31); 4501 4502 dw[1] = 4503 __gen_offset(values->PointertoHSSamplerState, 5, 31); 4504} 4505 4506#define GEN8_3DSTATE_SAMPLER_STATE_POINTERS_PS_length 2 4507#define GEN8_3DSTATE_SAMPLER_STATE_POINTERS_PS_length_bias 2 4508#define GEN8_3DSTATE_SAMPLER_STATE_POINTERS_PS_header\ 4509 .DWordLength = 0, \ 4510 ._3DCommandSubOpcode = 47, \ 4511 ._3DCommandOpcode = 0, \ 4512 .CommandSubType = 3, \ 4513 .CommandType = 3 4514 4515struct GEN8_3DSTATE_SAMPLER_STATE_POINTERS_PS { 4516 uint32_t DWordLength; 4517 uint32_t _3DCommandSubOpcode; 4518 uint32_t _3DCommandOpcode; 4519 uint32_t CommandSubType; 4520 uint32_t CommandType; 4521 uint64_t PointertoPSSamplerState; 4522}; 4523 4524static inline void 4525GEN8_3DSTATE_SAMPLER_STATE_POINTERS_PS_pack(__attribute__((unused)) __gen_user_data *data, 4526 __attribute__((unused)) void * restrict dst, 4527 __attribute__((unused)) const struct GEN8_3DSTATE_SAMPLER_STATE_POINTERS_PS * restrict values) 4528{ 4529 uint32_t * restrict dw = (uint32_t * restrict) dst; 4530 4531 dw[0] = 4532 __gen_uint(values->DWordLength, 0, 7) | 4533 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 4534 __gen_uint(values->_3DCommandOpcode, 24, 26) | 4535 __gen_uint(values->CommandSubType, 27, 28) | 4536 __gen_uint(values->CommandType, 29, 31); 4537 4538 dw[1] = 4539 __gen_offset(values->PointertoPSSamplerState, 5, 31); 4540} 4541 4542#define GEN8_3DSTATE_SAMPLER_STATE_POINTERS_VS_length 2 4543#define GEN8_3DSTATE_SAMPLER_STATE_POINTERS_VS_length_bias 2 4544#define GEN8_3DSTATE_SAMPLER_STATE_POINTERS_VS_header\ 4545 .DWordLength = 0, \ 4546 ._3DCommandSubOpcode = 43, \ 4547 ._3DCommandOpcode = 0, \ 4548 .CommandSubType = 3, \ 4549 .CommandType = 3 4550 4551struct GEN8_3DSTATE_SAMPLER_STATE_POINTERS_VS { 4552 uint32_t DWordLength; 4553 uint32_t _3DCommandSubOpcode; 4554 uint32_t _3DCommandOpcode; 4555 uint32_t CommandSubType; 4556 uint32_t CommandType; 4557 uint64_t PointertoVSSamplerState; 4558}; 4559 4560static inline void 4561GEN8_3DSTATE_SAMPLER_STATE_POINTERS_VS_pack(__attribute__((unused)) __gen_user_data *data, 4562 __attribute__((unused)) void * restrict dst, 4563 __attribute__((unused)) const struct GEN8_3DSTATE_SAMPLER_STATE_POINTERS_VS * restrict values) 4564{ 4565 uint32_t * restrict dw = (uint32_t * restrict) dst; 4566 4567 dw[0] = 4568 __gen_uint(values->DWordLength, 0, 7) | 4569 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 4570 __gen_uint(values->_3DCommandOpcode, 24, 26) | 4571 __gen_uint(values->CommandSubType, 27, 28) | 4572 __gen_uint(values->CommandType, 29, 31); 4573 4574 dw[1] = 4575 __gen_offset(values->PointertoVSSamplerState, 5, 31); 4576} 4577 4578#define GEN8_3DSTATE_SAMPLE_MASK_length 2 4579#define GEN8_3DSTATE_SAMPLE_MASK_length_bias 2 4580#define GEN8_3DSTATE_SAMPLE_MASK_header \ 4581 .DWordLength = 0, \ 4582 ._3DCommandSubOpcode = 24, \ 4583 ._3DCommandOpcode = 0, \ 4584 .CommandSubType = 3, \ 4585 .CommandType = 3 4586 4587struct GEN8_3DSTATE_SAMPLE_MASK { 4588 uint32_t DWordLength; 4589 uint32_t _3DCommandSubOpcode; 4590 uint32_t _3DCommandOpcode; 4591 uint32_t CommandSubType; 4592 uint32_t CommandType; 4593 uint32_t SampleMask; 4594}; 4595 4596static inline void 4597GEN8_3DSTATE_SAMPLE_MASK_pack(__attribute__((unused)) __gen_user_data *data, 4598 __attribute__((unused)) void * restrict dst, 4599 __attribute__((unused)) const struct GEN8_3DSTATE_SAMPLE_MASK * restrict values) 4600{ 4601 uint32_t * restrict dw = (uint32_t * restrict) dst; 4602 4603 dw[0] = 4604 __gen_uint(values->DWordLength, 0, 7) | 4605 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 4606 __gen_uint(values->_3DCommandOpcode, 24, 26) | 4607 __gen_uint(values->CommandSubType, 27, 28) | 4608 __gen_uint(values->CommandType, 29, 31); 4609 4610 dw[1] = 4611 __gen_uint(values->SampleMask, 0, 15); 4612} 4613 4614#define GEN8_3DSTATE_SAMPLE_PATTERN_length 9 4615#define GEN8_3DSTATE_SAMPLE_PATTERN_length_bias 2 4616#define GEN8_3DSTATE_SAMPLE_PATTERN_header \ 4617 .DWordLength = 7, \ 4618 ._3DCommandSubOpcode = 28, \ 4619 ._3DCommandOpcode = 1, \ 4620 .CommandSubType = 3, \ 4621 .CommandType = 3 4622 4623struct GEN8_3DSTATE_SAMPLE_PATTERN { 4624 uint32_t DWordLength; 4625 uint32_t _3DCommandSubOpcode; 4626 uint32_t _3DCommandOpcode; 4627 uint32_t CommandSubType; 4628 uint32_t CommandType; 4629 float _8xSample4YOffset; 4630 float _8xSample4XOffset; 4631 float _8xSample5YOffset; 4632 float _8xSample5XOffset; 4633 float _8xSample6YOffset; 4634 float _8xSample6XOffset; 4635 float _8xSample7YOffset; 4636 float _8xSample7XOffset; 4637 float _8xSample0YOffset; 4638 float _8xSample0XOffset; 4639 float _8xSample1YOffset; 4640 float _8xSample1XOffset; 4641 float _8xSample2YOffset; 4642 float _8xSample2XOffset; 4643 float _8xSample3YOffset; 4644 float _8xSample3XOffset; 4645 float _4xSample0YOffset; 4646 float _4xSample0XOffset; 4647 float _4xSample1YOffset; 4648 float _4xSample1XOffset; 4649 float _4xSample2YOffset; 4650 float _4xSample2XOffset; 4651 float _4xSample3YOffset; 4652 float _4xSample3XOffset; 4653 float _2xSample0YOffset; 4654 float _2xSample0XOffset; 4655 float _2xSample1YOffset; 4656 float _2xSample1XOffset; 4657 float _1xSample0YOffset; 4658 float _1xSample0XOffset; 4659}; 4660 4661static inline void 4662GEN8_3DSTATE_SAMPLE_PATTERN_pack(__attribute__((unused)) __gen_user_data *data, 4663 __attribute__((unused)) void * restrict dst, 4664 __attribute__((unused)) const struct GEN8_3DSTATE_SAMPLE_PATTERN * restrict values) 4665{ 4666 uint32_t * restrict dw = (uint32_t * restrict) dst; 4667 4668 dw[0] = 4669 __gen_uint(values->DWordLength, 0, 7) | 4670 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 4671 __gen_uint(values->_3DCommandOpcode, 24, 26) | 4672 __gen_uint(values->CommandSubType, 27, 28) | 4673 __gen_uint(values->CommandType, 29, 31); 4674 4675 dw[1] = 0; 4676 4677 dw[2] = 0; 4678 4679 dw[3] = 0; 4680 4681 dw[4] = 0; 4682 4683 dw[5] = 4684 __gen_ufixed(values->_8xSample4YOffset, 0, 3, 4) | 4685 __gen_ufixed(values->_8xSample4XOffset, 4, 7, 4) | 4686 __gen_ufixed(values->_8xSample5YOffset, 8, 11, 4) | 4687 __gen_ufixed(values->_8xSample5XOffset, 12, 15, 4) | 4688 __gen_ufixed(values->_8xSample6YOffset, 16, 19, 4) | 4689 __gen_ufixed(values->_8xSample6XOffset, 20, 23, 4) | 4690 __gen_ufixed(values->_8xSample7YOffset, 24, 27, 4) | 4691 __gen_ufixed(values->_8xSample7XOffset, 28, 31, 4); 4692 4693 dw[6] = 4694 __gen_ufixed(values->_8xSample0YOffset, 0, 3, 4) | 4695 __gen_ufixed(values->_8xSample0XOffset, 4, 7, 4) | 4696 __gen_ufixed(values->_8xSample1YOffset, 8, 11, 4) | 4697 __gen_ufixed(values->_8xSample1XOffset, 12, 15, 4) | 4698 __gen_ufixed(values->_8xSample2YOffset, 16, 19, 4) | 4699 __gen_ufixed(values->_8xSample2XOffset, 20, 23, 4) | 4700 __gen_ufixed(values->_8xSample3YOffset, 24, 27, 4) | 4701 __gen_ufixed(values->_8xSample3XOffset, 28, 31, 4); 4702 4703 dw[7] = 4704 __gen_ufixed(values->_4xSample0YOffset, 0, 3, 4) | 4705 __gen_ufixed(values->_4xSample0XOffset, 4, 7, 4) | 4706 __gen_ufixed(values->_4xSample1YOffset, 8, 11, 4) | 4707 __gen_ufixed(values->_4xSample1XOffset, 12, 15, 4) | 4708 __gen_ufixed(values->_4xSample2YOffset, 16, 19, 4) | 4709 __gen_ufixed(values->_4xSample2XOffset, 20, 23, 4) | 4710 __gen_ufixed(values->_4xSample3YOffset, 24, 27, 4) | 4711 __gen_ufixed(values->_4xSample3XOffset, 28, 31, 4); 4712 4713 dw[8] = 4714 __gen_ufixed(values->_2xSample0YOffset, 0, 3, 4) | 4715 __gen_ufixed(values->_2xSample0XOffset, 4, 7, 4) | 4716 __gen_ufixed(values->_2xSample1YOffset, 8, 11, 4) | 4717 __gen_ufixed(values->_2xSample1XOffset, 12, 15, 4) | 4718 __gen_ufixed(values->_1xSample0YOffset, 16, 19, 4) | 4719 __gen_ufixed(values->_1xSample0XOffset, 20, 23, 4); 4720} 4721 4722#define GEN8_3DSTATE_SBE_length 4 4723#define GEN8_3DSTATE_SBE_length_bias 2 4724#define GEN8_3DSTATE_SBE_header \ 4725 .DWordLength = 2, \ 4726 ._3DCommandSubOpcode = 31, \ 4727 ._3DCommandOpcode = 0, \ 4728 .CommandSubType = 3, \ 4729 .CommandType = 3 4730 4731struct GEN8_3DSTATE_SBE { 4732 uint32_t DWordLength; 4733 uint32_t _3DCommandSubOpcode; 4734 uint32_t _3DCommandOpcode; 4735 uint32_t CommandSubType; 4736 uint32_t CommandType; 4737 uint32_t PrimitiveIDOverrideAttributeSelect; 4738 uint32_t VertexURBEntryReadOffset; 4739 uint32_t VertexURBEntryReadLength; 4740 bool PrimitiveIDOverrideComponentX; 4741 bool PrimitiveIDOverrideComponentY; 4742 bool PrimitiveIDOverrideComponentZ; 4743 bool PrimitiveIDOverrideComponentW; 4744 uint32_t PointSpriteTextureCoordinateOrigin; 4745#define UPPERLEFT 0 4746#define LOWERLEFT 1 4747 bool AttributeSwizzleEnable; 4748 uint32_t NumberofSFOutputAttributes; 4749 bool ForceVertexURBEntryReadOffset; 4750 bool ForceVertexURBEntryReadLength; 4751 uint32_t PointSpriteTextureCoordinateEnable; 4752 uint32_t ConstantInterpolationEnable; 4753}; 4754 4755static inline void 4756GEN8_3DSTATE_SBE_pack(__attribute__((unused)) __gen_user_data *data, 4757 __attribute__((unused)) void * restrict dst, 4758 __attribute__((unused)) const struct GEN8_3DSTATE_SBE * restrict values) 4759{ 4760 uint32_t * restrict dw = (uint32_t * restrict) dst; 4761 4762 dw[0] = 4763 __gen_uint(values->DWordLength, 0, 7) | 4764 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 4765 __gen_uint(values->_3DCommandOpcode, 24, 26) | 4766 __gen_uint(values->CommandSubType, 27, 28) | 4767 __gen_uint(values->CommandType, 29, 31); 4768 4769 dw[1] = 4770 __gen_uint(values->PrimitiveIDOverrideAttributeSelect, 0, 4) | 4771 __gen_uint(values->VertexURBEntryReadOffset, 5, 10) | 4772 __gen_uint(values->VertexURBEntryReadLength, 11, 15) | 4773 __gen_uint(values->PrimitiveIDOverrideComponentX, 16, 16) | 4774 __gen_uint(values->PrimitiveIDOverrideComponentY, 17, 17) | 4775 __gen_uint(values->PrimitiveIDOverrideComponentZ, 18, 18) | 4776 __gen_uint(values->PrimitiveIDOverrideComponentW, 19, 19) | 4777 __gen_uint(values->PointSpriteTextureCoordinateOrigin, 20, 20) | 4778 __gen_uint(values->AttributeSwizzleEnable, 21, 21) | 4779 __gen_uint(values->NumberofSFOutputAttributes, 22, 27) | 4780 __gen_uint(values->ForceVertexURBEntryReadOffset, 28, 28) | 4781 __gen_uint(values->ForceVertexURBEntryReadLength, 29, 29); 4782 4783 dw[2] = 4784 __gen_uint(values->PointSpriteTextureCoordinateEnable, 0, 31); 4785 4786 dw[3] = 4787 __gen_uint(values->ConstantInterpolationEnable, 0, 31); 4788} 4789 4790#define GEN8_3DSTATE_SBE_SWIZ_length 11 4791#define GEN8_3DSTATE_SBE_SWIZ_length_bias 2 4792#define GEN8_3DSTATE_SBE_SWIZ_header \ 4793 .DWordLength = 9, \ 4794 ._3DCommandSubOpcode = 81, \ 4795 ._3DCommandOpcode = 0, \ 4796 .CommandSubType = 3, \ 4797 .CommandType = 3 4798 4799struct GEN8_3DSTATE_SBE_SWIZ { 4800 uint32_t DWordLength; 4801 uint32_t _3DCommandSubOpcode; 4802 uint32_t _3DCommandOpcode; 4803 uint32_t CommandSubType; 4804 uint32_t CommandType; 4805 struct GEN8_SF_OUTPUT_ATTRIBUTE_DETAIL Attribute[16]; 4806 uint32_t AttributeWrapShortestEnables[16]; 4807}; 4808 4809static inline void 4810GEN8_3DSTATE_SBE_SWIZ_pack(__attribute__((unused)) __gen_user_data *data, 4811 __attribute__((unused)) void * restrict dst, 4812 __attribute__((unused)) const struct GEN8_3DSTATE_SBE_SWIZ * restrict values) 4813{ 4814 uint32_t * restrict dw = (uint32_t * restrict) dst; 4815 4816 dw[0] = 4817 __gen_uint(values->DWordLength, 0, 7) | 4818 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 4819 __gen_uint(values->_3DCommandOpcode, 24, 26) | 4820 __gen_uint(values->CommandSubType, 27, 28) | 4821 __gen_uint(values->CommandType, 29, 31); 4822 4823 uint32_t v1_0; 4824 GEN8_SF_OUTPUT_ATTRIBUTE_DETAIL_pack(data, &v1_0, &values->Attribute[0]); 4825 4826 uint32_t v1_1; 4827 GEN8_SF_OUTPUT_ATTRIBUTE_DETAIL_pack(data, &v1_1, &values->Attribute[1]); 4828 4829 dw[1] = 4830 __gen_uint(v1_0, 0, 15) | 4831 __gen_uint(v1_1, 16, 31); 4832 4833 uint32_t v2_0; 4834 GEN8_SF_OUTPUT_ATTRIBUTE_DETAIL_pack(data, &v2_0, &values->Attribute[2]); 4835 4836 uint32_t v2_1; 4837 GEN8_SF_OUTPUT_ATTRIBUTE_DETAIL_pack(data, &v2_1, &values->Attribute[3]); 4838 4839 dw[2] = 4840 __gen_uint(v2_0, 0, 15) | 4841 __gen_uint(v2_1, 16, 31); 4842 4843 uint32_t v3_0; 4844 GEN8_SF_OUTPUT_ATTRIBUTE_DETAIL_pack(data, &v3_0, &values->Attribute[4]); 4845 4846 uint32_t v3_1; 4847 GEN8_SF_OUTPUT_ATTRIBUTE_DETAIL_pack(data, &v3_1, &values->Attribute[5]); 4848 4849 dw[3] = 4850 __gen_uint(v3_0, 0, 15) | 4851 __gen_uint(v3_1, 16, 31); 4852 4853 uint32_t v4_0; 4854 GEN8_SF_OUTPUT_ATTRIBUTE_DETAIL_pack(data, &v4_0, &values->Attribute[6]); 4855 4856 uint32_t v4_1; 4857 GEN8_SF_OUTPUT_ATTRIBUTE_DETAIL_pack(data, &v4_1, &values->Attribute[7]); 4858 4859 dw[4] = 4860 __gen_uint(v4_0, 0, 15) | 4861 __gen_uint(v4_1, 16, 31); 4862 4863 uint32_t v5_0; 4864 GEN8_SF_OUTPUT_ATTRIBUTE_DETAIL_pack(data, &v5_0, &values->Attribute[8]); 4865 4866 uint32_t v5_1; 4867 GEN8_SF_OUTPUT_ATTRIBUTE_DETAIL_pack(data, &v5_1, &values->Attribute[9]); 4868 4869 dw[5] = 4870 __gen_uint(v5_0, 0, 15) | 4871 __gen_uint(v5_1, 16, 31); 4872 4873 uint32_t v6_0; 4874 GEN8_SF_OUTPUT_ATTRIBUTE_DETAIL_pack(data, &v6_0, &values->Attribute[10]); 4875 4876 uint32_t v6_1; 4877 GEN8_SF_OUTPUT_ATTRIBUTE_DETAIL_pack(data, &v6_1, &values->Attribute[11]); 4878 4879 dw[6] = 4880 __gen_uint(v6_0, 0, 15) | 4881 __gen_uint(v6_1, 16, 31); 4882 4883 uint32_t v7_0; 4884 GEN8_SF_OUTPUT_ATTRIBUTE_DETAIL_pack(data, &v7_0, &values->Attribute[12]); 4885 4886 uint32_t v7_1; 4887 GEN8_SF_OUTPUT_ATTRIBUTE_DETAIL_pack(data, &v7_1, &values->Attribute[13]); 4888 4889 dw[7] = 4890 __gen_uint(v7_0, 0, 15) | 4891 __gen_uint(v7_1, 16, 31); 4892 4893 uint32_t v8_0; 4894 GEN8_SF_OUTPUT_ATTRIBUTE_DETAIL_pack(data, &v8_0, &values->Attribute[14]); 4895 4896 uint32_t v8_1; 4897 GEN8_SF_OUTPUT_ATTRIBUTE_DETAIL_pack(data, &v8_1, &values->Attribute[15]); 4898 4899 dw[8] = 4900 __gen_uint(v8_0, 0, 15) | 4901 __gen_uint(v8_1, 16, 31); 4902 4903 dw[9] = 4904 __gen_uint(values->AttributeWrapShortestEnables[0], 0, 3) | 4905 __gen_uint(values->AttributeWrapShortestEnables[1], 4, 7) | 4906 __gen_uint(values->AttributeWrapShortestEnables[2], 8, 11) | 4907 __gen_uint(values->AttributeWrapShortestEnables[3], 12, 15) | 4908 __gen_uint(values->AttributeWrapShortestEnables[4], 16, 19) | 4909 __gen_uint(values->AttributeWrapShortestEnables[5], 20, 23) | 4910 __gen_uint(values->AttributeWrapShortestEnables[6], 24, 27) | 4911 __gen_uint(values->AttributeWrapShortestEnables[7], 28, 31); 4912 4913 dw[10] = 4914 __gen_uint(values->AttributeWrapShortestEnables[8], 0, 3) | 4915 __gen_uint(values->AttributeWrapShortestEnables[9], 4, 7) | 4916 __gen_uint(values->AttributeWrapShortestEnables[10], 8, 11) | 4917 __gen_uint(values->AttributeWrapShortestEnables[11], 12, 15) | 4918 __gen_uint(values->AttributeWrapShortestEnables[12], 16, 19) | 4919 __gen_uint(values->AttributeWrapShortestEnables[13], 20, 23) | 4920 __gen_uint(values->AttributeWrapShortestEnables[14], 24, 27) | 4921 __gen_uint(values->AttributeWrapShortestEnables[15], 28, 31); 4922} 4923 4924#define GEN8_3DSTATE_SCISSOR_STATE_POINTERS_length 2 4925#define GEN8_3DSTATE_SCISSOR_STATE_POINTERS_length_bias 2 4926#define GEN8_3DSTATE_SCISSOR_STATE_POINTERS_header\ 4927 .DWordLength = 0, \ 4928 ._3DCommandSubOpcode = 15, \ 4929 ._3DCommandOpcode = 0, \ 4930 .CommandSubType = 3, \ 4931 .CommandType = 3 4932 4933struct GEN8_3DSTATE_SCISSOR_STATE_POINTERS { 4934 uint32_t DWordLength; 4935 uint32_t _3DCommandSubOpcode; 4936 uint32_t _3DCommandOpcode; 4937 uint32_t CommandSubType; 4938 uint32_t CommandType; 4939 uint64_t ScissorRectPointer; 4940}; 4941 4942static inline void 4943GEN8_3DSTATE_SCISSOR_STATE_POINTERS_pack(__attribute__((unused)) __gen_user_data *data, 4944 __attribute__((unused)) void * restrict dst, 4945 __attribute__((unused)) const struct GEN8_3DSTATE_SCISSOR_STATE_POINTERS * restrict values) 4946{ 4947 uint32_t * restrict dw = (uint32_t * restrict) dst; 4948 4949 dw[0] = 4950 __gen_uint(values->DWordLength, 0, 7) | 4951 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 4952 __gen_uint(values->_3DCommandOpcode, 24, 26) | 4953 __gen_uint(values->CommandSubType, 27, 28) | 4954 __gen_uint(values->CommandType, 29, 31); 4955 4956 dw[1] = 4957 __gen_offset(values->ScissorRectPointer, 5, 31); 4958} 4959 4960#define GEN8_3DSTATE_SF_length 4 4961#define GEN8_3DSTATE_SF_length_bias 2 4962#define GEN8_3DSTATE_SF_header \ 4963 .DWordLength = 2, \ 4964 ._3DCommandSubOpcode = 19, \ 4965 ._3DCommandOpcode = 0, \ 4966 .CommandSubType = 3, \ 4967 .CommandType = 3 4968 4969struct GEN8_3DSTATE_SF { 4970 uint32_t DWordLength; 4971 uint32_t _3DCommandSubOpcode; 4972 uint32_t _3DCommandOpcode; 4973 uint32_t CommandSubType; 4974 uint32_t CommandType; 4975 bool ViewportTransformEnable; 4976 bool StatisticsEnable; 4977 bool LegacyGlobalDepthBiasEnable; 4978 float CHVLineWidth; 4979 uint32_t LineEndCapAntialiasingRegionWidth; 4980#define _05pixels 0 4981#define _10pixels 1 4982#define _20pixels 2 4983#define _40pixels 3 4984 float LineWidth; 4985 float PointWidth; 4986 uint32_t PointWidthSource; 4987#define Vertex 0 4988#define State 1 4989 uint32_t VertexSubPixelPrecisionSelect; 4990#define _8Bit 0 4991#define _4Bit 1 4992 bool SmoothPointEnable; 4993 uint32_t AALineDistanceMode; 4994#define AALINEDISTANCE_TRUE 1 4995 uint32_t TriangleFanProvokingVertexSelect; 4996 uint32_t LineStripListProvokingVertexSelect; 4997 uint32_t TriangleStripListProvokingVertexSelect; 4998 bool LastPixelEnable; 4999}; 5000 5001static inline void 5002GEN8_3DSTATE_SF_pack(__attribute__((unused)) __gen_user_data *data, 5003 __attribute__((unused)) void * restrict dst, 5004 __attribute__((unused)) const struct GEN8_3DSTATE_SF * restrict values) 5005{ 5006 uint32_t * restrict dw = (uint32_t * restrict) dst; 5007 5008 dw[0] = 5009 __gen_uint(values->DWordLength, 0, 7) | 5010 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 5011 __gen_uint(values->_3DCommandOpcode, 24, 26) | 5012 __gen_uint(values->CommandSubType, 27, 28) | 5013 __gen_uint(values->CommandType, 29, 31); 5014 5015 dw[1] = 5016 __gen_uint(values->ViewportTransformEnable, 1, 1) | 5017 __gen_uint(values->StatisticsEnable, 10, 10) | 5018 __gen_uint(values->LegacyGlobalDepthBiasEnable, 11, 11) | 5019 __gen_ufixed(values->CHVLineWidth, 12, 29, 7); 5020 5021 dw[2] = 5022 __gen_uint(values->LineEndCapAntialiasingRegionWidth, 16, 17) | 5023 __gen_ufixed(values->LineWidth, 18, 27, 7); 5024 5025 dw[3] = 5026 __gen_ufixed(values->PointWidth, 0, 10, 3) | 5027 __gen_uint(values->PointWidthSource, 11, 11) | 5028 __gen_uint(values->VertexSubPixelPrecisionSelect, 12, 12) | 5029 __gen_uint(values->SmoothPointEnable, 13, 13) | 5030 __gen_uint(values->AALineDistanceMode, 14, 14) | 5031 __gen_uint(values->TriangleFanProvokingVertexSelect, 25, 26) | 5032 __gen_uint(values->LineStripListProvokingVertexSelect, 27, 28) | 5033 __gen_uint(values->TriangleStripListProvokingVertexSelect, 29, 30) | 5034 __gen_uint(values->LastPixelEnable, 31, 31); 5035} 5036 5037#define GEN8_3DSTATE_SO_BUFFER_length 8 5038#define GEN8_3DSTATE_SO_BUFFER_length_bias 2 5039#define GEN8_3DSTATE_SO_BUFFER_header \ 5040 .DWordLength = 6, \ 5041 ._3DCommandSubOpcode = 24, \ 5042 ._3DCommandOpcode = 1, \ 5043 .CommandSubType = 3, \ 5044 .CommandType = 3 5045 5046struct GEN8_3DSTATE_SO_BUFFER { 5047 uint32_t DWordLength; 5048 uint32_t _3DCommandSubOpcode; 5049 uint32_t _3DCommandOpcode; 5050 uint32_t CommandSubType; 5051 uint32_t CommandType; 5052 bool StreamOutputBufferOffsetAddressEnable; 5053 bool StreamOffsetWriteEnable; 5054 uint32_t MOCS; 5055 uint32_t SOBufferIndex; 5056 bool SOBufferEnable; 5057 __gen_address_type SurfaceBaseAddress; 5058 uint32_t SurfaceSize; 5059 __gen_address_type StreamOutputBufferOffsetAddress; 5060 uint32_t StreamOffset; 5061}; 5062 5063static inline void 5064GEN8_3DSTATE_SO_BUFFER_pack(__attribute__((unused)) __gen_user_data *data, 5065 __attribute__((unused)) void * restrict dst, 5066 __attribute__((unused)) const struct GEN8_3DSTATE_SO_BUFFER * restrict values) 5067{ 5068 uint32_t * restrict dw = (uint32_t * restrict) dst; 5069 5070 dw[0] = 5071 __gen_uint(values->DWordLength, 0, 7) | 5072 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 5073 __gen_uint(values->_3DCommandOpcode, 24, 26) | 5074 __gen_uint(values->CommandSubType, 27, 28) | 5075 __gen_uint(values->CommandType, 29, 31); 5076 5077 dw[1] = 5078 __gen_uint(values->StreamOutputBufferOffsetAddressEnable, 20, 20) | 5079 __gen_uint(values->StreamOffsetWriteEnable, 21, 21) | 5080 __gen_uint(values->MOCS, 22, 28) | 5081 __gen_uint(values->SOBufferIndex, 29, 30) | 5082 __gen_uint(values->SOBufferEnable, 31, 31); 5083 5084 const uint64_t v2_address = 5085 __gen_combine_address(data, &dw[2], values->SurfaceBaseAddress, 0); 5086 dw[2] = v2_address; 5087 dw[3] = v2_address >> 32; 5088 5089 dw[4] = 5090 __gen_uint(values->SurfaceSize, 0, 29); 5091 5092 const uint64_t v5_address = 5093 __gen_combine_address(data, &dw[5], values->StreamOutputBufferOffsetAddress, 0); 5094 dw[5] = v5_address; 5095 dw[6] = v5_address >> 32; 5096 5097 dw[7] = 5098 __gen_uint(values->StreamOffset, 0, 31); 5099} 5100 5101#define GEN8_3DSTATE_SO_DECL_LIST_length_bias 2 5102#define GEN8_3DSTATE_SO_DECL_LIST_header \ 5103 ._3DCommandSubOpcode = 23, \ 5104 ._3DCommandOpcode = 1, \ 5105 .CommandSubType = 3, \ 5106 .CommandType = 3 5107 5108struct GEN8_3DSTATE_SO_DECL_LIST { 5109 uint32_t DWordLength; 5110 uint32_t _3DCommandSubOpcode; 5111 uint32_t _3DCommandOpcode; 5112 uint32_t CommandSubType; 5113 uint32_t CommandType; 5114 uint32_t StreamtoBufferSelects0; 5115 uint32_t StreamtoBufferSelects1; 5116 uint32_t StreamtoBufferSelects2; 5117 uint32_t StreamtoBufferSelects3; 5118 uint32_t NumEntries0; 5119 uint32_t NumEntries1; 5120 uint32_t NumEntries2; 5121 uint32_t NumEntries3; 5122 /* variable length fields follow */ 5123}; 5124 5125static inline void 5126GEN8_3DSTATE_SO_DECL_LIST_pack(__attribute__((unused)) __gen_user_data *data, 5127 __attribute__((unused)) void * restrict dst, 5128 __attribute__((unused)) const struct GEN8_3DSTATE_SO_DECL_LIST * restrict values) 5129{ 5130 uint32_t * restrict dw = (uint32_t * restrict) dst; 5131 5132 dw[0] = 5133 __gen_uint(values->DWordLength, 0, 8) | 5134 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 5135 __gen_uint(values->_3DCommandOpcode, 24, 26) | 5136 __gen_uint(values->CommandSubType, 27, 28) | 5137 __gen_uint(values->CommandType, 29, 31); 5138 5139 dw[1] = 5140 __gen_uint(values->StreamtoBufferSelects0, 0, 3) | 5141 __gen_uint(values->StreamtoBufferSelects1, 4, 7) | 5142 __gen_uint(values->StreamtoBufferSelects2, 8, 11) | 5143 __gen_uint(values->StreamtoBufferSelects3, 12, 15); 5144 5145 dw[2] = 5146 __gen_uint(values->NumEntries0, 0, 7) | 5147 __gen_uint(values->NumEntries1, 8, 15) | 5148 __gen_uint(values->NumEntries2, 16, 23) | 5149 __gen_uint(values->NumEntries3, 24, 31); 5150} 5151 5152#define GEN8_3DSTATE_STENCIL_BUFFER_length 5 5153#define GEN8_3DSTATE_STENCIL_BUFFER_length_bias 2 5154#define GEN8_3DSTATE_STENCIL_BUFFER_header \ 5155 .DWordLength = 3, \ 5156 ._3DCommandSubOpcode = 6, \ 5157 ._3DCommandOpcode = 0, \ 5158 .CommandSubType = 3, \ 5159 .CommandType = 3 5160 5161struct GEN8_3DSTATE_STENCIL_BUFFER { 5162 uint32_t DWordLength; 5163 uint32_t _3DCommandSubOpcode; 5164 uint32_t _3DCommandOpcode; 5165 uint32_t CommandSubType; 5166 uint32_t CommandType; 5167 uint32_t SurfacePitch; 5168 uint32_t MOCS; 5169 bool StencilBufferEnable; 5170 __gen_address_type SurfaceBaseAddress; 5171 uint32_t SurfaceQPitch; 5172}; 5173 5174static inline void 5175GEN8_3DSTATE_STENCIL_BUFFER_pack(__attribute__((unused)) __gen_user_data *data, 5176 __attribute__((unused)) void * restrict dst, 5177 __attribute__((unused)) const struct GEN8_3DSTATE_STENCIL_BUFFER * restrict values) 5178{ 5179 uint32_t * restrict dw = (uint32_t * restrict) dst; 5180 5181 dw[0] = 5182 __gen_uint(values->DWordLength, 0, 7) | 5183 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 5184 __gen_uint(values->_3DCommandOpcode, 24, 26) | 5185 __gen_uint(values->CommandSubType, 27, 28) | 5186 __gen_uint(values->CommandType, 29, 31); 5187 5188 dw[1] = 5189 __gen_uint(values->SurfacePitch, 0, 16) | 5190 __gen_uint(values->MOCS, 22, 28) | 5191 __gen_uint(values->StencilBufferEnable, 31, 31); 5192 5193 const uint64_t v2_address = 5194 __gen_combine_address(data, &dw[2], values->SurfaceBaseAddress, 0); 5195 dw[2] = v2_address; 5196 dw[3] = v2_address >> 32; 5197 5198 dw[4] = 5199 __gen_uint(values->SurfaceQPitch, 0, 14); 5200} 5201 5202#define GEN8_3DSTATE_STREAMOUT_length 5 5203#define GEN8_3DSTATE_STREAMOUT_length_bias 2 5204#define GEN8_3DSTATE_STREAMOUT_header \ 5205 .DWordLength = 3, \ 5206 ._3DCommandSubOpcode = 30, \ 5207 ._3DCommandOpcode = 0, \ 5208 .CommandSubType = 3, \ 5209 .CommandType = 3 5210 5211struct GEN8_3DSTATE_STREAMOUT { 5212 uint32_t DWordLength; 5213 uint32_t _3DCommandSubOpcode; 5214 uint32_t _3DCommandOpcode; 5215 uint32_t CommandSubType; 5216 uint32_t CommandType; 5217 uint32_t ForceRendering; 5218#define Resreved 1 5219#define Force_Off 2 5220#define Force_on 3 5221 bool SOStatisticsEnable; 5222 uint32_t ReorderMode; 5223#define LEADING 0 5224#define TRAILING 1 5225 uint32_t RenderStreamSelect; 5226 bool RenderingDisable; 5227 bool SOFunctionEnable; 5228 uint32_t Stream0VertexReadLength; 5229 uint32_t Stream0VertexReadOffset; 5230 uint32_t Stream1VertexReadLength; 5231 uint32_t Stream1VertexReadOffset; 5232 uint32_t Stream2VertexReadLength; 5233 uint32_t Stream2VertexReadOffset; 5234 uint32_t Stream3VertexReadLength; 5235 uint32_t Stream3VertexReadOffset; 5236 uint32_t Buffer0SurfacePitch; 5237 uint32_t Buffer1SurfacePitch; 5238 uint32_t Buffer2SurfacePitch; 5239 uint32_t Buffer3SurfacePitch; 5240}; 5241 5242static inline void 5243GEN8_3DSTATE_STREAMOUT_pack(__attribute__((unused)) __gen_user_data *data, 5244 __attribute__((unused)) void * restrict dst, 5245 __attribute__((unused)) const struct GEN8_3DSTATE_STREAMOUT * restrict values) 5246{ 5247 uint32_t * restrict dw = (uint32_t * restrict) dst; 5248 5249 dw[0] = 5250 __gen_uint(values->DWordLength, 0, 7) | 5251 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 5252 __gen_uint(values->_3DCommandOpcode, 24, 26) | 5253 __gen_uint(values->CommandSubType, 27, 28) | 5254 __gen_uint(values->CommandType, 29, 31); 5255 5256 dw[1] = 5257 __gen_uint(values->ForceRendering, 23, 24) | 5258 __gen_uint(values->SOStatisticsEnable, 25, 25) | 5259 __gen_uint(values->ReorderMode, 26, 26) | 5260 __gen_uint(values->RenderStreamSelect, 27, 28) | 5261 __gen_uint(values->RenderingDisable, 30, 30) | 5262 __gen_uint(values->SOFunctionEnable, 31, 31); 5263 5264 dw[2] = 5265 __gen_uint(values->Stream0VertexReadLength, 0, 4) | 5266 __gen_uint(values->Stream0VertexReadOffset, 5, 5) | 5267 __gen_uint(values->Stream1VertexReadLength, 8, 12) | 5268 __gen_uint(values->Stream1VertexReadOffset, 13, 13) | 5269 __gen_uint(values->Stream2VertexReadLength, 16, 20) | 5270 __gen_uint(values->Stream2VertexReadOffset, 21, 21) | 5271 __gen_uint(values->Stream3VertexReadLength, 24, 28) | 5272 __gen_uint(values->Stream3VertexReadOffset, 29, 29); 5273 5274 dw[3] = 5275 __gen_uint(values->Buffer0SurfacePitch, 0, 11) | 5276 __gen_uint(values->Buffer1SurfacePitch, 16, 27); 5277 5278 dw[4] = 5279 __gen_uint(values->Buffer2SurfacePitch, 0, 11) | 5280 __gen_uint(values->Buffer3SurfacePitch, 16, 27); 5281} 5282 5283#define GEN8_3DSTATE_TE_length 4 5284#define GEN8_3DSTATE_TE_length_bias 2 5285#define GEN8_3DSTATE_TE_header \ 5286 .DWordLength = 2, \ 5287 ._3DCommandSubOpcode = 28, \ 5288 ._3DCommandOpcode = 0, \ 5289 .CommandSubType = 3, \ 5290 .CommandType = 3 5291 5292struct GEN8_3DSTATE_TE { 5293 uint32_t DWordLength; 5294 uint32_t _3DCommandSubOpcode; 5295 uint32_t _3DCommandOpcode; 5296 uint32_t CommandSubType; 5297 uint32_t CommandType; 5298 bool TEEnable; 5299 uint32_t TEMode; 5300#define HW_TESS 0 5301#define SW_TESS 1 5302 uint32_t TEDomain; 5303#define QUAD 0 5304#define TRI 1 5305#define ISOLINE 2 5306 uint32_t OutputTopology; 5307#define OUTPUT_POINT 0 5308#define OUTPUT_LINE 1 5309#define OUTPUT_TRI_CW 2 5310#define OUTPUT_TRI_CCW 3 5311 uint32_t Partitioning; 5312#define INTEGER 0 5313#define ODD_FRACTIONAL 1 5314#define EVEN_FRACTIONAL 2 5315 float MaximumTessellationFactorOdd; 5316 float MaximumTessellationFactorNotOdd; 5317}; 5318 5319static inline void 5320GEN8_3DSTATE_TE_pack(__attribute__((unused)) __gen_user_data *data, 5321 __attribute__((unused)) void * restrict dst, 5322 __attribute__((unused)) const struct GEN8_3DSTATE_TE * restrict values) 5323{ 5324 uint32_t * restrict dw = (uint32_t * restrict) dst; 5325 5326 dw[0] = 5327 __gen_uint(values->DWordLength, 0, 7) | 5328 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 5329 __gen_uint(values->_3DCommandOpcode, 24, 26) | 5330 __gen_uint(values->CommandSubType, 27, 28) | 5331 __gen_uint(values->CommandType, 29, 31); 5332 5333 dw[1] = 5334 __gen_uint(values->TEEnable, 0, 0) | 5335 __gen_uint(values->TEMode, 1, 2) | 5336 __gen_uint(values->TEDomain, 4, 5) | 5337 __gen_uint(values->OutputTopology, 8, 9) | 5338 __gen_uint(values->Partitioning, 12, 13); 5339 5340 dw[2] = 5341 __gen_float(values->MaximumTessellationFactorOdd); 5342 5343 dw[3] = 5344 __gen_float(values->MaximumTessellationFactorNotOdd); 5345} 5346 5347#define GEN8_3DSTATE_URB_DS_length 2 5348#define GEN8_3DSTATE_URB_DS_length_bias 2 5349#define GEN8_3DSTATE_URB_DS_header \ 5350 .DWordLength = 0, \ 5351 ._3DCommandSubOpcode = 50, \ 5352 ._3DCommandOpcode = 0, \ 5353 .CommandSubType = 3, \ 5354 .CommandType = 3 5355 5356struct GEN8_3DSTATE_URB_DS { 5357 uint32_t DWordLength; 5358 uint32_t _3DCommandSubOpcode; 5359 uint32_t _3DCommandOpcode; 5360 uint32_t CommandSubType; 5361 uint32_t CommandType; 5362 uint32_t DSNumberofURBEntries; 5363 uint32_t DSURBEntryAllocationSize; 5364 uint32_t DSURBStartingAddress; 5365}; 5366 5367static inline void 5368GEN8_3DSTATE_URB_DS_pack(__attribute__((unused)) __gen_user_data *data, 5369 __attribute__((unused)) void * restrict dst, 5370 __attribute__((unused)) const struct GEN8_3DSTATE_URB_DS * restrict values) 5371{ 5372 uint32_t * restrict dw = (uint32_t * restrict) dst; 5373 5374 dw[0] = 5375 __gen_uint(values->DWordLength, 0, 7) | 5376 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 5377 __gen_uint(values->_3DCommandOpcode, 24, 26) | 5378 __gen_uint(values->CommandSubType, 27, 28) | 5379 __gen_uint(values->CommandType, 29, 31); 5380 5381 dw[1] = 5382 __gen_uint(values->DSNumberofURBEntries, 0, 15) | 5383 __gen_uint(values->DSURBEntryAllocationSize, 16, 24) | 5384 __gen_uint(values->DSURBStartingAddress, 25, 31); 5385} 5386 5387#define GEN8_3DSTATE_URB_GS_length 2 5388#define GEN8_3DSTATE_URB_GS_length_bias 2 5389#define GEN8_3DSTATE_URB_GS_header \ 5390 .DWordLength = 0, \ 5391 ._3DCommandSubOpcode = 51, \ 5392 ._3DCommandOpcode = 0, \ 5393 .CommandSubType = 3, \ 5394 .CommandType = 3 5395 5396struct GEN8_3DSTATE_URB_GS { 5397 uint32_t DWordLength; 5398 uint32_t _3DCommandSubOpcode; 5399 uint32_t _3DCommandOpcode; 5400 uint32_t CommandSubType; 5401 uint32_t CommandType; 5402 uint32_t GSNumberofURBEntries; 5403 uint32_t GSURBEntryAllocationSize; 5404 uint32_t GSURBStartingAddress; 5405}; 5406 5407static inline void 5408GEN8_3DSTATE_URB_GS_pack(__attribute__((unused)) __gen_user_data *data, 5409 __attribute__((unused)) void * restrict dst, 5410 __attribute__((unused)) const struct GEN8_3DSTATE_URB_GS * restrict values) 5411{ 5412 uint32_t * restrict dw = (uint32_t * restrict) dst; 5413 5414 dw[0] = 5415 __gen_uint(values->DWordLength, 0, 7) | 5416 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 5417 __gen_uint(values->_3DCommandOpcode, 24, 26) | 5418 __gen_uint(values->CommandSubType, 27, 28) | 5419 __gen_uint(values->CommandType, 29, 31); 5420 5421 dw[1] = 5422 __gen_uint(values->GSNumberofURBEntries, 0, 15) | 5423 __gen_uint(values->GSURBEntryAllocationSize, 16, 24) | 5424 __gen_uint(values->GSURBStartingAddress, 25, 31); 5425} 5426 5427#define GEN8_3DSTATE_URB_HS_length 2 5428#define GEN8_3DSTATE_URB_HS_length_bias 2 5429#define GEN8_3DSTATE_URB_HS_header \ 5430 .DWordLength = 0, \ 5431 ._3DCommandSubOpcode = 49, \ 5432 ._3DCommandOpcode = 0, \ 5433 .CommandSubType = 3, \ 5434 .CommandType = 3 5435 5436struct GEN8_3DSTATE_URB_HS { 5437 uint32_t DWordLength; 5438 uint32_t _3DCommandSubOpcode; 5439 uint32_t _3DCommandOpcode; 5440 uint32_t CommandSubType; 5441 uint32_t CommandType; 5442 uint32_t HSNumberofURBEntries; 5443 uint32_t HSURBEntryAllocationSize; 5444 uint32_t HSURBStartingAddress; 5445}; 5446 5447static inline void 5448GEN8_3DSTATE_URB_HS_pack(__attribute__((unused)) __gen_user_data *data, 5449 __attribute__((unused)) void * restrict dst, 5450 __attribute__((unused)) const struct GEN8_3DSTATE_URB_HS * restrict values) 5451{ 5452 uint32_t * restrict dw = (uint32_t * restrict) dst; 5453 5454 dw[0] = 5455 __gen_uint(values->DWordLength, 0, 7) | 5456 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 5457 __gen_uint(values->_3DCommandOpcode, 24, 26) | 5458 __gen_uint(values->CommandSubType, 27, 28) | 5459 __gen_uint(values->CommandType, 29, 31); 5460 5461 dw[1] = 5462 __gen_uint(values->HSNumberofURBEntries, 0, 15) | 5463 __gen_uint(values->HSURBEntryAllocationSize, 16, 24) | 5464 __gen_uint(values->HSURBStartingAddress, 25, 31); 5465} 5466 5467#define GEN8_3DSTATE_URB_VS_length 2 5468#define GEN8_3DSTATE_URB_VS_length_bias 2 5469#define GEN8_3DSTATE_URB_VS_header \ 5470 .DWordLength = 0, \ 5471 ._3DCommandSubOpcode = 48, \ 5472 ._3DCommandOpcode = 0, \ 5473 .CommandSubType = 3, \ 5474 .CommandType = 3 5475 5476struct GEN8_3DSTATE_URB_VS { 5477 uint32_t DWordLength; 5478 uint32_t _3DCommandSubOpcode; 5479 uint32_t _3DCommandOpcode; 5480 uint32_t CommandSubType; 5481 uint32_t CommandType; 5482 uint32_t VSNumberofURBEntries; 5483 uint32_t VSURBEntryAllocationSize; 5484 uint32_t VSURBStartingAddress; 5485}; 5486 5487static inline void 5488GEN8_3DSTATE_URB_VS_pack(__attribute__((unused)) __gen_user_data *data, 5489 __attribute__((unused)) void * restrict dst, 5490 __attribute__((unused)) const struct GEN8_3DSTATE_URB_VS * restrict values) 5491{ 5492 uint32_t * restrict dw = (uint32_t * restrict) dst; 5493 5494 dw[0] = 5495 __gen_uint(values->DWordLength, 0, 7) | 5496 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 5497 __gen_uint(values->_3DCommandOpcode, 24, 26) | 5498 __gen_uint(values->CommandSubType, 27, 28) | 5499 __gen_uint(values->CommandType, 29, 31); 5500 5501 dw[1] = 5502 __gen_uint(values->VSNumberofURBEntries, 0, 15) | 5503 __gen_uint(values->VSURBEntryAllocationSize, 16, 24) | 5504 __gen_uint(values->VSURBStartingAddress, 25, 31); 5505} 5506 5507#define GEN8_3DSTATE_VERTEX_BUFFERS_length_bias 2 5508#define GEN8_3DSTATE_VERTEX_BUFFERS_header \ 5509 .DWordLength = 3, \ 5510 ._3DCommandSubOpcode = 8, \ 5511 ._3DCommandOpcode = 0, \ 5512 .CommandSubType = 3, \ 5513 .CommandType = 3 5514 5515struct GEN8_3DSTATE_VERTEX_BUFFERS { 5516 uint32_t DWordLength; 5517 uint32_t _3DCommandSubOpcode; 5518 uint32_t _3DCommandOpcode; 5519 uint32_t CommandSubType; 5520 uint32_t CommandType; 5521 /* variable length fields follow */ 5522}; 5523 5524static inline void 5525GEN8_3DSTATE_VERTEX_BUFFERS_pack(__attribute__((unused)) __gen_user_data *data, 5526 __attribute__((unused)) void * restrict dst, 5527 __attribute__((unused)) const struct GEN8_3DSTATE_VERTEX_BUFFERS * restrict values) 5528{ 5529 uint32_t * restrict dw = (uint32_t * restrict) dst; 5530 5531 dw[0] = 5532 __gen_uint(values->DWordLength, 0, 7) | 5533 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 5534 __gen_uint(values->_3DCommandOpcode, 24, 26) | 5535 __gen_uint(values->CommandSubType, 27, 28) | 5536 __gen_uint(values->CommandType, 29, 31); 5537} 5538 5539#define GEN8_3DSTATE_VERTEX_ELEMENTS_length_bias 2 5540#define GEN8_3DSTATE_VERTEX_ELEMENTS_header \ 5541 .DWordLength = 1, \ 5542 ._3DCommandSubOpcode = 9, \ 5543 ._3DCommandOpcode = 0, \ 5544 .CommandSubType = 3, \ 5545 .CommandType = 3 5546 5547struct GEN8_3DSTATE_VERTEX_ELEMENTS { 5548 uint32_t DWordLength; 5549 uint32_t _3DCommandSubOpcode; 5550 uint32_t _3DCommandOpcode; 5551 uint32_t CommandSubType; 5552 uint32_t CommandType; 5553 /* variable length fields follow */ 5554}; 5555 5556static inline void 5557GEN8_3DSTATE_VERTEX_ELEMENTS_pack(__attribute__((unused)) __gen_user_data *data, 5558 __attribute__((unused)) void * restrict dst, 5559 __attribute__((unused)) const struct GEN8_3DSTATE_VERTEX_ELEMENTS * restrict values) 5560{ 5561 uint32_t * restrict dw = (uint32_t * restrict) dst; 5562 5563 dw[0] = 5564 __gen_uint(values->DWordLength, 0, 7) | 5565 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 5566 __gen_uint(values->_3DCommandOpcode, 24, 26) | 5567 __gen_uint(values->CommandSubType, 27, 28) | 5568 __gen_uint(values->CommandType, 29, 31); 5569} 5570 5571#define GEN8_3DSTATE_VF_length 2 5572#define GEN8_3DSTATE_VF_length_bias 2 5573#define GEN8_3DSTATE_VF_header \ 5574 .DWordLength = 0, \ 5575 ._3DCommandSubOpcode = 12, \ 5576 ._3DCommandOpcode = 0, \ 5577 .CommandSubType = 3, \ 5578 .CommandType = 3 5579 5580struct GEN8_3DSTATE_VF { 5581 uint32_t DWordLength; 5582 bool IndexedDrawCutIndexEnable; 5583 uint32_t _3DCommandSubOpcode; 5584 uint32_t _3DCommandOpcode; 5585 uint32_t CommandSubType; 5586 uint32_t CommandType; 5587 uint32_t CutIndex; 5588}; 5589 5590static inline void 5591GEN8_3DSTATE_VF_pack(__attribute__((unused)) __gen_user_data *data, 5592 __attribute__((unused)) void * restrict dst, 5593 __attribute__((unused)) const struct GEN8_3DSTATE_VF * restrict values) 5594{ 5595 uint32_t * restrict dw = (uint32_t * restrict) dst; 5596 5597 dw[0] = 5598 __gen_uint(values->DWordLength, 0, 7) | 5599 __gen_uint(values->IndexedDrawCutIndexEnable, 8, 8) | 5600 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 5601 __gen_uint(values->_3DCommandOpcode, 24, 26) | 5602 __gen_uint(values->CommandSubType, 27, 28) | 5603 __gen_uint(values->CommandType, 29, 31); 5604 5605 dw[1] = 5606 __gen_uint(values->CutIndex, 0, 31); 5607} 5608 5609#define GEN8_3DSTATE_VF_INSTANCING_length 3 5610#define GEN8_3DSTATE_VF_INSTANCING_length_bias 2 5611#define GEN8_3DSTATE_VF_INSTANCING_header \ 5612 .DWordLength = 1, \ 5613 ._3DCommandSubOpcode = 73, \ 5614 ._3DCommandOpcode = 0, \ 5615 .CommandSubType = 3, \ 5616 .CommandType = 3 5617 5618struct GEN8_3DSTATE_VF_INSTANCING { 5619 uint32_t DWordLength; 5620 uint32_t _3DCommandSubOpcode; 5621 uint32_t _3DCommandOpcode; 5622 uint32_t CommandSubType; 5623 uint32_t CommandType; 5624 uint32_t VertexElementIndex; 5625 bool InstancingEnable; 5626 uint32_t InstanceDataStepRate; 5627}; 5628 5629static inline void 5630GEN8_3DSTATE_VF_INSTANCING_pack(__attribute__((unused)) __gen_user_data *data, 5631 __attribute__((unused)) void * restrict dst, 5632 __attribute__((unused)) const struct GEN8_3DSTATE_VF_INSTANCING * restrict values) 5633{ 5634 uint32_t * restrict dw = (uint32_t * restrict) dst; 5635 5636 dw[0] = 5637 __gen_uint(values->DWordLength, 0, 7) | 5638 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 5639 __gen_uint(values->_3DCommandOpcode, 24, 26) | 5640 __gen_uint(values->CommandSubType, 27, 28) | 5641 __gen_uint(values->CommandType, 29, 31); 5642 5643 dw[1] = 5644 __gen_uint(values->VertexElementIndex, 0, 5) | 5645 __gen_uint(values->InstancingEnable, 8, 8); 5646 5647 dw[2] = 5648 __gen_uint(values->InstanceDataStepRate, 0, 31); 5649} 5650 5651#define GEN8_3DSTATE_VF_SGVS_length 2 5652#define GEN8_3DSTATE_VF_SGVS_length_bias 2 5653#define GEN8_3DSTATE_VF_SGVS_header \ 5654 .DWordLength = 0, \ 5655 ._3DCommandSubOpcode = 74, \ 5656 ._3DCommandOpcode = 0, \ 5657 .CommandSubType = 3, \ 5658 .CommandType = 3 5659 5660struct GEN8_3DSTATE_VF_SGVS { 5661 uint32_t DWordLength; 5662 uint32_t _3DCommandSubOpcode; 5663 uint32_t _3DCommandOpcode; 5664 uint32_t CommandSubType; 5665 uint32_t CommandType; 5666 uint32_t VertexIDElementOffset; 5667 uint32_t VertexIDComponentNumber; 5668#define COMP_0 0 5669#define COMP_1 1 5670#define COMP_2 2 5671#define COMP_3 3 5672 bool VertexIDEnable; 5673 uint32_t InstanceIDElementOffset; 5674 uint32_t InstanceIDComponentNumber; 5675#define COMP_0 0 5676#define COMP_1 1 5677#define COMP_2 2 5678#define COMP_3 3 5679 bool InstanceIDEnable; 5680}; 5681 5682static inline void 5683GEN8_3DSTATE_VF_SGVS_pack(__attribute__((unused)) __gen_user_data *data, 5684 __attribute__((unused)) void * restrict dst, 5685 __attribute__((unused)) const struct GEN8_3DSTATE_VF_SGVS * restrict values) 5686{ 5687 uint32_t * restrict dw = (uint32_t * restrict) dst; 5688 5689 dw[0] = 5690 __gen_uint(values->DWordLength, 0, 7) | 5691 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 5692 __gen_uint(values->_3DCommandOpcode, 24, 26) | 5693 __gen_uint(values->CommandSubType, 27, 28) | 5694 __gen_uint(values->CommandType, 29, 31); 5695 5696 dw[1] = 5697 __gen_uint(values->VertexIDElementOffset, 0, 5) | 5698 __gen_uint(values->VertexIDComponentNumber, 13, 14) | 5699 __gen_uint(values->VertexIDEnable, 15, 15) | 5700 __gen_uint(values->InstanceIDElementOffset, 16, 21) | 5701 __gen_uint(values->InstanceIDComponentNumber, 29, 30) | 5702 __gen_uint(values->InstanceIDEnable, 31, 31); 5703} 5704 5705#define GEN8_3DSTATE_VF_STATISTICS_length 1 5706#define GEN8_3DSTATE_VF_STATISTICS_length_bias 1 5707#define GEN8_3DSTATE_VF_STATISTICS_header \ 5708 ._3DCommandSubOpcode = 11, \ 5709 ._3DCommandOpcode = 0, \ 5710 .CommandSubType = 1, \ 5711 .CommandType = 3 5712 5713struct GEN8_3DSTATE_VF_STATISTICS { 5714 bool StatisticsEnable; 5715 uint32_t _3DCommandSubOpcode; 5716 uint32_t _3DCommandOpcode; 5717 uint32_t CommandSubType; 5718 uint32_t CommandType; 5719}; 5720 5721static inline void 5722GEN8_3DSTATE_VF_STATISTICS_pack(__attribute__((unused)) __gen_user_data *data, 5723 __attribute__((unused)) void * restrict dst, 5724 __attribute__((unused)) const struct GEN8_3DSTATE_VF_STATISTICS * restrict values) 5725{ 5726 uint32_t * restrict dw = (uint32_t * restrict) dst; 5727 5728 dw[0] = 5729 __gen_uint(values->StatisticsEnable, 0, 0) | 5730 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 5731 __gen_uint(values->_3DCommandOpcode, 24, 26) | 5732 __gen_uint(values->CommandSubType, 27, 28) | 5733 __gen_uint(values->CommandType, 29, 31); 5734} 5735 5736#define GEN8_3DSTATE_VF_TOPOLOGY_length 2 5737#define GEN8_3DSTATE_VF_TOPOLOGY_length_bias 2 5738#define GEN8_3DSTATE_VF_TOPOLOGY_header \ 5739 .DWordLength = 0, \ 5740 ._3DCommandSubOpcode = 75, \ 5741 ._3DCommandOpcode = 0, \ 5742 .CommandSubType = 3, \ 5743 .CommandType = 3 5744 5745struct GEN8_3DSTATE_VF_TOPOLOGY { 5746 uint32_t DWordLength; 5747 uint32_t _3DCommandSubOpcode; 5748 uint32_t _3DCommandOpcode; 5749 uint32_t CommandSubType; 5750 uint32_t CommandType; 5751 enum GEN8_3D_Prim_Topo_Type PrimitiveTopologyType; 5752}; 5753 5754static inline void 5755GEN8_3DSTATE_VF_TOPOLOGY_pack(__attribute__((unused)) __gen_user_data *data, 5756 __attribute__((unused)) void * restrict dst, 5757 __attribute__((unused)) const struct GEN8_3DSTATE_VF_TOPOLOGY * restrict values) 5758{ 5759 uint32_t * restrict dw = (uint32_t * restrict) dst; 5760 5761 dw[0] = 5762 __gen_uint(values->DWordLength, 0, 7) | 5763 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 5764 __gen_uint(values->_3DCommandOpcode, 24, 26) | 5765 __gen_uint(values->CommandSubType, 27, 28) | 5766 __gen_uint(values->CommandType, 29, 31); 5767 5768 dw[1] = 5769 __gen_uint(values->PrimitiveTopologyType, 0, 5); 5770} 5771 5772#define GEN8_3DSTATE_VIEWPORT_STATE_POINTERS_CC_length 2 5773#define GEN8_3DSTATE_VIEWPORT_STATE_POINTERS_CC_length_bias 2 5774#define GEN8_3DSTATE_VIEWPORT_STATE_POINTERS_CC_header\ 5775 .DWordLength = 0, \ 5776 ._3DCommandSubOpcode = 35, \ 5777 ._3DCommandOpcode = 0, \ 5778 .CommandSubType = 3, \ 5779 .CommandType = 3 5780 5781struct GEN8_3DSTATE_VIEWPORT_STATE_POINTERS_CC { 5782 uint32_t DWordLength; 5783 uint32_t _3DCommandSubOpcode; 5784 uint32_t _3DCommandOpcode; 5785 uint32_t CommandSubType; 5786 uint32_t CommandType; 5787 uint64_t CCViewportPointer; 5788}; 5789 5790static inline void 5791GEN8_3DSTATE_VIEWPORT_STATE_POINTERS_CC_pack(__attribute__((unused)) __gen_user_data *data, 5792 __attribute__((unused)) void * restrict dst, 5793 __attribute__((unused)) const struct GEN8_3DSTATE_VIEWPORT_STATE_POINTERS_CC * restrict values) 5794{ 5795 uint32_t * restrict dw = (uint32_t * restrict) dst; 5796 5797 dw[0] = 5798 __gen_uint(values->DWordLength, 0, 7) | 5799 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 5800 __gen_uint(values->_3DCommandOpcode, 24, 26) | 5801 __gen_uint(values->CommandSubType, 27, 28) | 5802 __gen_uint(values->CommandType, 29, 31); 5803 5804 dw[1] = 5805 __gen_offset(values->CCViewportPointer, 5, 31); 5806} 5807 5808#define GEN8_3DSTATE_VIEWPORT_STATE_POINTERS_SF_CLIP_length 2 5809#define GEN8_3DSTATE_VIEWPORT_STATE_POINTERS_SF_CLIP_length_bias 2 5810#define GEN8_3DSTATE_VIEWPORT_STATE_POINTERS_SF_CLIP_header\ 5811 .DWordLength = 0, \ 5812 ._3DCommandSubOpcode = 33, \ 5813 ._3DCommandOpcode = 0, \ 5814 .CommandSubType = 3, \ 5815 .CommandType = 3 5816 5817struct GEN8_3DSTATE_VIEWPORT_STATE_POINTERS_SF_CLIP { 5818 uint32_t DWordLength; 5819 uint32_t _3DCommandSubOpcode; 5820 uint32_t _3DCommandOpcode; 5821 uint32_t CommandSubType; 5822 uint32_t CommandType; 5823 uint64_t SFClipViewportPointer; 5824}; 5825 5826static inline void 5827GEN8_3DSTATE_VIEWPORT_STATE_POINTERS_SF_CLIP_pack(__attribute__((unused)) __gen_user_data *data, 5828 __attribute__((unused)) void * restrict dst, 5829 __attribute__((unused)) const struct GEN8_3DSTATE_VIEWPORT_STATE_POINTERS_SF_CLIP * restrict values) 5830{ 5831 uint32_t * restrict dw = (uint32_t * restrict) dst; 5832 5833 dw[0] = 5834 __gen_uint(values->DWordLength, 0, 7) | 5835 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 5836 __gen_uint(values->_3DCommandOpcode, 24, 26) | 5837 __gen_uint(values->CommandSubType, 27, 28) | 5838 __gen_uint(values->CommandType, 29, 31); 5839 5840 dw[1] = 5841 __gen_offset(values->SFClipViewportPointer, 6, 31); 5842} 5843 5844#define GEN8_3DSTATE_VS_length 9 5845#define GEN8_3DSTATE_VS_length_bias 2 5846#define GEN8_3DSTATE_VS_header \ 5847 .DWordLength = 7, \ 5848 ._3DCommandSubOpcode = 16, \ 5849 ._3DCommandOpcode = 0, \ 5850 .CommandSubType = 3, \ 5851 .CommandType = 3 5852 5853struct GEN8_3DSTATE_VS { 5854 uint32_t DWordLength; 5855 uint32_t _3DCommandSubOpcode; 5856 uint32_t _3DCommandOpcode; 5857 uint32_t CommandSubType; 5858 uint32_t CommandType; 5859 uint64_t KernelStartPointer; 5860 bool SoftwareExceptionEnable; 5861 bool AccessesUAV; 5862 bool IllegalOpcodeExceptionEnable; 5863 uint32_t FloatingPointMode; 5864#define IEEE754 0 5865#define Alternate 1 5866 uint32_t ThreadDispatchPriority; 5867#define High 1 5868 uint32_t BindingTableEntryCount; 5869 uint32_t SamplerCount; 5870#define NoSamplers 0 5871#define _14Samplers 1 5872#define _58Samplers 2 5873#define _912Samplers 3 5874#define _1316Samplers 4 5875 bool VectorMaskEnable; 5876 bool SingleVertexDispatch; 5877 uint32_t PerThreadScratchSpace; 5878 __gen_address_type ScratchSpaceBasePointer; 5879 uint32_t VertexURBEntryReadOffset; 5880 uint32_t VertexURBEntryReadLength; 5881 uint32_t DispatchGRFStartRegisterForURBData; 5882 bool Enable; 5883 bool VertexCacheDisable; 5884 bool SIMD8DispatchEnable; 5885 bool StatisticsEnable; 5886 uint32_t MaximumNumberofThreads; 5887 uint32_t UserClipDistanceCullTestEnableBitmask; 5888 uint32_t UserClipDistanceClipTestEnableBitmask; 5889 uint32_t VertexURBEntryOutputLength; 5890 uint32_t VertexURBEntryOutputReadOffset; 5891}; 5892 5893static inline void 5894GEN8_3DSTATE_VS_pack(__attribute__((unused)) __gen_user_data *data, 5895 __attribute__((unused)) void * restrict dst, 5896 __attribute__((unused)) const struct GEN8_3DSTATE_VS * restrict values) 5897{ 5898 uint32_t * restrict dw = (uint32_t * restrict) dst; 5899 5900 dw[0] = 5901 __gen_uint(values->DWordLength, 0, 7) | 5902 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 5903 __gen_uint(values->_3DCommandOpcode, 24, 26) | 5904 __gen_uint(values->CommandSubType, 27, 28) | 5905 __gen_uint(values->CommandType, 29, 31); 5906 5907 const uint64_t v1 = 5908 __gen_offset(values->KernelStartPointer, 6, 63); 5909 dw[1] = v1; 5910 dw[2] = v1 >> 32; 5911 5912 dw[3] = 5913 __gen_uint(values->SoftwareExceptionEnable, 7, 7) | 5914 __gen_uint(values->AccessesUAV, 12, 12) | 5915 __gen_uint(values->IllegalOpcodeExceptionEnable, 13, 13) | 5916 __gen_uint(values->FloatingPointMode, 16, 16) | 5917 __gen_uint(values->ThreadDispatchPriority, 17, 17) | 5918 __gen_uint(values->BindingTableEntryCount, 18, 25) | 5919 __gen_uint(values->SamplerCount, 27, 29) | 5920 __gen_uint(values->VectorMaskEnable, 30, 30) | 5921 __gen_uint(values->SingleVertexDispatch, 31, 31); 5922 5923 const uint64_t v4 = 5924 __gen_uint(values->PerThreadScratchSpace, 0, 3); 5925 const uint64_t v4_address = 5926 __gen_combine_address(data, &dw[4], values->ScratchSpaceBasePointer, v4); 5927 dw[4] = v4_address; 5928 dw[5] = (v4_address >> 32) | (v4 >> 32); 5929 5930 dw[6] = 5931 __gen_uint(values->VertexURBEntryReadOffset, 4, 9) | 5932 __gen_uint(values->VertexURBEntryReadLength, 11, 16) | 5933 __gen_uint(values->DispatchGRFStartRegisterForURBData, 20, 24); 5934 5935 dw[7] = 5936 __gen_uint(values->Enable, 0, 0) | 5937 __gen_uint(values->VertexCacheDisable, 1, 1) | 5938 __gen_uint(values->SIMD8DispatchEnable, 2, 2) | 5939 __gen_uint(values->StatisticsEnable, 10, 10) | 5940 __gen_uint(values->MaximumNumberofThreads, 23, 31); 5941 5942 dw[8] = 5943 __gen_uint(values->UserClipDistanceCullTestEnableBitmask, 0, 7) | 5944 __gen_uint(values->UserClipDistanceClipTestEnableBitmask, 8, 15) | 5945 __gen_uint(values->VertexURBEntryOutputLength, 16, 20) | 5946 __gen_uint(values->VertexURBEntryOutputReadOffset, 21, 26); 5947} 5948 5949#define GEN8_3DSTATE_WM_length 2 5950#define GEN8_3DSTATE_WM_length_bias 2 5951#define GEN8_3DSTATE_WM_header \ 5952 .DWordLength = 0, \ 5953 ._3DCommandSubOpcode = 20, \ 5954 ._3DCommandOpcode = 0, \ 5955 .CommandSubType = 3, \ 5956 .CommandType = 3 5957 5958struct GEN8_3DSTATE_WM { 5959 uint32_t DWordLength; 5960 uint32_t _3DCommandSubOpcode; 5961 uint32_t _3DCommandOpcode; 5962 uint32_t CommandSubType; 5963 uint32_t CommandType; 5964 uint32_t ForceKillPixelEnable; 5965#define ForceOff 1 5966#define ForceON 2 5967 uint32_t PointRasterizationRule; 5968#define RASTRULE_UPPER_LEFT 0 5969#define RASTRULE_UPPER_RIGHT 1 5970 bool LineStippleEnable; 5971 bool PolygonStippleEnable; 5972 uint32_t LineAntialiasingRegionWidth; 5973#define _05pixels 0 5974#define _10pixels 1 5975#define _20pixels 2 5976#define _40pixels 3 5977 uint32_t LineEndCapAntialiasingRegionWidth; 5978#define _05pixels 0 5979#define _10pixels 1 5980#define _20pixels 2 5981#define _40pixels 3 5982 uint32_t BarycentricInterpolationMode; 5983#define BIM_PERSPECTIVE_PIXEL 1 5984#define BIM_PERSPECTIVE_CENTROID 2 5985#define BIM_PERSPECTIVE_SAMPLE 4 5986#define BIM_LINEAR_PIXEL 8 5987#define BIM_LINEAR_CENTROID 16 5988#define BIM_LINEAR_SAMPLE 32 5989 uint32_t PositionZWInterpolationMode; 5990#define INTERP_PIXEL 0 5991#define INTERP_CENTROID 2 5992#define INTERP_SAMPLE 3 5993 uint32_t ForceThreadDispatchEnable; 5994#define ForceOff 1 5995#define ForceON 2 5996 uint32_t EarlyDepthStencilControl; 5997#define EDSC_NORMAL 0 5998#define EDSC_PSEXEC 1 5999#define EDSC_PREPS 2 6000 bool LegacyDiamondLineRasterization; 6001 bool LegacyHierarchicalDepthBufferResolveEnable; 6002 bool LegacyDepthBufferResolveEnable; 6003 bool LegacyDepthBufferClearEnable; 6004 bool StatisticsEnable; 6005}; 6006 6007static inline void 6008GEN8_3DSTATE_WM_pack(__attribute__((unused)) __gen_user_data *data, 6009 __attribute__((unused)) void * restrict dst, 6010 __attribute__((unused)) const struct GEN8_3DSTATE_WM * restrict values) 6011{ 6012 uint32_t * restrict dw = (uint32_t * restrict) dst; 6013 6014 dw[0] = 6015 __gen_uint(values->DWordLength, 0, 7) | 6016 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 6017 __gen_uint(values->_3DCommandOpcode, 24, 26) | 6018 __gen_uint(values->CommandSubType, 27, 28) | 6019 __gen_uint(values->CommandType, 29, 31); 6020 6021 dw[1] = 6022 __gen_uint(values->ForceKillPixelEnable, 0, 1) | 6023 __gen_uint(values->PointRasterizationRule, 2, 2) | 6024 __gen_uint(values->LineStippleEnable, 3, 3) | 6025 __gen_uint(values->PolygonStippleEnable, 4, 4) | 6026 __gen_uint(values->LineAntialiasingRegionWidth, 6, 7) | 6027 __gen_uint(values->LineEndCapAntialiasingRegionWidth, 8, 9) | 6028 __gen_uint(values->BarycentricInterpolationMode, 11, 16) | 6029 __gen_uint(values->PositionZWInterpolationMode, 17, 18) | 6030 __gen_uint(values->ForceThreadDispatchEnable, 19, 20) | 6031 __gen_uint(values->EarlyDepthStencilControl, 21, 22) | 6032 __gen_uint(values->LegacyDiamondLineRasterization, 26, 26) | 6033 __gen_uint(values->LegacyHierarchicalDepthBufferResolveEnable, 27, 27) | 6034 __gen_uint(values->LegacyDepthBufferResolveEnable, 28, 28) | 6035 __gen_uint(values->LegacyDepthBufferClearEnable, 30, 30) | 6036 __gen_uint(values->StatisticsEnable, 31, 31); 6037} 6038 6039#define GEN8_3DSTATE_WM_CHROMAKEY_length 2 6040#define GEN8_3DSTATE_WM_CHROMAKEY_length_bias 2 6041#define GEN8_3DSTATE_WM_CHROMAKEY_header \ 6042 .DWordLength = 0, \ 6043 ._3DCommandSubOpcode = 76, \ 6044 ._3DCommandOpcode = 0, \ 6045 .CommandSubType = 3, \ 6046 .CommandType = 3 6047 6048struct GEN8_3DSTATE_WM_CHROMAKEY { 6049 uint32_t DWordLength; 6050 uint32_t _3DCommandSubOpcode; 6051 uint32_t _3DCommandOpcode; 6052 uint32_t CommandSubType; 6053 uint32_t CommandType; 6054 bool ChromaKeyKillEnable; 6055}; 6056 6057static inline void 6058GEN8_3DSTATE_WM_CHROMAKEY_pack(__attribute__((unused)) __gen_user_data *data, 6059 __attribute__((unused)) void * restrict dst, 6060 __attribute__((unused)) const struct GEN8_3DSTATE_WM_CHROMAKEY * restrict values) 6061{ 6062 uint32_t * restrict dw = (uint32_t * restrict) dst; 6063 6064 dw[0] = 6065 __gen_uint(values->DWordLength, 0, 7) | 6066 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 6067 __gen_uint(values->_3DCommandOpcode, 24, 26) | 6068 __gen_uint(values->CommandSubType, 27, 28) | 6069 __gen_uint(values->CommandType, 29, 31); 6070 6071 dw[1] = 6072 __gen_uint(values->ChromaKeyKillEnable, 31, 31); 6073} 6074 6075#define GEN8_3DSTATE_WM_DEPTH_STENCIL_length 3 6076#define GEN8_3DSTATE_WM_DEPTH_STENCIL_length_bias 2 6077#define GEN8_3DSTATE_WM_DEPTH_STENCIL_header \ 6078 .DWordLength = 1, \ 6079 ._3DCommandSubOpcode = 78, \ 6080 ._3DCommandOpcode = 0, \ 6081 .CommandSubType = 3, \ 6082 .CommandType = 3 6083 6084struct GEN8_3DSTATE_WM_DEPTH_STENCIL { 6085 uint32_t DWordLength; 6086 uint32_t _3DCommandSubOpcode; 6087 uint32_t _3DCommandOpcode; 6088 uint32_t CommandSubType; 6089 uint32_t CommandType; 6090 bool DepthBufferWriteEnable; 6091 bool DepthTestEnable; 6092 bool StencilBufferWriteEnable; 6093 bool StencilTestEnable; 6094 bool DoubleSidedStencilEnable; 6095 enum GEN8_3D_Compare_Function DepthTestFunction; 6096 enum GEN8_3D_Compare_Function StencilTestFunction; 6097 enum GEN8_3D_Stencil_Operation BackfaceStencilPassDepthPassOp; 6098 enum GEN8_3D_Stencil_Operation BackfaceStencilPassDepthFailOp; 6099 enum GEN8_3D_Stencil_Operation BackfaceStencilFailOp; 6100 enum GEN8_3D_Compare_Function BackfaceStencilTestFunction; 6101 enum GEN8_3D_Stencil_Operation StencilPassDepthPassOp; 6102 enum GEN8_3D_Stencil_Operation StencilPassDepthFailOp; 6103 enum GEN8_3D_Stencil_Operation StencilFailOp; 6104 uint32_t BackfaceStencilWriteMask; 6105 uint32_t BackfaceStencilTestMask; 6106 uint32_t StencilWriteMask; 6107 uint32_t StencilTestMask; 6108}; 6109 6110static inline void 6111GEN8_3DSTATE_WM_DEPTH_STENCIL_pack(__attribute__((unused)) __gen_user_data *data, 6112 __attribute__((unused)) void * restrict dst, 6113 __attribute__((unused)) const struct GEN8_3DSTATE_WM_DEPTH_STENCIL * restrict values) 6114{ 6115 uint32_t * restrict dw = (uint32_t * restrict) dst; 6116 6117 dw[0] = 6118 __gen_uint(values->DWordLength, 0, 7) | 6119 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 6120 __gen_uint(values->_3DCommandOpcode, 24, 26) | 6121 __gen_uint(values->CommandSubType, 27, 28) | 6122 __gen_uint(values->CommandType, 29, 31); 6123 6124 dw[1] = 6125 __gen_uint(values->DepthBufferWriteEnable, 0, 0) | 6126 __gen_uint(values->DepthTestEnable, 1, 1) | 6127 __gen_uint(values->StencilBufferWriteEnable, 2, 2) | 6128 __gen_uint(values->StencilTestEnable, 3, 3) | 6129 __gen_uint(values->DoubleSidedStencilEnable, 4, 4) | 6130 __gen_uint(values->DepthTestFunction, 5, 7) | 6131 __gen_uint(values->StencilTestFunction, 8, 10) | 6132 __gen_uint(values->BackfaceStencilPassDepthPassOp, 11, 13) | 6133 __gen_uint(values->BackfaceStencilPassDepthFailOp, 14, 16) | 6134 __gen_uint(values->BackfaceStencilFailOp, 17, 19) | 6135 __gen_uint(values->BackfaceStencilTestFunction, 20, 22) | 6136 __gen_uint(values->StencilPassDepthPassOp, 23, 25) | 6137 __gen_uint(values->StencilPassDepthFailOp, 26, 28) | 6138 __gen_uint(values->StencilFailOp, 29, 31); 6139 6140 dw[2] = 6141 __gen_uint(values->BackfaceStencilWriteMask, 0, 7) | 6142 __gen_uint(values->BackfaceStencilTestMask, 8, 15) | 6143 __gen_uint(values->StencilWriteMask, 16, 23) | 6144 __gen_uint(values->StencilTestMask, 24, 31); 6145} 6146 6147#define GEN8_3DSTATE_WM_HZ_OP_length 5 6148#define GEN8_3DSTATE_WM_HZ_OP_length_bias 2 6149#define GEN8_3DSTATE_WM_HZ_OP_header \ 6150 .DWordLength = 3, \ 6151 ._3DCommandSubOpcode = 82, \ 6152 ._3DCommandOpcode = 0, \ 6153 .CommandSubType = 3, \ 6154 .CommandType = 3 6155 6156struct GEN8_3DSTATE_WM_HZ_OP { 6157 uint32_t DWordLength; 6158 uint32_t _3DCommandSubOpcode; 6159 uint32_t _3DCommandOpcode; 6160 uint32_t CommandSubType; 6161 uint32_t CommandType; 6162 uint32_t NumberofMultisamples; 6163 uint32_t StencilClearValue; 6164 bool FullSurfaceDepthandStencilClear; 6165 bool PixelPositionOffsetEnable; 6166 bool HierarchicalDepthBufferResolveEnable; 6167 bool DepthBufferResolveEnable; 6168 bool ScissorRectangleEnable; 6169 bool DepthBufferClearEnable; 6170 bool StencilBufferClearEnable; 6171 uint32_t ClearRectangleXMin; 6172 uint32_t ClearRectangleYMin; 6173 uint32_t ClearRectangleXMax; 6174 uint32_t ClearRectangleYMax; 6175 uint32_t SampleMask; 6176}; 6177 6178static inline void 6179GEN8_3DSTATE_WM_HZ_OP_pack(__attribute__((unused)) __gen_user_data *data, 6180 __attribute__((unused)) void * restrict dst, 6181 __attribute__((unused)) const struct GEN8_3DSTATE_WM_HZ_OP * restrict values) 6182{ 6183 uint32_t * restrict dw = (uint32_t * restrict) dst; 6184 6185 dw[0] = 6186 __gen_uint(values->DWordLength, 0, 7) | 6187 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 6188 __gen_uint(values->_3DCommandOpcode, 24, 26) | 6189 __gen_uint(values->CommandSubType, 27, 28) | 6190 __gen_uint(values->CommandType, 29, 31); 6191 6192 dw[1] = 6193 __gen_uint(values->NumberofMultisamples, 13, 15) | 6194 __gen_uint(values->StencilClearValue, 16, 23) | 6195 __gen_uint(values->FullSurfaceDepthandStencilClear, 25, 25) | 6196 __gen_uint(values->PixelPositionOffsetEnable, 26, 26) | 6197 __gen_uint(values->HierarchicalDepthBufferResolveEnable, 27, 27) | 6198 __gen_uint(values->DepthBufferResolveEnable, 28, 28) | 6199 __gen_uint(values->ScissorRectangleEnable, 29, 29) | 6200 __gen_uint(values->DepthBufferClearEnable, 30, 30) | 6201 __gen_uint(values->StencilBufferClearEnable, 31, 31); 6202 6203 dw[2] = 6204 __gen_uint(values->ClearRectangleXMin, 0, 15) | 6205 __gen_uint(values->ClearRectangleYMin, 16, 31); 6206 6207 dw[3] = 6208 __gen_uint(values->ClearRectangleXMax, 0, 15) | 6209 __gen_uint(values->ClearRectangleYMax, 16, 31); 6210 6211 dw[4] = 6212 __gen_uint(values->SampleMask, 0, 15); 6213} 6214 6215#define GEN8_GPGPU_CSR_BASE_ADDRESS_length 3 6216#define GEN8_GPGPU_CSR_BASE_ADDRESS_length_bias 2 6217#define GEN8_GPGPU_CSR_BASE_ADDRESS_header \ 6218 .DWordLength = 1, \ 6219 ._3DCommandSubOpcode = 4, \ 6220 ._3DCommandOpcode = 1, \ 6221 .CommandSubType = 0, \ 6222 .CommandType = 3 6223 6224struct GEN8_GPGPU_CSR_BASE_ADDRESS { 6225 uint32_t DWordLength; 6226 uint32_t _3DCommandSubOpcode; 6227 uint32_t _3DCommandOpcode; 6228 uint32_t CommandSubType; 6229 uint32_t CommandType; 6230 __gen_address_type GPGPUCSRBaseAddress; 6231}; 6232 6233static inline void 6234GEN8_GPGPU_CSR_BASE_ADDRESS_pack(__attribute__((unused)) __gen_user_data *data, 6235 __attribute__((unused)) void * restrict dst, 6236 __attribute__((unused)) const struct GEN8_GPGPU_CSR_BASE_ADDRESS * restrict values) 6237{ 6238 uint32_t * restrict dw = (uint32_t * restrict) dst; 6239 6240 dw[0] = 6241 __gen_uint(values->DWordLength, 0, 7) | 6242 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 6243 __gen_uint(values->_3DCommandOpcode, 24, 26) | 6244 __gen_uint(values->CommandSubType, 27, 28) | 6245 __gen_uint(values->CommandType, 29, 31); 6246 6247 const uint64_t v1_address = 6248 __gen_combine_address(data, &dw[1], values->GPGPUCSRBaseAddress, 0); 6249 dw[1] = v1_address; 6250 dw[2] = v1_address >> 32; 6251} 6252 6253#define GEN8_GPGPU_WALKER_length 15 6254#define GEN8_GPGPU_WALKER_length_bias 2 6255#define GEN8_GPGPU_WALKER_header \ 6256 .DWordLength = 13, \ 6257 .SubOpcode = 5, \ 6258 .MediaCommandOpcode = 1, \ 6259 .Pipeline = 2, \ 6260 .CommandType = 3 6261 6262struct GEN8_GPGPU_WALKER { 6263 uint32_t DWordLength; 6264 bool PredicateEnable; 6265 bool IndirectParameterEnable; 6266 uint32_t SubOpcode; 6267 uint32_t MediaCommandOpcode; 6268 uint32_t Pipeline; 6269 uint32_t CommandType; 6270 uint32_t InterfaceDescriptorOffset; 6271 uint32_t IndirectDataLength; 6272 uint64_t IndirectDataStartAddress; 6273 uint32_t ThreadWidthCounterMaximum; 6274 uint32_t ThreadHeightCounterMaximum; 6275 uint32_t ThreadDepthCounterMaximum; 6276 uint32_t SIMDSize; 6277#define SIMD8 0 6278#define SIMD16 1 6279#define SIMD32 2 6280 uint32_t ThreadGroupIDStartingX; 6281 uint32_t ThreadGroupIDXDimension; 6282 uint32_t ThreadGroupIDStartingY; 6283 uint32_t ThreadGroupIDYDimension; 6284 uint32_t ThreadGroupIDStartingResumeZ; 6285 uint32_t ThreadGroupIDZDimension; 6286 uint32_t RightExecutionMask; 6287 uint32_t BottomExecutionMask; 6288}; 6289 6290static inline void 6291GEN8_GPGPU_WALKER_pack(__attribute__((unused)) __gen_user_data *data, 6292 __attribute__((unused)) void * restrict dst, 6293 __attribute__((unused)) const struct GEN8_GPGPU_WALKER * restrict values) 6294{ 6295 uint32_t * restrict dw = (uint32_t * restrict) dst; 6296 6297 dw[0] = 6298 __gen_uint(values->DWordLength, 0, 7) | 6299 __gen_uint(values->PredicateEnable, 8, 8) | 6300 __gen_uint(values->IndirectParameterEnable, 10, 10) | 6301 __gen_uint(values->SubOpcode, 16, 23) | 6302 __gen_uint(values->MediaCommandOpcode, 24, 26) | 6303 __gen_uint(values->Pipeline, 27, 28) | 6304 __gen_uint(values->CommandType, 29, 31); 6305 6306 dw[1] = 6307 __gen_uint(values->InterfaceDescriptorOffset, 0, 5); 6308 6309 dw[2] = 6310 __gen_uint(values->IndirectDataLength, 0, 16); 6311 6312 dw[3] = 6313 __gen_offset(values->IndirectDataStartAddress, 6, 31); 6314 6315 dw[4] = 6316 __gen_uint(values->ThreadWidthCounterMaximum, 0, 5) | 6317 __gen_uint(values->ThreadHeightCounterMaximum, 8, 13) | 6318 __gen_uint(values->ThreadDepthCounterMaximum, 16, 21) | 6319 __gen_uint(values->SIMDSize, 30, 31); 6320 6321 dw[5] = 6322 __gen_uint(values->ThreadGroupIDStartingX, 0, 31); 6323 6324 dw[6] = 0; 6325 6326 dw[7] = 6327 __gen_uint(values->ThreadGroupIDXDimension, 0, 31); 6328 6329 dw[8] = 6330 __gen_uint(values->ThreadGroupIDStartingY, 0, 31); 6331 6332 dw[9] = 0; 6333 6334 dw[10] = 6335 __gen_uint(values->ThreadGroupIDYDimension, 0, 31); 6336 6337 dw[11] = 6338 __gen_uint(values->ThreadGroupIDStartingResumeZ, 0, 31); 6339 6340 dw[12] = 6341 __gen_uint(values->ThreadGroupIDZDimension, 0, 31); 6342 6343 dw[13] = 6344 __gen_uint(values->RightExecutionMask, 0, 31); 6345 6346 dw[14] = 6347 __gen_uint(values->BottomExecutionMask, 0, 31); 6348} 6349 6350#define GEN8_MEDIA_CURBE_LOAD_length 4 6351#define GEN8_MEDIA_CURBE_LOAD_length_bias 2 6352#define GEN8_MEDIA_CURBE_LOAD_header \ 6353 .DWordLength = 2, \ 6354 .SubOpcode = 1, \ 6355 .MediaCommandOpcode = 0, \ 6356 .Pipeline = 2, \ 6357 .CommandType = 3 6358 6359struct GEN8_MEDIA_CURBE_LOAD { 6360 uint32_t DWordLength; 6361 uint32_t SubOpcode; 6362 uint32_t MediaCommandOpcode; 6363 uint32_t Pipeline; 6364 uint32_t CommandType; 6365 uint32_t CURBETotalDataLength; 6366 uint32_t CURBEDataStartAddress; 6367}; 6368 6369static inline void 6370GEN8_MEDIA_CURBE_LOAD_pack(__attribute__((unused)) __gen_user_data *data, 6371 __attribute__((unused)) void * restrict dst, 6372 __attribute__((unused)) const struct GEN8_MEDIA_CURBE_LOAD * restrict values) 6373{ 6374 uint32_t * restrict dw = (uint32_t * restrict) dst; 6375 6376 dw[0] = 6377 __gen_uint(values->DWordLength, 0, 15) | 6378 __gen_uint(values->SubOpcode, 16, 23) | 6379 __gen_uint(values->MediaCommandOpcode, 24, 26) | 6380 __gen_uint(values->Pipeline, 27, 28) | 6381 __gen_uint(values->CommandType, 29, 31); 6382 6383 dw[1] = 0; 6384 6385 dw[2] = 6386 __gen_uint(values->CURBETotalDataLength, 0, 16); 6387 6388 dw[3] = 6389 __gen_uint(values->CURBEDataStartAddress, 0, 31); 6390} 6391 6392#define GEN8_MEDIA_INTERFACE_DESCRIPTOR_LOAD_length 4 6393#define GEN8_MEDIA_INTERFACE_DESCRIPTOR_LOAD_length_bias 2 6394#define GEN8_MEDIA_INTERFACE_DESCRIPTOR_LOAD_header\ 6395 .DWordLength = 2, \ 6396 .SubOpcode = 2, \ 6397 .MediaCommandOpcode = 0, \ 6398 .Pipeline = 2, \ 6399 .CommandType = 3 6400 6401struct GEN8_MEDIA_INTERFACE_DESCRIPTOR_LOAD { 6402 uint32_t DWordLength; 6403 uint32_t SubOpcode; 6404 uint32_t MediaCommandOpcode; 6405 uint32_t Pipeline; 6406 uint32_t CommandType; 6407 uint32_t InterfaceDescriptorTotalLength; 6408 uint64_t InterfaceDescriptorDataStartAddress; 6409}; 6410 6411static inline void 6412GEN8_MEDIA_INTERFACE_DESCRIPTOR_LOAD_pack(__attribute__((unused)) __gen_user_data *data, 6413 __attribute__((unused)) void * restrict dst, 6414 __attribute__((unused)) const struct GEN8_MEDIA_INTERFACE_DESCRIPTOR_LOAD * restrict values) 6415{ 6416 uint32_t * restrict dw = (uint32_t * restrict) dst; 6417 6418 dw[0] = 6419 __gen_uint(values->DWordLength, 0, 15) | 6420 __gen_uint(values->SubOpcode, 16, 23) | 6421 __gen_uint(values->MediaCommandOpcode, 24, 26) | 6422 __gen_uint(values->Pipeline, 27, 28) | 6423 __gen_uint(values->CommandType, 29, 31); 6424 6425 dw[1] = 0; 6426 6427 dw[2] = 6428 __gen_uint(values->InterfaceDescriptorTotalLength, 0, 16); 6429 6430 dw[3] = 6431 __gen_offset(values->InterfaceDescriptorDataStartAddress, 0, 31); 6432} 6433 6434#define GEN8_MEDIA_OBJECT_length_bias 2 6435#define GEN8_MEDIA_OBJECT_header \ 6436 .DWordLength = 4, \ 6437 .MediaCommandSubOpcode = 0, \ 6438 .MediaCommandOpcode = 1, \ 6439 .MediaCommandPipeline = 2, \ 6440 .CommandType = 3 6441 6442struct GEN8_MEDIA_OBJECT { 6443 uint32_t DWordLength; 6444 uint32_t MediaCommandSubOpcode; 6445 uint32_t MediaCommandOpcode; 6446 uint32_t MediaCommandPipeline; 6447 uint32_t CommandType; 6448 uint32_t InterfaceDescriptorOffset; 6449 uint32_t IndirectDataLength; 6450 uint32_t SubSliceDestinationSelect; 6451#define SubSlice2 2 6452#define SubSlice1 1 6453#define SubSlice0 0 6454 uint32_t SliceDestinationSelect; 6455#define Slice0 0 6456#define Slice1 1 6457#define Slice2 2 6458 uint32_t UseScoreboard; 6459#define Notusingscoreboard 0 6460#define Usingscoreboard 1 6461 uint32_t ForceDestination; 6462 uint32_t ThreadSynchronization; 6463#define Nothreadsynchronization 0 6464#define Threaddispatchissynchronizedbythespawnrootthreadmessage 1 6465 bool ChildrenPresent; 6466 __gen_address_type IndirectDataStartAddress; 6467 uint32_t ScoreboardX; 6468 uint32_t ScoredboardY; 6469 uint32_t ScoreboardMask; 6470 uint32_t ScoreboardColor; 6471 /* variable length fields follow */ 6472}; 6473 6474static inline void 6475GEN8_MEDIA_OBJECT_pack(__attribute__((unused)) __gen_user_data *data, 6476 __attribute__((unused)) void * restrict dst, 6477 __attribute__((unused)) const struct GEN8_MEDIA_OBJECT * restrict values) 6478{ 6479 uint32_t * restrict dw = (uint32_t * restrict) dst; 6480 6481 dw[0] = 6482 __gen_uint(values->DWordLength, 0, 15) | 6483 __gen_uint(values->MediaCommandSubOpcode, 16, 23) | 6484 __gen_uint(values->MediaCommandOpcode, 24, 26) | 6485 __gen_uint(values->MediaCommandPipeline, 27, 28) | 6486 __gen_uint(values->CommandType, 29, 31); 6487 6488 dw[1] = 6489 __gen_uint(values->InterfaceDescriptorOffset, 0, 5); 6490 6491 dw[2] = 6492 __gen_uint(values->IndirectDataLength, 0, 16) | 6493 __gen_uint(values->SubSliceDestinationSelect, 17, 18) | 6494 __gen_uint(values->SliceDestinationSelect, 19, 20) | 6495 __gen_uint(values->UseScoreboard, 21, 21) | 6496 __gen_uint(values->ForceDestination, 22, 22) | 6497 __gen_uint(values->ThreadSynchronization, 24, 24) | 6498 __gen_uint(values->ChildrenPresent, 31, 31); 6499 6500 dw[3] = __gen_combine_address(data, &dw[3], values->IndirectDataStartAddress, 0); 6501 6502 dw[4] = 6503 __gen_uint(values->ScoreboardX, 0, 8) | 6504 __gen_uint(values->ScoredboardY, 16, 24); 6505 6506 dw[5] = 6507 __gen_uint(values->ScoreboardMask, 0, 7) | 6508 __gen_uint(values->ScoreboardColor, 16, 19); 6509} 6510 6511#define GEN8_MEDIA_OBJECT_GRPID_length_bias 2 6512#define GEN8_MEDIA_OBJECT_GRPID_header \ 6513 .DWordLength = 5, \ 6514 .MediaCommandSubOpcode = 6, \ 6515 .MediaCommandOpcode = 1, \ 6516 .MediaCommandPipeline = 2, \ 6517 .CommandType = 3 6518 6519struct GEN8_MEDIA_OBJECT_GRPID { 6520 uint32_t DWordLength; 6521 uint32_t MediaCommandSubOpcode; 6522 uint32_t MediaCommandOpcode; 6523 uint32_t MediaCommandPipeline; 6524 uint32_t CommandType; 6525 uint32_t InterfaceDescriptorOffset; 6526 uint32_t IndirectDataLength; 6527 uint32_t SubSliceDestinationSelect; 6528#define SubSlice2 2 6529#define SubSlice1 1 6530#define SubSlice0 0 6531 uint32_t SliceDestinationSelect; 6532#define Slice0 0 6533#define Slice1 1 6534#define Slice2 2 6535 uint32_t UseScoreboard; 6536#define Notusingscoreboard 0 6537#define Usingscoreboard 1 6538 uint32_t ForceDestination; 6539 uint32_t EndofThreadGroup; 6540 __gen_address_type IndirectDataStartAddress; 6541 uint32_t ScoreboardX; 6542 uint32_t ScoreboardY; 6543 uint32_t ScoreboardMask; 6544 uint32_t ScoreboardColor; 6545 uint32_t GroupID; 6546 /* variable length fields follow */ 6547}; 6548 6549static inline void 6550GEN8_MEDIA_OBJECT_GRPID_pack(__attribute__((unused)) __gen_user_data *data, 6551 __attribute__((unused)) void * restrict dst, 6552 __attribute__((unused)) const struct GEN8_MEDIA_OBJECT_GRPID * restrict values) 6553{ 6554 uint32_t * restrict dw = (uint32_t * restrict) dst; 6555 6556 dw[0] = 6557 __gen_uint(values->DWordLength, 0, 15) | 6558 __gen_uint(values->MediaCommandSubOpcode, 16, 23) | 6559 __gen_uint(values->MediaCommandOpcode, 24, 26) | 6560 __gen_uint(values->MediaCommandPipeline, 27, 28) | 6561 __gen_uint(values->CommandType, 29, 31); 6562 6563 dw[1] = 6564 __gen_uint(values->InterfaceDescriptorOffset, 0, 5); 6565 6566 dw[2] = 6567 __gen_uint(values->IndirectDataLength, 0, 16) | 6568 __gen_uint(values->SubSliceDestinationSelect, 17, 18) | 6569 __gen_uint(values->SliceDestinationSelect, 19, 20) | 6570 __gen_uint(values->UseScoreboard, 21, 21) | 6571 __gen_uint(values->ForceDestination, 22, 22) | 6572 __gen_uint(values->EndofThreadGroup, 23, 23); 6573 6574 dw[3] = __gen_combine_address(data, &dw[3], values->IndirectDataStartAddress, 0); 6575 6576 dw[4] = 6577 __gen_uint(values->ScoreboardX, 0, 8) | 6578 __gen_uint(values->ScoreboardY, 16, 24); 6579 6580 dw[5] = 6581 __gen_uint(values->ScoreboardMask, 0, 7) | 6582 __gen_uint(values->ScoreboardColor, 16, 19); 6583 6584 dw[6] = 6585 __gen_uint(values->GroupID, 0, 31); 6586} 6587 6588#define GEN8_MEDIA_OBJECT_PRT_length 16 6589#define GEN8_MEDIA_OBJECT_PRT_length_bias 2 6590#define GEN8_MEDIA_OBJECT_PRT_header \ 6591 .DWordLength = 14, \ 6592 .SubOpcode = 2, \ 6593 .MediaCommandOpcode = 1, \ 6594 .Pipeline = 2, \ 6595 .CommandType = 3 6596 6597struct GEN8_MEDIA_OBJECT_PRT { 6598 uint32_t DWordLength; 6599 uint32_t SubOpcode; 6600 uint32_t MediaCommandOpcode; 6601 uint32_t Pipeline; 6602 uint32_t CommandType; 6603 uint32_t InterfaceDescriptorOffset; 6604 uint32_t PRT_FenceType; 6605#define Rootthreadqueue 0 6606#define VFEstateflush 1 6607 bool PRT_FenceNeeded; 6608 bool ChildrenPresent; 6609 uint32_t InlineData[12]; 6610}; 6611 6612static inline void 6613GEN8_MEDIA_OBJECT_PRT_pack(__attribute__((unused)) __gen_user_data *data, 6614 __attribute__((unused)) void * restrict dst, 6615 __attribute__((unused)) const struct GEN8_MEDIA_OBJECT_PRT * restrict values) 6616{ 6617 uint32_t * restrict dw = (uint32_t * restrict) dst; 6618 6619 dw[0] = 6620 __gen_uint(values->DWordLength, 0, 15) | 6621 __gen_uint(values->SubOpcode, 16, 23) | 6622 __gen_uint(values->MediaCommandOpcode, 24, 26) | 6623 __gen_uint(values->Pipeline, 27, 28) | 6624 __gen_uint(values->CommandType, 29, 31); 6625 6626 dw[1] = 6627 __gen_uint(values->InterfaceDescriptorOffset, 0, 5); 6628 6629 dw[2] = 6630 __gen_uint(values->PRT_FenceType, 22, 22) | 6631 __gen_uint(values->PRT_FenceNeeded, 23, 23) | 6632 __gen_uint(values->ChildrenPresent, 31, 31); 6633 6634 dw[3] = 0; 6635 6636 dw[4] = 6637 __gen_uint(values->InlineData[0], 0, 31); 6638 6639 dw[5] = 6640 __gen_uint(values->InlineData[1], 0, 31); 6641 6642 dw[6] = 6643 __gen_uint(values->InlineData[2], 0, 31); 6644 6645 dw[7] = 6646 __gen_uint(values->InlineData[3], 0, 31); 6647 6648 dw[8] = 6649 __gen_uint(values->InlineData[4], 0, 31); 6650 6651 dw[9] = 6652 __gen_uint(values->InlineData[5], 0, 31); 6653 6654 dw[10] = 6655 __gen_uint(values->InlineData[6], 0, 31); 6656 6657 dw[11] = 6658 __gen_uint(values->InlineData[7], 0, 31); 6659 6660 dw[12] = 6661 __gen_uint(values->InlineData[8], 0, 31); 6662 6663 dw[13] = 6664 __gen_uint(values->InlineData[9], 0, 31); 6665 6666 dw[14] = 6667 __gen_uint(values->InlineData[10], 0, 31); 6668 6669 dw[15] = 6670 __gen_uint(values->InlineData[11], 0, 31); 6671} 6672 6673#define GEN8_MEDIA_OBJECT_WALKER_length_bias 2 6674#define GEN8_MEDIA_OBJECT_WALKER_header \ 6675 .DWordLength = 15, \ 6676 .SubOpcode = 3, \ 6677 .MediaCommandOpcode = 1, \ 6678 .Pipeline = 2, \ 6679 .CommandType = 3 6680 6681struct GEN8_MEDIA_OBJECT_WALKER { 6682 uint32_t DWordLength; 6683 uint32_t SubOpcode; 6684 uint32_t MediaCommandOpcode; 6685 uint32_t Pipeline; 6686 uint32_t CommandType; 6687 uint32_t InterfaceDescriptorOffset; 6688 uint32_t IndirectDataLength; 6689 uint32_t UseScoreboard; 6690#define Notusingscoreboard 0 6691#define Usingscoreboard 1 6692 uint32_t ThreadSynchronization; 6693#define Nothreadsynchronization 0 6694#define Threaddispatchissynchronizedbythespawnrootthreadmessage 1 6695 uint32_t ChildrenPresent; 6696 uint64_t IndirectDataStartAddress; 6697 uint32_t ScoreboardMask; 6698 uint32_t GroupIDLoopSelect; 6699 int32_t MidLoopUnitX; 6700 int32_t LocalMidLoopUnitY; 6701 uint32_t MiddleLoopExtraSteps; 6702 uint32_t ColorCountMinusOne; 6703 uint32_t LocalLoopExecCount; 6704 uint32_t GlobalLoopExecCount; 6705 uint32_t BlockResolutionX; 6706 uint32_t BlockResolutionY; 6707 uint32_t LocalStartX; 6708 uint32_t LocalStartY; 6709 int32_t LocalOuterLoopStrideX; 6710 int32_t LocalOuterLoopStrideY; 6711 int32_t LocalInnerLoopUnitX; 6712 int32_t LocalInnerLoopUnitY; 6713 uint32_t GlobalResolutionX; 6714 uint32_t GlobalResolutionY; 6715 int32_t GlobalStartX; 6716 int32_t GlobalStartY; 6717 int32_t GlobalOuterLoopStrideX; 6718 int32_t GlobalOuterLoopStrideY; 6719 int32_t GlobalInnerLoopUnitX; 6720 int32_t GlobalInnerLoopUnitY; 6721 /* variable length fields follow */ 6722}; 6723 6724static inline void 6725GEN8_MEDIA_OBJECT_WALKER_pack(__attribute__((unused)) __gen_user_data *data, 6726 __attribute__((unused)) void * restrict dst, 6727 __attribute__((unused)) const struct GEN8_MEDIA_OBJECT_WALKER * restrict values) 6728{ 6729 uint32_t * restrict dw = (uint32_t * restrict) dst; 6730 6731 dw[0] = 6732 __gen_uint(values->DWordLength, 0, 15) | 6733 __gen_uint(values->SubOpcode, 16, 23) | 6734 __gen_uint(values->MediaCommandOpcode, 24, 26) | 6735 __gen_uint(values->Pipeline, 27, 28) | 6736 __gen_uint(values->CommandType, 29, 31); 6737 6738 dw[1] = 6739 __gen_uint(values->InterfaceDescriptorOffset, 0, 5); 6740 6741 dw[2] = 6742 __gen_uint(values->IndirectDataLength, 0, 16) | 6743 __gen_uint(values->UseScoreboard, 21, 21) | 6744 __gen_uint(values->ThreadSynchronization, 24, 24) | 6745 __gen_uint(values->ChildrenPresent, 31, 31); 6746 6747 dw[3] = 6748 __gen_offset(values->IndirectDataStartAddress, 0, 31); 6749 6750 dw[4] = 0; 6751 6752 dw[5] = 6753 __gen_uint(values->ScoreboardMask, 0, 7) | 6754 __gen_uint(values->GroupIDLoopSelect, 8, 31); 6755 6756 dw[6] = 6757 __gen_sint(values->MidLoopUnitX, 8, 9) | 6758 __gen_sint(values->LocalMidLoopUnitY, 12, 13) | 6759 __gen_uint(values->MiddleLoopExtraSteps, 16, 20) | 6760 __gen_uint(values->ColorCountMinusOne, 24, 27); 6761 6762 dw[7] = 6763 __gen_uint(values->LocalLoopExecCount, 0, 9) | 6764 __gen_uint(values->GlobalLoopExecCount, 16, 25); 6765 6766 dw[8] = 6767 __gen_uint(values->BlockResolutionX, 0, 8) | 6768 __gen_uint(values->BlockResolutionY, 16, 24); 6769 6770 dw[9] = 6771 __gen_uint(values->LocalStartX, 0, 8) | 6772 __gen_uint(values->LocalStartY, 16, 24); 6773 6774 dw[10] = 0; 6775 6776 dw[11] = 6777 __gen_sint(values->LocalOuterLoopStrideX, 0, 9) | 6778 __gen_sint(values->LocalOuterLoopStrideY, 16, 25); 6779 6780 dw[12] = 6781 __gen_sint(values->LocalInnerLoopUnitX, 0, 9) | 6782 __gen_sint(values->LocalInnerLoopUnitY, 16, 25); 6783 6784 dw[13] = 6785 __gen_uint(values->GlobalResolutionX, 0, 8) | 6786 __gen_uint(values->GlobalResolutionY, 16, 24); 6787 6788 dw[14] = 6789 __gen_sint(values->GlobalStartX, 0, 9) | 6790 __gen_sint(values->GlobalStartY, 16, 25); 6791 6792 dw[15] = 6793 __gen_sint(values->GlobalOuterLoopStrideX, 0, 9) | 6794 __gen_sint(values->GlobalOuterLoopStrideY, 16, 25); 6795 6796 dw[16] = 6797 __gen_sint(values->GlobalInnerLoopUnitX, 0, 9) | 6798 __gen_sint(values->GlobalInnerLoopUnitY, 16, 25); 6799} 6800 6801#define GEN8_MEDIA_STATE_FLUSH_length 2 6802#define GEN8_MEDIA_STATE_FLUSH_length_bias 2 6803#define GEN8_MEDIA_STATE_FLUSH_header \ 6804 .DWordLength = 0, \ 6805 .SubOpcode = 4, \ 6806 .MediaCommandOpcode = 0, \ 6807 .Pipeline = 2, \ 6808 .CommandType = 3 6809 6810struct GEN8_MEDIA_STATE_FLUSH { 6811 uint32_t DWordLength; 6812 uint32_t SubOpcode; 6813 uint32_t MediaCommandOpcode; 6814 uint32_t Pipeline; 6815 uint32_t CommandType; 6816 uint32_t InterfaceDescriptorOffset; 6817 uint32_t WatermarkRequired; 6818 bool FlushtoGO; 6819}; 6820 6821static inline void 6822GEN8_MEDIA_STATE_FLUSH_pack(__attribute__((unused)) __gen_user_data *data, 6823 __attribute__((unused)) void * restrict dst, 6824 __attribute__((unused)) const struct GEN8_MEDIA_STATE_FLUSH * restrict values) 6825{ 6826 uint32_t * restrict dw = (uint32_t * restrict) dst; 6827 6828 dw[0] = 6829 __gen_uint(values->DWordLength, 0, 15) | 6830 __gen_uint(values->SubOpcode, 16, 23) | 6831 __gen_uint(values->MediaCommandOpcode, 24, 26) | 6832 __gen_uint(values->Pipeline, 27, 28) | 6833 __gen_uint(values->CommandType, 29, 31); 6834 6835 dw[1] = 6836 __gen_uint(values->InterfaceDescriptorOffset, 0, 5) | 6837 __gen_uint(values->WatermarkRequired, 6, 6) | 6838 __gen_uint(values->FlushtoGO, 7, 7); 6839} 6840 6841#define GEN8_MEDIA_VFE_STATE_length 9 6842#define GEN8_MEDIA_VFE_STATE_length_bias 2 6843#define GEN8_MEDIA_VFE_STATE_header \ 6844 .DWordLength = 7, \ 6845 .SubOpcode = 0, \ 6846 .MediaCommandOpcode = 0, \ 6847 .Pipeline = 2, \ 6848 .CommandType = 3 6849 6850struct GEN8_MEDIA_VFE_STATE { 6851 uint32_t DWordLength; 6852 uint32_t SubOpcode; 6853 uint32_t MediaCommandOpcode; 6854 uint32_t Pipeline; 6855 uint32_t CommandType; 6856 uint32_t PerThreadScratchSpace; 6857 uint32_t StackSize; 6858 __gen_address_type ScratchSpaceBasePointer; 6859 uint32_t BypassGatewayControl; 6860#define MaintainingOpenGatewayForwardMsgCloseGatewayprotocollegacymode 0 6861#define BypassingOpenGatewayCloseGatewayprotocol 1 6862 uint32_t ResetGatewayTimer; 6863#define Maintainingtheexistingtimestampstate 0 6864#define Resettingrelativetimerandlatchingtheglobaltimestamp 1 6865 uint32_t NumberofURBEntries; 6866 uint32_t MaximumNumberofThreads; 6867 uint32_t SliceDisable; 6868#define AllSubslicesEnabled 0 6869#define OnlySlice0Enabled 1 6870#define OnlySlice0Subslice0Enabled 3 6871 uint32_t CURBEAllocationSize; 6872 uint32_t URBEntryAllocationSize; 6873 uint32_t ScoreboardMask; 6874 uint32_t ScoreboardType; 6875#define StallingScoreboard 0 6876#define NonStallingScoreboard 1 6877 bool ScoreboardEnable; 6878 int32_t Scoreboard0DeltaX; 6879 int32_t Scoreboard0DeltaY; 6880 int32_t Scoreboard1DeltaX; 6881 int32_t Scoreboard1DeltaY; 6882 int32_t Scoreboard2DeltaX; 6883 int32_t Scoreboard2DeltaY; 6884 int32_t Scoreboard3DeltaX; 6885 int32_t Scoreboard3DeltaY; 6886 int32_t Scoreboard4DeltaX; 6887 int32_t Scoreboard4DeltaY; 6888 int32_t Scoreboard5DeltaX; 6889 int32_t Scoreboard5DeltaY; 6890 int32_t Scoreboard6DeltaX; 6891 int32_t Scoreboard6DeltaY; 6892 int32_t Scoreboard7DeltaX; 6893 int32_t Scoreboard7DeltaY; 6894}; 6895 6896static inline void 6897GEN8_MEDIA_VFE_STATE_pack(__attribute__((unused)) __gen_user_data *data, 6898 __attribute__((unused)) void * restrict dst, 6899 __attribute__((unused)) const struct GEN8_MEDIA_VFE_STATE * restrict values) 6900{ 6901 uint32_t * restrict dw = (uint32_t * restrict) dst; 6902 6903 dw[0] = 6904 __gen_uint(values->DWordLength, 0, 15) | 6905 __gen_uint(values->SubOpcode, 16, 23) | 6906 __gen_uint(values->MediaCommandOpcode, 24, 26) | 6907 __gen_uint(values->Pipeline, 27, 28) | 6908 __gen_uint(values->CommandType, 29, 31); 6909 6910 const uint64_t v1 = 6911 __gen_uint(values->PerThreadScratchSpace, 0, 3) | 6912 __gen_uint(values->StackSize, 4, 7); 6913 const uint64_t v1_address = 6914 __gen_combine_address(data, &dw[1], values->ScratchSpaceBasePointer, v1); 6915 dw[1] = v1_address; 6916 dw[2] = (v1_address >> 32) | (v1 >> 32); 6917 6918 dw[3] = 6919 __gen_uint(values->BypassGatewayControl, 6, 6) | 6920 __gen_uint(values->ResetGatewayTimer, 7, 7) | 6921 __gen_uint(values->NumberofURBEntries, 8, 15) | 6922 __gen_uint(values->MaximumNumberofThreads, 16, 31); 6923 6924 dw[4] = 6925 __gen_uint(values->SliceDisable, 0, 1); 6926 6927 dw[5] = 6928 __gen_uint(values->CURBEAllocationSize, 0, 15) | 6929 __gen_uint(values->URBEntryAllocationSize, 16, 31); 6930 6931 dw[6] = 6932 __gen_uint(values->ScoreboardMask, 0, 7) | 6933 __gen_uint(values->ScoreboardType, 30, 30) | 6934 __gen_uint(values->ScoreboardEnable, 31, 31); 6935 6936 dw[7] = 6937 __gen_sint(values->Scoreboard0DeltaX, 0, 3) | 6938 __gen_sint(values->Scoreboard0DeltaY, 4, 7) | 6939 __gen_sint(values->Scoreboard1DeltaX, 8, 11) | 6940 __gen_sint(values->Scoreboard1DeltaY, 12, 15) | 6941 __gen_sint(values->Scoreboard2DeltaX, 16, 19) | 6942 __gen_sint(values->Scoreboard2DeltaY, 20, 23) | 6943 __gen_sint(values->Scoreboard3DeltaX, 24, 27) | 6944 __gen_sint(values->Scoreboard3DeltaY, 28, 31); 6945 6946 dw[8] = 6947 __gen_sint(values->Scoreboard4DeltaX, 0, 3) | 6948 __gen_sint(values->Scoreboard4DeltaY, 4, 7) | 6949 __gen_sint(values->Scoreboard5DeltaX, 8, 11) | 6950 __gen_sint(values->Scoreboard5DeltaY, 12, 15) | 6951 __gen_sint(values->Scoreboard6DeltaX, 16, 19) | 6952 __gen_sint(values->Scoreboard6DeltaY, 20, 23) | 6953 __gen_sint(values->Scoreboard7DeltaX, 24, 27) | 6954 __gen_sint(values->Scoreboard7DeltaY, 28, 31); 6955} 6956 6957#define GEN8_MI_ARB_CHECK_length 1 6958#define GEN8_MI_ARB_CHECK_length_bias 1 6959#define GEN8_MI_ARB_CHECK_header \ 6960 .MICommandOpcode = 5, \ 6961 .CommandType = 0 6962 6963struct GEN8_MI_ARB_CHECK { 6964 uint32_t MICommandOpcode; 6965 uint32_t CommandType; 6966}; 6967 6968static inline void 6969GEN8_MI_ARB_CHECK_pack(__attribute__((unused)) __gen_user_data *data, 6970 __attribute__((unused)) void * restrict dst, 6971 __attribute__((unused)) const struct GEN8_MI_ARB_CHECK * restrict values) 6972{ 6973 uint32_t * restrict dw = (uint32_t * restrict) dst; 6974 6975 dw[0] = 6976 __gen_uint(values->MICommandOpcode, 23, 28) | 6977 __gen_uint(values->CommandType, 29, 31); 6978} 6979 6980#define GEN8_MI_ARB_ON_OFF_length 1 6981#define GEN8_MI_ARB_ON_OFF_length_bias 1 6982#define GEN8_MI_ARB_ON_OFF_header \ 6983 .ArbitrationEnable = 1, \ 6984 .MICommandOpcode = 8, \ 6985 .CommandType = 0 6986 6987struct GEN8_MI_ARB_ON_OFF { 6988 bool ArbitrationEnable; 6989 uint32_t MICommandOpcode; 6990 uint32_t CommandType; 6991}; 6992 6993static inline void 6994GEN8_MI_ARB_ON_OFF_pack(__attribute__((unused)) __gen_user_data *data, 6995 __attribute__((unused)) void * restrict dst, 6996 __attribute__((unused)) const struct GEN8_MI_ARB_ON_OFF * restrict values) 6997{ 6998 uint32_t * restrict dw = (uint32_t * restrict) dst; 6999 7000 dw[0] = 7001 __gen_uint(values->ArbitrationEnable, 0, 0) | 7002 __gen_uint(values->MICommandOpcode, 23, 28) | 7003 __gen_uint(values->CommandType, 29, 31); 7004} 7005 7006#define GEN8_MI_ATOMIC_length 3 7007#define GEN8_MI_ATOMIC_length_bias 2 7008#define GEN8_MI_ATOMIC_header \ 7009 .DWordLength = 1, \ 7010 .MICommandOpcode = 47, \ 7011 .CommandType = 0 7012 7013struct GEN8_MI_ATOMIC { 7014 uint32_t DWordLength; 7015 uint32_t ATOMICOPCODE; 7016 uint32_t ReturnDataControl; 7017 uint32_t CSSTALL; 7018 uint32_t InlineData; 7019 uint32_t DataSize; 7020#define DWORD 0 7021#define QWORD 1 7022#define OCTWORD 2 7023#define RESERVED 3 7024 bool PostSyncOperation; 7025 uint32_t MemoryType; 7026#define PerProcessGraphicsAddress 0 7027#define GlobalGraphicsAddress 1 7028 uint32_t MICommandOpcode; 7029 uint32_t CommandType; 7030 __gen_address_type MemoryAddress; 7031 uint32_t Operand1DataDword0; 7032 uint32_t Operand2DataDword0; 7033 uint32_t Operand1DataDword1; 7034 uint32_t Operand2DataDword1; 7035 uint32_t Operand1DataDword2; 7036 uint32_t Operand2DataDword2; 7037 uint32_t Operand1DataDword3; 7038 uint32_t Operand2DataDword3; 7039}; 7040 7041static inline void 7042GEN8_MI_ATOMIC_pack(__attribute__((unused)) __gen_user_data *data, 7043 __attribute__((unused)) void * restrict dst, 7044 __attribute__((unused)) const struct GEN8_MI_ATOMIC * restrict values) 7045{ 7046 uint32_t * restrict dw = (uint32_t * restrict) dst; 7047 7048 dw[0] = 7049 __gen_uint(values->DWordLength, 0, 7) | 7050 __gen_uint(values->ATOMICOPCODE, 8, 15) | 7051 __gen_uint(values->ReturnDataControl, 16, 16) | 7052 __gen_uint(values->CSSTALL, 17, 17) | 7053 __gen_uint(values->InlineData, 18, 18) | 7054 __gen_uint(values->DataSize, 19, 20) | 7055 __gen_uint(values->PostSyncOperation, 21, 21) | 7056 __gen_uint(values->MemoryType, 22, 22) | 7057 __gen_uint(values->MICommandOpcode, 23, 28) | 7058 __gen_uint(values->CommandType, 29, 31); 7059 7060 const uint64_t v1_address = 7061 __gen_combine_address(data, &dw[1], values->MemoryAddress, 0); 7062 dw[1] = v1_address; 7063 dw[2] = v1_address >> 32; 7064} 7065 7066#define GEN8_MI_BATCH_BUFFER_END_length 1 7067#define GEN8_MI_BATCH_BUFFER_END_length_bias 1 7068#define GEN8_MI_BATCH_BUFFER_END_header \ 7069 .MICommandOpcode = 10, \ 7070 .CommandType = 0 7071 7072struct GEN8_MI_BATCH_BUFFER_END { 7073 uint32_t MICommandOpcode; 7074 uint32_t CommandType; 7075}; 7076 7077static inline void 7078GEN8_MI_BATCH_BUFFER_END_pack(__attribute__((unused)) __gen_user_data *data, 7079 __attribute__((unused)) void * restrict dst, 7080 __attribute__((unused)) const struct GEN8_MI_BATCH_BUFFER_END * restrict values) 7081{ 7082 uint32_t * restrict dw = (uint32_t * restrict) dst; 7083 7084 dw[0] = 7085 __gen_uint(values->MICommandOpcode, 23, 28) | 7086 __gen_uint(values->CommandType, 29, 31); 7087} 7088 7089#define GEN8_MI_BATCH_BUFFER_START_length 3 7090#define GEN8_MI_BATCH_BUFFER_START_length_bias 2 7091#define GEN8_MI_BATCH_BUFFER_START_header \ 7092 .DWordLength = 1, \ 7093 .MICommandOpcode = 49, \ 7094 .CommandType = 0 7095 7096struct GEN8_MI_BATCH_BUFFER_START { 7097 uint32_t DWordLength; 7098 uint32_t AddressSpaceIndicator; 7099#define ASI_GGTT 0 7100#define ASI_PPGTT 1 7101 bool ResourceStreamerEnable; 7102 bool PredicationEnable; 7103 bool AddOffsetEnable; 7104 uint32_t SecondLevelBatchBuffer; 7105#define Firstlevelbatch 0 7106#define Secondlevelbatch 1 7107 uint32_t MICommandOpcode; 7108 uint32_t CommandType; 7109 __gen_address_type BatchBufferStartAddress; 7110}; 7111 7112static inline void 7113GEN8_MI_BATCH_BUFFER_START_pack(__attribute__((unused)) __gen_user_data *data, 7114 __attribute__((unused)) void * restrict dst, 7115 __attribute__((unused)) const struct GEN8_MI_BATCH_BUFFER_START * restrict values) 7116{ 7117 uint32_t * restrict dw = (uint32_t * restrict) dst; 7118 7119 dw[0] = 7120 __gen_uint(values->DWordLength, 0, 7) | 7121 __gen_uint(values->AddressSpaceIndicator, 8, 8) | 7122 __gen_uint(values->ResourceStreamerEnable, 10, 10) | 7123 __gen_uint(values->PredicationEnable, 15, 15) | 7124 __gen_uint(values->AddOffsetEnable, 16, 16) | 7125 __gen_uint(values->SecondLevelBatchBuffer, 22, 22) | 7126 __gen_uint(values->MICommandOpcode, 23, 28) | 7127 __gen_uint(values->CommandType, 29, 31); 7128 7129 const uint64_t v1_address = 7130 __gen_combine_address(data, &dw[1], values->BatchBufferStartAddress, 0); 7131 dw[1] = v1_address; 7132 dw[2] = v1_address >> 32; 7133} 7134 7135#define GEN8_MI_CLFLUSH_length_bias 2 7136#define GEN8_MI_CLFLUSH_header \ 7137 .DWordLength = 1, \ 7138 .MICommandOpcode = 39, \ 7139 .CommandType = 0 7140 7141struct GEN8_MI_CLFLUSH { 7142 uint32_t DWordLength; 7143 bool UseGlobalGTT; 7144 uint32_t MICommandOpcode; 7145 uint32_t CommandType; 7146 uint32_t StartingCachelineOffset; 7147 __gen_address_type PageBaseAddress; 7148 /* variable length fields follow */ 7149}; 7150 7151static inline void 7152GEN8_MI_CLFLUSH_pack(__attribute__((unused)) __gen_user_data *data, 7153 __attribute__((unused)) void * restrict dst, 7154 __attribute__((unused)) const struct GEN8_MI_CLFLUSH * restrict values) 7155{ 7156 uint32_t * restrict dw = (uint32_t * restrict) dst; 7157 7158 dw[0] = 7159 __gen_uint(values->DWordLength, 0, 9) | 7160 __gen_uint(values->UseGlobalGTT, 22, 22) | 7161 __gen_uint(values->MICommandOpcode, 23, 28) | 7162 __gen_uint(values->CommandType, 29, 31); 7163 7164 const uint64_t v1 = 7165 __gen_uint(values->StartingCachelineOffset, 6, 11); 7166 const uint64_t v1_address = 7167 __gen_combine_address(data, &dw[1], values->PageBaseAddress, v1); 7168 dw[1] = v1_address; 7169 dw[2] = (v1_address >> 32) | (v1 >> 32); 7170} 7171 7172#define GEN8_MI_CONDITIONAL_BATCH_BUFFER_END_length 3 7173#define GEN8_MI_CONDITIONAL_BATCH_BUFFER_END_length_bias 2 7174#define GEN8_MI_CONDITIONAL_BATCH_BUFFER_END_header\ 7175 .DWordLength = 1, \ 7176 .CompareSemaphore = 0, \ 7177 .MICommandOpcode = 54, \ 7178 .CommandType = 0 7179 7180struct GEN8_MI_CONDITIONAL_BATCH_BUFFER_END { 7181 uint32_t DWordLength; 7182 uint32_t CompareSemaphore; 7183 bool UseGlobalGTT; 7184 uint32_t MICommandOpcode; 7185 uint32_t CommandType; 7186 uint32_t CompareDataDword; 7187 __gen_address_type CompareAddress; 7188}; 7189 7190static inline void 7191GEN8_MI_CONDITIONAL_BATCH_BUFFER_END_pack(__attribute__((unused)) __gen_user_data *data, 7192 __attribute__((unused)) void * restrict dst, 7193 __attribute__((unused)) const struct GEN8_MI_CONDITIONAL_BATCH_BUFFER_END * restrict values) 7194{ 7195 uint32_t * restrict dw = (uint32_t * restrict) dst; 7196 7197 dw[0] = 7198 __gen_uint(values->DWordLength, 0, 7) | 7199 __gen_uint(values->CompareSemaphore, 21, 21) | 7200 __gen_uint(values->UseGlobalGTT, 22, 22) | 7201 __gen_uint(values->MICommandOpcode, 23, 28) | 7202 __gen_uint(values->CommandType, 29, 31); 7203 7204 dw[1] = 7205 __gen_uint(values->CompareDataDword, 0, 31); 7206 7207 const uint64_t v2_address = 7208 __gen_combine_address(data, &dw[2], values->CompareAddress, 0); 7209 dw[2] = v2_address; 7210 dw[3] = v2_address >> 32; 7211} 7212 7213#define GEN8_MI_COPY_MEM_MEM_length 5 7214#define GEN8_MI_COPY_MEM_MEM_length_bias 2 7215#define GEN8_MI_COPY_MEM_MEM_header \ 7216 .DWordLength = 3, \ 7217 .MICommandOpcode = 46, \ 7218 .CommandType = 0 7219 7220struct GEN8_MI_COPY_MEM_MEM { 7221 uint32_t DWordLength; 7222 bool UseGlobalGTTDestination; 7223 bool UseGlobalGTTSource; 7224 uint32_t MICommandOpcode; 7225 uint32_t CommandType; 7226 __gen_address_type DestinationMemoryAddress; 7227 __gen_address_type SourceMemoryAddress; 7228}; 7229 7230static inline void 7231GEN8_MI_COPY_MEM_MEM_pack(__attribute__((unused)) __gen_user_data *data, 7232 __attribute__((unused)) void * restrict dst, 7233 __attribute__((unused)) const struct GEN8_MI_COPY_MEM_MEM * restrict values) 7234{ 7235 uint32_t * restrict dw = (uint32_t * restrict) dst; 7236 7237 dw[0] = 7238 __gen_uint(values->DWordLength, 0, 7) | 7239 __gen_uint(values->UseGlobalGTTDestination, 21, 21) | 7240 __gen_uint(values->UseGlobalGTTSource, 22, 22) | 7241 __gen_uint(values->MICommandOpcode, 23, 28) | 7242 __gen_uint(values->CommandType, 29, 31); 7243 7244 const uint64_t v1_address = 7245 __gen_combine_address(data, &dw[1], values->DestinationMemoryAddress, 0); 7246 dw[1] = v1_address; 7247 dw[2] = v1_address >> 32; 7248 7249 const uint64_t v3_address = 7250 __gen_combine_address(data, &dw[3], values->SourceMemoryAddress, 0); 7251 dw[3] = v3_address; 7252 dw[4] = v3_address >> 32; 7253} 7254 7255#define GEN8_MI_LOAD_REGISTER_IMM_length 3 7256#define GEN8_MI_LOAD_REGISTER_IMM_length_bias 2 7257#define GEN8_MI_LOAD_REGISTER_IMM_header \ 7258 .DWordLength = 1, \ 7259 .MICommandOpcode = 34, \ 7260 .CommandType = 0 7261 7262struct GEN8_MI_LOAD_REGISTER_IMM { 7263 uint32_t DWordLength; 7264 uint32_t ByteWriteDisables; 7265 uint32_t MICommandOpcode; 7266 uint32_t CommandType; 7267 uint64_t RegisterOffset; 7268 uint32_t DataDWord; 7269 /* variable length fields follow */ 7270}; 7271 7272static inline void 7273GEN8_MI_LOAD_REGISTER_IMM_pack(__attribute__((unused)) __gen_user_data *data, 7274 __attribute__((unused)) void * restrict dst, 7275 __attribute__((unused)) const struct GEN8_MI_LOAD_REGISTER_IMM * restrict values) 7276{ 7277 uint32_t * restrict dw = (uint32_t * restrict) dst; 7278 7279 dw[0] = 7280 __gen_uint(values->DWordLength, 0, 7) | 7281 __gen_uint(values->ByteWriteDisables, 8, 11) | 7282 __gen_uint(values->MICommandOpcode, 23, 28) | 7283 __gen_uint(values->CommandType, 29, 31); 7284 7285 dw[1] = 7286 __gen_offset(values->RegisterOffset, 2, 22); 7287 7288 dw[2] = 7289 __gen_uint(values->DataDWord, 0, 31); 7290} 7291 7292#define GEN8_MI_LOAD_REGISTER_MEM_length 4 7293#define GEN8_MI_LOAD_REGISTER_MEM_length_bias 2 7294#define GEN8_MI_LOAD_REGISTER_MEM_header \ 7295 .DWordLength = 2, \ 7296 .MICommandOpcode = 41, \ 7297 .CommandType = 0 7298 7299struct GEN8_MI_LOAD_REGISTER_MEM { 7300 uint32_t DWordLength; 7301 bool AsyncModeEnable; 7302 bool UseGlobalGTT; 7303 uint32_t MICommandOpcode; 7304 uint32_t CommandType; 7305 uint64_t RegisterAddress; 7306 __gen_address_type MemoryAddress; 7307}; 7308 7309static inline void 7310GEN8_MI_LOAD_REGISTER_MEM_pack(__attribute__((unused)) __gen_user_data *data, 7311 __attribute__((unused)) void * restrict dst, 7312 __attribute__((unused)) const struct GEN8_MI_LOAD_REGISTER_MEM * restrict values) 7313{ 7314 uint32_t * restrict dw = (uint32_t * restrict) dst; 7315 7316 dw[0] = 7317 __gen_uint(values->DWordLength, 0, 7) | 7318 __gen_uint(values->AsyncModeEnable, 21, 21) | 7319 __gen_uint(values->UseGlobalGTT, 22, 22) | 7320 __gen_uint(values->MICommandOpcode, 23, 28) | 7321 __gen_uint(values->CommandType, 29, 31); 7322 7323 dw[1] = 7324 __gen_offset(values->RegisterAddress, 2, 22); 7325 7326 const uint64_t v2_address = 7327 __gen_combine_address(data, &dw[2], values->MemoryAddress, 0); 7328 dw[2] = v2_address; 7329 dw[3] = v2_address >> 32; 7330} 7331 7332#define GEN8_MI_LOAD_REGISTER_REG_length 3 7333#define GEN8_MI_LOAD_REGISTER_REG_length_bias 2 7334#define GEN8_MI_LOAD_REGISTER_REG_header \ 7335 .DWordLength = 1, \ 7336 .MICommandOpcode = 42, \ 7337 .CommandType = 0 7338 7339struct GEN8_MI_LOAD_REGISTER_REG { 7340 uint32_t DWordLength; 7341 uint32_t MICommandOpcode; 7342 uint32_t CommandType; 7343 uint64_t SourceRegisterAddress; 7344 uint64_t DestinationRegisterAddress; 7345}; 7346 7347static inline void 7348GEN8_MI_LOAD_REGISTER_REG_pack(__attribute__((unused)) __gen_user_data *data, 7349 __attribute__((unused)) void * restrict dst, 7350 __attribute__((unused)) const struct GEN8_MI_LOAD_REGISTER_REG * restrict values) 7351{ 7352 uint32_t * restrict dw = (uint32_t * restrict) dst; 7353 7354 dw[0] = 7355 __gen_uint(values->DWordLength, 0, 7) | 7356 __gen_uint(values->MICommandOpcode, 23, 28) | 7357 __gen_uint(values->CommandType, 29, 31); 7358 7359 dw[1] = 7360 __gen_offset(values->SourceRegisterAddress, 2, 22); 7361 7362 dw[2] = 7363 __gen_offset(values->DestinationRegisterAddress, 2, 22); 7364} 7365 7366#define GEN8_MI_LOAD_SCAN_LINES_EXCL_length 2 7367#define GEN8_MI_LOAD_SCAN_LINES_EXCL_length_bias 2 7368#define GEN8_MI_LOAD_SCAN_LINES_EXCL_header \ 7369 .DWordLength = 0, \ 7370 .MICommandOpcode = 19, \ 7371 .CommandType = 0 7372 7373struct GEN8_MI_LOAD_SCAN_LINES_EXCL { 7374 uint32_t DWordLength; 7375 uint32_t DisplayPlaneSelect; 7376#define DisplayPlaneA 0 7377#define DisplayPlaneB 1 7378#define DisplayPlaneC 4 7379 uint32_t MICommandOpcode; 7380 uint32_t CommandType; 7381 uint32_t EndScanLineNumber; 7382 uint32_t StartScanLineNumber; 7383}; 7384 7385static inline void 7386GEN8_MI_LOAD_SCAN_LINES_EXCL_pack(__attribute__((unused)) __gen_user_data *data, 7387 __attribute__((unused)) void * restrict dst, 7388 __attribute__((unused)) const struct GEN8_MI_LOAD_SCAN_LINES_EXCL * restrict values) 7389{ 7390 uint32_t * restrict dw = (uint32_t * restrict) dst; 7391 7392 dw[0] = 7393 __gen_uint(values->DWordLength, 0, 5) | 7394 __gen_uint(values->DisplayPlaneSelect, 19, 21) | 7395 __gen_uint(values->MICommandOpcode, 23, 28) | 7396 __gen_uint(values->CommandType, 29, 31); 7397 7398 dw[1] = 7399 __gen_uint(values->EndScanLineNumber, 0, 12) | 7400 __gen_uint(values->StartScanLineNumber, 16, 28); 7401} 7402 7403#define GEN8_MI_LOAD_SCAN_LINES_INCL_length 2 7404#define GEN8_MI_LOAD_SCAN_LINES_INCL_length_bias 2 7405#define GEN8_MI_LOAD_SCAN_LINES_INCL_header \ 7406 .DWordLength = 0, \ 7407 .MICommandOpcode = 18, \ 7408 .CommandType = 0 7409 7410struct GEN8_MI_LOAD_SCAN_LINES_INCL { 7411 uint32_t DWordLength; 7412 uint32_t ScanLineEventDoneForward; 7413 uint32_t DisplayPlaneSelect; 7414#define DisplayPlaneA 0 7415#define DisplayPlaneB 1 7416#define DisplayPlaneC 4 7417 uint32_t MICommandOpcode; 7418 uint32_t CommandType; 7419 uint32_t EndScanLineNumber; 7420 uint32_t StartScanLineNumber; 7421}; 7422 7423static inline void 7424GEN8_MI_LOAD_SCAN_LINES_INCL_pack(__attribute__((unused)) __gen_user_data *data, 7425 __attribute__((unused)) void * restrict dst, 7426 __attribute__((unused)) const struct GEN8_MI_LOAD_SCAN_LINES_INCL * restrict values) 7427{ 7428 uint32_t * restrict dw = (uint32_t * restrict) dst; 7429 7430 dw[0] = 7431 __gen_uint(values->DWordLength, 0, 5) | 7432 __gen_uint(values->ScanLineEventDoneForward, 17, 18) | 7433 __gen_uint(values->DisplayPlaneSelect, 19, 21) | 7434 __gen_uint(values->MICommandOpcode, 23, 28) | 7435 __gen_uint(values->CommandType, 29, 31); 7436 7437 dw[1] = 7438 __gen_uint(values->EndScanLineNumber, 0, 12) | 7439 __gen_uint(values->StartScanLineNumber, 16, 28); 7440} 7441 7442#define GEN8_MI_LOAD_URB_MEM_length 4 7443#define GEN8_MI_LOAD_URB_MEM_length_bias 2 7444#define GEN8_MI_LOAD_URB_MEM_header \ 7445 .DWordLength = 2, \ 7446 .MICommandOpcode = 44, \ 7447 .CommandType = 0 7448 7449struct GEN8_MI_LOAD_URB_MEM { 7450 uint32_t DWordLength; 7451 uint32_t MICommandOpcode; 7452 uint32_t CommandType; 7453 uint32_t URBAddress; 7454 __gen_address_type MemoryAddress; 7455}; 7456 7457static inline void 7458GEN8_MI_LOAD_URB_MEM_pack(__attribute__((unused)) __gen_user_data *data, 7459 __attribute__((unused)) void * restrict dst, 7460 __attribute__((unused)) const struct GEN8_MI_LOAD_URB_MEM * restrict values) 7461{ 7462 uint32_t * restrict dw = (uint32_t * restrict) dst; 7463 7464 dw[0] = 7465 __gen_uint(values->DWordLength, 0, 7) | 7466 __gen_uint(values->MICommandOpcode, 23, 28) | 7467 __gen_uint(values->CommandType, 29, 31); 7468 7469 dw[1] = 7470 __gen_uint(values->URBAddress, 2, 14); 7471 7472 const uint64_t v2_address = 7473 __gen_combine_address(data, &dw[2], values->MemoryAddress, 0); 7474 dw[2] = v2_address; 7475 dw[3] = v2_address >> 32; 7476} 7477 7478#define GEN8_MI_MATH_length_bias 2 7479#define GEN8_MI_MATH_header \ 7480 .DWordLength = 0, \ 7481 .MICommandOpcode = 26, \ 7482 .CommandType = 0 7483 7484struct GEN8_MI_MATH { 7485 uint32_t DWordLength; 7486 uint32_t MICommandOpcode; 7487 uint32_t CommandType; 7488 /* variable length fields follow */ 7489}; 7490 7491static inline void 7492GEN8_MI_MATH_pack(__attribute__((unused)) __gen_user_data *data, 7493 __attribute__((unused)) void * restrict dst, 7494 __attribute__((unused)) const struct GEN8_MI_MATH * restrict values) 7495{ 7496 uint32_t * restrict dw = (uint32_t * restrict) dst; 7497 7498 dw[0] = 7499 __gen_uint(values->DWordLength, 0, 5) | 7500 __gen_uint(values->MICommandOpcode, 23, 28) | 7501 __gen_uint(values->CommandType, 29, 31); 7502} 7503 7504#define GEN8_MI_NOOP_length 1 7505#define GEN8_MI_NOOP_length_bias 1 7506#define GEN8_MI_NOOP_header \ 7507 .MICommandOpcode = 0, \ 7508 .CommandType = 0 7509 7510struct GEN8_MI_NOOP { 7511 uint32_t IdentificationNumber; 7512 bool IdentificationNumberRegisterWriteEnable; 7513 uint32_t MICommandOpcode; 7514 uint32_t CommandType; 7515}; 7516 7517static inline void 7518GEN8_MI_NOOP_pack(__attribute__((unused)) __gen_user_data *data, 7519 __attribute__((unused)) void * restrict dst, 7520 __attribute__((unused)) const struct GEN8_MI_NOOP * restrict values) 7521{ 7522 uint32_t * restrict dw = (uint32_t * restrict) dst; 7523 7524 dw[0] = 7525 __gen_uint(values->IdentificationNumber, 0, 21) | 7526 __gen_uint(values->IdentificationNumberRegisterWriteEnable, 22, 22) | 7527 __gen_uint(values->MICommandOpcode, 23, 28) | 7528 __gen_uint(values->CommandType, 29, 31); 7529} 7530 7531#define GEN8_MI_PREDICATE_length 1 7532#define GEN8_MI_PREDICATE_length_bias 1 7533#define GEN8_MI_PREDICATE_header \ 7534 .MICommandOpcode = 12, \ 7535 .CommandType = 0 7536 7537struct GEN8_MI_PREDICATE { 7538 uint32_t CompareOperation; 7539#define COMPARE_TRUE 0 7540#define COMPARE_FALSE 1 7541#define COMPARE_SRCS_EQUAL 2 7542#define COMPARE_DELTAS_EQUAL 3 7543 uint32_t CombineOperation; 7544#define COMBINE_SET 0 7545#define COMBINE_AND 1 7546#define COMBINE_OR 2 7547#define COMBINE_XOR 3 7548 uint32_t LoadOperation; 7549#define LOAD_KEEP 0 7550#define LOAD_LOAD 2 7551#define LOAD_LOADINV 3 7552 uint32_t MICommandOpcode; 7553 uint32_t CommandType; 7554}; 7555 7556static inline void 7557GEN8_MI_PREDICATE_pack(__attribute__((unused)) __gen_user_data *data, 7558 __attribute__((unused)) void * restrict dst, 7559 __attribute__((unused)) const struct GEN8_MI_PREDICATE * restrict values) 7560{ 7561 uint32_t * restrict dw = (uint32_t * restrict) dst; 7562 7563 dw[0] = 7564 __gen_uint(values->CompareOperation, 0, 1) | 7565 __gen_uint(values->CombineOperation, 3, 4) | 7566 __gen_uint(values->LoadOperation, 6, 7) | 7567 __gen_uint(values->MICommandOpcode, 23, 28) | 7568 __gen_uint(values->CommandType, 29, 31); 7569} 7570 7571#define GEN8_MI_REPORT_HEAD_length 1 7572#define GEN8_MI_REPORT_HEAD_length_bias 1 7573#define GEN8_MI_REPORT_HEAD_header \ 7574 .MICommandOpcode = 7, \ 7575 .CommandType = 0 7576 7577struct GEN8_MI_REPORT_HEAD { 7578 uint32_t MICommandOpcode; 7579 uint32_t CommandType; 7580}; 7581 7582static inline void 7583GEN8_MI_REPORT_HEAD_pack(__attribute__((unused)) __gen_user_data *data, 7584 __attribute__((unused)) void * restrict dst, 7585 __attribute__((unused)) const struct GEN8_MI_REPORT_HEAD * restrict values) 7586{ 7587 uint32_t * restrict dw = (uint32_t * restrict) dst; 7588 7589 dw[0] = 7590 __gen_uint(values->MICommandOpcode, 23, 28) | 7591 __gen_uint(values->CommandType, 29, 31); 7592} 7593 7594#define GEN8_MI_REPORT_PERF_COUNT_length 4 7595#define GEN8_MI_REPORT_PERF_COUNT_length_bias 2 7596#define GEN8_MI_REPORT_PERF_COUNT_header \ 7597 .DWordLength = 2, \ 7598 .MICommandOpcode = 40, \ 7599 .CommandType = 0 7600 7601struct GEN8_MI_REPORT_PERF_COUNT { 7602 uint32_t DWordLength; 7603 uint32_t MICommandOpcode; 7604 uint32_t CommandType; 7605 bool UseGlobalGTT; 7606 uint32_t CoreModeEnable; 7607 __gen_address_type MemoryAddress; 7608 uint32_t ReportID; 7609}; 7610 7611static inline void 7612GEN8_MI_REPORT_PERF_COUNT_pack(__attribute__((unused)) __gen_user_data *data, 7613 __attribute__((unused)) void * restrict dst, 7614 __attribute__((unused)) const struct GEN8_MI_REPORT_PERF_COUNT * restrict values) 7615{ 7616 uint32_t * restrict dw = (uint32_t * restrict) dst; 7617 7618 dw[0] = 7619 __gen_uint(values->DWordLength, 0, 5) | 7620 __gen_uint(values->MICommandOpcode, 23, 28) | 7621 __gen_uint(values->CommandType, 29, 31); 7622 7623 const uint64_t v1 = 7624 __gen_uint(values->UseGlobalGTT, 0, 0) | 7625 __gen_uint(values->CoreModeEnable, 4, 4); 7626 const uint64_t v1_address = 7627 __gen_combine_address(data, &dw[1], values->MemoryAddress, v1); 7628 dw[1] = v1_address; 7629 dw[2] = (v1_address >> 32) | (v1 >> 32); 7630 7631 dw[3] = 7632 __gen_uint(values->ReportID, 0, 31); 7633} 7634 7635#define GEN8_MI_RS_CONTEXT_length 1 7636#define GEN8_MI_RS_CONTEXT_length_bias 1 7637#define GEN8_MI_RS_CONTEXT_header \ 7638 .MICommandOpcode = 15, \ 7639 .CommandType = 0 7640 7641struct GEN8_MI_RS_CONTEXT { 7642 uint32_t ResourceStreamerSave; 7643#define RS_Restore 0 7644#define RS_Save 1 7645 uint32_t MICommandOpcode; 7646 uint32_t CommandType; 7647}; 7648 7649static inline void 7650GEN8_MI_RS_CONTEXT_pack(__attribute__((unused)) __gen_user_data *data, 7651 __attribute__((unused)) void * restrict dst, 7652 __attribute__((unused)) const struct GEN8_MI_RS_CONTEXT * restrict values) 7653{ 7654 uint32_t * restrict dw = (uint32_t * restrict) dst; 7655 7656 dw[0] = 7657 __gen_uint(values->ResourceStreamerSave, 0, 0) | 7658 __gen_uint(values->MICommandOpcode, 23, 28) | 7659 __gen_uint(values->CommandType, 29, 31); 7660} 7661 7662#define GEN8_MI_RS_CONTROL_length 1 7663#define GEN8_MI_RS_CONTROL_length_bias 1 7664#define GEN8_MI_RS_CONTROL_header \ 7665 .MICommandOpcode = 6, \ 7666 .CommandType = 0 7667 7668struct GEN8_MI_RS_CONTROL { 7669 uint32_t ResourceStreamerControl; 7670#define RS_Stop 0 7671#define RS_Start 1 7672 uint32_t MICommandOpcode; 7673 uint32_t CommandType; 7674}; 7675 7676static inline void 7677GEN8_MI_RS_CONTROL_pack(__attribute__((unused)) __gen_user_data *data, 7678 __attribute__((unused)) void * restrict dst, 7679 __attribute__((unused)) const struct GEN8_MI_RS_CONTROL * restrict values) 7680{ 7681 uint32_t * restrict dw = (uint32_t * restrict) dst; 7682 7683 dw[0] = 7684 __gen_uint(values->ResourceStreamerControl, 0, 0) | 7685 __gen_uint(values->MICommandOpcode, 23, 28) | 7686 __gen_uint(values->CommandType, 29, 31); 7687} 7688 7689#define GEN8_MI_RS_STORE_DATA_IMM_length 4 7690#define GEN8_MI_RS_STORE_DATA_IMM_length_bias 2 7691#define GEN8_MI_RS_STORE_DATA_IMM_header \ 7692 .DWordLength = 2, \ 7693 .MICommandOpcode = 43, \ 7694 .CommandType = 0 7695 7696struct GEN8_MI_RS_STORE_DATA_IMM { 7697 uint32_t DWordLength; 7698 uint32_t MICommandOpcode; 7699 uint32_t CommandType; 7700 uint32_t CoreModeEnable; 7701 __gen_address_type DestinationAddress; 7702 uint32_t DataDWord0; 7703}; 7704 7705static inline void 7706GEN8_MI_RS_STORE_DATA_IMM_pack(__attribute__((unused)) __gen_user_data *data, 7707 __attribute__((unused)) void * restrict dst, 7708 __attribute__((unused)) const struct GEN8_MI_RS_STORE_DATA_IMM * restrict values) 7709{ 7710 uint32_t * restrict dw = (uint32_t * restrict) dst; 7711 7712 dw[0] = 7713 __gen_uint(values->DWordLength, 0, 7) | 7714 __gen_uint(values->MICommandOpcode, 23, 28) | 7715 __gen_uint(values->CommandType, 29, 31); 7716 7717 const uint64_t v1 = 7718 __gen_uint(values->CoreModeEnable, 0, 0); 7719 const uint64_t v1_address = 7720 __gen_combine_address(data, &dw[1], values->DestinationAddress, v1); 7721 dw[1] = v1_address; 7722 dw[2] = (v1_address >> 32) | (v1 >> 32); 7723 7724 dw[3] = 7725 __gen_uint(values->DataDWord0, 0, 31); 7726} 7727 7728#define GEN8_MI_SEMAPHORE_SIGNAL_length 2 7729#define GEN8_MI_SEMAPHORE_SIGNAL_length_bias 2 7730#define GEN8_MI_SEMAPHORE_SIGNAL_header \ 7731 .DWordLength = 0, \ 7732 .MICommandOpcode = 27, \ 7733 .CommandType = 0 7734 7735struct GEN8_MI_SEMAPHORE_SIGNAL { 7736 uint32_t DWordLength; 7737 uint32_t TargetEngineSelect; 7738#define RCS 0 7739#define VCS0 1 7740#define BCS 2 7741#define VECS 3 7742#define VCS1 4 7743 bool PostSyncOperation; 7744 uint32_t MICommandOpcode; 7745 uint32_t CommandType; 7746 uint32_t TargetContextID; 7747}; 7748 7749static inline void 7750GEN8_MI_SEMAPHORE_SIGNAL_pack(__attribute__((unused)) __gen_user_data *data, 7751 __attribute__((unused)) void * restrict dst, 7752 __attribute__((unused)) const struct GEN8_MI_SEMAPHORE_SIGNAL * restrict values) 7753{ 7754 uint32_t * restrict dw = (uint32_t * restrict) dst; 7755 7756 dw[0] = 7757 __gen_uint(values->DWordLength, 0, 7) | 7758 __gen_uint(values->TargetEngineSelect, 15, 17) | 7759 __gen_uint(values->PostSyncOperation, 21, 21) | 7760 __gen_uint(values->MICommandOpcode, 23, 28) | 7761 __gen_uint(values->CommandType, 29, 31); 7762 7763 dw[1] = 7764 __gen_uint(values->TargetContextID, 0, 31); 7765} 7766 7767#define GEN8_MI_SEMAPHORE_WAIT_length 4 7768#define GEN8_MI_SEMAPHORE_WAIT_length_bias 2 7769#define GEN8_MI_SEMAPHORE_WAIT_header \ 7770 .DWordLength = 2, \ 7771 .MICommandOpcode = 28, \ 7772 .CommandType = 0 7773 7774struct GEN8_MI_SEMAPHORE_WAIT { 7775 uint32_t DWordLength; 7776 uint32_t CompareOperation; 7777#define COMPARE_SAD_GREATER_THAN_SDD 0 7778#define COMPARE_SAD_GREATER_THAN_OR_EQUAL_SDD 1 7779#define COMPARE_SAD_LESS_THAN_SDD 2 7780#define COMPARE_SAD_LESS_THAN_OR_EQUAL_SDD 3 7781#define COMPARE_SAD_EQUAL_SDD 4 7782#define COMPARE_SAD_NOT_EQUAL_SDD 5 7783 uint32_t WaitMode; 7784#define PollingMode 1 7785#define SignalMode 0 7786 uint32_t MemoryType; 7787#define PerProcessGraphicsAddress 0 7788#define GlobalGraphicsAddress 1 7789 uint32_t MICommandOpcode; 7790 uint32_t CommandType; 7791 uint32_t SemaphoreDataDword; 7792 __gen_address_type SemaphoreAddress; 7793 __gen_address_type SemaphoreAddressHigh; 7794}; 7795 7796static inline void 7797GEN8_MI_SEMAPHORE_WAIT_pack(__attribute__((unused)) __gen_user_data *data, 7798 __attribute__((unused)) void * restrict dst, 7799 __attribute__((unused)) const struct GEN8_MI_SEMAPHORE_WAIT * restrict values) 7800{ 7801 uint32_t * restrict dw = (uint32_t * restrict) dst; 7802 7803 dw[0] = 7804 __gen_uint(values->DWordLength, 0, 7) | 7805 __gen_uint(values->CompareOperation, 12, 14) | 7806 __gen_uint(values->WaitMode, 15, 15) | 7807 __gen_uint(values->MemoryType, 22, 22) | 7808 __gen_uint(values->MICommandOpcode, 23, 28) | 7809 __gen_uint(values->CommandType, 29, 31); 7810 7811 dw[1] = 7812 __gen_uint(values->SemaphoreDataDword, 0, 31); 7813 7814 dw[2] = __gen_combine_address(data, &dw[2], values->SemaphoreAddress, 0); 7815 7816 dw[3] = __gen_combine_address(data, &dw[3], values->SemaphoreAddressHigh, 0); 7817} 7818 7819#define GEN8_MI_SET_CONTEXT_length 2 7820#define GEN8_MI_SET_CONTEXT_length_bias 2 7821#define GEN8_MI_SET_CONTEXT_header \ 7822 .DWordLength = 0, \ 7823 .MICommandOpcode = 24, \ 7824 .CommandType = 0 7825 7826struct GEN8_MI_SET_CONTEXT { 7827 uint32_t DWordLength; 7828 uint32_t MICommandOpcode; 7829 uint32_t CommandType; 7830 uint32_t RestoreInhibit; 7831 uint32_t ForceRestore; 7832 bool ResourceStreamerStateRestoreEnable; 7833 bool ResourceStreamerStateSaveEnable; 7834 bool CoreModeEnable; 7835 uint32_t ReservedMustbe1; 7836 __gen_address_type LogicalContextAddress; 7837}; 7838 7839static inline void 7840GEN8_MI_SET_CONTEXT_pack(__attribute__((unused)) __gen_user_data *data, 7841 __attribute__((unused)) void * restrict dst, 7842 __attribute__((unused)) const struct GEN8_MI_SET_CONTEXT * restrict values) 7843{ 7844 uint32_t * restrict dw = (uint32_t * restrict) dst; 7845 7846 dw[0] = 7847 __gen_uint(values->DWordLength, 0, 7) | 7848 __gen_uint(values->MICommandOpcode, 23, 28) | 7849 __gen_uint(values->CommandType, 29, 31); 7850 7851 const uint32_t v1 = 7852 __gen_uint(values->RestoreInhibit, 0, 0) | 7853 __gen_uint(values->ForceRestore, 1, 1) | 7854 __gen_uint(values->ResourceStreamerStateRestoreEnable, 2, 2) | 7855 __gen_uint(values->ResourceStreamerStateSaveEnable, 3, 3) | 7856 __gen_uint(values->CoreModeEnable, 4, 4) | 7857 __gen_uint(values->ReservedMustbe1, 8, 8); 7858 dw[1] = __gen_combine_address(data, &dw[1], values->LogicalContextAddress, v1); 7859} 7860 7861#define GEN8_MI_SET_PREDICATE_length 1 7862#define GEN8_MI_SET_PREDICATE_length_bias 1 7863#define GEN8_MI_SET_PREDICATE_header \ 7864 .MICommandOpcode = 1, \ 7865 .CommandType = 0 7866 7867struct GEN8_MI_SET_PREDICATE { 7868 uint32_t PREDICATEENABLE; 7869#define NOOPNever 0 7870#define NOOPonResult2clear 1 7871#define NOOPonResult2set 2 7872#define NOOPonResultclear 3 7873#define NOOPonResultset 4 7874#define Executewhenonesliceenabled 5 7875#define Executewhentwoslicesareenabled 6 7876#define Executewhenthreeslicesareenabled 7 7877#define NOOPAlways 15 7878 uint32_t MICommandOpcode; 7879 uint32_t CommandType; 7880}; 7881 7882static inline void 7883GEN8_MI_SET_PREDICATE_pack(__attribute__((unused)) __gen_user_data *data, 7884 __attribute__((unused)) void * restrict dst, 7885 __attribute__((unused)) const struct GEN8_MI_SET_PREDICATE * restrict values) 7886{ 7887 uint32_t * restrict dw = (uint32_t * restrict) dst; 7888 7889 dw[0] = 7890 __gen_uint(values->PREDICATEENABLE, 0, 3) | 7891 __gen_uint(values->MICommandOpcode, 23, 28) | 7892 __gen_uint(values->CommandType, 29, 31); 7893} 7894 7895#define GEN8_MI_STORE_DATA_IMM_length 4 7896#define GEN8_MI_STORE_DATA_IMM_length_bias 2 7897#define GEN8_MI_STORE_DATA_IMM_header \ 7898 .DWordLength = 2, \ 7899 .MICommandOpcode = 32, \ 7900 .CommandType = 0 7901 7902struct GEN8_MI_STORE_DATA_IMM { 7903 uint32_t DWordLength; 7904 uint32_t StoreQword; 7905 bool UseGlobalGTT; 7906 uint32_t MICommandOpcode; 7907 uint32_t CommandType; 7908 uint32_t CoreModeEnable; 7909 __gen_address_type Address; 7910 uint64_t ImmediateData; 7911}; 7912 7913static inline void 7914GEN8_MI_STORE_DATA_IMM_pack(__attribute__((unused)) __gen_user_data *data, 7915 __attribute__((unused)) void * restrict dst, 7916 __attribute__((unused)) const struct GEN8_MI_STORE_DATA_IMM * restrict values) 7917{ 7918 uint32_t * restrict dw = (uint32_t * restrict) dst; 7919 7920 dw[0] = 7921 __gen_uint(values->DWordLength, 0, 9) | 7922 __gen_uint(values->StoreQword, 21, 21) | 7923 __gen_uint(values->UseGlobalGTT, 22, 22) | 7924 __gen_uint(values->MICommandOpcode, 23, 28) | 7925 __gen_uint(values->CommandType, 29, 31); 7926 7927 const uint64_t v1 = 7928 __gen_uint(values->CoreModeEnable, 0, 0); 7929 const uint64_t v1_address = 7930 __gen_combine_address(data, &dw[1], values->Address, v1); 7931 dw[1] = v1_address; 7932 dw[2] = (v1_address >> 32) | (v1 >> 32); 7933 7934 const uint64_t v3 = 7935 __gen_uint(values->ImmediateData, 0, 63); 7936 dw[3] = v3; 7937 dw[4] = v3 >> 32; 7938} 7939 7940#define GEN8_MI_STORE_DATA_INDEX_length 3 7941#define GEN8_MI_STORE_DATA_INDEX_length_bias 2 7942#define GEN8_MI_STORE_DATA_INDEX_header \ 7943 .DWordLength = 1, \ 7944 .MICommandOpcode = 33, \ 7945 .CommandType = 0 7946 7947struct GEN8_MI_STORE_DATA_INDEX { 7948 uint32_t DWordLength; 7949 uint32_t UsePerProcessHardwareStatusPage; 7950 uint32_t MICommandOpcode; 7951 uint32_t CommandType; 7952 uint32_t Offset; 7953 uint32_t DataDWord0; 7954 uint32_t DataDWord1; 7955}; 7956 7957static inline void 7958GEN8_MI_STORE_DATA_INDEX_pack(__attribute__((unused)) __gen_user_data *data, 7959 __attribute__((unused)) void * restrict dst, 7960 __attribute__((unused)) const struct GEN8_MI_STORE_DATA_INDEX * restrict values) 7961{ 7962 uint32_t * restrict dw = (uint32_t * restrict) dst; 7963 7964 dw[0] = 7965 __gen_uint(values->DWordLength, 0, 7) | 7966 __gen_uint(values->UsePerProcessHardwareStatusPage, 21, 21) | 7967 __gen_uint(values->MICommandOpcode, 23, 28) | 7968 __gen_uint(values->CommandType, 29, 31); 7969 7970 dw[1] = 7971 __gen_uint(values->Offset, 2, 11); 7972 7973 dw[2] = 7974 __gen_uint(values->DataDWord0, 0, 31); 7975} 7976 7977#define GEN8_MI_STORE_REGISTER_MEM_length 4 7978#define GEN8_MI_STORE_REGISTER_MEM_length_bias 2 7979#define GEN8_MI_STORE_REGISTER_MEM_header \ 7980 .DWordLength = 2, \ 7981 .MICommandOpcode = 36, \ 7982 .CommandType = 0 7983 7984struct GEN8_MI_STORE_REGISTER_MEM { 7985 uint32_t DWordLength; 7986 bool PredicateEnable; 7987 bool UseGlobalGTT; 7988 uint32_t MICommandOpcode; 7989 uint32_t CommandType; 7990 uint64_t RegisterAddress; 7991 __gen_address_type MemoryAddress; 7992}; 7993 7994static inline void 7995GEN8_MI_STORE_REGISTER_MEM_pack(__attribute__((unused)) __gen_user_data *data, 7996 __attribute__((unused)) void * restrict dst, 7997 __attribute__((unused)) const struct GEN8_MI_STORE_REGISTER_MEM * restrict values) 7998{ 7999 uint32_t * restrict dw = (uint32_t * restrict) dst; 8000 8001 dw[0] = 8002 __gen_uint(values->DWordLength, 0, 7) | 8003 __gen_uint(values->PredicateEnable, 21, 21) | 8004 __gen_uint(values->UseGlobalGTT, 22, 22) | 8005 __gen_uint(values->MICommandOpcode, 23, 28) | 8006 __gen_uint(values->CommandType, 29, 31); 8007 8008 dw[1] = 8009 __gen_offset(values->RegisterAddress, 2, 22); 8010 8011 const uint64_t v2_address = 8012 __gen_combine_address(data, &dw[2], values->MemoryAddress, 0); 8013 dw[2] = v2_address; 8014 dw[3] = v2_address >> 32; 8015} 8016 8017#define GEN8_MI_STORE_URB_MEM_length 4 8018#define GEN8_MI_STORE_URB_MEM_length_bias 2 8019#define GEN8_MI_STORE_URB_MEM_header \ 8020 .DWordLength = 2, \ 8021 .MICommandOpcode = 45, \ 8022 .CommandType = 0 8023 8024struct GEN8_MI_STORE_URB_MEM { 8025 uint32_t DWordLength; 8026 uint32_t MICommandOpcode; 8027 uint32_t CommandType; 8028 uint32_t URBAddress; 8029 __gen_address_type MemoryAddress; 8030}; 8031 8032static inline void 8033GEN8_MI_STORE_URB_MEM_pack(__attribute__((unused)) __gen_user_data *data, 8034 __attribute__((unused)) void * restrict dst, 8035 __attribute__((unused)) const struct GEN8_MI_STORE_URB_MEM * restrict values) 8036{ 8037 uint32_t * restrict dw = (uint32_t * restrict) dst; 8038 8039 dw[0] = 8040 __gen_uint(values->DWordLength, 0, 7) | 8041 __gen_uint(values->MICommandOpcode, 23, 28) | 8042 __gen_uint(values->CommandType, 29, 31); 8043 8044 dw[1] = 8045 __gen_uint(values->URBAddress, 2, 14); 8046 8047 const uint64_t v2_address = 8048 __gen_combine_address(data, &dw[2], values->MemoryAddress, 0); 8049 dw[2] = v2_address; 8050 dw[3] = v2_address >> 32; 8051} 8052 8053#define GEN8_MI_SUSPEND_FLUSH_length 1 8054#define GEN8_MI_SUSPEND_FLUSH_length_bias 1 8055#define GEN8_MI_SUSPEND_FLUSH_header \ 8056 .MICommandOpcode = 11, \ 8057 .CommandType = 0 8058 8059struct GEN8_MI_SUSPEND_FLUSH { 8060 bool SuspendFlush; 8061 uint32_t MICommandOpcode; 8062 uint32_t CommandType; 8063}; 8064 8065static inline void 8066GEN8_MI_SUSPEND_FLUSH_pack(__attribute__((unused)) __gen_user_data *data, 8067 __attribute__((unused)) void * restrict dst, 8068 __attribute__((unused)) const struct GEN8_MI_SUSPEND_FLUSH * restrict values) 8069{ 8070 uint32_t * restrict dw = (uint32_t * restrict) dst; 8071 8072 dw[0] = 8073 __gen_uint(values->SuspendFlush, 0, 0) | 8074 __gen_uint(values->MICommandOpcode, 23, 28) | 8075 __gen_uint(values->CommandType, 29, 31); 8076} 8077 8078#define GEN8_MI_TOPOLOGY_FILTER_length 1 8079#define GEN8_MI_TOPOLOGY_FILTER_length_bias 1 8080#define GEN8_MI_TOPOLOGY_FILTER_header \ 8081 .MICommandOpcode = 13, \ 8082 .CommandType = 0 8083 8084struct GEN8_MI_TOPOLOGY_FILTER { 8085 enum GEN8_3D_Prim_Topo_Type TopologyFilterValue; 8086 uint32_t MICommandOpcode; 8087 uint32_t CommandType; 8088}; 8089 8090static inline void 8091GEN8_MI_TOPOLOGY_FILTER_pack(__attribute__((unused)) __gen_user_data *data, 8092 __attribute__((unused)) void * restrict dst, 8093 __attribute__((unused)) const struct GEN8_MI_TOPOLOGY_FILTER * restrict values) 8094{ 8095 uint32_t * restrict dw = (uint32_t * restrict) dst; 8096 8097 dw[0] = 8098 __gen_uint(values->TopologyFilterValue, 0, 5) | 8099 __gen_uint(values->MICommandOpcode, 23, 28) | 8100 __gen_uint(values->CommandType, 29, 31); 8101} 8102 8103#define GEN8_MI_URB_ATOMIC_ALLOC_length 1 8104#define GEN8_MI_URB_ATOMIC_ALLOC_length_bias 1 8105#define GEN8_MI_URB_ATOMIC_ALLOC_header \ 8106 .MICommandOpcode = 9, \ 8107 .CommandType = 0 8108 8109struct GEN8_MI_URB_ATOMIC_ALLOC { 8110 uint32_t URBAtomicStorageSize; 8111 uint32_t URBAtomicStorageOffset; 8112 uint32_t MICommandOpcode; 8113 uint32_t CommandType; 8114}; 8115 8116static inline void 8117GEN8_MI_URB_ATOMIC_ALLOC_pack(__attribute__((unused)) __gen_user_data *data, 8118 __attribute__((unused)) void * restrict dst, 8119 __attribute__((unused)) const struct GEN8_MI_URB_ATOMIC_ALLOC * restrict values) 8120{ 8121 uint32_t * restrict dw = (uint32_t * restrict) dst; 8122 8123 dw[0] = 8124 __gen_uint(values->URBAtomicStorageSize, 0, 8) | 8125 __gen_uint(values->URBAtomicStorageOffset, 12, 19) | 8126 __gen_uint(values->MICommandOpcode, 23, 28) | 8127 __gen_uint(values->CommandType, 29, 31); 8128} 8129 8130#define GEN8_MI_URB_CLEAR_length 2 8131#define GEN8_MI_URB_CLEAR_length_bias 2 8132#define GEN8_MI_URB_CLEAR_header \ 8133 .DWordLength = 0, \ 8134 .MICommandOpcode = 25, \ 8135 .CommandType = 0 8136 8137struct GEN8_MI_URB_CLEAR { 8138 uint32_t DWordLength; 8139 uint32_t MICommandOpcode; 8140 uint32_t CommandType; 8141 uint64_t URBAddress; 8142 uint32_t URBClearLength; 8143}; 8144 8145static inline void 8146GEN8_MI_URB_CLEAR_pack(__attribute__((unused)) __gen_user_data *data, 8147 __attribute__((unused)) void * restrict dst, 8148 __attribute__((unused)) const struct GEN8_MI_URB_CLEAR * restrict values) 8149{ 8150 uint32_t * restrict dw = (uint32_t * restrict) dst; 8151 8152 dw[0] = 8153 __gen_uint(values->DWordLength, 0, 7) | 8154 __gen_uint(values->MICommandOpcode, 23, 28) | 8155 __gen_uint(values->CommandType, 29, 31); 8156 8157 dw[1] = 8158 __gen_offset(values->URBAddress, 0, 14) | 8159 __gen_uint(values->URBClearLength, 16, 29); 8160} 8161 8162#define GEN8_MI_USER_INTERRUPT_length 1 8163#define GEN8_MI_USER_INTERRUPT_length_bias 1 8164#define GEN8_MI_USER_INTERRUPT_header \ 8165 .MICommandOpcode = 2, \ 8166 .CommandType = 0 8167 8168struct GEN8_MI_USER_INTERRUPT { 8169 uint32_t MICommandOpcode; 8170 uint32_t CommandType; 8171}; 8172 8173static inline void 8174GEN8_MI_USER_INTERRUPT_pack(__attribute__((unused)) __gen_user_data *data, 8175 __attribute__((unused)) void * restrict dst, 8176 __attribute__((unused)) const struct GEN8_MI_USER_INTERRUPT * restrict values) 8177{ 8178 uint32_t * restrict dw = (uint32_t * restrict) dst; 8179 8180 dw[0] = 8181 __gen_uint(values->MICommandOpcode, 23, 28) | 8182 __gen_uint(values->CommandType, 29, 31); 8183} 8184 8185#define GEN8_MI_WAIT_FOR_EVENT_length 1 8186#define GEN8_MI_WAIT_FOR_EVENT_length_bias 1 8187#define GEN8_MI_WAIT_FOR_EVENT_header \ 8188 .MICommandOpcode = 3, \ 8189 .CommandType = 0 8190 8191struct GEN8_MI_WAIT_FOR_EVENT { 8192 bool DisplayPipeAScanLineWaitEnable; 8193 bool DisplayPlaneAFlipPendingWaitEnable; 8194 bool DisplaySpriteAFlipPendingWaitEnable; 8195 bool DisplayPipeAVerticalBlankWaitEnable; 8196 bool DisplayPipeBScanLineWaitEnable; 8197 bool DisplayPlaneBFlipPendingWaitEnable; 8198 bool DisplaySpriteBFlipPendingWaitEnable; 8199 bool DisplayPipeBVerticalBlankWaitEnable; 8200 bool DisplayPipeCScanLineWaitEnable; 8201 bool DisplayPlaneCFlipPendingWaitEnable; 8202 bool DisplaySpriteCFlipPendingWaitEnable; 8203 bool DisplayPipeCVerticalBlankWaitEnable; 8204 uint32_t MICommandOpcode; 8205 uint32_t CommandType; 8206}; 8207 8208static inline void 8209GEN8_MI_WAIT_FOR_EVENT_pack(__attribute__((unused)) __gen_user_data *data, 8210 __attribute__((unused)) void * restrict dst, 8211 __attribute__((unused)) const struct GEN8_MI_WAIT_FOR_EVENT * restrict values) 8212{ 8213 uint32_t * restrict dw = (uint32_t * restrict) dst; 8214 8215 dw[0] = 8216 __gen_uint(values->DisplayPipeAScanLineWaitEnable, 0, 0) | 8217 __gen_uint(values->DisplayPlaneAFlipPendingWaitEnable, 1, 1) | 8218 __gen_uint(values->DisplaySpriteAFlipPendingWaitEnable, 2, 2) | 8219 __gen_uint(values->DisplayPipeAVerticalBlankWaitEnable, 3, 3) | 8220 __gen_uint(values->DisplayPipeBScanLineWaitEnable, 8, 8) | 8221 __gen_uint(values->DisplayPlaneBFlipPendingWaitEnable, 9, 9) | 8222 __gen_uint(values->DisplaySpriteBFlipPendingWaitEnable, 10, 10) | 8223 __gen_uint(values->DisplayPipeBVerticalBlankWaitEnable, 11, 11) | 8224 __gen_uint(values->DisplayPipeCScanLineWaitEnable, 14, 14) | 8225 __gen_uint(values->DisplayPlaneCFlipPendingWaitEnable, 15, 15) | 8226 __gen_uint(values->DisplaySpriteCFlipPendingWaitEnable, 20, 20) | 8227 __gen_uint(values->DisplayPipeCVerticalBlankWaitEnable, 21, 21) | 8228 __gen_uint(values->MICommandOpcode, 23, 28) | 8229 __gen_uint(values->CommandType, 29, 31); 8230} 8231 8232#define GEN8_PIPELINE_SELECT_length 1 8233#define GEN8_PIPELINE_SELECT_length_bias 1 8234#define GEN8_PIPELINE_SELECT_header \ 8235 ._3DCommandSubOpcode = 4, \ 8236 ._3DCommandOpcode = 1, \ 8237 .CommandSubType = 1, \ 8238 .CommandType = 3 8239 8240struct GEN8_PIPELINE_SELECT { 8241 uint32_t PipelineSelection; 8242#define _3D 0 8243#define Media 1 8244#define GPGPU 2 8245 uint32_t _3DCommandSubOpcode; 8246 uint32_t _3DCommandOpcode; 8247 uint32_t CommandSubType; 8248 uint32_t CommandType; 8249}; 8250 8251static inline void 8252GEN8_PIPELINE_SELECT_pack(__attribute__((unused)) __gen_user_data *data, 8253 __attribute__((unused)) void * restrict dst, 8254 __attribute__((unused)) const struct GEN8_PIPELINE_SELECT * restrict values) 8255{ 8256 uint32_t * restrict dw = (uint32_t * restrict) dst; 8257 8258 dw[0] = 8259 __gen_uint(values->PipelineSelection, 0, 1) | 8260 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 8261 __gen_uint(values->_3DCommandOpcode, 24, 26) | 8262 __gen_uint(values->CommandSubType, 27, 28) | 8263 __gen_uint(values->CommandType, 29, 31); 8264} 8265 8266#define GEN8_PIPE_CONTROL_length 6 8267#define GEN8_PIPE_CONTROL_length_bias 2 8268#define GEN8_PIPE_CONTROL_header \ 8269 .DWordLength = 4, \ 8270 ._3DCommandSubOpcode = 0, \ 8271 ._3DCommandOpcode = 2, \ 8272 .CommandSubType = 3, \ 8273 .CommandType = 3 8274 8275struct GEN8_PIPE_CONTROL { 8276 uint32_t DWordLength; 8277 uint32_t _3DCommandSubOpcode; 8278 uint32_t _3DCommandOpcode; 8279 uint32_t CommandSubType; 8280 uint32_t CommandType; 8281 bool DepthCacheFlushEnable; 8282 bool StallAtPixelScoreboard; 8283 bool StateCacheInvalidationEnable; 8284 bool ConstantCacheInvalidationEnable; 8285 bool VFCacheInvalidationEnable; 8286 bool DCFlushEnable; 8287 bool PipeControlFlushEnable; 8288 bool NotifyEnable; 8289 bool IndirectStatePointersDisable; 8290 bool TextureCacheInvalidationEnable; 8291 bool InstructionCacheInvalidateEnable; 8292 bool RenderTargetCacheFlushEnable; 8293 bool DepthStallEnable; 8294 uint32_t PostSyncOperation; 8295#define NoWrite 0 8296#define WriteImmediateData 1 8297#define WritePSDepthCount 2 8298#define WriteTimestamp 3 8299 bool GenericMediaStateClear; 8300 bool TLBInvalidate; 8301 bool GlobalSnapshotCountReset; 8302 bool CommandStreamerStallEnable; 8303 uint32_t StoreDataIndex; 8304 uint32_t LRIPostSyncOperation; 8305#define NoLRIOperation 0 8306#define MMIOWriteImmediateData 1 8307 uint32_t DestinationAddressType; 8308#define DAT_PPGTT 0 8309#define DAT_GGTT 1 8310 __gen_address_type Address; 8311 uint64_t ImmediateData; 8312}; 8313 8314static inline void 8315GEN8_PIPE_CONTROL_pack(__attribute__((unused)) __gen_user_data *data, 8316 __attribute__((unused)) void * restrict dst, 8317 __attribute__((unused)) const struct GEN8_PIPE_CONTROL * restrict values) 8318{ 8319 uint32_t * restrict dw = (uint32_t * restrict) dst; 8320 8321 dw[0] = 8322 __gen_uint(values->DWordLength, 0, 7) | 8323 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 8324 __gen_uint(values->_3DCommandOpcode, 24, 26) | 8325 __gen_uint(values->CommandSubType, 27, 28) | 8326 __gen_uint(values->CommandType, 29, 31); 8327 8328 dw[1] = 8329 __gen_uint(values->DepthCacheFlushEnable, 0, 0) | 8330 __gen_uint(values->StallAtPixelScoreboard, 1, 1) | 8331 __gen_uint(values->StateCacheInvalidationEnable, 2, 2) | 8332 __gen_uint(values->ConstantCacheInvalidationEnable, 3, 3) | 8333 __gen_uint(values->VFCacheInvalidationEnable, 4, 4) | 8334 __gen_uint(values->DCFlushEnable, 5, 5) | 8335 __gen_uint(values->PipeControlFlushEnable, 7, 7) | 8336 __gen_uint(values->NotifyEnable, 8, 8) | 8337 __gen_uint(values->IndirectStatePointersDisable, 9, 9) | 8338 __gen_uint(values->TextureCacheInvalidationEnable, 10, 10) | 8339 __gen_uint(values->InstructionCacheInvalidateEnable, 11, 11) | 8340 __gen_uint(values->RenderTargetCacheFlushEnable, 12, 12) | 8341 __gen_uint(values->DepthStallEnable, 13, 13) | 8342 __gen_uint(values->PostSyncOperation, 14, 15) | 8343 __gen_uint(values->GenericMediaStateClear, 16, 16) | 8344 __gen_uint(values->TLBInvalidate, 18, 18) | 8345 __gen_uint(values->GlobalSnapshotCountReset, 19, 19) | 8346 __gen_uint(values->CommandStreamerStallEnable, 20, 20) | 8347 __gen_uint(values->StoreDataIndex, 21, 21) | 8348 __gen_uint(values->LRIPostSyncOperation, 23, 23) | 8349 __gen_uint(values->DestinationAddressType, 24, 24); 8350 8351 const uint64_t v2_address = 8352 __gen_combine_address(data, &dw[2], values->Address, 0); 8353 dw[2] = v2_address; 8354 dw[3] = v2_address >> 32; 8355 8356 const uint64_t v4 = 8357 __gen_uint(values->ImmediateData, 0, 63); 8358 dw[4] = v4; 8359 dw[5] = v4 >> 32; 8360} 8361 8362#define GEN8_STATE_BASE_ADDRESS_length 16 8363#define GEN8_STATE_BASE_ADDRESS_length_bias 2 8364#define GEN8_STATE_BASE_ADDRESS_header \ 8365 .DWordLength = 14, \ 8366 ._3DCommandSubOpcode = 1, \ 8367 ._3DCommandOpcode = 1, \ 8368 .CommandSubType = 0, \ 8369 .CommandType = 3 8370 8371struct GEN8_STATE_BASE_ADDRESS { 8372 uint32_t DWordLength; 8373 uint32_t _3DCommandSubOpcode; 8374 uint32_t _3DCommandOpcode; 8375 uint32_t CommandSubType; 8376 uint32_t CommandType; 8377 bool GeneralStateBaseAddressModifyEnable; 8378 uint32_t GeneralStateMOCS; 8379 __gen_address_type GeneralStateBaseAddress; 8380 uint32_t StatelessDataPortAccessMOCS; 8381 bool SurfaceStateBaseAddressModifyEnable; 8382 uint32_t SurfaceStateMOCS; 8383 __gen_address_type SurfaceStateBaseAddress; 8384 bool DynamicStateBaseAddressModifyEnable; 8385 uint32_t DynamicStateMOCS; 8386 __gen_address_type DynamicStateBaseAddress; 8387 bool IndirectObjectBaseAddressModifyEnable; 8388 uint32_t IndirectObjectMOCS; 8389 __gen_address_type IndirectObjectBaseAddress; 8390 bool InstructionBaseAddressModifyEnable; 8391 uint32_t InstructionMOCS; 8392 __gen_address_type InstructionBaseAddress; 8393 bool GeneralStateBufferSizeModifyEnable; 8394 uint32_t GeneralStateBufferSize; 8395 bool DynamicStateBufferSizeModifyEnable; 8396 uint32_t DynamicStateBufferSize; 8397 bool IndirectObjectBufferSizeModifyEnable; 8398 uint32_t IndirectObjectBufferSize; 8399 bool InstructionBuffersizeModifyEnable; 8400 uint32_t InstructionBufferSize; 8401}; 8402 8403static inline void 8404GEN8_STATE_BASE_ADDRESS_pack(__attribute__((unused)) __gen_user_data *data, 8405 __attribute__((unused)) void * restrict dst, 8406 __attribute__((unused)) const struct GEN8_STATE_BASE_ADDRESS * restrict values) 8407{ 8408 uint32_t * restrict dw = (uint32_t * restrict) dst; 8409 8410 dw[0] = 8411 __gen_uint(values->DWordLength, 0, 7) | 8412 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 8413 __gen_uint(values->_3DCommandOpcode, 24, 26) | 8414 __gen_uint(values->CommandSubType, 27, 28) | 8415 __gen_uint(values->CommandType, 29, 31); 8416 8417 const uint64_t v1 = 8418 __gen_uint(values->GeneralStateBaseAddressModifyEnable, 0, 0) | 8419 __gen_uint(values->GeneralStateMOCS, 4, 10); 8420 const uint64_t v1_address = 8421 __gen_combine_address(data, &dw[1], values->GeneralStateBaseAddress, v1); 8422 dw[1] = v1_address; 8423 dw[2] = (v1_address >> 32) | (v1 >> 32); 8424 8425 dw[3] = 8426 __gen_uint(values->StatelessDataPortAccessMOCS, 16, 22); 8427 8428 const uint64_t v4 = 8429 __gen_uint(values->SurfaceStateBaseAddressModifyEnable, 0, 0) | 8430 __gen_uint(values->SurfaceStateMOCS, 4, 10); 8431 const uint64_t v4_address = 8432 __gen_combine_address(data, &dw[4], values->SurfaceStateBaseAddress, v4); 8433 dw[4] = v4_address; 8434 dw[5] = (v4_address >> 32) | (v4 >> 32); 8435 8436 const uint64_t v6 = 8437 __gen_uint(values->DynamicStateBaseAddressModifyEnable, 0, 0) | 8438 __gen_uint(values->DynamicStateMOCS, 4, 10); 8439 const uint64_t v6_address = 8440 __gen_combine_address(data, &dw[6], values->DynamicStateBaseAddress, v6); 8441 dw[6] = v6_address; 8442 dw[7] = (v6_address >> 32) | (v6 >> 32); 8443 8444 const uint64_t v8 = 8445 __gen_uint(values->IndirectObjectBaseAddressModifyEnable, 0, 0) | 8446 __gen_uint(values->IndirectObjectMOCS, 4, 10); 8447 const uint64_t v8_address = 8448 __gen_combine_address(data, &dw[8], values->IndirectObjectBaseAddress, v8); 8449 dw[8] = v8_address; 8450 dw[9] = (v8_address >> 32) | (v8 >> 32); 8451 8452 const uint64_t v10 = 8453 __gen_uint(values->InstructionBaseAddressModifyEnable, 0, 0) | 8454 __gen_uint(values->InstructionMOCS, 4, 10); 8455 const uint64_t v10_address = 8456 __gen_combine_address(data, &dw[10], values->InstructionBaseAddress, v10); 8457 dw[10] = v10_address; 8458 dw[11] = (v10_address >> 32) | (v10 >> 32); 8459 8460 dw[12] = 8461 __gen_uint(values->GeneralStateBufferSizeModifyEnable, 0, 0) | 8462 __gen_uint(values->GeneralStateBufferSize, 12, 31); 8463 8464 dw[13] = 8465 __gen_uint(values->DynamicStateBufferSizeModifyEnable, 0, 0) | 8466 __gen_uint(values->DynamicStateBufferSize, 12, 31); 8467 8468 dw[14] = 8469 __gen_uint(values->IndirectObjectBufferSizeModifyEnable, 0, 0) | 8470 __gen_uint(values->IndirectObjectBufferSize, 12, 31); 8471 8472 dw[15] = 8473 __gen_uint(values->InstructionBuffersizeModifyEnable, 0, 0) | 8474 __gen_uint(values->InstructionBufferSize, 12, 31); 8475} 8476 8477#define GEN8_STATE_PREFETCH_length 2 8478#define GEN8_STATE_PREFETCH_length_bias 2 8479#define GEN8_STATE_PREFETCH_header \ 8480 .DWordLength = 0, \ 8481 ._3DCommandSubOpcode = 3, \ 8482 ._3DCommandOpcode = 0, \ 8483 .CommandSubType = 0, \ 8484 .CommandType = 3 8485 8486struct GEN8_STATE_PREFETCH { 8487 uint32_t DWordLength; 8488 uint32_t _3DCommandSubOpcode; 8489 uint32_t _3DCommandOpcode; 8490 uint32_t CommandSubType; 8491 uint32_t CommandType; 8492 uint32_t PrefetchCount; 8493 __gen_address_type PrefetchPointer; 8494}; 8495 8496static inline void 8497GEN8_STATE_PREFETCH_pack(__attribute__((unused)) __gen_user_data *data, 8498 __attribute__((unused)) void * restrict dst, 8499 __attribute__((unused)) const struct GEN8_STATE_PREFETCH * restrict values) 8500{ 8501 uint32_t * restrict dw = (uint32_t * restrict) dst; 8502 8503 dw[0] = 8504 __gen_uint(values->DWordLength, 0, 7) | 8505 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 8506 __gen_uint(values->_3DCommandOpcode, 24, 26) | 8507 __gen_uint(values->CommandSubType, 27, 28) | 8508 __gen_uint(values->CommandType, 29, 31); 8509 8510 const uint32_t v1 = 8511 __gen_uint(values->PrefetchCount, 0, 2); 8512 dw[1] = __gen_combine_address(data, &dw[1], values->PrefetchPointer, v1); 8513} 8514 8515#define GEN8_STATE_SIP_length 3 8516#define GEN8_STATE_SIP_length_bias 2 8517#define GEN8_STATE_SIP_header \ 8518 .DWordLength = 1, \ 8519 ._3DCommandSubOpcode = 2, \ 8520 ._3DCommandOpcode = 1, \ 8521 .CommandSubType = 0, \ 8522 .CommandType = 3 8523 8524struct GEN8_STATE_SIP { 8525 uint32_t DWordLength; 8526 uint32_t _3DCommandSubOpcode; 8527 uint32_t _3DCommandOpcode; 8528 uint32_t CommandSubType; 8529 uint32_t CommandType; 8530 uint64_t SystemInstructionPointer; 8531}; 8532 8533static inline void 8534GEN8_STATE_SIP_pack(__attribute__((unused)) __gen_user_data *data, 8535 __attribute__((unused)) void * restrict dst, 8536 __attribute__((unused)) const struct GEN8_STATE_SIP * restrict values) 8537{ 8538 uint32_t * restrict dw = (uint32_t * restrict) dst; 8539 8540 dw[0] = 8541 __gen_uint(values->DWordLength, 0, 7) | 8542 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 8543 __gen_uint(values->_3DCommandOpcode, 24, 26) | 8544 __gen_uint(values->CommandSubType, 27, 28) | 8545 __gen_uint(values->CommandType, 29, 31); 8546 8547 const uint64_t v1 = 8548 __gen_offset(values->SystemInstructionPointer, 4, 63); 8549 dw[1] = v1; 8550 dw[2] = v1 >> 32; 8551} 8552 8553#define GEN8_SWTESS_BASE_ADDRESS_length 2 8554#define GEN8_SWTESS_BASE_ADDRESS_length_bias 2 8555#define GEN8_SWTESS_BASE_ADDRESS_header \ 8556 .DWordLength = 0, \ 8557 ._3DCommandSubOpcode = 3, \ 8558 ._3DCommandOpcode = 1, \ 8559 .CommandSubType = 0, \ 8560 .CommandType = 3 8561 8562struct GEN8_SWTESS_BASE_ADDRESS { 8563 uint32_t DWordLength; 8564 uint32_t _3DCommandSubOpcode; 8565 uint32_t _3DCommandOpcode; 8566 uint32_t CommandSubType; 8567 uint32_t CommandType; 8568 uint32_t SWTessellationMOCS; 8569 __gen_address_type SWTessellationBaseAddress; 8570}; 8571 8572static inline void 8573GEN8_SWTESS_BASE_ADDRESS_pack(__attribute__((unused)) __gen_user_data *data, 8574 __attribute__((unused)) void * restrict dst, 8575 __attribute__((unused)) const struct GEN8_SWTESS_BASE_ADDRESS * restrict values) 8576{ 8577 uint32_t * restrict dw = (uint32_t * restrict) dst; 8578 8579 dw[0] = 8580 __gen_uint(values->DWordLength, 0, 7) | 8581 __gen_uint(values->_3DCommandSubOpcode, 16, 23) | 8582 __gen_uint(values->_3DCommandOpcode, 24, 26) | 8583 __gen_uint(values->CommandSubType, 27, 28) | 8584 __gen_uint(values->CommandType, 29, 31); 8585 8586 const uint64_t v1 = 8587 __gen_uint(values->SWTessellationMOCS, 8, 11); 8588 const uint64_t v1_address = 8589 __gen_combine_address(data, &dw[1], values->SWTessellationBaseAddress, v1); 8590 dw[1] = v1_address; 8591 dw[2] = (v1_address >> 32) | (v1 >> 32); 8592} 8593 8594#define GEN8_ACTHD_UDW_num 0x205c 8595#define GEN8_ACTHD_UDW_length 1 8596struct GEN8_ACTHD_UDW { 8597 uint32_t HeadPointerUpperDWORD; 8598}; 8599 8600static inline void 8601GEN8_ACTHD_UDW_pack(__attribute__((unused)) __gen_user_data *data, 8602 __attribute__((unused)) void * restrict dst, 8603 __attribute__((unused)) const struct GEN8_ACTHD_UDW * restrict values) 8604{ 8605 uint32_t * restrict dw = (uint32_t * restrict) dst; 8606 8607 dw[0] = 8608 __gen_uint(values->HeadPointerUpperDWORD, 0, 15); 8609} 8610 8611#define GEN8_BCS_ACTHD_UDW_num 0x2205c 8612#define GEN8_BCS_ACTHD_UDW_length 1 8613struct GEN8_BCS_ACTHD_UDW { 8614 uint32_t HeadPointerUpperDWORD; 8615}; 8616 8617static inline void 8618GEN8_BCS_ACTHD_UDW_pack(__attribute__((unused)) __gen_user_data *data, 8619 __attribute__((unused)) void * restrict dst, 8620 __attribute__((unused)) const struct GEN8_BCS_ACTHD_UDW * restrict values) 8621{ 8622 uint32_t * restrict dw = (uint32_t * restrict) dst; 8623 8624 dw[0] = 8625 __gen_uint(values->HeadPointerUpperDWORD, 0, 15); 8626} 8627 8628#define GEN8_BCS_INSTDONE_num 0x2206c 8629#define GEN8_BCS_INSTDONE_length 1 8630struct GEN8_BCS_INSTDONE { 8631 bool RingEnable; 8632 bool BlitterIDLE; 8633 bool GABIDLE; 8634 bool BCSDone; 8635}; 8636 8637static inline void 8638GEN8_BCS_INSTDONE_pack(__attribute__((unused)) __gen_user_data *data, 8639 __attribute__((unused)) void * restrict dst, 8640 __attribute__((unused)) const struct GEN8_BCS_INSTDONE * restrict values) 8641{ 8642 uint32_t * restrict dw = (uint32_t * restrict) dst; 8643 8644 dw[0] = 8645 __gen_uint(values->RingEnable, 0, 0) | 8646 __gen_uint(values->BlitterIDLE, 1, 1) | 8647 __gen_uint(values->GABIDLE, 2, 2) | 8648 __gen_uint(values->BCSDone, 3, 3); 8649} 8650 8651#define GEN8_BCS_RING_BUFFER_CTL_num 0x2203c 8652#define GEN8_BCS_RING_BUFFER_CTL_length 1 8653struct GEN8_BCS_RING_BUFFER_CTL { 8654 bool RingBufferEnable; 8655 uint32_t AutomaticReportHeadPointer; 8656#define MI_AUTOREPORT_OFF 0 8657#define MI_AUTOREPORT_64KB 1 8658#define MI_AUTOREPORT_4KB 2 8659#define MI_AUTOREPORT_128KB 3 8660 bool DisableRegisterAccesses; 8661 bool SemaphoreWait; 8662 bool RBWait; 8663 uint32_t BufferLengthinpages1; 8664}; 8665 8666static inline void 8667GEN8_BCS_RING_BUFFER_CTL_pack(__attribute__((unused)) __gen_user_data *data, 8668 __attribute__((unused)) void * restrict dst, 8669 __attribute__((unused)) const struct GEN8_BCS_RING_BUFFER_CTL * restrict values) 8670{ 8671 uint32_t * restrict dw = (uint32_t * restrict) dst; 8672 8673 dw[0] = 8674 __gen_uint(values->RingBufferEnable, 0, 0) | 8675 __gen_uint(values->AutomaticReportHeadPointer, 1, 2) | 8676 __gen_uint(values->DisableRegisterAccesses, 8, 8) | 8677 __gen_uint(values->SemaphoreWait, 10, 10) | 8678 __gen_uint(values->RBWait, 11, 11) | 8679 __gen_uint(values->BufferLengthinpages1, 12, 20); 8680} 8681 8682#define GEN8_CACHE_MODE_1_num 0x7004 8683#define GEN8_CACHE_MODE_1_length 1 8684struct GEN8_CACHE_MODE_1 { 8685 bool RCZReadafterexpansioncontrolfix2; 8686 bool DepthReadHitWriteOnlyOptimizationDisable; 8687 bool MCSCacheDisable; 8688 bool _4X4RCPFESTCOptimizationDisable; 8689 uint32_t SamplerCacheSetXORselection; 8690 uint32_t NPPMAFixEnable; 8691 uint32_t HIZEvictionPolicy; 8692 uint32_t NPEarlyZFailsDisable; 8693 uint32_t MSCResolveOptimizationDisable; 8694 bool RCZReadafterexpansioncontrolfix2Mask; 8695 bool DepthReadHitWriteOnlyOptimizationDisableMask; 8696 bool MCSCacheDisableMask; 8697 bool _4X4RCPFESTCOptimizationDisableMask; 8698 uint32_t SamplerCacheSetXORselectionMask; 8699 uint32_t NPPMAFixEnableMask; 8700 uint32_t HIZEvictionPolicyMask; 8701 uint32_t NPEarlyZFailsDisableMask; 8702 uint32_t MSCResolveOptimizationDisableMask; 8703}; 8704 8705static inline void 8706GEN8_CACHE_MODE_1_pack(__attribute__((unused)) __gen_user_data *data, 8707 __attribute__((unused)) void * restrict dst, 8708 __attribute__((unused)) const struct GEN8_CACHE_MODE_1 * restrict values) 8709{ 8710 uint32_t * restrict dw = (uint32_t * restrict) dst; 8711 8712 dw[0] = 8713 __gen_uint(values->RCZReadafterexpansioncontrolfix2, 2, 2) | 8714 __gen_uint(values->DepthReadHitWriteOnlyOptimizationDisable, 3, 3) | 8715 __gen_uint(values->MCSCacheDisable, 5, 5) | 8716 __gen_uint(values->_4X4RCPFESTCOptimizationDisable, 6, 6) | 8717 __gen_uint(values->SamplerCacheSetXORselection, 7, 8) | 8718 __gen_uint(values->NPPMAFixEnable, 11, 11) | 8719 __gen_uint(values->HIZEvictionPolicy, 12, 12) | 8720 __gen_uint(values->NPEarlyZFailsDisable, 13, 13) | 8721 __gen_uint(values->MSCResolveOptimizationDisable, 14, 14) | 8722 __gen_uint(values->RCZReadafterexpansioncontrolfix2Mask, 18, 18) | 8723 __gen_uint(values->DepthReadHitWriteOnlyOptimizationDisableMask, 19, 19) | 8724 __gen_uint(values->MCSCacheDisableMask, 21, 21) | 8725 __gen_uint(values->_4X4RCPFESTCOptimizationDisableMask, 22, 22) | 8726 __gen_uint(values->SamplerCacheSetXORselectionMask, 23, 24) | 8727 __gen_uint(values->NPPMAFixEnableMask, 27, 27) | 8728 __gen_uint(values->HIZEvictionPolicyMask, 28, 28) | 8729 __gen_uint(values->NPEarlyZFailsDisableMask, 29, 29) | 8730 __gen_uint(values->MSCResolveOptimizationDisableMask, 30, 30); 8731} 8732 8733#define GEN8_CL_INVOCATION_COUNT_num 0x2338 8734#define GEN8_CL_INVOCATION_COUNT_length 2 8735struct GEN8_CL_INVOCATION_COUNT { 8736 uint64_t CLInvocationCountReport; 8737}; 8738 8739static inline void 8740GEN8_CL_INVOCATION_COUNT_pack(__attribute__((unused)) __gen_user_data *data, 8741 __attribute__((unused)) void * restrict dst, 8742 __attribute__((unused)) const struct GEN8_CL_INVOCATION_COUNT * restrict values) 8743{ 8744 uint32_t * restrict dw = (uint32_t * restrict) dst; 8745 8746 const uint64_t v0 = 8747 __gen_uint(values->CLInvocationCountReport, 0, 63); 8748 dw[0] = v0; 8749 dw[1] = v0 >> 32; 8750} 8751 8752#define GEN8_CL_PRIMITIVES_COUNT_num 0x2340 8753#define GEN8_CL_PRIMITIVES_COUNT_length 2 8754struct GEN8_CL_PRIMITIVES_COUNT { 8755 uint64_t CLPrimitivesCountReport; 8756}; 8757 8758static inline void 8759GEN8_CL_PRIMITIVES_COUNT_pack(__attribute__((unused)) __gen_user_data *data, 8760 __attribute__((unused)) void * restrict dst, 8761 __attribute__((unused)) const struct GEN8_CL_PRIMITIVES_COUNT * restrict values) 8762{ 8763 uint32_t * restrict dw = (uint32_t * restrict) dst; 8764 8765 const uint64_t v0 = 8766 __gen_uint(values->CLPrimitivesCountReport, 0, 63); 8767 dw[0] = v0; 8768 dw[1] = v0 >> 32; 8769} 8770 8771#define GEN8_CS_INVOCATION_COUNT_num 0x2290 8772#define GEN8_CS_INVOCATION_COUNT_length 2 8773struct GEN8_CS_INVOCATION_COUNT { 8774 uint64_t CSInvocationCountReport; 8775}; 8776 8777static inline void 8778GEN8_CS_INVOCATION_COUNT_pack(__attribute__((unused)) __gen_user_data *data, 8779 __attribute__((unused)) void * restrict dst, 8780 __attribute__((unused)) const struct GEN8_CS_INVOCATION_COUNT * restrict values) 8781{ 8782 uint32_t * restrict dw = (uint32_t * restrict) dst; 8783 8784 const uint64_t v0 = 8785 __gen_uint(values->CSInvocationCountReport, 0, 63); 8786 dw[0] = v0; 8787 dw[1] = v0 >> 32; 8788} 8789 8790#define GEN8_DS_INVOCATION_COUNT_num 0x2308 8791#define GEN8_DS_INVOCATION_COUNT_length 2 8792struct GEN8_DS_INVOCATION_COUNT { 8793 uint64_t DSInvocationCountReport; 8794}; 8795 8796static inline void 8797GEN8_DS_INVOCATION_COUNT_pack(__attribute__((unused)) __gen_user_data *data, 8798 __attribute__((unused)) void * restrict dst, 8799 __attribute__((unused)) const struct GEN8_DS_INVOCATION_COUNT * restrict values) 8800{ 8801 uint32_t * restrict dw = (uint32_t * restrict) dst; 8802 8803 const uint64_t v0 = 8804 __gen_uint(values->DSInvocationCountReport, 0, 63); 8805 dw[0] = v0; 8806 dw[1] = v0 >> 32; 8807} 8808 8809#define GEN8_FAULT_REG_num 0x4094 8810#define GEN8_FAULT_REG_length 1 8811struct GEN8_FAULT_REG { 8812 bool ValidBit; 8813 uint32_t FaultType; 8814#define InvalidPTEFault 0 8815#define InvalidPDEFault 1 8816#define InvalidPDPEFault 2 8817#define InvalidPML4EFault 3 8818 uint32_t SRCIDofFault; 8819 uint32_t GTTSEL; 8820#define PPGTT 0 8821#define GGTT 1 8822 uint32_t EngineID; 8823#define GFX 0 8824#define MFX0 1 8825#define MFX1 2 8826#define VEBX 3 8827#define BLT 4 8828#define GUC 5 8829}; 8830 8831static inline void 8832GEN8_FAULT_REG_pack(__attribute__((unused)) __gen_user_data *data, 8833 __attribute__((unused)) void * restrict dst, 8834 __attribute__((unused)) const struct GEN8_FAULT_REG * restrict values) 8835{ 8836 uint32_t * restrict dw = (uint32_t * restrict) dst; 8837 8838 dw[0] = 8839 __gen_uint(values->ValidBit, 0, 0) | 8840 __gen_uint(values->FaultType, 1, 2) | 8841 __gen_uint(values->SRCIDofFault, 3, 10) | 8842 __gen_uint(values->GTTSEL, 11, 11) | 8843 __gen_uint(values->EngineID, 12, 14); 8844} 8845 8846#define GEN8_GFX_ARB_ERROR_RPT_num 0x40a0 8847#define GEN8_GFX_ARB_ERROR_RPT_length 1 8848struct GEN8_GFX_ARB_ERROR_RPT { 8849 bool TLBPageFaultError; 8850 bool RSTRMPAVPReadInvalid; 8851 bool InvalidPageDirectoryEntryError; 8852 bool ROSTRMPAVPInvalidPhysicalAddress; 8853 bool TLBPageVTDTranslationError; 8854 bool WRDPPAVPInvalid; 8855 bool PageDirectoryEntryVTDTranslationError; 8856 bool UnloadedPDError; 8857 bool GuCVTdtranslationPageFault2ndlevelUndefineddoorbell; 8858 bool NonWBmemorytypeforAdvancedContext; 8859 bool PASIDNotEnabled; 8860 bool PASIDBoundaryViolation; 8861 bool PASIDNotValid; 8862 bool PASIDWasZeroForUntranslatedRequest; 8863 bool ContextWasNotMarkedAsPresentWhenDoingDMA; 8864}; 8865 8866static inline void 8867GEN8_GFX_ARB_ERROR_RPT_pack(__attribute__((unused)) __gen_user_data *data, 8868 __attribute__((unused)) void * restrict dst, 8869 __attribute__((unused)) const struct GEN8_GFX_ARB_ERROR_RPT * restrict values) 8870{ 8871 uint32_t * restrict dw = (uint32_t * restrict) dst; 8872 8873 dw[0] = 8874 __gen_uint(values->TLBPageFaultError, 0, 0) | 8875 __gen_uint(values->RSTRMPAVPReadInvalid, 1, 1) | 8876 __gen_uint(values->InvalidPageDirectoryEntryError, 2, 2) | 8877 __gen_uint(values->ROSTRMPAVPInvalidPhysicalAddress, 3, 3) | 8878 __gen_uint(values->TLBPageVTDTranslationError, 4, 4) | 8879 __gen_uint(values->WRDPPAVPInvalid, 5, 5) | 8880 __gen_uint(values->PageDirectoryEntryVTDTranslationError, 6, 6) | 8881 __gen_uint(values->UnloadedPDError, 8, 8) | 8882 __gen_uint(values->GuCVTdtranslationPageFault2ndlevelUndefineddoorbell, 9, 9) | 8883 __gen_uint(values->NonWBmemorytypeforAdvancedContext, 10, 10) | 8884 __gen_uint(values->PASIDNotEnabled, 11, 11) | 8885 __gen_uint(values->PASIDBoundaryViolation, 12, 12) | 8886 __gen_uint(values->PASIDNotValid, 13, 13) | 8887 __gen_uint(values->PASIDWasZeroForUntranslatedRequest, 14, 14) | 8888 __gen_uint(values->ContextWasNotMarkedAsPresentWhenDoingDMA, 15, 15); 8889} 8890 8891#define GEN8_GS_INVOCATION_COUNT_num 0x2328 8892#define GEN8_GS_INVOCATION_COUNT_length 2 8893struct GEN8_GS_INVOCATION_COUNT { 8894 uint64_t GSInvocationCountReport; 8895}; 8896 8897static inline void 8898GEN8_GS_INVOCATION_COUNT_pack(__attribute__((unused)) __gen_user_data *data, 8899 __attribute__((unused)) void * restrict dst, 8900 __attribute__((unused)) const struct GEN8_GS_INVOCATION_COUNT * restrict values) 8901{ 8902 uint32_t * restrict dw = (uint32_t * restrict) dst; 8903 8904 const uint64_t v0 = 8905 __gen_uint(values->GSInvocationCountReport, 0, 63); 8906 dw[0] = v0; 8907 dw[1] = v0 >> 32; 8908} 8909 8910#define GEN8_GS_PRIMITIVES_COUNT_num 0x2330 8911#define GEN8_GS_PRIMITIVES_COUNT_length 2 8912struct GEN8_GS_PRIMITIVES_COUNT { 8913 uint64_t GSPrimitivesCountReport; 8914}; 8915 8916static inline void 8917GEN8_GS_PRIMITIVES_COUNT_pack(__attribute__((unused)) __gen_user_data *data, 8918 __attribute__((unused)) void * restrict dst, 8919 __attribute__((unused)) const struct GEN8_GS_PRIMITIVES_COUNT * restrict values) 8920{ 8921 uint32_t * restrict dw = (uint32_t * restrict) dst; 8922 8923 const uint64_t v0 = 8924 __gen_uint(values->GSPrimitivesCountReport, 0, 63); 8925 dw[0] = v0; 8926 dw[1] = v0 >> 32; 8927} 8928 8929#define GEN8_HS_INVOCATION_COUNT_num 0x2300 8930#define GEN8_HS_INVOCATION_COUNT_length 2 8931struct GEN8_HS_INVOCATION_COUNT { 8932 uint64_t HSInvocationCountReport; 8933}; 8934 8935static inline void 8936GEN8_HS_INVOCATION_COUNT_pack(__attribute__((unused)) __gen_user_data *data, 8937 __attribute__((unused)) void * restrict dst, 8938 __attribute__((unused)) const struct GEN8_HS_INVOCATION_COUNT * restrict values) 8939{ 8940 uint32_t * restrict dw = (uint32_t * restrict) dst; 8941 8942 const uint64_t v0 = 8943 __gen_uint(values->HSInvocationCountReport, 0, 63); 8944 dw[0] = v0; 8945 dw[1] = v0 >> 32; 8946} 8947 8948#define GEN8_IA_PRIMITIVES_COUNT_num 0x2318 8949#define GEN8_IA_PRIMITIVES_COUNT_length 2 8950struct GEN8_IA_PRIMITIVES_COUNT { 8951 uint64_t IAPrimitivesCountReport; 8952}; 8953 8954static inline void 8955GEN8_IA_PRIMITIVES_COUNT_pack(__attribute__((unused)) __gen_user_data *data, 8956 __attribute__((unused)) void * restrict dst, 8957 __attribute__((unused)) const struct GEN8_IA_PRIMITIVES_COUNT * restrict values) 8958{ 8959 uint32_t * restrict dw = (uint32_t * restrict) dst; 8960 8961 const uint64_t v0 = 8962 __gen_uint(values->IAPrimitivesCountReport, 0, 63); 8963 dw[0] = v0; 8964 dw[1] = v0 >> 32; 8965} 8966 8967#define GEN8_IA_VERTICES_COUNT_num 0x2310 8968#define GEN8_IA_VERTICES_COUNT_length 2 8969struct GEN8_IA_VERTICES_COUNT { 8970 uint64_t IAVerticesCountReport; 8971}; 8972 8973static inline void 8974GEN8_IA_VERTICES_COUNT_pack(__attribute__((unused)) __gen_user_data *data, 8975 __attribute__((unused)) void * restrict dst, 8976 __attribute__((unused)) const struct GEN8_IA_VERTICES_COUNT * restrict values) 8977{ 8978 uint32_t * restrict dw = (uint32_t * restrict) dst; 8979 8980 const uint64_t v0 = 8981 __gen_uint(values->IAVerticesCountReport, 0, 63); 8982 dw[0] = v0; 8983 dw[1] = v0 >> 32; 8984} 8985 8986#define GEN8_INSTDONE_1_num 0x206c 8987#define GEN8_INSTDONE_1_length 1 8988struct GEN8_INSTDONE_1 { 8989 bool PRB0RingEnable; 8990 bool VFGDone; 8991 bool VSDone; 8992 bool HSDone; 8993 bool TEDone; 8994 bool DSDone; 8995 bool GSDone; 8996 bool SOLDone; 8997 bool CLDone; 8998 bool SFDone; 8999 bool TDGDone; 9000 bool URBMDone; 9001 bool SVGDone; 9002 bool GAFSDone; 9003 bool VFEDone; 9004 bool TSGDone; 9005 bool GAFMDone; 9006 bool GAMDone; 9007 bool RSDone; 9008 bool CSDone; 9009 bool SDEDone; 9010 bool RCCFBCCSDone; 9011}; 9012 9013static inline void 9014GEN8_INSTDONE_1_pack(__attribute__((unused)) __gen_user_data *data, 9015 __attribute__((unused)) void * restrict dst, 9016 __attribute__((unused)) const struct GEN8_INSTDONE_1 * restrict values) 9017{ 9018 uint32_t * restrict dw = (uint32_t * restrict) dst; 9019 9020 dw[0] = 9021 __gen_uint(values->PRB0RingEnable, 0, 0) | 9022 __gen_uint(values->VFGDone, 1, 1) | 9023 __gen_uint(values->VSDone, 2, 2) | 9024 __gen_uint(values->HSDone, 3, 3) | 9025 __gen_uint(values->TEDone, 4, 4) | 9026 __gen_uint(values->DSDone, 5, 5) | 9027 __gen_uint(values->GSDone, 6, 6) | 9028 __gen_uint(values->SOLDone, 7, 7) | 9029 __gen_uint(values->CLDone, 8, 8) | 9030 __gen_uint(values->SFDone, 9, 9) | 9031 __gen_uint(values->TDGDone, 12, 12) | 9032 __gen_uint(values->URBMDone, 13, 13) | 9033 __gen_uint(values->SVGDone, 14, 14) | 9034 __gen_uint(values->GAFSDone, 15, 15) | 9035 __gen_uint(values->VFEDone, 16, 16) | 9036 __gen_uint(values->TSGDone, 17, 17) | 9037 __gen_uint(values->GAFMDone, 18, 18) | 9038 __gen_uint(values->GAMDone, 19, 19) | 9039 __gen_uint(values->RSDone, 20, 20) | 9040 __gen_uint(values->CSDone, 21, 21) | 9041 __gen_uint(values->SDEDone, 22, 22) | 9042 __gen_uint(values->RCCFBCCSDone, 23, 23); 9043} 9044 9045#define GEN8_INSTPM_num 0x20c0 9046#define GEN8_INSTPM_length 1 9047struct GEN8_INSTPM { 9048 bool _3DStateInstructionDisable; 9049 bool _3DRenderingInstructionDisable; 9050 bool MediaInstructionDisable; 9051 bool CONSTANT_BUFFERAddressOffsetDisable; 9052 bool _3DStateInstructionDisableMask; 9053 bool _3DRenderingInstructionDisableMask; 9054 bool MediaInstructionDisableMask; 9055 bool CONSTANT_BUFFERAddressOffsetDisableMask; 9056}; 9057 9058static inline void 9059GEN8_INSTPM_pack(__attribute__((unused)) __gen_user_data *data, 9060 __attribute__((unused)) void * restrict dst, 9061 __attribute__((unused)) const struct GEN8_INSTPM * restrict values) 9062{ 9063 uint32_t * restrict dw = (uint32_t * restrict) dst; 9064 9065 dw[0] = 9066 __gen_uint(values->_3DStateInstructionDisable, 1, 1) | 9067 __gen_uint(values->_3DRenderingInstructionDisable, 2, 2) | 9068 __gen_uint(values->MediaInstructionDisable, 3, 3) | 9069 __gen_uint(values->CONSTANT_BUFFERAddressOffsetDisable, 6, 6) | 9070 __gen_uint(values->_3DStateInstructionDisableMask, 17, 17) | 9071 __gen_uint(values->_3DRenderingInstructionDisableMask, 18, 18) | 9072 __gen_uint(values->MediaInstructionDisableMask, 19, 19) | 9073 __gen_uint(values->CONSTANT_BUFFERAddressOffsetDisableMask, 22, 22); 9074} 9075 9076#define GEN8_L3CNTLREG_num 0x7034 9077#define GEN8_L3CNTLREG_length 1 9078struct GEN8_L3CNTLREG { 9079 bool SLMEnable; 9080 uint32_t URBAllocation; 9081 uint32_t ROAllocation; 9082 uint32_t DCAllocation; 9083 uint32_t AllAllocation; 9084}; 9085 9086static inline void 9087GEN8_L3CNTLREG_pack(__attribute__((unused)) __gen_user_data *data, 9088 __attribute__((unused)) void * restrict dst, 9089 __attribute__((unused)) const struct GEN8_L3CNTLREG * restrict values) 9090{ 9091 uint32_t * restrict dw = (uint32_t * restrict) dst; 9092 9093 dw[0] = 9094 __gen_uint(values->SLMEnable, 0, 0) | 9095 __gen_uint(values->URBAllocation, 1, 7) | 9096 __gen_uint(values->ROAllocation, 11, 17) | 9097 __gen_uint(values->DCAllocation, 18, 24) | 9098 __gen_uint(values->AllAllocation, 25, 31); 9099} 9100 9101#define GEN8_PS_INVOCATION_COUNT_num 0x2348 9102#define GEN8_PS_INVOCATION_COUNT_length 2 9103struct GEN8_PS_INVOCATION_COUNT { 9104 uint64_t PSInvocationCountReport; 9105}; 9106 9107static inline void 9108GEN8_PS_INVOCATION_COUNT_pack(__attribute__((unused)) __gen_user_data *data, 9109 __attribute__((unused)) void * restrict dst, 9110 __attribute__((unused)) const struct GEN8_PS_INVOCATION_COUNT * restrict values) 9111{ 9112 uint32_t * restrict dw = (uint32_t * restrict) dst; 9113 9114 const uint64_t v0 = 9115 __gen_uint(values->PSInvocationCountReport, 0, 63); 9116 dw[0] = v0; 9117 dw[1] = v0 >> 32; 9118} 9119 9120#define GEN8_RCS_RING_BUFFER_CTL_num 0x203c 9121#define GEN8_RCS_RING_BUFFER_CTL_length 1 9122struct GEN8_RCS_RING_BUFFER_CTL { 9123 bool RingBufferEnable; 9124 uint32_t AutomaticReportHeadPointer; 9125#define MI_AUTOREPORT_OFF 0 9126#define MI_AUTOREPORT_64KB 1 9127#define MI_AUTOREPORT_4KB 2 9128#define MI_AUTOREPORT_128KB 3 9129 bool SemaphoreWait; 9130 bool RBWait; 9131 uint32_t BufferLengthinpages1; 9132}; 9133 9134static inline void 9135GEN8_RCS_RING_BUFFER_CTL_pack(__attribute__((unused)) __gen_user_data *data, 9136 __attribute__((unused)) void * restrict dst, 9137 __attribute__((unused)) const struct GEN8_RCS_RING_BUFFER_CTL * restrict values) 9138{ 9139 uint32_t * restrict dw = (uint32_t * restrict) dst; 9140 9141 dw[0] = 9142 __gen_uint(values->RingBufferEnable, 0, 0) | 9143 __gen_uint(values->AutomaticReportHeadPointer, 1, 2) | 9144 __gen_uint(values->SemaphoreWait, 10, 10) | 9145 __gen_uint(values->RBWait, 11, 11) | 9146 __gen_uint(values->BufferLengthinpages1, 12, 20); 9147} 9148 9149#define GEN8_ROW_INSTDONE_num 0xe164 9150#define GEN8_ROW_INSTDONE_length 1 9151struct GEN8_ROW_INSTDONE { 9152 bool BCDone; 9153 bool PSDDone; 9154 bool DAPRDone; 9155 bool TDLDone; 9156 bool ICDone; 9157 bool MA0Done; 9158 bool EU00DoneSS0; 9159 bool EU01DoneSS0; 9160 bool EU02DoneSS0; 9161 bool EU03DoneSS0; 9162 bool EU10DoneSS0; 9163 bool EU11DoneSS0; 9164 bool EU12DoneSS0; 9165 bool EU13DoneSS0; 9166 bool MA1DoneSS0; 9167}; 9168 9169static inline void 9170GEN8_ROW_INSTDONE_pack(__attribute__((unused)) __gen_user_data *data, 9171 __attribute__((unused)) void * restrict dst, 9172 __attribute__((unused)) const struct GEN8_ROW_INSTDONE * restrict values) 9173{ 9174 uint32_t * restrict dw = (uint32_t * restrict) dst; 9175 9176 dw[0] = 9177 __gen_uint(values->BCDone, 0, 0) | 9178 __gen_uint(values->PSDDone, 1, 1) | 9179 __gen_uint(values->DAPRDone, 3, 3) | 9180 __gen_uint(values->TDLDone, 6, 6) | 9181 __gen_uint(values->ICDone, 12, 12) | 9182 __gen_uint(values->MA0Done, 15, 15) | 9183 __gen_uint(values->EU00DoneSS0, 16, 16) | 9184 __gen_uint(values->EU01DoneSS0, 17, 17) | 9185 __gen_uint(values->EU02DoneSS0, 18, 18) | 9186 __gen_uint(values->EU03DoneSS0, 19, 19) | 9187 __gen_uint(values->EU10DoneSS0, 21, 21) | 9188 __gen_uint(values->EU11DoneSS0, 22, 22) | 9189 __gen_uint(values->EU12DoneSS0, 23, 23) | 9190 __gen_uint(values->EU13DoneSS0, 24, 24) | 9191 __gen_uint(values->MA1DoneSS0, 26, 26); 9192} 9193 9194#define GEN8_SAMPLER_INSTDONE_num 0xe160 9195#define GEN8_SAMPLER_INSTDONE_length 1 9196struct GEN8_SAMPLER_INSTDONE { 9197 bool IMEDone; 9198 bool PL0Done; 9199 bool SO0Done; 9200 bool DG0Done; 9201 bool FT0Done; 9202 bool DM0Done; 9203 bool SCDone; 9204 bool FL0Done; 9205 bool QCDone; 9206 bool SVSMDone; 9207 bool SI0Done; 9208 bool MT0Done; 9209 bool AVSDone; 9210 bool IEFDone; 9211 bool CREDone; 9212 bool SVSMARB3; 9213 bool SVSMARB2; 9214 bool SVSMARB1; 9215 bool SVSMAdapter; 9216 bool BDMDone; 9217}; 9218 9219static inline void 9220GEN8_SAMPLER_INSTDONE_pack(__attribute__((unused)) __gen_user_data *data, 9221 __attribute__((unused)) void * restrict dst, 9222 __attribute__((unused)) const struct GEN8_SAMPLER_INSTDONE * restrict values) 9223{ 9224 uint32_t * restrict dw = (uint32_t * restrict) dst; 9225 9226 dw[0] = 9227 __gen_uint(values->IMEDone, 0, 0) | 9228 __gen_uint(values->PL0Done, 1, 1) | 9229 __gen_uint(values->SO0Done, 2, 2) | 9230 __gen_uint(values->DG0Done, 3, 3) | 9231 __gen_uint(values->FT0Done, 4, 4) | 9232 __gen_uint(values->DM0Done, 5, 5) | 9233 __gen_uint(values->SCDone, 6, 6) | 9234 __gen_uint(values->FL0Done, 7, 7) | 9235 __gen_uint(values->QCDone, 8, 8) | 9236 __gen_uint(values->SVSMDone, 9, 9) | 9237 __gen_uint(values->SI0Done, 10, 10) | 9238 __gen_uint(values->MT0Done, 11, 11) | 9239 __gen_uint(values->AVSDone, 12, 12) | 9240 __gen_uint(values->IEFDone, 13, 13) | 9241 __gen_uint(values->CREDone, 14, 14) | 9242 __gen_uint(values->SVSMARB3, 15, 15) | 9243 __gen_uint(values->SVSMARB2, 16, 16) | 9244 __gen_uint(values->SVSMARB1, 17, 17) | 9245 __gen_uint(values->SVSMAdapter, 18, 18) | 9246 __gen_uint(values->BDMDone, 19, 19); 9247} 9248 9249#define GEN8_SC_INSTDONE_num 0x7100 9250#define GEN8_SC_INSTDONE_length 1 9251struct GEN8_SC_INSTDONE { 9252 bool SVLDone; 9253 bool WMFEDone; 9254 bool WMBEDone; 9255 bool HIZDone; 9256 bool STCDone; 9257 bool IZDone; 9258 bool SBEDone; 9259 bool RCZDone; 9260 bool RCCDone; 9261 bool RCPBEDone; 9262 bool RCPFEDone; 9263 bool DAPBDone; 9264 bool DAPRBEDone; 9265 bool SARBDone; 9266 bool DC0Done; 9267 bool DC1Done; 9268 bool DC2Done; 9269 bool GW0Done; 9270 bool GW1Done; 9271 bool GW2Done; 9272 bool TDCDone; 9273}; 9274 9275static inline void 9276GEN8_SC_INSTDONE_pack(__attribute__((unused)) __gen_user_data *data, 9277 __attribute__((unused)) void * restrict dst, 9278 __attribute__((unused)) const struct GEN8_SC_INSTDONE * restrict values) 9279{ 9280 uint32_t * restrict dw = (uint32_t * restrict) dst; 9281 9282 dw[0] = 9283 __gen_uint(values->SVLDone, 0, 0) | 9284 __gen_uint(values->WMFEDone, 1, 1) | 9285 __gen_uint(values->WMBEDone, 2, 2) | 9286 __gen_uint(values->HIZDone, 3, 3) | 9287 __gen_uint(values->STCDone, 4, 4) | 9288 __gen_uint(values->IZDone, 5, 5) | 9289 __gen_uint(values->SBEDone, 6, 6) | 9290 __gen_uint(values->RCZDone, 8, 8) | 9291 __gen_uint(values->RCCDone, 9, 9) | 9292 __gen_uint(values->RCPBEDone, 10, 10) | 9293 __gen_uint(values->RCPFEDone, 11, 11) | 9294 __gen_uint(values->DAPBDone, 12, 12) | 9295 __gen_uint(values->DAPRBEDone, 13, 13) | 9296 __gen_uint(values->SARBDone, 15, 15) | 9297 __gen_uint(values->DC0Done, 16, 16) | 9298 __gen_uint(values->DC1Done, 17, 17) | 9299 __gen_uint(values->DC2Done, 18, 18) | 9300 __gen_uint(values->GW0Done, 20, 20) | 9301 __gen_uint(values->GW1Done, 21, 21) | 9302 __gen_uint(values->GW2Done, 22, 22) | 9303 __gen_uint(values->TDCDone, 24, 24); 9304} 9305 9306#define GEN8_SO_NUM_PRIMS_WRITTEN0_num 0x5200 9307#define GEN8_SO_NUM_PRIMS_WRITTEN0_length 2 9308struct GEN8_SO_NUM_PRIMS_WRITTEN0 { 9309 uint64_t NumPrimsWrittenCount; 9310}; 9311 9312static inline void 9313GEN8_SO_NUM_PRIMS_WRITTEN0_pack(__attribute__((unused)) __gen_user_data *data, 9314 __attribute__((unused)) void * restrict dst, 9315 __attribute__((unused)) const struct GEN8_SO_NUM_PRIMS_WRITTEN0 * restrict values) 9316{ 9317 uint32_t * restrict dw = (uint32_t * restrict) dst; 9318 9319 const uint64_t v0 = 9320 __gen_uint(values->NumPrimsWrittenCount, 0, 63); 9321 dw[0] = v0; 9322 dw[1] = v0 >> 32; 9323} 9324 9325#define GEN8_SO_NUM_PRIMS_WRITTEN1_num 0x5208 9326#define GEN8_SO_NUM_PRIMS_WRITTEN1_length 2 9327struct GEN8_SO_NUM_PRIMS_WRITTEN1 { 9328 uint64_t NumPrimsWrittenCount; 9329}; 9330 9331static inline void 9332GEN8_SO_NUM_PRIMS_WRITTEN1_pack(__attribute__((unused)) __gen_user_data *data, 9333 __attribute__((unused)) void * restrict dst, 9334 __attribute__((unused)) const struct GEN8_SO_NUM_PRIMS_WRITTEN1 * restrict values) 9335{ 9336 uint32_t * restrict dw = (uint32_t * restrict) dst; 9337 9338 const uint64_t v0 = 9339 __gen_uint(values->NumPrimsWrittenCount, 0, 63); 9340 dw[0] = v0; 9341 dw[1] = v0 >> 32; 9342} 9343 9344#define GEN8_SO_NUM_PRIMS_WRITTEN2_num 0x5210 9345#define GEN8_SO_NUM_PRIMS_WRITTEN2_length 2 9346struct GEN8_SO_NUM_PRIMS_WRITTEN2 { 9347 uint64_t NumPrimsWrittenCount; 9348}; 9349 9350static inline void 9351GEN8_SO_NUM_PRIMS_WRITTEN2_pack(__attribute__((unused)) __gen_user_data *data, 9352 __attribute__((unused)) void * restrict dst, 9353 __attribute__((unused)) const struct GEN8_SO_NUM_PRIMS_WRITTEN2 * restrict values) 9354{ 9355 uint32_t * restrict dw = (uint32_t * restrict) dst; 9356 9357 const uint64_t v0 = 9358 __gen_uint(values->NumPrimsWrittenCount, 0, 63); 9359 dw[0] = v0; 9360 dw[1] = v0 >> 32; 9361} 9362 9363#define GEN8_SO_NUM_PRIMS_WRITTEN3_num 0x5218 9364#define GEN8_SO_NUM_PRIMS_WRITTEN3_length 2 9365struct GEN8_SO_NUM_PRIMS_WRITTEN3 { 9366 uint64_t NumPrimsWrittenCount; 9367}; 9368 9369static inline void 9370GEN8_SO_NUM_PRIMS_WRITTEN3_pack(__attribute__((unused)) __gen_user_data *data, 9371 __attribute__((unused)) void * restrict dst, 9372 __attribute__((unused)) const struct GEN8_SO_NUM_PRIMS_WRITTEN3 * restrict values) 9373{ 9374 uint32_t * restrict dw = (uint32_t * restrict) dst; 9375 9376 const uint64_t v0 = 9377 __gen_uint(values->NumPrimsWrittenCount, 0, 63); 9378 dw[0] = v0; 9379 dw[1] = v0 >> 32; 9380} 9381 9382#define GEN8_SO_PRIM_STORAGE_NEEDED0_num 0x5240 9383#define GEN8_SO_PRIM_STORAGE_NEEDED0_length 2 9384struct GEN8_SO_PRIM_STORAGE_NEEDED0 { 9385 uint64_t PrimStorageNeededCount; 9386}; 9387 9388static inline void 9389GEN8_SO_PRIM_STORAGE_NEEDED0_pack(__attribute__((unused)) __gen_user_data *data, 9390 __attribute__((unused)) void * restrict dst, 9391 __attribute__((unused)) const struct GEN8_SO_PRIM_STORAGE_NEEDED0 * restrict values) 9392{ 9393 uint32_t * restrict dw = (uint32_t * restrict) dst; 9394 9395 const uint64_t v0 = 9396 __gen_uint(values->PrimStorageNeededCount, 0, 63); 9397 dw[0] = v0; 9398 dw[1] = v0 >> 32; 9399} 9400 9401#define GEN8_SO_PRIM_STORAGE_NEEDED1_num 0x5248 9402#define GEN8_SO_PRIM_STORAGE_NEEDED1_length 2 9403struct GEN8_SO_PRIM_STORAGE_NEEDED1 { 9404 uint64_t PrimStorageNeededCount; 9405}; 9406 9407static inline void 9408GEN8_SO_PRIM_STORAGE_NEEDED1_pack(__attribute__((unused)) __gen_user_data *data, 9409 __attribute__((unused)) void * restrict dst, 9410 __attribute__((unused)) const struct GEN8_SO_PRIM_STORAGE_NEEDED1 * restrict values) 9411{ 9412 uint32_t * restrict dw = (uint32_t * restrict) dst; 9413 9414 const uint64_t v0 = 9415 __gen_uint(values->PrimStorageNeededCount, 0, 63); 9416 dw[0] = v0; 9417 dw[1] = v0 >> 32; 9418} 9419 9420#define GEN8_SO_PRIM_STORAGE_NEEDED2_num 0x5250 9421#define GEN8_SO_PRIM_STORAGE_NEEDED2_length 2 9422struct GEN8_SO_PRIM_STORAGE_NEEDED2 { 9423 uint64_t PrimStorageNeededCount; 9424}; 9425 9426static inline void 9427GEN8_SO_PRIM_STORAGE_NEEDED2_pack(__attribute__((unused)) __gen_user_data *data, 9428 __attribute__((unused)) void * restrict dst, 9429 __attribute__((unused)) const struct GEN8_SO_PRIM_STORAGE_NEEDED2 * restrict values) 9430{ 9431 uint32_t * restrict dw = (uint32_t * restrict) dst; 9432 9433 const uint64_t v0 = 9434 __gen_uint(values->PrimStorageNeededCount, 0, 63); 9435 dw[0] = v0; 9436 dw[1] = v0 >> 32; 9437} 9438 9439#define GEN8_SO_PRIM_STORAGE_NEEDED3_num 0x5258 9440#define GEN8_SO_PRIM_STORAGE_NEEDED3_length 2 9441struct GEN8_SO_PRIM_STORAGE_NEEDED3 { 9442 uint64_t PrimStorageNeededCount; 9443}; 9444 9445static inline void 9446GEN8_SO_PRIM_STORAGE_NEEDED3_pack(__attribute__((unused)) __gen_user_data *data, 9447 __attribute__((unused)) void * restrict dst, 9448 __attribute__((unused)) const struct GEN8_SO_PRIM_STORAGE_NEEDED3 * restrict values) 9449{ 9450 uint32_t * restrict dw = (uint32_t * restrict) dst; 9451 9452 const uint64_t v0 = 9453 __gen_uint(values->PrimStorageNeededCount, 0, 63); 9454 dw[0] = v0; 9455 dw[1] = v0 >> 32; 9456} 9457 9458#define GEN8_SO_WRITE_OFFSET0_num 0x5280 9459#define GEN8_SO_WRITE_OFFSET0_length 1 9460struct GEN8_SO_WRITE_OFFSET0 { 9461 uint64_t WriteOffset; 9462}; 9463 9464static inline void 9465GEN8_SO_WRITE_OFFSET0_pack(__attribute__((unused)) __gen_user_data *data, 9466 __attribute__((unused)) void * restrict dst, 9467 __attribute__((unused)) const struct GEN8_SO_WRITE_OFFSET0 * restrict values) 9468{ 9469 uint32_t * restrict dw = (uint32_t * restrict) dst; 9470 9471 dw[0] = 9472 __gen_offset(values->WriteOffset, 2, 31); 9473} 9474 9475#define GEN8_SO_WRITE_OFFSET1_num 0x5284 9476#define GEN8_SO_WRITE_OFFSET1_length 1 9477struct GEN8_SO_WRITE_OFFSET1 { 9478 uint64_t WriteOffset; 9479}; 9480 9481static inline void 9482GEN8_SO_WRITE_OFFSET1_pack(__attribute__((unused)) __gen_user_data *data, 9483 __attribute__((unused)) void * restrict dst, 9484 __attribute__((unused)) const struct GEN8_SO_WRITE_OFFSET1 * restrict values) 9485{ 9486 uint32_t * restrict dw = (uint32_t * restrict) dst; 9487 9488 dw[0] = 9489 __gen_offset(values->WriteOffset, 2, 31); 9490} 9491 9492#define GEN8_SO_WRITE_OFFSET2_num 0x5288 9493#define GEN8_SO_WRITE_OFFSET2_length 1 9494struct GEN8_SO_WRITE_OFFSET2 { 9495 uint64_t WriteOffset; 9496}; 9497 9498static inline void 9499GEN8_SO_WRITE_OFFSET2_pack(__attribute__((unused)) __gen_user_data *data, 9500 __attribute__((unused)) void * restrict dst, 9501 __attribute__((unused)) const struct GEN8_SO_WRITE_OFFSET2 * restrict values) 9502{ 9503 uint32_t * restrict dw = (uint32_t * restrict) dst; 9504 9505 dw[0] = 9506 __gen_offset(values->WriteOffset, 2, 31); 9507} 9508 9509#define GEN8_SO_WRITE_OFFSET3_num 0x528c 9510#define GEN8_SO_WRITE_OFFSET3_length 1 9511struct GEN8_SO_WRITE_OFFSET3 { 9512 uint64_t WriteOffset; 9513}; 9514 9515static inline void 9516GEN8_SO_WRITE_OFFSET3_pack(__attribute__((unused)) __gen_user_data *data, 9517 __attribute__((unused)) void * restrict dst, 9518 __attribute__((unused)) const struct GEN8_SO_WRITE_OFFSET3 * restrict values) 9519{ 9520 uint32_t * restrict dw = (uint32_t * restrict) dst; 9521 9522 dw[0] = 9523 __gen_offset(values->WriteOffset, 2, 31); 9524} 9525 9526#define GEN8_VCS2_RING_BUFFER_CTL_num 0x1203c 9527#define GEN8_VCS2_RING_BUFFER_CTL_length 1 9528struct GEN8_VCS2_RING_BUFFER_CTL { 9529 bool RingBufferEnable; 9530 uint32_t AutomaticReportHeadPointer; 9531#define MI_AUTOREPORT_OFF 0 9532#define MI_AUTOREPORT_64KB 1 9533#define MI_AUTOREPORT_4KB 2 9534#define MI_AUTOREPORT_128KB 3 9535 bool DisableRegisterAccesses; 9536 bool SemaphoreWait; 9537 bool RBWait; 9538 uint32_t BufferLengthinpages1; 9539}; 9540 9541static inline void 9542GEN8_VCS2_RING_BUFFER_CTL_pack(__attribute__((unused)) __gen_user_data *data, 9543 __attribute__((unused)) void * restrict dst, 9544 __attribute__((unused)) const struct GEN8_VCS2_RING_BUFFER_CTL * restrict values) 9545{ 9546 uint32_t * restrict dw = (uint32_t * restrict) dst; 9547 9548 dw[0] = 9549 __gen_uint(values->RingBufferEnable, 0, 0) | 9550 __gen_uint(values->AutomaticReportHeadPointer, 1, 2) | 9551 __gen_uint(values->DisableRegisterAccesses, 8, 8) | 9552 __gen_uint(values->SemaphoreWait, 10, 10) | 9553 __gen_uint(values->RBWait, 11, 11) | 9554 __gen_uint(values->BufferLengthinpages1, 12, 20); 9555} 9556 9557#define GEN8_VCS_ACTHD_UDW_num 0x1205c 9558#define GEN8_VCS_ACTHD_UDW_length 1 9559struct GEN8_VCS_ACTHD_UDW { 9560 uint32_t HeadPointerUpperDWORD; 9561}; 9562 9563static inline void 9564GEN8_VCS_ACTHD_UDW_pack(__attribute__((unused)) __gen_user_data *data, 9565 __attribute__((unused)) void * restrict dst, 9566 __attribute__((unused)) const struct GEN8_VCS_ACTHD_UDW * restrict values) 9567{ 9568 uint32_t * restrict dw = (uint32_t * restrict) dst; 9569 9570 dw[0] = 9571 __gen_uint(values->HeadPointerUpperDWORD, 0, 15); 9572} 9573 9574#define GEN8_VCS_INSTDONE_num 0x1206c 9575#define GEN8_VCS_INSTDONE_length 1 9576struct GEN8_VCS_INSTDONE { 9577 bool RingEnable; 9578 bool USBDone; 9579 bool QRCDone; 9580 bool SECDone; 9581 bool MPCDone; 9582 bool VFTDone; 9583 bool BSPDone; 9584 bool VLFDone; 9585 bool VOPDone; 9586 bool VMCDone; 9587 bool VIPDone; 9588 bool VITDone; 9589 bool VDSDone; 9590 bool VMXDone; 9591 bool VCPDone; 9592 bool VCDDone; 9593 bool VADDone; 9594 bool VMDDone; 9595 bool VISDone; 9596 bool VACDone; 9597 bool VAMDone; 9598 bool JPGDone; 9599 bool VBPDone; 9600 bool VHRDone; 9601 bool VCIDone; 9602 bool VCRDone; 9603 bool VINDone; 9604 bool VPRDone; 9605 bool VTQDone; 9606 bool Reserved; 9607 bool VCSDone; 9608 bool GACDone; 9609}; 9610 9611static inline void 9612GEN8_VCS_INSTDONE_pack(__attribute__((unused)) __gen_user_data *data, 9613 __attribute__((unused)) void * restrict dst, 9614 __attribute__((unused)) const struct GEN8_VCS_INSTDONE * restrict values) 9615{ 9616 uint32_t * restrict dw = (uint32_t * restrict) dst; 9617 9618 dw[0] = 9619 __gen_uint(values->RingEnable, 0, 0) | 9620 __gen_uint(values->USBDone, 1, 1) | 9621 __gen_uint(values->QRCDone, 2, 2) | 9622 __gen_uint(values->SECDone, 3, 3) | 9623 __gen_uint(values->MPCDone, 4, 4) | 9624 __gen_uint(values->VFTDone, 5, 5) | 9625 __gen_uint(values->BSPDone, 6, 6) | 9626 __gen_uint(values->VLFDone, 7, 7) | 9627 __gen_uint(values->VOPDone, 8, 8) | 9628 __gen_uint(values->VMCDone, 9, 9) | 9629 __gen_uint(values->VIPDone, 10, 10) | 9630 __gen_uint(values->VITDone, 11, 11) | 9631 __gen_uint(values->VDSDone, 12, 12) | 9632 __gen_uint(values->VMXDone, 13, 13) | 9633 __gen_uint(values->VCPDone, 14, 14) | 9634 __gen_uint(values->VCDDone, 15, 15) | 9635 __gen_uint(values->VADDone, 16, 16) | 9636 __gen_uint(values->VMDDone, 17, 17) | 9637 __gen_uint(values->VISDone, 18, 18) | 9638 __gen_uint(values->VACDone, 19, 19) | 9639 __gen_uint(values->VAMDone, 20, 20) | 9640 __gen_uint(values->JPGDone, 21, 21) | 9641 __gen_uint(values->VBPDone, 22, 22) | 9642 __gen_uint(values->VHRDone, 23, 23) | 9643 __gen_uint(values->VCIDone, 24, 24) | 9644 __gen_uint(values->VCRDone, 25, 25) | 9645 __gen_uint(values->VINDone, 26, 26) | 9646 __gen_uint(values->VPRDone, 27, 27) | 9647 __gen_uint(values->VTQDone, 28, 28) | 9648 __gen_uint(values->Reserved, 29, 29) | 9649 __gen_uint(values->VCSDone, 30, 30) | 9650 __gen_uint(values->GACDone, 31, 31); 9651} 9652 9653#define GEN8_VCS_RING_BUFFER_CTL_num 0x1203c 9654#define GEN8_VCS_RING_BUFFER_CTL_length 1 9655struct GEN8_VCS_RING_BUFFER_CTL { 9656 bool RingBufferEnable; 9657 uint32_t AutomaticReportHeadPointer; 9658#define MI_AUTOREPORT_OFF 0 9659#define MI_AUTOREPORT_64KB 1 9660#define MI_AUTOREPORT_4KB 2 9661#define MI_AUTOREPORT_128KB 3 9662 bool DisableRegisterAccesses; 9663 bool SemaphoreWait; 9664 bool RBWait; 9665 uint32_t BufferLengthinpages1; 9666}; 9667 9668static inline void 9669GEN8_VCS_RING_BUFFER_CTL_pack(__attribute__((unused)) __gen_user_data *data, 9670 __attribute__((unused)) void * restrict dst, 9671 __attribute__((unused)) const struct GEN8_VCS_RING_BUFFER_CTL * restrict values) 9672{ 9673 uint32_t * restrict dw = (uint32_t * restrict) dst; 9674 9675 dw[0] = 9676 __gen_uint(values->RingBufferEnable, 0, 0) | 9677 __gen_uint(values->AutomaticReportHeadPointer, 1, 2) | 9678 __gen_uint(values->DisableRegisterAccesses, 8, 8) | 9679 __gen_uint(values->SemaphoreWait, 10, 10) | 9680 __gen_uint(values->RBWait, 11, 11) | 9681 __gen_uint(values->BufferLengthinpages1, 12, 20); 9682} 9683 9684#define GEN8_VECS_ACTHD_UDW_num 0x1a05c 9685#define GEN8_VECS_ACTHD_UDW_length 1 9686struct GEN8_VECS_ACTHD_UDW { 9687 uint32_t HeadPointerUpperDWORD; 9688}; 9689 9690static inline void 9691GEN8_VECS_ACTHD_UDW_pack(__attribute__((unused)) __gen_user_data *data, 9692 __attribute__((unused)) void * restrict dst, 9693 __attribute__((unused)) const struct GEN8_VECS_ACTHD_UDW * restrict values) 9694{ 9695 uint32_t * restrict dw = (uint32_t * restrict) dst; 9696 9697 dw[0] = 9698 __gen_uint(values->HeadPointerUpperDWORD, 0, 15); 9699} 9700 9701#define GEN8_VECS_INSTDONE_num 0x1a06c 9702#define GEN8_VECS_INSTDONE_length 1 9703struct GEN8_VECS_INSTDONE { 9704 bool RingEnable; 9705 bool VECSDone; 9706 bool GAMDone; 9707}; 9708 9709static inline void 9710GEN8_VECS_INSTDONE_pack(__attribute__((unused)) __gen_user_data *data, 9711 __attribute__((unused)) void * restrict dst, 9712 __attribute__((unused)) const struct GEN8_VECS_INSTDONE * restrict values) 9713{ 9714 uint32_t * restrict dw = (uint32_t * restrict) dst; 9715 9716 dw[0] = 9717 __gen_uint(values->RingEnable, 0, 0) | 9718 __gen_uint(values->VECSDone, 30, 30) | 9719 __gen_uint(values->GAMDone, 31, 31); 9720} 9721 9722#define GEN8_VECS_RING_BUFFER_CTL_num 0x1a03c 9723#define GEN8_VECS_RING_BUFFER_CTL_length 1 9724struct GEN8_VECS_RING_BUFFER_CTL { 9725 bool RingBufferEnable; 9726 uint32_t AutomaticReportHeadPointer; 9727#define MI_AUTOREPORT_OFF 0 9728#define MI_AUTOREPORT_64KB 1 9729#define MI_AUTOREPORT_4KB 2 9730#define MI_AUTOREPORT_128KB 3 9731 bool DisableRegisterAccesses; 9732 bool SemaphoreWait; 9733 bool RBWait; 9734 uint32_t BufferLengthinpages1; 9735}; 9736 9737static inline void 9738GEN8_VECS_RING_BUFFER_CTL_pack(__attribute__((unused)) __gen_user_data *data, 9739 __attribute__((unused)) void * restrict dst, 9740 __attribute__((unused)) const struct GEN8_VECS_RING_BUFFER_CTL * restrict values) 9741{ 9742 uint32_t * restrict dw = (uint32_t * restrict) dst; 9743 9744 dw[0] = 9745 __gen_uint(values->RingBufferEnable, 0, 0) | 9746 __gen_uint(values->AutomaticReportHeadPointer, 1, 2) | 9747 __gen_uint(values->DisableRegisterAccesses, 8, 8) | 9748 __gen_uint(values->SemaphoreWait, 10, 10) | 9749 __gen_uint(values->RBWait, 11, 11) | 9750 __gen_uint(values->BufferLengthinpages1, 12, 20); 9751} 9752 9753#define GEN8_VS_INVOCATION_COUNT_num 0x2320 9754#define GEN8_VS_INVOCATION_COUNT_length 2 9755struct GEN8_VS_INVOCATION_COUNT { 9756 uint64_t VSInvocationCountReport; 9757}; 9758 9759static inline void 9760GEN8_VS_INVOCATION_COUNT_pack(__attribute__((unused)) __gen_user_data *data, 9761 __attribute__((unused)) void * restrict dst, 9762 __attribute__((unused)) const struct GEN8_VS_INVOCATION_COUNT * restrict values) 9763{ 9764 uint32_t * restrict dw = (uint32_t * restrict) dst; 9765 9766 const uint64_t v0 = 9767 __gen_uint(values->VSInvocationCountReport, 0, 63); 9768 dw[0] = v0; 9769 dw[1] = v0 >> 32; 9770} 9771 9772#endif /* GEN8_PACK_H */ 9773