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  * Decide if the suite is enabled by default or not.
  59  */
  60 CU_BOOL suite_basic_tests_enable(void);
  61
  62 /**
  63  * Tests in basic test suite
  64  */
  65 extern CU_TestInfo basic_tests[];
  66
  67 /**
  68  * Initialize bo test suite
  69  */
  70 int suite_bo_tests_init();
  71
  72 /**
  73  * Deinitialize bo test suite
  74  */
  75 int suite_bo_tests_clean();
  76
  77 /**
  78  * Tests in bo test suite
  79  */
  80 extern CU_TestInfo bo_tests[];
  81
  82 /**
  83  * Initialize cs test suite
  84  */
  85 int suite_cs_tests_init();
  86
  87 /**
  88  * Deinitialize cs test suite
  89  */
  90 int suite_cs_tests_clean();
  91
  92 /**
  93  * Decide if the suite is enabled by default or not.
  94  */
  95 CU_BOOL suite_cs_tests_enable(void);
  96
  97 /**
  98  * Tests in cs test suite
  99  */
 100 extern CU_TestInfo cs_tests[];
 101
 102 /**
 103  * Initialize vce test suite
 104  */
 105 int suite_vce_tests_init();
 106
 107 /**
 108  * Deinitialize vce test suite
 109  */
 110 int suite_vce_tests_clean();
 111
 112 /**
 113  * Decide if the suite is enabled by default or not.
 114  */
 115 CU_BOOL suite_vce_tests_enable(void);
 116
 117 /**
 118  * Tests in vce test suite
 119  */
 120 extern CU_TestInfo vce_tests[];
 121
 122 /**
 123 + * Initialize vcn test suite
 124 + */
 125 int suite_vcn_tests_init();
 126
 127 /**
 128 + * Deinitialize vcn test suite
 129 + */
 130 int suite_vcn_tests_clean();
 131
 132 /**
 133  * Decide if the suite is enabled by default or not.
 134  */
 135 CU_BOOL suite_vcn_tests_enable(void);
 136
 137 /**
 138 + * Tests in vcn test suite
 139 + */
 140 extern CU_TestInfo vcn_tests[];
 141
 142 /**
 143  * Initialize uvd enc test suite
 144  */
 145 int suite_uvd_enc_tests_init();
 146
 147 /**
 148  * Deinitialize uvd enc test suite
 149  */
 150 int suite_uvd_enc_tests_clean();
 151
 152 /**
 153  * Decide if the suite is enabled by default or not.
 154  */
 155 CU_BOOL suite_uvd_enc_tests_enable(void);
 156
 157 /**
 158  * Tests in uvd enc test suite
 159  */
 160 extern CU_TestInfo uvd_enc_tests[];
 161
 162 /**
 163  * Initialize deadlock test suite
 164  */
 165 int suite_deadlock_tests_init();
 166
 167 /**
 168  * Deinitialize deadlock test suite
 169  */
 170 int suite_deadlock_tests_clean();
 171
 172 /**
 173  * Decide if the suite is enabled by default or not.
 174  */
 175 CU_BOOL suite_deadlock_tests_enable(void);
 176
 177 /**
 178  * Tests in uvd enc test suite
 179  */
 180 extern CU_TestInfo deadlock_tests[];
 181
 182 /**
 183  * Initialize vm test suite
 184  */
 185 int suite_vm_tests_init();
 186
 187 /**
 188  * Deinitialize deadlock test suite
 189  */
 190 int suite_vm_tests_clean();
 191
 192 /**
 193  * Decide if the suite is enabled by default or not.
 194  */
 195 CU_BOOL suite_vm_tests_enable(void);
 196
 197 /**
 198  * Tests in vm test suite
 199  */
 200 extern CU_TestInfo vm_tests[];
 201
 202
 203 /**
 204  * Initialize ras test suite
 205  */
 206 int suite_ras_tests_init();
 207
 208 /**
 209  * Deinitialize deadlock test suite
 210  */
 211 int suite_ras_tests_clean();
 212
 213 /**
 214  * Decide if the suite is enabled by default or not.
 215  */
 216 CU_BOOL suite_ras_tests_enable(void);
 217
 218 /**
 219  * Tests in ras test suite
 220  */
 221 extern CU_TestInfo ras_tests[];
 222
 223
 224 /**
 225  * Initialize syncobj timeline test suite
 226  */
 227 int suite_syncobj_timeline_tests_init();
 228
 229 /**
 230  * Deinitialize syncobj timeline test suite
 231  */
 232 int suite_syncobj_timeline_tests_clean();
 233
 234 /**
 235  * Decide if the suite is enabled by default or not.
 236  */
 237 CU_BOOL suite_syncobj_timeline_tests_enable(void);
 238
 239 /**
 240  * Tests in syncobj timeline test suite
 241  */
 242 extern CU_TestInfo syncobj_timeline_tests[];
 243
 244 void amdgpu_dispatch_hang_helper(amdgpu_device_handle device_handle, uint32_t ip_type);
 245 void amdgpu_dispatch_hang_slow_helper(amdgpu_device_handle device_handle, uint32_t ip_type);
 246 void amdgpu_memcpy_draw_test(amdgpu_device_handle device_handle, uint32_t ring,
 247                              int hang);
 248 void amdgpu_memcpy_draw_hang_slow_test(amdgpu_device_handle device_handle, uint32_t ring);
 249
 250 /**
 251  * Initialize security test suite
 252  */
 253 int suite_security_tests_init();
 254
 255 /**
 256  * Deinitialize security test suite
 257  */
 258 int suite_security_tests_clean();
 259
 260 /**
 261  * Decide if the suite is enabled by default or not.
 262  */
 263 CU_BOOL suite_security_tests_enable(void);
 264
 265 /**
 266  * Tests in security test suite
 267  */
 268 extern CU_TestInfo security_tests[];
 269
 270 extern void
 271 amdgpu_command_submission_write_linear_helper_with_secure(unsigned ip_type,
 272                                                           bool secure);
 273
 274 /**
 275  * Helper functions
 276  */
 277 static inline amdgpu_bo_handle gpu_mem_alloc(
 278                                         amdgpu_device_handle device_handle,
 279                                         uint64_t size,
 280                                         uint64_t alignment,
 281                                         uint32_t type,
 282                                         uint64_t flags,
 283                                         uint64_t *vmc_addr,
 284                                         amdgpu_va_handle *va_handle)
 285 {
 286         struct amdgpu_bo_alloc_request req = {0};
 287         amdgpu_bo_handle buf_handle = NULL;
 288         int r;
 289
 290         req.alloc_size = size;
 291         req.phys_alignment = alignment;
 292         req.preferred_heap = type;
 293         req.flags = flags;
 294
 295         r = amdgpu_bo_alloc(device_handle, &req, &buf_handle);
 296         CU_ASSERT_EQUAL(r, 0);
 297         if (r)
 298                 return NULL;
 299
 300         if (vmc_addr && va_handle) {
 301                 r = amdgpu_va_range_alloc(device_handle,
 302                                           amdgpu_gpu_va_range_general,
 303                                           size, alignment, 0, vmc_addr,
 304                                           va_handle, 0);
 305                 CU_ASSERT_EQUAL(r, 0);
 306                 if (r)
 307                         goto error_free_bo;
 308
 309                 r = amdgpu_bo_va_op(buf_handle, 0, size, *vmc_addr, 0,
 310                                     AMDGPU_VA_OP_MAP);
 311                 CU_ASSERT_EQUAL(r, 0);
 312                 if (r)
 313                         goto error_free_va;
 314         }
 315
 316         return buf_handle;
 317
 318 error_free_va:
 319         r = amdgpu_va_range_free(*va_handle);
 320         CU_ASSERT_EQUAL(r, 0);
 321
 322 error_free_bo:
 323         r = amdgpu_bo_free(buf_handle);
 324         CU_ASSERT_EQUAL(r, 0);
 325
 326         return NULL;
 327 }
 328
 329 static inline int gpu_mem_free(amdgpu_bo_handle bo,
 330                                amdgpu_va_handle va_handle,
 331                                uint64_t vmc_addr,
 332                                uint64_t size)
 333 {
 334         int r;
 335
 336         if (!bo)
 337                 return 0;
 338
 339         if (va_handle) {
 340                 r = amdgpu_bo_va_op(bo, 0, size, vmc_addr, 0,
 341                                     AMDGPU_VA_OP_UNMAP);
 342                 CU_ASSERT_EQUAL(r, 0);
 343                 if (r)
 344                         return r;
 345
 346                 r = amdgpu_va_range_free(va_handle);
 347                 CU_ASSERT_EQUAL(r, 0);
 348                 if (r)
 349                         return r;
 350         }
 351
 352         r = amdgpu_bo_free(bo);
 353         CU_ASSERT_EQUAL(r, 0);
 354
 355         return r;
 356 }
 357
 358 static inline int
 359 amdgpu_bo_alloc_wrap(amdgpu_device_handle dev, unsigned size,
 360                      unsigned alignment, unsigned heap, uint64_t flags,
 361                      amdgpu_bo_handle *bo)
 362 {
 363         struct amdgpu_bo_alloc_request request = {};
 364         amdgpu_bo_handle buf_handle;
 365         int r;
 366
 367         request.alloc_size = size;
 368         request.phys_alignment = alignment;
 369         request.preferred_heap = heap;
 370         request.flags = flags;
 371
 372         r = amdgpu_bo_alloc(dev, &request, &buf_handle);
 373         if (r)
 374                 return r;
 375
 376         *bo = buf_handle;
 377
 378         return 0;
 379 }
 380
 381 int amdgpu_bo_alloc_and_map_raw(amdgpu_device_handle dev, unsigned size,
 382                         unsigned alignment, unsigned heap, uint64_t alloc_flags,
 383                         uint64_t mapping_flags, amdgpu_bo_handle *bo, void **cpu,
 384                         uint64_t *mc_address,
 385                         amdgpu_va_handle *va_handle);
 386
 387 static inline int
 388 amdgpu_bo_alloc_and_map(amdgpu_device_handle dev, unsigned size,
 389                         unsigned alignment, unsigned heap, uint64_t alloc_flags,
 390                         amdgpu_bo_handle *bo, void **cpu, uint64_t *mc_address,
 391                         amdgpu_va_handle *va_handle)
 392 {
 393         return amdgpu_bo_alloc_and_map_raw(dev, size, alignment, heap,
 394                                         alloc_flags, 0, bo, cpu, mc_address, va_handle);
 395 }
 396
 397 static inline int
 398 amdgpu_bo_unmap_and_free(amdgpu_bo_handle bo, amdgpu_va_handle va_handle,
 399                          uint64_t mc_addr, uint64_t size)
 400 {
 401         amdgpu_bo_cpu_unmap(bo);
 402         amdgpu_bo_va_op(bo, 0, size, mc_addr, 0, AMDGPU_VA_OP_UNMAP);
 403         amdgpu_va_range_free(va_handle);
 404         amdgpu_bo_free(bo);
 405
 406         return 0;
 407
 408 }
 409
 410 static inline int
 411 amdgpu_get_bo_list(amdgpu_device_handle dev, amdgpu_bo_handle bo1,
 412                    amdgpu_bo_handle bo2, amdgpu_bo_list_handle *list)
 413 {
 414         amdgpu_bo_handle resources[] = {bo1, bo2};
 415
 416         return amdgpu_bo_list_create(dev, bo2 ? 2 : 1, resources, NULL, list);
 417 }
 418
 419
 420 static inline CU_ErrorCode amdgpu_set_suite_active(const char *suite_name,
 421                                                           CU_BOOL active)
 422 {
 423         CU_ErrorCode r = CU_set_suite_active(CU_get_suite(suite_name), active);
 424
 425         if (r != CUE_SUCCESS)
 426                 fprintf(stderr, "Failed to obtain suite %s\n", suite_name);
 427
 428         return r;
 429 }
 430
 431 static inline CU_ErrorCode amdgpu_set_test_active(const char *suite_name,
 432                                   const char *test_name, CU_BOOL active)
 433 {
 434         CU_ErrorCode r;
 435         CU_pSuite pSuite = CU_get_suite(suite_name);
 436
 437         if (!pSuite) {
 438                 fprintf(stderr, "Failed to obtain suite %s\n",
 439                                 suite_name);
 440                 return CUE_NOSUITE;
 441         }
 442
 443         r = CU_set_test_active(CU_get_test(pSuite, test_name), active);
 444         if (r != CUE_SUCCESS)
 445                 fprintf(stderr, "Failed to obtain test %s\n", test_name);
 446
 447         return r;
 448 }
 449
 450 static inline bool asic_is_arcturus(uint32_t asic_id)
 451 {
 452         switch(asic_id) {
 453         /* Arcturus asic DID */
 454         case 0x738C:
 455         case 0x7388:
 456         case 0x738E:
 457                 return true;
 458         default:
 459                 return false;
 460         }
 461 }
 462
 463
 464 #endif  /* #ifdef _AMDGPU_TEST_H_ */