drm/amd/amdgpu: Fix stack frame size warnings in KUnit tests

[WHAT]
Replace stack-allocated large structs with kunit_kzalloc() in KUnit
test functions that exceed the kernel 1280-byte stack frame limit.
Also add CONFIG_FRAME_WARN=1024 to .kunitconfig to enforce the limit.

Affected structs and files:
- struct dc_link in amdgpu_dm_connector_test.c and
  amdgpu_dm_mst_types_test.c
- struct drm_plane, drm_plane_state, drm_framebuffer in
  amdgpu_dm_plane_test.c
- struct drm_connector_state, drm_atomic_state in
  amdgpu_dm_mst_types_test.c
- struct dm_connector_state in amdgpu_dm_test.c

Reported-by: kernel test robot <lkp@intel.com>
Closes: https://lore.kernel.org/oe-kbuild-all/202606230825.9qMV9L0g-lkp@intel.com/
Assisted-by: Copilot:Claude-Opus-4.6
Acked-by: George Zhang <george.zhang@amd.com>
Signed-off-by: Alex Hung <alex.hung@amd.com>
Signed-off-by: Alex Deucher <alexander.deucher@amd.com>

5 files changed, 208 insertions, 134 deletions

diff --git a/drivers/gpu/drm/amd/display/amdgpu_dm/tests/.kunitconfig b/drivers/gpu/drm/amd/display/amdgpu_dm/tests/.kunitconfig
index 1e93bd8b44ce..c7c8527dbb10 100644
--- a/drivers/gpu/drm/amd/display/amdgpu_dm/tests/.kunitconfig
+++ b/drivers/gpu/drm/amd/display/amdgpu_dm/tests/.kunitconfig
@@ -15,6 +15,9 @@ CONFIG_I2C=y
 CONFIG_POWER_SUPPLY=y
 CONFIG_CRC16=y
 
+# Limit stack size to 1280
+CONFIG_FRAME_WARN=1280
+
 # Treat warnings as errors
 CONFIG_WERROR=y
 
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 34e40d2a9d2c..aa451064b30c 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
@@ -29,10 +29,12 @@
  */
 static void dm_test_subconnector_type_none(struct kunit *test)
 {
-	struct dc_link link = {};
+	struct dc_link *link = kunit_kzalloc(test, sizeof(*link), GFP_KERNEL);
 
-	link.dpcd_caps.dongle_type = DISPLAY_DONGLE_NONE;
-	KUNIT_EXPECT_EQ(test, (int)get_subconnector_type(&link), (int)DRM_MODE_SUBCONNECTOR_Native);
+	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, link);
+
+	link->dpcd_caps.dongle_type = DISPLAY_DONGLE_NONE;
+	KUNIT_EXPECT_EQ(test, (int)get_subconnector_type(link), (int)DRM_MODE_SUBCONNECTOR_Native);
 }
 
 /**
@@ -41,10 +43,12 @@ static void dm_test_subconnector_type_none(struct kunit *test)
  */
 static void dm_test_subconnector_type_vga(struct kunit *test)
 {
-	struct dc_link link = {};
+	struct dc_link *link = kunit_kzalloc(test, sizeof(*link), GFP_KERNEL);
+
+	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, link);
 
-	link.dpcd_caps.dongle_type = DISPLAY_DONGLE_DP_VGA_CONVERTER;
-	KUNIT_EXPECT_EQ(test, (int)get_subconnector_type(&link), (int)DRM_MODE_SUBCONNECTOR_VGA);
+	link->dpcd_caps.dongle_type = DISPLAY_DONGLE_DP_VGA_CONVERTER;
+	KUNIT_EXPECT_EQ(test, (int)get_subconnector_type(link), (int)DRM_MODE_SUBCONNECTOR_VGA);
 }
 
 /**
@@ -53,10 +57,12 @@ static void dm_test_subconnector_type_vga(struct kunit *test)
  */
 static void dm_test_subconnector_type_dvi_converter(struct kunit *test)
 {
-	struct dc_link link = {};
+	struct dc_link *link = kunit_kzalloc(test, sizeof(*link), GFP_KERNEL);
 
-	link.dpcd_caps.dongle_type = DISPLAY_DONGLE_DP_DVI_CONVERTER;
-	KUNIT_EXPECT_EQ(test, (int)get_subconnector_type(&link), (int)DRM_MODE_SUBCONNECTOR_DVID);
+	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, link);
+
+	link->dpcd_caps.dongle_type = DISPLAY_DONGLE_DP_DVI_CONVERTER;
+	KUNIT_EXPECT_EQ(test, (int)get_subconnector_type(link), (int)DRM_MODE_SUBCONNECTOR_DVID);
 }
 
 /**
@@ -65,10 +71,12 @@ static void dm_test_subconnector_type_dvi_converter(struct kunit *test)
  */
 static void dm_test_subconnector_type_dvi_dongle(struct kunit *test)
 {
-	struct dc_link link = {};
+	struct dc_link *link = kunit_kzalloc(test, sizeof(*link), GFP_KERNEL);
+
+	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, link);
 
-	link.dpcd_caps.dongle_type = DISPLAY_DONGLE_DP_DVI_DONGLE;
-	KUNIT_EXPECT_EQ(test, (int)get_subconnector_type(&link), (int)DRM_MODE_SUBCONNECTOR_DVID);
+	link->dpcd_caps.dongle_type = DISPLAY_DONGLE_DP_DVI_DONGLE;
+	KUNIT_EXPECT_EQ(test, (int)get_subconnector_type(link), (int)DRM_MODE_SUBCONNECTOR_DVID);
 }
 
 /**
@@ -77,10 +85,12 @@ static void dm_test_subconnector_type_dvi_dongle(struct kunit *test)
  */
 static void dm_test_subconnector_type_hdmi_converter(struct kunit *test)
 {
-	struct dc_link link = {};
+	struct dc_link *link = kunit_kzalloc(test, sizeof(*link), GFP_KERNEL);
 
-	link.dpcd_caps.dongle_type = DISPLAY_DONGLE_DP_HDMI_CONVERTER;
-	KUNIT_EXPECT_EQ(test, (int)get_subconnector_type(&link), (int)DRM_MODE_SUBCONNECTOR_HDMIA);
+	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, link);
+
+	link->dpcd_caps.dongle_type = DISPLAY_DONGLE_DP_HDMI_CONVERTER;
+	KUNIT_EXPECT_EQ(test, (int)get_subconnector_type(link), (int)DRM_MODE_SUBCONNECTOR_HDMIA);
 }
 
 /**
@@ -89,10 +99,12 @@ static void dm_test_subconnector_type_hdmi_converter(struct kunit *test)
  */
 static void dm_test_subconnector_type_hdmi_dongle(struct kunit *test)
 {
-	struct dc_link link = {};
+	struct dc_link *link = kunit_kzalloc(test, sizeof(*link), GFP_KERNEL);
+
+	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, link);
 
-	link.dpcd_caps.dongle_type = DISPLAY_DONGLE_DP_HDMI_DONGLE;
-	KUNIT_EXPECT_EQ(test, (int)get_subconnector_type(&link), (int)DRM_MODE_SUBCONNECTOR_HDMIA);
+	link->dpcd_caps.dongle_type = DISPLAY_DONGLE_DP_HDMI_DONGLE;
+	KUNIT_EXPECT_EQ(test, (int)get_subconnector_type(link), (int)DRM_MODE_SUBCONNECTOR_HDMIA);
 }
 
 /**
@@ -101,10 +113,12 @@ static void dm_test_subconnector_type_hdmi_dongle(struct kunit *test)
  */
 static void dm_test_subconnector_type_mismatched(struct kunit *test)
 {
-	struct dc_link link = {};
+	struct dc_link *link = kunit_kzalloc(test, sizeof(*link), GFP_KERNEL);
 
-	link.dpcd_caps.dongle_type = DISPLAY_DONGLE_DP_HDMI_MISMATCHED_DONGLE;
-	KUNIT_EXPECT_EQ(test, (int)get_subconnector_type(&link), (int)DRM_MODE_SUBCONNECTOR_Unknown);
+	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, link);
+
+	link->dpcd_caps.dongle_type = DISPLAY_DONGLE_DP_HDMI_MISMATCHED_DONGLE;
+	KUNIT_EXPECT_EQ(test, (int)get_subconnector_type(link), (int)DRM_MODE_SUBCONNECTOR_Unknown);
 }
 
 /**
@@ -113,10 +127,12 @@ static void dm_test_subconnector_type_mismatched(struct kunit *test)
  */
 static void dm_test_subconnector_type_default_unknown(struct kunit *test)
 {
-	struct dc_link link = {};
+	struct dc_link *link = kunit_kzalloc(test, sizeof(*link), GFP_KERNEL);
+
+	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, link);
 
