}
}
-static void
-panfrost_emit_compute_shader(struct panfrost_context *ctx,
- enum pipe_shader_type st,
- struct mali_shader_meta *meta)
-{
- const struct panfrost_device *dev = pan_device(ctx->base.screen);
- struct panfrost_shader_state *ss = panfrost_get_shader_state(ctx, st);
-
- memset(meta, 0, sizeof(*meta));
- meta->shader = ss->shader;
- meta->attribute_count = ss->attribute_count;
- meta->varying_count = ss->varying_count;
- meta->texture_count = ctx->sampler_view_count[st];
- meta->sampler_count = ctx->sampler_count[st];
-
- if (dev->quirks & IS_BIFROST) {
- struct mali_bifrost_properties_packed prop;
- struct mali_preload_vertex_packed preload;
-
- pan_pack(&prop, BIFROST_PROPERTIES, cfg) {
- cfg.unknown = 0x800000; /* XXX */
- cfg.uniform_buffer_count = panfrost_ubo_count(ctx, st);
- }
-
- /* TODO: True compute shaders */
- pan_pack(&preload, PRELOAD_VERTEX, cfg) {
- cfg.uniform_count = ss->uniform_count;
- cfg.vertex_id = true;
- cfg.instance_id = true;
- }
-
- memcpy(&meta->bifrost_props, &prop, sizeof(prop));
- memcpy(&meta->bifrost_preload, &preload, sizeof(preload));
- } else {
- struct mali_midgard_properties_packed prop;
-
- pan_pack(&prop, MIDGARD_PROPERTIES, cfg) {
- cfg.uniform_buffer_count = panfrost_ubo_count(ctx, st);
- cfg.uniform_count = ss->uniform_count;
- cfg.work_register_count = ss->work_reg_count;
- cfg.writes_globals = ss->writes_global;
- cfg.suppress_inf_nan = true; /* XXX */
- }
-
- memcpy(&meta->midgard_props, &prop, sizeof(prop));
- }
-}
-
static unsigned
translate_tex_wrap(enum pipe_tex_wrap w)
{
unsigned rt_count = ctx->pipe_framebuffer.nr_cbufs;
memset(fragmeta, 0, sizeof(*fragmeta));
+ memcpy(&fragmeta->shader, &fs->shader, sizeof(fs->shader));
- fragmeta->shader = fs->shader;
- fragmeta->attribute_count = fs->attribute_count;
- fragmeta->varying_count = fs->varying_count;
- fragmeta->texture_count = ctx->sampler_view_count[PIPE_SHADER_FRAGMENT];
- fragmeta->sampler_count = ctx->sampler_count[PIPE_SHADER_FRAGMENT];
+ if (!panfrost_fs_required(fs, blend, rt_count)) {
+ struct mali_shader_packed shader = { 0 };
+ struct mali_midgard_properties_packed prop;
- if (dev->quirks & IS_BIFROST) {
+ if (dev->quirks & IS_BIFROST) {
+ struct mali_preload_packed preload = { 0 };
+ memcpy(&fragmeta->bifrost_preload, &preload, sizeof(preload));
+
+ pan_pack(&prop, BIFROST_PROPERTIES, cfg) {
+ cfg.unknown = 0x950020; /* XXX */
+ cfg.early_z_enable = true;
+ }
+ } else {
+ pan_pack(&shader, SHADER, cfg) {
+ cfg.shader = 0x1;
+ }
+
+ pan_pack(&prop, MIDGARD_PROPERTIES, cfg) {
+ cfg.work_register_count = 1;
+ cfg.depth_source = MALI_DEPTH_SOURCE_FIXED_FUNCTION;
+ cfg.early_z_enable = true;
+ }
+ }
+
+ memcpy(&fragmeta->shader, &shader, sizeof(shader));
+ memcpy(&fragmeta->midgard_props, &prop, sizeof(prop));
+ } else if (dev->quirks & IS_BIFROST) {
struct mali_bifrost_properties_packed prop;
- struct mali_preload_fragment_packed preload;
bool no_blend = true;
no_blend &= (!blend[i].load_dest | blend[i].no_colour);
pan_pack(&prop, BIFROST_PROPERTIES, cfg) {
- cfg.unknown = 0x950020; /* XXX */
- cfg.uniform_buffer_count = panfrost_ubo_count(ctx, PIPE_SHADER_FRAGMENT);
cfg.early_z_enable = !fs->can_discard && !fs->writes_depth && no_blend;
}
- pan_pack(&preload, PRELOAD_FRAGMENT, cfg) {
- cfg.uniform_count = fs->uniform_count;
- cfg.fragment_position = fs->reads_frag_coord;
- }
+ /* Combine with prepacked properties */
+ prop.opaque[0] |= fs->properties.opaque[0];
memcpy(&fragmeta->bifrost_props, &prop, sizeof(prop));
- memcpy(&fragmeta->bifrost_preload, &preload, sizeof(preload));
+ memcpy(&fragmeta->bifrost_preload, &fs->preload, sizeof(fs->preload));
} else {
struct mali_midgard_properties_packed prop;
has_blend_shader |= blend[c].is_shader;
pan_pack(&prop, MIDGARD_PROPERTIES, cfg) {
- cfg.uniform_buffer_count = panfrost_ubo_count(ctx, PIPE_SHADER_FRAGMENT);
- cfg.uniform_count = fs->uniform_count;
- cfg.work_register_count = fs->work_reg_count;
- cfg.writes_globals = fs->writes_global;
- cfg.suppress_inf_nan = true; /* XXX */
-
/* TODO: Reduce this limit? */
if (has_blend_shader)
- cfg.work_register_count = MAX2(cfg.work_register_count, 8);
+ cfg.work_register_count = MAX2(fs->work_reg_count, 8);
+ else
+ cfg.work_register_count = fs->work_reg_count;
- cfg.stencil_from_shader = fs->writes_stencil;
- cfg.helper_invocation_enable = fs->helper_invocations;
- cfg.depth_source = fs->writes_depth ?
- MALI_DEPTH_SOURCE_SHADER :
- MALI_DEPTH_SOURCE_FIXED_FUNCTION;
-
- /* Depend on other state */
cfg.early_z_enable = !(late_z || alpha_to_coverage);
cfg.reads_tilebuffer = fs->outputs_read || (!zs_enabled && fs->can_discard);
cfg.reads_depth_stencil = zs_enabled && fs->can_discard;
}
+ /* Combine with prepacked properties */
+ prop.opaque[0] |= fs->properties.opaque[0];
memcpy(&fragmeta->midgard_props, &prop, sizeof(prop));
}
SET_BIT(fragmeta->unknown2_4, MALI_ALPHA_TO_COVERAGE,
ctx->blend->base.alpha_to_coverage);
- /* Disable shader execution if we can */
- if (!panfrost_fs_required(fs, blend, rt_count)) {
- fragmeta->attribute_count = 0;
- fragmeta->varying_count = 0;
- fragmeta->texture_count = 0;
- fragmeta->sampler_count = 0;
-
- struct mali_midgard_properties_packed prop;
-
- if (dev->quirks & IS_BIFROST) {
- fragmeta->shader = 0x0;
-
- pan_pack(&prop, BIFROST_PROPERTIES, cfg) {
- cfg.unknown = 0x950020; /* XXX */
- cfg.early_z_enable = true;
- }
- } else {
- fragmeta->shader = 0x1;
-
- pan_pack(&prop, MIDGARD_PROPERTIES, cfg) {
- cfg.work_register_count = 1;
- cfg.depth_source = MALI_DEPTH_SOURCE_FIXED_FUNCTION;
- cfg.early_z_enable = true;
- }
- }
-
- memcpy(&fragmeta->midgard_props, &prop, sizeof(prop));
- }
-
if (dev->quirks & MIDGARD_SFBD) {
/* When only a single render target platform is used, the blend
* information is inside the shader meta itself. We additionally
}
}
-void
-panfrost_emit_shader_meta(struct panfrost_batch *batch,
- enum pipe_shader_type st,
- struct mali_vertex_tiler_postfix *postfix)
+mali_ptr
+panfrost_emit_compute_shader_meta(struct panfrost_batch *batch, enum pipe_shader_type stage)
{
- struct panfrost_context *ctx = batch->ctx;
- struct panfrost_shader_state *ss = panfrost_get_shader_state(ctx, st);
-
- if (!ss) {
- postfix->shader = 0;
- return;
- }
+ struct panfrost_shader_state *ss = panfrost_get_shader_state(batch->ctx, stage);
- struct mali_shader_meta meta;
-
- /* Add the shader BO to the batch. */
panfrost_batch_add_bo(batch, ss->bo,
PAN_BO_ACCESS_PRIVATE |
PAN_BO_ACCESS_READ |
- panfrost_bo_access_for_stage(st));
+ PAN_BO_ACCESS_VERTEX_TILER);
- mali_ptr shader_ptr;
+ panfrost_batch_add_bo(batch, pan_resource(ss->upload.rsrc)->bo,
+ PAN_BO_ACCESS_PRIVATE |
+ PAN_BO_ACCESS_READ |
+ PAN_BO_ACCESS_VERTEX_TILER);
- if (st == PIPE_SHADER_FRAGMENT) {
- struct panfrost_device *dev = pan_device(ctx->base.screen);
- unsigned rt_count = MAX2(ctx->pipe_framebuffer.nr_cbufs, 1);
- size_t desc_size = sizeof(meta);
- void *rts = NULL;
- struct panfrost_transfer xfer;
- unsigned rt_size;
+ return pan_resource(ss->upload.rsrc)->bo->gpu + ss->upload.offset;
+}
- if (dev->quirks & MIDGARD_SFBD)
- rt_size = 0;
- else if (dev->quirks & IS_BIFROST)
- rt_size = sizeof(struct bifrost_blend_rt);
- else
- rt_size = sizeof(struct midgard_blend_rt);
+mali_ptr
+panfrost_emit_frag_shader_meta(struct panfrost_batch *batch)
+{
+ struct panfrost_context *ctx = batch->ctx;
+ struct panfrost_shader_state *ss = panfrost_get_shader_state(ctx, PIPE_SHADER_FRAGMENT);
+ struct mali_shader_meta meta;
- desc_size += rt_size * rt_count;
+ /* Add the shader BO to the batch. */
+ panfrost_batch_add_bo(batch, ss->bo,
+ PAN_BO_ACCESS_PRIVATE |
+ PAN_BO_ACCESS_READ |
+ PAN_BO_ACCESS_FRAGMENT);
- if (rt_size)
- rts = rzalloc_size(ctx, rt_size * rt_count);
+ struct panfrost_device *dev = pan_device(ctx->base.screen);
+ unsigned rt_count = MAX2(ctx->pipe_framebuffer.nr_cbufs, 1);
+ size_t desc_size = sizeof(meta);
+ void *rts = NULL;
+ struct panfrost_transfer xfer;
+ unsigned rt_size;
+
+ if (dev->quirks & MIDGARD_SFBD)
+ rt_size = 0;
+ else if (dev->quirks & IS_BIFROST)
+ rt_size = sizeof(struct bifrost_blend_rt);
+ else
+ rt_size = sizeof(struct midgard_blend_rt);
- struct panfrost_blend_final blend[PIPE_MAX_COLOR_BUFS];
+ desc_size += rt_size * rt_count;
- for (unsigned c = 0; c < ctx->pipe_framebuffer.nr_cbufs; ++c)
- blend[c] = panfrost_get_blend_for_context(ctx, c);
+ if (rt_size)
+ rts = rzalloc_size(ctx, rt_size * rt_count);
- panfrost_emit_frag_shader(ctx, &meta, blend);
+ struct panfrost_blend_final blend[PIPE_MAX_COLOR_BUFS];
- if (!(dev->quirks & MIDGARD_SFBD))
- panfrost_emit_blend(batch, rts, blend);
- else
- batch->draws |= PIPE_CLEAR_COLOR0;
+ for (unsigned c = 0; c < ctx->pipe_framebuffer.nr_cbufs; ++c)
+ blend[c] = panfrost_get_blend_for_context(ctx, c);
- xfer = panfrost_pool_alloc_aligned(&batch->pool, desc_size, sizeof(meta));
+ panfrost_emit_frag_shader(ctx, &meta, blend);
- memcpy(xfer.cpu, &meta, sizeof(meta));
- memcpy(xfer.cpu + sizeof(meta), rts, rt_size * rt_count);
+ if (!(dev->quirks & MIDGARD_SFBD))
+ panfrost_emit_blend(batch, rts, blend);
+ else
+ batch->draws |= PIPE_CLEAR_COLOR0;
- if (rt_size)
- ralloc_free(rts);
+ xfer = panfrost_pool_alloc_aligned(&batch->pool, desc_size, sizeof(meta));
- shader_ptr = xfer.gpu;
- } else {
- panfrost_emit_compute_shader(ctx, st, &meta);
+ memcpy(xfer.cpu, &meta, sizeof(meta));
+ memcpy(xfer.cpu + sizeof(meta), rts, rt_size * rt_count);
- shader_ptr = panfrost_pool_upload(&batch->pool, &meta,
- sizeof(meta));
- }
+ if (rt_size)
+ ralloc_free(rts);
- postfix->shader = shader_ptr;
+ return xfer.gpu;
}
void
}
/* Next up, attach UBOs. UBO #0 is the uniforms we just
- * uploaded */
+ * uploaded, so it's always included. The count is the highest UBO
+ * addressable -- gaps are included. */
- unsigned ubo_count = panfrost_ubo_count(ctx, stage);
- assert(ubo_count >= 1);
+ unsigned ubo_count = 32 - __builtin_clz(buf->enabled_mask | 1);
size_t sz = MALI_UNIFORM_BUFFER_LENGTH * ubo_count;
struct panfrost_transfer ubos =
projects / mesa.git / blobdiff