Skip to contentSkip to conversation

vlv: add support for RPM

PATCH Superseded Imre Deak 5 participants 40 messages Apr 8, 2014 – Apr 16, 2014

Subsystems (2)

v1 of 2 Superseded Latest is v2 →

lore
Share & tools
lore

Imre Deak

author
#0 lore raw

cover vlv: add support for RPM

This adds the required helpers for saving/restoring HW context when going to D3 (and possibly to S0ix afterwards) state on VLV and then enables RPM.

Since we depend on the RC6 power context mechanism to save some state this also touches generic RPM parts, so that RPM is only enabled after the delayed RC6 enabling completes.

For more details on the VLV specific parts see patches 13 and 14.

I also included a related bugfix that Daniel and Paulo were also looking at (patch 7).

I tested this with igt/kms_flip and pm_pc8 on VLV/DP, they seem to pass fine, although I'm not sure that pm_pc8 goes through all interesting paths, I'm planning to check this next.

Imre Deak (15):
drm/i915: vlv: clean up GTLC wake control/status register macros drm/i915: vlv: clear master interrupt flag when disabling interrupts drm/i915: vlv: add RC6 residency counters
drm/i915: fix rc6 status debug print
drm/i915: take init power domain for sysfs/debugfs entries where
needed
drm/i915: get init power domain for gpu error state capture drm/i915: vlv: check port power domain instead of only D0 for eDP VDD
on
drm/i915: vlv: setup RPS min/max frequencies once during init time drm/i915: vlv: factor out vlv_force_gfx_clock
drm/i915: disable runtime PM until delayed RPS/RC6 enabling completes drm/i915: vlv: disable RPM if RC6 is not enabled
drm/i915: add various missing GTI/Gunit register definitions drm/i915: vlv: add gunit s0ix save/restore helpers drm/i915: vlv: add runtime PM support
drm/i915: vlv: enable RPM

 drivers/gpu/drm/i915/i915_debugfs.c |  22 +-
 drivers/gpu/drm/i915/i915_drv.c     | 399 +++++++++++++++++++++++++++++++++++-
 drivers/gpu/drm/i915/i915_drv.h     |  65 +++++-
 drivers/gpu/drm/i915/i915_gem.c     |   5 +-
 drivers/gpu/drm/i915/i915_irq.c     |   6 +
 drivers/gpu/drm/i915/i915_reg.h     |  56 ++++-
 drivers/gpu/drm/i915/i915_sysfs.c   |   4 +
 drivers/gpu/drm/i915/intel_dp.c     |   6 +-
 drivers/gpu/drm/i915/intel_drv.h    |   3 +
 drivers/gpu/drm/i915/intel_pm.c     | 136 ++++++++----
 10 files changed, 647 insertions(+), 55 deletions(-)
Signature · 1 line
1.8.4
author
#1 lore raw

PATCH 1/15 drm/i915: vlv: clean up GTLC wake control/status register macros

These will be needed by the upcoming VLV RPM helpers.

---
 drivers/gpu/drm/i915/i915_gem.c |  5 +++--
 drivers/gpu/drm/i915/i915_reg.h | 10 ++++++++--
 2 files changed, 11 insertions(+), 4 deletions(-)
drivers/gpu/drm/i915/i915_gem.c +3 -2
index 6370a76..d000d0f 100644
@@ -4458,8 +4458,9 @@ int i915_gem_init(struct drm_device *dev)
 
 	if (IS_VALLEYVIEW(dev)) {
 		/* VLVA0 (potential hack), BIOS isn't actually waking us */
-		I915_WRITE(VLV_GTLC_WAKE_CTRL, 1);
-		if (wait_for((I915_READ(VLV_GTLC_PW_STATUS) & 1) == 1, 10))
+		I915_WRITE(VLV_GTLC_WAKE_CTRL, VLV_GTLC_ALLOWWAKEREQ);
+		if (wait_for((I915_READ(VLV_GTLC_PW_STATUS) &
+			      VLV_GTLC_ALLOWWAKEACK), 10))
 			DRM_DEBUG_DRIVER("allow wake ack timed out\n");
 	}
 
drivers/gpu/drm/i915/i915_reg.h +8 -2
index 8e60737..0997da3 100644
@@ -4985,9 +4985,15 @@ enum punit_power_well {
 #define  FORCEWAKE_ACK_HSW			0x130044
 #define  FORCEWAKE_ACK				0x130090
 #define  VLV_GTLC_WAKE_CTRL			0x130090
+#define   VLV_GTLC_RENDER_CTX_EXISTS		(1 << 25)
+#define   VLV_GTLC_MEDIA_CTX_EXISTS		(1 << 24)
+#define   VLV_GTLC_ALLOWWAKEREQ			(1 << 0)
+
 #define  VLV_GTLC_PW_STATUS			0x130094
-#define VLV_GTLC_PW_RENDER_STATUS_MASK		0x80
-#define VLV_GTLC_PW_MEDIA_STATUS_MASK		0x20
+#define   VLV_GTLC_ALLOWWAKEACK			(1 << 0)
+#define   VLV_GTLC_ALLOWWAKEERR			(1 << 1)
+#define   VLV_GTLC_PW_MEDIA_STATUS_MASK		(1 << 5)
+#define   VLV_GTLC_PW_RENDER_STATUS_MASK	(1 << 7)
 #define  FORCEWAKE_MT				0xa188 /* multi-threaded */
 #define   FORCEWAKE_KERNEL			0x1
 #define   FORCEWAKE_USER			0x2
Signature · 1 line
1.8.4
#2 lore raw

Re: [PATCH 01/15] drm/i915: vlv: clean up GTLC wake control/status register macros

Well, first of all I couldn't find the regs definitions. I decided to do this review during fly but I didn't had this regs definitions on VLV docs I have here with me. Could you please point me to the correct docs?

Anyway this patch isn't really modifying any behaviour. So I would tend to let my Reviewed-by: Rodrigo Vivi <[email protected]> here anyway. Considering that the original author of changes plus the first reviewer already agreed with you.

Quoted 53 lines · Imre Deak

These will be needed by the upcoming VLV RPM helpers.

---
 drivers/gpu/drm/i915/i915_gem.c |  5 +++--
 drivers/gpu/drm/i915/i915_reg.h | 10 ++++++++--
 2 files changed, 11 insertions(+), 4 deletions(-)
drivers/gpu/drm/i915/i915_gem.c +3 -2
index 6370a76..d000d0f 100644
@@ -4458,8 +4458,9 @@ int i915_gem_init(struct drm_device *dev)
 
        if (IS_VALLEYVIEW(dev)) {
                /* VLVA0 (potential hack), BIOS isn't actually waking us */
-               I915_WRITE(VLV_GTLC_WAKE_CTRL, 1);
-               if (wait_for((I915_READ(VLV_GTLC_PW_STATUS) & 1) == 1, 10))
+               I915_WRITE(VLV_GTLC_WAKE_CTRL, VLV_GTLC_ALLOWWAKEREQ);
+               if (wait_for((I915_READ(VLV_GTLC_PW_STATUS) &
+                             VLV_GTLC_ALLOWWAKEACK), 10))
                        DRM_DEBUG_DRIVER("allow wake ack timed out\n");
        }
 
drivers/gpu/drm/i915/i915_reg.h +8 -3
index 8e60737..0997da3 100644
@@ -4985,9 +4985,15 @@ enum punit_power_well {
 #define  FORCEWAKE_ACK_HSW                     0x130044
 #define  FORCEWAKE_ACK                         0x130090
 #define  VLV_GTLC_WAKE_CTRL                    0x130090
+#define   VLV_GTLC_RENDER_CTX_EXISTS           (1 << 25)
+#define   VLV_GTLC_MEDIA_CTX_EXISTS            (1 << 24)
+#define   VLV_GTLC_ALLOWWAKEREQ                        (1 << 0)
+
 #define  VLV_GTLC_PW_STATUS                    0x130094
-#define VLV_GTLC_PW_RENDER_STATUS_MASK         0x80
-#define VLV_GTLC_PW_MEDIA_STATUS_MASK          0x20
+#define   VLV_GTLC_ALLOWWAKEACK                        (1 << 0)
+#define   VLV_GTLC_ALLOWWAKEERR                        (1 << 1)
+#define   VLV_GTLC_PW_MEDIA_STATUS_MASK                (1 << 5)
+#define   VLV_GTLC_PW_RENDER_STATUS_MASK       (1 << 7)
 #define  FORCEWAKE_MT                          0xa188 /* multi-threaded */
 #define   FORCEWAKE_KERNEL                     0x1
 #define   FORCEWAKE_USER                       0x2
--

1.8.4

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx

Signature · 2 lines
Rodrigo Vivi
Blog: http://blog.vivi.eng.br
author
#3 lore raw

Re: [PATCH 01/15] drm/i915: vlv: clean up GTLC wake control/status register macros

Quoted 4 lines · Rodrigo Vivi

Well, first of all I couldn't find the regs definitions. I decided to do this review during fly but I didn't had this regs definitions on VLV docs I have here with me. Could you please point me to the correct docs?

These regs are defined in the Gunit register HAS, I'll send you in private the details.

Quoted 4 lines

Anyway this patch isn't really modifying any behaviour. So I would tend to let my Reviewed-by: Rodrigo Vivi <[email protected]> here anyway. Considering that the original author of changes plus the first reviewer already agreed with you.

Note that there is already a v2 of this patchset, so please review that one.

--Imre

Quoted 57 lines · Imre Deak
Quoted 53 lines

These will be needed by the upcoming VLV RPM helpers.

---
 drivers/gpu/drm/i915/i915_gem.c |  5 +++--
 drivers/gpu/drm/i915/i915_reg.h | 10 ++++++++--
 2 files changed, 11 insertions(+), 4 deletions(-)
drivers/gpu/drm/i915/i915_gem.c +3 -2
index 6370a76..d000d0f 100644
@@ -4458,8 +4458,9 @@ int i915_gem_init(struct drm_device *dev)
 
        if (IS_VALLEYVIEW(dev)) {
                /* VLVA0 (potential hack), BIOS isn't actually waking us */
-               I915_WRITE(VLV_GTLC_WAKE_CTRL, 1);
-               if (wait_for((I915_READ(VLV_GTLC_PW_STATUS) & 1) == 1, 10))
+               I915_WRITE(VLV_GTLC_WAKE_CTRL, VLV_GTLC_ALLOWWAKEREQ);
+               if (wait_for((I915_READ(VLV_GTLC_PW_STATUS) &
+                             VLV_GTLC_ALLOWWAKEACK), 10))
                        DRM_DEBUG_DRIVER("allow wake ack timed out\n");
        }
 
drivers/gpu/drm/i915/i915_reg.h +8 -3
index 8e60737..0997da3 100644
@@ -4985,9 +4985,15 @@ enum punit_power_well {
 #define  FORCEWAKE_ACK_HSW                     0x130044
 #define  FORCEWAKE_ACK                         0x130090
 #define  VLV_GTLC_WAKE_CTRL                    0x130090
+#define   VLV_GTLC_RENDER_CTX_EXISTS           (1 << 25)
+#define   VLV_GTLC_MEDIA_CTX_EXISTS            (1 << 24)
+#define   VLV_GTLC_ALLOWWAKEREQ                        (1 << 0)
+
 #define  VLV_GTLC_PW_STATUS                    0x130094
-#define VLV_GTLC_PW_RENDER_STATUS_MASK         0x80
-#define VLV_GTLC_PW_MEDIA_STATUS_MASK          0x20
+#define   VLV_GTLC_ALLOWWAKEACK                        (1 << 0)
+#define   VLV_GTLC_ALLOWWAKEERR                        (1 << 1)
+#define   VLV_GTLC_PW_MEDIA_STATUS_MASK                (1 << 5)
+#define   VLV_GTLC_PW_RENDER_STATUS_MASK       (1 << 7)
 #define  FORCEWAKE_MT                          0xa188 /* multi-threaded */
 #define   FORCEWAKE_KERNEL                     0x1
 #define   FORCEWAKE_USER                       0x2
--

1.8.4

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx

author
#4 lore raw

PATCH 2/15 drm/i915: vlv: clear master interrupt flag when disabling interrupts

In reply to Imre Deak

Not clearing this flag causes spurious interrupts at least in D3 state, so before enabling RPM we need to fix this. We were already setting this flag when enabling interrupts, only clearing it was missing.

---
 drivers/gpu/drm/i915/i915_irq.c | 2 ++
 1 file changed, 2 insertions(+)
drivers/gpu/drm/i915/i915_irq.c +2 -0
index 4ca0344..b8f64d7 100644
@@ -3305,6 +3305,8 @@ static void valleyview_irq_uninstall(struct drm_device *dev)
 	if (!dev_priv)
 		return;
 
+	I915_WRITE(VLV_MASTER_IER, 0);
+
 	intel_hpd_irq_uninstall(dev_priv);
 
 	for_each_pipe(pipe)
Signature · 1 line
1.8.4
author
#5 lore raw

PATCH 3/15 drm/i915: vlv: add RC6 residency counters

In reply to Imre Deak
---
 drivers/gpu/drm/i915/i915_debugfs.c | 5 +++++
 drivers/gpu/drm/i915/i915_reg.h     | 3 +++
 2 files changed, 8 insertions(+)
drivers/gpu/drm/i915/i915_debugfs.c +5 -0
index 1e83ae4..02f1b39 100644
@@ -1261,6 +1261,11 @@ static int vlv_drpc_info(struct seq_file *m)
 			(I915_READ(VLV_GTLC_PW_STATUS) &
 				VLV_GTLC_PW_MEDIA_STATUS_MASK) ? "Up" : "Down");
 
+	seq_printf(m, "Render RC6 residency since boot: %u\n",
+		   I915_READ(VLV_GT_RENDER_RC6));
+	seq_printf(m, "Media RC6 residency since boot: %u\n",
+		   I915_READ(VLV_GT_MEDIA_RC6));
+
 	spin_lock_irq(&dev_priv->uncore.lock);
 	fw_rendercount = dev_priv->uncore.fw_rendercount;
 	fw_mediacount = dev_priv->uncore.fw_mediacount;
drivers/gpu/drm/i915/i915_reg.h +3 -0
index 0997da3..c4fd089 100644
@@ -5125,6 +5125,9 @@ enum punit_power_well {
 #define   VLV_MEDIA_RC6_COUNT_EN		(1<<1)
 #define   VLV_RENDER_RC6_COUNT_EN		(1<<0)
 #define GEN6_GT_GFX_RC6				0x138108
+#define VLV_GT_RENDER_RC6			0x138108
+#define VLV_GT_MEDIA_RC6			0x13810C
+
 #define GEN6_GT_GFX_RC6p			0x13810C
 #define GEN6_GT_GFX_RC6pp			0x138110
 
Signature · 1 line
1.8.4
author
#6 lore raw

PATCH 4/15 drm/i915: fix rc6 status debug print

In reply to Imre Deak

The parsing was incorrect for ILK and VLV.

---
 drivers/gpu/drm/i915/intel_pm.c | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)
drivers/gpu/drm/i915/intel_pm.c +7 -1
index a0527a1..869a4e3 100644
@@ -3215,6 +3215,12 @@ static void valleyview_disable_rps(struct drm_device *dev)
 
 static void intel_print_rc6_info(struct drm_device *dev, u32 mode)
 {
+	if (IS_VALLEYVIEW(dev)) {
+		if (mode & (GEN7_RC_CTL_TO_MODE | GEN6_RC_CTL_EI_MODE(1)))
+			mode = GEN6_RC_CTL_RC6_ENABLE;
+		else
+			mode = 0;
+	}
 	DRM_INFO("Enabling RC6 states: RC6 %s, RC6p %s, RC6pp %s\n",
 		 (mode & GEN6_RC_CTL_RC6_ENABLE) ? "on" : "off",
 		 (mode & GEN6_RC_CTL_RC6p_ENABLE) ? "on" : "off",
@@ -3842,7 +3848,7 @@ static void ironlake_enable_rc6(struct drm_device *dev)
 	I915_WRITE(PWRCTXA, i915_gem_obj_ggtt_offset(dev_priv->ips.pwrctx) | PWRCTX_EN);
 	I915_WRITE(RSTDBYCTL, I915_READ(RSTDBYCTL) & ~RCX_SW_EXIT);
 
-	intel_print_rc6_info(dev, INTEL_RC6_ENABLE);
+	intel_print_rc6_info(dev, GEN6_RC_CTL_RC6_ENABLE);
 }
 
 static unsigned long intel_pxfreq(u32 vidfreq)
Signature · 1 line
1.8.4
author
#7 lore raw

PATCH 5/15 drm/i915: take init power domain for sysfs/debugfs entries where needed

In reply to Imre Deak

For simplicity take the init power domain, which puts the device into D0 and turns on all display power wells.

---
 drivers/gpu/drm/i915/i915_debugfs.c | 17 +++++++++++++++--
 drivers/gpu/drm/i915/i915_sysfs.c   |  4 ++++
 2 files changed, 19 insertions(+), 2 deletions(-)
drivers/gpu/drm/i915/i915_debugfs.c +15 -2
index 02f1b39..348cf7c 100644
@@ -1239,9 +1239,13 @@ static int vlv_drpc_info(struct seq_file *m)
 	u32 rpmodectl1, rcctl1;
 	unsigned fw_rendercount = 0, fw_mediacount = 0;
 
+	intel_display_power_get(dev_priv, POWER_DOMAIN_INIT);
+
 	rpmodectl1 = I915_READ(GEN6_RP_CONTROL);
 	rcctl1 = I915_READ(GEN6_RC_CONTROL);
 
+	intel_display_power_put(dev_priv, POWER_DOMAIN_INIT);
+
 	seq_printf(m, "Video Turbo Mode: %s\n",
 		   yesno(rpmodectl1 & GEN6_RP_MEDIA_TURBO));
 	seq_printf(m, "Turbo enabled: %s\n",
@@ -1916,9 +1920,11 @@ static int i915_dpio_info(struct seq_file *m, void *data)
 		return 0;
 	}
 
+	intel_display_power_get(dev_priv, POWER_DOMAIN_INIT);
+
 	ret = mutex_lock_interruptible(&dev_priv->dpio_lock);
 	if (ret)
-		return ret;
+		goto out;
 
 	seq_printf(m, "DPIO_CTL: 0x%08x\n", I915_READ(DPIO_CTL));
 
@@ -1946,8 +1952,10 @@ static int i915_dpio_info(struct seq_file *m, void *data)
 		   vlv_dpio_read(dev_priv, PIPE_A, VLV_CMN_DW0));
 
 	mutex_unlock(&dev_priv->dpio_lock);
+out:
+	intel_display_power_put(dev_priv, POWER_DOMAIN_INIT);
 
-	return 0;
+	return ret;
 }
 
 static int i915_llc(struct seq_file *m, void *data)
@@ -3305,8 +3313,13 @@ i915_wedged_set(void *data, u64 val)
 {
 	struct drm_device *dev = data;
 
+	intel_display_power_get(dev_priv, POWER_DOMAIN_INIT);
+
 	i915_handle_error(dev, val,
 			  "Manually setting wedged to %llu", val);
+
+	intel_display_power_put(dev_priv, POWER_DOMAIN_INIT);
+
 	return 0;
 }
 
drivers/gpu/drm/i915/i915_sysfs.c +4 -0
index 9c57029..552c4ed 100644
@@ -263,6 +263,8 @@ static ssize_t gt_cur_freq_mhz_show(struct device *kdev,
 
 	flush_delayed_work(&dev_priv->rps.delayed_resume_work);
 
+	intel_display_power_get(dev_priv, POWER_DOMAIN_INIT);
+
 	mutex_lock(&dev_priv->rps.hw_lock);
 	if (IS_VALLEYVIEW(dev_priv->dev)) {
 		u32 freq;
@@ -273,6 +275,8 @@ static ssize_t gt_cur_freq_mhz_show(struct device *kdev,
 	}
 	mutex_unlock(&dev_priv->rps.hw_lock);
 
+	intel_display_power_put(dev_priv, POWER_DOMAIN_INIT);
+
 	return snprintf(buf, PAGE_SIZE, "%d\n", ret);
 }
 
Signature · 1 line
1.8.4
author
#8 lore raw

PATCH v2 5/15 drm/i915: take init power domain for sysfs/debugfs entries where needed

v2:
- make it actually compile, I managed to send the wrong version as v1 somehow

---
 drivers/gpu/drm/i915/i915_debugfs.c | 18 ++++++++++++++++--
 drivers/gpu/drm/i915/i915_sysfs.c   |  4 ++++
 2 files changed, 20 insertions(+), 2 deletions(-)
drivers/gpu/drm/i915/i915_debugfs.c +16 -2
index 02f1b39..ac91a44 100644
@@ -1239,9 +1239,13 @@ static int vlv_drpc_info(struct seq_file *m)
 	u32 rpmodectl1, rcctl1;
 	unsigned fw_rendercount = 0, fw_mediacount = 0;
 
+	intel_display_power_get(dev_priv, POWER_DOMAIN_INIT);
+
 	rpmodectl1 = I915_READ(GEN6_RP_CONTROL);
 	rcctl1 = I915_READ(GEN6_RC_CONTROL);
 
+	intel_display_power_put(dev_priv, POWER_DOMAIN_INIT);
+
 	seq_printf(m, "Video Turbo Mode: %s\n",
 		   yesno(rpmodectl1 & GEN6_RP_MEDIA_TURBO));
 	seq_printf(m, "Turbo enabled: %s\n",
@@ -1916,9 +1920,11 @@ static int i915_dpio_info(struct seq_file *m, void *data)
 		return 0;
 	}
 
+	intel_display_power_get(dev_priv, POWER_DOMAIN_INIT);
+
 	ret = mutex_lock_interruptible(&dev_priv->dpio_lock);
 	if (ret)
-		return ret;
+		goto out;
 
 	seq_printf(m, "DPIO_CTL: 0x%08x\n", I915_READ(DPIO_CTL));
 
@@ -1946,8 +1952,10 @@ static int i915_dpio_info(struct seq_file *m, void *data)
 		   vlv_dpio_read(dev_priv, PIPE_A, VLV_CMN_DW0));
 
 	mutex_unlock(&dev_priv->dpio_lock);
+out:
+	intel_display_power_put(dev_priv, POWER_DOMAIN_INIT);
 
-	return 0;
+	return ret;
 }
 
 static int i915_llc(struct seq_file *m, void *data)
@@ -3304,9 +3312,15 @@ static int
 i915_wedged_set(void *data, u64 val)
 {
 	struct drm_device *dev = data;
+	struct drm_i915_private *dev_priv = dev->dev_private;
+
+	intel_display_power_get(dev_priv, POWER_DOMAIN_INIT);
 
 	i915_handle_error(dev, val,
 			  "Manually setting wedged to %llu", val);
+
+	intel_display_power_put(dev_priv, POWER_DOMAIN_INIT);
+
 	return 0;
 }
 
