display/tests/intel_dp_link_test.c

// SPDX-License-Identifier: MIT
/*
 * Copyright © 2026 Intel Corporation
 */

#include <kunit/test.h>

#include <linux/compiler.h>
#include <linux/device.h>
#include <linux/log2.h>
#include <linux/prandom.h>
#include <linux/random.h>

#include <drm/display/drm_dp_helper.h>

#include <drm/intel/display_member.h>

#include "intel_connector.h"
#include "intel_display_core.h"
#include "intel_display_types.h"
#include "intel_dp_link_caps.h"
#include "intel_dp_link_training.h"

#define LINK_TEST_NUM_LANE_CONFIGS(__max_lane_count) \
	(ilog2(__max_lane_count) + 1)

#define LINK_TEST_NUM_CONFIGS(__num_rates, __max_lane_count) \
	((__num_rates) * LINK_TEST_NUM_LANE_CONFIGS(__max_lane_count))

#define LINK_TEST_MAX_LANE_COUNT		((u32)4)
#define LINK_TEST_MAX_CONFIGS			LINK_TEST_NUM_CONFIGS(DP_MAX_SUPPORTED_RATES, \
								      LINK_TEST_MAX_LANE_COUNT)

#define LINK_TEST_NUM_RANDOM_ITERATIONS		50

struct test_ctx {
	struct {
		struct intel_display display;
		struct device device;
		struct __intel_generic_device generic_device;

		struct intel_connector connector;
		struct intel_digital_port dig_port;

		struct intel_crtc_state crtc_state;
	} dev;

	const struct intel_dp_link_caps_test_ops *link_caps_ops;
	const struct intel_dp_link_training_test_ops *link_training_ops;

	struct rnd_state rnd;
};

struct link_rate_set {
	const int *entries;
	int size;
};

struct link_config_set {
	struct intel_dp_link_config entries[LINK_TEST_MAX_CONFIGS];
	int size;
};

struct test_config_table {
	struct kunit *test;

	struct link_rate_set rates;
	int max_lane_count;
	struct link_config_set disabled_configs;
};

static const int standard_dp_link_rates[] = {
	162000, 270000, 540000, 810000, 1000000, 1350000, 2000000
};

#define LINK_TEST_NUM_STANDARD_RATES (ARRAY_SIZE(standard_dp_link_rates))

#define INIT_STANDARD_TABLE(__test, __num_rates, __max_lane_count) { \
	.test = (__test), \
	.rates = { \
		.entries = standard_dp_link_rates, \
		.size = (__num_rates), \
	}, \
	.max_lane_count = (__max_lane_count), \
}

static const struct link_config_set standard_dp_link_configs[] = {
	[INTEL_DP_LINK_CAPS_ORDER_KEY_BW] = {                        /* MBps    PBN    */
		.entries = {
			{ .rate =  162000, .lane_count = 1 }, /*  162.0    3.00 */
			{ .rate =  270000, .lane_count = 1 }, /*  270.0    5.00 */
			{ .rate =  162000, .lane_count = 2 }, /*  324.0    6.00 */
			{ .rate =  270000, .lane_count = 2 }, /*  540.0   10.00 */
			{ .rate =  540000, .lane_count = 1 }, /*  540.0   10.00 */
			{ .rate =  162000, .lane_count = 4 }, /*  648.0   12.00 */
			{ .rate =  810000, .lane_count = 1 }, /*  810.0   15.00 */
			{ .rate =  270000, .lane_count = 4 }, /* 1080.0   20.00 */
			{ .rate =  540000, .lane_count = 2 }, /* 1080.0   20.00 */
			{ .rate = 1000000, .lane_count = 1 }, /* 1208.9   22.39 */
			{ .rate =  810000, .lane_count = 2 }, /* 1620.0   30.00 */
			{ .rate = 1350000, .lane_count = 1 }, /* 1632.0   30.22 */
			{ .rate =  540000, .lane_count = 4 }, /* 2160.0   40.00 */
			{ .rate = 1000000, .lane_count = 2 }, /* 2417.8   44.77 */
			{ .rate = 2000000, .lane_count = 1 }, /* 2417.8   44.77 */
			{ .rate =  810000, .lane_count = 4 }, /* 3240.0   60.00 */
			{ .rate = 1350000, .lane_count = 2 }, /* 3264.0   60.44 */
			{ .rate = 1000000, .lane_count = 4 }, /* 4835.6   89.55 */
			{ .rate = 2000000, .lane_count = 2 }, /* 4835.6   89.55 */
			{ .rate = 1350000, .lane_count = 4 }, /* 6527.9  120.89 */
			{ .rate = 2000000, .lane_count = 4 }, /* 9671.1  179.09 */
		},
		.size = LINK_TEST_NUM_CONFIGS(ARRAY_SIZE(standard_dp_link_rates),
					      LINK_TEST_MAX_LANE_COUNT),
	},
	[INTEL_DP_LINK_CAPS_ORDER_KEY_RATE_LANE] = {
		.entries = {
			{ .rate = 162000,  .lane_count = 1 },
			{ .rate = 162000,  .lane_count = 2 },
			{ .rate = 162000,  .lane_count = 4 },

			{ .rate = 270000,  .lane_count = 1 },
			{ .rate = 270000,  .lane_count = 2 },
			{ .rate = 270000,  .lane_count = 4 },

			{ .rate = 540000,  .lane_count = 1 },
			{ .rate = 540000,  .lane_count = 2 },
			{ .rate = 540000,  .lane_count = 4 },

			{ .rate = 810000,  .lane_count = 1 },
			{ .rate = 810000,  .lane_count = 2 },
			{ .rate = 810000,  .lane_count = 4 },

			{ .rate = 1000000, .lane_count = 1 },
			{ .rate = 1000000, .lane_count = 2 },
			{ .rate = 1000000, .lane_count = 4 },

			{ .rate = 1350000, .lane_count = 1 },
			{ .rate = 1350000, .lane_count = 2 },
			{ .rate = 1350000, .lane_count = 4 },

			{ .rate = 2000000, .lane_count = 1 },
			{ .rate = 2000000, .lane_count = 2 },
			{ .rate = 2000000, .lane_count = 4 },
		},
		.size = LINK_TEST_NUM_CONFIGS(ARRAY_SIZE(standard_dp_link_rates),
					      LINK_TEST_MAX_LANE_COUNT),
	},
	[INTEL_DP_LINK_CAPS_ORDER_KEY_LANE_RATE] = {
		.entries = {
			{ .rate = 162000,  .lane_count = 1 },
			{ .rate = 270000,  .lane_count = 1 },
			{ .rate = 540000,  .lane_count = 1 },
			{ .rate = 810000,  .lane_count = 1 },
			{ .rate = 1000000, .lane_count = 1 },
			{ .rate = 1350000, .lane_count = 1 },
			{ .rate = 2000000, .lane_count = 1 },

			{ .rate = 162000,  .lane_count = 2 },
			{ .rate = 270000,  .lane_count = 2 },
			{ .rate = 540000,  .lane_count = 2 },
			{ .rate = 810000,  .lane_count = 2 },
			{ .rate = 1000000, .lane_count = 2 },
			{ .rate = 1350000, .lane_count = 2 },
			{ .rate = 2000000, .lane_count = 2 },

			{ .rate = 162000,  .lane_count = 4 },
			{ .rate = 270000,  .lane_count = 4 },
			{ .rate = 540000,  .lane_count = 4 },
			{ .rate = 810000,  .lane_count = 4 },
			{ .rate = 1000000, .lane_count = 4 },
			{ .rate = 1350000, .lane_count = 4 },
			{ .rate = 2000000, .lane_count = 4 },
		},
		.size = LINK_TEST_NUM_CONFIGS(ARRAY_SIZE(standard_dp_link_rates),
					      LINK_TEST_MAX_LANE_COUNT),
	},
};

