Skip to contentSkip to conversation

drm/amdgpu: add done BO list

PATCH In review Peng Ju Zhou 2 participants 5 messages Aug 4, 2021

Subsystems (2)
lore
Share & tools
lore
#0 lore raw

PATCH 1/1 drm/amdgpu: add done BO list

From: David M Nieto <[email protected]>

backport of "add a list in VM for BOs in the done state"

---
 drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c | 1196 +++++++++++-------------
 1 file changed, 561 insertions(+), 635 deletions(-)
drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +561 -635
index 2a88ed5d983b..ecf7f2039de0 100644
@@ -25,22 +25,16 @@
  *          Alex Deucher
  *          Jerome Glisse
  */
-
 #include <linux/dma-fence-array.h>
 #include <linux/interval_tree_generic.h>
 #include <linux/idr.h>
-#include <linux/dma-buf.h>
 
 #include <drm/amdgpu_drm.h>
-#include <drm/drm_drv.h>
 #include "amdgpu.h"
 #include "amdgpu_trace.h"
 #include "amdgpu_amdkfd.h"
 #include "amdgpu_gmc.h"
 #include "amdgpu_xgmi.h"
-#include "amdgpu_dma_buf.h"
-#include "amdgpu_res_cursor.h"
-#include "kfd_svm.h"
 
 /**
  * DOC: GPUVM
@@ -89,46 +83,6 @@ struct amdgpu_prt_cb {
 };
 
 /**
- * amdgpu_vm_set_pasid - manage pasid and vm ptr mapping
- *
- * @adev: amdgpu_device pointer
- * @vm: amdgpu_vm pointer
- * @pasid: the pasid the VM is using on this GPU
- *
- * Set the pasid this VM is using on this GPU, can also be used to remove the
- * pasid by passing in zero.
- *
- */
-int amdgpu_vm_set_pasid(struct amdgpu_device *adev, struct amdgpu_vm *vm,
-			u32 pasid)
-{
-	int r;
-
-	if (vm->pasid == pasid)
-		return 0;
-
-	if (vm->pasid) {
-		r = xa_err(xa_erase_irq(&adev->vm_manager.pasids, vm->pasid));
-		if (r < 0)
-			return r;
-
-		vm->pasid = 0;
-	}
-
-	if (pasid) {
-		r = xa_err(xa_store_irq(&adev->vm_manager.pasids, pasid, vm,
-					GFP_KERNEL));
-		if (r < 0)
-			return r;
-
-		vm->pasid = pasid;
-	}
-
-
-	return 0;
-}
-
-/*
  * vm eviction_lock can be taken in MMU notifiers. Make sure no reclaim-FS
  * happens while holding this lock anywhere to prevent deadlocks when
  * an MMU notifier runs in reclaim-FS context.
@@ -136,13 +90,13 @@ int amdgpu_vm_set_pasid(struct amdgpu_device *adev, struct amdgpu_vm *vm,
 static inline void amdgpu_vm_eviction_lock(struct amdgpu_vm *vm)
 {
 	mutex_lock(&vm->eviction_lock);
-	vm->saved_flags = memalloc_noreclaim_save();
+	vm->saved_flags = memalloc_nofs_save();
 }
 
 static inline int amdgpu_vm_eviction_trylock(struct amdgpu_vm *vm)
 {
 	if (mutex_trylock(&vm->eviction_lock)) {
-		vm->saved_flags = memalloc_noreclaim_save();
+		vm->saved_flags = memalloc_nofs_save();
 		return 1;
 	}
 	return 0;
@@ -150,7 +104,7 @@ static inline int amdgpu_vm_eviction_trylock(struct amdgpu_vm *vm)
 
 static inline void amdgpu_vm_eviction_unlock(struct amdgpu_vm *vm)
 {
-	memalloc_noreclaim_restore(vm->saved_flags);
+	memalloc_nofs_restore(vm->saved_flags);
 	mutex_unlock(&vm->eviction_lock);
 }
 
@@ -372,7 +326,7 @@ static void amdgpu_vm_bo_base_init(struct amdgpu_vm_bo_base *base,
 	base->next = bo->vm_bo;
 	bo->vm_bo = base;
 
-	if (bo->tbo.base.resv != vm->root.bo->tbo.base.resv)
+	if (amdkcl_ttm_resvp(&bo->tbo) != amdkcl_ttm_resvp(&vm->root.base.bo->tbo))
 		return;
 
 	vm->bulk_moveable = false;
@@ -382,7 +336,7 @@ static void amdgpu_vm_bo_base_init(struct amdgpu_vm_bo_base *base,
 		amdgpu_vm_bo_idle(base);
 
 	if (bo->preferred_domains &
-	    amdgpu_mem_type_to_domain(bo->tbo.resource->mem_type))
+	    amdgpu_mem_type_to_domain(bo->tbo.mem.mem_type))
 		return;
 
 	/*
@@ -401,14 +355,14 @@ static void amdgpu_vm_bo_base_init(struct amdgpu_vm_bo_base *base,
  * Helper to get the parent entry for the child page table. NULL if we are at
  * the root page directory.
  */
-static struct amdgpu_vm_bo_base *amdgpu_vm_pt_parent(struct amdgpu_vm_bo_base *pt)
+static struct amdgpu_vm_pt *amdgpu_vm_pt_parent(struct amdgpu_vm_pt *pt)
 {
-	struct amdgpu_bo *parent = pt->bo->parent;
+	struct amdgpu_bo *parent = pt->base.bo->parent;
 
 	if (!parent)
 		return NULL;
 
-	return parent->vm_bo;
+	return container_of(parent->vm_bo, struct amdgpu_vm_pt, base);
 }
 
 /*
@@ -416,8 +370,8 @@ static struct amdgpu_vm_bo_base *amdgpu_vm_pt_parent(struct amdgpu_vm_bo_base *p
  */
 struct amdgpu_vm_pt_cursor {
 	uint64_t pfn;
-	struct amdgpu_vm_bo_base *parent;
-	struct amdgpu_vm_bo_base *entry;
+	struct amdgpu_vm_pt *parent;
+	struct amdgpu_vm_pt *entry;
 	unsigned level;
 };
 
@@ -456,17 +410,17 @@ static bool amdgpu_vm_pt_descendant(struct amdgpu_device *adev,
 {
 	unsigned mask, shift, idx;
 
-	if ((cursor->level == AMDGPU_VM_PTB) || !cursor->entry ||
-	    !cursor->entry->bo)
+	if (!cursor->entry->entries)
 		return false;
 
+	BUG_ON(!cursor->entry->base.bo);
 	mask = amdgpu_vm_entries_mask(adev, cursor->level);
 	shift = amdgpu_vm_level_shift(adev, cursor->level);
 
 	++cursor->level;
 	idx = (cursor->pfn >> shift) & mask;
 	cursor->parent = cursor->entry;
-	cursor->entry = &to_amdgpu_bo_vm(cursor->entry->bo)->entries[idx];
+	cursor->entry = &cursor->entry->entries[idx];
 	return true;
 }
 
@@ -493,7 +447,7 @@ static bool amdgpu_vm_pt_sibling(struct amdgpu_device *adev,
 	shift = amdgpu_vm_level_shift(adev, cursor->level - 1);
 	num_entries = amdgpu_vm_num_entries(adev, cursor->level - 1);
 
-	if (cursor->entry == &to_amdgpu_bo_vm(cursor->parent->bo)->entries[num_entries - 1])
+	if (cursor->entry == &cursor->parent->entries[num_entries - 1])
 		return false;
 
 	cursor->pfn += 1ULL << shift;
@@ -579,7 +533,7 @@ static void amdgpu_vm_pt_first_dfs(struct amdgpu_device *adev,
  * True when the search should continue, false otherwise.
  */
 static bool amdgpu_vm_pt_continue_dfs(struct amdgpu_vm_pt_cursor *start,
-				      struct amdgpu_vm_bo_base *entry)
+				      struct amdgpu_vm_pt *entry)
 {
 	return entry && (!start || entry != start->entry);
 }
@@ -630,7 +584,7 @@ void amdgpu_vm_get_pd_bo(struct amdgpu_vm *vm,
 			 struct amdgpu_bo_list_entry *entry)
 {
 	entry->priority = 0;
-	entry->tv.bo = &vm->root.bo->tbo;
+	entry->tv.bo = &vm->root.base.bo->tbo;
 	/* Two for VM updates, one for TTM and one for the CS job */
 	entry->tv.num_shared = 4;
 	entry->user_pages = NULL;
@@ -653,7 +607,7 @@ void amdgpu_vm_del_from_lru_notify(struct ttm_buffer_object *bo)
 	if (!amdgpu_bo_is_amdgpu_bo(bo))
 		return;
 
-	if (bo->pin_count)
+	if (bo->mem.placement & TTM_PL_FLAG_NO_EVICT)
 		return;
 
 	abo = ttm_to_amdgpu_bo(bo);
@@ -662,7 +616,7 @@ void amdgpu_vm_del_from_lru_notify(struct ttm_buffer_object *bo)
 	for (bo_base = abo->vm_bo; bo_base; bo_base = bo_base->next) {
 		struct amdgpu_vm *vm = bo_base->vm;
 
-		if (abo->tbo.base.resv == vm->root.bo->tbo.base.resv)
+		if (amdkcl_ttm_resvp(&abo->tbo) == amdkcl_ttm_resvp(&vm->root.base.bo->tbo))
 			vm->bulk_moveable = false;
 	}
 
@@ -682,30 +636,27 @@ void amdgpu_vm_move_to_lru_tail(struct amdgpu_device *adev,
 	struct amdgpu_vm_bo_base *bo_base;
 
 	if (vm->bulk_moveable) {
-		spin_lock(&adev->mman.bdev.lru_lock);
+		spin_lock(&ttm_bo_glob.lru_lock);
 		ttm_bo_bulk_move_lru_tail(&vm->lru_bulk_move);
-		spin_unlock(&adev->mman.bdev.lru_lock);
+		spin_unlock(&ttm_bo_glob.lru_lock);
 		return;
 	}
 
 	memset(&vm->lru_bulk_move, 0, sizeof(vm->lru_bulk_move));
 
-	spin_lock(&adev->mman.bdev.lru_lock);
+	spin_lock(&ttm_bo_glob.lru_lock);
 	list_for_each_entry(bo_base, &vm->idle, vm_status) {
 		struct amdgpu_bo *bo = bo_base->bo;
-		struct amdgpu_bo *shadow = amdgpu_bo_shadowed(bo);
 
 		if (!bo->parent)
 			continue;
 
-		ttm_bo_move_to_lru_tail(&bo->tbo, bo->tbo.resource,
-					&vm->lru_bulk_move);
-		if (shadow)
-			ttm_bo_move_to_lru_tail(&shadow->tbo,
-						shadow->tbo.resource,
+		ttm_bo_move_to_lru_tail(&bo->tbo, &vm->lru_bulk_move);
+		if (bo->shadow)
+			ttm_bo_move_to_lru_tail(&bo->shadow->tbo,
 						&vm->lru_bulk_move);
 	}
-	spin_unlock(&adev->mman.bdev.lru_lock);
+	spin_unlock(&ttm_bo_glob.lru_lock);
 
 	vm->bulk_moveable = true;
 }
@@ -734,21 +685,15 @@ int amdgpu_vm_validate_pt_bos(struct amdgpu_device *adev, struct amdgpu_vm *vm,
 
 	list_for_each_entry_safe(bo_base, tmp, &vm->evicted, vm_status) {
 		struct amdgpu_bo *bo = bo_base->bo;
-		struct amdgpu_bo *shadow = amdgpu_bo_shadowed(bo);
 
 		r = validate(param, bo);
 		if (r)
 			return r;
-		if (shadow) {
-			r = validate(param, shadow);
-			if (r)
-				return r;
-		}
 
 		if (bo->tbo.type != ttm_bo_type_kernel) {
 			amdgpu_vm_bo_moved(bo_base);
 		} else {
-			vm->update_funcs->map_table(to_amdgpu_bo_vm(bo));
+			vm->update_funcs->map_table(bo);
 			amdgpu_vm_bo_relocated(bo_base);
 		}
 	}
@@ -780,8 +725,8 @@ bool amdgpu_vm_ready(struct amdgpu_vm *vm)
  *
  * @adev: amdgpu_device pointer
  * @vm: VM to clear BO from
- * @vmbo: BO to clear
- * @immediate: use an immediate update
+ * @bo: BO to clear
+ * @direct: use a direct update
  *
  * Root PD needs to be reserved when calling this.
  *
@@ -790,14 +735,13 @@ bool amdgpu_vm_ready(struct amdgpu_vm *vm)
  */
 static int amdgpu_vm_clear_bo(struct amdgpu_device *adev,
 			      struct amdgpu_vm *vm,
-			      struct amdgpu_bo_vm *vmbo,
-			      bool immediate)
+			      struct amdgpu_bo *bo,
+			      bool direct)
 {
 	struct ttm_operation_ctx ctx = { true, false };
 	unsigned level = adev->vm_manager.root_level;
 	struct amdgpu_vm_update_params params;
-	struct amdgpu_bo *ancestor = &vmbo->bo;
-	struct amdgpu_bo *bo = &vmbo->bo;
+	struct amdgpu_bo *ancestor = bo;
 	unsigned entries, ats_entries;
 	uint64_t addr;
 	int r;
@@ -821,11 +765,11 @@ static int amdgpu_vm_clear_bo(struct amdgpu_device *adev,
 		entries -= ats_entries;
 
 	} else {
-		struct amdgpu_vm_bo_base *pt;
+		struct amdgpu_vm_pt *pt;
 
-		pt = ancestor->vm_bo;
+		pt = container_of(ancestor->vm_bo, struct amdgpu_vm_pt, base);
 		ats_entries = amdgpu_vm_num_ats_entries(adev);
-		if ((pt - to_amdgpu_bo_vm(vm->root.bo)->entries) >= ats_entries) {
+		if ((pt - vm->root.entries) >= ats_entries) {
 			ats_entries = 0;
 		} else {
 			ats_entries = entries;
@@ -837,22 +781,21 @@ static int amdgpu_vm_clear_bo(struct amdgpu_device *adev,
 	if (r)
 		return r;
 
-	if (vmbo->shadow) {
-		struct amdgpu_bo *shadow = vmbo->shadow;
-
-		r = ttm_bo_validate(&shadow->tbo, &shadow->placement, &ctx);
+	if (bo->shadow) {
+		r = ttm_bo_validate(&bo->shadow->tbo, &bo->shadow->placement,
+				    &ctx);
 		if (r)
 			return r;
 	}
 
-	r = vm->update_funcs->map_table(vmbo);
+	r = vm->update_funcs->map_table(bo);
 	if (r)
 		return r;
 
 	memset(&params, 0, sizeof(params));
 	params.adev = adev;
 	params.vm = vm;
-	params.immediate = immediate;
+	params.direct = direct;
 
 	r = vm->update_funcs->prepare(&params, NULL, AMDGPU_SYNC_EXPLICIT);
 	if (r)
@@ -869,7 +812,7 @@ static int amdgpu_vm_clear_bo(struct amdgpu_device *adev,
 			amdgpu_gmc_get_vm_pde(adev, level, &value, &flags);
 		}
 
-		r = vm->update_funcs->update(&params, vmbo, addr, 0, ats_entries,
+		r = vm->update_funcs->update(&params, bo, addr, 0, ats_entries,
 					     value, flags);
 		if (r)
 			return r;
@@ -892,7 +835,7 @@ static int amdgpu_vm_clear_bo(struct amdgpu_device *adev,
 			}
 		}
 
-		r = vm->update_funcs->update(&params, vmbo, addr, 0, entries,
+		r = vm->update_funcs->update(&params, bo, addr, 0, entries,
 					     value, flags);
 		if (r)
 			return r;
@@ -902,85 +845,34 @@ static int amdgpu_vm_clear_bo(struct amdgpu_device *adev,
 }
 
 /**
- * amdgpu_vm_pt_create - create bo for PD/PT
+ * amdgpu_vm_bo_param - fill in parameters for PD/PT allocation
  *
  * @adev: amdgpu_device pointer
  * @vm: requesting vm
  * @level: the page table level
- * @immediate: use a immediate update
- * @vmbo: pointer to the buffer object pointer
+ * @direct: use a direct update
+ * @bp: resulting BO allocation parameters
  */
-static int amdgpu_vm_pt_create(struct amdgpu_device *adev,
-			       struct amdgpu_vm *vm,
-			       int level, bool immediate,
-			       struct amdgpu_bo_vm **vmbo)
+static void amdgpu_vm_bo_param(struct amdgpu_device *adev, struct amdgpu_vm *vm,
+			       int level, bool direct,
+			       struct amdgpu_bo_param *bp)
 {
-	struct amdgpu_bo_param bp;
-	struct amdgpu_bo *bo;
-	struct dma_resv *resv;
-	unsigned int num_entries;
-	int r;
-
-	memset(&bp, 0, sizeof(bp));
+	memset(bp, 0, sizeof(*bp));
 
-	bp.size = amdgpu_vm_bo_size(adev, level);
-	bp.byte_align = AMDGPU_GPU_PAGE_SIZE;
-	bp.domain = AMDGPU_GEM_DOMAIN_VRAM;
-	bp.domain = amdgpu_bo_get_preferred_pin_domain(adev, bp.domain);
-	bp.flags = AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS |
+	bp->size = amdgpu_vm_bo_size(adev, level);
+	bp->byte_align = AMDGPU_GPU_PAGE_SIZE;
+	bp->domain = AMDGPU_GEM_DOMAIN_VRAM;
+	bp->domain = amdgpu_bo_get_preferred_pin_domain(adev, bp->domain);
+	bp->flags = AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS |
 		AMDGPU_GEM_CREATE_CPU_GTT_USWC;
-
-	if (level < AMDGPU_VM_PTB)
-		num_entries = amdgpu_vm_num_entries(adev, level);
-	else
-		num_entries = 0;
-
-	bp.bo_ptr_size = struct_size((*vmbo), entries, num_entries);
-
 	if (vm->use_cpu_for_update)
-		bp.flags |= AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED;
-
-	bp.type = ttm_bo_type_kernel;
-	bp.no_wait_gpu = immediate;
-	if (vm->root.bo)
-		bp.resv = vm->root.bo->tbo.base.resv;
-
-	r = amdgpu_bo_create_vm(adev, &bp, vmbo);
-	if (r)
-		return r;
-
-	bo = &(*vmbo)->bo;
-	if (vm->is_compute_context || (adev->flags & AMD_IS_APU)) {
-		(*vmbo)->shadow = NULL;
-		return 0;
-	}
-
-	if (!bp.resv)
-		WARN_ON(dma_resv_lock(bo->tbo.base.resv,
-				      NULL));
-	resv = bp.resv;
-	memset(&bp, 0, sizeof(bp));
-	bp.size = amdgpu_vm_bo_size(adev, level);
-	bp.domain = AMDGPU_GEM_DOMAIN_GTT;
-	bp.flags = AMDGPU_GEM_CREATE_CPU_GTT_USWC;
-	bp.type = ttm_bo_type_kernel;
-	bp.resv = bo->tbo.base.resv;
-	bp.bo_ptr_size = sizeof(struct amdgpu_bo);
-
-	r = amdgpu_bo_create(adev, &bp, &(*vmbo)->shadow);
-
-	if (!resv)
-		dma_resv_unlock(bo->tbo.base.resv);
-
-	if (r) {
-		amdgpu_bo_unref(&bo);
-		return r;
-	}
-
-	(*vmbo)->shadow->parent = amdgpu_bo_ref(bo);
-	amdgpu_bo_add_to_shadow_list(*vmbo);
-
-	return 0;
+		bp->flags |= AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED;
+	else if (!vm->root.base.bo || vm->root.base.bo->shadow)
+		bp->flags |= AMDGPU_GEM_CREATE_SHADOW;
+	bp->type = ttm_bo_type_kernel;
+	bp->no_wait_gpu = direct;
+	if (vm->root.base.bo)
+		bp->resv = amdkcl_ttm_resvp(&vm->root.base.bo->tbo);
 }
 
 /**
@@ -989,7 +881,7 @@ static int amdgpu_vm_pt_create(struct amdgpu_device *adev,
  * @adev: amdgpu_device pointer
  * @vm: VM to allocate page tables for
  * @cursor: Which page table to allocate
- * @immediate: use an immediate update
+ * @direct: use a direct update
  *
  * Make sure a specific page table or directory is allocated.
  *
@@ -1000,27 +892,40 @@ static int amdgpu_vm_pt_create(struct amdgpu_device *adev,
 static int amdgpu_vm_alloc_pts(struct amdgpu_device *adev,
 			       struct amdgpu_vm *vm,
 			       struct amdgpu_vm_pt_cursor *cursor,
-			       bool immediate)
+			       bool direct)
 {
-	struct amdgpu_vm_bo_base *entry = cursor->entry;
-	struct amdgpu_bo *pt_bo;
-	struct amdgpu_bo_vm *pt;
+	struct amdgpu_vm_pt *entry = cursor->entry;
+	struct amdgpu_bo_param bp;
+	struct amdgpu_bo *pt;
 	int r;
 
-	if (entry->bo)
+	if (cursor->level < AMDGPU_VM_PTB && !entry->entries) {
+		unsigned num_entries;
+
+		num_entries = amdgpu_vm_num_entries(adev, cursor->level);
+		entry->entries = kvmalloc_array(num_entries,
+						sizeof(*entry->entries),
+						GFP_KERNEL | __GFP_ZERO);
+		if (!entry->entries)
+			return -ENOMEM;
+	}
+
+	if (entry->base.bo)
 		return 0;
 
-	r = amdgpu_vm_pt_create(adev, vm, cursor->level, immediate, &pt);
+	amdgpu_vm_bo_param(adev, vm, cursor->level, direct, &bp);
+
+	r = amdgpu_bo_create(adev, &bp, &pt);
 	if (r)
 		return r;
 
 	/* Keep a reference to the root directory to avoid
 	 * freeing them up in the wrong order.
 	 */
-	pt_bo = &pt->bo;
-	pt_bo->parent = amdgpu_bo_ref(cursor->parent->bo);
-	amdgpu_vm_bo_base_init(entry, vm, pt_bo);
-	r = amdgpu_vm_clear_bo(adev, vm, pt, immediate);
+	pt->parent = amdgpu_bo_ref(cursor->parent->base.bo);
+	amdgpu_vm_bo_base_init(&entry->base, vm, pt);
+
+	r = amdgpu_vm_clear_bo(adev, vm, pt, direct);
 	if (r)
 		goto error_free_pt;
 
@@ -1028,7 +933,7 @@ static int amdgpu_vm_alloc_pts(struct amdgpu_device *adev,
 
 error_free_pt:
 	amdgpu_bo_unref(&pt->shadow);
-	amdgpu_bo_unref(&pt_bo);
+	amdgpu_bo_unref(&pt);
 	return r;
 }
 
@@ -1037,17 +942,16 @@ static int amdgpu_vm_alloc_pts(struct amdgpu_device *adev,
  *
  * @entry: PDE to free
  */
-static void amdgpu_vm_free_table(struct amdgpu_vm_bo_base *entry)
+static void amdgpu_vm_free_table(struct amdgpu_vm_pt *entry)
 {
-	struct amdgpu_bo *shadow;
-
-	if (!entry->bo)
-		return;
-	shadow = amdgpu_bo_shadowed(entry->bo);
-	entry->bo->vm_bo = NULL;
-	list_del(&entry->vm_status);
-	amdgpu_bo_unref(&shadow);
-	amdgpu_bo_unref(&entry->bo);
+	if (entry->base.bo) {
+		entry->base.bo->vm_bo = NULL;
+		list_del(&entry->base.vm_status);
+		amdgpu_bo_unref(&entry->base.bo->shadow);
+		amdgpu_bo_unref(&entry->base.bo);
+	}
+	kvfree(entry->entries);
+	entry->entries = NULL;
 }
 
 /**
@@ -1064,7 +968,7 @@ static void amdgpu_vm_free_pts(struct amdgpu_device *adev,
 			       struct amdgpu_vm_pt_cursor *start)
 {
 	struct amdgpu_vm_pt_cursor cursor;
-	struct amdgpu_vm_bo_base *entry;
+	struct amdgpu_vm_pt *entry;
 
 	vm->bulk_moveable = false;
 
@@ -1332,10 +1236,10 @@ uint64_t amdgpu_vm_map_gart(const dma_addr_t *pages_addr, uint64_t addr)
  */
 static int amdgpu_vm_update_pde(struct amdgpu_vm_update_params *params,
 				struct amdgpu_vm *vm,
-				struct amdgpu_vm_bo_base *entry)
+				struct amdgpu_vm_pt *entry)
 {
-	struct amdgpu_vm_bo_base *parent = amdgpu_vm_pt_parent(entry);
-	struct amdgpu_bo *bo = parent->bo, *pbo;
+	struct amdgpu_vm_pt *parent = amdgpu_vm_pt_parent(entry);
+	struct amdgpu_bo *bo = parent->base.bo, *pbo;
 	uint64_t pde, pt, flags;
 	unsigned level;
 
@@ -1343,10 +1247,9 @@ static int amdgpu_vm_update_pde(struct amdgpu_vm_update_params *params,
 		pbo = pbo->parent;
 
 	level += params->adev->vm_manager.root_level;
-	amdgpu_gmc_get_pde_for_bo(entry->bo, level, &pt, &flags);
-	pde = (entry - to_amdgpu_bo_vm(parent->bo)->entries) * 8;
-	return vm->update_funcs->update(params, to_amdgpu_bo_vm(bo), pde, pt,
-					1, 0, flags);
+	amdgpu_gmc_get_pde_for_bo(entry->base.bo, level, &pt, &flags);
+	pde = (entry - parent->entries) * 8;
+	return vm->update_funcs->update(params, bo, pde, pt, 1, 0, flags);
 }
 
 /**
@@ -1361,11 +1264,11 @@ static void amdgpu_vm_invalidate_pds(struct amdgpu_device *adev,
 				     struct amdgpu_vm *vm)
 {
 	struct amdgpu_vm_pt_cursor cursor;
-	struct amdgpu_vm_bo_base *entry;
+	struct amdgpu_vm_pt *entry;
 
 	for_each_amdgpu_vm_pt_dfs_safe(adev, vm, NULL, cursor, entry)
-		if (entry->bo && !entry->moved)
-			amdgpu_vm_bo_relocated(entry);
+		if (entry->base.bo && !entry->base.moved)
+			amdgpu_vm_bo_relocated(&entry->base);
 }
 
 /**
@@ -1373,7 +1276,7 @@ static void amdgpu_vm_invalidate_pds(struct amdgpu_device *adev,
  *
  * @adev: amdgpu_device pointer
  * @vm: requested vm
- * @immediate: submit immediately to the paging queue
+ * @direct: submit directly to the paging queue
  *
  * Makes sure all directories are up to date.
  *
@@ -1381,7 +1284,7 @@ static void amdgpu_vm_invalidate_pds(struct amdgpu_device *adev,
  * 0 for success, error for failure.
  */
 int amdgpu_vm_update_pdes(struct amdgpu_device *adev,
-			  struct amdgpu_vm *vm, bool immediate)
+			  struct amdgpu_vm *vm, bool direct)
 {
 	struct amdgpu_vm_update_params params;
 	int r;
@@ -1392,19 +1295,18 @@ int amdgpu_vm_update_pdes(struct amdgpu_device *adev,
 	memset(&params, 0, sizeof(params));
 	params.adev = adev;
 	params.vm = vm;
-	params.immediate = immediate;
+	params.direct = direct;
 
 	r = vm->update_funcs->prepare(&params, NULL, AMDGPU_SYNC_EXPLICIT);
 	if (r)
 		return r;
 
 	while (!list_empty(&vm->relocated)) {
-		struct amdgpu_vm_bo_base *entry;
+		struct amdgpu_vm_pt *entry;
 
-		entry = list_first_entry(&vm->relocated,
-					 struct amdgpu_vm_bo_base,
-					 vm_status);
-		amdgpu_vm_bo_idle(entry);
+		entry = list_first_entry(&vm->relocated, struct amdgpu_vm_pt,
+					 base.vm_status);
+		amdgpu_vm_bo_idle(&entry->base);
 
 		r = amdgpu_vm_update_pde(&params, vm, entry);
 		if (r)
@@ -1427,9 +1329,9 @@ int amdgpu_vm_update_pdes(struct amdgpu_device *adev,
  * Make sure to set the right flags for the PTEs at the desired level.
  */
 static void amdgpu_vm_update_flags(struct amdgpu_vm_update_params *params,
-				   struct amdgpu_bo_vm *pt, unsigned int level,
+				   struct amdgpu_bo *bo, unsigned level,
 				   uint64_t pe, uint64_t addr,
-				   unsigned int count, uint32_t incr,
+				   unsigned count, uint32_t incr,
 				   uint64_t flags)
 
 {
@@ -1445,7 +1347,7 @@ static void amdgpu_vm_update_flags(struct amdgpu_vm_update_params *params,
 		flags |= AMDGPU_PTE_EXECUTABLE;
 	}
 
-	params->vm->update_funcs->update(params, pt, pe, addr, count, incr,
+	params->vm->update_funcs->update(params, bo, pe, addr, count, incr,
 					 flags);
 }
 
@@ -1544,24 +1446,20 @@ static int amdgpu_vm_update_ptes(struct amdgpu_vm_update_params *params,
 		uint64_t incr, entry_end, pe_start;
 		struct amdgpu_bo *pt;
 
-		if (!params->unlocked) {
+		if (flags & (AMDGPU_PTE_VALID | AMDGPU_PTE_PRT)) {
 			/* make sure that the page tables covering the
 			 * address range are actually allocated
 			 */
 			r = amdgpu_vm_alloc_pts(params->adev, params->vm,
-						&cursor, params->immediate);
+						&cursor, params->direct);
 			if (r)
 				return r;
 		}
 
 		shift = amdgpu_vm_level_shift(adev, cursor.level);
 		parent_shift = amdgpu_vm_level_shift(adev, cursor.level - 1);
-		if (params->unlocked) {
-			/* Unlocked updates are only allowed on the leaves */
-			if (amdgpu_vm_pt_descendant(adev, &cursor))
-				continue;
-		} else if (adev->asic_type < CHIP_VEGA10 &&
-			   (flags & AMDGPU_PTE_VALID)) {
+		if (adev->asic_type < CHIP_VEGA10 &&
+		    (flags & AMDGPU_PTE_VALID)) {
 			/* No huge page support before GMC v9 */
 			if (cursor.level != AMDGPU_VM_PTB) {
 				if (!amdgpu_vm_pt_descendant(adev, &cursor))
@@ -1584,7 +1482,7 @@ static int amdgpu_vm_update_ptes(struct amdgpu_vm_update_params *params,
 			continue;
 		}
 
-		pt = cursor.entry->bo;
+		pt = cursor.entry->base.bo;
 		if (!pt) {
 			/* We need all PDs and PTs for mapping something, */
 			if (flags & AMDGPU_PTE_VALID)
@@ -1596,10 +1494,8 @@ static int amdgpu_vm_update_ptes(struct amdgpu_vm_update_params *params,
 			if (!amdgpu_vm_pt_ancestor(&cursor))
 				return -EINVAL;
 
-			pt = cursor.entry->bo;
+			pt = cursor.entry->base.bo;
 			shift = parent_shift;
-			frag_end = max(frag_end, ALIGN(frag_start + 1,
-				   1ULL << shift));
 		}
 
 		/* Looks good so far, calculate parameters for the update */
@@ -1611,26 +1507,19 @@ static int amdgpu_vm_update_ptes(struct amdgpu_vm_update_params *params,
 		entry_end = min(entry_end, end);
 
 		do {
-			struct amdgpu_vm *vm = params->vm;
 			uint64_t upd_end = min(entry_end, frag_end);
 			unsigned nptes = (upd_end - frag_start) >> shift;
-			uint64_t upd_flags = flags | AMDGPU_PTE_FRAG(frag);
 
 			/* This can happen when we set higher level PDs to
 			 * silent to stop fault floods.
 			 */
 			nptes = max(nptes, 1u);
-
-			trace_amdgpu_vm_update_ptes(params, frag_start, upd_end,
-						    nptes, dst, incr, upd_flags,
-						    vm->task_info.pid,
-						    vm->immediate.fence_context);
-			amdgpu_vm_update_flags(params, to_amdgpu_bo_vm(pt),
-					       cursor.level, pe_start, dst,
-					       nptes, incr, upd_flags);
+			amdgpu_vm_update_flags(params, pt, cursor.level,
+					       pe_start, dst, nptes, incr,
+					       flags | AMDGPU_PTE_FRAG(frag));
 
 			pe_start += nptes * 8;
-			dst += nptes * incr;
+			dst += (uint64_t)nptes * AMDGPU_GPU_PAGE_SIZE << shift;
 
 			frag_start = upd_end;
 			if (frag_start >= frag_end) {
@@ -1650,11 +1539,7 @@ static int amdgpu_vm_update_ptes(struct amdgpu_vm_update_params *params,
 			 * completely covered by the range and so potentially still in use.
 			 */
 			while (cursor.pfn < frag_start) {
-				/* Make sure previous mapping is freed */
-				if (cursor.entry->bo) {
-					params->table_freed = true;
-					amdgpu_vm_free_pts(adev, params->vm, &cursor);
-				}
+				amdgpu_vm_free_pts(adev, params->vm, &cursor);
 				amdgpu_vm_pt_next(adev, &cursor);
 			}
 
@@ -1670,51 +1555,39 @@ static int amdgpu_vm_update_ptes(struct amdgpu_vm_update_params *params,
 /**
  * amdgpu_vm_bo_update_mapping - update a mapping in the vm page table
  *
- * @adev: amdgpu_device pointer of the VM
- * @bo_adev: amdgpu_device pointer of the mapped BO
+ * @adev: amdgpu_device pointer
  * @vm: requested vm
- * @immediate: immediate submission in a page fault
- * @unlocked: unlocked invalidation during MM callback
+ * @direct: direct submission in a page fault
  * @resv: fences we need to sync to
  * @start: start of mapped range
  * @last: last mapped entry
  * @flags: flags for the entries
- * @offset: offset into nodes and pages_addr
- * @res: ttm_resource to map
+ * @addr: addr to set the area to
  * @pages_addr: DMA addresses to use for mapping
  * @fence: optional resulting fence
- * @table_freed: return true if page table is freed
  *
  * Fill in the page table entries between @start and @last.
  *
  * Returns:
  * 0 for success, -EINVAL for failure.
  */
-int amdgpu_vm_bo_update_mapping(struct amdgpu_device *adev,
-				struct amdgpu_device *bo_adev,
-				struct amdgpu_vm *vm, bool immediate,
-				bool unlocked, struct dma_resv *resv,
-				uint64_t start, uint64_t last,
-				uint64_t flags, uint64_t offset,
-				struct ttm_resource *res,
-				dma_addr_t *pages_addr,
-				struct dma_fence **fence,
-				bool *table_freed)
+static int amdgpu_vm_bo_update_mapping(struct amdgpu_device *adev,
+				       struct amdgpu_vm *vm, bool direct,
+				       struct dma_resv *resv,
+				       uint64_t start, uint64_t last,
+				       uint64_t flags, uint64_t addr,
+				       dma_addr_t *pages_addr,
+				       struct dma_fence **fence)
 {
 	struct amdgpu_vm_update_params params;
-	struct amdgpu_res_cursor cursor;
 	enum amdgpu_sync_mode sync_mode;
-	int r, idx;
-
-	if (!drm_dev_enter(&adev->ddev, &idx))
-		return -ENODEV;
+	int r;
 
 	memset(&params, 0, sizeof(params));
 	params.adev = adev;
 	params.vm = vm;
-	params.immediate = immediate;
+	params.direct = direct;
 	params.pages_addr = pages_addr;
-	params.unlocked = unlocked;
 
 	/* Implicitly sync to command submissions in the same VM before
 	 * unmapping. Sync to moving fences before mapping.
@@ -1730,133 +1603,178 @@ int amdgpu_vm_bo_update_mapping(struct amdgpu_device *adev,
 		goto error_unlock;
 	}
 
-	if (!unlocked && !dma_fence_is_signaled(vm->last_unlocked)) {
-		struct dma_fence *tmp = dma_fence_get_stub();
+	if (flags & (AMDGPU_PTE_VALID | AMDGPU_PTE_PRT)) {
+		struct amdgpu_bo *root = vm->root.base.bo;
 
-		amdgpu_bo_fence(vm->root.bo, vm->last_unlocked, true);
-		swap(vm->last_unlocked, tmp);
-		dma_fence_put(tmp);
+		if (!dma_fence_is_signaled(vm->last_direct))
+			amdgpu_bo_fence(root, vm->last_direct, true);
 	}
 
 	r = vm->update_funcs->prepare(&params, resv, sync_mode);
 	if (r)
 		goto error_unlock;
 
-	amdgpu_res_first(pages_addr ? NULL : res, offset,
-			 (last - start + 1) * AMDGPU_GPU_PAGE_SIZE, &cursor);
-	while (cursor.remaining) {
-		uint64_t tmp, num_entries, addr;
+	r = amdgpu_vm_update_ptes(&params, start, last + 1, addr, flags);
+	if (r)
+		goto error_unlock;
+
+	r = vm->update_funcs->commit(&params, fence);
+
+error_unlock:
+	amdgpu_vm_eviction_unlock(vm);
+	return r;
+}
 
-		num_entries = cursor.size >> AMDGPU_GPU_PAGE_SHIFT;
-		if (pages_addr) {
-			bool contiguous = true;
+/**
+ * amdgpu_vm_bo_split_mapping - split a mapping into smaller chunks
+ *
+ * @adev: amdgpu_device pointer
+ * @resv: fences we need to sync to
+ * @pages_addr: DMA addresses to use for mapping
+ * @vm: requested vm
+ * @mapping: mapped range and flags to use for the update
+ * @flags: HW flags for the mapping
+ * @bo_adev: amdgpu_device pointer that bo actually been allocated
+ * @nodes: array of drm_mm_nodes with the MC addresses
+ * @fence: optional resulting fence
+ *
+ * Split the mapping into smaller chunks so that each update fits
+ * into a SDMA IB.
+ *
+ * Returns:
+ * 0 for success, -EINVAL for failure.
+ */
+static int amdgpu_vm_bo_split_mapping(struct amdgpu_device *adev,
+				      struct dma_resv *resv,
+				      dma_addr_t *pages_addr,
+				      struct amdgpu_vm *vm,
+				      struct amdgpu_bo_va_mapping *mapping,
+				      uint64_t flags,
+				      struct amdgpu_device *bo_adev,
+				      struct ttm_mem_reg *mem,
+				      struct dma_fence **fence)
+{
+	struct drm_mm_node *nodes = mem ? mem->mm_node : NULL;
+	uint64_t vram_base_offset = bo_adev->vm_manager.vram_base_offset;
+	unsigned min_linear_pages = 1 << adev->vm_manager.fragment_size;
+	uint64_t pfn, start = mapping->start;
+	int r;
 
-			if (num_entries > AMDGPU_GPU_PAGES_IN_CPU_PAGE) {
-				uint64_t pfn = cursor.start >> PAGE_SHIFT;
-				uint64_t count;
+	/* normally,bo_va->flags only contians READABLE and WIRTEABLE bit go here
+	 * but in case of something, we filter the flags in first place
+	 */
+	if (!(mapping->flags & AMDGPU_PTE_READABLE))
+		flags &= ~AMDGPU_PTE_READABLE;
+	if (!(mapping->flags & AMDGPU_PTE_WRITEABLE))
+		flags &= ~AMDGPU_PTE_WRITEABLE;
+
+	/* Apply ASIC specific mapping flags */
+	amdgpu_gmc_get_vm_pte(adev, mapping, &flags);
+
+	if (adev != bo_adev &&
+	    !(flags & AMDGPU_PTE_SYSTEM) &&
+	    !mapping->bo_va->is_xgmi) {
+		if (amdgpu_device_is_peer_accessible(bo_adev, adev)) {
+			flags |= AMDGPU_PTE_SYSTEM;
+			vram_base_offset = bo_adev->gmc.aper_base;
+		} else {
+			DRM_DEBUG_DRIVER("Failed to map the VRAM for peer device access.\n");
+			return -EINVAL;
+		}
+	}
 
-				contiguous = pages_addr[pfn + 1] ==
-					pages_addr[pfn] + PAGE_SIZE;
+	trace_amdgpu_vm_bo_update(mapping);
 
-				tmp = num_entries /
-					AMDGPU_GPU_PAGES_IN_CPU_PAGE;
-				for (count = 2; count < tmp; ++count) {
-					uint64_t idx = pfn + count;
+	pfn = mapping->offset >> PAGE_SHIFT;
+	if (nodes) {
+		while (pfn >= nodes->size) {
+			pfn -= nodes->size;
+			++nodes;
+		}
+	}
 
-					if (contiguous != (pages_addr[idx] ==
-					    pages_addr[idx - 1] + PAGE_SIZE))
+	do {
+		dma_addr_t *dma_addr = NULL;
+		uint64_t max_entries;
+		uint64_t addr, last;
+		uint64_t count;
+
+		if (nodes) {
+			addr = nodes->start << PAGE_SHIFT;
+			max_entries = (nodes->size - pfn) *
+				AMDGPU_GPU_PAGES_IN_CPU_PAGE;
+
+			switch (mem->mem_type) {
+			case TTM_PL_TT:
+				if (pages_addr) {
+					for (count = 1;
+						 count < max_entries / AMDGPU_GPU_PAGES_IN_CPU_PAGE;
+						 ++count){
+						uint64_t idx = pfn + count;
+						if (pages_addr[idx] !=
+							(pages_addr[idx - 1] + PAGE_SIZE))
 						break;
+						}
+					if (count < min_linear_pages) {
+						addr = pfn << PAGE_SHIFT;
+						dma_addr = pages_addr;
+					} else {
+						addr = pages_addr[pfn];
+						max_entries = count;
+					}
+				} else if (flags & (AMDGPU_PTE_VALID | AMDGPU_PTE_PRT)) {
+					addr += vram_base_offset;
+					addr += pfn << PAGE_SHIFT;
 				}
-				num_entries = count *
-					AMDGPU_GPU_PAGES_IN_CPU_PAGE;
-			}
-
-			if (!contiguous) {
-				addr = cursor.start;
-				params.pages_addr = pages_addr;
-			} else {
-				addr = pages_addr[cursor.start >> PAGE_SHIFT];
-				params.pages_addr = NULL;
+				break;
+			case AMDGPU_PL_DGMA_IMPORT:
+			case AMDGPU_PL_DGMA_PEER:
+				addr = 0;
+				dma_addr = pages_addr;
+				break;
+			case AMDGPU_PL_DGMA:
+				addr += vram_base_offset +
+					adev->mman.bdev.man[mem->mem_type].gpu_offset -
+					adev->mman.bdev.man[TTM_PL_VRAM].gpu_offset;
+				addr += pfn << PAGE_SHIFT;
+				break;
+			case TTM_PL_VRAM:
+				addr += vram_base_offset;
+				addr += pfn << PAGE_SHIFT;
+				break;
+			default:
+				break;
 			}
-
-		} else if (flags & (AMDGPU_PTE_VALID | AMDGPU_PTE_PRT)) {
-			addr = bo_adev->vm_manager.vram_base_offset +
-				cursor.start;
 		} else {
 			addr = 0;
+			max_entries = S64_MAX;
 		}
 
-		tmp = start + num_entries;
-		r = amdgpu_vm_update_ptes(&params, start, tmp, addr, flags);
+		last = min((uint64_t)mapping->last, start + max_entries - 1);
+		r = amdgpu_vm_bo_update_mapping(adev, vm, false, resv,
+						start, last, flags, addr,
+						dma_addr, fence);
 		if (r)
-			goto error_unlock;
-
-		amdgpu_res_next(&cursor, num_entries * AMDGPU_GPU_PAGE_SIZE);
-		start = tmp;
-	}
+			return r;
 
-	r = vm->update_funcs->commit(&params, fence);
+		pfn += (last - start + 1) / AMDGPU_GPU_PAGES_IN_CPU_PAGE;
+		if (nodes && nodes->size == pfn) {
+			pfn = 0;
+			++nodes;
+		}
+		start = last + 1;
 
-	if (table_freed)
-		*table_freed = *table_freed || params.table_freed;
+	} while (unlikely(start != mapping->last + 1));
 
-error_unlock:
-	amdgpu_vm_eviction_unlock(vm);
-	drm_dev_exit(idx);
-	return r;
+	return 0;
 }
 
-void amdgpu_vm_get_memory(struct amdgpu_vm *vm, uint64_t *vram_mem,
-				uint64_t *gtt_mem, uint64_t *cpu_mem)
-{
-	struct amdgpu_bo_va *bo_va, *tmp;
-
-	list_for_each_entry_safe(bo_va, tmp, &vm->idle, base.vm_status) {
-		if (!bo_va->base.bo)
-			continue;
-		amdgpu_bo_get_memory(bo_va->base.bo, vram_mem,
-				gtt_mem, cpu_mem);
-	}
-	list_for_each_entry_safe(bo_va, tmp, &vm->evicted, base.vm_status) {
-		if (!bo_va->base.bo)
-			continue;
-		amdgpu_bo_get_memory(bo_va->base.bo, vram_mem,
-				gtt_mem, cpu_mem);
-	}
-	list_for_each_entry_safe(bo_va, tmp, &vm->relocated, base.vm_status) {
-		if (!bo_va->base.bo)
-			continue;
-		amdgpu_bo_get_memory(bo_va->base.bo, vram_mem,
-				gtt_mem, cpu_mem);
-	}
-	list_for_each_entry_safe(bo_va, tmp, &vm->moved, base.vm_status) {
-		if (!bo_va->base.bo)
-			continue;
-		amdgpu_bo_get_memory(bo_va->base.bo, vram_mem,
-				gtt_mem, cpu_mem);
-	}
-	spin_lock(&vm->invalidated_lock);
-	list_for_each_entry_safe(bo_va, tmp, &vm->invalidated, base.vm_status) {
-		if (!bo_va->base.bo)
-			continue;
-		amdgpu_bo_get_memory(bo_va->base.bo, vram_mem,
-				gtt_mem, cpu_mem);
-	}
-	list_for_each_entry_safe(bo_va, tmp, &vm->done, base.vm_status) {
-		if (!bo_va->base.bo)
-			continue;
-		amdgpu_bo_get_memory(bo_va->base.bo, vram_mem,
-				gtt_mem, cpu_mem);
-	}
-	spin_unlock(&vm->invalidated_lock);
-}
 /**
  * amdgpu_vm_bo_update - update all BO mappings in the vm page table
  *
  * @adev: amdgpu_device pointer
  * @bo_va: requested BO and VM object
  * @clear: if true clear the entries
- * @table_freed: return true if page table is freed
  *
  * Fill in the page table entries for @bo_va.
  *
@@ -1864,13 +1782,14 @@ void amdgpu_vm_get_memory(struct amdgpu_vm *vm, uint64_t *vram_mem,
  * 0 for success, -EINVAL for failure.
  */
 int amdgpu_vm_bo_update(struct amdgpu_device *adev, struct amdgpu_bo_va *bo_va,
-			bool clear, bool *table_freed)
+			bool clear)
 {
 	struct amdgpu_bo *bo = bo_va->base.bo;
 	struct amdgpu_vm *vm = bo_va->base.vm;
 	struct amdgpu_bo_va_mapping *mapping;
 	dma_addr_t *pages_addr = NULL;
-	struct ttm_resource *mem;
+	struct ttm_mem_reg *mem;
+	struct drm_mm_node *nodes;
 	struct dma_fence **last_update;
 	struct dma_resv *resv;
 	uint64_t flags;
@@ -1879,23 +1798,21 @@ int amdgpu_vm_bo_update(struct amdgpu_device *adev, struct amdgpu_bo_va *bo_va,
 
 	if (clear || !bo) {
 		mem = NULL;
-		resv = vm->root.bo->tbo.base.resv;
+		nodes = NULL;
+		resv = amdkcl_ttm_resvp(&vm->root.base.bo->tbo);
 	} else {
-		struct drm_gem_object *obj = &bo->tbo.base;
-
-		resv = bo->tbo.base.resv;
-		if (obj->import_attach && bo_va->is_xgmi) {
-			struct dma_buf *dma_buf = obj->import_attach->dmabuf;
-			struct drm_gem_object *gobj = dma_buf->priv;
-			struct amdgpu_bo *abo = gem_to_amdgpu_bo(gobj);
-
-			if (abo->tbo.resource->mem_type == TTM_PL_VRAM)
-				bo = gem_to_amdgpu_bo(gobj);
+		struct ttm_dma_tt *ttm;
+
+		mem = &bo->tbo.mem;
+		nodes = mem->mm_node;
+		if (mem->mem_type == TTM_PL_TT) {
+			ttm = container_of(bo->tbo.ttm, struct ttm_dma_tt, ttm);
+			pages_addr = ttm->dma_address;
+		} else if (mem->mem_type == AMDGPU_PL_DGMA_IMPORT ||
+			   mem->mem_type == AMDGPU_PL_DGMA_PEER) {
+			pages_addr = (dma_addr_t *)bo_va->base.bo->tbo.mem.bus.addr;
 		}
-		mem = bo->tbo.resource;
-		if (mem->mem_type == TTM_PL_TT ||
-		    mem->mem_type == AMDGPU_PL_PREEMPT)
-			pages_addr = bo->tbo.ttm->dma_address;
+		resv = amdkcl_ttm_resvp(&bo->tbo);
 	}
 
 	if (bo) {
@@ -1909,8 +1826,7 @@ int amdgpu_vm_bo_update(struct amdgpu_device *adev, struct amdgpu_bo_va *bo_va,
 		flags = 0x0;
 	}
 
-	if (clear || (bo && bo->tbo.base.resv ==
-		      vm->root.bo->tbo.base.resv))
+	if (clear || (bo && amdkcl_ttm_resvp(&bo->tbo) == amdkcl_ttm_resvp(&vm->root.base.bo->tbo)))
 		last_update = &vm->last_update;
 	else
 		last_update = &bo_va->last_pt_update;
@@ -1924,26 +1840,9 @@ int amdgpu_vm_bo_update(struct amdgpu_device *adev, struct amdgpu_bo_va *bo_va,
 	}
 
 	list_for_each_entry(mapping, &bo_va->invalids, list) {
-		uint64_t update_flags = flags;
-
-		/* normally,bo_va->flags only contians READABLE and WIRTEABLE bit go here
-		 * but in case of something, we filter the flags in first place
-		 */
-		if (!(mapping->flags & AMDGPU_PTE_READABLE))
-			update_flags &= ~AMDGPU_PTE_READABLE;
-		if (!(mapping->flags & AMDGPU_PTE_WRITEABLE))
-			update_flags &= ~AMDGPU_PTE_WRITEABLE;
-
-		/* Apply ASIC specific mapping flags */
-		amdgpu_gmc_get_vm_pte(adev, mapping, &update_flags);
-
-		trace_amdgpu_vm_bo_update(mapping);
-
-		r = amdgpu_vm_bo_update_mapping(adev, bo_adev, vm, false, false,
-						resv, mapping->start,
-						mapping->last, update_flags,
-						mapping->offset, mem,
-						pages_addr, last_update, table_freed);
+		r = amdgpu_vm_bo_split_mapping(adev, resv, pages_addr, vm,
+					       mapping, flags, bo_adev,
+					       mem, last_update);
 		if (r)
 			return r;
 	}
@@ -1952,8 +1851,8 @@ int amdgpu_vm_bo_update(struct amdgpu_device *adev, struct amdgpu_bo_va *bo_va,
 	 * the evicted list so that it gets validated again on the
 	 * next command submission.
 	 */
-	if (bo && bo->tbo.base.resv == vm->root.bo->tbo.base.resv) {
-		uint32_t mem_type = bo->tbo.resource->mem_type;
+	if (bo && amdkcl_ttm_resvp(&bo->tbo) == amdkcl_ttm_resvp(&vm->root.base.bo->tbo)) {
+		uint32_t mem_type = bo->tbo.mem.mem_type;
 
 		if (!(bo->preferred_domains &
 		      amdgpu_mem_type_to_domain(mem_type)))
@@ -2089,17 +1988,18 @@ static void amdgpu_vm_free_mapping(struct amdgpu_device *adev,
  */
 static void amdgpu_vm_prt_fini(struct amdgpu_device *adev, struct amdgpu_vm *vm)
 {
-	struct dma_resv *resv = vm->root.bo->tbo.base.resv;
+	struct dma_resv *resv = amdkcl_ttm_resvp(&vm->root.base.bo->tbo);
 	struct dma_fence *excl, **shared;
 	unsigned i, shared_count;
 	int r;
 
-	r = dma_resv_get_fences(resv, &excl, &shared_count, &shared);
+	r = dma_resv_get_fences_rcu(resv, &excl,
+					      &shared_count, &shared);
 	if (r) {
 		/* Not enough memory to grab the fence list, as last resort
 		 * block for all the fences to complete.
 		 */
-		dma_resv_wait_timeout(resv, true, false,
+		dma_resv_wait_timeout_rcu(resv, true, false,
 						    MAX_SCHEDULE_TIMEOUT);
 		return;
 	}
@@ -2135,7 +2035,7 @@ int amdgpu_vm_clear_freed(struct amdgpu_device *adev,
 			  struct amdgpu_vm *vm,
 			  struct dma_fence **fence)
 {
-	struct dma_resv *resv = vm->root.bo->tbo.base.resv;
+	struct dma_resv *resv = amdkcl_ttm_resvp(&vm->root.base.bo->tbo);
 	struct amdgpu_bo_va_mapping *mapping;
 	uint64_t init_pte_value = 0;
 	struct dma_fence *f = NULL;
@@ -2150,10 +2050,9 @@ int amdgpu_vm_clear_freed(struct amdgpu_device *adev,
 		    mapping->start < AMDGPU_GMC_HOLE_START)
 			init_pte_value = AMDGPU_PTE_DEFAULT_ATC;
 
-		r = amdgpu_vm_bo_update_mapping(adev, adev, vm, false, false,
-						resv, mapping->start,
-						mapping->last, init_pte_value,
-						0, NULL, NULL, &f, NULL);
+		r = amdgpu_vm_bo_update_mapping(adev, vm, false, resv,
+						mapping->start, mapping->last,
+						init_pte_value, 0, NULL, &f);
 		amdgpu_vm_free_mapping(adev, vm, mapping, f);
 		if (r) {
 			dma_fence_put(f);
@@ -2172,6 +2071,58 @@ int amdgpu_vm_clear_freed(struct amdgpu_device *adev,
 
 }
 
+void amdgpu_vm_get_memory(struct amdgpu_vm *vm, uint64_t *vram_mem,
+				uint64_t *gtt_mem, uint64_t *cpu_mem)
+{
+	struct amdgpu_bo_va *bo_va, *tmp;
+
+	list_for_each_entry_safe(bo_va, tmp, &vm->idle, base.vm_status) {
+		if (!bo_va->base.bo)
+			continue;
+		amdgpu_bo_get_memory(bo_va->base.bo, vram_mem,
+					gtt_mem, cpu_mem);
+	}
+	list_for_each_entry_safe(bo_va, tmp, &vm->evicted, base.vm_status) {
+		if (!bo_va->base.bo)
+			continue;
+		amdgpu_bo_get_memory(bo_va->base.bo, vram_mem,
+					gtt_mem, cpu_mem);
+	}
+	list_for_each_entry_safe(bo_va, tmp, &vm->relocated, base.vm_status) {
+		if (!bo_va->base.bo)
+			continue;
+		amdgpu_bo_get_memory(bo_va->base.bo, vram_mem,
+					gtt_mem, cpu_mem);
+	}
+	list_for_each_entry_safe(bo_va, tmp, &vm->moved, base.vm_status) {
+		if (!bo_va->base.bo)
+			continue;
+		amdgpu_bo_get_memory(bo_va->base.bo, vram_mem,
+					gtt_mem, cpu_mem);
+	}
+	spin_lock(&vm->invalidated_lock);
+	list_for_each_entry_safe(bo_va, tmp, &vm->invalidated, base.vm_status) {
+		if (!bo_va->base.bo)
+			continue;
+		amdgpu_bo_get_memory(bo_va->base.bo, vram_mem,
+					gtt_mem, cpu_mem);
+	}
+	list_for_each_entry_safe(bo_va, tmp, &vm->freed, base.vm_status) {
+		if (!bo_va->base.bo)
+			continue;
+		amdgpu_bo_get_memory(bo_va->base.bo, vram_mem,
+					gtt_mem, cpu_mem);
+	}
+	spin_unlock(&vm->invalidated_lock);
+
+	list_for_each_entry_safe(bo_va, tmp, &vm->done, base.vm_status) {
+		if (!bo_va->base.bo)
+			continue;
+		amdgpu_bo_get_memory(bo_va->base.bo, vram_mem,
+					gtt_mem, cpu_mem);
+	}
+}
+
 /**
  * amdgpu_vm_handle_moved - handle moved BOs in the PT
  *
@@ -2195,7 +2146,7 @@ int amdgpu_vm_handle_moved(struct amdgpu_device *adev,
 
 	list_for_each_entry_safe(bo_va, tmp, &vm->moved, base.vm_status) {
 		/* Per VM BOs never need to bo cleared in the page tables */
-		r = amdgpu_vm_bo_update(adev, bo_va, false, NULL);
+		r = amdgpu_vm_bo_update(adev, bo_va, false);
 		if (r)
 			return r;
 	}
@@ -2204,7 +2155,7 @@ int amdgpu_vm_handle_moved(struct amdgpu_device *adev,
 	while (!list_empty(&vm->invalidated)) {
 		bo_va = list_first_entry(&vm->invalidated, struct amdgpu_bo_va,
 					 base.vm_status);
-		resv = bo_va->base.bo->tbo.base.resv;
+		resv = amdkcl_ttm_resvp(&bo_va->base.bo->tbo);
 		spin_unlock(&vm->invalidated_lock);
 
 		/* Try to reserve the BO to avoid clearing its ptes */
@@ -2214,7 +2165,7 @@ int amdgpu_vm_handle_moved(struct amdgpu_device *adev,
 		else
 			clear = true;
 
-		r = amdgpu_vm_bo_update(adev, bo_va, clear, NULL);
+		r = amdgpu_vm_bo_update(adev, bo_va, clear);
 		if (r)
 			return r;
 
@@ -2258,13 +2209,14 @@ struct amdgpu_bo_va *amdgpu_vm_bo_add(struct amdgpu_device *adev,
 	INIT_LIST_HEAD(&bo_va->valids);
 	INIT_LIST_HEAD(&bo_va->invalids);
 
-	if (!bo)
-		return bo_va;
-
-	if (amdgpu_dmabuf_is_xgmi_accessible(adev, bo)) {
+	if (bo && amdgpu_xgmi_same_hive(adev, amdgpu_ttm_adev(bo->tbo.bdev)) &&
+	    (bo->preferred_domains & AMDGPU_GEM_DOMAIN_VRAM)) {
 		bo_va->is_xgmi = true;
+		mutex_lock(&adev->vm_manager.lock_pstate);
 		/* Power up XGMI if it can be potentially used */
-		amdgpu_xgmi_set_pstate(adev, AMDGPU_XGMI_PSTATE_MAX_VEGA20);
+		if (++adev->vm_manager.xgmi_map_counter == 1)
+			amdgpu_xgmi_set_pstate(adev, 1);
+		mutex_unlock(&adev->vm_manager.lock_pstate);
 	}
 
 	return bo_va;
@@ -2272,7 +2224,7 @@ struct amdgpu_bo_va *amdgpu_vm_bo_add(struct amdgpu_device *adev,
 
 
 /**
- * amdgpu_vm_bo_insert_map - insert a new mapping
+ * amdgpu_vm_bo_insert_mapping - insert a new mapping
  *
  * @adev: amdgpu_device pointer
  * @bo_va: bo_va to store the address
@@ -2294,7 +2246,7 @@ static void amdgpu_vm_bo_insert_map(struct amdgpu_device *adev,
 	if (mapping->flags & AMDGPU_PTE_PRT)
 		amdgpu_vm_prt_get(adev);
 
-	if (bo && bo->tbo.base.resv == vm->root.bo->tbo.base.resv &&
+	if (bo && amdkcl_ttm_resvp(&bo->tbo) == amdkcl_ttm_resvp(&vm->root.base.bo->tbo) &&
 	    !bo_va->base.moved) {
 		list_move(&bo_va->base.vm_status, &vm->moved);
 	}
@@ -2329,15 +2281,14 @@ int amdgpu_vm_bo_map(struct amdgpu_device *adev,
 	uint64_t eaddr;
 
 	/* validate the parameters */
-	if (saddr & ~PAGE_MASK || offset & ~PAGE_MASK ||
-	    size == 0 || size & ~PAGE_MASK)
+	if (saddr & AMDGPU_GPU_PAGE_MASK || offset & AMDGPU_GPU_PAGE_MASK ||
+	    size == 0 || size & AMDGPU_GPU_PAGE_MASK)
 		return -EINVAL;
 
 	/* make sure object fit at this offset */
 	eaddr = saddr + size - 1;
 	if (saddr >= eaddr ||
-	    (bo && offset + size > amdgpu_bo_size(bo)) ||
-	    (eaddr >= adev->vm_manager.max_pfn << AMDGPU_GPU_PAGE_SHIFT))
+	    (bo && offset + size > amdgpu_bo_size(bo)))
 		return -EINVAL;
 
 	saddr /= AMDGPU_GPU_PAGE_SIZE;
@@ -2395,15 +2346,14 @@ int amdgpu_vm_bo_replace_map(struct amdgpu_device *adev,
 	int r;
 
 	/* validate the parameters */
-	if (saddr & ~PAGE_MASK || offset & ~PAGE_MASK ||
-	    size == 0 || size & ~PAGE_MASK)
+	if (saddr & AMDGPU_GPU_PAGE_MASK || offset & AMDGPU_GPU_PAGE_MASK ||
+	    size == 0 || size & AMDGPU_GPU_PAGE_MASK)
 		return -EINVAL;
 
 	/* make sure object fit at this offset */
 	eaddr = saddr + size - 1;
 	if (saddr >= eaddr ||
-	    (bo && offset + size > amdgpu_bo_size(bo)) ||
-	    (eaddr >= adev->vm_manager.max_pfn << AMDGPU_GPU_PAGE_SHIFT))
+	    (bo && offset + size > amdgpu_bo_size(bo)))
 		return -EINVAL;
 
 	/* Allocate all the needed memory */
@@ -2541,7 +2491,7 @@ int amdgpu_vm_bo_clear_mappings(struct amdgpu_device *adev,
 			after->start = eaddr + 1;
 			after->last = tmp->last;
 			after->offset = tmp->offset;
-			after->offset += (after->start - tmp->start) << PAGE_SHIFT;
+			after->offset += after->start - tmp->start;
 			after->flags = tmp->flags;
 			after->bo_va = tmp->bo_va;
 			list_add(&after->list, &tmp->bo_va->invalids);
@@ -2628,7 +2578,7 @@ void amdgpu_vm_bo_trace_cs(struct amdgpu_vm *vm, struct ww_acquire_ctx *ticket)
 			struct amdgpu_bo *bo;
 
 			bo = mapping->bo_va->base.bo;
-			if (dma_resv_locking_ctx(bo->tbo.base.resv) !=
+			if (dma_resv_locking_ctx(amdkcl_ttm_resvp(&bo->tbo)) !=
 			    ticket)
 				continue;
 		}
@@ -2656,7 +2606,7 @@ void amdgpu_vm_bo_rmv(struct amdgpu_device *adev,
 	struct amdgpu_vm_bo_base **base;
 
 	if (bo) {
-		if (bo->tbo.base.resv == vm->root.bo->tbo.base.resv)
+		if (amdkcl_ttm_resvp(&bo->tbo) == amdkcl_ttm_resvp(&vm->root.base.bo->tbo))
 			vm->bulk_moveable = false;
 
 		for (base = &bo_va->base.bo->vm_bo; *base;
@@ -2689,8 +2639,12 @@ void amdgpu_vm_bo_rmv(struct amdgpu_device *adev,
 
 	dma_fence_put(bo_va->last_pt_update);
 
-	if (bo && bo_va->is_xgmi)
-		amdgpu_xgmi_set_pstate(adev, AMDGPU_XGMI_PSTATE_MIN);
+	if (bo && bo_va->is_xgmi) {
+		mutex_lock(&adev->vm_manager.lock_pstate);
+		if (--adev->vm_manager.xgmi_map_counter == 0)
+			amdgpu_xgmi_set_pstate(adev, 0);
+		mutex_unlock(&adev->vm_manager.lock_pstate);
+	}
 
 	kfree(bo_va);
 }
@@ -2711,7 +2665,7 @@ bool amdgpu_vm_evictable(struct amdgpu_bo *bo)
 		return true;
 
 	/* Don't evict VM page tables while they are busy */
-	if (!dma_resv_test_signaled(bo->tbo.base.resv, true))
+	if (!dma_resv_test_signaled_rcu(amdkcl_ttm_resvp(&bo->tbo), true))
 		return false;
 
 	/* Try to block ongoing updates */
@@ -2719,7 +2673,7 @@ bool amdgpu_vm_evictable(struct amdgpu_bo *bo)
 		return false;
 
 	/* Don't evict VM page tables while they are updated */
-	if (!dma_fence_is_signaled(bo_base->vm->last_unlocked)) {
+	if (!dma_fence_is_signaled(bo_base->vm->last_direct)) {
 		amdgpu_vm_eviction_unlock(bo_base->vm);
 		return false;
 	}
@@ -2744,13 +2698,13 @@ void amdgpu_vm_bo_invalidate(struct amdgpu_device *adev,
 	struct amdgpu_vm_bo_base *bo_base;
 
 	/* shadow bo doesn't have bo base, its validation needs its parent */
-	if (bo->parent && (amdgpu_bo_shadowed(bo->parent) == bo))
+	if (bo->parent && bo->parent->shadow == bo)
 		bo = bo->parent;
 
 	for (bo_base = bo->vm_bo; bo_base; bo_base = bo_base->next) {
 		struct amdgpu_vm *vm = bo_base->vm;
 
-		if (evicted && bo->tbo.base.resv == vm->root.bo->tbo.base.resv) {
+		if (evicted && amdkcl_ttm_resvp(&bo->tbo) == amdkcl_ttm_resvp(&vm->root.base.bo->tbo)) {
 			amdgpu_vm_bo_evicted(bo_base);
 			continue;
 		}
@@ -2761,7 +2715,7 @@ void amdgpu_vm_bo_invalidate(struct amdgpu_device *adev,
 
 		if (bo->tbo.type == ttm_bo_type_kernel)
 			amdgpu_vm_bo_relocated(bo_base);
-		else if (bo->tbo.base.resv == vm->root.bo->tbo.base.resv)
+		else if (amdkcl_ttm_resvp(&bo->tbo) == amdkcl_ttm_resvp(&vm->root.base.bo->tbo))
 			amdgpu_vm_bo_moved(bo_base);
 		else
 			amdgpu_vm_bo_invalidated(bo_base);
@@ -2891,12 +2845,12 @@ void amdgpu_vm_adjust_size(struct amdgpu_device *adev, uint32_t min_vm_size,
  */
 long amdgpu_vm_wait_idle(struct amdgpu_vm *vm, long timeout)
 {
-	timeout = dma_resv_wait_timeout(vm->root.bo->tbo.base.resv, true,
-					true, timeout);
+	timeout = dma_resv_wait_timeout_rcu(amdkcl_ttm_resvp(&vm->root.base.bo->tbo),
+						   true, true, timeout);
 	if (timeout <= 0)
 		return timeout;
 
-	return dma_fence_wait_timeout(vm->last_unlocked, true, timeout);
+	return dma_fence_wait_timeout(vm->last_direct, true, timeout);
 }
 
 /**
@@ -2904,19 +2858,26 @@ long amdgpu_vm_wait_idle(struct amdgpu_vm *vm, long timeout)
  *
  * @adev: amdgpu_device pointer
  * @vm: requested vm
+ * @vm_context: Indicates if it GFX or Compute context
+ * @pasid: Process address space identifier
  *
  * Init @vm fields.
  *
  * Returns:
  * 0 for success, error for failure.
  */
-int amdgpu_vm_init(struct amdgpu_device *adev, struct amdgpu_vm *vm)
+int amdgpu_vm_init(struct amdgpu_device *adev, struct amdgpu_vm *vm,
+		   int vm_context, unsigned int pasid)
 {
-	struct amdgpu_bo *root_bo;
-	struct amdgpu_bo_vm *root;
+	struct amdgpu_bo_param bp;
+	struct amdgpu_bo *root;
 	int r, i;
 
+#ifndef HAVE_TREE_INSERT_HAVE_RB_ROOT_CACHED
+	vm->va = RB_ROOT;
+#else
 	vm->va = RB_ROOT_CACHED;
+#endif
 	for (i = 0; i < AMDGPU_MAX_VMHUBS; i++)
 		vm->reserved_vmid[i] = NULL;
 	INIT_LIST_HEAD(&vm->evicted);
@@ -2929,7 +2890,7 @@ int amdgpu_vm_init(struct amdgpu_device *adev, struct amdgpu_vm *vm)
 	INIT_LIST_HEAD(&vm->done);
 
 	/* create scheduler entities for page table updates */
-	r = drm_sched_entity_init(&vm->immediate, DRM_SCHED_PRIORITY_NORMAL,
+	r = drm_sched_entity_init(&vm->direct, DRM_SCHED_PRIORITY_NORMAL,
 				  adev->vm_manager.vm_pte_scheds,
 				  adev->vm_manager.vm_pte_num_scheds, NULL);
 	if (r)
@@ -2939,14 +2900,21 @@ int amdgpu_vm_init(struct amdgpu_device *adev, struct amdgpu_vm *vm)
 				  adev->vm_manager.vm_pte_scheds,
 				  adev->vm_manager.vm_pte_num_scheds, NULL);
 	if (r)
-		goto error_free_immediate;
+		goto error_free_direct;
 
 	vm->pte_support_ats = false;
 	vm->is_compute_context = false;
 
-	vm->use_cpu_for_update = !!(adev->vm_manager.vm_update_mode &
-				    AMDGPU_VM_USE_CPU_FOR_GFX);
+	if (vm_context == AMDGPU_VM_CONTEXT_COMPUTE) {
+		vm->use_cpu_for_update = !!(adev->vm_manager.vm_update_mode &
+						AMDGPU_VM_USE_CPU_FOR_COMPUTE);
 
+		if (adev->asic_type == CHIP_RAVEN)
+			vm->pte_support_ats = true;
+	} else {
+		vm->use_cpu_for_update = !!(adev->vm_manager.vm_update_mode &
+						AMDGPU_VM_USE_CPU_FOR_GFX);
+	}
 	DRM_DEBUG_DRIVER("VM update mode is %s\n",
 			 vm->use_cpu_for_update ? "CPU" : "SDMA");
 	WARN_ONCE((vm->use_cpu_for_update &&
@@ -2958,50 +2926,65 @@ int amdgpu_vm_init(struct amdgpu_device *adev, struct amdgpu_vm *vm)
 	else
 		vm->update_funcs = &amdgpu_vm_sdma_funcs;
 	vm->last_update = NULL;
-	vm->last_unlocked = dma_fence_get_stub();
+	vm->last_direct = dma_fence_get_stub();
 
 	mutex_init(&vm->eviction_lock);
 	vm->evicting = false;
 
-	r = amdgpu_vm_pt_create(adev, vm, adev->vm_manager.root_level,
-				false, &root);
+	amdgpu_vm_bo_param(adev, vm, adev->vm_manager.root_level, false, &bp);
+	if (vm_context == AMDGPU_VM_CONTEXT_COMPUTE)
+		bp.flags &= ~AMDGPU_GEM_CREATE_SHADOW;
+	r = amdgpu_bo_create(adev, &bp, &root);
 	if (r)
 		goto error_free_delayed;
-	root_bo = &root->bo;
-	r = amdgpu_bo_reserve(root_bo, true);
+
+	r = amdgpu_bo_reserve(root, true);
 	if (r)
 		goto error_free_root;
 
-	r = dma_resv_reserve_shared(root_bo->tbo.base.resv, 1);
+	r = dma_resv_reserve_shared(amdkcl_ttm_resvp(&root->tbo), 1);
 	if (r)
 		goto error_unreserve;
 
-	amdgpu_vm_bo_base_init(&vm->root, vm, root_bo);
+	amdgpu_vm_bo_base_init(&vm->root.base, vm, root);
 
 	r = amdgpu_vm_clear_bo(adev, vm, root, false);
 	if (r)
 		goto error_unreserve;
 
-	amdgpu_bo_unreserve(vm->root.bo);
+	amdgpu_bo_unreserve(vm->root.base.bo);
+
+	if (pasid) {
+		unsigned long flags;
+
+		spin_lock_irqsave(&adev->vm_manager.pasid_lock, flags);
+		r = idr_alloc(&adev->vm_manager.pasid_idr, vm, pasid, pasid + 1,
+			      GFP_ATOMIC);
+		spin_unlock_irqrestore(&adev->vm_manager.pasid_lock, flags);
+		if (r < 0)
+			goto error_free_root;
+
+		vm->pasid = pasid;
+	}
 
 	INIT_KFIFO(vm->faults);
 
 	return 0;
 
 error_unreserve:
-	amdgpu_bo_unreserve(vm->root.bo);
+	amdgpu_bo_unreserve(vm->root.base.bo);
 
 error_free_root:
-	amdgpu_bo_unref(&root->shadow);
-	amdgpu_bo_unref(&root_bo);
-	vm->root.bo = NULL;
+	amdgpu_bo_unref(&vm->root.base.bo->shadow);
+	amdgpu_bo_unref(&vm->root.base.bo);
+	vm->root.base.bo = NULL;
 
 error_free_delayed:
-	dma_fence_put(vm->last_unlocked);
+	dma_fence_put(vm->last_direct);
 	drm_sched_entity_destroy(&vm->delayed);
 
-error_free_immediate:
-	drm_sched_entity_destroy(&vm->immediate);
+error_free_direct:
+	drm_sched_entity_destroy(&vm->direct);
 
 	return r;
 }
@@ -3020,14 +3003,17 @@ int amdgpu_vm_init(struct amdgpu_device *adev, struct amdgpu_vm *vm)
  *	0 if this VM is clean
  */
 static int amdgpu_vm_check_clean_reserved(struct amdgpu_device *adev,
-					  struct amdgpu_vm *vm)
+	struct amdgpu_vm *vm)
 {
 	enum amdgpu_vm_level root = adev->vm_manager.root_level;
 	unsigned int entries = amdgpu_vm_num_entries(adev, root);
 	unsigned int i = 0;
 
+	if (!(vm->root.entries))
+		return 0;
+
 	for (i = 0; i < entries; i++) {
-		if (to_amdgpu_bo_vm(vm->root.bo)->entries[i].bo)
+		if (vm->root.entries[i].base.bo)
 			return -EINVAL;
 	}
 
@@ -3039,6 +3025,7 @@ static int amdgpu_vm_check_clean_reserved(struct amdgpu_device *adev,
  *
  * @adev: amdgpu_device pointer
  * @vm: requested vm
+ * @pasid: pasid to use
  *
  * This only works on GFX VMs that don't have any BOs added and no
  * page tables allocated yet.
@@ -3046,6 +3033,7 @@ static int amdgpu_vm_check_clean_reserved(struct amdgpu_device *adev,
  * Changes the following VM parameters:
  * - use_cpu_for_update
  * - pte_supports_ats
+ * - pasid (old PASID is released, because compute manages its own PASIDs)
  *
  * Reinitializes the page directory to reflect the changed ATS
  * setting.
@@ -3053,12 +3041,13 @@ static int amdgpu_vm_check_clean_reserved(struct amdgpu_device *adev,
  * Returns:
  * 0 for success, -errno for errors.
  */
-int amdgpu_vm_make_compute(struct amdgpu_device *adev, struct amdgpu_vm *vm)
+int amdgpu_vm_make_compute(struct amdgpu_device *adev, struct amdgpu_vm *vm,
+			   unsigned int pasid)
 {
 	bool pte_support_ats = (adev->asic_type == CHIP_RAVEN);
 	int r;
 
-	r = amdgpu_bo_reserve(vm->root.bo, true);
+	r = amdgpu_bo_reserve(vm->root.base.bo, true);
 	if (r)
 		return r;
 
@@ -3067,16 +3056,27 @@ int amdgpu_vm_make_compute(struct amdgpu_device *adev, struct amdgpu_vm *vm)
 	if (r)
 		goto unreserve_bo;
 
+	if (pasid) {
+		unsigned long flags;
+
+		spin_lock_irqsave(&adev->vm_manager.pasid_lock, flags);
+		r = idr_alloc(&adev->vm_manager.pasid_idr, vm, pasid, pasid + 1,
+			      GFP_ATOMIC);
+		spin_unlock_irqrestore(&adev->vm_manager.pasid_lock, flags);
+
+		if (r == -ENOSPC)
+			goto unreserve_bo;
+		r = 0;
+	}
+
 	/* Check if PD needs to be reinitialized and do it before
 	 * changing any other state, in case it fails.
 	 */
 	if (pte_support_ats != vm->pte_support_ats) {
 		vm->pte_support_ats = pte_support_ats;
-		r = amdgpu_vm_clear_bo(adev, vm,
-				       to_amdgpu_bo_vm(vm->root.bo),
-				       false);
+		r = amdgpu_vm_clear_bo(adev, vm, vm->root.base.bo, false);
 		if (r)
-			goto unreserve_bo;
+			goto free_idr;
 	}
 
 	/* Update VM state */
@@ -3088,28 +3088,46 @@ int amdgpu_vm_make_compute(struct amdgpu_device *adev, struct amdgpu_vm *vm)
 		   !amdgpu_gmc_vram_full_visible(&adev->gmc)),
 		  "CPU update of VM recommended only for large BAR system\n");
 
-	if (vm->use_cpu_for_update) {
-		/* Sync with last SDMA update/clear before switching to CPU */
-		r = amdgpu_bo_sync_wait(vm->root.bo,
-					AMDGPU_FENCE_OWNER_UNDEFINED, true);
-		if (r)
-			goto unreserve_bo;
-
+	if (vm->use_cpu_for_update)
 		vm->update_funcs = &amdgpu_vm_cpu_funcs;
-	} else {
+	else
 		vm->update_funcs = &amdgpu_vm_sdma_funcs;
-	}
 	dma_fence_put(vm->last_update);
 	vm->last_update = NULL;
 	vm->is_compute_context = true;
 
+	if (vm->pasid) {
+		unsigned long flags;
+
+		spin_lock_irqsave(&adev->vm_manager.pasid_lock, flags);
+		idr_remove(&adev->vm_manager.pasid_idr, vm->pasid);
+		spin_unlock_irqrestore(&adev->vm_manager.pasid_lock, flags);
+
+		/* Free the original amdgpu allocated pasid
+		 * Will be replaced with kfd allocated pasid
+		 */
+		amdgpu_pasid_free(vm->pasid);
+		vm->pasid = 0;
+	}
+
 	/* Free the shadow bo for compute VM */
-	amdgpu_bo_unref(&to_amdgpu_bo_vm(vm->root.bo)->shadow);
+	amdgpu_bo_unref(&vm->root.base.bo->shadow);
+
+	if (pasid)
+		vm->pasid = pasid;
 
 	goto unreserve_bo;
 
+free_idr:
+	if (pasid) {
+		unsigned long flags;
+
+		spin_lock_irqsave(&adev->vm_manager.pasid_lock, flags);
+		idr_remove(&adev->vm_manager.pasid_idr, pasid);
+		spin_unlock_irqrestore(&adev->vm_manager.pasid_lock, flags);
+	}
 unreserve_bo:
-	amdgpu_bo_unreserve(vm->root.bo);
+	amdgpu_bo_unreserve(vm->root.base.bo);
 	return r;
 }
 
@@ -3123,7 +3141,14 @@ int amdgpu_vm_make_compute(struct amdgpu_device *adev, struct amdgpu_vm *vm)
  */
 void amdgpu_vm_release_compute(struct amdgpu_device *adev, struct amdgpu_vm *vm)
 {
-	amdgpu_vm_set_pasid(adev, vm, 0);
+	if (vm->pasid) {
+		unsigned long flags;
+
+		spin_lock_irqsave(&adev->vm_manager.pasid_lock, flags);
+		idr_remove(&adev->vm_manager.pasid_idr, vm->pasid);
+		spin_unlock_irqrestore(&adev->vm_manager.pasid_lock, flags);
+	}
+	vm->pasid = 0;
 	vm->is_compute_context = false;
 }
 
@@ -3145,11 +3170,19 @@ void amdgpu_vm_fini(struct amdgpu_device *adev, struct amdgpu_vm *vm)
 
 	amdgpu_amdkfd_gpuvm_destroy_cb(adev, vm);
 
-	root = amdgpu_bo_ref(vm->root.bo);
+	root = amdgpu_bo_ref(vm->root.base.bo);
 	amdgpu_bo_reserve(root, true);
-	amdgpu_vm_set_pasid(adev, vm, 0);
-	dma_fence_wait(vm->last_unlocked, false);
-	dma_fence_put(vm->last_unlocked);
+	if (vm->pasid) {
+		unsigned long flags;
+
+		spin_lock_irqsave(&adev->vm_manager.pasid_lock, flags);
+		idr_remove(&adev->vm_manager.pasid_idr, vm->pasid);
+		spin_unlock_irqrestore(&adev->vm_manager.pasid_lock, flags);
+		vm->pasid = 0;
+	}
+
+	dma_fence_wait(vm->last_direct, false);
+	dma_fence_put(vm->last_direct);
 
 	list_for_each_entry_safe(mapping, tmp, &vm->freed, list) {
 		if (mapping->flags & AMDGPU_PTE_PRT && prt_fini_needed) {
@@ -3164,16 +3197,24 @@ void amdgpu_vm_fini(struct amdgpu_device *adev, struct amdgpu_vm *vm)
 	amdgpu_vm_free_pts(adev, vm, NULL);
 	amdgpu_bo_unreserve(root);
 	amdgpu_bo_unref(&root);
-	WARN_ON(vm->root.bo);
+	WARN_ON(vm->root.base.bo);
 
-	drm_sched_entity_destroy(&vm->immediate);
+	drm_sched_entity_destroy(&vm->direct);
 	drm_sched_entity_destroy(&vm->delayed);
 
+#ifndef HAVE_TREE_INSERT_HAVE_RB_ROOT_CACHED
+	if (!RB_EMPTY_ROOT(&vm->va)) {
+#else
 	if (!RB_EMPTY_ROOT(&vm->va.rb_root)) {
+#endif
 		dev_err(adev->dev, "still active bo inside vm\n");
 	}
 	rbtree_postorder_for_each_entry_safe(mapping, tmp,
+#ifndef HAVE_TREE_INSERT_HAVE_RB_ROOT_CACHED
+					     &vm->va, rb) {
+#else
 					     &vm->va.rb_root, rb) {
+#endif
 		/* Don't remove the mapping here, we don't want to trigger a
 		 * rebalance and the tree is about to be destroyed anyway.
 		 */
@@ -3197,12 +3238,6 @@ void amdgpu_vm_manager_init(struct amdgpu_device *adev)
 {
 	unsigned i;
 
-	/* Concurrent flushes are only possible starting with Vega10 and
-	 * are broken on Navi10 and Navi14.
-	 */
-	adev->vm_manager.concurrent_flush = !(adev->asic_type < CHIP_VEGA10 ||
-					      adev->asic_type == CHIP_NAVI10 ||
-					      adev->asic_type == CHIP_NAVI14);
 	amdgpu_vmid_mgr_init(adev);
 
 	adev->vm_manager.fence_context =
@@ -3229,7 +3264,11 @@ void amdgpu_vm_manager_init(struct amdgpu_device *adev)
 	adev->vm_manager.vm_update_mode = 0;
 #endif
 
-	xa_init_flags(&adev->vm_manager.pasids, XA_FLAGS_LOCK_IRQ);
+	idr_init(&adev->vm_manager.pasid_idr);
+	spin_lock_init(&adev->vm_manager.pasid_lock);
+
+	adev->vm_manager.xgmi_map_counter = 0;
+	mutex_init(&adev->vm_manager.lock_pstate);
 }
 
 /**
@@ -3241,8 +3280,8 @@ void amdgpu_vm_manager_init(struct amdgpu_device *adev)
  */
 void amdgpu_vm_manager_fini(struct amdgpu_device *adev)
 {
-	WARN_ON(!xa_empty(&adev->vm_manager.pasids));
-	xa_destroy(&adev->vm_manager.pasids);
+	WARN_ON(!idr_is_empty(&adev->vm_manager.pasid_idr));
+	idr_destroy(&adev->vm_manager.pasid_idr);
 
 	amdgpu_vmid_mgr_fini(adev);
 }
@@ -3260,7 +3299,7 @@ void amdgpu_vm_manager_fini(struct amdgpu_device *adev)
 int amdgpu_vm_ioctl(struct drm_device *dev, void *data, struct drm_file *filp)
 {
 	union drm_amdgpu_vm *args = data;
-	struct amdgpu_device *adev = drm_to_adev(dev);
+	struct amdgpu_device *adev = dev->dev_private;
 	struct amdgpu_fpriv *fpriv = filp->driver_priv;
 	long timeout = msecs_to_jiffies(2000);
 	int r;
@@ -3280,7 +3319,7 @@ int amdgpu_vm_ioctl(struct drm_device *dev, void *data, struct drm_file *filp)
 		/* Wait vm idle to make sure the vmid set in SPM_VMID is
 		 * not referenced anymore.
 		 */
-		r = amdgpu_bo_reserve(fpriv->vm.root.bo, true);
+		r = amdgpu_bo_reserve(fpriv->vm.root.base.bo, true);
 		if (r)
 			return r;
 
@@ -3288,7 +3327,7 @@ int amdgpu_vm_ioctl(struct drm_device *dev, void *data, struct drm_file *filp)
 		if (r < 0)
 			return r;
 
-		amdgpu_bo_unreserve(fpriv->vm.root.bo);
+		amdgpu_bo_unreserve(fpriv->vm.root.base.bo);
 		amdgpu_vmid_free_reserved(adev, &fpriv->vm, AMDGPU_GFXHUB_0);
 		break;
 	default:
@@ -3305,19 +3344,19 @@ int amdgpu_vm_ioctl(struct drm_device *dev, void *data, struct drm_file *filp)
  * @pasid: PASID identifier for VM
  * @task_info: task_info to fill.
  */
-void amdgpu_vm_get_task_info(struct amdgpu_device *adev, u32 pasid,
+void amdgpu_vm_get_task_info(struct amdgpu_device *adev, unsigned int pasid,
 			 struct amdgpu_task_info *task_info)
 {
 	struct amdgpu_vm *vm;
 	unsigned long flags;
 
-	xa_lock_irqsave(&adev->vm_manager.pasids, flags);
+	spin_lock_irqsave(&adev->vm_manager.pasid_lock, flags);
 
-	vm = xa_load(&adev->vm_manager.pasids, pasid);
+	vm = idr_find(&adev->vm_manager.pasid_idr, pasid);
 	if (vm)
 		*task_info = vm->task_info;
 
-	xa_unlock_irqrestore(&adev->vm_manager.pasids, flags);
+	spin_unlock_irqrestore(&adev->vm_manager.pasid_lock, flags);
 }
 
 /**
@@ -3349,60 +3388,50 @@ void amdgpu_vm_set_task_info(struct amdgpu_vm *vm)
  * Try to gracefully handle a VM fault. Return true if the fault was handled and
  * shouldn't be reported any more.
  */
-bool amdgpu_vm_handle_fault(struct amdgpu_device *adev, u32 pasid,
+bool amdgpu_vm_handle_fault(struct amdgpu_device *adev, unsigned int pasid,
 			    uint64_t addr)
 {
-	bool is_compute_context = false;
 	struct amdgpu_bo *root;
-	unsigned long irqflags;
 	uint64_t value, flags;
 	struct amdgpu_vm *vm;
-	int r;
+	long r;
 
-	xa_lock_irqsave(&adev->vm_manager.pasids, irqflags);
-	vm = xa_load(&adev->vm_manager.pasids, pasid);
-	if (vm) {
-		root = amdgpu_bo_ref(vm->root.bo);
-		is_compute_context = vm->is_compute_context;
-	} else {
+	spin_lock(&adev->vm_manager.pasid_lock);
+	vm = idr_find(&adev->vm_manager.pasid_idr, pasid);
+	if (vm)
+		root = amdgpu_bo_ref(vm->root.base.bo);
+	else
 		root = NULL;
-	}
-	xa_unlock_irqrestore(&adev->vm_manager.pasids, irqflags);
+	spin_unlock(&adev->vm_manager.pasid_lock);
 
 	if (!root)
 		return false;
 
-	addr /= AMDGPU_GPU_PAGE_SIZE;
-
-	if (is_compute_context &&
-	    !svm_range_restore_pages(adev, pasid, addr)) {
-		amdgpu_bo_unref(&root);
-		return true;
-	}
-
 	r = amdgpu_bo_reserve(root, true);
 	if (r)
 		goto error_unref;
 
 	/* Double check that the VM still exists */
-	xa_lock_irqsave(&adev->vm_manager.pasids, irqflags);
-	vm = xa_load(&adev->vm_manager.pasids, pasid);
-	if (vm && vm->root.bo != root)
+	spin_lock(&adev->vm_manager.pasid_lock);
+	vm = idr_find(&adev->vm_manager.pasid_idr, pasid);
+	if (vm && vm->root.base.bo != root)
 		vm = NULL;
-	xa_unlock_irqrestore(&adev->vm_manager.pasids, irqflags);
+	spin_unlock(&adev->vm_manager.pasid_lock);
 	if (!vm)
 		goto error_unlock;
 
+	addr /= AMDGPU_GPU_PAGE_SIZE;
 	flags = AMDGPU_PTE_VALID | AMDGPU_PTE_SNOOPED |
 		AMDGPU_PTE_SYSTEM;
 
-	if (is_compute_context) {
+	if (vm->is_compute_context) {
 		/* Intentionally setting invalid PTE flag
 		 * combination to force a no-retry-fault
 		 */
 		flags = AMDGPU_PTE_EXECUTABLE | AMDGPU_PDE_PTE |
 			AMDGPU_PTE_TF;
 		value = 0;
+
 	} else if (amdgpu_vm_fault_stop == AMDGPU_VM_FAULT_STOP_NEVER) {
 		/* Redirect the access to the dummy page */
 		value = adev->dummy_page_addr;
@@ -3414,15 +3443,8 @@ bool amdgpu_vm_handle_fault(struct amdgpu_device *adev, u32 pasid,
 		value = 0;
 	}
 
-	r = dma_resv_reserve_shared(root->tbo.base.resv, 1);
-	if (r) {
-		pr_debug("failed %d to reserve fence slot\n", r);
-		goto error_unlock;
-	}
-
-	r = amdgpu_vm_bo_update_mapping(adev, adev, vm, true, false, NULL, addr,
-					addr, flags, value, NULL, NULL, NULL,
-					NULL);
+	r = amdgpu_vm_bo_update_mapping(adev, vm, true, NULL, addr, addr + 1,
+					flags, value, NULL, NULL);
 	if (r)
 		goto error_unlock;
 
@@ -3431,106 +3453,10 @@ bool amdgpu_vm_handle_fault(struct amdgpu_device *adev, u32 pasid,
 error_unlock:
 	amdgpu_bo_unreserve(root);
 	if (r < 0)
-		DRM_ERROR("Can't handle page fault (%d)\n", r);
+		DRM_ERROR("Can't handle page fault (%ld)\n", r);
 
 error_unref:
 	amdgpu_bo_unref(&root);
 
 	return false;
 }
-
-#if defined(CONFIG_DEBUG_FS)
-/**
- * amdgpu_debugfs_vm_bo_info  - print BO info for the VM
- *
- * @vm: Requested VM for printing BO info
- * @m: debugfs file
- *
- * Print BO information in debugfs file for the VM
- */
-void amdgpu_debugfs_vm_bo_info(struct amdgpu_vm *vm, struct seq_file *m)
-{
-	struct amdgpu_bo_va *bo_va, *tmp;
-	u64 total_idle = 0;
-	u64 total_evicted = 0;
-	u64 total_relocated = 0;
-	u64 total_moved = 0;
-	u64 total_invalidated = 0;
-	u64 total_done = 0;
-	unsigned int total_idle_objs = 0;
-	unsigned int total_evicted_objs = 0;
-	unsigned int total_relocated_objs = 0;
-	unsigned int total_moved_objs = 0;
-	unsigned int total_invalidated_objs = 0;
-	unsigned int total_done_objs = 0;
-	unsigned int id = 0;
-
-	seq_puts(m, "\tIdle BOs:\n");
-	list_for_each_entry_safe(bo_va, tmp, &vm->idle, base.vm_status) {
-		if (!bo_va->base.bo)
-			continue;
-		total_idle += amdgpu_bo_print_info(id++, bo_va->base.bo, m);
-	}
-	total_idle_objs = id;
-	id = 0;
-
-	seq_puts(m, "\tEvicted BOs:\n");
-	list_for_each_entry_safe(bo_va, tmp, &vm->evicted, base.vm_status) {
-		if (!bo_va->base.bo)
-			continue;
-		total_evicted += amdgpu_bo_print_info(id++, bo_va->base.bo, m);
-	}
-	total_evicted_objs = id;
-	id = 0;
-
-	seq_puts(m, "\tRelocated BOs:\n");
-	list_for_each_entry_safe(bo_va, tmp, &vm->relocated, base.vm_status) {
-		if (!bo_va->base.bo)
-			continue;
-		total_relocated += amdgpu_bo_print_info(id++, bo_va->base.bo, m);
-	}
-	total_relocated_objs = id;
-	id = 0;
-
-	seq_puts(m, "\tMoved BOs:\n");
-	list_for_each_entry_safe(bo_va, tmp, &vm->moved, base.vm_status) {
-		if (!bo_va->base.bo)
-			continue;
-		total_moved += amdgpu_bo_print_info(id++, bo_va->base.bo, m);
-	}
-	total_moved_objs = id;
-	id = 0;
-
-	seq_puts(m, "\tInvalidated BOs:\n");
-	spin_lock(&vm->invalidated_lock);
-	list_for_each_entry_safe(bo_va, tmp, &vm->invalidated, base.vm_status) {
-		if (!bo_va->base.bo)
-			continue;
-		total_invalidated += amdgpu_bo_print_info(id++,	bo_va->base.bo, m);
-	}
-	total_invalidated_objs = id;
-	id = 0;
-
-	seq_puts(m, "\tDone BOs:\n");
-	list_for_each_entry_safe(bo_va, tmp, &vm->done, base.vm_status) {
-		if (!bo_va->base.bo)
-			continue;
-		total_done += amdgpu_bo_print_info(id++, bo_va->base.bo, m);
-	}
-	spin_unlock(&vm->invalidated_lock);
-	total_done_objs = id;
-
-	seq_printf(m, "\tTotal idle size:        %12lld\tobjs:\t%d\n", total_idle,
-		   total_idle_objs);
-	seq_printf(m, "\tTotal evicted size:     %12lld\tobjs:\t%d\n", total_evicted,
-		   total_evicted_objs);
-	seq_printf(m, "\tTotal relocated size:   %12lld\tobjs:\t%d\n", total_relocated,
-		   total_relocated_objs);
-	seq_printf(m, "\tTotal moved size:       %12lld\tobjs:\t%d\n", total_moved,
-		   total_moved_objs);
-	seq_printf(m, "\tTotal invalidated size: %12lld\tobjs:\t%d\n", total_invalidated,
-		   total_invalidated_objs);
-	seq_printf(m, "\tTotal done size:        %12lld\tobjs:\t%d\n", total_done,
-		   total_done_objs);
-}
-#endif
Signature · 1 line
2.17.1
#1 lore raw

PATCH 1/1 drm/amdgpu: Add driver version

From: David M Nieto <[email protected]>

This sysfs is only defined in DKMS drivers
it exposes the internal AMDGPU version

---
 drivers/gpu/drm/amd/amdgpu/amdgpu_device.c | 2659 +++++++-------------
 1 file changed, 941 insertions(+), 1718 deletions(-)
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +941 -1718
index 9e53ff851496..d93d1c966bad 100644
@@ -29,6 +29,7 @@
 #include <linux/kthread.h>
 #include <linux/module.h>
 #include <linux/console.h>
+#include <linux/reboot.h>
 #include <linux/slab.h>
 
 #include <drm/drm_atomic_helper.h>
@@ -65,13 +66,9 @@
 #include "amdgpu_ras.h"
 #include "amdgpu_pmu.h"
 #include "amdgpu_fru_eeprom.h"
-#include "amdgpu_reset.h"
 
 #include <linux/suspend.h>
 #include <drm/task_barrier.h>
-#include <linux/pm_runtime.h>
-
-#include <drm/drm_drv.h>
 
 MODULE_FIRMWARE("amdgpu/vega10_gpu_info.bin");
 MODULE_FIRMWARE("amdgpu/vega12_gpu_info.bin");
@@ -83,8 +80,6 @@ MODULE_FIRMWARE("amdgpu/renoir_gpu_info.bin");
 MODULE_FIRMWARE("amdgpu/navi10_gpu_info.bin");
 MODULE_FIRMWARE("amdgpu/navi14_gpu_info.bin");
 MODULE_FIRMWARE("amdgpu/navi12_gpu_info.bin");
-MODULE_FIRMWARE("amdgpu/vangogh_gpu_info.bin");
-MODULE_FIRMWARE("amdgpu/yellow_carp_gpu_info.bin");
 
 #define AMDGPU_RESUME_MS		2000
 
@@ -114,17 +109,9 @@ const char *amdgpu_asic_name[] = {
 	"RAVEN",
 	"ARCTURUS",
 	"RENOIR",
-	"ALDEBARAN",
 	"NAVI10",
-	"CYAN_SKILLFISH",
 	"NAVI14",
 	"NAVI12",
-	"SIENNA_CICHLID",
-	"NAVY_FLOUNDER",
-	"VANGOGH",
-	"DIMGREY_CAVEFISH",
-	"BEIGE_GOBY",
-	"YELLOW_CARP",
 	"LAST",
 };
 
@@ -141,10 +128,10 @@ static ssize_t amdgpu_device_get_pcie_replay_count(struct device *dev,
 		struct device_attribute *attr, char *buf)
 {
 	struct drm_device *ddev = dev_get_drvdata(dev);
-	struct amdgpu_device *adev = drm_to_adev(ddev);
+	struct amdgpu_device *adev = ddev->dev_private;
 	uint64_t cnt = amdgpu_asic_get_pcie_replay_count(adev);
 
-	return sysfs_emit(buf, "%llu\n", cnt);
+	return snprintf(buf, PAGE_SIZE, "%llu\n", cnt);
 }
 
 static DEVICE_ATTR(pcie_replay_count, S_IRUGO,
@@ -166,9 +153,9 @@ static ssize_t amdgpu_device_get_product_name(struct device *dev,
 		struct device_attribute *attr, char *buf)
 {
 	struct drm_device *ddev = dev_get_drvdata(dev);
-	struct amdgpu_device *adev = drm_to_adev(ddev);
+	struct amdgpu_device *adev = ddev->dev_private;
 
-	return sysfs_emit(buf, "%s\n", adev->product_name);
+	return snprintf(buf, PAGE_SIZE, "%s\n", adev->product_name);
 }
 
 static DEVICE_ATTR(product_name, S_IRUGO,
@@ -188,9 +175,9 @@ static ssize_t amdgpu_device_get_product_number(struct device *dev,
 		struct device_attribute *attr, char *buf)
 {
 	struct drm_device *ddev = dev_get_drvdata(dev);
-	struct amdgpu_device *adev = drm_to_adev(ddev);
+	struct amdgpu_device *adev = ddev->dev_private;
 
-	return sysfs_emit(buf, "%s\n", adev->product_number);
+	return snprintf(buf, PAGE_SIZE, "%s\n", adev->product_number);
 }
 
 static DEVICE_ATTR(product_number, S_IRUGO,
@@ -210,45 +197,27 @@ static ssize_t amdgpu_device_get_serial_number(struct device *dev,
 		struct device_attribute *attr, char *buf)
 {
 	struct drm_device *ddev = dev_get_drvdata(dev);
-	struct amdgpu_device *adev = drm_to_adev(ddev);
+	struct amdgpu_device *adev = ddev->dev_private;
 
-	return sysfs_emit(buf, "%s\n", adev->serial);
+	return snprintf(buf, PAGE_SIZE, "%s\n", adev->serial);
 }
 
 static DEVICE_ATTR(serial_number, S_IRUGO,
 		amdgpu_device_get_serial_number, NULL);
 
 /**
- * amdgpu_device_supports_px - Is the device a dGPU with ATPX power control
- *
- * @dev: drm_device pointer
- *
- * Returns true if the device is a dGPU with ATPX power control,
- * otherwise return false.
- */
-bool amdgpu_device_supports_px(struct drm_device *dev)
-{
-	struct amdgpu_device *adev = drm_to_adev(dev);
-
-	if ((adev->flags & AMD_IS_PX) && !amdgpu_is_atpx_hybrid())
-		return true;
-	return false;
-}
-
-/**
- * amdgpu_device_supports_boco - Is the device a dGPU with ACPI power resources
+ * amdgpu_device_supports_boco - Is the device a dGPU with HG/PX power control
  *
  * @dev: drm_device pointer
  *
- * Returns true if the device is a dGPU with ACPI power control,
+ * Returns true if the device is a dGPU with HG/PX power control,
  * otherwise return false.
  */
 bool amdgpu_device_supports_boco(struct drm_device *dev)
 {
-	struct amdgpu_device *adev = drm_to_adev(dev);
+	struct amdgpu_device *adev = dev->dev_private;
 
-	if (adev->has_pr3 ||
-	    ((adev->flags & AMD_IS_PX) && amdgpu_is_atpx_hybrid()))
+	if (adev->flags & AMD_IS_PX)
 		return true;
 	return false;
 }
@@ -263,32 +232,15 @@ bool amdgpu_device_supports_boco(struct drm_device *dev)
  */
 bool amdgpu_device_supports_baco(struct drm_device *dev)
 {
-	struct amdgpu_device *adev = drm_to_adev(dev);
+	struct amdgpu_device *adev = dev->dev_private;
 
 	return amdgpu_asic_supports_baco(adev);
 }
 
 /**
- * amdgpu_device_supports_smart_shift - Is the device dGPU with
- * smart shift support
- *
- * @dev: drm_device pointer
+ * VRAM access helper functions.
  *
- * Returns true if the device is a dGPU with Smart Shift support,
- * otherwise returns false.
- */
-bool amdgpu_device_supports_smart_shift(struct drm_device *dev)
-{
-	return (amdgpu_device_supports_boco(dev) &&
-		amdgpu_acpi_is_power_shift_control_supported());
-}
-
-/*
- * VRAM access helper functions
- */
-
-/**
- * amdgpu_device_mm_access - access vram by MM_INDEX/MM_DATA
+ * amdgpu_device_vram_access - read/write a buffer in vram
  *
  * @adev: amdgpu_device pointer
  * @pos: offset of the buffer in vram
@@ -296,143 +248,61 @@ bool amdgpu_device_supports_smart_shift(struct drm_device *dev)
  * @size: read/write size, sizeof(@buf) must > @size
  * @write: true - write to vram, otherwise - read from vram
  */
-void amdgpu_device_mm_access(struct amdgpu_device *adev, loff_t pos,
-			     void *buf, size_t size, bool write)
+void amdgpu_device_vram_access(struct amdgpu_device *adev, loff_t pos,
+			       uint32_t *buf, size_t size, bool write)
 {
 	unsigned long flags;
-	uint32_t hi = ~0, tmp = 0;
-	uint32_t *data = buf;
+	uint32_t hi = ~0;
 	uint64_t last;
-	int idx;
-
-	if (!drm_dev_enter(&adev->ddev, &idx))
-		return;
-
-	BUG_ON(!IS_ALIGNED(pos, 4) || !IS_ALIGNED(size, 4));
-
-	spin_lock_irqsave(&adev->mmio_idx_lock, flags);
-	for (last = pos + size; pos < last; pos += 4) {
-		tmp = pos >> 31;
-
-		WREG32_NO_KIQ(mmMM_INDEX, ((uint32_t)pos) | 0x80000000);
-		if (tmp != hi) {
-			WREG32_NO_KIQ(mmMM_INDEX_HI, tmp);
-			hi = tmp;
-		}
-		if (write)
-			WREG32_NO_KIQ(mmMM_DATA, *data++);
-		else
-			*data++ = RREG32_NO_KIQ(mmMM_DATA);
-	}
 
-	spin_unlock_irqrestore(&adev->mmio_idx_lock, flags);
-	drm_dev_exit(idx);
-}
 
-/**
- * amdgpu_device_vram_access - access vram by vram aperature
- *
- * @adev: amdgpu_device pointer
- * @pos: offset of the buffer in vram
- * @buf: virtual address of the buffer in system memory
- * @size: read/write size, sizeof(@buf) must > @size
- * @write: true - write to vram, otherwise - read from vram
- *
- * The return value means how many bytes have been transferred.
- */
-size_t amdgpu_device_aper_access(struct amdgpu_device *adev, loff_t pos,
-				 void *buf, size_t size, bool write)
-{
 #ifdef CONFIG_64BIT
-	void __iomem *addr;
-	size_t count = 0;
-	uint64_t last;
-
-	if (!adev->mman.aper_base_kaddr)
-		return 0;
-
 	last = min(pos + size, adev->gmc.visible_vram_size);
 	if (last > pos) {
-		addr = adev->mman.aper_base_kaddr + pos;
-		count = last - pos;
+		void __iomem *addr = adev->mman.aper_base_kaddr + pos;
+		size_t count = last - pos;
 
 		if (write) {
 			memcpy_toio(addr, buf, count);
 			mb();
-			amdgpu_device_flush_hdp(adev, NULL);
+			amdgpu_asic_flush_hdp(adev, NULL);
 		} else {
-			amdgpu_device_invalidate_hdp(adev, NULL);
+			amdgpu_asic_invalidate_hdp(adev, NULL);
 			mb();
 			memcpy_fromio(buf, addr, count);
 		}
 
-	}
-
-	return count;
-#else
-	return 0;
-#endif
-}
-
-/**
- * amdgpu_device_vram_access - read/write a buffer in vram
- *
- * @adev: amdgpu_device pointer
- * @pos: offset of the buffer in vram
- * @buf: virtual address of the buffer in system memory
- * @size: read/write size, sizeof(@buf) must > @size
- * @write: true - write to vram, otherwise - read from vram
- */
-void amdgpu_device_vram_access(struct amdgpu_device *adev, loff_t pos,
-			       void *buf, size_t size, bool write)
-{
-	size_t count;
+		if (count == size)
+			return;
 
-	/* try to using vram apreature to access vram first */
-	count = amdgpu_device_aper_access(adev, pos, buf, size, write);
-	size -= count;
-	if (size) {
-		/* using MM to access rest vram */
 		pos += count;
-		buf += count;
-		amdgpu_device_mm_access(adev, pos, buf, size, write);
+		buf += count / 4;
+		size -= count;
 	}
-}
-
-/*
- * register access helper functions.
- */
+#endif
 
-/* Check if hw access should be skipped because of hotplug or device error */
-bool amdgpu_device_skip_hw_access(struct amdgpu_device *adev)
-{
-	if (adev->no_hw_access)
-		return true;
+	spin_lock_irqsave(&adev->mmio_idx_lock, flags);
+	for (last = pos + size; pos < last; pos += 4) {
+		uint32_t tmp = pos >> 31;
 
-#ifdef CONFIG_LOCKDEP
-	/*
-	 * This is a bit complicated to understand, so worth a comment. What we assert
-	 * here is that the GPU reset is not running on another thread in parallel.
-	 *
-	 * For this we trylock the read side of the reset semaphore, if that succeeds
-	 * we know that the reset is not running in paralell.
-	 *
-	 * If the trylock fails we assert that we are either already holding the read
-	 * side of the lock or are the reset thread itself and hold the write side of
-	 * the lock.
-	 */
-	if (in_task()) {
-		if (down_read_trylock(&adev->reset_sem))
-			up_read(&adev->reset_sem);
+		WREG32_NO_KIQ(mmMM_INDEX, ((uint32_t)pos) | 0x80000000);
+		if (tmp != hi) {
+			WREG32_NO_KIQ(mmMM_INDEX_HI, tmp);
+			hi = tmp;
+		}
+		if (write)
+			WREG32_NO_KIQ(mmMM_DATA, *buf++);
 		else
-			lockdep_assert_held(&adev->reset_sem);
+			*buf++ = RREG32_NO_KIQ(mmMM_DATA);
 	}
-#endif
-	return false;
+	spin_unlock_irqrestore(&adev->mmio_idx_lock, flags);
 }
 
+/*
+ * MMIO register access helper functions.
+ */
 /**
- * amdgpu_device_rreg - read a memory mapped IO or indirect register
+ * amdgpu_mm_rreg - read a memory mapped IO register
  *
  * @adev: amdgpu_device pointer
  * @reg: dword aligned register offset
@@ -440,29 +310,25 @@ bool amdgpu_device_skip_hw_access(struct amdgpu_device *adev)
  *
  * Returns the 32 bit value from the offset specified.
  */
-uint32_t amdgpu_device_rreg(struct amdgpu_device *adev,
-			    uint32_t reg, uint32_t acc_flags)
+uint32_t amdgpu_mm_rreg(struct amdgpu_device *adev, uint32_t reg,
+			uint32_t acc_flags)
 {
 	uint32_t ret;
 
-	if (amdgpu_device_skip_hw_access(adev))
-		return 0;
-
-	if ((reg * 4) < adev->rmmio_size) {
-		if (!(acc_flags & AMDGPU_REGS_NO_KIQ) &&
-		    amdgpu_sriov_runtime(adev) &&
-		    down_read_trylock(&adev->reset_sem)) {
-			ret = amdgpu_kiq_rreg(adev, reg);
-			up_read(&adev->reset_sem);
-		} else {
-			ret = readl(((void __iomem *)adev->rmmio) + (reg * 4));
-		}
-	} else {
-		ret = adev->pcie_rreg(adev, reg * 4);
-	}
+	if ((acc_flags & AMDGPU_REGS_KIQ) || (!(acc_flags & AMDGPU_REGS_NO_KIQ) && amdgpu_sriov_runtime(adev)))
+		return amdgpu_kiq_rreg(adev, reg);
 
-	trace_amdgpu_device_rreg(adev->pdev->device, reg, ret);
+	if ((reg * 4) < adev->rmmio_size && !(acc_flags & AMDGPU_REGS_IDX))
+		ret = readl(((void __iomem *)adev->rmmio) + (reg * 4));
+	else {
+		unsigned long flags;
 
+		spin_lock_irqsave(&adev->mmio_idx_lock, flags);
+		writel((reg * 4), ((void __iomem *)adev->rmmio) + (mmMM_INDEX * 4));
+		ret = readl(((void __iomem *)adev->rmmio) + (mmMM_DATA * 4));
+		spin_unlock_irqrestore(&adev->mmio_idx_lock, flags);
+	}
+	trace_amdgpu_mm_rreg(adev->pdev->device, reg, ret);
 	return ret;
 }
 
@@ -482,9 +348,6 @@ uint32_t amdgpu_device_rreg(struct amdgpu_device *adev,
  */
 uint8_t amdgpu_mm_rreg8(struct amdgpu_device *adev, uint32_t offset)
 {
-	if (amdgpu_device_skip_hw_access(adev))
-		return 0;
-
 	if (offset < adev->rmmio_size)
 		return (readb(adev->rmmio + offset));
 	BUG();
@@ -507,17 +370,34 @@ uint8_t amdgpu_mm_rreg8(struct amdgpu_device *adev, uint32_t offset)
  */
 void amdgpu_mm_wreg8(struct amdgpu_device *adev, uint32_t offset, uint8_t value)
 {
-	if (amdgpu_device_skip_hw_access(adev))
-		return;
-
 	if (offset < adev->rmmio_size)
 		writeb(value, adev->rmmio + offset);
 	else
 		BUG();
 }
 
+void static inline amdgpu_mm_wreg_mmio(struct amdgpu_device *adev, uint32_t reg, uint32_t v, uint32_t acc_flags)
+{
+	trace_amdgpu_mm_wreg(adev->pdev->device, reg, v);
+
+	if ((reg * 4) < adev->rmmio_size && !(acc_flags & AMDGPU_REGS_IDX))
+		writel(v, ((void __iomem *)adev->rmmio) + (reg * 4));
+	else {
+		unsigned long flags;
+
+		spin_lock_irqsave(&adev->mmio_idx_lock, flags);
+		writel((reg * 4), ((void __iomem *)adev->rmmio) + (mmMM_INDEX * 4));
+		writel(v, ((void __iomem *)adev->rmmio) + (mmMM_DATA * 4));
+		spin_unlock_irqrestore(&adev->mmio_idx_lock, flags);
+	}
+
+	if (adev->asic_type >= CHIP_VEGA10 && reg == 1 && adev->last_mm_index == 0x5702C) {
+		udelay(500);
+	}
+}
+
 /**
- * amdgpu_device_wreg - write to a memory mapped IO or indirect register
+ * amdgpu_mm_wreg - write to a memory mapped IO register
  *
  * @adev: amdgpu_device pointer
  * @reg: dword aligned register offset
@@ -526,27 +406,17 @@ void amdgpu_mm_wreg8(struct amdgpu_device *adev, uint32_t offset, uint8_t value)
  *
  * Writes the value specified to the offset specified.
  */
-void amdgpu_device_wreg(struct amdgpu_device *adev,
-			uint32_t reg, uint32_t v,
-			uint32_t acc_flags)
+void amdgpu_mm_wreg(struct amdgpu_device *adev, uint32_t reg, uint32_t v,
+		    uint32_t acc_flags)
 {
-	if (amdgpu_device_skip_hw_access(adev))
-		return;
-
-	if ((reg * 4) < adev->rmmio_size) {
-		if (!(acc_flags & AMDGPU_REGS_NO_KIQ) &&
-		    amdgpu_sriov_runtime(adev) &&
-		    down_read_trylock(&adev->reset_sem)) {
-			amdgpu_kiq_wreg(adev, reg, v);
-			up_read(&adev->reset_sem);
-		} else {
-			writel(v, ((void __iomem *)adev->rmmio) + (reg * 4));
-		}
-	} else {
-		adev->pcie_wreg(adev, reg * 4, v);
+	if (adev->asic_type >= CHIP_VEGA10 && reg == 0) {
+		adev->last_mm_index = v;
 	}
 
-	trace_amdgpu_device_wreg(adev->pdev->device, reg, v);
+	if ((acc_flags & AMDGPU_REGS_KIQ) || (!(acc_flags & AMDGPU_REGS_NO_KIQ) && amdgpu_sriov_runtime(adev)))
+		return amdgpu_kiq_wreg(adev, reg, v);
+
+	amdgpu_mm_wreg_mmio(adev, reg, v, acc_flags);
 }
 
 /*
@@ -554,19 +424,62 @@ void amdgpu_device_wreg(struct amdgpu_device *adev,
  *
  * this function is invoked only the debugfs register access
  * */
-void amdgpu_mm_wreg_mmio_rlc(struct amdgpu_device *adev,
-			     uint32_t reg, uint32_t v)
+void amdgpu_mm_wreg_mmio_rlc(struct amdgpu_device *adev, uint32_t reg, uint32_t v,
+		    uint32_t acc_flags)
 {
-	if (amdgpu_device_skip_hw_access(adev))
-		return;
-
 	if (amdgpu_sriov_fullaccess(adev) &&
-	    adev->gfx.rlc.funcs &&
-	    adev->gfx.rlc.funcs->is_rlcg_access_range) {
+		adev->gfx.rlc.funcs &&
+		adev->gfx.rlc.funcs->is_rlcg_access_range) {
+
 		if (adev->gfx.rlc.funcs->is_rlcg_access_range(adev, reg))
-			return adev->gfx.rlc.funcs->sriov_wreg(adev, reg, v, 0, 0);
-	} else {
-		writel(v, ((void __iomem *)adev->rmmio) + (reg * 4));
+			return adev->gfx.rlc.funcs->rlcg_wreg(adev, reg, v, 0);
+	}
+
+	amdgpu_mm_wreg_mmio(adev, reg, v, acc_flags);
+}
+
+/**
+ * amdgpu_io_rreg - read an IO register
+ *
+ * @adev: amdgpu_device pointer
+ * @reg: dword aligned register offset
+ *
+ * Returns the 32 bit value from the offset specified.
+ */
+u32 amdgpu_io_rreg(struct amdgpu_device *adev, u32 reg)
+{
+	if ((reg * 4) < adev->rio_mem_size)
+		return ioread32(adev->rio_mem + (reg * 4));
+	else {
+		iowrite32((reg * 4), adev->rio_mem + (mmMM_INDEX * 4));
+		return ioread32(adev->rio_mem + (mmMM_DATA * 4));
+	}
+}
+
+/**
+ * amdgpu_io_wreg - write to an IO register
+ *
+ * @adev: amdgpu_device pointer
+ * @reg: dword aligned register offset
+ * @v: 32 bit value to write to the register
+ *
+ * Writes the value specified to the offset specified.
+ */
+void amdgpu_io_wreg(struct amdgpu_device *adev, u32 reg, u32 v)
+{
+	if (adev->asic_type >= CHIP_VEGA10 && reg == 0) {
+		adev->last_mm_index = v;
+	}
+
+	if ((reg * 4) < adev->rio_mem_size)
+		iowrite32(v, adev->rio_mem + (reg * 4));
+	else {
+		iowrite32((reg * 4), adev->rio_mem + (mmMM_INDEX * 4));
+		iowrite32(v, adev->rio_mem + (mmMM_DATA * 4));
+	}
+
+	if (adev->asic_type >= CHIP_VEGA10 && reg == 1 && adev->last_mm_index == 0x5702C) {
+		udelay(500);
 	}
 }
 
@@ -581,9 +494,6 @@ void amdgpu_mm_wreg_mmio_rlc(struct amdgpu_device *adev,
  */
 u32 amdgpu_mm_rdoorbell(struct amdgpu_device *adev, u32 index)
 {
-	if (amdgpu_device_skip_hw_access(adev))
-		return 0;
-
 	if (index < adev->doorbell.num_doorbells) {
 		return readl(adev->doorbell.ptr + index);
 	} else {
@@ -604,9 +514,6 @@ u32 amdgpu_mm_rdoorbell(struct amdgpu_device *adev, u32 index)
  */
 void amdgpu_mm_wdoorbell(struct amdgpu_device *adev, u32 index, u32 v)
 {
-	if (amdgpu_device_skip_hw_access(adev))
-		return;
-
 	if (index < adev->doorbell.num_doorbells) {
 		writel(v, adev->doorbell.ptr + index);
 	} else {
@@ -625,9 +532,6 @@ void amdgpu_mm_wdoorbell(struct amdgpu_device *adev, u32 index, u32 v)
  */
 u64 amdgpu_mm_rdoorbell64(struct amdgpu_device *adev, u32 index)
 {
-	if (amdgpu_device_skip_hw_access(adev))
-		return 0;
-
 	if (index < adev->doorbell.num_doorbells) {
 		return atomic64_read((atomic64_t *)(adev->doorbell.ptr + index));
 	} else {
@@ -648,9 +552,6 @@ u64 amdgpu_mm_rdoorbell64(struct amdgpu_device *adev, u32 index)
  */
 void amdgpu_mm_wdoorbell64(struct amdgpu_device *adev, u32 index, u64 v)
 {
-	if (amdgpu_device_skip_hw_access(adev))
-		return;
-
 	if (index < adev->doorbell.num_doorbells) {
 		atomic64_set((atomic64_t *)(adev->doorbell.ptr + index), v);
 	} else {
@@ -658,141 +559,10 @@ void amdgpu_mm_wdoorbell64(struct amdgpu_device *adev, u32 index, u64 v)
 	}
 }
 
-/**
- * amdgpu_device_indirect_rreg - read an indirect register
- *
- * @adev: amdgpu_device pointer
- * @pcie_index: mmio register offset
- * @pcie_data: mmio register offset
- * @reg_addr: indirect register address to read from
- *
- * Returns the value of indirect register @reg_addr
- */
-u32 amdgpu_device_indirect_rreg(struct amdgpu_device *adev,
-				u32 pcie_index, u32 pcie_data,
-				u32 reg_addr)
-{
-	unsigned long flags;
-	u32 r;
-	void __iomem *pcie_index_offset;
-	void __iomem *pcie_data_offset;
-
-	spin_lock_irqsave(&adev->pcie_idx_lock, flags);
-	pcie_index_offset = (void __iomem *)adev->rmmio + pcie_index * 4;
-	pcie_data_offset = (void __iomem *)adev->rmmio + pcie_data * 4;
-
-	writel(reg_addr, pcie_index_offset);
-	readl(pcie_index_offset);
-	r = readl(pcie_data_offset);
-	spin_unlock_irqrestore(&adev->pcie_idx_lock, flags);
-
-	return r;
-}
-
-/**
- * amdgpu_device_indirect_rreg64 - read a 64bits indirect register
- *
- * @adev: amdgpu_device pointer
- * @pcie_index: mmio register offset
- * @pcie_data: mmio register offset
- * @reg_addr: indirect register address to read from
- *
- * Returns the value of indirect register @reg_addr
- */
-u64 amdgpu_device_indirect_rreg64(struct amdgpu_device *adev,
-				  u32 pcie_index, u32 pcie_data,
-				  u32 reg_addr)
-{
-	unsigned long flags;
-	u64 r;
-	void __iomem *pcie_index_offset;
-	void __iomem *pcie_data_offset;
-
-	spin_lock_irqsave(&adev->pcie_idx_lock, flags);
-	pcie_index_offset = (void __iomem *)adev->rmmio + pcie_index * 4;
-	pcie_data_offset = (void __iomem *)adev->rmmio + pcie_data * 4;
-
-	/* read low 32 bits */
-	writel(reg_addr, pcie_index_offset);
-	readl(pcie_index_offset);
-	r = readl(pcie_data_offset);
-	/* read high 32 bits */
-	writel(reg_addr + 4, pcie_index_offset);
-	readl(pcie_index_offset);
-	r |= ((u64)readl(pcie_data_offset) << 32);
-	spin_unlock_irqrestore(&adev->pcie_idx_lock, flags);
-
-	return r;
-}
-
-/**
- * amdgpu_device_indirect_wreg - write an indirect register address
- *
- * @adev: amdgpu_device pointer
- * @pcie_index: mmio register offset
- * @pcie_data: mmio register offset
- * @reg_addr: indirect register offset
- * @reg_data: indirect register data
- *
- */
-void amdgpu_device_indirect_wreg(struct amdgpu_device *adev,
-				 u32 pcie_index, u32 pcie_data,
-				 u32 reg_addr, u32 reg_data)
-{
-	unsigned long flags;
-	void __iomem *pcie_index_offset;
-	void __iomem *pcie_data_offset;
-
-	spin_lock_irqsave(&adev->pcie_idx_lock, flags);
-	pcie_index_offset = (void __iomem *)adev->rmmio + pcie_index * 4;
-	pcie_data_offset = (void __iomem *)adev->rmmio + pcie_data * 4;
-
-	writel(reg_addr, pcie_index_offset);
-	readl(pcie_index_offset);
-	writel(reg_data, pcie_data_offset);
-	readl(pcie_data_offset);
-	spin_unlock_irqrestore(&adev->pcie_idx_lock, flags);
-}
-
-/**
- * amdgpu_device_indirect_wreg64 - write a 64bits indirect register address
- *
- * @adev: amdgpu_device pointer
- * @pcie_index: mmio register offset
- * @pcie_data: mmio register offset
- * @reg_addr: indirect register offset
- * @reg_data: indirect register data
- *
- */
-void amdgpu_device_indirect_wreg64(struct amdgpu_device *adev,
-				   u32 pcie_index, u32 pcie_data,
-				   u32 reg_addr, u64 reg_data)
-{
-	unsigned long flags;
-	void __iomem *pcie_index_offset;
-	void __iomem *pcie_data_offset;
-
-	spin_lock_irqsave(&adev->pcie_idx_lock, flags);
-	pcie_index_offset = (void __iomem *)adev->rmmio + pcie_index * 4;
-	pcie_data_offset = (void __iomem *)adev->rmmio + pcie_data * 4;
-
-	/* write low 32 bits */
-	writel(reg_addr, pcie_index_offset);
-	readl(pcie_index_offset);
-	writel((u32)(reg_data & 0xffffffffULL), pcie_data_offset);
-	readl(pcie_data_offset);
-	/* write high 32 bits */
-	writel(reg_addr + 4, pcie_index_offset);
-	readl(pcie_index_offset);
-	writel((u32)(reg_data >> 32), pcie_data_offset);
-	readl(pcie_data_offset);
-	spin_unlock_irqrestore(&adev->pcie_idx_lock, flags);
-}
-
 /**
  * amdgpu_invalid_rreg - dummy reg read function
  *
- * @adev: amdgpu_device pointer
+ * @adev: amdgpu device pointer
  * @reg: offset of register
  *
  * Dummy register read function.  Used for register blocks
@@ -809,7 +579,7 @@ static uint32_t amdgpu_invalid_rreg(struct amdgpu_device *adev, uint32_t reg)
 /**
  * amdgpu_invalid_wreg - dummy reg write function
  *
- * @adev: amdgpu_device pointer
+ * @adev: amdgpu device pointer
  * @reg: offset of register
  * @v: value to write to the register
  *
@@ -826,7 +596,7 @@ static void amdgpu_invalid_wreg(struct amdgpu_device *adev, uint32_t reg, uint32
 /**
  * amdgpu_invalid_rreg64 - dummy 64 bit reg read function
  *
- * @adev: amdgpu_device pointer
+ * @adev: amdgpu device pointer
  * @reg: offset of register
  *
  * Dummy register read function.  Used for register blocks
@@ -843,7 +613,7 @@ static uint64_t amdgpu_invalid_rreg64(struct amdgpu_device *adev, uint32_t reg)
 /**
  * amdgpu_invalid_wreg64 - dummy reg write function
  *
- * @adev: amdgpu_device pointer
+ * @adev: amdgpu device pointer
  * @reg: offset of register
  * @v: value to write to the register
  *
@@ -860,7 +630,7 @@ static void amdgpu_invalid_wreg64(struct amdgpu_device *adev, uint32_t reg, uint
 /**
  * amdgpu_block_invalid_rreg - dummy reg read function
  *
- * @adev: amdgpu_device pointer
+ * @adev: amdgpu device pointer
  * @block: offset of instance
  * @reg: offset of register
  *
@@ -880,7 +650,7 @@ static uint32_t amdgpu_block_invalid_rreg(struct amdgpu_device *adev,
 /**
  * amdgpu_block_invalid_wreg - dummy reg write function
  *
- * @adev: amdgpu_device pointer
+ * @adev: amdgpu device pointer
  * @block: offset of instance
  * @reg: offset of register
  * @v: value to write to the register
@@ -897,24 +667,10 @@ static void amdgpu_block_invalid_wreg(struct amdgpu_device *adev,
 	BUG();
 }
 
-/**
- * amdgpu_device_asic_init - Wrapper for atom asic_init
- *
- * @adev: amdgpu_device pointer
- *
- * Does any asic specific work and then calls atom asic init.
- */
-static int amdgpu_device_asic_init(struct amdgpu_device *adev)
-{
-	amdgpu_asic_pre_asic_init(adev);
-
-	return amdgpu_atom_asic_init(adev->mode_info.atom_context);
-}
-
 /**
  * amdgpu_device_vram_scratch_init - allocate the VRAM scratch page
  *
- * @adev: amdgpu_device pointer
+ * @adev: amdgpu device pointer
  *
  * Allocates a scratch page of VRAM for use by various things in the
  * driver.
@@ -931,7 +687,7 @@ static int amdgpu_device_vram_scratch_init(struct amdgpu_device *adev)
 /**
  * amdgpu_device_vram_scratch_fini - Free the VRAM scratch page
  *
- * @adev: amdgpu_device pointer
+ * @adev: amdgpu device pointer
  *
  * Frees the VRAM scratch page.
  */
@@ -992,18 +748,6 @@ void amdgpu_device_pci_config_reset(struct amdgpu_device *adev)
 	pci_write_config_dword(adev->pdev, 0x7c, AMDGPU_ASIC_RESET_DATA);
 }
 
-/**
- * amdgpu_device_pci_reset - reset the GPU using generic PCI means
- *
- * @adev: amdgpu_device pointer
- *
- * Resets the GPU using generic pci reset interfaces (FLR, SBR, etc.).
- */
-int amdgpu_device_pci_reset(struct amdgpu_device *adev)
-{
-	return pci_reset_function(adev->pdev);
-}
-
 /*
  * GPU doorbell aperture helpers function.
  */
@@ -1169,6 +913,7 @@ void amdgpu_device_wb_free(struct amdgpu_device *adev, u32 wb)
 		__clear_bit(wb, adev->wb.used);
 }
 
+#ifdef AMDKCL_ENABLE_RESIZE_FB_BAR
 /**
  * amdgpu_device_resize_fb_bar - try to resize FB BAR
  *
@@ -1180,7 +925,8 @@ void amdgpu_device_wb_free(struct amdgpu_device *adev, u32 wb)
  */
 int amdgpu_device_resize_fb_bar(struct amdgpu_device *adev)
 {
-	int rbar_size = pci_rebar_bytes_to_size(adev->gmc.real_vram_size);
+	u64 space_needed = roundup_pow_of_two(adev->gmc.real_vram_size);
+	u32 rbar_size = order_base_2(((space_needed >> 20) | 1)) - 1;
 	struct pci_bus *root;
 	struct resource *res;
 	unsigned i;
@@ -1191,11 +937,6 @@ int amdgpu_device_resize_fb_bar(struct amdgpu_device *adev)
 	if (amdgpu_sriov_vf(adev))
 		return 0;
 
-	/* skip if the bios has already enabled large BAR */
-	if (adev->gmc.real_vram_size &&
-	    (pci_resource_len(adev->pdev, 0) >= adev->gmc.real_vram_size))
-		return 0;
-
 	/* Check if the root BUS has 64bit memory resources */
 	root = adev->pdev->bus;
 	while (root->parent)
@@ -1211,10 +952,6 @@ int amdgpu_device_resize_fb_bar(struct amdgpu_device *adev)
 	if (!res)
 		return 0;
 
-	/* Limit the BAR size to what is available */
-	rbar_size = min(fls(pci_rebar_get_possible_sizes(adev->pdev, 0)) - 1,
-			rbar_size);
-
 	/* Disable memory decoding while we change the BAR addresses and size */
 	pci_read_config_word(adev->pdev, PCI_COMMAND, &cmd);
 	pci_write_config_word(adev->pdev, PCI_COMMAND,
@@ -1246,6 +983,7 @@ int amdgpu_device_resize_fb_bar(struct amdgpu_device *adev)
 
 	return 0;
 }
+#endif
 
 /*
  * GPU helpers function.
@@ -1286,10 +1024,6 @@ bool amdgpu_device_need_post(struct amdgpu_device *adev)
 		}
 	}
 
-	/* Don't post if we need to reset whole hive on init */
-	if (adev->gmc.xgmi.pending_reset)
-		return false;
-
 	if (adev->has_hw_reset) {
 		adev->has_hw_reset = false;
 		return true;
@@ -1415,40 +1149,33 @@ static void amdgpu_device_check_smu_prv_buffer_size(struct amdgpu_device *adev)
 	adev->pm.smu_prv_buffer_size = 0;
 }
 
-static int amdgpu_device_init_apu_flags(struct amdgpu_device *adev)
+/**
+ * amdgpu_device_enable_extra_fw_load - parse firmware which needs explicit loading
+ *
+ * @adev: amdgpu_device pointer
+ *
+ * Enable specific firmware loading if the user has enabled it via
+ * the module parameter load_extra_fw. This feature allows the driver
+ * to load specific firmware, which should be skipped under some circumstances
+ * like virtualized environments by default.
+ */
+static void amdgpu_device_enable_extra_fw_load(struct amdgpu_device *adev)
 {
-	if (!(adev->flags & AMD_IS_APU) ||
-	    adev->asic_type < CHIP_RAVEN)
-		return 0;
+	adev->virt.extra_fw = 0;
 
-	switch (adev->asic_type) {
-	case CHIP_RAVEN:
-		if (adev->pdev->device == 0x15dd)
-			adev->apu_flags |= AMD_APU_IS_RAVEN;
-		if (adev->pdev->device == 0x15d8)
-			adev->apu_flags |= AMD_APU_IS_PICASSO;
-		break;
-	case CHIP_RENOIR:
-		if ((adev->pdev->device == 0x1636) ||
-		    (adev->pdev->device == 0x164c))
-			adev->apu_flags |= AMD_APU_IS_RENOIR;
-		else
-			adev->apu_flags |= AMD_APU_IS_GREEN_SARDINE;
-		break;
-	case CHIP_VANGOGH:
-		adev->apu_flags |= AMD_APU_IS_VANGOGH;
-		break;
-	case CHIP_YELLOW_CARP:
-		break;
-	case CHIP_CYAN_SKILLFISH:
-		if (adev->pdev->device == 0x13FE)
-			adev->apu_flags |= AMD_APU_IS_CYAN_SKILLFISH2;
-		break;
-	default:
-		return -EINVAL;
-	}
+	if (amdgpu_load_extra_fw) {
+		char *fwstr, *fwstr_tmp, *fwname_tmp;
 
-	return 0;
+		fwstr = kstrdup(amdgpu_load_extra_fw, GFP_KERNEL);
+		fwstr_tmp = fwstr;
+		while (fwname_tmp = strsep(&fwstr_tmp, ",")) {
+			if (!strcmp("ta", fwname_tmp))
+				adev->virt.extra_fw |= AMDGPU_SRIOV_EXTRA_FW_PSP_TA;
+			else
+				DRM_WARN("Skip loading unknown FW type: %s\n", fwname_tmp);
+		}
+		kfree(fwstr);
+	}
 }
 
 /**
@@ -1492,16 +1219,6 @@ static int amdgpu_device_check_arguments(struct amdgpu_device *adev)
 		amdgpu_vm_fragment_size = -1;
 	}
 
-	if (amdgpu_sched_hw_submission < 2) {
-		dev_warn(adev->dev, "sched hw submission jobs (%d) must be at least 2\n",
-			 amdgpu_sched_hw_submission);
-		amdgpu_sched_hw_submission = 2;
-	} else if (!is_power_of_2(amdgpu_sched_hw_submission)) {
-		dev_warn(adev->dev, "sched hw submission jobs (%d) must be a power of 2\n",
-			 amdgpu_sched_hw_submission);
-		amdgpu_sched_hw_submission = roundup_pow_of_two(amdgpu_sched_hw_submission);
-	}
-
 	amdgpu_device_check_smu_prv_buffer_size(adev);
 
 	amdgpu_device_check_vm_size(adev);
@@ -1510,9 +1227,11 @@ static int amdgpu_device_check_arguments(struct amdgpu_device *adev)
 
 	adev->firmware.load_type = amdgpu_ucode_get_load_type(adev, amdgpu_fw_load_type);
 
-	amdgpu_gmc_tmz_set(adev);
+	amdgpu_device_enable_extra_fw_load(adev);
+
+	amdgpu_direct_gma_size = min(amdgpu_direct_gma_size, 96);
 
-	amdgpu_gmc_noretry_set(adev);
+	amdgpu_gmc_tmz_set(adev);
 
 	return 0;
 }
@@ -1526,36 +1245,37 @@ static int amdgpu_device_check_arguments(struct amdgpu_device *adev)
  * Callback for the switcheroo driver.  Suspends or resumes the
  * the asics before or after it is powered up using ACPI methods.
  */
-static void amdgpu_switcheroo_set_state(struct pci_dev *pdev,
-					enum vga_switcheroo_state state)
+static void amdgpu_switcheroo_set_state(struct pci_dev *pdev, enum vga_switcheroo_state state)
 {
 	struct drm_device *dev = pci_get_drvdata(pdev);
 	int r;
 
-	if (amdgpu_device_supports_px(dev) && state == VGA_SWITCHEROO_OFF)
+	if (amdgpu_device_supports_boco(dev) && state == VGA_SWITCHEROO_OFF)
 		return;
 
 	if (state == VGA_SWITCHEROO_ON) {
-		pr_info("switched on\n");
+		pr_info("amdgpu: switched on\n");
 		/* don't suspend or resume card normally */
 		dev->switch_power_state = DRM_SWITCH_POWER_CHANGING;
 
-		pci_set_power_state(pdev, PCI_D0);
-		amdgpu_device_load_pci_state(pdev);
-		r = pci_enable_device(pdev);
+		pci_set_power_state(dev->pdev, PCI_D0);
+		pci_restore_state(dev->pdev);
+		r = pci_enable_device(dev->pdev);
 		if (r)
 			DRM_WARN("pci_enable_device failed (%d)\n", r);
 		amdgpu_device_resume(dev, true);
 
 		dev->switch_power_state = DRM_SWITCH_POWER_ON;
+		drm_kms_helper_poll_enable(dev);
 	} else {
-		pr_info("switched off\n");
+		pr_info("amdgpu: switched off\n");
+		drm_kms_helper_poll_disable(dev);
 		dev->switch_power_state = DRM_SWITCH_POWER_CHANGING;
 		amdgpu_device_suspend(dev, true);
-		amdgpu_device_cache_pci_state(pdev);
+		pci_save_state(dev->pdev);
 		/* Shut down the device */
-		pci_disable_device(pdev);
-		pci_set_power_state(pdev, PCI_D3cold);
+		pci_disable_device(dev->pdev);
+		pci_set_power_state(dev->pdev, PCI_D3cold);
 		dev->switch_power_state = DRM_SWITCH_POWER_OFF;
 	}
 }
@@ -1578,7 +1298,7 @@ static bool amdgpu_switcheroo_can_switch(struct pci_dev *pdev)
 	* locking inversion with the driver load path. And the access here is
 	* completely racy anyway. So don't bother with locking for now.
 	*/
-	return atomic_read(&dev->open_count) == 0;
+	return dev->open_count == 0;
 }
 
 static const struct vga_switcheroo_client_ops amdgpu_switcheroo_ops = {
@@ -1793,19 +1513,6 @@ int amdgpu_device_ip_block_add(struct amdgpu_device *adev,
 	if (!ip_block_version)
 		return -EINVAL;
 
-	switch (ip_block_version->type) {
-	case AMD_IP_BLOCK_TYPE_VCN:
-		if (adev->harvest_ip_mask & AMD_HARVEST_IP_VCN_MASK)
-			return 0;
-		break;
-	case AMD_IP_BLOCK_TYPE_JPEG:
-		if (adev->harvest_ip_mask & AMD_HARVEST_IP_JPEG_MASK)
-			return 0;
-		break;
-	default:
-		break;
-	}
-
 	DRM_INFO("add ip block number %d <%s>\n", adev->num_ip_blocks,
 		  ip_block_version->funcs->name);
 
@@ -1831,7 +1538,8 @@ static void amdgpu_device_enable_virtual_display(struct amdgpu_device *adev)
 	adev->enable_virtual_display = false;
 
 	if (amdgpu_virtual_display) {
-		const char *pci_address_name = pci_name(adev->pdev);
+		struct drm_device *ddev = adev->ddev;
+		const char *pci_address_name = pci_name(ddev->pdev);
 		char *pciaddstr, *pciaddstr_tmp, *pciaddname_tmp, *pciaddname;
 
 		pciaddstr = kstrdup(amdgpu_virtual_display, GFP_KERNEL);
@@ -1883,25 +1591,22 @@ static void amdgpu_device_enable_virtual_display(struct amdgpu_device *adev)
 static int amdgpu_device_parse_gpu_info_fw(struct amdgpu_device *adev)
 {
 	const char *chip_name;
-	char fw_name[40];
+	char fw_name[30];
 	int err;
 	const struct gpu_info_firmware_header_v1_0 *hdr;
 
 	adev->firmware.gpu_info_fw = NULL;
 
-	if (adev->mman.discovery_bin) {
-		amdgpu_discovery_get_gfx_info(adev);
-
-		/*
-		 * FIXME: The bounding box is still needed by Navi12, so
-		 * temporarily read it from gpu_info firmware. Should be droped
-		 * when DAL no longer needs it.
-		 */
-		if (adev->asic_type != CHIP_NAVI12)
-			return 0;
-	}
-
 	switch (adev->asic_type) {
+	case CHIP_TOPAZ:
+	case CHIP_TONGA:
+	case CHIP_FIJI:
+	case CHIP_POLARIS10:
+	case CHIP_POLARIS11:
+	case CHIP_POLARIS12:
+	case CHIP_VEGAM:
+	case CHIP_CARRIZO:
+	case CHIP_STONEY:
 #ifdef CONFIG_DRM_AMDGPU_SI
 	case CHIP_VERDE:
 	case CHIP_TAHITI:
@@ -1916,21 +1621,7 @@ static int amdgpu_device_parse_gpu_info_fw(struct amdgpu_device *adev)
 	case CHIP_KABINI:
 	case CHIP_MULLINS:
 #endif
-	case CHIP_TOPAZ:
-	case CHIP_TONGA:
-	case CHIP_FIJI:
-	case CHIP_POLARIS10:
-	case CHIP_POLARIS11:
-	case CHIP_POLARIS12:
-	case CHIP_VEGAM:
-	case CHIP_CARRIZO:
-	case CHIP_STONEY:
 	case CHIP_VEGA20:
-	case CHIP_ALDEBARAN:
-	case CHIP_SIENNA_CICHLID:
-	case CHIP_NAVY_FLOUNDER:
-	case CHIP_DIMGREY_CAVEFISH:
-	case CHIP_BEIGE_GOBY:
 	default:
 		return 0;
 	case CHIP_VEGA10:
@@ -1940,9 +1631,9 @@ static int amdgpu_device_parse_gpu_info_fw(struct amdgpu_device *adev)
 		chip_name = "vega12";
 		break;
 	case CHIP_RAVEN:
-		if (adev->apu_flags & AMD_APU_IS_RAVEN2)
+		if (adev->rev_id >= 8)
 			chip_name = "raven2";
-		else if (adev->apu_flags & AMD_APU_IS_PICASSO)
+		else if (adev->pdev->device == 0x15d8)
 			chip_name = "picasso";
 		else
 			chip_name = "raven";
@@ -1951,10 +1642,7 @@ static int amdgpu_device_parse_gpu_info_fw(struct amdgpu_device *adev)
 		chip_name = "arcturus";
 		break;
 	case CHIP_RENOIR:
-		if (adev->apu_flags & AMD_APU_IS_RENOIR)
-			chip_name = "renoir";
-		else
-			chip_name = "green_sardine";
+		chip_name = "renoir";
 		break;
 	case CHIP_NAVI10:
 		chip_name = "navi10";
@@ -1965,12 +1653,6 @@ static int amdgpu_device_parse_gpu_info_fw(struct amdgpu_device *adev)
 	case CHIP_NAVI12:
 		chip_name = "navi12";
 		break;
-	case CHIP_VANGOGH:
-		chip_name = "vangogh";
-		break;
-	case CHIP_YELLOW_CARP:
-		chip_name = "yellow_carp";
-		break;
 	}
 
 	snprintf(fw_name, sizeof(fw_name), "amdgpu/%s_gpu_info.bin", chip_name);
@@ -1999,10 +1681,7 @@ static int amdgpu_device_parse_gpu_info_fw(struct amdgpu_device *adev)
 			(const struct gpu_info_firmware_v1_0 *)(adev->firmware.gpu_info_fw->data +
 								le32_to_cpu(hdr->header.ucode_array_offset_bytes));
 
-		/*
-		 * Should be droped when DAL no longer needs it.
-		 */
-		if (adev->asic_type == CHIP_NAVI12)
+		if (amdgpu_discovery && adev->asic_type >= CHIP_NAVI10)
 			goto parse_soc_bounding_box;
 
 		adev->gfx.config.max_shader_engines = le32_to_cpu(gpu_info_fw->gc_num_se);
@@ -2034,9 +1713,10 @@ static int amdgpu_device_parse_gpu_info_fw(struct amdgpu_device *adev)
 		}
 
 parse_soc_bounding_box:
+#ifdef CONFIG_DRM_AMD_DC_DCN2_0
 		/*
 		 * soc bounding box info is not integrated in disocovery table,
-		 * we always need to parse it from gpu info firmware if needed.
+		 * we always need to parse it from gpu info firmware.
 		 */
 		if (hdr->version_minor == 2) {
 			const struct gpu_info_firmware_v1_2 *gpu_info_fw =
@@ -2044,6 +1724,7 @@ static int amdgpu_device_parse_gpu_info_fw(struct amdgpu_device *adev)
 									le32_to_cpu(hdr->header.ucode_array_offset_bytes));
 			adev->dm.soc_bounding_box = &gpu_info_fw->soc_bounding_box;
 		}
+#endif
 		break;
 	}
 	default:
@@ -2072,13 +1753,25 @@ static int amdgpu_device_ip_early_init(struct amdgpu_device *adev)
 
 	amdgpu_device_enable_virtual_display(adev);
 
-	if (amdgpu_sriov_vf(adev)) {
-		r = amdgpu_virt_request_full_gpu(adev, true);
+	switch (adev->asic_type) {
+	case CHIP_TOPAZ:
+	case CHIP_TONGA:
+	case CHIP_FIJI:
+	case CHIP_POLARIS10:
+	case CHIP_POLARIS11:
+	case CHIP_POLARIS12:
+	case CHIP_VEGAM:
+	case CHIP_CARRIZO:
+	case CHIP_STONEY:
+		if (adev->asic_type == CHIP_CARRIZO || adev->asic_type == CHIP_STONEY)
+			adev->family = AMDGPU_FAMILY_CZ;
+		else
+			adev->family = AMDGPU_FAMILY_VI;
+
+		r = vi_set_ip_blocks(adev);
 		if (r)
 			return r;
-	}
-
-	switch (adev->asic_type) {
+		break;
 #ifdef CONFIG_DRM_AMDGPU_SI
 	case CHIP_VERDE:
 	case CHIP_TAHITI:
@@ -2097,42 +1790,24 @@ static int amdgpu_device_ip_early_init(struct amdgpu_device *adev)
 	case CHIP_KAVERI:
 	case CHIP_KABINI:
 	case CHIP_MULLINS:
-		if (adev->flags & AMD_IS_APU)
-			adev->family = AMDGPU_FAMILY_KV;
-		else
+		if ((adev->asic_type == CHIP_BONAIRE) || (adev->asic_type == CHIP_HAWAII))
 			adev->family = AMDGPU_FAMILY_CI;
+		else
+			adev->family = AMDGPU_FAMILY_KV;
 
 		r = cik_set_ip_blocks(adev);
 		if (r)
 			return r;
 		break;
 #endif
-	case CHIP_TOPAZ:
-	case CHIP_TONGA:
-	case CHIP_FIJI:
-	case CHIP_POLARIS10:
-	case CHIP_POLARIS11:
-	case CHIP_POLARIS12:
-	case CHIP_VEGAM:
-	case CHIP_CARRIZO:
-	case CHIP_STONEY:
-		if (adev->flags & AMD_IS_APU)
-			adev->family = AMDGPU_FAMILY_CZ;
-		else
-			adev->family = AMDGPU_FAMILY_VI;
-
-		r = vi_set_ip_blocks(adev);
-		if (r)
-			return r;
-		break;
 	case CHIP_VEGA10:
 	case CHIP_VEGA12:
 	case CHIP_VEGA20:
 	case CHIP_RAVEN:
 	case CHIP_ARCTURUS:
 	case CHIP_RENOIR:
-	case CHIP_ALDEBARAN:
-		if (adev->flags & AMD_IS_APU)
+		if (adev->asic_type == CHIP_RAVEN ||
+		    adev->asic_type == CHIP_RENOIR)
 			adev->family = AMDGPU_FAMILY_RV;
 		else
 			adev->family = AMDGPU_FAMILY_AI;
@@ -2144,19 +1819,7 @@ static int amdgpu_device_ip_early_init(struct amdgpu_device *adev)
 	case  CHIP_NAVI10:
 	case  CHIP_NAVI14:
 	case  CHIP_NAVI12:
-	case  CHIP_SIENNA_CICHLID:
-	case  CHIP_NAVY_FLOUNDER:
-	case  CHIP_DIMGREY_CAVEFISH:
-	case  CHIP_BEIGE_GOBY:
-	case CHIP_VANGOGH:
-	case CHIP_YELLOW_CARP:
-	case CHIP_CYAN_SKILLFISH:
-		if (adev->asic_type == CHIP_VANGOGH)
-			adev->family = AMDGPU_FAMILY_VGH;
-		else if (adev->asic_type == CHIP_YELLOW_CARP)
-			adev->family = AMDGPU_FAMILY_YC;
-		else
-			adev->family = AMDGPU_FAMILY_NV;
+		adev->family = AMDGPU_FAMILY_NV;
 
 		r = nv_set_ip_blocks(adev);
 		if (r)
@@ -2167,13 +1830,47 @@ static int amdgpu_device_ip_early_init(struct amdgpu_device *adev)
 		return -EINVAL;
 	}
 
+	r = amdgpu_device_parse_gpu_info_fw(adev);
+	if (r)
+		return r;
+
+	if (amdgpu_discovery && adev->asic_type >= CHIP_NAVI10)
+		amdgpu_discovery_get_gfx_info(adev);
+
 	amdgpu_amdkfd_device_probe(adev);
 
+	if (amdgpu_sriov_vf(adev)) {
+		/* handle vbios stuff prior full access mode for new handshake */
+		if (adev->virt.req_init_data_ver == 1) {
+			if (!amdgpu_get_bios(adev)) {
+				DRM_ERROR("failed to get vbios\n");
+				return -EINVAL;
+			}
+
+			r = amdgpu_atombios_init(adev);
+			if (r) {
+				dev_err(adev->dev, "amdgpu_atombios_init failed\n");
+				amdgpu_vf_error_put(adev, AMDGIM_ERROR_VF_ATOMBIOS_INIT_FAIL, 0, 0);
+				return r;
+			}
+		}
+	}
+
+	/*get pf2vf msg info at it's earliest time*/
+	if (amdgpu_sriov_vf(adev))
+		amdgpu_virt_init_data_exchange(adev);
+
+	/* we need to send REQ_GPU here for legacy handshaker otherwise the vbios
+	 * will not be prepared by host for this VF */
+	if (amdgpu_sriov_vf(adev) && adev->virt.req_init_data_ver < 1) {
+		r = amdgpu_virt_request_full_gpu(adev, true);
+		if (r)
+			return r;
+	}
+
 	adev->pm.pp_feature = amdgpu_pp_feature_mask;
 	if (amdgpu_sriov_vf(adev) || sched_policy == KFD_SCHED_POLICY_NO_HWS)
 		adev->pm.pp_feature &= ~PP_GFXOFF_MASK;
-	if (amdgpu_sriov_vf(adev) && adev->asic_type == CHIP_SIENNA_CICHLID)
-		adev->pm.pp_feature &= ~PP_OVERDRIVE_MASK;
 
 	for (i = 0; i < adev->num_ip_blocks; i++) {
 		if ((amdgpu_ip_block_mask & (1 << i)) == 0) {
@@ -2198,9 +1895,9 @@ static int amdgpu_device_ip_early_init(struct amdgpu_device *adev)
 		}
 		/* get the vbios after the asic_funcs are set up */
 		if (adev->ip_blocks[i].version->type == AMD_IP_BLOCK_TYPE_COMMON) {
-			r = amdgpu_device_parse_gpu_info_fw(adev);
-			if (r)
-				return r;
+			/* skip vbios handling for new handshake */
+			if (amdgpu_sriov_vf(adev) && adev->virt.req_init_data_ver == 1)
+				continue;
 
 			/* Read BIOS */
 			if (!amdgpu_get_bios(adev))
@@ -2212,16 +1909,16 @@ static int amdgpu_device_ip_early_init(struct amdgpu_device *adev)
 				amdgpu_vf_error_put(adev, AMDGIM_ERROR_VF_ATOMBIOS_INIT_FAIL, 0, 0);
 				return r;
 			}
-
-			/*get pf2vf msg info at it's earliest time*/
-			if (amdgpu_sriov_vf(adev))
-				amdgpu_virt_init_data_exchange(adev);
-
 		}
 	}
 
-	adev->cg_flags &= amdgpu_cg_mask;
-	adev->pg_flags &= amdgpu_pg_mask;
+	if (amdgpu_sriov_vf(adev)) {
+		adev->cg_flags &= amdgpu_cg_mask;
+		adev->pg_flags &= amdgpu_pg_mask;
+	} else {
+		adev->cg_flags &= 0xffffffff;
+		adev->pg_flags &= 0xffffffff;
+	}
 
 	return 0;
 }
@@ -2283,14 +1980,11 @@ static int amdgpu_device_fw_loading(struct amdgpu_device *adev)
 			if (adev->ip_blocks[i].version->type != AMD_IP_BLOCK_TYPE_PSP)
 				continue;
 
-			if (!adev->ip_blocks[i].status.sw)
-				continue;
-
 			/* no need to do the fw loading again if already done*/
 			if (adev->ip_blocks[i].status.hw == true)
 				break;
 
-			if (amdgpu_in_reset(adev) || adev->in_suspend) {
+			if (adev->in_gpu_reset || adev->in_suspend) {
 				r = adev->ip_blocks[i].version->funcs->resume(adev);
 				if (r) {
 					DRM_ERROR("resume of IP block <%s> failed %d\n",
@@ -2336,6 +2030,12 @@ static int amdgpu_device_ip_init(struct amdgpu_device *adev)
 	if (r)
 		return r;
 
+	if (amdgpu_sriov_vf(adev) && adev->virt.req_init_data_ver > 0) {
+		r = amdgpu_virt_request_full_gpu(adev, true);
+		if (r)
+			return -EAGAIN;
+	}
+
 	for (i = 0; i < adev->num_ip_blocks; i++) {
 		if (!adev->ip_blocks[i].status.valid)
 			continue;
@@ -2410,26 +2110,17 @@ static int amdgpu_device_ip_init(struct amdgpu_device *adev)
 	 * it should be called after amdgpu_device_ip_hw_init_phase2  since
 	 * for some ASICs the RAS EEPROM code relies on SMU fully functioning
 	 * for I2C communication which only true at this point.
-	 *
-	 * amdgpu_ras_recovery_init may fail, but the upper only cares the
-	 * failure from bad gpu situation and stop amdgpu init process
-	 * accordingly. For other failed cases, it will still release all
-	 * the resource and print error message, rather than returning one
-	 * negative value to upper level.
+	 * recovery_init may fail, but it can free all resources allocated by
+	 * itself and its failure should not stop amdgpu init process.
 	 *
 	 * Note: theoretically, this should be called before all vram allocations
 	 * to protect retired page from abusing
 	 */
-	r = amdgpu_ras_recovery_init(adev);
-	if (r)
-		goto init_failed;
+	amdgpu_ras_recovery_init(adev);
 
 	if (adev->gmc.xgmi.num_physical_nodes > 1)
 		amdgpu_xgmi_add_device(adev);
-
-	/* Don't init kfd if whole hive need to be reset during init */
-	if (!adev->gmc.xgmi.pending_reset)
-		amdgpu_amdkfd_device_init(adev);
+	amdgpu_amdkfd_device_init(adev);
 
 	amdgpu_fru_get_product_info(adev);
 
@@ -2466,24 +2157,8 @@ static void amdgpu_device_fill_reset_magic(struct amdgpu_device *adev)
  */
 static bool amdgpu_device_check_vram_lost(struct amdgpu_device *adev)
 {
-	if (memcmp(adev->gart.ptr, adev->reset_magic,
-			AMDGPU_RESET_MAGIC_NUM))
-		return true;
-
-	if (!amdgpu_in_reset(adev))
-		return false;
-
-	/*
-	 * For all ASICs with baco/mode1 reset, the VRAM is
-	 * always assumed to be lost.
-	 */
-	switch (amdgpu_asic_reset_method(adev)) {
-	case AMD_RESET_METHOD_BACO:
-	case AMD_RESET_METHOD_MODE1:
-		return true;
-	default:
-		return false;
-	}
+	return !!memcmp(adev->gart.ptr, adev->reset_magic,
+			AMDGPU_RESET_MAGIC_NUM);
 }
 
 /**
@@ -2499,8 +2174,8 @@ static bool amdgpu_device_check_vram_lost(struct amdgpu_device *adev)
  * Returns 0 on success, negative error code on failure.
  */
 
-int amdgpu_device_set_cg_state(struct amdgpu_device *adev,
-			       enum amd_clockgating_state state)
+static int amdgpu_device_set_cg_state(struct amdgpu_device *adev,
+						enum amd_clockgating_state state)
 {
 	int i, j, r;
 
@@ -2511,10 +2186,6 @@ int amdgpu_device_set_cg_state(struct amdgpu_device *adev,
 		i = state == AMD_CG_STATE_GATE ? j : adev->num_ip_blocks - j - 1;
 		if (!adev->ip_blocks[i].status.late_initialized)
 			continue;
-		/* skip CG for GFX on S0ix */
-		if (adev->in_s0ix &&
-		    adev->ip_blocks[i].version->type == AMD_IP_BLOCK_TYPE_GFX)
-			continue;
 		/* skip CG for VCE/UVD, it's handled specially */
 		if (adev->ip_blocks[i].version->type != AMD_IP_BLOCK_TYPE_UVD &&
 		    adev->ip_blocks[i].version->type != AMD_IP_BLOCK_TYPE_VCE &&
@@ -2535,8 +2206,7 @@ int amdgpu_device_set_cg_state(struct amdgpu_device *adev,
 	return 0;
 }
 
-int amdgpu_device_set_pg_state(struct amdgpu_device *adev,
-			       enum amd_powergating_state state)
+static int amdgpu_device_set_pg_state(struct amdgpu_device *adev, enum amd_powergating_state state)
 {
 	int i, j, r;
 
@@ -2547,10 +2217,6 @@ int amdgpu_device_set_pg_state(struct amdgpu_device *adev,
 		i = state == AMD_PG_STATE_GATE ? j : adev->num_ip_blocks - j - 1;
 		if (!adev->ip_blocks[i].status.late_initialized)
 			continue;
-		/* skip PG for GFX on S0ix */
-		if (adev->in_s0ix &&
-		    adev->ip_blocks[i].version->type == AMD_IP_BLOCK_TYPE_GFX)
-			continue;
 		/* skip CG for VCE/UVD, it's handled specially */
 		if (adev->ip_blocks[i].version->type != AMD_IP_BLOCK_TYPE_UVD &&
 		    adev->ip_blocks[i].version->type != AMD_IP_BLOCK_TYPE_VCE &&
@@ -2590,7 +2256,9 @@ static int amdgpu_device_enable_mgpu_fan_boost(void)
 		gpu_ins = &(mgpu_info.gpu_ins[i]);
 		adev = gpu_ins->adev;
 		if (!(adev->flags & AMD_IS_APU) &&
-		    !gpu_ins->mgpu_fan_enabled) {
+		    !gpu_ins->mgpu_fan_enabled &&
+		    adev->powerplay.pp_funcs &&
+		    adev->powerplay.pp_funcs->enable_mgpu_fan_boost) {
 			ret = amdgpu_dpm_enable_mgpu_fan_boost(adev);
 			if (ret)
 				break;
@@ -2636,8 +2304,6 @@ static int amdgpu_device_ip_late_init(struct amdgpu_device *adev)
 		adev->ip_blocks[i].status.late_initialized = true;
 	}
 
-	amdgpu_ras_set_error_query_ready(adev, true);
-
 	amdgpu_device_set_cg_state(adev, AMD_CG_STATE_GATE);
 	amdgpu_device_set_pg_state(adev, AMD_PG_STATE_GATE);
 
@@ -2647,11 +2313,6 @@ static int amdgpu_device_ip_late_init(struct amdgpu_device *adev)
 	if (r)
 		DRM_ERROR("enable mgpu fan boost failed (%d).\n", r);
 
-	/* For XGMI + passthrough configuration on arcturus, enable light SBR */
-	if (adev->asic_type == CHIP_ARCTURUS &&
-	    amdgpu_passthrough(adev) &&
-	    adev->gmc.xgmi.num_physical_nodes > 1)
-		smu_set_light_sbr(&adev->smu, true);
 
 	if (adev->gmc.xgmi.num_physical_nodes > 1) {
 		mutex_lock(&mgpu_info.mutex);
@@ -2675,8 +2336,7 @@ static int amdgpu_device_ip_late_init(struct amdgpu_device *adev)
 				if (gpu_instance->adev->flags & AMD_IS_APU)
 					continue;
 
-				r = amdgpu_xgmi_set_pstate(gpu_instance->adev,
-						AMDGPU_XGMI_PSTATE_MIN);
+				r = amdgpu_xgmi_set_pstate(gpu_instance->adev, 0);
 				if (r) {
 					DRM_ERROR("pstate setting failed (%d).\n", r);
 					break;
@@ -2690,59 +2350,6 @@ static int amdgpu_device_ip_late_init(struct amdgpu_device *adev)
 	return 0;
 }
 
-static int amdgpu_device_ip_fini_early(struct amdgpu_device *adev)
-{
-	int i, r;
-
-	for (i = 0; i < adev->num_ip_blocks; i++) {
-		if (!adev->ip_blocks[i].version->funcs->early_fini)
-			continue;
-
-		r = adev->ip_blocks[i].version->funcs->early_fini((void *)adev);
-		if (r) {
-			DRM_DEBUG("early_fini of IP block <%s> failed %d\n",
-				  adev->ip_blocks[i].version->funcs->name, r);
-		}
-	}
-
-	amdgpu_amdkfd_suspend(adev, false);
-
-	amdgpu_device_set_pg_state(adev, AMD_PG_STATE_UNGATE);
-	amdgpu_device_set_cg_state(adev, AMD_CG_STATE_UNGATE);
-
-	/* need to disable SMC first */
-	for (i = 0; i < adev->num_ip_blocks; i++) {
-		if (!adev->ip_blocks[i].status.hw)
-			continue;
-		if (adev->ip_blocks[i].version->type == AMD_IP_BLOCK_TYPE_SMC) {
-			r = adev->ip_blocks[i].version->funcs->hw_fini((void *)adev);
-			/* XXX handle errors */
-			if (r) {
-				DRM_DEBUG("hw_fini of IP block <%s> failed %d\n",
-					  adev->ip_blocks[i].version->funcs->name, r);
-			}
-			adev->ip_blocks[i].status.hw = false;
-			break;
-		}
-	}
-
-	for (i = adev->num_ip_blocks - 1; i >= 0; i--) {
-		if (!adev->ip_blocks[i].status.hw)
-			continue;
-
-		r = adev->ip_blocks[i].version->funcs->hw_fini((void *)adev);
-		/* XXX handle errors */
-		if (r) {
-			DRM_DEBUG("hw_fini of IP block <%s> failed %d\n",
-				  adev->ip_blocks[i].version->funcs->name, r);
-		}
-
-		adev->ip_blocks[i].status.hw = false;
-	}
-
-	return 0;
-}
-
 /**
  * amdgpu_device_ip_fini - run fini for hardware IPs
  *
@@ -2754,7 +2361,7 @@ static int amdgpu_device_ip_fini_early(struct amdgpu_device *adev)
  * and sw_fini tears down any software state associated with each IP.
  * Returns 0 on success, negative error code on failure.
  */
-static int amdgpu_device_ip_fini(struct amdgpu_device *adev)
+static int amdgpu_device_ip_fini(struct amdgpu_device *adev, int skip_hw)
 {
 	int i, r;
 
@@ -2766,7 +2373,43 @@ static int amdgpu_device_ip_fini(struct amdgpu_device *adev)
 	if (adev->gmc.xgmi.num_physical_nodes > 1)
 		amdgpu_xgmi_remove_device(adev);
 
-	amdgpu_amdkfd_device_fini_sw(adev);
+	if (!skip_hw)
+		amdgpu_amdkfd_device_fini(adev);
+
+	amdgpu_device_set_pg_state(adev, AMD_PG_STATE_UNGATE);
+	amdgpu_device_set_cg_state(adev, AMD_CG_STATE_UNGATE);
+
+	if (!skip_hw) {
+		/* need to disable SMC first */
+		for (i = 0; i < adev->num_ip_blocks; i++) {
+			if (!adev->ip_blocks[i].status.hw)
+				continue;
+			if (adev->ip_blocks[i].version->type == AMD_IP_BLOCK_TYPE_SMC) {
+				r = adev->ip_blocks[i].version->funcs->hw_fini((void *)adev);
+				/* XXX handle errors */
+				if (r) {
+					DRM_DEBUG("hw_fini of IP block <%s> failed %d\n",
+							adev->ip_blocks[i].version->funcs->name, r);
+				}
+				adev->ip_blocks[i].status.hw = false;
+				break;
+			}
+		}
+
+		for (i = adev->num_ip_blocks - 1; i >= 0; i--) {
+			if (!adev->ip_blocks[i].status.hw)
+				continue;
+
+			r = adev->ip_blocks[i].version->funcs->hw_fini((void *)adev);
+			/* XXX handle errors */
+			if (r) {
+				DRM_DEBUG("hw_fini of IP block <%s> failed %d\n",
+						adev->ip_blocks[i].version->funcs->name, r);
+			}
+
+			adev->ip_blocks[i].status.hw = false;
+		}
+	}
 
 	for (i = adev->num_ip_blocks - 1; i >= 0; i--) {
 		if (!adev->ip_blocks[i].status.sw)
@@ -2857,21 +2500,18 @@ static int amdgpu_device_ip_suspend_phase1(struct amdgpu_device *adev)
 	for (i = adev->num_ip_blocks - 1; i >= 0; i--) {
 		if (!adev->ip_blocks[i].status.valid)
 			continue;
-
 		/* displays are handled separately */
-		if (adev->ip_blocks[i].version->type != AMD_IP_BLOCK_TYPE_DCE)
-			continue;
-
-		/* XXX handle errors */
-		r = adev->ip_blocks[i].version->funcs->suspend(adev);
-		/* XXX handle errors */
-		if (r) {
-			DRM_ERROR("suspend of IP block <%s> failed %d\n",
-				  adev->ip_blocks[i].version->funcs->name, r);
-			return r;
+		if (adev->ip_blocks[i].version->type == AMD_IP_BLOCK_TYPE_DCE) {
+			/* XXX handle errors */
+			r = adev->ip_blocks[i].version->funcs->suspend(adev);
+			/* XXX handle errors */
+			if (r) {
+				DRM_ERROR("suspend of IP block <%s> failed %d\n",
+					  adev->ip_blocks[i].version->funcs->name, r);
+				return r;
+			}
+			adev->ip_blocks[i].status.hw = false;
 		}
-
-		adev->ip_blocks[i].status.hw = false;
 	}
 
 	return 0;
@@ -2892,9 +2532,6 @@ static int amdgpu_device_ip_suspend_phase2(struct amdgpu_device *adev)
 {
 	int i, r;
 
-	if (adev->in_s0ix)
-		amdgpu_gfx_state_change_set(adev, sGpuChangeState_D3Entry);
-
 	for (i = adev->num_ip_blocks - 1; i >= 0; i--) {
 		if (!adev->ip_blocks[i].status.valid)
 			continue;
@@ -2907,27 +2544,6 @@ static int amdgpu_device_ip_suspend_phase2(struct amdgpu_device *adev)
 			adev->ip_blocks[i].status.hw = false;
 			continue;
 		}
-
-		/* skip unnecessary suspend if we do not initialize them yet */
-		if (adev->gmc.xgmi.pending_reset &&
-		    !(adev->ip_blocks[i].version->type == AMD_IP_BLOCK_TYPE_GMC ||
-		      adev->ip_blocks[i].version->type == AMD_IP_BLOCK_TYPE_SMC ||
-		      adev->ip_blocks[i].version->type == AMD_IP_BLOCK_TYPE_COMMON ||
-		      adev->ip_blocks[i].version->type == AMD_IP_BLOCK_TYPE_IH)) {
-			adev->ip_blocks[i].status.hw = false;
-			continue;
-		}
-
-		/* skip suspend of gfx and psp for S0ix
-		 * gfx is in gfxoff state, so on resume it will exit gfxoff just
-		 * like at runtime. PSP is also part of the always on hardware
-		 * so no need to suspend it.
-		 */
-		if (adev->in_s0ix &&
-		    (adev->ip_blocks[i].version->type == AMD_IP_BLOCK_TYPE_PSP ||
-		     adev->ip_blocks[i].version->type == AMD_IP_BLOCK_TYPE_GFX))
-			continue;
-
 		/* XXX handle errors */
 		r = adev->ip_blocks[i].version->funcs->suspend(adev);
 		/* XXX handle errors */
@@ -2947,6 +2563,7 @@ static int amdgpu_device_ip_suspend_phase2(struct amdgpu_device *adev)
 				}
 			}
 		}
+		adev->ip_blocks[i].status.hw = false;
 	}
 
 	return 0;
@@ -2965,17 +2582,22 @@ static int amdgpu_device_ip_suspend_phase2(struct amdgpu_device *adev)
  */
 int amdgpu_device_ip_suspend(struct amdgpu_device *adev)
 {
-	int r;
+	int r = 0;
+	int skip_hw = 0;
 
-	if (amdgpu_sriov_vf(adev)) {
-		amdgpu_virt_fini_data_exchange(adev);
-		amdgpu_virt_request_full_gpu(adev, false);
-	}
+	if (amdgpu_sriov_vf(adev))
+		skip_hw = amdgpu_virt_request_full_gpu(adev, false);
 
-	r = amdgpu_device_ip_suspend_phase1(adev);
-	if (r)
-		return r;
-	r = amdgpu_device_ip_suspend_phase2(adev);
+	/* In case amdgpu_virt_request_full_gpu failed and vm cannot get
+	 * full access, we should skip touching hw and let poweroff continue
+	 */
+
+	if (!skip_hw) {
+		r = amdgpu_device_ip_suspend_phase1(adev);
+		if (r)
+			return r;
+		r = amdgpu_device_ip_suspend_phase2(adev);
+	}
 
 	if (amdgpu_sriov_vf(adev))
 		amdgpu_virt_release_full_gpu(adev, false);
@@ -2997,7 +2619,6 @@ static int amdgpu_device_ip_reinit_early_sriov(struct amdgpu_device *adev)
 	for (i = 0; i < adev->num_ip_blocks; i++) {
 		int j;
 		struct amdgpu_ip_block *block;
-
 		block = &adev->ip_blocks[i];
 		block->status.hw = false;
 
@@ -3172,7 +2793,7 @@ static void amdgpu_device_detect_sriov_bios(struct amdgpu_device *adev)
 {
 	if (amdgpu_sriov_vf(adev)) {
 		if (adev->is_atom_fw) {
-			if (amdgpu_atomfirmware_gpu_virtualization_supported(adev))
+			if (amdgpu_atomfirmware_gpu_supports_virtualization(adev))
 				adev->virt.caps |= AMDGPU_SRIOV_CAPS_SRIOV_VBIOS;
 		} else {
 			if (amdgpu_atombios_has_gpu_virtualization_table(adev))
@@ -3196,12 +2817,6 @@ bool amdgpu_device_asic_has_dc_support(enum amd_asic_type asic_type)
 {
 	switch (asic_type) {
 #if defined(CONFIG_DRM_AMD_DC)
-#if defined(CONFIG_DRM_AMD_DC_SI)
-	case CHIP_TAHITI:
-	case CHIP_PITCAIRN:
-	case CHIP_VERDE:
-	case CHIP_OLAND:
-#endif
 	case CHIP_BONAIRE:
 	case CHIP_KAVERI:
 	case CHIP_KABINI:
@@ -3226,24 +2841,22 @@ bool amdgpu_device_asic_has_dc_support(enum amd_asic_type asic_type)
 	case CHIP_VEGA10:
 	case CHIP_VEGA12:
 	case CHIP_VEGA20:
-#if defined(CONFIG_DRM_AMD_DC_DCN)
+#if defined(CONFIG_DRM_AMD_DC_DCN1_0)
 	case CHIP_RAVEN:
+#endif
+#if defined(CONFIG_DRM_AMD_DC_DCN2_0)
 	case CHIP_NAVI10:
 	case CHIP_NAVI14:
 	case CHIP_NAVI12:
+#endif
+#if defined(CONFIG_DRM_AMD_DC_DCN2_1)
 	case CHIP_RENOIR:
-	case CHIP_SIENNA_CICHLID:
-	case CHIP_NAVY_FLOUNDER:
-	case CHIP_DIMGREY_CAVEFISH:
-	case CHIP_BEIGE_GOBY:
-	case CHIP_VANGOGH:
-	case CHIP_YELLOW_CARP:
 #endif
 		return amdgpu_dc != 0;
 #endif
 	default:
 		if (amdgpu_dc > 0)
-			DRM_INFO_ONCE("Display Core has been requested via kernel parameter "
+			DRM_INFO("Display Core has been requested via kernel parameter "
 					 "but isn't supported by ASIC, ignoring\n");
 		return false;
 	}
@@ -3252,25 +2865,24 @@ bool amdgpu_device_asic_has_dc_support(enum amd_asic_type asic_type)
 /**
  * amdgpu_device_has_dc_support - check if dc is supported
  *
- * @adev: amdgpu_device pointer
+ * @adev: amdgpu_device_pointer
  *
  * Returns true for supported, false for not supported
  */
 bool amdgpu_device_has_dc_support(struct amdgpu_device *adev)
 {
-	if (amdgpu_sriov_vf(adev) || 
-	    adev->enable_virtual_display ||
-	    (adev->harvest_ip_mask & AMD_HARVEST_IP_DMU_MASK))
+	if (adev->enable_virtual_display)
 		return false;
 
 	return amdgpu_device_asic_has_dc_support(adev->asic_type);
 }
 
+
 static void amdgpu_device_xgmi_reset_func(struct work_struct *__work)
 {
 	struct amdgpu_device *adev =
 		container_of(__work, struct amdgpu_device, xgmi_reset_work);
-	struct amdgpu_hive_info *hive = amdgpu_get_xgmi_hive(adev);
+	struct amdgpu_hive_info *hive = amdgpu_get_xgmi_hive(adev, 0);
 
 	/* It's a bug to not have a hive within this function */
 	if (WARN_ON(!hive))
@@ -3285,20 +2897,19 @@ static void amdgpu_device_xgmi_reset_func(struct work_struct *__work)
 	if (amdgpu_asic_reset_method(adev) == AMD_RESET_METHOD_BACO) {
 
 		task_barrier_enter(&hive->tb);
-		adev->asic_reset_res = amdgpu_device_baco_enter(adev_to_drm(adev));
+		adev->asic_reset_res = amdgpu_device_baco_enter(adev->ddev);
 
 		if (adev->asic_reset_res)
 			goto fail;
 
 		task_barrier_exit(&hive->tb);
-		adev->asic_reset_res = amdgpu_device_baco_exit(adev_to_drm(adev));
+		adev->asic_reset_res = amdgpu_device_baco_exit(adev->ddev);
 
 		if (adev->asic_reset_res)
 			goto fail;
 
-		if (adev->mmhub.ras_funcs &&
-		    adev->mmhub.ras_funcs->reset_ras_error_count)
-			adev->mmhub.ras_funcs->reset_ras_error_count(adev);
+		if (adev->mmhub.funcs && adev->mmhub.funcs->reset_ras_error_count)
+			adev->mmhub.funcs->reset_ras_error_count(adev);
 	} else {
 
 		task_barrier_full(&hive->tb);
@@ -3308,8 +2919,7 @@ static void amdgpu_device_xgmi_reset_func(struct work_struct *__work)
 fail:
 	if (adev->asic_reset_res)
 		DRM_WARN("ASIC reset failed with error, %d for drm dev, %s",
-			 adev->asic_reset_res, adev_to_drm(adev)->unique);
-	amdgpu_put_xgmi_hive(hive);
+			 adev->asic_reset_res, adev->ddev->unique);
 }
 
 static int amdgpu_device_get_job_timeout_settings(struct amdgpu_device *adev)
@@ -3321,8 +2931,8 @@ static int amdgpu_device_get_job_timeout_settings(struct amdgpu_device *adev)
 	int ret = 0;
 
 	/*
-	 * By default timeout for non compute jobs is 10000
-	 * and 60000 for compute jobs.
+	 * By default timeout for non compute jobs is 10000.
+	 * And there is no timeout enforced on compute jobs.
 	 * In SR-IOV or passthrough mode, timeout for compute
 	 * jobs are 60000 by default.
 	 */
@@ -3331,8 +2941,10 @@ static int amdgpu_device_get_job_timeout_settings(struct amdgpu_device *adev)
 	if (amdgpu_sriov_vf(adev))
 		adev->compute_timeout = amdgpu_sriov_is_pp_one_vf(adev) ?
 					msecs_to_jiffies(60000) : msecs_to_jiffies(10000);
-	else
+	else if (amdgpu_passthrough(adev))
 		adev->compute_timeout =  msecs_to_jiffies(60000);
+	else
+		adev->compute_timeout = MAX_SCHEDULE_TIMEOUT;
 
 	if (strnlen(input, AMDGPU_MAX_TIMEOUT_PARAM_LENGTH)) {
 		while ((timeout_setting = strsep(&input, ",")) &&
@@ -3381,18 +2993,47 @@ static int amdgpu_device_get_job_timeout_settings(struct amdgpu_device *adev)
 	return ret;
 }
 
-static const struct attribute *amdgpu_dev_attributes[] = {
-	&dev_attr_product_name.attr,
-	&dev_attr_product_number.attr,
-	&dev_attr_serial_number.attr,
-	&dev_attr_pcie_replay_count.attr,
-	NULL
-};
+/**
+ *
+ * The amdgpu driver provides a sysfs API for providing driver version data.
+ */
+static ssize_t amdgpu_get_driver_version(struct device *dev,
+				      struct device_attribute *attr,
+				      char *buf)
+{
+	return snprintf(buf, PAGE_SIZE, "%s\n",
+#ifdef BUILD_NUM
+		__stringify(INTERNAL_VER)"."__stringify(BUILD_NUM));
+#else
+		__stringify(INTERNAL_VER));
+#endif
+}
+
+static DEVICE_ATTR(version, S_IRUGO, amdgpu_get_driver_version, NULL);
+
+static int amdgpu_version_sysfs_init(struct amdgpu_device *adev)
+{
+	int ret;
+
+	ret = device_create_file(adev->dev, &dev_attr_version);
+	if (ret) {
+		DRM_ERROR("failed to create device file for version\n");
+		return ret;
+	}
+	return 0;
+}
+
+static void amdgpu_version_sysfs_fini(struct amdgpu_device *adev)
+{
+	device_remove_file(adev->dev, &dev_attr_version);
+}
 
 /**
  * amdgpu_device_init - initialize the driver
  *
  * @adev: amdgpu_device pointer
+ * @ddev: drm dev pointer
+ * @pdev: pci dev pointer
  * @flags: driver flags
  *
  * Initializes the driver info and hw (all asics).
@@ -3400,15 +3041,18 @@ static const struct attribute *amdgpu_dev_attributes[] = {
  * Called at driver startup.
  */
 int amdgpu_device_init(struct amdgpu_device *adev,
+		       struct drm_device *ddev,
+		       struct pci_dev *pdev,
 		       uint32_t flags)
 {
-	struct drm_device *ddev = adev_to_drm(adev);
-	struct pci_dev *pdev = adev->pdev;
 	int r, i;
-	bool px = false;
+	bool boco = false;
 	u32 max_MBps;
 
 	adev->shutdown = false;
+	adev->dev = &pdev->dev;
+	adev->ddev = ddev;
+	adev->pdev = pdev;
 	adev->flags = flags;
 
 	if (amdgpu_force_asic_type >= 0 && amdgpu_force_asic_type < CHIP_LAST)
@@ -3427,7 +3071,6 @@ int amdgpu_device_init(struct amdgpu_device *adev,
 	adev->vm_manager.vm_pte_funcs = NULL;
 	adev->vm_manager.vm_pte_num_scheds = 0;
 	adev->gmc.gmc_funcs = NULL;
-	adev->harvest_ip_mask = 0x0;
 	adev->fence_context = dma_fence_context_alloc(AMDGPU_MAX_RINGS);
 	bitmap_zero(adev->gfx.pipe_reserve_bitmap, AMDGPU_MAX_COMPUTE_QUEUES);
 
@@ -3454,6 +3097,7 @@ int amdgpu_device_init(struct amdgpu_device *adev,
 
 	/* mutex initialization are all done here so we
 	 * can recall function without having locking issues */
+	atomic_set(&adev->irq.ih.lock, 0);
 	mutex_init(&adev->firmware.mutex);
 	mutex_init(&adev->pm.mutex);
 	mutex_init(&adev->gfx.gpu_clock_mutex);
@@ -3464,14 +3108,9 @@ int amdgpu_device_init(struct amdgpu_device *adev,
 	mutex_init(&adev->mn_lock);
 	mutex_init(&adev->virt.vf_errors.lock);
 	hash_init(adev->mn_hash);
-	atomic_set(&adev->in_gpu_reset, 0);
-	init_rwsem(&adev->reset_sem);
+	mutex_init(&adev->lock_reset);
 	mutex_init(&adev->psp.mutex);
-	mutex_init(&adev->notifier_lock);
-
-	r = amdgpu_device_init_apu_flags(adev);
-	if (r)
-		return r;
+	mutex_init(&adev->virt.dump_mutex);
 
 	r = amdgpu_device_check_arguments(adev);
 	if (r)
@@ -3490,7 +3129,8 @@ int amdgpu_device_init(struct amdgpu_device *adev,
 	INIT_LIST_HEAD(&adev->shadow_list);
 	mutex_init(&adev->shadow_list_lock);
 
-	INIT_LIST_HEAD(&adev->reset_list);
+	INIT_LIST_HEAD(&adev->ring_lru_list);
+	spin_lock_init(&adev->ring_lru_list_lock);
 
 	INIT_DELAYED_WORK(&adev->delayed_init_work,
 			  amdgpu_device_delayed_init_work_handler);
@@ -3500,18 +3140,7 @@ int amdgpu_device_init(struct amdgpu_device *adev,
 	INIT_WORK(&adev->xgmi_reset_work, amdgpu_device_xgmi_reset_func);
 
 	adev->gfx.gfx_off_req_count = 1;
-	adev->pm.ac_power = power_supply_is_system_supplied() > 0;
-
-	atomic_set(&adev->throttling_logging_enabled, 1);
-	/*
-	 * If throttling continues, logging will be performed every minute
-	 * to avoid log flooding. "-1" is subtracted since the thermal
-	 * throttling interrupt comes every second. Thus, the total logging
-	 * interval is 59 seconds(retelimited printk interval) + 1(waiting
-	 * for throttling interrupt) = 60 seconds.
-	 */
-	ratelimit_state_init(&adev->throttling_logging_rs, (60 - 1) * HZ, 1);
-	ratelimit_set_flags(&adev->throttling_logging_rs, RATELIMIT_MSG_ON_RELEASE);
+	adev->pm.ac_power = power_supply_is_system_supplied() > 0 ? true : false;
 
 	/* Registers mapping */
 	/* TODO: block userspace mapping of io register */
@@ -3530,6 +3159,17 @@ int amdgpu_device_init(struct amdgpu_device *adev,
 	DRM_INFO("register mmio base: 0x%08X\n", (uint32_t)adev->rmmio_base);
 	DRM_INFO("register mmio size: %u\n", (unsigned)adev->rmmio_size);
 
+	/* io port mapping */
+	for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) {
+		if (pci_resource_flags(adev->pdev, i) & IORESOURCE_IO) {
+			adev->rio_mem_size = pci_resource_len(adev->pdev, i);
+			adev->rio_mem = pci_iomap(adev->pdev, i, adev->rio_mem_size);
+			break;
+		}
+	}
+	if (adev->rio_mem == NULL)
+		DRM_INFO("PCI I/O BAR is not found.\n");
+
 	/* enable PCIE atomic ops */
 	r = pci_enable_atomic_ops_to_root(adev->pdev,
 					  PCI_EXP_DEVCAP2_ATOMIC_COMP32 |
@@ -3566,14 +3206,28 @@ int amdgpu_device_init(struct amdgpu_device *adev,
 	/* doorbell bar mapping and doorbell index init*/
 	amdgpu_device_doorbell_init(adev);
 
+	/* if we have > 1 VGA cards, then disable the amdgpu VGA resources */
+	/* this will fail for cards that aren't VGA class devices, just
+	 * ignore it */
+	vga_client_register(adev->pdev, adev, NULL, amdgpu_device_vga_set_decode);
+
+	if (amdgpu_device_supports_boco(ddev))
+		boco = true;
+	if (amdgpu_has_atpx() &&
+	    (amdgpu_is_atpx_hybrid() ||
+	     amdgpu_has_atpx_dgpu_power_cntl()) &&
+	    !pci_is_thunderbolt_attached(adev->pdev))
+		vga_switcheroo_register_client(adev->pdev,
+					       &amdgpu_switcheroo_ops, boco);
+	if (boco)
+		vga_switcheroo_init_domain_pm_ops(adev->dev, &adev->vga_pm_domain);
+
 	if (amdgpu_emu_mode == 1) {
 		/* post the asic on emulation mode */
 		emu_soc_asic_init(adev);
 		goto fence_driver_init;
 	}
 
-	amdgpu_reset_init(adev);
-
 	/* detect if we are with an SRIOV vbios */
 	amdgpu_device_detect_sriov_bios(adev);
 
@@ -3581,33 +3235,13 @@ int amdgpu_device_init(struct amdgpu_device *adev,
 	 *  E.g., driver was not cleanly unloaded previously, etc.
 	 */
 	if (!amdgpu_sriov_vf(adev) && amdgpu_asic_need_reset_on_init(adev)) {
-		if (adev->gmc.xgmi.num_physical_nodes) {
-			dev_info(adev->dev, "Pending hive reset.\n");
-			adev->gmc.xgmi.pending_reset = true;
-			/* Only need to init necessary block for SMU to handle the reset */
-			for (i = 0; i < adev->num_ip_blocks; i++) {
-				if (!adev->ip_blocks[i].status.valid)
-					continue;
-				if (!(adev->ip_blocks[i].version->type == AMD_IP_BLOCK_TYPE_GMC ||
-				      adev->ip_blocks[i].version->type == AMD_IP_BLOCK_TYPE_COMMON ||
-				      adev->ip_blocks[i].version->type == AMD_IP_BLOCK_TYPE_IH ||
-				      adev->ip_blocks[i].version->type == AMD_IP_BLOCK_TYPE_SMC)) {
-					DRM_DEBUG("IP %s disabled for hw_init.\n",
-						adev->ip_blocks[i].version->funcs->name);
-					adev->ip_blocks[i].status.hw = true;
-				}
-			}
-		} else {
-			r = amdgpu_asic_reset(adev);
-			if (r) {
-				dev_err(adev->dev, "asic reset on init failed\n");
-				goto failed;
-			}
+		r = amdgpu_asic_reset(adev);
+		if (r) {
+			dev_err(adev->dev, "asic reset on init failed\n");
+			goto failed;
 		}
 	}
 
-	pci_enable_pcie_error_reporting(adev->pdev);
-
 	/* Post card if necessary */
 	if (amdgpu_device_need_post(adev)) {
 		if (!adev->bios) {
@@ -3616,7 +3250,7 @@ int amdgpu_device_init(struct amdgpu_device *adev,
 			goto failed;
 		}
 		DRM_INFO("GPU posting now...\n");
-		r = amdgpu_device_asic_init(adev);
+		r = amdgpu_atom_asic_init(adev->mode_info.atom_context);
 		if (r) {
 			dev_err(adev->dev, "gpu post error!\n");
 			goto failed;
@@ -3646,15 +3280,15 @@ int amdgpu_device_init(struct amdgpu_device *adev,
 
 fence_driver_init:
 	/* Fence driver */
-	r = amdgpu_fence_driver_sw_init(adev);
+	r = amdgpu_fence_driver_init(adev);
 	if (r) {
-		dev_err(adev->dev, "amdgpu_fence_driver_sw_init failed\n");
+		dev_err(adev->dev, "amdgpu_fence_driver_init failed\n");
 		amdgpu_vf_error_put(adev, AMDGIM_ERROR_VF_FENCE_INIT_FAIL, 0, 0);
 		goto failed;
 	}
 
 	/* init the mode config */
-	drm_mode_config_init(adev_to_drm(adev));
+	drm_mode_config_init(adev->ddev);
 
 	r = amdgpu_device_ip_init(adev);
 	if (r) {
@@ -3668,22 +3302,21 @@ int amdgpu_device_init(struct amdgpu_device *adev,
 			adev->virt.caps &= ~AMDGPU_SRIOV_CAPS_RUNTIME;
 			adev->virt.ops = NULL;
 			r = -EAGAIN;
-			goto release_ras_con;
+			goto failed;
 		}
 		dev_err(adev->dev, "amdgpu_device_ip_init failed\n");
 		amdgpu_vf_error_put(adev, AMDGIM_ERROR_VF_AMDGPU_INIT_FAIL, 0, 0);
-		goto release_ras_con;
+		goto failed;
 	}
 
-	amdgpu_fence_driver_hw_init(adev);
-
-	dev_info(adev->dev,
-		"SE %d, SH per SE %d, CU per SH %d, active_cu_number %d\n",
+	DRM_DEBUG("SE %d, SH per SE %d, CU per SH %d, active_cu_number %d\n",
 			adev->gfx.config.max_shader_engines,
 			adev->gfx.config.max_sh_per_se,
 			adev->gfx.config.max_cu_per_sh,
 			adev->gfx.cu_info.number);
 
+	amdgpu_ctx_init_sched(adev);
+
 	adev->accel_working = true;
 
 	amdgpu_vm_check_compute_bug(adev);
@@ -3705,6 +3338,14 @@ int amdgpu_device_init(struct amdgpu_device *adev,
 	} else
 		adev->pm_sysfs_en = true;
 
+	r = amdgpu_pm_uuid_sysfs_init(adev);
+	if (r)
+		DRM_ERROR("Creating uuid sysfs failed (%d).\n", r);
+
+	r = amdgpu_version_sysfs_init(adev);
+	if (r)
+		DRM_ERROR("Creating version sysfs failed (%d).\n", r);
+
 	r = amdgpu_ucode_sysfs_init(adev);
 	if (r) {
 		adev->ucode_sysfs_en = false;
@@ -3735,84 +3376,66 @@ int amdgpu_device_init(struct amdgpu_device *adev,
 	/* enable clockgating, etc. after ib tests, etc. since some blocks require
 	 * explicit gating rather than handling it automatically.
 	 */
-	if (!adev->gmc.xgmi.pending_reset) {
-		r = amdgpu_device_ip_late_init(adev);
+	r = amdgpu_device_ip_late_init(adev);
+	if (r) {
+		dev_err(adev->dev, "amdgpu_device_ip_late_init failed\n");
+		amdgpu_vf_error_put(adev, AMDGIM_ERROR_VF_AMDGPU_LATE_INIT_FAIL, 0, r);
+		goto failed;
+	}
+
+	/* must succeed. */
+	amdgpu_ras_resume(adev);
+
+	if (amdgpu_sriov_vf(adev)) {
+		r = amdgpu_ib_ring_tests(adev);
 		if (r) {
-			dev_err(adev->dev, "amdgpu_device_ip_late_init failed\n");
-			amdgpu_vf_error_put(adev, AMDGIM_ERROR_VF_AMDGPU_LATE_INIT_FAIL, 0, r);
-			goto release_ras_con;
+			DRM_ERROR("ib ring test failed (%d).\n", r);
+			return r;
 		}
-		/* must succeed. */
-		amdgpu_ras_resume(adev);
+	} else {
 		queue_delayed_work(system_wq, &adev->delayed_init_work,
-				   msecs_to_jiffies(AMDGPU_RESUME_MS));
+			   msecs_to_jiffies(AMDGPU_RESUME_MS));
 	}
 
-	if (amdgpu_sriov_vf(adev))
-		flush_delayed_work(&adev->delayed_init_work);
+	r = device_create_file(adev->dev, &dev_attr_pcie_replay_count);
+	if (r) {
+		dev_err(adev->dev, "Could not create pcie_replay_count");
+		return r;
+	}
 
-	r = sysfs_create_files(&adev->dev->kobj, amdgpu_dev_attributes);
-	if (r)
-		dev_err(adev->dev, "Could not create amdgpu device attr\n");
+	r = device_create_file(adev->dev, &dev_attr_product_name);
+	if (r) {
+		dev_err(adev->dev, "Could not create product_name");
+		return r;
+	}
+
+	r = device_create_file(adev->dev, &dev_attr_product_number);
+	if (r) {
+		dev_err(adev->dev, "Could not create product_number");
+		return r;
+	}
+
+	r = device_create_file(adev->dev, &dev_attr_serial_number);
+	if (r) {
+		dev_err(adev->dev, "Could not create serial_number");
+		return r;
+	}
 
 	if (IS_ENABLED(CONFIG_PERF_EVENTS))
 		r = amdgpu_pmu_init(adev);
 	if (r)
 		dev_err(adev->dev, "amdgpu_pmu_init failed\n");
 
-	/* Have stored pci confspace at hand for restore in sudden PCI error */
-	if (amdgpu_device_cache_pci_state(adev->pdev))
-		pci_restore_state(pdev);
-
-	/* if we have > 1 VGA cards, then disable the amdgpu VGA resources */
-	/* this will fail for cards that aren't VGA class devices, just
-	 * ignore it */
-	if ((adev->pdev->class >> 8) == PCI_CLASS_DISPLAY_VGA)
-		vga_client_register(adev->pdev, adev, NULL, amdgpu_device_vga_set_decode);
-
-	if (amdgpu_device_supports_px(ddev)) {
-		px = true;
-		vga_switcheroo_register_client(adev->pdev,
-					       &amdgpu_switcheroo_ops, px);
-		vga_switcheroo_init_domain_pm_ops(adev->dev, &adev->vga_pm_domain);
-	}
-
-	if (adev->gmc.xgmi.pending_reset)
-		queue_delayed_work(system_wq, &mgpu_info.delayed_reset_work,
-				   msecs_to_jiffies(AMDGPU_RESUME_MS));
-
 	return 0;
 
-release_ras_con:
-	amdgpu_release_ras_context(adev);
-
 failed:
 	amdgpu_vf_error_trans_all(adev);
+	if (boco)
+		vga_switcheroo_fini_domain_pm_ops(adev->dev);
 
 	return r;
 }
 
-static void amdgpu_device_unmap_mmio(struct amdgpu_device *adev)
-{
-	/* Clear all CPU mappings pointing to this device */
-	unmap_mapping_range(adev->ddev.anon_inode->i_mapping, 0, 0, 1);
-
-	/* Unmap all mapped bars - Doorbell, registers and VRAM */
-	amdgpu_device_doorbell_fini(adev);
-
-	iounmap(adev->rmmio);
-	adev->rmmio = NULL;
-	if (adev->mman.aper_base_kaddr)
-		iounmap(adev->mman.aper_base_kaddr);
-	adev->mman.aper_base_kaddr = NULL;
-
-	/* Memory manager related */
-	if (!adev->gmc.xgmi.connected_to_cpu) {
-		arch_phys_wc_del(adev->gmc.vram_mtrr);
-		arch_io_free_memtype_wc(adev->gmc.aper_base, adev->gmc.aper_size);
-	}
-}
-
 /**
  * amdgpu_device_fini - tear down the driver
  *
@@ -3821,58 +3444,49 @@ static void amdgpu_device_unmap_mmio(struct amdgpu_device *adev)
  * Tear down the driver info (all asics).
  * Called at driver shutdown.
  */
-void amdgpu_device_fini_hw(struct amdgpu_device *adev)
+void amdgpu_device_fini(struct amdgpu_device *adev)
 {
-	dev_info(adev->dev, "amdgpu: finishing device.\n");
-	flush_delayed_work(&adev->delayed_init_work);
+	int r = 0;
+	/* In case amdgpu_virt_request_full_gpu failed and vm cannot get
+	* full access, we should skip touching hw and let unload continue
+	*/
+	int skip_hw = 0;
+
+	DRM_INFO("amdgpu: finishing device.\n");
+	if (!amdgpu_sriov_vf(adev))
+		flush_delayed_work(&adev->delayed_init_work);
 	ttm_bo_lock_delayed_workqueue(&adev->mman.bdev);
 	adev->shutdown = true;
 
 	/* make sure IB test finished before entering exclusive mode
 	 * to avoid preemption on IB test
 	 * */
-	if (amdgpu_sriov_vf(adev)) {
-		amdgpu_virt_request_full_gpu(adev, false);
-		amdgpu_virt_fini_data_exchange(adev);
-	}
+	if (amdgpu_sriov_vf(adev))
+		skip_hw = amdgpu_virt_request_full_gpu(adev, false);
 
 	/* disable all interrupts */
-	amdgpu_irq_disable_all(adev);
+	if (!skip_hw)
+		amdgpu_irq_disable_all(adev);
 	if (adev->mode_info.mode_config_initialized){
 		if (!amdgpu_device_has_dc_support(adev))
-			drm_helper_force_disable_all(adev_to_drm(adev));
+			drm_helper_force_disable_all(adev->ddev);
+#ifdef HAVE_DRM_ATOMIC_HELPER_SHUTDOWN
 		else
-			drm_atomic_helper_shutdown(adev_to_drm(adev));
+			drm_atomic_helper_shutdown(adev->ddev);
+#endif
 	}
-	amdgpu_fence_driver_hw_fini(adev);
-
+	amdgpu_fence_driver_fini(adev, skip_hw);
+	amdgpu_pm_uuid_sysfs_fini(adev);
 	if (adev->pm_sysfs_en)
 		amdgpu_pm_sysfs_fini(adev);
-	if (adev->ucode_sysfs_en)
-		amdgpu_ucode_sysfs_fini(adev);
-	sysfs_remove_files(&adev->dev->kobj, amdgpu_dev_attributes);
-
+	amdgpu_version_sysfs_fini(adev);
 	amdgpu_fbdev_fini(adev);
-
-	amdgpu_irq_fini_hw(adev);
-
-	amdgpu_device_ip_fini_early(adev);
-
-	amdgpu_gart_dummy_page_fini(adev);
-
-	amdgpu_device_unmap_mmio(adev);
-}
-
-void amdgpu_device_fini_sw(struct amdgpu_device *adev)
-{
-	amdgpu_device_ip_fini(adev);
-	amdgpu_fence_driver_sw_fini(adev);
-	release_firmware(adev->firmware.gpu_info_fw);
-	adev->firmware.gpu_info_fw = NULL;
+	r = amdgpu_device_ip_fini(adev, skip_hw);
+	if (adev->firmware.gpu_info_fw) {
+		release_firmware(adev->firmware.gpu_info_fw);
+		adev->firmware.gpu_info_fw = NULL;
+	}
 	adev->accel_working = false;
-
-	amdgpu_reset_fini(adev);
-
 	/* free i2c buses */
 	if (!amdgpu_device_has_dc_support(adev))
 		amdgpu_i2c_fini(adev);
@@ -3882,20 +3496,31 @@ void amdgpu_device_fini_sw(struct amdgpu_device *adev)
 
 	kfree(adev->bios);
 	adev->bios = NULL;
-	if (amdgpu_device_supports_px(adev_to_drm(adev))) {
+	if (amdgpu_has_atpx() &&
+	    (amdgpu_is_atpx_hybrid() ||
+	     amdgpu_has_atpx_dgpu_power_cntl()) &&
+	    !pci_is_thunderbolt_attached(adev->pdev))
 		vga_switcheroo_unregister_client(adev->pdev);
+	if (amdgpu_device_supports_boco(adev->ddev))
 		vga_switcheroo_fini_domain_pm_ops(adev->dev);
-	}
-	if ((adev->pdev->class >> 8) == PCI_CLASS_DISPLAY_VGA)
-		vga_client_register(adev->pdev, NULL, NULL, NULL);
+	vga_client_register(adev->pdev, NULL, NULL, NULL);
+	if (adev->rio_mem)
+		pci_iounmap(adev->pdev, adev->rio_mem);
+	adev->rio_mem = NULL;
+	iounmap(adev->rmmio);
+	adev->rmmio = NULL;
+	amdgpu_device_doorbell_fini(adev);
 
+	device_remove_file(adev->dev, &dev_attr_pcie_replay_count);
+	if (adev->ucode_sysfs_en)
+		amdgpu_ucode_sysfs_fini(adev);
+	device_remove_file(adev->dev, &dev_attr_product_name);
+	device_remove_file(adev->dev, &dev_attr_product_number);
+	device_remove_file(adev->dev, &dev_attr_serial_number);
 	if (IS_ENABLED(CONFIG_PERF_EVENTS))
 		amdgpu_pmu_fini(adev);
-	if (adev->mman.discovery_bin)
+	if (amdgpu_discovery && adev->asic_type >= CHIP_NAVI10)
 		amdgpu_discovery_fini(adev);
-
-	kfree(adev->pci_state);
-
 }
 
 
@@ -3906,6 +3531,7 @@ void amdgpu_device_fini_sw(struct amdgpu_device *adev)
  * amdgpu_device_suspend - initiate device suspend
  *
  * @dev: drm dev pointer
+ * @suspend: suspend state
  * @fbcon : notify the fbdev of suspend
  *
  * Puts the hw in the suspend state (all asics).
@@ -3914,36 +3540,90 @@ void amdgpu_device_fini_sw(struct amdgpu_device *adev)
  */
 int amdgpu_device_suspend(struct drm_device *dev, bool fbcon)
 {
-	struct amdgpu_device *adev = drm_to_adev(dev);
+	struct amdgpu_device *adev;
+	struct drm_crtc *crtc;
+	struct drm_connector *connector;
+#ifdef HAVE_DRM_CONNECTOR_LIST_ITER_BEGIN
+	struct drm_connector_list_iter iter;
+#endif
+	int r;
+
+	if (dev == NULL || dev->dev_private == NULL) {
+		return -ENODEV;
+	}
+
+	adev = dev->dev_private;
 
 	if (dev->switch_power_state == DRM_SWITCH_POWER_OFF)
 		return 0;
 
 	adev->in_suspend = true;
-
-	if (amdgpu_acpi_smart_shift_update(dev, AMDGPU_SS_DEV_D3))
-		DRM_WARN("smart shift update failed\n");
-
 	drm_kms_helper_poll_disable(dev);
 
 	if (fbcon)
 		amdgpu_fbdev_set_suspend(adev, 1);
 
-	cancel_delayed_work_sync(&adev->delayed_init_work);
+	if (!amdgpu_sriov_vf(adev))
+		cancel_delayed_work_sync(&adev->delayed_init_work);
 
-	amdgpu_ras_suspend(adev);
+	if (!amdgpu_device_has_dc_support(adev)) {
+		/* turn off display hw */
+		drm_modeset_lock_all(dev);
+#ifdef HAVE_DRM_CONNECTOR_LIST_ITER_BEGIN
+		drm_connector_list_iter_begin(dev, &iter);
+		drm_for_each_connector_iter(connector, &iter)
+#else
+		drm_for_each_connector(connector, dev)
+#endif
+			drm_helper_connector_dpms(connector,
+						  DRM_MODE_DPMS_OFF);
+#ifdef HAVE_DRM_CONNECTOR_LIST_ITER_BEGIN
+		drm_connector_list_iter_end(&iter);
+#endif
+		drm_modeset_unlock_all(dev);
+			/* unpin the front buffers and cursors */
+		list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
+			struct amdgpu_crtc *amdgpu_crtc = to_amdgpu_crtc(crtc);
+			struct drm_framebuffer *fb = crtc->primary->fb;
+			struct amdgpu_bo *robj;
+
+			if (amdgpu_crtc->cursor_bo && !adev->enable_virtual_display) {
+				struct amdgpu_bo *aobj = gem_to_amdgpu_bo(amdgpu_crtc->cursor_bo);
+				r = amdgpu_bo_reserve(aobj, true);
+				if (r == 0) {
+					amdgpu_bo_unpin(aobj);
+					amdgpu_bo_unreserve(aobj);
+				}
+			}
+
+			if (fb == NULL || kcl_drm_fb_get_gem_obj(fb, 0) == NULL) {
+				continue;
+			}
+			robj = gem_to_amdgpu_bo(kcl_drm_fb_get_gem_obj(fb, 0));
+			/* don't unpin kernel fb objects */
+			if (!amdgpu_fbdev_robj_is_fb(adev, robj)) {
+				r = amdgpu_bo_reserve(robj, true);
+				if (r == 0) {
+					amdgpu_bo_unpin(robj);
+					amdgpu_bo_unreserve(robj);
+				}
+			}
+		}
+	}
+
+	amdgpu_amdkfd_suspend(adev, !fbcon);
 
-	amdgpu_device_ip_suspend_phase1(adev);
+	amdgpu_ras_suspend(adev);
 
-	if (!adev->in_s0ix)
-		amdgpu_amdkfd_suspend(adev, adev->in_runpm);
+	r = amdgpu_device_ip_suspend_phase1(adev);
 
 	/* evict vram memory */
 	amdgpu_bo_evict_vram(adev);
 
-	amdgpu_fence_driver_hw_fini(adev);
+	amdgpu_fence_driver_suspend(adev);
+
+	r = amdgpu_device_ip_suspend_phase2(adev);
 
-	amdgpu_device_ip_suspend_phase2(adev);
 	/* evict remaining vram memory
 	 * This second call to evict vram is to evict the gart page table
 	 * using the CPU.
@@ -3957,6 +3637,7 @@ int amdgpu_device_suspend(struct drm_device *dev, bool fbcon)
  * amdgpu_device_resume - initiate device resume
  *
  * @dev: drm dev pointer
+ * @resume: resume state
  * @fbcon : notify the fbdev of resume
  *
  * Bring the hw back to operating state (all asics).
@@ -3965,47 +3646,98 @@ int amdgpu_device_suspend(struct drm_device *dev, bool fbcon)
  */
 int amdgpu_device_resume(struct drm_device *dev, bool fbcon)
 {
-	struct amdgpu_device *adev = drm_to_adev(dev);
+	struct drm_connector *connector;
+#ifdef HAVE_DRM_CONNECTOR_LIST_ITER_BEGIN
+	struct drm_connector_list_iter iter;
+#endif
+	struct amdgpu_device *adev = dev->dev_private;
+	struct drm_crtc *crtc;
 	int r = 0;
 
 	if (dev->switch_power_state == DRM_SWITCH_POWER_OFF)
 		return 0;
 
-	if (adev->in_s0ix)
-		amdgpu_gfx_state_change_set(adev, sGpuChangeState_D0Entry);
-
 	/* post card */
 	if (amdgpu_device_need_post(adev)) {
-		r = amdgpu_device_asic_init(adev);
+		r = amdgpu_atom_asic_init(adev->mode_info.atom_context);
 		if (r)
-			dev_err(adev->dev, "amdgpu asic init failed\n");
+			DRM_ERROR("amdgpu asic init failed\n");
 	}
 
 	r = amdgpu_device_ip_resume(adev);
 	if (r) {
-		dev_err(adev->dev, "amdgpu_device_ip_resume failed (%d).\n", r);
+		DRM_ERROR("amdgpu_device_ip_resume failed (%d).\n", r);
 		return r;
 	}
-	amdgpu_fence_driver_hw_init(adev);
+	amdgpu_fence_driver_resume(adev);
+
 
 	r = amdgpu_device_ip_late_init(adev);
 	if (r)
 		return r;
 
-	queue_delayed_work(system_wq, &adev->delayed_init_work,
+	if (amdgpu_sriov_vf(adev)) {
+		r = amdgpu_ib_ring_tests(adev);
+		if (r) {
+			DRM_ERROR("ib ring test failed (%d).\n", r);
+			return r;
+		}
+	} else {
+		queue_delayed_work(system_wq, &adev->delayed_init_work,
 			   msecs_to_jiffies(AMDGPU_RESUME_MS));
+	}
 
-	if (!adev->in_s0ix) {
-		r = amdgpu_amdkfd_resume(adev, adev->in_runpm);
-		if (r)
-			return r;
+	if (!amdgpu_device_has_dc_support(adev)) {
+		/* pin cursors */
+		list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
+			struct amdgpu_crtc *amdgpu_crtc = to_amdgpu_crtc(crtc);
+
+			if (amdgpu_crtc->cursor_bo && !adev->enable_virtual_display) {
+				struct amdgpu_bo *aobj = gem_to_amdgpu_bo(amdgpu_crtc->cursor_bo);
+				r = amdgpu_bo_reserve(aobj, true);
+				if (r == 0) {
+					r = amdgpu_bo_pin(aobj, AMDGPU_GEM_DOMAIN_VRAM);
+					if (r != 0)
+						DRM_ERROR("Failed to pin cursor BO (%d)\n", r);
+					amdgpu_crtc->cursor_addr = amdgpu_bo_gpu_offset(aobj);
+					amdgpu_bo_unreserve(aobj);
+				}
+			}
+		}
 	}
+	r = amdgpu_amdkfd_resume(adev, !fbcon);
+	if (r)
+		return r;
 
 	/* Make sure IB tests flushed */
-	flush_delayed_work(&adev->delayed_init_work);
+	if (!amdgpu_sriov_vf(adev))
+		flush_delayed_work(&adev->delayed_init_work);
 
-	if (fbcon)
+	/* blat the mode back in */
+	if (fbcon) {
+		if (!amdgpu_device_has_dc_support(adev)) {
+			/* pre DCE11 */
+			drm_helper_resume_force_mode(dev);
+
+			/* turn on display hw */
+			drm_modeset_lock_all(dev);
+
+#ifdef HAVE_DRM_CONNECTOR_LIST_ITER_BEGIN
+			drm_connector_list_iter_begin(dev, &iter);
+			drm_for_each_connector_iter(connector, &iter)
+#else
+			drm_for_each_connector(connector, dev)
+#endif
+				drm_helper_connector_dpms(connector,
+							  DRM_MODE_DPMS_ON);
+#ifdef HAVE_DRM_CONNECTOR_LIST_ITER_BEGIN
+			drm_connector_list_iter_end(&iter);
+#endif
+
+			drm_modeset_unlock_all(dev);
+		}
 		amdgpu_fbdev_set_suspend(adev, 0);
+	}
 
 	drm_kms_helper_poll_enable(dev);
 
@@ -4032,9 +3764,6 @@ int amdgpu_device_resume(struct drm_device *dev, bool fbcon)
 #endif
 	adev->in_suspend = false;
 
-	if (amdgpu_acpi_smart_shift_update(dev, AMDGPU_SS_DEV_D0))
-		DRM_WARN("smart shift update failed\n");
-
 	return 0;
 }
 
@@ -4066,7 +3795,7 @@ static bool amdgpu_device_ip_check_soft_reset(struct amdgpu_device *adev)
 			adev->ip_blocks[i].status.hang =
 				adev->ip_blocks[i].version->funcs->check_soft_reset(adev);
 		if (adev->ip_blocks[i].status.hang) {
-			dev_info(adev->dev, "IP block:%s is hung!\n", adev->ip_blocks[i].version->funcs->name);
+			DRM_INFO("IP block:%s is hung!\n", adev->ip_blocks[i].version->funcs->name);
 			asic_hang = true;
 		}
 	}
@@ -4127,7 +3856,7 @@ static bool amdgpu_device_ip_need_full_reset(struct amdgpu_device *adev)
 		    (adev->ip_blocks[i].version->type == AMD_IP_BLOCK_TYPE_DCE) ||
 		     adev->ip_blocks[i].version->type == AMD_IP_BLOCK_TYPE_PSP) {
 			if (adev->ip_blocks[i].status.hang) {
-				dev_info(adev->dev, "Some block need full reset!\n");
+				DRM_INFO("Some block need full reset!\n");
 				return true;
 			}
 		}
@@ -4208,7 +3937,6 @@ static int amdgpu_device_recover_vram(struct amdgpu_device *adev)
 {
 	struct dma_fence *fence = NULL, *next = NULL;
 	struct amdgpu_bo *shadow;
-	struct amdgpu_bo_vm *vmbo;
 	long r = 1, tmo;
 
 	if (amdgpu_sriov_runtime(adev))
@@ -4216,14 +3944,14 @@ static int amdgpu_device_recover_vram(struct amdgpu_device *adev)
 	else
 		tmo = msecs_to_jiffies(100);
 
-	dev_info(adev->dev, "recover vram bo from shadow start\n");
+	DRM_INFO("recover vram bo from shadow start\n");
 	mutex_lock(&adev->shadow_list_lock);
-	list_for_each_entry(vmbo, &adev->shadow_list, shadow_list) {
-		shadow = &vmbo->bo;
+	list_for_each_entry(shadow, &adev->shadow_list, shadow_list) {
+
 		/* No need to recover an evicted BO */
-		if (shadow->tbo.resource->mem_type != TTM_PL_TT ||
-		    shadow->tbo.resource->start == AMDGPU_BO_INVALID_OFFSET ||
-		    shadow->parent->tbo.resource->mem_type != TTM_PL_VRAM)
+		if (shadow->tbo.mem.mem_type != TTM_PL_TT ||
+		    shadow->tbo.mem.start == AMDGPU_BO_INVALID_OFFSET ||
+		    shadow->parent->tbo.mem.mem_type != TTM_PL_VRAM)
 			continue;
 
 		r = amdgpu_bo_restore_shadow(shadow, &next);
@@ -4252,11 +3980,11 @@ static int amdgpu_device_recover_vram(struct amdgpu_device *adev)
 	dma_fence_put(fence);
 
 	if (r < 0 || tmo <= 0) {
-		dev_err(adev->dev, "recover vram bo from shadow failed, r is %ld, tmo is %ld\n", r, tmo);
+		DRM_ERROR("recover vram bo from shadow failed, r is %ld, tmo is %ld\n", r, tmo);
 		return -EIO;
 	}
 
-	dev_info(adev->dev, "recover vram bo from shadow done\n");
+	DRM_INFO("recover vram bo from shadow done\n");
 	return 0;
 }
 
@@ -4264,7 +3992,7 @@ static int amdgpu_device_recover_vram(struct amdgpu_device *adev)
 /**
  * amdgpu_device_reset_sriov - reset ASIC for SR-IOV vf
  *
- * @adev: amdgpu_device pointer
+ * @adev: amdgpu device pointer
  * @from_hypervisor: request from hypervisor
  *
  * do VF FLR and reinitialize Asic
@@ -4291,7 +4019,7 @@ static int amdgpu_device_reset_sriov(struct amdgpu_device *adev,
 
 	amdgpu_virt_init_data_exchange(adev);
 	/* we need recover gart prior to run SMC/CP/SDMA resume */
-	amdgpu_gtt_mgr_recover(ttm_manager_type(&adev->mman.bdev, TTM_PL_TT));
+	amdgpu_gtt_mgr_recover(&adev->mman.bdev.man[TTM_PL_TT]);
 
 	r = amdgpu_device_fw_loading(adev);
 	if (r)
@@ -4307,47 +4035,19 @@ static int amdgpu_device_reset_sriov(struct amdgpu_device *adev,
 	amdgpu_amdkfd_post_reset(adev);
 
 error:
+	amdgpu_virt_release_full_gpu(adev, true);
 	if (!r && adev->virt.gim_feature & AMDGIM_FEATURE_GIM_FLR_VRAMLOST) {
 		amdgpu_inc_vram_lost(adev);
 		r = amdgpu_device_recover_vram(adev);
 	}
-	amdgpu_virt_release_full_gpu(adev, true);
 
 	return r;
 }
 
-/**
- * amdgpu_device_has_job_running - check if there is any job in mirror list
- *
- * @adev: amdgpu_device pointer
- *
- * check if there is any job in mirror list
- */
-bool amdgpu_device_has_job_running(struct amdgpu_device *adev)
-{
-	int i;
-	struct drm_sched_job *job;
-
-	for (i = 0; i < AMDGPU_MAX_RINGS; ++i) {
-		struct amdgpu_ring *ring = adev->rings[i];
-
-		if (!ring || !ring->sched.thread)
-			continue;
-
-		spin_lock(&ring->sched.job_list_lock);
-		job = list_first_entry_or_null(&ring->sched.pending_list,
-					       struct drm_sched_job, list);
-		spin_unlock(&ring->sched.job_list_lock);
-		if (job)
-			return true;
-	}
-	return false;
-}
-
 /**
  * amdgpu_device_should_recover_gpu - check if we should try GPU recovery
  *
- * @adev: amdgpu_device pointer
+ * @adev: amdgpu device pointer
  *
  * Check amdgpu_gpu_recovery and SRIOV status to see if we should try to recover
  * a hung GPU.
@@ -4355,7 +4055,7 @@ bool amdgpu_device_has_job_running(struct amdgpu_device *adev)
 bool amdgpu_device_should_recover_gpu(struct amdgpu_device *adev)
 {
 	if (!amdgpu_device_ip_check_soft_reset(adev)) {
-		dev_info(adev->dev, "Timeout, but no hardware hang detected.\n");
+		DRM_INFO("Timeout, but no hardware hang detected.\n");
 		return false;
 	}
 
@@ -4385,12 +4085,6 @@ bool amdgpu_device_should_recover_gpu(struct amdgpu_device *adev)
 		case CHIP_NAVI10:
 		case CHIP_NAVI14:
 		case CHIP_NAVI12:
-		case CHIP_SIENNA_CICHLID:
-		case CHIP_NAVY_FLOUNDER:
-		case CHIP_DIMGREY_CAVEFISH:
-		case CHIP_BEIGE_GOBY:
-		case CHIP_VANGOGH:
-		case CHIP_ALDEBARAN:
 			break;
 		default:
 			goto disabled;
@@ -4400,69 +4094,21 @@ bool amdgpu_device_should_recover_gpu(struct amdgpu_device *adev)
 	return true;
 
 disabled:
-		dev_info(adev->dev, "GPU recovery disabled.\n");
+		DRM_INFO("GPU recovery disabled.\n");
 		return false;
 }
 
-int amdgpu_device_mode1_reset(struct amdgpu_device *adev)
-{
-        u32 i;
-        int ret = 0;
-
-        amdgpu_atombios_scratch_regs_engine_hung(adev, true);
-
-        dev_info(adev->dev, "GPU mode1 reset\n");
-
-        /* disable BM */
-        pci_clear_master(adev->pdev);
-
-        amdgpu_device_cache_pci_state(adev->pdev);
-
-        if (amdgpu_dpm_is_mode1_reset_supported(adev)) {
-                dev_info(adev->dev, "GPU smu mode1 reset\n");
-                ret = amdgpu_dpm_mode1_reset(adev);
-        } else {
-                dev_info(adev->dev, "GPU psp mode1 reset\n");
-                ret = psp_gpu_reset(adev);
-        }
-
-        if (ret)
-                dev_err(adev->dev, "GPU mode1 reset failed\n");
-
-        amdgpu_device_load_pci_state(adev->pdev);
-
-        /* wait for asic to come out of reset */
-        for (i = 0; i < adev->usec_timeout; i++) {
-                u32 memsize = adev->nbio.funcs->get_memsize(adev);
-
-                if (memsize != 0xffffffff)
-                        break;
-                udelay(1);
-        }
-
-        amdgpu_atombios_scratch_regs_engine_hung(adev, false);
-        return ret;
-}
 
-int amdgpu_device_pre_asic_reset(struct amdgpu_device *adev,
-				 struct amdgpu_reset_context *reset_context)
+static int amdgpu_device_pre_asic_reset(struct amdgpu_device *adev,
+					struct amdgpu_job *job,
+					bool *need_full_reset_arg)
 {
 	int i, r = 0;
-	struct amdgpu_job *job = NULL;
-	bool need_full_reset =
-		test_bit(AMDGPU_NEED_FULL_RESET, &reset_context->flags);
-
-	if (reset_context->reset_req_dev == adev)
-		job = reset_context->job;
+	bool need_full_reset  = *need_full_reset_arg;
 
-	/* no need to dump if device is not in good state during probe period */
-	if (!adev->gmc.xgmi.pending_reset)
-		amdgpu_debugfs_wait_dump(adev);
-
-	if (amdgpu_sriov_vf(adev)) {
-		/* stop the data exchange thread */
-		amdgpu_virt_fini_data_exchange(adev);
-	}
+	if (amdgpu_sriov_vf(adev))
+		if (!amdgpu_virt_notify_booked(adev, job))
+			amdgpu_virt_wait_dump(adev, MAX_SCHEDULE_TIMEOUT);
 
 	/* block all schedulers and reset given job's ring */
 	for (i = 0; i < AMDGPU_MAX_RINGS; ++i) {
@@ -4475,16 +4121,9 @@ int amdgpu_device_pre_asic_reset(struct amdgpu_device *adev,
 		amdgpu_fence_driver_force_completion(ring);
 	}
 
-	if (job && job->vm)
+	if (job)
 		drm_sched_increase_karma(&job->base);
 
-	r = amdgpu_reset_prepare_hwcontext(adev, reset_context);
-	/* If reset handler not implemented, continue; otherwise return */
-	if (r == -ENOSYS)
-		r = 0;
-	else
-		return r;
-
 	/* Don't suspend on bare metal if we are not going to HW reset the ASIC */
 	if (!amdgpu_sriov_vf(adev)) {
 
@@ -4496,69 +4135,52 @@ int amdgpu_device_pre_asic_reset(struct amdgpu_device *adev,
 			r = amdgpu_device_ip_soft_reset(adev);
 			amdgpu_device_ip_post_soft_reset(adev);
 			if (r || amdgpu_device_ip_check_soft_reset(adev)) {
-				dev_info(adev->dev, "soft reset failed, will fallback to full reset!\n");
+				DRM_INFO("soft reset failed, will fallback to full reset!\n");
 				need_full_reset = true;
 			}
 		}
 
 		if (need_full_reset)
 			r = amdgpu_device_ip_suspend(adev);
-		if (need_full_reset)
-			set_bit(AMDGPU_NEED_FULL_RESET, &reset_context->flags);
-		else
-			clear_bit(AMDGPU_NEED_FULL_RESET,
-				  &reset_context->flags);
+
+		*need_full_reset_arg = need_full_reset;
 	}
 
 	return r;
 }
 
-int amdgpu_do_asic_reset(struct list_head *device_list_handle,
-			 struct amdgpu_reset_context *reset_context)
+static int amdgpu_do_asic_reset(struct amdgpu_hive_info *hive,
+			       struct list_head *device_list_handle,
+			       bool *need_full_reset_arg)
 {
 	struct amdgpu_device *tmp_adev = NULL;
-	bool need_full_reset, skip_hw_reset, vram_lost = false;
+	bool need_full_reset = *need_full_reset_arg, vram_lost = false;
 	int r = 0;
 
-	/* Try reset handler method first */
-	tmp_adev = list_first_entry(device_list_handle, struct amdgpu_device,
-				    reset_list);
-	r = amdgpu_reset_perform_reset(tmp_adev, reset_context);
-	/* If reset handler not implemented, continue; otherwise return */
-	if (r == -ENOSYS)
-		r = 0;
-	else
-		return r;
-
-	/* Reset handler not implemented, use the default method */
-	need_full_reset =
-		test_bit(AMDGPU_NEED_FULL_RESET, &reset_context->flags);
-	skip_hw_reset = test_bit(AMDGPU_SKIP_HW_RESET, &reset_context->flags);
-
 	/*
-	 * ASIC reset has to be done on all XGMI hive nodes ASAP
+	 * ASIC reset has to be done on all HGMI hive nodes ASAP
 	 * to allow proper links negotiation in FW (within 1 sec)
 	 */
-	if (!skip_hw_reset && need_full_reset) {
-		list_for_each_entry(tmp_adev, device_list_handle, reset_list) {
+	if (need_full_reset) {
+		list_for_each_entry(tmp_adev, device_list_handle, gmc.xgmi.head) {
 			/* For XGMI run all resets in parallel to speed up the process */
 			if (tmp_adev->gmc.xgmi.num_physical_nodes > 1) {
-				tmp_adev->gmc.xgmi.pending_reset = false;
 				if (!queue_work(system_unbound_wq, &tmp_adev->xgmi_reset_work))
 					r = -EALREADY;
 			} else
 				r = amdgpu_asic_reset(tmp_adev);
 
 			if (r) {
-				dev_err(tmp_adev->dev, "ASIC reset failed with error, %d for drm dev, %s",
-					 r, adev_to_drm(tmp_adev)->unique);
+				DRM_ERROR("ASIC reset failed with error, %d for drm dev, %s",
+					 r, tmp_adev->ddev->unique);
 				break;
 			}
 		}
 
 		/* For XGMI wait for all resets to complete before proceed */
 		if (!r) {
-			list_for_each_entry(tmp_adev, device_list_handle, reset_list) {
+			list_for_each_entry(tmp_adev, device_list_handle,
+					    gmc.xgmi.head) {
 				if (tmp_adev->gmc.xgmi.num_physical_nodes > 1) {
 					flush_work(&tmp_adev->xgmi_reset_work);
 					r = tmp_adev->asic_reset_res;
@@ -4570,22 +4192,22 @@ int amdgpu_do_asic_reset(struct list_head *device_list_handle,
 	}
 
 	if (!r && amdgpu_ras_intr_triggered()) {
-		list_for_each_entry(tmp_adev, device_list_handle, reset_list) {
-			if (tmp_adev->mmhub.ras_funcs &&
-			    tmp_adev->mmhub.ras_funcs->reset_ras_error_count)
-				tmp_adev->mmhub.ras_funcs->reset_ras_error_count(tmp_adev);
+		list_for_each_entry(tmp_adev, device_list_handle, gmc.xgmi.head) {
+			if (tmp_adev->mmhub.funcs &&
+			    tmp_adev->mmhub.funcs->reset_ras_error_count)
+				tmp_adev->mmhub.funcs->reset_ras_error_count(tmp_adev);
 		}
 
 		amdgpu_ras_intr_cleared();
 	}
 
-	list_for_each_entry(tmp_adev, device_list_handle, reset_list) {
+	list_for_each_entry(tmp_adev, device_list_handle, gmc.xgmi.head) {
 		if (need_full_reset) {
 			/* post card */
-			r = amdgpu_device_asic_init(tmp_adev);
-			if (r) {
-				dev_warn(tmp_adev->dev, "asic atom init failed!");
-			} else {
+			if (amdgpu_atom_asic_init(tmp_adev->mode_info.atom_context))
+				DRM_WARN("asic atom init failed!");
+
+			if (!r) {
 				dev_info(tmp_adev->dev, "GPU reset succeeded, trying to resume\n");
 				r = amdgpu_device_ip_resume_phase1(tmp_adev);
 				if (r)
@@ -4597,7 +4219,8 @@ int amdgpu_do_asic_reset(struct list_head *device_list_handle,
 					amdgpu_inc_vram_lost(tmp_adev);
 				}
 
-				r = amdgpu_gtt_mgr_recover(ttm_manager_type(&tmp_adev->mman.bdev, TTM_PL_TT));
+				r = amdgpu_gtt_mgr_recover(
+					&tmp_adev->mman.bdev.man[TTM_PL_TT]);
 				if (r)
 					goto out;
 
@@ -4618,48 +4241,29 @@ int amdgpu_do_asic_reset(struct list_head *device_list_handle,
 				 */
 				amdgpu_register_gpu_instance(tmp_adev);
 
-				if (!reset_context->hive &&
-				    tmp_adev->gmc.xgmi.num_physical_nodes > 1)
-					amdgpu_xgmi_add_device(tmp_adev);
-
 				r = amdgpu_device_ip_late_init(tmp_adev);
 				if (r)
 					goto out;
 
 				amdgpu_fbdev_set_suspend(tmp_adev, 0);
 
-				/*
-				 * The GPU enters bad state once faulty pages
-				 * by ECC has reached the threshold, and ras
-				 * recovery is scheduled next. So add one check
-				 * here to break recovery if it indeed exceeds
-				 * bad page threshold, and remind user to
-				 * retire this GPU or setting one bigger
-				 * bad_page_threshold value to fix this once
-				 * probing driver again.
-				 */
-				if (!amdgpu_ras_eeprom_check_err_threshold(tmp_adev)) {
[… more lines in the raw message]

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

Signature · 1 line
2.17.1

Part of the diff is not shown here. View the raw message.

#2 lore raw

RE: [PATCH] drm/amdgpu: Add driver version

[AMD Official Use Only]

Merge error, Too big to drop

Quoted 4,579 lines

-----Original Message-----
From: Peng Ju Zhou <[email protected]>
Sent: Wednesday, August 4, 2021 10:15 AM
To: [email protected]
Cc: Nieto, David M <[email protected]>; Zhou, Peng Ju <[email protected]>
Subject: [PATCH] drm/amdgpu: Add driver version

From: David M Nieto <[email protected]>

This sysfs is only defined in DKMS drivers it exposes the internal AMDGPU version

---
 drivers/gpu/drm/amd/amdgpu/amdgpu_device.c | 2659 +++++++-------------
 1 file changed, 941 insertions(+), 1718 deletions(-)
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +3 -16
index 9e53ff851496..d93d1c966bad 100644
@@ -29,6 +29,7 @@
 #include <linux/kthread.h>
 #include <linux/module.h>
 #include <linux/console.h>
+#include <linux/reboot.h>
 #include <linux/slab.h>
 
 #include <drm/drm_atomic_helper.h>
@@ -65,13 +66,9 @@
 #include "amdgpu_ras.h"
 #include "amdgpu_pmu.h"
 #include "amdgpu_fru_eeprom.h"
-#include "amdgpu_reset.h"
 
 #include <linux/suspend.h>
 #include <drm/task_barrier.h>
-#include <linux/pm_runtime.h>
-
-#include <drm/drm_drv.h>
 
 MODULE_FIRMWARE("amdgpu/vega10_gpu_info.bin");
 MODULE_FIRMWARE("amdgpu/vega12_gpu_info.bin");
@@ -83,8 +80,6 @@ MODULE_FIRMWARE("amdgpu/renoir_gpu_info.bin");
 MODULE_FIRMWARE("amdgpu/navi10_gpu_info.bin");
 MODULE_FIRMWARE("amdgpu/navi14_gpu_info.bin");
 MODULE_FIRMWARE("amdgpu/navi12_gpu_info.bin");
-MODULE_FIRMWARE("amdgpu/vangogh_gpu_info.bin");
-MODULE_FIRMWARE("amdgpu/yellow_carp_gpu_info.bin");
 
 #define AMDGPU_RESUME_MS		2000
 
@@ -114,17 +109,9 @@ const char *amdgpu_asic_name[] = {
 	"RAVEN",
 	"ARCTURUS",
 	"RENOIR",
-	"ALDEBARAN",
 	"NAVI10",
-	"CYAN_SKILLFISH",
 	"NAVI14",
 	"NAVI12",
-	"SIENNA_CICHLID",
-	"NAVY_FLOUNDER",
-	"VANGOGH",
-	"DIMGREY_CAVEFISH",
-	"BEIGE_GOBY",
-	"YELLOW_CARP",
 	"LAST",
 };
 
@@ -141,10 +128,10 @@ static ssize_t
 amdgpu_device_get_pcie_replay_count(struct device *dev,
 		struct device_attribute *attr, char *buf)
 {
 	struct drm_device *ddev = dev_get_drvdata(dev);
-	struct amdgpu_device *adev = drm_to_adev(ddev);
+	struct amdgpu_device *adev = ddev->dev_private;
 	uint64_t cnt = amdgpu_asic_get_pcie_replay_count(adev);
 
-	return sysfs_emit(buf, "%llu\n", cnt);
+	return snprintf(buf, PAGE_SIZE, "%llu\n", cnt);
 }
 

static DEVICE_ATTR(pcie_replay_count, S_IRUGO,

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -2
@@ -166,9 +153,9 @@ static ssize_t
 amdgpu_device_get_product_name(struct device *dev,
 		struct device_attribute *attr, char *buf)
 {
 	struct drm_device *ddev = dev_get_drvdata(dev);
-	struct amdgpu_device *adev = drm_to_adev(ddev);
+	struct amdgpu_device *adev = ddev->dev_private;
 
-	return sysfs_emit(buf, "%s\n", adev->product_name);
+	return snprintf(buf, PAGE_SIZE, "%s\n", adev->product_name);
 }
 

static DEVICE_ATTR(product_name, S_IRUGO,

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -2
@@ -188,9 +175,9 @@ static ssize_t
 amdgpu_device_get_product_number(struct device *dev,
 		struct device_attribute *attr, char *buf)
 {
 	struct drm_device *ddev = dev_get_drvdata(dev);
-	struct amdgpu_device *adev = drm_to_adev(ddev);
+	struct amdgpu_device *adev = ddev->dev_private;
 
-	return sysfs_emit(buf, "%s\n", adev->product_number);
+	return snprintf(buf, PAGE_SIZE, "%s\n", adev->product_number);
 }
 

static DEVICE_ATTR(product_number, S_IRUGO,

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -3
@@ -210,45 +197,27 @@ static ssize_t
 amdgpu_device_get_serial_number(struct device *dev,
 		struct device_attribute *attr, char *buf)
 {
 	struct drm_device *ddev = dev_get_drvdata(dev);
-	struct amdgpu_device *adev = drm_to_adev(ddev);
+	struct amdgpu_device *adev = ddev->dev_private;
 
-	return sysfs_emit(buf, "%s\n", adev->serial);
+	return snprintf(buf, PAGE_SIZE, "%s\n", adev->serial);
 }
 
 static DEVICE_ATTR(serial_number, S_IRUGO,
 		amdgpu_device_get_serial_number, NULL);
 
 /**
- * amdgpu_device_supports_px - Is the device a dGPU with ATPX power

control
- *
- * @dev: drm_device pointer
- *
- * Returns true if the device is a dGPU with ATPX power control,
- * otherwise return false.
- */

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -11
-bool amdgpu_device_supports_px(struct drm_device *dev)
-{
-	struct amdgpu_device *adev = drm_to_adev(dev);
-
-	if ((adev->flags & AMD_IS_PX) && !amdgpu_is_atpx_hybrid())
-		return true;
-	return false;
-}
-
-/**
- * amdgpu_device_supports_boco - Is the device a dGPU with ACPI power

resources
+ * amdgpu_device_supports_boco - Is the device a dGPU with HG/PX power control
*
* @dev: drm_device pointer
*
- * Returns true if the device is a dGPU with ACPI power control,
+ * Returns true if the device is a dGPU with HG/PX power control,
* otherwise return false.
*/
bool amdgpu_device_supports_boco(struct drm_device *dev)
{

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +5 -23
-	struct amdgpu_device *adev = drm_to_adev(dev);
+	struct amdgpu_device *adev = dev->dev_private;
 
-	if (adev->has_pr3 ||
-	    ((adev->flags & AMD_IS_PX) && amdgpu_is_atpx_hybrid()))
+	if (adev->flags & AMD_IS_PX)
 		return true;
 	return false;
 }
@@ -263,32 +232,15 @@ bool amdgpu_device_supports_boco(struct
 drm_device *dev)
  */
 bool amdgpu_device_supports_baco(struct drm_device *dev)
 {
-	struct amdgpu_device *adev = drm_to_adev(dev);
+	struct amdgpu_device *adev = dev->dev_private;
 
 	return amdgpu_asic_supports_baco(adev);
 }
 
 /**
- * amdgpu_device_supports_smart_shift - Is the device dGPU with
- * smart shift support
- *
- * @dev: drm_device pointer
+ * VRAM access helper functions.
  *
- * Returns true if the device is a dGPU with Smart Shift support,
- * otherwise returns false.
- */
-bool amdgpu_device_supports_smart_shift(struct drm_device *dev)
-{
-	return (amdgpu_device_supports_boco(dev) &&
-		amdgpu_acpi_is_power_shift_control_supported());
-}
-
-/*
- * VRAM access helper functions
- */
-
-/**
- * amdgpu_device_mm_access - access vram by MM_INDEX/MM_DATA
+ * amdgpu_device_vram_access - read/write a buffer in vram
  *
  * @adev: amdgpu_device pointer

* @pos: offset of the buffer in vram

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +15 -94
@@ -296,143 +248,61 @@ bool amdgpu_device_supports_smart_shift(struct
 drm_device *dev)
  * @size: read/write size, sizeof(@buf) must > @size
  * @write: true - write to vram, otherwise - read from vram
  */
-void amdgpu_device_mm_access(struct amdgpu_device *adev, loff_t pos,
-			     void *buf, size_t size, bool write)
+void amdgpu_device_vram_access(struct amdgpu_device *adev, loff_t pos,
+			       uint32_t *buf, size_t size, bool write)
 {
 	unsigned long flags;
-	uint32_t hi = ~0, tmp = 0;
-	uint32_t *data = buf;
+	uint32_t hi = ~0;
 	uint64_t last;
-	int idx;
-
-	if (!drm_dev_enter(&adev->ddev, &idx))
-		return;
-
-	BUG_ON(!IS_ALIGNED(pos, 4) || !IS_ALIGNED(size, 4));
-
-	spin_lock_irqsave(&adev->mmio_idx_lock, flags);
-	for (last = pos + size; pos < last; pos += 4) {
-		tmp = pos >> 31;
-
-		WREG32_NO_KIQ(mmMM_INDEX, ((uint32_t)pos) |
 0x80000000);
-		if (tmp != hi) {
-			WREG32_NO_KIQ(mmMM_INDEX_HI, tmp);
-			hi = tmp;
-		}
-		if (write)
-			WREG32_NO_KIQ(mmMM_DATA, *data++);
-		else
-			*data++ = RREG32_NO_KIQ(mmMM_DATA);
-	}
 
-	spin_unlock_irqrestore(&adev->mmio_idx_lock, flags);
-	drm_dev_exit(idx);
-}
 
-/**
- * amdgpu_device_vram_access - access vram by vram aperature
- *
- * @adev: amdgpu_device pointer
- * @pos: offset of the buffer in vram
- * @buf: virtual address of the buffer in system memory
- * @size: read/write size, sizeof(@buf) must > @size
- * @write: true - write to vram, otherwise - read from vram
- *
- * The return value means how many bytes have been transferred.
- */
-size_t amdgpu_device_aper_access(struct amdgpu_device *adev, loff_t pos,
-				 void *buf, size_t size, bool write)
-{
 #ifdef CONFIG_64BIT
-	void __iomem *addr;
-	size_t count = 0;
-	uint64_t last;
-
-	if (!adev->mman.aper_base_kaddr)
-		return 0;
-
 	last = min(pos + size, adev->gmc.visible_vram_size);
 	if (last > pos) {
-		addr = adev->mman.aper_base_kaddr + pos;
-		count = last - pos;
+		void __iomem *addr = adev->mman.aper_base_kaddr + pos;
+		size_t count = last - pos;
 
 		if (write) {
 			memcpy_toio(addr, buf, count);
 			mb();
-			amdgpu_device_flush_hdp(adev, NULL);
+			amdgpu_asic_flush_hdp(adev, NULL);
 		} else {
-			amdgpu_device_invalidate_hdp(adev, NULL);
+			amdgpu_asic_invalidate_hdp(adev, NULL);
 			mb();
 			memcpy_fromio(buf, addr, count);
 		}
 
-	}
-
-	return count;
-#else
-	return 0;
-#endif
-}
-
-/**
- * amdgpu_device_vram_access - read/write a buffer in vram
- *
- * @adev: amdgpu_device pointer
- * @pos: offset of the buffer in vram
- * @buf: virtual address of the buffer in system memory
- * @size: read/write size, sizeof(@buf) must > @size
- * @write: true - write to vram, otherwise - read from vram
- */
-void amdgpu_device_vram_access(struct amdgpu_device *adev, loff_t pos,
-			       void *buf, size_t size, bool write)
-{
-	size_t count;
+		if (count == size)
+			return;
 
-	/* try to using vram apreature to access vram first */
-	count = amdgpu_device_aper_access(adev, pos, buf, size, write);
-	size -= count;
-	if (size) {
-		/* using MM to access rest vram */
 		pos += count;
-		buf += count;
-		amdgpu_device_mm_access(adev, pos, buf, size, write);
+		buf += count / 4;
+		size -= count;
 	}
-}
-
-/*
- * register access helper functions.
- */
+#endif
 
-/* Check if hw access should be skipped because of hotplug or device error */
-bool amdgpu_device_skip_hw_access(struct amdgpu_device *adev)
-{
-	if (adev->no_hw_access)
-		return true;
+	spin_lock_irqsave(&adev->mmio_idx_lock, flags);
+	for (last = pos + size; pos < last; pos += 4) {
+		uint32_t tmp = pos >> 31;
 
-#ifdef CONFIG_LOCKDEP
-	/*
-	 * This is a bit complicated to understand, so worth a comment. What

we assert

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -1
-	 * here is that the GPU reset is not running on another thread in

parallel.

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -2
-	 *
-	 * For this we trylock the read side of the reset semaphore, if that

succeeds

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -3
-	 * we know that the reset is not running in paralell.
-	 *
-	 * If the trylock fails we assert that we are either already holding the

read

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -1
-	 * side of the lock or are the reset thread itself and hold the write side

of

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -5
-	 * the lock.
-	 */
-	if (in_task()) {
-		if (down_read_trylock(&adev->reset_sem))
-			up_read(&adev->reset_sem);
+		WREG32_NO_KIQ(mmMM_INDEX, ((uint32_t)pos) |

0x80000000);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +23 -22
+		if (tmp != hi) {
+			WREG32_NO_KIQ(mmMM_INDEX_HI, tmp);
+			hi = tmp;
+		}
+		if (write)
+			WREG32_NO_KIQ(mmMM_DATA, *buf++);
 		else
-			lockdep_assert_held(&adev->reset_sem);
+			*buf++ = RREG32_NO_KIQ(mmMM_DATA);
 	}
-#endif
-	return false;
+	spin_unlock_irqrestore(&adev->mmio_idx_lock, flags);
 }
 
+/*
+ * MMIO register access helper functions.
+ */
 /**
- * amdgpu_device_rreg - read a memory mapped IO or indirect register
+ * amdgpu_mm_rreg - read a memory mapped IO register
  *
  * @adev: amdgpu_device pointer
  * @reg: dword aligned register offset
@@ -440,29 +310,25 @@ bool amdgpu_device_skip_hw_access(struct
 amdgpu_device *adev)
  *
  * Returns the 32 bit value from the offset specified.
  */
-uint32_t amdgpu_device_rreg(struct amdgpu_device *adev,
-			    uint32_t reg, uint32_t acc_flags)
+uint32_t amdgpu_mm_rreg(struct amdgpu_device *adev, uint32_t reg,
+			uint32_t acc_flags)
 {
 	uint32_t ret;
 
-	if (amdgpu_device_skip_hw_access(adev))
-		return 0;
-
-	if ((reg * 4) < adev->rmmio_size) {
-		if (!(acc_flags & AMDGPU_REGS_NO_KIQ) &&
-		    amdgpu_sriov_runtime(adev) &&
-		    down_read_trylock(&adev->reset_sem)) {
-			ret = amdgpu_kiq_rreg(adev, reg);
-			up_read(&adev->reset_sem);
-		} else {
-			ret = readl(((void __iomem *)adev->rmmio) + (reg * 4));
-		}
-	} else {
-		ret = adev->pcie_rreg(adev, reg * 4);
-	}
+	if ((acc_flags & AMDGPU_REGS_KIQ) || (!(acc_flags &
 AMDGPU_REGS_NO_KIQ) && amdgpu_sriov_runtime(adev)))
+		return amdgpu_kiq_rreg(adev, reg);
 
-	trace_amdgpu_device_rreg(adev->pdev->device, reg, ret);
+	if ((reg * 4) < adev->rmmio_size && !(acc_flags & AMDGPU_REGS_IDX))
+		ret = readl(((void __iomem *)adev->rmmio) + (reg * 4));
+	else {
+		unsigned long flags;
 
+		spin_lock_irqsave(&adev->mmio_idx_lock, flags);
+		writel((reg * 4), ((void __iomem *)adev->rmmio) +
 (mmMM_INDEX * 4));
+		ret = readl(((void __iomem *)adev->rmmio) + (mmMM_DATA

* 4));

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +3 -3
+		spin_unlock_irqrestore(&adev->mmio_idx_lock, flags);
+	}
+	trace_amdgpu_mm_rreg(adev->pdev->device, reg, ret);
 	return ret;
 }
@@ -482,9 +348,6 @@ uint32_t amdgpu_device_rreg(struct amdgpu_device
 *adev,
  */
 uint8_t amdgpu_mm_rreg8(struct amdgpu_device *adev, uint32_t offset)
 {
-	if (amdgpu_device_skip_hw_access(adev))
-		return 0;
-
 	if (offset < adev->rmmio_size)
 		return (readb(adev->rmmio + offset));
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +16 -3
 	BUG();
@@ -507,17 +370,34 @@ uint8_t amdgpu_mm_rreg8(struct amdgpu_device
 *adev, uint32_t offset)
  */
 void amdgpu_mm_wreg8(struct amdgpu_device *adev, uint32_t offset,
 uint8_t value)
 {
-	if (amdgpu_device_skip_hw_access(adev))
-		return;
-
 	if (offset < adev->rmmio_size)
 		writeb(value, adev->rmmio + offset);
 	else
 		BUG();
 }
 
+void static inline amdgpu_mm_wreg_mmio(struct amdgpu_device *adev,
 uint32_t reg, uint32_t v, uint32_t acc_flags)
+{
+	trace_amdgpu_mm_wreg(adev->pdev->device, reg, v);
+
+	if ((reg * 4) < adev->rmmio_size && !(acc_flags & AMDGPU_REGS_IDX))
+		writel(v, ((void __iomem *)adev->rmmio) + (reg * 4));
+	else {
+		unsigned long flags;
+
+		spin_lock_irqsave(&adev->mmio_idx_lock, flags);
+		writel((reg * 4), ((void __iomem *)adev->rmmio) +
 (mmMM_INDEX * 4));
+		writel(v, ((void __iomem *)adev->rmmio) + (mmMM_DATA *
 4));
+		spin_unlock_irqrestore(&adev->mmio_idx_lock, flags);
+	}
+
+	if (adev->asic_type >= CHIP_VEGA10 && reg == 1 && adev-
Quoted 1 line

last_mm_index == 0x5702C) {

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +13 -19
+		udelay(500);
+	}
+}
+
 /**
- * amdgpu_device_wreg - write to a memory mapped IO or indirect register
+ * amdgpu_mm_wreg - write to a memory mapped IO register
  *
  * @adev: amdgpu_device pointer
  * @reg: dword aligned register offset
@@ -526,27 +406,17 @@ void amdgpu_mm_wreg8(struct amdgpu_device
 *adev, uint32_t offset, uint8_t value)
  *
  * Writes the value specified to the offset specified.
  */
-void amdgpu_device_wreg(struct amdgpu_device *adev,
-			uint32_t reg, uint32_t v,
-			uint32_t acc_flags)
+void amdgpu_mm_wreg(struct amdgpu_device *adev, uint32_t reg, uint32_t
 v,
+		    uint32_t acc_flags)
 {
-	if (amdgpu_device_skip_hw_access(adev))
-		return;
-
-	if ((reg * 4) < adev->rmmio_size) {
-		if (!(acc_flags & AMDGPU_REGS_NO_KIQ) &&
-		    amdgpu_sriov_runtime(adev) &&
-		    down_read_trylock(&adev->reset_sem)) {
-			amdgpu_kiq_wreg(adev, reg, v);
-			up_read(&adev->reset_sem);
-		} else {
-			writel(v, ((void __iomem *)adev->rmmio) + (reg * 4));
-		}
-	} else {
-		adev->pcie_wreg(adev, reg * 4, v);
+	if (adev->asic_type >= CHIP_VEGA10 && reg == 0) {
+		adev->last_mm_index = v;
 	}
 
-	trace_amdgpu_device_wreg(adev->pdev->device, reg, v);
+	if ((acc_flags & AMDGPU_REGS_KIQ) || (!(acc_flags &
 AMDGPU_REGS_NO_KIQ) && amdgpu_sriov_runtime(adev)))
+		return amdgpu_kiq_wreg(adev, reg, v);
+
+	amdgpu_mm_wreg_mmio(adev, reg, v, acc_flags);

}

/*

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +52 -10
@@ -554,19 +424,62 @@ void amdgpu_device_wreg(struct amdgpu_device
 *adev,
  *
  * this function is invoked only the debugfs register access
  * */
-void amdgpu_mm_wreg_mmio_rlc(struct amdgpu_device *adev,
-			     uint32_t reg, uint32_t v)
+void amdgpu_mm_wreg_mmio_rlc(struct amdgpu_device *adev, uint32_t reg,
 uint32_t v,
+		    uint32_t acc_flags)
 {
-	if (amdgpu_device_skip_hw_access(adev))
-		return;
-
 	if (amdgpu_sriov_fullaccess(adev) &&
-	    adev->gfx.rlc.funcs &&
-	    adev->gfx.rlc.funcs->is_rlcg_access_range) {
+		adev->gfx.rlc.funcs &&
+		adev->gfx.rlc.funcs->is_rlcg_access_range) {
+
 		if (adev->gfx.rlc.funcs->is_rlcg_access_range(adev, reg))
-			return adev->gfx.rlc.funcs->sriov_wreg(adev, reg, v, 0,
 0);
-	} else {
-		writel(v, ((void __iomem *)adev->rmmio) + (reg * 4));
+			return adev->gfx.rlc.funcs->rlcg_wreg(adev, reg, v, 0);
+	}
+
+	amdgpu_mm_wreg_mmio(adev, reg, v, acc_flags);
+}
+
+/**
+ * amdgpu_io_rreg - read an IO register
+ *
+ * @adev: amdgpu_device pointer
+ * @reg: dword aligned register offset
+ *
+ * Returns the 32 bit value from the offset specified.
+ */
+u32 amdgpu_io_rreg(struct amdgpu_device *adev, u32 reg)
+{
+	if ((reg * 4) < adev->rio_mem_size)
+		return ioread32(adev->rio_mem + (reg * 4));
+	else {
+		iowrite32((reg * 4), adev->rio_mem + (mmMM_INDEX * 4));
+		return ioread32(adev->rio_mem + (mmMM_DATA * 4));
+	}
+}
+
+/**
+ * amdgpu_io_wreg - write to an IO register
+ *
+ * @adev: amdgpu_device pointer
+ * @reg: dword aligned register offset
+ * @v: 32 bit value to write to the register
+ *
+ * Writes the value specified to the offset specified.
+ */
+void amdgpu_io_wreg(struct amdgpu_device *adev, u32 reg, u32 v)
+{
+	if (adev->asic_type >= CHIP_VEGA10 && reg == 0) {
+		adev->last_mm_index = v;
+	}
+
+	if ((reg * 4) < adev->rio_mem_size)
+		iowrite32(v, adev->rio_mem + (reg * 4));
+	else {
+		iowrite32((reg * 4), adev->rio_mem + (mmMM_INDEX * 4));
+		iowrite32(v, adev->rio_mem + (mmMM_DATA * 4));
+	}
+
+	if (adev->asic_type >= CHIP_VEGA10 && reg == 1 && adev-
Quoted 1 line

last_mm_index == 0x5702C) {

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -3
+		udelay(500);
 	}
 }
@@ -581,9 +494,6 @@ void amdgpu_mm_wreg_mmio_rlc(struct
 amdgpu_device *adev,
  */
 u32 amdgpu_mm_rdoorbell(struct amdgpu_device *adev, u32 index)
 {
-	if (amdgpu_device_skip_hw_access(adev))
-		return 0;
-
 	if (index < adev->doorbell.num_doorbells) {
 		return readl(adev->doorbell.ptr + index);
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -3
 	} else {
@@ -604,9 +514,6 @@ u32 amdgpu_mm_rdoorbell(struct amdgpu_device
 *adev, u32 index)
  */
 void amdgpu_mm_wdoorbell(struct amdgpu_device *adev, u32 index, u32 v)
 {
-	if (amdgpu_device_skip_hw_access(adev))
-		return;
-
 	if (index < adev->doorbell.num_doorbells) {
 		writel(v, adev->doorbell.ptr + index);
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -3
 	} else {
@@ -625,9 +532,6 @@ void amdgpu_mm_wdoorbell(struct amdgpu_device
 *adev, u32 index, u32 v)
  */
 u64 amdgpu_mm_rdoorbell64(struct amdgpu_device *adev, u32 index)
 {
-	if (amdgpu_device_skip_hw_access(adev))
-		return 0;
-
 	if (index < adev->doorbell.num_doorbells) {
 		return atomic64_read((atomic64_t *)(adev->doorbell.ptr +

index));

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -3
 	} else {
@@ -648,9 +552,6 @@ u64 amdgpu_mm_rdoorbell64(struct amdgpu_device
 *adev, u32 index)
  */
 void amdgpu_mm_wdoorbell64(struct amdgpu_device *adev, u32 index, u64
 v)
 {
-	if (amdgpu_device_skip_hw_access(adev))
-		return;
-
 	if (index < adev->doorbell.num_doorbells) {
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -132
 		atomic64_set((atomic64_t *)(adev->doorbell.ptr + index), v);
 	} else {
@@ -658,141 +559,10 @@ void amdgpu_mm_wdoorbell64(struct
 amdgpu_device *adev, u32 index, u64 v)
 	}
 }
 
-/**
- * amdgpu_device_indirect_rreg - read an indirect register
- *
- * @adev: amdgpu_device pointer
- * @pcie_index: mmio register offset
- * @pcie_data: mmio register offset
- * @reg_addr: indirect register address to read from
- *
- * Returns the value of indirect register @reg_addr
- */
-u32 amdgpu_device_indirect_rreg(struct amdgpu_device *adev,
-				u32 pcie_index, u32 pcie_data,
-				u32 reg_addr)
-{
-	unsigned long flags;
-	u32 r;
-	void __iomem *pcie_index_offset;
-	void __iomem *pcie_data_offset;
-
-	spin_lock_irqsave(&adev->pcie_idx_lock, flags);
-	pcie_index_offset = (void __iomem *)adev->rmmio + pcie_index * 4;
-	pcie_data_offset = (void __iomem *)adev->rmmio + pcie_data * 4;
-
-	writel(reg_addr, pcie_index_offset);
-	readl(pcie_index_offset);
-	r = readl(pcie_data_offset);
-	spin_unlock_irqrestore(&adev->pcie_idx_lock, flags);
-
-	return r;
-}
-
-/**
- * amdgpu_device_indirect_rreg64 - read a 64bits indirect register
- *
- * @adev: amdgpu_device pointer
- * @pcie_index: mmio register offset
- * @pcie_data: mmio register offset
- * @reg_addr: indirect register address to read from
- *
- * Returns the value of indirect register @reg_addr
- */
-u64 amdgpu_device_indirect_rreg64(struct amdgpu_device *adev,
-				  u32 pcie_index, u32 pcie_data,
-				  u32 reg_addr)
-{
-	unsigned long flags;
-	u64 r;
-	void __iomem *pcie_index_offset;
-	void __iomem *pcie_data_offset;
-
-	spin_lock_irqsave(&adev->pcie_idx_lock, flags);
-	pcie_index_offset = (void __iomem *)adev->rmmio + pcie_index * 4;
-	pcie_data_offset = (void __iomem *)adev->rmmio + pcie_data * 4;
-
-	/* read low 32 bits */
-	writel(reg_addr, pcie_index_offset);
-	readl(pcie_index_offset);
-	r = readl(pcie_data_offset);
-	/* read high 32 bits */
-	writel(reg_addr + 4, pcie_index_offset);
-	readl(pcie_index_offset);
-	r |= ((u64)readl(pcie_data_offset) << 32);
-	spin_unlock_irqrestore(&adev->pcie_idx_lock, flags);
-
-	return r;
-}
-
-/**
- * amdgpu_device_indirect_wreg - write an indirect register address
- *
- * @adev: amdgpu_device pointer
- * @pcie_index: mmio register offset
- * @pcie_data: mmio register offset
- * @reg_addr: indirect register offset
- * @reg_data: indirect register data
- *
- */
-void amdgpu_device_indirect_wreg(struct amdgpu_device *adev,
-				 u32 pcie_index, u32 pcie_data,
-				 u32 reg_addr, u32 reg_data)
-{
-	unsigned long flags;
-	void __iomem *pcie_index_offset;
-	void __iomem *pcie_data_offset;
-
-	spin_lock_irqsave(&adev->pcie_idx_lock, flags);
-	pcie_index_offset = (void __iomem *)adev->rmmio + pcie_index * 4;
-	pcie_data_offset = (void __iomem *)adev->rmmio + pcie_data * 4;
-
-	writel(reg_addr, pcie_index_offset);
-	readl(pcie_index_offset);
-	writel(reg_data, pcie_data_offset);
-	readl(pcie_data_offset);
-	spin_unlock_irqrestore(&adev->pcie_idx_lock, flags);
-}
-
-/**
- * amdgpu_device_indirect_wreg64 - write a 64bits indirect register address
- *
- * @adev: amdgpu_device pointer
- * @pcie_index: mmio register offset
- * @pcie_data: mmio register offset
- * @reg_addr: indirect register offset
- * @reg_data: indirect register data
- *
- */
-void amdgpu_device_indirect_wreg64(struct amdgpu_device *adev,
-				   u32 pcie_index, u32 pcie_data,
-				   u32 reg_addr, u64 reg_data)
-{
-	unsigned long flags;
-	void __iomem *pcie_index_offset;
-	void __iomem *pcie_data_offset;
-
-	spin_lock_irqsave(&adev->pcie_idx_lock, flags);
-	pcie_index_offset = (void __iomem *)adev->rmmio + pcie_index * 4;
-	pcie_data_offset = (void __iomem *)adev->rmmio + pcie_data * 4;
-
-	/* write low 32 bits */
-	writel(reg_addr, pcie_index_offset);
-	readl(pcie_index_offset);
-	writel((u32)(reg_data & 0xffffffffULL), pcie_data_offset);
-	readl(pcie_data_offset);
-	/* write high 32 bits */
-	writel(reg_addr + 4, pcie_index_offset);
-	readl(pcie_index_offset);
-	writel((u32)(reg_data >> 32), pcie_data_offset);
-	readl(pcie_data_offset);
-	spin_unlock_irqrestore(&adev->pcie_idx_lock, flags);
-}
-
 /**
  * amdgpu_invalid_rreg - dummy reg read function
  *
- * @adev: amdgpu_device pointer
+ * @adev: amdgpu device pointer
  * @reg: offset of register
  *

* Dummy register read function. Used for register blocks

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -1
@@ -809,7 +579,7 @@ static uint32_t amdgpu_invalid_rreg(struct
 amdgpu_device *adev, uint32_t reg)
 /**
  * amdgpu_invalid_wreg - dummy reg write function
  *
- * @adev: amdgpu_device pointer
+ * @adev: amdgpu device pointer
  * @reg: offset of register
  * @v: value to write to the register

*

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -0
@@ -826,7 +596,7 @@ static void amdgpu_invalid_wreg(struct

amdgpu_device *adev, uint32_t reg, uint32
/**
* amdgpu_invalid_rreg64 - dummy 64 bit reg read function *
- * @adev: amdgpu_device pointer
+ * @adev: amdgpu device pointer
* @reg: offset of register
*
* Dummy register read function. Used for register blocks

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -1
@@ -843,7 +613,7 @@ static uint64_t amdgpu_invalid_rreg64(struct
 amdgpu_device *adev, uint32_t reg)
 /**
  * amdgpu_invalid_wreg64 - dummy reg write function
  *
- * @adev: amdgpu_device pointer
+ * @adev: amdgpu device pointer
  * @reg: offset of register
  * @v: value to write to the register

*

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -0
@@ -860,7 +630,7 @@ static void amdgpu_invalid_wreg64(struct

amdgpu_device *adev, uint32_t reg, uint
/**
* amdgpu_block_invalid_rreg - dummy reg read function *
- * @adev: amdgpu_device pointer
+ * @adev: amdgpu device pointer
* @block: offset of instance
* @reg: offset of register
*

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -1
@@ -880,7 +650,7 @@ static uint32_t amdgpu_block_invalid_rreg(struct
 amdgpu_device *adev,
 /**
  * amdgpu_block_invalid_wreg - dummy reg write function
  *
- * @adev: amdgpu_device pointer
+ * @adev: amdgpu device pointer
  * @block: offset of instance
  * @reg: offset of register

* @v: value to write to the register

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -15
@@ -897,24 +667,10 @@ static void amdgpu_block_invalid_wreg(struct
 amdgpu_device *adev,
 	BUG();
 }
 
-/**
- * amdgpu_device_asic_init - Wrapper for atom asic_init
- *
- * @adev: amdgpu_device pointer
- *
- * Does any asic specific work and then calls atom asic init.
- */
-static int amdgpu_device_asic_init(struct amdgpu_device *adev)
-{
-	amdgpu_asic_pre_asic_init(adev);
-
-	return amdgpu_atom_asic_init(adev->mode_info.atom_context);
-}
-
 /**
  * amdgpu_device_vram_scratch_init - allocate the VRAM scratch page
  *
- * @adev: amdgpu_device pointer
+ * @adev: amdgpu device pointer
  *
  * Allocates a scratch page of VRAM for use by various things in the

* driver.

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -1
@@ -931,7 +687,7 @@ static int amdgpu_device_vram_scratch_init(struct
 amdgpu_device *adev)
 /**
  * amdgpu_device_vram_scratch_fini - Free the VRAM scratch page
  *
- * @adev: amdgpu_device pointer
+ * @adev: amdgpu device pointer
  *
  * Frees the VRAM scratch page.

*/

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -12
@@ -992,18 +748,6 @@ void amdgpu_device_pci_config_reset(struct
 amdgpu_device *adev)
 	pci_write_config_dword(adev->pdev, 0x7c,
 AMDGPU_ASIC_RESET_DATA);
 }
 
-/**
- * amdgpu_device_pci_reset - reset the GPU using generic PCI means
- *
- * @adev: amdgpu_device pointer
- *
- * Resets the GPU using generic pci reset interfaces (FLR, SBR, etc.).
- */
-int amdgpu_device_pci_reset(struct amdgpu_device *adev)
-{
-	return pci_reset_function(adev->pdev);
-}
-
 /*

* GPU doorbell aperture helpers function. */

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -0
@@ -1169,6 +913,7 @@ void amdgpu_device_wb_free(struct amdgpu_device
 *adev, u32 wb)
 		__clear_bit(wb, adev->wb.used);
 }
 
+#ifdef AMDKCL_ENABLE_RESIZE_FB_BAR
 /**
  * amdgpu_device_resize_fb_bar - try to resize FB BAR

*

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -1
@@ -1180,7 +925,8 @@ void amdgpu_device_wb_free(struct amdgpu_device
 *adev, u32 wb)
  */
 int amdgpu_device_resize_fb_bar(struct amdgpu_device *adev)
 {
-	int rbar_size = pci_rebar_bytes_to_size(adev->gmc.real_vram_size);
+	u64 space_needed = roundup_pow_of_two(adev-
 >gmc.real_vram_size);
+	u32 rbar_size = order_base_2(((space_needed >> 20) | 1)) - 1;
 	struct pci_bus *root;
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -5
 	struct resource *res;
 	unsigned i;
@@ -1191,11 +937,6 @@ int amdgpu_device_resize_fb_bar(struct
 amdgpu_device *adev)
 	if (amdgpu_sriov_vf(adev))
 		return 0;
 
-	/* skip if the bios has already enabled large BAR */
-	if (adev->gmc.real_vram_size &&
-	    (pci_resource_len(adev->pdev, 0) >= adev->gmc.real_vram_size))
-		return 0;
-
 	/* Check if the root BUS has 64bit memory resources */
 	root = adev->pdev->bus;
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -4
 	while (root->parent)
@@ -1211,10 +952,6 @@ int amdgpu_device_resize_fb_bar(struct
 amdgpu_device *adev)
 	if (!res)
 		return 0;
 
-	/* Limit the BAR size to what is available */
-	rbar_size = min(fls(pci_rebar_get_possible_sizes(adev->pdev, 0)) - 1,
-			rbar_size);
-
 	/* Disable memory decoding while we change the BAR addresses and

size */

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -0
 	pci_read_config_word(adev->pdev, PCI_COMMAND, &cmd);
 	pci_write_config_word(adev->pdev, PCI_COMMAND,
@@ -1246,6 +983,7 @@ int amdgpu_device_resize_fb_bar(struct
 amdgpu_device *adev)
 
 	return 0;
 }
+#endif
 
 /*

* GPU helpers function.

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -4
@@ -1286,10 +1024,6 @@ bool amdgpu_device_need_post(struct
 amdgpu_device *adev)
 		}
 	}
 
-	/* Don't post if we need to reset whole hive on init */
-	if (adev->gmc.xgmi.pending_reset)
-		return false;
-
 	if (adev->has_hw_reset) {
 		adev->has_hw_reset = false;
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -1
 		return true;
@@ -1415,40 +1149,33 @@ static void
 amdgpu_device_check_smu_prv_buffer_size(struct amdgpu_device *adev)
 	adev->pm.smu_prv_buffer_size = 0;
 }
 
-static int amdgpu_device_init_apu_flags(struct amdgpu_device *adev)
+/**
+ * amdgpu_device_enable_extra_fw_load - parse firmware which needs

explicit loading
+ *
+ * @adev: amdgpu_device pointer
+ *
+ * Enable specific firmware loading if the user has enabled it via
+ * the module parameter load_extra_fw. This feature allows the driver
+ * to load specific firmware, which should be skipped under some circumstances
+ * like virtualized environments by default.
+ */
+static void amdgpu_device_enable_extra_fw_load(struct amdgpu_device *adev)
{

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +8 -30
-	if (!(adev->flags & AMD_IS_APU) ||
-	    adev->asic_type < CHIP_RAVEN)
-		return 0;
+	adev->virt.extra_fw = 0;
 
-	switch (adev->asic_type) {
-	case CHIP_RAVEN:
-		if (adev->pdev->device == 0x15dd)
-			adev->apu_flags |= AMD_APU_IS_RAVEN;
-		if (adev->pdev->device == 0x15d8)
-			adev->apu_flags |= AMD_APU_IS_PICASSO;
-		break;
-	case CHIP_RENOIR:
-		if ((adev->pdev->device == 0x1636) ||
-		    (adev->pdev->device == 0x164c))
-			adev->apu_flags |= AMD_APU_IS_RENOIR;
-		else
-			adev->apu_flags |= AMD_APU_IS_GREEN_SARDINE;
-		break;
-	case CHIP_VANGOGH:
-		adev->apu_flags |= AMD_APU_IS_VANGOGH;
-		break;
-	case CHIP_YELLOW_CARP:
-		break;
-	case CHIP_CYAN_SKILLFISH:
-		if (adev->pdev->device == 0x13FE)
-			adev->apu_flags |= AMD_APU_IS_CYAN_SKILLFISH2;
-		break;
-	default:
-		return -EINVAL;
-	}
+	if (amdgpu_load_extra_fw) {
+		char *fwstr, *fwstr_tmp, *fwname_tmp;
 
-	return 0;
+		fwstr = kstrdup(amdgpu_load_extra_fw, GFP_KERNEL);
+		fwstr_tmp = fwstr;
+		while (fwname_tmp = strsep(&fwstr_tmp, ",")) {
+			if (!strcmp("ta", fwname_tmp))
+				adev->virt.extra_fw |=

AMDGPU_SRIOV_EXTRA_FW_PSP_TA;

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -0
+			else
+				DRM_WARN("Skip loading unknown FW

type: %s\n", fwname_tmp);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +3 -8
+		}
+		kfree(fwstr);
+	}
 }
 
 /**
@@ -1492,16 +1219,6 @@ static int amdgpu_device_check_arguments(struct
 amdgpu_device *adev)
 		amdgpu_vm_fragment_size = -1;
 	}
 
-	if (amdgpu_sched_hw_submission < 2) {
-		dev_warn(adev->dev, "sched hw submission jobs (%d) must be
 at least 2\n",
-			 amdgpu_sched_hw_submission);
-		amdgpu_sched_hw_submission = 2;
-	} else if (!is_power_of_2(amdgpu_sched_hw_submission)) {
-		dev_warn(adev->dev, "sched hw submission jobs (%d) must be
 a power of 2\n",
-			 amdgpu_sched_hw_submission);
-		amdgpu_sched_hw_submission =

roundup_pow_of_two(amdgpu_sched_hw_submission);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +4 -4
-	}
-
 	amdgpu_device_check_smu_prv_buffer_size(adev);
 
 	amdgpu_device_check_vm_size(adev);
@@ -1510,9 +1227,11 @@ static int amdgpu_device_check_arguments(struct
 amdgpu_device *adev)
 
 	adev->firmware.load_type = amdgpu_ucode_get_load_type(adev,
 amdgpu_fw_load_type);
 
-	amdgpu_gmc_tmz_set(adev);
+	amdgpu_device_enable_extra_fw_load(adev);
+
+	amdgpu_direct_gma_size = min(amdgpu_direct_gma_size, 96);
 
-	amdgpu_gmc_noretry_set(adev);
+	amdgpu_gmc_tmz_set(adev);
 
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +10 -9
 	return 0;
 }
@@ -1526,36 +1245,37 @@ static int amdgpu_device_check_arguments(struct
 amdgpu_device *adev)
  * Callback for the switcheroo driver.  Suspends or resumes the
  * the asics before or after it is powered up using ACPI methods.
  */
-static void amdgpu_switcheroo_set_state(struct pci_dev *pdev,
-					enum vga_switcheroo_state state)
+static void amdgpu_switcheroo_set_state(struct pci_dev *pdev, enum
 vga_switcheroo_state state)
 {
 	struct drm_device *dev = pci_get_drvdata(pdev);
 	int r;
 
-	if (amdgpu_device_supports_px(dev) && state ==
 VGA_SWITCHEROO_OFF)
+	if (amdgpu_device_supports_boco(dev) && state ==
 VGA_SWITCHEROO_OFF)
 		return;
 
 	if (state == VGA_SWITCHEROO_ON) {
-		pr_info("switched on\n");
+		pr_info("amdgpu: switched on\n");
 		/* don't suspend or resume card normally */
 		dev->switch_power_state =
 DRM_SWITCH_POWER_CHANGING;
 
-		pci_set_power_state(pdev, PCI_D0);
-		amdgpu_device_load_pci_state(pdev);
-		r = pci_enable_device(pdev);
+		pci_set_power_state(dev->pdev, PCI_D0);
+		pci_restore_state(dev->pdev);
+		r = pci_enable_device(dev->pdev);
 		if (r)
 			DRM_WARN("pci_enable_device failed (%d)\n", r);
 		amdgpu_device_resume(dev, true);
 
 		dev->switch_power_state = DRM_SWITCH_POWER_ON;
+		drm_kms_helper_poll_enable(dev);
 	} else {
-		pr_info("switched off\n");
+		pr_info("amdgpu: switched off\n");
+		drm_kms_helper_poll_disable(dev);
 		dev->switch_power_state =
 DRM_SWITCH_POWER_CHANGING;
 		amdgpu_device_suspend(dev, true);
-		amdgpu_device_cache_pci_state(pdev);
+		pci_save_state(dev->pdev);
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +3 -3
 		/* Shut down the device */
-		pci_disable_device(pdev);
-		pci_set_power_state(pdev, PCI_D3cold);
+		pci_disable_device(dev->pdev);
+		pci_set_power_state(dev->pdev, PCI_D3cold);
 		dev->switch_power_state = DRM_SWITCH_POWER_OFF;
 	}
 }
@@ -1578,7 +1298,7 @@ static bool amdgpu_switcheroo_can_switch(struct
 pci_dev *pdev)
 	* locking inversion with the driver load path. And the access here is
 	* completely racy anyway. So don't bother with locking for now.
 	*/
-	return atomic_read(&dev->open_count) == 0;
+	return dev->open_count == 0;
 }
 

static const struct vga_switcheroo_client_ops amdgpu_switcheroo_ops = {

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -14
@@ -1793,19 +1513,6 @@ int amdgpu_device_ip_block_add(struct
 amdgpu_device *adev,
 	if (!ip_block_version)
 		return -EINVAL;
 
-	switch (ip_block_version->type) {
-	case AMD_IP_BLOCK_TYPE_VCN:
-		if (adev->harvest_ip_mask & AMD_HARVEST_IP_VCN_MASK)
-			return 0;
-		break;
-	case AMD_IP_BLOCK_TYPE_JPEG:
-		if (adev->harvest_ip_mask & AMD_HARVEST_IP_JPEG_MASK)
-			return 0;
-		break;
-	default:
-		break;
-	}
-
 	DRM_INFO("add ip block number %d <%s>\n", adev->num_ip_blocks,
 		  ip_block_version->funcs->name);
@@ -1831,7 +1538,8 @@ static void
 amdgpu_device_enable_virtual_display(struct amdgpu_device *adev)
 	adev->enable_virtual_display = false;
 
 	if (amdgpu_virtual_display) {
-		const char *pci_address_name = pci_name(adev->pdev);
+		struct drm_device *ddev = adev->ddev;
+		const char *pci_address_name = pci_name(ddev->pdev);
 		char *pciaddstr, *pciaddstr_tmp, *pciaddname_tmp,
 *pciaddname;
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -7
 		pciaddstr = kstrdup(amdgpu_virtual_display, GFP_KERNEL);
@@ -1883,25 +1591,22 @@ static void
 amdgpu_device_enable_virtual_display(struct amdgpu_device *adev)
 static int amdgpu_device_parse_gpu_info_fw(struct amdgpu_device *adev)
 {
 	const char *chip_name;
-	char fw_name[40];
+	char fw_name[30];
 	int err;
 	const struct gpu_info_firmware_header_v1_0 *hdr;
 
 	adev->firmware.gpu_info_fw = NULL;
 
-	if (adev->mman.discovery_bin) {
-		amdgpu_discovery_get_gfx_info(adev);
-
-		/*
-		 * FIXME: The bounding box is still needed by Navi12, so
-		 * temporarily read it from gpu_info firmware. Should be

droped

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +9 -20
-		 * when DAL no longer needs it.
-		 */
-		if (adev->asic_type != CHIP_NAVI12)
-			return 0;
-	}
-
 	switch (adev->asic_type) {
+	case CHIP_TOPAZ:
+	case CHIP_TONGA:
+	case CHIP_FIJI:
+	case CHIP_POLARIS10:
+	case CHIP_POLARIS11:
+	case CHIP_POLARIS12:
+	case CHIP_VEGAM:
+	case CHIP_CARRIZO:
+	case CHIP_STONEY:
 #ifdef CONFIG_DRM_AMDGPU_SI
 	case CHIP_VERDE:
 	case CHIP_TAHITI:
@@ -1916,21 +1621,7 @@ static int
 amdgpu_device_parse_gpu_info_fw(struct amdgpu_device *adev)
 	case CHIP_KABINI:
 	case CHIP_MULLINS:
 #endif
-	case CHIP_TOPAZ:
-	case CHIP_TONGA:
-	case CHIP_FIJI:
-	case CHIP_POLARIS10:
-	case CHIP_POLARIS11:
-	case CHIP_POLARIS12:
-	case CHIP_VEGAM:
-	case CHIP_CARRIZO:
-	case CHIP_STONEY:
 	case CHIP_VEGA20:
-	case CHIP_ALDEBARAN:
-	case CHIP_SIENNA_CICHLID:
-	case CHIP_NAVY_FLOUNDER:
-	case CHIP_DIMGREY_CAVEFISH:
-	case CHIP_BEIGE_GOBY:
 	default:
 		return 0;
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -2
 	case CHIP_VEGA10:
@@ -1940,9 +1631,9 @@ static int amdgpu_device_parse_gpu_info_fw(struct
 amdgpu_device *adev)
 		chip_name = "vega12";
 		break;
 	case CHIP_RAVEN:
-		if (adev->apu_flags & AMD_APU_IS_RAVEN2)
+		if (adev->rev_id >= 8)
 			chip_name = "raven2";
-		else if (adev->apu_flags & AMD_APU_IS_PICASSO)
+		else if (adev->pdev->device == 0x15d8)
 			chip_name = "picasso";
 		else
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -4
 			chip_name = "raven";
@@ -1951,10 +1642,7 @@ static int
 amdgpu_device_parse_gpu_info_fw(struct amdgpu_device *adev)
 		chip_name = "arcturus";
 		break;
 	case CHIP_RENOIR:
-		if (adev->apu_flags & AMD_APU_IS_RENOIR)
-			chip_name = "renoir";
-		else
-			chip_name = "green_sardine";
+		chip_name = "renoir";
 		break;
 	case CHIP_NAVI10:
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -6
 		chip_name = "navi10";
@@ -1965,12 +1653,6 @@ static int
 amdgpu_device_parse_gpu_info_fw(struct amdgpu_device *adev)
 	case CHIP_NAVI12:
 		chip_name = "navi12";
 		break;
-	case CHIP_VANGOGH:
-		chip_name = "vangogh";
-		break;
-	case CHIP_YELLOW_CARP:
-		chip_name = "yellow_carp";
-		break;
 	}
 

snprintf(fw_name, sizeof(fw_name), "amdgpu/%s_gpu_info.bin",
chip_name);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -0
@@ -1999,10 +1681,7 @@ static int
 amdgpu_device_parse_gpu_info_fw(struct amdgpu_device *adev)
 			(const struct gpu_info_firmware_v1_0 *)(adev-
Quoted 1 line

firmware.gpu_info_fw->data +

	le32_to_cpu(hdr->header.ucode_array_offset_bytes));
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -4
-		/*
-		 * Should be droped when DAL no longer needs it.
-		 */
-		if (adev->asic_type == CHIP_NAVI12)
+		if (amdgpu_discovery && adev->asic_type >= CHIP_NAVI10)
 			goto parse_soc_bounding_box;
 
 		adev->gfx.config.max_shader_engines =

le32_to_cpu(gpu_info_fw->gc_num_se);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -1
@@ -2034,9 +1713,10 @@ static int
 amdgpu_device_parse_gpu_info_fw(struct amdgpu_device *adev)
 		}
 
 parse_soc_bounding_box:
+#ifdef CONFIG_DRM_AMD_DC_DCN2_0
 		/*
 		 * soc bounding box info is not integrated in disocovery table,
-		 * we always need to parse it from gpu info firmware if needed.
+		 * we always need to parse it from gpu info firmware.
 		 */
 		if (hdr->version_minor == 2) {
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -0
 			const struct gpu_info_firmware_v1_2 *gpu_info_fw =
@@ -2044,6 +1724,7 @@ static int amdgpu_device_parse_gpu_info_fw(struct
 amdgpu_device *adev)
 
 	le32_to_cpu(hdr->header.ucode_array_offset_bytes));
 			adev->dm.soc_bounding_box = &gpu_info_fw-
 >soc_bounding_box;
 		}
+#endif
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +17 -5
 		break;
 	}
 	default:
@@ -2072,13 +1753,25 @@ static int amdgpu_device_ip_early_init(struct
 amdgpu_device *adev)
 
 	amdgpu_device_enable_virtual_display(adev);
 
-	if (amdgpu_sriov_vf(adev)) {
-		r = amdgpu_virt_request_full_gpu(adev, true);
+	switch (adev->asic_type) {
+	case CHIP_TOPAZ:
+	case CHIP_TONGA:
+	case CHIP_FIJI:
+	case CHIP_POLARIS10:
+	case CHIP_POLARIS11:
+	case CHIP_POLARIS12:
+	case CHIP_VEGAM:
+	case CHIP_CARRIZO:
+	case CHIP_STONEY:
+		if (adev->asic_type == CHIP_CARRIZO || adev->asic_type ==
 CHIP_STONEY)
+			adev->family = AMDGPU_FAMILY_CZ;
+		else
+			adev->family = AMDGPU_FAMILY_VI;
+
+		r = vi_set_ip_blocks(adev);
 		if (r)
 			return r;
-	}
-
-	switch (adev->asic_type) {
+		break;
 #ifdef CONFIG_DRM_AMDGPU_SI
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +5 -23
 	case CHIP_VERDE:
 	case CHIP_TAHITI:
@@ -2097,42 +1790,24 @@ static int amdgpu_device_ip_early_init(struct
 amdgpu_device *adev)
 	case CHIP_KAVERI:
 	case CHIP_KABINI:
 	case CHIP_MULLINS:
-		if (adev->flags & AMD_IS_APU)
-			adev->family = AMDGPU_FAMILY_KV;
-		else
+		if ((adev->asic_type == CHIP_BONAIRE) || (adev->asic_type ==
 CHIP_HAWAII))
 			adev->family = AMDGPU_FAMILY_CI;
+		else
+			adev->family = AMDGPU_FAMILY_KV;
 
 		r = cik_set_ip_blocks(adev);
 		if (r)
 			return r;
 		break;
 #endif
-	case CHIP_TOPAZ:
-	case CHIP_TONGA:
-	case CHIP_FIJI:
-	case CHIP_POLARIS10:
-	case CHIP_POLARIS11:
-	case CHIP_POLARIS12:
-	case CHIP_VEGAM:
-	case CHIP_CARRIZO:
-	case CHIP_STONEY:
-		if (adev->flags & AMD_IS_APU)
-			adev->family = AMDGPU_FAMILY_CZ;
-		else
-			adev->family = AMDGPU_FAMILY_VI;
-
-		r = vi_set_ip_blocks(adev);
-		if (r)
-			return r;
-		break;
 	case CHIP_VEGA10:
 	case CHIP_VEGA12:
 	case CHIP_VEGA20:
 	case CHIP_RAVEN:
 	case CHIP_ARCTURUS:
 	case CHIP_RENOIR:
-	case CHIP_ALDEBARAN:
-		if (adev->flags & AMD_IS_APU)
+		if (adev->asic_type == CHIP_RAVEN ||
+		    adev->asic_type == CHIP_RENOIR)
 			adev->family = AMDGPU_FAMILY_RV;
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -13
 		else
 			adev->family = AMDGPU_FAMILY_AI;
@@ -2144,19 +1819,7 @@ static int amdgpu_device_ip_early_init(struct
 amdgpu_device *adev)
 	case  CHIP_NAVI10:
 	case  CHIP_NAVI14:
 	case  CHIP_NAVI12:
-	case  CHIP_SIENNA_CICHLID:
-	case  CHIP_NAVY_FLOUNDER:
-	case  CHIP_DIMGREY_CAVEFISH:
-	case  CHIP_BEIGE_GOBY:
-	case CHIP_VANGOGH:
-	case CHIP_YELLOW_CARP:
-	case CHIP_CYAN_SKILLFISH:
-		if (adev->asic_type == CHIP_VANGOGH)
-			adev->family = AMDGPU_FAMILY_VGH;
-		else if (adev->asic_type == CHIP_YELLOW_CARP)
-			adev->family = AMDGPU_FAMILY_YC;
-		else
-			adev->family = AMDGPU_FAMILY_NV;
+		adev->family = AMDGPU_FAMILY_NV;
 
 		r = nv_set_ip_blocks(adev);
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +29 -0
 		if (r)
@@ -2167,13 +1830,47 @@ static int amdgpu_device_ip_early_init(struct
 amdgpu_device *adev)
 		return -EINVAL;
 	}
 
+	r = amdgpu_device_parse_gpu_info_fw(adev);
+	if (r)
+		return r;
+
+	if (amdgpu_discovery && adev->asic_type >= CHIP_NAVI10)
+		amdgpu_discovery_get_gfx_info(adev);
+
 	amdgpu_amdkfd_device_probe(adev);
 
+	if (amdgpu_sriov_vf(adev)) {
+		/* handle vbios stuff prior full access mode for new handshake
 */
+		if (adev->virt.req_init_data_ver == 1) {
+			if (!amdgpu_get_bios(adev)) {
+				DRM_ERROR("failed to get vbios\n");
+				return -EINVAL;
+			}
+
+			r = amdgpu_atombios_init(adev);
+			if (r) {
+				dev_err(adev->dev, "amdgpu_atombios_init
 failed\n");
+				amdgpu_vf_error_put(adev,
 AMDGIM_ERROR_VF_ATOMBIOS_INIT_FAIL, 0, 0);
+				return r;
+			}
+		}
+	}
+
+	/*get pf2vf msg info at it's earliest time*/
+	if (amdgpu_sriov_vf(adev))
+		amdgpu_virt_init_data_exchange(adev);
+
+	/* we need to send REQ_GPU here for legacy handshaker otherwise

the vbios

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +7 -0
+	 * will not be prepared by host for this VF */
+	if (amdgpu_sriov_vf(adev) && adev->virt.req_init_data_ver < 1) {
+		r = amdgpu_virt_request_full_gpu(adev, true);
+		if (r)
+			return r;
+	}
+
 	adev->pm.pp_feature = amdgpu_pp_feature_mask;
 	if (amdgpu_sriov_vf(adev) || sched_policy ==

KFD_SCHED_POLICY_NO_HWS)

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -1
 		adev->pm.pp_feature &= ~PP_GFXOFF_MASK;
-	if (amdgpu_sriov_vf(adev) && adev->asic_type ==

CHIP_SIENNA_CICHLID)

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +3 -4
-		adev->pm.pp_feature &= ~PP_OVERDRIVE_MASK;
 
 	for (i = 0; i < adev->num_ip_blocks; i++) {
 		if ((amdgpu_ip_block_mask & (1 << i)) == 0) {
@@ -2198,9 +1895,9 @@ static int amdgpu_device_ip_early_init(struct
 amdgpu_device *adev)
 		}
 		/* get the vbios after the asic_funcs are set up */
 		if (adev->ip_blocks[i].version->type ==
 AMD_IP_BLOCK_TYPE_COMMON) {
-			r = amdgpu_device_parse_gpu_info_fw(adev);
-			if (r)
-				return r;
+			/* skip vbios handling for new handshake */
+			if (amdgpu_sriov_vf(adev) && adev-
 >virt.req_init_data_ver == 1)
+				continue;
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +7 -7
 			/* Read BIOS */
 			if (!amdgpu_get_bios(adev))
@@ -2212,16 +1909,16 @@ static int amdgpu_device_ip_early_init(struct
 amdgpu_device *adev)
 				amdgpu_vf_error_put(adev,
 AMDGIM_ERROR_VF_ATOMBIOS_INIT_FAIL, 0, 0);
 				return r;
 			}
-
-			/*get pf2vf msg info at it's earliest time*/
-			if (amdgpu_sriov_vf(adev))
-				amdgpu_virt_init_data_exchange(adev);
-
 		}
 	}
 
-	adev->cg_flags &= amdgpu_cg_mask;
-	adev->pg_flags &= amdgpu_pg_mask;
+	if (amdgpu_sriov_vf(adev)) {
+		adev->cg_flags &= amdgpu_cg_mask;
+		adev->pg_flags &= amdgpu_pg_mask;
+	} else {
+		adev->cg_flags &= 0xffffffff;
+		adev->pg_flags &= 0xffffffff;
+	}
 
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -3
 	return 0;
 }
@@ -2283,14 +1980,11 @@ static int amdgpu_device_fw_loading(struct
 amdgpu_device *adev)
 			if (adev->ip_blocks[i].version->type !=
 AMD_IP_BLOCK_TYPE_PSP)
 				continue;
 
-			if (!adev->ip_blocks[i].status.sw)
-				continue;
-
 			/* no need to do the fw loading again if already

done*/

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -1
 			if (adev->ip_blocks[i].status.hw == true)
 				break;
 
-			if (amdgpu_in_reset(adev) || adev->in_suspend) {
+			if (adev->in_gpu_reset || adev->in_suspend) {
 				r = adev->ip_blocks[i].version->funcs-
Quoted 1 line

resume(adev);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -0
 				if (r) {
 					DRM_ERROR("resume of IP block <%s>

failed %d\n",

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +6 -0
@@ -2336,6 +2030,12 @@ static int amdgpu_device_ip_init(struct
 amdgpu_device *adev)
 	if (r)
 		return r;
 
+	if (amdgpu_sriov_vf(adev) && adev->virt.req_init_data_ver > 0) {
+		r = amdgpu_virt_request_full_gpu(adev, true);
+		if (r)
+			return -EAGAIN;
+	}
+
 	for (i = 0; i < adev->num_ip_blocks; i++) {
 		if (!adev->ip_blocks[i].status.valid)
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -0
 			continue;
@@ -2410,26 +2110,17 @@ static int amdgpu_device_ip_init(struct
 amdgpu_device *adev)
 	 * it should be called after amdgpu_device_ip_hw_init_phase2  since
 	 * for some ASICs the RAS EEPROM code relies on SMU fully

functioning

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +6 -31
 	 * for I2C communication which only true at this point.
-	 *
-	 * amdgpu_ras_recovery_init may fail, but the upper only cares the
-	 * failure from bad gpu situation and stop amdgpu init process
-	 * accordingly. For other failed cases, it will still release all
-	 * the resource and print error message, rather than returning one
-	 * negative value to upper level.
+	 * recovery_init may fail, but it can free all resources allocated by
+	 * itself and its failure should not stop amdgpu init process.
 	 *
 	 * Note: theoretically, this should be called before all vram allocations
 	 * to protect retired page from abusing
 	 */
-	r = amdgpu_ras_recovery_init(adev);
-	if (r)
-		goto init_failed;
+	amdgpu_ras_recovery_init(adev);
 
 	if (adev->gmc.xgmi.num_physical_nodes > 1)
 		amdgpu_xgmi_add_device(adev);
-
-	/* Don't init kfd if whole hive need to be reset during init */
-	if (!adev->gmc.xgmi.pending_reset)
-		amdgpu_amdkfd_device_init(adev);
+	amdgpu_amdkfd_device_init(adev);
 
 	amdgpu_fru_get_product_info(adev);
@@ -2466,24 +2157,8 @@ static void amdgpu_device_fill_reset_magic(struct
 amdgpu_device *adev)
  */
 static bool amdgpu_device_check_vram_lost(struct amdgpu_device *adev)
 {
-	if (memcmp(adev->gart.ptr, adev->reset_magic,
-			AMDGPU_RESET_MAGIC_NUM))
-		return true;
-
-	if (!amdgpu_in_reset(adev))
-		return false;
-
-	/*
-	 * For all ASICs with baco/mode1 reset, the VRAM is
-	 * always assumed to be lost.
-	 */
-	switch (amdgpu_asic_reset_method(adev)) {
-	case AMD_RESET_METHOD_BACO:
-	case AMD_RESET_METHOD_MODE1:
-		return true;
-	default:
-		return false;
-	}
+	return !!memcmp(adev->gart.ptr, adev->reset_magic,
+			AMDGPU_RESET_MAGIC_NUM);
 }
 

/**

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -2
@@ -2499,8 +2174,8 @@ static bool amdgpu_device_check_vram_lost(struct
 amdgpu_device *adev)
  * Returns 0 on success, negative error code on failure.
  */
 
-int amdgpu_device_set_cg_state(struct amdgpu_device *adev,
-			       enum amd_clockgating_state state)
+static int amdgpu_device_set_cg_state(struct amdgpu_device *adev,
+						enum amd_clockgating_state
 state)
 {
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -4
 	int i, j, r;
@@ -2511,10 +2186,6 @@ int amdgpu_device_set_cg_state(struct
 amdgpu_device *adev,
 		i = state == AMD_CG_STATE_GATE ? j : adev->num_ip_blocks -
 j - 1;
 		if (!adev->ip_blocks[i].status.late_initialized)
 			continue;
-		/* skip CG for GFX on S0ix */
-		if (adev->in_s0ix &&
-		    adev->ip_blocks[i].version->type ==
 AMD_IP_BLOCK_TYPE_GFX)
-			continue;
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -0
 		/* skip CG for VCE/UVD, it's handled specially */
 		if (adev->ip_blocks[i].version->type !=

AMD_IP_BLOCK_TYPE_UVD &&
adev->ip_blocks[i].version->type !=
AMD_IP_BLOCK_TYPE_VCE &&

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -2
@@ -2535,8 +2206,7 @@ int amdgpu_device_set_cg_state(struct
 amdgpu_device *adev,
 	return 0;
 }
 
-int amdgpu_device_set_pg_state(struct amdgpu_device *adev,
-			       enum amd_powergating_state state)
+static int amdgpu_device_set_pg_state(struct amdgpu_device *adev, enum
 amd_powergating_state state)
 {
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -4
 	int i, j, r;
@@ -2547,10 +2217,6 @@ int amdgpu_device_set_pg_state(struct
 amdgpu_device *adev,
 		i = state == AMD_PG_STATE_GATE ? j : adev->num_ip_blocks -
 j - 1;
 		if (!adev->ip_blocks[i].status.late_initialized)
 			continue;
-		/* skip PG for GFX on S0ix */
-		if (adev->in_s0ix &&
-		    adev->ip_blocks[i].version->type ==
 AMD_IP_BLOCK_TYPE_GFX)
-			continue;
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -0
 		/* skip CG for VCE/UVD, it's handled specially */
 		if (adev->ip_blocks[i].version->type !=

AMD_IP_BLOCK_TYPE_UVD &&
adev->ip_blocks[i].version->type !=
AMD_IP_BLOCK_TYPE_VCE &&

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +3 -1
@@ -2590,7 +2256,9 @@ static int
 amdgpu_device_enable_mgpu_fan_boost(void)
 		gpu_ins = &(mgpu_info.gpu_ins[i]);
 		adev = gpu_ins->adev;
 		if (!(adev->flags & AMD_IS_APU) &&
-		    !gpu_ins->mgpu_fan_enabled) {
+		    !gpu_ins->mgpu_fan_enabled &&
+		    adev->powerplay.pp_funcs &&
+		    adev->powerplay.pp_funcs->enable_mgpu_fan_boost) {
 			ret = amdgpu_dpm_enable_mgpu_fan_boost(adev);
 			if (ret)
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -7
 				break;
@@ -2636,8 +2304,6 @@ static int amdgpu_device_ip_late_init(struct
 amdgpu_device *adev)
 		adev->ip_blocks[i].status.late_initialized = true;
 	}
 
-	amdgpu_ras_set_error_query_ready(adev, true);
-
 	amdgpu_device_set_cg_state(adev, AMD_CG_STATE_GATE);
 	amdgpu_device_set_pg_state(adev, AMD_PG_STATE_GATE);
@@ -2647,11 +2313,6 @@ static int amdgpu_device_ip_late_init(struct
 amdgpu_device *adev)
 	if (r)
 		DRM_ERROR("enable mgpu fan boost failed (%d).\n", r);
 
-	/* For XGMI + passthrough configuration on arcturus, enable light SBR
 */
-	if (adev->asic_type == CHIP_ARCTURUS &&
-	    amdgpu_passthrough(adev) &&
-	    adev->gmc.xgmi.num_physical_nodes > 1)
-		smu_set_light_sbr(&adev->smu, true);
 
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -2
 	if (adev->gmc.xgmi.num_physical_nodes > 1) {
 		mutex_lock(&mgpu_info.mutex);
@@ -2675,8 +2336,7 @@ static int amdgpu_device_ip_late_init(struct
 amdgpu_device *adev)
 				if (gpu_instance->adev->flags & AMD_IS_APU)
 					continue;
 
-				r = amdgpu_xgmi_set_pstate(gpu_instance-
 >adev,
-
 	AMDGPU_XGMI_PSTATE_MIN);
+				r = amdgpu_xgmi_set_pstate(gpu_instance-
Quoted 1 line

adev, 0);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -0
 				if (r) {
 					DRM_ERROR("pstate setting failed

(%d).\n", r);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -29
 					break;
@@ -2690,59 +2350,6 @@ static int amdgpu_device_ip_late_init(struct
 amdgpu_device *adev)
 	return 0;
 }
 
-static int amdgpu_device_ip_fini_early(struct amdgpu_device *adev)
-{
-	int i, r;
-
-	for (i = 0; i < adev->num_ip_blocks; i++) {
-		if (!adev->ip_blocks[i].version->funcs->early_fini)
-			continue;
-
-		r = adev->ip_blocks[i].version->funcs->early_fini((void *)adev);
-		if (r) {
-			DRM_DEBUG("early_fini of IP block <%s> failed %d\n",
-				  adev->ip_blocks[i].version->funcs->name, r);
-		}
-	}
-
-	amdgpu_amdkfd_suspend(adev, false);
-
-	amdgpu_device_set_pg_state(adev, AMD_PG_STATE_UNGATE);
-	amdgpu_device_set_cg_state(adev, AMD_CG_STATE_UNGATE);
-
-	/* need to disable SMC first */
-	for (i = 0; i < adev->num_ip_blocks; i++) {
-		if (!adev->ip_blocks[i].status.hw)
-			continue;
-		if (adev->ip_blocks[i].version->type ==
 AMD_IP_BLOCK_TYPE_SMC) {
-			r = adev->ip_blocks[i].version->funcs->hw_fini((void
 *)adev);
-			/* XXX handle errors */
-			if (r) {
-				DRM_DEBUG("hw_fini of IP block <%s>

failed %d\n",

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -1
-					  adev->ip_blocks[i].version->funcs-
Quoted 1 line

name, r);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +17 -25
-			}
-			adev->ip_blocks[i].status.hw = false;
-			break;
-		}
-	}
-
-	for (i = adev->num_ip_blocks - 1; i >= 0; i--) {
-		if (!adev->ip_blocks[i].status.hw)
-			continue;
-
-		r = adev->ip_blocks[i].version->funcs->hw_fini((void *)adev);
-		/* XXX handle errors */
-		if (r) {
-			DRM_DEBUG("hw_fini of IP block <%s> failed %d\n",
-				  adev->ip_blocks[i].version->funcs->name, r);
-		}
-
-		adev->ip_blocks[i].status.hw = false;
-	}
-
-	return 0;
-}
-
 /**
  * amdgpu_device_ip_fini - run fini for hardware IPs
  *
@@ -2754,7 +2361,7 @@ static int amdgpu_device_ip_fini_early(struct
 amdgpu_device *adev)
  * and sw_fini tears down any software state associated with each IP.
  * Returns 0 on success, negative error code on failure.
  */
-static int amdgpu_device_ip_fini(struct amdgpu_device *adev)
+static int amdgpu_device_ip_fini(struct amdgpu_device *adev, int skip_hw)
 {
 	int i, r;
@@ -2766,7 +2373,43 @@ static int amdgpu_device_ip_fini(struct
 amdgpu_device *adev)
 	if (adev->gmc.xgmi.num_physical_nodes > 1)
 		amdgpu_xgmi_remove_device(adev);
 
-	amdgpu_amdkfd_device_fini_sw(adev);
+	if (!skip_hw)
+		amdgpu_amdkfd_device_fini(adev);
+
+	amdgpu_device_set_pg_state(adev, AMD_PG_STATE_UNGATE);
+	amdgpu_device_set_cg_state(adev, AMD_CG_STATE_UNGATE);
+
+	if (!skip_hw) {
+		/* need to disable SMC first */
+		for (i = 0; i < adev->num_ip_blocks; i++) {
+			if (!adev->ip_blocks[i].status.hw)
+				continue;
+			if (adev->ip_blocks[i].version->type ==
 AMD_IP_BLOCK_TYPE_SMC) {
+				r = adev->ip_blocks[i].version->funcs-
 >hw_fini((void *)adev);
+				/* XXX handle errors */
+				if (r) {
+					DRM_DEBUG("hw_fini of IP block <%s>

failed %d\n",

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -0
+							adev-
Quoted 1 line

ip_blocks[i].version->funcs->name, r);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +11 -0
+				}
+				adev->ip_blocks[i].status.hw = false;
+				break;
+			}
+		}
+
+		for (i = adev->num_ip_blocks - 1; i >= 0; i--) {
+			if (!adev->ip_blocks[i].status.hw)
+				continue;
+
+			r = adev->ip_blocks[i].version->funcs->hw_fini((void

*)adev);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +3 -0
+			/* XXX handle errors */
+			if (r) {
+				DRM_DEBUG("hw_fini of IP block <%s>

failed %d\n",

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -0
+						adev->ip_blocks[i].version-
Quoted 1 line

funcs->name, r);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +15 -16
+			}
+
+			adev->ip_blocks[i].status.hw = false;
+		}
+	}
 
 	for (i = adev->num_ip_blocks - 1; i >= 0; i--) {
 		if (!adev->ip_blocks[i].status.sw)
@@ -2857,21 +2500,18 @@ static int
 amdgpu_device_ip_suspend_phase1(struct amdgpu_device *adev)
 	for (i = adev->num_ip_blocks - 1; i >= 0; i--) {
 		if (!adev->ip_blocks[i].status.valid)
 			continue;
-
 		/* displays are handled separately */
-		if (adev->ip_blocks[i].version->type !=
 AMD_IP_BLOCK_TYPE_DCE)
-			continue;
-
-		/* XXX handle errors */
-		r = adev->ip_blocks[i].version->funcs->suspend(adev);
-		/* XXX handle errors */
-		if (r) {
-			DRM_ERROR("suspend of IP block <%s> failed %d\n",
-				  adev->ip_blocks[i].version->funcs->name, r);
-			return r;
+		if (adev->ip_blocks[i].version->type ==
 AMD_IP_BLOCK_TYPE_DCE) {
+			/* XXX handle errors */
+			r = adev->ip_blocks[i].version->funcs->suspend(adev);
+			/* XXX handle errors */
+			if (r) {
+				DRM_ERROR("suspend of IP block <%s>
 failed %d\n",
+					  adev->ip_blocks[i].version->funcs-
 >name, r);
+				return r;
+			}
+			adev->ip_blocks[i].status.hw = false;
 		}
-
-		adev->ip_blocks[i].status.hw = false;
 	}
 
 	return 0;
@@ -2892,9 +2532,6 @@ static int amdgpu_device_ip_suspend_phase2(struct
 amdgpu_device *adev)
 {
 	int i, r;
 
-	if (adev->in_s0ix)
-		amdgpu_gfx_state_change_set(adev,
 sGpuChangeState_D3Entry);
-
 	for (i = adev->num_ip_blocks - 1; i >= 0; i--) {
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -4
 		if (!adev->ip_blocks[i].status.valid)
 			continue;
@@ -2907,27 +2544,6 @@ static int
 amdgpu_device_ip_suspend_phase2(struct amdgpu_device *adev)
 			adev->ip_blocks[i].status.hw = false;
 			continue;
 		}
-
-		/* skip unnecessary suspend if we do not initialize them yet */
-		if (adev->gmc.xgmi.pending_reset &&
-		    !(adev->ip_blocks[i].version->type ==

AMD_IP_BLOCK_TYPE_GMC ||

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -1
-		      adev->ip_blocks[i].version->type ==

AMD_IP_BLOCK_TYPE_SMC ||

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -1
-		      adev->ip_blocks[i].version->type ==

AMD_IP_BLOCK_TYPE_COMMON ||

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -1
-		      adev->ip_blocks[i].version->type ==

AMD_IP_BLOCK_TYPE_IH)) {

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -11
-			adev->ip_blocks[i].status.hw = false;
-			continue;
-		}
-
-		/* skip suspend of gfx and psp for S0ix
-		 * gfx is in gfxoff state, so on resume it will exit gfxoff just
-		 * like at runtime. PSP is also part of the always on hardware
-		 * so no need to suspend it.
-		 */
-		if (adev->in_s0ix &&
-		    (adev->ip_blocks[i].version->type ==

AMD_IP_BLOCK_TYPE_PSP ||

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -1
-		     adev->ip_blocks[i].version->type ==

AMD_IP_BLOCK_TYPE_GFX))

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -2
-			continue;
-
 		/* XXX handle errors */
 		r = adev->ip_blocks[i].version->funcs->suspend(adev);
 		/* XXX handle errors */
@@ -2947,6 +2563,7 @@ static int amdgpu_device_ip_suspend_phase2(struct
 amdgpu_device *adev)
 				}
 			}
 		}
+		adev->ip_blocks[i].status.hw = false;
 	}
 
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +14 -9
 	return 0;
@@ -2965,17 +2582,22 @@ static int
 amdgpu_device_ip_suspend_phase2(struct amdgpu_device *adev)
  */
 int amdgpu_device_ip_suspend(struct amdgpu_device *adev)
 {
-	int r;
+	int r = 0;
+	int skip_hw = 0;
 
-	if (amdgpu_sriov_vf(adev)) {
-		amdgpu_virt_fini_data_exchange(adev);
-		amdgpu_virt_request_full_gpu(adev, false);
-	}
+	if (amdgpu_sriov_vf(adev))
+		skip_hw = amdgpu_virt_request_full_gpu(adev, false);
 
-	r = amdgpu_device_ip_suspend_phase1(adev);
-	if (r)
-		return r;
-	r = amdgpu_device_ip_suspend_phase2(adev);
+	/* In case amdgpu_virt_request_full_gpu failed and vm cannot get
+	 * full access, we should skip touching hw and let poweroff continue
+	 */
+
+	if (!skip_hw) {
+		r = amdgpu_device_ip_suspend_phase1(adev);
+		if (r)
+			return r;
+		r = amdgpu_device_ip_suspend_phase2(adev);
+	}
 
 	if (amdgpu_sriov_vf(adev))
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -2
 		amdgpu_virt_release_full_gpu(adev, false);
@@ -2997,7 +2619,6 @@ static int
 amdgpu_device_ip_reinit_early_sriov(struct amdgpu_device *adev)
 	for (i = 0; i < adev->num_ip_blocks; i++) {
 		int j;
 		struct amdgpu_ip_block *block;
-
 		block = &adev->ip_blocks[i];
 		block->status.hw = false;
@@ -3172,7 +2793,7 @@ static void amdgpu_device_detect_sriov_bios(struct
 amdgpu_device *adev)
 {
 	if (amdgpu_sriov_vf(adev)) {
 		if (adev->is_atom_fw) {
-			if
 (amdgpu_atomfirmware_gpu_virtualization_supported(adev))
+			if
 (amdgpu_atomfirmware_gpu_supports_virtualization(adev))

adev->virt.caps |=
AMDGPU_SRIOV_CAPS_SRIOV_VBIOS;

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -0
 		} else {
 			if

(amdgpu_atombios_has_gpu_virtualization_table(adev))

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -6
@@ -3196,12 +2817,6 @@ bool amdgpu_device_asic_has_dc_support(enum
 amd_asic_type asic_type)
 {
 	switch (asic_type) {
 #if defined(CONFIG_DRM_AMD_DC)
-#if defined(CONFIG_DRM_AMD_DC_SI)
-	case CHIP_TAHITI:
-	case CHIP_PITCAIRN:
-	case CHIP_VERDE:
-	case CHIP_OLAND:
-#endif
 	case CHIP_BONAIRE:
 	case CHIP_KAVERI:
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +5 -8
 	case CHIP_KABINI:
@@ -3226,24 +2841,22 @@ bool amdgpu_device_asic_has_dc_support(enum
 amd_asic_type asic_type)
 	case CHIP_VEGA10:
 	case CHIP_VEGA12:
 	case CHIP_VEGA20:
-#if defined(CONFIG_DRM_AMD_DC_DCN)
+#if defined(CONFIG_DRM_AMD_DC_DCN1_0)
 	case CHIP_RAVEN:
+#endif
+#if defined(CONFIG_DRM_AMD_DC_DCN2_0)
 	case CHIP_NAVI10:
 	case CHIP_NAVI14:
 	case CHIP_NAVI12:
+#endif
+#if defined(CONFIG_DRM_AMD_DC_DCN2_1)
 	case CHIP_RENOIR:
-	case CHIP_SIENNA_CICHLID:
-	case CHIP_NAVY_FLOUNDER:
-	case CHIP_DIMGREY_CAVEFISH:
-	case CHIP_BEIGE_GOBY:
-	case CHIP_VANGOGH:
-	case CHIP_YELLOW_CARP:
 #endif
 		return amdgpu_dc != 0;
 #endif
 	default:
 		if (amdgpu_dc > 0)
-			DRM_INFO_ONCE("Display Core has been requested

via kernel parameter "

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -0
+			DRM_INFO("Display Core has been requested via

kernel parameter "
"but isn't supported by ASIC,
ignoring\n");

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +4 -5
 		return false;
 	}
@@ -3252,25 +2865,24 @@ bool amdgpu_device_asic_has_dc_support(enum
 amd_asic_type asic_type)
 /**
  * amdgpu_device_has_dc_support - check if dc is supported
  *
- * @adev: amdgpu_device pointer
+ * @adev: amdgpu_device_pointer
  *
  * Returns true for supported, false for not supported
  */
 bool amdgpu_device_has_dc_support(struct amdgpu_device *adev)
 {
-	if (amdgpu_sriov_vf(adev) ||
-	    adev->enable_virtual_display ||
-	    (adev->harvest_ip_mask & AMD_HARVEST_IP_DMU_MASK))
+	if (adev->enable_virtual_display)
 		return false;
 
 	return amdgpu_device_asic_has_dc_support(adev->asic_type);
 }
 
+
 static void amdgpu_device_xgmi_reset_func(struct work_struct *__work)
 {
 	struct amdgpu_device *adev =
 		container_of(__work, struct amdgpu_device,
 xgmi_reset_work);
-	struct amdgpu_hive_info *hive = amdgpu_get_xgmi_hive(adev);
+	struct amdgpu_hive_info *hive = amdgpu_get_xgmi_hive(adev, 0);
 
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -5
 	/* It's a bug to not have a hive within this function */
 	if (WARN_ON(!hive))
@@ -3285,20 +2897,19 @@ static void
 amdgpu_device_xgmi_reset_func(struct work_struct *__work)
 	if (amdgpu_asic_reset_method(adev) == AMD_RESET_METHOD_BACO)
 {
 
 		task_barrier_enter(&hive->tb);
-		adev->asic_reset_res =
 amdgpu_device_baco_enter(adev_to_drm(adev));
+		adev->asic_reset_res = amdgpu_device_baco_enter(adev-
 >ddev);
 
 		if (adev->asic_reset_res)
 			goto fail;
 
 		task_barrier_exit(&hive->tb);
-		adev->asic_reset_res =
 amdgpu_device_baco_exit(adev_to_drm(adev));
+		adev->asic_reset_res = amdgpu_device_baco_exit(adev-
 >ddev);
 
 		if (adev->asic_reset_res)
 			goto fail;
 
-		if (adev->mmhub.ras_funcs &&
-		    adev->mmhub.ras_funcs->reset_ras_error_count)
-			adev->mmhub.ras_funcs-
Quoted 1 line

reset_ras_error_count(adev);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -0
+		if (adev->mmhub.funcs && adev->mmhub.funcs-
Quoted 1 line

reset_ras_error_count)

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -2
+			adev->mmhub.funcs->reset_ras_error_count(adev);
 	} else {
 
 		task_barrier_full(&hive->tb);
@@ -3308,8 +2919,7 @@ static void amdgpu_device_xgmi_reset_func(struct
 work_struct *__work)
 fail:
 	if (adev->asic_reset_res)
 		DRM_WARN("ASIC reset failed with error, %d for drm dev, %s",
-			 adev->asic_reset_res, adev_to_drm(adev)->unique);
-	amdgpu_put_xgmi_hive(hive);
+			 adev->asic_reset_res, adev->ddev->unique);
 }
 

static int amdgpu_device_get_job_timeout_settings(struct amdgpu_device
*adev)

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -2
@@ -3321,8 +2931,8 @@ static int
 amdgpu_device_get_job_timeout_settings(struct amdgpu_device *adev)
 	int ret = 0;
 
 	/*
-	 * By default timeout for non compute jobs is 10000
-	 * and 60000 for compute jobs.
+	 * By default timeout for non compute jobs is 10000.
+	 * And there is no timeout enforced on compute jobs.
 	 * In SR-IOV or passthrough mode, timeout for compute
 	 * jobs are 60000 by default.
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +3 -1
 	 */
@@ -3331,8 +2941,10 @@ static int
 amdgpu_device_get_job_timeout_settings(struct amdgpu_device *adev)
 	if (amdgpu_sriov_vf(adev))
 		adev->compute_timeout = amdgpu_sriov_is_pp_one_vf(adev) ?
 					msecs_to_jiffies(60000) :
 msecs_to_jiffies(10000);
-	else
+	else if (amdgpu_passthrough(adev))
 		adev->compute_timeout =  msecs_to_jiffies(60000);
+	else
+		adev->compute_timeout = MAX_SCHEDULE_TIMEOUT;
 
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +36 -7
 	if (strnlen(input, AMDGPU_MAX_TIMEOUT_PARAM_LENGTH)) {
 		while ((timeout_setting = strsep(&input, ",")) &&
@@ -3381,18 +2993,47 @@ static int
 amdgpu_device_get_job_timeout_settings(struct amdgpu_device *adev)
 	return ret;
 }
 
-static const struct attribute *amdgpu_dev_attributes[] = {
-	&dev_attr_product_name.attr,
-	&dev_attr_product_number.attr,
-	&dev_attr_serial_number.attr,
-	&dev_attr_pcie_replay_count.attr,
-	NULL
-};
+/**
+ *
+ * The amdgpu driver provides a sysfs API for providing driver version data.
+ */
+static ssize_t amdgpu_get_driver_version(struct device *dev,
+				      struct device_attribute *attr,
+				      char *buf)
+{
+	return snprintf(buf, PAGE_SIZE, "%s\n",
+#ifdef BUILD_NUM
+		__stringify(INTERNAL_VER)"."__stringify(BUILD_NUM));
+#else
+		__stringify(INTERNAL_VER));
+#endif
+}
+
+static DEVICE_ATTR(version, S_IRUGO, amdgpu_get_driver_version, NULL);
+
+static int amdgpu_version_sysfs_init(struct amdgpu_device *adev)
+{
+	int ret;
+
+	ret = device_create_file(adev->dev, &dev_attr_version);
+	if (ret) {
+		DRM_ERROR("failed to create device file for version\n");
+		return ret;
+	}
+	return 0;
+}
+
+static void amdgpu_version_sysfs_fini(struct amdgpu_device *adev)
+{
+	device_remove_file(adev->dev, &dev_attr_version);
+}
 
 /**
  * amdgpu_device_init - initialize the driver
  *
  * @adev: amdgpu_device pointer
+ * @ddev: drm dev pointer
+ * @pdev: pci dev pointer
  * @flags: driver flags
  *

* Initializes the driver info and hw (all asics).

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +6 -3
@@ -3400,15 +3041,18 @@ static const struct attribute
 *amdgpu_dev_attributes[] = {
  * Called at driver startup.
  */
 int amdgpu_device_init(struct amdgpu_device *adev,
+		       struct drm_device *ddev,
+		       struct pci_dev *pdev,
 		       uint32_t flags)
 {
-	struct drm_device *ddev = adev_to_drm(adev);
-	struct pci_dev *pdev = adev->pdev;
 	int r, i;
-	bool px = false;
+	bool boco = false;
 	u32 max_MBps;
 
 	adev->shutdown = false;
+	adev->dev = &pdev->dev;
+	adev->ddev = ddev;
+	adev->pdev = pdev;
 	adev->flags = flags;
 

if (amdgpu_force_asic_type >= 0 && amdgpu_force_asic_type <
CHIP_LAST)

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -1
@@ -3427,7 +3071,6 @@ int amdgpu_device_init(struct amdgpu_device
 *adev,
 	adev->vm_manager.vm_pte_funcs = NULL;
 	adev->vm_manager.vm_pte_num_scheds = 0;
 	adev->gmc.gmc_funcs = NULL;
-	adev->harvest_ip_mask = 0x0;
 	adev->fence_context =
 dma_fence_context_alloc(AMDGPU_MAX_RINGS);

bitmap_zero(adev->gfx.pipe_reserve_bitmap,
AMDGPU_MAX_COMPUTE_QUEUES);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -0
@@ -3454,6 +3097,7 @@ int amdgpu_device_init(struct amdgpu_device
 *adev,
 
 	/* mutex initialization are all done here so we
 	 * can recall function without having locking issues */
+	atomic_set(&adev->irq.ih.lock, 0);
 	mutex_init(&adev->firmware.mutex);
 	mutex_init(&adev->pm.mutex);
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -7
 	mutex_init(&adev->gfx.gpu_clock_mutex);
@@ -3464,14 +3108,9 @@ int amdgpu_device_init(struct amdgpu_device
 *adev,
 	mutex_init(&adev->mn_lock);
 	mutex_init(&adev->virt.vf_errors.lock);
 	hash_init(adev->mn_hash);
-	atomic_set(&adev->in_gpu_reset, 0);
-	init_rwsem(&adev->reset_sem);
+	mutex_init(&adev->lock_reset);
 	mutex_init(&adev->psp.mutex);
-	mutex_init(&adev->notifier_lock);
-
-	r = amdgpu_device_init_apu_flags(adev);
-	if (r)
-		return r;
+	mutex_init(&adev->virt.dump_mutex);
 
 	r = amdgpu_device_check_arguments(adev);
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -1
 	if (r)
@@ -3490,7 +3129,8 @@ int amdgpu_device_init(struct amdgpu_device
 *adev,
 	INIT_LIST_HEAD(&adev->shadow_list);
 	mutex_init(&adev->shadow_list_lock);
 
-	INIT_LIST_HEAD(&adev->reset_list);
+	INIT_LIST_HEAD(&adev->ring_lru_list);
+	spin_lock_init(&adev->ring_lru_list_lock);
 
 	INIT_DELAYED_WORK(&adev->delayed_init_work,
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -12
 			  amdgpu_device_delayed_init_work_handler);
@@ -3500,18 +3140,7 @@ int amdgpu_device_init(struct amdgpu_device
 *adev,
 	INIT_WORK(&adev->xgmi_reset_work,
 amdgpu_device_xgmi_reset_func);
 
 	adev->gfx.gfx_off_req_count = 1;
-	adev->pm.ac_power = power_supply_is_system_supplied() > 0;
-
-	atomic_set(&adev->throttling_logging_enabled, 1);
-	/*
-	 * If throttling continues, logging will be performed every minute
-	 * to avoid log flooding. "-1" is subtracted since the thermal
-	 * throttling interrupt comes every second. Thus, the total logging
-	 * interval is 59 seconds(retelimited printk interval) + 1(waiting
-	 * for throttling interrupt) = 60 seconds.
-	 */
-	ratelimit_state_init(&adev->throttling_logging_rs, (60 - 1) * HZ, 1);
-	ratelimit_set_flags(&adev->throttling_logging_rs,
 RATELIMIT_MSG_ON_RELEASE);
+	adev->pm.ac_power = power_supply_is_system_supplied() > 0 ? true :

false;

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +5 -0
 	/* Registers mapping */
 	/* TODO: block userspace mapping of io register */
@@ -3530,6 +3159,17 @@ int amdgpu_device_init(struct amdgpu_device
 *adev,
 	DRM_INFO("register mmio base: 0x%08X\n", (uint32_t)adev-
 >rmmio_base);
 	DRM_INFO("register mmio size: %u\n", (unsigned)adev->rmmio_size);
 
+	/* io port mapping */
+	for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) {
+		if (pci_resource_flags(adev->pdev, i) & IORESOURCE_IO) {
+			adev->rio_mem_size = pci_resource_len(adev->pdev,
 i);
+			adev->rio_mem = pci_iomap(adev->pdev, i, adev-
Quoted 1 line

rio_mem_size);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +6 -0
+			break;
+		}
+	}
+	if (adev->rio_mem == NULL)
+		DRM_INFO("PCI I/O BAR is not found.\n");
+
 	/* enable PCIE atomic ops */
 	r = pci_enable_atomic_ops_to_root(adev->pdev,

PCI_EXP_DEVCAP2_ATOMIC_COMP32 |

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +16 -2
@@ -3566,14 +3206,28 @@ int amdgpu_device_init(struct amdgpu_device
 *adev,
 	/* doorbell bar mapping and doorbell index init*/
 	amdgpu_device_doorbell_init(adev);
 
+	/* if we have > 1 VGA cards, then disable the amdgpu VGA resources */
+	/* this will fail for cards that aren't VGA class devices, just
+	 * ignore it */
+	vga_client_register(adev->pdev, adev, NULL,
 amdgpu_device_vga_set_decode);
+
+	if (amdgpu_device_supports_boco(ddev))
+		boco = true;
+	if (amdgpu_has_atpx() &&
+	    (amdgpu_is_atpx_hybrid() ||
+	     amdgpu_has_atpx_dgpu_power_cntl()) &&
+	    !pci_is_thunderbolt_attached(adev->pdev))
+		vga_switcheroo_register_client(adev->pdev,
+					       &amdgpu_switcheroo_ops, boco);
+	if (boco)
+		vga_switcheroo_init_domain_pm_ops(adev->dev, &adev-
 >vga_pm_domain);
+
 	if (amdgpu_emu_mode == 1) {
 		/* post the asic on emulation mode */
 		emu_soc_asic_init(adev);
 		goto fence_driver_init;
 	}
 
-	amdgpu_reset_init(adev);
-
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -4
 	/* detect if we are with an SRIOV vbios */
 	amdgpu_device_detect_sriov_bios(adev);
@@ -3581,33 +3235,13 @@ int amdgpu_device_init(struct amdgpu_device
 *adev,
 	 *  E.g., driver was not cleanly unloaded previously, etc.
 	 */
 	if (!amdgpu_sriov_vf(adev) &&
 amdgpu_asic_need_reset_on_init(adev)) {
-		if (adev->gmc.xgmi.num_physical_nodes) {
-			dev_info(adev->dev, "Pending hive reset.\n");
-			adev->gmc.xgmi.pending_reset = true;
-			/* Only need to init necessary block for SMU to handle

the reset */

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -4
-			for (i = 0; i < adev->num_ip_blocks; i++) {
-				if (!adev->ip_blocks[i].status.valid)
-					continue;
-				if (!(adev->ip_blocks[i].version->type ==

AMD_IP_BLOCK_TYPE_GMC ||

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -1
-				      adev->ip_blocks[i].version->type ==

AMD_IP_BLOCK_TYPE_COMMON ||

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -1
-				      adev->ip_blocks[i].version->type ==

AMD_IP_BLOCK_TYPE_IH ||

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -1
-				      adev->ip_blocks[i].version->type ==

AMD_IP_BLOCK_TYPE_SMC)) {

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -1
-					DRM_DEBUG("IP %s disabled for

hw_init.\n",

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -1
-						adev->ip_blocks[i].version-
Quoted 1 line

funcs->name);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -7
-					adev->ip_blocks[i].status.hw = true;
-				}
-			}
-		} else {
-			r = amdgpu_asic_reset(adev);
-			if (r) {
-				dev_err(adev->dev, "asic reset on init

failed\n");

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +5 -5
-				goto failed;
-			}
+		r = amdgpu_asic_reset(adev);
+		if (r) {
+			dev_err(adev->dev, "asic reset on init failed\n");
+			goto failed;
 		}
 	}
 
-	pci_enable_pcie_error_reporting(adev->pdev);
-
 	/* Post card if necessary */
 	if (amdgpu_device_need_post(adev)) {
 		if (!adev->bios) {
@@ -3616,7 +3250,7 @@ int amdgpu_device_init(struct amdgpu_device
 *adev,
 			goto failed;
 		}
 		DRM_INFO("GPU posting now...\n");
-		r = amdgpu_device_asic_init(adev);
+		r = amdgpu_atom_asic_init(adev->mode_info.atom_context);
 		if (r) {
 			dev_err(adev->dev, "gpu post error!\n");
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +3 -3
 			goto failed;
@@ -3646,15 +3280,15 @@ int amdgpu_device_init(struct amdgpu_device
 *adev,
 
 fence_driver_init:
 	/* Fence driver */
-	r = amdgpu_fence_driver_sw_init(adev);
+	r = amdgpu_fence_driver_init(adev);
 	if (r) {
-		dev_err(adev->dev, "amdgpu_fence_driver_sw_init failed\n");
+		dev_err(adev->dev, "amdgpu_fence_driver_init failed\n");
 		amdgpu_vf_error_put(adev,
 AMDGIM_ERROR_VF_FENCE_INIT_FAIL, 0, 0);
 		goto failed;
 	}
 
 	/* init the mode config */
-	drm_mode_config_init(adev_to_drm(adev));
+	drm_mode_config_init(adev->ddev);
 
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +5 -6
 	r = amdgpu_device_ip_init(adev);
 	if (r) {
@@ -3668,22 +3302,21 @@ int amdgpu_device_init(struct amdgpu_device
 *adev,
 			adev->virt.caps &= ~AMDGPU_SRIOV_CAPS_RUNTIME;
 			adev->virt.ops = NULL;
 			r = -EAGAIN;
-			goto release_ras_con;
+			goto failed;
 		}
 		dev_err(adev->dev, "amdgpu_device_ip_init failed\n");
 		amdgpu_vf_error_put(adev,
 AMDGIM_ERROR_VF_AMDGPU_INIT_FAIL, 0, 0);
-		goto release_ras_con;
+		goto failed;
 	}
 
-	amdgpu_fence_driver_hw_init(adev);
-
-	dev_info(adev->dev,
-		"SE %d, SH per SE %d, CU per SH %d, active_cu_number %d\n",
+	DRM_DEBUG("SE %d, SH per SE %d, CU per SH %d,
 active_cu_number %d\n",
 			adev->gfx.config.max_shader_engines,
 			adev->gfx.config.max_sh_per_se,
 			adev->gfx.config.max_cu_per_sh,
 			adev->gfx.cu_info.number);
 
+	amdgpu_ctx_init_sched(adev);
+
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +8 -0
 	adev->accel_working = true;
 
 	amdgpu_vm_check_compute_bug(adev);
@@ -3705,6 +3338,14 @@ int amdgpu_device_init(struct amdgpu_device
 *adev,
 	} else
 		adev->pm_sysfs_en = true;
 
+	r = amdgpu_pm_uuid_sysfs_init(adev);
+	if (r)
+		DRM_ERROR("Creating uuid sysfs failed (%d).\n", r);
+
+	r = amdgpu_version_sysfs_init(adev);
+	if (r)
+		DRM_ERROR("Creating version sysfs failed (%d).\n", r);
+
 	r = amdgpu_ucode_sysfs_init(adev);
 	if (r) {
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +40 -55
 		adev->ucode_sysfs_en = false;
@@ -3735,84 +3376,66 @@ int amdgpu_device_init(struct amdgpu_device
 *adev,
 	/* enable clockgating, etc. after ib tests, etc. since some blocks require
 	 * explicit gating rather than handling it automatically.
 	 */
-	if (!adev->gmc.xgmi.pending_reset) {
-		r = amdgpu_device_ip_late_init(adev);
+	r = amdgpu_device_ip_late_init(adev);
+	if (r) {
+		dev_err(adev->dev, "amdgpu_device_ip_late_init failed\n");
+		amdgpu_vf_error_put(adev,
 AMDGIM_ERROR_VF_AMDGPU_LATE_INIT_FAIL, 0, r);
+		goto failed;
+	}
+
+	/* must succeed. */
+	amdgpu_ras_resume(adev);
+
+	if (amdgpu_sriov_vf(adev)) {
+		r = amdgpu_ib_ring_tests(adev);
 		if (r) {
-			dev_err(adev->dev, "amdgpu_device_ip_late_init
 failed\n");
-			amdgpu_vf_error_put(adev,
 AMDGIM_ERROR_VF_AMDGPU_LATE_INIT_FAIL, 0, r);
-			goto release_ras_con;
+			DRM_ERROR("ib ring test failed (%d).\n", r);
+			return r;
 		}
-		/* must succeed. */
-		amdgpu_ras_resume(adev);
+	} else {
 		queue_delayed_work(system_wq, &adev->delayed_init_work,
-				   msecs_to_jiffies(AMDGPU_RESUME_MS));
+			   msecs_to_jiffies(AMDGPU_RESUME_MS));
 	}
 
-	if (amdgpu_sriov_vf(adev))
-		flush_delayed_work(&adev->delayed_init_work);
+	r = device_create_file(adev->dev, &dev_attr_pcie_replay_count);
+	if (r) {
+		dev_err(adev->dev, "Could not create pcie_replay_count");
+		return r;
+	}
 
-	r = sysfs_create_files(&adev->dev->kobj, amdgpu_dev_attributes);
-	if (r)
-		dev_err(adev->dev, "Could not create amdgpu device attr\n");
+	r = device_create_file(adev->dev, &dev_attr_product_name);
+	if (r) {
+		dev_err(adev->dev, "Could not create product_name");
+		return r;
+	}
+
+	r = device_create_file(adev->dev, &dev_attr_product_number);
+	if (r) {
+		dev_err(adev->dev, "Could not create product_number");
+		return r;
+	}
+
+	r = device_create_file(adev->dev, &dev_attr_serial_number);
+	if (r) {
+		dev_err(adev->dev, "Could not create serial_number");
+		return r;
+	}
 
 	if (IS_ENABLED(CONFIG_PERF_EVENTS))
 		r = amdgpu_pmu_init(adev);
 	if (r)
 		dev_err(adev->dev, "amdgpu_pmu_init failed\n");
 
-	/* Have stored pci confspace at hand for restore in sudden PCI error */
-	if (amdgpu_device_cache_pci_state(adev->pdev))
-		pci_restore_state(pdev);
-
-	/* if we have > 1 VGA cards, then disable the amdgpu VGA resources */
-	/* this will fail for cards that aren't VGA class devices, just
-	 * ignore it */
-	if ((adev->pdev->class >> 8) == PCI_CLASS_DISPLAY_VGA)
-		vga_client_register(adev->pdev, adev, NULL,
 amdgpu_device_vga_set_decode);
-
-	if (amdgpu_device_supports_px(ddev)) {
-		px = true;
-		vga_switcheroo_register_client(adev->pdev,
-					       &amdgpu_switcheroo_ops, px);
-		vga_switcheroo_init_domain_pm_ops(adev->dev, &adev-
 >vga_pm_domain);
-	}
-
-	if (adev->gmc.xgmi.pending_reset)
-		queue_delayed_work(system_wq,
 &mgpu_info.delayed_reset_work,
-				   msecs_to_jiffies(AMDGPU_RESUME_MS));
-
 	return 0;
 
-release_ras_con:
-	amdgpu_release_ras_context(adev);
-
 failed:
 	amdgpu_vf_error_trans_all(adev);
+	if (boco)
+		vga_switcheroo_fini_domain_pm_ops(adev->dev);
 
 	return r;
 }
 
-static void amdgpu_device_unmap_mmio(struct amdgpu_device *adev)
-{
-	/* Clear all CPU mappings pointing to this device */
-	unmap_mapping_range(adev->ddev.anon_inode->i_mapping, 0, 0, 1);
-
-	/* Unmap all mapped bars - Doorbell, registers and VRAM */
-	amdgpu_device_doorbell_fini(adev);
-
-	iounmap(adev->rmmio);
-	adev->rmmio = NULL;
-	if (adev->mman.aper_base_kaddr)
-		iounmap(adev->mman.aper_base_kaddr);
-	adev->mman.aper_base_kaddr = NULL;
-
-	/* Memory manager related */
-	if (!adev->gmc.xgmi.connected_to_cpu) {
-		arch_phys_wc_del(adev->gmc.vram_mtrr);
-		arch_io_free_memtype_wc(adev->gmc.aper_base, adev-
Quoted 1 line

gmc.aper_size);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +26 -38
-	}
-}
-
 /**
  * amdgpu_device_fini - tear down the driver
  *
@@ -3821,58 +3444,49 @@ static void amdgpu_device_unmap_mmio(struct
 amdgpu_device *adev)
  * Tear down the driver info (all asics).
  * Called at driver shutdown.
  */
-void amdgpu_device_fini_hw(struct amdgpu_device *adev)
+void amdgpu_device_fini(struct amdgpu_device *adev)
 {
-	dev_info(adev->dev, "amdgpu: finishing device.\n");
-	flush_delayed_work(&adev->delayed_init_work);
+	int r = 0;
+	/* In case amdgpu_virt_request_full_gpu failed and vm cannot get
+	* full access, we should skip touching hw and let unload continue
+	*/
+	int skip_hw = 0;
+
+	DRM_INFO("amdgpu: finishing device.\n");
+	if (!amdgpu_sriov_vf(adev))
+		flush_delayed_work(&adev->delayed_init_work);
 	ttm_bo_lock_delayed_workqueue(&adev->mman.bdev);
 	adev->shutdown = true;
 
 	/* make sure IB test finished before entering exclusive mode
 	 * to avoid preemption on IB test
 	 * */
-	if (amdgpu_sriov_vf(adev)) {
-		amdgpu_virt_request_full_gpu(adev, false);
-		amdgpu_virt_fini_data_exchange(adev);
-	}
+	if (amdgpu_sriov_vf(adev))
+		skip_hw = amdgpu_virt_request_full_gpu(adev, false);
 
 	/* disable all interrupts */
-	amdgpu_irq_disable_all(adev);
+	if (!skip_hw)
+		amdgpu_irq_disable_all(adev);
 	if (adev->mode_info.mode_config_initialized){
 		if (!amdgpu_device_has_dc_support(adev))
-			drm_helper_force_disable_all(adev_to_drm(adev));
+			drm_helper_force_disable_all(adev->ddev);
+#ifdef HAVE_DRM_ATOMIC_HELPER_SHUTDOWN
 		else
-			drm_atomic_helper_shutdown(adev_to_drm(adev));
+			drm_atomic_helper_shutdown(adev->ddev);
+#endif
 	}
-	amdgpu_fence_driver_hw_fini(adev);
-
+	amdgpu_fence_driver_fini(adev, skip_hw);
+	amdgpu_pm_uuid_sysfs_fini(adev);
 	if (adev->pm_sysfs_en)
 		amdgpu_pm_sysfs_fini(adev);
-	if (adev->ucode_sysfs_en)
-		amdgpu_ucode_sysfs_fini(adev);
-	sysfs_remove_files(&adev->dev->kobj, amdgpu_dev_attributes);
-
+	amdgpu_version_sysfs_fini(adev);
 	amdgpu_fbdev_fini(adev);
-
-	amdgpu_irq_fini_hw(adev);
-
-	amdgpu_device_ip_fini_early(adev);
-
-	amdgpu_gart_dummy_page_fini(adev);
-
-	amdgpu_device_unmap_mmio(adev);
-}
-
-void amdgpu_device_fini_sw(struct amdgpu_device *adev)
-{
-	amdgpu_device_ip_fini(adev);
-	amdgpu_fence_driver_sw_fini(adev);
-	release_firmware(adev->firmware.gpu_info_fw);
-	adev->firmware.gpu_info_fw = NULL;
+	r = amdgpu_device_ip_fini(adev, skip_hw);
+	if (adev->firmware.gpu_info_fw) {
+		release_firmware(adev->firmware.gpu_info_fw);
+		adev->firmware.gpu_info_fw = NULL;
+	}
 	adev->accel_working = false;
-
-	amdgpu_reset_fini(adev);
-
 	/* free i2c buses */
 	if (!amdgpu_device_has_dc_support(adev))
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +20 -8
 		amdgpu_i2c_fini(adev);
@@ -3882,20 +3496,31 @@ void amdgpu_device_fini_sw(struct
 amdgpu_device *adev)
 
 	kfree(adev->bios);
 	adev->bios = NULL;
-	if (amdgpu_device_supports_px(adev_to_drm(adev))) {
+	if (amdgpu_has_atpx() &&
+	    (amdgpu_is_atpx_hybrid() ||
+	     amdgpu_has_atpx_dgpu_power_cntl()) &&
+	    !pci_is_thunderbolt_attached(adev->pdev))
 		vga_switcheroo_unregister_client(adev->pdev);
+	if (amdgpu_device_supports_boco(adev->ddev))
 		vga_switcheroo_fini_domain_pm_ops(adev->dev);
-	}
-	if ((adev->pdev->class >> 8) == PCI_CLASS_DISPLAY_VGA)
-		vga_client_register(adev->pdev, NULL, NULL, NULL);
+	vga_client_register(adev->pdev, NULL, NULL, NULL);
+	if (adev->rio_mem)
+		pci_iounmap(adev->pdev, adev->rio_mem);
+	adev->rio_mem = NULL;
+	iounmap(adev->rmmio);
+	adev->rmmio = NULL;
+	amdgpu_device_doorbell_fini(adev);
 
+	device_remove_file(adev->dev, &dev_attr_pcie_replay_count);
+	if (adev->ucode_sysfs_en)
+		amdgpu_ucode_sysfs_fini(adev);
+	device_remove_file(adev->dev, &dev_attr_product_name);
+	device_remove_file(adev->dev, &dev_attr_product_number);
+	device_remove_file(adev->dev, &dev_attr_serial_number);
 	if (IS_ENABLED(CONFIG_PERF_EVENTS))
 		amdgpu_pmu_fini(adev);
-	if (adev->mman.discovery_bin)
+	if (amdgpu_discovery && adev->asic_type >= CHIP_NAVI10)
 		amdgpu_discovery_fini(adev);
-
-	kfree(adev->pci_state);
-
 }
 
@@ -3906,6 +3531,7 @@ void amdgpu_device_fini_sw(struct amdgpu_device
 *adev)
  * amdgpu_device_suspend - initiate device suspend
  *
  * @dev: drm dev pointer
+ * @suspend: suspend state
  * @fbcon : notify the fbdev of suspend
  *

* Puts the hw in the suspend state (all asics).

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +67 -12
@@ -3914,36 +3540,90 @@ void amdgpu_device_fini_sw(struct
 amdgpu_device *adev)
  */
 int amdgpu_device_suspend(struct drm_device *dev, bool fbcon)
 {
-	struct amdgpu_device *adev = drm_to_adev(dev);
+	struct amdgpu_device *adev;
+	struct drm_crtc *crtc;
+	struct drm_connector *connector;
+#ifdef HAVE_DRM_CONNECTOR_LIST_ITER_BEGIN
+	struct drm_connector_list_iter iter;
+#endif
+	int r;
+
+	if (dev == NULL || dev->dev_private == NULL) {
+		return -ENODEV;
+	}
+
+	adev = dev->dev_private;
 
 	if (dev->switch_power_state == DRM_SWITCH_POWER_OFF)
 		return 0;
 
 	adev->in_suspend = true;
-
-	if (amdgpu_acpi_smart_shift_update(dev, AMDGPU_SS_DEV_D3))
-		DRM_WARN("smart shift update failed\n");
-
 	drm_kms_helper_poll_disable(dev);
 
 	if (fbcon)
 		amdgpu_fbdev_set_suspend(adev, 1);
 
-	cancel_delayed_work_sync(&adev->delayed_init_work);
+	if (!amdgpu_sriov_vf(adev))
+		cancel_delayed_work_sync(&adev->delayed_init_work);
 
-	amdgpu_ras_suspend(adev);
+	if (!amdgpu_device_has_dc_support(adev)) {
+		/* turn off display hw */
+		drm_modeset_lock_all(dev);
+#ifdef HAVE_DRM_CONNECTOR_LIST_ITER_BEGIN
+		drm_connector_list_iter_begin(dev, &iter);
+		drm_for_each_connector_iter(connector, &iter)
+#else
+		drm_for_each_connector(connector, dev)
+#endif
+			drm_helper_connector_dpms(connector,
+						  DRM_MODE_DPMS_OFF);
+#ifdef HAVE_DRM_CONNECTOR_LIST_ITER_BEGIN
+		drm_connector_list_iter_end(&iter);
+#endif
+		drm_modeset_unlock_all(dev);
+			/* unpin the front buffers and cursors */
+		list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
+			struct amdgpu_crtc *amdgpu_crtc =
 to_amdgpu_crtc(crtc);
+			struct drm_framebuffer *fb = crtc->primary->fb;
+			struct amdgpu_bo *robj;
+
+			if (amdgpu_crtc->cursor_bo && !adev-
 >enable_virtual_display) {
+				struct amdgpu_bo *aobj =
 gem_to_amdgpu_bo(amdgpu_crtc->cursor_bo);
+				r = amdgpu_bo_reserve(aobj, true);
+				if (r == 0) {
+					amdgpu_bo_unpin(aobj);
+					amdgpu_bo_unreserve(aobj);
+				}
+			}
+
+			if (fb == NULL || kcl_drm_fb_get_gem_obj(fb, 0) ==
 NULL) {
+				continue;
+			}
+			robj =
 gem_to_amdgpu_bo(kcl_drm_fb_get_gem_obj(fb, 0));
+			/* don't unpin kernel fb objects */
+			if (!amdgpu_fbdev_robj_is_fb(adev, robj)) {
+				r = amdgpu_bo_reserve(robj, true);
+				if (r == 0) {
+					amdgpu_bo_unpin(robj);
+					amdgpu_bo_unreserve(robj);
+				}
+			}
+		}
+	}
+
+	amdgpu_amdkfd_suspend(adev, !fbcon);
 
-	amdgpu_device_ip_suspend_phase1(adev);
+	amdgpu_ras_suspend(adev);
 
-	if (!adev->in_s0ix)
-		amdgpu_amdkfd_suspend(adev, adev->in_runpm);
+	r = amdgpu_device_ip_suspend_phase1(adev);
 
 	/* evict vram memory */
 	amdgpu_bo_evict_vram(adev);
 
-	amdgpu_fence_driver_hw_fini(adev);
+	amdgpu_fence_driver_suspend(adev);
+
+	r = amdgpu_device_ip_suspend_phase2(adev);
 
-	amdgpu_device_ip_suspend_phase2(adev);
 	/* evict remaining vram memory
 	 * This second call to evict vram is to evict the gart page table
 	 * using the CPU.
@@ -3957,6 +3637,7 @@ int amdgpu_device_suspend(struct drm_device *dev,
 bool fbcon)
  * amdgpu_device_resume - initiate device resume
  *
  * @dev: drm dev pointer
+ * @resume: resume state
  * @fbcon : notify the fbdev of resume
  *

* Bring the hw back to operating state (all asics).

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +59 -15
@@ -3965,47 +3646,98 @@ int amdgpu_device_suspend(struct drm_device
 *dev, bool fbcon)
  */
 int amdgpu_device_resume(struct drm_device *dev, bool fbcon)
 {
-	struct amdgpu_device *adev = drm_to_adev(dev);
+	struct drm_connector *connector;
+#ifdef HAVE_DRM_CONNECTOR_LIST_ITER_BEGIN
+	struct drm_connector_list_iter iter;
+#endif
+	struct amdgpu_device *adev = dev->dev_private;
+	struct drm_crtc *crtc;
 	int r = 0;
 
 	if (dev->switch_power_state == DRM_SWITCH_POWER_OFF)
 		return 0;
 
-	if (adev->in_s0ix)
-		amdgpu_gfx_state_change_set(adev,
 sGpuChangeState_D0Entry);
-
 	/* post card */
 	if (amdgpu_device_need_post(adev)) {
-		r = amdgpu_device_asic_init(adev);
+		r = amdgpu_atom_asic_init(adev->mode_info.atom_context);
 		if (r)
-			dev_err(adev->dev, "amdgpu asic init failed\n");
+			DRM_ERROR("amdgpu asic init failed\n");
 	}
 
 	r = amdgpu_device_ip_resume(adev);
 	if (r) {
-		dev_err(adev->dev, "amdgpu_device_ip_resume failed
 (%d).\n", r);
+		DRM_ERROR("amdgpu_device_ip_resume failed (%d).\n", r);
 		return r;
 	}
-	amdgpu_fence_driver_hw_init(adev);
+	amdgpu_fence_driver_resume(adev);
+
 
 	r = amdgpu_device_ip_late_init(adev);
 	if (r)
 		return r;
 
-	queue_delayed_work(system_wq, &adev->delayed_init_work,
+	if (amdgpu_sriov_vf(adev)) {
+		r = amdgpu_ib_ring_tests(adev);
+		if (r) {
+			DRM_ERROR("ib ring test failed (%d).\n", r);
+			return r;
+		}
+	} else {
+		queue_delayed_work(system_wq, &adev->delayed_init_work,
 			   msecs_to_jiffies(AMDGPU_RESUME_MS));
+	}
 
-	if (!adev->in_s0ix) {
-		r = amdgpu_amdkfd_resume(adev, adev->in_runpm);
-		if (r)
-			return r;
+	if (!amdgpu_device_has_dc_support(adev)) {
+		/* pin cursors */
+		list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
+			struct amdgpu_crtc *amdgpu_crtc =
 to_amdgpu_crtc(crtc);
+
+			if (amdgpu_crtc->cursor_bo && !adev-
 >enable_virtual_display) {
+				struct amdgpu_bo *aobj =
 gem_to_amdgpu_bo(amdgpu_crtc->cursor_bo);
+				r = amdgpu_bo_reserve(aobj, true);
+				if (r == 0) {
+					r = amdgpu_bo_pin(aobj,
 AMDGPU_GEM_DOMAIN_VRAM);
+					if (r != 0)
+						DRM_ERROR("Failed to pin
 cursor BO (%d)\n", r);
+					amdgpu_crtc->cursor_addr =
 amdgpu_bo_gpu_offset(aobj);
+					amdgpu_bo_unreserve(aobj);
+				}
+			}
+		}
 	}
+	r = amdgpu_amdkfd_resume(adev, !fbcon);
+	if (r)
+		return r;
 
 	/* Make sure IB tests flushed */
-	flush_delayed_work(&adev->delayed_init_work);
+	if (!amdgpu_sriov_vf(adev))
+		flush_delayed_work(&adev->delayed_init_work);
 
-	if (fbcon)
+	/* blat the mode back in */
+	if (fbcon) {
+		if (!amdgpu_device_has_dc_support(adev)) {
+			/* pre DCE11 */
+			drm_helper_resume_force_mode(dev);
+
+			/* turn on display hw */
+			drm_modeset_lock_all(dev);
+
+#ifdef HAVE_DRM_CONNECTOR_LIST_ITER_BEGIN
+			drm_connector_list_iter_begin(dev, &iter);
+			drm_for_each_connector_iter(connector, &iter)
+#else
+			drm_for_each_connector(connector, dev)
+#endif
+				drm_helper_connector_dpms(connector,
+

DRM_MODE_DPMS_ON);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +8 -4
+#ifdef HAVE_DRM_CONNECTOR_LIST_ITER_BEGIN
+			drm_connector_list_iter_end(&iter);
+#endif
+
+			drm_modeset_unlock_all(dev);
+		}
 		amdgpu_fbdev_set_suspend(adev, 0);
+	}
 
 	drm_kms_helper_poll_enable(dev);
@@ -4032,9 +3764,6 @@ int amdgpu_device_resume(struct drm_device *dev,
 bool fbcon)
 #endif
 	adev->in_suspend = false;
 
-	if (amdgpu_acpi_smart_shift_update(dev, AMDGPU_SS_DEV_D0))
-		DRM_WARN("smart shift update failed\n");
-
 	return 0;
 }
@@ -4066,7 +3795,7 @@ static bool
 amdgpu_device_ip_check_soft_reset(struct amdgpu_device *adev)
 			adev->ip_blocks[i].status.hang =
 				adev->ip_blocks[i].version->funcs-
 >check_soft_reset(adev);
 		if (adev->ip_blocks[i].status.hang) {
-			dev_info(adev->dev, "IP block:%s is hung!\n", adev-
 >ip_blocks[i].version->funcs->name);
+			DRM_INFO("IP block:%s is hung!\n", adev-
Quoted 1 line

ip_blocks[i].version->funcs->name);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -0
 			asic_hang = true;
 		}
 	}
@@ -4127,7 +3856,7 @@ static bool
 amdgpu_device_ip_need_full_reset(struct amdgpu_device *adev)
 		    (adev->ip_blocks[i].version->type ==

AMD_IP_BLOCK_TYPE_DCE) ||
adev->ip_blocks[i].version->type ==
AMD_IP_BLOCK_TYPE_PSP) {

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -1
 			if (adev->ip_blocks[i].status.hang) {
-				dev_info(adev->dev, "Some block need full

reset!\n");

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -1
+				DRM_INFO("Some block need full reset!\n");
 				return true;
 			}
 		}
@@ -4208,7 +3937,6 @@ static int amdgpu_device_recover_vram(struct
 amdgpu_device *adev)
 {
 	struct dma_fence *fence = NULL, *next = NULL;
 	struct amdgpu_bo *shadow;
-	struct amdgpu_bo_vm *vmbo;
 	long r = 1, tmo;
 
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +3 -5
 	if (amdgpu_sriov_runtime(adev))
@@ -4216,14 +3944,14 @@ static int amdgpu_device_recover_vram(struct
 amdgpu_device *adev)
 	else
 		tmo = msecs_to_jiffies(100);
 
-	dev_info(adev->dev, "recover vram bo from shadow start\n");
+	DRM_INFO("recover vram bo from shadow start\n");
 	mutex_lock(&adev->shadow_list_lock);
-	list_for_each_entry(vmbo, &adev->shadow_list, shadow_list) {
-		shadow = &vmbo->bo;
+	list_for_each_entry(shadow, &adev->shadow_list, shadow_list) {
+
 		/* No need to recover an evicted BO */
-		if (shadow->tbo.resource->mem_type != TTM_PL_TT ||
-		    shadow->tbo.resource->start ==

AMDGPU_BO_INVALID_OFFSET ||

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -1
-		    shadow->parent->tbo.resource->mem_type !=

TTM_PL_VRAM)

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -0
+		if (shadow->tbo.mem.mem_type != TTM_PL_TT ||
+		    shadow->tbo.mem.start == AMDGPU_BO_INVALID_OFFSET

||

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +3 -2
+		    shadow->parent->tbo.mem.mem_type != TTM_PL_VRAM)
 			continue;
 
 		r = amdgpu_bo_restore_shadow(shadow, &next);
@@ -4252,11 +3980,11 @@ static int amdgpu_device_recover_vram(struct
 amdgpu_device *adev)
 	dma_fence_put(fence);
 
 	if (r < 0 || tmo <= 0) {
-		dev_err(adev->dev, "recover vram bo from shadow failed, r
 is %ld, tmo is %ld\n", r, tmo);
+		DRM_ERROR("recover vram bo from shadow failed, r is %ld,
 tmo is %ld\n", r, tmo);
 		return -EIO;
 	}
 
-	dev_info(adev->dev, "recover vram bo from shadow done\n");
+	DRM_INFO("recover vram bo from shadow done\n");
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -1
 	return 0;
 }
@@ -4264,7 +3992,7 @@ static int amdgpu_device_recover_vram(struct
 amdgpu_device *adev)
 /**
  * amdgpu_device_reset_sriov - reset ASIC for SR-IOV vf
  *
- * @adev: amdgpu_device pointer
+ * @adev: amdgpu device pointer
  * @from_hypervisor: request from hypervisor
  *

* do VF FLR and reinitialize Asic

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -1
@@ -4291,7 +4019,7 @@ static int amdgpu_device_reset_sriov(struct
 amdgpu_device *adev,
 
 	amdgpu_virt_init_data_exchange(adev);
 	/* we need recover gart prior to run SMC/CP/SDMA resume */
-	amdgpu_gtt_mgr_recover(ttm_manager_type(&adev->mman.bdev,
 TTM_PL_TT));
+	amdgpu_gtt_mgr_recover(&adev->mman.bdev.man[TTM_PL_TT]);
 
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -30
 	r = amdgpu_device_fw_loading(adev);
 	if (r)
@@ -4307,47 +4035,19 @@ static int amdgpu_device_reset_sriov(struct
 amdgpu_device *adev,
 	amdgpu_amdkfd_post_reset(adev);
 
 error:
+	amdgpu_virt_release_full_gpu(adev, true);
 	if (!r && adev->virt.gim_feature &
 AMDGIM_FEATURE_GIM_FLR_VRAMLOST) {
 		amdgpu_inc_vram_lost(adev);
 		r = amdgpu_device_recover_vram(adev);
 	}
-	amdgpu_virt_release_full_gpu(adev, true);
 
 	return r;
 }
 
-/**
- * amdgpu_device_has_job_running - check if there is any job in mirror list
- *
- * @adev: amdgpu_device pointer
- *
- * check if there is any job in mirror list
- */
-bool amdgpu_device_has_job_running(struct amdgpu_device *adev)
-{
-	int i;
-	struct drm_sched_job *job;
-
-	for (i = 0; i < AMDGPU_MAX_RINGS; ++i) {
-		struct amdgpu_ring *ring = adev->rings[i];
-
-		if (!ring || !ring->sched.thread)
-			continue;
-
-		spin_lock(&ring->sched.job_list_lock);
-		job = list_first_entry_or_null(&ring->sched.pending_list,
-					       struct drm_sched_job, list);
-		spin_unlock(&ring->sched.job_list_lock);
-		if (job)
-			return true;
-	}
-	return false;
-}
-
 /**
  * amdgpu_device_should_recover_gpu - check if we should try GPU recovery
  *
- * @adev: amdgpu_device pointer
+ * @adev: amdgpu device pointer
  *

* Check amdgpu_gpu_recovery and SRIOV status to see if we should try to
recover
* a hung GPU.

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -1
@@ -4355,7 +4055,7 @@ bool amdgpu_device_has_job_running(struct
 amdgpu_device *adev)
 bool amdgpu_device_should_recover_gpu(struct amdgpu_device *adev)
 {
 	if (!amdgpu_device_ip_check_soft_reset(adev)) {
-		dev_info(adev->dev, "Timeout, but no hardware hang
 detected.\n");
+		DRM_INFO("Timeout, but no hardware hang detected.\n");
 		return false;
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -6
 	}
@@ -4385,12 +4085,6 @@ bool amdgpu_device_should_recover_gpu(struct
 amdgpu_device *adev)
 		case CHIP_NAVI10:
 		case CHIP_NAVI14:
 		case CHIP_NAVI12:
-		case CHIP_SIENNA_CICHLID:
-		case CHIP_NAVY_FLOUNDER:
-		case CHIP_DIMGREY_CAVEFISH:
-		case CHIP_BEIGE_GOBY:
-		case CHIP_VANGOGH:
-		case CHIP_ALDEBARAN:
 			break;
 		default:
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +8 -56
 			goto disabled;
@@ -4400,69 +4094,21 @@ bool amdgpu_device_should_recover_gpu(struct
 amdgpu_device *adev)
 	return true;
 
 disabled:
-		dev_info(adev->dev, "GPU recovery disabled.\n");
+		DRM_INFO("GPU recovery disabled.\n");
 		return false;
 }
 
-int amdgpu_device_mode1_reset(struct amdgpu_device *adev)
-{
-        u32 i;
-        int ret = 0;
-
-        amdgpu_atombios_scratch_regs_engine_hung(adev, true);
-
-        dev_info(adev->dev, "GPU mode1 reset\n");
-
-        /* disable BM */
-        pci_clear_master(adev->pdev);
-
-        amdgpu_device_cache_pci_state(adev->pdev);
-
-        if (amdgpu_dpm_is_mode1_reset_supported(adev)) {
-                dev_info(adev->dev, "GPU smu mode1 reset\n");
-                ret = amdgpu_dpm_mode1_reset(adev);
-        } else {
-                dev_info(adev->dev, "GPU psp mode1 reset\n");
-                ret = psp_gpu_reset(adev);
-        }
-
-        if (ret)
-                dev_err(adev->dev, "GPU mode1 reset failed\n");
-
-        amdgpu_device_load_pci_state(adev->pdev);
-
-        /* wait for asic to come out of reset */
-        for (i = 0; i < adev->usec_timeout; i++) {
-                u32 memsize = adev->nbio.funcs->get_memsize(adev);
-
-                if (memsize != 0xffffffff)
-                        break;
-                udelay(1);
-        }
-
-        amdgpu_atombios_scratch_regs_engine_hung(adev, false);
-        return ret;
-}
 
-int amdgpu_device_pre_asic_reset(struct amdgpu_device *adev,
-				 struct amdgpu_reset_context *reset_context)
+static int amdgpu_device_pre_asic_reset(struct amdgpu_device *adev,
+					struct amdgpu_job *job,
+					bool *need_full_reset_arg)
 {
 	int i, r = 0;
-	struct amdgpu_job *job = NULL;
-	bool need_full_reset =
-		test_bit(AMDGPU_NEED_FULL_RESET, &reset_context->flags);
-
-	if (reset_context->reset_req_dev == adev)
-		job = reset_context->job;
+	bool need_full_reset  = *need_full_reset_arg;
 
-	/* no need to dump if device is not in good state during probe period
 */
-	if (!adev->gmc.xgmi.pending_reset)
-		amdgpu_debugfs_wait_dump(adev);
-
-	if (amdgpu_sriov_vf(adev)) {
-		/* stop the data exchange thread */
-		amdgpu_virt_fini_data_exchange(adev);
-	}
+	if (amdgpu_sriov_vf(adev))
+		if (!amdgpu_virt_notify_booked(adev, job))
+			amdgpu_virt_wait_dump(adev,
 MAX_SCHEDULE_TIMEOUT);
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -8
 	/* block all schedulers and reset given job's ring */
 	for (i = 0; i < AMDGPU_MAX_RINGS; ++i) {
@@ -4475,16 +4121,9 @@ int amdgpu_device_pre_asic_reset(struct
 amdgpu_device *adev,
 		amdgpu_fence_driver_force_completion(ring);
 	}
 
-	if (job && job->vm)
+	if (job)
 		drm_sched_increase_karma(&job->base);
 
-	r = amdgpu_reset_prepare_hwcontext(adev, reset_context);
-	/* If reset handler not implemented, continue; otherwise return */
-	if (r == -ENOSYS)
-		r = 0;
-	else
-		return r;
-
 	/* Don't suspend on bare metal if we are not going to HW reset the

ASIC */

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +10 -27
 	if (!amdgpu_sriov_vf(adev)) {
@@ -4496,69 +4135,52 @@ int amdgpu_device_pre_asic_reset(struct
 amdgpu_device *adev,
 			r = amdgpu_device_ip_soft_reset(adev);
 			amdgpu_device_ip_post_soft_reset(adev);
 			if (r || amdgpu_device_ip_check_soft_reset(adev)) {
-				dev_info(adev->dev, "soft reset failed, will
 fallback to full reset!\n");
+				DRM_INFO("soft reset failed, will fallback to
 full reset!\n");
 				need_full_reset = true;
 			}
 		}
 
 		if (need_full_reset)
 			r = amdgpu_device_ip_suspend(adev);
-		if (need_full_reset)
-			set_bit(AMDGPU_NEED_FULL_RESET, &reset_context-
 >flags);
-		else
-			clear_bit(AMDGPU_NEED_FULL_RESET,
-				  &reset_context->flags);
+
+		*need_full_reset_arg = need_full_reset;
 	}
 
 	return r;
 }
 
-int amdgpu_do_asic_reset(struct list_head *device_list_handle,
-			 struct amdgpu_reset_context *reset_context)
+static int amdgpu_do_asic_reset(struct amdgpu_hive_info *hive,
+			       struct list_head *device_list_handle,
+			       bool *need_full_reset_arg)
 {
 	struct amdgpu_device *tmp_adev = NULL;
-	bool need_full_reset, skip_hw_reset, vram_lost = false;
[… more lines in the raw message]

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

process */

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -1

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

&tmp_adev->xgmi_reset_work))

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -1

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

with error, %d for drm dev, %s",

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -1

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

for drm dev, %s",

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -1

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

reset_list) {

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -0

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

1) {
flush_work(&tmp_adev-

Quoted 1 line

xgmi_reset_work);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +5 -8

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

failed!");

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -1

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

Quoted 1 line

mode_info.atom_context))

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +3 -0

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

succeeded, trying to resume\n");
r =
amdgpu_device_ip_resume_phase1(tmp_adev);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -1

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

Quoted 1 line

mman.bdev.man[TTM_PL_TT]);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -8

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

check

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -7

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

(!amdgpu_ras_eeprom_check_err_threshold(tmp_adev)) {

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -8

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

1)

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -2

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

tmp_adev);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -0

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

Quoted 1 line

gmc.xgmi.num_physical_nodes > 1)

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -0

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

amdgpu_xgmi_update_topology(hive, tmp_adev);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -0

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

(%d).\n", r);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +9 -14

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +12 -109

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

the real one */

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -1

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

Quoted 1 line

sched.hw_submission_limit;

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +3 -0

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

ring->sched.timeout);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -1

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

job_id:%llx\n",

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +4 -3

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

emitted seq=%u\n",

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -0

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

Quoted 1 line

fence_drv.last_seq),

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -0

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

thread %s pid %d\n",

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -7

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

device_list_handle, need_full_reset);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +3 -5

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

job could flush vmid */

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -13

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

original_hw_submission_limit;

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +6 -4

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

AMD_RESET_METHOD_BACO) ?

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -8

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

amdgpu_ras_need_emergency_restart(adev);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -1

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

Quoted 1 line

reboot) {

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -0

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

Quoted 1 line

reboot) {

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +54 -42

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

the

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -0

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

reset

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +16 -25

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +24 -7

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -4

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

as gfx

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -1

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

an additional

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -1

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

synchronously

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -1

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

timeout,

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -4

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

Quoted 1 line

vram_lost_counter)))

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -2

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

&reset_context);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -0

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

Quoted 1 line

vram_lost_counter)) &&

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -0

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

device_list_handle, &need_full_reset);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -1

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

	drm_helper_resume_force_mode(adev_to_drm(tmp_adev));
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +7 -21

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

CAIL_ASIC_PCIE_LINK_SPEED_SUPPORT_GEN2 |

CAIL_ASIC_PCIE_LINK_SPEED_SUPPORT_GEN3);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -2

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

(CAIL_ASIC_PCIE_LINK_SPEED_SUPPORT_GEN1 | -
CAIL_ASIC_PCIE_LINK_SPEED_SUPPORT_GEN2 |
-
CAIL_ASIC_PCIE_LINK_SPEED_SUPPORT_GEN3 |
-
CAIL_ASIC_PCIE_LINK_SPEED_SUPPORT_GEN4 |
-
CAIL_ASIC_PCIE_LINK_SPEED_SUPPORT_GEN5);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -1

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

(CAIL_ASIC_PCIE_LINK_SPEED_SUPPORT_GEN1 |

CAIL_ASIC_PCIE_LINK_SPEED_SUPPORT_GEN2 |

CAIL_ASIC_PCIE_LINK_SPEED_SUPPORT_GEN3 |

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -0

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

(CAIL_PCIE_LINK_SPEED_SUPPORT_GEN1 |

CAIL_PCIE_LINK_SPEED_SUPPORT_GEN2);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -2

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

(CAIL_PCIE_LINK_SPEED_SUPPORT_GEN1 |
-
CAIL_PCIE_LINK_SPEED_SUPPORT_GEN2 |
-
CAIL_PCIE_LINK_SPEED_SUPPORT_GEN3 |
-
CAIL_PCIE_LINK_SPEED_SUPPORT_GEN4 |
-
CAIL_PCIE_LINK_SPEED_SUPPORT_GEN5);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -1

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

(CAIL_PCIE_LINK_SPEED_SUPPORT_GEN1 |

CAIL_PCIE_LINK_SPEED_SUPPORT_GEN2 |

CAIL_PCIE_LINK_SPEED_SUPPORT_GEN3 |

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +5 -0

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

@adev
+ *
+ * Return true if @peer_adev can access (DMA) @adev through the PCIe
+ * BAR, i.e. @adev is "large BAR" and the BAR matches the DMA mask of
+ * @peer_adev.
+ */

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +20 -37

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

pci_channel_state_t state)

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -136

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

PCI_ERS_RESULT_RECOVERED;

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -106

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

2.17.1

Part of the diff is not shown here. View the raw message.

#3 lore raw

Re: [PATCH] drm/amdgpu: Add driver version

Why did you then send it out?

Thanks,
Christian.

Am 04.08.21 um 09:05 schrieb Zhou, Peng Ju:

Quoted 4,580 lines

[AMD Official Use Only]

Merge error, Too big to drop

Quoted 4,576 lines

-----Original Message-----
From: Peng Ju Zhou <[email protected]>
Sent: Wednesday, August 4, 2021 10:15 AM
To: [email protected]
Cc: Nieto, David M <[email protected]>; Zhou, Peng Ju <[email protected]>
Subject: [PATCH] drm/amdgpu: Add driver version

From: David M Nieto <[email protected]>

This sysfs is only defined in DKMS drivers it exposes the internal AMDGPU version

---
  drivers/gpu/drm/amd/amdgpu/amdgpu_device.c | 2659 +++++++-------------
  1 file changed, 941 insertions(+), 1718 deletions(-)
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +3 -16
index 9e53ff851496..d93d1c966bad 100644
@@ -29,6 +29,7 @@
  #include <linux/kthread.h>
  #include <linux/module.h>
  #include <linux/console.h>
+#include <linux/reboot.h>
  #include <linux/slab.h>
 
  #include <drm/drm_atomic_helper.h>
@@ -65,13 +66,9 @@
  #include "amdgpu_ras.h"
  #include "amdgpu_pmu.h"
  #include "amdgpu_fru_eeprom.h"
-#include "amdgpu_reset.h"
 
  #include <linux/suspend.h>
  #include <drm/task_barrier.h>
-#include <linux/pm_runtime.h>
-
-#include <drm/drm_drv.h>
 
  MODULE_FIRMWARE("amdgpu/vega10_gpu_info.bin");
  MODULE_FIRMWARE("amdgpu/vega12_gpu_info.bin");
@@ -83,8 +80,6 @@ MODULE_FIRMWARE("amdgpu/renoir_gpu_info.bin");
  MODULE_FIRMWARE("amdgpu/navi10_gpu_info.bin");
  MODULE_FIRMWARE("amdgpu/navi14_gpu_info.bin");
  MODULE_FIRMWARE("amdgpu/navi12_gpu_info.bin");
-MODULE_FIRMWARE("amdgpu/vangogh_gpu_info.bin");
-MODULE_FIRMWARE("amdgpu/yellow_carp_gpu_info.bin");
 
  #define AMDGPU_RESUME_MS		2000
 
@@ -114,17 +109,9 @@ const char *amdgpu_asic_name[] = {
  	"RAVEN",
  	"ARCTURUS",
  	"RENOIR",
-	"ALDEBARAN",
  	"NAVI10",
-	"CYAN_SKILLFISH",
  	"NAVI14",
  	"NAVI12",
-	"SIENNA_CICHLID",
-	"NAVY_FLOUNDER",
-	"VANGOGH",
-	"DIMGREY_CAVEFISH",
-	"BEIGE_GOBY",
-	"YELLOW_CARP",
  	"LAST",
  };
 
@@ -141,10 +128,10 @@ static ssize_t
 amdgpu_device_get_pcie_replay_count(struct device *dev,
  		struct device_attribute *attr, char *buf)
  {
  	struct drm_device *ddev = dev_get_drvdata(dev);
-	struct amdgpu_device *adev = drm_to_adev(ddev);
+	struct amdgpu_device *adev = ddev->dev_private;
  	uint64_t cnt = amdgpu_asic_get_pcie_replay_count(adev);
 
-	return sysfs_emit(buf, "%llu\n", cnt);
+	return snprintf(buf, PAGE_SIZE, "%llu\n", cnt);
  }
 

static DEVICE_ATTR(pcie_replay_count, S_IRUGO,

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -2
@@ -166,9 +153,9 @@ static ssize_t
 amdgpu_device_get_product_name(struct device *dev,
  		struct device_attribute *attr, char *buf)
  {
  	struct drm_device *ddev = dev_get_drvdata(dev);
-	struct amdgpu_device *adev = drm_to_adev(ddev);
+	struct amdgpu_device *adev = ddev->dev_private;
 
-	return sysfs_emit(buf, "%s\n", adev->product_name);
+	return snprintf(buf, PAGE_SIZE, "%s\n", adev->product_name);
  }
 

static DEVICE_ATTR(product_name, S_IRUGO,

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -2
@@ -188,9 +175,9 @@ static ssize_t
 amdgpu_device_get_product_number(struct device *dev,
  		struct device_attribute *attr, char *buf)
  {
  	struct drm_device *ddev = dev_get_drvdata(dev);
-	struct amdgpu_device *adev = drm_to_adev(ddev);
+	struct amdgpu_device *adev = ddev->dev_private;
 
-	return sysfs_emit(buf, "%s\n", adev->product_number);
+	return snprintf(buf, PAGE_SIZE, "%s\n", adev->product_number);
  }
 

static DEVICE_ATTR(product_number, S_IRUGO,

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -3
@@ -210,45 +197,27 @@ static ssize_t
 amdgpu_device_get_serial_number(struct device *dev,
  		struct device_attribute *attr, char *buf)
  {
  	struct drm_device *ddev = dev_get_drvdata(dev);
-	struct amdgpu_device *adev = drm_to_adev(ddev);
+	struct amdgpu_device *adev = ddev->dev_private;
 
-	return sysfs_emit(buf, "%s\n", adev->serial);
+	return snprintf(buf, PAGE_SIZE, "%s\n", adev->serial);
  }
 
  static DEVICE_ATTR(serial_number, S_IRUGO,
  		amdgpu_device_get_serial_number, NULL);
 
  /**
- * amdgpu_device_supports_px - Is the device a dGPU with ATPX power

control
- *
- * @dev: drm_device pointer
- *
- * Returns true if the device is a dGPU with ATPX power control,
- * otherwise return false.
- */

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -11
-bool amdgpu_device_supports_px(struct drm_device *dev)
-{
-	struct amdgpu_device *adev = drm_to_adev(dev);
-
-	if ((adev->flags & AMD_IS_PX) && !amdgpu_is_atpx_hybrid())
-		return true;
-	return false;
-}
-
-/**
- * amdgpu_device_supports_boco - Is the device a dGPU with ACPI power

resources
+ * amdgpu_device_supports_boco - Is the device a dGPU with HG/PX power control
*
* @dev: drm_device pointer
*
- * Returns true if the device is a dGPU with ACPI power control,
+ * Returns true if the device is a dGPU with HG/PX power control,
* otherwise return false.
*/
bool amdgpu_device_supports_boco(struct drm_device *dev)
{

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +5 -23
-	struct amdgpu_device *adev = drm_to_adev(dev);
+	struct amdgpu_device *adev = dev->dev_private;
 
-	if (adev->has_pr3 ||
-	    ((adev->flags & AMD_IS_PX) && amdgpu_is_atpx_hybrid()))
+	if (adev->flags & AMD_IS_PX)
  		return true;
  	return false;
  }
@@ -263,32 +232,15 @@ bool amdgpu_device_supports_boco(struct
 drm_device *dev)
   */
  bool amdgpu_device_supports_baco(struct drm_device *dev)
  {
-	struct amdgpu_device *adev = drm_to_adev(dev);
+	struct amdgpu_device *adev = dev->dev_private;
 
  	return amdgpu_asic_supports_baco(adev);
  }
 
  /**
- * amdgpu_device_supports_smart_shift - Is the device dGPU with
- * smart shift support
- *
- * @dev: drm_device pointer
+ * VRAM access helper functions.
   *
- * Returns true if the device is a dGPU with Smart Shift support,
- * otherwise returns false.
- */
-bool amdgpu_device_supports_smart_shift(struct drm_device *dev)
-{
-	return (amdgpu_device_supports_boco(dev) &&
-		amdgpu_acpi_is_power_shift_control_supported());
-}
-
-/*
- * VRAM access helper functions
- */
-
-/**
- * amdgpu_device_mm_access - access vram by MM_INDEX/MM_DATA
+ * amdgpu_device_vram_access - read/write a buffer in vram
   *
   * @adev: amdgpu_device pointer

* @pos: offset of the buffer in vram

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +15 -94
@@ -296,143 +248,61 @@ bool amdgpu_device_supports_smart_shift(struct
 drm_device *dev)
   * @size: read/write size, sizeof(@buf) must > @size
   * @write: true - write to vram, otherwise - read from vram
   */
-void amdgpu_device_mm_access(struct amdgpu_device *adev, loff_t pos,
-			     void *buf, size_t size, bool write)
+void amdgpu_device_vram_access(struct amdgpu_device *adev, loff_t pos,
+			       uint32_t *buf, size_t size, bool write)
  {
  	unsigned long flags;
-	uint32_t hi = ~0, tmp = 0;
-	uint32_t *data = buf;
+	uint32_t hi = ~0;
  	uint64_t last;
-	int idx;
-
-	if (!drm_dev_enter(&adev->ddev, &idx))
-		return;
-
-	BUG_ON(!IS_ALIGNED(pos, 4) || !IS_ALIGNED(size, 4));
-
-	spin_lock_irqsave(&adev->mmio_idx_lock, flags);
-	for (last = pos + size; pos < last; pos += 4) {
-		tmp = pos >> 31;
-
-		WREG32_NO_KIQ(mmMM_INDEX, ((uint32_t)pos) |
 0x80000000);
-		if (tmp != hi) {
-			WREG32_NO_KIQ(mmMM_INDEX_HI, tmp);
-			hi = tmp;
-		}
-		if (write)
-			WREG32_NO_KIQ(mmMM_DATA, *data++);
-		else
-			*data++ = RREG32_NO_KIQ(mmMM_DATA);
-	}
 
-	spin_unlock_irqrestore(&adev->mmio_idx_lock, flags);
-	drm_dev_exit(idx);
-}
 
-/**
- * amdgpu_device_vram_access - access vram by vram aperature
- *
- * @adev: amdgpu_device pointer
- * @pos: offset of the buffer in vram
- * @buf: virtual address of the buffer in system memory
- * @size: read/write size, sizeof(@buf) must > @size
- * @write: true - write to vram, otherwise - read from vram
- *
- * The return value means how many bytes have been transferred.
- */
-size_t amdgpu_device_aper_access(struct amdgpu_device *adev, loff_t pos,
-				 void *buf, size_t size, bool write)
-{
  #ifdef CONFIG_64BIT
-	void __iomem *addr;
-	size_t count = 0;
-	uint64_t last;
-
-	if (!adev->mman.aper_base_kaddr)
-		return 0;
-
  	last = min(pos + size, adev->gmc.visible_vram_size);
  	if (last > pos) {
-		addr = adev->mman.aper_base_kaddr + pos;
-		count = last - pos;
+		void __iomem *addr = adev->mman.aper_base_kaddr + pos;
+		size_t count = last - pos;
 
  		if (write) {
  			memcpy_toio(addr, buf, count);
  			mb();
-			amdgpu_device_flush_hdp(adev, NULL);
+			amdgpu_asic_flush_hdp(adev, NULL);
  		} else {
-			amdgpu_device_invalidate_hdp(adev, NULL);
+			amdgpu_asic_invalidate_hdp(adev, NULL);
  			mb();
  			memcpy_fromio(buf, addr, count);
  		}
 
-	}
-
-	return count;
-#else
-	return 0;
-#endif
-}
-
-/**
- * amdgpu_device_vram_access - read/write a buffer in vram
- *
- * @adev: amdgpu_device pointer
- * @pos: offset of the buffer in vram
- * @buf: virtual address of the buffer in system memory
- * @size: read/write size, sizeof(@buf) must > @size
- * @write: true - write to vram, otherwise - read from vram
- */
-void amdgpu_device_vram_access(struct amdgpu_device *adev, loff_t pos,
-			       void *buf, size_t size, bool write)
-{
-	size_t count;
+		if (count == size)
+			return;
 
-	/* try to using vram apreature to access vram first */
-	count = amdgpu_device_aper_access(adev, pos, buf, size, write);
-	size -= count;
-	if (size) {
-		/* using MM to access rest vram */
  		pos += count;
-		buf += count;
-		amdgpu_device_mm_access(adev, pos, buf, size, write);
+		buf += count / 4;
+		size -= count;
  	}
-}
-
-/*
- * register access helper functions.
- */
+#endif
 
-/* Check if hw access should be skipped because of hotplug or device error */
-bool amdgpu_device_skip_hw_access(struct amdgpu_device *adev)
-{
-	if (adev->no_hw_access)
-		return true;
+	spin_lock_irqsave(&adev->mmio_idx_lock, flags);
+	for (last = pos + size; pos < last; pos += 4) {
+		uint32_t tmp = pos >> 31;
 
-#ifdef CONFIG_LOCKDEP
-	/*
-	 * This is a bit complicated to understand, so worth a comment. What

we assert

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -1
-	 * here is that the GPU reset is not running on another thread in

parallel.

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -2
-	 *
-	 * For this we trylock the read side of the reset semaphore, if that

succeeds

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -3
-	 * we know that the reset is not running in paralell.
-	 *
-	 * If the trylock fails we assert that we are either already holding the

read

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -1
-	 * side of the lock or are the reset thread itself and hold the write side

of

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -5
-	 * the lock.
-	 */
-	if (in_task()) {
-		if (down_read_trylock(&adev->reset_sem))
-			up_read(&adev->reset_sem);
+		WREG32_NO_KIQ(mmMM_INDEX, ((uint32_t)pos) |

0x80000000);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +23 -22
+		if (tmp != hi) {
+			WREG32_NO_KIQ(mmMM_INDEX_HI, tmp);
+			hi = tmp;
+		}
+		if (write)
+			WREG32_NO_KIQ(mmMM_DATA, *buf++);
  		else
-			lockdep_assert_held(&adev->reset_sem);
+			*buf++ = RREG32_NO_KIQ(mmMM_DATA);
  	}
-#endif
-	return false;
+	spin_unlock_irqrestore(&adev->mmio_idx_lock, flags);
  }
 
+/*
+ * MMIO register access helper functions.
+ */
  /**
- * amdgpu_device_rreg - read a memory mapped IO or indirect register
+ * amdgpu_mm_rreg - read a memory mapped IO register
   *
   * @adev: amdgpu_device pointer
   * @reg: dword aligned register offset
@@ -440,29 +310,25 @@ bool amdgpu_device_skip_hw_access(struct
 amdgpu_device *adev)
   *
   * Returns the 32 bit value from the offset specified.
   */
-uint32_t amdgpu_device_rreg(struct amdgpu_device *adev,
-			    uint32_t reg, uint32_t acc_flags)
+uint32_t amdgpu_mm_rreg(struct amdgpu_device *adev, uint32_t reg,
+			uint32_t acc_flags)
  {
  	uint32_t ret;
 
-	if (amdgpu_device_skip_hw_access(adev))
-		return 0;
-
-	if ((reg * 4) < adev->rmmio_size) {
-		if (!(acc_flags & AMDGPU_REGS_NO_KIQ) &&
-		    amdgpu_sriov_runtime(adev) &&
-		    down_read_trylock(&adev->reset_sem)) {
-			ret = amdgpu_kiq_rreg(adev, reg);
-			up_read(&adev->reset_sem);
-		} else {
-			ret = readl(((void __iomem *)adev->rmmio) + (reg * 4));
-		}
-	} else {
-		ret = adev->pcie_rreg(adev, reg * 4);
-	}
+	if ((acc_flags & AMDGPU_REGS_KIQ) || (!(acc_flags &
 AMDGPU_REGS_NO_KIQ) && amdgpu_sriov_runtime(adev)))
+		return amdgpu_kiq_rreg(adev, reg);
 
-	trace_amdgpu_device_rreg(adev->pdev->device, reg, ret);
+	if ((reg * 4) < adev->rmmio_size && !(acc_flags & AMDGPU_REGS_IDX))
+		ret = readl(((void __iomem *)adev->rmmio) + (reg * 4));
+	else {
+		unsigned long flags;
 
+		spin_lock_irqsave(&adev->mmio_idx_lock, flags);
+		writel((reg * 4), ((void __iomem *)adev->rmmio) +
 (mmMM_INDEX * 4));
+		ret = readl(((void __iomem *)adev->rmmio) + (mmMM_DATA

* 4));

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +3 -3
+		spin_unlock_irqrestore(&adev->mmio_idx_lock, flags);
+	}
+	trace_amdgpu_mm_rreg(adev->pdev->device, reg, ret);
  	return ret;
  }
@@ -482,9 +348,6 @@ uint32_t amdgpu_device_rreg(struct amdgpu_device
 *adev,
   */
  uint8_t amdgpu_mm_rreg8(struct amdgpu_device *adev, uint32_t offset)
  {
-	if (amdgpu_device_skip_hw_access(adev))
-		return 0;
-
  	if (offset < adev->rmmio_size)
  		return (readb(adev->rmmio + offset));
  	BUG();
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +16 -3
@@ -507,17 +370,34 @@ uint8_t amdgpu_mm_rreg8(struct amdgpu_device
 *adev, uint32_t offset)
   */
  void amdgpu_mm_wreg8(struct amdgpu_device *adev, uint32_t offset,
 uint8_t value)
  {
-	if (amdgpu_device_skip_hw_access(adev))
-		return;
-
  	if (offset < adev->rmmio_size)
  		writeb(value, adev->rmmio + offset);
  	else
  		BUG();
  }
 
+void static inline amdgpu_mm_wreg_mmio(struct amdgpu_device *adev,
 uint32_t reg, uint32_t v, uint32_t acc_flags)
+{
+	trace_amdgpu_mm_wreg(adev->pdev->device, reg, v);
+
+	if ((reg * 4) < adev->rmmio_size && !(acc_flags & AMDGPU_REGS_IDX))
+		writel(v, ((void __iomem *)adev->rmmio) + (reg * 4));
+	else {
+		unsigned long flags;
+
+		spin_lock_irqsave(&adev->mmio_idx_lock, flags);
+		writel((reg * 4), ((void __iomem *)adev->rmmio) +
 (mmMM_INDEX * 4));
+		writel(v, ((void __iomem *)adev->rmmio) + (mmMM_DATA *
 4));
+		spin_unlock_irqrestore(&adev->mmio_idx_lock, flags);
+	}
+
+	if (adev->asic_type >= CHIP_VEGA10 && reg == 1 && adev-
Quoted 1 line

last_mm_index == 0x5702C) {

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +13 -19
+		udelay(500);
+	}
+}
+
  /**
- * amdgpu_device_wreg - write to a memory mapped IO or indirect register
+ * amdgpu_mm_wreg - write to a memory mapped IO register
   *
   * @adev: amdgpu_device pointer
   * @reg: dword aligned register offset
@@ -526,27 +406,17 @@ void amdgpu_mm_wreg8(struct amdgpu_device
 *adev, uint32_t offset, uint8_t value)
   *
   * Writes the value specified to the offset specified.
   */
-void amdgpu_device_wreg(struct amdgpu_device *adev,
-			uint32_t reg, uint32_t v,
-			uint32_t acc_flags)
+void amdgpu_mm_wreg(struct amdgpu_device *adev, uint32_t reg, uint32_t
 v,
+		    uint32_t acc_flags)
  {
-	if (amdgpu_device_skip_hw_access(adev))
-		return;
-
-	if ((reg * 4) < adev->rmmio_size) {
-		if (!(acc_flags & AMDGPU_REGS_NO_KIQ) &&
-		    amdgpu_sriov_runtime(adev) &&
-		    down_read_trylock(&adev->reset_sem)) {
-			amdgpu_kiq_wreg(adev, reg, v);
-			up_read(&adev->reset_sem);
-		} else {
-			writel(v, ((void __iomem *)adev->rmmio) + (reg * 4));
-		}
-	} else {
-		adev->pcie_wreg(adev, reg * 4, v);
+	if (adev->asic_type >= CHIP_VEGA10 && reg == 0) {
+		adev->last_mm_index = v;
  	}
 
-	trace_amdgpu_device_wreg(adev->pdev->device, reg, v);
+	if ((acc_flags & AMDGPU_REGS_KIQ) || (!(acc_flags &
 AMDGPU_REGS_NO_KIQ) && amdgpu_sriov_runtime(adev)))
+		return amdgpu_kiq_wreg(adev, reg, v);
+
+	amdgpu_mm_wreg_mmio(adev, reg, v, acc_flags);
  }

/*

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +52 -10
@@ -554,19 +424,62 @@ void amdgpu_device_wreg(struct amdgpu_device
 *adev,
   *
   * this function is invoked only the debugfs register access
   * */
-void amdgpu_mm_wreg_mmio_rlc(struct amdgpu_device *adev,
-			     uint32_t reg, uint32_t v)
+void amdgpu_mm_wreg_mmio_rlc(struct amdgpu_device *adev, uint32_t reg,
 uint32_t v,
+		    uint32_t acc_flags)
  {
-	if (amdgpu_device_skip_hw_access(adev))
-		return;
-
  	if (amdgpu_sriov_fullaccess(adev) &&
-	    adev->gfx.rlc.funcs &&
-	    adev->gfx.rlc.funcs->is_rlcg_access_range) {
+		adev->gfx.rlc.funcs &&
+		adev->gfx.rlc.funcs->is_rlcg_access_range) {
+
  		if (adev->gfx.rlc.funcs->is_rlcg_access_range(adev, reg))
-			return adev->gfx.rlc.funcs->sriov_wreg(adev, reg, v, 0,
 0);
-	} else {
-		writel(v, ((void __iomem *)adev->rmmio) + (reg * 4));
+			return adev->gfx.rlc.funcs->rlcg_wreg(adev, reg, v, 0);
+	}
+
+	amdgpu_mm_wreg_mmio(adev, reg, v, acc_flags);
+}
+
+/**
+ * amdgpu_io_rreg - read an IO register
+ *
+ * @adev: amdgpu_device pointer
+ * @reg: dword aligned register offset
+ *
+ * Returns the 32 bit value from the offset specified.
+ */
+u32 amdgpu_io_rreg(struct amdgpu_device *adev, u32 reg)
+{
+	if ((reg * 4) < adev->rio_mem_size)
+		return ioread32(adev->rio_mem + (reg * 4));
+	else {
+		iowrite32((reg * 4), adev->rio_mem + (mmMM_INDEX * 4));
+		return ioread32(adev->rio_mem + (mmMM_DATA * 4));
+	}
+}
+
+/**
+ * amdgpu_io_wreg - write to an IO register
+ *
+ * @adev: amdgpu_device pointer
+ * @reg: dword aligned register offset
+ * @v: 32 bit value to write to the register
+ *
+ * Writes the value specified to the offset specified.
+ */
+void amdgpu_io_wreg(struct amdgpu_device *adev, u32 reg, u32 v)
+{
+	if (adev->asic_type >= CHIP_VEGA10 && reg == 0) {
+		adev->last_mm_index = v;
+	}
+
+	if ((reg * 4) < adev->rio_mem_size)
+		iowrite32(v, adev->rio_mem + (reg * 4));
+	else {
+		iowrite32((reg * 4), adev->rio_mem + (mmMM_INDEX * 4));
+		iowrite32(v, adev->rio_mem + (mmMM_DATA * 4));
+	}
+
+	if (adev->asic_type >= CHIP_VEGA10 && reg == 1 && adev-
Quoted 1 line

last_mm_index == 0x5702C) {

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -3
+		udelay(500);
  	}
  }
@@ -581,9 +494,6 @@ void amdgpu_mm_wreg_mmio_rlc(struct
 amdgpu_device *adev,
   */
  u32 amdgpu_mm_rdoorbell(struct amdgpu_device *adev, u32 index)
  {
-	if (amdgpu_device_skip_hw_access(adev))
-		return 0;
-
  	if (index < adev->doorbell.num_doorbells) {
  		return readl(adev->doorbell.ptr + index);
  	} else {
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -3
@@ -604,9 +514,6 @@ u32 amdgpu_mm_rdoorbell(struct amdgpu_device
 *adev, u32 index)
   */
  void amdgpu_mm_wdoorbell(struct amdgpu_device *adev, u32 index, u32 v)
  {
-	if (amdgpu_device_skip_hw_access(adev))
-		return;
-
  	if (index < adev->doorbell.num_doorbells) {
  		writel(v, adev->doorbell.ptr + index);
  	} else {
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -3
@@ -625,9 +532,6 @@ void amdgpu_mm_wdoorbell(struct amdgpu_device
 *adev, u32 index, u32 v)
   */
  u64 amdgpu_mm_rdoorbell64(struct amdgpu_device *adev, u32 index)
  {
-	if (amdgpu_device_skip_hw_access(adev))
-		return 0;
-
  	if (index < adev->doorbell.num_doorbells) {
  		return atomic64_read((atomic64_t *)(adev->doorbell.ptr +

index));
} else {

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -3
@@ -648,9 +552,6 @@ u64 amdgpu_mm_rdoorbell64(struct amdgpu_device
 *adev, u32 index)
   */
  void amdgpu_mm_wdoorbell64(struct amdgpu_device *adev, u32 index, u64
 v)
  {
-	if (amdgpu_device_skip_hw_access(adev))
-		return;
-
  	if (index < adev->doorbell.num_doorbells) {
  		atomic64_set((atomic64_t *)(adev->doorbell.ptr + index), v);
  	} else {
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -132
@@ -658,141 +559,10 @@ void amdgpu_mm_wdoorbell64(struct
 amdgpu_device *adev, u32 index, u64 v)
  	}
  }
 
-/**
- * amdgpu_device_indirect_rreg - read an indirect register
- *
- * @adev: amdgpu_device pointer
- * @pcie_index: mmio register offset
- * @pcie_data: mmio register offset
- * @reg_addr: indirect register address to read from
- *
- * Returns the value of indirect register @reg_addr
- */
-u32 amdgpu_device_indirect_rreg(struct amdgpu_device *adev,
-				u32 pcie_index, u32 pcie_data,
-				u32 reg_addr)
-{
-	unsigned long flags;
-	u32 r;
-	void __iomem *pcie_index_offset;
-	void __iomem *pcie_data_offset;
-
-	spin_lock_irqsave(&adev->pcie_idx_lock, flags);
-	pcie_index_offset = (void __iomem *)adev->rmmio + pcie_index * 4;
-	pcie_data_offset = (void __iomem *)adev->rmmio + pcie_data * 4;
-
-	writel(reg_addr, pcie_index_offset);
-	readl(pcie_index_offset);
-	r = readl(pcie_data_offset);
-	spin_unlock_irqrestore(&adev->pcie_idx_lock, flags);
-
-	return r;
-}
-
-/**
- * amdgpu_device_indirect_rreg64 - read a 64bits indirect register
- *
- * @adev: amdgpu_device pointer
- * @pcie_index: mmio register offset
- * @pcie_data: mmio register offset
- * @reg_addr: indirect register address to read from
- *
- * Returns the value of indirect register @reg_addr
- */
-u64 amdgpu_device_indirect_rreg64(struct amdgpu_device *adev,
-				  u32 pcie_index, u32 pcie_data,
-				  u32 reg_addr)
-{
-	unsigned long flags;
-	u64 r;
-	void __iomem *pcie_index_offset;
-	void __iomem *pcie_data_offset;
-
-	spin_lock_irqsave(&adev->pcie_idx_lock, flags);
-	pcie_index_offset = (void __iomem *)adev->rmmio + pcie_index * 4;
-	pcie_data_offset = (void __iomem *)adev->rmmio + pcie_data * 4;
-
-	/* read low 32 bits */
-	writel(reg_addr, pcie_index_offset);
-	readl(pcie_index_offset);
-	r = readl(pcie_data_offset);
-	/* read high 32 bits */
-	writel(reg_addr + 4, pcie_index_offset);
-	readl(pcie_index_offset);
-	r |= ((u64)readl(pcie_data_offset) << 32);
-	spin_unlock_irqrestore(&adev->pcie_idx_lock, flags);
-
-	return r;
-}
-
-/**
- * amdgpu_device_indirect_wreg - write an indirect register address
- *
- * @adev: amdgpu_device pointer
- * @pcie_index: mmio register offset
- * @pcie_data: mmio register offset
- * @reg_addr: indirect register offset
- * @reg_data: indirect register data
- *
- */
-void amdgpu_device_indirect_wreg(struct amdgpu_device *adev,
-				 u32 pcie_index, u32 pcie_data,
-				 u32 reg_addr, u32 reg_data)
-{
-	unsigned long flags;
-	void __iomem *pcie_index_offset;
-	void __iomem *pcie_data_offset;
-
-	spin_lock_irqsave(&adev->pcie_idx_lock, flags);
-	pcie_index_offset = (void __iomem *)adev->rmmio + pcie_index * 4;
-	pcie_data_offset = (void __iomem *)adev->rmmio + pcie_data * 4;
-
-	writel(reg_addr, pcie_index_offset);
-	readl(pcie_index_offset);
-	writel(reg_data, pcie_data_offset);
-	readl(pcie_data_offset);
-	spin_unlock_irqrestore(&adev->pcie_idx_lock, flags);
-}
-
-/**
- * amdgpu_device_indirect_wreg64 - write a 64bits indirect register address
- *
- * @adev: amdgpu_device pointer
- * @pcie_index: mmio register offset
- * @pcie_data: mmio register offset
- * @reg_addr: indirect register offset
- * @reg_data: indirect register data
- *
- */
-void amdgpu_device_indirect_wreg64(struct amdgpu_device *adev,
-				   u32 pcie_index, u32 pcie_data,
-				   u32 reg_addr, u64 reg_data)
-{
-	unsigned long flags;
-	void __iomem *pcie_index_offset;
-	void __iomem *pcie_data_offset;
-
-	spin_lock_irqsave(&adev->pcie_idx_lock, flags);
-	pcie_index_offset = (void __iomem *)adev->rmmio + pcie_index * 4;
-	pcie_data_offset = (void __iomem *)adev->rmmio + pcie_data * 4;
-
-	/* write low 32 bits */
-	writel(reg_addr, pcie_index_offset);
-	readl(pcie_index_offset);
-	writel((u32)(reg_data & 0xffffffffULL), pcie_data_offset);
-	readl(pcie_data_offset);
-	/* write high 32 bits */
-	writel(reg_addr + 4, pcie_index_offset);
-	readl(pcie_index_offset);
-	writel((u32)(reg_data >> 32), pcie_data_offset);
-	readl(pcie_data_offset);
-	spin_unlock_irqrestore(&adev->pcie_idx_lock, flags);
-}
-
  /**
   * amdgpu_invalid_rreg - dummy reg read function
   *
- * @adev: amdgpu_device pointer
+ * @adev: amdgpu device pointer
   * @reg: offset of register
   *

* Dummy register read function. Used for register blocks

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -1
@@ -809,7 +579,7 @@ static uint32_t amdgpu_invalid_rreg(struct
 amdgpu_device *adev, uint32_t reg)
  /**
   * amdgpu_invalid_wreg - dummy reg write function
   *
- * @adev: amdgpu_device pointer
+ * @adev: amdgpu device pointer
   * @reg: offset of register
   * @v: value to write to the register
   *
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -0
@@ -826,7 +596,7 @@ static void amdgpu_invalid_wreg(struct

amdgpu_device *adev, uint32_t reg, uint32
/**
* amdgpu_invalid_rreg64 - dummy 64 bit reg read function *
- * @adev: amdgpu_device pointer
+ * @adev: amdgpu device pointer
* @reg: offset of register
*
* Dummy register read function. Used for register blocks

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -1
@@ -843,7 +613,7 @@ static uint64_t amdgpu_invalid_rreg64(struct
 amdgpu_device *adev, uint32_t reg)
  /**
   * amdgpu_invalid_wreg64 - dummy reg write function
   *
- * @adev: amdgpu_device pointer
+ * @adev: amdgpu device pointer
   * @reg: offset of register
   * @v: value to write to the register
   *
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -0
@@ -860,7 +630,7 @@ static void amdgpu_invalid_wreg64(struct

amdgpu_device *adev, uint32_t reg, uint
/**
* amdgpu_block_invalid_rreg - dummy reg read function *
- * @adev: amdgpu_device pointer
+ * @adev: amdgpu device pointer
* @block: offset of instance
* @reg: offset of register
*

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -1
@@ -880,7 +650,7 @@ static uint32_t amdgpu_block_invalid_rreg(struct
 amdgpu_device *adev,
  /**
   * amdgpu_block_invalid_wreg - dummy reg write function
   *
- * @adev: amdgpu_device pointer
+ * @adev: amdgpu device pointer
   * @block: offset of instance
   * @reg: offset of register

* @v: value to write to the register

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -15
@@ -897,24 +667,10 @@ static void amdgpu_block_invalid_wreg(struct
 amdgpu_device *adev,
  	BUG();
  }
 
-/**
- * amdgpu_device_asic_init - Wrapper for atom asic_init
- *
- * @adev: amdgpu_device pointer
- *
- * Does any asic specific work and then calls atom asic init.
- */
-static int amdgpu_device_asic_init(struct amdgpu_device *adev)
-{
-	amdgpu_asic_pre_asic_init(adev);
-
-	return amdgpu_atom_asic_init(adev->mode_info.atom_context);
-}
-
  /**
   * amdgpu_device_vram_scratch_init - allocate the VRAM scratch page
   *
- * @adev: amdgpu_device pointer
+ * @adev: amdgpu device pointer
   *
   * Allocates a scratch page of VRAM for use by various things in the

* driver.

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -1
@@ -931,7 +687,7 @@ static int amdgpu_device_vram_scratch_init(struct
 amdgpu_device *adev)
  /**
   * amdgpu_device_vram_scratch_fini - Free the VRAM scratch page
   *
- * @adev: amdgpu_device pointer
+ * @adev: amdgpu device pointer
   *
   * Frees the VRAM scratch page.
   */
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -12
@@ -992,18 +748,6 @@ void amdgpu_device_pci_config_reset(struct
 amdgpu_device *adev)
  	pci_write_config_dword(adev->pdev, 0x7c,
 AMDGPU_ASIC_RESET_DATA);
  }
 
-/**
- * amdgpu_device_pci_reset - reset the GPU using generic PCI means
- *
- * @adev: amdgpu_device pointer
- *
- * Resets the GPU using generic pci reset interfaces (FLR, SBR, etc.).
- */
-int amdgpu_device_pci_reset(struct amdgpu_device *adev)
-{
-	return pci_reset_function(adev->pdev);
-}
-
  /*

* GPU doorbell aperture helpers function. */

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -0
@@ -1169,6 +913,7 @@ void amdgpu_device_wb_free(struct amdgpu_device
 *adev, u32 wb)
  		__clear_bit(wb, adev->wb.used);
  }
 
+#ifdef AMDKCL_ENABLE_RESIZE_FB_BAR
  /**
   * amdgpu_device_resize_fb_bar - try to resize FB BAR
   *
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -1
@@ -1180,7 +925,8 @@ void amdgpu_device_wb_free(struct amdgpu_device
 *adev, u32 wb)
   */
  int amdgpu_device_resize_fb_bar(struct amdgpu_device *adev)
  {
-	int rbar_size = pci_rebar_bytes_to_size(adev->gmc.real_vram_size);
+	u64 space_needed = roundup_pow_of_two(adev-
 > gmc.real_vram_size);
+	u32 rbar_size = order_base_2(((space_needed >> 20) | 1)) - 1;
  	struct pci_bus *root;

struct resource *res;
unsigned i;

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -5
@@ -1191,11 +937,6 @@ int amdgpu_device_resize_fb_bar(struct
 amdgpu_device *adev)
  	if (amdgpu_sriov_vf(adev))
  		return 0;
 
-	/* skip if the bios has already enabled large BAR */
-	if (adev->gmc.real_vram_size &&
-	    (pci_resource_len(adev->pdev, 0) >= adev->gmc.real_vram_size))
-		return 0;
-
  	/* Check if the root BUS has 64bit memory resources */
  	root = adev->pdev->bus;

while (root->parent)

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -4
@@ -1211,10 +952,6 @@ int amdgpu_device_resize_fb_bar(struct
 amdgpu_device *adev)
  	if (!res)
  		return 0;
 
-	/* Limit the BAR size to what is available */
-	rbar_size = min(fls(pci_rebar_get_possible_sizes(adev->pdev, 0)) - 1,
-			rbar_size);
-
  	/* Disable memory decoding while we change the BAR addresses and

size */
pci_read_config_word(adev->pdev, PCI_COMMAND, &cmd); pci_write_config_word(adev->pdev, PCI_COMMAND,

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -0
@@ -1246,6 +983,7 @@ int amdgpu_device_resize_fb_bar(struct
 amdgpu_device *adev)
 
  	return 0;
  }
+#endif
 
  /*

* GPU helpers function.

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -4
@@ -1286,10 +1024,6 @@ bool amdgpu_device_need_post(struct
 amdgpu_device *adev)
  		}
  	}
 
-	/* Don't post if we need to reset whole hive on init */
-	if (adev->gmc.xgmi.pending_reset)
-		return false;
-
  	if (adev->has_hw_reset) {
  		adev->has_hw_reset = false;

return true;

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -1
@@ -1415,40 +1149,33 @@ static void
 amdgpu_device_check_smu_prv_buffer_size(struct amdgpu_device *adev)
  	adev->pm.smu_prv_buffer_size = 0;
  }
 
-static int amdgpu_device_init_apu_flags(struct amdgpu_device *adev)
+/**
+ * amdgpu_device_enable_extra_fw_load - parse firmware which needs

explicit loading
+ *
+ * @adev: amdgpu_device pointer
+ *
+ * Enable specific firmware loading if the user has enabled it via
+ * the module parameter load_extra_fw. This feature allows the driver
+ * to load specific firmware, which should be skipped under some circumstances
+ * like virtualized environments by default.
+ */
+static void amdgpu_device_enable_extra_fw_load(struct amdgpu_device *adev)
{

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +8 -30
-	if (!(adev->flags & AMD_IS_APU) ||
-	    adev->asic_type < CHIP_RAVEN)
-		return 0;
+	adev->virt.extra_fw = 0;
 
-	switch (adev->asic_type) {
-	case CHIP_RAVEN:
-		if (adev->pdev->device == 0x15dd)
-			adev->apu_flags |= AMD_APU_IS_RAVEN;
-		if (adev->pdev->device == 0x15d8)
-			adev->apu_flags |= AMD_APU_IS_PICASSO;
-		break;
-	case CHIP_RENOIR:
-		if ((adev->pdev->device == 0x1636) ||
-		    (adev->pdev->device == 0x164c))
-			adev->apu_flags |= AMD_APU_IS_RENOIR;
-		else
-			adev->apu_flags |= AMD_APU_IS_GREEN_SARDINE;
-		break;
-	case CHIP_VANGOGH:
-		adev->apu_flags |= AMD_APU_IS_VANGOGH;
-		break;
-	case CHIP_YELLOW_CARP:
-		break;
-	case CHIP_CYAN_SKILLFISH:
-		if (adev->pdev->device == 0x13FE)
-			adev->apu_flags |= AMD_APU_IS_CYAN_SKILLFISH2;
-		break;
-	default:
-		return -EINVAL;
-	}
+	if (amdgpu_load_extra_fw) {
+		char *fwstr, *fwstr_tmp, *fwname_tmp;
 
-	return 0;
+		fwstr = kstrdup(amdgpu_load_extra_fw, GFP_KERNEL);
+		fwstr_tmp = fwstr;
+		while (fwname_tmp = strsep(&fwstr_tmp, ",")) {
+			if (!strcmp("ta", fwname_tmp))
+				adev->virt.extra_fw |=

AMDGPU_SRIOV_EXTRA_FW_PSP_TA;

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -0
+			else
+				DRM_WARN("Skip loading unknown FW

type: %s\n", fwname_tmp);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +3 -8
+		}
+		kfree(fwstr);
+	}
  }
 
  /**
@@ -1492,16 +1219,6 @@ static int amdgpu_device_check_arguments(struct
 amdgpu_device *adev)
  		amdgpu_vm_fragment_size = -1;
  	}
 
-	if (amdgpu_sched_hw_submission < 2) {
-		dev_warn(adev->dev, "sched hw submission jobs (%d) must be
 at least 2\n",
-			 amdgpu_sched_hw_submission);
-		amdgpu_sched_hw_submission = 2;
-	} else if (!is_power_of_2(amdgpu_sched_hw_submission)) {
-		dev_warn(adev->dev, "sched hw submission jobs (%d) must be
 a power of 2\n",
-			 amdgpu_sched_hw_submission);
-		amdgpu_sched_hw_submission =

roundup_pow_of_two(amdgpu_sched_hw_submission);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +4 -4
-	}
-
  	amdgpu_device_check_smu_prv_buffer_size(adev);
 
  	amdgpu_device_check_vm_size(adev);
@@ -1510,9 +1227,11 @@ static int amdgpu_device_check_arguments(struct
 amdgpu_device *adev)
 
  	adev->firmware.load_type = amdgpu_ucode_get_load_type(adev,
 amdgpu_fw_load_type);
 
-	amdgpu_gmc_tmz_set(adev);
+	amdgpu_device_enable_extra_fw_load(adev);
+
+	amdgpu_direct_gma_size = min(amdgpu_direct_gma_size, 96);
 
-	amdgpu_gmc_noretry_set(adev);
+	amdgpu_gmc_tmz_set(adev);
 
  	return 0;
  }
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +10 -9
@@ -1526,36 +1245,37 @@ static int amdgpu_device_check_arguments(struct
 amdgpu_device *adev)
   * Callback for the switcheroo driver.  Suspends or resumes the
   * the asics before or after it is powered up using ACPI methods.
   */
-static void amdgpu_switcheroo_set_state(struct pci_dev *pdev,
-					enum vga_switcheroo_state state)
+static void amdgpu_switcheroo_set_state(struct pci_dev *pdev, enum
 vga_switcheroo_state state)
  {
  	struct drm_device *dev = pci_get_drvdata(pdev);
  	int r;
 
-	if (amdgpu_device_supports_px(dev) && state ==
 VGA_SWITCHEROO_OFF)
+	if (amdgpu_device_supports_boco(dev) && state ==
 VGA_SWITCHEROO_OFF)
  		return;
 
  	if (state == VGA_SWITCHEROO_ON) {
-		pr_info("switched on\n");
+		pr_info("amdgpu: switched on\n");
  		/* don't suspend or resume card normally */
  		dev->switch_power_state =
 DRM_SWITCH_POWER_CHANGING;
 
-		pci_set_power_state(pdev, PCI_D0);
-		amdgpu_device_load_pci_state(pdev);
-		r = pci_enable_device(pdev);
+		pci_set_power_state(dev->pdev, PCI_D0);
+		pci_restore_state(dev->pdev);
+		r = pci_enable_device(dev->pdev);
  		if (r)
  			DRM_WARN("pci_enable_device failed (%d)\n", r);
  		amdgpu_device_resume(dev, true);
 
  		dev->switch_power_state = DRM_SWITCH_POWER_ON;
+		drm_kms_helper_poll_enable(dev);
  	} else {
-		pr_info("switched off\n");
+		pr_info("amdgpu: switched off\n");
+		drm_kms_helper_poll_disable(dev);
  		dev->switch_power_state =
 DRM_SWITCH_POWER_CHANGING;
  		amdgpu_device_suspend(dev, true);
-		amdgpu_device_cache_pci_state(pdev);
+		pci_save_state(dev->pdev);

/* Shut down the device */

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +3 -3
-		pci_disable_device(pdev);
-		pci_set_power_state(pdev, PCI_D3cold);
+		pci_disable_device(dev->pdev);
+		pci_set_power_state(dev->pdev, PCI_D3cold);
  		dev->switch_power_state = DRM_SWITCH_POWER_OFF;
  	}
  }
@@ -1578,7 +1298,7 @@ static bool amdgpu_switcheroo_can_switch(struct
 pci_dev *pdev)
  	* locking inversion with the driver load path. And the access here is
  	* completely racy anyway. So don't bother with locking for now.
  	*/
-	return atomic_read(&dev->open_count) == 0;
+	return dev->open_count == 0;
  }
 
  static const struct vga_switcheroo_client_ops amdgpu_switcheroo_ops = {
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -14
@@ -1793,19 +1513,6 @@ int amdgpu_device_ip_block_add(struct
 amdgpu_device *adev,
  	if (!ip_block_version)
  		return -EINVAL;
 
-	switch (ip_block_version->type) {
-	case AMD_IP_BLOCK_TYPE_VCN:
-		if (adev->harvest_ip_mask & AMD_HARVEST_IP_VCN_MASK)
-			return 0;
-		break;
-	case AMD_IP_BLOCK_TYPE_JPEG:
-		if (adev->harvest_ip_mask & AMD_HARVEST_IP_JPEG_MASK)
-			return 0;
-		break;
-	default:
-		break;
-	}
-
  	DRM_INFO("add ip block number %d <%s>\n", adev->num_ip_blocks,
  		  ip_block_version->funcs->name);
@@ -1831,7 +1538,8 @@ static void
 amdgpu_device_enable_virtual_display(struct amdgpu_device *adev)
  	adev->enable_virtual_display = false;
 
  	if (amdgpu_virtual_display) {
-		const char *pci_address_name = pci_name(adev->pdev);
+		struct drm_device *ddev = adev->ddev;
+		const char *pci_address_name = pci_name(ddev->pdev);
  		char *pciaddstr, *pciaddstr_tmp, *pciaddname_tmp,
 *pciaddname;
  		pciaddstr = kstrdup(amdgpu_virtual_display, GFP_KERNEL);
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -7
@@ -1883,25 +1591,22 @@ static void
 amdgpu_device_enable_virtual_display(struct amdgpu_device *adev)
  static int amdgpu_device_parse_gpu_info_fw(struct amdgpu_device *adev)
  {
  	const char *chip_name;
-	char fw_name[40];
+	char fw_name[30];
  	int err;
  	const struct gpu_info_firmware_header_v1_0 *hdr;
 
  	adev->firmware.gpu_info_fw = NULL;
 
-	if (adev->mman.discovery_bin) {
-		amdgpu_discovery_get_gfx_info(adev);
-
-		/*
-		 * FIXME: The bounding box is still needed by Navi12, so
-		 * temporarily read it from gpu_info firmware. Should be

droped

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +9 -20
-		 * when DAL no longer needs it.
-		 */
-		if (adev->asic_type != CHIP_NAVI12)
-			return 0;
-	}
-
  	switch (adev->asic_type) {
+	case CHIP_TOPAZ:
+	case CHIP_TONGA:
+	case CHIP_FIJI:
+	case CHIP_POLARIS10:
+	case CHIP_POLARIS11:
+	case CHIP_POLARIS12:
+	case CHIP_VEGAM:
+	case CHIP_CARRIZO:
+	case CHIP_STONEY:
  #ifdef CONFIG_DRM_AMDGPU_SI
  	case CHIP_VERDE:
  	case CHIP_TAHITI:
@@ -1916,21 +1621,7 @@ static int
 amdgpu_device_parse_gpu_info_fw(struct amdgpu_device *adev)
  	case CHIP_KABINI:
  	case CHIP_MULLINS:
  #endif
-	case CHIP_TOPAZ:
-	case CHIP_TONGA:
-	case CHIP_FIJI:
-	case CHIP_POLARIS10:
-	case CHIP_POLARIS11:
-	case CHIP_POLARIS12:
-	case CHIP_VEGAM:
-	case CHIP_CARRIZO:
-	case CHIP_STONEY:
  	case CHIP_VEGA20:
-	case CHIP_ALDEBARAN:
-	case CHIP_SIENNA_CICHLID:
-	case CHIP_NAVY_FLOUNDER:
-	case CHIP_DIMGREY_CAVEFISH:
-	case CHIP_BEIGE_GOBY:
  	default:
  		return 0;

case CHIP_VEGA10:

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -2
@@ -1940,9 +1631,9 @@ static int amdgpu_device_parse_gpu_info_fw(struct
 amdgpu_device *adev)
  		chip_name = "vega12";
  		break;
  	case CHIP_RAVEN:
-		if (adev->apu_flags & AMD_APU_IS_RAVEN2)
+		if (adev->rev_id >= 8)
  			chip_name = "raven2";
-		else if (adev->apu_flags & AMD_APU_IS_PICASSO)
+		else if (adev->pdev->device == 0x15d8)
  			chip_name = "picasso";
  		else
  			chip_name = "raven";
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -4
@@ -1951,10 +1642,7 @@ static int
 amdgpu_device_parse_gpu_info_fw(struct amdgpu_device *adev)
  		chip_name = "arcturus";
  		break;
  	case CHIP_RENOIR:
-		if (adev->apu_flags & AMD_APU_IS_RENOIR)
-			chip_name = "renoir";
-		else
-			chip_name = "green_sardine";
+		chip_name = "renoir";
  		break;
  	case CHIP_NAVI10:
  		chip_name = "navi10";
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -6
@@ -1965,12 +1653,6 @@ static int
 amdgpu_device_parse_gpu_info_fw(struct amdgpu_device *adev)
  	case CHIP_NAVI12:
  		chip_name = "navi12";
  		break;
-	case CHIP_VANGOGH:
-		chip_name = "vangogh";
-		break;
-	case CHIP_YELLOW_CARP:
-		chip_name = "yellow_carp";
-		break;
  	}
 

snprintf(fw_name, sizeof(fw_name), "amdgpu/%s_gpu_info.bin",
chip_name);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -0
@@ -1999,10 +1681,7 @@ static int
 amdgpu_device_parse_gpu_info_fw(struct amdgpu_device *adev)
  			(const struct gpu_info_firmware_v1_0 *)(adev-
Quoted 1 line

firmware.gpu_info_fw->data +

	le32_to_cpu(hdr->header.ucode_array_offset_bytes));
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -4
-		/*
-		 * Should be droped when DAL no longer needs it.
-		 */
-		if (adev->asic_type == CHIP_NAVI12)
+		if (amdgpu_discovery && adev->asic_type >= CHIP_NAVI10)
  			goto parse_soc_bounding_box;
 
  		adev->gfx.config.max_shader_engines =

le32_to_cpu(gpu_info_fw->gc_num_se);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -1
@@ -2034,9 +1713,10 @@ static int
 amdgpu_device_parse_gpu_info_fw(struct amdgpu_device *adev)
  		}
 
  parse_soc_bounding_box:
+#ifdef CONFIG_DRM_AMD_DC_DCN2_0
  		/*
  		 * soc bounding box info is not integrated in disocovery table,
-		 * we always need to parse it from gpu info firmware if needed.
+		 * we always need to parse it from gpu info firmware.
  		 */
  		if (hdr->version_minor == 2) {

const struct gpu_info_firmware_v1_2 *gpu_info_fw =

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -0
@@ -2044,6 +1724,7 @@ static int amdgpu_device_parse_gpu_info_fw(struct
 amdgpu_device *adev)
 
 	le32_to_cpu(hdr->header.ucode_array_offset_bytes));
  			adev->dm.soc_bounding_box = &gpu_info_fw-
 > soc_bounding_box;
  		}
+#endif
  		break;
  	}
  	default:
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +17 -5
@@ -2072,13 +1753,25 @@ static int amdgpu_device_ip_early_init(struct
 amdgpu_device *adev)
 
  	amdgpu_device_enable_virtual_display(adev);
 
-	if (amdgpu_sriov_vf(adev)) {
-		r = amdgpu_virt_request_full_gpu(adev, true);
+	switch (adev->asic_type) {
+	case CHIP_TOPAZ:
+	case CHIP_TONGA:
+	case CHIP_FIJI:
+	case CHIP_POLARIS10:
+	case CHIP_POLARIS11:
+	case CHIP_POLARIS12:
+	case CHIP_VEGAM:
+	case CHIP_CARRIZO:
+	case CHIP_STONEY:
+		if (adev->asic_type == CHIP_CARRIZO || adev->asic_type ==
 CHIP_STONEY)
+			adev->family = AMDGPU_FAMILY_CZ;
+		else
+			adev->family = AMDGPU_FAMILY_VI;
+
+		r = vi_set_ip_blocks(adev);
  		if (r)
  			return r;
-	}
-
-	switch (adev->asic_type) {
+		break;
  #ifdef CONFIG_DRM_AMDGPU_SI

case CHIP_VERDE:
case CHIP_TAHITI:

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +5 -23
@@ -2097,42 +1790,24 @@ static int amdgpu_device_ip_early_init(struct
 amdgpu_device *adev)
  	case CHIP_KAVERI:
  	case CHIP_KABINI:
  	case CHIP_MULLINS:
-		if (adev->flags & AMD_IS_APU)
-			adev->family = AMDGPU_FAMILY_KV;
-		else
+		if ((adev->asic_type == CHIP_BONAIRE) || (adev->asic_type ==
 CHIP_HAWAII))
  			adev->family = AMDGPU_FAMILY_CI;
+		else
+			adev->family = AMDGPU_FAMILY_KV;
 
  		r = cik_set_ip_blocks(adev);
  		if (r)
  			return r;
  		break;
  #endif
-	case CHIP_TOPAZ:
-	case CHIP_TONGA:
-	case CHIP_FIJI:
-	case CHIP_POLARIS10:
-	case CHIP_POLARIS11:
-	case CHIP_POLARIS12:
-	case CHIP_VEGAM:
-	case CHIP_CARRIZO:
-	case CHIP_STONEY:
-		if (adev->flags & AMD_IS_APU)
-			adev->family = AMDGPU_FAMILY_CZ;
-		else
-			adev->family = AMDGPU_FAMILY_VI;
-
-		r = vi_set_ip_blocks(adev);
-		if (r)
-			return r;
-		break;
  	case CHIP_VEGA10:
  	case CHIP_VEGA12:
  	case CHIP_VEGA20:
  	case CHIP_RAVEN:
  	case CHIP_ARCTURUS:
  	case CHIP_RENOIR:
-	case CHIP_ALDEBARAN:
-		if (adev->flags & AMD_IS_APU)
+		if (adev->asic_type == CHIP_RAVEN ||
+		    adev->asic_type == CHIP_RENOIR)
  			adev->family = AMDGPU_FAMILY_RV;
  		else
  			adev->family = AMDGPU_FAMILY_AI;
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -13
@@ -2144,19 +1819,7 @@ static int amdgpu_device_ip_early_init(struct
 amdgpu_device *adev)
  	case  CHIP_NAVI10:
  	case  CHIP_NAVI14:
  	case  CHIP_NAVI12:
-	case  CHIP_SIENNA_CICHLID:
-	case  CHIP_NAVY_FLOUNDER:
-	case  CHIP_DIMGREY_CAVEFISH:
-	case  CHIP_BEIGE_GOBY:
-	case CHIP_VANGOGH:
-	case CHIP_YELLOW_CARP:
-	case CHIP_CYAN_SKILLFISH:
-		if (adev->asic_type == CHIP_VANGOGH)
-			adev->family = AMDGPU_FAMILY_VGH;
-		else if (adev->asic_type == CHIP_YELLOW_CARP)
-			adev->family = AMDGPU_FAMILY_YC;
-		else
-			adev->family = AMDGPU_FAMILY_NV;
+		adev->family = AMDGPU_FAMILY_NV;
 
  		r = nv_set_ip_blocks(adev);

if (r)

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +29 -0
@@ -2167,13 +1830,47 @@ static int amdgpu_device_ip_early_init(struct
 amdgpu_device *adev)
  		return -EINVAL;
  	}
 
+	r = amdgpu_device_parse_gpu_info_fw(adev);
+	if (r)
+		return r;
+
+	if (amdgpu_discovery && adev->asic_type >= CHIP_NAVI10)
+		amdgpu_discovery_get_gfx_info(adev);
+
  	amdgpu_amdkfd_device_probe(adev);
 
+	if (amdgpu_sriov_vf(adev)) {
+		/* handle vbios stuff prior full access mode for new handshake
 */
+		if (adev->virt.req_init_data_ver == 1) {
+			if (!amdgpu_get_bios(adev)) {
+				DRM_ERROR("failed to get vbios\n");
+				return -EINVAL;
+			}
+
+			r = amdgpu_atombios_init(adev);
+			if (r) {
+				dev_err(adev->dev, "amdgpu_atombios_init
 failed\n");
+				amdgpu_vf_error_put(adev,
 AMDGIM_ERROR_VF_ATOMBIOS_INIT_FAIL, 0, 0);
+				return r;
+			}
+		}
+	}
+
+	/*get pf2vf msg info at it's earliest time*/
+	if (amdgpu_sriov_vf(adev))
+		amdgpu_virt_init_data_exchange(adev);
+
+	/* we need to send REQ_GPU here for legacy handshaker otherwise

the vbios

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +7 -0
+	 * will not be prepared by host for this VF */
+	if (amdgpu_sriov_vf(adev) && adev->virt.req_init_data_ver < 1) {
+		r = amdgpu_virt_request_full_gpu(adev, true);
+		if (r)
+			return r;
+	}
+
  	adev->pm.pp_feature = amdgpu_pp_feature_mask;
  	if (amdgpu_sriov_vf(adev) || sched_policy ==

KFD_SCHED_POLICY_NO_HWS)
adev->pm.pp_feature &= ~PP_GFXOFF_MASK;

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -1
-	if (amdgpu_sriov_vf(adev) && adev->asic_type ==

CHIP_SIENNA_CICHLID)

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +3 -4
-		adev->pm.pp_feature &= ~PP_OVERDRIVE_MASK;
 
  	for (i = 0; i < adev->num_ip_blocks; i++) {
  		if ((amdgpu_ip_block_mask & (1 << i)) == 0) {
@@ -2198,9 +1895,9 @@ static int amdgpu_device_ip_early_init(struct
 amdgpu_device *adev)
  		}
  		/* get the vbios after the asic_funcs are set up */
  		if (adev->ip_blocks[i].version->type ==
 AMD_IP_BLOCK_TYPE_COMMON) {
-			r = amdgpu_device_parse_gpu_info_fw(adev);
-			if (r)
-				return r;
+			/* skip vbios handling for new handshake */
+			if (amdgpu_sriov_vf(adev) && adev-
 > virt.req_init_data_ver == 1)
+				continue;

/* Read BIOS */
if (!amdgpu_get_bios(adev))

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +7 -7
@@ -2212,16 +1909,16 @@ static int amdgpu_device_ip_early_init(struct
 amdgpu_device *adev)
  				amdgpu_vf_error_put(adev,
 AMDGIM_ERROR_VF_ATOMBIOS_INIT_FAIL, 0, 0);
  				return r;
  			}
-
-			/*get pf2vf msg info at it's earliest time*/
-			if (amdgpu_sriov_vf(adev))
-				amdgpu_virt_init_data_exchange(adev);
-
  		}
  	}
 
-	adev->cg_flags &= amdgpu_cg_mask;
-	adev->pg_flags &= amdgpu_pg_mask;
+	if (amdgpu_sriov_vf(adev)) {
+		adev->cg_flags &= amdgpu_cg_mask;
+		adev->pg_flags &= amdgpu_pg_mask;
+	} else {
+		adev->cg_flags &= 0xffffffff;
+		adev->pg_flags &= 0xffffffff;
+	}
 
  	return 0;
  }
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -3
@@ -2283,14 +1980,11 @@ static int amdgpu_device_fw_loading(struct
 amdgpu_device *adev)
  			if (adev->ip_blocks[i].version->type !=
 AMD_IP_BLOCK_TYPE_PSP)
  				continue;
 
-			if (!adev->ip_blocks[i].status.sw)
-				continue;
-
  			/* no need to do the fw loading again if already

done*/
if (adev->ip_blocks[i].status.hw == true)
break;

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -1
-			if (amdgpu_in_reset(adev) || adev->in_suspend) {
+			if (adev->in_gpu_reset || adev->in_suspend) {
  				r = adev->ip_blocks[i].version->funcs-
Quoted 1 line

resume(adev);

if (r) {
DRM_ERROR("resume of IP block <%s>
failed %d\n",

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +6 -0
@@ -2336,6 +2030,12 @@ static int amdgpu_device_ip_init(struct
 amdgpu_device *adev)
  	if (r)
  		return r;
 
+	if (amdgpu_sriov_vf(adev) && adev->virt.req_init_data_ver > 0) {
+		r = amdgpu_virt_request_full_gpu(adev, true);
+		if (r)
+			return -EAGAIN;
+	}
+
  	for (i = 0; i < adev->num_ip_blocks; i++) {
  		if (!adev->ip_blocks[i].status.valid)

continue;

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -0
@@ -2410,26 +2110,17 @@ static int amdgpu_device_ip_init(struct
 amdgpu_device *adev)
  	 * it should be called after amdgpu_device_ip_hw_init_phase2  since
  	 * for some ASICs the RAS EEPROM code relies on SMU fully

functioning
* for I2C communication which only true at this point.

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +6 -31
-	 *
-	 * amdgpu_ras_recovery_init may fail, but the upper only cares the
-	 * failure from bad gpu situation and stop amdgpu init process
-	 * accordingly. For other failed cases, it will still release all
-	 * the resource and print error message, rather than returning one
-	 * negative value to upper level.
+	 * recovery_init may fail, but it can free all resources allocated by
+	 * itself and its failure should not stop amdgpu init process.
  	 *
  	 * Note: theoretically, this should be called before all vram allocations
  	 * to protect retired page from abusing
  	 */
-	r = amdgpu_ras_recovery_init(adev);
-	if (r)
-		goto init_failed;
+	amdgpu_ras_recovery_init(adev);
 
  	if (adev->gmc.xgmi.num_physical_nodes > 1)
  		amdgpu_xgmi_add_device(adev);
-
-	/* Don't init kfd if whole hive need to be reset during init */
-	if (!adev->gmc.xgmi.pending_reset)
-		amdgpu_amdkfd_device_init(adev);
+	amdgpu_amdkfd_device_init(adev);
 
  	amdgpu_fru_get_product_info(adev);
@@ -2466,24 +2157,8 @@ static void amdgpu_device_fill_reset_magic(struct
 amdgpu_device *adev)
   */
  static bool amdgpu_device_check_vram_lost(struct amdgpu_device *adev)
  {
-	if (memcmp(adev->gart.ptr, adev->reset_magic,
-			AMDGPU_RESET_MAGIC_NUM))
-		return true;
-
-	if (!amdgpu_in_reset(adev))
-		return false;
-
-	/*
-	 * For all ASICs with baco/mode1 reset, the VRAM is
-	 * always assumed to be lost.
-	 */
-	switch (amdgpu_asic_reset_method(adev)) {
-	case AMD_RESET_METHOD_BACO:
-	case AMD_RESET_METHOD_MODE1:
-		return true;
-	default:
-		return false;
-	}
+	return !!memcmp(adev->gart.ptr, adev->reset_magic,
+			AMDGPU_RESET_MAGIC_NUM);
  }
 

/**

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -2
@@ -2499,8 +2174,8 @@ static bool amdgpu_device_check_vram_lost(struct
 amdgpu_device *adev)
   * Returns 0 on success, negative error code on failure.
   */
 
-int amdgpu_device_set_cg_state(struct amdgpu_device *adev,
-			       enum amd_clockgating_state state)
+static int amdgpu_device_set_cg_state(struct amdgpu_device *adev,
+						enum amd_clockgating_state
 state)
  {

int i, j, r;

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -4
@@ -2511,10 +2186,6 @@ int amdgpu_device_set_cg_state(struct
 amdgpu_device *adev,
  		i = state == AMD_CG_STATE_GATE ? j : adev->num_ip_blocks -
 j - 1;
  		if (!adev->ip_blocks[i].status.late_initialized)
  			continue;
-		/* skip CG for GFX on S0ix */
-		if (adev->in_s0ix &&
-		    adev->ip_blocks[i].version->type ==
 AMD_IP_BLOCK_TYPE_GFX)
-			continue;

/* skip CG for VCE/UVD, it's handled specially */ if (adev->ip_blocks[i].version->type !=
AMD_IP_BLOCK_TYPE_UVD &&
adev->ip_blocks[i].version->type !=
AMD_IP_BLOCK_TYPE_VCE &&

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -2
@@ -2535,8 +2206,7 @@ int amdgpu_device_set_cg_state(struct
 amdgpu_device *adev,
  	return 0;
  }
 
-int amdgpu_device_set_pg_state(struct amdgpu_device *adev,
-			       enum amd_powergating_state state)
+static int amdgpu_device_set_pg_state(struct amdgpu_device *adev, enum
 amd_powergating_state state)
  {

int i, j, r;

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -4
@@ -2547,10 +2217,6 @@ int amdgpu_device_set_pg_state(struct
 amdgpu_device *adev,
  		i = state == AMD_PG_STATE_GATE ? j : adev->num_ip_blocks -
 j - 1;
  		if (!adev->ip_blocks[i].status.late_initialized)
  			continue;
-		/* skip PG for GFX on S0ix */
-		if (adev->in_s0ix &&
-		    adev->ip_blocks[i].version->type ==
 AMD_IP_BLOCK_TYPE_GFX)
-			continue;

/* skip CG for VCE/UVD, it's handled specially */ if (adev->ip_blocks[i].version->type !=
AMD_IP_BLOCK_TYPE_UVD &&
adev->ip_blocks[i].version->type !=
AMD_IP_BLOCK_TYPE_VCE &&

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +3 -1
@@ -2590,7 +2256,9 @@ static int
 amdgpu_device_enable_mgpu_fan_boost(void)
  		gpu_ins = &(mgpu_info.gpu_ins[i]);
  		adev = gpu_ins->adev;
  		if (!(adev->flags & AMD_IS_APU) &&
-		    !gpu_ins->mgpu_fan_enabled) {
+		    !gpu_ins->mgpu_fan_enabled &&
+		    adev->powerplay.pp_funcs &&
+		    adev->powerplay.pp_funcs->enable_mgpu_fan_boost) {
  			ret = amdgpu_dpm_enable_mgpu_fan_boost(adev);
  			if (ret)

break;

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -7
@@ -2636,8 +2304,6 @@ static int amdgpu_device_ip_late_init(struct
 amdgpu_device *adev)
  		adev->ip_blocks[i].status.late_initialized = true;
  	}
 
-	amdgpu_ras_set_error_query_ready(adev, true);
-
  	amdgpu_device_set_cg_state(adev, AMD_CG_STATE_GATE);
  	amdgpu_device_set_pg_state(adev, AMD_PG_STATE_GATE);
@@ -2647,11 +2313,6 @@ static int amdgpu_device_ip_late_init(struct
 amdgpu_device *adev)
  	if (r)
  		DRM_ERROR("enable mgpu fan boost failed (%d).\n", r);
 
-	/* For XGMI + passthrough configuration on arcturus, enable light SBR
 */
-	if (adev->asic_type == CHIP_ARCTURUS &&
-	    amdgpu_passthrough(adev) &&
-	    adev->gmc.xgmi.num_physical_nodes > 1)
-		smu_set_light_sbr(&adev->smu, true);
 
  	if (adev->gmc.xgmi.num_physical_nodes > 1) {
  		mutex_lock(&mgpu_info.mutex);
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -2
@@ -2675,8 +2336,7 @@ static int amdgpu_device_ip_late_init(struct
 amdgpu_device *adev)
  				if (gpu_instance->adev->flags & AMD_IS_APU)
  					continue;
 
-				r = amdgpu_xgmi_set_pstate(gpu_instance-
 > adev,
-
 	AMDGPU_XGMI_PSTATE_MIN);
+				r = amdgpu_xgmi_set_pstate(gpu_instance-
Quoted 1 line

adev, 0);

if (r) {
DRM_ERROR("pstate setting failed
(%d).\n", r);
break;

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -29
@@ -2690,59 +2350,6 @@ static int amdgpu_device_ip_late_init(struct
 amdgpu_device *adev)
  	return 0;
  }
 
-static int amdgpu_device_ip_fini_early(struct amdgpu_device *adev)
-{
-	int i, r;
-
-	for (i = 0; i < adev->num_ip_blocks; i++) {
-		if (!adev->ip_blocks[i].version->funcs->early_fini)
-			continue;
-
-		r = adev->ip_blocks[i].version->funcs->early_fini((void *)adev);
-		if (r) {
-			DRM_DEBUG("early_fini of IP block <%s> failed %d\n",
-				  adev->ip_blocks[i].version->funcs->name, r);
-		}
-	}
-
-	amdgpu_amdkfd_suspend(adev, false);
-
-	amdgpu_device_set_pg_state(adev, AMD_PG_STATE_UNGATE);
-	amdgpu_device_set_cg_state(adev, AMD_CG_STATE_UNGATE);
-
-	/* need to disable SMC first */
-	for (i = 0; i < adev->num_ip_blocks; i++) {
-		if (!adev->ip_blocks[i].status.hw)
-			continue;
-		if (adev->ip_blocks[i].version->type ==
 AMD_IP_BLOCK_TYPE_SMC) {
-			r = adev->ip_blocks[i].version->funcs->hw_fini((void
 *)adev);
-			/* XXX handle errors */
-			if (r) {
-				DRM_DEBUG("hw_fini of IP block <%s>

failed %d\n",

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -1
-					  adev->ip_blocks[i].version->funcs-
Quoted 1 line

name, r);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +17 -25
-			}
-			adev->ip_blocks[i].status.hw = false;
-			break;
-		}
-	}
-
-	for (i = adev->num_ip_blocks - 1; i >= 0; i--) {
-		if (!adev->ip_blocks[i].status.hw)
-			continue;
-
-		r = adev->ip_blocks[i].version->funcs->hw_fini((void *)adev);
-		/* XXX handle errors */
-		if (r) {
-			DRM_DEBUG("hw_fini of IP block <%s> failed %d\n",
-				  adev->ip_blocks[i].version->funcs->name, r);
-		}
-
-		adev->ip_blocks[i].status.hw = false;
-	}
-
-	return 0;
-}
-
  /**
   * amdgpu_device_ip_fini - run fini for hardware IPs
   *
@@ -2754,7 +2361,7 @@ static int amdgpu_device_ip_fini_early(struct
 amdgpu_device *adev)
   * and sw_fini tears down any software state associated with each IP.
   * Returns 0 on success, negative error code on failure.
   */
-static int amdgpu_device_ip_fini(struct amdgpu_device *adev)
+static int amdgpu_device_ip_fini(struct amdgpu_device *adev, int skip_hw)
  {
  	int i, r;
@@ -2766,7 +2373,43 @@ static int amdgpu_device_ip_fini(struct
 amdgpu_device *adev)
  	if (adev->gmc.xgmi.num_physical_nodes > 1)
  		amdgpu_xgmi_remove_device(adev);
 
-	amdgpu_amdkfd_device_fini_sw(adev);
+	if (!skip_hw)
+		amdgpu_amdkfd_device_fini(adev);
+
+	amdgpu_device_set_pg_state(adev, AMD_PG_STATE_UNGATE);
+	amdgpu_device_set_cg_state(adev, AMD_CG_STATE_UNGATE);
+
+	if (!skip_hw) {
+		/* need to disable SMC first */
+		for (i = 0; i < adev->num_ip_blocks; i++) {
+			if (!adev->ip_blocks[i].status.hw)
+				continue;
+			if (adev->ip_blocks[i].version->type ==
 AMD_IP_BLOCK_TYPE_SMC) {
+				r = adev->ip_blocks[i].version->funcs-
 > hw_fini((void *)adev);
+				/* XXX handle errors */
+				if (r) {
+					DRM_DEBUG("hw_fini of IP block <%s>

failed %d\n",

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -0
+							adev-
Quoted 1 line

ip_blocks[i].version->funcs->name, r);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +11 -0
+				}
+				adev->ip_blocks[i].status.hw = false;
+				break;
+			}
+		}
+
+		for (i = adev->num_ip_blocks - 1; i >= 0; i--) {
+			if (!adev->ip_blocks[i].status.hw)
+				continue;
+
+			r = adev->ip_blocks[i].version->funcs->hw_fini((void

*)adev);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +3 -0
+			/* XXX handle errors */
+			if (r) {
+				DRM_DEBUG("hw_fini of IP block <%s>

failed %d\n",

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -0
+						adev->ip_blocks[i].version-
Quoted 1 line

funcs->name, r);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +15 -16
+			}
+
+			adev->ip_blocks[i].status.hw = false;
+		}
+	}
 
  	for (i = adev->num_ip_blocks - 1; i >= 0; i--) {
  		if (!adev->ip_blocks[i].status.sw)
@@ -2857,21 +2500,18 @@ static int
 amdgpu_device_ip_suspend_phase1(struct amdgpu_device *adev)
  	for (i = adev->num_ip_blocks - 1; i >= 0; i--) {
  		if (!adev->ip_blocks[i].status.valid)
  			continue;
-
  		/* displays are handled separately */
-		if (adev->ip_blocks[i].version->type !=
 AMD_IP_BLOCK_TYPE_DCE)
-			continue;
-
-		/* XXX handle errors */
-		r = adev->ip_blocks[i].version->funcs->suspend(adev);
-		/* XXX handle errors */
-		if (r) {
-			DRM_ERROR("suspend of IP block <%s> failed %d\n",
-				  adev->ip_blocks[i].version->funcs->name, r);
-			return r;
+		if (adev->ip_blocks[i].version->type ==
 AMD_IP_BLOCK_TYPE_DCE) {
+			/* XXX handle errors */
+			r = adev->ip_blocks[i].version->funcs->suspend(adev);
+			/* XXX handle errors */
+			if (r) {
+				DRM_ERROR("suspend of IP block <%s>
 failed %d\n",
+					  adev->ip_blocks[i].version->funcs-
 > name, r);
+				return r;
+			}
+			adev->ip_blocks[i].status.hw = false;
  		}
-
-		adev->ip_blocks[i].status.hw = false;
  	}
 
  	return 0;
@@ -2892,9 +2532,6 @@ static int amdgpu_device_ip_suspend_phase2(struct
 amdgpu_device *adev)
  {
  	int i, r;
 
-	if (adev->in_s0ix)
-		amdgpu_gfx_state_change_set(adev,
 sGpuChangeState_D3Entry);
-
  	for (i = adev->num_ip_blocks - 1; i >= 0; i--) {

if (!adev->ip_blocks[i].status.valid)
continue;

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -4
@@ -2907,27 +2544,6 @@ static int
 amdgpu_device_ip_suspend_phase2(struct amdgpu_device *adev)
  			adev->ip_blocks[i].status.hw = false;
  			continue;
  		}
-
-		/* skip unnecessary suspend if we do not initialize them yet */
-		if (adev->gmc.xgmi.pending_reset &&
-		    !(adev->ip_blocks[i].version->type ==

AMD_IP_BLOCK_TYPE_GMC ||

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -1
-		      adev->ip_blocks[i].version->type ==

AMD_IP_BLOCK_TYPE_SMC ||

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -1
-		      adev->ip_blocks[i].version->type ==

AMD_IP_BLOCK_TYPE_COMMON ||

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -1
-		      adev->ip_blocks[i].version->type ==

AMD_IP_BLOCK_TYPE_IH)) {

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -11
-			adev->ip_blocks[i].status.hw = false;
-			continue;
-		}
-
-		/* skip suspend of gfx and psp for S0ix
-		 * gfx is in gfxoff state, so on resume it will exit gfxoff just
-		 * like at runtime. PSP is also part of the always on hardware
-		 * so no need to suspend it.
-		 */
-		if (adev->in_s0ix &&
-		    (adev->ip_blocks[i].version->type ==

AMD_IP_BLOCK_TYPE_PSP ||

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -1
-		     adev->ip_blocks[i].version->type ==

AMD_IP_BLOCK_TYPE_GFX))

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -2
-			continue;
-
  		/* XXX handle errors */
  		r = adev->ip_blocks[i].version->funcs->suspend(adev);
  		/* XXX handle errors */
@@ -2947,6 +2563,7 @@ static int amdgpu_device_ip_suspend_phase2(struct
 amdgpu_device *adev)
  				}
  			}
  		}
+		adev->ip_blocks[i].status.hw = false;
  	}
 

return 0;

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +14 -9
@@ -2965,17 +2582,22 @@ static int
 amdgpu_device_ip_suspend_phase2(struct amdgpu_device *adev)
   */
  int amdgpu_device_ip_suspend(struct amdgpu_device *adev)
  {
-	int r;
+	int r = 0;
+	int skip_hw = 0;
 
-	if (amdgpu_sriov_vf(adev)) {
-		amdgpu_virt_fini_data_exchange(adev);
-		amdgpu_virt_request_full_gpu(adev, false);
-	}
+	if (amdgpu_sriov_vf(adev))
+		skip_hw = amdgpu_virt_request_full_gpu(adev, false);
 
-	r = amdgpu_device_ip_suspend_phase1(adev);
-	if (r)
-		return r;
-	r = amdgpu_device_ip_suspend_phase2(adev);
+	/* In case amdgpu_virt_request_full_gpu failed and vm cannot get
+	 * full access, we should skip touching hw and let poweroff continue
+	 */
+
+	if (!skip_hw) {
+		r = amdgpu_device_ip_suspend_phase1(adev);
+		if (r)
+			return r;
+		r = amdgpu_device_ip_suspend_phase2(adev);
+	}
 
  	if (amdgpu_sriov_vf(adev))
  		amdgpu_virt_release_full_gpu(adev, false);
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -2
@@ -2997,7 +2619,6 @@ static int
 amdgpu_device_ip_reinit_early_sriov(struct amdgpu_device *adev)
  	for (i = 0; i < adev->num_ip_blocks; i++) {
  		int j;
  		struct amdgpu_ip_block *block;
-
  		block = &adev->ip_blocks[i];
  		block->status.hw = false;
@@ -3172,7 +2793,7 @@ static void amdgpu_device_detect_sriov_bios(struct
 amdgpu_device *adev)
  {
  	if (amdgpu_sriov_vf(adev)) {
  		if (adev->is_atom_fw) {
-			if
 (amdgpu_atomfirmware_gpu_virtualization_supported(adev))
+			if
 (amdgpu_atomfirmware_gpu_supports_virtualization(adev))

adev->virt.caps |=
AMDGPU_SRIOV_CAPS_SRIOV_VBIOS;
} else {
if
(amdgpu_atombios_has_gpu_virtualization_table(adev))

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -6
@@ -3196,12 +2817,6 @@ bool amdgpu_device_asic_has_dc_support(enum
 amd_asic_type asic_type)
  {
  	switch (asic_type) {
  #if defined(CONFIG_DRM_AMD_DC)
-#if defined(CONFIG_DRM_AMD_DC_SI)
-	case CHIP_TAHITI:
-	case CHIP_PITCAIRN:
-	case CHIP_VERDE:
-	case CHIP_OLAND:
-#endif
  	case CHIP_BONAIRE:
  	case CHIP_KAVERI:

case CHIP_KABINI:

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +5 -8
@@ -3226,24 +2841,22 @@ bool amdgpu_device_asic_has_dc_support(enum
 amd_asic_type asic_type)
  	case CHIP_VEGA10:
  	case CHIP_VEGA12:
  	case CHIP_VEGA20:
-#if defined(CONFIG_DRM_AMD_DC_DCN)
+#if defined(CONFIG_DRM_AMD_DC_DCN1_0)
  	case CHIP_RAVEN:
+#endif
+#if defined(CONFIG_DRM_AMD_DC_DCN2_0)
  	case CHIP_NAVI10:
  	case CHIP_NAVI14:
  	case CHIP_NAVI12:
+#endif
+#if defined(CONFIG_DRM_AMD_DC_DCN2_1)
  	case CHIP_RENOIR:
-	case CHIP_SIENNA_CICHLID:
-	case CHIP_NAVY_FLOUNDER:
-	case CHIP_DIMGREY_CAVEFISH:
-	case CHIP_BEIGE_GOBY:
-	case CHIP_VANGOGH:
-	case CHIP_YELLOW_CARP:
  #endif
  		return amdgpu_dc != 0;
  #endif
  	default:
  		if (amdgpu_dc > 0)
-			DRM_INFO_ONCE("Display Core has been requested

via kernel parameter "

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -0
+			DRM_INFO("Display Core has been requested via

kernel parameter "
"but isn't supported by ASIC,
ignoring\n");
return false;
}

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +4 -5
@@ -3252,25 +2865,24 @@ bool amdgpu_device_asic_has_dc_support(enum
 amd_asic_type asic_type)
  /**
   * amdgpu_device_has_dc_support - check if dc is supported
   *
- * @adev: amdgpu_device pointer
+ * @adev: amdgpu_device_pointer
   *
   * Returns true for supported, false for not supported
   */
  bool amdgpu_device_has_dc_support(struct amdgpu_device *adev)
  {
-	if (amdgpu_sriov_vf(adev) ||
-	    adev->enable_virtual_display ||
-	    (adev->harvest_ip_mask & AMD_HARVEST_IP_DMU_MASK))
+	if (adev->enable_virtual_display)
  		return false;
 
  	return amdgpu_device_asic_has_dc_support(adev->asic_type);
  }
 
+
  static void amdgpu_device_xgmi_reset_func(struct work_struct *__work)
  {
  	struct amdgpu_device *adev =
  		container_of(__work, struct amdgpu_device,
 xgmi_reset_work);
-	struct amdgpu_hive_info *hive = amdgpu_get_xgmi_hive(adev);
+	struct amdgpu_hive_info *hive = amdgpu_get_xgmi_hive(adev, 0);
 

/* It's a bug to not have a hive within this function */ if (WARN_ON(!hive))

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -5
@@ -3285,20 +2897,19 @@ static void
 amdgpu_device_xgmi_reset_func(struct work_struct *__work)
  	if (amdgpu_asic_reset_method(adev) == AMD_RESET_METHOD_BACO)
 {
 
  		task_barrier_enter(&hive->tb);
-		adev->asic_reset_res =
 amdgpu_device_baco_enter(adev_to_drm(adev));
+		adev->asic_reset_res = amdgpu_device_baco_enter(adev-
 > ddev);
  		if (adev->asic_reset_res)
  			goto fail;
 
  		task_barrier_exit(&hive->tb);
-		adev->asic_reset_res =
 amdgpu_device_baco_exit(adev_to_drm(adev));
+		adev->asic_reset_res = amdgpu_device_baco_exit(adev-
 > ddev);
  		if (adev->asic_reset_res)
  			goto fail;
 
-		if (adev->mmhub.ras_funcs &&
-		    adev->mmhub.ras_funcs->reset_ras_error_count)
-			adev->mmhub.ras_funcs-
Quoted 1 line

reset_ras_error_count(adev);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -0
+		if (adev->mmhub.funcs && adev->mmhub.funcs-
Quoted 1 line

reset_ras_error_count)

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -2
+			adev->mmhub.funcs->reset_ras_error_count(adev);
  	} else {
 
  		task_barrier_full(&hive->tb);
@@ -3308,8 +2919,7 @@ static void amdgpu_device_xgmi_reset_func(struct
 work_struct *__work)
  fail:
  	if (adev->asic_reset_res)
  		DRM_WARN("ASIC reset failed with error, %d for drm dev, %s",
-			 adev->asic_reset_res, adev_to_drm(adev)->unique);
-	amdgpu_put_xgmi_hive(hive);
+			 adev->asic_reset_res, adev->ddev->unique);
  }
 

static int amdgpu_device_get_job_timeout_settings(struct amdgpu_device
*adev)

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -2
@@ -3321,8 +2931,8 @@ static int
 amdgpu_device_get_job_timeout_settings(struct amdgpu_device *adev)
  	int ret = 0;
 
  	/*
-	 * By default timeout for non compute jobs is 10000
-	 * and 60000 for compute jobs.
+	 * By default timeout for non compute jobs is 10000.
+	 * And there is no timeout enforced on compute jobs.
  	 * In SR-IOV or passthrough mode, timeout for compute
  	 * jobs are 60000 by default.

*/

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +3 -1
@@ -3331,8 +2941,10 @@ static int
 amdgpu_device_get_job_timeout_settings(struct amdgpu_device *adev)
  	if (amdgpu_sriov_vf(adev))
  		adev->compute_timeout = amdgpu_sriov_is_pp_one_vf(adev) ?
  					msecs_to_jiffies(60000) :
 msecs_to_jiffies(10000);
-	else
+	else if (amdgpu_passthrough(adev))
  		adev->compute_timeout =  msecs_to_jiffies(60000);
+	else
+		adev->compute_timeout = MAX_SCHEDULE_TIMEOUT;
 
  	if (strnlen(input, AMDGPU_MAX_TIMEOUT_PARAM_LENGTH)) {
  		while ((timeout_setting = strsep(&input, ",")) &&
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +36 -7
@@ -3381,18 +2993,47 @@ static int
 amdgpu_device_get_job_timeout_settings(struct amdgpu_device *adev)
  	return ret;
  }
 
-static const struct attribute *amdgpu_dev_attributes[] = {
-	&dev_attr_product_name.attr,
-	&dev_attr_product_number.attr,
-	&dev_attr_serial_number.attr,
-	&dev_attr_pcie_replay_count.attr,
-	NULL
-};
+/**
+ *
+ * The amdgpu driver provides a sysfs API for providing driver version data.
+ */
+static ssize_t amdgpu_get_driver_version(struct device *dev,
+				      struct device_attribute *attr,
+				      char *buf)
+{
+	return snprintf(buf, PAGE_SIZE, "%s\n",
+#ifdef BUILD_NUM
+		__stringify(INTERNAL_VER)"."__stringify(BUILD_NUM));
+#else
+		__stringify(INTERNAL_VER));
+#endif
+}
+
+static DEVICE_ATTR(version, S_IRUGO, amdgpu_get_driver_version, NULL);
+
+static int amdgpu_version_sysfs_init(struct amdgpu_device *adev)
+{
+	int ret;
+
+	ret = device_create_file(adev->dev, &dev_attr_version);
+	if (ret) {
+		DRM_ERROR("failed to create device file for version\n");
+		return ret;
+	}
+	return 0;
+}
+
+static void amdgpu_version_sysfs_fini(struct amdgpu_device *adev)
+{
+	device_remove_file(adev->dev, &dev_attr_version);
+}
 
  /**
   * amdgpu_device_init - initialize the driver
   *
   * @adev: amdgpu_device pointer
+ * @ddev: drm dev pointer
+ * @pdev: pci dev pointer
   * @flags: driver flags
   *

* Initializes the driver info and hw (all asics).

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +6 -3
@@ -3400,15 +3041,18 @@ static const struct attribute
 *amdgpu_dev_attributes[] = {
   * Called at driver startup.
   */
  int amdgpu_device_init(struct amdgpu_device *adev,
+		       struct drm_device *ddev,
+		       struct pci_dev *pdev,
  		       uint32_t flags)
  {
-	struct drm_device *ddev = adev_to_drm(adev);
-	struct pci_dev *pdev = adev->pdev;
  	int r, i;
-	bool px = false;
+	bool boco = false;
  	u32 max_MBps;
 
  	adev->shutdown = false;
+	adev->dev = &pdev->dev;
+	adev->ddev = ddev;
+	adev->pdev = pdev;
  	adev->flags = flags;
 

if (amdgpu_force_asic_type >= 0 && amdgpu_force_asic_type <
CHIP_LAST)

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -1
@@ -3427,7 +3071,6 @@ int amdgpu_device_init(struct amdgpu_device
 *adev,
  	adev->vm_manager.vm_pte_funcs = NULL;
  	adev->vm_manager.vm_pte_num_scheds = 0;
  	adev->gmc.gmc_funcs = NULL;
-	adev->harvest_ip_mask = 0x0;
  	adev->fence_context =
 dma_fence_context_alloc(AMDGPU_MAX_RINGS);

bitmap_zero(adev->gfx.pipe_reserve_bitmap,
AMDGPU_MAX_COMPUTE_QUEUES);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -0
@@ -3454,6 +3097,7 @@ int amdgpu_device_init(struct amdgpu_device
 *adev,
 
  	/* mutex initialization are all done here so we
  	 * can recall function without having locking issues */
+	atomic_set(&adev->irq.ih.lock, 0);
  	mutex_init(&adev->firmware.mutex);
  	mutex_init(&adev->pm.mutex);
  	mutex_init(&adev->gfx.gpu_clock_mutex);
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -7
@@ -3464,14 +3108,9 @@ int amdgpu_device_init(struct amdgpu_device
 *adev,
  	mutex_init(&adev->mn_lock);
  	mutex_init(&adev->virt.vf_errors.lock);
  	hash_init(adev->mn_hash);
-	atomic_set(&adev->in_gpu_reset, 0);
-	init_rwsem(&adev->reset_sem);
+	mutex_init(&adev->lock_reset);
  	mutex_init(&adev->psp.mutex);
-	mutex_init(&adev->notifier_lock);
-
-	r = amdgpu_device_init_apu_flags(adev);
-	if (r)
-		return r;
+	mutex_init(&adev->virt.dump_mutex);
 
  	r = amdgpu_device_check_arguments(adev);

if (r)

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -1
@@ -3490,7 +3129,8 @@ int amdgpu_device_init(struct amdgpu_device
 *adev,
  	INIT_LIST_HEAD(&adev->shadow_list);
  	mutex_init(&adev->shadow_list_lock);
 
-	INIT_LIST_HEAD(&adev->reset_list);
+	INIT_LIST_HEAD(&adev->ring_lru_list);
+	spin_lock_init(&adev->ring_lru_list_lock);
 
  	INIT_DELAYED_WORK(&adev->delayed_init_work,

amdgpu_device_delayed_init_work_handler);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -12
@@ -3500,18 +3140,7 @@ int amdgpu_device_init(struct amdgpu_device
 *adev,
  	INIT_WORK(&adev->xgmi_reset_work,
 amdgpu_device_xgmi_reset_func);
 
  	adev->gfx.gfx_off_req_count = 1;
-	adev->pm.ac_power = power_supply_is_system_supplied() > 0;
-
-	atomic_set(&adev->throttling_logging_enabled, 1);
-	/*
-	 * If throttling continues, logging will be performed every minute
-	 * to avoid log flooding. "-1" is subtracted since the thermal
-	 * throttling interrupt comes every second. Thus, the total logging
-	 * interval is 59 seconds(retelimited printk interval) + 1(waiting
-	 * for throttling interrupt) = 60 seconds.
-	 */
-	ratelimit_state_init(&adev->throttling_logging_rs, (60 - 1) * HZ, 1);
-	ratelimit_set_flags(&adev->throttling_logging_rs,
 RATELIMIT_MSG_ON_RELEASE);
+	adev->pm.ac_power = power_supply_is_system_supplied() > 0 ? true :

false;

/* Registers mapping */
/* TODO: block userspace mapping of io register */

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +5 -0
@@ -3530,6 +3159,17 @@ int amdgpu_device_init(struct amdgpu_device
 *adev,
  	DRM_INFO("register mmio base: 0x%08X\n", (uint32_t)adev-
 > rmmio_base);
  	DRM_INFO("register mmio size: %u\n", (unsigned)adev->rmmio_size);
 
+	/* io port mapping */
+	for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) {
+		if (pci_resource_flags(adev->pdev, i) & IORESOURCE_IO) {
+			adev->rio_mem_size = pci_resource_len(adev->pdev,
 i);
+			adev->rio_mem = pci_iomap(adev->pdev, i, adev-
Quoted 1 line

rio_mem_size);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +6 -0
+			break;
+		}
+	}
+	if (adev->rio_mem == NULL)
+		DRM_INFO("PCI I/O BAR is not found.\n");
+
  	/* enable PCIE atomic ops */
  	r = pci_enable_atomic_ops_to_root(adev->pdev,

PCI_EXP_DEVCAP2_ATOMIC_COMP32 |

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +16 -2
@@ -3566,14 +3206,28 @@ int amdgpu_device_init(struct amdgpu_device
 *adev,
  	/* doorbell bar mapping and doorbell index init*/
  	amdgpu_device_doorbell_init(adev);
 
+	/* if we have > 1 VGA cards, then disable the amdgpu VGA resources */
+	/* this will fail for cards that aren't VGA class devices, just
+	 * ignore it */
+	vga_client_register(adev->pdev, adev, NULL,
 amdgpu_device_vga_set_decode);
+
+	if (amdgpu_device_supports_boco(ddev))
+		boco = true;
+	if (amdgpu_has_atpx() &&
+	    (amdgpu_is_atpx_hybrid() ||
+	     amdgpu_has_atpx_dgpu_power_cntl()) &&
+	    !pci_is_thunderbolt_attached(adev->pdev))
+		vga_switcheroo_register_client(adev->pdev,
+					       &amdgpu_switcheroo_ops, boco);
+	if (boco)
+		vga_switcheroo_init_domain_pm_ops(adev->dev, &adev-
 > vga_pm_domain);
+
  	if (amdgpu_emu_mode == 1) {
  		/* post the asic on emulation mode */
  		emu_soc_asic_init(adev);
  		goto fence_driver_init;
  	}
 
-	amdgpu_reset_init(adev);
-

/* detect if we are with an SRIOV vbios */ amdgpu_device_detect_sriov_bios(adev);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -4
@@ -3581,33 +3235,13 @@ int amdgpu_device_init(struct amdgpu_device
 *adev,
  	 *  E.g., driver was not cleanly unloaded previously, etc.
  	 */
  	if (!amdgpu_sriov_vf(adev) &&
 amdgpu_asic_need_reset_on_init(adev)) {
-		if (adev->gmc.xgmi.num_physical_nodes) {
-			dev_info(adev->dev, "Pending hive reset.\n");
-			adev->gmc.xgmi.pending_reset = true;
-			/* Only need to init necessary block for SMU to handle

the reset */

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -4
-			for (i = 0; i < adev->num_ip_blocks; i++) {
-				if (!adev->ip_blocks[i].status.valid)
-					continue;
-				if (!(adev->ip_blocks[i].version->type ==

AMD_IP_BLOCK_TYPE_GMC ||

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -1
-				      adev->ip_blocks[i].version->type ==

AMD_IP_BLOCK_TYPE_COMMON ||

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -1
-				      adev->ip_blocks[i].version->type ==

AMD_IP_BLOCK_TYPE_IH ||

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -1
-				      adev->ip_blocks[i].version->type ==

AMD_IP_BLOCK_TYPE_SMC)) {

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -1
-					DRM_DEBUG("IP %s disabled for

hw_init.\n",

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -1
-						adev->ip_blocks[i].version-
Quoted 1 line

funcs->name);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -7
-					adev->ip_blocks[i].status.hw = true;
-				}
-			}
-		} else {
-			r = amdgpu_asic_reset(adev);
-			if (r) {
-				dev_err(adev->dev, "asic reset on init

failed\n");

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +5 -5
-				goto failed;
-			}
+		r = amdgpu_asic_reset(adev);
+		if (r) {
+			dev_err(adev->dev, "asic reset on init failed\n");
+			goto failed;
  		}
  	}
 
-	pci_enable_pcie_error_reporting(adev->pdev);
-
  	/* Post card if necessary */
  	if (amdgpu_device_need_post(adev)) {
  		if (!adev->bios) {
@@ -3616,7 +3250,7 @@ int amdgpu_device_init(struct amdgpu_device
 *adev,
  			goto failed;
  		}
  		DRM_INFO("GPU posting now...\n");
-		r = amdgpu_device_asic_init(adev);
+		r = amdgpu_atom_asic_init(adev->mode_info.atom_context);
  		if (r) {
  			dev_err(adev->dev, "gpu post error!\n");

goto failed;

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +3 -3
@@ -3646,15 +3280,15 @@ int amdgpu_device_init(struct amdgpu_device
 *adev,
 
  fence_driver_init:
  	/* Fence driver */
-	r = amdgpu_fence_driver_sw_init(adev);
+	r = amdgpu_fence_driver_init(adev);
  	if (r) {
-		dev_err(adev->dev, "amdgpu_fence_driver_sw_init failed\n");
+		dev_err(adev->dev, "amdgpu_fence_driver_init failed\n");
  		amdgpu_vf_error_put(adev,
 AMDGIM_ERROR_VF_FENCE_INIT_FAIL, 0, 0);
  		goto failed;
  	}
 
  	/* init the mode config */
-	drm_mode_config_init(adev_to_drm(adev));
+	drm_mode_config_init(adev->ddev);
 
  	r = amdgpu_device_ip_init(adev);
  	if (r) {
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +5 -6
@@ -3668,22 +3302,21 @@ int amdgpu_device_init(struct amdgpu_device
 *adev,
  			adev->virt.caps &= ~AMDGPU_SRIOV_CAPS_RUNTIME;
  			adev->virt.ops = NULL;
  			r = -EAGAIN;
-			goto release_ras_con;
+			goto failed;
  		}
  		dev_err(adev->dev, "amdgpu_device_ip_init failed\n");
  		amdgpu_vf_error_put(adev,
 AMDGIM_ERROR_VF_AMDGPU_INIT_FAIL, 0, 0);
-		goto release_ras_con;
+		goto failed;
  	}
 
-	amdgpu_fence_driver_hw_init(adev);
-
-	dev_info(adev->dev,
-		"SE %d, SH per SE %d, CU per SH %d, active_cu_number %d\n",
+	DRM_DEBUG("SE %d, SH per SE %d, CU per SH %d,
 active_cu_number %d\n",
  			adev->gfx.config.max_shader_engines,
  			adev->gfx.config.max_sh_per_se,
  			adev->gfx.config.max_cu_per_sh,
  			adev->gfx.cu_info.number);
 
+	amdgpu_ctx_init_sched(adev);
+
  	adev->accel_working = true;

  	amdgpu_vm_check_compute_bug(adev);
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +8 -0
@@ -3705,6 +3338,14 @@ int amdgpu_device_init(struct amdgpu_device
 *adev,
  	} else
  		adev->pm_sysfs_en = true;
 
+	r = amdgpu_pm_uuid_sysfs_init(adev);
+	if (r)
+		DRM_ERROR("Creating uuid sysfs failed (%d).\n", r);
+
+	r = amdgpu_version_sysfs_init(adev);
+	if (r)
+		DRM_ERROR("Creating version sysfs failed (%d).\n", r);
+
  	r = amdgpu_ucode_sysfs_init(adev);
  	if (r) {
  		adev->ucode_sysfs_en = false;
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +40 -55
@@ -3735,84 +3376,66 @@ int amdgpu_device_init(struct amdgpu_device
 *adev,
  	/* enable clockgating, etc. after ib tests, etc. since some blocks require
  	 * explicit gating rather than handling it automatically.
  	 */
-	if (!adev->gmc.xgmi.pending_reset) {
-		r = amdgpu_device_ip_late_init(adev);
+	r = amdgpu_device_ip_late_init(adev);
+	if (r) {
+		dev_err(adev->dev, "amdgpu_device_ip_late_init failed\n");
+		amdgpu_vf_error_put(adev,
 AMDGIM_ERROR_VF_AMDGPU_LATE_INIT_FAIL, 0, r);
+		goto failed;
+	}
+
+	/* must succeed. */
+	amdgpu_ras_resume(adev);
+
+	if (amdgpu_sriov_vf(adev)) {
+		r = amdgpu_ib_ring_tests(adev);
  		if (r) {
-			dev_err(adev->dev, "amdgpu_device_ip_late_init
 failed\n");
-			amdgpu_vf_error_put(adev,
 AMDGIM_ERROR_VF_AMDGPU_LATE_INIT_FAIL, 0, r);
-			goto release_ras_con;
+			DRM_ERROR("ib ring test failed (%d).\n", r);
+			return r;
  		}
-		/* must succeed. */
-		amdgpu_ras_resume(adev);
+	} else {
  		queue_delayed_work(system_wq, &adev->delayed_init_work,
-				   msecs_to_jiffies(AMDGPU_RESUME_MS));
+			   msecs_to_jiffies(AMDGPU_RESUME_MS));
  	}
 
-	if (amdgpu_sriov_vf(adev))
-		flush_delayed_work(&adev->delayed_init_work);
+	r = device_create_file(adev->dev, &dev_attr_pcie_replay_count);
+	if (r) {
+		dev_err(adev->dev, "Could not create pcie_replay_count");
+		return r;
+	}
 
-	r = sysfs_create_files(&adev->dev->kobj, amdgpu_dev_attributes);
-	if (r)
-		dev_err(adev->dev, "Could not create amdgpu device attr\n");
+	r = device_create_file(adev->dev, &dev_attr_product_name);
+	if (r) {
+		dev_err(adev->dev, "Could not create product_name");
+		return r;
+	}
+
+	r = device_create_file(adev->dev, &dev_attr_product_number);
+	if (r) {
+		dev_err(adev->dev, "Could not create product_number");
+		return r;
+	}
+
+	r = device_create_file(adev->dev, &dev_attr_serial_number);
+	if (r) {
+		dev_err(adev->dev, "Could not create serial_number");
+		return r;
+	}
 
  	if (IS_ENABLED(CONFIG_PERF_EVENTS))
  		r = amdgpu_pmu_init(adev);
  	if (r)
  		dev_err(adev->dev, "amdgpu_pmu_init failed\n");
 
-	/* Have stored pci confspace at hand for restore in sudden PCI error */
-	if (amdgpu_device_cache_pci_state(adev->pdev))
-		pci_restore_state(pdev);
-
-	/* if we have > 1 VGA cards, then disable the amdgpu VGA resources */
-	/* this will fail for cards that aren't VGA class devices, just
-	 * ignore it */
-	if ((adev->pdev->class >> 8) == PCI_CLASS_DISPLAY_VGA)
-		vga_client_register(adev->pdev, adev, NULL,
 amdgpu_device_vga_set_decode);
-
-	if (amdgpu_device_supports_px(ddev)) {
-		px = true;
-		vga_switcheroo_register_client(adev->pdev,
-					       &amdgpu_switcheroo_ops, px);
-		vga_switcheroo_init_domain_pm_ops(adev->dev, &adev-
 > vga_pm_domain);
-	}
-
-	if (adev->gmc.xgmi.pending_reset)
-		queue_delayed_work(system_wq,
 &mgpu_info.delayed_reset_work,
-				   msecs_to_jiffies(AMDGPU_RESUME_MS));
-
  	return 0;
 
-release_ras_con:
-	amdgpu_release_ras_context(adev);
-
  failed:
  	amdgpu_vf_error_trans_all(adev);
+	if (boco)
+		vga_switcheroo_fini_domain_pm_ops(adev->dev);
 
  	return r;
  }
 
-static void amdgpu_device_unmap_mmio(struct amdgpu_device *adev)
-{
-	/* Clear all CPU mappings pointing to this device */
-	unmap_mapping_range(adev->ddev.anon_inode->i_mapping, 0, 0, 1);
-
-	/* Unmap all mapped bars - Doorbell, registers and VRAM */
-	amdgpu_device_doorbell_fini(adev);
-
-	iounmap(adev->rmmio);
-	adev->rmmio = NULL;
-	if (adev->mman.aper_base_kaddr)
-		iounmap(adev->mman.aper_base_kaddr);
-	adev->mman.aper_base_kaddr = NULL;
-
-	/* Memory manager related */
-	if (!adev->gmc.xgmi.connected_to_cpu) {
-		arch_phys_wc_del(adev->gmc.vram_mtrr);
-		arch_io_free_memtype_wc(adev->gmc.aper_base, adev-
Quoted 1 line

gmc.aper_size);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +26 -38
-	}
-}
-
  /**
   * amdgpu_device_fini - tear down the driver
   *
@@ -3821,58 +3444,49 @@ static void amdgpu_device_unmap_mmio(struct
 amdgpu_device *adev)
   * Tear down the driver info (all asics).
   * Called at driver shutdown.
   */
-void amdgpu_device_fini_hw(struct amdgpu_device *adev)
+void amdgpu_device_fini(struct amdgpu_device *adev)
  {
-	dev_info(adev->dev, "amdgpu: finishing device.\n");
-	flush_delayed_work(&adev->delayed_init_work);
+	int r = 0;
+	/* In case amdgpu_virt_request_full_gpu failed and vm cannot get
+	* full access, we should skip touching hw and let unload continue
+	*/
+	int skip_hw = 0;
+
+	DRM_INFO("amdgpu: finishing device.\n");
+	if (!amdgpu_sriov_vf(adev))
+		flush_delayed_work(&adev->delayed_init_work);
  	ttm_bo_lock_delayed_workqueue(&adev->mman.bdev);
  	adev->shutdown = true;
 
  	/* make sure IB test finished before entering exclusive mode
  	 * to avoid preemption on IB test
  	 * */
-	if (amdgpu_sriov_vf(adev)) {
-		amdgpu_virt_request_full_gpu(adev, false);
-		amdgpu_virt_fini_data_exchange(adev);
-	}
+	if (amdgpu_sriov_vf(adev))
+		skip_hw = amdgpu_virt_request_full_gpu(adev, false);
 
  	/* disable all interrupts */
-	amdgpu_irq_disable_all(adev);
+	if (!skip_hw)
+		amdgpu_irq_disable_all(adev);
  	if (adev->mode_info.mode_config_initialized){
  		if (!amdgpu_device_has_dc_support(adev))
-			drm_helper_force_disable_all(adev_to_drm(adev));
+			drm_helper_force_disable_all(adev->ddev);
+#ifdef HAVE_DRM_ATOMIC_HELPER_SHUTDOWN
  		else
-			drm_atomic_helper_shutdown(adev_to_drm(adev));
+			drm_atomic_helper_shutdown(adev->ddev);
+#endif
  	}
-	amdgpu_fence_driver_hw_fini(adev);
-
+	amdgpu_fence_driver_fini(adev, skip_hw);
+	amdgpu_pm_uuid_sysfs_fini(adev);
  	if (adev->pm_sysfs_en)
  		amdgpu_pm_sysfs_fini(adev);
-	if (adev->ucode_sysfs_en)
-		amdgpu_ucode_sysfs_fini(adev);
-	sysfs_remove_files(&adev->dev->kobj, amdgpu_dev_attributes);
-
+	amdgpu_version_sysfs_fini(adev);
  	amdgpu_fbdev_fini(adev);
-
-	amdgpu_irq_fini_hw(adev);
-
-	amdgpu_device_ip_fini_early(adev);
-
-	amdgpu_gart_dummy_page_fini(adev);
-
-	amdgpu_device_unmap_mmio(adev);
-}
-
-void amdgpu_device_fini_sw(struct amdgpu_device *adev)
-{
-	amdgpu_device_ip_fini(adev);
-	amdgpu_fence_driver_sw_fini(adev);
-	release_firmware(adev->firmware.gpu_info_fw);
-	adev->firmware.gpu_info_fw = NULL;
+	r = amdgpu_device_ip_fini(adev, skip_hw);
+	if (adev->firmware.gpu_info_fw) {
+		release_firmware(adev->firmware.gpu_info_fw);
+		adev->firmware.gpu_info_fw = NULL;
+	}
  	adev->accel_working = false;
-
-	amdgpu_reset_fini(adev);
-
  	/* free i2c buses */
  	if (!amdgpu_device_has_dc_support(adev))
  		amdgpu_i2c_fini(adev);
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +20 -8
@@ -3882,20 +3496,31 @@ void amdgpu_device_fini_sw(struct
 amdgpu_device *adev)
 
  	kfree(adev->bios);
  	adev->bios = NULL;
-	if (amdgpu_device_supports_px(adev_to_drm(adev))) {
+	if (amdgpu_has_atpx() &&
+	    (amdgpu_is_atpx_hybrid() ||
+	     amdgpu_has_atpx_dgpu_power_cntl()) &&
+	    !pci_is_thunderbolt_attached(adev->pdev))
  		vga_switcheroo_unregister_client(adev->pdev);
+	if (amdgpu_device_supports_boco(adev->ddev))
  		vga_switcheroo_fini_domain_pm_ops(adev->dev);
-	}
-	if ((adev->pdev->class >> 8) == PCI_CLASS_DISPLAY_VGA)
-		vga_client_register(adev->pdev, NULL, NULL, NULL);
+	vga_client_register(adev->pdev, NULL, NULL, NULL);
+	if (adev->rio_mem)
+		pci_iounmap(adev->pdev, adev->rio_mem);
+	adev->rio_mem = NULL;
+	iounmap(adev->rmmio);
+	adev->rmmio = NULL;
+	amdgpu_device_doorbell_fini(adev);
 
+	device_remove_file(adev->dev, &dev_attr_pcie_replay_count);
+	if (adev->ucode_sysfs_en)
+		amdgpu_ucode_sysfs_fini(adev);
+	device_remove_file(adev->dev, &dev_attr_product_name);
+	device_remove_file(adev->dev, &dev_attr_product_number);
+	device_remove_file(adev->dev, &dev_attr_serial_number);
  	if (IS_ENABLED(CONFIG_PERF_EVENTS))
  		amdgpu_pmu_fini(adev);
-	if (adev->mman.discovery_bin)
+	if (amdgpu_discovery && adev->asic_type >= CHIP_NAVI10)
  		amdgpu_discovery_fini(adev);
-
-	kfree(adev->pci_state);
-
  }
 
@@ -3906,6 +3531,7 @@ void amdgpu_device_fini_sw(struct amdgpu_device
 *adev)
   * amdgpu_device_suspend - initiate device suspend
   *
   * @dev: drm dev pointer
+ * @suspend: suspend state
   * @fbcon : notify the fbdev of suspend
   *

* Puts the hw in the suspend state (all asics).

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +67 -12
@@ -3914,36 +3540,90 @@ void amdgpu_device_fini_sw(struct
 amdgpu_device *adev)
   */
  int amdgpu_device_suspend(struct drm_device *dev, bool fbcon)
  {
-	struct amdgpu_device *adev = drm_to_adev(dev);
+	struct amdgpu_device *adev;
+	struct drm_crtc *crtc;
+	struct drm_connector *connector;
+#ifdef HAVE_DRM_CONNECTOR_LIST_ITER_BEGIN
+	struct drm_connector_list_iter iter;
+#endif
+	int r;
+
+	if (dev == NULL || dev->dev_private == NULL) {
+		return -ENODEV;
+	}
+
+	adev = dev->dev_private;
 
  	if (dev->switch_power_state == DRM_SWITCH_POWER_OFF)
  		return 0;
 
  	adev->in_suspend = true;
-
-	if (amdgpu_acpi_smart_shift_update(dev, AMDGPU_SS_DEV_D3))
-		DRM_WARN("smart shift update failed\n");
-
  	drm_kms_helper_poll_disable(dev);
 
  	if (fbcon)
  		amdgpu_fbdev_set_suspend(adev, 1);
 
-	cancel_delayed_work_sync(&adev->delayed_init_work);
+	if (!amdgpu_sriov_vf(adev))
+		cancel_delayed_work_sync(&adev->delayed_init_work);
 
-	amdgpu_ras_suspend(adev);
+	if (!amdgpu_device_has_dc_support(adev)) {
+		/* turn off display hw */
+		drm_modeset_lock_all(dev);
+#ifdef HAVE_DRM_CONNECTOR_LIST_ITER_BEGIN
+		drm_connector_list_iter_begin(dev, &iter);
+		drm_for_each_connector_iter(connector, &iter)
+#else
+		drm_for_each_connector(connector, dev)
+#endif
+			drm_helper_connector_dpms(connector,
+						  DRM_MODE_DPMS_OFF);
+#ifdef HAVE_DRM_CONNECTOR_LIST_ITER_BEGIN
+		drm_connector_list_iter_end(&iter);
+#endif
+		drm_modeset_unlock_all(dev);
+			/* unpin the front buffers and cursors */
+		list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
+			struct amdgpu_crtc *amdgpu_crtc =
 to_amdgpu_crtc(crtc);
+			struct drm_framebuffer *fb = crtc->primary->fb;
+			struct amdgpu_bo *robj;
+
+			if (amdgpu_crtc->cursor_bo && !adev-
 > enable_virtual_display) {
+				struct amdgpu_bo *aobj =
 gem_to_amdgpu_bo(amdgpu_crtc->cursor_bo);
+				r = amdgpu_bo_reserve(aobj, true);
+				if (r == 0) {
+					amdgpu_bo_unpin(aobj);
+					amdgpu_bo_unreserve(aobj);
+				}
+			}
+
+			if (fb == NULL || kcl_drm_fb_get_gem_obj(fb, 0) ==
 NULL) {
+				continue;
+			}
+			robj =
 gem_to_amdgpu_bo(kcl_drm_fb_get_gem_obj(fb, 0));
+			/* don't unpin kernel fb objects */
+			if (!amdgpu_fbdev_robj_is_fb(adev, robj)) {
+				r = amdgpu_bo_reserve(robj, true);
+				if (r == 0) {
+					amdgpu_bo_unpin(robj);
+					amdgpu_bo_unreserve(robj);
+				}
+			}
+		}
+	}
+
+	amdgpu_amdkfd_suspend(adev, !fbcon);
 
-	amdgpu_device_ip_suspend_phase1(adev);
+	amdgpu_ras_suspend(adev);
 
-	if (!adev->in_s0ix)
-		amdgpu_amdkfd_suspend(adev, adev->in_runpm);
+	r = amdgpu_device_ip_suspend_phase1(adev);
 
  	/* evict vram memory */
  	amdgpu_bo_evict_vram(adev);
 
-	amdgpu_fence_driver_hw_fini(adev);
+	amdgpu_fence_driver_suspend(adev);
+
+	r = amdgpu_device_ip_suspend_phase2(adev);
 
-	amdgpu_device_ip_suspend_phase2(adev);
  	/* evict remaining vram memory
  	 * This second call to evict vram is to evict the gart page table
  	 * using the CPU.
@@ -3957,6 +3637,7 @@ int amdgpu_device_suspend(struct drm_device *dev,
 bool fbcon)
   * amdgpu_device_resume - initiate device resume
   *
   * @dev: drm dev pointer
+ * @resume: resume state
   * @fbcon : notify the fbdev of resume
   *

* Bring the hw back to operating state (all asics).

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +59 -15
@@ -3965,47 +3646,98 @@ int amdgpu_device_suspend(struct drm_device
 *dev, bool fbcon)
   */
  int amdgpu_device_resume(struct drm_device *dev, bool fbcon)
  {
-	struct amdgpu_device *adev = drm_to_adev(dev);
+	struct drm_connector *connector;
+#ifdef HAVE_DRM_CONNECTOR_LIST_ITER_BEGIN
+	struct drm_connector_list_iter iter;
+#endif
+	struct amdgpu_device *adev = dev->dev_private;
+	struct drm_crtc *crtc;
  	int r = 0;
 
  	if (dev->switch_power_state == DRM_SWITCH_POWER_OFF)
  		return 0;
 
-	if (adev->in_s0ix)
-		amdgpu_gfx_state_change_set(adev,
 sGpuChangeState_D0Entry);
-
  	/* post card */
  	if (amdgpu_device_need_post(adev)) {
-		r = amdgpu_device_asic_init(adev);
+		r = amdgpu_atom_asic_init(adev->mode_info.atom_context);
  		if (r)
-			dev_err(adev->dev, "amdgpu asic init failed\n");
+			DRM_ERROR("amdgpu asic init failed\n");
  	}
 
  	r = amdgpu_device_ip_resume(adev);
  	if (r) {
-		dev_err(adev->dev, "amdgpu_device_ip_resume failed
 (%d).\n", r);
+		DRM_ERROR("amdgpu_device_ip_resume failed (%d).\n", r);
  		return r;
  	}
-	amdgpu_fence_driver_hw_init(adev);
+	amdgpu_fence_driver_resume(adev);
+
 
  	r = amdgpu_device_ip_late_init(adev);
  	if (r)
  		return r;
 
-	queue_delayed_work(system_wq, &adev->delayed_init_work,
+	if (amdgpu_sriov_vf(adev)) {
+		r = amdgpu_ib_ring_tests(adev);
+		if (r) {
+			DRM_ERROR("ib ring test failed (%d).\n", r);
+			return r;
+		}
+	} else {
+		queue_delayed_work(system_wq, &adev->delayed_init_work,
  			   msecs_to_jiffies(AMDGPU_RESUME_MS));
+	}
 
-	if (!adev->in_s0ix) {
-		r = amdgpu_amdkfd_resume(adev, adev->in_runpm);
-		if (r)
-			return r;
+	if (!amdgpu_device_has_dc_support(adev)) {
+		/* pin cursors */
+		list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
+			struct amdgpu_crtc *amdgpu_crtc =
 to_amdgpu_crtc(crtc);
+
+			if (amdgpu_crtc->cursor_bo && !adev-
 > enable_virtual_display) {
+				struct amdgpu_bo *aobj =
 gem_to_amdgpu_bo(amdgpu_crtc->cursor_bo);
+				r = amdgpu_bo_reserve(aobj, true);
+				if (r == 0) {
+					r = amdgpu_bo_pin(aobj,
 AMDGPU_GEM_DOMAIN_VRAM);
+					if (r != 0)
+						DRM_ERROR("Failed to pin
 cursor BO (%d)\n", r);
+					amdgpu_crtc->cursor_addr =
 amdgpu_bo_gpu_offset(aobj);
+					amdgpu_bo_unreserve(aobj);
+				}
+			}
+		}
  	}
+	r = amdgpu_amdkfd_resume(adev, !fbcon);
+	if (r)
+		return r;
 
  	/* Make sure IB tests flushed */
-	flush_delayed_work(&adev->delayed_init_work);
+	if (!amdgpu_sriov_vf(adev))
+		flush_delayed_work(&adev->delayed_init_work);
 
-	if (fbcon)
+	/* blat the mode back in */
+	if (fbcon) {
+		if (!amdgpu_device_has_dc_support(adev)) {
+			/* pre DCE11 */
+			drm_helper_resume_force_mode(dev);
+
+			/* turn on display hw */
+			drm_modeset_lock_all(dev);
+
+#ifdef HAVE_DRM_CONNECTOR_LIST_ITER_BEGIN
+			drm_connector_list_iter_begin(dev, &iter);
+			drm_for_each_connector_iter(connector, &iter)
+#else
+			drm_for_each_connector(connector, dev)
+#endif
+				drm_helper_connector_dpms(connector,
+

DRM_MODE_DPMS_ON);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +8 -4
+#ifdef HAVE_DRM_CONNECTOR_LIST_ITER_BEGIN
+			drm_connector_list_iter_end(&iter);
+#endif
+
+			drm_modeset_unlock_all(dev);
+		}
  		amdgpu_fbdev_set_suspend(adev, 0);
+	}
 
  	drm_kms_helper_poll_enable(dev);
@@ -4032,9 +3764,6 @@ int amdgpu_device_resume(struct drm_device *dev,
 bool fbcon)
  #endif
  	adev->in_suspend = false;
 
-	if (amdgpu_acpi_smart_shift_update(dev, AMDGPU_SS_DEV_D0))
-		DRM_WARN("smart shift update failed\n");
-
  	return 0;
  }
@@ -4066,7 +3795,7 @@ static bool
 amdgpu_device_ip_check_soft_reset(struct amdgpu_device *adev)
  			adev->ip_blocks[i].status.hang =
  				adev->ip_blocks[i].version->funcs-
 > check_soft_reset(adev);
  		if (adev->ip_blocks[i].status.hang) {
-			dev_info(adev->dev, "IP block:%s is hung!\n", adev-
 > ip_blocks[i].version->funcs->name);
+			DRM_INFO("IP block:%s is hung!\n", adev-
Quoted 1 line

ip_blocks[i].version->funcs->name);

asic_hang = true;
}
}

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -0
@@ -4127,7 +3856,7 @@ static bool
 amdgpu_device_ip_need_full_reset(struct amdgpu_device *adev)
  		    (adev->ip_blocks[i].version->type ==

AMD_IP_BLOCK_TYPE_DCE) ||
adev->ip_blocks[i].version->type ==
AMD_IP_BLOCK_TYPE_PSP) {
if (adev->ip_blocks[i].status.hang) {

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -1
-				dev_info(adev->dev, "Some block need full

reset!\n");

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -1
+				DRM_INFO("Some block need full reset!\n");
  				return true;
  			}
  		}
@@ -4208,7 +3937,6 @@ static int amdgpu_device_recover_vram(struct
 amdgpu_device *adev)
  {
  	struct dma_fence *fence = NULL, *next = NULL;
  	struct amdgpu_bo *shadow;
-	struct amdgpu_bo_vm *vmbo;
  	long r = 1, tmo;
 

if (amdgpu_sriov_runtime(adev))

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +3 -5
@@ -4216,14 +3944,14 @@ static int amdgpu_device_recover_vram(struct
 amdgpu_device *adev)
  	else
  		tmo = msecs_to_jiffies(100);
 
-	dev_info(adev->dev, "recover vram bo from shadow start\n");
+	DRM_INFO("recover vram bo from shadow start\n");
  	mutex_lock(&adev->shadow_list_lock);
-	list_for_each_entry(vmbo, &adev->shadow_list, shadow_list) {
-		shadow = &vmbo->bo;
+	list_for_each_entry(shadow, &adev->shadow_list, shadow_list) {
+
  		/* No need to recover an evicted BO */
-		if (shadow->tbo.resource->mem_type != TTM_PL_TT ||
-		    shadow->tbo.resource->start ==

AMDGPU_BO_INVALID_OFFSET ||

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -1
-		    shadow->parent->tbo.resource->mem_type !=

TTM_PL_VRAM)

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -0
+		if (shadow->tbo.mem.mem_type != TTM_PL_TT ||
+		    shadow->tbo.mem.start == AMDGPU_BO_INVALID_OFFSET

||

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +3 -2
+		    shadow->parent->tbo.mem.mem_type != TTM_PL_VRAM)
  			continue;
 
  		r = amdgpu_bo_restore_shadow(shadow, &next);
@@ -4252,11 +3980,11 @@ static int amdgpu_device_recover_vram(struct
 amdgpu_device *adev)
  	dma_fence_put(fence);
 
  	if (r < 0 || tmo <= 0) {
-		dev_err(adev->dev, "recover vram bo from shadow failed, r
 is %ld, tmo is %ld\n", r, tmo);
+		DRM_ERROR("recover vram bo from shadow failed, r is %ld,
 tmo is %ld\n", r, tmo);
  		return -EIO;
  	}
 
-	dev_info(adev->dev, "recover vram bo from shadow done\n");
+	DRM_INFO("recover vram bo from shadow done\n");
  	return 0;
  }
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -1
@@ -4264,7 +3992,7 @@ static int amdgpu_device_recover_vram(struct
 amdgpu_device *adev)
  /**
   * amdgpu_device_reset_sriov - reset ASIC for SR-IOV vf
   *
- * @adev: amdgpu_device pointer
+ * @adev: amdgpu device pointer
   * @from_hypervisor: request from hypervisor
   *

* do VF FLR and reinitialize Asic

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -1
@@ -4291,7 +4019,7 @@ static int amdgpu_device_reset_sriov(struct
 amdgpu_device *adev,
 
  	amdgpu_virt_init_data_exchange(adev);
  	/* we need recover gart prior to run SMC/CP/SDMA resume */
-	amdgpu_gtt_mgr_recover(ttm_manager_type(&adev->mman.bdev,
 TTM_PL_TT));
+	amdgpu_gtt_mgr_recover(&adev->mman.bdev.man[TTM_PL_TT]);
 
  	r = amdgpu_device_fw_loading(adev);
  	if (r)
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -30
@@ -4307,47 +4035,19 @@ static int amdgpu_device_reset_sriov(struct
 amdgpu_device *adev,
  	amdgpu_amdkfd_post_reset(adev);
 
  error:
+	amdgpu_virt_release_full_gpu(adev, true);
  	if (!r && adev->virt.gim_feature &
 AMDGIM_FEATURE_GIM_FLR_VRAMLOST) {
  		amdgpu_inc_vram_lost(adev);
  		r = amdgpu_device_recover_vram(adev);
  	}
-	amdgpu_virt_release_full_gpu(adev, true);
 
  	return r;
  }
 
-/**
- * amdgpu_device_has_job_running - check if there is any job in mirror list
- *
- * @adev: amdgpu_device pointer
- *
- * check if there is any job in mirror list
- */
-bool amdgpu_device_has_job_running(struct amdgpu_device *adev)
-{
-	int i;
-	struct drm_sched_job *job;
-
-	for (i = 0; i < AMDGPU_MAX_RINGS; ++i) {
-		struct amdgpu_ring *ring = adev->rings[i];
-
-		if (!ring || !ring->sched.thread)
-			continue;
-
-		spin_lock(&ring->sched.job_list_lock);
-		job = list_first_entry_or_null(&ring->sched.pending_list,
-					       struct drm_sched_job, list);
-		spin_unlock(&ring->sched.job_list_lock);
-		if (job)
-			return true;
-	}
-	return false;
-}
-
  /**
   * amdgpu_device_should_recover_gpu - check if we should try GPU recovery
   *
- * @adev: amdgpu_device pointer
+ * @adev: amdgpu device pointer
   *

* Check amdgpu_gpu_recovery and SRIOV status to see if we should try to
recover
* a hung GPU.

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -1
@@ -4355,7 +4055,7 @@ bool amdgpu_device_has_job_running(struct
 amdgpu_device *adev)
  bool amdgpu_device_should_recover_gpu(struct amdgpu_device *adev)
  {
  	if (!amdgpu_device_ip_check_soft_reset(adev)) {
-		dev_info(adev->dev, "Timeout, but no hardware hang
 detected.\n");
+		DRM_INFO("Timeout, but no hardware hang detected.\n");
  		return false;
  	}
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -6
@@ -4385,12 +4085,6 @@ bool amdgpu_device_should_recover_gpu(struct
 amdgpu_device *adev)
  		case CHIP_NAVI10:
  		case CHIP_NAVI14:
  		case CHIP_NAVI12:
-		case CHIP_SIENNA_CICHLID:
-		case CHIP_NAVY_FLOUNDER:
-		case CHIP_DIMGREY_CAVEFISH:
-		case CHIP_BEIGE_GOBY:
-		case CHIP_VANGOGH:
-		case CHIP_ALDEBARAN:
  			break;
  		default:

goto disabled;

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +8 -56
@@ -4400,69 +4094,21 @@ bool amdgpu_device_should_recover_gpu(struct
 amdgpu_device *adev)
  	return true;
 
  disabled:
-		dev_info(adev->dev, "GPU recovery disabled.\n");
+		DRM_INFO("GPU recovery disabled.\n");
  		return false;
  }
 
-int amdgpu_device_mode1_reset(struct amdgpu_device *adev)
-{
-        u32 i;
-        int ret = 0;
-
-        amdgpu_atombios_scratch_regs_engine_hung(adev, true);
-
-        dev_info(adev->dev, "GPU mode1 reset\n");
-
-        /* disable BM */
-        pci_clear_master(adev->pdev);
-
-        amdgpu_device_cache_pci_state(adev->pdev);
-
-        if (amdgpu_dpm_is_mode1_reset_supported(adev)) {
-                dev_info(adev->dev, "GPU smu mode1 reset\n");
-                ret = amdgpu_dpm_mode1_reset(adev);
-        } else {
-                dev_info(adev->dev, "GPU psp mode1 reset\n");
-                ret = psp_gpu_reset(adev);
-        }
-
-        if (ret)
-                dev_err(adev->dev, "GPU mode1 reset failed\n");
-
-        amdgpu_device_load_pci_state(adev->pdev);
-
-        /* wait for asic to come out of reset */
-        for (i = 0; i < adev->usec_timeout; i++) {
-                u32 memsize = adev->nbio.funcs->get_memsize(adev);
-
-                if (memsize != 0xffffffff)
-                        break;
-                udelay(1);
-        }
-
-        amdgpu_atombios_scratch_regs_engine_hung(adev, false);
-        return ret;
-}
 
-int amdgpu_device_pre_asic_reset(struct amdgpu_device *adev,
-				 struct amdgpu_reset_context *reset_context)
+static int amdgpu_device_pre_asic_reset(struct amdgpu_device *adev,
+					struct amdgpu_job *job,
+					bool *need_full_reset_arg)
  {
  	int i, r = 0;
-	struct amdgpu_job *job = NULL;
-	bool need_full_reset =
-		test_bit(AMDGPU_NEED_FULL_RESET, &reset_context->flags);
-
-	if (reset_context->reset_req_dev == adev)
-		job = reset_context->job;
+	bool need_full_reset  = *need_full_reset_arg;
 
-	/* no need to dump if device is not in good state during probe period
 */
-	if (!adev->gmc.xgmi.pending_reset)
-		amdgpu_debugfs_wait_dump(adev);
-
-	if (amdgpu_sriov_vf(adev)) {
-		/* stop the data exchange thread */
-		amdgpu_virt_fini_data_exchange(adev);
-	}
+	if (amdgpu_sriov_vf(adev))
+		if (!amdgpu_virt_notify_booked(adev, job))
+			amdgpu_virt_wait_dump(adev,
 MAX_SCHEDULE_TIMEOUT);

/* block all schedulers and reset given job's ring */ for (i = 0; i < AMDGPU_MAX_RINGS; ++i) {

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -8
@@ -4475,16 +4121,9 @@ int amdgpu_device_pre_asic_reset(struct
 amdgpu_device *adev,
  		amdgpu_fence_driver_force_completion(ring);
  	}
 
-	if (job && job->vm)
+	if (job)
  		drm_sched_increase_karma(&job->base);
 
-	r = amdgpu_reset_prepare_hwcontext(adev, reset_context);
-	/* If reset handler not implemented, continue; otherwise return */
-	if (r == -ENOSYS)
-		r = 0;
-	else
-		return r;
-
  	/* Don't suspend on bare metal if we are not going to HW reset the

ASIC */
if (!amdgpu_sriov_vf(adev)) {

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +10 -27
@@ -4496,69 +4135,52 @@ int amdgpu_device_pre_asic_reset(struct
 amdgpu_device *adev,
  			r = amdgpu_device_ip_soft_reset(adev);
  			amdgpu_device_ip_post_soft_reset(adev);
  			if (r || amdgpu_device_ip_check_soft_reset(adev)) {
-				dev_info(adev->dev, "soft reset failed, will
 fallback to full reset!\n");
+				DRM_INFO("soft reset failed, will fallback to
 full reset!\n");
  				need_full_reset = true;
  			}
  		}
 
  		if (need_full_reset)
  			r = amdgpu_device_ip_suspend(adev);
-		if (need_full_reset)
-			set_bit(AMDGPU_NEED_FULL_RESET, &reset_context-
 > flags);
-		else
-			clear_bit(AMDGPU_NEED_FULL_RESET,
-				  &reset_context->flags);
+
+		*need_full_reset_arg = need_full_reset;
  	}
 
  	return r;
  }
 
-int amdgpu_do_asic_reset(struct list_head *device_list_handle,
-			 struct amdgpu_reset_context *reset_context)
+static int amdgpu_do_asic_reset(struct amdgpu_hive_info *hive,
+			       struct list_head *device_list_handle,
+			       bool *need_full_reset_arg)
  {
  	struct amdgpu_device *tmp_adev = NULL;
-	bool need_full_reset, skip_hw_reset, vram_lost = false;
+	bool need_full_reset = *need_full_reset_arg, vram_lost = false;
  	int r = 0;
 
-	/* Try reset handler method first */
-	tmp_adev = list_first_entry(device_list_handle, struct amdgpu_device,
-				    reset_list);
-	r = amdgpu_reset_perform_reset(tmp_adev, reset_context);
-	/* If reset handler not implemented, continue; otherwise return */
-	if (r == -ENOSYS)
-		r = 0;
-	else
-		return r;
-
-	/* Reset handler not implemented, use the default method */
-	need_full_reset =
-		test_bit(AMDGPU_NEED_FULL_RESET, &reset_context->flags);
-	skip_hw_reset = test_bit(AMDGPU_SKIP_HW_RESET, &reset_context-
 > flags);
-
  	/*
-	 * ASIC reset has to be done on all XGMI hive nodes ASAP
+	 * ASIC reset has to be done on all HGMI hive nodes ASAP
  	 * to allow proper links negotiation in FW (within 1 sec)
  	 */
-	if (!skip_hw_reset && need_full_reset) {
-		list_for_each_entry(tmp_adev, device_list_handle, reset_list) {
+	if (need_full_reset) {
+		list_for_each_entry(tmp_adev, device_list_handle,
 gmc.xgmi.head) {
  			/* For XGMI run all resets in parallel to speed up the

process */
if (tmp_adev->gmc.xgmi.num_physical_nodes > 1) {

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -1
-				tmp_adev->gmc.xgmi.pending_reset = false;
  				if (!queue_work(system_unbound_wq,

&tmp_adev->xgmi_reset_work))
r = -EALREADY;
} else
r = amdgpu_asic_reset(tmp_adev);

  			if (r) {
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -1
-				dev_err(tmp_adev->dev, "ASIC reset failed

with error, %d for drm dev, %s",

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -1
-					 r, adev_to_drm(tmp_adev)->unique);
+				DRM_ERROR("ASIC reset failed with error, %d

for drm dev, %s",

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -1
+					 r, tmp_adev->ddev->unique);
  				break;
  			}
  		}
 
  		/* For XGMI wait for all resets to complete before proceed */
  		if (!r) {
-			list_for_each_entry(tmp_adev, device_list_handle,

reset_list) {

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -0
+			list_for_each_entry(tmp_adev, device_list_handle,
+					    gmc.xgmi.head) {
  				if (tmp_adev->gmc.xgmi.num_physical_nodes >

1) {
flush_work(&tmp_adev-

Quoted 1 line

xgmi_reset_work);

r = tmp_adev->asic_reset_res;

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +5 -8
@@ -4570,22 +4192,22 @@ int amdgpu_do_asic_reset(struct list_head
 *device_list_handle,
  	}
 
  	if (!r && amdgpu_ras_intr_triggered()) {
-		list_for_each_entry(tmp_adev, device_list_handle, reset_list) {
-			if (tmp_adev->mmhub.ras_funcs &&
-			    tmp_adev->mmhub.ras_funcs-
 > reset_ras_error_count)
-				tmp_adev->mmhub.ras_funcs-
 > reset_ras_error_count(tmp_adev);
+		list_for_each_entry(tmp_adev, device_list_handle,
 gmc.xgmi.head) {
+			if (tmp_adev->mmhub.funcs &&
+			    tmp_adev->mmhub.funcs->reset_ras_error_count)
+				tmp_adev->mmhub.funcs-
 > reset_ras_error_count(tmp_adev);
  		}
 
  		amdgpu_ras_intr_cleared();
  	}
 
-	list_for_each_entry(tmp_adev, device_list_handle, reset_list) {
+	list_for_each_entry(tmp_adev, device_list_handle, gmc.xgmi.head) {
  		if (need_full_reset) {
  			/* post card */
-			r = amdgpu_device_asic_init(tmp_adev);
-			if (r) {
-				dev_warn(tmp_adev->dev, "asic atom init

failed!");

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -1
-			} else {
+			if (amdgpu_atom_asic_init(tmp_adev-
Quoted 1 line

mode_info.atom_context))

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +3 -0
+				DRM_WARN("asic atom init failed!");
+
+			if (!r) {
  				dev_info(tmp_adev->dev, "GPU reset

succeeded, trying to resume\n");
r =
amdgpu_device_ip_resume_phase1(tmp_adev);
if (r)

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -1
@@ -4597,7 +4219,8 @@ int amdgpu_do_asic_reset(struct list_head
 *device_list_handle,
  					amdgpu_inc_vram_lost(tmp_adev);
  				}
 
-				r =
 amdgpu_gtt_mgr_recover(ttm_manager_type(&tmp_adev->mman.bdev,
 TTM_PL_TT));
+				r = amdgpu_gtt_mgr_recover(
+					&tmp_adev-
Quoted 1 line

mman.bdev.man[TTM_PL_TT]);

if (r)
goto out;

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -8
@@ -4618,48 +4241,29 @@ int amdgpu_do_asic_reset(struct list_head
 *device_list_handle,
  				 */
  				amdgpu_register_gpu_instance(tmp_adev);
 
-				if (!reset_context->hive &&
-				    tmp_adev->gmc.xgmi.num_physical_nodes >
 1)
-					amdgpu_xgmi_add_device(tmp_adev);
[… more lines in the raw message]

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

check

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -7

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

(!amdgpu_ras_eeprom_check_err_threshold(tmp_adev)) {

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -8

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

1)

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -2

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

tmp_adev);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -0

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

Quoted 1 line

gmc.xgmi.num_physical_nodes > 1)

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -0

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

amdgpu_xgmi_update_topology(hive, tmp_adev);
}
}

+
out:
if (!r) {
amdgpu_irq_gpu_reset_resume_helper(tmp_adev); r = amdgpu_ib_ring_tests(tmp_adev);
if (r) {
dev_err(tmp_adev->dev, "ib ring test failed
(%d).\n", r);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +9 -14

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

  	case AMD_RESET_METHOD_MODE1:
  		adev->mp1_state = PP_MP1_STATE_SHUTDOWN;
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +12 -109

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

the real one */
drm_sched_reset_karma(s_job);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -1

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

Quoted 1 line

sched.hw_submission_limit;

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +3 -0

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

ring->sched.timeout);
if (ret == 0) { /* timeout */

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -1

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

job_id:%llx\n",

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +4 -3

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

emitted seq=%u\n",

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -0

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

Quoted 1 line

fence_drv.last_seq),

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -0

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

thread %s pid %d\n",

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -7

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

device_list_handle, need_full_reset);
}

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +3 -5

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

job could flush vmid */
atomic_inc(&adev->gpu_reset_counter);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -13

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

original_hw_submission_limit;

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +6 -4

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

AMD_RESET_METHOD_BACO) ?

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -8

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

amdgpu_ras_need_emergency_restart(adev);

/*
* Flush RAM to disk so that after reboot
* the user can read log and see why the system rebooted. */

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -1

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

Quoted 1 line

reboot) {

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -0

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

Quoted 1 line

reboot) {

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +54 -42

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

the

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -0

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

reset

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +16 -25

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

goto skip_sched_resume;

/*

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +24 -7

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

  		if (r && r == -EAGAIN)
  			goto retry;
  	}
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -4

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

as gfx

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -1

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

an additional

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -1

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

synchronously

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -1

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

timeout,

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -4

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

Quoted 1 line

vram_lost_counter)))

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -2

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

&reset_context);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -0

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

Quoted 1 line

vram_lost_counter)) &&

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -0

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

device_list_handle, &need_full_reset);

  		for (i = 0; i < AMDGPU_MAX_RINGS; ++i) {
  			struct amdgpu_ring *ring = tmp_adev->rings[i];
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +2 -1

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

	drm_helper_resume_force_mode(adev_to_drm(tmp_adev));
drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +7 -21

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

CAIL_ASIC_PCIE_LINK_SPEED_SUPPORT_GEN2 |

CAIL_ASIC_PCIE_LINK_SPEED_SUPPORT_GEN3);
} else {

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -2

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

(CAIL_ASIC_PCIE_LINK_SPEED_SUPPORT_GEN1 | -
CAIL_ASIC_PCIE_LINK_SPEED_SUPPORT_GEN2 |
-
CAIL_ASIC_PCIE_LINK_SPEED_SUPPORT_GEN3 |
-
CAIL_ASIC_PCIE_LINK_SPEED_SUPPORT_GEN4 |
-
CAIL_ASIC_PCIE_LINK_SPEED_SUPPORT_GEN5);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -1

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

(CAIL_ASIC_PCIE_LINK_SPEED_SUPPORT_GEN1 |

CAIL_ASIC_PCIE_LINK_SPEED_SUPPORT_GEN2 |

CAIL_ASIC_PCIE_LINK_SPEED_SUPPORT_GEN3 |

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -0

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

(CAIL_PCIE_LINK_SPEED_SUPPORT_GEN1 |

CAIL_PCIE_LINK_SPEED_SUPPORT_GEN2);
} else {

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -2

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

(CAIL_PCIE_LINK_SPEED_SUPPORT_GEN1 |
-
CAIL_PCIE_LINK_SPEED_SUPPORT_GEN2 |
-
CAIL_PCIE_LINK_SPEED_SUPPORT_GEN3 |
-
CAIL_PCIE_LINK_SPEED_SUPPORT_GEN4 |
-
CAIL_PCIE_LINK_SPEED_SUPPORT_GEN5);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +1 -1

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

(CAIL_PCIE_LINK_SPEED_SUPPORT_GEN1 |

CAIL_PCIE_LINK_SPEED_SUPPORT_GEN2 |

CAIL_PCIE_LINK_SPEED_SUPPORT_GEN3 |

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +5 -0

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

@adev
+ *
+ * Return true if @peer_adev can access (DMA) @adev through the PCIe
+ * BAR, i.e. @adev is "large BAR" and the BAR matches the DMA mask of
+ * @peer_adev.
+ */

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +20 -37

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

pci_channel_state_t state)

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -136

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

PCI_ERS_RESULT_RECOVERED;

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +0 -106

Lines of this file are not shown. View the raw message.

The rest of this diff is not shown. View the raw message.

2.17.1

Part of the diff is not shown here. View the raw message.

#4 lore raw
In reply to Peng Ju Zhou

[AMD Official Use Only]

Merge error, Too big to drop

Quoted 2,392 lines

-----Original Message-----
From: Peng Ju Zhou <[email protected]>
Sent: Wednesday, August 4, 2021 10:15 AM
To: [email protected]
Cc: Nieto, David M <[email protected]>; Zhou, Peng Ju <[email protected]>
Subject: [PATCH] drm/amdgpu: add done BO list

From: David M Nieto <[email protected]>

backport of "add a list in VM for BOs in the done state"

---
 drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c | 1196 +++++++++++-------------
 1 file changed, 561 insertions(+), 635 deletions(-)
drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +0 -46
index 2a88ed5d983b..ecf7f2039de0 100644
@@ -25,22 +25,16 @@
  *          Alex Deucher
  *          Jerome Glisse
  */
-
 #include <linux/dma-fence-array.h>
 #include <linux/interval_tree_generic.h>
 #include <linux/idr.h>
-#include <linux/dma-buf.h>
 
 #include <drm/amdgpu_drm.h>
-#include <drm/drm_drv.h>
 #include "amdgpu.h"
 #include "amdgpu_trace.h"
 #include "amdgpu_amdkfd.h"
 #include "amdgpu_gmc.h"
 #include "amdgpu_xgmi.h"
-#include "amdgpu_dma_buf.h"
-#include "amdgpu_res_cursor.h"
-#include "kfd_svm.h"
 
 /**
  * DOC: GPUVM
@@ -89,46 +83,6 @@ struct amdgpu_prt_cb {
 };
 
 /**
- * amdgpu_vm_set_pasid - manage pasid and vm ptr mapping
- *
- * @adev: amdgpu_device pointer
- * @vm: amdgpu_vm pointer
- * @pasid: the pasid the VM is using on this GPU
- *
- * Set the pasid this VM is using on this GPU, can also be used to remove the
- * pasid by passing in zero.
- *
- */
-int amdgpu_vm_set_pasid(struct amdgpu_device *adev, struct amdgpu_vm
 *vm,
-			u32 pasid)
-{
-	int r;
-
-	if (vm->pasid == pasid)
-		return 0;
-
-	if (vm->pasid) {
-		r = xa_err(xa_erase_irq(&adev->vm_manager.pasids, vm-
 >pasid));
-		if (r < 0)
-			return r;
-
-		vm->pasid = 0;
-	}
-
-	if (pasid) {
-		r = xa_err(xa_store_irq(&adev->vm_manager.pasids, pasid, vm,
-					GFP_KERNEL));
-		if (r < 0)
-			return r;
-
-		vm->pasid = pasid;
-	}
-
-
-	return 0;
-}
-
-/*
  * vm eviction_lock can be taken in MMU notifiers. Make sure no reclaim-FS

* happens while holding this lock anywhere to prevent deadlocks when
* an MMU notifier runs in reclaim-FS context.

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +2 -2
@@ -136,13 +90,13 @@ int amdgpu_vm_set_pasid(struct amdgpu_device
 *adev, struct amdgpu_vm *vm,
 static inline void amdgpu_vm_eviction_lock(struct amdgpu_vm *vm)
 {
 	mutex_lock(&vm->eviction_lock);
-	vm->saved_flags = memalloc_noreclaim_save();
+	vm->saved_flags = memalloc_nofs_save();
 }
 
 static inline int amdgpu_vm_eviction_trylock(struct amdgpu_vm *vm)
 {
 	if (mutex_trylock(&vm->eviction_lock)) {
-		vm->saved_flags = memalloc_noreclaim_save();
+		vm->saved_flags = memalloc_nofs_save();
 		return 1;
 	}
drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +2 -2
 	return 0;
@@ -150,7 +104,7 @@ static inline int amdgpu_vm_eviction_trylock(struct
 amdgpu_vm *vm)
 
 static inline void amdgpu_vm_eviction_unlock(struct amdgpu_vm *vm)
 {
-	memalloc_noreclaim_restore(vm->saved_flags);
+	memalloc_nofs_restore(vm->saved_flags);
 	mutex_unlock(&vm->eviction_lock);
 }
@@ -372,7 +326,7 @@ static void amdgpu_vm_bo_base_init(struct
 amdgpu_vm_bo_base *base,
 	base->next = bo->vm_bo;
 	bo->vm_bo = base;
 
-	if (bo->tbo.base.resv != vm->root.bo->tbo.base.resv)
+	if (amdkcl_ttm_resvp(&bo->tbo) != amdkcl_ttm_resvp(&vm-
 >root.base.bo->tbo))
 		return;
drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +1 -1
 	vm->bulk_moveable = false;
@@ -382,7 +336,7 @@ static void amdgpu_vm_bo_base_init(struct
 amdgpu_vm_bo_base *base,
 		amdgpu_vm_bo_idle(base);
 
 	if (bo->preferred_domains &
-	    amdgpu_mem_type_to_domain(bo->tbo.resource->mem_type))
+	    amdgpu_mem_type_to_domain(bo->tbo.mem.mem_type))
 		return;
 
drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +3 -3
 	/*
@@ -401,14 +355,14 @@ static void amdgpu_vm_bo_base_init(struct
 amdgpu_vm_bo_base *base,
  * Helper to get the parent entry for the child page table. NULL if we are at
  * the root page directory.
  */
-static struct amdgpu_vm_bo_base *amdgpu_vm_pt_parent(struct
 amdgpu_vm_bo_base *pt)
+static struct amdgpu_vm_pt *amdgpu_vm_pt_parent(struct amdgpu_vm_pt
 *pt)
 {
-	struct amdgpu_bo *parent = pt->bo->parent;
+	struct amdgpu_bo *parent = pt->base.bo->parent;
 
 	if (!parent)
 		return NULL;
 
-	return parent->vm_bo;
+	return container_of(parent->vm_bo, struct amdgpu_vm_pt, base);

}

/*

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +6 -6
@@ -416,8 +370,8 @@ static struct amdgpu_vm_bo_base
 *amdgpu_vm_pt_parent(struct amdgpu_vm_bo_base *p
  */
 struct amdgpu_vm_pt_cursor {
 	uint64_t pfn;
-	struct amdgpu_vm_bo_base *parent;
-	struct amdgpu_vm_bo_base *entry;
+	struct amdgpu_vm_pt *parent;
+	struct amdgpu_vm_pt *entry;
 	unsigned level;
 };
@@ -456,17 +410,17 @@ static bool amdgpu_vm_pt_descendant(struct
 amdgpu_device *adev,
 {
 	unsigned mask, shift, idx;
 
-	if ((cursor->level == AMDGPU_VM_PTB) || !cursor->entry ||
-	    !cursor->entry->bo)
+	if (!cursor->entry->entries)
 		return false;
 
+	BUG_ON(!cursor->entry->base.bo);
 	mask = amdgpu_vm_entries_mask(adev, cursor->level);
 	shift = amdgpu_vm_level_shift(adev, cursor->level);
 
 	++cursor->level;
 	idx = (cursor->pfn >> shift) & mask;
 	cursor->parent = cursor->entry;
-	cursor->entry = &to_amdgpu_bo_vm(cursor->entry->bo)->entries[idx];
+	cursor->entry = &cursor->entry->entries[idx];
 	return true;
 }
@@ -493,7 +447,7 @@ static bool amdgpu_vm_pt_sibling(struct
 amdgpu_device *adev,
 	shift = amdgpu_vm_level_shift(adev, cursor->level - 1);
 	num_entries = amdgpu_vm_num_entries(adev, cursor->level - 1);
 
-	if (cursor->entry == &to_amdgpu_bo_vm(cursor->parent->bo)-
 >entries[num_entries - 1])
+	if (cursor->entry == &cursor->parent->entries[num_entries - 1])
 		return false;
drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +1 -1
 	cursor->pfn += 1ULL << shift;
@@ -579,7 +533,7 @@ static void amdgpu_vm_pt_first_dfs(struct
 amdgpu_device *adev,
  * True when the search should continue, false otherwise.
  */
 static bool amdgpu_vm_pt_continue_dfs(struct amdgpu_vm_pt_cursor *start,
-				      struct amdgpu_vm_bo_base *entry)
+				      struct amdgpu_vm_pt *entry)
 {
 	return entry && (!start || entry != start->entry);

}

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +2 -2
@@ -630,7 +584,7 @@ void amdgpu_vm_get_pd_bo(struct amdgpu_vm *vm,
 			 struct amdgpu_bo_list_entry *entry)
 {
 	entry->priority = 0;
-	entry->tv.bo = &vm->root.bo->tbo;
+	entry->tv.bo = &vm->root.base.bo->tbo;
 	/* Two for VM updates, one for TTM and one for the CS job */
 	entry->tv.num_shared = 4;
 	entry->user_pages = NULL;
@@ -653,7 +607,7 @@ void amdgpu_vm_del_from_lru_notify(struct
 ttm_buffer_object *bo)
 	if (!amdgpu_bo_is_amdgpu_bo(bo))
 		return;
 
-	if (bo->pin_count)
+	if (bo->mem.placement & TTM_PL_FLAG_NO_EVICT)
 		return;
 
drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +1 -1
 	abo = ttm_to_amdgpu_bo(bo);
@@ -662,7 +616,7 @@ void amdgpu_vm_del_from_lru_notify(struct
 ttm_buffer_object *bo)
 	for (bo_base = abo->vm_bo; bo_base; bo_base = bo_base->next) {
 		struct amdgpu_vm *vm = bo_base->vm;
 
-		if (abo->tbo.base.resv == vm->root.bo->tbo.base.resv)
+		if (amdkcl_ttm_resvp(&abo->tbo) == amdkcl_ttm_resvp(&vm-
 >root.base.bo->tbo))
 			vm->bulk_moveable = false;
drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +7 -10
 	}
@@ -682,30 +636,27 @@ void amdgpu_vm_move_to_lru_tail(struct
 amdgpu_device *adev,
 	struct amdgpu_vm_bo_base *bo_base;
 
 	if (vm->bulk_moveable) {
-		spin_lock(&adev->mman.bdev.lru_lock);
+		spin_lock(&ttm_bo_glob.lru_lock);
 		ttm_bo_bulk_move_lru_tail(&vm->lru_bulk_move);
-		spin_unlock(&adev->mman.bdev.lru_lock);
+		spin_unlock(&ttm_bo_glob.lru_lock);
 		return;
 	}
 
 	memset(&vm->lru_bulk_move, 0, sizeof(vm->lru_bulk_move));
 
-	spin_lock(&adev->mman.bdev.lru_lock);
+	spin_lock(&ttm_bo_glob.lru_lock);
 	list_for_each_entry(bo_base, &vm->idle, vm_status) {
 		struct amdgpu_bo *bo = bo_base->bo;
-		struct amdgpu_bo *shadow = amdgpu_bo_shadowed(bo);
 
 		if (!bo->parent)
 			continue;
 
-		ttm_bo_move_to_lru_tail(&bo->tbo, bo->tbo.resource,
-					&vm->lru_bulk_move);
-		if (shadow)
-			ttm_bo_move_to_lru_tail(&shadow->tbo,
-						shadow->tbo.resource,
+		ttm_bo_move_to_lru_tail(&bo->tbo, &vm->lru_bulk_move);
+		if (bo->shadow)
+			ttm_bo_move_to_lru_tail(&bo->shadow->tbo,
 						&vm->lru_bulk_move);
 	}
-	spin_unlock(&adev->mman.bdev.lru_lock);
+	spin_unlock(&ttm_bo_glob.lru_lock);
 
 	vm->bulk_moveable = true;

}

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +1 -7
@@ -734,21 +685,15 @@ int amdgpu_vm_validate_pt_bos(struct
 amdgpu_device *adev, struct amdgpu_vm *vm,
 
 	list_for_each_entry_safe(bo_base, tmp, &vm->evicted, vm_status) {
 		struct amdgpu_bo *bo = bo_base->bo;
-		struct amdgpu_bo *shadow = amdgpu_bo_shadowed(bo);
 
 		r = validate(param, bo);
 		if (r)
 			return r;
-		if (shadow) {
-			r = validate(param, shadow);
-			if (r)
-				return r;
-		}
 
 		if (bo->tbo.type != ttm_bo_type_kernel) {
 			amdgpu_vm_bo_moved(bo_base);
 		} else {
-			vm->update_funcs-
 >map_table(to_amdgpu_bo_vm(bo));
+			vm->update_funcs->map_table(bo);
 			amdgpu_vm_bo_relocated(bo_base);
drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +8 -9
 		}
 	}
@@ -780,8 +725,8 @@ bool amdgpu_vm_ready(struct amdgpu_vm *vm)
  *
  * @adev: amdgpu_device pointer
  * @vm: VM to clear BO from
- * @vmbo: BO to clear
- * @immediate: use an immediate update
+ * @bo: BO to clear
+ * @direct: use a direct update
  *
  * Root PD needs to be reserved when calling this.
  *
@@ -790,14 +735,13 @@ bool amdgpu_vm_ready(struct amdgpu_vm *vm)
  */
 static int amdgpu_vm_clear_bo(struct amdgpu_device *adev,
 			      struct amdgpu_vm *vm,
-			      struct amdgpu_bo_vm *vmbo,
-			      bool immediate)
+			      struct amdgpu_bo *bo,
+			      bool direct)
 {
 	struct ttm_operation_ctx ctx = { true, false };
 	unsigned level = adev->vm_manager.root_level;
 	struct amdgpu_vm_update_params params;
-	struct amdgpu_bo *ancestor = &vmbo->bo;
-	struct amdgpu_bo *bo = &vmbo->bo;
+	struct amdgpu_bo *ancestor = bo;
 	unsigned entries, ats_entries;
 	uint64_t addr;
 	int r;
@@ -821,11 +765,11 @@ static int amdgpu_vm_clear_bo(struct
 amdgpu_device *adev,
 		entries -= ats_entries;
 
 	} else {
-		struct amdgpu_vm_bo_base *pt;
+		struct amdgpu_vm_pt *pt;
 
-		pt = ancestor->vm_bo;
+		pt = container_of(ancestor->vm_bo, struct amdgpu_vm_pt,
 base);
 		ats_entries = amdgpu_vm_num_ats_entries(adev);
-		if ((pt - to_amdgpu_bo_vm(vm->root.bo)->entries) >=
 ats_entries) {
+		if ((pt - vm->root.entries) >= ats_entries) {
drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +5 -6
 			ats_entries = 0;
 		} else {
 			ats_entries = entries;
@@ -837,22 +781,21 @@ static int amdgpu_vm_clear_bo(struct
 amdgpu_device *adev,
 	if (r)
 		return r;
 
-	if (vmbo->shadow) {
-		struct amdgpu_bo *shadow = vmbo->shadow;
-
-		r = ttm_bo_validate(&shadow->tbo, &shadow->placement,
 &ctx);
+	if (bo->shadow) {
+		r = ttm_bo_validate(&bo->shadow->tbo, &bo->shadow-
 >placement,
+				    &ctx);
 		if (r)
 			return r;
 	}
 
-	r = vm->update_funcs->map_table(vmbo);
+	r = vm->update_funcs->map_table(bo);
 	if (r)
 		return r;
 
 	memset(&params, 0, sizeof(params));
 	params.adev = adev;
 	params.vm = vm;
-	params.immediate = immediate;
+	params.direct = direct;

r = vm->update_funcs->prepare(&params, NULL,
AMDGPU_SYNC_EXPLICIT);

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +1 -1
 	if (r)
@@ -869,7 +812,7 @@ static int amdgpu_vm_clear_bo(struct amdgpu_device
 *adev,
 			amdgpu_gmc_get_vm_pde(adev, level, &value,
 &flags);
 		}
 
-		r = vm->update_funcs->update(&params, vmbo, addr, 0,
 ats_entries,
+		r = vm->update_funcs->update(&params, bo, addr, 0,

ats_entries,

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +1 -1
 					     value, flags);
 		if (r)
 			return r;
@@ -892,7 +835,7 @@ static int amdgpu_vm_clear_bo(struct amdgpu_device
 *adev,
 			}
 		}
 
-		r = vm->update_funcs->update(&params, vmbo, addr, 0,
 entries,
+		r = vm->update_funcs->update(&params, bo, addr, 0, entries,
 					     value, flags);
drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +20 -71
 		if (r)
 			return r;
@@ -902,85 +845,34 @@ static int amdgpu_vm_clear_bo(struct
 amdgpu_device *adev,
 }
 
 /**
- * amdgpu_vm_pt_create - create bo for PD/PT
+ * amdgpu_vm_bo_param - fill in parameters for PD/PT allocation
  *
  * @adev: amdgpu_device pointer
  * @vm: requesting vm
  * @level: the page table level
- * @immediate: use a immediate update
- * @vmbo: pointer to the buffer object pointer
+ * @direct: use a direct update
+ * @bp: resulting BO allocation parameters
  */
-static int amdgpu_vm_pt_create(struct amdgpu_device *adev,
-			       struct amdgpu_vm *vm,
-			       int level, bool immediate,
-			       struct amdgpu_bo_vm **vmbo)
+static void amdgpu_vm_bo_param(struct amdgpu_device *adev, struct
 amdgpu_vm *vm,
+			       int level, bool direct,
+			       struct amdgpu_bo_param *bp)
 {
-	struct amdgpu_bo_param bp;
-	struct amdgpu_bo *bo;
-	struct dma_resv *resv;
-	unsigned int num_entries;
-	int r;
-
-	memset(&bp, 0, sizeof(bp));
+	memset(bp, 0, sizeof(*bp));
 
-	bp.size = amdgpu_vm_bo_size(adev, level);
-	bp.byte_align = AMDGPU_GPU_PAGE_SIZE;
-	bp.domain = AMDGPU_GEM_DOMAIN_VRAM;
-	bp.domain = amdgpu_bo_get_preferred_pin_domain(adev,
 bp.domain);
-	bp.flags = AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS |
+	bp->size = amdgpu_vm_bo_size(adev, level);
+	bp->byte_align = AMDGPU_GPU_PAGE_SIZE;
+	bp->domain = AMDGPU_GEM_DOMAIN_VRAM;
+	bp->domain = amdgpu_bo_get_preferred_pin_domain(adev, bp-
 >domain);
+	bp->flags = AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS |
 		AMDGPU_GEM_CREATE_CPU_GTT_USWC;
-
-	if (level < AMDGPU_VM_PTB)
-		num_entries = amdgpu_vm_num_entries(adev, level);
-	else
-		num_entries = 0;
-
-	bp.bo_ptr_size = struct_size((*vmbo), entries, num_entries);
-
 	if (vm->use_cpu_for_update)
-		bp.flags |= AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED;
-
-	bp.type = ttm_bo_type_kernel;
-	bp.no_wait_gpu = immediate;
-	if (vm->root.bo)
-		bp.resv = vm->root.bo->tbo.base.resv;
-
-	r = amdgpu_bo_create_vm(adev, &bp, vmbo);
-	if (r)
-		return r;
-
-	bo = &(*vmbo)->bo;
-	if (vm->is_compute_context || (adev->flags & AMD_IS_APU)) {
-		(*vmbo)->shadow = NULL;
-		return 0;
-	}
-
-	if (!bp.resv)
-		WARN_ON(dma_resv_lock(bo->tbo.base.resv,
-				      NULL));
-	resv = bp.resv;
-	memset(&bp, 0, sizeof(bp));
-	bp.size = amdgpu_vm_bo_size(adev, level);
-	bp.domain = AMDGPU_GEM_DOMAIN_GTT;
-	bp.flags = AMDGPU_GEM_CREATE_CPU_GTT_USWC;
-	bp.type = ttm_bo_type_kernel;
-	bp.resv = bo->tbo.base.resv;
-	bp.bo_ptr_size = sizeof(struct amdgpu_bo);
-
-	r = amdgpu_bo_create(adev, &bp, &(*vmbo)->shadow);
-
-	if (!resv)
-		dma_resv_unlock(bo->tbo.base.resv);
-
-	if (r) {
-		amdgpu_bo_unref(&bo);
-		return r;
-	}
-
-	(*vmbo)->shadow->parent = amdgpu_bo_ref(bo);
-	amdgpu_bo_add_to_shadow_list(*vmbo);
-
-	return 0;
+		bp->flags |= AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED;
+	else if (!vm->root.base.bo || vm->root.base.bo->shadow)
+		bp->flags |= AMDGPU_GEM_CREATE_SHADOW;
+	bp->type = ttm_bo_type_kernel;
+	bp->no_wait_gpu = direct;
+	if (vm->root.base.bo)
+		bp->resv = amdkcl_ttm_resvp(&vm->root.base.bo->tbo);
 }
 
 /**
@@ -989,7 +881,7 @@ static int amdgpu_vm_pt_create(struct amdgpu_device
 *adev,
  * @adev: amdgpu_device pointer
  * @vm: VM to allocate page tables for
  * @cursor: Which page table to allocate
- * @immediate: use an immediate update
+ * @direct: use a direct update
  *
  * Make sure a specific page table or directory is allocated.

*

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +33 -21
@@ -1000,27 +892,40 @@ static int amdgpu_vm_pt_create(struct
 amdgpu_device *adev,
 static int amdgpu_vm_alloc_pts(struct amdgpu_device *adev,
 			       struct amdgpu_vm *vm,
 			       struct amdgpu_vm_pt_cursor *cursor,
-			       bool immediate)
+			       bool direct)
 {
-	struct amdgpu_vm_bo_base *entry = cursor->entry;
-	struct amdgpu_bo *pt_bo;
-	struct amdgpu_bo_vm *pt;
+	struct amdgpu_vm_pt *entry = cursor->entry;
+	struct amdgpu_bo_param bp;
+	struct amdgpu_bo *pt;
 	int r;
 
-	if (entry->bo)
+	if (cursor->level < AMDGPU_VM_PTB && !entry->entries) {
+		unsigned num_entries;
+
+		num_entries = amdgpu_vm_num_entries(adev, cursor->level);
+		entry->entries = kvmalloc_array(num_entries,
+						sizeof(*entry->entries),
+						GFP_KERNEL | __GFP_ZERO);
+		if (!entry->entries)
+			return -ENOMEM;
+	}
+
+	if (entry->base.bo)
 		return 0;
 
-	r = amdgpu_vm_pt_create(adev, vm, cursor->level, immediate, &pt);
+	amdgpu_vm_bo_param(adev, vm, cursor->level, direct, &bp);
+
+	r = amdgpu_bo_create(adev, &bp, &pt);
 	if (r)
 		return r;
 
 	/* Keep a reference to the root directory to avoid
 	 * freeing them up in the wrong order.
 	 */
-	pt_bo = &pt->bo;
-	pt_bo->parent = amdgpu_bo_ref(cursor->parent->bo);
-	amdgpu_vm_bo_base_init(entry, vm, pt_bo);
-	r = amdgpu_vm_clear_bo(adev, vm, pt, immediate);
+	pt->parent = amdgpu_bo_ref(cursor->parent->base.bo);
+	amdgpu_vm_bo_base_init(&entry->base, vm, pt);
+
+	r = amdgpu_vm_clear_bo(adev, vm, pt, direct);
 	if (r)
 		goto error_free_pt;
@@ -1028,7 +933,7 @@ static int amdgpu_vm_alloc_pts(struct
 amdgpu_device *adev,
 
 error_free_pt:
 	amdgpu_bo_unref(&pt->shadow);
-	amdgpu_bo_unref(&pt_bo);
+	amdgpu_bo_unref(&pt);
 	return r;
 }
@@ -1037,17 +942,16 @@ static int amdgpu_vm_alloc_pts(struct
 amdgpu_device *adev,
  *
  * @entry: PDE to free
  */
-static void amdgpu_vm_free_table(struct amdgpu_vm_bo_base *entry)
+static void amdgpu_vm_free_table(struct amdgpu_vm_pt *entry)
 {
-	struct amdgpu_bo *shadow;
-
-	if (!entry->bo)
-		return;
-	shadow = amdgpu_bo_shadowed(entry->bo);
-	entry->bo->vm_bo = NULL;
-	list_del(&entry->vm_status);
-	amdgpu_bo_unref(&shadow);
-	amdgpu_bo_unref(&entry->bo);
+	if (entry->base.bo) {
+		entry->base.bo->vm_bo = NULL;
+		list_del(&entry->base.vm_status);
+		amdgpu_bo_unref(&entry->base.bo->shadow);
+		amdgpu_bo_unref(&entry->base.bo);
+	}
+	kvfree(entry->entries);
+	entry->entries = NULL;
 }
 

/**

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +4 -4
@@ -1064,7 +968,7 @@ static void amdgpu_vm_free_pts(struct
 amdgpu_device *adev,
 			       struct amdgpu_vm_pt_cursor *start)
 {
 	struct amdgpu_vm_pt_cursor cursor;
-	struct amdgpu_vm_bo_base *entry;
+	struct amdgpu_vm_pt *entry;
 
 	vm->bulk_moveable = false;
@@ -1332,10 +1236,10 @@ uint64_t amdgpu_vm_map_gart(const
 dma_addr_t *pages_addr, uint64_t addr)
  */
 static int amdgpu_vm_update_pde(struct amdgpu_vm_update_params
 *params,
 				struct amdgpu_vm *vm,
-				struct amdgpu_vm_bo_base *entry)
+				struct amdgpu_vm_pt *entry)
 {
-	struct amdgpu_vm_bo_base *parent = amdgpu_vm_pt_parent(entry);
-	struct amdgpu_bo *bo = parent->bo, *pbo;
+	struct amdgpu_vm_pt *parent = amdgpu_vm_pt_parent(entry);
+	struct amdgpu_bo *bo = parent->base.bo, *pbo;
 	uint64_t pde, pt, flags;
drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +3 -4
 	unsigned level;
@@ -1343,10 +1247,9 @@ static int amdgpu_vm_update_pde(struct
 amdgpu_vm_update_params *params,
 		pbo = pbo->parent;
 
 	level += params->adev->vm_manager.root_level;
-	amdgpu_gmc_get_pde_for_bo(entry->bo, level, &pt, &flags);
-	pde = (entry - to_amdgpu_bo_vm(parent->bo)->entries) * 8;
-	return vm->update_funcs->update(params, to_amdgpu_bo_vm(bo),
 pde, pt,
-					1, 0, flags);
+	amdgpu_gmc_get_pde_for_bo(entry->base.bo, level, &pt, &flags);
+	pde = (entry - parent->entries) * 8;
+	return vm->update_funcs->update(params, bo, pde, pt, 1, 0, flags);
 }

/**

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +3 -3
@@ -1361,11 +1264,11 @@ static void amdgpu_vm_invalidate_pds(struct
 amdgpu_device *adev,
 				     struct amdgpu_vm *vm)
 {
 	struct amdgpu_vm_pt_cursor cursor;
-	struct amdgpu_vm_bo_base *entry;
+	struct amdgpu_vm_pt *entry;
 
 	for_each_amdgpu_vm_pt_dfs_safe(adev, vm, NULL, cursor, entry)
-		if (entry->bo && !entry->moved)
-			amdgpu_vm_bo_relocated(entry);
+		if (entry->base.bo && !entry->base.moved)
+			amdgpu_vm_bo_relocated(&entry->base);
 }
 

/**

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +1 -1
@@ -1373,7 +1276,7 @@ static void amdgpu_vm_invalidate_pds(struct
 amdgpu_device *adev,
  *
  * @adev: amdgpu_device pointer
  * @vm: requested vm
- * @immediate: submit immediately to the paging queue
+ * @direct: submit directly to the paging queue
  *
  * Makes sure all directories are up to date.

*

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +1 -1
@@ -1381,7 +1284,7 @@ static void amdgpu_vm_invalidate_pds(struct
 amdgpu_device *adev,
  * 0 for success, error for failure.
  */
 int amdgpu_vm_update_pdes(struct amdgpu_device *adev,
-			  struct amdgpu_vm *vm, bool immediate)
+			  struct amdgpu_vm *vm, bool direct)
 {
 	struct amdgpu_vm_update_params params;
drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +5 -6
 	int r;
@@ -1392,19 +1295,18 @@ int amdgpu_vm_update_pdes(struct
 amdgpu_device *adev,
 	memset(&params, 0, sizeof(params));
 	params.adev = adev;
 	params.vm = vm;
-	params.immediate = immediate;
+	params.direct = direct;
 
 	r = vm->update_funcs->prepare(&params, NULL,
 AMDGPU_SYNC_EXPLICIT);
 	if (r)
 		return r;
 
 	while (!list_empty(&vm->relocated)) {
-		struct amdgpu_vm_bo_base *entry;
+		struct amdgpu_vm_pt *entry;
 
-		entry = list_first_entry(&vm->relocated,
-					 struct amdgpu_vm_bo_base,
-					 vm_status);
-		amdgpu_vm_bo_idle(entry);
+		entry = list_first_entry(&vm->relocated, struct amdgpu_vm_pt,
+					 base.vm_status);
+		amdgpu_vm_bo_idle(&entry->base);
 
drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +2 -2
 		r = amdgpu_vm_update_pde(&params, vm, entry);
 		if (r)
@@ -1427,9 +1329,9 @@ int amdgpu_vm_update_pdes(struct amdgpu_device
 *adev,
  * Make sure to set the right flags for the PTEs at the desired level.
  */
 static void amdgpu_vm_update_flags(struct amdgpu_vm_update_params
 *params,
-				   struct amdgpu_bo_vm *pt, unsigned int
 level,
+				   struct amdgpu_bo *bo, unsigned level,
 				   uint64_t pe, uint64_t addr,
-				   unsigned int count, uint32_t incr,
+				   unsigned count, uint32_t incr,
drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +5 -9
 				   uint64_t flags)
 
 {
@@ -1445,7 +1347,7 @@ static void amdgpu_vm_update_flags(struct
 amdgpu_vm_update_params *params,
 		flags |= AMDGPU_PTE_EXECUTABLE;
 	}
 
-	params->vm->update_funcs->update(params, pt, pe, addr, count, incr,
+	params->vm->update_funcs->update(params, bo, pe, addr, count, incr,
 					 flags);
 }
@@ -1544,24 +1446,20 @@ static int amdgpu_vm_update_ptes(struct
 amdgpu_vm_update_params *params,
 		uint64_t incr, entry_end, pe_start;
 		struct amdgpu_bo *pt;
 
-		if (!params->unlocked) {
+		if (flags & (AMDGPU_PTE_VALID | AMDGPU_PTE_PRT)) {
 			/* make sure that the page tables covering the
 			 * address range are actually allocated
 			 */
 			r = amdgpu_vm_alloc_pts(params->adev, params->vm,
-						&cursor, params->immediate);
+						&cursor, params->direct);
 			if (r)
 				return r;
 		}
 
 		shift = amdgpu_vm_level_shift(adev, cursor.level);
 		parent_shift = amdgpu_vm_level_shift(adev, cursor.level - 1);
-		if (params->unlocked) {
-			/* Unlocked updates are only allowed on the leaves */
-			if (amdgpu_vm_pt_descendant(adev, &cursor))
-				continue;
-		} else if (adev->asic_type < CHIP_VEGA10 &&
-			   (flags & AMDGPU_PTE_VALID)) {
+		if (adev->asic_type < CHIP_VEGA10 &&
+		    (flags & AMDGPU_PTE_VALID)) {
 			/* No huge page support before GMC v9 */
 			if (cursor.level != AMDGPU_VM_PTB) {

if (!amdgpu_vm_pt_descendant(adev,
&cursor))

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +1 -1
@@ -1584,7 +1482,7 @@ static int amdgpu_vm_update_ptes(struct
 amdgpu_vm_update_params *params,
 			continue;
 		}
 
-		pt = cursor.entry->bo;
+		pt = cursor.entry->base.bo;
 		if (!pt) {
 			/* We need all PDs and PTs for mapping something, */
drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +1 -3
 			if (flags & AMDGPU_PTE_VALID)
@@ -1596,10 +1494,8 @@ static int amdgpu_vm_update_ptes(struct
 amdgpu_vm_update_params *params,
 			if (!amdgpu_vm_pt_ancestor(&cursor))
 				return -EINVAL;
 
-			pt = cursor.entry->bo;
+			pt = cursor.entry->base.bo;
 			shift = parent_shift;
-			frag_end = max(frag_end, ALIGN(frag_start + 1,
-				   1ULL << shift));
 		}
 
drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +4 -11
 		/* Looks good so far, calculate parameters for the update */
@@ -1611,26 +1507,19 @@ static int amdgpu_vm_update_ptes(struct
 amdgpu_vm_update_params *params,
 		entry_end = min(entry_end, end);
 
 		do {
-			struct amdgpu_vm *vm = params->vm;
 			uint64_t upd_end = min(entry_end, frag_end);
 			unsigned nptes = (upd_end - frag_start) >> shift;
-			uint64_t upd_flags = flags | AMDGPU_PTE_FRAG(frag);
 
 			/* This can happen when we set higher level PDs to
 			 * silent to stop fault floods.
 			 */
 			nptes = max(nptes, 1u);
-
-			trace_amdgpu_vm_update_ptes(params, frag_start,
 upd_end,
-						    nptes, dst, incr, upd_flags,
-						    vm->task_info.pid,
-						    vm-
 >immediate.fence_context);
-			amdgpu_vm_update_flags(params,
 to_amdgpu_bo_vm(pt),
-					       cursor.level, pe_start, dst,
-					       nptes, incr, upd_flags);
+			amdgpu_vm_update_flags(params, pt, cursor.level,
+					       pe_start, dst, nptes, incr,
+					       flags | AMDGPU_PTE_FRAG(frag));
 
 			pe_start += nptes * 8;
-			dst += nptes * incr;
+			dst += (uint64_t)nptes * AMDGPU_GPU_PAGE_SIZE <<

shift;

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +0 -0
 			frag_start = upd_end;
 			if (frag_start >= frag_end) {
@@ -1650,11 +1539,7 @@ static int amdgpu_vm_update_ptes(struct
 amdgpu_vm_update_params *params,
 			 * completely covered by the range and so potentially

still in use.

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +0 -4
 			 */
 			while (cursor.pfn < frag_start) {
-				/* Make sure previous mapping is freed */
-				if (cursor.entry->bo) {
-					params->table_freed = true;
-					amdgpu_vm_free_pts(adev, params-
Quoted 1 line

vm, &cursor);

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +1 -1
-				}
+				amdgpu_vm_free_pts(adev, params->vm,

&cursor);

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +12 -24
 				amdgpu_vm_pt_next(adev, &cursor);
 			}
@@ -1670,51 +1555,39 @@ static int amdgpu_vm_update_ptes(struct
 amdgpu_vm_update_params *params,
 /**
  * amdgpu_vm_bo_update_mapping - update a mapping in the vm page table
  *
- * @adev: amdgpu_device pointer of the VM
- * @bo_adev: amdgpu_device pointer of the mapped BO
+ * @adev: amdgpu_device pointer
  * @vm: requested vm
- * @immediate: immediate submission in a page fault
- * @unlocked: unlocked invalidation during MM callback
+ * @direct: direct submission in a page fault
  * @resv: fences we need to sync to
  * @start: start of mapped range
  * @last: last mapped entry
  * @flags: flags for the entries
- * @offset: offset into nodes and pages_addr
- * @res: ttm_resource to map
+ * @addr: addr to set the area to
  * @pages_addr: DMA addresses to use for mapping
  * @fence: optional resulting fence
- * @table_freed: return true if page table is freed
  *
  * Fill in the page table entries between @start and @last.
  *
  * Returns:
  * 0 for success, -EINVAL for failure.
  */
-int amdgpu_vm_bo_update_mapping(struct amdgpu_device *adev,
-				struct amdgpu_device *bo_adev,
-				struct amdgpu_vm *vm, bool immediate,
-				bool unlocked, struct dma_resv *resv,
-				uint64_t start, uint64_t last,
-				uint64_t flags, uint64_t offset,
-				struct ttm_resource *res,
-				dma_addr_t *pages_addr,
-				struct dma_fence **fence,
-				bool *table_freed)
+static int amdgpu_vm_bo_update_mapping(struct amdgpu_device *adev,
+				       struct amdgpu_vm *vm, bool direct,
+				       struct dma_resv *resv,
+				       uint64_t start, uint64_t last,
+				       uint64_t flags, uint64_t addr,
+				       dma_addr_t *pages_addr,
+				       struct dma_fence **fence)
 {
 	struct amdgpu_vm_update_params params;
-	struct amdgpu_res_cursor cursor;
 	enum amdgpu_sync_mode sync_mode;
-	int r, idx;
-
-	if (!drm_dev_enter(&adev->ddev, &idx))
-		return -ENODEV;
+	int r;
 
 	memset(&params, 0, sizeof(params));
 	params.adev = adev;
 	params.vm = vm;
-	params.immediate = immediate;
+	params.direct = direct;
 	params.pages_addr = pages_addr;
-	params.unlocked = unlocked;
 
 	/* Implicitly sync to command submissions in the same VM before
drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +49 -15
 	 * unmapping. Sync to moving fences before mapping.
@@ -1730,133 +1603,178 @@ int amdgpu_vm_bo_update_mapping(struct
 amdgpu_device *adev,
 		goto error_unlock;
 	}
 
-	if (!unlocked && !dma_fence_is_signaled(vm->last_unlocked)) {
-		struct dma_fence *tmp = dma_fence_get_stub();
+	if (flags & (AMDGPU_PTE_VALID | AMDGPU_PTE_PRT)) {
+		struct amdgpu_bo *root = vm->root.base.bo;
 
-		amdgpu_bo_fence(vm->root.bo, vm->last_unlocked, true);
-		swap(vm->last_unlocked, tmp);
-		dma_fence_put(tmp);
+		if (!dma_fence_is_signaled(vm->last_direct))
+			amdgpu_bo_fence(root, vm->last_direct, true);
 	}
 
 	r = vm->update_funcs->prepare(&params, resv, sync_mode);
 	if (r)
 		goto error_unlock;
 
-	amdgpu_res_first(pages_addr ? NULL : res, offset,
-			 (last - start + 1) * AMDGPU_GPU_PAGE_SIZE, &cursor);
-	while (cursor.remaining) {
-		uint64_t tmp, num_entries, addr;
+	r = amdgpu_vm_update_ptes(&params, start, last + 1, addr, flags);
+	if (r)
+		goto error_unlock;
+
+	r = vm->update_funcs->commit(&params, fence);
+
+error_unlock:
+	amdgpu_vm_eviction_unlock(vm);
+	return r;
+}
 
-		num_entries = cursor.size >> AMDGPU_GPU_PAGE_SHIFT;
-		if (pages_addr) {
-			bool contiguous = true;
+/**
+ * amdgpu_vm_bo_split_mapping - split a mapping into smaller chunks
+ *
+ * @adev: amdgpu_device pointer
+ * @resv: fences we need to sync to
+ * @pages_addr: DMA addresses to use for mapping
+ * @vm: requested vm
+ * @mapping: mapped range and flags to use for the update
+ * @flags: HW flags for the mapping
+ * @bo_adev: amdgpu_device pointer that bo actually been allocated
+ * @nodes: array of drm_mm_nodes with the MC addresses
+ * @fence: optional resulting fence
+ *
+ * Split the mapping into smaller chunks so that each update fits
+ * into a SDMA IB.
+ *
+ * Returns:
+ * 0 for success, -EINVAL for failure.
+ */
+static int amdgpu_vm_bo_split_mapping(struct amdgpu_device *adev,
+				      struct dma_resv *resv,
+				      dma_addr_t *pages_addr,
+				      struct amdgpu_vm *vm,
+				      struct amdgpu_bo_va_mapping *mapping,
+				      uint64_t flags,
+				      struct amdgpu_device *bo_adev,
+				      struct ttm_mem_reg *mem,
+				      struct dma_fence **fence)
+{
+	struct drm_mm_node *nodes = mem ? mem->mm_node : NULL;
+	uint64_t vram_base_offset = bo_adev-
 >vm_manager.vram_base_offset;
+	unsigned min_linear_pages = 1 << adev->vm_manager.fragment_size;
+	uint64_t pfn, start = mapping->start;
+	int r;
 
-			if (num_entries >
 AMDGPU_GPU_PAGES_IN_CPU_PAGE) {
-				uint64_t pfn = cursor.start >> PAGE_SHIFT;
-				uint64_t count;
+	/* normally,bo_va->flags only contians READABLE and WIRTEABLE bit

go here

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +18 -0
+	 * but in case of something, we filter the flags in first place
+	 */
+	if (!(mapping->flags & AMDGPU_PTE_READABLE))
+		flags &= ~AMDGPU_PTE_READABLE;
+	if (!(mapping->flags & AMDGPU_PTE_WRITEABLE))
+		flags &= ~AMDGPU_PTE_WRITEABLE;
+
+	/* Apply ASIC specific mapping flags */
+	amdgpu_gmc_get_vm_pte(adev, mapping, &flags);
+
+	if (adev != bo_adev &&
+	    !(flags & AMDGPU_PTE_SYSTEM) &&
+	    !mapping->bo_va->is_xgmi) {
+		if (amdgpu_device_is_peer_accessible(bo_adev, adev)) {
+			flags |= AMDGPU_PTE_SYSTEM;
+			vram_base_offset = bo_adev->gmc.aper_base;
+		} else {
+			DRM_DEBUG_DRIVER("Failed to map the VRAM for

peer device access.\n");

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +27 -8
+			return -EINVAL;
+		}
+	}
 
-				contiguous = pages_addr[pfn + 1] ==
-					pages_addr[pfn] + PAGE_SIZE;
+	trace_amdgpu_vm_bo_update(mapping);
 
-				tmp = num_entries /
-					AMDGPU_GPU_PAGES_IN_CPU_PAGE;
-				for (count = 2; count < tmp; ++count) {
-					uint64_t idx = pfn + count;
+	pfn = mapping->offset >> PAGE_SHIFT;
+	if (nodes) {
+		while (pfn >= nodes->size) {
+			pfn -= nodes->size;
+			++nodes;
+		}
+	}
 
-					if (contiguous != (pages_addr[idx] ==
-					    pages_addr[idx - 1] + PAGE_SIZE))
+	do {
+		dma_addr_t *dma_addr = NULL;
+		uint64_t max_entries;
+		uint64_t addr, last;
+		uint64_t count;
+
+		if (nodes) {
+			addr = nodes->start << PAGE_SHIFT;
+			max_entries = (nodes->size - pfn) *
+				AMDGPU_GPU_PAGES_IN_CPU_PAGE;
+
+			switch (mem->mem_type) {
+			case TTM_PL_TT:
+				if (pages_addr) {
+					for (count = 1;
+						 count < max_entries /

AMDGPU_GPU_PAGES_IN_CPU_PAGE;

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +4 -0
+						 ++count){
+						uint64_t idx = pfn + count;
+						if (pages_addr[idx] !=
+							(pages_addr[idx - 1] +

PAGE_SIZE))

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +9 -0
 						break;
+						}
+					if (count < min_linear_pages) {
+						addr = pfn << PAGE_SHIFT;
+						dma_addr = pages_addr;
+					} else {
+						addr = pages_addr[pfn];
+						max_entries = count;
+					}
+				} else if (flags & (AMDGPU_PTE_VALID |

AMDGPU_PTE_PRT)) {

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +2 -9
+					addr += vram_base_offset;
+					addr += pfn << PAGE_SHIFT;
 				}
-				num_entries = count *
-					AMDGPU_GPU_PAGES_IN_CPU_PAGE;
-			}
-
-			if (!contiguous) {
-				addr = cursor.start;
-				params.pages_addr = pages_addr;
-			} else {
-				addr = pages_addr[cursor.start >>

PAGE_SHIFT];

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +9 -1
-				params.pages_addr = NULL;
+				break;
+			case AMDGPU_PL_DGMA_IMPORT:
+			case AMDGPU_PL_DGMA_PEER:
+				addr = 0;
+				dma_addr = pages_addr;
+				break;
+			case AMDGPU_PL_DGMA:
+				addr += vram_base_offset +
+					adev->mman.bdev.man[mem-
Quoted 1 line

mem_type].gpu_offset -

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +1 -0
+					adev-
Quoted 1 line

mman.bdev.man[TTM_PL_VRAM].gpu_offset;

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +13 -9
+				addr += pfn << PAGE_SHIFT;
+				break;
+			case TTM_PL_VRAM:
+				addr += vram_base_offset;
+				addr += pfn << PAGE_SHIFT;
+				break;
+			default:
+				break;
 			}
-
-		} else if (flags & (AMDGPU_PTE_VALID | AMDGPU_PTE_PRT)) {
-			addr = bo_adev->vm_manager.vram_base_offset +
-				cursor.start;
 		} else {
 			addr = 0;
+			max_entries = S64_MAX;
 		}
 
-		tmp = start + num_entries;
-		r = amdgpu_vm_update_ptes(&params, start, tmp, addr, flags);
+		last = min((uint64_t)mapping->last, start + max_entries - 1);
+		r = amdgpu_vm_bo_update_mapping(adev, vm, false, resv,
+						start, last, flags, addr,
+						dma_addr, fence);
 		if (r)
-			goto error_unlock;
-
-		amdgpu_res_next(&cursor, num_entries *

AMDGPU_GPU_PAGE_SIZE);

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +9 -10
-		start = tmp;
-	}
+			return r;
 
-	r = vm->update_funcs->commit(&params, fence);
+		pfn += (last - start + 1) / AMDGPU_GPU_PAGES_IN_CPU_PAGE;
+		if (nodes && nodes->size == pfn) {
+			pfn = 0;
+			++nodes;
+		}
+		start = last + 1;
 
-	if (table_freed)
-		*table_freed = *table_freed || params.table_freed;
+	} while (unlikely(start != mapping->last + 1));
 
-error_unlock:
-	amdgpu_vm_eviction_unlock(vm);
-	drm_dev_exit(idx);
-	return r;
+	return 0;
 }
 
-void amdgpu_vm_get_memory(struct amdgpu_vm *vm, uint64_t

*vram_mem,

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +0 -17
-				uint64_t *gtt_mem, uint64_t *cpu_mem)
-{
-	struct amdgpu_bo_va *bo_va, *tmp;
-
-	list_for_each_entry_safe(bo_va, tmp, &vm->idle, base.vm_status) {
-		if (!bo_va->base.bo)
-			continue;
-		amdgpu_bo_get_memory(bo_va->base.bo, vram_mem,
-				gtt_mem, cpu_mem);
-	}
-	list_for_each_entry_safe(bo_va, tmp, &vm->evicted, base.vm_status) {
-		if (!bo_va->base.bo)
-			continue;
-		amdgpu_bo_get_memory(bo_va->base.bo, vram_mem,
-				gtt_mem, cpu_mem);
-	}
-	list_for_each_entry_safe(bo_va, tmp, &vm->relocated, base.vm_status)

{

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +0 -13
-		if (!bo_va->base.bo)
-			continue;
-		amdgpu_bo_get_memory(bo_va->base.bo, vram_mem,
-				gtt_mem, cpu_mem);
-	}
-	list_for_each_entry_safe(bo_va, tmp, &vm->moved, base.vm_status) {
-		if (!bo_va->base.bo)
-			continue;
-		amdgpu_bo_get_memory(bo_va->base.bo, vram_mem,
-				gtt_mem, cpu_mem);
-	}
-	spin_lock(&vm->invalidated_lock);
-	list_for_each_entry_safe(bo_va, tmp, &vm->invalidated,

base.vm_status) {

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +3 -16
-		if (!bo_va->base.bo)
-			continue;
-		amdgpu_bo_get_memory(bo_va->base.bo, vram_mem,
-				gtt_mem, cpu_mem);
-	}
-	list_for_each_entry_safe(bo_va, tmp, &vm->done, base.vm_status) {
-		if (!bo_va->base.bo)
-			continue;
-		amdgpu_bo_get_memory(bo_va->base.bo, vram_mem,
-				gtt_mem, cpu_mem);
-	}
-	spin_unlock(&vm->invalidated_lock);
-}
 /**
  * amdgpu_vm_bo_update - update all BO mappings in the vm page table
  *
  * @adev: amdgpu_device pointer
  * @bo_va: requested BO and VM object
  * @clear: if true clear the entries
- * @table_freed: return true if page table is freed
  *
  * Fill in the page table entries for @bo_va.
  *
@@ -1864,13 +1782,14 @@ void amdgpu_vm_get_memory(struct
 amdgpu_vm *vm, uint64_t *vram_mem,
  * 0 for success, -EINVAL for failure.
  */
 int amdgpu_vm_bo_update(struct amdgpu_device *adev, struct
 amdgpu_bo_va *bo_va,
-			bool clear, bool *table_freed)
+			bool clear)
 {
 	struct amdgpu_bo *bo = bo_va->base.bo;
 	struct amdgpu_vm *vm = bo_va->base.vm;
 	struct amdgpu_bo_va_mapping *mapping;
 	dma_addr_t *pages_addr = NULL;
-	struct ttm_resource *mem;
+	struct ttm_mem_reg *mem;
+	struct drm_mm_node *nodes;
 	struct dma_fence **last_update;
drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +14 -17
 	struct dma_resv *resv;
 	uint64_t flags;
@@ -1879,23 +1798,21 @@ int amdgpu_vm_bo_update(struct
 amdgpu_device *adev, struct amdgpu_bo_va *bo_va,
 
 	if (clear || !bo) {
 		mem = NULL;
-		resv = vm->root.bo->tbo.base.resv;
+		nodes = NULL;
+		resv = amdkcl_ttm_resvp(&vm->root.base.bo->tbo);
 	} else {
-		struct drm_gem_object *obj = &bo->tbo.base;
-
-		resv = bo->tbo.base.resv;
-		if (obj->import_attach && bo_va->is_xgmi) {
-			struct dma_buf *dma_buf = obj->import_attach-
 >dmabuf;
-			struct drm_gem_object *gobj = dma_buf->priv;
-			struct amdgpu_bo *abo = gem_to_amdgpu_bo(gobj);
-
-			if (abo->tbo.resource->mem_type == TTM_PL_VRAM)
-				bo = gem_to_amdgpu_bo(gobj);
+		struct ttm_dma_tt *ttm;
+
+		mem = &bo->tbo.mem;
+		nodes = mem->mm_node;
+		if (mem->mem_type == TTM_PL_TT) {
+			ttm = container_of(bo->tbo.ttm, struct ttm_dma_tt,
 ttm);
+			pages_addr = ttm->dma_address;
+		} else if (mem->mem_type == AMDGPU_PL_DGMA_IMPORT ||
+			   mem->mem_type == AMDGPU_PL_DGMA_PEER) {
+			pages_addr = (dma_addr_t *)bo_va->base.bo-
 >tbo.mem.bus.addr;
 		}
-		mem = bo->tbo.resource;
-		if (mem->mem_type == TTM_PL_TT ||
-		    mem->mem_type == AMDGPU_PL_PREEMPT)
-			pages_addr = bo->tbo.ttm->dma_address;
+		resv = amdkcl_ttm_resvp(&bo->tbo);
 	}
 
 	if (bo) {
@@ -1909,8 +1826,7 @@ int amdgpu_vm_bo_update(struct amdgpu_device
 *adev, struct amdgpu_bo_va *bo_va,
 		flags = 0x0;
 	}
 
-	if (clear || (bo && bo->tbo.base.resv ==
-		      vm->root.bo->tbo.base.resv))
+	if (clear || (bo && amdkcl_ttm_resvp(&bo->tbo) ==
 amdkcl_ttm_resvp(&vm->root.base.bo->tbo)))
 		last_update = &vm->last_update;
drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +0 -3
 	else
 		last_update = &bo_va->last_pt_update;
@@ -1924,26 +1840,9 @@ int amdgpu_vm_bo_update(struct amdgpu_device
 *adev, struct amdgpu_bo_va *bo_va,
 	}
 
 	list_for_each_entry(mapping, &bo_va->invalids, list) {
-		uint64_t update_flags = flags;
-
-		/* normally,bo_va->flags only contians READABLE and

WIRTEABLE bit go here

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +0 -13
-		 * but in case of something, we filter the flags in first place
-		 */
-		if (!(mapping->flags & AMDGPU_PTE_READABLE))
-			update_flags &= ~AMDGPU_PTE_READABLE;
-		if (!(mapping->flags & AMDGPU_PTE_WRITEABLE))
-			update_flags &= ~AMDGPU_PTE_WRITEABLE;
-
-		/* Apply ASIC specific mapping flags */
-		amdgpu_gmc_get_vm_pte(adev, mapping, &update_flags);
-
-		trace_amdgpu_vm_bo_update(mapping);
-
-		r = amdgpu_vm_bo_update_mapping(adev, bo_adev, vm,

false, false,

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +0 -4
-						resv, mapping->start,
-						mapping->last, update_flags,
-						mapping->offset, mem,
-						pages_addr, last_update,

table_freed);

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +5 -2
+		r = amdgpu_vm_bo_split_mapping(adev, resv, pages_addr, vm,
+					       mapping, flags, bo_adev,
+					       mem, last_update);
 		if (r)
 			return r;
 	}
@@ -1952,8 +1851,8 @@ int amdgpu_vm_bo_update(struct amdgpu_device
 *adev, struct amdgpu_bo_va *bo_va,
 	 * the evicted list so that it gets validated again on the
 	 * next command submission.
 	 */
-	if (bo && bo->tbo.base.resv == vm->root.bo->tbo.base.resv) {
-		uint32_t mem_type = bo->tbo.resource->mem_type;
+	if (bo && amdkcl_ttm_resvp(&bo->tbo) == amdkcl_ttm_resvp(&vm-
 >root.base.bo->tbo)) {
+		uint32_t mem_type = bo->tbo.mem.mem_type;
 
drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +4 -3
 		if (!(bo->preferred_domains &
 		      amdgpu_mem_type_to_domain(mem_type)))
@@ -2089,17 +1988,18 @@ static void amdgpu_vm_free_mapping(struct
 amdgpu_device *adev,
  */
 static void amdgpu_vm_prt_fini(struct amdgpu_device *adev, struct
 amdgpu_vm *vm)
 {
-	struct dma_resv *resv = vm->root.bo->tbo.base.resv;
+	struct dma_resv *resv = amdkcl_ttm_resvp(&vm->root.base.bo->tbo);
 	struct dma_fence *excl, **shared;
 	unsigned i, shared_count;
 	int r;
 
-	r = dma_resv_get_fences(resv, &excl, &shared_count, &shared);
+	r = dma_resv_get_fences_rcu(resv, &excl,
+					      &shared_count, &shared);
 	if (r) {
 		/* Not enough memory to grab the fence list, as last resort
 		 * block for all the fences to complete.
 		 */
-		dma_resv_wait_timeout(resv, true, false,
+		dma_resv_wait_timeout_rcu(resv, true, false,
 						    MAX_SCHEDULE_TIMEOUT);
drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +1 -1
 		return;
 	}
@@ -2135,7 +2035,7 @@ int amdgpu_vm_clear_freed(struct amdgpu_device
 *adev,
 			  struct amdgpu_vm *vm,
 			  struct dma_fence **fence)
 {
-	struct dma_resv *resv = vm->root.bo->tbo.base.resv;
+	struct dma_resv *resv = amdkcl_ttm_resvp(&vm->root.base.bo->tbo);
 	struct amdgpu_bo_va_mapping *mapping;
 	uint64_t init_pte_value = 0;
drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +3 -4
 	struct dma_fence *f = NULL;
@@ -2150,10 +2050,9 @@ int amdgpu_vm_clear_freed(struct amdgpu_device
 *adev,
 		    mapping->start < AMDGPU_GMC_HOLE_START)
 			init_pte_value = AMDGPU_PTE_DEFAULT_ATC;
 
-		r = amdgpu_vm_bo_update_mapping(adev, adev, vm, false,
 false,
-						resv, mapping->start,
-						mapping->last, init_pte_value,
-						0, NULL, NULL, &f, NULL);
+		r = amdgpu_vm_bo_update_mapping(adev, vm, false, resv,
+						mapping->start, mapping-
 >last,
+						init_pte_value, 0, NULL, &f);
drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +31 -0
 		amdgpu_vm_free_mapping(adev, vm, mapping, f);
 		if (r) {
 			dma_fence_put(f);
@@ -2172,6 +2071,58 @@ int amdgpu_vm_clear_freed(struct amdgpu_device
 *adev,
 
 }
 
+void amdgpu_vm_get_memory(struct amdgpu_vm *vm, uint64_t
 *vram_mem,
+				uint64_t *gtt_mem, uint64_t *cpu_mem)
+{
+	struct amdgpu_bo_va *bo_va, *tmp;
+
+	list_for_each_entry_safe(bo_va, tmp, &vm->idle, base.vm_status) {
+		if (!bo_va->base.bo)
+			continue;
+		amdgpu_bo_get_memory(bo_va->base.bo, vram_mem,
+					gtt_mem, cpu_mem);
+	}
+	list_for_each_entry_safe(bo_va, tmp, &vm->evicted, base.vm_status) {
+		if (!bo_va->base.bo)
+			continue;
+		amdgpu_bo_get_memory(bo_va->base.bo, vram_mem,
+					gtt_mem, cpu_mem);
+	}
+	list_for_each_entry_safe(bo_va, tmp, &vm->relocated, base.vm_status)
 {
+		if (!bo_va->base.bo)
+			continue;
+		amdgpu_bo_get_memory(bo_va->base.bo, vram_mem,
+					gtt_mem, cpu_mem);
+	}
+	list_for_each_entry_safe(bo_va, tmp, &vm->moved, base.vm_status) {
+		if (!bo_va->base.bo)
+			continue;
+		amdgpu_bo_get_memory(bo_va->base.bo, vram_mem,
+					gtt_mem, cpu_mem);
+	}
+	spin_lock(&vm->invalidated_lock);
+	list_for_each_entry_safe(bo_va, tmp, &vm->invalidated,

base.vm_status) {

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +22 -1
+		if (!bo_va->base.bo)
+			continue;
+		amdgpu_bo_get_memory(bo_va->base.bo, vram_mem,
+					gtt_mem, cpu_mem);
+	}
+	list_for_each_entry_safe(bo_va, tmp, &vm->freed, base.vm_status) {
+		if (!bo_va->base.bo)
+			continue;
+		amdgpu_bo_get_memory(bo_va->base.bo, vram_mem,
+					gtt_mem, cpu_mem);
+	}
+	spin_unlock(&vm->invalidated_lock);
+
+	list_for_each_entry_safe(bo_va, tmp, &vm->done, base.vm_status) {
+		if (!bo_va->base.bo)
+			continue;
+		amdgpu_bo_get_memory(bo_va->base.bo, vram_mem,
+					gtt_mem, cpu_mem);
+	}
+}
+
 /**
  * amdgpu_vm_handle_moved - handle moved BOs in the PT
  *
@@ -2195,7 +2146,7 @@ int amdgpu_vm_handle_moved(struct
 amdgpu_device *adev,
 
 	list_for_each_entry_safe(bo_va, tmp, &vm->moved, base.vm_status) {
 		/* Per VM BOs never need to bo cleared in the page tables */
-		r = amdgpu_vm_bo_update(adev, bo_va, false, NULL);
+		r = amdgpu_vm_bo_update(adev, bo_va, false);
 		if (r)
 			return r;
drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +1 -1
 	}
@@ -2204,7 +2155,7 @@ int amdgpu_vm_handle_moved(struct
 amdgpu_device *adev,
 	while (!list_empty(&vm->invalidated)) {
 		bo_va = list_first_entry(&vm->invalidated, struct
 amdgpu_bo_va,
 					 base.vm_status);
-		resv = bo_va->base.bo->tbo.base.resv;
+		resv = amdkcl_ttm_resvp(&bo_va->base.bo->tbo);
 		spin_unlock(&vm->invalidated_lock);
drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +2 -5
 		/* Try to reserve the BO to avoid clearing its ptes */
@@ -2214,7 +2165,7 @@ int amdgpu_vm_handle_moved(struct
 amdgpu_device *adev,
 		else
 			clear = true;
 
-		r = amdgpu_vm_bo_update(adev, bo_va, clear, NULL);
+		r = amdgpu_vm_bo_update(adev, bo_va, clear);
 		if (r)
 			return r;
@@ -2258,13 +2209,14 @@ struct amdgpu_bo_va
 *amdgpu_vm_bo_add(struct amdgpu_device *adev,
 	INIT_LIST_HEAD(&bo_va->valids);
 	INIT_LIST_HEAD(&bo_va->invalids);
 
-	if (!bo)
-		return bo_va;
-
-	if (amdgpu_dmabuf_is_xgmi_accessible(adev, bo)) {
+	if (bo && amdgpu_xgmi_same_hive(adev, amdgpu_ttm_adev(bo-
Quoted 1 line

tbo.bdev)) &&

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +2 -1
+	    (bo->preferred_domains & AMDGPU_GEM_DOMAIN_VRAM)) {
 		bo_va->is_xgmi = true;
+		mutex_lock(&adev->vm_manager.lock_pstate);
 		/* Power up XGMI if it can be potentially used */
-		amdgpu_xgmi_set_pstate(adev,

AMDGPU_XGMI_PSTATE_MAX_VEGA20);

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +4 -1
+		if (++adev->vm_manager.xgmi_map_counter == 1)
+			amdgpu_xgmi_set_pstate(adev, 1);
+		mutex_unlock(&adev->vm_manager.lock_pstate);
 	}
 
 	return bo_va;
@@ -2272,7 +2224,7 @@ struct amdgpu_bo_va *amdgpu_vm_bo_add(struct
 amdgpu_device *adev,
 
 
 /**
- * amdgpu_vm_bo_insert_map - insert a new mapping
+ * amdgpu_vm_bo_insert_mapping - insert a new mapping
  *
  * @adev: amdgpu_device pointer

* @bo_va: bo_va to store the address

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +1 -1
@@ -2294,7 +2246,7 @@ static void amdgpu_vm_bo_insert_map(struct
 amdgpu_device *adev,
 	if (mapping->flags & AMDGPU_PTE_PRT)
 		amdgpu_vm_prt_get(adev);
 
-	if (bo && bo->tbo.base.resv == vm->root.bo->tbo.base.resv &&
+	if (bo && amdkcl_ttm_resvp(&bo->tbo) == amdkcl_ttm_resvp(&vm-
Quoted 1 line

root.base.bo->tbo) &&

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +1 -2
 	    !bo_va->base.moved) {
 		list_move(&bo_va->base.vm_status, &vm->moved);
 	}
@@ -2329,15 +2281,14 @@ int amdgpu_vm_bo_map(struct amdgpu_device
 *adev,
 	uint64_t eaddr;
 
 	/* validate the parameters */
-	if (saddr & ~PAGE_MASK || offset & ~PAGE_MASK ||
-	    size == 0 || size & ~PAGE_MASK)
+	if (saddr & AMDGPU_GPU_PAGE_MASK || offset &

AMDGPU_GPU_PAGE_MASK ||

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +1 -2
+	    size == 0 || size & AMDGPU_GPU_PAGE_MASK)
 		return -EINVAL;
 
 	/* make sure object fit at this offset */
 	eaddr = saddr + size - 1;
 	if (saddr >= eaddr ||
-	    (bo && offset + size > amdgpu_bo_size(bo)) ||
-	    (eaddr >= adev->vm_manager.max_pfn <<

AMDGPU_GPU_PAGE_SHIFT))

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +2 -2
+	    (bo && offset + size > amdgpu_bo_size(bo)))
 		return -EINVAL;
 
 	saddr /= AMDGPU_GPU_PAGE_SIZE;
@@ -2395,15 +2346,14 @@ int amdgpu_vm_bo_replace_map(struct
 amdgpu_device *adev,
 	int r;
 
 	/* validate the parameters */
-	if (saddr & ~PAGE_MASK || offset & ~PAGE_MASK ||
-	    size == 0 || size & ~PAGE_MASK)
+	if (saddr & AMDGPU_GPU_PAGE_MASK || offset &

AMDGPU_GPU_PAGE_MASK ||

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +1 -2
+	    size == 0 || size & AMDGPU_GPU_PAGE_MASK)
 		return -EINVAL;
 
 	/* make sure object fit at this offset */
 	eaddr = saddr + size - 1;
 	if (saddr >= eaddr ||
-	    (bo && offset + size > amdgpu_bo_size(bo)) ||
-	    (eaddr >= adev->vm_manager.max_pfn <<

AMDGPU_GPU_PAGE_SHIFT))

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +2 -1
+	    (bo && offset + size > amdgpu_bo_size(bo)))
 		return -EINVAL;
 
 	/* Allocate all the needed memory */
@@ -2541,7 +2491,7 @@ int amdgpu_vm_bo_clear_mappings(struct
 amdgpu_device *adev,
 			after->start = eaddr + 1;
 			after->last = tmp->last;
 			after->offset = tmp->offset;
-			after->offset += (after->start - tmp->start) <<
 PAGE_SHIFT;
+			after->offset += after->start - tmp->start;
 			after->flags = tmp->flags;
drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +1 -1
 			after->bo_va = tmp->bo_va;
 			list_add(&after->list, &tmp->bo_va->invalids);
@@ -2628,7 +2578,7 @@ void amdgpu_vm_bo_trace_cs(struct amdgpu_vm
 *vm, struct ww_acquire_ctx *ticket)
 			struct amdgpu_bo *bo;
 
 			bo = mapping->bo_va->base.bo;
-			if (dma_resv_locking_ctx(bo->tbo.base.resv) !=
+			if (dma_resv_locking_ctx(amdkcl_ttm_resvp(&bo-
Quoted 1 line

tbo)) !=

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +1 -1
 			    ticket)
 				continue;
 		}
@@ -2656,7 +2606,7 @@ void amdgpu_vm_bo_rmv(struct amdgpu_device
 *adev,
 	struct amdgpu_vm_bo_base **base;
 
 	if (bo) {
-		if (bo->tbo.base.resv == vm->root.bo->tbo.base.resv)
+		if (amdkcl_ttm_resvp(&bo->tbo) == amdkcl_ttm_resvp(&vm-
 >root.base.bo->tbo))
 			vm->bulk_moveable = false;
drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +6 -2
 		for (base = &bo_va->base.bo->vm_bo; *base;
@@ -2689,8 +2639,12 @@ void amdgpu_vm_bo_rmv(struct amdgpu_device
 *adev,
 
 	dma_fence_put(bo_va->last_pt_update);
 
-	if (bo && bo_va->is_xgmi)
-		amdgpu_xgmi_set_pstate(adev,
 AMDGPU_XGMI_PSTATE_MIN);
+	if (bo && bo_va->is_xgmi) {
+		mutex_lock(&adev->vm_manager.lock_pstate);
+		if (--adev->vm_manager.xgmi_map_counter == 0)
+			amdgpu_xgmi_set_pstate(adev, 0);
+		mutex_unlock(&adev->vm_manager.lock_pstate);
+	}
 
drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +4 -4
 	kfree(bo_va);
 }
@@ -2711,7 +2665,7 @@ bool amdgpu_vm_evictable(struct amdgpu_bo *bo)
 		return true;
 
 	/* Don't evict VM page tables while they are busy */
-	if (!dma_resv_test_signaled(bo->tbo.base.resv, true))
+	if (!dma_resv_test_signaled_rcu(amdkcl_ttm_resvp(&bo->tbo), true))
 		return false;
 
 	/* Try to block ongoing updates */
@@ -2719,7 +2673,7 @@ bool amdgpu_vm_evictable(struct amdgpu_bo *bo)
 		return false;
 
 	/* Don't evict VM page tables while they are updated */
-	if (!dma_fence_is_signaled(bo_base->vm->last_unlocked)) {
+	if (!dma_fence_is_signaled(bo_base->vm->last_direct)) {
 		amdgpu_vm_eviction_unlock(bo_base->vm);
 		return false;
 	}
@@ -2744,13 +2698,13 @@ void amdgpu_vm_bo_invalidate(struct
 amdgpu_device *adev,
 	struct amdgpu_vm_bo_base *bo_base;
 
 	/* shadow bo doesn't have bo base, its validation needs its parent */
-	if (bo->parent && (amdgpu_bo_shadowed(bo->parent) == bo))
+	if (bo->parent && bo->parent->shadow == bo)
 		bo = bo->parent;
 
 	for (bo_base = bo->vm_bo; bo_base; bo_base = bo_base->next) {
 		struct amdgpu_vm *vm = bo_base->vm;
 
-		if (evicted && bo->tbo.base.resv == vm->root.bo-
 >tbo.base.resv) {
+		if (evicted && amdkcl_ttm_resvp(&bo->tbo) ==
 amdkcl_ttm_resvp(&vm->root.base.bo->tbo)) {
drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +1 -1
 			amdgpu_vm_bo_evicted(bo_base);
 			continue;
 		}
@@ -2761,7 +2715,7 @@ void amdgpu_vm_bo_invalidate(struct
 amdgpu_device *adev,
 
 		if (bo->tbo.type == ttm_bo_type_kernel)
 			amdgpu_vm_bo_relocated(bo_base);
-		else if (bo->tbo.base.resv == vm->root.bo->tbo.base.resv)
+		else if (amdkcl_ttm_resvp(&bo->tbo) ==
 amdkcl_ttm_resvp(&vm->root.base.bo->tbo))
 			amdgpu_vm_bo_moved(bo_base);
drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +3 -3
 		else
 			amdgpu_vm_bo_invalidated(bo_base);
@@ -2891,12 +2845,12 @@ void amdgpu_vm_adjust_size(struct
 amdgpu_device *adev, uint32_t min_vm_size,
  */
 long amdgpu_vm_wait_idle(struct amdgpu_vm *vm, long timeout)
 {
-	timeout = dma_resv_wait_timeout(vm->root.bo->tbo.base.resv, true,
-					true, timeout);
+	timeout = dma_resv_wait_timeout_rcu(amdkcl_ttm_resvp(&vm-
 >root.base.bo->tbo),
+						   true, true, timeout);
 	if (timeout <= 0)
 		return timeout;
 
-	return dma_fence_wait_timeout(vm->last_unlocked, true, timeout);
+	return dma_fence_wait_timeout(vm->last_direct, true, timeout);
 }

/**

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +10 -3
@@ -2904,19 +2858,26 @@ long amdgpu_vm_wait_idle(struct amdgpu_vm
 *vm, long timeout)
  *
  * @adev: amdgpu_device pointer
  * @vm: requested vm
+ * @vm_context: Indicates if it GFX or Compute context
+ * @pasid: Process address space identifier
  *
  * Init @vm fields.
  *
  * Returns:
  * 0 for success, error for failure.
  */
-int amdgpu_vm_init(struct amdgpu_device *adev, struct amdgpu_vm *vm)
+int amdgpu_vm_init(struct amdgpu_device *adev, struct amdgpu_vm *vm,
+		   int vm_context, unsigned int pasid)
 {
-	struct amdgpu_bo *root_bo;
-	struct amdgpu_bo_vm *root;
+	struct amdgpu_bo_param bp;
+	struct amdgpu_bo *root;
 	int r, i;
 
+#ifndef HAVE_TREE_INSERT_HAVE_RB_ROOT_CACHED
+	vm->va = RB_ROOT;
+#else
 	vm->va = RB_ROOT_CACHED;
+#endif
 	for (i = 0; i < AMDGPU_MAX_VMHUBS; i++)
 		vm->reserved_vmid[i] = NULL;
drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +1 -1
 	INIT_LIST_HEAD(&vm->evicted);
@@ -2929,7 +2890,7 @@ int amdgpu_vm_init(struct amdgpu_device *adev,
 struct amdgpu_vm *vm)
 	INIT_LIST_HEAD(&vm->done);
 
 	/* create scheduler entities for page table updates */
-	r = drm_sched_entity_init(&vm->immediate,
 DRM_SCHED_PRIORITY_NORMAL,
+	r = drm_sched_entity_init(&vm->direct,
 DRM_SCHED_PRIORITY_NORMAL,
drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +0 -0
 				  adev->vm_manager.vm_pte_scheds,
 				  adev->vm_manager.vm_pte_num_scheds,

NULL);

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +1 -2
 	if (r)
@@ -2939,14 +2900,21 @@ int amdgpu_vm_init(struct amdgpu_device *adev,
 struct amdgpu_vm *vm)
 				  adev->vm_manager.vm_pte_scheds,
 				  adev->vm_manager.vm_pte_num_scheds,
 NULL);
 	if (r)
-		goto error_free_immediate;
+		goto error_free_direct;
 
 	vm->pte_support_ats = false;
 	vm->is_compute_context = false;
 
-	vm->use_cpu_for_update = !!(adev->vm_manager.vm_update_mode

&

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +2 -1
-				    AMDGPU_VM_USE_CPU_FOR_GFX);
+	if (vm_context == AMDGPU_VM_CONTEXT_COMPUTE) {
+		vm->use_cpu_for_update = !!(adev-
Quoted 1 line

vm_manager.vm_update_mode &

+

	AMDGPU_VM_USE_CPU_FOR_COMPUTE);
drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +4 -0
+		if (adev->asic_type == CHIP_RAVEN)
+			vm->pte_support_ats = true;
+	} else {
+		vm->use_cpu_for_update = !!(adev-
Quoted 1 line

vm_manager.vm_update_mode &

+

	AMDGPU_VM_USE_CPU_FOR_GFX);
drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +31 -15
+	}
 	DRM_DEBUG_DRIVER("VM update mode is %s\n",
 			 vm->use_cpu_for_update ? "CPU" : "SDMA");
 	WARN_ONCE((vm->use_cpu_for_update &&
@@ -2958,50 +2926,65 @@ int amdgpu_vm_init(struct amdgpu_device *adev,
 struct amdgpu_vm *vm)
 	else
 		vm->update_funcs = &amdgpu_vm_sdma_funcs;
 	vm->last_update = NULL;
-	vm->last_unlocked = dma_fence_get_stub();
+	vm->last_direct = dma_fence_get_stub();
 
 	mutex_init(&vm->eviction_lock);
 	vm->evicting = false;
 
-	r = amdgpu_vm_pt_create(adev, vm, adev->vm_manager.root_level,
-				false, &root);
+	amdgpu_vm_bo_param(adev, vm, adev->vm_manager.root_level,
 false, &bp);
+	if (vm_context == AMDGPU_VM_CONTEXT_COMPUTE)
+		bp.flags &= ~AMDGPU_GEM_CREATE_SHADOW;
+	r = amdgpu_bo_create(adev, &bp, &root);
 	if (r)
 		goto error_free_delayed;
-	root_bo = &root->bo;
-	r = amdgpu_bo_reserve(root_bo, true);
+
+	r = amdgpu_bo_reserve(root, true);
 	if (r)
 		goto error_free_root;
 
-	r = dma_resv_reserve_shared(root_bo->tbo.base.resv, 1);
+	r = dma_resv_reserve_shared(amdkcl_ttm_resvp(&root->tbo), 1);
 	if (r)
 		goto error_unreserve;
 
-	amdgpu_vm_bo_base_init(&vm->root, vm, root_bo);
+	amdgpu_vm_bo_base_init(&vm->root.base, vm, root);
 
 	r = amdgpu_vm_clear_bo(adev, vm, root, false);
 	if (r)
 		goto error_unreserve;
 
-	amdgpu_bo_unreserve(vm->root.bo);
+	amdgpu_bo_unreserve(vm->root.base.bo);
+
+	if (pasid) {
+		unsigned long flags;
+
+		spin_lock_irqsave(&adev->vm_manager.pasid_lock, flags);
+		r = idr_alloc(&adev->vm_manager.pasid_idr, vm, pasid, pasid +
 1,
+			      GFP_ATOMIC);
+		spin_unlock_irqrestore(&adev->vm_manager.pasid_lock, flags);
+		if (r < 0)
+			goto error_free_root;
+
+		vm->pasid = pasid;
+	}
 
 	INIT_KFIFO(vm->faults);
 
 	return 0;
 
 error_unreserve:
-	amdgpu_bo_unreserve(vm->root.bo);
+	amdgpu_bo_unreserve(vm->root.base.bo);
 
 error_free_root:
-	amdgpu_bo_unref(&root->shadow);
-	amdgpu_bo_unref(&root_bo);
-	vm->root.bo = NULL;
+	amdgpu_bo_unref(&vm->root.base.bo->shadow);
+	amdgpu_bo_unref(&vm->root.base.bo);
+	vm->root.base.bo = NULL;
 
 error_free_delayed:
-	dma_fence_put(vm->last_unlocked);
+	dma_fence_put(vm->last_direct);
 	drm_sched_entity_destroy(&vm->delayed);
 
-error_free_immediate:
-	drm_sched_entity_destroy(&vm->immediate);
+error_free_direct:
+	drm_sched_entity_destroy(&vm->direct);
drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +6 -2
 	return r;
 }
@@ -3020,14 +3003,17 @@ int amdgpu_vm_init(struct amdgpu_device *adev,
 struct amdgpu_vm *vm)
  *	0 if this VM is clean
  */
 static int amdgpu_vm_check_clean_reserved(struct amdgpu_device *adev,
-					  struct amdgpu_vm *vm)
+	struct amdgpu_vm *vm)
 {
 	enum amdgpu_vm_level root = adev->vm_manager.root_level;
 	unsigned int entries = amdgpu_vm_num_entries(adev, root);
 	unsigned int i = 0;
 
+	if (!(vm->root.entries))
+		return 0;
+
 	for (i = 0; i < entries; i++) {
-		if (to_amdgpu_bo_vm(vm->root.bo)->entries[i].bo)
+		if (vm->root.entries[i].base.bo)
 			return -EINVAL;
 	}
@@ -3039,6 +3025,7 @@ static int amdgpu_vm_check_clean_reserved(struct
 amdgpu_device *adev,
  *
  * @adev: amdgpu_device pointer
  * @vm: requested vm
+ * @pasid: pasid to use
  *
  * This only works on GFX VMs that don't have any BOs added and no

* page tables allocated yet.

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +1 -0
@@ -3046,6 +3033,7 @@ static int amdgpu_vm_check_clean_reserved(struct
 amdgpu_device *adev,
  * Changes the following VM parameters:
  * - use_cpu_for_update
  * - pte_supports_ats
+ * - pasid (old PASID is released, because compute manages its own PASIDs)
  *
  * Reinitializes the page directory to reflect the changed ATS

* setting.

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +3 -2
@@ -3053,12 +3041,13 @@ static int
 amdgpu_vm_check_clean_reserved(struct amdgpu_device *adev,
  * Returns:
  * 0 for success, -errno for errors.
  */
-int amdgpu_vm_make_compute(struct amdgpu_device *adev, struct
 amdgpu_vm *vm)
+int amdgpu_vm_make_compute(struct amdgpu_device *adev, struct
 amdgpu_vm *vm,
+			   unsigned int pasid)
 {
 	bool pte_support_ats = (adev->asic_type == CHIP_RAVEN);
 	int r;
 
-	r = amdgpu_bo_reserve(vm->root.bo, true);
+	r = amdgpu_bo_reserve(vm->root.base.bo, true);
drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +15 -4
 	if (r)
 		return r;
@@ -3067,16 +3056,27 @@ int amdgpu_vm_make_compute(struct
 amdgpu_device *adev, struct amdgpu_vm *vm)
 	if (r)
 		goto unreserve_bo;
 
+	if (pasid) {
+		unsigned long flags;
+
+		spin_lock_irqsave(&adev->vm_manager.pasid_lock, flags);
+		r = idr_alloc(&adev->vm_manager.pasid_idr, vm, pasid, pasid +
 1,
+			      GFP_ATOMIC);
+		spin_unlock_irqrestore(&adev->vm_manager.pasid_lock, flags);
+
+		if (r == -ENOSPC)
+			goto unreserve_bo;
+		r = 0;
+	}
+
 	/* Check if PD needs to be reinitialized and do it before
 	 * changing any other state, in case it fails.
 	 */
 	if (pte_support_ats != vm->pte_support_ats) {
 		vm->pte_support_ats = pte_support_ats;
-		r = amdgpu_vm_clear_bo(adev, vm,
-				       to_amdgpu_bo_vm(vm->root.bo),
-				       false);
+		r = amdgpu_vm_clear_bo(adev, vm, vm->root.base.bo, false);
 		if (r)
-			goto unreserve_bo;
+			goto free_idr;
 	}
drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +37 -12
 	/* Update VM state */
@@ -3088,28 +3088,46 @@ int amdgpu_vm_make_compute(struct
 amdgpu_device *adev, struct amdgpu_vm *vm)
 		   !amdgpu_gmc_vram_full_visible(&adev->gmc)),
 		  "CPU update of VM recommended only for large BAR
 system\n");
 
-	if (vm->use_cpu_for_update) {
-		/* Sync with last SDMA update/clear before switching to CPU
 */
-		r = amdgpu_bo_sync_wait(vm->root.bo,
-
 	AMDGPU_FENCE_OWNER_UNDEFINED, true);
-		if (r)
-			goto unreserve_bo;
-
+	if (vm->use_cpu_for_update)
 		vm->update_funcs = &amdgpu_vm_cpu_funcs;
-	} else {
+	else
 		vm->update_funcs = &amdgpu_vm_sdma_funcs;
-	}
 	dma_fence_put(vm->last_update);
 	vm->last_update = NULL;
 	vm->is_compute_context = true;
 
+	if (vm->pasid) {
+		unsigned long flags;
+
+		spin_lock_irqsave(&adev->vm_manager.pasid_lock, flags);
+		idr_remove(&adev->vm_manager.pasid_idr, vm->pasid);
+		spin_unlock_irqrestore(&adev->vm_manager.pasid_lock, flags);
+
+		/* Free the original amdgpu allocated pasid
+		 * Will be replaced with kfd allocated pasid
+		 */
+		amdgpu_pasid_free(vm->pasid);
+		vm->pasid = 0;
+	}
+
 	/* Free the shadow bo for compute VM */
-	amdgpu_bo_unref(&to_amdgpu_bo_vm(vm->root.bo)->shadow);
+	amdgpu_bo_unref(&vm->root.base.bo->shadow);
+
+	if (pasid)
+		vm->pasid = pasid;
 
 	goto unreserve_bo;
 
+free_idr:
+	if (pasid) {
+		unsigned long flags;
+
+		spin_lock_irqsave(&adev->vm_manager.pasid_lock, flags);
+		idr_remove(&adev->vm_manager.pasid_idr, pasid);
+		spin_unlock_irqrestore(&adev->vm_manager.pasid_lock, flags);
+	}
 unreserve_bo:
-	amdgpu_bo_unreserve(vm->root.bo);
+	amdgpu_bo_unreserve(vm->root.base.bo);
 	return r;
 }
@@ -3123,7 +3141,14 @@ int amdgpu_vm_make_compute(struct
 amdgpu_device *adev, struct amdgpu_vm *vm)
  */
 void amdgpu_vm_release_compute(struct amdgpu_device *adev, struct
 amdgpu_vm *vm)
 {
-	amdgpu_vm_set_pasid(adev, vm, 0);
+	if (vm->pasid) {
+		unsigned long flags;
+
+		spin_lock_irqsave(&adev->vm_manager.pasid_lock, flags);
+		idr_remove(&adev->vm_manager.pasid_idr, vm->pasid);
+		spin_unlock_irqrestore(&adev->vm_manager.pasid_lock, flags);
+	}
+	vm->pasid = 0;
 	vm->is_compute_context = false;

}

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +12 -4
@@ -3145,11 +3170,19 @@ void amdgpu_vm_fini(struct amdgpu_device
 *adev, struct amdgpu_vm *vm)
 
 	amdgpu_amdkfd_gpuvm_destroy_cb(adev, vm);
 
-	root = amdgpu_bo_ref(vm->root.bo);
+	root = amdgpu_bo_ref(vm->root.base.bo);
 	amdgpu_bo_reserve(root, true);
-	amdgpu_vm_set_pasid(adev, vm, 0);
-	dma_fence_wait(vm->last_unlocked, false);
-	dma_fence_put(vm->last_unlocked);
+	if (vm->pasid) {
+		unsigned long flags;
+
+		spin_lock_irqsave(&adev->vm_manager.pasid_lock, flags);
+		idr_remove(&adev->vm_manager.pasid_idr, vm->pasid);
+		spin_unlock_irqrestore(&adev->vm_manager.pasid_lock, flags);
+		vm->pasid = 0;
+	}
+
+	dma_fence_wait(vm->last_direct, false);
+	dma_fence_put(vm->last_direct);
 
 	list_for_each_entry_safe(mapping, tmp, &vm->freed, list) {
drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +10 -2
 		if (mapping->flags & AMDGPU_PTE_PRT && prt_fini_needed) {
@@ -3164,16 +3197,24 @@ void amdgpu_vm_fini(struct amdgpu_device
 *adev, struct amdgpu_vm *vm)
 	amdgpu_vm_free_pts(adev, vm, NULL);
 	amdgpu_bo_unreserve(root);
 	amdgpu_bo_unref(&root);
-	WARN_ON(vm->root.bo);
+	WARN_ON(vm->root.base.bo);
 
-	drm_sched_entity_destroy(&vm->immediate);
+	drm_sched_entity_destroy(&vm->direct);
 	drm_sched_entity_destroy(&vm->delayed);
 
+#ifndef HAVE_TREE_INSERT_HAVE_RB_ROOT_CACHED
+	if (!RB_EMPTY_ROOT(&vm->va)) {
+#else
 	if (!RB_EMPTY_ROOT(&vm->va.rb_root)) {
+#endif
 		dev_err(adev->dev, "still active bo inside vm\n");
 	}
 	rbtree_postorder_for_each_entry_safe(mapping, tmp,
+#ifndef HAVE_TREE_INSERT_HAVE_RB_ROOT_CACHED
+					     &vm->va, rb) {
+#else
 					     &vm->va.rb_root, rb) {
+#endif
 		/* Don't remove the mapping here, we don't want to trigger a
 		 * rebalance and the tree is about to be destroyed anyway.
drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +0 -4
 		 */
@@ -3197,12 +3238,6 @@ void amdgpu_vm_manager_init(struct
 amdgpu_device *adev)
 {
 	unsigned i;
 
-	/* Concurrent flushes are only possible starting with Vega10 and
-	 * are broken on Navi10 and Navi14.
-	 */
-	adev->vm_manager.concurrent_flush = !(adev->asic_type <

CHIP_VEGA10 ||

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +0 -1
-					      adev->asic_type == CHIP_NAVI10

||

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +5 -2
-					      adev->asic_type == CHIP_NAVI14);
 	amdgpu_vmid_mgr_init(adev);
 
 	adev->vm_manager.fence_context =
@@ -3229,7 +3264,11 @@ void amdgpu_vm_manager_init(struct
 amdgpu_device *adev)
 	adev->vm_manager.vm_update_mode = 0;
 #endif
 
-	xa_init_flags(&adev->vm_manager.pasids, XA_FLAGS_LOCK_IRQ);
+	idr_init(&adev->vm_manager.pasid_idr);
+	spin_lock_init(&adev->vm_manager.pasid_lock);
+
+	adev->vm_manager.xgmi_map_counter = 0;
+	mutex_init(&adev->vm_manager.lock_pstate);
 }
 

/**

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +2 -2
@@ -3241,8 +3280,8 @@ void amdgpu_vm_manager_init(struct
 amdgpu_device *adev)
  */
 void amdgpu_vm_manager_fini(struct amdgpu_device *adev)
 {
-	WARN_ON(!xa_empty(&adev->vm_manager.pasids));
-	xa_destroy(&adev->vm_manager.pasids);
+	WARN_ON(!idr_is_empty(&adev->vm_manager.pasid_idr));
+	idr_destroy(&adev->vm_manager.pasid_idr);
 
 	amdgpu_vmid_mgr_fini(adev);

}

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +1 -1
@@ -3260,7 +3299,7 @@ void amdgpu_vm_manager_fini(struct
 amdgpu_device *adev)
 int amdgpu_vm_ioctl(struct drm_device *dev, void *data, struct drm_file *filp)
 {
 	union drm_amdgpu_vm *args = data;
-	struct amdgpu_device *adev = drm_to_adev(dev);
+	struct amdgpu_device *adev = dev->dev_private;
 	struct amdgpu_fpriv *fpriv = filp->driver_priv;
 	long timeout = msecs_to_jiffies(2000);
drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +2 -2
 	int r;
@@ -3280,7 +3319,7 @@ int amdgpu_vm_ioctl(struct drm_device *dev, void
 *data, struct drm_file *filp)
 		/* Wait vm idle to make sure the vmid set in SPM_VMID is
 		 * not referenced anymore.
 		 */
-		r = amdgpu_bo_reserve(fpriv->vm.root.bo, true);
+		r = amdgpu_bo_reserve(fpriv->vm.root.base.bo, true);
 		if (r)
 			return r;
@@ -3288,7 +3327,7 @@ int amdgpu_vm_ioctl(struct drm_device *dev, void
 *data, struct drm_file *filp)
 		if (r < 0)
 			return r;
 
-		amdgpu_bo_unreserve(fpriv->vm.root.bo);
+		amdgpu_bo_unreserve(fpriv->vm.root.base.bo);
 		amdgpu_vmid_free_reserved(adev, &fpriv->vm,
 AMDGPU_GFXHUB_0);
drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +4 -4
 		break;
 	default:
@@ -3305,19 +3344,19 @@ int amdgpu_vm_ioctl(struct drm_device *dev,
 void *data, struct drm_file *filp)
  * @pasid: PASID identifier for VM
  * @task_info: task_info to fill.
  */
-void amdgpu_vm_get_task_info(struct amdgpu_device *adev, u32 pasid,
+void amdgpu_vm_get_task_info(struct amdgpu_device *adev, unsigned int
 pasid,
 			 struct amdgpu_task_info *task_info)
 {
 	struct amdgpu_vm *vm;
 	unsigned long flags;
 
-	xa_lock_irqsave(&adev->vm_manager.pasids, flags);
+	spin_lock_irqsave(&adev->vm_manager.pasid_lock, flags);
 
-	vm = xa_load(&adev->vm_manager.pasids, pasid);
+	vm = idr_find(&adev->vm_manager.pasid_idr, pasid);
 	if (vm)
 		*task_info = vm->task_info;
 
-	xa_unlock_irqrestore(&adev->vm_manager.pasids, flags);
+	spin_unlock_irqrestore(&adev->vm_manager.pasid_lock, flags);
 }

/**

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +15 -25
@@ -3349,60 +3388,50 @@ void amdgpu_vm_set_task_info(struct
 amdgpu_vm *vm)
  * Try to gracefully handle a VM fault. Return true if the fault was handled and
  * shouldn't be reported any more.
  */
-bool amdgpu_vm_handle_fault(struct amdgpu_device *adev, u32 pasid,
+bool amdgpu_vm_handle_fault(struct amdgpu_device *adev, unsigned int
 pasid,
 			    uint64_t addr)
 {
-	bool is_compute_context = false;
 	struct amdgpu_bo *root;
-	unsigned long irqflags;
 	uint64_t value, flags;
 	struct amdgpu_vm *vm;
-	int r;
+	long r;
 
-	xa_lock_irqsave(&adev->vm_manager.pasids, irqflags);
-	vm = xa_load(&adev->vm_manager.pasids, pasid);
-	if (vm) {
-		root = amdgpu_bo_ref(vm->root.bo);
-		is_compute_context = vm->is_compute_context;
-	} else {
+	spin_lock(&adev->vm_manager.pasid_lock);
+	vm = idr_find(&adev->vm_manager.pasid_idr, pasid);
+	if (vm)
+		root = amdgpu_bo_ref(vm->root.base.bo);
+	else
 		root = NULL;
-	}
-	xa_unlock_irqrestore(&adev->vm_manager.pasids, irqflags);
+	spin_unlock(&adev->vm_manager.pasid_lock);
 
 	if (!root)
 		return false;
 
-	addr /= AMDGPU_GPU_PAGE_SIZE;
-
-	if (is_compute_context &&
-	    !svm_range_restore_pages(adev, pasid, addr)) {
-		amdgpu_bo_unref(&root);
-		return true;
-	}
-
 	r = amdgpu_bo_reserve(root, true);
 	if (r)
 		goto error_unref;
 
 	/* Double check that the VM still exists */
-	xa_lock_irqsave(&adev->vm_manager.pasids, irqflags);
-	vm = xa_load(&adev->vm_manager.pasids, pasid);
-	if (vm && vm->root.bo != root)
+	spin_lock(&adev->vm_manager.pasid_lock);
+	vm = idr_find(&adev->vm_manager.pasid_idr, pasid);
+	if (vm && vm->root.base.bo != root)
 		vm = NULL;
-	xa_unlock_irqrestore(&adev->vm_manager.pasids, irqflags);
+	spin_unlock(&adev->vm_manager.pasid_lock);
 	if (!vm)
 		goto error_unlock;
 
+	addr /= AMDGPU_GPU_PAGE_SIZE;
 	flags = AMDGPU_PTE_VALID | AMDGPU_PTE_SNOOPED |
 		AMDGPU_PTE_SYSTEM;
 
-	if (is_compute_context) {
+	if (vm->is_compute_context) {
 		/* Intentionally setting invalid PTE flag
 		 * combination to force a no-retry-fault
 		 */
 		flags = AMDGPU_PTE_EXECUTABLE | AMDGPU_PDE_PTE |
 			AMDGPU_PTE_TF;
 		value = 0;
+
 	} else if (amdgpu_vm_fault_stop ==

AMDGPU_VM_FAULT_STOP_NEVER) {

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +4 -21
 		/* Redirect the access to the dummy page */
 		value = adev->dummy_page_addr;
@@ -3414,15 +3443,8 @@ bool amdgpu_vm_handle_fault(struct
 amdgpu_device *adev, u32 pasid,
 		value = 0;
 	}
 
-	r = dma_resv_reserve_shared(root->tbo.base.resv, 1);
-	if (r) {
-		pr_debug("failed %d to reserve fence slot\n", r);
-		goto error_unlock;
-	}
-
-	r = amdgpu_vm_bo_update_mapping(adev, adev, vm, true, false,
 NULL, addr,
-					addr, flags, value, NULL, NULL, NULL,
-					NULL);
+	r = amdgpu_vm_bo_update_mapping(adev, vm, true, NULL, addr, addr
+ 1,
+					flags, value, NULL, NULL);
 	if (r)
 		goto error_unlock;
@@ -3431,106 +3453,10 @@ bool amdgpu_vm_handle_fault(struct
 amdgpu_device *adev, u32 pasid,
 error_unlock:
 	amdgpu_bo_unreserve(root);
 	if (r < 0)
-		DRM_ERROR("Can't handle page fault (%d)\n", r);
+		DRM_ERROR("Can't handle page fault (%ld)\n", r);
 
 error_unref:
 	amdgpu_bo_unref(&root);
 
 	return false;
 }
-
-#if defined(CONFIG_DEBUG_FS)
-/**
- * amdgpu_debugfs_vm_bo_info  - print BO info for the VM
- *
- * @vm: Requested VM for printing BO info
- * @m: debugfs file
- *
- * Print BO information in debugfs file for the VM
- */
-void amdgpu_debugfs_vm_bo_info(struct amdgpu_vm *vm, struct seq_file

*m)

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +0 -30
-{
-	struct amdgpu_bo_va *bo_va, *tmp;
-	u64 total_idle = 0;
-	u64 total_evicted = 0;
-	u64 total_relocated = 0;
-	u64 total_moved = 0;
-	u64 total_invalidated = 0;
-	u64 total_done = 0;
-	unsigned int total_idle_objs = 0;
-	unsigned int total_evicted_objs = 0;
-	unsigned int total_relocated_objs = 0;
-	unsigned int total_moved_objs = 0;
-	unsigned int total_invalidated_objs = 0;
-	unsigned int total_done_objs = 0;
-	unsigned int id = 0;
-
-	seq_puts(m, "\tIdle BOs:\n");
-	list_for_each_entry_safe(bo_va, tmp, &vm->idle, base.vm_status) {
-		if (!bo_va->base.bo)
-			continue;
-		total_idle += amdgpu_bo_print_info(id++, bo_va->base.bo, m);
-	}
-	total_idle_objs = id;
-	id = 0;
-
-	seq_puts(m, "\tEvicted BOs:\n");
-	list_for_each_entry_safe(bo_va, tmp, &vm->evicted, base.vm_status) {
-		if (!bo_va->base.bo)
-			continue;
-		total_evicted += amdgpu_bo_print_info(id++, bo_va->base.bo,

m);

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +0 -6
-	}
-	total_evicted_objs = id;
-	id = 0;
-
-	seq_puts(m, "\tRelocated BOs:\n");
-	list_for_each_entry_safe(bo_va, tmp, &vm->relocated, base.vm_status)

{

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +0 -3
-		if (!bo_va->base.bo)
-			continue;
-		total_relocated += amdgpu_bo_print_info(id++, bo_va-
Quoted 1 line

base.bo, m);

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +0 -9
-	}
-	total_relocated_objs = id;
-	id = 0;
-
-	seq_puts(m, "\tMoved BOs:\n");
-	list_for_each_entry_safe(bo_va, tmp, &vm->moved, base.vm_status) {
-		if (!bo_va->base.bo)
-			continue;
-		total_moved += amdgpu_bo_print_info(id++, bo_va->base.bo,

m);

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +0 -7
-	}
-	total_moved_objs = id;
-	id = 0;
-
-	seq_puts(m, "\tInvalidated BOs:\n");
-	spin_lock(&vm->invalidated_lock);
-	list_for_each_entry_safe(bo_va, tmp, &vm->invalidated,

base.vm_status) {

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +0 -3
-		if (!bo_va->base.bo)
-			continue;
-		total_invalidated += amdgpu_bo_print_info(id++,
	bo_va->base.bo, m);
drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +0 -9
-	}
-	total_invalidated_objs = id;
-	id = 0;
-
-	seq_puts(m, "\tDone BOs:\n");
-	list_for_each_entry_safe(bo_va, tmp, &vm->done, base.vm_status) {
-		if (!bo_va->base.bo)
-			continue;
-		total_done += amdgpu_bo_print_info(id++, bo_va->base.bo,

m);

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +0 -7
-	}
-	spin_unlock(&vm->invalidated_lock);
-	total_done_objs = id;
-
-	seq_printf(m, "\tTotal idle size:        %12lld\tobjs:\t%d\n", total_idle,
-		   total_idle_objs);
-	seq_printf(m, "\tTotal evicted size:     %12lld\tobjs:\t%d\n",

total_evicted,

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +0 -2
-		   total_evicted_objs);
-	seq_printf(m, "\tTotal relocated size:   %12lld\tobjs:\t%d\n",

total_relocated,

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +0 -2
-		   total_relocated_objs);
-	seq_printf(m, "\tTotal moved size:       %12lld\tobjs:\t%d\n",

total_moved,

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +0 -2
-		   total_moved_objs);
-	seq_printf(m, "\tTotal invalidated size: %12lld\tobjs:\t%d\n",

total_invalidated,

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +0 -6
-		   total_invalidated_objs);
-	seq_printf(m, "\tTotal done size:        %12lld\tobjs:\t%d\n", total_done,
-		   total_done_objs);
-}
-#endif
--

2.17.1