Intel-GFX Archive on lore.kernel.org
 help / color / mirror / Atom feed
* [PATCH 0/6] drm/i915: Make register accesses and unclaimed mmio detection lockless for TGL+
@ 2026-11-19 20:50 Ville Syrjala
  2026-11-19 20:50 ` [PATCH 1/6] drm/i915/de: Uninline intel_de_{read,write}_fw() Ville Syrjala
                   ` (6 more replies)
  0 siblings, 7 replies; 9+ messages in thread
From: Ville Syrjala @ 2026-11-19 20:50 UTC (permalink / raw)
  To: intel-gfx; +Cc: intel-xe

From: Ville Syrjälä <ville.syrjala@linux.intel.com>

Make the unclaimed mmio detection lockless (albeit somewhat
more racy), and utilize that to to make all register accesses
lockless on TGL+. By using the lockless xe driver on TGL+ we've
pretty well established that serializing all register accesses
(ala IVB/HSW) is not required on TGL+.

And I tossed in the deinlining of intel_de_{read,write}_fw()
as well because the bloat has been bothering me for a while.

I left out the earlier xe parts. Once we land these i915 bits,
we can try again to enable unclaimed mmio detect for the pre-LNL
platforms on xe as well. Theoretically those should be fine since
i915 is fine, but the messed up differences in the init/suspend
ordering between the drivers can cause xe exclusive issues still.
And based on the last attempt we already know that some LNL+ systems
are have broken pure display code paths (eg. ALPM), which will need
to be fixed before we can enable the unclaimed mmio detection for those
platforms.

v2: Drop the xe stuff
    Keep the modparam as int for compatibility purposes (Jani)

Ville Syrjälä (6):
  drm/i915/de: Uninline intel_de_{read,write}_fw()
  drm/i915/de: Pimp the intel_de_{read,write}_fw() docs
  drm/i915/de: Flatten the unclaimed mmio code
  drm/i915/de: Make mmio_debug lockless
  drm/i915/de: Optimize the mmio_debug checks in intel_de_{read,write}()
  drm/i915/de: Make display registers unlocked for TGL+ on i915

 drivers/gpu/drm/i915/display/intel_de.c       | 180 ++++++++++++------
 drivers/gpu/drm/i915/display/intel_de.h       |  40 ++--
 .../gpu/drm/i915/display/intel_display_core.h |  16 +-
 .../drm/i915/display/intel_display_params.c   |   2 +-
 4 files changed, 147 insertions(+), 91 deletions(-)

-- 
2.56.0


^ permalink raw reply	[flat|nested] 9+ messages in thread

* [PATCH 1/6] drm/i915/de: Uninline intel_de_{read,write}_fw()
  2026-11-19 20:50 [PATCH 0/6] drm/i915: Make register accesses and unclaimed mmio detection lockless for TGL+ Ville Syrjala