static int lookup_rate(const struct link_rate_set *rate_set, int rate)
{
	int i;

	for (i = 0; i < rate_set->size; i++)
		if (rate_set->entries[i] == rate)
			return i;

	return -1;
}

static bool has_rate(const struct link_rate_set *rate_set, int rate)
{
	return lookup_rate(rate_set, rate) >= 0;
}

static bool link_configs_match(const struct intel_dp_link_config *a,
			       const struct intel_dp_link_config *b)
{
	return a->rate == b->rate && a->lane_count == b->lane_count;
}

static int lookup_config(const struct link_config_set *config_set,
			 const struct intel_dp_link_config *config)
{
	int i;

	for (i = 0; i < config_set->size; i++)
		if (link_configs_match(&config_set->entries[i], config))
			return i;

	return -1;
}

static bool has_config(const struct link_config_set *config_set,
		       const struct intel_dp_link_config *config)
{
	return lookup_config(config_set, config) >= 0;
}

static void add_config(struct kunit *test,
		       struct link_config_set *config_set,
		       const struct intel_dp_link_config *config)
{
	KUNIT_ASSERT_LT(test, config_set->size, ARRAY_SIZE(config_set->entries));

	config_set->entries[config_set->size] = *config;
	config_set->size++;
}

static const struct intel_dp_link_caps_order config_orders[] = {
	{
		.key = INTEL_DP_LINK_CAPS_ORDER_KEY_BW,
		.dir = INTEL_DP_LINK_CAPS_ORDER_DIR_ASC,
	}, {
		.key = INTEL_DP_LINK_CAPS_ORDER_KEY_BW,
		.dir = INTEL_DP_LINK_CAPS_ORDER_DIR_DESC,
	}, {
		.key = INTEL_DP_LINK_CAPS_ORDER_KEY_RATE_LANE,
		.dir = INTEL_DP_LINK_CAPS_ORDER_DIR_ASC,
	}, {
		.key = INTEL_DP_LINK_CAPS_ORDER_KEY_RATE_LANE,
		.dir = INTEL_DP_LINK_CAPS_ORDER_DIR_DESC,
	}, {
		.key = INTEL_DP_LINK_CAPS_ORDER_KEY_LANE_RATE,
		.dir = INTEL_DP_LINK_CAPS_ORDER_DIR_ASC,
	}, {
		.key = INTEL_DP_LINK_CAPS_ORDER_KEY_LANE_RATE,
		.dir = INTEL_DP_LINK_CAPS_ORDER_DIR_DESC,
	}
};

static const struct link_config_set *
link_caps_config_order_key_to_set(struct kunit *test, enum intel_dp_link_caps_order_key key)
{
	return &standard_dp_link_configs[key];
}

/*
 * TEST: Baseline with fixed reference table
 * -----------------------------------------
 * Verify the link_caps config iterator using fixed standard DP config tables.
 */
static void baseline_test_for_order(struct kunit *test,
				    struct intel_dp_link_caps *link_caps,
				    struct intel_dp_link_caps_order config_order)
{
	struct test_ctx *ctx = test->priv;
	const struct link_config_set *config_set =
		link_caps_config_order_key_to_set(test, config_order.key);
	const struct intel_dp_link_caps_test_ops *ops = ctx->link_caps_ops;
	struct intel_dp_link_config iter_config;
	struct intel_dp_link_caps_iter iter;
	int pos = 0;

	ops->iter_start(&iter, link_caps, config_order, INTEL_DP_LINK_CAPS_FILTER_ALL);
	for_each_dp_link_config(&iter, &iter_config) {
		int idx = pos;

		if (config_order.dir == INTEL_DP_LINK_CAPS_ORDER_DIR_DESC)
			idx = config_set->size - idx - 1;

		KUNIT_EXPECT_TRUE(test, link_configs_match(&iter_config,
							   &config_set->entries[idx]));

		pos++;
	}
	ops->iter_end(&iter);
}

static void intel_dp_link_caps_test_baseline(struct kunit *test)
{
	struct test_ctx *ctx = test->priv;
	struct intel_dp_link_caps *link_caps = ctx->dev.dig_port.dp.link.caps;
	const struct intel_dp_link_caps_test_ops *ops =
		ctx->link_caps_ops;
	int i;

	ops->update(link_caps,
		    standard_dp_link_rates, LINK_TEST_NUM_STANDARD_RATES,
		    LINK_TEST_MAX_LANE_COUNT,
		    true);

	for (i = 0; i < ARRAY_SIZE(config_orders); i++)
		baseline_test_for_order(test, link_caps, config_orders[i]);
}

static int get_num_configs(int num_rates, int max_lane_count)
{
	return num_rates * LINK_TEST_NUM_LANE_CONFIGS(max_lane_count);
}

static int rand_in_range(struct test_ctx *ctx, int min, int max)
{
	return min + (prandom_u32_state(&ctx->rnd) % (max - min + 1));
}

/*
 * TEST: Update reset
 * ------------------
 * Verify that resetting link_caps with the DP standard rates/lane
 * counts updates the configuration table accordingly for all
 * combinations.
 */
static void verify_bw_asc_config_order(struct kunit *test,
				       const struct intel_dp_link_config *last_config,
				       const struct intel_dp_link_config *config)
{
	int config_bw = drm_dp_max_dprx_data_rate(config->rate,
						  config->lane_count);
	int last_config_bw = drm_dp_max_dprx_data_rate(last_config->rate,
						       last_config->lane_count);

	KUNIT_EXPECT_GE(test, config_bw, last_config_bw);
	if (config_bw == last_config_bw)
		KUNIT_EXPECT_GT(test, config->rate, last_config->rate);
}

static void verify_bw_desc_config_order(struct kunit *test,
					const struct intel_dp_link_config *last_config,
					const struct intel_dp_link_config *config)
{
	int config_bw = drm_dp_max_dprx_data_rate(config->rate,
						  config->lane_count);
	int last_config_bw = drm_dp_max_dprx_data_rate(last_config->rate,
						       last_config->lane_count);

	KUNIT_EXPECT_LE(test, config_bw, last_config_bw);
	if (config_bw == last_config_bw)
		KUNIT_EXPECT_LT(test, config->rate, last_config->rate);
}

static void verify_rate_lane_asc_config_order(struct kunit *test,
					      const struct intel_dp_link_config *last_config,
					      const struct intel_dp_link_config *config)
{
	KUNIT_EXPECT_GE(test, config->rate, last_config->rate);
	if (config->rate == last_config->rate)
		KUNIT_EXPECT_GT(test, config->lane_count, last_config->lane_count);
}

static void verify_rate_lane_desc_config_order(struct kunit *test,
					       const struct intel_dp_link_config *last_config,
					       const struct intel_dp_link_config *config)
{
	KUNIT_EXPECT_LE(test, config->rate, last_config->rate);
	if (config->rate == last_config->rate)
		KUNIT_EXPECT_LT(test, config->lane_count, last_config->lane_count);
}

static void verify_lane_rate_asc_config_order(struct kunit *test,
					      const struct intel_dp_link_config *last_config,
					      const struct intel_dp_link_config *config)
{
	KUNIT_EXPECT_GE(test, config->lane_count, last_config->lane_count);
	if (config->lane_count == last_config->lane_count)
		KUNIT_EXPECT_GT(test, config->rate, last_config->rate);
}

static void verify_lane_rate_desc_config_order(struct kunit *test,
					       const struct intel_dp_link_config *last_config,
					       const struct intel_dp_link_config *config)
{
	KUNIT_EXPECT_LE(test, config->lane_count, last_config->lane_count);
	if (config->lane_count == last_config->lane_count)
		KUNIT_EXPECT_LT(test, config->rate, last_config->rate);
}

static void verify_config_order(struct kunit *test,
				struct intel_dp_link_caps_order config_order,
				const struct intel_dp_link_config *last_config,
				const struct intel_dp_link_config *config)
{
	switch (config_order.key) {
	case INTEL_DP_LINK_CAPS_ORDER_KEY_BW:
		if (config_order.dir == INTEL_DP_LINK_CAPS_ORDER_DIR_ASC)
			verify_bw_asc_config_order(test, last_config, config);
		else
			verify_bw_desc_config_order(test, last_config, config);
		break;
	case INTEL_DP_LINK_CAPS_ORDER_KEY_RATE_LANE:
		if (config_order.dir == INTEL_DP_LINK_CAPS_ORDER_DIR_ASC)
			verify_rate_lane_asc_config_order(test, last_config, config);
		else
			verify_rate_lane_desc_config_order(test, last_config, config);
		break;
	case INTEL_DP_LINK_CAPS_ORDER_KEY_LANE_RATE:
		if (config_order.dir == INTEL_DP_LINK_CAPS_ORDER_DIR_ASC)
			verify_lane_rate_asc_config_order(test, last_config, config);
		else
			verify_lane_rate_desc_config_order(test, last_config, config);
		break;
	default:
		KUNIT_FAIL_AND_ABORT(test, "Missing order key: %d", config_order.key);
	}
}

static int expected_num_configs(const struct test_config_table *expected_table,
				const struct intel_dp_link_config *max_limits)
{
	int num_configs = 0;
	int lane_count;
	int rate_idx;

	for (rate_idx = 0; rate_idx < expected_table->rates.size; rate_idx++) {
		for (lane_count = 1; lane_count <= expected_table->max_lane_count; lane_count <<= 1) {
			struct intel_dp_link_config config = {
				.rate = expected_table->rates.entries[rate_idx],
				.lane_count = lane_count,
			};

			if (config.rate > max_limits->rate ||
			    config.lane_count > max_limits->lane_count)
				continue;

			if (has_config(&expected_table->disabled_configs, &config))
				continue;

			num_configs++;
		}
	}

	return num_configs;
}

static void
verify_link_caps_for_order(const struct test_config_table *expected_table,
			   struct intel_dp_link_caps *link_caps,
			   struct intel_dp_link_caps_order config_order,
			   const struct intel_dp_link_config *max_limits)
{
	struct kunit *test = expected_table->test;
	struct test_ctx *ctx = test->priv;
	const struct intel_dp_link_caps_test_ops *ops =
		ctx->link_caps_ops;
	struct intel_dp_link_config expected_max_bw_config = {};
	struct intel_dp_link_config actual_max_bw_config;
	struct intel_dp_link_config last_config = {};
	struct intel_dp_link_config old_max_limits;
	struct intel_dp_link_config iter_config;
	struct intel_dp_link_caps_iter iter;
	int num_actual_configs = 0;
	int max_bw = 0;

	ops->get_max_limits(link_caps, &old_max_limits);
	ops->set_max_limits(link_caps, max_limits);

	ops->iter_start(&iter, link_caps, config_order, INTEL_DP_LINK_CAPS_FILTER_ALL);
	for_each_dp_link_config(&iter, &iter_config) {
		int bw;

		KUNIT_EXPECT_LE(test, iter_config.rate, max_limits->rate);
		KUNIT_EXPECT_LE(test, iter_config.lane_count, max_limits->lane_count);

		num_actual_configs++;

		/*
		 * Verify the config's rate/lane-count values and its ordering relative
		 * to the previous config.
		 */
		if (last_config.rate)
			verify_config_order(test, config_order, &last_config, &iter_config);
		last_config = iter_config;

		KUNIT_EXPECT_TRUE(test, has_rate(&expected_table->rates,
						 iter_config.rate));
		KUNIT_EXPECT_LE(test, iter_config.lane_count,
				      expected_table->max_lane_count);
		KUNIT_EXPECT_TRUE(test, is_power_of_2(iter_config.lane_count));

		/* Verify the config's disabled state */
		KUNIT_EXPECT_FALSE(test, has_config(&expected_table->disabled_configs,
						    &iter_config));

		/*
		 * Update the max limits for allowed configs, verified at the
		 * end for the whole config table.
		 */

		bw = drm_dp_max_dprx_data_rate(iter_config.rate, iter_config.lane_count);
		if (bw > max_bw ||
		    (bw == max_bw && iter_config.rate > expected_max_bw_config.rate)) {
			max_bw = bw;
			expected_max_bw_config = iter_config;
		}
	}
	ops->iter_end(&iter);

	KUNIT_EXPECT_EQ(test, num_actual_configs, expected_num_configs(expected_table, max_limits));

	ops->get_max_bw_config(link_caps, &actual_max_bw_config);
	KUNIT_EXPECT_TRUE(test, link_configs_match(&expected_max_bw_config,
						   &actual_max_bw_config));

	KUNIT_ASSERT_TRUE(test, ops->set_max_limits(link_caps, &old_max_limits));
}

