Skip to contentSkip to conversation

drm/i915: Use intel_engine_stop_cs when stopping ringbuffer

PATCH In review Mika Kuoppala 3 participants 10 messages Feb 27, 2019

Subsystems (2)
lore
Share & tools
lore
#0 lore raw

PATCH 1/3 drm/i915: Use intel_engine_stop_cs when stopping ringbuffer

We have an exported function for stopping the engine before disabling a ringbuffer. Take it into use.

---
 drivers/gpu/drm/i915/intel_engine_cs.c  |  3 +++
 drivers/gpu/drm/i915/intel_ringbuffer.c | 31 +++++++++++--------------
 2 files changed, 16 insertions(+), 18 deletions(-)
drivers/gpu/drm/i915/intel_engine_cs.c +3 -0
index 4f244019560d..3feb0f74c239 100644
@@ -817,6 +817,9 @@ void intel_engine_cancel_stop_cs(struct intel_engine_cs *engine)
 {
 	struct drm_i915_private *dev_priv = engine->i915;
 
+	if (INTEL_GEN(dev_priv) < 3)
+		return;
+
 	GEM_TRACE("%s\n", engine->name);
 
 	I915_WRITE_FW(RING_MI_MODE(engine->mmio_base),
drivers/gpu/drm/i915/intel_ringbuffer.c +13 -18
index 1b96b0960adc..5363dad1208d 100644
@@ -607,23 +607,19 @@ static void ring_setup_status_page(struct intel_engine_cs *engine)
 static bool stop_ring(struct intel_engine_cs *engine)
 {
 	struct drm_i915_private *dev_priv = engine->i915;
+	int ret;
 
-	if (INTEL_GEN(dev_priv) > 2) {
-		I915_WRITE_MODE(engine, _MASKED_BIT_ENABLE(STOP_RING));
-		if (intel_wait_for_register(dev_priv,
-					    RING_MI_MODE(engine->mmio_base),
-					    MODE_IDLE,
-					    MODE_IDLE,
-					    1000)) {
-			DRM_ERROR("%s : timed out trying to stop ring\n",
-				  engine->name);
-			/* Sometimes we observe that the idle flag is not
-			 * set even though the ring is empty. So double
-			 * check before giving up.
-			 */
-			if (I915_READ_HEAD(engine) != I915_READ_TAIL(engine))
-				return false;
-		}
+	ret = intel_engine_stop_cs(engine);
+	if (ret == -ENODEV)
+		ret = 0;
+
+	if (ret) {
+		/* Sometimes we observe that the idle flag is not
+		 * set even though the ring is empty. So double
+		 * check before giving up.
+		 */
+		if (I915_READ_HEAD(engine) != I915_READ_TAIL(engine))
+			return false;
 	}
 
 	I915_WRITE_HEAD(engine, I915_READ_TAIL(engine));
@@ -718,8 +714,7 @@ static int init_ring_common(struct intel_engine_cs *engine)
 		goto out;
 	}
 
-	if (INTEL_GEN(dev_priv) > 2)
-		I915_WRITE_MODE(engine, _MASKED_BIT_DISABLE(STOP_RING));
+	intel_engine_cancel_stop_cs(engine);
 
 	/* Now awake, let it get started */
 	if (ring->tail != ring->head) {
Signature · 6 lines
2.17.1

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

PATCH 2/3 drm/i915: Introduce intel_engine_stop_ringbuffer

We use identical sequence of stopping ringbuffer on reset handing and on ring initialization. Make a function to handle both cases.

---
 drivers/gpu/drm/i915/i915_reset.c       | 18 +---------------
 drivers/gpu/drm/i915/intel_engine_cs.c  | 28 +++++++++++++++++++++++++
 drivers/gpu/drm/i915/intel_ringbuffer.c | 10 ++-------
 drivers/gpu/drm/i915/intel_ringbuffer.h |  2 ++
 4 files changed, 33 insertions(+), 25 deletions(-)
drivers/gpu/drm/i915/i915_reset.c +1 -17
index 55d6123dbba4..4191398b5125 100644
@@ -113,28 +113,12 @@ void i915_reset_request(struct i915_request *rq, bool guilty)
 
 static void gen3_stop_engine(struct intel_engine_cs *engine)
 {
-	struct drm_i915_private *dev_priv = engine->i915;
-	const u32 base = engine->mmio_base;
-
 	GEM_TRACE("%s\n", engine->name);
 
 	if (intel_engine_stop_cs(engine))
 		GEM_TRACE("%s: timed out on STOP_RING\n", engine->name);
 
-	I915_WRITE_FW(RING_HEAD(base), I915_READ_FW(RING_TAIL(base)));
-	POSTING_READ_FW(RING_HEAD(base)); /* paranoia */
-
-	I915_WRITE_FW(RING_HEAD(base), 0);
-	I915_WRITE_FW(RING_TAIL(base), 0);
-	POSTING_READ_FW(RING_TAIL(base));
-
-	/* The ring must be empty before it is disabled */
-	I915_WRITE_FW(RING_CTL(base), 0);
-
-	/* Check acts as a post */
-	if (I915_READ_FW(RING_HEAD(base)))
-		GEM_TRACE("%s: ring head [%x] not parked\n",
-			  engine->name, I915_READ_FW(RING_HEAD(base)));
+	intel_engine_stop_ringbuffer(engine);
 }
 
 static void i915_stop_engines(struct drm_i915_private *i915,
drivers/gpu/drm/i915/intel_engine_cs.c +28 -0
index 3feb0f74c239..a8e47cfa6e35 100644
@@ -826,6 +826,34 @@ void intel_engine_cancel_stop_cs(struct intel_engine_cs *engine)
 		      _MASKED_BIT_DISABLE(STOP_RING));
 }
 
+int intel_engine_stop_ringbuffer(struct intel_engine_cs *engine)
+{
+	struct drm_i915_private *dev_priv = engine->i915;
+	const u32 base = engine->mmio_base;
+
+	assert_forcewakes_active(dev_priv, FORCEWAKE_ALL);
+	GEM_TRACE("%s\n", engine->name);
+
+	I915_WRITE_FW(RING_HEAD(base), I915_READ_FW(RING_TAIL(base)));
+	POSTING_READ_FW(RING_HEAD(base)); /* paranoia */
+
+	I915_WRITE_FW(RING_HEAD(base), 0);
+	I915_WRITE_FW(RING_TAIL(base), 0);
+	POSTING_READ_FW(RING_TAIL(base));
+
+	/* The ring must be empty before it is disabled */
+	I915_WRITE_FW(RING_CTL(base), 0);
+
+	/* Check acts as a post */
+	if (I915_READ_FW(RING_HEAD(base))) {
+		GEM_TRACE("%s: ring head [%x] not parked\n",
+			  engine->name, I915_READ_FW(RING_HEAD(base)));
+		return -EIO;
+	}
+
+	return 0;
+}
+
 const char *i915_cache_level_str(struct drm_i915_private *i915, int type)
 {
 	switch (type) {
drivers/gpu/drm/i915/intel_ringbuffer.c +2 -8
index 5363dad1208d..8936a9051760 100644
@@ -622,15 +622,9 @@ static bool stop_ring(struct intel_engine_cs *engine)
 			return false;
 	}
 
-	I915_WRITE_HEAD(engine, I915_READ_TAIL(engine));
+	ret = intel_engine_stop_ringbuffer(engine);
 
-	I915_WRITE_HEAD(engine, 0);
-	I915_WRITE_TAIL(engine, 0);
-
-	/* The ring must be empty before it is disabled */
-	I915_WRITE_CTL(engine, 0);
-
-	return (I915_READ_HEAD(engine) & HEAD_ADDR) == 0;
+	return ret == 0;
 }
 
 static int init_ring_common(struct intel_engine_cs *engine)
drivers/gpu/drm/i915/intel_ringbuffer.h +2 -0
index de8dba7565b0..10eb0f9a1432 100644
@@ -858,6 +858,8 @@ int intel_init_vebox_ring_buffer(struct intel_engine_cs *engine);
 int intel_engine_stop_cs(struct intel_engine_cs *engine);
 void intel_engine_cancel_stop_cs(struct intel_engine_cs *engine);
 
+int intel_engine_stop_ringbuffer(struct intel_engine_cs *engine);
+
 void intel_engine_set_hwsp_writemask(struct intel_engine_cs *engine, u32 mask);
 
 u64 intel_engine_get_active_head(const struct intel_engine_cs *engine);
Signature · 6 lines
2.17.1

_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
Reviewed-by on v1 2/3
#2 lore raw

Re: [PATCH 2/3] drm/i915: Introduce intel_engine_stop_ringbuffer

Quoting Mika Kuoppala (2019-02-27 16:58:49)

Quoted 52 lines

We use identical sequence of stopping ringbuffer on reset handing and on ring initialization. Make a function to handle both cases.

---
 drivers/gpu/drm/i915/i915_reset.c       | 18 +---------------
 drivers/gpu/drm/i915/intel_engine_cs.c  | 28 +++++++++++++++++++++++++
 drivers/gpu/drm/i915/intel_ringbuffer.c | 10 ++-------
 drivers/gpu/drm/i915/intel_ringbuffer.h |  2 ++
 4 files changed, 33 insertions(+), 25 deletions(-)
drivers/gpu/drm/i915/i915_reset.c +1 -17
index 55d6123dbba4..4191398b5125 100644
@@ -113,28 +113,12 @@ void i915_reset_request(struct i915_request *rq, bool guilty)
 
 static void gen3_stop_engine(struct intel_engine_cs *engine)
 {
-       struct drm_i915_private *dev_priv = engine->i915;
-       const u32 base = engine->mmio_base;
-
        GEM_TRACE("%s\n", engine->name);
 
        if (intel_engine_stop_cs(engine))
                GEM_TRACE("%s: timed out on STOP_RING\n", engine->name);
 
-       I915_WRITE_FW(RING_HEAD(base), I915_READ_FW(RING_TAIL(base)));
-       POSTING_READ_FW(RING_HEAD(base)); /* paranoia */
-
-       I915_WRITE_FW(RING_HEAD(base), 0);
-       I915_WRITE_FW(RING_TAIL(base), 0);
-       POSTING_READ_FW(RING_TAIL(base));
-
-       /* The ring must be empty before it is disabled */
-       I915_WRITE_FW(RING_CTL(base), 0);
-
-       /* Check acts as a post */
-       if (I915_READ_FW(RING_HEAD(base)))
-               GEM_TRACE("%s: ring head [%x] not parked\n",
-                         engine->name, I915_READ_FW(RING_HEAD(base)));
+       intel_engine_stop_ringbuffer(engine);
 }
 
 static void i915_stop_engines(struct drm_i915_private *i915,
drivers/gpu/drm/i915/intel_engine_cs.c +0 -0
index 3feb0f74c239..a8e47cfa6e35 100644

drivers/gpu/drm/i915/intel_engine_cs.c void intel_engine_cancel_stop_cs(struct intel_engine_cs *engine) · line 829

Quoted 4 lines
drivers/gpu/drm/i915/intel_engine_cs.c +1 -0
@@ -826,6 +826,34 @@ void intel_engine_cancel_stop_cs(struct intel_engine_cs *engine)
                      _MASKED_BIT_DISABLE(STOP_RING));
 }
 
+int intel_engine_stop_ringbuffer(struct intel_engine_cs *engine)

I think intel_engine_stop_ring() works better, since it is the set of RING registers we are controlling and are not concerned here with the backing buffer.

Quoted 35 lines
drivers/gpu/drm/i915/intel_engine_cs.c +27 -0
+{
+       struct drm_i915_private *dev_priv = engine->i915;
+       const u32 base = engine->mmio_base;
+
+       assert_forcewakes_active(dev_priv, FORCEWAKE_ALL);
+       GEM_TRACE("%s\n", engine->name);
+
+       I915_WRITE_FW(RING_HEAD(base), I915_READ_FW(RING_TAIL(base)));
+       POSTING_READ_FW(RING_HEAD(base)); /* paranoia */
+
+       I915_WRITE_FW(RING_HEAD(base), 0);
+       I915_WRITE_FW(RING_TAIL(base), 0);
+       POSTING_READ_FW(RING_TAIL(base));
+
+       /* The ring must be empty before it is disabled */
+       I915_WRITE_FW(RING_CTL(base), 0);
+
+       /* Check acts as a post */
+       if (I915_READ_FW(RING_HEAD(base))) {
+               GEM_TRACE("%s: ring head [%x] not parked\n",
+                         engine->name, I915_READ_FW(RING_HEAD(base)));
+               return -EIO;
+       }
+
+       return 0;
+}
+
 const char *i915_cache_level_str(struct drm_i915_private *i915, int type)
 {
        switch (type) {
drivers/gpu/drm/i915/intel_ringbuffer.c +0 -0
index 5363dad1208d..8936a9051760 100644

drivers/gpu/drm/i915/intel_ringbuffer.c static bool stop_ring(struct intel_engine_cs *engine) · line 625

Quoted 5 lines
drivers/gpu/drm/i915/intel_ringbuffer.c +1 -1
@@ -622,15 +622,9 @@ static bool stop_ring(struct intel_engine_cs *engine)
                        return false;
        }
 
-       I915_WRITE_HEAD(engine, I915_READ_TAIL(engine));
+       ret = intel_engine_stop_ringbuffer(engine);

Maybe

if (intel_engine_stop_ring(engine))

	return false;

return false;

looks tidier?

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

#3 lore raw

PATCH 3/3 drm/i915: Disable PSMI idle messaging when stopping ring

In reply to Mika Kuoppala

Hardware cannot be in a middle of idle flow messaging when we pull the plug from ringbuffer. Disable idle messaging before we do so to avoid potential deadlock on engine initialization and reset.

v2: INVALID_MMIO_REG, unconditional enable (Chris)

---
 drivers/gpu/drm/i915/intel_engine_cs.c | 56 +++++++++++++++++++++++++-
 1 file changed, 55 insertions(+), 1 deletion(-)
drivers/gpu/drm/i915/intel_engine_cs.c +55 -1
index a8e47cfa6e35..fe7fca392b63 100644
@@ -725,7 +725,7 @@ int intel_engine_init_common(struct intel_engine_cs *engine)
 
 /**
  * intel_engines_cleanup_common - cleans up the engine state created by
- *                                the common initiailizers.
+ *                                the common initializers.
  * @engine: Engine to cleanup.
  *
  * This cleans up everything created by the common helpers.
@@ -826,6 +826,55 @@ void intel_engine_cancel_stop_cs(struct intel_engine_cs *engine)
 		      _MASKED_BIT_DISABLE(STOP_RING));
 }
 
+static i915_reg_t get_idle_poll_reg(const struct intel_engine_cs *engine)
+{
+	if (engine->id != RCS)
+		return INVALID_MMIO_REG;
+
+	if (IS_GEN(engine->i915, 9))
+		return GEN9_RCS_FE_FSM2;
+
+	if (IS_GEN(engine->i915, 8))
+		return GEN6_RCS_PWR_FSM;
+
+	return INVALID_MMIO_REG;
+}
+
+static void disable_idle_messaging(struct intel_engine_cs *engine)
+{
+	struct drm_i915_private *dev_priv = engine->i915;
+	i915_reg_t poll_reg;
+
+	poll_reg = get_idle_poll_reg(engine);
+	if (!i915_mmio_reg_valid(poll_reg))
+		return;
+
+	GEM_DEBUG_WARN_ON(I915_READ_FW(GEN6_RC_SLEEP_PSMI_CONTROL) &
+			  GEN6_PSMI_SLEEP_MSG_DISABLE);
+
+	I915_WRITE_FW(GEN6_RC_SLEEP_PSMI_CONTROL,
+		      _MASKED_BIT_ENABLE(GEN6_PSMI_SLEEP_MSG_DISABLE));
+
+	if (__intel_wait_for_register_fw(dev_priv, poll_reg,
+					 0x7f, 0x30,
+					 5000, 0,
+					 NULL))
+		DRM_DEBUG_DRIVER("psmi idle msg poll timeout\n");
+}
+
+static void enable_idle_messaging(struct intel_engine_cs *engine)
+{
+	struct drm_i915_private *dev_priv = engine->i915;
+	i915_reg_t poll_reg;
+
+	poll_reg = get_idle_poll_reg(engine);
+	if (!i915_mmio_reg_valid(poll_reg))
+		return;
+
+	I915_WRITE_FW(GEN6_RC_SLEEP_PSMI_CONTROL,
+		      _MASKED_BIT_DISABLE(GEN6_PSMI_SLEEP_MSG_DISABLE));
+}
+
 int intel_engine_stop_ringbuffer(struct intel_engine_cs *engine)
 {
 	struct drm_i915_private *dev_priv = engine->i915;
@@ -841,9 +890,14 @@ int intel_engine_stop_ringbuffer(struct intel_engine_cs *engine)
 	I915_WRITE_FW(RING_TAIL(base), 0);
 	POSTING_READ_FW(RING_TAIL(base));
 
+	/* Idle messaging needs to be off during ring disable */
+	disable_idle_messaging(engine);
+
 	/* The ring must be empty before it is disabled */
 	I915_WRITE_FW(RING_CTL(base), 0);
 
+	enable_idle_messaging(engine);
+
 	/* Check acts as a post */
 	if (I915_READ_FW(RING_HEAD(base))) {
 		GEM_TRACE("%s: ring head [%x] not parked\n",
Signature · 6 lines
2.17.1

_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
Acked-by on v1 3/3
#4 lore raw

Re: [PATCH 3/3] drm/i915: Disable PSMI idle messaging when stopping ring

Quoting Mika Kuoppala (2019-02-27 16:58:50)

Quoted 49 lines

Hardware cannot be in a middle of idle flow messaging when we pull the plug from ringbuffer. Disable idle messaging before we do so to avoid potential deadlock on engine initialization and reset.

v2: INVALID_MMIO_REG, unconditional enable (Chris)

---
 drivers/gpu/drm/i915/intel_engine_cs.c | 56 +++++++++++++++++++++++++-
 1 file changed, 55 insertions(+), 1 deletion(-)
drivers/gpu/drm/i915/intel_engine_cs.c +20 -1
index a8e47cfa6e35..fe7fca392b63 100644
@@ -725,7 +725,7 @@ int intel_engine_init_common(struct intel_engine_cs *engine)
 
 /**
  * intel_engines_cleanup_common - cleans up the engine state created by
- *                                the common initiailizers.
+ *                                the common initializers.
  * @engine: Engine to cleanup.
  *
  * This cleans up everything created by the common helpers.
@@ -826,6 +826,55 @@ void intel_engine_cancel_stop_cs(struct intel_engine_cs *engine)
                      _MASKED_BIT_DISABLE(STOP_RING));
 }
 
+static i915_reg_t get_idle_poll_reg(const struct intel_engine_cs *engine)
+{
+       if (engine->id != RCS)
+               return INVALID_MMIO_REG;
+
+       if (IS_GEN(engine->i915, 9))
+               return GEN9_RCS_FE_FSM2;
+
+       if (IS_GEN(engine->i915, 8))
+               return GEN6_RCS_PWR_FSM;
+
+       return INVALID_MMIO_REG;
+}
+
+static void disable_idle_messaging(struct intel_engine_cs *engine)
+{
+       struct drm_i915_private *dev_priv = engine->i915;
+       i915_reg_t poll_reg;
+

drivers/gpu/drm/i915/intel_engine_cs.c void intel_engine_cancel_stop_cs(struct intel_engine_cs *engine) · line 857

Quoted 10 lines
drivers/gpu/drm/i915/intel_engine_cs.c +10 -0
+       poll_reg = get_idle_poll_reg(engine);
+       if (!i915_mmio_reg_valid(poll_reg))
+               return;
+
+       GEM_DEBUG_WARN_ON(I915_READ_FW(GEN6_RC_SLEEP_PSMI_CONTROL) &
+                         GEN6_PSMI_SLEEP_MSG_DISABLE);
+
+       I915_WRITE_FW(GEN6_RC_SLEEP_PSMI_CONTROL,
+                     _MASKED_BIT_ENABLE(GEN6_PSMI_SLEEP_MSG_DISABLE));
+

Needs some reference at least. Or a synposis of what exactly we are waiting for in a comment.

Quoted 28 lines
drivers/gpu/drm/i915/intel_engine_cs.c +21 -0
+       if (__intel_wait_for_register_fw(dev_priv, poll_reg,
+                                        0x7f, 0x30,
+                                        5000, 0,
+                                        NULL))
+               DRM_DEBUG_DRIVER("psmi idle msg poll timeout\n");
+}
+
+static void enable_idle_messaging(struct intel_engine_cs *engine)
+{
+       struct drm_i915_private *dev_priv = engine->i915;
+       i915_reg_t poll_reg;
+
+       poll_reg = get_idle_poll_reg(engine);
+       if (!i915_mmio_reg_valid(poll_reg))
+               return;
+
+       I915_WRITE_FW(GEN6_RC_SLEEP_PSMI_CONTROL,
+                     _MASKED_BIT_DISABLE(GEN6_PSMI_SLEEP_MSG_DISABLE));
+}
+
 int intel_engine_stop_ringbuffer(struct intel_engine_cs *engine)
 {
        struct drm_i915_private *dev_priv = engine->i915;
@@ -841,9 +890,14 @@ int intel_engine_stop_ringbuffer(struct intel_engine_cs *engine)
        I915_WRITE_FW(RING_TAIL(base), 0);
        POSTING_READ_FW(RING_TAIL(base));
 
+       /* Idle messaging needs to be off during ring disable */

drivers/gpu/drm/i915/intel_engine_cs.c int intel_engine_stop_ringbuffer(struct intel_engine_cs *engine) · line 903

Quoted 10 lines
drivers/gpu/drm/i915/intel_engine_cs.c +4 -0
+       disable_idle_messaging(engine);
+
        /* The ring must be empty before it is disabled */
        I915_WRITE_FW(RING_CTL(base), 0);
 
+       enable_idle_messaging(engine);
+
        /* Check acts as a post */
        if (I915_READ_FW(RING_HEAD(base))) {
                GEM_TRACE("%s: ring head [%x] not parked\n",

Given the history SLEEP_MSG_DISABLE around RING_CTL is not surprising.

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

#5 lore raw
In reply to Mika Kuoppala
Quoted 50 lines · Mika Kuoppala

We have an exported function for stopping the engine before disabling a ringbuffer. Take it into use.

---
 drivers/gpu/drm/i915/intel_engine_cs.c  |  3 +++
 drivers/gpu/drm/i915/intel_ringbuffer.c | 31 +++++++++++--------------
 2 files changed, 16 insertions(+), 18 deletions(-)
drivers/gpu/drm/i915/intel_engine_cs.c +3 -0
index 4f244019560d..3feb0f74c239 100644
@@ -817,6 +817,9 @@ void intel_engine_cancel_stop_cs(struct intel_engine_cs *engine)
 {
 	struct drm_i915_private *dev_priv = engine->i915;
 
+	if (INTEL_GEN(dev_priv) < 3)
+		return;
+
 	GEM_TRACE("%s\n", engine->name);
 
 	I915_WRITE_FW(RING_MI_MODE(engine->mmio_base),
drivers/gpu/drm/i915/intel_ringbuffer.c +1 -16
index 1b96b0960adc..5363dad1208d 100644
@@ -607,23 +607,19 @@ static void ring_setup_status_page(struct intel_engine_cs *engine)
 static bool stop_ring(struct intel_engine_cs *engine)
 {
 	struct drm_i915_private *dev_priv = engine->i915;
+	int ret;
 
-	if (INTEL_GEN(dev_priv) > 2) {
-		I915_WRITE_MODE(engine, _MASKED_BIT_ENABLE(STOP_RING));
-		if (intel_wait_for_register(dev_priv,
-					    RING_MI_MODE(engine->mmio_base),
-					    MODE_IDLE,
-					    MODE_IDLE,
-					    1000)) {
-			DRM_ERROR("%s : timed out trying to stop ring\n",
-				  engine->name);
-			/* Sometimes we observe that the idle flag is not
-			 * set even though the ring is empty. So double
-			 * check before giving up.
-			 */
-			if (I915_READ_HEAD(engine) != I915_READ_TAIL(engine))
-				return false;
-		}

drivers/gpu/drm/i915/intel_ringbuffer.c static void ring_setup_status_page(struct intel_engine_cs *engine) · line 621

Quoted 10 lines
drivers/gpu/drm/i915/intel_ringbuffer.c +10 -0
+	ret = intel_engine_stop_cs(engine);
+	if (ret == -ENODEV)
+		ret = 0;
+
+	if (ret) {
+		/* Sometimes we observe that the idle flag is not
+		 * set even though the ring is empty. So double
+		 * check before giving up.
+		 */
+		if (I915_READ_HEAD(engine) != I915_READ_TAIL(engine))

Hmm these could have been also converted to the _FW variants. -Mika

Quoted 16 lines
drivers/gpu/drm/i915/intel_ringbuffer.c +2 -2
+			return false;
 	}
 
 	I915_WRITE_HEAD(engine, I915_READ_TAIL(engine));
@@ -718,8 +714,7 @@ static int init_ring_common(struct intel_engine_cs *engine)
 		goto out;
 	}
 
-	if (INTEL_GEN(dev_priv) > 2)
-		I915_WRITE_MODE(engine, _MASKED_BIT_DISABLE(STOP_RING));
+	intel_engine_cancel_stop_cs(engine);
 
 	/* Now awake, let it get started */
 	if (ring->tail != ring->head) {
Signature · 1 line
2.17.1

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

#6 lore raw

Quoting Mika Kuoppala (2019-02-27 17:03:38)

Quoted 56 lines
Quoted 54 lines · Mika Kuoppala

We have an exported function for stopping the engine before disabling a ringbuffer. Take it into use.

---
 drivers/gpu/drm/i915/intel_engine_cs.c  |  3 +++
 drivers/gpu/drm/i915/intel_ringbuffer.c | 31 +++++++++++--------------
 2 files changed, 16 insertions(+), 18 deletions(-)
drivers/gpu/drm/i915/intel_engine_cs.c +3 -0
index 4f244019560d..3feb0f74c239 100644
@@ -817,6 +817,9 @@ void intel_engine_cancel_stop_cs(struct intel_engine_cs *engine)
 {
      struct drm_i915_private *dev_priv = engine->i915;
 
+     if (INTEL_GEN(dev_priv) < 3)
+             return;
+
      GEM_TRACE("%s\n", engine->name);
 
      I915_WRITE_FW(RING_MI_MODE(engine->mmio_base),
drivers/gpu/drm/i915/intel_ringbuffer.c +5 -16
index 1b96b0960adc..5363dad1208d 100644
@@ -607,23 +607,19 @@ static void ring_setup_status_page(struct intel_engine_cs *engine)
 static bool stop_ring(struct intel_engine_cs *engine)
 {
      struct drm_i915_private *dev_priv = engine->i915;
+     int ret;
 
-     if (INTEL_GEN(dev_priv) > 2) {
-             I915_WRITE_MODE(engine, _MASKED_BIT_ENABLE(STOP_RING));
-             if (intel_wait_for_register(dev_priv,
-                                         RING_MI_MODE(engine->mmio_base),
-                                         MODE_IDLE,
-                                         MODE_IDLE,
-                                         1000)) {
-                     DRM_ERROR("%s : timed out trying to stop ring\n",
-                               engine->name);
-                     /* Sometimes we observe that the idle flag is not
-                      * set even though the ring is empty. So double
-                      * check before giving up.
-                      */
-                     if (I915_READ_HEAD(engine) != I915_READ_TAIL(engine))
-                             return false;
-             }
+     ret = intel_engine_stop_cs(engine);
+     if (ret == -ENODEV)
+             ret = 0;
+
Quoted 8 lines

drivers/gpu/drm/i915/intel_ringbuffer.c static void ring_setup_status_page(struct intel_engine_cs *engine) · line 621

Quoted 6 lines
drivers/gpu/drm/i915/intel_ringbuffer.c +6 -0
+     if (ret) {
+             /* Sometimes we observe that the idle flag is not
+              * set even though the ring is empty. So double
+              * check before giving up.
+              */
+             if (I915_READ_HEAD(engine) != I915_READ_TAIL(engine))

Hmm these could have been also converted to the _FW variants.

Sneak it in.
-Chris
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

Reviewed-by on v1 1/3
#7 lore raw
In reply to Mika Kuoppala

Quoting Mika Kuoppala (2019-02-27 16:58:48)

Quoted 46 lines

We have an exported function for stopping the engine before disabling a ringbuffer. Take it into use.

---
 drivers/gpu/drm/i915/intel_engine_cs.c  |  3 +++
 drivers/gpu/drm/i915/intel_ringbuffer.c | 31 +++++++++++--------------
 2 files changed, 16 insertions(+), 18 deletions(-)
drivers/gpu/drm/i915/intel_engine_cs.c +3 -0
index 4f244019560d..3feb0f74c239 100644
@@ -817,6 +817,9 @@ void intel_engine_cancel_stop_cs(struct intel_engine_cs *engine)
 {
        struct drm_i915_private *dev_priv = engine->i915;
 
+       if (INTEL_GEN(dev_priv) < 3)
+               return;
+
        GEM_TRACE("%s\n", engine->name);
 
        I915_WRITE_FW(RING_MI_MODE(engine->mmio_base),
drivers/gpu/drm/i915/intel_ringbuffer.c +1 -12
index 1b96b0960adc..5363dad1208d 100644
@@ -607,23 +607,19 @@ static void ring_setup_status_page(struct intel_engine_cs *engine)
 static bool stop_ring(struct intel_engine_cs *engine)
 {
        struct drm_i915_private *dev_priv = engine->i915;
+       int ret;
 
-       if (INTEL_GEN(dev_priv) > 2) {
-               I915_WRITE_MODE(engine, _MASKED_BIT_ENABLE(STOP_RING));
-               if (intel_wait_for_register(dev_priv,
-                                           RING_MI_MODE(engine->mmio_base),
-                                           MODE_IDLE,
-                                           MODE_IDLE,
-                                           1000)) {
-                       DRM_ERROR("%s : timed out trying to stop ring\n",
-                                 engine->name);
-                       /* Sometimes we observe that the idle flag is not
-                        * set even though the ring is empty. So double
-                        * check before giving up.

drivers/gpu/drm/i915/intel_ringbuffer.c static void ring_setup_status_page(struct intel_engine_cs *engine) · line 617

Quoted 10 lines
drivers/gpu/drm/i915/intel_ringbuffer.c +6 -4
-                        */
-                       if (I915_READ_HEAD(engine) != I915_READ_TAIL(engine))
-                               return false;
-               }
+       ret = intel_engine_stop_cs(engine);
+       if (ret == -ENODEV)
+               ret = 0;
+
+       if (ret) {
+               /* Sometimes we observe that the idle flag is not

As you go past, gradually switch over to
/*
* Sometimes...
style. The joys of a slow transition to uniformity and switching styles half way through.

Quoted 9 lines
drivers/gpu/drm/i915/intel_ringbuffer.c +5 -0
+                * set even though the ring is empty. So double
+                * check before giving up.
+                */
+               if (I915_READ_HEAD(engine) != I915_READ_TAIL(engine))
+                       return false;
        }
 
        I915_WRITE_HEAD(engine, I915_READ_TAIL(engine));

drivers/gpu/drm/i915/intel_ringbuffer.c static int init_ring_common(struct intel_engine_cs *engine) · line 720

Quoted 9 lines
drivers/gpu/drm/i915/intel_ringbuffer.c +1 -2
@@ -718,8 +714,7 @@ static int init_ring_common(struct intel_engine_cs *engine)
                goto out;
        }
 
-       if (INTEL_GEN(dev_priv) > 2)
-               I915_WRITE_MODE(engine, _MASKED_BIT_DISABLE(STOP_RING));
+       intel_engine_cancel_stop_cs(engine);
 
        /* Now awake, let it get started */
        if (ring->tail != ring->head) {

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

#8 lore raw

✗ Fi.CI.BAT: failure for series starting with [1/3] drm/i915: Use intel_engine_stop_cs when stopping ringbuffer

In reply to Mika Kuoppala
== Series Details ==

== Series Details ==

Series: series starting with [1/3] drm/i915: Use intel_engine_stop_cs when stopping ringbuffer
URL : https://patchwork.freedesktop.org/series/57304/
State : failure

== Summary ==

CI Bug Log - changes from CI_DRM_5666 -> Patchwork_12316
====================================================

Summary
-------

**FAILURE**

Serious unknown changes coming with Patchwork_12316 absolutely need to be verified manually.

If you think the reported changes have nothing to do with the changes introduced in Patchwork_12316, please notify your bug team to allow them to document this new failure mode, which will reduce false positives in CI.

External URL: https://patchwork.freedesktop.org/api/1.0/series/57304/revisions/1/

Possible new issues
-------------------

Here are the unknown changes that may have been introduced in Patchwork_12316:

### IGT changes ###

#### Possible regressions ####

* igt@i915_selftest@live_active:
- fi-apl-guc: PASS -> DMESG-WARN

Known issues
------------

Here are the changes found in Patchwork_12316 that come from known issues:

### IGT changes ###

#### Issues hit ####

* igt@i915_pm_rpm@basic-pci-d3-state:
- fi-byt-j1900: PASS -> SKIP [fdo#109271]

* igt@i915_pm_rpm@basic-rte:
- fi-byt-j1900: PASS -> FAIL [fdo#108800]

* igt@i915_selftest@live_contexts:
- fi-icl-u2: NOTRUN -> DMESG-FAIL [fdo#108569]

* igt@kms_busy@basic-flip-a:
- fi-kbl-7567u: PASS -> SKIP [fdo#109271] / [fdo#109278] +2

* igt@kms_chamelium@common-hpd-after-suspend:
- fi-kbl-7567u: PASS -> WARN [fdo#109380]

* igt@kms_pipe_crc_basic@nonblocking-crc-pipe-c:
- fi-kbl-7567u: PASS -> SKIP [fdo#109271] +33

* igt@kms_psr@primary_mmap_gtt:
- fi-blb-e6850: NOTRUN -> SKIP [fdo#109271] +27

#### Possible fixes ####

* igt@i915_selftest@live_requests:
- fi-icl-u2: INCOMPLETE [fdo#109644] -> PASS

* igt@kms_pipe_crc_basic@suspend-read-crc-pipe-b:
- fi-blb-e6850: INCOMPLETE [fdo#107718] -> PASS

{name}: This element is suppressed. This means it is ignored when computing
the status of the difference (SUCCESS, WARNING, or FAILURE).

[fdo#107718]: https://bugs.freedesktop.org/show_bug.cgi?id=107718
[fdo#108569]: https://bugs.freedesktop.org/show_bug.cgi?id=108569
[fdo#108800]: https://bugs.freedesktop.org/show_bug.cgi?id=108800
[fdo#109271]: https://bugs.freedesktop.org/show_bug.cgi?id=109271
[fdo#109278]: https://bugs.freedesktop.org/show_bug.cgi?id=109278
[fdo#109380]: https://bugs.freedesktop.org/show_bug.cgi?id=109380
[fdo#109644]: https://bugs.freedesktop.org/show_bug.cgi?id=109644

Participating hosts (44 -> 36)
------------------------------

Missing (8): fi-ilk-m540 fi-hsw-4200u fi-hsw-peppy fi-byt-squawks fi-bsw-cyan fi-ctg-p8600 fi-gdg-551 fi-ivb-3770

Build changes
-------------

* Linux: CI_DRM_5666 -> Patchwork_12316

CI_DRM_5666: 358ab8acaabef3cef2a7ce9e5dd7c4196a0c30fc @ git://anongit.freedesktop.org/gfx-ci/linux
IGT_4860: b79007f9c575a538a63ce9301a890ed9e1a45f35 @ git://anongit.freedesktop.org/xorg/app/intel-gpu-tools
Patchwork_12316: a3a61404858ebb091d4618c68a60513cfdedfc95 @ git://anongit.freedesktop.org/gfx-ci/linux

== Linux commits ==

a3a61404858e drm/i915: Disable PSMI idle messaging when stopping ring c29ce4adfdc3 drm/i915: Introduce intel_engine_stop_ringbuffer 8195837078fd drm/i915: Use intel_engine_stop_cs when stopping ringbuffer

== Logs ==

For more details see: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_12316/
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

#9 lore raw

Re: ✗ Fi.CI.BAT: failure for series starting with [1/3] drm/i915: Use intel_engine_stop_cs when stopping ringbuffer

Quoting Patchwork (2019-02-27 17:41:59)

Quoted 4 lines

#### Possible regressions ####

* igt@i915_selftest@live_active:
- fi-apl-guc: PASS -> DMESG-WARN

Second flip due to "drm/i915: Avoid waking the engines just to check if they are idle", both skl.

Suggests that its passing earlier was fluke.
-Chris
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx