[PATCH v2 23/27] drm/tests: hdmi: Add Fixed/Constrained rate VRR tests
Nicolas Frattaroli
nicolas.frattaroli at collabora.com
Thu Nov 5 07:52:14 PST 2026
Add tests to verify the functionality of the
VRR_{MIN,MAX}_{NUMERATOR,DENOMINATOR} properties and the HDMI state
helpers that make use of them.
This includes tests for fixed rate scenarios, as well as a test for a
constrained game mode scenario. A parametric test case checks that
various erroneous target rates are rejected.
Proper handling of CinemaVRR is tested as well.
Signed-off-by: Nicolas Frattaroli <nicolas.frattaroli at collabora.com>
---
drivers/gpu/drm/tests/drm_hdmi_state_helper_test.c | 386 +++++++++++++++++++++
1 file changed, 386 insertions(+)
diff --git a/drivers/gpu/drm/tests/drm_hdmi_state_helper_test.c b/drivers/gpu/drm/tests/drm_hdmi_state_helper_test.c
index def414085069..4d9bcab57778 100644
--- a/drivers/gpu/drm/tests/drm_hdmi_state_helper_test.c
+++ b/drivers/gpu/drm/tests/drm_hdmi_state_helper_test.c
@@ -3674,10 +3674,396 @@ static void drm_test_check_hdmi_vrr_flush_vsync(struct kunit *test)
crtc_state->vrr_state.max_vtotal);
}
+/*
+ * Check that on a VRR-capable sink with VRR enabled and a fixed target rate
+ * set, an atomic commit works, and the derived vtotals are as expected.
+ */
+static void drm_test_check_hdmi_vrr_fixed_rate(struct kunit *test)
+{
+ struct drm_atomic_helper_connector_hdmi_priv *priv;
+ struct drm_modeset_acquire_ctx ctx;
+ struct drm_display_mode *preferred;
+ struct drm_crtc_state *crtc_state;
+ struct drm_atomic_commit *state;
+ int mode_refresh;
+ int ret;
+
+ priv = drm_kunit_helper_connector_hdmi_init_with_edid_funcs(test,
+ BIT(DRM_OUTPUT_COLOR_FORMAT_RGB444),
+ 8,
+ &dummy_connector_hdmi_funcs,
+ test_edid_hdmi_vrr);
+ KUNIT_ASSERT_NOT_NULL(test, priv);
+
+ KUNIT_ASSERT_TRUE(test, priv->connector.display_info.is_hdmi);
+ KUNIT_ASSERT_TRUE(test, priv->connector.display_info.hdmi.vrr_cap.supported);
+ KUNIT_ASSERT_TRUE(test, priv->connector.display_info.hdmi.vrr_cap.cinema_vrr);
+
+ preferred = find_preferred_mode(&priv->connector);
+ KUNIT_ASSERT_NOT_NULL(test, preferred);
+
+ mode_refresh = drm_mode_vrefresh(preferred);
+
+ guard(modeset_lock)(&ctx);
+
+ allocate_state_for_vrr_test(test, priv, &ctx, preferred, &state);
+
+retry:
+ prepare_state_for_vrr_test(test, priv, &ctx, state, &crtc_state);
+
+ crtc_state->vrr_enabled = true;
+ crtc_state->vrr_state.vrr_min_n = 40;
+ crtc_state->vrr_state.vrr_min_d = 1;
+ /* Equivalent fraction, expressed differently to pose a hurdle */
+ crtc_state->vrr_state.vrr_max_n = 40000;
+ crtc_state->vrr_state.vrr_max_d = 1000;
+
+ ret = drm_atomic_commit(state);
+ if (ret == -EDEADLK) {
+ drm_atomic_commit_clear(state);
+ ret = drm_modeset_backoff(&ctx);
+ if (!ret)
+ goto retry;
+ }
+ KUNIT_ASSERT_EQ(test, ret, 0);
+
+ crtc_state = drm_atomic_get_new_crtc_state(state, priv->crtc);
+ KUNIT_ASSERT_NOT_NULL(test, crtc_state);
+
+ KUNIT_EXPECT_EQ(test, crtc_state->vrr_state.base_vtotal,
+ preferred->crtc_vtotal * mode_refresh / 40);
+
+ /* Minimum rate is 24Hz because of the CinemaVRR flag */
+ KUNIT_EXPECT_EQ(test, crtc_state->vrr_state.max_vtotal,
+ preferred->crtc_vtotal * mode_refresh / 24);
+}
+
+/*
+ * Check that the drm_hdmi_helper_vrr_flush() and drm_hdmi_helper_vrr_vsync()
+ * helpers return the expected values on a VRR-capable sink with VRR enabled
+ * and a fixed target set.
+ */
+static void drm_test_check_hdmi_vrr_fixed_rate_flush_vsync(struct kunit *test)
+{
+ struct drm_atomic_helper_connector_hdmi_priv *priv;
+ struct drm_modeset_acquire_ctx ctx;
+ struct drm_display_mode *preferred;
+ struct drm_crtc_state *crtc_state;
+ struct drm_atomic_commit *state;
+ int mode_refresh;
+ int ret;
+
+ priv = drm_kunit_helper_connector_hdmi_init_with_edid_funcs(test,
+ BIT(DRM_OUTPUT_COLOR_FORMAT_RGB444),
+ 8,
+ &dummy_connector_hdmi_funcs,
+ test_edid_hdmi_vrr);
+ KUNIT_ASSERT_NOT_NULL(test, priv);
+
+ KUNIT_ASSERT_TRUE(test, priv->connector.display_info.is_hdmi);
+ KUNIT_ASSERT_TRUE(test, priv->connector.display_info.hdmi.vrr_cap.supported);
+
+ preferred = find_preferred_mode(&priv->connector);
+ KUNIT_ASSERT_NOT_NULL(test, preferred);
+
+ mode_refresh = drm_mode_vrefresh(preferred);
+
+ scoped_guard(modeset_lock, &ctx) {
+ allocate_state_for_vrr_test(test, priv, &ctx, preferred, &state);
+
+retry:
+ prepare_state_for_vrr_test(test, priv, &ctx, state, &crtc_state);
+
+ crtc_state->vrr_enabled = true;
+ crtc_state->vrr_state.vrr_min_n = 40000;
+ crtc_state->vrr_state.vrr_min_d = 1001;
+ /* Equivalent fraction, expressed differently to pose a hurdle */
+ crtc_state->vrr_state.vrr_max_n = 80000;
+ crtc_state->vrr_state.vrr_max_d = 2002;
+
+ ret = drm_atomic_commit(state);
+ if (ret == -EDEADLK) {
+ drm_atomic_commit_clear(state);
+ ret = drm_modeset_backoff(&ctx);
+ if (!ret)
+ goto retry;
+ }
+ KUNIT_ASSERT_EQ(test, ret, 0);
+
+ crtc_state = drm_atomic_get_new_crtc_state(state, priv->crtc);
+ KUNIT_ASSERT_NOT_NULL(test, crtc_state);
+
+ KUNIT_EXPECT_EQ(test, crtc_state->vrr_state.base_vtotal,
+ mult_frac(preferred->crtc_vtotal, mode_refresh * 1000, 39960));
+
+ /* Fixed rate case: flush should never trigger a vtotal update. */
+ KUNIT_EXPECT_FALSE(test, drm_crtc_helper_vrr_flush(crtc_state));
+ KUNIT_EXPECT_EQ(test, crtc_state->vrr_state.cur_vtotal, 0);
+
+ /*
+ * Invoking drm_hdmi_helper_vrr_flush() again should not change
+ * cur_vtotal, meaning it should return false.
+ */
+ KUNIT_EXPECT_FALSE(test, drm_crtc_helper_vrr_flush(crtc_state));
+ KUNIT_EXPECT_EQ(test, crtc_state->vrr_state.cur_vtotal, 0);
+
+ /* First vsync will set cur_vtotal. */
+ KUNIT_EXPECT_TRUE(test, drm_crtc_helper_vrr_vsync(crtc_state));
+ KUNIT_EXPECT_EQ(test, crtc_state->vrr_state.cur_vtotal,
+ crtc_state->vrr_state.base_vtotal);
+ /* First vsync with fixed rate will still be dynamic. */
+ KUNIT_EXPECT_TRUE(test, crtc_state->vrr_state.dynamic);
+ }
+
+ /* Try a second commit to evaluate the dynamic flag */
+ scoped_guard(modeset_lock, &ctx) {
+ allocate_state_for_vrr_test(test, priv, &ctx, preferred, &state);
+
+retry_2:
+ prepare_state_for_vrr_test(test, priv, &ctx, state, &crtc_state);
+
+ ret = drm_atomic_commit(state);
+ if (ret == -EDEADLK) {
+ drm_atomic_commit_clear(state);
+ ret = drm_modeset_backoff(&ctx);
+ if (!ret)
+ goto retry_2;
+ }
+ KUNIT_ASSERT_EQ(test, ret, 0);
+
+ crtc_state = drm_atomic_get_new_crtc_state(state, priv->crtc);
+ KUNIT_ASSERT_NOT_NULL(test, crtc_state);
+
+ KUNIT_EXPECT_FALSE(test, drm_crtc_helper_vrr_flush(crtc_state));
+ KUNIT_EXPECT_EQ(test, crtc_state->vrr_state.cur_vtotal,
+ crtc_state->vrr_state.base_vtotal);
+ KUNIT_EXPECT_FALSE(test, crtc_state->vrr_state.dynamic);
+ KUNIT_EXPECT_FALSE(test, drm_crtc_helper_vrr_vsync(crtc_state));
+ KUNIT_EXPECT_EQ(test, crtc_state->vrr_state.cur_vtotal,
+ crtc_state->vrr_state.base_vtotal);
+ /* Subsequent vsyncs with fixed rate won't be dynamic. */
+ KUNIT_EXPECT_FALSE(test, crtc_state->vrr_state.dynamic);
+ }
+}
+
+struct vrr_target_error_params {
+ unsigned int vrr_min_n;
+ unsigned int vrr_min_d;
+ unsigned int vrr_max_n;
+ unsigned int vrr_max_d;
+ bool cinema_vrr_override;
+ const char *desc;
+};
+
+static struct vrr_target_error_params vrr_target_errors[] = {
+ { 26, 1, 26 * 2000, 2000, false, "VRR target <= min rate should fail" },
+ { 200, 1, 200, 1, true, "VRR target <= max rate should fail" },
+ { 60, 1, 40, 1, true, "VRR max target <= VRR min target should fail" },
+ { 40, 1, 60, 0, true, "VRR max target denominator of 0 should fail" },
+ { 40, 0, 60, 1, true, "VRR min target denominator of 0 should fail" },
+ { 25000, 1001, 30, 1, true, "CinemaVRR with non-fixed rate should fail" },
+ { 0, 1000, 60, 1, true, "Minimum-Incomplete range should fail" },
+ { 40, 1, 0, 0, false, "Maximum-Incomplete range should fail" },
+};
+
+KUNIT_ARRAY_PARAM_DESC(check_vrr_target_errors, vrr_target_errors, desc);
+
+/*
+ * Check that on a VRR-capable sink with VRR enabled and various erroneous
+ * combinations of target rates set, an atomic commit fails.
+ */
+static void drm_test_check_hdmi_vrr_target_rate_fail(struct kunit *test)
+{
+ const struct vrr_target_error_params *params = test->param_value;
+ struct drm_atomic_helper_connector_hdmi_priv *priv;
+ struct drm_modeset_acquire_ctx ctx;
+ struct drm_display_mode *preferred;
+ struct drm_crtc_state *crtc_state;
+ struct drm_atomic_commit *state;
+ struct drm_connector *conn;
+ int ret;
+
+ priv = drm_kunit_helper_connector_hdmi_init_with_edid_funcs(test,
+ BIT(DRM_OUTPUT_COLOR_FORMAT_RGB444),
+ 8,
+ &dummy_connector_hdmi_funcs,
+ test_edid_hdmi_vrr);
+ KUNIT_ASSERT_NOT_NULL(test, priv);
+
+ conn = &priv->connector;
+ KUNIT_ASSERT_TRUE(test, conn->display_info.is_hdmi);
+ KUNIT_ASSERT_TRUE(test, conn->display_info.hdmi.vrr_cap.supported);
+ KUNIT_ASSERT_LT(test, 24, conn->display_info.hdmi.vrr_cap.vrr_min);
+
+ preferred = find_preferred_mode(conn);
+ KUNIT_ASSERT_NOT_NULL(test, preferred);
+
+ guard(modeset_lock)(&ctx);
+
+ allocate_state_for_vrr_test(test, priv, &ctx, preferred, &state);
+
+retry:
+ prepare_state_for_vrr_test(test, priv, &ctx, state, &crtc_state);
+
+ /*
+ * Allow individual test parameters to play with the CinemaVRR flag
+ * without needing to bring their own modified EDID.
+ */
+ conn->display_info.hdmi.vrr_cap.cinema_vrr = params->cinema_vrr_override;
+
+ crtc_state->vrr_enabled = true;
+ crtc_state->vrr_state.vrr_min_n = params->vrr_min_n;
+ crtc_state->vrr_state.vrr_min_d = params->vrr_min_d;
+ crtc_state->vrr_state.vrr_max_n = params->vrr_max_n;
+ crtc_state->vrr_state.vrr_max_d = params->vrr_max_d;
+
+ ret = drm_atomic_commit(state);
+ if (ret == -EDEADLK) {
+ drm_atomic_commit_clear(state);
+ ret = drm_modeset_backoff(&ctx);
+ if (!ret)
+ goto retry;
+ }
+ KUNIT_EXPECT_LT(test, ret, 0);
+
+ drm_modeset_drop_locks(&ctx);
+ drm_modeset_acquire_fini(&ctx);
+}
+
+/*
+ * Check that on a VRR-capable sink that has the CinemaVRR flag set, with VRR
+ * enabled and a fixed target rate set, an atomic commit succeeds at a rate
+ * only possible if CinemaVRR is supported and a fixed target is used.
+ */
+static void drm_test_check_hdmi_vrr_fixed_rate_cinema_vrr(struct kunit *test)
+{
+ struct drm_atomic_helper_connector_hdmi_priv *priv;
+ struct drm_modeset_acquire_ctx ctx;
+ struct drm_display_mode *preferred;
+ struct drm_crtc_state *crtc_state;
+ struct drm_atomic_commit *state;
+ struct drm_connector *conn;
+ int mode_refresh;
+ int ret;
+
+ priv = drm_kunit_helper_connector_hdmi_init_with_edid_funcs(test,
+ BIT(DRM_OUTPUT_COLOR_FORMAT_RGB444),
+ 8,
+ &dummy_connector_hdmi_funcs,
+ test_edid_hdmi_vrr);
+ KUNIT_ASSERT_NOT_NULL(test, priv);
+
+ conn = &priv->connector;
+ KUNIT_ASSERT_TRUE(test, conn->display_info.is_hdmi);
+ KUNIT_ASSERT_TRUE(test, conn->display_info.hdmi.vrr_cap.supported);
+ KUNIT_ASSERT_TRUE(test, conn->display_info.hdmi.vrr_cap.cinema_vrr);
+ KUNIT_ASSERT_LT(test, 24, conn->display_info.hdmi.vrr_cap.vrr_min);
+
+ preferred = find_preferred_mode(conn);
+ KUNIT_ASSERT_NOT_NULL(test, preferred);
+
+ mode_refresh = drm_mode_vrefresh(preferred);
+
+ guard(modeset_lock)(&ctx);
+
+ allocate_state_for_vrr_test(test, priv, &ctx, preferred, &state);
+
+retry:
+ prepare_state_for_vrr_test(test, priv, &ctx, state, &crtc_state);
+
+ crtc_state->vrr_enabled = true;
+
+ /* 24/1.001 Hz should work */
+ crtc_state->vrr_state.vrr_min_n = 24000;
+ crtc_state->vrr_state.vrr_min_d = 1001;
+ crtc_state->vrr_state.vrr_max_n = 24000;
+ crtc_state->vrr_state.vrr_max_d = 1001;
+
+ ret = drm_atomic_commit(state);
+ if (ret == -EDEADLK) {
+ drm_atomic_commit_clear(state);
+ ret = drm_modeset_backoff(&ctx);
+ if (!ret)
+ goto retry;
+ }
+ KUNIT_EXPECT_EQ(test, ret, 0);
+ KUNIT_EXPECT_EQ(test, crtc_state->vrr_state.base_vtotal,
+ mult_frac(preferred->crtc_vtotal, mode_refresh * 1000, 23976));
+}
+
+/*
+ * Check that on a VRR-capable sink, an atomic commit with a VRR minimum and
+ * maximum target rate that's more narrow than the monitor's target rate
+ * succeeds and produces the expected derived values.
+ */
+static void drm_test_check_hdmi_vrr_constrained_rate(struct kunit *test)
+{
+ struct drm_atomic_helper_connector_hdmi_priv *priv;
+ struct drm_modeset_acquire_ctx ctx;
+ struct drm_display_mode *preferred;
+ struct drm_crtc_state *crtc_state;
+ struct drm_atomic_commit *state;
+ struct drm_connector *conn;
+ int mode_refresh;
+ int ret;
+
+ priv = drm_kunit_helper_connector_hdmi_init_with_edid_funcs(test,
+ BIT(DRM_OUTPUT_COLOR_FORMAT_RGB444),
+ 8,
+ &dummy_connector_hdmi_funcs,
+ test_edid_hdmi_vrr);
+ KUNIT_ASSERT_NOT_NULL(test, priv);
+
+ conn = &priv->connector;
+ KUNIT_ASSERT_TRUE(test, conn->display_info.is_hdmi);
+ KUNIT_ASSERT_TRUE(test, conn->display_info.hdmi.vrr_cap.supported);
+
+ preferred = find_preferred_mode(conn);
+ KUNIT_ASSERT_NOT_NULL(test, preferred);
+
+ mode_refresh = drm_mode_vrefresh(preferred);
+
+ guard(modeset_lock)(&ctx);
+
+ allocate_state_for_vrr_test(test, priv, &ctx, preferred, &state);
+
+retry:
+ prepare_state_for_vrr_test(test, priv, &ctx, state, &crtc_state);
+
+ crtc_state->vrr_enabled = true;
+ crtc_state->vrr_state.vrr_min_n = 40;
+ crtc_state->vrr_state.vrr_min_d = 1;
+ crtc_state->vrr_state.vrr_max_n = 80;
+ crtc_state->vrr_state.vrr_max_d = 1;
+
+ ret = drm_atomic_commit(state);
+ if (ret == -EDEADLK) {
+ drm_atomic_commit_clear(state);
+ ret = drm_modeset_backoff(&ctx);
+ if (!ret)
+ goto retry;
+ }
+ KUNIT_ASSERT_EQ(test, ret, 0);
+
+ crtc_state = drm_atomic_get_new_crtc_state(state, priv->crtc);
+ KUNIT_ASSERT_NOT_NULL(test, crtc_state);
+
+ KUNIT_EXPECT_EQ(test, crtc_state->vrr_state.base_vtotal,
+ preferred->crtc_vtotal * mode_refresh / 80);
+ KUNIT_EXPECT_EQ(test, crtc_state->vrr_state.max_vtotal,
+ preferred->crtc_vtotal * mode_refresh / 40);
+}
+
static struct kunit_case drm_atomic_helper_connector_hdmi_vrr_tests[] = {
KUNIT_CASE(drm_test_check_hdmi_vrr),
KUNIT_CASE(drm_test_check_hdmi_vrr_sink_fail),
KUNIT_CASE(drm_test_check_hdmi_vrr_flush_vsync),
+ KUNIT_CASE(drm_test_check_hdmi_vrr_fixed_rate),
+ KUNIT_CASE(drm_test_check_hdmi_vrr_fixed_rate_flush_vsync),
+ KUNIT_CASE_PARAM(drm_test_check_hdmi_vrr_target_rate_fail,
+ check_vrr_target_errors_gen_params),
+ KUNIT_CASE(drm_test_check_hdmi_vrr_fixed_rate_cinema_vrr),
+ KUNIT_CASE(drm_test_check_hdmi_vrr_constrained_rate),
{ }
};
--
2.56.0
More information about the Linux-rockchip
mailing list