src/gallium/drivers/etnaviv/etnaviv_texture.c

   1 /*
   2  * Copyright (c) 2012-2015 Etnaviv Project
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sub license,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the
  12  * next paragraph) shall be included in all copies or substantial portions
  13  * of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  21  * DEALINGS IN THE SOFTWARE.
  22  *
  23  * Authors:
  24  *    Wladimir J. van der Laan <laanwj@gmail.com>
  25  */
  26
  27 #include "etnaviv_texture.h"
  28
  29 #include "hw/common.xml.h"
  30
  31 #include "etnaviv_clear_blit.h"
  32 #include "etnaviv_context.h"
  33 #include "etnaviv_emit.h"
  34 #include "etnaviv_format.h"
  35 #include "etnaviv_texture_state.h"
  36 #include "etnaviv_translate.h"
  37 #include "util/u_inlines.h"
  38 #include "util/u_memory.h"
  39
  40 #include <drm_fourcc.h>
  41
  42 static void
  43 etna_bind_sampler_states(struct pipe_context *pctx, enum pipe_shader_type shader,
  44                          unsigned start_slot, unsigned num_samplers,
  45                          void **samplers)
  46 {
  47    /* bind fragment sampler */
  48    struct etna_context *ctx = etna_context(pctx);
  49    int offset;
  50
  51    switch (shader) {
  52    case PIPE_SHADER_FRAGMENT:
  53       offset = 0;
  54       ctx->num_fragment_samplers = num_samplers;
  55       break;
  56    case PIPE_SHADER_VERTEX:
  57       offset = ctx->specs.vertex_sampler_offset;
  58       break;
  59    default:
  60       assert(!"Invalid shader");
  61       return;
  62    }
  63
  64    uint32_t mask = 1 << offset;
  65    for (int idx = 0; idx < num_samplers; ++idx, mask <<= 1) {
  66       ctx->sampler[offset + idx] = samplers[idx];
  67       if (samplers[idx])
  68          ctx->active_samplers |= mask;
  69       else
  70          ctx->active_samplers &= ~mask;
  71    }
  72
  73    ctx->dirty |= ETNA_DIRTY_SAMPLERS;
  74 }
  75
  76 static void
  77 etna_configure_sampler_ts(struct etna_sampler_ts *sts, struct pipe_sampler_view *pview, bool enable)
  78 {
  79    assert(sts);
  80    sts->enable = enable;
  81    if (enable) {
  82       struct etna_resource *rsc = etna_resource(pview->texture);
  83       struct etna_resource_level *lev = &rsc->levels[0];
  84       assert(rsc->ts_bo && lev->ts_valid);
  85
  86       sts->TS_SAMPLER_CONFIG =
  87          VIVS_TS_SAMPLER_CONFIG_ENABLE(1) |
  88          VIVS_TS_SAMPLER_CONFIG_FORMAT(translate_ts_sampler_format(rsc->base.format));
  89       sts->TS_SAMPLER_CLEAR_VALUE = lev->clear_value;
  90       sts->TS_SAMPLER_CLEAR_VALUE2 = lev->clear_value; /* To handle 64-bit formats this needs a different value */
  91       sts->TS_SAMPLER_STATUS_BASE.bo = rsc->ts_bo;
  92       sts->TS_SAMPLER_STATUS_BASE.offset = lev->ts_offset;
  93       sts->TS_SAMPLER_STATUS_BASE.flags = ETNA_RELOC_READ;
  94    } else {
  95       sts->TS_SAMPLER_CONFIG = 0;
  96       sts->TS_SAMPLER_STATUS_BASE.bo = NULL;
  97    }
  98    /* n.b.: relies on caller to mark ETNA_DIRTY_SAMPLER_VIEWS */
  99 }
 100
 101 /* Return true if the GPU can use sampler TS with this sampler view.
 102  * Sampler TS is an optimization used when rendering to textures, where
 103  * a resolve-in-place can be avoided when rendering has left a (valid) TS.
 104  */
 105 static bool
 106 etna_can_use_sampler_ts(struct pipe_sampler_view *view, int num)
 107 {
 108     /* Can use sampler TS when:
 109      * - the hardware supports sampler TS.
 110      * - the sampler view will be bound to sampler <VIVS_TS_SAMPLER__LEN.
 111      *   HALTI5 adds a mapping from sampler to sampler TS unit, but this is AFAIK
 112      *   absent on earlier models.
 113      * - it is a texture, not a buffer.
 114      * - the sampler view has a supported format for sampler TS.
 115      * - the sampler will have one LOD, and it happens to be level 0.
 116      *   (it is not sure if the hw supports it for other levels, but available
 117      *   state strongly suggests only one at a time).
 118      * - the resource TS is valid for level 0.
 119      */
 120    struct etna_resource *rsc = etna_resource(view->texture);
 121    struct etna_screen *screen = etna_screen(rsc->base.screen);
 122    return VIV_FEATURE(screen, chipMinorFeatures2, TEXTURE_TILED_READ) &&
 123       num < VIVS_TS_SAMPLER__LEN &&
 124       rsc->base.target != PIPE_BUFFER &&
 125       translate_ts_sampler_format(rsc->base.format) != ETNA_NO_MATCH &&
 126       view->u.tex.first_level == 0 && MIN2(view->u.tex.last_level, rsc->base.last_level) == 0 &&
 127       rsc->levels[0].ts_valid;
 128 }
 129
 130 static void
 131 etna_update_sampler_source(struct pipe_sampler_view *view, int num)
 132 {
 133    struct etna_resource *base = etna_resource(view->texture);
 134    struct etna_resource *to = base, *from = base;
 135    struct etna_context *ctx = etna_context(view->context);
 136    bool enable_sampler_ts = false;
 137
 138    if (base->external && etna_resource_newer(etna_resource(base->external), base))
 139       from = etna_resource(base->external);
 140
 141    if (base->texture)
 142       to = etna_resource(base->texture);
 143
 144    if ((to != from) && etna_resource_older(to, from)) {
 145       etna_copy_resource(view->context, &to->base, &from->base, 0,
 146                          view->texture->last_level);
 147       to->seqno = from->seqno;
 148    } else if ((to == from) && etna_resource_needs_flush(to)) {
 149       if (ctx->ts_for_sampler_view && etna_can_use_sampler_ts(view, num)) {
 150          enable_sampler_ts = true;
 151          /* Do not set flush_seqno because the resolve-to-self was bypassed */
 152       } else {
 153          /* Resolve TS if needed */
 154          etna_copy_resource(view->context, &to->base, &from->base, 0,
 155                             view->texture->last_level);
 156          to->flush_seqno = from->seqno;
 157       }
 158    }
 159    if (ctx->ts_for_sampler_view) {
 160       etna_configure_sampler_ts(ctx->ts_for_sampler_view(view), view, enable_sampler_ts);
 161    }
 162 }
 163
 164 static bool
 165 etna_resource_sampler_compatible(struct etna_resource *res)
 166 {
 167    if (util_format_is_compressed(res->base.format))
 168       return true;
 169
 170    struct etna_screen *screen = etna_screen(res->base.screen);
 171    /* This GPU supports texturing from supertiled textures? */
 172    if (res->layout == ETNA_LAYOUT_SUPER_TILED && VIV_FEATURE(screen, chipMinorFeatures2, SUPERTILED_TEXTURE))
 173       return true;
 174
 175    /* This GPU supports texturing from linear textures? */
 176    if (res->layout == ETNA_LAYOUT_LINEAR && VIV_FEATURE(screen, chipMinorFeatures1, LINEAR_TEXTURE_SUPPORT))
 177       return true;
 178
 179    /* Otherwise, only support tiled layouts */
 180    if (res->layout != ETNA_LAYOUT_TILED)
 181       return false;
 182
 183    /* If we have HALIGN support, we can allow for the RS padding */
 184    if (VIV_FEATURE(screen, chipMinorFeatures1, TEXTURE_HALIGN))
 185       return true;
 186
 187    /* Non-HALIGN GPUs only accept 4x4 tile-aligned textures */
 188    if (res->halign != TEXTURE_HALIGN_FOUR)
 189       return false;
 190
 191    return true;
 192 }
 193
 194 struct etna_resource *
 195 etna_texture_handle_incompatible(struct pipe_context *pctx, struct pipe_resource *prsc)
 196 {
 197    struct etna_resource *res = etna_resource(prsc);
 198    if (!etna_resource_sampler_compatible(res)) {
 199       /* The original resource is not compatible with the sampler.
 200        * Allocate an appropriately tiled texture. */
 201       if (!res->texture) {
 202          struct pipe_resource templat = *prsc;
 203
 204          templat.bind &= ~(PIPE_BIND_DEPTH_STENCIL | PIPE_BIND_RENDER_TARGET |
 205                            PIPE_BIND_BLENDABLE);
 206          res->texture =
 207             etna_resource_alloc(pctx->screen, ETNA_LAYOUT_TILED,
 208                                 ETNA_ADDRESSING_MODE_TILED,
 209                                 DRM_FORMAT_MOD_LINEAR, &templat);
 210       }
 211
 212       if (!res->texture) {
 213          return NULL;
 214       }
 215       res = etna_resource(res->texture);
 216    }
 217    return res;
 218 }
 219
 220 static void
 221 set_sampler_views(struct etna_context *ctx, unsigned start, unsigned end,
 222                   unsigned nr, struct pipe_sampler_view **views)
 223 {
 224    unsigned i, j;
 225    uint32_t mask = 1 << start;
 226    uint32_t prev_active_sampler_views = ctx->active_sampler_views;
 227
 228    for (i = start, j = 0; j < nr; i++, j++, mask <<= 1) {
 229       pipe_sampler_view_reference(&ctx->sampler_view[i], views[j]);
 230       if (views[j]) {
 231          ctx->active_sampler_views |= mask;
 232          ctx->dirty_sampler_views |= mask;
 233       } else
 234          ctx->active_sampler_views &= ~mask;
 235    }
 236
 237    for (; i < end; i++, mask <<= 1) {
 238       pipe_sampler_view_reference(&ctx->sampler_view[i], NULL);
 239       ctx->active_sampler_views &= ~mask;
 240    }
 241
 242    /* sampler views that changed state (even to inactive) are also dirty */
 243    ctx->dirty_sampler_views |= ctx->active_sampler_views ^ prev_active_sampler_views;
 244 }
 245
 246 static inline void
 247 etna_fragtex_set_sampler_views(struct etna_context *ctx, unsigned nr,
 248                                struct pipe_sampler_view **views)
 249 {
 250    unsigned start = 0;
 251    unsigned end = start + ctx->specs.fragment_sampler_count;
 252
 253    set_sampler_views(ctx, start, end, nr, views);
 254    ctx->num_fragment_sampler_views = nr;
 255 }
 256
 257
 258 static inline void
 259 etna_vertex_set_sampler_views(struct etna_context *ctx, unsigned nr,
 260                               struct pipe_sampler_view **views)
 261 {
 262    unsigned start = ctx->specs.vertex_sampler_offset;
 263    unsigned end = start + ctx->specs.vertex_sampler_count;
 264
 265    set_sampler_views(ctx, start, end, nr, views);
 266 }
 267
 268 static void
 269 etna_set_sampler_views(struct pipe_context *pctx, enum pipe_shader_type shader,
 270                        unsigned start_slot, unsigned num_views,
 271                        struct pipe_sampler_view **views)
 272 {
 273    struct etna_context *ctx = etna_context(pctx);
 274    assert(start_slot == 0);
 275
 276    ctx->dirty |= ETNA_DIRTY_SAMPLER_VIEWS | ETNA_DIRTY_TEXTURE_CACHES;
 277
 278    for (unsigned idx = 0; idx < num_views; ++idx) {
 279       if (views[idx])
 280          etna_update_sampler_source(views[idx], idx);
 281    }
 282
 283    switch (shader) {
 284    case PIPE_SHADER_FRAGMENT:
 285       etna_fragtex_set_sampler_views(ctx, num_views, views);
 286       break;
 287    case PIPE_SHADER_VERTEX:
 288       etna_vertex_set_sampler_views(ctx, num_views, views);
 289       break;
 290    default:;
 291    }
 292 }
 293
 294 static void
 295 etna_texture_barrier(struct pipe_context *pctx, unsigned flags)
 296 {
 297    struct etna_context *ctx = etna_context(pctx);
 298    /* clear color and texture cache to make sure that texture unit reads
 299     * what has been written */
 300    etna_set_state(ctx->stream, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR | VIVS_GL_FLUSH_CACHE_TEXTURE);
 301 }
 302
 303 uint32_t
 304 active_samplers_bits(struct etna_context *ctx)
 305 {
 306    return ctx->active_sampler_views & ctx->active_samplers;
 307 }
 308
 309 void
 310 etna_texture_init(struct pipe_context *pctx)
 311 {
 312    pctx->bind_sampler_states = etna_bind_sampler_states;
 313    pctx->set_sampler_views = etna_set_sampler_views;
 314    pctx->texture_barrier = etna_texture_barrier;
 315    etna_texture_state_init(pctx);
 316 }