src/gallium/drivers/etnaviv/etnaviv_context.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  *    Christian Gmeiner <christian.gmeiner@gmail.com>
  26  */
  27
  28 #include "etnaviv_context.h"
  29
  30 #include "etnaviv_blend.h"
  31 #include "etnaviv_clear_blit.h"
  32 #include "etnaviv_compiler.h"
  33 #include "etnaviv_debug.h"
  34 #include "etnaviv_emit.h"
  35 #include "etnaviv_fence.h"
  36 #include "etnaviv_query.h"
  37 #include "etnaviv_rasterizer.h"
  38 #include "etnaviv_screen.h"
  39 #include "etnaviv_shader.h"
  40 #include "etnaviv_state.h"
  41 #include "etnaviv_surface.h"
  42 #include "etnaviv_texture.h"
  43 #include "etnaviv_transfer.h"
  44 #include "etnaviv_translate.h"
  45 #include "etnaviv_zsa.h"
  46
  47 #include "pipe/p_context.h"
  48 #include "pipe/p_state.h"
  49 #include "util/u_blitter.h"
  50 #include "util/u_helpers.h"
  51 #include "util/u_memory.h"
  52 #include "util/u_prim.h"
  53 #include "util/u_upload_mgr.h"
  54
  55 #include "hw/common.xml.h"
  56
  57 static void
  58 etna_context_destroy(struct pipe_context *pctx)
  59 {
  60    struct etna_context *ctx = etna_context(pctx);
  61
  62    if (ctx->primconvert)
  63       util_primconvert_destroy(ctx->primconvert);
  64
  65    if (ctx->blitter)
  66       util_blitter_destroy(ctx->blitter);
  67
  68    if (pctx->stream_uploader)
  69       u_upload_destroy(pctx->stream_uploader);
  70
  71    if (ctx->stream)
  72       etna_cmd_stream_del(ctx->stream);
  73
  74    slab_destroy_child(&ctx->transfer_pool);
  75
  76    if (ctx->in_fence_fd != -1)
  77       close(ctx->in_fence_fd);
  78
  79    FREE(pctx);
  80 }
  81
  82 /* Update render state where needed based on draw operation */
  83 static void
  84 etna_update_state_for_draw(struct etna_context *ctx, const struct pipe_draw_info *info)
  85 {
  86    /* Handle primitive restart:
  87     * - If not an indexed draw, we don't care about the state of the primitive restart bit.
  88     * - Otherwise, set the bit in INDEX_STREAM_CONTROL in the index buffer state
  89     *   accordingly
  90     * - If the value of the INDEX_STREAM_CONTROL register changed due to this, or
  91     *   primitive restart is enabled and the restart index changed, mark the index
  92     *   buffer state as dirty
  93     */
  94
  95    if (info->index_size) {
  96       uint32_t new_control = ctx->index_buffer.FE_INDEX_STREAM_CONTROL;
  97
  98       if (info->primitive_restart)
  99          new_control |= VIVS_FE_INDEX_STREAM_CONTROL_PRIMITIVE_RESTART;
 100       else
 101          new_control &= ~VIVS_FE_INDEX_STREAM_CONTROL_PRIMITIVE_RESTART;
 102
 103       if (ctx->index_buffer.FE_INDEX_STREAM_CONTROL != new_control ||
 104           (info->primitive_restart && ctx->index_buffer.FE_PRIMITIVE_RESTART_INDEX != info->restart_index)) {
 105          ctx->index_buffer.FE_INDEX_STREAM_CONTROL = new_control;
 106          ctx->index_buffer.FE_PRIMITIVE_RESTART_INDEX = info->restart_index;
 107          ctx->dirty |= ETNA_DIRTY_INDEX_BUFFER;
 108       }
 109    }
 110 }
 111
 112 static bool
 113 etna_get_vs(struct etna_context *ctx, struct etna_shader_key key)
 114 {
 115    const struct etna_shader_variant *old = ctx->shader.vs;
 116
 117    ctx->shader.vs = etna_shader_variant(ctx->shader.bind_vs, key, &ctx->debug);
 118
 119    if (!ctx->shader.vs)
 120       return false;
 121
 122    if (old != ctx->shader.vs)
 123       ctx->dirty |= ETNA_DIRTY_SHADER;
 124
 125    return true;
 126 }
 127
 128 static bool
 129 etna_get_fs(struct etna_context *ctx, struct etna_shader_key key)
 130 {
 131    const struct etna_shader_variant *old = ctx->shader.fs;
 132
 133    ctx->shader.fs = etna_shader_variant(ctx->shader.bind_fs, key, &ctx->debug);
 134
 135    if (!ctx->shader.fs)
 136       return false;
 137
 138    if (old != ctx->shader.fs)
 139       ctx->dirty |= ETNA_DIRTY_SHADER;
 140
 141    return true;
 142 }
 143
 144 static void
 145 etna_draw_vbo(struct pipe_context *pctx, const struct pipe_draw_info *info)
 146 {
 147    struct etna_context *ctx = etna_context(pctx);
 148    struct pipe_framebuffer_state *pfb = &ctx->framebuffer_s;
 149    uint32_t draw_mode;
 150    unsigned i;
 151
 152    if (!info->count_from_stream_output && !info->indirect &&
 153        !info->primitive_restart &&
 154        !u_trim_pipe_prim(info->mode, (unsigned*)&info->count))
 155       return;
 156
 157    if (ctx->vertex_elements == NULL || ctx->vertex_elements->num_elements == 0)
 158       return; /* Nothing to do */
 159
 160    if (!(ctx->prim_hwsupport & (1 << info->mode))) {
 161       struct primconvert_context *primconvert = ctx->primconvert;
 162       util_primconvert_save_rasterizer_state(primconvert, ctx->rasterizer);
 163       util_primconvert_draw_vbo(primconvert, info);
 164       return;
 165    }
 166
 167    int prims = u_decomposed_prims_for_vertices(info->mode, info->count);
 168    if (unlikely(prims <= 0)) {
 169       DBG("Invalid draw primitive mode=%i or no primitives to be drawn", info->mode);
 170       return;
 171    }
 172
 173    draw_mode = translate_draw_mode(info->mode);
 174    if (draw_mode == ETNA_NO_MATCH) {
 175       BUG("Unsupported draw mode");
 176       return;
 177    }
 178
 179    /* Upload a user index buffer. */
 180    unsigned index_offset = 0;
 181    struct pipe_resource *indexbuf = NULL;
 182
 183    if (info->index_size) {
 184       indexbuf = info->has_user_indices ? NULL : info->index.resource;
 185       if (info->has_user_indices &&
 186           !util_upload_index_buffer(pctx, info, &indexbuf, &index_offset)) {
 187          BUG("Index buffer upload failed.");
 188          return;
 189       }
 190
 191       ctx->index_buffer.FE_INDEX_STREAM_BASE_ADDR.bo = etna_resource(indexbuf)->bo;
 192       ctx->index_buffer.FE_INDEX_STREAM_BASE_ADDR.offset = index_offset;
 193       ctx->index_buffer.FE_INDEX_STREAM_BASE_ADDR.flags = ETNA_RELOC_READ;
 194       ctx->index_buffer.FE_INDEX_STREAM_CONTROL = translate_index_size(info->index_size);
 195       ctx->dirty |= ETNA_DIRTY_INDEX_BUFFER;
 196
 197       if (!ctx->index_buffer.FE_INDEX_STREAM_BASE_ADDR.bo) {
 198          BUG("Unsupported or no index buffer");
 199          return;
 200       }
 201    }
 202
 203    struct etna_shader_key key = {};
 204    struct etna_surface *cbuf = etna_surface(pfb->cbufs[0]);
 205
 206    if (cbuf) {
 207       struct etna_resource *res = etna_resource(cbuf->base.texture);
 208
 209       key.frag_rb_swap = !!translate_rs_format_rb_swap(res->base.format);
 210    }
 211
 212    if (!etna_get_vs(ctx, key) || !etna_get_fs(ctx, key)) {
 213       BUG("compiled shaders are not okay");
 214       return;
 215    }
 216
 217    /* Update any derived state */
 218    if (!etna_state_update(ctx))
 219       return;
 220
 221    /*
 222     * Figure out the buffers/features we need:
 223     */
 224    if (etna_depth_enabled(ctx))
 225       resource_written(ctx, pfb->zsbuf->texture);
 226
 227    if (etna_stencil_enabled(ctx))
 228       resource_written(ctx, pfb->zsbuf->texture);
 229
 230    for (i = 0; i < pfb->nr_cbufs; i++) {
 231       struct pipe_resource *surf;
 232
 233       if (!pfb->cbufs[i])
 234          continue;
 235
 236       surf = pfb->cbufs[i]->texture;
 237       resource_written(ctx, surf);
 238    }
 239
 240    /* Mark constant buffers as being read */
 241    resource_read(ctx, ctx->constant_buffer[PIPE_SHADER_VERTEX].buffer);
 242    resource_read(ctx, ctx->constant_buffer[PIPE_SHADER_FRAGMENT].buffer);
 243
 244    /* Mark VBOs as being read */
 245    for (i = 0; i < ctx->vertex_buffer.count; i++) {
 246       assert(!ctx->vertex_buffer.vb[i].is_user_buffer);
 247       resource_read(ctx, ctx->vertex_buffer.vb[i].buffer.resource);
 248    }
 249
 250    /* Mark index buffer as being read */
 251    resource_read(ctx, indexbuf);
 252
 253    /* Mark textures as being read */
 254    for (i = 0; i < PIPE_MAX_SAMPLERS; i++)
 255       if (ctx->sampler_view[i])
 256          resource_read(ctx, ctx->sampler_view[i]->texture);
 257
 258    ctx->stats.prims_emitted += u_reduced_prims_for_vertices(info->mode, info->count);
 259    ctx->stats.draw_calls++;
 260
 261    /* Update state for this draw operation */
 262    etna_update_state_for_draw(ctx, info);
 263
 264    /* First, sync state, then emit DRAW_PRIMITIVES or DRAW_INDEXED_PRIMITIVES */
 265    etna_emit_state(ctx);
 266
 267    if (info->index_size)
 268       etna_draw_indexed_primitives(ctx->stream, draw_mode, info->start, prims, info->index_bias);
 269    else
 270       etna_draw_primitives(ctx->stream, draw_mode, info->start, prims);
 271
 272    if (DBG_ENABLED(ETNA_DBG_DRAW_STALL)) {
 273       /* Stall the FE after every draw operation.  This allows better
 274        * debug of GPU hang conditions, as the FE will indicate which
 275        * draw op has caused the hang. */
 276       etna_stall(ctx->stream, SYNC_RECIPIENT_FE, SYNC_RECIPIENT_PE);
 277    }
 278
 279    if (DBG_ENABLED(ETNA_DBG_FLUSH_ALL))
 280       pctx->flush(pctx, NULL, 0);
 281
 282    if (ctx->framebuffer.cbuf)
 283       etna_resource(ctx->framebuffer.cbuf->texture)->seqno++;
 284    if (ctx->framebuffer.zsbuf)
 285       etna_resource(ctx->framebuffer.zsbuf->texture)->seqno++;
 286    if (info->index_size && indexbuf != info->index.resource)
 287       pipe_resource_reference(&indexbuf, NULL);
 288 }
 289
 290 static void
 291 etna_flush(struct pipe_context *pctx, struct pipe_fence_handle **fence,
 292            enum pipe_flush_flags flags)
 293 {
 294    struct etna_context *ctx = etna_context(pctx);
 295    int out_fence_fd = -1;
 296
 297    etna_cmd_stream_flush2(ctx->stream, ctx->in_fence_fd,
 298                           (flags & PIPE_FLUSH_FENCE_FD) ? &out_fence_fd :
 299                           NULL);
 300
 301    if (fence)
 302       *fence = etna_fence_create(pctx, out_fence_fd);
 303 }
 304
 305 static void
 306 etna_cmd_stream_reset_notify(struct etna_cmd_stream *stream, void *priv)
 307 {
 308    struct etna_context *ctx = priv;
 309    struct etna_resource *rsc, *rsc_tmp;
 310
 311    etna_set_state(stream, VIVS_GL_API_MODE, VIVS_GL_API_MODE_OPENGL);
 312    etna_set_state(stream, VIVS_GL_VERTEX_ELEMENT_CONFIG, 0x00000001);
 313    etna_set_state(stream, VIVS_RA_EARLY_DEPTH, 0x00000031);
 314    etna_set_state(stream, VIVS_PA_W_CLIP_LIMIT, 0x34000001);
 315
 316    /* Enable SINGLE_BUFFER for resolve, if supported */
 317    etna_set_state(stream, VIVS_RS_SINGLE_BUFFER, COND(ctx->specs.single_buffer, VIVS_RS_SINGLE_BUFFER_ENABLE));
 318
 319    ctx->dirty = ~0L;
 320
 321    /* go through all the used resources and clear their status flag */
 322    LIST_FOR_EACH_ENTRY_SAFE(rsc, rsc_tmp, &ctx->used_resources, list)
 323    {
 324       debug_assert(rsc->status != 0);
 325       rsc->status = 0;
 326       rsc->pending_ctx = NULL;
 327       list_delinit(&rsc->list);
 328    }
 329
 330    assert(LIST_IS_EMPTY(&ctx->used_resources));
 331 }
 332
 333 static void
 334 etna_set_debug_callback(struct pipe_context *pctx,
 335                         const struct pipe_debug_callback *cb)
 336 {
 337    struct etna_context *ctx = etna_context(pctx);
 338
 339    if (cb)
 340       ctx->debug = *cb;
 341    else
 342       memset(&ctx->debug, 0, sizeof(ctx->debug));
 343 }
 344
 345 struct pipe_context *
 346 etna_context_create(struct pipe_screen *pscreen, void *priv, unsigned flags)
 347 {
 348    struct etna_context *ctx = CALLOC_STRUCT(etna_context);
 349    struct etna_screen *screen;
 350    struct pipe_context *pctx;
 351
 352    if (ctx == NULL)
 353       return NULL;
 354
 355    pctx = &ctx->base;
 356    pctx->priv = ctx;
 357    pctx->screen = pscreen;
 358    pctx->stream_uploader = u_upload_create_default(pctx);
 359    if (!pctx->stream_uploader)
 360       goto fail;
 361    pctx->const_uploader = pctx->stream_uploader;
 362
 363    screen = etna_screen(pscreen);
 364    ctx->stream = etna_cmd_stream_new(screen->pipe, 0x2000, &etna_cmd_stream_reset_notify, ctx);
 365    if (ctx->stream == NULL)
 366       goto fail;
 367
 368    /* context ctxate setup */
 369    ctx->specs = screen->specs;
 370    ctx->screen = screen;
 371    /* need some sane default in case state tracker doesn't set some state: */
 372    ctx->sample_mask = 0xffff;
 373
 374    list_inithead(&ctx->used_resources);
 375
 376    /*  Set sensible defaults for state */
 377    etna_cmd_stream_reset_notify(ctx->stream, ctx);
 378
 379    ctx->in_fence_fd = -1;
 380
 381    pctx->destroy = etna_context_destroy;
 382    pctx->draw_vbo = etna_draw_vbo;
 383    pctx->flush = etna_flush;
 384    pctx->set_debug_callback = etna_set_debug_callback;
 385    pctx->create_fence_fd = etna_create_fence_fd;
 386    pctx->fence_server_sync = etna_fence_server_sync;
 387
 388    /* creation of compile states */
 389    pctx->create_blend_state = etna_blend_state_create;
 390    pctx->create_rasterizer_state = etna_rasterizer_state_create;
 391    pctx->create_depth_stencil_alpha_state = etna_zsa_state_create;
 392
 393    etna_clear_blit_init(pctx);
 394    etna_query_context_init(pctx);
 395    etna_state_init(pctx);
 396    etna_surface_init(pctx);
 397    etna_shader_init(pctx);
 398    etna_texture_init(pctx);
 399    etna_transfer_init(pctx);
 400
 401    ctx->blitter = util_blitter_create(pctx);
 402    if (!ctx->blitter)
 403       goto fail;
 404
 405    /* Generate the bitmask of supported draw primitives. */
 406    ctx->prim_hwsupport = 1 << PIPE_PRIM_POINTS |
 407                          1 << PIPE_PRIM_LINES |
 408                          1 << PIPE_PRIM_LINE_STRIP |
 409                          1 << PIPE_PRIM_TRIANGLES |
 410                          1 << PIPE_PRIM_TRIANGLE_STRIP |
 411                          1 << PIPE_PRIM_TRIANGLE_FAN;
 412
 413    if (VIV_FEATURE(ctx->screen, chipMinorFeatures2, LINE_LOOP))
 414       ctx->prim_hwsupport |= 1 << PIPE_PRIM_LINE_LOOP;
 415
 416    ctx->primconvert = util_primconvert_create(pctx, ctx->prim_hwsupport);
 417    if (!ctx->primconvert)
 418       goto fail;
 419
 420    slab_create_child(&ctx->transfer_pool, &screen->transfer_pool);
 421
 422    return pctx;
 423
 424 fail:
 425    pctx->destroy(pctx);
 426
 427    return NULL;
 428 }