2 * Mesa 3-D graphics library
4 * Copyright (C) 2013 LunarG, Inc.
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included
14 * in all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22 * DEALINGS IN THE SOFTWARE.
25 * Chia-I Wu <olv@lunarg.com>
28 #include "genhw/genhw.h"
29 #include "util/u_dual_blend.h"
31 #include "ilo_blitter.h"
32 #include "ilo_builder_3d.h"
33 #include "ilo_builder_render.h"
34 #include "ilo_shader.h"
35 #include "ilo_state.h"
36 #include "ilo_render_gen.h"
39 * A wrapper for gen6_PIPE_CONTROL().
42 gen7_pipe_control(struct ilo_render
*r
, uint32_t dw1
)
44 struct intel_bo
*bo
= (dw1
& GEN6_PIPE_CONTROL_WRITE__MASK
) ?
45 r
->workaround_bo
: NULL
;
47 ILO_DEV_ASSERT(r
->dev
, 7, 7.5);
49 if (dw1
& GEN6_PIPE_CONTROL_CS_STALL
) {
50 /* CS stall cannot be set alone */
51 const uint32_t mask
= GEN6_PIPE_CONTROL_RENDER_CACHE_FLUSH
|
52 GEN6_PIPE_CONTROL_DEPTH_CACHE_FLUSH
|
53 GEN6_PIPE_CONTROL_PIXEL_SCOREBOARD_STALL
|
54 GEN6_PIPE_CONTROL_DEPTH_STALL
|
55 GEN6_PIPE_CONTROL_WRITE__MASK
;
57 dw1
|= GEN6_PIPE_CONTROL_PIXEL_SCOREBOARD_STALL
;
60 gen6_PIPE_CONTROL(r
->builder
, dw1
, bo
, 0, false);
63 r
->state
.current_pipe_control_dw1
|= dw1
;
64 r
->state
.deferred_pipe_control_dw1
&= ~dw1
;
68 gen7_wa_post_3dstate_push_constant_alloc_ps(struct ilo_render
*r
)
71 * From the Ivy Bridge PRM, volume 2 part 1, page 292:
73 * "A PIPE_CONTOL command with the CS Stall bit set must be programmed
74 * in the ring after this instruction
75 * (3DSTATE_PUSH_CONSTANT_ALLOC_PS)."
77 const uint32_t dw1
= GEN6_PIPE_CONTROL_CS_STALL
;
79 ILO_DEV_ASSERT(r
->dev
, 7, 7.5);
81 r
->state
.deferred_pipe_control_dw1
|= dw1
;
85 gen7_wa_pre_vs(struct ilo_render
*r
)
88 * From the Ivy Bridge PRM, volume 2 part 1, page 106:
90 * "A PIPE_CONTROL with Post-Sync Operation set to 1h and a depth stall
91 * needs to be sent just prior to any 3DSTATE_VS, 3DSTATE_URB_VS,
92 * 3DSTATE_CONSTANT_VS, 3DSTATE_BINDING_TABLE_POINTER_VS,
93 * 3DSTATE_SAMPLER_STATE_POINTER_VS command. Only one PIPE_CONTROL
94 * needs to be sent before any combination of VS associated 3DSTATE."
96 const uint32_t dw1
= GEN6_PIPE_CONTROL_DEPTH_STALL
|
97 GEN6_PIPE_CONTROL_WRITE_IMM
;
99 ILO_DEV_ASSERT(r
->dev
, 7, 7.5);
101 if ((r
->state
.current_pipe_control_dw1
& dw1
) != dw1
)
102 gen7_pipe_control(r
, dw1
);
106 gen7_wa_pre_3dstate_sf_depth_bias(struct ilo_render
*r
)
109 * From the Ivy Bridge PRM, volume 2 part 1, page 258:
111 * "Due to an HW issue driver needs to send a pipe control with stall
112 * when ever there is state change in depth bias related state (in
115 const uint32_t dw1
= GEN6_PIPE_CONTROL_CS_STALL
;
117 ILO_DEV_ASSERT(r
->dev
, 7, 7.5);
119 if ((r
->state
.current_pipe_control_dw1
& dw1
) != dw1
)
120 gen7_pipe_control(r
, dw1
);
124 gen7_wa_pre_3dstate_multisample(struct ilo_render
*r
)
127 * From the Ivy Bridge PRM, volume 2 part 1, page 304:
129 * "Driver must ierarchi that all the caches in the depth pipe are
130 * flushed before this command (3DSTATE_MULTISAMPLE) is parsed. This
131 * requires driver to send a PIPE_CONTROL with a CS stall along with a
132 * Depth Flush prior to this command.
134 const uint32_t dw1
= GEN6_PIPE_CONTROL_DEPTH_CACHE_FLUSH
|
135 GEN6_PIPE_CONTROL_CS_STALL
;
137 ILO_DEV_ASSERT(r
->dev
, 7, 7.5);
139 if ((r
->state
.current_pipe_control_dw1
& dw1
) != dw1
)
140 gen7_pipe_control(r
, dw1
);
144 gen7_wa_pre_depth(struct ilo_render
*r
)
147 * From the Ivy Bridge PRM, volume 2 part 1, page 315:
149 * "Driver must send a least one PIPE_CONTROL command with CS Stall and
150 * a post sync operation prior to the group of depth
151 * commands(3DSTATE_DEPTH_BUFFER, 3DSTATE_CLEAR_PARAMS,
152 * 3DSTATE_STENCIL_BUFFER, and 3DSTATE_HIER_DEPTH_BUFFER)."
154 const uint32_t dw1
= GEN6_PIPE_CONTROL_CS_STALL
|
155 GEN6_PIPE_CONTROL_WRITE_IMM
;
157 ILO_DEV_ASSERT(r
->dev
, 7, 7.5);
159 if ((r
->state
.current_pipe_control_dw1
& dw1
) != dw1
)
160 gen7_pipe_control(r
, dw1
);
163 * From the Ivy Bridge PRM, volume 2 part 1, page 315:
165 * "Restriction: Prior to changing Depth/Stencil Buffer state (i.e.,
166 * any combination of 3DSTATE_DEPTH_BUFFER, 3DSTATE_CLEAR_PARAMS,
167 * 3DSTATE_STENCIL_BUFFER, 3DSTATE_HIER_DEPTH_BUFFER) SW must first
168 * issue a pipelined depth stall (PIPE_CONTROL with Depth Stall bit
169 * set), followed by a pipelined depth cache flush (PIPE_CONTROL with
170 * Depth Flush Bit set, followed by another pipelined depth stall
171 * (PIPE_CONTROL with Depth Stall Bit set), unless SW can otherwise
172 * guarantee that the pipeline from WM onwards is already flushed
173 * (e.g., via a preceding MI_FLUSH)."
175 gen7_pipe_control(r
, GEN6_PIPE_CONTROL_DEPTH_STALL
);
176 gen7_pipe_control(r
, GEN6_PIPE_CONTROL_DEPTH_CACHE_FLUSH
);
177 gen7_pipe_control(r
, GEN6_PIPE_CONTROL_DEPTH_STALL
);
181 gen7_wa_pre_3dstate_ps_max_threads(struct ilo_render
*r
)
184 * From the Ivy Bridge PRM, volume 2 part 1, page 286:
186 * "If this field (Maximum Number of Threads in 3DSTATE_PS) is changed
187 * between 3DPRIMITIVE commands, a PIPE_CONTROL command with Stall at
188 * Pixel Scoreboard set is required to be issued."
190 const uint32_t dw1
= GEN6_PIPE_CONTROL_PIXEL_SCOREBOARD_STALL
;
192 ILO_DEV_ASSERT(r
->dev
, 7, 7.5);
194 if ((r
->state
.current_pipe_control_dw1
& dw1
) != dw1
)
195 gen7_pipe_control(r
, dw1
);
199 gen7_wa_post_ps_and_later(struct ilo_render
*r
)
202 * From the Ivy Bridge PRM, volume 2 part 1, page 276:
204 * "The driver must make sure a PIPE_CONTROL with the Depth Stall
205 * Enable bit set after all the following states are programmed:
208 * - 3DSTATE_VIEWPORT_STATE_POINTERS_CC
209 * - 3DSTATE_CONSTANT_PS
210 * - 3DSTATE_BINDING_TABLE_POINTERS_PS
211 * - 3DSTATE_SAMPLER_STATE_POINTERS_PS
212 * - 3DSTATE_CC_STATE_POINTERS
213 * - 3DSTATE_BLEND_STATE_POINTERS
214 * - 3DSTATE_DEPTH_STENCIL_STATE_POINTERS"
216 const uint32_t dw1
= GEN6_PIPE_CONTROL_DEPTH_STALL
;
218 ILO_DEV_ASSERT(r
->dev
, 7, 7.5);
220 r
->state
.deferred_pipe_control_dw1
|= dw1
;
223 #define DIRTY(state) (session->pipe_dirty & ILO_DIRTY_ ## state)
226 gen7_draw_common_urb(struct ilo_render
*r
,
227 const struct ilo_state_vector
*vec
,
228 struct ilo_render_draw_session
*session
)
230 /* 3DSTATE_URB_{VS,GS,HS,DS} */
231 if (DIRTY(VE
) || DIRTY(VS
)) {
232 /* the first 16KB are reserved for VS and PS PCBs */
233 const int offset
= (ilo_dev_gen(r
->dev
) == ILO_GEN(7.5) &&
234 r
->dev
->gt
== 3) ? 32768 : 16384;
235 int vs_entry_size
, vs_total_size
;
237 vs_entry_size
= (vec
->vs
) ?
238 ilo_shader_get_kernel_param(vec
->vs
, ILO_KERNEL_OUTPUT_COUNT
) : 0;
241 * From the Ivy Bridge PRM, volume 2 part 1, page 35:
243 * "Programming Restriction: As the VS URB entry serves as both the
244 * per-vertex input and output of the VS shader, the VS URB
245 * Allocation Size must be sized to the maximum of the vertex input
246 * and output structures."
248 if (vs_entry_size
< vec
->ve
->count
+ vec
->ve
->prepend_nosrc_cso
)
249 vs_entry_size
= vec
->ve
->count
+ vec
->ve
->prepend_nosrc_cso
;
251 vs_entry_size
*= sizeof(float) * 4;
252 vs_total_size
= r
->dev
->urb_size
- offset
;
256 gen7_3DSTATE_URB_VS(r
->builder
,
257 offset
, vs_total_size
, vs_entry_size
);
259 gen7_3DSTATE_URB_GS(r
->builder
, offset
, 0, 0);
260 gen7_3DSTATE_URB_HS(r
->builder
, offset
, 0, 0);
261 gen7_3DSTATE_URB_DS(r
->builder
, offset
, 0, 0);
266 gen7_draw_common_pcb_alloc(struct ilo_render
*r
,
267 const struct ilo_state_vector
*vec
,
268 struct ilo_render_draw_session
*session
)
270 /* 3DSTATE_PUSH_CONSTANT_ALLOC_{VS,PS} */
271 if (r
->hw_ctx_changed
) {
273 * Push constant buffers are only allowed to take up at most the first
274 * 16KB of the URB. Split the space evenly for VS and FS.
276 const int max_size
= (ilo_dev_gen(r
->dev
) == ILO_GEN(7.5) &&
277 r
->dev
->gt
== 3) ? 32768 : 16384;
278 const int size
= max_size
/ 2;
281 gen7_3DSTATE_PUSH_CONSTANT_ALLOC_VS(r
->builder
, offset
, size
);
284 gen7_3DSTATE_PUSH_CONSTANT_ALLOC_PS(r
->builder
, offset
, size
);
286 if (ilo_dev_gen(r
->dev
) == ILO_GEN(7))
287 gen7_wa_post_3dstate_push_constant_alloc_ps(r
);
292 gen7_draw_common_pointers_1(struct ilo_render
*r
,
293 const struct ilo_state_vector
*vec
,
294 struct ilo_render_draw_session
*session
)
296 /* 3DSTATE_VIEWPORT_STATE_POINTERS_{CC,SF_CLIP} */
297 if (session
->viewport_changed
) {
298 gen7_3DSTATE_VIEWPORT_STATE_POINTERS_CC(r
->builder
,
299 r
->state
.CC_VIEWPORT
);
301 gen7_3DSTATE_VIEWPORT_STATE_POINTERS_SF_CLIP(r
->builder
,
302 r
->state
.SF_CLIP_VIEWPORT
);
307 gen7_draw_common_pointers_2(struct ilo_render
*r
,
308 const struct ilo_state_vector
*vec
,
309 struct ilo_render_draw_session
*session
)
311 /* 3DSTATE_BLEND_STATE_POINTERS */
312 if (session
->blend_changed
) {
313 gen7_3DSTATE_BLEND_STATE_POINTERS(r
->builder
,
314 r
->state
.BLEND_STATE
);
317 /* 3DSTATE_CC_STATE_POINTERS */
318 if (session
->cc_changed
) {
319 gen7_3DSTATE_CC_STATE_POINTERS(r
->builder
,
320 r
->state
.COLOR_CALC_STATE
);
323 /* 3DSTATE_DEPTH_STENCIL_STATE_POINTERS */
324 if (session
->dsa_changed
) {
325 gen7_3DSTATE_DEPTH_STENCIL_STATE_POINTERS(r
->builder
,
326 r
->state
.DEPTH_STENCIL_STATE
);
331 gen7_draw_vs(struct ilo_render
*r
,
332 const struct ilo_state_vector
*vec
,
333 struct ilo_render_draw_session
*session
)
335 const bool emit_3dstate_binding_table
=
336 session
->binding_table_vs_changed
;
337 const bool emit_3dstate_sampler_state
=
338 session
->sampler_vs_changed
;
339 /* see gen6_draw_vs() */
340 const bool emit_3dstate_constant_vs
= session
->pcb_vs_changed
;
341 const bool emit_3dstate_vs
= (DIRTY(VS
) || r
->instruction_bo_changed
);
343 /* emit depth stall before any of the VS commands */
344 if (emit_3dstate_binding_table
|| emit_3dstate_sampler_state
||
345 emit_3dstate_constant_vs
|| emit_3dstate_vs
)
348 /* 3DSTATE_BINDING_TABLE_POINTERS_VS */
349 if (emit_3dstate_binding_table
) {
350 gen7_3DSTATE_BINDING_TABLE_POINTERS_VS(r
->builder
,
351 r
->state
.vs
.BINDING_TABLE_STATE
);
354 /* 3DSTATE_SAMPLER_STATE_POINTERS_VS */
355 if (emit_3dstate_sampler_state
) {
356 gen7_3DSTATE_SAMPLER_STATE_POINTERS_VS(r
->builder
,
357 r
->state
.vs
.SAMPLER_STATE
);
360 /* 3DSTATE_CONSTANT_VS */
361 if (emit_3dstate_constant_vs
) {
362 gen7_3DSTATE_CONSTANT_VS(r
->builder
,
363 &r
->state
.vs
.PUSH_CONSTANT_BUFFER
,
364 &r
->state
.vs
.PUSH_CONSTANT_BUFFER_size
,
370 gen6_3DSTATE_VS(r
->builder
, vec
->vs
);
374 gen7_draw_hs(struct ilo_render
*r
,
375 const struct ilo_state_vector
*vec
,
376 struct ilo_render_draw_session
*session
)
378 /* 3DSTATE_CONSTANT_HS and 3DSTATE_HS */
379 if (r
->hw_ctx_changed
) {
380 gen7_3DSTATE_CONSTANT_HS(r
->builder
, 0, 0, 0);
381 gen7_disable_3DSTATE_HS(r
->builder
);
384 /* 3DSTATE_BINDING_TABLE_POINTERS_HS */
385 if (r
->hw_ctx_changed
)
386 gen7_3DSTATE_BINDING_TABLE_POINTERS_HS(r
->builder
, 0);
390 gen7_draw_te(struct ilo_render
*r
,
391 const struct ilo_state_vector
*vec
,
392 struct ilo_render_draw_session
*session
)
395 if (r
->hw_ctx_changed
)
396 gen7_3DSTATE_TE(r
->builder
);
400 gen7_draw_ds(struct ilo_render
*r
,
401 const struct ilo_state_vector
*vec
,
402 struct ilo_render_draw_session
*session
)
404 /* 3DSTATE_CONSTANT_DS and 3DSTATE_DS */
405 if (r
->hw_ctx_changed
) {
406 gen7_3DSTATE_CONSTANT_DS(r
->builder
, 0, 0, 0);
407 gen7_disable_3DSTATE_DS(r
->builder
);
410 /* 3DSTATE_BINDING_TABLE_POINTERS_DS */
411 if (r
->hw_ctx_changed
)
412 gen7_3DSTATE_BINDING_TABLE_POINTERS_DS(r
->builder
, 0);
417 gen7_draw_gs(struct ilo_render
*r
,
418 const struct ilo_state_vector
*vec
,
419 struct ilo_render_draw_session
*session
)
421 /* 3DSTATE_CONSTANT_GS and 3DSTATE_GS */
422 if (r
->hw_ctx_changed
) {
423 gen7_3DSTATE_CONSTANT_GS(r
->builder
, 0, 0, 0);
424 gen7_disable_3DSTATE_GS(r
->builder
);
427 /* 3DSTATE_BINDING_TABLE_POINTERS_GS */
428 if (session
->binding_table_gs_changed
) {
429 gen7_3DSTATE_BINDING_TABLE_POINTERS_GS(r
->builder
,
430 r
->state
.gs
.BINDING_TABLE_STATE
);
435 gen7_draw_sol(struct ilo_render
*r
,
436 const struct ilo_state_vector
*vec
,
437 struct ilo_render_draw_session
*session
)
439 const struct pipe_stream_output_info
*so_info
;
440 const struct ilo_shader_state
*shader
;
441 bool dirty_sh
= false;
445 dirty_sh
= DIRTY(GS
);
449 dirty_sh
= DIRTY(VS
);
452 so_info
= ilo_shader_get_kernel_so_info(shader
);
454 /* 3DSTATE_SO_BUFFER */
455 if ((DIRTY(SO
) || dirty_sh
|| r
->batch_bo_changed
) &&
459 for (i
= 0; i
< vec
->so
.count
; i
++) {
460 const int stride
= so_info
->stride
[i
] * 4; /* in bytes */
462 gen7_3DSTATE_SO_BUFFER(r
->builder
, i
, stride
, vec
->so
.states
[i
]);
466 gen7_disable_3DSTATE_SO_BUFFER(r
->builder
, i
);
469 /* 3DSTATE_SO_DECL_LIST */
470 if (dirty_sh
&& vec
->so
.enabled
)
471 gen7_3DSTATE_SO_DECL_LIST(r
->builder
, so_info
);
473 /* 3DSTATE_STREAMOUT */
474 if (DIRTY(SO
) || DIRTY(RASTERIZER
) || dirty_sh
) {
475 const unsigned buffer_mask
= (1 << vec
->so
.count
) - 1;
476 const int output_count
= ilo_shader_get_kernel_param(shader
,
477 ILO_KERNEL_OUTPUT_COUNT
);
479 gen7_3DSTATE_STREAMOUT(r
->builder
, 0,
480 vec
->rasterizer
->state
.rasterizer_discard
,
481 buffer_mask
, output_count
);
486 gen7_draw_sf(struct ilo_render
*r
,
487 const struct ilo_state_vector
*vec
,
488 struct ilo_render_draw_session
*session
)
491 if (DIRTY(RASTERIZER
) || DIRTY(FS
))
492 gen7_3DSTATE_SBE(r
->builder
, vec
->rasterizer
, vec
->fs
);
495 if (DIRTY(RASTERIZER
) || DIRTY(FB
)) {
496 struct pipe_surface
*zs
= vec
->fb
.state
.zsbuf
;
498 gen7_wa_pre_3dstate_sf_depth_bias(r
);
499 gen7_3DSTATE_SF(r
->builder
, vec
->rasterizer
,
500 (zs
) ? zs
->format
: PIPE_FORMAT_NONE
);
505 gen7_draw_wm(struct ilo_render
*r
,
506 const struct ilo_state_vector
*vec
,
507 struct ilo_render_draw_session
*session
)
510 if (DIRTY(FS
) || DIRTY(BLEND
) || DIRTY(DSA
) || DIRTY(RASTERIZER
)) {
511 const bool cc_may_kill
= (vec
->dsa
->dw_alpha
||
512 vec
->blend
->alpha_to_coverage
);
514 gen7_3DSTATE_WM(r
->builder
, vec
->fs
, vec
->rasterizer
, cc_may_kill
);
517 /* 3DSTATE_BINDING_TABLE_POINTERS_PS */
518 if (session
->binding_table_fs_changed
) {
519 gen7_3DSTATE_BINDING_TABLE_POINTERS_PS(r
->builder
,
520 r
->state
.wm
.BINDING_TABLE_STATE
);
523 /* 3DSTATE_SAMPLER_STATE_POINTERS_PS */
524 if (session
->sampler_fs_changed
) {
525 gen7_3DSTATE_SAMPLER_STATE_POINTERS_PS(r
->builder
,
526 r
->state
.wm
.SAMPLER_STATE
);
529 /* 3DSTATE_CONSTANT_PS */
530 if (session
->pcb_fs_changed
) {
531 gen7_3DSTATE_CONSTANT_PS(r
->builder
,
532 &r
->state
.wm
.PUSH_CONSTANT_BUFFER
,
533 &r
->state
.wm
.PUSH_CONSTANT_BUFFER_size
,
538 if (DIRTY(FS
) || DIRTY(BLEND
) || r
->instruction_bo_changed
) {
539 const bool dual_blend
= vec
->blend
->dual_blend
;
541 if ((ilo_dev_gen(r
->dev
) == ILO_GEN(7) ||
542 ilo_dev_gen(r
->dev
) == ILO_GEN(7.5)) &&
544 gen7_wa_pre_3dstate_ps_max_threads(r
);
546 gen7_3DSTATE_PS(r
->builder
, vec
->fs
, dual_blend
);
549 /* 3DSTATE_SCISSOR_STATE_POINTERS */
550 if (session
->scissor_changed
) {
551 gen6_3DSTATE_SCISSOR_STATE_POINTERS(r
->builder
,
552 r
->state
.SCISSOR_RECT
);
555 /* XXX what is the best way to know if this workaround is needed? */
557 const bool emit_3dstate_ps
= (DIRTY(FS
) || DIRTY(BLEND
));
558 const bool emit_3dstate_depth_buffer
=
559 (DIRTY(FB
) || DIRTY(DSA
) || r
->state_bo_changed
);
561 if (emit_3dstate_ps
||
562 session
->pcb_fs_changed
||
563 session
->viewport_changed
||
564 session
->binding_table_fs_changed
||
565 session
->sampler_fs_changed
||
566 session
->cc_changed
||
567 session
->blend_changed
||
568 session
->dsa_changed
)
569 gen7_wa_post_ps_and_later(r
);
571 if (emit_3dstate_depth_buffer
)
572 gen7_wa_pre_depth(r
);
575 /* 3DSTATE_DEPTH_BUFFER and 3DSTATE_CLEAR_PARAMS */
576 if (DIRTY(FB
) || r
->batch_bo_changed
) {
577 const struct ilo_zs_surface
*zs
;
578 uint32_t clear_params
;
580 if (vec
->fb
.state
.zsbuf
) {
581 const struct ilo_surface_cso
*surface
=
582 (const struct ilo_surface_cso
*) vec
->fb
.state
.zsbuf
;
583 const struct ilo_texture_slice
*slice
=
584 ilo_texture_get_slice(ilo_texture(surface
->base
.texture
),
585 surface
->base
.u
.tex
.level
, surface
->base
.u
.tex
.first_layer
);
587 assert(!surface
->is_rt
);
589 clear_params
= slice
->clear_value
;
592 zs
= &vec
->fb
.null_zs
;
596 gen6_3DSTATE_DEPTH_BUFFER(r
->builder
, zs
, false);
597 gen6_3DSTATE_HIER_DEPTH_BUFFER(r
->builder
, zs
);
598 gen6_3DSTATE_STENCIL_BUFFER(r
->builder
, zs
);
599 gen7_3DSTATE_CLEAR_PARAMS(r
->builder
, clear_params
);
604 gen7_draw_wm_multisample(struct ilo_render
*r
,
605 const struct ilo_state_vector
*vec
,
606 struct ilo_render_draw_session
*session
)
608 /* 3DSTATE_MULTISAMPLE and 3DSTATE_SAMPLE_MASK */
609 if (DIRTY(SAMPLE_MASK
) || DIRTY(FB
)) {
610 const uint32_t *packed_sample_pos
;
612 gen7_wa_pre_3dstate_multisample(r
);
615 (vec
->fb
.num_samples
> 4) ? r
->packed_sample_position_8x
:
616 (vec
->fb
.num_samples
> 1) ? &r
->packed_sample_position_4x
:
617 &r
->packed_sample_position_1x
;
619 gen6_3DSTATE_MULTISAMPLE(r
->builder
,
620 vec
->fb
.num_samples
, packed_sample_pos
,
621 vec
->rasterizer
->state
.half_pixel_center
);
623 gen7_3DSTATE_SAMPLE_MASK(r
->builder
,
624 (vec
->fb
.num_samples
> 1) ? vec
->sample_mask
: 0x1,
625 vec
->fb
.num_samples
);
630 gen7_draw_vf_draw(struct ilo_render
*r
,
631 const struct ilo_state_vector
*vec
,
632 struct ilo_render_draw_session
*session
)
634 if (r
->state
.deferred_pipe_control_dw1
)
635 gen7_pipe_control(r
, r
->state
.deferred_pipe_control_dw1
);
638 gen7_3DPRIMITIVE(r
->builder
, vec
->draw
, &vec
->ib
);
640 r
->state
.current_pipe_control_dw1
= 0;
641 r
->state
.deferred_pipe_control_dw1
= 0;
645 ilo_render_emit_draw_commands_gen7(struct ilo_render
*render
,
646 const struct ilo_state_vector
*vec
,
647 struct ilo_render_draw_session
*session
)
649 ILO_DEV_ASSERT(render
->dev
, 7, 7.5);
652 * We try to keep the order of the commands match, as closely as possible,
653 * that of the classic i965 driver. It allows us to compare the command
656 gen6_draw_common_select(render
, vec
, session
);
657 gen6_draw_common_sip(render
, vec
, session
);
658 gen6_draw_vf_statistics(render
, vec
, session
);
659 gen7_draw_common_pcb_alloc(render
, vec
, session
);
660 gen6_draw_common_base_address(render
, vec
, session
);
661 gen7_draw_common_pointers_1(render
, vec
, session
);
662 gen7_draw_common_urb(render
, vec
, session
);
663 gen7_draw_common_pointers_2(render
, vec
, session
);
664 gen7_draw_wm_multisample(render
, vec
, session
);
665 gen7_draw_gs(render
, vec
, session
);
666 gen7_draw_hs(render
, vec
, session
);
667 gen7_draw_te(render
, vec
, session
);
668 gen7_draw_ds(render
, vec
, session
);
669 gen7_draw_vs(render
, vec
, session
);
670 gen7_draw_sol(render
, vec
, session
);
671 gen6_draw_clip(render
, vec
, session
);
672 gen7_draw_sf(render
, vec
, session
);
673 gen7_draw_wm(render
, vec
, session
);
674 gen6_draw_wm_raster(render
, vec
, session
);
675 gen6_draw_sf_rect(render
, vec
, session
);
676 gen6_draw_vf(render
, vec
, session
);
677 gen7_draw_vf_draw(render
, vec
, session
);
681 gen7_rectlist_pcb_alloc(struct ilo_render
*r
,
682 const struct ilo_blitter
*blitter
)
685 * Push constant buffers are only allowed to take up at most the first
686 * 16KB of the URB. Split the space evenly for VS and FS.
689 (ilo_dev_gen(r
->dev
) == ILO_GEN(7.5) && r
->dev
->gt
== 3) ? 32768 : 16384;
690 const int size
= max_size
/ 2;
693 gen7_3DSTATE_PUSH_CONSTANT_ALLOC_VS(r
->builder
, offset
, size
);
696 gen7_3DSTATE_PUSH_CONSTANT_ALLOC_PS(r
->builder
, offset
, size
);
698 gen7_wa_post_3dstate_push_constant_alloc_ps(r
);
702 gen7_rectlist_urb(struct ilo_render
*r
,
703 const struct ilo_blitter
*blitter
)
705 /* the first 16KB are reserved for VS and PS PCBs */
707 (ilo_dev_gen(r
->dev
) == ILO_GEN(7.5) && r
->dev
->gt
== 3) ? 32768 : 16384;
709 gen7_3DSTATE_URB_VS(r
->builder
, offset
, r
->dev
->urb_size
- offset
,
710 (blitter
->ve
.count
+ blitter
->ve
.prepend_nosrc_cso
) *
713 gen7_3DSTATE_URB_GS(r
->builder
, offset
, 0, 0);
714 gen7_3DSTATE_URB_HS(r
->builder
, offset
, 0, 0);
715 gen7_3DSTATE_URB_DS(r
->builder
, offset
, 0, 0);
719 gen7_rectlist_vs_to_sf(struct ilo_render
*r
,
720 const struct ilo_blitter
*blitter
)
722 gen7_3DSTATE_CONSTANT_VS(r
->builder
, NULL
, NULL
, 0);
723 gen6_disable_3DSTATE_VS(r
->builder
);
725 gen7_3DSTATE_CONSTANT_HS(r
->builder
, NULL
, NULL
, 0);
726 gen7_disable_3DSTATE_HS(r
->builder
);
728 gen7_3DSTATE_TE(r
->builder
);
730 gen7_3DSTATE_CONSTANT_DS(r
->builder
, NULL
, NULL
, 0);
731 gen7_disable_3DSTATE_DS(r
->builder
);
733 gen7_3DSTATE_CONSTANT_GS(r
->builder
, NULL
, NULL
, 0);
734 gen7_disable_3DSTATE_GS(r
->builder
);
736 gen7_3DSTATE_STREAMOUT(r
->builder
, 0, false, 0x0, 0);
738 gen6_disable_3DSTATE_CLIP(r
->builder
);
740 gen7_wa_pre_3dstate_sf_depth_bias(r
);
742 gen7_3DSTATE_SF(r
->builder
, NULL
, blitter
->fb
.dst
.base
.format
);
743 gen7_3DSTATE_SBE(r
->builder
, NULL
, NULL
);
747 gen7_rectlist_wm(struct ilo_render
*r
,
748 const struct ilo_blitter
*blitter
)
752 switch (blitter
->op
) {
753 case ILO_BLITTER_RECTLIST_CLEAR_ZS
:
754 hiz_op
= GEN7_WM_DW1_DEPTH_CLEAR
;
756 case ILO_BLITTER_RECTLIST_RESOLVE_Z
:
757 hiz_op
= GEN7_WM_DW1_DEPTH_RESOLVE
;
759 case ILO_BLITTER_RECTLIST_RESOLVE_HIZ
:
760 hiz_op
= GEN7_WM_DW1_HIZ_RESOLVE
;
767 gen7_hiz_3DSTATE_WM(r
->builder
, hiz_op
);
769 gen7_3DSTATE_CONSTANT_PS(r
->builder
, NULL
, NULL
, 0);
771 gen7_wa_pre_3dstate_ps_max_threads(r
);
772 gen7_disable_3DSTATE_PS(r
->builder
);
776 gen7_rectlist_wm_depth(struct ilo_render
*r
,
777 const struct ilo_blitter
*blitter
)
779 gen7_wa_pre_depth(r
);
781 if (blitter
->uses
& (ILO_BLITTER_USE_FB_DEPTH
|
782 ILO_BLITTER_USE_FB_STENCIL
)) {
783 gen6_3DSTATE_DEPTH_BUFFER(r
->builder
,
784 &blitter
->fb
.dst
.u
.zs
, true);
787 if (blitter
->uses
& ILO_BLITTER_USE_FB_DEPTH
) {
788 gen6_3DSTATE_HIER_DEPTH_BUFFER(r
->builder
,
789 &blitter
->fb
.dst
.u
.zs
);
792 if (blitter
->uses
& ILO_BLITTER_USE_FB_STENCIL
) {
793 gen6_3DSTATE_STENCIL_BUFFER(r
->builder
,
794 &blitter
->fb
.dst
.u
.zs
);
797 gen7_3DSTATE_CLEAR_PARAMS(r
->builder
,
798 blitter
->depth_clear_value
);
802 gen7_rectlist_wm_multisample(struct ilo_render
*r
,
803 const struct ilo_blitter
*blitter
)
805 const uint32_t *packed_sample_pos
=
806 (blitter
->fb
.num_samples
> 4) ? r
->packed_sample_position_8x
:
807 (blitter
->fb
.num_samples
> 1) ? &r
->packed_sample_position_4x
:
808 &r
->packed_sample_position_1x
;
810 gen7_wa_pre_3dstate_multisample(r
);
812 gen6_3DSTATE_MULTISAMPLE(r
->builder
, blitter
->fb
.num_samples
,
813 packed_sample_pos
, true);
815 gen7_3DSTATE_SAMPLE_MASK(r
->builder
,
816 (1 << blitter
->fb
.num_samples
) - 1, blitter
->fb
.num_samples
);
820 ilo_render_emit_rectlist_commands_gen7(struct ilo_render
*r
,
821 const struct ilo_blitter
*blitter
,
822 const struct ilo_render_rectlist_session
*session
)
824 ILO_DEV_ASSERT(r
->dev
, 7, 7.5);
826 gen7_rectlist_wm_multisample(r
, blitter
);
828 gen6_state_base_address(r
->builder
, true);
830 gen6_user_3DSTATE_VERTEX_BUFFERS(r
->builder
,
831 session
->vb_start
, session
->vb_end
,
832 sizeof(blitter
->vertices
[0]));
834 gen6_3DSTATE_VERTEX_ELEMENTS(r
->builder
, &blitter
->ve
);
836 gen7_rectlist_pcb_alloc(r
, blitter
);
838 /* needed for any VS-related commands */
841 gen7_rectlist_urb(r
, blitter
);
843 if (blitter
->uses
& ILO_BLITTER_USE_DSA
) {
844 gen7_3DSTATE_DEPTH_STENCIL_STATE_POINTERS(r
->builder
,
845 r
->state
.DEPTH_STENCIL_STATE
);
848 if (blitter
->uses
& ILO_BLITTER_USE_CC
) {
849 gen7_3DSTATE_CC_STATE_POINTERS(r
->builder
,
850 r
->state
.COLOR_CALC_STATE
);
853 gen7_rectlist_vs_to_sf(r
, blitter
);
854 gen7_rectlist_wm(r
, blitter
);
856 if (blitter
->uses
& ILO_BLITTER_USE_VIEWPORT
) {
857 gen7_3DSTATE_VIEWPORT_STATE_POINTERS_CC(r
->builder
,
858 r
->state
.CC_VIEWPORT
);
861 gen7_rectlist_wm_depth(r
, blitter
);
863 gen6_3DSTATE_DRAWING_RECTANGLE(r
->builder
, 0, 0,
864 blitter
->fb
.width
, blitter
->fb
.height
);
866 gen7_3DPRIMITIVE(r
->builder
, &blitter
->draw
, NULL
);
870 ilo_render_get_draw_commands_len_gen7(const struct ilo_render
*render
,
871 const struct ilo_state_vector
*vec
)
875 ILO_DEV_ASSERT(render
->dev
, 7, 7.5);
878 len
+= GEN7_3DSTATE_URB_ANY__SIZE
* 4;
879 len
+= GEN7_3DSTATE_PUSH_CONSTANT_ALLOC_ANY__SIZE
* 5;
880 len
+= GEN6_3DSTATE_CONSTANT_ANY__SIZE
* 5;
881 len
+= GEN7_3DSTATE_POINTERS_ANY__SIZE
* (5 + 5 + 4);
882 len
+= GEN7_3DSTATE_SO_BUFFER__SIZE
* 4;
883 len
+= GEN6_PIPE_CONTROL__SIZE
* 5;
886 GEN6_STATE_BASE_ADDRESS__SIZE
+
887 GEN6_STATE_SIP__SIZE
+
888 GEN6_3DSTATE_VF_STATISTICS__SIZE
+
889 GEN6_PIPELINE_SELECT__SIZE
+
890 GEN6_3DSTATE_CLEAR_PARAMS__SIZE
+
891 GEN6_3DSTATE_DEPTH_BUFFER__SIZE
+
892 GEN6_3DSTATE_STENCIL_BUFFER__SIZE
+
893 GEN6_3DSTATE_HIER_DEPTH_BUFFER__SIZE
+
894 GEN6_3DSTATE_VERTEX_BUFFERS__SIZE
+
895 GEN6_3DSTATE_VERTEX_ELEMENTS__SIZE
+
896 GEN6_3DSTATE_INDEX_BUFFER__SIZE
+
897 GEN75_3DSTATE_VF__SIZE
+
898 GEN6_3DSTATE_VS__SIZE
+
899 GEN6_3DSTATE_GS__SIZE
+
900 GEN6_3DSTATE_CLIP__SIZE
+
901 GEN6_3DSTATE_SF__SIZE
+
902 GEN6_3DSTATE_WM__SIZE
+
903 GEN6_3DSTATE_SAMPLE_MASK__SIZE
+
904 GEN7_3DSTATE_HS__SIZE
+
905 GEN7_3DSTATE_TE__SIZE
+
906 GEN7_3DSTATE_DS__SIZE
+
907 GEN7_3DSTATE_STREAMOUT__SIZE
+
908 GEN7_3DSTATE_SBE__SIZE
+
909 GEN7_3DSTATE_PS__SIZE
+
910 GEN6_3DSTATE_DRAWING_RECTANGLE__SIZE
+
911 GEN6_3DSTATE_POLY_STIPPLE_OFFSET__SIZE
+
912 GEN6_3DSTATE_POLY_STIPPLE_PATTERN__SIZE
+
913 GEN6_3DSTATE_LINE_STIPPLE__SIZE
+
914 GEN6_3DSTATE_AA_LINE_PARAMETERS__SIZE
+
915 GEN6_3DSTATE_MULTISAMPLE__SIZE
+
916 GEN7_3DSTATE_SO_DECL_LIST__SIZE
+
917 GEN6_3DPRIMITIVE__SIZE
;