drivers/gpu/drm/i915/i915_sysfs.c +4 -0
index 9c57029..552c4ed 100644
@@ -263,6 +263,8 @@ static ssize_t gt_cur_freq_mhz_show(struct device *kdev,
 
 	flush_delayed_work(&dev_priv->rps.delayed_resume_work);
 
+	intel_display_power_get(dev_priv, POWER_DOMAIN_INIT);
+
 	mutex_lock(&dev_priv->rps.hw_lock);
 	if (IS_VALLEYVIEW(dev_priv->dev)) {
 		u32 freq;
@@ -273,6 +275,8 @@ static ssize_t gt_cur_freq_mhz_show(struct device *kdev,
 	}
 	mutex_unlock(&dev_priv->rps.hw_lock);
 
+	intel_display_power_put(dev_priv, POWER_DOMAIN_INIT);
+
 	return snprintf(buf, PAGE_SIZE, "%d\n", ret);
 }
 
Signature · 1 line
1.8.3.2
#9 lore raw

Re: [PATCH v2 5/15] drm/i915: take init power domain for sysfs/debugfs entries where needed

Quoted 5 lines · Imre Deak

v2:
- make it actually compile, I managed to send the wrong version as v1 somehow

Usually if we just want the device to be out of D3 we just use intel_runtime_pm_get/put. On a quick look it seems like that's enough for these places here, too?
-Daniel

Quoted 93 lines
---
 drivers/gpu/drm/i915/i915_debugfs.c | 18 ++++++++++++++++--
 drivers/gpu/drm/i915/i915_sysfs.c   |  4 ++++
 2 files changed, 20 insertions(+), 2 deletions(-)
drivers/gpu/drm/i915/i915_debugfs.c +16 -2
index 02f1b39..ac91a44 100644
@@ -1239,9 +1239,13 @@ static int vlv_drpc_info(struct seq_file *m)
 	u32 rpmodectl1, rcctl1;
 	unsigned fw_rendercount = 0, fw_mediacount = 0;
 
+	intel_display_power_get(dev_priv, POWER_DOMAIN_INIT);
+
 	rpmodectl1 = I915_READ(GEN6_RP_CONTROL);
 	rcctl1 = I915_READ(GEN6_RC_CONTROL);
 
+	intel_display_power_put(dev_priv, POWER_DOMAIN_INIT);
+
 	seq_printf(m, "Video Turbo Mode: %s\n",
 		   yesno(rpmodectl1 & GEN6_RP_MEDIA_TURBO));
 	seq_printf(m, "Turbo enabled: %s\n",
@@ -1916,9 +1920,11 @@ static int i915_dpio_info(struct seq_file *m, void *data)
 		return 0;
 	}
 
+	intel_display_power_get(dev_priv, POWER_DOMAIN_INIT);
+
 	ret = mutex_lock_interruptible(&dev_priv->dpio_lock);
 	if (ret)
-		return ret;
+		goto out;
 
 	seq_printf(m, "DPIO_CTL: 0x%08x\n", I915_READ(DPIO_CTL));
 
@@ -1946,8 +1952,10 @@ static int i915_dpio_info(struct seq_file *m, void *data)
 		   vlv_dpio_read(dev_priv, PIPE_A, VLV_CMN_DW0));
 
 	mutex_unlock(&dev_priv->dpio_lock);
+out:
+	intel_display_power_put(dev_priv, POWER_DOMAIN_INIT);
 
-	return 0;
+	return ret;
 }
 
 static int i915_llc(struct seq_file *m, void *data)
@@ -3304,9 +3312,15 @@ static int
 i915_wedged_set(void *data, u64 val)
 {
 	struct drm_device *dev = data;
+	struct drm_i915_private *dev_priv = dev->dev_private;
+
+	intel_display_power_get(dev_priv, POWER_DOMAIN_INIT);
 
 	i915_handle_error(dev, val,
 			  "Manually setting wedged to %llu", val);
+
+	intel_display_power_put(dev_priv, POWER_DOMAIN_INIT);
+
 	return 0;
 }
 
drivers/gpu/drm/i915/i915_sysfs.c +4 -0
index 9c57029..552c4ed 100644
@@ -263,6 +263,8 @@ static ssize_t gt_cur_freq_mhz_show(struct device *kdev,
 
 	flush_delayed_work(&dev_priv->rps.delayed_resume_work);
 
+	intel_display_power_get(dev_priv, POWER_DOMAIN_INIT);
+
 	mutex_lock(&dev_priv->rps.hw_lock);
 	if (IS_VALLEYVIEW(dev_priv->dev)) {
 		u32 freq;
@@ -273,6 +275,8 @@ static ssize_t gt_cur_freq_mhz_show(struct device *kdev,
 	}
 	mutex_unlock(&dev_priv->rps.hw_lock);
 
+	intel_display_power_put(dev_priv, POWER_DOMAIN_INIT);
+
 	return snprintf(buf, PAGE_SIZE, "%d\n", ret);
 }
 
Signature · 6 lines
1.8.3.2

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
Signature · 3 lines
Daniel Vetter
Software Engineer, Intel Corporation
+41 (0) 79 365 57 48 - http://blog.ffwll.ch
#10 lore raw

Re: [PATCH v2 5/15] drm/i915: take init power domain for sysfs/debugfs entries where needed

2014-04-09 11:15 GMT-03:00 Daniel Vetter <[email protected]>:

Quoted 4 lines · Imre Deak
Quoted 3 lines

v2:
- make it actually compile, I managed to send the wrong version as v1 somehow

This version removed the commit message of the first version.

Quoted 6 lines
Quoted 2 lines

Usually if we just want the device to be out of D3 we just use intel_runtime_pm_get/put. On a quick look it seems like that's enough for these places here, too?

I agree that using the "init" power domain here is a bad idea. IMHO we really should keep the init power domain only to the init/resume paths. Otherwise, if we ever get a bug report saying that INIT get/put calls are unbalanced, we may waste a lot of time debugging init/resume while the problem may be in debugfs.

If you just need to resume from runtime PM, just use intel_runtime_pm_get/put. If you need more specific things, you should probably get the specific power domains.

Quoted 104 lines

-Daniel

Quoted 89 lines
---
 drivers/gpu/drm/i915/i915_debugfs.c | 18 ++++++++++++++++--
 drivers/gpu/drm/i915/i915_sysfs.c   |  4 ++++
 2 files changed, 20 insertions(+), 2 deletions(-)
drivers/gpu/drm/i915/i915_debugfs.c +16 -2
index 02f1b39..ac91a44 100644
@@ -1239,9 +1239,13 @@ static int vlv_drpc_info(struct seq_file *m)
      u32 rpmodectl1, rcctl1;
      unsigned fw_rendercount = 0, fw_mediacount = 0;
 
+     intel_display_power_get(dev_priv, POWER_DOMAIN_INIT);
+
      rpmodectl1 = I915_READ(GEN6_RP_CONTROL);
      rcctl1 = I915_READ(GEN6_RC_CONTROL);
 
+     intel_display_power_put(dev_priv, POWER_DOMAIN_INIT);
+
      seq_printf(m, "Video Turbo Mode: %s\n",
                 yesno(rpmodectl1 & GEN6_RP_MEDIA_TURBO));
      seq_printf(m, "Turbo enabled: %s\n",
@@ -1916,9 +1920,11 @@ static int i915_dpio_info(struct seq_file *m, void *data)
              return 0;
      }
 
+     intel_display_power_get(dev_priv, POWER_DOMAIN_INIT);
+
      ret = mutex_lock_interruptible(&dev_priv->dpio_lock);
      if (ret)
-             return ret;
+             goto out;
 
      seq_printf(m, "DPIO_CTL: 0x%08x\n", I915_READ(DPIO_CTL));
 
@@ -1946,8 +1952,10 @@ static int i915_dpio_info(struct seq_file *m, void *data)
                 vlv_dpio_read(dev_priv, PIPE_A, VLV_CMN_DW0));
 
      mutex_unlock(&dev_priv->dpio_lock);
+out:
+     intel_display_power_put(dev_priv, POWER_DOMAIN_INIT);
 
-     return 0;
+     return ret;
 }
 
 static int i915_llc(struct seq_file *m, void *data)
@@ -3304,9 +3312,15 @@ static int
 i915_wedged_set(void *data, u64 val)
 {
      struct drm_device *dev = data;
+     struct drm_i915_private *dev_priv = dev->dev_private;
+
+     intel_display_power_get(dev_priv, POWER_DOMAIN_INIT);
 
      i915_handle_error(dev, val,
                        "Manually setting wedged to %llu", val);
+
+     intel_display_power_put(dev_priv, POWER_DOMAIN_INIT);
+
      return 0;
 }
 
drivers/gpu/drm/i915/i915_sysfs.c +4 -1
index 9c57029..552c4ed 100644
@@ -263,6 +263,8 @@ static ssize_t gt_cur_freq_mhz_show(struct device *kdev,
 
      flush_delayed_work(&dev_priv->rps.delayed_resume_work);
 
+     intel_display_power_get(dev_priv, POWER_DOMAIN_INIT);
+
      mutex_lock(&dev_priv->rps.hw_lock);
      if (IS_VALLEYVIEW(dev_priv->dev)) {
              u32 freq;
@@ -273,6 +275,8 @@ static ssize_t gt_cur_freq_mhz_show(struct device *kdev,
      }
      mutex_unlock(&dev_priv->rps.hw_lock);
 
+     intel_display_power_put(dev_priv, POWER_DOMAIN_INIT);
+
      return snprintf(buf, PAGE_SIZE, "%d\n", ret);
 }
 
--

1.8.3.2

Quoted 4 lines

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx

--
Daniel Vetter
Software Engineer, Intel Corporation
+41 (0) 79 365 57 48 - http://blog.ffwll.ch
_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx

Signature · 1 line
Paulo Zanoni
author
#11 lore raw

Re: [PATCH v2 5/15] drm/i915: take init power domain for sysfs/debugfs entries where needed

In reply to Daniel Vetter
Quoted 10 lines · Daniel Vetter
Quoted 5 lines · Imre Deak

v2:
- make it actually compile, I managed to send the wrong version as v1 somehow

Usually if we just want the device to be out of D3 we just use intel_runtime_pm_get/put. On a quick look it seems like that's enough for these places here, too?

For drpc yes, but for the others we need the DPIO power wells up too. I got for all VLV case the power well ref for simplicity, I can change it to an RPM ref for drpc, if that's ok.

--Imre

Quoted 96 lines

-Daniel

Quoted 93 lines
---
 drivers/gpu/drm/i915/i915_debugfs.c | 18 ++++++++++++++++--
 drivers/gpu/drm/i915/i915_sysfs.c   |  4 ++++
 2 files changed, 20 insertions(+), 2 deletions(-)
drivers/gpu/drm/i915/i915_debugfs.c +16 -2
index 02f1b39..ac91a44 100644
@@ -1239,9 +1239,13 @@ static int vlv_drpc_info(struct seq_file *m)
 	u32 rpmodectl1, rcctl1;
 	unsigned fw_rendercount = 0, fw_mediacount = 0;
 
+	intel_display_power_get(dev_priv, POWER_DOMAIN_INIT);
+
 	rpmodectl1 = I915_READ(GEN6_RP_CONTROL);
 	rcctl1 = I915_READ(GEN6_RC_CONTROL);
 
+	intel_display_power_put(dev_priv, POWER_DOMAIN_INIT);
+
 	seq_printf(m, "Video Turbo Mode: %s\n",
 		   yesno(rpmodectl1 & GEN6_RP_MEDIA_TURBO));
 	seq_printf(m, "Turbo enabled: %s\n",
@@ -1916,9 +1920,11 @@ static int i915_dpio_info(struct seq_file *m, void *data)
 		return 0;
 	}
 
+	intel_display_power_get(dev_priv, POWER_DOMAIN_INIT);
+
 	ret = mutex_lock_interruptible(&dev_priv->dpio_lock);
 	if (ret)
-		return ret;
+		goto out;
 
 	seq_printf(m, "DPIO_CTL: 0x%08x\n", I915_READ(DPIO_CTL));
 
@@ -1946,8 +1952,10 @@ static int i915_dpio_info(struct seq_file *m, void *data)
 		   vlv_dpio_read(dev_priv, PIPE_A, VLV_CMN_DW0));
 
 	mutex_unlock(&dev_priv->dpio_lock);
+out:
+	intel_display_power_put(dev_priv, POWER_DOMAIN_INIT);
 
-	return 0;
+	return ret;
 }
 
 static int i915_llc(struct seq_file *m, void *data)
@@ -3304,9 +3312,15 @@ static int
 i915_wedged_set(void *data, u64 val)
 {
 	struct drm_device *dev = data;
+	struct drm_i915_private *dev_priv = dev->dev_private;
+
+	intel_display_power_get(dev_priv, POWER_DOMAIN_INIT);
 
 	i915_handle_error(dev, val,
 			  "Manually setting wedged to %llu", val);
+
+	intel_display_power_put(dev_priv, POWER_DOMAIN_INIT);
+
 	return 0;
 }
 
drivers/gpu/drm/i915/i915_sysfs.c +4 -0
index 9c57029..552c4ed 100644
@@ -263,6 +263,8 @@ static ssize_t gt_cur_freq_mhz_show(struct device *kdev,
 
 	flush_delayed_work(&dev_priv->rps.delayed_resume_work);
 
+	intel_display_power_get(dev_priv, POWER_DOMAIN_INIT);
+
 	mutex_lock(&dev_priv->rps.hw_lock);
 	if (IS_VALLEYVIEW(dev_priv->dev)) {
 		u32 freq;
@@ -273,6 +275,8 @@ static ssize_t gt_cur_freq_mhz_show(struct device *kdev,
 	}
 	mutex_unlock(&dev_priv->rps.hw_lock);
 
+	intel_display_power_put(dev_priv, POWER_DOMAIN_INIT);
+
 	return snprintf(buf, PAGE_SIZE, "%d\n", ret);
 }
 
Signature · 6 lines
1.8.3.2

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
#12 lore raw

Re: [PATCH v2 5/15] drm/i915: take init power domain for sysfs/debugfs entries where needed

Quoted 8 lines · Imre Deak
Quoted 7 lines · Daniel Vetter
Quoted 5 lines · Imre Deak

v2:
- make it actually compile, I managed to send the wrong version as v1 somehow

Quoted 7 lines
Quoted 3 lines

Usually if we just want the device to be out of D3 we just use intel_runtime_pm_get/put. On a quick look it seems like that's enough for these places here, too?

For drpc yes, but for the others we need the DPIO power wells up too. I got for all VLV case the power well ref for simplicity, I can change it to an RPM ref for drpc, if that's ok.

The dpio_info file would need DPIO wells up. However I think we should just kill that file. It just dumps a small subset of the registers w/o decoding anything, and we can get more extensive dumps w/ igt, so I don't see the point of this file.

The error handler should already be able to deal with the wells being down no?

The gt_cutr_freq file just talks to the punit so no need for any power wells either AFAICS.

Quoted 105 lines

--Imre

Quoted 88 lines

-Daniel

Quoted 86 lines
---
 drivers/gpu/drm/i915/i915_debugfs.c | 18 ++++++++++++++++--
 drivers/gpu/drm/i915/i915_sysfs.c   |  4 ++++
 2 files changed, 20 insertions(+), 2 deletions(-)
drivers/gpu/drm/i915/i915_debugfs.c +16 -2
index 02f1b39..ac91a44 100644
@@ -1239,9 +1239,13 @@ static int vlv_drpc_info(struct seq_file *m)
 	u32 rpmodectl1, rcctl1;
 	unsigned fw_rendercount = 0, fw_mediacount = 0;
 
+	intel_display_power_get(dev_priv, POWER_DOMAIN_INIT);
+
 	rpmodectl1 = I915_READ(GEN6_RP_CONTROL);
 	rcctl1 = I915_READ(GEN6_RC_CONTROL);
 
+	intel_display_power_put(dev_priv, POWER_DOMAIN_INIT);
+
 	seq_printf(m, "Video Turbo Mode: %s\n",
 		   yesno(rpmodectl1 & GEN6_RP_MEDIA_TURBO));
 	seq_printf(m, "Turbo enabled: %s\n",
@@ -1916,9 +1920,11 @@ static int i915_dpio_info(struct seq_file *m, void *data)
 		return 0;
 	}
 
+	intel_display_power_get(dev_priv, POWER_DOMAIN_INIT);
+
 	ret = mutex_lock_interruptible(&dev_priv->dpio_lock);
 	if (ret)
-		return ret;
+		goto out;
 
 	seq_printf(m, "DPIO_CTL: 0x%08x\n", I915_READ(DPIO_CTL));
 
@@ -1946,8 +1952,10 @@ static int i915_dpio_info(struct seq_file *m, void *data)
 		   vlv_dpio_read(dev_priv, PIPE_A, VLV_CMN_DW0));
 
 	mutex_unlock(&dev_priv->dpio_lock);
+out:
+	intel_display_power_put(dev_priv, POWER_DOMAIN_INIT);
 
-	return 0;
+	return ret;
 }
 
 static int i915_llc(struct seq_file *m, void *data)
@@ -3304,9 +3312,15 @@ static int
 i915_wedged_set(void *data, u64 val)
 {
 	struct drm_device *dev = data;
+	struct drm_i915_private *dev_priv = dev->dev_private;
+
+	intel_display_power_get(dev_priv, POWER_DOMAIN_INIT);
 
 	i915_handle_error(dev, val,
 			  "Manually setting wedged to %llu", val);
+
+	intel_display_power_put(dev_priv, POWER_DOMAIN_INIT);
+
 	return 0;
 }
 
drivers/gpu/drm/i915/i915_sysfs.c +4 -0
index 9c57029..552c4ed 100644
@@ -263,6 +263,8 @@ static ssize_t gt_cur_freq_mhz_show(struct device *kdev,
 
 	flush_delayed_work(&dev_priv->rps.delayed_resume_work);
 
+	intel_display_power_get(dev_priv, POWER_DOMAIN_INIT);
+
 	mutex_lock(&dev_priv->rps.hw_lock);
 	if (IS_VALLEYVIEW(dev_priv->dev)) {
 		u32 freq;
@@ -273,6 +275,8 @@ static ssize_t gt_cur_freq_mhz_show(struct device *kdev,
 	}
 	mutex_unlock(&dev_priv->rps.hw_lock);
 
+	intel_display_power_put(dev_priv, POWER_DOMAIN_INIT);
+
 	return snprintf(buf, PAGE_SIZE, "%d\n", ret);
 }
 
Quoted 8 lines
Quoted 7 lines
Signature · 6 lines
1.8.3.2

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx

Signature · 2 lines
Ville Syrjälä
Intel OTC
author
#13 lore raw

Re: [PATCH v2 5/15] drm/i915: take init power domain for sysfs/debugfs entries where needed

Quoted 13 lines · Ville Syrjälä
Quoted 12 lines · Imre Deak
Quoted 10 lines · Daniel Vetter
Quoted 5 lines · Imre Deak

v2:
- make it actually compile, I managed to send the wrong version as v1 somehow

Usually if we just want the device to be out of D3 we just use intel_runtime_pm_get/put. On a quick look it seems like that's enough for these places here, too?

Quoted 8 lines
Quoted 3 lines

For drpc yes, but for the others we need the DPIO power wells up too. I got for all VLV case the power well ref for simplicity, I can change it to an RPM ref for drpc, if that's ok.

The dpio_info file would need DPIO wells up. However I think we should just kill that file. It just dumps a small subset of the registers w/o decoding anything, and we can get more extensive dumps w/ igt, so I don't see the point of this file.

Agreed, there are at least the intel_dpio_* tools and other similar ones for reading registers in other address spaces, so this file looks a bit arbitrary. I can remove it if no one objects.

Quoted 2 lines

The error handler should already be able to deal with the wells being down no?

i915_handle_error can be called from IRQ context, so it can't get power domain refs. On an interrupt error detection path this isn't a problem since there the HW is in D0, but here that's not guaranteed.

I took the separate power domain refs in the error _capture_ function since that's a deferred work. There again D0 is not guaranteed, for example we could reset the HW, schedule the capture work, drop the last RPM ref and only then start running the capture function.

Quoted 2 lines

The gt_cutr_freq file just talks to the punit so no need for any power wells either AFAICS.

Hm right, this one needs only D0 as drpc. I'll change this too.

--Imre

Quoted 102 lines
Quoted 102 lines

--Imre

Quoted 96 lines

-Daniel

Quoted 93 lines
---
 drivers/gpu/drm/i915/i915_debugfs.c | 18 ++++++++++++++++--
 drivers/gpu/drm/i915/i915_sysfs.c   |  4 ++++
 2 files changed, 20 insertions(+), 2 deletions(-)
drivers/gpu/drm/i915/i915_debugfs.c +16 -2
index 02f1b39..ac91a44 100644
@@ -1239,9 +1239,13 @@ static int vlv_drpc_info(struct seq_file *m)
 	u32 rpmodectl1, rcctl1;
 	unsigned fw_rendercount = 0, fw_mediacount = 0;
 
+	intel_display_power_get(dev_priv, POWER_DOMAIN_INIT);
+
 	rpmodectl1 = I915_READ(GEN6_RP_CONTROL);
 	rcctl1 = I915_READ(GEN6_RC_CONTROL);
 
+	intel_display_power_put(dev_priv, POWER_DOMAIN_INIT);
+
 	seq_printf(m, "Video Turbo Mode: %s\n",
 		   yesno(rpmodectl1 & GEN6_RP_MEDIA_TURBO));
 	seq_printf(m, "Turbo enabled: %s\n",
@@ -1916,9 +1920,11 @@ static int i915_dpio_info(struct seq_file *m, void *data)
 		return 0;
 	}
 
+	intel_display_power_get(dev_priv, POWER_DOMAIN_INIT);
+
 	ret = mutex_lock_interruptible(&dev_priv->dpio_lock);
 	if (ret)
-		return ret;
+		goto out;
 
 	seq_printf(m, "DPIO_CTL: 0x%08x\n", I915_READ(DPIO_CTL));
 
@@ -1946,8 +1952,10 @@ static int i915_dpio_info(struct seq_file *m, void *data)
 		   vlv_dpio_read(dev_priv, PIPE_A, VLV_CMN_DW0));
 
 	mutex_unlock(&dev_priv->dpio_lock);
+out:
+	intel_display_power_put(dev_priv, POWER_DOMAIN_INIT);
 
-	return 0;
+	return ret;
 }
 
 static int i915_llc(struct seq_file *m, void *data)
@@ -3304,9 +3312,15 @@ static int
 i915_wedged_set(void *data, u64 val)
 {
 	struct drm_device *dev = data;
+	struct drm_i915_private *dev_priv = dev->dev_private;
+
+	intel_display_power_get(dev_priv, POWER_DOMAIN_INIT);
 
 	i915_handle_error(dev, val,
 			  "Manually setting wedged to %llu", val);
+
+	intel_display_power_put(dev_priv, POWER_DOMAIN_INIT);
+
 	return 0;
 }
 