@ 2026-11-19 20:50 ` Ville Syrjala
  2026-11-19 20:50 ` [PATCH 2/6] drm/i915/de: Pimp the intel_de_{read,write}_fw() docs Ville Syrjala
                   ` (5 subsequent siblings)
  6 siblings, 0 replies; 9+ messages in thread
From: Ville Syrjala @ 2026-11-19 20:50 UTC (permalink / raw)
  To: intel-gfx; +Cc: intel-xe, Jani Nikula

From: Ville Syrjälä <ville.syrjala@linux.intel.com>

One might think that inlining intel_de_{read,write}_fw() would
be a good idea for performance reasons, and if these were just
the raw readl()/writel() then that would be true. But they
also contain the tracepoint, which actually translates to
surprising amount of code. The register accessors are used in
so many places that the extra code really adds up.

So making these non-inline functions seems like the better
choice here. This also lets the compiler again combine the
dsb vs. not branches from multiple back to back
intel_de_write_dsb() calls into a single branch. The
inlined tracepoint bloated the code so much that the
compiler generally just gave up on that, emitting funkier
code as a result.

I do want the inline versions inside intel_de.c to keep
the overhead minimal inside the vfuncs. gcc refuses to
inline any of these on its own for whatever reason.

Note that for xe we are now doing two function calls for
each of these since xe_mmio_{read,write}32() are also real
non-inline functions. But once we get rid of the uncore
stuff completely xe will again lose the second level of
function calls.

This shrinks the final i915.ko by 800 KiB without lockdep,
and 1200 KiB with lockdep enabled.

bloat-o-meter highlights:
add/remove: 25/34 grow/shrink: 30/150 up/down: 208667/-253907 (-45240)
Function                                     old     new   delta
...
do_gmbus_xfer                               2342    1392    -950
skl_write_plane_wm                          2199    1212    -987
skl_plane_update_arm                        1997     976   -1021
ilk_update_pipe_csc                         1752     723   -1029
i9xx_plane_update_arm                       1670     621   -1049
chv_load_luts                               2043     912   -1131
vlv_atomic_update_fifo                      2177     895   -1282
icl_color_commit_noarm                      2329     931   -1398
g4x_sprite_update_arm                       2138     737   -1401
ilk_read_pipe_csc                           1807     337   -1470
icl_read_csc                                1987     439   -1548
ivb_sprite_update_arm                       2324     730   -1594
i9xx_cursor_update_arm                      4513    2817   -1696
gen8_de_irq_handler                         5037    2816   -2221
vlv_sprite_update_arm                       4627    1225   -3402
icl_plane_update_noarm                      7885    3143   -4742
Total: Before=39595300, After=39550060, chg -0.11%

Reviewed-by: Jani Nikula <jani.nikula@intel.com>
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
---
 drivers/gpu/drm/i915/display/intel_de.c | 47 +++++++++++++++++++++----
 drivers/gpu/drm/i915/display/intel_de.h | 26 ++------------
 2 files changed, 43 insertions(+), 30 deletions(-)

diff --git a/drivers/gpu/drm/i915/display/intel_de.c b/drivers/gpu/drm/i915/display/intel_de.c
index 08a0027e7930..799ca57bac65 100644
--- a/drivers/gpu/drm/i915/display/intel_de.c
+++ b/drivers/gpu/drm/i915/display/intel_de.c
@@ -10,6 +10,13 @@
 #include "intel_de.h"
 #include "intel_display_regs.h"
 #include "intel_display_rpm.h"
+#include "intel_uncore.h"
+#include "intel_uncore_trace.h"
+
+static inline struct intel_uncore *__to_uncore(struct intel_display *display)
+{
+	return display->mmio.uncore;
+}
 
 static int intel_de_wait_for_register(struct intel_display *display,
 				      intel_reg_t reg, u32 mask, u32 value,
@@ -165,11 +172,39 @@ u16 intel_de_read16(struct intel_display *display, intel_reg_t reg)
 	return intel_uncore_read16(__to_uncore(display), reg);
 }
 
+static __always_inline u32
+__intel_de_read_fw(struct intel_display *display, intel_reg_t reg)
+{
+	u32 val;
+
+	val = intel_uncore_read_fw(__to_uncore(display), reg);
+	trace_i915_reg_rw(false, reg, val, sizeof(val), true);
+
+	return val;
+}
+
+static __always_inline void
+__intel_de_write_fw(struct intel_display *display, intel_reg_t reg, u32 val)
+{
+	trace_i915_reg_rw(true, reg, val, sizeof(val), true);
+	intel_uncore_write_fw(__to_uncore(display), reg, val);
+}
+
+u32 intel_de_read_fw(struct intel_display *display, intel_reg_t reg)
+{
+	return __intel_de_read_fw(display, reg);
+}
+
+void intel_de_write_fw(struct intel_display *display, intel_reg_t reg, u32 val)
+{
+	__intel_de_write_fw(display, reg, val);
+}
+
 static bool hsw_check_for_unclaimed_mmio(struct intel_display *display)
 {
 	u32 dbg;
 
-	dbg = intel_de_read_fw(display, FPGA_DBG);
+	dbg = __intel_de_read_fw(display, FPGA_DBG);
 	if (likely(!(dbg & FPGA_DBG_RM_NOCLAIM)))
 		return false;
 
@@ -189,7 +224,7 @@ static bool hsw_check_for_unclaimed_mmio(struct intel_display *display)
 		drm_err(display->drm,
 			"Lost access to MMIO BAR; all registers now read back as 0xFFFFFFFF!\n");
 
-	intel_de_write_fw(display, FPGA_DBG, FPGA_DBG_RM_NOCLAIM);
+	__intel_de_write_fw(display, FPGA_DBG, FPGA_DBG_RM_NOCLAIM);
 
 	return true;
 }
@@ -198,11 +233,11 @@ static bool vlv_check_for_unclaimed_mmio(struct intel_display *display)
 {
 	u32 cer;
 
-	cer = intel_de_read_fw(display, CLAIM_ER);
+	cer = __intel_de_read_fw(display, CLAIM_ER);
 	if (likely(!(cer & (CLAIM_ER_OVERFLOW | CLAIM_ER_CTR_MASK))))
 		return false;
 
-	intel_de_write_fw(display, CLAIM_ER, CLAIM_ER_CLR);
+	__intel_de_write_fw(display, CLAIM_ER, CLAIM_ER_CLR);
 
 	return true;
 }
@@ -348,7 +383,7 @@ __intel_de_read(struct intel_display *display, intel_reg_t reg,
 	__mmio_lock_pre(display, &irqflags, mmio_flags);
 	__mmio_unclaimed_pre(display, reg, false, mmio_flags);
 
-	val = intel_de_read_fw(display, reg);
+	val = __intel_de_read_fw(display, reg);
 
 	__mmio_unclaimed_post(display, reg, false, mmio_flags);
 	__mmio_lock_post(display, irqflags, mmio_flags);
@@ -369,7 +404,7 @@ __intel_de_write(struct intel_display *display, intel_reg_t reg, u32 val,
 	__mmio_lock_pre(display, &irqflags, mmio_flags);
 	__mmio_unclaimed_pre(display, reg, true, mmio_flags);
 
-	intel_de_write_fw(display, reg, val);
+	__intel_de_write_fw(display, reg, val);
 
 	__mmio_unclaimed_post(display, reg, true, mmio_flags);
 	__mmio_lock_post(display, irqflags, mmio_flags);
diff --git a/drivers/gpu/drm/i915/display/intel_de.h b/drivers/gpu/drm/i915/display/intel_de.h
index 310f81edc09d..a6dcb91b36f2 100644
--- a/drivers/gpu/drm/i915/display/intel_de.h
+++ b/drivers/gpu/drm/i915/display/intel_de.h
@@ -8,8 +8,6 @@
 
 #include "intel_display_core.h"
 #include "intel_dsb.h"
-#include "intel_uncore.h"
-#include "intel_uncore_trace.h"
 
 struct intel_mmio_funcs {
 	u32 (*read)(struct intel_display *display, intel_reg_t reg);
@@ -17,11 +15,6 @@ struct intel_mmio_funcs {
 	bool (*check_for_unclaimed_mmio)(struct intel_display *display);
 };
 
-static inline struct intel_uncore *__to_uncore(struct intel_display *display)
-{
-	return display->mmio.uncore;
-}
-
 void intel_de_init(struct intel_display *display);
 bool intel_de_unclaimed_mmio_detected(struct intel_display *display);
 bool intel_de_arm_unclaimed_mmio_detection(struct intel_display *display);
@@ -101,23 +94,8 @@ int intel_de_wait_for_clear_ms(struct intel_display *display, intel_reg_t reg,
  * therefore generally be serialised, by either the dev_priv->uncore.lock or
  * a more localised lock guarding all access to that bank of registers.
  */
-static inline u32
-intel_de_read_fw(struct intel_display *display, intel_reg_t reg)
-{
-	u32 val;
-
-	val = intel_uncore_read_fw(__to_uncore(display), reg);
-	trace_i915_reg_rw(false, reg, val, sizeof(val), true);
-
-	return val;
-}
-
-static inline void
-intel_de_write_fw(struct intel_display *display, intel_reg_t reg, u32 val)
-{
-	trace_i915_reg_rw(true, reg, val, sizeof(val), true);
-	intel_uncore_write_fw(__to_uncore(display), reg, val);
-}
+u32 intel_de_read_fw(struct intel_display *display, intel_reg_t reg);
+void intel_de_write_fw(struct intel_display *display, intel_reg_t reg, u32 val);
 
 static inline u32
 intel_de_rmw_fw(struct intel_display *display, intel_reg_t reg, u32 clear, u32 set)
-- 
2.56.0


^ permalink raw reply related	[flat|nested] 9+ messages in thread

* [PATCH 2/6] drm/i915/de: Pimp the intel_de_{read,write}_fw() docs
  2026-11-19 20:50 [PATCH 0/6] drm/i915: Make register accesses and unclaimed mmio detection lockless for TGL+ Ville Syrjala
  2026-11-19 20:50 ` [PATCH 1/6] drm/i915/de: Uninline intel_de_{read,write}_fw() Ville Syrjala