-	link.dpcd_caps.dongle_type = (typeof(link.dpcd_caps.dongle_type))0x7f;
-	KUNIT_EXPECT_EQ(test, (int)get_subconnector_type(&link), (int)DRM_MODE_SUBCONNECTOR_Unknown);
+	link->dpcd_caps.dongle_type = (typeof(link->dpcd_caps.dongle_type))0x7f;
+	KUNIT_EXPECT_EQ(test, (int)get_subconnector_type(link), (int)DRM_MODE_SUBCONNECTOR_Unknown);
 }
 
 /* Tests for get_output_content_type() */
diff --git a/drivers/gpu/drm/amd/display/amdgpu_dm/tests/amdgpu_dm_mst_types_test.c b/drivers/gpu/drm/amd/display/amdgpu_dm/tests/amdgpu_dm_mst_types_test.c
index a6b4df091e8e..3a663ee0ca2b 100644
--- a/drivers/gpu/drm/amd/display/amdgpu_dm/tests/amdgpu_dm_mst_types_test.c
+++ b/drivers/gpu/drm/amd/display/amdgpu_dm/tests/amdgpu_dm_mst_types_test.c
@@ -129,13 +129,15 @@ static ssize_t dm_mst_test_desc_aux_transfer(struct drm_dp_aux *aux,
  */
 static void dm_mst_test_needs_dsc_aux_workaround_match(struct kunit *test)
 {
-	struct dc_link link = {0};
+	struct dc_link *link = kunit_kzalloc(test, sizeof(*link), GFP_KERNEL);
 
-	link.dpcd_caps.branch_dev_id = DP_BRANCH_DEVICE_ID_90CC24;
-	link.dpcd_caps.dpcd_rev.raw = DPCD_REV_14;
-	link.dpcd_caps.sink_count.bits.SINK_COUNT = 2;
+	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, link);
 
-	KUNIT_EXPECT_TRUE(test, needs_dsc_aux_workaround(&link));
+	link->dpcd_caps.branch_dev_id = DP_BRANCH_DEVICE_ID_90CC24;
+	link->dpcd_caps.dpcd_rev.raw = DPCD_REV_14;
+	link->dpcd_caps.sink_count.bits.SINK_COUNT = 2;
+
+	KUNIT_EXPECT_TRUE(test, needs_dsc_aux_workaround(link));
 }
 
 /**
@@ -147,13 +149,15 @@ static void dm_mst_test_needs_dsc_aux_workaround_match(struct kunit *test)
  */
 static void dm_mst_test_needs_dsc_aux_workaround_rev12(struct kunit *test)
 {
-	struct dc_link link = {0};
+	struct dc_link *link = kunit_kzalloc(test, sizeof(*link), GFP_KERNEL);
 
-	link.dpcd_caps.branch_dev_id = DP_BRANCH_DEVICE_ID_90CC24;
-	link.dpcd_caps.dpcd_rev.raw = DPCD_REV_12;
-	link.dpcd_caps.sink_count.bits.SINK_COUNT = 3;
+	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, link);
 
-	KUNIT_EXPECT_TRUE(test, needs_dsc_aux_workaround(&link));
+	link->dpcd_caps.branch_dev_id = DP_BRANCH_DEVICE_ID_90CC24;
+	link->dpcd_caps.dpcd_rev.raw = DPCD_REV_12;
+	link->dpcd_caps.sink_count.bits.SINK_COUNT = 3;
+
+	KUNIT_EXPECT_TRUE(test, needs_dsc_aux_workaround(link));
 }
 
 /**
@@ -165,13 +169,15 @@ static void dm_mst_test_needs_dsc_aux_workaround_rev12(struct kunit *test)
  */
 static void dm_mst_test_needs_dsc_aux_workaround_wrong_dev_id(struct kunit *test)
 {
-	struct dc_link link = {0};
+	struct dc_link *link = kunit_kzalloc(test, sizeof(*link), GFP_KERNEL);
+
+	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, link);
 
-	link.dpcd_caps.branch_dev_id = 0x123456;
-	link.dpcd_caps.dpcd_rev.raw = DPCD_REV_14;
-	link.dpcd_caps.sink_count.bits.SINK_COUNT = 2;
+	link->dpcd_caps.branch_dev_id = 0x123456;
+	link->dpcd_caps.dpcd_rev.raw = DPCD_REV_14;
+	link->dpcd_caps.sink_count.bits.SINK_COUNT = 2;
 
