Skip to contentSkip to conversation

GEN-9 Arbitrated Bandwidth WM WA's & IPC

PATCH Superseded Mahesh Kumar 4 participants 19 messages Nov 24, 2016 – Dec 1, 2016

Subsystems (2)

v5 of 7 Superseded Latest is v7 →

lore
Share & tools
lore
#0 lore raw

v5 cover GEN-9 Arbitrated Bandwidth WM WA's & IPC

This series implements following set of functionality
Implement IPC WA's for Broxton/KBL
Enable IPC in supported platforms
Convert WM calculation to fixed point calculation Calculation of System memory Bandwidth for SKL/KBL/BXT Implementation of Arbitrated memory Bandwidth related WM WA's

Mahesh Kumar (8):
drm/i915/skl: Add variables to check x_tile and y_tile drm/i915/bxt: IPC WA for Broxton
drm/i915/kbl: IPC workaround for kabylake drm/i915/bxt: Enable IPC support
drm/i915/skl+: change WM calc to fixed point 16.16 drm/i915: Add intel_atomic_get_existing_crtc_state function drm/i915: Decode system memory bandwidth drm/i915/gen9: WM memory bandwidth related workaround

 drivers/gpu/drm/i915/i915_drv.c  | 175 ++++++++++++++++++++++++++
 drivers/gpu/drm/i915/i915_drv.h  | 107 ++++++++++++++++
 drivers/gpu/drm/i915/i915_reg.h  |  38 ++++++
 drivers/gpu/drm/i915/intel_drv.h |  15 +++
 drivers/gpu/drm/i915/intel_pm.c  | 265 ++++++++++++++++++++++++++++++++-------
 5 files changed, 553 insertions(+), 47 deletions(-)
Signature · 6 lines
2.10.1

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

PATCH v6 1/8 drm/i915/skl: Add variables to check x_tile and y_tile

This patch adds variable to check for X_tiled & y_tiled planes, instead of always checking against framebuffer-modifiers.

Changes:
- Created separate patch as per Paulo's comment
- Added x_tiled variable as well
Changes since V2:
- Incorporate Paulo's comments
- Rebase

---
 drivers/gpu/drm/i915/intel_pm.c | 22 ++++++++++++----------
 1 file changed, 12 insertions(+), 10 deletions(-)
