Re: [PATCH v2 33/34] drm/i915/kunit: DP link: add update config tests

[Imre Deak <imre.deak@intel.com>]

On Sat, Jul 04, 2026 at 12:51:20PM +0200, Michał Grzelak wrote:
> On Wed, 1 Jul 2026, Imre Deak wrote:
> > Add KUnit tests for link_caps updates shrinking or expanding the
> > supported rates and lane counts.
> > 
> > The tests also cover updates with disabled configurations, including
> > random shrink and expand sequences, to verify that disabled state,
> > allowed configurations, ordering, and max limits stay consistent across
> > updates.
> > 
> > v2: Remove test cases for the now unused merge update mode.
> > 
> > Signed-off-by: Imre Deak <imre.deak@intel.com>
> > ---
> > .../i915/display/tests/intel_dp_link_test.c   | 780 ++++++++++++++++++
> > 1 file changed, 780 insertions(+)
> > 
> > diff --git a/drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c b/drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c
> > index 1dc5bf6888990..43283245ad037 100644
> > --- a/drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c
> > +++ b/drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c
> > @@ -61,12 +61,29 @@ struct link_config_set {
> > 	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 = {
> > @@ -159,12 +176,56 @@ static const struct link_config_set standard_dp_link_configs[] = {
> > 	},
> > };
> > 
> > +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,
> > @@ -236,9 +297,728 @@ static void intel_dp_link_caps_test_baseline(struct kunit *test)
> > 		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
> > + * ------------------
> 
> Same comment as in PATCH 32/34.

To me the text below describes this test group sufficiently, similarly
to the other test group below.

> > + * 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_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;
> > +	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++) {
> 
> Here we break line after each statement, while in eg. verify_link_caps()
> we kept all of them in one line. Is it possible to unify the style, or
> here we are hitting hard limit on line's length?

It's usual to wrap the for(;;) lines if joining them would make the line
less readable.

> > +			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
> > + * ------------------------------
> 
> Same comment as in PATCH 32/34.
> > + * 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
> 
> nit: s/rate,/rate, /
> > +	 * 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))
> 
> Does it make any sense to do:
> 
> if (!REG_FIELD_GET(disabled_config_mask, BIT(i)))

Not really, the mask above is not a register value. Similarly to all the
masks below.

> > +			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))
> 
> here same for REG_FIELD_GET().
> 
> > +		*rates_step = rand_in_range(ctx, 1, num_rates - 1);
> > +
> > +	if (shrink_mask & BIT(0))
> 
> ditto.
> 
> > +		*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))
> 
> ditto.
> 
> > +		*rates_step = rand_in_range(ctx, 1, max_num_rates - num_rates);
> > +
> > +	if (expand_mask & BIT(0))
> 
> ditto.
> 
> > +		*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);
> > +}
> > +
> > 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),
> > +
> 
> not sure if this newline is superfluous.
> 
> With all that addressed:
> 
> Reviewed-by: Michał Grzelak <michal.grzelak@intel.com>
> 
> BR,
> Michał
> 
> > 	{}
> > };
> > 
> > -- 
> > 2.49.1