@ 2026-11-19 20:50 ` Ville Syrjala
  2026-11-19 20:50 ` [PATCH 3/6] drm/i915/de: Flatten the unclaimed mmio code Ville Syrjala
                   ` (4 subsequent siblings)
  6 siblings, 0 replies; 9+ messages in thread
From: Ville Syrjala @ 2026-11-19 20:50 UTC (permalink / raw)
  To: intel-gfx; +Cc: intel-xe, Jani Nikula

From: Ville Syrjälä <ville.syrjala@linux.intel.com>

Include a bit more guidance on when to use or not use
intel_de_{read,write}_fw(), and what the extra caveats
are.

v2: Point people at the DMC code to help them figure out
    if they need the wakelock (Jani)

Reviewed-by: Jani Nikula <jani.nikula@intel.com>
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
---
 drivers/gpu/drm/i915/display/intel_de.h | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/drivers/gpu/drm/i915/display/intel_de.h b/drivers/gpu/drm/i915/display/intel_de.h
index a6dcb91b36f2..3fe99f0c331b 100644
--- a/drivers/gpu/drm/i915/display/intel_de.h
+++ b/drivers/gpu/drm/i915/display/intel_de.h
@@ -87,12 +87,19 @@ int intel_de_wait_for_clear_ms(struct intel_display *display, intel_reg_t reg,
 			       u32 mask, unsigned int timeout_ms);
 
 /*
- * Unlocked mmio-accessors, think carefully before using these.
+ * Unlocked mmio-accessors, think carefully before using these. Generally only
+ * highly performance sensitive code should use these (eg. vblank evade critical
+ * section, or interrupt handlers).
  *
  * Certain architectures will die if the same cacheline is concurrently accessed
- * by different clients (e.g. on Ivybridge). Access to registers should
- * therefore generally be serialised, by either the dev_priv->uncore.lock or
+ * by different clients (e.g. on Ivybridge/Haswell). Access to registers should
+ * therefore generally be serialised, by either the display->mmio.lock or
  * a more localised lock guarding all access to that bank of registers.
+ *
+ * DMC wakelock will not be taken by these. It must be done manually,
+ * if needed. See intel_dmc_wl.c for which registers need the wakelock.
+ *
+ * These will also skip the mmio_debug unclaimed register detection.
  */
 u32 intel_de_read_fw(struct intel_display *display, intel_reg_t reg);
 void intel_de_write_fw(struct intel_display *display, intel_reg_t reg, u32 val);
-- 
2.56.0


^ permalink raw reply related	[flat|nested] 9+ messages in thread

* [PATCH 3/6] drm/i915/de: Flatten the unclaimed mmio code
  2026-11-19 20:50 [PATCH 0/6] drm/i915: Make register accesses and unclaimed mmio detection lockless for TGL+ Ville Syrjala
  2026-11-19 20:50 ` [PATCH 1/6] drm/i915/de: Uninline intel_de_{read,write}_fw() Ville Syrjala
  2026-11-19 20:50 ` [PATCH 2/6] drm/i915/de: Pimp the intel_de_{read,write}_fw() docs Ville Syrjala
@ 2026-11-19 20:50 ` Ville Syrjala
  2026-11-19 20:50 ` [PATCH 4/6] drm/i915/de: Make mmio_debug lockless Ville Syrjala
                   ` (3 subsequent siblings)
  6 siblings, 0 replies; 9+ messages in thread
From: Ville Syrjala @ 2026-11-19 20:50 UTC (permalink / raw)
  To: intel-gfx; +Cc: intel-xe, Jani Nikula

From: Ville Syrjälä <ville.syrjala@linux.intel.com>

The unclaimed register access code is nested a few
too many levels to my linking in places. Flatten it
all out to make it a bit nicer.

Reviewed-by: Jani Nikula <jani.nikula@intel.com>
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
---
 drivers/gpu/drm/i915/display/intel_de.c | 51 ++++++++++++++-----------
 1 file changed, 29 insertions(+), 22 deletions(-)

