drm/amdgpu: use amdgpu_bo_param for amdgpu_bo_create v2

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.

Signed-off-by: Chunming Zhou <david1.zhou@amd.com>
Reviewed-by: Huang Rui <ray.huang@amd.com> (v1)
Reviewed-by: Christian König <christian.koenig@amd.com>
Reviewed-by: Junwei Zhang <Jerry.Zhang@amd.com>
Cc: christian.koenig@amd.com
Cc: Felix.Kuehling@amd.com
Signed-off-by: Alex Deucher <alexander.deucher@amd.com>

diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.c
index 4d36203..887702c 100644 (file)
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.c
@@ -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);

diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gpuvm.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gpuvm.c
index 1d6e147..c1b0cdb 100644 (file)
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gpuvm.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gpuvm.c
@@ -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);

diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_benchmark.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_benchmark.c
index 02b849b..19cfff3 100644 (file)
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_benchmark.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_benchmark.c
@@ -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;
        }

diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_gart.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_gart.c
index cf0f186..17d6b9f 100644 (file)
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_gart.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_gart.c
@@ -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;
                }

diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_gem.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_gem.c
index 46b9ea4..1200c5b 100644 (file)
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_gem.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_gem.c
@@ -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) {

diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_object.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_object.c
index b33a7fd..cac65e3 100644 (file)
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_object.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_object.c
@@ -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)

diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_object.h b/drivers/gpu/drm/amd/amdgpu/amdgpu_object.h
index 4bb6f0a..e9a21d9 100644 (file)
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_object.h
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_object.h
@@ -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,

diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_prime.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_prime.c
index 4b584cb..713417b 100644 (file)
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_prime.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_prime.c
@@ -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;
 

diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_test.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_test.c
index 2dbe875..d167e8a 100644 (file)
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_test.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_test.c
@@ -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;

diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c
index 29efaac..dfd22db 100644 (file)
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c
@@ -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;

diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c
index f0fbc33..9ec7c10 100644 (file)
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c
@@ -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));
+       bp.size = size;
+       bp.byte_align = align;
+       bp.domain = AMDGPU_GEM_DOMAIN_VRAM;
+       bp.flags = flags;
+       bp.type = ttm_bo_type_kernel;
+       bp.resv = NULL;
+       r = amdgpu_bo_create(adev, &bp, &vm->root.base.bo);
        if (r)
                goto error_free_sched_entity;