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_translate.h"
  36 #include "util/u_inlines.h"
  37 #include "util/u_memory.h"
  38
  39 static void *
  40 etna_create_sampler_state(struct pipe_context *pipe,
  41                           const struct pipe_sampler_state *ss)
  42 {
  43    struct etna_sampler_state *cs = CALLOC_STRUCT(etna_sampler_state);
  44
  45    if (!cs)
  46       return NULL;
  47
  48    cs->TE_SAMPLER_CONFIG0 =
  49       VIVS_TE_SAMPLER_CONFIG0_UWRAP(translate_texture_wrapmode(ss->wrap_s)) |
  50       VIVS_TE_SAMPLER_CONFIG0_VWRAP(translate_texture_wrapmode(ss->wrap_t)) |
  51       VIVS_TE_SAMPLER_CONFIG0_MIN(translate_texture_filter(ss->min_img_filter)) |
  52       VIVS_TE_SAMPLER_CONFIG0_MIP(translate_texture_mipfilter(ss->min_mip_filter)) |
  53       VIVS_TE_SAMPLER_CONFIG0_MAG(translate_texture_filter(ss->mag_img_filter)) |
  54       COND(ss->normalized_coords, VIVS_TE_SAMPLER_CONFIG0_ROUND_UV);
  55    cs->TE_SAMPLER_CONFIG1 = 0; /* VIVS_TE_SAMPLER_CONFIG1 (swizzle, extended
  56                                   format) fully determined by sampler view */
  57    cs->TE_SAMPLER_LOD_CONFIG =
  58       COND(ss->lod_bias != 0.0, VIVS_TE_SAMPLER_LOD_CONFIG_BIAS_ENABLE) |
  59       VIVS_TE_SAMPLER_LOD_CONFIG_BIAS(etna_float_to_fixp55(ss->lod_bias));
  60
  61    if (ss->min_mip_filter != PIPE_TEX_MIPFILTER_NONE) {
  62       cs->min_lod = etna_float_to_fixp55(ss->min_lod);
  63       cs->max_lod = etna_float_to_fixp55(ss->max_lod);
  64    } else {
  65       /* when not mipmapping, we need to set max/min lod so that always
  66        * lowest LOD is selected */
  67       cs->min_lod = cs->max_lod = etna_float_to_fixp55(ss->min_lod);
  68    }
  69
  70    return cs;
  71 }
  72
  73 static void
  74 etna_bind_sampler_states(struct pipe_context *pctx, enum pipe_shader_type shader,
  75                          unsigned start_slot, unsigned num_samplers,
  76                          void **samplers)
  77 {
  78    /* bind fragment sampler */
  79    struct etna_context *ctx = etna_context(pctx);
  80    int offset;
  81
  82    switch (shader) {
  83    case PIPE_SHADER_FRAGMENT:
  84       offset = 0;
  85       ctx->num_fragment_samplers = num_samplers;
  86       break;
  87    case PIPE_SHADER_VERTEX:
  88       offset = ctx->specs.vertex_sampler_offset;
  89       break;
  90    default:
  91       assert(!"Invalid shader");
  92       return;
  93    }
  94
  95    uint32_t mask = 1 << offset;
  96    for (int idx = 0; idx < num_samplers; ++idx, mask <<= 1) {
  97       ctx->sampler[offset + idx] = samplers[idx];
  98       if (samplers[idx])
  99          ctx->active_samplers |= mask;
 100       else
 101          ctx->active_samplers &= ~mask;
 102    }
 103
 104    ctx->dirty |= ETNA_DIRTY_SAMPLERS;
 105 }
 106
 107 static void
 108 etna_delete_sampler_state(struct pipe_context *pctx, void *ss)
 109 {
 110    FREE(ss);
 111 }
 112
 113 static void
 114 etna_update_sampler_source(struct pipe_sampler_view *view)
 115 {
 116    struct etna_resource *res = etna_resource(view->texture);
 117
 118    if (res->texture && etna_resource_older(etna_resource(res->texture), res)) {
 119       /* Texture is older than render buffer, copy the texture using RS */
 120       etna_copy_resource(view->context, res->texture, view->texture, 0,
 121                          view->texture->last_level);
 122       etna_resource(res->texture)->seqno = res->seqno;
 123    }
 124 }
 125
 126 static bool
 127 etna_resource_sampler_compatible(struct etna_resource *res)
 128 {
 129    if (util_format_is_compressed(res->base.format))
 130       return true;
 131
 132    struct etna_screen *screen = etna_screen(res->base.screen);
 133    /* This GPU supports texturing from supertiled textures? */
 134    if (res->layout == ETNA_LAYOUT_SUPER_TILED && VIV_FEATURE(screen, chipMinorFeatures2, SUPERTILED_TEXTURE))
 135       return true;
 136
 137    /* TODO: LINEAR_TEXTURE_SUPPORT */
 138
 139    /* Otherwise, only support tiled layouts */
 140    if (res->layout != ETNA_LAYOUT_TILED)
 141       return false;
 142
 143    /* If we have HALIGN support, we can allow for the RS padding */
 144    if (VIV_FEATURE(screen, chipMinorFeatures1, TEXTURE_HALIGN))
 145       return true;
 146
 147    /* Non-HALIGN GPUs only accept 4x4 tile-aligned textures */
 148    if (res->halign != TEXTURE_HALIGN_FOUR)
 149       return false;
 150
 151    return true;
 152 }
 153
 154 static struct pipe_sampler_view *
 155 etna_create_sampler_view(struct pipe_context *pctx, struct pipe_resource *prsc,
 156                          const struct pipe_sampler_view *so)
 157 {
 158    struct etna_sampler_view *sv = CALLOC_STRUCT(etna_sampler_view);
 159    struct etna_resource *res = etna_resource(prsc);
 160    struct etna_context *ctx = etna_context(pctx);
 161
 162    if (!sv)
 163       return NULL;
 164
 165    if (!etna_resource_sampler_compatible(res)) {
 166       /* The original resource is not compatible with the sampler.
 167        * Allocate an appropriately tiled texture. */
 168       if (!res->texture) {
 169          struct pipe_resource templat = *prsc;
 170
 171          templat.bind &= ~(PIPE_BIND_DEPTH_STENCIL | PIPE_BIND_RENDER_TARGET |
 172                            PIPE_BIND_BLENDABLE);
 173          res->texture =
 174             etna_resource_alloc(pctx->screen, ETNA_LAYOUT_TILED, &templat);
 175       }
 176
 177       if (!res->texture) {
 178          free(sv);
 179          return NULL;
 180       }
 181       res = etna_resource(res->texture);
 182    }
 183
 184    sv->base = *so;
 185    pipe_reference(NULL, &prsc->reference);
 186    sv->base.texture = prsc;
 187    sv->base.reference.count = 1;
 188    sv->base.context = pctx;
 189
 190    /* merged with sampler state */
 191    sv->TE_SAMPLER_CONFIG0 =
 192       VIVS_TE_SAMPLER_CONFIG0_FORMAT(translate_texture_format(sv->base.format));
 193    sv->TE_SAMPLER_CONFIG0_MASK = 0xffffffff;
 194
 195    switch (sv->base.target) {
 196    case PIPE_TEXTURE_1D:
 197       /* For 1D textures, we will have a height of 1, so we can use 2D
 198        * but set T wrap to repeat */
 199       sv->TE_SAMPLER_CONFIG0_MASK = ~VIVS_TE_SAMPLER_CONFIG0_VWRAP__MASK;
 200       sv->TE_SAMPLER_CONFIG0 |= VIVS_TE_SAMPLER_CONFIG0_VWRAP(TEXTURE_WRAPMODE_REPEAT);
 201       /* fallthrough */
 202    case PIPE_TEXTURE_2D:
 203    case PIPE_TEXTURE_RECT:
 204       sv->TE_SAMPLER_CONFIG0 |= VIVS_TE_SAMPLER_CONFIG0_TYPE(TEXTURE_TYPE_2D);
 205       break;
 206    case PIPE_TEXTURE_CUBE:
 207       sv->TE_SAMPLER_CONFIG0 |= VIVS_TE_SAMPLER_CONFIG0_TYPE(TEXTURE_TYPE_CUBE_MAP);
 208       break;
 209    default:
 210       BUG("Unhandled texture target");
 211       free(sv);
 212       return NULL;
 213    }
 214
 215    sv->TE_SAMPLER_CONFIG1 = VIVS_TE_SAMPLER_CONFIG1_SWIZZLE_R(so->swizzle_r) |
 216                             VIVS_TE_SAMPLER_CONFIG1_SWIZZLE_G(so->swizzle_g) |
 217                             VIVS_TE_SAMPLER_CONFIG1_SWIZZLE_B(so->swizzle_b) |
 218                             VIVS_TE_SAMPLER_CONFIG1_SWIZZLE_A(so->swizzle_a) |
 219                             VIVS_TE_SAMPLER_CONFIG1_HALIGN(res->halign);
 220    sv->TE_SAMPLER_SIZE = VIVS_TE_SAMPLER_SIZE_WIDTH(res->base.width0) |
 221                          VIVS_TE_SAMPLER_SIZE_HEIGHT(res->base.height0);
 222    sv->TE_SAMPLER_LOG_SIZE =
 223       VIVS_TE_SAMPLER_LOG_SIZE_WIDTH(etna_log2_fixp55(res->base.width0)) |
 224       VIVS_TE_SAMPLER_LOG_SIZE_HEIGHT(etna_log2_fixp55(res->base.height0));
 225
 226    /* Set up levels-of-detail */
 227    for (int lod = 0; lod <= res->base.last_level; ++lod) {
 228       sv->TE_SAMPLER_LOD_ADDR[lod].bo = res->bo;
 229       sv->TE_SAMPLER_LOD_ADDR[lod].offset = res->levels[lod].offset;
 230       sv->TE_SAMPLER_LOD_ADDR[lod].flags = ETNA_RELOC_READ;
 231    }
 232    sv->min_lod = sv->base.u.tex.first_level << 5;
 233    sv->max_lod = MIN2(sv->base.u.tex.last_level, res->base.last_level) << 5;
 234
 235    /* Workaround for npot textures -- it appears that only CLAMP_TO_EDGE is
 236     * supported when the appropriate capability is not set. */
 237    if (!ctx->specs.npot_tex_any_wrap &&
 238        (!util_is_power_of_two(res->base.width0) || !util_is_power_of_two(res->base.height0))) {
 239       sv->TE_SAMPLER_CONFIG0_MASK = ~(VIVS_TE_SAMPLER_CONFIG0_UWRAP__MASK |
 240                                       VIVS_TE_SAMPLER_CONFIG0_VWRAP__MASK);
 241       sv->TE_SAMPLER_CONFIG0 |=
 242          VIVS_TE_SAMPLER_CONFIG0_UWRAP(TEXTURE_WRAPMODE_CLAMP_TO_EDGE) |
 243          VIVS_TE_SAMPLER_CONFIG0_VWRAP(TEXTURE_WRAPMODE_CLAMP_TO_EDGE);
 244    }
 245
 246    return &sv->base;
 247 }
 248
 249 static void
 250 etna_sampler_view_destroy(struct pipe_context *pctx,
 251                           struct pipe_sampler_view *view)
 252 {
 253    pipe_resource_reference(&view->texture, NULL);
 254    FREE(view);
 255 }
 256
 257 static void
 258 set_sampler_views(struct etna_context *ctx, unsigned start, unsigned end,
 259                   unsigned nr, struct pipe_sampler_view **views)
 260 {
 261    unsigned i, j;
 262    uint32_t mask = 1 << start;
 263
 264    for (i = start, j = 0; j < nr; i++, j++, mask <<= 1) {
 265       pipe_sampler_view_reference(&ctx->sampler_view[i], views[j]);
 266       if (views[j])
 267          ctx->active_sampler_views |= mask;
 268       else
 269          ctx->active_sampler_views &= ~mask;
 270    }
 271
 272    for (; i < end; i++, mask <<= 1) {
 273       pipe_sampler_view_reference(&ctx->sampler_view[i], NULL);
 274       ctx->active_sampler_views &= ~mask;
 275    }
 276 }
 277
 278 static inline void
 279 etna_fragtex_set_sampler_views(struct etna_context *ctx, unsigned nr,
 280                                struct pipe_sampler_view **views)
 281 {
 282    unsigned start = 0;
 283    unsigned end = start + ctx->specs.fragment_sampler_count;
 284
 285    set_sampler_views(ctx, start, end, nr, views);
 286    ctx->num_fragment_sampler_views = nr;
 287 }
 288
 289
 290 static inline void
 291 etna_vertex_set_sampler_views(struct etna_context *ctx, unsigned nr,
 292                               struct pipe_sampler_view **views)
 293 {
 294    unsigned start = ctx->specs.vertex_sampler_offset;
 295    unsigned end = start + ctx->specs.vertex_sampler_count;
 296
 297    set_sampler_views(ctx, start, end, nr, views);
 298 }
 299
 300 static void
 301 etna_set_sampler_views(struct pipe_context *pctx, enum pipe_shader_type shader,
 302                        unsigned start_slot, unsigned num_views,
 303                        struct pipe_sampler_view **views)
 304 {
 305    struct etna_context *ctx = etna_context(pctx);
 306    assert(start_slot == 0);
 307
 308    ctx->dirty |= ETNA_DIRTY_SAMPLER_VIEWS | ETNA_DIRTY_TEXTURE_CACHES;
 309
 310    for (unsigned idx = 0; idx < num_views; ++idx) {
 311       if (views[idx])
 312          etna_update_sampler_source(views[idx]);
 313    }
 314
 315    switch (shader) {
 316    case PIPE_SHADER_FRAGMENT:
 317       etna_fragtex_set_sampler_views(ctx, num_views, views);
 318       break;
 319    case PIPE_SHADER_VERTEX:
 320       etna_vertex_set_sampler_views(ctx, num_views, views);
 321       break;
 322    default:;
 323    }
 324 }
 325
 326 static void
 327 etna_texture_barrier(struct pipe_context *pctx, unsigned flags)
 328 {
 329    struct etna_context *ctx = etna_context(pctx);
 330    /* clear color and texture cache to make sure that texture unit reads
 331     * what has been written */
 332    etna_set_state(ctx->stream, VIVS_GL_FLUSH_CACHE, VIVS_GL_FLUSH_CACHE_COLOR | VIVS_GL_FLUSH_CACHE_TEXTURE);
 333 }
 334
 335 void
 336 etna_texture_init(struct pipe_context *pctx)
 337 {
 338    pctx->create_sampler_state = etna_create_sampler_state;
 339    pctx->bind_sampler_states = etna_bind_sampler_states;
 340    pctx->delete_sampler_state = etna_delete_sampler_state;
 341    pctx->set_sampler_views = etna_set_sampler_views;
 342    pctx->create_sampler_view = etna_create_sampler_view;
 343    pctx->sampler_view_destroy = etna_sampler_view_destroy;
 344    pctx->texture_barrier = etna_texture_barrier;
 345 }