diff --git a/drivers/gpu/drm/i915/display/intel_de.c b/drivers/gpu/drm/i915/display/intel_de.c
index 799ca57bac65..17954963ddf9 100644
--- a/drivers/gpu/drm/i915/display/intel_de.c
+++ b/drivers/gpu/drm/i915/display/intel_de.c
@@ -250,11 +250,13 @@ static void check_unclaimed_mmio_pre(struct intel_display *display,
 	if (!display->params.mmio_debug)
 		return;
 
-	if (display->mmio.funcs->check_for_unclaimed_mmio(display))
-		drm_dbg_kms(display->drm,
-			    "Unclaimed access detected before %s register 0x%x\n",
-			    write ? "write to" : "read from",
-			    intel_reg_offset(reg));
+	if (!display->mmio.funcs->check_for_unclaimed_mmio(display))
+		return;
+
+	drm_dbg_kms(display->drm,
+		    "Unclaimed access detected before %s register 0x%x\n",
+		    write ? "write to" : "read from",
+		    intel_reg_offset(reg));
 }
 
 static void check_unclaimed_mmio_post(struct intel_display *display,
@@ -265,13 +267,16 @@ static void check_unclaimed_mmio_post(struct intel_display *display,
 	if (!display->params.mmio_debug)
 		return;
 
-	if (drm_WARN(display->drm,
-		     display->mmio.funcs->check_for_unclaimed_mmio(display),
-		     "Unclaimed %s register 0x%x\n",
-		     write ? "write to" : "read from",
-		     intel_reg_offset(reg)))
-		/* Only report the first N failures */
-		display->params.mmio_debug--;
+	if (!display->mmio.funcs->check_for_unclaimed_mmio(display))
+		return;
+
+	drm_WARN(display->drm, true,
+		 "Unclaimed %s register 0x%x\n",
+		 write ? "write to" : "read from",
+		 intel_reg_offset(reg));
+
+	/* Only report the first N failures */
+	display->params.mmio_debug--;
 }
 
 bool intel_de_unclaimed_mmio_detected(struct intel_display *display)
@@ -300,18 +305,20 @@ bool intel_de_arm_unclaimed_mmio_detection(struct intel_display *display)
 	if (display->mmio.unclaimed_mmio_check <= 0)
 		goto out;
 
-	if (display->mmio.funcs->check_for_unclaimed_mmio(display)) {
-		if (!display->params.mmio_debug) {
-			drm_dbg_kms(display->drm,
-				    "Unclaimed register detected, "
-				    "enabling oneshot unclaimed register reporting. "
-				    "Please use i915.mmio_debug=N for more information.\n");
-			display->params.mmio_debug++;
-		}
-		display->mmio.unclaimed_mmio_check--;
-		ret = true;
+	if (!display->mmio.funcs->check_for_unclaimed_mmio(display))
+		goto out;
+
+	if (!display->params.mmio_debug) {
+		drm_dbg_kms(display->drm,
+			    "Unclaimed register detected, "
+			    "enabling oneshot unclaimed register reporting. "
+			    "Please use i915.mmio_debug=N for more information.\n");
+		display->params.mmio_debug++;
 	}
 
+	display->mmio.unclaimed_mmio_check--;
+	ret = true;
+
 out:
 	spin_unlock_irq(&display->mmio.lock);
 
-- 
2.56.0


^ permalink raw reply related	[flat|nested] 9+ messages in thread

* [PATCH 4/6] drm/i915/de: Make mmio_debug lockless
  2026-11-19 20:50 [PATCH 0/6] drm/i915: Make register accesses and unclaimed mmio detection lockless for TGL+ Ville Syrjala
                   ` (2 preceding siblings ...)
  2026-11-19 20:50 ` [PATCH 3/6] drm/i915/de: Flatten the unclaimed mmio code Ville Syrjala
@ 2026-11-19 20:50 ` Ville Syrjala
  2026-11-19 20:57   ` sashiko-bot
  2026-11-19 20:50 ` [PATCH 5/6] drm/i915/de: Optimize the mmio_debug checks in intel_de_{read, write}() Ville Syrjala
                   ` (2 subsequent siblings)
  6 siblings, 1 reply; 9+ messages in thread
From: Ville Syrjala @ 2026-11-19 20:50 UTC (permalink / raw)
  To: intel-gfx; +Cc: intel-xe, Jani Nikula

From: Ville Syrjälä <ville.syrjala@linux.intel.com>

Currently we protect the mmio_debug state using mmio.lock.
We can't just drop the locks or we risk the read-modify-writes
to the modparam to get out of whack. But if we get rid of the
read-modify-writes and just switch to simple booleans all
we need are loads and stores which are naturally atomic.

This is of course racy, but quite harmlessly so. Perhaps the
worst thing that can happen is that we mistake which register
caused the unclaimed access, but that can already happen since
we use the completely lockless intel_de_{read,write}_fw() in
many places. And a pair of threads getting a bit confused
about the state of the booleans should also be harmless. Perhaps
we end up doing a few extra unclaimed mmio debug checks while the
first thread is already about to disable the thing. No big deal.

And for good measure, let's annotate the booleans with
READ_ONCE()/WRITE_ONCE() to highlight the lockless nature,
though I don't think we need those for correctness.

With the booleans we do lose the capability to set mmio_debug
to a specific value, and then automagically disable it once
that many unclaimed register accesses have been detected.
With the boolean it's mmio_debug all the time or none of
the time. Not sure if anyone actually used that feature
anyway, so doesn't seem like a big loss to me.

I do want to preserve the oneshot detection thing automagically
armed by intel_de_arm_unclaimed_mmio_detection(). So we need a
second boolean for that.

And the third boolean will be mmio.unclaimed_mmio_check. That
was already effectively a boolean, but still being adjusted
with rmw.

The FPGA_DBG/CLAIM_ER accesses done from the read/write vfuncs
will still be conditionally protected by the mmio.lock, based
on mmio_flags. But the accesses from intel_de_unclaimed_mmio_detected()
and intel_de_arm_unclaimed_mmio_detection() need another
solution. For that I'm just adding another boolean into the
mmio funcs that tells us whether the lock should be taken
there or not. Calls to these functions are exceedingly rare
so no need to come up with any clever solution here.

Note that for compatibility reasons we'll actually keep the
modparam type unchanged as an int, and just treat it like a
boolean. With a real boolean type the kernel would only accept
numerical values of 0 and 1, and otherwise refuse to load the
module. We can safely change type to a real boolean when we
eventually move the modparam over to the display module. At
that point the modparam will no longer exist for i915, and
the kernel will ignore any unknown modparam and simply load
the module anyway.

v2: Keep the modparam as int, but treat it as a boolean (Jani)
    Document the booleans (Jani)

Reviewed-by: Jani Nikula <jani.nikula@intel.com>
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
---
 drivers/gpu/drm/i915/display/intel_de.c       | 58 +++++++++----------
 drivers/gpu/drm/i915/display/intel_de.h       |  1 +
 .../gpu/drm/i915/display/intel_display_core.h | 16 +++--
 .../drm/i915/display/intel_display_params.c   |  2 +-
 4 files changed, 40 insertions(+), 37 deletions(-)

diff --git a/drivers/gpu/drm/i915/display/intel_de.c b/drivers/gpu/drm/i915/display/intel_de.c
index 17954963ddf9..82ed1c6a55c9 100644
--- a/drivers/gpu/drm/i915/display/intel_de.c
+++ b/drivers/gpu/drm/i915/display/intel_de.c
@@ -242,12 +242,16 @@ static bool vlv_check_for_unclaimed_mmio(struct intel_display *display)
 	return true;
 }
 
+static bool mmio_debug_is_enabled(struct intel_display *display)
+{
+	return !!READ_ONCE(display->params.mmio_debug) ||
+		READ_ONCE(display->mmio.mmio_debug_oneshot);
+}
+
 static void check_unclaimed_mmio_pre(struct intel_display *display,
 				     intel_reg_t reg, bool write)
 {
-	lockdep_assert_held(&display->mmio.lock);
-
-	if (!display->params.mmio_debug)
+	if (!mmio_debug_is_enabled(display))
 		return;
 
 	if (!display->mmio.funcs->check_for_unclaimed_mmio(display))
@@ -262,9 +266,7 @@ static void check_unclaimed_mmio_pre(struct intel_display *display,
 static void check_unclaimed_mmio_post(struct intel_display *display,
 				      intel_reg_t reg, bool write)
 {
-	lockdep_assert_held(&display->mmio.lock);
-
-	if (!display->params.mmio_debug)
+	if (!mmio_debug_is_enabled(display))
 		return;
 
 	if (!display->mmio.funcs->check_for_unclaimed_mmio(display))
@@ -275,8 +277,7 @@ static void check_unclaimed_mmio_post(struct intel_display *display,
 		 write ? "write to" : "read from",
 		 intel_reg_offset(reg));
 
-	/* Only report the first N failures */
-	display->params.mmio_debug--;
+	WRITE_ONCE(display->mmio.mmio_debug_oneshot, false);
 }
 
 bool intel_de_unclaimed_mmio_detected(struct intel_display *display)
@@ -286,43 +287,36 @@ bool intel_de_unclaimed_mmio_detected(struct intel_display *display)
 	if (!display->mmio.funcs->check_for_unclaimed_mmio)
 		return false;
 
-	spin_lock_irq(&display->mmio.lock);
-	ret = display->mmio.funcs->check_for_unclaimed_mmio(display);
-	spin_unlock_irq(&display->mmio.lock);
+	if (display->mmio.funcs->check_for_unclaimed_mmio_needs_lock) {
+		spin_lock_irq(&display->mmio.lock);
+		ret = display->mmio.funcs->check_for_unclaimed_mmio(display);
+		spin_unlock_irq(&display->mmio.lock);
+	} else {
+		ret = display->mmio.funcs->check_for_unclaimed_mmio(display);
+	}
 
 	return ret;
 }
 
 bool intel_de_arm_unclaimed_mmio_detection(struct intel_display *display)
 {
-	bool ret = false;
-
-	if (!display->mmio.funcs->check_for_unclaimed_mmio)
+	if (!READ_ONCE(display->mmio.unclaimed_mmio_check))
 		return false;
 
-	spin_lock_irq(&display->mmio.lock);
-
-	if (display->mmio.unclaimed_mmio_check <= 0)
-		goto out;
-
-	if (!display->mmio.funcs->check_for_unclaimed_mmio(display))
-		goto out;
+	if (!intel_de_unclaimed_mmio_detected(display))
+		return false;
 
-	if (!display->params.mmio_debug) {
+	if (!READ_ONCE(display->params.mmio_debug)) {
 		drm_dbg_kms(display->drm,
 			    "Unclaimed register detected, "
 			    "enabling oneshot unclaimed register reporting. "
-			    "Please use i915.mmio_debug=N for more information.\n");
-		display->params.mmio_debug++;
+			    "Please use i915.mmio_debug=Y for more information.\n");
+		WRITE_ONCE(display->mmio.mmio_debug_oneshot, true);
 	}
 
-	display->mmio.unclaimed_mmio_check--;
-	ret = true;
-
-out:
-	spin_unlock_irq(&display->mmio.lock);
+	WRITE_ONCE(display->mmio.unclaimed_mmio_check, false);
 
-	return ret;
+	return true;
 }
 
 #define __MMIO_WAKELOCK		BIT(0)
@@ -474,12 +468,14 @@ static const struct intel_mmio_funcs hsw_mmio_funcs = {
 	.read = hsw_mmio_read,
 	.write = hsw_mmio_write,
 	.check_for_unclaimed_mmio = hsw_check_for_unclaimed_mmio,
+	.check_for_unclaimed_mmio_needs_lock = true,
 };
 
 static const struct intel_mmio_funcs vlv_mmio_funcs = {
 	.read = hsw_mmio_read,
 	.write = hsw_mmio_write,
 	.check_for_unclaimed_mmio = vlv_check_for_unclaimed_mmio,
+	.check_for_unclaimed_mmio_needs_lock = true,
 };
 
 #define LNL_MMIO_FLAGS __MMIO_WAKELOCK
@@ -539,7 +535,7 @@ void intel_de_init(struct intel_display *display)
 	}
 
 	if (display->mmio.funcs->check_for_unclaimed_mmio)
-		display->mmio.unclaimed_mmio_check = 1;
+		WRITE_ONCE(display->mmio.unclaimed_mmio_check, true);
 
 	/* clear out unclaimed reg detection bit someone else left behind */
 	if (intel_de_unclaimed_mmio_detected(display))
diff --git a/drivers/gpu/drm/i915/display/intel_de.h b/drivers/gpu/drm/i915/display/intel_de.h
index 3fe99f0c331b..c21fff7be748 100644
--- a/drivers/gpu/drm/i915/display/intel_de.h
+++ b/drivers/gpu/drm/i915/display/intel_de.h
@@ -13,6 +13,7 @@ struct intel_mmio_funcs {
 	u32 (*read)(struct intel_display *display, intel_reg_t reg);
 	void (*write)(struct intel_display *display, intel_reg_t reg, u32 val);
 	bool (*check_for_unclaimed_mmio)(struct intel_display *display);
+	bool check_for_unclaimed_mmio_needs_lock;
 };
 
 void intel_de_init(struct intel_display *display);
diff --git a/drivers/gpu/drm/i915/display/intel_display_core.h b/drivers/gpu/drm/i915/display/intel_display_core.h
index d68ecc19b8a8..b422d24e21b2 100644
--- a/drivers/gpu/drm/i915/display/intel_display_core.h
+++ b/drivers/gpu/drm/i915/display/intel_display_core.h
@@ -539,17 +539,23 @@ struct intel_display {
 		 * serializes all display register accesses done
 		 * using intel_de_{read,write}(), but not those
 		 * done using intel_de_{read,write}_fw().
-		 *
-		 * The lock also protects mmio.unclaimed_mmio_check
-		 * and read-modify-write of display->params.mmio_debug.
 		 */
 		spinlock_t lock;
 
 		struct intel_uncore *uncore;
 		const struct intel_mmio_funcs *funcs;
 
-		/* protected by mmio.lock */
-		int unclaimed_mmio_check;
+		/*
+		 * Oneshot mmio_debug mode enabled if
+		 * intel_de_arm_unclaimed_mmio_detection()
+		 * detects a previous unclaimed register access.
+		 */
+		bool mmio_debug_oneshot;
+		/*
+		 * Perform intel_de_arm_unclaimed_mmio_detection()
+		 * checks at predetermined points?
+		 */
+		bool unclaimed_mmio_check;
 	} mmio;
 
 	struct {
diff --git a/drivers/gpu/drm/i915/display/intel_display_params.c b/drivers/gpu/drm/i915/display/intel_display_params.c
index ace3081461de..8c073b07daa2 100644
--- a/drivers/gpu/drm/i915/display/intel_display_params.c
+++ b/drivers/gpu/drm/i915/display/intel_display_params.c
@@ -144,7 +144,7 @@ intel_display_param_named_unsafe(enable_dmc_wl, int, 0400,
 	"Default: -1");
 
 intel_display_param_named(mmio_debug, int, 0400,
-	"Enable the MMIO debug code for the first N failures (default: off). "
+	"Enable the MMIO debug code, 0=disabled, any other value=enabled (default: off). "
 	"This may negatively affect performance.");
 
 __maybe_unused
-- 
2.56.0


^ permalink raw reply related	[flat|nested] 9+ messages in thread

* [PATCH 5/6] drm/i915/de: Optimize the mmio_debug checks in intel_de_{read, write}()
  2026-11-19 20:50 [PATCH 0/6] drm/i915: Make register accesses and unclaimed mmio detection lockless for TGL+ Ville Syrjala
                   ` (3 preceding siblings ...)
  2026-11-19 20:50 ` [PATCH 4/6] drm/i915/de: Make mmio_debug lockless Ville Syrjala
@ 2026-11-19 20:50 ` Ville Syrjala
  2026-11-19 20:50 ` [PATCH 6/6] drm/i915/de: Make display registers unlocked for TGL+ on i915 Ville Syrjala
  2026-11-20  0:09 ` ✓ i915.CI.BAT: success for drm/i915: Make register accesses and unclaimed mmio detection lockless for TGL+ Patchwork
  6 siblings, 0 replies; 9+ messages in thread
From: Ville Syrjala @ 2026-11-19 20:50 UTC (permalink / raw)
  To: intel-gfx; +Cc: intel-xe, Jani Nikula

From: Ville Syrjälä <ville.syrjala@linux.intel.com>

Currently we do the "is mmio_debug enabled?" check from
the non-inlined check_unclaimed_mmio_{pre,post}(). That means
we pay for two extra function calls for every register access
even when mmio_debug is disabled.

Inline the checks into the actual intel_de_{read,write}() to
avoid the pointless overhead. We have to hand hold the compiler
a bit (by using a bitwise OR instead of logical OR) or else
it'll emit a separate branch for each boolean.

v2: mmio_debug is still an int

Reviewed-by: Jani Nikula <jani.nikula@intel.com>
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
---
 drivers/gpu/drm/i915/display/intel_de.c | 44 ++++++++++++++-----------
 1 file changed, 24 insertions(+), 20 deletions(-)

diff --git a/drivers/gpu/drm/i915/display/intel_de.c b/drivers/gpu/drm/i915/display/intel_de.c
index 82ed1c6a55c9..ebe3789e5441 100644
--- a/drivers/gpu/drm/i915/display/intel_de.c
+++ b/drivers/gpu/drm/i915/display/intel_de.c
@@ -242,18 +242,9 @@ static bool vlv_check_for_unclaimed_mmio(struct intel_display *display)
 	return true;
 }
 
-static bool mmio_debug_is_enabled(struct intel_display *display)
-{
-	return !!READ_ONCE(display->params.mmio_debug) ||
-		READ_ONCE(display->mmio.mmio_debug_oneshot);
-}
-
 static void check_unclaimed_mmio_pre(struct intel_display *display,
 				     intel_reg_t reg, bool write)
 {
-	if (!mmio_debug_is_enabled(display))
-		return;
-
 	if (!display->mmio.funcs->check_for_unclaimed_mmio(display))
 		return;
 
@@ -266,9 +257,6 @@ static void check_unclaimed_mmio_pre(struct intel_display *display,
 static void check_unclaimed_mmio_post(struct intel_display *display,
 				      intel_reg_t reg, bool write)
 {
-	if (!mmio_debug_is_enabled(display))
-		return;
-
 	if (!display->mmio.funcs->check_for_unclaimed_mmio(display))
 		return;
 
@@ -355,19 +343,29 @@ __mmio_lock_post(struct intel_display *display, unsigned long irqflags,
 		spin_unlock_irqrestore(&display->mmio.lock, irqflags);
 }
 
+static __always_inline bool
+__mmio_debug_is_enabled(struct intel_display *display)
+{
+	/* with || gcc emits two branches for this */
+	return unlikely(!!READ_ONCE(display->params.mmio_debug) |
+			READ_ONCE(display->mmio.mmio_debug_oneshot));
+}
+
 static __always_inline void
 __mmio_unclaimed_pre(struct intel_display *display, intel_reg_t reg,
-		     const bool write, const unsigned int mmio_flags)
+		     const bool write, const bool mmio_debug_is_enabled,
+		     const unsigned int mmio_flags)
 {
-	if (mmio_flags & __MMIO_UNCLAIMED)
+	if (mmio_flags & __MMIO_UNCLAIMED && mmio_debug_is_enabled)
 		check_unclaimed_mmio_pre(display, reg, write);
 }
 
 static __always_inline void
 __mmio_unclaimed_post(struct intel_display *display, intel_reg_t reg,
-		      const bool write, const unsigned int mmio_flags)
+		      const bool write, const bool mmio_debug_is_enabled,
+		      const unsigned int mmio_flags)
 {
-	if (mmio_flags & __MMIO_UNCLAIMED)
+	if (mmio_flags & __MMIO_UNCLAIMED && mmio_debug_is_enabled)
 		check_unclaimed_mmio_post(display, reg, write);
 }
 
@@ -375,6 +373,7 @@ static __always_inline u32
 __intel_de_read(struct intel_display *display, intel_reg_t reg,
 		const unsigned int mmio_flags)
 {
+	const bool mmio_debug_is_enabled = __mmio_debug_is_enabled(display);
 	unsigned long irqflags;
 	u32 val;
 
@@ -382,11 +381,13 @@ __intel_de_read(struct intel_display *display, intel_reg_t reg,
 
 	__mmio_wakelock_pre(display, reg, mmio_flags);
 	__mmio_lock_pre(display, &irqflags, mmio_flags);
-	__mmio_unclaimed_pre(display, reg, false, mmio_flags);
+	__mmio_unclaimed_pre(display, reg, false,
+			     mmio_debug_is_enabled, mmio_flags);
 
 	val = __intel_de_read_fw(display, reg);
 
-	__mmio_unclaimed_post(display, reg, false, mmio_flags);
+	__mmio_unclaimed_post(display, reg, false,
+			      mmio_debug_is_enabled, mmio_flags);
 	__mmio_lock_post(display, irqflags, mmio_flags);
 	__mmio_wakelock_post(display, reg, mmio_flags);
 
@@ -397,17 +398,20 @@ static __always_inline void
 __intel_de_write(struct intel_display *display, intel_reg_t reg, u32 val,
 		 const unsigned int mmio_flags)
 {
+	const bool mmio_debug_is_enabled = __mmio_debug_is_enabled(display);
 	unsigned long irqflags;
 
 	assert_display_rpm_held(display);
 
 	__mmio_wakelock_pre(display, reg, mmio_flags);
 	__mmio_lock_pre(display, &irqflags, mmio_flags);
-	__mmio_unclaimed_pre(display, reg, true, mmio_flags);
+	__mmio_unclaimed_pre(display, reg, true,
+			     mmio_debug_is_enabled, mmio_flags);
 
 	__intel_de_write_fw(display, reg, val);
 
-	__mmio_unclaimed_post(display, reg, true, mmio_flags);
+	__mmio_unclaimed_post(display, reg, true,
+			      mmio_debug_is_enabled, mmio_flags);
 	__mmio_lock_post(display, irqflags, mmio_flags);
 	__mmio_wakelock_post(display, reg, mmio_flags);
 }
-- 
2.56.0


^ permalink raw reply related	[flat|nested] 9+ messages in thread

* [PATCH 6/6] drm/i915/de: Make display registers unlocked for TGL+ on i915
  2026-11-19 20:50 [PATCH 0/6] drm/i915: Make register accesses and unclaimed mmio detection lockless for TGL+ Ville Syrjala
                   ` (4 preceding siblings ...)
  2026-11-19 20:50 ` [PATCH 5/6] drm/i915/de: Optimize the mmio_debug checks in intel_de_{read, write}() Ville Syrjala
@ 2026-11-19 20:50 ` Ville Syrjala
  2026-11-20  0:09 ` ✓ i915.CI.BAT: success for drm/i915: Make register accesses and unclaimed mmio detection lockless for TGL+ Patchwork
  6 siblings, 0 replies; 9+ messages in thread
From: Ville Syrjala @ 2026-11-19 20:50 UTC (permalink / raw)
  To: intel-gfx; +Cc: intel-xe, Jani Nikula

From: Ville Syrjälä <ville.syrjala@linux.intel.com>

Now that the unclaimed register detection should survive
without the lock there should be no reason to use the lock
on most platforms.

Start by weaning TGL+ off the lock. Since some people have
been using the (lockless) xe driver on TGL/etc. it should
be fairly well established that serializing all register
accesses is not needed on these platforms.

Reviewed-by: Jani Nikula <jani.nikula@intel.com>
Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
---
 drivers/gpu/drm/i915/display/intel_de.c | 26 +++++++++++++++++++++++--
 1 file changed, 24 insertions(+), 2 deletions(-)

diff --git a/drivers/gpu/drm/i915/display/intel_de.c b/drivers/gpu/drm/i915/display/intel_de.c
index ebe3789e5441..5f7997a13764 100644
--- a/drivers/gpu/drm/i915/display/intel_de.c
+++ b/drivers/gpu/drm/i915/display/intel_de.c
@@ -482,6 +482,26 @@ static const struct intel_mmio_funcs vlv_mmio_funcs = {
 	.check_for_unclaimed_mmio_needs_lock = true,
 };
 
+#define TGL_MMIO_FLAGS __MMIO_UNCLAIMED
+
+static u32 tgl_mmio_read(struct intel_display *display, intel_reg_t reg)
+{
+	return __intel_de_read(display, reg, TGL_MMIO_FLAGS);
+}
+
+static void tgl_mmio_write(struct intel_display *display, intel_reg_t reg, u32 val)
+{
+	__intel_de_write(display, reg, val, TGL_MMIO_FLAGS);
+}
+
+#undef TGL_MMIO_FLAGS
+
+static const struct intel_mmio_funcs tgl_mmio_funcs = {
+	.read = tgl_mmio_read,
+	.write = tgl_mmio_write,
+	.check_for_unclaimed_mmio = hsw_check_for_unclaimed_mmio,
+};
+
 #define LNL_MMIO_FLAGS __MMIO_WAKELOCK
 
 static u32 lnl_mmio_read(struct intel_display *display, intel_reg_t reg)
@@ -522,8 +542,10 @@ void intel_de_init(struct intel_display *display)
 	 * rid of driver_is_i915().
 	 */
 	if (driver_is_i915()) {
-		if (DISPLAY_VER(display) >= 9 ||
-		    display->platform.broadwell || display->platform.haswell)
+		if (DISPLAY_VER(display) >= 12)
+			display->mmio.funcs = &tgl_mmio_funcs;
+		else if (DISPLAY_VER(display) >= 9 ||
+			 display->platform.broadwell || display->platform.haswell)
 			display->mmio.funcs = &hsw_mmio_funcs;
 		else if (display->platform.valleyview || display->platform.cherryview)
 			display->mmio.funcs = &vlv_mmio_funcs;
-- 
2.56.0


^ permalink raw reply related	[flat|nested] 9+ messages in thread

* Re: [PATCH 4/6] drm/i915/de: Make mmio_debug lockless
  2026-11-19 20:50 ` [PATCH 4/6] drm/i915/de: Make mmio_debug lockless Ville Syrjala
@ 2026-11-19 20:57   ` sashiko-bot
  0 siblings, 0 replies; 9+ messages in thread
From: sashiko-bot @ 2026-11-19 20:57 UTC (permalink / raw)
  To: Ville Syrjala, intel-gfx; +Cc: intel-xe

Thank you for your contribution! Sashiko AI review found 1 potential
issue to consider:
- [Low] drm/i915/de: intel_de_arm_unclaimed_mmio_detection() logs
  invalid mmio_debug=Y
--

commit 61affa910ea8da633b71cb74783032c77e14188a
Author: Ville Syrjälä <ville.syrjala@linux.intel.com>

drm/i915/de: Make mmio_debug lockless

This commit converts the unclaimed MMIO debug tracking from lock-protected
read-modify-write counters to lockless booleans, while keeping the
mmio_debug module parameter as an int for compatibility.

> diff --git a/drivers/gpu/drm/i915/display/intel_de.c b/drivers/gpu/drm/i915/display/intel_de.c
> index 17954963ddf98..82ed1c6a55c96 100644
> --- a/drivers/gpu/drm/i915/display/intel_de.c
> +++ b/drivers/gpu/drm/i915/display/intel_de.c

[ ... ]

> @@ -286,43 +287,36 @@ bool intel_de_unclaimed_mmio_detected(struct intel_display *display)
>  	if (!display->mmio.funcs->check_for_unclaimed_mmio)
>  		return false;
>  
> -	spin_lock_irq(&display->mmio.lock);
> -	ret = display->mmio.funcs->check_for_unclaimed_mmio(display);
> -	spin_unlock_irq(&display->mmio.lock);
> +	if (display->mmio.funcs->check_for_unclaimed_mmio_needs_lock) {
> +		spin_lock_irq(&display->mmio.lock);
> +		ret = display->mmio.funcs->check_for_unclaimed_mmio(display);
> +		spin_unlock_irq(&display->mmio.lock);
> +	} else {
> +		ret = display->mmio.funcs->check_for_unclaimed_mmio(display);
> +	}
>  
>  	return ret;
>  }
>  
>  bool intel_de_arm_unclaimed_mmio_detection(struct intel_display *display)
>  {
> -	bool ret = false;
> -
> -	if (!display->mmio.funcs->check_for_unclaimed_mmio)
> +	if (!READ_ONCE(display->mmio.unclaimed_mmio_check))
>  		return false;
>  
> -	spin_lock_irq(&display->mmio.lock);
> -
> -	if (display->mmio.unclaimed_mmio_check <= 0)
> -		goto out;
> -
> -	if (!display->mmio.funcs->check_for_unclaimed_mmio(display))
> -		goto out;
> +	if (!intel_de_unclaimed_mmio_detected(display))
> +		return false;
>  
> -	if (!display->params.mmio_debug) {
> +	if (!READ_ONCE(display->params.mmio_debug)) {
>  		drm_dbg_kms(display->drm,
>  			    "Unclaimed register detected, "
>  			    "enabling oneshot unclaimed register reporting. "
> -			    "Please use i915.mmio_debug=N for more information.\n");
> -		display->params.mmio_debug++;
> +			    "Please use i915.mmio_debug=Y for more information.\n");
> +		WRITE_ONCE(display->mmio.mmio_debug_oneshot, true);
>  	}

[Severity: Low]
Should this message suggest i915.mmio_debug=1 instead of i915.mmio_debug=Y?

Because mmio_debug remains an int module parameter, param_set_int() rejects
"Y" with -EINVAL and prevents the i915 module from loading when a user
passes i915.mmio_debug=Y on the command line.

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20261119205040.31935-1-ville.syrjala@linux.intel.com?part=4

^ permalink raw reply	[flat|nested] 9+ messages in thread

* ✓ i915.CI.BAT: success for drm/i915: Make register accesses and unclaimed mmio detection lockless for TGL+
  2026-11-19 20:50 [PATCH 0/6] drm/i915: Make register accesses and unclaimed mmio detection lockless for TGL+ Ville Syrjala
                   ` (5 preceding siblings ...)
  2026-11-19 20:50 ` [PATCH 6/6] drm/i915/de: Make display registers unlocked for TGL+ on i915 Ville Syrjala
@ 2026-11-20  0:09 ` Patchwork
  6 siblings, 0 replies; 9+ messages in thread
From: Patchwork @ 2026-11-20  0:09 UTC (permalink / raw)
  To: Ville Syrjala; +Cc: intel-gfx

[-- Attachment #1: Type: text/plain, Size: 5419 bytes --]

== Series Details ==

Series: drm/i915: Make register accesses and unclaimed mmio detection lockless for TGL+
URL   : https://patchwork.freedesktop.org/series/179140/
State : success

== Summary ==

CI Bug Log - changes from CI_DRM_19570 -> Patchwork_179140v1
====================================================

Summary
-------

  **SUCCESS**

  No regressions found.

  External URL: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_179140v1/index.html

Participating hosts (39 -> 39)
------------------------------

  Additional (1): bat-adls-6 
  Missing    (1): bat-dg2-13 

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

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

### IGT changes ###

#### Issues hit ####

  * igt@gem_lmem_swapping@parallel-random-engines:
    - bat-adls-6:         NOTRUN -> [SKIP][1] ([i915#4613]) +3 other tests skip
   [1]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_179140v1/bat-adls-6/igt@gem_lmem_swapping@parallel-random-engines.html

  * igt@gem_tiled_pread_basic@basic:
    - bat-adls-6:         NOTRUN -> [SKIP][2] ([i915#15656])
   [2]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_179140v1/bat-adls-6/igt@gem_tiled_pread_basic@basic.html

  * igt@intel_hwmon@hwmon-read:
    - bat-adls-6:         NOTRUN -> [SKIP][3] ([i915#7707]) +1 other test skip
   [3]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_179140v1/bat-adls-6/igt@intel_hwmon@hwmon-read.html

  * igt@kms_cursor_legacy@basic-busy-flip-before-cursor-legacy:
    - bat-adls-6:         NOTRUN -> [SKIP][4] ([i915#4103]) +1 other test skip
   [4]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_179140v1/bat-adls-6/igt@kms_cursor_legacy@basic-busy-flip-before-cursor-legacy.html

  * igt@kms_dsc@dsc-basic:
    - bat-adls-6:         NOTRUN -> [SKIP][5] ([i915#16361])
   [5]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_179140v1/bat-adls-6/igt@kms_dsc@dsc-basic.html

  * igt@kms_force_connector_basic@force-load-detect:
    - bat-adls-6:         NOTRUN -> [SKIP][6] ([i915#17452])
   [6]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_179140v1/bat-adls-6/igt@kms_force_connector_basic@force-load-detect.html

  * igt@kms_pm_backlight@basic-brightness:
    - bat-adls-6:         NOTRUN -> [SKIP][7] ([i915#5354])
   [7]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_179140v1/bat-adls-6/igt@kms_pm_backlight@basic-brightness.html

  * igt@kms_psr@psr-primary-mmap-gtt:
    - bat-adls-6:         NOTRUN -> [SKIP][8] ([i915#1072] / [i915#9732]) +3 other tests skip
   [8]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_179140v1/bat-adls-6/igt@kms_psr@psr-primary-mmap-gtt.html

  * igt@kms_setmode@basic-clone-single-crtc:
    - bat-adls-6:         NOTRUN -> [SKIP][9] ([i915#3555])
   [9]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_179140v1/bat-adls-6/igt@kms_setmode@basic-clone-single-crtc.html

  * igt@prime_vgem@basic-fence-read:
    - bat-adls-6:         NOTRUN -> [SKIP][10] ([i915#17448] / [i915#3291]) +2 other tests skip
   [10]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_179140v1/bat-adls-6/igt@prime_vgem@basic-fence-read.html

  
#### Possible fixes ####

  * igt@i915_selftest@live:
    - fi-bsw-n3050:       [ABORT][11] ([i915#17765]) -> [PASS][12] +1 other test pass
   [11]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_19570/fi-bsw-n3050/igt@i915_selftest@live.html
   [12]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_179140v1/fi-bsw-n3050/igt@i915_selftest@live.html

  * igt@kms_pm_rpm@basic-rte:
    - bat-rpls-4:         [DMESG-WARN][13] ([i915#13400]) -> [PASS][14] +1 other test pass
   [13]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_19570/bat-rpls-4/igt@kms_pm_rpm@basic-rte.html
   [14]: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_179140v1/bat-rpls-4/igt@kms_pm_rpm@basic-rte.html

  
  [i915#1072]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/1072
  [i915#13400]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/13400
  [i915#15656]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15656
  [i915#16361]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/16361
  [i915#17448]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/17448
  [i915#17452]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/17452
  [i915#17765]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/17765
  [i915#3291]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3291
  [i915#3555]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3555
  [i915#4103]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4103
  [i915#4613]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4613
  [i915#5354]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/5354
  [i915#7707]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/7707
  [i915#9732]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9732


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

  * Linux: CI_DRM_19570 -> Patchwork_179140v1

  CI-20190529: 20190529
  CI_DRM_19570: 5e1f7086abf6664123216020e4afb75a2512292e @ git://anongit.freedesktop.org/gfx-ci/linux
  IGT_9199: f28241ac1ad57574315e7bd31b174294cca2f29c @ https://gitlab.freedesktop.org/drm/igt-gpu-tools.git
  Patchwork_179140v1: 5e1f7086abf6664123216020e4afb75a2512292e @ git://anongit.freedesktop.org/gfx-ci/linux

== Logs ==

For more details see: https://intel-gfx-ci.01.org/tree/drm-tip/Patchwork_179140v1/index.html

[-- Attachment #2: Type: text/html, Size: 6313 bytes --]

^ permalink raw reply	[flat|nested] 9+ messages in thread

end of thread, other threads:[~2026-11-20  0:09 UTC | newest]

Thread overview: 9+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2026-11-19 20:50 [PATCH 0/6] drm/i915: Make register accesses and unclaimed mmio detection lockless for TGL+ Ville Syrjala
2026-11-19 20:50 ` [PATCH 1/6] drm/i915/de: Uninline intel_de_{read,write}_fw() Ville Syrjala
2026-11-19 20:50 ` [PATCH 2/6] drm/i915/de: Pimp the intel_de_{read,write}_fw() docs Ville Syrjala
2026-11-19 20:50 ` [PATCH 3/6] drm/i915/de: Flatten the unclaimed mmio code Ville Syrjala
2026-11-19 20:50 ` [PATCH 4/6] drm/i915/de: Make mmio_debug lockless Ville Syrjala
2026-11-19 20:57   ` sashiko-bot
2026-11-19 20:50 ` [PATCH 5/6] drm/i915/de: Optimize the mmio_debug checks in intel_de_{read, write}() Ville Syrjala
2026-11-19 20:50 ` [PATCH 6/6] drm/i915/de: Make display registers unlocked for TGL+ on i915 Ville Syrjala
2026-11-20  0:09 ` ✓ i915.CI.BAT: success for drm/i915: Make register accesses and unclaimed mmio detection lockless for TGL+ Patchwork

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox