src/etnaviv/drm/etnaviv_cmd_stream.c

   1 /*
   2  * Copyright (C) 2014-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, sublicense,
   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 next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * 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 NONINFRINGEMENT.  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 FROM,
  20  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  21  * SOFTWARE.
  22  *
  23  * Authors:
  24  *    Christian Gmeiner <christian.gmeiner@gmail.com>
  25  */
  26
  27 #include <assert.h>
  28
  29 #include "etnaviv_drmif.h"
  30 #include "etnaviv_priv.h"
  31
  32 static pthread_mutex_t idx_lock = PTHREAD_MUTEX_INITIALIZER;
  33
  34 static void *grow(void *ptr, uint32_t nr, uint32_t *max, uint32_t sz)
  35 {
  36         if ((nr + 1) > *max) {
  37                 if ((*max * 2) < (nr + 1))
  38                         *max = nr + 5;
  39                 else
  40                         *max = *max * 2;
  41                 ptr = realloc(ptr, *max * sz);
  42         }
  43
  44         return ptr;
  45 }
  46
  47 #define APPEND(x, name) ({ \
  48         (x)->name = grow((x)->name, (x)->nr_ ## name, &(x)->max_ ## name, sizeof((x)->name[0])); \
  49         (x)->nr_ ## name ++; \
  50 })
  51
  52 static inline struct etna_cmd_stream_priv *
  53 etna_cmd_stream_priv(struct etna_cmd_stream *stream)
  54 {
  55     return (struct etna_cmd_stream_priv *)stream;
  56 }
  57
  58 struct etna_cmd_stream *etna_cmd_stream_new(struct etna_pipe *pipe,
  59         uint32_t size,
  60                 void (*reset_notify)(struct etna_cmd_stream *stream, void *priv),
  61                 void *priv)
  62 {
  63         struct etna_cmd_stream_priv *stream = NULL;
  64
  65         if (size == 0) {
  66                 ERROR_MSG("invalid size of 0");
  67                 goto fail;
  68         }
  69
  70         stream = calloc(1, sizeof(*stream));
  71         if (!stream) {
  72                 ERROR_MSG("allocation failed");
  73                 goto fail;
  74         }
  75
  76         /* allocate even number of 32-bit words */
  77         size = ALIGN(size, 2);
  78
  79         stream->base.buffer = malloc(size * sizeof(uint32_t));
  80         if (!stream->base.buffer) {
  81                 ERROR_MSG("allocation failed");
  82                 goto fail;
  83         }
  84
  85         stream->base.size = size;
  86         stream->pipe = pipe;
  87         stream->reset_notify = reset_notify;
  88         stream->reset_notify_priv = priv;
  89
  90         return &stream->base;
  91
  92 fail:
  93         if (stream)
  94                 etna_cmd_stream_del(&stream->base);
  95
  96         return NULL;
  97 }
  98
  99 void etna_cmd_stream_del(struct etna_cmd_stream *stream)
 100 {
 101         struct etna_cmd_stream_priv *priv = etna_cmd_stream_priv(stream);
 102
 103         free(stream->buffer);
 104         free(priv->submit.relocs);
 105         free(priv->submit.pmrs);
 106         free(priv);
 107 }
 108
 109 static void reset_buffer(struct etna_cmd_stream *stream)
 110 {
 111         struct etna_cmd_stream_priv *priv = etna_cmd_stream_priv(stream);
 112
 113         stream->offset = 0;
 114         priv->submit.nr_bos = 0;
 115         priv->submit.nr_relocs = 0;
 116         priv->submit.nr_pmrs = 0;
 117         priv->nr_bos = 0;
 118
 119         if (priv->reset_notify)
 120                 priv->reset_notify(stream, priv->reset_notify_priv);
 121 }
 122
 123 uint32_t etna_cmd_stream_timestamp(struct etna_cmd_stream *stream)
 124 {
 125         return etna_cmd_stream_priv(stream)->last_timestamp;
 126 }
 127
 128 static uint32_t append_bo(struct etna_cmd_stream *stream, struct etna_bo *bo)
 129 {
 130         struct etna_cmd_stream_priv *priv = etna_cmd_stream_priv(stream);
 131         uint32_t idx;
 132
 133         idx = APPEND(&priv->submit, bos);
 134         idx = APPEND(priv, bos);
 135
 136         priv->submit.bos[idx].flags = 0;
 137         priv->submit.bos[idx].handle = bo->handle;
 138
 139         priv->bos[idx] = etna_bo_ref(bo);
 140
 141         return idx;
 142 }
 143
 144 /* add (if needed) bo, return idx: */
 145 static uint32_t bo2idx(struct etna_cmd_stream *stream, struct etna_bo *bo,
 146                 uint32_t flags)
 147 {
 148         struct etna_cmd_stream_priv *priv = etna_cmd_stream_priv(stream);
 149         uint32_t idx;
 150
 151         pthread_mutex_lock(&idx_lock);
 152
 153         if (bo->current_stream == stream) {
 154                 idx = bo->idx;
 155         } else {
 156                 void *val;
 157
 158                 if (!priv->bo_table)
 159                         priv->bo_table = drmHashCreate();
 160
 161                 if (!drmHashLookup(priv->bo_table, bo->handle, &val)) {
 162                         /* found */
 163                         idx = (uint32_t)(uintptr_t)val;
 164                 } else {
 165                         idx = append_bo(stream, bo);
 166                         val = (void *)(uintptr_t)idx;
 167                         drmHashInsert(priv->bo_table, bo->handle, val);
 168                 }
 169
 170                 bo->current_stream = stream;
 171                 bo->idx = idx;
 172         }
 173         pthread_mutex_unlock(&idx_lock);
 174
 175         if (flags & ETNA_RELOC_READ)
 176                 priv->submit.bos[idx].flags |= ETNA_SUBMIT_BO_READ;
 177         if (flags & ETNA_RELOC_WRITE)
 178                 priv->submit.bos[idx].flags |= ETNA_SUBMIT_BO_WRITE;
 179
 180         return idx;
 181 }
 182
 183 static void flush(struct etna_cmd_stream *stream, int in_fence_fd,
 184                   int *out_fence_fd)
 185 {
 186         struct etna_cmd_stream_priv *priv = etna_cmd_stream_priv(stream);
 187         int ret, id = priv->pipe->id;
 188         struct etna_gpu *gpu = priv->pipe->gpu;
 189
 190         struct drm_etnaviv_gem_submit req = {
 191                 .pipe = gpu->core,
 192                 .exec_state = id,
 193                 .bos = VOID2U64(priv->submit.bos),
 194                 .nr_bos = priv->submit.nr_bos,
 195                 .relocs = VOID2U64(priv->submit.relocs),
 196                 .nr_relocs = priv->submit.nr_relocs,
 197                 .pmrs = VOID2U64(priv->submit.pmrs),
 198                 .nr_pmrs = priv->submit.nr_pmrs,
 199                 .stream = VOID2U64(stream->buffer),
 200                 .stream_size = stream->offset * 4, /* in bytes */
 201         };
 202
 203         if (in_fence_fd != -1) {
 204                 req.flags |= ETNA_SUBMIT_FENCE_FD_IN | ETNA_SUBMIT_NO_IMPLICIT;
 205                 req.fence_fd = in_fence_fd;
 206         }
 207
 208         if (out_fence_fd)
 209                 req.flags |= ETNA_SUBMIT_FENCE_FD_OUT;
 210
 211         ret = drmCommandWriteRead(gpu->dev->fd, DRM_ETNAVIV_GEM_SUBMIT,
 212                         &req, sizeof(req));
 213
 214         if (ret)
 215                 ERROR_MSG("submit failed: %d (%s)", ret, strerror(errno));
 216         else
 217                 priv->last_timestamp = req.fence;
 218
 219         for (uint32_t i = 0; i < priv->nr_bos; i++) {
 220                 struct etna_bo *bo = priv->bos[i];
 221
 222                 bo->current_stream = NULL;
 223                 etna_bo_del(bo);
 224         }
 225
 226         if (priv->bo_table) {
 227                 drmHashDestroy(priv->bo_table);
 228                 priv->bo_table = NULL;
 229         }
 230
 231         if (out_fence_fd)
 232                 *out_fence_fd = req.fence_fd;
 233 }
 234
 235 void etna_cmd_stream_flush(struct etna_cmd_stream *stream)
 236 {
 237         flush(stream, -1, NULL);
 238         reset_buffer(stream);
 239 }
 240
 241 void etna_cmd_stream_flush2(struct etna_cmd_stream *stream,
 242                                                                            int in_fence_fd,
 243                                                                            int *out_fence_fd)
 244 {
 245         flush(stream, in_fence_fd, out_fence_fd);
 246         reset_buffer(stream);
 247 }
 248
 249 void etna_cmd_stream_finish(struct etna_cmd_stream *stream)
 250 {
 251         struct etna_cmd_stream_priv *priv = etna_cmd_stream_priv(stream);
 252
 253         flush(stream, -1, NULL);
 254         etna_pipe_wait(priv->pipe, priv->last_timestamp, 5000);
 255         reset_buffer(stream);
 256 }
 257
 258 void etna_cmd_stream_reloc(struct etna_cmd_stream *stream,
 259                                                                           const struct etna_reloc *r)
 260 {
 261         struct etna_cmd_stream_priv *priv = etna_cmd_stream_priv(stream);
 262         struct drm_etnaviv_gem_submit_reloc *reloc;
 263         uint32_t idx = APPEND(&priv->submit, relocs);
 264         uint32_t addr = 0;
 265
 266         reloc = &priv->submit.relocs[idx];
 267
 268         reloc->reloc_idx = bo2idx(stream, r->bo, r->flags);
 269         reloc->reloc_offset = r->offset;
 270         reloc->submit_offset = stream->offset * 4; /* in bytes */
 271         reloc->flags = 0;
 272
 273         etna_cmd_stream_emit(stream, addr);
 274 }
 275
 276 void etna_cmd_stream_perf(struct etna_cmd_stream *stream, const struct etna_perf *p)
 277 {
 278         struct etna_cmd_stream_priv *priv = etna_cmd_stream_priv(stream);
 279         struct drm_etnaviv_gem_submit_pmr *pmr;
 280         uint32_t idx = APPEND(&priv->submit, pmrs);
 281
 282         pmr = &priv->submit.pmrs[idx];
 283
 284         pmr->flags = p->flags;
 285         pmr->sequence = p->sequence;
 286         pmr->read_offset = p->offset;
 287         pmr->read_idx = bo2idx(stream, p->bo, ETNA_SUBMIT_BO_READ | ETNA_SUBMIT_BO_WRITE);
 288         pmr->domain = p->signal->domain->id;
 289         pmr->signal = p->signal->signal;
 290 }