-	KUNIT_EXPECT_FALSE(test, needs_dsc_aux_workaround(&link));
+	KUNIT_EXPECT_FALSE(test, needs_dsc_aux_workaround(link));
 }
 
 /**
@@ -183,13 +189,15 @@ static void dm_mst_test_needs_dsc_aux_workaround_wrong_dev_id(struct kunit *test
  */
 static void dm_mst_test_needs_dsc_aux_workaround_wrong_rev(struct kunit *test)
 {
-	struct dc_link link = {0};
+	struct dc_link *link = kunit_kzalloc(test, sizeof(*link), GFP_KERNEL);
+
+	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, link);
 
-	link.dpcd_caps.branch_dev_id = DP_BRANCH_DEVICE_ID_90CC24;
-	link.dpcd_caps.dpcd_rev.raw = 0x11; /* DPCD 1.1 */
-	link.dpcd_caps.sink_count.bits.SINK_COUNT = 2;
+	link->dpcd_caps.branch_dev_id = DP_BRANCH_DEVICE_ID_90CC24;
+	link->dpcd_caps.dpcd_rev.raw = 0x11; /* DPCD 1.1 */
+	link->dpcd_caps.sink_count.bits.SINK_COUNT = 2;
 
-	KUNIT_EXPECT_FALSE(test, needs_dsc_aux_workaround(&link));
+	KUNIT_EXPECT_FALSE(test, needs_dsc_aux_workaround(link));
 }
 
 /**
@@ -201,13 +209,15 @@ static void dm_mst_test_needs_dsc_aux_workaround_wrong_rev(struct kunit *test)
  */
 static void dm_mst_test_needs_dsc_aux_workaround_low_sink_count(struct kunit *test)
 {
-	struct dc_link link = {0};
+	struct dc_link *link = kunit_kzalloc(test, sizeof(*link), GFP_KERNEL);
 
-	link.dpcd_caps.branch_dev_id = DP_BRANCH_DEVICE_ID_90CC24;
-	link.dpcd_caps.dpcd_rev.raw = DPCD_REV_14;
-	link.dpcd_caps.sink_count.bits.SINK_COUNT = 1;
+	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, link);
+
+	link->dpcd_caps.branch_dev_id = DP_BRANCH_DEVICE_ID_90CC24;
+	link->dpcd_caps.dpcd_rev.raw = DPCD_REV_14;
+	link->dpcd_caps.sink_count.bits.SINK_COUNT = 1;
 
-	KUNIT_EXPECT_FALSE(test, needs_dsc_aux_workaround(&link));
+	KUNIT_EXPECT_FALSE(test, needs_dsc_aux_workaround(link));
 }
 
 /**
@@ -219,13 +229,15 @@ static void dm_mst_test_needs_dsc_aux_workaround_low_sink_count(struct kunit *te
  */
 static void dm_mst_test_needs_dsc_aux_workaround_zero_sink_count(struct kunit *test)
 {
-	struct dc_link link = {0};
+	struct dc_link *link = kunit_kzalloc(test, sizeof(*link), GFP_KERNEL);
 
-	link.dpcd_caps.branch_dev_id = DP_BRANCH_DEVICE_ID_90CC24;
-	link.dpcd_caps.dpcd_rev.raw = DPCD_REV_14;
-	link.dpcd_caps.sink_count.bits.SINK_COUNT = 0;
+	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, link);
 
-	KUNIT_EXPECT_FALSE(test, needs_dsc_aux_workaround(&link));
+	link->dpcd_caps.branch_dev_id = DP_BRANCH_DEVICE_ID_90CC24;
+	link->dpcd_caps.dpcd_rev.raw = DPCD_REV_14;
+	link->dpcd_caps.sink_count.bits.SINK_COUNT = 0;
+
+	KUNIT_EXPECT_FALSE(test, needs_dsc_aux_workaround(link));
 }
 
 /* Tests for dm_mst_get_pbn_divider */
