#include <kunit/test.h>
#include <drm/drm_drv.h>
#include <drm/drm_atomic_uapi.h>
#include <drm/drm_edid.h>
#include <drm/drm_fixed.h>
#include <drm/drm_kunit_helpers.h>
#include <drm/drm_managed.h>
#include <drm/drm_atomic_helper.h>
#include <drm/drm_connector.h>
#include <drm/drm_mode_config.h>
#include <drm/drm_modeset_lock.h>
#include <drm/drm_property.h>
#include <drm/display/drm_dp.h>
#include <drm/display/drm_dp_helper.h>
#include <drm/display/drm_dp_mst_helper.h>
#include "dc.h"
#include "dpcd_defs.h"
#include "dmub_cmd.h"
#include "amdgpu.h"
#include "amdgpu_mode.h"
#include "amdgpu_dm.h"
#include "amdgpu_dm_hdcp.h"
#include "amdgpu_dm_mst_types.h"
#include "amdgpu_dm_kunit_test_helpers.h"
#include "dsc/dsc.h"
#include "inc/core_types.h"
#include "inc/link_service.h"
static u8 dm_mst_test_dpcd[0x10];
static u8 dm_mst_test_desc_dpcd[0x10];
static struct aux_payload dm_mst_test_last_payload;
static int dm_mst_test_aux_transfer_raw_result;
static u8 dm_mst_test_aux_transfer_raw_reply;
static enum aux_return_code_type dm_mst_test_aux_transfer_raw_operation_result;
static ssize_t dm_mst_test_aux_transfer_override;
static ssize_t dm_mst_test_aux_write_override;
static int dm_mst_test_aux_transfer_raw(struct ddc_service *ddc,
struct aux_payload *payload,
enum aux_return_code_type *operation_result)
{
size_t i;
dm_mst_test_last_payload = *payload;
*operation_result = dm_mst_test_aux_transfer_raw_operation_result;
payload->reply[0] = dm_mst_test_aux_transfer_raw_reply;
if (dm_mst_test_aux_transfer_raw_result)
return dm_mst_test_aux_transfer_raw_result;
if (payload->write)
return 0;
for (i = 0; i < payload->length; i++)
payload->data[i] = dm_mst_test_dpcd[(payload->address + i) & 0xf];
return payload->length;
}
static void dm_mst_test_setup_dm_aux(struct amdgpu_dm_dp_aux *dm_aux,
struct ddc_service *ddc,
struct dc_link *link,
struct dc *dc,
struct link_service *link_srv,
struct dc_context *ctx,
struct amdgpu_device *adev)
{
memset(&dm_mst_test_last_payload, 0, sizeof(dm_mst_test_last_payload));
dm_mst_test_aux_transfer_raw_result = 0;
dm_mst_test_aux_transfer_raw_reply = 0;
dm_mst_test_aux_transfer_raw_operation_result = AUX_RET_SUCCESS;
link_srv->aux_transfer_raw = dm_mst_test_aux_transfer_raw;
dc->link_srv = link_srv;
link->dc = dc;
ctx->driver_context = adev;
ddc->link = link;
ddc->ctx = ctx;
dm_aux->ddc_service = ddc;
dm_aux->aux.name = "dm_mst_test_dm_aux";
dm_aux->aux.transfer = dm_dp_aux_transfer;
drm_dp_aux_init(&dm_aux->aux);
drm_dp_dpcd_set_probe(&dm_aux->aux, false);
}
static const struct dc_link_status *dm_mst_test_get_status(const struct dc_link *link)
{
return &link->link_status;
}
static ssize_t dm_mst_test_aux_transfer(struct drm_dp_aux *aux,
struct drm_dp_aux_msg *msg)
{
size_t i;
ssize_t ret;
ret = dm_mst_test_aux_transfer_override;
if (ret)
return ret;
switch (msg->request & ~DP_AUX_I2C_MOT) {
case DP_AUX_NATIVE_READ:
for (i = 0; i < msg->size; i++)
((u8 *)msg->buffer)[i] =
dm_mst_test_dpcd[(msg->address + i) & 0xf];
msg->reply = DP_AUX_NATIVE_REPLY_ACK;
return msg->size;
case DP_AUX_NATIVE_WRITE:
if (dm_mst_test_aux_write_override)
return dm_mst_test_aux_write_override;
msg->reply = DP_AUX_NATIVE_REPLY_ACK;
return msg->size;
default:
return -EINVAL;
}
}
static struct amdgpu_dm_connector *dm_mst_test_alloc_sideband_connector(struct kunit *test)
{
struct amdgpu_dm_connector *aconnector;
struct link_service *link_srv;
struct dc_link *link;
struct dc *dc;
aconnector = kunit_kzalloc(test, sizeof(*aconnector), GFP_KERNEL);
link_srv = kunit_kzalloc(test, sizeof(*link_srv), GFP_KERNEL);
link = kunit_kzalloc(test, sizeof(*link), GFP_KERNEL);
dc = kunit_kzalloc(test, sizeof(*dc), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, aconnector);
KUNIT_ASSERT_NOT_NULL(test, link_srv);
KUNIT_ASSERT_NOT_NULL(test, link);
KUNIT_ASSERT_NOT_NULL(test, dc);
mutex_init(&aconnector->handle_mst_msg_ready);
link_srv->get_status = dm_mst_test_get_status;
dc->link_srv = link_srv;
link->dc = dc;
link->dpcd_caps.dpcd_rev.raw = DPCD_REV_14;
link->link_status.dpcd_caps = &link->dpcd_caps;
aconnector->dc_link = link;
aconnector->dm_dp_aux.aux.name = "dm_mst_test_sideband_aux";
aconnector->dm_dp_aux.aux.transfer = dm_mst_test_aux_transfer;
drm_dp_aux_init(&aconnector->dm_dp_aux.aux);
drm_dp_dpcd_set_probe(&aconnector->dm_dp_aux.aux, false);
memset(dm_mst_test_dpcd, 0, sizeof(dm_mst_test_dpcd));
dm_mst_test_aux_transfer_override = 0;
dm_mst_test_aux_write_override = 0;
return aconnector;
}
static uint32_t dm_mst_test_dp_link_bandwidth_kbps(
const struct dc_link *link,
const struct dc_link_settings *link_settings)
{
return 4320000;
}
static const struct dc_link_settings *dm_mst_test_dp_get_verified_link_cap(
const struct dc_link *link)
{
return &link->verified_link_cap;
}
static ssize_t dm_mst_test_desc_aux_transfer(struct drm_dp_aux *aux,
struct drm_dp_aux_msg *msg)
{
size_t i;
if ((msg->request & ~DP_AUX_I2C_MOT) != DP_AUX_NATIVE_READ)
return -EINVAL;
for (i = 0; i < msg->size; i++)
((u8 *)msg->buffer)[i] = dm_mst_test_desc_dpcd[msg->address + i - DP_BRANCH_OUI];
msg->reply = DP_AUX_NATIVE_REPLY_ACK;
return msg->size;
}
static void dm_mst_test_needs_dsc_aux_workaround_match(struct kunit *test)
{
struct dc_link *link = kunit_kzalloc(test, sizeof(*link), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, link);
link->dpcd_caps.branch_dev_id = DP_BRANCH_DEVICE_ID_90CC24;
link->dpcd_caps.dpcd_rev.raw = DPCD_REV_14;
link->dpcd_caps.sink_count.bits.SINK_COUNT = 2;
KUNIT_EXPECT_TRUE(test, needs_dsc_aux_workaround(link));
}
static void dm_mst_test_needs_dsc_aux_workaround_rev12(struct kunit *test)
{
struct dc_link *link = kunit_kzalloc(test, sizeof(*link), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, link);
link->dpcd_caps.branch_dev_id = DP_BRANCH_DEVICE_ID_90CC24;
link->dpcd_caps.dpcd_rev.raw = DPCD_REV_12;
link->dpcd_caps.sink_count.bits.SINK_COUNT = 3;
KUNIT_EXPECT_TRUE(test, needs_dsc_aux_workaround(link));
}
static void dm_mst_test_needs_dsc_aux_workaround_wrong_dev_id(struct kunit *test)
{
struct dc_link *link = kunit_kzalloc(test, sizeof(*link), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, link);
link->dpcd_caps.branch_dev_id = 0x123456;
link->dpcd_caps.dpcd_rev.raw = DPCD_REV_14;
link->dpcd_caps.sink_count.bits.SINK_COUNT = 2;
KUNIT_EXPECT_FALSE(test, needs_dsc_aux_workaround(link));
}
static void dm_mst_test_needs_dsc_aux_workaround_wrong_rev(struct kunit *test)
{
struct dc_link *link = kunit_kzalloc(test, sizeof(*link), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, link);
link->dpcd_caps.branch_dev_id = DP_BRANCH_DEVICE_ID_90CC24;
link->dpcd_caps.dpcd_rev.raw = 0x11;
link->dpcd_caps.sink_count.bits.SINK_COUNT = 2;
KUNIT_EXPECT_FALSE(test, needs_dsc_aux_workaround(link));
}
static void dm_mst_test_needs_dsc_aux_workaround_low_sink_count(struct kunit *test)
{
struct dc_link *link = kunit_kzalloc(test, sizeof(*link), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, link);
link->dpcd_caps.branch_dev_id = DP_BRANCH_DEVICE_ID_90CC24;
link->dpcd_caps.dpcd_rev.raw = DPCD_REV_14;
link->dpcd_caps.sink_count.bits.SINK_COUNT = 1;
KUNIT_EXPECT_FALSE(test, needs_dsc_aux_workaround(link));
}
static void dm_mst_test_needs_dsc_aux_workaround_zero_sink_count(struct kunit *test)
{
struct dc_link *link = kunit_kzalloc(test, sizeof(*link), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, link);
link->dpcd_caps.branch_dev_id = DP_BRANCH_DEVICE_ID_90CC24;
link->dpcd_caps.dpcd_rev.raw = DPCD_REV_14;
link->dpcd_caps.sink_count.bits.SINK_COUNT = 0;
KUNIT_EXPECT_FALSE(test, needs_dsc_aux_workaround(link));
}
static void dm_mst_test_pbn_divider_null_link(struct kunit *test)
{
KUNIT_EXPECT_EQ(test, dm_mst_get_pbn_divider(NULL), 0U);
}
static void dm_mst_test_pbn_divider_uses_link_bandwidth(struct kunit *test)
{
struct link_service *link_srv;
struct dc_link *link;
struct dc *dc;
link_srv = kunit_kzalloc(test, sizeof(*link_srv), GFP_KERNEL);
link = kunit_kzalloc(test, sizeof(*link), GFP_KERNEL);
dc = kunit_kzalloc(test, sizeof(*dc), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, link_srv);
KUNIT_ASSERT_NOT_NULL(test, link);
KUNIT_ASSERT_NOT_NULL(test, dc);
link_srv->dp_get_verified_link_cap = dm_mst_test_dp_get_verified_link_cap;
link_srv->dp_link_bandwidth_kbps = dm_mst_test_dp_link_bandwidth_kbps;
dc->link_srv = link_srv;
link->dc = dc;
KUNIT_EXPECT_EQ(test, dm_mst_get_pbn_divider(link),
(uint32_t)(dfixed_const(1000) / 100));
}
static void dm_mst_test_reset_connector_setting(struct kunit *test)
{
struct amdgpu_dm_connector *aconnector;
struct drm_dp_mst_port *port;
aconnector = kunit_kzalloc(test, sizeof(*aconnector), GFP_KERNEL);
port = kunit_kzalloc(test, sizeof(*port), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, aconnector);
KUNIT_ASSERT_NOT_NULL(test, port);
aconnector->drm_edid = (const struct drm_edid *)test;
aconnector->dsc_aux = (struct drm_dp_aux *)test;
aconnector->mst_output_port = port;
aconnector->mst_output_port->passthrough_aux = (struct drm_dp_aux *)test;
aconnector->mst_local_bw = 12345;
aconnector->vc_full_pbn = 678;
amdgpu_dm_mst_reset_mst_connector_setting(aconnector);
KUNIT_EXPECT_TRUE(test, aconnector->drm_edid == NULL);
KUNIT_EXPECT_TRUE(test, aconnector->dsc_aux == NULL);
KUNIT_EXPECT_TRUE(test, aconnector->mst_output_port->passthrough_aux == NULL);
KUNIT_EXPECT_EQ(test, aconnector->mst_local_bw, 0U);
KUNIT_EXPECT_EQ(test, aconnector->vc_full_pbn, 0U);
}
static void dm_mst_test_retrieve_downstream_no_aux(struct kunit *test)
{
struct amdgpu_dm_connector *aconnector;
aconnector = kunit_kzalloc(test, sizeof(*aconnector), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, aconnector);
aconnector->dsc_aux = NULL;
KUNIT_EXPECT_FALSE(test, retrieve_downstream_port_device(aconnector));
}
static void dm_mst_test_retrieve_downstream_present(struct kunit *test)
{
struct amdgpu_dm_connector *aconnector;
struct drm_dp_aux *aux;
aconnector = kunit_kzalloc(test, sizeof(*aconnector), GFP_KERNEL);
aux = kunit_kzalloc(test, sizeof(*aux), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, aconnector);
KUNIT_ASSERT_NOT_NULL(test, aux);
memset(dm_mst_test_dpcd, 0, sizeof(dm_mst_test_dpcd));
dm_mst_test_dpcd[DP_DOWNSTREAMPORT_PRESENT] = 0x05;
dm_mst_test_aux_transfer_override = 0;
aux->name = "dm_mst_test_aux";
aux->transfer = dm_mst_test_aux_transfer;
drm_dp_aux_init(aux);
drm_dp_dpcd_set_probe(aux, false);
aconnector->dsc_aux = aux;
KUNIT_EXPECT_TRUE(test, retrieve_downstream_port_device(aconnector));
KUNIT_EXPECT_EQ(test,
(int)aconnector->mst_downstream_port_present.fields.PORT_PRESENT, 1);
KUNIT_EXPECT_EQ(test,
(int)aconnector->mst_downstream_port_present.fields.PORT_TYPE, 2);
}
static void dm_mst_test_retrieve_downstream_aux_error(struct kunit *test)
{
struct amdgpu_dm_connector *aconnector;
struct drm_dp_aux *aux;
aconnector = kunit_kzalloc(test, sizeof(*aconnector), GFP_KERNEL);
aux = kunit_kzalloc(test, sizeof(*aux), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, aconnector);
KUNIT_ASSERT_NOT_NULL(test, aux);
dm_mst_test_aux_transfer_override = -EIO;
aux->name = "dm_mst_test_aux";
aux->transfer = dm_mst_test_aux_transfer;
drm_dp_aux_init(aux);
drm_dp_dpcd_set_probe(aux, false);
aconnector->dsc_aux = aux;
KUNIT_EXPECT_FALSE(test, retrieve_downstream_port_device(aconnector));
dm_mst_test_aux_transfer_override = 0;
}
static void dm_mst_test_retrieve_branch_no_parent(struct kunit *test)
{
struct amdgpu_dm_connector *aconnector;
struct drm_dp_mst_port *port;
aconnector = kunit_kzalloc(test, sizeof(*aconnector), GFP_KERNEL);
port = kunit_kzalloc(test, sizeof(*port), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, aconnector);
KUNIT_ASSERT_NOT_NULL(test, port);
port->parent = NULL;
aconnector->mst_output_port = port;
KUNIT_EXPECT_FALSE(test, retrieve_branch_specific_data(aconnector));
}
static void dm_mst_test_retrieve_branch_reads_oui(struct kunit *test)
{
struct amdgpu_dm_connector *aconnector;
struct drm_dp_mst_topology_mgr *mgr;
struct drm_dp_mst_branch *branch;
struct drm_dp_mst_port *port;
struct drm_dp_aux *aux;
aconnector = kunit_kzalloc(test, sizeof(*aconnector), GFP_KERNEL);
mgr = kunit_kzalloc(test, sizeof(*mgr), GFP_KERNEL);
branch = kunit_kzalloc(test, sizeof(*branch), GFP_KERNEL);
port = kunit_kzalloc(test, sizeof(*port), GFP_KERNEL);
aux = kunit_kzalloc(test, sizeof(*aux), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, aconnector);
KUNIT_ASSERT_NOT_NULL(test, mgr);
KUNIT_ASSERT_NOT_NULL(test, branch);
KUNIT_ASSERT_NOT_NULL(test, port);
KUNIT_ASSERT_NOT_NULL(test, aux);
memset(dm_mst_test_desc_dpcd, 0, sizeof(dm_mst_test_desc_dpcd));
dm_mst_test_desc_dpcd[0] = 0x12;
dm_mst_test_desc_dpcd[1] = 0x34;
dm_mst_test_desc_dpcd[2] = 0x56;
aux->name = "dm_mst_test_desc_aux";
aux->transfer = dm_mst_test_desc_aux_transfer;
drm_dp_aux_init(aux);
drm_dp_dpcd_set_probe(aux, false);
mgr->aux = aux;
port->parent = branch;
port->mgr = mgr;
port->aux.drm_dev = NULL;
aconnector->mst_output_port = port;
KUNIT_EXPECT_TRUE(test, retrieve_branch_specific_data(aconnector));
KUNIT_EXPECT_EQ(test, aconnector->branch_ieee_oui, 0x123456U);
}
static void dm_mst_test_aux_result_success(struct kunit *test)
{
KUNIT_EXPECT_EQ(test, dm_dp_aux_transfer_result(-5, AUX_RET_SUCCESS), (ssize_t)-5);
KUNIT_EXPECT_EQ(test, dm_dp_aux_transfer_result(3, AUX_RET_SUCCESS), (ssize_t)3);
}
static void dm_mst_test_aux_result_eio(struct kunit *test)
{
KUNIT_EXPECT_EQ(test, dm_dp_aux_transfer_result(-1, AUX_RET_ERROR_HPD_DISCON),
(ssize_t)-EIO);
KUNIT_EXPECT_EQ(test, dm_dp_aux_transfer_result(-1, AUX_RET_ERROR_UNKNOWN),
(ssize_t)-EIO);
KUNIT_EXPECT_EQ(test, dm_dp_aux_transfer_result(-1, AUX_RET_ERROR_INVALID_OPERATION),
(ssize_t)-EIO);
KUNIT_EXPECT_EQ(test, dm_dp_aux_transfer_result(-1, AUX_RET_ERROR_PROTOCOL_ERROR),
(ssize_t)-EIO);
}
static void dm_mst_test_aux_result_ebusy(struct kunit *test)
{
KUNIT_EXPECT_EQ(test, dm_dp_aux_transfer_result(-1, AUX_RET_ERROR_INVALID_REPLY),
(ssize_t)-EBUSY);
KUNIT_EXPECT_EQ(test, dm_dp_aux_transfer_result(-1, AUX_RET_ERROR_ENGINE_ACQUIRE),
(ssize_t)-EBUSY);
}
static void dm_mst_test_aux_result_timeout(struct kunit *test)
{
KUNIT_EXPECT_EQ(test, dm_dp_aux_transfer_result(-1, AUX_RET_ERROR_TIMEOUT),
(ssize_t)-ETIMEDOUT);
}
static void dm_mst_test_aux_transfer_native_read(struct kunit *test)
{
struct amdgpu_dm_dp_aux *dm_aux;
struct amdgpu_device *adev;
struct ddc_service *ddc;
struct dc_link *link;
struct dc *dc;
struct link_service *link_srv;
struct dc_context *ctx;
u8 buffer[3] = { 0 };
ssize_t ret;
dm_aux = kunit_kzalloc(test, sizeof(*dm_aux), GFP_KERNEL);
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
ddc = kunit_kzalloc(test, sizeof(*ddc), GFP_KERNEL);
link = kunit_kzalloc(test, sizeof(*link), GFP_KERNEL);
dc = kunit_kzalloc(test, sizeof(*dc), GFP_KERNEL);
link_srv = kunit_kzalloc(test, sizeof(*link_srv), GFP_KERNEL);
ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, dm_aux);
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ddc);
KUNIT_ASSERT_NOT_NULL(test, link);
KUNIT_ASSERT_NOT_NULL(test, dc);
KUNIT_ASSERT_NOT_NULL(test, link_srv);
KUNIT_ASSERT_NOT_NULL(test, ctx);
memset(dm_mst_test_dpcd, 0, sizeof(dm_mst_test_dpcd));
dm_mst_test_dpcd[4] = 0xaa;
dm_mst_test_dpcd[5] = 0xbb;
dm_mst_test_dpcd[6] = 0xcc;
dm_mst_test_setup_dm_aux(dm_aux, ddc, link, dc, link_srv, ctx, adev);
ret = drm_dp_dpcd_read(&dm_aux->aux, 4, buffer, sizeof(buffer));
KUNIT_EXPECT_EQ(test, ret, (ssize_t)sizeof(buffer));
KUNIT_EXPECT_EQ(test, buffer[0], (u8)0xaa);
KUNIT_EXPECT_EQ(test, buffer[1], (u8)0xbb);
KUNIT_EXPECT_EQ(test, buffer[2], (u8)0xcc);
KUNIT_EXPECT_FALSE(test, dm_mst_test_last_payload.write);
KUNIT_EXPECT_FALSE(test, dm_mst_test_last_payload.i2c_over_aux);
KUNIT_EXPECT_EQ(test, dm_mst_test_last_payload.address, 4U);
}
static void dm_mst_test_aux_transfer_native_write(struct kunit *test)
{
struct amdgpu_dm_dp_aux *dm_aux;
struct amdgpu_device *adev;
struct ddc_service *ddc;
struct dc_link *link;
struct dc *dc;
struct link_service *link_srv;
struct dc_context *ctx;
u8 buffer[2] = { 0x11, 0x22 };
ssize_t ret;
dm_aux = kunit_kzalloc(test, sizeof(*dm_aux), GFP_KERNEL);
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
ddc = kunit_kzalloc(test, sizeof(*ddc), GFP_KERNEL);
link = kunit_kzalloc(test, sizeof(*link), GFP_KERNEL);
dc = kunit_kzalloc(test, sizeof(*dc), GFP_KERNEL);
link_srv = kunit_kzalloc(test, sizeof(*link_srv), GFP_KERNEL);
ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, dm_aux);
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ddc);
KUNIT_ASSERT_NOT_NULL(test, link);
KUNIT_ASSERT_NOT_NULL(test, dc);
KUNIT_ASSERT_NOT_NULL(test, link_srv);
KUNIT_ASSERT_NOT_NULL(test, ctx);
dm_mst_test_setup_dm_aux(dm_aux, ddc, link, dc, link_srv, ctx, adev);
ret = drm_dp_dpcd_write(&dm_aux->aux, 7, buffer, sizeof(buffer));
KUNIT_EXPECT_EQ(test, ret, (ssize_t)sizeof(buffer));
KUNIT_EXPECT_TRUE(test, dm_mst_test_last_payload.write);
KUNIT_EXPECT_FALSE(test, dm_mst_test_last_payload.i2c_over_aux);
KUNIT_EXPECT_EQ(test, dm_mst_test_last_payload.address, 7U);
KUNIT_EXPECT_EQ(test, dm_mst_test_last_payload.length,
(u32)sizeof(buffer));
}
static void dm_mst_test_aux_transfer_partial_write(struct kunit *test)
{
struct amdgpu_dm_dp_aux *dm_aux;
struct amdgpu_device *adev;
struct ddc_service *ddc;
struct dc_link *link;
struct dc *dc;
struct link_service *link_srv;
struct dc_context *ctx;
u8 buffer[2] = { 1, 0xaa };
struct drm_dp_aux_msg msg = {
.address = 7,
.request = DP_AUX_NATIVE_WRITE,
.buffer = buffer,
.size = sizeof(buffer),
};
ssize_t ret;
dm_aux = kunit_kzalloc(test, sizeof(*dm_aux), GFP_KERNEL);
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
ddc = kunit_kzalloc(test, sizeof(*ddc), GFP_KERNEL);
link = kunit_kzalloc(test, sizeof(*link), GFP_KERNEL);
dc = kunit_kzalloc(test, sizeof(*dc), GFP_KERNEL);
link_srv = kunit_kzalloc(test, sizeof(*link_srv), GFP_KERNEL);
ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, dm_aux);
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ddc);
KUNIT_ASSERT_NOT_NULL(test, link);
KUNIT_ASSERT_NOT_NULL(test, dc);
KUNIT_ASSERT_NOT_NULL(test, link_srv);
KUNIT_ASSERT_NOT_NULL(test, ctx);
dm_mst_test_setup_dm_aux(dm_aux, ddc, link, dc, link_srv, ctx, adev);
dm_mst_test_aux_transfer_raw_result = 1;
ret = dm_dp_aux_transfer(&dm_aux->aux, &msg);
KUNIT_EXPECT_EQ(test, ret, (ssize_t)buffer[0]);
KUNIT_EXPECT_TRUE(test, dm_mst_test_last_payload.write);
KUNIT_EXPECT_EQ(test, dm_mst_test_last_payload.address, 7U);
}
static void dm_mst_test_aux_transfer_error_result(struct kunit *test)
{
struct amdgpu_dm_dp_aux *dm_aux;
struct amdgpu_device *adev;
struct ddc_service *ddc;
struct dc_link *link;
struct dc *dc;
struct link_service *link_srv;
struct dc_context *ctx;
u8 buffer[2] = { 0 };
ssize_t ret;
dm_aux = kunit_kzalloc(test, sizeof(*dm_aux), GFP_KERNEL);
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
ddc = kunit_kzalloc(test, sizeof(*ddc), GFP_KERNEL);
link = kunit_kzalloc(test, sizeof(*link), GFP_KERNEL);
dc = kunit_kzalloc(test, sizeof(*dc), GFP_KERNEL);
link_srv = kunit_kzalloc(test, sizeof(*link_srv), GFP_KERNEL);
ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, dm_aux);
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ddc);
KUNIT_ASSERT_NOT_NULL(test, link);
KUNIT_ASSERT_NOT_NULL(test, dc);
KUNIT_ASSERT_NOT_NULL(test, link_srv);
KUNIT_ASSERT_NOT_NULL(test, ctx);
dm_mst_test_setup_dm_aux(dm_aux, ddc, link, dc, link_srv, ctx, adev);
dm_mst_test_aux_transfer_raw_result = -EIO;
dm_mst_test_aux_transfer_raw_operation_result = AUX_RET_ERROR_TIMEOUT;
ret = drm_dp_dpcd_read(&dm_aux->aux, 4, buffer, sizeof(buffer));
KUNIT_EXPECT_EQ(test, ret, (ssize_t)-ETIMEDOUT);
KUNIT_EXPECT_FALSE(test, dm_mst_test_last_payload.write);
KUNIT_EXPECT_EQ(test, dm_mst_test_last_payload.address, 4U);
}
static void dm_mst_test_aux_transfer_hpd_discon_quirk(struct kunit *test)
{
struct amdgpu_dm_dp_aux *dm_aux;
struct amdgpu_device *adev;
struct ddc_service *ddc;
struct dc_link *link;
struct dc *dc;
struct link_service *link_srv;
struct dc_context *ctx;
u8 buffer[2] = { 2, 0 };
ssize_t ret;
dm_aux = kunit_kzalloc(test, sizeof(*dm_aux), GFP_KERNEL);
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
ddc = kunit_kzalloc(test, sizeof(*ddc), GFP_KERNEL);
link = kunit_kzalloc(test, sizeof(*link), GFP_KERNEL);
dc = kunit_kzalloc(test, sizeof(*dc), GFP_KERNEL);
link_srv = kunit_kzalloc(test, sizeof(*link_srv), GFP_KERNEL);
ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, dm_aux);
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ddc);
KUNIT_ASSERT_NOT_NULL(test, link);
KUNIT_ASSERT_NOT_NULL(test, dc);
KUNIT_ASSERT_NOT_NULL(test, link_srv);
KUNIT_ASSERT_NOT_NULL(test, ctx);
dm_mst_test_setup_dm_aux(dm_aux, ddc, link, dc, link_srv, ctx, adev);
adev->dm.aux_hpd_discon_quirk = true;
dm_mst_test_aux_transfer_raw_result = -EIO;
dm_mst_test_aux_transfer_raw_operation_result = AUX_RET_ERROR_HPD_DISCON;
ret = drm_dp_dpcd_write(&dm_aux->aux, DP_SIDEBAND_MSG_DOWN_REQ_BASE,
buffer, sizeof(buffer));
KUNIT_EXPECT_EQ(test, ret, (ssize_t)sizeof(buffer));
KUNIT_EXPECT_TRUE(test, dm_mst_test_last_payload.write);
KUNIT_EXPECT_EQ(test, dm_mst_test_last_payload.address,
DP_SIDEBAND_MSG_DOWN_REQ_BASE);
}
static void dm_mst_test_aux_transfer_non_ack_reply(struct kunit *test)
{
struct amdgpu_dm_dp_aux *dm_aux;
struct amdgpu_device *adev;
struct ddc_service *ddc;
struct dc_link *link;
struct dc *dc;
struct link_service *link_srv;
struct dc_context *ctx;
u8 buffer[2] = { 0 };
struct drm_dp_aux_msg msg = {
.address = 4,
.request = DP_AUX_NATIVE_READ,
.buffer = buffer,
.size = sizeof(buffer),
};
ssize_t ret;
dm_aux = kunit_kzalloc(test, sizeof(*dm_aux), GFP_KERNEL);
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
ddc = kunit_kzalloc(test, sizeof(*ddc), GFP_KERNEL);
link = kunit_kzalloc(test, sizeof(*link), GFP_KERNEL);
dc = kunit_kzalloc(test, sizeof(*dc), GFP_KERNEL);
link_srv = kunit_kzalloc(test, sizeof(*link_srv), GFP_KERNEL);
ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, dm_aux);
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, ddc);
KUNIT_ASSERT_NOT_NULL(test, link);
KUNIT_ASSERT_NOT_NULL(test, dc);
KUNIT_ASSERT_NOT_NULL(test, link_srv);
KUNIT_ASSERT_NOT_NULL(test, ctx);
dm_mst_test_setup_dm_aux(dm_aux, ddc, link, dc, link_srv, ctx, adev);
dm_mst_test_aux_transfer_raw_reply = DP_AUX_NATIVE_REPLY_NACK;
ret = dm_dp_aux_transfer(&dm_aux->aux, &msg);
KUNIT_EXPECT_EQ(test, ret, (ssize_t)sizeof(buffer));
KUNIT_EXPECT_EQ(test, dm_mst_test_last_payload.address, 4U);
}
static void dm_mst_test_aux_transfer_oversized(struct kunit *test)
{
struct drm_dp_aux_msg msg = { 0 };
u8 buffer[17] = { 0 };
msg.request = DP_AUX_NATIVE_WRITE;
msg.buffer = buffer;
msg.size = sizeof(buffer);
KUNIT_EXPECT_EQ(test, dm_dp_aux_transfer(NULL, &msg), (ssize_t)-E2BIG);
}
static void dm_mst_test_fill_payload_flags_native_write(struct kunit *test)
{
struct aux_payload payload = { 0 };
dm_dp_aux_fill_payload_flags(DP_AUX_NATIVE_WRITE, &payload);
KUNIT_EXPECT_FALSE(test, payload.i2c_over_aux);
KUNIT_EXPECT_TRUE(test, payload.write);
KUNIT_EXPECT_FALSE(test, payload.mot);
KUNIT_EXPECT_FALSE(test, payload.write_status_update);
}
static void dm_mst_test_fill_payload_flags_native_read(struct kunit *test)
{
struct aux_payload payload = { 0 };
dm_dp_aux_fill_payload_flags(DP_AUX_NATIVE_READ, &payload);
KUNIT_EXPECT_FALSE(test, payload.i2c_over_aux);
KUNIT_EXPECT_FALSE(test, payload.write);
KUNIT_EXPECT_FALSE(test, payload.mot);
}
static void dm_mst_test_fill_payload_flags_i2c_read_mot(struct kunit *test)
{
struct aux_payload payload = { 0 };
dm_dp_aux_fill_payload_flags(DP_AUX_I2C_READ | DP_AUX_I2C_MOT, &payload);
KUNIT_EXPECT_TRUE(test, payload.i2c_over_aux);
KUNIT_EXPECT_FALSE(test, payload.write);
KUNIT_EXPECT_TRUE(test, payload.mot);
}
static void dm_mst_test_fill_payload_flags_write_status(struct kunit *test)
{
struct aux_payload payload = { 0 };
dm_dp_aux_fill_payload_flags(DP_AUX_I2C_WRITE | DP_AUX_I2C_WRITE_STATUS_UPDATE,
&payload);
KUNIT_EXPECT_TRUE(test, payload.i2c_over_aux);
KUNIT_EXPECT_TRUE(test, payload.write_status_update);
}
static void dm_mst_test_msg_ready_mask(struct kunit *test)
{
KUNIT_EXPECT_EQ(test, dm_mst_msg_ready_mask(DOWN_REP_MSG_RDY_EVENT),
(u8)DP_DOWN_REP_MSG_RDY);
KUNIT_EXPECT_EQ(test, dm_mst_msg_ready_mask(UP_REQ_MSG_RDY_EVENT),
(u8)DP_UP_REQ_MSG_RDY);
KUNIT_EXPECT_EQ(test, dm_mst_msg_ready_mask(DOWN_OR_UP_MSG_RDY_EVENT),
(u8)(DP_DOWN_REP_MSG_RDY | DP_UP_REQ_MSG_RDY));
KUNIT_EXPECT_EQ(test, dm_mst_msg_ready_mask(NONE_MSG_RDY_EVENT),
(u8)(DP_DOWN_REP_MSG_RDY | DP_UP_REQ_MSG_RDY));
}
static void dm_mst_test_select_esi_dpcd_legacy(struct kunit *test)
{
int dpcd_addr = -1;
u8 dpcd_bytes_to_read = 0;
dm_mst_select_esi_dpcd(0x11, &dpcd_addr, &dpcd_bytes_to_read);
KUNIT_EXPECT_EQ(test, dpcd_addr, DP_SINK_COUNT);
KUNIT_EXPECT_EQ(test, (int)dpcd_bytes_to_read,
(int)(DP_LANE0_1_STATUS - DP_SINK_COUNT));
}
static void dm_mst_test_select_esi_dpcd_esi(struct kunit *test)
{
int dpcd_addr = -1;
u8 dpcd_bytes_to_read = 0;
dm_mst_select_esi_dpcd(0x14, &dpcd_addr, &dpcd_bytes_to_read);
KUNIT_EXPECT_EQ(test, dpcd_addr, DP_SINK_COUNT_ESI);
KUNIT_EXPECT_EQ(test, (int)dpcd_bytes_to_read,
(int)(DP_PSR_ERROR_STATUS - DP_SINK_COUNT_ESI));
}
static void dm_mst_test_sideband_msg_ready_no_ready_bits(struct kunit *test)
{
struct amdgpu_dm_connector *aconnector;
aconnector = dm_mst_test_alloc_sideband_connector(test);
dm_handle_mst_sideband_msg_ready_event(&aconnector->mst_mgr,
DOWN_REP_MSG_RDY_EVENT);
KUNIT_EXPECT_EQ(test, dm_mst_test_dpcd[1], (u8)0);
}
static void dm_mst_test_sideband_msg_ready_read_error(struct kunit *test)
{
struct amdgpu_dm_connector *aconnector;
aconnector = dm_mst_test_alloc_sideband_connector(test);
dm_mst_test_aux_transfer_override = -EIO;
dm_handle_mst_sideband_msg_ready_event(&aconnector->mst_mgr,
DOWN_REP_MSG_RDY_EVENT);
KUNIT_EXPECT_EQ(test, dm_mst_test_dpcd[1], (u8)0);
dm_mst_test_aux_transfer_override = 0;
}
static void dm_mst_test_sideband_msg_ready_without_mst_state(struct kunit *test)
{
struct amdgpu_dm_connector *aconnector;
aconnector = dm_mst_test_alloc_sideband_connector(test);
dm_mst_test_dpcd[(DP_SINK_COUNT_ESI + 1) & 0xf] = DP_DOWN_REP_MSG_RDY;
dm_handle_mst_sideband_msg_ready_event(&aconnector->mst_mgr,
DOWN_REP_MSG_RDY_EVENT);
KUNIT_EXPECT_EQ(test, dm_mst_test_dpcd[(DP_SINK_COUNT_ESI + 1) & 0xf],
DP_DOWN_REP_MSG_RDY);
}
static void dm_mst_test_down_rep_msg_ready_wrapper(struct kunit *test)
{
struct amdgpu_dm_connector *aconnector;
aconnector = dm_mst_test_alloc_sideband_connector(test);
dm_handle_mst_down_rep_msg_ready(&aconnector->mst_mgr);
KUNIT_EXPECT_EQ(test, dm_mst_test_dpcd[1], (u8)0);
}
static void dm_mst_test_initialize_dp_connector_edp(struct kunit *test)
{
struct amdgpu_dm_connector *aconnector;
struct amdgpu_device *adev;
struct ddc_service *ddc;
struct dc_link *link;
adev = dm_kunit_alloc_adev(test);
link = dm_kunit_alloc_link(test);
ddc = kunit_kzalloc(test, sizeof(*ddc), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, ddc);
adev->dm.adev = adev;
adev->dm.ddev = &adev->ddev;
link->ddc = ddc;
aconnector = dm_kunit_alloc_connector(test, adev, link);
aconnector->base.connector_type = DRM_MODE_CONNECTOR_eDP;
amdgpu_dm_initialize_dp_connector(&adev->dm, aconnector, 5);
KUNIT_EXPECT_TRUE(test, aconnector->dm_dp_aux.aux.transfer == dm_dp_aux_transfer);
KUNIT_EXPECT_PTR_EQ(test, aconnector->dm_dp_aux.aux.drm_dev, &adev->ddev);
KUNIT_EXPECT_PTR_EQ(test, aconnector->dm_dp_aux.ddc_service, ddc);
KUNIT_EXPECT_PTR_EQ(test, aconnector->mst_mgr.dev, NULL);
KUNIT_EXPECT_NOT_NULL(test, aconnector->dm_dp_aux.aux.name);
if (aconnector->dm_dp_aux.aux.name)
KUNIT_EXPECT_NOT_NULL(test, strstr(aconnector->dm_dp_aux.aux.name, "5"));
drm_dp_cec_unregister_connector(&aconnector->dm_dp_aux.aux);
kfree(aconnector->dm_dp_aux.aux.name);
}
static bool dm_mst_test_dp_get_max_link_enc_cap(const struct dc_link *link,
struct dc_link_settings *cap)
{
return true;
}
static void dm_mst_test_connector_destroy(struct drm_connector *connector)
{
}
static const struct drm_connector_funcs dm_mst_test_connector_funcs = {
.reset = drm_atomic_helper_connector_reset,
.destroy = dm_mst_test_connector_destroy,
.atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
.atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
};
static void dm_mst_test_initialize_dp_connector_mst(struct kunit *test)
{
struct amdgpu_dm_connector *aconnector;
struct amdgpu_device *adev;
struct link_service *link_srv;
struct ddc_service *ddc;
struct dc_link *link;
struct dc *dc;
int ret;
adev = dm_kunit_alloc_adev(test);
ret = drmm_mode_config_init(&adev->ddev);
KUNIT_ASSERT_EQ(test, ret, 0);
ddc = kunit_kzalloc(test, sizeof(*ddc), GFP_KERNEL);
link = dm_kunit_alloc_link(test);
dc = kunit_kzalloc(test, sizeof(*dc), GFP_KERNEL);
link_srv = kunit_kzalloc(test, sizeof(*link_srv), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, ddc);
KUNIT_ASSERT_NOT_NULL(test, dc);
KUNIT_ASSERT_NOT_NULL(test, link_srv);
link_srv->dp_get_max_link_enc_cap = dm_mst_test_dp_get_max_link_enc_cap;
dc->link_srv = link_srv;
link->dc = dc;
link->ddc = ddc;
adev->dm.adev = adev;
adev->dm.ddev = &adev->ddev;
aconnector = dm_kunit_alloc_connector(test, adev, link);
ret = drm_connector_init(&adev->ddev, &aconnector->base,
&dm_mst_test_connector_funcs,
DRM_MODE_CONNECTOR_DisplayPort);
KUNIT_ASSERT_EQ(test, ret, 0);
amdgpu_dm_initialize_dp_connector(&adev->dm, aconnector, 7);
KUNIT_EXPECT_TRUE(test, aconnector->dm_dp_aux.aux.transfer == dm_dp_aux_transfer);
KUNIT_EXPECT_PTR_EQ(test, aconnector->mst_mgr.dev, &adev->ddev);
KUNIT_EXPECT_PTR_EQ(test, aconnector->mst_mgr.aux, &aconnector->dm_dp_aux.aux);
KUNIT_EXPECT_EQ(test, aconnector->mst_mgr.max_payloads, 4);
KUNIT_EXPECT_TRUE(test, aconnector->mst_mgr.cbs != NULL);
drm_dp_mst_topology_mgr_destroy(&aconnector->mst_mgr);
drm_dp_cec_unregister_connector(&aconnector->dm_dp_aux.aux);
kfree(aconnector->dm_dp_aux.aux.name);
drm_connector_cleanup(&aconnector->base);
}
static void dm_mst_test_atomic_best_encoder(struct kunit *test)
{
struct drm_connector_state connector_state = { 0 };
struct drm_atomic_commit state = { 0 };
struct amdgpu_dm_connector *aconnector;
struct amdgpu_device *adev;
struct amdgpu_crtc *acrtc;
unsigned int connector_index = 3;
adev = kunit_kzalloc(test, sizeof(*adev), GFP_KERNEL);
aconnector = kunit_kzalloc(test, sizeof(*aconnector), GFP_KERNEL);
acrtc = kunit_kzalloc(test, sizeof(*acrtc), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, adev);
KUNIT_ASSERT_NOT_NULL(test, aconnector);
KUNIT_ASSERT_NOT_NULL(test, acrtc);
aconnector->base.dev = &adev->ddev;
aconnector->base.index = connector_index;
acrtc->crtc_id = 2;
connector_state.connector = &aconnector->base;
connector_state.crtc = &acrtc->base;
state.num_connector = connector_index + 1;
state.connectors = kunit_kzalloc(test,
sizeof(*state.connectors) * state.num_connector,
GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, state.connectors);
state.connectors[connector_index].ptr = &aconnector->base;
state.connectors[connector_index].new_state = &connector_state;
KUNIT_EXPECT_PTR_EQ(test, dm_mst_atomic_best_encoder(&aconnector->base, &state),
&adev->dm.mst_encoders[2].base);
}
static void dm_mst_test_create_fake_mst_encoders(struct kunit *test)
{
struct amdgpu_device *adev;
struct drm_device *drm;
int i;
adev = dm_kunit_alloc_adev(test);
drm = &adev->ddev;
adev->dm.display_indexes_num = 3;
adev->mode_info.num_crtc = 3;
dm_dp_create_fake_mst_encoders(adev);
for (i = 0; i < adev->dm.display_indexes_num; i++) {
struct drm_encoder *encoder = &adev->dm.mst_encoders[i].base;
KUNIT_EXPECT_PTR_EQ(test, encoder->dev, drm);
KUNIT_EXPECT_EQ(test, encoder->encoder_type, DRM_MODE_ENCODER_DPMST);
KUNIT_EXPECT_EQ(test, encoder->possible_crtcs, 0x7U);
KUNIT_EXPECT_TRUE(test, encoder->helper_private != NULL);
}
}
struct dm_mst_test_add_ctx {
struct amdgpu_device *adev;
struct amdgpu_dm_connector *master;
struct drm_dp_mst_port *port;
struct dc_link *link;
};
static void dm_mst_test_cleanup_add_ctx(void *data)
{
struct amdgpu_dm_connector *master = data;
drm_connector_cleanup(&master->base);
}
static void dm_mst_test_create_mode_props(struct kunit *test, struct amdgpu_device *adev)
{
struct amdgpu_mode_info *mode_info = &adev->mode_info;
struct drm_device *drm = adev_to_drm(adev);
KUNIT_ASSERT_EQ(test, drm_mode_create_scaling_mode_property(drm), 0);
mode_info->underscan_property =
drm_property_create_range(drm, 0, "underscan", 0, 1);
mode_info->underscan_hborder_property =
drm_property_create_range(drm, 0, "underscan hborder", 0, 128);
mode_info->underscan_vborder_property =
drm_property_create_range(drm, 0, "underscan vborder", 0, 128);
KUNIT_ASSERT_NOT_NULL(test, mode_info->underscan_property);
KUNIT_ASSERT_NOT_NULL(test, mode_info->underscan_hborder_property);
KUNIT_ASSERT_NOT_NULL(test, mode_info->underscan_vborder_property);
}
static void dm_mst_test_init_add_ctx(struct kunit *test, struct dm_mst_test_add_ctx *ctx)
{
struct amdgpu_device *adev;
struct drm_device *drm;
int ret;
adev = dm_kunit_alloc_adev(test);
drm = &adev->ddev;
ret = drmm_mode_config_init(drm);
KUNIT_ASSERT_EQ(test, ret, 0);
dm_mst_test_create_mode_props(test, adev);
adev->dm.adev = adev;
adev->dm.ddev = drm;
adev->dm.display_indexes_num = 2;
adev->mode_info.num_crtc = 2;
dm_dp_create_fake_mst_encoders(adev);
ctx->adev = adev;
ctx->link = dm_kunit_alloc_link(test);
ctx->link->link_enc = kunit_kzalloc(test, sizeof(*ctx->link->link_enc), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, ctx->link->link_enc);
ctx->master = dm_kunit_alloc_connector(test, adev, ctx->link);
ctx->master->connector_id = 5;
ret = drm_connector_init(drm, &ctx->master->base, &dm_mst_test_connector_funcs,
DRM_MODE_CONNECTOR_DisplayPort);
KUNIT_ASSERT_EQ(test, ret, 0);
KUNIT_ASSERT_EQ(test,
kunit_add_action_or_reset(test, dm_mst_test_cleanup_add_ctx, ctx->master), 0);
ctx->port = kunit_kzalloc(test, sizeof(*ctx->port), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, ctx->port);
kref_init(&ctx->port->malloc_kref);
ctx->port->mgr = &ctx->master->mst_mgr;
}
static bool dm_mst_test_has_prop(struct drm_connector *connector, struct drm_property *prop)
{
struct drm_object_properties *props = connector->base.properties;
int i;
if (!prop)
return false;
for (i = 0; i < props->count; i++)
if (props->properties[i] == prop)
return true;
return false;
}
static void dm_mst_test_add_mst_connector_creates(struct kunit *test)
{
struct amdgpu_dm_connector *aconnector;
struct dm_mst_test_add_ctx ctx;
struct drm_connector *connector;
dm_mst_test_init_add_ctx(test, &ctx);
connector = dm_dp_add_mst_connector(&ctx.master->mst_mgr, ctx.port, "1-3");
KUNIT_ASSERT_NOT_NULL(test, connector);
aconnector = to_amdgpu_dm_connector(connector);
KUNIT_EXPECT_PTR_EQ(test, aconnector->mst_output_port, ctx.port);
KUNIT_EXPECT_PTR_EQ(test, aconnector->mst_root, ctx.master);
KUNIT_EXPECT_PTR_EQ(test, aconnector->dc_link, ctx.link);
KUNIT_EXPECT_EQ(test, aconnector->connector_id, 5);
KUNIT_EXPECT_TRUE(test, aconnector->mst_status & MST_PROBE);
KUNIT_EXPECT_EQ(test, aconnector->branch_ieee_oui, 0U);
KUNIT_EXPECT_EQ(test, connector->connector_type, DRM_MODE_CONNECTOR_DisplayPort);
KUNIT_EXPECT_EQ(test, connector->possible_encoders, 0x3U);
KUNIT_EXPECT_NOT_NULL(test, connector->state);
KUNIT_EXPECT_NOT_NULL(test, connector->path_blob_ptr);
KUNIT_EXPECT_EQ(test, kref_read(&ctx.port->malloc_kref), 2U);
KUNIT_EXPECT_TRUE(test,
dm_mst_test_has_prop(connector,
ctx.adev->ddev.mode_config.path_property));
KUNIT_EXPECT_TRUE(test,
dm_mst_test_has_prop(connector,
ctx.adev->ddev.mode_config.tile_property));
dm_dp_mst_connector_destroy(connector);
}
static void dm_mst_test_add_mst_connector_inherits_props(struct kunit *test)
{
struct dm_mst_test_add_ctx ctx;
struct drm_connector *connector;
struct drm_device *drm;
dm_mst_test_init_add_ctx(test, &ctx);
drm = &ctx.adev->ddev;
ctx.master->base.max_bpc_property =
drm_property_create_range(drm, 0, "max bpc", 8, 16);
ctx.master->base.vrr_capable_property =
drm_property_create_bool(drm, DRM_MODE_PROP_IMMUTABLE, "vrr_capable");
KUNIT_ASSERT_NOT_NULL(test, ctx.master->base.max_bpc_property);
KUNIT_ASSERT_NOT_NULL(test, ctx.master->base.vrr_capable_property);
KUNIT_ASSERT_EQ(test, drm_mode_create_dp_colorspace_property(&ctx.master->base, 0), 0);
connector = dm_dp_add_mst_connector(&ctx.master->mst_mgr, ctx.port, "1-4");
KUNIT_ASSERT_NOT_NULL(test, connector);
KUNIT_EXPECT_PTR_EQ(test, connector->max_bpc_property, ctx.master->base.max_bpc_property);
KUNIT_EXPECT_PTR_EQ(test, connector->vrr_capable_property,
ctx.master->base.vrr_capable_property);
KUNIT_EXPECT_PTR_EQ(test, connector->colorspace_property,
ctx.master->base.colorspace_property);
KUNIT_EXPECT_TRUE(test, dm_mst_test_has_prop(connector, connector->max_bpc_property));
KUNIT_EXPECT_TRUE(test, dm_mst_test_has_prop(connector, connector->colorspace_property));
dm_dp_mst_connector_destroy(connector);
}
static void dm_mst_test_add_mst_connector_init_fails(struct kunit *test)
{
struct dm_mst_test_add_ctx ctx;
struct drm_device *drm;
int id;
dm_mst_test_init_add_ctx(test, &ctx);
drm = &ctx.adev->ddev;
do {
id = ida_alloc_max(&drm->mode_config.connector_ida, 31, GFP_KERNEL);
} while (id >= 0);
KUNIT_ASSERT_EQ(test, id, -ENOSPC);
KUNIT_EXPECT_NULL(test, dm_dp_add_mst_connector(&ctx.master->mst_mgr, ctx.port, "1-5"));
KUNIT_EXPECT_EQ(test, kref_read(&ctx.port->malloc_kref), 1U);
}
static void dm_mst_test_atomic_check_no_old_crtc(struct kunit *test)
{
struct drm_connector_state *old_conn_state;
struct drm_connector_state *new_conn_state;
struct drm_atomic_commit *state;
struct amdgpu_dm_connector *aconnector;
struct amdgpu_dm_connector *root;
struct drm_dp_mst_port *port;
unsigned int connector_index = 2;
old_conn_state = kunit_kzalloc(test, sizeof(*old_conn_state), GFP_KERNEL);
new_conn_state = kunit_kzalloc(test, sizeof(*new_conn_state), GFP_KERNEL);
state = kunit_kzalloc(test, sizeof(*state), GFP_KERNEL);
aconnector = kunit_kzalloc(test, sizeof(*aconnector), GFP_KERNEL);
root = kunit_kzalloc(test, sizeof(*root), GFP_KERNEL);
port = kunit_kzalloc(test, sizeof(*port), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, old_conn_state);
KUNIT_ASSERT_NOT_NULL(test, new_conn_state);
KUNIT_ASSERT_NOT_NULL(test, state);
KUNIT_ASSERT_NOT_NULL(test, aconnector);
KUNIT_ASSERT_NOT_NULL(test, root);
KUNIT_ASSERT_NOT_NULL(test, port);
aconnector->base.index = connector_index;
aconnector->mst_root = root;
aconnector->mst_output_port = port;
port->connector = &aconnector->base;
old_conn_state->connector = &aconnector->base;
new_conn_state->connector = &aconnector->base;
state->num_connector = connector_index + 1;
state->connectors = kunit_kzalloc(test,
sizeof(*state->connectors) * state->num_connector,
GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, state->connectors);
state->connectors[connector_index].ptr = &aconnector->base;
state->connectors[connector_index].old_state = old_conn_state;
state->connectors[connector_index].new_state = new_conn_state;
KUNIT_EXPECT_EQ(test, dm_dp_mst_atomic_check(&aconnector->base, state), 0);
}
static void dm_mst_test_detect_unregistered(struct kunit *test)
{
struct amdgpu_dm_connector *aconnector;
aconnector = kunit_kzalloc(test, sizeof(*aconnector), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, aconnector);
aconnector->base.registration_state = DRM_CONNECTOR_UNREGISTERED;
KUNIT_EXPECT_EQ(test,
dm_dp_mst_detect(&aconnector->base, NULL, false),
(int)connector_status_disconnected);
}
static struct dc_sink *dm_mst_test_next_remote_sink;
static struct dc_sink *dm_mst_test_removed_sink;
static unsigned int dm_mst_test_add_remote_sink_calls;
static unsigned int dm_mst_test_remove_remote_sink_calls;
static struct dc_sink *dm_mst_test_add_remote_sink(
struct dc_link *link,
const uint8_t *edid,
unsigned int len,
struct dc_sink_init_data *init_data)
{
struct dc_sink *sink = dm_mst_test_next_remote_sink;
dm_mst_test_add_remote_sink_calls++;
if (sink) {
sink->link = link;
sink->sink_signal = init_data->sink_signal;
link->sink_count++;
}
return sink;
}
static void dm_mst_test_remove_remote_sink(struct dc_link *link, struct dc_sink *sink)
{
dm_mst_test_remove_remote_sink_calls++;
dm_mst_test_removed_sink = sink;
if (link->sink_count)
link->sink_count--;
}
static struct dc_sink *dm_mst_test_alloc_sink(struct kunit *test)
{
struct dc_sink *sink = kzalloc_obj(*sink);
KUNIT_ASSERT_NOT_NULL(test, sink);
kref_init(&sink->refcount);
return sink;
}
struct dm_mst_test_child {
struct amdgpu_device *adev;
struct amdgpu_dm_connector *aconnector;
struct amdgpu_dm_connector *root;
struct drm_dp_mst_port *port;
struct dc_link *link;
};
static void dm_mst_test_init_child(struct kunit *test, struct dm_mst_test_child *child)
{
struct link_service *link_srv;
struct amdgpu_device *adev;
struct dc *dc;
int ret;
adev = dm_kunit_alloc_adev(test);
ret = drmm_mode_config_init(&adev->ddev);
KUNIT_ASSERT_EQ(test, ret, 0);
dc = kunit_kzalloc(test, sizeof(*dc), GFP_KERNEL);
link_srv = kunit_kzalloc(test, sizeof(*link_srv), GFP_KERNEL);
child->port = kunit_kzalloc(test, sizeof(*child->port), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, dc);
KUNIT_ASSERT_NOT_NULL(test, link_srv);
KUNIT_ASSERT_NOT_NULL(test, child->port);
link_srv->add_remote_sink = dm_mst_test_add_remote_sink;
link_srv->remove_remote_sink = dm_mst_test_remove_remote_sink;
dc->link_srv = link_srv;
child->adev = adev;
child->link = dm_kunit_alloc_link(test);
child->link->dc = dc;
child->root = dm_kunit_alloc_connector(test, adev, child->link);
child->root->mst_mgr.dev = &adev->ddev;
mutex_init(&child->root->mst_mgr.lock);
drm_modeset_lock_init(&child->root->mst_mgr.base.lock);
child->port->mgr = &child->root->mst_mgr;
child->port->aux.name = "dm_mst_test_port_aux";
child->port->aux.transfer = dm_mst_test_aux_transfer;
drm_dp_aux_init(&child->port->aux);
drm_dp_dpcd_set_probe(&child->port->aux, false);
child->aconnector = dm_kunit_alloc_connector(test, adev, child->link);
child->aconnector->mst_root = child->root;
child->aconnector->mst_output_port = child->port;
ret = drm_connector_init(&adev->ddev, &child->aconnector->base,
&dm_mst_test_connector_funcs,
DRM_MODE_CONNECTOR_DisplayPort);
KUNIT_ASSERT_EQ(test, ret, 0);
child->aconnector->base.kdev = adev->ddev.dev;
memset(dm_mst_test_dpcd, 0, sizeof(dm_mst_test_dpcd));
dm_mst_test_aux_transfer_override = 0;
dm_mst_test_aux_write_override = 0;
dm_mst_test_next_remote_sink = NULL;
dm_mst_test_removed_sink = NULL;
dm_mst_test_add_remote_sink_calls = 0;
dm_mst_test_remove_remote_sink_calls = 0;
}
static void dm_mst_test_fini_child(struct dm_mst_test_child *child)
{
drm_edid_free(child->aconnector->drm_edid);
drm_edid_free(child->port->cached_edid);
drm_connector_cleanup(&child->aconnector->base);
drm_modeset_lock_fini(&child->root->mst_mgr.base.lock);
mutex_destroy(&child->root->mst_mgr.lock);
}
static void dm_mst_test_get_modes_no_edid_adds_default_sink(struct kunit *test)
{
struct dm_mst_test_child child;
struct dc_sink *sink;
dm_mst_test_init_child(test, &child);
sink = dm_mst_test_alloc_sink(test);
dm_mst_test_next_remote_sink = sink;
child.aconnector->mst_status = MST_REMOTE_EDID;
KUNIT_EXPECT_EQ(test, dm_dp_mst_get_modes(&child.aconnector->base), 0);
KUNIT_EXPECT_EQ(test, dm_mst_test_add_remote_sink_calls, 1U);
KUNIT_EXPECT_PTR_EQ(test, child.aconnector->dc_sink, sink);
KUNIT_EXPECT_PTR_EQ(test, sink->priv, (void *)child.aconnector);
KUNIT_EXPECT_EQ(test, child.aconnector->mst_status & MST_REMOTE_EDID, 0);
dc_sink_release(sink);
dm_mst_test_fini_child(&child);
}
static void dm_mst_test_get_modes_no_edid_sink_alloc_fails(struct kunit *test)
{
struct dm_mst_test_child child;
dm_mst_test_init_child(test, &child);
KUNIT_EXPECT_EQ(test, dm_dp_mst_get_modes(&child.aconnector->base), 0);
KUNIT_EXPECT_EQ(test, dm_mst_test_add_remote_sink_calls, 1U);
KUNIT_EXPECT_NULL(test, child.aconnector->dc_sink);
dm_mst_test_fini_child(&child);
}
static void dm_mst_test_get_modes_no_edid_keeps_existing_sink(struct kunit *test)
{
struct dm_mst_test_child child;
struct dc_sink *sink;
dm_mst_test_init_child(test, &child);
sink = dm_mst_test_alloc_sink(test);
child.aconnector->dc_sink = sink;
KUNIT_EXPECT_EQ(test, dm_dp_mst_get_modes(&child.aconnector->base), 0);
KUNIT_EXPECT_EQ(test, dm_mst_test_add_remote_sink_calls, 0U);
KUNIT_EXPECT_PTR_EQ(test, child.aconnector->dc_sink, sink);
dc_sink_release(sink);
dm_mst_test_fini_child(&child);
}
static const u8 dm_mst_test_edid[EDID_LENGTH] = {
0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
[EDID_LENGTH - 1] = 0x06,
};
static void dm_mst_test_get_modes_cached_edid_replaces_virtual_sink(struct kunit *test)
{
struct dm_mst_test_child child;
struct dc_sink *virtual_sink;
struct dc_sink *sink;
dm_mst_test_init_child(test, &child);
child.aconnector->drm_edid = drm_edid_alloc(dm_mst_test_edid, sizeof(dm_mst_test_edid));
KUNIT_ASSERT_NOT_NULL(test, child.aconnector->drm_edid);
virtual_sink = dm_mst_test_alloc_sink(test);
virtual_sink->sink_signal = SIGNAL_TYPE_VIRTUAL;
child.aconnector->dc_sink = virtual_sink;
sink = dm_mst_test_alloc_sink(test);
dm_mst_test_next_remote_sink = sink;
KUNIT_EXPECT_EQ(test, dm_dp_mst_get_modes(&child.aconnector->base), 0);
KUNIT_EXPECT_EQ(test, dm_mst_test_add_remote_sink_calls, 1U);
KUNIT_EXPECT_PTR_EQ(test, child.aconnector->dc_sink, sink);
KUNIT_EXPECT_EQ(test, sink->sink_signal, SIGNAL_TYPE_DISPLAY_PORT_MST);
KUNIT_EXPECT_PTR_EQ(test, sink->priv, (void *)child.aconnector);
dc_sink_release(sink);
dm_mst_test_fini_child(&child);
}
static void dm_mst_test_get_modes_cached_edid_sink_alloc_fails(struct kunit *test)
{
struct dm_mst_test_child child;
dm_mst_test_init_child(test, &child);
child.aconnector->drm_edid = drm_edid_alloc(dm_mst_test_edid, sizeof(dm_mst_test_edid));
KUNIT_ASSERT_NOT_NULL(test, child.aconnector->drm_edid);
KUNIT_EXPECT_EQ(test, dm_dp_mst_get_modes(&child.aconnector->base), 0);
KUNIT_EXPECT_EQ(test, dm_mst_test_add_remote_sink_calls, 1U);
KUNIT_EXPECT_NULL(test, child.aconnector->dc_sink);
dm_mst_test_fini_child(&child);
}
static void dm_mst_test_get_modes_restores_hdcp_properties(struct kunit *test)
{
struct dm_connector_state *conn_state;
struct dm_mst_test_child child;
struct hdcp_workqueue *hdcp;
struct dc_sink *sink;
unsigned int index;
dm_mst_test_init_child(test, &child);
child.aconnector->drm_edid = drm_edid_alloc(dm_mst_test_edid, sizeof(dm_mst_test_edid));
KUNIT_ASSERT_NOT_NULL(test, child.aconnector->drm_edid);
conn_state = kzalloc_obj(*conn_state);
hdcp = kunit_kzalloc(test, sizeof(*hdcp), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, conn_state);
KUNIT_ASSERT_NOT_NULL(test, hdcp);
index = child.aconnector->base.index;
hdcp->hdcp_content_type[index] = DRM_MODE_HDCP_CONTENT_TYPE1;
hdcp->content_protection[index] = DRM_MODE_CONTENT_PROTECTION_ENABLED;
child.adev->dm.hdcp_workqueue = hdcp;
child.aconnector->base.state = &conn_state->base;
sink = dm_mst_test_alloc_sink(test);
dm_mst_test_next_remote_sink = sink;
KUNIT_EXPECT_EQ(test, dm_dp_mst_get_modes(&child.aconnector->base), 0);
KUNIT_EXPECT_PTR_EQ(test, child.aconnector->dc_sink, sink);
KUNIT_EXPECT_EQ(test, child.aconnector->base.state->hdcp_content_type,
(unsigned int)DRM_MODE_HDCP_CONTENT_TYPE1);
KUNIT_EXPECT_EQ(test, child.aconnector->base.state->content_protection,
(unsigned int)DRM_MODE_CONTENT_PROTECTION_ENABLED);
dc_sink_release(sink);
dm_mst_test_fini_child(&child);
}
static void dm_mst_test_get_modes_reads_remote_edid(struct kunit *test)
{
struct drm_dp_mst_branch *mstb;
struct dm_mst_test_child child;
struct dc_sink *sink;
dm_mst_test_init_child(test, &child);
mstb = kunit_kzalloc(test, sizeof(*mstb), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, mstb);
mstb->mgr = &child.root->mst_mgr;
INIT_LIST_HEAD(&mstb->ports);
list_add(&child.port->next, &mstb->ports);
kref_init(&child.port->topology_kref);
child.root->mst_mgr.mst_primary = mstb;
child.port->cached_edid = drm_edid_alloc(dm_mst_test_edid, sizeof(dm_mst_test_edid));
KUNIT_ASSERT_NOT_NULL(test, child.port->cached_edid);
sink = dm_mst_test_alloc_sink(test);
dm_mst_test_next_remote_sink = sink;
KUNIT_EXPECT_EQ(test, dm_dp_mst_get_modes(&child.aconnector->base), 0);
KUNIT_EXPECT_NOT_NULL(test, child.aconnector->drm_edid);
KUNIT_EXPECT_EQ(test, child.aconnector->mst_status & MST_REMOTE_EDID, (int)MST_REMOTE_EDID);
KUNIT_EXPECT_PTR_EQ(test, child.aconnector->dc_sink, sink);
dc_sink_release(sink);
dm_mst_test_fini_child(&child);
}
static void dm_mst_test_detect_reads_port_dpcd_rev(struct kunit *test)
{
struct dm_mst_test_child child;
dm_mst_test_init_child(test, &child);
child.port->pdt = DP_PEER_DEVICE_SST_SINK;
dm_mst_test_dpcd[0] = 0x13;
KUNIT_EXPECT_EQ(test, dm_dp_mst_detect(&child.aconnector->base, NULL, false),
(int)connector_status_disconnected);
KUNIT_EXPECT_EQ(test, (int)child.port->dpcd_rev, 0x13);
dm_mst_test_fini_child(&child);
}
static void dm_mst_test_detect_unknown_dpcd_rev(struct kunit *test)
{
struct dm_mst_test_child child;
dm_mst_test_init_child(test, &child);
child.port->pdt = DP_PEER_DEVICE_SST_SINK;
KUNIT_EXPECT_EQ(test, dm_dp_mst_detect(&child.aconnector->base, NULL, false),
(int)connector_status_disconnected);
KUNIT_EXPECT_EQ(test, (int)child.port->dpcd_rev, 0);
dm_mst_test_fini_child(&child);
}
static void dm_mst_test_detect_dpcd_read_error(struct kunit *test)
{
struct dm_mst_test_child child;
dm_mst_test_init_child(test, &child);
child.port->pdt = DP_PEER_DEVICE_SST_SINK;
dm_mst_test_aux_transfer_override = -EIO;
KUNIT_EXPECT_EQ(test, dm_dp_mst_detect(&child.aconnector->base, NULL, false),
(int)connector_status_disconnected);
KUNIT_EXPECT_EQ(test, (int)child.port->dpcd_rev, 0);
dm_mst_test_fini_child(&child);
}
static void dm_mst_test_detect_disconnect_releases_sink(struct kunit *test)
{
struct dm_mst_test_child child;
struct dc_sink *sink;
dm_mst_test_init_child(test, &child);
child.port->pdt = DP_PEER_DEVICE_NONE;
child.port->dpcd_rev = 0x14;
sink = dm_mst_test_alloc_sink(test);
child.aconnector->dc_sink = sink;
child.aconnector->dsc_aux = &child.port->aux;
child.aconnector->mst_local_bw = 1234;
child.link->sink_count = 1;
KUNIT_EXPECT_EQ(test, dm_dp_mst_detect(&child.aconnector->base, NULL, false),
(int)connector_status_disconnected);
KUNIT_EXPECT_EQ(test, (int)child.port->dpcd_rev, 0);
KUNIT_EXPECT_EQ(test, dm_mst_test_remove_remote_sink_calls, 1U);
KUNIT_EXPECT_PTR_EQ(test, dm_mst_test_removed_sink, sink);
KUNIT_EXPECT_NULL(test, child.aconnector->dc_sink);
KUNIT_EXPECT_NULL(test, child.aconnector->dsc_aux);
KUNIT_EXPECT_EQ(test, child.aconnector->mst_local_bw, 0U);
dm_mst_test_fini_child(&child);
}
static void dm_mst_test_connector_late_register(struct kunit *test)
{
struct dm_mst_test_child child;
dm_mst_test_init_child(test, &child);
KUNIT_EXPECT_EQ(test, amdgpu_dm_mst_connector_late_register(&child.aconnector->base), 0);
dm_mst_test_fini_child(&child);
}
static void dm_mst_test_connector_early_unregister_no_sink(struct kunit *test)
{
struct dm_mst_test_child child;
dm_mst_test_init_child(test, &child);
child.aconnector->mst_status = MST_REMOTE_EDID;
amdgpu_dm_mst_connector_early_unregister(&child.aconnector->base);
KUNIT_EXPECT_EQ(test, dm_mst_test_remove_remote_sink_calls, 0U);
KUNIT_EXPECT_EQ(test, (int)child.aconnector->mst_status, (int)MST_STATUS_DEFAULT);
dm_mst_test_fini_child(&child);
}
static void dm_mst_test_connector_early_unregister_releases_sink(struct kunit *test)
{
struct dm_mst_test_child child;
struct dc_sink *sink;
dm_mst_test_init_child(test, &child);
sink = dm_mst_test_alloc_sink(test);
child.aconnector->dc_sink = sink;
child.aconnector->vc_full_pbn = 42;
child.link->sink_count = 1;
amdgpu_dm_mst_connector_early_unregister(&child.aconnector->base);
KUNIT_EXPECT_EQ(test, dm_mst_test_remove_remote_sink_calls, 1U);
KUNIT_EXPECT_PTR_EQ(test, dm_mst_test_removed_sink, sink);
KUNIT_EXPECT_NULL(test, child.aconnector->dc_sink);
KUNIT_EXPECT_EQ(test, child.aconnector->vc_full_pbn, 0U);
KUNIT_EXPECT_EQ(test, (int)child.aconnector->mst_status, (int)MST_STATUS_DEFAULT);
dm_mst_test_fini_child(&child);
}
static struct amdgpu_dm_connector *
dm_mst_test_alloc_destroyable_connector(struct kunit *test, struct dm_mst_test_child *child)
{
struct amdgpu_dm_connector *aconnector;
struct drm_dp_mst_branch *mstb;
struct drm_dp_mst_port *port;
int ret;
aconnector = kzalloc_obj(*aconnector);
port = kzalloc_obj(*port);
mstb = kunit_kzalloc(test, sizeof(*mstb), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, aconnector);
KUNIT_ASSERT_NOT_NULL(test, port);
KUNIT_ASSERT_NOT_NULL(test, mstb);
mstb->mgr = &child->root->mst_mgr;
kref_init(&mstb->malloc_kref);
kref_get(&mstb->malloc_kref);
port->mgr = &child->root->mst_mgr;
port->parent = mstb;
kref_init(&port->malloc_kref);
aconnector->dc_link = child->link;
aconnector->mst_root = child->root;
aconnector->mst_output_port = port;
ret = drm_connector_init(&child->adev->ddev, &aconnector->base,
&dm_mst_test_connector_funcs,
DRM_MODE_CONNECTOR_DisplayPort);
KUNIT_ASSERT_EQ(test, ret, 0);
return aconnector;
}
static void dm_mst_test_connector_destroy_no_sink(struct kunit *test)
{
struct amdgpu_dm_connector *aconnector;
struct dm_mst_test_child child;
dm_mst_test_init_child(test, &child);
aconnector = dm_mst_test_alloc_destroyable_connector(test, &child);
dm_dp_mst_connector_destroy(&aconnector->base);
KUNIT_EXPECT_EQ(test, dm_mst_test_remove_remote_sink_calls, 0U);
dm_mst_test_fini_child(&child);
}
static void dm_mst_test_connector_destroy_releases_sink(struct kunit *test)
{
struct amdgpu_dm_connector *aconnector;
struct dm_mst_test_child child;
struct dc_sink *sink;
dm_mst_test_init_child(test, &child);
aconnector = dm_mst_test_alloc_destroyable_connector(test, &child);
sink = dm_mst_test_alloc_sink(test);
aconnector->dc_sink = sink;
child.link->sink_count = 1;
dm_dp_mst_connector_destroy(&aconnector->base);
KUNIT_EXPECT_EQ(test, dm_mst_test_remove_remote_sink_calls, 1U);
KUNIT_EXPECT_PTR_EQ(test, dm_mst_test_removed_sink, sink);
dm_mst_test_fini_child(&child);
}
static struct amdgpu_dm_connector *
dm_mst_test_alloc_armed_sideband_connector(struct kunit *test)
{
struct amdgpu_dm_connector *aconnector;
struct amdgpu_device *adev;
int ret;
adev = dm_kunit_alloc_adev(test);
ret = drmm_mode_config_init(&adev->ddev);
KUNIT_ASSERT_EQ(test, ret, 0);
aconnector = dm_mst_test_alloc_sideband_connector(test);
ret = drm_dp_mst_topology_mgr_init(&aconnector->mst_mgr, &adev->ddev,
&aconnector->dm_dp_aux.aux, 16, 4, 0);
KUNIT_ASSERT_EQ(test, ret, 0);
aconnector->mst_mgr.mst_state = true;
dm_mst_test_dpcd[(DP_SINK_COUNT_ESI + 1) & 0xf] = DP_DOWN_REP_MSG_RDY;
return aconnector;
}
static void dm_mst_test_free_armed_sideband_connector(struct amdgpu_dm_connector *aconnector)
{
aconnector->mst_mgr.mst_state = false;
drm_dp_mst_topology_mgr_destroy(&aconnector->mst_mgr);
}
static void dm_mst_test_sideband_msg_ready_acks_down_rep(struct kunit *test)
{
struct amdgpu_dm_connector *aconnector;
aconnector = dm_mst_test_alloc_armed_sideband_connector(test);
dm_handle_mst_sideband_msg_ready_event(&aconnector->mst_mgr, DOWN_REP_MSG_RDY_EVENT);
KUNIT_EXPECT_EQ(test, aconnector->mst_mgr.sink_count, 0);
dm_mst_test_free_armed_sideband_connector(aconnector);
}
static void dm_mst_test_sideband_msg_ready_ack_write_fails(struct kunit *test)
{
struct amdgpu_dm_connector *aconnector;
aconnector = dm_mst_test_alloc_armed_sideband_connector(test);
dm_mst_test_aux_write_override = -EIO;
dm_handle_mst_sideband_msg_ready_event(&aconnector->mst_mgr, DOWN_REP_MSG_RDY_EVENT);
KUNIT_EXPECT_EQ(test, aconnector->mst_mgr.sink_count, 0);
dm_mst_test_free_armed_sideband_connector(aconnector);
}
#define DM_MST_TEST_DSC_DPCD_SIZE 0x600
static u8 dm_mst_test_dsc_dpcd[DM_MST_TEST_DSC_DPCD_SIZE];
static struct drm_dp_aux *dm_mst_test_dsc_aux_fail;
static ssize_t dm_mst_test_dsc_aux_transfer(struct drm_dp_aux *aux,
struct drm_dp_aux_msg *msg)
{
size_t i;
if (aux == dm_mst_test_dsc_aux_fail)
return -EIO;
if (msg->address + msg->size > DM_MST_TEST_DSC_DPCD_SIZE)
return -EINVAL;
msg->reply = DP_AUX_NATIVE_REPLY_ACK;
if ((msg->request & ~DP_AUX_I2C_MOT) == DP_AUX_NATIVE_WRITE)
return msg->size;
for (i = 0; i < msg->size; i++)
((u8 *)msg->buffer)[i] = dm_mst_test_dsc_dpcd[msg->address + i];
return msg->size;
}
static void dm_mst_test_reset_dsc_dpcd(void)
{
memset(dm_mst_test_dsc_dpcd, 0, sizeof(dm_mst_test_dsc_dpcd));
dm_mst_test_dsc_aux_fail = NULL;
}
static void dm_mst_test_init_dsc_aux(struct drm_dp_aux *aux, const char *name)
{
aux->name = name;
aux->transfer = dm_mst_test_dsc_aux_transfer;
drm_dp_aux_init(aux);
drm_dp_dpcd_set_probe(aux, false);
}
static struct drm_dp_aux *dm_mst_test_alloc_dsc_aux(struct kunit *test, const char *name)
{
struct drm_dp_aux *aux = kunit_kzalloc(test, sizeof(*aux), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, aux);
dm_mst_test_init_dsc_aux(aux, name);
return aux;
}
static void dm_mst_test_set_link_settings(u8 link_bw_set, u8 lane_count, u8 coding)
{
dm_mst_test_dsc_dpcd[DP_LINK_BW_SET] = link_bw_set;
dm_mst_test_dsc_dpcd[DP_LANE_COUNT_SET] = lane_count;
dm_mst_test_dsc_dpcd[DP_MAIN_LINK_CHANNEL_CODING_SET] = coding;
}
struct dm_mst_link_bw_param {
const char *name;
u8 link_bw_set;
u8 lane_count;
u8 coding;
bool aux_fails;
bool supported;
uint32_t cur_link_bw;
};
static const struct dm_mst_link_bw_param dm_mst_link_bw_params[] = {
{ "hbr2_8b_10b", DP_LINK_BW_5_4, 4, DP_8b_10b_ENCODING, false, true, 16761600 },
{ "uhbr10", DP_LINK_BW_10, 4, DP_128b_132b_ENCODING, false, true, 38564000 },
{ "uhbr13_5", DP_LINK_BW_13_5, 4, DP_128b_132b_ENCODING, false, true, 52061400 },
{ "uhbr20", DP_LINK_BW_20, 4, DP_128b_132b_ENCODING, false, true, 77128000 },
{ "unlisted_uhbr_rate", 0x1e, 4, DP_128b_132b_ENCODING, false, false, 0 },
{ "unknown_encoding", DP_LINK_BW_5_4, 4, DP_UNKNOWN_ENCODING, false, false, 0 },
{ "dpcd_read_error", DP_LINK_BW_5_4, 4, DP_8b_10b_ENCODING, true, false, 0 },
};
KUNIT_ARRAY_PARAM_DESC(dm_mst_link_bw, dm_mst_link_bw_params, name);
static void dm_mst_test_link_current_set_bw(struct kunit *test)
{
const struct dm_mst_link_bw_param *param = test->param_value;
uint32_t cur_link_bw = 0xdeadbeef;
struct drm_dp_aux *aux;
dm_mst_test_reset_dsc_dpcd();
aux = dm_mst_test_alloc_dsc_aux(test, "dm_mst_test_link_bw_aux");
dm_mst_test_set_link_settings(param->link_bw_set, param->lane_count, param->coding);
if (param->aux_fails)
dm_mst_test_dsc_aux_fail = aux;
KUNIT_EXPECT_EQ(test, dp_get_link_current_set_bw(aux, &cur_link_bw), param->supported);
KUNIT_EXPECT_EQ(test, cur_link_bw, param->cur_link_bw);
}
static void dm_mst_test_set_panamera_ids(struct dc_link *link, u32 branch_dev_id,
u8 dev_name_4, u8 cascaded_id)
{
link->dpcd_caps.branch_dev_id = branch_dev_id;
link->dpcd_caps.branch_dev_name[4] = dev_name_4;
dm_mst_test_dsc_dpcd[DP_BRANCH_VENDOR_SPECIFIC_START + 2] = cascaded_id;
}
static struct drm_dp_mst_port *dm_mst_test_alloc_mgr_port(struct kunit *test)
{
struct drm_dp_mst_topology_mgr *mgr;
struct drm_dp_mst_port *port;
mgr = kunit_kzalloc(test, sizeof(*mgr), GFP_KERNEL);
port = kunit_kzalloc(test, sizeof(*port), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, mgr);
KUNIT_ASSERT_NOT_NULL(test, port);
mutex_init(&mgr->lock);
mgr->aux = dm_mst_test_alloc_dsc_aux(test, "dm_mst_test_mgr_aux");
port->mgr = mgr;
return port;
}
struct dm_mst_panamera_param {
const char *name;
u32 branch_dev_id;
u8 dev_name_4;
u8 cascaded_id;
bool aux_fails;
bool cascaded;
};
static const struct dm_mst_panamera_param dm_mst_panamera_params[] = {
{ "cascaded_hub", DP_BRANCH_DEVICE_ID_90CC24, 0x50,
SYNAPTICS_CASCADED_HUB_ID, false, true },
{ "wrong_dev_id", 0x001122, 0x50, SYNAPTICS_CASCADED_HUB_ID, false, false },
{ "not_panamera", DP_BRANCH_DEVICE_ID_90CC24, 0x40,
SYNAPTICS_CASCADED_HUB_ID, false, false },
{ "not_cascaded", DP_BRANCH_DEVICE_ID_90CC24, 0x50, 0, false, false },
{ "dpcd_read_error", DP_BRANCH_DEVICE_ID_90CC24, 0x50,
SYNAPTICS_CASCADED_HUB_ID, true, false },
};
KUNIT_ARRAY_PARAM_DESC(dm_mst_panamera, dm_mst_panamera_params, name);
static void dm_mst_test_synaptics_cascaded(struct kunit *test)
{
const struct dm_mst_panamera_param *param = test->param_value;
struct drm_dp_mst_port *port;
struct dc_link *link;
dm_mst_test_reset_dsc_dpcd();
port = dm_mst_test_alloc_mgr_port(test);
link = dm_kunit_alloc_link(test);
dm_mst_test_set_panamera_ids(link, param->branch_dev_id, param->dev_name_4,
param->cascaded_id);
if (param->aux_fails)
dm_mst_test_dsc_aux_fail = port->mgr->aux;
KUNIT_EXPECT_EQ(test, is_synaptics_cascaded_panamera(link, port), param->cascaded);
}
struct dm_mst_test_dsc_ctx {
struct amdgpu_dm_connector *aconnector;
struct amdgpu_dm_connector *root;
struct drm_dp_mst_port *port;
struct dc_sink *sink;
struct dc_link *link;
};
static void dm_mst_test_init_dsc_ctx(struct kunit *test, struct dm_mst_test_dsc_ctx *ctx)
{
struct drm_dp_mst_branch *branch;
struct dc *dc;
dm_mst_test_reset_dsc_dpcd();
ctx->aconnector = kunit_kzalloc(test, sizeof(*ctx->aconnector), GFP_KERNEL);
ctx->root = kunit_kzalloc(test, sizeof(*ctx->root), GFP_KERNEL);
ctx->sink = kunit_kzalloc(test, sizeof(*ctx->sink), GFP_KERNEL);
branch = kunit_kzalloc(test, sizeof(*branch), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, ctx->aconnector);
KUNIT_ASSERT_NOT_NULL(test, ctx->root);
KUNIT_ASSERT_NOT_NULL(test, ctx->sink);
KUNIT_ASSERT_NOT_NULL(test, branch);
dc = dm_kunit_alloc_dc_with_ctx(test);
ctx->link = dm_kunit_alloc_link(test);
ctx->link->ctx = dc->ctx;
ctx->port = dm_mst_test_alloc_mgr_port(test);
ctx->port->parent = branch;
dm_mst_test_init_dsc_aux(&ctx->port->aux, "dm_mst_test_port_dsc_aux");
dm_mst_test_init_dsc_aux(&ctx->root->dm_dp_aux.aux, "dm_mst_test_root_dsc_aux");
ctx->aconnector->dc_link = ctx->link;
ctx->aconnector->dc_sink = ctx->sink;
ctx->aconnector->mst_output_port = ctx->port;
ctx->aconnector->mst_root = ctx->root;
}
static void dm_mst_test_arm_dsc_aux_workaround(struct dc_link *link)
{
link->dpcd_caps.branch_dev_id = DP_BRANCH_DEVICE_ID_90CC24;
link->dpcd_caps.dpcd_rev.raw = DPCD_REV_14;
link->dpcd_caps.sink_count.bits.SINK_COUNT = 2;
}
static void dm_mst_test_validate_dsc_caps_no_aux(struct kunit *test)
{
struct dm_mst_test_dsc_ctx ctx;
dm_mst_test_init_dsc_ctx(test, &ctx);
KUNIT_EXPECT_FALSE(test, validate_dsc_caps_on_connector(ctx.aconnector));
KUNIT_EXPECT_NULL(test, ctx.aconnector->dsc_aux);
}
static void dm_mst_test_validate_dsc_caps_aux_workaround(struct kunit *test)
{
struct dm_mst_test_dsc_ctx ctx;
dm_mst_test_init_dsc_ctx(test, &ctx);
dm_mst_test_arm_dsc_aux_workaround(ctx.link);
dm_mst_test_dsc_dpcd[DP_DSC_SUPPORT] = DP_DSC_DECOMPRESSION_IS_SUPPORTED;
KUNIT_EXPECT_TRUE(test, validate_dsc_caps_on_connector(ctx.aconnector));
KUNIT_EXPECT_PTR_EQ(test, ctx.aconnector->dsc_aux, &ctx.root->dm_dp_aux.aux);
KUNIT_EXPECT_TRUE(test, ctx.sink->dsc_caps.dsc_dec_caps.is_dsc_supported);
}
static void dm_mst_test_validate_dsc_caps_cascaded_hub(struct kunit *test)
{
struct dm_mst_test_dsc_ctx ctx;
dm_mst_test_init_dsc_ctx(test, &ctx);
dm_mst_test_arm_dsc_aux_workaround(ctx.link);
dm_mst_test_set_panamera_ids(ctx.link, DP_BRANCH_DEVICE_ID_90CC24, 0x50,
SYNAPTICS_CASCADED_HUB_ID);
dm_mst_test_dsc_dpcd[DP_DSC_SUPPORT] = DP_DSC_DECOMPRESSION_IS_SUPPORTED;
KUNIT_EXPECT_TRUE(test, validate_dsc_caps_on_connector(ctx.aconnector));
KUNIT_EXPECT_PTR_EQ(test, ctx.aconnector->dsc_aux, ctx.port->mgr->aux);
}
static void dm_mst_test_validate_dsc_caps_read_error(struct kunit *test)
{
struct dm_mst_test_dsc_ctx ctx;
dm_mst_test_init_dsc_ctx(test, &ctx);
dm_mst_test_arm_dsc_aux_workaround(ctx.link);
dm_mst_test_dsc_aux_fail = &ctx.root->dm_dp_aux.aux;
KUNIT_EXPECT_FALSE(test, validate_dsc_caps_on_connector(ctx.aconnector));
KUNIT_EXPECT_PTR_EQ(test, ctx.aconnector->dsc_aux, &ctx.root->dm_dp_aux.aux);
}
static void dm_mst_test_validate_dsc_caps_unsupported(struct kunit *test)
{
struct dm_mst_test_dsc_ctx ctx;
dm_mst_test_init_dsc_ctx(test, &ctx);
dm_mst_test_arm_dsc_aux_workaround(ctx.link);
KUNIT_EXPECT_FALSE(test, validate_dsc_caps_on_connector(ctx.aconnector));
KUNIT_EXPECT_FALSE(test, ctx.sink->dsc_caps.dsc_dec_caps.is_dsc_supported);
}
static uint32_t dm_mst_test_root_link_bw_kbps;
static uint32_t dm_mst_test_root_bandwidth_kbps(const struct dc_link *link,
const struct dc_link_settings *link_settings)
{
return dm_mst_test_root_link_bw_kbps;
}
struct dm_mst_test_port_mode_ctx {
struct amdgpu_dm_connector *aconnector;
struct dc_stream_state *stream;
struct drm_dp_mst_port *port;
struct dc_sink *sink;
struct dc_link *link;
struct dc *dc;
};
static void dm_mst_test_init_port_mode_ctx(struct kunit *test,
struct dm_mst_test_port_mode_ctx *ctx,
uint32_t root_link_bw_kbps, u32 full_pbn,
uint32_t pix_clk_100hz)
{
struct link_service *link_srv;
struct resource_pool *res_pool;
dm_mst_test_reset_dsc_dpcd();
ctx->aconnector = kunit_kzalloc(test, sizeof(*ctx->aconnector), GFP_KERNEL);
ctx->sink = kunit_kzalloc(test, sizeof(*ctx->sink), GFP_KERNEL);
link_srv = kunit_kzalloc(test, sizeof(*link_srv), GFP_KERNEL);
res_pool = kunit_kzalloc(test, sizeof(*res_pool), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, ctx->aconnector);
KUNIT_ASSERT_NOT_NULL(test, ctx->sink);
KUNIT_ASSERT_NOT_NULL(test, link_srv);
KUNIT_ASSERT_NOT_NULL(test, res_pool);
dm_mst_test_root_link_bw_kbps = root_link_bw_kbps;
link_srv->dp_link_bandwidth_kbps = dm_mst_test_root_bandwidth_kbps;
ctx->dc = dm_kunit_alloc_dc_with_ctx(test);
ctx->dc->link_srv = link_srv;
ctx->dc->res_pool = res_pool;
ctx->link = dm_kunit_alloc_link(test);
ctx->link->dc = ctx->dc;
ctx->link->ctx = ctx->dc->ctx;
ctx->sink->ctx = ctx->dc->ctx;
ctx->port = dm_mst_test_alloc_mgr_port(test);
ctx->port->full_pbn = full_pbn;
ctx->stream = dm_kunit_alloc_stream(test, ctx->link);
ctx->stream->sink = ctx->sink;
ctx->stream->timing.display_color_depth = COLOR_DEPTH_888;
ctx->stream->timing.pix_clk_100hz = pix_clk_100hz;
ctx->aconnector->dc_link = ctx->link;
ctx->aconnector->dc_sink = ctx->sink;
ctx->aconnector->mst_output_port = ctx->port;
}
static void dm_mst_test_port_mode_fits_without_dsc(struct kunit *test)
{
struct dm_mst_test_port_mode_ctx ctx;
dm_mst_test_init_port_mode_ctx(test, &ctx, 1000000, 1000, 100000);
KUNIT_EXPECT_EQ(test, dm_dp_mst_is_port_support_mode(ctx.aconnector, ctx.stream), DC_OK);
KUNIT_EXPECT_EQ(test, (u32)ctx.stream->timing.flags.DSC, 0U);
}
static void dm_mst_test_port_mode_no_dsc_aux(struct kunit *test)
{
struct dm_mst_test_port_mode_ctx ctx;
dm_mst_test_init_port_mode_ctx(test, &ctx, 100000, 10, 100000);
KUNIT_EXPECT_EQ(test, dm_dp_mst_is_port_support_mode(ctx.aconnector, ctx.stream),
DC_FAIL_BANDWIDTH_VALIDATE);
}
static void dm_mst_test_port_mode_no_common_dsc_config(struct kunit *test)
{
struct dm_mst_test_port_mode_ctx ctx;
dm_mst_test_init_port_mode_ctx(test, &ctx, 100000, 10, 100000);
ctx.aconnector->dsc_aux = ctx.port->mgr->aux;
KUNIT_EXPECT_EQ(test, dm_dp_mst_is_port_support_mode(ctx.aconnector, ctx.stream),
DC_FAIL_BANDWIDTH_VALIDATE);
}
#define DM_MST_TEST_DSC_PIX_CLK_100HZ 1485000
static void dm_mst_test_dsc_get_enc_caps(struct dsc_enc_caps *dsc_enc_caps, int pixel_clock_100Hz)
{
dsc_enc_caps->dsc_version = 0x21;
dsc_enc_caps->slice_caps.bits.NUM_SLICES_1 = 1;
dsc_enc_caps->slice_caps.bits.NUM_SLICES_2 = 1;
dsc_enc_caps->slice_caps.bits.NUM_SLICES_4 = 1;
dsc_enc_caps->lb_bit_depth = 13;
dsc_enc_caps->is_block_pred_supported = true;
dsc_enc_caps->color_formats.bits.RGB = 1;
dsc_enc_caps->color_depth.bits.COLOR_DEPTH_8_BPC = 1;
dsc_enc_caps->max_total_throughput_mps = 4800;
dsc_enc_caps->max_slice_width = 5184;
dsc_enc_caps->bpp_increment_div = 16;
}
static const struct dsc_funcs dm_mst_test_dsc_funcs = {
.dsc_get_enc_caps = dm_mst_test_dsc_get_enc_caps,
};
static void dm_mst_test_setup_dsc_caps(struct kunit *test, struct dc *dc, struct dc_sink *sink)
{
struct dsc_dec_dpcd_caps *dec = &sink->dsc_caps.dsc_dec_caps;
struct display_stream_compressor *dsc;
dsc = kunit_kzalloc(test, sizeof(*dsc), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, dsc);
dsc->funcs = &dm_mst_test_dsc_funcs;
dsc->ctx = dc->ctx;
dc->res_pool->dscs[0] = dsc;
dec->is_dsc_supported = true;
dec->dsc_version = 0x21;
dec->rc_buffer_size = 16 * 1024;
dec->slice_caps1.bits.NUM_SLICES_1 = 1;
dec->slice_caps1.bits.NUM_SLICES_2 = 1;
dec->slice_caps1.bits.NUM_SLICES_4 = 1;
dec->lb_bit_depth = 13;
dec->is_block_pred_supported = true;
dec->color_formats.bits.RGB = 1;
dec->color_depth.bits.COLOR_DEPTH_8_BPC = 1;
dec->throughput_mode_0_mps = 1000;
dec->throughput_mode_1_mps = 1000;
dec->max_slice_width = 5120;
dec->bpp_increment_div = 16;
}
static void dm_mst_test_set_dsc_timing(struct dc_crtc_timing *timing)
{
timing->display_color_depth = COLOR_DEPTH_888;
timing->pixel_encoding = PIXEL_ENCODING_RGB;
timing->h_addressable = 1920;
timing->v_addressable = 1080;
timing->pix_clk_100hz = DM_MST_TEST_DSC_PIX_CLK_100HZ;
}
static void dm_mst_test_enable_dsc(struct kunit *test, struct dm_mst_test_port_mode_ctx *ctx)
{
struct drm_dp_mst_branch *branch;
branch = kunit_kzalloc(test, sizeof(*branch), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, branch);
dm_mst_test_setup_dsc_caps(test, ctx->dc, ctx->sink);
dm_mst_test_set_dsc_timing(&ctx->stream->timing);
ctx->port->parent = branch;
dm_mst_test_init_dsc_aux(&ctx->port->aux, "dm_mst_test_port_mode_aux");
ctx->aconnector->dsc_aux = ctx->port->mgr->aux;
}
static void dm_mst_test_port_mode_dsc_passthrough_fits(struct kunit *test)
{
struct dm_mst_test_port_mode_ctx ctx;
dm_mst_test_init_port_mode_ctx(test, &ctx, 2500000, 1000, 100000);
dm_mst_test_enable_dsc(test, &ctx);
ctx.port->passthrough_aux = ctx.port->mgr->aux;
KUNIT_EXPECT_EQ(test, dm_dp_mst_is_port_support_mode(ctx.aconnector, ctx.stream), DC_OK);
KUNIT_EXPECT_EQ(test, (u32)ctx.stream->timing.flags.DSC, 1U);
}
static void dm_mst_test_port_mode_dsc_passthrough_too_narrow(struct kunit *test)
{
struct dm_mst_test_port_mode_ctx ctx;
dm_mst_test_init_port_mode_ctx(test, &ctx, 1000000, 1000, 100000);
dm_mst_test_enable_dsc(test, &ctx);
ctx.port->passthrough_aux = ctx.port->mgr->aux;
KUNIT_EXPECT_EQ(test, dm_dp_mst_is_port_support_mode(ctx.aconnector, ctx.stream),
DC_FAIL_BANDWIDTH_VALIDATE);
KUNIT_EXPECT_EQ(test, (u32)ctx.stream->timing.flags.DSC, 0U);
}
static void dm_mst_test_port_mode_last_link_too_slow(struct kunit *test)
{
struct dm_mst_test_port_mode_ctx ctx;
dm_mst_test_init_port_mode_ctx(test, &ctx, 2500000, 1000, 100000);
dm_mst_test_enable_dsc(test, &ctx);
ctx.port->pdt = DP_PEER_DEVICE_SST_SINK;
dm_mst_test_set_link_settings(DP_LINK_BW_1_62, 1, DP_8b_10b_ENCODING);
KUNIT_EXPECT_EQ(test, dm_dp_mst_is_port_support_mode(ctx.aconnector, ctx.stream),
DC_FAIL_BANDWIDTH_VALIDATE);
KUNIT_EXPECT_EQ(test, ctx.aconnector->mst_local_bw, 1257120U);
KUNIT_EXPECT_EQ(test, ctx.aconnector->vc_full_pbn, ctx.port->full_pbn);
}
static void dm_mst_test_port_mode_last_link_cached_bw(struct kunit *test)
{
struct dm_mst_test_port_mode_ctx ctx;
dm_mst_test_init_port_mode_ctx(test, &ctx, 2500000, 1000, 100000);
dm_mst_test_enable_dsc(test, &ctx);
ctx.port->pdt = DP_PEER_DEVICE_SST_SINK;
ctx.aconnector->vc_full_pbn = ctx.port->full_pbn;
ctx.aconnector->mst_local_bw = 100000;
KUNIT_EXPECT_EQ(test, dm_dp_mst_is_port_support_mode(ctx.aconnector, ctx.stream),
DC_FAIL_BANDWIDTH_VALIDATE);
KUNIT_EXPECT_EQ(test, ctx.aconnector->mst_local_bw, 100000U);
}
static void dm_mst_test_port_mode_last_link_synaptics_quirk(struct kunit *test)
{
struct dm_mst_test_port_mode_ctx ctx;
dm_mst_test_init_port_mode_ctx(test, &ctx, 2500000, 1000, 100000);
dm_mst_test_enable_dsc(test, &ctx);
ctx.port->pdt = DP_PEER_DEVICE_SST_SINK;
ctx.aconnector->branch_ieee_oui = DP_BRANCH_DEVICE_ID_90CC24;
dm_mst_test_set_link_settings(DP_LINK_BW_1_62, 1, DP_8b_10b_ENCODING);
KUNIT_EXPECT_EQ(test, dm_dp_mst_is_port_support_mode(ctx.aconnector, ctx.stream), DC_OK);
KUNIT_EXPECT_EQ(test, (u32)ctx.stream->timing.flags.DSC, 1U);
}
static void dm_mst_test_port_mode_upstream_vc_too_small(struct kunit *test)
{
struct dm_mst_test_port_mode_ctx ctx;
struct drm_dp_mst_port *upstream;
dm_mst_test_init_port_mode_ctx(test, &ctx, 2500000, 1000, 100000);
dm_mst_test_enable_dsc(test, &ctx);
ctx.port->pdt = DP_PEER_DEVICE_NONE;
upstream = kunit_kzalloc(test, sizeof(*upstream), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, upstream);
upstream->full_pbn = 100;
ctx.port->parent->port_parent = upstream;
KUNIT_EXPECT_EQ(test, dm_dp_mst_is_port_support_mode(ctx.aconnector, ctx.stream),
DC_FAIL_BANDWIDTH_VALIDATE);
}
static void dm_mst_test_port_mode_branch_throughput_exceeded(struct kunit *test)
{
struct dm_mst_test_port_mode_ctx ctx;
dm_mst_test_init_port_mode_ctx(test, &ctx, 2500000, 1000, 100000);
dm_mst_test_enable_dsc(test, &ctx);
ctx.port->passthrough_aux = ctx.port->mgr->aux;
ctx.sink->dsc_caps.dsc_dec_caps.branch_overall_throughput_0_mps = 100;
KUNIT_EXPECT_EQ(test, dm_dp_mst_is_port_support_mode(ctx.aconnector, ctx.stream),
DC_FAIL_BANDWIDTH_VALIDATE);
}
static uint32_t dm_mst_test_bw_kbps_from_raw_frl(uint8_t bw)
{
return bw * 3000;
}
static struct amdgpu_dm_connector *dm_mst_test_alloc_frl_connector(struct kunit *test,
bool pcon_support,
u8 dwn_strm_port_type,
u8 max_encoded_link_bw,
u8 max_frl_rate,
u8 frl_dsc_max_frl_rate)
{
struct amdgpu_dm_connector *aconnector;
struct link_service *link_srv;
struct dc_sink *sink;
struct dc_link *link;
struct dc *dc;
aconnector = kunit_kzalloc(test, sizeof(*aconnector), GFP_KERNEL);
sink = kunit_kzalloc(test, sizeof(*sink), GFP_KERNEL);
link_srv = kunit_kzalloc(test, sizeof(*link_srv), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, aconnector);
KUNIT_ASSERT_NOT_NULL(test, sink);
KUNIT_ASSERT_NOT_NULL(test, link_srv);
link_srv->bw_kbps_from_raw_frl_link_rate_data = dm_mst_test_bw_kbps_from_raw_frl;
dc = dm_kunit_alloc_dc_with_ctx(test);
dc->link_srv = link_srv;
dc->caps.dp_hdmi21_pcon_support = pcon_support;
link = dm_kunit_alloc_link(test);
link->dc = dc;
sink->edid_caps.max_frl_rate = max_frl_rate;
sink->edid_caps.frl_dsc_max_frl_rate = frl_dsc_max_frl_rate;
aconnector->dc_link = link;
aconnector->dc_sink = sink;
aconnector->mst_downstream_port_caps.bytes.byte0.bits.DWN_STRM_PORTX_TYPE =
dwn_strm_port_type;
aconnector->mst_downstream_port_caps.bytes.byte2.bits.MAX_ENCODED_LINK_BW_SUPPORT =
max_encoded_link_bw;
return aconnector;
}
static void dm_mst_test_conv_frl_bw_no_pcon_support(struct kunit *test)
{
struct amdgpu_dm_connector *aconnector;
uint32_t bw_in_kbps = 0;
uint32_t dsc_bw_in_kbps = 0;
aconnector = dm_mst_test_alloc_frl_connector(test, false, DOWN_STREAM_DETAILED_HDMI,
3, 5, 2);
KUNIT_EXPECT_FALSE(test, get_conv_frl_bw(aconnector, &bw_in_kbps, &dsc_bw_in_kbps));
KUNIT_EXPECT_EQ(test, bw_in_kbps, 0U);
KUNIT_EXPECT_EQ(test, dsc_bw_in_kbps, 0U);
}
static void dm_mst_test_conv_frl_bw_not_hdmi_port(struct kunit *test)
{
struct amdgpu_dm_connector *aconnector;
uint32_t bw_in_kbps = 0;
uint32_t dsc_bw_in_kbps = 0;
aconnector = dm_mst_test_alloc_frl_connector(test, true, DOWN_STREAM_DETAILED_DP, 3, 5, 2);
KUNIT_EXPECT_FALSE(test, get_conv_frl_bw(aconnector, &bw_in_kbps, &dsc_bw_in_kbps));
KUNIT_EXPECT_EQ(test, bw_in_kbps, 0U);
}
static void dm_mst_test_conv_frl_bw_sink_without_frl(struct kunit *test)
{
struct amdgpu_dm_connector *aconnector;
uint32_t bw_in_kbps = 0;
uint32_t dsc_bw_in_kbps = 0;
aconnector = dm_mst_test_alloc_frl_connector(test, true, DOWN_STREAM_DETAILED_HDMI,
3, 0, 2);
KUNIT_EXPECT_FALSE(test, get_conv_frl_bw(aconnector, &bw_in_kbps, &dsc_bw_in_kbps));
KUNIT_EXPECT_EQ(test, bw_in_kbps, 0U);
}
static void dm_mst_test_conv_frl_bw_bottleneck(struct kunit *test)
{
struct amdgpu_dm_connector *aconnector;
uint32_t bw_in_kbps = 0;
uint32_t dsc_bw_in_kbps = 0;
aconnector = dm_mst_test_alloc_frl_connector(test, true, DOWN_STREAM_DETAILED_HDMI,
3, 5, 2);
KUNIT_EXPECT_TRUE(test, get_conv_frl_bw(aconnector, &bw_in_kbps, &dsc_bw_in_kbps));
KUNIT_EXPECT_EQ(test, bw_in_kbps, 9000U);
KUNIT_EXPECT_EQ(test, dsc_bw_in_kbps, 6000U);
}
static void dm_mst_test_log_dsc_params(struct kunit *test)
{
struct dsc_mst_fairness_vars vars[3] = {
{ .pbn = 100, .dsc_enabled = false, .bpp_x16 = 160 },
{ .pbn = 200, .dsc_enabled = true, .bpp_x16 = 192 },
{ .pbn = 300, .dsc_enabled = true, .bpp_x16 = 256 },
};
log_dsc_params(2, vars, 1);
KUNIT_EXPECT_EQ(test, vars[1].pbn, 200);
KUNIT_EXPECT_EQ(test, vars[2].bpp_x16, 256);
}
struct dm_mst_test_crtc_state_ctx {
struct drm_atomic_commit *state;
struct drm_crtc *crtcs;
struct dm_crtc_state *crtc_states;
struct drm_connector *connector;
struct drm_connector_state *conn_state;
};
static void dm_mst_test_init_crtc_state_ctx(struct kunit *test,
struct dm_mst_test_crtc_state_ctx *ctx,
unsigned int num_crtc)
{
struct amdgpu_device *adev;
unsigned int i;
adev = dm_kunit_alloc_adev(test);
adev->ddev.mode_config.num_crtc = num_crtc;
ctx->state = kunit_kzalloc(test, sizeof(*ctx->state), GFP_KERNEL);
ctx->crtcs = kunit_kcalloc(test, num_crtc, sizeof(*ctx->crtcs), GFP_KERNEL);
ctx->crtc_states = kunit_kcalloc(test, num_crtc, sizeof(*ctx->crtc_states), GFP_KERNEL);
ctx->connector = kunit_kzalloc(test, sizeof(*ctx->connector), GFP_KERNEL);
ctx->conn_state = kunit_kzalloc(test, sizeof(*ctx->conn_state), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, ctx->state);
KUNIT_ASSERT_NOT_NULL(test, ctx->crtcs);
KUNIT_ASSERT_NOT_NULL(test, ctx->crtc_states);
KUNIT_ASSERT_NOT_NULL(test, ctx->connector);
KUNIT_ASSERT_NOT_NULL(test, ctx->conn_state);
ctx->state->dev = &adev->ddev;
ctx->state->crtcs = kunit_kcalloc(test, num_crtc, sizeof(*ctx->state->crtcs), GFP_KERNEL);
ctx->state->connectors = kunit_kzalloc(test, sizeof(*ctx->state->connectors), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, ctx->state->crtcs);
KUNIT_ASSERT_NOT_NULL(test, ctx->state->connectors);
for (i = 0; i < num_crtc; i++) {
ctx->crtcs[i].dev = &adev->ddev;
ctx->crtc_states[i].base.crtc = &ctx->crtcs[i];
ctx->state->crtcs[i].ptr = &ctx->crtcs[i];
ctx->state->crtcs[i].new_state = &ctx->crtc_states[i].base;
ctx->state->crtcs[i].old_state = &ctx->crtc_states[i].base;
}
}
static void dm_mst_test_attach_connector(struct dm_mst_test_crtc_state_ctx *ctx,
struct drm_crtc *crtc)
{
ctx->conn_state->crtc = crtc;
ctx->state->connectors[0].ptr = ctx->connector;
ctx->state->connectors[0].new_state = ctx->conn_state;
ctx->state->num_connector = 1;
}
static void dm_mst_test_find_crtc_index_matches(struct kunit *test)
{
struct dm_mst_test_crtc_state_ctx ctx;
struct dc_stream_state *stream;
dm_mst_test_init_crtc_state_ctx(test, &ctx, 3);
stream = dm_kunit_alloc_stream(test, NULL);
ctx.crtc_states[2].stream = stream;
KUNIT_EXPECT_EQ(test, find_crtc_index_in_state_by_stream(ctx.state, stream), 2);
}
static void dm_mst_test_find_crtc_index_no_match(struct kunit *test)
{
struct dm_mst_test_crtc_state_ctx ctx;
struct dc_stream_state *stream;
dm_mst_test_init_crtc_state_ctx(test, &ctx, 2);
stream = dm_kunit_alloc_stream(test, NULL);
KUNIT_EXPECT_EQ(test, find_crtc_index_in_state_by_stream(ctx.state, stream), -1);
}
struct dm_mst_precompute_param {
const char *name;
bool connector_attached;
bool has_stream;
enum dc_connection_type link_type;
bool dsc_support;
bool dsc_passthrough;
bool needed;
};
static const struct dm_mst_precompute_param dm_mst_precompute_params[] = {
{ "no_connector", false, true, dc_connection_mst_branch, true, false, false },
{ "dsc_hub", true, true, dc_connection_mst_branch, true, false, true },
{ "dsc_passthrough_hub", true, true, dc_connection_mst_branch, false, true, true },
{ "sst_link", true, true, dc_connection_single, true, false, false },
{ "mst_without_dsc", true, true, dc_connection_mst_branch, false, false, false },
{ "no_stream", true, false, dc_connection_mst_branch, true, false, false },
};
KUNIT_ARRAY_PARAM_DESC(dm_mst_precompute, dm_mst_precompute_params, name);
static void dm_mst_test_dsc_precompute_needed(struct kunit *test)
{
const struct dm_mst_precompute_param *param = test->param_value;
struct dm_mst_test_crtc_state_ctx ctx;
struct dc_link *link;
dm_mst_test_init_crtc_state_ctx(test, &ctx, 1);
if (param->connector_attached)
dm_mst_test_attach_connector(&ctx, &ctx.crtcs[0]);
if (param->has_stream) {
link = dm_kunit_alloc_link(test);
link->type = param->link_type;
link->dpcd_caps.dsc_caps.dsc_basic_caps.fields.dsc_support.DSC_SUPPORT =
param->dsc_support;
link->dpcd_caps.dsc_caps.dsc_basic_caps.fields.dsc_support.DSC_PASSTHROUGH_SUPPORT =
param->dsc_passthrough;
ctx.crtc_states[0].stream = dm_kunit_alloc_stream(test, link);
}
KUNIT_EXPECT_EQ(test, is_dsc_precompute_needed(ctx.state), param->needed);
}
struct dm_mst_test_recompute_ctx {
struct amdgpu_device *adev;
struct drm_atomic_commit *state;
struct amdgpu_dm_connector *aconnector;
struct drm_connector_state *conn_state;
struct drm_crtc_state *crtc_state;
struct dc_state *dc_state;
struct dc_link *link;
struct dc *dc;
};
static void dm_mst_test_init_recompute_ctx(struct kunit *test,
struct dm_mst_test_recompute_ctx *ctx)
{
struct drm_crtc *crtc;
ctx->adev = dm_kunit_alloc_adev(test);
ctx->adev->ddev.mode_config.num_crtc = 1;
ctx->dc = dm_kunit_alloc_dc_with_ctx(test);
ctx->dc->current_state = dm_kunit_alloc_dc_state(test);
ctx->dc_state = dm_kunit_alloc_dc_state(test);
ctx->link = dm_kunit_alloc_link(test);
ctx->link->dc = ctx->dc;
ctx->link->type = dc_connection_mst_branch;
ctx->aconnector = dm_kunit_alloc_connector(test, ctx->adev, ctx->link);
ctx->conn_state = kunit_kzalloc(test, sizeof(*ctx->conn_state), GFP_KERNEL);
crtc = kunit_kzalloc(test, sizeof(*crtc), GFP_KERNEL);
ctx->crtc_state = kunit_kzalloc(test, sizeof(*ctx->crtc_state), GFP_KERNEL);
ctx->state = kunit_kzalloc(test, sizeof(*ctx->state), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, ctx->conn_state);
KUNIT_ASSERT_NOT_NULL(test, crtc);
KUNIT_ASSERT_NOT_NULL(test, ctx->crtc_state);
KUNIT_ASSERT_NOT_NULL(test, ctx->state);
ctx->state->dev = &ctx->adev->ddev;
ctx->state->crtcs = kunit_kzalloc(test, sizeof(*ctx->state->crtcs), GFP_KERNEL);
ctx->state->connectors = kunit_kzalloc(test, sizeof(*ctx->state->connectors), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, ctx->state->crtcs);
KUNIT_ASSERT_NOT_NULL(test, ctx->state->connectors);
crtc->dev = &ctx->adev->ddev;
ctx->crtc_state->crtc = crtc;
ctx->state->crtcs[0].ptr = crtc;
ctx->state->crtcs[0].new_state = ctx->crtc_state;
ctx->state->crtcs[0].old_state = ctx->crtc_state;
ctx->conn_state->connector = &ctx->aconnector->base;
ctx->conn_state->crtc = crtc;
ctx->state->connectors[0].ptr = &ctx->aconnector->base;
ctx->state->connectors[0].new_state = ctx->conn_state;
ctx->state->num_connector = 1;
}
static struct dc_stream_state *dm_mst_test_add_link_stream(struct kunit *test,
struct dc_state *dc_state,
struct dc_link *link,
struct amdgpu_dm_connector *aconnector)
{
struct dc_stream_state *stream = dm_kunit_alloc_stream(test, link);
KUNIT_ASSERT_LT(test, dc_state->stream_count, MAX_PIPES);
stream->dm_stream_context = aconnector;
dc_state->streams[dc_state->stream_count++] = stream;
return stream;
}
static void dm_mst_test_recompute_not_mst_branch(struct kunit *test)
{
struct dm_mst_test_recompute_ctx ctx;
dm_mst_test_init_recompute_ctx(test, &ctx);
ctx.link->type = dc_connection_single;
KUNIT_EXPECT_FALSE(test, is_dsc_need_re_compute(ctx.state, ctx.dc_state, ctx.link));
}
static void dm_mst_test_recompute_legacy_hub_without_dsc(struct kunit *test)
{
struct dm_mst_test_recompute_ctx ctx;
dm_mst_test_init_recompute_ctx(test, &ctx);
dm_mst_test_arm_dsc_aux_workaround(ctx.link);
KUNIT_EXPECT_FALSE(test, is_dsc_need_re_compute(ctx.state, ctx.dc_state, ctx.link));
}
static void dm_mst_test_recompute_no_stream_on_link(struct kunit *test)
{
struct dm_mst_test_recompute_ctx ctx;
struct dc_link *other_link;
dm_mst_test_init_recompute_ctx(test, &ctx);
other_link = dm_kunit_alloc_link(test);
dm_mst_test_add_link_stream(test, ctx.dc_state, other_link, ctx.aconnector);
KUNIT_EXPECT_FALSE(test, is_dsc_need_re_compute(ctx.state, ctx.dc_state, ctx.link));
}
static void dm_mst_test_recompute_on_mode_change(struct kunit *test)
{
struct dm_mst_test_recompute_ctx ctx;
dm_mst_test_init_recompute_ctx(test, &ctx);
dm_mst_test_add_link_stream(test, ctx.dc_state, ctx.link, ctx.aconnector);
ctx.crtc_state->enable = true;
ctx.crtc_state->active = true;
ctx.crtc_state->mode_changed = true;
KUNIT_EXPECT_TRUE(test, is_dsc_need_re_compute(ctx.state, ctx.dc_state, ctx.link));
}
static void dm_mst_test_recompute_unchanged_stream(struct kunit *test)
{
struct dm_mst_test_recompute_ctx ctx;
dm_mst_test_init_recompute_ctx(test, &ctx);
dm_mst_test_add_link_stream(test, ctx.dc_state, ctx.link, ctx.aconnector);
dm_mst_test_add_link_stream(test, ctx.dc->current_state, ctx.link, ctx.aconnector);
ctx.crtc_state->enable = true;
ctx.crtc_state->active = true;
KUNIT_EXPECT_FALSE(test, is_dsc_need_re_compute(ctx.state, ctx.dc_state, ctx.link));
}
static void dm_mst_test_recompute_stream_removed(struct kunit *test)
{
struct dm_mst_test_recompute_ctx ctx;
struct amdgpu_dm_connector *gone;
dm_mst_test_init_recompute_ctx(test, &ctx);
gone = dm_kunit_alloc_connector(test, ctx.adev, ctx.link);
dm_mst_test_add_link_stream(test, ctx.dc_state, ctx.link, ctx.aconnector);
dm_mst_test_add_link_stream(test, ctx.dc->current_state, ctx.link, gone);
ctx.crtc_state->enable = true;
ctx.crtc_state->active = true;
KUNIT_EXPECT_TRUE(test, is_dsc_need_re_compute(ctx.state, ctx.dc_state, ctx.link));
}
static void dm_mst_test_recompute_stream_without_connector(struct kunit *test)
{
struct dm_mst_test_recompute_ctx ctx;
dm_mst_test_init_recompute_ctx(test, &ctx);
dm_mst_test_add_link_stream(test, ctx.dc_state, ctx.link, NULL);
KUNIT_EXPECT_FALSE(test, is_dsc_need_re_compute(ctx.state, ctx.dc_state, ctx.link));
}
static void dm_mst_test_recompute_connector_without_crtc(struct kunit *test)
{
struct dm_mst_test_recompute_ctx ctx;
dm_mst_test_init_recompute_ctx(test, &ctx);
dm_mst_test_add_link_stream(test, ctx.dc_state, ctx.link, ctx.aconnector);
dm_mst_test_add_link_stream(test, ctx.dc->current_state, ctx.link, ctx.aconnector);
ctx.conn_state->crtc = NULL;
KUNIT_EXPECT_FALSE(test, is_dsc_need_re_compute(ctx.state, ctx.dc_state, ctx.link));
}
typedef enum dc_status (*dm_mst_test_remove_stream_fn)(struct dc *dc, struct dc_state *new_ctx,
struct dc_stream_state *stream);
static enum dc_status dm_mst_test_remove_stream_fails(struct dc *dc, struct dc_state *new_ctx,
struct dc_stream_state *stream)
{
return DC_ERROR_UNEXPECTED;
}
static struct dc_stream_state *
dm_mst_test_add_mst_dsc_stream(struct kunit *test, struct dm_mst_test_recompute_ctx *ctx,
dm_mst_test_remove_stream_fn remove_stream)
{
struct dc_stream_state *stream;
struct resource_pool *res_pool;
struct drm_dp_mst_port *port;
struct resource_funcs *funcs;
struct dc_sink *sink;
sink = kunit_kzalloc(test, sizeof(*sink), GFP_KERNEL);
port = kunit_kzalloc(test, sizeof(*port), GFP_KERNEL);
res_pool = kunit_kzalloc(test, sizeof(*res_pool), GFP_KERNEL);
funcs = kunit_kzalloc(test, sizeof(*funcs), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, sink);
KUNIT_ASSERT_NOT_NULL(test, port);
KUNIT_ASSERT_NOT_NULL(test, res_pool);
KUNIT_ASSERT_NOT_NULL(test, funcs);
funcs->remove_stream_from_ctx = remove_stream;
res_pool->funcs = funcs;
ctx->dc->res_pool = res_pool;
sink->dsc_caps.dsc_dec_caps.is_dsc_supported = true;
ctx->aconnector->dc_sink = sink;
ctx->aconnector->mst_output_port = port;
stream = dm_mst_test_add_link_stream(test, ctx->dc_state, ctx->link, ctx->aconnector);
stream->ctx = ctx->dc->ctx;
stream->signal = SIGNAL_TYPE_DISPLAY_PORT_MST;
return stream;
}
static void dm_mst_test_compute_configs_skips_sst(struct kunit *test)
{
struct dm_mst_test_recompute_ctx ctx;
struct dsc_mst_fairness_vars vars[MAX_PIPES] = {};
struct dc_stream_state *stream;
dm_mst_test_init_recompute_ctx(test, &ctx);
stream = dm_mst_test_add_link_stream(test, ctx.dc_state, ctx.link, ctx.aconnector);
stream->ctx = ctx.dc->ctx;
stream->signal = SIGNAL_TYPE_DISPLAY_PORT;
KUNIT_EXPECT_EQ(test, compute_mst_dsc_configs_for_state(ctx.state, ctx.dc_state, vars), 0);
}
static void dm_mst_test_compute_configs_skips_incomplete(struct kunit *test)
{
struct dm_mst_test_recompute_ctx ctx;
struct dsc_mst_fairness_vars vars[MAX_PIPES] = {};
struct dc_stream_state *stream;
dm_mst_test_init_recompute_ctx(test, &ctx);
stream = dm_mst_test_add_link_stream(test, ctx.dc_state, ctx.link, ctx.aconnector);
stream->ctx = ctx.dc->ctx;
stream->signal = SIGNAL_TYPE_DISPLAY_PORT_MST;
KUNIT_EXPECT_EQ(test, compute_mst_dsc_configs_for_state(ctx.state, ctx.dc_state, vars), 0);
}
static void dm_mst_test_compute_configs_remove_stream_fails(struct kunit *test)
{
struct dm_mst_test_recompute_ctx ctx;
struct dsc_mst_fairness_vars vars[MAX_PIPES] = {};
dm_mst_test_init_recompute_ctx(test, &ctx);
dm_mst_test_add_mst_dsc_stream(test, &ctx, dm_mst_test_remove_stream_fails);
KUNIT_EXPECT_EQ(test, compute_mst_dsc_configs_for_state(ctx.state, ctx.dc_state, vars),
-EINVAL);
}
static void dm_mst_test_compute_configs_no_recompute(struct kunit *test)
{
struct dm_mst_test_recompute_ctx ctx;
struct dsc_mst_fairness_vars vars[MAX_PIPES] = {};
dm_mst_test_init_recompute_ctx(test, &ctx);
ctx.link->type = dc_connection_single;
dm_mst_test_add_mst_dsc_stream(test, &ctx, NULL);
KUNIT_EXPECT_EQ(test, compute_mst_dsc_configs_for_state(ctx.state, ctx.dc_state, vars), 0);
}
static void dm_mst_test_pre_validate_dsc_not_needed(struct kunit *test)
{
struct dm_mst_test_crtc_state_ctx ctx;
struct dsc_mst_fairness_vars vars[MAX_PIPES] = {};
struct dm_atomic_state *dm_state = NULL;
dm_mst_test_init_crtc_state_ctx(test, &ctx, 1);
KUNIT_EXPECT_EQ(test, pre_validate_dsc(ctx.state, &dm_state, vars), 0);
KUNIT_EXPECT_NULL(test, dm_state);
}
static void dm_mst_test_pre_compute_configs_skips_sst(struct kunit *test)
{
struct dm_mst_test_recompute_ctx ctx;
struct dsc_mst_fairness_vars vars[MAX_PIPES] = {};
struct dc_stream_state *stream;
dm_mst_test_init_recompute_ctx(test, &ctx);
stream = dm_mst_test_add_link_stream(test, ctx.dc_state, ctx.link, ctx.aconnector);
stream->ctx = ctx.dc->ctx;
stream->signal = SIGNAL_TYPE_DISPLAY_PORT;
KUNIT_EXPECT_EQ(test, pre_compute_mst_dsc_configs_for_state(ctx.state, ctx.dc_state, vars), 0);
}
static void dm_mst_test_pre_compute_configs_skips_incomplete(struct kunit *test)
{
struct dm_mst_test_recompute_ctx ctx;
struct dsc_mst_fairness_vars vars[MAX_PIPES] = {};
struct dc_stream_state *stream;
dm_mst_test_init_recompute_ctx(test, &ctx);
stream = dm_mst_test_add_link_stream(test, ctx.dc_state, ctx.link, ctx.aconnector);
stream->ctx = ctx.dc->ctx;
stream->signal = SIGNAL_TYPE_DISPLAY_PORT_MST;
KUNIT_EXPECT_EQ(test, pre_compute_mst_dsc_configs_for_state(ctx.state, ctx.dc_state, vars), 0);
}
static void dm_mst_test_pre_compute_configs_no_recompute(struct kunit *test)
{
struct dm_mst_test_recompute_ctx ctx;
struct dsc_mst_fairness_vars vars[MAX_PIPES] = {};
dm_mst_test_init_recompute_ctx(test, &ctx);
ctx.link->type = dc_connection_single;
dm_mst_test_add_mst_dsc_stream(test, &ctx, NULL);
KUNIT_EXPECT_EQ(test, pre_compute_mst_dsc_configs_for_state(ctx.state, ctx.dc_state, vars), 0);
}
static const struct drm_connector_funcs dm_mst_test_dsc_link_conn_funcs = {
.reset = drm_atomic_helper_connector_reset,
.atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
.atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
};
static enum dp_link_encoding dm_mst_test_mst_encoding_format(const struct dc_link *link)
{
return DP_8b_10b_ENCODING;
}
struct dm_mst_test_dsc_link_ctx {
struct drm_modeset_acquire_ctx acquire_ctx;
struct amdgpu_dm_connector *aconnector;
struct drm_dp_mst_topology_state *mst_state;
struct drm_atomic_commit *state;
struct dc_stream_state *stream;
struct drm_device *drm;
struct dc_state *dc_state;
};
static void dm_mst_test_dsc_link_drop_locks(void *data)
{
struct dm_mst_test_dsc_link_ctx *ctx = data;
ctx->drm->mode_config.acquire_ctx = NULL;
drm_modeset_drop_locks(&ctx->acquire_ctx);
drm_modeset_acquire_fini(&ctx->acquire_ctx);
}
static void dm_mst_test_destroy_mst_mgr(void *data)
{
struct drm_dp_mst_topology_mgr *mgr = data;
mgr->mst_state = false;
drm_dp_mst_topology_mgr_destroy(mgr);
}
static struct dm_mst_test_dsc_link_ctx *
dm_mst_test_alloc_dsc_link_ctx(struct kunit *test, int total_avail_slots)
{
struct dm_mst_test_dsc_link_ctx *ctx;
struct drm_connector_state *conn_state;
struct drm_crtc_state *crtc_state;
struct link_service *link_srv;
struct resource_pool *res_pool;
struct drm_dp_mst_port *port;
struct drm_plane *primary;
struct drm_crtc *crtc;
struct dc_sink *sink;
struct dc_link *link;
struct device *dev;
struct dc *dc;
ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, ctx);
dev = drm_kunit_helper_alloc_device(test);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev);
ctx->drm = __drm_kunit_helper_alloc_drm_device(test, dev,
sizeof(struct amdgpu_device),
offsetof(struct amdgpu_device, ddev),
DRIVER_MODESET | DRIVER_ATOMIC);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx->drm);
primary = drm_kunit_helper_create_primary_plane(test, ctx->drm, NULL, NULL, NULL, 0, NULL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, primary);
crtc = drm_kunit_helper_create_crtc(test, ctx->drm, primary, NULL, NULL, NULL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, crtc);
ctx->aconnector = drmm_kzalloc(ctx->drm, sizeof(*ctx->aconnector), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, ctx->aconnector);
KUNIT_ASSERT_EQ(test,
drmm_connector_init(ctx->drm, &ctx->aconnector->base,
&dm_mst_test_dsc_link_conn_funcs,
DRM_MODE_CONNECTOR_DisplayPort, NULL), 0);
drm_mode_config_reset(ctx->drm);
KUNIT_ASSERT_EQ(test,
drm_dp_mst_topology_mgr_init(&ctx->aconnector->mst_mgr, ctx->drm,
&ctx->aconnector->dm_dp_aux.aux, 16, 4,
ctx->aconnector->base.base.id), 0);
KUNIT_ASSERT_EQ(test,
kunit_add_action_or_reset(test, dm_mst_test_destroy_mst_mgr,
&ctx->aconnector->mst_mgr), 0);
drm_modeset_acquire_init(&ctx->acquire_ctx, 0);
ctx->drm->mode_config.acquire_ctx = &ctx->acquire_ctx;
KUNIT_ASSERT_EQ(test,
kunit_add_action_or_reset(test, dm_mst_test_dsc_link_drop_locks, ctx), 0);
ctx->state = drm_kunit_helper_atomic_state_alloc(test, ctx->drm, &ctx->acquire_ctx);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx->state);
crtc_state = drm_atomic_get_crtc_state(ctx->state, crtc);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, crtc_state);
crtc_state->enable = true;
crtc_state->active = true;
crtc_state->mode_changed = true;
conn_state = drm_atomic_get_connector_state(ctx->state, &ctx->aconnector->base);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, conn_state);
KUNIT_ASSERT_EQ(test, drm_atomic_set_crtc_for_connector(conn_state, crtc), 0);
ctx->mst_state = drm_atomic_get_mst_topology_state(ctx->state, &ctx->aconnector->mst_mgr);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx->mst_state);
ctx->mst_state->pbn_div.full = dfixed_const(10);
ctx->mst_state->total_avail_slots = total_avail_slots;
ctx->aconnector->mst_mgr.mst_state = true;
link_srv = kunit_kzalloc(test, sizeof(*link_srv), GFP_KERNEL);
res_pool = kunit_kzalloc(test, sizeof(*res_pool), GFP_KERNEL);
sink = kunit_kzalloc(test, sizeof(*sink), GFP_KERNEL);
port = kunit_kzalloc(test, sizeof(*port), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, link_srv);
KUNIT_ASSERT_NOT_NULL(test, res_pool);
KUNIT_ASSERT_NOT_NULL(test, sink);
KUNIT_ASSERT_NOT_NULL(test, port);
link_srv->mst_decide_link_encoding_format = dm_mst_test_mst_encoding_format;
dc = dm_kunit_alloc_dc_with_ctx(test);
dc->link_srv = link_srv;
dc->res_pool = res_pool;
dc->current_state = dm_kunit_alloc_dc_state(test);
link = dm_kunit_alloc_link(test);
link->dc = dc;
link->ctx = dc->ctx;
link->type = dc_connection_mst_branch;
sink->ctx = dc->ctx;
dm_mst_test_setup_dsc_caps(test, dc, sink);
kref_init(&port->malloc_kref);
port->mgr = &ctx->aconnector->mst_mgr;
port->connector = &ctx->aconnector->base;
port->full_pbn = 2000;
ctx->aconnector->dc_link = link;
ctx->aconnector->dc_sink = sink;
ctx->aconnector->mst_output_port = port;
ctx->dc_state = dm_kunit_alloc_dc_state(test);
ctx->stream = dm_kunit_alloc_stream(test, link);
ctx->stream->ctx = dc->ctx;
ctx->stream->sink = sink;
ctx->stream->dm_stream_context = ctx->aconnector;
ctx->stream->signal = SIGNAL_TYPE_DISPLAY_PORT_MST;
dm_mst_test_set_dsc_timing(&ctx->stream->timing);
ctx->dc_state->streams[0] = ctx->stream;
ctx->dc_state->stream_count = 1;
return ctx;
}
static void dm_mst_test_dsc_link_fits_uncompressed(struct kunit *test)
{
struct dsc_mst_fairness_vars vars[MAX_PIPES] = {};
struct dm_mst_test_dsc_link_ctx *ctx;
ctx = dm_mst_test_alloc_dsc_link_ctx(test, 64);
KUNIT_EXPECT_EQ(test, pre_compute_mst_dsc_configs_for_state(ctx->state, ctx->dc_state, vars), 0);
KUNIT_EXPECT_FALSE(test, vars[0].dsc_enabled);
KUNIT_EXPECT_EQ(test, (u32)ctx->stream->timing.flags.DSC, 0U);
KUNIT_EXPECT_PTR_EQ(test, vars[0].aconnector, ctx->aconnector);
}
static void dm_mst_test_dsc_link_enables_compression(struct kunit *test)
{
struct dsc_mst_fairness_vars vars[MAX_PIPES] = {};
struct dm_mst_test_dsc_link_ctx *ctx;
ctx = dm_mst_test_alloc_dsc_link_ctx(test, 30);
KUNIT_EXPECT_EQ(test, pre_compute_mst_dsc_configs_for_state(ctx->state, ctx->dc_state, vars), 0);
KUNIT_EXPECT_TRUE(test, vars[0].dsc_enabled);
KUNIT_EXPECT_GT(test, vars[0].bpp_x16, 0);
KUNIT_EXPECT_EQ(test, (u32)ctx->stream->timing.flags.DSC, 1U);
}
static void dm_mst_test_dsc_link_out_of_slots(struct kunit *test)
{
struct dsc_mst_fairness_vars vars[MAX_PIPES] = {};
struct dm_mst_test_dsc_link_ctx *ctx;
ctx = dm_mst_test_alloc_dsc_link_ctx(test, 10);
KUNIT_EXPECT_EQ(test, pre_compute_mst_dsc_configs_for_state(ctx->state, ctx->dc_state, vars), -ENOSPC);
}
static void dm_mst_test_dsc_link_forced_dsc(struct kunit *test)
{
struct dsc_mst_fairness_vars vars[MAX_PIPES] = {};
struct dm_mst_test_dsc_link_ctx *ctx;
ctx = dm_mst_test_alloc_dsc_link_ctx(test, 64);
ctx->aconnector->dsc_settings.dsc_force_enable = DSC_CLK_FORCE_ENABLE;
KUNIT_EXPECT_EQ(test, pre_compute_mst_dsc_configs_for_state(ctx->state, ctx->dc_state, vars), 0);
KUNIT_EXPECT_FALSE(test, vars[0].dsc_enabled);
KUNIT_EXPECT_EQ(test, (u32)ctx->stream->timing.flags.DSC, 0U);
}
static void dm_mst_test_dsc_link_forced_dsc_stays_on(struct kunit *test)
{
struct dsc_mst_fairness_vars vars[MAX_PIPES] = {};
struct dm_mst_test_dsc_link_ctx *ctx;
ctx = dm_mst_test_alloc_dsc_link_ctx(test, 30);
ctx->aconnector->dsc_settings.dsc_force_enable = DSC_CLK_FORCE_ENABLE;
KUNIT_EXPECT_EQ(test, pre_compute_mst_dsc_configs_for_state(ctx->state, ctx->dc_state, vars), 0);
KUNIT_EXPECT_TRUE(test, vars[0].dsc_enabled);
}
static void dm_mst_test_dsc_link_bpp_overwrite(struct kunit *test)
{
struct dsc_mst_fairness_vars vars[MAX_PIPES] = {};
struct dm_mst_test_dsc_link_ctx *ctx;
ctx = dm_mst_test_alloc_dsc_link_ctx(test, 30);
ctx->aconnector->dsc_settings.dsc_bits_per_pixel = 10 * 16;
ctx->aconnector->dsc_settings.dsc_num_slices_h = 2;
ctx->aconnector->dsc_settings.dsc_num_slices_v = 4;
KUNIT_EXPECT_EQ(test, pre_compute_mst_dsc_configs_for_state(ctx->state, ctx->dc_state, vars), 0);
KUNIT_EXPECT_EQ(test, ctx->stream->timing.dsc_cfg.bits_per_pixel, 10 * 16);
KUNIT_EXPECT_EQ(test, (u32)ctx->stream->timing.dsc_cfg.num_slices_h, 2U);
KUNIT_EXPECT_EQ(test, (u32)ctx->stream->timing.dsc_cfg.num_slices_v, 4U);
}
static void dm_mst_test_dsc_link_compression_disabled(struct kunit *test)
{
struct dsc_mst_fairness_vars vars[MAX_PIPES] = {};
struct dm_mst_test_dsc_link_ctx *ctx;
ctx = dm_mst_test_alloc_dsc_link_ctx(test, 30);
ctx->aconnector->dsc_settings.dsc_force_enable = DSC_CLK_FORCE_DISABLE;
KUNIT_EXPECT_EQ(test, pre_compute_mst_dsc_configs_for_state(ctx->state, ctx->dc_state, vars), -ENOSPC);
}
static void dm_mst_test_dsc_link_bpp_between_limits(struct kunit *test)
{
struct dsc_mst_fairness_vars vars[MAX_PIPES] = {};
struct dm_mst_test_dsc_link_ctx *ctx;
ctx = dm_mst_test_alloc_dsc_link_ctx(test, 63);
ctx->mst_state->pbn_div.full = dfixed_const(4);
KUNIT_EXPECT_EQ(test, pre_compute_mst_dsc_configs_for_state(ctx->state, ctx->dc_state, vars), 0);
KUNIT_EXPECT_TRUE(test, vars[0].dsc_enabled);
KUNIT_EXPECT_GT(test, vars[0].bpp_x16, 8 * 16);
KUNIT_EXPECT_LT(test, vars[0].bpp_x16, 16 * 16);
}
static struct kunit_case dm_mst_types_test_cases[] = {
KUNIT_CASE(dm_mst_test_needs_dsc_aux_workaround_match),
KUNIT_CASE(dm_mst_test_needs_dsc_aux_workaround_rev12),
KUNIT_CASE(dm_mst_test_needs_dsc_aux_workaround_wrong_dev_id),
KUNIT_CASE(dm_mst_test_needs_dsc_aux_workaround_wrong_rev),
KUNIT_CASE(dm_mst_test_needs_dsc_aux_workaround_low_sink_count),
KUNIT_CASE(dm_mst_test_needs_dsc_aux_workaround_zero_sink_count),
KUNIT_CASE(dm_mst_test_pbn_divider_null_link),
KUNIT_CASE(dm_mst_test_pbn_divider_uses_link_bandwidth),
KUNIT_CASE(dm_mst_test_reset_connector_setting),
KUNIT_CASE(dm_mst_test_retrieve_downstream_no_aux),
KUNIT_CASE(dm_mst_test_retrieve_downstream_present),
KUNIT_CASE(dm_mst_test_retrieve_downstream_aux_error),
KUNIT_CASE(dm_mst_test_retrieve_branch_no_parent),
KUNIT_CASE(dm_mst_test_retrieve_branch_reads_oui),
KUNIT_CASE(dm_mst_test_aux_result_success),
KUNIT_CASE(dm_mst_test_aux_result_eio),
KUNIT_CASE(dm_mst_test_aux_result_ebusy),
KUNIT_CASE(dm_mst_test_aux_result_timeout),
KUNIT_CASE(dm_mst_test_aux_transfer_native_read),
KUNIT_CASE(dm_mst_test_aux_transfer_native_write),
KUNIT_CASE(dm_mst_test_aux_transfer_partial_write),
KUNIT_CASE(dm_mst_test_aux_transfer_error_result),
KUNIT_CASE(dm_mst_test_aux_transfer_hpd_discon_quirk),
KUNIT_CASE(dm_mst_test_aux_transfer_non_ack_reply),
KUNIT_CASE(dm_mst_test_aux_transfer_oversized),
KUNIT_CASE(dm_mst_test_fill_payload_flags_native_write),
KUNIT_CASE(dm_mst_test_fill_payload_flags_native_read),
KUNIT_CASE(dm_mst_test_fill_payload_flags_i2c_read_mot),
KUNIT_CASE(dm_mst_test_fill_payload_flags_write_status),
KUNIT_CASE(dm_mst_test_msg_ready_mask),
KUNIT_CASE(dm_mst_test_select_esi_dpcd_legacy),
KUNIT_CASE(dm_mst_test_select_esi_dpcd_esi),
KUNIT_CASE(dm_mst_test_sideband_msg_ready_no_ready_bits),
KUNIT_CASE(dm_mst_test_sideband_msg_ready_read_error),
KUNIT_CASE(dm_mst_test_sideband_msg_ready_without_mst_state),
KUNIT_CASE(dm_mst_test_sideband_msg_ready_acks_down_rep),
KUNIT_CASE(dm_mst_test_sideband_msg_ready_ack_write_fails),
KUNIT_CASE(dm_mst_test_down_rep_msg_ready_wrapper),
KUNIT_CASE(dm_mst_test_initialize_dp_connector_edp),
KUNIT_CASE(dm_mst_test_initialize_dp_connector_mst),
KUNIT_CASE(dm_mst_test_atomic_best_encoder),
KUNIT_CASE(dm_mst_test_create_fake_mst_encoders),
KUNIT_CASE(dm_mst_test_add_mst_connector_creates),
KUNIT_CASE(dm_mst_test_add_mst_connector_inherits_props),
KUNIT_CASE(dm_mst_test_add_mst_connector_init_fails),
KUNIT_CASE(dm_mst_test_atomic_check_no_old_crtc),
KUNIT_CASE(dm_mst_test_detect_unregistered),
KUNIT_CASE(dm_mst_test_detect_reads_port_dpcd_rev),
KUNIT_CASE(dm_mst_test_detect_unknown_dpcd_rev),
KUNIT_CASE(dm_mst_test_detect_dpcd_read_error),
KUNIT_CASE(dm_mst_test_detect_disconnect_releases_sink),
KUNIT_CASE(dm_mst_test_get_modes_no_edid_adds_default_sink),
KUNIT_CASE(dm_mst_test_get_modes_no_edid_sink_alloc_fails),
KUNIT_CASE(dm_mst_test_get_modes_no_edid_keeps_existing_sink),
KUNIT_CASE(dm_mst_test_get_modes_cached_edid_replaces_virtual_sink),
KUNIT_CASE(dm_mst_test_get_modes_cached_edid_sink_alloc_fails),
KUNIT_CASE(dm_mst_test_get_modes_restores_hdcp_properties),
KUNIT_CASE(dm_mst_test_get_modes_reads_remote_edid),
KUNIT_CASE(dm_mst_test_connector_late_register),
KUNIT_CASE(dm_mst_test_connector_early_unregister_no_sink),
KUNIT_CASE(dm_mst_test_connector_early_unregister_releases_sink),
KUNIT_CASE(dm_mst_test_connector_destroy_no_sink),
KUNIT_CASE(dm_mst_test_connector_destroy_releases_sink),
KUNIT_CASE_PARAM(dm_mst_test_link_current_set_bw, dm_mst_link_bw_gen_params),
KUNIT_CASE_PARAM(dm_mst_test_synaptics_cascaded, dm_mst_panamera_gen_params),
KUNIT_CASE(dm_mst_test_validate_dsc_caps_no_aux),
KUNIT_CASE(dm_mst_test_validate_dsc_caps_aux_workaround),
KUNIT_CASE(dm_mst_test_validate_dsc_caps_cascaded_hub),
KUNIT_CASE(dm_mst_test_validate_dsc_caps_read_error),
KUNIT_CASE(dm_mst_test_validate_dsc_caps_unsupported),
KUNIT_CASE(dm_mst_test_port_mode_fits_without_dsc),
KUNIT_CASE(dm_mst_test_port_mode_no_dsc_aux),
KUNIT_CASE(dm_mst_test_port_mode_no_common_dsc_config),
KUNIT_CASE(dm_mst_test_port_mode_dsc_passthrough_fits),
KUNIT_CASE(dm_mst_test_port_mode_dsc_passthrough_too_narrow),
KUNIT_CASE(dm_mst_test_port_mode_last_link_too_slow),
KUNIT_CASE(dm_mst_test_port_mode_last_link_cached_bw),
KUNIT_CASE(dm_mst_test_port_mode_last_link_synaptics_quirk),
KUNIT_CASE(dm_mst_test_port_mode_upstream_vc_too_small),
KUNIT_CASE(dm_mst_test_port_mode_branch_throughput_exceeded),
KUNIT_CASE(dm_mst_test_conv_frl_bw_no_pcon_support),
KUNIT_CASE(dm_mst_test_conv_frl_bw_not_hdmi_port),
KUNIT_CASE(dm_mst_test_conv_frl_bw_sink_without_frl),
KUNIT_CASE(dm_mst_test_conv_frl_bw_bottleneck),
KUNIT_CASE(dm_mst_test_log_dsc_params),
KUNIT_CASE(dm_mst_test_find_crtc_index_matches),
KUNIT_CASE(dm_mst_test_find_crtc_index_no_match),
KUNIT_CASE_PARAM(dm_mst_test_dsc_precompute_needed, dm_mst_precompute_gen_params),
KUNIT_CASE(dm_mst_test_recompute_not_mst_branch),
KUNIT_CASE(dm_mst_test_recompute_legacy_hub_without_dsc),
KUNIT_CASE(dm_mst_test_recompute_no_stream_on_link),
KUNIT_CASE(dm_mst_test_recompute_on_mode_change),
KUNIT_CASE(dm_mst_test_recompute_unchanged_stream),
KUNIT_CASE(dm_mst_test_recompute_stream_removed),
KUNIT_CASE(dm_mst_test_recompute_stream_without_connector),
KUNIT_CASE(dm_mst_test_recompute_connector_without_crtc),
KUNIT_CASE(dm_mst_test_compute_configs_skips_sst),
KUNIT_CASE(dm_mst_test_compute_configs_skips_incomplete),
KUNIT_CASE(dm_mst_test_compute_configs_remove_stream_fails),
KUNIT_CASE(dm_mst_test_compute_configs_no_recompute),
KUNIT_CASE(dm_mst_test_pre_validate_dsc_not_needed),
KUNIT_CASE(dm_mst_test_pre_compute_configs_skips_sst),
KUNIT_CASE(dm_mst_test_pre_compute_configs_skips_incomplete),
KUNIT_CASE(dm_mst_test_pre_compute_configs_no_recompute),
KUNIT_CASE(dm_mst_test_dsc_link_fits_uncompressed),
KUNIT_CASE(dm_mst_test_dsc_link_enables_compression),
KUNIT_CASE(dm_mst_test_dsc_link_out_of_slots),
KUNIT_CASE(dm_mst_test_dsc_link_forced_dsc),
KUNIT_CASE(dm_mst_test_dsc_link_forced_dsc_stays_on),
KUNIT_CASE(dm_mst_test_dsc_link_bpp_overwrite),
KUNIT_CASE(dm_mst_test_dsc_link_compression_disabled),
KUNIT_CASE(dm_mst_test_dsc_link_bpp_between_limits),
{}
};
static struct kunit_suite dm_mst_types_test_suite = {
.name = "amdgpu_dm_mst_types",
.test_cases = dm_mst_types_test_cases,
};
kunit_test_suite(dm_mst_types_test_suite);
MODULE_LICENSE("Dual MIT/GPL");
MODULE_DESCRIPTION("KUnit tests for amdgpu_dm_mst_types"