drm/amdgpu: add amdgpu_bo_param

After that, we can easily add new parameter when need.

v2:
a) rebase.
b) Initialize struct amdgpu_bo_param, future new member could only be used in some one case, but all member should have its own initial value.

Change-Id I6e80039c3801f163129ecc605d931483fdbc91db

Signed-off-by Chunming Zhou <[email protected]>

Reviewed-by Huang Rui <[email protected]> (v1)

Reviewed-by Christian König <[email protected]> (v1)

Cc [email protected]

Cc [email protected]

---
  drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.c       | 12 +++--
  drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gpuvm.c | 11 ++++-
  drivers/gpu/drm/amd/amdgpu/amdgpu_benchmark.c    | 15 ++++--
  drivers/gpu/drm/amd/amdgpu/amdgpu_gart.c         | 17 ++++---
  drivers/gpu/drm/amd/amdgpu/amdgpu_gem.c          | 11 ++++-
  drivers/gpu/drm/amd/amdgpu/amdgpu_object.c       | 58 ++++++++++++------------
  drivers/gpu/drm/amd/amdgpu/amdgpu_object.h       |  6 +--
  drivers/gpu/drm/amd/amdgpu/amdgpu_prime.c        | 12 +++--
  drivers/gpu/drm/amd/amdgpu/amdgpu_test.c         | 18 +++++---
  drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c          | 15 ++++--
  drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c           | 26 ++++++++---
  11 files changed, 130 insertions(+), 71 deletions(-)

drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.c +9 -3

