#include <kunit/test.h>
#include <linux/workqueue.h>
#include <linux/kobject.h>
#include <linux/slab.h>
#include <linux/sysfs.h>
#include <linux/i2c.h>
#include <drm/display/drm_dp_helper.h>
#include "amdgpu.h"
#include "amdgpu_dm.h"
#include "amdgpu_dm_hdcp.h"
#include "amdgpu_dm_kunit_test_helpers.h"
#include "hdcp_psp.h"
static void dummy_work_fn(struct work_struct *work) {}
static void dm_test_hdcp_get_cp_disabled_returns_desired(struct kunit *test)
{
unsigned int content_protection = DRM_MODE_CONTENT_PROTECTION_UNDESIRED;
bool update;
update = hdcp_get_content_protection_from_status(
DRM_MODE_HDCP_CONTENT_TYPE0,
MOD_HDCP_ENCRYPTION_STATUS_HDCP_OFF,
&content_protection);
KUNIT_EXPECT_TRUE(test, update);
KUNIT_EXPECT_EQ(test, content_protection,
DRM_MODE_CONTENT_PROTECTION_DESIRED);
}
static void dm_test_hdcp_get_cp_type0_returns_enabled(struct kunit *test)
{
unsigned int content_protection = DRM_MODE_CONTENT_PROTECTION_UNDESIRED;
bool update;
update = hdcp_get_content_protection_from_status(
DRM_MODE_HDCP_CONTENT_TYPE0,
MOD_HDCP_ENCRYPTION_STATUS_HDCP2_TYPE0_ON,
&content_protection);
KUNIT_EXPECT_TRUE(test, update);
KUNIT_EXPECT_EQ(test, content_protection,
DRM_MODE_CONTENT_PROTECTION_ENABLED);
}
static void dm_test_hdcp_get_cp_type1_returns_enabled(struct kunit *test)
{
unsigned int content_protection = DRM_MODE_CONTENT_PROTECTION_UNDESIRED;
bool update;
update = hdcp_get_content_protection_from_status(
DRM_MODE_HDCP_CONTENT_TYPE1,
MOD_HDCP_ENCRYPTION_STATUS_HDCP2_TYPE1_ON,
&content_protection);
KUNIT_EXPECT_TRUE(test, update);
KUNIT_EXPECT_EQ(test, content_protection,
DRM_MODE_CONTENT_PROTECTION_ENABLED);
}
static void dm_test_hdcp_get_cp_type1_rejects_type0_status(struct kunit *test)
{
unsigned int content_protection = DRM_MODE_CONTENT_PROTECTION_UNDESIRED;
bool update;
update = hdcp_get_content_protection_from_status(
DRM_MODE_HDCP_CONTENT_TYPE1,
MOD_HDCP_ENCRYPTION_STATUS_HDCP2_TYPE0_ON,
&content_protection);
KUNIT_EXPECT_FALSE(test, update);
KUNIT_EXPECT_EQ(test, content_protection,
DRM_MODE_CONTENT_PROTECTION_UNDESIRED);
}
static void dm_test_hdcp_get_cp_type0_rejects_type1_status(struct kunit *test)
{
unsigned int content_protection = DRM_MODE_CONTENT_PROTECTION_UNDESIRED;
bool update;
update = hdcp_get_content_protection_from_status(
DRM_MODE_HDCP_CONTENT_TYPE0,
MOD_HDCP_ENCRYPTION_STATUS_HDCP2_TYPE1_ON,
&content_protection);
KUNIT_EXPECT_FALSE(test, update);
KUNIT_EXPECT_EQ(test, content_protection,
DRM_MODE_CONTENT_PROTECTION_UNDESIRED);
}
static void dm_test_hdcp_get_adjustments_disable_authentication(struct kunit *test)
{
struct mod_hdcp_link_adjustment link_adjust;
struct mod_hdcp_display_adjustment display_adjust;
unsigned int disable;
unsigned int hdcp1_disable;
unsigned int force_type;
hdcp_get_link_display_adjustments(false, DRM_MODE_HDCP_CONTENT_TYPE0,
false, false, false, &link_adjust, &display_adjust);
disable = display_adjust.disable;
hdcp1_disable = link_adjust.hdcp1.disable;
force_type = link_adjust.hdcp2.force_type;
KUNIT_EXPECT_EQ(test, disable,
MOD_HDCP_DISPLAY_DISABLE_AUTHENTICATION);
KUNIT_EXPECT_EQ(test, link_adjust.auth_delay, 0);
KUNIT_EXPECT_EQ(test, link_adjust.retry_limit, 0);
KUNIT_EXPECT_EQ(test, hdcp1_disable, 0);
KUNIT_EXPECT_EQ(test, force_type, 0);
}
static void dm_test_hdcp_get_adjustments_type0_policy(struct kunit *test)
{
struct mod_hdcp_link_adjustment link_adjust;
struct mod_hdcp_display_adjustment display_adjust;
unsigned int disable;
unsigned int hdcp1_disable;
unsigned int force_type;
hdcp_get_link_display_adjustments(true, DRM_MODE_HDCP_CONTENT_TYPE0,
false, false, true, &link_adjust, &display_adjust);
disable = display_adjust.disable;
hdcp1_disable = link_adjust.hdcp1.disable;
force_type = link_adjust.hdcp2.force_type;
KUNIT_EXPECT_EQ(test, disable,
MOD_HDCP_DISPLAY_NOT_DISABLE);
KUNIT_EXPECT_EQ(test, link_adjust.auth_delay, 2);
KUNIT_EXPECT_EQ(test, link_adjust.retry_limit, MAX_NUM_OF_ATTEMPTS);
KUNIT_EXPECT_EQ(test, hdcp1_disable, 0);
KUNIT_EXPECT_EQ(test, force_type,
MOD_HDCP_FORCE_TYPE_0);
KUNIT_EXPECT_FALSE(test, link_adjust.hdcp2.use_fw_locality_check);
KUNIT_EXPECT_TRUE(test, link_adjust.hdcp2.use_sw_locality_fallback);
}
static void dm_test_hdcp_get_adjustments_type1_policy(struct kunit *test)
{
struct mod_hdcp_link_adjustment link_adjust;
struct mod_hdcp_display_adjustment display_adjust;
unsigned int disable;
unsigned int hdcp1_disable;
unsigned int force_type;
hdcp_get_link_display_adjustments(true, DRM_MODE_HDCP_CONTENT_TYPE1,
false, true, false, &link_adjust, &display_adjust);
disable = display_adjust.disable;
hdcp1_disable = link_adjust.hdcp1.disable;
force_type = link_adjust.hdcp2.force_type;
KUNIT_EXPECT_EQ(test, disable,
MOD_HDCP_DISPLAY_NOT_DISABLE);
KUNIT_EXPECT_EQ(test, link_adjust.auth_delay, 2);
KUNIT_EXPECT_EQ(test, link_adjust.retry_limit, MAX_NUM_OF_ATTEMPTS);
KUNIT_EXPECT_EQ(test, hdcp1_disable, 1);
KUNIT_EXPECT_EQ(test, force_type,
MOD_HDCP_FORCE_TYPE_1);
KUNIT_EXPECT_TRUE(test, link_adjust.hdcp2.use_fw_locality_check);
KUNIT_EXPECT_FALSE(test, link_adjust.hdcp2.use_sw_locality_fallback);
}
static void dm_test_hdcp_get_adjustments_fused_io_enables_fw_check(struct kunit *test)
{
struct mod_hdcp_link_adjustment link_adjust;
struct mod_hdcp_display_adjustment display_adjust;
hdcp_get_link_display_adjustments(true, DRM_MODE_HDCP_CONTENT_TYPE0,
true, false, false, &link_adjust, &display_adjust);
KUNIT_EXPECT_TRUE(test, link_adjust.hdcp2.use_fw_locality_check);
}
static struct hdcp_workqueue *alloc_test_workqueue(struct kunit *test)
{
struct hdcp_workqueue *work;
work = kunit_kzalloc(test, sizeof(*work), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, work);
INIT_DELAYED_WORK(&work->callback_dwork, dummy_work_fn);
INIT_DELAYED_WORK(&work->watchdog_timer_dwork, dummy_work_fn);
INIT_DELAYED_WORK(&work->property_validate_dwork, dummy_work_fn);
return work;
}
static void dm_test_process_output_property_validate_always_scheduled(struct kunit *test)
{
struct hdcp_workqueue *work = alloc_test_workqueue(test);
process_output(work);
KUNIT_EXPECT_TRUE(test, work_pending(&work->property_validate_dwork.work));
KUNIT_EXPECT_FALSE(test, delayed_work_pending(&work->callback_dwork));
KUNIT_EXPECT_FALSE(test, delayed_work_pending(&work->watchdog_timer_dwork));
cancel_delayed_work_sync(&work->property_validate_dwork);
}
static void dm_test_process_output_callback_needed(struct kunit *test)
{
struct hdcp_workqueue *work = alloc_test_workqueue(test);
work->output.callback_needed = true;
work->output.callback_delay = 500;
process_output(work);
KUNIT_EXPECT_TRUE(test, delayed_work_pending(&work->callback_dwork));
cancel_delayed_work_sync(&work->callback_dwork);
cancel_delayed_work_sync(&work->property_validate_dwork);
}
static void dm_test_process_output_callback_stop(struct kunit *test)
{
struct hdcp_workqueue *work = alloc_test_workqueue(test);
schedule_delayed_work(&work->callback_dwork, msecs_to_jiffies(10000));
KUNIT_ASSERT_TRUE(test, delayed_work_pending(&work->callback_dwork));
work->output.callback_stop = true;
process_output(work);
KUNIT_EXPECT_FALSE(test, delayed_work_pending(&work->callback_dwork));
cancel_delayed_work_sync(&work->property_validate_dwork);
}
static void dm_test_process_output_watchdog_needed(struct kunit *test)
{
struct hdcp_workqueue *work = alloc_test_workqueue(test);
work->output.watchdog_timer_needed = true;
work->output.watchdog_timer_delay = 1000;
process_output(work);
KUNIT_EXPECT_TRUE(test, delayed_work_pending(&work->watchdog_timer_dwork));
cancel_delayed_work_sync(&work->watchdog_timer_dwork);
cancel_delayed_work_sync(&work->property_validate_dwork);
}
static void dm_test_process_output_watchdog_stop(struct kunit *test)
{
struct hdcp_workqueue *work = alloc_test_workqueue(test);
schedule_delayed_work(&work->watchdog_timer_dwork, msecs_to_jiffies(10000));
KUNIT_ASSERT_TRUE(test, delayed_work_pending(&work->watchdog_timer_dwork));
work->output.watchdog_timer_stop = true;
process_output(work);
KUNIT_EXPECT_FALSE(test, delayed_work_pending(&work->watchdog_timer_dwork));
cancel_delayed_work_sync(&work->property_validate_dwork);
}
static void dm_test_process_output_callback_and_watchdog_needed(struct kunit *test)
{
struct hdcp_workqueue *work = alloc_test_workqueue(test);
work->output.callback_needed = true;
work->output.callback_delay = 200;
work->output.watchdog_timer_needed = true;
work->output.watchdog_timer_delay = 800;
process_output(work);
KUNIT_EXPECT_TRUE(test, delayed_work_pending(&work->callback_dwork));
KUNIT_EXPECT_TRUE(test, delayed_work_pending(&work->watchdog_timer_dwork));
cancel_delayed_work_sync(&work->callback_dwork);
cancel_delayed_work_sync(&work->watchdog_timer_dwork);
cancel_delayed_work_sync(&work->property_validate_dwork);
}
static void dm_test_process_output_callback_stop_and_needed_requeues(struct kunit *test)
{
struct hdcp_workqueue *work = alloc_test_workqueue(test);
schedule_delayed_work(&work->callback_dwork, msecs_to_jiffies(10000));
KUNIT_ASSERT_TRUE(test, delayed_work_pending(&work->callback_dwork));
work->output.callback_stop = true;
work->output.callback_needed = true;
work->output.callback_delay = 300;
process_output(work);
KUNIT_EXPECT_TRUE(test, delayed_work_pending(&work->callback_dwork));
cancel_delayed_work_sync(&work->callback_dwork);
cancel_delayed_work_sync(&work->property_validate_dwork);
}
static void dm_test_process_output_watchdog_stop_and_needed_requeues(struct kunit *test)
{
struct hdcp_workqueue *work = alloc_test_workqueue(test);
schedule_delayed_work(&work->watchdog_timer_dwork, msecs_to_jiffies(10000));
KUNIT_ASSERT_TRUE(test, delayed_work_pending(&work->watchdog_timer_dwork));
work->output.watchdog_timer_stop = true;
work->output.watchdog_timer_needed = true;
work->output.watchdog_timer_delay = 700;
process_output(work);
KUNIT_EXPECT_TRUE(test, delayed_work_pending(&work->watchdog_timer_dwork));
cancel_delayed_work_sync(&work->watchdog_timer_dwork);
cancel_delayed_work_sync(&work->property_validate_dwork);
}
static struct hdcp_workqueue *alloc_test_workqueue_for_property_update(struct kunit *test)
{
struct hdcp_workqueue *work;
work = kunit_kzalloc(test, sizeof(*work), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, work);
mutex_init(&work->mutex);
INIT_WORK(&work->property_update_work, dummy_work_fn);
return work;
}
static struct amdgpu_dm_connector *alloc_update_connector(struct kunit *test,
enum drm_connector_status status,
struct drm_connector_state *conn_state,
struct drm_device *dev)
{
struct amdgpu_dm_connector *aconnector;
aconnector = kunit_kzalloc(test, sizeof(*aconnector), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, aconnector);
aconnector->base.status = status;
aconnector->base.state = conn_state;
aconnector->base.dev = dev;
return aconnector;
}
static void dm_test_event_property_update_skips_null_connector(struct kunit *test)
{
struct hdcp_workqueue *work = alloc_test_workqueue_for_property_update(test);
enum mod_hdcp_encryption_status before;
work->encryption_status[0] = MOD_HDCP_ENCRYPTION_STATUS_HDCP2_TYPE0_ON;
before = work->encryption_status[0];
event_property_update(&work->property_update_work);
KUNIT_EXPECT_EQ(test, work->encryption_status[0], before);
}
static void dm_test_event_property_update_skips_disconnected(struct kunit *test)
{
struct hdcp_workqueue *work = alloc_test_workqueue_for_property_update(test);
struct drm_connector_state *conn_state;
conn_state = kunit_kzalloc(test, sizeof(*conn_state), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, conn_state);
work->aconnector[1] = alloc_update_connector(test, connector_status_disconnected,
conn_state, NULL);
work->encryption_status[1] = MOD_HDCP_ENCRYPTION_STATUS_HDCP2_TYPE1_ON;
event_property_update(&work->property_update_work);
KUNIT_EXPECT_EQ(test, work->encryption_status[1],
MOD_HDCP_ENCRYPTION_STATUS_HDCP2_TYPE1_ON);
}
static void dm_test_event_property_update_skips_null_state(struct kunit *test)
{
struct hdcp_workqueue *work = alloc_test_workqueue_for_property_update(test);
work->aconnector[2] = alloc_update_connector(test, connector_status_connected,
NULL, NULL);
work->encryption_status[2] = MOD_HDCP_ENCRYPTION_STATUS_HDCP2_TYPE1_ON;
event_property_update(&work->property_update_work);
KUNIT_EXPECT_EQ(test, work->encryption_status[2],
MOD_HDCP_ENCRYPTION_STATUS_HDCP2_TYPE1_ON);
}
static void dm_test_event_property_update_skips_null_dev(struct kunit *test)
{
struct hdcp_workqueue *work = alloc_test_workqueue_for_property_update(test);
struct drm_connector_state *conn_state;
conn_state = kunit_kzalloc(test, sizeof(*conn_state), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, conn_state);
work->aconnector[3] = alloc_update_connector(test, connector_status_connected,
conn_state, NULL);
work->encryption_status[3] = MOD_HDCP_ENCRYPTION_STATUS_HDCP2_TYPE1_ON;
event_property_update(&work->property_update_work);
KUNIT_EXPECT_EQ(test, work->encryption_status[3],
MOD_HDCP_ENCRYPTION_STATUS_HDCP2_TYPE1_ON);
}
static void dm_test_event_property_update_desired_when_off(struct kunit *test)
{
struct amdgpu_device *adev = dm_kunit_alloc_adev(test);
struct hdcp_workqueue *work = alloc_test_workqueue_for_property_update(test);
struct drm_connector_state *conn_state;
conn_state = kunit_kzalloc(test, sizeof(*conn_state), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, conn_state);
conn_state->content_protection = DRM_MODE_CONTENT_PROTECTION_DESIRED;
work->aconnector[0] = alloc_update_connector(test, connector_status_connected,
conn_state, &adev->ddev);
work->encryption_status[0] = MOD_HDCP_ENCRYPTION_STATUS_HDCP_OFF;
event_property_update(&work->property_update_work);
KUNIT_EXPECT_EQ(test, conn_state->content_protection,
(unsigned int)DRM_MODE_CONTENT_PROTECTION_DESIRED);
KUNIT_EXPECT_EQ(test, work->encryption_status[0],
MOD_HDCP_ENCRYPTION_STATUS_HDCP_OFF);
}
static void dm_test_event_property_update_enabled_when_encrypted(struct kunit *test)
{
struct amdgpu_device *adev = dm_kunit_alloc_adev(test);
struct hdcp_workqueue *work = alloc_test_workqueue_for_property_update(test);
struct drm_connector_state *conn_state;
conn_state = kunit_kzalloc(test, sizeof(*conn_state), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, conn_state);
conn_state->hdcp_content_type = DRM_MODE_HDCP_CONTENT_TYPE0;
conn_state->content_protection = DRM_MODE_CONTENT_PROTECTION_ENABLED;
work->aconnector[0] = alloc_update_connector(test, connector_status_connected,
conn_state, &adev->ddev);
work->encryption_status[0] = MOD_HDCP_ENCRYPTION_STATUS_HDCP1_ON;
event_property_update(&work->property_update_work);
KUNIT_EXPECT_EQ(test, conn_state->content_protection,
(unsigned int)DRM_MODE_CONTENT_PROTECTION_ENABLED);
KUNIT_EXPECT_EQ(test, work->encryption_status[0],
MOD_HDCP_ENCRYPTION_STATUS_HDCP1_ON);
}
static struct hdcp_workqueue *alloc_test_workqueue_for_callback(struct kunit *test)
{
struct hdcp_workqueue *work;
work = kunit_kzalloc(test, sizeof(*work), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, work);
mutex_init(&work->mutex);
INIT_DELAYED_WORK(&work->callback_dwork, dummy_work_fn);
INIT_DELAYED_WORK(&work->watchdog_timer_dwork, dummy_work_fn);
INIT_DELAYED_WORK(&work->property_validate_dwork, dummy_work_fn);
return work;
}
static void dm_test_event_callback_cancels_callback_dwork(struct kunit *test)
{
struct hdcp_workqueue *work = alloc_test_workqueue_for_callback(test);
schedule_delayed_work(&work->callback_dwork, msecs_to_jiffies(10000));
KUNIT_ASSERT_TRUE(test, delayed_work_pending(&work->callback_dwork));
event_callback(&work->callback_dwork.work);
KUNIT_EXPECT_FALSE(test, delayed_work_pending(&work->callback_dwork));
cancel_delayed_work_sync(&work->callback_dwork);
cancel_delayed_work_sync(&work->watchdog_timer_dwork);
cancel_delayed_work_sync(&work->property_validate_dwork);
}
static void dm_test_event_callback_schedules_property_validate(struct kunit *test)
{
struct hdcp_workqueue *work = alloc_test_workqueue_for_callback(test);
event_callback(&work->callback_dwork.work);
KUNIT_EXPECT_TRUE(test, work_pending(&work->property_validate_dwork.work));
KUNIT_EXPECT_FALSE(test, mutex_is_locked(&work->mutex));
cancel_delayed_work_sync(&work->callback_dwork);
cancel_delayed_work_sync(&work->watchdog_timer_dwork);
cancel_delayed_work_sync(&work->property_validate_dwork);
}
static struct hdcp_workqueue *alloc_test_workqueue_for_property_validate(struct kunit *test)
{
struct hdcp_workqueue *work;
work = kunit_kzalloc(test, sizeof(*work), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, work);
mutex_init(&work->mutex);
INIT_WORK(&work->property_update_work, dummy_work_fn);
return work;
}
static struct amdgpu_dm_connector *alloc_validate_connector(struct kunit *test,
unsigned int index,
enum drm_connector_status status,
bool with_state)
{
struct amdgpu_dm_connector *aconnector;
aconnector = kunit_kzalloc(test, sizeof(*aconnector), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, aconnector);
aconnector->base.index = index;
aconnector->base.status = status;
if (with_state) {
struct drm_connector_state *conn_state;
conn_state = kunit_kzalloc(test, sizeof(*conn_state), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, conn_state);
aconnector->base.state = conn_state;
}
return aconnector;
}
static void dm_test_event_property_validate_skips_null_connector(struct kunit *test)
{
struct hdcp_workqueue *work = alloc_test_workqueue_for_property_validate(test);
work->encryption_status[0] = MOD_HDCP_ENCRYPTION_STATUS_HDCP2_TYPE1_ON;
event_property_validate(&work->property_validate_dwork.work);
KUNIT_EXPECT_FALSE(test, work_pending(&work->property_update_work));
KUNIT_EXPECT_EQ(test, work->encryption_status[0],
MOD_HDCP_ENCRYPTION_STATUS_HDCP2_TYPE1_ON);
}
static void dm_test_event_property_validate_skips_disconnected(struct kunit *test)
{
struct hdcp_workqueue *work = alloc_test_workqueue_for_property_validate(test);
work->aconnector[1] = alloc_validate_connector(test, 1,
connector_status_disconnected, true);
work->encryption_status[1] = MOD_HDCP_ENCRYPTION_STATUS_HDCP2_TYPE1_ON;
event_property_validate(&work->property_validate_dwork.work);
KUNIT_EXPECT_FALSE(test, work_pending(&work->property_update_work));
KUNIT_EXPECT_EQ(test, work->encryption_status[1],
MOD_HDCP_ENCRYPTION_STATUS_HDCP2_TYPE1_ON);
}
static void dm_test_event_property_validate_skips_null_state(struct kunit *test)
{
struct hdcp_workqueue *work = alloc_test_workqueue_for_property_validate(test);
work->aconnector[2] = alloc_validate_connector(test, 2,
connector_status_connected, false);
work->encryption_status[2] = MOD_HDCP_ENCRYPTION_STATUS_HDCP2_TYPE1_ON;
event_property_validate(&work->property_validate_dwork.work);
KUNIT_EXPECT_FALSE(test, work_pending(&work->property_update_work));
KUNIT_EXPECT_EQ(test, work->encryption_status[2],
MOD_HDCP_ENCRYPTION_STATUS_HDCP2_TYPE1_ON);
}
static void dm_test_event_property_validate_updates_on_status_change(struct kunit *test)
{
struct hdcp_workqueue *work = alloc_test_workqueue_for_property_validate(test);
work->aconnector[3] = alloc_validate_connector(test, 3,
connector_status_connected, true);
work->encryption_status[3] = MOD_HDCP_ENCRYPTION_STATUS_HDCP2_TYPE1_ON;
event_property_validate(&work->property_validate_dwork.work);
KUNIT_EXPECT_EQ(test, work->encryption_status[3],
MOD_HDCP_ENCRYPTION_STATUS_HDCP_OFF);
KUNIT_EXPECT_TRUE(test, work_pending(&work->property_update_work));
cancel_work_sync(&work->property_update_work);
}
static void dm_test_event_property_validate_no_update_when_unchanged(struct kunit *test)
{
struct hdcp_workqueue *work = alloc_test_workqueue_for_property_validate(test);
work->aconnector[4] = alloc_validate_connector(test, 4,
connector_status_connected, true);
work->encryption_status[4] = MOD_HDCP_ENCRYPTION_STATUS_HDCP_OFF;
event_property_validate(&work->property_validate_dwork.work);
KUNIT_EXPECT_EQ(test, work->encryption_status[4],
MOD_HDCP_ENCRYPTION_STATUS_HDCP_OFF);
KUNIT_EXPECT_FALSE(test, work_pending(&work->property_update_work));
}
static void dm_test_event_watchdog_timer_cancels_watchdog_dwork(struct kunit *test)
{
struct hdcp_workqueue *work = alloc_test_workqueue_for_callback(test);
schedule_delayed_work(&work->watchdog_timer_dwork, msecs_to_jiffies(10000));
KUNIT_ASSERT_TRUE(test, delayed_work_pending(&work->watchdog_timer_dwork));
event_watchdog_timer(&work->watchdog_timer_dwork.work);
KUNIT_EXPECT_FALSE(test, delayed_work_pending(&work->watchdog_timer_dwork));
cancel_delayed_work_sync(&work->callback_dwork);
cancel_delayed_work_sync(&work->watchdog_timer_dwork);
cancel_delayed_work_sync(&work->property_validate_dwork);
}
static void dm_test_event_watchdog_timer_schedules_property_validate(struct kunit *test)
{
struct hdcp_workqueue *work = alloc_test_workqueue_for_callback(test);
event_watchdog_timer(&work->watchdog_timer_dwork.work);
KUNIT_EXPECT_TRUE(test, work_pending(&work->property_validate_dwork.work));
KUNIT_EXPECT_FALSE(test, mutex_is_locked(&work->mutex));
cancel_delayed_work_sync(&work->callback_dwork);
cancel_delayed_work_sync(&work->watchdog_timer_dwork);
cancel_delayed_work_sync(&work->property_validate_dwork);
}
static struct hdcp_workqueue *alloc_test_workqueue_for_cpirq(struct kunit *test)
{
struct hdcp_workqueue *work;
work = kunit_kzalloc(test, sizeof(*work), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, work);
mutex_init(&work->mutex);
INIT_WORK(&work->cpirq_work, dummy_work_fn);
INIT_DELAYED_WORK(&work->callback_dwork, dummy_work_fn);
INIT_DELAYED_WORK(&work->watchdog_timer_dwork, dummy_work_fn);
INIT_DELAYED_WORK(&work->property_validate_dwork, dummy_work_fn);
return work;
}
static void dm_test_event_cpirq_schedules_property_validate(struct kunit *test)
{
struct hdcp_workqueue *work = alloc_test_workqueue_for_cpirq(test);
event_cpirq(&work->cpirq_work);
KUNIT_EXPECT_TRUE(test, work_pending(&work->property_validate_dwork.work));
KUNIT_EXPECT_FALSE(test, mutex_is_locked(&work->mutex));
cancel_delayed_work_sync(&work->callback_dwork);
cancel_delayed_work_sync(&work->watchdog_timer_dwork);
cancel_delayed_work_sync(&work->property_validate_dwork);
}
static void dm_test_event_cpirq_leaves_callback_and_watchdog_idle(struct kunit *test)
{
struct hdcp_workqueue *work = alloc_test_workqueue_for_cpirq(test);
event_cpirq(&work->cpirq_work);
KUNIT_EXPECT_FALSE(test, delayed_work_pending(&work->callback_dwork));
KUNIT_EXPECT_FALSE(test, delayed_work_pending(&work->watchdog_timer_dwork));
cancel_delayed_work_sync(&work->callback_dwork);
cancel_delayed_work_sync(&work->watchdog_timer_dwork);
cancel_delayed_work_sync(&work->property_validate_dwork);
}
static void dm_test_hdcp_handle_cpirq_schedules_work(struct kunit *test)
{
struct hdcp_workqueue *work;
work = kunit_kzalloc(test, sizeof(*work), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, work);
INIT_WORK(&work->cpirq_work, dummy_work_fn);
hdcp_handle_cpirq(work, 0);
KUNIT_EXPECT_TRUE(test, work_pending(&work->cpirq_work));
cancel_work_sync(&work->cpirq_work);
}
static void dm_test_hdcp_handle_cpirq_selects_link_index(struct kunit *test)
{
struct hdcp_workqueue *work;
work = kunit_kcalloc(test, 2, sizeof(*work), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, work);
INIT_WORK(&work[0].cpirq_work, dummy_work_fn);
INIT_WORK(&work[1].cpirq_work, dummy_work_fn);
hdcp_handle_cpirq(work, 1);
KUNIT_EXPECT_FALSE(test, work_pending(&work[0].cpirq_work));
KUNIT_EXPECT_TRUE(test, work_pending(&work[1].cpirq_work));
cancel_work_sync(&work[1].cpirq_work);
}
static void dm_test_hdcp_update_display_enable_schedules_property_validate(struct kunit *test)
{
struct hdcp_workqueue *work;
work = kunit_kzalloc(test, sizeof(*work), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, work);
INIT_DELAYED_WORK(&work->property_validate_dwork, dummy_work_fn);
work->srm_size = 0;
hdcp_update_display_encryption_control(work, work, 0, true);
KUNIT_EXPECT_TRUE(test, delayed_work_pending(&work->property_validate_dwork));
cancel_delayed_work_sync(&work->property_validate_dwork);
}
static void dm_test_hdcp_update_display_disable_resets_status_and_cancels_validate(struct kunit *test)
{
struct hdcp_workqueue *work;
work = kunit_kzalloc(test, sizeof(*work), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, work);
INIT_DELAYED_WORK(&work->property_validate_dwork, dummy_work_fn);
schedule_delayed_work(&work->property_validate_dwork, msecs_to_jiffies(10000));
KUNIT_ASSERT_TRUE(test, delayed_work_pending(&work->property_validate_dwork));
work->encryption_status[3] = MOD_HDCP_ENCRYPTION_STATUS_HDCP2_TYPE1_ON;
hdcp_update_display_encryption_control(work, work, 3, false);
KUNIT_EXPECT_EQ(test, work->encryption_status[3],
MOD_HDCP_ENCRYPTION_STATUS_HDCP_OFF);
KUNIT_EXPECT_FALSE(test, delayed_work_pending(&work->property_validate_dwork));
}
static void dm_test_hdcp_create_workqueue_zero_max_links_returns_null(struct kunit *test)
{
struct cp_psp cp_psp = {0};
struct dc *dc;
struct hdcp_workqueue *work;
dc = kunit_kzalloc(test, sizeof(*dc), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, dc);
dc->caps.max_links = 0;
work = hdcp_create_workqueue(NULL, &cp_psp, dc);
KUNIT_EXPECT_PTR_EQ(test, work, NULL);
}
static void dm_test_hdcp_create_workqueue_initializes_work(struct kunit *test)
{
struct amdgpu_device *adev = dm_kunit_alloc_adev(test);
struct cp_psp cp_psp = {0};
struct dc *dc = dm_kunit_alloc_dc_with_ctx(test);
struct hdcp_workqueue *work;
adev->dev = adev->ddev.dev;
dc->caps.max_links = 1;
dc->ctx->dce_version = DCE_VERSION_UNKNOWN;
work = hdcp_create_workqueue(adev, &cp_psp, dc);
KUNIT_ASSERT_NOT_NULL(test, work);
KUNIT_EXPECT_EQ(test, work->max_link, 1);
KUNIT_EXPECT_NOT_NULL(test, work->srm);
KUNIT_EXPECT_NOT_NULL(test, work->srm_temp);
KUNIT_EXPECT_PTR_EQ(test, (void *)cp_psp.funcs.update_stream_config,
(void *)update_config);
KUNIT_EXPECT_PTR_EQ(test, (void *)cp_psp.funcs.enable_assr,
(void *)enable_assr);
KUNIT_EXPECT_PTR_EQ(test, cp_psp.handle, work);
KUNIT_EXPECT_PTR_EQ(test, work[0].hdcp.config.psp.handle, &adev->psp);
KUNIT_EXPECT_EQ(test, work[0].hdcp.config.psp.caps.dtm_v3_supported, 0);
hdcp_destroy(&adev->dev->kobj, work);
}
static void dm_test_hdcp_create_workqueue_sets_dtm_v3_for_dcn31(struct kunit *test)
{
struct amdgpu_device *adev = dm_kunit_alloc_adev(test);
struct cp_psp cp_psp = {0};
struct dc *dc = dm_kunit_alloc_dc_with_ctx(test);
struct hdcp_workqueue *work;
adev->dev = adev->ddev.dev;
dc->caps.max_links = 1;
dc->ctx->dce_version = DCN_VERSION_3_1;
work = hdcp_create_workqueue(adev, &cp_psp, dc);
KUNIT_ASSERT_NOT_NULL(test, work);
KUNIT_EXPECT_EQ(test, work[0].hdcp.config.psp.caps.dtm_v3_supported, 1);
hdcp_destroy(&adev->dev->kobj, work);
}
static void dm_test_hdcp_create_workqueue_initializes_all_links(struct kunit *test)
{
struct amdgpu_device *adev = dm_kunit_alloc_adev(test);
struct cp_psp cp_psp = {0};
struct dc *dc = dm_kunit_alloc_dc_with_ctx(test);
struct hdcp_workqueue *work;
int i;
adev->dev = adev->ddev.dev;
dc->caps.max_links = 3;
dc->ctx->dce_version = DCN_VERSION_3_1;
work = hdcp_create_workqueue(adev, &cp_psp, dc);
KUNIT_ASSERT_NOT_NULL(test, work);
KUNIT_EXPECT_EQ(test, work->max_link, 3);
for (i = 0; i < 3; i++) {
KUNIT_EXPECT_PTR_EQ(test, work[i].hdcp.config.psp.handle,
&adev->psp);
KUNIT_EXPECT_EQ(test, work[i].hdcp.config.psp.caps.dtm_v3_supported, 1);
}
hdcp_destroy(&adev->dev->kobj, work);
}
static ssize_t test_srm_bin_read(struct file *filp, struct kobject *kobj,
const struct bin_attribute *bin_attr, char *buffer,
loff_t pos, size_t count)
{
return 0;
}
static ssize_t test_srm_bin_write(struct file *filp, struct kobject *kobj,
const struct bin_attribute *bin_attr, char *buffer,
loff_t pos, size_t count)
{
return count;
}
static struct kobject *setup_destroy_sysfs(struct kunit *test,
struct hdcp_workqueue *work)
{
struct kobject *kobj;
int ret;
kobj = kobject_create_and_add("amdgpu_dm_hdcp_test", NULL);
KUNIT_ASSERT_NOT_NULL(test, kobj);
sysfs_bin_attr_init(&work->attr);
work->attr.attr.name = "hdcp_srm";
work->attr.attr.mode = 0664;
work->attr.size = 16;
work->attr.read = test_srm_bin_read;
work->attr.write = test_srm_bin_write;
ret = sysfs_create_bin_file(kobj, &work->attr);
KUNIT_ASSERT_EQ(test, ret, 0);
return kobj;
}
static void dm_test_hdcp_destroy_frees_and_removes_sysfs(struct kunit *test)
{
struct hdcp_workqueue *work;
struct kobject *kobj;
work = kzalloc_obj(*work);
KUNIT_ASSERT_NOT_NULL(test, work);
work->max_link = 1;
INIT_DELAYED_WORK(&work->callback_dwork, dummy_work_fn);
INIT_DELAYED_WORK(&work->watchdog_timer_dwork, dummy_work_fn);
INIT_DELAYED_WORK(&work->property_validate_dwork, dummy_work_fn);
work->srm = kzalloc(16, GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, work->srm);
work->srm_temp = kzalloc(16, GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, work->srm_temp);
kobj = setup_destroy_sysfs(test, work);
schedule_delayed_work(&work->callback_dwork, msecs_to_jiffies(10000));
KUNIT_ASSERT_TRUE(test, delayed_work_pending(&work->callback_dwork));
hdcp_destroy(kobj, work);
kobject_put(kobj);
}
static void dm_test_hdcp_destroy_zero_links_null_srm(struct kunit *test)
{
struct hdcp_workqueue *work;
struct kobject *kobj;
work = kzalloc_obj(*work);
KUNIT_ASSERT_NOT_NULL(test, work);
work->max_link = 0;
work->srm = NULL;
work->srm_temp = NULL;
kobj = setup_destroy_sysfs(test, work);
hdcp_destroy(kobj, work);
kobject_put(kobj);
}
static void dm_test_link_lock_locks_and_unlocks_all_links(struct kunit *test)
{
const int num_links = 3;
struct hdcp_workqueue *work;
int i;
work = kunit_kcalloc(test, num_links, sizeof(*work), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, work);
work[0].max_link = num_links;
for (i = 0; i < num_links; i++)
mutex_init(&work[i].mutex);
link_lock(work, true);
for (i = 0; i < num_links; i++)
KUNIT_EXPECT_TRUE(test, mutex_is_locked(&work[i].mutex));
link_lock(work, false);
for (i = 0; i < num_links; i++)
KUNIT_EXPECT_FALSE(test, mutex_is_locked(&work[i].mutex));
link_lock(work, true);
for (i = 0; i < num_links; i++)
KUNIT_EXPECT_TRUE(test, mutex_is_locked(&work[i].mutex));
link_lock(work, false);
}
static void dm_test_link_lock_zero_links_is_noop(struct kunit *test)
{
struct hdcp_workqueue *work;
work = kunit_kzalloc(test, sizeof(*work), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, work);
mutex_init(&work->mutex);
work->max_link = 0;
link_lock(work, true);
KUNIT_EXPECT_FALSE(test, mutex_is_locked(&work->mutex));
}
static void dm_test_psp_get_srm_uninitialized_returns_null(struct kunit *test)
{
struct psp_context *psp;
uint32_t srm_version = 0xdead;
uint32_t srm_size = 0xbeef;
uint8_t *srm;
psp = kunit_kzalloc(test, sizeof(*psp), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, psp);
srm = psp_get_srm(psp, &srm_version, &srm_size);
KUNIT_EXPECT_PTR_EQ(test, srm, NULL);
KUNIT_EXPECT_EQ(test, srm_version, 0xdead);
KUNIT_EXPECT_EQ(test, srm_size, 0xbeef);
}
static void dm_test_psp_set_srm_uninitialized_returns_einval(struct kunit *test)
{
struct psp_context *psp;
uint32_t srm_version = 0xdead;
u8 srm_buf[4] = {0};
int ret;
psp = kunit_kzalloc(test, sizeof(*psp), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, psp);
ret = psp_set_srm(psp, srm_buf, sizeof(srm_buf), &srm_version);
KUNIT_EXPECT_EQ(test, ret, -EINVAL);
KUNIT_EXPECT_EQ(test, srm_version, 0xdead);
}
static void dm_test_psp_set_srm_initialized_stages_command(struct kunit *test)
{
struct amdgpu_device *adev = dm_kunit_alloc_adev(test);
struct ta_hdcp_shared_memory *hdcp_cmd;
struct psp_context *psp;
uint32_t srm_version = 0xdead;
u8 srm_buf[4] = {0x1, 0x2, 0x3, 0x4};
int ret;
KUNIT_ASSERT_NOT_NULL(test, adev);
psp = kunit_kzalloc(test, sizeof(*psp), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, psp);
hdcp_cmd = kunit_kzalloc(test, sizeof(*hdcp_cmd), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, hdcp_cmd);
psp->adev = adev;
psp->hdcp_context.context.initialized = true;
psp->hdcp_context.context.mem_context.shared_buf = (uint8_t *)hdcp_cmd;
adev->virt.caps |= AMDGPU_SRIOV_CAPS_IS_VF;
ret = psp_set_srm(psp, srm_buf, sizeof(srm_buf), &srm_version);
KUNIT_EXPECT_EQ(test, ret, -EINVAL);
KUNIT_EXPECT_EQ(test, srm_version, 0xdead);
KUNIT_EXPECT_EQ(test, hdcp_cmd->cmd_id, TA_HDCP_COMMAND__HDCP_SET_SRM);
KUNIT_EXPECT_EQ(test, hdcp_cmd->in_msg.hdcp_set_srm.srm_buf_size,
(uint32_t)sizeof(srm_buf));
KUNIT_EXPECT_MEMEQ(test, hdcp_cmd->in_msg.hdcp_set_srm.srm_buf, srm_buf,
sizeof(srm_buf));
}
static void dm_test_srm_data_write_uninitialized_ta_keeps_srm(struct kunit *test)
{
struct hdcp_workqueue *work;
struct psp_context *psp;
u8 buf[4] = {0xAA, 0xBB, 0xCC, 0xDD};
ssize_t ret;
work = kunit_kzalloc(test, sizeof(*work), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, work);
psp = kunit_kzalloc(test, sizeof(*psp), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, psp);
work->max_link = 1;
mutex_init(&work->mutex);
work->hdcp.config.psp.handle = psp;
work->srm_temp = kunit_kzalloc(test, PSP_HDCP_SRM_FIRST_GEN_MAX_SIZE, GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, work->srm_temp);
work->srm = kunit_kzalloc(test, PSP_HDCP_SRM_FIRST_GEN_MAX_SIZE, GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, work->srm);
ret = srm_data_write(NULL, NULL, &work->attr, buf, 0, sizeof(buf));
KUNIT_EXPECT_EQ(test, ret, (ssize_t)sizeof(buf));
KUNIT_EXPECT_MEMEQ(test, work->srm_temp, buf, sizeof(buf));
KUNIT_EXPECT_EQ(test, work->srm_size, 0u);
}
static void dm_test_srm_data_read_uninitialized_ta_returns_einval(struct kunit *test)
{
struct hdcp_workqueue *work;
struct psp_context *psp;
u8 buf[4];
ssize_t ret;
work = kunit_kzalloc(test, sizeof(*work), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, work);
psp = kunit_kzalloc(test, sizeof(*psp), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, psp);
work->max_link = 1;
mutex_init(&work->mutex);
work->hdcp.config.psp.handle = psp;
ret = srm_data_read(NULL, NULL, &work->attr, buf, 0, sizeof(buf));
KUNIT_EXPECT_EQ(test, ret, (ssize_t)-EINVAL);
}
static void dm_test_srm_data_read_empty_srm_returns_zero(struct kunit *test)
{
struct amdgpu_device *adev = dm_kunit_alloc_adev(test);
struct ta_hdcp_shared_memory *hdcp_cmd;
struct hdcp_workqueue *work;
struct psp_context *psp;
u8 buf[4];
ssize_t ret;
KUNIT_ASSERT_NOT_NULL(test, adev);
work = kunit_kzalloc(test, sizeof(*work), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, work);
psp = kunit_kzalloc(test, sizeof(*psp), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, psp);
hdcp_cmd = kunit_kzalloc(test, sizeof(*hdcp_cmd), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, hdcp_cmd);
work->max_link = 1;
mutex_init(&work->mutex);
psp->adev = adev;
psp->hdcp_context.context.initialized = true;
psp->hdcp_context.context.mem_context.shared_buf = (uint8_t *)hdcp_cmd;
work->hdcp.config.psp.handle = psp;
adev->virt.caps |= AMDGPU_SRIOV_CAPS_IS_VF;
ret = srm_data_read(NULL, NULL, &work->attr, buf, 0, sizeof(buf));
KUNIT_EXPECT_EQ(test, ret, 0);
}
static struct amdgpu_dm_connector *alloc_test_connector(struct kunit *test,
unsigned int index);
#define FAKE_DDC_MAX_MSGS 4
static struct fake_i2c_capture {
int num;
struct i2c_msg msgs[FAKE_DDC_MAX_MSGS];
} fake_i2c_cap;
static int fake_i2c_master_xfer(struct i2c_adapter *adap, struct i2c_msg *msgs,
int num)
{
int i;
fake_i2c_cap.num = num;
for (i = 0; i < num && i < FAKE_DDC_MAX_MSGS; i++)
fake_i2c_cap.msgs[i] = msgs[i];
return num;
}
static u32 fake_i2c_functionality(struct i2c_adapter *adap)
{
return I2C_FUNC_I2C;
}
static const struct i2c_algorithm fake_i2c_algo = {
.master_xfer = fake_i2c_master_xfer,
.functionality = fake_i2c_functionality,
};
static void fake_i2c_lock_bus(struct i2c_adapter *adap, unsigned int flags) {}
static int fake_i2c_trylock_bus(struct i2c_adapter *adap, unsigned int flags)
{
return 1;
}
static void fake_i2c_unlock_bus(struct i2c_adapter *adap, unsigned int flags) {}
static const struct i2c_lock_operations fake_i2c_lock_ops = {
.lock_bus = fake_i2c_lock_bus,
.trylock_bus = fake_i2c_trylock_bus,
.unlock_bus = fake_i2c_unlock_bus,
};
static struct fake_aux_capture {
int calls;
u8 request;
unsigned int address;
size_t size;
} fake_aux_cap;
static ssize_t fake_aux_transfer(struct drm_dp_aux *aux,
struct drm_dp_aux_msg *msg)
{
fake_aux_cap.calls++;
fake_aux_cap.request = msg->request;
fake_aux_cap.address = msg->address;
fake_aux_cap.size = msg->size;
msg->reply = DP_AUX_NATIVE_REPLY_ACK;
return msg->size;
}
static struct dc_link *alloc_test_ddc_link(struct kunit *test)
{
struct amdgpu_dm_connector *aconnector = alloc_test_connector(test, 0);
struct amdgpu_i2c_adapter *i2c;
struct dc_link *link;
KUNIT_ASSERT_NOT_NULL(test, aconnector);
i2c = kunit_kzalloc(test, sizeof(*i2c), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, i2c);
i2c->base.algo = &fake_i2c_algo;
i2c->base.lock_ops = &fake_i2c_lock_ops;
aconnector->i2c = i2c;
mutex_init(&aconnector->dm_dp_aux.aux.hw_mutex);
aconnector->dm_dp_aux.aux.transfer = fake_aux_transfer;
aconnector->dm_dp_aux.aux.dpcd_probe_disabled = true;
link = aconnector->dc_link;
link->priv = aconnector;
return link;
}
static void dm_test_lp_write_i2c_builds_single_write_payload(struct kunit *test)
{
struct dc_link *link = alloc_test_ddc_link(test);
u8 data[3] = {0x11, 0x22, 0x33};
bool ok;
memset(&fake_i2c_cap, 0, sizeof(fake_i2c_cap));
ok = lp_write_i2c(link, 0x3a, data, sizeof(data));
KUNIT_EXPECT_TRUE(test, ok);
KUNIT_ASSERT_EQ(test, fake_i2c_cap.num, 1);
KUNIT_EXPECT_EQ(test, (int)fake_i2c_cap.msgs[0].flags, 0);
KUNIT_EXPECT_EQ(test, (int)fake_i2c_cap.msgs[0].addr, 0x3a);
KUNIT_EXPECT_EQ(test, (int)fake_i2c_cap.msgs[0].len, (int)sizeof(data));
KUNIT_EXPECT_PTR_EQ(test, fake_i2c_cap.msgs[0].buf, (void *)data);
}
static void dm_test_lp_read_i2c_builds_offset_then_read(struct kunit *test)
{
struct dc_link *link = alloc_test_ddc_link(test);
u8 data[4];
bool ok;
memset(&fake_i2c_cap, 0, sizeof(fake_i2c_cap));
ok = lp_read_i2c(link, 0x50, 0x07, data, sizeof(data));
KUNIT_EXPECT_TRUE(test, ok);
KUNIT_ASSERT_EQ(test, fake_i2c_cap.num, 2);
KUNIT_EXPECT_EQ(test, (int)fake_i2c_cap.msgs[0].flags, 0);
KUNIT_EXPECT_EQ(test, (int)fake_i2c_cap.msgs[0].addr, 0x50);
KUNIT_EXPECT_EQ(test, (int)fake_i2c_cap.msgs[0].len, 1);
KUNIT_EXPECT_EQ(test, (int)fake_i2c_cap.msgs[1].flags, I2C_M_RD);
KUNIT_EXPECT_EQ(test, (int)fake_i2c_cap.msgs[1].addr, 0x50);
KUNIT_EXPECT_EQ(test, (int)fake_i2c_cap.msgs[1].len, (int)sizeof(data));
KUNIT_EXPECT_PTR_EQ(test, fake_i2c_cap.msgs[1].buf, (void *)data);
}
static void dm_test_lp_write_dpcd_forwards_native_write(struct kunit *test)
{
struct dc_link *link = alloc_test_ddc_link(test);
u8 data[2] = {0xDE, 0xAD};
bool ok;
memset(&fake_aux_cap, 0, sizeof(fake_aux_cap));
ok = lp_write_dpcd(link, 0x68000, data, sizeof(data));
KUNIT_EXPECT_TRUE(test, ok);
KUNIT_EXPECT_EQ(test, fake_aux_cap.calls, 1);
KUNIT_EXPECT_EQ(test, (int)fake_aux_cap.request, DP_AUX_NATIVE_WRITE);
KUNIT_EXPECT_EQ(test, fake_aux_cap.address, 0x68000u);
KUNIT_EXPECT_EQ(test, (int)fake_aux_cap.size, (int)sizeof(data));
}
static void dm_test_lp_read_dpcd_forwards_native_read(struct kunit *test)
{
struct dc_link *link = alloc_test_ddc_link(test);
u8 data[4];
bool ok;
memset(&fake_aux_cap, 0, sizeof(fake_aux_cap));
ok = lp_read_dpcd(link, 0x00220, data, sizeof(data));
KUNIT_EXPECT_TRUE(test, ok);
KUNIT_EXPECT_EQ(test, fake_aux_cap.calls, 1);
KUNIT_EXPECT_EQ(test, (int)fake_aux_cap.request, DP_AUX_NATIVE_READ);
KUNIT_EXPECT_EQ(test, fake_aux_cap.address, 0x00220u);
KUNIT_EXPECT_EQ(test, (int)fake_aux_cap.size, (int)sizeof(data));
}
static void dm_test_lp_write_i2c_no_connector_returns_false(struct kunit *test)
{
struct dc_link *link = alloc_test_ddc_link(test);
u8 data[2] = {0x01, 0x02};
bool ok;
link->priv = NULL;
memset(&fake_i2c_cap, 0, sizeof(fake_i2c_cap));
ok = lp_write_i2c(link, 0x3a, data, sizeof(data));
KUNIT_EXPECT_FALSE(test, ok);
KUNIT_EXPECT_EQ(test, fake_i2c_cap.num, 0);
}
static void dm_test_lp_read_dpcd_no_connector_returns_false(struct kunit *test)
{
struct dc_link *link = alloc_test_ddc_link(test);
u8 data[4];
bool ok;
link->priv = NULL;
memset(&fake_aux_cap, 0, sizeof(fake_aux_cap));
ok = lp_read_dpcd(link, 0x00220, data, sizeof(data));
KUNIT_EXPECT_FALSE(test, ok);
KUNIT_EXPECT_EQ(test, fake_aux_cap.calls, 0);
}
static void dm_test_lp_atomic_i2c_null_handle_returns_false(struct kunit *test)
{
struct mod_hdcp_atomic_op_i2c op = { 0 };
KUNIT_EXPECT_FALSE(test,
lp_atomic_write_poll_read_i2c(NULL, &op, &op, &op, 0, 0));
}
static void dm_test_lp_atomic_i2c_oversized_op_returns_false(struct kunit *test)
{
struct amdgpu_dm_connector *aconnector = alloc_test_connector(test, 0);
struct mod_hdcp_atomic_op_i2c write = { .size = 0x100 };
struct mod_hdcp_atomic_op_i2c op = { 0 };
struct dc_link *link;
KUNIT_ASSERT_NOT_NULL(test, aconnector);
link = aconnector->dc_link;
link->no_ddc_pin = true;
KUNIT_EXPECT_FALSE(test,
lp_atomic_write_poll_read_i2c(link, &write, &op, &op, 0, 0));
}
static void dm_test_lp_atomic_aux_null_handle_returns_false(struct kunit *test)
{
struct mod_hdcp_atomic_op_aux op = { 0 };
KUNIT_EXPECT_FALSE(test,
lp_atomic_write_poll_read_aux(NULL, &op, &op, &op, 0, 0));
}
static void dm_test_lp_atomic_aux_oversized_op_returns_false(struct kunit *test)
{
struct amdgpu_dm_connector *aconnector = alloc_test_connector(test, 0);
struct mod_hdcp_atomic_op_aux write = { .size = 0x100 };
struct mod_hdcp_atomic_op_aux op = { 0 };
struct ddc_service *ddc;
struct ddc *ddc_pin;
struct dc_link *link;
void *pin_data;
KUNIT_ASSERT_NOT_NULL(test, aconnector);
ddc = kunit_kzalloc(test, sizeof(*ddc), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, ddc);
ddc_pin = kunit_kzalloc(test, sizeof(*ddc_pin), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, ddc_pin);
pin_data = kunit_kzalloc(test, 128, GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, pin_data);
ddc_pin->pin_data = pin_data;
ddc->ddc_pin = ddc_pin;
link = aconnector->dc_link;
link->ddc = ddc;
KUNIT_EXPECT_FALSE(test,
lp_atomic_write_poll_read_aux(link, &write, &op, &op, 0, 0));
}
static struct hdcp_workqueue *alloc_test_workqueue_locked(struct kunit *test)
{
struct hdcp_workqueue *work;
work = kunit_kzalloc(test, sizeof(*work), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, work);
mutex_init(&work->mutex);
INIT_DELAYED_WORK(&work->callback_dwork, dummy_work_fn);
INIT_DELAYED_WORK(&work->watchdog_timer_dwork, dummy_work_fn);
INIT_DELAYED_WORK(&work->property_validate_dwork, dummy_work_fn);
return work;
}
static struct amdgpu_dm_connector *alloc_test_connector(struct kunit *test,
unsigned int index)
{
struct amdgpu_dm_connector *aconnector;
struct dc_link *dc_link;
struct dc *dc;
aconnector = kunit_kzalloc(test, sizeof(*aconnector), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, aconnector);
dc_link = kunit_kzalloc(test, sizeof(*dc_link), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, dc_link);
dc = kunit_kzalloc(test, sizeof(*dc), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, dc);
kref_init(&aconnector->base.base.refcount);
aconnector->base.index = index;
dc_link->dc = dc;
aconnector->dc_link = dc_link;
return aconnector;
}
static void dm_test_hdcp_update_display_enable_registers_connector(struct kunit *test)
{
struct hdcp_workqueue *work = alloc_test_workqueue_locked(test);
struct amdgpu_dm_connector *aconnector = alloc_test_connector(test, 0);
work->srm_size = 0;
hdcp_update_display(work, 0, aconnector, DRM_MODE_HDCP_CONTENT_TYPE0, true);
KUNIT_EXPECT_PTR_EQ(test, work->aconnector[0], aconnector);
KUNIT_EXPECT_EQ(test, work->encryption_status[0],
MOD_HDCP_ENCRYPTION_STATUS_HDCP_OFF);
cancel_delayed_work_sync(&work->property_validate_dwork);
cancel_delayed_work_sync(&work->callback_dwork);
cancel_delayed_work_sync(&work->watchdog_timer_dwork);
}
static void dm_test_hdcp_update_display_disable_sets_status_off(struct kunit *test)
{
struct hdcp_workqueue *work = alloc_test_workqueue_locked(test);
struct amdgpu_dm_connector *aconnector = alloc_test_connector(test, 2);
work->encryption_status[2] = MOD_HDCP_ENCRYPTION_STATUS_HDCP2_TYPE1_ON;
hdcp_update_display(work, 0, aconnector, DRM_MODE_HDCP_CONTENT_TYPE0, false);
KUNIT_EXPECT_PTR_EQ(test, work->aconnector[2], aconnector);
KUNIT_EXPECT_EQ(test, work->encryption_status[2],
MOD_HDCP_ENCRYPTION_STATUS_HDCP_OFF);
cancel_delayed_work_sync(&work->property_validate_dwork);
cancel_delayed_work_sync(&work->callback_dwork);
cancel_delayed_work_sync(&work->watchdog_timer_dwork);
}
static void dm_test_hdcp_remove_display_enabled_resets_cp(struct kunit *test)
{
struct hdcp_workqueue *work = alloc_test_workqueue_locked(test);
struct amdgpu_dm_connector *aconnector = alloc_test_connector(test, 1);
struct drm_connector_state *conn_state;
conn_state = kunit_kzalloc(test, sizeof(*conn_state), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, conn_state);
conn_state->content_protection = DRM_MODE_CONTENT_PROTECTION_ENABLED;
aconnector->base.state = conn_state;
work->aconnector[1] = aconnector;
hdcp_remove_display(work, 0, aconnector);
KUNIT_EXPECT_EQ(test, conn_state->content_protection,
DRM_MODE_CONTENT_PROTECTION_DESIRED);
KUNIT_EXPECT_PTR_EQ(test, work->aconnector[1], NULL);
cancel_delayed_work_sync(&work->property_validate_dwork);
cancel_delayed_work_sync(&work->callback_dwork);
cancel_delayed_work_sync(&work->watchdog_timer_dwork);
}
static void dm_test_hdcp_remove_display_null_state_clears_connector(struct kunit *test)
{
struct hdcp_workqueue *work = alloc_test_workqueue_locked(test);
struct amdgpu_dm_connector *aconnector = alloc_test_connector(test, 0);
aconnector->base.state = NULL;
work->aconnector[0] = aconnector;
hdcp_remove_display(work, 0, aconnector);
KUNIT_EXPECT_PTR_EQ(test, work->aconnector[0], NULL);
cancel_delayed_work_sync(&work->property_validate_dwork);
cancel_delayed_work_sync(&work->callback_dwork);
cancel_delayed_work_sync(&work->watchdog_timer_dwork);
}
static void dm_test_hdcp_reset_display_clears_all_state(struct kunit *test)
{
struct hdcp_workqueue *work = alloc_test_workqueue_locked(test);
struct amdgpu_dm_connector *aconnector = alloc_test_connector(test, 4);
work->encryption_status[4] = MOD_HDCP_ENCRYPTION_STATUS_HDCP2_TYPE1_ON;
work->aconnector[4] = aconnector;
hdcp_reset_display(work, 0);
KUNIT_EXPECT_EQ(test, work->encryption_status[4],
MOD_HDCP_ENCRYPTION_STATUS_HDCP_OFF);
KUNIT_EXPECT_PTR_EQ(test, work->aconnector[4], NULL);
cancel_delayed_work_sync(&work->property_validate_dwork);
cancel_delayed_work_sync(&work->callback_dwork);
cancel_delayed_work_sync(&work->watchdog_timer_dwork);
}
static struct hdcp_workqueue *alloc_test_workqueue_for_assr(struct kunit *test,
struct amdgpu_device *adev)
{
struct hdcp_workqueue *work;
struct psp_context *psp;
work = kunit_kzalloc(test, sizeof(*work), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, work);
psp = kunit_kzalloc(test, sizeof(*psp), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, psp);
psp->adev = adev;
work->hdcp.config.psp.handle = psp;
return work;
}
static void dm_test_enable_assr_uninitialized_dtm_returns_false(struct kunit *test)
{
struct amdgpu_device *adev = dm_kunit_alloc_adev(test);
struct hdcp_workqueue *work = alloc_test_workqueue_for_assr(test, adev);
struct dc_link *link;
bool ret;
link = kunit_kzalloc(test, sizeof(*link), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, link);
ret = enable_assr(work, link);
KUNIT_EXPECT_FALSE(test, ret);
}
static void dm_test_enable_assr_uninitialized_dtm_ignores_link(struct kunit *test)
{
struct amdgpu_device *adev = dm_kunit_alloc_adev(test);
struct hdcp_workqueue *work = alloc_test_workqueue_for_assr(test, adev);
bool ret;
ret = enable_assr(work, NULL);
KUNIT_EXPECT_FALSE(test, ret);
}
static void dm_test_enable_assr_initialized_builds_command_and_fails(struct kunit *test)
{
struct amdgpu_device *adev = dm_kunit_alloc_adev(test);
struct hdcp_workqueue *work = alloc_test_workqueue_for_assr(test, adev);
struct psp_context *psp = work->hdcp.config.psp.handle;
struct ta_dtm_shared_memory *dtm_cmd;
struct dc_link *link;
bool ret;
dtm_cmd = kunit_kzalloc(test, sizeof(*dtm_cmd), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, dtm_cmd);
link = kunit_kzalloc(test, sizeof(*link), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, link);
link->link_enc_hw_inst = 3;
psp->dtm_context.context.initialized = true;
psp->dtm_context.context.mem_context.shared_buf = (uint8_t *)dtm_cmd;
mutex_init(&psp->dtm_context.mutex);
adev->virt.caps |= AMDGPU_SRIOV_CAPS_IS_VF;
ret = enable_assr(work, link);
KUNIT_EXPECT_FALSE(test, ret);
KUNIT_EXPECT_EQ(test, dtm_cmd->cmd_id, TA_DTM_COMMAND__TOPOLOGY_ASSR_ENABLE);
KUNIT_EXPECT_EQ(test,
dtm_cmd->dtm_in_message.topology_assr_enable.display_topology_dig_be_index,
link->link_enc_hw_inst);
KUNIT_EXPECT_EQ(test, dtm_cmd->dtm_status, TA_DTM_STATUS__GENERIC_FAILURE);
KUNIT_EXPECT_FALSE(test, mutex_is_locked(&psp->dtm_context.mutex));
}
static void dm_test_update_config_null_connector_is_noop(struct kunit *test)
{
struct hdcp_workqueue *work = alloc_test_workqueue_locked(test);
struct cp_psp_stream_config config = {0};
config.dm_stream_ctx = NULL;
update_config(work, &config);
KUNIT_EXPECT_PTR_EQ(test, work->aconnector[0], NULL);
}
static void dm_test_update_config_null_dc_link_is_noop(struct kunit *test)
{
struct hdcp_workqueue *work = alloc_test_workqueue_locked(test);
struct amdgpu_dm_connector *aconnector;
struct cp_psp_stream_config config = {0};
aconnector = kunit_kzalloc(test, sizeof(*aconnector), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, aconnector);
aconnector->dc_link = NULL;
config.dm_stream_ctx = aconnector;
update_config(work, &config);
KUNIT_EXPECT_PTR_EQ(test, work->aconnector[0], NULL);
}
static void dm_test_update_config_dpms_off_removes_display(struct kunit *test)
{
struct hdcp_workqueue *work = alloc_test_workqueue_locked(test);
struct amdgpu_dm_connector *aconnector = alloc_test_connector(test, 0);
struct drm_connector_state *conn_state;
struct cp_psp_stream_config config = {0};
conn_state = kunit_kzalloc(test, sizeof(*conn_state), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, conn_state);
conn_state->content_protection = DRM_MODE_CONTENT_PROTECTION_ENABLED;
aconnector->base.state = conn_state;
work->aconnector[0] = aconnector;
config.dm_stream_ctx = aconnector;
config.dpms_off = true;
update_config(work, &config);
KUNIT_EXPECT_EQ(test, conn_state->content_protection,
DRM_MODE_CONTENT_PROTECTION_DESIRED);
KUNIT_EXPECT_PTR_EQ(test, work->aconnector[0], NULL);
cancel_delayed_work_sync(&work->property_validate_dwork);
cancel_delayed_work_sync(&work->callback_dwork);
cancel_delayed_work_sync(&work->watchdog_timer_dwork);
}
static void dm_test_update_config_populates_display_and_link(struct kunit *test)
{
struct hdcp_workqueue *work = alloc_test_workqueue_locked(test);
struct amdgpu_dm_connector *aconnector = alloc_test_connector(test, 0);
struct psp_context *psp;
struct cp_psp_stream_config config = {0};
psp = kunit_kzalloc(test, sizeof(*psp), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, psp);
work->hdcp.config.psp.handle = psp;
config.dm_stream_ctx = aconnector;
config.dpms_off = false;
config.otg_inst = 1;
config.dig_fe = 4;
config.dig_be = 5;
config.stream_enc_idx = 6;
config.link_enc_idx = 7;
config.dio_output_idx = 8;
config.phy_idx = 2;
update_config(work, &config);
KUNIT_EXPECT_EQ(test, work->encryption_status[0],
MOD_HDCP_ENCRYPTION_STATUS_HDCP_OFF);
KUNIT_EXPECT_PTR_EQ(test, work->aconnector[0], aconnector);
KUNIT_EXPECT_EQ(test, work->display.state, MOD_HDCP_DISPLAY_ACTIVE);
KUNIT_EXPECT_EQ(test, work->display.controller,
CONTROLLER_ID_D0 + config.otg_inst);
KUNIT_EXPECT_EQ(test, work->display.dig_fe, config.dig_fe);
KUNIT_EXPECT_EQ(test, work->display.stream_enc_idx, config.stream_enc_idx);
KUNIT_EXPECT_EQ(test, work->link.dig_be, config.dig_be);
KUNIT_EXPECT_EQ(test, work->link.link_enc_idx, config.link_enc_idx);
KUNIT_EXPECT_EQ(test, work->link.dio_output_id, config.dio_output_idx);
KUNIT_EXPECT_EQ(test, work->link.phy_idx, config.phy_idx);
KUNIT_EXPECT_TRUE(test, work_pending(&work->property_validate_dwork.work));
cancel_delayed_work_sync(&work->property_validate_dwork);
cancel_delayed_work_sync(&work->callback_dwork);
cancel_delayed_work_sync(&work->watchdog_timer_dwork);
}
static struct kunit_case dm_hdcp_test_cases[] = {
KUNIT_CASE(dm_test_hdcp_get_cp_disabled_returns_desired),
KUNIT_CASE(dm_test_hdcp_get_cp_type0_returns_enabled),
KUNIT_CASE(dm_test_hdcp_get_cp_type1_returns_enabled),
KUNIT_CASE(dm_test_hdcp_get_cp_type1_rejects_type0_status),
KUNIT_CASE(dm_test_hdcp_get_cp_type0_rejects_type1_status),
KUNIT_CASE(dm_test_hdcp_get_adjustments_disable_authentication),
KUNIT_CASE(dm_test_hdcp_get_adjustments_type0_policy),
KUNIT_CASE(dm_test_hdcp_get_adjustments_type1_policy),
KUNIT_CASE(dm_test_hdcp_get_adjustments_fused_io_enables_fw_check),
KUNIT_CASE(dm_test_process_output_property_validate_always_scheduled),
KUNIT_CASE(dm_test_process_output_callback_needed),
KUNIT_CASE(dm_test_process_output_callback_stop),
KUNIT_CASE(dm_test_process_output_watchdog_needed),
KUNIT_CASE(dm_test_process_output_watchdog_stop),
KUNIT_CASE(dm_test_process_output_callback_and_watchdog_needed),
KUNIT_CASE(dm_test_process_output_callback_stop_and_needed_requeues),
KUNIT_CASE(dm_test_process_output_watchdog_stop_and_needed_requeues),
KUNIT_CASE(dm_test_event_property_update_skips_null_connector),
KUNIT_CASE(dm_test_event_property_update_skips_disconnected),
KUNIT_CASE(dm_test_event_property_update_skips_null_state),
KUNIT_CASE(dm_test_event_property_update_skips_null_dev),
KUNIT_CASE(dm_test_event_property_update_desired_when_off),
KUNIT_CASE(dm_test_event_property_update_enabled_when_encrypted),
KUNIT_CASE(dm_test_event_callback_cancels_callback_dwork),
KUNIT_CASE(dm_test_event_callback_schedules_property_validate),
KUNIT_CASE(dm_test_event_property_validate_skips_null_connector),
KUNIT_CASE(dm_test_event_property_validate_skips_disconnected),
KUNIT_CASE(dm_test_event_property_validate_skips_null_state),
KUNIT_CASE(dm_test_event_property_validate_updates_on_status_change),
KUNIT_CASE(dm_test_event_property_validate_no_update_when_unchanged),
KUNIT_CASE(dm_test_event_watchdog_timer_cancels_watchdog_dwork),
KUNIT_CASE(dm_test_event_watchdog_timer_schedules_property_validate),
KUNIT_CASE(dm_test_event_cpirq_schedules_property_validate),
KUNIT_CASE(dm_test_event_cpirq_leaves_callback_and_watchdog_idle),
KUNIT_CASE(dm_test_hdcp_handle_cpirq_schedules_work),
KUNIT_CASE(dm_test_hdcp_handle_cpirq_selects_link_index),
KUNIT_CASE(dm_test_hdcp_update_display_enable_schedules_property_validate),
KUNIT_CASE(dm_test_hdcp_update_display_disable_resets_status_and_cancels_validate),
KUNIT_CASE(dm_test_hdcp_create_workqueue_zero_max_links_returns_null),
KUNIT_CASE(dm_test_hdcp_create_workqueue_initializes_work),
KUNIT_CASE(dm_test_hdcp_create_workqueue_sets_dtm_v3_for_dcn31),
KUNIT_CASE(dm_test_hdcp_create_workqueue_initializes_all_links),
KUNIT_CASE(dm_test_hdcp_destroy_frees_and_removes_sysfs),
KUNIT_CASE(dm_test_hdcp_destroy_zero_links_null_srm),
KUNIT_CASE(dm_test_link_lock_locks_and_unlocks_all_links),
KUNIT_CASE(dm_test_link_lock_zero_links_is_noop),
KUNIT_CASE(dm_test_psp_get_srm_uninitialized_returns_null),
KUNIT_CASE(dm_test_psp_set_srm_uninitialized_returns_einval),
KUNIT_CASE(dm_test_psp_set_srm_initialized_stages_command),
KUNIT_CASE(dm_test_srm_data_write_uninitialized_ta_keeps_srm),
KUNIT_CASE(dm_test_srm_data_read_uninitialized_ta_returns_einval),
KUNIT_CASE(dm_test_srm_data_read_empty_srm_returns_zero),
KUNIT_CASE(dm_test_lp_write_i2c_builds_single_write_payload),
KUNIT_CASE(dm_test_lp_read_i2c_builds_offset_then_read),
KUNIT_CASE(dm_test_lp_write_dpcd_forwards_native_write),
KUNIT_CASE(dm_test_lp_read_dpcd_forwards_native_read),
KUNIT_CASE(dm_test_lp_write_i2c_no_connector_returns_false),
KUNIT_CASE(dm_test_lp_read_dpcd_no_connector_returns_false),
KUNIT_CASE(dm_test_lp_atomic_i2c_null_handle_returns_false),
KUNIT_CASE(dm_test_lp_atomic_i2c_oversized_op_returns_false),
KUNIT_CASE(dm_test_lp_atomic_aux_null_handle_returns_false),
KUNIT_CASE(dm_test_lp_atomic_aux_oversized_op_returns_false),
KUNIT_CASE(dm_test_hdcp_update_display_enable_registers_connector),
KUNIT_CASE(dm_test_hdcp_update_display_disable_sets_status_off),
KUNIT_CASE(dm_test_hdcp_remove_display_enabled_resets_cp),
KUNIT_CASE(dm_test_hdcp_remove_display_null_state_clears_connector),
KUNIT_CASE(dm_test_hdcp_reset_display_clears_all_state),
KUNIT_CASE(dm_test_enable_assr_uninitialized_dtm_returns_false),
KUNIT_CASE(dm_test_enable_assr_uninitialized_dtm_ignores_link),
KUNIT_CASE(dm_test_enable_assr_initialized_builds_command_and_fails),
KUNIT_CASE(dm_test_update_config_null_connector_is_noop),
KUNIT_CASE(dm_test_update_config_null_dc_link_is_noop),
KUNIT_CASE(dm_test_update_config_dpms_off_removes_display),
KUNIT_CASE(dm_test_update_config_populates_display_and_link),
{}
};
static struct kunit_suite dm_hdcp_test_suite = {
.name = "amdgpu_dm_hdcp",
.test_cases = dm_hdcp_test_cases,
};
kunit_test_suite(dm_hdcp_test_suite);
MODULE_LICENSE("Dual MIT/GPL");
MODULE_DESCRIPTION("KUnit tests for amdgpu_dm_hdcp");
MODULE_AUTHOR("AMD"