summaryrefslogtreecommitdiff
path: root/src/panfrost/lib/genxml/decode.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/panfrost/lib/genxml/decode.c')
-rw-r--r--src/panfrost/lib/genxml/decode.c508
1 files changed, 508 insertions, 0 deletions
diff --git a/src/panfrost/lib/genxml/decode.c b/src/panfrost/lib/genxml/decode.c
new file mode 100644
index 00000000000..fea885a3e54
--- /dev/null
+++ b/src/panfrost/lib/genxml/decode.c
@@ -0,0 +1,508 @@
+/*
+ * Copyright (C) 2017-2019 Alyssa Rosenzweig
+ * Copyright (C) 2017-2019 Connor Abbott
+ * Copyright (C) 2019 Collabora, Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include "decode.h"
+#include <ctype.h>
+#include <errno.h>
+#include <memory.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <genxml/gen_macros.h>
+#include <sys/mman.h>
+
+#include "compiler/bifrost/disassemble.h"
+#include "compiler/valhall/disassemble.h"
+#include "midgard/disassemble.h"
+#include "util/set.h"
+#include "pan_format.h"
+
+#if PAN_ARCH <= 5
+/* Midgard's tiler descriptor is embedded within the
+ * larger FBD */
+
+static void
+pandecode_midgard_tiler_descriptor(struct pandecode_context *ctx,
+ const struct mali_tiler_context_packed *tp,
+ const struct mali_tiler_weights_packed *wp)
+{
+ pan_unpack(tp, TILER_CONTEXT, t);
+ DUMP_UNPACKED(ctx, TILER_CONTEXT, t, "Tiler:\n");
+
+ /* We've never seen weights used in practice, but they exist */
+ pan_unpack(wp, TILER_WEIGHTS, w);
+ bool nonzero_weights = false;
+
+ nonzero_weights |= w.weight0 != 0x0;
+ nonzero_weights |= w.weight1 != 0x0;
+ nonzero_weights |= w.weight2 != 0x0;
+ nonzero_weights |= w.weight3 != 0x0;
+ nonzero_weights |= w.weight4 != 0x0;
+ nonzero_weights |= w.weight5 != 0x0;
+ nonzero_weights |= w.weight6 != 0x0;
+ nonzero_weights |= w.weight7 != 0x0;
+
+ if (nonzero_weights)
+ DUMP_UNPACKED(ctx, TILER_WEIGHTS, w, "Tiler Weights:\n");
+}
+#endif
+
+#if PAN_ARCH >= 5
+static void
+pandecode_render_target(struct pandecode_context *ctx, uint64_t gpu_va,
+ unsigned gpu_id,
+ const struct MALI_FRAMEBUFFER_PARAMETERS *fb)
+{
+ pandecode_log(ctx, "Color Render Targets @%" PRIx64 ":\n", gpu_va);
+ ctx->indent++;
+
+ for (int i = 0; i < (fb->render_target_count); i++) {
+ mali_ptr rt_va = gpu_va + i * pan_size(RENDER_TARGET);
+ const struct mali_render_target_packed *PANDECODE_PTR_VAR(
+ ctx, rtp, (mali_ptr)rt_va);
+ DUMP_CL(ctx, RENDER_TARGET, rtp, "Color Render Target %d:\n", i);
+ }
+
+ ctx->indent--;
+ pandecode_log(ctx, "\n");
+}
+#endif
+
+#if PAN_ARCH >= 6
+static void
+pandecode_sample_locations(struct pandecode_context *ctx, const void *fb)
+{
+ pan_section_unpack(fb, FRAMEBUFFER, PARAMETERS, params);
+
+ const u16 *PANDECODE_PTR_VAR(ctx, samples, params.sample_locations);
+
+ pandecode_log(ctx, "Sample locations @%" PRIx64 ":\n",
+ params.sample_locations);
+ for (int i = 0; i < 33; i++) {
+ pandecode_log(ctx, " (%d, %d),\n", samples[2 * i] - 128,
+ samples[2 * i + 1] - 128);
+ }
+}
+#endif
+
+struct pandecode_fbd
+GENX(pandecode_fbd)(struct pandecode_context *ctx, uint64_t gpu_va,
+ bool is_fragment, unsigned gpu_id)
+{
+ const void *PANDECODE_PTR_VAR(ctx, fb, (mali_ptr)gpu_va);
+ pan_section_unpack(fb, FRAMEBUFFER, PARAMETERS, params);
+ DUMP_UNPACKED(ctx, FRAMEBUFFER_PARAMETERS, params, "Parameters:\n");
+
+#if PAN_ARCH >= 6
+ pandecode_sample_locations(ctx, fb);
+
+ unsigned dcd_size = pan_size(DRAW);
+ unsigned job_type_param = 0;
+
+#if PAN_ARCH <= 9
+ job_type_param = MALI_JOB_TYPE_FRAGMENT;
+#endif
+
+ if (params.pre_frame_0 != MALI_PRE_POST_FRAME_SHADER_MODE_NEVER) {
+ const void *PANDECODE_PTR_VAR(ctx, dcd,
+ params.frame_shader_dcds + (0 * dcd_size));
+ pan_unpack(dcd, DRAW, draw);
+ pandecode_log(ctx, "Pre frame 0 @%" PRIx64 " (mode=%d):\n",
+ params.frame_shader_dcds, params.pre_frame_0);
+ GENX(pandecode_dcd)(ctx, &draw, job_type_param, gpu_id);
+ }
+
+ if (params.pre_frame_1 != MALI_PRE_POST_FRAME_SHADER_MODE_NEVER) {
+ const void *PANDECODE_PTR_VAR(ctx, dcd,
+ params.frame_shader_dcds + (1 * dcd_size));
+ pan_unpack(dcd, DRAW, draw);
+ pandecode_log(ctx, "Pre frame 1 @%" PRIx64 ":\n",
+ params.frame_shader_dcds + (1 * dcd_size));
+ GENX(pandecode_dcd)(ctx, &draw, job_type_param, gpu_id);
+ }
+
+ if (params.post_frame != MALI_PRE_POST_FRAME_SHADER_MODE_NEVER) {
+ const void *PANDECODE_PTR_VAR(ctx, dcd,
+ params.frame_shader_dcds + (2 * dcd_size));
+ pan_unpack(dcd, DRAW, draw);
+ pandecode_log(ctx, "Post frame:\n");
+ GENX(pandecode_dcd)(ctx, &draw, job_type_param, gpu_id);
+ }
+#else
+ DUMP_SECTION(ctx, FRAMEBUFFER, LOCAL_STORAGE, fb, "Local Storage:\n");
+
+ const void *t = pan_section_ptr(fb, FRAMEBUFFER, TILER);
+ const void *w = pan_section_ptr(fb, FRAMEBUFFER, TILER_WEIGHTS);
+ pandecode_midgard_tiler_descriptor(ctx, t, w);
+#endif
+
+ pandecode_log(ctx, "Framebuffer @%" PRIx64 ":\n", gpu_va);
+ ctx->indent++;
+
+ DUMP_UNPACKED(ctx, FRAMEBUFFER_PARAMETERS, params, "Parameters:\n");
+#if PAN_ARCH >= 6
+ if (params.tiler)
+ GENX(pandecode_tiler)(ctx, params.tiler, gpu_id);
+#endif
+
+ ctx->indent--;
+ pandecode_log(ctx, "\n");
+
+#if PAN_ARCH >= 5
+ gpu_va += pan_size(FRAMEBUFFER);
+
+ if (params.has_zs_crc_extension) {
+ const struct mali_zs_crc_extension_packed *PANDECODE_PTR_VAR(
+ ctx, zs_crc, (mali_ptr)gpu_va);
+ DUMP_CL(ctx, ZS_CRC_EXTENSION, zs_crc, "ZS CRC Extension:\n");
+ pandecode_log(ctx, "\n");
+
+ gpu_va += pan_size(ZS_CRC_EXTENSION);
+ }
+
+ if (is_fragment)
+ pandecode_render_target(ctx, gpu_va, gpu_id, &params);
+
+ return (struct pandecode_fbd){
+ .rt_count = params.render_target_count,
+ .has_extra = params.has_zs_crc_extension,
+ };
+#else
+ /* Dummy unpack of the padding section to make sure all words are 0.
+ * No need to call print here since the section is supposed to be empty.
+ */
+ pan_section_unpack(fb, FRAMEBUFFER, PADDING_1, padding1);
+ pan_section_unpack(fb, FRAMEBUFFER, PADDING_2, padding2);
+
+ return (struct pandecode_fbd){
+ .rt_count = 1,
+ };
+#endif
+}
+
+#if PAN_ARCH >= 5
+mali_ptr
+GENX(pandecode_blend)(struct pandecode_context *ctx, void *descs, int rt_no,
+ mali_ptr frag_shader)
+{
+ pan_unpack(descs + (rt_no * pan_size(BLEND)), BLEND, b);
+ DUMP_UNPACKED(ctx, BLEND, b, "Blend RT %d:\n", rt_no);
+#if PAN_ARCH >= 6
+ if (b.internal.mode != MALI_BLEND_MODE_SHADER)
+ return 0;
+
+ return (frag_shader & 0xFFFFFFFF00000000ULL) | b.internal.shader.pc;
+#else
+ return b.blend_shader ? (b.shader_pc & ~0xf) : 0;
+#endif
+}
+#endif
+
+#if PAN_ARCH <= 7
+static bool
+panfrost_is_yuv_format(uint32_t packed)
+{
+#if PAN_ARCH == 7
+ enum mali_format mali_fmt = packed >> 12;
+ return mali_fmt >= MALI_YUV8 && mali_fmt <= MALI_CUSTOM_YUV_5;
+#else
+ /* Currently only supported by panfrost on v7 */
+ assert(0);
+ return false;
+#endif
+}
+
+static void
+pandecode_texture_payload(struct pandecode_context *ctx, mali_ptr payload,
+ const struct MALI_TEXTURE *tex)
+{
+ unsigned nr_samples =
+ tex->dimension == MALI_TEXTURE_DIMENSION_3D ? 1 : tex->sample_count;
+
+ /* A bunch of bitmap pointers follow.
+ * We work out the correct number,
+ * based on the mipmap/cubemap
+ * properties, but dump extra
+ * possibilities to futureproof */
+
+ int bitmap_count = tex->levels;
+
+ /* Miptree for each face */
+ if (tex->dimension == MALI_TEXTURE_DIMENSION_CUBE)
+ bitmap_count *= 6;
+
+ /* Array of layers */
+ bitmap_count *= nr_samples;
+
+ /* Array of textures */
+ bitmap_count *= tex->array_size;
+
+#define PANDECODE_EMIT_TEX_PAYLOAD_DESC(T, msg) \
+ for (int i = 0; i < bitmap_count; ++i) { \
+ uint64_t addr = payload + pan_size(T) * i; \
+ pan_unpack(PANDECODE_PTR(ctx, addr, void), T, s); \
+ DUMP_UNPACKED(ctx, T, s, msg " @%" PRIx64 ":\n", addr) \
+ }
+
+#if PAN_ARCH <= 5
+ switch (tex->surface_type) {
+ case MALI_SURFACE_TYPE_32:
+ PANDECODE_EMIT_TEX_PAYLOAD_DESC(SURFACE_32, "Surface 32");
+ break;
+ case MALI_SURFACE_TYPE_64:
+ PANDECODE_EMIT_TEX_PAYLOAD_DESC(SURFACE, "Surface");
+ break;
+ case MALI_SURFACE_TYPE_32_WITH_ROW_STRIDE:
+ PANDECODE_EMIT_TEX_PAYLOAD_DESC(SURFACE_32, "Surface 32 With Row Stride");
+ break;
+ case MALI_SURFACE_TYPE_64_WITH_STRIDES:
+ PANDECODE_EMIT_TEX_PAYLOAD_DESC(SURFACE_WITH_STRIDE,
+ "Surface With Stride");
+ break;
+ default:
+ fprintf(ctx->dump_stream, "Unknown surface descriptor type %X\n",
+ tex->surface_type);
+ break;
+ }
+#elif PAN_ARCH == 6
+ PANDECODE_EMIT_TEX_PAYLOAD_DESC(SURFACE_WITH_STRIDE, "Surface With Stride");
+#else
+ STATIC_ASSERT(PAN_ARCH == 7);
+ if (panfrost_is_yuv_format(tex->format)) {
+ PANDECODE_EMIT_TEX_PAYLOAD_DESC(MULTIPLANAR_SURFACE, "Surface YUV");
+ } else {
+ PANDECODE_EMIT_TEX_PAYLOAD_DESC(SURFACE_WITH_STRIDE,
+ "Surface With Stride");
+ }
+#endif
+
+#undef PANDECODE_EMIT_TEX_PAYLOAD_DESC
+}
+#endif
+
+#if PAN_ARCH <= 5
+void
+GENX(pandecode_texture)(struct pandecode_context *ctx, mali_ptr u, unsigned tex)
+{
+ const uint8_t *cl = pandecode_fetch_gpu_mem(ctx, u, pan_size(TEXTURE));
+
+ pan_unpack(cl, TEXTURE, temp);
+ DUMP_UNPACKED(ctx, TEXTURE, temp, "Texture:\n")
+
+ ctx->indent++;
+ pandecode_texture_payload(ctx, u + pan_size(TEXTURE), &temp);
+ ctx->indent--;
+}
+#else
+void
+GENX(pandecode_texture)(struct pandecode_context *ctx, const void *cl,
+ unsigned tex)
+{
+ pan_unpack(cl, TEXTURE, temp);
+ DUMP_UNPACKED(ctx, TEXTURE, temp, "Texture:\n")
+
+ ctx->indent++;
+
+#if PAN_ARCH >= 9
+ int plane_count = temp.levels * temp.array_size;
+
+ /* Miptree for each face */
+ if (temp.dimension == MALI_TEXTURE_DIMENSION_CUBE)
+ plane_count *= 6;
+
+ for (unsigned i = 0; i < plane_count; ++i)
+ DUMP_ADDR(ctx, PLANE, temp.surfaces + i * pan_size(PLANE), "Plane %u:\n",
+ i);
+#else
+ pandecode_texture_payload(ctx, temp.surfaces, &temp);
+#endif
+ ctx->indent--;
+}
+#endif
+
+#if PAN_ARCH >= 6
+void
+GENX(pandecode_tiler)(struct pandecode_context *ctx, mali_ptr gpu_va,
+ unsigned gpu_id)
+{
+ pan_unpack(PANDECODE_PTR(ctx, gpu_va, void), TILER_CONTEXT, t);
+
+ if (t.heap) {
+ pan_unpack(PANDECODE_PTR(ctx, t.heap, void), TILER_HEAP, h);
+ DUMP_UNPACKED(ctx, TILER_HEAP, h, "Tiler Heap:\n");
+ }
+
+ DUMP_UNPACKED(ctx, TILER_CONTEXT, t, "Tiler Context @%" PRIx64 ":\n",
+ gpu_va);
+}
+#endif
+
+#if PAN_ARCH >= 9
+void
+GENX(pandecode_fau)(struct pandecode_context *ctx, mali_ptr addr,
+ unsigned count, const char *name)
+{
+ if (count == 0)
+ return;
+
+ const uint32_t *PANDECODE_PTR_VAR(ctx, raw, addr);
+
+ pandecode_validate_buffer(ctx, addr, count * 8);
+
+ fprintf(ctx->dump_stream, "%s @%" PRIx64 ":\n", name, addr);
+ for (unsigned i = 0; i < count; ++i) {
+ fprintf(ctx->dump_stream, " %08X %08X\n", raw[2 * i], raw[2 * i + 1]);
+ }
+ fprintf(ctx->dump_stream, "\n");
+}
+
+mali_ptr
+GENX(pandecode_shader)(struct pandecode_context *ctx, mali_ptr addr,
+ const char *label, unsigned gpu_id)
+{
+ MAP_ADDR(ctx, SHADER_PROGRAM, addr, cl);
+ pan_unpack(cl, SHADER_PROGRAM, desc);
+
+ assert(desc.type == 8);
+
+ DUMP_UNPACKED(ctx, SHADER_PROGRAM, desc, "%s Shader @%" PRIx64 ":\n", label,
+ addr);
+ pandecode_shader_disassemble(ctx, desc.binary, gpu_id);
+ return desc.binary;
+}
+
+static void
+pandecode_resources(struct pandecode_context *ctx, mali_ptr addr, unsigned size)
+{
+ const uint8_t *cl = pandecode_fetch_gpu_mem(ctx, addr, size);
+ assert((size % 0x20) == 0);
+
+ for (unsigned i = 0; i < size; i += 0x20) {
+ unsigned type = (cl[i] & 0xF);
+
+ switch (type) {
+ case MALI_DESCRIPTOR_TYPE_SAMPLER:
+ DUMP_CL(ctx, SAMPLER, cl + i, "Sampler @%" PRIx64 ":\n", addr + i);
+ break;
+ case MALI_DESCRIPTOR_TYPE_TEXTURE:
+ pandecode_log(ctx, "Texture @%" PRIx64 "\n", addr + i);
+ GENX(pandecode_texture)(ctx, cl + i, i);
+ break;
+ case MALI_DESCRIPTOR_TYPE_ATTRIBUTE:
+ DUMP_CL(ctx, ATTRIBUTE, cl + i, "Attribute @%" PRIx64 ":\n", addr + i);
+ break;
+ case MALI_DESCRIPTOR_TYPE_BUFFER:
+ DUMP_CL(ctx, BUFFER, cl + i, "Buffer @%" PRIx64 ":\n", addr + i);
+ break;
+ default:
+ fprintf(ctx->dump_stream, "Unknown descriptor type %X\n", type);
+ break;
+ }
+ }
+}
+
+void
+GENX(pandecode_resource_tables)(struct pandecode_context *ctx, mali_ptr addr,
+ const char *label)
+{
+ unsigned count = addr & 0x3F;
+ addr = addr & ~0x3F;
+
+ const uint8_t *cl =
+ pandecode_fetch_gpu_mem(ctx, addr, MALI_RESOURCE_LENGTH * count);
+
+ pandecode_log(ctx, "%s resource table @%" PRIx64 "\n", label, addr);
+ ctx->indent += 2;
+ for (unsigned i = 0; i < count; ++i) {
+ pan_unpack(cl + i * MALI_RESOURCE_LENGTH, RESOURCE, entry);
+ DUMP_UNPACKED(ctx, RESOURCE, entry, "Entry %u @%" PRIx64 ":\n", i,
+ addr + i * MALI_RESOURCE_LENGTH);
+
+ ctx->indent += 2;
+ if (entry.address)
+ pandecode_resources(ctx, entry.address, entry.size);
+ ctx->indent -= 2;
+ }
+ ctx->indent -= 2;
+}
+
+void
+GENX(pandecode_depth_stencil)(struct pandecode_context *ctx, mali_ptr addr)
+{
+ MAP_ADDR(ctx, DEPTH_STENCIL, addr, cl);
+ pan_unpack(cl, DEPTH_STENCIL, desc);
+ DUMP_UNPACKED(ctx, DEPTH_STENCIL, desc, "Depth/stencil");
+}
+
+void
+GENX(pandecode_shader_environment)(struct pandecode_context *ctx,
+ const struct MALI_SHADER_ENVIRONMENT *p,
+ unsigned gpu_id)
+{
+ if (p->shader)
+ GENX(pandecode_shader)(ctx, p->shader, "Shader", gpu_id);
+
+ if (p->resources)
+ GENX(pandecode_resource_tables)(ctx, p->resources, "Resources");
+
+ if (p->thread_storage)
+ DUMP_ADDR(ctx, LOCAL_STORAGE, p->thread_storage, "Local Storage:\n");
+
+ if (p->fau)
+ GENX(pandecode_fau)(ctx, p->fau, p->fau_count, "FAU");
+}
+
+void
+GENX(pandecode_blend_descs)(struct pandecode_context *ctx, mali_ptr blend,
+ unsigned count, mali_ptr frag_shader,
+ unsigned gpu_id)
+{
+ for (unsigned i = 0; i < count; ++i) {
+ struct mali_blend_packed *PANDECODE_PTR_VAR(ctx, blend_descs, blend);
+
+ mali_ptr blend_shader =
+ GENX(pandecode_blend)(ctx, blend_descs, i, frag_shader);
+ if (blend_shader) {
+ fprintf(ctx->dump_stream, "Blend shader %u @%" PRIx64 "", i,
+ blend_shader);
+ pandecode_shader_disassemble(ctx, blend_shader, gpu_id);
+ }
+ }
+}
+
+void
+GENX(pandecode_dcd)(struct pandecode_context *ctx, const struct MALI_DRAW *p,
+ unsigned unused, unsigned gpu_id)
+{
+ mali_ptr frag_shader = 0;
+
+ GENX(pandecode_depth_stencil)(ctx, p->depth_stencil);
+ GENX(pandecode_blend_descs)
+ (ctx, p->blend, p->blend_count, frag_shader, gpu_id);
+ GENX(pandecode_shader_environment)(ctx, &p->shader, gpu_id);
+ DUMP_UNPACKED(ctx, DRAW, *p, "Draw:\n");
+}
+#endif
generated by cgit v1.2.3 (git 2.39.1) at 2024-04-26 02:44:10 +0000