src/freedreno/drm/msm_ringbuffer.c

   1 /*
   2  * Copyright (C) 2012-2018 Rob Clark <robclark@freedesktop.org>
   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  *    Rob Clark <robclark@freedesktop.org>
  25  */
  26
  27 #include <assert.h>
  28 #include <inttypes.h>
  29
  30 #include "util/hash_table.h"
  31 #include "util/set.h"
  32 #include "util/slab.h"
  33
  34 #include "drm/freedreno_ringbuffer.h"
  35 #include "msm_priv.h"
  36
  37 /* The legacy implementation of submit/ringbuffer, which still does the
  38  * traditional reloc and cmd tracking
  39  */
  40
  41
  42 #define INIT_SIZE 0x1000
  43
  44
  45 struct msm_submit {
  46         struct fd_submit base;
  47
  48         DECLARE_ARRAY(struct drm_msm_gem_submit_bo, submit_bos);
  49         DECLARE_ARRAY(struct fd_bo *, bos);
  50
  51         /* maps fd_bo to idx in bos table: */
  52         struct hash_table *bo_table;
  53
  54         struct slab_mempool ring_pool;
  55
  56         /* hash-set of associated rings: */
  57         struct set *ring_set;
  58
  59         struct fd_ringbuffer *primary;
  60
  61         /* Allow for sub-allocation of stateobj ring buffers (ie. sharing
  62          * the same underlying bo)..
  63          *
  64          * We also rely on previous stateobj having been fully constructed
  65          * so we can reclaim extra space at it's end.
  66          */
  67         struct fd_ringbuffer *suballoc_ring;
  68 };
  69 FD_DEFINE_CAST(fd_submit, msm_submit);
  70
  71 /* for FD_RINGBUFFER_GROWABLE rb's, tracks the 'finalized' cmdstream buffers
  72  * and sizes.  Ie. a finalized buffer can have no more commands appended to
  73  * it.
  74  */
  75 struct msm_cmd {
  76         struct fd_bo *ring_bo;
  77         unsigned size;
  78         DECLARE_ARRAY(struct drm_msm_gem_submit_reloc, relocs);
  79 };
  80
  81 static struct msm_cmd *
  82 cmd_new(struct fd_bo *ring_bo)
  83 {
  84         struct msm_cmd *cmd = malloc(sizeof(*cmd));
  85         cmd->ring_bo = fd_bo_ref(ring_bo);
  86         cmd->size = 0;
  87         cmd->nr_relocs = cmd->max_relocs = 0;
  88         cmd->relocs = NULL;
  89         return cmd;
  90 }
  91
  92 static void
  93 cmd_free(struct msm_cmd *cmd)
  94 {
  95         fd_bo_del(cmd->ring_bo);
  96         free(cmd->relocs);
  97         free(cmd);
  98 }
  99
 100 struct msm_ringbuffer {
 101         struct fd_ringbuffer base;
 102
 103         /* for FD_RINGBUFFER_STREAMING rb's which are sub-allocated */
 104         unsigned offset;
 105
 106         union {
 107                 /* for _FD_RINGBUFFER_OBJECT case: */
 108                 struct {
 109                         struct fd_pipe *pipe;
 110                         DECLARE_ARRAY(struct fd_bo *, reloc_bos);
 111                         struct set *ring_set;
 112                 };
 113                 /* for other cases: */
 114                 struct {
 115                         struct fd_submit *submit;
 116                         DECLARE_ARRAY(struct msm_cmd *, cmds);
 117                 };
 118         } u;
 119
 120         struct msm_cmd *cmd;          /* current cmd */
 121         struct fd_bo *ring_bo;
 122 };
 123 FD_DEFINE_CAST(fd_ringbuffer, msm_ringbuffer);
 124
 125 static void finalize_current_cmd(struct fd_ringbuffer *ring);
 126 static struct fd_ringbuffer * msm_ringbuffer_init(
 127                 struct msm_ringbuffer *msm_ring,
 128                 uint32_t size, enum fd_ringbuffer_flags flags);
 129
 130 /* add (if needed) bo to submit and return index: */
 131 static uint32_t
 132 append_bo(struct msm_submit *submit, struct fd_bo *bo)
 133 {
 134         struct msm_bo *msm_bo = to_msm_bo(bo);
 135         uint32_t idx;
 136
 137         /* NOTE: it is legal to use the same bo on different threads for
 138          * different submits.  But it is not legal to use the same submit
 139          * from given threads.
 140          */
 141         idx = READ_ONCE(msm_bo->idx);
 142
 143         if (unlikely((idx >= submit->nr_submit_bos) ||
 144                         (submit->submit_bos[idx].handle != bo->handle))) {
 145                 uint32_t hash = _mesa_hash_pointer(bo);
 146                 struct hash_entry *entry;
 147
 148                 entry = _mesa_hash_table_search_pre_hashed(submit->bo_table, hash, bo);
 149                 if (entry) {
 150                         /* found */
 151                         idx = (uint32_t)(uintptr_t)entry->data;
 152                 } else {
 153                         idx = APPEND(submit, submit_bos);
 154                         idx = APPEND(submit, bos);
 155
 156                         submit->submit_bos[idx].flags = bo->flags;
 157                         submit->submit_bos[idx].handle = bo->handle;
 158                         submit->submit_bos[idx].presumed = 0;
 159
 160                         submit->bos[idx] = fd_bo_ref(bo);
 161
 162                         _mesa_hash_table_insert_pre_hashed(submit->bo_table, hash, bo,
 163                                         (void *)(uintptr_t)idx);
 164                 }
 165                 msm_bo->idx = idx;
 166         }
 167
 168         return idx;
 169 }
 170
 171 static void
 172 append_ring(struct set *set, struct fd_ringbuffer *ring)
 173 {
 174         uint32_t hash = _mesa_hash_pointer(ring);
 175
 176         if (!_mesa_set_search_pre_hashed(set, hash, ring)) {
 177                 fd_ringbuffer_ref(ring);
 178                 _mesa_set_add_pre_hashed(set, hash, ring);
 179         }
 180 }
 181
 182 static void
 183 msm_submit_suballoc_ring_bo(struct fd_submit *submit,
 184                 struct msm_ringbuffer *msm_ring, uint32_t size)
 185 {
 186         struct msm_submit *msm_submit = to_msm_submit(submit);
 187         unsigned suballoc_offset = 0;
 188         struct fd_bo *suballoc_bo = NULL;
 189
 190         if (msm_submit->suballoc_ring) {
 191                 struct msm_ringbuffer *suballoc_ring =
 192                                 to_msm_ringbuffer(msm_submit->suballoc_ring);
 193
 194                 suballoc_bo = suballoc_ring->ring_bo;
 195                 suballoc_offset = fd_ringbuffer_size(msm_submit->suballoc_ring) +
 196                                 suballoc_ring->offset;
 197
 198                 suballoc_offset = align(suballoc_offset, 0x10);
 199
 200                 if ((size + suballoc_offset) > suballoc_bo->size) {
 201                         suballoc_bo = NULL;
 202                 }
 203         }
 204
 205         if (!suballoc_bo) {
 206                 // TODO possibly larger size for streaming bo?
 207                 msm_ring->ring_bo = fd_bo_new_ring(submit->pipe->dev, 0x8000);
 208                 msm_ring->offset = 0;
 209         } else {
 210                 msm_ring->ring_bo = fd_bo_ref(suballoc_bo);
 211                 msm_ring->offset = suballoc_offset;
 212         }
 213
 214         struct fd_ringbuffer *old_suballoc_ring = msm_submit->suballoc_ring;
 215
 216         msm_submit->suballoc_ring = fd_ringbuffer_ref(&msm_ring->base);
 217
 218         if (old_suballoc_ring)
 219                 fd_ringbuffer_del(old_suballoc_ring);
 220 }
 221
 222 static struct fd_ringbuffer *
 223 msm_submit_new_ringbuffer(struct fd_submit *submit, uint32_t size,
 224                 enum fd_ringbuffer_flags flags)
 225 {
 226         struct msm_submit *msm_submit = to_msm_submit(submit);
 227         struct msm_ringbuffer *msm_ring;
 228
 229         msm_ring = slab_alloc_st(&msm_submit->ring_pool);
 230
 231         msm_ring->u.submit = submit;
 232
 233         /* NOTE: needs to be before _suballoc_ring_bo() since it could
 234          * increment the refcnt of the current ring
 235          */
 236         msm_ring->base.refcnt = 1;
 237
 238         if (flags & FD_RINGBUFFER_STREAMING) {
 239                 msm_submit_suballoc_ring_bo(submit, msm_ring, size);
 240         } else {
 241                 if (flags & FD_RINGBUFFER_GROWABLE)
 242                         size = INIT_SIZE;
 243
 244                 msm_ring->offset = 0;
 245                 msm_ring->ring_bo = fd_bo_new_ring(submit->pipe->dev, size);
 246         }
 247
 248         if (!msm_ringbuffer_init(msm_ring, size, flags))
 249                 return NULL;
 250
 251         if (flags & FD_RINGBUFFER_PRIMARY) {
 252                 debug_assert(!msm_submit->primary);
 253                 msm_submit->primary = fd_ringbuffer_ref(&msm_ring->base);
 254         }
 255
 256         return &msm_ring->base;
 257 }
 258
 259 static struct drm_msm_gem_submit_reloc *
 260 handle_stateobj_relocs(struct msm_submit *submit, struct msm_ringbuffer *ring)
 261 {
 262         struct msm_cmd *cmd = ring->cmd;
 263         struct drm_msm_gem_submit_reloc *relocs;
 264
 265         relocs = malloc(cmd->nr_relocs * sizeof(*relocs));
 266
 267         for (unsigned i = 0; i < cmd->nr_relocs; i++) {
 268                 unsigned idx = cmd->relocs[i].reloc_idx;
 269                 struct fd_bo *bo = ring->u.reloc_bos[idx];
 270
 271                 relocs[i] = cmd->relocs[i];
 272                 relocs[i].reloc_idx = append_bo(submit, bo);
 273         }
 274
 275         return relocs;
 276 }
 277
 278 static int
 279 msm_submit_flush(struct fd_submit *submit, int in_fence_fd,
 280                 int *out_fence_fd, uint32_t *out_fence)
 281 {
 282         struct msm_submit *msm_submit = to_msm_submit(submit);
 283         struct msm_pipe *msm_pipe = to_msm_pipe(submit->pipe);
 284         struct drm_msm_gem_submit req = {
 285                         .flags = msm_pipe->pipe,
 286                         .queueid = msm_pipe->queue_id,
 287         };
 288         int ret;
 289
 290         debug_assert(msm_submit->primary);
 291
 292         finalize_current_cmd(msm_submit->primary);
 293         append_ring(msm_submit->ring_set, msm_submit->primary);
 294
 295         unsigned nr_cmds = 0;
 296         unsigned nr_objs = 0;
 297
 298         set_foreach(msm_submit->ring_set, entry) {
 299                 struct fd_ringbuffer *ring = (void *)entry->key;
 300                 if (ring->flags & _FD_RINGBUFFER_OBJECT) {
 301                         nr_cmds += 1;
 302                         nr_objs += 1;
 303                 } else {
 304                         if (ring != msm_submit->primary)
 305                                 finalize_current_cmd(ring);
 306                         nr_cmds += to_msm_ringbuffer(ring)->u.nr_cmds;
 307                 }
 308         }
 309
 310         void *obj_relocs[nr_objs];
 311         struct drm_msm_gem_submit_cmd cmds[nr_cmds];
 312         unsigned i = 0, o = 0;
 313
 314         set_foreach(msm_submit->ring_set, entry) {
 315                 struct fd_ringbuffer *ring = (void *)entry->key;
 316                 struct msm_ringbuffer *msm_ring = to_msm_ringbuffer(ring);
 317
 318                 debug_assert(i < nr_cmds);
 319
 320                 // TODO handle relocs:
 321                 if (ring->flags & _FD_RINGBUFFER_OBJECT) {
 322
 323                         debug_assert(o < nr_objs);
 324
 325                         void *relocs = handle_stateobj_relocs(msm_submit, msm_ring);
 326                         obj_relocs[o++] = relocs;
 327
 328                         cmds[i].type = MSM_SUBMIT_CMD_IB_TARGET_BUF;
 329                         cmds[i].submit_idx =
 330                                 append_bo(msm_submit, msm_ring->ring_bo);
 331                         cmds[i].submit_offset = msm_ring->offset;
 332                         cmds[i].size = offset_bytes(ring->cur, ring->start);
 333                         cmds[i].pad = 0;
 334                         cmds[i].nr_relocs = msm_ring->cmd->nr_relocs;
 335                         cmds[i].relocs = VOID2U64(relocs);
 336
 337                         i++;
 338                 } else {
 339                         for (unsigned j = 0; j < msm_ring->u.nr_cmds; j++) {
 340                                 if (ring->flags & FD_RINGBUFFER_PRIMARY) {
 341                                         cmds[i].type = MSM_SUBMIT_CMD_BUF;
 342                                 } else {
 343                                         cmds[i].type = MSM_SUBMIT_CMD_IB_TARGET_BUF;
 344                                 }
 345                                 cmds[i].submit_idx = append_bo(msm_submit,
 346                                                 msm_ring->u.cmds[j]->ring_bo);
 347                                 cmds[i].submit_offset = msm_ring->offset;
 348                                 cmds[i].size = msm_ring->u.cmds[j]->size;
 349                                 cmds[i].pad = 0;
 350                                 cmds[i].nr_relocs = msm_ring->u.cmds[j]->nr_relocs;
 351                                 cmds[i].relocs = VOID2U64(msm_ring->u.cmds[j]->relocs);
 352
 353                                 i++;
 354                         }
 355                 }
 356         }
 357
 358         if (in_fence_fd != -1) {
 359                 req.flags |= MSM_SUBMIT_FENCE_FD_IN | MSM_SUBMIT_NO_IMPLICIT;
 360                 req.fence_fd = in_fence_fd;
 361         }
 362
 363         if (out_fence_fd) {
 364                 req.flags |= MSM_SUBMIT_FENCE_FD_OUT;
 365         }
 366
 367         /* needs to be after get_cmd() as that could create bos/cmds table: */
 368         req.bos = VOID2U64(msm_submit->submit_bos),
 369         req.nr_bos = msm_submit->nr_submit_bos;
 370         req.cmds = VOID2U64(cmds),
 371         req.nr_cmds = nr_cmds;
 372
 373         DEBUG_MSG("nr_cmds=%u, nr_bos=%u", req.nr_cmds, req.nr_bos);
 374
 375         ret = drmCommandWriteRead(submit->pipe->dev->fd, DRM_MSM_GEM_SUBMIT,
 376                         &req, sizeof(req));
 377         if (ret) {
 378                 ERROR_MSG("submit failed: %d (%s)", ret, strerror(errno));
 379                 msm_dump_submit(&req);
 380         } else if (!ret) {
 381                 if (out_fence)
 382                         *out_fence = req.fence;
 383
 384                 if (out_fence_fd)
 385                         *out_fence_fd = req.fence_fd;
 386         }
 387
 388         for (unsigned o = 0; o < nr_objs; o++)
 389                 free(obj_relocs[o]);
 390
 391         return ret;
 392 }
 393
 394 static void
 395 unref_rings(struct set_entry *entry)
 396 {
 397         struct fd_ringbuffer *ring = (void *)entry->key;
 398         fd_ringbuffer_del(ring);
 399 }
 400
 401 static void
 402 msm_submit_destroy(struct fd_submit *submit)
 403 {
 404         struct msm_submit *msm_submit = to_msm_submit(submit);
 405
 406         if (msm_submit->primary)
 407                 fd_ringbuffer_del(msm_submit->primary);
 408         if (msm_submit->suballoc_ring)
 409                 fd_ringbuffer_del(msm_submit->suballoc_ring);
 410
 411         _mesa_hash_table_destroy(msm_submit->bo_table, NULL);
 412         _mesa_set_destroy(msm_submit->ring_set, unref_rings);
 413
 414         // TODO it would be nice to have a way to debug_assert() if all
 415         // rb's haven't been free'd back to the slab, because that is
 416         // an indication that we are leaking bo's
 417         slab_destroy(&msm_submit->ring_pool);
 418
 419         for (unsigned i = 0; i < msm_submit->nr_bos; i++)
 420                 fd_bo_del(msm_submit->bos[i]);
 421
 422         free(msm_submit->submit_bos);
 423         free(msm_submit->bos);
 424         free(msm_submit);
 425 }
 426
 427 static const struct fd_submit_funcs submit_funcs = {
 428                 .new_ringbuffer = msm_submit_new_ringbuffer,
 429                 .flush = msm_submit_flush,
 430                 .destroy = msm_submit_destroy,
 431 };
 432
 433 struct fd_submit *
 434 msm_submit_new(struct fd_pipe *pipe)
 435 {
 436         struct msm_submit *msm_submit = calloc(1, sizeof(*msm_submit));
 437         struct fd_submit *submit;
 438
 439         msm_submit->bo_table = _mesa_hash_table_create(NULL,
 440                         _mesa_hash_pointer, _mesa_key_pointer_equal);
 441         msm_submit->ring_set = _mesa_set_create(NULL,
 442                         _mesa_hash_pointer, _mesa_key_pointer_equal);
 443         // TODO tune size:
 444         slab_create(&msm_submit->ring_pool, sizeof(struct msm_ringbuffer), 16);
 445
 446         submit = &msm_submit->base;
 447         submit->pipe = pipe;
 448         submit->funcs = &submit_funcs;
 449
 450         return submit;
 451 }
 452
 453
 454 static void
 455 finalize_current_cmd(struct fd_ringbuffer *ring)
 456 {
 457         struct msm_ringbuffer *msm_ring = to_msm_ringbuffer(ring);
 458
 459         debug_assert(!(ring->flags & _FD_RINGBUFFER_OBJECT));
 460
 461         if (!msm_ring->cmd)
 462                 return;
 463
 464         debug_assert(msm_ring->cmd->ring_bo == msm_ring->ring_bo);
 465
 466         unsigned idx = APPEND(&msm_ring->u, cmds);
 467
 468         msm_ring->u.cmds[idx] = msm_ring->cmd;
 469         msm_ring->cmd = NULL;
 470
 471         msm_ring->u.cmds[idx]->size = offset_bytes(ring->cur, ring->start);
 472 }
 473
 474 static void
 475 msm_ringbuffer_grow(struct fd_ringbuffer *ring, uint32_t size)
 476 {
 477         struct msm_ringbuffer *msm_ring = to_msm_ringbuffer(ring);
 478         struct fd_pipe *pipe = msm_ring->u.submit->pipe;
 479
 480         debug_assert(ring->flags & FD_RINGBUFFER_GROWABLE);
 481
 482         finalize_current_cmd(ring);
 483
 484         fd_bo_del(msm_ring->ring_bo);
 485         msm_ring->ring_bo = fd_bo_new_ring(pipe->dev, size);
 486         msm_ring->cmd = cmd_new(msm_ring->ring_bo);
 487
 488         ring->start = fd_bo_map(msm_ring->ring_bo);
 489         ring->end = &(ring->start[size/4]);
 490         ring->cur = ring->start;
 491         ring->size = size;
 492 }
 493
 494 static void
 495 msm_ringbuffer_emit_reloc(struct fd_ringbuffer *ring,
 496                 const struct fd_reloc *reloc)
 497 {
 498         struct msm_ringbuffer *msm_ring = to_msm_ringbuffer(ring);
 499         struct fd_pipe *pipe;
 500         unsigned reloc_idx;
 501
 502         if (ring->flags & _FD_RINGBUFFER_OBJECT) {
 503                 unsigned idx = APPEND(&msm_ring->u, reloc_bos);
 504
 505                 msm_ring->u.reloc_bos[idx] = fd_bo_ref(reloc->bo);
 506
 507                 /* this gets fixed up at submit->flush() time, since this state-
 508                  * object rb can be used with many different submits
 509                  */
 510                 reloc_idx = idx;
 511
 512                 pipe = msm_ring->u.pipe;
 513         } else {
 514                 struct msm_submit *msm_submit =
 515                                 to_msm_submit(msm_ring->u.submit);
 516
 517                 reloc_idx = append_bo(msm_submit, reloc->bo);
 518
 519                 pipe = msm_ring->u.submit->pipe;
 520         }
 521
 522         struct drm_msm_gem_submit_reloc *r;
 523         unsigned idx = APPEND(msm_ring->cmd, relocs);
 524
 525         r = &msm_ring->cmd->relocs[idx];
 526
 527         r->reloc_idx = reloc_idx;
 528         r->reloc_offset = reloc->offset;
 529         r->or = reloc->or;
 530         r->shift = reloc->shift;
 531         r->submit_offset = offset_bytes(ring->cur, ring->start) +
 532                         msm_ring->offset;
 533
 534         ring->cur++;
 535
 536         if (pipe->gpu_id >= 500) {
 537                 idx = APPEND(msm_ring->cmd, relocs);
 538                 r = &msm_ring->cmd->relocs[idx];
 539
 540                 r->reloc_idx = reloc_idx;
 541                 r->reloc_offset = reloc->offset;
 542                 r->or = reloc->orhi;
 543                 r->shift = reloc->shift - 32;
 544                 r->submit_offset = offset_bytes(ring->cur, ring->start) +
 545                                 msm_ring->offset;
 546
 547                 ring->cur++;
 548         }
 549 }
 550
 551 static void
 552 append_stateobj_rings(struct msm_submit *submit, struct fd_ringbuffer *target)
 553 {
 554         struct msm_ringbuffer *msm_target = to_msm_ringbuffer(target);
 555
 556         debug_assert(target->flags & _FD_RINGBUFFER_OBJECT);
 557
 558         set_foreach(msm_target->u.ring_set, entry) {
 559                 struct fd_ringbuffer *ring = (void *)entry->key;
 560
 561                 append_ring(submit->ring_set, ring);
 562
 563                 if (ring->flags & _FD_RINGBUFFER_OBJECT) {
 564                         append_stateobj_rings(submit, ring);
 565                 }
 566         }
 567 }
 568
 569 static uint32_t
 570 msm_ringbuffer_emit_reloc_ring(struct fd_ringbuffer *ring,
 571                 struct fd_ringbuffer *target, uint32_t cmd_idx)
 572 {
 573         struct msm_ringbuffer *msm_target = to_msm_ringbuffer(target);
 574         struct msm_ringbuffer *msm_ring = to_msm_ringbuffer(ring);
 575         struct fd_bo *bo;
 576         uint32_t size;
 577
 578         if ((target->flags & FD_RINGBUFFER_GROWABLE) &&
 579                         (cmd_idx < msm_target->u.nr_cmds)) {
 580                 bo   = msm_target->u.cmds[cmd_idx]->ring_bo;
 581                 size = msm_target->u.cmds[cmd_idx]->size;
 582         } else {
 583                 bo   = msm_target->ring_bo;
 584                 size = offset_bytes(target->cur, target->start);
 585         }
 586
 587         msm_ringbuffer_emit_reloc(ring, &(struct fd_reloc){
 588                 .bo     = bo,
 589                 .offset = msm_target->offset,
 590         });
 591
 592         if (!size)
 593                 return 0;
 594
 595         if ((target->flags & _FD_RINGBUFFER_OBJECT) &&
 596                         !(ring->flags & _FD_RINGBUFFER_OBJECT)) {
 597                 struct msm_submit *msm_submit = to_msm_submit(msm_ring->u.submit);
 598
 599                 append_stateobj_rings(msm_submit, target);
 600         }
 601
 602         if (ring->flags & _FD_RINGBUFFER_OBJECT) {
 603                 append_ring(msm_ring->u.ring_set, target);
 604         } else {
 605                 struct msm_submit *msm_submit = to_msm_submit(msm_ring->u.submit);
 606                 append_ring(msm_submit->ring_set, target);
 607         }
 608
 609         return size;
 610 }
 611
 612 static uint32_t
 613 msm_ringbuffer_cmd_count(struct fd_ringbuffer *ring)
 614 {
 615         if (ring->flags & FD_RINGBUFFER_GROWABLE)
 616                 return to_msm_ringbuffer(ring)->u.nr_cmds + 1;
 617         return 1;
 618 }
 619
 620 static void
 621 msm_ringbuffer_destroy(struct fd_ringbuffer *ring)
 622 {
 623         struct msm_ringbuffer *msm_ring = to_msm_ringbuffer(ring);
 624
 625         fd_bo_del(msm_ring->ring_bo);
 626         if (msm_ring->cmd)
 627                 cmd_free(msm_ring->cmd);
 628
 629         if (ring->flags & _FD_RINGBUFFER_OBJECT) {
 630                 for (unsigned i = 0; i < msm_ring->u.nr_reloc_bos; i++) {
 631                         fd_bo_del(msm_ring->u.reloc_bos[i]);
 632                 }
 633
 634                 _mesa_set_destroy(msm_ring->u.ring_set, unref_rings);
 635
 636                 free(msm_ring->u.reloc_bos);
 637                 free(msm_ring);
 638         } else {
 639                 struct fd_submit *submit = msm_ring->u.submit;
 640
 641                 for (unsigned i = 0; i < msm_ring->u.nr_cmds; i++) {
 642                         cmd_free(msm_ring->u.cmds[i]);
 643                 }
 644
 645                 free(msm_ring->u.cmds);
 646                 slab_free_st(&to_msm_submit(submit)->ring_pool, msm_ring);
 647         }
 648 }
 649
 650 static const struct fd_ringbuffer_funcs ring_funcs = {
 651                 .grow = msm_ringbuffer_grow,
 652                 .emit_reloc = msm_ringbuffer_emit_reloc,
 653                 .emit_reloc_ring = msm_ringbuffer_emit_reloc_ring,
 654                 .cmd_count = msm_ringbuffer_cmd_count,
 655                 .destroy = msm_ringbuffer_destroy,
 656 };
 657
 658 static inline struct fd_ringbuffer *
 659 msm_ringbuffer_init(struct msm_ringbuffer *msm_ring, uint32_t size,
 660                 enum fd_ringbuffer_flags flags)
 661 {
 662         struct fd_ringbuffer *ring = &msm_ring->base;
 663
 664         debug_assert(msm_ring->ring_bo);
 665
 666         uint8_t *base = fd_bo_map(msm_ring->ring_bo);
 667         ring->start = (void *)(base + msm_ring->offset);
 668         ring->end = &(ring->start[size/4]);
 669         ring->cur = ring->start;
 670
 671         ring->size = size;
 672         ring->flags = flags;
 673
 674         ring->funcs = &ring_funcs;
 675
 676         msm_ring->u.cmds = NULL;
 677         msm_ring->u.nr_cmds = msm_ring->u.max_cmds = 0;
 678
 679         msm_ring->cmd = cmd_new(msm_ring->ring_bo);
 680
 681         return ring;
 682 }
 683
 684 struct fd_ringbuffer *
 685 msm_ringbuffer_new_object(struct fd_pipe *pipe, uint32_t size)
 686 {
 687         struct msm_ringbuffer *msm_ring = malloc(sizeof(*msm_ring));
 688
 689         msm_ring->u.pipe = pipe;
 690         msm_ring->offset = 0;
 691         msm_ring->ring_bo = fd_bo_new_ring(pipe->dev, size);
 692         msm_ring->base.refcnt = 1;
 693
 694         msm_ring->u.reloc_bos = NULL;
 695         msm_ring->u.nr_reloc_bos = msm_ring->u.max_reloc_bos = 0;
 696
 697         msm_ring->u.ring_set = _mesa_set_create(NULL,
 698                         _mesa_hash_pointer, _mesa_key_pointer_equal);
 699
 700         return msm_ringbuffer_init(msm_ring, size, _FD_RINGBUFFER_OBJECT);
 701 }