From 01ae6a918111196e9cce7a817445db0b11825f9f Mon Sep 17 00:00:00 2001 From: Eric Anholt Date: Tue, 1 May 2018 12:39:31 -0700 Subject: v3d: Rename driver functions from vc5 to v3d. This is the final step of the driver rename. --- src/gallium/drivers/v3d/v3d_blit.c | 96 ++++----- src/gallium/drivers/v3d/v3d_bufmgr.c | 158 +++++++------- src/gallium/drivers/v3d/v3d_bufmgr.h | 50 ++--- src/gallium/drivers/v3d/v3d_cl.c | 24 +-- src/gallium/drivers/v3d/v3d_cl.h | 98 ++++----- src/gallium/drivers/v3d/v3d_context.c | 112 +++++----- src/gallium/drivers/v3d/v3d_context.h | 210 +++++++++--------- src/gallium/drivers/v3d/v3d_fence.c | 38 ++-- src/gallium/drivers/v3d/v3d_format_table.h | 2 +- src/gallium/drivers/v3d/v3d_formats.c | 34 +-- src/gallium/drivers/v3d/v3d_job.c | 188 ++++++++--------- src/gallium/drivers/v3d/v3d_program.c | 264 +++++++++++------------ src/gallium/drivers/v3d/v3d_query.c | 84 ++++---- src/gallium/drivers/v3d/v3d_resource.c | 220 +++++++++---------- src/gallium/drivers/v3d/v3d_resource.h | 48 ++--- src/gallium/drivers/v3d/v3d_screen.c | 72 +++---- src/gallium/drivers/v3d/v3d_screen.h | 22 +- src/gallium/drivers/v3d/v3d_simulator.c | 162 +++++++------- src/gallium/drivers/v3d/v3d_tiling.c | 102 ++++----- src/gallium/drivers/v3d/v3d_tiling.h | 18 +- src/gallium/drivers/v3d/v3d_uniforms.c | 114 +++++----- src/gallium/drivers/v3d/v3dx_context.h | 8 +- src/gallium/drivers/v3d/v3dx_draw.c | 264 +++++++++++------------ src/gallium/drivers/v3d/v3dx_emit.c | 258 +++++++++++------------ src/gallium/drivers/v3d/v3dx_format_table.c | 4 +- src/gallium/drivers/v3d/v3dx_job.c | 4 +- src/gallium/drivers/v3d/v3dx_rcl.c | 74 +++---- src/gallium/drivers/v3d/v3dx_simulator.c | 22 +- src/gallium/drivers/v3d/v3dx_state.c | 316 ++++++++++++++-------------- 29 files changed, 1533 insertions(+), 1533 deletions(-) (limited to 'src/gallium/drivers/v3d') diff --git a/src/gallium/drivers/v3d/v3d_blit.c b/src/gallium/drivers/v3d/v3d_blit.c index 7c67d4561ba..6e609fbe3cb 100644 --- a/src/gallium/drivers/v3d/v3d_blit.c +++ b/src/gallium/drivers/v3d/v3d_blit.c @@ -28,7 +28,7 @@ #if 0 static struct pipe_surface * -vc5_get_blit_surface(struct pipe_context *pctx, +v3d_get_blit_surface(struct pipe_context *pctx, struct pipe_resource *prsc, unsigned level) { struct pipe_surface tmpl; @@ -49,9 +49,9 @@ is_tile_unaligned(unsigned size, unsigned tile_size) } static bool -vc5_tile_blit(struct pipe_context *pctx, const struct pipe_blit_info *info) +v3d_tile_blit(struct pipe_context *pctx, const struct pipe_blit_info *info) { - struct vc5_context *vc5 = vc5_context(pctx); + struct v3d_context *v3d = v3d_context(pctx); bool msaa = (info->src.resource->nr_samples > 1 || info->dst.resource->nr_samples > 1); int tile_width = msaa ? 32 : 64; @@ -95,7 +95,7 @@ vc5_tile_blit(struct pipe_context *pctx, const struct pipe_blit_info *info) * determine the stride (which could be fixed by explicitly supplying * it in the ABI). */ - struct vc5_resource *rsc = vc5_resource(info->src.resource); + struct v3d_resource *rsc = v3d_resource(info->src.resource); uint32_t stride; @@ -123,13 +123,13 @@ vc5_tile_blit(struct pipe_context *pctx, const struct pipe_blit_info *info) } struct pipe_surface *dst_surf = - vc5_get_blit_surface(pctx, info->dst.resource, info->dst.level); + v3d_get_blit_surface(pctx, info->dst.resource, info->dst.level); struct pipe_surface *src_surf = - vc5_get_blit_surface(pctx, info->src.resource, info->src.level); + v3d_get_blit_surface(pctx, info->src.resource, info->src.level); - vc5_flush_jobs_reading_resource(vc5, info->src.resource); + v3d_flush_jobs_reading_resource(v3d, info->src.resource); - struct vc5_job *job = vc5_get_job(vc5, dst_surf, NULL); + struct v3d_job *job = v3d_get_job(v3d, dst_surf, NULL); pipe_surface_reference(&job->color_read, src_surf); /* If we're resolving from MSAA to single sample, we still need to run @@ -154,7 +154,7 @@ vc5_tile_blit(struct pipe_context *pctx, const struct pipe_blit_info *info) job->needs_flush = true; job->resolve |= PIPE_CLEAR_COLOR; - vc5_job_submit(vc5, job); + v3d_job_submit(v3d, job); pipe_surface_reference(&dst_surf, NULL); pipe_surface_reference(&src_surf, NULL); @@ -164,47 +164,47 @@ vc5_tile_blit(struct pipe_context *pctx, const struct pipe_blit_info *info) #endif void -vc5_blitter_save(struct vc5_context *vc5) +v3d_blitter_save(struct v3d_context *v3d) { - util_blitter_save_fragment_constant_buffer_slot(vc5->blitter, - vc5->constbuf[PIPE_SHADER_FRAGMENT].cb); - util_blitter_save_vertex_buffer_slot(vc5->blitter, vc5->vertexbuf.vb); - util_blitter_save_vertex_elements(vc5->blitter, vc5->vtx); - util_blitter_save_vertex_shader(vc5->blitter, vc5->prog.bind_vs); - util_blitter_save_so_targets(vc5->blitter, vc5->streamout.num_targets, - vc5->streamout.targets); - util_blitter_save_rasterizer(vc5->blitter, vc5->rasterizer); - util_blitter_save_viewport(vc5->blitter, &vc5->viewport); - util_blitter_save_scissor(vc5->blitter, &vc5->scissor); - util_blitter_save_fragment_shader(vc5->blitter, vc5->prog.bind_fs); - util_blitter_save_blend(vc5->blitter, vc5->blend); - util_blitter_save_depth_stencil_alpha(vc5->blitter, vc5->zsa); - util_blitter_save_stencil_ref(vc5->blitter, &vc5->stencil_ref); - util_blitter_save_sample_mask(vc5->blitter, vc5->sample_mask); - util_blitter_save_framebuffer(vc5->blitter, &vc5->framebuffer); - util_blitter_save_fragment_sampler_states(vc5->blitter, - vc5->fragtex.num_samplers, - (void **)vc5->fragtex.samplers); - util_blitter_save_fragment_sampler_views(vc5->blitter, - vc5->fragtex.num_textures, vc5->fragtex.textures); - util_blitter_save_so_targets(vc5->blitter, vc5->streamout.num_targets, - vc5->streamout.targets); + util_blitter_save_fragment_constant_buffer_slot(v3d->blitter, + v3d->constbuf[PIPE_SHADER_FRAGMENT].cb); + util_blitter_save_vertex_buffer_slot(v3d->blitter, v3d->vertexbuf.vb); + util_blitter_save_vertex_elements(v3d->blitter, v3d->vtx); + util_blitter_save_vertex_shader(v3d->blitter, v3d->prog.bind_vs); + util_blitter_save_so_targets(v3d->blitter, v3d->streamout.num_targets, + v3d->streamout.targets); + util_blitter_save_rasterizer(v3d->blitter, v3d->rasterizer); + util_blitter_save_viewport(v3d->blitter, &v3d->viewport); + util_blitter_save_scissor(v3d->blitter, &v3d->scissor); + util_blitter_save_fragment_shader(v3d->blitter, v3d->prog.bind_fs); + util_blitter_save_blend(v3d->blitter, v3d->blend); + util_blitter_save_depth_stencil_alpha(v3d->blitter, v3d->zsa); + util_blitter_save_stencil_ref(v3d->blitter, &v3d->stencil_ref); + util_blitter_save_sample_mask(v3d->blitter, v3d->sample_mask); + util_blitter_save_framebuffer(v3d->blitter, &v3d->framebuffer); + util_blitter_save_fragment_sampler_states(v3d->blitter, + v3d->fragtex.num_samplers, + (void **)v3d->fragtex.samplers); + util_blitter_save_fragment_sampler_views(v3d->blitter, + v3d->fragtex.num_textures, v3d->fragtex.textures); + util_blitter_save_so_targets(v3d->blitter, v3d->streamout.num_targets, + v3d->streamout.targets); } static bool -vc5_render_blit(struct pipe_context *ctx, struct pipe_blit_info *info) +v3d_render_blit(struct pipe_context *ctx, struct pipe_blit_info *info) { - struct vc5_context *vc5 = vc5_context(ctx); + struct v3d_context *v3d = v3d_context(ctx); - if (!util_blitter_is_blit_supported(vc5->blitter, info)) { + if (!util_blitter_is_blit_supported(v3d->blitter, info)) { fprintf(stderr, "blit unsupported %s -> %s\n", util_format_short_name(info->src.resource->format), util_format_short_name(info->dst.resource->format)); return false; } - vc5_blitter_save(vc5); - util_blitter_blit(vc5->blitter, info); + v3d_blitter_save(v3d); + util_blitter_blit(v3d->blitter, info); return true; } @@ -213,11 +213,11 @@ vc5_render_blit(struct pipe_context *ctx, struct pipe_blit_info *info) * or R8 texture. */ static void -vc5_stencil_blit(struct pipe_context *ctx, const struct pipe_blit_info *info) +v3d_stencil_blit(struct pipe_context *ctx, const struct pipe_blit_info *info) { - struct vc5_context *vc5 = vc5_context(ctx); - struct vc5_resource *src = vc5_resource(info->src.resource); - struct vc5_resource *dst = vc5_resource(info->dst.resource); + struct v3d_context *v3d = v3d_context(ctx); + struct v3d_resource *src = v3d_resource(info->src.resource); + struct v3d_resource *dst = v3d_resource(info->dst.resource); enum pipe_format src_format, dst_format; if (src->separate_stencil) { @@ -267,8 +267,8 @@ vc5_stencil_blit(struct pipe_context *ctx, const struct pipe_blit_info *info) struct pipe_sampler_view *src_view = ctx->create_sampler_view(ctx, &src->base, &src_tmpl); - vc5_blitter_save(vc5); - util_blitter_blit_generic(vc5->blitter, dst_surf, &info->dst.box, + v3d_blitter_save(v3d); + util_blitter_blit_generic(v3d->blitter, dst_surf, &info->dst.box, src_view, &info->src.box, src->base.width0, src->base.height0, PIPE_MASK_R, @@ -284,19 +284,19 @@ vc5_stencil_blit(struct pipe_context *ctx, const struct pipe_blit_info *info) * Scaling, format conversion, up- and downsampling (resolve) are allowed. */ void -vc5_blit(struct pipe_context *pctx, const struct pipe_blit_info *blit_info) +v3d_blit(struct pipe_context *pctx, const struct pipe_blit_info *blit_info) { struct pipe_blit_info info = *blit_info; if (info.mask & PIPE_MASK_S) { - vc5_stencil_blit(pctx, blit_info); + v3d_stencil_blit(pctx, blit_info); info.mask &= ~PIPE_MASK_S; } #if 0 - if (vc5_tile_blit(pctx, blit_info)) + if (v3d_tile_blit(pctx, blit_info)) return; #endif - vc5_render_blit(pctx, &info); + v3d_render_blit(pctx, &info); } diff --git a/src/gallium/drivers/v3d/v3d_bufmgr.c b/src/gallium/drivers/v3d/v3d_bufmgr.c index ef2a5fa07be..f7a851f9d43 100644 --- a/src/gallium/drivers/v3d/v3d_bufmgr.c +++ b/src/gallium/drivers/v3d/v3d_bufmgr.c @@ -46,12 +46,12 @@ static bool dump_stats = false; static void -vc5_bo_cache_free_all(struct vc5_bo_cache *cache); +v3d_bo_cache_free_all(struct v3d_bo_cache *cache); static void -vc5_bo_dump_stats(struct vc5_screen *screen) +v3d_bo_dump_stats(struct v3d_screen *screen) { - struct vc5_bo_cache *cache = &screen->bo_cache; + struct v3d_bo_cache *cache = &screen->bo_cache; fprintf(stderr, " BOs allocated: %d\n", screen->bo_count); fprintf(stderr, " BOs size: %dkb\n", screen->bo_size / 1024); @@ -59,10 +59,10 @@ vc5_bo_dump_stats(struct vc5_screen *screen) fprintf(stderr, " BOs cached size: %dkb\n", cache->bo_size / 1024); if (!list_empty(&cache->time_list)) { - struct vc5_bo *first = LIST_ENTRY(struct vc5_bo, + struct v3d_bo *first = LIST_ENTRY(struct v3d_bo, cache->time_list.next, time_list); - struct vc5_bo *last = LIST_ENTRY(struct vc5_bo, + struct v3d_bo *last = LIST_ENTRY(struct v3d_bo, cache->time_list.prev, time_list); @@ -79,7 +79,7 @@ vc5_bo_dump_stats(struct vc5_screen *screen) } static void -vc5_bo_remove_from_cache(struct vc5_bo_cache *cache, struct vc5_bo *bo) +v3d_bo_remove_from_cache(struct v3d_bo_cache *cache, struct v3d_bo *bo) { list_del(&bo->time_list); list_del(&bo->size_list); @@ -87,32 +87,32 @@ vc5_bo_remove_from_cache(struct vc5_bo_cache *cache, struct vc5_bo *bo) cache->bo_size -= bo->size; } -static struct vc5_bo * -vc5_bo_from_cache(struct vc5_screen *screen, uint32_t size, const char *name) +static struct v3d_bo * +v3d_bo_from_cache(struct v3d_screen *screen, uint32_t size, const char *name) { - struct vc5_bo_cache *cache = &screen->bo_cache; + struct v3d_bo_cache *cache = &screen->bo_cache; uint32_t page_index = size / 4096 - 1; if (cache->size_list_size <= page_index) return NULL; - struct vc5_bo *bo = NULL; + struct v3d_bo *bo = NULL; mtx_lock(&cache->lock); if (!list_empty(&cache->size_list[page_index])) { - bo = LIST_ENTRY(struct vc5_bo, cache->size_list[page_index].next, + bo = LIST_ENTRY(struct v3d_bo, cache->size_list[page_index].next, size_list); /* Check that the BO has gone idle. If not, then we want to * allocate something new instead, since we assume that the * user will proceed to CPU map it and fill it with stuff. */ - if (!vc5_bo_wait(bo, 0, NULL)) { + if (!v3d_bo_wait(bo, 0, NULL)) { mtx_unlock(&cache->lock); return NULL; } pipe_reference_init(&bo->reference, 1); - vc5_bo_remove_from_cache(cache, bo); + v3d_bo_remove_from_cache(cache, bo); bo->name = name; } @@ -120,25 +120,25 @@ vc5_bo_from_cache(struct vc5_screen *screen, uint32_t size, const char *name) return bo; } -struct vc5_bo * -vc5_bo_alloc(struct vc5_screen *screen, uint32_t size, const char *name) +struct v3d_bo * +v3d_bo_alloc(struct v3d_screen *screen, uint32_t size, const char *name) { - struct vc5_bo *bo; + struct v3d_bo *bo; int ret; size = align(size, 4096); - bo = vc5_bo_from_cache(screen, size, name); + bo = v3d_bo_from_cache(screen, size, name); if (bo) { if (dump_stats) { fprintf(stderr, "Allocated %s %dkb from cache:\n", name, size / 1024); - vc5_bo_dump_stats(screen); + v3d_bo_dump_stats(screen); } return bo; } - bo = CALLOC_STRUCT(vc5_bo); + bo = CALLOC_STRUCT(v3d_bo); if (!bo) return NULL; @@ -156,7 +156,7 @@ vc5_bo_alloc(struct vc5_screen *screen, uint32_t size, const char *name) .size = size }; - ret = vc5_ioctl(screen->fd, DRM_IOCTL_V3D_CREATE_BO, &create); + ret = v3d_ioctl(screen->fd, DRM_IOCTL_V3D_CREATE_BO, &create); bo->handle = create.handle; bo->offset = create.offset; @@ -164,7 +164,7 @@ vc5_bo_alloc(struct vc5_screen *screen, uint32_t size, const char *name) if (!list_empty(&screen->bo_cache.time_list) && !cleared_and_retried) { cleared_and_retried = true; - vc5_bo_cache_free_all(&screen->bo_cache); + v3d_bo_cache_free_all(&screen->bo_cache); goto retry; } @@ -176,31 +176,31 @@ vc5_bo_alloc(struct vc5_screen *screen, uint32_t size, const char *name) screen->bo_size += bo->size; if (dump_stats) { fprintf(stderr, "Allocated %s %dkb:\n", name, size / 1024); - vc5_bo_dump_stats(screen); + v3d_bo_dump_stats(screen); } return bo; } void -vc5_bo_last_unreference(struct vc5_bo *bo) +v3d_bo_last_unreference(struct v3d_bo *bo) { - struct vc5_screen *screen = bo->screen; + struct v3d_screen *screen = bo->screen; struct timespec time; clock_gettime(CLOCK_MONOTONIC, &time); mtx_lock(&screen->bo_cache.lock); - vc5_bo_last_unreference_locked_timed(bo, time.tv_sec); + v3d_bo_last_unreference_locked_timed(bo, time.tv_sec); mtx_unlock(&screen->bo_cache.lock); } static void -vc5_bo_free(struct vc5_bo *bo) +v3d_bo_free(struct v3d_bo *bo) { - struct vc5_screen *screen = bo->screen; + struct v3d_screen *screen = bo->screen; if (bo->map) { - if (using_vc5_simulator && bo->name && + if (using_v3d_simulator && bo->name && strcmp(bo->name, "winsys") == 0) { free(bo->map); } else { @@ -212,7 +212,7 @@ vc5_bo_free(struct vc5_bo *bo) struct drm_gem_close c; memset(&c, 0, sizeof(c)); c.handle = bo->handle; - int ret = vc5_ioctl(screen->fd, DRM_IOCTL_GEM_CLOSE, &c); + int ret = v3d_ioctl(screen->fd, DRM_IOCTL_GEM_CLOSE, &c); if (ret != 0) fprintf(stderr, "close object %d: %s\n", bo->handle, strerror(errno)); @@ -224,30 +224,30 @@ vc5_bo_free(struct vc5_bo *bo) bo->name ? bo->name : "", bo->name ? " " : "", bo->size / 1024); - vc5_bo_dump_stats(screen); + v3d_bo_dump_stats(screen); } free(bo); } static void -free_stale_bos(struct vc5_screen *screen, time_t time) +free_stale_bos(struct v3d_screen *screen, time_t time) { - struct vc5_bo_cache *cache = &screen->bo_cache; + struct v3d_bo_cache *cache = &screen->bo_cache; bool freed_any = false; - list_for_each_entry_safe(struct vc5_bo, bo, &cache->time_list, + list_for_each_entry_safe(struct v3d_bo, bo, &cache->time_list, time_list) { if (dump_stats && !freed_any) { fprintf(stderr, "Freeing stale BOs:\n"); - vc5_bo_dump_stats(screen); + v3d_bo_dump_stats(screen); freed_any = true; } /* If it's more than a second old, free it. */ if (time - bo->free_time > 2) { - vc5_bo_remove_from_cache(cache, bo); - vc5_bo_free(bo); + v3d_bo_remove_from_cache(cache, bo); + v3d_bo_free(bo); } else { break; } @@ -255,31 +255,31 @@ free_stale_bos(struct vc5_screen *screen, time_t time) if (dump_stats && freed_any) { fprintf(stderr, "Freed stale BOs:\n"); - vc5_bo_dump_stats(screen); + v3d_bo_dump_stats(screen); } } static void -vc5_bo_cache_free_all(struct vc5_bo_cache *cache) +v3d_bo_cache_free_all(struct v3d_bo_cache *cache) { mtx_lock(&cache->lock); - list_for_each_entry_safe(struct vc5_bo, bo, &cache->time_list, + list_for_each_entry_safe(struct v3d_bo, bo, &cache->time_list, time_list) { - vc5_bo_remove_from_cache(cache, bo); - vc5_bo_free(bo); + v3d_bo_remove_from_cache(cache, bo); + v3d_bo_free(bo); } mtx_unlock(&cache->lock); } void -vc5_bo_last_unreference_locked_timed(struct vc5_bo *bo, time_t time) +v3d_bo_last_unreference_locked_timed(struct v3d_bo *bo, time_t time) { - struct vc5_screen *screen = bo->screen; - struct vc5_bo_cache *cache = &screen->bo_cache; + struct v3d_screen *screen = bo->screen; + struct v3d_bo_cache *cache = &screen->bo_cache; uint32_t page_index = bo->size / 4096 - 1; if (!bo->private) { - vc5_bo_free(bo); + v3d_bo_free(bo); return; } @@ -316,19 +316,19 @@ vc5_bo_last_unreference_locked_timed(struct vc5_bo *bo, time_t time) if (dump_stats) { fprintf(stderr, "Freed %s %dkb to cache:\n", bo->name, bo->size / 1024); - vc5_bo_dump_stats(screen); + v3d_bo_dump_stats(screen); } bo->name = NULL; free_stale_bos(screen, time); } -static struct vc5_bo * -vc5_bo_open_handle(struct vc5_screen *screen, +static struct v3d_bo * +v3d_bo_open_handle(struct v3d_screen *screen, uint32_t winsys_stride, uint32_t handle, uint32_t size) { - struct vc5_bo *bo; + struct v3d_bo *bo; assert(size); @@ -340,7 +340,7 @@ vc5_bo_open_handle(struct vc5_screen *screen, goto done; } - bo = CALLOC_STRUCT(vc5_bo); + bo = CALLOC_STRUCT(v3d_bo); pipe_reference_init(&bo->reference, 1); bo->screen = screen; bo->handle = handle; @@ -349,7 +349,7 @@ vc5_bo_open_handle(struct vc5_screen *screen, bo->private = false; #ifdef USE_V3D_SIMULATOR - vc5_simulator_open_from_handle(screen->fd, winsys_stride, + v3d_simulator_open_from_handle(screen->fd, winsys_stride, bo->handle, bo->size); bo->map = malloc(bo->size); #endif @@ -357,7 +357,7 @@ vc5_bo_open_handle(struct vc5_screen *screen, struct drm_v3d_get_bo_offset get = { .handle = handle, }; - int ret = vc5_ioctl(screen->fd, DRM_IOCTL_V3D_GET_BO_OFFSET, &get); + int ret = v3d_ioctl(screen->fd, DRM_IOCTL_V3D_GET_BO_OFFSET, &get); if (ret) { fprintf(stderr, "Failed to get BO offset: %s\n", strerror(errno)); @@ -375,31 +375,31 @@ done: return bo; } -struct vc5_bo * -vc5_bo_open_name(struct vc5_screen *screen, uint32_t name, +struct v3d_bo * +v3d_bo_open_name(struct v3d_screen *screen, uint32_t name, uint32_t winsys_stride) { struct drm_gem_open o = { .name = name }; - int ret = vc5_ioctl(screen->fd, DRM_IOCTL_GEM_OPEN, &o); + int ret = v3d_ioctl(screen->fd, DRM_IOCTL_GEM_OPEN, &o); if (ret) { fprintf(stderr, "Failed to open bo %d: %s\n", name, strerror(errno)); return NULL; } - return vc5_bo_open_handle(screen, winsys_stride, o.handle, o.size); + return v3d_bo_open_handle(screen, winsys_stride, o.handle, o.size); } -struct vc5_bo * -vc5_bo_open_dmabuf(struct vc5_screen *screen, int fd, uint32_t winsys_stride) +struct v3d_bo * +v3d_bo_open_dmabuf(struct v3d_screen *screen, int fd, uint32_t winsys_stride) { uint32_t handle; int ret = drmPrimeFDToHandle(screen->fd, fd, &handle); int size; if (ret) { - fprintf(stderr, "Failed to get vc5 handle for dmabuf %d\n", fd); + fprintf(stderr, "Failed to get v3d handle for dmabuf %d\n", fd); return NULL; } @@ -410,11 +410,11 @@ vc5_bo_open_dmabuf(struct vc5_screen *screen, int fd, uint32_t winsys_stride) return NULL; } - return vc5_bo_open_handle(screen, winsys_stride, handle, size); + return v3d_bo_open_handle(screen, winsys_stride, handle, size); } int -vc5_bo_get_dmabuf(struct vc5_bo *bo) +v3d_bo_get_dmabuf(struct v3d_bo *bo) { int fd; int ret = drmPrimeHandleToFD(bo->screen->fd, bo->handle, @@ -434,12 +434,12 @@ vc5_bo_get_dmabuf(struct vc5_bo *bo) } bool -vc5_bo_flink(struct vc5_bo *bo, uint32_t *name) +v3d_bo_flink(struct v3d_bo *bo, uint32_t *name) { struct drm_gem_flink flink = { .handle = bo->handle, }; - int ret = vc5_ioctl(bo->screen->fd, DRM_IOCTL_GEM_FLINK, &flink); + int ret = v3d_ioctl(bo->screen->fd, DRM_IOCTL_GEM_FLINK, &flink); if (ret) { fprintf(stderr, "Failed to flink bo %d: %s\n", bo->handle, strerror(errno)); @@ -453,13 +453,13 @@ vc5_bo_flink(struct vc5_bo *bo, uint32_t *name) return true; } -static int vc5_wait_bo_ioctl(int fd, uint32_t handle, uint64_t timeout_ns) +static int v3d_wait_bo_ioctl(int fd, uint32_t handle, uint64_t timeout_ns) { struct drm_v3d_wait_bo wait = { .handle = handle, .timeout_ns = timeout_ns, }; - int ret = vc5_ioctl(fd, DRM_IOCTL_V3D_WAIT_BO, &wait); + int ret = v3d_ioctl(fd, DRM_IOCTL_V3D_WAIT_BO, &wait); if (ret == -1) return -errno; else @@ -468,18 +468,18 @@ static int vc5_wait_bo_ioctl(int fd, uint32_t handle, uint64_t timeout_ns) } bool -vc5_bo_wait(struct vc5_bo *bo, uint64_t timeout_ns, const char *reason) +v3d_bo_wait(struct v3d_bo *bo, uint64_t timeout_ns, const char *reason) { - struct vc5_screen *screen = bo->screen; + struct v3d_screen *screen = bo->screen; if (unlikely(V3D_DEBUG & V3D_DEBUG_PERF) && timeout_ns && reason) { - if (vc5_wait_bo_ioctl(screen->fd, bo->handle, 0) == -ETIME) { + if (v3d_wait_bo_ioctl(screen->fd, bo->handle, 0) == -ETIME) { fprintf(stderr, "Blocking on %s BO for %s\n", bo->name, reason); } } - int ret = vc5_wait_bo_ioctl(screen->fd, bo->handle, timeout_ns); + int ret = v3d_wait_bo_ioctl(screen->fd, bo->handle, timeout_ns); if (ret) { if (ret != -ETIME) { fprintf(stderr, "wait failed: %d\n", ret); @@ -493,7 +493,7 @@ vc5_bo_wait(struct vc5_bo *bo, uint64_t timeout_ns, const char *reason) } void * -vc5_bo_map_unsynchronized(struct vc5_bo *bo) +v3d_bo_map_unsynchronized(struct v3d_bo *bo) { uint64_t offset; int ret; @@ -504,7 +504,7 @@ vc5_bo_map_unsynchronized(struct vc5_bo *bo) struct drm_v3d_mmap_bo map; memset(&map, 0, sizeof(map)); map.handle = bo->handle; - ret = vc5_ioctl(bo->screen->fd, DRM_IOCTL_V3D_MMAP_BO, &map); + ret = v3d_ioctl(bo->screen->fd, DRM_IOCTL_V3D_MMAP_BO, &map); offset = map.offset; if (ret != 0) { fprintf(stderr, "map ioctl failure\n"); @@ -524,11 +524,11 @@ vc5_bo_map_unsynchronized(struct vc5_bo *bo) } void * -vc5_bo_map(struct vc5_bo *bo) +v3d_bo_map(struct v3d_bo *bo) { - void *map = vc5_bo_map_unsynchronized(bo); + void *map = v3d_bo_map_unsynchronized(bo); - bool ok = vc5_bo_wait(bo, PIPE_TIMEOUT_INFINITE, "bo map"); + bool ok = v3d_bo_wait(bo, PIPE_TIMEOUT_INFINITE, "bo map"); if (!ok) { fprintf(stderr, "BO wait for map failed\n"); abort(); @@ -538,15 +538,15 @@ vc5_bo_map(struct vc5_bo *bo) } void -vc5_bufmgr_destroy(struct pipe_screen *pscreen) +v3d_bufmgr_destroy(struct pipe_screen *pscreen) { - struct vc5_screen *screen = vc5_screen(pscreen); - struct vc5_bo_cache *cache = &screen->bo_cache; + struct v3d_screen *screen = v3d_screen(pscreen); + struct v3d_bo_cache *cache = &screen->bo_cache; - vc5_bo_cache_free_all(cache); + v3d_bo_cache_free_all(cache); if (dump_stats) { fprintf(stderr, "BO stats after screen destroy:\n"); - vc5_bo_dump_stats(screen); + v3d_bo_dump_stats(screen); } } diff --git a/src/gallium/drivers/v3d/v3d_bufmgr.h b/src/gallium/drivers/v3d/v3d_bufmgr.h index 4519a206026..8fbde5ae9af 100644 --- a/src/gallium/drivers/v3d/v3d_bufmgr.h +++ b/src/gallium/drivers/v3d/v3d_bufmgr.h @@ -30,11 +30,11 @@ #include "util/list.h" #include "v3d_screen.h" -struct vc5_context; +struct v3d_context; -struct vc5_bo { +struct v3d_bo { struct pipe_reference reference; - struct vc5_screen *screen; + struct v3d_screen *screen; void *map; const char *name; uint32_t handle; @@ -56,43 +56,43 @@ struct vc5_bo { bool private; }; -struct vc5_bo *vc5_bo_alloc(struct vc5_screen *screen, uint32_t size, +struct v3d_bo *v3d_bo_alloc(struct v3d_screen *screen, uint32_t size, const char *name); -void vc5_bo_last_unreference(struct vc5_bo *bo); -void vc5_bo_last_unreference_locked_timed(struct vc5_bo *bo, time_t time); -struct vc5_bo *vc5_bo_open_name(struct vc5_screen *screen, uint32_t name, +void v3d_bo_last_unreference(struct v3d_bo *bo); +void v3d_bo_last_unreference_locked_timed(struct v3d_bo *bo, time_t time); +struct v3d_bo *v3d_bo_open_name(struct v3d_screen *screen, uint32_t name, uint32_t winsys_stride); -struct vc5_bo *vc5_bo_open_dmabuf(struct vc5_screen *screen, int fd, +struct v3d_bo *v3d_bo_open_dmabuf(struct v3d_screen *screen, int fd, uint32_t winsys_stride); -bool vc5_bo_flink(struct vc5_bo *bo, uint32_t *name); -int vc5_bo_get_dmabuf(struct vc5_bo *bo); +bool v3d_bo_flink(struct v3d_bo *bo, uint32_t *name); +int v3d_bo_get_dmabuf(struct v3d_bo *bo); static inline void -vc5_bo_set_reference(struct vc5_bo **old_bo, struct vc5_bo *new_bo) +v3d_bo_set_reference(struct v3d_bo **old_bo, struct v3d_bo *new_bo) { if (pipe_reference(&(*old_bo)->reference, &new_bo->reference)) - vc5_bo_last_unreference(*old_bo); + v3d_bo_last_unreference(*old_bo); *old_bo = new_bo; } -static inline struct vc5_bo * -vc5_bo_reference(struct vc5_bo *bo) +static inline struct v3d_bo * +v3d_bo_reference(struct v3d_bo *bo) { pipe_reference(NULL, &bo->reference); return bo; } static inline void -vc5_bo_unreference(struct vc5_bo **bo) +v3d_bo_unreference(struct v3d_bo **bo) { - struct vc5_screen *screen; + struct v3d_screen *screen; if (!*bo) return; if ((*bo)->private) { /* Avoid the mutex for private BOs */ if (pipe_reference(&(*bo)->reference, NULL)) - vc5_bo_last_unreference(*bo); + v3d_bo_last_unreference(*bo); } else { screen = (*bo)->screen; mtx_lock(&screen->bo_handles_mutex); @@ -100,7 +100,7 @@ vc5_bo_unreference(struct vc5_bo **bo) if (pipe_reference(&(*bo)->reference, NULL)) { util_hash_table_remove(screen->bo_handles, (void *)(uintptr_t)(*bo)->handle); - vc5_bo_last_unreference(*bo); + v3d_bo_last_unreference(*bo); } mtx_unlock(&screen->bo_handles_mutex); @@ -110,31 +110,31 @@ vc5_bo_unreference(struct vc5_bo **bo) } static inline void -vc5_bo_unreference_locked_timed(struct vc5_bo **bo, time_t time) +v3d_bo_unreference_locked_timed(struct v3d_bo **bo, time_t time) { if (!*bo) return; if (pipe_reference(&(*bo)->reference, NULL)) - vc5_bo_last_unreference_locked_timed(*bo, time); + v3d_bo_last_unreference_locked_timed(*bo, time); *bo = NULL; } void * -vc5_bo_map(struct vc5_bo *bo); +v3d_bo_map(struct v3d_bo *bo); void * -vc5_bo_map_unsynchronized(struct vc5_bo *bo); +v3d_bo_map_unsynchronized(struct v3d_bo *bo); bool -vc5_bo_wait(struct vc5_bo *bo, uint64_t timeout_ns, const char *reason); +v3d_bo_wait(struct v3d_bo *bo, uint64_t timeout_ns, const char *reason); bool -vc5_wait_seqno(struct vc5_screen *screen, uint64_t seqno, uint64_t timeout_ns, +v3d_wait_seqno(struct v3d_screen *screen, uint64_t seqno, uint64_t timeout_ns, const char *reason); void -vc5_bufmgr_destroy(struct pipe_screen *pscreen); +v3d_bufmgr_destroy(struct pipe_screen *pscreen); #endif /* VC5_BUFMGR_H */ diff --git a/src/gallium/drivers/v3d/v3d_cl.c b/src/gallium/drivers/v3d/v3d_cl.c index 2ffb7ea9a2c..94e83a894a4 100644 --- a/src/gallium/drivers/v3d/v3d_cl.c +++ b/src/gallium/drivers/v3d/v3d_cl.c @@ -30,7 +30,7 @@ #include "broadcom/cle/v3dx_pack.h" void -vc5_init_cl(struct vc5_job *job, struct vc5_cl *cl) +v3d_init_cl(struct v3d_job *job, struct v3d_cl *cl) { cl->base = NULL; cl->next = cl->base; @@ -39,7 +39,7 @@ vc5_init_cl(struct vc5_job *job, struct vc5_cl *cl) } uint32_t -vc5_cl_ensure_space(struct vc5_cl *cl, uint32_t space, uint32_t alignment) +v3d_cl_ensure_space(struct v3d_cl *cl, uint32_t space, uint32_t alignment) { uint32_t offset = align(cl_offset(cl), alignment); @@ -48,9 +48,9 @@ vc5_cl_ensure_space(struct vc5_cl *cl, uint32_t space, uint32_t alignment) return offset; } - vc5_bo_unreference(&cl->bo); - cl->bo = vc5_bo_alloc(cl->job->vc5->screen, align(space, 4096), "CL"); - cl->base = vc5_bo_map(cl->bo); + v3d_bo_unreference(&cl->bo); + cl->bo = v3d_bo_alloc(cl->job->v3d->screen, align(space, 4096), "CL"); + cl->base = v3d_bo_map(cl->bo); cl->size = cl->bo->size; cl->next = cl->base; @@ -58,12 +58,12 @@ vc5_cl_ensure_space(struct vc5_cl *cl, uint32_t space, uint32_t alignment) } void -vc5_cl_ensure_space_with_branch(struct vc5_cl *cl, uint32_t space) +v3d_cl_ensure_space_with_branch(struct v3d_cl *cl, uint32_t space) { if (cl_offset(cl) + space + cl_packet_length(BRANCH) <= cl->size) return; - struct vc5_bo *new_bo = vc5_bo_alloc(cl->job->vc5->screen, 4096, "CL"); + struct v3d_bo *new_bo = v3d_bo_alloc(cl->job->v3d->screen, 4096, "CL"); assert(space <= new_bo->size); /* Chain to the new BO from the old one. */ @@ -71,20 +71,20 @@ vc5_cl_ensure_space_with_branch(struct vc5_cl *cl, uint32_t space) cl_emit(cl, BRANCH, branch) { branch.address = cl_address(new_bo, 0); } - vc5_bo_unreference(&cl->bo); + v3d_bo_unreference(&cl->bo); } else { /* Root the first RCL/BCL BO in the job. */ - vc5_job_add_bo(cl->job, cl->bo); + v3d_job_add_bo(cl->job, cl->bo); } cl->bo = new_bo; - cl->base = vc5_bo_map(cl->bo); + cl->base = v3d_bo_map(cl->bo); cl->size = cl->bo->size; cl->next = cl->base; } void -vc5_destroy_cl(struct vc5_cl *cl) +v3d_destroy_cl(struct v3d_cl *cl) { - vc5_bo_unreference(&cl->bo); + v3d_bo_unreference(&cl->bo); } diff --git a/src/gallium/drivers/v3d/v3d_cl.h b/src/gallium/drivers/v3d/v3d_cl.h index 7025b5a672b..1f3754f29f5 100644 --- a/src/gallium/drivers/v3d/v3d_cl.h +++ b/src/gallium/drivers/v3d/v3d_cl.h @@ -29,70 +29,70 @@ #include "util/u_math.h" #include "util/macros.h" -struct vc5_bo; -struct vc5_job; -struct vc5_cl; +struct v3d_bo; +struct v3d_job; +struct v3d_cl; /** * Undefined structure, used for typechecking that you're passing the pointers * to these functions correctly. */ -struct vc5_cl_out; +struct v3d_cl_out; /** A reference to a BO used in the CL packing functions */ -struct vc5_cl_reloc { - struct vc5_bo *bo; +struct v3d_cl_reloc { + struct v3d_bo *bo; uint32_t offset; }; -static inline void cl_pack_emit_reloc(struct vc5_cl *cl, const struct vc5_cl_reloc *); +static inline void cl_pack_emit_reloc(struct v3d_cl *cl, const struct v3d_cl_reloc *); -#define __gen_user_data struct vc5_cl -#define __gen_address_type struct vc5_cl_reloc +#define __gen_user_data struct v3d_cl +#define __gen_address_type struct v3d_cl_reloc #define __gen_address_offset(reloc) (((reloc)->bo ? (reloc)->bo->offset : 0) + \ (reloc)->offset) #define __gen_emit_reloc cl_pack_emit_reloc -struct vc5_cl { +struct v3d_cl { void *base; - struct vc5_job *job; - struct vc5_cl_out *next; - struct vc5_bo *bo; + struct v3d_job *job; + struct v3d_cl_out *next; + struct v3d_bo *bo; uint32_t size; }; -void vc5_init_cl(struct vc5_job *job, struct vc5_cl *cl); -void vc5_destroy_cl(struct vc5_cl *cl); -void vc5_dump_cl(void *cl, uint32_t size, bool is_render); -uint32_t vc5_gem_hindex(struct vc5_job *job, struct vc5_bo *bo); +void v3d_init_cl(struct v3d_job *job, struct v3d_cl *cl); +void v3d_destroy_cl(struct v3d_cl *cl); +void v3d_dump_cl(void *cl, uint32_t size, bool is_render); +uint32_t v3d_gem_hindex(struct v3d_job *job, struct v3d_bo *bo); struct PACKED unaligned_16 { uint16_t x; }; struct PACKED unaligned_32 { uint32_t x; }; -static inline uint32_t cl_offset(struct vc5_cl *cl) +static inline uint32_t cl_offset(struct v3d_cl *cl) { return (char *)cl->next - (char *)cl->base; } -static inline struct vc5_cl_reloc cl_get_address(struct vc5_cl *cl) +static inline struct v3d_cl_reloc cl_get_address(struct v3d_cl *cl) { - return (struct vc5_cl_reloc){ .bo = cl->bo, .offset = cl_offset(cl) }; + return (struct v3d_cl_reloc){ .bo = cl->bo, .offset = cl_offset(cl) }; } static inline void -cl_advance(struct vc5_cl_out **cl, uint32_t n) +cl_advance(struct v3d_cl_out **cl, uint32_t n) { - (*cl) = (struct vc5_cl_out *)((char *)(*cl) + n); + (*cl) = (struct v3d_cl_out *)((char *)(*cl) + n); } -static inline struct vc5_cl_out * -cl_start(struct vc5_cl *cl) +static inline struct v3d_cl_out * +cl_start(struct v3d_cl *cl) { return cl->next; } static inline void -cl_end(struct vc5_cl *cl, struct vc5_cl_out *next) +cl_end(struct v3d_cl *cl, struct v3d_cl_out *next) { cl->next = next; assert(cl_offset(cl) <= cl->size); @@ -100,71 +100,71 @@ cl_end(struct vc5_cl *cl, struct vc5_cl_out *next) static inline void -put_unaligned_32(struct vc5_cl_out *ptr, uint32_t val) +put_unaligned_32(struct v3d_cl_out *ptr, uint32_t val) { struct unaligned_32 *p = (void *)ptr; p->x = val; } static inline void -put_unaligned_16(struct vc5_cl_out *ptr, uint16_t val) +put_unaligned_16(struct v3d_cl_out *ptr, uint16_t val) { struct unaligned_16 *p = (void *)ptr; p->x = val; } static inline void -cl_u8(struct vc5_cl_out **cl, uint8_t n) +cl_u8(struct v3d_cl_out **cl, uint8_t n) { *(uint8_t *)(*cl) = n; cl_advance(cl, 1); } static inline void -cl_u16(struct vc5_cl_out **cl, uint16_t n) +cl_u16(struct v3d_cl_out **cl, uint16_t n) { put_unaligned_16(*cl, n); cl_advance(cl, 2); } static inline void -cl_u32(struct vc5_cl_out **cl, uint32_t n) +cl_u32(struct v3d_cl_out **cl, uint32_t n) { put_unaligned_32(*cl, n); cl_advance(cl, 4); } static inline void -cl_aligned_u32(struct vc5_cl_out **cl, uint32_t n) +cl_aligned_u32(struct v3d_cl_out **cl, uint32_t n) { *(uint32_t *)(*cl) = n; cl_advance(cl, 4); } static inline void -cl_aligned_reloc(struct vc5_cl *cl, - struct vc5_cl_out **cl_out, - struct vc5_bo *bo, uint32_t offset) +cl_aligned_reloc(struct v3d_cl *cl, + struct v3d_cl_out **cl_out, + struct v3d_bo *bo, uint32_t offset) { cl_aligned_u32(cl_out, bo->offset + offset); - vc5_job_add_bo(cl->job, bo); + v3d_job_add_bo(cl->job, bo); } static inline void -cl_ptr(struct vc5_cl_out **cl, void *ptr) +cl_ptr(struct v3d_cl_out **cl, void *ptr) { - *(struct vc5_cl_out **)(*cl) = ptr; + *(struct v3d_cl_out **)(*cl) = ptr; cl_advance(cl, sizeof(void *)); } static inline void -cl_f(struct vc5_cl_out **cl, float f) +cl_f(struct v3d_cl_out **cl, float f) { cl_u32(cl, fui(f)); } static inline void -cl_aligned_f(struct vc5_cl_out **cl, float f) +cl_aligned_f(struct v3d_cl_out **cl, float f) { cl_aligned_u32(cl, fui(f)); } @@ -172,18 +172,18 @@ cl_aligned_f(struct vc5_cl_out **cl, float f) /** * Reference to a BO with its associated offset, used in the pack process. */ -static inline struct vc5_cl_reloc -cl_address(struct vc5_bo *bo, uint32_t offset) +static inline struct v3d_cl_reloc +cl_address(struct v3d_bo *bo, uint32_t offset) { - struct vc5_cl_reloc reloc = { + struct v3d_cl_reloc reloc = { .bo = bo, .offset = offset, }; return reloc; } -uint32_t vc5_cl_ensure_space(struct vc5_cl *cl, uint32_t size, uint32_t align); -void vc5_cl_ensure_space_with_branch(struct vc5_cl *cl, uint32_t size); +uint32_t v3d_cl_ensure_space(struct v3d_cl *cl, uint32_t size, uint32_t align); +void v3d_cl_ensure_space_with_branch(struct v3d_cl *cl, uint32_t size); #define cl_packet_header(packet) V3DX(packet ## _header) #define cl_packet_length(packet) V3DX(packet ## _length) @@ -191,7 +191,7 @@ void vc5_cl_ensure_space_with_branch(struct vc5_cl *cl, uint32_t size); #define cl_packet_struct(packet) V3DX(packet) static inline void * -cl_get_emit_space(struct vc5_cl_out **cl, size_t size) +cl_get_emit_space(struct v3d_cl_out **cl, size_t size) { void *addr = *cl; cl_advance(cl, size); @@ -219,7 +219,7 @@ cl_get_emit_space(struct vc5_cl_out **cl, size_t size) *_loop_terminate = &name; \ __builtin_expect(_loop_terminate != NULL, 1); \ ({ \ - struct vc5_cl_out *cl_out = cl_start(cl); \ + struct v3d_cl_out *cl_out = cl_start(cl); \ cl_packet_pack(packet)(cl, (uint8_t *)cl_out, &name); \ cl_advance(&cl_out, cl_packet_length(packet)); \ cl_end(cl, cl_out); \ @@ -233,7 +233,7 @@ cl_get_emit_space(struct vc5_cl_out **cl, size_t size) *_loop_terminate = &name; \ __builtin_expect(_loop_terminate != NULL, 1); \ ({ \ - struct vc5_cl_out *cl_out = cl_start(cl); \ + struct v3d_cl_out *cl_out = cl_start(cl); \ uint8_t packed[cl_packet_length(packet)]; \ cl_packet_pack(packet)(cl, packed, &name); \ for (int _i = 0; _i < cl_packet_length(packet); _i++) \ @@ -270,10 +270,10 @@ cl_get_emit_space(struct vc5_cl_out **cl, size_t size) * for this exec. */ static inline void -cl_pack_emit_reloc(struct vc5_cl *cl, const struct vc5_cl_reloc *reloc) +cl_pack_emit_reloc(struct v3d_cl *cl, const struct v3d_cl_reloc *reloc) { if (reloc->bo) - vc5_job_add_bo(cl->job, reloc->bo); + v3d_job_add_bo(cl->job, reloc->bo); } #endif /* VC5_CL_H */ diff --git a/src/gallium/drivers/v3d/v3d_context.c b/src/gallium/drivers/v3d/v3d_context.c index cb37eba3841..cef32ceb069 100644 --- a/src/gallium/drivers/v3d/v3d_context.c +++ b/src/gallium/drivers/v3d/v3d_context.c @@ -39,106 +39,106 @@ #include "v3d_resource.h" void -vc5_flush(struct pipe_context *pctx) +v3d_flush(struct pipe_context *pctx) { - struct vc5_context *vc5 = vc5_context(pctx); + struct v3d_context *v3d = v3d_context(pctx); struct hash_entry *entry; - hash_table_foreach(vc5->jobs, entry) { - struct vc5_job *job = entry->data; - vc5_job_submit(vc5, job); + hash_table_foreach(v3d->jobs, entry) { + struct v3d_job *job = entry->data; + v3d_job_submit(v3d, job); } } static void -vc5_pipe_flush(struct pipe_context *pctx, struct pipe_fence_handle **fence, +v3d_pipe_flush(struct pipe_context *pctx, struct pipe_fence_handle **fence, unsigned flags) { - struct vc5_context *vc5 = vc5_context(pctx); + struct v3d_context *v3d = v3d_context(pctx); - vc5_flush(pctx); + v3d_flush(pctx); if (fence) { struct pipe_screen *screen = pctx->screen; - struct vc5_fence *f = vc5_fence_create(vc5); + struct v3d_fence *f = v3d_fence_create(v3d); screen->fence_reference(screen, fence, NULL); *fence = (struct pipe_fence_handle *)f; } } static void -vc5_invalidate_resource(struct pipe_context *pctx, struct pipe_resource *prsc) +v3d_invalidate_resource(struct pipe_context *pctx, struct pipe_resource *prsc) { - struct vc5_context *vc5 = vc5_context(pctx); - struct vc5_resource *rsc = vc5_resource(prsc); + struct v3d_context *v3d = v3d_context(pctx); + struct v3d_resource *rsc = v3d_resource(prsc); rsc->initialized_buffers = 0; - struct hash_entry *entry = _mesa_hash_table_search(vc5->write_jobs, + struct hash_entry *entry = _mesa_hash_table_search(v3d->write_jobs, prsc); if (!entry) return; - struct vc5_job *job = entry->data; + struct v3d_job *job = entry->data; if (job->key.zsbuf && job->key.zsbuf->texture == prsc) job->resolve &= ~(PIPE_CLEAR_DEPTH | PIPE_CLEAR_STENCIL); } static void -vc5_context_destroy(struct pipe_context *pctx) +v3d_context_destroy(struct pipe_context *pctx) { - struct vc5_context *vc5 = vc5_context(pctx); + struct v3d_context *v3d = v3d_context(pctx); - vc5_flush(pctx); + v3d_flush(pctx); - if (vc5->blitter) - util_blitter_destroy(vc5->blitter); + if (v3d->blitter) + util_blitter_destroy(v3d->blitter); - if (vc5->primconvert) - util_primconvert_destroy(vc5->primconvert); + if (v3d->primconvert) + util_primconvert_destroy(v3d->primconvert); - if (vc5->uploader) - u_upload_destroy(vc5->uploader); + if (v3d->uploader) + u_upload_destroy(v3d->uploader); - slab_destroy_child(&vc5->transfer_pool); + slab_destroy_child(&v3d->transfer_pool); - pipe_surface_reference(&vc5->framebuffer.cbufs[0], NULL); - pipe_surface_reference(&vc5->framebuffer.zsbuf, NULL); + pipe_surface_reference(&v3d->framebuffer.cbufs[0], NULL); + pipe_surface_reference(&v3d->framebuffer.zsbuf, NULL); - vc5_program_fini(pctx); + v3d_program_fini(pctx); - ralloc_free(vc5); + ralloc_free(v3d); } struct pipe_context * -vc5_context_create(struct pipe_screen *pscreen, void *priv, unsigned flags) +v3d_context_create(struct pipe_screen *pscreen, void *priv, unsigned flags) { - struct vc5_screen *screen = vc5_screen(pscreen); - struct vc5_context *vc5; + struct v3d_screen *screen = v3d_screen(pscreen); + struct v3d_context *v3d; /* Prevent dumping of the shaders built during context setup. */ uint32_t saved_shaderdb_flag = V3D_DEBUG & V3D_DEBUG_SHADERDB; V3D_DEBUG &= ~V3D_DEBUG_SHADERDB; - vc5 = rzalloc(NULL, struct vc5_context); - if (!vc5) + v3d = rzalloc(NULL, struct v3d_context); + if (!v3d) return NULL; - struct pipe_context *pctx = &vc5->base; + struct pipe_context *pctx = &v3d->base; - vc5->screen = screen; + v3d->screen = screen; int ret = drmSyncobjCreate(screen->fd, DRM_SYNCOBJ_CREATE_SIGNALED, - &vc5->out_sync); + &v3d->out_sync); if (ret) { - ralloc_free(vc5); + ralloc_free(v3d); return NULL; } pctx->screen = pscreen; pctx->priv = priv; - pctx->destroy = vc5_context_destroy; - pctx->flush = vc5_pipe_flush; - pctx->invalidate_resource = vc5_invalidate_resource; + pctx->destroy = v3d_context_destroy; + pctx->flush = v3d_pipe_flush; + pctx->invalidate_resource = v3d_invalidate_resource; if (screen->devinfo.ver >= 41) { v3d41_draw_init(pctx); @@ -147,35 +147,35 @@ vc5_context_create(struct pipe_screen *pscreen, void *priv, unsigned flags) v3d33_draw_init(pctx); v3d33_state_init(pctx); } - vc5_program_init(pctx); - vc5_query_init(pctx); - vc5_resource_context_init(pctx); + v3d_program_init(pctx); + v3d_query_init(pctx); + v3d_resource_context_init(pctx); - vc5_job_init(vc5); + v3d_job_init(v3d); - vc5->fd = screen->fd; + v3d->fd = screen->fd; - slab_create_child(&vc5->transfer_pool, &screen->transfer_pool); + slab_create_child(&v3d->transfer_pool, &screen->transfer_pool); - vc5->uploader = u_upload_create_default(&vc5->base); - vc5->base.stream_uploader = vc5->uploader; - vc5->base.const_uploader = vc5->uploader; + v3d->uploader = u_upload_create_default(&v3d->base); + v3d->base.stream_uploader = v3d->uploader; + v3d->base.const_uploader = v3d->uploader; - vc5->blitter = util_blitter_create(pctx); - if (!vc5->blitter) + v3d->blitter = util_blitter_create(pctx); + if (!v3d->blitter) goto fail; - vc5->primconvert = util_primconvert_create(pctx, + v3d->primconvert = util_primconvert_create(pctx, (1 << PIPE_PRIM_QUADS) - 1); - if (!vc5->primconvert) + if (!v3d->primconvert) goto fail; V3D_DEBUG |= saved_shaderdb_flag; - vc5->sample_mask = (1 << VC5_MAX_SAMPLES) - 1; - vc5->active_queries = true; + v3d->sample_mask = (1 << VC5_MAX_SAMPLES) - 1; + v3d->active_queries = true; - return &vc5->base; + return &v3d->base; fail: pctx->destroy(pctx); diff --git a/src/gallium/drivers/v3d/v3d_context.h b/src/gallium/drivers/v3d/v3d_context.h index 7c17eccd47e..d110ed50222 100644 --- a/src/gallium/drivers/v3d/v3d_context.h +++ b/src/gallium/drivers/v3d/v3d_context.h @@ -39,18 +39,18 @@ #include "v3d_drm.h" #include "v3d_screen.h" -struct vc5_job; -struct vc5_bo; -void vc5_job_add_bo(struct vc5_job *job, struct vc5_bo *bo); +struct v3d_job; +struct v3d_bo; +void v3d_job_add_bo(struct v3d_job *job, struct v3d_bo *bo); #include "v3d_bufmgr.h" #include "v3d_resource.h" #include "v3d_cl.h" #ifdef USE_V3D_SIMULATOR -#define using_vc5_simulator true +#define using_v3d_simulator true #else -#define using_vc5_simulator false +#define using_v3d_simulator false #endif #define VC5_DIRTY_BLEND (1 << 0) @@ -84,7 +84,7 @@ void vc5_job_add_bo(struct vc5_job *job, struct vc5_bo *bo); #define VC5_MAX_FS_INPUTS 64 -struct vc5_sampler_view { +struct v3d_sampler_view { struct pipe_sampler_view base; uint32_t p0; uint32_t p1; @@ -93,10 +93,10 @@ struct vc5_sampler_view { uint8_t texture_shader_state[32]; /* V3D 4.x: Texture state struct. */ - struct vc5_bo *bo; + struct v3d_bo *bo; }; -struct vc5_sampler_state { +struct v3d_sampler_state { struct pipe_sampler_state base; uint32_t p0; uint32_t p1; @@ -104,24 +104,24 @@ struct vc5_sampler_state { /* V3D 3.x: Packed texture state. */ uint8_t texture_shader_state[32]; /* V3D 4.x: Sampler state struct. */ - struct vc5_bo *bo; + struct v3d_bo *bo; }; -struct vc5_texture_stateobj { +struct v3d_texture_stateobj { struct pipe_sampler_view *textures[PIPE_MAX_SAMPLERS]; unsigned num_textures; struct pipe_sampler_state *samplers[PIPE_MAX_SAMPLERS]; unsigned num_samplers; - struct vc5_cl_reloc texture_state[PIPE_MAX_SAMPLERS]; + struct v3d_cl_reloc texture_state[PIPE_MAX_SAMPLERS]; }; -struct vc5_shader_uniform_info { +struct v3d_shader_uniform_info { enum quniform_contents *contents; uint32_t *data; uint32_t count; }; -struct vc5_uncompiled_shader { +struct v3d_uncompiled_shader { /** A name for this program, so you can track it in shader-db output. */ uint32_t program_id; /** How many variants of this program were compiled, for shader-db. */ @@ -141,8 +141,8 @@ struct vc5_uncompiled_shader { bool was_tgsi; }; -struct vc5_compiled_shader { - struct vc5_bo *bo; +struct v3d_compiled_shader { + struct v3d_bo *bo; union { struct v3d_prog_data *base; @@ -151,54 +151,54 @@ struct vc5_compiled_shader { } prog_data; /** - * VC5_DIRTY_* flags that, when set in vc5->dirty, mean that the + * VC5_DIRTY_* flags that, when set in v3d->dirty, mean that the * uniforms have to be rewritten (and therefore the shader state * reemitted). */ uint32_t uniform_dirty_bits; }; -struct vc5_program_stateobj { - struct vc5_uncompiled_shader *bind_vs, *bind_fs; - struct vc5_compiled_shader *cs, *vs, *fs; +struct v3d_program_stateobj { + struct v3d_uncompiled_shader *bind_vs, *bind_fs; + struct v3d_compiled_shader *cs, *vs, *fs; - struct vc5_bo *spill_bo; + struct v3d_bo *spill_bo; int spill_size_per_thread; }; -struct vc5_constbuf_stateobj { +struct v3d_constbuf_stateobj { struct pipe_constant_buffer cb[PIPE_MAX_CONSTANT_BUFFERS]; uint32_t enabled_mask; uint32_t dirty_mask; }; -struct vc5_vertexbuf_stateobj { +struct v3d_vertexbuf_stateobj { struct pipe_vertex_buffer vb[PIPE_MAX_ATTRIBS]; unsigned count; uint32_t enabled_mask; uint32_t dirty_mask; }; -struct vc5_vertex_stateobj { +struct v3d_vertex_stateobj { struct pipe_vertex_element pipe[VC5_MAX_ATTRIBUTES]; unsigned num_elements; uint8_t attrs[12 * VC5_MAX_ATTRIBUTES]; - struct vc5_bo *default_attribute_values; + struct v3d_bo *default_attribute_values; }; -struct vc5_streamout_stateobj { +struct v3d_streamout_stateobj { struct pipe_stream_output_target *targets[PIPE_MAX_SO_BUFFERS]; unsigned num_targets; }; -/* Hash table key for vc5->jobs */ -struct vc5_job_key { +/* Hash table key for v3d->jobs */ +struct v3d_job_key { struct pipe_surface *cbufs[4]; struct pipe_surface *zsbuf; }; -enum vc5_ez_state { +enum v3d_ez_state { VC5_EZ_UNDECIDED = 0, VC5_EZ_GT_GE, VC5_EZ_LT_LE, @@ -214,13 +214,13 @@ enum vc5_ez_state { * target (which would mean reading back from the old render target when * starting to render to it again). */ -struct vc5_job { - struct vc5_context *vc5; - struct vc5_cl bcl; - struct vc5_cl rcl; - struct vc5_cl indirect; - struct vc5_bo *tile_alloc; - struct vc5_bo *tile_state; +struct v3d_job { + struct v3d_context *v3d; + struct v3d_cl bcl; + struct v3d_cl rcl; + struct v3d_cl indirect; + struct v3d_bo *tile_alloc; + struct v3d_bo *tile_state; uint32_t shader_rec_count; struct drm_v3d_submit_cl submit; @@ -310,12 +310,12 @@ struct vc5_job { * Current EZ state for drawing. Updated at the start of draw after * we've decided on the shader being rendered. */ - enum vc5_ez_state ez_state; + enum v3d_ez_state ez_state; /** * The first EZ state that was used for drawing with a decided EZ * direction (so either UNDECIDED, GT, or LT). */ - enum vc5_ez_state first_ez_state; + enum v3d_ez_state first_ez_state; /** * Number of draw calls (not counting full buffer clears) queued in @@ -323,24 +323,24 @@ struct vc5_job { */ uint32_t draw_calls_queued; - struct vc5_job_key key; + struct v3d_job_key key; }; -struct vc5_context { +struct v3d_context { struct pipe_context base; int fd; - struct vc5_screen *screen; + struct v3d_screen *screen; /** The 3D rendering job for the currently bound FBO. */ - struct vc5_job *job; + struct v3d_job *job; - /* Map from struct vc5_job_key to the job for that FBO. + /* Map from struct v3d_job_key to the job for that FBO. */ struct hash_table *jobs; /** - * Map from vc5_resource to a job writing to that resource. + * Map from v3d_resource to a job writing to that resource. * * Primarily for flushing jobs rendering to textures that are now * being read from. @@ -359,7 +359,7 @@ struct vc5_context { uint32_t next_uncompiled_program_id; uint64_t next_compiled_program_id; - struct vc5_compiler_state *compiler_state; + struct v3d_compiler_state *compiler_state; uint8_t prim_mode; @@ -374,14 +374,14 @@ struct vc5_context { /** @{ Current pipeline state objects */ struct pipe_scissor_state scissor; struct pipe_blend_state *blend; - struct vc5_rasterizer_state *rasterizer; - struct vc5_depth_stencil_alpha_state *zsa; + struct v3d_rasterizer_state *rasterizer; + struct v3d_depth_stencil_alpha_state *zsa; - struct vc5_texture_stateobj verttex, fragtex; + struct v3d_texture_stateobj verttex, fragtex; - struct vc5_program_stateobj prog; + struct v3d_program_stateobj prog; - struct vc5_vertex_stateobj *vtx; + struct v3d_vertex_stateobj *vtx; struct { struct pipe_blend_color f; @@ -414,14 +414,14 @@ struct vc5_context { struct pipe_poly_stipple stipple; struct pipe_clip_state clip; struct pipe_viewport_state viewport; - struct vc5_constbuf_stateobj constbuf[PIPE_SHADER_TYPES]; - struct vc5_vertexbuf_stateobj vertexbuf; - struct vc5_streamout_stateobj streamout; - struct vc5_bo *current_oq; + struct v3d_constbuf_stateobj constbuf[PIPE_SHADER_TYPES]; + struct v3d_vertexbuf_stateobj vertexbuf; + struct v3d_streamout_stateobj streamout; + struct v3d_bo *current_oq; /** @} */ }; -struct vc5_rasterizer_state { +struct v3d_rasterizer_state { struct pipe_rasterizer_state base; /* VC5_CONFIGURATION_BITS */ @@ -441,10 +441,10 @@ struct vc5_rasterizer_state { uint16_t offset_factor; }; -struct vc5_depth_stencil_alpha_state { +struct v3d_depth_stencil_alpha_state { struct pipe_depth_stencil_alpha_state base; - enum vc5_ez_state ez_state; + enum v3d_ez_state ez_state; /** Uniforms for stencil state. * @@ -463,92 +463,92 @@ struct vc5_depth_stencil_alpha_state { fprintf(stderr, __VA_ARGS__); \ } while (0) -static inline struct vc5_context * -vc5_context(struct pipe_context *pcontext) +static inline struct v3d_context * +v3d_context(struct pipe_context *pcontext) { - return (struct vc5_context *)pcontext; + return (struct v3d_context *)pcontext; } -static inline struct vc5_sampler_view * -vc5_sampler_view(struct pipe_sampler_view *psview) +static inline struct v3d_sampler_view * +v3d_sampler_view(struct pipe_sampler_view *psview) { - return (struct vc5_sampler_view *)psview; + return (struct v3d_sampler_view *)psview; } -static inline struct vc5_sampler_state * -vc5_sampler_state(struct pipe_sampler_state *psampler) +static inline struct v3d_sampler_state * +v3d_sampler_state(struct pipe_sampler_state *psampler) { - return (struct vc5_sampler_state *)psampler; + return (struct v3d_sampler_state *)psampler; } -struct pipe_context *vc5_context_create(struct pipe_screen *pscreen, +struct pipe_context *v3d_context_create(struct pipe_screen *pscreen, void *priv, unsigned flags); -void vc5_program_init(struct pipe_context *pctx); -void vc5_program_fini(struct pipe_context *pctx); -void vc5_query_init(struct pipe_context *pctx); +void v3d_program_init(struct pipe_context *pctx); +void v3d_program_fini(struct pipe_context *pctx); +void v3d_query_init(struct pipe_context *pctx); -void vc5_simulator_init(struct vc5_screen *screen); -void vc5_simulator_destroy(struct vc5_screen *screen); -int vc5_simulator_flush(struct vc5_context *vc5, +void v3d_simulator_init(struct v3d_screen *screen); +void v3d_simulator_destroy(struct v3d_screen *screen); +int v3d_simulator_flush(struct v3d_context *v3d, struct drm_v3d_submit_cl *args, - struct vc5_job *job); -int vc5_simulator_ioctl(int fd, unsigned long request, void *arg); -void vc5_simulator_open_from_handle(int fd, uint32_t winsys_stride, + struct v3d_job *job); +int v3d_simulator_ioctl(int fd, unsigned long request, void *arg); +void v3d_simulator_open_from_handle(int fd, uint32_t winsys_stride, int handle, uint32_t size); static inline int -vc5_ioctl(int fd, unsigned long request, void *arg) +v3d_ioctl(int fd, unsigned long request, void *arg) { - if (using_vc5_simulator) - return vc5_simulator_ioctl(fd, request, arg); + if (using_v3d_simulator) + return v3d_simulator_ioctl(fd, request, arg); else return drmIoctl(fd, request, arg); } -void vc5_set_shader_uniform_dirty_flags(struct vc5_compiled_shader *shader); -struct vc5_cl_reloc vc5_write_uniforms(struct vc5_context *vc5, - struct vc5_compiled_shader *shader, - struct vc5_constbuf_stateobj *cb, - struct vc5_texture_stateobj *texstate); +void v3d_set_shader_uniform_dirty_flags(struct v3d_compiled_shader *shader); +struct v3d_cl_reloc v3d_write_uniforms(struct v3d_context *v3d, + struct v3d_compiled_shader *shader, + struct v3d_constbuf_stateobj *cb, + struct v3d_texture_stateobj *texstate); -void vc5_flush(struct pipe_context *pctx); -void vc5_job_init(struct vc5_context *vc5); -struct vc5_job *vc5_get_job(struct vc5_context *vc5, +void v3d_flush(struct pipe_context *pctx); +void v3d_job_init(struct v3d_context *v3d); +struct v3d_job *v3d_get_job(struct v3d_context *v3d, struct pipe_surface **cbufs, struct pipe_surface *zsbuf); -struct vc5_job *vc5_get_job_for_fbo(struct vc5_context *vc5); -void vc5_job_add_bo(struct vc5_job *job, struct vc5_bo *bo); -void vc5_job_add_write_resource(struct vc5_job *job, struct pipe_resource *prsc); -void vc5_job_submit(struct vc5_context *vc5, struct vc5_job *job); -void vc5_flush_jobs_writing_resource(struct vc5_context *vc5, +struct v3d_job *v3d_get_job_for_fbo(struct v3d_context *v3d); +void v3d_job_add_bo(struct v3d_job *job, struct v3d_bo *bo); +void v3d_job_add_write_resource(struct v3d_job *job, struct pipe_resource *prsc); +void v3d_job_submit(struct v3d_context *v3d, struct v3d_job *job); +void v3d_flush_jobs_writing_resource(struct v3d_context *v3d, struct pipe_resource *prsc); -void vc5_flush_jobs_reading_resource(struct vc5_context *vc5, +void v3d_flush_jobs_reading_resource(struct v3d_context *v3d, struct pipe_resource *prsc); -void vc5_update_compiled_shaders(struct vc5_context *vc5, uint8_t prim_mode); +void v3d_update_compiled_shaders(struct v3d_context *v3d, uint8_t prim_mode); -bool vc5_rt_format_supported(const struct v3d_device_info *devinfo, +bool v3d_rt_format_supported(const struct v3d_device_info *devinfo, enum pipe_format f); -bool vc5_tex_format_supported(const struct v3d_device_info *devinfo, +bool v3d_tex_format_supported(const struct v3d_device_info *devinfo, enum pipe_format f); -uint8_t vc5_get_rt_format(const struct v3d_device_info *devinfo, enum pipe_format f); -uint8_t vc5_get_tex_format(const struct v3d_device_info *devinfo, enum pipe_format f); -uint8_t vc5_get_tex_return_size(const struct v3d_device_info *devinfo, +uint8_t v3d_get_rt_format(const struct v3d_device_info *devinfo, enum pipe_format f); +uint8_t v3d_get_tex_format(const struct v3d_device_info *devinfo, enum pipe_format f); +uint8_t v3d_get_tex_return_size(const struct v3d_device_info *devinfo, enum pipe_format f, enum pipe_tex_compare compare); -uint8_t vc5_get_tex_return_channels(const struct v3d_device_info *devinfo, +uint8_t v3d_get_tex_return_channels(const struct v3d_device_info *devinfo, enum pipe_format f); -const uint8_t *vc5_get_format_swizzle(const struct v3d_device_info *devinfo, +const uint8_t *v3d_get_format_swizzle(const struct v3d_device_info *devinfo, enum pipe_format f); -void vc5_get_internal_type_bpp_for_output_format(const struct v3d_device_info *devinfo, +void v3d_get_internal_type_bpp_for_output_format(const struct v3d_device_info *devinfo, uint32_t format, uint32_t *type, uint32_t *bpp); -void vc5_init_query_functions(struct vc5_context *vc5); -void vc5_blit(struct pipe_context *pctx, const struct pipe_blit_info *blit_info); -void vc5_blitter_save(struct vc5_context *vc5); +void v3d_init_query_functions(struct v3d_context *v3d); +void v3d_blit(struct pipe_context *pctx, const struct pipe_blit_info *blit_info); +void v3d_blitter_save(struct v3d_context *v3d); -struct vc5_fence *vc5_fence_create(struct vc5_context *vc5); +struct v3d_fence *v3d_fence_create(struct v3d_context *v3d); #ifdef v3dX # include "v3dx_context.h" diff --git a/src/gallium/drivers/v3d/v3d_fence.c b/src/gallium/drivers/v3d/v3d_fence.c index 54bce562403..fb2e4306104 100644 --- a/src/gallium/drivers/v3d/v3d_fence.c +++ b/src/gallium/drivers/v3d/v3d_fence.c @@ -21,7 +21,7 @@ * IN THE SOFTWARE. */ -/** @file vc5_fence.c +/** @file v3d_fence.c * * Seqno-based fence management. * @@ -39,20 +39,20 @@ #include "v3d_context.h" #include "v3d_bufmgr.h" -struct vc5_fence { +struct v3d_fence { struct pipe_reference reference; uint32_t sync; }; static void -vc5_fence_reference(struct pipe_screen *pscreen, +v3d_fence_reference(struct pipe_screen *pscreen, struct pipe_fence_handle **pp, struct pipe_fence_handle *pf) { - struct vc5_screen *screen = vc5_screen(pscreen); - struct vc5_fence **p = (struct vc5_fence **)pp; - struct vc5_fence *f = (struct vc5_fence *)pf; - struct vc5_fence *old = *p; + struct v3d_screen *screen = v3d_screen(pscreen); + struct v3d_fence **p = (struct v3d_fence **)pp; + struct v3d_fence *f = (struct v3d_fence *)pf; + struct v3d_fence *old = *p; if (pipe_reference(&(*p)->reference, &f->reference)) { drmSyncobjDestroy(screen->fd, old->sync); @@ -62,27 +62,27 @@ vc5_fence_reference(struct pipe_screen *pscreen, } static boolean -vc5_fence_finish(struct pipe_screen *pscreen, +v3d_fence_finish(struct pipe_screen *pscreen, struct pipe_context *ctx, struct pipe_fence_handle *pf, uint64_t timeout_ns) { - struct vc5_screen *screen = vc5_screen(pscreen); - struct vc5_fence *f = (struct vc5_fence *)pf; + struct v3d_screen *screen = v3d_screen(pscreen); + struct v3d_fence *f = (struct v3d_fence *)pf; return drmSyncobjWait(screen->fd, &f->sync, 1, timeout_ns, 0, NULL); } -struct vc5_fence * -vc5_fence_create(struct vc5_context *vc5) +struct v3d_fence * +v3d_fence_create(struct v3d_context *v3d) { - struct vc5_fence *f = calloc(1, sizeof(*f)); + struct v3d_fence *f = calloc(1, sizeof(*f)); if (!f) return NULL; uint32_t new_sync; /* Make a new sync object for the context. */ - int ret = drmSyncobjCreate(vc5->fd, DRM_SYNCOBJ_CREATE_SIGNALED, + int ret = drmSyncobjCreate(v3d->fd, DRM_SYNCOBJ_CREATE_SIGNALED, &new_sync); if (ret) { free(f); @@ -90,15 +90,15 @@ vc5_fence_create(struct vc5_context *vc5) } pipe_reference_init(&f->reference, 1); - f->sync = vc5->out_sync; - vc5->out_sync = new_sync; + f->sync = v3d->out_sync; + v3d->out_sync = new_sync; return f; } void -vc5_fence_init(struct vc5_screen *screen) +v3d_fence_init(struct v3d_screen *screen) { - screen->base.fence_reference = vc5_fence_reference; - screen->base.fence_finish = vc5_fence_finish; + screen->base.fence_reference = v3d_fence_reference; + screen->base.fence_finish = v3d_fence_finish; } diff --git a/src/gallium/drivers/v3d/v3d_format_table.h b/src/gallium/drivers/v3d/v3d_format_table.h index 8b8011351a1..b291708c3ed 100644 --- a/src/gallium/drivers/v3d/v3d_format_table.h +++ b/src/gallium/drivers/v3d/v3d_format_table.h @@ -26,7 +26,7 @@ #include #include -struct vc5_format { +struct v3d_format { /** Set if the pipe format is defined in the table. */ bool present; diff --git a/src/gallium/drivers/v3d/v3d_formats.c b/src/gallium/drivers/v3d/v3d_formats.c index 8424b368cf4..bdb86935f65 100644 --- a/src/gallium/drivers/v3d/v3d_formats.c +++ b/src/gallium/drivers/v3d/v3d_formats.c @@ -22,7 +22,7 @@ */ /** - * @file vc5_formats.c + * @file v3d_formats.c * * Contains the table and accessors for VC5 texture and render target format * support. @@ -37,7 +37,7 @@ #include "v3d_context.h" #include "v3d_format_table.h" -static const struct vc5_format * +static const struct v3d_format * get_format(const struct v3d_device_info *devinfo, enum pipe_format f) { if (devinfo->ver >= 41) @@ -47,10 +47,10 @@ get_format(const struct v3d_device_info *devinfo, enum pipe_format f) } bool -vc5_rt_format_supported(const struct v3d_device_info *devinfo, +v3d_rt_format_supported(const struct v3d_device_info *devinfo, enum pipe_format f) { - const struct vc5_format *vf = get_format(devinfo, f); + const struct v3d_format *vf = get_format(devinfo, f); if (!vf) return false; @@ -59,9 +59,9 @@ vc5_rt_format_supported(const struct v3d_device_info *devinfo, } uint8_t -vc5_get_rt_format(const struct v3d_device_info *devinfo, enum pipe_format f) +v3d_get_rt_format(const struct v3d_device_info *devinfo, enum pipe_format f) { - const struct vc5_format *vf = get_format(devinfo, f); + const struct v3d_format *vf = get_format(devinfo, f); if (!vf) return 0; @@ -70,18 +70,18 @@ vc5_get_rt_format(const struct v3d_device_info *devinfo, enum pipe_format f) } bool -vc5_tex_format_supported(const struct v3d_device_info *devinfo, +v3d_tex_format_supported(const struct v3d_device_info *devinfo, enum pipe_format f) { - const struct vc5_format *vf = get_format(devinfo, f); + const struct v3d_format *vf = get_format(devinfo, f); return vf != NULL; } uint8_t -vc5_get_tex_format(const struct v3d_device_info *devinfo, enum pipe_format f) +v3d_get_tex_format(const struct v3d_device_info *devinfo, enum pipe_format f) { - const struct vc5_format *vf = get_format(devinfo, f); + const struct v3d_format *vf = get_format(devinfo, f); if (!vf) return 0; @@ -90,10 +90,10 @@ vc5_get_tex_format(const struct v3d_device_info *devinfo, enum pipe_format f) } uint8_t -vc5_get_tex_return_size(const struct v3d_device_info *devinfo, +v3d_get_tex_return_size(const struct v3d_device_info *devinfo, enum pipe_format f, enum pipe_tex_compare compare) { - const struct vc5_format *vf = get_format(devinfo, f); + const struct v3d_format *vf = get_format(devinfo, f); if (!vf) return 0; @@ -105,10 +105,10 @@ vc5_get_tex_return_size(const struct v3d_device_info *devinfo, } uint8_t -vc5_get_tex_return_channels(const struct v3d_device_info *devinfo, +v3d_get_tex_return_channels(const struct v3d_device_info *devinfo, enum pipe_format f) { - const struct vc5_format *vf = get_format(devinfo, f); + const struct v3d_format *vf = get_format(devinfo, f); if (!vf) return 0; @@ -117,9 +117,9 @@ vc5_get_tex_return_channels(const struct v3d_device_info *devinfo, } const uint8_t * -vc5_get_format_swizzle(const struct v3d_device_info *devinfo, enum pipe_format f) +v3d_get_format_swizzle(const struct v3d_device_info *devinfo, enum pipe_format f) { - const struct vc5_format *vf = get_format(devinfo, f); + const struct v3d_format *vf = get_format(devinfo, f); static const uint8_t fallback[] = {0, 1, 2, 3}; if (!vf) @@ -129,7 +129,7 @@ vc5_get_format_swizzle(const struct v3d_device_info *devinfo, enum pipe_format f } void -vc5_get_internal_type_bpp_for_output_format(const struct v3d_device_info *devinfo, +v3d_get_internal_type_bpp_for_output_format(const struct v3d_device_info *devinfo, uint32_t format, uint32_t *type, uint32_t *bpp) diff --git a/src/gallium/drivers/v3d/v3d_job.c b/src/gallium/drivers/v3d/v3d_job.c index 85c64df34ca..7be568d623a 100644 --- a/src/gallium/drivers/v3d/v3d_job.c +++ b/src/gallium/drivers/v3d/v3d_job.c @@ -21,7 +21,7 @@ * IN THE SOFTWARE. */ -/** @file vc5_job.c +/** @file v3d_job.c * * Functions for submitting VC5 render jobs to the kernel. */ @@ -45,16 +45,16 @@ remove_from_ht(struct hash_table *ht, void *key) } static void -vc5_job_free(struct vc5_context *vc5, struct vc5_job *job) +v3d_job_free(struct v3d_context *v3d, struct v3d_job *job) { struct set_entry *entry; set_foreach(job->bos, entry) { - struct vc5_bo *bo = (struct vc5_bo *)entry->key; - vc5_bo_unreference(&bo); + struct v3d_bo *bo = (struct v3d_bo *)entry->key; + v3d_bo_unreference(&bo); } - remove_from_ht(vc5->jobs, &job->key); + remove_from_ht(v3d->jobs, &job->key); if (job->write_prscs) { struct set_entry *entry; @@ -62,43 +62,43 @@ vc5_job_free(struct vc5_context *vc5, struct vc5_job *job) set_foreach(job->write_prscs, entry) { const struct pipe_resource *prsc = entry->key; - remove_from_ht(vc5->write_jobs, (void *)prsc); + remove_from_ht(v3d->write_jobs, (void *)prsc); } } for (int i = 0; i < VC5_MAX_DRAW_BUFFERS; i++) { if (job->cbufs[i]) { - remove_from_ht(vc5->write_jobs, job->cbufs[i]->texture); + remove_from_ht(v3d->write_jobs, job->cbufs[i]->texture); pipe_surface_reference(&job->cbufs[i], NULL); } } if (job->zsbuf) { - remove_from_ht(vc5->write_jobs, job->zsbuf->texture); + remove_from_ht(v3d->write_jobs, job->zsbuf->texture); pipe_surface_reference(&job->zsbuf, NULL); } - if (vc5->job == job) - vc5->job = NULL; + if (v3d->job == job) + v3d->job = NULL; - vc5_destroy_cl(&job->bcl); - vc5_destroy_cl(&job->rcl); - vc5_destroy_cl(&job->indirect); - vc5_bo_unreference(&job->tile_alloc); - vc5_bo_unreference(&job->tile_state); + v3d_destroy_cl(&job->bcl); + v3d_destroy_cl(&job->rcl); + v3d_destroy_cl(&job->indirect); + v3d_bo_unreference(&job->tile_alloc); + v3d_bo_unreference(&job->tile_state); ralloc_free(job); } -static struct vc5_job * -vc5_job_create(struct vc5_context *vc5) +static struct v3d_job * +v3d_job_create(struct v3d_context *v3d) { - struct vc5_job *job = rzalloc(vc5, struct vc5_job); + struct v3d_job *job = rzalloc(v3d, struct v3d_job); - job->vc5 = vc5; + job->v3d = v3d; - vc5_init_cl(job, &job->bcl); - vc5_init_cl(job, &job->rcl); - vc5_init_cl(job, &job->indirect); + v3d_init_cl(job, &job->bcl); + v3d_init_cl(job, &job->rcl); + v3d_init_cl(job, &job->indirect); job->draw_min_x = ~0; job->draw_min_y = ~0; @@ -112,7 +112,7 @@ vc5_job_create(struct vc5_context *vc5) } void -vc5_job_add_bo(struct vc5_job *job, struct vc5_bo *bo) +v3d_job_add_bo(struct v3d_job *job, struct v3d_bo *bo) { if (!bo) return; @@ -120,7 +120,7 @@ vc5_job_add_bo(struct vc5_job *job, struct vc5_bo *bo) if (_mesa_set_search(job->bos, bo)) return; - vc5_bo_reference(bo); + v3d_bo_reference(bo); _mesa_set_add(job->bos, bo); job->referenced_size += bo->size; @@ -136,9 +136,9 @@ vc5_job_add_bo(struct vc5_job *job, struct vc5_bo *bo) } void -vc5_job_add_write_resource(struct vc5_job *job, struct pipe_resource *prsc) +v3d_job_add_write_resource(struct v3d_job *job, struct pipe_resource *prsc) { - struct vc5_context *vc5 = job->vc5; + struct v3d_context *v3d = job->v3d; if (!job->write_prscs) { job->write_prscs = _mesa_set_create(job, @@ -147,36 +147,36 @@ vc5_job_add_write_resource(struct vc5_job *job, struct pipe_resource *prsc) } _mesa_set_add(job->write_prscs, prsc); - _mesa_hash_table_insert(vc5->write_jobs, prsc, job); + _mesa_hash_table_insert(v3d->write_jobs, prsc, job); } void -vc5_flush_jobs_writing_resource(struct vc5_context *vc5, +v3d_flush_jobs_writing_resource(struct v3d_context *v3d, struct pipe_resource *prsc) { - struct hash_entry *entry = _mesa_hash_table_search(vc5->write_jobs, + struct hash_entry *entry = _mesa_hash_table_search(v3d->write_jobs, prsc); if (entry) { - struct vc5_job *job = entry->data; - vc5_job_submit(vc5, job); + struct v3d_job *job = entry->data; + v3d_job_submit(v3d, job); } } void -vc5_flush_jobs_reading_resource(struct vc5_context *vc5, +v3d_flush_jobs_reading_resource(struct v3d_context *v3d, struct pipe_resource *prsc) { - struct vc5_resource *rsc = vc5_resource(prsc); + struct v3d_resource *rsc = v3d_resource(prsc); - vc5_flush_jobs_writing_resource(vc5, prsc); + v3d_flush_jobs_writing_resource(v3d, prsc); struct hash_entry *entry; - hash_table_foreach(vc5->jobs, entry) { - struct vc5_job *job = entry->data; + hash_table_foreach(v3d->jobs, entry) { + struct v3d_job *job = entry->data; if (_mesa_set_search(job->bos, rsc->bo)) { - vc5_job_submit(vc5, job); - /* Reminder: vc5->jobs is safe to keep iterating even + v3d_job_submit(v3d, job); + /* Reminder: v3d->jobs is safe to keep iterating even * after deletion of an entry. */ continue; @@ -185,7 +185,7 @@ vc5_flush_jobs_reading_resource(struct vc5_context *vc5, } static void -vc5_job_set_tile_buffer_size(struct vc5_job *job) +v3d_job_set_tile_buffer_size(struct v3d_job *job) { static const uint8_t tile_sizes[] = { 64, 64, @@ -206,7 +206,7 @@ vc5_job_set_tile_buffer_size(struct vc5_job *job) int max_bpp = RENDER_TARGET_MAXIMUM_32BPP; for (int i = 0; i < VC5_MAX_DRAW_BUFFERS; i++) { if (job->cbufs[i]) { - struct vc5_surface *surf = vc5_surface(job->cbufs[i]); + struct v3d_surface *surf = v3d_surface(job->cbufs[i]); max_bpp = MAX2(max_bpp, surf->internal_bpp); } } @@ -220,19 +220,19 @@ vc5_job_set_tile_buffer_size(struct vc5_job *job) } /** - * Returns a vc5_job struture for tracking V3D rendering to a particular FBO. + * Returns a v3d_job struture for tracking V3D rendering to a particular FBO. * * If we've already started rendering to this FBO, then return old same job, * otherwise make a new one. If we're beginning rendering to an FBO, make * sure that any previous reads of the FBO (or writes to its color/Z surfaces) * have been flushed. */ -struct vc5_job * -vc5_get_job(struct vc5_context *vc5, +struct v3d_job * +v3d_get_job(struct v3d_context *v3d, struct pipe_surface **cbufs, struct pipe_surface *zsbuf) { /* Return the existing job for this FBO if we have one */ - struct vc5_job_key local_key = { + struct v3d_job_key local_key = { .cbufs = { cbufs[0], cbufs[1], @@ -241,7 +241,7 @@ vc5_get_job(struct vc5_context *vc5, }, .zsbuf = zsbuf, }; - struct hash_entry *entry = _mesa_hash_table_search(vc5->jobs, + struct hash_entry *entry = _mesa_hash_table_search(v3d->jobs, &local_key); if (entry) return entry->data; @@ -249,11 +249,11 @@ vc5_get_job(struct vc5_context *vc5, /* Creating a new job. Make sure that any previous jobs reading or * writing these buffers are flushed. */ - struct vc5_job *job = vc5_job_create(vc5); + struct v3d_job *job = v3d_job_create(v3d); for (int i = 0; i < VC5_MAX_DRAW_BUFFERS; i++) { if (cbufs[i]) { - vc5_flush_jobs_reading_resource(vc5, cbufs[i]->texture); + v3d_flush_jobs_reading_resource(v3d, cbufs[i]->texture); pipe_surface_reference(&job->cbufs[i], cbufs[i]); if (cbufs[i]->texture->nr_samples > 1) @@ -261,83 +261,83 @@ vc5_get_job(struct vc5_context *vc5, } } if (zsbuf) { - vc5_flush_jobs_reading_resource(vc5, zsbuf->texture); + v3d_flush_jobs_reading_resource(v3d, zsbuf->texture); pipe_surface_reference(&job->zsbuf, zsbuf); if (zsbuf->texture->nr_samples > 1) job->msaa = true; } - vc5_job_set_tile_buffer_size(job); + v3d_job_set_tile_buffer_size(job); for (int i = 0; i < VC5_MAX_DRAW_BUFFERS; i++) { if (cbufs[i]) - _mesa_hash_table_insert(vc5->write_jobs, + _mesa_hash_table_insert(v3d->write_jobs, cbufs[i]->texture, job); } if (zsbuf) - _mesa_hash_table_insert(vc5->write_jobs, zsbuf->texture, job); + _mesa_hash_table_insert(v3d->write_jobs, zsbuf->texture, job); memcpy(&job->key, &local_key, sizeof(local_key)); - _mesa_hash_table_insert(vc5->jobs, &job->key, job); + _mesa_hash_table_insert(v3d->jobs, &job->key, job); return job; } -struct vc5_job * -vc5_get_job_for_fbo(struct vc5_context *vc5) +struct v3d_job * +v3d_get_job_for_fbo(struct v3d_context *v3d) { - if (vc5->job) - return vc5->job; + if (v3d->job) + return v3d->job; - struct pipe_surface **cbufs = vc5->framebuffer.cbufs; - struct pipe_surface *zsbuf = vc5->framebuffer.zsbuf; - struct vc5_job *job = vc5_get_job(vc5, cbufs, zsbuf); + struct pipe_surface **cbufs = v3d->framebuffer.cbufs; + struct pipe_surface *zsbuf = v3d->framebuffer.zsbuf; + struct v3d_job *job = v3d_get_job(v3d, cbufs, zsbuf); - /* The dirty flags are tracking what's been updated while vc5->job has + /* The dirty flags are tracking what's been updated while v3d->job has * been bound, so set them all to ~0 when switching between jobs. We * also need to reset all state at the start of rendering. */ - vc5->dirty = ~0; + v3d->dirty = ~0; /* If we're binding to uninitialized buffers, no need to load their * contents before drawing. */ for (int i = 0; i < 4; i++) { if (cbufs[i]) { - struct vc5_resource *rsc = vc5_resource(cbufs[i]->texture); + struct v3d_resource *rsc = v3d_resource(cbufs[i]->texture); if (!rsc->writes) job->cleared |= PIPE_CLEAR_COLOR0 << i; } } if (zsbuf) { - struct vc5_resource *rsc = vc5_resource(zsbuf->texture); + struct v3d_resource *rsc = v3d_resource(zsbuf->texture); if (!rsc->writes) job->cleared |= PIPE_CLEAR_DEPTH | PIPE_CLEAR_STENCIL; } - job->draw_tiles_x = DIV_ROUND_UP(vc5->framebuffer.width, + job->draw_tiles_x = DIV_ROUND_UP(v3d->framebuffer.width, job->tile_width); - job->draw_tiles_y = DIV_ROUND_UP(vc5->framebuffer.height, + job->draw_tiles_y = DIV_ROUND_UP(v3d->framebuffer.height, job->tile_height); - vc5->job = job; + v3d->job = job; return job; } static bool -vc5_clif_dump_lookup(void *data, uint32_t addr, void **vaddr) +v3d_clif_dump_lookup(void *data, uint32_t addr, void **vaddr) { - struct vc5_job *job = data; + struct v3d_job *job = data; struct set_entry *entry; set_foreach(job->bos, entry) { - struct vc5_bo *bo = (void *)entry->key; + struct v3d_bo *bo = (void *)entry->key; if (addr >= bo->offset && addr < bo->offset + bo->size) { - vc5_bo_map(bo); + v3d_bo_map(bo); *vaddr = bo->map + addr - bo->offset; return true; } @@ -347,13 +347,13 @@ vc5_clif_dump_lookup(void *data, uint32_t addr, void **vaddr) } static void -vc5_clif_dump(struct vc5_context *vc5, struct vc5_job *job) +v3d_clif_dump(struct v3d_context *v3d, struct v3d_job *job) { if (!(V3D_DEBUG & V3D_DEBUG_CL)) return; - struct clif_dump *clif = clif_dump_init(&vc5->screen->devinfo, - stderr, vc5_clif_dump_lookup, + struct clif_dump *clif = clif_dump_init(&v3d->screen->devinfo, + stderr, v3d_clif_dump_lookup, job); fprintf(stderr, "BCL: 0x%08x..0x%08x\n", @@ -370,26 +370,26 @@ vc5_clif_dump(struct vc5_context *vc5, struct vc5_job *job) * Submits the job to the kernel and then reinitializes it. */ void -vc5_job_submit(struct vc5_context *vc5, struct vc5_job *job) +v3d_job_submit(struct v3d_context *v3d, struct v3d_job *job) { - MAYBE_UNUSED struct vc5_screen *screen = vc5->screen; + MAYBE_UNUSED struct v3d_screen *screen = v3d->screen; if (!job->needs_flush) goto done; - if (vc5->screen->devinfo.ver >= 41) + if (v3d->screen->devinfo.ver >= 41) v3d41_emit_rcl(job); else v3d33_emit_rcl(job); if (cl_offset(&job->bcl) > 0) { if (screen->devinfo.ver >= 41) - v3d41_bcl_epilogue(vc5, job); + v3d41_bcl_epilogue(v3d, job); else - v3d33_bcl_epilogue(vc5, job); + v3d33_bcl_epilogue(v3d, job); } - job->submit.out_sync = vc5->out_sync; + job->submit.out_sync = v3d->out_sync; job->submit.bcl_end = job->bcl.bo->offset + cl_offset(&job->bcl); job->submit.rcl_end = job->rcl.bo->offset + cl_offset(&job->rcl); @@ -397,23 +397,23 @@ vc5_job_submit(struct vc5_context *vc5, struct vc5_job *job) * instead of binner packets. */ if (screen->devinfo.ver >= 41) { - vc5_job_add_bo(job, job->tile_alloc); + v3d_job_add_bo(job, job->tile_alloc); job->submit.qma = job->tile_alloc->offset; job->submit.qms = job->tile_alloc->size; - vc5_job_add_bo(job, job->tile_state); + v3d_job_add_bo(job, job->tile_state); job->submit.qts = job->tile_state->offset; } - vc5_clif_dump(vc5, job); + v3d_clif_dump(v3d, job); if (!(V3D_DEBUG & V3D_DEBUG_NORAST)) { int ret; #ifndef USE_V3D_SIMULATOR - ret = drmIoctl(vc5->fd, DRM_IOCTL_V3D_SUBMIT_CL, &job->submit); + ret = drmIoctl(v3d->fd, DRM_IOCTL_V3D_SUBMIT_CL, &job->submit); #else - ret = vc5_simulator_flush(vc5, &job->submit, job); + ret = v3d_simulator_flush(v3d, &job->submit, job); #endif static bool warned = false; if (ret && !warned) { @@ -424,28 +424,28 @@ vc5_job_submit(struct vc5_context *vc5, struct vc5_job *job) } done: - vc5_job_free(vc5, job); + v3d_job_free(v3d, job); } static bool -vc5_job_compare(const void *a, const void *b) +v3d_job_compare(const void *a, const void *b) { - return memcmp(a, b, sizeof(struct vc5_job_key)) == 0; + return memcmp(a, b, sizeof(struct v3d_job_key)) == 0; } static uint32_t -vc5_job_hash(const void *key) +v3d_job_hash(const void *key) { - return _mesa_hash_data(key, sizeof(struct vc5_job_key)); + return _mesa_hash_data(key, sizeof(struct v3d_job_key)); } void -vc5_job_init(struct vc5_context *vc5) +v3d_job_init(struct v3d_context *v3d) { - vc5->jobs = _mesa_hash_table_create(vc5, - vc5_job_hash, - vc5_job_compare); - vc5->write_jobs = _mesa_hash_table_create(vc5, + v3d->jobs = _mesa_hash_table_create(v3d, + v3d_job_hash, + v3d_job_compare); + v3d->write_jobs = _mesa_hash_table_create(v3d, _mesa_hash_pointer, _mesa_key_pointer_equal); } diff --git a/src/gallium/drivers/v3d/v3d_program.c b/src/gallium/drivers/v3d/v3d_program.c index ce2e0be8ed2..63e6fda5471 100644 --- a/src/gallium/drivers/v3d/v3d_program.c +++ b/src/gallium/drivers/v3d/v3d_program.c @@ -38,7 +38,7 @@ #include "mesa/state_tracker/st_glsl_types.h" static gl_varying_slot -vc5_get_slot_for_driver_location(nir_shader *s, uint32_t driver_location) +v3d_get_slot_for_driver_location(nir_shader *s, uint32_t driver_location) { nir_foreach_variable(var, &s->outputs) { if (var->data.driver_location == driver_location) { @@ -58,7 +58,7 @@ vc5_get_slot_for_driver_location(nir_shader *s, uint32_t driver_location) * varyings together in a single data spec. */ static void -vc5_set_transform_feedback_outputs(struct vc5_uncompiled_shader *so, +v3d_set_transform_feedback_outputs(struct v3d_uncompiled_shader *so, const struct pipe_stream_output_info *stream_output) { if (!stream_output->num_outputs) @@ -96,7 +96,7 @@ vc5_set_transform_feedback_outputs(struct vc5_uncompiled_shader *so, */ for (int j = 0; j < output->num_components; j++) { gl_varying_slot slot = - vc5_get_slot_for_driver_location(so->base.ir.nir, output->register_index); + v3d_get_slot_for_driver_location(so->base.ir.nir, output->register_index); slots[slot_count] = v3d_slot_from_slot_and_component(slot, @@ -173,15 +173,15 @@ uniforms_type_size(const struct glsl_type *type) } static void * -vc5_shader_state_create(struct pipe_context *pctx, +v3d_shader_state_create(struct pipe_context *pctx, const struct pipe_shader_state *cso) { - struct vc5_context *vc5 = vc5_context(pctx); - struct vc5_uncompiled_shader *so = CALLOC_STRUCT(vc5_uncompiled_shader); + struct v3d_context *v3d = v3d_context(pctx); + struct v3d_uncompiled_shader *so = CALLOC_STRUCT(v3d_uncompiled_shader); if (!so) return NULL; - so->program_id = vc5->next_uncompiled_program_id++; + so->program_id = v3d->next_uncompiled_program_id++; nir_shader *s; @@ -227,7 +227,7 @@ vc5_shader_state_create(struct pipe_context *pctx, so->base.type = PIPE_SHADER_IR_NIR; so->base.ir.nir = s; - vc5_set_transform_feedback_outputs(so, &cso->stream_output); + v3d_set_transform_feedback_outputs(so, &cso->stream_output); if (V3D_DEBUG & (V3D_DEBUG_NIR | v3d_debug_flag_for_shader_stage(s->info.stage))) { @@ -241,19 +241,19 @@ vc5_shader_state_create(struct pipe_context *pctx, return so; } -static struct vc5_compiled_shader * -vc5_get_compiled_shader(struct vc5_context *vc5, struct v3d_key *key) +static struct v3d_compiled_shader * +v3d_get_compiled_shader(struct v3d_context *v3d, struct v3d_key *key) { - struct vc5_uncompiled_shader *shader_state = key->shader_state; + struct v3d_uncompiled_shader *shader_state = key->shader_state; nir_shader *s = shader_state->base.ir.nir; struct hash_table *ht; uint32_t key_size; if (s->info.stage == MESA_SHADER_FRAGMENT) { - ht = vc5->fs_cache; + ht = v3d->fs_cache; key_size = sizeof(struct v3d_fs_key); } else { - ht = vc5->vs_cache; + ht = v3d->vs_cache; key_size = sizeof(struct v3d_vs_key); } @@ -261,8 +261,8 @@ vc5_get_compiled_shader(struct vc5_context *vc5, struct v3d_key *key) if (entry) return entry->data; - struct vc5_compiled_shader *shader = - rzalloc(NULL, struct vc5_compiled_shader); + struct v3d_compiled_shader *shader = + rzalloc(NULL, struct v3d_compiled_shader); int program_id = shader_state->program_id; int variant_id = @@ -274,7 +274,7 @@ vc5_get_compiled_shader(struct vc5_context *vc5, struct v3d_key *key) case MESA_SHADER_VERTEX: shader->prog_data.vs = rzalloc(shader, struct v3d_vs_prog_data); - qpu_insts = v3d_compile_vs(vc5->screen->compiler, + qpu_insts = v3d_compile_vs(v3d->screen->compiler, (struct v3d_vs_key *)key, shader->prog_data.vs, s, program_id, variant_id, @@ -283,7 +283,7 @@ vc5_get_compiled_shader(struct vc5_context *vc5, struct v3d_key *key) case MESA_SHADER_FRAGMENT: shader->prog_data.fs = rzalloc(shader, struct v3d_fs_prog_data); - qpu_insts = v3d_compile_fs(vc5->screen->compiler, + qpu_insts = v3d_compile_fs(v3d->screen->compiler, (struct v3d_fs_key *)key, shader->prog_data.fs, s, program_id, variant_id, @@ -293,31 +293,31 @@ vc5_get_compiled_shader(struct vc5_context *vc5, struct v3d_key *key) unreachable("bad stage"); } - vc5_set_shader_uniform_dirty_flags(shader); + v3d_set_shader_uniform_dirty_flags(shader); - shader->bo = vc5_bo_alloc(vc5->screen, shader_size, "shader"); - vc5_bo_map(shader->bo); + shader->bo = v3d_bo_alloc(v3d->screen, shader_size, "shader"); + v3d_bo_map(shader->bo); memcpy(shader->bo->map, qpu_insts, shader_size); free(qpu_insts); - struct vc5_key *dup_key; + struct v3d_key *dup_key; dup_key = ralloc_size(shader, key_size); memcpy(dup_key, key, key_size); _mesa_hash_table_insert(ht, dup_key, shader); if (shader->prog_data.base->spill_size > - vc5->prog.spill_size_per_thread) { + v3d->prog.spill_size_per_thread) { /* Max 4 QPUs per slice, 3 slices per core. We only do single * core so far. This overallocates memory on smaller cores. */ int total_spill_size = 4 * 3 * shader->prog_data.base->spill_size; - vc5_bo_unreference(&vc5->prog.spill_bo); - vc5->prog.spill_bo = vc5_bo_alloc(vc5->screen, + v3d_bo_unreference(&v3d->prog.spill_bo); + v3d->prog.spill_bo = v3d_bo_alloc(v3d->screen, total_spill_size, "spill"); - vc5->prog.spill_size_per_thread = + v3d->prog.spill_size_per_thread = shader->prog_data.base->spill_size; } @@ -325,14 +325,14 @@ vc5_get_compiled_shader(struct vc5_context *vc5, struct v3d_key *key) } static void -vc5_setup_shared_key(struct vc5_context *vc5, struct v3d_key *key, - struct vc5_texture_stateobj *texstate) +v3d_setup_shared_key(struct v3d_context *v3d, struct v3d_key *key, + struct v3d_texture_stateobj *texstate) { - const struct v3d_device_info *devinfo = &vc5->screen->devinfo; + const struct v3d_device_info *devinfo = &v3d->screen->devinfo; for (int i = 0; i < texstate->num_textures; i++) { struct pipe_sampler_view *sampler = texstate->textures[i]; - struct vc5_sampler_view *vc5_sampler = vc5_sampler_view(sampler); + struct v3d_sampler_view *v3d_sampler = v3d_sampler_view(sampler); struct pipe_sampler_state *sampler_state = texstate->samplers[i]; @@ -340,7 +340,7 @@ vc5_setup_shared_key(struct vc5_context *vc5, struct v3d_key *key, continue; key->tex[i].return_size = - vc5_get_tex_return_size(devinfo, + v3d_get_tex_return_size(devinfo, sampler->format, sampler_state->compare_mode); @@ -354,14 +354,14 @@ vc5_setup_shared_key(struct vc5_context *vc5, struct v3d_key *key, key->tex[i].return_channels = 4; } else { key->tex[i].return_channels = - vc5_get_tex_return_channels(devinfo, + v3d_get_tex_return_channels(devinfo, sampler->format); } if (key->tex[i].return_size == 32 && devinfo->ver < 40) { memcpy(key->tex[i].swizzle, - vc5_sampler->swizzle, - sizeof(vc5_sampler->swizzle)); + v3d_sampler->swizzle, + sizeof(v3d_sampler->swizzle)); } else { /* For 16-bit returns, we let the sampler state handle * the swizzle. @@ -384,17 +384,17 @@ vc5_setup_shared_key(struct vc5_context *vc5, struct v3d_key *key, } } - key->ucp_enables = vc5->rasterizer->base.clip_plane_enable; + key->ucp_enables = v3d->rasterizer->base.clip_plane_enable; } static void -vc5_update_compiled_fs(struct vc5_context *vc5, uint8_t prim_mode) +v3d_update_compiled_fs(struct v3d_context *v3d, uint8_t prim_mode) { - struct vc5_job *job = vc5->job; + struct v3d_job *job = v3d->job; struct v3d_fs_key local_key; struct v3d_fs_key *key = &local_key; - if (!(vc5->dirty & (VC5_DIRTY_PRIM_MODE | + if (!(v3d->dirty & (VC5_DIRTY_PRIM_MODE | VC5_DIRTY_BLEND | VC5_DIRTY_FRAMEBUFFER | VC5_DIRTY_ZSA | @@ -406,40 +406,40 @@ vc5_update_compiled_fs(struct vc5_context *vc5, uint8_t prim_mode) } memset(key, 0, sizeof(*key)); - vc5_setup_shared_key(vc5, &key->base, &vc5->fragtex); - key->base.shader_state = vc5->prog.bind_fs; + v3d_setup_shared_key(v3d, &key->base, &v3d->fragtex); + key->base.shader_state = v3d->prog.bind_fs; key->is_points = (prim_mode == PIPE_PRIM_POINTS); key->is_lines = (prim_mode >= PIPE_PRIM_LINES && prim_mode <= PIPE_PRIM_LINE_STRIP); - key->clamp_color = vc5->rasterizer->base.clamp_fragment_color; - if (vc5->blend->logicop_enable) { - key->logicop_func = vc5->blend->logicop_func; + key->clamp_color = v3d->rasterizer->base.clamp_fragment_color; + if (v3d->blend->logicop_enable) { + key->logicop_func = v3d->blend->logicop_func; } else { key->logicop_func = PIPE_LOGICOP_COPY; } if (job->msaa) { - key->msaa = vc5->rasterizer->base.multisample; - key->sample_coverage = (vc5->rasterizer->base.multisample && - vc5->sample_mask != (1 << VC5_MAX_SAMPLES) - 1); - key->sample_alpha_to_coverage = vc5->blend->alpha_to_coverage; - key->sample_alpha_to_one = vc5->blend->alpha_to_one; + key->msaa = v3d->rasterizer->base.multisample; + key->sample_coverage = (v3d->rasterizer->base.multisample && + v3d->sample_mask != (1 << VC5_MAX_SAMPLES) - 1); + key->sample_alpha_to_coverage = v3d->blend->alpha_to_coverage; + key->sample_alpha_to_one = v3d->blend->alpha_to_one; } - key->depth_enabled = (vc5->zsa->base.depth.enabled || - vc5->zsa->base.stencil[0].enabled); - if (vc5->zsa->base.alpha.enabled) { + key->depth_enabled = (v3d->zsa->base.depth.enabled || + v3d->zsa->base.stencil[0].enabled); + if (v3d->zsa->base.alpha.enabled) { key->alpha_test = true; - key->alpha_test_func = vc5->zsa->base.alpha.func; + key->alpha_test_func = v3d->zsa->base.alpha.func; } /* gl_FragColor's propagation to however many bound color buffers * there are means that the buffer count needs to be in the key. */ - key->nr_cbufs = vc5->framebuffer.nr_cbufs; - key->swap_color_rb = vc5->swap_color_rb; + key->nr_cbufs = v3d->framebuffer.nr_cbufs; + key->swap_color_rb = v3d->swap_color_rb; for (int i = 0; i < key->nr_cbufs; i++) { - struct pipe_surface *cbuf = vc5->framebuffer.cbufs[i]; + struct pipe_surface *cbuf = v3d->framebuffer.cbufs[i]; if (!cbuf) continue; @@ -451,7 +451,7 @@ vc5_update_compiled_fs(struct vc5_context *vc5, uint8_t prim_mode) key->f32_color_rb |= 1 << i; } - if (vc5->prog.bind_fs->was_tgsi) { + if (v3d->prog.bind_fs->was_tgsi) { if (util_format_is_pure_uint(cbuf->format)) key->uint_color_rb |= 1 << i; else if (util_format_is_pure_sint(cbuf->format)) @@ -461,48 +461,48 @@ vc5_update_compiled_fs(struct vc5_context *vc5, uint8_t prim_mode) if (key->is_points) { key->point_sprite_mask = - vc5->rasterizer->base.sprite_coord_enable; + v3d->rasterizer->base.sprite_coord_enable; key->point_coord_upper_left = - (vc5->rasterizer->base.sprite_coord_mode == + (v3d->rasterizer->base.sprite_coord_mode == PIPE_SPRITE_COORD_UPPER_LEFT); } - key->light_twoside = vc5->rasterizer->base.light_twoside; - key->shade_model_flat = vc5->rasterizer->base.flatshade; + key->light_twoside = v3d->rasterizer->base.light_twoside; + key->shade_model_flat = v3d->rasterizer->base.flatshade; - struct vc5_compiled_shader *old_fs = vc5->prog.fs; - vc5->prog.fs = vc5_get_compiled_shader(vc5, &key->base); - if (vc5->prog.fs == old_fs) + struct v3d_compiled_shader *old_fs = v3d->prog.fs; + v3d->prog.fs = v3d_get_compiled_shader(v3d, &key->base); + if (v3d->prog.fs == old_fs) return; - vc5->dirty |= VC5_DIRTY_COMPILED_FS; + v3d->dirty |= VC5_DIRTY_COMPILED_FS; if (old_fs) { - if (vc5->prog.fs->prog_data.fs->flat_shade_flags != + if (v3d->prog.fs->prog_data.fs->flat_shade_flags != old_fs->prog_data.fs->flat_shade_flags) { - vc5->dirty |= VC5_DIRTY_FLAT_SHADE_FLAGS; + v3d->dirty |= VC5_DIRTY_FLAT_SHADE_FLAGS; } - if (vc5->prog.fs->prog_data.fs->centroid_flags != + if (v3d->prog.fs->prog_data.fs->centroid_flags != old_fs->prog_data.fs->centroid_flags) { - vc5->dirty |= VC5_DIRTY_CENTROID_FLAGS; + v3d->dirty |= VC5_DIRTY_CENTROID_FLAGS; } } - if (old_fs && memcmp(vc5->prog.fs->prog_data.fs->input_slots, + if (old_fs && memcmp(v3d->prog.fs->prog_data.fs->input_slots, old_fs->prog_data.fs->input_slots, - sizeof(vc5->prog.fs->prog_data.fs->input_slots))) { - vc5->dirty |= VC5_DIRTY_FS_INPUTS; + sizeof(v3d->prog.fs->prog_data.fs->input_slots))) { + v3d->dirty |= VC5_DIRTY_FS_INPUTS; } } static void -vc5_update_compiled_vs(struct vc5_context *vc5, uint8_t prim_mode) +v3d_update_compiled_vs(struct v3d_context *v3d, uint8_t prim_mode) { struct v3d_vs_key local_key; struct v3d_vs_key *key = &local_key; - if (!(vc5->dirty & (VC5_DIRTY_PRIM_MODE | + if (!(v3d->dirty & (VC5_DIRTY_PRIM_MODE | VC5_DIRTY_RASTERIZER | VC5_DIRTY_VERTTEX | VC5_DIRTY_VTXSTATE | @@ -512,29 +512,29 @@ vc5_update_compiled_vs(struct vc5_context *vc5, uint8_t prim_mode) } memset(key, 0, sizeof(*key)); - vc5_setup_shared_key(vc5, &key->base, &vc5->verttex); - key->base.shader_state = vc5->prog.bind_vs; - key->num_fs_inputs = vc5->prog.fs->prog_data.fs->base.num_inputs; + v3d_setup_shared_key(v3d, &key->base, &v3d->verttex); + key->base.shader_state = v3d->prog.bind_vs; + key->num_fs_inputs = v3d->prog.fs->prog_data.fs->base.num_inputs; STATIC_ASSERT(sizeof(key->fs_inputs) == - sizeof(vc5->prog.fs->prog_data.fs->input_slots)); - memcpy(key->fs_inputs, vc5->prog.fs->prog_data.fs->input_slots, + sizeof(v3d->prog.fs->prog_data.fs->input_slots)); + memcpy(key->fs_inputs, v3d->prog.fs->prog_data.fs->input_slots, sizeof(key->fs_inputs)); - key->clamp_color = vc5->rasterizer->base.clamp_vertex_color; + key->clamp_color = v3d->rasterizer->base.clamp_vertex_color; key->per_vertex_point_size = (prim_mode == PIPE_PRIM_POINTS && - vc5->rasterizer->base.point_size_per_vertex); + v3d->rasterizer->base.point_size_per_vertex); - struct vc5_compiled_shader *vs = - vc5_get_compiled_shader(vc5, &key->base); - if (vs != vc5->prog.vs) { - vc5->prog.vs = vs; - vc5->dirty |= VC5_DIRTY_COMPILED_VS; + struct v3d_compiled_shader *vs = + v3d_get_compiled_shader(v3d, &key->base); + if (vs != v3d->prog.vs) { + v3d->prog.vs = vs; + v3d->dirty |= VC5_DIRTY_COMPILED_VS; } key->is_coord = true; /* Coord shaders only output varyings used by transform feedback. */ - struct vc5_uncompiled_shader *shader_state = key->base.shader_state; + struct v3d_uncompiled_shader *shader_state = key->base.shader_state; memcpy(key->fs_inputs, shader_state->tf_outputs, sizeof(*key->fs_inputs) * shader_state->num_tf_outputs); if (shader_state->num_tf_outputs < key->num_fs_inputs) { @@ -545,19 +545,19 @@ vc5_update_compiled_vs(struct vc5_context *vc5, uint8_t prim_mode) } key->num_fs_inputs = shader_state->num_tf_outputs; - struct vc5_compiled_shader *cs = - vc5_get_compiled_shader(vc5, &key->base); - if (cs != vc5->prog.cs) { - vc5->prog.cs = cs; - vc5->dirty |= VC5_DIRTY_COMPILED_CS; + struct v3d_compiled_shader *cs = + v3d_get_compiled_shader(v3d, &key->base); + if (cs != v3d->prog.cs) { + v3d->prog.cs = cs; + v3d->dirty |= VC5_DIRTY_COMPILED_CS; } } void -vc5_update_compiled_shaders(struct vc5_context *vc5, uint8_t prim_mode) +v3d_update_compiled_shaders(struct v3d_context *v3d, uint8_t prim_mode) { - vc5_update_compiled_fs(vc5, prim_mode); - vc5_update_compiled_vs(vc5, prim_mode); + v3d_update_compiled_fs(v3d, prim_mode); + v3d_update_compiled_vs(v3d, prim_mode); } static uint32_t @@ -586,16 +586,16 @@ vs_cache_compare(const void *key1, const void *key2) static void delete_from_cache_if_matches(struct hash_table *ht, - struct vc5_compiled_shader **last_compile, + struct v3d_compiled_shader **last_compile, struct hash_entry *entry, - struct vc5_uncompiled_shader *so) + struct v3d_uncompiled_shader *so) { const struct v3d_key *key = entry->key; if (key->shader_state == so) { - struct vc5_compiled_shader *shader = entry->data; + struct v3d_compiled_shader *shader = entry->data; _mesa_hash_table_remove(ht, entry); - vc5_bo_unreference(&shader->bo); + v3d_bo_unreference(&shader->bo); if (shader == *last_compile) *last_compile = NULL; @@ -605,18 +605,18 @@ delete_from_cache_if_matches(struct hash_table *ht, } static void -vc5_shader_state_delete(struct pipe_context *pctx, void *hwcso) +v3d_shader_state_delete(struct pipe_context *pctx, void *hwcso) { - struct vc5_context *vc5 = vc5_context(pctx); - struct vc5_uncompiled_shader *so = hwcso; + struct v3d_context *v3d = v3d_context(pctx); + struct v3d_uncompiled_shader *so = hwcso; struct hash_entry *entry; - hash_table_foreach(vc5->fs_cache, entry) { - delete_from_cache_if_matches(vc5->fs_cache, &vc5->prog.fs, + hash_table_foreach(v3d->fs_cache, entry) { + delete_from_cache_if_matches(v3d->fs_cache, &v3d->prog.fs, entry, so); } - hash_table_foreach(vc5->vs_cache, entry) { - delete_from_cache_if_matches(vc5->vs_cache, &vc5->prog.vs, + hash_table_foreach(v3d->vs_cache, entry) { + delete_from_cache_if_matches(v3d->vs_cache, &v3d->prog.vs, entry, so); } @@ -625,58 +625,58 @@ vc5_shader_state_delete(struct pipe_context *pctx, void *hwcso) } static void -vc5_fp_state_bind(struct pipe_context *pctx, void *hwcso) +v3d_fp_state_bind(struct pipe_context *pctx, void *hwcso) { - struct vc5_context *vc5 = vc5_context(pctx); - vc5->prog.bind_fs = hwcso; - vc5->dirty |= VC5_DIRTY_UNCOMPILED_FS; + struct v3d_context *v3d = v3d_context(pctx); + v3d->prog.bind_fs = hwcso; + v3d->dirty |= VC5_DIRTY_UNCOMPILED_FS; } static void -vc5_vp_state_bind(struct pipe_context *pctx, void *hwcso) +v3d_vp_state_bind(struct pipe_context *pctx, void *hwcso) { - struct vc5_context *vc5 = vc5_context(pctx); - vc5->prog.bind_vs = hwcso; - vc5->dirty |= VC5_DIRTY_UNCOMPILED_VS; + struct v3d_context *v3d = v3d_context(pctx); + v3d->prog.bind_vs = hwcso; + v3d->dirty |= VC5_DIRTY_UNCOMPILED_VS; } void -vc5_program_init(struct pipe_context *pctx) +v3d_program_init(struct pipe_context *pctx) { - struct vc5_context *vc5 = vc5_context(pctx); + struct v3d_context *v3d = v3d_context(pctx); - pctx->create_vs_state = vc5_shader_state_create; - pctx->delete_vs_state = vc5_shader_state_delete; + pctx->create_vs_state = v3d_shader_state_create; + pctx->delete_vs_state = v3d_shader_state_delete; - pctx->create_fs_state = vc5_shader_state_create; - pctx->delete_fs_state = vc5_shader_state_delete; + pctx->create_fs_state = v3d_shader_state_create; + pctx->delete_fs_state = v3d_shader_state_delete; - pctx->bind_fs_state = vc5_fp_state_bind; - pctx->bind_vs_state = vc5_vp_state_bind; + pctx->bind_fs_state = v3d_fp_state_bind; + pctx->bind_vs_state = v3d_vp_state_bind; - vc5->fs_cache = _mesa_hash_table_create(pctx, fs_cache_hash, + v3d->fs_cache = _mesa_hash_table_create(pctx, fs_cache_hash, fs_cache_compare); - vc5->vs_cache = _mesa_hash_table_create(pctx, vs_cache_hash, + v3d->vs_cache = _mesa_hash_table_create(pctx, vs_cache_hash, vs_cache_compare); } void -vc5_program_fini(struct pipe_context *pctx) +v3d_program_fini(struct pipe_context *pctx) { - struct vc5_context *vc5 = vc5_context(pctx); + struct v3d_context *v3d = v3d_context(pctx); struct hash_entry *entry; - hash_table_foreach(vc5->fs_cache, entry) { - struct vc5_compiled_shader *shader = entry->data; - vc5_bo_unreference(&shader->bo); + hash_table_foreach(v3d->fs_cache, entry) { + struct v3d_compiled_shader *shader = entry->data; + v3d_bo_unreference(&shader->bo); ralloc_free(shader); - _mesa_hash_table_remove(vc5->fs_cache, entry); + _mesa_hash_table_remove(v3d->fs_cache, entry); } - hash_table_foreach(vc5->vs_cache, entry) { - struct vc5_compiled_shader *shader = entry->data; - vc5_bo_unreference(&shader->bo); + hash_table_foreach(v3d->vs_cache, entry) { + struct v3d_compiled_shader *shader = entry->data; + v3d_bo_unreference(&shader->bo); ralloc_free(shader); - _mesa_hash_table_remove(vc5->vs_cache, entry); + _mesa_hash_table_remove(v3d->vs_cache, entry); } } diff --git a/src/gallium/drivers/v3d/v3d_query.c b/src/gallium/drivers/v3d/v3d_query.c index f645544bedf..d3447793b0a 100644 --- a/src/gallium/drivers/v3d/v3d_query.c +++ b/src/gallium/drivers/v3d/v3d_query.c @@ -36,18 +36,18 @@ #include "v3d_context.h" #include "broadcom/cle/v3d_packet_v33_pack.h" -struct vc5_query +struct v3d_query { enum pipe_query_type type; - struct vc5_bo *bo; + struct v3d_bo *bo; uint32_t start, end; }; static struct pipe_query * -vc5_create_query(struct pipe_context *pctx, unsigned query_type, unsigned index) +v3d_create_query(struct pipe_context *pctx, unsigned query_type, unsigned index) { - struct vc5_query *q = calloc(1, sizeof(*q)); + struct v3d_query *q = calloc(1, sizeof(*q)); q->type = query_type; @@ -56,34 +56,34 @@ vc5_create_query(struct pipe_context *pctx, unsigned query_type, unsigned index) } static void -vc5_destroy_query(struct pipe_context *pctx, struct pipe_query *query) +v3d_destroy_query(struct pipe_context *pctx, struct pipe_query *query) { - struct vc5_query *q = (struct vc5_query *)query; + struct v3d_query *q = (struct v3d_query *)query; - vc5_bo_unreference(&q->bo); + v3d_bo_unreference(&q->bo); free(q); } static boolean -vc5_begin_query(struct pipe_context *pctx, struct pipe_query *query) +v3d_begin_query(struct pipe_context *pctx, struct pipe_query *query) { - struct vc5_context *vc5 = vc5_context(pctx); - struct vc5_query *q = (struct vc5_query *)query; + struct v3d_context *v3d = v3d_context(pctx); + struct v3d_query *q = (struct v3d_query *)query; switch (q->type) { case PIPE_QUERY_PRIMITIVES_GENERATED: - q->start = vc5->prims_generated; + q->start = v3d->prims_generated; break; case PIPE_QUERY_PRIMITIVES_EMITTED: - q->start = vc5->tf_prims_generated; + q->start = v3d->tf_prims_generated; break; default: - q->bo = vc5_bo_alloc(vc5->screen, 4096, "query"); + q->bo = v3d_bo_alloc(v3d->screen, 4096, "query"); - uint32_t *map = vc5_bo_map(q->bo); + uint32_t *map = v3d_bo_map(q->bo); *map = 0; - vc5->current_oq = q->bo; - vc5->dirty |= VC5_DIRTY_OQ; + v3d->current_oq = q->bo; + v3d->dirty |= VC5_DIRTY_OQ; break; } @@ -91,21 +91,21 @@ vc5_begin_query(struct pipe_context *pctx, struct pipe_query *query) } static bool -vc5_end_query(struct pipe_context *pctx, struct pipe_query *query) +v3d_end_query(struct pipe_context *pctx, struct pipe_query *query) { - struct vc5_context *vc5 = vc5_context(pctx); - struct vc5_query *q = (struct vc5_query *)query; + struct v3d_context *v3d = v3d_context(pctx); + struct v3d_query *q = (struct v3d_query *)query; switch (q->type) { case PIPE_QUERY_PRIMITIVES_GENERATED: - q->end = vc5->prims_generated; + q->end = v3d->prims_generated; break; case PIPE_QUERY_PRIMITIVES_EMITTED: - q->end = vc5->tf_prims_generated; + q->end = v3d->tf_prims_generated; break; default: - vc5->current_oq = NULL; - vc5->dirty |= VC5_DIRTY_OQ; + v3d->current_oq = NULL; + v3d->dirty |= VC5_DIRTY_OQ; break; } @@ -113,29 +113,29 @@ vc5_end_query(struct pipe_context *pctx, struct pipe_query *query) } static boolean -vc5_get_query_result(struct pipe_context *pctx, struct pipe_query *query, +v3d_get_query_result(struct pipe_context *pctx, struct pipe_query *query, boolean wait, union pipe_query_result *vresult) { - struct vc5_query *q = (struct vc5_query *)query; + struct v3d_query *q = (struct v3d_query *)query; uint32_t result = 0; if (q->bo) { /* XXX: Only flush the jobs using this BO. */ - vc5_flush(pctx); + v3d_flush(pctx); if (wait) { - if (!vc5_bo_wait(q->bo, 0, "query")) + if (!v3d_bo_wait(q->bo, 0, "query")) return false; } else { - if (!vc5_bo_wait(q->bo, ~0ull, "query")) + if (!v3d_bo_wait(q->bo, ~0ull, "query")) return false; } /* XXX: Sum up per-core values. */ - uint32_t *map = vc5_bo_map(q->bo); + uint32_t *map = v3d_bo_map(q->bo); result = *map; - vc5_bo_unreference(&q->bo); + v3d_bo_unreference(&q->bo); } switch (q->type) { @@ -158,23 +158,23 @@ vc5_get_query_result(struct pipe_context *pctx, struct pipe_query *query, } static void -vc5_set_active_query_state(struct pipe_context *pctx, boolean enable) +v3d_set_active_query_state(struct pipe_context *pctx, boolean enable) { - struct vc5_context *vc5 = vc5_context(pctx); + struct v3d_context *v3d = v3d_context(pctx); - vc5->active_queries = enable; - vc5->dirty |= VC5_DIRTY_OQ; - vc5->dirty |= VC5_DIRTY_STREAMOUT; + v3d->active_queries = enable; + v3d->dirty |= VC5_DIRTY_OQ; + v3d->dirty |= VC5_DIRTY_STREAMOUT; } void -vc5_query_init(struct pipe_context *pctx) +v3d_query_init(struct pipe_context *pctx) { - pctx->create_query = vc5_create_query; - pctx->destroy_query = vc5_destroy_query; - pctx->begin_query = vc5_begin_query; - pctx->end_query = vc5_end_query; - pctx->get_query_result = vc5_get_query_result; - pctx->set_active_query_state = vc5_set_active_query_state; + pctx->create_query = v3d_create_query; + pctx->destroy_query = v3d_destroy_query; + pctx->begin_query = v3d_begin_query; + pctx->end_query = v3d_end_query; + pctx->get_query_result = v3d_get_query_result; + pctx->set_active_query_state = v3d_set_active_query_state; } diff --git a/src/gallium/drivers/v3d/v3d_resource.c b/src/gallium/drivers/v3d/v3d_resource.c index 1cd3f1949a2..d9b254a93e0 100644 --- a/src/gallium/drivers/v3d/v3d_resource.c +++ b/src/gallium/drivers/v3d/v3d_resource.c @@ -40,7 +40,7 @@ #include "broadcom/cle/v3d_packet_v33_pack.h" static void -vc5_debug_resource_layout(struct vc5_resource *rsc, const char *caller) +v3d_debug_resource_layout(struct v3d_resource *rsc, const char *caller) { if (!(V3D_DEBUG & V3D_DEBUG_SURFACE)) return; @@ -68,7 +68,7 @@ vc5_debug_resource_layout(struct vc5_resource *rsc, const char *caller) }; for (int i = 0; i <= prsc->last_level; i++) { - struct vc5_resource_slice *slice = &rsc->slices[i]; + struct v3d_resource_slice *slice = &rsc->slices[i]; int level_width = slice->stride / rsc->cpp; int level_height = slice->padded_height; @@ -94,17 +94,17 @@ vc5_debug_resource_layout(struct vc5_resource *rsc, const char *caller) } static bool -vc5_resource_bo_alloc(struct vc5_resource *rsc) +v3d_resource_bo_alloc(struct v3d_resource *rsc) { struct pipe_resource *prsc = &rsc->base; struct pipe_screen *pscreen = prsc->screen; - struct vc5_bo *bo; + struct v3d_bo *bo; - bo = vc5_bo_alloc(vc5_screen(pscreen), rsc->size, "resource"); + bo = v3d_bo_alloc(v3d_screen(pscreen), rsc->size, "resource"); if (bo) { - vc5_bo_unreference(&rsc->bo); + v3d_bo_unreference(&rsc->bo); rsc->bo = bo; - vc5_debug_resource_layout(rsc, "alloc"); + v3d_debug_resource_layout(rsc, "alloc"); return true; } else { return false; @@ -112,23 +112,23 @@ vc5_resource_bo_alloc(struct vc5_resource *rsc) } static void -vc5_resource_transfer_unmap(struct pipe_context *pctx, +v3d_resource_transfer_unmap(struct pipe_context *pctx, struct pipe_transfer *ptrans) { - struct vc5_context *vc5 = vc5_context(pctx); - struct vc5_transfer *trans = vc5_transfer(ptrans); + struct v3d_context *v3d = v3d_context(pctx); + struct v3d_transfer *trans = v3d_transfer(ptrans); if (trans->map) { - struct vc5_resource *rsc = vc5_resource(ptrans->resource); - struct vc5_resource_slice *slice = &rsc->slices[ptrans->level]; + struct v3d_resource *rsc = v3d_resource(ptrans->resource); + struct v3d_resource_slice *slice = &rsc->slices[ptrans->level]; if (ptrans->usage & PIPE_TRANSFER_WRITE) { for (int z = 0; z < ptrans->box.depth; z++) { void *dst = rsc->bo->map + - vc5_layer_offset(&rsc->base, + v3d_layer_offset(&rsc->base, ptrans->level, ptrans->box.z + z); - vc5_store_tiled_image(dst, + v3d_store_tiled_image(dst, slice->stride, (trans->map + ptrans->stride * @@ -143,19 +143,19 @@ vc5_resource_transfer_unmap(struct pipe_context *pctx, } pipe_resource_reference(&ptrans->resource, NULL); - slab_free(&vc5->transfer_pool, ptrans); + slab_free(&v3d->transfer_pool, ptrans); } static void * -vc5_resource_transfer_map(struct pipe_context *pctx, +v3d_resource_transfer_map(struct pipe_context *pctx, struct pipe_resource *prsc, unsigned level, unsigned usage, const struct pipe_box *box, struct pipe_transfer **pptrans) { - struct vc5_context *vc5 = vc5_context(pctx); - struct vc5_resource *rsc = vc5_resource(prsc); - struct vc5_transfer *trans; + struct v3d_context *v3d = v3d_context(pctx); + struct v3d_resource *rsc = v3d_resource(prsc); + struct v3d_transfer *trans; struct pipe_transfer *ptrans; enum pipe_format format = prsc->format; char *buf; @@ -179,20 +179,20 @@ vc5_resource_transfer_map(struct pipe_context *pctx, } if (usage & PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE) { - if (vc5_resource_bo_alloc(rsc)) { + if (v3d_resource_bo_alloc(rsc)) { /* If it might be bound as one of our vertex buffers * or UBOs, make sure we re-emit vertex buffer state * or uniforms. */ if (prsc->bind & PIPE_BIND_VERTEX_BUFFER) - vc5->dirty |= VC5_DIRTY_VTXBUF; + v3d->dirty |= VC5_DIRTY_VTXBUF; if (prsc->bind & PIPE_BIND_CONSTANT_BUFFER) - vc5->dirty |= VC5_DIRTY_CONSTBUF; + v3d->dirty |= VC5_DIRTY_CONSTBUF; } else { /* If we failed to reallocate, flush users so that we * don't violate any syncing requirements. */ - vc5_flush_jobs_reading_resource(vc5, prsc); + v3d_flush_jobs_reading_resource(v3d, prsc); } } else if (!(usage & PIPE_TRANSFER_UNSYNCHRONIZED)) { /* If we're writing and the buffer is being used by the CL, we @@ -200,9 +200,9 @@ vc5_resource_transfer_map(struct pipe_context *pctx, * to flush if the CL has written our buffer. */ if (usage & PIPE_TRANSFER_WRITE) - vc5_flush_jobs_reading_resource(vc5, prsc); + v3d_flush_jobs_reading_resource(v3d, prsc); else - vc5_flush_jobs_writing_resource(vc5, prsc); + v3d_flush_jobs_writing_resource(v3d, prsc); } if (usage & PIPE_TRANSFER_WRITE) { @@ -210,7 +210,7 @@ vc5_resource_transfer_map(struct pipe_context *pctx, rsc->initialized_buffers = ~0; } - trans = slab_alloc(&vc5->transfer_pool); + trans = slab_alloc(&v3d->transfer_pool); if (!trans) return NULL; @@ -230,9 +230,9 @@ vc5_resource_transfer_map(struct pipe_context *pctx, */ if (usage & PIPE_TRANSFER_UNSYNCHRONIZED) - buf = vc5_bo_map_unsynchronized(rsc->bo); + buf = v3d_bo_map_unsynchronized(rsc->bo); else - buf = vc5_bo_map(rsc->bo); + buf = v3d_bo_map(rsc->bo); if (!buf) { fprintf(stderr, "Failed to map bo\n"); goto fail; @@ -248,7 +248,7 @@ vc5_resource_transfer_map(struct pipe_context *pctx, ptrans->box.height = DIV_ROUND_UP(ptrans->box.height, util_format_get_blockheight(format)); - struct vc5_resource_slice *slice = &rsc->slices[level]; + struct v3d_resource_slice *slice = &rsc->slices[level]; if (rsc->tiled) { /* No direct mappings of tiled, since we need to manually * tile/untile. @@ -264,10 +264,10 @@ vc5_resource_transfer_map(struct pipe_context *pctx, if (usage & PIPE_TRANSFER_READ) { for (int z = 0; z < ptrans->box.depth; z++) { void *src = rsc->bo->map + - vc5_layer_offset(&rsc->base, + v3d_layer_offset(&rsc->base, ptrans->level, ptrans->box.z + z); - vc5_load_tiled_image((trans->map + + v3d_load_tiled_image((trans->map + ptrans->stride * ptrans->box.height * z), ptrans->stride, @@ -291,29 +291,29 @@ vc5_resource_transfer_map(struct pipe_context *pctx, fail: - vc5_resource_transfer_unmap(pctx, ptrans); + v3d_resource_transfer_unmap(pctx, ptrans); return NULL; } static void -vc5_resource_destroy(struct pipe_screen *pscreen, +v3d_resource_destroy(struct pipe_screen *pscreen, struct pipe_resource *prsc) { - struct vc5_resource *rsc = vc5_resource(prsc); + struct v3d_resource *rsc = v3d_resource(prsc); - vc5_bo_unreference(&rsc->bo); + v3d_bo_unreference(&rsc->bo); free(rsc); } static boolean -vc5_resource_get_handle(struct pipe_screen *pscreen, +v3d_resource_get_handle(struct pipe_screen *pscreen, struct pipe_context *pctx, struct pipe_resource *prsc, struct winsys_handle *whandle, unsigned usage) { - struct vc5_resource *rsc = vc5_resource(prsc); - struct vc5_bo *bo = rsc->bo; + struct v3d_resource *rsc = v3d_resource(prsc); + struct v3d_bo *bo = rsc->bo; whandle->stride = rsc->slices[0].stride; @@ -325,12 +325,12 @@ vc5_resource_get_handle(struct pipe_screen *pscreen, switch (whandle->type) { case DRM_API_HANDLE_TYPE_SHARED: - return vc5_bo_flink(bo, &whandle->handle); + return v3d_bo_flink(bo, &whandle->handle); case DRM_API_HANDLE_TYPE_KMS: whandle->handle = bo->handle; return TRUE; case DRM_API_HANDLE_TYPE_FD: - whandle->handle = vc5_bo_get_dmabuf(bo); + whandle->handle = v3d_bo_get_dmabuf(bo); return whandle->handle != -1; } @@ -350,9 +350,9 @@ vc5_resource_get_handle(struct pipe_screen *pscreen, * between columns of UIF blocks. */ static uint32_t -vc5_get_ub_pad(struct vc5_resource *rsc, uint32_t height) +v3d_get_ub_pad(struct v3d_resource *rsc, uint32_t height) { - uint32_t utile_h = vc5_utile_height(rsc->cpp); + uint32_t utile_h = v3d_utile_height(rsc->cpp); uint32_t uif_block_h = utile_h * 2; uint32_t height_ub = height / uif_block_h; @@ -384,7 +384,7 @@ vc5_get_ub_pad(struct vc5_resource *rsc, uint32_t height) } static void -vc5_setup_slices(struct vc5_resource *rsc) +v3d_setup_slices(struct v3d_resource *rsc) { struct pipe_resource *prsc = &rsc->base; uint32_t width = prsc->width0; @@ -399,8 +399,8 @@ vc5_setup_slices(struct vc5_resource *rsc) uint32_t pot_height = 2 * util_next_power_of_two(u_minify(height, 1)); uint32_t pot_depth = 2 * util_next_power_of_two(u_minify(depth, 1)); uint32_t offset = 0; - uint32_t utile_w = vc5_utile_width(rsc->cpp); - uint32_t utile_h = vc5_utile_height(rsc->cpp); + uint32_t utile_w = v3d_utile_width(rsc->cpp); + uint32_t utile_h = v3d_utile_height(rsc->cpp); uint32_t uif_block_w = utile_w * 2; uint32_t uif_block_h = utile_h * 2; uint32_t block_width = util_format_get_blockwidth(prsc->format); @@ -412,7 +412,7 @@ vc5_setup_slices(struct vc5_resource *rsc) bool uif_top = msaa; for (int i = prsc->last_level; i >= 0; i--) { - struct vc5_resource_slice *slice = &rsc->slices[i]; + struct v3d_resource_slice *slice = &rsc->slices[i]; uint32_t level_width, level_height, level_depth; if (i < 2) { @@ -466,7 +466,7 @@ vc5_setup_slices(struct vc5_resource *rsc) level_height = align(level_height, uif_block_h); - slice->ub_pad = vc5_get_ub_pad(rsc, + slice->ub_pad = v3d_get_ub_pad(rsc, level_height); level_height += slice->ub_pad * uif_block_h; @@ -539,10 +539,10 @@ vc5_setup_slices(struct vc5_resource *rsc) } uint32_t -vc5_layer_offset(struct pipe_resource *prsc, uint32_t level, uint32_t layer) +v3d_layer_offset(struct pipe_resource *prsc, uint32_t level, uint32_t layer) { - struct vc5_resource *rsc = vc5_resource(prsc); - struct vc5_resource_slice *slice = &rsc->slices[level]; + struct v3d_resource *rsc = v3d_resource(prsc); + struct v3d_resource_slice *slice = &rsc->slices[level]; if (prsc->target == PIPE_TEXTURE_3D) return slice->offset + layer * slice->size; @@ -550,12 +550,12 @@ vc5_layer_offset(struct pipe_resource *prsc, uint32_t level, uint32_t layer) return slice->offset + layer * rsc->cube_map_stride; } -static struct vc5_resource * -vc5_resource_setup(struct pipe_screen *pscreen, +static struct v3d_resource * +v3d_resource_setup(struct pipe_screen *pscreen, const struct pipe_resource *tmpl) { - struct vc5_screen *screen = vc5_screen(pscreen); - struct vc5_resource *rsc = CALLOC_STRUCT(vc5_resource); + struct v3d_screen *screen = v3d_screen(pscreen); + struct v3d_resource *rsc = CALLOC_STRUCT(v3d_resource); if (!rsc) return NULL; struct pipe_resource *prsc = &rsc->base; @@ -572,12 +572,12 @@ vc5_resource_setup(struct pipe_screen *pscreen, if (screen->devinfo.ver < 40 && prsc->nr_samples > 1) rsc->cpp *= prsc->nr_samples; } else { - assert(vc5_rt_format_supported(&screen->devinfo, prsc->format)); + assert(v3d_rt_format_supported(&screen->devinfo, prsc->format)); uint32_t output_image_format = - vc5_get_rt_format(&screen->devinfo, prsc->format); + v3d_get_rt_format(&screen->devinfo, prsc->format); uint32_t internal_type; uint32_t internal_bpp; - vc5_get_internal_type_bpp_for_output_format(&screen->devinfo, + v3d_get_internal_type_bpp_for_output_format(&screen->devinfo, output_image_format, &internal_type, &internal_bpp); @@ -613,13 +613,13 @@ find_modifier(uint64_t needle, const uint64_t *haystack, int count) } static struct pipe_resource * -vc5_resource_create_with_modifiers(struct pipe_screen *pscreen, +v3d_resource_create_with_modifiers(struct pipe_screen *pscreen, const struct pipe_resource *tmpl, const uint64_t *modifiers, int count) { bool linear_ok = find_modifier(DRM_FORMAT_MOD_LINEAR, modifiers, count); - struct vc5_resource *rsc = vc5_resource_setup(pscreen, tmpl); + struct v3d_resource *rsc = v3d_resource_setup(pscreen, tmpl); struct pipe_resource *prsc = &rsc->base; /* Use a tiled layout if we can, for better 3D performance. */ bool should_tile = true; @@ -641,7 +641,7 @@ vc5_resource_create_with_modifiers(struct pipe_screen *pscreen, /* Scanout BOs for simulator need to be linear for interaction with * i965. */ - if (using_vc5_simulator && + if (using_v3d_simulator && tmpl->bind & (PIPE_BIND_SHARED | PIPE_BIND_SCANOUT)) should_tile = false; @@ -662,34 +662,34 @@ vc5_resource_create_with_modifiers(struct pipe_screen *pscreen, rsc->internal_format = prsc->format; - vc5_setup_slices(rsc); - if (!vc5_resource_bo_alloc(rsc)) + v3d_setup_slices(rsc); + if (!v3d_resource_bo_alloc(rsc)) goto fail; return prsc; fail: - vc5_resource_destroy(pscreen, prsc); + v3d_resource_destroy(pscreen, prsc); return NULL; } struct pipe_resource * -vc5_resource_create(struct pipe_screen *pscreen, +v3d_resource_create(struct pipe_screen *pscreen, const struct pipe_resource *tmpl) { const uint64_t mod = DRM_FORMAT_MOD_INVALID; - return vc5_resource_create_with_modifiers(pscreen, tmpl, &mod, 1); + return v3d_resource_create_with_modifiers(pscreen, tmpl, &mod, 1); } static struct pipe_resource * -vc5_resource_from_handle(struct pipe_screen *pscreen, +v3d_resource_from_handle(struct pipe_screen *pscreen, const struct pipe_resource *tmpl, struct winsys_handle *whandle, unsigned usage) { - struct vc5_screen *screen = vc5_screen(pscreen); - struct vc5_resource *rsc = vc5_resource_setup(pscreen, tmpl); + struct v3d_screen *screen = v3d_screen(pscreen); + struct v3d_resource *rsc = v3d_resource_setup(pscreen, tmpl); struct pipe_resource *prsc = &rsc->base; - struct vc5_resource_slice *slice = &rsc->slices[0]; + struct v3d_resource_slice *slice = &rsc->slices[0]; if (!rsc) return NULL; @@ -716,11 +716,11 @@ vc5_resource_from_handle(struct pipe_screen *pscreen, switch (whandle->type) { case DRM_API_HANDLE_TYPE_SHARED: - rsc->bo = vc5_bo_open_name(screen, + rsc->bo = v3d_bo_open_name(screen, whandle->handle, whandle->stride); break; case DRM_API_HANDLE_TYPE_FD: - rsc->bo = vc5_bo_open_dmabuf(screen, + rsc->bo = v3d_bo_open_dmabuf(screen, whandle->handle, whandle->stride); break; default: @@ -735,8 +735,8 @@ vc5_resource_from_handle(struct pipe_screen *pscreen, rsc->internal_format = prsc->format; - vc5_setup_slices(rsc); - vc5_debug_resource_layout(rsc, "import"); + v3d_setup_slices(rsc); + v3d_debug_resource_layout(rsc, "import"); if (whandle->stride != slice->stride) { static bool warned = false; @@ -756,19 +756,19 @@ vc5_resource_from_handle(struct pipe_screen *pscreen, return prsc; fail: - vc5_resource_destroy(pscreen, prsc); + v3d_resource_destroy(pscreen, prsc); return NULL; } static struct pipe_surface * -vc5_create_surface(struct pipe_context *pctx, +v3d_create_surface(struct pipe_context *pctx, struct pipe_resource *ptex, const struct pipe_surface *surf_tmpl) { - struct vc5_context *vc5 = vc5_context(pctx); - struct vc5_screen *screen = vc5->screen; - struct vc5_surface *surface = CALLOC_STRUCT(vc5_surface); - struct vc5_resource *rsc = vc5_resource(ptex); + struct v3d_context *v3d = v3d_context(pctx); + struct v3d_screen *screen = v3d->screen; + struct v3d_surface *surface = CALLOC_STRUCT(v3d_surface); + struct v3d_resource *rsc = v3d_resource(ptex); if (!surface) return NULL; @@ -777,7 +777,7 @@ vc5_create_surface(struct pipe_context *pctx, struct pipe_surface *psurf = &surface->base; unsigned level = surf_tmpl->u.tex.level; - struct vc5_resource_slice *slice = &rsc->slices[level]; + struct v3d_resource_slice *slice = &rsc->slices[level]; pipe_reference_init(&psurf->reference, 1); pipe_resource_reference(&psurf->texture, ptex); @@ -790,11 +790,11 @@ vc5_create_surface(struct pipe_context *pctx, psurf->u.tex.first_layer = surf_tmpl->u.tex.first_layer; psurf->u.tex.last_layer = surf_tmpl->u.tex.last_layer; - surface->offset = vc5_layer_offset(ptex, level, + surface->offset = v3d_layer_offset(ptex, level, psurf->u.tex.first_layer); surface->tiling = slice->tiling; - surface->format = vc5_get_rt_format(&screen->devinfo, psurf->format); + surface->format = v3d_get_rt_format(&screen->devinfo, psurf->format); if (util_format_is_depth_or_stencil(psurf->format)) { switch (psurf->format) { @@ -810,7 +810,7 @@ vc5_create_surface(struct pipe_context *pctx, } } else { uint32_t bpp, type; - vc5_get_internal_type_bpp_for_output_format(&screen->devinfo, + v3d_get_internal_type_bpp_for_output_format(&screen->devinfo, surface->format, &type, &bpp); surface->internal_type = type; @@ -821,12 +821,12 @@ vc5_create_surface(struct pipe_context *pctx, surface->tiling == VC5_TILING_UIF_XOR) { surface->padded_height_of_output_image_in_uif_blocks = (slice->padded_height / - (2 * vc5_utile_height(rsc->cpp))); + (2 * v3d_utile_height(rsc->cpp))); } if (rsc->separate_stencil) { surface->separate_stencil = - vc5_create_surface(pctx, &rsc->separate_stencil->base, + v3d_create_surface(pctx, &rsc->separate_stencil->base, surf_tmpl); } @@ -834,9 +834,9 @@ vc5_create_surface(struct pipe_context *pctx, } static void -vc5_surface_destroy(struct pipe_context *pctx, struct pipe_surface *psurf) +v3d_surface_destroy(struct pipe_context *pctx, struct pipe_surface *psurf) { - struct vc5_surface *surf = vc5_surface(psurf); + struct v3d_surface *surf = v3d_surface(psurf); if (surf->separate_stencil) pipe_surface_reference(&surf->separate_stencil, NULL); @@ -846,7 +846,7 @@ vc5_surface_destroy(struct pipe_context *pctx, struct pipe_surface *psurf) } static void -vc5_flush_resource(struct pipe_context *pctx, struct pipe_resource *resource) +v3d_flush_resource(struct pipe_context *pctx, struct pipe_resource *resource) { /* All calls to flush_resource are followed by a flush of the context, * so there's nothing to do. @@ -854,61 +854,61 @@ vc5_flush_resource(struct pipe_context *pctx, struct pipe_resource *resource) } static enum pipe_format -vc5_resource_get_internal_format(struct pipe_resource *prsc) +v3d_resource_get_internal_format(struct pipe_resource *prsc) { - return vc5_resource(prsc)->internal_format; + return v3d_resource(prsc)->internal_format; } static void -vc5_resource_set_stencil(struct pipe_resource *prsc, +v3d_resource_set_stencil(struct pipe_resource *prsc, struct pipe_resource *stencil) { - vc5_resource(prsc)->separate_stencil = vc5_resource(stencil); + v3d_resource(prsc)->separate_stencil = v3d_resource(stencil); } static struct pipe_resource * -vc5_resource_get_stencil(struct pipe_resource *prsc) +v3d_resource_get_stencil(struct pipe_resource *prsc) { - struct vc5_resource *rsc = vc5_resource(prsc); + struct v3d_resource *rsc = v3d_resource(prsc); return &rsc->separate_stencil->base; } static const struct u_transfer_vtbl transfer_vtbl = { - .resource_create = vc5_resource_create, - .resource_destroy = vc5_resource_destroy, - .transfer_map = vc5_resource_transfer_map, - .transfer_unmap = vc5_resource_transfer_unmap, + .resource_create = v3d_resource_create, + .resource_destroy = v3d_resource_destroy, + .transfer_map = v3d_resource_transfer_map, + .transfer_unmap = v3d_resource_transfer_unmap, .transfer_flush_region = u_default_transfer_flush_region, - .get_internal_format = vc5_resource_get_internal_format, - .set_stencil = vc5_resource_set_stencil, - .get_stencil = vc5_resource_get_stencil, + .get_internal_format = v3d_resource_get_internal_format, + .set_stencil = v3d_resource_set_stencil, + .get_stencil = v3d_resource_get_stencil, }; void -vc5_resource_screen_init(struct pipe_screen *pscreen) +v3d_resource_screen_init(struct pipe_screen *pscreen) { pscreen->resource_create_with_modifiers = - vc5_resource_create_with_modifiers; + v3d_resource_create_with_modifiers; pscreen->resource_create = u_transfer_helper_resource_create; - pscreen->resource_from_handle = vc5_resource_from_handle; - pscreen->resource_get_handle = vc5_resource_get_handle; + pscreen->resource_from_handle = v3d_resource_from_handle; + pscreen->resource_get_handle = v3d_resource_get_handle; pscreen->resource_destroy = u_transfer_helper_resource_destroy; pscreen->transfer_helper = u_transfer_helper_create(&transfer_vtbl, true, true, true); } void -vc5_resource_context_init(struct pipe_context *pctx) +v3d_resource_context_init(struct pipe_context *pctx) { pctx->transfer_map = u_transfer_helper_transfer_map; pctx->transfer_flush_region = u_transfer_helper_transfer_flush_region; pctx->transfer_unmap = u_transfer_helper_transfer_unmap; pctx->buffer_subdata = u_default_buffer_subdata; pctx->texture_subdata = u_default_texture_subdata; - pctx->create_surface = vc5_create_surface; - pctx->surface_destroy = vc5_surface_destroy; + pctx->create_surface = v3d_create_surface; + pctx->surface_destroy = v3d_surface_destroy; pctx->resource_copy_region = util_resource_copy_region; - pctx->blit = vc5_blit; - pctx->flush_resource = vc5_flush_resource; + pctx->blit = v3d_blit; + pctx->flush_resource = v3d_flush_resource; } diff --git a/src/gallium/drivers/v3d/v3d_resource.h b/src/gallium/drivers/v3d/v3d_resource.h index dc68f803e90..141c4ca1f61 100644 --- a/src/gallium/drivers/v3d/v3d_resource.h +++ b/src/gallium/drivers/v3d/v3d_resource.h @@ -38,10 +38,10 @@ */ /** - * Tiling mode enum used for vc5_resource.c, which maps directly to the Memory + * Tiling mode enum used for v3d_resource.c, which maps directly to the Memory * Format field of render target and Z/Stencil config. */ -enum vc5_tiling_mode { +enum v3d_tiling_mode { /* Untiled resources. Not valid as texture inputs. */ VC5_TILING_RASTER, @@ -65,12 +65,12 @@ enum vc5_tiling_mode { VC5_TILING_UIF_XOR, }; -struct vc5_transfer { +struct v3d_transfer { struct pipe_transfer base; void *map; }; -struct vc5_resource_slice { +struct v3d_resource_slice { uint32_t offset; uint32_t stride; uint32_t padded_height; @@ -80,13 +80,13 @@ struct vc5_resource_slice { */ uint32_t size; uint8_t ub_pad; - enum vc5_tiling_mode tiling; + enum v3d_tiling_mode tiling; }; -struct vc5_surface { +struct v3d_surface { struct pipe_surface base; uint32_t offset; - enum vc5_tiling_mode tiling; + enum v3d_tiling_mode tiling; /** * Output image format for TILE_RENDERING_MODE_CONFIGURATION */ @@ -112,10 +112,10 @@ struct vc5_surface { struct pipe_surface *separate_stencil; }; -struct vc5_resource { +struct v3d_resource { struct pipe_resource base; - struct vc5_bo *bo; - struct vc5_resource_slice slices[VC5_MAX_MIP_LEVELS]; + struct v3d_bo *bo; + struct v3d_resource_slice slices[VC5_MAX_MIP_LEVELS]; uint32_t cube_map_stride; uint32_t size; int cpp; @@ -143,32 +143,32 @@ struct vc5_resource { enum pipe_format internal_format; /* Resource storing the S8 part of a Z32F_S8 resource, or NULL. */ - struct vc5_resource *separate_stencil; + struct v3d_resource *separate_stencil; }; -static inline struct vc5_resource * -vc5_resource(struct pipe_resource *prsc) +static inline struct v3d_resource * +v3d_resource(struct pipe_resource *prsc) { - return (struct vc5_resource *)prsc; + return (struct v3d_resource *)prsc; } -static inline struct vc5_surface * -vc5_surface(struct pipe_surface *psurf) +static inline struct v3d_surface * +v3d_surface(struct pipe_surface *psurf) { - return (struct vc5_surface *)psurf; + return (struct v3d_surface *)psurf; } -static inline struct vc5_transfer * -vc5_transfer(struct pipe_transfer *ptrans) +static inline struct v3d_transfer * +v3d_transfer(struct pipe_transfer *ptrans) { - return (struct vc5_transfer *)ptrans; + return (struct v3d_transfer *)ptrans; } -void vc5_resource_screen_init(struct pipe_screen *pscreen); -void vc5_resource_context_init(struct pipe_context *pctx); -struct pipe_resource *vc5_resource_create(struct pipe_screen *pscreen, +void v3d_resource_screen_init(struct pipe_screen *pscreen); +void v3d_resource_context_init(struct pipe_context *pctx); +struct pipe_resource *v3d_resource_create(struct pipe_screen *pscreen, const struct pipe_resource *tmpl); -uint32_t vc5_layer_offset(struct pipe_resource *prsc, uint32_t level, +uint32_t v3d_layer_offset(struct pipe_resource *prsc, uint32_t level, uint32_t layer); diff --git a/src/gallium/drivers/v3d/v3d_screen.c b/src/gallium/drivers/v3d/v3d_screen.c index 95e6a6907f4..3777802a6d7 100644 --- a/src/gallium/drivers/v3d/v3d_screen.c +++ b/src/gallium/drivers/v3d/v3d_screen.c @@ -40,9 +40,9 @@ #include "compiler/v3d_compiler.h" static const char * -vc5_screen_get_name(struct pipe_screen *pscreen) +v3d_screen_get_name(struct pipe_screen *pscreen) { - struct vc5_screen *screen = vc5_screen(pscreen); + struct v3d_screen *screen = v3d_screen(pscreen); if (!screen->name) { screen->name = ralloc_asprintf(screen, @@ -55,22 +55,22 @@ vc5_screen_get_name(struct pipe_screen *pscreen) } static const char * -vc5_screen_get_vendor(struct pipe_screen *pscreen) +v3d_screen_get_vendor(struct pipe_screen *pscreen) { return "Broadcom"; } static void -vc5_screen_destroy(struct pipe_screen *pscreen) +v3d_screen_destroy(struct pipe_screen *pscreen) { - struct vc5_screen *screen = vc5_screen(pscreen); + struct v3d_screen *screen = v3d_screen(pscreen); util_hash_table_destroy(screen->bo_handles); - vc5_bufmgr_destroy(pscreen); + v3d_bufmgr_destroy(pscreen); slab_destroy_parent(&screen->transfer_pool); - if (using_vc5_simulator) - vc5_simulator_destroy(screen); + if (using_v3d_simulator) + v3d_simulator_destroy(screen); v3d_compiler_free(screen->compiler); @@ -79,9 +79,9 @@ vc5_screen_destroy(struct pipe_screen *pscreen) } static int -vc5_screen_get_param(struct pipe_screen *pscreen, enum pipe_cap param) +v3d_screen_get_param(struct pipe_screen *pscreen, enum pipe_cap param) { - struct vc5_screen *screen = vc5_screen(pscreen); + struct v3d_screen *screen = v3d_screen(pscreen); switch (param) { /* Supported features (boolean caps). */ @@ -323,7 +323,7 @@ vc5_screen_get_param(struct pipe_screen *pscreen, enum pipe_cap param) } static float -vc5_screen_get_paramf(struct pipe_screen *pscreen, enum pipe_capf param) +v3d_screen_get_paramf(struct pipe_screen *pscreen, enum pipe_capf param) { switch (param) { case PIPE_CAPF_MAX_LINE_WIDTH: @@ -350,7 +350,7 @@ vc5_screen_get_paramf(struct pipe_screen *pscreen, enum pipe_capf param) } static int -vc5_screen_get_shader_param(struct pipe_screen *pscreen, unsigned shader, +v3d_screen_get_shader_param(struct pipe_screen *pscreen, unsigned shader, enum pipe_shader_cap param) { if (shader != PIPE_SHADER_VERTEX && @@ -429,13 +429,13 @@ vc5_screen_get_shader_param(struct pipe_screen *pscreen, unsigned shader, } static boolean -vc5_screen_is_format_supported(struct pipe_screen *pscreen, +v3d_screen_is_format_supported(struct pipe_screen *pscreen, enum pipe_format format, enum pipe_texture_target target, unsigned sample_count, unsigned usage) { - struct vc5_screen *screen = vc5_screen(pscreen); + struct v3d_screen *screen = v3d_screen(pscreen); if (sample_count > 1 && sample_count != VC5_MAX_SAMPLES) return FALSE; @@ -506,12 +506,12 @@ vc5_screen_is_format_supported(struct pipe_screen *pscreen, } if ((usage & PIPE_BIND_RENDER_TARGET) && - !vc5_rt_format_supported(&screen->devinfo, format)) { + !v3d_rt_format_supported(&screen->devinfo, format)) { return FALSE; } if ((usage & PIPE_BIND_SAMPLER_VIEW) && - !vc5_tex_format_supported(&screen->devinfo, format)) { + !v3d_tex_format_supported(&screen->devinfo, format)) { return FALSE; } @@ -547,7 +547,7 @@ static int handle_compare(void *key1, void *key2) } static bool -vc5_get_device_info(struct vc5_screen *screen) +v3d_get_device_info(struct v3d_screen *screen) { struct drm_v3d_get_param ident0 = { .param = DRM_V3D_PARAM_V3D_CORE0_IDENT0, @@ -557,13 +557,13 @@ vc5_get_device_info(struct vc5_screen *screen) }; int ret; - ret = vc5_ioctl(screen->fd, DRM_IOCTL_V3D_GET_PARAM, &ident0); + ret = v3d_ioctl(screen->fd, DRM_IOCTL_V3D_GET_PARAM, &ident0); if (ret != 0) { fprintf(stderr, "Couldn't get V3D core IDENT0: %s\n", strerror(errno)); return false; } - ret = vc5_ioctl(screen->fd, DRM_IOCTL_V3D_GET_PARAM, &ident1); + ret = v3d_ioctl(screen->fd, DRM_IOCTL_V3D_GET_PARAM, &ident1); if (ret != 0) { fprintf(stderr, "Couldn't get V3D core IDENT1: %s\n", strerror(errno)); @@ -591,7 +591,7 @@ vc5_get_device_info(struct vc5_screen *screen) } static const void * -vc5_screen_get_compiler_options(struct pipe_screen *pscreen, +v3d_screen_get_compiler_options(struct pipe_screen *pscreen, enum pipe_shader_ir ir, unsigned shader) { return &v3d_nir_options; @@ -600,17 +600,17 @@ vc5_screen_get_compiler_options(struct pipe_screen *pscreen, struct pipe_screen * v3d_screen_create(int fd) { - struct vc5_screen *screen = rzalloc(NULL, struct vc5_screen); + struct v3d_screen *screen = rzalloc(NULL, struct v3d_screen); struct pipe_screen *pscreen; pscreen = &screen->base; - pscreen->destroy = vc5_screen_destroy; - pscreen->get_param = vc5_screen_get_param; - pscreen->get_paramf = vc5_screen_get_paramf; - pscreen->get_shader_param = vc5_screen_get_shader_param; - pscreen->context_create = vc5_context_create; - pscreen->is_format_supported = vc5_screen_is_format_supported; + pscreen->destroy = v3d_screen_destroy; + pscreen->get_param = v3d_screen_get_param; + pscreen->get_paramf = v3d_screen_get_paramf; + pscreen->get_shader_param = v3d_screen_get_shader_param; + pscreen->context_create = v3d_context_create; + pscreen->is_format_supported = v3d_screen_is_format_supported; screen->fd = fd; list_inithead(&screen->bo_cache.time_list); @@ -618,26 +618,26 @@ v3d_screen_create(int fd) screen->bo_handles = util_hash_table_create(handle_hash, handle_compare); #if defined(USE_V3D_SIMULATOR) - vc5_simulator_init(screen); + v3d_simulator_init(screen); #endif - if (!vc5_get_device_info(screen)) + if (!v3d_get_device_info(screen)) goto fail; - slab_create_parent(&screen->transfer_pool, sizeof(struct vc5_transfer), 16); + slab_create_parent(&screen->transfer_pool, sizeof(struct v3d_transfer), 16); - vc5_fence_init(screen); + v3d_fence_init(screen); v3d_process_debug_variable(); - vc5_resource_screen_init(pscreen); + v3d_resource_screen_init(pscreen); screen->compiler = v3d_compiler_init(&screen->devinfo); - pscreen->get_name = vc5_screen_get_name; - pscreen->get_vendor = vc5_screen_get_vendor; - pscreen->get_device_vendor = vc5_screen_get_vendor; - pscreen->get_compiler_options = vc5_screen_get_compiler_options; + pscreen->get_name = v3d_screen_get_name; + pscreen->get_vendor = v3d_screen_get_vendor; + pscreen->get_device_vendor = v3d_screen_get_vendor; + pscreen->get_compiler_options = v3d_screen_get_compiler_options; return pscreen; diff --git a/src/gallium/drivers/v3d/v3d_screen.h b/src/gallium/drivers/v3d/v3d_screen.h index 975bfe01a75..111dd196f6c 100644 --- a/src/gallium/drivers/v3d/v3d_screen.h +++ b/src/gallium/drivers/v3d/v3d_screen.h @@ -32,7 +32,7 @@ #include "broadcom/common/v3d_debug.h" #include "broadcom/common/v3d_device_info.h" -struct vc5_bo; +struct v3d_bo; #define VC5_MAX_MIP_LEVELS 12 #define VC5_MAX_TEXTURE_SAMPLERS 32 @@ -51,9 +51,9 @@ struct vc5_bo; #define VC5_UIFBLOCK_SIZE (4 * VC5_UBLOCK_SIZE) #define VC5_UIFBLOCK_ROW_SIZE (4 * VC5_UIFBLOCK_SIZE) -struct vc5_simulator_file; +struct v3d_simulator_file; -struct vc5_screen { +struct v3d_screen { struct pipe_screen base; int fd; @@ -63,10 +63,10 @@ struct vc5_screen { struct slab_parent_pool transfer_pool; - struct vc5_bo_cache { - /** List of struct vc5_bo freed, by age. */ + struct v3d_bo_cache { + /** List of struct v3d_bo freed, by age. */ struct list_head time_list; - /** List of struct vc5_bo freed, per size, by age. */ + /** List of struct v3d_bo freed, per size, by age. */ struct list_head *size_list; uint32_t size_list_size; @@ -84,18 +84,18 @@ struct vc5_screen { uint32_t bo_size; uint32_t bo_count; - struct vc5_simulator_file *sim_file; + struct v3d_simulator_file *sim_file; }; -static inline struct vc5_screen * -vc5_screen(struct pipe_screen *screen) +static inline struct v3d_screen * +v3d_screen(struct pipe_screen *screen) { - return (struct vc5_screen *)screen; + return (struct v3d_screen *)screen; } struct pipe_screen *v3d_screen_create(int fd); void -vc5_fence_init(struct vc5_screen *screen); +v3d_fence_init(struct v3d_screen *screen); #endif /* VC5_SCREEN_H */ diff --git a/src/gallium/drivers/v3d/v3d_simulator.c b/src/gallium/drivers/v3d/v3d_simulator.c index 86e4ed3be3d..8ef88db3a50 100644 --- a/src/gallium/drivers/v3d/v3d_simulator.c +++ b/src/gallium/drivers/v3d/v3d_simulator.c @@ -22,7 +22,7 @@ */ /** - * @file vc5_simulator.c + * @file v3d_simulator.c * * Implements VC5 simulation on top of a non-VC5 GEM fd. * @@ -60,7 +60,7 @@ #include "v3d_context.h" /** Global (across GEM fds) state for the simulator */ -static struct vc5_simulator_state { +static struct v3d_simulator_state { mtx_t mutex; struct v3d_hw *v3d; @@ -76,7 +76,7 @@ static struct vc5_simulator_state { struct mem_block *heap; struct mem_block *overflow; - /** Mapping from GEM handle to struct vc5_simulator_bo * */ + /** Mapping from GEM handle to struct v3d_simulator_bo * */ struct hash_table *fd_map; int refcount; @@ -85,19 +85,19 @@ static struct vc5_simulator_state { }; /** Per-GEM-fd state for the simulator. */ -struct vc5_simulator_file { +struct v3d_simulator_file { int fd; - /** Mapping from GEM handle to struct vc5_simulator_bo * */ + /** Mapping from GEM handle to struct v3d_simulator_bo * */ struct hash_table *bo_map; struct mem_block *gmp; void *gmp_vaddr; }; -/** Wrapper for drm_vc5_bo tracking the simulator-specific state. */ -struct vc5_simulator_bo { - struct vc5_simulator_file *file; +/** Wrapper for drm_v3d_bo tracking the simulator-specific state. */ +struct v3d_simulator_bo { + struct v3d_simulator_file *file; /** Area for this BO within sim_state->mem */ struct mem_block *block; @@ -116,8 +116,8 @@ int_to_key(int key) return (void *)(uintptr_t)key; } -static struct vc5_simulator_file * -vc5_get_simulator_file_for_fd(int fd) +static struct v3d_simulator_file * +v3d_get_simulator_file_for_fd(int fd) { struct hash_entry *entry = _mesa_hash_table_search(sim_state.fd_map, int_to_key(fd + 1)); @@ -137,7 +137,7 @@ vc5_get_simulator_file_for_fd(int fd) * permissions (bit 0 = read, bit 1 = write, write-only forbidden). */ static void -set_gmp_flags(struct vc5_simulator_file *file, +set_gmp_flags(struct v3d_simulator_file *file, uint32_t offset, uint32_t size, uint32_t flag) { assert((offset & ((1 << GMP_ALIGN2) - 1)) == 0); @@ -158,12 +158,12 @@ set_gmp_flags(struct vc5_simulator_file *file, * Allocates space in simulator memory and returns a tracking struct for it * that also contains the drm_gem_cma_object struct. */ -static struct vc5_simulator_bo * -vc5_create_simulator_bo(int fd, int handle, unsigned size) +static struct v3d_simulator_bo * +v3d_create_simulator_bo(int fd, int handle, unsigned size) { - struct vc5_simulator_file *file = vc5_get_simulator_file_for_fd(fd); - struct vc5_simulator_bo *sim_bo = rzalloc(file, - struct vc5_simulator_bo); + struct v3d_simulator_file *file = v3d_get_simulator_file_for_fd(fd); + struct v3d_simulator_bo *sim_bo = rzalloc(file, + struct v3d_simulator_bo); size = align(size, 4096); sim_bo->file = file; @@ -182,7 +182,7 @@ vc5_create_simulator_bo(int fd, int handle, unsigned size) *(uint32_t *)(sim_bo->vaddr + sim_bo->size) = BO_SENTINEL; - /* A handle of 0 is used for vc5_gem.c internal allocations that + /* A handle of 0 is used for v3d_gem.c internal allocations that * don't need to go in the lookup table. */ if (handle != 0) { @@ -196,9 +196,9 @@ vc5_create_simulator_bo(int fd, int handle, unsigned size) } static void -vc5_free_simulator_bo(struct vc5_simulator_bo *sim_bo) +v3d_free_simulator_bo(struct v3d_simulator_bo *sim_bo) { - struct vc5_simulator_file *sim_file = sim_bo->file; + struct v3d_simulator_file *sim_file = sim_bo->file; if (sim_bo->winsys_map) munmap(sim_bo->winsys_map, sim_bo->size); @@ -217,8 +217,8 @@ vc5_free_simulator_bo(struct vc5_simulator_bo *sim_bo) ralloc_free(sim_bo); } -static struct vc5_simulator_bo * -vc5_get_simulator_bo(struct vc5_simulator_file *file, int gem_handle) +static struct v3d_simulator_bo * +v3d_get_simulator_bo(struct v3d_simulator_file *file, int gem_handle) { mtx_lock(&sim_state.mutex); struct hash_entry *entry = @@ -229,17 +229,17 @@ vc5_get_simulator_bo(struct vc5_simulator_file *file, int gem_handle) } static int -vc5_simulator_pin_bos(int fd, struct vc5_job *job) +v3d_simulator_pin_bos(int fd, struct v3d_job *job) { - struct vc5_simulator_file *file = vc5_get_simulator_file_for_fd(fd); + struct v3d_simulator_file *file = v3d_get_simulator_file_for_fd(fd); struct set_entry *entry; set_foreach(job->bos, entry) { - struct vc5_bo *bo = (struct vc5_bo *)entry->key; - struct vc5_simulator_bo *sim_bo = - vc5_get_simulator_bo(file, bo->handle); + struct v3d_bo *bo = (struct v3d_bo *)entry->key; + struct v3d_simulator_bo *sim_bo = + v3d_get_simulator_bo(file, bo->handle); - vc5_bo_map(bo); + v3d_bo_map(bo); memcpy(sim_bo->vaddr, bo->map, bo->size); } @@ -247,22 +247,22 @@ vc5_simulator_pin_bos(int fd, struct vc5_job *job) } static int -vc5_simulator_unpin_bos(int fd, struct vc5_job *job) +v3d_simulator_unpin_bos(int fd, struct v3d_job *job) { - struct vc5_simulator_file *file = vc5_get_simulator_file_for_fd(fd); + struct v3d_simulator_file *file = v3d_get_simulator_file_for_fd(fd); struct set_entry *entry; set_foreach(job->bos, entry) { - struct vc5_bo *bo = (struct vc5_bo *)entry->key; - struct vc5_simulator_bo *sim_bo = - vc5_get_simulator_bo(file, bo->handle); + struct v3d_bo *bo = (struct v3d_bo *)entry->key; + struct v3d_simulator_bo *sim_bo = + v3d_get_simulator_bo(file, bo->handle); if (*(uint32_t *)(sim_bo->vaddr + sim_bo->size) != BO_SENTINEL) { fprintf(stderr, "Buffer overflow in %s\n", bo->name); } - vc5_bo_map(bo); + v3d_bo_map(bo); memcpy(bo->map, sim_bo->vaddr, bo->size); } @@ -271,20 +271,20 @@ vc5_simulator_unpin_bos(int fd, struct vc5_job *job) #if 0 static void -vc5_dump_to_file(struct vc5_exec_info *exec) +v3d_dump_to_file(struct v3d_exec_info *exec) { static int dumpno = 0; - struct drm_vc5_get_hang_state *state; - struct drm_vc5_get_hang_state_bo *bo_state; + struct drm_v3d_get_hang_state *state; + struct drm_v3d_get_hang_state_bo *bo_state; unsigned int dump_version = 0; - if (!(vc5_debug & VC5_DEBUG_DUMP)) + if (!(v3d_debug & VC5_DEBUG_DUMP)) return; state = calloc(1, sizeof(*state)); int unref_count = 0; - list_for_each_entry_safe(struct drm_vc5_bo, bo, &exec->unref_list, + list_for_each_entry_safe(struct drm_v3d_bo, bo, &exec->unref_list, unref_head) { unref_count++; } @@ -294,7 +294,7 @@ vc5_dump_to_file(struct vc5_exec_info *exec) bo_state = calloc(state->bo_count, sizeof(*bo_state)); char *filename = NULL; - asprintf(&filename, "vc5-dri-%d.dump", dumpno++); + asprintf(&filename, "v3d-dri-%d.dump", dumpno++); FILE *f = fopen(filename, "w+"); if (!f) { fprintf(stderr, "Couldn't open %s: %s", filename, @@ -320,7 +320,7 @@ vc5_dump_to_file(struct vc5_exec_info *exec) bo_state[i].size = cma_bo->base.size; } - list_for_each_entry_safe(struct drm_vc5_bo, bo, &exec->unref_list, + list_for_each_entry_safe(struct drm_v3d_bo, bo, &exec->unref_list, unref_head) { struct drm_gem_cma_object *cma_bo = &bo->base; bo_state[i].handle = 0; @@ -342,7 +342,7 @@ vc5_dump_to_file(struct vc5_exec_info *exec) fwrite(cma_bo->vaddr, cma_bo->base.size, 1, f); } - list_for_each_entry_safe(struct drm_vc5_bo, bo, &exec->unref_list, + list_for_each_entry_safe(struct drm_v3d_bo, bo, &exec->unref_list, unref_head) { struct drm_gem_cma_object *cma_bo = &bo->base; fwrite(cma_bo->vaddr, cma_bo->base.size, 1, f); @@ -359,15 +359,15 @@ vc5_dump_to_file(struct vc5_exec_info *exec) #endif int -vc5_simulator_flush(struct vc5_context *vc5, - struct drm_v3d_submit_cl *submit, struct vc5_job *job) +v3d_simulator_flush(struct v3d_context *v3d, + struct drm_v3d_submit_cl *submit, struct v3d_job *job) { - struct vc5_screen *screen = vc5->screen; + struct v3d_screen *screen = v3d->screen; int fd = screen->fd; - struct vc5_simulator_file *file = vc5_get_simulator_file_for_fd(fd); - struct vc5_surface *csurf = vc5_surface(vc5->framebuffer.cbufs[0]); - struct vc5_resource *ctex = csurf ? vc5_resource(csurf->base.texture) : NULL; - struct vc5_simulator_bo *csim_bo = ctex ? vc5_get_simulator_bo(file, ctex->bo->handle) : NULL; + struct v3d_simulator_file *file = v3d_get_simulator_file_for_fd(fd); + struct v3d_surface *csurf = v3d_surface(v3d->framebuffer.cbufs[0]); + struct v3d_resource *ctex = csurf ? v3d_resource(csurf->base.texture) : NULL; + struct v3d_simulator_bo *csim_bo = ctex ? v3d_get_simulator_bo(file, ctex->bo->handle) : NULL; uint32_t winsys_stride = ctex ? csim_bo->winsys_stride : 0; uint32_t sim_stride = ctex ? ctex->slices[0].stride : 0; uint32_t row_len = MIN2(sim_stride, winsys_stride); @@ -389,18 +389,18 @@ vc5_simulator_flush(struct vc5_context *vc5, } } - ret = vc5_simulator_pin_bos(fd, job); + ret = v3d_simulator_pin_bos(fd, job); if (ret) return ret; - //vc5_dump_to_file(&exec); + //v3d_dump_to_file(&exec); if (sim_state.ver >= 41) v3d41_simulator_flush(sim_state.v3d, submit, file->gmp->ofs); else v3d33_simulator_flush(sim_state.v3d, submit, file->gmp->ofs); - ret = vc5_simulator_unpin_bos(fd, job); + ret = v3d_simulator_unpin_bos(fd, job); if (ret) return ret; @@ -419,7 +419,7 @@ vc5_simulator_flush(struct vc5_context *vc5, * Map the underlying GEM object from the real hardware GEM handle. */ static void * -vc5_simulator_map_winsys_bo(int fd, struct vc5_simulator_bo *sim_bo) +v3d_simulator_map_winsys_bo(int fd, struct v3d_simulator_bo *sim_bo) { int ret; void *map; @@ -453,14 +453,14 @@ vc5_simulator_map_winsys_bo(int fd, struct vc5_simulator_bo *sim_bo) * time, but we're still using drmPrimeFDToHandle() so we have this helper to * be called afterward instead. */ -void vc5_simulator_open_from_handle(int fd, uint32_t winsys_stride, +void v3d_simulator_open_from_handle(int fd, uint32_t winsys_stride, int handle, uint32_t size) { - struct vc5_simulator_bo *sim_bo = - vc5_create_simulator_bo(fd, handle, size); + struct v3d_simulator_bo *sim_bo = + v3d_create_simulator_bo(fd, handle, size); sim_bo->winsys_stride = winsys_stride; - sim_bo->winsys_map = vc5_simulator_map_winsys_bo(fd, sim_bo); + sim_bo->winsys_map = v3d_simulator_map_winsys_bo(fd, sim_bo); } /** @@ -469,7 +469,7 @@ void vc5_simulator_open_from_handle(int fd, uint32_t winsys_stride, * Making a VC5 BO is just a matter of making a corresponding BO on the host. */ static int -vc5_simulator_create_bo_ioctl(int fd, struct drm_v3d_create_bo *args) +v3d_simulator_create_bo_ioctl(int fd, struct drm_v3d_create_bo *args) { int ret; struct drm_mode_create_dumb create = { @@ -483,8 +483,8 @@ vc5_simulator_create_bo_ioctl(int fd, struct drm_v3d_create_bo *args) args->handle = create.handle; - struct vc5_simulator_bo *sim_bo = - vc5_create_simulator_bo(fd, create.handle, args->size); + struct v3d_simulator_bo *sim_bo = + v3d_create_simulator_bo(fd, create.handle, args->size); args->offset = sim_bo->block->ofs; @@ -497,7 +497,7 @@ vc5_simulator_create_bo_ioctl(int fd, struct drm_v3d_create_bo *args) * We just pass this straight through to dumb mmap. */ static int -vc5_simulator_mmap_bo_ioctl(int fd, struct drm_v3d_mmap_bo *args) +v3d_simulator_mmap_bo_ioctl(int fd, struct drm_v3d_mmap_bo *args) { int ret; struct drm_mode_map_dumb map = { @@ -511,10 +511,10 @@ vc5_simulator_mmap_bo_ioctl(int fd, struct drm_v3d_mmap_bo *args) } static int -vc5_simulator_get_bo_offset_ioctl(int fd, struct drm_v3d_get_bo_offset *args) +v3d_simulator_get_bo_offset_ioctl(int fd, struct drm_v3d_get_bo_offset *args) { - struct vc5_simulator_file *file = vc5_get_simulator_file_for_fd(fd); - struct vc5_simulator_bo *sim_bo = vc5_get_simulator_bo(file, + struct v3d_simulator_file *file = v3d_get_simulator_file_for_fd(fd); + struct v3d_simulator_bo *sim_bo = v3d_get_simulator_bo(file, args->handle); args->offset = sim_bo->block->ofs; @@ -523,21 +523,21 @@ vc5_simulator_get_bo_offset_ioctl(int fd, struct drm_v3d_get_bo_offset *args) } static int -vc5_simulator_gem_close_ioctl(int fd, struct drm_gem_close *args) +v3d_simulator_gem_close_ioctl(int fd, struct drm_gem_close *args) { /* Free the simulator's internal tracking. */ - struct vc5_simulator_file *file = vc5_get_simulator_file_for_fd(fd); - struct vc5_simulator_bo *sim_bo = vc5_get_simulator_bo(file, + struct v3d_simulator_file *file = v3d_get_simulator_file_for_fd(fd); + struct v3d_simulator_bo *sim_bo = v3d_get_simulator_bo(file, args->handle); - vc5_free_simulator_bo(sim_bo); + v3d_free_simulator_bo(sim_bo); /* Pass the call on down. */ return drmIoctl(fd, DRM_IOCTL_GEM_CLOSE, args); } static int -vc5_simulator_get_param_ioctl(int fd, struct drm_v3d_get_param *args) +v3d_simulator_get_param_ioctl(int fd, struct drm_v3d_get_param *args) { if (sim_state.ver >= 41) return v3d41_simulator_get_param_ioctl(sim_state.v3d, args); @@ -546,18 +546,18 @@ vc5_simulator_get_param_ioctl(int fd, struct drm_v3d_get_param *args) } int -vc5_simulator_ioctl(int fd, unsigned long request, void *args) +v3d_simulator_ioctl(int fd, unsigned long request, void *args) { switch (request) { case DRM_IOCTL_V3D_CREATE_BO: - return vc5_simulator_create_bo_ioctl(fd, args); + return v3d_simulator_create_bo_ioctl(fd, args); case DRM_IOCTL_V3D_MMAP_BO: - return vc5_simulator_mmap_bo_ioctl(fd, args); + return v3d_simulator_mmap_bo_ioctl(fd, args); case DRM_IOCTL_V3D_GET_BO_OFFSET: - return vc5_simulator_get_bo_offset_ioctl(fd, args); + return v3d_simulator_get_bo_offset_ioctl(fd, args); case DRM_IOCTL_V3D_WAIT_BO: - /* We do all of the vc5 rendering synchronously, so we just + /* We do all of the v3d rendering synchronously, so we just * return immediately on the wait ioctls. This ignores any * native rendering to the host BO, so it does mean we race on * front buffer rendering. @@ -565,10 +565,10 @@ vc5_simulator_ioctl(int fd, unsigned long request, void *args) return 0; case DRM_IOCTL_V3D_GET_PARAM: - return vc5_simulator_get_param_ioctl(fd, args); + return v3d_simulator_get_param_ioctl(fd, args); case DRM_IOCTL_GEM_CLOSE: - return vc5_simulator_gem_close_ioctl(fd, args); + return v3d_simulator_gem_close_ioctl(fd, args); case DRM_IOCTL_GEM_OPEN: case DRM_IOCTL_GEM_FLINK: @@ -580,7 +580,7 @@ vc5_simulator_ioctl(int fd, unsigned long request, void *args) } static void -vc5_simulator_init_global(const struct v3d_device_info *devinfo) +v3d_simulator_init_global(const struct v3d_device_info *devinfo) { mtx_lock(&sim_state.mutex); if (sim_state.refcount++) { @@ -622,12 +622,12 @@ vc5_simulator_init_global(const struct v3d_device_info *devinfo) } void -vc5_simulator_init(struct vc5_screen *screen) +v3d_simulator_init(struct v3d_screen *screen) { - vc5_simulator_init_global(&screen->devinfo); + v3d_simulator_init_global(&screen->devinfo); - screen->sim_file = rzalloc(screen, struct vc5_simulator_file); - struct vc5_simulator_file *sim_file = screen->sim_file; + screen->sim_file = rzalloc(screen, struct v3d_simulator_file); + struct v3d_simulator_file *sim_file = screen->sim_file; screen->sim_file->bo_map = _mesa_hash_table_create(screen->sim_file, @@ -645,7 +645,7 @@ vc5_simulator_init(struct vc5_screen *screen) } void -vc5_simulator_destroy(struct vc5_screen *screen) +v3d_simulator_destroy(struct v3d_screen *screen) { mtx_lock(&sim_state.mutex); if (!--sim_state.refcount) { diff --git a/src/gallium/drivers/v3d/v3d_tiling.c b/src/gallium/drivers/v3d/v3d_tiling.c index f9c4a342184..bc227be23ac 100644 --- a/src/gallium/drivers/v3d/v3d_tiling.c +++ b/src/gallium/drivers/v3d/v3d_tiling.c @@ -21,7 +21,7 @@ * IN THE SOFTWARE. */ -/** @file vc5_tiling.c +/** @file v3d_tiling.c * * Handles information about the VC5 tiling formats, and loading and storing * from them. @@ -34,7 +34,7 @@ /** Return the width in pixels of a 64-byte microtile. */ uint32_t -vc5_utile_width(int cpp) +v3d_utile_width(int cpp) { switch (cpp) { case 1: @@ -52,7 +52,7 @@ vc5_utile_width(int cpp) /** Return the height in pixels of a 64-byte microtile. */ uint32_t -vc5_utile_height(int cpp) +v3d_utile_height(int cpp) { switch (cpp) { case 1: @@ -75,10 +75,10 @@ vc5_utile_height(int cpp) * arrangement. */ static inline uint32_t -vc5_get_utile_pixel_offset(uint32_t cpp, uint32_t x, uint32_t y) +v3d_get_utile_pixel_offset(uint32_t cpp, uint32_t x, uint32_t y) { - uint32_t utile_w = vc5_utile_width(cpp); - uint32_t utile_h = vc5_utile_height(cpp); + uint32_t utile_w = v3d_utile_width(cpp); + uint32_t utile_h = v3d_utile_height(cpp); assert(x < utile_w && y < utile_h); @@ -91,17 +91,17 @@ vc5_get_utile_pixel_offset(uint32_t cpp, uint32_t x, uint32_t y) * LINEARTILE is a single line of utiles in either the X or Y direction. */ static inline uint32_t -vc5_get_lt_pixel_offset(uint32_t cpp, uint32_t image_h, uint32_t x, uint32_t y) +v3d_get_lt_pixel_offset(uint32_t cpp, uint32_t image_h, uint32_t x, uint32_t y) { - uint32_t utile_w = vc5_utile_width(cpp); - uint32_t utile_h = vc5_utile_height(cpp); + uint32_t utile_w = v3d_utile_width(cpp); + uint32_t utile_h = v3d_utile_height(cpp); uint32_t utile_index_x = x / utile_w; uint32_t utile_index_y = y / utile_h; assert(utile_index_x == 0 || utile_index_y == 0); return (64 * (utile_index_x + utile_index_y) + - vc5_get_utile_pixel_offset(cpp, + v3d_get_utile_pixel_offset(cpp, x & (utile_w - 1), y & (utile_h - 1))); } @@ -113,11 +113,11 @@ vc5_get_lt_pixel_offset(uint32_t cpp, uint32_t image_h, uint32_t x, uint32_t y) * utiles), and the UIF blocks are in 1 or 2 columns in raster order. */ static inline uint32_t -vc5_get_ublinear_pixel_offset(uint32_t cpp, uint32_t x, uint32_t y, +v3d_get_ublinear_pixel_offset(uint32_t cpp, uint32_t x, uint32_t y, int ublinear_number) { - uint32_t utile_w = vc5_utile_width(cpp); - uint32_t utile_h = vc5_utile_height(cpp); + uint32_t utile_w = v3d_utile_width(cpp); + uint32_t utile_h = v3d_utile_height(cpp); uint32_t ub_w = utile_w * 2; uint32_t ub_h = utile_h * 2; uint32_t ub_x = x / ub_w; @@ -127,23 +127,23 @@ vc5_get_ublinear_pixel_offset(uint32_t cpp, uint32_t x, uint32_t y, ub_x) + ((x & utile_w) ? 64 : 0) + ((y & utile_h) ? 128 : 0) + - + vc5_get_utile_pixel_offset(cpp, + + v3d_get_utile_pixel_offset(cpp, x & (utile_w - 1), y & (utile_h - 1))); } static inline uint32_t -vc5_get_ublinear_2_column_pixel_offset(uint32_t cpp, uint32_t image_h, +v3d_get_ublinear_2_column_pixel_offset(uint32_t cpp, uint32_t image_h, uint32_t x, uint32_t y) { - return vc5_get_ublinear_pixel_offset(cpp, x, y, 2); + return v3d_get_ublinear_pixel_offset(cpp, x, y, 2); } static inline uint32_t -vc5_get_ublinear_1_column_pixel_offset(uint32_t cpp, uint32_t image_h, +v3d_get_ublinear_1_column_pixel_offset(uint32_t cpp, uint32_t image_h, uint32_t x, uint32_t y) { - return vc5_get_ublinear_pixel_offset(cpp, x, y, 1); + return v3d_get_ublinear_pixel_offset(cpp, x, y, 1); } /** @@ -154,11 +154,11 @@ vc5_get_ublinear_1_column_pixel_offset(uint32_t cpp, uint32_t image_h, * 4x4 groups, and those 4x4 groups are then stored in raster order. */ static inline uint32_t -vc5_get_uif_pixel_offset(uint32_t cpp, uint32_t image_h, uint32_t x, uint32_t y, +v3d_get_uif_pixel_offset(uint32_t cpp, uint32_t image_h, uint32_t x, uint32_t y, bool do_xor) { - uint32_t utile_w = vc5_utile_width(cpp); - uint32_t utile_h = vc5_utile_height(cpp); + uint32_t utile_w = v3d_utile_width(cpp); + uint32_t utile_h = v3d_utile_height(cpp); uint32_t mb_width = utile_w * 2; uint32_t mb_height = utile_h * 2; uint32_t log2_mb_width = ffs(mb_width) - 1; @@ -190,7 +190,7 @@ vc5_get_uif_pixel_offset(uint32_t cpp, uint32_t image_h, uint32_t x, uint32_t y, uint32_t mb_pixel_address = (mb_base_addr + mb_tile_offset + - vc5_get_utile_pixel_offset(cpp, + v3d_get_utile_pixel_offset(cpp, utile_x, utile_y)); @@ -198,21 +198,21 @@ vc5_get_uif_pixel_offset(uint32_t cpp, uint32_t image_h, uint32_t x, uint32_t y, } static inline uint32_t -vc5_get_uif_xor_pixel_offset(uint32_t cpp, uint32_t image_h, +v3d_get_uif_xor_pixel_offset(uint32_t cpp, uint32_t image_h, uint32_t x, uint32_t y) { - return vc5_get_uif_pixel_offset(cpp, image_h, x, y, true); + return v3d_get_uif_pixel_offset(cpp, image_h, x, y, true); } static inline uint32_t -vc5_get_uif_no_xor_pixel_offset(uint32_t cpp, uint32_t image_h, +v3d_get_uif_no_xor_pixel_offset(uint32_t cpp, uint32_t image_h, uint32_t x, uint32_t y) { - return vc5_get_uif_pixel_offset(cpp, image_h, x, y, false); + return v3d_get_uif_pixel_offset(cpp, image_h, x, y, false); } static inline void -vc5_move_pixels_general_percpp(void *gpu, uint32_t gpu_stride, +v3d_move_pixels_general_percpp(void *gpu, uint32_t gpu_stride, void *cpu, uint32_t cpu_stride, int cpp, uint32_t image_h, const struct pipe_box *box, @@ -249,7 +249,7 @@ vc5_move_pixels_general_percpp(void *gpu, uint32_t gpu_stride, } static inline void -vc5_move_pixels_general(void *gpu, uint32_t gpu_stride, +v3d_move_pixels_general(void *gpu, uint32_t gpu_stride, void *cpu, uint32_t cpu_stride, int cpp, uint32_t image_h, const struct pipe_box *box, @@ -260,35 +260,35 @@ vc5_move_pixels_general(void *gpu, uint32_t gpu_stride, { switch (cpp) { case 1: - vc5_move_pixels_general_percpp(gpu, gpu_stride, + v3d_move_pixels_general_percpp(gpu, gpu_stride, cpu, cpu_stride, 1, image_h, box, get_pixel_offset, is_load); break; case 2: - vc5_move_pixels_general_percpp(gpu, gpu_stride, + v3d_move_pixels_general_percpp(gpu, gpu_stride, cpu, cpu_stride, 2, image_h, box, get_pixel_offset, is_load); break; case 4: - vc5_move_pixels_general_percpp(gpu, gpu_stride, + v3d_move_pixels_general_percpp(gpu, gpu_stride, cpu, cpu_stride, 4, image_h, box, get_pixel_offset, is_load); break; case 8: - vc5_move_pixels_general_percpp(gpu, gpu_stride, + v3d_move_pixels_general_percpp(gpu, gpu_stride, cpu, cpu_stride, 8, image_h, box, get_pixel_offset, is_load); break; case 16: - vc5_move_pixels_general_percpp(gpu, gpu_stride, + v3d_move_pixels_general_percpp(gpu, gpu_stride, cpu, cpu_stride, 16, image_h, box, get_pixel_offset, @@ -298,9 +298,9 @@ vc5_move_pixels_general(void *gpu, uint32_t gpu_stride, } static inline void -vc5_move_tiled_image(void *gpu, uint32_t gpu_stride, +v3d_move_tiled_image(void *gpu, uint32_t gpu_stride, void *cpu, uint32_t cpu_stride, - enum vc5_tiling_mode tiling_format, + enum v3d_tiling_mode tiling_format, int cpp, uint32_t image_h, const struct pipe_box *box, @@ -308,38 +308,38 @@ vc5_move_tiled_image(void *gpu, uint32_t gpu_stride, { switch (tiling_format) { case VC5_TILING_UIF_XOR: - vc5_move_pixels_general(gpu, gpu_stride, + v3d_move_pixels_general(gpu, gpu_stride, cpu, cpu_stride, cpp, image_h, box, - vc5_get_uif_xor_pixel_offset, + v3d_get_uif_xor_pixel_offset, is_load); break; case VC5_TILING_UIF_NO_XOR: - vc5_move_pixels_general(gpu, gpu_stride, + v3d_move_pixels_general(gpu, gpu_stride, cpu, cpu_stride, cpp, image_h, box, - vc5_get_uif_no_xor_pixel_offset, + v3d_get_uif_no_xor_pixel_offset, is_load); break; case VC5_TILING_UBLINEAR_2_COLUMN: - vc5_move_pixels_general(gpu, gpu_stride, + v3d_move_pixels_general(gpu, gpu_stride, cpu, cpu_stride, cpp, image_h, box, - vc5_get_ublinear_2_column_pixel_offset, + v3d_get_ublinear_2_column_pixel_offset, is_load); break; case VC5_TILING_UBLINEAR_1_COLUMN: - vc5_move_pixels_general(gpu, gpu_stride, + v3d_move_pixels_general(gpu, gpu_stride, cpu, cpu_stride, cpp, image_h, box, - vc5_get_ublinear_1_column_pixel_offset, + v3d_get_ublinear_1_column_pixel_offset, is_load); break; case VC5_TILING_LINEARTILE: - vc5_move_pixels_general(gpu, gpu_stride, + v3d_move_pixels_general(gpu, gpu_stride, cpu, cpu_stride, cpp, image_h, box, - vc5_get_lt_pixel_offset, + v3d_get_lt_pixel_offset, is_load); break; default: @@ -353,13 +353,13 @@ vc5_move_tiled_image(void *gpu, uint32_t gpu_stride, * start of \p dst according to the given tiling format. */ void -vc5_load_tiled_image(void *dst, uint32_t dst_stride, +v3d_load_tiled_image(void *dst, uint32_t dst_stride, void *src, uint32_t src_stride, - enum vc5_tiling_mode tiling_format, int cpp, + enum v3d_tiling_mode tiling_format, int cpp, uint32_t image_h, const struct pipe_box *box) { - vc5_move_tiled_image(src, src_stride, + v3d_move_tiled_image(src, src_stride, dst, dst_stride, tiling_format, cpp, @@ -373,13 +373,13 @@ vc5_load_tiled_image(void *dst, uint32_t dst_stride, * \p dst according to the given tiling format. */ void -vc5_store_tiled_image(void *dst, uint32_t dst_stride, +v3d_store_tiled_image(void *dst, uint32_t dst_stride, void *src, uint32_t src_stride, - enum vc5_tiling_mode tiling_format, int cpp, + enum v3d_tiling_mode tiling_format, int cpp, uint32_t image_h, const struct pipe_box *box) { - vc5_move_tiled_image(dst, dst_stride, + v3d_move_tiled_image(dst, dst_stride, src, src_stride, tiling_format, cpp, diff --git a/src/gallium/drivers/v3d/v3d_tiling.h b/src/gallium/drivers/v3d/v3d_tiling.h index d3cf48c4527..79577445ea8 100644 --- a/src/gallium/drivers/v3d/v3d_tiling.h +++ b/src/gallium/drivers/v3d/v3d_tiling.h @@ -24,19 +24,19 @@ #ifndef VC5_TILING_H #define VC5_TILING_H -uint32_t vc5_utile_width(int cpp) ATTRIBUTE_CONST; -uint32_t vc5_utile_height(int cpp) ATTRIBUTE_CONST; -bool vc5_size_is_lt(uint32_t width, uint32_t height, int cpp) ATTRIBUTE_CONST; -void vc5_load_utile(void *dst, void *src, uint32_t dst_stride, uint32_t cpp); -void vc5_store_utile(void *dst, void *src, uint32_t src_stride, uint32_t cpp); -void vc5_load_tiled_image(void *dst, uint32_t dst_stride, +uint32_t v3d_utile_width(int cpp) ATTRIBUTE_CONST; +uint32_t v3d_utile_height(int cpp) ATTRIBUTE_CONST; +bool v3d_size_is_lt(uint32_t width, uint32_t height, int cpp) ATTRIBUTE_CONST; +void v3d_load_utile(void *dst, void *src, uint32_t dst_stride, uint32_t cpp); +void v3d_store_utile(void *dst, void *src, uint32_t src_stride, uint32_t cpp); +void v3d_load_tiled_image(void *dst, uint32_t dst_stride, void *src, uint32_t src_stride, - enum vc5_tiling_mode tiling_format, int cpp, + enum v3d_tiling_mode tiling_format, int cpp, uint32_t image_h, const struct pipe_box *box); -void vc5_store_tiled_image(void *dst, uint32_t dst_stride, +void v3d_store_tiled_image(void *dst, uint32_t dst_stride, void *src, uint32_t src_stride, - enum vc5_tiling_mode tiling_format, int cpp, + enum v3d_tiling_mode tiling_format, int cpp, uint32_t image_h, const struct pipe_box *box); diff --git a/src/gallium/drivers/v3d/v3d_uniforms.c b/src/gallium/drivers/v3d/v3d_uniforms.c index c7a39b50a74..9dd128ab418 100644 --- a/src/gallium/drivers/v3d/v3d_uniforms.c +++ b/src/gallium/drivers/v3d/v3d_uniforms.c @@ -38,14 +38,14 @@ } static void -write_texture_border_color(struct vc5_job *job, - struct vc5_cl_out **uniforms, - struct vc5_texture_stateobj *texstate, +write_texture_border_color(struct v3d_job *job, + struct v3d_cl_out **uniforms, + struct v3d_texture_stateobj *texstate, uint32_t unit) { struct pipe_sampler_state *sampler = texstate->samplers[unit]; struct pipe_sampler_view *texture = texstate->textures[unit]; - struct vc5_resource *rsc = vc5_resource(texture->texture); + struct v3d_resource *rsc = v3d_resource(texture->texture); union util_color uc; const struct util_format_description *tex_format_desc = @@ -68,15 +68,15 @@ write_texture_border_color(struct vc5_job *job, border_color, tex_format_desc->swizzle); - /* Now, pack so that when the vc5_format-sampled texture contents are - * replaced with our border color, the vc5_get_format_swizzle() + /* Now, pack so that when the v3d_format-sampled texture contents are + * replaced with our border color, the v3d_get_format_swizzle() * swizzling will get the right channels. */ if (util_format_is_depth_or_stencil(texture->format)) { uc.ui[0] = util_pack_z(PIPE_FORMAT_Z24X8_UNORM, sampler->border_color.f[0]) << 8; } else { - switch (rsc->vc5_format) { + switch (rsc->v3d_format) { default: case VC5_TEXTURE_TYPE_RGBA8888: util_pack_color(storage_color, @@ -105,7 +105,7 @@ write_texture_border_color(struct vc5_job *job, #endif static uint32_t -get_texrect_scale(struct vc5_texture_stateobj *texstate, +get_texrect_scale(struct v3d_texture_stateobj *texstate, enum quniform_contents contents, uint32_t data) { @@ -121,7 +121,7 @@ get_texrect_scale(struct vc5_texture_stateobj *texstate, } static uint32_t -get_texture_size(struct vc5_texture_stateobj *texstate, +get_texture_size(struct v3d_texture_stateobj *texstate, enum quniform_contents contents, uint32_t data) { @@ -147,18 +147,18 @@ get_texture_size(struct vc5_texture_stateobj *texstate, } } -static struct vc5_bo * -vc5_upload_ubo(struct vc5_context *vc5, - struct vc5_compiled_shader *shader, +static struct v3d_bo * +v3d_upload_ubo(struct v3d_context *v3d, + struct v3d_compiled_shader *shader, const uint32_t *gallium_uniforms) { if (!shader->prog_data.base->ubo_size) return NULL; - struct vc5_bo *ubo = vc5_bo_alloc(vc5->screen, + struct v3d_bo *ubo = v3d_bo_alloc(v3d->screen, shader->prog_data.base->ubo_size, "ubo"); - void *data = vc5_bo_map(ubo); + void *data = v3d_bo_map(ubo); for (uint32_t i = 0; i < shader->prog_data.base->num_ubo_ranges; i++) { memcpy(data + shader->prog_data.base->ubo_ranges[i].dst_offset, ((const void *)gallium_uniforms + @@ -177,23 +177,23 @@ vc5_upload_ubo(struct vc5_context *vc5, * two together here. */ static void -write_texture_p0(struct vc5_job *job, - struct vc5_cl_out **uniforms, - struct vc5_texture_stateobj *texstate, +write_texture_p0(struct v3d_job *job, + struct v3d_cl_out **uniforms, + struct v3d_texture_stateobj *texstate, uint32_t unit, uint32_t shader_data) { struct pipe_sampler_state *psampler = texstate->samplers[unit]; - struct vc5_sampler_state *sampler = vc5_sampler_state(psampler); + struct v3d_sampler_state *sampler = v3d_sampler_state(psampler); cl_aligned_u32(uniforms, shader_data | sampler->p0); } /** Writes the V3D 3.x P1 (CFG_MODE=1) texture parameter. */ static void -write_texture_p1(struct vc5_job *job, - struct vc5_cl_out **uniforms, - struct vc5_texture_stateobj *texstate, +write_texture_p1(struct v3d_job *job, + struct v3d_cl_out **uniforms, + struct v3d_texture_stateobj *texstate, uint32_t data) { /* Extract the texture unit from the top bits, and the compiler's @@ -203,7 +203,7 @@ write_texture_p1(struct vc5_job *job, uint32_t p1 = data & 0x1f; struct pipe_sampler_view *psview = texstate->textures[unit]; - struct vc5_sampler_view *sview = vc5_sampler_view(psview); + struct v3d_sampler_view *sview = v3d_sampler_view(psview); struct V3D33_TEXTURE_UNIFORM_PARAMETER_1_CFG_MODE1 unpacked = { .texture_state_record_base_address = texstate->texture_state[unit], @@ -219,9 +219,9 @@ write_texture_p1(struct vc5_job *job, /** Writes the V3D 4.x TMU configuration parameter 0. */ static void -write_tmu_p0(struct vc5_job *job, - struct vc5_cl_out **uniforms, - struct vc5_texture_stateobj *texstate, +write_tmu_p0(struct v3d_job *job, + struct v3d_cl_out **uniforms, + struct v3d_texture_stateobj *texstate, uint32_t data) { /* Extract the texture unit from the top bits, and the compiler's @@ -231,18 +231,18 @@ write_tmu_p0(struct vc5_job *job, uint32_t p0 = data & 0x00ffffff; struct pipe_sampler_view *psview = texstate->textures[unit]; - struct vc5_sampler_view *sview = vc5_sampler_view(psview); - struct vc5_resource *rsc = vc5_resource(psview->texture); + struct v3d_sampler_view *sview = v3d_sampler_view(psview); + struct v3d_resource *rsc = v3d_resource(psview->texture); cl_aligned_reloc(&job->indirect, uniforms, sview->bo, p0); - vc5_job_add_bo(job, rsc->bo); + v3d_job_add_bo(job, rsc->bo); } /** Writes the V3D 4.x TMU configuration parameter 1. */ static void -write_tmu_p1(struct vc5_job *job, - struct vc5_cl_out **uniforms, - struct vc5_texture_stateobj *texstate, +write_tmu_p1(struct v3d_job *job, + struct v3d_cl_out **uniforms, + struct v3d_texture_stateobj *texstate, uint32_t data) { /* Extract the texture unit from the top bits, and the compiler's @@ -252,30 +252,30 @@ write_tmu_p1(struct vc5_job *job, uint32_t p0 = data & 0x00ffffff; struct pipe_sampler_state *psampler = texstate->samplers[unit]; - struct vc5_sampler_state *sampler = vc5_sampler_state(psampler); + struct v3d_sampler_state *sampler = v3d_sampler_state(psampler); cl_aligned_reloc(&job->indirect, uniforms, sampler->bo, p0); } -struct vc5_cl_reloc -vc5_write_uniforms(struct vc5_context *vc5, struct vc5_compiled_shader *shader, - struct vc5_constbuf_stateobj *cb, - struct vc5_texture_stateobj *texstate) +struct v3d_cl_reloc +v3d_write_uniforms(struct v3d_context *v3d, struct v3d_compiled_shader *shader, + struct v3d_constbuf_stateobj *cb, + struct v3d_texture_stateobj *texstate) { struct v3d_uniform_list *uinfo = &shader->prog_data.base->uniforms; - struct vc5_job *job = vc5->job; + struct v3d_job *job = v3d->job; const uint32_t *gallium_uniforms = cb->cb[0].user_buffer; - struct vc5_bo *ubo = vc5_upload_ubo(vc5, shader, gallium_uniforms); + struct v3d_bo *ubo = v3d_upload_ubo(v3d, shader, gallium_uniforms); /* We always need to return some space for uniforms, because the HW * will be prefetching, even if we don't read any in the program. */ - vc5_cl_ensure_space(&job->indirect, MAX2(uinfo->count, 1) * 4, 4); + v3d_cl_ensure_space(&job->indirect, MAX2(uinfo->count, 1) * 4, 4); - struct vc5_cl_reloc uniform_stream = cl_get_address(&job->indirect); - vc5_bo_reference(uniform_stream.bo); + struct v3d_cl_reloc uniform_stream = cl_get_address(&job->indirect); + v3d_bo_reference(uniform_stream.bo); - struct vc5_cl_out *uniforms = + struct v3d_cl_out *uniforms = cl_start(&job->indirect); for (int i = 0; i < uinfo->count; i++) { @@ -289,22 +289,22 @@ vc5_write_uniforms(struct vc5_context *vc5, struct vc5_compiled_shader *shader, gallium_uniforms[uinfo->data[i]]); break; case QUNIFORM_VIEWPORT_X_SCALE: - cl_aligned_f(&uniforms, vc5->viewport.scale[0] * 256.0f); + cl_aligned_f(&uniforms, v3d->viewport.scale[0] * 256.0f); break; case QUNIFORM_VIEWPORT_Y_SCALE: - cl_aligned_f(&uniforms, vc5->viewport.scale[1] * 256.0f); + cl_aligned_f(&uniforms, v3d->viewport.scale[1] * 256.0f); break; case QUNIFORM_VIEWPORT_Z_OFFSET: - cl_aligned_f(&uniforms, vc5->viewport.translate[2]); + cl_aligned_f(&uniforms, v3d->viewport.translate[2]); break; case QUNIFORM_VIEWPORT_Z_SCALE: - cl_aligned_f(&uniforms, vc5->viewport.scale[2]); + cl_aligned_f(&uniforms, v3d->viewport.scale[2]); break; case QUNIFORM_USER_CLIP_PLANE: cl_aligned_f(&uniforms, - vc5->clip.ucp[uinfo->data[i] / 4][uinfo->data[i] % 4]); + v3d->clip.ucp[uinfo->data[i] / 4][uinfo->data[i] % 4]); break; case QUNIFORM_TMU_CONFIG_P0: @@ -350,19 +350,19 @@ vc5_write_uniforms(struct vc5_context *vc5, struct vc5_compiled_shader *shader, case QUNIFORM_STENCIL: cl_aligned_u32(&uniforms, - vc5->zsa->stencil_uniforms[uinfo->data[i]] | + v3d->zsa->stencil_uniforms[uinfo->data[i]] | (uinfo->data[i] <= 1 ? - (vc5->stencil_ref.ref_value[uinfo->data[i]] << 8) : + (v3d->stencil_ref.ref_value[uinfo->data[i]] << 8) : 0)); break; case QUNIFORM_ALPHA_REF: cl_aligned_f(&uniforms, - vc5->zsa->base.alpha.ref_value); + v3d->zsa->base.alpha.ref_value); break; case QUNIFORM_SAMPLE_MASK: - cl_aligned_u32(&uniforms, vc5->sample_mask); + cl_aligned_u32(&uniforms, v3d->sample_mask); break; case QUNIFORM_UBO_ADDR: @@ -371,8 +371,8 @@ vc5_write_uniforms(struct vc5_context *vc5, struct vc5_compiled_shader *shader, ubo, 0); } else { int ubo_index = uinfo->data[i]; - struct vc5_resource *rsc = - vc5_resource(cb->cb[ubo_index].buffer); + struct v3d_resource *rsc = + v3d_resource(cb->cb[ubo_index].buffer); cl_aligned_reloc(&job->indirect, &uniforms, rsc->bo, @@ -391,12 +391,12 @@ vc5_write_uniforms(struct vc5_context *vc5, struct vc5_compiled_shader *shader, case QUNIFORM_SPILL_OFFSET: cl_aligned_reloc(&job->indirect, &uniforms, - vc5->prog.spill_bo, 0); + v3d->prog.spill_bo, 0); break; case QUNIFORM_SPILL_SIZE_PER_THREAD: cl_aligned_u32(&uniforms, - vc5->prog.spill_size_per_thread); + v3d->prog.spill_size_per_thread); break; default: @@ -419,13 +419,13 @@ vc5_write_uniforms(struct vc5_context *vc5, struct vc5_compiled_shader *shader, cl_end(&job->indirect, uniforms); - vc5_bo_unreference(&ubo); + v3d_bo_unreference(&ubo); return uniform_stream; } void -vc5_set_shader_uniform_dirty_flags(struct vc5_compiled_shader *shader) +v3d_set_shader_uniform_dirty_flags(struct v3d_compiled_shader *shader) { uint32_t dirty = 0; diff --git a/src/gallium/drivers/v3d/v3dx_context.h b/src/gallium/drivers/v3d/v3dx_context.h index faeda2c0fbb..bb90e1ccf15 100644 --- a/src/gallium/drivers/v3d/v3dx_context.h +++ b/src/gallium/drivers/v3d/v3dx_context.h @@ -27,21 +27,21 @@ */ struct v3d_hw; -struct vc5_format; +struct v3d_format; void v3dX(emit_state)(struct pipe_context *pctx); -void v3dX(emit_rcl)(struct vc5_job *job); +void v3dX(emit_rcl)(struct v3d_job *job); void v3dX(draw_init)(struct pipe_context *pctx); void v3dX(state_init)(struct pipe_context *pctx); -void v3dX(bcl_epilogue)(struct vc5_context *vc5, struct vc5_job *job); +void v3dX(bcl_epilogue)(struct v3d_context *v3d, struct v3d_job *job); void v3dX(simulator_init_regs)(struct v3d_hw *v3d); int v3dX(simulator_get_param_ioctl)(struct v3d_hw *v3d, struct drm_v3d_get_param *args); void v3dX(simulator_flush)(struct v3d_hw *v3d, struct drm_v3d_submit_cl *submit, uint32_t gmp_ofs); -const struct vc5_format *v3dX(get_format_desc)(enum pipe_format f); +const struct v3d_format *v3dX(get_format_desc)(enum pipe_format f); void v3dX(get_internal_type_bpp_for_output_format)(uint32_t format, uint32_t *type, uint32_t *bpp); diff --git a/src/gallium/drivers/v3d/v3dx_draw.c b/src/gallium/drivers/v3d/v3dx_draw.c index 03ee6b2b196..28b35165c77 100644 --- a/src/gallium/drivers/v3d/v3dx_draw.c +++ b/src/gallium/drivers/v3d/v3dx_draw.c @@ -40,9 +40,9 @@ * Does the initial bining command list setup for drawing to a given FBO. */ static void -vc5_start_draw(struct vc5_context *vc5) +v3d_start_draw(struct v3d_context *v3d) { - struct vc5_job *job = vc5->job; + struct v3d_job *job = v3d->job; if (job->needs_flush) return; @@ -50,14 +50,14 @@ vc5_start_draw(struct vc5_context *vc5) /* Get space to emit our BCL state, using a branch to jump to a new BO * if necessary. */ - vc5_cl_ensure_space_with_branch(&job->bcl, 256 /* XXX */); + v3d_cl_ensure_space_with_branch(&job->bcl, 256 /* XXX */); job->submit.bcl_start = job->bcl.bo->offset; - vc5_job_add_bo(job, job->bcl.bo); + v3d_job_add_bo(job, job->bcl.bo); - job->tile_alloc = vc5_bo_alloc(vc5->screen, 1024 * 1024, "tile alloc"); - uint32_t tsda_per_tile_size = vc5->screen->devinfo.ver >= 40 ? 256 : 64; - job->tile_state = vc5_bo_alloc(vc5->screen, + job->tile_alloc = v3d_bo_alloc(v3d->screen, 1024 * 1024, "tile alloc"); + uint32_t tsda_per_tile_size = v3d->screen->devinfo.ver >= 40 ? 256 : 64; + job->tile_state = v3d_bo_alloc(v3d->screen, job->draw_tiles_y * job->draw_tiles_x * tsda_per_tile_size, @@ -78,10 +78,10 @@ vc5_start_draw(struct vc5_context *vc5) cl_emit(&job->bcl, TILE_BINNING_MODE_CONFIGURATION_PART1, config) { #if V3D_VERSION >= 40 - config.width_in_pixels_minus_1 = vc5->framebuffer.width - 1; - config.height_in_pixels_minus_1 = vc5->framebuffer.height - 1; + config.width_in_pixels_minus_1 = v3d->framebuffer.width - 1; + config.height_in_pixels_minus_1 = v3d->framebuffer.height - 1; config.number_of_render_targets_minus_1 = - MAX2(vc5->framebuffer.nr_cbufs, 1) - 1; + MAX2(v3d->framebuffer.nr_cbufs, 1) - 1; #else /* V3D_VERSION < 40 */ config.tile_state_data_array_base_address = cl_address(job->tile_state, 0); @@ -90,7 +90,7 @@ vc5_start_draw(struct vc5_context *vc5) config.height_in_tiles = job->draw_tiles_y; /* Must be >= 1 */ config.number_of_render_targets = - MAX2(vc5->framebuffer.nr_cbufs, 1); + MAX2(v3d->framebuffer.nr_cbufs, 1); #endif /* V3D_VERSION < 40 */ config.multisample_mode_4x = job->msaa; @@ -110,53 +110,53 @@ vc5_start_draw(struct vc5_context *vc5) cl_emit(&job->bcl, START_TILE_BINNING, bin); job->needs_flush = true; - job->draw_width = vc5->framebuffer.width; - job->draw_height = vc5->framebuffer.height; + job->draw_width = v3d->framebuffer.width; + job->draw_height = v3d->framebuffer.height; } static void -vc5_predraw_check_textures(struct pipe_context *pctx, - struct vc5_texture_stateobj *stage_tex) +v3d_predraw_check_textures(struct pipe_context *pctx, + struct v3d_texture_stateobj *stage_tex) { - struct vc5_context *vc5 = vc5_context(pctx); + struct v3d_context *v3d = v3d_context(pctx); for (int i = 0; i < stage_tex->num_textures; i++) { struct pipe_sampler_view *view = stage_tex->textures[i]; if (!view) continue; - vc5_flush_jobs_writing_resource(vc5, view->texture); + v3d_flush_jobs_writing_resource(v3d, view->texture); } } static void -vc5_emit_gl_shader_state(struct vc5_context *vc5, +v3d_emit_gl_shader_state(struct v3d_context *v3d, const struct pipe_draw_info *info) { - struct vc5_job *job = vc5->job; + struct v3d_job *job = v3d->job; /* VC5_DIRTY_VTXSTATE */ - struct vc5_vertex_stateobj *vtx = vc5->vtx; + struct v3d_vertex_stateobj *vtx = v3d->vtx; /* VC5_DIRTY_VTXBUF */ - struct vc5_vertexbuf_stateobj *vertexbuf = &vc5->vertexbuf; + struct v3d_vertexbuf_stateobj *vertexbuf = &v3d->vertexbuf; /* Upload the uniforms to the indirect CL first */ - struct vc5_cl_reloc fs_uniforms = - vc5_write_uniforms(vc5, vc5->prog.fs, - &vc5->constbuf[PIPE_SHADER_FRAGMENT], - &vc5->fragtex); - struct vc5_cl_reloc vs_uniforms = - vc5_write_uniforms(vc5, vc5->prog.vs, - &vc5->constbuf[PIPE_SHADER_VERTEX], - &vc5->verttex); - struct vc5_cl_reloc cs_uniforms = - vc5_write_uniforms(vc5, vc5->prog.cs, - &vc5->constbuf[PIPE_SHADER_VERTEX], - &vc5->verttex); + struct v3d_cl_reloc fs_uniforms = + v3d_write_uniforms(v3d, v3d->prog.fs, + &v3d->constbuf[PIPE_SHADER_FRAGMENT], + &v3d->fragtex); + struct v3d_cl_reloc vs_uniforms = + v3d_write_uniforms(v3d, v3d->prog.vs, + &v3d->constbuf[PIPE_SHADER_VERTEX], + &v3d->verttex); + struct v3d_cl_reloc cs_uniforms = + v3d_write_uniforms(v3d, v3d->prog.cs, + &v3d->constbuf[PIPE_SHADER_VERTEX], + &v3d->verttex); /* See GFXH-930 workaround below */ uint32_t num_elements_to_emit = MAX2(vtx->num_elements, 1); uint32_t shader_rec_offset = - vc5_cl_ensure_space(&job->indirect, + v3d_cl_ensure_space(&job->indirect, cl_packet_length(GL_SHADER_STATE_RECORD) + num_elements_to_emit * cl_packet_length(GL_SHADER_STATE_ATTRIBUTE_RECORD), @@ -167,30 +167,30 @@ vc5_emit_gl_shader_state(struct vc5_context *vc5, /* VC5_DIRTY_PRIM_MODE | VC5_DIRTY_RASTERIZER */ shader.point_size_in_shaded_vertex_data = (info->mode == PIPE_PRIM_POINTS && - vc5->rasterizer->base.point_size_per_vertex); + v3d->rasterizer->base.point_size_per_vertex); /* Must be set if the shader modifies Z, discards, or modifies * the sample mask. For any of these cases, the fragment * shader needs to write the Z value (even just discards). */ shader.fragment_shader_does_z_writes = - (vc5->prog.fs->prog_data.fs->writes_z || - vc5->prog.fs->prog_data.fs->discard); + (v3d->prog.fs->prog_data.fs->writes_z || + v3d->prog.fs->prog_data.fs->discard); shader.fragment_shader_uses_real_pixel_centre_w_in_addition_to_centroid_w2 = - vc5->prog.fs->prog_data.fs->uses_centroid_and_center_w; + v3d->prog.fs->prog_data.fs->uses_centroid_and_center_w; shader.number_of_varyings_in_fragment_shader = - vc5->prog.fs->prog_data.base->num_inputs; + v3d->prog.fs->prog_data.base->num_inputs; shader.propagate_nans = true; shader.coordinate_shader_code_address = - cl_address(vc5->prog.cs->bo, 0); + cl_address(v3d->prog.cs->bo, 0); shader.vertex_shader_code_address = - cl_address(vc5->prog.vs->bo, 0); + cl_address(v3d->prog.vs->bo, 0); shader.fragment_shader_code_address = - cl_address(vc5->prog.fs->bo, 0); + cl_address(v3d->prog.fs->bo, 0); /* XXX: Use combined input/output size flag in the common * case. @@ -198,14 +198,14 @@ vc5_emit_gl_shader_state(struct vc5_context *vc5, shader.coordinate_shader_has_separate_input_and_output_vpm_blocks = true; shader.vertex_shader_has_separate_input_and_output_vpm_blocks = true; shader.coordinate_shader_input_vpm_segment_size = - MAX2(vc5->prog.cs->prog_data.vs->vpm_input_size, 1); + MAX2(v3d->prog.cs->prog_data.vs->vpm_input_size, 1); shader.vertex_shader_input_vpm_segment_size = - MAX2(vc5->prog.vs->prog_data.vs->vpm_input_size, 1); + MAX2(v3d->prog.vs->prog_data.vs->vpm_input_size, 1); shader.coordinate_shader_output_vpm_segment_size = - vc5->prog.cs->prog_data.vs->vpm_output_size; + v3d->prog.cs->prog_data.vs->vpm_output_size; shader.vertex_shader_output_vpm_segment_size = - vc5->prog.vs->prog_data.vs->vpm_output_size; + v3d->prog.vs->prog_data.vs->vpm_output_size; shader.coordinate_shader_uniforms_address = cs_uniforms; shader.vertex_shader_uniforms_address = vs_uniforms; @@ -213,41 +213,41 @@ vc5_emit_gl_shader_state(struct vc5_context *vc5, #if V3D_VERSION >= 41 shader.coordinate_shader_4_way_threadable = - vc5->prog.cs->prog_data.vs->base.threads == 4; + v3d->prog.cs->prog_data.vs->base.threads == 4; shader.vertex_shader_4_way_threadable = - vc5->prog.vs->prog_data.vs->base.threads == 4; + v3d->prog.vs->prog_data.vs->base.threads == 4; shader.fragment_shader_4_way_threadable = - vc5->prog.fs->prog_data.fs->base.threads == 4; + v3d->prog.fs->prog_data.fs->base.threads == 4; shader.coordinate_shader_start_in_final_thread_section = - vc5->prog.cs->prog_data.vs->base.single_seg; + v3d->prog.cs->prog_data.vs->base.single_seg; shader.vertex_shader_start_in_final_thread_section = - vc5->prog.vs->prog_data.vs->base.single_seg; + v3d->prog.vs->prog_data.vs->base.single_seg; shader.fragment_shader_start_in_final_thread_section = - vc5->prog.fs->prog_data.fs->base.single_seg; + v3d->prog.fs->prog_data.fs->base.single_seg; #else shader.coordinate_shader_4_way_threadable = - vc5->prog.cs->prog_data.vs->base.threads == 4; + v3d->prog.cs->prog_data.vs->base.threads == 4; shader.coordinate_shader_2_way_threadable = - vc5->prog.cs->prog_data.vs->base.threads == 2; + v3d->prog.cs->prog_data.vs->base.threads == 2; shader.vertex_shader_4_way_threadable = - vc5->prog.vs->prog_data.vs->base.threads == 4; + v3d->prog.vs->prog_data.vs->base.threads == 4; shader.vertex_shader_2_way_threadable = - vc5->prog.vs->prog_data.vs->base.threads == 2; + v3d->prog.vs->prog_data.vs->base.threads == 2; shader.fragment_shader_4_way_threadable = - vc5->prog.fs->prog_data.fs->base.threads == 4; + v3d->prog.fs->prog_data.fs->base.threads == 4; shader.fragment_shader_2_way_threadable = - vc5->prog.fs->prog_data.fs->base.threads == 2; + v3d->prog.fs->prog_data.fs->base.threads == 2; #endif shader.vertex_id_read_by_coordinate_shader = - vc5->prog.cs->prog_data.vs->uses_vid; + v3d->prog.cs->prog_data.vs->uses_vid; shader.instance_id_read_by_coordinate_shader = - vc5->prog.cs->prog_data.vs->uses_iid; + v3d->prog.cs->prog_data.vs->uses_iid; shader.vertex_id_read_by_vertex_shader = - vc5->prog.vs->prog_data.vs->uses_vid; + v3d->prog.vs->prog_data.vs->uses_vid; shader.instance_id_read_by_vertex_shader = - vc5->prog.vs->prog_data.vs->uses_iid; + v3d->prog.vs->prog_data.vs->uses_iid; shader.address_of_default_attribute_values = cl_address(vtx->default_attribute_values, 0); @@ -257,7 +257,7 @@ vc5_emit_gl_shader_state(struct vc5_context *vc5, struct pipe_vertex_element *elem = &vtx->pipe[i]; struct pipe_vertex_buffer *vb = &vertexbuf->vb[elem->vertex_buffer_index]; - struct vc5_resource *rsc = vc5_resource(vb->buffer.resource); + struct v3d_resource *rsc = v3d_resource(vb->buffer.resource); const uint32_t size = cl_packet_length(GL_SHADER_STATE_ATTRIBUTE_RECORD); @@ -269,9 +269,9 @@ vc5_emit_gl_shader_state(struct vc5_context *vc5, vb->buffer_offset + elem->src_offset); attr.number_of_values_read_by_coordinate_shader = - vc5->prog.cs->prog_data.vs->vattr_sizes[i]; + v3d->prog.cs->prog_data.vs->vattr_sizes[i]; attr.number_of_values_read_by_vertex_shader = - vc5->prog.vs->prog_data.vs->vattr_sizes[i]; + v3d->prog.vs->prog_data.vs->vattr_sizes[i]; #if V3D_VERSION >= 41 attr.maximum_index = 0xffffff; #endif @@ -301,9 +301,9 @@ vc5_emit_gl_shader_state(struct vc5_context *vc5, state.number_of_attribute_arrays = num_elements_to_emit; } - vc5_bo_unreference(&cs_uniforms.bo); - vc5_bo_unreference(&vs_uniforms.bo); - vc5_bo_unreference(&fs_uniforms.bo); + v3d_bo_unreference(&cs_uniforms.bo); + v3d_bo_unreference(&vs_uniforms.bo); + v3d_bo_unreference(&fs_uniforms.bo); job->shader_rec_count++; } @@ -313,26 +313,26 @@ vc5_emit_gl_shader_state(struct vc5_context *vc5, * recorded by CL packets. */ static void -vc5_tf_statistics_record(struct vc5_context *vc5, +v3d_tf_statistics_record(struct v3d_context *v3d, const struct pipe_draw_info *info, bool prim_tf) { - if (!vc5->active_queries) + if (!v3d->active_queries) return; uint32_t prims = u_prims_for_vertices(info->mode, info->count); - vc5->prims_generated += prims; + v3d->prims_generated += prims; if (prim_tf) { /* XXX: Only count if we didn't overflow. */ - vc5->tf_prims_generated += prims; + v3d->tf_prims_generated += prims; } } static void -vc5_update_job_ez(struct vc5_context *vc5, struct vc5_job *job) +v3d_update_job_ez(struct v3d_context *v3d, struct v3d_job *job) { - switch (vc5->zsa->ez_state) { + switch (v3d->zsa->ez_state) { case VC5_EZ_UNDECIDED: /* If the Z/S state didn't pick a direction but didn't * disable, then go along with the current EZ state. This @@ -346,8 +346,8 @@ vc5_update_job_ez(struct vc5_context *vc5, struct vc5_job *job) * the current direction if we've decided on one. */ if (job->ez_state == VC5_EZ_UNDECIDED) - job->ez_state = vc5->zsa->ez_state; - else if (job->ez_state != vc5->zsa->ez_state) + job->ez_state = v3d->zsa->ez_state; + else if (job->ez_state != v3d->zsa->ez_state) job->ez_state = VC5_EZ_DISABLED; break; @@ -364,7 +364,7 @@ vc5_update_job_ez(struct vc5_context *vc5, struct vc5_job *job) * the chosen EZ direction (though we could use * ARB_conservative_depth's hints to avoid this) */ - if (vc5->prog.fs->prog_data.fs->writes_z) { + if (v3d->prog.fs->prog_data.fs->writes_z) { job->ez_state = VC5_EZ_DISABLED; } @@ -373,9 +373,9 @@ vc5_update_job_ez(struct vc5_context *vc5, struct vc5_job *job) } static void -vc5_draw_vbo(struct pipe_context *pctx, const struct pipe_draw_info *info) +v3d_draw_vbo(struct pipe_context *pctx, const struct pipe_draw_info *info) { - struct vc5_context *vc5 = vc5_context(pctx); + struct v3d_context *v3d = v3d_context(pctx); if (!info->count_from_stream_output && !info->indirect && !info->primitive_restart && @@ -403,8 +403,8 @@ vc5_draw_vbo(struct pipe_context *pctx, const struct pipe_draw_info *info) } if (info->mode >= PIPE_PRIM_QUADS) { - util_primconvert_save_rasterizer_state(vc5->primconvert, &vc5->rasterizer->base); - util_primconvert_draw_vbo(vc5->primconvert, info); + util_primconvert_save_rasterizer_state(v3d->primconvert, &v3d->rasterizer->base); + util_primconvert_draw_vbo(v3d->primconvert, info); perf_debug("Fallback conversion for %d %s vertices\n", info->count, u_prim_name(info->mode)); return; @@ -413,24 +413,24 @@ vc5_draw_vbo(struct pipe_context *pctx, const struct pipe_draw_info *info) /* Before setting up the draw, flush anything writing to the textures * that we read from. */ - vc5_predraw_check_textures(pctx, &vc5->verttex); - vc5_predraw_check_textures(pctx, &vc5->fragtex); + v3d_predraw_check_textures(pctx, &v3d->verttex); + v3d_predraw_check_textures(pctx, &v3d->fragtex); - struct vc5_job *job = vc5_get_job_for_fbo(vc5); + struct v3d_job *job = v3d_get_job_for_fbo(v3d); /* Get space to emit our draw call into the BCL, using a branch to * jump to a new BO if necessary. */ - vc5_cl_ensure_space_with_branch(&job->bcl, 256 /* XXX */); + v3d_cl_ensure_space_with_branch(&job->bcl, 256 /* XXX */); - if (vc5->prim_mode != info->mode) { - vc5->prim_mode = info->mode; - vc5->dirty |= VC5_DIRTY_PRIM_MODE; + if (v3d->prim_mode != info->mode) { + v3d->prim_mode = info->mode; + v3d->dirty |= VC5_DIRTY_PRIM_MODE; } - vc5_start_draw(vc5); - vc5_update_compiled_shaders(vc5, info->mode); - vc5_update_job_ez(vc5, job); + v3d_start_draw(v3d); + v3d_update_compiled_shaders(v3d, info->mode); + v3d_update_job_ez(v3d, job); #if V3D_VERSION >= 41 v3d41_emit_state(pctx); @@ -438,20 +438,20 @@ vc5_draw_vbo(struct pipe_context *pctx, const struct pipe_draw_info *info) v3d33_emit_state(pctx); #endif - if (vc5->dirty & (VC5_DIRTY_VTXBUF | + if (v3d->dirty & (VC5_DIRTY_VTXBUF | VC5_DIRTY_VTXSTATE | VC5_DIRTY_PRIM_MODE | VC5_DIRTY_RASTERIZER | VC5_DIRTY_COMPILED_CS | VC5_DIRTY_COMPILED_VS | VC5_DIRTY_COMPILED_FS | - vc5->prog.cs->uniform_dirty_bits | - vc5->prog.vs->uniform_dirty_bits | - vc5->prog.fs->uniform_dirty_bits)) { - vc5_emit_gl_shader_state(vc5, info); + v3d->prog.cs->uniform_dirty_bits | + v3d->prog.vs->uniform_dirty_bits | + v3d->prog.fs->uniform_dirty_bits)) { + v3d_emit_gl_shader_state(v3d, info); } - vc5->dirty = 0; + v3d->dirty = 0; /* The Base Vertex/Base Instance packet sets those values to nonzero * for the next draw call only. @@ -468,11 +468,11 @@ vc5_draw_vbo(struct pipe_context *pctx, const struct pipe_draw_info *info) /* V3D 3.x: The HW only processes transform feedback on primitives * with the flag set. */ - if (vc5->streamout.num_targets) + if (v3d->streamout.num_targets) prim_tf_enable = (V3D_PRIM_POINTS_TF - V3D_PRIM_POINTS); #endif - vc5_tf_statistics_record(vc5, info, vc5->streamout.num_targets); + v3d_tf_statistics_record(v3d, info, v3d->streamout.num_targets); /* Note that the primitive type fields match with OpenGL/gallium * definitions, up to but not including QUADS. @@ -483,14 +483,14 @@ vc5_draw_vbo(struct pipe_context *pctx, const struct pipe_draw_info *info) struct pipe_resource *prsc; if (info->has_user_indices) { prsc = NULL; - u_upload_data(vc5->uploader, 0, + u_upload_data(v3d->uploader, 0, info->count * info->index_size, 4, info->index.user, &offset, &prsc); } else { prsc = info->index.resource; } - struct vc5_resource *rsc = vc5_resource(prsc); + struct v3d_resource *rsc = v3d_resource(prsc); #if V3D_VERSION >= 40 cl_emit(&job->bcl, INDEX_BUFFER_SETUP, ib) { @@ -553,18 +553,18 @@ vc5_draw_vbo(struct pipe_context *pctx, const struct pipe_draw_info *info) } job->draw_calls_queued++; - if (vc5->zsa && job->zsbuf && - (vc5->zsa->base.depth.enabled || - vc5->zsa->base.stencil[0].enabled)) { - struct vc5_resource *rsc = vc5_resource(job->zsbuf->texture); - vc5_job_add_bo(job, rsc->bo); + if (v3d->zsa && job->zsbuf && + (v3d->zsa->base.depth.enabled || + v3d->zsa->base.stencil[0].enabled)) { + struct v3d_resource *rsc = v3d_resource(job->zsbuf->texture); + v3d_job_add_bo(job, rsc->bo); - if (vc5->zsa->base.depth.enabled) { + if (v3d->zsa->base.depth.enabled) { job->resolve |= PIPE_CLEAR_DEPTH; rsc->initialized_buffers = PIPE_CLEAR_DEPTH; } - if (vc5->zsa->base.stencil[0].enabled) { + if (v3d->zsa->base.stencil[0].enabled) { job->resolve |= PIPE_CLEAR_STENCIL; rsc->initialized_buffers |= PIPE_CLEAR_STENCIL; } @@ -575,36 +575,36 @@ vc5_draw_vbo(struct pipe_context *pctx, const struct pipe_draw_info *info) if (job->resolve & bit || !job->cbufs[i]) continue; - struct vc5_resource *rsc = vc5_resource(job->cbufs[i]->texture); + struct v3d_resource *rsc = v3d_resource(job->cbufs[i]->texture); job->resolve |= bit; - vc5_job_add_bo(job, rsc->bo); + v3d_job_add_bo(job, rsc->bo); } if (job->referenced_size > 768 * 1024 * 1024) { perf_debug("Flushing job with %dkb to try to free up memory\n", job->referenced_size / 1024); - vc5_flush(pctx); + v3d_flush(pctx); } if (V3D_DEBUG & V3D_DEBUG_ALWAYS_FLUSH) - vc5_flush(pctx); + v3d_flush(pctx); } static void -vc5_clear(struct pipe_context *pctx, unsigned buffers, +v3d_clear(struct pipe_context *pctx, unsigned buffers, const union pipe_color_union *color, double depth, unsigned stencil) { - struct vc5_context *vc5 = vc5_context(pctx); - struct vc5_job *job = vc5_get_job_for_fbo(vc5); + struct v3d_context *v3d = v3d_context(pctx); + struct v3d_job *job = v3d_get_job_for_fbo(v3d); /* We can't flag new buffers for clearing once we've queued draws. We * could avoid this by using the 3d engine to clear. */ if (job->draw_calls_queued) { perf_debug("Flushing rendering to process new clear.\n"); - vc5_job_submit(vc5, job); - job = vc5_get_job_for_fbo(vc5); + v3d_job_submit(v3d, job); + job = v3d_get_job_for_fbo(v3d); } for (int i = 0; i < VC5_MAX_DRAW_BUFFERS; i++) { @@ -612,15 +612,15 @@ vc5_clear(struct pipe_context *pctx, unsigned buffers, if (!(buffers & bit)) continue; - struct pipe_surface *psurf = vc5->framebuffer.cbufs[i]; - struct vc5_surface *surf = vc5_surface(psurf); - struct vc5_resource *rsc = vc5_resource(psurf->texture); + struct pipe_surface *psurf = v3d->framebuffer.cbufs[i]; + struct v3d_surface *surf = v3d_surface(psurf); + struct v3d_resource *rsc = v3d_resource(psurf->texture); union util_color uc; uint32_t internal_size = 4 << surf->internal_bpp; static union pipe_color_union swapped_color; - if (vc5->swap_color_rb & (1 << i)) { + if (v3d->swap_color_rb & (1 << i)) { swapped_color.f[0] = color->f[2]; swapped_color.f[1] = color->f[1]; swapped_color.f[2] = color->f[0]; @@ -665,8 +665,8 @@ vc5_clear(struct pipe_context *pctx, unsigned buffers, unsigned zsclear = buffers & PIPE_CLEAR_DEPTHSTENCIL; if (zsclear) { - struct vc5_resource *rsc = - vc5_resource(vc5->framebuffer.zsbuf->texture); + struct v3d_resource *rsc = + v3d_resource(v3d->framebuffer.zsbuf->texture); if (zsclear & PIPE_CLEAR_DEPTH) job->clear_z = depth; @@ -678,16 +678,16 @@ vc5_clear(struct pipe_context *pctx, unsigned buffers, job->draw_min_x = 0; job->draw_min_y = 0; - job->draw_max_x = vc5->framebuffer.width; - job->draw_max_y = vc5->framebuffer.height; + job->draw_max_x = v3d->framebuffer.width; + job->draw_max_y = v3d->framebuffer.height; job->cleared |= buffers; job->resolve |= buffers; - vc5_start_draw(vc5); + v3d_start_draw(v3d); } static void -vc5_clear_render_target(struct pipe_context *pctx, struct pipe_surface *ps, +v3d_clear_render_target(struct pipe_context *pctx, struct pipe_surface *ps, const union pipe_color_union *color, unsigned x, unsigned y, unsigned w, unsigned h, bool render_condition_enabled) @@ -696,7 +696,7 @@ vc5_clear_render_target(struct pipe_context *pctx, struct pipe_surface *ps, } static void -vc5_clear_depth_stencil(struct pipe_context *pctx, struct pipe_surface *ps, +v3d_clear_depth_stencil(struct pipe_context *pctx, struct pipe_surface *ps, unsigned buffers, double depth, unsigned stencil, unsigned x, unsigned y, unsigned w, unsigned h, bool render_condition_enabled) @@ -707,8 +707,8 @@ vc5_clear_depth_stencil(struct pipe_context *pctx, struct pipe_surface *ps, void v3dX(draw_init)(struct pipe_context *pctx) { - pctx->draw_vbo = vc5_draw_vbo; - pctx->clear = vc5_clear; - pctx->clear_render_target = vc5_clear_render_target; - pctx->clear_depth_stencil = vc5_clear_depth_stencil; + pctx->draw_vbo = v3d_draw_vbo; + pctx->clear = v3d_clear; + pctx->clear_render_target = v3d_clear_render_target; + pctx->clear_depth_stencil = v3d_clear_depth_stencil; } diff --git a/src/gallium/drivers/v3d/v3dx_emit.c b/src/gallium/drivers/v3d/v3dx_emit.c index e2aba356de4..a52ddfe6b1e 100644 --- a/src/gallium/drivers/v3d/v3dx_emit.c +++ b/src/gallium/drivers/v3d/v3dx_emit.c @@ -29,7 +29,7 @@ #include "broadcom/compiler/v3d_compiler.h" static uint8_t -vc5_factor(enum pipe_blendfactor factor, bool dst_alpha_one) +v3d_factor(enum pipe_blendfactor factor, bool dst_alpha_one) { /* We may get a bad blendfactor when blending is disabled. */ if (factor == 0) @@ -78,7 +78,7 @@ vc5_factor(enum pipe_blendfactor factor, bool dst_alpha_one) static inline uint16_t swizzled_border_color(const struct v3d_device_info *devinfo, struct pipe_sampler_state *sampler, - struct vc5_sampler_view *sview, + struct v3d_sampler_view *sview, int chan) { const struct util_format_description *desc = @@ -93,7 +93,7 @@ swizzled_border_color(const struct v3d_device_info *devinfo, * For swizzling in the shader, we don't do any pre-swizzling of the * border color. */ - if (vc5_get_tex_return_size(devinfo, sview->base.format, + if (v3d_get_tex_return_size(devinfo, sview->base.format, sampler->compare_mode) != 32) swiz = desc->swizzle[swiz]; @@ -127,26 +127,26 @@ translate_swizzle(unsigned char pipe_swizzle) } static void -emit_one_texture(struct vc5_context *vc5, struct vc5_texture_stateobj *stage_tex, +emit_one_texture(struct v3d_context *v3d, struct v3d_texture_stateobj *stage_tex, int i) { - struct vc5_job *job = vc5->job; + struct v3d_job *job = v3d->job; struct pipe_sampler_state *psampler = stage_tex->samplers[i]; - struct vc5_sampler_state *sampler = vc5_sampler_state(psampler); + struct v3d_sampler_state *sampler = v3d_sampler_state(psampler); struct pipe_sampler_view *psview = stage_tex->textures[i]; - struct vc5_sampler_view *sview = vc5_sampler_view(psview); + struct v3d_sampler_view *sview = v3d_sampler_view(psview); struct pipe_resource *prsc = psview->texture; - struct vc5_resource *rsc = vc5_resource(prsc); - const struct v3d_device_info *devinfo = &vc5->screen->devinfo; + struct v3d_resource *rsc = v3d_resource(prsc); + const struct v3d_device_info *devinfo = &v3d->screen->devinfo; stage_tex->texture_state[i].offset = - vc5_cl_ensure_space(&job->indirect, + v3d_cl_ensure_space(&job->indirect, cl_packet_length(TEXTURE_SHADER_STATE), 32); - vc5_bo_set_reference(&stage_tex->texture_state[i].bo, + v3d_bo_set_reference(&stage_tex->texture_state[i].bo, job->indirect.bo); - uint32_t return_size = vc5_get_tex_return_size(devinfo, psview->format, + uint32_t return_size = v3d_get_tex_return_size(devinfo, psview->format, psampler->compare_mode); struct V3D33_TEXTURE_SHADER_STATE unpacked = { @@ -246,24 +246,24 @@ emit_one_texture(struct vc5_context *vc5, struct vc5_texture_stateobj *stage_tex packed[i] |= sview->texture_shader_state[i] | sampler->texture_shader_state[i]; /* TMU indirect structs need to be 32b aligned. */ - vc5_cl_ensure_space(&job->indirect, ARRAY_SIZE(packed), 32); + v3d_cl_ensure_space(&job->indirect, ARRAY_SIZE(packed), 32); cl_emit_prepacked(&job->indirect, &packed); } static void -emit_textures(struct vc5_context *vc5, struct vc5_texture_stateobj *stage_tex) +emit_textures(struct v3d_context *v3d, struct v3d_texture_stateobj *stage_tex) { for (int i = 0; i < stage_tex->num_textures; i++) { if (stage_tex->textures[i]) - emit_one_texture(vc5, stage_tex, i); + emit_one_texture(v3d, stage_tex, i); } } #endif /* V3D_VERSION < 40 */ static uint32_t -translate_colormask(struct vc5_context *vc5, uint32_t colormask, int rt) +translate_colormask(struct v3d_context *v3d, uint32_t colormask, int rt) { - if (vc5->swap_color_rb & (1 << rt)) { + if (v3d->swap_color_rb & (1 << rt)) { colormask = ((colormask & (2 | 8)) | ((colormask & 1) << 2) | ((colormask & 4) >> 2)); @@ -273,7 +273,7 @@ translate_colormask(struct vc5_context *vc5, uint32_t colormask, int rt) } static void -emit_rt_blend(struct vc5_context *vc5, struct vc5_job *job, +emit_rt_blend(struct v3d_context *v3d, struct v3d_job *job, struct pipe_blend_state *blend, int rt) { cl_emit(&job->bcl, BLEND_CONFIG, config) { @@ -287,33 +287,33 @@ emit_rt_blend(struct vc5_context *vc5, struct vc5_job *job, config.colour_blend_mode = rtblend->rgb_func; config.colour_blend_dst_factor = - vc5_factor(rtblend->rgb_dst_factor, - vc5->blend_dst_alpha_one); + v3d_factor(rtblend->rgb_dst_factor, + v3d->blend_dst_alpha_one); config.colour_blend_src_factor = - vc5_factor(rtblend->rgb_src_factor, - vc5->blend_dst_alpha_one); + v3d_factor(rtblend->rgb_src_factor, + v3d->blend_dst_alpha_one); config.alpha_blend_mode = rtblend->alpha_func; config.alpha_blend_dst_factor = - vc5_factor(rtblend->alpha_dst_factor, - vc5->blend_dst_alpha_one); + v3d_factor(rtblend->alpha_dst_factor, + v3d->blend_dst_alpha_one); config.alpha_blend_src_factor = - vc5_factor(rtblend->alpha_src_factor, - vc5->blend_dst_alpha_one); + v3d_factor(rtblend->alpha_src_factor, + v3d->blend_dst_alpha_one); } } void v3dX(emit_state)(struct pipe_context *pctx) { - struct vc5_context *vc5 = vc5_context(pctx); - struct vc5_job *job = vc5->job; - bool rasterizer_discard = vc5->rasterizer->base.rasterizer_discard; + struct v3d_context *v3d = v3d_context(pctx); + struct v3d_job *job = v3d->job; + bool rasterizer_discard = v3d->rasterizer->base.rasterizer_discard; - if (vc5->dirty & (VC5_DIRTY_SCISSOR | VC5_DIRTY_VIEWPORT | + if (v3d->dirty & (VC5_DIRTY_SCISSOR | VC5_DIRTY_VIEWPORT | VC5_DIRTY_RASTERIZER)) { - float *vpscale = vc5->viewport.scale; - float *vptranslate = vc5->viewport.translate; + float *vpscale = v3d->viewport.scale; + float *vptranslate = v3d->viewport.translate; float vp_minx = -fabsf(vpscale[0]) + vptranslate[0]; float vp_maxx = fabsf(vpscale[0]) + vptranslate[0]; float vp_miny = -fabsf(vpscale[1]) + vptranslate[1]; @@ -328,16 +328,16 @@ v3dX(emit_state)(struct pipe_context *pctx) * primitives would rasterize outside of the view volume. */ uint32_t minx, miny, maxx, maxy; - if (!vc5->rasterizer->base.scissor) { + if (!v3d->rasterizer->base.scissor) { minx = MAX2(vp_minx, 0); miny = MAX2(vp_miny, 0); maxx = MIN2(vp_maxx, job->draw_width); maxy = MIN2(vp_maxy, job->draw_height); } else { - minx = MAX2(vp_minx, vc5->scissor.minx); - miny = MAX2(vp_miny, vc5->scissor.miny); - maxx = MIN2(vp_maxx, vc5->scissor.maxx); - maxy = MIN2(vp_maxy, vc5->scissor.maxy); + minx = MAX2(vp_minx, v3d->scissor.minx); + miny = MAX2(vp_miny, v3d->scissor.miny); + maxx = MIN2(vp_maxx, v3d->scissor.maxx); + maxy = MIN2(vp_maxy, v3d->scissor.maxy); } cl_emit(&job->bcl, CLIP_WINDOW, clip) { @@ -365,140 +365,140 @@ v3dX(emit_state)(struct pipe_context *pctx) job->draw_max_y = MAX2(job->draw_max_y, maxy); } - if (vc5->dirty & (VC5_DIRTY_RASTERIZER | + if (v3d->dirty & (VC5_DIRTY_RASTERIZER | VC5_DIRTY_ZSA | VC5_DIRTY_BLEND | VC5_DIRTY_COMPILED_FS)) { cl_emit(&job->bcl, CONFIGURATION_BITS, config) { config.enable_forward_facing_primitive = !rasterizer_discard && - !(vc5->rasterizer->base.cull_face & + !(v3d->rasterizer->base.cull_face & PIPE_FACE_FRONT); config.enable_reverse_facing_primitive = !rasterizer_discard && - !(vc5->rasterizer->base.cull_face & + !(v3d->rasterizer->base.cull_face & PIPE_FACE_BACK); /* This seems backwards, but it's what gets the * clipflat test to pass. */ config.clockwise_primitives = - vc5->rasterizer->base.front_ccw; + v3d->rasterizer->base.front_ccw; config.enable_depth_offset = - vc5->rasterizer->base.offset_tri; + v3d->rasterizer->base.offset_tri; config.rasterizer_oversample_mode = - vc5->rasterizer->base.multisample; + v3d->rasterizer->base.multisample; config.direct3d_provoking_vertex = - vc5->rasterizer->base.flatshade_first; + v3d->rasterizer->base.flatshade_first; - config.blend_enable = vc5->blend->rt[0].blend_enable; + config.blend_enable = v3d->blend->rt[0].blend_enable; /* Note: EZ state may update based on the compiled FS, * along with ZSA */ config.early_z_updates_enable = (job->ez_state != VC5_EZ_DISABLED); - if (vc5->zsa->base.depth.enabled) { + if (v3d->zsa->base.depth.enabled) { config.z_updates_enable = - vc5->zsa->base.depth.writemask; + v3d->zsa->base.depth.writemask; config.early_z_enable = config.early_z_updates_enable; config.depth_test_function = - vc5->zsa->base.depth.func; + v3d->zsa->base.depth.func; } else { config.depth_test_function = PIPE_FUNC_ALWAYS; } config.stencil_enable = - vc5->zsa->base.stencil[0].enabled; + v3d->zsa->base.stencil[0].enabled; } } - if (vc5->dirty & VC5_DIRTY_RASTERIZER && - vc5->rasterizer->base.offset_tri) { + if (v3d->dirty & VC5_DIRTY_RASTERIZER && + v3d->rasterizer->base.offset_tri) { cl_emit(&job->bcl, DEPTH_OFFSET, depth) { depth.depth_offset_factor = - vc5->rasterizer->offset_factor; + v3d->rasterizer->offset_factor; depth.depth_offset_units = - vc5->rasterizer->offset_units; + v3d->rasterizer->offset_units; } } - if (vc5->dirty & VC5_DIRTY_RASTERIZER) { + if (v3d->dirty & VC5_DIRTY_RASTERIZER) { cl_emit(&job->bcl, POINT_SIZE, point_size) { - point_size.point_size = vc5->rasterizer->point_size; + point_size.point_size = v3d->rasterizer->point_size; } cl_emit(&job->bcl, LINE_WIDTH, line_width) { - line_width.line_width = vc5->rasterizer->base.line_width; + line_width.line_width = v3d->rasterizer->base.line_width; } } - if (vc5->dirty & VC5_DIRTY_VIEWPORT) { + if (v3d->dirty & VC5_DIRTY_VIEWPORT) { cl_emit(&job->bcl, CLIPPER_XY_SCALING, clip) { clip.viewport_half_width_in_1_256th_of_pixel = - vc5->viewport.scale[0] * 256.0f; + v3d->viewport.scale[0] * 256.0f; clip.viewport_half_height_in_1_256th_of_pixel = - vc5->viewport.scale[1] * 256.0f; + v3d->viewport.scale[1] * 256.0f; } cl_emit(&job->bcl, CLIPPER_Z_SCALE_AND_OFFSET, clip) { clip.viewport_z_offset_zc_to_zs = - vc5->viewport.translate[2]; + v3d->viewport.translate[2]; clip.viewport_z_scale_zc_to_zs = - vc5->viewport.scale[2]; + v3d->viewport.scale[2]; } cl_emit(&job->bcl, CLIPPER_Z_MIN_MAX_CLIPPING_PLANES, clip) { - clip.minimum_zw = (vc5->viewport.translate[2] - - vc5->viewport.scale[2]); - clip.maximum_zw = (vc5->viewport.translate[2] + - vc5->viewport.scale[2]); + clip.minimum_zw = (v3d->viewport.translate[2] - + v3d->viewport.scale[2]); + clip.maximum_zw = (v3d->viewport.translate[2] + + v3d->viewport.scale[2]); } cl_emit(&job->bcl, VIEWPORT_OFFSET, vp) { vp.viewport_centre_x_coordinate = - vc5->viewport.translate[0]; + v3d->viewport.translate[0]; vp.viewport_centre_y_coordinate = - vc5->viewport.translate[1]; + v3d->viewport.translate[1]; } } - if (vc5->dirty & VC5_DIRTY_BLEND && vc5->blend->rt[0].blend_enable) { - struct pipe_blend_state *blend = vc5->blend; + if (v3d->dirty & VC5_DIRTY_BLEND && v3d->blend->rt[0].blend_enable) { + struct pipe_blend_state *blend = v3d->blend; if (blend->independent_blend_enable) { for (int i = 0; i < VC5_MAX_DRAW_BUFFERS; i++) - emit_rt_blend(vc5, job, blend, i); + emit_rt_blend(v3d, job, blend, i); } else { - emit_rt_blend(vc5, job, blend, 0); + emit_rt_blend(v3d, job, blend, 0); } } - if (vc5->dirty & VC5_DIRTY_BLEND) { - struct pipe_blend_state *blend = vc5->blend; + if (v3d->dirty & VC5_DIRTY_BLEND) { + struct pipe_blend_state *blend = v3d->blend; cl_emit(&job->bcl, COLOUR_WRITE_MASKS, mask) { if (blend->independent_blend_enable) { mask.render_target_0_per_colour_component_write_masks = - translate_colormask(vc5, blend->rt[0].colormask, 0); + translate_colormask(v3d, blend->rt[0].colormask, 0); mask.render_target_1_per_colour_component_write_masks = - translate_colormask(vc5, blend->rt[1].colormask, 1); + translate_colormask(v3d, blend->rt[1].colormask, 1); mask.render_target_2_per_colour_component_write_masks = - translate_colormask(vc5, blend->rt[2].colormask, 2); + translate_colormask(v3d, blend->rt[2].colormask, 2); mask.render_target_3_per_colour_component_write_masks = - translate_colormask(vc5, blend->rt[3].colormask, 3); + translate_colormask(v3d, blend->rt[3].colormask, 3); } else { mask.render_target_0_per_colour_component_write_masks = - translate_colormask(vc5, blend->rt[0].colormask, 0); + translate_colormask(v3d, blend->rt[0].colormask, 0); mask.render_target_1_per_colour_component_write_masks = - translate_colormask(vc5, blend->rt[0].colormask, 1); + translate_colormask(v3d, blend->rt[0].colormask, 1); mask.render_target_2_per_colour_component_write_masks = - translate_colormask(vc5, blend->rt[0].colormask, 2); + translate_colormask(v3d, blend->rt[0].colormask, 2); mask.render_target_3_per_colour_component_write_masks = - translate_colormask(vc5, blend->rt[0].colormask, 3); + translate_colormask(v3d, blend->rt[0].colormask, 3); } } } @@ -506,37 +506,37 @@ v3dX(emit_state)(struct pipe_context *pctx) /* GFXH-1431: On V3D 3.x, writing BLEND_CONFIG resets the constant * color. */ - if (vc5->dirty & VC5_DIRTY_BLEND_COLOR || - (V3D_VERSION < 41 && (vc5->dirty & VC5_DIRTY_BLEND))) { + if (v3d->dirty & VC5_DIRTY_BLEND_COLOR || + (V3D_VERSION < 41 && (v3d->dirty & VC5_DIRTY_BLEND))) { cl_emit(&job->bcl, BLEND_CONSTANT_COLOUR, colour) { - colour.red_f16 = (vc5->swap_color_rb ? - vc5->blend_color.hf[2] : - vc5->blend_color.hf[0]); - colour.green_f16 = vc5->blend_color.hf[1]; - colour.blue_f16 = (vc5->swap_color_rb ? - vc5->blend_color.hf[0] : - vc5->blend_color.hf[2]); - colour.alpha_f16 = vc5->blend_color.hf[3]; + colour.red_f16 = (v3d->swap_color_rb ? + v3d->blend_color.hf[2] : + v3d->blend_color.hf[0]); + colour.green_f16 = v3d->blend_color.hf[1]; + colour.blue_f16 = (v3d->swap_color_rb ? + v3d->blend_color.hf[0] : + v3d->blend_color.hf[2]); + colour.alpha_f16 = v3d->blend_color.hf[3]; } } - if (vc5->dirty & (VC5_DIRTY_ZSA | VC5_DIRTY_STENCIL_REF)) { - struct pipe_stencil_state *front = &vc5->zsa->base.stencil[0]; - struct pipe_stencil_state *back = &vc5->zsa->base.stencil[1]; + if (v3d->dirty & (VC5_DIRTY_ZSA | VC5_DIRTY_STENCIL_REF)) { + struct pipe_stencil_state *front = &v3d->zsa->base.stencil[0]; + struct pipe_stencil_state *back = &v3d->zsa->base.stencil[1]; if (front->enabled) { cl_emit_with_prepacked(&job->bcl, STENCIL_CONFIG, - vc5->zsa->stencil_front, config) { + v3d->zsa->stencil_front, config) { config.stencil_ref_value = - vc5->stencil_ref.ref_value[0]; + v3d->stencil_ref.ref_value[0]; } } if (back->enabled) { cl_emit_with_prepacked(&job->bcl, STENCIL_CONFIG, - vc5->zsa->stencil_back, config) { + v3d->zsa->stencil_back, config) { config.stencil_ref_value = - vc5->stencil_ref.ref_value[1]; + v3d->stencil_ref.ref_value[1]; } } } @@ -545,18 +545,18 @@ v3dX(emit_state)(struct pipe_context *pctx) /* Pre-4.x, we have texture state that depends on both the sampler and * the view, so we merge them together at draw time. */ - if (vc5->dirty & VC5_DIRTY_FRAGTEX) - emit_textures(vc5, &vc5->fragtex); + if (v3d->dirty & VC5_DIRTY_FRAGTEX) + emit_textures(v3d, &v3d->fragtex); - if (vc5->dirty & VC5_DIRTY_VERTTEX) - emit_textures(vc5, &vc5->verttex); + if (v3d->dirty & VC5_DIRTY_VERTTEX) + emit_textures(v3d, &v3d->verttex); #endif - if (vc5->dirty & VC5_DIRTY_FLAT_SHADE_FLAGS) { + if (v3d->dirty & VC5_DIRTY_FLAT_SHADE_FLAGS) { bool emitted_any = false; - for (int i = 0; i < ARRAY_SIZE(vc5->prog.fs->prog_data.fs->flat_shade_flags); i++) { - if (!vc5->prog.fs->prog_data.fs->flat_shade_flags[i]) + for (int i = 0; i < ARRAY_SIZE(v3d->prog.fs->prog_data.fs->flat_shade_flags); i++) { + if (!v3d->prog.fs->prog_data.fs->flat_shade_flags[i]) continue; cl_emit(&job->bcl, FLAT_SHADE_FLAGS, flags) { @@ -578,7 +578,7 @@ v3dX(emit_state)(struct pipe_context *pctx) } flags.flat_shade_flags_for_varyings_v024 = - vc5->prog.fs->prog_data.fs->flat_shade_flags[i]; + v3d->prog.fs->prog_data.fs->flat_shade_flags[i]; } emitted_any = true; @@ -590,11 +590,11 @@ v3dX(emit_state)(struct pipe_context *pctx) } #if V3D_VERSION >= 40 - if (vc5->dirty & VC5_DIRTY_CENTROID_FLAGS) { + if (v3d->dirty & VC5_DIRTY_CENTROID_FLAGS) { bool emitted_any = false; - for (int i = 0; i < ARRAY_SIZE(vc5->prog.fs->prog_data.fs->centroid_flags); i++) { - if (!vc5->prog.fs->prog_data.fs->centroid_flags[i]) + for (int i = 0; i < ARRAY_SIZE(v3d->prog.fs->prog_data.fs->centroid_flags); i++) { + if (!v3d->prog.fs->prog_data.fs->centroid_flags[i]) continue; cl_emit(&job->bcl, CENTROID_FLAGS, flags) { @@ -616,7 +616,7 @@ v3dX(emit_state)(struct pipe_context *pctx) } flags.centroid_flags_for_varyings_v024 = - vc5->prog.fs->prog_data.fs->centroid_flags[i]; + v3d->prog.fs->prog_data.fs->centroid_flags[i]; } emitted_any = true; @@ -631,25 +631,25 @@ v3dX(emit_state)(struct pipe_context *pctx) /* Set up the transform feedback data specs (which VPM entries to * output to which buffers). */ - if (vc5->dirty & (VC5_DIRTY_STREAMOUT | + if (v3d->dirty & (VC5_DIRTY_STREAMOUT | VC5_DIRTY_RASTERIZER | VC5_DIRTY_PRIM_MODE)) { - struct vc5_streamout_stateobj *so = &vc5->streamout; + struct v3d_streamout_stateobj *so = &v3d->streamout; if (so->num_targets) { - bool psiz_per_vertex = (vc5->prim_mode == PIPE_PRIM_POINTS && - vc5->rasterizer->base.point_size_per_vertex); + bool psiz_per_vertex = (v3d->prim_mode == PIPE_PRIM_POINTS && + v3d->rasterizer->base.point_size_per_vertex); uint16_t *tf_specs = (psiz_per_vertex ? - vc5->prog.bind_vs->tf_specs_psiz : - vc5->prog.bind_vs->tf_specs); + v3d->prog.bind_vs->tf_specs_psiz : + v3d->prog.bind_vs->tf_specs); #if V3D_VERSION >= 40 - job->tf_enabled = (vc5->prog.bind_vs->num_tf_specs != 0 && - vc5->active_queries); + job->tf_enabled = (v3d->prog.bind_vs->num_tf_specs != 0 && + v3d->active_queries); cl_emit(&job->bcl, TRANSFORM_FEEDBACK_SPECS, tfe) { tfe.number_of_16_bit_output_data_specs_following = - vc5->prog.bind_vs->num_tf_specs; + v3d->prog.bind_vs->num_tf_specs; tfe.enable = job->tf_enabled; }; #else /* V3D_VERSION < 40 */ @@ -657,10 +657,10 @@ v3dX(emit_state)(struct pipe_context *pctx) tfe.number_of_32_bit_output_buffer_address_following = so->num_targets; tfe.number_of_16_bit_output_data_specs_following = - vc5->prog.bind_vs->num_tf_specs; + v3d->prog.bind_vs->num_tf_specs; }; #endif /* V3D_VERSION < 40 */ - for (int i = 0; i < vc5->prog.bind_vs->num_tf_specs; i++) { + for (int i = 0; i < v3d->prog.bind_vs->num_tf_specs; i++) { cl_emit_prepacked(&job->bcl, &tf_specs[i]); } } else if (job->tf_enabled) { @@ -674,13 +674,13 @@ v3dX(emit_state)(struct pipe_context *pctx) } /* Set up the trasnform feedback buffers. */ - if (vc5->dirty & VC5_DIRTY_STREAMOUT) { - struct vc5_streamout_stateobj *so = &vc5->streamout; + if (v3d->dirty & VC5_DIRTY_STREAMOUT) { + struct v3d_streamout_stateobj *so = &v3d->streamout; for (int i = 0; i < so->num_targets; i++) { const struct pipe_stream_output_target *target = so->targets[i]; - struct vc5_resource *rsc = target ? - vc5_resource(target->buffer) : NULL; + struct v3d_resource *rsc = target ? + v3d_resource(target->buffer) : NULL; #if V3D_VERSION >= 40 if (!target) @@ -704,18 +704,18 @@ v3dX(emit_state)(struct pipe_context *pctx) }; #endif /* V3D_VERSION < 40 */ if (target) { - vc5_job_add_write_resource(vc5->job, + v3d_job_add_write_resource(v3d->job, target->buffer); } /* XXX: buffer_size? */ } } - if (vc5->dirty & VC5_DIRTY_OQ) { + if (v3d->dirty & VC5_DIRTY_OQ) { cl_emit(&job->bcl, OCCLUSION_QUERY_COUNTER, counter) { - job->oq_enabled = vc5->active_queries && vc5->current_oq; + job->oq_enabled = v3d->active_queries && v3d->current_oq; if (job->oq_enabled) { - counter.address = cl_address(vc5->current_oq, 0); + counter.address = cl_address(v3d->current_oq, 0); } } } diff --git a/src/gallium/drivers/v3d/v3dx_format_table.c b/src/gallium/drivers/v3d/v3dx_format_table.c index 458488119c7..39286bd6547 100644 --- a/src/gallium/drivers/v3d/v3dx_format_table.c +++ b/src/gallium/drivers/v3d/v3dx_format_table.c @@ -58,7 +58,7 @@ #define SWIZ_XXXX SWIZ(X, X, X, X) #define SWIZ_000X SWIZ(0, 0, 0, X) -static const struct vc5_format format_table[] = { +static const struct v3d_format format_table[] = { FORMAT(B8G8R8A8_UNORM, RGBA8, RGBA8, SWIZ_ZYXW, 16, 0), FORMAT(B8G8R8X8_UNORM, RGBA8, RGBA8, SWIZ_ZYX1, 16, 0), FORMAT(B8G8R8A8_SRGB, SRGB8_ALPHA8, RGBA8, SWIZ_ZYXW, 16, 0), @@ -178,7 +178,7 @@ static const struct vc5_format format_table[] = { FORMAT(DXT5_RGBA, NO, BC3, SWIZ_XYZ1, 16, 0), }; -const struct vc5_format * +const struct v3d_format * v3dX(get_format_desc)(enum pipe_format f) { if (f < ARRAY_SIZE(format_table) && format_table[f].present) diff --git a/src/gallium/drivers/v3d/v3dx_job.c b/src/gallium/drivers/v3d/v3dx_job.c index 5e1a345b170..036a39ea579 100644 --- a/src/gallium/drivers/v3d/v3dx_job.c +++ b/src/gallium/drivers/v3d/v3dx_job.c @@ -30,9 +30,9 @@ #include "v3d_context.h" #include "broadcom/cle/v3dx_pack.h" -void v3dX(bcl_epilogue)(struct vc5_context *vc5, struct vc5_job *job) +void v3dX(bcl_epilogue)(struct v3d_context *v3d, struct v3d_job *job) { - vc5_cl_ensure_space_with_branch(&job->bcl, + v3d_cl_ensure_space_with_branch(&job->bcl, cl_packet_length(OCCLUSION_QUERY_COUNTER) + #if V3D_VERSION >= 41 cl_packet_length(TRANSFORM_FEEDBACK_SPECS) + diff --git a/src/gallium/drivers/v3d/v3dx_rcl.c b/src/gallium/drivers/v3d/v3dx_rcl.c index 3801d03ecee..5be29aca1fd 100644 --- a/src/gallium/drivers/v3d/v3dx_rcl.c +++ b/src/gallium/drivers/v3d/v3dx_rcl.c @@ -40,7 +40,7 @@ * dummy store. */ static void -flush_last_load(struct vc5_cl *cl) +flush_last_load(struct v3d_cl *cl) { if (V3D_VERSION >= 40) return; @@ -52,17 +52,17 @@ flush_last_load(struct vc5_cl *cl) } static void -load_general(struct vc5_cl *cl, struct pipe_surface *psurf, int buffer, +load_general(struct v3d_cl *cl, struct pipe_surface *psurf, int buffer, uint32_t pipe_bit, uint32_t *loads_pending) { - struct vc5_surface *surf = vc5_surface(psurf); + struct v3d_surface *surf = v3d_surface(psurf); bool separate_stencil = surf->separate_stencil && buffer == STENCIL; if (separate_stencil) { psurf = surf->separate_stencil; - surf = vc5_surface(psurf); + surf = v3d_surface(psurf); } - struct vc5_resource *rsc = vc5_resource(psurf->texture); + struct v3d_resource *rsc = v3d_resource(psurf->texture); cl_emit(cl, LOAD_TILE_BUFFER_GENERAL, load) { load.buffer_to_load = buffer; @@ -80,7 +80,7 @@ load_general(struct vc5_cl *cl, struct pipe_surface *psurf, int buffer, load.height_in_ub_or_stride = surf->padded_height_of_output_image_in_uif_blocks; } else if (surf->tiling == VC5_TILING_RASTER) { - struct vc5_resource_slice *slice = + struct v3d_resource_slice *slice = &rsc->slices[psurf->u.tex.level]; load.height_in_ub_or_stride = slice->stride; } @@ -107,21 +107,21 @@ load_general(struct vc5_cl *cl, struct pipe_surface *psurf, int buffer, } static void -store_general(struct vc5_job *job, - struct vc5_cl *cl, struct pipe_surface *psurf, int buffer, +store_general(struct v3d_job *job, + struct v3d_cl *cl, struct pipe_surface *psurf, int buffer, int pipe_bit, uint32_t *stores_pending, bool general_color_clear) { - struct vc5_surface *surf = vc5_surface(psurf); + struct v3d_surface *surf = v3d_surface(psurf); bool separate_stencil = surf->separate_stencil && buffer == STENCIL; if (separate_stencil) { psurf = surf->separate_stencil; - surf = vc5_surface(psurf); + surf = v3d_surface(psurf); } *stores_pending &= ~pipe_bit; bool last_store = !(*stores_pending); - struct vc5_resource *rsc = vc5_resource(psurf->texture); + struct v3d_resource *rsc = v3d_resource(psurf->texture); rsc->writes++; @@ -147,7 +147,7 @@ store_general(struct vc5_job *job, store.height_in_ub_or_stride = surf->padded_height_of_output_image_in_uif_blocks; } else if (surf->tiling == VC5_TILING_RASTER) { - struct vc5_resource_slice *slice = + struct v3d_resource_slice *slice = &rsc->slices[psurf->u.tex.level]; store.height_in_ub_or_stride = slice->stride; } @@ -204,7 +204,7 @@ zs_buffer_from_pipe_bits(int pipe_clear_bits) } static void -vc5_rcl_emit_loads(struct vc5_job *job, struct vc5_cl *cl) +v3d_rcl_emit_loads(struct v3d_job *job, struct v3d_cl *cl) { uint32_t loads_pending = job->resolve & ~job->cleared; @@ -226,7 +226,7 @@ vc5_rcl_emit_loads(struct vc5_job *job, struct vc5_cl *cl) if ((loads_pending & PIPE_CLEAR_DEPTHSTENCIL) && (V3D_VERSION >= 40 || (job->zsbuf && job->zsbuf->texture->nr_samples > 1))) { - struct vc5_resource *rsc = vc5_resource(job->zsbuf->texture); + struct v3d_resource *rsc = v3d_resource(job->zsbuf->texture); if (rsc->separate_stencil && (loads_pending & PIPE_CLEAR_STENCIL)) { @@ -267,7 +267,7 @@ vc5_rcl_emit_loads(struct vc5_job *job, struct vc5_cl *cl) } static void -vc5_rcl_emit_stores(struct vc5_job *job, struct vc5_cl *cl) +v3d_rcl_emit_stores(struct v3d_job *job, struct v3d_cl *cl) { MAYBE_UNUSED bool needs_color_clear = job->cleared & PIPE_CLEAR_COLOR_BUFFERS; MAYBE_UNUSED bool needs_z_clear = job->cleared & PIPE_CLEAR_DEPTH; @@ -319,7 +319,7 @@ vc5_rcl_emit_stores(struct vc5_job *job, struct vc5_cl *cl) if (job->resolve & PIPE_CLEAR_DEPTHSTENCIL && job->zsbuf && !(V3D_VERSION < 40 && job->zsbuf->texture->nr_samples <= 1)) { - struct vc5_resource *rsc = vc5_resource(job->zsbuf->texture); + struct v3d_resource *rsc = v3d_resource(job->zsbuf->texture); if (rsc->separate_stencil) { if (job->resolve & PIPE_CLEAR_DEPTH) { store_general(job, cl, job->zsbuf, Z, @@ -382,14 +382,14 @@ vc5_rcl_emit_stores(struct vc5_job *job, struct vc5_cl *cl) } static void -vc5_rcl_emit_generic_per_tile_list(struct vc5_job *job, int last_cbuf) +v3d_rcl_emit_generic_per_tile_list(struct v3d_job *job, int last_cbuf) { /* Emit the generic list in our indirect state -- the rcl will just * have pointers into it. */ - struct vc5_cl *cl = &job->indirect; - vc5_cl_ensure_space(cl, 200, 1); - struct vc5_cl_reloc tile_list_start = cl_get_address(cl); + struct v3d_cl *cl = &job->indirect; + v3d_cl_ensure_space(cl, 200, 1); + struct v3d_cl_reloc tile_list_start = cl_get_address(cl); if (V3D_VERSION >= 40) { /* V3D 4.x only requires a single tile coordinates, and @@ -398,7 +398,7 @@ vc5_rcl_emit_generic_per_tile_list(struct vc5_job *job, int last_cbuf) cl_emit(cl, TILE_COORDINATES_IMPLICIT, coords); } - vc5_rcl_emit_loads(job, cl); + v3d_rcl_emit_loads(job, cl); if (V3D_VERSION < 40) { /* Tile Coordinates triggers the last reload and sets where @@ -417,7 +417,7 @@ vc5_rcl_emit_generic_per_tile_list(struct vc5_job *job, int last_cbuf) cl_emit(cl, BRANCH_TO_IMPLICIT_TILE_LIST, branch); - vc5_rcl_emit_stores(job, cl); + v3d_rcl_emit_stores(job, cl); #if V3D_VERSION >= 40 cl_emit(cl, END_OF_TILE_MARKER, end); @@ -433,13 +433,13 @@ vc5_rcl_emit_generic_per_tile_list(struct vc5_job *job, int last_cbuf) #if V3D_VERSION >= 40 static void -v3d_setup_render_target(struct vc5_job *job, int cbuf, +v3d_setup_render_target(struct v3d_job *job, int cbuf, uint32_t *rt_bpp, uint32_t *rt_type, uint32_t *rt_clamp) { if (!job->cbufs[cbuf]) return; - struct vc5_surface *surf = vc5_surface(job->cbufs[cbuf]); + struct v3d_surface *surf = v3d_surface(job->cbufs[cbuf]); *rt_bpp = surf->internal_bpp; *rt_type = surf->internal_type; *rt_clamp = V3D_RENDER_TARGET_CLAMP_NONE; @@ -448,8 +448,8 @@ v3d_setup_render_target(struct vc5_job *job, int cbuf, #else /* V3D_VERSION < 40 */ static void -v3d_emit_z_stencil_config(struct vc5_job *job, struct vc5_surface *surf, - struct vc5_resource *rsc, bool is_separate_stencil) +v3d_emit_z_stencil_config(struct v3d_job *job, struct v3d_surface *surf, + struct v3d_resource *rsc, bool is_separate_stencil) { cl_emit(&job->rcl, TILE_RENDERING_MODE_CONFIGURATION_Z_STENCIL_CONFIG, zs) { zs.address = cl_address(rsc->bo, surf->offset); @@ -479,15 +479,15 @@ v3d_emit_z_stencil_config(struct vc5_job *job, struct vc5_surface *surf, #define div_round_up(a, b) (((a) + (b) - 1) / b) void -v3dX(emit_rcl)(struct vc5_job *job) +v3dX(emit_rcl)(struct v3d_job *job) { /* The RCL list should be empty. */ assert(!job->rcl.bo); - vc5_cl_ensure_space_with_branch(&job->rcl, 200 + 256 * + v3d_cl_ensure_space_with_branch(&job->rcl, 200 + 256 * cl_packet_length(SUPERTILE_COORDINATES)); job->submit.rcl_start = job->rcl.bo->offset; - vc5_job_add_bo(job, job->rcl.bo); + v3d_job_add_bo(job, job->rcl.bo); int nr_cbufs = 0; for (int i = 0; i < VC5_MAX_DRAW_BUFFERS; i++) { @@ -506,7 +506,7 @@ v3dX(emit_rcl)(struct vc5_job *job) config.enable_stencil_store = job->resolve & PIPE_CLEAR_STENCIL; #else /* V3D_VERSION >= 40 */ if (job->zsbuf) { - struct vc5_surface *surf = vc5_surface(job->zsbuf); + struct v3d_surface *surf = v3d_surface(job->zsbuf); config.internal_depth_type = surf->internal_type; } #endif /* V3D_VERSION >= 40 */ @@ -544,8 +544,8 @@ v3dX(emit_rcl)(struct vc5_job *job) struct pipe_surface *psurf = job->cbufs[i]; if (!psurf) continue; - struct vc5_surface *surf = vc5_surface(psurf); - struct vc5_resource *rsc = vc5_resource(psurf->texture); + struct v3d_surface *surf = v3d_surface(psurf); + struct v3d_resource *rsc = v3d_resource(psurf->texture); MAYBE_UNUSED uint32_t config_pad = 0; uint32_t clear_pad = 0; @@ -553,7 +553,7 @@ v3dX(emit_rcl)(struct vc5_job *job) /* XXX: Set the pad for raster. */ if (surf->tiling == VC5_TILING_UIF_NO_XOR || surf->tiling == VC5_TILING_UIF_XOR) { - int uif_block_height = vc5_utile_height(rsc->cpp) * 2; + int uif_block_height = v3d_utile_height(rsc->cpp) * 2; uint32_t implicit_padded_height = (align(job->draw_height, uif_block_height) / uif_block_height); if (surf->padded_height_of_output_image_in_uif_blocks - @@ -636,8 +636,8 @@ v3dX(emit_rcl)(struct vc5_job *job) /* TODO: Don't bother emitting if we don't load/clear Z/S. */ if (job->zsbuf) { struct pipe_surface *psurf = job->zsbuf; - struct vc5_surface *surf = vc5_surface(psurf); - struct vc5_resource *rsc = vc5_resource(psurf->texture); + struct v3d_surface *surf = v3d_surface(psurf); + struct v3d_resource *rsc = v3d_resource(psurf->texture); v3d_emit_z_stencil_config(job, surf, rsc, false); @@ -647,7 +647,7 @@ v3dX(emit_rcl)(struct vc5_job *job) */ if (surf->separate_stencil) { v3d_emit_z_stencil_config(job, - vc5_surface(surf->separate_stencil), + v3d_surface(surf->separate_stencil), rsc->separate_stencil, true); } } @@ -752,7 +752,7 @@ v3dX(emit_rcl)(struct vc5_job *job) cl_emit(&job->rcl, FLUSH_VCD_CACHE, flush); - vc5_rcl_emit_generic_per_tile_list(job, nr_cbufs - 1); + v3d_rcl_emit_generic_per_tile_list(job, nr_cbufs - 1); cl_emit(&job->rcl, WAIT_ON_SEMAPHORE, sem); diff --git a/src/gallium/drivers/v3d/v3dx_simulator.c b/src/gallium/drivers/v3d/v3dx_simulator.c index ee8b6f2b9fd..a1e72e0e1d9 100644 --- a/src/gallium/drivers/v3d/v3dx_simulator.c +++ b/src/gallium/drivers/v3d/v3dx_simulator.c @@ -22,7 +22,7 @@ */ /** - * @file vc5_simulator_hw.c + * @file v3d_simulator_hw.c * * Implements the actual HW interaction betweeh the GL driver's VC5 simulator and the simulator. * @@ -49,7 +49,7 @@ #define V3D_READ(reg) v3d_hw_read_reg(v3d, reg) static void -vc5_flush_l3(struct v3d_hw *v3d) +v3d_flush_l3(struct v3d_hw *v3d) { if (!v3d_hw_has_gca(v3d)) return; @@ -64,7 +64,7 @@ vc5_flush_l3(struct v3d_hw *v3d) /* Invalidates the L2 cache. This is a read-only cache. */ static void -vc5_flush_l2(struct v3d_hw *v3d) +v3d_flush_l2(struct v3d_hw *v3d) { V3D_WRITE(V3D_CTL_0_L2CACTL, V3D_CTL_0_L2CACTL_L2CCLR_SET | @@ -73,7 +73,7 @@ vc5_flush_l2(struct v3d_hw *v3d) /* Invalidates texture L2 cachelines */ static void -vc5_flush_l2t(struct v3d_hw *v3d) +v3d_flush_l2t(struct v3d_hw *v3d) { V3D_WRITE(V3D_CTL_0_L2TFLSTA, 0); V3D_WRITE(V3D_CTL_0_L2TFLEND, ~0); @@ -84,18 +84,18 @@ vc5_flush_l2t(struct v3d_hw *v3d) /* Invalidates the slice caches. These are read-only caches. */ static void -vc5_flush_slices(struct v3d_hw *v3d) +v3d_flush_slices(struct v3d_hw *v3d) { V3D_WRITE(V3D_CTL_0_SLCACTL, ~0); } static void -vc5_flush_caches(struct v3d_hw *v3d) +v3d_flush_caches(struct v3d_hw *v3d) { - vc5_flush_l3(v3d); - vc5_flush_l2(v3d); - vc5_flush_l2t(v3d); - vc5_flush_slices(v3d); + v3d_flush_l3(v3d); + v3d_flush_l2(v3d); + v3d_flush_l2t(v3d); + v3d_flush_slices(v3d); } int @@ -152,7 +152,7 @@ v3dX(simulator_flush)(struct v3d_hw *v3d, struct drm_v3d_submit_cl *submit, ; } - vc5_flush_caches(v3d); + v3d_flush_caches(v3d); if (submit->qma) { V3D_WRITE(V3D_CLE_0_CT0QMA, submit->qma); diff --git a/src/gallium/drivers/v3d/v3dx_state.c b/src/gallium/drivers/v3d/v3dx_state.c index e992796a218..1387a22e048 100644 --- a/src/gallium/drivers/v3d/v3dx_state.c +++ b/src/gallium/drivers/v3d/v3dx_state.c @@ -37,7 +37,7 @@ #include "broadcom/cle/v3dx_pack.h" static void * -vc5_generic_cso_state_create(const void *src, uint32_t size) +v3d_generic_cso_state_create(const void *src, uint32_t size) { void *dst = calloc(1, size); if (!dst) @@ -47,48 +47,48 @@ vc5_generic_cso_state_create(const void *src, uint32_t size) } static void -vc5_generic_cso_state_delete(struct pipe_context *pctx, void *hwcso) +v3d_generic_cso_state_delete(struct pipe_context *pctx, void *hwcso) { free(hwcso); } static void -vc5_set_blend_color(struct pipe_context *pctx, +v3d_set_blend_color(struct pipe_context *pctx, const struct pipe_blend_color *blend_color) { - struct vc5_context *vc5 = vc5_context(pctx); - vc5->blend_color.f = *blend_color; + struct v3d_context *v3d = v3d_context(pctx); + v3d->blend_color.f = *blend_color; for (int i = 0; i < 4; i++) { - vc5->blend_color.hf[i] = + v3d->blend_color.hf[i] = util_float_to_half(blend_color->color[i]); } - vc5->dirty |= VC5_DIRTY_BLEND_COLOR; + v3d->dirty |= VC5_DIRTY_BLEND_COLOR; } static void -vc5_set_stencil_ref(struct pipe_context *pctx, +v3d_set_stencil_ref(struct pipe_context *pctx, const struct pipe_stencil_ref *stencil_ref) { - struct vc5_context *vc5 = vc5_context(pctx); - vc5->stencil_ref = *stencil_ref; - vc5->dirty |= VC5_DIRTY_STENCIL_REF; + struct v3d_context *v3d = v3d_context(pctx); + v3d->stencil_ref = *stencil_ref; + v3d->dirty |= VC5_DIRTY_STENCIL_REF; } static void -vc5_set_clip_state(struct pipe_context *pctx, +v3d_set_clip_state(struct pipe_context *pctx, const struct pipe_clip_state *clip) { - struct vc5_context *vc5 = vc5_context(pctx); - vc5->clip = *clip; - vc5->dirty |= VC5_DIRTY_CLIP; + struct v3d_context *v3d = v3d_context(pctx); + v3d->clip = *clip; + v3d->dirty |= VC5_DIRTY_CLIP; } static void -vc5_set_sample_mask(struct pipe_context *pctx, unsigned sample_mask) +v3d_set_sample_mask(struct pipe_context *pctx, unsigned sample_mask) { - struct vc5_context *vc5 = vc5_context(pctx); - vc5->sample_mask = sample_mask & ((1 << VC5_MAX_SAMPLES) - 1); - vc5->dirty |= VC5_DIRTY_SAMPLE_MASK; + struct v3d_context *v3d = v3d_context(pctx); + v3d->sample_mask = sample_mask & ((1 << VC5_MAX_SAMPLES) - 1); + v3d->dirty |= VC5_DIRTY_SAMPLE_MASK; } static uint16_t @@ -98,12 +98,12 @@ float_to_187_half(float f) } static void * -vc5_create_rasterizer_state(struct pipe_context *pctx, +v3d_create_rasterizer_state(struct pipe_context *pctx, const struct pipe_rasterizer_state *cso) { - struct vc5_rasterizer_state *so; + struct v3d_rasterizer_state *so; - so = CALLOC_STRUCT(vc5_rasterizer_state); + so = CALLOC_STRUCT(v3d_rasterizer_state); if (!so) return NULL; @@ -124,10 +124,10 @@ vc5_create_rasterizer_state(struct pipe_context *pctx, /* Blend state is baked into shaders. */ static void * -vc5_create_blend_state(struct pipe_context *pctx, +v3d_create_blend_state(struct pipe_context *pctx, const struct pipe_blend_state *cso) { - return vc5_generic_cso_state_create(cso, sizeof(*cso)); + return v3d_generic_cso_state_create(cso, sizeof(*cso)); } static uint32_t @@ -147,12 +147,12 @@ translate_stencil_op(enum pipe_stencil_op op) } static void * -vc5_create_depth_stencil_alpha_state(struct pipe_context *pctx, +v3d_create_depth_stencil_alpha_state(struct pipe_context *pctx, const struct pipe_depth_stencil_alpha_state *cso) { - struct vc5_depth_stencil_alpha_state *so; + struct v3d_depth_stencil_alpha_state *so; - so = CALLOC_STRUCT(vc5_depth_stencil_alpha_state); + so = CALLOC_STRUCT(v3d_depth_stencil_alpha_state); if (!so) return NULL; @@ -235,82 +235,82 @@ vc5_create_depth_stencil_alpha_state(struct pipe_context *pctx, } static void -vc5_set_polygon_stipple(struct pipe_context *pctx, +v3d_set_polygon_stipple(struct pipe_context *pctx, const struct pipe_poly_stipple *stipple) { - struct vc5_context *vc5 = vc5_context(pctx); - vc5->stipple = *stipple; - vc5->dirty |= VC5_DIRTY_STIPPLE; + struct v3d_context *v3d = v3d_context(pctx); + v3d->stipple = *stipple; + v3d->dirty |= VC5_DIRTY_STIPPLE; } static void -vc5_set_scissor_states(struct pipe_context *pctx, +v3d_set_scissor_states(struct pipe_context *pctx, unsigned start_slot, unsigned num_scissors, const struct pipe_scissor_state *scissor) { - struct vc5_context *vc5 = vc5_context(pctx); + struct v3d_context *v3d = v3d_context(pctx); - vc5->scissor = *scissor; - vc5->dirty |= VC5_DIRTY_SCISSOR; + v3d->scissor = *scissor; + v3d->dirty |= VC5_DIRTY_SCISSOR; } static void -vc5_set_viewport_states(struct pipe_context *pctx, +v3d_set_viewport_states(struct pipe_context *pctx, unsigned start_slot, unsigned num_viewports, const struct pipe_viewport_state *viewport) { - struct vc5_context *vc5 = vc5_context(pctx); - vc5->viewport = *viewport; - vc5->dirty |= VC5_DIRTY_VIEWPORT; + struct v3d_context *v3d = v3d_context(pctx); + v3d->viewport = *viewport; + v3d->dirty |= VC5_DIRTY_VIEWPORT; } static void -vc5_set_vertex_buffers(struct pipe_context *pctx, +v3d_set_vertex_buffers(struct pipe_context *pctx, unsigned start_slot, unsigned count, const struct pipe_vertex_buffer *vb) { - struct vc5_context *vc5 = vc5_context(pctx); - struct vc5_vertexbuf_stateobj *so = &vc5->vertexbuf; + struct v3d_context *v3d = v3d_context(pctx); + struct v3d_vertexbuf_stateobj *so = &v3d->vertexbuf; util_set_vertex_buffers_mask(so->vb, &so->enabled_mask, vb, start_slot, count); so->count = util_last_bit(so->enabled_mask); - vc5->dirty |= VC5_DIRTY_VTXBUF; + v3d->dirty |= VC5_DIRTY_VTXBUF; } static void -vc5_blend_state_bind(struct pipe_context *pctx, void *hwcso) +v3d_blend_state_bind(struct pipe_context *pctx, void *hwcso) { - struct vc5_context *vc5 = vc5_context(pctx); - vc5->blend = hwcso; - vc5->dirty |= VC5_DIRTY_BLEND; + struct v3d_context *v3d = v3d_context(pctx); + v3d->blend = hwcso; + v3d->dirty |= VC5_DIRTY_BLEND; } static void -vc5_rasterizer_state_bind(struct pipe_context *pctx, void *hwcso) +v3d_rasterizer_state_bind(struct pipe_context *pctx, void *hwcso) { - struct vc5_context *vc5 = vc5_context(pctx); - vc5->rasterizer = hwcso; - vc5->dirty |= VC5_DIRTY_RASTERIZER; + struct v3d_context *v3d = v3d_context(pctx); + v3d->rasterizer = hwcso; + v3d->dirty |= VC5_DIRTY_RASTERIZER; } static void -vc5_zsa_state_bind(struct pipe_context *pctx, void *hwcso) +v3d_zsa_state_bind(struct pipe_context *pctx, void *hwcso) { - struct vc5_context *vc5 = vc5_context(pctx); - vc5->zsa = hwcso; - vc5->dirty |= VC5_DIRTY_ZSA; + struct v3d_context *v3d = v3d_context(pctx); + v3d->zsa = hwcso; + v3d->dirty |= VC5_DIRTY_ZSA; } static void * -vc5_vertex_state_create(struct pipe_context *pctx, unsigned num_elements, +v3d_vertex_state_create(struct pipe_context *pctx, unsigned num_elements, const struct pipe_vertex_element *elements) { - struct vc5_context *vc5 = vc5_context(pctx); - struct vc5_vertex_stateobj *so = CALLOC_STRUCT(vc5_vertex_stateobj); + struct v3d_context *v3d = v3d_context(pctx); + struct v3d_vertex_stateobj *so = CALLOC_STRUCT(v3d_vertex_stateobj); if (!so) return NULL; @@ -385,11 +385,11 @@ vc5_vertex_state_create(struct pipe_context *pctx, unsigned num_elements, /* Set up the default attribute values in case any of the vertex * elements use them. */ - so->default_attribute_values = vc5_bo_alloc(vc5->screen, + so->default_attribute_values = v3d_bo_alloc(v3d->screen, VC5_MAX_ATTRIBUTES * 4 * sizeof(float), "default attributes"); - uint32_t *attrs = vc5_bo_map(so->default_attribute_values); + uint32_t *attrs = v3d_bo_map(so->default_attribute_values); for (int i = 0; i < VC5_MAX_ATTRIBUTES; i++) { attrs[i * 4 + 0] = 0; attrs[i * 4 + 1] = 0; @@ -406,19 +406,19 @@ vc5_vertex_state_create(struct pipe_context *pctx, unsigned num_elements, } static void -vc5_vertex_state_bind(struct pipe_context *pctx, void *hwcso) +v3d_vertex_state_bind(struct pipe_context *pctx, void *hwcso) { - struct vc5_context *vc5 = vc5_context(pctx); - vc5->vtx = hwcso; - vc5->dirty |= VC5_DIRTY_VTXSTATE; + struct v3d_context *v3d = v3d_context(pctx); + v3d->vtx = hwcso; + v3d->dirty |= VC5_DIRTY_VTXSTATE; } static void -vc5_set_constant_buffer(struct pipe_context *pctx, uint shader, uint index, +v3d_set_constant_buffer(struct pipe_context *pctx, uint shader, uint index, const struct pipe_constant_buffer *cb) { - struct vc5_context *vc5 = vc5_context(pctx); - struct vc5_constbuf_stateobj *so = &vc5->constbuf[shader]; + struct v3d_context *v3d = v3d_context(pctx); + struct v3d_constbuf_stateobj *so = &v3d->constbuf[shader]; util_copy_constant_buffer(&so->cb[index], cb); @@ -433,24 +433,24 @@ vc5_set_constant_buffer(struct pipe_context *pctx, uint shader, uint index, so->enabled_mask |= 1 << index; so->dirty_mask |= 1 << index; - vc5->dirty |= VC5_DIRTY_CONSTBUF; + v3d->dirty |= VC5_DIRTY_CONSTBUF; } static void -vc5_set_framebuffer_state(struct pipe_context *pctx, +v3d_set_framebuffer_state(struct pipe_context *pctx, const struct pipe_framebuffer_state *framebuffer) { - struct vc5_context *vc5 = vc5_context(pctx); - struct pipe_framebuffer_state *cso = &vc5->framebuffer; + struct v3d_context *v3d = v3d_context(pctx); + struct pipe_framebuffer_state *cso = &v3d->framebuffer; - vc5->job = NULL; + v3d->job = NULL; util_copy_framebuffer_state(cso, framebuffer); - vc5->swap_color_rb = 0; - vc5->blend_dst_alpha_one = 0; - for (int i = 0; i < vc5->framebuffer.nr_cbufs; i++) { - struct pipe_surface *cbuf = vc5->framebuffer.cbufs[i]; + v3d->swap_color_rb = 0; + v3d->blend_dst_alpha_one = 0; + for (int i = 0; i < v3d->framebuffer.nr_cbufs; i++) { + struct pipe_surface *cbuf = v3d->framebuffer.cbufs[i]; if (!cbuf) continue; @@ -462,27 +462,27 @@ vc5_set_framebuffer_state(struct pipe_context *pctx, */ if (desc->swizzle[0] == PIPE_SWIZZLE_Z && cbuf->format != PIPE_FORMAT_B5G6R5_UNORM) { - vc5->swap_color_rb |= 1 << i; + v3d->swap_color_rb |= 1 << i; } if (desc->swizzle[3] == PIPE_SWIZZLE_1) - vc5->blend_dst_alpha_one |= 1 << i; + v3d->blend_dst_alpha_one |= 1 << i; } - vc5->dirty |= VC5_DIRTY_FRAMEBUFFER; + v3d->dirty |= VC5_DIRTY_FRAMEBUFFER; } -static struct vc5_texture_stateobj * -vc5_get_stage_tex(struct vc5_context *vc5, enum pipe_shader_type shader) +static struct v3d_texture_stateobj * +v3d_get_stage_tex(struct v3d_context *v3d, enum pipe_shader_type shader) { switch (shader) { case PIPE_SHADER_FRAGMENT: - vc5->dirty |= VC5_DIRTY_FRAGTEX; - return &vc5->fragtex; + v3d->dirty |= VC5_DIRTY_FRAGTEX; + return &v3d->fragtex; break; case PIPE_SHADER_VERTEX: - vc5->dirty |= VC5_DIRTY_VERTTEX; - return &vc5->verttex; + v3d->dirty |= VC5_DIRTY_VERTTEX; + return &v3d->verttex; break; default: fprintf(stderr, "Unknown shader target %d\n", shader); @@ -510,11 +510,11 @@ static uint32_t translate_wrap(uint32_t pipe_wrap, bool using_nearest) static void * -vc5_create_sampler_state(struct pipe_context *pctx, +v3d_create_sampler_state(struct pipe_context *pctx, const struct pipe_sampler_state *cso) { - MAYBE_UNUSED struct vc5_context *vc5 = vc5_context(pctx); - struct vc5_sampler_state *so = CALLOC_STRUCT(vc5_sampler_state); + MAYBE_UNUSED struct v3d_context *v3d = v3d_context(pctx); + struct v3d_sampler_state *so = CALLOC_STRUCT(v3d_sampler_state); if (!so) return NULL; @@ -526,9 +526,9 @@ vc5_create_sampler_state(struct pipe_context *pctx, cso->min_img_filter == PIPE_TEX_MIPFILTER_NEAREST); #if V3D_VERSION >= 40 - so->bo = vc5_bo_alloc(vc5->screen, cl_packet_length(SAMPLER_STATE), + so->bo = v3d_bo_alloc(v3d->screen, cl_packet_length(SAMPLER_STATE), "sampler"); - void *map = vc5_bo_map(so->bo); + void *map = v3d_bo_map(so->bo); v3dx_pack(map, SAMPLER_STATE, sampler) { sampler.wrap_i_border = false; @@ -601,12 +601,12 @@ vc5_create_sampler_state(struct pipe_context *pctx, } static void -vc5_sampler_states_bind(struct pipe_context *pctx, +v3d_sampler_states_bind(struct pipe_context *pctx, enum pipe_shader_type shader, unsigned start, unsigned nr, void **hwcso) { - struct vc5_context *vc5 = vc5_context(pctx); - struct vc5_texture_stateobj *stage_tex = vc5_get_stage_tex(vc5, shader); + struct v3d_context *v3d = v3d_context(pctx); + struct v3d_texture_stateobj *stage_tex = v3d_get_stage_tex(v3d, shader); assert(start == 0); unsigned i; @@ -626,13 +626,13 @@ vc5_sampler_states_bind(struct pipe_context *pctx, } static void -vc5_sampler_state_delete(struct pipe_context *pctx, +v3d_sampler_state_delete(struct pipe_context *pctx, void *hwcso) { struct pipe_sampler_state *psampler = hwcso; - struct vc5_sampler_state *sampler = vc5_sampler_state(psampler); + struct v3d_sampler_state *sampler = v3d_sampler_state(psampler); - vc5_bo_unreference(&sampler->bo); + v3d_bo_unreference(&sampler->bo); free(psampler); } @@ -657,13 +657,13 @@ translate_swizzle(unsigned char pipe_swizzle) #endif static struct pipe_sampler_view * -vc5_create_sampler_view(struct pipe_context *pctx, struct pipe_resource *prsc, +v3d_create_sampler_view(struct pipe_context *pctx, struct pipe_resource *prsc, const struct pipe_sampler_view *cso) { - struct vc5_context *vc5 = vc5_context(pctx); - struct vc5_screen *screen = vc5->screen; - struct vc5_sampler_view *so = CALLOC_STRUCT(vc5_sampler_view); - struct vc5_resource *rsc = vc5_resource(prsc); + struct v3d_context *v3d = v3d_context(pctx); + struct v3d_screen *screen = v3d->screen; + struct v3d_sampler_view *so = CALLOC_STRUCT(v3d_sampler_view); + struct v3d_resource *rsc = v3d_resource(prsc); if (!so) return NULL; @@ -683,7 +683,7 @@ vc5_create_sampler_view(struct pipe_context *pctx, struct pipe_resource *prsc, cso->swizzle_a }; const uint8_t *fmt_swizzle = - vc5_get_format_swizzle(&screen->devinfo, so->base.format); + v3d_get_format_swizzle(&screen->devinfo, so->base.format); util_format_compose_swizzles(fmt_swizzle, view_swizzle, so->swizzle); so->base.texture = prsc; @@ -693,9 +693,9 @@ vc5_create_sampler_view(struct pipe_context *pctx, struct pipe_resource *prsc, int msaa_scale = prsc->nr_samples > 1 ? 2 : 1; #if V3D_VERSION >= 40 - so->bo = vc5_bo_alloc(vc5->screen, cl_packet_length(SAMPLER_STATE), + so->bo = v3d_bo_alloc(v3d->screen, cl_packet_length(SAMPLER_STATE), "sampler"); - void *map = vc5_bo_map(so->bo); + void *map = v3d_bo_map(so->bo); v3dx_pack(map, TEXTURE_SHADER_STATE, tex) { #else /* V3D_VERSION < 40 */ @@ -752,17 +752,17 @@ vc5_create_sampler_view(struct pipe_context *pctx, struct pipe_resource *prsc, * to catch failures. * * We explicitly allow remapping S8Z24 to RGBA8888 for - * vc5_blit.c's stencil blits. + * v3d_blit.c's stencil blits. */ assert((util_format_linear(cso->format) == util_format_linear(prsc->format)) || (prsc->format == PIPE_FORMAT_S8_UINT_Z24_UNORM && cso->format == PIPE_FORMAT_R8G8B8A8_UNORM)); uint32_t output_image_format = - vc5_get_rt_format(&screen->devinfo, cso->format); + v3d_get_rt_format(&screen->devinfo, cso->format); uint32_t internal_type; uint32_t internal_bpp; - vc5_get_internal_type_bpp_for_output_format(&screen->devinfo, + v3d_get_internal_type_bpp_for_output_format(&screen->devinfo, output_image_format, &internal_type, &internal_bpp); @@ -786,7 +786,7 @@ vc5_create_sampler_view(struct pipe_context *pctx, struct pipe_resource *prsc, */ tex.srgb = false; } else { - tex.texture_type = vc5_get_tex_format(&screen->devinfo, + tex.texture_type = v3d_get_tex_format(&screen->devinfo, cso->format); } @@ -817,24 +817,24 @@ vc5_create_sampler_view(struct pipe_context *pctx, struct pipe_resource *prsc, } static void -vc5_sampler_view_destroy(struct pipe_context *pctx, +v3d_sampler_view_destroy(struct pipe_context *pctx, struct pipe_sampler_view *psview) { - struct vc5_sampler_view *sview = vc5_sampler_view(psview); + struct v3d_sampler_view *sview = v3d_sampler_view(psview); - vc5_bo_unreference(&sview->bo); + v3d_bo_unreference(&sview->bo); pipe_resource_reference(&psview->texture, NULL); free(psview); } static void -vc5_set_sampler_views(struct pipe_context *pctx, +v3d_set_sampler_views(struct pipe_context *pctx, enum pipe_shader_type shader, unsigned start, unsigned nr, struct pipe_sampler_view **views) { - struct vc5_context *vc5 = vc5_context(pctx); - struct vc5_texture_stateobj *stage_tex = vc5_get_stage_tex(vc5, shader); + struct v3d_context *v3d = v3d_context(pctx); + struct v3d_texture_stateobj *stage_tex = v3d_get_stage_tex(v3d, shader); unsigned i; unsigned new_nr = 0; @@ -854,7 +854,7 @@ vc5_set_sampler_views(struct pipe_context *pctx, } static struct pipe_stream_output_target * -vc5_create_stream_output_target(struct pipe_context *pctx, +v3d_create_stream_output_target(struct pipe_context *pctx, struct pipe_resource *prsc, unsigned buffer_offset, unsigned buffer_size) @@ -876,7 +876,7 @@ vc5_create_stream_output_target(struct pipe_context *pctx, } static void -vc5_stream_output_target_destroy(struct pipe_context *pctx, +v3d_stream_output_target_destroy(struct pipe_context *pctx, struct pipe_stream_output_target *target) { pipe_resource_reference(&target->buffer, NULL); @@ -884,13 +884,13 @@ vc5_stream_output_target_destroy(struct pipe_context *pctx, } static void -vc5_set_stream_output_targets(struct pipe_context *pctx, +v3d_set_stream_output_targets(struct pipe_context *pctx, unsigned num_targets, struct pipe_stream_output_target **targets, const unsigned *offsets) { - struct vc5_context *ctx = vc5_context(pctx); - struct vc5_streamout_stateobj *so = &ctx->streamout; + struct v3d_context *ctx = v3d_context(pctx); + struct v3d_streamout_stateobj *so = &ctx->streamout; unsigned i; assert(num_targets <= ARRAY_SIZE(so->targets)); @@ -909,43 +909,43 @@ vc5_set_stream_output_targets(struct pipe_context *pctx, void v3dX(state_init)(struct pipe_context *pctx) { - pctx->set_blend_color = vc5_set_blend_color; - pctx->set_stencil_ref = vc5_set_stencil_ref; - pctx->set_clip_state = vc5_set_clip_state; - pctx->set_sample_mask = vc5_set_sample_mask; - pctx->set_constant_buffer = vc5_set_constant_buffer; - pctx->set_framebuffer_state = vc5_set_framebuffer_state; - pctx->set_polygon_stipple = vc5_set_polygon_stipple; - pctx->set_scissor_states = vc5_set_scissor_states; - pctx->set_viewport_states = vc5_set_viewport_states; - - pctx->set_vertex_buffers = vc5_set_vertex_buffers; - - pctx->create_blend_state = vc5_create_blend_state; - pctx->bind_blend_state = vc5_blend_state_bind; - pctx->delete_blend_state = vc5_generic_cso_state_delete; - - pctx->create_rasterizer_state = vc5_create_rasterizer_state; - pctx->bind_rasterizer_state = vc5_rasterizer_state_bind; - pctx->delete_rasterizer_state = vc5_generic_cso_state_delete; - - pctx->create_depth_stencil_alpha_state = vc5_create_depth_stencil_alpha_state; - pctx->bind_depth_stencil_alpha_state = vc5_zsa_state_bind; - pctx->delete_depth_stencil_alpha_state = vc5_generic_cso_state_delete; - - pctx->create_vertex_elements_state = vc5_vertex_state_create; - pctx->delete_vertex_elements_state = vc5_generic_cso_state_delete; - pctx->bind_vertex_elements_state = vc5_vertex_state_bind; - - pctx->create_sampler_state = vc5_create_sampler_state; - pctx->delete_sampler_state = vc5_sampler_state_delete; - pctx->bind_sampler_states = vc5_sampler_states_bind; - - pctx->create_sampler_view = vc5_create_sampler_view; - pctx->sampler_view_destroy = vc5_sampler_view_destroy; - pctx->set_sampler_views = vc5_set_sampler_views; - - pctx->create_stream_output_target = vc5_create_stream_output_target; - pctx->stream_output_target_destroy = vc5_stream_output_target_destroy; - pctx->set_stream_output_targets = vc5_set_stream_output_targets; + pctx->set_blend_color = v3d_set_blend_color; + pctx->set_stencil_ref = v3d_set_stencil_ref; + pctx->set_clip_state = v3d_set_clip_state; + pctx->set_sample_mask = v3d_set_sample_mask; + pctx->set_constant_buffer = v3d_set_constant_buffer; + pctx->set_framebuffer_state = v3d_set_framebuffer_state; + pctx->set_polygon_stipple = v3d_set_polygon_stipple; + pctx->set_scissor_states = v3d_set_scissor_states; + pctx->set_viewport_states = v3d_set_viewport_states; + + pctx->set_vertex_buffers = v3d_set_vertex_buffers; + + pctx->create_blend_state = v3d_create_blend_state; + pctx->bind_blend_state = v3d_blend_state_bind; + pctx->delete_blend_state = v3d_generic_cso_state_delete; + + pctx->create_rasterizer_state = v3d_create_rasterizer_state; + pctx->bind_rasterizer_state = v3d_rasterizer_state_bind; + pctx->delete_rasterizer_state = v3d_generic_cso_state_delete; + + pctx->create_depth_stencil_alpha_state = v3d_create_depth_stencil_alpha_state; + pctx->bind_depth_stencil_alpha_state = v3d_zsa_state_bind; + pctx->delete_depth_stencil_alpha_state = v3d_generic_cso_state_delete; + + pctx->create_vertex_elements_state = v3d_vertex_state_create; + pctx->delete_vertex_elements_state = v3d_generic_cso_state_delete; + pctx->bind_vertex_elements_state = v3d_vertex_state_bind; + + pctx->create_sampler_state = v3d_create_sampler_state; + pctx->delete_sampler_state = v3d_sampler_state_delete; + pctx->bind_sampler_states = v3d_sampler_states_bind; + + pctx->create_sampler_view = v3d_create_sampler_view; + pctx->sampler_view_destroy = v3d_sampler_view_destroy; + pctx->set_sampler_views = v3d_set_sampler_views; + + pctx->create_stream_output_target = v3d_create_stream_output_target; + pctx->stream_output_target_destroy = v3d_stream_output_target_destroy; + pctx->set_stream_output_targets = v3d_set_stream_output_targets; } -- cgit v1.2.3