drivers/gpu/drm/i915/i915_sysfs.c +4 -0
index 9c57029..552c4ed 100644
@@ -263,6 +263,8 @@ static ssize_t gt_cur_freq_mhz_show(struct device *kdev,
 
 	flush_delayed_work(&dev_priv->rps.delayed_resume_work);
 
+	intel_display_power_get(dev_priv, POWER_DOMAIN_INIT);
+
 	mutex_lock(&dev_priv->rps.hw_lock);
 	if (IS_VALLEYVIEW(dev_priv->dev)) {
 		u32 freq;
@@ -273,6 +275,8 @@ static ssize_t gt_cur_freq_mhz_show(struct device *kdev,
 	}
 	mutex_unlock(&dev_priv->rps.hw_lock);
 
+	intel_display_power_put(dev_priv, POWER_DOMAIN_INIT);
+
 	return snprintf(buf, PAGE_SIZE, "%d\n", ret);
 }
 
Signature · 6 lines
1.8.3.2

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
Quoted 5 lines
Quoted 4 lines

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx

#14 lore raw

Re: [PATCH v2 5/15] drm/i915: take init power domain for sysfs/debugfs entries where needed

In reply to Ville Syrjälä
Quoted 22 lines · Ville Syrjälä
Quoted 8 lines · Imre Deak
Quoted 7 lines · Daniel Vetter
Quoted 5 lines · Imre Deak

v2:
- make it actually compile, I managed to send the wrong version as v1 somehow

Quoted 7 lines
Quoted 3 lines

Usually if we just want the device to be out of D3 we just use intel_runtime_pm_get/put. On a quick look it seems like that's enough for these places here, too?

For drpc yes, but for the others we need the DPIO power wells up too. I got for all VLV case the power well ref for simplicity, I can change it to an RPM ref for drpc, if that's ok.

The dpio_info file would need DPIO wells up. However I think we should just kill that file. It just dumps a small subset of the registers w/o decoding anything, and we can get more extensive dumps w/ igt, so I don't see the point of this file.

Quoted 5 lines

The error handler should already be able to deal with the wells being down no?

The gt_cutr_freq file just talks to the punit so no need for any power wells either AFAICS.

I'm ok with this plan of ripping out useless debugfs files. And if we need a specific set of display power domains then imo we should grab the specific list, not just INIT, i.e. all of them.
-Daniel

Signature · 3 lines
Daniel Vetter
Software Engineer, Intel Corporation
+41 (0) 79 365 57 48 - http://blog.ffwll.ch
author
#15 lore raw

PATCH 6/15 drm/i915: get init power domain for gpu error state capture

In reply to Imre Deak

Since the state capture happens from a deferred work, we may drop the last power domain/RPM reference since the error got triggered (from an interrupt handler for example). I hit this by writing to the i915_wedged debugfs file.

---
 drivers/gpu/drm/i915/i915_irq.c | 4 ++++
 1 file changed, 4 insertions(+)
drivers/gpu/drm/i915/i915_irq.c +4 -0
index b8f64d7..a586c16 100644
@@ -2174,6 +2174,8 @@ static void i915_error_work_func(struct work_struct *work)
 		kobject_uevent_env(&dev->primary->kdev->kobj, KOBJ_CHANGE,
 				   reset_event);
 
+		intel_display_power_get(dev_priv, POWER_DOMAIN_INIT);
+
 		/*
 		 * All state reset _must_ be completed before we update the
 		 * reset counter, for otherwise waiters might miss the reset
@@ -2184,6 +2186,8 @@ static void i915_error_work_func(struct work_struct *work)
 
 		intel_display_handle_reset(dev);
 
+		intel_display_power_put(dev_priv, POWER_DOMAIN_INIT);
+
 		if (ret == 0) {
 			/*
 			 * After all the gem state is reset, increment the reset
Signature · 1 line
1.8.4
#16 lore raw

Re: [PATCH 06/15] drm/i915: get init power domain for gpu error state capture

Quoted 6 lines · Imre Deak

Since the state capture happens from a deferred work, we may drop the last power domain/RPM reference since the error got triggered (from an interrupt handler for example). I hit this by writing to the i915_wedged debugfs file.

This looks fishy - as long as the gpu is busy we should keep a runtime pm ref around. Also same comment as before, grabbing a display power domain for this seems wrong.
-Daniel

Quoted 33 lines
---
 drivers/gpu/drm/i915/i915_irq.c | 4 ++++
 1 file changed, 4 insertions(+)
drivers/gpu/drm/i915/i915_irq.c +4 -0
index b8f64d7..a586c16 100644
@@ -2174,6 +2174,8 @@ static void i915_error_work_func(struct work_struct *work)
 		kobject_uevent_env(&dev->primary->kdev->kobj, KOBJ_CHANGE,
 				   reset_event);
 
+		intel_display_power_get(dev_priv, POWER_DOMAIN_INIT);
+
 		/*
 		 * All state reset _must_ be completed before we update the
 		 * reset counter, for otherwise waiters might miss the reset
@@ -2184,6 +2186,8 @@ static void i915_error_work_func(struct work_struct *work)
 
 		intel_display_handle_reset(dev);
 
+		intel_display_power_put(dev_priv, POWER_DOMAIN_INIT);
+
 		if (ret == 0) {
 			/*
 			 * After all the gem state is reset, increment the reset
Signature · 6 lines
1.8.4

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
Signature · 3 lines
Daniel Vetter
Software Engineer, Intel Corporation
+41 (0) 79 365 57 48 - http://blog.ffwll.ch
author
#17 lore raw

PATCH 7/15 drm/i915: vlv: check port power domain instead of only D0 for eDP VDD on

In reply to Imre Deak

Some platforms need additional power domains to be on in addition to the device D0 state to access the panel registers.

Suggested by Daniel.

Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=76987

---
 drivers/gpu/drm/i915/intel_dp.c | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)
drivers/gpu/drm/i915/intel_dp.c +5 -1
index e48d47c..c7a52d1 100644
@@ -313,8 +313,12 @@ static bool edp_have_panel_vdd(struct intel_dp *intel_dp)
 {
 	struct drm_device *dev = intel_dp_to_dev(intel_dp);
 	struct drm_i915_private *dev_priv = dev->dev_private;
+	struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
+	struct intel_encoder *intel_encoder = &intel_dig_port->base;
+	enum intel_display_power_domain power_domain;
 
-	return !dev_priv->pm.suspended &&
+	power_domain = intel_display_port_power_domain(intel_encoder);
+	return intel_display_power_enabled(dev_priv, power_domain) &&
 	       (I915_READ(_pp_ctrl_reg(intel_dp)) & EDP_FORCE_VDD) != 0;
 }
 
Signature · 1 line
1.8.4
#18 lore raw

Re: [PATCH 07/15] drm/i915: vlv: check port power domain instead of only D0 for eDP VDD on

2014-04-08 13:57 GMT-03:00 Imre Deak <[email protected]>:

Quoted 17 lines

Some platforms need additional power domains to be on in addition to the device D0 state to access the panel registers.

Suggested by Daniel.

Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=76987

---
 drivers/gpu/drm/i915/intel_dp.c | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)
drivers/gpu/drm/i915/intel_dp.c +0 -0
index e48d47c..c7a52d1 100644
@@ -313,8 +313,12 @@ static bool edp_have_panel_vdd(struct intel_dp *intel_dp)
 {

drivers/gpu/drm/i915/intel_dp.c static bool edp_have_panel_vdd(struct intel_dp *intel_dp) · line 322

Quoted 10 lines
drivers/gpu/drm/i915/intel_dp.c +5 -1
        struct drm_device *dev = intel_dp_to_dev(intel_dp);
        struct drm_i915_private *dev_priv = dev->dev_private;
+       struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
+       struct intel_encoder *intel_encoder = &intel_dig_port->base;
+       enum intel_display_power_domain power_domain;
 
-       return !dev_priv->pm.suspended &&
+       power_domain = intel_display_port_power_domain(intel_encoder);
+       return intel_display_power_enabled(dev_priv, power_domain) &&
               (I915_READ(_pp_ctrl_reg(intel_dp)) & EDP_FORCE_VDD) != 0;

This is an interesting problem. The patch looks like the correct fix for VLV, but it creates the problem that it will enable unneeded power wells on HSW/BDW. My crystal ball tells me we're gonna have many instances of this type of "problem" in the future. In this case, shouldn't we create a new power domain, e.g., POWER_DOMAIN_EDP_VDD, that grabs the appropriate power wells on VLV, but just gets runtime PM on HSW+?

Quoted 9 lines
drivers/gpu/drm/i915/intel_dp.c +0 -1
 }
 
--

1.8.4

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx

Signature · 1 line
Paulo Zanoni
author
#19 lore raw

Re: [PATCH 07/15] drm/i915: vlv: check port power domain instead of only D0 for eDP VDD on

Quoted 24 lines · Paulo Zanoni

2014-04-08 13:57 GMT-03:00 Imre Deak <[email protected]>:

Quoted 23 lines

Some platforms need additional power domains to be on in addition to the device D0 state to access the panel registers.

Suggested by Daniel.

Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=76987

---
 drivers/gpu/drm/i915/intel_dp.c | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)
drivers/gpu/drm/i915/intel_dp.c +3 -0
index e48d47c..c7a52d1 100644
@@ -313,8 +313,12 @@ static bool edp_have_panel_vdd(struct intel_dp *intel_dp)
 {
        struct drm_device *dev = intel_dp_to_dev(intel_dp);
        struct drm_i915_private *dev_priv = dev->dev_private;
+       struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
+       struct intel_encoder *intel_encoder = &intel_dig_port->base;
+       enum intel_display_power_domain power_domain;
 
Quoted 8 lines

drivers/gpu/drm/i915/intel_dp.c static bool edp_have_panel_vdd(struct intel_dp *intel_dp) · line 322

Quoted 4 lines
drivers/gpu/drm/i915/intel_dp.c +2 -1
-       return !dev_priv->pm.suspended &&
+       power_domain = intel_display_port_power_domain(intel_encoder);
+       return intel_display_power_enabled(dev_priv, power_domain) &&
               (I915_READ(_pp_ctrl_reg(intel_dp)) & EDP_FORCE_VDD) != 0;

This is an interesting problem. The patch looks like the correct fix for VLV, but it creates the problem that it will enable unneeded power wells on HSW/BDW.

I guess you mean port A here. In that case power_domain is POWER_DOMAIN_PORT_DDI_A_4_LANES, which will map both for HSW and BDW to the always-on power well, hence we only get an RPM ref for them?

Quoted 5 lines

My crystal ball tells me we're gonna have many
instances of this type of "problem" in the future. In this case, shouldn't we create a new power domain, e.g., POWER_DOMAIN_EDP_VDD, that grabs the appropriate power wells on VLV, but just gets runtime PM on HSW+?

Yea, well it's always a possibility that the current granularity is not enough for a new platform and then we have no choice than to extend the set of power domains. This is what happened now for the AUX stuff on SKL, we need to add the new AUX domains. We can also decide that the power saving doesn't justify the complexity and just grab the coarser domain for a given functionality.

--Imre

Quoted 13 lines
Quoted 10 lines
drivers/gpu/drm/i915/intel_dp.c +0 -1
 }
 
--

1.8.4

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx

author
#20 lore raw

PATCH 8/15 drm/i915: vlv: setup RPS min/max frequencies once during init time

In reply to Imre Deak

When enabling RPM on VLV, GT power save enabling becomes relatively frequent, so optimize it a bit.

---
 drivers/gpu/drm/i915/intel_pm.c | 66 +++++++++++++++++++++++++----------------
 1 file changed, 41 insertions(+), 25 deletions(-)
drivers/gpu/drm/i915/intel_pm.c +41 -25
index 869a4e3..e0b8982 100644
@@ -3633,6 +3633,45 @@ static void valleyview_cleanup_pctx(struct drm_device *dev)
 	dev_priv->vlv_pctx = NULL;
 }
 
+static void valleyview_init_gt_powersave(struct drm_device *dev)
+{
+	struct drm_i915_private *dev_priv = dev->dev_private;
+
+	valleyview_setup_pctx(dev);
+
+	mutex_lock(&dev_priv->rps.hw_lock);
+
+	dev_priv->rps.max_freq = valleyview_rps_max_freq(dev_priv);
+	dev_priv->rps.rp0_freq = dev_priv->rps.max_freq;
+	DRM_DEBUG_DRIVER("max GPU freq: %d MHz (%u)\n",
+			 vlv_gpu_freq(dev_priv, dev_priv->rps.max_freq),
+			 dev_priv->rps.max_freq);
+
+	dev_priv->rps.efficient_freq = valleyview_rps_rpe_freq(dev_priv);
+	DRM_DEBUG_DRIVER("RPe GPU freq: %d MHz (%u)\n",
+			 vlv_gpu_freq(dev_priv, dev_priv->rps.efficient_freq),
+			 dev_priv->rps.efficient_freq);
+
+	dev_priv->rps.min_freq = valleyview_rps_min_freq(dev_priv);
+	DRM_DEBUG_DRIVER("min GPU freq: %d MHz (%u)\n",
+			 vlv_gpu_freq(dev_priv, dev_priv->rps.min_freq),
+			 dev_priv->rps.min_freq);
+
+	/* Preserve min/max settings in case of re-init */
+	if (dev_priv->rps.max_freq_softlimit == 0)
+		dev_priv->rps.max_freq_softlimit = dev_priv->rps.max_freq;
+
+	if (dev_priv->rps.min_freq_softlimit == 0)
+		dev_priv->rps.min_freq_softlimit = dev_priv->rps.min_freq;
+
+	mutex_unlock(&dev_priv->rps.hw_lock);
+}
+
+static void valleyview_cleanup_gt_powersave(struct drm_device *dev)
+{
+	valleyview_cleanup_pctx(dev);
+}
+
 static void valleyview_enable_rps(struct drm_device *dev)
 {
 	struct drm_i915_private *dev_priv = dev->dev_private;
@@ -3699,29 +3738,6 @@ static void valleyview_enable_rps(struct drm_device *dev)
 			 vlv_gpu_freq(dev_priv, dev_priv->rps.cur_freq),
 			 dev_priv->rps.cur_freq);
 
-	dev_priv->rps.max_freq = valleyview_rps_max_freq(dev_priv);
-	dev_priv->rps.rp0_freq  = dev_priv->rps.max_freq;
-	DRM_DEBUG_DRIVER("max GPU freq: %d MHz (%u)\n",
-			 vlv_gpu_freq(dev_priv, dev_priv->rps.max_freq),
-			 dev_priv->rps.max_freq);
-
-	dev_priv->rps.efficient_freq = valleyview_rps_rpe_freq(dev_priv);
-	DRM_DEBUG_DRIVER("RPe GPU freq: %d MHz (%u)\n",
-			 vlv_gpu_freq(dev_priv, dev_priv->rps.efficient_freq),
-			 dev_priv->rps.efficient_freq);
-
-	dev_priv->rps.min_freq = valleyview_rps_min_freq(dev_priv);
-	DRM_DEBUG_DRIVER("min GPU freq: %d MHz (%u)\n",
-			 vlv_gpu_freq(dev_priv, dev_priv->rps.min_freq),
-			 dev_priv->rps.min_freq);
-
-	/* Preserve min/max settings in case of re-init */
-	if (dev_priv->rps.max_freq_softlimit == 0)
-		dev_priv->rps.max_freq_softlimit = dev_priv->rps.max_freq;
-
-	if (dev_priv->rps.min_freq_softlimit == 0)
-		dev_priv->rps.min_freq_softlimit = dev_priv->rps.min_freq;
-
 	DRM_DEBUG_DRIVER("setting GPU freq to %d MHz (%u)\n",
 			 vlv_gpu_freq(dev_priv, dev_priv->rps.efficient_freq),
 			 dev_priv->rps.efficient_freq);
@@ -4463,13 +4479,13 @@ static void intel_init_emon(struct drm_device *dev)
 void intel_init_gt_powersave(struct drm_device *dev)
 {
 	if (IS_VALLEYVIEW(dev))
-		valleyview_setup_pctx(dev);
+		valleyview_init_gt_powersave(dev);
 }
 
 void intel_cleanup_gt_powersave(struct drm_device *dev)
 {
 	if (IS_VALLEYVIEW(dev))
-		valleyview_cleanup_pctx(dev);
+		valleyview_cleanup_gt_powersave(dev);
 }
 
 void intel_disable_gt_powersave(struct drm_device *dev)
Signature · 1 line
1.8.4
author
#21 lore raw

PATCH 9/15 drm/i915: vlv: factor out vlv_force_gfx_clock

In reply to Imre Deak

This will be needed by the VLV RPM helpers too.

---
 drivers/gpu/drm/i915/i915_drv.c | 32 ++++++++++++++++++++++++++++++++
 drivers/gpu/drm/i915/i915_drv.h |  1 +
 drivers/gpu/drm/i915/intel_pm.c | 16 ++--------------
 3 files changed, 35 insertions(+), 14 deletions(-)
drivers/gpu/drm/i915/i915_drv.c +32 -0
index 5d8250f..8dee34c 100644
@@ -920,6 +920,38 @@ static void hsw_runtime_resume(struct drm_i915_private *dev_priv)
 	hsw_disable_pc8(dev_priv);
 }
 
+int vlv_force_gfx_clock(struct drm_i915_private *dev_priv, bool force_on)
+{
+	u32 val;
+	int err;
+
+#define COND (I915_READ(VLV_GTLC_SURVIVABILITY_REG) & VLV_GFX_CLK_STATUS_BIT)
+	/* Wait for a previous force on/off to settle */
+	if (force_on) {
+		err = wait_for(!COND, 5);
+		if (err) {
+			DRM_ERROR("timeout waiting for GFX clock force-off\n");
+			return err;
+		}
+	}
+
+	val = I915_READ(VLV_GTLC_SURVIVABILITY_REG);
+	val &= ~VLV_GFX_CLK_FORCE_ON_BIT;
+	if (force_on)
+		val |= VLV_GFX_CLK_FORCE_ON_BIT;
+	I915_WRITE(VLV_GTLC_SURVIVABILITY_REG, val);
+
+	if (!force_on)
+		return 0;
+
+	err = wait_for(COND, 5);
+	if (err)
+		DRM_ERROR("timeout waiting for GFX clock force-on\n");
+
+	return err;
+#undef COND
+}
+
 static int intel_runtime_suspend(struct device *device)
 {
 	struct pci_dev *pdev = to_pci_dev(device);
drivers/gpu/drm/i915/i915_drv.h +1 -0
index 55addaa..0800429 100644
@@ -1952,6 +1952,7 @@ extern unsigned long i915_chipset_val(struct drm_i915_private *dev_priv);
 extern unsigned long i915_mch_val(struct drm_i915_private *dev_priv);
 extern unsigned long i915_gfx_val(struct drm_i915_private *dev_priv);
 extern void i915_update_gfx_val(struct drm_i915_private *dev_priv);
+int vlv_force_gfx_clock(struct drm_i915_private *dev_priv, bool on);
 
 extern void intel_console_resume(struct work_struct *work);
 
drivers/gpu/drm/i915/intel_pm.c +2 -14
index e0b8982..5728238 100644
@@ -3094,16 +3094,7 @@ static void vlv_set_rps_idle(struct drm_i915_private *dev_priv)
 	/* Mask turbo interrupt so that they will not come in between */
 	I915_WRITE(GEN6_PMINTRMSK, 0xffffffff);
 
-	/* Bring up the Gfx clock */
-	I915_WRITE(VLV_GTLC_SURVIVABILITY_REG,
-		I915_READ(VLV_GTLC_SURVIVABILITY_REG) |
-				VLV_GFX_CLK_FORCE_ON_BIT);
-
-	if (wait_for(((VLV_GFX_CLK_STATUS_BIT &
-		I915_READ(VLV_GTLC_SURVIVABILITY_REG)) != 0), 5)) {
-			DRM_ERROR("GFX_CLK_ON request timed out\n");
-		return;
-	}
+	vlv_force_gfx_clock(dev_priv, true);
 
 	dev_priv->rps.cur_freq = dev_priv->rps.min_freq_softlimit;
 
@@ -3114,10 +3105,7 @@ static void vlv_set_rps_idle(struct drm_i915_private *dev_priv)
 				& GENFREQSTATUS) == 0, 5))
 		DRM_ERROR("timed out waiting for Punit\n");
 
-	/* Release the Gfx clock */
-	I915_WRITE(VLV_GTLC_SURVIVABILITY_REG,
-		I915_READ(VLV_GTLC_SURVIVABILITY_REG) &
-				~VLV_GFX_CLK_FORCE_ON_BIT);
+	vlv_force_gfx_clock(dev_priv, false);
 
 	I915_WRITE(GEN6_PMINTRMSK,
 		   gen6_rps_pm_mask(dev_priv, dev_priv->rps.cur_freq));
Signature · 1 line
1.8.4
author
#22 lore raw

PATCH 10/15 drm/i915: disable runtime PM until delayed RPS/RC6 enabling completes

In reply to Imre Deak

At least on some platforms we depend on RC6 being enabled for RPM, so disable RPM until the delayed RC6 enabling completes. For simplicity don't differentiate between platforms, those that don't have this dependency will enable RC6 only rarely during driver init and system resume.

---
 drivers/gpu/drm/i915/i915_drv.c  |  5 ++++-
 drivers/gpu/drm/i915/intel_drv.h |  1 +
 drivers/gpu/drm/i915/intel_pm.c  | 17 +++++++++++++++++
 3 files changed, 22 insertions(+), 1 deletion(-)
drivers/gpu/drm/i915/i915_drv.c +4 -1
index 8dee34c..0948228 100644
@@ -755,7 +755,7 @@ int i915_reset(struct drm_device *dev)
 		 * of re-init after reset. */
 		if (INTEL_INFO(dev)->gen > 5) {
 			mutex_lock(&dev->struct_mutex);
-			intel_enable_gt_powersave(dev);
+			intel_reset_gt_powersave(dev);
 			mutex_unlock(&dev->struct_mutex);
 		}
 
@@ -958,6 +958,9 @@ static int intel_runtime_suspend(struct device *device)
 	struct drm_device *dev = pci_get_drvdata(pdev);
 	struct drm_i915_private *dev_priv = dev->dev_private;
 
+	if (WARN_ON_ONCE(!dev_priv->rps.enabled))
+		return -ENODEV;
+
 	WARN_ON(!HAS_RUNTIME_PM(dev));
 	assert_force_wake_inactive(dev_priv);
 
drivers/gpu/drm/i915/intel_drv.h +1 -0
index 42762b7..7f4e873 100644
@@ -901,6 +901,7 @@ void intel_init_gt_powersave(struct drm_device *dev);
 void intel_cleanup_gt_powersave(struct drm_device *dev);
 void intel_enable_gt_powersave(struct drm_device *dev);
 void intel_disable_gt_powersave(struct drm_device *dev);
+void intel_reset_gt_powersave(struct drm_device *dev);
 void ironlake_teardown_rc6(struct drm_device *dev);
 void gen6_update_ring_freq(struct drm_device *dev);
 void gen6_rps_idle(struct drm_i915_private *dev_priv);
drivers/gpu/drm/i915/intel_pm.c +17 -0
index 5728238..c082936 100644
@@ -4519,6 +4519,8 @@ static void intel_gen6_powersave_work(struct work_struct *work)
 	}
 	dev_priv->rps.enabled = true;
 	mutex_unlock(&dev_priv->rps.hw_lock);
+
+	intel_runtime_pm_put(dev_priv);
 }
 
 void intel_enable_gt_powersave(struct drm_device *dev)
@@ -4534,12 +4536,27 @@ void intel_enable_gt_powersave(struct drm_device *dev)
 		 * PCU communication is slow and this doesn't need to be
 		 * done at any specific time, so do this out of our fast path
 		 * to make resume and init faster.
+		 *
+		 * On platforms like Valleyview we depend on the HW RC6 power
+		 * context save/restore mechanism when entering D3 through
+		 * runtime PM suspend. So disable RPM until RPS/RC6 is
+		 * properly setup.
 		 */
+		if (!cancel_delayed_work(&dev_priv->rps.delayed_resume_work))
+			intel_runtime_pm_get_noresume(dev_priv);
 		schedule_delayed_work(&dev_priv->rps.delayed_resume_work,
 				      round_jiffies_up_relative(HZ));
 	}
 }
 
+void intel_reset_gt_powersave(struct drm_device *dev)
+{
+	struct drm_i915_private *dev_priv = dev->dev_private;
+
+	dev_priv->rps.enabled = false;
+	intel_enable_gt_powersave(dev);
+}
+
 static void ibx_init_clock_gating(struct drm_device *dev)
 {
 	struct drm_i915_private *dev_priv = dev->dev_private;
Signature · 1 line
1.8.4
#23 lore raw

Re: [PATCH 10/15] drm/i915: disable runtime PM until delayed RPS/RC6 enabling completes

Quoted 62 lines · Imre Deak

At least on some platforms we depend on RC6 being enabled for RPM, so disable RPM until the delayed RC6 enabling completes. For simplicity don't differentiate between platforms, those that don't have this dependency will enable RC6 only rarely during driver init and system resume.

---
 drivers/gpu/drm/i915/i915_drv.c  |  5 ++++-
 drivers/gpu/drm/i915/intel_drv.h |  1 +
 drivers/gpu/drm/i915/intel_pm.c  | 17 +++++++++++++++++
 3 files changed, 22 insertions(+), 1 deletion(-)
drivers/gpu/drm/i915/i915_drv.c +4 -1
index 8dee34c..0948228 100644
@@ -755,7 +755,7 @@ int i915_reset(struct drm_device *dev)
 		 * of re-init after reset. */
 		if (INTEL_INFO(dev)->gen > 5) {
 			mutex_lock(&dev->struct_mutex);
-			intel_enable_gt_powersave(dev);
+			intel_reset_gt_powersave(dev);
 			mutex_unlock(&dev->struct_mutex);
 		}
 
@@ -958,6 +958,9 @@ static int intel_runtime_suspend(struct device *device)
 	struct drm_device *dev = pci_get_drvdata(pdev);
 	struct drm_i915_private *dev_priv = dev->dev_private;
 
+	if (WARN_ON_ONCE(!dev_priv->rps.enabled))
+		return -ENODEV;
+
 	WARN_ON(!HAS_RUNTIME_PM(dev));
 	assert_force_wake_inactive(dev_priv);
 
drivers/gpu/drm/i915/intel_drv.h +1 -0
index 42762b7..7f4e873 100644
@@ -901,6 +901,7 @@ void intel_init_gt_powersave(struct drm_device *dev);
 void intel_cleanup_gt_powersave(struct drm_device *dev);
 void intel_enable_gt_powersave(struct drm_device *dev);
 void intel_disable_gt_powersave(struct drm_device *dev);
+void intel_reset_gt_powersave(struct drm_device *dev);
 void ironlake_teardown_rc6(struct drm_device *dev);
 void gen6_update_ring_freq(struct drm_device *dev);
 void gen6_rps_idle(struct drm_i915_private *dev_priv);
drivers/gpu/drm/i915/intel_pm.c +2 -0
index 5728238..c082936 100644
@@ -4519,6 +4519,8 @@ static void intel_gen6_powersave_work(struct work_struct *work)
 	}
 	dev_priv->rps.enabled = true;
 	mutex_unlock(&dev_priv->rps.hw_lock);
