#include <kunit/test.h>
#include <drm/drm_atomic.h>
#include <drm/drm_blend.h>
#include "link_enc_cfg.h"
#include "amdgpu_dm_plane.h"
#include "amdgpu_dm_kunit_test_helpers.h"
#include "amdgpu_rlc.h"
#include "gc/gc_11_0_0_offset.h"
#include "gc/gc_11_0_0_sh_mask.h"
#include <drm/amdgpu_drm.h>
#include <drm/drm_mode_config.h>
#include <drm/drm_plane.h>
#include <drm/drm_property.h>
struct dm_test_dcc_cap_ctx {
bool callback_ret;
bool capable;
bool output_independent_64b_blks;
bool called;
struct dc_dcc_surface_param captured_input;
};
static struct dm_test_dcc_cap_ctx *dm_test_dcc_ctx;
struct dm_test_gfx11_reg_ctx {
u32 gb_addr_config;
u32 gc_reg_offsets[1];
u32 expected_reg;
u32 captured_reg;
u32 captured_acc_flags;
u32 captured_hwip;
u32 captured_xcc_id;
bool called;
};
static struct dm_test_gfx11_reg_ctx *dm_test_gfx11_reg_ctx;
static u32 dm_test_gfx11_rreg32(struct amdgpu_device *adev,
u32 reg, u32 acc_flags, u32 hwip,
u32 xcc_id)
{
if (!dm_test_gfx11_reg_ctx)
return 0;
dm_test_gfx11_reg_ctx->called = true;
dm_test_gfx11_reg_ctx->captured_reg = reg;
dm_test_gfx11_reg_ctx->captured_acc_flags = acc_flags;
dm_test_gfx11_reg_ctx->captured_hwip = hwip;
dm_test_gfx11_reg_ctx->captured_xcc_id = xcc_id;
return dm_test_gfx11_reg_ctx->gb_addr_config;
}
static const struct amdgpu_rlc_reg_funcs dm_test_gfx11_reg_funcs = {
.rreg32 = dm_test_gfx11_rreg32,
};
static bool dm_test_get_dcc_compression_cap(const struct dc *dc,
const struct dc_dcc_surface_param *input,
struct dc_surface_dcc_cap *output)
{
if (!dm_test_dcc_ctx)
return false;
dm_test_dcc_ctx->called = true;
dm_test_dcc_ctx->captured_input = *input;
output->capable = dm_test_dcc_ctx->capable;
output->grph.rgb.independent_64b_blks = dm_test_dcc_ctx->output_independent_64b_blks;
return dm_test_dcc_ctx->callback_ret;
}
static void dm_test_init_validate_dcc_inputs(struct amdgpu_device **adev,
struct dc **dc,
struct dc_tiling_info *tiling_info,
struct dc_plane_dcc_param *dcc,
struct dc_plane_address *address,
struct plane_size *plane_size,
struct kunit *test)
{
*adev = kunit_kzalloc(test, sizeof(**adev), GFP_KERNEL);
*dc = kunit_kzalloc(test, sizeof(**dc), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, *adev);
KUNIT_ASSERT_NOT_NULL(test, *dc);
(*adev)->dm.dc = *dc;
(*adev)->family = AMDGPU_FAMILY_NV;
tiling_info->gfx9.swizzle = 9;
dcc->enable = 1;
dcc->independent_64b_blks = 1;
plane_size->surface_size.width = 1920;
plane_size->surface_size.height = 1080;
(void)address;
}
static void dm_test_plane_is_video_format_known_video(struct kunit *test)
{
KUNIT_EXPECT_TRUE(test, amdgpu_dm_plane_is_video_format(DRM_FORMAT_NV12));
KUNIT_EXPECT_TRUE(test, amdgpu_dm_plane_is_video_format(DRM_FORMAT_NV21));
KUNIT_EXPECT_TRUE(test, amdgpu_dm_plane_is_video_format(DRM_FORMAT_P010));
}
static void dm_test_fill_blending_pixel_blend_modes(struct kunit *test)
{
static const struct {
const char *name;
unsigned int blend_mode;
bool with_fb;
bool per_pixel_alpha;
bool pre_multiplied_alpha;
} cases[] = {
{ "defaults", DRM_MODE_BLEND_PIXEL_NONE, false, false, true },
{ "premultiplied", DRM_MODE_BLEND_PREMULTI, true, true, true },
{ "coverage", DRM_MODE_BLEND_COVERAGE, true, true, false },
};
struct drm_framebuffer fb = { 0 };
unsigned int i;
fb.format = drm_format_info(DRM_FORMAT_ARGB8888);
KUNIT_ASSERT_NOT_NULL(test, fb.format);
for (i = 0; i < ARRAY_SIZE(cases); i++) {
struct drm_plane_state state = { 0 };
bool per_pixel_alpha;
bool pre_multiplied_alpha;
bool global_alpha;
int global_alpha_value;
if (cases[i].with_fb)
state.fb = &fb;
state.pixel_blend_mode = cases[i].blend_mode;
state.alpha = 0xffff;
amdgpu_dm_plane_fill_blending_from_plane_state(&state,
&per_pixel_alpha,
&pre_multiplied_alpha,
&global_alpha,
&global_alpha_value);
KUNIT_EXPECT_EQ_MSG(test, per_pixel_alpha, cases[i].per_pixel_alpha,
"%s", cases[i].name);
KUNIT_EXPECT_EQ_MSG(test, pre_multiplied_alpha, cases[i].pre_multiplied_alpha,
"%s", cases[i].name);
KUNIT_EXPECT_FALSE_MSG(test, global_alpha, "%s", cases[i].name);
KUNIT_EXPECT_EQ_MSG(test, global_alpha_value, 0xff, "%s", cases[i].name);
}
}
static void dm_test_fill_blending_global_alpha(struct kunit *test)
{
static const struct {
const char *name;
u32 dce_version;
int expected;
} cases[] = {
{ "8-bit field", IP_VERSION(4, 0, 0), 0x80 },
{ "DCN 4.2 12-bit field", IP_VERSION(4, 2, 0), 0x800 },
};
unsigned int i;
for (i = 0; i < ARRAY_SIZE(cases); i++) {
struct amdgpu_device *adev;
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);
adev->ip_versions[DCE_HWIP][0] = cases[i].dce_version;
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,
&per_pixel_alpha,
&pre_multiplied_alpha,
&global_alpha,
&global_alpha_value);
KUNIT_EXPECT_FALSE_MSG(test, per_pixel_alpha, "%s", cases[i].name);
KUNIT_EXPECT_TRUE_MSG(test, pre_multiplied_alpha, "%s", cases[i].name);
KUNIT_EXPECT_TRUE_MSG(test, global_alpha, "%s", cases[i].name);
KUNIT_EXPECT_EQ_MSG(test, global_alpha_value, cases[i].expected,
"%s", cases[i].name);
}
}
static void dm_test_modifier_has_dcc(struct kunit *test)
{
uint64_t dcc_mod = AMD_FMT_MOD | AMD_FMT_MOD_SET(DCC, 1);
KUNIT_EXPECT_FALSE(test, amdgpu_dm_plane_modifier_has_dcc(DRM_FORMAT_MOD_LINEAR));
KUNIT_EXPECT_TRUE(test, amdgpu_dm_plane_modifier_has_dcc(dcc_mod));
}
static void dm_test_modifier_gfx9_swizzle_mode(struct kunit *test)
{
uint64_t mod = AMD_FMT_MOD | AMD_FMT_MOD_SET(TILE, AMD_FMT_MOD_TILE_GFX9_64K_S_X);
KUNIT_EXPECT_EQ(test, amdgpu_dm_plane_modifier_gfx9_swizzle_mode(DRM_FORMAT_MOD_LINEAR), 0U);
KUNIT_EXPECT_EQ(test,
amdgpu_dm_plane_modifier_gfx9_swizzle_mode(mod),
(unsigned int)AMD_FMT_MOD_TILE_GFX9_64K_S_X);
}
static void dm_test_get_plane_formats(struct kunit *test)
{
struct drm_plane *plane;
struct dc_plane_cap *cap;
struct dc_plane_cap *universal_cap;
uint32_t formats[32] = {0};
plane = kunit_kzalloc(test, sizeof(*plane), GFP_KERNEL);
cap = kunit_kzalloc(test, sizeof(*cap), GFP_KERNEL);
universal_cap = kunit_kzalloc(test, sizeof(*universal_cap), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, plane);
KUNIT_ASSERT_NOT_NULL(test, cap);
KUNIT_ASSERT_NOT_NULL(test, universal_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);
plane->type = DRM_PLANE_TYPE_OVERLAY;
KUNIT_EXPECT_EQ(test, amdgpu_dm_plane_get_plane_formats(plane, NULL, formats, 32), 9);
universal_cap->type = DC_PLANE_TYPE_DCN_UNIVERSAL;
KUNIT_EXPECT_EQ(test,
amdgpu_dm_plane_get_plane_formats(plane, universal_cap, formats, 32),
14);
plane->type = DRM_PLANE_TYPE_CURSOR;
KUNIT_EXPECT_EQ(test, amdgpu_dm_plane_get_plane_formats(plane, NULL, formats, 32), 1);
}
static void dm_test_get_plane_modifiers(struct kunit *test)
{
struct amdgpu_device *adev;
uint64_t *mods = NULL;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, adev);
adev->family = AMDGPU_FAMILY_NV;
KUNIT_ASSERT_EQ(test,
amdgpu_dm_plane_get_plane_modifiers(adev, DRM_PLANE_TYPE_CURSOR, &mods),
0);
KUNIT_ASSERT_NOT_NULL(test, mods);
KUNIT_EXPECT_EQ(test, mods[0], DRM_FORMAT_MOD_LINEAR);
KUNIT_EXPECT_EQ(test, mods[1], DRM_FORMAT_MOD_INVALID);
kfree(mods);
}
static void dm_test_fill_dc_scaling_info(struct kunit *test)
{
struct amdgpu_device *adev;
struct drm_plane_state state = {0};
struct dc_scaling_info info = {0};
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, adev);
state.src_w = 0;
state.src_h = 100 << 16;
state.crtc_w = 100;
state.crtc_h = 100;
KUNIT_EXPECT_EQ(test, amdgpu_dm_plane_fill_dc_scaling_info(adev, &state, &info), -EINVAL);
state.src_w = 100 << 16;
state.src_h = 100 << 16;
state.crtc_w = 100;
state.crtc_h = 100;
KUNIT_EXPECT_EQ(test, amdgpu_dm_plane_fill_dc_scaling_info(adev, &state, &info), 0);
}
static void dm_test_get_min_max_dc_plane_scaling(struct kunit *test)
{
struct amdgpu_device *adev;
struct dc *dc;
struct drm_framebuffer *fb;
int min_downscale = 0;
int max_upscale = 0;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
dc = kunit_kzalloc(test, sizeof(*dc), GFP_KERNEL);
fb = kunit_kzalloc(test, sizeof(*fb), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, dc);
KUNIT_ASSERT_NOT_NULL(test, fb);
adev->dm.dc = dc;
dc->caps.planes[0].max_upscale_factor.nv12 = 1;
dc->caps.planes[0].max_downscale_factor.nv12 = 1;
dc->caps.planes[0].max_upscale_factor.argb8888 = 1600;
dc->caps.planes[0].max_downscale_factor.argb8888 = 250;
dc->caps.planes[0].max_upscale_factor.fp16 = 2000;
dc->caps.planes[0].max_downscale_factor.fp16 = 500;
fb->format = drm_format_info(DRM_FORMAT_NV12);
KUNIT_ASSERT_NOT_NULL(test, fb->format);
amdgpu_dm_plane_get_min_max_dc_plane_scaling(&adev->ddev, fb, &min_downscale, &max_upscale);
KUNIT_EXPECT_EQ(test, min_downscale, 1000);
KUNIT_EXPECT_EQ(test, max_upscale, 1000);
fb->format = drm_format_info(DRM_FORMAT_XRGB8888);
KUNIT_ASSERT_NOT_NULL(test, fb->format);
amdgpu_dm_plane_get_min_max_dc_plane_scaling(&adev->ddev, fb, &min_downscale, &max_upscale);
KUNIT_EXPECT_EQ(test, min_downscale, 250);
KUNIT_EXPECT_EQ(test, max_upscale, 1600);
fb->format = drm_format_info(DRM_FORMAT_ARGB16161616F);
KUNIT_ASSERT_NOT_NULL(test, fb->format);
amdgpu_dm_plane_get_min_max_dc_plane_scaling(&adev->ddev, fb, &min_downscale, &max_upscale);
KUNIT_EXPECT_EQ(test, min_downscale, 500);
KUNIT_EXPECT_EQ(test, max_upscale, 2000);
}
static void dm_test_get_cursor_position(struct kunit *test)
{
struct amdgpu_device *adev;
struct amdgpu_crtc *amdgpu_crtc;
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;
KUNIT_ASSERT_EQ(test,
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);
KUNIT_EXPECT_EQ(test, position.y, 0);
KUNIT_EXPECT_EQ(test, position.x_hotspot, 5);
KUNIT_EXPECT_EQ(test, position.y_hotspot, 7);
KUNIT_EXPECT_TRUE(test, position.translate_by_source);
memset(&position, 0, sizeof(position));
state->crtc_x = -64;
state->crtc_y = 0;
KUNIT_ASSERT_EQ(test,
amdgpu_dm_plane_get_cursor_position(plane, &amdgpu_crtc->base, &position),
0);
KUNIT_EXPECT_FALSE(test, position.enable);
state->crtc_w = 128;
KUNIT_EXPECT_EQ(test,
amdgpu_dm_plane_get_cursor_position(plane, &amdgpu_crtc->base, &position),
-EINVAL);
}
static void dm_test_format_mod_supported(struct kunit *test)
{
struct amdgpu_device *adev;
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;
KUNIT_EXPECT_TRUE(test,
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,
DRM_FORMAT_MOD_INVALID));
KUNIT_EXPECT_FALSE(test,
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;
KUNIT_EXPECT_FALSE(test,
amdgpu_dm_plane_format_mod_supported(plane, DRM_FORMAT_NV12, listed_mod));
KUNIT_EXPECT_FALSE(test,
amdgpu_dm_plane_format_mod_supported(plane, DRM_FORMAT_XRGB8888_A8,
listed_mod));
}
static void dm_test_fill_gfx9_plane_attributes_from_modifiers(struct kunit *test)
{
struct amdgpu_device *adev;
struct amdgpu_framebuffer *afb;
struct plane_size plane_size = {0};
struct dc_tiling_info tiling_info = {0};
struct dc_plane_dcc_param dcc = {0};
struct dc_plane_address address = {0};
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
afb = kunit_kzalloc(test, sizeof(*afb), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, afb);
adev->family = AMDGPU_FAMILY_NV;
adev->gfx.config.gb_addr_config_fields.num_pipes = 2;
adev->gfx.config.gb_addr_config_fields.num_banks = 4;
adev->gfx.config.gb_addr_config_fields.pipe_interleave_size = 256;
adev->gfx.config.gb_addr_config_fields.num_se = 1;
adev->gfx.config.gb_addr_config_fields.max_compress_frags = 2;
adev->gfx.config.gb_addr_config_fields.num_rb_per_se = 1;
adev->gfx.config.gb_addr_config_fields.num_pkrs = 2;
adev->ip_versions[GC_HWIP][0] = IP_VERSION(10, 3, 0);
afb->base.modifier = DRM_FORMAT_MOD_LINEAR;
KUNIT_EXPECT_EQ(test,
amdgpu_dm_plane_fill_gfx9_attrs_from_modifiers(
adev, afb, SURFACE_PIXEL_FORMAT_GRPH_ARGB8888,
ROTATION_ANGLE_0, &plane_size, &tiling_info, &dcc, &address),
0);
KUNIT_EXPECT_EQ(test, (int)tiling_info.gfxversion, (int)DcGfxVersion9);
KUNIT_EXPECT_EQ(test, tiling_info.gfx9.swizzle, 0U);
KUNIT_EXPECT_FALSE(test, dcc.enable);
}
static void dm_test_helper_check_state_viewport_rejects(struct kunit *test)
{
static const struct {
const char *name;
int crtc_x;
int crtc_y;
int crtc_w;
int crtc_h;
int hdisplay;
int vdisplay;
} cases[] = {
{ "outside the display", 200, 0, 100, 100, 100, 100 },
{ "width below minimum", 0, 0, 10, 100, 1920, 1080 },
{ "top-clipped height", -2, -95, 100, 100, 1920, 1080 },
{ "bottom-clipped height", 0, 95, 100, 100, 1920, 100 },
};
unsigned int i;
for (i = 0; i < ARRAY_SIZE(cases); i++) {
struct drm_plane *plane;
struct drm_plane_state *state;
struct drm_crtc *crtc;
struct drm_crtc_state *new_crtc_state;
struct drm_framebuffer *fb;
int ret;
plane = kunit_kzalloc(test, sizeof(*plane), GFP_KERNEL);
state = kunit_kzalloc(test, sizeof(*state), GFP_KERNEL);
crtc = kunit_kzalloc(test, sizeof(*crtc), GFP_KERNEL);
new_crtc_state = kunit_kzalloc(test, sizeof(*new_crtc_state), GFP_KERNEL);
fb = kunit_kzalloc(test, sizeof(*fb), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, plane);
KUNIT_ASSERT_NOT_NULL(test, state);
KUNIT_ASSERT_NOT_NULL(test, crtc);
KUNIT_ASSERT_NOT_NULL(test, new_crtc_state);
KUNIT_ASSERT_NOT_NULL(test, fb);
plane->type = DRM_PLANE_TYPE_OVERLAY;
state->plane = plane;
state->fb = fb;
state->crtc = crtc;
state->crtc_x = cases[i].crtc_x;
state->crtc_y = cases[i].crtc_y;
state->crtc_w = cases[i].crtc_w;
state->crtc_h = cases[i].crtc_h;
new_crtc_state->mode.crtc_hdisplay = cases[i].hdisplay;
new_crtc_state->mode.crtc_vdisplay = cases[i].vdisplay;
ret = amdgpu_dm_plane_helper_check_state(state, new_crtc_state);
KUNIT_EXPECT_EQ_MSG(test, ret, -EINVAL, "%s", cases[i].name);
}
}
static void dm_test_validate_dcc_early_exits(struct kunit *test)
{
static const struct {
const char *name;
bool dcc_enable;
enum surface_pixel_format format;
int expected;
} cases[] = {
{ "dcc disabled", false, SURFACE_PIXEL_FORMAT_GRPH_ARGB8888, 0 },
{ "video before gfx12", true, SURFACE_PIXEL_FORMAT_VIDEO_420_YCbCr, -EINVAL },
{ "no capability callback", true, SURFACE_PIXEL_FORMAT_GRPH_ARGB8888, -EINVAL },
};
unsigned int i;
for (i = 0; i < ARRAY_SIZE(cases); i++) {
struct amdgpu_device *adev;
struct dc *dc;
struct dc_tiling_info tiling_info = {0};
struct dc_plane_dcc_param dcc = {0};
struct dc_plane_address address = {0};
struct plane_size plane_size = {0};
int ret;
dm_test_init_validate_dcc_inputs(&adev, &dc, &tiling_info, &dcc, &address,
&plane_size, test);
dcc.enable = cases[i].dcc_enable;
ret = amdgpu_dm_plane_validate_dcc(adev, cases[i].format, ROTATION_ANGLE_0,
&tiling_info, &dcc, &address, &plane_size);
KUNIT_EXPECT_EQ_MSG(test, ret, cases[i].expected, "%s", cases[i].name);
}
}
static void dm_test_validate_dcc_rejects_from_cap(struct kunit *test)
{
static const struct {
const char *name;
bool callback_ret;
bool capable;
bool output_independent_64b_blks;
u32 independent_64b_blks;
} cases[] = {
{ "callback fails", false, true, false, 1 },
{ "not capable", true, false, false, 1 },
{ "independent 64B mismatch", true, true, true, 0 },
};
unsigned int i;
for (i = 0; i < ARRAY_SIZE(cases); i++) {
struct amdgpu_device *adev;
struct dc *dc;
struct dc_tiling_info tiling_info = {0};
struct dc_plane_dcc_param dcc = {0};
struct dc_plane_address address = {0};
struct plane_size plane_size = {0};
struct dm_test_dcc_cap_ctx ctx = {
.callback_ret = cases[i].callback_ret,
.capable = cases[i].capable,
.output_independent_64b_blks = cases[i].output_independent_64b_blks,
};
int ret;
dm_test_init_validate_dcc_inputs(&adev, &dc, &tiling_info, &dcc, &address,
&plane_size, test);
dcc.independent_64b_blks = cases[i].independent_64b_blks;
dc->cap_funcs.get_dcc_compression_cap = dm_test_get_dcc_compression_cap;
dm_test_dcc_ctx = &ctx;
ret = amdgpu_dm_plane_validate_dcc(adev, SURFACE_PIXEL_FORMAT_GRPH_ARGB8888,
ROTATION_ANGLE_0, &tiling_info, &dcc,
&address, &plane_size);
dm_test_dcc_ctx = NULL;
KUNIT_EXPECT_EQ_MSG(test, ret, -EINVAL, "%s", cases[i].name);
KUNIT_EXPECT_TRUE_MSG(test, ctx.called, "%s", cases[i].name);
}
}
static void dm_test_validate_dcc_success_and_scan_mapping(struct kunit *test)
{
struct amdgpu_device *adev;
struct dc *dc;
struct dc_tiling_info tiling_info = {0};
struct dc_plane_dcc_param dcc = {0};
struct dc_plane_address address = {0};
struct plane_size plane_size = {0};
struct dm_test_dcc_cap_ctx ctx = {
.callback_ret = true,
.capable = true,
.output_independent_64b_blks = true,
};
dm_test_init_validate_dcc_inputs(&adev, &dc, &tiling_info, &dcc, &address,
&plane_size, test);
dc->cap_funcs.get_dcc_compression_cap = dm_test_get_dcc_compression_cap;
dm_test_dcc_ctx = &ctx;
KUNIT_EXPECT_EQ(test,
amdgpu_dm_plane_validate_dcc(adev, SURFACE_PIXEL_FORMAT_GRPH_ARGB8888,
ROTATION_ANGLE_90, &tiling_info, &dcc,
&address, &plane_size),
0);
KUNIT_EXPECT_TRUE(test, ctx.called);
KUNIT_EXPECT_EQ(test, (int)ctx.captured_input.scan, (int)SCAN_DIRECTION_VERTICAL);
KUNIT_EXPECT_EQ(test, (int)ctx.captured_input.format,
(int)SURFACE_PIXEL_FORMAT_GRPH_ARGB8888);
dm_test_dcc_ctx = NULL;
}
static void dm_test_add_modifier_appends_and_grows(struct kunit *test)
{
uint64_t size = 0;
uint64_t cap = 2;
uint64_t *mods = kmalloc_array(cap, sizeof(*mods), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, mods);
amdgpu_dm_plane_add_modifier(&mods, &size, &cap, 0x1234ULL);
KUNIT_ASSERT_NOT_NULL(test, mods);
KUNIT_EXPECT_EQ(test, size, 1ULL);
KUNIT_EXPECT_EQ(test, cap, 2ULL);
KUNIT_EXPECT_EQ(test, mods[0], 0x1234ULL);
kfree(mods);
size = 1;
cap = 1;
mods = kmalloc_objs(*mods, cap);
KUNIT_ASSERT_NOT_NULL(test, mods);
mods[0] = 0xAAULL;
amdgpu_dm_plane_add_modifier(&mods, &size, &cap, 0xBBULL);
KUNIT_ASSERT_NOT_NULL(test, mods);
KUNIT_EXPECT_EQ(test, cap, 2ULL);
KUNIT_EXPECT_EQ(test, size, 2ULL);
KUNIT_EXPECT_EQ(test, mods[0], 0xAAULL);
KUNIT_EXPECT_EQ(test, mods[1], 0xBBULL);
kfree(mods);
}
static void dm_test_add_modifier_failure_paths(struct kunit *test)
{
uint64_t size = 3;
uint64_t cap = 7;
uint64_t *mods = NULL;
amdgpu_dm_plane_add_modifier(&mods, &size, &cap, 0x55ULL);
KUNIT_EXPECT_PTR_EQ(test, mods, NULL);
KUNIT_EXPECT_EQ(test, size, 3ULL);
KUNIT_EXPECT_EQ(test, cap, 7ULL);
cap = 1ULL << 62;
size = cap;
mods = kmalloc_objs(*mods, 1);
KUNIT_ASSERT_NOT_NULL(test, mods);
amdgpu_dm_plane_add_modifier(&mods, &size, &cap, 0x1234ULL);
KUNIT_EXPECT_PTR_EQ(test, mods, NULL);
KUNIT_EXPECT_EQ(test, size, 1ULL << 62);
}
static void dm_test_fill_gfx9_tiling_info_from_device(struct kunit *test)
{
struct amdgpu_device *adev;
struct dc_tiling_info tiling_info = {0};
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, adev);
adev->gfx.config.gb_addr_config_fields.num_pipes = 4;
adev->gfx.config.gb_addr_config_fields.num_banks = 8;
adev->gfx.config.gb_addr_config_fields.pipe_interleave_size = 256;
adev->gfx.config.gb_addr_config_fields.num_se = 2;
adev->gfx.config.gb_addr_config_fields.max_compress_frags = 1;
adev->gfx.config.gb_addr_config_fields.num_rb_per_se = 2;
adev->gfx.config.gb_addr_config_fields.num_pkrs = 3;
adev->ip_versions[GC_HWIP][0] = IP_VERSION(10, 2, 9);
tiling_info.gfx9.num_pkrs = 0x5a;
amdgpu_dm_plane_fill_gfx9_tiling_info_from_device(adev, &tiling_info);
KUNIT_EXPECT_EQ(test, tiling_info.gfx9.num_pipes, 4U);
KUNIT_EXPECT_EQ(test, tiling_info.gfx9.num_banks, 8U);
KUNIT_EXPECT_EQ(test, tiling_info.gfx9.pipe_interleave, 256U);
KUNIT_EXPECT_EQ(test, tiling_info.gfx9.num_shader_engines, 2U);
KUNIT_EXPECT_EQ(test, tiling_info.gfx9.max_compressed_frags, 1U);
KUNIT_EXPECT_EQ(test, tiling_info.gfx9.num_rb_per_se, 2U);
KUNIT_EXPECT_EQ(test, tiling_info.gfx9.shaderEnable, 1U);
KUNIT_EXPECT_EQ(test, tiling_info.gfx9.num_pkrs, 0x5aU);
adev->gfx.config.gb_addr_config_fields.num_pipes = 2;
adev->gfx.config.gb_addr_config_fields.num_banks = 4;
adev->gfx.config.gb_addr_config_fields.pipe_interleave_size = 128;
adev->gfx.config.gb_addr_config_fields.num_se = 1;
adev->gfx.config.gb_addr_config_fields.max_compress_frags = 2;
adev->gfx.config.gb_addr_config_fields.num_rb_per_se = 1;
adev->gfx.config.gb_addr_config_fields.num_pkrs = 6;
adev->ip_versions[GC_HWIP][0] = IP_VERSION(10, 3, 0);
memset(&tiling_info, 0, sizeof(tiling_info));
amdgpu_dm_plane_fill_gfx9_tiling_info_from_device(adev, &tiling_info);
KUNIT_EXPECT_EQ(test, tiling_info.gfx9.num_pipes, 2U);
KUNIT_EXPECT_EQ(test, tiling_info.gfx9.num_banks, 4U);
KUNIT_EXPECT_EQ(test, tiling_info.gfx9.pipe_interleave, 128U);
KUNIT_EXPECT_EQ(test, tiling_info.gfx9.num_shader_engines, 1U);
KUNIT_EXPECT_EQ(test, tiling_info.gfx9.max_compressed_frags, 2U);
KUNIT_EXPECT_EQ(test, tiling_info.gfx9.num_rb_per_se, 1U);
KUNIT_EXPECT_EQ(test, tiling_info.gfx9.shaderEnable, 1U);
KUNIT_EXPECT_EQ(test, tiling_info.gfx9.num_pkrs, 6U);
}
static void dm_test_fill_gfx9_tiling_info_from_modifier(struct kunit *test)
{
struct amdgpu_device *adev;
struct dc_tiling_info tiling_info = {0};
uint64_t modifier;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, adev);
adev->family = AMDGPU_FAMILY_NV;
adev->gfx.config.gb_addr_config_fields.num_pipes = 4;
adev->gfx.config.gb_addr_config_fields.num_banks = 8;
adev->gfx.config.gb_addr_config_fields.pipe_interleave_size = 256;
adev->gfx.config.gb_addr_config_fields.num_se = 2;
adev->gfx.config.gb_addr_config_fields.max_compress_frags = 1;
adev->gfx.config.gb_addr_config_fields.num_rb_per_se = 2;
adev->gfx.config.gb_addr_config_fields.num_pkrs = 3;
adev->ip_versions[GC_HWIP][0] = IP_VERSION(10, 3, 0);
amdgpu_dm_plane_fill_gfx9_tiling_info_from_modifier(adev, &tiling_info,
DRM_FORMAT_MOD_LINEAR);
KUNIT_EXPECT_EQ(test, tiling_info.gfx9.num_pipes, 4U);
KUNIT_EXPECT_EQ(test, tiling_info.gfx9.num_banks, 8U);
KUNIT_EXPECT_EQ(test, tiling_info.gfx9.pipe_interleave, 256U);
KUNIT_EXPECT_EQ(test, tiling_info.gfx9.num_shader_engines, 2U);
KUNIT_EXPECT_EQ(test, tiling_info.gfx9.max_compressed_frags, 1U);
KUNIT_EXPECT_EQ(test, tiling_info.gfx9.num_rb_per_se, 2U);
KUNIT_EXPECT_EQ(test, tiling_info.gfx9.shaderEnable, 1U);
KUNIT_EXPECT_EQ(test, tiling_info.gfx9.num_pkrs, 3U);
adev->family = AMDGPU_FAMILY_RV;
adev->gfx.config.gb_addr_config_fields.num_banks = 16;
adev->gfx.config.gb_addr_config_fields.num_pkrs = 7;
adev->ip_versions[GC_HWIP][0] = IP_VERSION(10, 2, 9);
memset(&tiling_info, 0, sizeof(tiling_info));
tiling_info.gfx9.num_pkrs = 0x5a;
modifier = AMD_FMT_MOD |
AMD_FMT_MOD_SET(TILE, AMD_FMT_MOD_TILE_GFX9_64K_S_X) |
AMD_FMT_MOD_SET(PIPE_XOR_BITS, 7) |
AMD_FMT_MOD_SET(BANK_XOR_BITS, 3) |
AMD_FMT_MOD_SET(PACKERS, 2);
amdgpu_dm_plane_fill_gfx9_tiling_info_from_modifier(adev, &tiling_info, modifier);
KUNIT_EXPECT_EQ(test, tiling_info.gfx9.num_pipes, 32U);
KUNIT_EXPECT_EQ(test, tiling_info.gfx9.num_shader_engines, 4U);
KUNIT_EXPECT_EQ(test, tiling_info.gfx9.num_banks, 8U);
KUNIT_EXPECT_EQ(test, tiling_info.gfx9.num_pkrs, 0x5aU);
KUNIT_EXPECT_EQ(test, tiling_info.gfx9.shaderEnable, 1U);
adev->family = AMDGPU_FAMILY_NV;
adev->gfx.config.gb_addr_config_fields.num_pipes = 2;
adev->gfx.config.gb_addr_config_fields.num_banks = 9;
adev->gfx.config.gb_addr_config_fields.pipe_interleave_size = 128;
adev->gfx.config.gb_addr_config_fields.num_se = 1;
adev->gfx.config.gb_addr_config_fields.max_compress_frags = 2;
adev->gfx.config.gb_addr_config_fields.num_rb_per_se = 1;
adev->gfx.config.gb_addr_config_fields.num_pkrs = 2;
adev->ip_versions[GC_HWIP][0] = IP_VERSION(10, 3, 0);
memset(&tiling_info, 0, sizeof(tiling_info));
modifier = AMD_FMT_MOD |
AMD_FMT_MOD_SET(TILE, AMD_FMT_MOD_TILE_GFX9_64K_S_X) |
AMD_FMT_MOD_SET(PIPE_XOR_BITS, 6) |
AMD_FMT_MOD_SET(BANK_XOR_BITS, 2) |
AMD_FMT_MOD_SET(PACKERS, 3);
amdgpu_dm_plane_fill_gfx9_tiling_info_from_modifier(adev, &tiling_info, modifier);
KUNIT_EXPECT_EQ(test, tiling_info.gfx9.num_pipes, 32U);
KUNIT_EXPECT_EQ(test, tiling_info.gfx9.num_shader_engines, 2U);
KUNIT_EXPECT_EQ(test, tiling_info.gfx9.num_banks, 9U);
KUNIT_EXPECT_EQ(test, tiling_info.gfx9.num_pkrs, 8U);
KUNIT_EXPECT_EQ(test, tiling_info.gfx9.shaderEnable, 1U);
}
static void dm_test_get_format_info(struct kunit *test)
{
u64 dcc_mod = AMD_FMT_MOD |
AMD_FMT_MOD_SET(TILE_VERSION, AMD_FMT_MOD_TILE_VER_GFX9) |
AMD_FMT_MOD_SET(DCC, 1);
const struct drm_format_info *format_info;
KUNIT_EXPECT_PTR_EQ(test,
(void *)amdgpu_dm_plane_get_format_info(DRM_FORMAT_XRGB8888,
DRM_FORMAT_MOD_LINEAR),
NULL);
format_info = amdgpu_dm_plane_get_format_info(DRM_FORMAT_XRGB8888, dcc_mod);
KUNIT_EXPECT_NOT_NULL(test, format_info);
}
static int dm_test_mods_count(const u64 *mods)
{
int i = 0;
while (mods[i] != DRM_FORMAT_MOD_INVALID)
i++;
return i;
}
static void dm_test_expect_mods_terminated(struct kunit *test, struct amdgpu_device *adev)
{
u64 *mods = NULL;
int ret;
int count;
ret = amdgpu_dm_plane_get_plane_modifiers(adev, DRM_PLANE_TYPE_PRIMARY, &mods);
KUNIT_ASSERT_EQ(test, ret, 0);
KUNIT_ASSERT_NOT_NULL(test, mods);
count = dm_test_mods_count(mods);
KUNIT_EXPECT_GT(test, count, 0);
KUNIT_EXPECT_EQ(test, mods[count - 1], DRM_FORMAT_MOD_LINEAR);
kfree(mods);
}
static bool dm_test_mods_contain(const u64 *mods, u64 expected)
{
int count = dm_test_mods_count(mods);
int i;
for (i = 0; i < count; i++) {
if (mods[i] == expected)
return true;
}
return false;
}
static u64 *dm_test_get_primary_mods(struct kunit *test, struct amdgpu_device *adev)
{
u64 *mods = NULL;
int ret;
ret = amdgpu_dm_plane_get_plane_modifiers(adev, DRM_PLANE_TYPE_PRIMARY, &mods);
KUNIT_ASSERT_EQ(test, ret, 0);
KUNIT_ASSERT_NOT_NULL(test, mods);
return mods;
}
static int dm_test_gfx9_attrs(struct amdgpu_device *adev,
const struct amdgpu_framebuffer *afb,
const struct plane_size *plane_size,
struct dc_tiling_info *tiling_info,
struct dc_plane_dcc_param *dcc,
struct dc_plane_address *address)
{
return amdgpu_dm_plane_fill_gfx9_attrs_from_modifiers(adev,
afb, SURFACE_PIXEL_FORMAT_GRPH_ARGB8888, ROTATION_ANGLE_0,
plane_size, tiling_info, dcc, address);
}
static int dm_test_gfx12_attrs(struct amdgpu_device *adev,
const struct amdgpu_framebuffer *afb,
const struct plane_size *plane_size,
struct dc_tiling_info *tiling_info,
struct dc_plane_dcc_param *dcc,
struct dc_plane_address *address)
{
return amdgpu_dm_plane_fill_gfx12_attrs_from_modifiers(adev,
afb, SURFACE_PIXEL_FORMAT_GRPH_ARGB8888, ROTATION_ANGLE_0,
plane_size, tiling_info, dcc, address);
}
static int dm_test_plane_attrs(struct amdgpu_device *adev,
const struct amdgpu_framebuffer *afb,
enum surface_pixel_format format,
struct dc_tiling_info *tiling_info,
struct plane_size *plane_size,
struct dc_plane_dcc_param *dcc,
struct dc_plane_address *address)
{
return amdgpu_dm_plane_fill_plane_buffer_attributes(adev, afb, format,
ROTATION_ANGLE_0, tiling_info, plane_size, dcc, address,
false);
}
static int dm_test_video_attrs(struct amdgpu_device *adev,
const struct amdgpu_framebuffer *afb,
struct dc_tiling_info *tiling_info,
struct plane_size *plane_size,
struct dc_plane_dcc_param *dcc,
struct dc_plane_address *address)
{
return dm_test_plane_attrs(adev, afb, SURFACE_PIXEL_FORMAT_VIDEO_420_YCbCr,
tiling_info, plane_size, dcc, address);
}
static int dm_test_graphics_attrs(struct amdgpu_device *adev,
const struct amdgpu_framebuffer *afb,
struct dc_tiling_info *tiling_info,
struct plane_size *plane_size,
struct dc_plane_dcc_param *dcc,
struct dc_plane_address *address)
{
return dm_test_plane_attrs(adev, afb, SURFACE_PIXEL_FORMAT_GRPH_ARGB8888,
tiling_info, plane_size, dcc, address);
}
static void dm_test_setup_gfx9_dcc_device(struct amdgpu_device *adev,
struct dc *dc,
struct dm_test_dcc_cap_ctx *ctx,
bool output_independent_64b_blks)
{
adev->family = AMDGPU_FAMILY_NV;
adev->dm.dc = dc;
adev->gfx.config.gb_addr_config_fields.num_pipes = 2;
adev->gfx.config.gb_addr_config_fields.num_pkrs = 2;
adev->ip_versions[GC_HWIP][0] = IP_VERSION(10, 3, 0);
dc->cap_funcs.get_dcc_compression_cap = dm_test_get_dcc_compression_cap;
ctx->callback_ret = true;
ctx->capable = true;
ctx->output_independent_64b_blks = output_independent_64b_blks;
dm_test_dcc_ctx = ctx;
}
static u64 dm_test_gfx9_dcc_modifier(u64 tile_version, bool independent_64b_blks,
bool independent_128b_blks)
{
return AMD_FMT_MOD |
AMD_FMT_MOD_SET(TILE, AMD_FMT_MOD_TILE_GFX9_64K_S_X) |
AMD_FMT_MOD_SET(TILE_VERSION, tile_version) |
AMD_FMT_MOD_SET(DCC, 1) |
AMD_FMT_MOD_SET(DCC_INDEPENDENT_64B, independent_64b_blks) |
AMD_FMT_MOD_SET(DCC_INDEPENDENT_128B, independent_128b_blks);
}
static void dm_test_setup_gfx11_device(struct amdgpu_device *adev,
struct dm_test_gfx11_reg_ctx *ctx,
u32 num_pkrs_log2, u32 num_pipes_log2)
{
ctx->gb_addr_config =
REG_SET_FIELD(0, GB_ADDR_CONFIG, NUM_PKRS, num_pkrs_log2) |
REG_SET_FIELD(0, GB_ADDR_CONFIG, NUM_PIPES, num_pipes_log2);
ctx->gc_reg_offsets[regGB_ADDR_CONFIG_BASE_IDX] = 0;
ctx->expected_reg = ctx->gc_reg_offsets[regGB_ADDR_CONFIG_BASE_IDX] +
regGB_ADDR_CONFIG;
dm_test_gfx11_reg_ctx = ctx;
adev->family = AMDGPU_FAMILY_GC_11_0_0;
adev->reg_offset[GC_HWIP][0] = ctx->gc_reg_offsets;
adev->gfx.rlc.reg_funcs = &dm_test_gfx11_reg_funcs;
}
static u64 dm_test_gfx11_dcc_best_modifier(u32 pipe_xor_bits, u32 pkrs, u32 tile)
{
return AMD_FMT_MOD |
AMD_FMT_MOD_SET(TILE_VERSION, AMD_FMT_MOD_TILE_VER_GFX11) |
AMD_FMT_MOD_SET(PIPE_XOR_BITS, pipe_xor_bits) |
AMD_FMT_MOD_SET(TILE, tile) |
AMD_FMT_MOD_SET(PACKERS, pkrs) |
AMD_FMT_MOD_SET(DCC, 1) |
AMD_FMT_MOD_SET(DCC_INDEPENDENT_128B, 1) |
AMD_FMT_MOD_SET(DCC_MAX_COMPRESSED_BLOCK, AMD_FMT_MOD_DCC_BLOCK_128B);
}
static u64 dm_test_gfx11_dcc_4k_modifier(u32 pipe_xor_bits, u32 pkrs, u32 tile)
{
return AMD_FMT_MOD |
AMD_FMT_MOD_SET(TILE_VERSION, AMD_FMT_MOD_TILE_VER_GFX11) |
AMD_FMT_MOD_SET(PIPE_XOR_BITS, pipe_xor_bits) |
AMD_FMT_MOD_SET(TILE, tile) |
AMD_FMT_MOD_SET(PACKERS, pkrs) |
AMD_FMT_MOD_SET(DCC, 1) |
AMD_FMT_MOD_SET(DCC_INDEPENDENT_64B, 1) |
AMD_FMT_MOD_SET(DCC_INDEPENDENT_128B, 1) |
AMD_FMT_MOD_SET(DCC_MAX_COMPRESSED_BLOCK, AMD_FMT_MOD_DCC_BLOCK_64B);
}
static void dm_test_get_plane_modifiers_gfx9(struct kunit *test)
{
struct amdgpu_device *adev;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, adev);
adev->family = AMDGPU_FAMILY_AI;
adev->gfx.config.gb_addr_config_fields.num_pipes = 4;
adev->gfx.config.gb_addr_config_fields.num_banks = 8;
adev->gfx.config.gb_addr_config_fields.num_se = 2;
adev->gfx.config.gb_addr_config_fields.num_rb_per_se = 2;
dm_test_expect_mods_terminated(test, adev);
}
static void dm_test_get_plane_modifiers_gfx10_and_gfx12(struct kunit *test)
{
static const struct {
u32 family;
u32 gc_ip_version;
u32 num_pipes;
u32 num_pkrs;
} cases[] = {
{ AMDGPU_FAMILY_NV, IP_VERSION(10, 1, 0), 4, 0 },
{ AMDGPU_FAMILY_NV, IP_VERSION(10, 3, 0), 4, 2 },
{ AMDGPU_FAMILY_GC_12_0_0, 0, 0, 0 },
};
unsigned int i;
for (i = 0; i < ARRAY_SIZE(cases); i++) {
struct amdgpu_device *adev;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, adev);
adev->family = cases[i].family;
adev->ip_versions[GC_HWIP][0] = cases[i].gc_ip_version;
adev->gfx.config.gb_addr_config_fields.num_pipes = cases[i].num_pipes;
adev->gfx.config.gb_addr_config_fields.num_pkrs = cases[i].num_pkrs;
dm_test_expect_mods_terminated(test, adev);
}
}
static void dm_test_get_plane_modifiers_rv(struct kunit *test)
{
static const struct {
const char *name;
u32 external_rev_id;
u32 constant_encode;
} cases[] = {
{ "raven", 0x80, 0 },
{ "raven2", 0x81, 1 },
};
int pipes = 2;
int pipe_xor_bits = 3;
int bank_xor_bits = 2;
u64 s_x_mod;
u64 s_mod;
unsigned int i;
s_x_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(PIPE_XOR_BITS, pipe_xor_bits) |
AMD_FMT_MOD_SET(BANK_XOR_BITS, bank_xor_bits);
s_mod = AMD_FMT_MOD |
AMD_FMT_MOD_SET(TILE, AMD_FMT_MOD_TILE_GFX9_64K_S) |
AMD_FMT_MOD_SET(TILE_VERSION, AMD_FMT_MOD_TILE_VER_GFX9);
for (i = 0; i < ARRAY_SIZE(cases); i++) {
struct amdgpu_device *adev;
u64 *mods;
u64 dcc_mod;
u64 retile_mod;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, adev);
adev->family = AMDGPU_FAMILY_RV;
adev->asic_type = CHIP_RAVEN;
adev->external_rev_id = cases[i].external_rev_id;
adev->gfx.config.gb_addr_config_fields.num_pipes = 4;
adev->gfx.config.gb_addr_config_fields.num_banks = 4;
adev->gfx.config.gb_addr_config_fields.num_se = 2;
adev->gfx.config.gb_addr_config_fields.num_rb_per_se = 2;
mods = dm_test_get_primary_mods(test, adev);
dcc_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(PIPE_XOR_BITS, pipe_xor_bits) |
AMD_FMT_MOD_SET(BANK_XOR_BITS, bank_xor_bits) |
AMD_FMT_MOD_SET(DCC, 1) |
AMD_FMT_MOD_SET(DCC_INDEPENDENT_64B, 1) |
AMD_FMT_MOD_SET(DCC_MAX_COMPRESSED_BLOCK, AMD_FMT_MOD_DCC_BLOCK_64B) |
AMD_FMT_MOD_SET(DCC_CONSTANT_ENCODE, cases[i].constant_encode);
retile_mod = dcc_mod |
AMD_FMT_MOD_SET(DCC_RETILE, 1) |
AMD_FMT_MOD_SET(RB, 2) |
AMD_FMT_MOD_SET(PIPE, pipes);
KUNIT_EXPECT_TRUE_MSG(test, dm_test_mods_contain(mods, dcc_mod),
"%s", cases[i].name);
KUNIT_EXPECT_TRUE_MSG(test, dm_test_mods_contain(mods, retile_mod),
"%s", cases[i].name);
KUNIT_EXPECT_TRUE_MSG(test, dm_test_mods_contain(mods, s_x_mod),
"%s", cases[i].name);
KUNIT_EXPECT_TRUE_MSG(test, dm_test_mods_contain(mods, s_mod),
"%s", cases[i].name);
kfree(mods);
}
}
static void dm_test_get_plane_modifiers_gfx11_64k_first(struct kunit *test)
{
struct dm_test_gfx11_reg_ctx ctx = {0};
struct amdgpu_device *adev;
u64 *mods;
u32 pipe_xor_bits = 4;
u32 pkrs = 1;
u32 tile = AMD_FMT_MOD_TILE_GFX9_64K_R_X;
u64 dcc_best;
u64 dcc_4k;
u64 d_mod;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, adev);
dm_test_setup_gfx11_device(adev, &ctx, pkrs, pipe_xor_bits);
mods = dm_test_get_primary_mods(test, adev);
dcc_best = dm_test_gfx11_dcc_best_modifier(pipe_xor_bits, pkrs, tile);
dcc_4k = dm_test_gfx11_dcc_4k_modifier(pipe_xor_bits, pkrs, tile);
d_mod = AMD_FMT_MOD |
AMD_FMT_MOD_SET(TILE_VERSION, AMD_FMT_MOD_TILE_VER_GFX11) |
AMD_FMT_MOD_SET(TILE, AMD_FMT_MOD_TILE_GFX9_64K_D);
KUNIT_EXPECT_TRUE(test, ctx.called);
KUNIT_EXPECT_EQ(test, ctx.captured_reg, ctx.expected_reg);
KUNIT_EXPECT_EQ(test, ctx.captured_acc_flags, 0U);
KUNIT_EXPECT_EQ(test, ctx.captured_hwip, (u32)GC_HWIP);
KUNIT_EXPECT_EQ(test, ctx.captured_xcc_id, 0U);
KUNIT_EXPECT_EQ(test, mods[0], dcc_best);
KUNIT_EXPECT_TRUE(test, dm_test_mods_contain(mods, dcc_4k));
KUNIT_EXPECT_TRUE(test,
dm_test_mods_contain(mods,
dcc_best | AMD_FMT_MOD_SET(DCC_RETILE, 1)));
KUNIT_EXPECT_TRUE(test, dm_test_mods_contain(mods, d_mod));
dm_test_gfx11_reg_ctx = NULL;
kfree(mods);
}
static void dm_test_get_plane_modifiers_gfx11_256k_first(struct kunit *test)
{
struct dm_test_gfx11_reg_ctx ctx = {0};
struct amdgpu_device *adev;
u64 *mods;
u32 pipe_xor_bits = 5;
u32 pkrs = 2;
u32 tile = AMD_FMT_MOD_TILE_GFX11_256K_R_X;
u32 fallback_tile = AMD_FMT_MOD_TILE_GFX9_64K_R_X;
u64 dcc_best;
u64 fallback_dcc_best = dm_test_gfx11_dcc_best_modifier(pipe_xor_bits, pkrs,
fallback_tile);
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, adev);
dm_test_setup_gfx11_device(adev, &ctx, pkrs, pipe_xor_bits);
mods = dm_test_get_primary_mods(test, adev);
dcc_best = dm_test_gfx11_dcc_best_modifier(pipe_xor_bits, pkrs, tile);
KUNIT_EXPECT_TRUE(test, ctx.called);
KUNIT_EXPECT_EQ(test, ctx.captured_reg, ctx.expected_reg);
KUNIT_EXPECT_EQ(test, mods[0], dcc_best);
KUNIT_EXPECT_TRUE(test, dm_test_mods_contain(mods, fallback_dcc_best));
dm_test_gfx11_reg_ctx = NULL;
kfree(mods);
}
static void dm_test_fill_gfx9_plane_attributes_dcc(struct kunit *test)
{
struct amdgpu_device *adev;
struct dc *dc;
struct amdgpu_framebuffer *afb;
struct plane_size plane_size = {0};
struct dc_tiling_info tiling_info = {0};
struct dc_plane_dcc_param dcc = {0};
struct dc_plane_address address = {0};
struct dm_test_dcc_cap_ctx ctx = {
.callback_ret = true,
.capable = true,
.output_independent_64b_blks = true,
};
int ret;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
dc = kunit_kzalloc(test, sizeof(*dc), GFP_KERNEL);
afb = kunit_kzalloc(test, sizeof(*afb), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, dc);
KUNIT_ASSERT_NOT_NULL(test, afb);
adev->family = AMDGPU_FAMILY_NV;
adev->dm.dc = dc;
adev->gfx.config.gb_addr_config_fields.num_pipes = 2;
adev->gfx.config.gb_addr_config_fields.num_pkrs = 2;
adev->ip_versions[GC_HWIP][0] = IP_VERSION(10, 3, 0);
dc->cap_funcs.get_dcc_compression_cap = dm_test_get_dcc_compression_cap;
dm_test_dcc_ctx = &ctx;
afb->base.pitches[1] = 256;
afb->base.modifier = 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_GFX10_RBPLUS) |
AMD_FMT_MOD_SET(DCC, 1) |
AMD_FMT_MOD_SET(DCC_INDEPENDENT_64B, 1);
plane_size.surface_size.width = 1920;
plane_size.surface_size.height = 1080;
ret = dm_test_gfx9_attrs(adev, afb, &plane_size, &tiling_info, &dcc,
&address);
KUNIT_EXPECT_EQ(test, ret, 0);
KUNIT_EXPECT_EQ(test, (int)tiling_info.gfxversion, (int)DcGfxVersion9);
KUNIT_EXPECT_TRUE(test, dcc.enable);
KUNIT_EXPECT_EQ(test, (int)dcc.dcc_ind_blk, (int)hubp_ind_block_64b);
KUNIT_EXPECT_EQ(test, dcc.meta_pitch, 256U);
dm_test_dcc_ctx = NULL;
}
static void dm_test_fill_gfx9_plane_attributes_validate_fails(struct kunit *test)
{
struct amdgpu_device *adev;
struct dc *dc;
struct amdgpu_framebuffer *afb;
struct plane_size plane_size = {0};
struct dc_tiling_info tiling_info = {0};
struct dc_plane_dcc_param dcc = {0};
struct dc_plane_address address = {0};
u64 tile_version = AMD_FMT_MOD_TILE_VER_GFX10_RBPLUS;
int ret;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
dc = kunit_kzalloc(test, sizeof(*dc), GFP_KERNEL);
afb = kunit_kzalloc(test, sizeof(*afb), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, dc);
KUNIT_ASSERT_NOT_NULL(test, afb);
adev->family = AMDGPU_FAMILY_NV;
adev->dm.dc = dc;
adev->ip_versions[GC_HWIP][0] = IP_VERSION(10, 3, 0);
afb->base.modifier = dm_test_gfx9_dcc_modifier(tile_version, true, false);
plane_size.surface_size.width = 1920;
plane_size.surface_size.height = 1080;
ret = dm_test_gfx9_attrs(adev, afb, &plane_size, &tiling_info, &dcc,
&address);
KUNIT_EXPECT_EQ(test, ret, -EINVAL);
}
static void dm_test_fill_gfx9_plane_attributes_dcc_ind_blk(struct kunit *test)
{
static const struct {
const char *name;
u64 tile_version;
bool independent_64b_blks;
bool independent_128b_blks;
int expected_ind_blk;
} cases[] = {
{ "rbplus 64B no 128BCL", AMD_FMT_MOD_TILE_VER_GFX10_RBPLUS, true, true,
hubp_ind_block_64b_no_128bcl },
{ "rbplus 128B", AMD_FMT_MOD_TILE_VER_GFX10_RBPLUS, false, true,
hubp_ind_block_128b },
{ "rbplus unconstrained", AMD_FMT_MOD_TILE_VER_GFX10_RBPLUS, false, false,
hubp_ind_block_unconstrained },
{ "gfx9 64B", AMD_FMT_MOD_TILE_VER_GFX9, true, false, hubp_ind_block_64b },
{ "gfx9 unconstrained", AMD_FMT_MOD_TILE_VER_GFX9, false, false,
hubp_ind_block_unconstrained },
};
struct plane_size plane_size = {0};
struct amdgpu_device *adev;
struct amdgpu_framebuffer *afb;
struct dc *dc;
unsigned int i;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
dc = kunit_kzalloc(test, sizeof(*dc), GFP_KERNEL);
afb = kunit_kzalloc(test, sizeof(*afb), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, dc);
KUNIT_ASSERT_NOT_NULL(test, afb);
plane_size.surface_size.width = 1920;
plane_size.surface_size.height = 1080;
for (i = 0; i < ARRAY_SIZE(cases); i++) {
struct dc_tiling_info tiling_info = {0};
struct dc_plane_dcc_param dcc = {0};
struct dc_plane_address address = {0};
struct dm_test_dcc_cap_ctx ctx = {0};
int ret;
dm_test_setup_gfx9_dcc_device(adev, dc, &ctx, cases[i].independent_64b_blks);
afb->base.modifier = dm_test_gfx9_dcc_modifier(cases[i].tile_version,
cases[i].independent_64b_blks,
cases[i].independent_128b_blks);
ret = dm_test_gfx9_attrs(adev, afb, &plane_size, &tiling_info, &dcc,
&address);
dm_test_dcc_ctx = NULL;
KUNIT_EXPECT_EQ_MSG(test, ret, 0, "%s", cases[i].name);
KUNIT_EXPECT_TRUE_MSG(test, dcc.enable, "%s", cases[i].name);
KUNIT_EXPECT_EQ_MSG(test, (int)dcc.dcc_ind_blk, cases[i].expected_ind_blk,
"%s", cases[i].name);
}
}
static void dm_test_fill_gfx12_plane_attributes_dcc_blocks(struct kunit *test)
{
static const struct {
const char *name;
u64 max_compressed_block;
bool independent_64b_blks;
int expected_ind_blk;
} cases[] = {
{ "64B", 0, true, hubp_ind_block_64b },
{ "128B", 1, false, hubp_ind_block_128b },
{ "unconstrained", 2, false, hubp_ind_block_unconstrained },
};
struct dm_test_dcc_cap_ctx ctx = {
.callback_ret = true,
.capable = true,
.output_independent_64b_blks = false,
};
struct plane_size plane_size = {0};
struct amdgpu_device *adev;
struct amdgpu_framebuffer *afb;
struct dc *dc;
unsigned int i;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
dc = kunit_kzalloc(test, sizeof(*dc), GFP_KERNEL);
afb = kunit_kzalloc(test, sizeof(*afb), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, dc);
KUNIT_ASSERT_NOT_NULL(test, afb);
adev->family = AMDGPU_FAMILY_GC_12_0_0;
adev->dm.dc = dc;
dc->cap_funcs.get_dcc_compression_cap = dm_test_get_dcc_compression_cap;
plane_size.surface_size.width = 1920;
plane_size.surface_size.height = 1080;
for (i = 0; i < ARRAY_SIZE(cases); i++) {
struct dc_tiling_info tiling_info = {0};
struct dc_plane_dcc_param dcc = {0};
struct dc_plane_address address = {0};
int ret;
afb->base.modifier = AMD_FMT_MOD |
AMD_FMT_MOD_SET(TILE, AMD_FMT_MOD_TILE_GFX12_64K_2D) |
AMD_FMT_MOD_SET(TILE_VERSION, AMD_FMT_MOD_TILE_VER_GFX12) |
AMD_FMT_MOD_SET(DCC, 1) |
AMD_FMT_MOD_SET(DCC_MAX_COMPRESSED_BLOCK,
cases[i].max_compressed_block);
dm_test_dcc_ctx = &ctx;
ret = dm_test_gfx12_attrs(adev, afb, &plane_size, &tiling_info, &dcc,
&address);
dm_test_dcc_ctx = NULL;
KUNIT_EXPECT_EQ_MSG(test, ret, 0, "%s", cases[i].name);
KUNIT_EXPECT_EQ_MSG(test, (int)tiling_info.gfxversion, (int)DcGfxAddr3,
"%s", cases[i].name);
KUNIT_EXPECT_TRUE_MSG(test, dcc.enable, "%s", cases[i].name);
KUNIT_EXPECT_EQ_MSG(test, (bool)dcc.independent_64b_blks,
cases[i].independent_64b_blks, "%s", cases[i].name);
KUNIT_EXPECT_EQ_MSG(test, (int)dcc.dcc_ind_blk, cases[i].expected_ind_blk,
"%s", cases[i].name);
}
}
static void dm_test_fill_gfx12_plane_attributes_validate_fails(struct kunit *test)
{
struct amdgpu_device *adev;
struct dc *dc;
struct amdgpu_framebuffer *afb;
struct plane_size plane_size = {0};
struct dc_tiling_info tiling_info = {0};
struct dc_plane_dcc_param dcc = {0};
struct dc_plane_address address = {0};
int ret;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
dc = kunit_kzalloc(test, sizeof(*dc), GFP_KERNEL);
afb = kunit_kzalloc(test, sizeof(*afb), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, dc);
KUNIT_ASSERT_NOT_NULL(test, afb);
adev->family = AMDGPU_FAMILY_GC_12_0_0;
adev->dm.dc = dc;
afb->base.modifier = AMD_FMT_MOD |
AMD_FMT_MOD_SET(TILE, AMD_FMT_MOD_TILE_GFX12_64K_2D) |
AMD_FMT_MOD_SET(TILE_VERSION, AMD_FMT_MOD_TILE_VER_GFX12) |
AMD_FMT_MOD_SET(DCC, 1) |
AMD_FMT_MOD_SET(DCC_MAX_COMPRESSED_BLOCK, 1);
plane_size.surface_size.width = 1920;
plane_size.surface_size.height = 1080;
ret = dm_test_gfx12_attrs(adev, afb, &plane_size, &tiling_info, &dcc,
&address);
KUNIT_EXPECT_EQ(test, ret, -EINVAL);
}
static void dm_test_fill_plane_buffer_attributes_video(struct kunit *test)
{
struct amdgpu_device *adev;
struct amdgpu_framebuffer *afb;
struct dc_tiling_info tiling_info;
struct plane_size plane_size;
struct dc_plane_dcc_param dcc;
struct dc_plane_address address;
int ret;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
afb = kunit_kzalloc(test, sizeof(*afb), GFP_KERNEL);
tiling_info = (struct dc_tiling_info){0};
plane_size = (struct plane_size){0};
dcc = (struct dc_plane_dcc_param){0};
address = (struct dc_plane_address){0};
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, afb);
adev->family = AMDGPU_FAMILY_NV;
adev->ip_versions[GC_HWIP][0] = IP_VERSION(10, 3, 0);
afb->address = 0x80000000ULL;
afb->base.width = 1920;
afb->base.height = 1080;
afb->base.offsets[0] = 0;
afb->base.offsets[1] = 0x200000;
afb->base.pitches[0] = 1920;
afb->base.pitches[1] = 1920;
afb->base.format = drm_format_info(DRM_FORMAT_NV12);
afb->base.modifier = DRM_FORMAT_MOD_LINEAR;
KUNIT_ASSERT_NOT_NULL(test, afb->base.format);
ret = dm_test_video_attrs(adev, afb, &tiling_info, &plane_size, &dcc,
&address);
KUNIT_EXPECT_EQ(test, ret, 0);
KUNIT_EXPECT_EQ(test, plane_size.surface_size.width, 1920);
KUNIT_EXPECT_EQ(test, plane_size.chroma_size.width, 960U);
KUNIT_EXPECT_EQ(test, plane_size.chroma_size.height, 540U);
KUNIT_EXPECT_EQ(test, address.type,
(int)PLN_ADDR_TYPE_VIDEO_PROGRESSIVE);
KUNIT_EXPECT_EQ(test, (int)tiling_info.gfxversion, (int)DcGfxVersion9);
}
static void dm_test_fill_plane_buffer_attributes_gfx12(struct kunit *test)
{
struct amdgpu_device *adev;
struct dc *dc;
struct amdgpu_framebuffer *afb;
struct dc_tiling_info tiling_info;
struct plane_size plane_size;
struct dc_plane_dcc_param dcc;
struct dc_plane_address address;
int ret;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
dc = kunit_kzalloc(test, sizeof(*dc), GFP_KERNEL);
afb = kunit_kzalloc(test, sizeof(*afb), GFP_KERNEL);
tiling_info = (struct dc_tiling_info){0};
plane_size = (struct plane_size){0};
dcc = (struct dc_plane_dcc_param){0};
address = (struct dc_plane_address){0};
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, dc);
KUNIT_ASSERT_NOT_NULL(test, afb);
adev->family = AMDGPU_FAMILY_GC_12_0_0;
adev->dm.dc = dc;
afb->address = 0x80000000ULL;
afb->base.width = 1920;
afb->base.height = 1080;
afb->base.pitches[0] = 7680;
afb->base.format = drm_format_info(DRM_FORMAT_XRGB8888);
afb->base.modifier = DRM_FORMAT_MOD_LINEAR;
KUNIT_ASSERT_NOT_NULL(test, afb->base.format);
ret = dm_test_graphics_attrs(adev, afb, &tiling_info, &plane_size, &dcc,
&address);
KUNIT_EXPECT_EQ(test, ret, 0);
KUNIT_EXPECT_EQ(test, address.type, (int)PLN_ADDR_TYPE_GRAPHICS);
KUNIT_EXPECT_EQ(test, (int)tiling_info.gfxversion, (int)DcGfxAddr3);
}
static void dm_test_helper_check_state_scaling_caps(struct kunit *test)
{
struct amdgpu_device *adev;
struct dc *dc;
struct drm_plane *plane;
struct drm_plane_state *state;
struct drm_crtc *crtc;
struct drm_crtc_state *new_crtc_state;
struct drm_framebuffer *fb;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
dc = kunit_kzalloc(test, sizeof(*dc), GFP_KERNEL);
plane = kunit_kzalloc(test, sizeof(*plane), GFP_KERNEL);
state = kunit_kzalloc(test, sizeof(*state), GFP_KERNEL);
crtc = kunit_kzalloc(test, sizeof(*crtc), GFP_KERNEL);
new_crtc_state = kunit_kzalloc(test, sizeof(*new_crtc_state), GFP_KERNEL);
fb = kunit_kzalloc(test, sizeof(*fb), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, dc);
KUNIT_ASSERT_NOT_NULL(test, plane);
KUNIT_ASSERT_NOT_NULL(test, state);
KUNIT_ASSERT_NOT_NULL(test, crtc);
KUNIT_ASSERT_NOT_NULL(test, new_crtc_state);
KUNIT_ASSERT_NOT_NULL(test, fb);
adev->dm.dc = dc;
dc->caps.planes[0].max_upscale_factor.argb8888 = 1;
dc->caps.planes[0].max_downscale_factor.argb8888 = 1;
plane->type = DRM_PLANE_TYPE_OVERLAY;
plane->dev = &adev->ddev;
crtc->dev = &adev->ddev;
fb->width = 100;
fb->height = 100;
fb->format = drm_format_info(DRM_FORMAT_XRGB8888);
KUNIT_ASSERT_NOT_NULL(test, fb->format);
state->plane = plane;
state->fb = fb;
state->crtc = crtc;
state->src_w = 100 << 16;
state->src_h = 100 << 16;
state->crtc_w = 200;
state->crtc_h = 200;
new_crtc_state->crtc = crtc;
new_crtc_state->mode.crtc_hdisplay = 1920;
new_crtc_state->mode.crtc_vdisplay = 1080;
KUNIT_EXPECT_EQ(test,
amdgpu_dm_plane_helper_check_state(state, new_crtc_state),
-ERANGE);
}
static void dm_test_fill_dc_scaling_info_nv12_dcn1x(struct kunit *test)
{
struct amdgpu_device *adev;
struct drm_plane_state state = {0};
struct drm_framebuffer fb = {0};
struct dc_scaling_info info = {0};
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, adev);
adev->ip_versions[DCE_HWIP][0] = IP_VERSION(1, 0, 0);
fb.format = drm_format_info(DRM_FORMAT_NV12);
KUNIT_ASSERT_NOT_NULL(test, fb.format);
state.fb = &fb;
state.src_x = 10 << 16;
state.src_y = 0;
state.src_w = 100 << 16;
state.src_h = 100 << 16;
state.crtc_w = 100;
state.crtc_h = 100;
KUNIT_EXPECT_EQ(test,
amdgpu_dm_plane_fill_dc_scaling_info(adev, &state, &info),
-EINVAL);
state.src_x = 0;
state.src_y = 10 << 16;
memset(&info, 0, sizeof(info));
KUNIT_EXPECT_EQ(test,
amdgpu_dm_plane_fill_dc_scaling_info(adev, &state, &info),
-EINVAL);
}
static void dm_test_fill_dc_scaling_info_plane_caps(struct kunit *test)
{
struct amdgpu_device *adev;
struct dc *dc;
struct drm_plane *plane;
struct drm_plane_state *state;
struct drm_framebuffer *fb;
struct dc_scaling_info info = {0};
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
dc = kunit_kzalloc(test, sizeof(*dc), 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, dc);
KUNIT_ASSERT_NOT_NULL(test, plane);
KUNIT_ASSERT_NOT_NULL(test, state);
KUNIT_ASSERT_NOT_NULL(test, fb);
adev->dm.dc = dc;
dc->caps.planes[0].max_upscale_factor.argb8888 = 16000;
dc->caps.planes[0].max_downscale_factor.argb8888 = 250;
plane->dev = &adev->ddev;
fb->format = drm_format_info(DRM_FORMAT_XRGB8888);
KUNIT_ASSERT_NOT_NULL(test, fb->format);
state->plane = plane;
state->fb = fb;
state->src_w = 100 << 16;
state->src_h = 100 << 16;
state->crtc_w = 100;
state->crtc_h = 100;
KUNIT_EXPECT_EQ(test,
amdgpu_dm_plane_fill_dc_scaling_info(adev, state, &info),
0);
}
static void dm_test_format_mod_supported_d_swizzle_reject(struct kunit *test)
{
struct amdgpu_device *adev;
struct drm_plane *plane;
u64 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_RV;
plane->dev = &adev->ddev;
listed_mod = AMD_FMT_MOD |
AMD_FMT_MOD_SET(TILE, AMD_FMT_MOD_TILE_GFX9_64K_D) |
AMD_FMT_MOD_SET(TILE_VERSION, AMD_FMT_MOD_TILE_VER_GFX9);
plane->modifiers = &listed_mod;
plane->modifier_count = 1;
KUNIT_EXPECT_FALSE(test,
amdgpu_dm_plane_format_mod_supported(plane, DRM_FORMAT_XRGB8888,
listed_mod));
}
static void dm_test_atomic_async_check_rejects(struct kunit *test)
{
struct drm_plane *plane;
plane = kunit_kzalloc(test, sizeof(*plane), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, plane);
plane->type = DRM_PLANE_TYPE_PRIMARY;
KUNIT_EXPECT_EQ(test,
amdgpu_dm_plane_atomic_async_check(plane, NULL, true),
-EINVAL);
KUNIT_EXPECT_EQ(test,
amdgpu_dm_plane_atomic_async_check(plane, NULL, false),
-EINVAL);
}
static void dm_test_atomic_async_check_overlay_cursor(struct kunit *test)
{
struct drm_atomic_commit *state;
struct __drm_planes_state *planes;
struct __drm_crtcs_state *crtcs;
struct drm_plane *plane;
struct drm_plane_state *plane_state;
struct drm_crtc *crtc;
struct dm_crtc_state *dm_crtc_state;
state = kunit_kzalloc(test, sizeof(*state), GFP_KERNEL);
planes = kunit_kzalloc(test, sizeof(*planes), GFP_KERNEL);
crtcs = kunit_kzalloc(test, sizeof(*crtcs), GFP_KERNEL);
plane = kunit_kzalloc(test, sizeof(*plane), GFP_KERNEL);
plane_state = kunit_kzalloc(test, sizeof(*plane_state), GFP_KERNEL);
crtc = kunit_kzalloc(test, sizeof(*crtc), GFP_KERNEL);
dm_crtc_state = kunit_kzalloc(test, sizeof(*dm_crtc_state), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, state);
KUNIT_ASSERT_NOT_NULL(test, planes);
KUNIT_ASSERT_NOT_NULL(test, crtcs);
KUNIT_ASSERT_NOT_NULL(test, plane);
KUNIT_ASSERT_NOT_NULL(test, plane_state);
KUNIT_ASSERT_NOT_NULL(test, crtc);
KUNIT_ASSERT_NOT_NULL(test, dm_crtc_state);
plane->type = DRM_PLANE_TYPE_CURSOR;
plane->index = 0;
crtc->index = 0;
plane_state->crtc = crtc;
dm_crtc_state->cursor_mode = DM_CURSOR_OVERLAY_MODE;
state->planes = planes;
state->crtcs = crtcs;
state->planes[0].new_state = plane_state;
state->crtcs[0].new_state = &dm_crtc_state->base;
KUNIT_EXPECT_EQ(test,
amdgpu_dm_plane_atomic_async_check(plane, state, false),
-EINVAL);
dm_crtc_state->cursor_mode = DM_CURSOR_NATIVE_MODE;
KUNIT_EXPECT_EQ(test,
amdgpu_dm_plane_atomic_async_check(plane, state, false),
0);
}
static struct amdgpu_device *dm_test_init_atomic_check_state(struct kunit *test,
struct drm_atomic_commit **state,
struct drm_plane **plane,
struct dm_plane_state **dm_plane_state,
struct drm_crtc_state **new_crtc_state,
struct drm_framebuffer **fb)
{
struct amdgpu_device *adev;
struct dc *dc;
struct __drm_planes_state *planes;
struct __drm_crtcs_state *crtcs;
struct dc_plane_state *dc_plane_state;
struct drm_crtc *crtc;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
dc = kunit_kzalloc(test, sizeof(*dc), GFP_KERNEL);
*state = kunit_kzalloc(test, sizeof(**state), GFP_KERNEL);
planes = kunit_kzalloc(test, sizeof(*planes), GFP_KERNEL);
crtcs = kunit_kzalloc(test, sizeof(*crtcs), GFP_KERNEL);
*plane = kunit_kzalloc(test, sizeof(**plane), GFP_KERNEL);
*dm_plane_state = kunit_kzalloc(test, sizeof(**dm_plane_state), GFP_KERNEL);
dc_plane_state = kunit_kzalloc(test, sizeof(*dc_plane_state), GFP_KERNEL);
crtc = kunit_kzalloc(test, sizeof(*crtc), GFP_KERNEL);
*new_crtc_state = kunit_kzalloc(test, sizeof(**new_crtc_state), GFP_KERNEL);
*fb = kunit_kzalloc(test, sizeof(**fb), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, dc);
KUNIT_ASSERT_NOT_NULL(test, *state);
KUNIT_ASSERT_NOT_NULL(test, planes);
KUNIT_ASSERT_NOT_NULL(test, crtcs);
KUNIT_ASSERT_NOT_NULL(test, *plane);
KUNIT_ASSERT_NOT_NULL(test, *dm_plane_state);
KUNIT_ASSERT_NOT_NULL(test, dc_plane_state);
KUNIT_ASSERT_NOT_NULL(test, crtc);
KUNIT_ASSERT_NOT_NULL(test, *new_crtc_state);
KUNIT_ASSERT_NOT_NULL(test, *fb);
adev->dm.dc = dc;
dc->caps.planes[0].max_upscale_factor.argb8888 = 1000;
dc->caps.planes[0].max_downscale_factor.argb8888 = 1000;
dc->caps.planes[0].max_upscale_factor.nv12 = 1000;
dc->caps.planes[0].max_downscale_factor.nv12 = 1000;
(*plane)->dev = &adev->ddev;
(*plane)->index = 0;
(*plane)->type = DRM_PLANE_TYPE_OVERLAY;
(*plane)->name = "kunit-plane";
crtc->dev = &adev->ddev;
crtc->index = 0;
(*fb)->width = 100;
(*fb)->height = 100;
(*fb)->format = drm_format_info(DRM_FORMAT_XRGB8888);
KUNIT_ASSERT_NOT_NULL(test, (*fb)->format);
(*dm_plane_state)->base.plane = *plane;
(*dm_plane_state)->base.state = *state;
(*dm_plane_state)->base.crtc = crtc;
(*dm_plane_state)->base.fb = *fb;
(*dm_plane_state)->base.src_w = 100 << 16;
(*dm_plane_state)->base.src_h = 100 << 16;
(*dm_plane_state)->base.crtc_w = 100;
(*dm_plane_state)->base.crtc_h = 100;
(*dm_plane_state)->dc_state = dc_plane_state;
(*new_crtc_state)->crtc = crtc;
(*new_crtc_state)->enable = true;
(*new_crtc_state)->mode.crtc_hdisplay = 1920;
(*new_crtc_state)->mode.crtc_vdisplay = 1080;
(*state)->planes = planes;
(*state)->crtcs = crtcs;
(*state)->planes[0].new_state = &(*dm_plane_state)->base;
(*state)->crtcs[0].new_state = *new_crtc_state;
return adev;
}
static void dm_test_atomic_check_no_dc_state(struct kunit *test)
{
struct amdgpu_device *adev;
struct drm_atomic_commit *state;
struct __drm_planes_state *planes;
struct drm_plane *plane;
struct dm_plane_state *dm_plane_state;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
state = kunit_kzalloc(test, sizeof(*state), GFP_KERNEL);
planes = kunit_kzalloc(test, sizeof(*planes), GFP_KERNEL);
plane = kunit_kzalloc(test, sizeof(*plane), GFP_KERNEL);
dm_plane_state = kunit_kzalloc(test, sizeof(*dm_plane_state), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, state);
KUNIT_ASSERT_NOT_NULL(test, planes);
KUNIT_ASSERT_NOT_NULL(test, plane);
KUNIT_ASSERT_NOT_NULL(test, dm_plane_state);
plane->dev = &adev->ddev;
plane->index = 0;
dm_plane_state->base.plane = plane;
state->planes = planes;
state->planes[0].new_state = &dm_plane_state->base;
KUNIT_EXPECT_EQ(test, amdgpu_dm_plane_atomic_check(plane, state), 0);
}
static void dm_test_atomic_check_missing_crtc_state(struct kunit *test)
{
struct amdgpu_device *adev;
struct drm_atomic_commit *state;
struct __drm_planes_state *planes;
struct __drm_crtcs_state *crtcs;
struct drm_plane *plane;
struct dm_plane_state *dm_plane_state;
struct dc_plane_state *dc_plane_state;
struct drm_crtc *crtc;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
state = kunit_kzalloc(test, sizeof(*state), GFP_KERNEL);
planes = kunit_kzalloc(test, sizeof(*planes), GFP_KERNEL);
crtcs = kunit_kzalloc(test, sizeof(*crtcs), GFP_KERNEL);
plane = kunit_kzalloc(test, sizeof(*plane), GFP_KERNEL);
dm_plane_state = kunit_kzalloc(test, sizeof(*dm_plane_state), GFP_KERNEL);
dc_plane_state = kunit_kzalloc(test, sizeof(*dc_plane_state), GFP_KERNEL);
crtc = kunit_kzalloc(test, sizeof(*crtc), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, state);
KUNIT_ASSERT_NOT_NULL(test, planes);
KUNIT_ASSERT_NOT_NULL(test, crtcs);
KUNIT_ASSERT_NOT_NULL(test, plane);
KUNIT_ASSERT_NOT_NULL(test, dm_plane_state);
KUNIT_ASSERT_NOT_NULL(test, dc_plane_state);
KUNIT_ASSERT_NOT_NULL(test, crtc);
plane->dev = &adev->ddev;
plane->index = 0;
crtc->index = 0;
dm_plane_state->base.plane = plane;
dm_plane_state->base.crtc = crtc;
dm_plane_state->dc_state = dc_plane_state;
state->planes = planes;
state->crtcs = crtcs;
state->planes[0].new_state = &dm_plane_state->base;
KUNIT_EXPECT_EQ(test, amdgpu_dm_plane_atomic_check(plane, state), -EINVAL);
}
static void dm_test_atomic_check_rejects(struct kunit *test)
{
struct drm_atomic_commit *state;
struct drm_plane *plane;
struct dm_plane_state *dm_plane_state;
struct drm_crtc_state *new_crtc_state;
struct drm_framebuffer *fb;
struct amdgpu_device *adev;
void *color_pipeline;
void *degamma_lut;
dm_test_init_atomic_check_state(test, &state, &plane, &dm_plane_state,
&new_crtc_state, &fb);
dm_plane_state->base.crtc_w = 10;
KUNIT_EXPECT_EQ(test, amdgpu_dm_plane_atomic_check(plane, state), -EINVAL);
dm_test_init_atomic_check_state(test, &state, &plane, &dm_plane_state,
&new_crtc_state, &fb);
color_pipeline = kunit_kzalloc(test, 1, GFP_KERNEL);
degamma_lut = kunit_kzalloc(test, 1, GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, color_pipeline);
KUNIT_ASSERT_NOT_NULL(test, degamma_lut);
dm_plane_state->base.color_pipeline = color_pipeline;
new_crtc_state->degamma_lut = degamma_lut;
KUNIT_EXPECT_EQ(test, amdgpu_dm_plane_atomic_check(plane, state), -EINVAL);
adev = dm_test_init_atomic_check_state(test, &state, &plane, &dm_plane_state,
&new_crtc_state, &fb);
adev->ip_versions[DCE_HWIP][0] = IP_VERSION(1, 0, 0);
fb->width = 200;
fb->format = drm_format_info(DRM_FORMAT_NV12);
KUNIT_ASSERT_NOT_NULL(test, fb->format);
dm_plane_state->base.src_x = 1 << 16;
KUNIT_EXPECT_EQ(test, amdgpu_dm_plane_atomic_check(plane, state), -EINVAL);
}
static void dm_test_panic_flush_no_dc_state(struct kunit *test)
{
struct drm_plane *plane;
struct dm_plane_state *dm_plane_state;
plane = kunit_kzalloc(test, sizeof(*plane), GFP_KERNEL);
dm_plane_state = kunit_kzalloc(test, sizeof(*dm_plane_state), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, plane);
KUNIT_ASSERT_NOT_NULL(test, dm_plane_state);
plane->state = &dm_plane_state->base;
amdgpu_dm_plane_panic_flush(plane);
}
static const struct drm_plane_funcs dm_test_plane_reset_funcs = {
.atomic_destroy_state = amdgpu_dm_plane_drm_plane_destroy_state,
};
static void dm_test_plane_create_state_initializes_state(struct kunit *test)
{
struct drm_plane_state *plane_state;
struct dm_plane_state *new_state;
struct drm_plane *plane;
plane = kunit_kzalloc(test, sizeof(*plane), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, plane);
plane->funcs = &dm_test_plane_reset_funcs;
plane_state = amdgpu_dm_plane_drm_plane_create_state(plane);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, plane_state);
new_state = to_dm_plane_state(plane_state);
KUNIT_EXPECT_EQ(test, new_state->degamma_tf, AMDGPU_TRANSFER_FUNCTION_DEFAULT);
KUNIT_EXPECT_EQ(test, new_state->hdr_mult, AMDGPU_HDR_MULT_DEFAULT);
KUNIT_EXPECT_EQ(test, new_state->shaper_tf, AMDGPU_TRANSFER_FUNCTION_DEFAULT);
KUNIT_EXPECT_EQ(test, new_state->blend_tf, AMDGPU_TRANSFER_FUNCTION_DEFAULT);
amdgpu_dm_plane_drm_plane_destroy_state(plane, &new_state->base);
}
static void dm_test_plane_duplicate_state_copies_fields(struct kunit *test)
{
struct dm_plane_state *old_state;
struct drm_plane_state *dup_base;
struct dm_plane_state *dup_state;
struct drm_plane *plane;
plane = kunit_kzalloc(test, sizeof(*plane), GFP_KERNEL);
old_state = kunit_kzalloc(test, sizeof(*old_state), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, plane);
KUNIT_ASSERT_NOT_NULL(test, old_state);
old_state->flip_addr = kunit_kzalloc(test, sizeof(*old_state->flip_addr), GFP_KERNEL);
old_state->scaling_info = kunit_kzalloc(test, sizeof(*old_state->scaling_info), GFP_KERNEL);
old_state->plane_info = kunit_kzalloc(test, sizeof(*old_state->plane_info), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, old_state->flip_addr);
KUNIT_ASSERT_NOT_NULL(test, old_state->scaling_info);
KUNIT_ASSERT_NOT_NULL(test, old_state->plane_info);
old_state->degamma_tf = AMDGPU_TRANSFER_FUNCTION_PQ_EOTF;
old_state->hdr_mult = 0x123456789ULL;
old_state->shaper_tf = AMDGPU_TRANSFER_FUNCTION_IDENTITY;
old_state->blend_tf = AMDGPU_TRANSFER_FUNCTION_SRGB_EOTF;
plane->state = &old_state->base;
dup_base = amdgpu_dm_plane_drm_plane_duplicate_state(plane);
KUNIT_ASSERT_NOT_NULL(test, dup_base);
dup_state = to_dm_plane_state(dup_base);
KUNIT_EXPECT_EQ(test, dup_state->degamma_tf, AMDGPU_TRANSFER_FUNCTION_PQ_EOTF);
KUNIT_EXPECT_EQ(test, dup_state->hdr_mult, 0x123456789ULL);
KUNIT_EXPECT_EQ(test, dup_state->shaper_tf, AMDGPU_TRANSFER_FUNCTION_IDENTITY);
KUNIT_EXPECT_EQ(test, dup_state->blend_tf, AMDGPU_TRANSFER_FUNCTION_SRGB_EOTF);
KUNIT_EXPECT_NULL(test, dup_state->dc_state);
amdgpu_dm_plane_drm_plane_destroy_state(plane, dup_base);
}
static void dm_test_attach_color_blobs(struct kunit *test, struct drm_device *dev,
struct dm_plane_state *state)
{
struct drm_property_blob **blobs[] = {
&state->degamma_lut, &state->ctm, &state->lut3d,
&state->shaper_lut, &state->blend_lut,
};
u32 blob_data = 0;
unsigned int i;
for (i = 0; i < ARRAY_SIZE(blobs); i++) {
*blobs[i] = drm_property_create_blob(dev, sizeof(blob_data), &blob_data);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, *blobs[i]);
}
}
static void dm_test_plane_duplicate_state_copies_resources(struct kunit *test)
{
struct amdgpu_device *adev = dm_kunit_alloc_adev(test);
struct dm_plane_state *old_state;
struct drm_plane_state *dup_base;
struct dm_plane_state *dup_state;
struct dc_plane_state *dc_plane_state;
struct drm_plane *plane;
KUNIT_ASSERT_EQ(test, drmm_mode_config_init(&adev->ddev), 0);
plane = kunit_kzalloc(test, sizeof(*plane), GFP_KERNEL);
old_state = kunit_kzalloc(test, sizeof(*old_state), GFP_KERNEL);
dc_plane_state = kunit_kzalloc(test, sizeof(*dc_plane_state), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, plane);
KUNIT_ASSERT_NOT_NULL(test, old_state);
KUNIT_ASSERT_NOT_NULL(test, dc_plane_state);
kref_init(&dc_plane_state->refcount);
old_state->dc_state = dc_plane_state;
dm_test_attach_color_blobs(test, &adev->ddev, old_state);
old_state->flip_addr = kunit_kzalloc(test, sizeof(*old_state->flip_addr), GFP_KERNEL);
old_state->scaling_info = kunit_kzalloc(test, sizeof(*old_state->scaling_info), GFP_KERNEL);
old_state->plane_info = kunit_kzalloc(test, sizeof(*old_state->plane_info), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, old_state->flip_addr);
KUNIT_ASSERT_NOT_NULL(test, old_state->scaling_info);
KUNIT_ASSERT_NOT_NULL(test, old_state->plane_info);
plane->state = &old_state->base;
dup_base = amdgpu_dm_plane_drm_plane_duplicate_state(plane);
KUNIT_ASSERT_NOT_NULL(test, dup_base);
dup_state = to_dm_plane_state(dup_base);
KUNIT_EXPECT_PTR_EQ(test, dup_state->dc_state, dc_plane_state);
KUNIT_EXPECT_EQ(test, kref_read(&dc_plane_state->refcount), 2U);
KUNIT_EXPECT_PTR_EQ(test, dup_state->degamma_lut, old_state->degamma_lut);
KUNIT_EXPECT_PTR_EQ(test, dup_state->ctm, old_state->ctm);
KUNIT_EXPECT_PTR_EQ(test, dup_state->shaper_lut, old_state->shaper_lut);
KUNIT_EXPECT_PTR_EQ(test, dup_state->lut3d, old_state->lut3d);
KUNIT_EXPECT_PTR_EQ(test, dup_state->blend_lut, old_state->blend_lut);
amdgpu_dm_plane_drm_plane_destroy_state(plane, dup_base);
drm_property_blob_put(old_state->degamma_lut);
drm_property_blob_put(old_state->ctm);
drm_property_blob_put(old_state->lut3d);
drm_property_blob_put(old_state->shaper_lut);
drm_property_blob_put(old_state->blend_lut);
}
static void dm_test_plane_destroy_state_minimal(struct kunit *test)
{
struct dm_plane_state *dm_plane_state;
struct drm_plane *plane;
plane = kunit_kzalloc(test, sizeof(*plane), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, plane);
dm_plane_state = kzalloc_obj(*dm_plane_state);
KUNIT_ASSERT_NOT_NULL(test, dm_plane_state);
amdgpu_dm_plane_drm_plane_destroy_state(plane, &dm_plane_state->base);
}
static void dm_test_plane_destroy_state_releases_resources(struct kunit *test)
{
struct amdgpu_device *adev = dm_kunit_alloc_adev(test);
struct dm_plane_state *dm_plane_state;
struct dc_plane_state *dc_plane_state;
struct drm_plane *plane;
KUNIT_ASSERT_EQ(test, drmm_mode_config_init(&adev->ddev), 0);
plane = kunit_kzalloc(test, sizeof(*plane), GFP_KERNEL);
dc_plane_state = kunit_kzalloc(test, sizeof(*dc_plane_state), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, plane);
KUNIT_ASSERT_NOT_NULL(test, dc_plane_state);
dm_plane_state = kzalloc_obj(*dm_plane_state);
KUNIT_ASSERT_NOT_NULL(test, dm_plane_state);
kref_init(&dc_plane_state->refcount);
kref_get(&dc_plane_state->refcount);
dm_plane_state->dc_state = dc_plane_state;
dm_test_attach_color_blobs(test, &adev->ddev, dm_plane_state);
amdgpu_dm_plane_drm_plane_destroy_state(plane, &dm_plane_state->base);
KUNIT_EXPECT_EQ(test, kref_read(&dc_plane_state->refcount), 1U);
}
static void dm_test_add_modifier_dedup(struct kunit *test)
{
u64 size = 2;
u64 cap = 4;
u64 *mods = kmalloc_array(cap, sizeof(*mods), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, mods);
mods[0] = 0xAAULL;
mods[1] = 0xBBULL;
amdgpu_dm_plane_add_modifier_dedup(&mods, &size, &cap, 0xAAULL);
KUNIT_EXPECT_EQ(test, size, 2ULL);
amdgpu_dm_plane_add_modifier_dedup(&mods, &size, &cap, 0xBBULL);
KUNIT_EXPECT_EQ(test, size, 2ULL);
amdgpu_dm_plane_add_modifier_dedup(&mods, &size, &cap, 0xCCULL);
KUNIT_ASSERT_EQ(test, size, 3ULL);
KUNIT_EXPECT_EQ(test, mods[2], 0xCCULL);
kfree(mods);
size = 3;
cap = 7;
mods = NULL;
amdgpu_dm_plane_add_modifier_dedup(&mods, &size, &cap, 0x55ULL);
KUNIT_EXPECT_PTR_EQ(test, mods, NULL);
KUNIT_EXPECT_EQ(test, size, 3ULL);
KUNIT_EXPECT_EQ(test, cap, 7ULL);
}
static int dm_test_gfx6_tiling(struct dc_tiling_info *tiling_info, u64 modifier)
{
return amdgpu_dm_plane_fill_gfx6_tiling_info_from_modifier(tiling_info, modifier);
}
static void dm_test_fill_gfx6_tiling_info_from_modifier(struct kunit *test)
{
struct dc_tiling_info tiling_info = {0};
u64 not_amd_mod = DRM_FORMAT_MOD_VENDOR_AMD;
u64 gfx9_mod = AMD_FMT_MOD | AMD_FMT_MOD_SET(TILE_VERSION, AMD_FMT_MOD_TILE_VER_GFX9);
u64 mod_1d = AMD_FMT_MOD |
AMD_FMT_MOD_SET(TILE_VERSION, AMD_FMT_MOD_TILE_VER_GFX6) |
AMD_FMT_MOD_SET(TILE, AMD_FMT_MOD_TILE_GFX6_1D_TILED_THIN1) |
AMD_FMT_MOD_SET(MICROTILE, AMD_FMT_MOD_MICROTILE_DISPLAY) |
AMD_FMT_MOD_SET(NUM_BANKS, 3);
u64 mod_2d = AMD_FMT_MOD |
AMD_FMT_MOD_SET(TILE_VERSION, AMD_FMT_MOD_TILE_VER_GFX6) |
AMD_FMT_MOD_SET(TILE, AMD_FMT_MOD_TILE_GFX6_2D_TILED_THIN1) |
AMD_FMT_MOD_SET(MICROTILE, AMD_FMT_MOD_MICROTILE_DISPLAY) |
AMD_FMT_MOD_SET(PIPE_CONFIG, 5) |
AMD_FMT_MOD_SET(TILE_SPLIT, 4) |
AMD_FMT_MOD_SET(BANK_WIDTH, 1) |
AMD_FMT_MOD_SET(BANK_HEIGHT, 2) |
AMD_FMT_MOD_SET(MACRO_TILE_ASPECT, 3) |
AMD_FMT_MOD_SET(NUM_BANKS, 2);
KUNIT_EXPECT_EQ(test, dm_test_gfx6_tiling(&tiling_info, DRM_FORMAT_MOD_LINEAR), 0);
KUNIT_EXPECT_EQ(test, (int)tiling_info.gfx8.array_mode, (int)DC_ARRAY_LINEAR_GENERAL);
KUNIT_EXPECT_EQ(test, (int)tiling_info.gfxversion, (int)DcGfxVersion8);
KUNIT_EXPECT_EQ(test, dm_test_gfx6_tiling(&tiling_info, not_amd_mod), -EINVAL);
KUNIT_EXPECT_EQ(test, dm_test_gfx6_tiling(&tiling_info, gfx9_mod), -EINVAL);
memset(&tiling_info, 0, sizeof(tiling_info));
KUNIT_EXPECT_EQ(test, dm_test_gfx6_tiling(&tiling_info, mod_1d), 0);
KUNIT_EXPECT_EQ(test, (int)tiling_info.gfx8.array_mode,
(int)AMD_FMT_MOD_TILE_GFX6_1D_TILED_THIN1);
KUNIT_EXPECT_EQ(test, (int)tiling_info.gfxversion, (int)DcGfxVersion8);
KUNIT_EXPECT_EQ(test, tiling_info.gfx8.num_banks, 0U);
memset(&tiling_info, 0, sizeof(tiling_info));
KUNIT_EXPECT_EQ(test, dm_test_gfx6_tiling(&tiling_info, mod_2d), 0);
KUNIT_EXPECT_EQ(test, (int)tiling_info.gfx8.array_mode,
(int)AMD_FMT_MOD_TILE_GFX6_2D_TILED_THIN1);
KUNIT_EXPECT_EQ(test, (int)tiling_info.gfx8.tile_mode,
(int)AMD_FMT_MOD_MICROTILE_DISPLAY);
KUNIT_EXPECT_EQ(test, tiling_info.gfx8.pipe_config, 5U);
KUNIT_EXPECT_EQ(test, tiling_info.gfx8.tile_split, 4U);
KUNIT_EXPECT_EQ(test, tiling_info.gfx8.bank_width, 1U);
KUNIT_EXPECT_EQ(test, tiling_info.gfx8.bank_height, 2U);
KUNIT_EXPECT_EQ(test, tiling_info.gfx8.tile_aspect, 3U);
KUNIT_EXPECT_EQ(test, tiling_info.gfx8.num_banks, 2U);
}
static u64 dm_test_gfx6_mod(u32 tile, u32 pipe_config, u32 tile_split, u32 bank_width,
u32 bank_height, u32 aspect, u32 num_banks)
{
return AMD_FMT_MOD |
AMD_FMT_MOD_SET(TILE_VERSION, AMD_FMT_MOD_TILE_VER_GFX6) |
AMD_FMT_MOD_SET(TILE, tile) |
AMD_FMT_MOD_SET(MICROTILE, AMD_FMT_MOD_MICROTILE_DISPLAY) |
AMD_FMT_MOD_SET(PIPE_CONFIG, pipe_config) |
AMD_FMT_MOD_SET(TILE_SPLIT, tile_split) |
AMD_FMT_MOD_SET(BANK_WIDTH, bank_width) |
AMD_FMT_MOD_SET(BANK_HEIGHT, bank_height) |
AMD_FMT_MOD_SET(MACRO_TILE_ASPECT, aspect) |
AMD_FMT_MOD_SET(NUM_BANKS, num_banks);
}
static struct amdgpu_device *dm_test_alloc_gfx7_device(struct kunit *test)
{
struct amdgpu_device *adev;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, adev);
adev->family = AMDGPU_FAMILY_VI;
adev->gfx.config.mem_row_size_in_kb = 4;
adev->gfx.config.tile_mode_array[10] = (4u << 2) | (2u << 6);
adev->gfx.config.macrotile_mode_array[1] = 0xb9u;
adev->gfx.config.macrotile_mode_array[2] = 0xb9u;
adev->gfx.config.macrotile_mode_array[3] = 0x2au;
return adev;
}
static void dm_test_get_gfx6_tile_idx(struct kunit *test)
{
struct amdgpu_device *adev;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, adev);
adev->family = AMDGPU_FAMILY_VI;
KUNIT_EXPECT_EQ(test,
amdgpu_dm_plane_get_gfx6_tile_idx(adev, 32, DC_ARRAY_1D_TILED_THIN1),
9U);
KUNIT_EXPECT_EQ(test,
amdgpu_dm_plane_get_gfx6_tile_idx(adev, 32, DC_ARRAY_2D_TILED_THIN1),
10U);
adev->family = AMDGPU_FAMILY_SI;
KUNIT_EXPECT_EQ(test,
amdgpu_dm_plane_get_gfx6_tile_idx(adev, 8, DC_ARRAY_2D_TILED_THIN1),
10U);
KUNIT_EXPECT_EQ(test,
amdgpu_dm_plane_get_gfx6_tile_idx(adev, 16, DC_ARRAY_2D_TILED_THIN1),
11U);
KUNIT_EXPECT_EQ(test,
amdgpu_dm_plane_get_gfx6_tile_idx(adev, 32, DC_ARRAY_2D_TILED_THIN1),
12U);
}
static void dm_test_calc_gfx7_tile_split(struct kunit *test)
{
struct amdgpu_device *adev;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, adev);
adev->gfx.config.mem_row_size_in_kb = 4;
KUNIT_EXPECT_EQ(test, amdgpu_dm_plane_calc_gfx7_tile_split(adev, 8, 0u << 25), 256U);
KUNIT_EXPECT_EQ(test, amdgpu_dm_plane_calc_gfx7_tile_split(adev, 32, 1u << 25), 512U);
adev->gfx.config.mem_row_size_in_kb = 1;
KUNIT_EXPECT_EQ(test, amdgpu_dm_plane_calc_gfx7_tile_split(adev, 64, 3u << 25), 1024U);
}
static void dm_test_get_gfx7_macro_tile_idx(struct kunit *test)
{
KUNIT_EXPECT_EQ(test, amdgpu_dm_plane_get_gfx7_macro_tile_idx(8, 1024), 0U);
KUNIT_EXPECT_EQ(test, amdgpu_dm_plane_get_gfx7_macro_tile_idx(32, 1024), 2U);
KUNIT_EXPECT_EQ(test, amdgpu_dm_plane_get_gfx7_macro_tile_idx(64, 256), 2U);
}
static void dm_test_calc_gfx6_mod(struct kunit *test)
{
struct amdgpu_device *adev = dm_test_alloc_gfx7_device(test);
struct amdgpu_device *si_adev;
u64 expected_1d = AMD_FMT_MOD |
AMD_FMT_MOD_SET(TILE_VERSION, AMD_FMT_MOD_TILE_VER_GFX6) |
AMD_FMT_MOD_SET(TILE, AMD_FMT_MOD_TILE_GFX6_1D_TILED_THIN1) |
AMD_FMT_MOD_SET(MICROTILE, AMD_FMT_MOD_MICROTILE_DISPLAY);
KUNIT_EXPECT_EQ(test,
amdgpu_dm_plane_calc_gfx6_mod(adev, 0, DC_ARRAY_1D_TILED_THIN1),
expected_1d);
KUNIT_EXPECT_EQ(test,
amdgpu_dm_plane_calc_gfx6_mod(adev, 32, DC_ARRAY_2D_TILED_THIN1),
dm_test_gfx6_mod(AMD_FMT_MOD_TILE_GFX6_2D_TILED_THIN1, 2, 2, 1, 2, 3, 2));
KUNIT_EXPECT_EQ(test,
amdgpu_dm_plane_calc_gfx6_mod(adev, 64, DC_ARRAY_2D_TILED_THIN1),
dm_test_gfx6_mod(AMD_FMT_MOD_TILE_GFX6_2D_TILED_THIN1, 2, 3, 2, 2, 2, 0));
si_adev = kunit_kzalloc(test, sizeof(*si_adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, si_adev);
si_adev->family = AMDGPU_FAMILY_SI;
si_adev->gfx.config.tile_mode_array[12] = (4u << 2) | (3u << 6) | (2u << 11) |
(1u << 14) | (2u << 16) | (3u << 18) |
(1u << 20);
KUNIT_EXPECT_EQ(test,
amdgpu_dm_plane_calc_gfx6_mod(si_adev, 32, DC_ARRAY_2D_TILED_THIN1),
dm_test_gfx6_mod(AMD_FMT_MOD_TILE_GFX6_2D_TILED_THIN1, 3, 2, 1, 2, 3, 1));
}
static void dm_test_gfx6_format_mod_supported(struct kunit *test)
{
struct amdgpu_device *adev = dm_test_alloc_gfx7_device(test);
u64 modifier = amdgpu_dm_plane_calc_gfx6_mod(adev, 32, DC_ARRAY_2D_TILED_THIN1);
u64 gfx9_mod = AMD_FMT_MOD | AMD_FMT_MOD_SET(TILE_VERSION, AMD_FMT_MOD_TILE_VER_GFX9);
u64 bad_tile_mod = AMD_FMT_MOD | AMD_FMT_MOD_SET(TILE, 3);
u64 bad_micro_mod = AMD_FMT_MOD |
AMD_FMT_MOD_SET(TILE, AMD_FMT_MOD_TILE_GFX6_2D_TILED_THIN1) |
AMD_FMT_MOD_SET(MICROTILE, AMD_FMT_MOD_MICROTILE_THIN);
u64 not_amd_mod = DRM_FORMAT_MOD_VENDOR_AMD;
u64 dcc_mod = modifier | AMD_FMT_MOD_SET(DCC, 1);
KUNIT_EXPECT_TRUE(test, amdgpu_dm_plane_gfx6_format_mod_supported(adev, 32, modifier));
KUNIT_EXPECT_FALSE(test, amdgpu_dm_plane_gfx6_format_mod_supported(adev, 64, modifier));
KUNIT_EXPECT_FALSE(test, amdgpu_dm_plane_gfx6_format_mod_supported(adev, 32, not_amd_mod));
KUNIT_EXPECT_FALSE(test, amdgpu_dm_plane_gfx6_format_mod_supported(adev, 32, gfx9_mod));
KUNIT_EXPECT_FALSE(test, amdgpu_dm_plane_gfx6_format_mod_supported(adev, 32, dcc_mod));
KUNIT_EXPECT_FALSE(test, amdgpu_dm_plane_gfx6_format_mod_supported(adev, 32, bad_tile_mod));
KUNIT_EXPECT_FALSE(test, amdgpu_dm_plane_gfx6_format_mod_supported(adev, 32, bad_micro_mod));
adev->family = AMDGPU_FAMILY_AI;
KUNIT_EXPECT_FALSE(test, amdgpu_dm_plane_gfx6_format_mod_supported(adev, 32, modifier));
}
static void dm_test_get_plane_modifiers_gfx6(struct kunit *test)
{
struct amdgpu_device *adev = dm_test_alloc_gfx7_device(test);
u64 *mods = dm_test_get_primary_mods(test, adev);
u64 mod_1d = AMD_FMT_MOD |
AMD_FMT_MOD_SET(TILE_VERSION, AMD_FMT_MOD_TILE_VER_GFX6) |
AMD_FMT_MOD_SET(TILE, AMD_FMT_MOD_TILE_GFX6_1D_TILED_THIN1) |
AMD_FMT_MOD_SET(MICROTILE, AMD_FMT_MOD_MICROTILE_DISPLAY);
KUNIT_EXPECT_EQ(test, dm_test_mods_count(mods), 4);
KUNIT_EXPECT_EQ(test, mods[0],
dm_test_gfx6_mod(AMD_FMT_MOD_TILE_GFX6_2D_TILED_THIN1, 2, 2, 1, 2, 3, 2));
KUNIT_EXPECT_EQ(test, mods[1],
dm_test_gfx6_mod(AMD_FMT_MOD_TILE_GFX6_2D_TILED_THIN1, 2, 3, 2, 2, 2, 0));
KUNIT_EXPECT_EQ(test, mods[2], mod_1d);
KUNIT_EXPECT_EQ(test, mods[3], DRM_FORMAT_MOD_LINEAR);
kfree(mods);
}
static void dm_test_format_mod_supported_gfx6(struct kunit *test)
{
struct amdgpu_device *adev = dm_test_alloc_gfx7_device(test);
struct drm_plane *plane;
u64 listed_mod = amdgpu_dm_plane_calc_gfx6_mod(adev, 32, DC_ARRAY_2D_TILED_THIN1);
plane = kunit_kzalloc(test, sizeof(*plane), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, plane);
plane->dev = &adev->ddev;
plane->modifiers = &listed_mod;
plane->modifier_count = 1;
KUNIT_EXPECT_TRUE(test,
amdgpu_dm_plane_format_mod_supported(plane, DRM_FORMAT_XRGB8888,
listed_mod));
KUNIT_EXPECT_FALSE(test,
amdgpu_dm_plane_format_mod_supported(plane, DRM_FORMAT_XRGB16161616,
listed_mod));
}
static void dm_test_helper_prepare_fb_no_fb(struct kunit *test)
{
struct drm_plane_state state = {0};
struct drm_plane *plane;
plane = kunit_kzalloc(test, sizeof(*plane), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, plane);
KUNIT_EXPECT_EQ(test, amdgpu_dm_plane_helper_prepare_fb(plane, &state), 0);
}
static void dm_test_helper_cleanup_fb_no_fb(struct kunit *test)
{
struct drm_plane_state state = {0};
struct drm_plane *plane;
plane = kunit_kzalloc(test, sizeof(*plane), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, plane);
amdgpu_dm_plane_helper_cleanup_fb(plane, &state);
}
static void dm_test_handle_cursor_update_no_fb(struct kunit *test)
{
struct amdgpu_device *adev;
struct drm_plane_state old_state = {0};
struct drm_plane_state state = {0};
struct drm_plane *plane;
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);
plane->dev = &adev->ddev;
plane->state = &state;
amdgpu_dm_plane_handle_cursor_update(plane, &old_state);
}
static void dm_test_atomic_async_update_copies_state(struct kunit *test)
{
struct amdgpu_device *adev;
struct drm_atomic_commit *state;
struct __drm_planes_state *planes;
struct drm_plane_state *cur_state;
struct drm_plane_state *new_state;
struct drm_plane_state *old_state;
struct amdgpu_framebuffer *afb;
struct drm_plane *plane;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
state = kunit_kzalloc(test, sizeof(*state), GFP_KERNEL);
planes = kunit_kzalloc(test, sizeof(*planes), GFP_KERNEL);
plane = kunit_kzalloc(test, sizeof(*plane), GFP_KERNEL);
cur_state = kunit_kzalloc(test, sizeof(*cur_state), GFP_KERNEL);
new_state = kunit_kzalloc(test, sizeof(*new_state), GFP_KERNEL);
old_state = kunit_kzalloc(test, sizeof(*old_state), GFP_KERNEL);
afb = kunit_kzalloc(test, sizeof(*afb), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, state);
KUNIT_ASSERT_NOT_NULL(test, planes);
KUNIT_ASSERT_NOT_NULL(test, plane);
KUNIT_ASSERT_NOT_NULL(test, cur_state);
KUNIT_ASSERT_NOT_NULL(test, new_state);
KUNIT_ASSERT_NOT_NULL(test, old_state);
KUNIT_ASSERT_NOT_NULL(test, afb);
plane->dev = &adev->ddev;
plane->index = 0;
plane->state = cur_state;
cur_state->fb = &afb->base;
new_state->src_x = 1 << 16;
new_state->src_y = 2 << 16;
new_state->src_w = 64 << 16;
new_state->src_h = 64 << 16;
new_state->crtc_x = 10;
new_state->crtc_y = 20;
new_state->crtc_w = 64;
new_state->crtc_h = 64;
state->planes = planes;
state->planes[0].new_state = new_state;
state->planes[0].old_state = old_state;
amdgpu_dm_plane_atomic_async_update(plane, state);
KUNIT_EXPECT_PTR_EQ(test, cur_state->fb, NULL);
KUNIT_EXPECT_PTR_EQ(test, new_state->fb, &afb->base);
KUNIT_EXPECT_EQ(test, cur_state->src_x, 1U << 16);
KUNIT_EXPECT_EQ(test, cur_state->src_h, 64U << 16);
KUNIT_EXPECT_EQ(test, cur_state->crtc_x, 10);
KUNIT_EXPECT_EQ(test, cur_state->crtc_h, 64U);
}
static void dm_test_fill_plane_buffer_attributes_gfx6(struct kunit *test)
{
struct dc_tiling_info tiling_info = {0};
struct dc_plane_dcc_param dcc = {0};
struct dc_plane_address address = {0};
struct plane_size plane_size = {0};
struct amdgpu_framebuffer *afb;
struct amdgpu_device *adev;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
afb = kunit_kzalloc(test, sizeof(*afb), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, afb);
adev->family = AMDGPU_FAMILY_CZ;
afb->address = 0x80000000ULL;
afb->base.width = 1920;
afb->base.height = 1080;
afb->base.pitches[0] = 7680;
afb->base.format = drm_format_info(DRM_FORMAT_XRGB8888);
KUNIT_ASSERT_NOT_NULL(test, afb->base.format);
afb->base.modifier = AMD_FMT_MOD |
AMD_FMT_MOD_SET(TILE_VERSION, AMD_FMT_MOD_TILE_VER_GFX6) |
AMD_FMT_MOD_SET(TILE, AMD_FMT_MOD_TILE_GFX6_1D_TILED_THIN1) |
AMD_FMT_MOD_SET(MICROTILE, AMD_FMT_MOD_MICROTILE_DISPLAY);
KUNIT_EXPECT_EQ(test, dm_test_graphics_attrs(adev, afb, &tiling_info,
&plane_size, &dcc, &address), 0);
KUNIT_EXPECT_EQ(test, address.type, (int)PLN_ADDR_TYPE_GRAPHICS);
KUNIT_EXPECT_EQ(test, (int)tiling_info.gfxversion, (int)DcGfxVersion8);
afb->base.modifier = AMD_FMT_MOD |
AMD_FMT_MOD_SET(TILE_VERSION, AMD_FMT_MOD_TILE_VER_GFX9);
KUNIT_EXPECT_EQ(test, dm_test_graphics_attrs(adev, afb, &tiling_info,
&plane_size, &dcc, &address), -EINVAL);
}
static void dm_test_atomic_check_success(struct kunit *test)
{
struct dm_plane_state *dm_plane_state;
struct drm_crtc_state *new_crtc_state;
struct drm_atomic_commit *state;
struct resource_pool *res_pool;
struct amdgpu_device *adev;
struct drm_framebuffer *fb;
struct drm_plane *plane;
adev = dm_test_init_atomic_check_state(test, &state, &plane, &dm_plane_state,
&new_crtc_state, &fb);
res_pool = kunit_kzalloc(test, sizeof(*res_pool), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, res_pool);
res_pool->funcs = kunit_kzalloc(test, sizeof(*res_pool->funcs), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, res_pool->funcs);
adev->dm.dc->res_pool = res_pool;
dm_plane_state->dc_state->src_rect.width = 100;
dm_plane_state->dc_state->src_rect.height = 100;
dm_plane_state->dc_state->dst_rect.width = 100;
dm_plane_state->dc_state->dst_rect.height = 100;
KUNIT_EXPECT_EQ(test, amdgpu_dm_plane_atomic_check(plane, state), 0);
}
struct dm_test_cursor_ctx {
struct amdgpu_device *adev;
struct amdgpu_crtc *acrtc;
struct dm_crtc_state *crtc_state;
struct drm_plane_state *state;
struct drm_plane_state old_state;
struct drm_plane *plane;
};
static struct dm_test_cursor_ctx *dm_test_alloc_cursor_ctx(struct kunit *test)
{
struct amdgpu_framebuffer *afb;
struct dm_test_cursor_ctx *ctx;
ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
afb = kunit_kzalloc(test, sizeof(*afb), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, ctx);
KUNIT_ASSERT_NOT_NULL(test, afb);
ctx->adev = dm_kunit_alloc_adev(test);
ctx->acrtc = kunit_kzalloc(test, sizeof(*ctx->acrtc), GFP_KERNEL);
ctx->crtc_state = kunit_kzalloc(test, sizeof(*ctx->crtc_state), GFP_KERNEL);
ctx->state = kunit_kzalloc(test, sizeof(*ctx->state), GFP_KERNEL);
ctx->plane = kunit_kzalloc(test, sizeof(*ctx->plane), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, ctx->acrtc);
KUNIT_ASSERT_NOT_NULL(test, ctx->crtc_state);
KUNIT_ASSERT_NOT_NULL(test, ctx->state);
KUNIT_ASSERT_NOT_NULL(test, ctx->plane);
ctx->adev->dm.dc = dm_kunit_alloc_dc_with_ctx(test);
ctx->acrtc->base.dev = &ctx->adev->ddev;
ctx->acrtc->base.state = &ctx->crtc_state->base;
ctx->acrtc->max_cursor_width = 64;
ctx->acrtc->max_cursor_height = 64;
afb->address = 0x80000000ULL;
afb->base.pitches[0] = 256;
afb->base.format = drm_format_info(DRM_FORMAT_ARGB8888);
KUNIT_ASSERT_NOT_NULL(test, afb->base.format);
ctx->state->fb = &afb->base;
ctx->state->crtc = &ctx->acrtc->base;
ctx->state->crtc_w = 64;
ctx->state->crtc_h = 64;
ctx->plane->dev = &ctx->adev->ddev;
ctx->plane->state = ctx->state;
return ctx;
}
static void dm_test_handle_cursor_update_disabled(struct kunit *test)
{
struct dm_test_cursor_ctx *ctx = dm_test_alloc_cursor_ctx(test);
ctx->state->crtc_x = -64;
amdgpu_dm_plane_handle_cursor_update(ctx->plane, &ctx->old_state);
KUNIT_EXPECT_EQ(test, ctx->acrtc->cursor_width, 0);
KUNIT_EXPECT_EQ(test, ctx->acrtc->cursor_height, 0);
}
static void dm_test_handle_cursor_update_no_stream(struct kunit *test)
{
struct dm_test_cursor_ctx *ctx = dm_test_alloc_cursor_ctx(test);
ctx->crtc_state->cm_is_degamma_srgb = true;
ctx->adev->dm.dc->caps.color.dpp.gamma_corr = true;
amdgpu_dm_plane_handle_cursor_update(ctx->plane, &ctx->old_state);
KUNIT_EXPECT_EQ(test, ctx->acrtc->cursor_width, 64);
KUNIT_EXPECT_EQ(test, ctx->acrtc->cursor_height, 64);
}
static int dm_test_clear_dcc_tiling_count;
static void dm_test_clear_surface_dcc_and_tiling(struct pipe_ctx *pipe_ctx,
struct dc_plane_state *plane_state,
bool clear_tiling)
{
if (clear_tiling)
dm_test_clear_dcc_tiling_count++;
}
static void dm_test_panic_flush_disables_dcc(struct kunit *test)
{
struct dc_plane_state *dc_plane_state;
struct dm_plane_state *dm_plane_state;
struct resource_pool *res_pool;
struct drm_framebuffer *fb;
struct drm_plane *plane;
struct dc *dc;
plane = kunit_kzalloc(test, sizeof(*plane), GFP_KERNEL);
dm_plane_state = kunit_kzalloc(test, sizeof(*dm_plane_state), GFP_KERNEL);
dc_plane_state = kunit_kzalloc(test, sizeof(*dc_plane_state), GFP_KERNEL);
fb = kunit_kzalloc(test, sizeof(*fb), GFP_KERNEL);
res_pool = kunit_kzalloc(test, sizeof(*res_pool), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, plane);
KUNIT_ASSERT_NOT_NULL(test, dm_plane_state);
KUNIT_ASSERT_NOT_NULL(test, dc_plane_state);
KUNIT_ASSERT_NOT_NULL(test, fb);
KUNIT_ASSERT_NOT_NULL(test, res_pool);
dc = dm_kunit_alloc_dc_with_ctx(test);
dc->current_state = dm_kunit_alloc_dc_state(test);
dc->hwss.clear_surface_dcc_and_tiling = dm_test_clear_surface_dcc_and_tiling;
res_pool->pipe_count = 1;
dc->res_pool = res_pool;
dc_plane_state->ctx = dc->ctx;
fb->modifier = AMD_FMT_MOD;
dm_plane_state->base.fb = fb;
dm_plane_state->dc_state = dc_plane_state;
plane->state = &dm_plane_state->base;
dm_test_clear_dcc_tiling_count = 0;
amdgpu_dm_plane_panic_flush(plane);
KUNIT_EXPECT_EQ(test, dm_test_clear_dcc_tiling_count, 1);
}
static struct drm_plane *dm_test_alloc_init_plane(struct kunit *test,
struct amdgpu_device **adev_out)
{
struct amdgpu_device *adev;
struct drm_plane *plane;
adev = dm_kunit_alloc_adev(test);
adev->family = AMDGPU_FAMILY_NV;
adev->dm.adev = adev;
adev->dm.dc = dm_kunit_alloc_dc_with_ctx(test);
plane = kzalloc_obj(*plane);
KUNIT_ASSERT_NOT_NULL(test, plane);
plane->type = DRM_PLANE_TYPE_OVERLAY;
*adev_out = adev;
return plane;
}
static void dm_test_plane_init_creates_optional_properties(struct kunit *test)
{
struct amdgpu_device *adev;
struct drm_plane *plane;
plane = dm_test_alloc_init_plane(test, &adev);
adev->asic_type = CHIP_BONAIRE;
adev->ip_versions[DCE_HWIP][0] = IP_VERSION(3, 1, 0);
KUNIT_ASSERT_EQ(test, amdgpu_dm_plane_init(&adev->dm, plane, 1, NULL), 0);
KUNIT_EXPECT_NOT_NULL(test, plane->rotation_property);
KUNIT_EXPECT_NOT_NULL(test, adev->ddev.mode_config.prop_fb_damage_clips);
}
static void dm_test_plane_init_creates_color_pipeline(struct kunit *test)
{
struct amdgpu_device *adev;
struct drm_plane *plane;
plane = dm_test_alloc_init_plane(test, &adev);
adev->dm.dc->ctx->dce_version = DCN_VERSION_3_0;
KUNIT_ASSERT_EQ(test, amdgpu_dm_plane_init(&adev->dm, plane, 1, NULL), 0);
KUNIT_EXPECT_NOT_NULL(test, plane->color_pipeline_property);
}
static struct kunit_case amdgpu_dm_plane_test_cases[] = {
KUNIT_CASE(dm_test_plane_is_video_format_known_video),
KUNIT_CASE(dm_test_get_format_info),
KUNIT_CASE(dm_test_fill_blending_pixel_blend_modes),
KUNIT_CASE(dm_test_fill_blending_global_alpha),
KUNIT_CASE(dm_test_modifier_has_dcc),
KUNIT_CASE(dm_test_modifier_gfx9_swizzle_mode),
KUNIT_CASE(dm_test_get_plane_formats),
KUNIT_CASE(dm_test_get_plane_modifiers),
KUNIT_CASE(dm_test_get_plane_modifiers_gfx6),
KUNIT_CASE(dm_test_get_plane_modifiers_gfx9),
KUNIT_CASE(dm_test_get_plane_modifiers_rv),
KUNIT_CASE(dm_test_get_plane_modifiers_gfx10_and_gfx12),
KUNIT_CASE(dm_test_get_plane_modifiers_gfx11_64k_first),
KUNIT_CASE(dm_test_get_plane_modifiers_gfx11_256k_first),
KUNIT_CASE(dm_test_fill_dc_scaling_info),
KUNIT_CASE(dm_test_fill_dc_scaling_info_nv12_dcn1x),
KUNIT_CASE(dm_test_fill_dc_scaling_info_plane_caps),
KUNIT_CASE(dm_test_get_min_max_dc_plane_scaling),
KUNIT_CASE(dm_test_fill_plane_buffer_attributes_video),
KUNIT_CASE(dm_test_fill_plane_buffer_attributes_gfx12),
KUNIT_CASE(dm_test_fill_plane_buffer_attributes_gfx6),
KUNIT_CASE(dm_test_get_cursor_position),
KUNIT_CASE(dm_test_format_mod_supported),
KUNIT_CASE(dm_test_format_mod_supported_d_swizzle_reject),
KUNIT_CASE(dm_test_format_mod_supported_gfx6),
KUNIT_CASE(dm_test_fill_gfx12_plane_attributes_dcc_blocks),
KUNIT_CASE(dm_test_fill_gfx12_plane_attributes_validate_fails),
KUNIT_CASE(dm_test_fill_gfx9_plane_attributes_from_modifiers),
KUNIT_CASE(dm_test_fill_gfx9_plane_attributes_dcc),
KUNIT_CASE(dm_test_fill_gfx9_plane_attributes_validate_fails),
KUNIT_CASE(dm_test_fill_gfx9_plane_attributes_dcc_ind_blk),
KUNIT_CASE(dm_test_helper_check_state_viewport_rejects),
KUNIT_CASE(dm_test_helper_check_state_scaling_caps),
KUNIT_CASE(dm_test_helper_prepare_fb_no_fb),
KUNIT_CASE(dm_test_helper_cleanup_fb_no_fb),
KUNIT_CASE(dm_test_handle_cursor_update_no_fb),
KUNIT_CASE(dm_test_handle_cursor_update_disabled),
KUNIT_CASE(dm_test_handle_cursor_update_no_stream),
KUNIT_CASE(dm_test_atomic_async_update_copies_state),
KUNIT_CASE(dm_test_atomic_async_check_rejects),
KUNIT_CASE(dm_test_atomic_async_check_overlay_cursor),
KUNIT_CASE(dm_test_atomic_check_no_dc_state),
KUNIT_CASE(dm_test_atomic_check_missing_crtc_state),
KUNIT_CASE(dm_test_atomic_check_rejects),
KUNIT_CASE(dm_test_atomic_check_success),
KUNIT_CASE(dm_test_panic_flush_no_dc_state),
KUNIT_CASE(dm_test_panic_flush_disables_dcc),
KUNIT_CASE(dm_test_plane_create_state_initializes_state),
KUNIT_CASE(dm_test_plane_duplicate_state_copies_fields),
KUNIT_CASE(dm_test_plane_duplicate_state_copies_resources),
KUNIT_CASE(dm_test_plane_destroy_state_minimal),
KUNIT_CASE(dm_test_plane_destroy_state_releases_resources),
KUNIT_CASE(dm_test_add_modifier_appends_and_grows),
KUNIT_CASE(dm_test_add_modifier_failure_paths),
KUNIT_CASE(dm_test_add_modifier_dedup),
KUNIT_CASE(dm_test_fill_gfx6_tiling_info_from_modifier),
KUNIT_CASE(dm_test_get_gfx6_tile_idx),
KUNIT_CASE(dm_test_calc_gfx7_tile_split),
KUNIT_CASE(dm_test_get_gfx7_macro_tile_idx),
KUNIT_CASE(dm_test_calc_gfx6_mod),
KUNIT_CASE(dm_test_gfx6_format_mod_supported),
KUNIT_CASE(dm_test_fill_gfx9_tiling_info_from_device),
KUNIT_CASE(dm_test_fill_gfx9_tiling_info_from_modifier),
KUNIT_CASE(dm_test_validate_dcc_early_exits),
KUNIT_CASE(dm_test_validate_dcc_rejects_from_cap),
KUNIT_CASE(dm_test_validate_dcc_success_and_scan_mapping),
KUNIT_CASE(dm_test_plane_init_creates_optional_properties),
KUNIT_CASE(dm_test_plane_init_creates_color_pipeline),
{}
};
static struct kunit_suite amdgpu_dm_plane_test_suite = {
.name = "amdgpu_dm_plane",
.test_cases = amdgpu_dm_plane_test_cases,
};
kunit_test_suite(amdgpu_dm_plane_test_suite);
MODULE_DESCRIPTION("KUnit tests for amdgpu_dm_plane");
MODULE_LICENSE("Dual MIT/GPL"