static bool max_limits_valid(const struct test_config_table *expected_table,
			     const struct intel_dp_link_config *max_limits)
{
	int lane_count;
	int rate_idx;

	for (rate_idx = 0; rate_idx < expected_table->rates.size; rate_idx++) {
		for (lane_count = 1; lane_count <= expected_table->max_lane_count; lane_count <<= 1) {
			struct intel_dp_link_config config = {
				.rate = expected_table->rates.entries[rate_idx],
				.lane_count = lane_count,
			};

			if (has_config(&expected_table->disabled_configs, &config))
				continue;

			if (config.rate <= max_limits->rate &&
			    config.lane_count <= max_limits->lane_count)
				return true;
		}
	}

	return false;
}

static void get_max_limits(const struct test_config_table *expected_table,
			   struct intel_dp_link_config *max_limits)
{
	int lane_count;
	int rate_idx;

	max_limits->rate = 0;
	max_limits->lane_count = 0;

	for (rate_idx = 0; rate_idx < expected_table->rates.size; rate_idx++) {
		for (lane_count = 1; lane_count <= expected_table->max_lane_count; lane_count <<= 1) {
			struct intel_dp_link_config config = {
				.rate = expected_table->rates.entries[rate_idx],
				.lane_count = lane_count,
			};

			if (has_config(&expected_table->disabled_configs, &config))
				continue;

			max_limits->rate = max(max_limits->rate, config.rate);
			max_limits->lane_count = max(max_limits->lane_count, config.lane_count);
		}
	}
}

static void verify_link_caps(const struct test_config_table *expected_table,
			     struct intel_dp_link_caps *link_caps)
{
	struct kunit *test = expected_table->test;
	struct test_ctx *ctx = test->priv;
	const struct intel_dp_link_caps_test_ops *ops = ctx->link_caps_ops;
	struct intel_dp_link_config max_limits;
	int i;

	get_max_limits(expected_table, &max_limits);

	for (i = 0; i < ARRAY_SIZE(config_orders); i++) {
		int lane_count;
		int rate_idx;

		verify_link_caps_for_order(expected_table, link_caps, config_orders[i], &max_limits);
		/*
		 * Verify iteration after setting the max limits to each
		 * configurations.
		 */
		for (rate_idx = 0; rate_idx < expected_table->rates.size; rate_idx++) {
			for (lane_count = 1; lane_count <= expected_table->max_lane_count; lane_count <<= 1) {
				struct intel_dp_link_config config = {
					.rate = expected_table->rates.entries[rate_idx],
					.lane_count = lane_count,
				};

				if (!max_limits_valid(expected_table, &config)) {
					/* Verify that invalid max limits are rejected. */
					KUNIT_EXPECT_FALSE(test, ops->set_max_limits(link_caps, &config));

					continue;
				}

				verify_link_caps_for_order(expected_table, link_caps, config_orders[i],
							   &config);
			}
		}
	}
}

static void update_link_caps_and_verify(struct test_config_table *expected_table,
					struct intel_dp_link_caps *link_caps,
					bool reset)
{
	struct kunit *test = expected_table->test;
	struct test_ctx *ctx = test->priv;
	const struct intel_dp_link_caps_test_ops *ops =
		ctx->link_caps_ops;
	bool link_params_changed;

	link_params_changed = ops->update(link_caps,
					  expected_table->rates.entries,
					  expected_table->rates.size,
					  expected_table->max_lane_count,
					  reset);
	KUNIT_EXPECT_TRUE(test, !reset || link_params_changed);

	/*
	 * ops->update() re-enables all configurations when called with
	 * reset=true, or changed link parameters.
	 */
	if (link_params_changed)
		expected_table->disabled_configs.size = 0;

	verify_link_caps(expected_table, link_caps);
}

static void intel_dp_link_caps_test_update_reset(struct kunit *test)
{
	struct test_ctx *ctx = test->priv;
	struct intel_dp_link_caps *link_caps = ctx->dev.dig_port.dp.link.caps;
	int max_lane_count;
	int num_rates;

	for (max_lane_count = 1;
	     max_lane_count <= LINK_TEST_MAX_LANE_COUNT;
	     max_lane_count <<= 1) {
		for (num_rates = 1;
		     num_rates <= LINK_TEST_NUM_STANDARD_RATES;
		     num_rates++) {
			struct test_config_table expected_table =
				INIT_STANDARD_TABLE(test, num_rates,
						    max_lane_count);

			update_link_caps_and_verify(&expected_table, link_caps, true);
		}
	}
}

/*
 * TEST: Update shrink and expand
 * ------------------------------
 * Verify that removing or adding supported rates/lane counts updates
 * the configuration table accordingly.
 */
static void disable_configs_and_verify(struct kunit *test,
				       struct intel_dp_link_caps *link_caps,
				       struct test_config_table *expected_table,
				       const struct link_config_set *config_set)
{
	struct test_ctx *ctx = test->priv;
	const struct intel_dp_link_caps_test_ops *ops =
		ctx->link_caps_ops;
	int i;

	for (i = 0; i < config_set->size; i++) {
		KUNIT_ASSERT_FALSE(test, has_config(&expected_table->disabled_configs,
						    &config_set->entries[i]));
		add_config(test, &expected_table->disabled_configs, &config_set->entries[i]);

		KUNIT_ASSERT_TRUE(test, ops->disable_config(link_caps, &config_set->entries[i]));

		verify_link_caps(expected_table, link_caps);
	}
}

static void disable_configs_for_shrink_and_verify(struct test_config_table *expected_table,
						  struct intel_dp_link_caps *link_caps)
{
	struct kunit *test = expected_table->test;
	struct link_config_set config_set = {};
	struct intel_dp_link_config max_config;

	/*
	 * When configs shrink disable the config with the
	 * second-highest rate, lane params, so the disabled config
	 * stays around after the configs got shrunk.
	 */
	KUNIT_ASSERT_GE(test, expected_table->rates.size, 2);
	KUNIT_ASSERT_GE(test, expected_table->max_lane_count, 2);

