#include <kunit/test.h>
#include <drm/drm_drv.h>
#include <drm/drm_kunit_helpers.h>
#include <drm/drm_atomic_helper.h>
#include <drm/drm_probe_helper.h>
#include <drm/drm_vblank.h>
#include <drm/drm_writeback.h>
#include <drm/display/drm_dp_helper.h>
#include "dc.h"
#include "inc/core_types.h"
#include "inc/hw/timing_generator.h"
#include "irq/irq_service.h"
#include "amdgpu.h"
#include "amdgpu_mode.h"
#include "amdgpu_dm.h"
#include "amdgpu_dm_hdcp.h"
#include "amdgpu_dm_irq.h"
#include "amdgpu_dm_kunit_test_helpers.h"
#include "dc_dmub_srv.h"
#include "ivsrcid/ivsrcid_vislands30.h"
#include "ivsrcid/dcn/irqsrcs_dcn_1_0.h"
#include "link_service.h"
#include "dmub/dmub_srv.h"
#include "dal_asic_id.h"
#include "../../amdgpu/amdgpu_reset.h"
static void dm_test_irq_handler(void *arg)
{
}
static void dm_test_irq_handler_alt(void *arg)
{
}
static void dm_test_irq_handler_count(void *arg)
{
int *count = arg;
if (count)
(*count)++;
}
static bool dm_test_detect_connection_none(struct dc_link *link,
enum dc_connection_type *type)
{
*type = dc_connection_none;
return true;
}
static bool dm_test_detect_link_false(struct dc_link *link,
enum dc_detect_reason reason)
{
return false;
}
static bool dm_test_detect_link_true(struct dc_link *link,
enum dc_detect_reason reason)
{
return true;
}
static int dm_test_detect_link_count;
static bool dm_test_detect_link_false_count(struct dc_link *link,
enum dc_detect_reason reason)
{
dm_test_detect_link_count++;
return false;
}
static bool dm_test_detect_connection_single(struct dc_link *link,
enum dc_connection_type *type)
{
*type = dc_connection_single;
return true;
}
static bool dm_test_detect_connection_fail(struct dc_link *link,
enum dc_connection_type *type)
{
return false;
}
static int dm_test_automated_test_count;
static int dm_test_handle_link_loss_count;
static void dm_test_dp_handle_automated_test(struct dc_link *link)
{
dm_test_automated_test_count++;
}
static void dm_test_dp_handle_link_loss(struct dc_link *link)
{
dm_test_handle_link_loss_count++;
}
static bool dm_test_dp_parse_link_loss_true(struct dc_link *link,
union hpd_irq_data *hpd_irq_dpcd_data)
{
return true;
}
static bool dm_test_dp_should_allow_hpd_rx_irq_true(const struct dc_link *link)
{
return true;
}
static enum dc_status dm_test_dp_read_hpd_rx_irq_data_ok(struct dc_link *link,
union hpd_irq_data *irq_data)
{
return DC_OK;
}
static const struct dc_link_status *dm_test_get_link_status(const struct dc_link *link)
{
return &link->link_status;
}
static ssize_t dm_test_aux_transfer_fail(struct drm_dp_aux *aux,
struct drm_dp_aux_msg *msg)
{
return -EIO;
}
static struct dc_sink *dm_test_sink_create(struct dc_link *link)
{
struct dc_sink *sink = kzalloc_obj(*sink);
if (!sink)
return NULL;
sink->link = link;
sink->ctx = link->ctx;
kref_init(&sink->refcount);
return sink;
}
static void dm_test_sink_free(struct kref *kref)
{
struct dc_sink *sink = container_of(kref, struct dc_sink, refcount);
kfree(sink->dc_container_id);
kfree(sink);
}
static void dm_test_sink_release(struct dc_sink *sink)
{
kref_put(&sink->refcount, dm_test_sink_free);
}
static bool dm_test_handle_hpd_rx_no_work(struct dc_link *link,
union hpd_irq_data *hpd_irq_data,
bool *link_loss,
bool defer_handling,
bool *has_left_work)
{
*link_loss = false;
*has_left_work = false;
return false;
}
static bool dm_test_handle_hpd_rx_automated(struct dc_link *link,
union hpd_irq_data *hpd_irq_data,
bool *link_loss,
bool defer_handling,
bool *has_left_work)
{
*link_loss = false;
*has_left_work = true;
hpd_irq_data->bytes.device_service_irq.bits.AUTOMATED_TEST = 1;
return false;
}
static bool dm_test_handle_hpd_rx_msg_rdy(struct dc_link *link,
union hpd_irq_data *hpd_irq_data,
bool *link_loss,
bool defer_handling,
bool *has_left_work)
{
*link_loss = false;
*has_left_work = true;
hpd_irq_data->bytes.device_service_irq.bits.UP_REQ_MSG_RDY = 1;
return false;
}
static bool dm_test_handle_hpd_rx_link_loss(struct dc_link *link,
union hpd_irq_data *hpd_irq_data,
bool *link_loss,
bool defer_handling,
bool *has_left_work)
{
*link_loss = true;
*has_left_work = true;
return false;
}
static bool dm_test_handle_hpd_rx_result_true(struct dc_link *link,
union hpd_irq_data *hpd_irq_data,
bool *link_loss,
bool defer_handling,
bool *has_left_work)
{
*link_loss = false;
*has_left_work = false;
return true;
}
static bool dm_test_handle_hpd_rx_cp_irq(struct dc_link *link,
union hpd_irq_data *hpd_irq_data,
bool *link_loss,
bool defer_handling,
bool *has_left_work)
{
*link_loss = false;
*has_left_work = false;
hpd_irq_data->bytes.device_service_irq.bits.CP_IRQ = 1;
return false;
}
static bool dm_test_allow_hpd_rx_irq_true(const struct dc_link *link)
{
return true;
}
static void dm_test_tg_get_scanoutpos(struct timing_generator *tg,
uint32_t *v_blank_start,
uint32_t *v_blank_end,
uint32_t *h_position,
uint32_t *v_position)
{
*v_blank_start = 100;
*v_blank_end = 110;
*h_position = 0;
*v_position = 200;
}
static const struct timing_generator_funcs dm_test_tg_funcs = {
.get_scanoutpos = dm_test_tg_get_scanoutpos,
};
static uint32_t dm_test_dmub_get_outbox0_wptr(struct dmub_srv *dmub)
{
return 0;
}
#define DM_TEST_OUTBOX0_TRACE_ENTRIES 65
#define DM_TEST_OUTBOX0_TRACE_BYTES \
(DM_TEST_OUTBOX0_TRACE_ENTRIES * sizeof(struct dmcub_trace_buf_entry))
#define DM_TEST_OUTBOX0_RB_SIZE (2 * DM_TEST_OUTBOX0_TRACE_BYTES)
static uint32_t dm_test_dmub_get_outbox0_wptr_full(struct dmub_srv *dmub)
{
return DM_TEST_OUTBOX0_TRACE_BYTES;
}
static uint32_t dm_test_dmub_get_outbox1_wptr(struct dmub_srv *dmub)
{
return 0;
}
static int dm_test_dmub_notify_count;
static void dm_test_dmub_notify_callback(struct amdgpu_device *adev,
struct dmub_notification *notify)
{
dm_test_dmub_notify_count++;
}
static enum dc_irq_source dm_test_to_dal_irq_source_dce110(
struct irq_service *irq_service,
uint32_t src_id,
uint32_t ext_id)
{
switch (src_id) {
case VISLANDS30_IV_SRCID_D1_VERTICAL_INTERRUPT0:
return DC_IRQ_SOURCE_VBLANK1;
case VISLANDS30_IV_SRCID_D1_V_UPDATE_INT:
return DC_IRQ_SOURCE_VUPDATE1;
case VISLANDS30_IV_SRCID_D1_GRPH_PFLIP:
return DC_IRQ_SOURCE_PFLIP1;
case VISLANDS30_IV_SRCID_D1_GRPH_PFLIP + 2:
return DC_IRQ_SOURCE_PFLIP2;
case VISLANDS30_IV_SRCID_D1_GRPH_PFLIP + 4:
return DC_IRQ_SOURCE_PFLIP3;
case VISLANDS30_IV_SRCID_D1_GRPH_PFLIP + 6:
return DC_IRQ_SOURCE_PFLIP4;
case VISLANDS30_IV_SRCID_D1_GRPH_PFLIP + 8:
return DC_IRQ_SOURCE_PFLIP5;
case VISLANDS30_IV_SRCID_D1_GRPH_PFLIP + 10:
return DC_IRQ_SOURCE_PFLIP6;
default:
return DC_IRQ_SOURCE_INVALID;
}
}
static const struct irq_service_funcs dm_test_irq_service_funcs_dce110 = {
.to_dal_irq_source = dm_test_to_dal_irq_source_dce110
};
static enum dc_irq_source dm_test_to_dal_irq_source_unmapped(
struct irq_service *irq_service,
uint32_t src_id,
uint32_t ext_id)
{
return DC_IRQ_SOURCE_INVALID;
}
static const struct irq_service_funcs dm_test_irq_service_funcs_unmapped = {
.to_dal_irq_source = dm_test_to_dal_irq_source_unmapped
};
static enum dc_irq_source dm_test_to_dal_irq_source_vblank_only(
struct irq_service *irq_service,
uint32_t src_id,
uint32_t ext_id)
{
if (src_id == VISLANDS30_IV_SRCID_D1_VERTICAL_INTERRUPT0)
return DC_IRQ_SOURCE_VBLANK1;
return DC_IRQ_SOURCE_INVALID;
}
static const struct irq_service_funcs dm_test_irq_service_funcs_vblank_only = {
.to_dal_irq_source = dm_test_to_dal_irq_source_vblank_only
};
static enum dc_irq_source dm_test_to_dal_irq_source_no_pflip(
struct irq_service *irq_service,
uint32_t src_id,
uint32_t ext_id)
{
switch (src_id) {
case VISLANDS30_IV_SRCID_D1_VERTICAL_INTERRUPT0:
return DC_IRQ_SOURCE_VBLANK1;
case VISLANDS30_IV_SRCID_D1_V_UPDATE_INT:
return DC_IRQ_SOURCE_VUPDATE1;
default:
return DC_IRQ_SOURCE_INVALID;
}
}
static const struct irq_service_funcs dm_test_irq_service_funcs_no_pflip = {
.to_dal_irq_source = dm_test_to_dal_irq_source_no_pflip
};
static enum dc_irq_source dm_test_to_dal_irq_source_dcn10(
struct irq_service *irq_service,
uint32_t src_id,
uint32_t ext_id)
{
switch (src_id) {
case DCN_1_0__SRCID__DC_D1_OTG_VSTARTUP:
return DC_IRQ_SOURCE_VBLANK1;
case DCN_1_0__SRCID__OTG0_IHC_V_UPDATE_NO_LOCK_INTERRUPT:
return DC_IRQ_SOURCE_VUPDATE1;
case DCN_1_0__SRCID__HUBP0_FLIP_INTERRUPT:
return DC_IRQ_SOURCE_PFLIP1;
case DCN_1_0__SRCID__DMCUB_OUTBOX_LOW_PRIORITY_READY_INT:
return DC_IRQ_SOURCE_DMCUB_OUTBOX;
default:
return DC_IRQ_SOURCE_INVALID;
}
}
static const struct irq_service_funcs dm_test_irq_service_funcs_dcn10 = {
.to_dal_irq_source = dm_test_to_dal_irq_source_dcn10
};
static bool dm_test_irq_src_set(struct irq_service *irq_service,
const struct irq_source_info *info, bool enable)
{
return true;
}
static bool dm_test_irq_src_ack(struct irq_service *irq_service,
const struct irq_source_info *info)
{
return true;
}
static struct irq_source_info_funcs dm_test_irq_src_funcs = {
.set = dm_test_irq_src_set,
.ack = dm_test_irq_src_ack,
};
static struct dc *dm_test_alloc_dc_with_irq_service(struct kunit *test,
const struct irq_service_funcs *funcs)
{
struct irq_source_info *info;
struct resource_pool *res_pool;
struct irq_service *irqs;
struct dc *dc;
int i;
dc = dm_kunit_alloc_dc_with_ctx(test);
res_pool = kunit_kzalloc(test, sizeof(*res_pool), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, res_pool);
irqs = kunit_kzalloc(test, sizeof(*irqs), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, irqs);
info = kunit_kzalloc(test, sizeof(*info) * DAL_IRQ_SOURCES_NUMBER,
GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, info);
for (i = 0; i < DAL_IRQ_SOURCES_NUMBER; i++)
info[i].funcs = &dm_test_irq_src_funcs;
irqs->funcs = funcs;
irqs->info = info;
res_pool->irqs = irqs;
dc->res_pool = res_pool;
return dc;
}
static void dm_test_free_irq_sources(void *data)
{
struct amdgpu_device *adev = data;
int i;
for (i = 0; i < AMDGPU_IRQ_CLIENTID_MAX; i++) {
kfree(adev->irq.client[i].sources);
adev->irq.client[i].sources = NULL;
}
kfree(adev->crtc_irq.enabled_types);
adev->crtc_irq.enabled_types = NULL;
kfree(adev->vline0_irq.enabled_types);
adev->vline0_irq.enabled_types = NULL;
kfree(adev->vupdate_irq.enabled_types);
adev->vupdate_irq.enabled_types = NULL;
kfree(adev->pageflip_irq.enabled_types);
adev->pageflip_irq.enabled_types = NULL;
kfree(adev->dmub_outbox_irq.enabled_types);
adev->dmub_outbox_irq.enabled_types = NULL;
kfree(adev->dmub_trace_irq.enabled_types);
adev->dmub_trace_irq.enabled_types = NULL;
kfree(adev->hpd_irq.enabled_types);
adev->hpd_irq.enabled_types = NULL;
}
static void dm_test_crtc_list_del(void *data)
{
struct amdgpu_crtc *acrtc = data;
if (acrtc->base.dev && drm_dev_has_vblank(acrtc->base.dev))
drm_crtc_vblank_off(&acrtc->base);
list_del_init(&acrtc->base.head);
}
static const struct drm_crtc_funcs dm_test_crtc_funcs = {
};
static struct amdgpu_crtc *dm_test_add_crtc(struct kunit *test,
struct amdgpu_device *adev)
{
struct amdgpu_crtc *acrtc;
acrtc = kunit_kzalloc(test, sizeof(*acrtc), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, acrtc);
INIT_LIST_HEAD(&acrtc->base.head);
acrtc->base.dev = &adev->ddev;
acrtc->base.funcs = &dm_test_crtc_funcs;
acrtc->otg_inst = 0;
list_add_tail(&acrtc->base.head, &adev->ddev.mode_config.crtc_list);
KUNIT_ASSERT_EQ(test, kunit_add_action_or_reset(test,
dm_test_crtc_list_del, acrtc), 0);
return acrtc;
}
struct dm_test_hpd_rx_wq_ctx {
struct hpd_rx_irq_offload_work_queue *wq;
int count;
};
static void dm_test_destroy_hpd_rx_wq(void *data)
{
struct dm_test_hpd_rx_wq_ctx *ctx = data;
int i;
for (i = 0; i < ctx->count; i++)
if (ctx->wq[i].wq)
destroy_workqueue(ctx->wq[i].wq);
kfree(ctx->wq);
}
static const struct drm_connector_funcs dm_test_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_connector_cleanup(void *data)
{
drm_connector_cleanup(data);
}
static void dm_test_drm_dev_unregister(void *data)
{
drm_dev_unregister(data);
}
static void dm_test_register_drm_dev(struct kunit *test, struct amdgpu_device *adev)
{
KUNIT_ASSERT_EQ(test, drm_dev_register(&adev->ddev, 0), 0);
KUNIT_ASSERT_EQ(test, kunit_add_action_or_reset(test, dm_test_drm_dev_unregister,
&adev->ddev), 0);
}
static void dm_test_hdcp_dummy_work(struct work_struct *work)
{
}
static struct hdcp_workqueue *dm_test_alloc_hdcp_workqueue(struct kunit *test)
{
struct hdcp_workqueue *hdcp_work;
hdcp_work = kunit_kzalloc(test, sizeof(*hdcp_work), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, hdcp_work);
mutex_init(&hdcp_work->mutex);
INIT_WORK(&hdcp_work->cpirq_work, dm_test_hdcp_dummy_work);
INIT_DELAYED_WORK(&hdcp_work->callback_dwork, dm_test_hdcp_dummy_work);
INIT_DELAYED_WORK(&hdcp_work->watchdog_timer_dwork, dm_test_hdcp_dummy_work);
INIT_DELAYED_WORK(&hdcp_work->property_validate_dwork, dm_test_hdcp_dummy_work);
return hdcp_work;
}
static void dm_test_flush_hdcp_workqueue(struct hdcp_workqueue *hdcp_work)
{
flush_work(&hdcp_work->cpirq_work);
cancel_delayed_work_sync(&hdcp_work->callback_dwork);
cancel_delayed_work_sync(&hdcp_work->watchdog_timer_dwork);
cancel_delayed_work_sync(&hdcp_work->property_validate_dwork);
}
static void dm_test_hpd_to_dal_irq_source_hpd1(struct kunit *test)
{
KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_hpd_to_dal_irq_source(AMDGPU_HPD_1),
(int)DC_IRQ_SOURCE_HPD1);
}
static void dm_test_hpd_to_dal_irq_source_hpd2(struct kunit *test)
{
KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_hpd_to_dal_irq_source(AMDGPU_HPD_2),
(int)DC_IRQ_SOURCE_HPD2);
}
static void dm_test_hpd_to_dal_irq_source_hpd3(struct kunit *test)
{
KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_hpd_to_dal_irq_source(AMDGPU_HPD_3),
(int)DC_IRQ_SOURCE_HPD3);
}
static void dm_test_hpd_to_dal_irq_source_hpd4(struct kunit *test)
{
KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_hpd_to_dal_irq_source(AMDGPU_HPD_4),
(int)DC_IRQ_SOURCE_HPD4);
}
static void dm_test_hpd_to_dal_irq_source_hpd5(struct kunit *test)
{
KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_hpd_to_dal_irq_source(AMDGPU_HPD_5),
(int)DC_IRQ_SOURCE_HPD5);
}
static void dm_test_hpd_to_dal_irq_source_hpd6(struct kunit *test)
{
KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_hpd_to_dal_irq_source(AMDGPU_HPD_6),
(int)DC_IRQ_SOURCE_HPD6);
}
static void dm_test_hpd_to_dal_irq_source_invalid(struct kunit *test)
{
KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_hpd_to_dal_irq_source(AMDGPU_HPD_NONE),
(int)DC_IRQ_SOURCE_INVALID);
}
static void dm_test_are_sinks_equal_first_null(struct kunit *test)
{
struct dc_sink *sink2;
sink2 = kunit_kzalloc(test, sizeof(*sink2), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, sink2);
KUNIT_EXPECT_FALSE(test, are_sinks_equal(NULL, sink2));
}
static void dm_test_are_sinks_equal_second_null(struct kunit *test)
{
struct dc_sink *sink1;
sink1 = kunit_kzalloc(test, sizeof(*sink1), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, sink1);
KUNIT_EXPECT_FALSE(test, are_sinks_equal(sink1, NULL));
}
static void dm_test_are_sinks_equal_different_signal(struct kunit *test)
{
struct dc_sink *sink1, *sink2;
sink1 = kunit_kzalloc(test, sizeof(*sink1), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, sink1);
sink2 = kunit_kzalloc(test, sizeof(*sink2), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, sink2);
sink1->sink_signal = SIGNAL_TYPE_HDMI_TYPE_A;
sink2->sink_signal = SIGNAL_TYPE_DISPLAY_PORT;
KUNIT_EXPECT_FALSE(test, are_sinks_equal(sink1, sink2));
}
static void dm_test_are_sinks_equal_different_edid_length(struct kunit *test)
{
struct dc_sink *sink1, *sink2;
sink1 = kunit_kzalloc(test, sizeof(*sink1), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, sink1);
sink2 = kunit_kzalloc(test, sizeof(*sink2), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, sink2);
sink1->sink_signal = SIGNAL_TYPE_HDMI_TYPE_A;
sink2->sink_signal = SIGNAL_TYPE_HDMI_TYPE_A;
sink1->dc_edid.length = 128;
sink2->dc_edid.length = 256;
KUNIT_EXPECT_FALSE(test, are_sinks_equal(sink1, sink2));
}
static void dm_test_are_sinks_equal_different_edid_data(struct kunit *test)
{
struct dc_sink *sink1, *sink2;
sink1 = kunit_kzalloc(test, sizeof(*sink1), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, sink1);
sink2 = kunit_kzalloc(test, sizeof(*sink2), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, sink2);
sink1->sink_signal = SIGNAL_TYPE_HDMI_TYPE_A;
sink2->sink_signal = SIGNAL_TYPE_HDMI_TYPE_A;
sink1->dc_edid.length = 4;
sink2->dc_edid.length = 4;
memset(sink1->dc_edid.raw_edid, 0xAA, 4);
memset(sink2->dc_edid.raw_edid, 0xBB, 4);
KUNIT_EXPECT_FALSE(test, are_sinks_equal(sink1, sink2));
}
static void dm_test_are_sinks_equal_zero_length(struct kunit *test)
{
struct dc_sink *sink1, *sink2;
sink1 = kunit_kzalloc(test, sizeof(*sink1), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, sink1);
sink2 = kunit_kzalloc(test, sizeof(*sink2), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, sink2);
sink1->sink_signal = SIGNAL_TYPE_DISPLAY_PORT;
sink2->sink_signal = SIGNAL_TYPE_DISPLAY_PORT;
sink1->dc_edid.length = 0;
sink2->dc_edid.length = 0;
KUNIT_EXPECT_TRUE(test, are_sinks_equal(sink1, sink2));
}
static void dm_test_are_sinks_equal_full_edid_identical(struct kunit *test)
{
struct dc_sink *sink1, *sink2;
sink1 = kunit_kzalloc(test, sizeof(*sink1), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, sink1);
sink2 = kunit_kzalloc(test, sizeof(*sink2), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, sink2);
sink1->sink_signal = SIGNAL_TYPE_HDMI_TYPE_A;
sink2->sink_signal = SIGNAL_TYPE_HDMI_TYPE_A;
sink1->dc_edid.length = 128;
sink2->dc_edid.length = 128;
memset(sink1->dc_edid.raw_edid, 0x5A, 128);
memset(sink2->dc_edid.raw_edid, 0x5A, 128);
KUNIT_EXPECT_TRUE(test, are_sinks_equal(sink1, sink2));
}
static void dm_test_are_sinks_equal_full_edid_last_byte_differs(struct kunit *test)
{
struct dc_sink *sink1, *sink2;
sink1 = kunit_kzalloc(test, sizeof(*sink1), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, sink1);
sink2 = kunit_kzalloc(test, sizeof(*sink2), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, sink2);
sink1->sink_signal = SIGNAL_TYPE_HDMI_TYPE_A;
sink2->sink_signal = SIGNAL_TYPE_HDMI_TYPE_A;
sink1->dc_edid.length = 128;
sink2->dc_edid.length = 128;
memset(sink1->dc_edid.raw_edid, 0x5A, 128);
memset(sink2->dc_edid.raw_edid, 0x5A, 128);
sink2->dc_edid.raw_edid[127] = 0x5B;
KUNIT_EXPECT_FALSE(test, are_sinks_equal(sink1, sink2));
}
static void dm_test_notification_str_no_data(struct kunit *test)
{
KUNIT_EXPECT_STREQ(test, dmub_notification_type_str(DMUB_NOTIFICATION_NO_DATA), "NO_DATA");
}
static void dm_test_notification_str_aux_reply(struct kunit *test)
{
KUNIT_EXPECT_STREQ(test, dmub_notification_type_str(DMUB_NOTIFICATION_AUX_REPLY), "AUX_REPLY");
}
static void dm_test_notification_str_hpd(struct kunit *test)
{
KUNIT_EXPECT_STREQ(test, dmub_notification_type_str(DMUB_NOTIFICATION_HPD), "HPD");
}
static void dm_test_notification_str_hpd_irq(struct kunit *test)
{
KUNIT_EXPECT_STREQ(test, dmub_notification_type_str(DMUB_NOTIFICATION_HPD_IRQ), "HPD_IRQ");
}
static void dm_test_notification_str_set_config(struct kunit *test)
{
KUNIT_EXPECT_STREQ(test, dmub_notification_type_str(DMUB_NOTIFICATION_SET_CONFIG_REPLY),
"SET_CONFIG_REPLY");
}
static void dm_test_notification_str_dpia(struct kunit *test)
{
KUNIT_EXPECT_STREQ(test, dmub_notification_type_str(DMUB_NOTIFICATION_DPIA_NOTIFICATION),
"DPIA_NOTIFICATION");
}
static void dm_test_notification_str_hpd_sense(struct kunit *test)
{
KUNIT_EXPECT_STREQ(test, dmub_notification_type_str(DMUB_NOTIFICATION_HPD_SENSE_NOTIFY),
"HPD_SENSE_NOTIFY");
}
static void dm_test_notification_str_fused_io(struct kunit *test)
{
KUNIT_EXPECT_STREQ(test, dmub_notification_type_str(DMUB_NOTIFICATION_FUSED_IO),
"FUSED_IO");
}
static void dm_test_notification_str_unknown(struct kunit *test)
{
KUNIT_EXPECT_STREQ(test, dmub_notification_type_str(DMUB_NOTIFICATION_MAX), "<unknown>");
}
static void dm_test_irq_init_initializes_lists(struct kunit *test)
{
struct amdgpu_device *adev;
int src;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
KUNIT_EXPECT_EQ(test, amdgpu_dm_irq_init(adev), 0);
for (src = 0; src < DAL_IRQ_SOURCES_NUMBER; src++) {
KUNIT_EXPECT_TRUE(test,
list_empty(&adev->dm.irq_handler_list_low_tab[src]));
KUNIT_EXPECT_TRUE(test,
list_empty(&adev->dm.irq_handler_list_high_tab[src]));
}
}
static void dm_test_irq_register_rejects_null_params(struct kunit *test)
{
struct amdgpu_device *adev;
struct dc_interrupt_params int_params = { 0 };
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
int_params.int_context = INTERRUPT_LOW_IRQ_CONTEXT;
int_params.irq_source = DC_IRQ_SOURCE_HPD1;
KUNIT_EXPECT_NULL(test,
amdgpu_dm_irq_register_interrupt(adev, NULL,
dm_test_irq_handler, NULL));
KUNIT_EXPECT_NULL(test,
amdgpu_dm_irq_register_interrupt(adev, &int_params, NULL, NULL));
}
static void dm_test_irq_register_rejects_invalid_context(struct kunit *test)
{
struct amdgpu_device *adev;
struct dc_interrupt_params int_params = { 0 };
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
int_params.int_context = INTERRUPT_CONTEXT_NUMBER;
int_params.irq_source = DC_IRQ_SOURCE_HPD1;
KUNIT_EXPECT_NULL(test,
amdgpu_dm_irq_register_interrupt(adev, &int_params,
dm_test_irq_handler, NULL));
}
static void dm_test_irq_register_rejects_invalid_source(struct kunit *test)
{
struct amdgpu_device *adev;
struct dc_interrupt_params int_params = { 0 };
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
int_params.int_context = INTERRUPT_LOW_IRQ_CONTEXT;
int_params.irq_source = DC_IRQ_SOURCE_INVALID;
KUNIT_EXPECT_NULL(test,
amdgpu_dm_irq_register_interrupt(adev, &int_params,
dm_test_irq_handler, NULL));
}
static void dm_test_irq_register_separate_contexts(struct kunit *test)
{
struct amdgpu_device *adev;
struct dc_interrupt_params int_params = { 0 };
void *handler;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
KUNIT_ASSERT_EQ(test, amdgpu_dm_irq_init(adev), 0);
int_params.irq_source = DC_IRQ_SOURCE_HPD5;
int_params.int_context = INTERRUPT_LOW_IRQ_CONTEXT;
handler = amdgpu_dm_irq_register_interrupt(adev, &int_params,
dm_test_irq_handler, adev);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, handler);
int_params.int_context = INTERRUPT_HIGH_IRQ_CONTEXT;
handler = amdgpu_dm_irq_register_interrupt(adev, &int_params,
dm_test_irq_handler, adev);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, handler);
KUNIT_EXPECT_FALSE(test,
list_empty(&adev->dm.irq_handler_list_low_tab[DC_IRQ_SOURCE_HPD5]));
KUNIT_EXPECT_FALSE(test,
list_empty(&adev->dm.irq_handler_list_high_tab[DC_IRQ_SOURCE_HPD5]));
amdgpu_dm_irq_unregister_interrupt(adev, DC_IRQ_SOURCE_HPD5,
dm_test_irq_handler);
KUNIT_EXPECT_TRUE(test,
list_empty(&adev->dm.irq_handler_list_low_tab[DC_IRQ_SOURCE_HPD5]));
KUNIT_EXPECT_FALSE(test,
list_empty(&adev->dm.irq_handler_list_high_tab[DC_IRQ_SOURCE_HPD5]));
amdgpu_dm_irq_unregister_interrupt(adev, DC_IRQ_SOURCE_HPD5,
dm_test_irq_handler);
KUNIT_EXPECT_TRUE(test,
list_empty(&adev->dm.irq_handler_list_high_tab[DC_IRQ_SOURCE_HPD5]));
}
static void dm_test_irq_unregister_rejects_invalid_source(struct kunit *test)
{
struct amdgpu_device *adev;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
KUNIT_ASSERT_EQ(test, amdgpu_dm_irq_init(adev), 0);
amdgpu_dm_irq_unregister_interrupt(adev, DC_IRQ_SOURCE_INVALID,
dm_test_irq_handler);
KUNIT_EXPECT_TRUE(test,
list_empty(&adev->dm.irq_handler_list_low_tab[DC_IRQ_SOURCE_HPD1]));
KUNIT_EXPECT_TRUE(test,
list_empty(&adev->dm.irq_handler_list_high_tab[DC_IRQ_SOURCE_HPD1]));
}
static void dm_test_irq_unregister_rejects_null_handler(struct kunit *test)
{
struct amdgpu_device *adev;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
KUNIT_ASSERT_EQ(test, amdgpu_dm_irq_init(adev), 0);
amdgpu_dm_irq_unregister_interrupt(adev, DC_IRQ_SOURCE_HPD1,
DAL_INVALID_IRQ_HANDLER_IDX);
KUNIT_EXPECT_TRUE(test,
list_empty(&adev->dm.irq_handler_list_low_tab[DC_IRQ_SOURCE_HPD1]));
KUNIT_EXPECT_TRUE(test,
list_empty(&adev->dm.irq_handler_list_high_tab[DC_IRQ_SOURCE_HPD1]));
}
static void dm_test_irq_unregister_handler_not_found(struct kunit *test)
{
struct amdgpu_device *adev;
struct dc_interrupt_params int_params = { 0 };
void *handler;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
KUNIT_ASSERT_EQ(test, amdgpu_dm_irq_init(adev), 0);
int_params.int_context = INTERRUPT_LOW_IRQ_CONTEXT;
int_params.irq_source = DC_IRQ_SOURCE_HPD1;
handler = amdgpu_dm_irq_register_interrupt(adev, &int_params,
dm_test_irq_handler, adev);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, handler);
amdgpu_dm_irq_unregister_interrupt(adev, DC_IRQ_SOURCE_HPD1,
dm_test_irq_handler_alt);
KUNIT_EXPECT_FALSE(test,
list_empty(&adev->dm.irq_handler_list_low_tab[DC_IRQ_SOURCE_HPD1]));
amdgpu_dm_irq_unregister_interrupt(adev, DC_IRQ_SOURCE_HPD1,
dm_test_irq_handler);
KUNIT_EXPECT_TRUE(test,
list_empty(&adev->dm.irq_handler_list_low_tab[DC_IRQ_SOURCE_HPD1]));
}
static void dm_test_irq_fini_removes_registered_handlers(struct kunit *test)
{
struct amdgpu_device *adev;
struct dc_interrupt_params int_params = { 0 };
void *handler;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
KUNIT_ASSERT_EQ(test, amdgpu_dm_irq_init(adev), 0);
int_params.int_context = INTERRUPT_LOW_IRQ_CONTEXT;
int_params.irq_source = DC_IRQ_SOURCE_HPD3;
handler = amdgpu_dm_irq_register_interrupt(adev, &int_params,
dm_test_irq_handler, adev);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, handler);
int_params.int_context = INTERRUPT_HIGH_IRQ_CONTEXT;
int_params.irq_source = DC_IRQ_SOURCE_HPD4;
handler = amdgpu_dm_irq_register_interrupt(adev, &int_params,
dm_test_irq_handler, adev);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, handler);
amdgpu_dm_irq_fini(adev);
KUNIT_EXPECT_TRUE(test,
list_empty(&adev->dm.irq_handler_list_low_tab[DC_IRQ_SOURCE_HPD3]));
KUNIT_EXPECT_TRUE(test,
list_empty(&adev->dm.irq_handler_list_high_tab[DC_IRQ_SOURCE_HPD4]));
}
static void dm_test_irq_fini_on_empty_tables(struct kunit *test)
{
struct amdgpu_device *adev;
int src;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
KUNIT_ASSERT_EQ(test, amdgpu_dm_irq_init(adev), 0);
amdgpu_dm_irq_fini(adev);
for (src = 0; src < DAL_IRQ_SOURCES_NUMBER; src++) {
KUNIT_EXPECT_TRUE(test,
list_empty(&adev->dm.irq_handler_list_low_tab[src]));
KUNIT_EXPECT_TRUE(test,
list_empty(&adev->dm.irq_handler_list_high_tab[src]));
}
}
static void dm_test_get_crtc_by_otg_inst_returns_match(struct kunit *test)
{
struct amdgpu_crtc *acrtc_a, *acrtc_b;
struct amdgpu_device *adev;
struct drm_device *drm;
adev = dm_kunit_alloc_adev(test);
drm = &adev->ddev;
acrtc_a = kunit_kzalloc(test, sizeof(*acrtc_a), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, acrtc_a);
acrtc_b = kunit_kzalloc(test, sizeof(*acrtc_b), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, acrtc_b);
INIT_LIST_HEAD(&acrtc_a->base.head);
INIT_LIST_HEAD(&acrtc_b->base.head);
acrtc_a->otg_inst = 1;
acrtc_b->otg_inst = 3;
list_add_tail(&acrtc_a->base.head, &drm->mode_config.crtc_list);
KUNIT_ASSERT_EQ(test, kunit_add_action_or_reset(test, dm_test_crtc_list_del, acrtc_a), 0);
list_add_tail(&acrtc_b->base.head, &drm->mode_config.crtc_list);
KUNIT_ASSERT_EQ(test, kunit_add_action_or_reset(test, dm_test_crtc_list_del, acrtc_b), 0);
KUNIT_EXPECT_PTR_EQ(test, amdgpu_dm_get_crtc_by_otg_inst(adev, 3), acrtc_b);
}
static void dm_test_get_crtc_by_otg_inst_returns_null(struct kunit *test)
{
struct amdgpu_crtc *acrtc;
struct amdgpu_device *adev;
struct drm_device *drm;
adev = dm_kunit_alloc_adev(test);
drm = &adev->ddev;
acrtc = kunit_kzalloc(test, sizeof(*acrtc), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, acrtc);
INIT_LIST_HEAD(&acrtc->base.head);
acrtc->otg_inst = 2;
list_add_tail(&acrtc->base.head, &drm->mode_config.crtc_list);
KUNIT_ASSERT_EQ(test, kunit_add_action_or_reset(test, dm_test_crtc_list_del, acrtc), 0);
KUNIT_EXPECT_NULL(test, amdgpu_dm_get_crtc_by_otg_inst(adev, 5));
}
static void dm_test_get_crtc_by_otg_inst_empty_list(struct kunit *test)
{
struct amdgpu_device *adev;
adev = dm_kunit_alloc_adev(test);
KUNIT_EXPECT_NULL(test, amdgpu_dm_get_crtc_by_otg_inst(adev, 0));
}
static void dm_test_get_crtc_by_otg_inst_unassigned_otg(struct kunit *test)
{
struct amdgpu_device *adev;
struct amdgpu_crtc *acrtc;
adev = dm_kunit_alloc_adev(test);
acrtc = kunit_kzalloc(test, sizeof(*acrtc), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, acrtc);
adev->mode_info.crtcs[0] = acrtc;
KUNIT_EXPECT_PTR_EQ(test, amdgpu_dm_get_crtc_by_otg_inst(adev, -1), acrtc);
}
static void dm_test_set_irq_funcs(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.num_crtc = 6;
adev->mode_info.num_hpd = 4;
amdgpu_dm_set_irq_funcs(adev);
KUNIT_EXPECT_EQ(test, adev->crtc_irq.num_types, 6);
KUNIT_EXPECT_EQ(test, adev->vline0_irq.num_types, 6);
KUNIT_EXPECT_EQ(test, adev->vupdate_irq.num_types, 6);
KUNIT_EXPECT_EQ(test, adev->pageflip_irq.num_types, 6);
KUNIT_EXPECT_EQ(test, adev->dmub_outbox_irq.num_types, 1);
KUNIT_EXPECT_EQ(test, adev->dmub_trace_irq.num_types, 1);
KUNIT_EXPECT_EQ(test, adev->hpd_irq.num_types, 4);
KUNIT_EXPECT_TRUE(test, adev->crtc_irq.funcs != NULL);
KUNIT_EXPECT_TRUE(test, adev->vline0_irq.funcs != NULL);
KUNIT_EXPECT_TRUE(test, adev->dmub_outbox_irq.funcs != NULL);
KUNIT_EXPECT_TRUE(test, adev->vupdate_irq.funcs != NULL);
KUNIT_EXPECT_TRUE(test, adev->dmub_trace_irq.funcs != NULL);
KUNIT_EXPECT_TRUE(test, adev->pageflip_irq.funcs != NULL);
KUNIT_EXPECT_TRUE(test, adev->hpd_irq.funcs != NULL);
}
static void dm_test_irq_suspend_empty(struct kunit *test)
{
struct amdgpu_device *adev;
int src;
adev = dm_kunit_alloc_adev(test);
KUNIT_ASSERT_EQ(test, amdgpu_dm_irq_init(adev), 0);
amdgpu_dm_irq_suspend(adev);
for (src = 0; src < DAL_IRQ_SOURCES_NUMBER; src++) {
KUNIT_EXPECT_TRUE(test, list_empty(&adev->dm.irq_handler_list_low_tab[src]));
KUNIT_EXPECT_TRUE(test, list_empty(&adev->dm.irq_handler_list_high_tab[src]));
}
}
static void dm_test_irq_resume_early_empty(struct kunit *test)
{
struct amdgpu_device *adev;
int src;
adev = dm_kunit_alloc_adev(test);
KUNIT_ASSERT_EQ(test, amdgpu_dm_irq_init(adev), 0);
amdgpu_dm_irq_resume_early(adev);
for (src = 0; src < DAL_IRQ_SOURCES_NUMBER; src++)
KUNIT_EXPECT_TRUE(test, list_empty(&adev->dm.irq_handler_list_high_tab[src]));
}
static void dm_test_irq_resume_late_empty(struct kunit *test)
{
struct amdgpu_device *adev;
int src;
adev = dm_kunit_alloc_adev(test);
KUNIT_ASSERT_EQ(test, amdgpu_dm_irq_init(adev), 0);
amdgpu_dm_irq_resume_late(adev);
for (src = 0; src < DAL_IRQ_SOURCES_NUMBER; src++)
KUNIT_EXPECT_TRUE(test, list_empty(&adev->dm.irq_handler_list_low_tab[src]));
}
static void dm_test_irq_suspend_registered(struct kunit *test)
{
struct dc_interrupt_params int_params = { 0 };
struct amdgpu_device *adev;
void *handler;
adev = dm_kunit_alloc_adev(test);
KUNIT_ASSERT_EQ(test, amdgpu_dm_irq_init(adev), 0);
int_params.int_context = INTERRUPT_LOW_IRQ_CONTEXT;
int_params.irq_source = DC_IRQ_SOURCE_HPD1;
handler = amdgpu_dm_irq_register_interrupt(adev, &int_params,
dm_test_irq_handler, adev);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, handler);
amdgpu_dm_irq_suspend(adev);
amdgpu_dm_irq_unregister_interrupt(adev, DC_IRQ_SOURCE_HPD1,
dm_test_irq_handler);
}
static void dm_test_irq_suspend_disables_polling(struct kunit *test)
{
struct amdgpu_device *adev;
adev = dm_kunit_alloc_adev(test);
KUNIT_ASSERT_EQ(test, amdgpu_dm_irq_init(adev), 0);
drm_kms_helper_poll_init(&adev->ddev);
KUNIT_ASSERT_TRUE(test, adev->ddev.mode_config.poll_enabled);
amdgpu_dm_irq_suspend(adev);
KUNIT_EXPECT_TRUE(test, adev->ddev.mode_config.poll_enabled);
drm_kms_helper_poll_fini(&adev->ddev);
}
static void dm_test_irq_resume_early_registered(struct kunit *test)
{
struct dc_interrupt_params int_params = { 0 };
struct amdgpu_device *adev;
void *handler;
adev = dm_kunit_alloc_adev(test);
KUNIT_ASSERT_EQ(test, amdgpu_dm_irq_init(adev), 0);
int_params.int_context = INTERRUPT_LOW_IRQ_CONTEXT;
int_params.irq_source = DC_IRQ_SOURCE_HPD1RX;
handler = amdgpu_dm_irq_register_interrupt(adev, &int_params,
dm_test_irq_handler, adev);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, handler);
amdgpu_dm_irq_resume_early(adev);
amdgpu_dm_irq_unregister_interrupt(adev, DC_IRQ_SOURCE_HPD1RX,
dm_test_irq_handler);
}
static void dm_test_irq_resume_late_registered(struct kunit *test)
{
struct dc_interrupt_params int_params = { 0 };
struct amdgpu_device *adev;
void *handler;
adev = dm_kunit_alloc_adev(test);
KUNIT_ASSERT_EQ(test, amdgpu_dm_irq_init(adev), 0);
int_params.int_context = INTERRUPT_LOW_IRQ_CONTEXT;
int_params.irq_source = DC_IRQ_SOURCE_HPD1;
handler = amdgpu_dm_irq_register_interrupt(adev, &int_params,
dm_test_irq_handler, adev);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, handler);
amdgpu_dm_irq_resume_late(adev);
amdgpu_dm_irq_unregister_interrupt(adev, DC_IRQ_SOURCE_HPD1,
dm_test_irq_handler);
}
static void dm_test_irq_resume_late_enables_polling(struct kunit *test)
{
struct amdgpu_device *adev;
adev = dm_kunit_alloc_adev(test);
KUNIT_ASSERT_EQ(test, amdgpu_dm_irq_init(adev), 0);
drm_kms_helper_poll_init(&adev->ddev);
KUNIT_ASSERT_TRUE(test, adev->ddev.mode_config.poll_enabled);
amdgpu_dm_irq_resume_late(adev);
KUNIT_EXPECT_TRUE(test, adev->ddev.mode_config.poll_enabled);
drm_kms_helper_poll_fini(&adev->ddev);
}
static void dm_test_hpd_rx_irq_create_workqueue(struct kunit *test)
{
struct dm_test_hpd_rx_wq_ctx *ctx;
struct amdgpu_device *adev;
struct dc *dc;
int i;
adev = dm_kunit_alloc_adev(test);
dc = kunit_kzalloc(test, sizeof(*dc), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dc);
dc->caps.max_links = 4;
adev->dm.dc = dc;
ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx);
ctx->wq = amdgpu_dm_hpd_rx_irq_create_workqueue(adev);
KUNIT_ASSERT_NOT_NULL(test, ctx->wq);
ctx->count = dc->caps.max_links;
KUNIT_ASSERT_EQ(test, kunit_add_action_or_reset(test, dm_test_destroy_hpd_rx_wq, ctx), 0);
for (i = 0; i < dc->caps.max_links; i++)
KUNIT_EXPECT_TRUE(test, ctx->wq[i].wq != NULL);
}
static void dm_test_hpd_rx_irq_work_suspend_null(struct kunit *test)
{
struct amdgpu_display_manager *dm;
dm = kunit_kzalloc(test, sizeof(*dm), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dm);
amdgpu_dm_hpd_rx_irq_work_suspend(dm);
}
static void dm_test_hpd_rx_irq_work_suspend_flushes(struct kunit *test)
{
struct dm_test_hpd_rx_wq_ctx *ctx;
struct amdgpu_device *adev;
struct dc *dc;
adev = dm_kunit_alloc_adev(test);
dc = kunit_kzalloc(test, sizeof(*dc), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dc);
dc->caps.max_links = 2;
adev->dm.dc = dc;
ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx);
ctx->wq = amdgpu_dm_hpd_rx_irq_create_workqueue(adev);
KUNIT_ASSERT_NOT_NULL(test, ctx->wq);
ctx->count = dc->caps.max_links;
KUNIT_ASSERT_EQ(test, kunit_add_action_or_reset(test, dm_test_destroy_hpd_rx_wq, ctx), 0);
adev->dm.hpd_rx_offload_wq = ctx->wq;
amdgpu_dm_hpd_rx_irq_work_suspend(&adev->dm);
}
static void dm_test_set_crtc_irq_state_no_crtc(struct kunit *test)
{
struct amdgpu_device *adev;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
KUNIT_EXPECT_EQ(test,
amdgpu_dm_set_crtc_irq_state(adev, NULL, 0, AMDGPU_IRQ_STATE_ENABLE), 0);
}
static void dm_test_set_pflip_irq_state_no_crtc(struct kunit *test)
{
struct amdgpu_device *adev;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
KUNIT_EXPECT_EQ(test,
amdgpu_dm_set_pflip_irq_state(adev, NULL, 0, AMDGPU_IRQ_STATE_DISABLE), 0);
}
static void dm_test_set_vline0_irq_state_no_crtc(struct kunit *test)
{
struct amdgpu_device *adev;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
KUNIT_EXPECT_EQ(test,
amdgpu_dm_set_vline0_irq_state(adev, NULL, 0, AMDGPU_IRQ_STATE_ENABLE), 0);
}
static void dm_test_set_vupdate_irq_state_no_crtc(struct kunit *test)
{
struct amdgpu_device *adev;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
KUNIT_EXPECT_EQ(test,
amdgpu_dm_set_vupdate_irq_state(adev, NULL, 0, AMDGPU_IRQ_STATE_ENABLE), 0);
}
static void dm_test_set_crtc_irq_state_otg_disabled(struct kunit *test)
{
struct amdgpu_device *adev;
struct amdgpu_crtc *acrtc;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
acrtc = kunit_kzalloc(test, sizeof(*acrtc), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, acrtc);
acrtc->otg_inst = -1;
adev->mode_info.crtcs[0] = acrtc;
KUNIT_EXPECT_EQ(test,
amdgpu_dm_set_crtc_irq_state(adev, NULL, 0, AMDGPU_IRQ_STATE_ENABLE), 0);
}
static void dm_test_set_crtc_irq_state_enable(struct kunit *test)
{
struct amdgpu_device *adev;
struct amdgpu_crtc *acrtc;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
acrtc = kunit_kzalloc(test, sizeof(*acrtc), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, acrtc);
acrtc->otg_inst = 3;
adev->mode_info.crtcs[0] = acrtc;
KUNIT_EXPECT_EQ(test,
amdgpu_dm_set_crtc_irq_state(adev, NULL, 0, AMDGPU_IRQ_STATE_ENABLE), 0);
}
static void dm_test_set_pflip_irq_state_disable(struct kunit *test)
{
struct amdgpu_device *adev;
struct amdgpu_crtc *acrtc;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
acrtc = kunit_kzalloc(test, sizeof(*acrtc), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, acrtc);
acrtc->otg_inst = 1;
adev->mode_info.crtcs[0] = acrtc;
KUNIT_EXPECT_EQ(test,
amdgpu_dm_set_pflip_irq_state(adev, NULL, 0, AMDGPU_IRQ_STATE_DISABLE), 0);
}
static void dm_test_set_crtc_irq_state_allows_idle(struct kunit *test)
{
struct amdgpu_device *adev;
struct amdgpu_crtc *acrtc;
struct dal_logger *logger;
struct dc *dc;
adev = dm_kunit_alloc_adev(test);
acrtc = kunit_kzalloc(test, sizeof(*acrtc), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, acrtc);
dc = dm_test_alloc_dc_with_irq_service(test, &dm_test_irq_service_funcs_dcn10);
logger = kunit_kzalloc(test, sizeof(*logger), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, logger);
logger->dev = &adev->ddev;
dc->ctx->logger = logger;
dc->caps.ips_support = true;
dc->idle_optimizations_allowed = true;
dc->debug.disable_idle_power_optimizations = true;
adev->dm.dc = dc;
acrtc->otg_inst = 0;
adev->mode_info.crtcs[0] = acrtc;
KUNIT_EXPECT_EQ(test,
amdgpu_dm_set_crtc_irq_state(adev, NULL, 0, AMDGPU_IRQ_STATE_ENABLE), 0);
}
static void dm_test_irq_immediate_work_empty(struct kunit *test)
{
struct amdgpu_device *adev;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
KUNIT_ASSERT_EQ(test, amdgpu_dm_irq_init(adev), 0);
amdgpu_dm_irq_immediate_work(adev, DC_IRQ_SOURCE_HPD1);
}
static void dm_test_irq_immediate_work_invokes_all(struct kunit *test)
{
struct amdgpu_device *adev;
struct dc_interrupt_params int_params = { 0 };
int count = 0;
void *handler;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
KUNIT_ASSERT_EQ(test, amdgpu_dm_irq_init(adev), 0);
int_params.int_context = INTERRUPT_HIGH_IRQ_CONTEXT;
int_params.irq_source = DC_IRQ_SOURCE_HPD2;
handler = amdgpu_dm_irq_register_interrupt(adev, &int_params,
dm_test_irq_handler_count, &count);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, handler);
handler = amdgpu_dm_irq_register_interrupt(adev, &int_params,
dm_test_irq_handler_count, &count);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, handler);
amdgpu_dm_irq_immediate_work(adev, DC_IRQ_SOURCE_HPD2);
KUNIT_EXPECT_EQ(test, count, 2);
amdgpu_dm_irq_unregister_interrupt(adev, DC_IRQ_SOURCE_HPD2, dm_test_irq_handler_count);
amdgpu_dm_irq_unregister_interrupt(adev, DC_IRQ_SOURCE_HPD2, dm_test_irq_handler_count);
}
static void dm_test_irq_schedule_work_empty(struct kunit *test)
{
struct amdgpu_device *adev;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
KUNIT_ASSERT_EQ(test, amdgpu_dm_irq_init(adev), 0);
amdgpu_dm_irq_schedule_work(adev, DC_IRQ_SOURCE_HPD1);
}
static void dm_test_irq_schedule_work_queues_handler(struct kunit *test)
{
struct amdgpu_device *adev;
struct dc_interrupt_params int_params = { 0 };
int count = 0;
void *handler;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
KUNIT_ASSERT_EQ(test, amdgpu_dm_irq_init(adev), 0);
int_params.int_context = INTERRUPT_LOW_IRQ_CONTEXT;
int_params.irq_source = DC_IRQ_SOURCE_HPD1;
handler = amdgpu_dm_irq_register_interrupt(adev, &int_params,
dm_test_irq_handler_count, &count);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, handler);
amdgpu_dm_irq_schedule_work(adev, DC_IRQ_SOURCE_HPD1);
flush_workqueue(adev->dm.irq_wq);
KUNIT_EXPECT_EQ(test, count, 1);
amdgpu_dm_irq_fini(adev);
}
static void dm_test_irq_schedule_work_requeue_fallback(struct kunit *test)
{
struct dc_interrupt_params int_params = { 0 };
struct amdgpu_device *adev;
int count = 0;
void *handler;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
KUNIT_ASSERT_EQ(test, amdgpu_dm_irq_init(adev), 0);
int_params.int_context = INTERRUPT_LOW_IRQ_CONTEXT;
int_params.irq_source = DC_IRQ_SOURCE_HPD1;
handler = amdgpu_dm_irq_register_interrupt(adev, &int_params,
dm_test_irq_handler_count, &count);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, handler);
amdgpu_dm_irq_schedule_work(adev, DC_IRQ_SOURCE_HPD1);
amdgpu_dm_irq_schedule_work(adev, DC_IRQ_SOURCE_HPD1);
flush_workqueue(adev->dm.irq_wq);
KUNIT_EXPECT_EQ(test, count, 2);
amdgpu_dm_irq_fini(adev);
}
static void dm_test_irq_schedule_work_no_workqueue(struct kunit *test)
{
struct dc_interrupt_params int_params = { 0 };
struct amdgpu_device *adev;
int count = 0;
void *handler;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
KUNIT_ASSERT_EQ(test, amdgpu_dm_irq_init(adev), 0);
int_params.int_context = INTERRUPT_LOW_IRQ_CONTEXT;
int_params.irq_source = DC_IRQ_SOURCE_HPD1;
handler = amdgpu_dm_irq_register_interrupt(adev, &int_params,
dm_test_irq_handler_count, &count);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, handler);
destroy_workqueue(adev->dm.irq_wq);
adev->dm.irq_wq = NULL;
amdgpu_dm_irq_schedule_work(adev, DC_IRQ_SOURCE_HPD1);
KUNIT_EXPECT_EQ(test, count, 0);
amdgpu_dm_irq_fini(adev);
}
static void dm_test_set_hpd_irq_state_null_dc(struct kunit *test)
{
struct amdgpu_device *adev;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
KUNIT_EXPECT_EQ(test, amdgpu_dm_set_hpd_irq_state(adev, NULL, AMDGPU_HPD_1,
AMDGPU_IRQ_STATE_ENABLE), 0);
KUNIT_EXPECT_EQ(test, amdgpu_dm_set_hpd_irq_state(adev, NULL, AMDGPU_HPD_1,
AMDGPU_IRQ_STATE_DISABLE), 0);
}
static void dm_test_set_dmub_outbox_irq_state_null_dc(struct kunit *test)
{
struct amdgpu_device *adev;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
KUNIT_EXPECT_EQ(test, amdgpu_dm_set_dmub_outbox_irq_state(adev, NULL, 0,
AMDGPU_IRQ_STATE_ENABLE), 0);
KUNIT_EXPECT_EQ(test, amdgpu_dm_set_dmub_outbox_irq_state(adev, NULL, 0,
AMDGPU_IRQ_STATE_DISABLE), 0);
}
static void dm_test_set_dmub_trace_irq_state_null_dc(struct kunit *test)
{
struct amdgpu_device *adev;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
KUNIT_EXPECT_EQ(test, amdgpu_dm_set_dmub_trace_irq_state(adev, NULL, 0,
AMDGPU_IRQ_STATE_ENABLE), 0);
KUNIT_EXPECT_EQ(test, amdgpu_dm_set_dmub_trace_irq_state(adev, NULL, 0,
AMDGPU_IRQ_STATE_DISABLE), 0);
}
static void dm_test_outbox_init_null_dc(struct kunit *test)
{
struct amdgpu_device *adev;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
amdgpu_dm_outbox_init(adev);
}
static void dm_test_hpd_init_empty_connectors(struct kunit *test)
{
struct amdgpu_device *adev;
adev = dm_kunit_alloc_adev(test);
amdgpu_dm_hpd_init(adev);
}
static void dm_test_hpd_fini_empty_connectors(struct kunit *test)
{
struct amdgpu_device *adev;
adev = dm_kunit_alloc_adev(test);
amdgpu_dm_hpd_fini(adev);
}
static void dm_test_hpd_init_fini_with_connectors(struct kunit *test)
{
struct amdgpu_dm_connector *aconn;
struct drm_connector *wbconn;
struct amdgpu_device *adev;
struct dc_link *link;
adev = dm_kunit_alloc_adev(test);
adev->mode_info.num_hpd = 0;
wbconn = kunit_kzalloc(test, sizeof(*wbconn), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, wbconn);
KUNIT_ASSERT_EQ(test, drm_connector_init(&adev->ddev, wbconn, &dm_test_connector_funcs,
DRM_MODE_CONNECTOR_WRITEBACK), 0);
KUNIT_ASSERT_EQ(test,
kunit_add_action_or_reset(test, dm_test_connector_cleanup, wbconn), 0);
aconn = kunit_kzalloc(test, sizeof(*aconn), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, aconn);
KUNIT_ASSERT_EQ(test, drm_connector_init(&adev->ddev, &aconn->base,
&dm_test_connector_funcs,
DRM_MODE_CONNECTOR_DisplayPort), 0);
KUNIT_ASSERT_EQ(test,
kunit_add_action_or_reset(test, dm_test_connector_cleanup, &aconn->base), 0);
link = kunit_kzalloc(test, sizeof(*link), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, link);
link->irq_source_hpd = DC_IRQ_SOURCE_HPD1;
link->irq_source_hpd_rx = DC_IRQ_SOURCE_HPD1RX;
aconn->dc_link = link;
amdgpu_dm_hpd_init(adev);
amdgpu_dm_hpd_fini(adev);
}
static void dm_test_hpd_init_fini_analog_connector(struct kunit *test)
{
struct amdgpu_dm_connector *aconn;
struct amdgpu_device *adev;
struct dc_link *link;
adev = dm_kunit_alloc_adev(test);
adev->mode_info.num_hpd = 0;
aconn = kunit_kzalloc(test, sizeof(*aconn), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, aconn);
KUNIT_ASSERT_EQ(test, drm_connector_init(&adev->ddev, &aconn->base,
&dm_test_connector_funcs,
DRM_MODE_CONNECTOR_VGA), 0);
KUNIT_ASSERT_EQ(test,
kunit_add_action_or_reset(test, dm_test_connector_cleanup, &aconn->base), 0);
link = kunit_kzalloc(test, sizeof(*link), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, link);
link->irq_source_hpd = DC_IRQ_SOURCE_HPD1;
link->irq_source_hpd_rx = DC_IRQ_SOURCE_HPD1RX;
link->link_id.id = CONNECTOR_ID_VGA;
aconn->dc_link = link;
amdgpu_dm_hpd_init(adev);
KUNIT_EXPECT_TRUE(test, adev->ddev.mode_config.poll_enabled);
amdgpu_dm_hpd_fini(adev);
KUNIT_EXPECT_FALSE(test, adev->ddev.mode_config.poll_enabled);
}
static void dm_test_hpd_init_fini_irq_ref(struct kunit *test)
{
struct amdgpu_dm_connector *aconn;
struct amdgpu_device *adev;
struct dc_link *link;
adev = dm_kunit_alloc_adev(test);
adev->mode_info.num_hpd = 1;
aconn = kunit_kzalloc(test, sizeof(*aconn), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, aconn);
KUNIT_ASSERT_EQ(test, drm_connector_init(&adev->ddev, &aconn->base,
&dm_test_connector_funcs,
DRM_MODE_CONNECTOR_DisplayPort), 0);
KUNIT_ASSERT_EQ(test,
kunit_add_action_or_reset(test, dm_test_connector_cleanup, &aconn->base), 0);
link = kunit_kzalloc(test, sizeof(*link), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, link);
link->irq_source_hpd = DC_IRQ_SOURCE_HPD1;
link->irq_source_hpd_rx = DC_IRQ_SOURCE_INVALID;
aconn->dc_link = link;
amdgpu_dm_hpd_init(adev);
amdgpu_dm_hpd_fini(adev);
}
static void dm_test_hpd_init_skips_connector_without_link(struct kunit *test)
{
struct amdgpu_dm_connector *aconn;
struct amdgpu_device *adev;
adev = dm_kunit_alloc_adev(test);
adev->mode_info.num_hpd = 0;
aconn = kunit_kzalloc(test, sizeof(*aconn), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, aconn);
KUNIT_ASSERT_EQ(test, drm_connector_init(&adev->ddev, &aconn->base,
&dm_test_connector_funcs,
DRM_MODE_CONNECTOR_DisplayPort), 0);
KUNIT_ASSERT_EQ(test, kunit_add_action_or_reset(test, dm_test_connector_cleanup,
&aconn->base), 0);
amdgpu_dm_hpd_init(adev);
KUNIT_EXPECT_FALSE(test, adev->ddev.mode_config.poll_enabled);
}
static void dm_test_hpd_rx_offload_work_no_connector(struct kunit *test)
{
struct hpd_rx_irq_offload_work_queue *offload_wq;
struct hpd_rx_irq_offload_work *offload_work;
struct amdgpu_device *adev;
adev = dm_kunit_alloc_adev(test);
offload_wq = kunit_kzalloc(test, sizeof(*offload_wq), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, offload_wq);
offload_work = kzalloc_obj(*offload_work);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, offload_work);
offload_work->offload_wq = offload_wq;
offload_work->adev = adev;
INIT_WORK(&offload_work->work, dm_handle_hpd_rx_offload_work);
dm_handle_hpd_rx_offload_work(&offload_work->work);
}
static struct hpd_rx_irq_offload_work *
dm_test_setup_hpd_rx_offload_work(struct kunit *test,
struct link_service **link_srv_out)
{
struct hpd_rx_irq_offload_work_queue *offload_wq;
struct hpd_rx_irq_offload_work *offload_work;
struct amdgpu_dm_connector *aconn;
struct link_service *link_srv;
struct amdgpu_device *adev;
struct dc_context *ctx;
struct dc_link *link;
struct dc *dc;
adev = dm_kunit_alloc_adev(test);
mutex_init(&adev->dm.dc_lock);
adev->reset_domain = kunit_kzalloc(test, sizeof(*adev->reset_domain),
GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev->reset_domain);
offload_wq = kunit_kzalloc(test, sizeof(*offload_wq), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, offload_wq);
spin_lock_init(&offload_wq->offload_lock);
aconn = dm_kunit_alloc_connector(test, adev, NULL);
mutex_init(&aconn->hpd_lock);
offload_wq->aconnector = aconn;
dc = kunit_kzalloc(test, sizeof(*dc), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dc);
ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx);
link_srv = kunit_kzalloc(test, sizeof(*link_srv), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, link_srv);
link = kunit_kzalloc(test, sizeof(*link), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, link);
link_srv->detect_connection_type = dm_test_detect_connection_single;
dc->link_srv = link_srv;
dc->ctx = ctx;
ctx->dc = dc;
link->dc = dc;
link->ctx = ctx;
link->connector_signal = SIGNAL_TYPE_DISPLAY_PORT;
aconn->dc_link = link;
offload_work = kzalloc_obj(*offload_work);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, offload_work);
offload_work->offload_wq = offload_wq;
offload_work->adev = adev;
INIT_WORK(&offload_work->work, dm_handle_hpd_rx_offload_work);
*link_srv_out = link_srv;
return offload_work;
}
static void dm_test_hpd_rx_offload_work_detect_type_fails(struct kunit *test)
{
struct hpd_rx_irq_offload_work *offload_work;
struct link_service *link_srv;
dm_test_automated_test_count = 0;
offload_work = dm_test_setup_hpd_rx_offload_work(test, &link_srv);
link_srv->detect_connection_type = dm_test_detect_connection_fail;
link_srv->dp_handle_automated_test = dm_test_dp_handle_automated_test;
offload_work->data.bytes.device_service_irq.bits.AUTOMATED_TEST = 1;
dm_handle_hpd_rx_offload_work(&offload_work->work);
KUNIT_EXPECT_EQ(test, dm_test_automated_test_count, 0);
}
static void dm_test_hpd_rx_offload_work_in_reset(struct kunit *test)
{
struct hpd_rx_irq_offload_work *offload_work;
struct link_service *link_srv;
dm_test_automated_test_count = 0;
offload_work = dm_test_setup_hpd_rx_offload_work(test, &link_srv);
link_srv->dp_handle_automated_test = dm_test_dp_handle_automated_test;
offload_work->data.bytes.device_service_irq.bits.AUTOMATED_TEST = 1;
atomic_set(&offload_work->adev->reset_domain->in_gpu_reset, 1);
dm_handle_hpd_rx_offload_work(&offload_work->work);
KUNIT_EXPECT_EQ(test, dm_test_automated_test_count, 0);
}
static void dm_test_hpd_rx_offload_work_msg_rdy(struct kunit *test)
{
struct hpd_rx_irq_offload_work *offload_work;
struct amdgpu_dm_connector *aconn;
struct link_service *link_srv;
struct dc_link *link;
offload_work = dm_test_setup_hpd_rx_offload_work(test, &link_srv);
aconn = offload_work->offload_wq->aconnector;
link = aconn->dc_link;
link_srv->get_status = dm_test_get_link_status;
link->link_status.dpcd_caps = &link->dpcd_caps;
mutex_init(&aconn->handle_mst_msg_ready);
aconn->dm_dp_aux.aux.name = "dm_irq_test_msg_rdy_aux";
aconn->dm_dp_aux.aux.transfer = dm_test_aux_transfer_fail;
drm_dp_aux_init(&aconn->dm_dp_aux.aux);
drm_dp_dpcd_set_probe(&aconn->dm_dp_aux.aux, false);
offload_work->offload_wq->is_handling_mst_msg_rdy_event = true;
offload_work->data.bytes.device_service_irq.bits.UP_REQ_MSG_RDY = 1;
dm_handle_hpd_rx_offload_work(&offload_work->work);
KUNIT_EXPECT_FALSE(test, offload_work->offload_wq->is_handling_mst_msg_rdy_event);
}
static void dm_test_hpd_rx_offload_work_automated_test(struct kunit *test)
{
struct hpd_rx_irq_offload_work *offload_work;
struct link_service *link_srv;
dm_test_automated_test_count = 0;
offload_work = dm_test_setup_hpd_rx_offload_work(test, &link_srv);
link_srv->dp_handle_automated_test = dm_test_dp_handle_automated_test;
offload_work->offload_wq->aconnector->dc_link->aux_access_disabled = true;
offload_work->data.bytes.device_service_irq.bits.AUTOMATED_TEST = 1;
dm_handle_hpd_rx_offload_work(&offload_work->work);
KUNIT_EXPECT_EQ(test, dm_test_automated_test_count, 1);
}
static void dm_test_hpd_rx_offload_work_timing_changed(struct kunit *test)
{
struct hpd_rx_irq_offload_work *offload_work;
struct amdgpu_dm_connector *aconn;
struct link_service *link_srv;
offload_work = dm_test_setup_hpd_rx_offload_work(test, &link_srv);
aconn = offload_work->offload_wq->aconnector;
dm_test_register_drm_dev(test, offload_work->adev);
link_srv->dp_handle_automated_test = dm_test_dp_handle_automated_test;
aconn->timing_changed = true;
aconn->dc_link->aux_access_disabled = true;
offload_work->data.bytes.device_service_irq.bits.AUTOMATED_TEST = 1;
aconn->base.force = DRM_FORCE_ON;
dm_handle_hpd_rx_offload_work(&offload_work->work);
KUNIT_EXPECT_EQ(test, aconn->base.force, DRM_FORCE_UNSPECIFIED);
}
static void dm_test_hpd_rx_offload_work_link_loss(struct kunit *test)
{
struct hpd_rx_irq_offload_work *offload_work;
struct link_service *link_srv;
dm_test_handle_link_loss_count = 0;
offload_work = dm_test_setup_hpd_rx_offload_work(test, &link_srv);
link_srv->dp_parse_link_loss_status = dm_test_dp_parse_link_loss_true;
link_srv->dp_should_allow_hpd_rx_irq = dm_test_dp_should_allow_hpd_rx_irq_true;
link_srv->dp_read_hpd_rx_irq_data = dm_test_dp_read_hpd_rx_irq_data_ok;
link_srv->dp_handle_link_loss = dm_test_dp_handle_link_loss;
dm_handle_hpd_rx_offload_work(&offload_work->work);
KUNIT_EXPECT_EQ(test, dm_test_handle_link_loss_count, 1);
}
static struct amdgpu_dm_connector *dm_test_setup_hdmi_debounce(struct kunit *test,
struct link_service **link_srv_out)
{
struct amdgpu_dm_connector *aconn;
struct link_service *link_srv;
struct amdgpu_device *adev;
struct dc_context *ctx;
struct dc_link *link;
struct dc *dc;
adev = dm_kunit_alloc_adev(test);
mutex_init(&adev->dm.dc_lock);
aconn = dm_kunit_alloc_connector(test, adev, NULL);
mutex_init(&aconn->hpd_lock);
INIT_DELAYED_WORK(&aconn->hdmi_hpd_debounce_work,
amdgpu_dm_hdmi_hpd_debounce_work);
dc = kunit_kzalloc(test, sizeof(*dc), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dc);
ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx);
link_srv = kunit_kzalloc(test, sizeof(*link_srv), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, link_srv);
link = kunit_kzalloc(test, sizeof(*link), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, link);
link_srv->detect_link = dm_test_detect_link_false;
dc->ctx = ctx;
dc->link_srv = link_srv;
ctx->dc = dc;
link->dc = dc;
link->ctx = ctx;
aconn->dc_link = link;
*link_srv_out = link_srv;
return aconn;
}
static void dm_test_hdmi_hpd_debounce_detect_false(struct kunit *test)
{
struct amdgpu_dm_connector *aconn;
struct link_service *link_srv;
aconn = dm_test_setup_hdmi_debounce(test, &link_srv);
amdgpu_dm_hdmi_hpd_debounce_work(&aconn->hdmi_hpd_debounce_work.work);
KUNIT_EXPECT_NULL(test, aconn->hdmi_prev_sink);
}
static void dm_test_hdmi_hpd_debounce_reallow_idle(struct kunit *test)
{
struct amdgpu_dm_connector *aconn;
struct link_service *link_srv;
struct dc_dmub_srv *dmub_srv;
struct dal_logger *logger;
struct dc *dc;
aconn = dm_test_setup_hdmi_debounce(test, &link_srv);
dc = aconn->dc_link->ctx->dc;
logger = kunit_kzalloc(test, sizeof(*logger), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, logger);
dmub_srv = kunit_kzalloc(test, sizeof(*dmub_srv), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dmub_srv);
logger->dev = aconn->base.dev;
dc->ctx->logger = logger;
dmub_srv->idle_allowed = true;
dc->ctx->dmub_srv = dmub_srv;
dc->caps.ips_support = true;
dc->debug.disable_idle_power_optimizations = true;
aconn->hdmi_prev_sink = dm_test_sink_create(aconn->dc_link);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, aconn->hdmi_prev_sink);
amdgpu_dm_hdmi_hpd_debounce_work(&aconn->hdmi_hpd_debounce_work.work);
KUNIT_EXPECT_NULL(test, aconn->hdmi_prev_sink);
}
static void dm_test_hdmi_hpd_debounce_sink_unchanged(struct kunit *test)
{
struct amdgpu_dm_connector *aconn;
struct link_service *link_srv;
struct dc_link *link;
aconn = dm_test_setup_hdmi_debounce(test, &link_srv);
link_srv->detect_link = dm_test_detect_link_true;
aconn->mst_mgr.mst_state = true;
link = aconn->dc_link;
link->local_sink = dm_test_sink_create(link);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, link->local_sink);
aconn->hdmi_prev_sink = dm_test_sink_create(link);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, aconn->hdmi_prev_sink);
amdgpu_dm_hdmi_hpd_debounce_work(&aconn->hdmi_hpd_debounce_work.work);
KUNIT_EXPECT_NULL(test, aconn->hdmi_prev_sink);
dm_test_sink_release(link->local_sink);
}
static void dm_test_hdmi_hpd_debounce_sink_changed(struct kunit *test)
{
struct amdgpu_dm_connector *aconn;
struct link_service *link_srv;
aconn = dm_test_setup_hdmi_debounce(test, &link_srv);
dm_test_register_drm_dev(test, drm_to_adev(aconn->base.dev));
link_srv->detect_link = dm_test_detect_link_true;
aconn->mst_mgr.mst_state = true;
aconn->hdmi_prev_sink = dm_test_sink_create(aconn->dc_link);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, aconn->hdmi_prev_sink);
amdgpu_dm_hdmi_hpd_debounce_work(&aconn->hdmi_hpd_debounce_work.work);
KUNIT_EXPECT_NULL(test, aconn->hdmi_prev_sink);
}
static void dm_test_handle_hpd_irq_disabled(struct kunit *test)
{
struct amdgpu_dm_connector *aconn;
struct dm_connector_state *state;
struct amdgpu_device *adev;
struct dc_context *ctx;
struct dc_link *link;
struct dc *dc;
adev = dm_kunit_alloc_adev(test);
adev->dm.disable_hpd_irq = true;
aconn = dm_kunit_alloc_connector(test, adev, NULL);
state = kunit_kzalloc(test, sizeof(*state), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state);
aconn->base.state = &state->base;
dc = kunit_kzalloc(test, sizeof(*dc), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dc);
ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx);
link = kunit_kzalloc(test, sizeof(*link), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, link);
dc->ctx = ctx;
ctx->dc = dc;
link->ctx = ctx;
aconn->dc_link = link;
aconn->fake_enable = true;
handle_hpd_irq_helper(aconn, DETECT_REASON_HPD);
KUNIT_EXPECT_TRUE(test, aconn->fake_enable);
handle_hpd_irq(aconn);
KUNIT_EXPECT_TRUE(test, aconn->fake_enable);
}
static struct amdgpu_dm_connector *dm_test_setup_hpd_irq_helper(struct kunit *test,
struct link_service **link_srv_out)
{
struct amdgpu_dm_connector *aconn;
struct dm_connector_state *state;
struct link_service *link_srv;
struct amdgpu_device *adev;
struct dc_context *ctx;
struct dc_link *link;
struct dc *dc;
adev = dm_kunit_alloc_adev(test);
mutex_init(&adev->dm.dc_lock);
aconn = dm_kunit_alloc_connector(test, adev, NULL);
mutex_init(&aconn->hpd_lock);
INIT_DELAYED_WORK(&aconn->hdmi_hpd_debounce_work,
amdgpu_dm_hdmi_hpd_debounce_work);
state = kunit_kzalloc(test, sizeof(*state), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state);
aconn->base.state = &state->base;
dc = kunit_kzalloc(test, sizeof(*dc), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dc);
ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx);
link_srv = kunit_kzalloc(test, sizeof(*link_srv), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, link_srv);
link = kunit_kzalloc(test, sizeof(*link), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, link);
link_srv->detect_connection_type = dm_test_detect_connection_none;
dc->ctx = ctx;
dc->link_srv = link_srv;
ctx->dc = dc;
link->dc = dc;
link->ctx = ctx;
aconn->dc_link = link;
*link_srv_out = link_srv;
return aconn;
}
static void dm_test_handle_hpd_irq_helper_debounce_schedule(struct kunit *test)
{
struct amdgpu_dm_connector *aconn;
struct link_service *link_srv;
struct dc_link *link;
aconn = dm_test_setup_hpd_irq_helper(test, &link_srv);
link = aconn->dc_link;
aconn->hdmi_hpd_debounce_delay_ms = 100;
link->connector_signal = SIGNAL_TYPE_HDMI_TYPE_A;
link->local_sink = dm_test_sink_create(link);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, link->local_sink);
handle_hpd_irq_helper(aconn, DETECT_REASON_HPD);
KUNIT_EXPECT_PTR_EQ(test, aconn->hdmi_prev_sink, link->local_sink);
cancel_delayed_work_sync(&aconn->hdmi_hpd_debounce_work);
dm_test_sink_release(aconn->hdmi_prev_sink);
dm_test_sink_release(link->local_sink);
}
static void dm_test_handle_hpd_irq_helper_debounce_release_prev(struct kunit *test)
{
struct amdgpu_dm_connector *aconn;
struct link_service *link_srv;
struct dc_link *link;
aconn = dm_test_setup_hpd_irq_helper(test, &link_srv);
link = aconn->dc_link;
aconn->hdmi_hpd_debounce_delay_ms = 100;
link->connector_signal = SIGNAL_TYPE_HDMI_TYPE_A;
link->local_sink = dm_test_sink_create(link);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, link->local_sink);
aconn->hdmi_prev_sink = dm_test_sink_create(link);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, aconn->hdmi_prev_sink);
KUNIT_ASSERT_PTR_NE(test, aconn->hdmi_prev_sink, link->local_sink);
KUNIT_ASSERT_TRUE(test,
schedule_delayed_work(&aconn->hdmi_hpd_debounce_work,
10 * HZ));
handle_hpd_irq_helper(aconn, DETECT_REASON_HPD);
KUNIT_EXPECT_PTR_EQ(test, aconn->hdmi_prev_sink, link->local_sink);
cancel_delayed_work_sync(&aconn->hdmi_hpd_debounce_work);
dm_test_sink_release(aconn->hdmi_prev_sink);
dm_test_sink_release(link->local_sink);
}
static void dm_test_handle_hpd_irq_helper_detect_type_fails(struct kunit *test)
{
struct amdgpu_dm_connector *aconn;
struct link_service *link_srv;
aconn = dm_test_setup_hpd_irq_helper(test, &link_srv);
link_srv->detect_connection_type = dm_test_detect_connection_fail;
link_srv->detect_link = dm_test_detect_link_false;
aconn->fake_enable = true;
handle_hpd_irq_helper(aconn, DETECT_REASON_HPD);
KUNIT_EXPECT_FALSE(test, aconn->fake_enable);
}
static void dm_test_handle_hpd_irq_helper_hdcp_reset(struct kunit *test)
{
struct amdgpu_dm_connector *aconn;
struct hdcp_workqueue *hdcp_work;
struct link_service *link_srv;
aconn = dm_test_setup_hpd_irq_helper(test, &link_srv);
link_srv->detect_link = dm_test_detect_link_false;
hdcp_work = dm_test_alloc_hdcp_workqueue(test);
drm_to_adev(aconn->base.dev)->dm.hdcp_workqueue = hdcp_work;
handle_hpd_irq_helper(aconn, DETECT_REASON_HPD);
KUNIT_EXPECT_TRUE(test, to_dm_connector_state(aconn->base.state)->update_hdcp);
dm_test_flush_hdcp_workqueue(hdcp_work);
}
static void dm_test_handle_hpd_irq_helper_forced_detect(struct kunit *test)
{
struct amdgpu_dm_connector *aconn;
struct link_service *link_srv;
dm_test_detect_link_count = 0;
aconn = dm_test_setup_hpd_irq_helper(test, &link_srv);
dm_test_register_drm_dev(test, drm_to_adev(aconn->base.dev));
link_srv->detect_link = dm_test_detect_link_false_count;
aconn->base.force = DRM_FORCE_ON;
aconn->dc_link->ctx->driver_context = drm_to_adev(aconn->base.dev);
handle_hpd_irq_helper(aconn, DETECT_REASON_HPDRX);
KUNIT_EXPECT_EQ(test, dm_test_detect_link_count, 0);
}
static void dm_test_handle_hpd_irq_helper_detect_true(struct kunit *test)
{
struct amdgpu_dm_connector *aconn;
struct link_service *link_srv;
aconn = dm_test_setup_hpd_irq_helper(test, &link_srv);
dm_test_register_drm_dev(test, drm_to_adev(aconn->base.dev));
link_srv->detect_connection_type = dm_test_detect_connection_single;
link_srv->detect_link = dm_test_detect_link_true;
aconn->mst_mgr.mst_state = true;
aconn->fake_enable = true;
handle_hpd_irq_helper(aconn, DETECT_REASON_HPD);
KUNIT_EXPECT_FALSE(test, aconn->fake_enable);
}
static void dm_test_handle_hpd_irq_helper_debounce_pending(struct kunit *test)
{
struct amdgpu_dm_connector *aconn;
struct link_service *link_srv;
dm_test_detect_link_count = 0;
aconn = dm_test_setup_hpd_irq_helper(test, &link_srv);
link_srv->detect_link = dm_test_detect_link_false_count;
KUNIT_ASSERT_TRUE(test,
schedule_delayed_work(&aconn->hdmi_hpd_debounce_work,
10 * HZ));
handle_hpd_irq_helper(aconn, DETECT_REASON_HPD);
KUNIT_EXPECT_EQ(test, dm_test_detect_link_count, 0);
cancel_delayed_work_sync(&aconn->hdmi_hpd_debounce_work);
}
static void dm_test_handle_hpd_rx_irq_disabled(struct kunit *test)
{
struct hpd_rx_irq_offload_work_queue *offload_wq;
struct amdgpu_dm_connector *aconn;
struct link_service *link_srv;
struct amdgpu_device *adev;
struct dc_context *ctx;
struct dc_link *link;
struct dc *dc;
adev = dm_kunit_alloc_adev(test);
adev->dm.disable_hpd_irq = true;
offload_wq = kunit_kzalloc(test, sizeof(*offload_wq), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, offload_wq);
adev->dm.hpd_rx_offload_wq = offload_wq;
aconn = dm_kunit_alloc_connector(test, adev, NULL);
dc = kunit_kzalloc(test, sizeof(*dc), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dc);
ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx);
link_srv = kunit_kzalloc(test, sizeof(*link_srv), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, link_srv);
link = kunit_kzalloc(test, sizeof(*link), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, link);
link_srv->dp_handle_hpd_rx_irq = dm_test_handle_hpd_rx_no_work;
dc->ctx = ctx;
dc->link_srv = link_srv;
ctx->dc = dc;
link->dc = dc;
link->ctx = ctx;
link->link_index = 0;
aconn->dc_link = link;
handle_hpd_rx_irq(aconn);
}
static void dm_test_schedule_hpd_rx_offload_work(struct kunit *test)
{
struct hpd_rx_irq_offload_work_queue *offload_wq;
struct amdgpu_device *adev;
union hpd_irq_data data = { 0 };
adev = dm_kunit_alloc_adev(test);
offload_wq = kunit_kzalloc(test, sizeof(*offload_wq), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, offload_wq);
offload_wq->wq = create_singlethread_workqueue("dm_irq_test_hpd_rx");
KUNIT_ASSERT_NOT_NULL(test, offload_wq->wq);
schedule_hpd_rx_offload_work(adev, offload_wq, data);
flush_workqueue(offload_wq->wq);
destroy_workqueue(offload_wq->wq);
}
static void dm_test_destroy_offload_wq(void *data)
{
struct workqueue_struct *wq = data;
flush_workqueue(wq);
destroy_workqueue(wq);
}
static struct amdgpu_dm_connector *dm_test_setup_hpd_rx_irq(struct kunit *test,
struct link_service **link_srv_out)
{
struct hpd_rx_irq_offload_work_queue *offload_wq;
struct amdgpu_dm_connector *aconn;
struct link_service *link_srv;
struct amdgpu_device *adev;
struct dc_context *ctx;
struct dc_link *link;
struct dc *dc;
adev = dm_kunit_alloc_adev(test);
mutex_init(&adev->dm.dc_lock);
offload_wq = kunit_kzalloc(test, sizeof(*offload_wq), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, offload_wq);
spin_lock_init(&offload_wq->offload_lock);
offload_wq->wq = create_singlethread_workqueue("dm_irq_test_hpd_rx");
KUNIT_ASSERT_NOT_NULL(test, offload_wq->wq);
KUNIT_ASSERT_EQ(test, kunit_add_action_or_reset(test, dm_test_destroy_offload_wq,
offload_wq->wq), 0);
adev->dm.hpd_rx_offload_wq = offload_wq;
aconn = dm_kunit_alloc_connector(test, adev, NULL);
mutex_init(&aconn->hpd_lock);
aconn->mst_mgr.mst_state = true;
dc = kunit_kzalloc(test, sizeof(*dc), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dc);
ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx);
link_srv = kunit_kzalloc(test, sizeof(*link_srv), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, link_srv);
link = kunit_kzalloc(test, sizeof(*link), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, link);
dc->ctx = ctx;
dc->link_srv = link_srv;
ctx->dc = dc;
link->dc = dc;
link->ctx = ctx;
link->link_index = 0;
link->type = dc_connection_mst_branch;
aconn->dc_link = link;
*link_srv_out = link_srv;
return aconn;
}
static void dm_test_handle_hpd_rx_irq_automated_test(struct kunit *test)
{
struct amdgpu_dm_connector *aconn;
struct link_service *link_srv;
aconn = dm_test_setup_hpd_rx_irq(test, &link_srv);
link_srv->dp_handle_hpd_rx_irq = dm_test_handle_hpd_rx_automated;
handle_hpd_rx_irq(aconn);
}
static void dm_test_handle_hpd_rx_irq_msg_rdy(struct kunit *test)
{
struct amdgpu_dm_connector *aconn;
struct link_service *link_srv;
aconn = dm_test_setup_hpd_rx_irq(test, &link_srv);
link_srv->dp_handle_hpd_rx_irq = dm_test_handle_hpd_rx_msg_rdy;
link_srv->dp_should_allow_hpd_rx_irq = dm_test_allow_hpd_rx_irq_true;
handle_hpd_rx_irq(aconn);
KUNIT_EXPECT_TRUE(test, drm_to_adev(aconn->base.dev)
->dm.hpd_rx_offload_wq->is_handling_mst_msg_rdy_event);
}
static void dm_test_handle_hpd_rx_irq_link_loss(struct kunit *test)
{
struct amdgpu_dm_connector *aconn;
struct link_service *link_srv;
aconn = dm_test_setup_hpd_rx_irq(test, &link_srv);
link_srv->dp_handle_hpd_rx_irq = dm_test_handle_hpd_rx_link_loss;
link_srv->dp_should_allow_hpd_rx_irq = dm_test_allow_hpd_rx_irq_true;
handle_hpd_rx_irq(aconn);
KUNIT_EXPECT_TRUE(test, drm_to_adev(aconn->base.dev)
->dm.hpd_rx_offload_wq->is_handling_link_loss);
}
static void dm_test_handle_hpd_rx_irq_detect_type_fails(struct kunit *test)
{
struct amdgpu_dm_connector *aconn;
struct link_service *link_srv;
dm_test_detect_link_count = 0;
aconn = dm_test_setup_hpd_rx_irq(test, &link_srv);
link_srv->dp_handle_hpd_rx_irq = dm_test_handle_hpd_rx_result_true;
link_srv->detect_connection_type = dm_test_detect_connection_fail;
link_srv->detect_link = dm_test_detect_link_false_count;
aconn->mst_mgr.mst_state = false;
aconn->dc_link->type = dc_connection_single;
handle_hpd_rx_irq(aconn);
KUNIT_EXPECT_EQ(test, dm_test_detect_link_count, 1);
}
static void dm_test_handle_hpd_rx_irq_forced_detect(struct kunit *test)
{
struct amdgpu_dm_connector *aconn;
struct link_service *link_srv;
dm_test_detect_link_count = 0;
aconn = dm_test_setup_hpd_rx_irq(test, &link_srv);
dm_test_register_drm_dev(test, drm_to_adev(aconn->base.dev));
link_srv->dp_handle_hpd_rx_irq = dm_test_handle_hpd_rx_result_true;
link_srv->detect_connection_type = dm_test_detect_connection_none;
link_srv->detect_link = dm_test_detect_link_false_count;
aconn->mst_mgr.mst_state = false;
aconn->base.force = DRM_FORCE_ON;
aconn->dc_link->ctx->driver_context = drm_to_adev(aconn->base.dev);
aconn->fake_enable = true;
handle_hpd_rx_irq(aconn);
KUNIT_EXPECT_FALSE(test, aconn->fake_enable);
KUNIT_EXPECT_EQ(test, dm_test_detect_link_count, 0);
}
static void dm_test_handle_hpd_rx_irq_detect_true(struct kunit *test)
{
struct amdgpu_dm_connector *aconn;
struct link_service *link_srv;
aconn = dm_test_setup_hpd_rx_irq(test, &link_srv);
dm_test_register_drm_dev(test, drm_to_adev(aconn->base.dev));
link_srv->dp_handle_hpd_rx_irq = dm_test_handle_hpd_rx_result_true;
link_srv->detect_connection_type = dm_test_detect_connection_single;
link_srv->detect_link = dm_test_detect_link_true;
aconn->mst_mgr.mst_state = false;
aconn->fake_enable = true;
handle_hpd_rx_irq(aconn);
KUNIT_EXPECT_FALSE(test, aconn->fake_enable);
}
static void dm_test_handle_hpd_rx_irq_cp_irq(struct kunit *test)
{
struct amdgpu_dm_connector *aconn;
struct hdcp_workqueue *hdcp_work;
struct link_service *link_srv;
aconn = dm_test_setup_hpd_rx_irq(test, &link_srv);
link_srv->dp_handle_hpd_rx_irq = dm_test_handle_hpd_rx_cp_irq;
hdcp_work = dm_test_alloc_hdcp_workqueue(test);
drm_to_adev(aconn->base.dev)->dm.hdcp_workqueue = hdcp_work;
handle_hpd_rx_irq(aconn);
dm_test_flush_hdcp_workqueue(hdcp_work);
}
static void dm_test_dmub_hpd_callback_null_inputs(struct kunit *test)
{
struct amdgpu_device *adev;
adev = dm_kunit_alloc_adev(test);
dmub_hpd_callback(NULL, NULL);
dmub_hpd_callback(adev, NULL);
}
static void dm_test_dmub_hpd_callback_invalid_index(struct kunit *test)
{
struct dmub_notification notify = { 0 };
struct amdgpu_device *adev;
struct dc *dc;
adev = dm_kunit_alloc_adev(test);
dc = kunit_kzalloc(test, sizeof(*dc), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dc);
adev->dm.dc = dc;
notify.link_index = 1;
dmub_hpd_callback(adev, ¬ify);
}
static void dm_test_dmub_hpd_callback_empty_connectors(struct kunit *test)
{
struct dmub_notification notify = { 0 };
struct amdgpu_device *adev;
struct dc *dc;
adev = dm_kunit_alloc_adev(test);
dc = kunit_kzalloc(test, sizeof(*dc), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dc);
adev->dm.dc = dc;
adev->dm.ddev = &adev->ddev;
dc->link_count = 1;
notify.type = DMUB_NOTIFICATION_HPD_SENSE_NOTIFY;
dmub_hpd_callback(adev, ¬ify);
dmub_hpd_sense_callback(adev, ¬ify);
}
static void dm_test_dmub_hpd_callback_suspend_skip(struct kunit *test)
{
struct dmub_notification notify = { 0 };
struct amdgpu_device *adev;
struct dc *dc;
adev = dm_kunit_alloc_adev(test);
dc = kunit_kzalloc(test, sizeof(*dc), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dc);
adev->dm.dc = dc;
adev->in_suspend = true;
dc->link_count = 1;
notify.type = DMUB_NOTIFICATION_HPD;
dmub_hpd_callback(adev, ¬ify);
}
static void dm_test_dmub_hpd_callback_unknown_type_match(struct kunit *test)
{
struct dmub_notification notify = { 0 };
struct amdgpu_dm_connector *aconn;
struct drm_connector *wbconn;
struct amdgpu_device *adev;
struct dc_link *link;
struct dc *dc;
adev = dm_kunit_alloc_adev(test);
dc = kunit_kzalloc(test, sizeof(*dc), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dc);
adev->dm.dc = dc;
adev->dm.ddev = &adev->ddev;
dc->link_count = 1;
link = kunit_kzalloc(test, sizeof(*link), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, link);
dc->links[0] = link;
wbconn = kunit_kzalloc(test, sizeof(*wbconn), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, wbconn);
KUNIT_ASSERT_EQ(test, drm_connector_init(&adev->ddev, wbconn, &dm_test_connector_funcs,
DRM_MODE_CONNECTOR_WRITEBACK), 0);
KUNIT_ASSERT_EQ(test, kunit_add_action_or_reset(test, dm_test_connector_cleanup, wbconn), 0);
aconn = kunit_kzalloc(test, sizeof(*aconn), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, aconn);
KUNIT_ASSERT_EQ(test, drm_connector_init(&adev->ddev, &aconn->base,
&dm_test_connector_funcs,
DRM_MODE_CONNECTOR_DisplayPort), 0);
KUNIT_ASSERT_EQ(test,
kunit_add_action_or_reset(test, dm_test_connector_cleanup, &aconn->base), 0);
aconn->dc_link = link;
notify.link_index = 0;
notify.type = DMUB_NOTIFICATION_HPD_SENSE_NOTIFY;
dmub_hpd_callback(adev, ¬ify);
}
static void dm_test_dmub_hpd_callback_hpd_type(struct kunit *test)
{
struct dmub_notification notify = { 0 };
struct amdgpu_dm_connector *aconn;
struct link_service *link_srv;
struct amdgpu_device *adev;
struct dc_context *ctx;
struct dc_link *link;
struct dc *dc;
adev = dm_kunit_alloc_adev(test);
mutex_init(&adev->dm.dc_lock);
dc = kunit_kzalloc(test, sizeof(*dc), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dc);
ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx);
link_srv = kunit_kzalloc(test, sizeof(*link_srv), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, link_srv);
link = kunit_kzalloc(test, sizeof(*link), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, link);
link_srv->detect_connection_type = dm_test_detect_connection_none;
link_srv->detect_link = dm_test_detect_link_false;
dc->ctx = ctx;
dc->link_srv = link_srv;
ctx->dc = dc;
link->dc = dc;
link->ctx = ctx;
adev->dm.dc = dc;
adev->dm.ddev = &adev->ddev;
dc->link_count = 1;
dc->links[0] = link;
aconn = kunit_kzalloc(test, sizeof(*aconn), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, aconn);
KUNIT_ASSERT_EQ(test, drm_connector_init(&adev->ddev, &aconn->base,
&dm_test_connector_funcs,
DRM_MODE_CONNECTOR_DisplayPort), 0);
KUNIT_ASSERT_EQ(test,
kunit_add_action_or_reset(test, dm_test_connector_cleanup, &aconn->base), 0);
mutex_init(&aconn->hpd_lock);
INIT_DELAYED_WORK(&aconn->hdmi_hpd_debounce_work,
amdgpu_dm_hdmi_hpd_debounce_work);
aconn->dc_link = link;
notify.link_index = 0;
notify.type = DMUB_NOTIFICATION_HPD;
dmub_hpd_callback(adev, ¬ify);
}
static void dm_test_dmub_hpd_callback_hpd_irq_type(struct kunit *test)
{
struct hpd_rx_irq_offload_work_queue *offload_wq;
struct dmub_notification notify = { 0 };
struct amdgpu_dm_connector *aconn;
struct link_service *link_srv;
struct amdgpu_device *adev;
struct dc_context *ctx;
struct dc_link *link;
struct dc *dc;
adev = dm_kunit_alloc_adev(test);
mutex_init(&adev->dm.dc_lock);
offload_wq = kunit_kzalloc(test, sizeof(*offload_wq), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, offload_wq);
spin_lock_init(&offload_wq->offload_lock);
adev->dm.hpd_rx_offload_wq = offload_wq;
dc = kunit_kzalloc(test, sizeof(*dc), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dc);
ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx);
link_srv = kunit_kzalloc(test, sizeof(*link_srv), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, link_srv);
link = kunit_kzalloc(test, sizeof(*link), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, link);
link_srv->dp_handle_hpd_rx_irq = dm_test_handle_hpd_rx_no_work;
dc->ctx = ctx;
dc->link_srv = link_srv;
ctx->dc = dc;
link->dc = dc;
link->ctx = ctx;
link->link_index = 0;
link->type = dc_connection_mst_branch;
adev->dm.dc = dc;
adev->dm.ddev = &adev->ddev;
dc->link_count = 1;
dc->links[0] = link;
aconn = kunit_kzalloc(test, sizeof(*aconn), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, aconn);
KUNIT_ASSERT_EQ(test, drm_connector_init(&adev->ddev, &aconn->base,
&dm_test_connector_funcs,
DRM_MODE_CONNECTOR_DisplayPort), 0);
KUNIT_ASSERT_EQ(test,
kunit_add_action_or_reset(test, dm_test_connector_cleanup, &aconn->base), 0);
mutex_init(&aconn->hpd_lock);
aconn->mst_mgr.mst_state = true;
aconn->dc_link = link;
notify.link_index = 0;
notify.type = DMUB_NOTIFICATION_HPD_IRQ;
dmub_hpd_callback(adev, ¬ify);
}
static void dm_test_register_hpd_handlers_empty(struct kunit *test)
{
struct amdgpu_device *adev;
struct dc *dc;
adev = dm_kunit_alloc_adev(test);
dc = kunit_kzalloc(test, sizeof(*dc), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dc);
adev->dm.dc = dc;
KUNIT_EXPECT_EQ(test, amdgpu_dm_register_hpd_handlers(adev), 0);
}
static void dm_test_register_hpd_handlers_valid(struct kunit *test)
{
struct amdgpu_dm_connector *aconn;
struct drm_connector *wbconn;
struct amdgpu_device *adev;
struct dc_link *link;
struct dc *dc;
adev = dm_kunit_alloc_adev(test);
KUNIT_ASSERT_EQ(test, amdgpu_dm_irq_init(adev), 0);
dc = kunit_kzalloc(test, sizeof(*dc), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dc);
adev->dm.dc = dc;
wbconn = kunit_kzalloc(test, sizeof(*wbconn), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, wbconn);
KUNIT_ASSERT_EQ(test, drm_connector_init(&adev->ddev, wbconn, &dm_test_connector_funcs,
DRM_MODE_CONNECTOR_WRITEBACK), 0);
KUNIT_ASSERT_EQ(test,
kunit_add_action_or_reset(test, dm_test_connector_cleanup, wbconn), 0);
aconn = kunit_kzalloc(test, sizeof(*aconn), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, aconn);
KUNIT_ASSERT_EQ(test, drm_connector_init(&adev->ddev, &aconn->base,
&dm_test_connector_funcs,
DRM_MODE_CONNECTOR_DisplayPort), 0);
KUNIT_ASSERT_EQ(test,
kunit_add_action_or_reset(test, dm_test_connector_cleanup, &aconn->base), 0);
link = kunit_kzalloc(test, sizeof(*link), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, link);
link->irq_source_hpd = DC_IRQ_SOURCE_HPD1;
link->irq_source_hpd_rx = DC_IRQ_SOURCE_HPD1RX;
aconn->dc_link = link;
KUNIT_EXPECT_EQ(test, amdgpu_dm_register_hpd_handlers(adev), 0);
KUNIT_EXPECT_FALSE(test,
list_empty(&adev->dm.irq_handler_list_low_tab[DC_IRQ_SOURCE_HPD1]));
KUNIT_EXPECT_FALSE(test,
list_empty(&adev->dm.irq_handler_list_low_tab[DC_IRQ_SOURCE_HPD1RX]));
amdgpu_dm_irq_fini(adev);
}
static void dm_test_register_hpd_handlers_invalid_hpd(struct kunit *test)
{
struct amdgpu_dm_connector *aconn;
struct amdgpu_device *adev;
struct dc_link *link;
struct dc *dc;
adev = dm_kunit_alloc_adev(test);
KUNIT_ASSERT_EQ(test, amdgpu_dm_irq_init(adev), 0);
dc = kunit_kzalloc(test, sizeof(*dc), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dc);
adev->dm.dc = dc;
aconn = kunit_kzalloc(test, sizeof(*aconn), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, aconn);
KUNIT_ASSERT_EQ(test, drm_connector_init(&adev->ddev, &aconn->base,
&dm_test_connector_funcs,
DRM_MODE_CONNECTOR_DisplayPort), 0);
KUNIT_ASSERT_EQ(test,
kunit_add_action_or_reset(test, dm_test_connector_cleanup, &aconn->base), 0);
link = kunit_kzalloc(test, sizeof(*link), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, link);
link->irq_source_hpd = DC_IRQ_SOURCE_HPD1RX;
link->irq_source_hpd_rx = DC_IRQ_SOURCE_INVALID;
aconn->dc_link = link;
KUNIT_EXPECT_EQ(test, amdgpu_dm_register_hpd_handlers(adev), -EINVAL);
amdgpu_dm_irq_fini(adev);
}
static void dm_test_register_hpd_handlers_invalid_hpd_rx(struct kunit *test)
{
struct amdgpu_dm_connector *aconn;
struct amdgpu_device *adev;
struct dc_link *link;
struct dc *dc;
adev = dm_kunit_alloc_adev(test);
KUNIT_ASSERT_EQ(test, amdgpu_dm_irq_init(adev), 0);
dc = kunit_kzalloc(test, sizeof(*dc), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dc);
adev->dm.dc = dc;
aconn = kunit_kzalloc(test, sizeof(*aconn), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, aconn);
KUNIT_ASSERT_EQ(test, drm_connector_init(&adev->ddev, &aconn->base,
&dm_test_connector_funcs,
DRM_MODE_CONNECTOR_DisplayPort), 0);
KUNIT_ASSERT_EQ(test,
kunit_add_action_or_reset(test, dm_test_connector_cleanup, &aconn->base), 0);
link = kunit_kzalloc(test, sizeof(*link), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, link);
link->irq_source_hpd = DC_IRQ_SOURCE_INVALID;
link->irq_source_hpd_rx = DC_IRQ_SOURCE_HPD1;
aconn->dc_link = link;
KUNIT_EXPECT_EQ(test, amdgpu_dm_register_hpd_handlers(adev), -EINVAL);
amdgpu_dm_irq_fini(adev);
}
static void dm_test_register_hpd_handlers_dmub_outbox(struct kunit *test)
{
struct amdgpu_device *adev;
struct dc *dc;
adev = dm_kunit_alloc_adev(test);
KUNIT_ASSERT_EQ(test, amdgpu_dm_irq_init(adev), 0);
dc = dm_kunit_alloc_dc_with_ctx(test);
adev->dm.dc = dc;
dc->caps.dmcub_support = true;
dc->ctx->asic_id.chip_family = AMDGPU_FAMILY_GC_11_0_1;
KUNIT_EXPECT_EQ(test, amdgpu_dm_register_hpd_handlers(adev), 0);
KUNIT_EXPECT_PTR_EQ(test, adev->dm.dmub_callback[DMUB_NOTIFICATION_HPD],
(dmub_notify_interrupt_callback_t)dmub_hpd_callback);
KUNIT_EXPECT_PTR_EQ(test, adev->dm.dmub_callback[DMUB_NOTIFICATION_HPD_IRQ],
(dmub_notify_interrupt_callback_t)dmub_hpd_callback);
KUNIT_EXPECT_PTR_EQ(test,
adev->dm.dmub_callback[DMUB_NOTIFICATION_HPD_SENSE_NOTIFY],
(dmub_notify_interrupt_callback_t)dmub_hpd_sense_callback);
amdgpu_dm_irq_fini(adev);
}
static void dm_test_pflip_high_irq_no_crtc(struct kunit *test)
{
struct common_irq_params params = { 0 };
struct amdgpu_device *adev;
adev = dm_kunit_alloc_adev(test);
params.adev = adev;
params.irq_src = (enum dc_irq_source)IRQ_TYPE_PFLIP;
dm_pflip_high_irq(¶ms);
}
static void dm_test_pflip_high_irq_not_submitted(struct kunit *test)
{
struct common_irq_params params = { 0 };
struct amdgpu_crtc *acrtc;
struct amdgpu_device *adev;
adev = dm_kunit_alloc_adev(test);
acrtc = dm_test_add_crtc(test, adev);
acrtc->pflip_status = AMDGPU_FLIP_NONE;
params.adev = adev;
params.irq_src = (enum dc_irq_source)IRQ_TYPE_PFLIP;
dm_pflip_high_irq(¶ms);
KUNIT_EXPECT_EQ(test, acrtc->pflip_status, AMDGPU_FLIP_NONE);
}
static void dm_test_pflip_high_irq_completes_flip(struct kunit *test)
{
struct drm_pending_vblank_event *event;
struct common_irq_params params = { 0 };
struct amdgpu_device *adev;
struct amdgpu_crtc *acrtc;
adev = dm_kunit_alloc_adev(test);
KUNIT_ASSERT_EQ(test, drm_vblank_init(&adev->ddev, 1), 0);
acrtc = dm_test_add_crtc(test, adev);
acrtc->pflip_status = AMDGPU_FLIP_SUBMITTED;
event = kzalloc_obj(*event);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, event);
acrtc->event = event;
adev->ddev.vblank[0].enabled = true;
KUNIT_ASSERT_EQ(test, drm_crtc_vblank_get(&acrtc->base), 0);
params.adev = adev;
params.irq_src = (enum dc_irq_source)IRQ_TYPE_PFLIP;
dm_pflip_high_irq(¶ms);
KUNIT_EXPECT_NULL(test, acrtc->event);
KUNIT_EXPECT_EQ(test, acrtc->pflip_status, AMDGPU_FLIP_NONE);
}
static struct amdgpu_crtc *dm_test_setup_vrr_pflip_crtc(struct kunit *test,
struct timing_generator *tg)
{
struct dc_stream_state *stream;
struct amdgpu_device *adev;
struct amdgpu_crtc *acrtc;
struct dc_link *link;
struct dc *dc;
adev = dm_kunit_alloc_adev(test);
KUNIT_ASSERT_EQ(test, drm_vblank_init(&adev->ddev, 1), 0);
dc = dm_kunit_alloc_dc_with_ctx(test);
dc->current_state = kunit_kzalloc(test, sizeof(*dc->current_state),
GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dc->current_state);
adev->dm.dc = dc;
link = dm_kunit_alloc_link(test);
stream = dm_kunit_alloc_stream(test, link);
stream->ctx = dc->ctx;
if (tg) {
dc->current_state->res_ctx.pipe_ctx[0].stream = stream;
dc->current_state->res_ctx.pipe_ctx[0].stream_res.tg = tg;
}
acrtc = dm_test_add_crtc(test, adev);
acrtc->pflip_status = AMDGPU_FLIP_SUBMITTED;
acrtc->dm_irq_params.stream = stream;
acrtc->dm_irq_params.freesync_config.state = VRR_STATE_ACTIVE_VARIABLE;
return acrtc;
}
static void dm_test_pflip_high_irq_vrr_no_scanoutpos(struct kunit *test)
{
struct drm_pending_vblank_event *event;
struct common_irq_params params = { 0 };
struct amdgpu_device *adev;
struct amdgpu_crtc *acrtc;
acrtc = dm_test_setup_vrr_pflip_crtc(test, NULL);
adev = drm_to_adev(acrtc->base.dev);
event = kzalloc_obj(*event);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, event);
acrtc->event = event;
adev->ddev.vblank[0].enabled = true;
KUNIT_ASSERT_EQ(test, drm_crtc_vblank_get(&acrtc->base), 0);
params.adev = adev;
params.irq_src = (enum dc_irq_source)IRQ_TYPE_PFLIP;
dm_pflip_high_irq(¶ms);
KUNIT_EXPECT_NULL(test, acrtc->event);
KUNIT_EXPECT_EQ(test, acrtc->pflip_status, AMDGPU_FLIP_NONE);
}
static void dm_test_pflip_high_irq_vrr_front_porch(struct kunit *test)
{
struct drm_pending_vblank_event *event;
struct common_irq_params params = { 0 };
struct timing_generator *tg;
struct amdgpu_device *adev;
struct amdgpu_crtc *acrtc;
tg = kunit_kzalloc(test, sizeof(*tg), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, tg);
tg->funcs = &dm_test_tg_funcs;
acrtc = dm_test_setup_vrr_pflip_crtc(test, tg);
adev = drm_to_adev(acrtc->base.dev);
event = kzalloc_obj(*event);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, event);
acrtc->event = event;
params.adev = adev;
params.irq_src = (enum dc_irq_source)IRQ_TYPE_PFLIP;
dm_pflip_high_irq(¶ms);
KUNIT_EXPECT_NULL(test, acrtc->event);
KUNIT_EXPECT_EQ(test, acrtc->pflip_status, AMDGPU_FLIP_NONE);
KUNIT_ASSERT_PTR_EQ(test, adev->ddev.vblank_event_list.next,
&event->base.link);
list_del(&event->base.link);
kfree(event);
}
static void dm_test_vupdate_high_irq_no_crtc(struct kunit *test)
{
struct common_irq_params params = { 0 };
struct amdgpu_device *adev;
adev = dm_kunit_alloc_adev(test);
params.adev = adev;
params.irq_src = (enum dc_irq_source)IRQ_TYPE_VUPDATE;
dm_vupdate_high_irq(¶ms);
}
static void dm_test_vupdate_high_irq_dcn_completes_flip(struct kunit *test)
{
struct drm_pending_vblank_event *event;
struct common_irq_params params = { 0 };
struct amdgpu_device *adev;
struct amdgpu_crtc *acrtc;
adev = dm_kunit_alloc_adev(test);
KUNIT_ASSERT_EQ(test, drm_vblank_init(&adev->ddev, 1), 0);
adev->ip_versions[DCE_HWIP][0] = IP_VERSION(3, 0, 0);
adev->family = AMDGPU_FAMILY_AI;
acrtc = dm_test_add_crtc(test, adev);
acrtc->pflip_status = AMDGPU_FLIP_SUBMITTED;
event = kzalloc_obj(*event);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, event);
acrtc->event = event;
adev->ddev.vblank[0].time = ktime_get();
adev->ddev.vblank[0].enabled = true;
KUNIT_ASSERT_EQ(test, drm_crtc_vblank_get(&acrtc->base), 0);
params.adev = adev;
params.irq_src = (enum dc_irq_source)IRQ_TYPE_VUPDATE;
dm_vupdate_high_irq(¶ms);
KUNIT_EXPECT_NULL(test, acrtc->event);
KUNIT_EXPECT_EQ(test, acrtc->pflip_status, AMDGPU_FLIP_NONE);
}
static void dm_test_vupdate_high_irq_dcn_no_active_planes(struct kunit *test)
{
struct common_irq_params params = { 0 };
struct amdgpu_device *adev;
struct amdgpu_crtc *acrtc;
adev = dm_kunit_alloc_adev(test);
KUNIT_ASSERT_EQ(test, drm_vblank_init(&adev->ddev, 1), 0);
adev->ip_versions[DCE_HWIP][0] = IP_VERSION(3, 0, 0);
adev->family = AMDGPU_FAMILY_AI;
acrtc = dm_test_add_crtc(test, adev);
acrtc->pflip_status = AMDGPU_FLIP_SUBMITTED;
acrtc->dm_irq_params.active_planes = 0;
params.adev = adev;
params.irq_src = (enum dc_irq_source)IRQ_TYPE_VUPDATE;
dm_vupdate_high_irq(¶ms);
KUNIT_EXPECT_EQ(test, acrtc->pflip_status, AMDGPU_FLIP_NONE);
}
static struct amdgpu_crtc *dm_test_setup_vmin_vmax_crtc(struct kunit *test,
unsigned int v_total_min,
unsigned int v_total_max)
{
struct dc_stream_state *stream;
struct amdgpu_device *adev;
struct amdgpu_crtc *acrtc;
struct dc_link *link;
struct dc *dc;
adev = dm_kunit_alloc_adev(test);
mutex_init(&adev->dm.dc_lock);
KUNIT_ASSERT_EQ(test, drm_vblank_init(&adev->ddev, 1), 0);
KUNIT_ASSERT_EQ(test, amdgpu_dm_irq_init(adev), 0);
dc = dm_kunit_alloc_dc_with_ctx(test);
dc->current_state = kunit_kzalloc(test, sizeof(*dc->current_state),
GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dc->current_state);
adev->dm.dc = dc;
link = dm_kunit_alloc_link(test);
stream = dm_kunit_alloc_stream(test, link);
acrtc = dm_test_add_crtc(test, adev);
acrtc->dm_irq_params.freesync_config.state = VRR_STATE_ACTIVE_VARIABLE;
acrtc->dm_irq_params.stream = stream;
acrtc->dm_irq_params.vrr_params.adjust.v_total_min = v_total_min;
acrtc->dm_irq_params.vrr_params.adjust.v_total_max = v_total_max;
return acrtc;
}
static void dm_test_vupdate_high_irq_dce_vrr_btr(struct kunit *test)
{
struct common_irq_params params = { 0 };
struct dc_stream_state *stream;
struct amdgpu_device *adev;
struct amdgpu_crtc *acrtc;
acrtc = dm_test_setup_vmin_vmax_crtc(test, 2000, 2200);
adev = drm_to_adev(acrtc->base.dev);
stream = acrtc->dm_irq_params.stream;
adev->family = AMDGPU_FAMILY_SI;
adev->ddev.vblank[0].time = ktime_get();
params.adev = adev;
params.irq_src = (enum dc_irq_source)IRQ_TYPE_VUPDATE;
dm_vupdate_high_irq(¶ms);
flush_workqueue(adev->dm.vmin_vmax_wq);
KUNIT_EXPECT_EQ(test, stream->adjust.v_total_min, 2000);
KUNIT_EXPECT_EQ(test, stream->adjust.v_total_max, 2200);
KUNIT_EXPECT_EQ(test, kref_read(&stream->refcount), 1);
amdgpu_dm_irq_fini(adev);
}
static void dm_test_crtc_high_irq_no_crtc(struct kunit *test)
{
struct common_irq_params params = { 0 };
struct amdgpu_device *adev;
adev = dm_kunit_alloc_adev(test);
params.adev = adev;
params.irq_src = (enum dc_irq_source)IRQ_TYPE_VBLANK;
dm_crtc_high_irq(¶ms);
}
static void dm_test_crtc_high_irq_vrr_pre_ai(struct kunit *test)
{
struct common_irq_params params = { 0 };
struct amdgpu_crtc *acrtc;
struct amdgpu_device *adev;
adev = dm_kunit_alloc_adev(test);
acrtc = dm_test_add_crtc(test, adev);
acrtc->dm_irq_params.freesync_config.state = VRR_STATE_ACTIVE_VARIABLE;
adev->family = AMDGPU_FAMILY_SI;
params.adev = adev;
params.irq_src = (enum dc_irq_source)IRQ_TYPE_VBLANK;
dm_crtc_high_irq(¶ms);
}
static void dm_test_crtc_high_irq_vrr_ai_no_stream(struct kunit *test)
{
struct common_irq_params params = { 0 };
struct amdgpu_crtc *acrtc;
struct amdgpu_device *adev;
adev = dm_kunit_alloc_adev(test);
acrtc = dm_test_add_crtc(test, adev);
acrtc->pflip_status = AMDGPU_FLIP_NONE;
acrtc->dm_irq_params.freesync_config.state = VRR_STATE_ACTIVE_VARIABLE;
adev->family = AMDGPU_FAMILY_AI;
params.adev = adev;
params.irq_src = (enum dc_irq_source)IRQ_TYPE_VBLANK;
dm_crtc_high_irq(¶ms);
KUNIT_EXPECT_EQ(test, acrtc->pflip_status, AMDGPU_FLIP_NONE);
}
static void dm_test_crtc_high_irq_writeback_disables(struct kunit *test)
{
struct drm_writeback_connector *wb_conn;
struct common_irq_params params = { 0 };
struct amdgpu_device *adev;
struct amdgpu_crtc *acrtc;
struct dc *dc;
adev = dm_kunit_alloc_adev(test);
KUNIT_ASSERT_EQ(test, drm_vblank_init(&adev->ddev, 1), 0);
dc = dm_test_alloc_dc_with_irq_service(test,
&dm_test_irq_service_funcs_dcn10);
adev->dm.dc = dc;
adev->family = AMDGPU_FAMILY_SI;
acrtc = dm_test_add_crtc(test, adev);
wb_conn = kunit_kzalloc(test, sizeof(*wb_conn), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, wb_conn);
acrtc->wb_conn = wb_conn;
acrtc->wb_pending = true;
params.adev = adev;
params.irq_src = (enum dc_irq_source)IRQ_TYPE_VBLANK;
dm_crtc_high_irq(¶ms);
KUNIT_EXPECT_TRUE(test, acrtc->wb_frame_done);
KUNIT_EXPECT_TRUE(test, acrtc->wb_pending);
}
static void dm_test_crtc_high_irq_writeback_completes(struct kunit *test)
{
struct drm_writeback_connector *wb_conn;
struct common_irq_params params = { 0 };
struct drm_writeback_job *job;
struct amdgpu_device *adev;
struct amdgpu_crtc *acrtc;
adev = dm_kunit_alloc_adev(test);
KUNIT_ASSERT_EQ(test, drm_vblank_init(&adev->ddev, 1), 0);
adev->family = AMDGPU_FAMILY_SI;
acrtc = dm_test_add_crtc(test, adev);
wb_conn = kunit_kzalloc(test, sizeof(*wb_conn), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, wb_conn);
spin_lock_init(&wb_conn->job_lock);
INIT_LIST_HEAD(&wb_conn->job_queue);
job = kzalloc_obj(*job);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, job);
list_add_tail(&job->list_entry, &wb_conn->job_queue);
acrtc->wb_conn = wb_conn;
acrtc->wb_pending = true;
acrtc->wb_frame_done = true;
adev->ddev.vblank[0].enabled = true;
KUNIT_ASSERT_EQ(test, drm_crtc_vblank_get(&acrtc->base), 0);
params.adev = adev;
params.irq_src = (enum dc_irq_source)IRQ_TYPE_VBLANK;
dm_crtc_high_irq(¶ms);
KUNIT_EXPECT_FALSE(test, acrtc->wb_pending);
KUNIT_EXPECT_FALSE(test, acrtc->wb_frame_done);
}
static void dm_test_crtc_high_irq_schedules_vmin_vmax(struct kunit *test)
{
struct common_irq_params params = { 0 };
struct dc_stream_state *stream;
struct amdgpu_device *adev;
struct amdgpu_crtc *acrtc;
acrtc = dm_test_setup_vmin_vmax_crtc(test, 1000, 1100);
adev = drm_to_adev(acrtc->base.dev);
stream = acrtc->dm_irq_params.stream;
adev->family = AMDGPU_FAMILY_AI;
acrtc->dm_irq_params.vrr_params.supported = true;
params.adev = adev;
params.irq_src = (enum dc_irq_source)IRQ_TYPE_VBLANK;
dm_crtc_high_irq(¶ms);
flush_workqueue(adev->dm.vmin_vmax_wq);
KUNIT_EXPECT_EQ(test, stream->adjust.v_total_min, 1000);
KUNIT_EXPECT_EQ(test, stream->adjust.v_total_max, 1100);
KUNIT_EXPECT_EQ(test, kref_read(&stream->refcount), 1);
amdgpu_dm_irq_fini(adev);
}
static void dm_test_handle_hpd_work_out_of_range(struct kunit *test)
{
struct dmub_hpd_work *hpd_work;
struct amdgpu_device *adev;
adev = dm_kunit_alloc_adev(test);
hpd_work = kzalloc_obj(*hpd_work);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, hpd_work);
hpd_work->dmub_notify = kzalloc_obj(*hpd_work->dmub_notify);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, hpd_work->dmub_notify);
hpd_work->dmub_notify->type =
(enum dmub_notification_type)ARRAY_SIZE(adev->dm.dmub_callback);
hpd_work->adev = adev;
INIT_WORK(&hpd_work->handle_hpd_work, dm_handle_hpd_work);
dm_handle_hpd_work(&hpd_work->handle_hpd_work);
}
static void dm_test_handle_hpd_work_null_notify(struct kunit *test)
{
struct dmub_hpd_work *hpd_work;
struct amdgpu_device *adev;
adev = dm_kunit_alloc_adev(test);
hpd_work = kzalloc_obj(*hpd_work);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, hpd_work);
hpd_work->adev = adev;
INIT_WORK(&hpd_work->handle_hpd_work, dm_handle_hpd_work);
dm_handle_hpd_work(&hpd_work->handle_hpd_work);
kfree(hpd_work);
}
static void dm_test_dmub_outbox1_low_irq_empty(struct kunit *test)
{
struct common_irq_params params = { 0 };
struct dc_dmub_srv *dc_dmub_srv;
struct amdgpu_device *adev;
struct dmub_srv *dmub;
struct dc *dc;
adev = dm_kunit_alloc_adev(test);
dc = dm_kunit_alloc_dc_with_ctx(test);
dc_dmub_srv = kunit_kzalloc(test, sizeof(*dc_dmub_srv), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dc_dmub_srv);
dmub = kunit_kzalloc(test, sizeof(*dmub), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dmub);
dmub->hw_funcs.get_outbox0_wptr = dm_test_dmub_get_outbox0_wptr;
dc_dmub_srv->dmub = dmub;
dc->ctx->dmub_srv = dc_dmub_srv;
adev->dm.dc = dc;
params.adev = adev;
params.irq_src = DC_IRQ_SOURCE_DMCUB_OUTBOX;
dm_dmub_outbox1_low_irq(¶ms);
}
static void dm_test_dmub_outbox1_low_irq_drains_trace(struct kunit *test)
{
struct common_irq_params params = { 0 };
struct dc_dmub_srv *dc_dmub_srv;
struct amdgpu_device *adev;
struct dmub_srv *dmub;
struct dc *dc;
void *rb;
adev = dm_kunit_alloc_adev(test);
dc = dm_kunit_alloc_dc_with_ctx(test);
dc_dmub_srv = kunit_kzalloc(test, sizeof(*dc_dmub_srv), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dc_dmub_srv);
dmub = kunit_kzalloc(test, sizeof(*dmub), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dmub);
rb = kunit_kzalloc(test, DM_TEST_OUTBOX0_RB_SIZE, GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, rb);
dmub->outbox0_rb.base_address = rb;
dmub->outbox0_rb.capacity = DM_TEST_OUTBOX0_RB_SIZE;
dmub->hw_funcs.get_outbox0_wptr = dm_test_dmub_get_outbox0_wptr_full;
dc_dmub_srv->dmub = dmub;
dc->ctx->dmub_srv = dc_dmub_srv;
adev->dm.dc = dc;
params.adev = adev;
params.irq_src = DC_IRQ_SOURCE_DMCUB_OUTBOX;
dm_dmub_outbox1_low_irq(¶ms);
KUNIT_EXPECT_EQ(test, dmub->outbox0_rb.rptr, DM_TEST_OUTBOX0_TRACE_BYTES);
}
static struct amdgpu_device *dm_test_alloc_adev_outbox_notify(struct kunit *test)
{
struct dc_dmub_srv *dc_dmub_srv;
struct amdgpu_device *adev;
struct dmub_srv *dmub;
struct dc *dc;
adev = dm_kunit_alloc_adev(test);
dc = dm_kunit_alloc_dc_with_ctx(test);
dc_dmub_srv = kunit_kzalloc(test, sizeof(*dc_dmub_srv), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dc_dmub_srv);
dmub = kunit_kzalloc(test, sizeof(*dmub), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dmub);
dmub->hw_init = true;
dmub->hw_funcs.get_outbox0_wptr = dm_test_dmub_get_outbox0_wptr;
dmub->hw_funcs.get_outbox1_wptr = dm_test_dmub_get_outbox1_wptr;
dc_dmub_srv->dmub = dmub;
dc->ctx->dmub_srv = dc_dmub_srv;
dc->caps.dmcub_support = true;
dc->ctx->asic_id.chip_family = AMDGPU_FAMILY_GC_11_0_1;
adev->dm.dc = dc;
return adev;
}
static void dm_test_dmub_outbox1_low_irq_no_handler(struct kunit *test)
{
struct common_irq_params params = { 0 };
struct amdgpu_device *adev;
adev = dm_test_alloc_adev_outbox_notify(test);
params.adev = adev;
params.irq_src = DC_IRQ_SOURCE_DMCUB_OUTBOX;
dm_dmub_outbox1_low_irq(¶ms);
}
static void dm_test_dmub_outbox1_low_irq_direct_callback(struct kunit *test)
{
struct common_irq_params params = { 0 };
struct amdgpu_device *adev;
adev = dm_test_alloc_adev_outbox_notify(test);
adev->dm.dmub_callback[DMUB_NOTIFICATION_NO_DATA] = dm_test_dmub_notify_callback;
adev->dm.dmub_thread_offload[DMUB_NOTIFICATION_NO_DATA] = false;
params.adev = adev;
params.irq_src = DC_IRQ_SOURCE_DMCUB_OUTBOX;
dm_test_dmub_notify_count = 0;
dm_dmub_outbox1_low_irq(¶ms);
KUNIT_EXPECT_EQ(test, dm_test_dmub_notify_count, 1);
}
static void dm_test_dmub_outbox1_low_irq_offload(struct kunit *test)
{
struct common_irq_params params = { 0 };
struct amdgpu_device *adev;
adev = dm_test_alloc_adev_outbox_notify(test);
adev->dm.dmub_callback[DMUB_NOTIFICATION_NO_DATA] = dm_test_dmub_notify_callback;
adev->dm.dmub_thread_offload[DMUB_NOTIFICATION_NO_DATA] = true;
adev->dm.delayed_hpd_wq = create_singlethread_workqueue("dm_irq_test_outbox");
KUNIT_ASSERT_NOT_NULL(test, adev->dm.delayed_hpd_wq);
params.adev = adev;
params.irq_src = DC_IRQ_SOURCE_DMCUB_OUTBOX;
dm_test_dmub_notify_count = 0;
dm_dmub_outbox1_low_irq(¶ms);
flush_workqueue(adev->dm.delayed_hpd_wq);
destroy_workqueue(adev->dm.delayed_hpd_wq);
KUNIT_EXPECT_EQ(test, dm_test_dmub_notify_count, 1);
}
static void dm_test_dce110_register_irq_handlers_rejects_uninitialized_sources(struct kunit *test)
{
struct amdgpu_device *adev;
struct dc *dc;
adev = dm_kunit_alloc_adev(test);
dc = dm_kunit_alloc_dc_with_ctx(test);
adev->dm.dc = dc;
KUNIT_EXPECT_EQ(test, amdgpu_dm_dce110_register_irq_handlers(adev), -EINVAL);
}
static struct amdgpu_device *dm_test_setup_irq_regs(struct kunit *test,
const struct irq_service_funcs *funcs)
{
struct amdgpu_device *adev;
struct dc *dc;
adev = dm_kunit_alloc_adev(test);
KUNIT_ASSERT_EQ(test, kunit_add_action_or_reset(test, dm_test_free_irq_sources,
adev), 0);
dc = dm_test_alloc_dc_with_irq_service(test, funcs);
dc->ctx->dce_version = DCE_VERSION_11_0;
dc->caps.max_otg_num = 1;
adev->dm.dc = dc;
adev->mode_info.num_crtc = 1;
adev->mode_info.num_hpd = 1;
amdgpu_dm_set_irq_funcs(adev);
KUNIT_ASSERT_EQ(test, amdgpu_dm_irq_init(adev), 0);
return adev;
}
static void dm_test_dce110_register_irq_handlers_one_crtc(struct kunit *test)
{
struct amdgpu_device *adev;
adev = dm_test_setup_irq_regs(test, &dm_test_irq_service_funcs_dce110);
KUNIT_EXPECT_EQ(test, amdgpu_dm_dce110_register_irq_handlers(adev), 0);
KUNIT_EXPECT_EQ(test, (int)adev->dm.vblank_params[0].irq_src,
(int)DC_IRQ_SOURCE_VBLANK1);
KUNIT_EXPECT_PTR_EQ(test, adev->dm.vblank_params[0].adev, adev);
KUNIT_EXPECT_EQ(test, (int)adev->dm.vupdate_params[0].irq_src,
(int)DC_IRQ_SOURCE_VUPDATE1);
KUNIT_EXPECT_EQ(test, (int)adev->dm.pflip_params[0].irq_src,
(int)DC_IRQ_SOURCE_PFLIP1);
KUNIT_EXPECT_EQ(test, (int)adev->dm.pflip_params[5].irq_src,
(int)DC_IRQ_SOURCE_PFLIP6);
amdgpu_dm_irq_fini(adev);
}
static void dm_test_dce110_register_irq_handlers_soc15_client(struct kunit *test)
{
struct amdgpu_irq_src **soc15_sources;
struct amdgpu_device *adev;
adev = dm_test_setup_irq_regs(test, &dm_test_irq_service_funcs_dce110);
adev->family = AMDGPU_FAMILY_AI;
KUNIT_EXPECT_EQ(test, amdgpu_dm_dce110_register_irq_handlers(adev), 0);
KUNIT_EXPECT_NULL(test, adev->irq.client[AMDGPU_IRQ_CLIENTID_LEGACY].sources);
soc15_sources = adev->irq.client[SOC15_IH_CLIENTID_DCE].sources;
KUNIT_ASSERT_NOT_NULL(test, soc15_sources);
KUNIT_EXPECT_PTR_EQ(test,
soc15_sources[VISLANDS30_IV_SRCID_D1_VERTICAL_INTERRUPT0],
&adev->crtc_irq);
amdgpu_dm_irq_fini(adev);
}
static void dm_test_dce110_register_irq_handlers_crtc_add_id_fails(struct kunit *test)
{
struct amdgpu_device *adev;
struct dc *dc;
adev = dm_kunit_alloc_adev(test);
dc = dm_test_alloc_dc_with_irq_service(test, &dm_test_irq_service_funcs_dce110);
dc->ctx->dce_version = DCE_VERSION_11_0;
adev->dm.dc = dc;
adev->mode_info.num_crtc = 1;
KUNIT_EXPECT_EQ(test, amdgpu_dm_dce110_register_irq_handlers(adev), -EINVAL);
}
static void dm_test_dce110_register_irq_handlers_bad_vblank_source(struct kunit *test)
{
struct amdgpu_device *adev;
adev = dm_test_setup_irq_regs(test, &dm_test_irq_service_funcs_unmapped);
KUNIT_EXPECT_EQ(test, amdgpu_dm_dce110_register_irq_handlers(adev), -EINVAL);
amdgpu_dm_irq_fini(adev);
}
static void dm_test_dce110_register_irq_handlers_bad_vupdate_source(struct kunit *test)
{
struct amdgpu_device *adev;
adev = dm_test_setup_irq_regs(test, &dm_test_irq_service_funcs_vblank_only);
KUNIT_EXPECT_EQ(test, amdgpu_dm_dce110_register_irq_handlers(adev), -EINVAL);
amdgpu_dm_irq_fini(adev);
}
static void dm_test_dce110_register_irq_handlers_bad_pflip_source(struct kunit *test)
{
struct amdgpu_device *adev;
adev = dm_test_setup_irq_regs(test, &dm_test_irq_service_funcs_no_pflip);
KUNIT_EXPECT_EQ(test, amdgpu_dm_dce110_register_irq_handlers(adev), -EINVAL);
amdgpu_dm_irq_fini(adev);
}
static void dm_test_dce110_register_irq_handlers_vupdate_add_id_fails(struct kunit *test)
{
struct amdgpu_device *adev;
adev = dm_test_setup_irq_regs(test, &dm_test_irq_service_funcs_dce110);
adev->vupdate_irq.funcs = NULL;
KUNIT_EXPECT_EQ(test, amdgpu_dm_dce110_register_irq_handlers(adev), -EINVAL);
amdgpu_dm_irq_fini(adev);
}
static void dm_test_dce110_register_irq_handlers_hpd_add_id_fails(struct kunit *test)
{
struct amdgpu_device *adev;
adev = dm_test_setup_irq_regs(test, &dm_test_irq_service_funcs_dce110);
adev->hpd_irq.funcs = NULL;
KUNIT_EXPECT_EQ(test, amdgpu_dm_dce110_register_irq_handlers(adev), -EINVAL);
amdgpu_dm_irq_fini(adev);
}
static void dm_test_dcn10_register_irq_handlers_zero_crtc(struct kunit *test)
{
struct amdgpu_device *adev;
struct dc *dc;
adev = dm_kunit_alloc_adev(test);
KUNIT_ASSERT_EQ(test, kunit_add_action_or_reset(test, dm_test_free_irq_sources,
adev), 0);
dc = dm_kunit_alloc_dc_with_ctx(test);
adev->dm.dc = dc;
adev->mode_info.num_hpd = 1;
amdgpu_dm_set_irq_funcs(adev);
KUNIT_EXPECT_EQ(test, amdgpu_dm_dcn10_register_irq_handlers(adev), 0);
KUNIT_ASSERT_NOT_NULL(test, adev->irq.client[SOC15_IH_CLIENTID_DCE].sources);
KUNIT_EXPECT_PTR_EQ(test,
adev->irq.client[SOC15_IH_CLIENTID_DCE].sources[DCN_1_0__SRCID__DC_HPD1_INT],
&adev->hpd_irq);
}
static void dm_test_dcn10_register_irq_handlers_one_crtc(struct kunit *test)
{
struct amdgpu_device *adev;
adev = dm_test_setup_irq_regs(test, &dm_test_irq_service_funcs_dcn10);
KUNIT_EXPECT_EQ(test, amdgpu_dm_dcn10_register_irq_handlers(adev), 0);
KUNIT_EXPECT_EQ(test, (int)adev->dm.vblank_params[0].irq_src, 0);
KUNIT_EXPECT_NULL(test, adev->dm.vblank_params[0].adev);
KUNIT_EXPECT_EQ(test, (int)adev->dm.vupdate_params[0].irq_src,
(int)DC_IRQ_SOURCE_VUPDATE1);
KUNIT_EXPECT_EQ(test, (int)adev->dm.pflip_params[0].irq_src, 0);
amdgpu_dm_irq_fini(adev);
}
static void dm_test_dcn10_register_irq_handlers_vupdate_add_id_fails(struct kunit *test)
{
struct amdgpu_device *adev;
adev = dm_test_setup_irq_regs(test, &dm_test_irq_service_funcs_dcn10);
adev->vupdate_irq.funcs = NULL;
KUNIT_EXPECT_EQ(test, amdgpu_dm_dcn10_register_irq_handlers(adev), -EINVAL);
amdgpu_dm_irq_fini(adev);
}
static void dm_test_dcn10_register_irq_handlers_bad_vupdate_source(struct kunit *test)
{
struct amdgpu_device *adev;
adev = dm_test_setup_irq_regs(test, &dm_test_irq_service_funcs_unmapped);
KUNIT_EXPECT_EQ(test, amdgpu_dm_dcn10_register_irq_handlers(adev), -EINVAL);
amdgpu_dm_irq_fini(adev);
}
static void dm_test_dcn10_register_irq_handlers_hpd_add_id_fails(struct kunit *test)
{
struct amdgpu_device *adev;
adev = dm_test_setup_irq_regs(test, &dm_test_irq_service_funcs_dcn10);
adev->hpd_irq.funcs = NULL;
KUNIT_EXPECT_EQ(test, amdgpu_dm_dcn10_register_irq_handlers(adev), -EINVAL);
amdgpu_dm_irq_fini(adev);
}
static void dm_test_register_outbox_irq_handlers_without_dmub(struct kunit *test)
{
struct amdgpu_device *adev;
struct dc *dc;
adev = dm_kunit_alloc_adev(test);
KUNIT_ASSERT_EQ(test, kunit_add_action_or_reset(test, dm_test_free_irq_sources,
adev), 0);
dc = dm_kunit_alloc_dc_with_ctx(test);
adev->dm.dc = dc;
amdgpu_dm_set_irq_funcs(adev);
KUNIT_EXPECT_EQ(test, amdgpu_dm_register_outbox_irq_handlers(adev), 0);
KUNIT_ASSERT_NOT_NULL(test, adev->irq.client[SOC15_IH_CLIENTID_DCE].sources);
KUNIT_EXPECT_PTR_EQ(test,
adev->irq.client[SOC15_IH_CLIENTID_DCE].sources[
DCN_1_0__SRCID__DMCUB_OUTBOX_LOW_PRIORITY_READY_INT],
&adev->dmub_outbox_irq);
}
static void dm_test_register_outbox_irq_handlers_add_id_fails(struct kunit *test)
{
struct amdgpu_device *adev;
struct dc *dc;
adev = dm_kunit_alloc_adev(test);
dc = dm_kunit_alloc_dc_with_ctx(test);
adev->dm.dc = dc;
KUNIT_EXPECT_EQ(test, amdgpu_dm_register_outbox_irq_handlers(adev), -EINVAL);
}
static void dm_test_register_outbox_irq_handlers_with_dmub(struct kunit *test)
{
struct dc_dmub_srv *dc_dmub_srv;
struct amdgpu_device *adev;
struct list_head *hnd_list;
struct dc *dc;
adev = dm_kunit_alloc_adev(test);
KUNIT_ASSERT_EQ(test, kunit_add_action_or_reset(test, dm_test_free_irq_sources,
adev), 0);
dc = dm_test_alloc_dc_with_irq_service(test, &dm_test_irq_service_funcs_dcn10);
dc_dmub_srv = kunit_kzalloc(test, sizeof(*dc_dmub_srv), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dc_dmub_srv);
dc->ctx->dmub_srv = dc_dmub_srv;
adev->dm.dc = dc;
amdgpu_dm_set_irq_funcs(adev);
KUNIT_ASSERT_EQ(test, amdgpu_dm_irq_init(adev), 0);
KUNIT_EXPECT_EQ(test, amdgpu_dm_register_outbox_irq_handlers(adev), 0);
KUNIT_EXPECT_EQ(test, (int)adev->dm.dmub_outbox_params[0].irq_src,
(int)DC_IRQ_SOURCE_DMCUB_OUTBOX);
KUNIT_EXPECT_PTR_EQ(test, adev->dm.dmub_outbox_params[0].adev, adev);
hnd_list = &adev->dm.irq_handler_list_low_tab[DC_IRQ_SOURCE_DMCUB_OUTBOX];
KUNIT_EXPECT_FALSE(test, list_empty(hnd_list));
amdgpu_dm_irq_fini(adev);
}
static void dm_test_irq_handler_dispatches_work(struct kunit *test)
{
struct dc_interrupt_params int_params = { 0 };
struct amdgpu_iv_entry entry = { 0 };
struct amdgpu_device *adev;
int high_count = 0;
int low_count = 0;
void *handler;
struct dc *dc;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
KUNIT_ASSERT_EQ(test, amdgpu_dm_irq_init(adev), 0);
dc = dm_test_alloc_dc_with_irq_service(test,
&dm_test_irq_service_funcs_dce110);
adev->dm.dc = dc;
int_params.int_context = INTERRUPT_HIGH_IRQ_CONTEXT;
int_params.irq_source = DC_IRQ_SOURCE_VBLANK1;
handler = amdgpu_dm_irq_register_interrupt(adev, &int_params,
dm_test_irq_handler_count,
&high_count);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, handler);
int_params.int_context = INTERRUPT_LOW_IRQ_CONTEXT;
handler = amdgpu_dm_irq_register_interrupt(adev, &int_params,
dm_test_irq_handler_count,
&low_count);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, handler);
entry.src_id = VISLANDS30_IV_SRCID_D1_VERTICAL_INTERRUPT0;
entry.src_data[0] = 0;
KUNIT_EXPECT_EQ(test, amdgpu_dm_irq_handler(adev, NULL, &entry), 0);
KUNIT_EXPECT_EQ(test, high_count, 1);
flush_workqueue(adev->dm.irq_wq);
KUNIT_EXPECT_EQ(test, low_count, 1);
amdgpu_dm_irq_fini(adev);
}
static void dm_test_irq_handler_invalid_source(struct kunit *test)
{
struct dc_interrupt_params int_params = { 0 };
struct amdgpu_iv_entry entry = { 0 };
struct amdgpu_device *adev;
int high_count = 0;
int low_count = 0;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
KUNIT_ASSERT_EQ(test, amdgpu_dm_irq_init(adev), 0);
adev->dm.dc = dm_test_alloc_dc_with_irq_service(test, &dm_test_irq_service_funcs_unmapped);
int_params.int_context = INTERRUPT_HIGH_IRQ_CONTEXT;
int_params.irq_source = DC_IRQ_SOURCE_VBLANK1;
KUNIT_ASSERT_NOT_ERR_OR_NULL(test,
amdgpu_dm_irq_register_interrupt(adev, &int_params, dm_test_irq_handler_count,
&high_count));
int_params.int_context = INTERRUPT_LOW_IRQ_CONTEXT;
KUNIT_ASSERT_NOT_ERR_OR_NULL(test,
amdgpu_dm_irq_register_interrupt(adev, &int_params, dm_test_irq_handler_count,
&low_count));
KUNIT_EXPECT_EQ(test, amdgpu_dm_irq_handler(adev, NULL, &entry), 0);
flush_workqueue(adev->dm.irq_wq);
KUNIT_EXPECT_EQ(test, high_count, 0);
KUNIT_EXPECT_EQ(test, low_count, 0);
amdgpu_dm_irq_fini(adev);
}
static void dm_test_handle_vmin_vmax_update(struct kunit *test)
{
struct dc_crtc_timing_adjust *adjust;
struct vupdate_offload_work *work;
struct dc_stream_state *stream;
struct amdgpu_device *adev;
struct dc *dc;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
mutex_init(&adev->dm.dc_lock);
dc = dm_kunit_alloc_dc_with_ctx(test);
dc->current_state = kunit_kzalloc(test, sizeof(*dc->current_state),
GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dc->current_state);
adev->dm.dc = dc;
stream = kunit_kzalloc(test, sizeof(*stream), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream);
kref_init(&stream->refcount);
kref_get(&stream->refcount);
work = kzalloc_obj(*work);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, work);
adjust = kzalloc_obj(*adjust);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adjust);
work->adev = adev;
work->stream = stream;
work->adjust = adjust;
adjust->v_total_min = 1000;
adjust->v_total_max = 1100;
dm_handle_vmin_vmax_update(&work->work);
KUNIT_EXPECT_EQ(test, stream->adjust.v_total_min, 1000);
KUNIT_EXPECT_EQ(test, stream->adjust.v_total_max, 1100);
KUNIT_EXPECT_EQ(test, kref_read(&stream->refcount), 1);
}
static struct kunit_case amdgpu_dm_irq_tests[] = {
KUNIT_CASE(dm_test_hpd_to_dal_irq_source_hpd1),
KUNIT_CASE(dm_test_hpd_to_dal_irq_source_hpd2),
KUNIT_CASE(dm_test_hpd_to_dal_irq_source_hpd3),
KUNIT_CASE(dm_test_hpd_to_dal_irq_source_hpd4),
KUNIT_CASE(dm_test_hpd_to_dal_irq_source_hpd5),
KUNIT_CASE(dm_test_hpd_to_dal_irq_source_hpd6),
KUNIT_CASE(dm_test_hpd_to_dal_irq_source_invalid),
KUNIT_CASE(dm_test_are_sinks_equal_first_null),
KUNIT_CASE(dm_test_are_sinks_equal_second_null),
KUNIT_CASE(dm_test_are_sinks_equal_different_signal),
KUNIT_CASE(dm_test_are_sinks_equal_different_edid_length),
KUNIT_CASE(dm_test_are_sinks_equal_different_edid_data),
KUNIT_CASE(dm_test_are_sinks_equal_zero_length),
KUNIT_CASE(dm_test_are_sinks_equal_full_edid_identical),
KUNIT_CASE(dm_test_are_sinks_equal_full_edid_last_byte_differs),
KUNIT_CASE(dm_test_notification_str_no_data),
KUNIT_CASE(dm_test_notification_str_aux_reply),
KUNIT_CASE(dm_test_notification_str_hpd),
KUNIT_CASE(dm_test_notification_str_hpd_irq),
KUNIT_CASE(dm_test_notification_str_set_config),
KUNIT_CASE(dm_test_notification_str_dpia),
KUNIT_CASE(dm_test_notification_str_hpd_sense),
KUNIT_CASE(dm_test_notification_str_fused_io),
KUNIT_CASE(dm_test_notification_str_unknown),
KUNIT_CASE(dm_test_irq_init_initializes_lists),
KUNIT_CASE(dm_test_irq_register_rejects_null_params),
KUNIT_CASE(dm_test_irq_register_rejects_invalid_context),
KUNIT_CASE(dm_test_irq_register_rejects_invalid_source),
KUNIT_CASE(dm_test_irq_register_separate_contexts),
KUNIT_CASE(dm_test_irq_unregister_rejects_invalid_source),
KUNIT_CASE(dm_test_irq_unregister_rejects_null_handler),
KUNIT_CASE(dm_test_irq_unregister_handler_not_found),
KUNIT_CASE(dm_test_irq_fini_removes_registered_handlers),
KUNIT_CASE(dm_test_irq_fini_on_empty_tables),
KUNIT_CASE(dm_test_get_crtc_by_otg_inst_returns_match),
KUNIT_CASE(dm_test_get_crtc_by_otg_inst_returns_null),
KUNIT_CASE(dm_test_get_crtc_by_otg_inst_empty_list),
KUNIT_CASE(dm_test_get_crtc_by_otg_inst_unassigned_otg),
KUNIT_CASE(dm_test_set_irq_funcs),
KUNIT_CASE(dm_test_irq_suspend_empty),
KUNIT_CASE(dm_test_irq_resume_early_empty),
KUNIT_CASE(dm_test_irq_resume_late_empty),
KUNIT_CASE(dm_test_irq_suspend_registered),
KUNIT_CASE(dm_test_irq_suspend_disables_polling),
KUNIT_CASE(dm_test_irq_resume_early_registered),
KUNIT_CASE(dm_test_irq_resume_late_registered),
KUNIT_CASE(dm_test_irq_resume_late_enables_polling),
KUNIT_CASE(dm_test_hpd_rx_irq_create_workqueue),
KUNIT_CASE(dm_test_hpd_rx_irq_work_suspend_null),
KUNIT_CASE(dm_test_hpd_rx_irq_work_suspend_flushes),
KUNIT_CASE(dm_test_set_crtc_irq_state_no_crtc),
KUNIT_CASE(dm_test_set_pflip_irq_state_no_crtc),
KUNIT_CASE(dm_test_set_vline0_irq_state_no_crtc),
KUNIT_CASE(dm_test_set_vupdate_irq_state_no_crtc),
KUNIT_CASE(dm_test_set_crtc_irq_state_otg_disabled),
KUNIT_CASE(dm_test_set_crtc_irq_state_enable),
KUNIT_CASE(dm_test_set_pflip_irq_state_disable),
KUNIT_CASE(dm_test_set_crtc_irq_state_allows_idle),
KUNIT_CASE(dm_test_irq_immediate_work_empty),
KUNIT_CASE(dm_test_irq_immediate_work_invokes_all),
KUNIT_CASE(dm_test_irq_schedule_work_empty),
KUNIT_CASE(dm_test_irq_schedule_work_queues_handler),
KUNIT_CASE(dm_test_irq_schedule_work_requeue_fallback),
KUNIT_CASE(dm_test_irq_schedule_work_no_workqueue),
KUNIT_CASE(dm_test_set_hpd_irq_state_null_dc),
KUNIT_CASE(dm_test_set_dmub_outbox_irq_state_null_dc),
KUNIT_CASE(dm_test_set_dmub_trace_irq_state_null_dc),
KUNIT_CASE(dm_test_outbox_init_null_dc),
KUNIT_CASE(dm_test_hpd_init_empty_connectors),
KUNIT_CASE(dm_test_hpd_fini_empty_connectors),
KUNIT_CASE(dm_test_hpd_init_fini_with_connectors),
KUNIT_CASE(dm_test_hpd_init_fini_analog_connector),
KUNIT_CASE(dm_test_hpd_init_fini_irq_ref),
KUNIT_CASE(dm_test_hpd_init_skips_connector_without_link),
KUNIT_CASE(dm_test_hpd_rx_offload_work_no_connector),
KUNIT_CASE(dm_test_hpd_rx_offload_work_detect_type_fails),
KUNIT_CASE(dm_test_hpd_rx_offload_work_in_reset),
KUNIT_CASE(dm_test_hpd_rx_offload_work_msg_rdy),
KUNIT_CASE(dm_test_hpd_rx_offload_work_automated_test),
KUNIT_CASE(dm_test_hpd_rx_offload_work_timing_changed),
KUNIT_CASE(dm_test_hpd_rx_offload_work_link_loss),
KUNIT_CASE(dm_test_hdmi_hpd_debounce_detect_false),
KUNIT_CASE(dm_test_hdmi_hpd_debounce_reallow_idle),
KUNIT_CASE(dm_test_hdmi_hpd_debounce_sink_unchanged),
KUNIT_CASE(dm_test_hdmi_hpd_debounce_sink_changed),
KUNIT_CASE(dm_test_handle_hpd_irq_disabled),
KUNIT_CASE(dm_test_handle_hpd_irq_helper_debounce_schedule),
KUNIT_CASE(dm_test_handle_hpd_irq_helper_debounce_release_prev),
KUNIT_CASE(dm_test_handle_hpd_irq_helper_detect_type_fails),
KUNIT_CASE(dm_test_handle_hpd_irq_helper_debounce_pending),
KUNIT_CASE(dm_test_handle_hpd_irq_helper_hdcp_reset),
KUNIT_CASE(dm_test_handle_hpd_irq_helper_forced_detect),
KUNIT_CASE(dm_test_handle_hpd_irq_helper_detect_true),
KUNIT_CASE(dm_test_handle_hpd_rx_irq_disabled),
KUNIT_CASE(dm_test_handle_hpd_rx_irq_automated_test),
KUNIT_CASE(dm_test_handle_hpd_rx_irq_msg_rdy),
KUNIT_CASE(dm_test_handle_hpd_rx_irq_link_loss),
KUNIT_CASE(dm_test_handle_hpd_rx_irq_detect_type_fails),
KUNIT_CASE(dm_test_handle_hpd_rx_irq_forced_detect),
KUNIT_CASE(dm_test_handle_hpd_rx_irq_detect_true),
KUNIT_CASE(dm_test_handle_hpd_rx_irq_cp_irq),
KUNIT_CASE(dm_test_schedule_hpd_rx_offload_work),
KUNIT_CASE(dm_test_dmub_hpd_callback_null_inputs),
KUNIT_CASE(dm_test_dmub_hpd_callback_invalid_index),
KUNIT_CASE(dm_test_dmub_hpd_callback_empty_connectors),
KUNIT_CASE(dm_test_dmub_hpd_callback_suspend_skip),
KUNIT_CASE(dm_test_dmub_hpd_callback_unknown_type_match),
KUNIT_CASE(dm_test_dmub_hpd_callback_hpd_type),
KUNIT_CASE(dm_test_dmub_hpd_callback_hpd_irq_type),
KUNIT_CASE(dm_test_register_hpd_handlers_empty),
KUNIT_CASE(dm_test_register_hpd_handlers_valid),
KUNIT_CASE(dm_test_register_hpd_handlers_invalid_hpd),
KUNIT_CASE(dm_test_register_hpd_handlers_invalid_hpd_rx),
KUNIT_CASE(dm_test_register_hpd_handlers_dmub_outbox),
KUNIT_CASE(dm_test_pflip_high_irq_no_crtc),
KUNIT_CASE(dm_test_pflip_high_irq_not_submitted),
KUNIT_CASE(dm_test_pflip_high_irq_completes_flip),
KUNIT_CASE(dm_test_pflip_high_irq_vrr_no_scanoutpos),
KUNIT_CASE(dm_test_pflip_high_irq_vrr_front_porch),
KUNIT_CASE(dm_test_vupdate_high_irq_no_crtc),
KUNIT_CASE(dm_test_vupdate_high_irq_dcn_completes_flip),
KUNIT_CASE(dm_test_vupdate_high_irq_dcn_no_active_planes),
KUNIT_CASE(dm_test_vupdate_high_irq_dce_vrr_btr),
KUNIT_CASE(dm_test_crtc_high_irq_no_crtc),
KUNIT_CASE(dm_test_crtc_high_irq_vrr_pre_ai),
KUNIT_CASE(dm_test_crtc_high_irq_vrr_ai_no_stream),
KUNIT_CASE(dm_test_crtc_high_irq_writeback_disables),
KUNIT_CASE(dm_test_crtc_high_irq_writeback_completes),
KUNIT_CASE(dm_test_crtc_high_irq_schedules_vmin_vmax),
KUNIT_CASE(dm_test_handle_hpd_work_out_of_range),
KUNIT_CASE(dm_test_handle_hpd_work_null_notify),
KUNIT_CASE(dm_test_dmub_outbox1_low_irq_empty),
KUNIT_CASE(dm_test_dmub_outbox1_low_irq_drains_trace),
KUNIT_CASE(dm_test_dmub_outbox1_low_irq_no_handler),
KUNIT_CASE(dm_test_dmub_outbox1_low_irq_direct_callback),
KUNIT_CASE(dm_test_dmub_outbox1_low_irq_offload),
KUNIT_CASE(dm_test_dce110_register_irq_handlers_rejects_uninitialized_sources),
KUNIT_CASE(dm_test_dce110_register_irq_handlers_one_crtc),
KUNIT_CASE(dm_test_dce110_register_irq_handlers_soc15_client),
KUNIT_CASE(dm_test_dce110_register_irq_handlers_crtc_add_id_fails),
KUNIT_CASE(dm_test_dce110_register_irq_handlers_bad_vblank_source),
KUNIT_CASE(dm_test_dce110_register_irq_handlers_bad_vupdate_source),
KUNIT_CASE(dm_test_dce110_register_irq_handlers_bad_pflip_source),
KUNIT_CASE(dm_test_dce110_register_irq_handlers_vupdate_add_id_fails),
KUNIT_CASE(dm_test_dce110_register_irq_handlers_hpd_add_id_fails),
KUNIT_CASE(dm_test_dcn10_register_irq_handlers_zero_crtc),
KUNIT_CASE(dm_test_dcn10_register_irq_handlers_one_crtc),
KUNIT_CASE(dm_test_dcn10_register_irq_handlers_vupdate_add_id_fails),
KUNIT_CASE(dm_test_dcn10_register_irq_handlers_bad_vupdate_source),
KUNIT_CASE(dm_test_dcn10_register_irq_handlers_hpd_add_id_fails),
KUNIT_CASE(dm_test_register_outbox_irq_handlers_without_dmub),
KUNIT_CASE(dm_test_register_outbox_irq_handlers_add_id_fails),
KUNIT_CASE(dm_test_register_outbox_irq_handlers_with_dmub),
KUNIT_CASE(dm_test_irq_handler_dispatches_work),
KUNIT_CASE(dm_test_irq_handler_invalid_source),
KUNIT_CASE(dm_test_handle_vmin_vmax_update),
{}
};
static struct kunit_suite amdgpu_dm_irq_test_suite = {
.name = "amdgpu_dm_irq",
.test_cases = amdgpu_dm_irq_tests,
};
kunit_test_suite(amdgpu_dm_irq_test_suite);
MODULE_AUTHOR("AMD");
MODULE_DESCRIPTION("KUnit tests for amdgpu_dm_irq");
MODULE_LICENSE("Dual MIT/GPL"