Merge branch 'next-keys2' of git://git.kernel.org/pub/scm/linux/kernel/git/jmorris...

[linux.git] / drivers / gpu / drm / amd / amdgpu / amdgpu_object.c

diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_object.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_object.c
index c1387efc0c91b8ddc3dfac4d69bc74c5541c14e6..904014dc5915f8142dd0dc6c169a76bacbaf7e9f 100644 (file)
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_object.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_object.c
@@ -51,18 +51,6 @@
  *
  */
 
  *
  */
 

-static bool amdgpu_bo_need_backup(struct amdgpu_device *adev)
-{
-       if (adev->flags & AMD_IS_APU)
-               return false;
-
-       if (amdgpu_gpu_recovery == 0 ||
-           (amdgpu_gpu_recovery == -1  && !amdgpu_sriov_vf(adev)))
-               return false;
-
-       return true;
-}
-

 /**
  * amdgpu_bo_subtract_pin_size - Remove BO from pin_size accounting
  *
 /**
  * amdgpu_bo_subtract_pin_size - Remove BO from pin_size accounting
  *


@@ -439,7 +427,11 @@ static int amdgpu_bo_do_create(struct amdgpu_device *adev,
        int r;
 
        page_align = roundup(bp->byte_align, PAGE_SIZE) >> PAGE_SHIFT;
        int r;
 
        page_align = roundup(bp->byte_align, PAGE_SIZE) >> PAGE_SHIFT;

-       size = ALIGN(size, PAGE_SIZE);
+       if (bp->domain & (AMDGPU_GEM_DOMAIN_GDS | AMDGPU_GEM_DOMAIN_GWS |
+                         AMDGPU_GEM_DOMAIN_OA))
+               size <<= PAGE_SHIFT;
+       else
+               size = ALIGN(size, PAGE_SIZE);

 
        if (!amdgpu_bo_validate_size(adev, size, bp->domain))
                return -ENOMEM;
 
        if (!amdgpu_bo_validate_size(adev, size, bp->domain))
                return -ENOMEM;


@@ -544,7 +536,7 @@ fail_unreserve:
 }
 
 static int amdgpu_bo_create_shadow(struct amdgpu_device *adev,
 }
 
 static int amdgpu_bo_create_shadow(struct amdgpu_device *adev,

-                                  unsigned long size, int byte_align,
+                                  unsigned long size,

                                   struct amdgpu_bo *bo)
 {
        struct amdgpu_bo_param bp;
                                   struct amdgpu_bo *bo)
 {
        struct amdgpu_bo_param bp;


@@ -555,7 +547,6 @@ static int amdgpu_bo_create_shadow(struct amdgpu_device *adev,
 
        memset(&bp, 0, sizeof(bp));
        bp.size = size;
 
        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.domain = AMDGPU_GEM_DOMAIN_GTT;
        bp.flags = AMDGPU_GEM_CREATE_CPU_GTT_USWC |
                AMDGPU_GEM_CREATE_SHADOW;


@@ -566,7 +557,7 @@ static int amdgpu_bo_create_shadow(struct amdgpu_device *adev,
        if (!r) {
                bo->shadow->parent = amdgpu_bo_ref(bo);
                mutex_lock(&adev->shadow_list_lock);
        if (!r) {
                bo->shadow->parent = amdgpu_bo_ref(bo);
                mutex_lock(&adev->shadow_list_lock);

-               list_add_tail(&bo->shadow_list, &adev->shadow_list);
+               list_add_tail(&bo->shadow->shadow_list, &adev->shadow_list);

                mutex_unlock(&adev->shadow_list_lock);
        }
 
                mutex_unlock(&adev->shadow_list_lock);
        }
 


@@ -599,12 +590,12 @@ int amdgpu_bo_create(struct amdgpu_device *adev,
        if (r)
                return r;
 
        if (r)
                return r;
 

-       if ((flags & AMDGPU_GEM_CREATE_SHADOW) && amdgpu_bo_need_backup(adev)) {
+       if ((flags & AMDGPU_GEM_CREATE_SHADOW) && !(adev->flags & AMD_IS_APU)) {

                if (!bp->resv)
                        WARN_ON(reservation_object_lock((*bo_ptr)->tbo.resv,
                                                        NULL));
 
                if (!bp->resv)
                        WARN_ON(reservation_object_lock((*bo_ptr)->tbo.resv,
                                                        NULL));
 

-               r = amdgpu_bo_create_shadow(adev, bp->size, bp->byte_align, (*bo_ptr));
+               r = amdgpu_bo_create_shadow(adev, bp->size, *bo_ptr);

 
                if (!bp->resv)
                        reservation_object_unlock((*bo_ptr)->tbo.resv);
 
                if (!bp->resv)
                        reservation_object_unlock((*bo_ptr)->tbo.resv);


@@ -698,13 +689,10 @@ retry:
 }
 
 /**
 }
 
 /**

- * amdgpu_bo_restore_from_shadow - restore an &amdgpu_bo buffer object
- * @adev: amdgpu device object
- * @ring: amdgpu_ring for the engine handling the buffer operations
- * @bo: &amdgpu_bo buffer to be restored
- * @resv: reservation object with embedded fence
+ * amdgpu_bo_restore_shadow - restore an &amdgpu_bo shadow
+ *
+ * @shadow: &amdgpu_bo shadow to be restored

  * @fence: dma_fence associated with the operation
  * @fence: dma_fence associated with the operation

- * @direct: whether to submit the job directly

  *
  * Copies a buffer object's shadow content back to the object.
  * This is used for recovering a buffer from its shadow in case of a gpu
  *
  * Copies a buffer object's shadow content back to the object.
  * This is used for recovering a buffer from its shadow in case of a gpu


@@ -713,36 +701,19 @@ retry:
  * Returns:
  * 0 for success or a negative error code on failure.
  */
  * Returns:
  * 0 for success or a negative error code on failure.
  */

