drivers/gpu/drm/i915/selftests/i915_vma.c

   1 /*
   2  * Copyright © 2016 Intel Corporation
   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 (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21  * IN THE SOFTWARE.
  22  *
  23  */
  24
  25 #include <linux/prime_numbers.h>
  26
  27 #include "gem/selftests/mock_context.h"
  28
  29 #include "i915_scatterlist.h"
  30 #include "i915_selftest.h"
  31
  32 #include "mock_gem_device.h"
  33 #include "mock_gtt.h"
  34
  35 static bool assert_vma(struct i915_vma *vma,
  36                        struct drm_i915_gem_object *obj,
  37                        struct i915_gem_context *ctx)
  38 {
  39         bool ok = true;
  40
  41         if (vma->vm != ctx->vm) {
  42                 pr_err("VMA created with wrong VM\n");
  43                 ok = false;
  44         }
  45
  46         if (vma->size != obj->base.size) {
  47                 pr_err("VMA created with wrong size, found %llu, expected %zu\n",
  48                        vma->size, obj->base.size);
  49                 ok = false;
  50         }
  51
  52         if (vma->ggtt_view.type != I915_GGTT_VIEW_NORMAL) {
  53                 pr_err("VMA created with wrong type [%d]\n",
  54                        vma->ggtt_view.type);
  55                 ok = false;
  56         }
  57
  58         return ok;
  59 }
  60
  61 static struct i915_vma *
  62 checked_vma_instance(struct drm_i915_gem_object *obj,
  63                      struct i915_address_space *vm,
  64                      const struct i915_ggtt_view *view)
  65 {
  66         struct i915_vma *vma;
  67         bool ok = true;
  68
  69         vma = i915_vma_instance(obj, vm, view);
  70         if (IS_ERR(vma))
  71                 return vma;
  72
  73         /* Manual checks, will be reinforced by i915_vma_compare! */
  74         if (vma->vm != vm) {
  75                 pr_err("VMA's vm [%p] does not match request [%p]\n",
  76                        vma->vm, vm);
  77                 ok = false;
  78         }
  79
  80         if (i915_is_ggtt(vm) != i915_vma_is_ggtt(vma)) {
  81                 pr_err("VMA ggtt status [%d] does not match parent [%d]\n",
  82                        i915_vma_is_ggtt(vma), i915_is_ggtt(vm));
  83                 ok = false;
  84         }
  85
  86         if (i915_vma_compare(vma, vm, view)) {
  87                 pr_err("i915_vma_compare failed with create parameters!\n");
  88                 return ERR_PTR(-EINVAL);
  89         }
  90
  91         if (i915_vma_compare(vma, vma->vm,
  92                              i915_vma_is_ggtt(vma) ? &vma->ggtt_view : NULL)) {
  93                 pr_err("i915_vma_compare failed with itself\n");
  94                 return ERR_PTR(-EINVAL);
  95         }
  96
  97         if (!ok) {
  98                 pr_err("i915_vma_compare failed to detect the difference!\n");
  99                 return ERR_PTR(-EINVAL);
 100         }
 101
 102         return vma;
 103 }
 104
 105 static int create_vmas(struct drm_i915_private *i915,
 106                        struct list_head *objects,
 107                        struct list_head *contexts)
 108 {
 109         struct drm_i915_gem_object *obj;
 110         struct i915_gem_context *ctx;
 111         int pinned;
 112
 113         list_for_each_entry(obj, objects, st_link) {
 114                 for (pinned = 0; pinned <= 1; pinned++) {
 115                         list_for_each_entry(ctx, contexts, link) {
 116                                 struct i915_address_space *vm = ctx->vm;
 117                                 struct i915_vma *vma;
 118                                 int err;
 119
 120                                 vma = checked_vma_instance(obj, vm, NULL);
 121                                 if (IS_ERR(vma))
 122                                         return PTR_ERR(vma);
 123
 124                                 if (!assert_vma(vma, obj, ctx)) {
 125                                         pr_err("VMA lookup/create failed\n");
 126                                         return -EINVAL;
 127                                 }
 128
 129                                 if (!pinned) {
 130                                         err = i915_vma_pin(vma, 0, 0, PIN_USER);
 131                                         if (err) {
 132                                                 pr_err("Failed to pin VMA\n");
 133                                                 return err;
 134                                         }
 135                                 } else {
 136                                         i915_vma_unpin(vma);
 137                                 }
 138                         }
 139                 }
 140         }
 141
 142         return 0;
 143 }
 144
 145 static int igt_vma_create(void *arg)
 146 {
 147         struct i915_ggtt *ggtt = arg;
 148         struct drm_i915_private *i915 = ggtt->vm.i915;
 149         struct drm_i915_gem_object *obj, *on;
 150         struct i915_gem_context *ctx, *cn;
 151         unsigned long num_obj, num_ctx;
 152         unsigned long no, nc;
 153         IGT_TIMEOUT(end_time);
 154         LIST_HEAD(contexts);
 155         LIST_HEAD(objects);
 156         int err = -ENOMEM;
 157
 158         /* Exercise creating many vma amonst many objections, checking the
 159          * vma creation and lookup routines.
 160          */
 161
 162         no = 0;
 163         for_each_prime_number(num_obj, ULONG_MAX - 1) {
 164                 for (; no < num_obj; no++) {
 165                         obj = i915_gem_object_create_internal(i915, PAGE_SIZE);
 166                         if (IS_ERR(obj))
 167                                 goto out;
 168
 169                         list_add(&obj->st_link, &objects);
 170                 }
 171
 172                 nc = 0;
 173                 for_each_prime_number(num_ctx, MAX_CONTEXT_HW_ID) {
 174                         for (; nc < num_ctx; nc++) {
 175                                 ctx = mock_context(i915, "mock");
 176                                 if (!ctx)
 177                                         goto out;
 178
 179                                 list_move(&ctx->link, &contexts);
 180                         }
 181
 182                         err = create_vmas(i915, &objects, &contexts);
 183                         if (err)
 184                                 goto out;
 185
 186                         if (igt_timeout(end_time,
 187                                         "%s timed out: after %lu objects in %lu contexts\n",
 188                                         __func__, no, nc))
 189                                 goto end;
 190                 }
 191
 192                 list_for_each_entry_safe(ctx, cn, &contexts, link) {
 193                         list_del_init(&ctx->link);
 194                         mock_context_close(ctx);
 195                 }
 196         }
 197
 198 end:
 199         /* Final pass to lookup all created contexts */
 200         err = create_vmas(i915, &objects, &contexts);
 201 out:
 202         list_for_each_entry_safe(ctx, cn, &contexts, link) {
 203                 list_del_init(&ctx->link);
 204                 mock_context_close(ctx);
 205         }
 206
 207         list_for_each_entry_safe(obj, on, &objects, st_link)
 208                 i915_gem_object_put(obj);
 209         return err;
 210 }
 211
 212 struct pin_mode {
 213         u64 size;
 214         u64 flags;
 215         bool (*assert)(const struct i915_vma *,
 216                        const struct pin_mode *mode,
 217                        int result);
 218         const char *string;
 219 };
 220
 221 static bool assert_pin_valid(const struct i915_vma *vma,
 222                              const struct pin_mode *mode,
 223                              int result)
 224 {
 225         if (result)
 226                 return false;
 227
 228         if (i915_vma_misplaced(vma, mode->size, 0, mode->flags))
 229                 return false;
 230
 231         return true;
 232 }
 233
 234 __maybe_unused
 235 static bool assert_pin_enospc(const struct i915_vma *vma,
 236                               const struct pin_mode *mode,
 237                               int result)
 238 {
 239         return result == -ENOSPC;
 240 }
 241
 242 __maybe_unused
 243 static bool assert_pin_einval(const struct i915_vma *vma,
 244                               const struct pin_mode *mode,
 245                               int result)
 246 {
 247         return result == -EINVAL;
 248 }
 249
 250 static int igt_vma_pin1(void *arg)
 251 {
 252         struct i915_ggtt *ggtt = arg;
 253         const struct pin_mode modes[] = {
 254 #define VALID(sz, fl) { .size = (sz), .flags = (fl), .assert = assert_pin_valid, .string = #sz ", " #fl ", (valid) " }
 255 #define __INVALID(sz, fl, check, eval) { .size = (sz), .flags = (fl), .assert = (check), .string = #sz ", " #fl ", (invalid " #eval ")" }
 256 #define INVALID(sz, fl) __INVALID(sz, fl, assert_pin_einval, EINVAL)
 257 #define NOSPACE(sz, fl) __INVALID(sz, fl, assert_pin_enospc, ENOSPC)
 258                 VALID(0, PIN_GLOBAL),
 259                 VALID(0, PIN_GLOBAL | PIN_MAPPABLE),
 260
 261                 VALID(0, PIN_GLOBAL | PIN_OFFSET_BIAS | 4096),
 262                 VALID(0, PIN_GLOBAL | PIN_OFFSET_BIAS | 8192),
 263                 VALID(0, PIN_GLOBAL | PIN_OFFSET_BIAS | (ggtt->mappable_end - 4096)),
 264                 VALID(0, PIN_GLOBAL | PIN_MAPPABLE | PIN_OFFSET_BIAS | (ggtt->mappable_end - 4096)),
 265                 VALID(0, PIN_GLOBAL | PIN_OFFSET_BIAS | (ggtt->vm.total - 4096)),
 266
 267                 VALID(0, PIN_GLOBAL | PIN_MAPPABLE | PIN_OFFSET_FIXED | (ggtt->mappable_end - 4096)),
 268                 INVALID(0, PIN_GLOBAL | PIN_MAPPABLE | PIN_OFFSET_FIXED | ggtt->mappable_end),
 269                 VALID(0, PIN_GLOBAL | PIN_OFFSET_FIXED | (ggtt->vm.total - 4096)),
 270                 INVALID(0, PIN_GLOBAL | PIN_OFFSET_FIXED | ggtt->vm.total),
 271                 INVALID(0, PIN_GLOBAL | PIN_OFFSET_FIXED | round_down(U64_MAX, PAGE_SIZE)),
 272
 273                 VALID(4096, PIN_GLOBAL),
 274                 VALID(8192, PIN_GLOBAL),
 275                 VALID(ggtt->mappable_end - 4096, PIN_GLOBAL | PIN_MAPPABLE),
 276                 VALID(ggtt->mappable_end, PIN_GLOBAL | PIN_MAPPABLE),
 277                 NOSPACE(ggtt->mappable_end + 4096, PIN_GLOBAL | PIN_MAPPABLE),
 278                 VALID(ggtt->vm.total - 4096, PIN_GLOBAL),
 279                 VALID(ggtt->vm.total, PIN_GLOBAL),
 280                 NOSPACE(ggtt->vm.total + 4096, PIN_GLOBAL),
 281                 NOSPACE(round_down(U64_MAX, PAGE_SIZE), PIN_GLOBAL),
 282                 INVALID(8192, PIN_GLOBAL | PIN_MAPPABLE | PIN_OFFSET_FIXED | (ggtt->mappable_end - 4096)),
 283                 INVALID(8192, PIN_GLOBAL | PIN_OFFSET_FIXED | (ggtt->vm.total - 4096)),
 284                 INVALID(8192, PIN_GLOBAL | PIN_OFFSET_FIXED | (round_down(U64_MAX, PAGE_SIZE) - 4096)),
 285
 286                 VALID(8192, PIN_GLOBAL | PIN_OFFSET_BIAS | (ggtt->mappable_end - 4096)),
 287
 288 #if !IS_ENABLED(CONFIG_DRM_I915_DEBUG_GEM)
 289                 /* Misusing BIAS is a programming error (it is not controllable
 290                  * from userspace) so when debugging is enabled, it explodes.
 291                  * However, the tests are still quite interesting for checking
 292                  * variable start, end and size.
 293                  */
 294                 NOSPACE(0, PIN_GLOBAL | PIN_MAPPABLE | PIN_OFFSET_BIAS | ggtt->mappable_end),
 295                 NOSPACE(0, PIN_GLOBAL | PIN_OFFSET_BIAS | ggtt->vm.total),
 296                 NOSPACE(8192, PIN_GLOBAL | PIN_MAPPABLE | PIN_OFFSET_BIAS | (ggtt->mappable_end - 4096)),
 297                 NOSPACE(8192, PIN_GLOBAL | PIN_OFFSET_BIAS | (ggtt->vm.total - 4096)),
 298 #endif
 299                 { },
 300 #undef NOSPACE
 301 #undef INVALID
 302 #undef __INVALID
 303 #undef VALID
 304         }, *m;
 305         struct drm_i915_gem_object *obj;
 306         struct i915_vma *vma;
 307         int err = -EINVAL;
 308
 309         /* Exercise all the weird and wonderful i915_vma_pin requests,
 310          * focusing on error handling of boundary conditions.
 311          */
 312
 313         GEM_BUG_ON(!drm_mm_clean(&ggtt->vm.mm));
 314
 315         obj = i915_gem_object_create_internal(ggtt->vm.i915, PAGE_SIZE);
 316         if (IS_ERR(obj))
 317                 return PTR_ERR(obj);
 318
 319         vma = checked_vma_instance(obj, &ggtt->vm, NULL);
 320         if (IS_ERR(vma))
 321                 goto out;
 322
 323         for (m = modes; m->assert; m++) {
 324                 err = i915_vma_pin(vma, m->size, 0, m->flags);
 325                 if (!m->assert(vma, m, err)) {
 326                         pr_err("%s to pin single page into GGTT with mode[%d:%s]: size=%llx flags=%llx, err=%d\n",
 327                                m->assert == assert_pin_valid ? "Failed" : "Unexpectedly succeeded",
 328                                (int)(m - modes), m->string, m->size, m->flags,
 329                                err);
 330                         if (!err)
 331                                 i915_vma_unpin(vma);
 332                         err = -EINVAL;
 333                         goto out;
 334                 }
 335
 336                 if (!err) {
 337                         i915_vma_unpin(vma);
 338                         err = i915_vma_unbind(vma);
 339                         if (err) {
 340                                 pr_err("Failed to unbind single page from GGTT, err=%d\n", err);
 341                                 goto out;
 342                         }
 343                 }
 344         }
 345
 346         err = 0;
 347 out:
 348         i915_gem_object_put(obj);
 349         return err;
 350 }
 351
 352 static unsigned long rotated_index(const struct intel_rotation_info *r,
 353                                    unsigned int n,
 354                                    unsigned int x,
 355                                    unsigned int y)
 356 {
 357         return (r->plane[n].stride * (r->plane[n].height - y - 1) +
 358                 r->plane[n].offset + x);
 359 }
 360
 361 static struct scatterlist *
 362 assert_rotated(struct drm_i915_gem_object *obj,
 363                const struct intel_rotation_info *r, unsigned int n,
 364                struct scatterlist *sg)
 365 {
 366         unsigned int x, y;
 367
 368         for (x = 0; x < r->plane[n].width; x++) {
 369                 for (y = 0; y < r->plane[n].height; y++) {
 370                         unsigned long src_idx;
 371                         dma_addr_t src;
 372
 373                         if (!sg) {
 374                                 pr_err("Invalid sg table: too short at plane %d, (%d, %d)!\n",
 375                                        n, x, y);
 376                                 return ERR_PTR(-EINVAL);
 377                         }
 378
 379                         src_idx = rotated_index(r, n, x, y);
 380                         src = i915_gem_object_get_dma_address(obj, src_idx);
 381
 382                         if (sg_dma_len(sg) != PAGE_SIZE) {
 383                                 pr_err("Invalid sg.length, found %d, expected %lu for rotated page (%d, %d) [src index %lu]\n",
 384                                        sg_dma_len(sg), PAGE_SIZE,
 385                                        x, y, src_idx);
 386                                 return ERR_PTR(-EINVAL);
 387                         }
 388
 389                         if (sg_dma_address(sg) != src) {
 390                                 pr_err("Invalid address for rotated page (%d, %d) [src index %lu]\n",
 391                                        x, y, src_idx);
 392                                 return ERR_PTR(-EINVAL);
 393                         }
 394
 395                         sg = sg_next(sg);
 396                 }
 397         }
 398
 399         return sg;
 400 }
 401
 402 static unsigned long remapped_index(const struct intel_remapped_info *r,
 403                                     unsigned int n,
 404                                     unsigned int x,
 405                                     unsigned int y)
 406 {
 407         return (r->plane[n].stride * y +
 408                 r->plane[n].offset + x);
 409 }
 410
 411 static struct scatterlist *
 412 assert_remapped(struct drm_i915_gem_object *obj,
 413                 const struct intel_remapped_info *r, unsigned int n,
 414                 struct scatterlist *sg)
 415 {
 416         unsigned int x, y;
 417         unsigned int left = 0;
 418         unsigned int offset;
 419
 420         for (y = 0; y < r->plane[n].height; y++) {
 421                 for (x = 0; x < r->plane[n].width; x++) {
 422                         unsigned long src_idx;
 423                         dma_addr_t src;
 424
 425                         if (!sg) {
 426                                 pr_err("Invalid sg table: too short at plane %d, (%d, %d)!\n",
 427                                        n, x, y);
 428                                 return ERR_PTR(-EINVAL);
 429                         }
 430                         if (!left) {
 431                                 offset = 0;
 432                                 left = sg_dma_len(sg);
 433                         }
 434
 435                         src_idx = remapped_index(r, n, x, y);
 436                         src = i915_gem_object_get_dma_address(obj, src_idx);
 437
 438                         if (left < PAGE_SIZE || left & (PAGE_SIZE-1)) {
 439                                 pr_err("Invalid sg.length, found %d, expected %lu for remapped page (%d, %d) [src index %lu]\n",
 440                                        sg_dma_len(sg), PAGE_SIZE,
 441                                        x, y, src_idx);
 442                                 return ERR_PTR(-EINVAL);
 443                         }
 444
 445                         if (sg_dma_address(sg) + offset != src) {
 446                                 pr_err("Invalid address for remapped page (%d, %d) [src index %lu]\n",
 447                                        x, y, src_idx);
 448                                 return ERR_PTR(-EINVAL);
 449                         }
 450
 451                         left -= PAGE_SIZE;
 452                         offset += PAGE_SIZE;
 453
 454
 455                         if (!left)
 456                                 sg = sg_next(sg);
 457                 }
 458         }
 459
 460         return sg;
 461 }
 462
 463 static unsigned int rotated_size(const struct intel_remapped_plane_info *a,
 464                                  const struct intel_remapped_plane_info *b)
 465 {
 466         return a->width * a->height + b->width * b->height;
 467 }
 468
 469 static int igt_vma_rotate_remap(void *arg)
 470 {
 471         struct i915_ggtt *ggtt = arg;
 472         struct i915_address_space *vm = &ggtt->vm;
 473         struct drm_i915_gem_object *obj;
 474         const struct intel_remapped_plane_info planes[] = {
 475                 { .width = 1, .height = 1, .stride = 1 },
 476                 { .width = 2, .height = 2, .stride = 2 },
 477                 { .width = 4, .height = 4, .stride = 4 },
 478                 { .width = 8, .height = 8, .stride = 8 },
 479
 480                 { .width = 3, .height = 5, .stride = 3 },
 481                 { .width = 3, .height = 5, .stride = 4 },
 482                 { .width = 3, .height = 5, .stride = 5 },
 483
 484                 { .width = 5, .height = 3, .stride = 5 },
 485                 { .width = 5, .height = 3, .stride = 7 },
 486                 { .width = 5, .height = 3, .stride = 9 },
 487
 488                 { .width = 4, .height = 6, .stride = 6 },
 489                 { .width = 6, .height = 4, .stride = 6 },
 490                 { }
 491         }, *a, *b;
 492         enum i915_ggtt_view_type types[] = {
 493                 I915_GGTT_VIEW_ROTATED,
 494                 I915_GGTT_VIEW_REMAPPED,
 495                 0,
 496         }, *t;
 497         const unsigned int max_pages = 64;
 498         int err = -ENOMEM;
 499
 500         /* Create VMA for many different combinations of planes and check
 501          * that the page layout within the rotated VMA match our expectations.
 502          */
 503
 504         obj = i915_gem_object_create_internal(vm->i915, max_pages * PAGE_SIZE);
 505         if (IS_ERR(obj))
 506                 goto out;
 507
 508         for (t = types; *t; t++) {
 509         for (a = planes; a->width; a++) {
 510                 for (b = planes + ARRAY_SIZE(planes); b-- != planes; ) {
 511                         struct i915_ggtt_view view;
 512                         unsigned int n, max_offset;
 513
 514                         max_offset = max(a->stride * a->height,
 515                                          b->stride * b->height);
 516                         GEM_BUG_ON(max_offset > max_pages);
 517                         max_offset = max_pages - max_offset;
 518
 519                         view.type = *t;
 520                         view.rotated.plane[0] = *a;
 521                         view.rotated.plane[1] = *b;
 522
 523                         for_each_prime_number_from(view.rotated.plane[0].offset, 0, max_offset) {
 524                                 for_each_prime_number_from(view.rotated.plane[1].offset, 0, max_offset) {
 525                                         struct scatterlist *sg;
 526                                         struct i915_vma *vma;
 527
 528                                         vma = checked_vma_instance(obj, vm, &view);
 529                                         if (IS_ERR(vma)) {
 530                                                 err = PTR_ERR(vma);
 531                                                 goto out_object;
 532                                         }
 533
 534                                         err = i915_vma_pin(vma, 0, 0, PIN_GLOBAL);
 535                                         if (err) {
 536                                                 pr_err("Failed to pin VMA, err=%d\n", err);
 537                                                 goto out_object;
 538                                         }
 539
 540                                         if (view.type == I915_GGTT_VIEW_ROTATED &&
 541                                             vma->size != rotated_size(a, b) * PAGE_SIZE) {
 542                                                 pr_err("VMA is wrong size, expected %lu, found %llu\n",
 543                                                        PAGE_SIZE * rotated_size(a, b), vma->size);
 544                                                 err = -EINVAL;
 545                                                 goto out_object;
 546                                         }
 547
 548                                         if (view.type == I915_GGTT_VIEW_REMAPPED &&
 549                                             vma->size > rotated_size(a, b) * PAGE_SIZE) {
 550                                                 pr_err("VMA is wrong size, expected %lu, found %llu\n",
 551                                                        PAGE_SIZE * rotated_size(a, b), vma->size);
 552                                                 err = -EINVAL;
 553                                                 goto out_object;
 554                                         }
 555
 556                                         if (vma->pages->nents > rotated_size(a, b)) {
 557                                                 pr_err("sg table is wrong sizeo, expected %u, found %u nents\n",
 558                                                        rotated_size(a, b), vma->pages->nents);
 559                                                 err = -EINVAL;
 560                                                 goto out_object;
 561                                         }
 562
 563                                         if (vma->node.size < vma->size) {
 564                                                 pr_err("VMA binding too small, expected %llu, found %llu\n",
 565                                                        vma->size, vma->node.size);
 566                                                 err = -EINVAL;
 567                                                 goto out_object;
 568                                         }
 569
 570                                         if (vma->pages == obj->mm.pages) {
 571                                                 pr_err("VMA using unrotated object pages!\n");
 572                                                 err = -EINVAL;
 573                                                 goto out_object;
 574                                         }
 575
 576                                         sg = vma->pages->sgl;
 577                                         for (n = 0; n < ARRAY_SIZE(view.rotated.plane); n++) {
 578                                                 if (view.type == I915_GGTT_VIEW_ROTATED)
 579                                                         sg = assert_rotated(obj, &view.rotated, n, sg);
 580                                                 else
 581                                                         sg = assert_remapped(obj, &view.remapped, n, sg);
 582                                                 if (IS_ERR(sg)) {
 583                                                         pr_err("Inconsistent %s VMA pages for plane %d: [(%d, %d, %d, %d), (%d, %d, %d, %d)]\n",
 584                                                                view.type == I915_GGTT_VIEW_ROTATED ?
 585                                                                "rotated" : "remapped", n,
 586                                                                view.rotated.plane[0].width,
 587                                                                view.rotated.plane[0].height,
 588                                                                view.rotated.plane[0].stride,
 589                                                                view.rotated.plane[0].offset,
 590                                                                view.rotated.plane[1].width,
 591                                                                view.rotated.plane[1].height,
 592                                                                view.rotated.plane[1].stride,
 593                                                                view.rotated.plane[1].offset);
 594                                                         err = -EINVAL;
 595                                                         goto out_object;
 596                                                 }
 597                                         }
 598
 599                                         i915_vma_unpin(vma);
 600                                 }
 601                         }
 602                 }
 603         }
 604         }
 605
 606 out_object:
 607         i915_gem_object_put(obj);
 608 out:
 609         return err;
 610 }
 611
 612 static bool assert_partial(struct drm_i915_gem_object *obj,
 613                            struct i915_vma *vma,
 614                            unsigned long offset,
 615                            unsigned long size)
 616 {
 617         struct sgt_iter sgt;
 618         dma_addr_t dma;
 619
 620         for_each_sgt_dma(dma, sgt, vma->pages) {
 621                 dma_addr_t src;
 622
 623                 if (!size) {
 624                         pr_err("Partial scattergather list too long\n");
 625                         return false;
 626                 }
 627
 628                 src = i915_gem_object_get_dma_address(obj, offset);
 629                 if (src != dma) {
 630                         pr_err("DMA mismatch for partial page offset %lu\n",
 631                                offset);
 632                         return false;
 633                 }
 634
 635                 offset++;
 636                 size--;
 637         }
 638
 639         return true;
 640 }
 641
 642 static bool assert_pin(struct i915_vma *vma,
 643                        struct i915_ggtt_view *view,
 644                        u64 size,
 645                        const char *name)
 646 {
 647         bool ok = true;
 648
 649         if (vma->size != size) {
 650                 pr_err("(%s) VMA is wrong size, expected %llu, found %llu\n",
 651                        name, size, vma->size);
 652                 ok = false;
 653         }
 654
 655         if (vma->node.size < vma->size) {
 656                 pr_err("(%s) VMA binding too small, expected %llu, found %llu\n",
 657                        name, vma->size, vma->node.size);
 658                 ok = false;
 659         }
 660
 661         if (view && view->type != I915_GGTT_VIEW_NORMAL) {
 662                 if (memcmp(&vma->ggtt_view, view, sizeof(*view))) {
 663                         pr_err("(%s) VMA mismatch upon creation!\n",
 664                                name);
 665                         ok = false;
 666                 }
 667
 668                 if (vma->pages == vma->obj->mm.pages) {
 669                         pr_err("(%s) VMA using original object pages!\n",
 670                                name);
 671                         ok = false;
 672                 }
 673         } else {
 674                 if (vma->ggtt_view.type != I915_GGTT_VIEW_NORMAL) {
 675                         pr_err("Not the normal ggtt view! Found %d\n",
 676                                vma->ggtt_view.type);
 677                         ok = false;
 678                 }
 679
 680                 if (vma->pages != vma->obj->mm.pages) {
 681                         pr_err("VMA not using object pages!\n");
 682                         ok = false;
 683                 }
 684         }
 685
 686         return ok;
 687 }
 688
 689 static int igt_vma_partial(void *arg)
 690 {
 691         struct i915_ggtt *ggtt = arg;
 692         struct i915_address_space *vm = &ggtt->vm;
 693         const unsigned int npages = 1021; /* prime! */
 694         struct drm_i915_gem_object *obj;
 695         const struct phase {
 696                 const char *name;
 697         } phases[] = {
 698                 { "create" },
 699                 { "lookup" },
 700                 { },
 701         }, *p;
 702         unsigned int sz, offset;
 703         struct i915_vma *vma;
 704         int err = -ENOMEM;
 705
 706         /* Create lots of different VMA for the object and check that
 707          * we are returned the same VMA when we later request the same range.
 708          */
 709
 710         obj = i915_gem_object_create_internal(vm->i915, npages * PAGE_SIZE);
 711         if (IS_ERR(obj))
 712                 goto out;
 713
 714         for (p = phases; p->name; p++) { /* exercise both create/lookup */
 715                 unsigned int count, nvma;
 716
 717                 nvma = 0;
 718                 for_each_prime_number_from(sz, 1, npages) {
 719                         for_each_prime_number_from(offset, 0, npages - sz) {
 720                                 struct i915_ggtt_view view;
 721
 722                                 view.type = I915_GGTT_VIEW_PARTIAL;
 723                                 view.partial.offset = offset;
 724                                 view.partial.size = sz;
 725
 726                                 if (sz == npages)
 727                                         view.type = I915_GGTT_VIEW_NORMAL;
 728
 729                                 vma = checked_vma_instance(obj, vm, &view);
 730                                 if (IS_ERR(vma)) {
 731                                         err = PTR_ERR(vma);
 732                                         goto out_object;
 733                                 }
 734
 735                                 err = i915_vma_pin(vma, 0, 0, PIN_GLOBAL);
 736                                 if (err)
 737                                         goto out_object;
 738
 739                                 if (!assert_pin(vma, &view, sz*PAGE_SIZE, p->name)) {
 740                                         pr_err("(%s) Inconsistent partial pinning for (offset=%d, size=%d)\n",
 741                                                p->name, offset, sz);
 742                                         err = -EINVAL;
 743                                         goto out_object;
 744                                 }
 745
 746                                 if (!assert_partial(obj, vma, offset, sz)) {
 747                                         pr_err("(%s) Inconsistent partial pages for (offset=%d, size=%d)\n",
 748                                                p->name, offset, sz);
 749                                         err = -EINVAL;
 750                                         goto out_object;
 751                                 }
 752
 753                                 i915_vma_unpin(vma);
 754                                 nvma++;
 755                         }
 756                 }
 757
 758                 count = 0;
 759                 list_for_each_entry(vma, &obj->vma.list, obj_link)
 760                         count++;
 761                 if (count != nvma) {
 762                         pr_err("(%s) All partial vma were not recorded on the obj->vma_list: found %u, expected %u\n",
 763                                p->name, count, nvma);
 764                         err = -EINVAL;
 765                         goto out_object;
 766                 }
 767
 768                 /* Check that we did create the whole object mapping */
 769                 vma = checked_vma_instance(obj, vm, NULL);
 770                 if (IS_ERR(vma)) {
 771                         err = PTR_ERR(vma);
 772                         goto out_object;
 773                 }
 774
 775                 err = i915_vma_pin(vma, 0, 0, PIN_GLOBAL);
 776                 if (err)
 777                         goto out_object;
 778
 779                 if (!assert_pin(vma, NULL, obj->base.size, p->name)) {
 780                         pr_err("(%s) inconsistent full pin\n", p->name);
 781                         err = -EINVAL;
 782                         goto out_object;
 783                 }
 784
 785                 i915_vma_unpin(vma);
 786
 787                 count = 0;
 788                 list_for_each_entry(vma, &obj->vma.list, obj_link)
 789                         count++;
 790                 if (count != nvma) {
 791                         pr_err("(%s) allocated an extra full vma!\n", p->name);
 792                         err = -EINVAL;
 793                         goto out_object;
 794                 }
 795         }
 796
 797 out_object:
 798         i915_gem_object_put(obj);
 799 out:
 800         return err;
 801 }
 802
 803 int i915_vma_mock_selftests(void)
 804 {
 805         static const struct i915_subtest tests[] = {
 806                 SUBTEST(igt_vma_create),
 807                 SUBTEST(igt_vma_pin1),
 808                 SUBTEST(igt_vma_rotate_remap),
 809                 SUBTEST(igt_vma_partial),
 810         };
 811         struct drm_i915_private *i915;
 812         struct i915_ggtt *ggtt;
 813         int err;
 814
 815         i915 = mock_gem_device();
 816         if (!i915)
 817                 return -ENOMEM;
 818
 819         ggtt = kmalloc(sizeof(*ggtt), GFP_KERNEL);
 820         if (!ggtt) {
 821                 err = -ENOMEM;
 822                 goto out_put;
 823         }
 824         mock_init_ggtt(i915, ggtt);
 825
 826         mutex_lock(&i915->drm.struct_mutex);
 827         err = i915_subtests(tests, ggtt);
 828         mock_device_flush(i915);
 829         mutex_unlock(&i915->drm.struct_mutex);
 830
 831         i915_gem_drain_freed_objects(i915);
 832
 833         mock_fini_ggtt(ggtt);
 834         kfree(ggtt);
 835 out_put:
 836         drm_dev_put(&i915->drm);
 837         return err;
 838 }
 839
 840 static int igt_vma_remapped_gtt(void *arg)
 841 {
 842         struct drm_i915_private *i915 = arg;
 843         const struct intel_remapped_plane_info planes[] = {
 844                 { .width = 1, .height = 1, .stride = 1 },
 845                 { .width = 2, .height = 2, .stride = 2 },
 846                 { .width = 4, .height = 4, .stride = 4 },
 847                 { .width = 8, .height = 8, .stride = 8 },
 848
 849                 { .width = 3, .height = 5, .stride = 3 },
 850                 { .width = 3, .height = 5, .stride = 4 },
 851                 { .width = 3, .height = 5, .stride = 5 },
 852
 853                 { .width = 5, .height = 3, .stride = 5 },
 854                 { .width = 5, .height = 3, .stride = 7 },
 855                 { .width = 5, .height = 3, .stride = 9 },
 856
 857                 { .width = 4, .height = 6, .stride = 6 },
 858                 { .width = 6, .height = 4, .stride = 6 },
 859                 { }
 860         }, *p;
 861         enum i915_ggtt_view_type types[] = {
 862                 I915_GGTT_VIEW_ROTATED,
 863                 I915_GGTT_VIEW_REMAPPED,
 864                 0,
 865         }, *t;
 866         struct drm_i915_gem_object *obj;
 867         intel_wakeref_t wakeref;
 868         int err = 0;
 869
 870         obj = i915_gem_object_create_internal(i915, 10 * 10 * PAGE_SIZE);
 871         if (IS_ERR(obj))
 872                 return PTR_ERR(obj);
 873
 874         mutex_lock(&i915->drm.struct_mutex);
 875
 876         wakeref = intel_runtime_pm_get(&i915->runtime_pm);
 877
 878         for (t = types; *t; t++) {
 879                 for (p = planes; p->width; p++) {
 880                         struct i915_ggtt_view view = {
 881                                 .type = *t,
 882                                 .rotated.plane[0] = *p,
 883                         };
 884                         struct i915_vma *vma;
 885                         u32 __iomem *map;
 886                         unsigned int x, y;
 887                         int err;
 888
 889                         i915_gem_object_lock(obj);
 890                         err = i915_gem_object_set_to_gtt_domain(obj, true);
 891                         i915_gem_object_unlock(obj);
 892                         if (err)
 893                                 goto out;
 894
 895                         vma = i915_gem_object_ggtt_pin(obj, &view, 0, 0, PIN_MAPPABLE);
 896                         if (IS_ERR(vma)) {
 897                                 err = PTR_ERR(vma);
 898                                 goto out;
 899                         }
 900
 901                         GEM_BUG_ON(vma->ggtt_view.type != *t);
 902
 903                         map = i915_vma_pin_iomap(vma);
 904                         i915_vma_unpin(vma);
 905                         if (IS_ERR(map)) {
 906                                 err = PTR_ERR(map);
 907                                 goto out;
 908                         }
 909
 910                         for (y = 0 ; y < p->height; y++) {
 911                                 for (x = 0 ; x < p->width; x++) {
 912                                         unsigned int offset;
 913                                         u32 val = y << 16 | x;
 914
 915                                         if (*t == I915_GGTT_VIEW_ROTATED)
 916                                                 offset = (x * p->height + y) * PAGE_SIZE;
 917                                         else
 918                                                 offset = (y * p->width + x) * PAGE_SIZE;
 919
 920                                         iowrite32(val, &map[offset / sizeof(*map)]);
 921                                 }
 922                         }
 923
 924                         i915_vma_unpin_iomap(vma);
 925
 926                         vma = i915_gem_object_ggtt_pin(obj, NULL, 0, 0, PIN_MAPPABLE);
 927                         if (IS_ERR(vma)) {
 928                                 err = PTR_ERR(vma);
 929                                 goto out;
 930                         }
 931
 932                         GEM_BUG_ON(vma->ggtt_view.type != I915_GGTT_VIEW_NORMAL);
 933
 934                         map = i915_vma_pin_iomap(vma);
 935                         i915_vma_unpin(vma);
 936                         if (IS_ERR(map)) {
 937                                 err = PTR_ERR(map);
 938                                 goto out;
 939                         }
 940
 941                         for (y = 0 ; y < p->height; y++) {
 942                                 for (x = 0 ; x < p->width; x++) {
 943                                         unsigned int offset, src_idx;
 944                                         u32 exp = y << 16 | x;
 945                                         u32 val;
 946
 947                                         if (*t == I915_GGTT_VIEW_ROTATED)
 948                                                 src_idx = rotated_index(&view.rotated, 0, x, y);
 949                                         else
 950                                                 src_idx = remapped_index(&view.remapped, 0, x, y);
 951                                         offset = src_idx * PAGE_SIZE;
 952
 953                                         val = ioread32(&map[offset / sizeof(*map)]);
 954                                         if (val != exp) {
 955                                                 pr_err("%s VMA write test failed, expected 0x%x, found 0x%x\n",
 956                                                        *t == I915_GGTT_VIEW_ROTATED ? "Rotated" : "Remapped",
 957                                                        val, exp);
 958                                                 i915_vma_unpin_iomap(vma);
 959                                                 goto out;
 960                                         }
 961                                 }
 962                         }
 963                         i915_vma_unpin_iomap(vma);
 964                 }
 965         }
 966
 967 out:
 968         intel_runtime_pm_put(&i915->runtime_pm, wakeref);
 969         mutex_unlock(&i915->drm.struct_mutex);
 970         i915_gem_object_put(obj);
 971
 972         return err;
 973 }
 974
 975 int i915_vma_live_selftests(struct drm_i915_private *i915)
 976 {
 977         static const struct i915_subtest tests[] = {
 978                 SUBTEST(igt_vma_remapped_gtt),
 979         };
 980
 981         return i915_subtests(tests, i915);
 982 }