Skip to contentSkip to conversation

Update PSR/PSR2_SF documenation and Add FBC support

PATCH New Jeevan B 1 participant 5 messages Dec 4, 2023 Library code

lore
Share & tools
lore

Jeevan B

author
#0 lore raw

cover Update PSR/PSR2_SF documenation and Add FBC support

fix kms_psr documentation, subtest naming and add fbc support/test for kms_psr, kms_psr2_sf.

v2: rebase
v3: correct the skip logic for unsupported platform.

Jeevan B (3):
tests/intel/kms_psr: fix subtest naming tests/intel/kms_psr: Add FBC support to PSR/PSR2/PR tests tests/intel/kms_psr2_sf: Add FBC support to PSR2 tests

Swati Sharma (1):
tests/intel/kms_psr: fix documentation

 lib/igt_psr.h             |   5 +
 tests/intel/kms_psr.c     | 572 +++++++++++++++++++----------------
 tests/intel/kms_psr2_sf.c | 609 +++++++++++++++++++++-----------------
 3 files changed, 652 insertions(+), 534 deletions(-)
Signature · 1 line
2.25.1
author
#1 lore raw

PATCH 1/4 tests/intel/kms_psr: fix documentation

From: Swati Sharma <[email protected]>

Optimize documentation and update mega features accordingly.

---
 tests/intel/kms_psr.c | 215 +++++++++++++++---------------------------
 1 file changed, 74 insertions(+), 141 deletions(-)
tests/intel/kms_psr.c +74 -141
index 05bdd7b98..31d6f779c 100644
@@ -43,143 +43,93 @@
 #include "xe/xe_query.h"
 
 /**
- * SUBTEST: psr_basic
- * Description: Basic check for psr if it is detecting changes made in planes
- * Functionality: psr1
+ * SUBTEST: %s_basic
+ * Description: Basic check for %arg[1] if it is detecting changes made in planes
+ * Functionality: %arg[1]
  *
- * SUBTEST: psr_%s_%s
- * Description: Check if psr is detecting memory mapping, rendering and plane
- *              operations performed on %arg[1]
- * Driver requirement: i915
- * Functionality: kms_core, plane, psr1
- *
- * arg[1]:
- *
- * @cursor:             Cursor plane
- * @primary:            Primary plane
- * @sprite:             Sprite plane
- *
- * arg[2]:
+ * SUBTEST: %s_dpms
+ * Description: Check if %arg[1] is detecting changes when rendering operation
+ *              is performed with dpms enabled or disabled
+ * Functionality: %arg[1], dpms
  *
- * @mmap_cpu:           MMAP CPU
- * @mmap_gtt:           MMAP GTT
- */
-
-/**
- * SUBTEST: psr_sprite_plane_move
- * Description: Check if psr is detecting memory mapping, rendering and plane
- *              operations performed on sprite planes
- * Functionality: plane, psr1
+ * SUBTEST: %s_no_drrs
+ * Description: Check if %arg[1] is detecting changes when drrs is disabled
+ * Functionality: %arg[1], drrs
  *
- * SUBTEST: psr_%s_%s
- * Description: Check if psr is detecting memory mapping, rendering and plane
- *              operations performed on %arg[1] planes
- * Functionality: kms_core, plane, psr1
+ * SUBTEST: %s_suspend
+ * Description: Check if %arg[1] is detecting changes when plane operation is
+ *              performed with suspend resume cycles
+ * Functionality: %arg[1], suspend
  *
  * arg[1]:
  *
- * @cursor:             Cursor plane
- * @sprite:             Sprite plane
- *
- * arg[2]:
- *
- * @blt:                Blitter
- * @render:             Render
- * @plane_onoff:        Plane On off
+ * @psr:             psr1
+ * @psr2:            psr2
  */
 
 /**
- * SUBTEST: psr_primary_%s
- * Description: Check if psr is detecting memory mapping, rendering and plane
- *              operations performed on %arg[1] planes
- * Functionality: kms_core, psr1
+ * SUBTEST: %s_%s_%s
+ * Description: Check if %arg[1] is detecting memory mapping %arg[3] operations
+ * 		performed on %arg[2] planes
+ * Driver requirement: i915
+ * Functionality: %arg[1], plane
  *
  * arg[1]:
  *
- * @blt:                Blitter
- * @render:             Render
- */
-
-/**
- * SUBTEST: psr_dpms
- * Description: Check if psr is detecting changes when rendering operation is
- *              performed  with dpms enabled or disabled
- * Functionality: dpms, psr1
- *
- * SUBTEST: psr_no_drrs
- * Description: Check if psr is detecting changes when drrs is disabled
- * Functionality: drrs, psr1
- *
- * SUBTEST: psr_suspend
- * Description: Check if psr is detecting changes when plane operation
- *              is performed with suspend resume cycles
- * Functionality: psr1, suspend
- *
- * SUBTEST: psr2_dpms
- * Description: Check if psr is detecting changes when rendering operation
- *              is performed  with dpms enabled or disabled
- * Functionality: dpms, psr2
- *
- * SUBTEST: psr2_no_drrs
- * Description: Check if psr is detecting changes when drrs is disabled
- * Functionality: drrs, psr2
- *
- * SUBTEST: psr2_suspend
- * Description: Check if psr is detecting changes when plane operation is
- *              performed with suspend resume cycles
- * Functionality: psr2, suspend
- *
- * SUBTEST: psr2_basic
- * Description: Basic check for psr if it is detecting changes made in planes
- * Functionality: psr2
+ * @psr:		psr1
+ * @psr2:		psr2
  *
- * SUBTEST: psr2_%s_%s
- * Description: Check if psr2 is detecting memory mapping, rendering and plane
- *              operations performed on %arg[1] planes
- * Driver requirement: i915
- * Functionality: kms_core, plane, psr2
- *
- * arg[1]:
+ * arg[2]:
  *
  * @cursor:             Cursor plane
  * @primary:            Primary plane
  * @sprite:             Sprite plane
  *
- * arg[2]:
+ * arg[3]:
  *
  * @mmap_cpu:           MMAP CPU
  * @mmap_gtt:           MMAP GTT
  */
 
 /**
- * SUBTEST: psr2_primary_page_flip
- * Description: Check if psr is detecting memory mapping, rendering and plane
- *              operations performed on primary planes
- * Functionality: plane, psr2
+ * SUBTEST: %s_primary_page_flip
+ * Description: Check if %arg[1] is detecting page-flipping operation
+ * 		performed on primary plane
+ * Functionality: %arg[1], plane
  *
- * SUBTEST: psr2_primary_%s
- * Description: Check if psr is detecting memory mapping, rendering and plane
- *              operations performed on primary planes
- * Functionality: kms_core, plane, psr2
+ * SUBTEST: %s_primary_%s
+ * Description: Check if %arg[1] is detecting rendering operations %arg[2]
+ * 		when performed on primary plane
+ * Functionality: %arg[1], plane
  *
  * arg[1]:
  *
+ * @psr:		psr1
+ * @psr2:		psr2
+ *
+ * arg[2]:
+ *
  * @blt:                Blitter
  * @render:             Render
  */
 
 /**
- * SUBTEST: psr2_%s_%s
- * Description: Check if psr is detecting memory mapping, rendering and plane
- *              operations performed on %arg[1] planes
- * Functionality: kms_core, plane, psr2
+ * SUBTEST: %s_%s_%s
+ * Description: Check if %arg[1] is detecting rendering and plane
+ *              operations %arg[3] performed on %arg[2] planes
+ * Functionality: %arg[1], plane
  *
  * arg[1]:
  *
+ * @psr:		psr1
+ * @psr2:		psr2
+ *
+ * arg[2]:
+ *
  * @cursor:             Cursor plane
  * @sprite:             Sprite plane
  *
- * arg[2]:
+ * arg[3]:
  *
  * @blt:                Blitter
  * @render:             Render
@@ -188,36 +138,36 @@
  */
 
 /**
+ * SUBTEST: pr_basic
+ * Description: Basic check for pr if it is detecting changes made in planes
+ * Functionality: pr
+ * Mega feature: DP2.0
+ *
  * SUBTEST: pr_dpms
  * Description: Check if pr is detecting changes when rendering operation
  *              is performed with dpms enabled or disabled
- * Functionality: dpms, pr
- * Mega feature: Panel Replay
+ * Functionality: pr, dpms
+ * Mega feature: DP2.0
  *
  * SUBTEST: pr_no_drrs
  * Description: Check if pr is detecting changes when drrs is disabled
- * Functionality: drrs, pr
- * Mega feature: Panel Replay
+ * Functionality: pr, drrs
+ * Mega feature: DP2.0
  *
  * SUBTEST: pr_suspend
  * Description: Check if pr is detecting changes when plane operation is
  *              performed with suspend resume cycles
  * Functionality: pr, suspend
- * Mega feature: Panel Replay
- *
- * SUBTEST: pr_basic
- * Description: Basic check for pr if it is detecting changes made in planes
- * Functionality: pr
- * Mega feature: Panel Replay
+ * Mega feature: DP2.0
  */
 
 /**
  * SUBTEST: pr_%s_%s
- * Description: Check if pr is detecting memory mapping, rendering and plane
- *              operations performed on %arg[1] planes
+ * Description: Check if pr is detecting memory mapping %arg[2] operations
+ * 		performed on %arg[1] planes
  * Driver requirement: i915
- * Functionality: kms_core, plane, pr
- * Mega feature: Panel Replay
+ * Functionality: pr, plane
+ * Mega feature: DP2.0
  *
  * arg[1]:
  *
@@ -233,16 +183,16 @@
 
 /**
  * SUBTEST: pr_primary_page_flip
- * Description: Check if pr is detecting memory mapping, rendering and plane
- *              operations performed on primary planes
- * Functionality: plane, pr
- * Mega feature: Panel Replay
+ * Description: Check if pr is detecting page-flipping operation
+ * 		performed on primary plane
+ * Functionality: pr, plane
+ * Mega feature: DP2.0
  *
  * SUBTEST: pr_primary_%s
- * Description: Check if pr is detecting memory mapping, rendering and plane
- *              operations performed on primary planes
- * Functionality: kms_core, plane, pr
- * Mega feature: Panel Replay
+ * Description: Check if pr is detecting rendering operations %arg[1]
+ * 		when performed on primary plane
+ * Functionality: pr, plane
+ * Mega feature: DP2.0
  *
  * arg[1]:
  *
@@ -252,10 +202,10 @@
 
 /**
  * SUBTEST: pr_%s_%s
- * Description: Check if pr is detecting memory mapping, rendering and plane
- *              operations performed on %arg[1] planes
- * Functionality: kms_core, plane, pr
- * Mega feature: Panel Replay
+ * Description: Check if pr is detecting rendering and plane
+ *              operations %arg[2] performed on %arg[1] planes
+ * Functionality: pr, plane
+ * Mega feature: DP2.0
  *
  * arg[1]:
  *
@@ -270,23 +220,6 @@
  * @plane_move:         Move plane position
  */
 