-int amdgpu_bo_restore_from_shadow(struct amdgpu_device *adev,
-                                 struct amdgpu_ring *ring,
-                                 struct amdgpu_bo *bo,
-                                 struct reservation_object *resv,
-                                 struct dma_fence **fence,
-                                 bool direct)
+int amdgpu_bo_restore_shadow(struct amdgpu_bo *shadow, struct dma_fence **fence)

 
 {
 
 {

-       struct amdgpu_bo *shadow = bo->shadow;
-       uint64_t bo_addr, shadow_addr;
-       int r;
+       struct amdgpu_device *adev = amdgpu_ttm_adev(shadow->tbo.bdev);
+       struct amdgpu_ring *ring = adev->mman.buffer_funcs_ring;
+       uint64_t shadow_addr, parent_addr;

 
 

-       if (!shadow)
-               return -EINVAL;
-
-       bo_addr = amdgpu_bo_gpu_offset(bo);
-       shadow_addr = amdgpu_bo_gpu_offset(bo->shadow);
-
-       r = reservation_object_reserve_shared(bo->tbo.resv);
-       if (r)
-               goto err;
+       shadow_addr = amdgpu_bo_gpu_offset(shadow);
+       parent_addr = amdgpu_bo_gpu_offset(shadow->parent);

 
 

-       r = amdgpu_copy_buffer(ring, shadow_addr, bo_addr,
-                              amdgpu_bo_size(bo), resv, fence,
-                              direct, false);
-       if (!r)
-               amdgpu_bo_fence(bo, *fence, true);
-
-err:
-       return r;
+       return amdgpu_copy_buffer(ring, shadow_addr, parent_addr,
+                                 amdgpu_bo_size(shadow), NULL, fence,
+                                 true, false);

 }
 
 /**
 }
 
 /**


@@ -1366,7 +1337,7 @@ u64 amdgpu_bo_gpu_offset(struct amdgpu_bo *bo)
 {
        WARN_ON_ONCE(bo->tbo.mem.mem_type == TTM_PL_SYSTEM);
        WARN_ON_ONCE(!ww_mutex_is_locked(&bo->tbo.resv->lock) &&
 {
        WARN_ON_ONCE(bo->tbo.mem.mem_type == TTM_PL_SYSTEM);
        WARN_ON_ONCE(!ww_mutex_is_locked(&bo->tbo.resv->lock) &&

-                    !bo->pin_count);
+                    !bo->pin_count && bo->tbo.type != ttm_bo_type_kernel);

        WARN_ON_ONCE(bo->tbo.mem.start == AMDGPU_BO_INVALID_OFFSET);
        WARN_ON_ONCE(bo->tbo.mem.mem_type == TTM_PL_VRAM &&
                     !(bo->flags & AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS));
        WARN_ON_ONCE(bo->tbo.mem.start == AMDGPU_BO_INVALID_OFFSET);
        WARN_ON_ONCE(bo->tbo.mem.mem_type == TTM_PL_VRAM &&
                     !(bo->flags & AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS));