lima_screen.c \
lima_screen.h \
lima_state.c \
- lima_submit.c \
- lima_submit.h \
+ lima_job.c \
+ lima_job.h \
lima_texture.c \
lima_texture.h \
lima_util.c \
#include "lima_context.h"
#include "lima_resource.h"
#include "lima_bo.h"
-#include "lima_submit.h"
+#include "lima_job.h"
#include "lima_util.h"
#include "lima_fence.h"
uint32_t
lima_ctx_buff_va(struct lima_context *ctx, enum lima_ctx_buff buff)
{
- struct lima_submit *submit = lima_submit_get(ctx);
+ struct lima_job *job = lima_job_get(ctx);
struct lima_ctx_buff_state *cbs = ctx->buffer_state + buff;
struct lima_resource *res = lima_resource(cbs->res);
int pipe = buff < lima_ctx_buff_num_gp ? LIMA_PIPE_GP : LIMA_PIPE_PP;
- lima_submit_add_bo(submit, pipe, res->bo, LIMA_SUBMIT_BO_READ);
+ lima_job_add_bo(job, pipe, res->bo, LIMA_SUBMIT_BO_READ);
return res->bo->va + cbs->offset;
}
{
struct lima_context *ctx = lima_context(pctx);
- struct hash_entry *entry = _mesa_hash_table_search(ctx->write_submits, prsc);
+ struct hash_entry *entry = _mesa_hash_table_search(ctx->write_jobs, prsc);
if (!entry)
return;
- struct lima_submit *submit = entry->data;
- if (submit->key.zsbuf && (submit->key.zsbuf->texture == prsc))
- submit->resolve &= ~(PIPE_CLEAR_DEPTH | PIPE_CLEAR_STENCIL);
+ struct lima_job *job = entry->data;
+ if (job->key.zsbuf && (job->key.zsbuf->texture == prsc))
+ job->resolve &= ~(PIPE_CLEAR_DEPTH | PIPE_CLEAR_STENCIL);
- if (submit->key.cbuf && (submit->key.cbuf->texture == prsc))
- submit->resolve &= ~PIPE_CLEAR_COLOR0;
+ if (job->key.cbuf && (job->key.cbuf->texture == prsc))
+ job->resolve &= ~PIPE_CLEAR_COLOR0;
}
static void
struct lima_context *ctx = lima_context(pctx);
struct lima_screen *screen = lima_screen(pctx->screen);
- lima_submit_fini(ctx);
+ lima_job_fini(ctx);
for (int i = 0; i < lima_ctx_buff_num; i++)
pipe_resource_reference(&ctx->buffer_state[i].res, NULL);
goto err_out;
}
- if (!lima_submit_init(ctx))
+ if (!lima_job_init(ctx))
goto err_out;
return &ctx->base;
struct lima_ctx_buff_state buffer_state[lima_ctx_buff_num];
- /* current submit */
- struct lima_submit *submit;
+ /* current job */
+ struct lima_job *job;
- /* map from lima_submit_key to lima_submit */
- struct hash_table *submits;
+ /* map from lima_job_key to lima_job */
+ struct hash_table *jobs;
- /* map from pipe_resource to lima_submit which write to it */
- struct hash_table *write_submits;
+ /* map from pipe_resource to lima_job which write to it */
+ struct hash_table *write_jobs;
int in_sync_fd;
uint32_t in_sync[2];
lima_context_create(struct pipe_screen *pscreen, void *priv, unsigned flags);
void lima_flush(struct lima_context *ctx);
-void lima_flush_submit_accessing_bo(
+void lima_flush_job_accessing_bo(
struct lima_context *ctx, struct lima_bo *bo, bool write);
-void lima_flush_previous_submit_writing_resource(
+void lima_flush_previous_job_writing_resource(
struct lima_context *ctx, struct pipe_resource *prsc);
#endif
#include "lima_resource.h"
#include "lima_program.h"
#include "lima_bo.h"
-#include "lima_submit.h"
+#include "lima_job.h"
#include "lima_texture.h"
#include "lima_util.h"
#include "lima_gpu.h"
}
static void
-lima_update_submit_wb(struct lima_context *ctx, unsigned buffers)
+lima_update_job_wb(struct lima_context *ctx, unsigned buffers)
{
- struct lima_submit *submit = lima_submit_get(ctx);
+ struct lima_job *job = lima_job_get(ctx);
struct lima_context_framebuffer *fb = &ctx->framebuffer;
- /* add to submit when the buffer is dirty and resolve is clear (not added before) */
+ /* add to job when the buffer is dirty and resolve is clear (not added before) */
if (fb->base.nr_cbufs && (buffers & PIPE_CLEAR_COLOR0) &&
- !(submit->resolve & PIPE_CLEAR_COLOR0)) {
+ !(job->resolve & PIPE_CLEAR_COLOR0)) {
struct lima_resource *res = lima_resource(fb->base.cbufs[0]->texture);
- lima_flush_submit_accessing_bo(ctx, res->bo, true);
- _mesa_hash_table_insert(ctx->write_submits, &res->base, submit);
- lima_submit_add_bo(submit, LIMA_PIPE_PP, res->bo, LIMA_SUBMIT_BO_WRITE);
+ lima_flush_job_accessing_bo(ctx, res->bo, true);
+ _mesa_hash_table_insert(ctx->write_jobs, &res->base, job);
+ lima_job_add_bo(job, LIMA_PIPE_PP, res->bo, LIMA_SUBMIT_BO_WRITE);
}
- /* add to submit when the buffer is dirty and resolve is clear (not added before) */
+ /* add to job when the buffer is dirty and resolve is clear (not added before) */
if (fb->base.zsbuf && (buffers & (PIPE_CLEAR_DEPTH | PIPE_CLEAR_STENCIL)) &&
- !(submit->resolve & (PIPE_CLEAR_DEPTH | PIPE_CLEAR_STENCIL))) {
+ !(job->resolve & (PIPE_CLEAR_DEPTH | PIPE_CLEAR_STENCIL))) {
struct lima_resource *res = lima_resource(fb->base.zsbuf->texture);
- lima_flush_submit_accessing_bo(ctx, res->bo, true);
- _mesa_hash_table_insert(ctx->write_submits, &res->base, submit);
- lima_submit_add_bo(submit, LIMA_PIPE_PP, res->bo, LIMA_SUBMIT_BO_WRITE);
+ lima_flush_job_accessing_bo(ctx, res->bo, true);
+ _mesa_hash_table_insert(ctx->write_jobs, &res->base, job);
+ lima_job_add_bo(job, LIMA_PIPE_PP, res->bo, LIMA_SUBMIT_BO_WRITE);
}
- submit->resolve |= buffers;
+ job->resolve |= buffers;
}
static void
const union pipe_color_union *color, double depth, unsigned stencil)
{
struct lima_context *ctx = lima_context(pctx);
- struct lima_submit *submit = lima_submit_get(ctx);
+ struct lima_job *job = lima_job_get(ctx);
- /* flush if this submit already contains any draw, otherwise multi clear can be
- * combined into a single submit */
- if (lima_submit_has_draw_pending(submit)) {
- lima_do_submit(submit);
- submit = lima_submit_get(ctx);
+ /* flush if this job already contains any draw, otherwise multi clear can be
+ * combined into a single job */
+ if (lima_job_has_draw_pending(job)) {
+ lima_do_job(job);
+ job = lima_job_get(ctx);
}
- lima_update_submit_wb(ctx, buffers);
+ lima_update_job_wb(ctx, buffers);
/* no need to reload if cleared */
if (ctx->framebuffer.base.nr_cbufs && (buffers & PIPE_CLEAR_COLOR0)) {
surf->reload = false;
}
- struct lima_submit_clear *clear = &submit->clear;
+ struct lima_job_clear *clear = &job->clear;
clear->buffers = buffers;
if (buffers & PIPE_CLEAR_COLOR0) {
ctx->dirty |= LIMA_CONTEXT_DIRTY_CLEAR;
- lima_damage_rect_union(&submit->damage_rect,
+ lima_damage_rect_union(&job->damage_rect,
0, ctx->framebuffer.base.width,
0, ctx->framebuffer.base.height);
}
static void
lima_pack_vs_cmd(struct lima_context *ctx, const struct pipe_draw_info *info)
{
- struct lima_submit *submit = lima_submit_get(ctx);
+ struct lima_job *job = lima_job_get(ctx);
- VS_CMD_BEGIN(&submit->vs_cmd_array, 24);
+ VS_CMD_BEGIN(&job->vs_cmd_array, 24);
if (!info->index_size) {
VS_CMD_ARRAYS_SEMAPHORE_BEGIN_1();
if (lima_is_scissor_zero(ctx))
return;
- struct lima_submit *submit = lima_submit_get(ctx);
- PLBU_CMD_BEGIN(&submit->plbu_cmd_array, 32);
+ struct lima_job *job = lima_job_get(ctx);
+ PLBU_CMD_BEGIN(&job->plbu_cmd_array, 32);
PLBU_CMD_VIEWPORT_LEFT(fui(ctx->viewport.left));
PLBU_CMD_VIEWPORT_RIGHT(fui(ctx->viewport.right));
maxy = MIN2(maxy, ctx->viewport.top);
PLBU_CMD_SCISSORS(minx, maxx, miny, maxy);
- lima_damage_rect_union(&submit->damage_rect, minx, maxx, miny, maxy);
+ lima_damage_rect_union(&job->damage_rect, minx, maxx, miny, maxy);
PLBU_CMD_UNKNOWN1();
render->varyings_address = 0x00000000;
}
- struct lima_submit *submit = lima_submit_get(ctx);
+ struct lima_job *job = lima_job_get(ctx);
lima_dump_command_stream_print(
- submit->dump, render, sizeof(*render),
+ job->dump, render, sizeof(*render),
false, "add render state at va %x\n",
lima_ctx_buff_va(ctx, lima_ctx_buff_pp_plb_rsw));
lima_dump_rsw_command_stream_print(
- submit->dump, render, sizeof(*render),
+ job->dump, render, sizeof(*render),
lima_ctx_buff_va(ctx, lima_ctx_buff_pp_plb_rsw));
}
static void
lima_update_gp_attribute_info(struct lima_context *ctx, const struct pipe_draw_info *info)
{
- struct lima_submit *submit = lima_submit_get(ctx);
+ struct lima_job *job = lima_job_get(ctx);
struct lima_vertex_element_state *ve = ctx->vertex_elements;
struct lima_context_vertex_buffer *vb = &ctx->vertex_buffers;
struct pipe_vertex_buffer *pvb = vb->vb + pve->vertex_buffer_index;
struct lima_resource *res = lima_resource(pvb->buffer.resource);
- lima_submit_add_bo(submit, LIMA_PIPE_GP, res->bo, LIMA_SUBMIT_BO_READ);
+ lima_job_add_bo(job, LIMA_PIPE_GP, res->bo, LIMA_SUBMIT_BO_READ);
unsigned start = info->index_size ? (ctx->min_index + info->index_bias) : info->start;
attribute[n++] = res->bo->va + pvb->buffer_offset + pve->src_offset
}
lima_dump_command_stream_print(
- submit->dump, attribute, n * 4, false, "update attribute info at va %x\n",
+ job->dump, attribute, n * 4, false, "update attribute info at va %x\n",
lima_ctx_buff_va(ctx, lima_ctx_buff_gp_attribute_info));
}
memcpy(vs_const_buff + vs->uniform_pending_offset + 32,
vs->constant, vs->constant_size);
- struct lima_submit *submit = lima_submit_get(ctx);
+ struct lima_job *job = lima_job_get(ctx);
lima_dump_command_stream_print(
- submit->dump, vs_const_buff, size, true,
+ job->dump, vs_const_buff, size, true,
"update gp uniform at va %x\n",
lima_ctx_buff_va(ctx, lima_ctx_buff_gp_uniform));
}
*array = lima_ctx_buff_va(ctx, lima_ctx_buff_pp_uniform);
- struct lima_submit *submit = lima_submit_get(ctx);
+ struct lima_job *job = lima_job_get(ctx);
lima_dump_command_stream_print(
- submit->dump, fp16_const_buff, const_buff_size * 2,
+ job->dump, fp16_const_buff, const_buff_size * 2,
false, "add pp uniform data at va %x\n",
lima_ctx_buff_va(ctx, lima_ctx_buff_pp_uniform));
lima_dump_command_stream_print(
- submit->dump, array, 4, false, "add pp uniform info at va %x\n",
+ job->dump, array, 4, false, "add pp uniform info at va %x\n",
lima_ctx_buff_va(ctx, lima_ctx_buff_pp_uniform_array));
}
static void
lima_update_varying(struct lima_context *ctx, const struct pipe_draw_info *info)
{
- struct lima_submit *submit = lima_submit_get(ctx);
+ struct lima_job *job = lima_job_get(ctx);
struct lima_screen *screen = lima_screen(ctx->base.screen);
struct lima_vs_shader_state *vs = ctx->vs;
uint32_t gp_output_size;
*/
ctx->gp_output = lima_bo_create(screen, gp_output_size, 0);
assert(ctx->gp_output);
- lima_submit_add_bo(submit, LIMA_PIPE_GP, ctx->gp_output, LIMA_SUBMIT_BO_WRITE);
- lima_submit_add_bo(submit, LIMA_PIPE_PP, ctx->gp_output, LIMA_SUBMIT_BO_READ);
+ lima_job_add_bo(job, LIMA_PIPE_GP, ctx->gp_output, LIMA_SUBMIT_BO_WRITE);
+ lima_job_add_bo(job, LIMA_PIPE_PP, ctx->gp_output, LIMA_SUBMIT_BO_READ);
for (int i = 0; i < vs->num_outputs; i++) {
struct lima_varying_info *v = vs->varying + i;
}
lima_dump_command_stream_print(
- submit->dump, varying, n * 4, false, "update varying info at va %x\n",
+ job->dump, varying, n * 4, false, "update varying info at va %x\n",
lima_ctx_buff_va(ctx, lima_ctx_buff_gp_varying_info));
}
if (fb->base.nr_cbufs)
buffers |= PIPE_CLEAR_COLOR0;
- lima_update_submit_wb(ctx, buffers);
+ lima_update_job_wb(ctx, buffers);
lima_update_gp_attribute_info(ctx, info);
lima_pack_plbu_cmd(ctx, info);
if (ctx->gp_output) {
- lima_bo_unreference(ctx->gp_output); /* held by submit */
+ lima_bo_unreference(ctx->gp_output); /* held by job */
ctx->gp_output = NULL;
}
const struct pipe_draw_info *info)
{
struct lima_context *ctx = lima_context(pctx);
- struct lima_submit *submit = lima_submit_get(ctx);
+ struct lima_job *job = lima_job_get(ctx);
struct pipe_resource *indexbuf = NULL;
/* Mali Utgard GPU always need min/max index info for index draw,
ctx->index_offset = 0;
}
- lima_submit_add_bo(submit, LIMA_PIPE_GP, ctx->index_res->bo, LIMA_SUBMIT_BO_READ);
- lima_submit_add_bo(submit, LIMA_PIPE_PP, ctx->index_res->bo, LIMA_SUBMIT_BO_READ);
+ lima_job_add_bo(job, LIMA_PIPE_GP, ctx->index_res->bo, LIMA_SUBMIT_BO_READ);
+ lima_job_add_bo(job, LIMA_PIPE_PP, ctx->index_res->bo, LIMA_SUBMIT_BO_READ);
lima_draw_vbo_update(pctx, info);
if (indexbuf)
if (!lima_update_vs_state(ctx) || !lima_update_fs_state(ctx))
return;
- struct lima_submit *submit = lima_submit_get(ctx);
+ struct lima_job *job = lima_job_get(ctx);
lima_dump_command_stream_print(
- submit->dump, ctx->vs->bo->map, ctx->vs->shader_size, false,
+ job->dump, ctx->vs->bo->map, ctx->vs->shader_size, false,
"add vs at va %x\n", ctx->vs->bo->va);
lima_dump_command_stream_print(
- submit->dump, ctx->fs->bo->map, ctx->fs->shader_size, false,
+ job->dump, ctx->fs->bo->map, ctx->fs->shader_size, false,
"add fs at va %x\n", ctx->fs->bo->va);
- lima_submit_add_bo(submit, LIMA_PIPE_GP, ctx->vs->bo, LIMA_SUBMIT_BO_READ);
- lima_submit_add_bo(submit, LIMA_PIPE_PP, ctx->fs->bo, LIMA_SUBMIT_BO_READ);
+ lima_job_add_bo(job, LIMA_PIPE_GP, ctx->vs->bo, LIMA_SUBMIT_BO_READ);
+ lima_job_add_bo(job, LIMA_PIPE_PP, ctx->fs->bo, LIMA_SUBMIT_BO_READ);
if (info->index_size)
lima_draw_vbo_indexed(pctx, info);
#include "lima_screen.h"
#include "lima_context.h"
#include "lima_fence.h"
-#include "lima_submit.h"
+#include "lima_job.h"
struct pipe_fence_handle {
struct pipe_reference reference;
--- /dev/null
+/*
+ * Copyright (C) 2017-2019 Lima Project
+ *
+ * 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 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 COPYRIGHT HOLDER(S) OR AUTHOR(S) 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 <stdlib.h>
+#include <string.h>
+
+#include "xf86drm.h"
+#include "drm-uapi/lima_drm.h"
+
+#include "util/u_math.h"
+#include "util/ralloc.h"
+#include "util/os_time.h"
+#include "util/hash_table.h"
+#include "util/u_upload_mgr.h"
+#include "util/u_inlines.h"
+
+#include "lima_screen.h"
+#include "lima_context.h"
+#include "lima_job.h"
+#include "lima_bo.h"
+#include "lima_util.h"
+#include "lima_format.h"
+#include "lima_resource.h"
+#include "lima_texture.h"
+#include "lima_fence.h"
+#include "lima_gpu.h"
+
+#define VOID2U64(x) ((uint64_t)(unsigned long)(x))
+
+static void
+lima_get_fb_info(struct lima_job *job)
+{
+ struct lima_context *ctx = job->ctx;
+ struct lima_job_fb_info *fb = &job->fb;
+
+ fb->width = ctx->framebuffer.base.width;
+ fb->height = ctx->framebuffer.base.height;
+
+ int width = align(fb->width, 16) >> 4;
+ int height = align(fb->height, 16) >> 4;
+
+ struct lima_screen *screen = lima_screen(ctx->base.screen);
+
+ fb->tiled_w = width;
+ fb->tiled_h = height;
+
+ fb->shift_h = 0;
+ fb->shift_w = 0;
+
+ int limit = screen->plb_max_blk;
+ while ((width * height) > limit) {
+ if (width >= height) {
+ width = (width + 1) >> 1;
+ fb->shift_w++;
+ } else {
+ height = (height + 1) >> 1;
+ fb->shift_h++;
+ }
+ }
+
+ fb->block_w = width;
+ fb->block_h = height;
+
+ fb->shift_min = MIN3(fb->shift_w, fb->shift_h, 2);
+}
+
+static struct lima_job *
+lima_job_create(struct lima_context *ctx)
+{
+ struct lima_job *s;
+
+ s = rzalloc(ctx, struct lima_job);
+ if (!s)
+ return NULL;
+
+ s->fd = lima_screen(ctx->base.screen)->fd;
+ s->ctx = ctx;
+
+ s->damage_rect.minx = s->damage_rect.miny = 0xffff;
+ s->damage_rect.maxx = s->damage_rect.maxy = 0;
+
+ for (int i = 0; i < 2; i++) {
+ util_dynarray_init(s->gem_bos + i, s);
+ util_dynarray_init(s->bos + i, s);
+ }
+
+ util_dynarray_init(&s->vs_cmd_array, s);
+ util_dynarray_init(&s->plbu_cmd_array, s);
+ util_dynarray_init(&s->plbu_cmd_head, s);
+
+ struct lima_context_framebuffer *fb = &ctx->framebuffer;
+ pipe_surface_reference(&s->key.cbuf, fb->base.cbufs[0]);
+ pipe_surface_reference(&s->key.zsbuf, fb->base.zsbuf);
+
+ lima_get_fb_info(s);
+
+ s->dump = lima_dump_create();
+
+ return s;
+}
+
+static void
+lima_job_free(struct lima_job *job)
+{
+ struct lima_context *ctx = job->ctx;
+
+ _mesa_hash_table_remove_key(ctx->jobs, &job->key);
+
+ if (job->key.cbuf && (job->resolve & PIPE_CLEAR_COLOR0))
+ _mesa_hash_table_remove_key(ctx->write_jobs, job->key.cbuf->texture);
+ if (job->key.zsbuf && (job->resolve & (PIPE_CLEAR_DEPTH | PIPE_CLEAR_STENCIL)))
+ _mesa_hash_table_remove_key(ctx->write_jobs, job->key.zsbuf->texture);
+
+ pipe_surface_reference(&job->key.cbuf, NULL);
+ pipe_surface_reference(&job->key.zsbuf, NULL);
+
+ lima_dump_free(job->dump);
+ job->dump = NULL;
+
+ /* TODO: do we need a cache for job? */
+ ralloc_free(job);
+}
+
+static struct lima_job *
+_lima_job_get(struct lima_context *ctx)
+{
+ struct lima_context_framebuffer *fb = &ctx->framebuffer;
+ struct lima_job_key local_key = {
+ .cbuf = fb->base.cbufs[0],
+ .zsbuf = fb->base.zsbuf,
+ };
+
+ struct hash_entry *entry = _mesa_hash_table_search(ctx->jobs, &local_key);
+ if (entry)
+ return entry->data;
+
+ struct lima_job *job = lima_job_create(ctx);
+ if (!job)
+ return NULL;
+
+ _mesa_hash_table_insert(ctx->jobs, &job->key, job);
+
+ return job;
+}
+
+/*
+ * Note: this function can only be called in draw code path,
+ * must not exist in flush code path.
+ */
+struct lima_job *
+lima_job_get(struct lima_context *ctx)
+{
+ if (ctx->job)
+ return ctx->job;
+
+ ctx->job = _lima_job_get(ctx);
+ return ctx->job;
+}
+
+bool lima_job_add_bo(struct lima_job *job, int pipe,
+ struct lima_bo *bo, uint32_t flags)
+{
+ util_dynarray_foreach(job->gem_bos + pipe, struct drm_lima_gem_submit_bo, gem_bo) {
+ if (bo->handle == gem_bo->handle) {
+ gem_bo->flags |= flags;
+ return true;
+ }
+ }
+
+ struct drm_lima_gem_submit_bo *job_bo =
+ util_dynarray_grow(job->gem_bos + pipe, struct drm_lima_gem_submit_bo, 1);
+ job_bo->handle = bo->handle;
+ job_bo->flags = flags;
+
+ struct lima_bo **jbo = util_dynarray_grow(job->bos + pipe, struct lima_bo *, 1);
+ *jbo = bo;
+
+ /* prevent bo from being freed when job start */
+ lima_bo_reference(bo);
+
+ return true;
+}
+
+static bool
+lima_job_start(struct lima_job *job, int pipe, void *frame, uint32_t size)
+{
+ struct lima_context *ctx = job->ctx;
+ struct drm_lima_gem_submit req = {
+ .ctx = ctx->id,
+ .pipe = pipe,
+ .nr_bos = job->gem_bos[pipe].size / sizeof(struct drm_lima_gem_submit_bo),
+ .bos = VOID2U64(util_dynarray_begin(job->gem_bos + pipe)),
+ .frame = VOID2U64(frame),
+ .frame_size = size,
+ .out_sync = ctx->out_sync[pipe],
+ };
+
+ if (ctx->in_sync_fd >= 0) {
+ int err = drmSyncobjImportSyncFile(job->fd, ctx->in_sync[pipe],
+ ctx->in_sync_fd);
+ if (err)
+ return false;
+
+ req.in_sync[0] = ctx->in_sync[pipe];
+ close(ctx->in_sync_fd);
+ ctx->in_sync_fd = -1;
+ }
+
+ bool ret = drmIoctl(job->fd, DRM_IOCTL_LIMA_GEM_SUBMIT, &req) == 0;
+
+ util_dynarray_foreach(job->bos + pipe, struct lima_bo *, bo) {
+ lima_bo_unreference(*bo);
+ }
+
+ return ret;
+}
+
+static bool
+lima_job_wait(struct lima_job *job, int pipe, uint64_t timeout_ns)
+{
+ int64_t abs_timeout = os_time_get_absolute_timeout(timeout_ns);
+ if (abs_timeout == OS_TIMEOUT_INFINITE)
+ abs_timeout = INT64_MAX;
+
+ struct lima_context *ctx = job->ctx;
+ return !drmSyncobjWait(job->fd, ctx->out_sync + pipe, 1, abs_timeout, 0, NULL);
+}
+
+static bool
+lima_job_has_bo(struct lima_job *job, struct lima_bo *bo, bool all)
+{
+ for (int i = 0; i < 2; i++) {
+ util_dynarray_foreach(job->gem_bos + i, struct drm_lima_gem_submit_bo, gem_bo) {
+ if (bo->handle == gem_bo->handle) {
+ if (all || gem_bo->flags & LIMA_SUBMIT_BO_WRITE)
+ return true;
+ else
+ break;
+ }
+ }
+ }
+
+ return false;
+}
+
+void *
+lima_job_create_stream_bo(struct lima_job *job, int pipe,
+ unsigned size, uint32_t *va)
+{
+ struct lima_context *ctx = job->ctx;
+
+ void *cpu;
+ unsigned offset;
+ struct pipe_resource *pres = NULL;
+ u_upload_alloc(ctx->uploader, 0, size, 0x40, &offset, &pres, &cpu);
+
+ struct lima_resource *res = lima_resource(pres);
+ *va = res->bo->va + offset;
+
+ lima_job_add_bo(job, pipe, res->bo, LIMA_SUBMIT_BO_READ);
+
+ pipe_resource_reference(&pres, NULL);
+
+ return cpu;
+}
+
+static inline struct lima_damage_region *
+lima_job_get_damage(struct lima_job *job)
+{
+ if (!(job->key.cbuf && (job->resolve & PIPE_CLEAR_COLOR0)))
+ return NULL;
+
+ struct lima_surface *surf = lima_surface(job->key.cbuf);
+ struct lima_resource *res = lima_resource(surf->base.texture);
+ return &res->damage;
+}
+
+static bool
+lima_fb_need_reload(struct lima_job *job)
+{
+ /* Depth buffer is always discarded */
+ if (!(job->key.cbuf && (job->resolve & PIPE_CLEAR_COLOR0)))
+ return false;
+
+ struct lima_surface *surf = lima_surface(job->key.cbuf);
+ struct lima_resource *res = lima_resource(surf->base.texture);
+ if (res->damage.region) {
+ /* for EGL_KHR_partial_update, when EGL_EXT_buffer_age is enabled,
+ * we need to reload damage region, otherwise just want to reload
+ * the region not aligned to tile boundary */
+ //if (!res->damage.aligned)
+ // return true;
+ return true;
+ }
+ else if (surf->reload)
+ return true;
+
+ return false;
+}
+
+static void
+lima_pack_reload_plbu_cmd(struct lima_job *job)
+{
+ #define lima_reload_render_state_offset 0x0000
+ #define lima_reload_gl_pos_offset 0x0040
+ #define lima_reload_varying_offset 0x0080
+ #define lima_reload_tex_desc_offset 0x00c0
+ #define lima_reload_tex_array_offset 0x0100
+ #define lima_reload_buffer_size 0x0140
+
+ struct lima_context *ctx = job->ctx;
+
+ uint32_t va;
+ void *cpu = lima_job_create_stream_bo(
+ job, LIMA_PIPE_PP, lima_reload_buffer_size, &va);
+
+ struct lima_screen *screen = lima_screen(ctx->base.screen);
+
+ uint32_t reload_shader_first_instr_size =
+ ((uint32_t *)(screen->pp_buffer->map + pp_reload_program_offset))[0] & 0x1f;
+ uint32_t reload_shader_va = screen->pp_buffer->va + pp_reload_program_offset;
+
+ struct lima_render_state reload_render_state = {
+ .alpha_blend = 0xf03b1ad2,
+ .depth_test = 0x0000000e,
+ .depth_range = 0xffff0000,
+ .stencil_front = 0x00000007,
+ .stencil_back = 0x00000007,
+ .multi_sample = 0x0000f007,
+ .shader_address = reload_shader_va | reload_shader_first_instr_size,
+ .varying_types = 0x00000001,
+ .textures_address = va + lima_reload_tex_array_offset,
+ .aux0 = 0x00004021,
+ .varyings_address = va + lima_reload_varying_offset,
+ };
+ memcpy(cpu + lima_reload_render_state_offset, &reload_render_state,
+ sizeof(reload_render_state));
+
+ lima_tex_desc *td = cpu + lima_reload_tex_desc_offset;
+ memset(td, 0, lima_min_tex_desc_size);
+ lima_texture_desc_set_res(ctx, td, job->key.cbuf->texture, 0, 0);
+ td->unnorm_coords = 1;
+ td->texture_type = LIMA_TEXTURE_TYPE_2D;
+ td->min_img_filter_nearest = 1;
+ td->mag_img_filter_nearest = 1;
+ td->wrap_s_clamp_to_edge = 1;
+ td->wrap_t_clamp_to_edge = 1;
+ td->unknown_2_2 = 0x1;
+
+ uint32_t *ta = cpu + lima_reload_tex_array_offset;
+ ta[0] = va + lima_reload_tex_desc_offset;
+
+ struct lima_job_fb_info *fb = &job->fb;
+ float reload_gl_pos[] = {
+ fb->width, 0, 0, 1,
+ 0, 0, 0, 1,
+ 0, fb->height, 0, 1,
+ };
+ memcpy(cpu + lima_reload_gl_pos_offset, reload_gl_pos,
+ sizeof(reload_gl_pos));
+
+ float reload_varying[] = {
+ fb->width, 0, 0, 0,
+ 0, fb->height, 0, 0,
+ };
+ memcpy(cpu + lima_reload_varying_offset, reload_varying,
+ sizeof(reload_varying));
+
+ PLBU_CMD_BEGIN(&job->plbu_cmd_head, 20);
+
+ PLBU_CMD_VIEWPORT_LEFT(0);
+ PLBU_CMD_VIEWPORT_RIGHT(fui(fb->width));
+ PLBU_CMD_VIEWPORT_BOTTOM(0);
+ PLBU_CMD_VIEWPORT_TOP(fui(fb->height));
+
+ PLBU_CMD_RSW_VERTEX_ARRAY(
+ va + lima_reload_render_state_offset,
+ va + lima_reload_gl_pos_offset);
+
+ PLBU_CMD_UNKNOWN2();
+ PLBU_CMD_UNKNOWN1();
+
+ PLBU_CMD_INDICES(screen->pp_buffer->va + pp_shared_index_offset);
+ PLBU_CMD_INDEXED_DEST(va + lima_reload_gl_pos_offset);
+ PLBU_CMD_DRAW_ELEMENTS(0xf, 0, 3);
+
+ PLBU_CMD_END();
+}
+
+static void
+lima_pack_head_plbu_cmd(struct lima_job *job)
+{
+ struct lima_context *ctx = job->ctx;
+ struct lima_job_fb_info *fb = &job->fb;
+
+ PLBU_CMD_BEGIN(&job->plbu_cmd_head, 10);
+
+ PLBU_CMD_UNKNOWN2();
+ PLBU_CMD_BLOCK_STEP(fb->shift_min, fb->shift_h, fb->shift_w);
+ PLBU_CMD_TILED_DIMENSIONS(fb->tiled_w, fb->tiled_h);
+ PLBU_CMD_BLOCK_STRIDE(fb->block_w);
+
+ PLBU_CMD_ARRAY_ADDRESS(
+ ctx->plb_gp_stream->va + ctx->plb_index * ctx->plb_gp_size,
+ fb->block_w * fb->block_h);
+
+ PLBU_CMD_END();
+
+ if (lima_fb_need_reload(job))
+ lima_pack_reload_plbu_cmd(job);
+}
+
+static void
+hilbert_rotate(int n, int *x, int *y, int rx, int ry)
+{
+ if (ry == 0) {
+ if (rx == 1) {
+ *x = n-1 - *x;
+ *y = n-1 - *y;
+ }
+
+ /* Swap x and y */
+ int t = *x;
+ *x = *y;
+ *y = t;
+ }
+}
+
+static void
+hilbert_coords(int n, int d, int *x, int *y)
+{
+ int rx, ry, i, t=d;
+
+ *x = *y = 0;
+
+ for (i = 0; (1 << i) < n; i++) {
+
+ rx = 1 & (t / 2);
+ ry = 1 & (t ^ rx);
+
+ hilbert_rotate(1 << i, x, y, rx, ry);
+
+ *x += rx << i;
+ *y += ry << i;
+
+ t /= 4;
+ }
+}
+
+static int
+lima_get_pp_stream_size(int num_pp, int tiled_w, int tiled_h, uint32_t *off)
+{
+ /* carefully calculate each stream start address:
+ * 1. overflow: each stream size may be different due to
+ * fb->tiled_w * fb->tiled_h can't be divided by num_pp,
+ * extra size should be added to the preceeding stream
+ * 2. alignment: each stream address should be 0x20 aligned
+ */
+ int delta = tiled_w * tiled_h / num_pp * 16 + 16;
+ int remain = tiled_w * tiled_h % num_pp;
+ int offset = 0;
+
+ for (int i = 0; i < num_pp; i++) {
+ off[i] = offset;
+
+ offset += delta;
+ if (remain) {
+ offset += 16;
+ remain--;
+ }
+ offset = align(offset, 0x20);
+ }
+
+ return offset;
+}
+
+static bool
+inside_damage_region(int x, int y, struct lima_damage_region *ds)
+{
+ if (!ds || !ds->region)
+ return true;
+
+ for (int i = 0; i < ds->num_region; i++) {
+ struct pipe_scissor_state *ss = ds->region + i;
+ if (x >= ss->minx && x < ss->maxx &&
+ y >= ss->miny && y < ss->maxy)
+ return true;
+ }
+
+ return false;
+}
+
+static void
+lima_generate_pp_stream(struct lima_job *job, int off_x, int off_y,
+ int tiled_w, int tiled_h)
+{
+ struct lima_context *ctx = job->ctx;
+ struct lima_pp_stream_state *ps = &ctx->pp_stream;
+ struct lima_job_fb_info *fb = &job->fb;
+ struct lima_damage_region *damage = lima_job_get_damage(job);
+ struct lima_screen *screen = lima_screen(ctx->base.screen);
+ int i, num_pp = screen->num_pp;
+
+ /* use hilbert_coords to generates 1D to 2D relationship.
+ * 1D for pp stream index and 2D for plb block x/y on framebuffer.
+ * if multi pp, interleave the 1D index to make each pp's render target
+ * close enough which should result close workload
+ */
+ int max = MAX2(tiled_w, tiled_h);
+ int index = 0;
+ uint32_t *stream[4];
+ int si[4] = {0};
+ int dim = 0;
+ int count = 0;
+
+ /* Don't update count if we get zero rect. We'll just generate
+ * PP stream with just terminators in it.
+ */
+ if ((tiled_w * tiled_h) != 0) {
+ dim = util_logbase2_ceil(max);
+ count = 1 << (dim + dim);
+ }
+
+ for (i = 0; i < num_pp; i++)
+ stream[i] = ps->map + ps->offset[i];
+
+ for (i = 0; i < count; i++) {
+ int x, y;
+ hilbert_coords(max, i, &x, &y);
+ if (x < tiled_w && y < tiled_h) {
+ x += off_x;
+ y += off_y;
+
+ if (!inside_damage_region(x, y, damage))
+ continue;
+
+ int pp = index % num_pp;
+ int offset = ((y >> fb->shift_h) * fb->block_w +
+ (x >> fb->shift_w)) * LIMA_CTX_PLB_BLK_SIZE;
+ int plb_va = ctx->plb[ctx->plb_index]->va + offset;
+
+ stream[pp][si[pp]++] = 0;
+ stream[pp][si[pp]++] = 0xB8000000 | x | (y << 8);
+ stream[pp][si[pp]++] = 0xE0000002 | ((plb_va >> 3) & ~0xE0000003);
+ stream[pp][si[pp]++] = 0xB0000000;
+
+ index++;
+ }
+ }
+
+ for (i = 0; i < num_pp; i++) {
+ stream[i][si[i]++] = 0;
+ stream[i][si[i]++] = 0xBC000000;
+ stream[i][si[i]++] = 0;
+ stream[i][si[i]++] = 0;
+
+ lima_dump_command_stream_print(
+ job->dump, stream[i], si[i] * 4,
+ false, "pp plb stream %d at va %x\n",
+ i, ps->va + ps->offset[i]);
+ }
+}
+
+static void
+lima_update_damage_pp_stream(struct lima_job *job)
+{
+ struct lima_context *ctx = job->ctx;
+ struct lima_damage_region *ds = lima_job_get_damage(job);
+ struct lima_job_fb_info *fb = &job->fb;
+ struct pipe_scissor_state bound;
+ struct pipe_scissor_state *dr = &job->damage_rect;
+
+ if (ds && ds->region) {
+ struct pipe_scissor_state *dbound = &ds->bound;
+ bound.minx = MAX2(dbound->minx, dr->minx >> 4);
+ bound.miny = MAX2(dbound->miny, dr->miny >> 4);
+ bound.maxx = MIN2(dbound->maxx, (dr->maxx + 0xf) >> 4);
+ bound.maxy = MIN2(dbound->maxy, (dr->maxy + 0xf) >> 4);
+ } else {
+ bound.minx = dr->minx >> 4;
+ bound.miny = dr->miny >> 4;
+ bound.maxx = (dr->maxx + 0xf) >> 4;
+ bound.maxy = (dr->maxy + 0xf) >> 4;
+ }
+
+ /* Clamp to FB size */
+ bound.minx = MIN2(bound.minx, fb->tiled_w);
+ bound.miny = MIN2(bound.miny, fb->tiled_h);
+ bound.maxx = MIN2(bound.maxx, fb->tiled_w);
+ bound.maxy = MIN2(bound.maxy, fb->tiled_h);
+
+ int tiled_w = bound.maxx - bound.minx;
+ int tiled_h = bound.maxy - bound.miny;
+
+ struct lima_screen *screen = lima_screen(ctx->base.screen);
+ int size = lima_get_pp_stream_size(
+ screen->num_pp, tiled_w, tiled_h, ctx->pp_stream.offset);
+
+ ctx->pp_stream.map = lima_job_create_stream_bo(
+ job, LIMA_PIPE_PP, size, &ctx->pp_stream.va);
+
+ lima_generate_pp_stream(job, bound.minx, bound.miny, tiled_w, tiled_h);
+}
+
+static void
+lima_update_full_pp_stream(struct lima_job *job)
+{
+ struct lima_context *ctx = job->ctx;
+ struct lima_job_fb_info *fb = &job->fb;
+ struct lima_ctx_plb_pp_stream_key key = {
+ .plb_index = ctx->plb_index,
+ .tiled_w = fb->tiled_w,
+ .tiled_h = fb->tiled_h,
+ };
+
+ struct hash_entry *entry =
+ _mesa_hash_table_search(ctx->plb_pp_stream, &key);
+ struct lima_ctx_plb_pp_stream *s = entry->data;
+
+ if (s->bo) {
+ ctx->pp_stream.map = lima_bo_map(s->bo);
+ ctx->pp_stream.va = s->bo->va;
+ memcpy(ctx->pp_stream.offset, s->offset, sizeof(s->offset));
+ }
+ else {
+ struct lima_screen *screen = lima_screen(ctx->base.screen);
+ int size = lima_get_pp_stream_size(
+ screen->num_pp, fb->tiled_w, fb->tiled_h, s->offset);
+ s->bo = lima_bo_create(screen, size, 0);
+
+ ctx->pp_stream.map = lima_bo_map(s->bo);
+ ctx->pp_stream.va = s->bo->va;
+ memcpy(ctx->pp_stream.offset, s->offset, sizeof(s->offset));
+
+ lima_generate_pp_stream(job, 0, 0, fb->tiled_w, fb->tiled_h);
+ }
+
+ lima_job_add_bo(job, LIMA_PIPE_PP, s->bo, LIMA_SUBMIT_BO_READ);
+}
+
+static bool
+lima_damage_fullscreen(struct lima_job *job)
+{
+ struct pipe_scissor_state *dr = &job->damage_rect;
+
+ return dr->minx == 0 &&
+ dr->miny == 0 &&
+ dr->maxx == job->fb.width &&
+ dr->maxy == job->fb.height;
+}
+
+static void
+lima_update_pp_stream(struct lima_job *job)
+{
+ struct lima_context *ctx = job->ctx;
+ struct lima_damage_region *damage = lima_job_get_damage(job);
+ if ((damage && damage->region) || !lima_damage_fullscreen(job))
+ lima_update_damage_pp_stream(job);
+ else if (ctx->plb_pp_stream)
+ lima_update_full_pp_stream(job);
+ else
+ ctx->pp_stream.map = NULL;
+}
+
+static void
+lima_update_job_bo(struct lima_job *job)
+{
+ struct lima_context *ctx = job->ctx;
+
+ lima_job_add_bo(job, LIMA_PIPE_GP, ctx->plb_gp_stream,
+ LIMA_SUBMIT_BO_READ);
+ lima_job_add_bo(job, LIMA_PIPE_GP, ctx->plb[ctx->plb_index],
+ LIMA_SUBMIT_BO_WRITE);
+ lima_job_add_bo(job, LIMA_PIPE_GP, ctx->gp_tile_heap[ctx->plb_index],
+ LIMA_SUBMIT_BO_WRITE);
+
+ lima_dump_command_stream_print(
+ job->dump, ctx->plb_gp_stream->map + ctx->plb_index * ctx->plb_gp_size,
+ ctx->plb_gp_size, false, "gp plb stream at va %x\n",
+ ctx->plb_gp_stream->va + ctx->plb_index * ctx->plb_gp_size);
+
+ lima_job_add_bo(job, LIMA_PIPE_PP, ctx->plb[ctx->plb_index],
+ LIMA_SUBMIT_BO_READ);
+ lima_job_add_bo(job, LIMA_PIPE_PP, ctx->gp_tile_heap[ctx->plb_index],
+ LIMA_SUBMIT_BO_READ);
+
+ struct lima_screen *screen = lima_screen(ctx->base.screen);
+ lima_job_add_bo(job, LIMA_PIPE_PP, screen->pp_buffer, LIMA_SUBMIT_BO_READ);
+}
+
+static void
+lima_finish_plbu_cmd(struct util_dynarray *plbu_cmd_array)
+{
+ int i = 0;
+ uint32_t *plbu_cmd = util_dynarray_ensure_cap(plbu_cmd_array, plbu_cmd_array->size + 2 * 4);
+
+ plbu_cmd[i++] = 0x00000000;
+ plbu_cmd[i++] = 0x50000000; /* END */
+
+ plbu_cmd_array->size += i * 4;
+}
+
+static void
+lima_pack_wb_zsbuf_reg(struct lima_job *job, uint32_t *wb_reg, int wb_idx)
+{
+ struct lima_job_fb_info *fb = &job->fb;
+ struct pipe_surface *zsbuf = job->key.zsbuf;
+ struct lima_resource *res = lima_resource(zsbuf->texture);
+ int level = zsbuf->u.tex.level;
+ uint32_t format = lima_format_get_pixel(zsbuf->format);
+
+ struct lima_pp_wb_reg *wb = (void *)wb_reg;
+ wb[wb_idx].type = 0x01; /* 1 for depth, stencil */
+ wb[wb_idx].address = res->bo->va + res->levels[level].offset;
+ wb[wb_idx].pixel_format = format;
+ if (res->tiled) {
+ wb[wb_idx].pixel_layout = 0x2;
+ wb[wb_idx].pitch = fb->tiled_w;
+ } else {
+ wb[wb_idx].pixel_layout = 0x0;
+ wb[wb_idx].pitch = res->levels[level].stride / 8;
+ }
+ wb[wb_idx].mrt_bits = 0;
+}
+
+static void
+lima_pack_wb_cbuf_reg(struct lima_job *job, uint32_t *wb_reg, int wb_idx)
+{
+ struct lima_job_fb_info *fb = &job->fb;
+ struct pipe_surface *cbuf = job->key.cbuf;
+ struct lima_resource *res = lima_resource(cbuf->texture);
+ int level = cbuf->u.tex.level;
+ unsigned layer = cbuf->u.tex.first_layer;
+ uint32_t format = lima_format_get_pixel(cbuf->format);
+ bool swap_channels = lima_format_get_swap_rb(cbuf->format);
+
+ struct lima_pp_wb_reg *wb = (void *)wb_reg;
+ wb[wb_idx].type = 0x02; /* 2 for color buffer */
+ wb[wb_idx].address = res->bo->va + res->levels[level].offset + layer * res->levels[level].layer_stride;
+ wb[wb_idx].pixel_format = format;
+ if (res->tiled) {
+ wb[wb_idx].pixel_layout = 0x2;
+ wb[wb_idx].pitch = fb->tiled_w;
+ } else {
+ wb[wb_idx].pixel_layout = 0x0;
+ wb[wb_idx].pitch = res->levels[level].stride / 8;
+ }
+ wb[wb_idx].mrt_bits = swap_channels ? 0x4 : 0x0;
+}
+
+static void
+lima_pack_pp_frame_reg(struct lima_job *job, uint32_t *frame_reg,
+ uint32_t *wb_reg)
+{
+ struct lima_context *ctx = job->ctx;
+ struct lima_job_fb_info *fb = &job->fb;
+ struct lima_pp_frame_reg *frame = (void *)frame_reg;
+ struct lima_screen *screen = lima_screen(ctx->base.screen);
+ int wb_idx = 0;
+
+ frame->render_address = screen->pp_buffer->va + pp_frame_rsw_offset;
+ frame->flags = 0x02;
+ frame->clear_value_depth = job->clear.depth;
+ frame->clear_value_stencil = job->clear.stencil;
+ frame->clear_value_color = job->clear.color_8pc;
+ frame->clear_value_color_1 = job->clear.color_8pc;
+ frame->clear_value_color_2 = job->clear.color_8pc;
+ frame->clear_value_color_3 = job->clear.color_8pc;
+ frame->one = 1;
+
+ frame->width = fb->width - 1;
+ frame->height = fb->height - 1;
+
+ /* frame->fragment_stack_address is overwritten per-pp in the kernel
+ * by the values of pp_frame.fragment_stack_address[i] */
+
+ /* These are "stack size" and "stack offset" shifted,
+ * here they are assumed to be always the same. */
+ frame->fragment_stack_size = job->pp_max_stack_size << 16 | job->pp_max_stack_size;
+
+ /* related with MSAA and different value when r4p0/r7p0 */
+ frame->supersampled_height = fb->height * 2 - 1;
+ frame->scale = 0xE0C;
+
+ frame->dubya = 0x77;
+ frame->onscreen = 1;
+ frame->blocking = (fb->shift_min << 28) | (fb->shift_h << 16) | fb->shift_w;
+ frame->foureight = 0x8888;
+
+ if (job->key.cbuf && (job->resolve & PIPE_CLEAR_COLOR0))
+ lima_pack_wb_cbuf_reg(job, wb_reg, wb_idx++);
+
+ if (job->key.zsbuf &&
+ (job->resolve & (PIPE_CLEAR_DEPTH | PIPE_CLEAR_STENCIL)))
+ lima_pack_wb_zsbuf_reg(job, wb_reg, wb_idx++);
+}
+
+void
+lima_do_job(struct lima_job *job)
+{
+ #define pp_stack_pp_size 0x400
+
+ struct lima_context *ctx = job->ctx;
+
+ lima_pack_head_plbu_cmd(job);
+ lima_finish_plbu_cmd(&job->plbu_cmd_array);
+
+ lima_update_job_bo(job);
+
+ int vs_cmd_size = job->vs_cmd_array.size;
+ uint32_t vs_cmd_va = 0;
+
+ if (vs_cmd_size) {
+ void *vs_cmd = lima_job_create_stream_bo(
+ job, LIMA_PIPE_GP, vs_cmd_size, &vs_cmd_va);
+ memcpy(vs_cmd, util_dynarray_begin(&job->vs_cmd_array), vs_cmd_size);
+
+ lima_dump_command_stream_print(
+ job->dump, vs_cmd, vs_cmd_size, false, "flush vs cmd at va %x\n", vs_cmd_va);
+ lima_dump_vs_command_stream_print(job->dump, vs_cmd, vs_cmd_size, vs_cmd_va);
+ }
+
+ uint32_t plbu_cmd_va;
+ int plbu_cmd_size = job->plbu_cmd_array.size + job->plbu_cmd_head.size;
+ void *plbu_cmd = lima_job_create_stream_bo(
+ job, LIMA_PIPE_GP, plbu_cmd_size, &plbu_cmd_va);
+ memcpy(plbu_cmd,
+ util_dynarray_begin(&job->plbu_cmd_head),
+ job->plbu_cmd_head.size);
+ memcpy(plbu_cmd + job->plbu_cmd_head.size,
+ util_dynarray_begin(&job->plbu_cmd_array),
+ job->plbu_cmd_array.size);
+
+ lima_dump_command_stream_print(
+ job->dump, plbu_cmd, plbu_cmd_size, false, "flush plbu cmd at va %x\n", plbu_cmd_va);
+ lima_dump_plbu_command_stream_print(job->dump, plbu_cmd, plbu_cmd_size, plbu_cmd_va);
+
+ struct lima_screen *screen = lima_screen(ctx->base.screen);
+ struct drm_lima_gp_frame gp_frame;
+ struct lima_gp_frame_reg *gp_frame_reg = (void *)gp_frame.frame;
+ gp_frame_reg->vs_cmd_start = vs_cmd_va;
+ gp_frame_reg->vs_cmd_end = vs_cmd_va + vs_cmd_size;
+ gp_frame_reg->plbu_cmd_start = plbu_cmd_va;
+ gp_frame_reg->plbu_cmd_end = plbu_cmd_va + plbu_cmd_size;
+ gp_frame_reg->tile_heap_start = ctx->gp_tile_heap[ctx->plb_index]->va;
+ gp_frame_reg->tile_heap_end = ctx->gp_tile_heap[ctx->plb_index]->va + ctx->gp_tile_heap_size;
+
+ lima_dump_command_stream_print(
+ job->dump, &gp_frame, sizeof(gp_frame), false, "add gp frame\n");
+
+ if (!lima_job_start(job, LIMA_PIPE_GP, &gp_frame, sizeof(gp_frame)))
+ fprintf(stderr, "gp job error\n");
+
+ if (job->dump) {
+ if (lima_job_wait(job, LIMA_PIPE_GP, PIPE_TIMEOUT_INFINITE)) {
+ if (ctx->gp_output) {
+ float *pos = lima_bo_map(ctx->gp_output);
+ lima_dump_command_stream_print(
+ job->dump, pos, 4 * 4 * 16, true, "gl_pos dump at va %x\n",
+ ctx->gp_output->va);
+ }
+
+ uint32_t *plb = lima_bo_map(ctx->plb[ctx->plb_index]);
+ lima_dump_command_stream_print(
+ job->dump, plb, LIMA_CTX_PLB_BLK_SIZE, false, "plb dump at va %x\n",
+ ctx->plb[ctx->plb_index]->va);
+ }
+ else {
+ fprintf(stderr, "gp job wait error\n");
+ exit(1);
+ }
+ }
+
+ uint32_t pp_stack_va = 0;
+ if (job->pp_max_stack_size) {
+ lima_job_create_stream_bo(
+ job, LIMA_PIPE_PP,
+ screen->num_pp * job->pp_max_stack_size * pp_stack_pp_size,
+ &pp_stack_va);
+ }
+
+ lima_update_pp_stream(job);
+
+ struct lima_pp_stream_state *ps = &ctx->pp_stream;
+ if (screen->gpu_type == DRM_LIMA_PARAM_GPU_ID_MALI400) {
+ struct drm_lima_m400_pp_frame pp_frame = {0};
+ lima_pack_pp_frame_reg(job, pp_frame.frame, pp_frame.wb);
+ pp_frame.num_pp = screen->num_pp;
+
+ for (int i = 0; i < screen->num_pp; i++) {
+ pp_frame.plbu_array_address[i] = ps->va + ps->offset[i];
+ if (job->pp_max_stack_size)
+ pp_frame.fragment_stack_address[i] = pp_stack_va +
+ job->pp_max_stack_size * pp_stack_pp_size * i;
+ }
+
+ lima_dump_command_stream_print(
+ job->dump, &pp_frame, sizeof(pp_frame), false, "add pp frame\n");
+
+ if (!lima_job_start(job, LIMA_PIPE_PP, &pp_frame, sizeof(pp_frame)))
+ fprintf(stderr, "pp job error\n");
+ }
+ else {
+ struct drm_lima_m450_pp_frame pp_frame = {0};
+ lima_pack_pp_frame_reg(job, pp_frame.frame, pp_frame.wb);
+ pp_frame.num_pp = screen->num_pp;
+
+ if (job->pp_max_stack_size)
+ for (int i = 0; i < screen->num_pp; i++)
+ pp_frame.fragment_stack_address[i] = pp_stack_va +
+ job->pp_max_stack_size * pp_stack_pp_size * i;
+
+ if (ps->map) {
+ for (int i = 0; i < screen->num_pp; i++)
+ pp_frame.plbu_array_address[i] = ps->va + ps->offset[i];
+ }
+ else {
+ pp_frame.use_dlbu = true;
+
+ struct lima_job_fb_info *fb = &job->fb;
+ pp_frame.dlbu_regs[0] = ctx->plb[ctx->plb_index]->va;
+ pp_frame.dlbu_regs[1] = ((fb->tiled_h - 1) << 16) | (fb->tiled_w - 1);
+ unsigned s = util_logbase2(LIMA_CTX_PLB_BLK_SIZE) - 7;
+ pp_frame.dlbu_regs[2] = (s << 28) | (fb->shift_h << 16) | fb->shift_w;
+ pp_frame.dlbu_regs[3] = ((fb->tiled_h - 1) << 24) | ((fb->tiled_w - 1) << 16);
+ }
+
+ lima_dump_command_stream_print(
+ job->dump, &pp_frame, sizeof(pp_frame), false, "add pp frame\n");
+
+ if (!lima_job_start(job, LIMA_PIPE_PP, &pp_frame, sizeof(pp_frame)))
+ fprintf(stderr, "pp job error\n");
+ }
+
+ if (job->dump) {
+ if (!lima_job_wait(job, LIMA_PIPE_PP, PIPE_TIMEOUT_INFINITE)) {
+ fprintf(stderr, "pp wait error\n");
+ exit(1);
+ }
+ }
+
+ ctx->plb_index = (ctx->plb_index + 1) % lima_ctx_num_plb;
+
+ if (job->key.cbuf && (job->resolve & PIPE_CLEAR_COLOR0)) {
+ /* Set reload flag for next draw. It'll be unset if buffer is cleared */
+ struct lima_surface *surf = lima_surface(job->key.cbuf);
+ surf->reload = true;
+ }
+
+ if (ctx->job == job)
+ ctx->job = NULL;
+
+ lima_job_free(job);
+}
+
+void
+lima_flush(struct lima_context *ctx)
+{
+ hash_table_foreach(ctx->jobs, entry) {
+ struct lima_job *job = entry->data;
+ lima_do_job(job);
+ }
+}
+
+void
+lima_flush_job_accessing_bo(
+ struct lima_context *ctx, struct lima_bo *bo, bool write)
+{
+ hash_table_foreach(ctx->jobs, entry) {
+ struct lima_job *job = entry->data;
+ if (lima_job_has_bo(job, bo, write))
+ lima_do_job(job);
+ }
+}
+
+/*
+ * This is for current job flush previous job which write to the resource it wants
+ * to read. Tipical usage is flush the FBO which is used as current task's texture.
+ */
+void
+lima_flush_previous_job_writing_resource(
+ struct lima_context *ctx, struct pipe_resource *prsc)
+{
+ struct hash_entry *entry = _mesa_hash_table_search(ctx->write_jobs, prsc);
+
+ if (entry) {
+ struct lima_job *job = entry->data;
+
+ /* do not flush current job */
+ if (job != ctx->job)
+ lima_do_job(job);
+ }
+}
+
+static void
+lima_pipe_flush(struct pipe_context *pctx, struct pipe_fence_handle **fence,
+ unsigned flags)
+{
+ struct lima_context *ctx = lima_context(pctx);
+
+ lima_flush(ctx);
+
+ if (fence) {
+ int drm_fd = lima_screen(ctx->base.screen)->fd;
+ int fd;
+
+ if (!drmSyncobjExportSyncFile(drm_fd, ctx->out_sync[LIMA_PIPE_PP], &fd))
+ *fence = lima_fence_create(fd);
+ }
+}
+
+static bool
+lima_job_compare(const void *s1, const void *s2)
+{
+ return memcmp(s1, s2, sizeof(struct lima_job_key)) == 0;
+}
+
+static uint32_t
+lima_job_hash(const void *key)
+{
+ return _mesa_hash_data(key, sizeof(struct lima_job_key));
+}
+
+bool lima_job_init(struct lima_context *ctx)
+{
+ int fd = lima_screen(ctx->base.screen)->fd;
+
+ ctx->jobs = _mesa_hash_table_create(ctx, lima_job_hash, lima_job_compare);
+ if (!ctx->jobs)
+ return false;
+
+ ctx->write_jobs = _mesa_hash_table_create(
+ ctx, _mesa_hash_pointer, _mesa_key_pointer_equal);
+ if (!ctx->write_jobs)
+ return false;
+
+ ctx->in_sync_fd = -1;
+
+ for (int i = 0; i < 2; i++) {
+ if (drmSyncobjCreate(fd, DRM_SYNCOBJ_CREATE_SIGNALED, ctx->in_sync + i) ||
+ drmSyncobjCreate(fd, DRM_SYNCOBJ_CREATE_SIGNALED, ctx->out_sync + i))
+ return false;
+ }
+
+ ctx->base.flush = lima_pipe_flush;
+
+ return true;
+}
+
+void lima_job_fini(struct lima_context *ctx)
+{
+ int fd = lima_screen(ctx->base.screen)->fd;
+
+ lima_flush(ctx);
+
+ for (int i = 0; i < 2; i++) {
+ if (ctx->in_sync[i])
+ drmSyncobjDestroy(fd, ctx->in_sync[i]);
+ if (ctx->out_sync[i])
+ drmSyncobjDestroy(fd, ctx->out_sync[i]);
+ }
+
+ if (ctx->in_sync_fd >= 0)
+ close(ctx->in_sync_fd);
+}
--- /dev/null
+/*
+ * Copyright (C) 2018-2019 Lima Project
+ *
+ * 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 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 COPYRIGHT HOLDER(S) OR AUTHOR(S) 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.
+ *
+ */
+
+#ifndef H_LIMA_JOB
+#define H_LIMA_JOB
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#include <util/u_dynarray.h>
+
+#include <pipe/p_state.h>
+
+struct lima_context;
+struct lima_bo;
+struct lima_dump;
+struct pipe_surface;
+
+struct lima_job_key {
+ struct pipe_surface *cbuf;
+ struct pipe_surface *zsbuf;
+};
+
+struct lima_job_clear {
+ unsigned buffers;
+ uint32_t color_8pc;
+ uint32_t depth;
+ uint32_t stencil;
+ uint64_t color_16pc;
+};
+
+struct lima_job_fb_info {
+ int width, height;
+ int tiled_w, tiled_h;
+ int shift_w, shift_h;
+ int block_w, block_h;
+ int shift_min;
+};
+
+struct lima_job {
+ int fd;
+ struct lima_context *ctx;
+
+ struct util_dynarray gem_bos[2];
+ struct util_dynarray bos[2];
+
+ struct lima_job_key key;
+
+ struct util_dynarray vs_cmd_array;
+ struct util_dynarray plbu_cmd_array;
+ struct util_dynarray plbu_cmd_head;
+
+ unsigned resolve;
+
+ int pp_max_stack_size;
+
+ struct pipe_scissor_state damage_rect;
+
+ struct lima_job_clear clear;
+
+ struct lima_job_fb_info fb;
+
+ /* for dump command stream */
+ struct lima_dump *dump;
+};
+
+static inline bool
+lima_job_has_draw_pending(struct lima_job *job)
+{
+ return !!job->plbu_cmd_array.size;
+}
+
+struct lima_job *lima_job_get(struct lima_context *ctx);
+
+bool lima_job_add_bo(struct lima_job *job, int pipe,
+ struct lima_bo *bo, uint32_t flags);
+void *lima_job_create_stream_bo(struct lima_job *job, int pipe,
+ unsigned size, uint32_t *va);
+
+void lima_do_job(struct lima_job *job);
+
+bool lima_job_init(struct lima_context *ctx);
+void lima_job_fini(struct lima_context *ctx);
+
+#endif
#include "lima_screen.h"
#include "lima_context.h"
-#include "lima_submit.h"
+#include "lima_job.h"
#include "lima_program.h"
#include "lima_bo.h"
#include "ir/lima_ir.h"
fs->shader = NULL;
}
- struct lima_submit *submit = lima_submit_get(ctx);
- submit->pp_max_stack_size = MAX2(submit->pp_max_stack_size, ctx->fs->stack_size);
+ struct lima_job *job = lima_job_get(ctx);
+ job->pp_max_stack_size = MAX2(job->pp_max_stack_size, ctx->fs->stack_size);
return true;
}
* range, so no need to sync */
if (pres->usage != PIPE_USAGE_STREAM) {
if (usage & PIPE_TRANSFER_READ_WRITE) {
- lima_flush_submit_accessing_bo(ctx, bo, usage & PIPE_TRANSFER_WRITE);
+ lima_flush_job_accessing_bo(ctx, bo, usage & PIPE_TRANSFER_WRITE);
unsigned op = usage & PIPE_TRANSFER_WRITE ?
LIMA_GEM_WAIT_WRITE : LIMA_GEM_WAIT_READ;
"don't use tiled buffers" },
{ "nogrowheap", LIMA_DEBUG_NO_GROW_HEAP,
"disable growable heap buffer" },
- { "singlesubmit", LIMA_DEBUG_SINGLE_SUBMIT,
- "disable multi submit optimization" },
+ { "singlejob", LIMA_DEBUG_SINGLE_JOB,
+ "disable multi job optimization" },
{ NULL }
};
#define LIMA_DEBUG_BO_CACHE (1 << 5)
#define LIMA_DEBUG_NO_TILING (1 << 6)
#define LIMA_DEBUG_NO_GROW_HEAP (1 << 7)
-#define LIMA_DEBUG_SINGLE_SUBMIT (1 << 8)
+#define LIMA_DEBUG_SINGLE_JOB (1 << 8)
extern uint32_t lima_debug;
extern int lima_ctx_num_plb;
{
struct lima_context *ctx = lima_context(pctx);
- /* make sure there are always single submit in this context */
- if (lima_debug & LIMA_DEBUG_SINGLE_SUBMIT)
+ /* make sure there are always single job in this context */
+ if (lima_debug & LIMA_DEBUG_SINGLE_JOB)
lima_flush(ctx);
struct lima_context_framebuffer *fb = &ctx->framebuffer;
util_copy_framebuffer_state(&fb->base, framebuffer);
- ctx->submit = NULL;
+ ctx->job = NULL;
ctx->dirty |= LIMA_CONTEXT_DIRTY_FRAMEBUFFER;
}
+++ /dev/null
-/*
- * Copyright (C) 2017-2019 Lima Project
- *
- * 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 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 COPYRIGHT HOLDER(S) OR AUTHOR(S) 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 <stdlib.h>
-#include <string.h>
-
-#include "xf86drm.h"
-#include "drm-uapi/lima_drm.h"
-
-#include "util/u_math.h"
-#include "util/ralloc.h"
-#include "util/os_time.h"
-#include "util/hash_table.h"
-#include "util/u_upload_mgr.h"
-#include "util/u_inlines.h"
-
-#include "lima_screen.h"
-#include "lima_context.h"
-#include "lima_submit.h"
-#include "lima_bo.h"
-#include "lima_util.h"
-#include "lima_format.h"
-#include "lima_resource.h"
-#include "lima_texture.h"
-#include "lima_fence.h"
-#include "lima_gpu.h"
-
-#define VOID2U64(x) ((uint64_t)(unsigned long)(x))
-
-static void
-lima_get_fb_info(struct lima_submit *submit)
-{
- struct lima_context *ctx = submit->ctx;
- struct lima_submit_fb_info *fb = &submit->fb;
-
- fb->width = ctx->framebuffer.base.width;
- fb->height = ctx->framebuffer.base.height;
-
- int width = align(fb->width, 16) >> 4;
- int height = align(fb->height, 16) >> 4;
-
- struct lima_screen *screen = lima_screen(ctx->base.screen);
-
- fb->tiled_w = width;
- fb->tiled_h = height;
-
- fb->shift_h = 0;
- fb->shift_w = 0;
-
- int limit = screen->plb_max_blk;
- while ((width * height) > limit) {
- if (width >= height) {
- width = (width + 1) >> 1;
- fb->shift_w++;
- } else {
- height = (height + 1) >> 1;
- fb->shift_h++;
- }
- }
-
- fb->block_w = width;
- fb->block_h = height;
-
- fb->shift_min = MIN3(fb->shift_w, fb->shift_h, 2);
-}
-
-static struct lima_submit *
-lima_submit_create(struct lima_context *ctx)
-{
- struct lima_submit *s;
-
- s = rzalloc(ctx, struct lima_submit);
- if (!s)
- return NULL;
-
- s->fd = lima_screen(ctx->base.screen)->fd;
- s->ctx = ctx;
-
- s->damage_rect.minx = s->damage_rect.miny = 0xffff;
- s->damage_rect.maxx = s->damage_rect.maxy = 0;
-
- for (int i = 0; i < 2; i++) {
- util_dynarray_init(s->gem_bos + i, s);
- util_dynarray_init(s->bos + i, s);
- }
-
- util_dynarray_init(&s->vs_cmd_array, s);
- util_dynarray_init(&s->plbu_cmd_array, s);
- util_dynarray_init(&s->plbu_cmd_head, s);
-
- struct lima_context_framebuffer *fb = &ctx->framebuffer;
- pipe_surface_reference(&s->key.cbuf, fb->base.cbufs[0]);
- pipe_surface_reference(&s->key.zsbuf, fb->base.zsbuf);
-
- lima_get_fb_info(s);
-
- s->dump = lima_dump_create();
-
- return s;
-}
-
-static void
-lima_submit_free(struct lima_submit *submit)
-{
- struct lima_context *ctx = submit->ctx;
-
- _mesa_hash_table_remove_key(ctx->submits, &submit->key);
-
- if (submit->key.cbuf && (submit->resolve & PIPE_CLEAR_COLOR0))
- _mesa_hash_table_remove_key(ctx->write_submits, submit->key.cbuf->texture);
- if (submit->key.zsbuf && (submit->resolve & (PIPE_CLEAR_DEPTH | PIPE_CLEAR_STENCIL)))
- _mesa_hash_table_remove_key(ctx->write_submits, submit->key.zsbuf->texture);
-
- pipe_surface_reference(&submit->key.cbuf, NULL);
- pipe_surface_reference(&submit->key.zsbuf, NULL);
-
- lima_dump_free(submit->dump);
- submit->dump = NULL;
-
- /* TODO: do we need a cache for submit? */
- ralloc_free(submit);
-}
-
-static struct lima_submit *
-_lima_submit_get(struct lima_context *ctx)
-{
- struct lima_context_framebuffer *fb = &ctx->framebuffer;
- struct lima_submit_key local_key = {
- .cbuf = fb->base.cbufs[0],
- .zsbuf = fb->base.zsbuf,
- };
-
- struct hash_entry *entry = _mesa_hash_table_search(ctx->submits, &local_key);
- if (entry)
- return entry->data;
-
- struct lima_submit *submit = lima_submit_create(ctx);
- if (!submit)
- return NULL;
-
- _mesa_hash_table_insert(ctx->submits, &submit->key, submit);
-
- return submit;
-}
-
-/*
- * Note: this function can only be called in draw code path,
- * must not exist in flush code path.
- */
-struct lima_submit *
-lima_submit_get(struct lima_context *ctx)
-{
- if (ctx->submit)
- return ctx->submit;
-
- ctx->submit = _lima_submit_get(ctx);
- return ctx->submit;
-}
-
-bool lima_submit_add_bo(struct lima_submit *submit, int pipe,
- struct lima_bo *bo, uint32_t flags)
-{
- util_dynarray_foreach(submit->gem_bos + pipe, struct drm_lima_gem_submit_bo, gem_bo) {
- if (bo->handle == gem_bo->handle) {
- gem_bo->flags |= flags;
- return true;
- }
- }
-
- struct drm_lima_gem_submit_bo *submit_bo =
- util_dynarray_grow(submit->gem_bos + pipe, struct drm_lima_gem_submit_bo, 1);
- submit_bo->handle = bo->handle;
- submit_bo->flags = flags;
-
- struct lima_bo **jbo = util_dynarray_grow(submit->bos + pipe, struct lima_bo *, 1);
- *jbo = bo;
-
- /* prevent bo from being freed when submit start */
- lima_bo_reference(bo);
-
- return true;
-}
-
-static bool
-lima_submit_start(struct lima_submit *submit, int pipe, void *frame, uint32_t size)
-{
- struct lima_context *ctx = submit->ctx;
- struct drm_lima_gem_submit req = {
- .ctx = ctx->id,
- .pipe = pipe,
- .nr_bos = submit->gem_bos[pipe].size / sizeof(struct drm_lima_gem_submit_bo),
- .bos = VOID2U64(util_dynarray_begin(submit->gem_bos + pipe)),
- .frame = VOID2U64(frame),
- .frame_size = size,
- .out_sync = ctx->out_sync[pipe],
- };
-
- if (ctx->in_sync_fd >= 0) {
- int err = drmSyncobjImportSyncFile(submit->fd, ctx->in_sync[pipe],
- ctx->in_sync_fd);
- if (err)
- return false;
-
- req.in_sync[0] = ctx->in_sync[pipe];
- close(ctx->in_sync_fd);
- ctx->in_sync_fd = -1;
- }
-
- bool ret = drmIoctl(submit->fd, DRM_IOCTL_LIMA_GEM_SUBMIT, &req) == 0;
-
- util_dynarray_foreach(submit->bos + pipe, struct lima_bo *, bo) {
- lima_bo_unreference(*bo);
- }
-
- return ret;
-}
-
-static bool
-lima_submit_wait(struct lima_submit *submit, int pipe, uint64_t timeout_ns)
-{
- int64_t abs_timeout = os_time_get_absolute_timeout(timeout_ns);
- if (abs_timeout == OS_TIMEOUT_INFINITE)
- abs_timeout = INT64_MAX;
-
- struct lima_context *ctx = submit->ctx;
- return !drmSyncobjWait(submit->fd, ctx->out_sync + pipe, 1, abs_timeout, 0, NULL);
-}
-
-static bool
-lima_submit_has_bo(struct lima_submit *submit, struct lima_bo *bo, bool all)
-{
- for (int i = 0; i < 2; i++) {
- util_dynarray_foreach(submit->gem_bos + i, struct drm_lima_gem_submit_bo, gem_bo) {
- if (bo->handle == gem_bo->handle) {
- if (all || gem_bo->flags & LIMA_SUBMIT_BO_WRITE)
- return true;
- else
- break;
- }
- }
- }
-
- return false;
-}
-
-void *
-lima_submit_create_stream_bo(struct lima_submit *submit, int pipe,
- unsigned size, uint32_t *va)
-{
- struct lima_context *ctx = submit->ctx;
-
- void *cpu;
- unsigned offset;
- struct pipe_resource *pres = NULL;
- u_upload_alloc(ctx->uploader, 0, size, 0x40, &offset, &pres, &cpu);
-
- struct lima_resource *res = lima_resource(pres);
- *va = res->bo->va + offset;
-
- lima_submit_add_bo(submit, pipe, res->bo, LIMA_SUBMIT_BO_READ);
-
- pipe_resource_reference(&pres, NULL);
-
- return cpu;
-}
-
-static inline struct lima_damage_region *
-lima_submit_get_damage(struct lima_submit *submit)
-{
- if (!(submit->key.cbuf && (submit->resolve & PIPE_CLEAR_COLOR0)))
- return NULL;
-
- struct lima_surface *surf = lima_surface(submit->key.cbuf);
- struct lima_resource *res = lima_resource(surf->base.texture);
- return &res->damage;
-}
-
-static bool
-lima_fb_need_reload(struct lima_submit *submit)
-{
- /* Depth buffer is always discarded */
- if (!(submit->key.cbuf && (submit->resolve & PIPE_CLEAR_COLOR0)))
- return false;
-
- struct lima_surface *surf = lima_surface(submit->key.cbuf);
- struct lima_resource *res = lima_resource(surf->base.texture);
- if (res->damage.region) {
- /* for EGL_KHR_partial_update, when EGL_EXT_buffer_age is enabled,
- * we need to reload damage region, otherwise just want to reload
- * the region not aligned to tile boundary */
- //if (!res->damage.aligned)
- // return true;
- return true;
- }
- else if (surf->reload)
- return true;
-
- return false;
-}
-
-static void
-lima_pack_reload_plbu_cmd(struct lima_submit *submit)
-{
- #define lima_reload_render_state_offset 0x0000
- #define lima_reload_gl_pos_offset 0x0040
- #define lima_reload_varying_offset 0x0080
- #define lima_reload_tex_desc_offset 0x00c0
- #define lima_reload_tex_array_offset 0x0100
- #define lima_reload_buffer_size 0x0140
-
- struct lima_context *ctx = submit->ctx;
-
- uint32_t va;
- void *cpu = lima_submit_create_stream_bo(
- submit, LIMA_PIPE_PP, lima_reload_buffer_size, &va);
-
- struct lima_screen *screen = lima_screen(ctx->base.screen);
-
- uint32_t reload_shader_first_instr_size =
- ((uint32_t *)(screen->pp_buffer->map + pp_reload_program_offset))[0] & 0x1f;
- uint32_t reload_shader_va = screen->pp_buffer->va + pp_reload_program_offset;
-
- struct lima_render_state reload_render_state = {
- .alpha_blend = 0xf03b1ad2,
- .depth_test = 0x0000000e,
- .depth_range = 0xffff0000,
- .stencil_front = 0x00000007,
- .stencil_back = 0x00000007,
- .multi_sample = 0x0000f007,
- .shader_address = reload_shader_va | reload_shader_first_instr_size,
- .varying_types = 0x00000001,
- .textures_address = va + lima_reload_tex_array_offset,
- .aux0 = 0x00004021,
- .varyings_address = va + lima_reload_varying_offset,
- };
- memcpy(cpu + lima_reload_render_state_offset, &reload_render_state,
- sizeof(reload_render_state));
-
- lima_tex_desc *td = cpu + lima_reload_tex_desc_offset;
- memset(td, 0, lima_min_tex_desc_size);
- lima_texture_desc_set_res(ctx, td, submit->key.cbuf->texture, 0, 0);
- td->unnorm_coords = 1;
- td->texture_type = LIMA_TEXTURE_TYPE_2D;
- td->min_img_filter_nearest = 1;
- td->mag_img_filter_nearest = 1;
- td->wrap_s_clamp_to_edge = 1;
- td->wrap_t_clamp_to_edge = 1;
- td->unknown_2_2 = 0x1;
-
- uint32_t *ta = cpu + lima_reload_tex_array_offset;
- ta[0] = va + lima_reload_tex_desc_offset;
-
- struct lima_submit_fb_info *fb = &submit->fb;
- float reload_gl_pos[] = {
- fb->width, 0, 0, 1,
- 0, 0, 0, 1,
- 0, fb->height, 0, 1,
- };
- memcpy(cpu + lima_reload_gl_pos_offset, reload_gl_pos,
- sizeof(reload_gl_pos));
-
- float reload_varying[] = {
- fb->width, 0, 0, 0,
- 0, fb->height, 0, 0,
- };
- memcpy(cpu + lima_reload_varying_offset, reload_varying,
- sizeof(reload_varying));
-
- PLBU_CMD_BEGIN(&submit->plbu_cmd_head, 20);
-
- PLBU_CMD_VIEWPORT_LEFT(0);
- PLBU_CMD_VIEWPORT_RIGHT(fui(fb->width));
- PLBU_CMD_VIEWPORT_BOTTOM(0);
- PLBU_CMD_VIEWPORT_TOP(fui(fb->height));
-
- PLBU_CMD_RSW_VERTEX_ARRAY(
- va + lima_reload_render_state_offset,
- va + lima_reload_gl_pos_offset);
-
- PLBU_CMD_UNKNOWN2();
- PLBU_CMD_UNKNOWN1();
-
- PLBU_CMD_INDICES(screen->pp_buffer->va + pp_shared_index_offset);
- PLBU_CMD_INDEXED_DEST(va + lima_reload_gl_pos_offset);
- PLBU_CMD_DRAW_ELEMENTS(0xf, 0, 3);
-
- PLBU_CMD_END();
-}
-
-static void
-lima_pack_head_plbu_cmd(struct lima_submit *submit)
-{
- struct lima_context *ctx = submit->ctx;
- struct lima_submit_fb_info *fb = &submit->fb;
-
- PLBU_CMD_BEGIN(&submit->plbu_cmd_head, 10);
-
- PLBU_CMD_UNKNOWN2();
- PLBU_CMD_BLOCK_STEP(fb->shift_min, fb->shift_h, fb->shift_w);
- PLBU_CMD_TILED_DIMENSIONS(fb->tiled_w, fb->tiled_h);
- PLBU_CMD_BLOCK_STRIDE(fb->block_w);
-
- PLBU_CMD_ARRAY_ADDRESS(
- ctx->plb_gp_stream->va + ctx->plb_index * ctx->plb_gp_size,
- fb->block_w * fb->block_h);
-
- PLBU_CMD_END();
-
- if (lima_fb_need_reload(submit))
- lima_pack_reload_plbu_cmd(submit);
-}
-
-static void
-hilbert_rotate(int n, int *x, int *y, int rx, int ry)
-{
- if (ry == 0) {
- if (rx == 1) {
- *x = n-1 - *x;
- *y = n-1 - *y;
- }
-
- /* Swap x and y */
- int t = *x;
- *x = *y;
- *y = t;
- }
-}
-
-static void
-hilbert_coords(int n, int d, int *x, int *y)
-{
- int rx, ry, i, t=d;
-
- *x = *y = 0;
-
- for (i = 0; (1 << i) < n; i++) {
-
- rx = 1 & (t / 2);
- ry = 1 & (t ^ rx);
-
- hilbert_rotate(1 << i, x, y, rx, ry);
-
- *x += rx << i;
- *y += ry << i;
-
- t /= 4;
- }
-}
-
-static int
-lima_get_pp_stream_size(int num_pp, int tiled_w, int tiled_h, uint32_t *off)
-{
- /* carefully calculate each stream start address:
- * 1. overflow: each stream size may be different due to
- * fb->tiled_w * fb->tiled_h can't be divided by num_pp,
- * extra size should be added to the preceeding stream
- * 2. alignment: each stream address should be 0x20 aligned
- */
- int delta = tiled_w * tiled_h / num_pp * 16 + 16;
- int remain = tiled_w * tiled_h % num_pp;
- int offset = 0;
-
- for (int i = 0; i < num_pp; i++) {
- off[i] = offset;
-
- offset += delta;
- if (remain) {
- offset += 16;
- remain--;
- }
- offset = align(offset, 0x20);
- }
-
- return offset;
-}
-
-static bool
-inside_damage_region(int x, int y, struct lima_damage_region *ds)
-{
- if (!ds || !ds->region)
- return true;
-
- for (int i = 0; i < ds->num_region; i++) {
- struct pipe_scissor_state *ss = ds->region + i;
- if (x >= ss->minx && x < ss->maxx &&
- y >= ss->miny && y < ss->maxy)
- return true;
- }
-
- return false;
-}
-
-static void
-lima_generate_pp_stream(struct lima_submit *submit, int off_x, int off_y,
- int tiled_w, int tiled_h)
-{
- struct lima_context *ctx = submit->ctx;
- struct lima_pp_stream_state *ps = &ctx->pp_stream;
- struct lima_submit_fb_info *fb = &submit->fb;
- struct lima_damage_region *damage = lima_submit_get_damage(submit);
- struct lima_screen *screen = lima_screen(ctx->base.screen);
- int i, num_pp = screen->num_pp;
-
- /* use hilbert_coords to generates 1D to 2D relationship.
- * 1D for pp stream index and 2D for plb block x/y on framebuffer.
- * if multi pp, interleave the 1D index to make each pp's render target
- * close enough which should result close workload
- */
- int max = MAX2(tiled_w, tiled_h);
- int index = 0;
- uint32_t *stream[4];
- int si[4] = {0};
- int dim = 0;
- int count = 0;
-
- /* Don't update count if we get zero rect. We'll just generate
- * PP stream with just terminators in it.
- */
- if ((tiled_w * tiled_h) != 0) {
- dim = util_logbase2_ceil(max);
- count = 1 << (dim + dim);
- }
-
- for (i = 0; i < num_pp; i++)
- stream[i] = ps->map + ps->offset[i];
-
- for (i = 0; i < count; i++) {
- int x, y;
- hilbert_coords(max, i, &x, &y);
- if (x < tiled_w && y < tiled_h) {
- x += off_x;
- y += off_y;
-
- if (!inside_damage_region(x, y, damage))
- continue;
-
- int pp = index % num_pp;
- int offset = ((y >> fb->shift_h) * fb->block_w +
- (x >> fb->shift_w)) * LIMA_CTX_PLB_BLK_SIZE;
- int plb_va = ctx->plb[ctx->plb_index]->va + offset;
-
- stream[pp][si[pp]++] = 0;
- stream[pp][si[pp]++] = 0xB8000000 | x | (y << 8);
- stream[pp][si[pp]++] = 0xE0000002 | ((plb_va >> 3) & ~0xE0000003);
- stream[pp][si[pp]++] = 0xB0000000;
-
- index++;
- }
- }
-
- for (i = 0; i < num_pp; i++) {
- stream[i][si[i]++] = 0;
- stream[i][si[i]++] = 0xBC000000;
- stream[i][si[i]++] = 0;
- stream[i][si[i]++] = 0;
-
- lima_dump_command_stream_print(
- submit->dump, stream[i], si[i] * 4,
- false, "pp plb stream %d at va %x\n",
- i, ps->va + ps->offset[i]);
- }
-}
-
-static void
-lima_update_damage_pp_stream(struct lima_submit *submit)
-{
- struct lima_context *ctx = submit->ctx;
- struct lima_damage_region *ds = lima_submit_get_damage(submit);
- struct lima_submit_fb_info *fb = &submit->fb;
- struct pipe_scissor_state bound;
- struct pipe_scissor_state *dr = &submit->damage_rect;
-
- if (ds && ds->region) {
- struct pipe_scissor_state *dbound = &ds->bound;
- bound.minx = MAX2(dbound->minx, dr->minx >> 4);
- bound.miny = MAX2(dbound->miny, dr->miny >> 4);
- bound.maxx = MIN2(dbound->maxx, (dr->maxx + 0xf) >> 4);
- bound.maxy = MIN2(dbound->maxy, (dr->maxy + 0xf) >> 4);
- } else {
- bound.minx = dr->minx >> 4;
- bound.miny = dr->miny >> 4;
- bound.maxx = (dr->maxx + 0xf) >> 4;
- bound.maxy = (dr->maxy + 0xf) >> 4;
- }
-
- /* Clamp to FB size */
- bound.minx = MIN2(bound.minx, fb->tiled_w);
- bound.miny = MIN2(bound.miny, fb->tiled_h);
- bound.maxx = MIN2(bound.maxx, fb->tiled_w);
- bound.maxy = MIN2(bound.maxy, fb->tiled_h);
-
- int tiled_w = bound.maxx - bound.minx;
- int tiled_h = bound.maxy - bound.miny;
-
- struct lima_screen *screen = lima_screen(ctx->base.screen);
- int size = lima_get_pp_stream_size(
- screen->num_pp, tiled_w, tiled_h, ctx->pp_stream.offset);
-
- ctx->pp_stream.map = lima_submit_create_stream_bo(
- submit, LIMA_PIPE_PP, size, &ctx->pp_stream.va);
-
- lima_generate_pp_stream(submit, bound.minx, bound.miny, tiled_w, tiled_h);
-}
-
-static void
-lima_update_full_pp_stream(struct lima_submit *submit)
-{
- struct lima_context *ctx = submit->ctx;
- struct lima_submit_fb_info *fb = &submit->fb;
- struct lima_ctx_plb_pp_stream_key key = {
- .plb_index = ctx->plb_index,
- .tiled_w = fb->tiled_w,
- .tiled_h = fb->tiled_h,
- };
-
- struct hash_entry *entry =
- _mesa_hash_table_search(ctx->plb_pp_stream, &key);
- struct lima_ctx_plb_pp_stream *s = entry->data;
-
- if (s->bo) {
- ctx->pp_stream.map = lima_bo_map(s->bo);
- ctx->pp_stream.va = s->bo->va;
- memcpy(ctx->pp_stream.offset, s->offset, sizeof(s->offset));
- }
- else {
- struct lima_screen *screen = lima_screen(ctx->base.screen);
- int size = lima_get_pp_stream_size(
- screen->num_pp, fb->tiled_w, fb->tiled_h, s->offset);
- s->bo = lima_bo_create(screen, size, 0);
-
- ctx->pp_stream.map = lima_bo_map(s->bo);
- ctx->pp_stream.va = s->bo->va;
- memcpy(ctx->pp_stream.offset, s->offset, sizeof(s->offset));
-
- lima_generate_pp_stream(submit, 0, 0, fb->tiled_w, fb->tiled_h);
- }
-
- lima_submit_add_bo(submit, LIMA_PIPE_PP, s->bo, LIMA_SUBMIT_BO_READ);
-}
-
-static bool
-lima_damage_fullscreen(struct lima_submit *submit)
-{
- struct pipe_scissor_state *dr = &submit->damage_rect;
-
- return dr->minx == 0 &&
- dr->miny == 0 &&
- dr->maxx == submit->fb.width &&
- dr->maxy == submit->fb.height;
-}
-
-static void
-lima_update_pp_stream(struct lima_submit *submit)
-{
- struct lima_context *ctx = submit->ctx;
- struct lima_damage_region *damage = lima_submit_get_damage(submit);
- if ((damage && damage->region) || !lima_damage_fullscreen(submit))
- lima_update_damage_pp_stream(submit);
- else if (ctx->plb_pp_stream)
- lima_update_full_pp_stream(submit);
- else
- ctx->pp_stream.map = NULL;
-}
-
-static void
-lima_update_submit_bo(struct lima_submit *submit)
-{
- struct lima_context *ctx = submit->ctx;
-
- lima_submit_add_bo(submit, LIMA_PIPE_GP, ctx->plb_gp_stream,
- LIMA_SUBMIT_BO_READ);
- lima_submit_add_bo(submit, LIMA_PIPE_GP, ctx->plb[ctx->plb_index],
- LIMA_SUBMIT_BO_WRITE);
- lima_submit_add_bo(submit, LIMA_PIPE_GP, ctx->gp_tile_heap[ctx->plb_index],
- LIMA_SUBMIT_BO_WRITE);
-
- lima_dump_command_stream_print(
- submit->dump, ctx->plb_gp_stream->map + ctx->plb_index * ctx->plb_gp_size,
- ctx->plb_gp_size, false, "gp plb stream at va %x\n",
- ctx->plb_gp_stream->va + ctx->plb_index * ctx->plb_gp_size);
-
- lima_submit_add_bo(submit, LIMA_PIPE_PP, ctx->plb[ctx->plb_index],
- LIMA_SUBMIT_BO_READ);
- lima_submit_add_bo(submit, LIMA_PIPE_PP, ctx->gp_tile_heap[ctx->plb_index],
- LIMA_SUBMIT_BO_READ);
-
- struct lima_screen *screen = lima_screen(ctx->base.screen);
- lima_submit_add_bo(submit, LIMA_PIPE_PP, screen->pp_buffer, LIMA_SUBMIT_BO_READ);
-}
-
-static void
-lima_finish_plbu_cmd(struct util_dynarray *plbu_cmd_array)
-{
- int i = 0;
- uint32_t *plbu_cmd = util_dynarray_ensure_cap(plbu_cmd_array, plbu_cmd_array->size + 2 * 4);
-
- plbu_cmd[i++] = 0x00000000;
- plbu_cmd[i++] = 0x50000000; /* END */
-
- plbu_cmd_array->size += i * 4;
-}
-
-static void
-lima_pack_wb_zsbuf_reg(struct lima_submit *submit, uint32_t *wb_reg, int wb_idx)
-{
- struct lima_submit_fb_info *fb = &submit->fb;
- struct pipe_surface *zsbuf = submit->key.zsbuf;
- struct lima_resource *res = lima_resource(zsbuf->texture);
- int level = zsbuf->u.tex.level;
- uint32_t format = lima_format_get_pixel(zsbuf->format);
-
- struct lima_pp_wb_reg *wb = (void *)wb_reg;
- wb[wb_idx].type = 0x01; /* 1 for depth, stencil */
- wb[wb_idx].address = res->bo->va + res->levels[level].offset;
- wb[wb_idx].pixel_format = format;
- if (res->tiled) {
- wb[wb_idx].pixel_layout = 0x2;
- wb[wb_idx].pitch = fb->tiled_w;
- } else {
- wb[wb_idx].pixel_layout = 0x0;
- wb[wb_idx].pitch = res->levels[level].stride / 8;
- }
- wb[wb_idx].mrt_bits = 0;
-}
-
-static void
-lima_pack_wb_cbuf_reg(struct lima_submit *submit, uint32_t *wb_reg, int wb_idx)
-{
- struct lima_submit_fb_info *fb = &submit->fb;
- struct pipe_surface *cbuf = submit->key.cbuf;
- struct lima_resource *res = lima_resource(cbuf->texture);
- int level = cbuf->u.tex.level;
- unsigned layer = cbuf->u.tex.first_layer;
- uint32_t format = lima_format_get_pixel(cbuf->format);
- bool swap_channels = lima_format_get_swap_rb(cbuf->format);
-
- struct lima_pp_wb_reg *wb = (void *)wb_reg;
- wb[wb_idx].type = 0x02; /* 2 for color buffer */
- wb[wb_idx].address = res->bo->va + res->levels[level].offset + layer * res->levels[level].layer_stride;
- wb[wb_idx].pixel_format = format;
- if (res->tiled) {
- wb[wb_idx].pixel_layout = 0x2;
- wb[wb_idx].pitch = fb->tiled_w;
- } else {
- wb[wb_idx].pixel_layout = 0x0;
- wb[wb_idx].pitch = res->levels[level].stride / 8;
- }
- wb[wb_idx].mrt_bits = swap_channels ? 0x4 : 0x0;
-}
-
-static void
-lima_pack_pp_frame_reg(struct lima_submit *submit, uint32_t *frame_reg,
- uint32_t *wb_reg)
-{
- struct lima_context *ctx = submit->ctx;
- struct lima_submit_fb_info *fb = &submit->fb;
- struct lima_pp_frame_reg *frame = (void *)frame_reg;
- struct lima_screen *screen = lima_screen(ctx->base.screen);
- int wb_idx = 0;
-
- frame->render_address = screen->pp_buffer->va + pp_frame_rsw_offset;
- frame->flags = 0x02;
- frame->clear_value_depth = submit->clear.depth;
- frame->clear_value_stencil = submit->clear.stencil;
- frame->clear_value_color = submit->clear.color_8pc;
- frame->clear_value_color_1 = submit->clear.color_8pc;
- frame->clear_value_color_2 = submit->clear.color_8pc;
- frame->clear_value_color_3 = submit->clear.color_8pc;
- frame->one = 1;
-
- frame->width = fb->width - 1;
- frame->height = fb->height - 1;
-
- /* frame->fragment_stack_address is overwritten per-pp in the kernel
- * by the values of pp_frame.fragment_stack_address[i] */
-
- /* These are "stack size" and "stack offset" shifted,
- * here they are assumed to be always the same. */
- frame->fragment_stack_size = submit->pp_max_stack_size << 16 | submit->pp_max_stack_size;
-
- /* related with MSAA and different value when r4p0/r7p0 */
- frame->supersampled_height = fb->height * 2 - 1;
- frame->scale = 0xE0C;
-
- frame->dubya = 0x77;
- frame->onscreen = 1;
- frame->blocking = (fb->shift_min << 28) | (fb->shift_h << 16) | fb->shift_w;
- frame->foureight = 0x8888;
-
- if (submit->key.cbuf && (submit->resolve & PIPE_CLEAR_COLOR0))
- lima_pack_wb_cbuf_reg(submit, wb_reg, wb_idx++);
-
- if (submit->key.zsbuf &&
- (submit->resolve & (PIPE_CLEAR_DEPTH | PIPE_CLEAR_STENCIL)))
- lima_pack_wb_zsbuf_reg(submit, wb_reg, wb_idx++);
-}
-
-void
-lima_do_submit(struct lima_submit *submit)
-{
- #define pp_stack_pp_size 0x400
-
- struct lima_context *ctx = submit->ctx;
-
- lima_pack_head_plbu_cmd(submit);
- lima_finish_plbu_cmd(&submit->plbu_cmd_array);
-
- lima_update_submit_bo(submit);
-
- int vs_cmd_size = submit->vs_cmd_array.size;
- uint32_t vs_cmd_va = 0;
-
- if (vs_cmd_size) {
- void *vs_cmd = lima_submit_create_stream_bo(
- submit, LIMA_PIPE_GP, vs_cmd_size, &vs_cmd_va);
- memcpy(vs_cmd, util_dynarray_begin(&submit->vs_cmd_array), vs_cmd_size);
-
- lima_dump_command_stream_print(
- submit->dump, vs_cmd, vs_cmd_size, false, "flush vs cmd at va %x\n", vs_cmd_va);
- lima_dump_vs_command_stream_print(submit->dump, vs_cmd, vs_cmd_size, vs_cmd_va);
- }
-
- uint32_t plbu_cmd_va;
- int plbu_cmd_size = submit->plbu_cmd_array.size + submit->plbu_cmd_head.size;
- void *plbu_cmd = lima_submit_create_stream_bo(
- submit, LIMA_PIPE_GP, plbu_cmd_size, &plbu_cmd_va);
- memcpy(plbu_cmd,
- util_dynarray_begin(&submit->plbu_cmd_head),
- submit->plbu_cmd_head.size);
- memcpy(plbu_cmd + submit->plbu_cmd_head.size,
- util_dynarray_begin(&submit->plbu_cmd_array),
- submit->plbu_cmd_array.size);
-
- lima_dump_command_stream_print(
- submit->dump, plbu_cmd, plbu_cmd_size, false, "flush plbu cmd at va %x\n", plbu_cmd_va);
- lima_dump_plbu_command_stream_print(submit->dump, plbu_cmd, plbu_cmd_size, plbu_cmd_va);
-
- struct lima_screen *screen = lima_screen(ctx->base.screen);
- struct drm_lima_gp_frame gp_frame;
- struct lima_gp_frame_reg *gp_frame_reg = (void *)gp_frame.frame;
- gp_frame_reg->vs_cmd_start = vs_cmd_va;
- gp_frame_reg->vs_cmd_end = vs_cmd_va + vs_cmd_size;
- gp_frame_reg->plbu_cmd_start = plbu_cmd_va;
- gp_frame_reg->plbu_cmd_end = plbu_cmd_va + plbu_cmd_size;
- gp_frame_reg->tile_heap_start = ctx->gp_tile_heap[ctx->plb_index]->va;
- gp_frame_reg->tile_heap_end = ctx->gp_tile_heap[ctx->plb_index]->va + ctx->gp_tile_heap_size;
-
- lima_dump_command_stream_print(
- submit->dump, &gp_frame, sizeof(gp_frame), false, "add gp frame\n");
-
- if (!lima_submit_start(submit, LIMA_PIPE_GP, &gp_frame, sizeof(gp_frame)))
- fprintf(stderr, "gp submit error\n");
-
- if (submit->dump) {
- if (lima_submit_wait(submit, LIMA_PIPE_GP, PIPE_TIMEOUT_INFINITE)) {
- if (ctx->gp_output) {
- float *pos = lima_bo_map(ctx->gp_output);
- lima_dump_command_stream_print(
- submit->dump, pos, 4 * 4 * 16, true, "gl_pos dump at va %x\n",
- ctx->gp_output->va);
- }
-
- uint32_t *plb = lima_bo_map(ctx->plb[ctx->plb_index]);
- lima_dump_command_stream_print(
- submit->dump, plb, LIMA_CTX_PLB_BLK_SIZE, false, "plb dump at va %x\n",
- ctx->plb[ctx->plb_index]->va);
- }
- else {
- fprintf(stderr, "gp submit wait error\n");
- exit(1);
- }
- }
-
- uint32_t pp_stack_va = 0;
- if (submit->pp_max_stack_size) {
- lima_submit_create_stream_bo(
- submit, LIMA_PIPE_PP,
- screen->num_pp * submit->pp_max_stack_size * pp_stack_pp_size,
- &pp_stack_va);
- }
-
- lima_update_pp_stream(submit);
-
- struct lima_pp_stream_state *ps = &ctx->pp_stream;
- if (screen->gpu_type == DRM_LIMA_PARAM_GPU_ID_MALI400) {
- struct drm_lima_m400_pp_frame pp_frame = {0};
- lima_pack_pp_frame_reg(submit, pp_frame.frame, pp_frame.wb);
- pp_frame.num_pp = screen->num_pp;
-
- for (int i = 0; i < screen->num_pp; i++) {
- pp_frame.plbu_array_address[i] = ps->va + ps->offset[i];
- if (submit->pp_max_stack_size)
- pp_frame.fragment_stack_address[i] = pp_stack_va +
- submit->pp_max_stack_size * pp_stack_pp_size * i;
- }
-
- lima_dump_command_stream_print(
- submit->dump, &pp_frame, sizeof(pp_frame), false, "add pp frame\n");
-
- if (!lima_submit_start(submit, LIMA_PIPE_PP, &pp_frame, sizeof(pp_frame)))
- fprintf(stderr, "pp submit error\n");
- }
- else {
- struct drm_lima_m450_pp_frame pp_frame = {0};
- lima_pack_pp_frame_reg(submit, pp_frame.frame, pp_frame.wb);
- pp_frame.num_pp = screen->num_pp;
-
- if (submit->pp_max_stack_size)
- for (int i = 0; i < screen->num_pp; i++)
- pp_frame.fragment_stack_address[i] = pp_stack_va +
- submit->pp_max_stack_size * pp_stack_pp_size * i;
-
- if (ps->map) {
- for (int i = 0; i < screen->num_pp; i++)
- pp_frame.plbu_array_address[i] = ps->va + ps->offset[i];
- }
- else {
- pp_frame.use_dlbu = true;
-
- struct lima_submit_fb_info *fb = &submit->fb;
- pp_frame.dlbu_regs[0] = ctx->plb[ctx->plb_index]->va;
- pp_frame.dlbu_regs[1] = ((fb->tiled_h - 1) << 16) | (fb->tiled_w - 1);
- unsigned s = util_logbase2(LIMA_CTX_PLB_BLK_SIZE) - 7;
- pp_frame.dlbu_regs[2] = (s << 28) | (fb->shift_h << 16) | fb->shift_w;
- pp_frame.dlbu_regs[3] = ((fb->tiled_h - 1) << 24) | ((fb->tiled_w - 1) << 16);
- }
-
- lima_dump_command_stream_print(
- submit->dump, &pp_frame, sizeof(pp_frame), false, "add pp frame\n");
-
- if (!lima_submit_start(submit, LIMA_PIPE_PP, &pp_frame, sizeof(pp_frame)))
- fprintf(stderr, "pp submit error\n");
- }
-
- if (submit->dump) {
- if (!lima_submit_wait(submit, LIMA_PIPE_PP, PIPE_TIMEOUT_INFINITE)) {
- fprintf(stderr, "pp wait error\n");
- exit(1);
- }
- }
-
- ctx->plb_index = (ctx->plb_index + 1) % lima_ctx_num_plb;
-
- if (submit->key.cbuf && (submit->resolve & PIPE_CLEAR_COLOR0)) {
- /* Set reload flag for next draw. It'll be unset if buffer is cleared */
- struct lima_surface *surf = lima_surface(submit->key.cbuf);
- surf->reload = true;
- }
-
- if (ctx->submit == submit)
- ctx->submit = NULL;
-
- lima_submit_free(submit);
-}
-
-void
-lima_flush(struct lima_context *ctx)
-{
- hash_table_foreach(ctx->submits, entry) {
- struct lima_submit *submit = entry->data;
- lima_do_submit(submit);
- }
-}
-
-void
-lima_flush_submit_accessing_bo(
- struct lima_context *ctx, struct lima_bo *bo, bool write)
-{
- hash_table_foreach(ctx->submits, entry) {
- struct lima_submit *submit = entry->data;
- if (lima_submit_has_bo(submit, bo, write))
- lima_do_submit(submit);
- }
-}
-
-/*
- * This is for current submit flush previous submit which write to the resource it wants
- * to read. Tipical usage is flush the FBO which is used as current task's texture.
- */
-void
-lima_flush_previous_submit_writing_resource(
- struct lima_context *ctx, struct pipe_resource *prsc)
-{
- struct hash_entry *entry = _mesa_hash_table_search(ctx->write_submits, prsc);
-
- if (entry) {
- struct lima_submit *submit = entry->data;
-
- /* do not flush current submit */
- if (submit != ctx->submit)
- lima_do_submit(submit);
- }
-}
-
-static void
-lima_pipe_flush(struct pipe_context *pctx, struct pipe_fence_handle **fence,
- unsigned flags)
-{
- struct lima_context *ctx = lima_context(pctx);
-
- lima_flush(ctx);
-
- if (fence) {
- int drm_fd = lima_screen(ctx->base.screen)->fd;
- int fd;
-
- if (!drmSyncobjExportSyncFile(drm_fd, ctx->out_sync[LIMA_PIPE_PP], &fd))
- *fence = lima_fence_create(fd);
- }
-}
-
-static bool
-lima_submit_compare(const void *s1, const void *s2)
-{
- return memcmp(s1, s2, sizeof(struct lima_submit_key)) == 0;
-}
-
-static uint32_t
-lima_submit_hash(const void *key)
-{
- return _mesa_hash_data(key, sizeof(struct lima_submit_key));
-}
-
-bool lima_submit_init(struct lima_context *ctx)
-{
- int fd = lima_screen(ctx->base.screen)->fd;
-
- ctx->submits = _mesa_hash_table_create(ctx, lima_submit_hash, lima_submit_compare);
- if (!ctx->submits)
- return false;
-
- ctx->write_submits = _mesa_hash_table_create(
- ctx, _mesa_hash_pointer, _mesa_key_pointer_equal);
- if (!ctx->write_submits)
- return false;
-
- ctx->in_sync_fd = -1;
-
- for (int i = 0; i < 2; i++) {
- if (drmSyncobjCreate(fd, DRM_SYNCOBJ_CREATE_SIGNALED, ctx->in_sync + i) ||
- drmSyncobjCreate(fd, DRM_SYNCOBJ_CREATE_SIGNALED, ctx->out_sync + i))
- return false;
- }
-
- ctx->base.flush = lima_pipe_flush;
-
- return true;
-}
-
-void lima_submit_fini(struct lima_context *ctx)
-{
- int fd = lima_screen(ctx->base.screen)->fd;
-
- lima_flush(ctx);
-
- for (int i = 0; i < 2; i++) {
- if (ctx->in_sync[i])
- drmSyncobjDestroy(fd, ctx->in_sync[i]);
- if (ctx->out_sync[i])
- drmSyncobjDestroy(fd, ctx->out_sync[i]);
- }
-
- if (ctx->in_sync_fd >= 0)
- close(ctx->in_sync_fd);
-}
+++ /dev/null
-/*
- * Copyright (C) 2018-2019 Lima Project
- *
- * 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 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 COPYRIGHT HOLDER(S) OR AUTHOR(S) 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.
- *
- */
-
-#ifndef H_LIMA_SUBMIT
-#define H_LIMA_SUBMIT
-
-#include <stdbool.h>
-#include <stdint.h>
-
-#include <util/u_dynarray.h>
-
-#include <pipe/p_state.h>
-
-struct lima_context;
-struct lima_bo;
-struct lima_dump;
-struct pipe_surface;
-
-struct lima_submit_key {
- struct pipe_surface *cbuf;
- struct pipe_surface *zsbuf;
-};
-
-struct lima_submit_clear {
- unsigned buffers;
- uint32_t color_8pc;
- uint32_t depth;
- uint32_t stencil;
- uint64_t color_16pc;
-};
-
-struct lima_submit_fb_info {
- int width, height;
- int tiled_w, tiled_h;
- int shift_w, shift_h;
- int block_w, block_h;
- int shift_min;
-};
-
-struct lima_submit {
- int fd;
- struct lima_context *ctx;
-
- struct util_dynarray gem_bos[2];
- struct util_dynarray bos[2];
-
- struct lima_submit_key key;
-
- struct util_dynarray vs_cmd_array;
- struct util_dynarray plbu_cmd_array;
- struct util_dynarray plbu_cmd_head;
-
- unsigned resolve;
-
- int pp_max_stack_size;
-
- struct pipe_scissor_state damage_rect;
-
- struct lima_submit_clear clear;
-
- struct lima_submit_fb_info fb;
-
- /* for dump command stream */
- struct lima_dump *dump;
-};
-
-static inline bool
-lima_submit_has_draw_pending(struct lima_submit *submit)
-{
- return !!submit->plbu_cmd_array.size;
-}
-
-struct lima_submit *lima_submit_get(struct lima_context *ctx);
-
-bool lima_submit_add_bo(struct lima_submit *submit, int pipe,
- struct lima_bo *bo, uint32_t flags);
-void *lima_submit_create_stream_bo(struct lima_submit *submit, int pipe,
- unsigned size, uint32_t *va);
-
-void lima_do_submit(struct lima_submit *submit);
-
-bool lima_submit_init(struct lima_context *ctx);
-void lima_submit_fini(struct lima_context *ctx);
-
-#endif
#include "lima_screen.h"
#include "lima_texture.h"
#include "lima_resource.h"
-#include "lima_submit.h"
+#include "lima_job.h"
#include "lima_util.h"
#include "lima_format.h"
/*
* Note: this function is used by both draw and flush code path,
- * make sure no lima_submit_get() is called inside this.
+ * make sure no lima_job_get() is called inside this.
*/
void
lima_texture_desc_set_res(struct lima_context *ctx, lima_tex_desc *desc,
void
lima_update_textures(struct lima_context *ctx)
{
- struct lima_submit *submit = lima_submit_get(ctx);
+ struct lima_job *job = lima_job_get(ctx);
struct lima_texture_stateobj *lima_tex = &ctx->tex_stateobj;
assert (lima_tex->num_samplers <= 16);
if (!lima_tex->num_samplers || !lima_tex->num_textures)
return;
- /* we always need to add texture bo to submit */
+ /* we always need to add texture bo to job */
for (int i = 0; i < lima_tex->num_samplers; i++) {
struct lima_sampler_view *texture = lima_sampler_view(lima_tex->textures[i]);
struct lima_resource *rsc = lima_resource(texture->base.texture);
- lima_flush_previous_submit_writing_resource(ctx, texture->base.texture);
- lima_submit_add_bo(submit, LIMA_PIPE_PP, rsc->bo, LIMA_SUBMIT_BO_READ);
+ lima_flush_previous_job_writing_resource(ctx, texture->base.texture);
+ lima_job_add_bo(job, LIMA_PIPE_PP, rsc->bo, LIMA_SUBMIT_BO_READ);
}
/* do not regenerate texture desc if no change */
}
lima_dump_command_stream_print(
- submit->dump, descs, size, false, "add textures_desc at va %x\n",
+ job->dump, descs, size, false, "add textures_desc at va %x\n",
lima_ctx_buff_va(ctx, lima_ctx_buff_pp_tex_desc));
lima_dump_texture_descriptor(
- submit->dump, descs, size,
+ job->dump, descs, size,
lima_ctx_buff_va(ctx, lima_ctx_buff_pp_tex_desc) + lima_tex_list_size,
lima_tex_list_size);
}
'lima_query.c',
'lima_bo.c',
'lima_bo.h',
- 'lima_submit.c',
- 'lima_submit.h',
+ 'lima_job.c',
+ 'lima_job.h',
'lima_parser.c',
'lima_parser.h',
'lima_util.c',
projects / mesa.git / commitdiff