freedreno: support for using generic clear path

Since clears are more or less just normal draws, there isn't that much
benefit in having hand-rolled clear path.  Add support to use u_blitter
instead if gen specific backend doesn't implement ctx->clear().

Signed-off-by: Rob Clark <robdclark@gmail.com>

diff --git a/src/gallium/drivers/freedreno/freedreno_context.c b/src/gallium/drivers/freedreno/freedreno_context.c
index 402e88f7ca99b23bb9df47e49ada8f86f68a49b1..ad62fd605ddce1093f7006ac0436efc494d65cd5 100644 (file)
--- a/src/gallium/drivers/freedreno/freedreno_context.c
+++ b/src/gallium/drivers/freedreno/freedreno_context.c
@@ -115,6 +115,9 @@ fd_context_destroy(struct pipe_context *pctx)
        if (ctx->blitter)
                util_blitter_destroy(ctx->blitter);
 
+       if (ctx->clear_rs_state)
+               pctx->delete_rasterizer_state(pctx, ctx->clear_rs_state);
+
        if (ctx->primconvert)
                util_primconvert_destroy(ctx->primconvert);
 

diff --git a/src/gallium/drivers/freedreno/freedreno_context.h b/src/gallium/drivers/freedreno/freedreno_context.h
index ffc4d9ef47ce1df7819e44ecd79f9be531ddaa57..037c199c245fcd90e26244a4d7caf5e4ade04d0d 100644 (file)
--- a/src/gallium/drivers/freedreno/freedreno_context.h
+++ b/src/gallium/drivers/freedreno/freedreno_context.h
@@ -117,6 +117,7 @@ struct fd_context {
        struct util_queue flush_queue;
 
        struct blitter_context *blitter;
+       void *clear_rs_state;
        struct primconvert_context *primconvert;
 
        /* slab for pipe_transfer allocations: */

diff --git a/src/gallium/drivers/freedreno/freedreno_draw.c b/src/gallium/drivers/freedreno/freedreno_draw.c
index 715ad21e6021d2c7ee8b63301453f30707fe8a61..efc1dd2774de13e7c535719c23ca496ea6537dc8 100644 (file)
--- a/src/gallium/drivers/freedreno/freedreno_draw.c
+++ b/src/gallium/drivers/freedreno/freedreno_draw.c
@@ -203,6 +203,72 @@ fd_draw_vbo(struct pipe_context *pctx, const struct pipe_draw_info *info)
        fd_batch_check_size(batch);
 }
 
+/* Generic clear implementation (partially) using u_blitter: */
+static void
+fd_blitter_clear(struct pipe_context *pctx, unsigned buffers,
+               const union pipe_color_union *color, double depth, unsigned stencil)
+{
+       struct fd_context *ctx = fd_context(pctx);
+       struct pipe_framebuffer_state *pfb = &ctx->batch->framebuffer;
+       struct blitter_context *blitter = ctx->blitter;
+
+       fd_blitter_pipe_begin(ctx, false, true, FD_STAGE_CLEAR);
+
+       util_blitter_common_clear_setup(blitter, pfb->width, pfb->height,
+                       buffers, NULL, NULL);
+
+       struct pipe_stencil_ref sr = {
+               .ref_value = { stencil & 0xff }
+       };
+       pctx->set_stencil_ref(pctx, &sr);
+
+       struct pipe_constant_buffer cb = {
+               .buffer_size = 16,
+               .user_buffer = &color->ui,
+       };
+       pctx->set_constant_buffer(pctx, PIPE_SHADER_FRAGMENT, 0, &cb);
+
+       if (!ctx->clear_rs_state) {
+               const struct pipe_rasterizer_state tmpl = {
+                       .cull_face = PIPE_FACE_NONE,
+                       .half_pixel_center = 1,
+                       .bottom_edge_rule = 1,
+                       .flatshade = 1,
+                       .depth_clip = 1,
+               };
+               ctx->clear_rs_state = pctx->create_rasterizer_state(pctx, &tmpl);
+       }
+       pctx->bind_rasterizer_state(pctx, ctx->clear_rs_state);
+
+       struct pipe_viewport_state vp = {
+               .scale     = { 0.5f * pfb->width, -0.5f * pfb->height, depth },
+               .translate = { 0.5f * pfb->width,  0.5f * pfb->height, 0.0f },
+       };
+       pctx->set_viewport_states(pctx, 0, 1, &vp);
+
+       pctx->bind_vertex_elements_state(pctx, ctx->solid_vbuf_state.vtx);
+       pctx->set_vertex_buffers(pctx, blitter->vb_slot, 1,
+                       &ctx->solid_vbuf_state.vertexbuf.vb[0]);
+       pctx->set_stream_output_targets(pctx, 0, NULL, NULL);
+       pctx->bind_vs_state(pctx, ctx->solid_prog.vp);
+       pctx->bind_fs_state(pctx, ctx->solid_prog.fp);
+
+       struct pipe_draw_info info = {
+               .mode = PIPE_PRIM_MAX,    /* maps to DI_PT_RECTLIST */
+               .count = 2,
+               .instance_count = 1,
+       };
+       ctx->draw_vbo(ctx, &info);
+
+       util_blitter_restore_constant_buffer_state(blitter);
+       util_blitter_restore_vertex_states(blitter);
+       util_blitter_restore_fragment_states(blitter);
+       util_blitter_restore_render_cond(blitter);
+       util_blitter_unset_running_flag(blitter);
+
+       fd_blitter_pipe_end(ctx);
+}
+
 /* TODO figure out how to make better use of existing state mechanism
  * for clear (and possibly gmem->mem / mem->gmem) so we can (a) keep
  * track of what state really actually changes, and (b) reduce the code
@@ -274,6 +340,14 @@ fd_clear(struct pipe_context *pctx, unsigned buffers,
                util_format_short_name(pipe_surface_format(pfb->cbufs[0])),
                util_format_short_name(pipe_surface_format(pfb->zsbuf)));
 
+       /* if per-gen backend doesn't implement ctx->clear() generic
+        * blitter clear:
+        */
+       if (!ctx->clear) {
+               fd_blitter_clear(pctx, buffers, color, depth, stencil);
+               return;
+       }
+
        fd_hw_query_set_stage(batch, batch->draw, FD_STAGE_CLEAR);
 
        ctx->clear(ctx, buffers, color, depth, stencil);