+
+	intel_runtime_pm_put(dev_priv);
 }
 
 void intel_enable_gt_powersave(struct drm_device *dev)

drivers/gpu/drm/i915/intel_pm.c void intel_enable_gt_powersave(struct drm_device *dev) · line 4544

Quoted 9 lines
drivers/gpu/drm/i915/intel_pm.c +5 -0
@@ -4534,12 +4536,27 @@ void intel_enable_gt_powersave(struct drm_device *dev)
 		 * PCU communication is slow and this doesn't need to be
 		 * done at any specific time, so do this out of our fast path
 		 * to make resume and init faster.
+		 *
+		 * On platforms like Valleyview we depend on the HW RC6 power
+		 * context save/restore mechanism when entering D3 through
+		 * runtime PM suspend. So disable RPM until RPS/RC6 is
+		 * properly setup.
 		 */

I'm pretty sure that depency also exists on other platforms since I did wonder quite a bit how the current runtime pm stuff resurrects the render state ;-)

Imo the right approach here is to grab a runtime pm reference in the function that launches the async work and drop it again when that work has completed. We already temporarily disable runtime pm in driver load and suspend/resume code, so that should cover us.
-Daniel

Quoted 25 lines
drivers/gpu/drm/i915/intel_pm.c +10 -0
+		if (!cancel_delayed_work(&dev_priv->rps.delayed_resume_work))
+			intel_runtime_pm_get_noresume(dev_priv);
 		schedule_delayed_work(&dev_priv->rps.delayed_resume_work,
 				      round_jiffies_up_relative(HZ));
 	}
 }
 
+void intel_reset_gt_powersave(struct drm_device *dev)
+{
+	struct drm_i915_private *dev_priv = dev->dev_private;
+
+	dev_priv->rps.enabled = false;
+	intel_enable_gt_powersave(dev);
+}
+
 static void ibx_init_clock_gating(struct drm_device *dev)
 {
 	struct drm_i915_private *dev_priv = dev->dev_private;
Signature · 6 lines
1.8.4

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
Signature · 3 lines
Daniel Vetter
Software Engineer, Intel Corporation
+41 (0) 79 365 57 48 - http://blog.ffwll.ch
author
#24 lore raw

Re: [PATCH 10/15] drm/i915: disable runtime PM until delayed RPS/RC6 enabling completes

Quoted 61 lines · Daniel Vetter
Quoted 60 lines · Imre Deak

At least on some platforms we depend on RC6 being enabled for RPM, so disable RPM until the delayed RC6 enabling completes. For simplicity don't differentiate between platforms, those that don't have this dependency will enable RC6 only rarely during driver init and system resume.

---
 drivers/gpu/drm/i915/i915_drv.c  |  5 ++++-
 drivers/gpu/drm/i915/intel_drv.h |  1 +
 drivers/gpu/drm/i915/intel_pm.c  | 17 +++++++++++++++++
 3 files changed, 22 insertions(+), 1 deletion(-)
drivers/gpu/drm/i915/i915_drv.c +4 -1
index 8dee34c..0948228 100644
@@ -755,7 +755,7 @@ int i915_reset(struct drm_device *dev)
 		 * of re-init after reset. */
 		if (INTEL_INFO(dev)->gen > 5) {
 			mutex_lock(&dev->struct_mutex);
-			intel_enable_gt_powersave(dev);
+			intel_reset_gt_powersave(dev);
 			mutex_unlock(&dev->struct_mutex);
 		}
 
@@ -958,6 +958,9 @@ static int intel_runtime_suspend(struct device *device)
 	struct drm_device *dev = pci_get_drvdata(pdev);
 	struct drm_i915_private *dev_priv = dev->dev_private;
 
+	if (WARN_ON_ONCE(!dev_priv->rps.enabled))
+		return -ENODEV;
+
 	WARN_ON(!HAS_RUNTIME_PM(dev));
 	assert_force_wake_inactive(dev_priv);
 
drivers/gpu/drm/i915/intel_drv.h +1 -0
index 42762b7..7f4e873 100644
@@ -901,6 +901,7 @@ void intel_init_gt_powersave(struct drm_device *dev);
 void intel_cleanup_gt_powersave(struct drm_device *dev);
 void intel_enable_gt_powersave(struct drm_device *dev);
 void intel_disable_gt_powersave(struct drm_device *dev);
+void intel_reset_gt_powersave(struct drm_device *dev);
 void ironlake_teardown_rc6(struct drm_device *dev);
 void gen6_update_ring_freq(struct drm_device *dev);
 void gen6_rps_idle(struct drm_i915_private *dev_priv);
drivers/gpu/drm/i915/intel_pm.c +2 -0
index 5728238..c082936 100644
@@ -4519,6 +4519,8 @@ static void intel_gen6_powersave_work(struct work_struct *work)
 	}
 	dev_priv->rps.enabled = true;
 	mutex_unlock(&dev_priv->rps.hw_lock);
+
+	intel_runtime_pm_put(dev_priv);
 }
 
Quoted 15 lines

drivers/gpu/drm/i915/intel_pm.c void intel_enable_gt_powersave(struct drm_device *dev) · line 4544

Quoted 11 lines
drivers/gpu/drm/i915/intel_pm.c +5 -0
 void intel_enable_gt_powersave(struct drm_device *dev)
@@ -4534,12 +4536,27 @@ void intel_enable_gt_powersave(struct drm_device *dev)
 		 * PCU communication is slow and this doesn't need to be
 		 * done at any specific time, so do this out of our fast path
 		 * to make resume and init faster.
+		 *
+		 * On platforms like Valleyview we depend on the HW RC6 power
+		 * context save/restore mechanism when entering D3 through
+		 * runtime PM suspend. So disable RPM until RPS/RC6 is
+		 * properly setup.
 		 */

I'm pretty sure that depency also exists on other platforms since I did wonder quite a bit how the current runtime pm stuff resurrects the render state ;-)

Yes, that's possible, I haven't checked this for other platforms, but they should be covered too after this patch. Well, we'll still need to re-enable RPS for those during RPM resume. Perhaps that can be done in the context of the refactoring work you asked for 14/15.

Quoted 3 lines

Imo the right approach here is to grab a runtime pm reference in the function that launches the async work and drop it again when that work has completed.

Do you mean something different than what this patch does? I get here the RPM reference when rps.delayed_resume_work is scheduled and drop it when the work is completed. Note that after we enable RPM for VLV we have to do this same sequence when re-enabling RPS from runtime resume, hence the _noresume version.

Quoted 2 lines

We already temporarily disable runtime pm in driver load and suspend/resume code, so that should cover us.

As stated above, we need the same re-enabling sequence during runtime resume.

--Imre

Quoted 29 lines

-Daniel

Quoted 25 lines
drivers/gpu/drm/i915/intel_pm.c +10 -0
+		if (!cancel_delayed_work(&dev_priv->rps.delayed_resume_work))
+			intel_runtime_pm_get_noresume(dev_priv);
 		schedule_delayed_work(&dev_priv->rps.delayed_resume_work,
 				      round_jiffies_up_relative(HZ));
 	}
 }
 
+void intel_reset_gt_powersave(struct drm_device *dev)
+{
+	struct drm_i915_private *dev_priv = dev->dev_private;
+
+	dev_priv->rps.enabled = false;
+	intel_enable_gt_powersave(dev);
+}
+
 static void ibx_init_clock_gating(struct drm_device *dev)
 {
 	struct drm_i915_private *dev_priv = dev->dev_private;
Signature · 6 lines
1.8.4

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
#25 lore raw

Re: [PATCH 10/15] drm/i915: disable runtime PM until delayed RPS/RC6 enabling completes

Quoted 87 lines · Imre Deak
Quoted 61 lines · Daniel Vetter
Quoted 60 lines · Imre Deak

At least on some platforms we depend on RC6 being enabled for RPM, so disable RPM until the delayed RC6 enabling completes. For simplicity don't differentiate between platforms, those that don't have this dependency will enable RC6 only rarely during driver init and system resume.

---
 drivers/gpu/drm/i915/i915_drv.c  |  5 ++++-
 drivers/gpu/drm/i915/intel_drv.h |  1 +
 drivers/gpu/drm/i915/intel_pm.c  | 17 +++++++++++++++++
 3 files changed, 22 insertions(+), 1 deletion(-)
drivers/gpu/drm/i915/i915_drv.c +4 -1
index 8dee34c..0948228 100644
@@ -755,7 +755,7 @@ int i915_reset(struct drm_device *dev)
 		 * of re-init after reset. */
 		if (INTEL_INFO(dev)->gen > 5) {
 			mutex_lock(&dev->struct_mutex);
-			intel_enable_gt_powersave(dev);
+			intel_reset_gt_powersave(dev);
 			mutex_unlock(&dev->struct_mutex);
 		}
 
@@ -958,6 +958,9 @@ static int intel_runtime_suspend(struct device *device)
 	struct drm_device *dev = pci_get_drvdata(pdev);
 	struct drm_i915_private *dev_priv = dev->dev_private;
 
+	if (WARN_ON_ONCE(!dev_priv->rps.enabled))
+		return -ENODEV;
+
 	WARN_ON(!HAS_RUNTIME_PM(dev));
 	assert_force_wake_inactive(dev_priv);
 
drivers/gpu/drm/i915/intel_drv.h +1 -0
index 42762b7..7f4e873 100644
@@ -901,6 +901,7 @@ void intel_init_gt_powersave(struct drm_device *dev);
 void intel_cleanup_gt_powersave(struct drm_device *dev);
 void intel_enable_gt_powersave(struct drm_device *dev);
 void intel_disable_gt_powersave(struct drm_device *dev);
+void intel_reset_gt_powersave(struct drm_device *dev);
 void ironlake_teardown_rc6(struct drm_device *dev);
 void gen6_update_ring_freq(struct drm_device *dev);
 void gen6_rps_idle(struct drm_i915_private *dev_priv);
drivers/gpu/drm/i915/intel_pm.c +2 -0
index 5728238..c082936 100644
@@ -4519,6 +4519,8 @@ static void intel_gen6_powersave_work(struct work_struct *work)
 	}
 	dev_priv->rps.enabled = true;
 	mutex_unlock(&dev_priv->rps.hw_lock);
+
+	intel_runtime_pm_put(dev_priv);
 }
 
Quoted 15 lines

drivers/gpu/drm/i915/intel_pm.c void intel_enable_gt_powersave(struct drm_device *dev) · line 4544

Quoted 11 lines
drivers/gpu/drm/i915/intel_pm.c +5 -0
 void intel_enable_gt_powersave(struct drm_device *dev)
@@ -4534,12 +4536,27 @@ void intel_enable_gt_powersave(struct drm_device *dev)
 		 * PCU communication is slow and this doesn't need to be
 		 * done at any specific time, so do this out of our fast path
 		 * to make resume and init faster.
+		 *
+		 * On platforms like Valleyview we depend on the HW RC6 power
+		 * context save/restore mechanism when entering D3 through
+		 * runtime PM suspend. So disable RPM until RPS/RC6 is
+		 * properly setup.
 		 */

I'm pretty sure that depency also exists on other platforms since I did wonder quite a bit how the current runtime pm stuff resurrects the render state ;-)

Yes, that's possible, I haven't checked this for other platforms, but they should be covered too after this patch. Well, we'll still need to re-enable RPS for those during RPM resume. Perhaps that can be done in the context of the refactoring work you asked for 14/15.

Quoted 3 lines

Imo the right approach here is to grab a runtime pm reference in the function that launches the async work and drop it again when that work has completed.

Quoted 5 lines

Do you mean something different than what this patch does? I get here the RPM reference when rps.delayed_resume_work is scheduled and drop it when the work is completed. Note that after we enable RPM for VLV we have to do this same sequence when re-enabling RPS from runtime resume, hence the _noresume version.

Ah, just failed to read the patch, somehow was getting confused ... Please extend this comment to explain why we need the _noresume variant, that sounds like a really crucial detail.
-Daniel

Signature · 3 lines
Daniel Vetter
Software Engineer, Intel Corporation
+41 (0) 79 365 57 48 - http://blog.ffwll.ch
#26 lore raw

Re: [PATCH 10/15] drm/i915: disable runtime PM until delayed RPS/RC6 enabling completes

Quoted 94 lines · Daniel Vetter
Quoted 87 lines · Imre Deak
Quoted 61 lines · Daniel Vetter
Quoted 60 lines · Imre Deak

At least on some platforms we depend on RC6 being enabled for RPM, so disable RPM until the delayed RC6 enabling completes. For simplicity don't differentiate between platforms, those that don't have this dependency will enable RC6 only rarely during driver init and system resume.

---
 drivers/gpu/drm/i915/i915_drv.c  |  5 ++++-
 drivers/gpu/drm/i915/intel_drv.h |  1 +
 drivers/gpu/drm/i915/intel_pm.c  | 17 +++++++++++++++++
 3 files changed, 22 insertions(+), 1 deletion(-)
drivers/gpu/drm/i915/i915_drv.c +4 -1
index 8dee34c..0948228 100644
@@ -755,7 +755,7 @@ int i915_reset(struct drm_device *dev)
 		 * of re-init after reset. */
 		if (INTEL_INFO(dev)->gen > 5) {
 			mutex_lock(&dev->struct_mutex);
-			intel_enable_gt_powersave(dev);
+			intel_reset_gt_powersave(dev);
 			mutex_unlock(&dev->struct_mutex);
 		}
 
@@ -958,6 +958,9 @@ static int intel_runtime_suspend(struct device *device)
 	struct drm_device *dev = pci_get_drvdata(pdev);
 	struct drm_i915_private *dev_priv = dev->dev_private;
 
+	if (WARN_ON_ONCE(!dev_priv->rps.enabled))
+		return -ENODEV;
+
 	WARN_ON(!HAS_RUNTIME_PM(dev));
 	assert_force_wake_inactive(dev_priv);
 
drivers/gpu/drm/i915/intel_drv.h +1 -0
index 42762b7..7f4e873 100644
@@ -901,6 +901,7 @@ void intel_init_gt_powersave(struct drm_device *dev);
 void intel_cleanup_gt_powersave(struct drm_device *dev);
 void intel_enable_gt_powersave(struct drm_device *dev);
 void intel_disable_gt_powersave(struct drm_device *dev);
+void intel_reset_gt_powersave(struct drm_device *dev);
 void ironlake_teardown_rc6(struct drm_device *dev);
 void gen6_update_ring_freq(struct drm_device *dev);
 void gen6_rps_idle(struct drm_i915_private *dev_priv);
drivers/gpu/drm/i915/intel_pm.c +2 -0
index 5728238..c082936 100644
@@ -4519,6 +4519,8 @@ static void intel_gen6_powersave_work(struct work_struct *work)
 	}
 	dev_priv->rps.enabled = true;
 	mutex_unlock(&dev_priv->rps.hw_lock);
+
+	intel_runtime_pm_put(dev_priv);
 }
 
Quoted 15 lines

drivers/gpu/drm/i915/intel_pm.c void intel_enable_gt_powersave(struct drm_device *dev) · line 4544

Quoted 11 lines
drivers/gpu/drm/i915/intel_pm.c +5 -0
 void intel_enable_gt_powersave(struct drm_device *dev)
@@ -4534,12 +4536,27 @@ void intel_enable_gt_powersave(struct drm_device *dev)
 		 * PCU communication is slow and this doesn't need to be
 		 * done at any specific time, so do this out of our fast path
 		 * to make resume and init faster.
+		 *
+		 * On platforms like Valleyview we depend on the HW RC6 power
+		 * context save/restore mechanism when entering D3 through
+		 * runtime PM suspend. So disable RPM until RPS/RC6 is
+		 * properly setup.
 		 */

I'm pretty sure that depency also exists on other platforms since I did wonder quite a bit how the current runtime pm stuff resurrects the render state ;-)

Yes, that's possible, I haven't checked this for other platforms, but they should be covered too after this patch. Well, we'll still need to re-enable RPS for those during RPM resume. Perhaps that can be done in the context of the refactoring work you asked for 14/15.

Quoted 3 lines

Imo the right approach here is to grab a runtime pm reference in the function that launches the async work and drop it again when that work has completed.

Quoted 5 lines

Do you mean something different than what this patch does? I get here the RPM reference when rps.delayed_resume_work is scheduled and drop it when the work is completed. Note that after we enable RPM for VLV we have to do this same sequence when re-enabling RPS from runtime resume, hence the _noresume version.

Quoted 3 lines

Ah, just failed to read the patch, somehow was getting confused ... Please extend this comment to explain why we need the _noresume variant, that sounds like a really crucial detail.

Aside: Collaborating on this test with Mika would be good since he's working on the initial render state stuff for hw contexts/rp6 on bdw. Closely related topics imo. Adding Mika.
-Daniel

Signature · 3 lines
Daniel Vetter
Software Engineer, Intel Corporation
+41 (0) 79 365 57 48 - http://blog.ffwll.ch
author
#27 lore raw

PATCH 11/15 drm/i915: vlv: disable RPM if RC6 is not enabled

In reply to Imre Deak

On VLV we depend on RC6 saving the GT render and media HW context before going to D3 state, so disable RPM if RC6 is not enabled.

---
 drivers/gpu/drm/i915/intel_drv.h |  2 ++
 drivers/gpu/drm/i915/intel_pm.c  | 29 ++++++++++++++++++++++++++++-
 2 files changed, 30 insertions(+), 1 deletion(-)
drivers/gpu/drm/i915/intel_drv.h +2 -0
index 7f4e873..b4fcd14 100644
@@ -902,6 +902,7 @@ void intel_cleanup_gt_powersave(struct drm_device *dev);
 void intel_enable_gt_powersave(struct drm_device *dev);
 void intel_disable_gt_powersave(struct drm_device *dev);
 void intel_reset_gt_powersave(struct drm_device *dev);
+bool valleyview_rc6_enabled(struct drm_device *dev);
 void ironlake_teardown_rc6(struct drm_device *dev);
 void gen6_update_ring_freq(struct drm_device *dev);
 void gen6_rps_idle(struct drm_i915_private *dev_priv);
@@ -909,6 +910,7 @@ void gen6_rps_boost(struct drm_i915_private *dev_priv);
 void intel_aux_display_runtime_get(struct drm_i915_private *dev_priv);
 void intel_aux_display_runtime_put(struct drm_i915_private *dev_priv);
 void intel_runtime_pm_get(struct drm_i915_private *dev_priv);
+void intel_runtime_pm_get_noresume(struct drm_i915_private *dev_priv);
 void intel_runtime_pm_put(struct drm_i915_private *dev_priv);
 void intel_init_runtime_pm(struct drm_i915_private *dev_priv);
 void intel_fini_runtime_pm(struct drm_i915_private *dev_priv);
drivers/gpu/drm/i915/intel_pm.c +28 -1
index c082936..15e6b38 100644
@@ -3660,6 +3660,11 @@ static void valleyview_cleanup_gt_powersave(struct drm_device *dev)
 	valleyview_cleanup_pctx(dev);
 }
 
+bool valleyview_rc6_enabled(struct drm_device *dev)
+{
+	return intel_enable_rc6(dev) & INTEL_RC6_ENABLE;
+}
+
 static void valleyview_enable_rps(struct drm_device *dev)
 {
 	struct drm_i915_private *dev_priv = dev->dev_private;
@@ -3709,7 +3714,7 @@ static void valleyview_enable_rps(struct drm_device *dev)
 		   _MASKED_BIT_ENABLE(VLV_COUNT_RANGE_HIGH |
 				      VLV_MEDIA_RC6_COUNT_EN |
 				      VLV_RENDER_RC6_COUNT_EN));
-	if (intel_enable_rc6(dev) & INTEL_RC6_ENABLE)
+	if (valleyview_rc6_enabled(dev))
 		rc6_mode = GEN7_RC_CTL_TO_MODE | VLV_RC_CTL_CTX_RST_PARALLEL;
 
 	intel_print_rc6_info(dev, rc6_mode);
@@ -6010,6 +6015,18 @@ void intel_runtime_pm_get(struct drm_i915_private *dev_priv)
 	WARN(dev_priv->pm.suspended, "Device still suspended.\n");
 }
 
+void intel_runtime_pm_get_noresume(struct drm_i915_private *dev_priv)
+{
+	struct drm_device *dev = dev_priv->dev;
+	struct device *device = &dev->pdev->dev;
+
+	if (!HAS_RUNTIME_PM(dev))
+		return;
+
+	WARN(dev_priv->pm.suspended, "Can't get nosync-ref while suspended.\n");
+	pm_runtime_get_noresume(device);
+}
+
 void intel_runtime_pm_put(struct drm_i915_private *dev_priv)
 {
 	struct drm_device *dev = dev_priv->dev;
@@ -6032,6 +6049,13 @@ void intel_init_runtime_pm(struct drm_i915_private *dev_priv)
 
 	pm_runtime_set_active(device);
 
+	/*
+	 * On Valleyview we depend on the HW RC6 power context save/restore
+	 * mechanism for RPM, so leave RPM disabled if RC6 is disabled.
+	 */
+	if (IS_VALLEYVIEW(dev) && !valleyview_rc6_enabled(dev))
+		return;
+
 	pm_runtime_set_autosuspend_delay(device, 10000); /* 10s */
 	pm_runtime_mark_last_busy(device);
 	pm_runtime_use_autosuspend(device);
@@ -6047,6 +6071,9 @@ void intel_fini_runtime_pm(struct drm_i915_private *dev_priv)
 	if (!HAS_RUNTIME_PM(dev))
 		return;
 
+	if (IS_VALLEYVIEW(dev) && !valleyview_rc6_enabled(dev))
+		return;
+
 	/* Make sure we're not suspended first. */
 	pm_runtime_get_sync(device);
 	pm_runtime_disable(device);
Signature · 1 line
1.8.4
#28 lore raw

Re: [PATCH 11/15] drm/i915: vlv: disable RPM if RC6 is not enabled

2014-04-08 13:57 GMT-03:00 Imre Deak <[email protected]>:

Quoted 2 lines

On VLV we depend on RC6 saving the GT render and media HW context before going to D3 state, so disable RPM if RC6 is not enabled.

Maybe this problem affects other platforms too, and we just didn't notice because RC6 is always enabled on them. Did we test this on the other platforms?

Do we have a way to disable RC6 at runtime? If yes, then we could probably try to write some test at pm_pc8.c.

Quoted 102 lines
---
 drivers/gpu/drm/i915/intel_drv.h |  2 ++
 drivers/gpu/drm/i915/intel_pm.c  | 29 ++++++++++++++++++++++++++++-
 2 files changed, 30 insertions(+), 1 deletion(-)
drivers/gpu/drm/i915/intel_drv.h +2 -0
index 7f4e873..b4fcd14 100644
@@ -902,6 +902,7 @@ void intel_cleanup_gt_powersave(struct drm_device *dev);
 void intel_enable_gt_powersave(struct drm_device *dev);
 void intel_disable_gt_powersave(struct drm_device *dev);
 void intel_reset_gt_powersave(struct drm_device *dev);
+bool valleyview_rc6_enabled(struct drm_device *dev);
 void ironlake_teardown_rc6(struct drm_device *dev);
 void gen6_update_ring_freq(struct drm_device *dev);
 void gen6_rps_idle(struct drm_i915_private *dev_priv);
@@ -909,6 +910,7 @@ void gen6_rps_boost(struct drm_i915_private *dev_priv);
 void intel_aux_display_runtime_get(struct drm_i915_private *dev_priv);
 void intel_aux_display_runtime_put(struct drm_i915_private *dev_priv);
 void intel_runtime_pm_get(struct drm_i915_private *dev_priv);
+void intel_runtime_pm_get_noresume(struct drm_i915_private *dev_priv);
 void intel_runtime_pm_put(struct drm_i915_private *dev_priv);
 void intel_init_runtime_pm(struct drm_i915_private *dev_priv);
 void intel_fini_runtime_pm(struct drm_i915_private *dev_priv);
drivers/gpu/drm/i915/intel_pm.c +28 -2
index c082936..15e6b38 100644
@@ -3660,6 +3660,11 @@ static void valleyview_cleanup_gt_powersave(struct drm_device *dev)
        valleyview_cleanup_pctx(dev);
 }
 
