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

Some additional fixes for 4.9:
- The rest of Christian's GTT rework which fixes a long standing bug
  in the GPUVM code among other things
- Changes to the pci shutdown callbacks for certain hypervisors
- Fix hpd interrupt storms on eDP panels which have the hpd interrupt
  enabled by the bios
- misc cleanups and bug fixes

* 'drm-next-4.9' of git://people.freedesktop.org/~agd5f/linux: (33 commits)
  drm/radeon: always apply pci shutdown callbacks
  drm/amdgpu: always apply pci shutdown callbacks (v2)
  drm/amdgpu: improve VM PTE trace points
  drm/amdgpu: fix GART_DEBUGFS define
  drm/amdgpu: free userptrs even if GTT isn't bound
  drm/amd/amdgpu: Various cleanups for DCEv6
  drm/amdgpu: fix BO move offsets
  drm/amdgpu: fix amdgpu_move_blit on 32bit systems
  drm/amdgpu: fix gtt_mgr bo's offset
  drm/amdgpu: fix initializing the VM BO shadow
  drm/amdgpu: fix initializing the VM last eviction counter
  drm/amdgpu: cleanup VM shadow BO unreferencing
  drm/amdgpu: allocate GTT space for shadow VM page tables
  drm/amdgpu: rename all rbo variable to abo v2
  drm/amdgpu: remove unused member from struct amdgpu_bo
  drm/amdgpu: add a custom GTT memory manager v2
  drm/amdgpu/dce6: disable hpd on local panels
  drm/amdgpu/dce8: disable hpd on local panels
  drm/amdgpu/dce11: disable hpd on local panels
  drm/amdgpu/dce10: disable hpd on local panels
  ...

1 files changed, 55 insertions, 12 deletions

diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c
index a6a48ed9562e..bc4b22c6fc08 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c
@@ -487,7 +487,7 @@ static void amdgpu_vm_do_set_ptes(struct amdgpu_pte_update_params *params,
                                   unsigned count, uint32_t incr,
                                   uint32_t flags)
 {
-        trace_amdgpu_vm_set_page(pe, addr, count, incr, flags);
+        trace_amdgpu_vm_set_ptes(pe, addr, count, incr, flags);
 
         if (count < 3) {
                 amdgpu_vm_write_pte(params->adev, params->ib, pe,
@@ -516,10 +516,12 @@ static void amdgpu_vm_do_copy_ptes(struct amdgpu_pte_update_params *params,
                                    unsigned count, uint32_t incr,
                                    uint32_t flags)
 {
-        trace_amdgpu_vm_set_page(pe, addr, count, incr, flags);
+        uint64_t src = (params->src + (addr >> 12) * 8);
 
-        amdgpu_vm_copy_pte(params->adev, params->ib, pe,
-                           (params->src + (addr >> 12) * 8), count);
+
+        trace_amdgpu_vm_copy_ptes(pe, src, count);
+
+        amdgpu_vm_copy_pte(params->adev, params->ib, pe, src, count);
 }
 
 /**
@@ -552,6 +554,10 @@ static int amdgpu_vm_clear_bo(struct amdgpu_device *adev,
         if (r)
                 goto error;
 
+        r = amdgpu_ttm_bind(&bo->tbo, &bo->tbo.mem);
+        if (r)
+                goto error;
+
         addr = amdgpu_bo_gpu_offset(bo);
         entries = amdgpu_bo_size(bo) / 8;
 
@@ -625,6 +631,11 @@ static int amdgpu_vm_update_pd_or_shadow(struct amdgpu_device *adev,
 
         if (!pd)
                 return 0;
+
+        r = amdgpu_ttm_bind(&pd->tbo, &pd->tbo.mem);
+        if (r)
+                return r;
+
         pd_addr = amdgpu_bo_gpu_offset(pd);
         ring = container_of(vm->entity.sched, struct amdgpu_ring, sched);
 
@@ -650,6 +661,14 @@ static int amdgpu_vm_update_pd_or_shadow(struct amdgpu_device *adev,
                 if (bo == NULL)
                         continue;
 
+                if (bo->shadow) {
+                        struct amdgpu_bo *shadow = bo->shadow;
+
+                        r = amdgpu_ttm_bind(&shadow->tbo, &shadow->tbo.mem);
+                        if (r)
+                                return r;
+                }
+
                 pt = amdgpu_bo_gpu_offset(bo);
                 if (!shadow) {
                         if (vm->page_tables[pt_idx].addr == pt)
@@ -1000,6 +1019,7 @@ static int amdgpu_vm_bo_update_mapping(struct amdgpu_device *adev,
                                                     AMDGPU_GPU_PAGE_SIZE);
                         pte[i] |= flags;
                 }
+                addr = 0;
         }
 
         r = amdgpu_sync_fence(adev, &job->sync, exclusive);
@@ -1412,10 +1432,20 @@ int amdgpu_vm_bo_map(struct amdgpu_device *adev,
 
                 r = amdgpu_vm_clear_bo(adev, vm, pt);
                 if (r) {
+                        amdgpu_bo_unref(&pt->shadow);
                         amdgpu_bo_unref(&pt);
                         goto error_free;
                 }
 
+                if (pt->shadow) {
+                        r = amdgpu_vm_clear_bo(adev, vm, pt->shadow);
+                        if (r) {
+                                amdgpu_bo_unref(&pt->shadow);
+                                amdgpu_bo_unref(&pt);
+                                goto error_free;
+                        }
+                }
+
                 entry->robj = pt;
                 entry->priority = 0;
                 entry->tv.bo = &entry->robj->tbo;
@@ -1610,14 +1640,25 @@ int amdgpu_vm_init(struct amdgpu_device *adev, struct amdgpu_vm *vm)
                 goto error_free_page_directory;
 
         r = amdgpu_vm_clear_bo(adev, vm, vm->page_directory);
-        amdgpu_bo_unreserve(vm->page_directory);
         if (r)
-                goto error_free_page_directory;
+                goto error_unreserve;
+
+        if (vm->page_directory->shadow) {
+                r = amdgpu_vm_clear_bo(adev, vm, vm->page_directory->shadow);
+                if (r)
+                        goto error_unreserve;
+        }
+
         vm->last_eviction_counter = atomic64_read(&adev->num_evictions);
+        amdgpu_bo_unreserve(vm->page_directory);
 
         return 0;
 
+error_unreserve:
+        amdgpu_bo_unreserve(vm->page_directory);
+
 error_free_page_directory:
+        amdgpu_bo_unref(&vm->page_directory->shadow);
         amdgpu_bo_unref(&vm->page_directory);
         vm->page_directory = NULL;
 
@@ -1660,15 +1701,17 @@ void amdgpu_vm_fini(struct amdgpu_device *adev, struct amdgpu_vm *vm)
         }
 
         for (i = 0; i < amdgpu_vm_num_pdes(adev); i++) {
-                if (vm->page_tables[i].entry.robj &&
-                    vm->page_tables[i].entry.robj->shadow)
-                        amdgpu_bo_unref(&vm->page_tables[i].entry.robj->shadow);
-                amdgpu_bo_unref(&vm->page_tables[i].entry.robj);
+                struct amdgpu_bo *pt = vm->page_tables[i].entry.robj;
+
+                if (!pt)
+                        continue;
+
+                amdgpu_bo_unref(&pt->shadow);
+                amdgpu_bo_unref(&pt);
         }
         drm_free_large(vm->page_tables);
 
-        if (vm->page_directory->shadow)
-                amdgpu_bo_unref(&vm->page_directory->shadow);
+        amdgpu_bo_unref(&vm->page_directory->shadow);
         amdgpu_bo_unref(&vm->page_directory);
         fence_put(vm->page_directory_fence);
 }