"Fossies" - the Fresh Open Source Software Archive

Member "mesa-20.1.8/src/gallium/drivers/etnaviv/etnaviv_emit.h" (16 Sep 2020, 7242 Bytes) of package /linux/misc/mesa-20.1.8.tar.xz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "etnaviv_emit.h" see the Fossies "Dox" file reference documentation.

    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 #ifndef H_ETNA_EMIT
   28 #define H_ETNA_EMIT
   29 
   30 #include "etnaviv_screen.h"
   31 #include "etnaviv_util.h"
   32 #include "hw/cmdstream.xml.h"
   33 
   34 struct etna_context;
   35 
   36 struct etna_coalesce {
   37    uint32_t start;
   38    uint32_t last_reg;
   39    uint32_t last_fixp;
   40 };
   41 
   42 static inline void
   43 etna_emit_load_state(struct etna_cmd_stream *stream, const uint16_t offset,
   44                      const uint16_t count, const int fixp)
   45 {
   46    uint32_t v;
   47 
   48    v = VIV_FE_LOAD_STATE_HEADER_OP_LOAD_STATE |
   49        COND(fixp, VIV_FE_LOAD_STATE_HEADER_FIXP) |
   50        VIV_FE_LOAD_STATE_HEADER_OFFSET(offset) |
   51        (VIV_FE_LOAD_STATE_HEADER_COUNT(count) &
   52         VIV_FE_LOAD_STATE_HEADER_COUNT__MASK);
   53 
   54    etna_cmd_stream_emit(stream, v);
   55 }
   56 
   57 static inline void
   58 etna_set_state(struct etna_cmd_stream *stream, uint32_t address, uint32_t value)
   59 {
   60    etna_cmd_stream_reserve(stream, 2);
   61    etna_emit_load_state(stream, address >> 2, 1, 0);
   62    etna_cmd_stream_emit(stream, value);
   63 }
   64 
   65 static inline void
   66 etna_set_state_reloc(struct etna_cmd_stream *stream, uint32_t address,
   67                      const struct etna_reloc *reloc)
   68 {
   69    etna_cmd_stream_reserve(stream, 2);
   70    etna_emit_load_state(stream, address >> 2, 1, 0);
   71    etna_cmd_stream_reloc(stream, reloc);
   72 }
   73 
   74 static inline void
   75 etna_set_state_multi(struct etna_cmd_stream *stream, uint32_t base,
   76                      uint32_t num, const uint32_t *values)
   77 {
   78    if (num == 0)
   79       return;
   80 
   81    etna_cmd_stream_reserve(stream, 1 + num + 1); /* 1 extra for potential alignment */
   82    etna_emit_load_state(stream, base >> 2, num, 0);
   83 
   84    for (uint32_t i = 0; i < num; i++)
   85       etna_cmd_stream_emit(stream, values[i]);
   86 
   87    /* add potential padding */
   88    if ((num % 2) == 0)
   89       etna_cmd_stream_emit(stream, 0);
   90 }
   91 
   92 void
   93 etna_stall(struct etna_cmd_stream *stream, uint32_t from, uint32_t to);
   94 
   95 static inline void
   96 etna_draw_primitives(struct etna_cmd_stream *stream, uint32_t primitive_type,
   97                      uint32_t start, uint32_t count)
   98 {
   99    etna_cmd_stream_reserve(stream, 4);
  100 
  101    etna_cmd_stream_emit(stream, VIV_FE_DRAW_PRIMITIVES_HEADER_OP_DRAW_PRIMITIVES);
  102    etna_cmd_stream_emit(stream, primitive_type);
  103    etna_cmd_stream_emit(stream, start);
  104    etna_cmd_stream_emit(stream, count);
  105 }
  106 
  107 static inline void
  108 etna_draw_indexed_primitives(struct etna_cmd_stream *stream,
  109                              uint32_t primitive_type, uint32_t start,
  110                              uint32_t count, uint32_t offset)
  111 {
  112    etna_cmd_stream_reserve(stream, 5 + 1);
  113 
  114    etna_cmd_stream_emit(stream, VIV_FE_DRAW_INDEXED_PRIMITIVES_HEADER_OP_DRAW_INDEXED_PRIMITIVES);
  115    etna_cmd_stream_emit(stream, primitive_type);
  116    etna_cmd_stream_emit(stream, start);
  117    etna_cmd_stream_emit(stream, count);
  118    etna_cmd_stream_emit(stream, offset);
  119    etna_cmd_stream_emit(stream, 0);
  120 }
  121 
  122 /* important: this takes a vertex count, not a primitive count */
  123 static inline void
  124 etna_draw_instanced(struct etna_cmd_stream *stream,
  125                     uint32_t indexed, uint32_t primitive_type,
  126                     uint32_t instance_count,
  127                     uint32_t vertex_count, uint32_t offset)
  128 {
  129    etna_cmd_stream_reserve(stream, 3 + 1);
  130    etna_cmd_stream_emit(stream,
  131       VIV_FE_DRAW_INSTANCED_HEADER_OP_DRAW_INSTANCED |
  132       COND(indexed, VIV_FE_DRAW_INSTANCED_HEADER_INDEXED) |
  133       VIV_FE_DRAW_INSTANCED_HEADER_TYPE(primitive_type) |
  134       VIV_FE_DRAW_INSTANCED_HEADER_INSTANCE_COUNT_LO(instance_count & 0xffff));
  135    etna_cmd_stream_emit(stream,
  136       VIV_FE_DRAW_INSTANCED_COUNT_INSTANCE_COUNT_HI(instance_count >> 16) |
  137       VIV_FE_DRAW_INSTANCED_COUNT_VERTEX_COUNT(vertex_count));
  138    etna_cmd_stream_emit(stream,
  139       VIV_FE_DRAW_INSTANCED_START_INDEX(offset));
  140    etna_cmd_stream_emit(stream, 0);
  141 }
  142 
  143 static inline void
  144 etna_coalesce_start(struct etna_cmd_stream *stream,
  145                     struct etna_coalesce *coalesce)
  146 {
  147    coalesce->start = etna_cmd_stream_offset(stream);
  148    coalesce->last_reg = 0;
  149    coalesce->last_fixp = 0;
  150 }
  151 
  152 static inline void
  153 etna_coalesce_end(struct etna_cmd_stream *stream,
  154                   struct etna_coalesce *coalesce)
  155 {
  156    uint32_t end = etna_cmd_stream_offset(stream);
  157    uint32_t size = end - coalesce->start;
  158 
  159    if (size) {
  160       uint32_t offset = coalesce->start - 1;
  161       uint32_t value = etna_cmd_stream_get(stream, offset);
  162 
  163       value |= VIV_FE_LOAD_STATE_HEADER_COUNT(size);
  164       etna_cmd_stream_set(stream, offset, value);
  165    }
  166 
  167    /* append needed padding */
  168    if (end % 2 == 1)
  169       etna_cmd_stream_emit(stream, 0xdeadbeef);
  170 }
  171 
  172 static inline void
  173 check_coalsence(struct etna_cmd_stream *stream, struct etna_coalesce *coalesce,
  174                 uint32_t reg, uint32_t fixp)
  175 {
  176    if (coalesce->last_reg != 0) {
  177       if (((coalesce->last_reg + 4) != reg) || (coalesce->last_fixp != fixp)) {
  178          etna_coalesce_end(stream, coalesce);
  179          etna_emit_load_state(stream, reg >> 2, 0, fixp);
  180          coalesce->start = etna_cmd_stream_offset(stream);
  181       }
  182    } else {
  183       etna_emit_load_state(stream, reg >> 2, 0, fixp);
  184       coalesce->start = etna_cmd_stream_offset(stream);
  185    }
  186 
  187    coalesce->last_reg = reg;
  188    coalesce->last_fixp = fixp;
  189 }
  190 
  191 static inline void
  192 etna_coalsence_emit(struct etna_cmd_stream *stream,
  193                     struct etna_coalesce *coalesce, uint32_t reg,
  194                     uint32_t value)
  195 {
  196    check_coalsence(stream, coalesce, reg, 0);
  197    etna_cmd_stream_emit(stream, value);
  198 }
  199 
  200 static inline void
  201 etna_coalsence_emit_fixp(struct etna_cmd_stream *stream,
  202                          struct etna_coalesce *coalesce, uint32_t reg,
  203                          uint32_t value)
  204 {
  205    check_coalsence(stream, coalesce, reg, 1);
  206    etna_cmd_stream_emit(stream, value);
  207 }
  208 
  209 static inline void
  210 etna_coalsence_emit_reloc(struct etna_cmd_stream *stream,
  211                           struct etna_coalesce *coalesce, uint32_t reg,
  212                           const struct etna_reloc *r)
  213 {
  214    if (r->bo) {
  215       check_coalsence(stream, coalesce, reg, 0);
  216       etna_cmd_stream_reloc(stream, r);
  217    }
  218 }
  219 
  220 void
  221 etna_emit_state(struct etna_context *ctx);
  222 
  223 #endif