+bool valleyview_rc6_enabled(struct drm_device *dev)
+{
+       return intel_enable_rc6(dev) & INTEL_RC6_ENABLE;
+}
+
 static void valleyview_enable_rps(struct drm_device *dev)
 {
        struct drm_i915_private *dev_priv = dev->dev_private;
@@ -3709,7 +3714,7 @@ static void valleyview_enable_rps(struct drm_device *dev)
                   _MASKED_BIT_ENABLE(VLV_COUNT_RANGE_HIGH |
                                      VLV_MEDIA_RC6_COUNT_EN |
                                      VLV_RENDER_RC6_COUNT_EN));
-       if (intel_enable_rc6(dev) & INTEL_RC6_ENABLE)
+       if (valleyview_rc6_enabled(dev))
                rc6_mode = GEN7_RC_CTL_TO_MODE | VLV_RC_CTL_CTX_RST_PARALLEL;
 
        intel_print_rc6_info(dev, rc6_mode);
@@ -6010,6 +6015,18 @@ void intel_runtime_pm_get(struct drm_i915_private *dev_priv)
        WARN(dev_priv->pm.suspended, "Device still suspended.\n");
 }
 
+void intel_runtime_pm_get_noresume(struct drm_i915_private *dev_priv)
+{
+       struct drm_device *dev = dev_priv->dev;
+       struct device *device = &dev->pdev->dev;
+
+       if (!HAS_RUNTIME_PM(dev))
+               return;
+
+       WARN(dev_priv->pm.suspended, "Can't get nosync-ref while suspended.\n");
+       pm_runtime_get_noresume(device);
+}
+
 void intel_runtime_pm_put(struct drm_i915_private *dev_priv)
 {
        struct drm_device *dev = dev_priv->dev;
@@ -6032,6 +6049,13 @@ void intel_init_runtime_pm(struct drm_i915_private *dev_priv)
 
        pm_runtime_set_active(device);
 
+       /*
+        * On Valleyview we depend on the HW RC6 power context save/restore
+        * mechanism for RPM, so leave RPM disabled if RC6 is disabled.
+        */
+       if (IS_VALLEYVIEW(dev) && !valleyview_rc6_enabled(dev))
+               return;
+
        pm_runtime_set_autosuspend_delay(device, 10000); /* 10s */
        pm_runtime_mark_last_busy(device);
        pm_runtime_use_autosuspend(device);
@@ -6047,6 +6071,9 @@ void intel_fini_runtime_pm(struct drm_i915_private *dev_priv)
        if (!HAS_RUNTIME_PM(dev))
                return;
 
+       if (IS_VALLEYVIEW(dev) && !valleyview_rc6_enabled(dev))
+               return;
+
        /* Make sure we're not suspended first. */
        pm_runtime_get_sync(device);
        pm_runtime_disable(device);
--

1.8.4

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx

Signature · 1 line
Paulo Zanoni
author
#29 lore raw

Re: [PATCH 11/15] drm/i915: vlv: disable RPM if RC6 is not enabled

Quoted 7 lines · Paulo Zanoni

2014-04-08 13:57 GMT-03:00 Imre Deak <[email protected]>:

Quoted 2 lines

On VLV we depend on RC6 saving the GT render and media HW context before going to D3 state, so disable RPM if RC6 is not enabled.

Maybe this problem affects other platforms too, and we just didn't notice because RC6 is always enabled on them. Did we test this on the other platforms?

No, tbh I wanted to submit this as early as possible. I think now with patch 10/15 RPM should be disabled for all GEN6+ platforms.

Quoted 2 lines

Do we have a way to disable RC6 at runtime? If yes, then we could probably try to write some test at pm_pc8.c.

It's a module option, but I can look into adding a test for it.

--Imre

Quoted 104 lines
Quoted 101 lines
---
 drivers/gpu/drm/i915/intel_drv.h |  2 ++
 drivers/gpu/drm/i915/intel_pm.c  | 29 ++++++++++++++++++++++++++++-
 2 files changed, 30 insertions(+), 1 deletion(-)
drivers/gpu/drm/i915/intel_drv.h +2 -0
index 7f4e873..b4fcd14 100644
@@ -902,6 +902,7 @@ void intel_cleanup_gt_powersave(struct drm_device *dev);
 void intel_enable_gt_powersave(struct drm_device *dev);
 void intel_disable_gt_powersave(struct drm_device *dev);
 void intel_reset_gt_powersave(struct drm_device *dev);
+bool valleyview_rc6_enabled(struct drm_device *dev);
 void ironlake_teardown_rc6(struct drm_device *dev);
 void gen6_update_ring_freq(struct drm_device *dev);
 void gen6_rps_idle(struct drm_i915_private *dev_priv);
@@ -909,6 +910,7 @@ void gen6_rps_boost(struct drm_i915_private *dev_priv);
 void intel_aux_display_runtime_get(struct drm_i915_private *dev_priv);
 void intel_aux_display_runtime_put(struct drm_i915_private *dev_priv);
 void intel_runtime_pm_get(struct drm_i915_private *dev_priv);
+void intel_runtime_pm_get_noresume(struct drm_i915_private *dev_priv);
 void intel_runtime_pm_put(struct drm_i915_private *dev_priv);
 void intel_init_runtime_pm(struct drm_i915_private *dev_priv);
 void intel_fini_runtime_pm(struct drm_i915_private *dev_priv);
drivers/gpu/drm/i915/intel_pm.c +28 -2
index c082936..15e6b38 100644
@@ -3660,6 +3660,11 @@ static void valleyview_cleanup_gt_powersave(struct drm_device *dev)
        valleyview_cleanup_pctx(dev);
 }
 
+bool valleyview_rc6_enabled(struct drm_device *dev)
+{
+       return intel_enable_rc6(dev) & INTEL_RC6_ENABLE;
+}
+
 static void valleyview_enable_rps(struct drm_device *dev)
 {
        struct drm_i915_private *dev_priv = dev->dev_private;
@@ -3709,7 +3714,7 @@ static void valleyview_enable_rps(struct drm_device *dev)
                   _MASKED_BIT_ENABLE(VLV_COUNT_RANGE_HIGH |
                                      VLV_MEDIA_RC6_COUNT_EN |
                                      VLV_RENDER_RC6_COUNT_EN));
-       if (intel_enable_rc6(dev) & INTEL_RC6_ENABLE)
+       if (valleyview_rc6_enabled(dev))
                rc6_mode = GEN7_RC_CTL_TO_MODE | VLV_RC_CTL_CTX_RST_PARALLEL;
 
        intel_print_rc6_info(dev, rc6_mode);
@@ -6010,6 +6015,18 @@ void intel_runtime_pm_get(struct drm_i915_private *dev_priv)
        WARN(dev_priv->pm.suspended, "Device still suspended.\n");
 }
 
