drivers/gpu/drm/tests/drm_atomic_state_test.c - linux - Git at Google

 // SPDX-License-Identifier: GPL-2.0
 /*
  * Test cases for the drm_atomic_state 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_state *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);
 		KUNIT_ASSERT_NOT_ERR_OR_NULL(test, conn_state);

 		ret = drm_atomic_set_crtc_for_connector(conn_state, crtc);
 		KUNIT_EXPECT_EQ(test, ret, 0);
 	}

 	crtc_state = drm_atomic_get_crtc_state(state, crtc);
 	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, crtc_state);

 	ret = drm_atomic_set_mode_for_crtc(crtc_state, &drm_atomic_test_mode);
 	KUNIT_EXPECT_EQ(test, ret, 0);

 	crtc_state->enable = true;
 	crtc_state->active = true;

 	if (connector) {
 		ret = drm_atomic_commit(state);
 		KUNIT_ASSERT_EQ(test, ret, 0);
 	} 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_state *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 enable
 	ret = set_up_atomic_state(test, priv, old_conn, &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);

 	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_state *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);

 	ret = set_up_atomic_state(test, priv, NULL, &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);

 	crtc_state = drm_atomic_get_crtc_state(state, priv->crtc);
 	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);
 	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");
	// SPDX-License-Identifier: GPL-2.0
	/*
	* Test cases for the drm_atomic_state 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_state *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);
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, conn_state);

	ret = drm_atomic_set_crtc_for_connector(conn_state, crtc);
	KUNIT_EXPECT_EQ(test, ret, 0);
	}

	crtc_state = drm_atomic_get_crtc_state(state, crtc);
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, crtc_state);

	ret = drm_atomic_set_mode_for_crtc(crtc_state, &drm_atomic_test_mode);
	KUNIT_EXPECT_EQ(test, ret, 0);

	crtc_state->enable = true;
	crtc_state->active = true;

	if (connector) {
	ret = drm_atomic_commit(state);
	KUNIT_ASSERT_EQ(test, ret, 0);
	} 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_state *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 enable
	ret = set_up_atomic_state(test, priv, old_conn, &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);

	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_state *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);

	ret = set_up_atomic_state(test, priv, NULL, &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);

	crtc_state = drm_atomic_get_crtc_state(state, priv->crtc);
	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);
	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");