#include "midgard/midgard_compile.h"
#include "bifrost/bifrost_compile.h"
#include "util/u_dynarray.h"
+#include "util/u_upload_mgr.h"
#include "tgsi/tgsi_dump.h"
+static void
+pan_pack_midgard_props(struct panfrost_shader_state *state,
+ gl_shader_stage stage)
+{
+ pan_pack(&state->properties, MIDGARD_PROPERTIES, cfg) {
+ cfg.uniform_buffer_count = state->ubo_count;
+ cfg.uniform_count = state->uniform_count;
+ cfg.writes_globals = state->writes_global;
+ cfg.suppress_inf_nan = true; /* XXX */
+
+ if (stage == MESA_SHADER_FRAGMENT) {
+ /* Work register count, early-z, reads at draw-time */
+ cfg.stencil_from_shader = state->writes_stencil;
+ cfg.helper_invocation_enable = state->helper_invocations;
+ cfg.depth_source = state->writes_depth ?
+ MALI_DEPTH_SOURCE_SHADER :
+ MALI_DEPTH_SOURCE_FIXED_FUNCTION;
+ } else {
+ cfg.work_register_count = state->work_reg_count;
+ }
+ }
+}
+
+static void
+pan_pack_bifrost_props(struct panfrost_shader_state *state,
+ gl_shader_stage stage)
+{
+ switch (stage) {
+ case MESA_SHADER_VERTEX:
+ pan_pack(&state->properties, BIFROST_PROPERTIES, cfg) {
+ cfg.unknown = 0x800000; /* XXX */
+ cfg.uniform_buffer_count = state->ubo_count;
+ }
+
+ pan_pack(&state->preload, PRELOAD_VERTEX, cfg) {
+ cfg.uniform_count = state->uniform_count;
+ cfg.vertex_id = true;
+ cfg.instance_id = true;
+ }
+
+ break;
+ case MESA_SHADER_FRAGMENT:
+ pan_pack(&state->properties, BIFROST_PROPERTIES, cfg) {
+ /* Early-Z set at draw-time */
+
+ cfg.unknown = 0x950020; /* XXX */
+ cfg.uniform_buffer_count = state->ubo_count;
+ }
+
+ pan_pack(&state->preload, PRELOAD_FRAGMENT, cfg) {
+ cfg.uniform_count = state->uniform_count;
+ cfg.fragment_position = state->reads_frag_coord;
+ }
+
+ break;
+ default:
+ unreachable("TODO");
+ }
+}
+
+static void
+pan_upload_shader_descriptor(struct panfrost_context *ctx,
+ struct panfrost_shader_state *state)
+{
+ const struct panfrost_device *dev = pan_device(ctx->base.screen);
+ struct mali_state_packed *out;
+
+ u_upload_alloc(ctx->state_uploader, 0, MALI_STATE_LENGTH, MALI_STATE_LENGTH,
+ &state->upload.offset, &state->upload.rsrc, (void **) &out);
+
+ pan_pack(out, STATE_OPAQUE, cfg) {
+ cfg.shader = state->shader;
+ memcpy(&cfg.properties, &state->properties, sizeof(state->properties));
+
+ if (dev->quirks & IS_BIFROST)
+ cfg.preload = state->preload;
+ }
+
+ u_upload_unmap(ctx->state_uploader);
+}
+
static unsigned
pan_format_from_nir_base(nir_alu_type base)
{
uint64_t *outputs_written)
{
struct panfrost_device *dev = pan_device(ctx->base.screen);
- uint8_t *dst;
nir_shader *s;
}
/* Prepare the compiled binary for upload */
+ mali_ptr shader = 0;
+ unsigned attribute_count = 0, varying_count = 0;
int size = program.compiled.size;
- dst = program.compiled.data;
-
- /* Upload the shader. The lookahead tag is ORed on as a tagged pointer.
- * I bet someone just thought that would be a cute pun. At least,
- * that's how I'd do it. */
if (size) {
state->bo = panfrost_bo_create(dev, size, PAN_BO_EXECUTE);
- memcpy(state->bo->cpu, dst, size);
+ memcpy(state->bo->cpu, program.compiled.data, size);
+ shader = state->bo->gpu;
}
+ /* Midgard needs the first tag on the bottom nibble */
+
if (!(dev->quirks & IS_BIFROST)) {
- /* If size = 0, no shader. Use dummy tag to avoid
- * INSTR_INVALID_ENC */
- state->first_tag = size ? program.first_tag : 1;
+ /* If size = 0, we tag as "end-of-shader" */
+
+ if (size)
+ shader |= program.first_tag;
+ else
+ shader = 0x1;
}
util_dynarray_fini(&program.compiled);
switch (stage) {
case MESA_SHADER_VERTEX:
- state->attribute_count = util_bitcount64(s->info.inputs_read);
- state->varying_count = util_bitcount64(s->info.outputs_written);
+ attribute_count = util_bitcount64(s->info.inputs_read);
+ varying_count = util_bitcount64(s->info.outputs_written);
if (vertex_id)
- state->attribute_count = MAX2(state->attribute_count, PAN_VERTEX_ID + 1);
+ attribute_count = MAX2(attribute_count, PAN_VERTEX_ID + 1);
if (instance_id)
- state->attribute_count = MAX2(state->attribute_count, PAN_INSTANCE_ID + 1);
+ attribute_count = MAX2(attribute_count, PAN_INSTANCE_ID + 1);
break;
case MESA_SHADER_FRAGMENT:
- state->attribute_count = 0;
- state->varying_count = util_bitcount64(s->info.inputs_read);
+ varying_count = util_bitcount64(s->info.inputs_read);
if (s->info.outputs_written & BITFIELD64_BIT(FRAG_RESULT_DEPTH))
state->writes_depth = true;
if (s->info.outputs_written & BITFIELD64_BIT(FRAG_RESULT_STENCIL))
break;
case MESA_SHADER_COMPUTE:
/* TODO: images */
- state->attribute_count = 0;
- state->varying_count = 0;
state->shared_size = s->info.cs.shared_size;
break;
default:
}
}
+ /* Needed for linkage */
+ state->attribute_count = attribute_count;
+ state->varying_count = varying_count;
+ state->ubo_count = s->info.num_ubos + 1; /* off-by-one for uniforms */
+
+ /* Prepare the descriptors at compile-time */
+ pan_pack(&state->shader, SHADER, cfg) {
+ cfg.shader = shader;
+ cfg.attribute_count = attribute_count;
+ cfg.varying_count = varying_count;
+ cfg.texture_count = s->info.num_textures;
+ cfg.sampler_count = cfg.texture_count;
+ }
+
+ if (dev->quirks & IS_BIFROST)
+ pan_pack_bifrost_props(state, stage);
+ else
+ pan_pack_midgard_props(state, stage);
+
+ if (stage != MESA_SHADER_FRAGMENT)
+ pan_upload_shader_descriptor(ctx, state);
+
/* In both clone and tgsi_to_nir paths, the shader is ralloc'd against
* a NULL context */
ralloc_free(s);
projects / mesa.git / blobdiff