Something went wrong. Try again.
(I'm so sorry!) Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410// SPDX-License-Identifier: GPL-2.0/* * Test cases for the drm_atomic_commit helpers * * Copyright (c) 2024 Qualcomm Innovation Center, Inc. All rights reserved. */
#include <drm/drm_atomic.h>#include <drm/drm_atomic_helper.h>#include <drm/drm_atomic_uapi.h>#include <drm/drm_kunit_helpers.h>#include <drm/drm_probe_helper.h>
#define DRM_TEST_ENC_0 BIT(0)#define DRM_TEST_ENC_1 BIT(1)#define DRM_TEST_ENC_2 BIT(2)
#define DRM_TEST_CONN_0 BIT(0)
struct drm_clone_mode_test { const char *name; u32 encoder_mask; int expected_result;};
static const struct drm_display_mode drm_atomic_test_mode = { DRM_MODE("1024x768", 0, 65000, 1024, 1048, 1184, 1344, 0, 768, 771, 777, 806, 0, DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC)};
struct drm_atomic_test_priv { struct drm_device drm; struct drm_plane *plane; struct drm_crtc *crtc; struct drm_encoder encoders[3]; struct drm_connector connectors[2];};
static int modeset_counter;
static void drm_test_encoder_mode_set(struct drm_encoder *encoder, struct drm_crtc_state *crtc_state, struct drm_connector_state *conn_state){ modeset_counter++;}
static const struct drm_encoder_helper_funcs drm_atomic_test_encoder_funcs = { .atomic_mode_set = drm_test_encoder_mode_set,};
static const struct drm_connector_funcs dummy_connector_funcs = { .atomic_destroy_state = drm_atomic_helper_connector_destroy_state, .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state, .reset = drm_atomic_helper_connector_reset,};
static int drm_atomic_test_dummy_get_modes(struct drm_connector *connector){ return drm_connector_helper_get_modes_fixed(connector, &drm_atomic_test_mode);}
static const struct drm_connector_helper_funcs dummy_connector_helper_funcs = { .get_modes = drm_atomic_test_dummy_get_modes,};
static struct drm_atomic_test_priv *drm_atomic_test_init_drm_components(struct kunit *test, bool has_connectors){ struct drm_atomic_test_priv *priv; struct drm_encoder *enc; struct drm_connector *conn; struct drm_device *drm; struct device *dev; int ret;
dev = drm_kunit_helper_alloc_device(test); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev);
priv = drm_kunit_helper_alloc_drm_device(test, dev, struct drm_atomic_test_priv, drm, DRIVER_MODESET | DRIVER_ATOMIC); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, priv); test->priv = priv;
drm = &priv->drm; priv->plane = drm_kunit_helper_create_primary_plane(test, drm, NULL, NULL, NULL, 0, NULL); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, priv->plane);
priv->crtc = drm_kunit_helper_create_crtc(test, drm, priv->plane, NULL, NULL, NULL); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, priv->crtc);
for (int i = 0; i < ARRAY_SIZE(priv->encoders); i++) { enc = &priv->encoders[i];
ret = drmm_encoder_init(drm, enc, NULL, DRM_MODE_ENCODER_DSI, NULL); KUNIT_ASSERT_EQ(test, ret, 0);
enc->possible_crtcs = drm_crtc_mask(priv->crtc); }
priv->encoders[0].possible_clones = DRM_TEST_ENC_0 | DRM_TEST_ENC_1; priv->encoders[1].possible_clones = DRM_TEST_ENC_0 | DRM_TEST_ENC_1; priv->encoders[2].possible_clones = DRM_TEST_ENC_2;
if (!has_connectors) goto done;
BUILD_BUG_ON(ARRAY_SIZE(priv->connectors) > ARRAY_SIZE(priv->encoders));
for (int i = 0; i < ARRAY_SIZE(priv->connectors); i++) { conn = &priv->connectors[i];
ret = drmm_connector_init(drm, conn, &dummy_connector_funcs, DRM_MODE_CONNECTOR_DSI, NULL); KUNIT_ASSERT_EQ(test, ret, 0);
drm_connector_helper_add(conn, &dummy_connector_helper_funcs); drm_encoder_helper_add(&priv->encoders[i], &drm_atomic_test_encoder_funcs);
drm_connector_attach_encoder(conn, &priv->encoders[i]); }
done: drm_mode_config_reset(drm);
return priv;}
static int set_up_atomic_state(struct kunit *test, struct drm_atomic_test_priv *priv, struct drm_connector *connector, struct drm_modeset_acquire_ctx *ctx){ struct drm_device *drm = &priv->drm; struct drm_crtc *crtc = priv->crtc; struct drm_atomic_commit *state; struct drm_connector_state *conn_state; struct drm_crtc_state *crtc_state; int ret;
state = drm_kunit_helper_atomic_state_alloc(test, drm, ctx); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state);
if (connector) { conn_state = drm_atomic_get_connector_state(state, connector); if (IS_ERR(conn_state)) return PTR_ERR(conn_state);
ret = drm_atomic_set_crtc_for_connector(conn_state, crtc); if (ret) return ret; }
crtc_state = drm_atomic_get_crtc_state(state, crtc); if (IS_ERR(crtc_state)) return PTR_ERR(crtc_state);
ret = drm_atomic_set_mode_for_crtc(crtc_state, &drm_atomic_test_mode); if (ret) return ret;
crtc_state->enable = true; crtc_state->active = true;
if (connector) { ret = drm_atomic_commit(state); if (ret) return ret; } else { // dummy connector mask crtc_state->connector_mask = DRM_TEST_CONN_0; }
return 0;}
/* * Test that the DRM encoder mode_set() is called when the atomic state * connectors are changed but the CRTC mode is not. */static void drm_test_check_connector_changed_modeset(struct kunit *test){ struct drm_atomic_test_priv *priv; struct drm_modeset_acquire_ctx ctx; struct drm_connector *old_conn, *new_conn; struct drm_atomic_commit *state; struct drm_device *drm; struct drm_connector_state *new_conn_state, *old_conn_state; int ret, initial_modeset_count;
priv = drm_atomic_test_init_drm_components(test, true); KUNIT_ASSERT_NOT_NULL(test, priv);
drm = &priv->drm; old_conn = &priv->connectors[0]; new_conn = &priv->connectors[1];
drm_modeset_acquire_init(&ctx, 0);
// first modeset to enableretry_set_up: ret = set_up_atomic_state(test, priv, old_conn, &ctx); if (ret == -EDEADLK) { ret = drm_modeset_backoff(&ctx); if (!ret) goto retry_set_up; } KUNIT_ASSERT_EQ(test, ret, 0);
state = drm_kunit_helper_atomic_state_alloc(test, drm, &ctx); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state);
new_conn_state = drm_atomic_get_connector_state(state, new_conn); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, new_conn_state);
old_conn_state = drm_atomic_get_connector_state(state, old_conn); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, old_conn_state);
ret = drm_atomic_set_crtc_for_connector(old_conn_state, NULL); KUNIT_EXPECT_EQ(test, ret, 0);
ret = drm_atomic_set_crtc_for_connector(new_conn_state, priv->crtc); KUNIT_EXPECT_EQ(test, ret, 0);
initial_modeset_count = modeset_counter;
// modeset_disables is called as part of the atomic commit tail ret = drm_atomic_commit(state); KUNIT_ASSERT_EQ(test, ret, 0); KUNIT_ASSERT_EQ(test, modeset_counter, initial_modeset_count + 1);
drm_modeset_drop_locks(&ctx); drm_modeset_acquire_fini(&ctx);}
/* * Test that the drm_crtc_in_clone_mode() helper can detect if a given CRTC * state is in clone mode */static void drm_test_check_in_clone_mode(struct kunit *test){ bool ret; const struct drm_clone_mode_test *param = test->param_value; struct drm_crtc_state *crtc_state;
crtc_state = kunit_kzalloc(test, sizeof(*crtc_state), GFP_KERNEL); KUNIT_ASSERT_NOT_NULL(test, crtc_state);
crtc_state->encoder_mask = param->encoder_mask;
ret = drm_crtc_in_clone_mode(crtc_state);
KUNIT_ASSERT_EQ(test, ret, param->expected_result);}
/* * Test that the atomic commit path will succeed for valid clones (or non-cloned * states) and fail for states where the cloned encoders are not possible_clones * of each other. */static void drm_test_check_valid_clones(struct kunit *test){ int ret; const struct drm_clone_mode_test *param = test->param_value; struct drm_atomic_test_priv *priv; struct drm_modeset_acquire_ctx ctx; struct drm_device *drm; struct drm_atomic_commit *state; struct drm_crtc_state *crtc_state;
priv = drm_atomic_test_init_drm_components(test, false); KUNIT_ASSERT_NOT_NULL(test, priv);
drm = &priv->drm;
drm_modeset_acquire_init(&ctx, 0);
retry_set_up: ret = set_up_atomic_state(test, priv, NULL, &ctx); if (ret == -EDEADLK) { ret = drm_modeset_backoff(&ctx); if (!ret) goto retry_set_up; } KUNIT_ASSERT_EQ(test, ret, 0);
state = drm_kunit_helper_atomic_state_alloc(test, drm, &ctx); KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state);
retry: crtc_state = drm_atomic_get_crtc_state(state, priv->crtc); if (PTR_ERR(crtc_state) == -EDEADLK) { drm_atomic_commit_clear(state); ret = drm_modeset_backoff(&ctx); if (!ret) goto retry; } KUNIT_ASSERT_NOT_ERR_OR_NULL(test, crtc_state);
crtc_state->encoder_mask = param->encoder_mask;
// force modeset crtc_state->mode_changed = true;
ret = drm_atomic_helper_check_modeset(drm, state); if (ret == -EDEADLK) { drm_atomic_commit_clear(state); ret = drm_modeset_backoff(&ctx); if (!ret) goto retry; } KUNIT_ASSERT_EQ(test, ret, param->expected_result);
drm_modeset_drop_locks(&ctx); drm_modeset_acquire_fini(&ctx);}
static void drm_check_in_clone_mode_desc(const struct drm_clone_mode_test *t, char *desc){ sprintf(desc, "%s", t->name);}
static void drm_check_valid_clones_desc(const struct drm_clone_mode_test *t, char *desc){ sprintf(desc, "%s", t->name);}
static const struct drm_clone_mode_test drm_clone_mode_tests[] = { { .name = "in_clone_mode", .encoder_mask = DRM_TEST_ENC_0 | DRM_TEST_ENC_1, .expected_result = true, }, { .name = "not_in_clone_mode", .encoder_mask = DRM_TEST_ENC_0, .expected_result = false, },};
static const struct drm_clone_mode_test drm_valid_clone_mode_tests[] = { { .name = "not_in_clone_mode", .encoder_mask = DRM_TEST_ENC_0, .expected_result = 0, },
{ .name = "valid_clone", .encoder_mask = DRM_TEST_ENC_0 | DRM_TEST_ENC_1, .expected_result = 0, }, { .name = "invalid_clone", .encoder_mask = DRM_TEST_ENC_0 | DRM_TEST_ENC_2, .expected_result = -EINVAL, },};
KUNIT_ARRAY_PARAM(drm_check_in_clone_mode, drm_clone_mode_tests, drm_check_in_clone_mode_desc);
KUNIT_ARRAY_PARAM(drm_check_valid_clones, drm_valid_clone_mode_tests, drm_check_valid_clones_desc);
static struct kunit_case drm_test_check_modeset_test[] = { KUNIT_CASE(drm_test_check_connector_changed_modeset), {}};
static struct kunit_case drm_in_clone_mode_check_test[] = { KUNIT_CASE_PARAM(drm_test_check_in_clone_mode, drm_check_in_clone_mode_gen_params), KUNIT_CASE_PARAM(drm_test_check_valid_clones, drm_check_valid_clones_gen_params), {}};
static struct kunit_suite drm_test_check_modeset_test_suite = { .name = "drm_validate_modeset", .test_cases = drm_test_check_modeset_test,};
static struct kunit_suite drm_in_clone_mode_check_test_suite = { .name = "drm_validate_clone_mode", .test_cases = drm_in_clone_mode_check_test,};
kunit_test_suites(&drm_in_clone_mode_check_test_suite, &drm_test_check_modeset_test_suite);
MODULE_AUTHOR("Jessica Zhang <quic_jesszhan@quicinc.com");MODULE_DESCRIPTION("Test cases for the drm_atomic_helper functions");MODULE_LICENSE("GPL");