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