From: Yuling Li <Yuling.Li@amd.com>
To: <igt-dev@lists.freedesktop.org>
Cc: <vitaly.prosyak@amd.com>, Yuling Li <Yuling.Li@amd.com>
Subject: [PATCH i-g-t] tests/kms_plane_cursor: add native cursor test with multiple overlays
Date: Fri, 20 Nov 2026 15:30:49 +0800 [thread overview]
Message-ID: <20261120073049.91138-1-Yuling.Li@amd.com> (raw)
Exercise native cursor visibility while three overlay planes are
switched between quadrant positions.
This reproduces incorrect cursor suppression when a split overlay
is mistaken for a split partner that covers the lower pipe.
The issue exposed by this test was fixed in Linux kernel.
Signed-off-by: Yuling Li <Yuling.Li@amd.com>
---
tests/kms_plane_cursor.c | 233 ++++++++++++++++++++++++++++++++++++++-
1 file changed, 228 insertions(+), 5 deletions(-)
diff --git a/tests/kms_plane_cursor.c b/tests/kms_plane_cursor.c
index 4b69f1a17..48e5a1c13 100644
--- a/tests/kms_plane_cursor.c
+++ b/tests/kms_plane_cursor.c
@@ -24,7 +24,7 @@
* TEST: kms plane cursor
* Category: Display
* Description: Tests cursor interactions with primary and overlay planes.
- * Driver requirement: i915, xe
+ * Driver requirement: i915, xe, amdgpu
* Mega feature: General Display Features
*/
@@ -37,6 +37,10 @@
* SUBTEST: primary
* Description: Tests atomic cursor positioning on primary plane
*
+ * SUBTEST: multi-overlay
+ * Description: Tests native cursor positioning with three overlays arranged in
+ * quadrants while switching their positions
+ *
* SUBTEST: viewport
* Description: Tests atomic cursor positioning on primary plane and overlay plane
* with buffer larger than viewport used for display
@@ -47,13 +51,14 @@
*
* Some assumptions made:
* - Cursor planes can be placed on top of overlay planes
- * - DRM index indicates z-ordering, higher index = higher z-order
+ * - Overlay z-order follows zpos, with plane ID used to break ties
*/
enum {
TEST_PRIMARY = 0,
TEST_OVERLAY = 1 << 0,
TEST_VIEWPORT = 1 << 1,
+ TEST_MPO = 1 << 2,
};
typedef struct {
@@ -73,6 +78,7 @@ typedef struct data {
igt_display_t display;
igt_plane_t *primary;
igt_plane_t *overlay;
+ igt_plane_t *overlays[3];
igt_plane_t *cursor;
igt_output_t *output;
igt_crtc_t *crtc;
@@ -81,6 +87,7 @@ typedef struct data {
igt_fb_t ref_fb;
igt_fb_t pfb;
igt_fb_t ofb;
+ igt_fb_t mpo_fbs[3];
igt_fb_t cfb;
int drm_fd;
rect_t rect;
@@ -88,6 +95,49 @@ typedef struct data {
uint64_t max_curh;
} data_t;
+enum quadrant {
+ TOP_LEFT,
+ TOP_RIGHT,
+ BOTTOM_LEFT,
+ BOTTOM_RIGHT,
+ QUADRANT_COUNT,
+};
+
+static const enum quadrant mpo_slots[3][3] = {
+ { TOP_RIGHT, BOTTOM_RIGHT, BOTTOM_LEFT },
+ { BOTTOM_RIGHT, BOTTOM_LEFT, TOP_RIGHT },
+ { BOTTOM_LEFT, TOP_RIGHT, BOTTOM_RIGHT },
+};
+
+static const double mpo_colors[3][3] = {
+ { 0.25, 0.25, 0.25 },
+ { 0.50, 0.50, 0.50 },
+ { 0.75, 0.75, 0.75 },
+};
+
+static int plane_zpos_cmp(const void *left, const void *right)
+{
+ igt_plane_t *plane_left = *(igt_plane_t * const *)left;
+ igt_plane_t *plane_right = *(igt_plane_t * const *)right;
+ uint64_t zpos_left = 0, zpos_right = 0;
+
+ if (igt_plane_has_prop(plane_left, IGT_PLANE_ZPOS) &&
+ igt_plane_has_prop(plane_right, IGT_PLANE_ZPOS)) {
+ zpos_left = igt_plane_get_prop(plane_left, IGT_PLANE_ZPOS);
+ zpos_right = igt_plane_get_prop(plane_right, IGT_PLANE_ZPOS);
+ }
+
+ if (zpos_left < zpos_right)
+ return -1;
+ if (zpos_left > zpos_right)
+ return 1;
+ if (plane_left->drm_plane->plane_id < plane_right->drm_plane->plane_id)
+ return -1;
+ if (plane_left->drm_plane->plane_id > plane_right->drm_plane->plane_id)
+ return 1;
+ return 0;
+}
+
/* Common test setup. */
static void test_init(data_t *data, igt_crtc_t *crtc, igt_output_t *output,
unsigned int flags)
@@ -99,9 +149,20 @@ static void test_init(data_t *data, igt_crtc_t *crtc, igt_output_t *output,
data->primary = igt_crtc_get_plane_type(data->crtc,
DRM_PLANE_TYPE_PRIMARY);
- if (flags & TEST_OVERLAY)
+ data->overlay = NULL;
+ memset(data->overlays, 0, sizeof(data->overlays));
+ if (flags & TEST_MPO) {
+ for (int i = 0; i < ARRAY_SIZE(data->overlays); i++)
+ data->overlays[i] =
+ igt_crtc_get_plane_type_index(data->crtc,
+ DRM_PLANE_TYPE_OVERLAY,
+ i);
+ qsort(data->overlays, ARRAY_SIZE(data->overlays),
+ sizeof(data->overlays[0]), plane_zpos_cmp);
+ } else if (flags & TEST_OVERLAY) {
data->overlay = igt_crtc_get_plane_type(data->crtc,
DRM_PLANE_TYPE_OVERLAY);
+ }
data->cursor = igt_crtc_get_plane_type(data->crtc,
DRM_PLANE_TYPE_CURSOR);
@@ -127,10 +188,40 @@ static void test_fini(data_t *data)
igt_plane_set_fb(data->primary, NULL);
if (data->overlay)
igt_plane_set_fb(data->overlay, NULL);
+ for (int i = 0; i < ARRAY_SIZE(data->overlays); i++)
+ if (data->overlays[i])
+ igt_plane_set_fb(data->overlays[i], NULL);
igt_plane_set_fb(data->cursor, NULL);
igt_display_commit2(&data->display, COMMIT_ATOMIC);
}
+static rect_t quadrant_rect(const data_t *data, enum quadrant quadrant)
+{
+ int split_x = (data->mode->hdisplay + 1) / 2;
+ int split_y = (data->mode->vdisplay + 1) / 2;
+ rect_t rect = {
+ .x = quadrant == TOP_RIGHT || quadrant == BOTTOM_RIGHT ?
+ split_x : 0,
+ .y = quadrant == BOTTOM_LEFT || quadrant == BOTTOM_RIGHT ?
+ split_y : 0,
+ };
+
+ rect.w = rect.x ? data->mode->hdisplay - split_x : split_x;
+ rect.h = rect.y ? data->mode->vdisplay - split_y : split_y;
+ return rect;
+}
+
+static pos_t quadrant_cursor_pos(const data_t *data, int size,
+ enum quadrant quadrant)
+{
+ rect_t rect = quadrant_rect(data, quadrant);
+
+ return (pos_t) {
+ .x = rect.x + (rect.w - size) / 2,
+ .y = rect.y + (rect.h - size) / 2,
+ };
+}
+
/*
* Draws white and gray (if overlay FB is given) on the primary FB.
* Draws a magenta square where the cursor should be over top both planes.
@@ -239,10 +330,117 @@ static void test_cursor_spots(data_t *data, int size, unsigned int flags)
}
}
+static void set_mpo_overlays(data_t *data, int phase)
+{
+ for (int i = 0; i < ARRAY_SIZE(data->overlays); i++) {
+ rect_t rect = quadrant_rect(data, mpo_slots[phase][i]);
+
+ igt_plane_set_fb(data->overlays[i], &data->mpo_fbs[i]);
+ igt_plane_set_position(data->overlays[i], rect.x, rect.y);
+ igt_plane_set_size(data->overlays[i], rect.w, rect.h);
+ igt_fb_set_position(&data->mpo_fbs[i], data->overlays[i], 0, 0);
+ igt_fb_set_size(&data->mpo_fbs[i], data->overlays[i],
+ rect.w, rect.h);
+ }
+}
+
+static void disable_mpo_planes(data_t *data)
+{
+ for (int i = 0; i < ARRAY_SIZE(data->overlays); i++)
+ igt_plane_set_fb(data->overlays[i], NULL);
+ igt_plane_set_fb(data->cursor, NULL);
+}
+
+static void draw_mpo_reference(data_t *data, int phase, pos_t cursor_pos,
+ int cursor_size)
+{
+ cairo_t *cr = igt_get_cairo_ctx(data->drm_fd, &data->ref_fb);
+
+ igt_paint_color(cr, 0, 0, data->ref_fb.width, data->ref_fb.height,
+ 1.0, 1.0, 1.0);
+
+ for (int i = 0; i < ARRAY_SIZE(data->overlays); i++) {
+ rect_t rect = quadrant_rect(data, mpo_slots[phase][i]);
+
+ igt_paint_color(cr, rect.x, rect.y, rect.w, rect.h,
+ mpo_colors[i][0], mpo_colors[i][1],
+ mpo_colors[i][2]);
+ }
+
+ igt_paint_color(cr, cursor_pos.x, cursor_pos.y,
+ cursor_size, cursor_size, 1.0, 0.0, 1.0);
+ igt_put_cairo_ctx(cr);
+}
+
+static void test_cursor_mpo(data_t *data, int size)
+{
+ igt_crc_t references[3][QUADRANT_COUNT];
+ igt_crc_t test_crc;
+ const enum quadrant positions[] = {
+ BOTTOM_RIGHT,
+ TOP_LEFT,
+ TOP_RIGHT,
+ BOTTOM_LEFT,
+ };
+
+ igt_pipe_crc_start(data->pipe_crc);
+
+ /*
+ * Capture every software-composited reference before enabling the
+ * overlays. This leaves the hardware pass free to switch overlay
+ * topology while the native cursor remains enabled.
+ */
+ for (int phase = 0; phase < ARRAY_SIZE(mpo_slots); phase++) {
+ for (int i = 0; i < ARRAY_SIZE(positions); i++) {
+ pos_t cursor_pos =
+ quadrant_cursor_pos(data, size, positions[i]);
+
+ draw_mpo_reference(data, phase, cursor_pos, size);
+ igt_plane_set_fb(data->primary, &data->ref_fb);
+ disable_mpo_planes(data);
+ igt_display_commit_atomic(&data->display, 0, NULL);
+ igt_pipe_crc_get_current(data->drm_fd, data->pipe_crc,
+ &references[phase][i]);
+ }
+ }
+
+ igt_plane_set_fb(data->primary, &data->pfb);
+
+ for (int phase = 0; phase < ARRAY_SIZE(mpo_slots); phase++) {
+ set_mpo_overlays(data, phase);
+
+ for (int i = 0; i < ARRAY_SIZE(positions); i++) {
+ pos_t cursor_pos =
+ quadrant_cursor_pos(data, size, positions[i]);
+
+ /*
+ * The first commit for each phase switches overlay
+ * positions with the cursor on the bottom-right pipe.
+ * Subsequent commits only move the cursor.
+ */
+ igt_plane_set_fb(data->cursor, &data->cfb);
+ igt_plane_set_position(data->cursor,
+ cursor_pos.x, cursor_pos.y);
+ igt_display_commit_atomic(&data->display, 0, NULL);
+
+ if (is_amdgpu_device(data->drm_fd))
+ igt_wait_for_vblank_count(data->crtc, 1);
+
+ igt_pipe_crc_get_current(data->drm_fd, data->pipe_crc,
+ &test_crc);
+ igt_assert_crc_equal(&references[phase][i], &test_crc);
+ }
+ }
+
+ igt_pipe_crc_stop(data->pipe_crc);
+}
+
static void test_cleanup(data_t *data)
{
igt_remove_fb(data->drm_fd, &data->cfb);
igt_remove_fb(data->drm_fd, &data->ofb);
+ for (int i = 0; i < ARRAY_SIZE(data->mpo_fbs); i++)
+ igt_remove_fb(data->drm_fd, &data->mpo_fbs[i]);
igt_remove_fb(data->drm_fd, &data->pfb);
igt_remove_fb(data->drm_fd, &data->ref_fb);
}
@@ -257,6 +455,9 @@ static void test_cursor(data_t *data, int size, unsigned int flags)
sw = data->mode->hdisplay;
sh = data->mode->vdisplay;
+ igt_skip_on((flags & TEST_MPO) &&
+ (size > sw / 2 || size > sh / 2));
+
test_cleanup(data);
igt_create_fb(data->drm_fd, sw, sh, DRM_FORMAT_XRGB8888,
@@ -265,7 +466,19 @@ static void test_cursor(data_t *data, int size, unsigned int flags)
igt_create_color_fb(data->drm_fd, sw, sh, DRM_FORMAT_XRGB8888,
DRM_FORMAT_MOD_LINEAR, 1.0, 1.0, 1.0, &data->pfb);
- if (flags & TEST_OVERLAY) {
+ if (flags & TEST_MPO) {
+ int width = (sw + 1) / 2;
+ int height = (sh + 1) / 2;
+
+ for (int i = 0; i < ARRAY_SIZE(data->mpo_fbs); i++)
+ igt_create_color_fb(data->drm_fd, width, height,
+ DRM_FORMAT_XRGB8888,
+ DRM_FORMAT_MOD_LINEAR,
+ mpo_colors[i][0],
+ mpo_colors[i][1],
+ mpo_colors[i][2],
+ &data->mpo_fbs[i]);
+ } else if (flags & TEST_OVERLAY) {
int width = (flags & TEST_VIEWPORT) ? data->rect.w + pad : data->rect.w;
int height = (flags & TEST_VIEWPORT) ? data->rect.h + pad : data->rect.h;
@@ -281,7 +494,10 @@ static void test_cursor(data_t *data, int size, unsigned int flags)
data->crtc);
igt_display_commit2(&data->display, COMMIT_ATOMIC);
- test_cursor_spots(data, size, flags);
+ if (flags & TEST_MPO)
+ test_cursor_mpo(data, size);
+ else
+ test_cursor_spots(data, size, flags);
}
int igt_main()
@@ -304,6 +520,9 @@ int igt_main()
{ "viewport", TEST_PRIMARY | TEST_OVERLAY | TEST_VIEWPORT,
"Tests atomic cursor positioning on primary plane and overlay plane "
"with buffer larger than viewport used for display" },
+ { "multi-overlay", TEST_PRIMARY | TEST_MPO,
+ "Tests native cursor positioning while switching three overlay "
+ "planes between quadrant positions" },
};
igt_fixture() {
@@ -334,6 +553,10 @@ int igt_main()
DRM_PLANE_TYPE_OVERLAY))
continue;
+ if ((tests[i].flags & TEST_MPO) &&
+ igt_crtc_count_plane_type(crtc, DRM_PLANE_TYPE_OVERLAY) < 3)
+ continue;
+
igt_display_reset(display);
igt_output_set_crtc(output,
--
2.34.1
next reply other threads:[~2026-11-20 13:14 UTC|newest]
Thread overview: 3+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-20 7:30 Yuling Li [this message]
2026-11-20 14:38 ` ✓ Xe.CI.BAT: success for tests/kms_plane_cursor: add native cursor test with multiple overlays Patchwork
2026-11-20 14:48 ` ✓ i915.CI.BAT: " Patchwork
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20261120073049.91138-1-Yuling.Li@amd.com \
--to=yuling.li@amd.com \
--cc=igt-dev@lists.freedesktop.org \
--cc=vitaly.prosyak@amd.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.