tests/prime_nv_test.c

   1 /* basic set of prime tests between intel and nouveau */
   2
   3 /* test list -
   4    1. share buffer from intel -> nouveau.
   5    2. share buffer from nouveau -> intel
   6    3. share intel->nouveau, map on both, write intel, read nouveau
   7    4. share intel->nouveau, blit intel fill, readback on nouveau
   8    test 1 + map buffer, read/write, map other size.
   9    do some hw actions on the buffer
  10    some illegal operations -
  11        close prime fd try and map
  12
  13    TODO add some nouveau rendering tests
  14 */
  15
  16
  17 #include <stdio.h>
  18 #include <stdlib.h>
  19 #include <unistd.h>
  20 #include <fcntl.h>
  21 #include <string.h>
  22 #include <sys/stat.h>
  23 #include <sys/ioctl.h>
  24
  25 #include "ioctl_wrappers.h"
  26 #include "intel_bufmgr.h"
  27 #include "nouveau.h"
  28 #include "intel_io.h"
  29 #include "intel_batchbuffer.h"
  30 #include "intel_chipset.h"
  31 #include "drmtest.h"
  32
  33 int intel_fd = -1, nouveau_fd = -1;
  34 drm_intel_bufmgr *bufmgr;
  35 struct nouveau_device *ndev;
  36 struct nouveau_client *nclient;
  37 uint32_t devid;
  38 struct intel_batchbuffer *intel_batch;
  39
  40 #define BO_SIZE (256*1024)
  41
  42 static int find_and_open_devices(void)
  43 {
  44         int i;
  45         char path[80];
  46         struct stat buf;
  47         FILE *fl;
  48         char vendor_id[8];
  49         int venid;
  50         for (i = 0; i < 9; i++) {
  51                 char *ret;
  52
  53                 sprintf(path, "/sys/class/drm/card%d/device/vendor", i);
  54                 if (stat(path, &buf))
  55                         break;
  56
  57                 fl = fopen(path, "r");
  58                 if (!fl)
  59                         break;
  60
  61                 ret = fgets(vendor_id, 8, fl);
  62                 igt_assert(ret);
  63                 fclose(fl);
  64
  65                 venid = strtoul(vendor_id, NULL, 16);
  66                 sprintf(path, "/dev/dri/card%d", i);
  67                 if (venid == 0x8086) {
  68                         intel_fd = open(path, O_RDWR);
  69                         if (!intel_fd)
  70                                 return -1;
  71                 } else if (venid == 0x10de) {
  72                         nouveau_fd = open(path, O_RDWR);
  73                         if (!nouveau_fd)
  74                                 return -1;
  75                 }
  76         }
  77         return 0;
  78 }
  79
  80 /*
  81  * prime test 1 -
  82  * allocate buffer on intel,
  83  * set prime on buffer,
  84  * retrive buffer from nouveau,
  85  * close prime_fd,
  86  *  unref buffers
  87  */
  88 static void test_i915_nv_sharing(void)
  89 {
  90         drm_intel_bo *test_intel_bo;
  91         int prime_fd;
  92         struct nouveau_bo *nvbo;
  93
  94         test_intel_bo = drm_intel_bo_alloc(bufmgr, "test bo", BO_SIZE, 4096);
  95         igt_assert(test_intel_bo);
  96
  97         drm_intel_bo_gem_export_to_prime(test_intel_bo, &prime_fd);
  98
  99         igt_assert(nouveau_bo_prime_handle_ref(ndev, prime_fd, &nvbo) == 0);
 100         close(prime_fd);
 101
 102         nouveau_bo_ref(NULL, &nvbo);
 103         drm_intel_bo_unreference(test_intel_bo);
 104 }
 105
 106 /*
 107  * prime test 2 -
 108  * allocate buffer on nouveau
 109  * set prime on buffer,
 110  * retrive buffer from intel
 111  * close prime_fd,
 112  *  unref buffers
 113  */
 114 static void test_nv_i915_sharing(void)
 115 {
 116         drm_intel_bo *test_intel_bo;
 117         int prime_fd;
 118         struct nouveau_bo *nvbo;
 119
 120         igt_assert(nouveau_bo_new(ndev, NOUVEAU_BO_GART | NOUVEAU_BO_MAP,
 121                                   0, BO_SIZE, NULL, &nvbo) == 0);
 122         igt_assert(nouveau_bo_set_prime(nvbo, &prime_fd) == 0);
 123
 124         test_intel_bo = drm_intel_bo_gem_create_from_prime(bufmgr, prime_fd, BO_SIZE);
 125         close(prime_fd);
 126         igt_assert(test_intel_bo);
 127
 128         nouveau_bo_ref(NULL, &nvbo);
 129         drm_intel_bo_unreference(test_intel_bo);
 130 }
 131
 132 /*
 133  * allocate intel, give to nouveau, map on nouveau
 134  * write 0xdeadbeef, non-gtt map on intel, read
 135  */
 136 static void test_nv_write_i915_cpu_mmap_read(void)
 137 {
 138         drm_intel_bo *test_intel_bo;
 139         int prime_fd;
 140         struct nouveau_bo *nvbo = NULL;
 141         uint32_t *ptr;
 142
 143         test_intel_bo = drm_intel_bo_alloc(bufmgr, "test bo", BO_SIZE, 4096);
 144
 145         drm_intel_bo_gem_export_to_prime(test_intel_bo, &prime_fd);
 146
 147         igt_assert(nouveau_bo_prime_handle_ref(ndev, prime_fd, &nvbo) == 0);
 148         close(prime_fd);
 149
 150         igt_assert(nouveau_bo_map(nvbo, NOUVEAU_BO_RDWR, nclient) == 0);
 151         ptr = nvbo->map;
 152         *ptr = 0xdeadbeef;
 153
 154         drm_intel_bo_map(test_intel_bo, 1);
 155         ptr = test_intel_bo->virtual;
 156         igt_assert(ptr);
 157
 158         igt_assert(*ptr == 0xdeadbeef);
 159         nouveau_bo_ref(NULL, &nvbo);
 160         drm_intel_bo_unreference(test_intel_bo);
 161 }
 162
 163 /*
 164  * allocate intel, give to nouveau, map on nouveau
 165  * write 0xdeadbeef, gtt map on intel, read
 166  */
 167 static void test_nv_write_i915_gtt_mmap_read(void)
 168 {
 169         drm_intel_bo *test_intel_bo;
 170         int prime_fd;
 171         struct nouveau_bo *nvbo = NULL;
 172         uint32_t *ptr;
 173
 174         test_intel_bo = drm_intel_bo_alloc(bufmgr, "test bo", BO_SIZE, 4096);
 175
 176         drm_intel_bo_gem_export_to_prime(test_intel_bo, &prime_fd);
 177
 178         igt_assert(nouveau_bo_prime_handle_ref(ndev, prime_fd, &nvbo) == 0);
 179         close(prime_fd);
 180         igt_assert(nouveau_bo_map(nvbo, NOUVEAU_BO_RDWR, nclient) == 0);
 181         ptr = nvbo->map;
 182         *ptr = 0xdeadbeef;
 183
 184         drm_intel_gem_bo_map_gtt(test_intel_bo);
 185         ptr = test_intel_bo->virtual;
 186         igt_assert(ptr);
 187
 188         igt_assert(*ptr == 0xdeadbeef);
 189
 190         nouveau_bo_ref(NULL, &nvbo);
 191         drm_intel_bo_unreference(test_intel_bo);
 192 }
 193
 194 /* test drm_intel_bo_map doesn't work properly,
 195    this tries to map the backing shmem fd, which doesn't exist
 196    for these objects */
 197 static void test_i915_import_cpu_mmap(void)
 198 {
 199         drm_intel_bo *test_intel_bo;
 200         int prime_fd;
 201         struct nouveau_bo *nvbo;
 202         uint32_t *ptr;
 203
 204         igt_assert(nouveau_bo_new(ndev, NOUVEAU_BO_GART | NOUVEAU_BO_MAP,
 205                                   0, BO_SIZE, NULL, &nvbo) == 0);
 206         igt_assert(nouveau_bo_set_prime(nvbo, &prime_fd) == 0);
 207         test_intel_bo = drm_intel_bo_gem_create_from_prime(bufmgr, prime_fd, BO_SIZE);
 208         close(prime_fd);
 209         igt_assert(test_intel_bo);
 210
 211         igt_assert(nouveau_bo_map(nvbo, NOUVEAU_BO_RDWR, nclient) == 0);
 212
 213         ptr = nvbo->map;
 214         *ptr = 0xdeadbeef;
 215
 216         igt_assert(drm_intel_bo_map(test_intel_bo, 0) == 0);
 217         igt_assert(test_intel_bo->virtual);
 218         ptr = test_intel_bo->virtual;
 219
 220         igt_assert(*ptr == 0xdeadbeef);
 221         nouveau_bo_ref(NULL, &nvbo);
 222         drm_intel_bo_unreference(test_intel_bo);
 223 }
 224
 225 /* test drm_intel_bo_map_gtt works properly,
 226    this tries to map the backing shmem fd, which doesn't exist
 227    for these objects */
 228 static void test_i915_import_gtt_mmap(void)
 229 {
 230         drm_intel_bo *test_intel_bo;
 231         int prime_fd;
 232         struct nouveau_bo *nvbo;
 233         uint32_t *ptr;
 234
 235         igt_assert(nouveau_bo_new(ndev, NOUVEAU_BO_GART | NOUVEAU_BO_MAP,
 236                                   0, BO_SIZE, NULL, &nvbo) == 0);
 237         igt_assert(nouveau_bo_set_prime(nvbo, &prime_fd) == 0);
 238
 239         test_intel_bo = drm_intel_bo_gem_create_from_prime(bufmgr, prime_fd, BO_SIZE);
 240         close(prime_fd);
 241         igt_assert(test_intel_bo);
 242
 243         igt_assert(nouveau_bo_map(nvbo, NOUVEAU_BO_RDWR, nclient) == 0);
 244
 245         ptr = nvbo->map;
 246         *ptr = 0xdeadbeef;
 247         *(ptr + 1) = 0xa55a55;
 248
 249         igt_assert(drm_intel_gem_bo_map_gtt(test_intel_bo) == 0);
 250         igt_assert(test_intel_bo->virtual);
 251         ptr = test_intel_bo->virtual;
 252
 253         igt_assert(*ptr == 0xdeadbeef);
 254         nouveau_bo_ref(NULL, &nvbo);
 255         drm_intel_bo_unreference(test_intel_bo);
 256 }
 257
 258 /* test 7 - import from nouveau into intel, test pread/pwrite fail */
 259 static void test_i915_import_pread_pwrite(void)
 260 {
 261         drm_intel_bo *test_intel_bo;
 262         int prime_fd;
 263         struct nouveau_bo *nvbo;
 264         uint32_t *ptr;
 265         uint32_t buf[64];
 266
 267         igt_assert(nouveau_bo_new(ndev, NOUVEAU_BO_GART | NOUVEAU_BO_MAP,
 268                                   0, BO_SIZE, NULL, &nvbo) == 0);
 269         igt_assert(nouveau_bo_set_prime(nvbo, &prime_fd) == 0);
 270
 271         test_intel_bo = drm_intel_bo_gem_create_from_prime(bufmgr, prime_fd, BO_SIZE);
 272         close(prime_fd);
 273         igt_assert(test_intel_bo);
 274
 275         igt_assert(nouveau_bo_map(nvbo, NOUVEAU_BO_RDWR, nclient) == 0);
 276
 277         ptr = nvbo->map;
 278         *ptr = 0xdeadbeef;
 279
 280         gem_read(intel_fd, test_intel_bo->handle, 0, buf, 256);
 281         igt_assert(buf[0] == 0xdeadbeef);
 282         buf[0] = 0xabcdef55;
 283
 284         gem_write(intel_fd, test_intel_bo->handle, 0, buf, 4);
 285
 286         igt_assert(*ptr == 0xabcdef55);
 287
 288         nouveau_bo_ref(NULL, &nvbo);
 289         drm_intel_bo_unreference(test_intel_bo);
 290 }
 291
 292 static void
 293 set_bo(drm_intel_bo *bo, uint32_t val, int width, int height)
 294 {
 295         int size = width * height;
 296         uint32_t *vaddr;
 297
 298         drm_intel_gem_bo_start_gtt_access(bo, true);
 299         vaddr = bo->virtual;
 300         while (size--)
 301                 *vaddr++ = val;
 302 }
 303
 304 static drm_intel_bo *
 305 create_bo(drm_intel_bufmgr *ibufmgr, uint32_t val, int width, int height)
 306 {
 307         drm_intel_bo *bo;
 308
 309         bo = drm_intel_bo_alloc(ibufmgr, "bo", 4*width*height, 0);
 310         igt_assert(bo);
 311
 312         /* gtt map doesn't have a write parameter, so just keep the mapping
 313          * around (to avoid the set_domain with the gtt write domain set) and
 314          * manually tell the kernel when we start access the gtt. */
 315         drm_intel_gem_bo_map_gtt(bo);
 316
 317         set_bo(bo, val, width, height);
 318
 319         return bo;
 320 }
 321
 322 /* use intel hw to fill the BO with a blit from another BO,
 323    then readback from the nouveau bo, check value is correct */
 324 static void test_i915_blt_fill_nv_read(void)
 325 {
 326         drm_intel_bo *test_intel_bo, *src_bo;
 327         int prime_fd;
 328         struct nouveau_bo *nvbo = NULL;
 329         uint32_t *ptr;
 330
 331         src_bo = create_bo(bufmgr, 0xaa55aa55, 256, 1);
 332
 333         test_intel_bo = drm_intel_bo_alloc(bufmgr, "test bo", BO_SIZE, 4096);
 334
 335         drm_intel_bo_gem_export_to_prime(test_intel_bo, &prime_fd);
 336
 337         igt_assert(nouveau_bo_prime_handle_ref(ndev, prime_fd, &nvbo) == 0);
 338         close(prime_fd);
 339
 340         intel_copy_bo(intel_batch, test_intel_bo, src_bo, BO_SIZE);
 341
 342         igt_assert(nouveau_bo_map(nvbo, NOUVEAU_BO_RDWR, nclient) == 0);
 343
 344         drm_intel_bo_map(test_intel_bo, 0);
 345
 346         ptr = nvbo->map;
 347         igt_assert(*ptr == 0xaa55aa55);
 348         nouveau_bo_ref(NULL, &nvbo);
 349         drm_intel_bo_unreference(test_intel_bo);
 350 }
 351
 352 /* test 8 use nouveau to do blit */
 353
 354 /* test 9 nouveau copy engine?? */
 355
 356 igt_main
 357 {
 358         igt_fixture {
 359                 igt_assert(find_and_open_devices() == 0);
 360
 361                 igt_require(nouveau_fd != -1);
 362                 igt_require(intel_fd != -1);
 363
 364                 /* set up intel bufmgr */
 365                 bufmgr = drm_intel_bufmgr_gem_init(intel_fd, 4096);
 366                 igt_assert(bufmgr);
 367                 /* Do not enable reuse, we share (almost) all buffers. */
 368                 //drm_intel_bufmgr_gem_enable_reuse(bufmgr);
 369
 370                 /* set up nouveau bufmgr */
 371                 igt_assert(nouveau_device_wrap(nouveau_fd, 0, &ndev) == 0);
 372                 igt_assert(nouveau_client_new(ndev, &nclient) == 0);
 373
 374                 /* set up an intel batch buffer */
 375                 devid = intel_get_drm_devid(intel_fd);
 376                 intel_batch = intel_batchbuffer_alloc(bufmgr, devid);
 377         }
 378
 379 #define xtest(name) \
 380         igt_subtest(#name) \
 381                 test_##name();
 382
 383         xtest(i915_nv_sharing);
 384         xtest(nv_i915_sharing);
 385         xtest(nv_write_i915_cpu_mmap_read);
 386         xtest(nv_write_i915_gtt_mmap_read);
 387         xtest(i915_import_cpu_mmap);
 388         xtest(i915_import_gtt_mmap);
 389         xtest(i915_import_pread_pwrite);
 390         xtest(i915_blt_fill_nv_read);
 391
 392         igt_fixture {
 393                 intel_batchbuffer_free(intel_batch);
 394
 395                 nouveau_device_del(&ndev);
 396                 drm_intel_bufmgr_destroy(bufmgr);
 397
 398                 close(intel_fd);
 399                 close(nouveau_fd);
 400         }
 401 }