+void intel_runtime_pm_get_noresume(struct drm_i915_private *dev_priv)
+{
+       struct drm_device *dev = dev_priv->dev;
+       struct device *device = &dev->pdev->dev;
+
+       if (!HAS_RUNTIME_PM(dev))
+               return;
+
+       WARN(dev_priv->pm.suspended, "Can't get nosync-ref while suspended.\n");
+       pm_runtime_get_noresume(device);
+}
+
 void intel_runtime_pm_put(struct drm_i915_private *dev_priv)
 {
        struct drm_device *dev = dev_priv->dev;
@@ -6032,6 +6049,13 @@ void intel_init_runtime_pm(struct drm_i915_private *dev_priv)
 
        pm_runtime_set_active(device);
 
+       /*
+        * On Valleyview we depend on the HW RC6 power context save/restore
+        * mechanism for RPM, so leave RPM disabled if RC6 is disabled.
+        */
+       if (IS_VALLEYVIEW(dev) && !valleyview_rc6_enabled(dev))
+               return;
+
        pm_runtime_set_autosuspend_delay(device, 10000); /* 10s */
        pm_runtime_mark_last_busy(device);
        pm_runtime_use_autosuspend(device);
@@ -6047,6 +6071,9 @@ void intel_fini_runtime_pm(struct drm_i915_private *dev_priv)
        if (!HAS_RUNTIME_PM(dev))
                return;
 
+       if (IS_VALLEYVIEW(dev) && !valleyview_rc6_enabled(dev))
+               return;
+
        /* Make sure we're not suspended first. */
        pm_runtime_get_sync(device);
        pm_runtime_disable(device);
--

1.8.4

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx

#30 lore raw

Re: [PATCH 11/15] drm/i915: vlv: disable RPM if RC6 is not enabled

Quoted 9 lines · Imre Deak
Quoted 7 lines · Paulo Zanoni

2014-04-08 13:57 GMT-03:00 Imre Deak <[email protected]>:

Quoted 2 lines

On VLV we depend on RC6 saving the GT render and media HW context before going to D3 state, so disable RPM if RC6 is not enabled.

Maybe this problem affects other platforms too, and we just didn't notice because RC6 is always enabled on them. Did we test this on the other platforms?

Quoted 7 lines

No, tbh I wanted to submit this as early as possible. I think now with patch 10/15 RPM should be disabled for all GEN6+ platforms.

Quoted 2 lines

Do we have a way to disable RC6 at runtime? If yes, then we could probably try to write some test at pm_pc8.c.

It's a module option, but I can look into adding a test for it.

Doing a test for this is fairly tricky and since disabling rc6 isn't a supported option really not that useful imo. What might be genuinely useful though is checking that the entire render state gets restored correctly by doing
- rendercpy batch
- make sure we go into runtime suspend
- re-emit the rendercpy 3D_PRIM command _without_ all the state setup

This obviously needs hw contexts to work. If we somehow fail to restore some of the render state then this should nicely blow up all over the place. Of course it's a crude check, but better than just doing a blit or something which essentially just checks that the rings and ptes still work.
-Daniel

Signature · 3 lines
Daniel Vetter
Software Engineer, Intel Corporation
+41 (0) 79 365 57 48 - http://blog.ffwll.ch
author
#31 lore raw

PATCH 12/15 drm/i915: add various missing GTI/Gunit register definitions

In reply to Imre Deak

Needed by the VLV S0ix context save/restore helpers.

---
 drivers/gpu/drm/i915/i915_reg.h | 43 ++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 42 insertions(+), 1 deletion(-)
drivers/gpu/drm/i915/i915_reg.h +42 -1
index c4fd089..4796c3c 100644
@@ -92,6 +92,9 @@
 #define   GEN6_MBC_SNPCR_LOW	(2<<21)
 #define   GEN6_MBC_SNPCR_MIN	(3<<21) /* only 1/16th of the cache is shared */
 
+#define GEN7_G3DCTL		0x9024
+#define GEN7_GSCKGCTL		0x9028
+
 #define GEN6_MBCTL		0x0907c
 #define   GEN6_MBCTL_ENABLE_BOOT_FETCH	(1 << 4)
 #define   GEN6_MBCTL_CTX_FETCH_NEEDED	(1 << 3)
@@ -775,9 +778,20 @@ enum punit_power_well {
 #define RING_MAX_IDLE(base)	((base)+0x54)
 #define RING_HWS_PGA(base)	((base)+0x80)
 #define RING_HWS_PGA_GEN6(base)	((base)+0x2080)
-#define ARB_MODE		0x04030
+
+#define GEN7_WR_WATERMARK	0x4028
+#define GEN7_GFX_PRIO_CTRL	0x402C
+#define ARB_MODE		0x4030
 #define   ARB_MODE_SWIZZLE_SNB	(1<<4)
 #define   ARB_MODE_SWIZZLE_IVB	(1<<5)
+#define GEN7_GFX_PEND_TLB0	0x4034
+#define GEN7_GFX_PEND_TLB1	0x4038
+/* L3, CVS, ZTLB, RCC, CASC LRA min, max values */
+#define GEN7_LRA_LIMITS_BASE	0x403C
+#define GEN7_LRA_LIMITS_REG_NUM	13
+#define GEN7_MEDIA_MAX_REQ_COUNT	0x4070
+#define GEN7_GFX_MAX_REQ_COUNT		0x4074
+
 #define GAMTARBMODE		0x04a08
 #define   ARB_MODE_BWGTLB_DISABLE (1<<9)
 #define   ARB_MODE_SWIZZLE_BDW	(1<<1)
@@ -812,6 +826,9 @@ enum punit_power_well {
 #define   RING_WAIT_I8XX	(1<<0) /* gen2, PRBx_HEAD */
 #define   RING_WAIT		(1<<11) /* gen3+, PRBx_CTL */
 #define   RING_WAIT_SEMAPHORE	(1<<10) /* gen6+ */
+
+#define GEN7_TLB_RD_ADDR	0x4700
+
 #if 0
 #define PRB0_TAIL	0x02030
 #define PRB0_HEAD	0x02034
@@ -938,6 +955,8 @@ enum punit_power_well {
 
 #define VLV_DISPLAY_BASE 0x180000
 
+#define VLV_GU_CTL0	(VLV_DISPLAY_BASE + 0x2030)
+#define VLV_GU_CTL1	(VLV_DISPLAY_BASE + 0x2034)
 #define SCPD0		0x0209c /* 915+ only */
 #define IER		0x020a0
 #define IIR		0x020a4
@@ -945,6 +964,7 @@ enum punit_power_well {
 #define ISR		0x020ac
 #define VLV_GUNIT_CLOCK_GATE	(VLV_DISPLAY_BASE + 0x2060)
 #define   GCFG_DIS		(1<<8)
+#define VLV_GUNIT_CLOCK_GATE2	(VLV_DISPLAY_BASE + 0x2064)
 #define VLV_IIR_RW	(VLV_DISPLAY_BASE + 0x2084)
 #define VLV_IER		(VLV_DISPLAY_BASE + 0x20a0)
 #define VLV_IIR		(VLV_DISPLAY_BASE + 0x20a4)
@@ -4977,6 +4997,8 @@ enum punit_power_well {
 
 #define  EDP_LINK_TRAIN_VOL_EMP_MASK_IVB	(0x3f<<22)
 
+#define  VLV_PMWGICZ				0x1300a4
+
 #define  FORCEWAKE				0xA18C
 #define  FORCEWAKE_VLV				0x1300b0
 #define  FORCEWAKE_ACK_VLV			0x1300b4
@@ -5000,6 +5022,7 @@ enum punit_power_well {
 #define  FORCEWAKE_MT_ACK			0x130040
 #define  ECOBUS					0xa180
 #define    FORCEWAKE_MT_ENABLE			(1<<5)
+#define  VLV_SPAREG2H				0xA194
 
 #define  GTFIFODBG				0x120000
 #define    GT_FIFO_SBDROPERR			(1<<6)
@@ -5029,12 +5052,24 @@ enum punit_power_well {
 # define GEN6_RCPBUNIT_CLOCK_GATE_DISABLE		(1 << 12)
 # define GEN6_RCCUNIT_CLOCK_GATE_DISABLE		(1 << 11)
 
+#define GEN7_UCGCTL3				0x9408
+
 #define GEN7_UCGCTL4				0x940c
 #define  GEN7_L3BANK2X_CLOCK_GATE_DISABLE	(1<<25)
 
+#define GEN7_RCGCTL1				0x9410
+#define GEN7_RCGCTL2				0x9414
+#define GEN7_RSTCTL				0x9420
+
 #define GEN8_UCGCTL6				0x9430
 #define   GEN8_SDEUNIT_CLOCK_GATE_DISABLE	(1<<14)
 
+#define GEN7_GFXPAUSE				0xA000
+#define GEN7_RPDEUHWTC				0xA080
+#define GEN7_RPDEUC				0xA084
+
+#define VLV_PWRDWNUPCTL				0xA294
+
 #define GEN6_RPNSWREQ				0xA008
 #define   GEN6_TURBO_DISABLE			(1<<31)
 #define   GEN6_FREQUENCY(x)			((x)<<25)
@@ -5087,6 +5122,7 @@ enum punit_power_well {
 #define GEN6_RP_UP_EI				0xA068
 #define GEN6_RP_DOWN_EI				0xA06C
 #define GEN6_RP_IDLE_HYSTERSIS			0xA070
+#define GEN7_RPDEUCSW				0xA088
 #define GEN6_RC_STATE				0xA094
 #define GEN6_RC1_WAKE_RATE_LIMIT		0xA098
 #define GEN6_RC6_WAKE_RATE_LIMIT		0xA09C
@@ -5094,9 +5130,11 @@ enum punit_power_well {
 #define GEN6_RC_EVALUATION_INTERVAL		0xA0A8
 #define GEN6_RC_IDLE_HYSTERSIS			0xA0AC
 #define GEN6_RC_SLEEP				0xA0B0
+#define VLV_RCUBMABDTMR				0xA0B0
 #define GEN6_RC1e_THRESHOLD			0xA0B4
 #define GEN6_RC6_THRESHOLD			0xA0B8
 #define GEN6_RC6p_THRESHOLD			0xA0BC
+#define VLV_RCEDATA				0xA0BC
 #define GEN6_RC6pp_THRESHOLD			0xA0C0
 #define GEN6_PMINTRMSK				0xA168
 
@@ -5115,6 +5153,9 @@ enum punit_power_well {
 						 GEN6_PM_RP_DOWN_THRESHOLD | \
 						 GEN6_PM_RP_DOWN_TIMEOUT)
 
+#define GEN7_GT_SCRATCH_BASE			0x4F100
+#define GEN7_GT_SCRATCH_REG_NUM			8
+
 #define VLV_GTLC_SURVIVABILITY_REG              0x130098
 #define VLV_GFX_CLK_STATUS_BIT			(1<<3)
 #define VLV_GFX_CLK_FORCE_ON_BIT		(1<<2)
Signature · 1 line
1.8.4
author
#32 lore raw

PATCH 13/15 drm/i915: vlv: add gunit s0ix save/restore helpers

In reply to Imre Deak

Needed by the next patch adding RPM suspend/resume support to VLV.

---
 drivers/gpu/drm/i915/i915_drv.c | 192 ++++++++++++++++++++++++++++++++++++++++
 drivers/gpu/drm/i915/i915_drv.h |  62 +++++++++++++
 2 files changed, 254 insertions(+)
drivers/gpu/drm/i915/i915_drv.c +192 -0
index 0948228..9f9d0db 100644
@@ -920,6 +920,198 @@ static void hsw_runtime_resume(struct drm_i915_private *dev_priv)
 	hsw_disable_pc8(dev_priv);
 }
 
+/*
+ * Save all Gunit registers that may be lost after a D3 and a subsequent
+ * S0i[R123] transition. The list of registers needing a save/restore is
+ * defined in the VLV2_S0IXRegs document. This documents marks all Gunit
+ * registers in the following way:
+ * - Driver: saved/restored by the driver
+ * - Punit : saved/restored by the Punit firmware
+ * - No, w/o marking: no need to save/restore, since the register is R/O or
+ *                    used internally by the HW in a way that doesn't depend
+ *                    keeping the content across a suspend/resume.
+ * - Debug : used for debugging
+ *
+ * We save/restore all registers marked with 'Driver', with the following
+ * exceptions:
+ * - Registers out of use, including also registers marked with 'Debug'.
+ *   These have no effect on the driver's operation, so we don't save/restore
+ *   them to reduce the overhead.
+ * - Registers that are fully setup by an initialization function called from
+ *   the resume path. For example many clock gating and RPS/RC6 registers.
+ * - Registers that provide the right functionality with their reset defaults.
+ *
+ * TODO: Except for registers that based on the above 3 criteria can be safely
+ * ignored, we save/restore all others, practically treating the HW context as
+ * a black-box for the driver. Further investigation is needed to reduce the
+ * saved/restored registers even further, by following the same 3 criteria.
+ */
+static void vlv_save_gunit_s0ix_state(struct drm_i915_private *dev_priv)
+{
+	struct vlv_s0ix_state *s = &dev_priv->vlv_s0ix_state;
+	int i;
+
+	/* GAM 0x4000-0x4770 */
+	s->wr_watermark		= I915_READ(GEN7_WR_WATERMARK);
+	s->gfx_prio_ctrl	= I915_READ(GEN7_GFX_PRIO_CTRL);
+	s->arb_mode		= I915_READ(ARB_MODE);
+	s->gfx_pend_tlb0	= I915_READ(GEN7_GFX_PEND_TLB0);
+	s->gfx_pend_tlb1	= I915_READ(GEN7_GFX_PEND_TLB1);
+
+	for (i = 0; i < ARRAY_SIZE(s->lra_limits); i++)
+		s->lra_limits[i] = I915_READ(GEN7_LRA_LIMITS_BASE + i * 4);
+
+	s->media_max_req_count	= I915_READ(GEN7_MEDIA_MAX_REQ_COUNT);
+	s->gfx_max_req_count	= I915_READ(GEN7_MEDIA_MAX_REQ_COUNT);
+
+	s->render_hwsp		= I915_READ(RENDER_HWS_PGA_GEN7);
+	s->ecochk		= I915_READ(GAM_ECOCHK);
+	s->bsd_hwsp		= I915_READ(BSD_HWS_PGA_GEN7);
+	s->blt_hwsp		= I915_READ(BLT_HWS_PGA_GEN7);
+
+	s->tlb_rd_addr		= I915_READ(GEN7_TLB_RD_ADDR);
+
+	/* MBC 0x9024-0x91D0, 0x8500 */
+	s->g3dctl		= I915_READ(GEN7_G3DCTL);
+	s->gsckgctl		= I915_READ(GEN7_GSCKGCTL);
+	s->mbctl		= I915_READ(GEN6_MBCTL);
+
+	/* GCP 0x9400-0x9424, 0x8100-0x810C */
+	s->ucgctl1		= I915_READ(GEN6_UCGCTL1);
+	s->ucgctl3		= I915_READ(GEN7_UCGCTL3);
+	s->rcgctl1		= I915_READ(GEN7_RCGCTL1);
+	s->rcgctl2		= I915_READ(GEN7_RCGCTL2);
+	s->rstctl		= I915_READ(GEN7_RSTCTL);
+	s->misccpctl		= I915_READ(GEN7_MISCCPCTL);
+
+	/* GPM 0xA000-0xAA84, 0x8000-0x80FC */
+	s->gfxpause		= I915_READ(GEN7_GFXPAUSE);
+	s->rpdeuhwtc		= I915_READ(GEN7_RPDEUHWTC);
+	s->rpdeuc		= I915_READ(GEN7_RPDEUC);
+	s->ecobus		= I915_READ(ECOBUS);
+	s->pwrdwnupctl		= I915_READ(VLV_PWRDWNUPCTL);
+	s->rp_down_timeout	= I915_READ(GEN6_RP_DOWN_TIMEOUT);
+	s->rp_deucsw		= I915_READ(GEN7_RPDEUCSW);
+	s->rcubmabdtmr		= I915_READ(VLV_RCUBMABDTMR);
+	s->rcedata		= I915_READ(VLV_RCEDATA);
+	s->spare2gh		= I915_READ(VLV_SPAREG2H);
+
+	/* Display CZ domain, 0x4400C-0x4402C, 0x4F000-0x4F11F */
+	s->gt_imr		= I915_READ(GTIMR);
+	s->gt_ier		= I915_READ(GTIER);
+	s->pm_imr		= I915_READ(GEN6_PMIIR);
+	s->pm_ier		= I915_READ(GEN6_PMIER);
+
+	for (i = 0; i < ARRAY_SIZE(s->gt_scratch); i++)
+		s->gt_scratch[i] = I915_READ(GEN7_GT_SCRATCH_BASE + i * 4);
+
+	/* GT SA CZ domain, 0x100000-0x138124 */
+	s->tilectl		= I915_READ(TILECTL);
+	s->gt_fifoctl		= I915_READ(GTFIFOCTL);
+	s->gtlc_wake_ctrl	= I915_READ(VLV_GTLC_WAKE_CTRL);
+	s->gtlc_survive		= I915_READ(VLV_GTLC_SURVIVABILITY_REG);
+	s->pmwgicz		= I915_READ(VLV_PMWGICZ);
+
+	/* Gunit-Display CZ domain, 0x182028-0x1821CF */
+	s->gu_ctl0		= I915_READ(VLV_GU_CTL0);
+	s->gu_ctl1		= I915_READ(VLV_GU_CTL1);
+	s->clock_gate_dis2	= I915_READ(VLV_GUNIT_CLOCK_GATE2);
+
+	/*
+	 * Not saving any of:
+	 * DFT,		0x9800-0x9EC0
+	 * SARB,	0xB000-0xB1FC
+	 * GAC,		0x5208-0x524C, 0x14000-0x14C000
+	 * PCI CFG
+	 */
+}
+
+static void vlv_restore_gunit_s0ix_state(struct drm_i915_private *dev_priv)
+{
+	struct vlv_s0ix_state *s = &dev_priv->vlv_s0ix_state;
+	u32 val;
+	int i;
+
+	/* GAM 0x4000-0x4770 */
+	I915_WRITE(GEN7_WR_WATERMARK,	s->wr_watermark);
+	I915_WRITE(GEN7_GFX_PRIO_CTRL,	s->gfx_prio_ctrl);
+	I915_WRITE(ARB_MODE,		s->arb_mode | (0xffff << 16));
+	I915_WRITE(GEN7_GFX_PEND_TLB0,	s->gfx_pend_tlb0);
+	I915_WRITE(GEN7_GFX_PEND_TLB1,	s->gfx_pend_tlb1);
+
+	for (i = 0; i < ARRAY_SIZE(s->lra_limits); i++)
+		I915_WRITE(GEN7_LRA_LIMITS_BASE + i * 4, s->lra_limits[i]);
+
+	I915_WRITE(GEN7_MEDIA_MAX_REQ_COUNT, s->media_max_req_count);
+	I915_WRITE(GEN7_MEDIA_MAX_REQ_COUNT, s->gfx_max_req_count);
+
+	I915_WRITE(RENDER_HWS_PGA_GEN7,	s->render_hwsp);
+	I915_WRITE(GAM_ECOCHK,		s->ecochk);
+	I915_WRITE(BSD_HWS_PGA_GEN7,	s->bsd_hwsp);
+	I915_WRITE(BLT_HWS_PGA_GEN7,	s->blt_hwsp);
+
+	I915_WRITE(GEN7_TLB_RD_ADDR,	s->tlb_rd_addr);
+
+	/* MBC 0x9024-0x91D0, 0x8500 */
+	I915_WRITE(GEN7_G3DCTL,		s->g3dctl);
+	I915_WRITE(GEN7_GSCKGCTL,	s->gsckgctl);
+	I915_WRITE(GEN6_MBCTL,		s->mbctl);
+
+	/* GCP 0x9400-0x9424, 0x8100-0x810C */
+	I915_WRITE(GEN6_UCGCTL1,	s->ucgctl1);
+	I915_WRITE(GEN7_UCGCTL3,	s->ucgctl3);
+	I915_WRITE(GEN7_RCGCTL1,	s->rcgctl1);
+	I915_WRITE(GEN7_RCGCTL2,	s->rcgctl2);
+	I915_WRITE(GEN7_RSTCTL,		s->rstctl);
+	I915_WRITE(GEN7_MISCCPCTL,	s->misccpctl);
+
+	/* GPM 0xA000-0xAA84, 0x8000-0x80FC */
+	I915_WRITE(GEN7_GFXPAUSE,	s->gfxpause);
+	I915_WRITE(GEN7_RPDEUHWTC,	s->rpdeuhwtc);
+	I915_WRITE(GEN7_RPDEUC,		s->rpdeuc);
+	I915_WRITE(ECOBUS,		s->ecobus);
+	I915_WRITE(VLV_PWRDWNUPCTL,	s->pwrdwnupctl);
+	I915_WRITE(GEN6_RP_DOWN_TIMEOUT,s->rp_down_timeout);
+	I915_WRITE(GEN7_RPDEUCSW,	s->rp_deucsw);
+	I915_WRITE(VLV_RCUBMABDTMR,	s->rcubmabdtmr);
+	I915_WRITE(VLV_RCEDATA,		s->rcedata);
+	I915_WRITE(VLV_SPAREG2H,	s->spare2gh);
+
+	/* Display CZ domain, 0x4400C-0x4402C, 0x4F000-0x4F11F */
+	I915_WRITE(GTIMR,		s->gt_imr);
+	I915_WRITE(GTIER,		s->gt_ier);
+	I915_WRITE(GEN6_PMIIR,		s->pm_imr);
+	I915_WRITE(GEN6_PMIER,		s->pm_ier);
+
+	for (i = 0; i < ARRAY_SIZE(s->gt_scratch); i++)
+		I915_WRITE(GEN7_GT_SCRATCH_BASE + i * 4, s->gt_scratch[i]);
+
+	/* GT SA CZ domain, 0x100000-0x138124 */
+	I915_WRITE(TILECTL,			s->tilectl);
+	I915_WRITE(GTFIFOCTL,			s->gt_fifoctl);
+	/*
+	 * Preserve the GT allow wake and GFX force clock bit, they are not
+	 * be restored, as they are used to control the s0ix suspend/resume
+	 * sequence by the caller.
+	 */
+	val = I915_READ(VLV_GTLC_WAKE_CTRL);
+	val &= VLV_GTLC_ALLOWWAKEREQ;
+	val |= s->gtlc_wake_ctrl & ~VLV_GTLC_ALLOWWAKEREQ;
+	I915_WRITE(VLV_GTLC_WAKE_CTRL, val);
+
+	val = I915_READ(VLV_GTLC_SURVIVABILITY_REG);
+	val &= VLV_GFX_CLK_FORCE_ON_BIT;
+	val |= s->gtlc_survive & ~VLV_GFX_CLK_FORCE_ON_BIT;
+	I915_WRITE(VLV_GTLC_SURVIVABILITY_REG,	val);
+
+	I915_WRITE(VLV_PMWGICZ,			s->pmwgicz);
+
+	/* Gunit-Display CZ domain, 0x182028-0x1821CF */
+	I915_WRITE(VLV_GU_CTL0,			s->gu_ctl0);
+	I915_WRITE(VLV_GU_CTL1,			s->gu_ctl1);
+	I915_WRITE(VLV_GUNIT_CLOCK_GATE2,	s->clock_gate_dis2);
+}
+
 int vlv_force_gfx_clock(struct drm_i915_private *dev_priv, bool force_on)
 {
 	u32 val;
drivers/gpu/drm/i915/i915_drv.h +62 -0

74 lines not on this page · raw message

Signature · 1 line
1.8.4
author
#33 lore raw

PATCH 14/15 drm/i915: vlv: add runtime PM support

In reply to Imre Deak

Add runtime PM support for VLV, but leave it disabled. The next patch enables it.

The suspend/resume sequence used is based on [1] and [2]. In practice we depend on the GT RC6 mechanism to save the HW context depending on the render and media power wells. By the time we run the runtime suspend callback the display side is also off and the HW context for that is managed by the display power domain framework.

Besides the above there are Gunit registers that depend on a system-wide power well. This power well goes off once the device enters any of the S0i[R123] states. To handle this scenario, save/restore these Gunit registers. Note that this is not the complete register set dictated by [2], to remove some overhead registers that are known not to be used are ignored. Also some registers are fully setup by initialization functions called during resume, these are not saved either. The list of registers can be further reduced, see the TODO note in the code.

[1] VLV_gfx_clocking_PM_reset_y12w21d3 / "Driver D3 entry/exit"
[2] VLV2_S0IXRegs

---
 drivers/gpu/drm/i915/i915_drv.c | 170 +++++++++++++++++++++++++++++++++++++++-
 1 file changed, 166 insertions(+), 4 deletions(-)
drivers/gpu/drm/i915/i915_drv.c +166 -4
index 9f9d0db..16ca37f 100644
@@ -891,19 +891,23 @@ static int i915_pm_poweroff(struct device *dev)
 	return i915_drm_freeze(drm_dev);
 }
 
-static void snb_runtime_suspend(struct drm_i915_private *dev_priv)
+static int snb_runtime_suspend(struct drm_i915_private *dev_priv)
 {
 	struct drm_device *dev = dev_priv->dev;
 
 	intel_runtime_pm_disable_interrupts(dev);
+
+	return 0;
 }
 
-static void hsw_runtime_suspend(struct drm_i915_private *dev_priv)
+static int hsw_runtime_suspend(struct drm_i915_private *dev_priv)
 {
 	hsw_enable_pc8(dev_priv);
+
+	return 0;
 }
 
-static void snb_runtime_resume(struct drm_i915_private *dev_priv)
+static int snb_runtime_resume(struct drm_i915_private *dev_priv)
 {
 	struct drm_device *dev = dev_priv->dev;
 
@@ -913,11 +917,15 @@ static void snb_runtime_resume(struct drm_i915_private *dev_priv)
 	mutex_lock(&dev_priv->rps.hw_lock);
 	gen6_update_ring_freq(dev);
 	mutex_unlock(&dev_priv->rps.hw_lock);
+
+	return 0;
 }
 
-static void hsw_runtime_resume(struct drm_i915_private *dev_priv)
+static int hsw_runtime_resume(struct drm_i915_private *dev_priv)
 {
 	hsw_disable_pc8(dev_priv);
+
+	return 0;
 }
 
 /*
@@ -1144,11 +1152,155 @@ int vlv_force_gfx_clock(struct drm_i915_private *dev_priv, bool force_on)
 #undef COND
 }
 
+static int vlv_allow_gt_wake(struct drm_i915_private *dev_priv, bool allow)
+{
+	u32 val;
+	int err = 0;
+
+	val = I915_READ(VLV_GTLC_WAKE_CTRL);
+	val &= ~VLV_GTLC_ALLOWWAKEREQ;
+	if (allow)
+		val |= VLV_GTLC_ALLOWWAKEREQ;
+	I915_WRITE(VLV_GTLC_WAKE_CTRL, val);
+	POSTING_READ(VLV_GTLC_WAKE_CTRL);
+
+#define COND (!!(I915_READ(VLV_GTLC_PW_STATUS) & VLV_GTLC_ALLOWWAKEACK) == \
+	      allow)
+	err = wait_for(COND, 1);
+	if (err)
+		DRM_ERROR("timeout disabling GT waking\n");
+	return err;
+#undef COND
+}
+
+static int vlv_wait_for_gt_wells(struct drm_i915_private *dev_priv,
+				 bool wait_for_on)
+{
+	u32 mask;
+	u32 val;
+	int err;
+
+	mask = VLV_GTLC_PW_MEDIA_STATUS_MASK | VLV_GTLC_PW_RENDER_STATUS_MASK;
+	val = wait_for_on ? mask : 0;
+#define COND ((I915_READ(VLV_GTLC_PW_STATUS) & mask) == val)
+	if (COND)
+		return 0;
+
+	DRM_DEBUG_KMS("waiting for GT wells to go %s (%08x)\n",
+			wait_for_on ? "on" : "off",
+			I915_READ(VLV_GTLC_PW_STATUS));
+
+	/*
+	 * RC6 transitioning can be delayed up to 2 msec (see
+	 * valleyview_enable_rps), use 3 msec for safety.
+	 */
+	err = wait_for(COND, 3);
+	if (err)
+		DRM_ERROR("timeout waiting for GT wells to go %s\n",
+			  wait_for_on ? "on" : "off");
+
+	return err;
+#undef COND
+}
+
+static void vlv_check_no_gt_access(struct drm_i915_private *dev_priv)
+{
+	if (!(I915_READ(VLV_GTLC_PW_STATUS) & VLV_GTLC_ALLOWWAKEERR))
+		return;
+
+	DRM_ERROR("GT register access while GT waking disabled\n");
+	I915_WRITE(VLV_GTLC_PW_STATUS, VLV_GTLC_ALLOWWAKEERR);
+}
+
+static int vlv_runtime_suspend(struct drm_i915_private *dev_priv)
+{
+	struct drm_device *dev = dev_priv->dev;
+	u32 mask;
+	int err;
+
+	if (WARN_ON(!valleyview_rc6_enabled(dev)))
+		return -ENODEV;
+
+	intel_runtime_pm_disable_interrupts(dev);
+	cancel_work_sync(&dev_priv->rps.work);
+
+	/*
+	 * Bspec defines the following GT well on flags as debug only, so
+	 * don't treat them as hard failures.
+	 */
+	(void)vlv_wait_for_gt_wells(dev_priv, false);
+
+	mask = VLV_GTLC_RENDER_CTX_EXISTS | VLV_GTLC_MEDIA_CTX_EXISTS;
+	WARN_ON((I915_READ(VLV_GTLC_WAKE_CTRL) & mask) != mask);
+
+	vlv_check_no_gt_access(dev_priv);
+
+	err = vlv_force_gfx_clock(dev_priv, true);
+	if (err)
+		goto err1;
+
+	err = vlv_allow_gt_wake(dev_priv, false);
+	if (err)
+		goto err2;
+	vlv_save_gunit_s0ix_state(dev_priv);
+
+	err = vlv_force_gfx_clock(dev_priv, false);
+	if (err)
+		goto err2;
+
+	return 0;
+
+err2:
+	/* For safety always re-enable waking and disable gfx clock forcing */
+	vlv_allow_gt_wake(dev_priv, true);
+err1:
+	vlv_force_gfx_clock(dev_priv, false);
+	intel_runtime_pm_restore_interrupts(dev);
+
+	return err;
+}
+
+static int vlv_runtime_resume(struct drm_i915_private *dev_priv)
+{
+	struct drm_device *dev = dev_priv->dev;
+	int err;
+	int ret;
+
+	/*
+	 * If any of the steps fail just try to continue, that's the best we
+	 * can do at this point. Return the first error code (which will also
+	 * leave RPM permanentyl disabled).
+	 */
+	ret = vlv_force_gfx_clock(dev_priv, true);
+
+	vlv_restore_gunit_s0ix_state(dev_priv);
+
+	err = vlv_allow_gt_wake(dev_priv, true);
+	if (!ret)
+		ret = err;
+
+	err = vlv_force_gfx_clock(dev_priv, false);
+	if (!ret)
+		ret = err;
+
+	vlv_check_no_gt_access(dev_priv);
+
+	intel_init_clock_gating(dev);
+	intel_reset_gt_powersave(dev);
+	i915_gem_init_swizzling(dev);
+	i915_gem_restore_fences(dev);
+
+	intel_runtime_pm_restore_interrupts(dev);
+
+	return ret;
+}
+
 static int intel_runtime_suspend(struct device *device)
 {
 	struct pci_dev *pdev = to_pci_dev(device);
 	struct drm_device *dev = pci_get_drvdata(pdev);
 	struct drm_i915_private *dev_priv = dev->dev_private;
+	int ret = 0;
 
 	if (WARN_ON_ONCE(!dev_priv->rps.enabled))
 		return -ENODEV;
@@ -1162,9 +1314,17 @@ static int intel_runtime_suspend(struct device *device)
 		snb_runtime_suspend(dev_priv);
 	else if (IS_HASWELL(dev) || IS_BROADWELL(dev))
 		hsw_runtime_suspend(dev_priv);
+	else if (IS_VALLEYVIEW(dev))
+		ret = vlv_runtime_suspend(dev_priv);
 	else
 		WARN_ON(1);
 
+	if (ret) {
+		DRM_ERROR("Runtime suspend failed, disabling it\n");
+
+		return ret;
+	}
+
 	i915_gem_release_all_mmaps(dev_priv);
 
 	del_timer_sync(&dev_priv->gpu_error.hangcheck_timer);
@@ -1200,6 +1360,8 @@ static int intel_runtime_resume(struct device *device)
 		snb_runtime_resume(dev_priv);
 	else if (IS_HASWELL(dev) || IS_BROADWELL(dev))
 		hsw_runtime_resume(dev_priv);
+	else if (IS_VALLEYVIEW(dev))
+		vlv_runtime_resume(dev_priv);
 	else
 		WARN_ON(1);
 
Signature · 1 line
1.8.4
#34 lore raw

Re: [PATCH 14/15] drm/i915: vlv: add runtime PM support

Quoted 249 lines · Imre Deak

Add runtime PM support for VLV, but leave it disabled. The next patch enables it.

The suspend/resume sequence used is based on [1] and [2]. In practice we depend on the GT RC6 mechanism to save the HW context depending on the render and media power wells. By the time we run the runtime suspend callback the display side is also off and the HW context for that is managed by the display power domain framework.

Besides the above there are Gunit registers that depend on a system-wide power well. This power well goes off once the device enters any of the S0i[R123] states. To handle this scenario, save/restore these Gunit registers. Note that this is not the complete register set dictated by [2], to remove some overhead registers that are known not to be used are ignored. Also some registers are fully setup by initialization functions called during resume, these are not saved either. The list of registers can be further reduced, see the TODO note in the code.

[1] VLV_gfx_clocking_PM_reset_y12w21d3 / "Driver D3 entry/exit"
[2] VLV2_S0IXRegs

---
 drivers/gpu/drm/i915/i915_drv.c | 170 +++++++++++++++++++++++++++++++++++++++-
 1 file changed, 166 insertions(+), 4 deletions(-)
drivers/gpu/drm/i915/i915_drv.c +164 -4
index 9f9d0db..16ca37f 100644
@@ -891,19 +891,23 @@ static int i915_pm_poweroff(struct device *dev)
 	return i915_drm_freeze(drm_dev);
 }
 
-static void snb_runtime_suspend(struct drm_i915_private *dev_priv)
+static int snb_runtime_suspend(struct drm_i915_private *dev_priv)
 {
 	struct drm_device *dev = dev_priv->dev;
 
 	intel_runtime_pm_disable_interrupts(dev);
+
+	return 0;
 }
 
-static void hsw_runtime_suspend(struct drm_i915_private *dev_priv)
+static int hsw_runtime_suspend(struct drm_i915_private *dev_priv)
 {
 	hsw_enable_pc8(dev_priv);
+
+	return 0;
 }
 
-static void snb_runtime_resume(struct drm_i915_private *dev_priv)
+static int snb_runtime_resume(struct drm_i915_private *dev_priv)
 {
 	struct drm_device *dev = dev_priv->dev;
 
@@ -913,11 +917,15 @@ static void snb_runtime_resume(struct drm_i915_private *dev_priv)
 	mutex_lock(&dev_priv->rps.hw_lock);
 	gen6_update_ring_freq(dev);
 	mutex_unlock(&dev_priv->rps.hw_lock);
+
+	return 0;
 }
 
-static void hsw_runtime_resume(struct drm_i915_private *dev_priv)
+static int hsw_runtime_resume(struct drm_i915_private *dev_priv)
 {
 	hsw_disable_pc8(dev_priv);
+
+	return 0;
 }
 
 /*
@@ -1144,11 +1152,155 @@ int vlv_force_gfx_clock(struct drm_i915_private *dev_priv, bool force_on)
 #undef COND
 }
 
+static int vlv_allow_gt_wake(struct drm_i915_private *dev_priv, bool allow)
+{
+	u32 val;
+	int err = 0;
+
+	val = I915_READ(VLV_GTLC_WAKE_CTRL);
+	val &= ~VLV_GTLC_ALLOWWAKEREQ;
+	if (allow)
+		val |= VLV_GTLC_ALLOWWAKEREQ;
+	I915_WRITE(VLV_GTLC_WAKE_CTRL, val);
+	POSTING_READ(VLV_GTLC_WAKE_CTRL);
+
+#define COND (!!(I915_READ(VLV_GTLC_PW_STATUS) & VLV_GTLC_ALLOWWAKEACK) == \
+	      allow)
+	err = wait_for(COND, 1);
+	if (err)
+		DRM_ERROR("timeout disabling GT waking\n");
+	return err;
+#undef COND
+}
+
+static int vlv_wait_for_gt_wells(struct drm_i915_private *dev_priv,
+				 bool wait_for_on)
+{
+	u32 mask;
+	u32 val;
+	int err;
+
+	mask = VLV_GTLC_PW_MEDIA_STATUS_MASK | VLV_GTLC_PW_RENDER_STATUS_MASK;
+	val = wait_for_on ? mask : 0;
+#define COND ((I915_READ(VLV_GTLC_PW_STATUS) & mask) == val)
+	if (COND)
+		return 0;
+
+	DRM_DEBUG_KMS("waiting for GT wells to go %s (%08x)\n",
+			wait_for_on ? "on" : "off",
+			I915_READ(VLV_GTLC_PW_STATUS));
+
+	/*
+	 * RC6 transitioning can be delayed up to 2 msec (see
+	 * valleyview_enable_rps), use 3 msec for safety.
+	 */
+	err = wait_for(COND, 3);
+	if (err)
+		DRM_ERROR("timeout waiting for GT wells to go %s\n",
+			  wait_for_on ? "on" : "off");
+
+	return err;
+#undef COND
+}
+
+static void vlv_check_no_gt_access(struct drm_i915_private *dev_priv)
+{
+	if (!(I915_READ(VLV_GTLC_PW_STATUS) & VLV_GTLC_ALLOWWAKEERR))
+		return;
+
+	DRM_ERROR("GT register access while GT waking disabled\n");
+	I915_WRITE(VLV_GTLC_PW_STATUS, VLV_GTLC_ALLOWWAKEERR);
+}
+
+static int vlv_runtime_suspend(struct drm_i915_private *dev_priv)
+{
+	struct drm_device *dev = dev_priv->dev;
+	u32 mask;
+	int err;
+
+	if (WARN_ON(!valleyview_rc6_enabled(dev)))
+		return -ENODEV;
+
+	intel_runtime_pm_disable_interrupts(dev);
+	cancel_work_sync(&dev_priv->rps.work);
+
+	/*
+	 * Bspec defines the following GT well on flags as debug only, so
+	 * don't treat them as hard failures.
+	 */
+	(void)vlv_wait_for_gt_wells(dev_priv, false);
+
+	mask = VLV_GTLC_RENDER_CTX_EXISTS | VLV_GTLC_MEDIA_CTX_EXISTS;
+	WARN_ON((I915_READ(VLV_GTLC_WAKE_CTRL) & mask) != mask);
+
+	vlv_check_no_gt_access(dev_priv);
+
+	err = vlv_force_gfx_clock(dev_priv, true);
+	if (err)
+		goto err1;
+
+	err = vlv_allow_gt_wake(dev_priv, false);
+	if (err)
+		goto err2;
+	vlv_save_gunit_s0ix_state(dev_priv);
+
+	err = vlv_force_gfx_clock(dev_priv, false);
+	if (err)
+		goto err2;
+
+	return 0;
+
+err2:
+	/* For safety always re-enable waking and disable gfx clock forcing */
+	vlv_allow_gt_wake(dev_priv, true);
+err1:
+	vlv_force_gfx_clock(dev_priv, false);
+	intel_runtime_pm_restore_interrupts(dev);
+
+	return err;
+}
+
+static int vlv_runtime_resume(struct drm_i915_private *dev_priv)
+{
+	struct drm_device *dev = dev_priv->dev;
+	int err;
+	int ret;
+
+	/*
+	 * If any of the steps fail just try to continue, that's the best we
+	 * can do at this point. Return the first error code (which will also
+	 * leave RPM permanentyl disabled).
+	 */
+	ret = vlv_force_gfx_clock(dev_priv, true);
+
+	vlv_restore_gunit_s0ix_state(dev_priv);
+
+	err = vlv_allow_gt_wake(dev_priv, true);
+	if (!ret)
+		ret = err;
+
+	err = vlv_force_gfx_clock(dev_priv, false);
+	if (!ret)
+		ret = err;
+
+	vlv_check_no_gt_access(dev_priv);
+
+	intel_init_clock_gating(dev);
+	intel_reset_gt_powersave(dev);
+	i915_gem_init_swizzling(dev);
+	i915_gem_restore_fences(dev);
+
+	intel_runtime_pm_restore_interrupts(dev);
+
+	return ret;
+}
+
 static int intel_runtime_suspend(struct device *device)
 {
 	struct pci_dev *pdev = to_pci_dev(device);
 	struct drm_device *dev = pci_get_drvdata(pdev);
 	struct drm_i915_private *dev_priv = dev->dev_private;
+	int ret = 0;
 
 	if (WARN_ON_ONCE(!dev_priv->rps.enabled))
 		return -ENODEV;
@@ -1162,9 +1314,17 @@ static int intel_runtime_suspend(struct device *device)
 		snb_runtime_suspend(dev_priv);
 	else if (IS_HASWELL(dev) || IS_BROADWELL(dev))
 		hsw_runtime_suspend(dev_priv);
+	else if (IS_VALLEYVIEW(dev))
+		ret = vlv_runtime_suspend(dev_priv);
 	else
 		WARN_ON(1);
 
+	if (ret) {
+		DRM_ERROR("Runtime suspend failed, disabling it\n");
+
+		return ret;
+	}
+
 	i915_gem_release_all_mmaps(dev_priv);
 
 	del_timer_sync(&dev_priv->gpu_error.hangcheck_timer);

drivers/gpu/drm/i915/i915_drv.c static int intel_runtime_resume(struct device *device) · line 1364

Quoted 5 lines
drivers/gpu/drm/i915/i915_drv.c +2 -0
@@ -1200,6 +1360,8 @@ static int intel_runtime_resume(struct device *device)
 		snb_runtime_resume(dev_priv);
 	else if (IS_HASWELL(dev) || IS_BROADWELL(dev))
 		hsw_runtime_resume(dev_priv);
+	else if (IS_VALLEYVIEW(dev))
+		vlv_runtime_resume(dev_priv);

Golden rule of refactoring: The 3rd guy gets to cleanup the mess. Imo it's time to refactor the common parts form these platform functions out and move them into generic code, and only call down into platform code as needed. If we don't do that we'll have completely hell due to slight differences in ordering between platforms.

Also I think we should try to share as much code as possible with the other setup/teardowns paths, i.e. driver load/unload, system suspend/resume and gpu reset.

Thanks, Daniel

Quoted 10 lines
drivers/gpu/drm/i915/i915_drv.c +0 -0
 	else
 		WARN_ON(1);
 
Signature · 6 lines
1.8.4

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
Signature · 3 lines
Daniel Vetter
Software Engineer, Intel Corporation
+41 (0) 79 365 57 48 - http://blog.ffwll.ch
author
#35 lore raw

Re: [PATCH 14/15] drm/i915: vlv: add runtime PM support

Quoted 248 lines · Daniel Vetter
Quoted 247 lines · Imre Deak

Add runtime PM support for VLV, but leave it disabled. The next patch enables it.

The suspend/resume sequence used is based on [1] and [2]. In practice we depend on the GT RC6 mechanism to save the HW context depending on the render and media power wells. By the time we run the runtime suspend callback the display side is also off and the HW context for that is managed by the display power domain framework.

Besides the above there are Gunit registers that depend on a system-wide power well. This power well goes off once the device enters any of the S0i[R123] states. To handle this scenario, save/restore these Gunit registers. Note that this is not the complete register set dictated by [2], to remove some overhead registers that are known not to be used are ignored. Also some registers are fully setup by initialization functions called during resume, these are not saved either. The list of registers can be further reduced, see the TODO note in the code.

[1] VLV_gfx_clocking_PM_reset_y12w21d3 / "Driver D3 entry/exit"
[2] VLV2_S0IXRegs

---
 drivers/gpu/drm/i915/i915_drv.c | 170 +++++++++++++++++++++++++++++++++++++++-
 1 file changed, 166 insertions(+), 4 deletions(-)
drivers/gpu/drm/i915/i915_drv.c +164 -4
index 9f9d0db..16ca37f 100644
@@ -891,19 +891,23 @@ static int i915_pm_poweroff(struct device *dev)
 	return i915_drm_freeze(drm_dev);
 }
 
-static void snb_runtime_suspend(struct drm_i915_private *dev_priv)
+static int snb_runtime_suspend(struct drm_i915_private *dev_priv)
 {
 	struct drm_device *dev = dev_priv->dev;
 
 	intel_runtime_pm_disable_interrupts(dev);
+
+	return 0;
 }
 
-static void hsw_runtime_suspend(struct drm_i915_private *dev_priv)
+static int hsw_runtime_suspend(struct drm_i915_private *dev_priv)
 {
 	hsw_enable_pc8(dev_priv);
+
+	return 0;
 }
 
-static void snb_runtime_resume(struct drm_i915_private *dev_priv)
+static int snb_runtime_resume(struct drm_i915_private *dev_priv)
 {
 	struct drm_device *dev = dev_priv->dev;
 
@@ -913,11 +917,15 @@ static void snb_runtime_resume(struct drm_i915_private *dev_priv)
 	mutex_lock(&dev_priv->rps.hw_lock);
 	gen6_update_ring_freq(dev);
 	mutex_unlock(&dev_priv->rps.hw_lock);
+
+	return 0;
 }
 
-static void hsw_runtime_resume(struct drm_i915_private *dev_priv)
+static int hsw_runtime_resume(struct drm_i915_private *dev_priv)
 {
 	hsw_disable_pc8(dev_priv);
+
+	return 0;
 }
 
 /*
@@ -1144,11 +1152,155 @@ int vlv_force_gfx_clock(struct drm_i915_private *dev_priv, bool force_on)
 #undef COND
 }
 
+static int vlv_allow_gt_wake(struct drm_i915_private *dev_priv, bool allow)
+{
+	u32 val;
+	int err = 0;
+
+	val = I915_READ(VLV_GTLC_WAKE_CTRL);
+	val &= ~VLV_GTLC_ALLOWWAKEREQ;
+	if (allow)
+		val |= VLV_GTLC_ALLOWWAKEREQ;
+	I915_WRITE(VLV_GTLC_WAKE_CTRL, val);
+	POSTING_READ(VLV_GTLC_WAKE_CTRL);
+
+#define COND (!!(I915_READ(VLV_GTLC_PW_STATUS) & VLV_GTLC_ALLOWWAKEACK) == \
+	      allow)
+	err = wait_for(COND, 1);
+	if (err)
+		DRM_ERROR("timeout disabling GT waking\n");
+	return err;
+#undef COND
+}
+
+static int vlv_wait_for_gt_wells(struct drm_i915_private *dev_priv,
+				 bool wait_for_on)
+{
+	u32 mask;
+	u32 val;
+	int err;
+
+	mask = VLV_GTLC_PW_MEDIA_STATUS_MASK | VLV_GTLC_PW_RENDER_STATUS_MASK;
+	val = wait_for_on ? mask : 0;
+#define COND ((I915_READ(VLV_GTLC_PW_STATUS) & mask) == val)
+	if (COND)
+		return 0;
+
+	DRM_DEBUG_KMS("waiting for GT wells to go %s (%08x)\n",
+			wait_for_on ? "on" : "off",
+			I915_READ(VLV_GTLC_PW_STATUS));
+
+	/*
+	 * RC6 transitioning can be delayed up to 2 msec (see
+	 * valleyview_enable_rps), use 3 msec for safety.
+	 */
+	err = wait_for(COND, 3);
+	if (err)
+		DRM_ERROR("timeout waiting for GT wells to go %s\n",
+			  wait_for_on ? "on" : "off");
+
+	return err;
+#undef COND
+}
+
+static void vlv_check_no_gt_access(struct drm_i915_private *dev_priv)
+{
+	if (!(I915_READ(VLV_GTLC_PW_STATUS) & VLV_GTLC_ALLOWWAKEERR))
+		return;
+
+	DRM_ERROR("GT register access while GT waking disabled\n");
+	I915_WRITE(VLV_GTLC_PW_STATUS, VLV_GTLC_ALLOWWAKEERR);
+}
+
+static int vlv_runtime_suspend(struct drm_i915_private *dev_priv)
+{
+	struct drm_device *dev = dev_priv->dev;
+	u32 mask;
+	int err;
+
+	if (WARN_ON(!valleyview_rc6_enabled(dev)))
+		return -ENODEV;
+
+	intel_runtime_pm_disable_interrupts(dev);
+	cancel_work_sync(&dev_priv->rps.work);
+
+	/*
+	 * Bspec defines the following GT well on flags as debug only, so
+	 * don't treat them as hard failures.
+	 */
+	(void)vlv_wait_for_gt_wells(dev_priv, false);
+
+	mask = VLV_GTLC_RENDER_CTX_EXISTS | VLV_GTLC_MEDIA_CTX_EXISTS;
+	WARN_ON((I915_READ(VLV_GTLC_WAKE_CTRL) & mask) != mask);
+
+	vlv_check_no_gt_access(dev_priv);
+
+	err = vlv_force_gfx_clock(dev_priv, true);
+	if (err)
+		goto err1;
+
+	err = vlv_allow_gt_wake(dev_priv, false);
+	if (err)
+		goto err2;
+	vlv_save_gunit_s0ix_state(dev_priv);
+
+	err = vlv_force_gfx_clock(dev_priv, false);
+	if (err)
+		goto err2;
+
+	return 0;
+
+err2:
+	/* For safety always re-enable waking and disable gfx clock forcing */
+	vlv_allow_gt_wake(dev_priv, true);
+err1:
+	vlv_force_gfx_clock(dev_priv, false);
+	intel_runtime_pm_restore_interrupts(dev);
+
+	return err;
+}
+
+static int vlv_runtime_resume(struct drm_i915_private *dev_priv)
+{
+	struct drm_device *dev = dev_priv->dev;
+	int err;
+	int ret;
+
+	/*
+	 * If any of the steps fail just try to continue, that's the best we
+	 * can do at this point. Return the first error code (which will also
+	 * leave RPM permanentyl disabled).
+	 */
+	ret = vlv_force_gfx_clock(dev_priv, true);
+
+	vlv_restore_gunit_s0ix_state(dev_priv);
+
+	err = vlv_allow_gt_wake(dev_priv, true);
+	if (!ret)
+		ret = err;
+
+	err = vlv_force_gfx_clock(dev_priv, false);
+	if (!ret)
+		ret = err;
+
+	vlv_check_no_gt_access(dev_priv);
+
+	intel_init_clock_gating(dev);
+	intel_reset_gt_powersave(dev);
+	i915_gem_init_swizzling(dev);
+	i915_gem_restore_fences(dev);
+
+	intel_runtime_pm_restore_interrupts(dev);
+
+	return ret;
+}
+
 static int intel_runtime_suspend(struct device *device)
 {
 	struct pci_dev *pdev = to_pci_dev(device);
 	struct drm_device *dev = pci_get_drvdata(pdev);
 	struct drm_i915_private *dev_priv = dev->dev_private;
+	int ret = 0;
 
 	if (WARN_ON_ONCE(!dev_priv->rps.enabled))
 		return -ENODEV;
@@ -1162,9 +1314,17 @@ static int intel_runtime_suspend(struct device *device)
 		snb_runtime_suspend(dev_priv);
 	else if (IS_HASWELL(dev) || IS_BROADWELL(dev))
 		hsw_runtime_suspend(dev_priv);
+	else if (IS_VALLEYVIEW(dev))
+		ret = vlv_runtime_suspend(dev_priv);
 	else
 		WARN_ON(1);
 
+	if (ret) {
+		DRM_ERROR("Runtime suspend failed, disabling it\n");
+
+		return ret;
+	}
+
 	i915_gem_release_all_mmaps(dev_priv);
 
Quoted 13 lines

drivers/gpu/drm/i915/i915_drv.c static int intel_runtime_resume(struct device *device) · line 1364

Quoted 7 lines
drivers/gpu/drm/i915/i915_drv.c +2 -0
 	del_timer_sync(&dev_priv->gpu_error.hangcheck_timer);
@@ -1200,6 +1360,8 @@ static int intel_runtime_resume(struct device *device)
 		snb_runtime_resume(dev_priv);
 	else if (IS_HASWELL(dev) || IS_BROADWELL(dev))
 		hsw_runtime_resume(dev_priv);
+	else if (IS_VALLEYVIEW(dev))
+		vlv_runtime_resume(dev_priv);

Golden rule of refactoring: The 3rd guy gets to cleanup the mess. Imo it's time to refactor the common parts form these platform functions out and move them into generic code, and only call down into platform code as needed. If we don't do that we'll have completely hell due to slight differences in ordering between platforms.

Ok, the common parts basically boil down to

intel_runtime_pm_disable_interrupts(); / _enable_interrupts();

and I think we also need to add

cancel_work_sync(&dev_priv->rps.work);

to all platforms. I can do this.

Quoted 3 lines

Also I think we should try to share as much code as possible with the other setup/teardowns paths, i.e. driver load/unload, system suspend/resume and gpu reset.

I agree, but this needs much more refactoring first on the other parts you mention above before we can unify things. That's mainly because on the RPM path we can call only low level functions (since an RPM callback can be called basically from anywhere in the driver) whereas the handlers you mention do a high level initialization. So for VLV RPM resume we call for example

intel_init_clock_gating();
i915_gem_init_swizzling();
i915_gem_restore_fences();

but for system resume we simply do a full

intel_modeset_init_hw();

which includes the above low level steps interleaved with quite a lot of other init steps. We may also need to rethink locking before sharing those parts.

So I'm happy to do this refactoring, but I'd suggest doing it as a follow-up.

--Imre

Quoted 13 lines

Thanks, Daniel

Quoted 10 lines
drivers/gpu/drm/i915/i915_drv.c +0 -0
 	else
 		WARN_ON(1);
 
Signature · 6 lines
1.8.4

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
#36 lore raw

Re: [PATCH 14/15] drm/i915: vlv: add runtime PM support

Quoted 290 lines · Imre Deak
Quoted 248 lines · Daniel Vetter
Quoted 247 lines · Imre Deak

Add runtime PM support for VLV, but leave it disabled. The next patch enables it.

The suspend/resume sequence used is based on [1] and [2]. In practice we depend on the GT RC6 mechanism to save the HW context depending on the render and media power wells. By the time we run the runtime suspend callback the display side is also off and the HW context for that is managed by the display power domain framework.

Besides the above there are Gunit registers that depend on a system-wide power well. This power well goes off once the device enters any of the S0i[R123] states. To handle this scenario, save/restore these Gunit registers. Note that this is not the complete register set dictated by [2], to remove some overhead registers that are known not to be used are ignored. Also some registers are fully setup by initialization functions called during resume, these are not saved either. The list of registers can be further reduced, see the TODO note in the code.

[1] VLV_gfx_clocking_PM_reset_y12w21d3 / "Driver D3 entry/exit"
[2] VLV2_S0IXRegs

---
 drivers/gpu/drm/i915/i915_drv.c | 170 +++++++++++++++++++++++++++++++++++++++-
 1 file changed, 166 insertions(+), 4 deletions(-)
drivers/gpu/drm/i915/i915_drv.c +164 -4
index 9f9d0db..16ca37f 100644
@@ -891,19 +891,23 @@ static int i915_pm_poweroff(struct device *dev)
 	return i915_drm_freeze(drm_dev);
 }
 
-static void snb_runtime_suspend(struct drm_i915_private *dev_priv)
+static int snb_runtime_suspend(struct drm_i915_private *dev_priv)
 {
 	struct drm_device *dev = dev_priv->dev;
 
 	intel_runtime_pm_disable_interrupts(dev);
+
+	return 0;
 }
 
-static void hsw_runtime_suspend(struct drm_i915_private *dev_priv)
+static int hsw_runtime_suspend(struct drm_i915_private *dev_priv)
 {
 	hsw_enable_pc8(dev_priv);
+
+	return 0;
 }
 
-static void snb_runtime_resume(struct drm_i915_private *dev_priv)
+static int snb_runtime_resume(struct drm_i915_private *dev_priv)
 {
 	struct drm_device *dev = dev_priv->dev;
 
@@ -913,11 +917,15 @@ static void snb_runtime_resume(struct drm_i915_private *dev_priv)
 	mutex_lock(&dev_priv->rps.hw_lock);
 	gen6_update_ring_freq(dev);
 	mutex_unlock(&dev_priv->rps.hw_lock);
+
+	return 0;
 }
 
-static void hsw_runtime_resume(struct drm_i915_private *dev_priv)
+static int hsw_runtime_resume(struct drm_i915_private *dev_priv)
 {
 	hsw_disable_pc8(dev_priv);
+
+	return 0;
 }
 
 /*
@@ -1144,11 +1152,155 @@ int vlv_force_gfx_clock(struct drm_i915_private *dev_priv, bool force_on)
 #undef COND
 }
 
+static int vlv_allow_gt_wake(struct drm_i915_private *dev_priv, bool allow)
+{
+	u32 val;
+	int err = 0;
+
+	val = I915_READ(VLV_GTLC_WAKE_CTRL);
+	val &= ~VLV_GTLC_ALLOWWAKEREQ;
+	if (allow)
+		val |= VLV_GTLC_ALLOWWAKEREQ;
+	I915_WRITE(VLV_GTLC_WAKE_CTRL, val);
+	POSTING_READ(VLV_GTLC_WAKE_CTRL);
+
+#define COND (!!(I915_READ(VLV_GTLC_PW_STATUS) & VLV_GTLC_ALLOWWAKEACK) == \
+	      allow)
+	err = wait_for(COND, 1);
+	if (err)
+		DRM_ERROR("timeout disabling GT waking\n");
+	return err;
+#undef COND
+}
+
+static int vlv_wait_for_gt_wells(struct drm_i915_private *dev_priv,
+				 bool wait_for_on)
+{
+	u32 mask;
+	u32 val;
+	int err;
+
+	mask = VLV_GTLC_PW_MEDIA_STATUS_MASK | VLV_GTLC_PW_RENDER_STATUS_MASK;
+	val = wait_for_on ? mask : 0;
+#define COND ((I915_READ(VLV_GTLC_PW_STATUS) & mask) == val)
+	if (COND)
+		return 0;
+
+	DRM_DEBUG_KMS("waiting for GT wells to go %s (%08x)\n",
+			wait_for_on ? "on" : "off",
+			I915_READ(VLV_GTLC_PW_STATUS));
+
+	/*
+	 * RC6 transitioning can be delayed up to 2 msec (see
+	 * valleyview_enable_rps), use 3 msec for safety.
+	 */
+	err = wait_for(COND, 3);
+	if (err)
+		DRM_ERROR("timeout waiting for GT wells to go %s\n",
+			  wait_for_on ? "on" : "off");
+
+	return err;
+#undef COND
+}
+
+static void vlv_check_no_gt_access(struct drm_i915_private *dev_priv)
+{
+	if (!(I915_READ(VLV_GTLC_PW_STATUS) & VLV_GTLC_ALLOWWAKEERR))
+		return;
+
+	DRM_ERROR("GT register access while GT waking disabled\n");
+	I915_WRITE(VLV_GTLC_PW_STATUS, VLV_GTLC_ALLOWWAKEERR);
+}
+
+static int vlv_runtime_suspend(struct drm_i915_private *dev_priv)
+{
+	struct drm_device *dev = dev_priv->dev;
+	u32 mask;
+	int err;
+
+	if (WARN_ON(!valleyview_rc6_enabled(dev)))
+		return -ENODEV;
+
+	intel_runtime_pm_disable_interrupts(dev);
+	cancel_work_sync(&dev_priv->rps.work);
+
+	/*
+	 * Bspec defines the following GT well on flags as debug only, so
+	 * don't treat them as hard failures.
+	 */
+	(void)vlv_wait_for_gt_wells(dev_priv, false);
+
+	mask = VLV_GTLC_RENDER_CTX_EXISTS | VLV_GTLC_MEDIA_CTX_EXISTS;
+	WARN_ON((I915_READ(VLV_GTLC_WAKE_CTRL) & mask) != mask);
+
+	vlv_check_no_gt_access(dev_priv);
+
+	err = vlv_force_gfx_clock(dev_priv, true);
+	if (err)
+		goto err1;
+
+	err = vlv_allow_gt_wake(dev_priv, false);
+	if (err)
+		goto err2;
+	vlv_save_gunit_s0ix_state(dev_priv);
+
+	err = vlv_force_gfx_clock(dev_priv, false);
+	if (err)
+		goto err2;
+
+	return 0;
+
+err2:
+	/* For safety always re-enable waking and disable gfx clock forcing */
+	vlv_allow_gt_wake(dev_priv, true);
+err1:
+	vlv_force_gfx_clock(dev_priv, false);
+	intel_runtime_pm_restore_interrupts(dev);
+
+	return err;
+}
+
+static int vlv_runtime_resume(struct drm_i915_private *dev_priv)
+{
+	struct drm_device *dev = dev_priv->dev;
+	int err;
+	int ret;
+
+	/*
+	 * If any of the steps fail just try to continue, that's the best we
+	 * can do at this point. Return the first error code (which will also
+	 * leave RPM permanentyl disabled).
+	 */
+	ret = vlv_force_gfx_clock(dev_priv, true);
+
+	vlv_restore_gunit_s0ix_state(dev_priv);
+
+	err = vlv_allow_gt_wake(dev_priv, true);
+	if (!ret)
+		ret = err;
+
+	err = vlv_force_gfx_clock(dev_priv, false);
+	if (!ret)
+		ret = err;
+
+	vlv_check_no_gt_access(dev_priv);
+
+	intel_init_clock_gating(dev);
+	intel_reset_gt_powersave(dev);
+	i915_gem_init_swizzling(dev);
+	i915_gem_restore_fences(dev);
+
+	intel_runtime_pm_restore_interrupts(dev);
+
+	return ret;
+}
+
 static int intel_runtime_suspend(struct device *device)
 {
 	struct pci_dev *pdev = to_pci_dev(device);
 	struct drm_device *dev = pci_get_drvdata(pdev);
 	struct drm_i915_private *dev_priv = dev->dev_private;
+	int ret = 0;
 
 	if (WARN_ON_ONCE(!dev_priv->rps.enabled))
 		return -ENODEV;
@@ -1162,9 +1314,17 @@ static int intel_runtime_suspend(struct device *device)
 		snb_runtime_suspend(dev_priv);
 	else if (IS_HASWELL(dev) || IS_BROADWELL(dev))
 		hsw_runtime_suspend(dev_priv);
+	else if (IS_VALLEYVIEW(dev))
+		ret = vlv_runtime_suspend(dev_priv);
 	else
 		WARN_ON(1);
 
+	if (ret) {
+		DRM_ERROR("Runtime suspend failed, disabling it\n");
+
+		return ret;
+	}
+
 	i915_gem_release_all_mmaps(dev_priv);
 
Quoted 13 lines

drivers/gpu/drm/i915/i915_drv.c static int intel_runtime_resume(struct device *device) · line 1364

Quoted 7 lines
drivers/gpu/drm/i915/i915_drv.c +2 -0
 	del_timer_sync(&dev_priv->gpu_error.hangcheck_timer);
@@ -1200,6 +1360,8 @@ static int intel_runtime_resume(struct device *device)
 		snb_runtime_resume(dev_priv);
 	else if (IS_HASWELL(dev) || IS_BROADWELL(dev))
 		hsw_runtime_resume(dev_priv);
+	else if (IS_VALLEYVIEW(dev))
+		vlv_runtime_resume(dev_priv);

Golden rule of refactoring: The 3rd guy gets to cleanup the mess. Imo it's time to refactor the common parts form these platform functions out and move them into generic code, and only call down into platform code as needed. If we don't do that we'll have completely hell due to slight differences in ordering between platforms.

Ok, the common parts basically boil down to

intel_runtime_pm_disable_interrupts(); / _enable_interrupts();

and I think we also need to add

cancel_work_sync(&dev_priv->rps.work);

to all platforms. I can do this.

Quoted 3 lines

Also I think we should try to share as much code as possible with the other setup/teardowns paths, i.e. driver load/unload, system suspend/resume and gpu reset.

I agree, but this needs much more refactoring first on the other parts you mention above before we can unify things. That's mainly because on the RPM path we can call only low level functions (since an RPM callback can be called basically from anywhere in the driver) whereas the handlers you mention do a high level initialization. So for VLV RPM resume we call for example

intel_init_clock_gating();
i915_gem_init_swizzling();
i915_gem_restore_fences();

but for system resume we simply do a full

Quoted 8 lines

intel_modeset_init_hw();

which includes the above low level steps interleaved with quite a lot of other init steps. We may also need to rethink locking before sharing those parts.

So I'm happy to do this refactoring, but I'd suggest doing it as a follow-up.

Yeah I agree that the full thing needs more work and maybe 1-2 more platforms so that we have a clearer picture. But imo it's time to start, and the above few things you've mentioned look like a good first stab at the problem.
-Daniel

Signature · 3 lines
Daniel Vetter
Software Engineer, Intel Corporation
+41 (0) 79 365 57 48 - http://blog.ffwll.ch
#37 lore raw

Re: [PATCH 14/15] drm/i915: vlv: add runtime PM support

In reply to Imre Deak

2014-04-08 13:57 GMT-03:00 Imre Deak <[email protected]>:

Quoted 231 lines

Add runtime PM support for VLV, but leave it disabled. The next patch enables it.

The suspend/resume sequence used is based on [1] and [2]. In practice we depend on the GT RC6 mechanism to save the HW context depending on the render and media power wells. By the time we run the runtime suspend callback the display side is also off and the HW context for that is managed by the display power domain framework.

Besides the above there are Gunit registers that depend on a system-wide power well. This power well goes off once the device enters any of the S0i[R123] states. To handle this scenario, save/restore these Gunit registers. Note that this is not the complete register set dictated by [2], to remove some overhead registers that are known not to be used are ignored. Also some registers are fully setup by initialization functions called during resume, these are not saved either. The list of registers can be further reduced, see the TODO note in the code.

[1] VLV_gfx_clocking_PM_reset_y12w21d3 / "Driver D3 entry/exit"
[2] VLV2_S0IXRegs

---
 drivers/gpu/drm/i915/i915_drv.c | 170 +++++++++++++++++++++++++++++++++++++++-
 1 file changed, 166 insertions(+), 4 deletions(-)
drivers/gpu/drm/i915/i915_drv.c +156 -4
index 9f9d0db..16ca37f 100644
@@ -891,19 +891,23 @@ static int i915_pm_poweroff(struct device *dev)
        return i915_drm_freeze(drm_dev);
 }
 
-static void snb_runtime_suspend(struct drm_i915_private *dev_priv)
+static int snb_runtime_suspend(struct drm_i915_private *dev_priv)
 {
        struct drm_device *dev = dev_priv->dev;
 
        intel_runtime_pm_disable_interrupts(dev);
+
+       return 0;
 }
 
-static void hsw_runtime_suspend(struct drm_i915_private *dev_priv)
+static int hsw_runtime_suspend(struct drm_i915_private *dev_priv)
 {
        hsw_enable_pc8(dev_priv);
+
+       return 0;
 }
 
-static void snb_runtime_resume(struct drm_i915_private *dev_priv)
+static int snb_runtime_resume(struct drm_i915_private *dev_priv)
 {
        struct drm_device *dev = dev_priv->dev;
 
@@ -913,11 +917,15 @@ static void snb_runtime_resume(struct drm_i915_private *dev_priv)
        mutex_lock(&dev_priv->rps.hw_lock);
        gen6_update_ring_freq(dev);
        mutex_unlock(&dev_priv->rps.hw_lock);
+
+       return 0;
 }
 
-static void hsw_runtime_resume(struct drm_i915_private *dev_priv)
+static int hsw_runtime_resume(struct drm_i915_private *dev_priv)
 {
        hsw_disable_pc8(dev_priv);
+
+       return 0;
 }
 
 /*
@@ -1144,11 +1152,155 @@ int vlv_force_gfx_clock(struct drm_i915_private *dev_priv, bool force_on)
 #undef COND
 }
 
+static int vlv_allow_gt_wake(struct drm_i915_private *dev_priv, bool allow)
+{
+       u32 val;
+       int err = 0;
+
+       val = I915_READ(VLV_GTLC_WAKE_CTRL);
+       val &= ~VLV_GTLC_ALLOWWAKEREQ;
+       if (allow)
+               val |= VLV_GTLC_ALLOWWAKEREQ;
+       I915_WRITE(VLV_GTLC_WAKE_CTRL, val);
+       POSTING_READ(VLV_GTLC_WAKE_CTRL);
+
+#define COND (!!(I915_READ(VLV_GTLC_PW_STATUS) & VLV_GTLC_ALLOWWAKEACK) == \
+             allow)
+       err = wait_for(COND, 1);
+       if (err)
+               DRM_ERROR("timeout disabling GT waking\n");
+       return err;
+#undef COND
+}
+
+static int vlv_wait_for_gt_wells(struct drm_i915_private *dev_priv,
+                                bool wait_for_on)
+{
+       u32 mask;
+       u32 val;
+       int err;
+
+       mask = VLV_GTLC_PW_MEDIA_STATUS_MASK | VLV_GTLC_PW_RENDER_STATUS_MASK;
+       val = wait_for_on ? mask : 0;
+#define COND ((I915_READ(VLV_GTLC_PW_STATUS) & mask) == val)
+       if (COND)
+               return 0;
+
+       DRM_DEBUG_KMS("waiting for GT wells to go %s (%08x)\n",
+                       wait_for_on ? "on" : "off",
+                       I915_READ(VLV_GTLC_PW_STATUS));
+
+       /*
+        * RC6 transitioning can be delayed up to 2 msec (see
+        * valleyview_enable_rps), use 3 msec for safety.
+        */
+       err = wait_for(COND, 3);
+       if (err)
+               DRM_ERROR("timeout waiting for GT wells to go %s\n",
+                         wait_for_on ? "on" : "off");
+
+       return err;
+#undef COND
+}
+
+static void vlv_check_no_gt_access(struct drm_i915_private *dev_priv)
+{
+       if (!(I915_READ(VLV_GTLC_PW_STATUS) & VLV_GTLC_ALLOWWAKEERR))
+               return;
+
+       DRM_ERROR("GT register access while GT waking disabled\n");
+       I915_WRITE(VLV_GTLC_PW_STATUS, VLV_GTLC_ALLOWWAKEERR);
+}
+
+static int vlv_runtime_suspend(struct drm_i915_private *dev_priv)
+{
+       struct drm_device *dev = dev_priv->dev;
+       u32 mask;
+       int err;
+
+       if (WARN_ON(!valleyview_rc6_enabled(dev)))
+               return -ENODEV;
+
+       intel_runtime_pm_disable_interrupts(dev);
+       cancel_work_sync(&dev_priv->rps.work);
+
+       /*
+        * Bspec defines the following GT well on flags as debug only, so
+        * don't treat them as hard failures.
+        */
+       (void)vlv_wait_for_gt_wells(dev_priv, false);
+
+       mask = VLV_GTLC_RENDER_CTX_EXISTS | VLV_GTLC_MEDIA_CTX_EXISTS;
+       WARN_ON((I915_READ(VLV_GTLC_WAKE_CTRL) & mask) != mask);
+
+       vlv_check_no_gt_access(dev_priv);
+
+       err = vlv_force_gfx_clock(dev_priv, true);
+       if (err)
+               goto err1;
+
+       err = vlv_allow_gt_wake(dev_priv, false);
+       if (err)
+               goto err2;
+       vlv_save_gunit_s0ix_state(dev_priv);
+
+       err = vlv_force_gfx_clock(dev_priv, false);
+       if (err)
+               goto err2;
+
+       return 0;
+
+err2:
+       /* For safety always re-enable waking and disable gfx clock forcing */
+       vlv_allow_gt_wake(dev_priv, true);
+err1:
+       vlv_force_gfx_clock(dev_priv, false);
+       intel_runtime_pm_restore_interrupts(dev);
+
+       return err;
+}
+
+static int vlv_runtime_resume(struct drm_i915_private *dev_priv)
+{
+       struct drm_device *dev = dev_priv->dev;
+       int err;
+       int ret;
+
+       /*
+        * If any of the steps fail just try to continue, that's the best we
+        * can do at this point. Return the first error code (which will also
+        * leave RPM permanentyl disabled).
+        */
+       ret = vlv_force_gfx_clock(dev_priv, true);
+
+       vlv_restore_gunit_s0ix_state(dev_priv);
+
+       err = vlv_allow_gt_wake(dev_priv, true);
+       if (!ret)
+               ret = err;
+
+       err = vlv_force_gfx_clock(dev_priv, false);
+       if (!ret)
+               ret = err;
+
+       vlv_check_no_gt_access(dev_priv);
+
+       intel_init_clock_gating(dev);
+       intel_reset_gt_powersave(dev);
+       i915_gem_init_swizzling(dev);
+       i915_gem_restore_fences(dev);
+
+       intel_runtime_pm_restore_interrupts(dev);
+
+       return ret;
+}
+
 static int intel_runtime_suspend(struct device *device)
 {
        struct pci_dev *pdev = to_pci_dev(device);
        struct drm_device *dev = pci_get_drvdata(pdev);
        struct drm_i915_private *dev_priv = dev->dev_private;
+       int ret = 0;
 
        if (WARN_ON_ONCE(!dev_priv->rps.enabled))
                return -ENODEV;

drivers/gpu/drm/i915/i915_drv.c static int intel_runtime_suspend(struct device *device) · line 1316

Quoted 3 lines
drivers/gpu/drm/i915/i915_drv.c +0 -0
@@ -1162,9 +1314,17 @@ static int intel_runtime_suspend(struct device *device)
                snb_runtime_suspend(dev_priv);
        else if (IS_HASWELL(dev) || IS_BROADWELL(dev))
                hsw_runtime_suspend(dev_priv);

You make these guys return an error code, but you don't check for them. Even if they always return 0, I think it's good to add the check now, because in the future someone may write a patch adding a non-zero return and forget to add code to check for the error.

Quoted 15 lines
drivers/gpu/drm/i915/i915_drv.c +8 -0
+       else if (IS_VALLEYVIEW(dev))
+               ret = vlv_runtime_suspend(dev_priv);
        else
                WARN_ON(1);
 
+       if (ret) {
+               DRM_ERROR("Runtime suspend failed, disabling it\n");
+
+               return ret;
+       }
+
        i915_gem_release_all_mmaps(dev_priv);
 
        del_timer_sync(&dev_priv->gpu_error.hangcheck_timer);

drivers/gpu/drm/i915/i915_drv.c static int intel_runtime_resume(struct device *device) · line 1364

Quoted 5 lines
drivers/gpu/drm/i915/i915_drv.c +2 -0
@@ -1200,6 +1360,8 @@ static int intel_runtime_resume(struct device *device)
                snb_runtime_resume(dev_priv);
        else if (IS_HASWELL(dev) || IS_BROADWELL(dev))
                hsw_runtime_resume(dev_priv);
+       else if (IS_VALLEYVIEW(dev))
+               vlv_runtime_resume(dev_priv);

Same here.

Quoted 10 lines
drivers/gpu/drm/i915/i915_drv.c +0 -1
        else
                WARN_ON(1);
 
--

1.8.4

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx

Signature · 1 line
Paulo Zanoni
author
#38 lore raw

Re: [PATCH 14/15] drm/i915: vlv: add runtime PM support

Quoted 229 lines · Paulo Zanoni

2014-04-08 13:57 GMT-03:00 Imre Deak <[email protected]>:

Quoted 228 lines

Add runtime PM support for VLV, but leave it disabled. The next patch enables it.

The suspend/resume sequence used is based on [1] and [2]. In practice we depend on the GT RC6 mechanism to save the HW context depending on the render and media power wells. By the time we run the runtime suspend callback the display side is also off and the HW context for that is managed by the display power domain framework.

Besides the above there are Gunit registers that depend on a system-wide power well. This power well goes off once the device enters any of the S0i[R123] states. To handle this scenario, save/restore these Gunit registers. Note that this is not the complete register set dictated by [2], to remove some overhead registers that are known not to be used are ignored. Also some registers are fully setup by initialization functions called during resume, these are not saved either. The list of registers can be further reduced, see the TODO note in the code.

[1] VLV_gfx_clocking_PM_reset_y12w21d3 / "Driver D3 entry/exit"
[2] VLV2_S0IXRegs

---
 drivers/gpu/drm/i915/i915_drv.c | 170 +++++++++++++++++++++++++++++++++++++++-
 1 file changed, 166 insertions(+), 4 deletions(-)
drivers/gpu/drm/i915/i915_drv.c +156 -4
index 9f9d0db..16ca37f 100644
@@ -891,19 +891,23 @@ static int i915_pm_poweroff(struct device *dev)
        return i915_drm_freeze(drm_dev);
 }
 
-static void snb_runtime_suspend(struct drm_i915_private *dev_priv)
+static int snb_runtime_suspend(struct drm_i915_private *dev_priv)
 {
        struct drm_device *dev = dev_priv->dev;
 
        intel_runtime_pm_disable_interrupts(dev);
+
+       return 0;
 }
 
-static void hsw_runtime_suspend(struct drm_i915_private *dev_priv)
+static int hsw_runtime_suspend(struct drm_i915_private *dev_priv)
 {
        hsw_enable_pc8(dev_priv);
+
+       return 0;
 }
 
-static void snb_runtime_resume(struct drm_i915_private *dev_priv)
+static int snb_runtime_resume(struct drm_i915_private *dev_priv)
 {
        struct drm_device *dev = dev_priv->dev;
 
@@ -913,11 +917,15 @@ static void snb_runtime_resume(struct drm_i915_private *dev_priv)
        mutex_lock(&dev_priv->rps.hw_lock);
        gen6_update_ring_freq(dev);
        mutex_unlock(&dev_priv->rps.hw_lock);
+
+       return 0;
 }
 
-static void hsw_runtime_resume(struct drm_i915_private *dev_priv)
+static int hsw_runtime_resume(struct drm_i915_private *dev_priv)
 {
        hsw_disable_pc8(dev_priv);
+
+       return 0;
 }
 
 /*
@@ -1144,11 +1152,155 @@ int vlv_force_gfx_clock(struct drm_i915_private *dev_priv, bool force_on)
 #undef COND
 }
 
+static int vlv_allow_gt_wake(struct drm_i915_private *dev_priv, bool allow)
+{
+       u32 val;
+       int err = 0;
+
+       val = I915_READ(VLV_GTLC_WAKE_CTRL);
+       val &= ~VLV_GTLC_ALLOWWAKEREQ;
+       if (allow)
+               val |= VLV_GTLC_ALLOWWAKEREQ;
+       I915_WRITE(VLV_GTLC_WAKE_CTRL, val);
+       POSTING_READ(VLV_GTLC_WAKE_CTRL);
+
+#define COND (!!(I915_READ(VLV_GTLC_PW_STATUS) & VLV_GTLC_ALLOWWAKEACK) == \
+             allow)
+       err = wait_for(COND, 1);
+       if (err)
+               DRM_ERROR("timeout disabling GT waking\n");
+       return err;
+#undef COND
+}
+
+static int vlv_wait_for_gt_wells(struct drm_i915_private *dev_priv,
+                                bool wait_for_on)
+{
+       u32 mask;
+       u32 val;
+       int err;
+
+       mask = VLV_GTLC_PW_MEDIA_STATUS_MASK | VLV_GTLC_PW_RENDER_STATUS_MASK;
+       val = wait_for_on ? mask : 0;
+#define COND ((I915_READ(VLV_GTLC_PW_STATUS) & mask) == val)
+       if (COND)
+               return 0;
+
+       DRM_DEBUG_KMS("waiting for GT wells to go %s (%08x)\n",
+                       wait_for_on ? "on" : "off",
+                       I915_READ(VLV_GTLC_PW_STATUS));
+
+       /*
+        * RC6 transitioning can be delayed up to 2 msec (see
+        * valleyview_enable_rps), use 3 msec for safety.
+        */
+       err = wait_for(COND, 3);
+       if (err)
+               DRM_ERROR("timeout waiting for GT wells to go %s\n",
+                         wait_for_on ? "on" : "off");
+
+       return err;
+#undef COND
+}
+
+static void vlv_check_no_gt_access(struct drm_i915_private *dev_priv)
+{
+       if (!(I915_READ(VLV_GTLC_PW_STATUS) & VLV_GTLC_ALLOWWAKEERR))
+               return;
+
+       DRM_ERROR("GT register access while GT waking disabled\n");
+       I915_WRITE(VLV_GTLC_PW_STATUS, VLV_GTLC_ALLOWWAKEERR);
+}
+
+static int vlv_runtime_suspend(struct drm_i915_private *dev_priv)
+{
+       struct drm_device *dev = dev_priv->dev;
+       u32 mask;
+       int err;
+
+       if (WARN_ON(!valleyview_rc6_enabled(dev)))
+               return -ENODEV;
+
+       intel_runtime_pm_disable_interrupts(dev);
+       cancel_work_sync(&dev_priv->rps.work);
+
+       /*
+        * Bspec defines the following GT well on flags as debug only, so
+        * don't treat them as hard failures.
+        */
+       (void)vlv_wait_for_gt_wells(dev_priv, false);
+
+       mask = VLV_GTLC_RENDER_CTX_EXISTS | VLV_GTLC_MEDIA_CTX_EXISTS;
+       WARN_ON((I915_READ(VLV_GTLC_WAKE_CTRL) & mask) != mask);
+
+       vlv_check_no_gt_access(dev_priv);
+
+       err = vlv_force_gfx_clock(dev_priv, true);
+       if (err)
+               goto err1;
+
+       err = vlv_allow_gt_wake(dev_priv, false);
+       if (err)
+               goto err2;
+       vlv_save_gunit_s0ix_state(dev_priv);
+
+       err = vlv_force_gfx_clock(dev_priv, false);
+       if (err)
+               goto err2;
+
+       return 0;
+
+err2:
+       /* For safety always re-enable waking and disable gfx clock forcing */
+       vlv_allow_gt_wake(dev_priv, true);
+err1:
+       vlv_force_gfx_clock(dev_priv, false);
+       intel_runtime_pm_restore_interrupts(dev);
+
+       return err;
+}
+
+static int vlv_runtime_resume(struct drm_i915_private *dev_priv)
+{
+       struct drm_device *dev = dev_priv->dev;
+       int err;
+       int ret;
+
+       /*
+        * If any of the steps fail just try to continue, that's the best we
+        * can do at this point. Return the first error code (which will also
+        * leave RPM permanentyl disabled).
+        */
+       ret = vlv_force_gfx_clock(dev_priv, true);
+
+       vlv_restore_gunit_s0ix_state(dev_priv);
+
+       err = vlv_allow_gt_wake(dev_priv, true);
+       if (!ret)
+               ret = err;
+
+       err = vlv_force_gfx_clock(dev_priv, false);
+       if (!ret)
+               ret = err;
+
+       vlv_check_no_gt_access(dev_priv);
+
+       intel_init_clock_gating(dev);
+       intel_reset_gt_powersave(dev);
+       i915_gem_init_swizzling(dev);
+       i915_gem_restore_fences(dev);
+
+       intel_runtime_pm_restore_interrupts(dev);
+
+       return ret;
+}
+
 static int intel_runtime_suspend(struct device *device)
 {
        struct pci_dev *pdev = to_pci_dev(device);
        struct drm_device *dev = pci_get_drvdata(pdev);
        struct drm_i915_private *dev_priv = dev->dev_private;
+       int ret = 0;
 
Quoted 11 lines

drivers/gpu/drm/i915/i915_drv.c static int intel_runtime_suspend(struct device *device) · line 1316

Quoted 6 lines
drivers/gpu/drm/i915/i915_drv.c +0 -0
        if (WARN_ON_ONCE(!dev_priv->rps.enabled))
                return -ENODEV;
@@ -1162,9 +1314,17 @@ static int intel_runtime_suspend(struct device *device)
                snb_runtime_suspend(dev_priv);
        else if (IS_HASWELL(dev) || IS_BROADWELL(dev))
                hsw_runtime_suspend(dev_priv);

You make these guys return an error code, but you don't check for them. Even if they always return 0, I think it's good to add the check now, because in the future someone may write a patch adding a non-zero return and forget to add code to check for the error.

Yep, I missed that.

I actually depend on these propagating the error from the VLV callbacks, since those can fail.

BTW, right now I'm leaving RPM permanently disabled in case of an error, but I think we should try to reenable it.. Perhaps after a reset. I wasn't sure what's the right policy here, but in any case this can be added later as a follow-up if needed.

--Imre

Quoted 37 lines
Quoted 16 lines
drivers/gpu/drm/i915/i915_drv.c +8 -0
+       else if (IS_VALLEYVIEW(dev))
+               ret = vlv_runtime_suspend(dev_priv);
        else
                WARN_ON(1);
 
+       if (ret) {
+               DRM_ERROR("Runtime suspend failed, disabling it\n");
+
+               return ret;
+       }
+
        i915_gem_release_all_mmaps(dev_priv);
 
        del_timer_sync(&dev_priv->gpu_error.hangcheck_timer);

drivers/gpu/drm/i915/i915_drv.c static int intel_runtime_resume(struct device *device) · line 1364

Quoted 5 lines
drivers/gpu/drm/i915/i915_drv.c +2 -0
@@ -1200,6 +1360,8 @@ static int intel_runtime_resume(struct device *device)
                snb_runtime_resume(dev_priv);
        else if (IS_HASWELL(dev) || IS_BROADWELL(dev))
                hsw_runtime_resume(dev_priv);
+       else if (IS_VALLEYVIEW(dev))
+               vlv_runtime_resume(dev_priv);

Same here.

Quoted 10 lines
drivers/gpu/drm/i915/i915_drv.c +0 -1
        else
                WARN_ON(1);
 
--

1.8.4

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx

author
#39 lore raw

PATCH 15/15 drm/i915: vlv: enable RPM

In reply to Imre Deak
---
 drivers/gpu/drm/i915/i915_drv.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/gpu/drm/i915/i915_drv.h +1 -1
index d94e10a..84d4298 100644
@@ -1928,7 +1928,7 @@ struct drm_i915_cmd_table {
 #define HAS_FPGA_DBG_UNCLAIMED(dev)	(INTEL_INFO(dev)->has_fpga_dbg)
 #define HAS_PSR(dev)		(IS_HASWELL(dev) || IS_BROADWELL(dev))
 #define HAS_RUNTIME_PM(dev)	(IS_GEN6(dev) || IS_HASWELL(dev) || \
-				 IS_BROADWELL(dev))
+				 IS_BROADWELL(dev) || IS_VALLEYVIEW(dev))
 
 #define INTEL_PCH_DEVICE_ID_MASK		0xff00
 #define INTEL_PCH_IBX_DEVICE_ID_TYPE		0x3b00
Signature · 1 line
1.8.4