Subversion Repositories Kolibri OS

Rev

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, &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, gtt_obj + i);
  91.                 if (r) {
  92.                         DRM_ERROR("Failed to create GTT object %d\n", i);
  93.                         goto out_lclean;
  94.                 }
  95.  
  96.                 r = radeon_bo_reserve(gtt_obj[i], false);
  97.                 if (unlikely(r != 0))
  98.                         goto out_lclean_unref;
  99.                 r = radeon_bo_pin(gtt_obj[i], RADEON_GEM_DOMAIN_GTT, &gtt_addr);
  100.                 if (r) {
  101.                         DRM_ERROR("Failed to pin GTT object %d\n", i);
  102.                         goto out_lclean_unres;
  103.                 }
  104.  
  105.                 r = radeon_bo_kmap(gtt_obj[i], &gtt_map);
  106.                 if (r) {
  107.                         DRM_ERROR("Failed to map GTT object %d\n", i);
  108.                         goto out_lclean_unpin;
  109.                 }
  110.  
  111.                 for (gtt_start = gtt_map, gtt_end = gtt_map + size;
  112.                      gtt_start < gtt_end;
  113.                      gtt_start++)
  114.                         *gtt_start = gtt_start;
  115.  
  116.                 radeon_bo_kunmap(gtt_obj[i]);
  117.  
  118.                 if (ring == R600_RING_TYPE_DMA_INDEX)
  119.                         r = radeon_copy_dma(rdev, gtt_addr, vram_addr, size / RADEON_GPU_PAGE_SIZE, &fence);
  120.                 else
  121.                         r = radeon_copy_blit(rdev, gtt_addr, vram_addr, size / RADEON_GPU_PAGE_SIZE, &fence);
  122.                 if (r) {
  123.                         DRM_ERROR("Failed GTT->VRAM copy %d\n", i);
  124.                         goto out_lclean_unpin;
  125.                 }
  126.  
  127.                 r = radeon_fence_wait(fence, false);
  128.                 if (r) {
  129.                         DRM_ERROR("Failed to wait for GTT->VRAM fence %d\n", i);
  130.                         goto out_lclean_unpin;
  131.                 }
  132.  
  133.                 radeon_fence_unref(&fence);
  134.  
  135.                 r = radeon_bo_kmap(vram_obj, &vram_map);
  136.                 if (r) {
  137.                         DRM_ERROR("Failed to map VRAM object after copy %d\n", i);
  138.                         goto out_lclean_unpin;
  139.                 }
  140.  
  141.                 for (gtt_start = gtt_map, gtt_end = gtt_map + size,
  142.                      vram_start = vram_map, vram_end = vram_map + size;
  143.                      vram_start < vram_end;
  144.                      gtt_start++, vram_start++) {
  145.                         if (*vram_start != gtt_start) {
  146.                                 DRM_ERROR("Incorrect GTT->VRAM copy %d: Got 0x%p, "
  147.                                           "expected 0x%p (GTT/VRAM offset "
  148.                                           "0x%16llx/0x%16llx)\n",
  149.                                           i, *vram_start, gtt_start,
  150.                                           (unsigned long long)
  151.                                           (gtt_addr - rdev->mc.gtt_start +
  152.                                            (void*)gtt_start - gtt_map),
  153.                                           (unsigned long long)
  154.                                           (vram_addr - rdev->mc.vram_start +
  155.                                            (void*)gtt_start - gtt_map));
  156.                                 radeon_bo_kunmap(vram_obj);
  157.                                 goto out_lclean_unpin;
  158.                         }
  159.                         *vram_start = vram_start;
  160.                 }
  161.  
  162.                 radeon_bo_kunmap(vram_obj);
  163.  
  164.                 if (ring == R600_RING_TYPE_DMA_INDEX)
  165.                         r = radeon_copy_dma(rdev, vram_addr, gtt_addr, size / RADEON_GPU_PAGE_SIZE, &fence);
  166.                 else
  167.                         r = radeon_copy_blit(rdev, vram_addr, gtt_addr, size / RADEON_GPU_PAGE_SIZE, &fence);
  168.                 if (r) {
  169.                         DRM_ERROR("Failed VRAM->GTT copy %d\n", i);
  170.                         goto out_lclean_unpin;
  171.                 }
  172.  
  173.                 r = radeon_fence_wait(fence, false);
  174.                 if (r) {
  175.                         DRM_ERROR("Failed to wait for VRAM->GTT fence %d\n", i);
  176.                         goto out_lclean_unpin;
  177.                 }
  178.  
  179.                 radeon_fence_unref(&fence);
  180.  
  181.                 r = radeon_bo_kmap(gtt_obj[i], &gtt_map);
  182.                 if (r) {
  183.                         DRM_ERROR("Failed to map GTT object after copy %d\n", i);
  184.                         goto out_lclean_unpin;
  185.                 }
  186.  
  187.                 for (gtt_start = gtt_map, gtt_end = gtt_map + size,
  188.                      vram_start = vram_map, vram_end = vram_map + size;
  189.                      gtt_start < gtt_end;
  190.                      gtt_start++, vram_start++) {
  191.                         if (*gtt_start != vram_start) {
  192.                                 DRM_ERROR("Incorrect VRAM->GTT copy %d: Got 0x%p, "
  193.                                           "expected 0x%p (VRAM/GTT offset "
  194.                                           "0x%16llx/0x%16llx)\n",
  195.                                           i, *gtt_start, vram_start,
  196.                                           (unsigned long long)
  197.                                           (vram_addr - rdev->mc.vram_start +
  198.                                            (void*)vram_start - vram_map),
  199.                                           (unsigned long long)
  200.                                           (gtt_addr - rdev->mc.gtt_start +
  201.                                            (void*)vram_start - vram_map));
  202.                                 radeon_bo_kunmap(gtt_obj[i]);
  203.                                 goto out_lclean_unpin;
  204.                         }
  205.                 }
  206.  
  207.                 radeon_bo_kunmap(gtt_obj[i]);
  208.  
  209.                 DRM_INFO("Tested GTT->VRAM and VRAM->GTT copy for GTT offset 0x%llx\n",
  210.                          gtt_addr - rdev->mc.gtt_start);
  211.                 continue;
  212.  
  213. out_lclean_unpin:
  214.                 radeon_bo_unpin(gtt_obj[i]);
  215. out_lclean_unres:
  216.                 radeon_bo_unreserve(gtt_obj[i]);
  217. out_lclean_unref:
  218.                 radeon_bo_unref(&gtt_obj[i]);
  219. out_lclean:
  220.                 for (--i; i >= 0; --i) {
  221.                         radeon_bo_unpin(gtt_obj[i]);
  222.                         radeon_bo_unreserve(gtt_obj[i]);
  223.                         radeon_bo_unref(&gtt_obj[i]);
  224.                 }
  225.                 if (fence)
  226.                         radeon_fence_unref(&fence);
  227.                 break;
  228.         }
  229.  
  230.         radeon_bo_unpin(vram_obj);
  231. out_unres:
  232.         radeon_bo_unreserve(vram_obj);
  233. out_unref:
  234.         radeon_bo_unref(&vram_obj);
  235. out_cleanup:
  236.         kfree(gtt_obj);
  237.         if (r) {
  238.                 printk(KERN_WARNING "Error while testing BO move.\n");
  239.         }
  240. }
  241.  
  242. void radeon_test_moves(struct radeon_device *rdev)
  243. {
  244.         if (rdev->asic->copy.dma)
  245.                 radeon_do_test_moves(rdev, RADEON_TEST_COPY_DMA);
  246.         if (rdev->asic->copy.blit)
  247.                 radeon_do_test_moves(rdev, RADEON_TEST_COPY_BLIT);
  248. }
  249.  
  250. static int radeon_test_create_and_emit_fence(struct radeon_device *rdev,
  251.                                              struct radeon_ring *ring,
  252.                                              struct radeon_fence **fence)
  253. {
  254.         uint32_t handle = ring->idx ^ 0xdeafbeef;
  255.         int r;
  256.  
  257.         if (ring->idx == R600_RING_TYPE_UVD_INDEX) {
  258. #if 0
  259.                 r = radeon_uvd_get_create_msg(rdev, ring->idx, handle, NULL);
  260.                 if (r) {
  261.                         DRM_ERROR("Failed to get dummy create msg\n");
  262.                         return r;
  263.                 }
  264.  
  265.                 r = radeon_uvd_get_destroy_msg(rdev, ring->idx, handle, fence);
  266.                 if (r) {
  267.                         DRM_ERROR("Failed to get dummy destroy msg\n");
  268.                         return r;
  269.                 }
  270. #endif
  271.         } else if (ring->idx == TN_RING_TYPE_VCE1_INDEX ||
  272.                    ring->idx == TN_RING_TYPE_VCE2_INDEX) {
  273. #if 0
  274.                 r = radeon_vce_get_create_msg(rdev, ring->idx, handle, NULL);
  275.                 if (r) {
  276.                         DRM_ERROR("Failed to get dummy create msg\n");
  277.                         return r;
  278.                 }
  279.  
  280.                 r = radeon_vce_get_destroy_msg(rdev, ring->idx, handle, fence);
  281.                 if (r) {
  282.                         DRM_ERROR("Failed to get dummy destroy msg\n");
  283.                         return r;
  284.                 }
  285. #endif
  286.         } else {
  287.                 r = radeon_ring_lock(rdev, ring, 64);
  288.                 if (r) {
  289.                         DRM_ERROR("Failed to lock ring A %d\n", ring->idx);
  290.                         return r;
  291.                 }
  292.                 radeon_fence_emit(rdev, fence, ring->idx);
  293.                 radeon_ring_unlock_commit(rdev, ring, false);
  294.         }
  295.         return 0;
  296. }
  297.  
  298. void radeon_test_ring_sync(struct radeon_device *rdev,
  299.                            struct radeon_ring *ringA,
  300.                            struct radeon_ring *ringB)
  301. {
  302.         struct radeon_fence *fence1 = NULL, *fence2 = NULL;
  303.         struct radeon_semaphore *semaphore = NULL;
  304.         int r;
  305.  
  306.         r = radeon_semaphore_create(rdev, &semaphore);
  307.         if (r) {
  308.                 DRM_ERROR("Failed to create semaphore\n");
  309.                 goto out_cleanup;
  310.         }
  311.  
  312.         r = radeon_ring_lock(rdev, ringA, 64);
  313.         if (r) {
  314.                 DRM_ERROR("Failed to lock ring A %d\n", ringA->idx);
  315.                 goto out_cleanup;
  316.         }
  317.         radeon_semaphore_emit_wait(rdev, ringA->idx, semaphore);
  318.         radeon_ring_unlock_commit(rdev, ringA, false);
  319.  
  320.         r = radeon_test_create_and_emit_fence(rdev, ringA, &fence1);
  321.         if (r)
  322.                 goto out_cleanup;
  323.  
  324.         r = radeon_ring_lock(rdev, ringA, 64);
  325.         if (r) {
  326.                 DRM_ERROR("Failed to lock ring A %d\n", ringA->idx);
  327.                 goto out_cleanup;
  328.         }
  329.         radeon_semaphore_emit_wait(rdev, ringA->idx, semaphore);
  330.         radeon_ring_unlock_commit(rdev, ringA, false);
  331.  
  332.         r = radeon_test_create_and_emit_fence(rdev, ringA, &fence2);
  333.         if (r)
  334.                 goto out_cleanup;
  335.  
  336.         mdelay(1000);
  337.  
  338.         if (radeon_fence_signaled(fence1)) {
  339.                 DRM_ERROR("Fence 1 signaled without waiting for semaphore.\n");
  340.                 goto out_cleanup;
  341.         }
  342.  
  343.         r = radeon_ring_lock(rdev, ringB, 64);
  344.         if (r) {
  345.                 DRM_ERROR("Failed to lock ring B %p\n", ringB);
  346.                 goto out_cleanup;
  347.         }
  348.         radeon_semaphore_emit_signal(rdev, ringB->idx, semaphore);
  349.         radeon_ring_unlock_commit(rdev, ringB, false);
  350.  
  351.         r = radeon_fence_wait(fence1, false);
  352.         if (r) {
  353.                 DRM_ERROR("Failed to wait for sync fence 1\n");
  354.                 goto out_cleanup;
  355.         }
  356.  
  357.         mdelay(1000);
  358.  
  359.         if (radeon_fence_signaled(fence2)) {
  360.                 DRM_ERROR("Fence 2 signaled without waiting for semaphore.\n");
  361.                 goto out_cleanup;
  362.         }
  363.  
  364.         r = radeon_ring_lock(rdev, ringB, 64);
  365.         if (r) {
  366.                 DRM_ERROR("Failed to lock ring B %p\n", ringB);
  367.                 goto out_cleanup;
  368.         }
  369.         radeon_semaphore_emit_signal(rdev, ringB->idx, semaphore);
  370.         radeon_ring_unlock_commit(rdev, ringB, false);
  371.  
  372.         r = radeon_fence_wait(fence2, false);
  373.         if (r) {
  374.                 DRM_ERROR("Failed to wait for sync fence 1\n");
  375.                 goto out_cleanup;
  376.         }
  377.  
  378. out_cleanup:
  379.         radeon_semaphore_free(rdev, &semaphore, NULL);
  380.  
  381.         if (fence1)
  382.                 radeon_fence_unref(&fence1);
  383.  
  384.         if (fence2)
  385.                 radeon_fence_unref(&fence2);
  386.  
  387.         if (r)
  388.                 printk(KERN_WARNING "Error while testing ring sync (%d).\n", r);
  389. }
  390.  
  391. static void radeon_test_ring_sync2(struct radeon_device *rdev,
  392.                             struct radeon_ring *ringA,
  393.                             struct radeon_ring *ringB,
  394.                             struct radeon_ring *ringC)
  395. {
  396.         struct radeon_fence *fenceA = NULL, *fenceB = NULL;
  397.         struct radeon_semaphore *semaphore = NULL;
  398.         bool sigA, sigB;
  399.         int i, r;
  400.  
  401.         r = radeon_semaphore_create(rdev, &semaphore);
  402.         if (r) {
  403.                 DRM_ERROR("Failed to create semaphore\n");
  404.                 goto out_cleanup;
  405.         }
  406.  
  407.         r = radeon_ring_lock(rdev, ringA, 64);
  408.         if (r) {
  409.                 DRM_ERROR("Failed to lock ring A %d\n", ringA->idx);
  410.                 goto out_cleanup;
  411.         }
  412.         radeon_semaphore_emit_wait(rdev, ringA->idx, semaphore);
  413.         radeon_ring_unlock_commit(rdev, ringA, false);
  414.  
  415.         r = radeon_test_create_and_emit_fence(rdev, ringA, &fenceA);
  416.         if (r)
  417.                 goto out_cleanup;
  418.  
  419.         r = radeon_ring_lock(rdev, ringB, 64);
  420.         if (r) {
  421.                 DRM_ERROR("Failed to lock ring B %d\n", ringB->idx);
  422.                 goto out_cleanup;
  423.         }
  424.         radeon_semaphore_emit_wait(rdev, ringB->idx, semaphore);
  425.         radeon_ring_unlock_commit(rdev, ringB, false);
  426.         r = radeon_test_create_and_emit_fence(rdev, ringB, &fenceB);
  427.         if (r)
  428.                 goto out_cleanup;
  429.  
  430.         mdelay(1000);
  431.  
  432.         if (radeon_fence_signaled(fenceA)) {
  433.                 DRM_ERROR("Fence A signaled without waiting for semaphore.\n");
  434.                 goto out_cleanup;
  435.         }
  436.         if (radeon_fence_signaled(fenceB)) {
  437.                 DRM_ERROR("Fence B signaled without waiting for semaphore.\n");
  438.                 goto out_cleanup;
  439.         }
  440.  
  441.         r = radeon_ring_lock(rdev, ringC, 64);
  442.         if (r) {
  443.                 DRM_ERROR("Failed to lock ring B %p\n", ringC);
  444.                 goto out_cleanup;
  445.         }
  446.         radeon_semaphore_emit_signal(rdev, ringC->idx, semaphore);
  447.         radeon_ring_unlock_commit(rdev, ringC, false);
  448.  
  449.         for (i = 0; i < 30; ++i) {
  450.                 mdelay(100);
  451.                 sigA = radeon_fence_signaled(fenceA);
  452.                 sigB = radeon_fence_signaled(fenceB);
  453.                 if (sigA || sigB)
  454.                         break;
  455.         }
  456.  
  457.         if (!sigA && !sigB) {
  458.                 DRM_ERROR("Neither fence A nor B has been signaled\n");
  459.                 goto out_cleanup;
  460.         } else if (sigA && sigB) {
  461.                 DRM_ERROR("Both fence A and B has been signaled\n");
  462.                 goto out_cleanup;
  463.         }
  464.  
  465.         DRM_INFO("Fence %c was first signaled\n", sigA ? 'A' : 'B');
  466.  
  467.         r = radeon_ring_lock(rdev, ringC, 64);
  468.         if (r) {
  469.                 DRM_ERROR("Failed to lock ring B %p\n", ringC);
  470.                 goto out_cleanup;
  471.         }
  472.         radeon_semaphore_emit_signal(rdev, ringC->idx, semaphore);
  473.         radeon_ring_unlock_commit(rdev, ringC, false);
  474.  
  475.         mdelay(1000);
  476.  
  477.         r = radeon_fence_wait(fenceA, false);
  478.         if (r) {
  479.                 DRM_ERROR("Failed to wait for sync fence A\n");
  480.                 goto out_cleanup;
  481.         }
  482.         r = radeon_fence_wait(fenceB, false);
  483.         if (r) {
  484.                 DRM_ERROR("Failed to wait for sync fence B\n");
  485.                 goto out_cleanup;
  486.         }
  487.  
  488. out_cleanup:
  489.         radeon_semaphore_free(rdev, &semaphore, NULL);
  490.  
  491.         if (fenceA)
  492.                 radeon_fence_unref(&fenceA);
  493.  
  494.         if (fenceB)
  495.                 radeon_fence_unref(&fenceB);
  496.  
  497.         if (r)
  498.                 printk(KERN_WARNING "Error while testing ring sync (%d).\n", r);
  499. }
  500.  
  501. static bool radeon_test_sync_possible(struct radeon_ring *ringA,
  502.                                       struct radeon_ring *ringB)
  503. {
  504.         if (ringA->idx == TN_RING_TYPE_VCE2_INDEX &&
  505.             ringB->idx == TN_RING_TYPE_VCE1_INDEX)
  506.                 return false;
  507.  
  508.         return true;
  509. }
  510.  
  511. void radeon_test_syncing(struct radeon_device *rdev)
  512. {
  513.         int i, j, k;
  514.  
  515.         for (i = 1; i < RADEON_NUM_RINGS; ++i) {
  516.                 struct radeon_ring *ringA = &rdev->ring[i];
  517.                 if (!ringA->ready)
  518.                         continue;
  519.  
  520.                 for (j = 0; j < i; ++j) {
  521.                         struct radeon_ring *ringB = &rdev->ring[j];
  522.                         if (!ringB->ready)
  523.                                 continue;
  524.  
  525.                         if (!radeon_test_sync_possible(ringA, ringB))
  526.                                 continue;
  527.  
  528.                         DRM_INFO("Testing syncing between rings %d and %d...\n", i, j);
  529.                         radeon_test_ring_sync(rdev, ringA, ringB);
  530.  
  531.                         DRM_INFO("Testing syncing between rings %d and %d...\n", j, i);
  532.                         radeon_test_ring_sync(rdev, ringB, ringA);
  533.  
  534.                         for (k = 0; k < j; ++k) {
  535.                                 struct radeon_ring *ringC = &rdev->ring[k];
  536.                                 if (!ringC->ready)
  537.                                         continue;
  538.  
  539.                                 if (!radeon_test_sync_possible(ringA, ringC))
  540.                                         continue;
  541.  
  542.                                 if (!radeon_test_sync_possible(ringB, ringC))
  543.                                         continue;
  544.  
  545.                                 DRM_INFO("Testing syncing between rings %d, %d and %d...\n", i, j, k);
  546.                                 radeon_test_ring_sync2(rdev, ringA, ringB, ringC);
  547.  
  548.                                 DRM_INFO("Testing syncing between rings %d, %d and %d...\n", i, k, j);
  549.                                 radeon_test_ring_sync2(rdev, ringA, ringC, ringB);
  550.  
  551.                                 DRM_INFO("Testing syncing between rings %d, %d and %d...\n", j, i, k);
  552.                                 radeon_test_ring_sync2(rdev, ringB, ringA, ringC);
  553.  
  554.                                 DRM_INFO("Testing syncing between rings %d, %d and %d...\n", j, k, i);
  555.                                 radeon_test_ring_sync2(rdev, ringB, ringC, ringA);
  556.  
  557.                                 DRM_INFO("Testing syncing between rings %d, %d and %d...\n", k, i, j);
  558.                                 radeon_test_ring_sync2(rdev, ringC, ringA, ringB);
  559.  
  560.                                 DRM_INFO("Testing syncing between rings %d, %d and %d...\n", k, j, i);
  561.                                 radeon_test_ring_sync2(rdev, ringC, ringB, ringA);
  562.                         }
  563.                 }
  564.         }
  565. }
  566.