Subversion Repositories Kolibri OS

Rev

Rev 5078 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. /*
  2.  * Copyright 2009 VMware, Inc.
  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 shall be included in
  12.  * all copies or substantial portions of the Software.
  13.  *
  14.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15.  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  17.  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  18.  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  19.  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  20.  * OTHER DEALINGS IN THE SOFTWARE.
  21.  *
  22.  * Authors: Michel Dänzer
  23.  */
  24. #include <drm/drmP.h>
  25. #include <drm/radeon_drm.h>
  26. #include "radeon_reg.h"
  27. #include "radeon.h"
  28.  
  29. #define RADEON_TEST_COPY_BLIT 1
  30. #define RADEON_TEST_COPY_DMA  0
  31.  
  32.  
  33. /* Test BO GTT->VRAM and VRAM->GTT GPU copies across the whole GTT aperture */
  34. static void radeon_do_test_moves(struct radeon_device *rdev, int flag)
  35. {
  36.         struct radeon_bo *vram_obj = NULL;
  37.         struct radeon_bo **gtt_obj = NULL;
  38.         uint64_t gtt_addr, vram_addr;
  39.         unsigned n, size;
  40.         int i, r, ring;
  41.  
  42.         switch (flag) {
  43.         case RADEON_TEST_COPY_DMA:
  44.                 ring = radeon_copy_dma_ring_index(rdev);
  45.                 break;
  46.         case RADEON_TEST_COPY_BLIT:
  47.                 ring = radeon_copy_blit_ring_index(rdev);
  48.                 break;
  49.         default:
  50.                 DRM_ERROR("Unknown copy method\n");
  51.                 return;
  52.         }
  53.  
  54.         size = 1024 * 1024;
  55.  
  56.         /* Number of tests =
  57.          * (Total GTT - IB pool - writeback page - ring buffers) / test size
  58.          */
  59.         n = rdev->mc.gtt_size - rdev->gart_pin_size;
  60.         n /= size;
  61.  
  62.         gtt_obj = kzalloc(n * sizeof(*gtt_obj), GFP_KERNEL);
  63.         if (!gtt_obj) {
  64.                 DRM_ERROR("Failed to allocate %d pointers\n", n);
  65.                 r = 1;
  66.                 goto out_cleanup;
  67.         }
  68.  
  69.         r = radeon_bo_create(rdev, size, PAGE_SIZE, true, RADEON_GEM_DOMAIN_VRAM,
  70.                              0, NULL, NULL, &vram_obj);
  71.         if (r) {
  72.                 DRM_ERROR("Failed to create VRAM object\n");
  73.                 goto out_cleanup;
  74.         }
  75.         r = radeon_bo_reserve(vram_obj, false);
  76.         if (unlikely(r != 0))
  77.                 goto out_unref;
  78.         r = radeon_bo_pin(vram_obj, RADEON_GEM_DOMAIN_VRAM, &vram_addr);
  79.         if (r) {
  80.                 DRM_ERROR("Failed to pin VRAM object\n");
  81.                 goto out_unres;
  82.         }
  83.         for (i = 0; i < n; i++) {
  84.                 void *gtt_map, *vram_map;
  85.                 void **gtt_start, **gtt_end;
  86.                 void **vram_start, **vram_end;
  87.                 struct radeon_fence *fence = NULL;
  88.  
  89.                 r = radeon_bo_create(rdev, size, PAGE_SIZE, true,
  90.                                      RADEON_GEM_DOMAIN_GTT, 0, NULL, NULL,
  91.                                      gtt_obj + i);
  92.                 if (r) {
  93.                         DRM_ERROR("Failed to create GTT object %d\n", i);
  94.                         goto out_lclean;
  95.                 }
  96.  
  97.                 r = radeon_bo_reserve(gtt_obj[i], false);
  98.                 if (unlikely(r != 0))
  99.                         goto out_lclean_unref;
  100.                 r = radeon_bo_pin(gtt_obj[i], RADEON_GEM_DOMAIN_GTT, &gtt_addr);
  101.                 if (r) {
  102.                         DRM_ERROR("Failed to pin GTT object %d\n", i);
  103.                         goto out_lclean_unres;
  104.                 }
  105.  
  106.                 r = radeon_bo_kmap(gtt_obj[i], &gtt_map);
  107.                 if (r) {
  108.                         DRM_ERROR("Failed to map GTT object %d\n", i);
  109.                         goto out_lclean_unpin;
  110.                 }
  111.  
  112.                 for (gtt_start = gtt_map, gtt_end = gtt_map + size;
  113.                      gtt_start < gtt_end;
  114.                      gtt_start++)
  115.                         *gtt_start = gtt_start;
  116.  
  117.                 radeon_bo_kunmap(gtt_obj[i]);
  118.  
  119.                 if (ring == R600_RING_TYPE_DMA_INDEX)
  120.                         fence = radeon_copy_dma(rdev, gtt_addr, vram_addr,
  121.                                                 size / RADEON_GPU_PAGE_SIZE,
  122.                                                 NULL);
  123.                 else
  124.                         fence = radeon_copy_blit(rdev, gtt_addr, vram_addr,
  125.                                                  size / RADEON_GPU_PAGE_SIZE,
  126.                                                  NULL);
  127.                 if (IS_ERR(fence)) {
  128.                         DRM_ERROR("Failed GTT->VRAM copy %d\n", i);
  129.                         r = PTR_ERR(fence);
  130.                         goto out_lclean_unpin;
  131.                 }
  132.  
  133.                 r = radeon_fence_wait(fence, false);
  134.                 if (r) {
  135.                         DRM_ERROR("Failed to wait for GTT->VRAM fence %d\n", i);
  136.                         goto out_lclean_unpin;
  137.                 }
  138.  
  139.                 radeon_fence_unref(&fence);
  140.  
  141.                 r = radeon_bo_kmap(vram_obj, &vram_map);
  142.                 if (r) {
  143.                         DRM_ERROR("Failed to map VRAM object after copy %d\n", i);
  144.                         goto out_lclean_unpin;
  145.                 }
  146.  
  147.                 for (gtt_start = gtt_map, gtt_end = gtt_map + size,
  148.                      vram_start = vram_map, vram_end = vram_map + size;
  149.                      vram_start < vram_end;
  150.                      gtt_start++, vram_start++) {
  151.                         if (*vram_start != gtt_start) {
  152.                                 DRM_ERROR("Incorrect GTT->VRAM copy %d: Got 0x%p, "
  153.                                           "expected 0x%p (GTT/VRAM offset "
  154.                                           "0x%16llx/0x%16llx)\n",
  155.                                           i, *vram_start, gtt_start,
  156.                                           (unsigned long long)
  157.                                           (gtt_addr - rdev->mc.gtt_start +
  158.                                            (void*)gtt_start - gtt_map),
  159.                                           (unsigned long long)
  160.                                           (vram_addr - rdev->mc.vram_start +
  161.                                            (void*)gtt_start - gtt_map));
  162.                                 radeon_bo_kunmap(vram_obj);
  163.                                 goto out_lclean_unpin;
  164.                         }
  165.                         *vram_start = vram_start;
  166.                 }
  167.  
  168.                 radeon_bo_kunmap(vram_obj);
  169.  
  170.                 if (ring == R600_RING_TYPE_DMA_INDEX)
  171.                         fence = radeon_copy_dma(rdev, vram_addr, gtt_addr,
  172.                                                 size / RADEON_GPU_PAGE_SIZE,
  173.                                                 NULL);
  174.                 else
  175.                         fence = radeon_copy_blit(rdev, vram_addr, gtt_addr,
  176.                                                  size / RADEON_GPU_PAGE_SIZE,
  177.                                                  NULL);
  178.                 if (IS_ERR(fence)) {
  179.                         DRM_ERROR("Failed VRAM->GTT copy %d\n", i);
  180.                         r = PTR_ERR(fence);
  181.                         goto out_lclean_unpin;
  182.                 }
  183.  
  184.                 r = radeon_fence_wait(fence, false);
  185.                 if (r) {
  186.                         DRM_ERROR("Failed to wait for VRAM->GTT fence %d\n", i);
  187.                         goto out_lclean_unpin;
  188.                 }
  189.  
  190.                 radeon_fence_unref(&fence);
  191.  
  192.                 r = radeon_bo_kmap(gtt_obj[i], &gtt_map);
  193.                 if (r) {
  194.                         DRM_ERROR("Failed to map GTT object after copy %d\n", i);
  195.                         goto out_lclean_unpin;
  196.                 }
  197.  
  198.                 for (gtt_start = gtt_map, gtt_end = gtt_map + size,
  199.                      vram_start = vram_map, vram_end = vram_map + size;
  200.                      gtt_start < gtt_end;
  201.                      gtt_start++, vram_start++) {
  202.                         if (*gtt_start != vram_start) {
  203.                                 DRM_ERROR("Incorrect VRAM->GTT copy %d: Got 0x%p, "
  204.                                           "expected 0x%p (VRAM/GTT offset "
  205.                                           "0x%16llx/0x%16llx)\n",
  206.                                           i, *gtt_start, vram_start,
  207.                                           (unsigned long long)
  208.                                           (vram_addr - rdev->mc.vram_start +
  209.                                            (void*)vram_start - vram_map),
  210.                                           (unsigned long long)
  211.                                           (gtt_addr - rdev->mc.gtt_start +
  212.                                            (void*)vram_start - vram_map));
  213.                                 radeon_bo_kunmap(gtt_obj[i]);
  214.                                 goto out_lclean_unpin;
  215.                         }
  216.                 }
  217.  
  218.                 radeon_bo_kunmap(gtt_obj[i]);
  219.  
  220.                 DRM_INFO("Tested GTT->VRAM and VRAM->GTT copy for GTT offset 0x%llx\n",
  221.                          gtt_addr - rdev->mc.gtt_start);
  222.                 continue;
  223.  
  224. out_lclean_unpin:
  225.                 radeon_bo_unpin(gtt_obj[i]);
  226. out_lclean_unres:
  227.                 radeon_bo_unreserve(gtt_obj[i]);
  228. out_lclean_unref:
  229.                 radeon_bo_unref(&gtt_obj[i]);
  230. out_lclean:
  231.                 for (--i; i >= 0; --i) {
  232.                         radeon_bo_unpin(gtt_obj[i]);
  233.                         radeon_bo_unreserve(gtt_obj[i]);
  234.                         radeon_bo_unref(&gtt_obj[i]);
  235.                 }
  236.                 if (fence && !IS_ERR(fence))
  237.                         radeon_fence_unref(&fence);
  238.                 break;
  239.         }
  240.  
  241.         radeon_bo_unpin(vram_obj);
  242. out_unres:
  243.         radeon_bo_unreserve(vram_obj);
  244. out_unref:
  245.         radeon_bo_unref(&vram_obj);
  246. out_cleanup:
  247.         kfree(gtt_obj);
  248.         if (r) {
  249.                 printk(KERN_WARNING "Error while testing BO move.\n");
  250.         }
  251. }
  252.  
  253. void radeon_test_moves(struct radeon_device *rdev)
  254. {
  255.         if (rdev->asic->copy.dma)
  256.                 radeon_do_test_moves(rdev, RADEON_TEST_COPY_DMA);
  257.         if (rdev->asic->copy.blit)
  258.                 radeon_do_test_moves(rdev, RADEON_TEST_COPY_BLIT);
  259. }
  260.  
  261. static int radeon_test_create_and_emit_fence(struct radeon_device *rdev,
  262.                                              struct radeon_ring *ring,
  263.                                              struct radeon_fence **fence)
  264. {
  265.         uint32_t handle = ring->idx ^ 0xdeafbeef;
  266.         int r;
  267.  
  268.         if (ring->idx == R600_RING_TYPE_UVD_INDEX) {
  269. #if 0
  270.                 r = radeon_uvd_get_create_msg(rdev, ring->idx, handle, NULL);
  271.                 if (r) {
  272.                         DRM_ERROR("Failed to get dummy create msg\n");
  273.                         return r;
  274.                 }
  275.  
  276.                 r = radeon_uvd_get_destroy_msg(rdev, ring->idx, handle, fence);
  277.                 if (r) {
  278.                         DRM_ERROR("Failed to get dummy destroy msg\n");
  279.                         return r;
  280.                 }
  281. #endif
  282.         } else if (ring->idx == TN_RING_TYPE_VCE1_INDEX ||
  283.                    ring->idx == TN_RING_TYPE_VCE2_INDEX) {
  284. #if 0
  285.                 r = radeon_vce_get_create_msg(rdev, ring->idx, handle, NULL);
  286.                 if (r) {
  287.                         DRM_ERROR("Failed to get dummy create msg\n");
  288.                         return r;
  289.                 }
  290.  
  291.                 r = radeon_vce_get_destroy_msg(rdev, ring->idx, handle, fence);
  292.                 if (r) {
  293.                         DRM_ERROR("Failed to get dummy destroy msg\n");
  294.                         return r;
  295.                 }
  296. #endif
  297.         } else {
  298.                 r = radeon_ring_lock(rdev, ring, 64);
  299.                 if (r) {
  300.                         DRM_ERROR("Failed to lock ring A %d\n", ring->idx);
  301.                         return r;
  302.                 }
  303.                 radeon_fence_emit(rdev, fence, ring->idx);
  304.                 radeon_ring_unlock_commit(rdev, ring, false);
  305.         }
  306.         return 0;
  307. }
  308.  
  309. void radeon_test_ring_sync(struct radeon_device *rdev,
  310.                            struct radeon_ring *ringA,
  311.                            struct radeon_ring *ringB)
  312. {
  313.         struct radeon_fence *fence1 = NULL, *fence2 = NULL;
  314.         struct radeon_semaphore *semaphore = NULL;
  315.         int r;
  316.  
  317.         r = radeon_semaphore_create(rdev, &semaphore);
  318.         if (r) {
  319.                 DRM_ERROR("Failed to create semaphore\n");
  320.                 goto out_cleanup;
  321.         }
  322.  
  323.         r = radeon_ring_lock(rdev, ringA, 64);
  324.         if (r) {
  325.                 DRM_ERROR("Failed to lock ring A %d\n", ringA->idx);
  326.                 goto out_cleanup;
  327.         }
  328.         radeon_semaphore_emit_wait(rdev, ringA->idx, semaphore);
  329.         radeon_ring_unlock_commit(rdev, ringA, false);
  330.  
  331.         r = radeon_test_create_and_emit_fence(rdev, ringA, &fence1);
  332.         if (r)
  333.                 goto out_cleanup;
  334.  
  335.         r = radeon_ring_lock(rdev, ringA, 64);
  336.         if (r) {
  337.                 DRM_ERROR("Failed to lock ring A %d\n", ringA->idx);
  338.                 goto out_cleanup;
  339.         }
  340.         radeon_semaphore_emit_wait(rdev, ringA->idx, semaphore);
  341.         radeon_ring_unlock_commit(rdev, ringA, false);
  342.  
  343.         r = radeon_test_create_and_emit_fence(rdev, ringA, &fence2);
  344.         if (r)
  345.                 goto out_cleanup;
  346.  
  347.         mdelay(1000);
  348.  
  349.         if (radeon_fence_signaled(fence1)) {
  350.                 DRM_ERROR("Fence 1 signaled without waiting for semaphore.\n");
  351.                 goto out_cleanup;
  352.         }
  353.  
  354.         r = radeon_ring_lock(rdev, ringB, 64);
  355.         if (r) {
  356.                 DRM_ERROR("Failed to lock ring B %p\n", ringB);
  357.                 goto out_cleanup;
  358.         }
  359.         radeon_semaphore_emit_signal(rdev, ringB->idx, semaphore);
  360.         radeon_ring_unlock_commit(rdev, ringB, false);
  361.  
  362.         r = radeon_fence_wait(fence1, false);
  363.         if (r) {
  364.                 DRM_ERROR("Failed to wait for sync fence 1\n");
  365.                 goto out_cleanup;
  366.         }
  367.  
  368.         mdelay(1000);
  369.  
  370.         if (radeon_fence_signaled(fence2)) {
  371.                 DRM_ERROR("Fence 2 signaled without waiting for semaphore.\n");
  372.                 goto out_cleanup;
  373.         }
  374.  
  375.         r = radeon_ring_lock(rdev, ringB, 64);
  376.         if (r) {
  377.                 DRM_ERROR("Failed to lock ring B %p\n", ringB);
  378.                 goto out_cleanup;
  379.         }
  380.         radeon_semaphore_emit_signal(rdev, ringB->idx, semaphore);
  381.         radeon_ring_unlock_commit(rdev, ringB, false);
  382.  
  383.         r = radeon_fence_wait(fence2, false);
  384.         if (r) {
  385.                 DRM_ERROR("Failed to wait for sync fence 1\n");
  386.                 goto out_cleanup;
  387.         }
  388.  
  389. out_cleanup:
  390.         radeon_semaphore_free(rdev, &semaphore, NULL);
  391.  
  392.         if (fence1)
  393.                 radeon_fence_unref(&fence1);
  394.  
  395.         if (fence2)
  396.                 radeon_fence_unref(&fence2);
  397.  
  398.         if (r)
  399.                 printk(KERN_WARNING "Error while testing ring sync (%d).\n", r);
  400. }
  401.  
  402. static void radeon_test_ring_sync2(struct radeon_device *rdev,
  403.                             struct radeon_ring *ringA,
  404.                             struct radeon_ring *ringB,
  405.                             struct radeon_ring *ringC)
  406. {
  407.         struct radeon_fence *fenceA = NULL, *fenceB = NULL;
  408.         struct radeon_semaphore *semaphore = NULL;
  409.         bool sigA, sigB;
  410.         int i, r;
  411.  
  412.         r = radeon_semaphore_create(rdev, &semaphore);
  413.         if (r) {
  414.                 DRM_ERROR("Failed to create semaphore\n");
  415.                 goto out_cleanup;
  416.         }
  417.  
  418.         r = radeon_ring_lock(rdev, ringA, 64);
  419.         if (r) {
  420.                 DRM_ERROR("Failed to lock ring A %d\n", ringA->idx);
  421.                 goto out_cleanup;
  422.         }
  423.         radeon_semaphore_emit_wait(rdev, ringA->idx, semaphore);
  424.         radeon_ring_unlock_commit(rdev, ringA, false);
  425.  
  426.         r = radeon_test_create_and_emit_fence(rdev, ringA, &fenceA);
  427.         if (r)
  428.                 goto out_cleanup;
  429.  
  430.         r = radeon_ring_lock(rdev, ringB, 64);
  431.         if (r) {
  432.                 DRM_ERROR("Failed to lock ring B %d\n", ringB->idx);
  433.                 goto out_cleanup;
  434.         }
  435.         radeon_semaphore_emit_wait(rdev, ringB->idx, semaphore);
  436.         radeon_ring_unlock_commit(rdev, ringB, false);
  437.         r = radeon_test_create_and_emit_fence(rdev, ringB, &fenceB);
  438.         if (r)
  439.                 goto out_cleanup;
  440.  
  441.         mdelay(1000);
  442.  
  443.         if (radeon_fence_signaled(fenceA)) {
  444.                 DRM_ERROR("Fence A signaled without waiting for semaphore.\n");
  445.                 goto out_cleanup;
  446.         }
  447.         if (radeon_fence_signaled(fenceB)) {
  448.                 DRM_ERROR("Fence B signaled without waiting for semaphore.\n");
  449.                 goto out_cleanup;
  450.         }
  451.  
  452.         r = radeon_ring_lock(rdev, ringC, 64);
  453.         if (r) {
  454.                 DRM_ERROR("Failed to lock ring B %p\n", ringC);
  455.                 goto out_cleanup;
  456.         }
  457.         radeon_semaphore_emit_signal(rdev, ringC->idx, semaphore);
  458.         radeon_ring_unlock_commit(rdev, ringC, false);
  459.  
  460.         for (i = 0; i < 30; ++i) {
  461.                 mdelay(100);
  462.                 sigA = radeon_fence_signaled(fenceA);
  463.                 sigB = radeon_fence_signaled(fenceB);
  464.                 if (sigA || sigB)
  465.                         break;
  466.         }
  467.  
  468.         if (!sigA && !sigB) {
  469.                 DRM_ERROR("Neither fence A nor B has been signaled\n");
  470.                 goto out_cleanup;
  471.         } else if (sigA && sigB) {
  472.                 DRM_ERROR("Both fence A and B has been signaled\n");
  473.                 goto out_cleanup;
  474.         }
  475.  
  476.         DRM_INFO("Fence %c was first signaled\n", sigA ? 'A' : 'B');
  477.  
  478.         r = radeon_ring_lock(rdev, ringC, 64);
  479.         if (r) {
  480.                 DRM_ERROR("Failed to lock ring B %p\n", ringC);
  481.                 goto out_cleanup;
  482.         }
  483.         radeon_semaphore_emit_signal(rdev, ringC->idx, semaphore);
  484.         radeon_ring_unlock_commit(rdev, ringC, false);
  485.  
  486.         mdelay(1000);
  487.  
  488.         r = radeon_fence_wait(fenceA, false);
  489.         if (r) {
  490.                 DRM_ERROR("Failed to wait for sync fence A\n");
  491.                 goto out_cleanup;
  492.         }
  493.         r = radeon_fence_wait(fenceB, false);
  494.         if (r) {
  495.                 DRM_ERROR("Failed to wait for sync fence B\n");
  496.                 goto out_cleanup;
  497.         }
  498.  
  499. out_cleanup:
  500.         radeon_semaphore_free(rdev, &semaphore, NULL);
  501.  
  502.         if (fenceA)
  503.                 radeon_fence_unref(&fenceA);
  504.  
  505.         if (fenceB)
  506.                 radeon_fence_unref(&fenceB);
  507.  
  508.         if (r)
  509.                 printk(KERN_WARNING "Error while testing ring sync (%d).\n", r);
  510. }
  511.  
  512. static bool radeon_test_sync_possible(struct radeon_ring *ringA,
  513.                                       struct radeon_ring *ringB)
  514. {
  515.         if (ringA->idx == TN_RING_TYPE_VCE2_INDEX &&
  516.             ringB->idx == TN_RING_TYPE_VCE1_INDEX)
  517.                 return false;
  518.  
  519.         return true;
  520. }
  521.  
  522. void radeon_test_syncing(struct radeon_device *rdev)
  523. {
  524.         int i, j, k;
  525.  
  526.         for (i = 1; i < RADEON_NUM_RINGS; ++i) {
  527.                 struct radeon_ring *ringA = &rdev->ring[i];
  528.                 if (!ringA->ready)
  529.                         continue;
  530.  
  531.                 for (j = 0; j < i; ++j) {
  532.                         struct radeon_ring *ringB = &rdev->ring[j];
  533.                         if (!ringB->ready)
  534.                                 continue;
  535.  
  536.                         if (!radeon_test_sync_possible(ringA, ringB))
  537.                                 continue;
  538.  
  539.                         DRM_INFO("Testing syncing between rings %d and %d...\n", i, j);
  540.                         radeon_test_ring_sync(rdev, ringA, ringB);
  541.  
  542.                         DRM_INFO("Testing syncing between rings %d and %d...\n", j, i);
  543.                         radeon_test_ring_sync(rdev, ringB, ringA);
  544.  
  545.                         for (k = 0; k < j; ++k) {
  546.                                 struct radeon_ring *ringC = &rdev->ring[k];
  547.                                 if (!ringC->ready)
  548.                                         continue;
  549.  
  550.                                 if (!radeon_test_sync_possible(ringA, ringC))
  551.                                         continue;
  552.  
  553.                                 if (!radeon_test_sync_possible(ringB, ringC))
  554.                                         continue;
  555.  
  556.                                 DRM_INFO("Testing syncing between rings %d, %d and %d...\n", i, j, k);
  557.                                 radeon_test_ring_sync2(rdev, ringA, ringB, ringC);
  558.  
  559.                                 DRM_INFO("Testing syncing between rings %d, %d and %d...\n", i, k, j);
  560.                                 radeon_test_ring_sync2(rdev, ringA, ringC, ringB);
  561.  
  562.                                 DRM_INFO("Testing syncing between rings %d, %d and %d...\n", j, i, k);
  563.                                 radeon_test_ring_sync2(rdev, ringB, ringA, ringC);
  564.  
  565.                                 DRM_INFO("Testing syncing between rings %d, %d and %d...\n", j, k, i);
  566.                                 radeon_test_ring_sync2(rdev, ringB, ringC, ringA);
  567.  
  568.                                 DRM_INFO("Testing syncing between rings %d, %d and %d...\n", k, i, j);
  569.                                 radeon_test_ring_sync2(rdev, ringC, ringA, ringB);
  570.  
  571.                                 DRM_INFO("Testing syncing between rings %d, %d and %d...\n", k, j, i);
  572.                                 radeon_test_ring_sync2(rdev, ringC, ringB, ringA);
  573.                         }
  574.                 }
  575.         }
  576. }
  577.