drivers/gpu/drm/radeon/radeon_ring.c

   1 /*
   2  * Copyright 2008 Advanced Micro Devices, Inc.
   3  * Copyright 2008 Red Hat Inc.
   4  * Copyright 2009 Jerome Glisse.
   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 shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  19  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  20  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  21  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  22  * OTHER DEALINGS IN THE SOFTWARE.
  23  *
  24  * Authors: Dave Airlie
  25  *          Alex Deucher
  26  *          Jerome Glisse
  27  *          Christian König
  28  */
  29 #include <linux/seq_file.h>
  30 #include <linux/slab.h>
  31 #include <drm/drmP.h>
  32 #include <drm/radeon_drm.h>
  33 #include "radeon_reg.h"
  34 #include "radeon.h"
  35 #include "atom.h"
  36
  37 /*
  38  * IB
  39  * IBs (Indirect Buffers) and areas of GPU accessible memory where
  40  * commands are stored.  You can put a pointer to the IB in the
  41  * command ring and the hw will fetch the commands from the IB
  42  * and execute them.  Generally userspace acceleration drivers
  43  * produce command buffers which are send to the kernel and
  44  * put in IBs for execution by the requested ring.
  45  */
  46 static int radeon_debugfs_sa_init(struct radeon_device *rdev);
  47
  48 /**
  49  * radeon_ib_get - request an IB (Indirect Buffer)
  50  *
  51  * @rdev: radeon_device pointer
  52  * @ring: ring index the IB is associated with
  53  * @ib: IB object returned
  54  * @size: requested IB size
  55  *
  56  * Request an IB (all asics).  IBs are allocated using the
  57  * suballocator.
  58  * Returns 0 on success, error on failure.
  59  */
  60 int radeon_ib_get(struct radeon_device *rdev, int ring,
  61                   struct radeon_ib *ib, struct radeon_vm *vm,
  62                   unsigned size)
  63 {
  64         int r;
  65
  66         r = radeon_sa_bo_new(rdev, &rdev->ring_tmp_bo, &ib->sa_bo, size, 256);
  67         if (r) {
  68                 dev_err(rdev->dev, "failed to get a new IB (%d)\n", r);
  69                 return r;
  70         }
  71
  72         r = radeon_semaphore_create(rdev, &ib->semaphore);
  73         if (r) {
  74                 return r;
  75         }
  76
  77         ib->ring = ring;
  78         ib->fence = NULL;
  79         ib->ptr = radeon_sa_bo_cpu_addr(ib->sa_bo);
  80         ib->vm = vm;
  81         if (vm) {
  82                 /* ib pool is bound at RADEON_VA_IB_OFFSET in virtual address
  83                  * space and soffset is the offset inside the pool bo
  84                  */
  85                 ib->gpu_addr = ib->sa_bo->soffset + RADEON_VA_IB_OFFSET;
  86         } else {
  87                 ib->gpu_addr = radeon_sa_bo_gpu_addr(ib->sa_bo);
  88         }
  89         ib->is_const_ib = false;
  90
  91         return 0;
  92 }
  93
  94 /**
  95  * radeon_ib_free - free an IB (Indirect Buffer)
  96  *
  97  * @rdev: radeon_device pointer
  98  * @ib: IB object to free
  99  *
 100  * Free an IB (all asics).
 101  */
 102 void radeon_ib_free(struct radeon_device *rdev, struct radeon_ib *ib)
 103 {
 104         radeon_semaphore_free(rdev, &ib->semaphore, ib->fence);
 105         radeon_sa_bo_free(rdev, &ib->sa_bo, ib->fence);
 106         radeon_fence_unref(&ib->fence);
 107 }
 108
 109 /**
 110  * radeon_ib_schedule - schedule an IB (Indirect Buffer) on the ring
 111  *
 112  * @rdev: radeon_device pointer
 113  * @ib: IB object to schedule
 114  * @const_ib: Const IB to schedule (SI only)
 115  *
 116  * Schedule an IB on the associated ring (all asics).
 117  * Returns 0 on success, error on failure.
 118  *
 119  * On SI, there are two parallel engines fed from the primary ring,
 120  * the CE (Constant Engine) and the DE (Drawing Engine).  Since
 121  * resource descriptors have moved to memory, the CE allows you to
 122  * prime the caches while the DE is updating register state so that
 123  * the resource descriptors will be already in cache when the draw is
 124  * processed.  To accomplish this, the userspace driver submits two
 125  * IBs, one for the CE and one for the DE.  If there is a CE IB (called
 126  * a CONST_IB), it will be put on the ring prior to the DE IB.  Prior
 127  * to SI there was just a DE IB.
 128  */
 129 int radeon_ib_schedule(struct radeon_device *rdev, struct radeon_ib *ib,
 130                        struct radeon_ib *const_ib)
 131 {
 132         struct radeon_ring *ring = &rdev->ring[ib->ring];
 133         int r = 0;
 134
 135         if (!ib->length_dw || !ring->ready) {
 136                 /* TODO: Nothings in the ib we should report. */
 137                 dev_err(rdev->dev, "couldn't schedule ib\n");
 138                 return -EINVAL;
 139         }
 140
 141         /* 64 dwords should be enough for fence too */
 142         r = radeon_ring_lock(rdev, ring, 64 + RADEON_NUM_SYNCS * 8);
 143         if (r) {
 144                 dev_err(rdev->dev, "scheduling IB failed (%d).\n", r);
 145                 return r;
 146         }
 147
 148         /* grab a vm id if necessary */
 149         if (ib->vm) {
 150                 struct radeon_fence *vm_id_fence;
 151                 vm_id_fence = radeon_vm_grab_id(rdev, ib->vm, ib->ring);
 152                 radeon_semaphore_sync_to(ib->semaphore, vm_id_fence);
 153         }
 154
 155         /* sync with other rings */
 156         r = radeon_semaphore_sync_rings(rdev, ib->semaphore, ib->ring);
 157         if (r) {
 158                 dev_err(rdev->dev, "failed to sync rings (%d)\n", r);
 159                 radeon_ring_unlock_undo(rdev, ring);
 160                 return r;
 161         }
 162
 163         if (ib->vm)
 164                 radeon_vm_flush(rdev, ib->vm, ib->ring);
 165
 166         if (const_ib) {
 167                 radeon_ring_ib_execute(rdev, const_ib->ring, const_ib);
 168                 radeon_semaphore_free(rdev, &const_ib->semaphore, NULL);
 169         }
 170         radeon_ring_ib_execute(rdev, ib->ring, ib);
 171         r = radeon_fence_emit(rdev, &ib->fence, ib->ring);
 172         if (r) {
 173                 dev_err(rdev->dev, "failed to emit fence for new IB (%d)\n", r);
 174                 radeon_ring_unlock_undo(rdev, ring);
 175                 return r;
 176         }
 177         if (const_ib) {
 178                 const_ib->fence = radeon_fence_ref(ib->fence);
 179         }
 180
 181         if (ib->vm)
 182                 radeon_vm_fence(rdev, ib->vm, ib->fence);
 183
 184         radeon_ring_unlock_commit(rdev, ring);
 185         return 0;
 186 }
 187
 188 /**
 189  * radeon_ib_pool_init - Init the IB (Indirect Buffer) pool
 190  *
 191  * @rdev: radeon_device pointer
 192  *
 193  * Initialize the suballocator to manage a pool of memory
 194  * for use as IBs (all asics).
 195  * Returns 0 on success, error on failure.
 196  */
 197 int radeon_ib_pool_init(struct radeon_device *rdev)
 198 {
 199         int r;
 200
 201         if (rdev->ib_pool_ready) {
 202                 return 0;
 203         }
 204
 205         if (rdev->family >= CHIP_BONAIRE) {
 206                 r = radeon_sa_bo_manager_init(rdev, &rdev->ring_tmp_bo,
 207                                               RADEON_IB_POOL_SIZE*64*1024,
 208                                               RADEON_GPU_PAGE_SIZE,
 209                                               RADEON_GEM_DOMAIN_GTT,
 210                                               RADEON_GEM_GTT_WC);
 211         } else {
 212                 /* Before CIK, it's better to stick to cacheable GTT due
 213                  * to the command stream checking
 214                  */
 215                 r = radeon_sa_bo_manager_init(rdev, &rdev->ring_tmp_bo,
 216                                               RADEON_IB_POOL_SIZE*64*1024,
 217                                               RADEON_GPU_PAGE_SIZE,
 218                                               RADEON_GEM_DOMAIN_GTT, 0);
 219         }
 220         if (r) {
 221                 return r;
 222         }
 223
 224         r = radeon_sa_bo_manager_start(rdev, &rdev->ring_tmp_bo);
 225         if (r) {
 226                 return r;
 227         }
 228
 229         rdev->ib_pool_ready = true;
 230         if (radeon_debugfs_sa_init(rdev)) {
 231                 dev_err(rdev->dev, "failed to register debugfs file for SA\n");
 232         }
 233         return 0;
 234 }
 235
 236 /**
 237  * radeon_ib_pool_fini - Free the IB (Indirect Buffer) pool
 238  *
 239  * @rdev: radeon_device pointer
 240  *
 241  * Tear down the suballocator managing the pool of memory
 242  * for use as IBs (all asics).
 243  */
 244 void radeon_ib_pool_fini(struct radeon_device *rdev)
 245 {
 246         if (rdev->ib_pool_ready) {
 247                 radeon_sa_bo_manager_suspend(rdev, &rdev->ring_tmp_bo);
 248                 radeon_sa_bo_manager_fini(rdev, &rdev->ring_tmp_bo);
 249                 rdev->ib_pool_ready = false;
 250         }
 251 }
 252
 253 /**
 254  * radeon_ib_ring_tests - test IBs on the rings
 255  *
 256  * @rdev: radeon_device pointer
 257  *
 258  * Test an IB (Indirect Buffer) on each ring.
 259  * If the test fails, disable the ring.
 260  * Returns 0 on success, error if the primary GFX ring
 261  * IB test fails.
 262  */
 263 int radeon_ib_ring_tests(struct radeon_device *rdev)
 264 {
 265         unsigned i;
 266         int r;
 267
 268         for (i = 0; i < RADEON_NUM_RINGS; ++i) {
 269                 struct radeon_ring *ring = &rdev->ring[i];
 270
 271                 if (!ring->ready)
 272                         continue;
 273
 274                 r = radeon_ib_test(rdev, i, ring);
 275                 if (r) {
 276                         ring->ready = false;
 277                         rdev->needs_reset = false;
 278
 279                         if (i == RADEON_RING_TYPE_GFX_INDEX) {
 280                                 /* oh, oh, that's really bad */
 281                                 DRM_ERROR("radeon: failed testing IB on GFX ring (%d).\n", r);
 282                                 rdev->accel_working = false;
 283                                 return r;
 284
 285                         } else {
 286                                 /* still not good, but we can live with it */
 287                                 DRM_ERROR("radeon: failed testing IB on ring %d (%d).\n", i, r);
 288                         }
 289                 }
 290         }
 291         return 0;
 292 }
 293
 294 /*
 295  * Rings
 296  * Most engines on the GPU are fed via ring buffers.  Ring
 297  * buffers are areas of GPU accessible memory that the host
 298  * writes commands into and the GPU reads commands out of.
 299  * There is a rptr (read pointer) that determines where the
 300  * GPU is currently reading, and a wptr (write pointer)
 301  * which determines where the host has written.  When the
 302  * pointers are equal, the ring is idle.  When the host
 303  * writes commands to the ring buffer, it increments the
 304  * wptr.  The GPU then starts fetching commands and executes
 305  * them until the pointers are equal again.
 306  */
 307 static int radeon_debugfs_ring_init(struct radeon_device *rdev, struct radeon_ring *ring);
 308
 309 /**
 310  * radeon_ring_write - write a value to the ring
 311  *
 312  * @ring: radeon_ring structure holding ring information
 313  * @v: dword (dw) value to write
 314  *
 315  * Write a value to the requested ring buffer (all asics).
 316  */
 317 void radeon_ring_write(struct radeon_ring *ring, uint32_t v)
 318 {
 319 #if DRM_DEBUG_CODE
 320         if (ring->count_dw <= 0) {
 321                 DRM_ERROR("radeon: writing more dwords to the ring than expected!\n");
 322         }
 323 #endif
 324         ring->ring[ring->wptr++] = v;
 325         ring->wptr &= ring->ptr_mask;
 326         ring->count_dw--;
 327         ring->ring_free_dw--;
 328 }
 329
 330 /**
 331  * radeon_ring_supports_scratch_reg - check if the ring supports
 332  * writing to scratch registers
 333  *
 334  * @rdev: radeon_device pointer
 335  * @ring: radeon_ring structure holding ring information
 336  *
 337  * Check if a specific ring supports writing to scratch registers (all asics).
 338  * Returns true if the ring supports writing to scratch regs, false if not.
 339  */
 340 bool radeon_ring_supports_scratch_reg(struct radeon_device *rdev,
 341                                       struct radeon_ring *ring)
 342 {
 343         switch (ring->idx) {
 344         case RADEON_RING_TYPE_GFX_INDEX:
 345         case CAYMAN_RING_TYPE_CP1_INDEX:
 346         case CAYMAN_RING_TYPE_CP2_INDEX:
 347                 return true;
 348         default:
 349                 return false;
 350         }
 351 }
 352
 353 /**
 354  * radeon_ring_free_size - update the free size
 355  *
 356  * @rdev: radeon_device pointer
 357  * @ring: radeon_ring structure holding ring information
 358  *
 359  * Update the free dw slots in the ring buffer (all asics).
 360  */
 361 void radeon_ring_free_size(struct radeon_device *rdev, struct radeon_ring *ring)
 362 {
 363         uint32_t rptr = radeon_ring_get_rptr(rdev, ring);
 364
 365         /* This works because ring_size is a power of 2 */
 366         ring->ring_free_dw = rptr + (ring->ring_size / 4);
 367         ring->ring_free_dw -= ring->wptr;
 368         ring->ring_free_dw &= ring->ptr_mask;
 369         if (!ring->ring_free_dw) {
 370                 /* this is an empty ring */
 371                 ring->ring_free_dw = ring->ring_size / 4;
 372                 /*  update lockup info to avoid false positive */
 373                 radeon_ring_lockup_update(rdev, ring);
 374         }
 375 }
 376
 377 /**
 378  * radeon_ring_alloc - allocate space on the ring buffer
 379  *
 380  * @rdev: radeon_device pointer
 381  * @ring: radeon_ring structure holding ring information
 382  * @ndw: number of dwords to allocate in the ring buffer
 383  *
 384  * Allocate @ndw dwords in the ring buffer (all asics).
 385  * Returns 0 on success, error on failure.
 386  */
 387 int radeon_ring_alloc(struct radeon_device *rdev, struct radeon_ring *ring, unsigned ndw)
 388 {
 389         int r;
 390
 391         /* make sure we aren't trying to allocate more space than there is on the ring */
 392         if (ndw > (ring->ring_size / 4))
 393                 return -ENOMEM;
 394         /* Align requested size with padding so unlock_commit can
 395          * pad safely */
 396         radeon_ring_free_size(rdev, ring);
 397         ndw = (ndw + ring->align_mask) & ~ring->align_mask;
 398         while (ndw > (ring->ring_free_dw - 1)) {
 399                 radeon_ring_free_size(rdev, ring);
 400                 if (ndw < ring->ring_free_dw) {
 401                         break;
 402                 }
 403                 r = radeon_fence_wait_next(rdev, ring->idx);
 404                 if (r)
 405                         return r;
 406         }
 407         ring->count_dw = ndw;
 408         ring->wptr_old = ring->wptr;
 409         return 0;
 410 }
 411
 412 /**
 413  * radeon_ring_lock - lock the ring and allocate space on it
 414  *
 415  * @rdev: radeon_device pointer
 416  * @ring: radeon_ring structure holding ring information
 417  * @ndw: number of dwords to allocate in the ring buffer
 418  *
 419  * Lock the ring and allocate @ndw dwords in the ring buffer
 420  * (all asics).
 421  * Returns 0 on success, error on failure.
 422  */
 423 int radeon_ring_lock(struct radeon_device *rdev, struct radeon_ring *ring, unsigned ndw)
 424 {
 425         int r;
 426
 427         mutex_lock(&rdev->ring_lock);
 428         r = radeon_ring_alloc(rdev, ring, ndw);
 429         if (r) {
 430                 mutex_unlock(&rdev->ring_lock);
 431                 return r;
 432         }
 433         return 0;
 434 }
 435
 436 /**
 437  * radeon_ring_commit - tell the GPU to execute the new
 438  * commands on the ring buffer
 439  *
 440  * @rdev: radeon_device pointer
 441  * @ring: radeon_ring structure holding ring information
 442  *
 443  * Update the wptr (write pointer) to tell the GPU to
 444  * execute new commands on the ring buffer (all asics).
 445  */
 446 void radeon_ring_commit(struct radeon_device *rdev, struct radeon_ring *ring)
 447 {
 448         /* We pad to match fetch size */
 449         while (ring->wptr & ring->align_mask) {
 450                 radeon_ring_write(ring, ring->nop);
 451         }
 452         mb();
 453         radeon_ring_set_wptr(rdev, ring);
 454 }
 455
 456 /**
 457  * radeon_ring_unlock_commit - tell the GPU to execute the new
 458  * commands on the ring buffer and unlock it
 459  *
 460  * @rdev: radeon_device pointer
 461  * @ring: radeon_ring structure holding ring information
 462  *
 463  * Call radeon_ring_commit() then unlock the ring (all asics).
 464  */
 465 void radeon_ring_unlock_commit(struct radeon_device *rdev, struct radeon_ring *ring)
 466 {
 467         radeon_ring_commit(rdev, ring);
 468         mutex_unlock(&rdev->ring_lock);
 469 }
 470
 471 /**
 472  * radeon_ring_undo - reset the wptr
 473  *
 474  * @ring: radeon_ring structure holding ring information
 475  *
 476  * Reset the driver's copy of the wptr (all asics).
 477  */
 478 void radeon_ring_undo(struct radeon_ring *ring)
 479 {
 480         ring->wptr = ring->wptr_old;
 481 }
 482
 483 /**
 484  * radeon_ring_unlock_undo - reset the wptr and unlock the ring
 485  *
 486  * @ring: radeon_ring structure holding ring information
 487  *
 488  * Call radeon_ring_undo() then unlock the ring (all asics).
 489  */
 490 void radeon_ring_unlock_undo(struct radeon_device *rdev, struct radeon_ring *ring)
 491 {
 492         radeon_ring_undo(ring);
 493         mutex_unlock(&rdev->ring_lock);
 494 }
 495
 496 /**
 497  * radeon_ring_lockup_update - update lockup variables
 498  *
 499  * @ring: radeon_ring structure holding ring information
 500  *
 501  * Update the last rptr value and timestamp (all asics).
 502  */
 503 void radeon_ring_lockup_update(struct radeon_device *rdev,
 504                                struct radeon_ring *ring)
 505 {
 506         atomic_set(&ring->last_rptr, radeon_ring_get_rptr(rdev, ring));
 507         atomic64_set(&ring->last_activity, jiffies_64);
 508 }
 509
 510 /**
 511  * radeon_ring_test_lockup() - check if ring is lockedup by recording information
 512  * @rdev:       radeon device structure
 513  * @ring:       radeon_ring structure holding ring information
 514  *
 515  */
 516 bool radeon_ring_test_lockup(struct radeon_device *rdev, struct radeon_ring *ring)
 517 {
 518         uint32_t rptr = radeon_ring_get_rptr(rdev, ring);
 519         uint64_t last = atomic64_read(&ring->last_activity);
 520         uint64_t elapsed;
 521
 522         if (rptr != atomic_read(&ring->last_rptr)) {
 523                 /* ring is still working, no lockup */
 524                 radeon_ring_lockup_update(rdev, ring);
 525                 return false;
 526         }
 527
 528         elapsed = jiffies_to_msecs(jiffies_64 - last);
 529         if (radeon_lockup_timeout && elapsed >= radeon_lockup_timeout) {
 530                 dev_err(rdev->dev, "ring %d stalled for more than %llumsec\n",
 531                         ring->idx, elapsed);
 532                 return true;
 533         }
 534         /* give a chance to the GPU ... */
 535         return false;
 536 }
 537
 538 /**
 539  * radeon_ring_backup - Back up the content of a ring
 540  *
 541  * @rdev: radeon_device pointer
 542  * @ring: the ring we want to back up
 543  *
 544  * Saves all unprocessed commits from a ring, returns the number of dwords saved.
 545  */
 546 unsigned radeon_ring_backup(struct radeon_device *rdev, struct radeon_ring *ring,
 547                             uint32_t **data)
 548 {
 549         unsigned size, ptr, i;
 550
 551         /* just in case lock the ring */
 552         mutex_lock(&rdev->ring_lock);
 553         *data = NULL;
 554
 555         if (ring->ring_obj == NULL) {
 556                 mutex_unlock(&rdev->ring_lock);
 557                 return 0;
 558         }
 559
 560         /* it doesn't make sense to save anything if all fences are signaled */
 561         if (!radeon_fence_count_emitted(rdev, ring->idx)) {
 562                 mutex_unlock(&rdev->ring_lock);
 563                 return 0;
 564         }
 565
 566         /* calculate the number of dw on the ring */
 567         if (ring->rptr_save_reg)
 568                 ptr = RREG32(ring->rptr_save_reg);
 569         else if (rdev->wb.enabled)
 570                 ptr = le32_to_cpu(*ring->next_rptr_cpu_addr);
 571         else {
 572                 /* no way to read back the next rptr */
 573                 mutex_unlock(&rdev->ring_lock);
 574                 return 0;
 575         }
 576
 577         size = ring->wptr + (ring->ring_size / 4);
 578         size -= ptr;
 579         size &= ring->ptr_mask;
 580         if (size == 0) {
 581                 mutex_unlock(&rdev->ring_lock);
 582                 return 0;
 583         }
 584
 585         /* and then save the content of the ring */
 586         *data = kmalloc_array(size, sizeof(uint32_t), GFP_KERNEL);
 587         if (!*data) {
 588                 mutex_unlock(&rdev->ring_lock);
 589                 return 0;
 590         }
 591         for (i = 0; i < size; ++i) {
 592                 (*data)[i] = ring->ring[ptr++];
 593                 ptr &= ring->ptr_mask;
 594         }
 595
 596         mutex_unlock(&rdev->ring_lock);
 597         return size;
 598 }
 599
 600 /**
 601  * radeon_ring_restore - append saved commands to the ring again
 602  *
 603  * @rdev: radeon_device pointer
 604  * @ring: ring to append commands to
 605  * @size: number of dwords we want to write
 606  * @data: saved commands
 607  *
 608  * Allocates space on the ring and restore the previously saved commands.
 609  */
 610 int radeon_ring_restore(struct radeon_device *rdev, struct radeon_ring *ring,
 611                         unsigned size, uint32_t *data)
 612 {
 613         int i, r;
 614
 615         if (!size || !data)
 616                 return 0;
 617
 618         /* restore the saved ring content */
 619         r = radeon_ring_lock(rdev, ring, size);
 620         if (r)
 621                 return r;
 622
 623         for (i = 0; i < size; ++i) {
 624                 radeon_ring_write(ring, data[i]);
 625         }
 626
 627         radeon_ring_unlock_commit(rdev, ring);
 628         kfree(data);
 629         return 0;
 630 }
 631
 632 /**
 633  * radeon_ring_init - init driver ring struct.
 634  *
 635  * @rdev: radeon_device pointer
 636  * @ring: radeon_ring structure holding ring information
 637  * @ring_size: size of the ring
 638  * @rptr_offs: offset of the rptr writeback location in the WB buffer
 639  * @nop: nop packet for this ring
 640  *
 641  * Initialize the driver information for the selected ring (all asics).
 642  * Returns 0 on success, error on failure.
 643  */
 644 int radeon_ring_init(struct radeon_device *rdev, struct radeon_ring *ring, unsigned ring_size,
 645                      unsigned rptr_offs, u32 nop)
 646 {
 647         int r;
 648
 649         ring->ring_size = ring_size;
 650         ring->rptr_offs = rptr_offs;
 651         ring->nop = nop;
 652         /* Allocate ring buffer */
 653         if (ring->ring_obj == NULL) {
 654                 r = radeon_bo_create(rdev, ring->ring_size, PAGE_SIZE, true,
 655                                      RADEON_GEM_DOMAIN_GTT,
 656                                      (rdev->flags & RADEON_IS_PCIE) ?
 657                                      RADEON_GEM_GTT_WC : 0,
 658                                      NULL, &ring->ring_obj);
 659                 if (r) {
 660                         dev_err(rdev->dev, "(%d) ring create failed\n", r);
 661                         return r;
 662                 }
 663                 r = radeon_bo_reserve(ring->ring_obj, false);
 664                 if (unlikely(r != 0))
 665                         return r;
 666                 r = radeon_bo_pin(ring->ring_obj, RADEON_GEM_DOMAIN_GTT,
 667                                         &ring->gpu_addr);
 668                 if (r) {
 669                         radeon_bo_unreserve(ring->ring_obj);
 670                         dev_err(rdev->dev, "(%d) ring pin failed\n", r);
 671                         return r;
 672                 }
 673                 r = radeon_bo_kmap(ring->ring_obj,
 674                                        (void **)&ring->ring);
 675                 radeon_bo_unreserve(ring->ring_obj);
 676                 if (r) {
 677                         dev_err(rdev->dev, "(%d) ring map failed\n", r);
 678                         return r;
 679                 }
 680         }
 681         ring->ptr_mask = (ring->ring_size / 4) - 1;
 682         ring->ring_free_dw = ring->ring_size / 4;
 683         if (rdev->wb.enabled) {
 684                 u32 index = RADEON_WB_RING0_NEXT_RPTR + (ring->idx * 4);
 685                 ring->next_rptr_gpu_addr = rdev->wb.gpu_addr + index;
 686                 ring->next_rptr_cpu_addr = &rdev->wb.wb[index/4];
 687         }
 688         if (radeon_debugfs_ring_init(rdev, ring)) {
 689                 DRM_ERROR("Failed to register debugfs file for rings !\n");
 690         }
 691         radeon_ring_lockup_update(rdev, ring);
 692         return 0;
 693 }
 694
 695 /**
 696  * radeon_ring_fini - tear down the driver ring struct.
 697  *
 698  * @rdev: radeon_device pointer
 699  * @ring: radeon_ring structure holding ring information
 700  *
 701  * Tear down the driver information for the selected ring (all asics).
 702  */
 703 void radeon_ring_fini(struct radeon_device *rdev, struct radeon_ring *ring)
 704 {
 705         int r;
 706         struct radeon_bo *ring_obj;
 707
 708         mutex_lock(&rdev->ring_lock);
 709         ring_obj = ring->ring_obj;
 710         ring->ready = false;
 711         ring->ring = NULL;
 712         ring->ring_obj = NULL;
 713         mutex_unlock(&rdev->ring_lock);
 714
 715         if (ring_obj) {
 716                 r = radeon_bo_reserve(ring_obj, false);
 717                 if (likely(r == 0)) {
 718                         radeon_bo_kunmap(ring_obj);
 719                         radeon_bo_unpin(ring_obj);
 720                         radeon_bo_unreserve(ring_obj);
 721                 }
 722                 radeon_bo_unref(&ring_obj);
 723         }
 724 }
 725
 726 /*
 727  * Debugfs info
 728  */
 729 #if defined(CONFIG_DEBUG_FS)
 730
 731 static int radeon_debugfs_ring_info(struct seq_file *m, void *data)
 732 {
 733         struct drm_info_node *node = (struct drm_info_node *) m->private;
 734         struct drm_device *dev = node->minor->dev;
 735         struct radeon_device *rdev = dev->dev_private;
 736         int ridx = *(int*)node->info_ent->data;
 737         struct radeon_ring *ring = &rdev->ring[ridx];
 738
 739         uint32_t rptr, wptr, rptr_next;
 740         unsigned count, i, j;
 741
 742         radeon_ring_free_size(rdev, ring);
 743         count = (ring->ring_size / 4) - ring->ring_free_dw;
 744
 745         wptr = radeon_ring_get_wptr(rdev, ring);
 746         seq_printf(m, "wptr: 0x%08x [%5d]\n",
 747                    wptr, wptr);
 748
 749         rptr = radeon_ring_get_rptr(rdev, ring);
 750         seq_printf(m, "rptr: 0x%08x [%5d]\n",
 751                    rptr, rptr);
 752
 753         if (ring->rptr_save_reg) {
 754                 rptr_next = RREG32(ring->rptr_save_reg);
 755                 seq_printf(m, "rptr next(0x%04x): 0x%08x [%5d]\n",
 756                            ring->rptr_save_reg, rptr_next, rptr_next);
 757         } else
 758                 rptr_next = ~0;
 759
 760         seq_printf(m, "driver's copy of the wptr: 0x%08x [%5d]\n",
 761                    ring->wptr, ring->wptr);
 762         seq_printf(m, "last semaphore signal addr : 0x%016llx\n",
 763                    ring->last_semaphore_signal_addr);
 764         seq_printf(m, "last semaphore wait addr   : 0x%016llx\n",
 765                    ring->last_semaphore_wait_addr);
 766         seq_printf(m, "%u free dwords in ring\n", ring->ring_free_dw);
 767         seq_printf(m, "%u dwords in ring\n", count);
 768
 769         if (!ring->ready)
 770                 return 0;
 771
 772         /* print 8 dw before current rptr as often it's the last executed
 773          * packet that is the root issue
 774          */
 775         i = (rptr + ring->ptr_mask + 1 - 32) & ring->ptr_mask;
 776         for (j = 0; j <= (count + 32); j++) {
 777                 seq_printf(m, "r[%5d]=0x%08x", i, ring->ring[i]);
 778                 if (rptr == i)
 779                         seq_puts(m, " *");
 780                 if (rptr_next == i)
 781                         seq_puts(m, " #");
 782                 seq_puts(m, "\n");
 783                 i = (i + 1) & ring->ptr_mask;
 784         }
 785         return 0;
 786 }
 787
 788 static int radeon_gfx_index = RADEON_RING_TYPE_GFX_INDEX;
 789 static int cayman_cp1_index = CAYMAN_RING_TYPE_CP1_INDEX;
 790 static int cayman_cp2_index = CAYMAN_RING_TYPE_CP2_INDEX;
 791 static int radeon_dma1_index = R600_RING_TYPE_DMA_INDEX;
 792 static int radeon_dma2_index = CAYMAN_RING_TYPE_DMA1_INDEX;
 793 static int r600_uvd_index = R600_RING_TYPE_UVD_INDEX;
 794 static int si_vce1_index = TN_RING_TYPE_VCE1_INDEX;
 795 static int si_vce2_index = TN_RING_TYPE_VCE2_INDEX;
 796
 797 static struct drm_info_list radeon_debugfs_ring_info_list[] = {
 798         {"radeon_ring_gfx", radeon_debugfs_ring_info, 0, &radeon_gfx_index},
 799         {"radeon_ring_cp1", radeon_debugfs_ring_info, 0, &cayman_cp1_index},
 800         {"radeon_ring_cp2", radeon_debugfs_ring_info, 0, &cayman_cp2_index},
 801         {"radeon_ring_dma1", radeon_debugfs_ring_info, 0, &radeon_dma1_index},
 802         {"radeon_ring_dma2", radeon_debugfs_ring_info, 0, &radeon_dma2_index},
 803         {"radeon_ring_uvd", radeon_debugfs_ring_info, 0, &r600_uvd_index},
 804         {"radeon_ring_vce1", radeon_debugfs_ring_info, 0, &si_vce1_index},
 805         {"radeon_ring_vce2", radeon_debugfs_ring_info, 0, &si_vce2_index},
 806 };
 807
 808 static int radeon_debugfs_sa_info(struct seq_file *m, void *data)
 809 {
 810         struct drm_info_node *node = (struct drm_info_node *) m->private;
 811         struct drm_device *dev = node->minor->dev;
 812         struct radeon_device *rdev = dev->dev_private;
 813
 814         radeon_sa_bo_dump_debug_info(&rdev->ring_tmp_bo, m);
 815
 816         return 0;
 817
 818 }
 819
 820 static struct drm_info_list radeon_debugfs_sa_list[] = {
 821         {"radeon_sa_info", &radeon_debugfs_sa_info, 0, NULL},
 822 };
 823
 824 #endif
 825
 826 static int radeon_debugfs_ring_init(struct radeon_device *rdev, struct radeon_ring *ring)
 827 {
 828 #if defined(CONFIG_DEBUG_FS)
 829         unsigned i;
 830         for (i = 0; i < ARRAY_SIZE(radeon_debugfs_ring_info_list); ++i) {
 831                 struct drm_info_list *info = &radeon_debugfs_ring_info_list[i];
 832                 int ridx = *(int*)radeon_debugfs_ring_info_list[i].data;
 833                 unsigned r;
 834
 835                 if (&rdev->ring[ridx] != ring)
 836                         continue;
 837
 838                 r = radeon_debugfs_add_files(rdev, info, 1);
 839                 if (r)
 840                         return r;
 841         }
 842 #endif
 843         return 0;
 844 }
 845
 846 static int radeon_debugfs_sa_init(struct radeon_device *rdev)
 847 {
 848 #if defined(CONFIG_DEBUG_FS)
 849         return radeon_debugfs_add_files(rdev, radeon_debugfs_sa_list, 1);
 850 #else
 851         return 0;
 852 #endif
 853 }