Merge branch 'drm-next-4.12' of git://people.freedesktop.org/~agd5f/linux into drm-next

New stuff for 4.12:
- Preliminary vega10 support
- Support for multi-level page tables
- GPU sensor stuff for mesa
- job tracing improvements
- PRT support for sparse buffers
- Additional SR-IOV improvements
- ttm improvements
- misc bug fixes and code cleanups

* 'drm-next-4.12' of git://people.freedesktop.org/~agd5f/linux: (315 commits)
  drm/amdgpu: Fix 32bit x86 compilation warning
  drm/amdgpu: just disallow reading untouched registers
  drm/amdgpu: remove duplicate allowed reg CP_CPF_BUSY_STAT
  drm/amdgpu/soc15: enable psp block for SRIOV
  drm/amdgpu/soc15: bypass pp block for vf
  drm/amdgpu/psp: add check sOS sign
  drm/amd/amdgpu: Correct ring wptr address in debugfs (v2)
  drm/amdgpu: Fix multi-level page table bugs for large BOs v3
  drm/amdgpu: Fix Vega10 VM initialization
  drm/amdgpu: Make max_pfn 64-bit
  drm/amdgpu: drop GB_GPU_ID from the golden settings
  drm/amdgpu: fix vm pte pde flags to 64-bit for sdma (v3)
  drm/amd/amdgpu: fix Tonga S3 resume hang on rhel6.8
  drm/ttm: decrease ttm bo priority number
  drm/amd/amdgpu: fix performance drop when VRAM pressure
  drm/amdgpu: Couple small warning fixes
  drm/amdgpu: Clean up GFX 9 VM fault messages
  drm/amdgpu: Register UTCL2 as a source of VM faults
  drm/amdgpu/soc15: drop support for reading some registers
  drm/amdgpu/soc15: return cached values for some registers (v2)
  ...

1 files changed, 86 insertions, 36 deletions

diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_gem.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_gem.c
index 106cf83c2e6b..f85520d4e711 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_gem.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_gem.c
@@ -152,6 +152,7 @@ void amdgpu_gem_object_close(struct drm_gem_object *obj,
         struct ttm_validate_buffer tv;
         struct ww_acquire_ctx ticket;
         struct amdgpu_bo_va *bo_va;
+        struct dma_fence *fence = NULL;
         int r;
 
         INIT_LIST_HEAD(&list);
@@ -173,6 +174,17 @@ void amdgpu_gem_object_close(struct drm_gem_object *obj,
         if (bo_va) {
                 if (--bo_va->ref_count == 0) {
                         amdgpu_vm_bo_rmv(adev, bo_va);
+
+                        r = amdgpu_vm_clear_freed(adev, vm, &fence);
+                        if (unlikely(r)) {
+                                dev_err(adev->dev, "failed to clear page "
+                                        "tables on GEM object close (%d)\n", r);
+                        }
+
+                        if (fence) {
+                                amdgpu_bo_fence(bo, fence, true);
+                                dma_fence_put(fence);
+                        }
                 }
         }
         ttm_eu_backoff_reservation(&ticket, &list);
@@ -507,14 +519,16 @@ static int amdgpu_gem_va_check(void *param, struct amdgpu_bo *bo)
  * amdgpu_gem_va_update_vm -update the bo_va in its VM
  *
  * @adev: amdgpu_device pointer
+ * @vm: vm to update
  * @bo_va: bo_va to update
  * @list: validation list
- * @operation: map or unmap
+ * @operation: map, unmap or clear
  *
  * Update the bo_va directly after setting its address. Errors are not
  * vital here, so they are not reported back to userspace.
  */
 static void amdgpu_gem_va_update_vm(struct amdgpu_device *adev,
+                                    struct amdgpu_vm *vm,
                                     struct amdgpu_bo_va *bo_va,
                                     struct list_head *list,
                                     uint32_t operation)
@@ -529,20 +543,21 @@ static void amdgpu_gem_va_update_vm(struct amdgpu_device *adev,
                         goto error;
         }
 
-        r = amdgpu_vm_validate_pt_bos(adev, bo_va->vm, amdgpu_gem_va_check,
+        r = amdgpu_vm_validate_pt_bos(adev, vm, amdgpu_gem_va_check,
                                       NULL);
         if (r)
                 goto error;
 
-        r = amdgpu_vm_update_page_directory(adev, bo_va->vm);
+        r = amdgpu_vm_update_directories(adev, vm);
         if (r)
                 goto error;
 
-        r = amdgpu_vm_clear_freed(adev, bo_va->vm);
+        r = amdgpu_vm_clear_freed(adev, vm, NULL);
         if (r)
                 goto error;
 
-        if (operation == AMDGPU_VA_OP_MAP)
+        if (operation == AMDGPU_VA_OP_MAP ||
+            operation == AMDGPU_VA_OP_REPLACE)
                 r = amdgpu_vm_bo_update(adev, bo_va, false);
 
 error:
@@ -553,6 +568,12 @@ error:
 int amdgpu_gem_va_ioctl(struct drm_device *dev, void *data,
                           struct drm_file *filp)
 {
+        const uint32_t valid_flags = AMDGPU_VM_DELAY_UPDATE |
+                AMDGPU_VM_PAGE_READABLE | AMDGPU_VM_PAGE_WRITEABLE |
+                AMDGPU_VM_PAGE_EXECUTABLE | AMDGPU_VM_MTYPE_MASK;
+        const uint32_t prt_flags = AMDGPU_VM_DELAY_UPDATE |
+                AMDGPU_VM_PAGE_PRT;
+
         struct drm_amdgpu_gem_va *args = data;
         struct drm_gem_object *gobj;
         struct amdgpu_device *adev = dev->dev_private;
@@ -563,7 +584,7 @@ int amdgpu_gem_va_ioctl(struct drm_device *dev, void *data,
         struct ttm_validate_buffer tv;
         struct ww_acquire_ctx ticket;
         struct list_head list;
-        uint32_t invalid_flags, va_flags = 0;
+        uint64_t va_flags;
         int r = 0;
 
         if (!adev->vm_manager.enabled)
@@ -577,17 +598,17 @@ int amdgpu_gem_va_ioctl(struct drm_device *dev, void *data,
                 return -EINVAL;
         }
 
-        invalid_flags = ~(AMDGPU_VM_DELAY_UPDATE | AMDGPU_VM_PAGE_READABLE |
-                        AMDGPU_VM_PAGE_WRITEABLE | AMDGPU_VM_PAGE_EXECUTABLE);
-        if ((args->flags & invalid_flags)) {
-                dev_err(&dev->pdev->dev, "invalid flags 0x%08X vs 0x%08X\n",
-                        args->flags, invalid_flags);
+        if ((args->flags & ~valid_flags) && (args->flags & ~prt_flags)) {
+                dev_err(&dev->pdev->dev, "invalid flags combination 0x%08X\n",
+                        args->flags);
                 return -EINVAL;
         }
 
         switch (args->operation) {
         case AMDGPU_VA_OP_MAP:
         case AMDGPU_VA_OP_UNMAP:
+        case AMDGPU_VA_OP_CLEAR:
+        case AMDGPU_VA_OP_REPLACE:
                 break;
         default:
                 dev_err(&dev->pdev->dev, "unsupported operation %d\n",
@@ -595,38 +616,47 @@ int amdgpu_gem_va_ioctl(struct drm_device *dev, void *data,
                 return -EINVAL;
         }
 
-        gobj = drm_gem_object_lookup(filp, args->handle);
-        if (gobj == NULL)
-                return -ENOENT;
-        abo = gem_to_amdgpu_bo(gobj);
         INIT_LIST_HEAD(&list);
-        tv.bo = &abo->tbo;
-        tv.shared = false;
-        list_add(&tv.head, &list);
+        if ((args->operation != AMDGPU_VA_OP_CLEAR) &&
+            !(args->flags & AMDGPU_VM_PAGE_PRT)) {
+                gobj = drm_gem_object_lookup(filp, args->handle);
+                if (gobj == NULL)
+                        return -ENOENT;
+                abo = gem_to_amdgpu_bo(gobj);
+                tv.bo = &abo->tbo;
+                tv.shared = false;
+                list_add(&tv.head, &list);
+        } else {
+                gobj = NULL;
+                abo = NULL;
+        }
 
         amdgpu_vm_get_pd_bo(&fpriv->vm, &list, &vm_pd);
 
         r = ttm_eu_reserve_buffers(&ticket, &list, true, NULL);
-        if (r) {
-                drm_gem_object_unreference_unlocked(gobj);
-                return r;
-        }
+        if (r)
+                goto error_unref;
 
-        bo_va = amdgpu_vm_bo_find(&fpriv->vm, abo);
-        if (!bo_va) {
-                ttm_eu_backoff_reservation(&ticket, &list);
-                drm_gem_object_unreference_unlocked(gobj);
-                return -ENOENT;
+        if (abo) {
+                bo_va = amdgpu_vm_bo_find(&fpriv->vm, abo);
+                if (!bo_va) {
+                        r = -ENOENT;
+                        goto error_backoff;
+                }
+        } else if (args->operation != AMDGPU_VA_OP_CLEAR) {
+                bo_va = fpriv->prt_va;
+        } else {
+                bo_va = NULL;
         }
 
         switch (args->operation) {
         case AMDGPU_VA_OP_MAP:
-                if (args->flags & AMDGPU_VM_PAGE_READABLE)
-                        va_flags |= AMDGPU_PTE_READABLE;
-                if (args->flags & AMDGPU_VM_PAGE_WRITEABLE)
-                        va_flags |= AMDGPU_PTE_WRITEABLE;
-                if (args->flags & AMDGPU_VM_PAGE_EXECUTABLE)
-                        va_flags |= AMDGPU_PTE_EXECUTABLE;
+                r = amdgpu_vm_alloc_pts(adev, bo_va->vm, args->va_address,
+                                        args->map_size);
+                if (r)
+                        goto error_backoff;
+
+                va_flags = amdgpu_vm_get_pte_flags(adev, args->flags);
                 r = amdgpu_vm_bo_map(adev, bo_va, args->va_address,
                                      args->offset_in_bo, args->map_size,
                                      va_flags);
@@ -634,14 +664,34 @@ int amdgpu_gem_va_ioctl(struct drm_device *dev, void *data,
         case AMDGPU_VA_OP_UNMAP:
                 r = amdgpu_vm_bo_unmap(adev, bo_va, args->va_address);
                 break;
+
+        case AMDGPU_VA_OP_CLEAR:
+                r = amdgpu_vm_bo_clear_mappings(adev, &fpriv->vm,
+                                                args->va_address,
+                                                args->map_size);
+                break;
+        case AMDGPU_VA_OP_REPLACE:
+                r = amdgpu_vm_alloc_pts(adev, bo_va->vm, args->va_address,
+                                        args->map_size);
+                if (r)
+                        goto error_backoff;
+
+                va_flags = amdgpu_vm_get_pte_flags(adev, args->flags);
+                r = amdgpu_vm_bo_replace_map(adev, bo_va, args->va_address,
+                                             args->offset_in_bo, args->map_size,
+                                             va_flags);
+                break;
         default:
                 break;
         }
-        if (!r && !(args->flags & AMDGPU_VM_DELAY_UPDATE) &&
-            !amdgpu_vm_debug)
-                amdgpu_gem_va_update_vm(adev, bo_va, &list, args->operation);
+        if (!r && !(args->flags & AMDGPU_VM_DELAY_UPDATE) && !amdgpu_vm_debug)
+                amdgpu_gem_va_update_vm(adev, &fpriv->vm, bo_va, &list,
+                                        args->operation);
+
+error_backoff:
         ttm_eu_backoff_reservation(&ticket, &list);
 
+error_unref:
         drm_gem_object_unreference_unlocked(gobj);
         return r;
 }