2 * Copyright © 2016 Intel Corporation
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:
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
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
24 #ifndef BLORP_GENX_EXEC_H
25 #define BLORP_GENX_EXEC_H
27 #include "blorp_priv.h"
28 #include "dev/gen_device_info.h"
29 #include "common/gen_sample_positions.h"
30 #include "genxml/gen_macros.h"
33 * This file provides the blorp pipeline setup and execution functionality.
34 * It defines the following function:
37 * blorp_exec(struct blorp_context *blorp, void *batch_data,
38 * const struct blorp_params *params);
40 * It is the job of whoever includes this header to wrap this in something
41 * to get an externally visible symbol.
43 * In order for the blorp_exec function to work, the driver must provide
44 * implementations of the following static helper functions.
48 blorp_emit_dwords(struct blorp_batch
*batch
, unsigned n
);
51 blorp_emit_reloc(struct blorp_batch
*batch
,
52 void *location
, struct blorp_address address
, uint32_t delta
);
55 blorp_alloc_dynamic_state(struct blorp_batch
*batch
,
60 blorp_alloc_vertex_buffer(struct blorp_batch
*batch
, uint32_t size
,
61 struct blorp_address
*addr
);
64 static struct blorp_address
65 blorp_get_workaround_page(struct blorp_batch
*batch
);
69 blorp_alloc_binding_table(struct blorp_batch
*batch
, unsigned num_entries
,
70 unsigned state_size
, unsigned state_alignment
,
71 uint32_t *bt_offset
, uint32_t *surface_offsets
,
75 blorp_flush_range(struct blorp_batch
*batch
, void *start
, size_t size
);
78 blorp_surface_reloc(struct blorp_batch
*batch
, uint32_t ss_offset
,
79 struct blorp_address address
, uint32_t delta
);
82 static struct blorp_address
83 blorp_get_surface_base_address(struct blorp_batch
*batch
);
87 blorp_emit_urb_config(struct blorp_batch
*batch
,
88 unsigned vs_entry_size
, unsigned sf_entry_size
);
91 blorp_emit_pipeline(struct blorp_batch
*batch
,
92 const struct blorp_params
*params
);
94 /***** BEGIN blorp_exec implementation ******/
97 _blorp_combine_address(struct blorp_batch
*batch
, void *location
,
98 struct blorp_address address
, uint32_t delta
)
100 if (address
.buffer
== NULL
) {
101 return address
.offset
+ delta
;
103 return blorp_emit_reloc(batch
, location
, address
, delta
);
107 #define __gen_address_type struct blorp_address
108 #define __gen_user_data struct blorp_batch
109 #define __gen_combine_address _blorp_combine_address
111 #include "genxml/genX_pack.h"
113 #define _blorp_cmd_length(cmd) cmd ## _length
114 #define _blorp_cmd_length_bias(cmd) cmd ## _length_bias
115 #define _blorp_cmd_header(cmd) cmd ## _header
116 #define _blorp_cmd_pack(cmd) cmd ## _pack
118 #define blorp_emit(batch, cmd, name) \
119 for (struct cmd name = { _blorp_cmd_header(cmd) }, \
120 *_dst = blorp_emit_dwords(batch, _blorp_cmd_length(cmd)); \
121 __builtin_expect(_dst != NULL, 1); \
122 _blorp_cmd_pack(cmd)(batch, (void *)_dst, &name), \
125 #define blorp_emitn(batch, cmd, n) ({ \
126 uint32_t *_dw = blorp_emit_dwords(batch, n); \
128 struct cmd template = { \
129 _blorp_cmd_header(cmd), \
130 .DWordLength = n - _blorp_cmd_length_bias(cmd), \
132 _blorp_cmd_pack(cmd)(batch, _dw, &template); \
134 _dw ? _dw + 1 : NULL; /* Array starts at dw[1] */ \
137 #define STRUCT_ZERO(S) ({ struct S t; memset(&t, 0, sizeof(t)); t; })
139 #define blorp_emit_dynamic(batch, state, name, align, offset) \
140 for (struct state name = STRUCT_ZERO(state), \
141 *_dst = blorp_alloc_dynamic_state(batch, \
142 _blorp_cmd_length(state) * 4, \
144 __builtin_expect(_dst != NULL, 1); \
145 _blorp_cmd_pack(state)(batch, (void *)_dst, &name), \
146 blorp_flush_range(batch, _dst, _blorp_cmd_length(state) * 4), \
155 * Assign the entire URB to the VS. Even though the VS disabled, URB space
156 * is still needed because the clipper loads the VUE's from the URB. From
157 * the Sandybridge PRM, Volume 2, Part 1, Section 3DSTATE,
158 * Dword 1.15:0 "VS Number of URB Entries":
159 * This field is always used (even if VS Function Enable is DISABLED).
161 * The warning below appears in the PRM (Section 3DSTATE_URB), but we can
162 * safely ignore it because this batch contains only one draw call.
163 * Because of URB corruption caused by allocating a previous GS unit
164 * URB entry to the VS unit, software is required to send a “GS NULL
165 * Fence” (Send URB fence with VS URB size == 1 and GS URB size == 0)
166 * plus a dummy DRAW call before any case where VS will be taking over
169 * If the 3DSTATE_URB_VS is emitted, than the others must be also.
170 * From the Ivybridge PRM, Volume 2 Part 1, section 1.7.1 3DSTATE_URB_VS:
172 * 3DSTATE_URB_HS, 3DSTATE_URB_DS, and 3DSTATE_URB_GS must also be
173 * programmed in order for the programming of this state to be
177 emit_urb_config(struct blorp_batch
*batch
,
178 const struct blorp_params
*params
)
180 /* Once vertex fetcher has written full VUE entries with complete
181 * header the space requirement is as follows per vertex (in bytes):
183 * Header Position Program constants
184 * +--------+------------+-------------------+
185 * | 16 | 16 | n x 16 |
186 * +--------+------------+-------------------+
188 * where 'n' stands for number of varying inputs expressed as vec4s.
190 const unsigned num_varyings
=
191 params
->wm_prog_data
? params
->wm_prog_data
->num_varying_inputs
: 0;
192 const unsigned total_needed
= 16 + 16 + num_varyings
* 16;
194 /* The URB size is expressed in units of 64 bytes (512 bits) */
195 const unsigned vs_entry_size
= DIV_ROUND_UP(total_needed
, 64);
197 const unsigned sf_entry_size
=
198 params
->sf_prog_data
? params
->sf_prog_data
->urb_entry_size
: 0;
200 blorp_emit_urb_config(batch
, vs_entry_size
, sf_entry_size
);
204 blorp_emit_vertex_data(struct blorp_batch
*batch
,
205 const struct blorp_params
*params
,
206 struct blorp_address
*addr
,
209 const float vertices
[] = {
210 /* v0 */ (float)params
->x1
, (float)params
->y1
, params
->z
,
211 /* v1 */ (float)params
->x0
, (float)params
->y1
, params
->z
,
212 /* v2 */ (float)params
->x0
, (float)params
->y0
, params
->z
,
215 void *data
= blorp_alloc_vertex_buffer(batch
, sizeof(vertices
), addr
);
216 memcpy(data
, vertices
, sizeof(vertices
));
217 *size
= sizeof(vertices
);
218 blorp_flush_range(batch
, data
, *size
);
222 blorp_emit_input_varying_data(struct blorp_batch
*batch
,
223 const struct blorp_params
*params
,
224 struct blorp_address
*addr
,
227 const unsigned vec4_size_in_bytes
= 4 * sizeof(float);
228 const unsigned max_num_varyings
=
229 DIV_ROUND_UP(sizeof(params
->wm_inputs
), vec4_size_in_bytes
);
230 const unsigned num_varyings
=
231 params
->wm_prog_data
? params
->wm_prog_data
->num_varying_inputs
: 0;
233 *size
= 16 + num_varyings
* vec4_size_in_bytes
;
235 const uint32_t *const inputs_src
= (const uint32_t *)¶ms
->wm_inputs
;
236 void *data
= blorp_alloc_vertex_buffer(batch
, *size
, addr
);
237 uint32_t *inputs
= data
;
239 /* Copy in the VS inputs */
240 assert(sizeof(params
->vs_inputs
) == 16);
241 memcpy(inputs
, ¶ms
->vs_inputs
, sizeof(params
->vs_inputs
));
244 if (params
->wm_prog_data
) {
245 /* Walk over the attribute slots, determine if the attribute is used by
246 * the program and when necessary copy the values from the input storage
247 * to the vertex data buffer.
249 for (unsigned i
= 0; i
< max_num_varyings
; i
++) {
250 const gl_varying_slot attr
= VARYING_SLOT_VAR0
+ i
;
252 const int input_index
= params
->wm_prog_data
->urb_setup
[attr
];
256 memcpy(inputs
, inputs_src
+ i
* 4, vec4_size_in_bytes
);
262 blorp_flush_range(batch
, data
, *size
);
266 blorp_fill_vertex_buffer_state(struct blorp_batch
*batch
,
267 struct GENX(VERTEX_BUFFER_STATE
) *vb
,
269 struct blorp_address addr
, uint32_t size
,
272 vb
[idx
].VertexBufferIndex
= idx
;
273 vb
[idx
].BufferStartingAddress
= addr
;
274 vb
[idx
].BufferPitch
= stride
;
277 vb
[idx
].VertexBufferMOCS
= addr
.mocs
;
281 vb
[idx
].AddressModifyEnable
= true;
285 vb
[idx
].BufferSize
= size
;
287 vb
[idx
].BufferAccessType
= stride
> 0 ? VERTEXDATA
: INSTANCEDATA
;
288 vb
[idx
].EndAddress
= vb
[idx
].BufferStartingAddress
;
289 vb
[idx
].EndAddress
.offset
+= size
- 1;
291 vb
[idx
].BufferAccessType
= stride
> 0 ? VERTEXDATA
: INSTANCEDATA
;
292 vb
[idx
].MaxIndex
= stride
> 0 ? size
/ stride
: 0;
297 blorp_emit_vertex_buffers(struct blorp_batch
*batch
,
298 const struct blorp_params
*params
)
300 struct GENX(VERTEX_BUFFER_STATE
) vb
[3];
301 memset(vb
, 0, sizeof(vb
));
303 struct blorp_address addr
;
305 blorp_emit_vertex_data(batch
, params
, &addr
, &size
);
306 blorp_fill_vertex_buffer_state(batch
, vb
, 0, addr
, size
, 3 * sizeof(float));
308 blorp_emit_input_varying_data(batch
, params
, &addr
, &size
);
309 blorp_fill_vertex_buffer_state(batch
, vb
, 1, addr
, size
, 0);
311 uint32_t num_vbs
= 2;
312 if (params
->dst_clear_color_as_input
) {
313 blorp_fill_vertex_buffer_state(batch
, vb
, num_vbs
++,
314 params
->dst
.clear_color_addr
,
315 batch
->blorp
->isl_dev
->ss
.clear_value_size
,
319 const unsigned num_dwords
= 1 + num_vbs
* GENX(VERTEX_BUFFER_STATE_length
);
320 uint32_t *dw
= blorp_emitn(batch
, GENX(3DSTATE_VERTEX_BUFFERS
), num_dwords
);
324 for (unsigned i
= 0; i
< num_vbs
; i
++) {
325 GENX(VERTEX_BUFFER_STATE_pack
)(batch
, dw
, &vb
[i
]);
326 dw
+= GENX(VERTEX_BUFFER_STATE_length
);
331 blorp_emit_vertex_elements(struct blorp_batch
*batch
,
332 const struct blorp_params
*params
)
334 const unsigned num_varyings
=
335 params
->wm_prog_data
? params
->wm_prog_data
->num_varying_inputs
: 0;
336 bool need_ndc
= batch
->blorp
->compiler
->devinfo
->gen
<= 5;
337 const unsigned num_elements
= 2 + need_ndc
+ num_varyings
;
339 struct GENX(VERTEX_ELEMENT_STATE
) ve
[num_elements
];
340 memset(ve
, 0, num_elements
* sizeof(*ve
));
342 /* Setup VBO for the rectangle primitive..
344 * A rectangle primitive (3DPRIM_RECTLIST) consists of only three
345 * vertices. The vertices reside in screen space with DirectX
346 * coordinates (that is, (0, 0) is the upper left corner).
353 * Since the VS is disabled, the clipper loads each VUE directly from
354 * the URB. This is controlled by the 3DSTATE_VERTEX_BUFFERS and
355 * 3DSTATE_VERTEX_ELEMENTS packets below. The VUE contents are as follows:
356 * dw0: Reserved, MBZ.
357 * dw1: Render Target Array Index. Below vertex fetcher gets programmed
358 * to assign this with primitive instance identifier which will be
359 * used for layered clears. All other renders have only one instance
360 * and therefore the value will be effectively zero.
361 * dw2: Viewport Index. The HiZ op disables viewport mapping and
362 * scissoring, so set the dword to 0.
363 * dw3: Point Width: The HiZ op does not emit the POINTLIST primitive,
364 * so set the dword to 0.
365 * dw4: Vertex Position X.
366 * dw5: Vertex Position Y.
367 * dw6: Vertex Position Z.
368 * dw7: Vertex Position W.
370 * dw8: Flat vertex input 0
371 * dw9: Flat vertex input 1
373 * dwn: Flat vertex input n - 8
375 * For details, see the Sandybridge PRM, Volume 2, Part 1, Section 1.5.1
376 * "Vertex URB Entry (VUE) Formats".
378 * Only vertex position X and Y are going to be variable, Z is fixed to
379 * zero and W to one. Header words dw0,2,3 are zero. There is no need to
380 * include the fixed values in the vertex buffer. Vertex fetcher can be
381 * instructed to fill vertex elements with constant values of one and zero
382 * instead of reading them from the buffer.
383 * Flat inputs are program constants that are not interpolated. Moreover
384 * their values will be the same between vertices.
386 * See the vertex element setup below.
390 ve
[slot
] = (struct GENX(VERTEX_ELEMENT_STATE
)) {
391 .VertexBufferIndex
= 1,
393 .SourceElementFormat
= (enum GENX(SURFACE_FORMAT
)) ISL_FORMAT_R32G32B32A32_FLOAT
,
394 .SourceElementOffset
= 0,
395 .Component0Control
= VFCOMP_STORE_SRC
,
397 /* From Gen8 onwards hardware is no more instructed to overwrite
398 * components using an element specifier. Instead one has separate
399 * 3DSTATE_VF_SGVS (System Generated Value Setup) state packet for it.
402 .Component1Control
= VFCOMP_STORE_0
,
404 .Component1Control
= VFCOMP_STORE_IID
,
406 .Component1Control
= VFCOMP_STORE_0
,
408 .Component2Control
= VFCOMP_STORE_0
,
409 .Component3Control
= VFCOMP_STORE_0
,
411 .DestinationElementOffset
= slot
* 4,
417 /* On Iron Lake and earlier, a native device coordinates version of the
418 * position goes right after the normal VUE header and before position.
419 * Since w == 1 for all of our coordinates, this is just a copy of the
422 ve
[slot
] = (struct GENX(VERTEX_ELEMENT_STATE
)) {
423 .VertexBufferIndex
= 0,
425 .SourceElementFormat
= (enum GENX(SURFACE_FORMAT
)) ISL_FORMAT_R32G32B32_FLOAT
,
426 .SourceElementOffset
= 0,
427 .Component0Control
= VFCOMP_STORE_SRC
,
428 .Component1Control
= VFCOMP_STORE_SRC
,
429 .Component2Control
= VFCOMP_STORE_SRC
,
430 .Component3Control
= VFCOMP_STORE_1_FP
,
431 .DestinationElementOffset
= slot
* 4,
436 ve
[slot
] = (struct GENX(VERTEX_ELEMENT_STATE
)) {
437 .VertexBufferIndex
= 0,
439 .SourceElementFormat
= (enum GENX(SURFACE_FORMAT
)) ISL_FORMAT_R32G32B32_FLOAT
,
440 .SourceElementOffset
= 0,
441 .Component0Control
= VFCOMP_STORE_SRC
,
442 .Component1Control
= VFCOMP_STORE_SRC
,
443 .Component2Control
= VFCOMP_STORE_SRC
,
444 .Component3Control
= VFCOMP_STORE_1_FP
,
446 .DestinationElementOffset
= slot
* 4,
451 if (params
->dst_clear_color_as_input
) {
452 /* If the caller wants the destination indirect clear color, redirect
453 * to vertex buffer 2 where we stored it earlier. The only users of
454 * an indirect clear color source have that as their only vertex
457 assert(num_varyings
== 1);
458 ve
[slot
] = (struct GENX(VERTEX_ELEMENT_STATE
)) {
459 .VertexBufferIndex
= 2,
461 .SourceElementOffset
= 0,
462 .Component0Control
= VFCOMP_STORE_SRC
,
464 .SourceElementFormat
= (enum GENX(SURFACE_FORMAT
)) ISL_FORMAT_R32G32B32A32_FLOAT
,
465 .Component1Control
= VFCOMP_STORE_SRC
,
466 .Component2Control
= VFCOMP_STORE_SRC
,
467 .Component3Control
= VFCOMP_STORE_SRC
,
469 /* Clear colors on gen7-8 are for bits out of one dword */
470 .SourceElementFormat
= (enum GENX(SURFACE_FORMAT
)) ISL_FORMAT_R32_FLOAT
,
471 .Component1Control
= VFCOMP_STORE_0
,
472 .Component2Control
= VFCOMP_STORE_0
,
473 .Component3Control
= VFCOMP_STORE_0
,
478 for (unsigned i
= 0; i
< num_varyings
; ++i
) {
479 ve
[slot
] = (struct GENX(VERTEX_ELEMENT_STATE
)) {
480 .VertexBufferIndex
= 1,
482 .SourceElementFormat
= (enum GENX(SURFACE_FORMAT
)) ISL_FORMAT_R32G32B32A32_FLOAT
,
483 .SourceElementOffset
= 16 + i
* 4 * sizeof(float),
484 .Component0Control
= VFCOMP_STORE_SRC
,
485 .Component1Control
= VFCOMP_STORE_SRC
,
486 .Component2Control
= VFCOMP_STORE_SRC
,
487 .Component3Control
= VFCOMP_STORE_SRC
,
489 .DestinationElementOffset
= slot
* 4,
496 const unsigned num_dwords
=
497 1 + GENX(VERTEX_ELEMENT_STATE_length
) * num_elements
;
498 uint32_t *dw
= blorp_emitn(batch
, GENX(3DSTATE_VERTEX_ELEMENTS
), num_dwords
);
502 for (unsigned i
= 0; i
< num_elements
; i
++) {
503 GENX(VERTEX_ELEMENT_STATE_pack
)(batch
, dw
, &ve
[i
]);
504 dw
+= GENX(VERTEX_ELEMENT_STATE_length
);
508 /* Overwrite Render Target Array Index (2nd dword) in the VUE header with
509 * primitive instance identifier. This is used for layered clears.
511 blorp_emit(batch
, GENX(3DSTATE_VF_SGVS
), sgvs
) {
512 sgvs
.InstanceIDEnable
= true;
513 sgvs
.InstanceIDComponentNumber
= COMP_1
;
514 sgvs
.InstanceIDElementOffset
= 0;
517 for (unsigned i
= 0; i
< num_elements
; i
++) {
518 blorp_emit(batch
, GENX(3DSTATE_VF_INSTANCING
), vf
) {
519 vf
.VertexElementIndex
= i
;
520 vf
.InstancingEnable
= false;
524 blorp_emit(batch
, GENX(3DSTATE_VF_TOPOLOGY
), topo
) {
525 topo
.PrimitiveTopologyType
= _3DPRIM_RECTLIST
;
530 /* 3DSTATE_VIEWPORT_STATE_POINTERS */
532 blorp_emit_cc_viewport(struct blorp_batch
*batch
)
534 uint32_t cc_vp_offset
;
535 blorp_emit_dynamic(batch
, GENX(CC_VIEWPORT
), vp
, 32, &cc_vp_offset
) {
536 vp
.MinimumDepth
= 0.0;
537 vp
.MaximumDepth
= 1.0;
541 blorp_emit(batch
, GENX(3DSTATE_VIEWPORT_STATE_POINTERS_CC
), vsp
) {
542 vsp
.CCViewportPointer
= cc_vp_offset
;
545 blorp_emit(batch
, GENX(3DSTATE_VIEWPORT_STATE_POINTERS
), vsp
) {
546 vsp
.CCViewportStateChange
= true;
547 vsp
.PointertoCC_VIEWPORT
= cc_vp_offset
;
555 blorp_emit_sampler_state(struct blorp_batch
*batch
)
558 blorp_emit_dynamic(batch
, GENX(SAMPLER_STATE
), sampler
, 32, &offset
) {
559 sampler
.MipModeFilter
= MIPFILTER_NONE
;
560 sampler
.MagModeFilter
= MAPFILTER_LINEAR
;
561 sampler
.MinModeFilter
= MAPFILTER_LINEAR
;
564 sampler
.TCXAddressControlMode
= TCM_CLAMP
;
565 sampler
.TCYAddressControlMode
= TCM_CLAMP
;
566 sampler
.TCZAddressControlMode
= TCM_CLAMP
;
567 sampler
.MaximumAnisotropy
= RATIO21
;
568 sampler
.RAddressMinFilterRoundingEnable
= true;
569 sampler
.RAddressMagFilterRoundingEnable
= true;
570 sampler
.VAddressMinFilterRoundingEnable
= true;
571 sampler
.VAddressMagFilterRoundingEnable
= true;
572 sampler
.UAddressMinFilterRoundingEnable
= true;
573 sampler
.UAddressMagFilterRoundingEnable
= true;
575 sampler
.NonnormalizedCoordinateEnable
= true;
580 blorp_emit(batch
, GENX(3DSTATE_SAMPLER_STATE_POINTERS_PS
), ssp
) {
581 ssp
.PointertoPSSamplerState
= offset
;
584 blorp_emit(batch
, GENX(3DSTATE_SAMPLER_STATE_POINTERS
), ssp
) {
585 ssp
.VSSamplerStateChange
= true;
586 ssp
.GSSamplerStateChange
= true;
587 ssp
.PSSamplerStateChange
= true;
588 ssp
.PointertoPSSamplerState
= offset
;
595 /* What follows is the code for setting up a "pipeline" on Sandy Bridge and
596 * later hardware. This file will be included by i965 for gen4-5 as well, so
597 * this code is guarded by GEN_GEN >= 6.
602 blorp_emit_vs_config(struct blorp_batch
*batch
,
603 const struct blorp_params
*params
)
605 struct brw_vs_prog_data
*vs_prog_data
= params
->vs_prog_data
;
606 assert(!vs_prog_data
|| GEN_GEN
< 11 ||
607 vs_prog_data
->base
.dispatch_mode
== DISPATCH_MODE_SIMD8
);
609 blorp_emit(batch
, GENX(3DSTATE_VS
), vs
) {
613 vs
.KernelStartPointer
= params
->vs_prog_kernel
;
615 vs
.DispatchGRFStartRegisterForURBData
=
616 vs_prog_data
->base
.base
.dispatch_grf_start_reg
;
617 vs
.VertexURBEntryReadLength
=
618 vs_prog_data
->base
.urb_read_length
;
619 vs
.VertexURBEntryReadOffset
= 0;
621 vs
.MaximumNumberofThreads
=
622 batch
->blorp
->isl_dev
->info
->max_vs_threads
- 1;
625 vs
.SIMD8DispatchEnable
=
626 vs_prog_data
->base
.dispatch_mode
== DISPATCH_MODE_SIMD8
;
633 blorp_emit_sf_config(struct blorp_batch
*batch
,
634 const struct blorp_params
*params
)
636 const struct brw_wm_prog_data
*prog_data
= params
->wm_prog_data
;
640 * Disable ViewportTransformEnable (dw2.1)
642 * From the SandyBridge PRM, Volume 2, Part 1, Section 1.3, "3D
643 * Primitives Overview":
644 * RECTLIST: Viewport Mapping must be DISABLED (as is typical with the
645 * use of screen- space coordinates).
647 * A solid rectangle must be rendered, so set FrontFaceFillMode (dw2.4:3)
648 * and BackFaceFillMode (dw2.5:6) to SOLID(0).
650 * From the Sandy Bridge PRM, Volume 2, Part 1, Section
651 * 6.4.1.1 3DSTATE_SF, Field FrontFaceFillMode:
652 * SOLID: Any triangle or rectangle object found to be front-facing
653 * is rendered as a solid object. This setting is required when
654 * (rendering rectangle (RECTLIST) objects.
659 blorp_emit(batch
, GENX(3DSTATE_SF
), sf
);
661 blorp_emit(batch
, GENX(3DSTATE_RASTER
), raster
) {
662 raster
.CullMode
= CULLMODE_NONE
;
665 blorp_emit(batch
, GENX(3DSTATE_SBE
), sbe
) {
666 sbe
.VertexURBEntryReadOffset
= 1;
668 sbe
.NumberofSFOutputAttributes
= prog_data
->num_varying_inputs
;
669 sbe
.VertexURBEntryReadLength
= brw_blorp_get_urb_length(prog_data
);
670 sbe
.ConstantInterpolationEnable
= prog_data
->flat_inputs
;
672 sbe
.NumberofSFOutputAttributes
= 0;
673 sbe
.VertexURBEntryReadLength
= 1;
675 sbe
.ForceVertexURBEntryReadLength
= true;
676 sbe
.ForceVertexURBEntryReadOffset
= true;
679 for (unsigned i
= 0; i
< 32; i
++)
680 sbe
.AttributeActiveComponentFormat
[i
] = ACF_XYZW
;
686 blorp_emit(batch
, GENX(3DSTATE_SF
), sf
) {
687 sf
.FrontFaceFillMode
= FILL_MODE_SOLID
;
688 sf
.BackFaceFillMode
= FILL_MODE_SOLID
;
690 sf
.MultisampleRasterizationMode
= params
->num_samples
> 1 ?
691 MSRASTMODE_ON_PATTERN
: MSRASTMODE_OFF_PIXEL
;
694 sf
.DepthBufferSurfaceFormat
= params
->depth_format
;
698 blorp_emit(batch
, GENX(3DSTATE_SBE
), sbe
) {
699 sbe
.VertexURBEntryReadOffset
= 1;
701 sbe
.NumberofSFOutputAttributes
= prog_data
->num_varying_inputs
;
702 sbe
.VertexURBEntryReadLength
= brw_blorp_get_urb_length(prog_data
);
703 sbe
.ConstantInterpolationEnable
= prog_data
->flat_inputs
;
705 sbe
.NumberofSFOutputAttributes
= 0;
706 sbe
.VertexURBEntryReadLength
= 1;
710 #else /* GEN_GEN <= 6 */
712 blorp_emit(batch
, GENX(3DSTATE_SF
), sf
) {
713 sf
.FrontFaceFillMode
= FILL_MODE_SOLID
;
714 sf
.BackFaceFillMode
= FILL_MODE_SOLID
;
716 sf
.MultisampleRasterizationMode
= params
->num_samples
> 1 ?
717 MSRASTMODE_ON_PATTERN
: MSRASTMODE_OFF_PIXEL
;
719 sf
.VertexURBEntryReadOffset
= 1;
721 sf
.NumberofSFOutputAttributes
= prog_data
->num_varying_inputs
;
722 sf
.VertexURBEntryReadLength
= brw_blorp_get_urb_length(prog_data
);
723 sf
.ConstantInterpolationEnable
= prog_data
->flat_inputs
;
725 sf
.NumberofSFOutputAttributes
= 0;
726 sf
.VertexURBEntryReadLength
= 1;
734 blorp_emit_ps_config(struct blorp_batch
*batch
,
735 const struct blorp_params
*params
)
737 const struct brw_wm_prog_data
*prog_data
= params
->wm_prog_data
;
739 /* Even when thread dispatch is disabled, max threads (dw5.25:31) must be
740 * nonzero to prevent the GPU from hanging. While the documentation doesn't
741 * mention this explicitly, it notes that the valid range for the field is
742 * [1,39] = [2,40] threads, which excludes zero.
744 * To be safe (and to minimize extraneous code) we go ahead and fully
745 * configure the WM state whether or not there is a WM program.
750 blorp_emit(batch
, GENX(3DSTATE_WM
), wm
);
752 blorp_emit(batch
, GENX(3DSTATE_PS
), ps
) {
753 if (params
->src
.enabled
) {
754 ps
.SamplerCount
= 1; /* Up to 4 samplers */
755 ps
.BindingTableEntryCount
= 2;
757 ps
.BindingTableEntryCount
= 1;
761 ps
.DispatchGRFStartRegisterForConstantSetupData0
=
762 prog_data
->base
.dispatch_grf_start_reg
;
763 ps
.DispatchGRFStartRegisterForConstantSetupData2
=
764 prog_data
->dispatch_grf_start_reg_2
;
766 ps
._8PixelDispatchEnable
= prog_data
->dispatch_8
;
767 ps
._16PixelDispatchEnable
= prog_data
->dispatch_16
;
769 ps
.KernelStartPointer0
= params
->wm_prog_kernel
;
770 ps
.KernelStartPointer2
=
771 params
->wm_prog_kernel
+ prog_data
->prog_offset_2
;
774 /* 3DSTATE_PS expects the number of threads per PSD, which is always 64
775 * for pre Gen11 and 128 for gen11+; On gen11+ If a programmed value is
776 * k, it implies 2(k+1) threads. It implicitly scales for different GT
777 * levels (which have some # of PSDs).
779 * In Gen8 the format is U8-2 whereas in Gen9+ it is U9-1.
782 ps
.MaximumNumberofThreadsPerPSD
= 64 - 1;
784 ps
.MaximumNumberofThreadsPerPSD
= 64 - 2;
786 switch (params
->fast_clear_op
) {
787 case ISL_AUX_OP_NONE
:
790 case ISL_AUX_OP_PARTIAL_RESOLVE
:
791 ps
.RenderTargetResolveType
= RESOLVE_PARTIAL
;
793 case ISL_AUX_OP_FULL_RESOLVE
:
794 ps
.RenderTargetResolveType
= RESOLVE_FULL
;
797 case ISL_AUX_OP_FULL_RESOLVE
:
798 ps
.RenderTargetResolveEnable
= true;
801 case ISL_AUX_OP_FAST_CLEAR
:
802 ps
.RenderTargetFastClearEnable
= true;
805 unreachable("Invalid fast clear op");
809 blorp_emit(batch
, GENX(3DSTATE_PS_EXTRA
), psx
) {
811 psx
.PixelShaderValid
= true;
812 psx
.AttributeEnable
= prog_data
->num_varying_inputs
> 0;
813 psx
.PixelShaderIsPerSample
= prog_data
->persample_dispatch
;
816 if (params
->src
.enabled
)
817 psx
.PixelShaderKillsPixel
= true;
822 blorp_emit(batch
, GENX(3DSTATE_WM
), wm
) {
823 switch (params
->hiz_op
) {
824 case ISL_AUX_OP_FAST_CLEAR
:
825 wm
.DepthBufferClear
= true;
827 case ISL_AUX_OP_FULL_RESOLVE
:
828 wm
.DepthBufferResolveEnable
= true;
830 case ISL_AUX_OP_AMBIGUATE
:
831 wm
.HierarchicalDepthBufferResolveEnable
= true;
833 case ISL_AUX_OP_NONE
:
836 unreachable("not reached");
840 wm
.ThreadDispatchEnable
= true;
842 if (params
->src
.enabled
)
843 wm
.PixelShaderKillsPixel
= true;
845 if (params
->num_samples
> 1) {
846 wm
.MultisampleRasterizationMode
= MSRASTMODE_ON_PATTERN
;
847 wm
.MultisampleDispatchMode
=
848 (prog_data
&& prog_data
->persample_dispatch
) ?
849 MSDISPMODE_PERSAMPLE
: MSDISPMODE_PERPIXEL
;
851 wm
.MultisampleRasterizationMode
= MSRASTMODE_OFF_PIXEL
;
852 wm
.MultisampleDispatchMode
= MSDISPMODE_PERSAMPLE
;
856 blorp_emit(batch
, GENX(3DSTATE_PS
), ps
) {
857 ps
.MaximumNumberofThreads
=
858 batch
->blorp
->isl_dev
->info
->max_wm_threads
- 1;
865 ps
.DispatchGRFStartRegisterForConstantSetupData0
=
866 prog_data
->base
.dispatch_grf_start_reg
;
867 ps
.DispatchGRFStartRegisterForConstantSetupData2
=
868 prog_data
->dispatch_grf_start_reg_2
;
870 ps
.KernelStartPointer0
= params
->wm_prog_kernel
;
871 ps
.KernelStartPointer2
=
872 params
->wm_prog_kernel
+ prog_data
->prog_offset_2
;
874 ps
._8PixelDispatchEnable
= prog_data
->dispatch_8
;
875 ps
._16PixelDispatchEnable
= prog_data
->dispatch_16
;
877 ps
.AttributeEnable
= prog_data
->num_varying_inputs
> 0;
879 /* Gen7 hardware gets angry if we don't enable at least one dispatch
880 * mode, so just enable 16-pixel dispatch if we don't have a program.
882 ps
._16PixelDispatchEnable
= true;
885 if (params
->src
.enabled
)
886 ps
.SamplerCount
= 1; /* Up to 4 samplers */
888 switch (params
->fast_clear_op
) {
889 case ISL_AUX_OP_NONE
:
891 case ISL_AUX_OP_FULL_RESOLVE
:
892 ps
.RenderTargetResolveEnable
= true;
894 case ISL_AUX_OP_FAST_CLEAR
:
895 ps
.RenderTargetFastClearEnable
= true;
898 unreachable("Invalid fast clear op");
902 #else /* GEN_GEN <= 6 */
904 blorp_emit(batch
, GENX(3DSTATE_WM
), wm
) {
905 wm
.MaximumNumberofThreads
=
906 batch
->blorp
->isl_dev
->info
->max_wm_threads
- 1;
908 switch (params
->hiz_op
) {
909 case ISL_AUX_OP_FAST_CLEAR
:
910 wm
.DepthBufferClear
= true;
912 case ISL_AUX_OP_FULL_RESOLVE
:
913 wm
.DepthBufferResolveEnable
= true;
915 case ISL_AUX_OP_AMBIGUATE
:
916 wm
.HierarchicalDepthBufferResolveEnable
= true;
918 case ISL_AUX_OP_NONE
:
921 unreachable("not reached");
925 wm
.ThreadDispatchEnable
= true;
927 wm
.DispatchGRFStartRegisterForConstantSetupData0
=
928 prog_data
->base
.dispatch_grf_start_reg
;
929 wm
.DispatchGRFStartRegisterForConstantSetupData2
=
930 prog_data
->dispatch_grf_start_reg_2
;
932 wm
.KernelStartPointer0
= params
->wm_prog_kernel
;
933 wm
.KernelStartPointer2
=
934 params
->wm_prog_kernel
+ prog_data
->prog_offset_2
;
936 wm
._8PixelDispatchEnable
= prog_data
->dispatch_8
;
937 wm
._16PixelDispatchEnable
= prog_data
->dispatch_16
;
939 wm
.NumberofSFOutputAttributes
= prog_data
->num_varying_inputs
;
942 if (params
->src
.enabled
) {
943 wm
.SamplerCount
= 1; /* Up to 4 samplers */
944 wm
.PixelShaderKillsPixel
= true; /* TODO: temporarily smash on */
947 if (params
->num_samples
> 1) {
948 wm
.MultisampleRasterizationMode
= MSRASTMODE_ON_PATTERN
;
949 wm
.MultisampleDispatchMode
=
950 (prog_data
&& prog_data
->persample_dispatch
) ?
951 MSDISPMODE_PERSAMPLE
: MSDISPMODE_PERPIXEL
;
953 wm
.MultisampleRasterizationMode
= MSRASTMODE_OFF_PIXEL
;
954 wm
.MultisampleDispatchMode
= MSDISPMODE_PERSAMPLE
;
962 blorp_emit_blend_state(struct blorp_batch
*batch
,
963 const struct blorp_params
*params
)
965 struct GENX(BLEND_STATE
) blend
;
966 memset(&blend
, 0, sizeof(blend
));
969 int size
= GENX(BLEND_STATE_length
) * 4;
970 size
+= GENX(BLEND_STATE_ENTRY_length
) * 4 * params
->num_draw_buffers
;
971 uint32_t *state
= blorp_alloc_dynamic_state(batch
, size
, 64, &offset
);
972 uint32_t *pos
= state
;
974 GENX(BLEND_STATE_pack
)(NULL
, pos
, &blend
);
975 pos
+= GENX(BLEND_STATE_length
);
977 for (unsigned i
= 0; i
< params
->num_draw_buffers
; ++i
) {
978 struct GENX(BLEND_STATE_ENTRY
) entry
= {
979 .PreBlendColorClampEnable
= true,
980 .PostBlendColorClampEnable
= true,
981 .ColorClampRange
= COLORCLAMP_RTFORMAT
,
983 .WriteDisableRed
= params
->color_write_disable
[0],
984 .WriteDisableGreen
= params
->color_write_disable
[1],
985 .WriteDisableBlue
= params
->color_write_disable
[2],
986 .WriteDisableAlpha
= params
->color_write_disable
[3],
988 GENX(BLEND_STATE_ENTRY_pack
)(NULL
, pos
, &entry
);
989 pos
+= GENX(BLEND_STATE_ENTRY_length
);
992 blorp_flush_range(batch
, state
, size
);
995 blorp_emit(batch
, GENX(3DSTATE_BLEND_STATE_POINTERS
), sp
) {
996 sp
.BlendStatePointer
= offset
;
998 sp
.BlendStatePointerValid
= true;
1004 blorp_emit(batch
, GENX(3DSTATE_PS_BLEND
), ps_blend
) {
1005 ps_blend
.HasWriteableRT
= true;
1013 blorp_emit_color_calc_state(struct blorp_batch
*batch
,
1014 MAYBE_UNUSED
const struct blorp_params
*params
)
1017 blorp_emit_dynamic(batch
, GENX(COLOR_CALC_STATE
), cc
, 64, &offset
) {
1019 cc
.StencilReferenceValue
= params
->stencil_ref
;
1024 blorp_emit(batch
, GENX(3DSTATE_CC_STATE_POINTERS
), sp
) {
1025 sp
.ColorCalcStatePointer
= offset
;
1027 sp
.ColorCalcStatePointerValid
= true;
1036 blorp_emit_depth_stencil_state(struct blorp_batch
*batch
,
1037 const struct blorp_params
*params
)
1040 struct GENX(3DSTATE_WM_DEPTH_STENCIL
) ds
= {
1041 GENX(3DSTATE_WM_DEPTH_STENCIL_header
),
1044 struct GENX(DEPTH_STENCIL_STATE
) ds
= { 0 };
1047 if (params
->depth
.enabled
) {
1048 ds
.DepthBufferWriteEnable
= true;
1050 switch (params
->hiz_op
) {
1051 case ISL_AUX_OP_NONE
:
1052 ds
.DepthTestEnable
= true;
1053 ds
.DepthTestFunction
= COMPAREFUNCTION_ALWAYS
;
1056 /* See the following sections of the Sandy Bridge PRM, Volume 2, Part1:
1057 * - 7.5.3.1 Depth Buffer Clear
1058 * - 7.5.3.2 Depth Buffer Resolve
1059 * - 7.5.3.3 Hierarchical Depth Buffer Resolve
1061 case ISL_AUX_OP_FULL_RESOLVE
:
1062 ds
.DepthTestEnable
= true;
1063 ds
.DepthTestFunction
= COMPAREFUNCTION_NEVER
;
1066 case ISL_AUX_OP_FAST_CLEAR
:
1067 case ISL_AUX_OP_AMBIGUATE
:
1068 ds
.DepthTestEnable
= false;
1070 case ISL_AUX_OP_PARTIAL_RESOLVE
:
1071 unreachable("Invalid HIZ op");
1075 if (params
->stencil
.enabled
) {
1076 ds
.StencilBufferWriteEnable
= true;
1077 ds
.StencilTestEnable
= true;
1078 ds
.DoubleSidedStencilEnable
= false;
1080 ds
.StencilTestFunction
= COMPAREFUNCTION_ALWAYS
;
1081 ds
.StencilPassDepthPassOp
= STENCILOP_REPLACE
;
1083 ds
.StencilWriteMask
= params
->stencil_mask
;
1085 ds
.StencilReferenceValue
= params
->stencil_ref
;
1090 uint32_t offset
= 0;
1091 uint32_t *dw
= blorp_emit_dwords(batch
,
1092 GENX(3DSTATE_WM_DEPTH_STENCIL_length
));
1096 GENX(3DSTATE_WM_DEPTH_STENCIL_pack
)(NULL
, dw
, &ds
);
1099 void *state
= blorp_alloc_dynamic_state(batch
,
1100 GENX(DEPTH_STENCIL_STATE_length
) * 4,
1102 GENX(DEPTH_STENCIL_STATE_pack
)(NULL
, state
, &ds
);
1103 blorp_flush_range(batch
, state
, GENX(DEPTH_STENCIL_STATE_length
) * 4);
1107 blorp_emit(batch
, GENX(3DSTATE_DEPTH_STENCIL_STATE_POINTERS
), sp
) {
1108 sp
.PointertoDEPTH_STENCIL_STATE
= offset
;
1116 blorp_emit_3dstate_multisample(struct blorp_batch
*batch
,
1117 const struct blorp_params
*params
)
1119 blorp_emit(batch
, GENX(3DSTATE_MULTISAMPLE
), ms
) {
1120 ms
.NumberofMultisamples
= __builtin_ffs(params
->num_samples
) - 1;
1123 /* The PRM says that this bit is valid only for DX9:
1125 * SW can choose to set this bit only for DX9 API. DX10/OGL API's
1126 * should not have any effect by setting or not setting this bit.
1128 ms
.PixelPositionOffsetEnable
= false;
1131 switch (params
->num_samples
) {
1133 GEN_SAMPLE_POS_1X(ms
.Sample
);
1136 GEN_SAMPLE_POS_2X(ms
.Sample
);
1139 GEN_SAMPLE_POS_4X(ms
.Sample
);
1142 GEN_SAMPLE_POS_8X(ms
.Sample
);
1148 GEN_SAMPLE_POS_4X(ms
.Sample
);
1150 ms
.PixelLocation
= CENTER
;
1155 blorp_emit_pipeline(struct blorp_batch
*batch
,
1156 const struct blorp_params
*params
)
1158 uint32_t blend_state_offset
= 0;
1159 uint32_t color_calc_state_offset
;
1160 uint32_t depth_stencil_state_offset
;
1162 emit_urb_config(batch
, params
);
1164 if (params
->wm_prog_data
) {
1165 blend_state_offset
= blorp_emit_blend_state(batch
, params
);
1167 color_calc_state_offset
= blorp_emit_color_calc_state(batch
, params
);
1168 depth_stencil_state_offset
= blorp_emit_depth_stencil_state(batch
, params
);
1171 /* 3DSTATE_CC_STATE_POINTERS
1173 * The pointer offsets are relative to
1174 * CMD_STATE_BASE_ADDRESS.DynamicStateBaseAddress.
1176 * The HiZ op doesn't use BLEND_STATE or COLOR_CALC_STATE.
1178 * The dynamic state emit helpers emit their own STATE_POINTERS packets on
1179 * gen7+. However, on gen6 and earlier, they're all lumpped together in
1180 * one CC_STATE_POINTERS packet so we have to emit that here.
1182 blorp_emit(batch
, GENX(3DSTATE_CC_STATE_POINTERS
), cc
) {
1183 cc
.BLEND_STATEChange
= true;
1184 cc
.ColorCalcStatePointerValid
= true;
1185 cc
.DEPTH_STENCIL_STATEChange
= true;
1186 cc
.PointertoBLEND_STATE
= blend_state_offset
;
1187 cc
.ColorCalcStatePointer
= color_calc_state_offset
;
1188 cc
.PointertoDEPTH_STENCIL_STATE
= depth_stencil_state_offset
;
1191 (void)blend_state_offset
;
1192 (void)color_calc_state_offset
;
1193 (void)depth_stencil_state_offset
;
1196 blorp_emit(batch
, GENX(3DSTATE_CONSTANT_VS
), vs
);
1198 blorp_emit(batch
, GENX(3DSTATE_CONSTANT_HS
), hs
);
1199 blorp_emit(batch
, GENX(3DSTATE_CONSTANT_DS
), DS
);
1201 blorp_emit(batch
, GENX(3DSTATE_CONSTANT_GS
), gs
);
1202 blorp_emit(batch
, GENX(3DSTATE_CONSTANT_PS
), ps
);
1204 if (params
->src
.enabled
)
1205 blorp_emit_sampler_state(batch
);
1207 blorp_emit_3dstate_multisample(batch
, params
);
1209 blorp_emit(batch
, GENX(3DSTATE_SAMPLE_MASK
), mask
) {
1210 mask
.SampleMask
= (1 << params
->num_samples
) - 1;
1213 /* From the BSpec, 3D Pipeline > Geometry > Vertex Shader > State,
1214 * 3DSTATE_VS, Dword 5.0 "VS Function Enable":
1216 * [DevSNB] A pipeline flush must be programmed prior to a
1217 * 3DSTATE_VS command that causes the VS Function Enable to
1218 * toggle. Pipeline flush can be executed by sending a PIPE_CONTROL
1219 * command with CS stall bit set and a post sync operation.
1221 * We've already done one at the start of the BLORP operation.
1223 blorp_emit_vs_config(batch
, params
);
1225 blorp_emit(batch
, GENX(3DSTATE_HS
), hs
);
1226 blorp_emit(batch
, GENX(3DSTATE_TE
), te
);
1227 blorp_emit(batch
, GENX(3DSTATE_DS
), DS
);
1228 blorp_emit(batch
, GENX(3DSTATE_STREAMOUT
), so
);
1230 blorp_emit(batch
, GENX(3DSTATE_GS
), gs
);
1232 blorp_emit(batch
, GENX(3DSTATE_CLIP
), clip
) {
1233 clip
.PerspectiveDivideDisable
= true;
1236 blorp_emit_sf_config(batch
, params
);
1237 blorp_emit_ps_config(batch
, params
);
1239 blorp_emit_cc_viewport(batch
);
1242 /******** This is the end of the pipeline setup code ********/
1244 #endif /* GEN_GEN >= 6 */
1246 #if GEN_GEN >= 7 && GEN_GEN <= 10
1248 blorp_emit_memcpy(struct blorp_batch
*batch
,
1249 struct blorp_address dst
,
1250 struct blorp_address src
,
1253 assert(size
% 4 == 0);
1255 for (unsigned dw
= 0; dw
< size
; dw
+= 4) {
1257 blorp_emit(batch
, GENX(MI_COPY_MEM_MEM
), cp
) {
1258 cp
.DestinationMemoryAddress
= dst
;
1259 cp
.SourceMemoryAddress
= src
;
1262 /* IVB does not have a general purpose register for command streamer
1263 * commands. Therefore, we use an alternate temporary register.
1265 #define BLORP_TEMP_REG 0x2440 /* GEN7_3DPRIM_BASE_VERTEX */
1266 blorp_emit(batch
, GENX(MI_LOAD_REGISTER_MEM
), load
) {
1267 load
.RegisterAddress
= BLORP_TEMP_REG
;
1268 load
.MemoryAddress
= src
;
1270 blorp_emit(batch
, GENX(MI_STORE_REGISTER_MEM
), store
) {
1271 store
.RegisterAddress
= BLORP_TEMP_REG
;
1272 store
.MemoryAddress
= dst
;
1274 #undef BLORP_TEMP_REG
1283 blorp_emit_surface_state(struct blorp_batch
*batch
,
1284 const struct brw_blorp_surface_info
*surface
,
1285 void *state
, uint32_t state_offset
,
1286 const bool color_write_disables
[4],
1287 bool is_render_target
)
1289 const struct isl_device
*isl_dev
= batch
->blorp
->isl_dev
;
1290 struct isl_surf surf
= surface
->surf
;
1292 if (surf
.dim
== ISL_SURF_DIM_1D
&&
1293 surf
.dim_layout
== ISL_DIM_LAYOUT_GEN4_2D
) {
1294 assert(surf
.logical_level0_px
.height
== 1);
1295 surf
.dim
= ISL_SURF_DIM_2D
;
1298 /* Blorp doesn't support HiZ in any of the blit or slow-clear paths */
1299 enum isl_aux_usage aux_usage
= surface
->aux_usage
;
1300 if (aux_usage
== ISL_AUX_USAGE_HIZ
)
1301 aux_usage
= ISL_AUX_USAGE_NONE
;
1303 isl_channel_mask_t write_disable_mask
= 0;
1304 if (is_render_target
&& GEN_GEN
<= 5) {
1305 if (color_write_disables
[0])
1306 write_disable_mask
|= ISL_CHANNEL_RED_BIT
;
1307 if (color_write_disables
[1])
1308 write_disable_mask
|= ISL_CHANNEL_GREEN_BIT
;
1309 if (color_write_disables
[2])
1310 write_disable_mask
|= ISL_CHANNEL_BLUE_BIT
;
1311 if (color_write_disables
[3])
1312 write_disable_mask
|= ISL_CHANNEL_ALPHA_BIT
;
1315 isl_surf_fill_state(batch
->blorp
->isl_dev
, state
,
1316 .surf
= &surf
, .view
= &surface
->view
,
1317 .aux_surf
= &surface
->aux_surf
, .aux_usage
= aux_usage
,
1318 .mocs
= surface
->addr
.mocs
,
1319 .clear_color
= surface
->clear_color
,
1320 .write_disables
= write_disable_mask
);
1322 blorp_surface_reloc(batch
, state_offset
+ isl_dev
->ss
.addr_offset
,
1325 if (aux_usage
!= ISL_AUX_USAGE_NONE
) {
1326 /* On gen7 and prior, the bottom 12 bits of the MCS base address are
1327 * used to store other information. This should be ok, however, because
1328 * surface buffer addresses are always 4K page alinged.
1330 assert((surface
->aux_addr
.offset
& 0xfff) == 0);
1331 uint32_t *aux_addr
= state
+ isl_dev
->ss
.aux_addr_offset
;
1332 blorp_surface_reloc(batch
, state_offset
+ isl_dev
->ss
.aux_addr_offset
,
1333 surface
->aux_addr
, *aux_addr
);
1336 blorp_flush_range(batch
, state
, GENX(RENDER_SURFACE_STATE_length
) * 4);
1338 if (surface
->clear_color_addr
.buffer
) {
1340 unreachable("Implement indirect clear support on gen11+");
1341 #elif GEN_GEN >= 7 && GEN_GEN <= 10
1342 struct blorp_address dst_addr
= blorp_get_surface_base_address(batch
);
1343 dst_addr
.offset
+= state_offset
+ isl_dev
->ss
.clear_value_offset
;
1344 blorp_emit_memcpy(batch
, dst_addr
, surface
->clear_color_addr
,
1345 isl_dev
->ss
.clear_value_size
);
1347 unreachable("Fast clears are only supported on gen7+");
1353 blorp_emit_null_surface_state(struct blorp_batch
*batch
,
1354 const struct brw_blorp_surface_info
*surface
,
1357 struct GENX(RENDER_SURFACE_STATE
) ss
= {
1358 .SurfaceType
= SURFTYPE_NULL
,
1359 .SurfaceFormat
= (enum GENX(SURFACE_FORMAT
)) ISL_FORMAT_R8G8B8A8_UNORM
,
1360 .Width
= surface
->surf
.logical_level0_px
.width
- 1,
1361 .Height
= surface
->surf
.logical_level0_px
.height
- 1,
1362 .MIPCountLOD
= surface
->view
.base_level
,
1363 .MinimumArrayElement
= surface
->view
.base_array_layer
,
1364 .Depth
= surface
->view
.array_len
- 1,
1365 .RenderTargetViewExtent
= surface
->view
.array_len
- 1,
1367 .NumberofMultisamples
= ffs(surface
->surf
.samples
) - 1,
1371 .SurfaceArray
= surface
->surf
.dim
!= ISL_SURF_DIM_3D
,
1377 .TiledSurface
= true,
1381 GENX(RENDER_SURFACE_STATE_pack
)(NULL
, state
, &ss
);
1383 blorp_flush_range(batch
, state
, GENX(RENDER_SURFACE_STATE_length
) * 4);
1387 blorp_emit_surface_states(struct blorp_batch
*batch
,
1388 const struct blorp_params
*params
)
1390 const struct isl_device
*isl_dev
= batch
->blorp
->isl_dev
;
1391 uint32_t bind_offset
, surface_offsets
[2];
1392 void *surface_maps
[2];
1394 MAYBE_UNUSED
bool has_indirect_clear_color
= false;
1395 if (params
->use_pre_baked_binding_table
) {
1396 bind_offset
= params
->pre_baked_binding_table_offset
;
1398 unsigned num_surfaces
= 1 + params
->src
.enabled
;
1399 blorp_alloc_binding_table(batch
, num_surfaces
,
1400 isl_dev
->ss
.size
, isl_dev
->ss
.align
,
1401 &bind_offset
, surface_offsets
, surface_maps
);
1403 if (params
->dst
.enabled
) {
1404 blorp_emit_surface_state(batch
, ¶ms
->dst
,
1405 surface_maps
[BLORP_RENDERBUFFER_BT_INDEX
],
1406 surface_offsets
[BLORP_RENDERBUFFER_BT_INDEX
],
1407 params
->color_write_disable
, true);
1408 if (params
->dst
.clear_color_addr
.buffer
!= NULL
)
1409 has_indirect_clear_color
= true;
1411 assert(params
->depth
.enabled
|| params
->stencil
.enabled
);
1412 const struct brw_blorp_surface_info
*surface
=
1413 params
->depth
.enabled
? ¶ms
->depth
: ¶ms
->stencil
;
1414 blorp_emit_null_surface_state(batch
, surface
,
1415 surface_maps
[BLORP_RENDERBUFFER_BT_INDEX
]);
1418 if (params
->src
.enabled
) {
1419 blorp_emit_surface_state(batch
, ¶ms
->src
,
1420 surface_maps
[BLORP_TEXTURE_BT_INDEX
],
1421 surface_offsets
[BLORP_TEXTURE_BT_INDEX
],
1423 if (params
->src
.clear_color_addr
.buffer
!= NULL
)
1424 has_indirect_clear_color
= true;
1429 if (has_indirect_clear_color
) {
1430 /* Updating a surface state object may require that the state cache be
1431 * invalidated. From the SKL PRM, Shared Functions -> State -> State
1434 * Whenever the RENDER_SURFACE_STATE object in memory pointed to by
1435 * the Binding Table Pointer (BTP) and Binding Table Index (BTI) is
1436 * modified [...], the L1 state cache must be invalidated to ensure
1437 * the new surface or sampler state is fetched from system memory.
1439 blorp_emit(batch
, GENX(PIPE_CONTROL
), pipe
) {
1440 pipe
.StateCacheInvalidationEnable
= true;
1446 blorp_emit(batch
, GENX(3DSTATE_BINDING_TABLE_POINTERS_VS
), bt
);
1447 blorp_emit(batch
, GENX(3DSTATE_BINDING_TABLE_POINTERS_HS
), bt
);
1448 blorp_emit(batch
, GENX(3DSTATE_BINDING_TABLE_POINTERS_DS
), bt
);
1449 blorp_emit(batch
, GENX(3DSTATE_BINDING_TABLE_POINTERS_GS
), bt
);
1451 blorp_emit(batch
, GENX(3DSTATE_BINDING_TABLE_POINTERS_PS
), bt
) {
1452 bt
.PointertoPSBindingTable
= bind_offset
;
1455 blorp_emit(batch
, GENX(3DSTATE_BINDING_TABLE_POINTERS
), bt
) {
1456 bt
.PSBindingTableChange
= true;
1457 bt
.PointertoPSBindingTable
= bind_offset
;
1460 blorp_emit(batch
, GENX(3DSTATE_BINDING_TABLE_POINTERS
), bt
) {
1461 bt
.PointertoPSBindingTable
= bind_offset
;
1467 blorp_emit_depth_stencil_config(struct blorp_batch
*batch
,
1468 const struct blorp_params
*params
)
1470 const struct isl_device
*isl_dev
= batch
->blorp
->isl_dev
;
1472 uint32_t *dw
= blorp_emit_dwords(batch
, isl_dev
->ds
.size
/ 4);
1476 struct isl_depth_stencil_hiz_emit_info info
= { };
1478 if (params
->depth
.enabled
) {
1479 info
.view
= ¶ms
->depth
.view
;
1480 info
.mocs
= params
->depth
.addr
.mocs
;
1481 } else if (params
->stencil
.enabled
) {
1482 info
.view
= ¶ms
->stencil
.view
;
1483 info
.mocs
= params
->stencil
.addr
.mocs
;
1486 if (params
->depth
.enabled
) {
1487 info
.depth_surf
= ¶ms
->depth
.surf
;
1489 info
.depth_address
=
1490 blorp_emit_reloc(batch
, dw
+ isl_dev
->ds
.depth_offset
/ 4,
1491 params
->depth
.addr
, 0);
1493 info
.hiz_usage
= params
->depth
.aux_usage
;
1494 if (info
.hiz_usage
== ISL_AUX_USAGE_HIZ
) {
1495 info
.hiz_surf
= ¶ms
->depth
.aux_surf
;
1497 struct blorp_address hiz_address
= params
->depth
.aux_addr
;
1499 /* Sandy bridge hardware does not technically support mipmapped HiZ.
1500 * However, we have a special layout that allows us to make it work
1501 * anyway by manually offsetting to the specified miplevel.
1503 assert(info
.hiz_surf
->dim_layout
== ISL_DIM_LAYOUT_GEN6_STENCIL_HIZ
);
1505 isl_surf_get_image_offset_B_tile_sa(info
.hiz_surf
,
1506 info
.view
->base_level
, 0, 0,
1507 &offset_B
, NULL
, NULL
);
1508 hiz_address
.offset
+= offset_B
;
1512 blorp_emit_reloc(batch
, dw
+ isl_dev
->ds
.hiz_offset
/ 4,
1515 info
.depth_clear_value
= params
->depth
.clear_color
.f32
[0];
1519 if (params
->stencil
.enabled
) {
1520 info
.stencil_surf
= ¶ms
->stencil
.surf
;
1522 struct blorp_address stencil_address
= params
->stencil
.addr
;
1524 /* Sandy bridge hardware does not technically support mipmapped stencil.
1525 * However, we have a special layout that allows us to make it work
1526 * anyway by manually offsetting to the specified miplevel.
1528 assert(info
.stencil_surf
->dim_layout
== ISL_DIM_LAYOUT_GEN6_STENCIL_HIZ
);
1530 isl_surf_get_image_offset_B_tile_sa(info
.stencil_surf
,
1531 info
.view
->base_level
, 0, 0,
1532 &offset_B
, NULL
, NULL
);
1533 stencil_address
.offset
+= offset_B
;
1536 info
.stencil_address
=
1537 blorp_emit_reloc(batch
, dw
+ isl_dev
->ds
.stencil_offset
/ 4,
1538 stencil_address
, 0);
1541 isl_emit_depth_stencil_hiz_s(isl_dev
, dw
, &info
);
1545 /* Emits the Optimized HiZ sequence specified in the BDW+ PRMs. The
1546 * depth/stencil buffer extents are ignored to handle APIs which perform
1547 * clearing operations without such information.
1550 blorp_emit_gen8_hiz_op(struct blorp_batch
*batch
,
1551 const struct blorp_params
*params
)
1553 /* We should be performing an operation on a depth or stencil buffer.
1555 assert(params
->depth
.enabled
|| params
->stencil
.enabled
);
1557 /* The stencil buffer should only be enabled if a fast clear operation is
1560 if (params
->stencil
.enabled
)
1561 assert(params
->hiz_op
== ISL_AUX_OP_FAST_CLEAR
);
1563 /* From the BDW PRM Volume 2, 3DSTATE_WM_HZ_OP:
1565 * 3DSTATE_MULTISAMPLE packet must be used prior to this packet to change
1566 * the Number of Multisamples. This packet must not be used to change
1567 * Number of Multisamples in a rendering sequence.
1569 * Since HIZ may be the first thing in a batch buffer, play safe and always
1570 * emit 3DSTATE_MULTISAMPLE.
1572 blorp_emit_3dstate_multisample(batch
, params
);
1574 /* If we can't alter the depth stencil config and multiple layers are
1575 * involved, the HiZ op will fail. This is because the op requires that a
1576 * new config is emitted for each additional layer.
1578 if (batch
->flags
& BLORP_BATCH_NO_EMIT_DEPTH_STENCIL
) {
1579 assert(params
->num_layers
<= 1);
1581 blorp_emit_depth_stencil_config(batch
, params
);
1584 blorp_emit(batch
, GENX(3DSTATE_WM_HZ_OP
), hzp
) {
1585 switch (params
->hiz_op
) {
1586 case ISL_AUX_OP_FAST_CLEAR
:
1587 hzp
.StencilBufferClearEnable
= params
->stencil
.enabled
;
1588 hzp
.DepthBufferClearEnable
= params
->depth
.enabled
;
1589 hzp
.StencilClearValue
= params
->stencil_ref
;
1590 hzp
.FullSurfaceDepthandStencilClear
= params
->full_surface_hiz_op
;
1592 case ISL_AUX_OP_FULL_RESOLVE
:
1593 assert(params
->full_surface_hiz_op
);
1594 hzp
.DepthBufferResolveEnable
= true;
1596 case ISL_AUX_OP_AMBIGUATE
:
1597 assert(params
->full_surface_hiz_op
);
1598 hzp
.HierarchicalDepthBufferResolveEnable
= true;
1600 case ISL_AUX_OP_PARTIAL_RESOLVE
:
1601 case ISL_AUX_OP_NONE
:
1602 unreachable("Invalid HIZ op");
1605 hzp
.NumberofMultisamples
= ffs(params
->num_samples
) - 1;
1606 hzp
.SampleMask
= 0xFFFF;
1608 /* Due to a hardware issue, this bit MBZ */
1609 assert(hzp
.ScissorRectangleEnable
== false);
1611 /* Contrary to the HW docs both fields are inclusive */
1612 hzp
.ClearRectangleXMin
= params
->x0
;
1613 hzp
.ClearRectangleYMin
= params
->y0
;
1615 /* Contrary to the HW docs both fields are exclusive */
1616 hzp
.ClearRectangleXMax
= params
->x1
;
1617 hzp
.ClearRectangleYMax
= params
->y1
;
1620 /* PIPE_CONTROL w/ all bits clear except for “Post-Sync Operation” must set
1621 * to “Write Immediate Data” enabled.
1623 blorp_emit(batch
, GENX(PIPE_CONTROL
), pc
) {
1624 pc
.PostSyncOperation
= WriteImmediateData
;
1625 pc
.Address
= blorp_get_workaround_page(batch
);
1628 blorp_emit(batch
, GENX(3DSTATE_WM_HZ_OP
), hzp
);
1633 * \brief Execute a blit or render pass operation.
1635 * To execute the operation, this function manually constructs and emits a
1636 * batch to draw a rectangle primitive. The batchbuffer is flushed before
1637 * constructing and after emitting the batch.
1639 * This function alters no GL state.
1642 blorp_exec(struct blorp_batch
*batch
, const struct blorp_params
*params
)
1645 if (params
->hiz_op
!= ISL_AUX_OP_NONE
) {
1646 blorp_emit_gen8_hiz_op(batch
, params
);
1651 blorp_emit_vertex_buffers(batch
, params
);
1652 blorp_emit_vertex_elements(batch
, params
);
1654 blorp_emit_pipeline(batch
, params
);
1656 blorp_emit_surface_states(batch
, params
);
1658 if (!(batch
->flags
& BLORP_BATCH_NO_EMIT_DEPTH_STENCIL
))
1659 blorp_emit_depth_stencil_config(batch
, params
);
1661 blorp_emit(batch
, GENX(3DPRIMITIVE
), prim
) {
1662 prim
.VertexAccessType
= SEQUENTIAL
;
1663 prim
.PrimitiveTopologyType
= _3DPRIM_RECTLIST
;
1665 prim
.PredicateEnable
= batch
->flags
& BLORP_BATCH_PREDICATE_ENABLE
;
1667 prim
.VertexCountPerInstance
= 3;
1668 prim
.InstanceCount
= params
->num_layers
;
1672 #endif /* BLORP_GENX_EXEC_H */