	max_config.rate = expected_table->rates.entries[expected_table->rates.size - 2];
	max_config.lane_count = expected_table->max_lane_count >> 1;

	add_config(test, &config_set, &max_config);
	disable_configs_and_verify(test, link_caps, expected_table,
				   &config_set);
}

static void disable_configs_for_expand_and_verify(struct test_config_table *expected_table,
						  struct intel_dp_link_caps *link_caps)
{
	struct kunit *test = expected_table->test;
	struct link_config_set config_set = {};
	struct intel_dp_link_config max_config;

	KUNIT_ASSERT_GE(test, expected_table->rates.size, 1);

	max_config.rate = expected_table->rates.entries[expected_table->rates.size - 1];
	max_config.lane_count = expected_table->max_lane_count;

	add_config(test, &config_set, &max_config);
	disable_configs_and_verify(test, link_caps, expected_table,
				   &config_set);
}

static void get_nth_rate_lane_config(const struct test_config_table *expected_table, int n,
				     struct intel_dp_link_config *config)
{
	int num_lane_configs = LINK_TEST_NUM_LANE_CONFIGS(expected_table->max_lane_count);
	int rate_idx = n / num_lane_configs;
	int lane_count_exp = n % num_lane_configs;

	config->rate = expected_table->rates.entries[rate_idx];
	config->lane_count = 1 << lane_count_exp;
}

static void test_update_rates_shrink(struct kunit *test, bool disable_configs)
{
	struct test_ctx *ctx = test->priv;
	struct intel_dp_link_caps *link_caps = ctx->dev.dig_port.dp.link.caps;
	struct test_config_table expected_table =
		INIT_STANDARD_TABLE(test, LINK_TEST_NUM_STANDARD_RATES,
					  LINK_TEST_MAX_LANE_COUNT);

	update_link_caps_and_verify(&expected_table, link_caps, true);

	while (expected_table.rates.size > 1) {
		if (disable_configs)
			disable_configs_for_shrink_and_verify(&expected_table, link_caps);

		expected_table.rates.size--;

		update_link_caps_and_verify(&expected_table, link_caps, false);
	}
}

static void intel_dp_link_caps_test_update_rates_shrink(struct kunit *test)
{
	test_update_rates_shrink(test, false);
}

static void intel_dp_link_caps_test_update_rates_shrink_disable(struct kunit *test)
{
	test_update_rates_shrink(test, true);
}

static void test_update_rates_expand(struct kunit *test, bool disable_configs)
{
	struct test_ctx *ctx = test->priv;
	struct intel_dp_link_caps *link_caps = ctx->dev.dig_port.dp.link.caps;
	struct test_config_table expected_table =
		INIT_STANDARD_TABLE(test, 1, LINK_TEST_MAX_LANE_COUNT);

	update_link_caps_and_verify(&expected_table, link_caps, true);

	while (expected_table.rates.size < LINK_TEST_NUM_STANDARD_RATES) {
		if (disable_configs)
			disable_configs_for_expand_and_verify(&expected_table, link_caps);

		expected_table.rates.size++;

		update_link_caps_and_verify(&expected_table, link_caps, false);
	}
}

static void intel_dp_link_caps_test_update_rates_expand(struct kunit *test)
{
	test_update_rates_expand(test, false);
}

static void intel_dp_link_caps_test_update_rates_expand_disable(struct kunit *test)
{
	test_update_rates_expand(test, true);
}

static void test_update_lanes_shrink(struct kunit *test, bool disable_configs)
{
	struct test_ctx *ctx = test->priv;
	struct intel_dp_link_caps *link_caps = ctx->dev.dig_port.dp.link.caps;
	struct test_config_table expected_table =
		INIT_STANDARD_TABLE(test, LINK_TEST_NUM_STANDARD_RATES,
					  LINK_TEST_MAX_LANE_COUNT);

	update_link_caps_and_verify(&expected_table, link_caps, true);

	while (expected_table.max_lane_count > 1) {
		if (disable_configs)
			disable_configs_for_shrink_and_verify(&expected_table, link_caps);

		expected_table.max_lane_count >>= 1;

		update_link_caps_and_verify(&expected_table, link_caps, false);
	}
}

static void intel_dp_link_caps_test_update_lanes_shrink(struct kunit *test)
{
	test_update_lanes_shrink(test, false);
}

static void intel_dp_link_caps_test_update_lanes_shrink_disable(struct kunit *test)
{
	test_update_lanes_shrink(test, true);
}

static void test_update_lanes_expand(struct kunit *test, bool disable_configs)
{
	struct test_ctx *ctx = test->priv;
	struct intel_dp_link_caps *link_caps = ctx->dev.dig_port.dp.link.caps;
	struct test_config_table expected_table =
		INIT_STANDARD_TABLE(test, LINK_TEST_NUM_STANDARD_RATES, 1);

	update_link_caps_and_verify(&expected_table, link_caps, true);

	while (expected_table.max_lane_count < LINK_TEST_MAX_LANE_COUNT) {
		if (disable_configs)
			disable_configs_for_expand_and_verify(&expected_table, link_caps);

		expected_table.max_lane_count <<= 1;

		update_link_caps_and_verify(&expected_table, link_caps, false);
	}
}

static void intel_dp_link_caps_test_update_lanes_expand(struct kunit *test)
{
	test_update_lanes_expand(test, false);
}

static void intel_dp_link_caps_test_update_lanes_expand_disable(struct kunit *test)
{
	test_update_lanes_expand(test, true);
}

static void disable_random_configs_and_verify(struct test_config_table *expected_table,
					      struct intel_dp_link_caps *link_caps)
{
	struct kunit *test = expected_table->test;
	struct test_ctx *ctx = test->priv;
	struct link_config_set config_set = {};
	u32 disabled_config_mask;
	int num_configs;
	int i;

	num_configs = get_num_configs(expected_table->rates.size,
				      expected_table->max_lane_count);
	disabled_config_mask = prandom_u32_state(&ctx->rnd) &
			       GENMASK_U32(num_configs - 1, 0);

	for (i = 0; i < num_configs; i++) {
		struct intel_dp_link_config config;

		/* At least one config must remain enabled. */
		if (expected_table->disabled_configs.size +
		    config_set.size + 1 >= num_configs)
			break;

		if (!(BIT(i) & disabled_config_mask))
			continue;

		get_nth_rate_lane_config(expected_table, i, &config);
		/* Don't disable a config twice. */
		if (has_config(&expected_table->disabled_configs, &config))
			continue;

		add_config(test, &config_set, &config);
	}

	disable_configs_and_verify(test, link_caps, expected_table,
				   &config_set);
}

