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

Updates for 4.19.  Mostly bug fixes and cleanups.  Highlights:
- Internal API cleanup in GPU scheduler
- Decouple i2c and aux abstractions in DC
- Update maintainers
- Misc cleanups
- Misc bug fixes

Signed-off-by: Dave Airlie <airlied@redhat.com>
Link: https://patchwork.freedesktop.org/patch/msgid/20180725215326.2709-1-alexander.deucher@amd.com

1 files changed, 135 insertions, 69 deletions

diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c
index 386a7b34d2f4..ec53d8f96d06 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c
@@ -1926,7 +1926,7 @@ static void amdgpu_device_ip_late_init_func_handler(struct work_struct *work)
 }
 
 /**
- * amdgpu_device_ip_suspend - run suspend for hardware IPs
+ * amdgpu_device_ip_suspend_phase1 - run suspend for hardware IPs (phase 1)
  *
  * @adev: amdgpu_device pointer
  *
@@ -1936,7 +1936,55 @@ static void amdgpu_device_ip_late_init_func_handler(struct work_struct *work)
  * in each IP into a state suitable for suspend.
  * Returns 0 on success, negative error code on failure.
  */
-int amdgpu_device_ip_suspend(struct amdgpu_device *adev)
+static int amdgpu_device_ip_suspend_phase1(struct amdgpu_device *adev)
+{
+        int i, r;
+
+        if (amdgpu_sriov_vf(adev))
+                amdgpu_virt_request_full_gpu(adev, false);
+
+        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) {
+                        /* ungate blocks so that suspend can properly shut them down */
+                        if (adev->ip_blocks[i].version->funcs->set_clockgating_state) {
+                                r = adev->ip_blocks[i].version->funcs->set_clockgating_state((void *)adev,
+                                                                                             AMD_CG_STATE_UNGATE);
+                                if (r) {
+                                        DRM_ERROR("set_clockgating_state(ungate) of IP block <%s> failed %d\n",
+                                                  adev->ip_blocks[i].version->funcs->name, r);
+                                }
+                        }
+                        /* 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);
+                        }
+                }
+        }
+
+        if (amdgpu_sriov_vf(adev))
+                amdgpu_virt_release_full_gpu(adev, false);
+
+        return 0;
+}
+
+/**
+ * amdgpu_device_ip_suspend_phase2 - run suspend for hardware IPs (phase 2)
+ *
+ * @adev: amdgpu_device pointer
+ *
+ * Main suspend function for hardware IPs.  The list of all the hardware
+ * IPs that make up the asic is walked, clockgating is disabled and the
+ * suspend callbacks are run.  suspend puts the hardware and software state
+ * in each IP into a state suitable for suspend.
+ * Returns 0 on success, negative error code on failure.
+ */
+static int amdgpu_device_ip_suspend_phase2(struct amdgpu_device *adev)
 {
         int i, r;
 
@@ -1957,6 +2005,9 @@ int amdgpu_device_ip_suspend(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 in phase1 */
+                if (adev->ip_blocks[i].version->type == AMD_IP_BLOCK_TYPE_DCE)
+                        continue;
                 /* ungate blocks so that suspend can properly shut them down */
                 if (adev->ip_blocks[i].version->type != AMD_IP_BLOCK_TYPE_SMC &&
                         adev->ip_blocks[i].version->funcs->set_clockgating_state) {
@@ -1982,6 +2033,29 @@ int amdgpu_device_ip_suspend(struct amdgpu_device *adev)
         return 0;
 }
 
+/**
+ * amdgpu_device_ip_suspend - run suspend for hardware IPs
+ *
+ * @adev: amdgpu_device pointer
+ *
+ * Main suspend function for hardware IPs.  The list of all the hardware
+ * IPs that make up the asic is walked, clockgating is disabled and the
+ * suspend callbacks are run.  suspend puts the hardware and software state
+ * in each IP into a state suitable for suspend.
+ * Returns 0 on success, negative error code on failure.
+ */
+int amdgpu_device_ip_suspend(struct amdgpu_device *adev)
+{
+        int r;
+
+        r = amdgpu_device_ip_suspend_phase1(adev);
+        if (r)
+                return r;
+        r = amdgpu_device_ip_suspend_phase2(adev);
+
+        return r;
+}
+
 static int amdgpu_device_ip_reinit_early_sriov(struct amdgpu_device *adev)
 {
         int i, r;
@@ -2004,7 +2078,7 @@ static int amdgpu_device_ip_reinit_early_sriov(struct amdgpu_device *adev)
                                 continue;
 
                         r = block->version->funcs->hw_init(adev);
-                        DRM_INFO("RE-INIT: %s %s\n", block->version->funcs->name, r?"failed":"successed");
+                        DRM_INFO("RE-INIT: %s %s\n", block->version->funcs->name, r?"failed":"succeeded");
                         if (r)
                                 return r;
                 }
@@ -2039,7 +2113,7 @@ static int amdgpu_device_ip_reinit_late_sriov(struct amdgpu_device *adev)
                                 continue;
 
                         r = block->version->funcs->hw_init(adev);
-                        DRM_INFO("RE-INIT: %s %s\n", block->version->funcs->name, r?"failed":"successed");
+                        DRM_INFO("RE-INIT: %s %s\n", block->version->funcs->name, r?"failed":"succeeded");
                         if (r)
                                 return r;
                 }
@@ -2628,6 +2702,9 @@ int amdgpu_device_suspend(struct drm_device *dev, bool suspend, bool fbcon)
 
         drm_kms_helper_poll_disable(dev);
 
+        if (fbcon)
+                amdgpu_fbdev_set_suspend(adev, 1);
+
         if (!amdgpu_device_has_dc_support(adev)) {
                 /* turn off display hw */
                 drm_modeset_lock_all(dev);
@@ -2635,44 +2712,46 @@ int amdgpu_device_suspend(struct drm_device *dev, bool suspend, bool fbcon)
                         drm_helper_connector_dpms(connector, DRM_MODE_DPMS_OFF);
                 }
                 drm_modeset_unlock_all(dev);
-        }
-
-        amdgpu_amdkfd_suspend(adev);
-
-        /* 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) {
-                        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);
+                        /* 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) {
+                                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 || fb->obj[0] == NULL) {
-                        continue;
-                }
-                robj = gem_to_amdgpu_bo(fb->obj[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);
+                        if (fb == NULL || fb->obj[0] == NULL) {
+                                continue;
+                        }
+                        robj = gem_to_amdgpu_bo(fb->obj[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);
+
+        r = amdgpu_device_ip_suspend_phase1(adev);
+
         /* evict vram memory */
         amdgpu_bo_evict_vram(adev);
 
         amdgpu_fence_driver_suspend(adev);
 
-        r = amdgpu_device_ip_suspend(adev);
+        r = amdgpu_device_ip_suspend_phase2(adev);
 
         /* evict remaining vram memory
          * This second call to evict vram is to evict the gart page table
@@ -2691,11 +2770,6 @@ int amdgpu_device_suspend(struct drm_device *dev, bool suspend, bool fbcon)
                         DRM_ERROR("amdgpu asic reset failed\n");
         }
 
-        if (fbcon) {
-                console_lock();
-                amdgpu_fbdev_set_suspend(adev, 1);
-                console_unlock();
-        }
         return 0;
 }
 
@@ -2720,15 +2794,12 @@ int amdgpu_device_resume(struct drm_device *dev, bool resume, bool fbcon)
         if (dev->switch_power_state == DRM_SWITCH_POWER_OFF)
                 return 0;
 
-        if (fbcon)
-                console_lock();
-
         if (resume) {
                 pci_set_power_state(dev->pdev, PCI_D0);
                 pci_restore_state(dev->pdev);
                 r = pci_enable_device(dev->pdev);
                 if (r)
-                        goto unlock;
+                        return r;
         }
 
         /* post card */
@@ -2741,28 +2812,30 @@ int amdgpu_device_resume(struct drm_device *dev, bool resume, bool fbcon)
         r = amdgpu_device_ip_resume(adev);
         if (r) {
                 DRM_ERROR("amdgpu_device_ip_resume failed (%d).\n", r);
-                goto unlock;
+                return r;
         }
         amdgpu_fence_driver_resume(adev);
 
 
         r = amdgpu_device_ip_late_init(adev);
         if (r)
-                goto unlock;
-
-        /* 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) {
-                        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);
+                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) {
+                                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);
+                                }
                         }
                 }
         }
@@ -2783,6 +2856,7 @@ int amdgpu_device_resume(struct drm_device *dev, bool resume, bool fbcon)
                         }
                         drm_modeset_unlock_all(dev);
                 }
+                amdgpu_fbdev_set_suspend(adev, 0);
         }
 
         drm_kms_helper_poll_enable(dev);
@@ -2806,15 +2880,7 @@ int amdgpu_device_resume(struct drm_device *dev, bool resume, bool fbcon)
 #ifdef CONFIG_PM
         dev->dev->power.disable_depth--;
 #endif
-
-        if (fbcon)
-                amdgpu_fbdev_set_suspend(adev, 0);
-
-unlock:
-        if (fbcon)
-                console_unlock();
-
-        return r;
+        return 0;
 }
 
 /**
@@ -3091,7 +3157,7 @@ static int amdgpu_device_handle_vram_lost(struct amdgpu_device *adev)
  * @adev: amdgpu device pointer
  *
  * attempt to do soft-reset or full-reset and reinitialize Asic
- * return 0 means successed otherwise failed
+ * return 0 means succeeded otherwise failed
  */
 static int amdgpu_device_reset(struct amdgpu_device *adev)
 {
@@ -3169,7 +3235,7 @@ out:
  * @from_hypervisor: request from hypervisor
  *
  * do VF FLR and reinitialize Asic
- * return 0 means successed otherwise failed
+ * return 0 means succeeded otherwise failed
  */
 static int amdgpu_device_reset_sriov(struct amdgpu_device *adev,
                                      bool from_hypervisor)
@@ -3294,7 +3360,7 @@ int amdgpu_device_gpu_recover(struct amdgpu_device *adev,
                 dev_info(adev->dev, "GPU reset(%d) failed\n", atomic_read(&adev->gpu_reset_counter));
                 amdgpu_vf_error_put(adev, AMDGIM_ERROR_VF_GPU_RESET_FAIL, 0, r);
         } else {
-                dev_info(adev->dev, "GPU reset(%d) successed!\n",atomic_read(&adev->gpu_reset_counter));
+                dev_info(adev->dev, "GPU reset(%d) succeeded!\n",atomic_read(&adev->gpu_reset_counter));
         }
 
         amdgpu_vf_error_trans_all(adev);