drivers/gpu/drm/amd/amdgpu/amdgpu_vm_pt.c

   1 // SPDX-License-Identifier: GPL-2.0 OR MIT
   2 /*
   3  * Copyright 2022 Advanced Micro Devices, Inc.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be included in
  13  * all copies or substantial portions of the 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 COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  19  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  20  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  21  * OTHER DEALINGS IN THE SOFTWARE.
  22  */
  23
  24 #include <drm/drm_drv.h>
  25
  26 #include "amdgpu.h"
  27 #include "amdgpu_trace.h"
  28 #include "amdgpu_vm.h"
  29
  30 /*
  31  * amdgpu_vm_pt_cursor - state for for_each_amdgpu_vm_pt
  32  */
  33 struct amdgpu_vm_pt_cursor {
  34         uint64_t pfn;
  35         struct amdgpu_vm_bo_base *parent;
  36         struct amdgpu_vm_bo_base *entry;
  37         unsigned int level;
  38 };
  39
  40 /**
  41  * amdgpu_vm_pt_level_shift - return the addr shift for each level
  42  *
  43  * @adev: amdgpu_device pointer
  44  * @level: VMPT level
  45  *
  46  * Returns:
  47  * The number of bits the pfn needs to be right shifted for a level.
  48  */
  49 static unsigned int amdgpu_vm_pt_level_shift(struct amdgpu_device *adev,
  50                                              unsigned int level)
  51 {
  52         switch (level) {
  53         case AMDGPU_VM_PDB2:
  54         case AMDGPU_VM_PDB1:
  55         case AMDGPU_VM_PDB0:
  56                 return 9 * (AMDGPU_VM_PDB0 - level) +
  57                         adev->vm_manager.block_size;
  58         case AMDGPU_VM_PTB:
  59                 return 0;
  60         default:
  61                 return ~0;
  62         }
  63 }
  64
  65 /**
  66  * amdgpu_vm_pt_num_entries - return the number of entries in a PD/PT
  67  *
  68  * @adev: amdgpu_device pointer
  69  * @level: VMPT level
  70  *
  71  * Returns:
  72  * The number of entries in a page directory or page table.
  73  */
  74 static unsigned int amdgpu_vm_pt_num_entries(struct amdgpu_device *adev,
  75                                              unsigned int level)
  76 {
  77         unsigned int shift;
  78
  79         shift = amdgpu_vm_pt_level_shift(adev, adev->vm_manager.root_level);
  80         if (level == adev->vm_manager.root_level)
  81                 /* For the root directory */
  82                 return round_up(adev->vm_manager.max_pfn, 1ULL << shift)
  83                         >> shift;
  84         else if (level != AMDGPU_VM_PTB)
  85                 /* Everything in between */
  86                 return 512;
  87
  88         /* For the page tables on the leaves */
  89         return AMDGPU_VM_PTE_COUNT(adev);
  90 }
  91
  92 /**
  93  * amdgpu_vm_pt_entries_mask - the mask to get the entry number of a PD/PT
  94  *
  95  * @adev: amdgpu_device pointer
  96  * @level: VMPT level
  97  *
  98  * Returns:
  99  * The mask to extract the entry number of a PD/PT from an address.
 100  */
 101 static uint32_t amdgpu_vm_pt_entries_mask(struct amdgpu_device *adev,
 102                                           unsigned int level)
 103 {
 104         if (level <= adev->vm_manager.root_level)
 105                 return 0xffffffff;
 106         else if (level != AMDGPU_VM_PTB)
 107                 return 0x1ff;
 108         else
 109                 return AMDGPU_VM_PTE_COUNT(adev) - 1;
 110 }
 111
 112 /**
 113  * amdgpu_vm_pt_size - returns the size of the page table in bytes
 114  *
 115  * @adev: amdgpu_device pointer
 116  * @level: VMPT level
 117  *
 118  * Returns:
 119  * The size of the BO for a page directory or page table in bytes.
 120  */
 121 static unsigned int amdgpu_vm_pt_size(struct amdgpu_device *adev,
 122                                       unsigned int level)
 123 {
 124         return AMDGPU_GPU_PAGE_ALIGN(amdgpu_vm_pt_num_entries(adev, level) * 8);
 125 }
 126
 127 /**
 128  * amdgpu_vm_pt_parent - get the parent page directory
 129  *
 130  * @pt: child page table
 131  *
 132  * Helper to get the parent entry for the child page table. NULL if we are at
 133  * the root page directory.
 134  */
 135 static struct amdgpu_vm_bo_base *
 136 amdgpu_vm_pt_parent(struct amdgpu_vm_bo_base *pt)
 137 {
 138         struct amdgpu_bo *parent = pt->bo->parent;
 139
 140         if (!parent)
 141                 return NULL;
 142
 143         return parent->vm_bo;
 144 }
 145
 146 /**
 147  * amdgpu_vm_pt_start - start PD/PT walk
 148  *
 149  * @adev: amdgpu_device pointer
 150  * @vm: amdgpu_vm structure
 151  * @start: start address of the walk
 152  * @cursor: state to initialize
 153  *
 154  * Initialize a amdgpu_vm_pt_cursor to start a walk.
 155  */
 156 static void amdgpu_vm_pt_start(struct amdgpu_device *adev,
 157                                struct amdgpu_vm *vm, uint64_t start,
 158                                struct amdgpu_vm_pt_cursor *cursor)
 159 {
 160         cursor->pfn = start;
 161         cursor->parent = NULL;
 162         cursor->entry = &vm->root;
 163         cursor->level = adev->vm_manager.root_level;
 164 }
 165
 166 /**
 167  * amdgpu_vm_pt_descendant - go to child node
 168  *
 169  * @adev: amdgpu_device pointer
 170  * @cursor: current state
 171  *
 172  * Walk to the child node of the current node.
 173  * Returns:
 174  * True if the walk was possible, false otherwise.
 175  */
 176 static bool amdgpu_vm_pt_descendant(struct amdgpu_device *adev,
 177                                     struct amdgpu_vm_pt_cursor *cursor)
 178 {
 179         unsigned int mask, shift, idx;
 180
 181         if ((cursor->level == AMDGPU_VM_PTB) || !cursor->entry ||
 182             !cursor->entry->bo)
 183                 return false;
 184
 185         mask = amdgpu_vm_pt_entries_mask(adev, cursor->level);
 186         shift = amdgpu_vm_pt_level_shift(adev, cursor->level);
 187
 188         ++cursor->level;
 189         idx = (cursor->pfn >> shift) & mask;
 190         cursor->parent = cursor->entry;
 191         cursor->entry = &to_amdgpu_bo_vm(cursor->entry->bo)->entries[idx];
 192         return true;
 193 }
 194
 195 /**
 196  * amdgpu_vm_pt_sibling - go to sibling node
 197  *
 198  * @adev: amdgpu_device pointer
 199  * @cursor: current state
 200  *
 201  * Walk to the sibling node of the current node.
 202  * Returns:
 203  * True if the walk was possible, false otherwise.
 204  */
 205 static bool amdgpu_vm_pt_sibling(struct amdgpu_device *adev,
 206                                  struct amdgpu_vm_pt_cursor *cursor)
 207 {
 208
 209         unsigned int shift, num_entries;
 210         struct amdgpu_bo_vm *parent;
 211
 212         /* Root doesn't have a sibling */
 213         if (!cursor->parent)
 214                 return false;
 215
 216         /* Go to our parents and see if we got a sibling */
 217         shift = amdgpu_vm_pt_level_shift(adev, cursor->level - 1);
 218         num_entries = amdgpu_vm_pt_num_entries(adev, cursor->level - 1);
 219         parent = to_amdgpu_bo_vm(cursor->parent->bo);
 220
 221         if (cursor->entry == &parent->entries[num_entries - 1])
 222                 return false;
 223
 224         cursor->pfn += 1ULL << shift;
 225         cursor->pfn &= ~((1ULL << shift) - 1);
 226         ++cursor->entry;
 227         return true;
 228 }
 229
 230 /**
 231  * amdgpu_vm_pt_ancestor - go to parent node
 232  *
 233  * @cursor: current state
 234  *
 235  * Walk to the parent node of the current node.
 236  * Returns:
 237  * True if the walk was possible, false otherwise.
 238  */
 239 static bool amdgpu_vm_pt_ancestor(struct amdgpu_vm_pt_cursor *cursor)
 240 {
 241         if (!cursor->parent)
 242                 return false;
 243
 244         --cursor->level;
 245         cursor->entry = cursor->parent;
 246         cursor->parent = amdgpu_vm_pt_parent(cursor->parent);
 247         return true;
 248 }
 249
 250 /**
 251  * amdgpu_vm_pt_next - get next PD/PT in hieratchy
 252  *
 253  * @adev: amdgpu_device pointer
 254  * @cursor: current state
 255  *
 256  * Walk the PD/PT tree to the next node.
 257  */
 258 static void amdgpu_vm_pt_next(struct amdgpu_device *adev,
 259                               struct amdgpu_vm_pt_cursor *cursor)
 260 {
 261         /* First try a newborn child */
 262         if (amdgpu_vm_pt_descendant(adev, cursor))
 263                 return;
 264
 265         /* If that didn't worked try to find a sibling */
 266         while (!amdgpu_vm_pt_sibling(adev, cursor)) {
 267                 /* No sibling, go to our parents and grandparents */
 268                 if (!amdgpu_vm_pt_ancestor(cursor)) {
 269                         cursor->pfn = ~0ll;
 270                         return;
 271                 }
 272         }
 273 }
 274
 275 /**
 276  * amdgpu_vm_pt_first_dfs - start a deep first search
 277  *
 278  * @adev: amdgpu_device structure
 279  * @vm: amdgpu_vm structure
 280  * @start: optional cursor to start with
 281  * @cursor: state to initialize
 282  *
 283  * Starts a deep first traversal of the PD/PT tree.
 284  */
 285 static void amdgpu_vm_pt_first_dfs(struct amdgpu_device *adev,
 286                                    struct amdgpu_vm *vm,
 287                                    struct amdgpu_vm_pt_cursor *start,
 288                                    struct amdgpu_vm_pt_cursor *cursor)
 289 {
 290         if (start)
 291                 *cursor = *start;
 292         else
 293                 amdgpu_vm_pt_start(adev, vm, 0, cursor);
 294
 295         while (amdgpu_vm_pt_descendant(adev, cursor))
 296                 ;
 297 }
 298
 299 /**
 300  * amdgpu_vm_pt_continue_dfs - check if the deep first search should continue
 301  *
 302  * @start: starting point for the search
 303  * @entry: current entry
 304  *
 305  * Returns:
 306  * True when the search should continue, false otherwise.
 307  */
 308 static bool amdgpu_vm_pt_continue_dfs(struct amdgpu_vm_pt_cursor *start,
 309                                       struct amdgpu_vm_bo_base *entry)
 310 {
 311         return entry && (!start || entry != start->entry);
 312 }
 313
 314 /**
 315  * amdgpu_vm_pt_next_dfs - get the next node for a deep first search
 316  *
 317  * @adev: amdgpu_device structure
 318  * @cursor: current state
 319  *
 320  * Move the cursor to the next node in a deep first search.
 321  */
 322 static void amdgpu_vm_pt_next_dfs(struct amdgpu_device *adev,
 323                                   struct amdgpu_vm_pt_cursor *cursor)
 324 {
 325         if (!cursor->entry)
 326                 return;
 327
 328         if (!cursor->parent)
 329                 cursor->entry = NULL;
 330         else if (amdgpu_vm_pt_sibling(adev, cursor))
 331                 while (amdgpu_vm_pt_descendant(adev, cursor))
 332                         ;
 333         else
 334                 amdgpu_vm_pt_ancestor(cursor);
 335 }
 336
 337 /*
 338  * for_each_amdgpu_vm_pt_dfs_safe - safe deep first search of all PDs/PTs
 339  */
 340 #define for_each_amdgpu_vm_pt_dfs_safe(adev, vm, start, cursor, entry)          \
 341         for (amdgpu_vm_pt_first_dfs((adev), (vm), (start), &(cursor)),          \
 342              (entry) = (cursor).entry, amdgpu_vm_pt_next_dfs((adev), &(cursor));\
 343              amdgpu_vm_pt_continue_dfs((start), (entry));                       \
 344              (entry) = (cursor).entry, amdgpu_vm_pt_next_dfs((adev), &(cursor)))
 345
 346 /**
 347  * amdgpu_vm_pt_clear - initially clear the PDs/PTs
 348  *
 349  * @adev: amdgpu_device pointer
 350  * @vm: VM to clear BO from
 351  * @vmbo: BO to clear
 352  * @immediate: use an immediate update
 353  *
 354  * Root PD needs to be reserved when calling this.
 355  *
 356  * Returns:
 357  * 0 on success, errno otherwise.
 358  */
 359 int amdgpu_vm_pt_clear(struct amdgpu_device *adev, struct amdgpu_vm *vm,
 360                        struct amdgpu_bo_vm *vmbo, bool immediate)
 361 {
 362         unsigned int level = adev->vm_manager.root_level;
 363         struct ttm_operation_ctx ctx = { true, false };
 364         struct amdgpu_vm_update_params params;
 365         struct amdgpu_bo *ancestor = &vmbo->bo;
 366         unsigned int entries;
 367         struct amdgpu_bo *bo = &vmbo->bo;
 368         uint64_t addr;
 369         int r, idx;
 370
 371         /* Figure out our place in the hierarchy */
 372         if (ancestor->parent) {
 373                 ++level;
 374                 while (ancestor->parent->parent) {
 375                         ++level;
 376                         ancestor = ancestor->parent;
 377                 }
 378         }
 379
 380         entries = amdgpu_bo_size(bo) / 8;
 381
 382         r = ttm_bo_validate(&bo->tbo, &bo->placement, &ctx);
 383         if (r)
 384                 return r;
 385
 386         if (vmbo->shadow) {
 387                 struct amdgpu_bo *shadow = vmbo->shadow;
 388
 389                 r = ttm_bo_validate(&shadow->tbo, &shadow->placement, &ctx);
 390                 if (r)
 391                         return r;
 392         }
 393
 394         if (!drm_dev_enter(adev_to_drm(adev), &idx))
 395                 return -ENODEV;
 396
 397         r = vm->update_funcs->map_table(vmbo);
 398         if (r)
 399                 goto exit;
 400
 401         memset(&params, 0, sizeof(params));
 402         params.adev = adev;
 403         params.vm = vm;
 404         params.immediate = immediate;
 405
 406         r = vm->update_funcs->prepare(&params, NULL);
 407         if (r)
 408                 goto exit;
 409
 410         addr = 0;
 411
 412         uint64_t value = 0, flags = 0;
 413         if (adev->asic_type >= CHIP_VEGA10) {
 414                 if (level != AMDGPU_VM_PTB) {
 415                         /* Handle leaf PDEs as PTEs */
 416                         flags |= AMDGPU_PDE_PTE_FLAG(adev);
 417                         amdgpu_gmc_get_vm_pde(adev, level,
 418                                               &value, &flags);
 419                 } else {
 420                         /* Workaround for fault priority problem on GMC9 */
 421                         flags = AMDGPU_PTE_EXECUTABLE;
 422                 }
 423         }
 424
 425         r = vm->update_funcs->update(&params, vmbo, addr, 0, entries,
 426                                      value, flags);
 427         if (r)
 428                 goto exit;
 429
 430         r = vm->update_funcs->commit(&params, NULL);
 431 exit:
 432         drm_dev_exit(idx);
 433         return r;
 434 }
 435
 436 /**
 437  * amdgpu_vm_pt_create - create bo for PD/PT
 438  *
 439  * @adev: amdgpu_device pointer
 440  * @vm: requesting vm
 441  * @level: the page table level
 442  * @immediate: use a immediate update
 443  * @vmbo: pointer to the buffer object pointer
 444  * @xcp_id: GPU partition id
 445  */
 446 int amdgpu_vm_pt_create(struct amdgpu_device *adev, struct amdgpu_vm *vm,
 447                         int level, bool immediate, struct amdgpu_bo_vm **vmbo,
 448                         int32_t xcp_id)
 449 {
 450         struct amdgpu_bo_param bp;
 451         struct amdgpu_bo *bo;
 452         struct dma_resv *resv;
 453         unsigned int num_entries;
 454         int r;
 455
 456         memset(&bp, 0, sizeof(bp));
 457
 458         bp.size = amdgpu_vm_pt_size(adev, level);
 459         bp.byte_align = AMDGPU_GPU_PAGE_SIZE;
 460
 461         if (!adev->gmc.is_app_apu)
 462                 bp.domain = AMDGPU_GEM_DOMAIN_VRAM;
 463         else
 464                 bp.domain = AMDGPU_GEM_DOMAIN_GTT;
 465
 466         bp.domain = amdgpu_bo_get_preferred_domain(adev, bp.domain);
 467         bp.flags = AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS |
 468                 AMDGPU_GEM_CREATE_CPU_GTT_USWC;
 469
 470         if (level < AMDGPU_VM_PTB)
 471                 num_entries = amdgpu_vm_pt_num_entries(adev, level);
 472         else
 473                 num_entries = 0;
 474
 475         bp.bo_ptr_size = struct_size((*vmbo), entries, num_entries);
 476
 477         if (vm->use_cpu_for_update)
 478                 bp.flags |= AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED;
 479
 480         bp.type = ttm_bo_type_kernel;
 481         bp.no_wait_gpu = immediate;
 482         bp.xcp_id_plus1 = xcp_id + 1;
 483
 484         if (vm->root.bo)
 485                 bp.resv = vm->root.bo->tbo.base.resv;
 486
 487         r = amdgpu_bo_create_vm(adev, &bp, vmbo);
 488         if (r)
 489                 return r;
 490
 491         bo = &(*vmbo)->bo;
 492         if (vm->is_compute_context || (adev->flags & AMD_IS_APU)) {
 493                 (*vmbo)->shadow = NULL;
 494                 return 0;
 495         }
 496
 497         if (!bp.resv)
 498                 WARN_ON(dma_resv_lock(bo->tbo.base.resv,
 499                                       NULL));
 500         resv = bp.resv;
 501         memset(&bp, 0, sizeof(bp));
 502         bp.size = amdgpu_vm_pt_size(adev, level);
 503         bp.domain = AMDGPU_GEM_DOMAIN_GTT;
 504         bp.flags = AMDGPU_GEM_CREATE_CPU_GTT_USWC;
 505         bp.type = ttm_bo_type_kernel;
 506         bp.resv = bo->tbo.base.resv;
 507         bp.bo_ptr_size = sizeof(struct amdgpu_bo);
 508         bp.xcp_id_plus1 = xcp_id + 1;
 509
 510         r = amdgpu_bo_create(adev, &bp, &(*vmbo)->shadow);
 511
 512         if (!resv)
 513                 dma_resv_unlock(bo->tbo.base.resv);
 514
 515         if (r) {
 516                 amdgpu_bo_unref(&bo);
 517                 return r;
 518         }
 519
 520         amdgpu_bo_add_to_shadow_list(*vmbo);
 521
 522         return 0;
 523 }
 524
 525 /**
 526  * amdgpu_vm_pt_alloc - Allocate a specific page table
 527  *
 528  * @adev: amdgpu_device pointer
 529  * @vm: VM to allocate page tables for
 530  * @cursor: Which page table to allocate
 531  * @immediate: use an immediate update
 532  *
 533  * Make sure a specific page table or directory is allocated.
 534  *
 535  * Returns:
 536  * 1 if page table needed to be allocated, 0 if page table was already
 537  * allocated, negative errno if an error occurred.
 538  */
 539 static int amdgpu_vm_pt_alloc(struct amdgpu_device *adev,
 540                               struct amdgpu_vm *vm,
 541                               struct amdgpu_vm_pt_cursor *cursor,
 542                               bool immediate)
 543 {
 544         struct amdgpu_vm_bo_base *entry = cursor->entry;
 545         struct amdgpu_bo *pt_bo;
 546         struct amdgpu_bo_vm *pt;
 547         int r;
 548
 549         if (entry->bo)
 550                 return 0;
 551
 552         amdgpu_vm_eviction_unlock(vm);
 553         r = amdgpu_vm_pt_create(adev, vm, cursor->level, immediate, &pt,
 554                                 vm->root.bo->xcp_id);
 555         amdgpu_vm_eviction_lock(vm);
 556         if (r)
 557                 return r;
 558
 559         /* Keep a reference to the root directory to avoid
 560          * freeing them up in the wrong order.
 561          */
 562         pt_bo = &pt->bo;
 563         pt_bo->parent = amdgpu_bo_ref(cursor->parent->bo);
 564         amdgpu_vm_bo_base_init(entry, vm, pt_bo);
 565         r = amdgpu_vm_pt_clear(adev, vm, pt, immediate);
 566         if (r)
 567                 goto error_free_pt;
 568
 569         return 0;
 570
 571 error_free_pt:
 572         amdgpu_bo_unref(&pt->shadow);
 573         amdgpu_bo_unref(&pt_bo);
 574         return r;
 575 }
 576
 577 /**
 578  * amdgpu_vm_pt_free - free one PD/PT
 579  *
 580  * @entry: PDE to free
 581  */
 582 static void amdgpu_vm_pt_free(struct amdgpu_vm_bo_base *entry)
 583 {
 584         struct amdgpu_bo *shadow;
 585
 586         if (!entry->bo)
 587                 return;
 588
 589         entry->bo->vm_bo = NULL;
 590         shadow = amdgpu_bo_shadowed(entry->bo);
 591         if (shadow) {
 592                 ttm_bo_set_bulk_move(&shadow->tbo, NULL);
 593                 amdgpu_bo_unref(&shadow);
 594         }
 595         ttm_bo_set_bulk_move(&entry->bo->tbo, NULL);
 596
 597         spin_lock(&entry->vm->status_lock);
 598         list_del(&entry->vm_status);
 599         spin_unlock(&entry->vm->status_lock);
 600         amdgpu_bo_unref(&entry->bo);
 601 }
 602
 603 void amdgpu_vm_pt_free_work(struct work_struct *work)
 604 {
 605         struct amdgpu_vm_bo_base *entry, *next;
 606         struct amdgpu_vm *vm;
 607         LIST_HEAD(pt_freed);
 608
 609         vm = container_of(work, struct amdgpu_vm, pt_free_work);
 610
 611         spin_lock(&vm->status_lock);
 612         list_splice_init(&vm->pt_freed, &pt_freed);
 613         spin_unlock(&vm->status_lock);
 614
 615         /* flush_work in amdgpu_vm_fini ensure vm->root.bo is valid. */
 616         amdgpu_bo_reserve(vm->root.bo, true);
 617
 618         list_for_each_entry_safe(entry, next, &pt_freed, vm_status)
 619                 amdgpu_vm_pt_free(entry);
 620
 621         amdgpu_bo_unreserve(vm->root.bo);
 622 }
 623
 624 /**
 625  * amdgpu_vm_pt_free_list - free PD/PT levels
 626  *
 627  * @adev: amdgpu device structure
 628  * @params: see amdgpu_vm_update_params definition
 629  *
 630  * Free the page directory objects saved in the flush list
 631  */
 632 void amdgpu_vm_pt_free_list(struct amdgpu_device *adev,
 633                             struct amdgpu_vm_update_params *params)
 634 {
 635         struct amdgpu_vm_bo_base *entry, *next;
 636         struct amdgpu_vm *vm = params->vm;
 637         bool unlocked = params->unlocked;
 638
 639         if (list_empty(&params->tlb_flush_waitlist))
 640                 return;
 641
 642         if (unlocked) {
 643                 spin_lock(&vm->status_lock);
 644                 list_splice_init(&params->tlb_flush_waitlist, &vm->pt_freed);
 645                 spin_unlock(&vm->status_lock);
 646                 schedule_work(&vm->pt_free_work);
 647                 return;
 648         }
 649
 650         list_for_each_entry_safe(entry, next, &params->tlb_flush_waitlist, vm_status)
 651                 amdgpu_vm_pt_free(entry);
 652 }
 653
 654 /**
 655  * amdgpu_vm_pt_add_list - add PD/PT level to the flush list
 656  *
 657  * @params: parameters for the update
 658  * @cursor: first PT entry to start DF search from, non NULL
 659  *
 660  * This list will be freed after TLB flush.
 661  */
 662 static void amdgpu_vm_pt_add_list(struct amdgpu_vm_update_params *params,
 663                                   struct amdgpu_vm_pt_cursor *cursor)
 664 {
 665         struct amdgpu_vm_pt_cursor seek;
 666         struct amdgpu_vm_bo_base *entry;
 667
 668         spin_lock(&params->vm->status_lock);
 669         for_each_amdgpu_vm_pt_dfs_safe(params->adev, params->vm, cursor, seek, entry) {
 670                 if (entry && entry->bo)
 671                         list_move(&entry->vm_status, &params->tlb_flush_waitlist);
 672         }
 673
 674         /* enter start node now */
 675         list_move(&cursor->entry->vm_status, &params->tlb_flush_waitlist);
 676         spin_unlock(&params->vm->status_lock);
 677 }
 678
 679 /**
 680  * amdgpu_vm_pt_free_root - free root PD
 681  * @adev: amdgpu device structure
 682  * @vm: amdgpu vm structure
 683  *
 684  * Free the root page directory and everything below it.
 685  */
 686 void amdgpu_vm_pt_free_root(struct amdgpu_device *adev, struct amdgpu_vm *vm)
 687 {
 688         struct amdgpu_vm_pt_cursor cursor;
 689         struct amdgpu_vm_bo_base *entry;
 690
 691         for_each_amdgpu_vm_pt_dfs_safe(adev, vm, NULL, cursor, entry) {
 692                 if (entry)
 693                         amdgpu_vm_pt_free(entry);
 694         }
 695 }
 696
 697 /**
 698  * amdgpu_vm_pde_update - update a single level in the hierarchy
 699  *
 700  * @params: parameters for the update
 701  * @entry: entry to update
 702  *
 703  * Makes sure the requested entry in parent is up to date.
 704  */
 705 int amdgpu_vm_pde_update(struct amdgpu_vm_update_params *params,
 706                          struct amdgpu_vm_bo_base *entry)
 707 {
 708         struct amdgpu_vm_bo_base *parent = amdgpu_vm_pt_parent(entry);
 709         struct amdgpu_bo *bo, *pbo;
 710         struct amdgpu_vm *vm = params->vm;
 711         uint64_t pde, pt, flags;
 712         unsigned int level;
 713
 714         if (WARN_ON(!parent))
 715                 return -EINVAL;
 716
 717         bo = parent->bo;
 718         for (level = 0, pbo = bo->parent; pbo; ++level)
 719                 pbo = pbo->parent;
 720
 721         level += params->adev->vm_manager.root_level;
 722         amdgpu_gmc_get_pde_for_bo(entry->bo, level, &pt, &flags);
 723         pde = (entry - to_amdgpu_bo_vm(parent->bo)->entries) * 8;
 724         return vm->update_funcs->update(params, to_amdgpu_bo_vm(bo), pde, pt,
 725                                         1, 0, flags);
 726 }
 727
 728 /**
 729  * amdgpu_vm_pte_update_noretry_flags - Update PTE no-retry flags
 730  *
 731  * @adev: amdgpu_device pointer
 732  * @flags: pointer to PTE flags
 733  *
 734  * Update PTE no-retry flags when TF is enabled.
 735  */
 736 static void amdgpu_vm_pte_update_noretry_flags(struct amdgpu_device *adev,
 737                                                 uint64_t *flags)
 738 {
 739         /*
 740          * Update no-retry flags with the corresponding TF
 741          * no-retry combination.
 742          */
 743         if ((*flags & AMDGPU_VM_NORETRY_FLAGS) == AMDGPU_VM_NORETRY_FLAGS) {
 744                 *flags &= ~AMDGPU_VM_NORETRY_FLAGS;
 745                 *flags |= adev->gmc.noretry_flags;
 746         }
 747 }
 748
 749 /*
 750  * amdgpu_vm_pte_update_flags - figure out flags for PTE updates
 751  *
 752  * Make sure to set the right flags for the PTEs at the desired level.
 753  */
 754 static void amdgpu_vm_pte_update_flags(struct amdgpu_vm_update_params *params,
 755                                        struct amdgpu_bo_vm *pt,
 756                                        unsigned int level,
 757                                        uint64_t pe, uint64_t addr,
 758                                        unsigned int count, uint32_t incr,
 759                                        uint64_t flags)
 760 {
 761         struct amdgpu_device *adev = params->adev;
 762
 763         if (level != AMDGPU_VM_PTB) {
 764                 flags |= AMDGPU_PDE_PTE_FLAG(params->adev);
 765                 amdgpu_gmc_get_vm_pde(adev, level, &addr, &flags);
 766
 767         } else if (adev->asic_type >= CHIP_VEGA10 &&
 768                    !(flags & AMDGPU_PTE_VALID) &&
 769                    !(flags & AMDGPU_PTE_PRT_FLAG(params->adev))) {
 770
 771                 /* Workaround for fault priority problem on GMC9 */
 772                 flags |= AMDGPU_PTE_EXECUTABLE;
 773         }
 774
 775         /*
 776          * Update no-retry flags to use the no-retry flag combination
 777          * with TF enabled. The AMDGPU_VM_NORETRY_FLAGS flag combination
 778          * does not work when TF is enabled. So, replace them with
 779          * AMDGPU_VM_NORETRY_FLAGS_TF flag combination which works for
 780          * all cases.
 781          */
 782         if (level == AMDGPU_VM_PTB)
 783                 amdgpu_vm_pte_update_noretry_flags(adev, &flags);
 784
 785         /* APUs mapping system memory may need different MTYPEs on different
 786          * NUMA nodes. Only do this for contiguous ranges that can be assumed
 787          * to be on the same NUMA node.
 788          */
 789         if ((flags & AMDGPU_PTE_SYSTEM) && (adev->flags & AMD_IS_APU) &&
 790             adev->gmc.gmc_funcs->override_vm_pte_flags &&
 791             num_possible_nodes() > 1 && !params->pages_addr && params->allow_override)
 792                 amdgpu_gmc_override_vm_pte_flags(adev, params->vm, addr, &flags);
 793
 794         params->vm->update_funcs->update(params, pt, pe, addr, count, incr,
 795                                          flags);
 796 }
 797
 798 /**
 799  * amdgpu_vm_pte_fragment - get fragment for PTEs
 800  *
 801  * @params: see amdgpu_vm_update_params definition
 802  * @start: first PTE to handle
 803  * @end: last PTE to handle
 804  * @flags: hw mapping flags
 805  * @frag: resulting fragment size
 806  * @frag_end: end of this fragment
 807  *
 808  * Returns the first possible fragment for the start and end address.
 809  */
 810 static void amdgpu_vm_pte_fragment(struct amdgpu_vm_update_params *params,
 811                                    uint64_t start, uint64_t end, uint64_t flags,
 812                                    unsigned int *frag, uint64_t *frag_end)
 813 {
 814         /**
 815          * The MC L1 TLB supports variable sized pages, based on a fragment
 816          * field in the PTE. When this field is set to a non-zero value, page
 817          * granularity is increased from 4KB to (1 << (12 + frag)). The PTE
 818          * flags are considered valid for all PTEs within the fragment range
 819          * and corresponding mappings are assumed to be physically contiguous.
 820          *
 821          * The L1 TLB can store a single PTE for the whole fragment,
 822          * significantly increasing the space available for translation
 823          * caching. This leads to large improvements in throughput when the
 824          * TLB is under pressure.
 825          *
 826          * The L2 TLB distributes small and large fragments into two
 827          * asymmetric partitions. The large fragment cache is significantly
 828          * larger. Thus, we try to use large fragments wherever possible.
 829          * Userspace can support this by aligning virtual base address and
 830          * allocation size to the fragment size.
 831          *
 832          * Starting with Vega10 the fragment size only controls the L1. The L2
 833          * is now directly feed with small/huge/giant pages from the walker.
 834          */
 835         unsigned int max_frag;
 836
 837         if (params->adev->asic_type < CHIP_VEGA10)
 838                 max_frag = params->adev->vm_manager.fragment_size;
 839         else
 840                 max_frag = 31;
 841
 842         /* system pages are non continuously */
 843         if (params->pages_addr) {
 844                 *frag = 0;
 845                 *frag_end = end;
 846                 return;
 847         }
 848
 849         /* This intentionally wraps around if no bit is set */
 850         *frag = min_t(unsigned int, ffs(start) - 1, fls64(end - start) - 1);
 851         if (*frag >= max_frag) {
 852                 *frag = max_frag;
 853                 *frag_end = end & ~((1ULL << max_frag) - 1);
 854         } else {
 855                 *frag_end = start + (1 << *frag);
 856         }
 857 }
 858
 859 /**
 860  * amdgpu_vm_ptes_update - make sure that page tables are valid
 861  *
 862  * @params: see amdgpu_vm_update_params definition
 863  * @start: start of GPU address range
 864  * @end: end of GPU address range
 865  * @dst: destination address to map to, the next dst inside the function
 866  * @flags: mapping flags
 867  *
 868  * Update the page tables in the range @start - @end.
 869  *
 870  * Returns:
 871  * 0 for success, -EINVAL for failure.
 872  */
 873 int amdgpu_vm_ptes_update(struct amdgpu_vm_update_params *params,
 874                           uint64_t start, uint64_t end,
 875                           uint64_t dst, uint64_t flags)
 876 {
 877         struct amdgpu_device *adev = params->adev;
 878         struct amdgpu_vm_pt_cursor cursor;
 879         uint64_t frag_start = start, frag_end;
 880         unsigned int frag;
 881         int r;
 882
 883         /* figure out the initial fragment */
 884         amdgpu_vm_pte_fragment(params, frag_start, end, flags, &frag,
 885                                &frag_end);
 886
 887         /* walk over the address space and update the PTs */
 888         amdgpu_vm_pt_start(adev, params->vm, start, &cursor);
 889         while (cursor.pfn < end) {
 890                 unsigned int shift, parent_shift, mask;
 891                 uint64_t incr, entry_end, pe_start;
 892                 struct amdgpu_bo *pt;
 893
 894                 if (!params->unlocked) {
 895                         /* make sure that the page tables covering the
 896                          * address range are actually allocated
 897                          */
 898                         r = amdgpu_vm_pt_alloc(params->adev, params->vm,
 899                                                &cursor, params->immediate);
 900                         if (r)
 901                                 return r;
 902                 }
 903
 904                 shift = amdgpu_vm_pt_level_shift(adev, cursor.level);
 905                 parent_shift = amdgpu_vm_pt_level_shift(adev, cursor.level - 1);
 906                 if (params->unlocked) {
 907                         /* Unlocked updates are only allowed on the leaves */
 908                         if (amdgpu_vm_pt_descendant(adev, &cursor))
 909                                 continue;
 910                 } else if (adev->asic_type < CHIP_VEGA10 &&
 911                            (flags & AMDGPU_PTE_VALID)) {
 912                         /* No huge page support before GMC v9 */
 913                         if (cursor.level != AMDGPU_VM_PTB) {
 914                                 if (!amdgpu_vm_pt_descendant(adev, &cursor))
 915                                         return -ENOENT;
 916                                 continue;
 917                         }
 918                 } else if (frag < shift) {
 919                         /* We can't use this level when the fragment size is
 920                          * smaller than the address shift. Go to the next
 921                          * child entry and try again.
 922                          */
 923                         if (amdgpu_vm_pt_descendant(adev, &cursor))
 924                                 continue;
 925                 } else if (frag >= parent_shift) {
 926                         /* If the fragment size is even larger than the parent
 927                          * shift we should go up one level and check it again.
 928                          */
 929                         if (!amdgpu_vm_pt_ancestor(&cursor))
 930                                 return -EINVAL;
 931                         continue;
 932                 }
 933
 934                 pt = cursor.entry->bo;
 935                 if (!pt) {
 936                         /* We need all PDs and PTs for mapping something, */
 937                         if (flags & AMDGPU_PTE_VALID)
 938                                 return -ENOENT;
 939
 940                         /* but unmapping something can happen at a higher
 941                          * level.
 942                          */
 943                         if (!amdgpu_vm_pt_ancestor(&cursor))
 944                                 return -EINVAL;
 945
 946                         pt = cursor.entry->bo;
 947                         shift = parent_shift;
 948                         frag_end = max(frag_end, ALIGN(frag_start + 1,
 949                                    1ULL << shift));
 950                 }
 951
 952                 /* Looks good so far, calculate parameters for the update */
 953                 incr = (uint64_t)AMDGPU_GPU_PAGE_SIZE << shift;
 954                 mask = amdgpu_vm_pt_entries_mask(adev, cursor.level);
 955                 pe_start = ((cursor.pfn >> shift) & mask) * 8;
 956                 entry_end = ((uint64_t)mask + 1) << shift;
 957                 entry_end += cursor.pfn & ~(entry_end - 1);
 958                 entry_end = min(entry_end, end);
 959
 960                 do {
 961                         struct amdgpu_vm *vm = params->vm;
 962                         uint64_t upd_end = min(entry_end, frag_end);
 963                         unsigned int nptes = (upd_end - frag_start) >> shift;
 964                         uint64_t upd_flags = flags | AMDGPU_PTE_FRAG(frag);
 965
 966                         /* This can happen when we set higher level PDs to
 967                          * silent to stop fault floods.
 968                          */
 969                         nptes = max(nptes, 1u);
 970
 971                         trace_amdgpu_vm_update_ptes(params, frag_start, upd_end,
 972                                                     min(nptes, 32u), dst, incr,
 973                                                     upd_flags,
 974                                                     vm->task_info ? vm->task_info->tgid : 0,
 975                                                     vm->immediate.fence_context);
 976                         amdgpu_vm_pte_update_flags(params, to_amdgpu_bo_vm(pt),
 977                                                    cursor.level, pe_start, dst,
 978                                                    nptes, incr, upd_flags);
 979
 980                         pe_start += nptes * 8;
 981                         dst += nptes * incr;
 982
 983                         frag_start = upd_end;
 984                         if (frag_start >= frag_end) {
 985                                 /* figure out the next fragment */
 986                                 amdgpu_vm_pte_fragment(params, frag_start, end,
 987                                                        flags, &frag, &frag_end);
 988                                 if (frag < shift)
 989                                         break;
 990                         }
 991                 } while (frag_start < entry_end);
 992
 993                 if (amdgpu_vm_pt_descendant(adev, &cursor)) {
 994                         /* Free all child entries.
 995                          * Update the tables with the flags and addresses and free up subsequent
 996                          * tables in the case of huge pages or freed up areas.
 997                          * This is the maximum you can free, because all other page tables are not
 998                          * completely covered by the range and so potentially still in use.
 999                          */
1000                         while (cursor.pfn < frag_start) {
1001                                 /* Make sure previous mapping is freed */
1002                                 if (cursor.entry->bo) {
1003                                         params->needs_flush = true;
1004                                         amdgpu_vm_pt_add_list(params, &cursor);
1005                                 }
1006                                 amdgpu_vm_pt_next(adev, &cursor);
1007                         }
1008
1009                 } else if (frag >= shift) {
1010                         /* or just move on to the next on the same level. */
1011                         amdgpu_vm_pt_next(adev, &cursor);
1012                 }
1013         }
1014
1015         return 0;
1016 }
1017
1018 /**
1019  * amdgpu_vm_pt_map_tables - have bo of root PD cpu accessible
1020  * @adev: amdgpu device structure
1021  * @vm: amdgpu vm structure
1022  *
1023  * make root page directory and everything below it cpu accessible.
1024  */
1025 int amdgpu_vm_pt_map_tables(struct amdgpu_device *adev, struct amdgpu_vm *vm)
1026 {
1027         struct amdgpu_vm_pt_cursor cursor;
1028         struct amdgpu_vm_bo_base *entry;
1029
1030         for_each_amdgpu_vm_pt_dfs_safe(adev, vm, NULL, cursor, entry) {
1031
1032                 struct amdgpu_bo_vm *bo;
1033                 int r;
1034
1035                 if (entry->bo) {
1036                         bo = to_amdgpu_bo_vm(entry->bo);
1037                         r = vm->update_funcs->map_table(bo);
1038                         if (r)
1039                                 return r;
1040                 }
1041         }
1042
1043         return 0;
1044 }