drivers/gpu/drm/i915/intel_pm.c +12 -10
index e54708d..8908736 100644
@@ -3592,13 +3592,18 @@ static int skl_compute_plane_wm(const struct drm_i915_private *dev_priv,
 	struct intel_atomic_state *state =
 		to_intel_atomic_state(cstate->base.state);
 	bool apply_memory_bw_wa = skl_needs_memory_bw_wa(state);
+	bool y_tiled, x_tiled;
 
 	if (latency == 0 || !cstate->base.active || !intel_pstate->base.visible) {
 		*enabled = false;
 		return 0;
 	}
 
-	if (apply_memory_bw_wa && fb->modifier == I915_FORMAT_MOD_X_TILED)
+	y_tiled = fb->modifier == I915_FORMAT_MOD_Y_TILED ||
+				fb->modifier == I915_FORMAT_MOD_Yf_TILED;
+	x_tiled = fb->modifier == I915_FORMAT_MOD_X_TILED;
+
+	if (apply_memory_bw_wa && x_tiled)
 		latency += 15;
 
 	width = drm_rect_width(&intel_pstate->base.src) >> 16;
@@ -3637,16 +3642,15 @@ static int skl_compute_plane_wm(const struct drm_i915_private *dev_priv,
 		y_min_scanlines *= 2;
 
 	plane_bytes_per_line = width * cpp;
-	if (fb->modifier == I915_FORMAT_MOD_Y_TILED ||
-	    fb->modifier == I915_FORMAT_MOD_Yf_TILED) {
+	if (y_tiled) {
 		plane_blocks_per_line =
 		      DIV_ROUND_UP(plane_bytes_per_line * y_min_scanlines, 512);
 		plane_blocks_per_line /= y_min_scanlines;
-	} else if (fb->modifier == DRM_FORMAT_MOD_NONE) {
+	} else if (x_tiled) {
+		plane_blocks_per_line = DIV_ROUND_UP(plane_bytes_per_line, 512);
+	} else {
 		plane_blocks_per_line = DIV_ROUND_UP(plane_bytes_per_line, 512)
 					+ 1;
-	} else {
-		plane_blocks_per_line = DIV_ROUND_UP(plane_bytes_per_line, 512);
 	}
 
 	method1 = skl_wm_method1(plane_pixel_rate, cpp, latency);
@@ -3657,8 +3661,7 @@ static int skl_compute_plane_wm(const struct drm_i915_private *dev_priv,
 
 	y_tile_minimum = plane_blocks_per_line * y_min_scanlines;
 
-	if (fb->modifier == I915_FORMAT_MOD_Y_TILED ||
-	    fb->modifier == I915_FORMAT_MOD_Yf_TILED) {
+	if (y_tiled) {
 		selected_result = max(method2, y_tile_minimum);
 	} else {
 		if ((cpp * cstate->base.adjusted_mode.crtc_htotal / 512 < 1) &&
@@ -3674,8 +3677,7 @@ static int skl_compute_plane_wm(const struct drm_i915_private *dev_priv,
 	res_lines = DIV_ROUND_UP(selected_result, plane_blocks_per_line);
 
 	if (level >= 1 && level <= 7) {
-		if (fb->modifier == I915_FORMAT_MOD_Y_TILED ||
-		    fb->modifier == I915_FORMAT_MOD_Yf_TILED) {
+		if (y_tiled) {
 			res_blocks += y_tile_minimum;
 			res_lines += y_min_scanlines;
 		} else {
Signature · 6 lines
2.10.1

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

PATCH v6 2/8 drm/i915/bxt: IPC WA for Broxton

In reply to Mahesh Kumar

If IPC is enabled in BXT, display underruns are observed.
WA: The Line Time programmed in the WM_LINETIME register should be half of the actual calculated Line Time.

Programmed Line Time = 1/2*Calculated Line Time

---
 drivers/gpu/drm/i915/i915_drv.c |  2 ++
 drivers/gpu/drm/i915/i915_drv.h |  2 ++
 drivers/gpu/drm/i915/intel_pm.c | 11 +++++++++--
 3 files changed, 13 insertions(+), 2 deletions(-)
drivers/gpu/drm/i915/i915_drv.c +2 -0
index 445fec9..1b0a589 100644
@@ -1243,6 +1243,8 @@ int i915_driver_load(struct pci_dev *pdev, const struct pci_device_id *ent)
 
 	intel_runtime_pm_enable(dev_priv);
 
+	dev_priv->ipc_enabled = false;
+
 	/* Everything is in place, we can now relax! */
 	DRM_INFO("Initialized %s %d.%d.%d %s for %s on minor %d\n",
 		 driver.name, driver.major, driver.minor, driver.patchlevel,
drivers/gpu/drm/i915/i915_drv.h +2 -0
index 63c0ea0..6691a4e 100644
@@ -2128,6 +2128,8 @@ struct drm_i915_private {
 	/* perform PHY state sanity checks? */
 	bool chv_phy_assert[2];
 
+	bool ipc_enabled;
+
 	/* Used to save the pipe-to-encoder mapping for audio */
 	struct intel_encoder *av_enc_map[I915_MAX_PIPES];
 
drivers/gpu/drm/i915/intel_pm.c +9 -2
index 8908736..7090a7c 100644
@@ -3769,7 +3769,10 @@ skl_compute_wm_level(const struct drm_i915_private *dev_priv,
 static uint32_t
 skl_compute_linetime_wm(struct intel_crtc_state *cstate)
 {
+	struct drm_atomic_state *state = cstate->base.state;
+	struct drm_i915_private *dev_priv = to_i915(state->dev);
 	uint32_t pixel_rate;
+	uint32_t linetime_wm;
 
 	if (!cstate->base.active)
 		return 0;
@@ -3779,8 +3782,12 @@ skl_compute_linetime_wm(struct intel_crtc_state *cstate)
 	if (WARN_ON(pixel_rate == 0))
 		return 0;
 
-	return DIV_ROUND_UP(8 * cstate->base.adjusted_mode.crtc_htotal * 1000,
-			    pixel_rate);
+	linetime_wm = DIV_ROUND_UP(8 * cstate->base.adjusted_mode.crtc_htotal *
+						1000, pixel_rate);
+	if (IS_BROXTON(dev_priv) && dev_priv->ipc_enabled)
+		linetime_wm = DIV_ROUND_UP(linetime_wm, 2);
+
+	return linetime_wm;
 }
 
 static void skl_compute_transition_wm(struct intel_crtc_state *cstate,
Signature · 6 lines
2.10.1

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

Re: [PATCH v6 2/8] drm/i915/bxt: IPC WA for Broxton

Mahesh Kumar schreef op do 24-11-2016 om 09:31 [+0530]:

Quoted 71 lines

If IPC is enabled in BXT, display underruns are observed.
WA: The Line Time programmed in the WM_LINETIME register should be half of the actual calculated Line Time.

Programmed Line Time = 1/2*Calculated Line Time

---

 drivers/gpu/drm/i915/i915_drv.c |  2 ++
 drivers/gpu/drm/i915/i915_drv.h |  2 ++
 drivers/gpu/drm/i915/intel_pm.c | 11 +++++++++--
 3 files changed, 13 insertions(+), 2 deletions(-)
drivers/gpu/drm/i915/i915_drv.c +0 -0
index 445fec9..1b0a589 100644
@@ -1243,6 +1243,8 @@ int i915_driver_load(struct pci_dev *pdev,
 const struct pci_device_id *ent)


  intel_runtime_pm_enable(dev_priv);

drivers/gpu/drm/i915/i915_drv.c +2 -0
+	dev_priv->ipc_enabled = false;
+

  /* Everything is in place, we can now relax! */ DRM_INFO("Initialized %s %d.%d.%d %s for %s on minor %d\n", driver.name, driver.major, driver.minor, driver.patchlevel,

drivers/gpu/drm/i915/i915_drv.h +0 -0
index 63c0ea0..6691a4e 100644
@@ -2128,6 +2128,8 @@ struct drm_i915_private {
  	/* perform PHY state sanity checks? */
  	bool chv_phy_assert[2];

drivers/gpu/drm/i915/i915_drv.h +2 -0
+	bool ipc_enabled;
+

  /* Used to save the pipe-to-encoder mapping for audio */ struct intel_encoder *av_enc_map[I915_MAX_PIPES];

drivers/gpu/drm/i915/intel_pm.c +0 -0
index 8908736..7090a7c 100644
@@ -3769,7 +3769,10 @@ skl_compute_wm_level(const struct
 drm_i915_private *dev_priv,

 static uint32_t
 skl_compute_linetime_wm(struct intel_crtc_state *cstate) {

drivers/gpu/drm/i915/intel_pm.c +2 -0
+	struct drm_atomic_state *state = cstate->base.state;
+	struct drm_i915_private *dev_priv = to_i915(state->dev);

  uint32_t pixel_rate;

drivers/gpu/drm/i915/intel_pm.c +1 -0
+	uint32_t linetime_wm;


  if (!cstate->base.active)
  return 0;

drivers/gpu/drm/i915/intel_pm.c +0 -0
@@ -3779,8 +3782,12 @@ skl_compute_linetime_wm(struct
 intel_crtc_state *cstate)
  	if (WARN_ON(pixel_rate == 0))
  		return 0;

drivers/gpu/drm/i915/intel_pm.c +0 -1
-	return DIV_ROUND_UP(8 * cstate-
Quoted 1 line

base.adjusted_mode.crtc_htotal * 1000,

drivers/gpu/drm/i915/intel_pm.c +1 -1
-			    pixel_rate);
+	linetime_wm = DIV_ROUND_UP(8 * cstate-
Quoted 1 line

base.adjusted_mode.crtc_htotal *

drivers/gpu/drm/i915/intel_pm.c skl_compute_linetime_wm(struct intel_crtc_state *cstate) · line 3788

Quoted 3 lines
drivers/gpu/drm/i915/intel_pm.c +3 -0
+						1000, pixel_rate);
+	if (IS_BROXTON(dev_priv) && dev_priv->ipc_enabled)
+		linetime_wm = DIV_ROUND_UP(linetime_wm, 2);

I've asked on irc to be sure, but this needs slightly more info in the code as well. Same for 3/8 and 8/8.

12:47 < mlankhorst> danvet: if we add hw workarounds that don't have a name, do we still have to write comments about them in the code? 12:48 < danvet> at least a bspec reference
12:48 < danvet> some hint to make it possible to find where it's from 12:49 < danvet> e.g. mesa has traditionally just pasted the entire bspec paragraph
12:49 < mlankhorst> ok
12:49 < danvet> we've done that too in the past, but then the wa db mostly made that redundant
12:49 < danvet> but if there's no wa entry, then full deal 12:49 < danvet> also, maybe a bspec bug notice to pls add one 12:49 < danvet> you should be able to do that over the web, and afaik there should be one for every w/a
---------------------------------------------------------------------
Intel International B.V.
Registered in The Netherlands under number 34098535 Statutory seat: Haarlemmermeer
Registered address: Capronilaan 37, 1119NG Schiphol-Rijk

This e-mail and any attachments may contain confidential material for the sole use of the intended recipient(s). Any review or distribution by others is strictly prohibited. If you are not the intended recipient, please contact the sender and delete all copies.
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

#4 lore raw

Re: [PATCH v6 2/8] drm/i915/bxt: IPC WA for Broxton

Hi,

Will keep WA number in commit message/WA location. thanks,

Regards,

-Mahesh

Quoted 78 lines · Maarten

Mahesh Kumar schreef op do 24-11-2016 om 09:31 [+0530]:

Quoted 71 lines

If IPC is enabled in BXT, display underruns are observed.
WA: The Line Time programmed in the WM_LINETIME register should be half of the actual calculated Line Time.

Programmed Line Time = 1/2*Calculated Line Time

---
  drivers/gpu/drm/i915/i915_drv.c |  2 ++
  drivers/gpu/drm/i915/i915_drv.h |  2 ++
  drivers/gpu/drm/i915/intel_pm.c | 11 +++++++++--
  3 files changed, 13 insertions(+), 2 deletions(-)
drivers/gpu/drm/i915/i915_drv.c +2 -0
index 445fec9..1b0a589 100644
@@ -1243,6 +1243,8 @@ int i915_driver_load(struct pci_dev *pdev,
 const struct pci_device_id *ent)
 
  	intel_runtime_pm_enable(dev_priv);
 
+	dev_priv->ipc_enabled = false;
+
  	/* Everything is in place, we can now relax! */
  	DRM_INFO("Initialized %s %d.%d.%d %s for %s on minor %d\n",

driver.name, driver.major, driver.minor,
driver.patchlevel,

drivers/gpu/drm/i915/i915_drv.h +2 -0
index 63c0ea0..6691a4e 100644
@@ -2128,6 +2128,8 @@ struct drm_i915_private {
  	/* perform PHY state sanity checks? */
  	bool chv_phy_assert[2];
 
+	bool ipc_enabled;
+
  	/* Used to save the pipe-to-encoder mapping for audio */
  	struct intel_encoder *av_enc_map[I915_MAX_PIPES];
 
drivers/gpu/drm/i915/intel_pm.c +3 -0
index 8908736..7090a7c 100644
@@ -3769,7 +3769,10 @@ skl_compute_wm_level(const struct
 drm_i915_private *dev_priv,
  static uint32_t
  skl_compute_linetime_wm(struct intel_crtc_state *cstate)
  {
+	struct drm_atomic_state *state = cstate->base.state;
+	struct drm_i915_private *dev_priv = to_i915(state->dev);
  	uint32_t pixel_rate;
+	uint32_t linetime_wm;
 
  	if (!cstate->base.active)

return 0;

drivers/gpu/drm/i915/intel_pm.c +1 -2
@@ -3779,8 +3782,12 @@ skl_compute_linetime_wm(struct
 intel_crtc_state *cstate)
  	if (WARN_ON(pixel_rate == 0))
  		return 0;
 
-	return DIV_ROUND_UP(8 * cstate-
 > base.adjusted_mode.crtc_htotal * 1000,
-			    pixel_rate);
+	linetime_wm = DIV_ROUND_UP(8 * cstate-
Quoted 1 line

base.adjusted_mode.crtc_htotal *

drivers/gpu/drm/i915/intel_pm.c skl_compute_linetime_wm(struct intel_crtc_state *cstate) · line 3788

Quoted 3 lines
drivers/gpu/drm/i915/intel_pm.c +3 -0
+						1000, pixel_rate);
+	if (IS_BROXTON(dev_priv) && dev_priv->ipc_enabled)
+		linetime_wm = DIV_ROUND_UP(linetime_wm, 2);

I've asked on irc to be sure, but this needs slightly more info in the code as well. Same for 3/8 and 8/8.

Quoted 13 lines

12:47 < mlankhorst> danvet: if we add hw workarounds that don't have a name, do we still have to write comments about them in the code? 12:48 < danvet> at least a bspec reference
12:48 < danvet> some hint to make it possible to find where it's from 12:49 < danvet> e.g. mesa has traditionally just pasted the entire bspec paragraph
12:49 < mlankhorst> ok
12:49 < danvet> we've done that too in the past, but then the wa db mostly made that redundant
12:49 < danvet> but if there's no wa entry, then full deal 12:49 < danvet> also, maybe a bspec bug notice to pls add one 12:49 < danvet> you should be able to do that over the web, and afaik there should be one for every w/a

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

#5 lore raw

Re: [PATCH v6 2/8] drm/i915/bxt: IPC WA for Broxton

Hey,

Mahesh Kumar schreef op ma 28-11-2016 om 18:37 [+0530]:

Quoted 4 lines

Hi,

Will keep WA number in commit message/WA location. thanks,

Sounds good, with that fixed patches 1-5 and 7 look good to me. I think patch 6 will no longer be required since the workaround status will also be kept inside intel_state.

~Maarten
---------------------------------------------------------------------
Intel International B.V.
Registered in The Netherlands under number 34098535 Statutory seat: Haarlemmermeer
Registered address: Capronilaan 37, 1119NG Schiphol-Rijk

This e-mail and any attachments may contain confidential material for the sole use of the intended recipient(s). Any review or distribution by others is strictly prohibited. If you are not the intended recipient, please contact the sender and delete all copies.
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

#6 lore raw

PATCH v6 3/8 drm/i915/kbl: IPC workaround for kabylake

In reply to Mahesh Kumar

IPC (Isoch Priority Control) may cause underflows.

KBL WA: When IPC is enabled, watermark latency values must be increased by 4us across all levels. This brings level 0 up to 6us.

---
 drivers/gpu/drm/i915/intel_pm.c | 4 ++++
 1 file changed, 4 insertions(+)
drivers/gpu/drm/i915/intel_pm.c +4 -0
index 7090a7c..33d22cc 100644
@@ -3603,6 +3603,10 @@ static int skl_compute_plane_wm(const struct drm_i915_private *dev_priv,
 				fb->modifier == I915_FORMAT_MOD_Yf_TILED;
 	x_tiled = fb->modifier == I915_FORMAT_MOD_X_TILED;
 
+	/* IPC WA for kabylake */
+	if (IS_KABYLAKE(dev_priv) && dev_priv->ipc_enabled)
+		latency += 4;
+
 	if (apply_memory_bw_wa && x_tiled)
 		latency += 15;
 
Signature · 6 lines
2.10.1

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

PATCH v6 4/8 drm/i915/bxt: Enable IPC support

In reply to Mahesh Kumar

This patch adds IPC support for platforms. This patch enables IPC only for BXT/KBL platform as for SKL recommendation is to keep is disabled. IPC (Isochronous Priority Control) is the hardware feature, which dynamically controles the memory read priority of Display.

When IPC is enabled, plane read requests are sent at high priority until filling above the transition watermark, then the requests are sent at lower priority until dropping below the level 0 watermark. The lower priority requests allow other memory clients to have better memory access. When IPC is disabled, all plane read requests are sent at high priority.

Changes since V1:
- Remove commandline parameter to disable ipc
- Address Paulo's comments
Changes since V2:
- Address review comments
- Set ipc_enabled flag
Changes since V3:
- move ipc_enabled flag assignment inside intel_ipc_enable function

---
 drivers/gpu/drm/i915/i915_drv.c  |  2 +-
 drivers/gpu/drm/i915/i915_reg.h  |  1 +
 drivers/gpu/drm/i915/intel_drv.h |  1 +
 drivers/gpu/drm/i915/intel_pm.c  | 16 ++++++++++++++++
 4 files changed, 19 insertions(+), 1 deletion(-)
drivers/gpu/drm/i915/i915_drv.c +1 -1
index 1b0a589..b83e84b 100644
@@ -1243,7 +1243,7 @@ int i915_driver_load(struct pci_dev *pdev, const struct pci_device_id *ent)
 
 	intel_runtime_pm_enable(dev_priv);
 
-	dev_priv->ipc_enabled = false;
+	intel_enable_ipc(dev_priv);
 
 	/* Everything is in place, we can now relax! */
 	DRM_INFO("Initialized %s %d.%d.%d %s for %s on minor %d\n",
drivers/gpu/drm/i915/i915_reg.h +1 -0
index c70c07a..300418a 100644
@@ -6076,6 +6076,7 @@ enum {
 #define  DISP_FBC_WM_DIS		(1<<15)
 #define DISP_ARB_CTL2	_MMIO(0x45004)
 #define  DISP_DATA_PARTITION_5_6	(1<<6)
+#define  DISP_IPC_ENABLE		(1<<3)
 #define DBUF_CTL	_MMIO(0x45008)
 #define  DBUF_POWER_REQUEST		(1<<31)
 #define  DBUF_POWER_STATE		(1<<30)
drivers/gpu/drm/i915/intel_drv.h +1 -0
index cd132c2..ad542a2 100644
@@ -1745,6 +1745,7 @@ bool skl_ddb_allocation_overlaps(const struct skl_ddb_entry **entries,
 uint32_t ilk_pipe_pixel_rate(const struct intel_crtc_state *pipe_config);
 bool ilk_disable_lp_wm(struct drm_device *dev);
 int sanitize_rc6_option(struct drm_i915_private *dev_priv, int enable_rc6);
+void intel_enable_ipc(struct drm_i915_private *dev_priv);
 static inline int intel_enable_rc6(void)
 {
 	return i915.enable_rc6;
drivers/gpu/drm/i915/intel_pm.c +16 -0
index 33d22cc..df6d231 100644
@@ -4682,6 +4682,22 @@ void intel_update_watermarks(struct intel_crtc *crtc)
 		dev_priv->display.update_wm(crtc);
 }
 
+void intel_enable_ipc(struct drm_i915_private *dev_priv)
+{
+	u32 val;
+
+	dev_priv->ipc_enabled = false;
+	if (!(IS_BROXTON(dev_priv) || IS_KABYLAKE(dev_priv)))
+		return;
+
+	val = I915_READ(DISP_ARB_CTL2);
+
+	val |= DISP_IPC_ENABLE;
+
+	I915_WRITE(DISP_ARB_CTL2, val);
+	dev_priv->ipc_enabled = true;
+}
+
 /*
  * Lock protecting IPS related data structures
  */
Signature · 6 lines
2.10.1

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

PATCH v6 5/8 drm/i915/skl+: change WM calc to fixed point 16.16

In reply to Mahesh Kumar

This patch changes Watermak calculation to fixed point calculation. Problem with current calculation is during plane_blocks_per_line calculation we divide intermediate blocks with min_scanlines and takes floor of the result because of integer operation. hence we end-up assigning less blocks than required. Which leads to flickers.

Changes since V1:
- Add fixed point data type as per Paulo's review
Changes since V1:
- use fixed_point instead of fp_16_16

---
 drivers/gpu/drm/i915/i915_drv.h | 84 +++++++++++++++++++++++++++++++++++++++++
 drivers/gpu/drm/i915/intel_pm.c | 69 +++++++++++++++++++--------------
 2 files changed, 124 insertions(+), 29 deletions(-)
drivers/gpu/drm/i915/i915_drv.h +84 -0
index 6691a4e..e332f04 100644
@@ -119,6 +119,90 @@ bool __i915_inject_load_failure(const char *func, int line);
 #define i915_inject_load_failure() \
 	__i915_inject_load_failure(__func__, __LINE__)
 
+typedef struct {
+	uint32_t val;
+} uint_fixed_16_16_t;
+
+#define FP_16_16_MAX ({ \
+		uint_fixed_16_16_t fp; \
+		fp.val = UINT_MAX; \
+		fp; \
+})
+
+static inline uint_fixed_16_16_t u32_to_fixed_point(uint32_t val)
+{
+	uint_fixed_16_16_t fp;
+
+	WARN_ON(val >> 16);
+
+	fp.val = val << 16;
+	return fp;
+}
+
+static inline uint32_t fixed_point_to_u32_round_up(uint_fixed_16_16_t fp)
+{
+	return DIV_ROUND_UP(fp.val, 1 << 16);
+}
+
+static inline uint32_t fixed_point_to_u32(uint_fixed_16_16_t fp)
+{
+	return (fp.val / (1 << 16));
+}
+
+static inline uint_fixed_16_16_t min_fixed_point(uint_fixed_16_16_t min1,
+					uint_fixed_16_16_t min2)
+{
+	uint_fixed_16_16_t min;
+
+	min.val = min(min1.val, min2.val);
+	return min;
+}
+
+static inline uint_fixed_16_16_t max_fixed_point(uint_fixed_16_16_t max1,
+					uint_fixed_16_16_t max2)
+{
+	uint_fixed_16_16_t max;
+
+	max.val = max(max1.val, max2.val);
+	return max;
+}
+
+static inline uint_fixed_16_16_t fixed_point_div_round_up(uint32_t val,
+					uint32_t d)
+{
+	uint_fixed_16_16_t fp, res;
+
+	fp = u32_to_fixed_point(val);
+	res.val = DIV_ROUND_UP(fp.val, d);
+	return res;
+}
+
+static inline uint_fixed_16_16_t fixed_point_div_round_up_u64(uint32_t val,
+								uint32_t d)
+{
+	uint_fixed_16_16_t res;
+	uint64_t interm_val;
+
+	interm_val = (uint64_t)val << 16;
+	interm_val = DIV_ROUND_UP_ULL(interm_val, d);
+	WARN_ON(interm_val >> 32);
+	res.val = (uint32_t) interm_val;
+
+	return res;
+}
+
+static inline uint_fixed_16_16_t mul_fixed_point_u32(uint32_t val,
+						uint_fixed_16_16_t mul)
+{
+	uint64_t intermediate_val;
+	uint_fixed_16_16_t fp;
+
+	intermediate_val = (uint64_t) val * mul.val;
+	WARN_ON(intermediate_val >> 32);
+	fp.val = (uint32_t) intermediate_val;
+	return fp;
+}
+
 static inline const char *yesno(bool v)
 {
 	return v ? "yes" : "no";
drivers/gpu/drm/i915/intel_pm.c +40 -29

126 lines not on this page · raw message

Signature · 6 lines
2.10.1

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

PATCH v6 6/8 drm/i915: Add intel_atomic_get_existing_crtc_state function

In reply to Mahesh Kumar

This patch Adds a function to extract intel_crtc_state from the atomic_state, if not available it returns NULL.

---
 drivers/gpu/drm/i915/intel_drv.h | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
drivers/gpu/drm/i915/intel_drv.h +14 -0
index ad542a2..db75773 100644
@@ -1794,6 +1794,20 @@ intel_atomic_get_crtc_state(struct drm_atomic_state *state,
 	return to_intel_crtc_state(crtc_state);
 }
 
+static inline struct intel_crtc_state *
+intel_atomic_get_existing_crtc_state(struct drm_atomic_state *state,
+				      struct intel_crtc *crtc)
+{
+	struct drm_crtc_state *crtc_state;
+
+	crtc_state = drm_atomic_get_existing_crtc_state(state, &crtc->base);
+
+	if (crtc_state)
+		return to_intel_crtc_state(crtc_state);
+	else
+		return NULL;
+}
+
 static inline struct intel_plane_state *
 intel_atomic_get_existing_plane_state(struct drm_atomic_state *state,
 				      struct intel_plane *plane)
Signature · 6 lines
2.10.1

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

PATCH v6 7/8 drm/i915: Decode system memory bandwidth

In reply to Mahesh Kumar

This patch adds support to decode system memory bandwidth which will be used for arbitrated display memory percentage calculation in GEN9 based system.

Changes from v1:
- Address comments from Paulo
- implement decode function for SKL/KBL also
Changes from v2:
- Rewrite the code as per HW team inputs
- Addresses review comments

---
 drivers/gpu/drm/i915/i915_drv.c | 173 ++++++++++++++++++++++++++++++++++++++++
 drivers/gpu/drm/i915/i915_drv.h |  12 +++
 drivers/gpu/drm/i915/i915_reg.h |  37 +++++++++
 3 files changed, 222 insertions(+)
drivers/gpu/drm/i915/i915_drv.c +173 -0
index b83e84b..ded1d05 100644
@@ -976,6 +976,173 @@ static void intel_sanitize_options(struct drm_i915_private *dev_priv)
 	DRM_DEBUG_DRIVER("use GPU sempahores? %s\n", yesno(i915.semaphores));
 }
 
+static inline enum rank skl_memdev_get_channel_rank(uint32_t val)
+{
+	uint8_t l_rank, s_rank;
+	uint8_t l_size, s_size;
+	enum rank ch_rank = DRAM_RANK_SINGLE;
+
+	l_size = (val >> SKL_DRAM_SIZE_L_SHIFT) & SKL_DRAM_SIZE_MASK;
+	s_size = (val >> SKL_DRAM_SIZE_S_SHIFT) & SKL_DRAM_SIZE_MASK;
+	l_rank = (val >> SKL_DRAM_RANK_L_SHIFT) & SKL_DRAM_RANK_MASK;
+	s_rank = (val >> SKL_DRAM_RANK_S_SHIFT) & SKL_DRAM_RANK_MASK;
+
+	/*
+	 * If any of the slot has dual rank memory consider
+	 * dual rank memory channel
+	 */
+	if (l_rank == SKL_DRAM_RANK_DUAL || s_rank == SKL_DRAM_RANK_DUAL)
+		ch_rank = DRAM_RANK_DUAL;
+
+	/*
+	 * If both the slot has single rank memory then configuration
+	 * is dual rank memory
+	 */
+	if ((l_size && l_rank == SKL_DRAM_RANK_SINGLE) &&
+		(s_size && s_rank == SKL_DRAM_RANK_SINGLE))
+		ch_rank = DRAM_RANK_DUAL;
+	return ch_rank;
+}
+
+static int
+skl_get_memdev_info(struct drm_i915_private *dev_priv)
+{
+	struct memdev_info *memdev_info = &dev_priv->memdev_info;
+	uint32_t mem_freq_khz;
+	uint32_t val;
+	enum rank ch0_rank, ch1_rank;
+
+	val = I915_READ(SKL_MC_BIOS_DATA_0_0_0_MCHBAR_PCU);
+	mem_freq_khz = (val & SKL_REQ_DATA_MASK) *
+				SKL_MEMORY_FREQ_MULTIPLIER_KHZ;
+
+	val = I915_READ(SKL_MAD_DIMM_CH0_0_0_0_MCHBAR_MCMAIN);
+	if (val != 0x0) {
+		memdev_info->num_channels++;
+		ch0_rank = skl_memdev_get_channel_rank(val);
+	}
+
+	val = I915_READ(SKL_MAD_DIMM_CH1_0_0_0_MCHBAR_MCMAIN);
+	if (val != 0x0) {
+		memdev_info->num_channels++;
+		ch1_rank = skl_memdev_get_channel_rank(val);
+	}
+
+	if (memdev_info->num_channels == 0) {
+		DRM_ERROR("Number of mem channels are zero\n");
+		return -EINVAL;
+	}
+
+	memdev_info->bandwidth_kbps = (memdev_info->num_channels *
+							mem_freq_khz * 8);
+
+	if (memdev_info->bandwidth_kbps == 0) {
+		DRM_ERROR("Couldn't get system memory bandwidth\n");
+		return -EINVAL;
+	}
+	memdev_info->valid = true;
+
+	/*
+	 * If any of channel is single rank channel,
+	 * consider single rank memory
+	 */
+	if (ch0_rank == DRAM_RANK_SINGLE || ch1_rank == DRAM_RANK_SINGLE)
+		memdev_info->rank = DRAM_RANK_SINGLE;
+	else
+		memdev_info->rank = max(ch0_rank, ch1_rank);
+
+	return 0;
+}
+
+static int
+bxt_get_memdev_info(struct drm_i915_private *dev_priv)
+{
+	struct memdev_info *memdev_info = &dev_priv->memdev_info;
+	uint32_t dram_channels;
+	uint32_t mem_freq_khz, val;
+	uint8_t num_active_channels;
+	int i;
+
+	val = I915_READ(BXT_P_CR_MC_BIOS_REQ_0_0_0);
+	mem_freq_khz = ((val & BXT_REQ_DATA_MASK) *
+				BXT_MEMORY_FREQ_MULTIPLIER_KHZ);
+
+	dram_channels = (val >> BXT_DRAM_CHANNEL_ACTIVE_SHIFT) &
+					BXT_DRAM_CHANNEL_ACTIVE_MASK;
+	num_active_channels = hweight32(dram_channels);
+
+	memdev_info->bandwidth_kbps = (mem_freq_khz * num_active_channels * 4);
+
+	if (memdev_info->bandwidth_kbps == 0) {
+		DRM_ERROR("Couldn't get system memory bandwidth\n");
+		return -EINVAL;
+	}
+	memdev_info->valid = true;
+
+	/*
+	 * Now read each DUNIT8/9/10/11 to check the rank of each dimms.
+	 */
+	for (i = 0; i < BXT_D_CR_DRP0_DUNIT_MAX; i++) {
+		val = I915_READ(BXT_D_CR_DRP0_DUNIT(i));
+		if (val != 0xFFFFFFFF) {
+			uint8_t rank;
+			enum rank ch_rank;
+
+			memdev_info->num_channels++;
+			rank = val & BXT_DRAM_RANK_MASK;
+			if (rank == BXT_DRAM_RANK_SINGLE)
+				ch_rank = DRAM_RANK_SINGLE;
+			else if (rank == BXT_DRAM_RANK_DUAL)
+				ch_rank = DRAM_RANK_DUAL;
+			else
+				ch_rank = DRAM_RANK_INVALID;
+
+			/*
+			 * If any of channel is having single rank memory
+			 * consider memory as single rank
+			 */
+			if (memdev_info->rank == DRAM_RANK_INVALID)
+				memdev_info->rank = ch_rank;
+			else if (ch_rank == DRAM_RANK_SINGLE)
+				memdev_info->rank = DRAM_RANK_SINGLE;
+		}
+	}
+	return 0;
+}
+
+static void
+intel_get_memdev_info(struct drm_i915_private *dev_priv)
+{
+	struct memdev_info *memdev_info = &dev_priv->memdev_info;
+	int ret;
+
+	memdev_info->valid = false;
+	memdev_info->rank = DRAM_RANK_INVALID;
+	memdev_info->num_channels = 0;
+
+	if (!IS_GEN9(dev_priv))
+		return;
+
+	if (IS_BROXTON(dev_priv))
+		ret = bxt_get_memdev_info(dev_priv);
+	else
+		ret = skl_get_memdev_info(dev_priv);
+	if (ret)
+		return;
+
+	DRM_DEBUG_DRIVER("DRAM bandwidth: %u KBps total-channels: %u\n",
+				memdev_info->bandwidth_kbps,
+				memdev_info->num_channels);
+	if (memdev_info->rank == DRAM_RANK_INVALID)
+		DRM_INFO("Counld not get memory rank info\n");
+	else {
+		DRM_DEBUG_DRIVER("DRAM rank: %s rank\n",
+				(memdev_info->rank == DRAM_RANK_DUAL) ?
+						"dual" : "single");
+	}
+}
+
+
 /**
  * i915_driver_init_hw - setup state requiring device access
  * @dev_priv: device private
@@ -1078,6 +1245,12 @@ static int i915_driver_init_hw(struct drm_i915_private *dev_priv)
 			DRM_DEBUG_DRIVER("can't enable MSI");
 	}
 
+	/*
+	 * Fill the memdev structure to get the system raw bandwidth
+	 * This will be used by WM algorithm, to implement GEN9 based WA
+	 */
+	intel_get_memdev_info(dev_priv);
+
 	return 0;
 
 out_ggtt:
drivers/gpu/drm/i915/i915_drv.h +12 -0
index e332f04..4e2f17f 100644
@@ -2168,6 +2168,18 @@ struct drm_i915_private {
 		bool distrust_bios_wm;
 	} wm;
 
+	struct memdev_info {
+		bool valid;
+		uint32_t bandwidth_kbps;
+		uint8_t num_channels;
+		enum rank {
+			DRAM_RANK_INVALID = 0,
+			DRAM_RANK_SINGLE,
+			DRAM_RANK_DUAL
+		} rank;
+	} memdev_info;
+
+
 	struct i915_runtime_pm pm;
 
 	/* Abstract the submission mechanism (legacy ringbuffer or execlists) away */
drivers/gpu/drm/i915/i915_reg.h +37 -0
index 300418a..9a06810 100644
@@ -7672,6 +7672,43 @@ enum {
 #define  DC_STATE_DEBUG_MASK_CORES	(1<<0)
 #define  DC_STATE_DEBUG_MASK_MEMORY_UP	(1<<1)
 
+#define BXT_P_CR_MC_BIOS_REQ_0_0_0	_MMIO(MCHBAR_MIRROR_BASE_SNB + 0x7114)
+#define BXT_REQ_DATA_MASK			0x3F
+#define BXT_DRAM_ACTIVE_CHANNEL_SHIFT		12
+#define BXT_DRAM_ACTIVE_CHANNEL_MASK		0xF
+/*
+ * BIOS programs this field of REQ_DATA [5:0] in integer
+ * multiple of 133333 KHz (133.33MHz)
+ */
+#define	BXT_MEMORY_FREQ_MULTIPLIER_KHZ		133333
+#define BXT_D_CR_DRP0_DUNIT8			0x1000
+#define BXT_D_CR_DRP0_DUNIT9			0x1200
+#define BXT_D_CR_DRP0_DUNIT_MAX			4
+#define _MMIO_MCHBAR_DUNIT(x, a, b) _MMIO(MCHBAR_MIRROR_BASE_SNB + (a) + (x)*((b)-(a)))
+#define BXT_D_CR_DRP0_DUNIT(x)	_MMIO_MCHBAR_DUNIT(x, BXT_D_CR_DRP0_DUNIT8, BXT_D_CR_DRP0_DUNIT9)
+#define BXT_DRAM_CHANNEL_ACTIVE_SHIFT		12
+#define BXT_DRAM_CHANNEL_ACTIVE_MASK		0xF
+#define BXT_DRAM_RANK_MASK			0x3
+#define BXT_DRAM_RANK_SINGLE			0x1
+#define BXT_DRAM_RANK_DUAL			0x3
+
+/*
+ * SKL memory frequeny multiplier is 266667 KHz (266.67 MHz)
+ */
+#define	SKL_MEMORY_FREQ_MULTIPLIER_KHZ		266667
+#define SKL_MC_BIOS_DATA_0_0_0_MCHBAR_PCU	_MMIO(MCHBAR_MIRROR_BASE_SNB + 0x5E04)
+#define SKL_REQ_DATA_MASK			(0xF << 0)
+#define SKL_MAD_DIMM_CH0_0_0_0_MCHBAR_MCMAIN	_MMIO(MCHBAR_MIRROR_BASE_SNB + 0x500C)
+#define SKL_MAD_DIMM_CH1_0_0_0_MCHBAR_MCMAIN	_MMIO(MCHBAR_MIRROR_BASE_SNB + 0x5010)
+#define SKL_DRAM_SIZE_MASK			0x1F
+#define SKL_DRAM_SIZE_L_SHIFT			0
+#define SKL_DRAM_SIZE_S_SHIFT			16
+#define SKL_DRAM_RANK_MASK			0x1
+#define SKL_DRAM_RANK_L_SHIFT			10
+#define SKL_DRAM_RANK_S_SHIFT			26
+#define SKL_DRAM_RANK_SINGLE			0x0
+#define SKL_DRAM_RANK_DUAL			0x1
+
 /* Please see hsw_read_dcomp() and hsw_write_dcomp() before using this register,
  * since on HSW we can't write to it using I915_WRITE. */
 #define D_COMP_HSW			_MMIO(MCHBAR_MIRROR_BASE_SNB + 0x5F0C)
Signature · 6 lines
2.10.1

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

Re: [PATCH v6 7/8] drm/i915: Decode system memory bandwidth

url: https://github.com/0day-ci/linux/commits/Mahesh-Kumar/GEN-9-Arbitrated-Bandwidth-WM-WA-s-IPC/20161124-172826 config: x86_64-randconfig-x012-201647 (attached as .config) compiler: gcc-6 (Debian…

Hi Mahesh,

[auto build test WARNING on next-20161123]
[cannot apply to drm-intel/for-linux-next v4.9-rc6 v4.9-rc5 v4.9-rc4 v4.9-rc6]
[if your patch is applied to the wrong git tree, please drop us a note to help improve the system]

url: https://github.com/0day-ci/linux/commits/Mahesh-Kumar/GEN-9-Arbitrated-Bandwidth-WM-WA-s-IPC/20161124-172826
config: x86_64-randconfig-x012-201647 (attached as .config)
compiler: gcc-6 (Debian 6.2.0-3) 6.2.0 20160901 reproduce:

        # save the attached .config to linux build tree
        make ARCH=x86_64 

Note: it may well be a FALSE warning. FWIW you are at least aware of it now.
http://gcc.gnu.org/wiki/Better_Uninitialized_Warnings

All warnings (new ones prefixed by >>):

drivers/gpu/drm/i915/i915_drv.c: In function 'i915_driver_load':

>> drivers/gpu/drm/i915/i915_drv.c:1049:47: warning: 'ch1_rank' may be used uninitialized in this function [-Wmaybe-uninitialized]
     if (ch0_rank == DRAM_RANK_SINGLE || ch1_rank == DRAM_RANK_SINGLE)
                                         ~~~~~~~~~^~~~~~~~~~~~~~~~~~~
   drivers/gpu/drm/i915/i915_drv.c:1013:22: note: 'ch1_rank' was declared here
     enum rank ch0_rank, ch1_rank;
                         ^~~~~~~~
>> drivers/gpu/drm/i915/i915_drv.c:1049:15: warning: 'ch0_rank' may be used uninitialized in this function [-Wmaybe-uninitialized]
     if (ch0_rank == DRAM_RANK_SINGLE || ch1_rank == DRAM_RANK_SINGLE)
         ~~~~~~~~~^~~~~~~~~~~~~~~~~~~
   drivers/gpu/drm/i915/i915_drv.c:1013:12: note: 'ch0_rank' was declared here
     enum rank ch0_rank, ch1_rank;
               ^~~~~~~~

vim +/ch1_rank +1049 drivers/gpu/drm/i915/i915_drv.c

1033 return -EINVAL;
1034 }
1035
1036 memdev_info->bandwidth_kbps = (memdev_info->num_channels *
1037 mem_freq_khz * 8);
1038
1039 if (memdev_info->bandwidth_kbps == 0) {
1040 DRM_ERROR("Couldn't get system memory bandwidth\n");
1041 return -EINVAL;
1042 }
1043 memdev_info->valid = true;
1044
1045 /*
1046 * If any of channel is single rank channel,
1047 * consider single rank memory
1048 */

> 1049		if (ch0_rank == DRAM_RANK_SINGLE || ch1_rank == DRAM_RANK_SINGLE)

1050 memdev_info->rank = DRAM_RANK_SINGLE;
1051 else
1052 memdev_info->rank = max(ch0_rank, ch1_rank);
1053
1054 return 0;
1055 }
1056
1057 static int

---
0-DAY kernel test infrastructure Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all Intel Corporation

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

#12 lore raw

PATCH v6 8/8 drm/i915/gen9: WM memory bandwidth related workaround

In reply to Mahesh Kumar

This patch implemnets Workariunds related to display arbitrated memory bandwidth. These WA are applicabe for all gen-9 based platforms.

Changes since v1:
- Rebase on top of Paulo's patch series
Changes since v2:
- Address review comments
- Rebase/rework as per other patch changes in series

---
 drivers/gpu/drm/i915/i915_drv.h |   9 +++
 drivers/gpu/drm/i915/intel_pm.c | 149 +++++++++++++++++++++++++++++++++++++---
 2 files changed, 149 insertions(+), 9 deletions(-)
drivers/gpu/drm/i915/i915_drv.h +9 -0
index 4e2f17f..2b673c6 100644
@@ -1193,6 +1193,13 @@ enum intel_sbi_destination {
 	SBI_MPHY,
 };
 
+/* SKL+ Watermark arbitrated display bandwidth Workarounds */
+enum watermark_memory_wa {
+	WATERMARK_WA_NONE,
+	WATERMARK_WA_X_TILED,
+	WATERMARK_WA_Y_TILED,
+};
+
 #define QUIRK_PIPEA_FORCE (1<<0)
 #define QUIRK_LVDS_SSC_DISABLE (1<<1)
 #define QUIRK_INVERT_BRIGHTNESS (1<<2)
@@ -1764,6 +1771,8 @@ struct skl_ddb_allocation {
 
 struct skl_wm_values {
 	unsigned dirty_pipes;
+	/* any WaterMark memory workaround Required */
+	enum watermark_memory_wa mem_wa;
 	struct skl_ddb_allocation ddb;
 };
 
drivers/gpu/drm/i915/intel_pm.c +140 -9

197 lines not on this page · raw message

Signature · 6 lines
2.10.1

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

Re: [PATCH v6 8/8] drm/i915/gen9: WM memory bandwidth related workaround

Mahesh Kumar schreef op do 24-11-2016 om 09:31 [+0530]:

Quoted 176 lines

This patch implemnets Workariunds related to display arbitrated memory
bandwidth. These WA are applicabe for all gen-9 based platforms.

Changes since v1:
 - Rebase on top of Paulo's patch series Changes since v2:
 - Address review comments
 - Rebase/rework as per other patch changes in series

---
 drivers/gpu/drm/i915/i915_drv.h |   9 +++
 drivers/gpu/drm/i915/intel_pm.c | 149
+++++++++++++++++++++++++++++++++++++---

 2 files changed, 149 insertions(+), 9 deletions(-)
drivers/gpu/drm/i915/i915_drv.h +0 -0
index 4e2f17f..2b673c6 100644
@@ -1193,6 +1193,13 @@ enum intel_sbi_destination {
  	SBI_MPHY,
  };

drivers/gpu/drm/i915/i915_drv.h +7 -0
+/* SKL+ Watermark arbitrated display bandwidth Workarounds */
+enum watermark_memory_wa {
+	WATERMARK_WA_NONE,
+	WATERMARK_WA_X_TILED,
+	WATERMARK_WA_Y_TILED,
+};
+

 #define QUIRK_PIPEA_FORCE (1<<0)
 #define QUIRK_LVDS_SSC_DISABLE (1<<1)
 #define QUIRK_INVERT_BRIGHTNESS (1<<2)

drivers/gpu/drm/i915/i915_drv.h +0 -0
@@ -1764,6 +1771,8 @@ struct skl_ddb_allocation {


 struct skl_wm_values {
  unsigned dirty_pipes;

drivers/gpu/drm/i915/i915_drv.h +2 -0
+	/* any WaterMark memory workaround Required */
+	enum watermark_memory_wa mem_wa;

  struct skl_ddb_allocation ddb;
 };

drivers/gpu/drm/i915/intel_pm.c +0 -0
index 3e2dd8f..547bbda 100644
@@ -2889,11 +2889,7 @@ skl_wm_plane_id(const struct intel_plane
 *plane)
  	}
  }


-/*
- * FIXME: We still don't have the proper code detect if we need to apply the WA,
- * so assume we'll always need it in order to avoid underruns.
- */

drivers/gpu/drm/i915/intel_pm.c +1 -1
-static bool skl_needs_memory_bw_wa(struct intel_atomic_state *state)
+static bool intel_needs_memory_bw_wa(struct intel_atomic_state

*state)
 {
  struct drm_i915_private *dev_priv = to_i915(state-

Quoted 1 line

base.dev);

drivers/gpu/drm/i915/intel_pm.c +0 -0
@@ -3067,7 +3063,7 @@ bool intel_can_enable_sagv(struct
 drm_atomic_state *state)


  latency = dev_priv->wm.skl_latency[level];

drivers/gpu/drm/i915/intel_pm.c +1 -1
-		if (skl_needs_memory_bw_wa(intel_state) &&
+		if (intel_needs_memory_bw_wa(intel_state) &&

      plane->base.state->fb->modifier == I915_FORMAT_MOD_X_TILED) latency += 15;

drivers/gpu/drm/i915/intel_pm.c +0 -0
@@ -3597,7 +3593,7 @@ static int skl_compute_plane_wm(const struct
 drm_i915_private *dev_priv,
  	uint32_t y_min_scanlines;

  struct intel_atomic_state *state = to_intel_atomic_state(cstate->base.state);

drivers/gpu/drm/i915/intel_pm.c +1 -1
-	bool apply_memory_bw_wa = skl_needs_memory_bw_wa(state);
+	enum watermark_memory_wa mem_wa;

  bool y_tiled, x_tiled;

  if (latency == 0 || !cstate->base.active || !intel_pstate-

Quoted 1 line

base.visible) {

drivers/gpu/drm/i915/intel_pm.c +0 -0
@@ -3613,7 +3609,8 @@ static int skl_compute_plane_wm(const struct
 drm_i915_private *dev_priv,
  	if (IS_KABYLAKE(dev_priv) && dev_priv->ipc_enabled)
  		latency += 4;

drivers/gpu/drm/i915/intel_pm.c +2 -1
-	if (apply_memory_bw_wa && x_tiled)
+	mem_wa = state->wm_results.mem_wa;
+	if (mem_wa != WATERMARK_WA_NONE && x_tiled)

  latency += 15;

  width = drm_rect_width(&intel_pstate->base.src) >> 16;

drivers/gpu/drm/i915/intel_pm.c +0 -0
@@ -3648,7 +3645,7 @@ static int skl_compute_plane_wm(const struct
 drm_i915_private *dev_priv,
  		y_min_scanlines = 4;
  	}

drivers/gpu/drm/i915/intel_pm.c +1 -1
-	if (apply_memory_bw_wa)
+	if (mem_wa == WATERMARK_WA_Y_TILED)

  y_min_scanlines *= 2;

  plane_bytes_per_line = width * cpp;

drivers/gpu/drm/i915/intel_pm.c +0 -0
@@ -4077,6 +4074,15 @@ skl_compute_ddb(struct drm_atomic_state
 *state)
  	}


  /*

drivers/gpu/drm/i915/intel_pm.c +4 -0
+	 * If Watermark workaround is changed we need to recalculate
+	 * watermark values for all active pipes
+	 */
+	if (intel_state->wm_results.mem_wa != dev_priv-
Quoted 1 line

wm.skl_hw.mem_wa) {

drivers/gpu/drm/i915/intel_pm.c +5 -0
+		realloc_pipes = ~0;
+		intel_state->wm_results.dirty_pipes = ~0;
+	}
+
+	/*

   * We're not recomputing for the pipes not included in the commit, so
   * make sure we start with the current state. */

drivers/gpu/drm/i915/intel_pm.c +0 -0
@@ -4102,6 +4108,129 @@ skl_compute_ddb(struct drm_atomic_state
 *state)
  }


 static void

drivers/gpu/drm/i915/intel_pm.c +7 -0
+skl_compute_memory_bandwidth_wm_wa(struct drm_atomic_state *state)
+{
+	struct drm_device *dev = state->dev;
+	struct drm_i915_private *dev_priv = to_i915(dev);
+	struct intel_crtc *intel_crtc;
+	struct intel_plane_state *intel_pstate;
+	struct intel_atomic_state *intel_state =

to_intel_atomic_state(state);

drivers/gpu/drm/i915/intel_pm.c +24 -0
+	struct memdev_info *memdev_info = &dev_priv->memdev_info;
+	int num_active_pipes;
+	uint32_t max_pipe_bw_kbps, total_pipe_bw_kbps;
+	int display_bw_percentage;
+	bool y_tile_enabled = false;
+
+	if (!intel_needs_memory_bw_wa(intel_state)) {
+		intel_state->wm_results.mem_wa = WATERMARK_WA_NONE;
+		return;
+	}
+
+	if (!memdev_info->valid)
+		goto exit;
+
+	max_pipe_bw_kbps = 0;
+	num_active_pipes = 0;
+	for_each_intel_crtc(dev, intel_crtc) {
+		struct intel_crtc_state *cstate;
+		struct intel_plane *plane;
+		int num_active_planes;
+		uint32_t  max_plane_bw_kbps, pipe_bw_kbps;
+
+		/*
+		 * If CRTC is part of current atomic commit, get

crtc state from

drivers/gpu/drm/i915/intel_pm.c +1 -0
+		 * existing CRTC state. else take the cached CRTC

state

drivers/gpu/drm/i915/intel_pm.c +4 -0
+		 */
+		cstate = NULL;
+		if (state)
+			cstate =

intel_atomic_get_existing_crtc_state(state,

drivers/gpu/drm/i915/intel_pm.c +3 -0
+					intel_crtc);
+		if (!cstate)
+			cstate = to_intel_crtc_state(intel_crtc-
Quoted 1 line
Quoted 1 line

base.state);

This is really really not allowed. If you want to access crtc->state, you need to get the state.

Since a w/a forces a full recalculation, best you can do is put the per pipe status in crtc_state->wm.skl as well. If it changes you could add all other pipes.

Quoted 7 lines
drivers/gpu/drm/i915/intel_pm.c +6 -0
+		if (!cstate->base.active)
+			continue;
+
+		num_active_planes = 0;
+		max_plane_bw_kbps = 0;
+		for_each_intel_plane_mask(dev, plane, cstate-
Quoted 1 line

base.plane_mask) {

This is very much not allowed either!

If you want to do this safely and you hold crtc_state, use drm_atomic_crtc_state_for_each_plane_state.

Quoted 103 lines
drivers/gpu/drm/i915/intel_pm.c +7 -0
+			struct drm_framebuffer *fb;
+			uint32_t plane_bw_kbps;
+			uint32_t id = skl_wm_plane_id(plane);
+
+			intel_pstate = NULL;
+			intel_pstate =
+				intel_atomic_get_existing_plane_stat

e(state,

drivers/gpu/drm/i915/intel_pm.c +1 -0
+									

plane);

drivers/gpu/drm/i915/intel_pm.c +3 -0
+			if (!intel_pstate)
+				intel_pstate =
+					to_intel_plane_state(plane-
Quoted 1 line

base.state);

drivers/gpu/drm/i915/intel_pm.c +12 -0
+
+			if (!intel_pstate->base.visible)
+				continue;
+
+			if (WARN_ON(!intel_pstate->base.fb))
+				continue;
+
+			if (id == PLANE_CURSOR)
+				continue;
+
+			fb = intel_pstate->base.fb;
+			if ((fb->modifier == I915_FORMAT_MOD_Y_TILED

||

drivers/gpu/drm/i915/intel_pm.c +1 -0
+				fb->modifier ==

I915_FORMAT_MOD_Yf_TILED))

drivers/gpu/drm/i915/intel_pm.c +3 -0
+				y_tile_enabled = true;
+
+			plane_bw_kbps =

skl_adjusted_plane_pixel_rate(cstate,

drivers/gpu/drm/i915/intel_pm.c +1 -0
+								inte

l_pstate);

drivers/gpu/drm/i915/intel_pm.c +2 -0
+			max_plane_bw_kbps = max(plane_bw_kbps,
+							max_plane_bw

_kbps);

drivers/gpu/drm/i915/intel_pm.c +3 -0
+			num_active_planes++;
+		}
+		pipe_bw_kbps = max_plane_bw_kbps *

num_active_planes;

drivers/gpu/drm/i915/intel_pm.c +1 -0
+		max_pipe_bw_kbps = max(pipe_bw_kbps,

max_pipe_bw_kbps);

drivers/gpu/drm/i915/intel_pm.c +6 -0
+		num_active_pipes++;
+	}
+
+	total_pipe_bw_kbps = max_pipe_bw_kbps * num_active_pipes;
+
+	display_bw_percentage = DIV_ROUND_UP_ULL(total_pipe_bw_kbps

* 100,

drivers/gpu/drm/i915/intel_pm.c +1 -0
+						memdev_info-
Quoted 1 line

bandwidth_kbps);

drivers/gpu/drm/i915/intel_pm.c +3 -0
+
+	/*
+	 * If there is any Ytile plane enabled and arbitrated

display

drivers/gpu/drm/i915/intel_pm.c +4 -0
+	 * bandwidth > 20% of raw system memory bandwidth
+	 * Enale Y-tile related WA
+	 *
+	 * If memory is dual channel single rank, Xtile limit = 35%,

else Xtile

drivers/gpu/drm/i915/intel_pm.c +7 -0
+	 * limit = 60%
+	 * If there is no Ytile plane enabled and
+	 * arbitrated display bandwidth > Xtile limit
+	 * Enable X-tile realated WA
+	 */
+	if (y_tile_enabled && (display_bw_percentage > 20))
+		intel_state->wm_results.mem_wa =

WATERMARK_WA_Y_TILED;

drivers/gpu/drm/i915/intel_pm.c +9 -0
+	else {
+		int x_tile_percentage = 60;
+		enum rank rank = DRAM_RANK_SINGLE;
+
+		if (memdev_info->rank != DRAM_RANK_INVALID)
+			rank = memdev_info->rank;
+
+		if ((rank == DRAM_RANK_SINGLE) &&
+					(memdev_info->num_channels

== 2))

drivers/gpu/drm/i915/intel_pm.c +4 -0
+			x_tile_percentage = 35;
+
+		if (display_bw_percentage > x_tile_percentage)
+			intel_state->wm_results.mem_wa =

WATERMARK_WA_X_TILED;

drivers/gpu/drm/i915/intel_pm.c +9 -0
+	}
+	return;
+
+exit:
+	intel_state->wm_results.mem_wa = WATERMARK_WA_Y_TILED;
+}
+
+
+static void

 skl_copy_wm_for_pipe(struct skl_wm_values *dst,
       struct skl_wm_values *src,
       enum pipe pipe)

drivers/gpu/drm/i915/intel_pm.c +0 -0
@@ -4177,6 +4306,8 @@ skl_compute_wm(struct drm_atomic_state *state)
  	/* Clear all dirty flags */
  	results->dirty_pipes = 0;

drivers/gpu/drm/i915/intel_pm.c +2 -0
+	skl_compute_memory_bandwidth_wm_wa(state);
+
Quoted 3 lines

  ret = skl_compute_ddb(state);
  if (ret)
  return ret;

---------------------------------------------------------------------
Intel International B.V.
Registered in The Netherlands under number 34098535 Statutory seat: Haarlemmermeer
Registered address: Capronilaan 37, 1119NG Schiphol-Rijk

This e-mail and any attachments may contain confidential material for the sole use of the intended recipient(s). Any review or distribution by others is strictly prohibited. If you are not the intended recipient, please contact the sender and delete all copies.
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

#14 lore raw

Re: [PATCH v6 8/8] drm/i915/gen9: WM memory bandwidth related workaround

Hi,

Quoted 177 lines · Maarten

Mahesh Kumar schreef op do 24-11-2016 om 09:31 [+0530]:

Quoted 176 lines

This patch implemnets Workariunds related to display arbitrated memory
bandwidth. These WA are applicabe for all gen-9 based platforms.

Changes since v1:
- Rebase on top of Paulo's patch series
Changes since v2:
- Address review comments
- Rebase/rework as per other patch changes in series

---
  drivers/gpu/drm/i915/i915_drv.h |   9 +++
  drivers/gpu/drm/i915/intel_pm.c | 149
+++++++++++++++++++++++++++++++++++++---
  2 files changed, 149 insertions(+), 9 deletions(-)
drivers/gpu/drm/i915/i915_drv.h +9 -0
index 4e2f17f..2b673c6 100644
@@ -1193,6 +1193,13 @@ enum intel_sbi_destination {
  	SBI_MPHY,
  };
 
+/* SKL+ Watermark arbitrated display bandwidth Workarounds */
+enum watermark_memory_wa {
+	WATERMARK_WA_NONE,
+	WATERMARK_WA_X_TILED,
+	WATERMARK_WA_Y_TILED,
+};
+
  #define QUIRK_PIPEA_FORCE (1<<0)
  #define QUIRK_LVDS_SSC_DISABLE (1<<1)
  #define QUIRK_INVERT_BRIGHTNESS (1<<2)
@@ -1764,6 +1771,8 @@ struct skl_ddb_allocation {
 
  struct skl_wm_values {
  	unsigned dirty_pipes;
+	/* any WaterMark memory workaround Required */
+	enum watermark_memory_wa mem_wa;
  	struct skl_ddb_allocation ddb;
  };
 
drivers/gpu/drm/i915/intel_pm.c +1 -5
index 3e2dd8f..547bbda 100644
@@ -2889,11 +2889,7 @@ skl_wm_plane_id(const struct intel_plane
 *plane)
  	}
  }
 
-/*
- * FIXME: We still don't have the proper code detect if we need to
 apply the WA,
- * so assume we'll always need it in order to avoid underruns.
- */
-static bool skl_needs_memory_bw_wa(struct intel_atomic_state *state)
+static bool intel_needs_memory_bw_wa(struct intel_atomic_state
 *state)

{
struct drm_i915_private *dev_priv = to_i915(state-

Quoted 1 line

base.dev);

drivers/gpu/drm/i915/intel_pm.c +1 -1
@@ -3067,7 +3063,7 @@ bool intel_can_enable_sagv(struct
 drm_atomic_state *state)
 
  		latency = dev_priv->wm.skl_latency[level];
 
-		if (skl_needs_memory_bw_wa(intel_state) &&
+		if (intel_needs_memory_bw_wa(intel_state) &&
  		    plane->base.state->fb->modifier ==
  		    I915_FORMAT_MOD_X_TILED)
  			latency += 15;
drivers/gpu/drm/i915/intel_pm.c +1 -1
@@ -3597,7 +3593,7 @@ static int skl_compute_plane_wm(const struct
 drm_i915_private *dev_priv,
  	uint32_t y_min_scanlines;
  	struct intel_atomic_state *state =
  		to_intel_atomic_state(cstate->base.state);
-	bool apply_memory_bw_wa = skl_needs_memory_bw_wa(state);
+	enum watermark_memory_wa mem_wa;
  	bool y_tiled, x_tiled;
 

if (latency == 0 || !cstate->base.active || !intel_pstate-

Quoted 1 line

base.visible) {

drivers/gpu/drm/i915/intel_pm.c +2 -1
@@ -3613,7 +3609,8 @@ static int skl_compute_plane_wm(const struct
 drm_i915_private *dev_priv,
  	if (IS_KABYLAKE(dev_priv) && dev_priv->ipc_enabled)
  		latency += 4;
 
-	if (apply_memory_bw_wa && x_tiled)
+	mem_wa = state->wm_results.mem_wa;
+	if (mem_wa != WATERMARK_WA_NONE && x_tiled)
  		latency += 15;
 
  	width = drm_rect_width(&intel_pstate->base.src) >> 16;
drivers/gpu/drm/i915/intel_pm.c +1 -1
@@ -3648,7 +3645,7 @@ static int skl_compute_plane_wm(const struct
 drm_i915_private *dev_priv,
  		y_min_scanlines = 4;
  	}
 
-	if (apply_memory_bw_wa)
+	if (mem_wa == WATERMARK_WA_Y_TILED)
  		y_min_scanlines *= 2;
 
  	plane_bytes_per_line = width * cpp;
drivers/gpu/drm/i915/intel_pm.c +9 -0
@@ -4077,6 +4074,15 @@ skl_compute_ddb(struct drm_atomic_state
 *state)
  	}
 
  	/*
+	 * If Watermark workaround is changed we need to recalculate
+	 * watermark values for all active pipes
+	 */
+	if (intel_state->wm_results.mem_wa != dev_priv-
 > wm.skl_hw.mem_wa) {
+		realloc_pipes = ~0;
+		intel_state->wm_results.dirty_pipes = ~0;
+	}
+
+	/*
  	 * We're not recomputing for the pipes not included in the

commit, so
* make sure we start with the current state. */

drivers/gpu/drm/i915/intel_pm.c +31 -0
@@ -4102,6 +4108,129 @@ skl_compute_ddb(struct drm_atomic_state
 *state)
  }
 
  static void
+skl_compute_memory_bandwidth_wm_wa(struct drm_atomic_state *state)
+{
+	struct drm_device *dev = state->dev;
+	struct drm_i915_private *dev_priv = to_i915(dev);
+	struct intel_crtc *intel_crtc;
+	struct intel_plane_state *intel_pstate;
+	struct intel_atomic_state *intel_state =
 to_intel_atomic_state(state);
+	struct memdev_info *memdev_info = &dev_priv->memdev_info;
+	int num_active_pipes;
+	uint32_t max_pipe_bw_kbps, total_pipe_bw_kbps;
+	int display_bw_percentage;
+	bool y_tile_enabled = false;
+
+	if (!intel_needs_memory_bw_wa(intel_state)) {
+		intel_state->wm_results.mem_wa = WATERMARK_WA_NONE;
+		return;
+	}
+
+	if (!memdev_info->valid)
+		goto exit;
+
+	max_pipe_bw_kbps = 0;
+	num_active_pipes = 0;
+	for_each_intel_crtc(dev, intel_crtc) {
+		struct intel_crtc_state *cstate;
+		struct intel_plane *plane;
+		int num_active_planes;
+		uint32_t  max_plane_bw_kbps, pipe_bw_kbps;
+
+		/*
+		 * If CRTC is part of current atomic commit, get

crtc state from

drivers/gpu/drm/i915/intel_pm.c +1 -0
+		 * existing CRTC state. else take the cached CRTC

state

drivers/gpu/drm/i915/intel_pm.c +4 -0
+		 */
+		cstate = NULL;
+		if (state)
+			cstate =

intel_atomic_get_existing_crtc_state(state,

drivers/gpu/drm/i915/intel_pm.c +3 -0
+					intel_crtc);
+		if (!cstate)
+			cstate = to_intel_crtc_state(intel_crtc-
Quoted 7 lines
Quoted 1 line
Quoted 1 line

base.state);

This is really really not allowed. If you want to access crtc->state, you need to get the state.

Since a w/a forces a full recalculation, best you can do is put the per pipe status in crtc_state->wm.skl as well. If it changes you could add all other pipes.

I really don't want to add all pipes in "state" until that is necessary otherwise it'll make our commit huge, that's why getting the cached state. Same goes for plane. Later if w/a changes then I'm adding all the CRTC's in relloc_pipes mask.

	if (intel_state->wm_results.mem_wa != dev_priv->wm.skl_hw.mem_wa)

If I hold the crtc->mutex or plane->mutex lock, It may cause deadlock with other commits.
I can keep a cached copy of plane memory bandwidth requirement in "dev_priv->wm.skl_hw", but again if there are two parallel commits it may cause race.

Can you please suggest what is the correct way of getting plane/crtc state during check phase without have to actually commit them (add in global-state), If any such thing is available in atomic framework?

Regards,
-Mahesh

Quoted 112 lines
Quoted 7 lines
drivers/gpu/drm/i915/intel_pm.c +6 -0
+		if (!cstate->base.active)
+			continue;
+
+		num_active_planes = 0;
+		max_plane_bw_kbps = 0;
+		for_each_intel_plane_mask(dev, plane, cstate-
Quoted 1 line

base.plane_mask) {

This is very much not allowed either!

If you want to do this safely and you hold crtc_state, use drm_atomic_crtc_state_for_each_plane_state.

Quoted 101 lines
drivers/gpu/drm/i915/intel_pm.c +7 -0
+			struct drm_framebuffer *fb;
+			uint32_t plane_bw_kbps;
+			uint32_t id = skl_wm_plane_id(plane);
+
+			intel_pstate = NULL;
+			intel_pstate =
+				intel_atomic_get_existing_plane_stat

e(state,

drivers/gpu/drm/i915/intel_pm.c +1 -0
+									

plane);

drivers/gpu/drm/i915/intel_pm.c +3 -0
+			if (!intel_pstate)
+				intel_pstate =
+					to_intel_plane_state(plane-
Quoted 1 line

base.state);

drivers/gpu/drm/i915/intel_pm.c +12 -0
+
+			if (!intel_pstate->base.visible)
+				continue;
+
+			if (WARN_ON(!intel_pstate->base.fb))
+				continue;
+
+			if (id == PLANE_CURSOR)
+				continue;
+
+			fb = intel_pstate->base.fb;
+			if ((fb->modifier == I915_FORMAT_MOD_Y_TILED

||

drivers/gpu/drm/i915/intel_pm.c +1 -0
+				fb->modifier ==

I915_FORMAT_MOD_Yf_TILED))

drivers/gpu/drm/i915/intel_pm.c +3 -0
+				y_tile_enabled = true;
+
+			plane_bw_kbps =

skl_adjusted_plane_pixel_rate(cstate,

drivers/gpu/drm/i915/intel_pm.c +1 -0
+								inte

l_pstate);

drivers/gpu/drm/i915/intel_pm.c +2 -0
+			max_plane_bw_kbps = max(plane_bw_kbps,
+							max_plane_bw

_kbps);

drivers/gpu/drm/i915/intel_pm.c +3 -0
+			num_active_planes++;
+		}
+		pipe_bw_kbps = max_plane_bw_kbps *

num_active_planes;

drivers/gpu/drm/i915/intel_pm.c +1 -0
+		max_pipe_bw_kbps = max(pipe_bw_kbps,

max_pipe_bw_kbps);

drivers/gpu/drm/i915/intel_pm.c +6 -0
+		num_active_pipes++;
+	}
+
+	total_pipe_bw_kbps = max_pipe_bw_kbps * num_active_pipes;
+
+	display_bw_percentage = DIV_ROUND_UP_ULL(total_pipe_bw_kbps

* 100,

drivers/gpu/drm/i915/intel_pm.c +1 -0
+						memdev_info-
Quoted 1 line

bandwidth_kbps);

drivers/gpu/drm/i915/intel_pm.c +3 -0
+
+	/*
+	 * If there is any Ytile plane enabled and arbitrated

display

drivers/gpu/drm/i915/intel_pm.c +4 -0
+	 * bandwidth > 20% of raw system memory bandwidth
+	 * Enale Y-tile related WA
+	 *
+	 * If memory is dual channel single rank, Xtile limit = 35%,

else Xtile

drivers/gpu/drm/i915/intel_pm.c +7 -0
+	 * limit = 60%
+	 * If there is no Ytile plane enabled and
+	 * arbitrated display bandwidth > Xtile limit
+	 * Enable X-tile realated WA
+	 */
+	if (y_tile_enabled && (display_bw_percentage > 20))
+		intel_state->wm_results.mem_wa =

WATERMARK_WA_Y_TILED;

drivers/gpu/drm/i915/intel_pm.c +9 -0
+	else {
+		int x_tile_percentage = 60;
+		enum rank rank = DRAM_RANK_SINGLE;
+
+		if (memdev_info->rank != DRAM_RANK_INVALID)
+			rank = memdev_info->rank;
+
+		if ((rank == DRAM_RANK_SINGLE) &&
+					(memdev_info->num_channels

== 2))

drivers/gpu/drm/i915/intel_pm.c +4 -0
+			x_tile_percentage = 35;
+
+		if (display_bw_percentage > x_tile_percentage)
+			intel_state->wm_results.mem_wa =

WATERMARK_WA_X_TILED;

drivers/gpu/drm/i915/intel_pm.c +9 -0
+	}
+	return;
+
+exit:
+	intel_state->wm_results.mem_wa = WATERMARK_WA_Y_TILED;
+}
+
+
+static void
  skl_copy_wm_for_pipe(struct skl_wm_values *dst,
  		     struct skl_wm_values *src,
  		     enum pipe pipe)
@@ -4177,6 +4306,8 @@ skl_compute_wm(struct drm_atomic_state *state)
  	/* Clear all dirty flags */
  	results->dirty_pipes = 0;
 
Quoted 5 lines

drivers/gpu/drm/i915/intel_pm.c skl_compute_wm(struct drm_atomic_state *state) · line 4313

Quoted 5 lines
drivers/gpu/drm/i915/intel_pm.c +2 -0
+	skl_compute_memory_bandwidth_wm_wa(state);
+
  	ret = skl_compute_ddb(state);
  	if (ret)
  		return ret;

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

#15 lore raw

Re: [PATCH v6 8/8] drm/i915/gen9: WM memory bandwidth related workaround

Mahesh Kumar schreef op di 29-11-2016 om 11:12 [+0530]:

Quoted 226 lines

Hi,

Quoted 196 lines · Maarten

Mahesh Kumar schreef op do 24-11-2016 om 09:31 [+0530]:

Quoted 193 lines

This patch implemnets Workariunds related to display arbitrated memory
bandwidth. These WA are applicabe for all gen-9 based platforms.

Changes since v1:
  - Rebase on top of Paulo's patch series Changes since v2:
  - Address review comments
  - Rebase/rework as per other patch changes in series

---
  drivers/gpu/drm/i915/i915_drv.h |   9 +++
  drivers/gpu/drm/i915/intel_pm.c | 149
+++++++++++++++++++++++++++++++++++++---

  2 files changed, 149 insertions(+), 9 deletions(-)
drivers/gpu/drm/i915/i915_drv.h +0 -0
index 4e2f17f..2b673c6 100644
@@ -1193,6 +1193,13 @@ enum intel_sbi_destination {
   	SBI_MPHY,
   };

drivers/gpu/drm/i915/i915_drv.h +7 -0
+/* SKL+ Watermark arbitrated display bandwidth Workarounds */
+enum watermark_memory_wa {
+	WATERMARK_WA_NONE,
+	WATERMARK_WA_X_TILED,
+	WATERMARK_WA_Y_TILED,
+};
+

  #define QUIRK_PIPEA_FORCE (1<<0)
  #define QUIRK_LVDS_SSC_DISABLE (1<<1)
  #define QUIRK_INVERT_BRIGHTNESS (1<<2)

drivers/gpu/drm/i915/i915_drv.h +0 -0
@@ -1764,6 +1771,8 @@ struct skl_ddb_allocation {


  struct skl_wm_values {
   unsigned dirty_pipes;

drivers/gpu/drm/i915/i915_drv.h +2 -0
+	/* any WaterMark memory workaround Required */
+	enum watermark_memory_wa mem_wa;

   struct skl_ddb_allocation ddb;
  };

drivers/gpu/drm/i915/intel_pm.c +0 -0
index 3e2dd8f..547bbda 100644
@@ -2889,11 +2889,7 @@ skl_wm_plane_id(const struct intel_plane
 *plane)
   	}
   }


-/*
- * FIXME: We still don't have the proper code detect if we need to
apply the WA,
- * so assume we'll always need it in order to avoid underruns.
- */
-static bool skl_needs_memory_bw_wa(struct intel_atomic_state *state)
+static bool intel_needs_memory_bw_wa(struct intel_atomic_state *state)
  {
   struct drm_i915_private *dev_priv = to_i915(state-

Quoted 2 lines

base.dev);

drivers/gpu/drm/i915/intel_pm.c +0 -0
@@ -3067,7 +3063,7 @@ bool intel_can_enable_sagv(struct
 drm_atomic_state *state)


   latency = dev_priv->wm.skl_latency[level];

drivers/gpu/drm/i915/intel_pm.c +1 -1
-		if (skl_needs_memory_bw_wa(intel_state) &&
+		if (intel_needs_memory_bw_wa(intel_state) &&

       plane->base.state->fb->modifier == I915_FORMAT_MOD_X_TILED) latency += 15;

drivers/gpu/drm/i915/intel_pm.c +0 -0
@@ -3597,7 +3593,7 @@ static int skl_compute_plane_wm(const

struct
drm_i915_private *dev_priv,
   uint32_t y_min_scanlines;
   struct intel_atomic_state *state = to_intel_atomic_state(cstate->base.state);

drivers/gpu/drm/i915/intel_pm.c +1 -1
-	bool apply_memory_bw_wa = skl_needs_memory_bw_wa(state);
+	enum watermark_memory_wa mem_wa;

   bool y_tiled, x_tiled;

   if (latency == 0 || !cstate->base.active || !intel_pstate-

Quoted 2 lines

base.visible) {

drivers/gpu/drm/i915/intel_pm.c +0 -0
@@ -3613,7 +3609,8 @@ static int skl_compute_plane_wm(const

struct
drm_i915_private *dev_priv,
   if (IS_KABYLAKE(dev_priv) && dev_priv->ipc_enabled) latency += 4;

drivers/gpu/drm/i915/intel_pm.c +2 -1
-	if (apply_memory_bw_wa && x_tiled)
+	mem_wa = state->wm_results.mem_wa;
+	if (mem_wa != WATERMARK_WA_NONE && x_tiled)

   latency += 15;

   width = drm_rect_width(&intel_pstate->base.src) >> 16;

drivers/gpu/drm/i915/intel_pm.c +0 -0
@@ -3648,7 +3645,7 @@ static int skl_compute_plane_wm(const

struct
drm_i915_private *dev_priv,
   y_min_scanlines = 4;
   }

drivers/gpu/drm/i915/intel_pm.c +1 -1
-	if (apply_memory_bw_wa)
+	if (mem_wa == WATERMARK_WA_Y_TILED)

   y_min_scanlines *= 2;

   plane_bytes_per_line = width * cpp;

drivers/gpu/drm/i915/intel_pm.c +0 -0
@@ -4077,6 +4074,15 @@ skl_compute_ddb(struct drm_atomic_state
 *state)
   	}


   /*

drivers/gpu/drm/i915/intel_pm.c +1 -0
+	 * If Watermark workaround is changed we need to

recalculate

drivers/gpu/drm/i915/intel_pm.c +3 -0
+	 * watermark values for all active pipes
+	 */
+	if (intel_state->wm_results.mem_wa != dev_priv-
Quoted 2 lines

wm.skl_hw.mem_wa) {

drivers/gpu/drm/i915/intel_pm.c +5 -0
+		realloc_pipes = ~0;
+		intel_state->wm_results.dirty_pipes = ~0;
+	}
+
+	/*

    * We're not recomputing for the pipes not included in the
commit, so
    * make sure we start with the current state. */

drivers/gpu/drm/i915/intel_pm.c +0 -0
@@ -4102,6 +4108,129 @@ skl_compute_ddb(struct drm_atomic_state
 *state)
   }


  static void +skl_compute_memory_bandwidth_wm_wa(struct drm_atomic_state *state)

drivers/gpu/drm/i915/intel_pm.c +6 -0
+{
+	struct drm_device *dev = state->dev;
+	struct drm_i915_private *dev_priv = to_i915(dev);
+	struct intel_crtc *intel_crtc;
+	struct intel_plane_state *intel_pstate;
+	struct intel_atomic_state *intel_state =

to_intel_atomic_state(state);

drivers/gpu/drm/i915/intel_pm.c +1 -0
+	struct memdev_info *memdev_info = &dev_priv-
Quoted 1 line

memdev_info;

drivers/gpu/drm/i915/intel_pm.c +7 -0
+	int num_active_pipes;
+	uint32_t max_pipe_bw_kbps, total_pipe_bw_kbps;
+	int display_bw_percentage;
+	bool y_tile_enabled = false;
+
+	if (!intel_needs_memory_bw_wa(intel_state)) {
+		intel_state->wm_results.mem_wa =

WATERMARK_WA_NONE;

drivers/gpu/drm/i915/intel_pm.c +16 -0
+		return;
+	}
+
+	if (!memdev_info->valid)
+		goto exit;
+
+	max_pipe_bw_kbps = 0;
+	num_active_pipes = 0;
+	for_each_intel_crtc(dev, intel_crtc) {
+		struct intel_crtc_state *cstate;
+		struct intel_plane *plane;
+		int num_active_planes;
+		uint32_t  max_plane_bw_kbps, pipe_bw_kbps;
+
+		/*
+		 * If CRTC is part of current atomic commit, get

crtc state from

drivers/gpu/drm/i915/intel_pm.c +1 -0
+		 * existing CRTC state. else take the cached

CRTC
state

drivers/gpu/drm/i915/intel_pm.c +4 -0
+		 */
+		cstate = NULL;
+		if (state)
+			cstate =

intel_atomic_get_existing_crtc_state(state,

drivers/gpu/drm/i915/intel_pm.c +3 -0
+					intel_crtc);
+		if (!cstate)
+			cstate = to_intel_crtc_state(intel_crtc-
Quoted 1 line
Quoted 1 line
Quoted 1 line

base.state);

Quoted 8 lines

This is really really not allowed. If you want to access crtc->state, you need to get the state.

Since a w/a forces a full recalculation, best you can do is put the per
pipe status in crtc_state->wm.skl as well. If it changes you could add
all other pipes.

I really don't want to add all pipes in "state" until that is necessary
otherwise it'll make our commit huge, that's why getting the cached state.
Same goes for plane. Later if w/a changes then I'm  adding all the CRTC's in relloc_pipes mask.

	if (intel_state->wm_results.mem_wa != dev_priv-
Quoted 1 line

wm.skl_hw.mem_wa)

If I hold the crtc->mutex or plane->mutex lock, It may cause deadlock
with other commits.
I can keep a cached copy of plane memory bandwidth requirement in "dev_priv->wm.skl_hw", but again if there are two parallel commits it
may cause race.

Quoted 5 lines

Can you please suggest what is the correct way of getting plane/crtc state during check phase without have to actually commit them (add in
global-state),
If any such thing is available in atomic framework?

How often will the workaround status change in practice?

You could do same as active_crtcs, protect changing the workaround current crtc's workaround mode in dev_priv->wm.skl.wa_state[pipe] with connection_mutex. If this means changing that the global workaround setting is changed, then also acquire all other crtc states.

I can't say it's pretty though, it would need a good justification for how bad the problem is in practice plus pretty good documentation on why it works.

~Maarten
---------------------------------------------------------------------
Intel International B.V.
Registered in The Netherlands under number 34098535 Statutory seat: Haarlemmermeer
Registered address: Capronilaan 37, 1119NG Schiphol-Rijk

This e-mail and any attachments may contain confidential material for the sole use of the intended recipient(s). Any review or distribution by others is strictly prohibited. If you are not the intended recipient, please contact the sender and delete all copies.
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

#16 lore raw

Re: [PATCH v6 8/8] drm/i915/gen9: WM memory bandwidth related workaround

Quoted 220 lines · Maarten

Mahesh Kumar schreef op di 29-11-2016 om 11:12 [+0530]:

Quoted 219 lines

Hi,

Quoted 190 lines · Maarten

Mahesh Kumar schreef op do 24-11-2016 om 09:31 [+0530]:

Quoted 188 lines

This patch implemnets Workariunds related to display arbitrated memory
bandwidth. These WA are applicabe for all gen-9 based platforms.

Changes since v1:
- Rebase on top of Paulo's patch series
Changes since v2:
- Address review comments
- Rebase/rework as per other patch changes in series

---
   drivers/gpu/drm/i915/i915_drv.h |   9 +++
   drivers/gpu/drm/i915/intel_pm.c | 149
+++++++++++++++++++++++++++++++++++++---
   2 files changed, 149 insertions(+), 9 deletions(-)
drivers/gpu/drm/i915/i915_drv.h +9 -0
index 4e2f17f..2b673c6 100644
@@ -1193,6 +1193,13 @@ enum intel_sbi_destination {
   	SBI_MPHY,
   };
 
+/* SKL+ Watermark arbitrated display bandwidth Workarounds */
+enum watermark_memory_wa {
+	WATERMARK_WA_NONE,
+	WATERMARK_WA_X_TILED,
+	WATERMARK_WA_Y_TILED,
+};
+
   #define QUIRK_PIPEA_FORCE (1<<0)
   #define QUIRK_LVDS_SSC_DISABLE (1<<1)
   #define QUIRK_INVERT_BRIGHTNESS (1<<2)
@@ -1764,6 +1771,8 @@ struct skl_ddb_allocation {
 
   struct skl_wm_values {
   	unsigned dirty_pipes;
+	/* any WaterMark memory workaround Required */
+	enum watermark_memory_wa mem_wa;
   	struct skl_ddb_allocation ddb;
   };
 
drivers/gpu/drm/i915/intel_pm.c +0 -2
index 3e2dd8f..547bbda 100644
@@ -2889,11 +2889,7 @@ skl_wm_plane_id(const struct intel_plane
 *plane)
   	}
   }
 
-/*
- * FIXME: We still don't have the proper code detect if we need

to
apply the WA,
- * so assume we'll always need it in order to avoid underruns.
- */
-static bool skl_needs_memory_bw_wa(struct intel_atomic_state *state)
+static bool intel_needs_memory_bw_wa(struct intel_atomic_state *state)

   {
   	struct drm_i915_private *dev_priv = to_i915(state-
Quoted 1 line

base.dev);

drivers/gpu/drm/i915/intel_pm.c +1 -1
@@ -3067,7 +3063,7 @@ bool intel_can_enable_sagv(struct
 drm_atomic_state *state)
 
   		latency = dev_priv->wm.skl_latency[level];
 
-		if (skl_needs_memory_bw_wa(intel_state) &&
+		if (intel_needs_memory_bw_wa(intel_state) &&
   		    plane->base.state->fb->modifier ==
   		    I915_FORMAT_MOD_X_TILED)
   			latency += 15;
drivers/gpu/drm/i915/intel_pm.c +0 -0
@@ -3597,7 +3593,7 @@ static int skl_compute_plane_wm(const

struct
drm_i915_private *dev_priv,
uint32_t y_min_scanlines;
struct intel_atomic_state *state =
to_intel_atomic_state(cstate->base.state);

drivers/gpu/drm/i915/intel_pm.c +1 -1
-	bool apply_memory_bw_wa = skl_needs_memory_bw_wa(state);
+	enum watermark_memory_wa mem_wa;
   	bool y_tiled, x_tiled;
 
   	if (latency == 0 || !cstate->base.active ||

!intel_pstate-

Quoted 1 line

base.visible) {

drivers/gpu/drm/i915/intel_pm.c +0 -0
@@ -3613,7 +3609,8 @@ static int skl_compute_plane_wm(const

struct
drm_i915_private *dev_priv,
if (IS_KABYLAKE(dev_priv) && dev_priv->ipc_enabled)
latency += 4;

drivers/gpu/drm/i915/intel_pm.c +2 -1
-	if (apply_memory_bw_wa && x_tiled)
+	mem_wa = state->wm_results.mem_wa;
+	if (mem_wa != WATERMARK_WA_NONE && x_tiled)
   		latency += 15;
 
   	width = drm_rect_width(&intel_pstate->base.src) >> 16;
@@ -3648,7 +3645,7 @@ static int skl_compute_plane_wm(const

struct
drm_i915_private *dev_priv,

   		y_min_scanlines = 4;
   	}
drivers/gpu/drm/i915/intel_pm.c +2 -1
-	if (apply_memory_bw_wa)
+	if (mem_wa == WATERMARK_WA_Y_TILED)
   		y_min_scanlines *= 2;
 
   	plane_bytes_per_line = width * cpp;
@@ -4077,6 +4074,15 @@ skl_compute_ddb(struct drm_atomic_state
 *state)
   	}
 
   	/*
+	 * If Watermark workaround is changed we need to

recalculate

drivers/gpu/drm/i915/intel_pm.c +3 -0
+	 * watermark values for all active pipes
+	 */
+	if (intel_state->wm_results.mem_wa != dev_priv-
Quoted 1 line

wm.skl_hw.mem_wa) {

drivers/gpu/drm/i915/intel_pm.c +5 -0
+		realloc_pipes = ~0;
+		intel_state->wm_results.dirty_pipes = ~0;
+	}
+
+	/*
   	 * We're not recomputing for the pipes not included in

the
commit, so
* make sure we start with the current state. */

drivers/gpu/drm/i915/intel_pm.c +8 -0
@@ -4102,6 +4108,129 @@ skl_compute_ddb(struct drm_atomic_state
 *state)
   }
 
   static void
+skl_compute_memory_bandwidth_wm_wa(struct drm_atomic_state
 *state)
+{
+	struct drm_device *dev = state->dev;
+	struct drm_i915_private *dev_priv = to_i915(dev);
+	struct intel_crtc *intel_crtc;
+	struct intel_plane_state *intel_pstate;
+	struct intel_atomic_state *intel_state =
 to_intel_atomic_state(state);
+	struct memdev_info *memdev_info = &dev_priv-
Quoted 1 line

memdev_info;

drivers/gpu/drm/i915/intel_pm.c +7 -0
+	int num_active_pipes;
+	uint32_t max_pipe_bw_kbps, total_pipe_bw_kbps;
+	int display_bw_percentage;
+	bool y_tile_enabled = false;
+
+	if (!intel_needs_memory_bw_wa(intel_state)) {
+		intel_state->wm_results.mem_wa =

WATERMARK_WA_NONE;

drivers/gpu/drm/i915/intel_pm.c +16 -0
+		return;
+	}
+
+	if (!memdev_info->valid)
+		goto exit;
+
+	max_pipe_bw_kbps = 0;
+	num_active_pipes = 0;
+	for_each_intel_crtc(dev, intel_crtc) {
+		struct intel_crtc_state *cstate;
+		struct intel_plane *plane;
+		int num_active_planes;
+		uint32_t  max_plane_bw_kbps, pipe_bw_kbps;
+
+		/*
+		 * If CRTC is part of current atomic commit, get

crtc state from

drivers/gpu/drm/i915/intel_pm.c +1 -0
+		 * existing CRTC state. else take the cached

CRTC
state

drivers/gpu/drm/i915/intel_pm.c +4 -0
+		 */
+		cstate = NULL;
+		if (state)
+			cstate =

intel_atomic_get_existing_crtc_state(state,

drivers/gpu/drm/i915/intel_pm.c +3 -0
+					intel_crtc);
+		if (!cstate)
+			cstate = to_intel_crtc_state(intel_crtc-
Quoted 1 line
Quoted 1 line

base.state);

Quoted 8 lines

This is really really not allowed. If you want to access crtc->state, you need to get the state.

Since a w/a forces a full recalculation, best you can do is put the per
pipe status in crtc_state->wm.skl as well. If it changes you could add
all other pipes.

I really don't want to add all pipes in "state" until that is necessary
otherwise it'll make our commit huge, that's why getting the cached state.
Same goes for plane. Later if w/a changes then I'm adding all the CRTC's in relloc_pipes mask.

	if (intel_state->wm_results.mem_wa != dev_priv-
Quoted 1 line

wm.skl_hw.mem_wa)

If I hold the crtc->mutex or plane->mutex lock, It may cause deadlock
with other commits.
I can keep a cached copy of plane memory bandwidth requirement in "dev_priv->wm.skl_hw", but again if there are two parallel commits it
may cause race.

Quoted 6 lines
Quoted 5 lines

Can you please suggest what is the correct way of getting plane/crtc state during check phase without have to actually commit them (add in
global-state),
If any such thing is available in atomic framework?

How often will the workaround status change in practice?

In Linux use-case status changes very rarely, If we connect multiple high resolution display & our DRAM's bandwidth is less we may have to enable the WA. & it'll remain there until any display in unplugged OR any modeset with lower resolution.
On the other hand, In OS with multi-plane enabled, WA may change if any plane is enabled/disabled (based on total bandwidth requirement for display)

Quoted 4 lines

You could do same as active_crtcs, protect changing the workaround current crtc's workaround mode in dev_priv->wm.skl.wa_state[pipe] with connection_mutex. If this means changing that the global workaround setting is changed, then also acquire all other crtc states.

This is not per-CRTC WA, this is complete display-system level WA. & depends upon total memory requirement of display.
As you suggested I can keep the status(bandwidth requirement) for each pipe in dev_priv->wm.skl.wa_state/bandwidth[pipe], and access it with some mutex. Is connection mutex is right mutex to hold, what about wm_mutex?

Regards,
-Mahesh

Quoted 6 lines

I can't say it's pretty though, it would need a good justification for how bad the problem is in practice plus pretty good documentation on why it works.

~Maarten

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

#17 lore raw

Re: [PATCH v6 8/8] drm/i915/gen9: WM memory bandwidth related workaround

Mahesh Kumar schreef op di 29-11-2016 om 19:17 [+0530]:

Quoted 277 lines · Maarten
Quoted 250 lines

Mahesh Kumar schreef op di 29-11-2016 om 11:12 [+0530]:

Quoted 248 lines

Hi,

Quoted 215 lines · Maarten

Mahesh Kumar schreef op do 24-11-2016 om 09:31 [+0530]:

Quoted 207 lines

This patch implemnets Workariunds related to display arbitrated
memory
bandwidth. These WA are applicabe for all gen-9 based platforms.

Changes since v1:
   - Rebase on top of Paulo's patch series Changes since v2:
   - Address review comments
   - Rebase/rework as per other patch changes in series

---
   drivers/gpu/drm/i915/i915_drv.h |   9 +++
   drivers/gpu/drm/i915/intel_pm.c | 149
+++++++++++++++++++++++++++++++++++++---

   2 files changed, 149 insertions(+), 9 deletions(-)
drivers/gpu/drm/i915/i915_drv.h +0 -0
index 4e2f17f..2b673c6 100644
@@ -1193,6 +1193,13 @@ enum intel_sbi_destination {
    	SBI_MPHY,
    };


+/* SKL+ Watermark arbitrated display bandwidth Workarounds */

drivers/gpu/drm/i915/i915_drv.h +6 -0
+enum watermark_memory_wa {
+	WATERMARK_WA_NONE,
+	WATERMARK_WA_X_TILED,
+	WATERMARK_WA_Y_TILED,
+};
+

   #define QUIRK_PIPEA_FORCE (1<<0)
   #define QUIRK_LVDS_SSC_DISABLE (1<<1)
   #define QUIRK_INVERT_BRIGHTNESS (1<<2)

drivers/gpu/drm/i915/i915_drv.h +0 -0
@@ -1764,6 +1771,8 @@ struct skl_ddb_allocation {


   struct skl_wm_values {
    unsigned dirty_pipes;

drivers/gpu/drm/i915/i915_drv.h +2 -0
+	/* any WaterMark memory workaround Required */
+	enum watermark_memory_wa mem_wa;

    struct skl_ddb_allocation ddb;
   };

drivers/gpu/drm/i915/intel_pm.c +0 -0
index 3e2dd8f..547bbda 100644
@@ -2889,11 +2889,7 @@ skl_wm_plane_id(const struct

intel_plane
*plane)
    }
   }

-/*
- * FIXME: We still don't have the proper code detect if we need
to
apply the WA,
- * so assume we'll always need it in order to avoid underruns.
- */
-static bool skl_needs_memory_bw_wa(struct intel_atomic_state *state)
+static bool intel_needs_memory_bw_wa(struct intel_atomic_state
*state)
   {
    struct drm_i915_private *dev_priv = to_i915(state-

Quoted 2 lines

base.dev);

drivers/gpu/drm/i915/intel_pm.c +0 -0
@@ -3067,7 +3063,7 @@ bool intel_can_enable_sagv(struct
 drm_atomic_state *state)


    latency = dev_priv->wm.skl_latency[level];

drivers/gpu/drm/i915/intel_pm.c +1 -1
-		if (skl_needs_memory_bw_wa(intel_state) &&
+		if (intel_needs_memory_bw_wa(intel_state) &&

        plane->base.state->fb->modifier == I915_FORMAT_MOD_X_TILED) latency += 15;

drivers/gpu/drm/i915/intel_pm.c +0 -0
@@ -3597,7 +3593,7 @@ static int skl_compute_plane_wm(const

struct
drm_i915_private *dev_priv,
    uint32_t y_min_scanlines;
    struct intel_atomic_state *state = to_intel_atomic_state(cstate->base.state);

drivers/gpu/drm/i915/intel_pm.c +0 -1
-	bool apply_memory_bw_wa =

skl_needs_memory_bw_wa(state);

drivers/gpu/drm/i915/intel_pm.c +1 -0
+	enum watermark_memory_wa mem_wa;

    bool y_tiled, x_tiled;

    if (latency == 0 || !cstate->base.active || !intel_pstate-

Quoted 2 lines

base.visible) {

drivers/gpu/drm/i915/intel_pm.c +0 -0
@@ -3613,7 +3609,8 @@ static int skl_compute_plane_wm(const

struct
drm_i915_private *dev_priv,
    if (IS_KABYLAKE(dev_priv) && dev_priv-

Quoted 1 line

ipc_enabled)

    latency += 4;

drivers/gpu/drm/i915/intel_pm.c +2 -1
-	if (apply_memory_bw_wa && x_tiled)
+	mem_wa = state->wm_results.mem_wa;
+	if (mem_wa != WATERMARK_WA_NONE && x_tiled)

    latency += 15;

    width = drm_rect_width(&intel_pstate->base.src) >> 16;

drivers/gpu/drm/i915/intel_pm.c +0 -0
@@ -3648,7 +3645,7 @@ static int skl_compute_plane_wm(const

struct
drm_i915_private *dev_priv,
    y_min_scanlines = 4;
    }

drivers/gpu/drm/i915/intel_pm.c +1 -1
-	if (apply_memory_bw_wa)
+	if (mem_wa == WATERMARK_WA_Y_TILED)

    y_min_scanlines *= 2;

    plane_bytes_per_line = width * cpp;

drivers/gpu/drm/i915/intel_pm.c +0 -0
@@ -4077,6 +4074,15 @@ skl_compute_ddb(struct

drm_atomic_state
*state)
    }

    /*

drivers/gpu/drm/i915/intel_pm.c +1 -0
+	 * If Watermark workaround is changed we need to

recalculate

drivers/gpu/drm/i915/intel_pm.c +3 -0
+	 * watermark values for all active pipes
+	 */
+	if (intel_state->wm_results.mem_wa != dev_priv-
Quoted 2 lines

wm.skl_hw.mem_wa) {

drivers/gpu/drm/i915/intel_pm.c +5 -0
+		realloc_pipes = ~0;
+		intel_state->wm_results.dirty_pipes = ~0;
+	}
+
+	/*

     * We're not recomputing for the pipes not included in
the
commit, so
     * make sure we start with the current state. */

drivers/gpu/drm/i915/intel_pm.c +0 -0
@@ -4102,6 +4108,129 @@ skl_compute_ddb(struct

drm_atomic_state
*state)
   }

   static void +skl_compute_memory_bandwidth_wm_wa(struct drm_atomic_state *state)

drivers/gpu/drm/i915/intel_pm.c +6 -0
+{
+	struct drm_device *dev = state->dev;
+	struct drm_i915_private *dev_priv = to_i915(dev);
+	struct intel_crtc *intel_crtc;
+	struct intel_plane_state *intel_pstate;
+	struct intel_atomic_state *intel_state =

to_intel_atomic_state(state);

drivers/gpu/drm/i915/intel_pm.c +1 -0
+	struct memdev_info *memdev_info = &dev_priv-
Quoted 2 lines

memdev_info;

drivers/gpu/drm/i915/intel_pm.c +7 -0
+	int num_active_pipes;
+	uint32_t max_pipe_bw_kbps, total_pipe_bw_kbps;
+	int display_bw_percentage;
+	bool y_tile_enabled = false;
+
+	if (!intel_needs_memory_bw_wa(intel_state)) {
+		intel_state->wm_results.mem_wa =

WATERMARK_WA_NONE;

drivers/gpu/drm/i915/intel_pm.c +16 -0
+		return;
+	}
+
+	if (!memdev_info->valid)
+		goto exit;
+
+	max_pipe_bw_kbps = 0;
+	num_active_pipes = 0;
+	for_each_intel_crtc(dev, intel_crtc) {
+		struct intel_crtc_state *cstate;
+		struct intel_plane *plane;
+		int num_active_planes;
+		uint32_t  max_plane_bw_kbps, pipe_bw_kbps;
+
+		/*
+		 * If CRTC is part of current atomic commit,

get
crtc state from

drivers/gpu/drm/i915/intel_pm.c +1 -0
+		 * existing CRTC state. else take the cached

CRTC
state

drivers/gpu/drm/i915/intel_pm.c +4 -0
+		 */
+		cstate = NULL;
+		if (state)
+			cstate =

intel_atomic_get_existing_crtc_state(state,

drivers/gpu/drm/i915/intel_pm.c +3 -0
+					intel_crtc);
+		if (!cstate)
+			cstate =
Quoted 3 lines

to_intel_crtc_state(intel_crtc-

Quoted 2 lines

base.state);

This is really really not allowed. If you want to access crtc->state, you need to get the state.

Quoted 7 lines

Since a w/a forces a full recalculation, best you can do is put the
per
pipe status in crtc_state->wm.skl as well. If it changes you could
add
all other pipes.

I really don't want to add all pipes in "state" until that is necessary
otherwise it'll make our commit huge, that's why getting the cached
state.
Same goes for plane. Later if w/a changes then I'm  adding all the
CRTC's in relloc_pipes mask.

	if (intel_state->wm_results.mem_wa != dev_priv-
Quoted 2 lines

wm.skl_hw.mem_wa)

If I hold the crtc->mutex or plane->mutex lock, It may cause deadlock
with other commits.
I can keep a cached copy of plane memory bandwidth requirement in "dev_priv->wm.skl_hw", but again if there are two parallel commits
it
may cause race.

Quoted 8 lines
Quoted 7 lines

Can you please suggest what is the correct way of getting plane/crtc
state during check phase without have to actually commit them (add
in
global-state),
If any such thing is available in atomic framework?

How often will the workaround status change in practice?

In Linux use-case status changes very rarely, If we connect multiple high resolution display & our DRAM's bandwidth is less we may have to
enable the WA.
& it'll remain there until any display in unplugged OR any modeset with
lower resolution.
On the other hand, In OS with multi-plane enabled, WA may change if any
plane is enabled/disabled (based on total bandwidth requirement for display)

Quoted 6 lines

You could do same as active_crtcs, protect changing the workaround current crtc's workaround mode in dev_priv->wm.skl.wa_state[pipe] with
connection_mutex. If this means changing that the global workaround setting is changed, then also acquire all other crtc states.

Quoted 8 lines

This is not per-CRTC WA, this is complete display-system level WA. & depends upon total memory requirement of display.
As you suggested I can keep the status(bandwidth requirement) for each
pipe in dev_priv->wm.skl.wa_state/bandwidth[pipe], and access it with
some mutex.
Is connection mutex is right mutex to hold, what about wm_mutex?

It's nasty to do so, but it would work. connection_mutex is a ww_mutex. But I don't think this situation will happen often, so if the w/a for current crtc changes, won't it be better to just grab all states anyway? I don't think the optimization is worth the complexity it introduces you run the numbers in normal use.

~Maarten
---------------------------------------------------------------------
Intel International B.V.
Registered in The Netherlands under number 34098535 Statutory seat: Haarlemmermeer
Registered address: Capronilaan 37, 1119NG Schiphol-Rijk

This e-mail and any attachments may contain confidential material for the sole use of the intended recipient(s). Any review or distribution by others is strictly prohibited. If you are not the intended recipient, please contact the sender and delete all copies.
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx

#18 lore raw

✓ Fi.CI.BAT: success for GEN-9 Arbitrated Bandwidth WM WA's & IPC (rev2)

In reply to Mahesh Kumar
== Series Details ==

== Series Details ==

Series: GEN-9 Arbitrated Bandwidth WM WA's & IPC (rev2)
URL : https://patchwork.freedesktop.org/series/15562/
State : success

== Summary ==

Series 15562v2 GEN-9 Arbitrated Bandwidth WM WA's & IPC
https://patchwork.freedesktop.org/api/1.0/series/15562/revisions/2/mbox/

fi-bdw-5557u     total:244  pass:229  dwarn:0   dfail:0   fail:0   skip:15 
fi-bsw-n3050     total:244  pass:204  dwarn:0   dfail:0   fail:0   skip:40 
fi-byt-j1900     total:244  pass:216  dwarn:0   dfail:0   fail:0   skip:28 
fi-byt-n2820     total:244  pass:212  dwarn:0   dfail:0   fail:0   skip:32 
fi-hsw-4770      total:244  pass:224  dwarn:0   dfail:0   fail:0   skip:20 
fi-hsw-4770r     total:244  pass:224  dwarn:0   dfail:0   fail:0   skip:20 
fi-ilk-650       total:244  pass:191  dwarn:0   dfail:0   fail:0   skip:53 
fi-ivb-3520m     total:244  pass:222  dwarn:0   dfail:0   fail:0   skip:22 
fi-ivb-3770      total:244  pass:222  dwarn:0   dfail:0   fail:0   skip:22 
fi-kbl-7200u     total:244  pass:222  dwarn:0   dfail:0   fail:0   skip:22 
fi-skl-6260u     total:244  pass:230  dwarn:0   dfail:0   fail:0   skip:14 
fi-skl-6700hq    total:244  pass:223  dwarn:0   dfail:0   fail:0   skip:21 
fi-skl-6700k     total:244  pass:222  dwarn:1   dfail:0   fail:0   skip:21 
fi-skl-6770hq    total:244  pass:230  dwarn:0   dfail:0   fail:0   skip:14 
fi-snb-2520m     total:244  pass:212  dwarn:0   dfail:0   fail:0   skip:32 
fi-snb-2600      total:244  pass:211  dwarn:0   dfail:0   fail:0   skip:33 

a08f9fc55a649334a2788a804904d920f8b2fda2 drm-intel-nightly: 2016y-11m-23d-20h-25m-10s UTC integration manifest 7ee0d75 drm/i915: Add intel_atomic_get_existing_crtc_state function
8472737 drm/i915/skl+: change WM calc to fixed point 16.16
bc8dd25 drm/i915/bxt: Enable IPC support
4a59efc drm/i915/kbl: IPC workaround for kabylake
e3fe641 drm/i915/bxt: IPC WA for Broxton
667f684 drm/i915/skl: Add variables to check x_tile and y_tile

== Logs ==

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