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_query_hw.h"
  38 #include "etnaviv_rasterizer.h"
  39 #include "etnaviv_screen.h"
  40 #include "etnaviv_shader.h"
  41 #include "etnaviv_state.h"
  42 #include "etnaviv_surface.h"
  43 #include "etnaviv_texture.h"
  44 #include "etnaviv_transfer.h"
  45 #include "etnaviv_translate.h"
  46 #include "etnaviv_zsa.h"
  47
  48 #include "pipe/p_context.h"
  49 #include "pipe/p_state.h"
  50 #include "util/u_blitter.h"
  51 #include "util/u_helpers.h"
  52 #include "util/u_memory.h"
  53 #include "util/u_prim.h"
  54 #include "util/u_upload_mgr.h"
  55
  56 #include "hw/common.xml.h"
  57
  58 static void
  59 etna_context_destroy(struct pipe_context *pctx)
  60 {
  61    struct etna_context *ctx = etna_context(pctx);
  62
  63    if (ctx->dummy_rt)
  64       etna_bo_del(ctx->dummy_rt);
  65
  66    if (ctx->primconvert)
  67       util_primconvert_destroy(ctx->primconvert);
  68
  69    if (ctx->blitter)
  70       util_blitter_destroy(ctx->blitter);
  71
  72    if (pctx->stream_uploader)
  73       u_upload_destroy(pctx->stream_uploader);
  74
  75    if (ctx->stream)
  76       etna_cmd_stream_del(ctx->stream);
  77
  78    slab_destroy_child(&ctx->transfer_pool);
  79
  80    if (ctx->in_fence_fd != -1)
  81       close(ctx->in_fence_fd);
  82
  83    FREE(pctx);
  84 }
  85
  86 /* Update render state where needed based on draw operation */
  87 static void
  88 etna_update_state_for_draw(struct etna_context *ctx, const struct pipe_draw_info *info)
  89 {
  90    /* Handle primitive restart:
  91     * - If not an indexed draw, we don't care about the state of the primitive restart bit.
  92     * - Otherwise, set the bit in INDEX_STREAM_CONTROL in the index buffer state
  93     *   accordingly
  94     * - If the value of the INDEX_STREAM_CONTROL register changed due to this, or
  95     *   primitive restart is enabled and the restart index changed, mark the index
  96     *   buffer state as dirty
  97     */
  98
  99    if (info->index_size) {
 100       uint32_t new_control = ctx->index_buffer.FE_INDEX_STREAM_CONTROL;
 101
 102       if (info->primitive_restart)
 103          new_control |= VIVS_FE_INDEX_STREAM_CONTROL_PRIMITIVE_RESTART;
 104       else
 105          new_control &= ~VIVS_FE_INDEX_STREAM_CONTROL_PRIMITIVE_RESTART;
 106
 107       if (ctx->index_buffer.FE_INDEX_STREAM_CONTROL != new_control ||
 108           (info->primitive_restart && ctx->index_buffer.FE_PRIMITIVE_RESTART_INDEX != info->restart_index)) {
 109          ctx->index_buffer.FE_INDEX_STREAM_CONTROL = new_control;
 110          ctx->index_buffer.FE_PRIMITIVE_RESTART_INDEX = info->restart_index;
 111          ctx->dirty |= ETNA_DIRTY_INDEX_BUFFER;
 112       }
 113    }
 114 }
 115
 116 static bool
 117 etna_get_vs(struct etna_context *ctx, struct etna_shader_key key)
 118 {
 119    const struct etna_shader_variant *old = ctx->shader.vs;
 120
 121    ctx->shader.vs = etna_shader_variant(ctx->shader.bind_vs, key, &ctx->debug);
 122
 123    if (!ctx->shader.vs)
 124       return false;
 125
 126    if (old != ctx->shader.vs)
 127       ctx->dirty |= ETNA_DIRTY_SHADER;
 128
 129    return true;
 130 }
 131
 132 static bool
 133 etna_get_fs(struct etna_context *ctx, struct etna_shader_key key)
 134 {
 135    const struct etna_shader_variant *old = ctx->shader.fs;
 136
 137    ctx->shader.fs = etna_shader_variant(ctx->shader.bind_fs, key, &ctx->debug);
 138
 139    if (!ctx->shader.fs)
 140       return false;
 141
 142    if (old != ctx->shader.fs)
 143       ctx->dirty |= ETNA_DIRTY_SHADER;
 144
 145    return true;
 146 }
 147
 148 static void
 149 etna_draw_vbo(struct pipe_context *pctx, const struct pipe_draw_info *info)
 150 {
 151    struct etna_context *ctx = etna_context(pctx);
 152    struct pipe_framebuffer_state *pfb = &ctx->framebuffer_s;
 153    uint32_t draw_mode;
 154    unsigned i;
 155
 156    if (!info->count_from_stream_output && !info->indirect &&
 157        !info->primitive_restart &&
 158        !u_trim_pipe_prim(info->mode, (unsigned*)&info->count))
 159       return;
 160
 161    if (ctx->vertex_elements == NULL || ctx->vertex_elements->num_elements == 0)
 162       return; /* Nothing to do */
 163
 164    if (!(ctx->prim_hwsupport & (1 << info->mode))) {
 165       struct primconvert_context *primconvert = ctx->primconvert;
 166       util_primconvert_save_rasterizer_state(primconvert, ctx->rasterizer);
 167       util_primconvert_draw_vbo(primconvert, info);
 168       return;
 169    }
 170
 171    int prims = u_decomposed_prims_for_vertices(info->mode, info->count);
 172    if (unlikely(prims <= 0)) {
 173       DBG("Invalid draw primitive mode=%i or no primitives to be drawn", info->mode);
 174       return;
 175    }
 176
 177    draw_mode = translate_draw_mode(info->mode);
 178    if (draw_mode == ETNA_NO_MATCH) {
 179       BUG("Unsupported draw mode");
 180       return;
 181    }
 182
 183    /* Upload a user index buffer. */
 184    unsigned index_offset = 0;
 185    struct pipe_resource *indexbuf = NULL;
 186
 187    if (info->index_size) {
 188       indexbuf = info->has_user_indices ? NULL : info->index.resource;
 189       if (info->has_user_indices &&
 190           !util_upload_index_buffer(pctx, info, &indexbuf, &index_offset)) {
 191          BUG("Index buffer upload failed.");
 192          return;
 193       }
 194       /* Add start to index offset, when rendering indexed */
 195       index_offset += info->start * info->index_size;
 196
 197       ctx->index_buffer.FE_INDEX_STREAM_BASE_ADDR.bo = etna_resource(indexbuf)->bo;
 198       ctx->index_buffer.FE_INDEX_STREAM_BASE_ADDR.offset = index_offset;
 199       ctx->index_buffer.FE_INDEX_STREAM_BASE_ADDR.flags = ETNA_RELOC_READ;
 200       ctx->index_buffer.FE_INDEX_STREAM_CONTROL = translate_index_size(info->index_size);
 201
 202       if (!ctx->index_buffer.FE_INDEX_STREAM_BASE_ADDR.bo) {
 203          BUG("Unsupported or no index buffer");
 204          return;
 205       }
 206    } else {
 207       ctx->index_buffer.FE_INDEX_STREAM_BASE_ADDR.bo = 0;
 208       ctx->index_buffer.FE_INDEX_STREAM_BASE_ADDR.offset = 0;
 209       ctx->index_buffer.FE_INDEX_STREAM_BASE_ADDR.flags = 0;
 210       ctx->index_buffer.FE_INDEX_STREAM_CONTROL = 0;
 211    }
 212    ctx->dirty |= ETNA_DIRTY_INDEX_BUFFER;
 213
 214    struct etna_shader_key key = {};
 215    struct etna_surface *cbuf = etna_surface(pfb->cbufs[0]);
 216
 217    if (cbuf) {
 218       struct etna_resource *res = etna_resource(cbuf->base.texture);
 219
 220       key.frag_rb_swap = !!translate_rs_format_rb_swap(res->base.format);
 221    }
 222
 223    if (!etna_get_vs(ctx, key) || !etna_get_fs(ctx, key)) {
 224       BUG("compiled shaders are not okay");
 225       return;
 226    }
 227
 228    /* Update any derived state */
 229    if (!etna_state_update(ctx))
 230       return;
 231
 232    /*
 233     * Figure out the buffers/features we need:
 234     */
 235    if (etna_depth_enabled(ctx))
 236       resource_written(ctx, pfb->zsbuf->texture);
 237
 238    if (etna_stencil_enabled(ctx))
 239       resource_written(ctx, pfb->zsbuf->texture);
 240
 241    for (i = 0; i < pfb->nr_cbufs; i++) {
 242       struct pipe_resource *surf;
 243
 244       if (!pfb->cbufs[i])
 245          continue;
 246
 247       surf = pfb->cbufs[i]->texture;
 248       resource_written(ctx, surf);
 249    }
 250
 251    /* Mark constant buffers as being read */
 252    resource_read(ctx, ctx->constant_buffer[PIPE_SHADER_VERTEX].buffer);
 253    resource_read(ctx, ctx->constant_buffer[PIPE_SHADER_FRAGMENT].buffer);
 254
 255    /* Mark VBOs as being read */
 256    for (i = 0; i < ctx->vertex_buffer.count; i++) {
 257       assert(!ctx->vertex_buffer.vb[i].is_user_buffer);
 258       resource_read(ctx, ctx->vertex_buffer.vb[i].buffer.resource);
 259    }
 260
 261    /* Mark index buffer as being read */
 262    resource_read(ctx, indexbuf);
 263
 264    /* Mark textures as being read */
 265    for (i = 0; i < PIPE_MAX_SAMPLERS; i++)
 266       if (ctx->sampler_view[i])
 267          resource_read(ctx, ctx->sampler_view[i]->texture);
 268
 269    list_for_each_entry(struct etna_hw_query, hq, &ctx->active_hw_queries, node)
 270       resource_written(ctx, hq->prsc);
 271
 272    ctx->stats.prims_emitted += u_reduced_prims_for_vertices(info->mode, info->count);
 273    ctx->stats.draw_calls++;
 274
 275    /* Update state for this draw operation */
 276    etna_update_state_for_draw(ctx, info);
 277
 278    /* First, sync state, then emit DRAW_PRIMITIVES or DRAW_INDEXED_PRIMITIVES */
 279    etna_emit_state(ctx);
 280
 281    if (ctx->specs.halti >= 2) {
 282       /* On HALTI2+ (GC3000 and higher) only use instanced drawing commands, as the blob does */
 283       etna_draw_instanced(ctx->stream, info->index_size, draw_mode, 1,
 284          info->count, info->index_size ? info->index_bias : info->start);
 285    } else {
 286       if (info->index_size)
 287          etna_draw_indexed_primitives(ctx->stream, draw_mode, 0, prims, info->index_bias);
 288       else
 289          etna_draw_primitives(ctx->stream, draw_mode, info->start, prims);
 290    }
 291
 292    if (DBG_ENABLED(ETNA_DBG_DRAW_STALL)) {
 293       /* Stall the FE after every draw operation.  This allows better
 294        * debug of GPU hang conditions, as the FE will indicate which
 295        * draw op has caused the hang. */
 296       etna_stall(ctx->stream, SYNC_RECIPIENT_FE, SYNC_RECIPIENT_PE);
 297    }
 298
 299    if (DBG_ENABLED(ETNA_DBG_FLUSH_ALL))
 300       pctx->flush(pctx, NULL, 0);
 301
 302    if (ctx->framebuffer.cbuf)
 303       etna_resource(ctx->framebuffer.cbuf->texture)->seqno++;
 304    if (ctx->framebuffer.zsbuf)
 305       etna_resource(ctx->framebuffer.zsbuf->texture)->seqno++;
 306    if (info->index_size && indexbuf != info->index.resource)
 307       pipe_resource_reference(&indexbuf, NULL);
 308 }
 309
 310 static void
 311 etna_flush(struct pipe_context *pctx, struct pipe_fence_handle **fence,
 312            enum pipe_flush_flags flags)
 313 {
 314    struct etna_context *ctx = etna_context(pctx);
 315    int out_fence_fd = -1;
 316
 317    list_for_each_entry(struct etna_hw_query, hq, &ctx->active_hw_queries, node)
 318       etna_hw_query_suspend(hq, ctx);
 319
 320    etna_cmd_stream_flush2(ctx->stream, ctx->in_fence_fd,
 321                           (flags & PIPE_FLUSH_FENCE_FD) ? &out_fence_fd :
 322                           NULL);
 323
 324    list_for_each_entry(struct etna_hw_query, hq, &ctx->active_hw_queries, node)
 325       etna_hw_query_resume(hq, ctx);
 326
 327    if (fence)
 328       *fence = etna_fence_create(pctx, out_fence_fd);
 329 }
 330
 331 static void
 332 etna_cmd_stream_reset_notify(struct etna_cmd_stream *stream, void *priv)
 333 {
 334    struct etna_context *ctx = priv;
 335    struct etna_resource *rsc, *rsc_tmp;
 336
 337    etna_set_state(stream, VIVS_GL_API_MODE, VIVS_GL_API_MODE_OPENGL);
 338    etna_set_state(stream, VIVS_GL_VERTEX_ELEMENT_CONFIG, 0x00000001);
 339    /* blob sets this to 0x40000031 on GC7000, seems to make no difference,
 340     * but keep it in mind if depth behaves strangely. */
 341    etna_set_state(stream, VIVS_RA_EARLY_DEPTH, 0x00000031);
 342    etna_set_state(stream, VIVS_PA_W_CLIP_LIMIT, 0x34000001);
 343    etna_set_state(stream, VIVS_PA_FLAGS, 0x00000000); /* blob sets ZCONVERT_BYPASS on GC3000+, this messes up z for us */
 344    etna_set_state(stream, VIVS_PA_VIEWPORT_UNK00A80, 0x38a01404);
 345    etna_set_state(stream, VIVS_PA_VIEWPORT_UNK00A84, fui(8192.0));
 346    etna_set_state(stream, VIVS_PA_ZFARCLIPPING, 0x00000000);
 347    etna_set_state(stream, VIVS_PE_ALPHA_COLOR_EXT0, 0x00000000);
 348    etna_set_state(stream, VIVS_PE_ALPHA_COLOR_EXT1, 0x00000000);
 349    etna_set_state(stream, VIVS_RA_HDEPTH_CONTROL, 0x00007000);
 350    etna_set_state(stream, VIVS_PE_STENCIL_CONFIG_EXT2, 0x00000000);
 351    etna_set_state(stream, VIVS_PS_CONTROL_EXT, 0x00000000);
 352
 353    /* There is no HALTI0 specific state */
 354    if (ctx->specs.halti >= 1) { /* Only on HALTI1+ */
 355       etna_set_state(stream, VIVS_VS_HALTI1_UNK00884, 0x00000808);
 356    }
 357    if (ctx->specs.halti >= 2) { /* Only on HALTI2+ */
 358       etna_set_state(stream, VIVS_RA_UNK00E0C, 0x00000000);
 359    }
 360    if (ctx->specs.halti >= 3) { /* Only on HALTI3+ */
 361       etna_set_state(stream, VIVS_PE_MEM_CONFIG, 0x00000000); /* TODO: cache modes */
 362       etna_set_state(stream, VIVS_PS_HALTI3_UNK0103C, 0x76543210);
 363    }
 364    if (ctx->specs.halti >= 4) { /* Only on HALTI4+ */
 365       etna_set_state(stream, VIVS_PS_MSAA_CONFIG, 0x6fffffff & 0xf70fffff & 0xfff6ffff &
 366                                                   0xffff6fff & 0xfffff6ff & 0xffffff7f);
 367       etna_set_state(stream, VIVS_PE_HALTI4_UNK014C0, 0x00000000);
 368    }
 369    if (ctx->specs.halti >= 5) { /* Only on HALTI5+ */
 370       etna_set_state(stream, VIVS_NTE_DESCRIPTOR_UNK14C40, 0x00000001);
 371       etna_set_state(stream, VIVS_FE_HALTI5_UNK007D8, 0x00000002);
 372       etna_set_state(stream, VIVS_FE_HALTI5_UNK007C4, 0x00000000);
 373       etna_set_state(stream, VIVS_PS_SAMPLER_BASE, 0x00000000);
 374       etna_set_state(stream, VIVS_VS_SAMPLER_BASE, 0x00000020);
 375       etna_set_state(stream, VIVS_SH_CONFIG, VIVS_SH_CONFIG_RTNE_ROUNDING);
 376    } else { /* Only on pre-HALTI5 */
 377       etna_set_state(stream, VIVS_GL_UNK03834, 0x00000000);
 378       etna_set_state(stream, VIVS_GL_UNK03838, 0x00000000);
 379       etna_set_state(stream, VIVS_GL_UNK03854, 0x00000000);
 380    }
 381
 382    if (!ctx->specs.use_blt) {
 383       /* Enable SINGLE_BUFFER for resolve, if supported */
 384       etna_set_state(stream, VIVS_RS_SINGLE_BUFFER, COND(ctx->specs.single_buffer, VIVS_RS_SINGLE_BUFFER_ENABLE));
 385    }
 386
 387    ctx->dirty = ~0L;
 388    ctx->dirty_sampler_views = ~0L;
 389
 390    /* go through all the used resources and clear their status flag */
 391    LIST_FOR_EACH_ENTRY_SAFE(rsc, rsc_tmp, &ctx->used_resources, list)
 392    {
 393       debug_assert(rsc->status != 0);
 394       rsc->status = 0;
 395       rsc->pending_ctx = NULL;
 396       list_delinit(&rsc->list);
 397    }
 398
 399    assert(LIST_IS_EMPTY(&ctx->used_resources));
 400 }
 401
 402 static void
 403 etna_set_debug_callback(struct pipe_context *pctx,
 404                         const struct pipe_debug_callback *cb)
 405 {
 406    struct etna_context *ctx = etna_context(pctx);
 407
 408    if (cb)
 409       ctx->debug = *cb;
 410    else
 411       memset(&ctx->debug, 0, sizeof(ctx->debug));
 412 }
 413
 414 struct pipe_context *
 415 etna_context_create(struct pipe_screen *pscreen, void *priv, unsigned flags)
 416 {
 417    struct etna_context *ctx = CALLOC_STRUCT(etna_context);
 418    struct etna_screen *screen;
 419    struct pipe_context *pctx;
 420
 421    if (ctx == NULL)
 422       return NULL;
 423
 424    pctx = &ctx->base;
 425    pctx->priv = ctx;
 426    pctx->screen = pscreen;
 427    pctx->stream_uploader = u_upload_create_default(pctx);
 428    if (!pctx->stream_uploader)
 429       goto fail;
 430    pctx->const_uploader = pctx->stream_uploader;
 431
 432    screen = etna_screen(pscreen);
 433    ctx->stream = etna_cmd_stream_new(screen->pipe, 0x2000, &etna_cmd_stream_reset_notify, ctx);
 434    if (ctx->stream == NULL)
 435       goto fail;
 436
 437    /* context ctxate setup */
 438    ctx->specs = screen->specs;
 439    ctx->screen = screen;
 440    /* need some sane default in case state tracker doesn't set some state: */
 441    ctx->sample_mask = 0xffff;
 442
 443    list_inithead(&ctx->used_resources);
 444
 445    /*  Set sensible defaults for state */
 446    etna_cmd_stream_reset_notify(ctx->stream, ctx);
 447
 448    ctx->in_fence_fd = -1;
 449
 450    pctx->destroy = etna_context_destroy;
 451    pctx->draw_vbo = etna_draw_vbo;
 452    pctx->flush = etna_flush;
 453    pctx->set_debug_callback = etna_set_debug_callback;
 454    pctx->create_fence_fd = etna_create_fence_fd;
 455    pctx->fence_server_sync = etna_fence_server_sync;
 456
 457    /* creation of compile states */
 458    pctx->create_blend_state = etna_blend_state_create;
 459    pctx->create_rasterizer_state = etna_rasterizer_state_create;
 460    pctx->create_depth_stencil_alpha_state = etna_zsa_state_create;
 461
 462    etna_clear_blit_init(pctx);
 463    etna_query_context_init(pctx);
 464    etna_state_init(pctx);
 465    etna_surface_init(pctx);
 466    etna_shader_init(pctx);
 467    etna_texture_init(pctx);
 468    etna_transfer_init(pctx);
 469
 470    ctx->blitter = util_blitter_create(pctx);
 471    if (!ctx->blitter)
 472       goto fail;
 473
 474    /* Generate the bitmask of supported draw primitives. */
 475    ctx->prim_hwsupport = 1 << PIPE_PRIM_POINTS |
 476                          1 << PIPE_PRIM_LINES |
 477                          1 << PIPE_PRIM_LINE_STRIP |
 478                          1 << PIPE_PRIM_TRIANGLES |
 479                          1 << PIPE_PRIM_TRIANGLE_STRIP |
 480                          1 << PIPE_PRIM_TRIANGLE_FAN;
 481
 482    if (VIV_FEATURE(ctx->screen, chipMinorFeatures2, LINE_LOOP))
 483       ctx->prim_hwsupport |= 1 << PIPE_PRIM_LINE_LOOP;
 484
 485    ctx->primconvert = util_primconvert_create(pctx, ctx->prim_hwsupport);
 486    if (!ctx->primconvert)
 487       goto fail;
 488
 489    slab_create_child(&ctx->transfer_pool, &screen->transfer_pool);
 490    list_inithead(&ctx->active_hw_queries);
 491
 492    /* create dummy RT buffer, used when rendering with no color buffer */
 493    ctx->dummy_rt = etna_bo_new(ctx->screen->dev, 64 * 64 * 4,
 494                                DRM_ETNA_GEM_CACHE_WC);
 495    if (!ctx->dummy_rt)
 496       goto fail;
 497
 498    ctx->dummy_rt_reloc.bo = ctx->dummy_rt;
 499    ctx->dummy_rt_reloc.offset = 0;
 500    ctx->dummy_rt_reloc.flags = ETNA_RELOC_READ | ETNA_RELOC_WRITE;
 501
 502    return pctx;
 503
 504 fail:
 505    pctx->destroy(pctx);
 506
 507    return NULL;
 508 }