lkml.org 
[lkml]   [2024]   [Mar]   [11]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Date
    Subject[PATCH v9 19/27] drm/tests: Add RGB Quantization tests
    The previous commit added the infrastructure to the connector state to
    track what RGB Quantization should be used in a given state for an HDMI
    connector.

    Let's add some kunit tests to make sure it works as expected.

    Reviewed-by: Dave Stevenson <dave.stevenson@raspberrypi.com>
    Signed-off-by: Maxime Ripard <mripard@kernel.org>
    ---
    .../gpu/drm/tests/drm_atomic_state_helper_test.c | 563 +++++++++++++++++++++
    1 file changed, 563 insertions(+)

    diff --git a/drivers/gpu/drm/tests/drm_atomic_state_helper_test.c b/drivers/gpu/drm/tests/drm_atomic_state_helper_test.c
    index 3de15cec2f5f..dcc0f7486f49 100644
    --- a/drivers/gpu/drm/tests/drm_atomic_state_helper_test.c
    +++ b/drivers/gpu/drm/tests/drm_atomic_state_helper_test.c
    @@ -350,10 +350,564 @@ static void drm_test_check_broadcast_rgb_crtc_mode_not_changed(struct kunit *tes
    crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
    KUNIT_ASSERT_NOT_ERR_OR_NULL(test, crtc_state);
    KUNIT_EXPECT_FALSE(test, crtc_state->mode_changed);
    }

    +/*
    + * Test that for an HDMI connector, with an HDMI monitor, if the
    + * Broadcast RGB property is set to auto with a mode that isn't the
    + * VIC-1 mode, we will get a limited RGB Quantization Range.
    + */
    +static void drm_test_check_broadcast_rgb_auto_cea_mode(struct kunit *test)
    +{
    + struct drm_atomic_helper_connector_hdmi_priv *priv;
    + struct drm_modeset_acquire_ctx *ctx;
    + struct drm_connector_state *conn_state;
    + struct drm_atomic_state *state;
    + struct drm_display_mode *preferred;
    + struct drm_connector *conn;
    + struct drm_device *drm;
    + struct drm_crtc *crtc;
    + int ret;
    +
    + priv = drm_atomic_helper_connector_hdmi_init(test,
    + BIT(HDMI_COLORSPACE_RGB),
    + 8);
    + KUNIT_ASSERT_NOT_NULL(test, priv);
    +
    + conn = &priv->connector;
    + KUNIT_ASSERT_TRUE(test, conn->display_info.is_hdmi);
    +
    + ctx = drm_kunit_helper_acquire_ctx_alloc(test);
    + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx);
    +
    + preferred = find_preferred_mode(conn);
    + KUNIT_ASSERT_NOT_NULL(test, preferred);
    + KUNIT_ASSERT_NE(test, drm_match_cea_mode(preferred), 1);
    +
    + drm = &priv->drm;
    + crtc = priv->crtc;
    + ret = light_up_connector(test, drm, crtc, conn, preferred, ctx);
    + KUNIT_ASSERT_EQ(test, ret, 0);
    +
    + state = drm_kunit_helper_atomic_state_alloc(test, drm, ctx);
    + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state);
    +
    + conn_state = drm_atomic_get_connector_state(state, conn);
    + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, conn_state);
    +
    + KUNIT_ASSERT_EQ(test,
    + conn_state->hdmi.broadcast_rgb,
    + DRM_HDMI_BROADCAST_RGB_AUTO);
    +
    + ret = drm_atomic_check_only(state);
    + KUNIT_ASSERT_EQ(test, ret, 0);
    +
    + conn_state = drm_atomic_get_connector_state(state, conn);
    + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, conn_state);
    +
    + KUNIT_EXPECT_FALSE(test, conn_state->hdmi.is_full_range);
    +}
    +
    +/*
    + * Test that for an HDMI connector, with an HDMI monitor, if the
    + * Broadcast RGB property is set to auto with a VIC-1 mode, we will get
    + * a full RGB Quantization Range.
    + */
    +static void drm_test_check_broadcast_rgb_auto_cea_mode_vic_1(struct kunit *test)
    +{
    + struct drm_atomic_helper_connector_hdmi_priv *priv;
    + struct drm_modeset_acquire_ctx *ctx;
    + struct drm_connector_state *conn_state;
    + struct drm_atomic_state *state;
    + struct drm_display_mode *mode;
    + struct drm_connector *conn;
    + struct drm_device *drm;
    + struct drm_crtc *crtc;
    + int ret;
    +
    + priv = drm_atomic_helper_connector_hdmi_init(test,
    + BIT(HDMI_COLORSPACE_RGB),
    + 8);
    + KUNIT_ASSERT_NOT_NULL(test, priv);
    +
    + conn = &priv->connector;
    + KUNIT_ASSERT_TRUE(test, conn->display_info.is_hdmi);
    +
    + ctx = drm_kunit_helper_acquire_ctx_alloc(test);
    + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx);
    +
    + mode = drm_display_mode_from_cea_vic(drm, 1);
    + KUNIT_ASSERT_NOT_NULL(test, mode);
    +
    + drm = &priv->drm;
    + crtc = priv->crtc;
    + ret = light_up_connector(test, drm, crtc, conn, mode, ctx);
    + KUNIT_ASSERT_EQ(test, ret, 0);
    +
    + state = drm_kunit_helper_atomic_state_alloc(test, drm, ctx);
    + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state);
    +
    + conn_state = drm_atomic_get_connector_state(state, conn);
    + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, conn_state);
    +
    + KUNIT_ASSERT_EQ(test,
    + conn_state->hdmi.broadcast_rgb,
    + DRM_HDMI_BROADCAST_RGB_AUTO);
    +
    + ret = drm_atomic_check_only(state);
    + KUNIT_ASSERT_EQ(test, ret, 0);
    +
    + conn_state = drm_atomic_get_connector_state(state, conn);
    + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, conn_state);
    +
    + KUNIT_EXPECT_TRUE(test, conn_state->hdmi.is_full_range);
    +}
    +
    +/*
    + * Test that for an HDMI connector, with an HDMI monitor, if the
    + * Broadcast RGB property is set to full with a mode that isn't the
    + * VIC-1 mode, we will get a full RGB Quantization Range.
    + */
    +static void drm_test_check_broadcast_rgb_full_cea_mode(struct kunit *test)
    +{
    + struct drm_atomic_helper_connector_hdmi_priv *priv;
    + struct drm_modeset_acquire_ctx *ctx;
    + struct drm_connector_state *conn_state;
    + struct drm_atomic_state *state;
    + struct drm_display_mode *preferred;
    + struct drm_connector *conn;
    + struct drm_device *drm;
    + struct drm_crtc *crtc;
    + int ret;
    +
    + priv = drm_atomic_helper_connector_hdmi_init(test,
    + BIT(HDMI_COLORSPACE_RGB),
    + 8);
    + KUNIT_ASSERT_NOT_NULL(test, priv);
    +
    + conn = &priv->connector;
    + KUNIT_ASSERT_TRUE(test, conn->display_info.is_hdmi);
    +
    + ctx = drm_kunit_helper_acquire_ctx_alloc(test);
    + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx);
    +
    + preferred = find_preferred_mode(conn);
    + KUNIT_ASSERT_NOT_NULL(test, preferred);
    + KUNIT_ASSERT_NE(test, drm_match_cea_mode(preferred), 1);
    +
    + drm = &priv->drm;
    + crtc = priv->crtc;
    + ret = light_up_connector(test, drm, crtc, conn, preferred, ctx);
    + KUNIT_ASSERT_EQ(test, ret, 0);
    +
    + state = drm_kunit_helper_atomic_state_alloc(test, drm, ctx);
    + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state);
    +
    + conn_state = drm_atomic_get_connector_state(state, conn);
    + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, conn_state);
    +
    + conn_state->hdmi.broadcast_rgb = DRM_HDMI_BROADCAST_RGB_FULL;
    +
    + ret = drm_atomic_check_only(state);
    + KUNIT_ASSERT_EQ(test, ret, 0);
    +
    + conn_state = drm_atomic_get_connector_state(state, conn);
    + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, conn_state);
    +
    + KUNIT_ASSERT_EQ(test,
    + conn_state->hdmi.broadcast_rgb,
    + DRM_HDMI_BROADCAST_RGB_FULL);
    +
    + KUNIT_EXPECT_TRUE(test, conn_state->hdmi.is_full_range);
    +}
    +
    +/*
    + * Test that for an HDMI connector, with an HDMI monitor, if the
    + * Broadcast RGB property is set to full with a VIC-1 mode, we will get
    + * a full RGB Quantization Range.
    + */
    +static void drm_test_check_broadcast_rgb_full_cea_mode_vic_1(struct kunit *test)
    +{
    + struct drm_atomic_helper_connector_hdmi_priv *priv;
    + struct drm_modeset_acquire_ctx *ctx;
    + struct drm_connector_state *conn_state;
    + struct drm_atomic_state *state;
    + struct drm_display_mode *mode;
    + struct drm_connector *conn;
    + struct drm_device *drm;
    + struct drm_crtc *crtc;
    + int ret;
    +
    + priv = drm_atomic_helper_connector_hdmi_init(test,
    + BIT(HDMI_COLORSPACE_RGB),
    + 8);
    + KUNIT_ASSERT_NOT_NULL(test, priv);
    +
    + conn = &priv->connector;
    + KUNIT_ASSERT_TRUE(test, conn->display_info.is_hdmi);
    +
    + ctx = drm_kunit_helper_acquire_ctx_alloc(test);
    + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx);
    +
    + mode = drm_display_mode_from_cea_vic(drm, 1);
    + KUNIT_ASSERT_NOT_NULL(test, mode);
    +
    + drm = &priv->drm;
    + crtc = priv->crtc;
    + ret = light_up_connector(test, drm, crtc, conn, mode, ctx);
    + KUNIT_ASSERT_EQ(test, ret, 0);
    +
    + state = drm_kunit_helper_atomic_state_alloc(test, drm, ctx);
    + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state);
    +
    + conn_state = drm_atomic_get_connector_state(state, conn);
    + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, conn_state);
    +
    + conn_state->hdmi.broadcast_rgb = DRM_HDMI_BROADCAST_RGB_FULL;
    +
    + ret = drm_atomic_check_only(state);
    + KUNIT_ASSERT_EQ(test, ret, 0);
    +
    + conn_state = drm_atomic_get_connector_state(state, conn);
    + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, conn_state);
    +
    + KUNIT_ASSERT_EQ(test,
    + conn_state->hdmi.broadcast_rgb,
    + DRM_HDMI_BROADCAST_RGB_FULL);
    +
    + KUNIT_EXPECT_TRUE(test, conn_state->hdmi.is_full_range);
    +}
    +
    +/*
    + * Test that for an HDMI connector, with an HDMI monitor, if the
    + * Broadcast RGB property is set to limited with a mode that isn't the
    + * VIC-1 mode, we will get a limited RGB Quantization Range.
    + */
    +static void drm_test_check_broadcast_rgb_limited_cea_mode(struct kunit *test)
    +{
    + struct drm_atomic_helper_connector_hdmi_priv *priv;
    + struct drm_modeset_acquire_ctx *ctx;
    + struct drm_connector_state *conn_state;
    + struct drm_atomic_state *state;
    + struct drm_display_mode *preferred;
    + struct drm_connector *conn;
    + struct drm_device *drm;
    + struct drm_crtc *crtc;
    + int ret;
    +
    + priv = drm_atomic_helper_connector_hdmi_init(test,
    + BIT(HDMI_COLORSPACE_RGB),
    + 8);
    + KUNIT_ASSERT_NOT_NULL(test, priv);
    +
    + conn = &priv->connector;
    + KUNIT_ASSERT_TRUE(test, conn->display_info.is_hdmi);
    +
    + ctx = drm_kunit_helper_acquire_ctx_alloc(test);
    + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx);
    +
    + preferred = find_preferred_mode(conn);
    + KUNIT_ASSERT_NOT_NULL(test, preferred);
    + KUNIT_ASSERT_NE(test, drm_match_cea_mode(preferred), 1);
    +
    + drm = &priv->drm;
    + crtc = priv->crtc;
    + ret = light_up_connector(test, drm, crtc, conn, preferred, ctx);
    + KUNIT_ASSERT_EQ(test, ret, 0);
    +
    + state = drm_kunit_helper_atomic_state_alloc(test, drm, ctx);
    + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state);
    +
    + conn_state = drm_atomic_get_connector_state(state, conn);
    + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, conn_state);
    +
    + conn_state->hdmi.broadcast_rgb = DRM_HDMI_BROADCAST_RGB_LIMITED;
    +
    + ret = drm_atomic_check_only(state);
    + KUNIT_ASSERT_EQ(test, ret, 0);
    +
    + conn_state = drm_atomic_get_connector_state(state, conn);
    + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, conn_state);
    +
    + KUNIT_ASSERT_EQ(test,
    + conn_state->hdmi.broadcast_rgb,
    + DRM_HDMI_BROADCAST_RGB_LIMITED);
    +
    + KUNIT_EXPECT_FALSE(test, conn_state->hdmi.is_full_range);
    +}
    +
    +/*
    + * Test that for an HDMI connector, with an HDMI monitor, if the
    + * Broadcast RGB property is set to limited with a VIC-1 mode, we will
    + * get a limited RGB Quantization Range.
    + */
    +static void drm_test_check_broadcast_rgb_limited_cea_mode_vic_1(struct kunit *test)
    +{
    + struct drm_atomic_helper_connector_hdmi_priv *priv;
    + struct drm_modeset_acquire_ctx *ctx;
    + struct drm_connector_state *conn_state;
    + struct drm_atomic_state *state;
    + struct drm_display_mode *mode;
    + struct drm_connector *conn;
    + struct drm_device *drm;
    + struct drm_crtc *crtc;
    + int ret;
    +
    + priv = drm_atomic_helper_connector_hdmi_init(test,
    + BIT(HDMI_COLORSPACE_RGB),
    + 8);
    + KUNIT_ASSERT_NOT_NULL(test, priv);
    +
    + conn = &priv->connector;
    + KUNIT_ASSERT_TRUE(test, conn->display_info.is_hdmi);
    +
    + ctx = drm_kunit_helper_acquire_ctx_alloc(test);
    + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx);
    +
    + mode = drm_display_mode_from_cea_vic(drm, 1);
    + KUNIT_ASSERT_NOT_NULL(test, mode);
    +
    + drm = &priv->drm;
    + crtc = priv->crtc;
    + ret = light_up_connector(test, drm, crtc, conn, mode, ctx);
    + KUNIT_ASSERT_EQ(test, ret, 0);
    +
    + state = drm_kunit_helper_atomic_state_alloc(test, drm, ctx);
    + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state);
    +
    + conn_state = drm_atomic_get_connector_state(state, conn);
    + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, conn_state);
    +
    + conn_state->hdmi.broadcast_rgb = DRM_HDMI_BROADCAST_RGB_LIMITED;
    +
    + ret = drm_atomic_check_only(state);
    + KUNIT_ASSERT_EQ(test, ret, 0);
    +
    + conn_state = drm_atomic_get_connector_state(state, conn);
    + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, conn_state);
    +
    + KUNIT_ASSERT_EQ(test,
    + conn_state->hdmi.broadcast_rgb,
    + DRM_HDMI_BROADCAST_RGB_LIMITED);
    +
    + KUNIT_EXPECT_FALSE(test, conn_state->hdmi.is_full_range);
    +}
    +
    +/*
    + * Test that if we have an HDMI connector that would use a YUV output,
    + * we always get a limited quantization range with the Broadcast RGB
    + * property set to auto.
    + */
    +static void drm_test_check_broadcast_rgb_auto_yuv(struct kunit *test)
    +{
    + struct drm_atomic_helper_connector_hdmi_priv *priv;
    + struct drm_modeset_acquire_ctx *ctx;
    + struct drm_connector_state *conn_state;
    + struct drm_atomic_state *state;
    + struct drm_display_info *info;
    + struct drm_display_mode *preferred;
    + unsigned long long rate;
    + struct drm_connector *conn;
    + struct drm_device *drm;
    + struct drm_crtc *crtc;
    + int ret;
    +
    + priv = drm_atomic_helper_connector_hdmi_init(test,
    + BIT(HDMI_COLORSPACE_RGB) |
    + BIT(HDMI_COLORSPACE_YUV422),
    + 12);
    + KUNIT_ASSERT_NOT_NULL(test, priv);
    +
    + conn = &priv->connector;
    + ret = set_connector_edid(test, conn,
    + test_edid_hdmi_1080p_rgb_yuv_dc_max_200mhz,
    + ARRAY_SIZE(test_edid_hdmi_1080p_rgb_yuv_dc_max_200mhz));
    + KUNIT_ASSERT_EQ(test, ret, 0);
    +
    + info = &conn->display_info;
    + KUNIT_ASSERT_TRUE(test, info->is_hdmi);
    + KUNIT_ASSERT_GT(test, info->max_tmds_clock, 0);
    +
    + ctx = drm_kunit_helper_acquire_ctx_alloc(test);
    + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx);
    +
    + preferred = find_preferred_mode(conn);
    + KUNIT_ASSERT_NOT_NULL(test, preferred);
    + KUNIT_ASSERT_FALSE(test, preferred->flags & DRM_MODE_FLAG_DBLCLK);
    +
    + rate = drm_connector_hdmi_compute_mode_clock(preferred, 12, HDMI_COLORSPACE_RGB);
    + KUNIT_ASSERT_GT(test, rate, info->max_tmds_clock * 1000);
    +
    + rate = drm_connector_hdmi_compute_mode_clock(preferred, 12, HDMI_COLORSPACE_YUV422);
    + KUNIT_ASSERT_LT(test, rate, info->max_tmds_clock * 1000);
    +
    + drm = &priv->drm;
    + crtc = priv->crtc;
    + ret = light_up_connector(test, drm, crtc, conn, preferred, ctx);
    + KUNIT_EXPECT_EQ(test, ret, 0);
    +
    + state = drm_kunit_helper_atomic_state_alloc(test, drm, ctx);
    + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state);
    +
    + conn_state = drm_atomic_get_connector_state(state, conn);
    + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, conn_state);
    +
    + conn_state->hdmi.broadcast_rgb = DRM_HDMI_BROADCAST_RGB_AUTO;
    +
    + ret = drm_atomic_check_only(state);
    + KUNIT_ASSERT_EQ(test, ret, 0);
    +
    + conn_state = drm_atomic_get_connector_state(state, conn);
    + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, conn_state);
    +
    + KUNIT_ASSERT_EQ(test, conn_state->hdmi.output_format, HDMI_COLORSPACE_YUV422);
    + KUNIT_EXPECT_FALSE(test, conn_state->hdmi.is_full_range);
    +}
    +
    +/*
    + * Test that if we have an HDMI connector that would use a YUV output,
    + * we always get a limited quantization range even if we have the
    + * Broadcast RGB property set to full.
    + */
    +static void drm_test_check_broadcast_rgb_full_yuv(struct kunit *test)
    +{
    + struct drm_atomic_helper_connector_hdmi_priv *priv;
    + struct drm_modeset_acquire_ctx *ctx;
    + struct drm_connector_state *conn_state;
    + struct drm_atomic_state *state;
    + struct drm_display_info *info;
    + struct drm_display_mode *preferred;
    + unsigned long long rate;
    + struct drm_connector *conn;
    + struct drm_device *drm;
    + struct drm_crtc *crtc;
    + int ret;
    +
    + priv = drm_atomic_helper_connector_hdmi_init(test,
    + BIT(HDMI_COLORSPACE_RGB) |
    + BIT(HDMI_COLORSPACE_YUV422),
    + 12);
    + KUNIT_ASSERT_NOT_NULL(test, priv);
    +
    + conn = &priv->connector;
    + ret = set_connector_edid(test, conn,
    + test_edid_hdmi_1080p_rgb_yuv_dc_max_200mhz,
    + ARRAY_SIZE(test_edid_hdmi_1080p_rgb_yuv_dc_max_200mhz));
    + KUNIT_ASSERT_EQ(test, ret, 0);
    +
    + info = &conn->display_info;
    + KUNIT_ASSERT_TRUE(test, info->is_hdmi);
    + KUNIT_ASSERT_GT(test, info->max_tmds_clock, 0);
    +
    + ctx = drm_kunit_helper_acquire_ctx_alloc(test);
    + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx);
    +
    + preferred = find_preferred_mode(conn);
    + KUNIT_ASSERT_NOT_NULL(test, preferred);
    + KUNIT_ASSERT_FALSE(test, preferred->flags & DRM_MODE_FLAG_DBLCLK);
    +
    + rate = drm_connector_hdmi_compute_mode_clock(preferred, 12, HDMI_COLORSPACE_RGB);
    + KUNIT_ASSERT_GT(test, rate, info->max_tmds_clock * 1000);
    +
    + rate = drm_connector_hdmi_compute_mode_clock(preferred, 12, HDMI_COLORSPACE_YUV422);
    + KUNIT_ASSERT_LT(test, rate, info->max_tmds_clock * 1000);
    +
    + drm = &priv->drm;
    + crtc = priv->crtc;
    + ret = light_up_connector(test, drm, crtc, conn, preferred, ctx);
    + KUNIT_EXPECT_EQ(test, ret, 0);
    +
    + state = drm_kunit_helper_atomic_state_alloc(test, drm, ctx);
    + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state);
    +
    + conn_state = drm_atomic_get_connector_state(state, conn);
    + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, conn_state);
    +
    + conn_state->hdmi.broadcast_rgb = DRM_HDMI_BROADCAST_RGB_FULL;
    +
    + ret = drm_atomic_check_only(state);
    + KUNIT_ASSERT_EQ(test, ret, 0);
    +
    + conn_state = drm_atomic_get_connector_state(state, conn);
    + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, conn_state);
    +
    + KUNIT_ASSERT_EQ(test, conn_state->hdmi.output_format, HDMI_COLORSPACE_YUV422);
    + KUNIT_EXPECT_FALSE(test, conn_state->hdmi.is_full_range);
    +}
    +
    +/*
    + * Test that if we have an HDMI connector that would use a YUV output,
    + * we always get a limited quantization range even if we have the
    + * Broadcast RGB property set to full.
    + */
    +static void drm_test_check_broadcast_rgb_limited_yuv(struct kunit *test)
    +{
    + struct drm_atomic_helper_connector_hdmi_priv *priv;
    + struct drm_modeset_acquire_ctx *ctx;
    + struct drm_connector_state *conn_state;
    + struct drm_atomic_state *state;
    + struct drm_display_info *info;
    + struct drm_display_mode *preferred;
    + unsigned long long rate;
    + struct drm_connector *conn;
    + struct drm_device *drm;
    + struct drm_crtc *crtc;
    + int ret;
    +
    + priv = drm_atomic_helper_connector_hdmi_init(test,
    + BIT(HDMI_COLORSPACE_RGB) |
    + BIT(HDMI_COLORSPACE_YUV422),
    + 12);
    + KUNIT_ASSERT_NOT_NULL(test, priv);
    +
    + conn = &priv->connector;
    + ret = set_connector_edid(test, conn,
    + test_edid_hdmi_1080p_rgb_yuv_dc_max_200mhz,
    + ARRAY_SIZE(test_edid_hdmi_1080p_rgb_yuv_dc_max_200mhz));
    + KUNIT_ASSERT_EQ(test, ret, 0);
    +
    + info = &conn->display_info;
    + KUNIT_ASSERT_TRUE(test, info->is_hdmi);
    + KUNIT_ASSERT_GT(test, info->max_tmds_clock, 0);
    +
    + ctx = drm_kunit_helper_acquire_ctx_alloc(test);
    + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx);
    +
    + preferred = find_preferred_mode(conn);
    + KUNIT_ASSERT_NOT_NULL(test, preferred);
    + KUNIT_ASSERT_FALSE(test, preferred->flags & DRM_MODE_FLAG_DBLCLK);
    +
    + rate = drm_connector_hdmi_compute_mode_clock(preferred, 12, HDMI_COLORSPACE_RGB);
    + KUNIT_ASSERT_GT(test, rate, info->max_tmds_clock * 1000);
    +
    + rate = drm_connector_hdmi_compute_mode_clock(preferred, 12, HDMI_COLORSPACE_YUV422);
    + KUNIT_ASSERT_LT(test, rate, info->max_tmds_clock * 1000);
    +
    + drm = &priv->drm;
    + crtc = priv->crtc;
    + ret = light_up_connector(test, drm, crtc, conn, preferred, ctx);
    + KUNIT_EXPECT_EQ(test, ret, 0);
    +
    + state = drm_kunit_helper_atomic_state_alloc(test, drm, ctx);
    + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state);
    +
    + conn_state = drm_atomic_get_connector_state(state, conn);
    + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, conn_state);
    +
    + conn_state->hdmi.broadcast_rgb = DRM_HDMI_BROADCAST_RGB_LIMITED;
    +
    + ret = drm_atomic_check_only(state);
    + KUNIT_ASSERT_EQ(test, ret, 0);
    +
    + conn_state = drm_atomic_get_connector_state(state, conn);
    + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, conn_state);
    +
    + KUNIT_ASSERT_EQ(test, conn_state->hdmi.output_format, HDMI_COLORSPACE_YUV422);
    + KUNIT_EXPECT_FALSE(test, conn_state->hdmi.is_full_range);
    +}
    +
    /*
    * Test that if we change the maximum bpc property to a different value,
    * we trigger a mode change on the connector's CRTC, which will in turn
    * disable/enable the connector.
    */
    @@ -1185,10 +1739,19 @@ static void drm_test_check_output_bpc_format_display_8bpc_only(struct kunit *tes
    KUNIT_EXPECT_EQ(test, conn_state->hdmi.output_bpc, 8);
    KUNIT_EXPECT_EQ(test, conn_state->hdmi.output_format, HDMI_COLORSPACE_RGB);
    }

    static struct kunit_case drm_atomic_helper_connector_hdmi_check_tests[] = {
    + KUNIT_CASE(drm_test_check_broadcast_rgb_auto_cea_mode),
    + KUNIT_CASE(drm_test_check_broadcast_rgb_auto_cea_mode_vic_1),
    + KUNIT_CASE(drm_test_check_broadcast_rgb_auto_yuv),
    + KUNIT_CASE(drm_test_check_broadcast_rgb_full_cea_mode),
    + KUNIT_CASE(drm_test_check_broadcast_rgb_full_cea_mode_vic_1),
    + KUNIT_CASE(drm_test_check_broadcast_rgb_full_yuv),
    + KUNIT_CASE(drm_test_check_broadcast_rgb_limited_cea_mode),
    + KUNIT_CASE(drm_test_check_broadcast_rgb_limited_cea_mode_vic_1),
    + KUNIT_CASE(drm_test_check_broadcast_rgb_limited_yuv),
    KUNIT_CASE(drm_test_check_broadcast_rgb_crtc_mode_changed),
    KUNIT_CASE(drm_test_check_broadcast_rgb_crtc_mode_not_changed),
    KUNIT_CASE(drm_test_check_hdmi_funcs_reject_rate),
    KUNIT_CASE(drm_test_check_max_tmds_rate_bpc_fallback),
    KUNIT_CASE(drm_test_check_max_tmds_rate_format_fallback),
    --
    2.43.2


    \
     
     \ /
      Last update: 2024-05-27 15:44    [W:8.506 / U:0.092 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site