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