etnaviv/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 drm_public 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 drm_public 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 drm_public 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                 /* slow-path: */
 157                 for (idx = 0; idx < priv->nr_bos; idx++)
 158                         if (priv->bos[idx] == bo)
 159                                 break;
 160                 if (idx == priv->nr_bos) {
 161                         /* not found */
 162                         idx = append_bo(stream, bo);
 163                 }
 164                 bo->current_stream = stream;
 165                 bo->idx = idx;
 166         }
 167         pthread_mutex_unlock(&idx_lock);
 168
 169         if (flags & ETNA_RELOC_READ)
 170                 priv->submit.bos[idx].flags |= ETNA_SUBMIT_BO_READ;
 171         if (flags & ETNA_RELOC_WRITE)
 172                 priv->submit.bos[idx].flags |= ETNA_SUBMIT_BO_WRITE;
 173
 174         return idx;
 175 }
 176
 177 static void flush(struct etna_cmd_stream *stream, int in_fence_fd,
 178                   int *out_fence_fd)
 179 {
 180         struct etna_cmd_stream_priv *priv = etna_cmd_stream_priv(stream);
 181         int ret, id = priv->pipe->id;
 182         struct etna_gpu *gpu = priv->pipe->gpu;
 183
 184         struct drm_etnaviv_gem_submit req = {
 185                 .pipe = gpu->core,
 186                 .exec_state = id,
 187                 .bos = VOID2U64(priv->submit.bos),
 188                 .nr_bos = priv->submit.nr_bos,
 189                 .relocs = VOID2U64(priv->submit.relocs),
 190                 .nr_relocs = priv->submit.nr_relocs,
 191                 .pmrs = VOID2U64(priv->submit.pmrs),
 192                 .nr_pmrs = priv->submit.nr_pmrs,
 193                 .stream = VOID2U64(stream->buffer),
 194                 .stream_size = stream->offset * 4, /* in bytes */
 195         };
 196
 197         if (in_fence_fd != -1) {
 198                 req.flags |= ETNA_SUBMIT_FENCE_FD_IN | ETNA_SUBMIT_NO_IMPLICIT;
 199                 req.fence_fd = in_fence_fd;
 200         }
 201
 202         if (out_fence_fd)
 203                 req.flags |= ETNA_SUBMIT_FENCE_FD_OUT;
 204
 205         ret = drmCommandWriteRead(gpu->dev->fd, DRM_ETNAVIV_GEM_SUBMIT,
 206                         &req, sizeof(req));
 207
 208         if (ret)
 209                 ERROR_MSG("submit failed: %d (%s)", ret, strerror(errno));
 210         else
 211                 priv->last_timestamp = req.fence;
 212
 213         for (uint32_t i = 0; i < priv->nr_bos; i++) {
 214                 struct etna_bo *bo = priv->bos[i];
 215
 216                 bo->current_stream = NULL;
 217                 etna_bo_del(bo);
 218         }
 219
 220         if (out_fence_fd)
 221                 *out_fence_fd = req.fence_fd;
 222 }
 223
 224 drm_public void etna_cmd_stream_flush(struct etna_cmd_stream *stream)
 225 {
 226         flush(stream, -1, NULL);
 227         reset_buffer(stream);
 228 }
 229
 230 drm_public void etna_cmd_stream_flush2(struct etna_cmd_stream *stream,
 231                                                                            int in_fence_fd,
 232                                                                            int *out_fence_fd)
 233 {
 234         flush(stream, in_fence_fd, out_fence_fd);
 235         reset_buffer(stream);
 236 }
 237
 238 drm_public void etna_cmd_stream_finish(struct etna_cmd_stream *stream)
 239 {
 240         struct etna_cmd_stream_priv *priv = etna_cmd_stream_priv(stream);
 241
 242         flush(stream, -1, NULL);
 243         etna_pipe_wait(priv->pipe, priv->last_timestamp, 5000);
 244         reset_buffer(stream);
 245 }
 246
 247 drm_public void etna_cmd_stream_reloc(struct etna_cmd_stream *stream,
 248                                                                           const struct etna_reloc *r)
 249 {
 250         struct etna_cmd_stream_priv *priv = etna_cmd_stream_priv(stream);
 251         struct drm_etnaviv_gem_submit_reloc *reloc;
 252         uint32_t idx = APPEND(&priv->submit, relocs);
 253         uint32_t addr = 0;
 254
 255         reloc = &priv->submit.relocs[idx];
 256
 257         reloc->reloc_idx = bo2idx(stream, r->bo, r->flags);
 258         reloc->reloc_offset = r->offset;
 259         reloc->submit_offset = stream->offset * 4; /* in bytes */
 260         reloc->flags = 0;
 261
 262         etna_cmd_stream_emit(stream, addr);
 263 }
 264
 265 drm_public void etna_cmd_stream_perf(struct etna_cmd_stream *stream, const struct etna_perf *p)
 266 {
 267         struct etna_cmd_stream_priv *priv = etna_cmd_stream_priv(stream);
 268         struct drm_etnaviv_gem_submit_pmr *pmr;
 269         uint32_t idx = APPEND(&priv->submit, pmrs);
 270
 271         pmr = &priv->submit.pmrs[idx];
 272
 273         pmr->flags = p->flags;
 274         pmr->sequence = p->sequence;
 275         pmr->read_offset = p->offset;
 276         pmr->read_idx = bo2idx(stream, p->bo, ETNA_SUBMIT_BO_READ | ETNA_SUBMIT_BO_WRITE);
 277         pmr->domain = p->signal->domain->id;
 278         pmr->signal = p->signal->signal;
 279 }