etnaviv: gallium driver for Vivante GPUs

This driver supports a wide range of Vivante IP cores like GC880,
GC1000, GC2000 and GC3000.

Changes from V1 -> V2:
 - added missing files to actually integrate the driver into build system.
 - adapted driver to new renderonly API

Signed-off-by: Christian Gmeiner <[email protected]>
Signed-off-by: Lucas Stach <[email protected]>
Signed-off-by: Philipp Zabel <[email protected]>
Signed-off-by: Rob Herring <[email protected]>
Signed-off-by: Russell King <[email protected]>
Signed-off-by: Wladimir J. van der Laan <[email protected]>
Acked-by: Emil Velikov <[email protected]>

1 files changed, 323 insertions, 0 deletions

diff --git a/src/gallium/drivers/etnaviv/etnaviv_context.c b/src/gallium/drivers/etnaviv/etnaviv_context.c
new file mode 100644
index 00000000000..d767cd1f38e
--- /dev/null
+++ b/src/gallium/drivers/etnaviv/etnaviv_context.c
@@ -0,0 +1,323 @@
+/*
+ * Copyright (c) 2012-2015 Etnaviv Project
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sub license,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ * Authors:
+ *    Wladimir J. van der Laan <[email protected]>
+ *    Christian Gmeiner <[email protected]>
+ */
+
+#include "etnaviv_context.h"
+
+#include "etnaviv_blend.h"
+#include "etnaviv_clear_blit.h"
+#include "etnaviv_compiler.h"
+#include "etnaviv_debug.h"
+#include "etnaviv_emit.h"
+#include "etnaviv_fence.h"
+#include "etnaviv_query.h"
+#include "etnaviv_rasterizer.h"
+#include "etnaviv_screen.h"
+#include "etnaviv_shader.h"
+#include "etnaviv_state.h"
+#include "etnaviv_surface.h"
+#include "etnaviv_texture.h"
+#include "etnaviv_transfer.h"
+#include "etnaviv_translate.h"
+#include "etnaviv_zsa.h"
+
+#include "pipe/p_context.h"
+#include "pipe/p_state.h"
+#include "util/u_blitter.h"
+#include "util/u_memory.h"
+#include "util/u_prim.h"
+
+#include "hw/common.xml.h"
+
+static void
+etna_context_destroy(struct pipe_context *pctx)
+{
+   struct etna_context *ctx = etna_context(pctx);
+
+   if (ctx->primconvert)
+      util_primconvert_destroy(ctx->primconvert);
+
+   if (ctx->blitter)
+      util_blitter_destroy(ctx->blitter);
+
+   if (ctx->stream)
+      etna_cmd_stream_del(ctx->stream);
+
+   slab_destroy_child(&ctx->transfer_pool);
+
+   FREE(pctx);
+}
+
+/* Update render state where needed based on draw operation */
+static void
+etna_update_state_for_draw(struct etna_context *ctx, const struct pipe_draw_info *info)
+{
+   /* Handle primitive restart:
+    * - If not an indexed draw, we don't care about the state of the primitive restart bit.
+    * - Otherwise, set the bit in INDEX_STREAM_CONTROL in the index buffer state
+    *   accordingly
+    * - If the value of the INDEX_STREAM_CONTROL register changed due to this, or
+    *   primitive restart is enabled and the restart index changed, mark the index
+    *   buffer state as dirty
+    */
+
+   if (info->indexed) {
+      uint32_t new_control = ctx->index_buffer.FE_INDEX_STREAM_CONTROL;
+
+      if (info->primitive_restart)
+         new_control |= VIVS_FE_INDEX_STREAM_CONTROL_PRIMITIVE_RESTART;
+      else
+         new_control &= ~VIVS_FE_INDEX_STREAM_CONTROL_PRIMITIVE_RESTART;
+
+      if (ctx->index_buffer.FE_INDEX_STREAM_CONTROL != new_control ||
+          (info->primitive_restart && ctx->index_buffer.FE_PRIMITIVE_RESTART_INDEX != info->restart_index)) {
+         ctx->index_buffer.FE_INDEX_STREAM_CONTROL = new_control;
+         ctx->index_buffer.FE_PRIMITIVE_RESTART_INDEX = info->restart_index;
+         ctx->dirty |= ETNA_DIRTY_INDEX_BUFFER;
+      }
+   }
+}
+
+
+static void
+etna_draw_vbo(struct pipe_context *pctx, const struct pipe_draw_info *info)
+{
+   struct etna_context *ctx = etna_context(pctx);
+   struct pipe_framebuffer_state *pfb = &ctx->framebuffer_s;
+   uint32_t draw_mode;
+   unsigned i;
+
+   if (ctx->vertex_elements == NULL || ctx->vertex_elements->num_elements == 0)
+      return; /* Nothing to do */
+
+   if (!(ctx->prim_hwsupport & (1 << info->mode))) {
+      struct primconvert_context *primconvert = ctx->primconvert;
+      util_primconvert_save_index_buffer(primconvert, &ctx->index_buffer.ib);
+      util_primconvert_save_rasterizer_state(primconvert, ctx->rasterizer);
+      util_primconvert_draw_vbo(primconvert, info);
+      return;
+   }
+
+   int prims = u_decomposed_prims_for_vertices(info->mode, info->count);
+   if (unlikely(prims <= 0)) {
+      DBG("Invalid draw primitive mode=%i or no primitives to be drawn", info->mode);
+      return;
+   }
+
+   draw_mode = translate_draw_mode(info->mode);
+   if (draw_mode == ETNA_NO_MATCH) {
+      BUG("Unsupported draw mode");
+      return;
+   }
+
+   if (info->indexed && !ctx->index_buffer.FE_INDEX_STREAM_BASE_ADDR.bo) {
+      BUG("Unsupported or no index buffer");
+      return;
+   }
+
+   /* Update any derived state */
+   if (!etna_state_update(ctx))
+      return;
+
+   /*
+    * Figure out the buffers/features we need:
+    */
+   if (etna_depth_enabled(ctx))
+      resource_written(ctx, pfb->zsbuf->texture);
+
+   if (etna_stencil_enabled(ctx))
+      resource_written(ctx, pfb->zsbuf->texture);
+
+   for (i = 0; i < pfb->nr_cbufs; i++) {
+      struct pipe_resource *surf;
+
+      if (!pfb->cbufs[i])
+         continue;
+
+      surf = pfb->cbufs[i]->texture;
+      resource_written(ctx, surf);
+   }
+
+   /* Mark constant buffers as being read */
+   resource_read(ctx, ctx->constant_buffer[PIPE_SHADER_VERTEX].buffer);
+   resource_read(ctx, ctx->constant_buffer[PIPE_SHADER_FRAGMENT].buffer);
+
+   /* Mark VBOs as being read */
+   for (i = 0; i < ctx->vertex_buffer.count; i++) {
+      assert(!ctx->vertex_buffer.vb[i].user_buffer);
+      resource_read(ctx, ctx->vertex_buffer.vb[i].buffer);
+   }
+
+   /* Mark index buffer as being read */
+   resource_read(ctx, ctx->index_buffer.ib.buffer);
+
+   /* Mark textures as being read */
+   for (i = 0; i < PIPE_MAX_SAMPLERS; i++)
+      if (ctx->sampler_view[i])
+         resource_read(ctx, ctx->sampler_view[i]->texture);
+
+   ctx->stats.prims_emitted += u_reduced_prims_for_vertices(info->mode, info->count);
+   ctx->stats.draw_calls++;
+
+   /* Update state for this draw operation */
+   etna_update_state_for_draw(ctx, info);
+
+   /* First, sync state, then emit DRAW_PRIMITIVES or DRAW_INDEXED_PRIMITIVES */
+   etna_emit_state(ctx);
+
+   if (info->indexed)
+      etna_draw_indexed_primitives(ctx->stream, draw_mode, info->start, prims, info->index_bias);
+   else
+      etna_draw_primitives(ctx->stream, draw_mode, info->start, prims);
+
+   if (DBG_ENABLED(ETNA_DBG_DRAW_STALL)) {
+      /* Stall the FE after every draw operation.  This allows better
+       * debug of GPU hang conditions, as the FE will indicate which
+       * draw op has caused the hang. */
+      etna_stall(ctx->stream, SYNC_RECIPIENT_FE, SYNC_RECIPIENT_PE);
+   }
+
+   if (DBG_ENABLED(ETNA_DBG_FLUSH_ALL))
+      pctx->flush(pctx, NULL, 0);
+
+   if (ctx->framebuffer.cbuf)
+      etna_resource(ctx->framebuffer.cbuf->texture)->seqno++;
+   if (ctx->framebuffer.zsbuf)
+      etna_resource(ctx->framebuffer.zsbuf->texture)->seqno++;
+}
+
+static void
+etna_flush(struct pipe_context *pctx, struct pipe_fence_handle **fence,
+           enum pipe_flush_flags flags)
+{
+   struct etna_context *ctx = etna_context(pctx);
+
+   etna_cmd_stream_flush(ctx->stream);
+
+   if (fence)
+      *fence = etna_fence_create(pctx);
+}
+
+static void
+etna_cmd_stream_reset_notify(struct etna_cmd_stream *stream, void *priv)
+{
+   struct etna_context *ctx = priv;
+   struct etna_resource *rsc, *rsc_tmp;
+
+   etna_set_state(stream, VIVS_GL_API_MODE, VIVS_GL_API_MODE_OPENGL);
+   etna_set_state(stream, VIVS_GL_VERTEX_ELEMENT_CONFIG, 0x00000001);
+   etna_set_state(stream, VIVS_RA_EARLY_DEPTH, 0x00000031);
+   etna_set_state(stream, VIVS_PA_W_CLIP_LIMIT, 0x34000001);
+
+   ctx->dirty = ~0L;
+
+   /* go through all the used resources and clear their status flag */
+   LIST_FOR_EACH_ENTRY_SAFE(rsc, rsc_tmp, &ctx->used_resources, list)
+   {
+      debug_assert(rsc->status != 0);
+      rsc->status = 0;
+      rsc->pending_ctx = NULL;
+      list_delinit(&rsc->list);
+   }
+
+   assert(LIST_IS_EMPTY(&ctx->used_resources));
+}
+
+struct pipe_context *
+etna_context_create(struct pipe_screen *pscreen, void *priv, unsigned flags)
+{
+   struct etna_context *ctx = CALLOC_STRUCT(etna_context);
+   struct etna_screen *screen;
+   struct pipe_context *pctx = NULL;
+
+   if (ctx == NULL)
+      return NULL;
+
+   screen = etna_screen(pscreen);
+   ctx->stream = etna_cmd_stream_new(screen->pipe, 0x2000, &etna_cmd_stream_reset_notify, ctx);
+   if (ctx->stream == NULL)
+      goto fail;
+
+   pctx = &ctx->base;
+   pctx->priv = ctx;
+   pctx->screen = pscreen;
+
+   /* context ctxate setup */
+   ctx->specs = screen->specs;
+   ctx->screen = screen;
+   /* need some sane default in case state tracker doesn't set some state: */
+   ctx->sample_mask = 0xffff;
+
+   list_inithead(&ctx->used_resources);
+
+   /*  Set sensible defaults for state */
+   etna_cmd_stream_reset_notify(ctx->stream, ctx);
+
+   pctx->destroy = etna_context_destroy;
+   pctx->draw_vbo = etna_draw_vbo;
+   pctx->flush = etna_flush;
+
+   /* creation of compile states */
+   pctx->create_blend_state = etna_blend_state_create;
+   pctx->create_rasterizer_state = etna_rasterizer_state_create;
+   pctx->create_depth_stencil_alpha_state = etna_zsa_state_create;
+
+   etna_clear_blit_init(pctx);
+   etna_query_context_init(pctx);
+   etna_state_init(pctx);
+   etna_surface_init(pctx);
+   etna_shader_init(pctx);
+   etna_texture_init(pctx);
+   etna_transfer_init(pctx);
+
+   ctx->blitter = util_blitter_create(pctx);
+   if (!ctx->blitter)
+      goto fail;
+
+   /* Generate the bitmask of supported draw primitives. */
+   ctx->prim_hwsupport = 1 << PIPE_PRIM_POINTS |
+                         1 << PIPE_PRIM_LINES |
+                         1 << PIPE_PRIM_LINE_STRIP |
+                         1 << PIPE_PRIM_TRIANGLES |
+                         1 << PIPE_PRIM_TRIANGLE_STRIP |
+                         1 << PIPE_PRIM_TRIANGLE_FAN;
+
+   if (VIV_FEATURE(ctx->screen, chipMinorFeatures2, LINE_LOOP))
+      ctx->prim_hwsupport |= 1 << PIPE_PRIM_LINE_LOOP;
+
+   ctx->primconvert = util_primconvert_create(pctx, ctx->prim_hwsupport);
+   if (!ctx->primconvert)
+      goto fail;
+
+   slab_create_child(&ctx->transfer_pool, &screen->transfer_pool);
+
+   return pctx;
+
+fail:
+   pctx->destroy(pctx);
+
+   return NULL;
+}