2 * Copyright © 2013 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 #include "util/ralloc.h"
26 #include "main/macros.h" /* Needed for MAX3 and MAX2 for format_rgb9e5 */
27 #include "util/format_rgb9e5.h"
28 #include "util/format_srgb.h"
30 #include "blorp_priv.h"
31 #include "compiler/brw_eu_defines.h"
33 #include "blorp_nir_builder.h"
35 #define FILE_DEBUG_FLAG DEBUG_BLORP
38 struct brw_blorp_const_color_prog_key
40 enum blorp_shader_type shader_type
; /* Must be BLORP_SHADER_TYPE_CLEAR */
41 bool use_simd16_replicated_data
;
42 bool clear_rgb_as_red
;
47 blorp_params_get_clear_kernel(struct blorp_batch
*batch
,
48 struct blorp_params
*params
,
49 bool use_replicated_data
,
50 bool clear_rgb_as_red
)
52 struct blorp_context
*blorp
= batch
->blorp
;
54 const struct brw_blorp_const_color_prog_key blorp_key
= {
55 .shader_type
= BLORP_SHADER_TYPE_CLEAR
,
56 .use_simd16_replicated_data
= use_replicated_data
,
57 .clear_rgb_as_red
= clear_rgb_as_red
,
60 if (blorp
->lookup_shader(batch
, &blorp_key
, sizeof(blorp_key
),
61 ¶ms
->wm_prog_kernel
, ¶ms
->wm_prog_data
))
64 void *mem_ctx
= ralloc_context(NULL
);
67 blorp_nir_init_shader(&b
, mem_ctx
, MESA_SHADER_FRAGMENT
, "BLORP-clear");
69 nir_variable
*v_color
=
70 BLORP_CREATE_NIR_INPUT(b
.shader
, clear_color
, glsl_vec4_type());
71 nir_ssa_def
*color
= nir_load_var(&b
, v_color
);
73 if (clear_rgb_as_red
) {
74 nir_ssa_def
*pos
= nir_f2i32(&b
, nir_load_frag_coord(&b
));
75 nir_ssa_def
*comp
= nir_umod(&b
, nir_channel(&b
, pos
, 0),
77 nir_ssa_def
*color_component
=
78 nir_bcsel(&b
, nir_ieq(&b
, comp
, nir_imm_int(&b
, 0)),
79 nir_channel(&b
, color
, 0),
80 nir_bcsel(&b
, nir_ieq(&b
, comp
, nir_imm_int(&b
, 1)),
81 nir_channel(&b
, color
, 1),
82 nir_channel(&b
, color
, 2)));
84 nir_ssa_def
*u
= nir_ssa_undef(&b
, 1, 32);
85 color
= nir_vec4(&b
, color_component
, u
, u
, u
);
88 nir_variable
*frag_color
= nir_variable_create(b
.shader
, nir_var_shader_out
,
91 frag_color
->data
.location
= FRAG_RESULT_COLOR
;
92 nir_store_var(&b
, frag_color
, color
, 0xf);
94 struct brw_wm_prog_key wm_key
;
95 brw_blorp_init_wm_prog_key(&wm_key
);
97 struct brw_wm_prog_data prog_data
;
98 const unsigned *program
=
99 blorp_compile_fs(blorp
, mem_ctx
, b
.shader
, &wm_key
, use_replicated_data
,
103 blorp
->upload_shader(batch
, MESA_SHADER_FRAGMENT
,
104 &blorp_key
, sizeof(blorp_key
),
105 program
, prog_data
.base
.program_size
,
106 &prog_data
.base
, sizeof(prog_data
),
107 ¶ms
->wm_prog_kernel
, ¶ms
->wm_prog_data
);
109 ralloc_free(mem_ctx
);
113 #pragma pack(push, 1)
114 struct layer_offset_vs_key
{
115 enum blorp_shader_type shader_type
;
120 /* In the case of doing attachment clears, we are using a surface state that
121 * is handed to us so we can't set (and don't even know) the base array layer.
122 * In order to do a layered clear in this scenario, we need some way of adding
123 * the base array layer to the instance id. Unfortunately, our hardware has
124 * no real concept of "base instance", so we have to do it manually in a
128 blorp_params_get_layer_offset_vs(struct blorp_batch
*batch
,
129 struct blorp_params
*params
)
131 struct blorp_context
*blorp
= batch
->blorp
;
132 struct layer_offset_vs_key blorp_key
= {
133 .shader_type
= BLORP_SHADER_TYPE_LAYER_OFFSET_VS
,
136 if (params
->wm_prog_data
)
137 blorp_key
.num_inputs
= params
->wm_prog_data
->num_varying_inputs
;
139 if (blorp
->lookup_shader(batch
, &blorp_key
, sizeof(blorp_key
),
140 ¶ms
->vs_prog_kernel
, ¶ms
->vs_prog_data
))
143 void *mem_ctx
= ralloc_context(NULL
);
146 blorp_nir_init_shader(&b
, mem_ctx
, MESA_SHADER_VERTEX
, "BLORP-layer-offset-vs");
148 const struct glsl_type
*uvec4_type
= glsl_vector_type(GLSL_TYPE_UINT
, 4);
150 /* First we deal with the header which has instance and base instance */
151 nir_variable
*a_header
= nir_variable_create(b
.shader
, nir_var_shader_in
,
152 uvec4_type
, "header");
153 a_header
->data
.location
= VERT_ATTRIB_GENERIC0
;
155 nir_variable
*v_layer
= nir_variable_create(b
.shader
, nir_var_shader_out
,
156 glsl_int_type(), "layer_id");
157 v_layer
->data
.location
= VARYING_SLOT_LAYER
;
159 /* Compute the layer id */
160 nir_ssa_def
*header
= nir_load_var(&b
, a_header
);
161 nir_ssa_def
*base_layer
= nir_channel(&b
, header
, 0);
162 nir_ssa_def
*instance
= nir_channel(&b
, header
, 1);
163 nir_store_var(&b
, v_layer
, nir_iadd(&b
, instance
, base_layer
), 0x1);
165 /* Then we copy the vertex from the next slot to VARYING_SLOT_POS */
166 nir_variable
*a_vertex
= nir_variable_create(b
.shader
, nir_var_shader_in
,
167 glsl_vec4_type(), "a_vertex");
168 a_vertex
->data
.location
= VERT_ATTRIB_GENERIC1
;
170 nir_variable
*v_pos
= nir_variable_create(b
.shader
, nir_var_shader_out
,
171 glsl_vec4_type(), "v_pos");
172 v_pos
->data
.location
= VARYING_SLOT_POS
;
174 nir_copy_var(&b
, v_pos
, a_vertex
);
176 /* Then we copy everything else */
177 for (unsigned i
= 0; i
< blorp_key
.num_inputs
; i
++) {
178 nir_variable
*a_in
= nir_variable_create(b
.shader
, nir_var_shader_in
,
179 uvec4_type
, "input");
180 a_in
->data
.location
= VERT_ATTRIB_GENERIC2
+ i
;
182 nir_variable
*v_out
= nir_variable_create(b
.shader
, nir_var_shader_out
,
183 uvec4_type
, "output");
184 v_out
->data
.location
= VARYING_SLOT_VAR0
+ i
;
186 nir_copy_var(&b
, v_out
, a_in
);
189 struct brw_vs_prog_data vs_prog_data
;
190 memset(&vs_prog_data
, 0, sizeof(vs_prog_data
));
192 const unsigned *program
=
193 blorp_compile_vs(blorp
, mem_ctx
, b
.shader
, &vs_prog_data
);
196 blorp
->upload_shader(batch
, MESA_SHADER_VERTEX
,
197 &blorp_key
, sizeof(blorp_key
),
198 program
, vs_prog_data
.base
.base
.program_size
,
199 &vs_prog_data
.base
.base
, sizeof(vs_prog_data
),
200 ¶ms
->vs_prog_kernel
, ¶ms
->vs_prog_data
);
202 ralloc_free(mem_ctx
);
206 /* The x0, y0, x1, and y1 parameters must already be populated with the render
207 * area of the framebuffer to be cleared.
210 get_fast_clear_rect(const struct isl_device
*dev
,
211 const struct isl_surf
*aux_surf
,
212 unsigned *x0
, unsigned *y0
,
213 unsigned *x1
, unsigned *y1
)
215 unsigned int x_align
, y_align
;
216 unsigned int x_scaledown
, y_scaledown
;
218 /* Only single sampled surfaces need to (and actually can) be resolved. */
219 if (aux_surf
->usage
== ISL_SURF_USAGE_CCS_BIT
) {
220 /* From the Ivy Bridge PRM, Vol2 Part1 11.7 "MCS Buffer for Render
221 * Target(s)", beneath the "Fast Color Clear" bullet (p327):
223 * Clear pass must have a clear rectangle that must follow
224 * alignment rules in terms of pixels and lines as shown in the
225 * table below. Further, the clear-rectangle height and width
226 * must be multiple of the following dimensions. If the height
227 * and width of the render target being cleared do not meet these
228 * requirements, an MCS buffer can be created such that it
229 * follows the requirement and covers the RT.
231 * The alignment size in the table that follows is related to the
232 * alignment size that is baked into the CCS surface format but with X
233 * alignment multiplied by 16 and Y alignment multiplied by 32.
235 x_align
= isl_format_get_layout(aux_surf
->format
)->bw
;
236 y_align
= isl_format_get_layout(aux_surf
->format
)->bh
;
240 /* The line alignment requirement for Y-tiled is halved at SKL and again
243 if (dev
->info
->gen
>= 12)
245 else if (dev
->info
->gen
>= 9)
250 /* From the Ivy Bridge PRM, Vol2 Part1 11.7 "MCS Buffer for Render
251 * Target(s)", beneath the "Fast Color Clear" bullet (p327):
253 * In order to optimize the performance MCS buffer (when bound to
254 * 1X RT) clear similarly to MCS buffer clear for MSRT case,
255 * clear rect is required to be scaled by the following factors
256 * in the horizontal and vertical directions:
258 * The X and Y scale down factors in the table that follows are each
259 * equal to half the alignment value computed above.
261 x_scaledown
= x_align
/ 2;
262 y_scaledown
= y_align
/ 2;
264 if (ISL_DEV_IS_HASWELL(dev
)) {
265 /* From BSpec: 3D-Media-GPGPU Engine > 3D Pipeline > Pixel > Pixel
266 * Backend > MCS Buffer for Render Target(s) [DevIVB+] > Table "Color
267 * Clear of Non-MultiSampled Render Target Restrictions":
269 * Clear rectangle must be aligned to two times the number of
270 * pixels in the table shown below due to 16x16 hashing across the
273 * This restriction is only documented to exist on HSW GT3 but
274 * empirical evidence suggests that it's also needed GT2.
280 assert(aux_surf
->usage
== ISL_SURF_USAGE_MCS_BIT
);
282 /* From the Ivy Bridge PRM, Vol2 Part1 11.7 "MCS Buffer for Render
283 * Target(s)", beneath the "MSAA Compression" bullet (p326):
285 * Clear pass for this case requires that scaled down primitive
286 * is sent down with upper left co-ordinate to coincide with
287 * actual rectangle being cleared. For MSAA, clear rectangle’s
288 * height and width need to as show in the following table in
289 * terms of (width,height) of the RT.
291 * MSAA Width of Clear Rect Height of Clear Rect
292 * 2X Ceil(1/8*width) Ceil(1/2*height)
293 * 4X Ceil(1/8*width) Ceil(1/2*height)
294 * 8X Ceil(1/2*width) Ceil(1/2*height)
295 * 16X width Ceil(1/2*height)
297 * The text "with upper left co-ordinate to coincide with actual
298 * rectangle being cleared" is a little confusing--it seems to imply
299 * that to clear a rectangle from (x,y) to (x+w,y+h), one needs to
300 * feed the pipeline using the rectangle (x,y) to
301 * (x+Ceil(w/N),y+Ceil(h/2)), where N is either 2 or 8 depending on
302 * the number of samples. Experiments indicate that this is not
303 * quite correct; actually, what the hardware appears to do is to
304 * align whatever rectangle is sent down the pipeline to the nearest
305 * multiple of 2x2 blocks, and then scale it up by a factor of N
306 * horizontally and 2 vertically. So the resulting alignment is 4
307 * vertically and either 4 or 16 horizontally, and the scaledown
308 * factor is 2 vertically and either 2 or 8 horizontally.
310 switch (aux_surf
->format
) {
311 case ISL_FORMAT_MCS_2X
:
312 case ISL_FORMAT_MCS_4X
:
315 case ISL_FORMAT_MCS_8X
:
318 case ISL_FORMAT_MCS_16X
:
322 unreachable("Unexpected MCS format for fast clear");
325 x_align
= x_scaledown
* 2;
326 y_align
= y_scaledown
* 2;
329 *x0
= ROUND_DOWN_TO(*x0
, x_align
) / x_scaledown
;
330 *y0
= ROUND_DOWN_TO(*y0
, y_align
) / y_scaledown
;
331 *x1
= ALIGN(*x1
, x_align
) / x_scaledown
;
332 *y1
= ALIGN(*y1
, y_align
) / y_scaledown
;
336 blorp_fast_clear(struct blorp_batch
*batch
,
337 const struct blorp_surf
*surf
,
338 enum isl_format format
, struct isl_swizzle swizzle
,
339 uint32_t level
, uint32_t start_layer
, uint32_t num_layers
,
340 uint32_t x0
, uint32_t y0
, uint32_t x1
, uint32_t y1
)
342 struct blorp_params params
;
343 blorp_params_init(¶ms
);
344 params
.num_layers
= num_layers
;
351 memset(¶ms
.wm_inputs
.clear_color
, 0xff, 4*sizeof(float));
352 params
.fast_clear_op
= ISL_AUX_OP_FAST_CLEAR
;
354 get_fast_clear_rect(batch
->blorp
->isl_dev
, surf
->aux_surf
,
355 ¶ms
.x0
, ¶ms
.y0
, ¶ms
.x1
, ¶ms
.y1
);
357 if (!blorp_params_get_clear_kernel(batch
, ¶ms
, true, false))
360 brw_blorp_surface_info_init(batch
->blorp
, ¶ms
.dst
, surf
, level
,
361 start_layer
, format
, true);
362 params
.num_samples
= params
.dst
.surf
.samples
;
364 /* If a swizzle was provided, we need to swizzle the clear color so that
365 * the hardware color format conversion will work properly.
367 params
.dst
.clear_color
= swizzle_color_value(params
.dst
.clear_color
,
370 batch
->blorp
->exec(batch
, ¶ms
);
373 union isl_color_value
374 swizzle_color_value(union isl_color_value src
, struct isl_swizzle swizzle
)
376 union isl_color_value dst
= { .u32
= { 0, } };
378 /* We assign colors in ABGR order so that the first one will be taken in
379 * RGBA precedence order. According to the PRM docs for shader channel
380 * select, this matches Haswell hardware behavior.
382 if ((unsigned)(swizzle
.a
- ISL_CHANNEL_SELECT_RED
) < 4)
383 dst
.u32
[swizzle
.a
- ISL_CHANNEL_SELECT_RED
] = src
.u32
[3];
384 if ((unsigned)(swizzle
.b
- ISL_CHANNEL_SELECT_RED
) < 4)
385 dst
.u32
[swizzle
.b
- ISL_CHANNEL_SELECT_RED
] = src
.u32
[2];
386 if ((unsigned)(swizzle
.g
- ISL_CHANNEL_SELECT_RED
) < 4)
387 dst
.u32
[swizzle
.g
- ISL_CHANNEL_SELECT_RED
] = src
.u32
[1];
388 if ((unsigned)(swizzle
.r
- ISL_CHANNEL_SELECT_RED
) < 4)
389 dst
.u32
[swizzle
.r
- ISL_CHANNEL_SELECT_RED
] = src
.u32
[0];
395 blorp_clear(struct blorp_batch
*batch
,
396 const struct blorp_surf
*surf
,
397 enum isl_format format
, struct isl_swizzle swizzle
,
398 uint32_t level
, uint32_t start_layer
, uint32_t num_layers
,
399 uint32_t x0
, uint32_t y0
, uint32_t x1
, uint32_t y1
,
400 union isl_color_value clear_color
,
401 const bool color_write_disable
[4])
403 struct blorp_params params
;
404 blorp_params_init(¶ms
);
406 /* Manually apply the clear destination swizzle. This way swizzled clears
407 * will work for swizzles which we can't normally use for rendering and it
408 * also ensures that they work on pre-Haswell hardware which can't swizlle
411 clear_color
= swizzle_color_value(clear_color
, swizzle
);
412 swizzle
= ISL_SWIZZLE_IDENTITY
;
414 bool clear_rgb_as_red
= false;
415 if (format
== ISL_FORMAT_R9G9B9E5_SHAREDEXP
) {
416 clear_color
.u32
[0] = float3_to_rgb9e5(clear_color
.f32
);
417 format
= ISL_FORMAT_R32_UINT
;
418 } else if (format
== ISL_FORMAT_L8_UNORM_SRGB
) {
419 clear_color
.f32
[0] = util_format_linear_to_srgb_float(clear_color
.f32
[0]);
420 format
= ISL_FORMAT_R8_UNORM
;
421 } else if (format
== ISL_FORMAT_A4B4G4R4_UNORM
) {
422 /* Broadwell and earlier cannot render to this format so we need to work
423 * around it by swapping the colors around and using B4G4R4A4 instead.
425 const struct isl_swizzle ARGB
= ISL_SWIZZLE(ALPHA
, RED
, GREEN
, BLUE
);
426 clear_color
= swizzle_color_value(clear_color
, ARGB
);
427 format
= ISL_FORMAT_B4G4R4A4_UNORM
;
428 } else if (isl_format_get_layout(format
)->bpb
% 3 == 0) {
429 clear_rgb_as_red
= true;
430 if (format
== ISL_FORMAT_R8G8B8_UNORM_SRGB
) {
431 clear_color
.f32
[0] = util_format_linear_to_srgb_float(clear_color
.f32
[0]);
432 clear_color
.f32
[1] = util_format_linear_to_srgb_float(clear_color
.f32
[1]);
433 clear_color
.f32
[2] = util_format_linear_to_srgb_float(clear_color
.f32
[2]);
437 memcpy(¶ms
.wm_inputs
.clear_color
, clear_color
.f32
, sizeof(float) * 4);
439 bool use_simd16_replicated_data
= true;
441 /* From the SNB PRM (Vol4_Part1):
443 * "Replicated data (Message Type = 111) is only supported when
444 * accessing tiled memory. Using this Message Type to access linear
445 * (untiled) memory is UNDEFINED."
447 if (surf
->surf
->tiling
== ISL_TILING_LINEAR
)
448 use_simd16_replicated_data
= false;
450 /* Replicated clears don't work yet before gen6 */
451 if (batch
->blorp
->isl_dev
->info
->gen
< 6)
452 use_simd16_replicated_data
= false;
454 /* Constant color writes ignore everyting in blend and color calculator
455 * state. This is not documented.
457 if (color_write_disable
) {
458 for (unsigned i
= 0; i
< 4; i
++) {
459 params
.color_write_disable
[i
] = color_write_disable
[i
];
460 if (color_write_disable
[i
])
461 use_simd16_replicated_data
= false;
465 if (!blorp_params_get_clear_kernel(batch
, ¶ms
,
466 use_simd16_replicated_data
,
470 if (!blorp_ensure_sf_program(batch
, ¶ms
))
473 while (num_layers
> 0) {
474 brw_blorp_surface_info_init(batch
->blorp
, ¶ms
.dst
, surf
, level
,
475 start_layer
, format
, true);
476 params
.dst
.view
.swizzle
= swizzle
;
483 if (params
.dst
.tile_x_sa
|| params
.dst
.tile_y_sa
) {
484 assert(params
.dst
.surf
.samples
== 1);
485 assert(num_layers
== 1);
486 params
.x0
+= params
.dst
.tile_x_sa
;
487 params
.y0
+= params
.dst
.tile_y_sa
;
488 params
.x1
+= params
.dst
.tile_x_sa
;
489 params
.y1
+= params
.dst
.tile_y_sa
;
492 /* The MinLOD and MinimumArrayElement don't work properly for cube maps.
493 * Convert them to a single slice on gen4.
495 if (batch
->blorp
->isl_dev
->info
->gen
== 4 &&
496 (params
.dst
.surf
.usage
& ISL_SURF_USAGE_CUBE_BIT
)) {
497 blorp_surf_convert_to_single_slice(batch
->blorp
->isl_dev
, ¶ms
.dst
);
500 if (clear_rgb_as_red
) {
501 surf_fake_rgb_with_red(batch
->blorp
->isl_dev
, ¶ms
.dst
);
506 if (isl_format_is_compressed(params
.dst
.surf
.format
)) {
507 blorp_surf_convert_to_uncompressed(batch
->blorp
->isl_dev
, ¶ms
.dst
,
508 NULL
, NULL
, NULL
, NULL
);
509 //&dst_x, &dst_y, &dst_w, &dst_h);
512 if (params
.dst
.tile_x_sa
|| params
.dst
.tile_y_sa
) {
513 /* Either we're on gen4 where there is no multisampling or the
514 * surface is compressed which also implies no multisampling.
515 * Therefore, sa == px and we don't need to do a conversion.
517 assert(params
.dst
.surf
.samples
== 1);
518 params
.x0
+= params
.dst
.tile_x_sa
;
519 params
.y0
+= params
.dst
.tile_y_sa
;
520 params
.x1
+= params
.dst
.tile_x_sa
;
521 params
.y1
+= params
.dst
.tile_y_sa
;
524 params
.num_samples
= params
.dst
.surf
.samples
;
526 /* We may be restricted on the number of layers we can bind at any one
527 * time. In particular, Sandy Bridge has a maximum number of layers of
528 * 512 but a maximum 3D texture size is much larger.
530 params
.num_layers
= MIN2(params
.dst
.view
.array_len
, num_layers
);
532 const unsigned max_image_width
= 16 * 1024;
533 if (params
.dst
.surf
.logical_level0_px
.width
> max_image_width
) {
534 /* Clearing an RGB image as red multiplies the surface width by 3
535 * so it may now be too wide for the hardware surface limits. We
536 * have to break the clear up into pieces in order to clear wide
539 assert(clear_rgb_as_red
);
540 assert(params
.dst
.surf
.dim
== ISL_SURF_DIM_2D
);
541 assert(params
.dst
.surf
.tiling
== ISL_TILING_LINEAR
);
542 assert(params
.dst
.surf
.logical_level0_px
.depth
== 1);
543 assert(params
.dst
.surf
.logical_level0_px
.array_len
== 1);
544 assert(params
.dst
.surf
.levels
== 1);
545 assert(params
.dst
.surf
.samples
== 1);
546 assert(params
.dst
.tile_x_sa
== 0 || params
.dst
.tile_y_sa
== 0);
547 assert(params
.dst
.aux_usage
== ISL_AUX_USAGE_NONE
);
549 /* max_image_width rounded down to a multiple of 3 */
550 const unsigned max_fake_rgb_width
= (max_image_width
/ 3) * 3;
552 isl_format_get_layout(params
.dst
.surf
.format
)->bpb
/ 8;
554 params
.dst
.surf
.logical_level0_px
.width
= max_fake_rgb_width
;
555 params
.dst
.surf
.phys_level0_sa
.width
= max_fake_rgb_width
;
557 uint32_t orig_x0
= params
.x0
, orig_x1
= params
.x1
;
558 uint64_t orig_offset
= params
.dst
.addr
.offset
;
559 for (uint32_t x
= orig_x0
; x
< orig_x1
; x
+= max_fake_rgb_width
) {
560 /* Offset to the surface. It's easy because we're linear */
561 params
.dst
.addr
.offset
= orig_offset
+ x
* cpp
;
564 params
.x1
= MIN2(orig_x1
- x
, max_image_width
);
566 batch
->blorp
->exec(batch
, ¶ms
);
569 batch
->blorp
->exec(batch
, ¶ms
);
572 start_layer
+= params
.num_layers
;
573 num_layers
-= params
.num_layers
;
578 blorp_clear_stencil_as_rgba(struct blorp_batch
*batch
,
579 const struct blorp_surf
*surf
,
580 uint32_t level
, uint32_t start_layer
,
582 uint32_t x0
, uint32_t y0
, uint32_t x1
, uint32_t y1
,
583 uint8_t stencil_mask
, uint8_t stencil_value
)
585 /* We only support separate W-tiled stencil for now */
586 if (surf
->surf
->format
!= ISL_FORMAT_R8_UINT
||
587 surf
->surf
->tiling
!= ISL_TILING_W
)
590 /* Stencil mask support would require piles of shader magic */
591 if (stencil_mask
!= 0xff)
594 if (surf
->surf
->samples
> 1) {
595 /* Adjust x0, y0, x1, and y1 to be in units of samples */
596 assert(surf
->surf
->msaa_layout
== ISL_MSAA_LAYOUT_INTERLEAVED
);
597 struct isl_extent2d msaa_px_size_sa
=
598 isl_get_interleaved_msaa_px_size_sa(surf
->surf
->samples
);
600 x0
*= msaa_px_size_sa
.w
;
601 y0
*= msaa_px_size_sa
.h
;
602 x1
*= msaa_px_size_sa
.w
;
603 y1
*= msaa_px_size_sa
.h
;
606 /* W-tiles and Y-tiles have the same layout as far as cache lines are
607 * concerned: both are 8x8 cache lines laid out Y-major. The difference is
608 * entirely in how the data is arranged withing the cache line. W-tiling
609 * is 8x8 pixels in a swizzled pattern while Y-tiling is 16B by 4 rows
610 * regardless of image format size. As long as everything is aligned to 8,
611 * we can just treat the W-tiled image as Y-tiled, ignore the layout
612 * difference within a cache line, and blast out data.
614 if (x0
% 8 != 0 || y0
% 8 != 0 || x1
% 8 != 0 || y1
% 8 != 0)
617 struct blorp_params params
;
618 blorp_params_init(¶ms
);
620 if (!blorp_params_get_clear_kernel(batch
, ¶ms
, true, false))
623 memset(¶ms
.wm_inputs
.clear_color
, stencil_value
,
624 sizeof(params
.wm_inputs
.clear_color
));
626 /* The Sandy Bridge PRM Vol. 4 Pt. 2, section 2.11.2.1.1 has the
627 * following footnote to the format table:
629 * 128 BPE Formats cannot be Tiled Y when used as render targets
631 * We have to use RGBA16_UINT on SNB.
633 enum isl_format wide_format
;
634 if (ISL_DEV_GEN(batch
->blorp
->isl_dev
) <= 6) {
635 wide_format
= ISL_FORMAT_R16G16B16A16_UINT
;
637 /* For RGBA16_UINT, we need to mask the stencil value otherwise, we risk
638 * clamping giving us the wrong values
640 for (unsigned i
= 0; i
< 4; i
++)
641 params
.wm_inputs
.clear_color
[i
] &= 0xffff;
643 wide_format
= ISL_FORMAT_R32G32B32A32_UINT
;
646 for (uint32_t a
= 0; a
< num_layers
; a
++) {
647 uint32_t layer
= start_layer
+ a
;
649 brw_blorp_surface_info_init(batch
->blorp
, ¶ms
.dst
, surf
, level
,
650 layer
, ISL_FORMAT_UNSUPPORTED
, true);
652 if (surf
->surf
->samples
> 1)
653 blorp_surf_fake_interleaved_msaa(batch
->blorp
->isl_dev
, ¶ms
.dst
);
655 /* Make it Y-tiled */
656 blorp_surf_retile_w_to_y(batch
->blorp
->isl_dev
, ¶ms
.dst
);
659 isl_format_get_layout(wide_format
)->bpb
/ 8;
661 params
.dst
.view
.format
= params
.dst
.surf
.format
= wide_format
;
662 assert(params
.dst
.surf
.logical_level0_px
.width
% wide_Bpp
== 0);
663 params
.dst
.surf
.logical_level0_px
.width
/= wide_Bpp
;
664 assert(params
.dst
.tile_x_sa
% wide_Bpp
== 0);
665 params
.dst
.tile_x_sa
/= wide_Bpp
;
667 params
.x0
= params
.dst
.tile_x_sa
+ x0
/ (wide_Bpp
/ 2);
668 params
.y0
= params
.dst
.tile_y_sa
+ y0
/ 2;
669 params
.x1
= params
.dst
.tile_x_sa
+ x1
/ (wide_Bpp
/ 2);
670 params
.y1
= params
.dst
.tile_y_sa
+ y1
/ 2;
672 batch
->blorp
->exec(batch
, ¶ms
);
679 blorp_clear_depth_stencil(struct blorp_batch
*batch
,
680 const struct blorp_surf
*depth
,
681 const struct blorp_surf
*stencil
,
682 uint32_t level
, uint32_t start_layer
,
684 uint32_t x0
, uint32_t y0
, uint32_t x1
, uint32_t y1
,
685 bool clear_depth
, float depth_value
,
686 uint8_t stencil_mask
, uint8_t stencil_value
)
688 if (!clear_depth
&& blorp_clear_stencil_as_rgba(batch
, stencil
, level
,
689 start_layer
, num_layers
,
695 struct blorp_params params
;
696 blorp_params_init(¶ms
);
703 if (ISL_DEV_GEN(batch
->blorp
->isl_dev
) == 6) {
704 /* For some reason, Sandy Bridge gets occlusion queries wrong if we
705 * don't have a shader. In particular, it records samples even though
706 * we disable statistics in 3DSTATE_WM. Give it the usual clear shader
707 * to work around the issue.
709 if (!blorp_params_get_clear_kernel(batch
, ¶ms
, false, false))
713 while (num_layers
> 0) {
714 params
.num_layers
= num_layers
;
717 brw_blorp_surface_info_init(batch
->blorp
, ¶ms
.stencil
, stencil
,
719 ISL_FORMAT_UNSUPPORTED
, true);
720 params
.stencil_mask
= stencil_mask
;
721 params
.stencil_ref
= stencil_value
;
723 params
.dst
.surf
.samples
= params
.stencil
.surf
.samples
;
724 params
.dst
.surf
.logical_level0_px
=
725 params
.stencil
.surf
.logical_level0_px
;
726 params
.dst
.view
= params
.stencil
.view
;
728 params
.num_samples
= params
.stencil
.surf
.samples
;
730 /* We may be restricted on the number of layers we can bind at any
731 * one time. In particular, Sandy Bridge has a maximum number of
732 * layers of 512 but a maximum 3D texture size is much larger.
734 if (params
.stencil
.view
.array_len
< params
.num_layers
)
735 params
.num_layers
= params
.stencil
.view
.array_len
;
739 brw_blorp_surface_info_init(batch
->blorp
, ¶ms
.depth
, depth
,
741 ISL_FORMAT_UNSUPPORTED
, true);
742 params
.z
= depth_value
;
743 params
.depth_format
=
744 isl_format_get_depth_format(depth
->surf
->format
, false);
746 params
.dst
.surf
.samples
= params
.depth
.surf
.samples
;
747 params
.dst
.surf
.logical_level0_px
=
748 params
.depth
.surf
.logical_level0_px
;
749 params
.dst
.view
= params
.depth
.view
;
751 params
.num_samples
= params
.depth
.surf
.samples
;
753 /* We may be restricted on the number of layers we can bind at any
754 * one time. In particular, Sandy Bridge has a maximum number of
755 * layers of 512 but a maximum 3D texture size is much larger.
757 if (params
.depth
.view
.array_len
< params
.num_layers
)
758 params
.num_layers
= params
.depth
.view
.array_len
;
761 batch
->blorp
->exec(batch
, ¶ms
);
763 start_layer
+= params
.num_layers
;
764 num_layers
-= params
.num_layers
;
769 blorp_can_hiz_clear_depth(const struct gen_device_info
*devinfo
,
770 const struct isl_surf
*surf
,
771 enum isl_aux_usage aux_usage
,
772 uint32_t level
, uint32_t layer
,
773 uint32_t x0
, uint32_t y0
, uint32_t x1
, uint32_t y1
)
775 /* This function currently doesn't support any gen prior to gen8 */
776 assert(devinfo
->gen
>= 8);
778 if (devinfo
->gen
== 8 && surf
->format
== ISL_FORMAT_R16_UNORM
) {
779 /* Apply the D16 alignment restrictions. On BDW, HiZ has an 8x4 sample
780 * block with the following property: as the number of samples increases,
781 * the number of pixels representable by this block decreases by a factor
782 * of the sample dimensions. Sample dimensions scale following the MSAA
783 * interleaved pattern.
785 * Sample|Sample|Pixel
787 * ===================
794 * Table: Pixel Dimensions in a HiZ Sample Block Pre-SKL
796 const struct isl_extent2d sa_block_dim
=
797 isl_get_interleaved_msaa_px_size_sa(surf
->samples
);
798 const uint8_t align_px_w
= 8 / sa_block_dim
.w
;
799 const uint8_t align_px_h
= 4 / sa_block_dim
.h
;
801 /* Fast depth clears clear an entire sample block at a time. As a result,
802 * the rectangle must be aligned to the dimensions of the encompassing
803 * pixel block for a successful operation.
805 * Fast clears can still work if the upper-left corner is aligned and the
806 * bottom-rigtht corner touches the edge of a depth buffer whose extent
807 * is unaligned. This is because each miplevel in the depth buffer is
808 * padded by the Pixel Dim (similar to a standard compressed texture).
809 * In this case, the clear rectangle could be padded by to match the full
810 * depth buffer extent but to support multiple clearing techniques, we
811 * chose to be unaware of the depth buffer's extent and thus don't handle
814 if (x0
% align_px_w
|| y0
% align_px_h
||
815 x1
% align_px_w
|| y1
% align_px_h
)
817 } else if (aux_usage
== ISL_AUX_USAGE_HIZ_CCS_WT
) {
818 /* We have to set the WM_HZ_OP::FullSurfaceDepthandStencilClear bit
819 * whenever we clear an uninitialized HIZ buffer (as some drivers
820 * currently do). However, this bit seems liable to clear 16x8 pixels in
821 * the ZCS on Gen12 - greater than the slice alignments for depth
824 assert(surf
->image_alignment_el
.w
% 16 != 0 ||
825 surf
->image_alignment_el
.h
% 8 != 0);
827 /* This is the hypothesis behind some corruption that was seen with the
828 * amd_vertex_shader_layer-layered-depth-texture-render piglit test.
830 * From the Compressed Depth Buffers section of the Bspec, under the
831 * Gen12 texture performant and ZCS columns:
833 * Update with clear at either 16x8 or 8x4 granularity, based on
834 * fs_clr or otherwise.
836 * There are a number of ways to avoid full surface CCS clears that
837 * overlap other slices, but for now we choose to disable fast-clears
838 * when an initializing clear could hit another miplevel.
840 * NOTE: Because the CCS compresses the depth buffer and not a version
841 * of it that has been rearranged with different alignments (like Gen8+
842 * HIZ), we have to make sure that the x0 and y0 are at least 16x8
843 * aligned in the context of the entire surface.
845 uint32_t slice_x0
, slice_y0
;
846 isl_surf_get_image_offset_el(surf
, level
,
847 surf
->dim
== ISL_SURF_DIM_3D
? 0 : layer
,
848 surf
->dim
== ISL_SURF_DIM_3D
? layer
: 0,
849 &slice_x0
, &slice_y0
);
850 const bool max_x1_y1
=
851 x1
== minify(surf
->logical_level0_px
.width
, level
) &&
852 y1
== minify(surf
->logical_level0_px
.height
, level
);
853 const uint32_t haligned_x1
= ALIGN(x1
, surf
->image_alignment_el
.w
);
854 const uint32_t valigned_y1
= ALIGN(y1
, surf
->image_alignment_el
.h
);
855 const bool unaligned
= (slice_x0
+ x0
) % 16 || (slice_y0
+ y0
) % 8 ||
856 max_x1_y1
? haligned_x1
% 16 || valigned_y1
% 8 :
858 const bool alignment_used
= surf
->levels
> 1 ||
859 surf
->logical_level0_px
.depth
> 1 ||
860 surf
->logical_level0_px
.array_len
> 1;
862 if (unaligned
&& alignment_used
)
866 return isl_aux_usage_has_hiz(aux_usage
);
870 blorp_hiz_clear_depth_stencil(struct blorp_batch
*batch
,
871 const struct blorp_surf
*depth
,
872 const struct blorp_surf
*stencil
,
874 uint32_t start_layer
, uint32_t num_layers
,
875 uint32_t x0
, uint32_t y0
,
876 uint32_t x1
, uint32_t y1
,
877 bool clear_depth
, float depth_value
,
878 bool clear_stencil
, uint8_t stencil_value
)
880 struct blorp_params params
;
881 blorp_params_init(¶ms
);
883 /* This requires WM_HZ_OP which only exists on gen8+ */
884 assert(ISL_DEV_GEN(batch
->blorp
->isl_dev
) >= 8);
886 params
.hiz_op
= ISL_AUX_OP_FAST_CLEAR
;
887 params
.num_layers
= 1;
894 for (uint32_t l
= 0; l
< num_layers
; l
++) {
895 const uint32_t layer
= start_layer
+ l
;
897 brw_blorp_surface_info_init(batch
->blorp
, ¶ms
.stencil
, stencil
,
899 ISL_FORMAT_UNSUPPORTED
, true);
900 params
.stencil_mask
= 0xff;
901 params
.stencil_ref
= stencil_value
;
902 params
.num_samples
= params
.stencil
.surf
.samples
;
906 /* If we're clearing depth, we must have HiZ */
907 assert(depth
&& depth
->aux_usage
== ISL_AUX_USAGE_HIZ
);
909 brw_blorp_surface_info_init(batch
->blorp
, ¶ms
.depth
, depth
,
911 ISL_FORMAT_UNSUPPORTED
, true);
912 params
.depth
.clear_color
.f32
[0] = depth_value
;
913 params
.depth_format
=
914 isl_format_get_depth_format(depth
->surf
->format
, false);
915 params
.num_samples
= params
.depth
.surf
.samples
;
918 batch
->blorp
->exec(batch
, ¶ms
);
922 /* Given a depth stencil attachment, this function performs a fast depth clear
923 * on a depth portion and a regular clear on the stencil portion. When
924 * performing a fast depth clear on the depth portion, the HiZ buffer is simply
925 * tagged as cleared so the depth clear value is not actually needed.
928 blorp_gen8_hiz_clear_attachments(struct blorp_batch
*batch
,
929 uint32_t num_samples
,
930 uint32_t x0
, uint32_t y0
,
931 uint32_t x1
, uint32_t y1
,
932 bool clear_depth
, bool clear_stencil
,
933 uint8_t stencil_value
)
935 assert(batch
->flags
& BLORP_BATCH_NO_EMIT_DEPTH_STENCIL
);
937 struct blorp_params params
;
938 blorp_params_init(¶ms
);
939 params
.num_layers
= 1;
940 params
.hiz_op
= ISL_AUX_OP_FAST_CLEAR
;
945 params
.num_samples
= num_samples
;
946 params
.depth
.enabled
= clear_depth
;
947 params
.stencil
.enabled
= clear_stencil
;
948 params
.stencil_ref
= stencil_value
;
949 batch
->blorp
->exec(batch
, ¶ms
);
952 /** Clear active color/depth/stencili attachments
954 * This function performs a clear operation on the currently bound
955 * color/depth/stencil attachments. It is assumed that any information passed
956 * in here is valid, consistent, and in-bounds relative to the currently
957 * attached depth/stencil. The binding_table_offset parameter is the 32-bit
958 * offset relative to surface state base address where pre-baked binding table
959 * that we are to use lives. If clear_color is false, binding_table_offset
960 * must point to a binding table with one entry which is a valid null surface
961 * that matches the currently bound depth and stencil.
964 blorp_clear_attachments(struct blorp_batch
*batch
,
965 uint32_t binding_table_offset
,
966 enum isl_format depth_format
,
967 uint32_t num_samples
,
968 uint32_t start_layer
, uint32_t num_layers
,
969 uint32_t x0
, uint32_t y0
, uint32_t x1
, uint32_t y1
,
970 bool clear_color
, union isl_color_value color_value
,
971 bool clear_depth
, float depth_value
,
972 uint8_t stencil_mask
, uint8_t stencil_value
)
974 struct blorp_params params
;
975 blorp_params_init(¶ms
);
977 assert(batch
->flags
& BLORP_BATCH_NO_EMIT_DEPTH_STENCIL
);
984 params
.use_pre_baked_binding_table
= true;
985 params
.pre_baked_binding_table_offset
= binding_table_offset
;
987 params
.num_layers
= num_layers
;
988 params
.num_samples
= num_samples
;
991 params
.dst
.enabled
= true;
993 memcpy(¶ms
.wm_inputs
.clear_color
, color_value
.f32
, sizeof(float) * 4);
995 /* Unfortunately, without knowing whether or not our destination surface
996 * is tiled or not, we have to assume it may be linear. This means no
997 * SIMD16_REPDATA for us. :-(
999 if (!blorp_params_get_clear_kernel(batch
, ¶ms
, false, false))
1004 params
.depth
.enabled
= true;
1006 params
.z
= depth_value
;
1007 params
.depth_format
= isl_format_get_depth_format(depth_format
, false);
1011 params
.stencil
.enabled
= true;
1013 params
.stencil_mask
= stencil_mask
;
1014 params
.stencil_ref
= stencil_value
;
1017 if (!blorp_params_get_layer_offset_vs(batch
, ¶ms
))
1020 params
.vs_inputs
.base_layer
= start_layer
;
1022 batch
->blorp
->exec(batch
, ¶ms
);
1026 blorp_ccs_resolve(struct blorp_batch
*batch
,
1027 struct blorp_surf
*surf
, uint32_t level
,
1028 uint32_t start_layer
, uint32_t num_layers
,
1029 enum isl_format format
,
1030 enum isl_aux_op resolve_op
)
1032 struct blorp_params params
;
1034 blorp_params_init(¶ms
);
1035 brw_blorp_surface_info_init(batch
->blorp
, ¶ms
.dst
, surf
,
1036 level
, start_layer
, format
, true);
1038 /* From the Ivy Bridge PRM, Vol2 Part1 11.9 "Render Target Resolve":
1040 * A rectangle primitive must be scaled down by the following factors
1041 * with respect to render target being resolved.
1043 * The scaledown factors in the table that follows are related to the block
1044 * size of the CCS format. For IVB and HSW, we divide by two, for BDW we
1045 * multiply by 8 and 16. On Sky Lake, we multiply by 8.
1047 const struct isl_format_layout
*aux_fmtl
=
1048 isl_format_get_layout(params
.dst
.aux_surf
.format
);
1049 assert(aux_fmtl
->txc
== ISL_TXC_CCS
);
1051 unsigned x_scaledown
, y_scaledown
;
1052 if (ISL_DEV_GEN(batch
->blorp
->isl_dev
) >= 12) {
1053 x_scaledown
= aux_fmtl
->bw
* 8;
1054 y_scaledown
= aux_fmtl
->bh
* 4;
1055 } else if (ISL_DEV_GEN(batch
->blorp
->isl_dev
) >= 9) {
1056 x_scaledown
= aux_fmtl
->bw
* 8;
1057 y_scaledown
= aux_fmtl
->bh
* 8;
1058 } else if (ISL_DEV_GEN(batch
->blorp
->isl_dev
) >= 8) {
1059 x_scaledown
= aux_fmtl
->bw
* 8;
1060 y_scaledown
= aux_fmtl
->bh
* 16;
1062 x_scaledown
= aux_fmtl
->bw
/ 2;
1063 y_scaledown
= aux_fmtl
->bh
/ 2;
1065 params
.x0
= params
.y0
= 0;
1066 params
.x1
= minify(params
.dst
.surf
.logical_level0_px
.width
, level
);
1067 params
.y1
= minify(params
.dst
.surf
.logical_level0_px
.height
, level
);
1068 params
.x1
= ALIGN(params
.x1
, x_scaledown
) / x_scaledown
;
1069 params
.y1
= ALIGN(params
.y1
, y_scaledown
) / y_scaledown
;
1071 if (batch
->blorp
->isl_dev
->info
->gen
>= 10) {
1072 assert(resolve_op
== ISL_AUX_OP_FULL_RESOLVE
||
1073 resolve_op
== ISL_AUX_OP_PARTIAL_RESOLVE
||
1074 resolve_op
== ISL_AUX_OP_AMBIGUATE
);
1075 } else if (batch
->blorp
->isl_dev
->info
->gen
>= 9) {
1076 assert(resolve_op
== ISL_AUX_OP_FULL_RESOLVE
||
1077 resolve_op
== ISL_AUX_OP_PARTIAL_RESOLVE
);
1079 /* Broadwell and earlier do not have a partial resolve */
1080 assert(resolve_op
== ISL_AUX_OP_FULL_RESOLVE
);
1082 params
.fast_clear_op
= resolve_op
;
1083 params
.num_layers
= num_layers
;
1085 /* Note: there is no need to initialize push constants because it doesn't
1086 * matter what data gets dispatched to the render target. However, we must
1087 * ensure that the fragment shader delivers the data using the "replicated
1091 if (!blorp_params_get_clear_kernel(batch
, ¶ms
, true, false))
1094 batch
->blorp
->exec(batch
, ¶ms
);
1097 static nir_ssa_def
*
1098 blorp_nir_bit(nir_builder
*b
, nir_ssa_def
*src
, unsigned bit
)
1100 return nir_iand(b
, nir_ushr(b
, src
, nir_imm_int(b
, bit
)),
1104 #pragma pack(push, 1)
1105 struct blorp_mcs_partial_resolve_key
1107 enum blorp_shader_type shader_type
;
1108 bool indirect_clear_color
;
1110 uint32_t num_samples
;
1115 blorp_params_get_mcs_partial_resolve_kernel(struct blorp_batch
*batch
,
1116 struct blorp_params
*params
)
1118 struct blorp_context
*blorp
= batch
->blorp
;
1119 const struct blorp_mcs_partial_resolve_key blorp_key
= {
1120 .shader_type
= BLORP_SHADER_TYPE_MCS_PARTIAL_RESOLVE
,
1121 .indirect_clear_color
= params
->dst
.clear_color_addr
.buffer
!= NULL
,
1122 .int_format
= isl_format_has_int_channel(params
->dst
.view
.format
),
1123 .num_samples
= params
->num_samples
,
1126 if (blorp
->lookup_shader(batch
, &blorp_key
, sizeof(blorp_key
),
1127 ¶ms
->wm_prog_kernel
, ¶ms
->wm_prog_data
))
1130 void *mem_ctx
= ralloc_context(NULL
);
1133 blorp_nir_init_shader(&b
, mem_ctx
, MESA_SHADER_FRAGMENT
,
1134 "BLORP-mcs-partial-resolve");
1136 nir_variable
*v_color
=
1137 BLORP_CREATE_NIR_INPUT(b
.shader
, clear_color
, glsl_vec4_type());
1139 nir_variable
*frag_color
=
1140 nir_variable_create(b
.shader
, nir_var_shader_out
,
1141 glsl_vec4_type(), "gl_FragColor");
1142 frag_color
->data
.location
= FRAG_RESULT_COLOR
;
1144 /* Do an MCS fetch and check if it is equal to the magic clear value */
1146 blorp_nir_txf_ms_mcs(&b
, nir_f2i32(&b
, nir_load_frag_coord(&b
)),
1147 nir_load_layer_id(&b
));
1148 nir_ssa_def
*is_clear
=
1149 blorp_nir_mcs_is_clear_color(&b
, mcs
, blorp_key
.num_samples
);
1151 /* If we aren't the clear value, discard. */
1152 nir_intrinsic_instr
*discard
=
1153 nir_intrinsic_instr_create(b
.shader
, nir_intrinsic_discard_if
);
1154 discard
->src
[0] = nir_src_for_ssa(nir_inot(&b
, is_clear
));
1155 nir_builder_instr_insert(&b
, &discard
->instr
);
1157 nir_ssa_def
*clear_color
= nir_load_var(&b
, v_color
);
1158 if (blorp_key
.indirect_clear_color
&& blorp
->isl_dev
->info
->gen
<= 8) {
1159 /* Gen7-8 clear colors are stored as single 0/1 bits */
1160 clear_color
= nir_vec4(&b
, blorp_nir_bit(&b
, clear_color
, 31),
1161 blorp_nir_bit(&b
, clear_color
, 30),
1162 blorp_nir_bit(&b
, clear_color
, 29),
1163 blorp_nir_bit(&b
, clear_color
, 28));
1165 if (!blorp_key
.int_format
)
1166 clear_color
= nir_i2f32(&b
, clear_color
);
1168 nir_store_var(&b
, frag_color
, clear_color
, 0xf);
1170 struct brw_wm_prog_key wm_key
;
1171 brw_blorp_init_wm_prog_key(&wm_key
);
1172 wm_key
.base
.tex
.compressed_multisample_layout_mask
= 1;
1173 wm_key
.base
.tex
.msaa_16
= blorp_key
.num_samples
== 16;
1174 wm_key
.multisample_fbo
= true;
1176 struct brw_wm_prog_data prog_data
;
1177 const unsigned *program
=
1178 blorp_compile_fs(blorp
, mem_ctx
, b
.shader
, &wm_key
, false,
1182 blorp
->upload_shader(batch
, MESA_SHADER_FRAGMENT
,
1183 &blorp_key
, sizeof(blorp_key
),
1184 program
, prog_data
.base
.program_size
,
1185 &prog_data
.base
, sizeof(prog_data
),
1186 ¶ms
->wm_prog_kernel
, ¶ms
->wm_prog_data
);
1188 ralloc_free(mem_ctx
);
1193 blorp_mcs_partial_resolve(struct blorp_batch
*batch
,
1194 struct blorp_surf
*surf
,
1195 enum isl_format format
,
1196 uint32_t start_layer
, uint32_t num_layers
)
1198 struct blorp_params params
;
1199 blorp_params_init(¶ms
);
1201 assert(batch
->blorp
->isl_dev
->info
->gen
>= 7);
1205 params
.x1
= surf
->surf
->logical_level0_px
.width
;
1206 params
.y1
= surf
->surf
->logical_level0_px
.height
;
1208 brw_blorp_surface_info_init(batch
->blorp
, ¶ms
.src
, surf
, 0,
1209 start_layer
, format
, false);
1210 brw_blorp_surface_info_init(batch
->blorp
, ¶ms
.dst
, surf
, 0,
1211 start_layer
, format
, true);
1213 params
.num_samples
= params
.dst
.surf
.samples
;
1214 params
.num_layers
= num_layers
;
1215 params
.dst_clear_color_as_input
= surf
->clear_color_addr
.buffer
!= NULL
;
1217 memcpy(¶ms
.wm_inputs
.clear_color
,
1218 surf
->clear_color
.f32
, sizeof(float) * 4);
1220 if (!blorp_params_get_mcs_partial_resolve_kernel(batch
, ¶ms
))
1223 batch
->blorp
->exec(batch
, ¶ms
);
1226 /** Clear a CCS to the "uncompressed" state
1228 * This pass is the CCS equivalent of a "HiZ resolve". It sets the CCS values
1229 * for a given layer/level of a surface to 0x0 which is the "uncompressed"
1230 * state which tells the sampler to go look at the main surface.
1233 blorp_ccs_ambiguate(struct blorp_batch
*batch
,
1234 struct blorp_surf
*surf
,
1235 uint32_t level
, uint32_t layer
)
1237 if (ISL_DEV_GEN(batch
->blorp
->isl_dev
) >= 10) {
1238 /* On gen10 and above, we have a hardware resolve op for this */
1239 return blorp_ccs_resolve(batch
, surf
, level
, layer
, 1,
1240 surf
->surf
->format
, ISL_AUX_OP_AMBIGUATE
);
1243 struct blorp_params params
;
1244 blorp_params_init(¶ms
);
1246 assert(ISL_DEV_GEN(batch
->blorp
->isl_dev
) >= 7);
1248 const struct isl_format_layout
*aux_fmtl
=
1249 isl_format_get_layout(surf
->aux_surf
->format
);
1250 assert(aux_fmtl
->txc
== ISL_TXC_CCS
);
1252 params
.dst
= (struct brw_blorp_surface_info
) {
1254 .addr
= surf
->aux_addr
,
1256 .usage
= ISL_SURF_USAGE_RENDER_TARGET_BIT
,
1257 .format
= ISL_FORMAT_R32G32B32A32_UINT
,
1259 .base_array_layer
= 0,
1262 .swizzle
= ISL_SWIZZLE_IDENTITY
,
1267 if (surf
->surf
->dim
== ISL_SURF_DIM_3D
) {
1272 uint32_t offset_B
, x_offset_el
, y_offset_el
;
1273 isl_surf_get_image_offset_el(surf
->aux_surf
, level
, layer
, z
,
1274 &x_offset_el
, &y_offset_el
);
1275 isl_tiling_get_intratile_offset_el(surf
->aux_surf
->tiling
, aux_fmtl
->bpb
,
1276 surf
->aux_surf
->row_pitch_B
,
1277 x_offset_el
, y_offset_el
,
1278 &offset_B
, &x_offset_el
, &y_offset_el
);
1279 params
.dst
.addr
.offset
+= offset_B
;
1281 const uint32_t width_px
=
1282 minify(surf
->aux_surf
->logical_level0_px
.width
, level
);
1283 const uint32_t height_px
=
1284 minify(surf
->aux_surf
->logical_level0_px
.height
, level
);
1285 const uint32_t width_el
= DIV_ROUND_UP(width_px
, aux_fmtl
->bw
);
1286 const uint32_t height_el
= DIV_ROUND_UP(height_px
, aux_fmtl
->bh
);
1288 struct isl_tile_info ccs_tile_info
;
1289 isl_surf_get_tile_info(surf
->aux_surf
, &ccs_tile_info
);
1291 /* We're going to map it as a regular RGBA32_UINT surface. We need to
1292 * downscale a good deal. We start by computing the area on the CCS to
1293 * clear in units of Y-tiled cache lines.
1295 uint32_t x_offset_cl
, y_offset_cl
, width_cl
, height_cl
;
1296 if (ISL_DEV_GEN(batch
->blorp
->isl_dev
) >= 8) {
1297 /* From the Sky Lake PRM Vol. 12 in the section on planes:
1299 * "The Color Control Surface (CCS) contains the compression status
1300 * of the cache-line pairs. The compression state of the cache-line
1301 * pair is specified by 2 bits in the CCS. Each CCS cache-line
1302 * represents an area on the main surface of 16x16 sets of 128 byte
1303 * Y-tiled cache-line-pairs. CCS is always Y tiled."
1305 * Each 2-bit surface element in the CCS corresponds to a single
1306 * cache-line pair in the main surface. This means that 16x16 el block
1307 * in the CCS maps to a Y-tiled cache line. Fortunately, CCS layouts
1308 * are calculated with a very large alignment so we can round up to a
1309 * whole cache line without worrying about overdraw.
1312 /* On Broadwell and above, a CCS tile is the same as a Y tile when
1313 * viewed at the cache-line granularity. Fortunately, the horizontal
1314 * and vertical alignment requirements of the CCS are such that we can
1315 * align to an entire cache line without worrying about crossing over
1316 * from one LOD to another.
1318 const uint32_t x_el_per_cl
= ccs_tile_info
.logical_extent_el
.w
/ 8;
1319 const uint32_t y_el_per_cl
= ccs_tile_info
.logical_extent_el
.h
/ 8;
1320 assert(surf
->aux_surf
->image_alignment_el
.w
% x_el_per_cl
== 0);
1321 assert(surf
->aux_surf
->image_alignment_el
.h
% y_el_per_cl
== 0);
1323 assert(x_offset_el
% x_el_per_cl
== 0);
1324 assert(y_offset_el
% y_el_per_cl
== 0);
1325 x_offset_cl
= x_offset_el
/ x_el_per_cl
;
1326 y_offset_cl
= y_offset_el
/ y_el_per_cl
;
1327 width_cl
= DIV_ROUND_UP(width_el
, x_el_per_cl
);
1328 height_cl
= DIV_ROUND_UP(height_el
, y_el_per_cl
);
1330 /* On gen7, the CCS tiling is not so nice. However, there we are
1331 * guaranteed that we only have a single level and slice so we don't
1332 * have to worry about it and can just align to a whole tile.
1334 assert(surf
->aux_surf
->logical_level0_px
.depth
== 1);
1335 assert(surf
->aux_surf
->logical_level0_px
.array_len
== 1);
1336 assert(x_offset_el
== 0 && y_offset_el
== 0);
1337 const uint32_t width_tl
=
1338 DIV_ROUND_UP(width_el
, ccs_tile_info
.logical_extent_el
.w
);
1339 const uint32_t height_tl
=
1340 DIV_ROUND_UP(height_el
, ccs_tile_info
.logical_extent_el
.h
);
1343 width_cl
= width_tl
* 8;
1344 height_cl
= height_tl
* 8;
1347 /* We're going to use a RGBA32 format so as to write data as quickly as
1348 * possible. A y-tiled cache line will then be 1x4 px.
1350 const uint32_t x_offset_rgba_px
= x_offset_cl
;
1351 const uint32_t y_offset_rgba_px
= y_offset_cl
* 4;
1352 const uint32_t width_rgba_px
= width_cl
;
1353 const uint32_t height_rgba_px
= height_cl
* 4;
1356 isl_surf_init(batch
->blorp
->isl_dev
, ¶ms
.dst
.surf
,
1357 .dim
= ISL_SURF_DIM_2D
,
1358 .format
= ISL_FORMAT_R32G32B32A32_UINT
,
1359 .width
= width_rgba_px
+ x_offset_rgba_px
,
1360 .height
= height_rgba_px
+ y_offset_rgba_px
,
1365 .row_pitch_B
= surf
->aux_surf
->row_pitch_B
,
1366 .usage
= ISL_SURF_USAGE_RENDER_TARGET_BIT
,
1367 .tiling_flags
= ISL_TILING_Y0_BIT
);
1370 params
.x0
= x_offset_rgba_px
;
1371 params
.y0
= y_offset_rgba_px
;
1372 params
.x1
= x_offset_rgba_px
+ width_rgba_px
;
1373 params
.y1
= y_offset_rgba_px
+ height_rgba_px
;
1375 /* A CCS value of 0 means "uncompressed." */
1376 memset(¶ms
.wm_inputs
.clear_color
, 0,
1377 sizeof(params
.wm_inputs
.clear_color
));
1379 if (!blorp_params_get_clear_kernel(batch
, ¶ms
, true, false))
1382 batch
->blorp
->exec(batch
, ¶ms
);