X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fgallium%2Fdrivers%2Ffreedreno%2Ffreedreno_resource.c;h=fb3d6b65635d87a77137af2d911ceccb83d1bfc9;hb=9e9a26c768b070d57f5f00abc982c548a5320a5e;hp=7108ed18776355031c776c5c15329c4f5c31d9b8;hpb=05f5122d4a60acd3890185b098757e3c152c5444;p=mesa.git diff --git a/src/gallium/drivers/freedreno/freedreno_resource.c b/src/gallium/drivers/freedreno/freedreno_resource.c index 7108ed18776..fb3d6b65635 100644 --- a/src/gallium/drivers/freedreno/freedreno_resource.c +++ b/src/gallium/drivers/freedreno/freedreno_resource.c @@ -24,9 +24,9 @@ * Rob Clark */ -#include "util/u_format.h" -#include "util/u_format_rgtc.h" -#include "util/u_format_zs.h" +#include "util/format/u_format.h" +#include "util/format/u_format_rgtc.h" +#include "util/format/u_format_zs.h" #include "util/u_inlines.h" #include "util/u_transfer.h" #include "util/u_string.h" @@ -50,6 +50,14 @@ /* XXX this should go away, needed for 'struct winsys_handle' */ #include "state_tracker/drm_driver.h" +/* A private modifier for now, so we have a way to request tiled but not + * compressed. It would perhaps be good to get real modifiers for the + * tiled formats, but would probably need to do some work to figure out + * the layout(s) of the tiled modes, and whether they are the same + * across generations. + */ +#define FD_FORMAT_MOD_QCOM_TILED fourcc_mod_code(QCOM, 0xffffffff) + /** * Go through the entire state and see if the resource is bound * anywhere. If it is, mark the relevant state as dirty. This is @@ -86,6 +94,15 @@ rebind_resource(struct fd_context *ctx, struct pipe_resource *prsc) ctx->dirty_shader[stage] |= FD_DIRTY_SHADER_TEX; } + /* Images */ + const unsigned num_images = util_last_bit(ctx->shaderimg[stage].enabled_mask); + for (unsigned i = 0; i < num_images; i++) { + if (ctx->dirty_shader[stage] & FD_DIRTY_SHADER_IMAGE) + break; + if (ctx->shaderimg[stage].si[i].resource == prsc) + ctx->dirty_shader[stage] |= FD_DIRTY_SHADER_IMAGE; + } + /* SSBOs */ const unsigned num_ssbos = util_last_bit(ctx->shaderbuf[stage].enabled_mask); for (unsigned i = 0; i < num_ssbos; i++) { @@ -136,9 +153,15 @@ do_blit(struct fd_context *ctx, const struct pipe_blit_info *blit, bool fallback } } +/** + * @rsc: the resource to shadow + * @level: the level to discard (if box != NULL, otherwise ignored) + * @box: the box to discard (or NULL if none) + * @modifier: the modifier for the new buffer state + */ static bool fd_try_shadow_resource(struct fd_context *ctx, struct fd_resource *rsc, - unsigned level, const struct pipe_box *box) + unsigned level, const struct pipe_box *box, uint64_t modifier) { struct pipe_context *pctx = &ctx->base; struct pipe_resource *prsc = &rsc->base; @@ -160,15 +183,16 @@ fd_try_shadow_resource(struct fd_context *ctx, struct fd_resource *rsc, if (prsc->target == PIPE_BUFFER) fallback = true; - bool whole_level = util_texrange_covers_whole_level(prsc, level, + bool discard_whole_level = box && util_texrange_covers_whole_level(prsc, level, box->x, box->y, box->z, box->width, box->height, box->depth); /* TODO need to be more clever about current level */ - if ((prsc->target >= PIPE_TEXTURE_2D) && !whole_level) + if ((prsc->target >= PIPE_TEXTURE_2D) && box && !discard_whole_level) return false; struct pipe_resource *pshadow = - pctx->screen->resource_create(pctx->screen, prsc); + pctx->screen->resource_create_with_modifiers(pctx->screen, + prsc, &modifier, 1); if (!pshadow) return false; @@ -199,6 +223,10 @@ fd_try_shadow_resource(struct fd_context *ctx, struct fd_resource *rsc, /* TODO valid_buffer_range?? */ swap(rsc->bo, shadow->bo); swap(rsc->write_batch, shadow->write_batch); + swap(rsc->offset, shadow->offset); + swap(rsc->ubwc_offset, shadow->ubwc_offset); + swap(rsc->ubwc_pitch, shadow->ubwc_pitch); + swap(rsc->ubwc_size, shadow->ubwc_size); rsc->seqno = p_atomic_inc_return(&ctx->screen->rsc_seqno); /* at this point, the newly created shadow buffer is not referenced @@ -231,7 +259,7 @@ fd_try_shadow_resource(struct fd_context *ctx, struct fd_resource *rsc, /* blit the other levels in their entirety: */ for (unsigned l = 0; l <= prsc->last_level; l++) { - if (l == level) + if (box && l == level) continue; /* just blit whole level: */ @@ -246,7 +274,7 @@ fd_try_shadow_resource(struct fd_context *ctx, struct fd_resource *rsc, /* deal w/ current level specially, since we might need to split * it up into a couple blits: */ - if (!whole_level) { + if (box && !discard_whole_level) { set_box(level, level); switch (prsc->target) { @@ -284,6 +312,34 @@ fd_try_shadow_resource(struct fd_context *ctx, struct fd_resource *rsc, return true; } +/** + * Uncompress an UBWC compressed buffer "in place". This works basically + * like resource shadowing, creating a new resource, and doing an uncompress + * blit, and swapping the state between shadow and original resource so it + * appears to the state tracker as if nothing changed. + */ +void +fd_resource_uncompress(struct fd_context *ctx, struct fd_resource *rsc) +{ + bool success = + fd_try_shadow_resource(ctx, rsc, 0, NULL, FD_FORMAT_MOD_QCOM_TILED); + + /* shadow should not fail in any cases where we need to uncompress: */ + debug_assert(success); + + /* + * TODO what if rsc is used in other contexts, we don't currently + * have a good way to rebind_resource() in other contexts. And an + * app that is reading one resource in multiple contexts, isn't + * going to expect that the resource is modified. + * + * Hopefully the edge cases where we need to uncompress are rare + * enough that they mostly only show up in deqp. + */ + + rebind_resource(ctx, &rsc->base); +} + static struct fd_resource * fd_alloc_staging(struct fd_context *ctx, struct fd_resource *rsc, unsigned level, const struct pipe_box *box) @@ -297,6 +353,8 @@ fd_alloc_staging(struct fd_context *ctx, struct fd_resource *rsc, * for 3d textures, it is the depth: */ if (tmpl.array_size > 1) { + if (tmpl.target == PIPE_TEXTURE_CUBE) + tmpl.target = PIPE_TEXTURE_2D_ARRAY; tmpl.array_size = box->depth; tmpl.depth0 = 1; } else { @@ -361,7 +419,7 @@ static void fd_resource_transfer_flush_region(struct pipe_context *pctx, struct fd_resource *rsc = fd_resource(ptrans->resource); if (ptrans->resource->target == PIPE_BUFFER) - util_range_add(&rsc->valid_buffer_range, + util_range_add(&rsc->base, &rsc->valid_buffer_range, ptrans->box.x + box->x, ptrans->box.x + box->x + box->width); } @@ -391,7 +449,7 @@ flush_resource(struct fd_context *ctx, struct fd_resource *rsc, unsigned usage) mtx_unlock(&ctx->screen->lock); foreach_batch(batch, &ctx->screen->batch_cache, batch_mask) - fd_batch_flush(batch, false, false); + fd_batch_flush(batch, false); foreach_batch(batch, &ctx->screen->batch_cache, batch_mask) { fd_batch_sync(batch); @@ -399,7 +457,7 @@ flush_resource(struct fd_context *ctx, struct fd_resource *rsc, unsigned usage) } assert(rsc->batch_mask == 0); } else if (write_batch) { - fd_batch_flush(write_batch, true, false); + fd_batch_flush(write_batch, true); } fd_batch_reference(&write_batch, NULL); @@ -431,7 +489,7 @@ fd_resource_transfer_unmap(struct pipe_context *pctx, fd_bo_cpu_fini(rsc->bo); } - util_range_add(&rsc->valid_buffer_range, + util_range_add(&rsc->base, &rsc->valid_buffer_range, ptrans->box.x, ptrans->box.x + ptrans->box.width); @@ -486,12 +544,14 @@ fd_resource_transfer_map(struct pipe_context *pctx, staging_rsc = fd_alloc_staging(ctx, rsc, level, box); if (staging_rsc) { + struct fd_resource_slice *staging_slice = + fd_resource_slice(staging_rsc, 0); // TODO for PIPE_TRANSFER_READ, need to do untiling blit.. trans->staging_prsc = &staging_rsc->base; trans->base.stride = util_format_get_nblocksx(format, - staging_rsc->slices[0].pitch) * staging_rsc->cpp; + staging_slice->pitch) * staging_rsc->cpp; trans->base.layer_stride = staging_rsc->layer_first ? - staging_rsc->layer_size : staging_rsc->slices[0].size0; + staging_rsc->layer_size : staging_slice->size0; trans->staging_box = *box; trans->staging_box.x = 0; trans->staging_box.y = 0; @@ -582,7 +642,8 @@ fd_resource_transfer_map(struct pipe_context *pctx, /* try shadowing only if it avoids a flush, otherwise staging would * be better: */ - if (needs_flush && fd_try_shadow_resource(ctx, rsc, level, box)) { + if (needs_flush && fd_try_shadow_resource(ctx, rsc, level, + box, DRM_FORMAT_MOD_LINEAR)) { needs_flush = busy = false; rebind_resource(ctx, prsc); ctx->stats.shadow_uploads++; @@ -601,11 +662,13 @@ fd_resource_transfer_map(struct pipe_context *pctx, */ staging_rsc = fd_alloc_staging(ctx, rsc, level, box); if (staging_rsc) { + struct fd_resource_slice *staging_slice = + fd_resource_slice(staging_rsc, 0); trans->staging_prsc = &staging_rsc->base; trans->base.stride = util_format_get_nblocksx(format, - staging_rsc->slices[0].pitch) * staging_rsc->cpp; + staging_slice->pitch) * staging_rsc->cpp; trans->base.layer_stride = staging_rsc->layer_first ? - staging_rsc->layer_size : staging_rsc->slices[0].size0; + staging_rsc->layer_size : staging_slice->size0; trans->staging_box = *box; trans->staging_box.x = 0; trans->staging_box.y = 0; @@ -681,11 +744,14 @@ fd_resource_modifier(struct fd_resource *rsc) if (!rsc->tile_mode) return DRM_FORMAT_MOD_LINEAR; + if (rsc->ubwc_size) + return DRM_FORMAT_MOD_QCOM_COMPRESSED; + /* TODO invent a modifier for tiled but not UBWC buffers: */ return DRM_FORMAT_MOD_INVALID; } -static boolean +static bool fd_resource_get_handle(struct pipe_screen *pscreen, struct pipe_context *pctx, struct pipe_resource *prsc, @@ -697,7 +763,7 @@ fd_resource_get_handle(struct pipe_screen *pscreen, handle->modifier = fd_resource_modifier(rsc); return fd_screen_bo_get_handle(pscreen, rsc->bo, rsc->scanout, - rsc->slices[0].pitch * rsc->cpp, handle); + fd_resource_slice(rsc, 0)->pitch * rsc->cpp, handle); } static uint32_t @@ -735,12 +801,12 @@ setup_slices(struct fd_resource *rsc, uint32_t alignment, enum pipe_format forma */ if (prsc->target == PIPE_TEXTURE_3D && ( level == 1 || - (level > 1 && rsc->slices[level - 1].size0 > 0xf000))) + (level > 1 && fd_resource_slice(rsc, level - 1)->size0 > 0xf000))) slice->size0 = align(blocks * rsc->cpp, alignment); else if (level == 0 || rsc->layer_first || alignment == 1) slice->size0 = align(blocks * rsc->cpp, alignment); else - slice->size0 = rsc->slices[level - 1].size0; + slice->size0 = fd_resource_slice(rsc, level - 1)->size0; size += slice->size0 * depth * layers_in_level; @@ -856,6 +922,9 @@ fd_resource_create_with_modifiers(struct pipe_screen *pscreen, struct renderonly_scanout *scanout; struct winsys_handle handle; + /* apply freedreno alignment requirement */ + scanout_templat.width0 = align(tmpl->width0, screen->gmem_alignw); + scanout = renderonly_scanout_for_resource(&scanout_templat, screen->ro, &handle); if (!scanout) @@ -910,31 +979,18 @@ fd_resource_create_with_modifiers(struct pipe_screen *pscreen, if (tmpl->bind & PIPE_BIND_SHARED) allow_ubwc = drm_find_modifier(DRM_FORMAT_MOD_QCOM_COMPRESSED, modifiers, count); - /* TODO turn on UBWC for all internal buffers - * - * There are still some regressions in deqp with UBWC enabled. I - * think it is mostly related to sampler/image views using a format - * that doesn't support compression with a resource created with - * a format that does. We need to track the compression state of - * a buffer and do an (in-place, hopefully?) resolve if it is re- - * interpreted with a format that does not support compression. - * - * It is possible (likely?) that we can't do atomic ops on a - * compressed buffer as well, so this would also require transition - * to a compressed state. - */ - allow_ubwc &= !!(fd_mesa_debug & FD_DBG_UBWC); + allow_ubwc &= !(fd_mesa_debug & FD_DBG_NOUBWC); + + pipe_reference_init(&prsc->reference, 1); + + prsc->screen = pscreen; if (screen->tile_mode && (tmpl->target != PIPE_BUFFER) && !linear) { - rsc->tile_mode = screen->tile_mode(tmpl); + rsc->tile_mode = screen->tile_mode(prsc); } - pipe_reference_init(&prsc->reference, 1); - - prsc->screen = pscreen; - util_range_init(&rsc->valid_buffer_range); rsc->internal_format = format; @@ -1038,7 +1094,7 @@ fd_resource_from_handle(struct pipe_screen *pscreen, { struct fd_screen *screen = fd_screen(pscreen); struct fd_resource *rsc = CALLOC_STRUCT(fd_resource); - struct fd_resource_slice *slice = &rsc->slices[0]; + struct fd_resource_slice *slice = fd_resource_slice(rsc, 0); struct pipe_resource *prsc = &rsc->base; uint32_t pitchalign = fd_screen(pscreen)->gmem_alignw; @@ -1078,7 +1134,7 @@ fd_resource_from_handle(struct pipe_screen *pscreen, if (handle->modifier == DRM_FORMAT_MOD_QCOM_COMPRESSED) { if (!is_supported_modifier(pscreen, tmpl->format, DRM_FORMAT_MOD_QCOM_COMPRESSED)) { - DBG("bad modifier: %llx", handle->modifier); + DBG("bad modifier: %"PRIx64, handle->modifier); goto fail; } debug_assert(screen->fill_ubwc_buffer_sizes);