diff --git a/src/gallium/drivers/freedreno/freedreno_resource.c b/src/gallium/drivers/freedreno/freedreno_resource.c
index 9ac95509abce9fb0ee1dd8fd559caa54856fcf14..2a4fd7442c8070f9a8aa47a3681b385fa6161da8 100644 (file)
--- a/src/gallium/drivers/freedreno/freedreno_resource.c
+++ b/src/gallium/drivers/freedreno/freedreno_resource.c
@@ -107,16 +107,13 @@ realloc_bo(struct fd_resource *rsc, uint32_t size)
        fd_bc_invalidate_resource(rsc, true);
 }
 
-static void fd_blitter_pipe_begin(struct fd_context *ctx, bool render_cond, bool discard);
-static void fd_blitter_pipe_end(struct fd_context *ctx);
-
 static void
 do_blit(struct fd_context *ctx, const struct pipe_blit_info *blit, bool fallback)
 {
        /* TODO size threshold too?? */
        if ((blit->src.resource->target != PIPE_BUFFER) && !fallback) {
                /* do blit on gpu: */
-               fd_blitter_pipe_begin(ctx, false, true);
+               fd_blitter_pipe_begin(ctx, false, true, FD_STAGE_BLIT);
                util_blitter_blit(ctx->blitter, blit);
                fd_blitter_pipe_end(ctx);
        } else {
@@ -939,7 +936,7 @@ fd_blitter_pipe_copy_region(struct fd_context *ctx,
                return false;
 
        /* TODO we could discard if dst box covers dst level fully.. */
-       fd_blitter_pipe_begin(ctx, false, false);
+       fd_blitter_pipe_begin(ctx, false, false, FD_STAGE_BLIT);
        util_blitter_copy_texture(ctx->blitter,
                        dst, dst_level, dstx, dsty, dstz,
                        src, src_level, src_box);
@@ -1045,14 +1042,17 @@ fd_blit(struct pipe_context *pctx, const struct pipe_blit_info *blit_info)
                return;
        }
 
-       fd_blitter_pipe_begin(ctx, info.render_condition_enable, discard);
+       fd_blitter_pipe_begin(ctx, info.render_condition_enable, discard, FD_STAGE_BLIT);
        util_blitter_blit(ctx->blitter, &info);
        fd_blitter_pipe_end(ctx);
 }
 
-static void
-fd_blitter_pipe_begin(struct fd_context *ctx, bool render_cond, bool discard)
+void
+fd_blitter_pipe_begin(struct fd_context *ctx, bool render_cond, bool discard,
+               enum fd_render_stage stage)
 {
+       util_blitter_save_fragment_constant_buffer_slot(ctx->blitter,
+                       ctx->constbuf[PIPE_SHADER_FRAGMENT].cb);
        util_blitter_save_vertex_buffer_slot(ctx->blitter, ctx->vtx.vertexbuf.vb);
        util_blitter_save_vertex_elements(ctx->blitter, ctx->vtx.vtx);
        util_blitter_save_vertex_shader(ctx->blitter, ctx->prog.vp);
@@ -1078,12 +1078,12 @@ fd_blitter_pipe_begin(struct fd_context *ctx, bool render_cond, bool discard)
                        ctx->cond_query, ctx->cond_cond, ctx->cond_mode);
 
        if (ctx->batch)
-               fd_hw_query_set_stage(ctx->batch, ctx->batch->draw, FD_STAGE_BLIT);
+               fd_hw_query_set_stage(ctx->batch, ctx->batch->draw, stage);
 
        ctx->in_blit = discard;
 }
 
-static void
+void
 fd_blitter_pipe_end(struct fd_context *ctx)
 {
        if (ctx->batch)

diff --git a/src/gallium/drivers/freedreno/freedreno_resource.h b/src/gallium/drivers/freedreno/freedreno_resource.h
index 8caab6b8a5a84dfd7981fb1e6d3d0510fd869297..60ba7e6961fbd68d97ff65cb7df7fa95f3c3ecd4 100644 (file)
--- a/src/gallium/drivers/freedreno/freedreno_resource.h
+++ b/src/gallium/drivers/freedreno/freedreno_resource.h
@@ -154,6 +154,10 @@ fd_resource_offset(struct fd_resource *rsc, unsigned level, unsigned layer)
        return offset;
 }
 
+void fd_blitter_pipe_begin(struct fd_context *ctx, bool render_cond, bool discard,
+               enum fd_render_stage stage);
+void fd_blitter_pipe_end(struct fd_context *ctx);
+
 void fd_resource_screen_init(struct pipe_screen *pscreen);
 void fd_resource_context_init(struct pipe_context *pctx);