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 #include <stdlib.h>
  29
  30 #include "etnaviv_drmif.h"
  31 #include "etnaviv_priv.h"
  32
  33 static pthread_mutex_t idx_lock = PTHREAD_MUTEX_INITIALIZER;
  34
  35 static void *grow(void *ptr, uint32_t nr, uint32_t *max, uint32_t sz)
  36 {
  37         if ((nr + 1) > *max) {
  38                 if ((*max * 2) < (nr + 1))
  39                         *max = nr + 5;
  40                 else
  41                         *max = *max * 2;
  42                 ptr = realloc(ptr, *max * sz);
  43         }
  44
  45         return ptr;
  46 }
  47
  48 #define APPEND(x, name) ({ \
  49         (x)->name = grow((x)->name, (x)->nr_ ## name, &(x)->max_ ## name, sizeof((x)->name[0])); \
  50         (x)->nr_ ## name ++; \
  51 })
  52
  53 void etna_cmd_stream_realloc(struct etna_cmd_stream *stream, size_t n)
  54 {
  55         size_t size;
  56         void *buffer;
  57
  58         /*
  59          * Increase the command buffer size by 1 kiB. Here we pick 1 kiB
  60          * increment to prevent it from growing too much too quickly.
  61          */
  62         size = ALIGN(stream->size + n, 1024);
  63
  64         /* Command buffer is too big for older kernel versions */
  65         if (size >= 32768)
  66                 goto error;
  67
  68         buffer = realloc(stream->buffer, size * 4);
  69         if (!buffer)
  70                 goto error;
  71
  72         stream->buffer = buffer;
  73         stream->size = size;
  74
  75         return;
  76
  77 error:
  78         WARN_MSG("command buffer too long, forcing flush.");
  79         etna_cmd_stream_force_flush(stream);
  80 }
  81
  82 static inline struct etna_cmd_stream_priv *
  83 etna_cmd_stream_priv(struct etna_cmd_stream *stream)
  84 {
  85     return (struct etna_cmd_stream_priv *)stream;
  86 }
  87
  88 struct etna_cmd_stream *etna_cmd_stream_new(struct etna_pipe *pipe,
  89         uint32_t size,
  90                 void (*force_flush)(struct etna_cmd_stream *stream, void *priv),
  91                 void *priv)
  92 {
  93         struct etna_cmd_stream_priv *stream = NULL;
  94
  95         if (size == 0) {
  96                 ERROR_MSG("invalid size of 0");
  97                 goto fail;
  98         }
  99
 100         stream = calloc(1, sizeof(*stream));
 101         if (!stream) {
 102                 ERROR_MSG("allocation failed");
 103                 goto fail;
 104         }
 105
 106         /* allocate even number of 32-bit words */
 107         size = ALIGN(size, 2);
 108
 109         stream->base.buffer = malloc(size * sizeof(uint32_t));
 110         if (!stream->base.buffer) {
 111                 ERROR_MSG("allocation failed");
 112                 goto fail;
 113         }
 114
 115         stream->base.size = size;
 116         stream->pipe = pipe;
 117         stream->force_flush = force_flush;
 118         stream->force_flush_priv = priv;
 119
 120         return &stream->base;
 121
 122 fail:
 123         if (stream)
 124                 etna_cmd_stream_del(&stream->base);
 125
 126         return NULL;
 127 }
 128
 129 void etna_cmd_stream_del(struct etna_cmd_stream *stream)
 130 {
 131         struct etna_cmd_stream_priv *priv = etna_cmd_stream_priv(stream);
 132
 133         free(stream->buffer);
 134         free(priv->submit.relocs);
 135         free(priv->submit.pmrs);
 136         free(priv);
 137 }
 138
 139 void etna_cmd_stream_force_flush(struct etna_cmd_stream *stream)
 140 {
 141         struct etna_cmd_stream_priv *priv = etna_cmd_stream_priv(stream);
 142
 143         if (priv->force_flush)
 144                 priv->force_flush(stream, priv->force_flush_priv);
 145 }
 146
 147 uint32_t etna_cmd_stream_timestamp(struct etna_cmd_stream *stream)
 148 {
 149         return etna_cmd_stream_priv(stream)->last_timestamp;
 150 }
 151
 152 static uint32_t append_bo(struct etna_cmd_stream *stream, struct etna_bo *bo)
 153 {
 154         struct etna_cmd_stream_priv *priv = etna_cmd_stream_priv(stream);
 155         uint32_t idx;
 156
 157         idx = APPEND(&priv->submit, bos);
 158         idx = APPEND(priv, bos);
 159
 160         priv->submit.bos[idx].flags = 0;
 161         priv->submit.bos[idx].handle = bo->handle;
 162         priv->submit.bos[idx].presumed = bo->va;
 163
 164         priv->bos[idx] = etna_bo_ref(bo);
 165
 166         return idx;
 167 }
 168
 169 /* add (if needed) bo, return idx: */
 170 static uint32_t bo2idx(struct etna_cmd_stream *stream, struct etna_bo *bo,
 171                 uint32_t flags)
 172 {
 173         struct etna_cmd_stream_priv *priv = etna_cmd_stream_priv(stream);
 174         uint32_t idx;
 175
 176         pthread_mutex_lock(&idx_lock);
 177
 178         if (bo->current_stream == stream) {
 179                 idx = bo->idx;
 180         } else {
 181                 void *val;
 182
 183                 if (!priv->bo_table)
 184                         priv->bo_table = drmHashCreate();
 185
 186                 if (!drmHashLookup(priv->bo_table, bo->handle, &val)) {
 187                         /* found */
 188                         idx = (uint32_t)(uintptr_t)val;
 189                 } else {
 190                         idx = append_bo(stream, bo);
 191                         val = (void *)(uintptr_t)idx;
 192                         drmHashInsert(priv->bo_table, bo->handle, val);
 193                 }
 194
 195                 bo->current_stream = stream;
 196                 bo->idx = idx;
 197         }
 198         pthread_mutex_unlock(&idx_lock);
 199
 200         if (flags & ETNA_RELOC_READ)
 201                 priv->submit.bos[idx].flags |= ETNA_SUBMIT_BO_READ;
 202         if (flags & ETNA_RELOC_WRITE)
 203                 priv->submit.bos[idx].flags |= ETNA_SUBMIT_BO_WRITE;
 204
 205         return idx;
 206 }
 207
 208 void etna_cmd_stream_flush(struct etna_cmd_stream *stream, int in_fence_fd,
 209                 int *out_fence_fd)
 210 {
 211         struct etna_cmd_stream_priv *priv = etna_cmd_stream_priv(stream);
 212         int ret, id = priv->pipe->id;
 213         struct etna_gpu *gpu = priv->pipe->gpu;
 214
 215         struct drm_etnaviv_gem_submit req = {
 216                 .pipe = gpu->core,
 217                 .exec_state = id,
 218                 .bos = VOID2U64(priv->submit.bos),
 219                 .nr_bos = priv->submit.nr_bos,
 220                 .relocs = VOID2U64(priv->submit.relocs),
 221                 .nr_relocs = priv->submit.nr_relocs,
 222                 .pmrs = VOID2U64(priv->submit.pmrs),
 223                 .nr_pmrs = priv->submit.nr_pmrs,
 224                 .stream = VOID2U64(stream->buffer),
 225                 .stream_size = stream->offset * 4, /* in bytes */
 226         };
 227
 228         if (in_fence_fd != -1) {
 229                 req.flags |= ETNA_SUBMIT_FENCE_FD_IN | ETNA_SUBMIT_NO_IMPLICIT;
 230                 req.fence_fd = in_fence_fd;
 231         }
 232
 233         if (out_fence_fd)
 234                 req.flags |= ETNA_SUBMIT_FENCE_FD_OUT;
 235
 236         if (gpu->dev->use_softpin)
 237                 req.flags |= ETNA_SUBMIT_SOFTPIN;
 238
 239         ret = drmCommandWriteRead(gpu->dev->fd, DRM_ETNAVIV_GEM_SUBMIT,
 240                         &req, sizeof(req));
 241
 242         if (ret)
 243                 ERROR_MSG("submit failed: %d (%s)", ret, strerror(errno));
 244         else
 245                 priv->last_timestamp = req.fence;
 246
 247         for (uint32_t i = 0; i < priv->nr_bos; i++) {
 248                 struct etna_bo *bo = priv->bos[i];
 249
 250                 bo->current_stream = NULL;
 251                 etna_bo_del(bo);
 252         }
 253
 254         if (priv->bo_table) {
 255                 drmHashDestroy(priv->bo_table);
 256                 priv->bo_table = NULL;
 257         }
 258
 259         if (out_fence_fd)
 260                 *out_fence_fd = req.fence_fd;
 261
 262         stream->offset = 0;
 263         priv->submit.nr_bos = 0;
 264         priv->submit.nr_relocs = 0;
 265         priv->submit.nr_pmrs = 0;
 266         priv->nr_bos = 0;
 267 }
 268
 269 void etna_cmd_stream_reloc(struct etna_cmd_stream *stream,
 270                                                                           const struct etna_reloc *r)
 271 {
 272         struct etna_cmd_stream_priv *priv = etna_cmd_stream_priv(stream);
 273         struct drm_etnaviv_gem_submit_reloc *reloc;
 274         uint32_t addr = r->bo->va + r->offset;
 275         uint32_t bo_idx = bo2idx(stream, r->bo, r->flags);
 276         uint32_t idx;
 277
 278         if (!priv->pipe->gpu->dev->use_softpin) {
 279                 idx = APPEND(&priv->submit, relocs);
 280                 reloc = &priv->submit.relocs[idx];
 281
 282                 reloc->reloc_idx = bo_idx;
 283                 reloc->reloc_offset = r->offset;
 284                 reloc->submit_offset = stream->offset * 4; /* in bytes */
 285                 reloc->flags = 0;
 286         }
 287
 288         etna_cmd_stream_emit(stream, addr);
 289 }
 290
 291 void etna_cmd_stream_ref_bo(struct etna_cmd_stream *stream, struct etna_bo *bo,
 292                 uint32_t flags)
 293 {
 294         bo2idx(stream, bo, flags);
 295 }
 296
 297 void etna_cmd_stream_perf(struct etna_cmd_stream *stream, const struct etna_perf *p)
 298 {
 299         struct etna_cmd_stream_priv *priv = etna_cmd_stream_priv(stream);
 300         struct drm_etnaviv_gem_submit_pmr *pmr;
 301         uint32_t idx = APPEND(&priv->submit, pmrs);
 302
 303         pmr = &priv->submit.pmrs[idx];
 304
 305         pmr->flags = p->flags;
 306         pmr->sequence = p->sequence;
 307         pmr->read_offset = p->offset;
 308         pmr->read_idx = bo2idx(stream, p->bo, ETNA_SUBMIT_BO_READ | ETNA_SUBMIT_BO_WRITE);
 309         pmr->domain = p->signal->domain->id;
 310         pmr->signal = p->signal->signal;
 311 }