#include <kunit/test.h>
#include <drm/drm_atomic.h>
#include <drm/drm_connector.h>
#include <drm/drm_kunit_helpers.h>
#include <drm/drm_vblank.h>
#include <linux/debugfs.h>
#include "dc.h"
#include "inc/core_types.h"
#include "irq/irq_service.h"
#include "inc/hw/timing_generator.h"
#include "inc/link_service.h"
#include "amdgpu.h"
#include "amdgpu_mode.h"
#include "amdgpu_dm.h"
#include "amdgpu_dm_crtc.h"
#include "amdgpu_dm_kunit_test_helpers.h"
#include "amdgpu_dm_irq_params.h"
static void dm_test_crtc_modeset_required_active_mode_changed(struct kunit *test)
{
struct drm_crtc_state state = {};
state.active = true;
state.mode_changed = true;
KUNIT_EXPECT_TRUE(test,
amdgpu_dm_crtc_modeset_required(&state, NULL, NULL));
}
static void dm_test_crtc_modeset_required_active_state_changed(struct kunit *test)
{
struct drm_crtc_state state = {};
state.active = true;
state.active_changed = true;
KUNIT_EXPECT_TRUE(test,
amdgpu_dm_crtc_modeset_required(&state, NULL, NULL));
}
static void dm_test_crtc_modeset_required_active_connectors_changed(struct kunit *test)
{
struct drm_crtc_state state = {};
state.active = true;
state.connectors_changed = true;
KUNIT_EXPECT_TRUE(test,
amdgpu_dm_crtc_modeset_required(&state, NULL, NULL));
}
static void dm_test_crtc_modeset_required_inactive(struct kunit *test)
{
struct drm_crtc_state state = {};
state.active = false;
state.mode_changed = true;
KUNIT_EXPECT_FALSE(test,
amdgpu_dm_crtc_modeset_required(&state, NULL, NULL));
}
static void dm_test_crtc_modeset_required_no_changes(struct kunit *test)
{
struct drm_crtc_state state = {};
state.active = true;
state.mode_changed = false;
state.active_changed = false;
state.connectors_changed = false;
KUNIT_EXPECT_FALSE(test,
amdgpu_dm_crtc_modeset_required(&state, NULL, NULL));
}
static void dm_test_crtc_vrr_active_irq_variable(struct kunit *test)
{
struct amdgpu_crtc *acrtc = kunit_kzalloc(test, sizeof(*acrtc),
GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, acrtc);
acrtc->dm_irq_params.freesync_config.state = VRR_STATE_ACTIVE_VARIABLE;
KUNIT_EXPECT_TRUE(test, amdgpu_dm_crtc_vrr_active_irq(acrtc));
}
static void dm_test_crtc_vrr_active_irq_fixed(struct kunit *test)
{
struct amdgpu_crtc *acrtc = kunit_kzalloc(test, sizeof(*acrtc),
GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, acrtc);
acrtc->dm_irq_params.freesync_config.state = VRR_STATE_ACTIVE_FIXED;
KUNIT_EXPECT_TRUE(test, amdgpu_dm_crtc_vrr_active_irq(acrtc));
}
static void dm_test_crtc_vrr_active_irq_inactive(struct kunit *test)
{
struct amdgpu_crtc *acrtc = kunit_kzalloc(test, sizeof(*acrtc),
GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, acrtc);
acrtc->dm_irq_params.freesync_config.state = VRR_STATE_INACTIVE;
KUNIT_EXPECT_FALSE(test, amdgpu_dm_crtc_vrr_active_irq(acrtc));
}
static void dm_test_crtc_vrr_active_irq_disabled(struct kunit *test)
{
struct amdgpu_crtc *acrtc = kunit_kzalloc(test, sizeof(*acrtc),
GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, acrtc);
acrtc->dm_irq_params.freesync_config.state = VRR_STATE_DISABLED;
KUNIT_EXPECT_FALSE(test, amdgpu_dm_crtc_vrr_active_irq(acrtc));
}
static void dm_test_crtc_vrr_active_irq_unsupported(struct kunit *test)
{
struct amdgpu_crtc *acrtc = kunit_kzalloc(test, sizeof(*acrtc),
GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, acrtc);
acrtc->dm_irq_params.freesync_config.state = VRR_STATE_UNSUPPORTED;
KUNIT_EXPECT_FALSE(test, amdgpu_dm_crtc_vrr_active_irq(acrtc));
}
static void dm_test_crtc_vrr_active_variable(struct kunit *test)
{
struct dm_crtc_state *dm_state = kunit_kzalloc(test,
sizeof(*dm_state),
GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dm_state);
dm_state->freesync_config.state = VRR_STATE_ACTIVE_VARIABLE;
KUNIT_EXPECT_TRUE(test, amdgpu_dm_crtc_vrr_active(dm_state));
}
static void dm_test_crtc_vrr_active_fixed(struct kunit *test)
{
struct dm_crtc_state *dm_state = kunit_kzalloc(test,
sizeof(*dm_state),
GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dm_state);
dm_state->freesync_config.state = VRR_STATE_ACTIVE_FIXED;
KUNIT_EXPECT_TRUE(test, amdgpu_dm_crtc_vrr_active(dm_state));
}
static void dm_test_crtc_vrr_active_inactive(struct kunit *test)
{
struct dm_crtc_state *dm_state = kunit_kzalloc(test,
sizeof(*dm_state),
GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dm_state);
dm_state->freesync_config.state = VRR_STATE_INACTIVE;
KUNIT_EXPECT_FALSE(test, amdgpu_dm_crtc_vrr_active(dm_state));
}
static void dm_test_crtc_vrr_active_disabled(struct kunit *test)
{
struct dm_crtc_state *dm_state = kunit_kzalloc(test,
sizeof(*dm_state),
GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dm_state);
dm_state->freesync_config.state = VRR_STATE_DISABLED;
KUNIT_EXPECT_FALSE(test, amdgpu_dm_crtc_vrr_active(dm_state));
}
static void dm_test_crtc_vrr_active_unsupported(struct kunit *test)
{
struct dm_crtc_state *dm_state = kunit_kzalloc(test,
sizeof(*dm_state),
GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dm_state);
dm_state->freesync_config.state = VRR_STATE_UNSUPPORTED;
KUNIT_EXPECT_FALSE(test, amdgpu_dm_crtc_vrr_active(dm_state));
}
static void dm_test_add_connector(struct drm_device *dev,
struct drm_connector *connector,
int connector_type,
enum drm_connector_status status)
{
INIT_LIST_HEAD(&connector->head);
kref_init(&connector->base.refcount);
connector->connector_type = connector_type;
connector->status = status;
list_add_tail(&connector->head, &dev->mode_config.connector_list);
}
static void dm_test_crtc_is_headless_null_adev(struct kunit *test)
{
KUNIT_EXPECT_TRUE(test, amdgpu_dm_is_headless(NULL));
}
static void dm_test_crtc_is_headless_no_connectors(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct drm_device *dev = dm_kunit_alloc_drm_with_connector_list(test);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
adev->dm.ddev = dev;
KUNIT_EXPECT_TRUE(test, amdgpu_dm_is_headless(adev));
}
static void dm_test_crtc_is_headless_writeback_only(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct drm_device *dev = dm_kunit_alloc_drm_with_connector_list(test);
struct drm_connector *wb = kunit_kzalloc(test, sizeof(*wb), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, wb);
adev->dm.ddev = dev;
dm_test_add_connector(dev, wb, DRM_MODE_CONNECTOR_WRITEBACK,
connector_status_connected);
KUNIT_EXPECT_TRUE(test, amdgpu_dm_is_headless(adev));
}
static void dm_test_crtc_is_headless_disconnected_display(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct drm_device *dev = dm_kunit_alloc_drm_with_connector_list(test);
struct drm_connector *display = kunit_kzalloc(test, sizeof(*display), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, display);
adev->dm.ddev = dev;
dm_test_add_connector(dev, display, DRM_MODE_CONNECTOR_HDMIA,
connector_status_disconnected);
KUNIT_EXPECT_TRUE(test, amdgpu_dm_is_headless(adev));
}
static void dm_test_crtc_is_headless_connected_display(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct drm_device *dev = dm_kunit_alloc_drm_with_connector_list(test);
struct drm_connector *display = kunit_kzalloc(test, sizeof(*display), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, display);
adev->dm.ddev = dev;
dm_test_add_connector(dev, display, DRM_MODE_CONNECTOR_HDMIA,
connector_status_connected);
KUNIT_EXPECT_FALSE(test, amdgpu_dm_is_headless(adev));
}
static void dm_test_crtc_is_headless_mixed_connectors(struct kunit *test)
{
struct amdgpu_device *adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
struct drm_device *dev = dm_kunit_alloc_drm_with_connector_list(test);
struct drm_connector *wb = kunit_kzalloc(test, sizeof(*wb), GFP_KERNEL);
struct drm_connector *display = kunit_kzalloc(test, sizeof(*display), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, wb);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, display);
adev->dm.ddev = dev;
dm_test_add_connector(dev, wb, DRM_MODE_CONNECTOR_WRITEBACK,
connector_status_connected);
dm_test_add_connector(dev, display, DRM_MODE_CONNECTOR_DisplayPort,
connector_status_connected);
KUNIT_EXPECT_FALSE(test, amdgpu_dm_is_headless(adev));
}
static void dm_test_crtc_helper_mode_fixup_returns_true(struct kunit *test)
{
struct drm_display_mode mode = { 0 };
struct drm_display_mode adjusted_mode = { 0 };
KUNIT_EXPECT_TRUE(test,
amdgpu_dm_crtc_helper_mode_fixup(NULL, &mode, &adjusted_mode));
}
static void dm_test_crtc_set_vupdate_irq_no_otg(struct kunit *test)
{
struct amdgpu_crtc *acrtc;
struct amdgpu_device *adev;
adev = dm_kunit_alloc_adev(test);
acrtc = kunit_kzalloc(test, sizeof(*acrtc), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, acrtc);
acrtc->base.dev = &adev->ddev;
acrtc->otg_inst = -1;
KUNIT_EXPECT_EQ(test, amdgpu_dm_crtc_set_vupdate_irq(&acrtc->base, true), 0);
KUNIT_EXPECT_EQ(test, amdgpu_dm_crtc_set_vupdate_irq(&acrtc->base, false), 0);
}
static void dm_test_crtc_set_vupdate_irq_dc_busy(struct kunit *test)
{
struct amdgpu_crtc *acrtc;
struct amdgpu_device *adev;
adev = dm_kunit_alloc_adev(test);
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->base.dev = &adev->ddev;
acrtc->otg_inst = 0;
KUNIT_EXPECT_EQ(test,
amdgpu_dm_crtc_set_vupdate_irq(&acrtc->base, true), -EBUSY);
}
static bool dm_test_vupdate_irq_src_set(struct irq_service *irq_service,
const struct irq_source_info *info,
bool enable)
{
return true;
}
static bool dm_test_vupdate_irq_src_ack(struct irq_service *irq_service,
const struct irq_source_info *info)
{
return true;
}
static struct irq_source_info_funcs dm_test_vupdate_irq_src_funcs = {
.set = dm_test_vupdate_irq_src_set,
.ack = dm_test_vupdate_irq_src_ack,
};
static bool dm_test_vupdate_irq_src_set_busy(struct irq_service *irq_service,
const struct irq_source_info *info,
bool enable)
{
return false;
}
static struct irq_source_info_funcs dm_test_vupdate_irq_src_busy_funcs = {
.set = dm_test_vupdate_irq_src_set_busy,
.ack = dm_test_vupdate_irq_src_ack,
};
static void dm_test_crtc_set_vupdate_irq_enable(struct kunit *test)
{
struct irq_source_info *info;
struct resource_pool *res_pool;
struct irq_service *irqs;
struct amdgpu_crtc *acrtc;
struct amdgpu_device *adev;
struct dc *dc;
int i;
adev = dm_kunit_alloc_adev(test);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
acrtc = kunit_kzalloc(test, sizeof(*acrtc), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, acrtc);
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_vupdate_irq_src_funcs;
irqs->info = info;
res_pool->irqs = irqs;
dc->res_pool = res_pool;
adev->dm.dc = dc;
acrtc->base.dev = &adev->ddev;
acrtc->otg_inst = 0;
KUNIT_EXPECT_EQ(test,
amdgpu_dm_crtc_set_vupdate_irq(&acrtc->base, true), 0);
KUNIT_EXPECT_EQ(test,
amdgpu_dm_crtc_set_vupdate_irq(&acrtc->base, false), 0);
}
static void dm_test_idle_create_workqueue(struct kunit *test)
{
struct amdgpu_device *adev;
struct idle_workqueue *idle_work;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
idle_work = idle_create_workqueue(adev);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, idle_work);
KUNIT_EXPECT_PTR_EQ(test, idle_work->dm, &adev->dm);
KUNIT_EXPECT_FALSE(test, idle_work->enable);
KUNIT_EXPECT_FALSE(test, idle_work->running);
kfree(idle_work);
}
static void dm_test_idle_worker_disabled_clears_running(struct kunit *test)
{
struct idle_workqueue *idle_work;
struct amdgpu_device *adev;
adev = dm_kunit_alloc_adev(test);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
idle_work = kunit_kzalloc(test, sizeof(*idle_work), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, idle_work);
idle_work->dm = &adev->dm;
idle_work->enable = false;
idle_work->running = true;
adev->dm.idle_workqueue = idle_work;
amdgpu_dm_idle_worker(&idle_work->work);
KUNIT_EXPECT_FALSE(test, idle_work->running);
}
static void dm_test_idle_worker_enabled_breaks_when_idle_disallowed(struct kunit *test)
{
struct idle_workqueue *idle_work;
struct amdgpu_device *adev;
adev = dm_kunit_alloc_adev(test);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
mutex_init(&adev->dm.dc_lock);
adev->dm.dc = dm_kunit_alloc_dc_with_ctx(test);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev->dm.dc);
adev->dm.dc->idle_optimizations_allowed = false;
idle_work = kunit_kzalloc(test, sizeof(*idle_work), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, idle_work);
idle_work->dm = &adev->dm;
idle_work->enable = true;
adev->dm.idle_workqueue = idle_work;
amdgpu_dm_idle_worker(&idle_work->work);
KUNIT_EXPECT_FALSE(test, idle_work->running);
}
static void dm_test_idle_worker_enabled_breaks_when_not_headless(struct kunit *test)
{
struct idle_workqueue *idle_work;
struct drm_connector *display;
struct amdgpu_device *adev;
adev = dm_kunit_alloc_adev(test);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
mutex_init(&adev->dm.dc_lock);
adev->dm.adev = adev;
adev->dm.ddev = dm_kunit_alloc_drm_with_connector_list(test);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev->dm.ddev);
adev->dm.dc = dm_kunit_alloc_dc_with_ctx(test);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev->dm.dc);
adev->dm.dc->idle_optimizations_allowed = true;
adev->dm.dc->caps.is_apu = true;
adev->dm.dc->current_state = dm_kunit_alloc_dc_state(test);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev->dm.dc->current_state);
display = kunit_kzalloc(test, sizeof(*display), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, display);
dm_test_add_connector(adev->dm.ddev, display, DRM_MODE_CONNECTOR_HDMIA,
connector_status_connected);
idle_work = kunit_kzalloc(test, sizeof(*idle_work), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, idle_work);
idle_work->dm = &adev->dm;
idle_work->enable = true;
adev->dm.idle_workqueue = idle_work;
amdgpu_dm_idle_worker(&idle_work->work);
KUNIT_EXPECT_FALSE(test, idle_work->running);
}
static bool dm_test_idle_apply_flip(struct dc *dc, bool enable)
{
return !enable;
}
static void dm_test_idle_worker_enabled_runs_body(struct kunit *test)
{
struct idle_workqueue *idle_work;
struct amdgpu_device *adev;
struct dal_logger *logger;
adev = dm_kunit_alloc_adev(test);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
mutex_init(&adev->dm.dc_lock);
adev->dm.adev = adev;
adev->dm.ddev = dm_kunit_alloc_drm_with_connector_list(test);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev->dm.ddev);
adev->dm.dc = dm_kunit_alloc_dc_with_ctx(test);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev->dm.dc);
adev->dm.dc->idle_optimizations_allowed = true;
adev->dm.dc->caps.is_apu = true;
logger = kunit_kzalloc(test, sizeof(*logger), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, logger);
logger->dev = &adev->ddev;
adev->dm.dc->ctx->logger = logger;
adev->dm.dc->clk_mgr = dm_kunit_alloc_clk_mgr(test);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev->dm.dc->clk_mgr);
adev->dm.dc->hwss.apply_idle_power_optimizations = dm_test_idle_apply_flip;
idle_work = kunit_kzalloc(test, sizeof(*idle_work), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, idle_work);
idle_work->dm = &adev->dm;
idle_work->enable = true;
adev->dm.idle_workqueue = idle_work;
amdgpu_dm_idle_worker(&idle_work->work);
KUNIT_EXPECT_FALSE(test, adev->dm.dc->idle_optimizations_allowed);
KUNIT_EXPECT_FALSE(test, idle_work->running);
}
static void dm_test_crtc_set_static_screen_optimze_no_sr_entry(struct kunit *test)
{
struct amdgpu_display_manager *dm;
struct dc_link *link;
struct dc_stream_state *stream;
dm = kunit_kzalloc(test, sizeof(*dm), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dm);
link = dm_kunit_alloc_link(test);
stream = dm_kunit_alloc_stream(test, link);
amdgpu_dm_crtc_set_static_screen_optimze(dm, stream, true, false);
amdgpu_dm_crtc_set_static_screen_optimze(dm, stream, false, false);
}
static void dm_test_crtc_set_static_screen_optimze_sr_entry_psr(struct kunit *test)
{
struct amdgpu_display_manager *dm;
struct dc_link *link;
struct dc_stream_state *stream;
dm = kunit_kzalloc(test, sizeof(*dm), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dm);
link = dm_kunit_alloc_link(test);
stream = dm_kunit_alloc_stream(test, link);
link->psr_settings.psr_version = DC_PSR_VERSION_1;
amdgpu_dm_crtc_set_static_screen_optimze(dm, stream, true, true);
amdgpu_dm_crtc_set_static_screen_optimze(dm, stream, false, true);
}
static void dm_test_crtc_set_static_screen_optimze_psr_su_skips(struct kunit *test)
{
struct amdgpu_display_manager *dm;
struct dc_link *link;
struct dc_stream_state *stream;
dm = kunit_kzalloc(test, sizeof(*dm), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dm);
link = dm_kunit_alloc_link(test);
stream = dm_kunit_alloc_stream(test, link);
link->psr_settings.psr_version = DC_PSR_VERSION_SU_1;
amdgpu_dm_crtc_set_static_screen_optimze(dm, stream, true, true);
}
static void dm_test_crtc_enable_vblank_rejects_unconfigured(struct kunit *test)
{
struct amdgpu_device *adev = dm_kunit_alloc_adev(test);
struct amdgpu_crtc *acrtc;
acrtc = kunit_kzalloc(test, sizeof(*acrtc), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, acrtc);
acrtc->base.dev = &adev->ddev;
acrtc->base.enabled = false;
KUNIT_EXPECT_EQ(test, amdgpu_dm_crtc_enable_vblank(&acrtc->base), -EINVAL);
}
static int dm_test_crtc_irq_src_set(struct amdgpu_device *adev,
struct amdgpu_irq_src *source,
unsigned int type,
enum amdgpu_interrupt_state state)
{
return 0;
}
static const struct amdgpu_irq_src_funcs dm_test_crtc_irq_src_funcs = {
.set = dm_test_crtc_irq_src_set,
};
static bool dm_test_crtc_get_vblank_timestamp(struct drm_crtc *crtc,
int *max_error,
ktime_t *vblank_time,
bool in_vblank_irq)
{
return false;
}
static int dm_test_crtc_enable_vblank(struct drm_crtc *crtc)
{
return 0;
}
static void dm_test_crtc_disable_vblank(struct drm_crtc *crtc)
{
}
static u32 dm_test_crtc_get_vblank_counter(struct drm_crtc *crtc)
{
return 0;
}
static const struct drm_crtc_funcs dm_test_crtc_funcs = {
.destroy = amdgpu_dm_crtc_destroy,
.atomic_duplicate_state = amdgpu_dm_crtc_duplicate_state,
.atomic_destroy_state = amdgpu_dm_crtc_destroy_state,
.enable_vblank = dm_test_crtc_enable_vblank,
.disable_vblank = dm_test_crtc_disable_vblank,
.get_vblank_counter = dm_test_crtc_get_vblank_counter,
.get_vblank_timestamp = dm_test_crtc_get_vblank_timestamp,
};
static void dm_test_crtc_cleanup(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 void dm_test_crtc_arm_irq_src(struct kunit *test,
struct amdgpu_irq_src *src, int count)
{
atomic_t *enabled;
enabled = kunit_kzalloc(test, sizeof(*enabled), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, enabled);
atomic_set(enabled, count);
src->num_types = 1;
src->enabled_types = enabled;
src->funcs = &dm_test_crtc_irq_src_funcs;
}
static struct amdgpu_crtc *
dm_test_crtc_setup_enable(struct kunit *test, struct amdgpu_device **adev_out,
enum dce_version dce_version)
{
struct amdgpu_reset_domain *reset_domain;
struct dc_stream_state *stream;
struct dm_crtc_state *dm_state;
struct amdgpu_device *adev;
struct amdgpu_crtc *acrtc;
struct dc_link *link;
adev = dm_kunit_alloc_adev(test);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
KUNIT_ASSERT_EQ(test, drm_vblank_init(&adev->ddev, 1), 0);
adev->dm.dc = dm_kunit_alloc_dc_with_ctx(test);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev->dm.dc);
adev->dm.dc->ctx->dce_version = dce_version;
adev->mode_info.num_crtc = 1;
reset_domain = kunit_kzalloc(test, sizeof(*reset_domain), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, reset_domain);
adev->reset_domain = reset_domain;
acrtc = kunit_kzalloc(test, sizeof(*acrtc), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, acrtc);
acrtc->base.dev = &adev->ddev;
acrtc->base.funcs = &dm_test_crtc_funcs;
acrtc->base.enabled = true;
acrtc->crtc_id = 0;
INIT_LIST_HEAD(&acrtc->base.head);
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_cleanup, acrtc), 0);
link = dm_kunit_alloc_link(test);
stream = dm_kunit_alloc_stream(test, link);
dm_state = kunit_kzalloc(test, sizeof(*dm_state), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dm_state);
dm_state->stream = stream;
acrtc->base.state = &dm_state->base;
*adev_out = adev;
return acrtc;
}
static void dm_test_crtc_enable_vblank_full_path(struct kunit *test)
{
struct dm_crtc_state *acrtc_state;
struct amdgpu_device *adev;
struct amdgpu_crtc *acrtc;
acrtc = dm_test_crtc_setup_enable(test, &adev, DCE_VERSION_8_0);
acrtc->otg_inst = -1;
acrtc_state = to_dm_crtc_state(acrtc->base.state);
acrtc_state->freesync_config.state = VRR_STATE_ACTIVE_VARIABLE;
adev->irq.installed = true;
dm_test_crtc_arm_irq_src(test, &adev->crtc_irq, 1);
dm_test_crtc_arm_irq_src(test, &adev->pageflip_irq, 1);
KUNIT_EXPECT_EQ(test, amdgpu_dm_crtc_enable_vblank(&acrtc->base), 0);
}
static void dm_test_crtc_enable_vblank_vupdate_busy(struct kunit *test)
{
struct irq_source_info *info;
struct resource_pool *res_pool;
struct dm_crtc_state *acrtc_state;
struct irq_service *irqs;
struct amdgpu_device *adev;
struct amdgpu_crtc *acrtc;
int i;
acrtc = dm_test_crtc_setup_enable(test, &adev, DCE_VERSION_8_0);
acrtc->otg_inst = 0;
acrtc_state = to_dm_crtc_state(acrtc->base.state);
acrtc_state->freesync_config.state = VRR_STATE_ACTIVE_VARIABLE;
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_vupdate_irq_src_busy_funcs;
irqs->info = info;
res_pool->irqs = irqs;
adev->dm.dc->res_pool = res_pool;
KUNIT_EXPECT_EQ(test,
amdgpu_dm_crtc_enable_vblank(&acrtc->base), -EBUSY);
}
static void dm_test_crtc_enable_vblank_crtc_irq_error(struct kunit *test)
{
struct amdgpu_device *adev;
struct amdgpu_crtc *acrtc;
acrtc = dm_test_crtc_setup_enable(test, &adev, DCE_VERSION_6_0);
adev->irq.installed = false;
KUNIT_EXPECT_EQ(test,
amdgpu_dm_crtc_enable_vblank(&acrtc->base), -ENOENT);
}
static void dm_test_crtc_enable_vblank_in_reset(struct kunit *test)
{
struct amdgpu_device *adev;
struct amdgpu_crtc *acrtc;
acrtc = dm_test_crtc_setup_enable(test, &adev, DCE_VERSION_6_0);
adev->irq.installed = true;
dm_test_crtc_arm_irq_src(test, &adev->crtc_irq, 1);
dm_test_crtc_arm_irq_src(test, &adev->pageflip_irq, 1);
atomic_set(&adev->reset_domain->in_gpu_reset, 1);
KUNIT_EXPECT_EQ(test, amdgpu_dm_crtc_enable_vblank(&acrtc->base), 0);
}
static void dm_test_crtc_enable_vblank_queues_work(struct kunit *test)
{
struct dm_crtc_state *acrtc_state;
struct amdgpu_device *adev;
struct amdgpu_crtc *acrtc;
acrtc = dm_test_crtc_setup_enable(test, &adev, DCE_VERSION_8_0);
acrtc->otg_inst = -1;
acrtc_state = to_dm_crtc_state(acrtc->base.state);
acrtc_state->freesync_config.state = VRR_STATE_ACTIVE_VARIABLE;
adev->irq.installed = true;
dm_test_crtc_arm_irq_src(test, &adev->crtc_irq, 1);
dm_test_crtc_arm_irq_src(test, &adev->pageflip_irq, 1);
mutex_init(&adev->dm.dc_lock);
adev->dm.vblank_control_workqueue =
create_singlethread_workqueue("dm_test_vblank");
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev->dm.vblank_control_workqueue);
KUNIT_EXPECT_EQ(test, amdgpu_dm_crtc_enable_vblank(&acrtc->base), 0);
destroy_workqueue(adev->dm.vblank_control_workqueue);
adev->dm.vblank_control_workqueue = NULL;
KUNIT_EXPECT_EQ(test, adev->dm.active_vblank_irq_count, 1);
}
static void dm_test_crtc_enable_vblank_ips_restore(struct kunit *test)
{
struct dm_crtc_state *acrtc_state;
struct drm_vblank_crtc *vblank;
struct amdgpu_device *adev;
struct amdgpu_crtc *acrtc;
struct dc_link *link;
acrtc = dm_test_crtc_setup_enable(test, &adev, DCE_VERSION_8_0);
acrtc->otg_inst = -1;
acrtc_state = to_dm_crtc_state(acrtc->base.state);
acrtc_state->freesync_config.state = VRR_STATE_ACTIVE_VARIABLE;
acrtc->base.funcs = &dm_test_crtc_funcs;
adev->dm.dc->caps.ips_support = true;
adev->dm.dc->config.disable_ips = DMUB_IPS_ENABLE;
link = acrtc_state->stream->link;
link->psr_settings.psr_version = DC_PSR_VERSION_1;
vblank = drm_crtc_vblank_crtc(&acrtc->base);
vblank->config.disable_immediate = true;
adev->irq.installed = true;
dm_test_crtc_arm_irq_src(test, &adev->crtc_irq, 1);
dm_test_crtc_arm_irq_src(test, &adev->pageflip_irq, 1);
KUNIT_EXPECT_EQ(test, amdgpu_dm_crtc_enable_vblank(&acrtc->base), 0);
}
static void dm_test_crtc_enable_vblank_ips_restore_replay(struct kunit *test)
{
struct dm_crtc_state *acrtc_state;
struct drm_vblank_crtc *vblank;
struct amdgpu_device *adev;
struct amdgpu_crtc *acrtc;
struct dc_link *link;
acrtc = dm_test_crtc_setup_enable(test, &adev, DCE_VERSION_8_0);
acrtc->otg_inst = -1;
acrtc_state = to_dm_crtc_state(acrtc->base.state);
acrtc_state->freesync_config.state = VRR_STATE_ACTIVE_VARIABLE;
acrtc->base.funcs = &dm_test_crtc_funcs;
adev->dm.dc->caps.ips_support = true;
adev->dm.dc->config.disable_ips = DMUB_IPS_ENABLE;
link = acrtc_state->stream->link;
link->psr_settings.psr_version = DC_PSR_VERSION_UNSUPPORTED;
link->replay_settings.config.replay_supported = true;
vblank = drm_crtc_vblank_crtc(&acrtc->base);
vblank->config.disable_immediate = true;
adev->irq.installed = true;
dm_test_crtc_arm_irq_src(test, &adev->crtc_irq, 1);
dm_test_crtc_arm_irq_src(test, &adev->pageflip_irq, 1);
KUNIT_EXPECT_EQ(test, amdgpu_dm_crtc_enable_vblank(&acrtc->base), 0);
}
static struct drm_crtc *dm_test_crtc_setup_vline0(struct kunit *test,
struct amdgpu_device **adev_out,
uint32_t ip_version)
{
struct amdgpu_device *adev;
struct drm_crtc *crtc;
adev = dm_kunit_alloc_adev(test);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
crtc = kunit_kzalloc(test, sizeof(*crtc), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, crtc);
crtc->dev = &adev->ddev;
adev->ip_versions[DCE_HWIP][0] = ip_version;
*adev_out = adev;
return crtc;
}
static void dm_test_crtc_set_vline0_irq_dce_noop(struct kunit *test)
{
struct amdgpu_device *adev;
struct drm_crtc *crtc;
crtc = dm_test_crtc_setup_vline0(test, &adev, 0);
KUNIT_EXPECT_EQ(test,
amdgpu_dm_crtc_set_vline0_irq(crtc, AMDGPU_CRTC_IRQ_VBLANK1, true), 0);
}
static void dm_test_crtc_set_vline0_irq_error(struct kunit *test)
{
struct amdgpu_device *adev;
struct drm_crtc *crtc;
crtc = dm_test_crtc_setup_vline0(test, &adev, IP_VERSION(3, 5, 0));
KUNIT_EXPECT_EQ(test,
amdgpu_dm_crtc_set_vline0_irq(crtc, AMDGPU_CRTC_IRQ_VBLANK1, true),
-ENOENT);
}
static void dm_test_crtc_set_vline0_irq_enable_disable(struct kunit *test)
{
struct amdgpu_device *adev;
struct drm_crtc *crtc;
atomic_t *refcount;
crtc = dm_test_crtc_setup_vline0(test, &adev, IP_VERSION(3, 5, 0));
adev->irq.installed = true;
dm_test_crtc_arm_irq_src(test, &adev->vline0_irq, 1);
refcount = &adev->vline0_irq.enabled_types[AMDGPU_CRTC_IRQ_VBLANK1];
KUNIT_EXPECT_EQ(test,
amdgpu_dm_crtc_set_vline0_irq(crtc, AMDGPU_CRTC_IRQ_VBLANK1, true), 0);
KUNIT_EXPECT_EQ(test, atomic_read(refcount), 2);
KUNIT_EXPECT_EQ(test,
amdgpu_dm_crtc_set_vline0_irq(crtc, AMDGPU_CRTC_IRQ_VBLANK1, false), 0);
KUNIT_EXPECT_EQ(test, atomic_read(refcount), 1);
}
static void dm_test_crtc_update_active_planes_no_stream(struct kunit *test)
{
struct dm_crtc_state *dm_state;
dm_state = kunit_kzalloc(test, sizeof(*dm_state), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dm_state);
dm_state->stream = NULL;
dm_state->active_planes = 5;
amdgpu_dm_crtc_update_crtc_active_planes(NULL, &dm_state->base);
KUNIT_EXPECT_EQ(test, dm_state->active_planes, 0);
}
static void dm_test_add_plane(struct drm_device *dev, struct drm_plane *plane,
unsigned int index, enum drm_plane_type type)
{
INIT_LIST_HEAD(&plane->head);
plane->index = index;
plane->type = type;
list_add_tail(&plane->head, &dev->mode_config.plane_list);
}
static void dm_test_count_crtc_active_planes_none(struct kunit *test)
{
struct drm_crtc_state *crtc_state;
struct drm_atomic_commit *state;
struct drm_device *dev;
dev = dm_kunit_alloc_drm_with_connector_list(test);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev);
INIT_LIST_HEAD(&dev->mode_config.plane_list);
state = kunit_kzalloc(test, sizeof(*state), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state);
state->dev = dev;
crtc_state = kunit_kzalloc(test, sizeof(*crtc_state), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, crtc_state);
crtc_state->state = state;
crtc_state->plane_mask = 0;
KUNIT_EXPECT_EQ(test, amdgpu_dm_crtc_count_crtc_active_planes(crtc_state), 0);
}
static void dm_test_count_crtc_active_planes_mixed(struct kunit *test)
{
struct drm_plane *plane_no_state;
struct drm_plane *plane_cursor;
struct drm_plane *plane_with_fb;
struct drm_plane *plane_no_fb;
struct drm_plane *plane_excluded;
struct drm_plane_state *ps_fb;
struct drm_plane_state *ps_no_fb;
struct drm_crtc_state *crtc_state;
struct drm_atomic_commit *state;
struct drm_framebuffer *fb;
struct drm_device *dev;
dev = dm_kunit_alloc_drm_with_connector_list(test);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev);
INIT_LIST_HEAD(&dev->mode_config.plane_list);
plane_no_state = kunit_kzalloc(test, sizeof(*plane_no_state), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, plane_no_state);
plane_cursor = kunit_kzalloc(test, sizeof(*plane_cursor), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, plane_cursor);
plane_with_fb = kunit_kzalloc(test, sizeof(*plane_with_fb), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, plane_with_fb);
plane_no_fb = kunit_kzalloc(test, sizeof(*plane_no_fb), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, plane_no_fb);
plane_excluded = kunit_kzalloc(test, sizeof(*plane_excluded), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, plane_excluded);
dm_test_add_plane(dev, plane_no_state, 0, DRM_PLANE_TYPE_PRIMARY);
dm_test_add_plane(dev, plane_cursor, 1, DRM_PLANE_TYPE_CURSOR);
dm_test_add_plane(dev, plane_with_fb, 2, DRM_PLANE_TYPE_PRIMARY);
dm_test_add_plane(dev, plane_no_fb, 3, DRM_PLANE_TYPE_PRIMARY);
dm_test_add_plane(dev, plane_excluded, 4, DRM_PLANE_TYPE_PRIMARY);
fb = kunit_kzalloc(test, sizeof(*fb), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, fb);
ps_fb = kunit_kzalloc(test, sizeof(*ps_fb), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ps_fb);
ps_fb->fb = fb;
ps_no_fb = kunit_kzalloc(test, sizeof(*ps_no_fb), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ps_no_fb);
ps_no_fb->fb = NULL;
state = kunit_kzalloc(test, sizeof(*state), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state);
state->dev = dev;
state->planes = kunit_kzalloc(test, sizeof(*state->planes) * 5, GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state->planes);
state->planes[0].new_state = NULL;
state->planes[1].new_state = ps_fb;
state->planes[2].new_state = ps_fb;
state->planes[3].new_state = ps_no_fb;
state->planes[4].new_state = ps_fb;
crtc_state = kunit_kzalloc(test, sizeof(*crtc_state), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, crtc_state);
crtc_state->state = state;
crtc_state->plane_mask = BIT(0) | BIT(1) | BIT(2) | BIT(3);
KUNIT_EXPECT_EQ(test, amdgpu_dm_crtc_count_crtc_active_planes(crtc_state), 2);
}
static void dm_test_crtc_duplicate_state_copies_fields(struct kunit *test)
{
struct drm_crtc *crtc;
struct dm_crtc_state *cur;
struct drm_crtc_state *dup;
struct dm_crtc_state *dm_dup;
crtc = kunit_kzalloc(test, sizeof(*crtc), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, crtc);
cur = kunit_kzalloc(test, sizeof(*cur), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, cur);
cur->abm_level = 3;
cur->active_planes = 2;
cur->vrr_supported = true;
cur->cm_has_degamma = true;
cur->cm_is_degamma_srgb = true;
cur->crc_skip_count = 7;
cur->mpo_requested = true;
crtc->state = &cur->base;
dup = amdgpu_dm_crtc_duplicate_state(crtc);
KUNIT_ASSERT_NOT_NULL(test, dup);
dm_dup = to_dm_crtc_state(dup);
KUNIT_EXPECT_EQ(test, dm_dup->abm_level, 3);
KUNIT_EXPECT_EQ(test, dm_dup->active_planes, 2);
KUNIT_EXPECT_TRUE(test, dm_dup->vrr_supported);
KUNIT_EXPECT_TRUE(test, dm_dup->cm_has_degamma);
KUNIT_EXPECT_TRUE(test, dm_dup->cm_is_degamma_srgb);
KUNIT_EXPECT_EQ(test, dm_dup->crc_skip_count, 7);
KUNIT_EXPECT_TRUE(test, dm_dup->mpo_requested);
amdgpu_dm_crtc_destroy_state(crtc, dup);
}
static void dm_test_crtc_duplicate_state_retains_stream(struct kunit *test)
{
struct dc_stream_state *stream;
struct drm_crtc *crtc;
struct dm_crtc_state *cur;
struct drm_crtc_state *dup;
struct dm_crtc_state *dm_dup;
struct dc_link *link;
crtc = kunit_kzalloc(test, sizeof(*crtc), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, crtc);
cur = kunit_kzalloc(test, sizeof(*cur), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, cur);
link = dm_kunit_alloc_link(test);
stream = dm_kunit_alloc_stream(test, link);
cur->stream = stream;
crtc->state = &cur->base;
dup = amdgpu_dm_crtc_duplicate_state(crtc);
KUNIT_ASSERT_NOT_NULL(test, dup);
dm_dup = to_dm_crtc_state(dup);
KUNIT_EXPECT_PTR_EQ(test, dm_dup->stream, stream);
KUNIT_EXPECT_EQ(test, kref_read(&stream->refcount), 2);
amdgpu_dm_crtc_destroy_state(crtc, dup);
KUNIT_EXPECT_EQ(test, kref_read(&stream->refcount), 1);
}
static void dm_test_crtc_duplicate_state_null_state_returns_null(struct kunit *test)
{
struct drm_crtc *crtc;
crtc = kunit_kzalloc(test, sizeof(*crtc), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, crtc);
crtc->state = NULL;
KUNIT_EXPECT_NULL(test, amdgpu_dm_crtc_duplicate_state(crtc));
}
static void dm_test_crtc_destroy_cleans_up_and_frees(struct kunit *test)
{
struct amdgpu_device *adev;
struct amdgpu_crtc *acrtc;
struct drm_plane *plane;
int ret;
adev = dm_kunit_alloc_adev(test);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
plane = drm_kunit_helper_create_primary_plane(test, &adev->ddev,
NULL, NULL, NULL, 0, NULL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, plane);
acrtc = kzalloc_obj(*acrtc);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, acrtc);
ret = drm_crtc_init_with_planes(&adev->ddev, &acrtc->base, plane,
NULL, &dm_test_crtc_funcs, NULL);
KUNIT_ASSERT_EQ(test, ret, 0);
KUNIT_EXPECT_EQ(test, adev->ddev.mode_config.num_crtc, 1);
amdgpu_dm_crtc_destroy(&acrtc->base);
KUNIT_EXPECT_EQ(test, adev->ddev.mode_config.num_crtc, 0);
}
static void dm_test_crtc_create_state_allocates_state(struct kunit *test)
{
struct amdgpu_device *adev = dm_kunit_alloc_adev(test);
struct drm_crtc_state *crtc_state;
struct drm_crtc *crtc;
crtc = kunit_kzalloc(test, sizeof(*crtc), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, crtc);
crtc->dev = &adev->ddev;
crtc->state = NULL;
crtc_state = amdgpu_dm_crtc_create_state(crtc);
KUNIT_EXPECT_NOT_ERR_OR_NULL(test, crtc_state);
if (!IS_ERR(crtc_state))
amdgpu_dm_crtc_destroy_state(crtc, crtc_state);
}
static void dm_test_crtc_reset_state_replaces_existing(struct kunit *test)
{
struct amdgpu_device *adev = dm_kunit_alloc_adev(test);
struct dc_stream_state *stream;
struct dm_crtc_state *old;
struct drm_crtc *crtc;
struct dc_link *link;
crtc = kunit_kzalloc(test, sizeof(*crtc), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, crtc);
crtc->dev = &adev->ddev;
link = dm_kunit_alloc_link(test);
stream = dm_kunit_alloc_stream(test, link);
kref_get(&stream->refcount);
old = kzalloc_obj(*old);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, old);
old->stream = stream;
crtc->state = &old->base;
amdgpu_dm_crtc_create_state(crtc);
KUNIT_EXPECT_EQ(test, kref_read(&stream->refcount), 1);
KUNIT_EXPECT_NOT_NULL(test, crtc->state);
if (crtc->state)
amdgpu_dm_crtc_destroy_state(crtc, crtc->state);
}
static void dm_test_crtc_destroy_state_no_stream(struct kunit *test)
{
struct dm_crtc_state *dm_state;
dm_state = kzalloc_obj(*dm_state);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dm_state);
amdgpu_dm_crtc_destroy_state(NULL, &dm_state->base);
}
static void dm_test_crtc_destroy_state_releases_stream(struct kunit *test)
{
struct dc_stream_state *stream;
struct dm_crtc_state *dm_state;
struct dc_link *link;
link = dm_kunit_alloc_link(test);
stream = dm_kunit_alloc_stream(test, link);
kref_get(&stream->refcount);
dm_state = kzalloc_obj(*dm_state);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dm_state);
dm_state->stream = stream;
amdgpu_dm_crtc_destroy_state(NULL, &dm_state->base);
KUNIT_EXPECT_EQ(test, kref_read(&stream->refcount), 1);
}
static void dm_test_crtc_handle_vblank_no_event(struct kunit *test)
{
struct amdgpu_device *adev;
struct amdgpu_crtc *acrtc;
adev = dm_kunit_alloc_adev(test);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
KUNIT_ASSERT_EQ(test, drm_vblank_init(&adev->ddev, 1), 0);
acrtc = kunit_kzalloc(test, sizeof(*acrtc), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, acrtc);
acrtc->base.dev = &adev->ddev;
acrtc->event = NULL;
amdgpu_dm_crtc_handle_vblank(acrtc);
KUNIT_EXPECT_NULL(test, acrtc->event);
}
static void dm_test_crtc_handle_vblank_skips_when_flip_submitted(struct kunit *test)
{
struct drm_pending_vblank_event *event;
struct amdgpu_device *adev;
struct amdgpu_crtc *acrtc;
adev = dm_kunit_alloc_adev(test);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
KUNIT_ASSERT_EQ(test, drm_vblank_init(&adev->ddev, 1), 0);
acrtc = kunit_kzalloc(test, sizeof(*acrtc), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, acrtc);
event = kunit_kzalloc(test, sizeof(*event), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, event);
acrtc->base.dev = &adev->ddev;
acrtc->base.funcs = &dm_test_crtc_funcs;
INIT_LIST_HEAD(&acrtc->base.head);
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_cleanup, acrtc), 0);
acrtc->event = event;
acrtc->pflip_status = AMDGPU_FLIP_SUBMITTED;
amdgpu_dm_crtc_handle_vblank(acrtc);
KUNIT_EXPECT_PTR_EQ(test, acrtc->event, event);
}
static void dm_test_crtc_handle_vblank_completes_cursor_only(struct kunit *test)
{
struct drm_pending_vblank_event *event;
struct amdgpu_device *adev;
struct amdgpu_crtc *acrtc;
adev = dm_kunit_alloc_adev(test);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
KUNIT_ASSERT_EQ(test, drm_vblank_init(&adev->ddev, 1), 0);
acrtc = kunit_kzalloc(test, sizeof(*acrtc), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, acrtc);
event = kzalloc_obj(*event);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, event);
acrtc->base.dev = &adev->ddev;
acrtc->base.funcs = &dm_test_crtc_funcs;
INIT_LIST_HEAD(&acrtc->base.head);
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_cleanup, acrtc), 0);
acrtc->event = event;
acrtc->pflip_status = AMDGPU_FLIP_NONE;
adev->ddev.vblank[0].enabled = true;
KUNIT_ASSERT_EQ(test, drm_crtc_vblank_get(&acrtc->base), 0);
amdgpu_dm_crtc_handle_vblank(acrtc);
KUNIT_EXPECT_NULL(test, acrtc->event);
}
static struct vblank_control_work *
dm_test_vblank_control_worker_setup(struct kunit *test, bool enable,
uint32_t count)
{
struct dc_stream_state *stream;
struct vblank_control_work *work;
struct amdgpu_device *adev;
struct amdgpu_crtc *acrtc;
adev = dm_kunit_alloc_adev(test);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
mutex_init(&adev->dm.dc_lock);
adev->dm.dc = dm_kunit_alloc_dc_with_ctx(test);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev->dm.dc);
adev->dm.active_vblank_irq_count = count;
acrtc = kunit_kzalloc(test, sizeof(*acrtc), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, acrtc);
acrtc->base.dev = &adev->ddev;
acrtc->base.state = NULL;
stream = dm_kunit_alloc_stream(test, NULL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream);
kref_get(&stream->refcount);
work = kzalloc_obj(*work);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, work);
work->dm = &adev->dm;
work->acrtc = acrtc;
work->stream = stream;
work->enable = enable;
return work;
}
static void dm_test_vblank_control_worker_enable_increments(struct kunit *test)
{
struct vblank_control_work *work;
struct amdgpu_display_manager *dm;
work = dm_test_vblank_control_worker_setup(test, true, 0);
dm = work->dm;
amdgpu_dm_crtc_vblank_control_worker(&work->work);
KUNIT_EXPECT_EQ(test, dm->active_vblank_irq_count, 1);
}
static void dm_test_vblank_control_worker_disable_decrements(struct kunit *test)
{
struct vblank_control_work *work;
struct amdgpu_display_manager *dm;
work = dm_test_vblank_control_worker_setup(test, false, 2);
dm = work->dm;
amdgpu_dm_crtc_vblank_control_worker(&work->work);
KUNIT_EXPECT_EQ(test, dm->active_vblank_irq_count, 1);
}
static void dm_test_vblank_control_worker_disable_clamps_zero(struct kunit *test)
{
struct vblank_control_work *work;
struct amdgpu_display_manager *dm;
work = dm_test_vblank_control_worker_setup(test, false, 0);
dm = work->dm;
amdgpu_dm_crtc_vblank_control_worker(&work->work);
KUNIT_EXPECT_EQ(test, dm->active_vblank_irq_count, 0);
}
static void dm_test_crtc_disable_vblank_no_irq_installed(struct kunit *test)
{
struct amdgpu_device *adev;
struct amdgpu_crtc *acrtc;
adev = dm_kunit_alloc_adev(test);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
adev->dm.dc = dm_kunit_alloc_dc_with_ctx(test);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev->dm.dc);
adev->dm.dc->ctx->dce_version = DCE_VERSION_6_0;
adev->dm.active_vblank_irq_count = 0;
adev->mode_info.num_crtc = 0;
adev->irq.installed = false;
acrtc = kunit_kzalloc(test, sizeof(*acrtc), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, acrtc);
acrtc->base.dev = &adev->ddev;
acrtc->crtc_id = 0;
amdgpu_dm_crtc_disable_vblank(&acrtc->base);
KUNIT_EXPECT_EQ(test, adev->dm.active_vblank_irq_count, 0);
}
static void dm_test_crtc_disable_vblank_vrr(struct kunit *test)
{
struct amdgpu_reset_domain *reset_domain;
struct amdgpu_device *adev;
struct amdgpu_crtc *acrtc;
adev = dm_kunit_alloc_adev(test);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
adev->dm.dc = dm_kunit_alloc_dc_with_ctx(test);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev->dm.dc);
adev->dm.dc->ctx->dce_version = DCE_VERSION_8_0;
adev->mode_info.num_crtc = 1;
adev->irq.installed = true;
reset_domain = kunit_kzalloc(test, sizeof(*reset_domain), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, reset_domain);
adev->reset_domain = reset_domain;
dm_test_crtc_arm_irq_src(test, &adev->crtc_irq, 2);
dm_test_crtc_arm_irq_src(test, &adev->pageflip_irq, 2);
acrtc = kunit_kzalloc(test, sizeof(*acrtc), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, acrtc);
acrtc->base.dev = &adev->ddev;
acrtc->crtc_id = 0;
acrtc->otg_inst = -1;
amdgpu_dm_crtc_disable_vblank(&acrtc->base);
KUNIT_EXPECT_EQ(test, atomic_read(&adev->crtc_irq.enabled_types[0]), 1);
KUNIT_EXPECT_EQ(test, atomic_read(&adev->pageflip_irq.enabled_types[0]), 1);
}
static void dm_test_crtc_disable_vblank_queues_work(struct kunit *test)
{
struct amdgpu_reset_domain *reset_domain;
struct dm_crtc_state *dm_state;
struct amdgpu_device *adev;
struct amdgpu_crtc *acrtc;
adev = dm_kunit_alloc_adev(test);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
adev->dm.dc = dm_kunit_alloc_dc_with_ctx(test);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev->dm.dc);
adev->dm.dc->ctx->dce_version = DCE_VERSION_6_0;
adev->dm.active_vblank_irq_count = 2;
adev->mode_info.num_crtc = 1;
adev->irq.installed = true;
reset_domain = kunit_kzalloc(test, sizeof(*reset_domain), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, reset_domain);
adev->reset_domain = reset_domain;
dm_test_crtc_arm_irq_src(test, &adev->crtc_irq, 2);
dm_test_crtc_arm_irq_src(test, &adev->pageflip_irq, 2);
acrtc = kunit_kzalloc(test, sizeof(*acrtc), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, acrtc);
acrtc->base.dev = &adev->ddev;
acrtc->crtc_id = 0;
acrtc->otg_inst = -1;
acrtc->ism.current_state = DM_ISM_STATE_HYSTERESIS_WAITING;
dm_state = kunit_kzalloc(test, sizeof(*dm_state), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dm_state);
acrtc->base.state = &dm_state->base;
mutex_init(&adev->dm.dc_lock);
adev->dm.vblank_control_workqueue =
create_singlethread_workqueue("dm_test_vblank");
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev->dm.vblank_control_workqueue);
amdgpu_dm_crtc_disable_vblank(&acrtc->base);
destroy_workqueue(adev->dm.vblank_control_workqueue);
adev->dm.vblank_control_workqueue = NULL;
KUNIT_EXPECT_EQ(test, adev->dm.active_vblank_irq_count, 1);
}
#ifdef CONFIG_DEBUG_FS
static void dm_test_crtc_late_register_inits_debugfs(struct kunit *test)
{
struct drm_crtc *crtc;
int ret;
crtc = kunit_kzalloc(test, sizeof(*crtc), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, crtc);
crtc->debugfs_entry = debugfs_create_dir("dm_test_crtc", NULL);
ret = amdgpu_dm_crtc_late_register(crtc);
KUNIT_EXPECT_EQ(test, ret, 0);
debugfs_remove_recursive(crtc->debugfs_entry);
}
#endif
static void dm_test_crtc_init_registers_crtc(struct kunit *test)
{
struct amdgpu_device *adev;
struct amdgpu_crtc *acrtc;
struct drm_plane *cursor;
struct drm_plane *plane;
struct dc *dc;
int ret;
adev = dm_kunit_alloc_adev(test);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
dc = dm_kunit_alloc_dc_with_ctx(test);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dc);
dc->caps.max_cursor_size = 256;
adev->dm.adev = adev;
adev->dm.ddev = &adev->ddev;
adev->dm.dc = dc;
plane = drm_kunit_helper_create_primary_plane(test, &adev->ddev,
NULL, NULL, NULL, 0, NULL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, plane);
ret = amdgpu_dm_crtc_init(&adev->dm, plane, 0);
KUNIT_EXPECT_EQ(test, ret, 0);
KUNIT_EXPECT_EQ(test, adev->ddev.mode_config.num_crtc, 1);
acrtc = adev->mode_info.crtcs[0];
KUNIT_ASSERT_NOT_NULL(test, acrtc);
KUNIT_EXPECT_EQ(test, acrtc->crtc_id, 0);
KUNIT_EXPECT_EQ(test, acrtc->otg_inst, -1);
KUNIT_EXPECT_FALSE(test, acrtc->base.enabled);
KUNIT_EXPECT_EQ(test, acrtc->max_cursor_width, 256);
KUNIT_EXPECT_EQ(test, acrtc->max_cursor_height, 256);
cursor = acrtc->base.cursor;
if (acrtc->base.state) {
amdgpu_dm_crtc_destroy_state(&acrtc->base, acrtc->base.state);
acrtc->base.state = NULL;
}
amdgpu_dm_crtc_destroy(&acrtc->base);
if (cursor)
cursor->funcs->destroy(cursor);
}
static void dm_test_crtc_init_enables_degamma(struct kunit *test)
{
struct amdgpu_device *adev;
struct amdgpu_crtc *acrtc;
struct drm_plane *cursor;
struct drm_plane *plane;
struct dc *dc;
int ret;
adev = dm_kunit_alloc_adev(test);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
dc = dm_kunit_alloc_dc_with_ctx(test);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dc);
dc->caps.color.dpp.dcn_arch = 1;
dc->ctx->dce_version = DCN_VERSION_3_0;
adev->dm.adev = adev;
adev->dm.ddev = &adev->ddev;
adev->dm.dc = dc;
plane = drm_kunit_helper_create_primary_plane(test, &adev->ddev,
NULL, NULL, NULL, 0, NULL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, plane);
ret = amdgpu_dm_crtc_init(&adev->dm, plane, 0);
KUNIT_EXPECT_EQ(test, ret, 0);
KUNIT_EXPECT_EQ(test, adev->ddev.mode_config.num_crtc, 1);
acrtc = adev->mode_info.crtcs[0];
KUNIT_ASSERT_NOT_NULL(test, acrtc);
KUNIT_EXPECT_EQ(test, acrtc->otg_inst, -1);
cursor = acrtc->base.cursor;
if (acrtc->base.state) {
amdgpu_dm_crtc_destroy_state(&acrtc->base, acrtc->base.state);
acrtc->base.state = NULL;
}
amdgpu_dm_crtc_destroy(&acrtc->base);
if (cursor)
cursor->funcs->destroy(cursor);
}
static void dm_test_crtc_atomic_check_no_stream_passes(struct kunit *test)
{
struct amdgpu_device *adev;
struct dm_crtc_state *dm_crtc_state;
struct drm_atomic_commit *state;
struct drm_crtc *crtc;
int ret;
adev = dm_kunit_alloc_adev(test);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
crtc = kunit_kzalloc(test, sizeof(*crtc), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, crtc);
crtc->dev = &adev->ddev;
dm_crtc_state = kunit_kzalloc(test, sizeof(*dm_crtc_state), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dm_crtc_state);
dm_crtc_state->base.crtc = crtc;
state = kunit_kzalloc(test, sizeof(*state), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state);
state->dev = &adev->ddev;
state->crtcs = kunit_kzalloc(test, sizeof(*state->crtcs), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state->crtcs);
state->crtcs[0].new_state = &dm_crtc_state->base;
dm_crtc_state->base.state = state;
ret = amdgpu_dm_crtc_helper_atomic_check(crtc, state);
KUNIT_EXPECT_EQ(test, ret, 0);
}
static bool dm_test_atomic_check_validate_timing_ok(struct timing_generator *tg,
const struct dc_crtc_timing *timing)
{
return true;
}
static bool dm_test_atomic_check_validate_timing_fail(struct timing_generator *tg,
const struct dc_crtc_timing *timing)
{
return false;
}
static enum dc_status dm_test_atomic_check_validate_mode_timing_ok(const struct dc_stream_state *stream,
struct dc_link *link,
const struct dc_crtc_timing *timing)
{
return DC_OK;
}
static void dm_test_crtc_atomic_check_enable_without_primary_fails(struct kunit *test)
{
struct amdgpu_device *adev;
struct dm_crtc_state *dm_crtc_state;
struct drm_atomic_commit *state;
struct drm_plane *primary;
struct drm_crtc *crtc;
int ret;
adev = dm_kunit_alloc_adev(test);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
primary = kunit_kzalloc(test, sizeof(*primary), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, primary);
crtc = kunit_kzalloc(test, sizeof(*crtc), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, crtc);
crtc->dev = &adev->ddev;
crtc->primary = primary;
dm_crtc_state = kunit_kzalloc(test, sizeof(*dm_crtc_state), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dm_crtc_state);
dm_crtc_state->base.crtc = crtc;
dm_crtc_state->base.enable = true;
dm_crtc_state->base.plane_mask = 0;
state = kunit_kzalloc(test, sizeof(*state), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state);
state->dev = &adev->ddev;
state->crtcs = kunit_kzalloc(test, sizeof(*state->crtcs), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state->crtcs);
state->crtcs[0].new_state = &dm_crtc_state->base;
dm_crtc_state->base.state = state;
ret = amdgpu_dm_crtc_helper_atomic_check(crtc, state);
KUNIT_EXPECT_EQ(test, ret, -EINVAL);
}
static void dm_test_crtc_atomic_check_async_flip_non_fast_fails(struct kunit *test)
{
struct amdgpu_device *adev;
struct dm_crtc_state *dm_crtc_state;
struct drm_atomic_commit *state;
struct drm_crtc *crtc;
int ret;
adev = dm_kunit_alloc_adev(test);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
crtc = kunit_kzalloc(test, sizeof(*crtc), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, crtc);
crtc->dev = &adev->ddev;
dm_crtc_state = kunit_kzalloc(test, sizeof(*dm_crtc_state), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dm_crtc_state);
dm_crtc_state->base.crtc = crtc;
dm_crtc_state->base.async_flip = true;
dm_crtc_state->update_type = UPDATE_TYPE_FULL;
state = kunit_kzalloc(test, sizeof(*state), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state);
state->dev = &adev->ddev;
state->crtcs = kunit_kzalloc(test, sizeof(*state->crtcs), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state->crtcs);
state->crtcs[0].new_state = &dm_crtc_state->base;
dm_crtc_state->base.state = state;
ret = amdgpu_dm_crtc_helper_atomic_check(crtc, state);
KUNIT_EXPECT_EQ(test, ret, -EINVAL);
}
static void dm_test_crtc_atomic_check_vrr_pulls_primary(struct kunit *test)
{
struct drm_plane_state *primary_plane_state;
struct amdgpu_device *adev;
struct dm_crtc_state *dm_crtc_state;
struct drm_atomic_commit *state;
struct drm_plane *primary;
struct drm_crtc *crtc;
int ret;
adev = dm_kunit_alloc_adev(test);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
primary = kunit_kzalloc(test, sizeof(*primary), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, primary);
crtc = kunit_kzalloc(test, sizeof(*crtc), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, crtc);
crtc->dev = &adev->ddev;
crtc->primary = primary;
dm_crtc_state = kunit_kzalloc(test, sizeof(*dm_crtc_state), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dm_crtc_state);
dm_crtc_state->base.crtc = crtc;
dm_crtc_state->freesync_config.state = VRR_STATE_ACTIVE_VARIABLE;
state = kunit_kzalloc(test, sizeof(*state), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state);
state->dev = &adev->ddev;
state->crtcs = kunit_kzalloc(test, sizeof(*state->crtcs), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state->crtcs);
state->crtcs[0].new_state = &dm_crtc_state->base;
dm_crtc_state->base.state = state;
state->acquire_ctx = kunit_kzalloc(test, sizeof(*state->acquire_ctx), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state->acquire_ctx);
state->planes = kunit_kzalloc(test, sizeof(*state->planes), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state->planes);
primary_plane_state = kunit_kzalloc(test, sizeof(*primary_plane_state), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, primary_plane_state);
state->planes[0].new_state = primary_plane_state;
ret = amdgpu_dm_crtc_helper_atomic_check(crtc, state);
KUNIT_EXPECT_EQ(test, ret, 0);
}
static void dm_test_crtc_atomic_check_valid_stream_passes(struct kunit *test)
{
struct timing_generator_funcs *tg_funcs;
struct timing_generator *tg;
struct resource_pool *res_pool;
struct link_service *link_srv;
struct amdgpu_device *adev;
struct dm_crtc_state *dm_crtc_state;
struct drm_atomic_commit *state;
struct dc_stream_state *stream;
struct dc_link *link;
struct drm_crtc *crtc;
struct dc *dc;
int ret;
adev = dm_kunit_alloc_adev(test);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
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);
tg = kunit_kzalloc(test, sizeof(*tg), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, tg);
tg_funcs = kunit_kzalloc(test, sizeof(*tg_funcs), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, tg_funcs);
tg_funcs->validate_timing = dm_test_atomic_check_validate_timing_ok;
tg->funcs = tg_funcs;
res_pool->timing_generators[0] = tg;
dc->res_pool = res_pool;
link_srv = kunit_kzalloc(test, sizeof(*link_srv), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, link_srv);
link_srv->validate_mode_timing = dm_test_atomic_check_validate_mode_timing_ok;
dc->link_srv = link_srv;
adev->dm.dc = dc;
link = dm_kunit_alloc_link(test);
link->ep_type = DISPLAY_ENDPOINT_UNKNOWN;
stream = dm_kunit_alloc_stream(test, link);
crtc = kunit_kzalloc(test, sizeof(*crtc), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, crtc);
crtc->dev = &adev->ddev;
dm_crtc_state = kunit_kzalloc(test, sizeof(*dm_crtc_state), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dm_crtc_state);
dm_crtc_state->base.crtc = crtc;
dm_crtc_state->stream = stream;
state = kunit_kzalloc(test, sizeof(*state), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state);
state->dev = &adev->ddev;
state->crtcs = kunit_kzalloc(test, sizeof(*state->crtcs), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state->crtcs);
state->crtcs[0].new_state = &dm_crtc_state->base;
dm_crtc_state->base.state = state;
ret = amdgpu_dm_crtc_helper_atomic_check(crtc, state);
KUNIT_EXPECT_EQ(test, ret, 0);
}
static void dm_test_crtc_atomic_check_invalid_stream_fails(struct kunit *test)
{
struct timing_generator_funcs *tg_funcs;
struct timing_generator *tg;
struct resource_pool *res_pool;
struct amdgpu_device *adev;
struct dm_crtc_state *dm_crtc_state;
struct drm_atomic_commit *state;
struct dc_stream_state *stream;
struct dc_link *link;
struct drm_crtc *crtc;
struct dc *dc;
int ret;
adev = dm_kunit_alloc_adev(test);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, adev);
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);
tg = kunit_kzalloc(test, sizeof(*tg), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, tg);
tg_funcs = kunit_kzalloc(test, sizeof(*tg_funcs), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, tg_funcs);
tg_funcs->validate_timing = dm_test_atomic_check_validate_timing_fail;
tg->funcs = tg_funcs;
res_pool->timing_generators[0] = tg;
dc->res_pool = res_pool;
adev->dm.dc = dc;
link = dm_kunit_alloc_link(test);
stream = dm_kunit_alloc_stream(test, link);
crtc = kunit_kzalloc(test, sizeof(*crtc), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, crtc);
crtc->dev = &adev->ddev;
dm_crtc_state = kunit_kzalloc(test, sizeof(*dm_crtc_state), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dm_crtc_state);
dm_crtc_state->base.crtc = crtc;
dm_crtc_state->stream = stream;
state = kunit_kzalloc(test, sizeof(*state), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state);
state->dev = &adev->ddev;
state->crtcs = kunit_kzalloc(test, sizeof(*state->crtcs), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, state->crtcs);
state->crtcs[0].new_state = &dm_crtc_state->base;
dm_crtc_state->base.state = state;
ret = amdgpu_dm_crtc_helper_atomic_check(crtc, state);
KUNIT_EXPECT_EQ(test, ret, -EINVAL);
}
static struct kunit_case amdgpu_dm_crtc_tests[] = {
KUNIT_CASE(dm_test_crtc_modeset_required_active_mode_changed),
KUNIT_CASE(dm_test_crtc_modeset_required_active_state_changed),
KUNIT_CASE(dm_test_crtc_modeset_required_active_connectors_changed),
KUNIT_CASE(dm_test_crtc_modeset_required_inactive),
KUNIT_CASE(dm_test_crtc_modeset_required_no_changes),
KUNIT_CASE(dm_test_crtc_vrr_active_irq_variable),
KUNIT_CASE(dm_test_crtc_vrr_active_irq_fixed),
KUNIT_CASE(dm_test_crtc_vrr_active_irq_inactive),
KUNIT_CASE(dm_test_crtc_vrr_active_irq_disabled),
KUNIT_CASE(dm_test_crtc_vrr_active_irq_unsupported),
KUNIT_CASE(dm_test_crtc_vrr_active_variable),
KUNIT_CASE(dm_test_crtc_vrr_active_fixed),
KUNIT_CASE(dm_test_crtc_vrr_active_inactive),
KUNIT_CASE(dm_test_crtc_vrr_active_disabled),
KUNIT_CASE(dm_test_crtc_vrr_active_unsupported),
KUNIT_CASE(dm_test_crtc_is_headless_null_adev),
KUNIT_CASE(dm_test_crtc_is_headless_no_connectors),
KUNIT_CASE(dm_test_crtc_is_headless_writeback_only),
KUNIT_CASE(dm_test_crtc_is_headless_disconnected_display),
KUNIT_CASE(dm_test_crtc_is_headless_connected_display),
KUNIT_CASE(dm_test_crtc_is_headless_mixed_connectors),
KUNIT_CASE(dm_test_crtc_helper_mode_fixup_returns_true),
KUNIT_CASE(dm_test_crtc_set_vupdate_irq_no_otg),
KUNIT_CASE(dm_test_crtc_set_vupdate_irq_dc_busy),
KUNIT_CASE(dm_test_crtc_set_vupdate_irq_enable),
KUNIT_CASE(dm_test_idle_create_workqueue),
KUNIT_CASE(dm_test_idle_worker_disabled_clears_running),
KUNIT_CASE(dm_test_idle_worker_enabled_breaks_when_idle_disallowed),
KUNIT_CASE(dm_test_idle_worker_enabled_breaks_when_not_headless),
KUNIT_CASE(dm_test_idle_worker_enabled_runs_body),
KUNIT_CASE(dm_test_crtc_set_static_screen_optimze_no_sr_entry),
KUNIT_CASE(dm_test_crtc_set_static_screen_optimze_sr_entry_psr),
KUNIT_CASE(dm_test_crtc_set_static_screen_optimze_psr_su_skips),
KUNIT_CASE(dm_test_crtc_enable_vblank_rejects_unconfigured),
KUNIT_CASE(dm_test_crtc_enable_vblank_full_path),
KUNIT_CASE(dm_test_crtc_enable_vblank_vupdate_busy),
KUNIT_CASE(dm_test_crtc_enable_vblank_crtc_irq_error),
KUNIT_CASE(dm_test_crtc_enable_vblank_in_reset),
KUNIT_CASE(dm_test_crtc_enable_vblank_queues_work),
KUNIT_CASE(dm_test_crtc_enable_vblank_ips_restore),
KUNIT_CASE(dm_test_crtc_enable_vblank_ips_restore_replay),
KUNIT_CASE(dm_test_crtc_set_vline0_irq_dce_noop),
KUNIT_CASE(dm_test_crtc_set_vline0_irq_error),
KUNIT_CASE(dm_test_crtc_set_vline0_irq_enable_disable),
KUNIT_CASE(dm_test_crtc_update_active_planes_no_stream),
KUNIT_CASE(dm_test_count_crtc_active_planes_none),
KUNIT_CASE(dm_test_count_crtc_active_planes_mixed),
KUNIT_CASE(dm_test_crtc_duplicate_state_copies_fields),
KUNIT_CASE(dm_test_crtc_duplicate_state_retains_stream),
KUNIT_CASE(dm_test_crtc_duplicate_state_null_state_returns_null),
KUNIT_CASE(dm_test_crtc_destroy_cleans_up_and_frees),
KUNIT_CASE(dm_test_crtc_create_state_allocates_state),
KUNIT_CASE(dm_test_crtc_reset_state_replaces_existing),
KUNIT_CASE(dm_test_crtc_destroy_state_no_stream),
KUNIT_CASE(dm_test_crtc_destroy_state_releases_stream),
KUNIT_CASE(dm_test_crtc_handle_vblank_no_event),
KUNIT_CASE(dm_test_crtc_handle_vblank_skips_when_flip_submitted),
KUNIT_CASE(dm_test_crtc_handle_vblank_completes_cursor_only),
KUNIT_CASE(dm_test_vblank_control_worker_enable_increments),
KUNIT_CASE(dm_test_vblank_control_worker_disable_decrements),
KUNIT_CASE(dm_test_vblank_control_worker_disable_clamps_zero),
KUNIT_CASE(dm_test_crtc_disable_vblank_no_irq_installed),
KUNIT_CASE(dm_test_crtc_disable_vblank_vrr),
KUNIT_CASE(dm_test_crtc_disable_vblank_queues_work),
#ifdef CONFIG_DEBUG_FS
KUNIT_CASE(dm_test_crtc_late_register_inits_debugfs),
#endif
KUNIT_CASE(dm_test_crtc_init_registers_crtc),
KUNIT_CASE(dm_test_crtc_init_enables_degamma),
KUNIT_CASE(dm_test_crtc_atomic_check_no_stream_passes),
KUNIT_CASE(dm_test_crtc_atomic_check_enable_without_primary_fails),
KUNIT_CASE(dm_test_crtc_atomic_check_async_flip_non_fast_fails),
KUNIT_CASE(dm_test_crtc_atomic_check_vrr_pulls_primary),
KUNIT_CASE(dm_test_crtc_atomic_check_valid_stream_passes),
KUNIT_CASE(dm_test_crtc_atomic_check_invalid_stream_fails),
{}
};
static struct kunit_suite amdgpu_dm_crtc_test_suite = {
.name = "amdgpu_dm_crtc",
.test_cases = amdgpu_dm_crtc_tests,
};
kunit_test_suite(amdgpu_dm_crtc_test_suite);
MODULE_AUTHOR("AMD");
MODULE_DESCRIPTION("KUnit tests for amdgpu_dm_crtc");
MODULE_LICENSE("Dual MIT/GPL"