-/**
- * SUBTEST: psr_cursor_plane_move
- * Description: Check if psr is detecting the plane operations performed on
- *		cursor planes
- * Functionality: psr1
- *
- * SUBTEST: psr_primary_page_flip
- * Description: Check if psr is detecting page-flipping operations performed
- *		on primary planes
- * Functionality: psr1
- *
- * SUBTEST: psr_sprite_plane_onoff
- * Description: Check if psr is detecting the plane operations performed on
- *		sprite planes
- * Functionality: psr1
- */
-
 enum operations {
 	PAGE_FLIP,
 	MMAP_GTT,
Signature · 1 line
2.25.1
author
#2 lore raw

PATCH 2/4 tests/intel/kms_psr: fix subtest naming

In reply to Jeevan B

update subtest naming from sub_test to sub-test.

---
 tests/intel/kms_psr.c | 72 +++++++++++++++++++++----------------------
 1 file changed, 36 insertions(+), 36 deletions(-)
tests/intel/kms_psr.c +36 -36
index 31d6f779c..aea8b0b3f 100644
@@ -43,20 +43,20 @@
 #include "xe/xe_query.h"
 
 /**
- * SUBTEST: %s_basic
+ * SUBTEST: %s-basic
  * Description: Basic check for %arg[1] if it is detecting changes made in planes
  * Functionality: %arg[1]
  *
- * SUBTEST: %s_dpms
+ * SUBTEST: %s-dpms
  * Description: Check if %arg[1] is detecting changes when rendering operation
  *              is performed with dpms enabled or disabled
  * Functionality: %arg[1], dpms
  *
- * SUBTEST: %s_no_drrs
+ * SUBTEST: %s-no-drrs
  * Description: Check if %arg[1] is detecting changes when drrs is disabled
  * Functionality: %arg[1], drrs
  *
- * SUBTEST: %s_suspend
+ * SUBTEST: %s-suspend
  * Description: Check if %arg[1] is detecting changes when plane operation is
  *              performed with suspend resume cycles
  * Functionality: %arg[1], suspend
@@ -68,7 +68,7 @@
  */
 
 /**
- * SUBTEST: %s_%s_%s
+ * SUBTEST: %s-%s-%s
  * Description: Check if %arg[1] is detecting memory mapping %arg[3] operations
  * 		performed on %arg[2] planes
  * Driver requirement: i915
@@ -87,17 +87,17 @@
  *
  * arg[3]:
  *
- * @mmap_cpu:           MMAP CPU
- * @mmap_gtt:           MMAP GTT
+ * @mmap-cpu:           MMAP CPU
+ * @mmap-gtt:           MMAP GTT
  */
 
 /**
- * SUBTEST: %s_primary_page_flip
+ * SUBTEST: %s-primary-page-flip
  * Description: Check if %arg[1] is detecting page-flipping operation
  * 		performed on primary plane
  * Functionality: %arg[1], plane
  *
- * SUBTEST: %s_primary_%s
+ * SUBTEST: %s-primary-%s
  * Description: Check if %arg[1] is detecting rendering operations %arg[2]
  * 		when performed on primary plane
  * Functionality: %arg[1], plane
@@ -114,7 +114,7 @@
  */
 
 /**
- * SUBTEST: %s_%s_%s
+ * SUBTEST: %s-%s-%s
  * Description: Check if %arg[1] is detecting rendering and plane
  *              operations %arg[3] performed on %arg[2] planes
  * Functionality: %arg[1], plane
@@ -133,28 +133,28 @@
  *
  * @blt:                Blitter
  * @render:             Render
- * @plane_onoff:        Plane On off
- * @plane_move:         Move plane position
+ * @plane-onoff:        Plane On off
+ * @plane-move:         Move plane position
  */
 
 /**
- * SUBTEST: pr_basic
+ * SUBTEST: pr-basic
  * Description: Basic check for pr if it is detecting changes made in planes
  * Functionality: pr
  * Mega feature: DP2.0
  *
- * SUBTEST: pr_dpms
+ * SUBTEST: pr-dpms
  * Description: Check if pr is detecting changes when rendering operation
  *              is performed with dpms enabled or disabled
  * Functionality: pr, dpms
  * Mega feature: DP2.0
  *
- * SUBTEST: pr_no_drrs
+ * SUBTEST: pr-no-drrs
  * Description: Check if pr is detecting changes when drrs is disabled
  * Functionality: pr, drrs
  * Mega feature: DP2.0
  *
- * SUBTEST: pr_suspend
+ * SUBTEST: pr-suspend
  * Description: Check if pr is detecting changes when plane operation is
  *              performed with suspend resume cycles
  * Functionality: pr, suspend
@@ -162,7 +162,7 @@
  */
 
 /**
- * SUBTEST: pr_%s_%s
+ * SUBTEST: pr-%s-%s
  * Description: Check if pr is detecting memory mapping %arg[2] operations
  * 		performed on %arg[1] planes
  * Driver requirement: i915
@@ -177,18 +177,18 @@
  *
  * arg[2]:
  *
- * @mmap_cpu:           MMAP CPU
- * @mmap_gtt:           MMAP GTT
+ * @mmap-cpu:           MMAP CPU
+ * @mmap-gtt:           MMAP GTT
  */
 
 /**
- * SUBTEST: pr_primary_page_flip
+ * SUBTEST: pr-primary-page-flip
  * Description: Check if pr is detecting page-flipping operation
  * 		performed on primary plane
  * Functionality: pr, plane
  * Mega feature: DP2.0
  *
- * SUBTEST: pr_primary_%s
+ * SUBTEST: pr-primary-%s
  * Description: Check if pr is detecting rendering operations %arg[1]
  * 		when performed on primary plane
  * Functionality: pr, plane
@@ -201,7 +201,7 @@
  */
 
 /**
- * SUBTEST: pr_%s_%s
+ * SUBTEST: pr-%s-%s
  * Description: Check if pr is detecting rendering and plane
  *              operations %arg[2] performed on %arg[1] planes
  * Functionality: pr, plane
@@ -216,8 +216,8 @@
  *
  * @blt:                Blitter
  * @render:             Render
- * @plane_onoff:        Plane On off
- * @plane_move:         Move plane position
+ * @plane-onoff:        Plane On off
+ * @plane-move:         Move plane position
  */
 
 enum operations {
@@ -233,13 +233,13 @@ enum operations {
 static const char *op_str(enum operations op)
 {
 	static const char * const name[] = {
-		[PAGE_FLIP] = "page_flip",
-		[MMAP_GTT] = "mmap_gtt",
-		[MMAP_CPU] = "mmap_cpu",
+		[PAGE_FLIP] = "page-flip",
+		[MMAP_GTT] = "mmap-gtt",
+		[MMAP_CPU] = "mmap-cpu",
 		[BLT] = "blt",
 		[RENDER] = "render",
-		[PLANE_MOVE] = "plane_move",
-		[PLANE_ONOFF] = "plane_onoff",
+		[PLANE_MOVE] = "plane-move",
+		[PLANE_ONOFF] = "plane-onoff",
 	};
 
 	return name[op];
@@ -682,9 +682,9 @@ igt_main
 	int z;
 	enum operations op;
 	const char *append_subtest_name[3] = {
-		"psr_",
-		"psr2_",
-		"pr_"
+		"psr-",
+		"psr2-",
+		"pr-"
 	};
 	int modes[] = {PSR_MODE_1, PSR_MODE_2, PR_MODE};
 	igt_output_t *output;
@@ -719,7 +719,7 @@ igt_main
 		}
 
 		igt_describe("Check if psr is detecting changes when drrs is disabled");
-		igt_subtest_with_dynamic_f("%sno_drrs", append_subtest_name[z]) {
+		igt_subtest_with_dynamic_f("%sno-drrs", append_subtest_name[z]) {
 			for_each_connected_output(&data.display, output) {
 				if (!psr_sink_support(data.drm_fd, data.debugfs_fd,
 						      data.op_psr_mode, output))
@@ -738,7 +738,7 @@ igt_main
 		for (op = PAGE_FLIP; op <= RENDER; op++) {
 			igt_describe("Check if psr is detecting page-flipping,memory mapping and "
 					"rendering operations performed on primary planes");
-			igt_subtest_with_dynamic_f("%sprimary_%s",
+			igt_subtest_with_dynamic_f("%sprimary-%s",
 				      append_subtest_name[z],
 				      op_str(op)) {
 				igt_skip_on(is_xe_device(data.drm_fd) &&
@@ -763,7 +763,7 @@ igt_main
 		for (op = MMAP_GTT; op <= PLANE_ONOFF; op++) {
 			igt_describe("Check if psr is detecting memory mapping,rendering "
 					"and plane operations performed on sprite planes");
-			igt_subtest_with_dynamic_f("%ssprite_%s",
+			igt_subtest_with_dynamic_f("%ssprite-%s",
 				      append_subtest_name[z],
 				      op_str(op)) {
 				igt_skip_on(is_xe_device(data.drm_fd) &&
@@ -786,7 +786,7 @@ igt_main
 
 			igt_describe("Check if psr is detecting memory mapping, rendering "
 					"and plane operations performed on cursor planes");
-			igt_subtest_with_dynamic_f("%scursor_%s",
+			igt_subtest_with_dynamic_f("%scursor-%s",
 				      append_subtest_name[z],
 				      op_str(op)) {
 				igt_skip_on(is_xe_device(data.drm_fd) &&
Signature · 1 line
2.25.1
author
#3 lore raw

PATCH 3/4 tests/intel/kms_psr: Add FBC support to PSR/PSR2/PR tests

In reply to Jeevan B

For LunarLake (intel_display_ver 20), FBC can be enabled along with PSR/PSR2/PR, thereby adding FBC checks to validate this scenario.

---
 lib/igt_psr.h         |   5 +
 tests/intel/kms_psr.c | 321 ++++++++++++++++++++++++++++--------------
 2 files changed, 222 insertions(+), 104 deletions(-)
lib/igt_psr.h +5 -0
index a30330e6c..36711c0d4 100644
@@ -40,6 +40,11 @@ enum psr_mode {
 	PSR_DISABLED,
 };
 
+enum fbc_mode {
+	FBC_DISABLED,
+	FBC_ENABLED,
+};
+
 bool psr_disabled_check(int debugfs_fd);
 bool psr2_selective_fetch_check(int debugfs_fd);
 bool psr_wait_entry(int debugfs_fd, enum psr_mode mode, igt_output_t *output);
tests/intel/kms_psr.c +217 -104

508 lines not on this page · raw message

Signature · 1 line
2.25.1
author
#4 lore raw

PATCH 4/4 tests/intel/kms_psr2_sf: Add FBC support to PSR2 tests

In reply to Jeevan B

For LunarLake (intel_display_ver 20), FBC can be enabled along with PSR2, thereby adding FBC checks to validate this scenario.

---
 tests/intel/kms_psr2_sf.c | 609 +++++++++++++++++++++-----------------
 1 file changed, 338 insertions(+), 271 deletions(-)
tests/intel/kms_psr2_sf.c +338 -271
index 27faa93d9..76435f501 100644
@@ -37,6 +37,7 @@
 #include "igt_sysfs.h"
 #include "igt_psr.h"
 #include "kms_dsc_helper.h"
+#include "i915/intel_fbc.h"
 #include <errno.h>
 #include <stdbool.h>
 #include <stdio.h>
@@ -47,6 +48,10 @@
  * Description: Test that selective fetch works on moving %arg[1] plane %arg[2]
  *              visible area (no update)
  *
+ * SUBTEST: fbc-%s-plane-move-continuous-%s
+ * Description: Test that fbc with selective fetch works on moving %arg[1] plane %arg[2]
+ *              visible area (no update)
+ *
  * arg[1]:
  *
  * @cursor:               Cursor
@@ -63,24 +68,46 @@
  * SUBTEST: cursor-plane-update-sf
  * Description: Test that selective fetch works on cursor plane
  *
+ * SUBTEST: fbc-cursor-plane-update-continuous-sf
+ * Description: Test that fbc with selective fetch works on cursor plane
+ *
  * SUBTEST: overlay-plane-update-continuous-sf
  * Description: Test that selective fetch works on overlay plane
  *
+ * SUBTEST: fbc-overlay-plane-update-continuous-sf-dmg-area
+ * Description: Test that fbc with selective fetch works on overlay plane
+ *
  * SUBTEST: overlay-plane-update-sf-dmg-area
  * Description: Test that selective fetch works on overlay plane
  *
+ * SUBTEST: fbc-overlay-plane-update-continuous-sf
+ * Description: Test that fbc with selective fetch works on overlay plane
+ *
  * SUBTEST: overlay-primary-update-sf-dmg-area
  * Description: Test that selective fetch works on primary plane with blended
  *              overlay plane
  *
+ * SUBTEST: fbc-overlay-primary-update-sf-dmg-area
+ * Description: Test that fbc with selective fetch works on primary plane with blended
+ *              overlay plane
+ *
  * SUBTEST: plane-move-sf-dmg-area
  * Description: Test that selective fetch works on moving overlay plane
  *
+ * SUBTEST: fbc-plane-move-sf-dmg-area
+ * Description: Test that fbc with selective fetch works on moving overlay plane
+ *
  * SUBTEST: primary-plane-update-sf-dmg-area
  * Description: Test that selective fetch works on primary plane
  *
+ * SUBTEST: fbc-primary-plane-update-continuous-sf-dmg-area
+ * Description: Test that fbc with selective fetch works on primary plane
+ *
  * SUBTEST: primary-plane-update-sf-dmg-area-big-fb
  * Description: Test that selective fetch works on primary plane with big fb
+ *
+ * SUBTEST: fbc-primary-plane-update-continuous-sf-dmg-area-big-fb
+ * Description: Test that fbc with selective fetch works on primary plane with big fb
  */
 
 IGT_TEST_DESCRIPTION("Tests to varify PSR2 selective fetch by sending multiple"
@@ -131,10 +158,12 @@ typedef struct {
 	struct drm_mode_rect plane_move_clip;
 	struct drm_mode_rect cursor_clip;
 	enum operations op;
+	enum fbc_mode op_fbc_mode;
 	enum plane_move_postion pos;
 	int test_plane_id;
 	igt_plane_t *test_plane;
 	bool big_fb_test;
+	bool fbc_flag;
 	cairo_t *cr;
 	uint32_t screen_changes;
 	int cur_x, cur_y;
@@ -439,6 +468,9 @@ static void prepare(data_t *data)
 	if (data->coexist_feature & FEATURE_DSC)
 		igt_require_f(igt_is_dsc_enabled(data->drm_fd, output->name),
 			      "DSC is not enabled\n");
+	if (data->op_fbc_mode == FBC_ENABLED)
+		igt_require_f(data->fbc_flag,
+			      "Can't test FBC with PSR\n");
 }
 
 static inline void manual(const char *expected)
@@ -840,6 +872,11 @@ static void run(data_t *data)
 
 	igt_assert(psr_wait_entry(data->debugfs_fd, PSR_MODE_2, NULL));
 
+	if (data->fbc_flag == true && data->op_fbc_mode == FBC_ENABLED)
+		igt_assert_f(intel_fbc_wait_until_enabled(data->drm_fd,
+							  data->pipe),
+							  "FBC still disabled");
+
 	data->screen_changes = 0;
 
 	switch (data->op) {
@@ -942,10 +979,15 @@ igt_main
 {
 	data_t data = {};
 	igt_output_t *outputs[IGT_MAX_PIPES * IGT_MAX_PIPES];
-	int i, j, k;
+	int i, j, k, y;
 	int pipes[IGT_MAX_PIPES * IGT_MAX_PIPES];
 	int n_pipes = 0;
 	int coexist_features[IGT_MAX_PIPES * IGT_MAX_PIPES];
+	const char *append_fbc_subtest[2] = {
+		"",
+		"fbc-"
+	};
+	int fbc_status[] = {FBC_DISABLED, FBC_ENABLED};
 
 	igt_fixture {
 		drmModeResPtr res;
@@ -961,6 +1003,11 @@ igt_main
 
 		display_init(&data);
 
+		if ((intel_display_ver(intel_get_drm_devid(data.drm_fd)) >= 20) &&
+		    (intel_fbc_supported_on_chipset(data.drm_fd, data.pipe))) {
+			data.fbc_flag = true;
+		}
+
 		/* Test if PSR2 can be enabled */
 		igt_require_f(psr_enable(data.drm_fd,
 					 data.debugfs_fd, PSR_MODE_2_SEL_FETCH),
@@ -995,54 +1042,116 @@ igt_main
 		}
 	}
 
-	/* Verify primary plane selective fetch */
-	igt_describe("Test that selective fetch works on primary plane");
-	igt_subtest_with_dynamic_f("primary-%s-sf-dmg-area", op_str(data.op)) {
-		for (i = 0; i < n_pipes; i++) {
-			if (!pipe_output_combo_valid(&data.display, pipes[i], outputs[i]))
-				continue;
+	for (y = 0; y < ARRAY_SIZE(fbc_status); y++) {
+		data.op_fbc_mode = fbc_status[y];
+		/* Verify primary plane selective fetch */
+		igt_describe("Test that selective fetch works on primary plane");
+		igt_subtest_with_dynamic_f("%sprimary-%s-sf-dmg-area", append_fbc_subtest[y],
+					   op_str(data.op)) {
+			for (i = 0; i < n_pipes; i++) {
+				if (!pipe_output_combo_valid(&data.display, pipes[i], outputs[i]))
+					continue;
 
-			for (j = FEATURE_NONE; j < FEATURE_COUNT; j++) {
-				if (j != FEATURE_NONE && !(coexist_features[i] & j))
+				for (j = FEATURE_NONE; j < FEATURE_COUNT; j++) {
+					if (j != FEATURE_NONE && !(coexist_features[i] & j))
+						continue;
+					igt_dynamic_f("pipe-%s-%s%s", kmstest_pipe_name(pipes[i]),
+						      igt_output_name(outputs[i]),
+						      coexist_feature_str(j)) {
+						data.pipe = pipes[i];
+						data.output = outputs[i];
+						data.test_plane_id = DRM_PLANE_TYPE_PRIMARY;
+						data.coexist_feature = j;
+						for (k = 1; k <= MAX_DAMAGE_AREAS; k++) {
+							data.damage_area_count = k;
+							prepare(&data);
+							run(&data);
+							cleanup(&data);
+						}
+					}
+				}
+			}
+		}
+
+		/* Verify primary plane selective fetch with big fb */
+		data.big_fb_test = 1;
+		igt_describe("Test that selective fetch works on primary plane with big fb");
+		igt_subtest_with_dynamic_f("%sprimary-%s-sf-dmg-area-big-fb", append_fbc_subtest[y],
+					   op_str(data.op)) {
+			for (i = 0; i < n_pipes; i++) {
+				if (!pipe_output_combo_valid(&data.display, pipes[i], outputs[i]))
 					continue;
-				igt_dynamic_f("pipe-%s-%s%s", kmstest_pipe_name(pipes[i]),
-					      igt_output_name(outputs[i]),
-					      coexist_feature_str(j)) {
-					data.pipe = pipes[i];
-					data.output = outputs[i];
-					data.test_plane_id = DRM_PLANE_TYPE_PRIMARY;
-					data.coexist_feature = j;
-					for (k = 1; k <= MAX_DAMAGE_AREAS; k++) {
-						data.damage_area_count = k;
-						prepare(&data);
-						run(&data);
-						cleanup(&data);
+
+				for (j = FEATURE_NONE; j < FEATURE_COUNT; j++) {
+					if (j != FEATURE_NONE && !(coexist_features[i] & j))
+						continue;
+					igt_dynamic_f("pipe-%s-%s%s", kmstest_pipe_name(pipes[i]),
+						      igt_output_name(outputs[i]),
+						      coexist_feature_str(j)) {
+						data.pipe = pipes[i];
+						data.output = outputs[i];
+						data.test_plane_id = DRM_PLANE_TYPE_PRIMARY;
+						data.coexist_feature = j;
+						for (k = 1; k <= MAX_DAMAGE_AREAS; k++) {
+							data.damage_area_count = k;
+							prepare(&data);
+							run(&data);
+							cleanup(&data);
+						}
 					}
 				}
 			}
 		}
-	}
 
-	/* Verify primary plane selective fetch with big fb */
-	data.big_fb_test = 1;
-	igt_describe("Test that selective fetch works on primary plane with big fb");
-	igt_subtest_with_dynamic_f("primary-%s-sf-dmg-area-big-fb", op_str(data.op)) {
-		for (i = 0; i < n_pipes; i++) {
-			if (!pipe_output_combo_valid(&data.display, pipes[i], outputs[i]))
-				continue;
+		data.big_fb_test = 0;
+		/* Verify overlay plane selective fetch */
+		igt_describe("Test that selective fetch works on overlay plane");
+		igt_subtest_with_dynamic_f("%soverlay-%s-sf-dmg-area", append_fbc_subtest[y],
+					   op_str(data.op)) {
+			for (i = 0; i < n_pipes; i++) {
+				if (!pipe_output_combo_valid(&data.display, pipes[i], outputs[i]))
+					continue;
+
+				for (j = FEATURE_NONE; j < FEATURE_COUNT; j++) {
+					if (j != FEATURE_NONE && !(coexist_features[i] & j))
+						continue;
+					igt_dynamic_f("pipe-%s-%s%s", kmstest_pipe_name(pipes[i]),
+						      igt_output_name(outputs[i]),
+						      coexist_feature_str(j)) {
+						data.pipe = pipes[i];
+						data.output = outputs[i];
+						data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
+						data.coexist_feature = j;
+						for (k = 1; k <= MAX_DAMAGE_AREAS; k++) {
+							data.damage_area_count = k;
+							prepare(&data);
+							run(&data);
+							cleanup(&data);
+						}
+					}
+				}
+			}
+		}
 
-			for (j = FEATURE_NONE; j < FEATURE_COUNT; j++) {
-				if (j != FEATURE_NONE && !(coexist_features[i] & j))
+		data.damage_area_count = 1;
+		/* Verify cursor plane selective fetch */
+		igt_describe("Test that selective fetch works on cursor plane");
+		igt_subtest_with_dynamic_f("%scursor-%s-sf", append_fbc_subtest[y],
+					   op_str(data.op)) {
+			for (i = 0; i < n_pipes; i++) {
+				if (!pipe_output_combo_valid(&data.display, pipes[i], outputs[i]))
 					continue;
-				igt_dynamic_f("pipe-%s-%s%s", kmstest_pipe_name(pipes[i]),
-					      igt_output_name(outputs[i]),
-					      coexist_feature_str(j)) {
-					data.pipe = pipes[i];
-					data.output = outputs[i];
-					data.test_plane_id = DRM_PLANE_TYPE_PRIMARY;
-					data.coexist_feature = j;
-					for (k = 1; k <= MAX_DAMAGE_AREAS; k++) {
-						data.damage_area_count = k;
+
+				for (j = FEATURE_NONE; j < FEATURE_COUNT; j++) {
+					if (j != FEATURE_NONE && !(coexist_features[i] & j))
+						continue;
+					igt_dynamic_f("pipe-%s-%s%s", kmstest_pipe_name(pipes[i]),
+						      igt_output_name(outputs[i]),
+						      coexist_feature_str(j)) {
+						data.pipe = pipes[i];
+						data.output = outputs[i];
+						data.test_plane_id = DRM_PLANE_TYPE_CURSOR;
+						data.coexist_feature = j;
 						prepare(&data);
 						run(&data);
 						cleanup(&data);
@@ -1050,28 +1159,25 @@ igt_main
 				}
 			}
 		}
-	}
-
-	data.big_fb_test = 0;
-	/* Verify overlay plane selective fetch */
-	igt_describe("Test that selective fetch works on overlay plane");
-	igt_subtest_with_dynamic_f("overlay-%s-sf-dmg-area", op_str(data.op)) {
-		for (i = 0; i < n_pipes; i++) {
-			if (!pipe_output_combo_valid(&data.display, pipes[i], outputs[i]))
-				continue;
 
-			for (j = FEATURE_NONE; j < FEATURE_COUNT; j++) {
-				if (j != FEATURE_NONE && !(coexist_features[i] & j))
+		data.op = PLANE_MOVE_CONTINUOUS;
+		igt_describe("Test that selective fetch works on moving cursor plane (no update)");
+		igt_subtest_with_dynamic_f("%scursor-%s-sf", append_fbc_subtest[y],
+					   op_str(data.op)) {
+			for (i = 0; i < n_pipes; i++) {
+				if (!pipe_output_combo_valid(&data.display, pipes[i], outputs[i]))
 					continue;
-				igt_dynamic_f("pipe-%s-%s%s", kmstest_pipe_name(pipes[i]),
-					      igt_output_name(outputs[i]),
-					      coexist_feature_str(j)) {
-					data.pipe = pipes[i];
-					data.output = outputs[i];
-					data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
-					data.coexist_feature = j;
-					for (k = 1; k <= MAX_DAMAGE_AREAS; k++) {
-						data.damage_area_count = k;
+
+				for (j = FEATURE_NONE; j < FEATURE_COUNT; j++) {
+					if (j != FEATURE_NONE && !(coexist_features[i] & j))
+						continue;
+					igt_dynamic_f("pipe-%s-%s%s", kmstest_pipe_name(pipes[i]),
+						      igt_output_name(outputs[i]),
+						      coexist_feature_str(j)) {
+						data.pipe = pipes[i];
+						data.output = outputs[i];
+						data.test_plane_id = DRM_PLANE_TYPE_CURSOR;
+						data.coexist_feature = j;
 						prepare(&data);
 						run(&data);
 						cleanup(&data);
@@ -1079,130 +1185,137 @@ igt_main
 				}
 			}
 		}
-	}
 
-	data.damage_area_count = 1;
-	/* Verify cursor plane selective fetch */
-	igt_describe("Test that selective fetch works on cursor plane");
-	igt_subtest_with_dynamic_f("cursor-%s-sf", op_str(data.op)) {
-		for (i = 0; i < n_pipes; i++) {
-			if (!pipe_output_combo_valid(&data.display, pipes[i], outputs[i]))
-				continue;
-
-			for (j = FEATURE_NONE; j < FEATURE_COUNT; j++) {
-				if (j != FEATURE_NONE && !(coexist_features[i] & j))
+		data.op = PLANE_MOVE_CONTINUOUS_EXCEED;
+		igt_describe("Test that selective fetch works on moving cursor plane exceeding "
+			     "partially visible area (no update)");
+		igt_subtest_with_dynamic_f("%scursor-%s-sf", append_fbc_subtest[y],
+					   op_str(data.op)) {
+			for (i = 0; i < n_pipes; i++) {
+				if (!pipe_output_combo_valid(&data.display, pipes[i], outputs[i]))
 					continue;
-				igt_dynamic_f("pipe-%s-%s%s", kmstest_pipe_name(pipes[i]),
-					      igt_output_name(outputs[i]),
-					      coexist_feature_str(j)) {
-					data.pipe = pipes[i];
-					data.output = outputs[i];
-					data.test_plane_id = DRM_PLANE_TYPE_CURSOR;
-					data.coexist_feature = j;
-					prepare(&data);
-					run(&data);
-					cleanup(&data);
+
+				for (j = FEATURE_NONE; j < FEATURE_COUNT; j++) {
+					if (j != FEATURE_NONE && !(coexist_features[i] & j))
+						continue;
+					igt_dynamic_f("pipe-%s-%s%s", kmstest_pipe_name(pipes[i]),
+						      igt_output_name(outputs[i]),
+						      coexist_feature_str(j)) {
+						data.pipe = pipes[i];
+						data.output = outputs[i];
+						data.test_plane_id = DRM_PLANE_TYPE_CURSOR;
+						data.coexist_feature = j;
+						prepare(&data);
+						run(&data);
+						cleanup(&data);
+					}
 				}
 			}
 		}
-	}
-
-	data.op = PLANE_MOVE_CONTINUOUS;
-	igt_describe("Test that selective fetch works on moving cursor plane (no update)");
-	igt_subtest_with_dynamic_f("cursor-%s-sf", op_str(data.op)) {
-		for (i = 0; i < n_pipes; i++) {
-			if (!pipe_output_combo_valid(&data.display, pipes[i], outputs[i]))
-				continue;
 
-			for (j = FEATURE_NONE; j < FEATURE_COUNT; j++) {
-				if (j != FEATURE_NONE && !(coexist_features[i] & j))
+		data.op = PLANE_MOVE_CONTINUOUS_EXCEED_FULLY;
+		igt_describe("Test that selective fetch works on moving cursor plane exceeding "
+			     "fully visible area (no update)");
+		igt_subtest_with_dynamic_f("%scursor-%s-sf", append_fbc_subtest[y],
+					   op_str(data.op)) {
+			for (i = 0; i < n_pipes; i++) {
+				if (!pipe_output_combo_valid(&data.display, pipes[i], outputs[i]))
 					continue;
-				igt_dynamic_f("pipe-%s-%s%s", kmstest_pipe_name(pipes[i]),
-					      igt_output_name(outputs[i]),
-					      coexist_feature_str(j)) {
-					data.pipe = pipes[i];
-					data.output = outputs[i];
-					data.test_plane_id = DRM_PLANE_TYPE_CURSOR;
-					data.coexist_feature = j;
-					prepare(&data);
-					run(&data);
-					cleanup(&data);
+
+				for (j = FEATURE_NONE; j < FEATURE_COUNT; j++) {
+					if (j != FEATURE_NONE && !(coexist_features[i] & j))
+						continue;
+					igt_dynamic_f("pipe-%s-%s%s", kmstest_pipe_name(pipes[i]),
+						      igt_output_name(outputs[i]),
+						      coexist_feature_str(j)) {
+						data.pipe = pipes[i];
+						data.output = outputs[i];
+						data.test_plane_id = DRM_PLANE_TYPE_CURSOR;
+						data.coexist_feature = j;
+						prepare(&data);
+						run(&data);
+						cleanup(&data);
+					}
 				}
 			}
 		}
-	}
-
-	data.op = PLANE_MOVE_CONTINUOUS_EXCEED;
-	igt_describe("Test that selective fetch works on moving cursor plane exceeding partially visible area (no update)");
-	igt_subtest_with_dynamic_f("cursor-%s-sf", op_str(data.op)) {
-		for (i = 0; i < n_pipes; i++) {
-			if (!pipe_output_combo_valid(&data.display, pipes[i], outputs[i]))
-				continue;
 
-			for (j = FEATURE_NONE; j < FEATURE_COUNT; j++) {
-				if (j != FEATURE_NONE && !(coexist_features[i] & j))
+		/* Only for overlay plane */
+		data.op = PLANE_MOVE;
+		/* Verify overlay plane move selective fetch */
+		igt_describe("Test that selective fetch works on moving overlay plane");
+		igt_subtest_with_dynamic_f("%s%s-sf-dmg-area", append_fbc_subtest[y],
+					   op_str(data.op)) {
+			for (i = 0; i < n_pipes; i++) {
+				if (!pipe_output_combo_valid(&data.display, pipes[i], outputs[i]))
 					continue;
-				igt_dynamic_f("pipe-%s-%s%s", kmstest_pipe_name(pipes[i]),
-					      igt_output_name(outputs[i]),
-					      coexist_feature_str(j)) {
-					data.pipe = pipes[i];
-					data.output = outputs[i];
-					data.test_plane_id = DRM_PLANE_TYPE_CURSOR;
-					data.coexist_feature = j;
-					prepare(&data);
-					run(&data);
-					cleanup(&data);
+
+				for (j = FEATURE_NONE; j < FEATURE_COUNT; j++) {
+					if (j != FEATURE_NONE && !(coexist_features[i] & j))
+						continue;
+					igt_dynamic_f("pipe-%s-%s%s", kmstest_pipe_name(pipes[i]),
+						      igt_output_name(outputs[i]),
+						      coexist_feature_str(j)) {
+						data.pipe = pipes[i];
+						data.output = outputs[i];
+						data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
+						data.coexist_feature = j;
+						for (k = POS_TOP_LEFT; k <= POS_BOTTOM_RIGHT ; k++) {
+							data.pos = k;
+							prepare(&data);
+							run(&data);
+							cleanup(&data);
+						}
+					}
 				}
 			}
 		}
-	}
 
-	data.op = PLANE_MOVE_CONTINUOUS_EXCEED_FULLY;
-	igt_describe("Test that selective fetch works on moving cursor plane exceeding fully visible area (no update)");
-	igt_subtest_with_dynamic_f("cursor-%s-sf", op_str(data.op)) {
-		for (i = 0; i < n_pipes; i++) {
-			if (!pipe_output_combo_valid(&data.display, pipes[i], outputs[i]))
-				continue;
-
-			for (j = FEATURE_NONE; j < FEATURE_COUNT; j++) {
-				if (j != FEATURE_NONE && !(coexist_features[i] & j))
+		data.op = PLANE_MOVE_CONTINUOUS;
+		igt_describe("Test that selective fetch works on moving overlay plane (no update)");
+		igt_subtest_with_dynamic_f("%soverlay-%s-sf", append_fbc_subtest[y],
+					   op_str(data.op)) {
+			for (i = 0; i < n_pipes; i++) {
+				if (!pipe_output_combo_valid(&data.display, pipes[i], outputs[i]))
 					continue;
-				igt_dynamic_f("pipe-%s-%s%s", kmstest_pipe_name(pipes[i]),
-					      igt_output_name(outputs[i]),
-					      coexist_feature_str(j)) {
+
+				for (j = FEATURE_NONE; j < FEATURE_COUNT; j++) {
+					if (j != FEATURE_NONE && !(coexist_features[i] & j))
+						continue;
+					igt_dynamic_f("pipe-%s-%s%s", kmstest_pipe_name(pipes[i]),
+						      igt_output_name(outputs[i]),
+						      coexist_feature_str(j)) {
 					data.pipe = pipes[i];
 					data.output = outputs[i];
-					data.test_plane_id = DRM_PLANE_TYPE_CURSOR;
+					data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
 					data.coexist_feature = j;
 					prepare(&data);
 					run(&data);
 					cleanup(&data);
+					}
 				}
 			}
 		}
-	}
 
-	/* Only for overlay plane */
-	data.op = PLANE_MOVE;
-	/* Verify overlay plane move selective fetch */
-	igt_describe("Test that selective fetch works on moving overlay plane");
-	igt_subtest_with_dynamic_f("%s-sf-dmg-area", op_str(data.op)) {
-		for (i = 0; i < n_pipes; i++) {
-			if (!pipe_output_combo_valid(&data.display, pipes[i], outputs[i]))
-				continue;
-
-			for (j = FEATURE_NONE; j < FEATURE_COUNT; j++) {
-				if (j != FEATURE_NONE && !(coexist_features[i] & j))
+		data.op = PLANE_MOVE_CONTINUOUS_EXCEED;
+		igt_describe("Test that selective fetch works on moving overlay plane partially "
+			     "exceeding visible area (no update)");
+		igt_subtest_with_dynamic_f("%soverlay-%s-sf", append_fbc_subtest[y],
+					   op_str(data.op)) {
+			for (i = 0; i < n_pipes; i++) {
+				if (!pipe_output_combo_valid(&data.display, pipes[i], outputs[i]))
 					continue;
-				igt_dynamic_f("pipe-%s-%s%s", kmstest_pipe_name(pipes[i]),
-					      igt_output_name(outputs[i]),
-					      coexist_feature_str(j)) {
-					data.pipe = pipes[i];
-					data.output = outputs[i];
-					data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
-					data.coexist_feature = j;
-					for (k = POS_TOP_LEFT; k <= POS_BOTTOM_RIGHT ; k++) {
-						data.pos = k;
+
+				for (j = FEATURE_NONE; j < FEATURE_COUNT; j++) {
+					if (j != FEATURE_NONE && !(coexist_features[i] & j))
+						continue;
+					igt_dynamic_f("pipe-%s-%s%s", kmstest_pipe_name(pipes[i]),
+						      igt_output_name(outputs[i]),
+						      coexist_feature_str(j)) {
+						data.pipe = pipes[i];
+						data.output = outputs[i];
+						data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
+						data.coexist_feature = j;
 						prepare(&data);
 						run(&data);
 						cleanup(&data);
@@ -1210,103 +1323,88 @@ igt_main
 				}
 			}
 		}
-	}
-
-	data.op = PLANE_MOVE_CONTINUOUS;
-	igt_describe("Test that selective fetch works on moving overlay plane (no update)");
-	igt_subtest_with_dynamic_f("overlay-%s-sf", op_str(data.op)) {
-		for (i = 0; i < n_pipes; i++) {
-			if (!pipe_output_combo_valid(&data.display, pipes[i], outputs[i]))
-				continue;
 
-			for (j = FEATURE_NONE; j < FEATURE_COUNT; j++) {
-				if (j != FEATURE_NONE && !(coexist_features[i] & j))
+		data.op = PLANE_MOVE_CONTINUOUS_EXCEED_FULLY;
+		igt_describe("Test that selective fetch works on moving overlay plane fully "
+			     "exceeding visible area (no update)");
+		igt_subtest_with_dynamic_f("%soverlay-%s-sf", append_fbc_subtest[y],
+					   op_str(data.op)) {
+			for (i = 0; i < n_pipes; i++) {
+				if (!pipe_output_combo_valid(&data.display, pipes[i], outputs[i]))
 					continue;
-				igt_dynamic_f("pipe-%s-%s%s", kmstest_pipe_name(pipes[i]),
-					      igt_output_name(outputs[i]),
-					      coexist_feature_str(j)) {
-				data.pipe = pipes[i];
-				data.output = outputs[i];
-				data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
-				data.coexist_feature = j;
-				prepare(&data);
-				run(&data);
-				cleanup(&data);
-				}
-			}
-		}
-	}
-
-	data.op = PLANE_MOVE_CONTINUOUS_EXCEED;
-	igt_describe("Test that selective fetch works on moving overlay plane partially exceeding visible area (no update)");
-	igt_subtest_with_dynamic_f("overlay-%s-sf", op_str(data.op)) {
-		for (i = 0; i < n_pipes; i++) {
-			if (!pipe_output_combo_valid(&data.display, pipes[i], outputs[i]))
-				continue;
 
-			for (j = FEATURE_NONE; j < FEATURE_COUNT; j++) {
-				if (j != FEATURE_NONE && !(coexist_features[i] & j))
-					continue;
-				igt_dynamic_f("pipe-%s-%s%s", kmstest_pipe_name(pipes[i]),
-					      igt_output_name(outputs[i]),
-					      coexist_feature_str(j)) {
-					data.pipe = pipes[i];
-					data.output = outputs[i];
-					data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
-					data.coexist_feature = j;
-					prepare(&data);
-					run(&data);
-					cleanup(&data);
+				for (j = FEATURE_NONE; j < FEATURE_COUNT; j++) {
+					if (j != FEATURE_NONE && !(coexist_features[i] & j))
+						continue;
+					igt_dynamic_f("pipe-%s-%s%s", kmstest_pipe_name(pipes[i]),
+						      igt_output_name(outputs[i]),
+						      coexist_feature_str(j)) {
+						data.pipe = pipes[i];
+						data.output = outputs[i];
+						data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
+						data.coexist_feature = j;
+						prepare(&data);
+						run(&data);
+						cleanup(&data);
+					}
 				}
 			}
 		}
-	}
 
-	data.op = PLANE_MOVE_CONTINUOUS_EXCEED_FULLY;
-	igt_describe("Test that selective fetch works on moving overlay plane fully exceeding visible area (no update)");
-	igt_subtest_with_dynamic_f("overlay-%s-sf", op_str(data.op)) {
-		for (i = 0; i < n_pipes; i++) {
-			if (!pipe_output_combo_valid(&data.display, pipes[i], outputs[i]))
-				continue;
-
-			for (j = FEATURE_NONE; j < FEATURE_COUNT; j++) {
-				if (j != FEATURE_NONE && !(coexist_features[i] & j))
+		/* Verify primary plane selective fetch with overplay plane blended */
+		data.op = OVERLAY_PRIM_UPDATE;
+		igt_describe("Test that selective fetch works on primary plane "
+			     "with blended overlay plane");
+		igt_subtest_with_dynamic_f("%s%s-sf-dmg-area", append_fbc_subtest[y],
+					   op_str(data.op)) {
+			for (i = 0; i < n_pipes; i++) {
+				if (!pipe_output_combo_valid(&data.display, pipes[i], outputs[i]))
 					continue;
-				igt_dynamic_f("pipe-%s-%s%s", kmstest_pipe_name(pipes[i]),
-					      igt_output_name(outputs[i]),
-					      coexist_feature_str(j)) {
-					data.pipe = pipes[i];
-					data.output = outputs[i];
-					data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
-					data.coexist_feature = j;
-					prepare(&data);
-					run(&data);
-					cleanup(&data);
+
+				for (j = FEATURE_NONE; j < FEATURE_COUNT; j++) {
+					if (j != FEATURE_NONE && !(coexist_features[i] & j))
+						continue;
+					igt_dynamic_f("pipe-%s-%s%s", kmstest_pipe_name(pipes[i]),
+						      igt_output_name(outputs[i]),
+						      coexist_feature_str(j)) {
+						data.pipe = pipes[i];
+						data.output = outputs[i];
+						for (k = 1; k <= MAX_DAMAGE_AREAS; k++) {
+							data.damage_area_count = k;
+							data.test_plane_id = DRM_PLANE_TYPE_PRIMARY;
+							data.coexist_feature = j;
+							prepare(&data);
+							run(&data);
+							cleanup(&data);
+						}
+					}
 				}
 			}
 		}
-	}
 
-	/* Verify primary plane selective fetch with overplay plane blended */
-	data.op = OVERLAY_PRIM_UPDATE;
-	igt_describe("Test that selective fetch works on primary plane "
-		     "with blended overlay plane");
-	igt_subtest_with_dynamic_f("%s-sf-dmg-area", op_str(data.op)) {
-		for (i = 0; i < n_pipes; i++) {
-			if (!pipe_output_combo_valid(&data.display, pipes[i], outputs[i]))
-				continue;
-
-			for (j = FEATURE_NONE; j < FEATURE_COUNT; j++) {
-				if (j != FEATURE_NONE && !(coexist_features[i] & j))
+		/*
+		 * Verify overlay plane selective fetch using NV12 primary
+		 * plane and continuous updates.
+		 */
+		data.op = PLANE_UPDATE_CONTINUOUS;
+		data.primary_format = DRM_FORMAT_NV12;
+		igt_describe("Test that selective fetch works on overlay plane");
+		igt_subtest_with_dynamic_f("%soverlay-%s-sf", append_fbc_subtest[y],
+					   op_str(data.op)) {
+			for (i = 0; i < n_pipes; i++) {
+				if (!pipe_output_combo_valid(&data.display, pipes[i], outputs[i]))
 					continue;
-				igt_dynamic_f("pipe-%s-%s%s", kmstest_pipe_name(pipes[i]),
-					      igt_output_name(outputs[i]),
-					      coexist_feature_str(j)) {
-					data.pipe = pipes[i];
-					data.output = outputs[i];
-					for (k = 1; k <= MAX_DAMAGE_AREAS; k++) {
-						data.damage_area_count = k;
-						data.test_plane_id = DRM_PLANE_TYPE_PRIMARY;
+
+				for (j = FEATURE_NONE; j < FEATURE_COUNT; j++) {
+					if (j != FEATURE_NONE && !(coexist_features[i] & j))
+						continue;
+					igt_dynamic_f("pipe-%s-%s%s", kmstest_pipe_name(pipes[i]),
+						      igt_output_name(outputs[i]),
+						      coexist_feature_str(j)) {
+						data.pipe = pipes[i];
+						data.output = outputs[i];
+						data.damage_area_count = 1;
+						data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
 						data.coexist_feature = j;
 						prepare(&data);
 						run(&data);
@@ -1317,37 +1415,6 @@ igt_main
 		}
 	}
 
-	/*
-	 * Verify overlay plane selective fetch using NV12 primary
-	 * plane and continuous updates.
-	 */
-	data.op = PLANE_UPDATE_CONTINUOUS;
-	data.primary_format = DRM_FORMAT_NV12;
-	igt_describe("Test that selective fetch works on overlay plane");
-	igt_subtest_with_dynamic_f("overlay-%s-sf", op_str(data.op)) {
-		for (i = 0; i < n_pipes; i++) {
-			if (!pipe_output_combo_valid(&data.display, pipes[i], outputs[i]))
-				continue;
-
-			for (j = FEATURE_NONE; j < FEATURE_COUNT; j++) {
-				if (j != FEATURE_NONE && !(coexist_features[i] & j))
-					continue;
-				igt_dynamic_f("pipe-%s-%s%s", kmstest_pipe_name(pipes[i]),
-					      igt_output_name(outputs[i]),
-					      coexist_feature_str(j)) {
-					data.pipe = pipes[i];
-					data.output = outputs[i];
-					data.damage_area_count = 1;
-					data.test_plane_id = DRM_PLANE_TYPE_OVERLAY;
-					data.coexist_feature = j;
-					prepare(&data);
-					run(&data);
-					cleanup(&data);
-				}
-			}
-		}
-	}
-
 	igt_fixture {
 		close(data.debugfs_fd);
 		display_fini(&data);
Signature · 1 line
2.25.1