tests/amdgpu/bo_tests.c

   1 /*
   2  * Copyright 2014 Advanced Micro Devices, 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 */
  23
  24 #ifdef HAVE_CONFIG_H
  25 #include "config.h"
  26 #endif
  27
  28 #include <stdio.h>
  29
  30 #include "CUnit/Basic.h"
  31
  32 #include "amdgpu_test.h"
  33 #include "amdgpu_drm.h"
  34
  35 #define BUFFER_SIZE (4*1024)
  36 #define BUFFER_ALIGN (4*1024)
  37
  38 static amdgpu_device_handle device_handle;
  39 static uint32_t major_version;
  40 static uint32_t minor_version;
  41
  42 static amdgpu_bo_handle buffer_handle;
  43 static uint64_t virtual_mc_base_address;
  44 static amdgpu_va_handle va_handle;
  45
  46 static void amdgpu_bo_export_import(void);
  47 static void amdgpu_bo_metadata(void);
  48 static void amdgpu_bo_map_unmap(void);
  49
  50 CU_TestInfo bo_tests[] = {
  51         { "Export/Import",  amdgpu_bo_export_import },
  52 #if 0
  53         { "Metadata",  amdgpu_bo_metadata },
  54 #endif
  55         { "CPU map/unmap",  amdgpu_bo_map_unmap },
  56         CU_TEST_INFO_NULL,
  57 };
  58
  59 int suite_bo_tests_init(void)
  60 {
  61         struct amdgpu_bo_alloc_request req = {0};
  62         amdgpu_bo_handle buf_handle;
  63         uint64_t va;
  64         int r;
  65
  66         r = amdgpu_device_initialize(drm_amdgpu[0], &major_version,
  67                                   &minor_version, &device_handle);
  68         if (r) {
  69                 if ((r == -EACCES) && (errno == EACCES))
  70                         printf("\n\nError:%s. "
  71                                 "Hint:Try to run this test program as root.",
  72                                 strerror(errno));
  73
  74                 return CUE_SINIT_FAILED;
  75         }
  76
  77         req.alloc_size = BUFFER_SIZE;
  78         req.phys_alignment = BUFFER_ALIGN;
  79         req.preferred_heap = AMDGPU_GEM_DOMAIN_GTT;
  80
  81         r = amdgpu_bo_alloc(device_handle, &req, &buf_handle);
  82         if (r)
  83                 return CUE_SINIT_FAILED;
  84
  85         r = amdgpu_va_range_alloc(device_handle,
  86                                   amdgpu_gpu_va_range_general,
  87                                   BUFFER_SIZE, BUFFER_ALIGN, 0,
  88                                   &va, &va_handle, 0);
  89         if (r)
  90                 goto error_va_alloc;
  91
  92         r = amdgpu_bo_va_op(buf_handle, 0, BUFFER_SIZE, va, 0, AMDGPU_VA_OP_MAP);
  93         if (r)
  94                 goto error_va_map;
  95
  96         buffer_handle = buf_handle;
  97         virtual_mc_base_address = va;
  98
  99         return CUE_SUCCESS;
 100
 101 error_va_map:
 102         amdgpu_va_range_free(va_handle);
 103
 104 error_va_alloc:
 105         amdgpu_bo_free(buf_handle);
 106         return CUE_SINIT_FAILED;
 107 }
 108
 109 int suite_bo_tests_clean(void)
 110 {
 111         int r;
 112
 113         r = amdgpu_bo_va_op(buffer_handle, 0, BUFFER_SIZE,
 114                             virtual_mc_base_address, 0,
 115                             AMDGPU_VA_OP_UNMAP);
 116         if (r)
 117                 return CUE_SCLEAN_FAILED;
 118
 119         r = amdgpu_va_range_free(va_handle);
 120         if (r)
 121                 return CUE_SCLEAN_FAILED;
 122
 123         r = amdgpu_bo_free(buffer_handle);
 124         if (r)
 125                 return CUE_SCLEAN_FAILED;
 126
 127         r = amdgpu_device_deinitialize(device_handle);
 128         if (r)
 129                 return CUE_SCLEAN_FAILED;
 130
 131         return CUE_SUCCESS;
 132 }
 133
 134 static void amdgpu_bo_export_import_do_type(enum amdgpu_bo_handle_type type)
 135 {
 136         struct amdgpu_bo_import_result res = {0};
 137         uint32_t shared_handle;
 138         int r;
 139
 140         r = amdgpu_bo_export(buffer_handle, type, &shared_handle);
 141         CU_ASSERT_EQUAL(r, 0);
 142
 143         r = amdgpu_bo_import(device_handle, type, shared_handle, &res);
 144         CU_ASSERT_EQUAL(r, 0);
 145
 146         CU_ASSERT_EQUAL(res.buf_handle, buffer_handle);
 147         CU_ASSERT_EQUAL(res.alloc_size, BUFFER_SIZE);
 148
 149         r = amdgpu_bo_free(res.buf_handle);
 150         CU_ASSERT_EQUAL(r, 0);
 151 }
 152
 153 static void amdgpu_bo_export_import(void)
 154 {
 155         if (open_render_node) {
 156                 printf("(DRM render node is used. Skip export/Import test) ");
 157                 return;
 158         }
 159
 160         amdgpu_bo_export_import_do_type(amdgpu_bo_handle_type_gem_flink_name);
 161         amdgpu_bo_export_import_do_type(amdgpu_bo_handle_type_dma_buf_fd);
 162 }
 163
 164 static void amdgpu_bo_metadata(void)
 165 {
 166         struct amdgpu_bo_metadata meta = {0};
 167         struct amdgpu_bo_info info = {0};
 168         int r;
 169
 170         meta.size_metadata = 1;
 171         meta.umd_metadata[0] = 0xdeadbeef;
 172
 173         r = amdgpu_bo_set_metadata(buffer_handle, &meta);
 174         CU_ASSERT_EQUAL(r, 0);
 175
 176         r = amdgpu_bo_query_info(buffer_handle, &info);
 177         CU_ASSERT_EQUAL(r, 0);
 178
 179         CU_ASSERT_EQUAL(info.metadata.size_metadata, 1);
 180         CU_ASSERT_EQUAL(info.metadata.umd_metadata[0], 0xdeadbeef);
 181 }
 182
 183 static void amdgpu_bo_map_unmap(void)
 184 {
 185         uint32_t *ptr;
 186         int i, r;
 187
 188         r = amdgpu_bo_cpu_map(buffer_handle, (void **)&ptr);
 189         CU_ASSERT_EQUAL(r, 0);
 190         CU_ASSERT_NOT_EQUAL(ptr, NULL);
 191
 192         for (i = 0; i < (BUFFER_SIZE / 4); ++i)
 193                 ptr[i] = 0xdeadbeef;
 194
 195         r = amdgpu_bo_cpu_unmap(buffer_handle);
 196         CU_ASSERT_EQUAL(r, 0);
 197 }