#include <kunit/test.h>
#include <drm/drm_atomic.h>
#include <drm/drm_blend.h>
#include <drm/drm_colorop.h>
#include <drm/drm_crtc.h>
#include <drm/drm_fourcc.h>
#include <drm/drm_framebuffer.h>
#include <drm/drm_plane.h>
#include "dc.h"
#include "amdgpu.h"
#include "amdgpu_mode.h"
#include "amdgpu_dm.h"
#include "amdgpu_dm_cursor.h"
#include "amdgpu_dm_kunit_test_helpers.h"
struct dm_cursor_fb_fixture {
struct amdgpu_device *adev;
struct amdgpu_crtc *acrtc;
struct amdgpu_framebuffer *afb;
struct drm_plane_state *plane_state;
};
static struct dm_cursor_fb_fixture dm_test_alloc_cursor_fb_fixture(struct kunit *test)
{
struct dm_cursor_fb_fixture fixture = { 0 };
fixture.adev = dm_kunit_alloc_adev(test);
fixture.acrtc = kunit_kzalloc(test, sizeof(*fixture.acrtc), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, fixture.acrtc);
fixture.afb = kunit_kzalloc(test, sizeof(*fixture.afb), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, fixture.afb);
fixture.plane_state = kunit_kzalloc(test, sizeof(*fixture.plane_state), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, fixture.plane_state);
fixture.acrtc->base.dev = &fixture.adev->ddev;
fixture.acrtc->max_cursor_width = 256;
fixture.acrtc->max_cursor_height = 256;
fixture.afb->base.width = 64;
fixture.afb->base.height = 64;
fixture.afb->base.pitches[0] = 64 * 4;
fixture.afb->base.format = drm_format_info(DRM_FORMAT_ARGB8888);
fixture.plane_state->fb = &fixture.afb->base;
fixture.plane_state->src_w = 64 << 16;
fixture.plane_state->src_h = 64 << 16;
return fixture;
}
struct dm_cursor_mode_fixture {
struct amdgpu_device *adev;
struct drm_atomic_commit *state;
struct dm_crtc_state *dm_crtc_state;
struct drm_crtc *crtc;
struct drm_plane *cursor;
struct drm_plane *primary;
struct drm_plane_state *old_cursor_state;
struct drm_plane_state *cursor_state;
struct drm_plane_state *old_primary_state;
struct drm_plane_state *primary_state;
struct drm_framebuffer *cursor_fb;
struct drm_framebuffer *primary_fb;
};
static struct dm_cursor_mode_fixture dm_test_alloc_cursor_mode_fixture(struct kunit *test)
{
struct dm_cursor_mode_fixture fixture = { 0 };
fixture.adev = dm_kunit_alloc_adev(test);
fixture.state = kunit_kzalloc(test, sizeof(*fixture.state), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, fixture.state);
fixture.dm_crtc_state = kunit_kzalloc(test, sizeof(*fixture.dm_crtc_state), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, fixture.dm_crtc_state);
fixture.crtc = kunit_kzalloc(test, sizeof(*fixture.crtc), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, fixture.crtc);
fixture.cursor = kunit_kzalloc(test, sizeof(*fixture.cursor), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, fixture.cursor);
fixture.primary = kunit_kzalloc(test, sizeof(*fixture.primary), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, fixture.primary);
fixture.old_cursor_state =
kunit_kzalloc(test, sizeof(*fixture.old_cursor_state), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, fixture.old_cursor_state);
fixture.cursor_state = kunit_kzalloc(test, sizeof(*fixture.cursor_state), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, fixture.cursor_state);
fixture.old_primary_state =
kunit_kzalloc(test, sizeof(*fixture.old_primary_state), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, fixture.old_primary_state);
fixture.primary_state = kunit_kzalloc(test, sizeof(*fixture.primary_state), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, fixture.primary_state);
fixture.cursor_fb = kunit_kzalloc(test, sizeof(*fixture.cursor_fb), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, fixture.cursor_fb);
fixture.primary_fb = kunit_kzalloc(test, sizeof(*fixture.primary_fb), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, fixture.primary_fb);
fixture.state->planes = kunit_kcalloc(test, 2, sizeof(*fixture.state->planes), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, fixture.state->planes);
fixture.state->acquire_ctx =
kunit_kzalloc(test, sizeof(*fixture.state->acquire_ctx), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, fixture.state->acquire_ctx);
fixture.adev->ddev.mode_config.num_total_plane = 2;
fixture.state->dev = &fixture.adev->ddev;
fixture.crtc->dev = &fixture.adev->ddev;
fixture.crtc->cursor = fixture.cursor;
fixture.cursor->dev = &fixture.adev->ddev;
fixture.cursor->index = 0;
fixture.cursor->type = DRM_PLANE_TYPE_CURSOR;
fixture.cursor->base.id = 2;
fixture.primary->dev = &fixture.adev->ddev;
fixture.primary->index = 1;
fixture.primary->type = DRM_PLANE_TYPE_PRIMARY;
fixture.primary->base.id = 1;
fixture.cursor_fb->format = drm_format_info(DRM_FORMAT_ARGB8888);
fixture.primary_fb->format = drm_format_info(DRM_FORMAT_XRGB8888);
fixture.old_cursor_state->plane = fixture.cursor;
fixture.old_cursor_state->crtc = fixture.crtc;
fixture.old_cursor_state->fb = fixture.cursor_fb;
fixture.old_cursor_state->src_w = 64 << 16;
fixture.old_cursor_state->src_h = 64 << 16;
fixture.old_cursor_state->crtc_w = 64;
fixture.old_cursor_state->crtc_h = 64;
fixture.old_cursor_state->zpos = 1;
*fixture.cursor_state = *fixture.old_cursor_state;
fixture.cursor_state->state = fixture.state;
fixture.old_primary_state->plane = fixture.primary;
fixture.old_primary_state->crtc = fixture.crtc;
fixture.old_primary_state->fb = fixture.primary_fb;
fixture.old_primary_state->src_w = 1920 << 16;
fixture.old_primary_state->src_h = 1080 << 16;
fixture.old_primary_state->crtc_w = 1920;
fixture.old_primary_state->crtc_h = 1080;
fixture.old_primary_state->zpos = 0;
*fixture.primary_state = *fixture.old_primary_state;
fixture.primary_state->state = fixture.state;
fixture.state->planes[0].ptr = fixture.cursor;
fixture.state->planes[0].old_state = fixture.old_cursor_state;
fixture.state->planes[0].new_state = fixture.cursor_state;
fixture.state->planes[1].ptr = fixture.primary;
fixture.state->planes[1].old_state = fixture.old_primary_state;
fixture.state->planes[1].new_state = fixture.primary_state;
fixture.dm_crtc_state->base.crtc = fixture.crtc;
fixture.dm_crtc_state->base.enable = true;
fixture.dm_crtc_state->base.plane_mask = drm_plane_mask(fixture.cursor) |
drm_plane_mask(fixture.primary);
fixture.dm_crtc_state->base.zpos_changed = true;
fixture.dm_crtc_state->base.mode.hdisplay = 1920;
fixture.dm_crtc_state->base.mode.vdisplay = 1080;
return fixture;
}
static void dm_test_add_cursor_mode_colorop(struct kunit *test,
struct dm_cursor_mode_fixture *fixture,
bool old_bypass, bool new_bypass)
{
struct drm_colorop_state *old_colorop_state;
struct drm_colorop_state *new_colorop_state;
struct drm_colorop *colorop;
colorop = kunit_kzalloc(test, sizeof(*colorop), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, colorop);
old_colorop_state = kunit_kzalloc(test, sizeof(*old_colorop_state), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, old_colorop_state);
new_colorop_state = kunit_kzalloc(test, sizeof(*new_colorop_state), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, new_colorop_state);
fixture->state->colorops =
kunit_kzalloc(test, sizeof(*fixture->state->colorops), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, fixture->state->colorops);
fixture->adev->ddev.mode_config.num_colorop = 1;
fixture->state->colorops[0].ptr = colorop;
fixture->state->colorops[0].old_state = old_colorop_state;
fixture->state->colorops[0].new_state = new_colorop_state;
colorop->plane = fixture->primary;
old_colorop_state->colorop = colorop;
old_colorop_state->bypass = old_bypass;
new_colorop_state->colorop = colorop;
new_colorop_state->bypass = new_bypass;
}
static int dm_test_get_cursor_mode(struct dm_cursor_mode_fixture *fixture,
enum amdgpu_dm_cursor_mode *cursor_mode)
{
return amdgpu_dm_crtc_get_cursor_mode(fixture->adev, fixture->state,
fixture->dm_crtc_state, cursor_mode);
}
static void dm_test_check_cursor_fb_valid_linear(struct kunit *test)
{
struct dm_cursor_fb_fixture fixture = dm_test_alloc_cursor_fb_fixture(test);
fixture.adev->family = AMDGPU_FAMILY_AI;
KUNIT_EXPECT_EQ(test,
dm_check_cursor_fb(fixture.acrtc, fixture.plane_state, &fixture.afb->base),
0);
}
static void dm_test_check_cursor_fb_rejects_size(struct kunit *test)
{
struct dm_cursor_fb_fixture fixture = dm_test_alloc_cursor_fb_fixture(test);
fixture.afb->base.width = fixture.acrtc->max_cursor_width + 1;
KUNIT_EXPECT_EQ(test,
dm_check_cursor_fb(fixture.acrtc, fixture.plane_state, &fixture.afb->base),
-EINVAL);
}
static void dm_test_check_cursor_fb_rejects_cropping(struct kunit *test)
{
struct dm_cursor_fb_fixture fixture = dm_test_alloc_cursor_fb_fixture(test);
fixture.plane_state->src_w = 32 << 16;
KUNIT_EXPECT_EQ(test,
dm_check_cursor_fb(fixture.acrtc, fixture.plane_state, &fixture.afb->base),
-EINVAL);
}
static void dm_test_check_cursor_fb_rejects_pitch(struct kunit *test)
{
struct dm_cursor_fb_fixture fixture = dm_test_alloc_cursor_fb_fixture(test);
fixture.afb->base.pitches[0] = 96 * 4;
KUNIT_EXPECT_EQ(test,
dm_check_cursor_fb(fixture.acrtc, fixture.plane_state, &fixture.afb->base),
-EINVAL);
}
static void dm_test_check_cursor_fb_rejects_unsupported_pitch(struct kunit *test)
{
struct dm_cursor_fb_fixture fixture = dm_test_alloc_cursor_fb_fixture(test);
fixture.afb->base.width = 32;
fixture.afb->base.pitches[0] = 32 * 4;
fixture.plane_state->src_w = 32 << 16;
KUNIT_EXPECT_EQ(test,
dm_check_cursor_fb(fixture.acrtc, fixture.plane_state, &fixture.afb->base),
-EINVAL);
}
static void dm_test_check_cursor_fb_rejects_tiling(struct kunit *test)
{
struct dm_cursor_fb_fixture fixture = dm_test_alloc_cursor_fb_fixture(test);
fixture.adev->family = AMDGPU_FAMILY_AI;
fixture.afb->tiling_flags = AMDGPU_TILING_SET(SWIZZLE_MODE, 1);
KUNIT_EXPECT_EQ(test,
dm_check_cursor_fb(fixture.acrtc, fixture.plane_state, &fixture.afb->base),
-EINVAL);
}
static void dm_test_check_cursor_fb_gfx12_tiling(struct kunit *test)
{
struct dm_cursor_fb_fixture fixture = dm_test_alloc_cursor_fb_fixture(test);
fixture.adev->family = AMDGPU_FAMILY_GC_12_0_0;
KUNIT_EXPECT_EQ(test,
dm_check_cursor_fb(fixture.acrtc, fixture.plane_state, &fixture.afb->base),
0);
fixture.afb->tiling_flags = AMDGPU_TILING_SET(GFX12_SWIZZLE_MODE, 1);
KUNIT_EXPECT_EQ(test,
dm_check_cursor_fb(fixture.acrtc, fixture.plane_state, &fixture.afb->base),
-EINVAL);
}
static void dm_test_check_cursor_fb_pre_ai_tiling(struct kunit *test)
{
struct dm_cursor_fb_fixture fixture = dm_test_alloc_cursor_fb_fixture(test);
fixture.adev->family = AMDGPU_FAMILY_CZ;
KUNIT_EXPECT_EQ(test,
dm_check_cursor_fb(fixture.acrtc, fixture.plane_state, &fixture.afb->base),
0);
fixture.afb->tiling_flags = AMDGPU_TILING_SET(ARRAY_MODE, DC_ARRAY_1D_TILED_THIN1);
KUNIT_EXPECT_EQ(test,
dm_check_cursor_fb(fixture.acrtc, fixture.plane_state, &fixture.afb->base),
-EINVAL);
}
static void dm_test_check_cursor_fb_modifier_skips_tiling(struct kunit *test)
{
struct dm_cursor_fb_fixture fixture = dm_test_alloc_cursor_fb_fixture(test);
fixture.adev->family = AMDGPU_FAMILY_AI;
fixture.afb->base.flags = DRM_MODE_FB_MODIFIERS;
fixture.afb->tiling_flags = AMDGPU_TILING_SET(SWIZZLE_MODE, 1);
KUNIT_EXPECT_EQ(test,
dm_check_cursor_fb(fixture.acrtc, fixture.plane_state, &fixture.afb->base),
0);
}
static void dm_test_check_native_cursor_state_disabled(struct kunit *test)
{
KUNIT_EXPECT_EQ(test,
amdgpu_dm_check_native_cursor_state(NULL, NULL, NULL, false),
0);
}
static void dm_test_check_native_cursor_state_rejects_offset(struct kunit *test)
{
struct amdgpu_device *adev = dm_kunit_alloc_adev(test);
struct amdgpu_crtc *acrtc;
struct drm_plane *plane;
struct drm_framebuffer *fb;
struct drm_plane_state *old_plane_state;
struct drm_plane_state *new_plane_state;
int ret;
acrtc = kunit_kzalloc(test, sizeof(*acrtc), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, acrtc);
plane = kunit_kzalloc(test, sizeof(*plane), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, plane);
fb = kunit_kzalloc(test, sizeof(*fb), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, fb);
old_plane_state = kunit_kzalloc(test, sizeof(*old_plane_state), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, old_plane_state);
new_plane_state = kunit_kzalloc(test, sizeof(*new_plane_state), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, new_plane_state);
acrtc->base.dev = &adev->ddev;
old_plane_state->crtc = &acrtc->base;
new_plane_state->crtc = &acrtc->base;
new_plane_state->fb = fb;
new_plane_state->src_x = 1;
plane->state = old_plane_state;
ret = amdgpu_dm_check_native_cursor_state(&acrtc->base, plane,
new_plane_state, true);
KUNIT_EXPECT_EQ(test, ret, -EINVAL);
}
static void dm_test_check_native_cursor_state_checks_fb(struct kunit *test)
{
struct dm_cursor_fb_fixture fixture = dm_test_alloc_cursor_fb_fixture(test);
struct drm_plane *plane;
struct drm_plane_state *old_plane_state;
int ret;
plane = kunit_kzalloc(test, sizeof(*plane), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, plane);
old_plane_state = kunit_kzalloc(test, sizeof(*old_plane_state), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, old_plane_state);
old_plane_state->crtc = &fixture.acrtc->base;
fixture.plane_state->crtc = &fixture.acrtc->base;
plane->state = old_plane_state;
ret = amdgpu_dm_check_native_cursor_state(&fixture.acrtc->base, plane,
fixture.plane_state, true);
KUNIT_EXPECT_EQ(test, ret, 0);
fixture.afb->base.width = fixture.acrtc->max_cursor_width + 1;
ret = amdgpu_dm_check_native_cursor_state(&fixture.acrtc->base, plane,
fixture.plane_state, true);
KUNIT_EXPECT_EQ(test, ret, -EINVAL);
}
static void dm_test_plane_color_pipeline_active(struct kunit *test)
{
struct amdgpu_device *adev = dm_kunit_alloc_adev(test);
struct drm_atomic_commit *state;
struct drm_colorop *colorop;
struct drm_colorop_state *old_colorop_state;
struct drm_colorop_state *new_colorop_state;
struct drm_plane *plane;
state = kunit_kzalloc(test, sizeof(*state), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, state);
colorop = kunit_kzalloc(test, sizeof(*colorop), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, colorop);
old_colorop_state = kunit_kzalloc(test, sizeof(*old_colorop_state), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, old_colorop_state);
new_colorop_state = kunit_kzalloc(test, sizeof(*new_colorop_state), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, new_colorop_state);
plane = kunit_kzalloc(test, sizeof(*plane), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, plane);
state->colorops = kunit_kzalloc(test, sizeof(*state->colorops), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, state->colorops);
adev->ddev.mode_config.num_colorop = 1;
state->dev = &adev->ddev;
state->colorops[0].ptr = colorop;
state->colorops[0].old_state = old_colorop_state;
state->colorops[0].new_state = new_colorop_state;
colorop->plane = plane;
old_colorop_state->colorop = colorop;
old_colorop_state->bypass = true;
new_colorop_state->colorop = colorop;
new_colorop_state->bypass = false;
KUNIT_EXPECT_FALSE(test, dm_plane_color_pipeline_active(state, plane, true));
KUNIT_EXPECT_TRUE(test, dm_plane_color_pipeline_active(state, plane, false));
}
static void dm_test_plane_color_pipeline_ignores_other_plane(struct kunit *test)
{
struct amdgpu_device *adev = dm_kunit_alloc_adev(test);
struct drm_atomic_commit *state;
struct drm_colorop *colorop;
struct drm_colorop_state *colorop_state;
struct drm_plane *colorop_plane;
struct drm_plane *other_plane;
state = kunit_kzalloc(test, sizeof(*state), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, state);
colorop = kunit_kzalloc(test, sizeof(*colorop), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, colorop);
colorop_state = kunit_kzalloc(test, sizeof(*colorop_state), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, colorop_state);
colorop_plane = kunit_kzalloc(test, sizeof(*colorop_plane), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, colorop_plane);
other_plane = kunit_kzalloc(test, sizeof(*other_plane), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, other_plane);
state->colorops = kunit_kzalloc(test, sizeof(*state->colorops), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, state->colorops);
adev->ddev.mode_config.num_colorop = 1;
state->dev = &adev->ddev;
state->colorops[0].ptr = colorop;
state->colorops[0].new_state = colorop_state;
colorop->plane = colorop_plane;
colorop_state->colorop = colorop;
KUNIT_EXPECT_FALSE(test, dm_plane_color_pipeline_active(state, other_plane, false));
}
static void dm_test_crtc_get_cursor_mode_disabled_crtc(struct kunit *test)
{
struct dm_cursor_mode_fixture fixture = dm_test_alloc_cursor_mode_fixture(test);
enum amdgpu_dm_cursor_mode cursor_mode = DM_CURSOR_OVERLAY_MODE;
fixture.dm_crtc_state->base.enable = false;
fixture.old_primary_state->crtc_w = 1280;
fixture.primary_state->crtc_w = 1280;
KUNIT_EXPECT_EQ(test, dm_test_get_cursor_mode(&fixture, &cursor_mode), 0);
KUNIT_EXPECT_EQ(test, cursor_mode, DM_CURSOR_NATIVE_MODE);
}
static void dm_test_crtc_get_cursor_mode_new_hardware(struct kunit *test)
{
struct dm_cursor_mode_fixture fixture = dm_test_alloc_cursor_mode_fixture(test);
enum amdgpu_dm_cursor_mode cursor_mode = DM_CURSOR_OVERLAY_MODE;
fixture.adev->ip_versions[DCE_HWIP][0] = IP_VERSION(4, 2, 0);
KUNIT_EXPECT_EQ(test, dm_test_get_cursor_mode(&fixture, &cursor_mode), 0);
KUNIT_EXPECT_EQ(test, cursor_mode, DM_CURSOR_NATIVE_MODE);
}
static void dm_test_crtc_get_cursor_mode_new_hardware_hole(struct kunit *test)
{
struct dm_cursor_mode_fixture fixture = dm_test_alloc_cursor_mode_fixture(test);
enum amdgpu_dm_cursor_mode cursor_mode = DM_CURSOR_NATIVE_MODE;
fixture.adev->ip_versions[DCE_HWIP][0] = IP_VERSION(4, 2, 0);
fixture.old_primary_state->crtc_w = 1280;
fixture.primary_state->crtc_w = 1280;
KUNIT_EXPECT_EQ(test, dm_test_get_cursor_mode(&fixture, &cursor_mode), 0);
KUNIT_EXPECT_EQ(test, cursor_mode, DM_CURSOR_OVERLAY_MODE);
}
static void dm_test_crtc_get_cursor_mode_no_change(struct kunit *test)
{
struct amdgpu_device *adev = dm_kunit_alloc_adev(test);
struct drm_atomic_commit *state;
struct dm_crtc_state *dm_crtc_state;
enum amdgpu_dm_cursor_mode cursor_mode = DM_CURSOR_NATIVE_MODE;
int ret;
state = kunit_kzalloc(test, sizeof(*state), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, state);
dm_crtc_state = kunit_kzalloc(test, sizeof(*dm_crtc_state), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, dm_crtc_state);
state->dev = &adev->ddev;
dm_crtc_state->base.enable = true;
dm_crtc_state->cursor_mode = DM_CURSOR_OVERLAY_MODE;
ret = amdgpu_dm_crtc_get_cursor_mode(adev, state, dm_crtc_state, &cursor_mode);
KUNIT_EXPECT_EQ(test, ret, 0);
KUNIT_EXPECT_EQ(test, cursor_mode, DM_CURSOR_OVERLAY_MODE);
}
static void dm_test_crtc_get_cursor_mode_disabled_cursor(struct kunit *test)
{
struct dm_cursor_mode_fixture fixture = dm_test_alloc_cursor_mode_fixture(test);
enum amdgpu_dm_cursor_mode cursor_mode = DM_CURSOR_NATIVE_MODE;
fixture.cursor_state->crtc = NULL;
fixture.cursor_state->fb = NULL;
KUNIT_EXPECT_EQ(test, dm_test_get_cursor_mode(&fixture, &cursor_mode), 0);
KUNIT_EXPECT_EQ(test, cursor_mode, DM_CURSOR_NATIVE_MODE);
}
static void dm_test_crtc_get_cursor_mode_yuv_plane(struct kunit *test)
{
struct dm_cursor_mode_fixture fixture = dm_test_alloc_cursor_mode_fixture(test);
enum amdgpu_dm_cursor_mode cursor_mode = DM_CURSOR_NATIVE_MODE;
fixture.primary_fb->format = drm_format_info(DRM_FORMAT_NV12);
KUNIT_EXPECT_EQ(test, dm_test_get_cursor_mode(&fixture, &cursor_mode), 0);
KUNIT_EXPECT_EQ(test, cursor_mode, DM_CURSOR_OVERLAY_MODE);
}
static void dm_test_crtc_get_cursor_mode_scale_mismatch(struct kunit *test)
{
struct dm_cursor_mode_fixture fixture = dm_test_alloc_cursor_mode_fixture(test);
enum amdgpu_dm_cursor_mode cursor_mode = DM_CURSOR_NATIVE_MODE;
fixture.old_primary_state->src_w = 960 << 16;
fixture.old_primary_state->src_h = 540 << 16;
fixture.primary_state->src_w = 960 << 16;
fixture.primary_state->src_h = 540 << 16;
KUNIT_EXPECT_EQ(test, dm_test_get_cursor_mode(&fixture, &cursor_mode), 0);
KUNIT_EXPECT_EQ(test, cursor_mode, DM_CURSOR_OVERLAY_MODE);
}
static void dm_test_crtc_get_cursor_mode_full_coverage(struct kunit *test)
{
struct dm_cursor_mode_fixture fixture = dm_test_alloc_cursor_mode_fixture(test);
enum amdgpu_dm_cursor_mode cursor_mode = DM_CURSOR_OVERLAY_MODE;
KUNIT_EXPECT_EQ(test, dm_test_get_cursor_mode(&fixture, &cursor_mode), 0);
KUNIT_EXPECT_EQ(test, cursor_mode, DM_CURSOR_NATIVE_MODE);
}
static void dm_test_crtc_get_cursor_mode_hole(struct kunit *test)
{
struct dm_cursor_mode_fixture fixture = dm_test_alloc_cursor_mode_fixture(test);
enum amdgpu_dm_cursor_mode cursor_mode = DM_CURSOR_NATIVE_MODE;
fixture.old_primary_state->crtc_w = 1280;
fixture.primary_state->crtc_w = 1280;
KUNIT_EXPECT_EQ(test, dm_test_get_cursor_mode(&fixture, &cursor_mode), 0);
KUNIT_EXPECT_EQ(test, cursor_mode, DM_CURSOR_OVERLAY_MODE);
}
static void dm_test_crtc_get_cursor_mode_without_cursor(struct kunit *test)
{
struct dm_cursor_mode_fixture fixture = dm_test_alloc_cursor_mode_fixture(test);
enum amdgpu_dm_cursor_mode cursor_mode = DM_CURSOR_NATIVE_MODE;
fixture.state->planes[0].ptr = NULL;
fixture.dm_crtc_state->base.plane_mask = drm_plane_mask(fixture.primary);
KUNIT_EXPECT_EQ(test, dm_test_get_cursor_mode(&fixture, &cursor_mode), 0);
KUNIT_EXPECT_EQ(test, cursor_mode, DM_CURSOR_NATIVE_MODE);
}
static void dm_test_crtc_get_cursor_mode_scale_changed(struct kunit *test)
{
struct dm_cursor_mode_fixture fixture = dm_test_alloc_cursor_mode_fixture(test);
enum amdgpu_dm_cursor_mode cursor_mode = DM_CURSOR_NATIVE_MODE;
fixture.primary_state->src_w = 960 << 16;
fixture.primary_state->src_h = 540 << 16;
KUNIT_EXPECT_EQ(test, dm_test_get_cursor_mode(&fixture, &cursor_mode), 0);
KUNIT_EXPECT_EQ(test, cursor_mode, DM_CURSOR_OVERLAY_MODE);
}
static void dm_test_crtc_get_cursor_mode_position_changed(struct kunit *test)
{
struct dm_cursor_mode_fixture fixture = dm_test_alloc_cursor_mode_fixture(test);
enum amdgpu_dm_cursor_mode cursor_mode = DM_CURSOR_NATIVE_MODE;
fixture.primary_state->crtc_x = 1;
KUNIT_EXPECT_EQ(test, dm_test_get_cursor_mode(&fixture, &cursor_mode), 0);
KUNIT_EXPECT_EQ(test, cursor_mode, DM_CURSOR_OVERLAY_MODE);
}
static void dm_test_crtc_get_cursor_mode_color_pipeline(struct kunit *test)
{
struct dm_cursor_mode_fixture fixture = dm_test_alloc_cursor_mode_fixture(test);
enum amdgpu_dm_cursor_mode cursor_mode = DM_CURSOR_NATIVE_MODE;
dm_test_add_cursor_mode_colorop(test, &fixture, true, false);
KUNIT_EXPECT_EQ(test, dm_test_get_cursor_mode(&fixture, &cursor_mode), 0);
KUNIT_EXPECT_EQ(test, cursor_mode, DM_CURSOR_OVERLAY_MODE);
}
static void dm_test_should_update_native_cursor_without_crtc(struct kunit *test)
{
KUNIT_EXPECT_TRUE(test, amdgpu_dm_should_update_native_cursor(NULL, NULL, NULL, false));
KUNIT_EXPECT_TRUE(test, amdgpu_dm_should_update_native_cursor(NULL, NULL, NULL, true));
}
static void dm_test_should_update_native_cursor_disable_native(struct kunit *test)
{
struct dm_crtc_state *dm_crtc_state;
struct drm_atomic_commit *state;
struct drm_crtc *crtc;
state = kunit_kzalloc(test, sizeof(*state), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, state);
crtc = kunit_kzalloc(test, sizeof(*crtc), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, crtc);
dm_crtc_state = kunit_kzalloc(test, sizeof(*dm_crtc_state), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, dm_crtc_state);
state->crtcs = kunit_kzalloc(test, sizeof(*state->crtcs), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, state->crtcs);
crtc->index = 0;
dm_crtc_state->cursor_mode = DM_CURSOR_NATIVE_MODE;
state->crtcs[0].old_state = &dm_crtc_state->base;
KUNIT_EXPECT_TRUE(test,
amdgpu_dm_should_update_native_cursor(state, crtc, NULL, false));
}
static void dm_test_should_update_native_cursor_enable_overlay(struct kunit *test)
{
struct dm_crtc_state *dm_crtc_state;
struct drm_atomic_commit *state;
struct drm_crtc *crtc;
state = kunit_kzalloc(test, sizeof(*state), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, state);
crtc = kunit_kzalloc(test, sizeof(*crtc), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, crtc);
dm_crtc_state = kunit_kzalloc(test, sizeof(*dm_crtc_state), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, dm_crtc_state);
state->crtcs = kunit_kzalloc(test, sizeof(*state->crtcs), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, state->crtcs);
crtc->index = 0;
dm_crtc_state->cursor_mode = DM_CURSOR_OVERLAY_MODE;
state->crtcs[0].new_state = &dm_crtc_state->base;
KUNIT_EXPECT_FALSE(test,
amdgpu_dm_should_update_native_cursor(state, NULL, crtc, true));
}
static void dm_test_oriented_plane_size_rotate_0(struct kunit *test)
{
struct drm_plane_state plane_state = { 0 };
int src_w = 0;
int src_h = 0;
plane_state.rotation = DRM_MODE_ROTATE_0;
plane_state.src_w = 1920 << 16;
plane_state.src_h = 1080 << 16;
dm_get_oriented_plane_size(&plane_state, &src_w, &src_h);
KUNIT_EXPECT_EQ(test, src_w, 1920);
KUNIT_EXPECT_EQ(test, src_h, 1080);
}
static void dm_test_oriented_plane_size_rotate_90(struct kunit *test)
{
struct drm_plane_state plane_state = { 0 };
int src_w = 0;
int src_h = 0;
plane_state.rotation = DRM_MODE_ROTATE_90;
plane_state.src_w = 1920 << 16;
plane_state.src_h = 1080 << 16;
dm_get_oriented_plane_size(&plane_state, &src_w, &src_h);
KUNIT_EXPECT_EQ(test, src_w, 1080);
KUNIT_EXPECT_EQ(test, src_h, 1920);
}
static void dm_test_oriented_plane_size_rotate_180(struct kunit *test)
{
struct drm_plane_state plane_state = { 0 };
int src_w = 0;
int src_h = 0;
plane_state.rotation = DRM_MODE_ROTATE_180;
plane_state.src_w = 1920 << 16;
plane_state.src_h = 1080 << 16;
dm_get_oriented_plane_size(&plane_state, &src_w, &src_h);
KUNIT_EXPECT_EQ(test, src_w, 1920);
KUNIT_EXPECT_EQ(test, src_h, 1080);
}
static void dm_test_oriented_plane_size_rotate_270(struct kunit *test)
{
struct drm_plane_state plane_state = { 0 };
int src_w = 0;
int src_h = 0;
plane_state.rotation = DRM_MODE_ROTATE_270;
plane_state.src_w = 1920 << 16;
plane_state.src_h = 1080 << 16;
dm_get_oriented_plane_size(&plane_state, &src_w, &src_h);
KUNIT_EXPECT_EQ(test, src_w, 1080);
KUNIT_EXPECT_EQ(test, src_h, 1920);
}
static void dm_test_get_plane_scale_identity(struct kunit *test)
{
struct drm_plane_state plane_state = { 0 };
int scale_w = 0;
int scale_h = 0;
plane_state.rotation = DRM_MODE_ROTATE_0;
plane_state.src_w = 1920 << 16;
plane_state.src_h = 1080 << 16;
plane_state.crtc_w = 1920;
plane_state.crtc_h = 1080;
dm_get_plane_scale(&plane_state, &scale_w, &scale_h);
KUNIT_EXPECT_EQ(test, scale_w, 1000);
KUNIT_EXPECT_EQ(test, scale_h, 1000);
}
static void dm_test_get_plane_scale_rotate_90_identity(struct kunit *test)
{
struct drm_plane_state plane_state = { 0 };
int scale_w = 0;
int scale_h = 0;
plane_state.rotation = DRM_MODE_ROTATE_90;
plane_state.src_w = 1920 << 16;
plane_state.src_h = 1080 << 16;
plane_state.crtc_w = 1080;
plane_state.crtc_h = 1920;
dm_get_plane_scale(&plane_state, &scale_w, &scale_h);
KUNIT_EXPECT_EQ(test, scale_w, 1000);
KUNIT_EXPECT_EQ(test, scale_h, 1000);
}
static void dm_test_get_plane_scale_zero_src_width(struct kunit *test)
{
struct drm_plane_state plane_state = { 0 };
int scale_w = 0;
int scale_h = 0;
plane_state.rotation = DRM_MODE_ROTATE_0;
plane_state.src_w = 0;
plane_state.src_h = 1080 << 16;
plane_state.crtc_w = 100;
plane_state.crtc_h = 200;
dm_get_plane_scale(&plane_state, &scale_w, &scale_h);
KUNIT_EXPECT_EQ(test, scale_w, 0);
KUNIT_EXPECT_EQ(test, scale_h, 185);
}
static struct kunit_case amdgpu_dm_cursor_tests[] = {
KUNIT_CASE(dm_test_check_cursor_fb_valid_linear),
KUNIT_CASE(dm_test_check_cursor_fb_rejects_size),
KUNIT_CASE(dm_test_check_cursor_fb_rejects_cropping),
KUNIT_CASE(dm_test_check_cursor_fb_rejects_pitch),
KUNIT_CASE(dm_test_check_cursor_fb_rejects_unsupported_pitch),
KUNIT_CASE(dm_test_check_cursor_fb_rejects_tiling),
KUNIT_CASE(dm_test_check_cursor_fb_gfx12_tiling),
KUNIT_CASE(dm_test_check_cursor_fb_pre_ai_tiling),
KUNIT_CASE(dm_test_check_cursor_fb_modifier_skips_tiling),
KUNIT_CASE(dm_test_check_native_cursor_state_disabled),
KUNIT_CASE(dm_test_check_native_cursor_state_rejects_offset),
KUNIT_CASE(dm_test_check_native_cursor_state_checks_fb),
KUNIT_CASE(dm_test_plane_color_pipeline_active),
KUNIT_CASE(dm_test_plane_color_pipeline_ignores_other_plane),
KUNIT_CASE(dm_test_crtc_get_cursor_mode_disabled_crtc),
KUNIT_CASE(dm_test_crtc_get_cursor_mode_new_hardware),
KUNIT_CASE(dm_test_crtc_get_cursor_mode_new_hardware_hole),
KUNIT_CASE(dm_test_crtc_get_cursor_mode_no_change),
KUNIT_CASE(dm_test_crtc_get_cursor_mode_disabled_cursor),
KUNIT_CASE(dm_test_crtc_get_cursor_mode_yuv_plane),
KUNIT_CASE(dm_test_crtc_get_cursor_mode_scale_mismatch),
KUNIT_CASE(dm_test_crtc_get_cursor_mode_full_coverage),
KUNIT_CASE(dm_test_crtc_get_cursor_mode_hole),
KUNIT_CASE(dm_test_crtc_get_cursor_mode_without_cursor),
KUNIT_CASE(dm_test_crtc_get_cursor_mode_scale_changed),
KUNIT_CASE(dm_test_crtc_get_cursor_mode_position_changed),
KUNIT_CASE(dm_test_crtc_get_cursor_mode_color_pipeline),
KUNIT_CASE(dm_test_should_update_native_cursor_without_crtc),
KUNIT_CASE(dm_test_should_update_native_cursor_disable_native),
KUNIT_CASE(dm_test_should_update_native_cursor_enable_overlay),
KUNIT_CASE(dm_test_oriented_plane_size_rotate_0),
KUNIT_CASE(dm_test_oriented_plane_size_rotate_90),
KUNIT_CASE(dm_test_oriented_plane_size_rotate_180),
KUNIT_CASE(dm_test_oriented_plane_size_rotate_270),
KUNIT_CASE(dm_test_get_plane_scale_identity),
KUNIT_CASE(dm_test_get_plane_scale_rotate_90_identity),
KUNIT_CASE(dm_test_get_plane_scale_zero_src_width),
{}
};
static struct kunit_suite amdgpu_dm_cursor_test_suite = {
.name = "amdgpu_dm_cursor",
.test_cases = amdgpu_dm_cursor_tests,
};
kunit_test_suite(amdgpu_dm_cursor_test_suite);
MODULE_AUTHOR("AMD");
MODULE_DESCRIPTION("KUnit tests for amdgpu_dm_cursor");
MODULE_LICENSE("Dual MIT/GPL"