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