tests/amdgpu/amdgpu_test.h

   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 #ifndef _AMDGPU_TEST_H_
  25 #define _AMDGPU_TEST_H_
  26
  27 #include "amdgpu.h"
  28 #include "amdgpu_drm.h"
  29
  30 /**
  31  * Define max. number of card in system which we are able to handle
  32  */
  33 #define MAX_CARDS_SUPPORTED     128
  34
  35 /* Forward reference for array to keep "drm" handles */
  36 extern int drm_amdgpu[MAX_CARDS_SUPPORTED];
  37
  38 /* Global variables */
  39 extern int open_render_node;
  40
  41 /*************************  Basic test suite ********************************/
  42
  43 /*
  44  * Define basic test suite to serve as the starting point for future testing
  45 */
  46
  47 /**
  48  * Initialize basic test suite
  49  */
  50 int suite_basic_tests_init();
  51
  52 /**
  53  * Deinitialize basic test suite
  54  */
  55 int suite_basic_tests_clean();
  56
  57 /**
  58  * Tests in basic test suite
  59  */
  60 extern CU_TestInfo basic_tests[];
  61
  62 /**
  63  * Initialize bo test suite
  64  */
  65 int suite_bo_tests_init();
  66
  67 /**
  68  * Deinitialize bo test suite
  69  */
  70 int suite_bo_tests_clean();
  71
  72 /**
  73  * Tests in bo test suite
  74  */
  75 extern CU_TestInfo bo_tests[];
  76
  77 /**
  78  * Initialize cs test suite
  79  */
  80 int suite_cs_tests_init();
  81
  82 /**
  83  * Deinitialize cs test suite
  84  */
  85 int suite_cs_tests_clean();
  86
  87 /**
  88  * Decide if the suite is enabled by default or not.
  89  */
  90 CU_BOOL suite_cs_tests_enable(void);
  91
  92 /**
  93  * Tests in cs test suite
  94  */
  95 extern CU_TestInfo cs_tests[];
  96
  97 /**
  98  * Initialize vce test suite
  99  */
 100 int suite_vce_tests_init();
 101
 102 /**
 103  * Deinitialize vce test suite
 104  */
 105 int suite_vce_tests_clean();
 106
 107 /**
 108  * Decide if the suite is enabled by default or not.
 109  */
 110 CU_BOOL suite_vce_tests_enable(void);
 111
 112 /**
 113  * Tests in vce test suite
 114  */
 115 extern CU_TestInfo vce_tests[];
 116
 117 /**
 118 + * Initialize vcn test suite
 119 + */
 120 int suite_vcn_tests_init();
 121
 122 /**
 123 + * Deinitialize vcn test suite
 124 + */
 125 int suite_vcn_tests_clean();
 126
 127 /**
 128  * Decide if the suite is enabled by default or not.
 129  */
 130 CU_BOOL suite_vcn_tests_enable(void);
 131
 132 /**
 133 + * Tests in vcn test suite
 134 + */
 135 extern CU_TestInfo vcn_tests[];
 136
 137 /**
 138  * Initialize uvd enc test suite
 139  */
 140 int suite_uvd_enc_tests_init();
 141
 142 /**
 143  * Deinitialize uvd enc test suite
 144  */
 145 int suite_uvd_enc_tests_clean();
 146
 147 /**
 148  * Decide if the suite is enabled by default or not.
 149  */
 150 CU_BOOL suite_uvd_enc_tests_enable(void);
 151
 152 /**
 153  * Tests in uvd enc test suite
 154  */
 155 extern CU_TestInfo uvd_enc_tests[];
 156
 157 /**
 158  * Initialize deadlock test suite
 159  */
 160 int suite_deadlock_tests_init();
 161
 162 /**
 163  * Deinitialize deadlock test suite
 164  */
 165 int suite_deadlock_tests_clean();
 166
 167 /**
 168  * Decide if the suite is enabled by default or not.
 169  */
 170 CU_BOOL suite_deadlock_tests_enable(void);
 171
 172 /**
 173  * Tests in uvd enc test suite
 174  */
 175 extern CU_TestInfo deadlock_tests[];
 176
 177 /**
 178  * Initialize vm test suite
 179  */
 180 int suite_vm_tests_init();
 181
 182 /**
 183  * Deinitialize deadlock test suite
 184  */
 185 int suite_vm_tests_clean();
 186
 187 /**
 188  * Decide if the suite is enabled by default or not.
 189  */
 190 CU_BOOL suite_vm_tests_enable(void);
 191
 192 /**
 193  * Tests in vm test suite
 194  */
 195 extern CU_TestInfo vm_tests[];
 196
 197
 198 /**
 199  * Initialize ras test suite
 200  */
 201 int suite_ras_tests_init();
 202
 203 /**
 204  * Deinitialize deadlock test suite
 205  */
 206 int suite_ras_tests_clean();
 207
 208 /**
 209  * Decide if the suite is enabled by default or not.
 210  */
 211 CU_BOOL suite_ras_tests_enable(void);
 212
 213 /**
 214  * Tests in ras test suite
 215  */
 216 extern CU_TestInfo ras_tests[];
 217
 218
 219 /**
 220  * Helper functions
 221  */
 222 static inline amdgpu_bo_handle gpu_mem_alloc(
 223                                         amdgpu_device_handle device_handle,
 224                                         uint64_t size,
 225                                         uint64_t alignment,
 226                                         uint32_t type,
 227                                         uint64_t flags,
 228                                         uint64_t *vmc_addr,
 229                                         amdgpu_va_handle *va_handle)
 230 {
 231         struct amdgpu_bo_alloc_request req = {0};
 232         amdgpu_bo_handle buf_handle = NULL;
 233         int r;
 234
 235         req.alloc_size = size;
 236         req.phys_alignment = alignment;
 237         req.preferred_heap = type;
 238         req.flags = flags;
 239
 240         r = amdgpu_bo_alloc(device_handle, &req, &buf_handle);
 241         CU_ASSERT_EQUAL(r, 0);
 242         if (r)
 243                 return NULL;
 244
 245         if (vmc_addr && va_handle) {
 246                 r = amdgpu_va_range_alloc(device_handle,
 247                                           amdgpu_gpu_va_range_general,
 248                                           size, alignment, 0, vmc_addr,
 249                                           va_handle, 0);
 250                 CU_ASSERT_EQUAL(r, 0);
 251                 if (r)
 252                         goto error_free_bo;
 253
 254                 r = amdgpu_bo_va_op(buf_handle, 0, size, *vmc_addr, 0,
 255                                     AMDGPU_VA_OP_MAP);
 256                 CU_ASSERT_EQUAL(r, 0);
 257                 if (r)
 258                         goto error_free_va;
 259         }
 260
 261         return buf_handle;
 262
 263 error_free_va:
 264         r = amdgpu_va_range_free(*va_handle);
 265         CU_ASSERT_EQUAL(r, 0);
 266
 267 error_free_bo:
 268         r = amdgpu_bo_free(buf_handle);
 269         CU_ASSERT_EQUAL(r, 0);
 270
 271         return NULL;
 272 }
 273
 274 static inline int gpu_mem_free(amdgpu_bo_handle bo,
 275                                amdgpu_va_handle va_handle,
 276                                uint64_t vmc_addr,
 277                                uint64_t size)
 278 {
 279         int r;
 280
 281         if (!bo)
 282                 return 0;
 283
 284         if (va_handle) {
 285                 r = amdgpu_bo_va_op(bo, 0, size, vmc_addr, 0,
 286                                     AMDGPU_VA_OP_UNMAP);
 287                 CU_ASSERT_EQUAL(r, 0);
 288                 if (r)
 289                         return r;
 290
 291                 r = amdgpu_va_range_free(va_handle);
 292                 CU_ASSERT_EQUAL(r, 0);
 293                 if (r)
 294                         return r;
 295         }
 296
 297         r = amdgpu_bo_free(bo);
 298         CU_ASSERT_EQUAL(r, 0);
 299
 300         return r;
 301 }
 302
 303 static inline int
 304 amdgpu_bo_alloc_wrap(amdgpu_device_handle dev, unsigned size,
 305                      unsigned alignment, unsigned heap, uint64_t flags,
 306                      amdgpu_bo_handle *bo)
 307 {
 308         struct amdgpu_bo_alloc_request request = {};
 309         amdgpu_bo_handle buf_handle;
 310         int r;
 311
 312         request.alloc_size = size;
 313         request.phys_alignment = alignment;
 314         request.preferred_heap = heap;
 315         request.flags = flags;
 316
 317         r = amdgpu_bo_alloc(dev, &request, &buf_handle);
 318         if (r)
 319                 return r;
 320
 321         *bo = buf_handle;
 322
 323         return 0;
 324 }
 325
 326 int amdgpu_bo_alloc_and_map_raw(amdgpu_device_handle dev, unsigned size,
 327                         unsigned alignment, unsigned heap, uint64_t alloc_flags,
 328                         uint64_t mapping_flags, amdgpu_bo_handle *bo, void **cpu,
 329                         uint64_t *mc_address,
 330                         amdgpu_va_handle *va_handle);
 331
 332 static inline int
 333 amdgpu_bo_alloc_and_map(amdgpu_device_handle dev, unsigned size,
 334                         unsigned alignment, unsigned heap, uint64_t alloc_flags,
 335                         amdgpu_bo_handle *bo, void **cpu, uint64_t *mc_address,
 336                         amdgpu_va_handle *va_handle)
 337 {
 338         return amdgpu_bo_alloc_and_map_raw(dev, size, alignment, heap,
 339                                         alloc_flags, 0, bo, cpu, mc_address, va_handle);
 340 }
 341
 342 static inline int
 343 amdgpu_bo_unmap_and_free(amdgpu_bo_handle bo, amdgpu_va_handle va_handle,
 344                          uint64_t mc_addr, uint64_t size)
 345 {
 346         amdgpu_bo_cpu_unmap(bo);
 347         amdgpu_bo_va_op(bo, 0, size, mc_addr, 0, AMDGPU_VA_OP_UNMAP);
 348         amdgpu_va_range_free(va_handle);
 349         amdgpu_bo_free(bo);
 350
 351         return 0;
 352
 353 }
 354
 355 static inline int
 356 amdgpu_get_bo_list(amdgpu_device_handle dev, amdgpu_bo_handle bo1,
 357                    amdgpu_bo_handle bo2, amdgpu_bo_list_handle *list)
 358 {
 359         amdgpu_bo_handle resources[] = {bo1, bo2};
 360
 361         return amdgpu_bo_list_create(dev, bo2 ? 2 : 1, resources, NULL, list);
 362 }
 363
 364
 365 static inline CU_ErrorCode amdgpu_set_suite_active(const char *suite_name,
 366                                                           CU_BOOL active)
 367 {
 368         CU_ErrorCode r = CU_set_suite_active(CU_get_suite(suite_name), active);
 369
 370         if (r != CUE_SUCCESS)
 371                 fprintf(stderr, "Failed to obtain suite %s\n", suite_name);
 372
 373         return r;
 374 }
 375
 376 static inline CU_ErrorCode amdgpu_set_test_active(const char *suite_name,
 377                                   const char *test_name, CU_BOOL active)
 378 {
 379         CU_ErrorCode r;
 380         CU_pSuite pSuite = CU_get_suite(suite_name);
 381
 382         if (!pSuite) {
 383                 fprintf(stderr, "Failed to obtain suite %s\n",
 384                                 suite_name);
 385                 return CUE_NOSUITE;
 386         }
 387
 388         r = CU_set_test_active(CU_get_test(pSuite, test_name), active);
 389         if (r != CUE_SUCCESS)
 390                 fprintf(stderr, "Failed to obtain test %s\n", test_name);
 391
 392         return r;
 393 }
 394
 395 #endif  /* #ifdef _AMDGPU_TEST_H_ */