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 static void amdgpu_memory_alloc(void);
  50 static void amdgpu_mem_fail_alloc(void);
  51
  52 CU_TestInfo bo_tests[] = {
  53         { "Export/Import",  amdgpu_bo_export_import },
  54 #if 0
  55         { "Metadata",  amdgpu_bo_metadata },
  56 #endif
  57         { "CPU map/unmap",  amdgpu_bo_map_unmap },
  58         { "Memory alloc Test",  amdgpu_memory_alloc },
  59         { "Memory fail alloc Test",  amdgpu_mem_fail_alloc },
  60         CU_TEST_INFO_NULL,
  61 };
  62
  63 int suite_bo_tests_init(void)
  64 {
  65         struct amdgpu_bo_alloc_request req = {0};
  66         amdgpu_bo_handle buf_handle;
  67         uint64_t va;
  68         int r;
  69
  70         r = amdgpu_device_initialize(drm_amdgpu[0], &major_version,
  71                                   &minor_version, &device_handle);
  72         if (r) {
  73                 if ((r == -EACCES) && (errno == EACCES))
  74                         printf("\n\nError:%s. "
  75                                 "Hint:Try to run this test program as root.",
  76                                 strerror(errno));
  77
  78                 return CUE_SINIT_FAILED;
  79         }
  80
  81         req.alloc_size = BUFFER_SIZE;
  82         req.phys_alignment = BUFFER_ALIGN;
  83         req.preferred_heap = AMDGPU_GEM_DOMAIN_GTT;
  84
  85         r = amdgpu_bo_alloc(device_handle, &req, &buf_handle);
  86         if (r)
  87                 return CUE_SINIT_FAILED;
  88
  89         r = amdgpu_va_range_alloc(device_handle,
  90                                   amdgpu_gpu_va_range_general,
  91                                   BUFFER_SIZE, BUFFER_ALIGN, 0,
  92                                   &va, &va_handle, 0);
  93         if (r)
  94                 goto error_va_alloc;
  95
  96         r = amdgpu_bo_va_op(buf_handle, 0, BUFFER_SIZE, va, 0, AMDGPU_VA_OP_MAP);
  97         if (r)
  98                 goto error_va_map;
  99
 100         buffer_handle = buf_handle;
 101         virtual_mc_base_address = va;
 102
 103         return CUE_SUCCESS;
 104
 105 error_va_map:
 106         amdgpu_va_range_free(va_handle);
 107
 108 error_va_alloc:
 109         amdgpu_bo_free(buf_handle);
 110         return CUE_SINIT_FAILED;
 111 }
 112
 113 int suite_bo_tests_clean(void)
 114 {
 115         int r;
 116
 117         r = amdgpu_bo_va_op(buffer_handle, 0, BUFFER_SIZE,
 118                             virtual_mc_base_address, 0,
 119                             AMDGPU_VA_OP_UNMAP);
 120         if (r)
 121                 return CUE_SCLEAN_FAILED;
 122
 123         r = amdgpu_va_range_free(va_handle);
 124         if (r)
 125                 return CUE_SCLEAN_FAILED;
 126
 127         r = amdgpu_bo_free(buffer_handle);
 128         if (r)
 129                 return CUE_SCLEAN_FAILED;
 130
 131         r = amdgpu_device_deinitialize(device_handle);
 132         if (r)
 133                 return CUE_SCLEAN_FAILED;
 134
 135         return CUE_SUCCESS;
 136 }
 137
 138 static void amdgpu_bo_export_import_do_type(enum amdgpu_bo_handle_type type)
 139 {
 140         struct amdgpu_bo_import_result res = {0};
 141         uint32_t shared_handle;
 142         int r;
 143
 144         r = amdgpu_bo_export(buffer_handle, type, &shared_handle);
 145         CU_ASSERT_EQUAL(r, 0);
 146
 147         r = amdgpu_bo_import(device_handle, type, shared_handle, &res);
 148         CU_ASSERT_EQUAL(r, 0);
 149
 150         CU_ASSERT_EQUAL(res.buf_handle, buffer_handle);
 151         CU_ASSERT_EQUAL(res.alloc_size, BUFFER_SIZE);
 152
 153         r = amdgpu_bo_free(res.buf_handle);
 154         CU_ASSERT_EQUAL(r, 0);
 155 }
 156
 157 static void amdgpu_bo_export_import(void)
 158 {
 159         if (open_render_node) {
 160                 printf("(DRM render node is used. Skip export/Import test) ");
 161                 return;
 162         }
 163
 164         amdgpu_bo_export_import_do_type(amdgpu_bo_handle_type_gem_flink_name);
 165         amdgpu_bo_export_import_do_type(amdgpu_bo_handle_type_dma_buf_fd);
 166 }
 167
 168 static void amdgpu_bo_metadata(void)
 169 {
 170         struct amdgpu_bo_metadata meta = {0};
 171         struct amdgpu_bo_info info = {0};
 172         int r;
 173
 174         meta.size_metadata = 1;
 175         meta.umd_metadata[0] = 0xdeadbeef;
 176
 177         r = amdgpu_bo_set_metadata(buffer_handle, &meta);
 178         CU_ASSERT_EQUAL(r, 0);
 179
 180         r = amdgpu_bo_query_info(buffer_handle, &info);
 181         CU_ASSERT_EQUAL(r, 0);
 182
 183         CU_ASSERT_EQUAL(info.metadata.size_metadata, 1);
 184         CU_ASSERT_EQUAL(info.metadata.umd_metadata[0], 0xdeadbeef);
 185 }
 186
 187 static void amdgpu_bo_map_unmap(void)
 188 {
 189         uint32_t *ptr;
 190         int i, r;
 191
 192         r = amdgpu_bo_cpu_map(buffer_handle, (void **)&ptr);
 193         CU_ASSERT_EQUAL(r, 0);
 194         CU_ASSERT_NOT_EQUAL(ptr, NULL);
 195
 196         for (i = 0; i < (BUFFER_SIZE / 4); ++i)
 197                 ptr[i] = 0xdeadbeef;
 198
 199         r = amdgpu_bo_cpu_unmap(buffer_handle);
 200         CU_ASSERT_EQUAL(r, 0);
 201 }
 202
 203 static void amdgpu_memory_alloc(void)
 204 {
 205         amdgpu_bo_handle bo;
 206         amdgpu_va_handle va_handle;
 207         uint64_t bo_mc;
 208         int r;
 209
 210         /* Test visible VRAM */
 211         bo = gpu_mem_alloc(device_handle,
 212                         4096, 4096,
 213                         AMDGPU_GEM_DOMAIN_VRAM,
 214                         AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED,
 215                         &bo_mc, &va_handle);
 216
 217         r = gpu_mem_free(bo, va_handle, bo_mc, 4096);
 218         CU_ASSERT_EQUAL(r, 0);
 219
 220         /* Test invisible VRAM */
 221         bo = gpu_mem_alloc(device_handle,
 222                         4096, 4096,
 223                         AMDGPU_GEM_DOMAIN_VRAM,
 224                         AMDGPU_GEM_CREATE_NO_CPU_ACCESS,
 225                         &bo_mc, &va_handle);
 226
 227         r = gpu_mem_free(bo, va_handle, bo_mc, 4096);
 228         CU_ASSERT_EQUAL(r, 0);
 229
 230         /* Test GART Cacheable */
 231         bo = gpu_mem_alloc(device_handle,
 232                         4096, 4096,
 233                         AMDGPU_GEM_DOMAIN_GTT,
 234                         0, &bo_mc, &va_handle);
 235
 236         r = gpu_mem_free(bo, va_handle, bo_mc, 4096);
 237         CU_ASSERT_EQUAL(r, 0);
 238
 239         /* Test GART USWC */
 240         bo = gpu_mem_alloc(device_handle,
 241                         4096, 4096,
 242                         AMDGPU_GEM_DOMAIN_GTT,
 243                         AMDGPU_GEM_CREATE_CPU_GTT_USWC,
 244                         &bo_mc, &va_handle);
 245
 246         r = gpu_mem_free(bo, va_handle, bo_mc, 4096);
 247         CU_ASSERT_EQUAL(r, 0);
 248 }
 249
 250 static void amdgpu_mem_fail_alloc(void)
 251 {
 252         amdgpu_bo_handle bo;
 253         int r;
 254         struct amdgpu_bo_alloc_request req = {0};
 255         amdgpu_bo_handle buf_handle;
 256
 257         /* Test impossible mem allocation, 1TB */
 258         req.alloc_size = 0xE8D4A51000;
 259         req.phys_alignment = 4096;
 260         req.preferred_heap = AMDGPU_GEM_DOMAIN_VRAM;
 261         req.flags = AMDGPU_GEM_CREATE_NO_CPU_ACCESS;
 262
 263         r = amdgpu_bo_alloc(device_handle, &req, &buf_handle);
 264         CU_ASSERT_EQUAL(r, -ENOMEM);
 265
 266         if (!r) {
 267                 r = amdgpu_bo_free(bo);
 268                 CU_ASSERT_EQUAL(r, 0);
 269         }
 270 }