static void get_params_shrink_step(struct test_ctx *ctx,
				   int num_rates, int max_lane_count,
				   int *rates_step, int *lanes_step)
{
	int shrink_mask;

	*rates_step = 0;
	*lanes_step = 0;

	if (num_rates == 1)
		shrink_mask = BIT(0);				/* shrink only lanes */
	else if (max_lane_count == 1)
		shrink_mask = BIT(1);				/* shrink only rates */
	else
		shrink_mask = rand_in_range(ctx,
					    BIT(0),
					    BIT(0) | BIT(1));	/* shrink one or both params */

	if (shrink_mask & BIT(1))
		*rates_step = rand_in_range(ctx, 1, num_rates - 1);

	if (shrink_mask & BIT(0))
		*lanes_step = rand_in_range(ctx, 1, ilog2(max_lane_count));
}

static void get_params_expand_step(struct test_ctx *ctx,
				   int max_num_rates, int num_rates,
				   int max_supported_lane_count, int max_lane_count,
				   int *rates_step, int *lanes_step)
{
	int expand_mask;

	*rates_step = 0;
	*lanes_step = 0;

	if (num_rates == max_num_rates)
		expand_mask = BIT(0);				/* expand only lanes */
	else if (max_lane_count == max_supported_lane_count)
		expand_mask = BIT(1);				/* expand only rates */
	else
		expand_mask = rand_in_range(ctx,
					    BIT(0),
					    BIT(0) | BIT(1));	/* expand one or both params */

	if (expand_mask & BIT(1))
		*rates_step = rand_in_range(ctx, 1, max_num_rates - num_rates);

	if (expand_mask & BIT(0))
		*lanes_step = rand_in_range(ctx, 1, ilog2(max_supported_lane_count /
							  max_lane_count));
}

static void test_update_params_shrink_random(struct kunit *test, bool disable_configs)
{
	struct test_ctx *ctx = test->priv;
	struct intel_dp_link_caps *link_caps = ctx->dev.dig_port.dp.link.caps;
	struct test_config_table expected_table =
		INIT_STANDARD_TABLE(test, LINK_TEST_NUM_STANDARD_RATES,
					  LINK_TEST_MAX_LANE_COUNT);

	update_link_caps_and_verify(&expected_table, link_caps, true);

	while (expected_table.rates.size > 1 || expected_table.max_lane_count > 1) {
		int rates_step;
		int lanes_step;

		if (disable_configs)
			disable_random_configs_and_verify(&expected_table, link_caps);

		get_params_shrink_step(ctx,
				       expected_table.rates.size,
				       expected_table.max_lane_count,
				       &rates_step, &lanes_step);

		expected_table.rates.size -= rates_step;
		expected_table.max_lane_count >>= lanes_step;

		update_link_caps_and_verify(&expected_table, link_caps, false);
	}
}

static void intel_dp_link_caps_test_update_params_shrink_random(struct kunit *test)
{
	int i;

	for (i = 0; i < LINK_TEST_NUM_RANDOM_ITERATIONS; i++)
		test_update_params_shrink_random(test, false);
}

static void intel_dp_link_caps_test_update_params_shrink_disable_random(struct kunit *test)
{
	int i;

	for (i = 0; i < LINK_TEST_NUM_RANDOM_ITERATIONS; i++)
		test_update_params_shrink_random(test, true);
}

static void test_update_params_expand_random(struct kunit *test, bool disable_configs)
{
	struct test_ctx *ctx = test->priv;
	struct intel_dp_link_caps *link_caps = ctx->dev.dig_port.dp.link.caps;
	struct test_config_table expected_table =
		INIT_STANDARD_TABLE(test, 1, 1);

	update_link_caps_and_verify(&expected_table, link_caps, true);

	while (expected_table.rates.size < LINK_TEST_NUM_STANDARD_RATES ||
	       expected_table.max_lane_count < LINK_TEST_MAX_LANE_COUNT) {
		int rates_step;
		int lanes_step;

		if (disable_configs)
			disable_random_configs_and_verify(&expected_table, link_caps);

		get_params_expand_step(ctx,
				       LINK_TEST_NUM_STANDARD_RATES,
				       expected_table.rates.size,
				       LINK_TEST_MAX_LANE_COUNT,
				       expected_table.max_lane_count,
				       &rates_step, &lanes_step);

		expected_table.rates.size += rates_step;
		expected_table.max_lane_count <<= lanes_step;

		update_link_caps_and_verify(&expected_table, link_caps, false);
	}
}

static void intel_dp_link_caps_test_update_params_expand_random(struct kunit *test)
{
	int i;

	for (i = 0; i < LINK_TEST_NUM_RANDOM_ITERATIONS; i++)
		test_update_params_expand_random(test, false);
}

static void intel_dp_link_caps_test_update_params_expand_disable_random(struct kunit *test)
{
	int i;

	for (i = 0; i < LINK_TEST_NUM_RANDOM_ITERATIONS; i++)
		test_update_params_expand_random(test, true);
}

/*
 * TEST: Fallback sequence
 * -----------------------
 * Verify the eDP fallback logic to set the maximum supported configuration
 * as a preference.
 *
 * For DP SST and MST verify fallback selection from the connector's
 * maximum configuration and iteration of the resulting allowed
 * configurations.
 */