index 4d36203ffb11..887702c59488 100644
@@ -217,13 +217,19 @@ int alloc_gtt_mem(struct kgd_dev *kgd, size_t size,
  {
  	struct amdgpu_device *adev = (struct amdgpu_device *)kgd;
  	struct amdgpu_bo *bo = NULL;
+	struct amdgpu_bo_param bp;
  	int r;
  	uint64_t gpu_addr_tmp = 0;
  	void *cpu_ptr_tmp = NULL;
 
-	r = amdgpu_bo_create(adev, size, PAGE_SIZE, AMDGPU_GEM_DOMAIN_GTT,
-			     AMDGPU_GEM_CREATE_CPU_GTT_USWC, ttm_bo_type_kernel,
-			     NULL, &bo);
+	memset(&bp, 0, sizeof(bp));
+	bp.size = size;
+	bp.byte_align = PAGE_SIZE;
+	bp.domain = AMDGPU_GEM_DOMAIN_GTT;
+	bp.flags = AMDGPU_GEM_CREATE_CPU_GTT_USWC;
+	bp.type = ttm_bo_type_kernel;
+	bp.resv = NULL;
+	r = amdgpu_bo_create(adev, &bp, &bo);
  	if (r) {
  		dev_err(adev->dev,
  			"failed to allocate BO for amdkfd (%d)\n", r);

drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gpuvm.c +9 -2

index 1d6e1479da38..c1b0cdb401dc 100644
@@ -1004,6 +1004,7 @@ int amdgpu_amdkfd_gpuvm_alloc_memory_of_gpu(
  	struct amdgpu_device *adev = get_amdgpu_device(kgd);
  	struct amdgpu_vm *avm = (struct amdgpu_vm *)vm;
  	struct amdgpu_bo *bo;
+	struct amdgpu_bo_param bp;
  	int byte_align;
  	u32 alloc_domain;
  	u64 alloc_flags;

@@ -1069,8 +1070,14 @@ int amdgpu_amdkfd_gpuvm_alloc_memory_of_gpu(
  	pr_debug("\tcreate BO VA 0x%llx size 0x%llx domain %s\n",
  			va, size, domain_string(alloc_domain));
 
-	ret = amdgpu_bo_create(adev, size, byte_align,
-				alloc_domain, alloc_flags, ttm_bo_type_device, NULL, &bo);
+	memset(&bp, 0, sizeof(bp));
+	bp.size = size;
+	bp.byte_align = byte_align;
+	bp.domain = alloc_domain;
+	bp.flags = alloc_flags;
+	bp.type = ttm_bo_type_device;
+	bp.resv = NULL;
+	ret = amdgpu_bo_create(adev, &bp, &bo);
  	if (ret) {
  		pr_debug("Failed to create BO on domain %s. ret %d\n",
  				domain_string(alloc_domain), ret);

drivers/gpu/drm/amd/amdgpu/amdgpu_benchmark.c +11 -4

index 02b849be083b..19cfff31f2e1 100644
@@ -75,13 +75,20 @@ static void amdgpu_benchmark_move(struct amdgpu_device *adev, unsigned size,
  {
  	struct amdgpu_bo *dobj = NULL;
  	struct amdgpu_bo *sobj = NULL;
+	struct amdgpu_bo_param bp;
  	uint64_t saddr, daddr;
  	int r, n;
  	int time;
 
+	memset(&bp, 0, sizeof(bp));
+	bp.size = size;
+	bp.byte_align = PAGE_SIZE;
+	bp.domain = sdomain;
+	bp.flags = 0;
+	bp.type = ttm_bo_type_kernel;
+	bp.resv = NULL;
  	n = AMDGPU_BENCHMARK_ITERATIONS;
-	r = amdgpu_bo_create(adev, size, PAGE_SIZE,sdomain, 0,
-			     ttm_bo_type_kernel, NULL, &sobj);
+	r = amdgpu_bo_create(adev, &bp, &sobj);
  	if (r) {
  		goto out_cleanup;
  	}

@@ -93,8 +100,8 @@ static void amdgpu_benchmark_move(struct amdgpu_device *adev, unsigned size,
  	if (r) {
  		goto out_cleanup;
  	}
-	r = amdgpu_bo_create(adev, size, PAGE_SIZE, ddomain, 0,
-			     ttm_bo_type_kernel, NULL, &dobj);
+	bp.domain = ddomain;
+	r = amdgpu_bo_create(adev, &bp, &dobj);
  	if (r) {
  		goto out_cleanup;
  	}

drivers/gpu/drm/amd/amdgpu/amdgpu_gart.c +11 -6

index cf0f186c6092..17d6b9fb6d77 100644
@@ -113,12 +113,17 @@ int amdgpu_gart_table_vram_alloc(struct amdgpu_device *adev)
  	int r;
 
  	if (adev->gart.robj == NULL) {
-		r = amdgpu_bo_create(adev, adev->gart.table_size, PAGE_SIZE,
-				     AMDGPU_GEM_DOMAIN_VRAM,
-				     AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED |
-				     AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS,
-				     ttm_bo_type_kernel, NULL,
-				     &adev->gart.robj);
+		struct amdgpu_bo_param bp;
+
+		memset(&bp, 0, sizeof(bp));
+		bp.size = adev->gart.table_size;
+		bp.byte_align = PAGE_SIZE;
+		bp.domain = AMDGPU_GEM_DOMAIN_VRAM;
+		bp.flags = AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED |
+			AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS;
+		bp.type = ttm_bo_type_kernel;
+		bp.resv = NULL;
+		r = amdgpu_bo_create(adev, &bp, &adev->gart.robj);
  		if (r) {
  			return r;
  		}

drivers/gpu/drm/amd/amdgpu/amdgpu_gem.c +9 -2

index 46b9ea4e6103..1200c5ba37da 100644
@@ -48,17 +48,24 @@ int amdgpu_gem_object_create(struct amdgpu_device *adev, unsigned long size,
  			     struct drm_gem_object **obj)
  {
  	struct amdgpu_bo *bo;
+	struct amdgpu_bo_param bp;
  	int r;
 
+	memset(&bp, 0, sizeof(bp));
  	*obj = NULL;
  	/* At least align on page size */
  	if (alignment < PAGE_SIZE) {
  		alignment = PAGE_SIZE;
  	}
 
+	bp.size = size;
+	bp.byte_align = alignment;
+	bp.type = type;
+	bp.resv = resv;
  retry:
-	r = amdgpu_bo_create(adev, size, alignment, initial_domain,
-			     flags, type, resv, &bo);
+	bp.flags = flags;
+	bp.domain = initial_domain;
+	r = amdgpu_bo_create(adev, &bp, &bo);
  	if (r) {
  		if (r != -ERESTARTSYS) {
  			if (flags & AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED) {

drivers/gpu/drm/amd/amdgpu/amdgpu_object.c +29 -29

index b33a7fdea7f2..cac65e32a0b9 100644
@@ -191,14 +191,21 @@ int amdgpu_bo_create_reserved(struct amdgpu_device *adev,
  			      u32 domain, struct amdgpu_bo **bo_ptr,
  			      u64 *gpu_addr, void **cpu_addr)
  {
+	struct amdgpu_bo_param bp;
  	bool free = false;
  	int r;
 
+	memset(&bp, 0, sizeof(bp));
+	bp.size = size;
+	bp.byte_align = align;
+	bp.domain = domain;
+	bp.flags = AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED |
+		AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS;
+	bp.type = ttm_bo_type_kernel;
+	bp.resv = NULL;
+
  	if (!*bo_ptr) {
-		r = amdgpu_bo_create(adev, size, align, domain,
-				     AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED |
-				     AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS,
-				     ttm_bo_type_kernel, NULL, bo_ptr);
+		r = amdgpu_bo_create(adev, &bp, bo_ptr);
  		if (r) {
  			dev_err(adev->dev, "(%d) failed to allocate kernel bo\n",
  				r);

@@ -470,20 +477,21 @@ static int amdgpu_bo_create_shadow(struct amdgpu_device *adev,
  				   unsigned long size, int byte_align,
  				   struct amdgpu_bo *bo)
  {
-	struct amdgpu_bo_param bp = {
-		.size = size,
-		.byte_align = byte_align,
-		.domain = AMDGPU_GEM_DOMAIN_GTT,
-		.flags = AMDGPU_GEM_CREATE_CPU_GTT_USWC |
-			AMDGPU_GEM_CREATE_SHADOW,
-		.type = ttm_bo_type_kernel,
-		.resv = bo->tbo.resv
-	};
+	struct amdgpu_bo_param bp;
  	int r;
 
  	if (bo->shadow)
  		return 0;
 
+	memset(&bp, 0, sizeof(bp));
+	bp.size = size;
+	bp.byte_align = byte_align;
+	bp.domain = AMDGPU_GEM_DOMAIN_GTT;
+	bp.flags = AMDGPU_GEM_CREATE_CPU_GTT_USWC |
+		AMDGPU_GEM_CREATE_SHADOW;
+	bp.type = ttm_bo_type_kernel;
+	bp.resv = bo->tbo.resv;
+
  	r = amdgpu_bo_do_create(adev, &bp, &bo->shadow);
  	if (!r) {
  		bo->shadow->parent = amdgpu_bo_ref(bo);

@@ -495,34 +503,26 @@ static int amdgpu_bo_create_shadow(struct amdgpu_device *adev,
  	return r;
  }
 
-int amdgpu_bo_create(struct amdgpu_device *adev, unsigned long size,
-		     int byte_align, u32 domain,
-		     u64 flags, enum ttm_bo_type type,
-		     struct reservation_object *resv,
+int amdgpu_bo_create(struct amdgpu_device *adev,
+		     struct amdgpu_bo_param *bp,
  		     struct amdgpu_bo **bo_ptr)
  {
-	struct amdgpu_bo_param bp = {
-		.size = size,
-		.byte_align = byte_align,
-		.domain = domain,
-		.flags = flags & ~AMDGPU_GEM_CREATE_SHADOW,
-		.type = type,
-		.resv = resv
-	};
+	u64 flags = bp->flags;
  	int r;
 
-	r = amdgpu_bo_do_create(adev, &bp, bo_ptr);
+	bp->flags = bp->flags & ~AMDGPU_GEM_CREATE_SHADOW;
+	r = amdgpu_bo_do_create(adev, bp, bo_ptr);
  	if (r)
  		return r;
 
  	if ((flags & AMDGPU_GEM_CREATE_SHADOW) && amdgpu_need_backup(adev)) {
-		if (!resv)
+		if (!bp->resv)
  			WARN_ON(reservation_object_lock((*bo_ptr)->tbo.resv,
  							NULL));
 
-		r = amdgpu_bo_create_shadow(adev, size, byte_align, (*bo_ptr));
+		r = amdgpu_bo_create_shadow(adev, bp->size, bp->byte_align, (*bo_ptr));
 
-		if (!resv)
+		if (!bp->resv)
  			reservation_object_unlock((*bo_ptr)->tbo.resv);
 
  		if (r)

drivers/gpu/drm/amd/amdgpu/amdgpu_object.h +2 -4

index 4bb6f0a8d799..e9a21d991e77 100644
@@ -233,10 +233,8 @@ static inline bool amdgpu_bo_explicit_sync(struct amdgpu_bo *bo)
  	return bo->flags & AMDGPU_GEM_CREATE_EXPLICIT_SYNC;
  }
 
-int amdgpu_bo_create(struct amdgpu_device *adev, unsigned long size,
-		     int byte_align, u32 domain,
-		     u64 flags, enum ttm_bo_type type,
-		     struct reservation_object *resv,
+int amdgpu_bo_create(struct amdgpu_device *adev,
+		     struct amdgpu_bo_param *bp,
  		     struct amdgpu_bo **bo_ptr);
  int amdgpu_bo_create_reserved(struct amdgpu_device *adev,
  			      unsigned long size, int align,

drivers/gpu/drm/amd/amdgpu/amdgpu_prime.c +9 -3

index 4b584cb75bf4..713417b6d15d 100644
@@ -102,12 +102,18 @@ amdgpu_gem_prime_import_sg_table(struct drm_device *dev,
  	struct reservation_object *resv = attach->dmabuf->resv;
  	struct amdgpu_device *adev = dev->dev_private;
  	struct amdgpu_bo *bo;
+	struct amdgpu_bo_param bp;
  	int ret;
 
+	memset(&bp, 0, sizeof(bp));
+	bp.size = attach->dmabuf->size;
+	bp.byte_align = PAGE_SIZE;
+	bp.domain = AMDGPU_GEM_DOMAIN_CPU;
+	bp.flags = 0;
+	bp.type = ttm_bo_type_sg;
+	bp.resv = resv;
  	ww_mutex_lock(&resv->lock, NULL);
-	ret = amdgpu_bo_create(adev, attach->dmabuf->size, PAGE_SIZE,
-			       AMDGPU_GEM_DOMAIN_CPU, 0, ttm_bo_type_sg,
-			       resv, &bo);
+	ret = amdgpu_bo_create(adev, &bp, &bo);
  	if (ret)
  		goto error;
 

drivers/gpu/drm/amd/amdgpu/amdgpu_test.c +12 -6

index 2dbe87591f81..d167e8ab76d3 100644
@@ -33,6 +33,7 @@ static void amdgpu_do_test_moves(struct amdgpu_device *adev)
  	struct amdgpu_ring *ring = adev->mman.buffer_funcs_ring;
  	struct amdgpu_bo *vram_obj = NULL;
  	struct amdgpu_bo **gtt_obj = NULL;
+	struct amdgpu_bo_param bp;
  	uint64_t gart_addr, vram_addr;
  	unsigned n, size;
  	int i, r;

@@ -58,9 +59,15 @@ static void amdgpu_do_test_moves(struct amdgpu_device *adev)
  		r = 1;
  		goto out_cleanup;
  	}
-
-	r = amdgpu_bo_create(adev, size, PAGE_SIZE, AMDGPU_GEM_DOMAIN_VRAM, 0,
-			     ttm_bo_type_kernel, NULL, &vram_obj);
+	memset(&bp, 0, sizeof(bp));
+	bp.size = size;
+	bp.byte_align = PAGE_SIZE;
+	bp.domain = AMDGPU_GEM_DOMAIN_VRAM;
+	bp.flags = 0;
+	bp.type = ttm_bo_type_kernel;
+	bp.resv = NULL;
+
+	r = amdgpu_bo_create(adev, &bp, &vram_obj);
  	if (r) {
  		DRM_ERROR("Failed to create VRAM object\n");
  		goto out_cleanup;

@@ -79,9 +86,8 @@ static void amdgpu_do_test_moves(struct amdgpu_device *adev)
  		void **vram_start, **vram_end;
  		struct dma_fence *fence = NULL;
 
-		r = amdgpu_bo_create(adev, size, PAGE_SIZE,
-				     AMDGPU_GEM_DOMAIN_GTT, 0,
-				     ttm_bo_type_kernel, NULL, gtt_obj + i);
+		bp.domain = AMDGPU_GEM_DOMAIN_GTT;
+		r = amdgpu_bo_create(adev, &bp, gtt_obj + i);
  		if (r) {
  			DRM_ERROR("Failed to create GTT object %d\n", i);
  			goto out_lclean;

drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c +10 -5

index 29efaac6e3ed..dfd22db13fb1 100644
@@ -1316,6 +1316,7 @@ static void amdgpu_ttm_fw_reserve_vram_fini(struct amdgpu_device *adev)
  static int amdgpu_ttm_fw_reserve_vram_init(struct amdgpu_device *adev)
  {
  	struct ttm_operation_ctx ctx = { false, false };
+	struct amdgpu_bo_param bp;
  	int r = 0;
  	int i;
  	u64 vram_size = adev->gmc.visible_vram_size;

@@ -1323,17 +1324,21 @@ static int amdgpu_ttm_fw_reserve_vram_init(struct amdgpu_device *adev)
  	u64 size = adev->fw_vram_usage.size;
  	struct amdgpu_bo *bo;
 
+	memset(&bp, 0, sizeof(bp));
+	bp.size = adev->fw_vram_usage.size;
+	bp.byte_align = PAGE_SIZE;
+	bp.domain = AMDGPU_GEM_DOMAIN_VRAM;
+	bp.flags = AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED |
+		AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS;
+	bp.type = ttm_bo_type_kernel;
+	bp.resv = NULL;
  	adev->fw_vram_usage.va = NULL;
  	adev->fw_vram_usage.reserved_bo = NULL;
 
  	if (adev->fw_vram_usage.size > 0 &&
  		adev->fw_vram_usage.size <= vram_size) {
 
-		r = amdgpu_bo_create(adev, adev->fw_vram_usage.size, PAGE_SIZE,
-				     AMDGPU_GEM_DOMAIN_VRAM,
-				     AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED |
-				     AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS,
-				     ttm_bo_type_kernel, NULL,
+		r = amdgpu_bo_create(adev, &bp,
  				     &adev->fw_vram_usage.reserved_bo);
  		if (r)
  			goto error_create;

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +12 -7

index f0fbc331aa30..9ec7c1041df2 100644
@@ -412,11 +412,16 @@ static int amdgpu_vm_alloc_levels(struct amdgpu_device *adev,
  		struct amdgpu_bo *pt;
 
  		if (!entry->base.bo) {
-			r = amdgpu_bo_create(adev,
-					     amdgpu_vm_bo_size(adev, level),
-					     AMDGPU_GPU_PAGE_SIZE,
-					     AMDGPU_GEM_DOMAIN_VRAM, flags,
-					     ttm_bo_type_kernel, resv, &pt);
+			struct amdgpu_bo_param 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.flags = flags;
+			bp.type = ttm_bo_type_kernel;
+			bp.resv = resv;
+			r = amdgpu_bo_create(adev, &bp, &pt);
  			if (r)
  				return r;
 

@@ -2368,6 +2373,7 @@ void amdgpu_vm_adjust_size(struct amdgpu_device *adev, uint32_t vm_size,
  int amdgpu_vm_init(struct amdgpu_device *adev, struct amdgpu_vm *vm,
  		   int vm_context, unsigned int pasid)
  {
+	struct amdgpu_bo_param bp;
  	const unsigned align = min(AMDGPU_VM_PTB_ALIGN_SIZE,
  		AMDGPU_VM_PTE_COUNT(adev) * 8);
  	unsigned ring_instance;

@@ -2422,8 +2428,14 @@ int amdgpu_vm_init(struct amdgpu_device *adev, struct amdgpu_vm *vm,
  		flags |= AMDGPU_GEM_CREATE_SHADOW;
 
  	size = amdgpu_vm_bo_size(adev, adev->vm_manager.root_level);
-	r = amdgpu_bo_create(adev, size, align, AMDGPU_GEM_DOMAIN_VRAM, flags,
-			     ttm_bo_type_kernel, NULL, &vm->root.base.bo);
+	memset(&bp, 0, sizeof(bp));

amdgpu_bo_create has too many parameters, and used in too many places. Collect them to one structure.

Change-Id Ib2aa98ee37a70f3cb0d61eef1d336e89187554d5

Signed-off-by Chunming Zhou <[email protected]>

Reviewed-by Huang Rui <[email protected]>

Reviewed-by Christian König <[email protected]>

---
  drivers/gpu/drm/amd/amdgpu/amdgpu_object.c | 75 +++++++++++++++++-------------
  drivers/gpu/drm/amd/amdgpu/amdgpu_object.h |  9 ++++
  2 files changed, 51 insertions(+), 33 deletions(-)

drivers/gpu/drm/amd/amdgpu/amdgpu_object.c +42 -33

index 24f582c696cc..b33a7fdea7f2 100644
@@ -341,27 +341,25 @@ static bool amdgpu_bo_validate_size(struct amdgpu_device *adev,
  	return false;
  }
 
-static int amdgpu_bo_do_create(struct amdgpu_device *adev, unsigned long size,
-			       int byte_align, u32 domain,
-			       u64 flags, enum ttm_bo_type type,
-			       struct reservation_object *resv,
+static int amdgpu_bo_do_create(struct amdgpu_device *adev,
+			       struct amdgpu_bo_param *bp,
  			       struct amdgpu_bo **bo_ptr)
  {
  	struct ttm_operation_ctx ctx = {
-		.interruptible = (type != ttm_bo_type_kernel),
+		.interruptible = (bp->type != ttm_bo_type_kernel),
  		.no_wait_gpu = false,
-		.resv = resv,
+		.resv = bp->resv,
  		.flags = TTM_OPT_FLAG_ALLOW_RES_EVICT
  	};
  	struct amdgpu_bo *bo;
-	unsigned long page_align;
+	unsigned long page_align, size = bp->size;
  	size_t acc_size;
  	int r;
 
-	page_align = roundup(byte_align, PAGE_SIZE) >> PAGE_SHIFT;
+	page_align = roundup(bp->byte_align, PAGE_SIZE) >> PAGE_SHIFT;
  	size = ALIGN(size, PAGE_SIZE);
 
-	if (!amdgpu_bo_validate_size(adev, size, domain))
+	if (!amdgpu_bo_validate_size(adev, size, bp->domain))
  		return -ENOMEM;
 
  	*bo_ptr = NULL;

@@ -375,18 +373,18 @@ static int amdgpu_bo_do_create(struct amdgpu_device *adev, unsigned long size,
  	drm_gem_private_object_init(adev->ddev, &bo->gem_base, size);
  	INIT_LIST_HEAD(&bo->shadow_list);
  	INIT_LIST_HEAD(&bo->va);
-	bo->preferred_domains = domain & (AMDGPU_GEM_DOMAIN_VRAM |
-					 AMDGPU_GEM_DOMAIN_GTT |
-					 AMDGPU_GEM_DOMAIN_CPU |
-					 AMDGPU_GEM_DOMAIN_GDS |
-					 AMDGPU_GEM_DOMAIN_GWS |
-					 AMDGPU_GEM_DOMAIN_OA);
+	bo->preferred_domains = bp->domain & (AMDGPU_GEM_DOMAIN_VRAM |
+					      AMDGPU_GEM_DOMAIN_GTT |
+					      AMDGPU_GEM_DOMAIN_CPU |
+					      AMDGPU_GEM_DOMAIN_GDS |
+					      AMDGPU_GEM_DOMAIN_GWS |
+					      AMDGPU_GEM_DOMAIN_OA);
  	bo->allowed_domains = bo->preferred_domains;
-	if (type != ttm_bo_type_kernel &&
+	if (bp->type != ttm_bo_type_kernel &&
  	    bo->allowed_domains == AMDGPU_GEM_DOMAIN_VRAM)
  		bo->allowed_domains |= AMDGPU_GEM_DOMAIN_GTT;
 
-	bo->flags = flags;
+	bo->flags = bp->flags;
 
  #ifdef CONFIG_X86_32
  	/* XXX: Write-combined CPU mappings of GTT seem broken on 32-bit

@@ -417,11 +415,11 @@ static int amdgpu_bo_do_create(struct amdgpu_device *adev, unsigned long size,
  #endif
 
  	bo->tbo.bdev = &adev->mman.bdev;
-	amdgpu_ttm_placement_from_domain(bo, domain);
+	amdgpu_ttm_placement_from_domain(bo, bp->domain);
 
-	r = ttm_bo_init_reserved(&adev->mman.bdev, &bo->tbo, size, type,
+	r = ttm_bo_init_reserved(&adev->mman.bdev, &bo->tbo, size, bp->type,
  				 &bo->placement, page_align, &ctx, acc_size,
-				 NULL, resv, &amdgpu_ttm_bo_destroy);
+				 NULL, bp->resv, &amdgpu_ttm_bo_destroy);
  	if (unlikely(r != 0))
  		return r;
 

@@ -433,10 +431,10 @@ static int amdgpu_bo_do_create(struct amdgpu_device *adev, unsigned long size,
  	else
  		amdgpu_cs_report_moved_bytes(adev, ctx.bytes_moved, 0);
 
-	if (type == ttm_bo_type_kernel)
+	if (bp->type == ttm_bo_type_kernel)
  		bo->tbo.priority = 1;
 
-	if (flags & AMDGPU_GEM_CREATE_VRAM_CLEARED &&
+	if (bp->flags & AMDGPU_GEM_CREATE_VRAM_CLEARED &&
  	    bo->tbo.mem.placement & TTM_PL_FLAG_VRAM) {
  		struct dma_fence *fence;
 

@@ -449,20 +447,20 @@ static int amdgpu_bo_do_create(struct amdgpu_device *adev, unsigned long size,
  		bo->tbo.moving = dma_fence_get(fence);
  		dma_fence_put(fence);
  	}
-	if (!resv)
+	if (!bp->resv)
  		amdgpu_bo_unreserve(bo);
  	*bo_ptr = bo;
 
  	trace_amdgpu_bo_create(bo);
 
  	/* Treat CPU_ACCESS_REQUIRED only as a hint if given by UMD */
-	if (type == ttm_bo_type_device)
+	if (bp->type == ttm_bo_type_device)
  		bo->flags &= ~AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED;
 
  	return 0;
 
  fail_unreserve:
-	if (!resv)
+	if (!bp->resv)
  		ww_mutex_unlock(&bo->tbo.resv->lock);
  	amdgpu_bo_unref(&bo);
  	return r;

@@ -472,16 +470,21 @@ static int amdgpu_bo_create_shadow(struct amdgpu_device *adev,
  				   unsigned long size, int byte_align,
  				   struct amdgpu_bo *bo)
  {
+	struct amdgpu_bo_param bp = {
+		.size = size,
+		.byte_align = byte_align,
+		.domain = AMDGPU_GEM_DOMAIN_GTT,
+		.flags = AMDGPU_GEM_CREATE_CPU_GTT_USWC |
+			AMDGPU_GEM_CREATE_SHADOW,
+		.type = ttm_bo_type_kernel,
+		.resv = bo->tbo.resv
+	};
  	int r;
 
  	if (bo->shadow)
  		return 0;
 
-	r = amdgpu_bo_do_create(adev, size, byte_align, AMDGPU_GEM_DOMAIN_GTT,
-				AMDGPU_GEM_CREATE_CPU_GTT_USWC |
-				AMDGPU_GEM_CREATE_SHADOW,
-				ttm_bo_type_kernel,
-				bo->tbo.resv, &bo->shadow);
+	r = amdgpu_bo_do_create(adev, &bp, &bo->shadow);
  	if (!r) {
  		bo->shadow->parent = amdgpu_bo_ref(bo);
  		mutex_lock(&adev->shadow_list_lock);

@@ -498,11 +501,17 @@ int amdgpu_bo_create(struct amdgpu_device *adev, unsigned long size,
  		     struct reservation_object *resv,
  		     struct amdgpu_bo **bo_ptr)
  {
-	uint64_t parent_flags = flags & ~AMDGPU_GEM_CREATE_SHADOW;
+	struct amdgpu_bo_param bp = {
+		.size = size,
+		.byte_align = byte_align,
+		.domain = domain,
+		.flags = flags & ~AMDGPU_GEM_CREATE_SHADOW,
+		.type = type,
+		.resv = resv
+	};
  	int r;
 
-	r = amdgpu_bo_do_create(adev, size, byte_align, domain,
-				parent_flags, type, resv, bo_ptr);
+	r = amdgpu_bo_do_create(adev, &bp, bo_ptr);
  	if (r)
  		return r;
 

drivers/gpu/drm/amd/amdgpu/amdgpu_object.h +2 -0

index 1e9fe85abcbb..4bb6f0a8d799 100644
@@ -33,6 +33,15 @@
 
  #define AMDGPU_BO_INVALID_OFFSET	LONG_MAX
 
+struct amdgpu_bo_param {
+	unsigned long			size;