#include <kunit/test.h>
#include <linux/device.h>
#include <drm/drm_atomic.h>
#include <drm/drm_atomic_helper.h>
#include <drm/drm_audio_component.h>
#include <drm/drm_connector.h>
#include <drm/drm_crtc.h>
#include <drm/drm_eld.h>
#include <drm/drm_kunit_helpers.h>
#include <drm/drm_probe_helper.h>
#include "dc.h"
#include "dc/inc/core_types.h"
#include "dc/inc/hw/audio.h"
#include "amdgpu.h"
#include "amdgpu_mode.h"
#include "amdgpu_dm.h"
#include "amdgpu_dm_audio.h"
#include "amdgpu_dm_kunit_test_helpers.h"
static const struct drm_connector_funcs dm_test_audio_connector_funcs = {
.reset = drm_atomic_helper_connector_reset,
.atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
.atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
.fill_modes = drm_helper_probe_single_connector_modes,
.destroy = drm_connector_cleanup,
};
static void dm_test_audio_connector_cleanup(void *data)
{
drm_connector_cleanup(data);
}
static struct drm_atomic_commit *dm_test_audio_alloc_atomic_state(struct kunit *test,
unsigned int num_connector,
unsigned int num_crtc)
{
struct drm_atomic_commit *state;
state = kunit_kzalloc(test, sizeof(*state), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, state);
state->num_connector = num_connector;
if (num_connector) {
state->connectors = kunit_kcalloc(test, num_connector,
sizeof(*state->connectors),
GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, state->connectors);
}
if (num_crtc) {
state->crtcs = kunit_kcalloc(test, num_crtc, sizeof(*state->crtcs),
GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, state->crtcs);
}
return state;
}
static void dm_test_audio_init_disabled(struct kunit *test)
{
struct amdgpu_device *adev;
int saved_audio = amdgpu_dm_audio_get_param();
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
amdgpu_dm_audio_set_param(0);
KUNIT_EXPECT_EQ(test, amdgpu_dm_audio_init(adev), 0);
KUNIT_EXPECT_FALSE(test, adev->mode_info.audio.enabled);
KUNIT_EXPECT_FALSE(test, adev->dm.audio_registered);
amdgpu_dm_audio_set_param(saved_audio);
}
static void dm_test_audio_init_enabled_success(struct kunit *test)
{
struct amdgpu_device *adev;
struct dc *dc;
struct resource_pool *res_pool;
struct audio *audio0;
struct audio *audio1;
struct device *dev;
int saved_audio = amdgpu_dm_audio_get_param();
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
dc = kunit_kzalloc(test, sizeof(*dc), GFP_KERNEL);
res_pool = kunit_kzalloc(test, sizeof(*res_pool), GFP_KERNEL);
audio0 = kunit_kzalloc(test, sizeof(*audio0), GFP_KERNEL);
audio1 = kunit_kzalloc(test, sizeof(*audio1), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dc);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, res_pool);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, audio0);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, audio1);
dev = root_device_register("kunit-dm-audio-init");
KUNIT_ASSERT_FALSE(test, IS_ERR(dev));
audio0->inst = 2;
audio1->inst = 6;
res_pool->audio_count = 2;
res_pool->audios[0] = audio0;
res_pool->audios[1] = audio1;
dc->res_pool = res_pool;
adev->dm.dc = dc;
adev->dev = dev;
amdgpu_dm_audio_set_param(1);
KUNIT_EXPECT_EQ(test, amdgpu_dm_audio_init(adev), 0);
KUNIT_EXPECT_TRUE(test, adev->mode_info.audio.enabled);
KUNIT_EXPECT_TRUE(test, adev->dm.audio_registered);
KUNIT_EXPECT_EQ(test, adev->mode_info.audio.num_pins, 2);
KUNIT_EXPECT_EQ(test, adev->mode_info.audio.pin[0].id, 2U);
KUNIT_EXPECT_EQ(test, adev->mode_info.audio.pin[1].id, 6U);
amdgpu_dm_audio_fini(adev);
root_device_unregister(dev);
amdgpu_dm_audio_set_param(saved_audio);
}
static void dm_test_audio_fini_without_enabled_audio(struct kunit *test)
{
struct amdgpu_device *adev;
int saved_audio = amdgpu_dm_audio_get_param();
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
amdgpu_dm_audio_set_param(1);
adev->mode_info.audio.enabled = false;
adev->dm.audio_registered = true;
amdgpu_dm_audio_fini(adev);
KUNIT_EXPECT_FALSE(test, adev->mode_info.audio.enabled);
KUNIT_EXPECT_TRUE(test, adev->dm.audio_registered);
amdgpu_dm_audio_set_param(saved_audio);
}
static void dm_test_fill_audio_info_ids_name_flags(struct kunit *test)
{
struct audio_info *audio_info;
struct drm_connector *connector;
struct dc_sink *dc_sink;
const char *name = "DM-AUDIO-PANEL";
audio_info = kunit_kzalloc(test, sizeof(*audio_info), GFP_KERNEL);
connector = kunit_kzalloc(test, sizeof(*connector), GFP_KERNEL);
dc_sink = kunit_kzalloc(test, sizeof(*dc_sink), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, audio_info);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, connector);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dc_sink);
dc_sink->edid_caps.manufacturer_id = 0x1234;
dc_sink->edid_caps.product_id = 0xABCD;
dc_sink->edid_caps.speaker_flags = 0x5;
strscpy(dc_sink->edid_caps.display_name, name,
AUDIO_INFO_DISPLAY_NAME_SIZE_IN_CHARS);
connector->display_info.cea_rev = 1;
amdgpu_dm_fill_audio_info(audio_info, connector, dc_sink);
KUNIT_EXPECT_EQ(test, audio_info->manufacture_id, 0x1234U);
KUNIT_EXPECT_EQ(test, audio_info->product_id, 0xABCDU);
KUNIT_EXPECT_EQ(test, audio_info->flags.all, 0x5U);
KUNIT_EXPECT_STREQ(test, audio_info->display_name, name);
}
static void dm_test_fill_audio_info_cea_lt_3_skips_modes(struct kunit *test)
{
struct audio_info *audio_info;
struct drm_connector *connector;
struct dc_sink *dc_sink;
audio_info = kunit_kzalloc(test, sizeof(*audio_info), GFP_KERNEL);
connector = kunit_kzalloc(test, sizeof(*connector), GFP_KERNEL);
dc_sink = kunit_kzalloc(test, sizeof(*dc_sink), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, audio_info);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, connector);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dc_sink);
connector->display_info.cea_rev = 2;
dc_sink->edid_caps.audio_mode_count = 2;
dc_sink->edid_caps.audio_modes[0].format_code = 1;
dc_sink->edid_caps.audio_modes[0].channel_count = 2;
dc_sink->edid_caps.audio_modes[0].sample_rate = 0x07;
dc_sink->edid_caps.audio_modes[0].sample_size = 16;
amdgpu_dm_fill_audio_info(audio_info, connector, dc_sink);
KUNIT_EXPECT_EQ(test, audio_info->mode_count, 0U);
}
static void dm_test_fill_audio_info_cea_ge_3_copies_modes(struct kunit *test)
{
struct audio_info *audio_info;
struct drm_connector *connector;
struct dc_sink *dc_sink;
audio_info = kunit_kzalloc(test, sizeof(*audio_info), GFP_KERNEL);
connector = kunit_kzalloc(test, sizeof(*connector), GFP_KERNEL);
dc_sink = kunit_kzalloc(test, sizeof(*dc_sink), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, audio_info);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, connector);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dc_sink);
connector->display_info.cea_rev = 3;
dc_sink->edid_caps.audio_mode_count = 2;
dc_sink->edid_caps.audio_modes[0].format_code = 1;
dc_sink->edid_caps.audio_modes[0].channel_count = 2;
dc_sink->edid_caps.audio_modes[0].sample_rate = 0x07;
dc_sink->edid_caps.audio_modes[0].sample_size = 16;
dc_sink->edid_caps.audio_modes[1].format_code = 11;
dc_sink->edid_caps.audio_modes[1].channel_count = 6;
dc_sink->edid_caps.audio_modes[1].sample_rate = 0x1F;
dc_sink->edid_caps.audio_modes[1].sample_size = 24;
amdgpu_dm_fill_audio_info(audio_info, connector, dc_sink);
KUNIT_EXPECT_EQ(test, audio_info->mode_count, 2U);
KUNIT_EXPECT_EQ(test, (int)audio_info->modes[0].format_code, 1);
KUNIT_EXPECT_EQ(test, audio_info->modes[0].channel_count, 2);
KUNIT_EXPECT_EQ(test, audio_info->modes[0].sample_rates.all, 0x07U);
KUNIT_EXPECT_EQ(test, audio_info->modes[0].sample_size, 16);
KUNIT_EXPECT_EQ(test, (int)audio_info->modes[1].format_code, 11);
KUNIT_EXPECT_EQ(test, audio_info->modes[1].channel_count, 6);
KUNIT_EXPECT_EQ(test, audio_info->modes[1].sample_rates.all, 0x1FU);
KUNIT_EXPECT_EQ(test, audio_info->modes[1].sample_size, 24);
}
static void dm_test_fill_audio_info_latency_present(struct kunit *test)
{
struct audio_info *audio_info;
struct drm_connector *connector;
struct dc_sink *dc_sink;
audio_info = kunit_kzalloc(test, sizeof(*audio_info), GFP_KERNEL);
connector = kunit_kzalloc(test, sizeof(*connector), GFP_KERNEL);
dc_sink = kunit_kzalloc(test, sizeof(*dc_sink), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, audio_info);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, connector);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dc_sink);
connector->display_info.cea_rev = 3;
connector->latency_present[0] = true;
connector->video_latency[0] = 11;
connector->audio_latency[0] = 22;
amdgpu_dm_fill_audio_info(audio_info, connector, dc_sink);
KUNIT_EXPECT_EQ(test, audio_info->video_latency, 11U);
KUNIT_EXPECT_EQ(test, audio_info->audio_latency, 22U);
}
static void dm_test_fill_audio_info_latency_absent_keeps_zero(struct kunit *test)
{
struct audio_info *audio_info;
struct drm_connector *connector;
struct dc_sink *dc_sink;
audio_info = kunit_kzalloc(test, sizeof(*audio_info), GFP_KERNEL);
connector = kunit_kzalloc(test, sizeof(*connector), GFP_KERNEL);
dc_sink = kunit_kzalloc(test, sizeof(*dc_sink), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, audio_info);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, connector);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dc_sink);
connector->display_info.cea_rev = 3;
connector->latency_present[0] = false;
connector->video_latency[0] = 99;
connector->audio_latency[0] = 88;
amdgpu_dm_fill_audio_info(audio_info, connector, dc_sink);
KUNIT_EXPECT_EQ(test, audio_info->video_latency, 0U);
KUNIT_EXPECT_EQ(test, audio_info->audio_latency, 0U);
}
static void dm_test_fill_audio_info_cea_ge_3_zero_modes(struct kunit *test)
{
struct audio_info *audio_info;
struct drm_connector *connector;
struct dc_sink *dc_sink;
audio_info = kunit_kzalloc(test, sizeof(*audio_info), GFP_KERNEL);
connector = kunit_kzalloc(test, sizeof(*connector), GFP_KERNEL);
dc_sink = kunit_kzalloc(test, sizeof(*dc_sink), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, audio_info);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, connector);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dc_sink);
connector->display_info.cea_rev = 3;
dc_sink->edid_caps.audio_mode_count = 0;
amdgpu_dm_fill_audio_info(audio_info, connector, dc_sink);
KUNIT_EXPECT_EQ(test, audio_info->mode_count, 0U);
KUNIT_EXPECT_EQ(test, (int)audio_info->modes[0].format_code, 0);
}
static void dm_test_audio_component_bind_sets_fields(struct kunit *test)
{
struct amdgpu_device *adev;
struct device *kdev;
struct drm_audio_component *acomp;
int ret;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
kdev = kunit_kzalloc(test, sizeof(*kdev), GFP_KERNEL);
acomp = kunit_kzalloc(test, sizeof(*acomp), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, kdev);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, acomp);
dev_set_drvdata(kdev, &adev->ddev);
ret = amdgpu_dm_audio_component_bind(kdev, NULL, acomp);
KUNIT_EXPECT_EQ(test, ret, 0);
KUNIT_EXPECT_NOT_NULL(test, acomp->ops);
KUNIT_EXPECT_PTR_EQ(test, acomp->dev, kdev);
KUNIT_EXPECT_PTR_EQ(test, adev->dm.audio_component, acomp);
}
static void dm_test_audio_component_unbind_clears_fields(struct kunit *test)
{
struct amdgpu_device *adev;
struct device *kdev;
struct drm_audio_component *acomp;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
kdev = kunit_kzalloc(test, sizeof(*kdev), GFP_KERNEL);
acomp = kunit_kzalloc(test, sizeof(*acomp), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, kdev);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, acomp);
dev_set_drvdata(kdev, &adev->ddev);
acomp->dev = kdev;
adev->dm.audio_component = acomp;
amdgpu_dm_audio_component_unbind(kdev, NULL, acomp);
KUNIT_EXPECT_NULL(test, acomp->ops);
KUNIT_EXPECT_NULL(test, acomp->dev);
KUNIT_EXPECT_NULL(test, adev->dm.audio_component);
}
static int dm_test_eld_notify_count;
static int dm_test_eld_notify_port;
static void *dm_test_eld_notify_ptr;
static void dm_test_pin_eld_notify(void *audio_ptr, int port, int pipe)
{
dm_test_eld_notify_count++;
dm_test_eld_notify_port = port;
dm_test_eld_notify_ptr = audio_ptr;
}
static void dm_test_audio_setup_notify_component(struct kunit *test,
struct amdgpu_device *adev)
{
struct drm_audio_component *acomp;
struct drm_audio_component_audio_ops *audio_ops;
acomp = kunit_kzalloc(test, sizeof(*acomp), GFP_KERNEL);
audio_ops = kunit_kzalloc(test, sizeof(*audio_ops), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, acomp);
KUNIT_ASSERT_NOT_NULL(test, audio_ops);
audio_ops->pin_eld_notify = dm_test_pin_eld_notify;
acomp->audio_ops = audio_ops;
adev->dm.audio_component = acomp;
}
static void dm_test_eld_notify_invokes_callback(struct kunit *test)
{
struct amdgpu_device *adev;
struct drm_audio_component *acomp;
struct drm_audio_component_audio_ops *audio_ops;
int marker = 0;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
acomp = kunit_kzalloc(test, sizeof(*acomp), GFP_KERNEL);
audio_ops = kunit_kzalloc(test, sizeof(*audio_ops), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, acomp);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, audio_ops);
audio_ops->audio_ptr = ▮
audio_ops->pin_eld_notify = dm_test_pin_eld_notify;
acomp->audio_ops = audio_ops;
adev->dm.audio_component = acomp;
dm_test_eld_notify_count = 0;
dm_test_eld_notify_port = -100;
dm_test_eld_notify_ptr = NULL;
amdgpu_dm_audio_eld_notify(adev, 7);
KUNIT_EXPECT_EQ(test, dm_test_eld_notify_count, 1);
KUNIT_EXPECT_EQ(test, dm_test_eld_notify_port, 7);
KUNIT_EXPECT_PTR_EQ(test, dm_test_eld_notify_ptr, (void *)&marker);
}
static void dm_test_eld_notify_no_component(struct kunit *test)
{
struct amdgpu_device *adev;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
adev->dm.audio_component = NULL;
dm_test_eld_notify_count = 0;
amdgpu_dm_audio_eld_notify(adev, 3);
KUNIT_EXPECT_EQ(test, dm_test_eld_notify_count, 0);
}
static void dm_test_eld_notify_null_audio_ops(struct kunit *test)
{
struct amdgpu_device *adev;
struct drm_audio_component *acomp;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
acomp = kunit_kzalloc(test, sizeof(*acomp), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, acomp);
acomp->audio_ops = NULL;
adev->dm.audio_component = acomp;
dm_test_eld_notify_count = 0;
amdgpu_dm_audio_eld_notify(adev, 3);
KUNIT_EXPECT_EQ(test, dm_test_eld_notify_count, 0);
}
static void dm_test_eld_notify_null_callback(struct kunit *test)
{
struct amdgpu_device *adev;
struct drm_audio_component *acomp;
struct drm_audio_component_audio_ops *audio_ops;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
acomp = kunit_kzalloc(test, sizeof(*acomp), GFP_KERNEL);
audio_ops = kunit_kzalloc(test, sizeof(*audio_ops), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, acomp);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, audio_ops);
audio_ops->pin_eld_notify = NULL;
acomp->audio_ops = audio_ops;
adev->dm.audio_component = acomp;
dm_test_eld_notify_count = 0;
amdgpu_dm_audio_eld_notify(adev, 3);
KUNIT_EXPECT_EQ(test, dm_test_eld_notify_count, 0);
}
static void dm_test_audio_init_pins_sets_defaults(struct kunit *test)
{
struct amdgpu_device *adev;
const unsigned int inst_array[] = {3, 7};
int i;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
amdgpu_dm_audio_init_pins(adev, 2, inst_array);
KUNIT_EXPECT_EQ(test, adev->mode_info.audio.num_pins, 2);
for (i = 0; i < 2; i++) {
KUNIT_EXPECT_EQ(test, adev->mode_info.audio.pin[i].channels, -1);
KUNIT_EXPECT_EQ(test, adev->mode_info.audio.pin[i].rate, -1);
KUNIT_EXPECT_EQ(test, adev->mode_info.audio.pin[i].bits_per_sample, -1);
KUNIT_EXPECT_EQ(test, adev->mode_info.audio.pin[i].status_bits, 0);
KUNIT_EXPECT_EQ(test, adev->mode_info.audio.pin[i].category_code, 0);
KUNIT_EXPECT_FALSE(test, adev->mode_info.audio.pin[i].connected);
KUNIT_EXPECT_EQ(test, adev->mode_info.audio.pin[i].offset, 0);
}
KUNIT_EXPECT_EQ(test, adev->mode_info.audio.pin[0].id, 3U);
KUNIT_EXPECT_EQ(test, adev->mode_info.audio.pin[1].id, 7U);
}
static void dm_test_audio_init_pins_zero_count(struct kunit *test)
{
struct amdgpu_device *adev;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
adev->mode_info.audio.pin[0].channels = 99;
amdgpu_dm_audio_init_pins(adev, 0, NULL);
KUNIT_EXPECT_EQ(test, adev->mode_info.audio.num_pins, 0);
KUNIT_EXPECT_EQ(test, adev->mode_info.audio.pin[0].channels, 99);
}
static void dm_test_audio_component_get_eld_copies_matching_connector(struct kunit *test)
{
struct amdgpu_device *adev = dm_kunit_alloc_adev(test);
struct amdgpu_dm_connector *aconnector;
struct drm_connector *wb_connector;
struct drm_audio_component *acomp;
struct device *kdev;
unsigned char buf[DRM_ELD_HEADER_BLOCK_SIZE + 8] = {0};
bool enabled = false;
int ret;
kdev = adev->ddev.dev;
KUNIT_ASSERT_NOT_NULL(test, kdev);
acomp = kunit_kzalloc(test, sizeof(*acomp), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, acomp);
wb_connector = kunit_kzalloc(test, sizeof(*wb_connector), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, wb_connector);
KUNIT_ASSERT_EQ(test, drm_connector_init(&adev->ddev, wb_connector,
&dm_test_audio_connector_funcs,
DRM_MODE_CONNECTOR_WRITEBACK), 0);
KUNIT_ASSERT_EQ(test, kunit_add_action_or_reset(test,
dm_test_audio_connector_cleanup, wb_connector), 0);
aconnector = kunit_kzalloc(test, sizeof(*aconnector), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, aconnector);
KUNIT_ASSERT_EQ(test, drm_connector_init(&adev->ddev, &aconnector->base,
&dm_test_audio_connector_funcs,
DRM_MODE_CONNECTOR_HDMIA), 0);
KUNIT_ASSERT_EQ(test, kunit_add_action_or_reset(test,
dm_test_audio_connector_cleanup, &aconnector->base), 0);
mutex_init(&adev->dm.audio_lock);
aconnector->audio_inst = 3;
aconnector->base.eld[DRM_ELD_BASELINE_ELD_LEN] = 2;
aconnector->base.eld[DRM_ELD_VER] = DRM_ELD_VER_CEA861D;
aconnector->base.eld[DRM_ELD_SPEAKER] = DRM_ELD_SPEAKER_FLR;
dev_set_drvdata(kdev, &adev->ddev);
KUNIT_ASSERT_EQ(test, amdgpu_dm_audio_component_bind(kdev, NULL, acomp), 0);
ret = acomp->ops->get_eld(kdev, 3, 0, &enabled, buf, sizeof(buf));
KUNIT_EXPECT_EQ(test, ret, DRM_ELD_HEADER_BLOCK_SIZE + 8);
KUNIT_EXPECT_TRUE(test, enabled);
KUNIT_EXPECT_EQ(test, memcmp(buf, aconnector->base.eld, ret), 0);
}
static void dm_test_audio_component_get_eld_no_match(struct kunit *test)
{
struct amdgpu_device *adev = dm_kunit_alloc_adev(test);
struct amdgpu_dm_connector *aconnector;
struct drm_audio_component *acomp;
struct device *kdev;
unsigned char buf[DRM_ELD_HEADER_BLOCK_SIZE] = {0x5a};
bool enabled = true;
int ret;
kdev = adev->ddev.dev;
KUNIT_ASSERT_NOT_NULL(test, kdev);
acomp = kunit_kzalloc(test, sizeof(*acomp), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, acomp);
aconnector = kunit_kzalloc(test, sizeof(*aconnector), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, aconnector);
KUNIT_ASSERT_EQ(test, drm_connector_init(&adev->ddev, &aconnector->base,
&dm_test_audio_connector_funcs,
DRM_MODE_CONNECTOR_HDMIA), 0);
KUNIT_ASSERT_EQ(test, kunit_add_action_or_reset(test,
dm_test_audio_connector_cleanup, &aconnector->base), 0);
mutex_init(&adev->dm.audio_lock);
aconnector->audio_inst = 4;
dev_set_drvdata(kdev, &adev->ddev);
KUNIT_ASSERT_EQ(test, amdgpu_dm_audio_component_bind(kdev, NULL, acomp), 0);
ret = acomp->ops->get_eld(kdev, 3, 0, &enabled, buf, sizeof(buf));
KUNIT_EXPECT_EQ(test, ret, 0);
KUNIT_EXPECT_FALSE(test, enabled);
KUNIT_EXPECT_EQ(test, buf[0], 0x5a);
}
static void dm_test_commit_audio_notifies_removed_connector(struct kunit *test)
{
struct amdgpu_device *adev = dm_kunit_alloc_adev(test);
struct drm_atomic_commit *state;
struct amdgpu_dm_connector *aconnector;
struct drm_connector_state *old_conn_state;
struct drm_connector_state *new_conn_state;
struct drm_crtc *crtc;
state = dm_test_audio_alloc_atomic_state(test, 1, 0);
aconnector = kunit_kzalloc(test, sizeof(*aconnector), GFP_KERNEL);
old_conn_state = kunit_kzalloc(test, sizeof(*old_conn_state), GFP_KERNEL);
new_conn_state = kunit_kzalloc(test, sizeof(*new_conn_state), GFP_KERNEL);
crtc = kunit_kzalloc(test, sizeof(*crtc), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, aconnector);
KUNIT_ASSERT_NOT_NULL(test, old_conn_state);
KUNIT_ASSERT_NOT_NULL(test, new_conn_state);
KUNIT_ASSERT_NOT_NULL(test, crtc);
mutex_init(&adev->dm.audio_lock);
dm_test_audio_setup_notify_component(test, adev);
aconnector->audio_inst = 5;
aconnector->base.connector_type = DRM_MODE_CONNECTOR_HDMIA;
old_conn_state->crtc = crtc;
state->connectors[0].ptr = &aconnector->base;
state->connectors[0].old_state = old_conn_state;
state->connectors[0].new_state = new_conn_state;
dm_test_eld_notify_count = 0;
dm_test_eld_notify_port = -1;
amdgpu_dm_commit_audio(&adev->ddev, state);
KUNIT_EXPECT_EQ(test, aconnector->audio_inst, -1);
KUNIT_EXPECT_EQ(test, dm_test_eld_notify_count, 1);
KUNIT_EXPECT_EQ(test, dm_test_eld_notify_port, 5);
}
static void dm_test_commit_audio_notifies_added_connector(struct kunit *test)
{
struct amdgpu_device *adev = dm_kunit_alloc_adev(test);
struct drm_atomic_commit *state;
struct amdgpu_dm_connector *aconnector;
struct drm_connector_state *old_conn_state;
struct drm_connector_state *new_conn_state;
struct drm_crtc *crtc;
struct dm_crtc_state *dm_crtc_state;
struct dc_stream_state *stream;
state = dm_test_audio_alloc_atomic_state(test, 1, 1);
aconnector = kunit_kzalloc(test, sizeof(*aconnector), GFP_KERNEL);
old_conn_state = kunit_kzalloc(test, sizeof(*old_conn_state), GFP_KERNEL);
new_conn_state = kunit_kzalloc(test, sizeof(*new_conn_state), GFP_KERNEL);
crtc = kunit_kzalloc(test, sizeof(*crtc), GFP_KERNEL);
dm_crtc_state = kunit_kzalloc(test, sizeof(*dm_crtc_state), GFP_KERNEL);
stream = kunit_kzalloc(test, sizeof(*stream), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, aconnector);
KUNIT_ASSERT_NOT_NULL(test, old_conn_state);
KUNIT_ASSERT_NOT_NULL(test, new_conn_state);
KUNIT_ASSERT_NOT_NULL(test, crtc);
KUNIT_ASSERT_NOT_NULL(test, dm_crtc_state);
KUNIT_ASSERT_NOT_NULL(test, stream);
adev->dm.dc = kunit_kzalloc(test, sizeof(*adev->dm.dc), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, adev->dm.dc);
adev->dm.dc->current_state = kunit_kzalloc(test,
sizeof(*adev->dm.dc->current_state),
GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, adev->dm.dc->current_state);
stream->ctx = kunit_kzalloc(test, sizeof(*stream->ctx), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, stream->ctx);
stream->ctx->dc = adev->dm.dc;
adev->dm.dc->current_state->stream_count = 1;
adev->dm.dc->current_state->streams[0] = stream;
adev->dm.dc->current_state->stream_status[0].audio_inst = 8;
mutex_init(&adev->dm.audio_lock);
dm_test_audio_setup_notify_component(test, adev);
aconnector->audio_inst = -1;
aconnector->base.connector_type = DRM_MODE_CONNECTOR_HDMIA;
crtc->index = 0;
new_conn_state->crtc = crtc;
dm_crtc_state->base.crtc = crtc;
dm_crtc_state->base.mode_changed = true;
dm_crtc_state->stream = stream;
state->connectors[0].ptr = &aconnector->base;
state->connectors[0].old_state = old_conn_state;
state->connectors[0].new_state = new_conn_state;
state->crtcs[0].ptr = crtc;
state->crtcs[0].new_state = &dm_crtc_state->base;
dm_test_eld_notify_count = 0;
dm_test_eld_notify_port = -1;
amdgpu_dm_commit_audio(&adev->ddev, state);
KUNIT_EXPECT_EQ(test, aconnector->audio_inst, 8);
KUNIT_EXPECT_EQ(test, dm_test_eld_notify_count, 2);
KUNIT_EXPECT_EQ(test, dm_test_eld_notify_port, 8);
}
static void dm_test_commit_audio_skips_writeback_removal(struct kunit *test)
{
struct amdgpu_device *adev = dm_kunit_alloc_adev(test);
struct drm_atomic_commit *state;
struct amdgpu_dm_connector *aconnector;
struct drm_connector_state *old_conn_state;
struct drm_connector_state *new_conn_state;
struct drm_crtc *crtc;
state = dm_test_audio_alloc_atomic_state(test, 1, 0);
aconnector = kunit_kzalloc(test, sizeof(*aconnector), GFP_KERNEL);
old_conn_state = kunit_kzalloc(test, sizeof(*old_conn_state), GFP_KERNEL);
new_conn_state = kunit_kzalloc(test, sizeof(*new_conn_state), GFP_KERNEL);
crtc = kunit_kzalloc(test, sizeof(*crtc), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, aconnector);
KUNIT_ASSERT_NOT_NULL(test, old_conn_state);
KUNIT_ASSERT_NOT_NULL(test, new_conn_state);
KUNIT_ASSERT_NOT_NULL(test, crtc);
mutex_init(&adev->dm.audio_lock);
dm_test_audio_setup_notify_component(test, adev);
aconnector->audio_inst = 9;
aconnector->base.connector_type = DRM_MODE_CONNECTOR_WRITEBACK;
old_conn_state->crtc = crtc;
state->connectors[0].ptr = &aconnector->base;
state->connectors[0].old_state = old_conn_state;
state->connectors[0].new_state = new_conn_state;
dm_test_eld_notify_count = 0;
amdgpu_dm_commit_audio(&adev->ddev, state);
KUNIT_EXPECT_EQ(test, aconnector->audio_inst, 9);
KUNIT_EXPECT_EQ(test, dm_test_eld_notify_count, 0);
}
static void dm_test_commit_audio_skips_without_new_crtc_state(struct kunit *test)
{
struct amdgpu_device *adev = dm_kunit_alloc_adev(test);
struct drm_atomic_commit *state;
struct amdgpu_dm_connector *aconnector;
struct drm_connector_state *old_conn_state;
struct drm_connector_state *new_conn_state;
struct drm_crtc *crtc;
state = dm_test_audio_alloc_atomic_state(test, 1, 1);
aconnector = kunit_kzalloc(test, sizeof(*aconnector), GFP_KERNEL);
old_conn_state = kunit_kzalloc(test, sizeof(*old_conn_state), GFP_KERNEL);
new_conn_state = kunit_kzalloc(test, sizeof(*new_conn_state), GFP_KERNEL);
crtc = kunit_kzalloc(test, sizeof(*crtc), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, aconnector);
KUNIT_ASSERT_NOT_NULL(test, old_conn_state);
KUNIT_ASSERT_NOT_NULL(test, new_conn_state);
KUNIT_ASSERT_NOT_NULL(test, crtc);
mutex_init(&adev->dm.audio_lock);
dm_test_audio_setup_notify_component(test, adev);
aconnector->audio_inst = 4;
aconnector->base.connector_type = DRM_MODE_CONNECTOR_HDMIA;
crtc->index = 0;
old_conn_state->crtc = crtc;
new_conn_state->crtc = crtc;
state->connectors[0].ptr = &aconnector->base;
state->connectors[0].old_state = old_conn_state;
state->connectors[0].new_state = new_conn_state;
dm_test_eld_notify_count = 0;
amdgpu_dm_commit_audio(&adev->ddev, state);
KUNIT_EXPECT_EQ(test, aconnector->audio_inst, 4);
KUNIT_EXPECT_EQ(test, dm_test_eld_notify_count, 0);
}
static void dm_test_commit_audio_skips_without_stream_status(struct kunit *test)
{
struct amdgpu_device *adev = dm_kunit_alloc_adev(test);
struct drm_atomic_commit *state;
struct amdgpu_dm_connector *aconnector;
struct drm_connector_state *old_conn_state;
struct drm_connector_state *new_conn_state;
struct drm_crtc *crtc;
struct dm_crtc_state *dm_crtc_state;
struct dc_stream_state *stream;
state = dm_test_audio_alloc_atomic_state(test, 1, 1);
aconnector = kunit_kzalloc(test, sizeof(*aconnector), GFP_KERNEL);
old_conn_state = kunit_kzalloc(test, sizeof(*old_conn_state), GFP_KERNEL);
new_conn_state = kunit_kzalloc(test, sizeof(*new_conn_state), GFP_KERNEL);
crtc = kunit_kzalloc(test, sizeof(*crtc), GFP_KERNEL);
dm_crtc_state = kunit_kzalloc(test, sizeof(*dm_crtc_state), GFP_KERNEL);
stream = kunit_kzalloc(test, sizeof(*stream), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, aconnector);
KUNIT_ASSERT_NOT_NULL(test, old_conn_state);
KUNIT_ASSERT_NOT_NULL(test, new_conn_state);
KUNIT_ASSERT_NOT_NULL(test, crtc);
KUNIT_ASSERT_NOT_NULL(test, dm_crtc_state);
KUNIT_ASSERT_NOT_NULL(test, stream);
adev->dm.dc = kunit_kzalloc(test, sizeof(*adev->dm.dc), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, adev->dm.dc);
adev->dm.dc->current_state = kunit_kzalloc(test,
sizeof(*adev->dm.dc->current_state),
GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, adev->dm.dc->current_state);
stream->ctx = kunit_kzalloc(test, sizeof(*stream->ctx), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, stream->ctx);
stream->ctx->dc = adev->dm.dc;
mutex_init(&adev->dm.audio_lock);
dm_test_audio_setup_notify_component(test, adev);
aconnector->audio_inst = -1;
aconnector->base.connector_type = DRM_MODE_CONNECTOR_HDMIA;
crtc->index = 0;
new_conn_state->crtc = crtc;
dm_crtc_state->base.crtc = crtc;
dm_crtc_state->base.mode_changed = true;
dm_crtc_state->stream = stream;
state->connectors[0].ptr = &aconnector->base;
state->connectors[0].old_state = old_conn_state;
state->connectors[0].new_state = new_conn_state;
state->crtcs[0].ptr = crtc;
state->crtcs[0].new_state = &dm_crtc_state->base;
dm_test_eld_notify_count = 0;
amdgpu_dm_commit_audio(&adev->ddev, state);
KUNIT_EXPECT_EQ(test, aconnector->audio_inst, -1);
KUNIT_EXPECT_EQ(test, dm_test_eld_notify_count, 1);
}
static void dm_test_commit_audio_skips_detached_connector(struct kunit *test)
{
struct amdgpu_device *adev = dm_kunit_alloc_adev(test);
struct drm_atomic_commit *state;
struct amdgpu_dm_connector *aconnector;
struct drm_connector_state *old_conn_state;
struct drm_connector_state *new_conn_state;
state = dm_test_audio_alloc_atomic_state(test, 1, 0);
aconnector = kunit_kzalloc(test, sizeof(*aconnector), GFP_KERNEL);
old_conn_state = kunit_kzalloc(test, sizeof(*old_conn_state), GFP_KERNEL);
new_conn_state = kunit_kzalloc(test, sizeof(*new_conn_state), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, aconnector);
KUNIT_ASSERT_NOT_NULL(test, old_conn_state);
KUNIT_ASSERT_NOT_NULL(test, new_conn_state);
aconnector->audio_inst = 11;
aconnector->base.connector_type = DRM_MODE_CONNECTOR_HDMIA;
state->connectors[0].ptr = &aconnector->base;
state->connectors[0].old_state = old_conn_state;
state->connectors[0].new_state = new_conn_state;
dm_test_eld_notify_count = 0;
amdgpu_dm_commit_audio(&adev->ddev, state);
KUNIT_EXPECT_EQ(test, aconnector->audio_inst, 11);
KUNIT_EXPECT_EQ(test, dm_test_eld_notify_count, 0);
}
static void dm_test_commit_audio_skips_without_modeset(struct kunit *test)
{
struct amdgpu_device *adev = dm_kunit_alloc_adev(test);
struct drm_atomic_commit *state;
struct amdgpu_dm_connector *aconnector;
struct drm_connector_state *old_conn_state;
struct drm_connector_state *new_conn_state;
struct drm_crtc *crtc;
struct dm_crtc_state *dm_crtc_state;
state = dm_test_audio_alloc_atomic_state(test, 1, 1);
aconnector = kunit_kzalloc(test, sizeof(*aconnector), GFP_KERNEL);
old_conn_state = kunit_kzalloc(test, sizeof(*old_conn_state), GFP_KERNEL);
new_conn_state = kunit_kzalloc(test, sizeof(*new_conn_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, aconnector);
KUNIT_ASSERT_NOT_NULL(test, old_conn_state);
KUNIT_ASSERT_NOT_NULL(test, new_conn_state);
KUNIT_ASSERT_NOT_NULL(test, crtc);
KUNIT_ASSERT_NOT_NULL(test, dm_crtc_state);
aconnector->audio_inst = 12;
aconnector->base.connector_type = DRM_MODE_CONNECTOR_HDMIA;
crtc->index = 0;
old_conn_state->crtc = crtc;
new_conn_state->crtc = crtc;
dm_crtc_state->base.crtc = crtc;
state->connectors[0].ptr = &aconnector->base;
state->connectors[0].old_state = old_conn_state;
state->connectors[0].new_state = new_conn_state;
state->crtcs[0].ptr = crtc;
state->crtcs[0].new_state = &dm_crtc_state->base;
dm_test_eld_notify_count = 0;
amdgpu_dm_commit_audio(&adev->ddev, state);
KUNIT_EXPECT_EQ(test, aconnector->audio_inst, 12);
KUNIT_EXPECT_EQ(test, dm_test_eld_notify_count, 0);
}
static void dm_test_commit_audio_skips_addition_without_stream(struct kunit *test)
{
struct amdgpu_device *adev = dm_kunit_alloc_adev(test);
struct drm_atomic_commit *state;
struct amdgpu_dm_connector *aconnector;
struct drm_connector_state *old_conn_state;
struct drm_connector_state *new_conn_state;
struct drm_crtc *crtc;
struct dm_crtc_state *dm_crtc_state;
state = dm_test_audio_alloc_atomic_state(test, 1, 1);
aconnector = kunit_kzalloc(test, sizeof(*aconnector), GFP_KERNEL);
old_conn_state = kunit_kzalloc(test, sizeof(*old_conn_state), GFP_KERNEL);
new_conn_state = kunit_kzalloc(test, sizeof(*new_conn_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, aconnector);
KUNIT_ASSERT_NOT_NULL(test, old_conn_state);
KUNIT_ASSERT_NOT_NULL(test, new_conn_state);
KUNIT_ASSERT_NOT_NULL(test, crtc);
KUNIT_ASSERT_NOT_NULL(test, dm_crtc_state);
mutex_init(&adev->dm.audio_lock);
dm_test_audio_setup_notify_component(test, adev);
aconnector->audio_inst = 13;
aconnector->base.connector_type = DRM_MODE_CONNECTOR_HDMIA;
crtc->index = 0;
old_conn_state->crtc = crtc;
new_conn_state->crtc = crtc;
dm_crtc_state->base.crtc = crtc;
dm_crtc_state->base.mode_changed = true;
state->connectors[0].ptr = &aconnector->base;
state->connectors[0].old_state = old_conn_state;
state->connectors[0].new_state = new_conn_state;
state->crtcs[0].ptr = crtc;
state->crtcs[0].new_state = &dm_crtc_state->base;
dm_test_eld_notify_count = 0;
dm_test_eld_notify_port = -1;
amdgpu_dm_commit_audio(&adev->ddev, state);
KUNIT_EXPECT_EQ(test, aconnector->audio_inst, -1);
KUNIT_EXPECT_EQ(test, dm_test_eld_notify_count, 1);
KUNIT_EXPECT_EQ(test, dm_test_eld_notify_port, 13);
}
static void dm_test_commit_audio_skips_writeback_addition(struct kunit *test)
{
struct amdgpu_device *adev = dm_kunit_alloc_adev(test);
struct drm_atomic_commit *state;
struct amdgpu_dm_connector *aconnector;
struct drm_connector_state *old_conn_state;
struct drm_connector_state *new_conn_state;
struct drm_crtc *crtc;
struct dm_crtc_state *dm_crtc_state;
struct dc_stream_state *stream;
state = dm_test_audio_alloc_atomic_state(test, 1, 1);
aconnector = kunit_kzalloc(test, sizeof(*aconnector), GFP_KERNEL);
old_conn_state = kunit_kzalloc(test, sizeof(*old_conn_state), GFP_KERNEL);
new_conn_state = kunit_kzalloc(test, sizeof(*new_conn_state), GFP_KERNEL);
crtc = kunit_kzalloc(test, sizeof(*crtc), GFP_KERNEL);
dm_crtc_state = kunit_kzalloc(test, sizeof(*dm_crtc_state), GFP_KERNEL);
stream = kunit_kzalloc(test, sizeof(*stream), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, aconnector);
KUNIT_ASSERT_NOT_NULL(test, old_conn_state);
KUNIT_ASSERT_NOT_NULL(test, new_conn_state);
KUNIT_ASSERT_NOT_NULL(test, crtc);
KUNIT_ASSERT_NOT_NULL(test, dm_crtc_state);
KUNIT_ASSERT_NOT_NULL(test, stream);
adev->dm.dc = kunit_kzalloc(test, sizeof(*adev->dm.dc), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, adev->dm.dc);
adev->dm.dc->current_state = kunit_kzalloc(test,
sizeof(*adev->dm.dc->current_state),
GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, adev->dm.dc->current_state);
stream->ctx = kunit_kzalloc(test, sizeof(*stream->ctx), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, stream->ctx);
stream->ctx->dc = adev->dm.dc;
adev->dm.dc->current_state->stream_count = 1;
adev->dm.dc->current_state->streams[0] = stream;
adev->dm.dc->current_state->stream_status[0].audio_inst = 14;
mutex_init(&adev->dm.audio_lock);
dm_test_audio_setup_notify_component(test, adev);
aconnector->audio_inst = 15;
aconnector->base.connector_type = DRM_MODE_CONNECTOR_WRITEBACK;
crtc->index = 0;
new_conn_state->crtc = crtc;
dm_crtc_state->base.crtc = crtc;
dm_crtc_state->base.mode_changed = true;
dm_crtc_state->stream = stream;
state->connectors[0].ptr = &aconnector->base;
state->connectors[0].old_state = old_conn_state;
state->connectors[0].new_state = new_conn_state;
state->crtcs[0].ptr = crtc;
state->crtcs[0].new_state = &dm_crtc_state->base;
dm_test_eld_notify_count = 0;
amdgpu_dm_commit_audio(&adev->ddev, state);
KUNIT_EXPECT_EQ(test, aconnector->audio_inst, 15);
KUNIT_EXPECT_EQ(test, dm_test_eld_notify_count, 0);
}
static struct kunit_case dm_audio_test_cases[] = {
KUNIT_CASE(dm_test_audio_init_disabled),
KUNIT_CASE(dm_test_audio_init_enabled_success),
KUNIT_CASE(dm_test_audio_init_pins_sets_defaults),
KUNIT_CASE(dm_test_audio_init_pins_zero_count),
KUNIT_CASE(dm_test_audio_fini_without_enabled_audio),
KUNIT_CASE(dm_test_fill_audio_info_ids_name_flags),
KUNIT_CASE(dm_test_fill_audio_info_cea_lt_3_skips_modes),
KUNIT_CASE(dm_test_fill_audio_info_cea_ge_3_copies_modes),
KUNIT_CASE(dm_test_fill_audio_info_cea_ge_3_zero_modes),
KUNIT_CASE(dm_test_fill_audio_info_latency_present),
KUNIT_CASE(dm_test_fill_audio_info_latency_absent_keeps_zero),
KUNIT_CASE(dm_test_audio_component_bind_sets_fields),
KUNIT_CASE(dm_test_audio_component_unbind_clears_fields),
KUNIT_CASE(dm_test_eld_notify_invokes_callback),
KUNIT_CASE(dm_test_eld_notify_no_component),
KUNIT_CASE(dm_test_eld_notify_null_audio_ops),
KUNIT_CASE(dm_test_eld_notify_null_callback),
KUNIT_CASE(dm_test_audio_component_get_eld_copies_matching_connector),
KUNIT_CASE(dm_test_audio_component_get_eld_no_match),
KUNIT_CASE(dm_test_commit_audio_notifies_removed_connector),
KUNIT_CASE(dm_test_commit_audio_notifies_added_connector),
KUNIT_CASE(dm_test_commit_audio_skips_writeback_removal),
KUNIT_CASE(dm_test_commit_audio_skips_without_new_crtc_state),
KUNIT_CASE(dm_test_commit_audio_skips_without_stream_status),
KUNIT_CASE(dm_test_commit_audio_skips_detached_connector),
KUNIT_CASE(dm_test_commit_audio_skips_without_modeset),
KUNIT_CASE(dm_test_commit_audio_skips_addition_without_stream),
KUNIT_CASE(dm_test_commit_audio_skips_writeback_addition),
{}
};
static struct kunit_suite dm_audio_test_suite = {
.name = "amdgpu_dm_audio",
.test_cases = dm_audio_test_cases,
};
kunit_test_suite(dm_audio_test_suite);
MODULE_LICENSE("Dual MIT/GPL");
MODULE_DESCRIPTION("KUnit tests for amdgpu_dm_audio");
MODULE_AUTHOR("AMD"