static void intel_dp_link_test_fallback_for_edp(struct kunit *test)
{
	struct test_ctx *ctx = test->priv;
	struct intel_dp_link_caps *link_caps = ctx->dev.dig_port.dp.link.caps;
	struct test_config_table expected_table =
		INIT_STANDARD_TABLE(test, LINK_TEST_NUM_STANDARD_RATES,
					  LINK_TEST_MAX_LANE_COUNT);
	struct intel_digital_port *dig_port = &ctx->dev.dig_port;
	const struct intel_dp_link_training_test_ops *lt_ops =
		ctx->link_training_ops;
	const struct intel_dp_link_caps_test_ops *lc_ops =
		ctx->link_caps_ops;
	struct intel_dp_link_config min_config = {
		.rate = expected_table.rates.entries[0],
		.lane_count = 1,
	};
	struct intel_dp_link_config max_config = {
		.rate = expected_table.rates.entries[expected_table.rates.size - 1],
		.lane_count = LINK_TEST_MAX_LANE_COUNT,
	};
	struct intel_dp_link_caps_order order;
	struct intel_dp_link_config iter_config;
	struct intel_dp_link_caps_iter iter;
	int fallback_err;

	dig_port->base.type = INTEL_OUTPUT_EDP;
	ctx->dev.dig_port.dp.use_max_params = false;

	update_link_caps_and_verify(&expected_table, link_caps, true);

	order = lc_ops->connector_compute_order(&ctx->dev.connector);

	lc_ops->iter_start(&iter, link_caps, order, INTEL_DP_LINK_CAPS_FILTER_ALL);
	for_each_dp_link_config(&iter, &iter_config)
		break;
	lc_ops->iter_end(&iter);

	KUNIT_EXPECT_FALSE(test, ctx->dev.dig_port.dp.use_max_params);
	KUNIT_EXPECT_TRUE(test, link_configs_match(&iter_config, &min_config));

	ctx->dev.crtc_state.output_types = BIT(dig_port->base.type);
	ctx->dev.crtc_state.port_clock = min_config.rate;
	ctx->dev.crtc_state.lane_count = min_config.lane_count;

	fallback_err = lt_ops->get_fallback_values(&ctx->dev.dig_port.dp, &ctx->dev.crtc_state);
	KUNIT_EXPECT_EQ(test, fallback_err, 0);

	/* The fallback should've changed the order. */
	order = lc_ops->connector_compute_order(&ctx->dev.connector);

	lc_ops->iter_start(&iter, link_caps, order, INTEL_DP_LINK_CAPS_FILTER_ALL);
	for_each_dp_link_config(&iter, &iter_config)
		break;
	lc_ops->iter_end(&iter);

	KUNIT_EXPECT_TRUE(test, ctx->dev.dig_port.dp.use_max_params);
	KUNIT_EXPECT_TRUE(test, link_configs_match(&iter_config, &max_config));
}

static bool test_fallback_from_target(struct test_config_table *expected_table,
				      enum intel_output_type output_type,
				      const struct intel_dp_link_config *expected_target_config,
				      const struct intel_dp_link_config *expected_fallback_config)
{
	struct kunit *test = expected_table->test;
	struct test_ctx *ctx = test->priv;
	struct intel_dp_link_caps *link_caps = ctx->dev.dig_port.dp.link.caps;
	struct intel_dp_link_config iter_config;
	const struct intel_dp_link_training_test_ops *lt_ops =
		ctx->link_training_ops;
	const struct intel_dp_link_caps_test_ops *lc_ops =
		ctx->link_caps_ops;
	/* Modify default order direction for max config lookup. */
	struct intel_dp_link_caps_order fallback_order =
		lc_ops->connector_fallback_order(ctx->dev.connector.mst.dp);
	struct intel_dp_link_caps_iter iter;
	int expected_fallback_err = 0;
	int fallback_err;

	/* Get the max connector config, optionally filtered to the max_rate limit. */
	lc_ops->iter_start(&iter, link_caps, fallback_order, INTEL_DP_LINK_CAPS_FILTER_ALL);
	for_each_dp_link_config(&iter, &iter_config)
		break;
	lc_ops->iter_end(&iter);

	KUNIT_EXPECT_TRUE(test, link_configs_match(&iter_config,
						   expected_target_config));
	KUNIT_EXPECT_FALSE(test, link_configs_match(&iter_config,
						    &INTEL_DP_LINK_CONFIG_NULL));

	ctx->dev.crtc_state.output_types = BIT(output_type);
	ctx->dev.crtc_state.port_clock = expected_target_config->rate;
	ctx->dev.crtc_state.lane_count = expected_target_config->lane_count;

	if (link_configs_match(expected_fallback_config, &INTEL_DP_LINK_CONFIG_NULL))
		expected_fallback_err = -1;

	fallback_err = lt_ops->get_fallback_values(&ctx->dev.dig_port.dp, &ctx->dev.crtc_state);
	KUNIT_EXPECT_EQ(test, fallback_err, expected_fallback_err);

	if (!fallback_err) {
		/*
		 * NOTE: This test does not verify any implied fallback
		 * target selection.
		 *
		 * The current driver behavior may still select a fallback
		 * configuration indirectly via max_limits, but that is an
		 * implementation artifact rather than part of the intended
		 * fallback API behavior, and is therefore not verified here.
		 *
		 * Instead, the effect of the fallback logic is verified by
		 * checking that the failed target configuration is disabled.
		 * Selecting the next target configuration from the remaining
		 * allowed configurations belongs to the modeset link target
		 * selection logic.
		 */
		add_config(test, &expected_table->disabled_configs,
			   expected_target_config);
	}

	verify_link_caps(expected_table, link_caps);

	return !fallback_err;
}

static const struct link_config_set *
get_target_configs_for_output_type(struct kunit *test,
				   enum intel_output_type output_type)
{
	switch (output_type) {
	case INTEL_OUTPUT_DDI:
	case INTEL_OUTPUT_DP:
	case INTEL_OUTPUT_EDP:
		return &standard_dp_link_configs[INTEL_DP_LINK_CAPS_ORDER_KEY_RATE_LANE];
	case INTEL_OUTPUT_DP_MST:
		return &standard_dp_link_configs[INTEL_DP_LINK_CAPS_ORDER_KEY_BW];
	default:
		KUNIT_FAIL_AND_ABORT(test, "Missing output type: %d", output_type);
	}
}

static const struct link_config_set *
get_fallback_configs_for_output_type(struct kunit *test,
				     enum intel_output_type output_type)
{
	switch (output_type) {
	case INTEL_OUTPUT_DDI:
	case INTEL_OUTPUT_DP:
	case INTEL_OUTPUT_EDP:
		return &standard_dp_link_configs[INTEL_DP_LINK_CAPS_ORDER_KEY_LANE_RATE];
	case INTEL_OUTPUT_DP_MST:
		return &standard_dp_link_configs[INTEL_DP_LINK_CAPS_ORDER_KEY_BW];
	default:
		KUNIT_FAIL_AND_ABORT(test, "Missing output type: %d", output_type);
	}
}

static void assert_config_is_supported(const struct test_config_table *expected_table,
				       const struct intel_dp_link_config *config)
{
	struct kunit *test = expected_table->test;

	KUNIT_ASSERT_TRUE(test, has_rate(&expected_table->rates, config->rate));
	KUNIT_ASSERT_LE(test, config->lane_count, expected_table->max_lane_count);
}

static bool get_fallback_config(const struct test_config_table *expected_table,
				enum intel_output_type output_type,
				const struct intel_dp_link_config *target_config,
				struct intel_dp_link_config *fallback_config)
{
	struct kunit *test = expected_table->test;
	const struct link_config_set *config_set =
		get_fallback_configs_for_output_type(test, output_type);
	int i;

	i = lookup_config(config_set, target_config);
	KUNIT_ASSERT_GE(test, i, 0);

	for (i--; i >= 0; i--) {
		const struct intel_dp_link_config *config =
			&config_set->entries[i];

		assert_config_is_supported(expected_table, config);
		*fallback_config = *config;

		return true;
	}

