From: Hugo Sales <[email protected]> Test that atomic_check reads the mode copies, not connector->modes, and only for the sink they came from. The highest refresh rate lookup returns nothing without a copy, even with modes in connector->modes, and nothing for a sink with another EDID or none, while a replugged sink with the same EDID keeps the copy. Scaling ignores a preferred mode copy from another sink, and dm_set_freesync_video_config() sets the fixed refresh config only when the copies match the new stream's sink
Signed-off-by: Hugo Sales <[email protected]> --- .../amdgpu_dm/tests/amdgpu_dm_connector_test.c | 120 +++++++++++++++++++++ .../amd/display/amdgpu_dm/tests/amdgpu_dm_test.c | 69 ++++++++++++ 2 files changed, 189 insertions(+) diff --git a/drivers/gpu/drm/amd/display/amdgpu_dm/tests/amdgpu_dm_connector_test.c b/drivers/gpu/drm/amd/display/amdgpu_dm/tests/amdgpu_dm_connector_test.c index 71ad7e4ea5c9e..6fbf85e50872c 100644 --- a/drivers/gpu/drm/amd/display/amdgpu_dm/tests/amdgpu_dm_connector_test.c +++ b/drivers/gpu/drm/amd/display/amdgpu_dm/tests/amdgpu_dm_connector_test.c @@ -2534,6 +2534,95 @@ static void dm_test_highest_refresh_preferred_mode(struct kunit *test) KUNIT_EXPECT_EQ(test, aconnector->freesync_vid_base.clock, 0); } +/** + * dm_test_highest_refresh_skips_modes - Test atomic_check callers never walk base.modes + * @test: The KUnit test context + * + * base.modes needs &drm_mode_config.mutex, which atomic_check doesn't hold. + * Without a copy the lookup returns NULL, even though base.modes has a mode + */ +static void dm_test_highest_refresh_skips_modes(struct kunit *test) +{ + struct amdgpu_dm_connector *aconnector; + struct dc_sink *sink; + struct drm_display_mode *mode; + + aconnector = kunit_kzalloc(test, sizeof(*aconnector), GFP_KERNEL); + KUNIT_ASSERT_NOT_NULL(test, aconnector); + mode = kunit_kzalloc(test, sizeof(*mode), GFP_KERNEL); + KUNIT_ASSERT_NOT_NULL(test, mode); + + aconnector->base.connector_type = DRM_MODE_CONNECTOR_HDMIA; + INIT_LIST_HEAD(&aconnector->base.modes); + INIT_LIST_HEAD(&aconnector->base.probed_modes); + + mode->type = DRM_MODE_TYPE_PREFERRED; + mode->clock = 148500; + mode->hdisplay = 1920; + mode->vdisplay = 1080; + mode->htotal = 2200; + mode->vtotal = 1125; + list_add_tail(&mode->head, &aconnector->base.modes); + + sink = dm_test_copies_sink(test, aconnector); + KUNIT_EXPECT_NULL(test, dm_test_highest_locked(test, aconnector, false, sink)); + KUNIT_EXPECT_EQ(test, aconnector->freesync_vid_base.clock, 0); +} + +/** + * dm_test_highest_refresh_other_sink - Test a copy from another sink is ignored + * @test: The KUnit test context + * + * After a monitor swap the copy describes the previous monitor until the next + * probe, so a sink with another EDID, or with none, gets no freesync base. A + * new sink with the same EDID, as after a replug, keeps it + */ +static void dm_test_highest_refresh_other_sink(struct kunit *test) +{ + struct amdgpu_dm_connector *aconnector; + struct drm_display_mode *mode; + struct dc_sink *probed, *other, *replugged, *no_edid; + + aconnector = kunit_kzalloc(test, sizeof(*aconnector), GFP_KERNEL); + KUNIT_ASSERT_NOT_NULL(test, aconnector); + mode = kunit_kzalloc(test, sizeof(*mode), GFP_KERNEL); + KUNIT_ASSERT_NOT_NULL(test, mode); + other = kunit_kzalloc(test, sizeof(*other), GFP_KERNEL); + KUNIT_ASSERT_NOT_NULL(test, other); + replugged = kunit_kzalloc(test, sizeof(*replugged), GFP_KERNEL); + KUNIT_ASSERT_NOT_NULL(test, replugged); + no_edid = kunit_kzalloc(test, sizeof(*no_edid), GFP_KERNEL); + KUNIT_ASSERT_NOT_NULL(test, no_edid); + + aconnector->base.connector_type = DRM_MODE_CONNECTOR_HDMIA; + INIT_LIST_HEAD(&aconnector->base.probed_modes); + aconnector->freesync_vid_base.clock = 148500; + aconnector->freesync_vid_base.hdisplay = 1920; + aconnector->freesync_vid_base.vdisplay = 1080; + aconnector->freesync_vid_base.htotal = 2200; + aconnector->freesync_vid_base.vtotal = 1125; + drm_mode_copy(mode, &aconnector->freesync_vid_base); + + probed = dm_test_copies_sink(test, aconnector); + replugged->dc_edid = probed->dc_edid; + other->dc_edid = probed->dc_edid; + other->dc_edid.raw_edid[12]++; + + KUNIT_EXPECT_PTR_EQ(test, + dm_test_highest_locked(test, aconnector, false, probed), + &aconnector->freesync_vid_base); + KUNIT_EXPECT_TRUE(test, dm_test_is_fs_video_locked(test, mode, aconnector, probed)); + KUNIT_EXPECT_PTR_EQ(test, + dm_test_highest_locked(test, aconnector, false, replugged), + &aconnector->freesync_vid_base); + + KUNIT_EXPECT_NULL(test, dm_test_highest_locked(test, aconnector, false, other)); + KUNIT_EXPECT_FALSE(test, dm_test_is_fs_video_locked(test, mode, aconnector, other)); + KUNIT_EXPECT_NULL(test, + dm_test_highest_locked(test, aconnector, false, no_edid)); + KUNIT_EXPECT_NULL(test, dm_test_highest_locked(test, aconnector, false, NULL)); +} + /* Tests for amdgpu_dm_connector_update_mode_copies() */ static struct drm_display_mode * @@ -8233,6 +8322,34 @@ static void dm_test_create_validate_stream_scaled_copy(struct kunit *test) KUNIT_EXPECT_EQ(test, dm_test_cvs_first_h_addressable, 3840); } +/** + * dm_test_create_validate_stream_stale_copy - Test atomic_check ignores a stale copy + * @test: The KUnit test context + * + * After a monitor swap the connector has a sink with another EDID, and the + * copy describes the previous monitor. Its timing must not be applied, even + * with scaling on + */ +static void dm_test_create_validate_stream_stale_copy(struct kunit *test) +{ + struct dm_test_cvs_dc *c = dm_test_cvs_dc_alloc(test); + + /* drm_mode_convert_umode() fills in the CRTC timing of atomic modes */ + drm_mode_set_crtcinfo(c->mode, CRTC_INTERLACE_HALVE_V); + c->dm_state->scaling = RMX_FULL; + dm_test_cvs_set_preferred_copy(test, c); + c->aconnector->dc_sink->dc_edid.raw_edid[12]++; + c->tgfuncs->validate_timing = dm_test_cvs_record_first_h_addressable; + dm_test_cvs_first_h_addressable = 0; + + KUNIT_EXPECT_NULL(test, + dm_test_validate_locked(&c->aconnector->base, + c->mode, + c->dm_state, + NULL)); + KUNIT_EXPECT_EQ(test, dm_test_cvs_first_h_addressable, 1920); +} + /** * dm_test_mode_valid_ignores_preferred_copy - Test mode_valid uses the mode's own timing * @test: The KUnit test context @@ -11271,6 +11388,8 @@ static struct kunit_case amdgpu_dm_connector_tests[] = { KUNIT_CASE(dm_test_highest_refresh_cached_base), KUNIT_CASE(dm_test_highest_refresh_preferred_mode), KUNIT_CASE(dm_test_highest_refresh_probed_skips_copy), + KUNIT_CASE(dm_test_highest_refresh_skips_modes), + KUNIT_CASE(dm_test_highest_refresh_other_sink), /* amdgpu_dm_connector_update_mode_copies */ KUNIT_CASE(dm_test_update_mode_copies_highest_refresh), KUNIT_CASE(dm_test_update_mode_copies_no_preferred), @@ -11503,6 +11622,7 @@ static struct kunit_case amdgpu_dm_connector_tests[] = { KUNIT_CASE(dm_test_create_validate_stream_prune_context), KUNIT_CASE(dm_test_create_validate_stream_hdmi_rgb_first), KUNIT_CASE(dm_test_create_validate_stream_scaled_copy), + KUNIT_CASE(dm_test_create_validate_stream_stale_copy), KUNIT_CASE(dm_test_mode_valid_ignores_preferred_copy), /* amdgpu_dm_update_connector_after_detect */ KUNIT_CASE(dm_test_update_after_detect_mst_noop), diff --git a/drivers/gpu/drm/amd/display/amdgpu_dm/tests/amdgpu_dm_test.c b/drivers/gpu/drm/amd/display/amdgpu_dm/tests/amdgpu_dm_test.c index 8eaa5909068bc..b6b3964ce497d 100644 --- a/drivers/gpu/drm/amd/display/amdgpu_dm/tests/amdgpu_dm_test.c +++ b/drivers/gpu/drm/amd/display/amdgpu_dm/tests/amdgpu_dm_test.c @@ -3296,6 +3296,74 @@ static void dm_test_freesync_video_config_no_old_stream(struct kunit *test) amdgpu_freesync_vid_mode = saved_vid_mode; } +/** + * dm_test_freesync_video_config_new_sink - Test the fixed config follows the new stream's sink + * @test: The KUnit test context + * + * The mode is a 50 Hz FreeSync video mode of a 1080p60 base. The fixed config + * is set only when the copies match the sink the new stream was built for, + * the sink create_stream_for_sink() checked when it picked the timing + */ +static void dm_test_freesync_video_config_new_sink(struct kunit *test) +{ + uint saved_vid_mode = amdgpu_freesync_vid_mode; + struct amdgpu_dm_connector *aconnector; + struct drm_display_mode *base, *mode; + struct dm_crtc_state *crtc_state; + struct dc_stream_state *stream; + struct dc_sink *sink, *other; + + aconnector = kunit_kzalloc(test, sizeof(*aconnector), GFP_KERNEL); + KUNIT_ASSERT_NOT_NULL(test, aconnector); + crtc_state = kunit_kzalloc(test, sizeof(*crtc_state), GFP_KERNEL); + KUNIT_ASSERT_NOT_NULL(test, crtc_state); + stream = kunit_kzalloc(test, sizeof(*stream), GFP_KERNEL); + KUNIT_ASSERT_NOT_NULL(test, stream); + sink = kunit_kzalloc(test, sizeof(*sink), GFP_KERNEL); + KUNIT_ASSERT_NOT_NULL(test, sink); + other = kunit_kzalloc(test, sizeof(*other), GFP_KERNEL); + KUNIT_ASSERT_NOT_NULL(test, other); + + aconnector->base.connector_type = DRM_MODE_CONNECTOR_HDMIA; + base = &aconnector->freesync_vid_base; + base->clock = 148500; + base->hdisplay = 1920; + base->hsync_start = 2008; + base->hsync_end = 2052; + base->htotal = 2200; + base->vdisplay = 1080; + base->vsync_start = 1084; + base->vsync_end = 1089; + base->vtotal = 1125; + + mode = &crtc_state->base.mode; + drm_mode_copy(mode, base); + mode->vsync_start += 225; + mode->vsync_end += 225; + mode->vtotal += 225; + + memset(sink->dc_edid.raw_edid, 0x5a, 128); + sink->dc_edid.length = 128; + other->dc_edid = sink->dc_edid; + other->dc_edid.raw_edid[12]++; + aconnector->mode_copies_edid_size = 128; + memcpy(aconnector->mode_copies_edid, sink->dc_edid.raw_edid, 128); + + amdgpu_freesync_vid_mode = 1; + + stream->sink = other; + dm_test_fs_video_config_locked(test, aconnector, crtc_state, stream); + KUNIT_EXPECT_EQ(test, (int)crtc_state->freesync_config.state, + (int)VRR_STATE_UNSUPPORTED); + + stream->sink = sink; + dm_test_fs_video_config_locked(test, aconnector, crtc_state, stream); + KUNIT_EXPECT_EQ(test, (int)crtc_state->freesync_config.state, + (int)VRR_STATE_ACTIVE_FIXED); + + amdgpu_freesync_vid_mode = saved_vid_mode; +} + /** * dm_test_update_crtc_state_unchanged - Test unchanged state needs no validation * @test: The KUnit test context @@ -5443,6 +5511,7 @@ static struct kunit_case amdgpu_dm_tests[] = { KUNIT_CASE(dm_test_aquire_global_lock_no_commit), KUNIT_CASE(dm_test_aquire_global_lock_waits_commit), KUNIT_CASE(dm_test_freesync_video_config_no_old_stream), + KUNIT_CASE(dm_test_freesync_video_config_new_sink), KUNIT_CASE(dm_test_update_crtc_state_unchanged), KUNIT_CASE(dm_test_update_plane_state_detached), KUNIT_CASE(dm_test_mod_power_update_streams_empty), -- 2.56.0
