freedreno/msm/msm_ringbuffer.c

   1 /* -*- mode: C; c-file-style: "k&r"; tab-width 4; indent-tabs-mode: t; -*- */
   2
   3 /*
   4  * Copyright (C) 2013 Rob Clark <robclark@freedesktop.org>
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the "Software"),
   8  * to deal in the Software without restriction, including without limitation
   9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  10  * and/or sell copies of the Software, and to permit persons to whom the
  11  * Software is furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice (including the next
  14  * paragraph) shall be included in all copies or substantial portions of the
  15  * Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  21  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  22  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  23  * SOFTWARE.
  24  *
  25  * Authors:
  26  *    Rob Clark <robclark@freedesktop.org>
  27  */
  28
  29 #include <assert.h>
  30 #include <inttypes.h>
  31
  32 #include "freedreno_ringbuffer.h"
  33 #include "msm_priv.h"
  34
  35 /* represents a single cmd buffer in the submit ioctl.  Each cmd buffer has
  36  * a backing bo, and a reloc table.
  37  */
  38 struct msm_cmd {
  39         struct list_head list;
  40
  41         struct fd_ringbuffer *ring;
  42         struct fd_bo *ring_bo;
  43
  44         /* reloc's table: */
  45         DECLARE_ARRAY(struct drm_msm_gem_submit_reloc, relocs);
  46
  47         uint32_t size;
  48 };
  49
  50 struct msm_ringbuffer {
  51         struct fd_ringbuffer base;
  52
  53         atomic_t refcnt;
  54
  55         /* submit ioctl related tables:
  56          * Note that bos and cmds are tracked by the parent ringbuffer, since
  57          * that is global to the submit ioctl call.  The reloc's table is tracked
  58          * per cmd-buffer.
  59          */
  60         struct {
  61                 /* bo's table: */
  62                 DECLARE_ARRAY(struct drm_msm_gem_submit_bo, bos);
  63
  64                 /* cmd's table: */
  65                 DECLARE_ARRAY(struct drm_msm_gem_submit_cmd, cmds);
  66         } submit;
  67
  68         /* should have matching entries in submit.bos: */
  69         /* Note, only in parent ringbuffer */
  70         DECLARE_ARRAY(struct fd_bo *, bos);
  71
  72         /* should have matching entries in submit.cmds: */
  73         DECLARE_ARRAY(struct msm_cmd *, cmds);
  74
  75         /* List of physical cmdstream buffers (msm_cmd) assocated with this
  76          * logical fd_ringbuffer.
  77          *
  78          * Note that this is different from msm_ringbuffer::cmds (which
  79          * shadows msm_ringbuffer::submit::cmds for tracking submit ioctl
  80          * related stuff, and *only* is tracked in the parent ringbuffer.
  81          * And only has "completed" cmd buffers (ie. we already know the
  82          * size) added via get_cmd().
  83          */
  84         struct list_head cmd_list;
  85
  86         int is_growable;
  87         unsigned cmd_count;
  88
  89         unsigned seqno;
  90
  91         /* maps fd_bo to idx: */
  92         void *bo_table;
  93 };
  94
  95 static inline struct msm_ringbuffer * to_msm_ringbuffer(struct fd_ringbuffer *x)
  96 {
  97         return (struct msm_ringbuffer *)x;
  98 }
  99
 100 static void msm_ringbuffer_unref(struct fd_ringbuffer *ring);
 101 static void msm_ringbuffer_ref(struct fd_ringbuffer *ring);
 102
 103 #define INIT_SIZE 0x1000
 104
 105 static pthread_mutex_t idx_lock = PTHREAD_MUTEX_INITIALIZER;
 106
 107 static void ring_cmd_del(struct msm_cmd *cmd)
 108 {
 109         fd_bo_del(cmd->ring_bo);
 110         list_del(&cmd->list);
 111         to_msm_ringbuffer(cmd->ring)->cmd_count--;
 112         free(cmd->relocs);
 113         free(cmd);
 114 }
 115
 116 static struct msm_cmd * ring_cmd_new(struct fd_ringbuffer *ring, uint32_t size)
 117 {
 118         struct msm_ringbuffer *msm_ring = to_msm_ringbuffer(ring);
 119         struct msm_cmd *cmd = calloc(1, sizeof(*cmd));
 120
 121         if (!cmd)
 122                 return NULL;
 123
 124         cmd->ring = ring;
 125         cmd->ring_bo = fd_bo_new_ring(ring->pipe->dev, size, 0);
 126         if (!cmd->ring_bo)
 127                 goto fail;
 128
 129         list_addtail(&cmd->list, &msm_ring->cmd_list);
 130         msm_ring->cmd_count++;
 131
 132         return cmd;
 133
 134 fail:
 135         ring_cmd_del(cmd);
 136         return NULL;
 137 }
 138
 139 static struct msm_cmd *current_cmd(struct fd_ringbuffer *ring)
 140 {
 141         struct msm_ringbuffer *msm_ring = to_msm_ringbuffer(ring);
 142         assert(!LIST_IS_EMPTY(&msm_ring->cmd_list));
 143         return LIST_LAST_ENTRY(&msm_ring->cmd_list, struct msm_cmd, list);
 144 }
 145
 146 static uint32_t append_bo(struct fd_ringbuffer *ring, struct fd_bo *bo)
 147 {
 148         struct msm_ringbuffer *msm_ring = to_msm_ringbuffer(ring);
 149         uint32_t idx;
 150
 151         idx = APPEND(&msm_ring->submit, bos);
 152         idx = APPEND(msm_ring, bos);
 153
 154         msm_ring->submit.bos[idx].flags = 0;
 155         msm_ring->submit.bos[idx].handle = bo->handle;
 156         msm_ring->submit.bos[idx].presumed = to_msm_bo(bo)->presumed;
 157
 158         msm_ring->bos[idx] = fd_bo_ref(bo);
 159
 160         return idx;
 161 }
 162
 163 /* add (if needed) bo, return idx: */
 164 static uint32_t bo2idx(struct fd_ringbuffer *ring, struct fd_bo *bo, uint32_t flags)
 165 {
 166         struct msm_ringbuffer *msm_ring = to_msm_ringbuffer(ring);
 167         struct msm_bo *msm_bo = to_msm_bo(bo);
 168         uint32_t idx;
 169         pthread_mutex_lock(&idx_lock);
 170         if (msm_bo->current_ring_seqno == msm_ring->seqno) {
 171                 idx = msm_bo->idx;
 172         } else {
 173                 void *val;
 174
 175                 if (!msm_ring->bo_table)
 176                         msm_ring->bo_table = drmHashCreate();
 177
 178                 if (!drmHashLookup(msm_ring->bo_table, bo->handle, &val)) {
 179                         /* found */
 180                         idx = (uint32_t)(uintptr_t)val;
 181                 } else {
 182                         idx = append_bo(ring, bo);
 183                         val = (void *)(uintptr_t)idx;
 184                         drmHashInsert(msm_ring->bo_table, bo->handle, val);
 185                 }
 186                 msm_bo->current_ring_seqno = msm_ring->seqno;
 187                 msm_bo->idx = idx;
 188         }
 189         pthread_mutex_unlock(&idx_lock);
 190         if (flags & FD_RELOC_READ)
 191                 msm_ring->submit.bos[idx].flags |= MSM_SUBMIT_BO_READ;
 192         if (flags & FD_RELOC_WRITE)
 193                 msm_ring->submit.bos[idx].flags |= MSM_SUBMIT_BO_WRITE;
 194         return idx;
 195 }
 196
 197 static int check_cmd_bo(struct fd_ringbuffer *ring,
 198                 struct drm_msm_gem_submit_cmd *cmd, struct fd_bo *bo)
 199 {
 200         struct msm_ringbuffer *msm_ring = to_msm_ringbuffer(ring);
 201         return msm_ring->submit.bos[cmd->submit_idx].handle == bo->handle;
 202 }
 203
 204 /* Ensure that submit has corresponding entry in cmds table for the
 205  * target cmdstream buffer:
 206  *
 207  * Returns TRUE if new cmd added (else FALSE if it was already in
 208  * the cmds table)
 209  */
 210 static int get_cmd(struct fd_ringbuffer *ring, struct msm_cmd *target_cmd,
 211                 uint32_t submit_offset, uint32_t size, uint32_t type)
 212 {
 213         struct msm_ringbuffer *msm_ring = to_msm_ringbuffer(ring);
 214         struct drm_msm_gem_submit_cmd *cmd;
 215         uint32_t i;
 216
 217         /* figure out if we already have a cmd buf: */
 218         for (i = 0; i < msm_ring->submit.nr_cmds; i++) {
 219                 cmd = &msm_ring->submit.cmds[i];
 220                 if ((cmd->submit_offset == submit_offset) &&
 221                                 (cmd->size == size) &&
 222                                 (cmd->type == type) &&
 223                                 check_cmd_bo(ring, cmd, target_cmd->ring_bo))
 224                         return FALSE;
 225         }
 226
 227         /* create cmd buf if not: */
 228         i = APPEND(&msm_ring->submit, cmds);
 229         APPEND(msm_ring, cmds);
 230         msm_ring->cmds[i] = target_cmd;
 231         cmd = &msm_ring->submit.cmds[i];
 232         cmd->type = type;
 233         cmd->submit_idx = bo2idx(ring, target_cmd->ring_bo, FD_RELOC_READ);
 234         cmd->submit_offset = submit_offset;
 235         cmd->size = size;
 236         cmd->pad = 0;
 237
 238         target_cmd->size = size;
 239
 240         return TRUE;
 241 }
 242
 243 static void * msm_ringbuffer_hostptr(struct fd_ringbuffer *ring)
 244 {
 245         return fd_bo_map(current_cmd(ring)->ring_bo);
 246 }
 247
 248 static uint32_t find_next_reloc_idx(struct msm_cmd *msm_cmd,
 249                 uint32_t start, uint32_t offset)
 250 {
 251         uint32_t i;
 252
 253         /* a binary search would be more clever.. */
 254         for (i = start; i < msm_cmd->nr_relocs; i++) {
 255                 struct drm_msm_gem_submit_reloc *reloc = &msm_cmd->relocs[i];
 256                 if (reloc->submit_offset >= offset)
 257                         return i;
 258         }
 259
 260         return i;
 261 }
 262
 263 static void delete_cmds(struct msm_ringbuffer *msm_ring)
 264 {
 265         struct msm_cmd *cmd, *tmp;
 266
 267         LIST_FOR_EACH_ENTRY_SAFE(cmd, tmp, &msm_ring->cmd_list, list) {
 268                 ring_cmd_del(cmd);
 269         }
 270 }
 271
 272 static void flush_reset(struct fd_ringbuffer *ring)
 273 {
 274         struct msm_ringbuffer *msm_ring = to_msm_ringbuffer(ring);
 275         unsigned i;
 276
 277         for (i = 0; i < msm_ring->nr_bos; i++) {
 278                 struct msm_bo *msm_bo = to_msm_bo(msm_ring->bos[i]);
 279                 if (!msm_bo)
 280                         continue;
 281                 msm_bo->current_ring_seqno = 0;
 282                 fd_bo_del(&msm_bo->base);
 283         }
 284
 285         /* for each of the cmd buffers, clear their reloc's: */
 286         for (i = 0; i < msm_ring->submit.nr_cmds; i++) {
 287                 struct msm_cmd *target_cmd = msm_ring->cmds[i];
 288                 if (!target_cmd)
 289                         continue;
 290                 target_cmd->nr_relocs = 0;
 291         }
 292
 293         msm_ring->submit.nr_cmds = 0;
 294         msm_ring->submit.nr_bos = 0;
 295         msm_ring->nr_cmds = 0;
 296         msm_ring->nr_bos = 0;
 297
 298         if (msm_ring->bo_table) {
 299                 drmHashDestroy(msm_ring->bo_table);
 300                 msm_ring->bo_table = NULL;
 301         }
 302
 303         if (msm_ring->is_growable) {
 304                 delete_cmds(msm_ring);
 305         } else {
 306                 /* in old mode, just reset the # of relocs: */
 307                 current_cmd(ring)->nr_relocs = 0;
 308         }
 309 }
 310
 311 static void finalize_current_cmd(struct fd_ringbuffer *ring, uint32_t *last_start)
 312 {
 313         uint32_t submit_offset, size, type;
 314         struct fd_ringbuffer *parent;
 315
 316         if (ring->parent) {
 317                 parent = ring->parent;
 318                 type = MSM_SUBMIT_CMD_IB_TARGET_BUF;
 319         } else {
 320                 parent = ring;
 321                 type = MSM_SUBMIT_CMD_BUF;
 322         }
 323
 324         submit_offset = offset_bytes(last_start, ring->start);
 325         size = offset_bytes(ring->cur, last_start);
 326
 327         get_cmd(parent, current_cmd(ring), submit_offset, size, type);
 328 }
 329
 330 static void dump_submit(struct msm_ringbuffer *msm_ring)
 331 {
 332         uint32_t i, j;
 333
 334         for (i = 0; i < msm_ring->submit.nr_bos; i++) {
 335                 struct drm_msm_gem_submit_bo *bo = &msm_ring->submit.bos[i];
 336                 ERROR_MSG("  bos[%d]: handle=%u, flags=%x", i, bo->handle, bo->flags);
 337         }
 338         for (i = 0; i < msm_ring->submit.nr_cmds; i++) {
 339                 struct drm_msm_gem_submit_cmd *cmd = &msm_ring->submit.cmds[i];
 340                 struct drm_msm_gem_submit_reloc *relocs = U642VOID(cmd->relocs);
 341                 ERROR_MSG("  cmd[%d]: type=%u, submit_idx=%u, submit_offset=%u, size=%u",
 342                                 i, cmd->type, cmd->submit_idx, cmd->submit_offset, cmd->size);
 343                 for (j = 0; j < cmd->nr_relocs; j++) {
 344                         struct drm_msm_gem_submit_reloc *r = &relocs[j];
 345                         ERROR_MSG("    reloc[%d]: submit_offset=%u, or=%08x, shift=%d, reloc_idx=%u"
 346                                         ", reloc_offset=%"PRIu64, j, r->submit_offset, r->or, r->shift,
 347                                         r->reloc_idx, r->reloc_offset);
 348                 }
 349         }
 350 }
 351
 352 static struct drm_msm_gem_submit_reloc *
 353 handle_stateobj_relocs(struct fd_ringbuffer *parent, struct fd_ringbuffer *stateobj,
 354                 struct drm_msm_gem_submit_reloc *orig_relocs, unsigned nr_relocs)
 355 {
 356         struct msm_ringbuffer *msm_ring = to_msm_ringbuffer(stateobj);
 357         struct drm_msm_gem_submit_reloc *relocs = malloc(nr_relocs * sizeof(*relocs));
 358         unsigned i;
 359
 360         for (i = 0; i < nr_relocs; i++) {
 361                 unsigned idx = orig_relocs[i].reloc_idx;
 362                 struct fd_bo *bo = msm_ring->bos[idx];
 363                 unsigned flags = 0;
 364
 365                 if (msm_ring->submit.bos[idx].flags & MSM_SUBMIT_BO_READ)
 366                         flags |= FD_RELOC_READ;
 367                 if (msm_ring->submit.bos[idx].flags & MSM_SUBMIT_BO_WRITE)
 368                         flags |= FD_RELOC_WRITE;
 369
 370                 relocs[i] = orig_relocs[i];
 371                 relocs[i].reloc_idx = bo2idx(parent, bo, flags);
 372         }
 373
 374         return relocs;
 375 }
 376
 377 static int msm_ringbuffer_flush(struct fd_ringbuffer *ring, uint32_t *last_start,
 378                 int in_fence_fd, int *out_fence_fd)
 379 {
 380         struct msm_ringbuffer *msm_ring = to_msm_ringbuffer(ring);
 381         struct drm_msm_gem_submit req = {
 382                         .flags = to_msm_pipe(ring->pipe)->pipe,
 383                         .queueid = to_msm_pipe(ring->pipe)->queue_id,
 384         };
 385         uint32_t i;
 386         int ret;
 387
 388         assert(!ring->parent);
 389
 390         if (in_fence_fd != -1) {
 391                 req.flags |= MSM_SUBMIT_FENCE_FD_IN | MSM_SUBMIT_NO_IMPLICIT;
 392                 req.fence_fd = in_fence_fd;
 393         }
 394
 395         if (out_fence_fd) {
 396                 req.flags |= MSM_SUBMIT_FENCE_FD_OUT;
 397         }
 398
 399         finalize_current_cmd(ring, last_start);
 400
 401         /* for each of the cmd's fix up their reloc's: */
 402         for (i = 0; i < msm_ring->submit.nr_cmds; i++) {
 403                 struct drm_msm_gem_submit_cmd *cmd = &msm_ring->submit.cmds[i];
 404                 struct msm_cmd *msm_cmd = msm_ring->cmds[i];
 405                 uint32_t a = find_next_reloc_idx(msm_cmd, 0, cmd->submit_offset);
 406                 uint32_t b = find_next_reloc_idx(msm_cmd, a, cmd->submit_offset + cmd->size);
 407                 struct drm_msm_gem_submit_reloc *relocs = &msm_cmd->relocs[a];
 408                 unsigned nr_relocs = (b > a) ? b - a : 0;
 409
 410                 /* for reusable stateobjs, the reloc table has reloc_idx that
 411                  * points into it's own private bos table, rather than the global
 412                  * bos table used for the submit, so we need to add the stateobj's
 413                  * bos to the global table and construct new relocs table with
 414                  * corresponding reloc_idx
 415                  */
 416                 if (msm_cmd->ring->flags & FD_RINGBUFFER_OBJECT) {
 417                         relocs = handle_stateobj_relocs(ring, msm_cmd->ring,
 418                                         relocs, nr_relocs);
 419                 }
 420
 421                 cmd->relocs = VOID2U64(relocs);
 422                 cmd->nr_relocs = nr_relocs;
 423         }
 424
 425         /* needs to be after get_cmd() as that could create bos/cmds table: */
 426         req.bos = VOID2U64(msm_ring->submit.bos),
 427         req.nr_bos = msm_ring->submit.nr_bos;
 428         req.cmds = VOID2U64(msm_ring->submit.cmds),
 429         req.nr_cmds = msm_ring->submit.nr_cmds;
 430
 431         DEBUG_MSG("nr_cmds=%u, nr_bos=%u", req.nr_cmds, req.nr_bos);
 432
 433         ret = drmCommandWriteRead(ring->pipe->dev->fd, DRM_MSM_GEM_SUBMIT,
 434                         &req, sizeof(req));
 435         if (ret) {
 436                 ERROR_MSG("submit failed: %d (%s)", ret, strerror(errno));
 437                 dump_submit(msm_ring);
 438         } else if (!ret) {
 439                 /* update timestamp on all rings associated with submit: */
 440                 for (i = 0; i < msm_ring->submit.nr_cmds; i++) {
 441                         struct msm_cmd *msm_cmd = msm_ring->cmds[i];
 442                         msm_cmd->ring->last_timestamp = req.fence;
 443                 }
 444
 445                 if (out_fence_fd) {
 446                         *out_fence_fd = req.fence_fd;
 447                 }
 448         }
 449
 450         /* free dynamically constructed stateobj relocs tables: */
 451         for (i = 0; i < msm_ring->submit.nr_cmds; i++) {
 452                 struct drm_msm_gem_submit_cmd *cmd = &msm_ring->submit.cmds[i];
 453                 struct msm_cmd *msm_cmd = msm_ring->cmds[i];
 454                 if (msm_cmd->ring->flags & FD_RINGBUFFER_OBJECT) {
 455                         /* we could have dropped last reference: */
 456                         msm_ring->cmds[i] = NULL;
 457                         msm_ringbuffer_unref(msm_cmd->ring);
 458                         free(U642VOID(cmd->relocs));
 459                 }
 460         }
 461
 462         flush_reset(ring);
 463
 464         return ret;
 465 }
 466
 467 static void msm_ringbuffer_grow(struct fd_ringbuffer *ring, uint32_t size)
 468 {
 469         assert(to_msm_ringbuffer(ring)->is_growable);
 470         finalize_current_cmd(ring, ring->last_start);
 471         ring_cmd_new(ring, size);
 472 }
 473
 474 static void msm_ringbuffer_reset(struct fd_ringbuffer *ring)
 475 {
 476         flush_reset(ring);
 477 }
 478
 479 static void msm_ringbuffer_emit_reloc(struct fd_ringbuffer *ring,
 480                 const struct fd_reloc *r)
 481 {
 482         struct fd_ringbuffer *parent = ring->parent ? ring->parent : ring;
 483         struct msm_bo *msm_bo = to_msm_bo(r->bo);
 484         struct drm_msm_gem_submit_reloc *reloc;
 485         struct msm_cmd *cmd = current_cmd(ring);
 486         uint32_t idx = APPEND(cmd, relocs);
 487         uint32_t addr;
 488
 489         reloc = &cmd->relocs[idx];
 490
 491         reloc->reloc_idx = bo2idx(parent, r->bo, r->flags);
 492         reloc->reloc_offset = r->offset;
 493         reloc->or = r->or;
 494         reloc->shift = r->shift;
 495         reloc->submit_offset = offset_bytes(ring->cur, ring->start);
 496
 497         addr = msm_bo->presumed;
 498         if (reloc->shift < 0)
 499                 addr >>= -reloc->shift;
 500         else
 501                 addr <<= reloc->shift;
 502         (*ring->cur++) = addr | r->or;
 503
 504         if (ring->pipe->gpu_id >= 500) {
 505                 struct drm_msm_gem_submit_reloc *reloc_hi;
 506
 507                 /* NOTE: grab reloc_idx *before* APPEND() since that could
 508                  * realloc() meaning that 'reloc' ptr is no longer valid:
 509                  */
 510                 uint32_t reloc_idx = reloc->reloc_idx;
 511
 512                 idx = APPEND(cmd, relocs);
 513
 514                 reloc_hi = &cmd->relocs[idx];
 515
 516                 reloc_hi->reloc_idx = reloc_idx;
 517                 reloc_hi->reloc_offset = r->offset;
 518                 reloc_hi->or = r->orhi;
 519                 reloc_hi->shift = r->shift - 32;
 520                 reloc_hi->submit_offset = offset_bytes(ring->cur, ring->start);
 521
 522                 addr = msm_bo->presumed >> 32;
 523                 if (reloc_hi->shift < 0)
 524                         addr >>= -reloc_hi->shift;
 525                 else
 526                         addr <<= reloc_hi->shift;
 527                 (*ring->cur++) = addr | r->orhi;
 528         }
 529 }
 530
 531 static uint32_t msm_ringbuffer_emit_reloc_ring(struct fd_ringbuffer *ring,
 532                 struct fd_ringbuffer *target, uint32_t cmd_idx,
 533                 uint32_t submit_offset, uint32_t size)
 534 {
 535         struct msm_cmd *cmd = NULL;
 536         uint32_t idx = 0;
 537         int added_cmd = FALSE;
 538
 539         LIST_FOR_EACH_ENTRY(cmd, &to_msm_ringbuffer(target)->cmd_list, list) {
 540                 if (idx == cmd_idx)
 541                         break;
 542                 idx++;
 543         }
 544
 545         assert(cmd && (idx == cmd_idx));
 546
 547         if (idx < (to_msm_ringbuffer(target)->cmd_count - 1)) {
 548                 /* All but the last cmd buffer is fully "baked" (ie. already has
 549                  * done get_cmd() to add it to the cmds table).  But in this case,
 550                  * the size we get is invalid (since it is calculated from the
 551                  * last cmd buffer):
 552                  */
 553                 size = cmd->size;
 554         } else {
 555                 struct fd_ringbuffer *parent = ring->parent ? ring->parent : ring;
 556                 added_cmd = get_cmd(parent, cmd, submit_offset, size,
 557                                 MSM_SUBMIT_CMD_IB_TARGET_BUF);
 558         }
 559
 560         msm_ringbuffer_emit_reloc(ring, &(struct fd_reloc){
 561                 .bo = cmd->ring_bo,
 562                 .flags = FD_RELOC_READ,
 563                 .offset = submit_offset,
 564         });
 565
 566         /* Unlike traditional ringbuffers which are deleted as a set (after
 567          * being flushed), mesa can't really guarantee that a stateobj isn't
 568          * destroyed after emitted but before flush, so we must hold a ref:
 569          */
 570         if (added_cmd && (target->flags & FD_RINGBUFFER_OBJECT)) {
 571                 msm_ringbuffer_ref(target);
 572         }
 573
 574         return size;
 575 }
 576
 577 static uint32_t msm_ringbuffer_cmd_count(struct fd_ringbuffer *ring)
 578 {
 579         return to_msm_ringbuffer(ring)->cmd_count;
 580 }
 581
 582 static void msm_ringbuffer_unref(struct fd_ringbuffer *ring)
 583 {
 584         struct msm_ringbuffer *msm_ring = to_msm_ringbuffer(ring);
 585
 586         if (!atomic_dec_and_test(&msm_ring->refcnt))
 587                 return;
 588
 589         flush_reset(ring);
 590         delete_cmds(msm_ring);
 591
 592         free(msm_ring->submit.cmds);
 593         free(msm_ring->submit.bos);
 594         free(msm_ring->bos);
 595         free(msm_ring->cmds);
 596         free(msm_ring);
 597 }
 598
 599 static void msm_ringbuffer_ref(struct fd_ringbuffer *ring)
 600 {
 601         struct msm_ringbuffer *msm_ring = to_msm_ringbuffer(ring);
 602         atomic_inc(&msm_ring->refcnt);
 603 }
 604
 605 static const struct fd_ringbuffer_funcs funcs = {
 606                 .hostptr = msm_ringbuffer_hostptr,
 607                 .flush = msm_ringbuffer_flush,
 608                 .grow = msm_ringbuffer_grow,
 609                 .reset = msm_ringbuffer_reset,
 610                 .emit_reloc = msm_ringbuffer_emit_reloc,
 611                 .emit_reloc_ring = msm_ringbuffer_emit_reloc_ring,
 612                 .cmd_count = msm_ringbuffer_cmd_count,
 613                 .destroy = msm_ringbuffer_unref,
 614 };
 615
 616 drm_private struct fd_ringbuffer * msm_ringbuffer_new(struct fd_pipe *pipe,
 617                 uint32_t size, enum fd_ringbuffer_flags flags)
 618 {
 619         struct msm_ringbuffer *msm_ring;
 620         struct fd_ringbuffer *ring;
 621
 622         msm_ring = calloc(1, sizeof(*msm_ring));
 623         if (!msm_ring) {
 624                 ERROR_MSG("allocation failed");
 625                 return NULL;
 626         }
 627
 628         if (size == 0) {
 629                 assert(pipe->dev->version >= FD_VERSION_UNLIMITED_CMDS);
 630                 size = INIT_SIZE;
 631                 msm_ring->is_growable = TRUE;
 632         }
 633
 634         list_inithead(&msm_ring->cmd_list);
 635         msm_ring->seqno = ++to_msm_device(pipe->dev)->ring_cnt;
 636         atomic_set(&msm_ring->refcnt, 1);
 637
 638         ring = &msm_ring->base;
 639         ring->funcs = &funcs;
 640         ring->size = size;
 641         ring->pipe = pipe;   /* needed in ring_cmd_new() */
 642
 643         ring_cmd_new(ring, size);
 644
 645         return ring;
 646 }