@@ -943,17 +955,23 @@ static void dm_mst_test_create_fake_mst_encoders(struct kunit *test)
  */
 static void dm_mst_test_atomic_check_no_old_crtc(struct kunit *test)
 {
-	struct drm_connector_state old_conn_state = { 0 };
-	struct drm_connector_state new_conn_state = { 0 };
-	struct drm_atomic_commit state = { 0 };
+	struct drm_connector_state *old_conn_state;
+	struct drm_connector_state *new_conn_state;
+	struct drm_atomic_commit *state;
 	struct amdgpu_dm_connector *aconnector;
 	struct amdgpu_dm_connector *root;
 	struct drm_dp_mst_port *port;
 	unsigned int connector_index = 2;
 
+	old_conn_state = kunit_kzalloc(test, sizeof(*old_conn_state), GFP_KERNEL);
+	new_conn_state = kunit_kzalloc(test, sizeof(*new_conn_state), GFP_KERNEL);
+	state = kunit_kzalloc(test, sizeof(*state), GFP_KERNEL);
 	aconnector = kunit_kzalloc(test, sizeof(*aconnector), GFP_KERNEL);
 	root = kunit_kzalloc(test, sizeof(*root), GFP_KERNEL);
 	port = kunit_kzalloc(test, sizeof(*port), GFP_KERNEL);
+	KUNIT_ASSERT_NOT_NULL(test, old_conn_state);
+	KUNIT_ASSERT_NOT_NULL(test, new_conn_state);
+	KUNIT_ASSERT_NOT_NULL(test, state);
 	KUNIT_ASSERT_NOT_NULL(test, aconnector);
 	KUNIT_ASSERT_NOT_NULL(test, root);
 	KUNIT_ASSERT_NOT_NULL(test, port);
@@ -962,18 +980,18 @@ static void dm_mst_test_atomic_check_no_old_crtc(struct kunit *test)
 	aconnector->mst_root = root;
 	aconnector->mst_output_port = port;
 	port->connector = &aconnector->base;
-	old_conn_state.connector = &aconnector->base;
-	new_conn_state.connector = &aconnector->base;
-	state.num_connector = connector_index + 1;
-	state.connectors = kunit_kzalloc(test,
-					 sizeof(*state.connectors) * state.num_connector,
+	old_conn_state->connector = &aconnector->base;
+	new_conn_state->connector = &aconnector->base;
+	state->num_connector = connector_index + 1;
+	state->connectors = kunit_kzalloc(test,
+					 sizeof(*state->connectors) * state->num_connector,
 					 GFP_KERNEL);
-	KUNIT_ASSERT_NOT_NULL(test, state.connectors);
-	state.connectors[connector_index].ptr = &aconnector->base;
-	state.connectors[connector_index].old_state = &old_conn_state;
-	state.connectors[connector_index].new_state = &new_conn_state;
+	KUNIT_ASSERT_NOT_NULL(test, state->connectors);
+	state->connectors[connector_index].ptr = &aconnector->base;
+	state->connectors[connector_index].old_state = old_conn_state;
+	state->connectors[connector_index].new_state = new_conn_state;
 
-	KUNIT_EXPECT_EQ(test, dm_dp_mst_atomic_check(&aconnector->base, &state), 0);
+	KUNIT_EXPECT_EQ(test, dm_dp_mst_atomic_check(&aconnector->base, state), 0);
 }
 
 /**
diff --git a/drivers/gpu/drm/amd/display/amdgpu_dm/tests/amdgpu_dm_plane_test.c b/drivers/gpu/drm/amd/display/amdgpu_dm/tests/amdgpu_dm_plane_test.c
index 071c28abaa8a..46c9af432e37 100644
--- a/drivers/gpu/drm/amd/display/amdgpu_dm/tests/amdgpu_dm_plane_test.c
+++ b/drivers/gpu/drm/amd/display/amdgpu_dm/tests/amdgpu_dm_plane_test.c
@@ -185,22 +185,26 @@ static void dm_test_fill_blending_coverage_alpha_format(struct kunit *test)
 static void dm_test_fill_blending_global_alpha(struct kunit *test)
 {
 	struct amdgpu_device *adev;
-	struct drm_plane plane = {0};
-	struct drm_plane_state state = { 0 };
+	struct drm_plane *plane;
+	struct drm_plane_state *state;
 	bool per_pixel_alpha;
 	bool pre_multiplied_alpha;
 	bool global_alpha;
 	int global_alpha_value;
 
 	adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
+	plane = kunit_kzalloc(test, sizeof(*plane), GFP_KERNEL);
+	state = kunit_kzalloc(test, sizeof(*state), GFP_KERNEL);
 	KUNIT_ASSERT_NOT_NULL(test, adev);
+	KUNIT_ASSERT_NOT_NULL(test, plane);
+	KUNIT_ASSERT_NOT_NULL(test, state);
 
-	plane.dev = &adev->ddev;
-	state.plane = &plane;
-	state.pixel_blend_mode = DRM_MODE_BLEND_PIXEL_NONE;
-	state.alpha = 0x8000;
+	plane->dev = &adev->ddev;
+	state->plane = plane;
+	state->pixel_blend_mode = DRM_MODE_BLEND_PIXEL_NONE;
+	state->alpha = 0x8000;
 
-	amdgpu_dm_plane_fill_blending_from_plane_state(&state,
+	amdgpu_dm_plane_fill_blending_from_plane_state(state,
 						       &per_pixel_alpha,
 						       &pre_multiplied_alpha,
 						       &global_alpha,
@@ -250,23 +254,28 @@ static void dm_test_modifier_gfx9_swizzle_mode(struct kunit *test)
  */
 static void dm_test_get_plane_formats(struct kunit *test)
 {
-	struct drm_plane plane = {0};
-	struct dc_plane_cap cap = {0};
+	struct drm_plane *plane;
+	struct dc_plane_cap *cap;
 	uint32_t formats[32] = {0};
 
-	plane.type = DRM_PLANE_TYPE_PRIMARY;
-	KUNIT_EXPECT_EQ(test, amdgpu_dm_plane_get_plane_formats(&plane, NULL, formats, 32), 14);
+	plane = kunit_kzalloc(test, sizeof(*plane), GFP_KERNEL);
+	cap = kunit_kzalloc(test, sizeof(*cap), GFP_KERNEL);
+	KUNIT_ASSERT_NOT_NULL(test, plane);
+	KUNIT_ASSERT_NOT_NULL(test, cap);
+
+	plane->type = DRM_PLANE_TYPE_PRIMARY;
+	KUNIT_EXPECT_EQ(test, amdgpu_dm_plane_get_plane_formats(plane, NULL, formats, 32), 14);
 
-	cap.pixel_format_support.nv12 = true;
-	cap.pixel_format_support.p010 = true;
-	cap.pixel_format_support.fp16 = true;
-	KUNIT_EXPECT_EQ(test, amdgpu_dm_plane_get_plane_formats(&plane, &cap, formats, 32), 20);
+	cap->pixel_format_support.nv12 = true;
+	cap->pixel_format_support.p010 = true;
+	cap->pixel_format_support.fp16 = true;
+	KUNIT_EXPECT_EQ(test, amdgpu_dm_plane_get_plane_formats(plane, cap, formats, 32), 20);
 
-	plane.type = DRM_PLANE_TYPE_OVERLAY;
-	KUNIT_EXPECT_EQ(test, amdgpu_dm_plane_get_plane_formats(&plane, NULL, formats, 32), 9);
+	plane->type = DRM_PLANE_TYPE_OVERLAY;
+	KUNIT_EXPECT_EQ(test, amdgpu_dm_plane_get_plane_formats(plane, NULL, formats, 32), 9);
 
-	plane.type = DRM_PLANE_TYPE_CURSOR;
-	KUNIT_EXPECT_EQ(test, amdgpu_dm_plane_get_plane_formats(&plane, NULL, formats, 32), 1);
+	plane->type = DRM_PLANE_TYPE_CURSOR;
+	KUNIT_EXPECT_EQ(test, amdgpu_dm_plane_get_plane_formats(plane, NULL, formats, 32), 1);
 }
 
 /**
@@ -433,30 +442,36 @@ static void dm_test_get_cursor_position(struct kunit *test)
 {
 	struct amdgpu_device *adev;
 	struct amdgpu_crtc *amdgpu_crtc;
-	struct drm_plane plane = {0};
-	struct drm_plane_state state = {0};
-	struct drm_framebuffer fb = {0};
+	struct drm_plane *plane;
+	struct drm_plane_state *state;
+	struct drm_framebuffer *fb;
 	struct dc_cursor_position position = {0};
 
 	adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
 	amdgpu_crtc = kunit_kzalloc(test, sizeof(*amdgpu_crtc), GFP_KERNEL);
+	plane = kunit_kzalloc(test, sizeof(*plane), GFP_KERNEL);
+	state = kunit_kzalloc(test, sizeof(*state), GFP_KERNEL);
+	fb = kunit_kzalloc(test, sizeof(*fb), GFP_KERNEL);
 	KUNIT_ASSERT_NOT_NULL(test, adev);
 	KUNIT_ASSERT_NOT_NULL(test, amdgpu_crtc);
+	KUNIT_ASSERT_NOT_NULL(test, plane);
+	KUNIT_ASSERT_NOT_NULL(test, state);
+	KUNIT_ASSERT_NOT_NULL(test, fb);
 
 	adev->ip_versions[DCE_HWIP][0] = IP_VERSION(4, 0, 0);
 	amdgpu_crtc->max_cursor_width = 64;
 	amdgpu_crtc->max_cursor_height = 64;
 
-	plane.dev = &adev->ddev;
-	plane.state = &state;
-	state.fb = &fb;
-	state.crtc_x = -5;
-	state.crtc_y = -7;
-	state.crtc_w = 32;
-	state.crtc_h = 32;
+	plane->dev = &adev->ddev;
+	plane->state = state;
+	state->fb = fb;
+	state->crtc_x = -5;
+	state->crtc_y = -7;
+	state->crtc_w = 32;
+	state->crtc_h = 32;
 
 	KUNIT_ASSERT_EQ(test,
-			amdgpu_dm_plane_get_cursor_position(&plane, &amdgpu_crtc->base, &position),
+			amdgpu_dm_plane_get_cursor_position(plane, &amdgpu_crtc->base, &position),
 			0);
 	KUNIT_EXPECT_TRUE(test, position.enable);
 	KUNIT_EXPECT_EQ(test, position.x, 0);
@@ -466,10 +481,10 @@ static void dm_test_get_cursor_position(struct kunit *test)
 	KUNIT_EXPECT_TRUE(test, position.translate_by_source);
 
 	memset(&position, 0, sizeof(position));
-	state.crtc_x = -64;
-	state.crtc_y = 0;
+	state->crtc_x = -64;
+	state->crtc_y = 0;
 	KUNIT_ASSERT_EQ(test,
-			amdgpu_dm_plane_get_cursor_position(&plane, &amdgpu_crtc->base, &position),
+			amdgpu_dm_plane_get_cursor_position(plane, &amdgpu_crtc->base, &position),
 			0);
 	KUNIT_EXPECT_FALSE(test, position.enable);
 }
@@ -483,35 +498,37 @@ static void dm_test_get_cursor_position(struct kunit *test)
 static void dm_test_format_mod_supported(struct kunit *test)
 {
 	struct amdgpu_device *adev;
-	struct drm_plane plane = {0};
+	struct drm_plane *plane;
 	uint64_t listed_mod;
 
 	adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
+	plane = kunit_kzalloc(test, sizeof(*plane), GFP_KERNEL);
 	KUNIT_ASSERT_NOT_NULL(test, adev);
+	KUNIT_ASSERT_NOT_NULL(test, plane);
 
 	adev->family = AMDGPU_FAMILY_NV;
-	plane.dev = &adev->ddev;
+	plane->dev = &adev->ddev;
 
 	KUNIT_EXPECT_TRUE(test,
-			  amdgpu_dm_plane_format_mod_supported(&plane, DRM_FORMAT_XRGB8888,
+			  amdgpu_dm_plane_format_mod_supported(plane, DRM_FORMAT_XRGB8888,
 							       DRM_FORMAT_MOD_LINEAR));
 	KUNIT_EXPECT_TRUE(test,
-			  amdgpu_dm_plane_format_mod_supported(&plane, DRM_FORMAT_XRGB8888,
+			  amdgpu_dm_plane_format_mod_supported(plane, DRM_FORMAT_XRGB8888,
 							       DRM_FORMAT_MOD_INVALID));
 
 	KUNIT_EXPECT_FALSE(test,
-			   amdgpu_dm_plane_format_mod_supported(&plane, DRM_FORMAT_XRGB8888,
+			   amdgpu_dm_plane_format_mod_supported(plane, DRM_FORMAT_XRGB8888,
 								DRM_FORMAT_MOD_VENDOR_AMD));
 
 	listed_mod = AMD_FMT_MOD |
 		     AMD_FMT_MOD_SET(TILE, AMD_FMT_MOD_TILE_GFX9_64K_S_X) |
 		     AMD_FMT_MOD_SET(TILE_VERSION, AMD_FMT_MOD_TILE_VER_GFX9) |
 		     AMD_FMT_MOD_SET(DCC, 1);
-	plane.modifiers = &listed_mod;
-	plane.modifier_count = 1;
+	plane->modifiers = &listed_mod;
+	plane->modifier_count = 1;
 
 	KUNIT_EXPECT_FALSE(test,
-			   amdgpu_dm_plane_format_mod_supported(&plane, DRM_FORMAT_NV12, listed_mod));
+			   amdgpu_dm_plane_format_mod_supported(plane, DRM_FORMAT_NV12, listed_mod));
 }
 
 /**
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 31194ab42f04..0b29bf0a7d04 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
@@ -452,14 +452,19 @@ static void dm_test_get_plane_scale_zero_src_width(struct kunit *test)
  */
 static void dm_test_scaling_state_same(struct kunit *test)
 {
-	struct dm_connector_state a = { 0 };
-	struct dm_connector_state b = { 0 };
+	struct dm_connector_state *a;
+	struct dm_connector_state *b;
 
-	a.scaling = RMX_FULL;
-	a.underscan_enable = false;
-	b = a;
+	a = kunit_kzalloc(test, sizeof(*a), GFP_KERNEL);
+	b = kunit_kzalloc(test, sizeof(*b), GFP_KERNEL);
+	KUNIT_ASSERT_NOT_NULL(test, a);
+	KUNIT_ASSERT_NOT_NULL(test, b);
 
-	KUNIT_EXPECT_FALSE(test, is_scaling_state_different(&a, &b));
+	a->scaling = RMX_FULL;
+	a->underscan_enable = false;
+	*b = *a;
+
+	KUNIT_EXPECT_FALSE(test, is_scaling_state_different(a, b));
 }
 
 /**
@@ -468,13 +473,18 @@ static void dm_test_scaling_state_same(struct kunit *test)
  */
 static void dm_test_scaling_state_scaling_changed(struct kunit *test)
 {
-	struct dm_connector_state a = { 0 };
-	struct dm_connector_state b = { 0 };
+	struct dm_connector_state *a;
+	struct dm_connector_state *b;
+
+	a = kunit_kzalloc(test, sizeof(*a), GFP_KERNEL);
+	b = kunit_kzalloc(test, sizeof(*b), GFP_KERNEL);
+	KUNIT_ASSERT_NOT_NULL(test, a);
+	KUNIT_ASSERT_NOT_NULL(test, b);
 
-	a.scaling = RMX_FULL;
-	b.scaling = RMX_CENTER;
+	a->scaling = RMX_FULL;
+	b->scaling = RMX_CENTER;
 
-	KUNIT_EXPECT_TRUE(test, is_scaling_state_different(&a, &b));
+	KUNIT_EXPECT_TRUE(test, is_scaling_state_different(a, b));
 }
 
 /**
@@ -483,16 +493,21 @@ static void dm_test_scaling_state_scaling_changed(struct kunit *test)
  */
 static void dm_test_scaling_state_underscan_enabled(struct kunit *test)
 {
-	struct dm_connector_state old_state = { 0 };
-	struct dm_connector_state new_state = { 0 };
+	struct dm_connector_state *old_state;
+	struct dm_connector_state *new_state;
+
+	old_state = kunit_kzalloc(test, sizeof(*old_state), GFP_KERNEL);
+	new_state = kunit_kzalloc(test, sizeof(*new_state), GFP_KERNEL);
+	KUNIT_ASSERT_NOT_NULL(test, old_state);
+	KUNIT_ASSERT_NOT_NULL(test, new_state);
 
 	/* new enables underscan with non-zero borders, old has it disabled */
-	new_state.underscan_enable = true;
-	new_state.underscan_hborder = 16;
-	new_state.underscan_vborder = 16;
-	old_state.underscan_enable = false;
+	new_state->underscan_enable = true;
+	new_state->underscan_hborder = 16;
+	new_state->underscan_vborder = 16;
+	old_state->underscan_enable = false;
 
-	KUNIT_EXPECT_TRUE(test, is_scaling_state_different(&new_state, &old_state));
+	KUNIT_EXPECT_TRUE(test, is_scaling_state_different(new_state, old_state));
 }
 
 /**
@@ -501,16 +516,21 @@ static void dm_test_scaling_state_underscan_enabled(struct kunit *test)
  */
 static void dm_test_scaling_state_underscan_border_changed(struct kunit *test)
 {
-	struct dm_connector_state a = { 0 };
-	struct dm_connector_state b = { 0 };
+	struct dm_connector_state *a;
+	struct dm_connector_state *b;
+
+	a = kunit_kzalloc(test, sizeof(*a), GFP_KERNEL);
+	b = kunit_kzalloc(test, sizeof(*b), GFP_KERNEL);
+	KUNIT_ASSERT_NOT_NULL(test, a);
+	KUNIT_ASSERT_NOT_NULL(test, b);
 
-	a.underscan_enable = true;
-	a.underscan_hborder = 16;
-	a.underscan_vborder = 16;
-	b = a;
-	b.underscan_hborder = 32;
+	a->underscan_enable = true;
+	a->underscan_hborder = 16;
+	a->underscan_vborder = 16;
+	*b = *a;
+	b->underscan_hborder = 32;
 
-	KUNIT_EXPECT_TRUE(test, is_scaling_state_different(&a, &b));
+	KUNIT_EXPECT_TRUE(test, is_scaling_state_different(a, b));
 }
 
 /* Tests for is_timing_unchanged_for_freesync() */