	return false;
}

static bool get_target_config(const struct test_config_table *expected_table,
			      enum intel_output_type output_type,
			      struct intel_dp_link_config *target)
{
	struct kunit *test = expected_table->test;
	const struct link_config_set *config_set =
		get_target_configs_for_output_type(test, output_type);
	int i;

	for (i = config_set->size - 1; i >= 0; i--) {
		const struct intel_dp_link_config *config =
			&config_set->entries[i];

		assert_config_is_supported(expected_table, config);
		*target = *config;

		return true;
	}

	return false;
}

static void test_fallback_seq(struct kunit *test,
			      enum intel_output_type output_type)
{
	struct test_ctx *ctx = test->priv;
	struct intel_dp_link_caps *link_caps = ctx->dev.dig_port.dp.link.caps;
	struct test_config_table expected_table =
		INIT_STANDARD_TABLE(test, LINK_TEST_NUM_STANDARD_RATES,
					  LINK_TEST_MAX_LANE_COUNT);
	struct intel_digital_port *dig_port = &ctx->dev.dig_port;
	struct intel_dp_link_config fallback_config = {};
	struct intel_dp_link_config target_config;
	int fallback_count = 0;
	bool target_found;

	dig_port->base.type = output_type;
	ctx->dev.dig_port.dp.use_max_params = false;

	update_link_caps_and_verify(&expected_table, link_caps, true);

	/* Get the initial target config. */
	target_found = get_target_config(&expected_table, output_type,
					 &target_config);
	KUNIT_ASSERT_TRUE(test, target_found);

	for (;;) {
		/* Also test the case where no fallback is available. */
		if (!get_fallback_config(&expected_table, output_type,
					 &target_config, &fallback_config))
			fallback_config = INTEL_DP_LINK_CONFIG_NULL;

		if (!test_fallback_from_target(&expected_table, output_type,
					       &target_config, &fallback_config))
			break;

		/* Simply select the fallback config as the next target. */
		target_config = fallback_config;

		fallback_count++;
		KUNIT_ASSERT_LT(test, fallback_count, LINK_TEST_MAX_CONFIGS);
	}
}

static void intel_dp_link_test_fallback_for_sst(struct kunit *test)
{
	test_fallback_seq(test, INTEL_OUTPUT_DP);
}

static void intel_dp_link_test_fallback_for_mst(struct kunit *test)
{
	struct test_ctx *ctx = test->priv;

	ctx->dev.connector.mst.dp = &ctx->dev.dig_port.dp;

	test_fallback_seq(test, INTEL_OUTPUT_DP_MST);
}

static struct kunit_case intel_dp_link_test_cases[] = {
	KUNIT_CASE(intel_dp_link_caps_test_baseline),

	KUNIT_CASE(intel_dp_link_caps_test_update_reset),

	KUNIT_CASE(intel_dp_link_caps_test_update_rates_shrink),
	KUNIT_CASE(intel_dp_link_caps_test_update_rates_shrink_disable),
	KUNIT_CASE(intel_dp_link_caps_test_update_rates_expand),
	KUNIT_CASE(intel_dp_link_caps_test_update_rates_expand_disable),
	KUNIT_CASE(intel_dp_link_caps_test_update_lanes_shrink),
	KUNIT_CASE(intel_dp_link_caps_test_update_lanes_shrink_disable),
	KUNIT_CASE(intel_dp_link_caps_test_update_lanes_expand),
	KUNIT_CASE(intel_dp_link_caps_test_update_lanes_expand_disable),
	KUNIT_CASE(intel_dp_link_caps_test_update_params_shrink_random),
	KUNIT_CASE(intel_dp_link_caps_test_update_params_shrink_disable_random),
	KUNIT_CASE(intel_dp_link_caps_test_update_params_expand_random),
	KUNIT_CASE(intel_dp_link_caps_test_update_params_expand_disable_random),

	KUNIT_CASE(intel_dp_link_test_fallback_for_edp),
	KUNIT_CASE(intel_dp_link_test_fallback_for_sst),
	KUNIT_CASE(intel_dp_link_test_fallback_for_mst),

	{}
};

static struct test_ctx test_ctx;

static int intel_dp_link_test_init(struct kunit *test)
{
	struct intel_digital_port *dig_port;
	struct intel_encoder *encoder;
	struct intel_dp *intel_dp;

	/* Reset the dev state for each test. */
	memset(&test_ctx.dev, 0, sizeof(test_ctx.dev));

	test_ctx.dev.generic_device.drm.dev = &test_ctx.dev.device;

	test_ctx.dev.display.drm = &test_ctx.dev.generic_device.drm;
	test_ctx.dev.generic_device.display = &test_ctx.dev.display;

	encoder = &test_ctx.dev.dig_port.base;
	encoder->base.dev = &test_ctx.dev.generic_device.drm;

	dig_port = &test_ctx.dev.dig_port;
	dig_port->base.type = INTEL_OUTPUT_DP;

	test_ctx.dev.connector.encoder = encoder;

	intel_dp = &dig_port->dp;
	intel_dp->attached_connector = &test_ctx.dev.connector;

	intel_dp->link.caps = test_ctx.link_caps_ops->init(intel_dp);

	test->priv = &test_ctx;

	return 0;
}

static void intel_dp_link_test_exit(struct kunit *test)
{
	struct test_ctx *ctx = test->priv;

	ctx->link_caps_ops->cleanup(ctx->dev.dig_port.dp.link.caps);
}

static int intel_dp_link_test_suite_init(struct kunit_suite *test_suite)
{
#ifdef I915
	test_ctx.link_caps_ops = &i915_display_dp_link_caps_test_ops;
	test_ctx.link_training_ops = &i915_display_dp_link_training_test_ops;
#else
	test_ctx.link_caps_ops = &intel_display_dp_link_caps_test_ops;
	test_ctx.link_training_ops = &intel_display_dp_link_training_test_ops;
#endif
	prandom_seed_state(&test_ctx.rnd, 0);

	return 0;
}

static struct kunit_suite intel_dp_link_test_suite = {
	.name = "intel_dp_link",
	.suite_init = intel_dp_link_test_suite_init,
	.init = intel_dp_link_test_init,
	.exit = intel_dp_link_test_exit,
	.test_cases = intel_dp_link_test_cases,
};

kunit_test_suites(&intel_dp_link_test_suite);

MODULE_IMPORT_NS("EXPORTED_FOR_KUNIT_TESTING");

MODULE_AUTHOR("Intel Corporation");
MODULE_LICENSE("GPL and additional rights");
MODULE_DESCRIPTION("Intel DP link KUnit tests");