drm/i915/dp_link: Unify modeset/fallback config selection
Subsystems (6)
v2 cover drm/i915/dp_link: Unify modeset/fallback config selection
This is v2 of the third part of patchset [1], unifying the link configuration selection logic used during modeset state computation and link training fallback selection, while also adding the corresponding KUnit tests. This constitutes patches 58–108 of [1] and, once merged, completes the original patchset. Due to the simplifications introduced in this version explained below, several patches from the original patchset have been dropped.
The patchset is based on the already merged first [2] and second [3] part of patchset [1].
For the rationale of this patchset, please refer to the parts related to link configuration selection in the cover letter of [1].
This v2 patchset version has the following changes:
- Track the state of link config iteration in an iteration object. (Jani)
- Use an opaque filter object for filtering the iterated configurations instead of exposing configuration indices via the API. (Jani)
- Remove all parts of the API accepting or returning a configuration index or position. (Jani)
- Use the config iterator for fallback selection. (Jani)
- Remove the change to track link configurations via a virtual indexing scheme. (Ville)
- Remove the functionality to merge new link configurations for a connected sink changing its capabilities, allowed by patchset [4] already merged. (Ville)
- Use the max BW link configuration during mode validation and TBT BW computation, instead of using the max link limits for these.
[1] https://lore.kernel.org/all/[email protected]
[2] https://lore.kernel.org/all/[email protected]
[3] https://lore.kernel.org/all/[email protected]
[4] https://lore.kernel.org/all/[email protected]
Imre Deak (34):
drm/i915/doc: Document DP link capabilities drm/i915/dp_link_caps: Factor out helper to get link config by index drm/i915/dp_link_caps: Add support for link rate, lane count iteration
orders
drm/i915/dp_link_caps: Add link configuration iterator drm/i915/dp_link_caps: Add helper to get iteration order for a
connector
drm/i915/dp_link_caps: Validate max link limits drm/i915/dp_link_caps: Add filter for enabled link configurations drm/i915/dp_link_caps: Re-enable link configurations after a link
reset
drm/i915/dp_link_caps: Re-enable link configurations after sink caps
change
drm/i915/dp_link_caps: Drop noupdate postfix from max link limit set
helpers
drm/i915/dp_link_caps: Add debugfs entry showing allowed
configurations
drm/i915/dp: Add link configuration filter for modeset computation drm/i915/dp_link_caps: Add helper to query max BW link configuration drm/i915/dp: Query max BW config via link_caps during mode validation drm/i915/dp_tunnel: Query max BW config via link_caps for BW
computation
drm/i915/dp_test: Use link caps for compliance link configs drm/i915/dp: Iterate configurations via link_caps for SST non-DSC drm/i915/dp: Iterate configurations via link_caps for SST DSC drm/i915/dp: Use link caps for eDP DSC config selection drm/i915/dp_mst: Use link caps for non-DSC config selection drm/i915/dp_mst: Use link caps for MST DSC config selection drm/i915/dp: Remove min/max link config limits drm/i915/dp_link_training: Reset the max link limits in the fallback
code
drm/i915/dp_link_training: Use config iterator for fallback drm/i915/dp_link_training: Disable failed config during fallback drm/i915/kunit: Enable KUnit tests
drm/i915/kunit: Add DP link test stub
drm/xe/kunit: Add display test config
drm/xe/kunit: Build DP link display tests
drm/i915/kunit: Setup DP link test context
drm/i915/kunit: Export link training and caps funcs for testing drm/i915/kunit: DP link: add baseline fixed table reference test drm/i915/kunit: DP link: add update config tests drm/i915/kunit: DP link: add fallback tests
.../intel-display/dp-link-capabilities.rst | 11 + Documentation/gpu/intel-display/index.rst | 1 + drivers/gpu/drm/i915/.kunitconfig | 12 + drivers/gpu/drm/i915/Kconfig.debug | 12 + drivers/gpu/drm/i915/Makefile | 2 + drivers/gpu/drm/i915/display/intel_dp.c | 291 ++-- drivers/gpu/drm/i915/display/intel_dp.h | 11 +- .../gpu/drm/i915/display/intel_dp_link_caps.c | 759 ++++++++- .../gpu/drm/i915/display/intel_dp_link_caps.h | 172 +- .../drm/i915/display/intel_dp_link_training.c | 237 +-- .../drm/i915/display/intel_dp_link_training.h | 31 + drivers/gpu/drm/i915/display/intel_dp_mst.c | 72 +- drivers/gpu/drm/i915/display/intel_dp_test.c | 107 +- drivers/gpu/drm/i915/display/intel_dp_test.h | 3 +- .../gpu/drm/i915/display/intel_dp_tunnel.c | 8 +- drivers/gpu/drm/i915/display/tests/Makefile | 7 + .../i915/display/tests/intel_dp_link_test.c | 1412 +++++++++++++++++ drivers/gpu/drm/xe/.gitignore | 1 + drivers/gpu/drm/xe/.kunitconfig-display | 11 + drivers/gpu/drm/xe/Makefile | 3 + drivers/gpu/drm/xe/display/tests/Makefile | 11 + 21 files changed, 2786 insertions(+), 388 deletions(-) create mode 100644 Documentation/gpu/intel-display/dp-link-capabilities.rst create mode 100644 drivers/gpu/drm/i915/.kunitconfig create mode 100644 drivers/gpu/drm/i915/display/tests/Makefile create mode 100644 drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c create mode 100644 drivers/gpu/drm/xe/.kunitconfig-display create mode 100644 drivers/gpu/drm/xe/display/tests/Makefile
Signature · 1 line
2.49.1
PATCH v2 1/34 drm/i915/doc: Document DP link capabilities
Add documentation for the DP link capabilities interface.
--- .../intel-display/dp-link-capabilities.rst | 11 +++ Documentation/gpu/intel-display/index.rst | 1 + .../gpu/drm/i915/display/intel_dp_link_caps.c | 81 +++++++++++++++++++ 3 files changed, 93 insertions(+) create mode 100644 Documentation/gpu/intel-display/dp-link-capabilities.rst
Documentation/gpu/intel-display/dp-link-capabilities.rst new file +11 -0
@@ -0,0 +1,11 @@ +.. SPDX-License-Identifier: MIT +.. Copyright © 2026 Intel Corporation + +DisplayPort Link Capabilities +============================= + +.. kernel-doc:: drivers/gpu/drm/i915/display/intel_dp_link_caps.c + :doc: DisplayPort link capabilities + +.. kernel-doc:: drivers/gpu/drm/i915/display/intel_dp_link_caps.h + :internal:
Documentation/gpu/intel-display/index.rst +1 -0
@@ -39,6 +39,7 @@ driver. The display driver isn't an independent driver in that sense. frontbuffer hotplug dp-link-training + dp-link-capabilities plane psr snps-phy
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +81 -0
87 lines not on this page · raw message
Signature · 1 line
2.49.1
RE: [PATCH v2 01/34] drm/i915/doc: Document DP link capabilities
Quoted 5 lines
Subject: [PATCH v2 01/34] drm/i915/doc: Document DP link capabilities
Add documentation for the DP link capabilities interface.
Signed-off-by Imre Deak <[email protected]>
LGTM,
Quoted 134 lines
--- .../intel-display/dp-link-capabilities.rst | 11 +++ Documentation/gpu/intel-display/index.rst | 1 + .../gpu/drm/i915/display/intel_dp_link_caps.c | 81 +++++++++++++++++++ 3 files changed, 93 insertions(+) create mode 100644 Documentation/gpu/intel-display/dp-link-capabilities.rstDocumentation/gpu/intel-display/dp-link-capabilities.rst new file +11
-0@@ -0,0 +1,11 @@ +.. SPDX-License-Identifier: MIT +.. Copyright © 2026 Intel Corporation + +DisplayPort Link Capabilities +============================= + +.. kernel-doc:: drivers/gpu/drm/i915/display/intel_dp_link_caps.c + :doc: DisplayPort link capabilities + +.. kernel-doc:: drivers/gpu/drm/i915/display/intel_dp_link_caps.h + :internal:Documentation/gpu/intel-display/index.rst +0
-0@@ -39,6 +39,7 @@ driver. The display driver isn't an independent driver inthat sense.
frontbuffer
hotplug
dp-link-trainingDocumentation/gpu/intel-display/index.rst +1
-0+ dp-link-capabilities plane psr snps-phydrivers/gpu/drm/i915/display/intel_dp_link_caps.c +81
-1@@ -19,6 +19,87 @@#include "intel_dp.h" #include "intel_dp_link_caps.h" +/** +* DOC: DisplayPort link capabilities +* +* The Intel DP link caps API tracks the supported and allowed +* DisplayPort link configurations for a DP encoder and its attached +* connectors, and provides helpers to iterate over the allowed +* configurations and constrain them by filtering, disabling, or +* limiting them to maximum link parameters. +* +* Locking +* ------- +* +* All accesses to this API must be serialized. The only exception +* is intel_dp_link_caps_get_max_limits(), which allow lockless +* lookup. Such lookups may observe an out-of-sync &struct +* intel_dp_link_config tuple, i.e. a rate from one state and a lane +* count from another. +* +* The Intel i915/xe drivers ensure the above serialization by holding +* &drm_mode_config.connection_mutex and, while holding the lock, +* waiting for any pending asynchronous atomic commits. This also allows +* use of the API from the tails of asynchronous atomic commits, which +* cannot hold the lock. +* +* Iterating and restricting link configurations +* --------------------------------------------- +* +* The link configuration iterators can iterate the ``allowed +* configurations`` during modeset configuration selection or link +* training fallback handling in a configurable order. +* +* The iteration order can depend on connector type (eDP, DP SST, +* DP MST) and modeset-specific conditions or driver policies, such +* as DSC vs. non-DSC modes, power saving vs. better user experience, +* or policy changes after a link training failure. +* +* The configurations exposed via the iterators can be additionally +* constrained in the following ways: +* +* - Filtered for a given modeset based on modeset-specific conditions. +* Examples for such conditions include driver policies preferring +* power saving or better user experience, post-link training failure +* preference changes, or sink automated test requests limiting the +* usable configurations. +* +* - Disabled permanently for the connected sink. Examples of reasons +* to disable a configuration include a link training failure for a +* given configuration or a driver workaround preventing the use of +* a particular configuration. +* +* - Limited via a maximum link rate and lane count. For example, after +* a link training failure, subsequent modesets may be limited to +* configurations at or below the failed parameters. +* +* This mechanism exists for backward compatibility only. Eventually, +* it will be removed in favor of relying solely on individually +* disabled configurations, as described above. +* +* Terminology +* ----------- +* +* ``Common link capabilities`` (or ``common caps``) refer to the link +* rates and maximum lane count supported by both the source and the +* sink, i.e. the intersection of their respective capabilities. +* +* ``Supported configurations`` are all configurations defined by the +* ``Common link capabilities``' link rates and maximum lane count. +* +* ``Disabled configurations`` are ``Supported configurations`` disabled +* via this API. +* +* ``Enabled configurations`` are ``Supported configurations`` that are +* not disabled. +* +* ``Forced configurations`` are ``Enabled configurations`` forced via +* forced link parameter debugfs entries. +* +* ``Allowed configurations`` are the ``Enabled configurations``, or if +* forcing is in effect the ``Forced configurations``, constrained by a +* maximum rate and lane count set via the API. +*/ struct intel_dp_link_caps {struct intel_dp *dp; --2.49.1
PATCH v2 2/34 drm/i915/dp_link_caps: Factor out helper to get link config by index
In reply to Imre DeakFactor out a helper that looks up a link configuration by index. This provides the link configuration directly, avoiding the indirect conversion via the packed config entry.
--- .../gpu/drm/i915/display/intel_dp_link_caps.c | 18 ++++++++++++++---- 1 file changed, 14 insertions(+), 4 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +14 -4
@@ -235,6 +235,16 @@ static int intel_dp_link_config_lane_count(const struct intel_dp_link_config_entreturn 1 << lce->lane_count_exp; } +static void +to_intel_dp_link_config (struct intel_dp_link_caps *link_caps, +int config_idx,struct intel_dp_link_config *config) +{ +const struct intel_dp_link_config_entry *lce = &link_caps->configs[config_idx]; + + config->rate =intel_dp_link_config_rate (link_caps, lce); + config->lane_count =intel_dp_link_config_lane_count (lce); +} +static void set_max_link_limits_no_update (struct intel_dp_link_caps *link_caps,const struct intel_dp_link_config *max_link_limits) {
@@ -401,15 +411,15 @@ void intel_dp_link_config_get(struct intel_dp_link_caps *link_caps, int idx, int *link_rate, int *lane_count) { struct intel_display *display = to_intel_display(link_caps->dp); -const struct intel_dp_link_config_entry *lce; +struct intel_dp_link_config config;if (drm_WARN_ON (display->drm, idx <0 || idx >= link_caps->num_configs)) idx =0 ; - lce = &link_caps->configs[idx]; +to_intel_dp_link_config (link_caps, idx, &config); - *link_rate =intel_dp_link_config_rate (link_caps, lce); - *lane_count =intel_dp_link_config_lane_count (lce); + *link_rate = config.rate; + *lane_count = config.lane_count; } int intel_dp_link_config_index(struct intel_dp_link_caps *link_caps,
Signature · 1 line
2.49.1
RE: [PATCH v2 02/34] drm/i915/dp_link_caps: Factor out helper to get link config by index
Quoted 8 lines
Subject: [PATCH v2 02/34] drm/i915/dp_link_caps: Factor out helper to get link config by index
Factor out a helper that looks up a link configuration by index. This provides the link configuration directly, avoiding the indirect conversion via the packed config entry.
Signed-off-by Imre Deak <[email protected]>
LGTM,
Quoted 50 lines
--- .../gpu/drm/i915/display/intel_dp_link_caps.c | 18 ++++++++++++++---- 1 file changed, 14 insertions(+), 4 deletions(-)drivers/gpu/drm/i915/display/intel_dp_link_caps.c +0
-0@@ -235,6 +235,16 @@ static int intel_dp_link_config_lane_count(const struct
intel_dp_link_config_entdrivers/gpu/drm/i915/display/intel_dp_link_caps.c +10
-0return 1 << lce->lane_count_exp; } +static void +to_intel_dp_link_config (struct intel_dp_link_caps *link_caps, +int config_idx,struct intel_dp_link_config *config) { +const struct intel_dp_link_config_entry *lce = +&link_caps->configs[config_idx]; + + config->rate =intel_dp_link_config_rate (link_caps, lce); + config->lane_count =intel_dp_link_config_lane_count (lce); +} + static void set_max_link_limits_no_update(struct intel_dp_link_caps
*link_caps,
const structintel_dp_link_config*max_link_limits) { @@ -401,15 +411,15 @@ void intel_dp_link_config_get(structintel_dp_link_caps*link_caps,drivers/gpu/drm/i915/display/intel_dp_link_caps.c +1
-1int idx, int *link_rate, int *lane_count) { struct intel_display *display = to_intel_display(link_caps->dp); -const struct intel_dp_link_config_entry *lce; +struct intel_dp_link_config config; if (drm_WARN_ON(display->drm, idx < 0 || idx >= link_caps-Quoted 1 line
num_configs))drivers/gpu/drm/i915/display/intel_dp_link_caps.c +3
-4idx =0 ; - lce = &link_caps->configs[idx]; +to_intel_dp_link_config (link_caps, idx, &config); - *link_rate =intel_dp_link_config_rate (link_caps, lce); - *lane_count =intel_dp_link_config_lane_count (lce); + *link_rate = config.rate; + *lane_count = config.lane_count; } int intel_dp_link_config_index(struct intel_dp_link_caps *link_caps, --2.49.1
PATCH v2 3/34 drm/i915/dp_link_caps: Add support for link rate, lane count iteration orders
In reply to Imre DeakAdd support for iterating configurations in either link rate/lane count or lane count/link rate order. Both orders are required for DP SST connector types: the former for computing the connector state during a modeset, and the latter for selecting a fallback configuration after a link training failure.
--- .../gpu/drm/i915/display/intel_dp_link_caps.c | 50 +++++++++++++++++++ 1 file changed, 50 insertions(+)
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +50 -0
@@ -122,6 +122,13 @@ struct intel_dp_link_caps { u8 lane_count_exp:INTEL_DP_LANE_COUNT_EXP_BITS; } configs[INTEL_DP_MAX_LINK_CONFIGS ]; +/* +* Indices to intel_dp_link_caps::configs[] in rate/lane count, +* lane_count/rate order. +*/ +u8 rate_lane_map[INTEL_DP_MAX_LINK_CONFIGS ]; +u8 lane_rate_map[INTEL_DP_MAX_LINK_CONFIGS ]; +/* * Forced parameters requested via debugfs. Remains set across sink * disconnects.
@@ -350,6 +357,34 @@ static int link_config_cmp_by_bw(const void *a, const void *b, const void *p)intel_dp_link_config_rate (link_caps, lce_b); } +static int link_config_cmp_by_rate_lane (const void *a,const void *b,const void *p) +{ +const struct intel_dp_link_caps *link_caps = p; +u8 *lce_a_idx = (u8 *)a; +u8 *lce_b_idx = (u8 *)b; +const struct intel_dp_link_config_entry *lce_a = &link_caps->configs[*lce_a_idx]; +const struct intel_dp_link_config_entry *lce_b = &link_caps->configs[*lce_b_idx]; + +if (lce_a->link_rate_idx != lce_b->link_rate_idx) +return lce_a->link_rate_idx - lce_b->link_rate_idx; + +return lce_a->lane_count_exp - lce_b->lane_count_exp; +} + +static int link_config_cmp_by_lane_rate (const void *a,const void *b,const void *p) +{ +const struct intel_dp_link_caps *link_caps = p; +u8 *lce_a_idx = (u8 *)a; +u8 *lce_b_idx = (u8 *)b; +const struct intel_dp_link_config_entry *lce_a = &link_caps->configs[*lce_a_idx]; +const struct intel_dp_link_config_entry *lce_b = &link_caps->configs[*lce_b_idx]; + +if (lce_a->lane_count_exp != lce_b->lane_count_exp) +return lce_a->lane_count_exp - lce_b->lane_count_exp; + +return lce_a->link_rate_idx - lce_b->link_rate_idx; +} +/* Return %true if the supported link parameters have changed. */ bool intel_dp_link_caps_update (struct intel_dp_link_caps *link_caps,const int *rates,int num_rates,int max_lane_count)
@@ -404,6 +439,21 @@ bool intel_dp_link_caps_update(struct intel_dp_link_caps *link_caps, link_config_cmp_by_bw,NULL , intel_dp); +for (i =0 ; i < link_caps->num_configs; i++) { + link_caps->rate_lane_map[i] = i; + link_caps->lane_rate_map[i] = i; + } + +sort_r (link_caps->rate_lane_map, link_caps->num_configs, +sizeof (link_caps->rate_lane_map[0 ]), + link_config_cmp_by_rate_lane,NULL , + link_caps); + +sort_r (link_caps->lane_rate_map, link_caps->num_configs, +sizeof (link_caps->lane_rate_map[0 ]), + link_config_cmp_by_lane_rate,NULL , + link_caps); +return link_params_changed; }
Signature · 1 line
2.49.1
RE: [PATCH v2 03/34] drm/i915/dp_link_caps: Add support for link rate, lane count iteration orders
Quoted 9 lines
Subject: [PATCH v2 03/34] drm/i915/dp_link_caps: Add support for link rate, lane count iteration orders
Add support for iterating configurations in either link rate/lane count or lane count/link rate order. Both orders are required for DP SST connector types: the former for computing the connector state during a modeset, and the latter for selecting a fallback configuration after a link training failure.
Signed-off-by Imre Deak <[email protected]>
LGTM,
Quoted 85 lines
--- .../gpu/drm/i915/display/intel_dp_link_caps.c | 50 +++++++++++++++++++ 1 file changed, 50 insertions(+)drivers/gpu/drm/i915/display/intel_dp_link_caps.c +35
-0@@ -122,6 +122,13 @@ struct intel_dp_link_caps { u8 lane_count_exp:INTEL_DP_LANE_COUNT_EXP_BITS; } configs[INTEL_DP_MAX_LINK_CONFIGS ]; +/* +* Indices to intel_dp_link_caps::configs[] in rate/lane count, +* lane_count/rate order. +*/ +u8 rate_lane_map[INTEL_DP_MAX_LINK_CONFIGS ]; +u8 lane_rate_map[INTEL_DP_MAX_LINK_CONFIGS ]; +/* * Forced parameters requested via debugfs. Remains set across sink * disconnects. @@ -350,6 +357,34 @@ static int link_config_cmp_by_bw(const void *a, const void *b, const void *p)intel_dp_link_config_rate (link_caps ,lce_b ); } +static int link_config_cmp_by_rate_lane (const void *a,const void *b, +const void *p) { +const struct intel_dp_link_caps *link_caps = p; +u8 *lce_a_idx = (u8 *)a; +u8 *lce_b_idx = (u8 *)b; +const struct intel_dp_link_config_entry *lce_a = &link_caps- >configs[*lce_a_idx]; +const struct intel_dp_link_config_entry *lce_b = +&link_caps->configs[*lce_b_idx]; + +if (lce_a->link_rate_idx != lce_b->link_rate_idx) +return lce_a->link_rate_idx - lce_b->link_rate_idx; + +return lce_a->lane_count_exp - lce_b->lane_count_exp; } + +static int link_config_cmp_by_lane_rate (const void *a,const void *b, +const void *p) { +const struct intel_dp_link_caps *link_caps = p; +u8 *lce_a_idx = (u8 *)a; +u8 *lce_b_idx = (u8 *)b; +const struct intel_dp_link_config_entry *lce_a = &link_caps- >configs[*lce_a_idx]; +const struct intel_dp_link_config_entry *lce_b = +&link_caps->configs[*lce_b_idx]; + +if (lce_a->lane_count_exp != lce_b->lane_count_exp) +return lce_a->lane_count_exp - lce_b->lane_count_exp; + +return lce_a->link_rate_idx - lce_b->link_rate_idx; } +/* Return %true if the supported link parameters have changed. */ bool intel_dp_link_caps_update(struct
intel_dp_link_caps*link_caps,
const int *rates, intnum_rates, intmax_lane_count) @@ -404,6 +439,21 @@ bool intel_dp_link_caps_update(structintel_dp_link_caps*link_caps,drivers/gpu/drm/i915/display/intel_dp_link_caps.c +15
-1link_config_cmp_by_bw,NULL , intel_dp); +for (i =0 ; i < link_caps->num_configs; i++) { + link_caps->rate_lane_map[i] = i; + link_caps->lane_rate_map[i] = i; + } + +sort_r (link_caps->rate_lane_map, link_caps->num_configs, +sizeof (link_caps->rate_lane_map[0 ]), + link_config_cmp_by_rate_lane,NULL , + link_caps); + +sort_r (link_caps->lane_rate_map, link_caps->num_configs, +sizeof (link_caps->lane_rate_map[0 ]), + link_config_cmp_by_lane_rate,NULL , + link_caps); +return link_params_changed; } --2.49.1
PATCH v2 4/34 drm/i915/dp_link_caps: Add link configuration iterator
In reply to Imre DeakAdd helpers to iterate over the allowed and optionally filtered set of link configurations in a given order.
Taking into account disabled configurations will be added later when adding support for disabling configurations.
Use the BW order in descending direction by default.
v2:
- Keep the iteration state in an iteration object. (Jani)
- Use a filter object instead of exposing configuration indices. (Jani)
- Move changes adding helpers required to setup the iteration object to this patch.
--- .../gpu/drm/i915/display/intel_dp_link_caps.c | 213 ++++++++++++++++++ .../gpu/drm/i915/display/intel_dp_link_caps.h | 106 +++++++++ 2 files changed, 319 insertions(+)
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +213 -0
@@ -16,6 +16,7 @@#include "intel_display_core.h" #include "intel_display_types.h" +#include "intel_display_utils.h" #include "intel_dp.h" #include "intel_dp_link_caps.h"
@@ -146,6 +147,18 @@ struct intel_dp_link_caps {*/ struct intel_dp_link_config max_limits; }; +static_assert (BITS_PER_TYPE (((struct intel_dp_link_caps_filter *)NULL )->config_mask) >= +ARRAY_SIZE (((struct intel_dp_link_caps *)NULL )->configs)); + +static struct intel_dp_link_caps_order bw_desc_config_order (void ) +{ +struct intel_dp_link_caps_order order = { + .key =INTEL_DP_LINK_CAPS_ORDER_KEY_BW , + .dir =INTEL_DP_LINK_CAPS_ORDER_DIR_DESC , + }; + +return order; +}/* Get length of common rates array potentially limited by max_rate. */ int intel_dp_common_len_rate_limit(struct intel_dp_link_caps *link_caps,
@@ -252,6 +265,206 @@ to_intel_dp_link_config(struct intel_dp_link_caps *link_caps, config->lane_count =intel_dp_link_config_lane_count (lce); } +static int +iter_pos_to_idx (struct intel_dp_link_caps *link_caps, +struct intel_dp_link_caps_order config_order, +int iter_pos) +{ +int config_idx; + +if (!in_range (iter_pos,0 , link_caps->num_configs)) +return -1 ; + +switch (config_order.dir) { +case INTEL_DP_LINK_CAPS_ORDER_DIR_ASC : +break ; +case INTEL_DP_LINK_CAPS_ORDER_DIR_DESC : + iter_pos = link_caps->num_configs -1 - iter_pos; + +break ; +default : +MISSING_CASE (config_order.dir); + +return -1 ; + } + +switch (config_order.key) { +case INTEL_DP_LINK_CAPS_ORDER_KEY_BW : + config_idx = iter_pos; + +break ; +case INTEL_DP_LINK_CAPS_ORDER_KEY_RATE_LANE : + config_idx = link_caps->rate_lane_map[iter_pos]; + +break ; +case INTEL_DP_LINK_CAPS_ORDER_KEY_LANE_RATE : + config_idx = link_caps->lane_rate_map[iter_pos]; + +break ; +default : +MISSING_CASE (config_order.key); + +return -1 ; + } + +return config_idx; +} + +static bool iter_get_next_config (struct intel_dp_link_caps_iter *iter, +struct intel_dp_link_config *config) +{ +while (true) { +int config_idx; + + iter->pos++; + + config_idx =iter_pos_to_idx (iter->link_caps, iter->order, iter->pos); +if (config_idx <0 ) { + iter->pos =-1 ; + *config =INTEL_DP_LINK_CONFIG_NULL ; + +break ; + } + +if (!(BIT (config_idx) & iter->filter.config_mask)) +continue ; + +to_intel_dp_link_config (iter->link_caps, config_idx, config); + +break ; + } + +return iter->pos >=0 ; +} + +static void iter_start (struct intel_dp_link_caps_iter *iter, +struct intel_dp_link_caps *link_caps, +struct intel_dp_link_caps_order order, +struct intel_dp_link_caps_filter filter) +{ + iter->link_caps = link_caps; + iter->pos =-1 ; + iter->order = order; + iter->filter = filter; + + iter->get_next_config = iter_get_next_config; +} + +static struct intel_dp_link_caps_filter +calc_allowed_config_filter (struct intel_dp_link_caps *link_caps, +struct intel_dp_link_caps_filter enabled_configs, +const struct intel_dp_link_config *max_limits, +const struct intel_dp_link_config *forced_params) +{ +struct intel_dp_link_caps_filter allowed_configs =INTEL_DP_LINK_CAPS_FILTER_NONE ; +struct intel_dp_link_caps_order order =bw_desc_config_order (); +struct intel_dp_link_caps_iter iter; +struct intel_dp_link_config config; + +iter_start (&iter, link_caps, order, enabled_configs); +for_each_dp_link_config (&iter, &config) { +if (forced_params->rate && + forced_params->rate != config.rate) +continue ; + +if (forced_params->lane_count && + forced_params->lane_count != config.lane_count) +continue ; + +if (config.rate > max_limits->rate) +continue ; + +if (config.lane_count > max_limits->lane_count) +continue ; + + allowed_configs.config_mask |=BIT (iter_pos_to_idx (link_caps, order, iter.pos)); + } +intel_dp_link_caps_iter_end (&iter); + +return allowed_configs; +} + +/* +* get_allowed_config_filter - get filter for the currently allowed configs +* @link_caps: link capabilities state +* +* Return: +* Filter of link configurations allowed after applying the current +* maximum link limits, and further narrowing them by removing any disabled +* configuration and limiting to forced link parameters. +* +* See also: +* - intel_dp_link_caps_get_max_limits() +* - intel_dp_link_caps_get_forced_params() +*/ +static struct intel_dp_link_caps_filter +get_allowed_config_filter (struct intel_dp_link_caps *link_caps) +{ +struct intel_dp_link_config forced_params; + +intel_dp_link_caps_get_forced_params (link_caps, &forced_params); + +/* TODO: Get filter for enabled configs. */ +return calc_allowed_config_filter (link_caps,INTEL_DP_LINK_CAPS_FILTER_ALL , + &link_caps->max_limits, &forced_params); +} + +void intel_dp_link_caps_iter_start (struct intel_dp_link_caps_iter *iter, +struct intel_dp_link_caps *link_caps, +struct intel_dp_link_caps_order order, +struct intel_dp_link_caps_filter filter) +{ + filter.config_mask &=get_allowed_config_filter (link_caps).config_mask; + +iter_start (iter, link_caps, order, filter); +} + +void intel_dp_link_caps_iter_end (struct intel_dp_link_caps_iter *iter) +{ +memset (iter,0 ,sizeof (*iter)); +} + +static int find_config_idx (struct intel_dp_link_caps *link_caps, +struct intel_dp_link_caps_filter filter, +const struct intel_dp_link_config *link_config) +{ +struct intel_dp_link_caps_order order =bw_desc_config_order (); +struct intel_dp_link_config iter_config; +struct intel_dp_link_caps_iter iter; +int pos =-1 ; + +intel_dp_link_caps_iter_start (&iter, link_caps, order, filter); +for_each_dp_link_config (&iter, &iter_config) { +if (iter_config.rate == link_config->rate && + iter_config.lane_count == link_config->lane_count) { + pos = iter.pos; + +break ; + } + } +intel_dp_link_caps_iter_end (&iter); + +if (pos <0 ) +return pos; + +return iter_pos_to_idx (link_caps, order, pos); +} + +bool intel_dp_link_caps_filter_add (struct intel_dp_link_caps *link_caps, +struct intel_dp_link_caps_filter *filter, +const struct intel_dp_link_config *config) +{ +int idx; + + idx =find_config_idx (link_caps,get_allowed_config_filter (link_caps), config); +if (idx <0 ) +return false; + + filter->config_mask |=BIT (idx); + +return true; +} +static void set_max_link_limits_no_update (struct intel_dp_link_caps *link_caps,const struct intel_dp_link_config *max_link_limits) {
drivers/gpu/drm/i915/display/intel_dp_link_caps.h +106 -0
124 lines not on this page · raw message
Signature · 1 line
2.49.1
RE: [PATCH v2 04/34] drm/i915/dp_link_caps: Add link configuration iterator
Quoted 11 lines
Subject: [PATCH v2 04/34] drm/i915/dp_link_caps: Add link configuration iterator
Add helpers to iterate over the allowed and optionally filtered set of link configurations in a given order.
Taking into account disabled configurations will be added later when adding support for disabling configurations.
Use the BW order in descending direction by default.
Quoted 7 lines
v2:
- Keep the iteration state in an iteration object. (Jani)
- Use a filter object instead of exposing configuration indices. (Jani)
- Move changes adding helpers required to setup the iteration object to this patch.Signed-off-by Imre Deak <[email protected]>
LGTM,
Quoted 376 lines
--- .../gpu/drm/i915/display/intel_dp_link_caps.c | 213 ++++++++++++++++++ .../gpu/drm/i915/display/intel_dp_link_caps.h | 106 +++++++++ 2 files changed, 319 insertions(+)drivers/gpu/drm/i915/display/intel_dp_link_caps.c +2
-0@@ -16,6 +16,7 @@#include "intel_display_core.h" #include "intel_display_types.h" +#include "intel_display_utils.h" #include "intel_dp.h" #include "intel_dp_link_caps.h" @@ -146,6 +147,18 @@ struct intel_dp_link_caps {*/ struct intel_dp_link_config max_limits; }; +static_assert(BITS_PER_TYPE(((struct intel_dp_link_caps_filter *)NULL)-Quoted 1 line
config_mask) >=drivers/gpu/drm/i915/display/intel_dp_link_caps.c +10
-0+ ARRAY_SIZE(((struct intel_dp_link_caps *)NULL)->configs)); + +static struct intel_dp_link_caps_order bw_desc_config_order (void ) { +struct intel_dp_link_caps_order order = { + .key =INTEL_DP_LINK_CAPS_ORDER_KEY_BW , + .dir =INTEL_DP_LINK_CAPS_ORDER_DIR_DESC , + }; + +return order; +}/* Get length of common rates array potentially limited by max_rate. */ int intel_dp_common_len_rate_limit(struct
intel_dp_link_caps*link_caps, @@ - 252,6 +265,206 @@ to_intel_dp_link_config(structintel_dp_link_caps*link_caps,drivers/gpu/drm/i915/display/intel_dp_link_caps.c +53
-0config->lane_count =intel_dp_link_config_lane_count (lce); } +static int +iter_pos_to_idx (struct intel_dp_link_caps *link_caps, +struct intel_dp_link_caps_order config_order, +int iter_pos) +{ +int config_idx; + +if (!in_range (iter_pos,0 , link_caps->num_configs)) +return -1 ; + +switch (config_order.dir) { +case INTEL_DP_LINK_CAPS_ORDER_DIR_ASC : +break ; +case INTEL_DP_LINK_CAPS_ORDER_DIR_DESC : + iter_pos = link_caps->num_configs -1 - iter_pos; + +break ; +default : +MISSING_CASE (config_order.dir); + +return -1 ; + } + +switch (config_order.key) { +case INTEL_DP_LINK_CAPS_ORDER_KEY_BW : + config_idx = iter_pos; + +break ; +case INTEL_DP_LINK_CAPS_ORDER_KEY_RATE_LANE : + config_idx = link_caps->rate_lane_map[iter_pos]; + +break ; +case INTEL_DP_LINK_CAPS_ORDER_KEY_LANE_RATE : + config_idx = link_caps->lane_rate_map[iter_pos]; + +break ; +default : +MISSING_CASE (config_order.key); + +return -1 ; + } + +return config_idx; +} + +static bool iter_get_next_config (struct intel_dp_link_caps_iter *iter, +struct intel_dp_link_config *config) { +while (true) { +int config_idx; + + iter->pos++; + + config_idx = iter_pos_to_idx(iter->link_caps, iter->order, iter-Quoted 1 line
pos);
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +35
-0+if (config_idx <0 ) { + iter->pos =-1 ; + *config =INTEL_DP_LINK_CONFIG_NULL ; + +break ; + } + +if (!(BIT (config_idx) & iter->filter.config_mask)) +continue ; + +to_intel_dp_link_config (iter->link_caps, config_idx, config); + +break ; + } + +return iter->pos >=0 ; +} + +static void iter_start (struct intel_dp_link_caps_iter *iter, +struct intel_dp_link_caps *link_caps, +struct intel_dp_link_caps_order order, +struct intel_dp_link_caps_filter filter) { + iter->link_caps = link_caps; + iter->pos =-1 ; + iter->order = order; + iter->filter = filter; + + iter->get_next_config = iter_get_next_config; } + +static struct intel_dp_link_caps_filter +calc_allowed_config_filter (struct intel_dp_link_caps *link_caps, +struct intel_dp_link_caps_filter enabled_configs, +const struct intel_dp_link_config *max_limits, +const struct intel_dp_link_config *forced_params) { + struct intel_dp_link_caps_filter allowed_configs =
INTEL_DP_LINK_CAPS_FILTER_NONE;drivers/gpu/drm/i915/display/intel_dp_link_caps.c +21
-0+struct intel_dp_link_caps_order order =bw_desc_config_order (); +struct intel_dp_link_caps_iter iter; +struct intel_dp_link_config config; + +iter_start (&iter, link_caps, order, enabled_configs); +for_each_dp_link_config (&iter, &config) { +if (forced_params->rate && + forced_params->rate != config.rate) +continue ; + +if (forced_params->lane_count && + forced_params->lane_count != config.lane_count) +continue ; + +if (config.rate > max_limits->rate) +continue ; + +if (config.lane_count > max_limits->lane_count) +continue ; + + allowed_configs.config_mask |= BIT(iter_pos_to_idx(link_caps,order, iter.pos));
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +29
-0+ } +intel_dp_link_caps_iter_end (&iter); + +return allowed_configs; +} + +/* +* get_allowed_config_filter - get filter for the currently allowed +configs +* @link_caps: link capabilities state +* +* Return: +* Filter of link configurations allowed after applying the current +* maximum link limits, and further narrowing them by removing any +disabled +* configuration and limiting to forced link parameters. +* +* See also: +* - intel_dp_link_caps_get_max_limits() +* - intel_dp_link_caps_get_forced_params() +*/ +static struct intel_dp_link_caps_filter +get_allowed_config_filter (struct intel_dp_link_caps *link_caps) { +struct intel_dp_link_config forced_params; + +intel_dp_link_caps_get_forced_params (link_caps, &forced_params); + +/* TODO: Get filter for enabled configs. */ + return calc_allowed_config_filter(link_caps,
INTEL_DP_LINK_CAPS_FILTER_ALL,drivers/gpu/drm/i915/display/intel_dp_link_caps.c +1
-0+ &link_caps->max_limits,
&forced_params); }drivers/gpu/drm/i915/display/intel_dp_link_caps.c +45
-0+ +void intel_dp_link_caps_iter_start (struct intel_dp_link_caps_iter *iter, +struct intel_dp_link_caps *link_caps, +struct intel_dp_link_caps_order order, +struct intel_dp_link_caps_filter filter) { + filter.config_mask &= +get_allowed_config_filter (link_caps).config_mask; + +iter_start (iter, link_caps, order, filter); } + +void intel_dp_link_caps_iter_end (struct intel_dp_link_caps_iter *iter) +{ +memset (iter,0 ,sizeof (*iter)); +} + +static int find_config_idx (struct intel_dp_link_caps *link_caps, +struct intel_dp_link_caps_filter filter, +const struct intel_dp_link_config *link_config) { +struct intel_dp_link_caps_order order =bw_desc_config_order (); +struct intel_dp_link_config iter_config; +struct intel_dp_link_caps_iter iter; +int pos =-1 ; + +intel_dp_link_caps_iter_start (&iter, link_caps, order, filter); +for_each_dp_link_config (&iter, &iter_config) { +if (iter_config.rate == link_config->rate && + iter_config.lane_count == link_config->lane_count) { + pos = iter.pos; + +break ; + } + } +intel_dp_link_caps_iter_end (&iter); + +if (pos <0 ) +return pos; + +return iter_pos_to_idx (link_caps, order, pos); } + +bool intel_dp_link_caps_filter_add (struct intel_dp_link_caps *link_caps, +struct intel_dp_link_caps_filter *filter, +const struct intel_dp_link_config *config) { +int idx; + + idx = find_config_idx(link_caps, get_allowed_config_filter(link_caps),config);
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +8
-0+if (idx <0 ) +return false; + + filter->config_mask |=BIT (idx); + +return true; +} + static void set_max_link_limits_no_update(struct intel_dp_link_caps
*link_caps,
const structintel_dp_link_config*max_link_limits) { diff --gita/drivers/gpu/drm/i915/display/intel_dp_link_caps.hb/drivers/gpu/drm/i915/display/intel_dp_link_caps.h
indexaf9028e7cb987..5ea87f112c13a100644drivers/gpu/drm/i915/display/intel_dp_link_caps.h +104
-0@@ -4,6 +4,7 @@#ifndef __INTEL_DP_LINK_CAPS_H__#define __INTEL_DP_LINK_CAPS_H__ +#include <linux/bitops.h> #include <linux/types.h> struct intel_connector ;@@ -11,6 +12,107 @@ struct intel_dp;struct intel_dp_link_caps ;struct intel_dp_link_config ; +/** +* enum intel_dp_link_caps_order_key - key used to order configurations +* @INTEL_DP_LINK_CAPS_ORDER_KEY_BW: +* Order configurations by bandwidth, then by link rate. +* @INTEL_DP_LINK_CAPS_ORDER_KEY_RATE_LANE: +* Order configurations by link rate, then by lane count. +* @INTEL_DP_LINK_CAPS_ORDER_KEY_LANE_RATE: +* Order configurations by lane count, then by link rate. +* @INTEL_DP_LINK_CAPS_ORDER_KEY_NUM: +* Number of ordering keys. +* +* Selects how a caller wants the configuration table to be ordered, +* together with an &enum intel_dp_link_caps_order_direction, for +* iteration queries. +* +* See also: +* - &struct intel_dp_link_caps_order +*/ +enum intel_dp_link_caps_order_key { +INTEL_DP_LINK_CAPS_ORDER_KEY_BW , +INTEL_DP_LINK_CAPS_ORDER_KEY_RATE_LANE , +INTEL_DP_LINK_CAPS_ORDER_KEY_LANE_RATE , + +INTEL_DP_LINK_CAPS_ORDER_KEY_NUM +}; + +/** +* enum intel_dp_link_caps_order_direction - iteration direction +* @INTEL_DP_LINK_CAPS_ORDER_DIR_ASC: +* Iterate in ascending order according to the selected ordering key. +* @INTEL_DP_LINK_CAPS_ORDER_DIR_DESC: +* Iterate in descending order according to the selected ordering key. +* @INTEL_DP_LINK_CAPS_ORDER_DIR_NUM: +* Number of ordering directions. +* +* Selects the direction associated with an +* &enum intel_dp_link_caps_order_key for iteration queries. +* +* See also: +* - &struct intel_dp_link_caps_order +*/ +enum intel_dp_link_caps_order_direction { +INTEL_DP_LINK_CAPS_ORDER_DIR_ASC , +INTEL_DP_LINK_CAPS_ORDER_DIR_DESC , + +INTEL_DP_LINK_CAPS_ORDER_DIR_NUM +}; + +/** +* struct intel_dp_link_caps_order - configuration ordering +* @key: +* Key used to order configurations. +* @dir: +* Direction of the selected ordering. +* +* Describes an iteration order for link configurations. +* +* See also: +* - for_each_dp_link_config() +*/ +struct intel_dp_link_caps_order { +enum intel_dp_link_caps_order_key key; +enum intel_dp_link_caps_order_direction dir; }; + +struct intel_dp_link_caps_filter { +u32 config_mask; +}; + +#define INTEL_DP_LINK_CAPS_FILTER_NONE \ + ((struct intel_dp_link_caps_filter){ .config_mask = 0 }) +#define INTEL_DP_LINK_CAPS_FILTER_ALL \ + ((struct intel_dp_link_caps_filter){ .config_mask = (u32)-1 }) + +struct intel_dp_link_caps_iter { +struct intel_dp_link_caps *link_caps; +int pos; +struct intel_dp_link_caps_order order; +struct intel_dp_link_caps_filter filter; + +bool (*get_next_config)(struct intel_dp_link_caps_iter *iter, +struct intel_dp_link_config *config); }; + +/** +* for_each_dp_link_config - iterate allowed link configurations +* @__iter: +* &struct intel_dp_link_caps_iter being iterated +* @__config: +* pointer to &struct intel_dp_link_config filled for each match +*/ +#define for_each_dp_link_config (__iter, __config) \ + while ((__iter)->get_next_config((__iter), (__config))) + +void intel_dp_link_caps_iter_start (struct intel_dp_link_caps_iter *iter, +struct intel_dp_link_caps *link_caps, +struct intel_dp_link_caps_order order, +struct intel_dp_link_caps_filter filter); + +void intel_dp_link_caps_iter_end (struct intel_dp_link_caps_iter *iter); +int intel_dp_common_len_rate_limit (struct intel_dp_link_caps *link_caps,int max_rate);int intel_dp_common_rate (struct intel_dp_link_caps *link_caps,int index);@@ -29,6 +131,10 @@ int intel_dp_link_config_index(struct intel_dp_link_caps *link_caps, void intel_dp_link_config_get(struct intel_dp_link_caps *link_caps,int idx,int *link_rate,int *lane_count); +bool intel_dp_link_caps_filter_add (struct intel_dp_link_caps *link_caps, +struct intel_dp_link_caps_filter *filter, +const struct intel_dp_link_config *config); +void intel_dp_link_caps_get_max_limits (struct intel_dp_link_caps *link_caps,struct intel_dp_link_config *max_link_limits); bool intel_dp_link_caps_set_max_limits(struct
intel_dp_link_caps*link_caps,
--
2.49.1
PATCH v2 5/34 drm/i915/dp_link_caps: Add helper to get iteration order for a connector
In reply to Imre DeakAdd helper to select the link configuration iteration order for a connector during state computation and fallback selection. This keeps the connector-specific ordering policy in the link caps module.
v2: Add helper to get the order for fallback selection as well.
--- .../gpu/drm/i915/display/intel_dp_link_caps.c | 50 +++++++++++++++++++ .../gpu/drm/i915/display/intel_dp_link_caps.h | 5 ++ 2 files changed, 55 insertions(+)
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +50 -0
@@ -160,6 +160,56 @@ static struct intel_dp_link_caps_order bw_desc_config_order(void)return order; } +static enum intel_dp_link_caps_order_key +connector_compute_order_key (bool is_mst) +{ +if (is_mst) +return INTEL_DP_LINK_CAPS_ORDER_KEY_BW ; +else +return INTEL_DP_LINK_CAPS_ORDER_KEY_RATE_LANE ; +} + +static enum intel_dp_link_caps_order_key +connector_fallback_order_key (bool is_mst) +{ +if (is_mst) +return INTEL_DP_LINK_CAPS_ORDER_KEY_BW ; +else +return INTEL_DP_LINK_CAPS_ORDER_KEY_LANE_RATE ; +} + +static enum intel_dp_link_caps_order_direction +connector_compute_order_dir (bool is_mst,bool use_max_params) +{ +if (is_mst || use_max_params) +return INTEL_DP_LINK_CAPS_ORDER_DIR_DESC ; +else +return INTEL_DP_LINK_CAPS_ORDER_DIR_ASC ; +} + +struct intel_dp_link_caps_order +intel_dp_link_caps_connector_compute_order (struct intel_connector *connector) +{ +struct intel_dp *intel_dp =intel_attached_dp (connector); +struct intel_dp_link_caps_order order = { + .key =connector_compute_order_key (connector->mst.dp), + .dir =connector_compute_order_dir (connector->mst.dp, intel_dp->use_max_params) + }; + +return order; +} + +struct intel_dp_link_caps_order +intel_dp_link_caps_connector_fallback_order (bool is_mst) +{ +struct intel_dp_link_caps_order order = { + .key =connector_fallback_order_key (is_mst), + .dir =INTEL_DP_LINK_CAPS_ORDER_DIR_DESC , + }; + +return order; +} +/* Get length of common rates array potentially limited by max_rate. */ int intel_dp_common_len_rate_limit (struct intel_dp_link_caps *link_caps,int max_rate)
drivers/gpu/drm/i915/display/intel_dp_link_caps.h +5 -0
@@ -113,6 +113,11 @@ void intel_dp_link_caps_iter_start(struct intel_dp_link_caps_iter *iter,void intel_dp_link_caps_iter_end (struct intel_dp_link_caps_iter *iter); +struct intel_dp_link_caps_order +intel_dp_link_caps_connector_compute_order (struct intel_connector *connector); +struct intel_dp_link_caps_order +intel_dp_link_caps_connector_fallback_order (bool is_mst); +int intel_dp_common_len_rate_limit (struct intel_dp_link_caps *link_caps,int max_rate);int intel_dp_common_rate (struct intel_dp_link_caps *link_caps,int index);
Signature · 1 line
2.49.1
RE: [PATCH v2 05/34] drm/i915/dp_link_caps: Add helper to get iteration order for a connector
Quoted 10 lines
Subject: [PATCH v2 05/34] drm/i915/dp_link_caps: Add helper to get iteration order for a connector
Add helper to select the link configuration iteration order for a connector during state computation and fallback selection. This keeps the connector- specific ordering policy in the link caps module.
v2: Add helper to get the order for fallback selection as well.
Signed-off-by Imre Deak <[email protected]>
LGTM,
Quoted 84 lines
--- .../gpu/drm/i915/display/intel_dp_link_caps.c | 50 +++++++++++++++++++ .../gpu/drm/i915/display/intel_dp_link_caps.h | 5 ++ 2 files changed, 55 insertions(+)drivers/gpu/drm/i915/display/intel_dp_link_caps.c +45
-0@@ -160,6 +160,56 @@ static struct intel_dp_link_caps_orderbw_desc_config_order (void ) return order; } +static enum intel_dp_link_caps_order_key +connector_compute_order_key (bool is_mst) { +if (is_mst) +return INTEL_DP_LINK_CAPS_ORDER_KEY_BW ; +else +return INTEL_DP_LINK_CAPS_ORDER_KEY_RATE_LANE ; +} + +static enum intel_dp_link_caps_order_key +connector_fallback_order_key (bool is_mst) { +if (is_mst) +return INTEL_DP_LINK_CAPS_ORDER_KEY_BW ; +else +return INTEL_DP_LINK_CAPS_ORDER_KEY_LANE_RATE ; +} + +static enum intel_dp_link_caps_order_direction +connector_compute_order_dir (bool is_mst,bool use_max_params) { +if (is_mst || use_max_params) +return INTEL_DP_LINK_CAPS_ORDER_DIR_DESC ; +else +return INTEL_DP_LINK_CAPS_ORDER_DIR_ASC ; } + +struct intel_dp_link_caps_order +intel_dp_link_caps_connector_compute_order (struct intel_connector +*connector) { +struct intel_dp *intel_dp =intel_attached_dp (connector); +struct intel_dp_link_caps_order order = { + .key =connector_compute_order_key (connector->mst.dp), + .dir =connector_compute_order_dir (connector->mst.dp, intel_dp->use_max_params) + }; + +return order; +} + +struct intel_dp_link_caps_order +intel_dp_link_caps_connector_fallback_order (bool is_mst) { +struct intel_dp_link_caps_order order = { + .key =connector_fallback_order_key (is_mst), + .dir =INTEL_DP_LINK_CAPS_ORDER_DIR_DESC , + }; + +return order; +} +/* Get length of common rates array potentially limited by max_rate. */ int intel_dp_common_len_rate_limit(struct
intel_dp_link_caps*link_caps,drivers/gpu/drm/i915/display/intel_dp_link_caps.c +0
-0int max_rate)drivers/gpu/drm/i915/display/intel_dp_link_caps.h +5
-0@@ -113,6 +113,11 @@ void intel_dp_link_caps_iter_start(structintel_dp_link_caps_iter *iter, void intel_dp_link_caps_iter_end(struct intel_dp_link_caps_iter *iter); +struct intel_dp_link_caps_order +intel_dp_link_caps_connector_compute_order (struct intel_connector +*connector);struct intel_dp_link_caps_order +intel_dp_link_caps_connector_fallback_order (bool is_mst); +int intel_dp_common_len_rate_limit (struct intel_dp_link_caps *link_caps,int max_rate);int
intel_dp_common_rate(struct intel_dp_link_caps *link_caps, int index);
--
2.49.1
PATCH v2 6/34 drm/i915/dp_link_caps: Validate max link limits
In reply to Imre DeakAdd validation in intel_dp_link_caps_set_max_limits() to ensure that the new maximum rate and lane count leave at least one allowed configuration.
The validation takes disabled configurations and active forced parameters into account. Disabled configurations are not supported yet, so that part has no effect for now.
At the moment this validation is also performed by the link training fallback code, but that will be removed later, leaving only the link caps module to perform the validation added in this patch.
v2: Rebase on changes using a filter object instead of a mask of
configuration indices.
--- .../gpu/drm/i915/display/intel_dp_link_caps.c | 28 ++++++++++++++++++- 1 file changed, 27 insertions(+), 1 deletion(-)
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +27 -1
@@ -558,6 +558,26 @@ void intel_dp_link_caps_get_max_limits(struct intel_dp_link_caps *link_caps, *max_link_limits = link_caps->max_limits; } +static bool max_link_limits_valid (struct intel_dp_link_caps *link_caps, +const struct intel_dp_link_config *max_link_limits) +{ +struct intel_dp_link_caps_filter allowed_configs; +struct intel_dp_link_config forced_params; + +if (max_link_limits->lane_count >INTEL_DP_MAX_LANE_COUNT || + !is_power_of_2 (max_link_limits->lane_count)) +return false; + +/* TODO: Validate max_link_limits->rate against the source supported rates. */ + +intel_dp_link_caps_get_forced_params (link_caps, &forced_params); +/* TODO: Get filter for enabled configs. */ + allowed_configs =calc_allowed_config_filter (link_caps,INTEL_DP_LINK_CAPS_FILTER_ALL , + max_link_limits, &forced_params); + +return allowed_configs.config_mask !=0 ; +} +/** * intel_dp_link_caps_set_max_limits - set the current maximum link limits * @link_caps: link capabilities state
@@ -566,6 +586,10 @@ void intel_dp_link_caps_get_max_limits(struct intel_dp_link_caps *link_caps,* Set the current maximum rate and lane count limits to @max_link_limits, * constraining the set of allowed configurations. * +* The new limits must leave at least one configuration allowed: the limits +* must not be below the currently active forced parameters or below all the +* configurations that remain after disabled configurations are excluded. +* * Unlike intel_dp_link_caps_get_max_limits(), the caller must serialize * this call against concurrent queries and updates to @link_caps, in line * with the rest of the API.
@@ -578,9 +602,11 @@ void intel_dp_link_caps_get_max_limits(struct intel_dp_link_caps *link_caps,bool intel_dp_link_caps_set_max_limits (struct intel_dp_link_caps *link_caps,const struct intel_dp_link_config *max_link_limits) { +if (!max_link_limits_valid (link_caps, max_link_limits)) +return false; +set_max_link_limits_no_update (link_caps, max_link_limits); -/* TODO: validate max_link_limits */ return true; }
Signature · 1 line
2.49.1
RE: [PATCH v2 06/34] drm/i915/dp_link_caps: Validate max link limits
Quoted 9 lines
Subject: [PATCH v2 06/34] drm/i915/dp_link_caps: Validate max link limits
Add validation in
intel_dp_link_caps_set_max_limits()to ensure that the new maximum rate and lane count leave at least one allowed configuration.The validation takes disabled configurations and active forced parameters into account. Disabled configurations are not supported yet, so that part has no effect for now.
Quoted 8 lines
At the moment this validation is also performed by the link training fallback code, but that will be removed later, leaving only the link caps module to perform the validation added in this patch.
v2: Rebase on changes using a filter object instead of a mask of
configuration indices.Signed-off-by Imre Deak <[email protected]>
LGTM,
Quoted 68 lines
--- .../gpu/drm/i915/display/intel_dp_link_caps.c | 28 ++++++++++++++++++- 1 file changed, 27 insertions(+), 1 deletion(-)drivers/gpu/drm/i915/display/intel_dp_link_caps.c +25
-0@@ -558,6 +558,26 @@ void intel_dp_link_caps_get_max_limits(structintel_dp_link_caps *link_caps, *max_link_limits = link_caps->max_limits; } +static bool max_link_limits_valid (struct intel_dp_link_caps *link_caps, +const struct intel_dp_link_config *max_link_limits) { +struct intel_dp_link_caps_filter allowed_configs; +struct intel_dp_link_config forced_params; + +if (max_link_limits->lane_count >INTEL_DP_MAX_LANE_COUNT || + !is_power_of_2 (max_link_limits->lane_count)) +return false; + +/* TODO: Validate max_link_limits->rate against the source supported +rates. */ + +intel_dp_link_caps_get_forced_params (link_caps, &forced_params); +/* TODO: Get filter for enabled configs. */ + allowed_configs =calc_allowed_config_filter (link_caps,INTEL_DP_LINK_CAPS_FILTER_ALL , + max_link_limits, &forced_params); + +return allowed_configs.config_mask !=0 ; } +/** * intel_dp_link_caps_set_max_limits - set the current maximum link limits * @link_caps: link capabilities state @@ -566,6 +586,10 @@ void intel_dp_link_caps_get_max_limits(structintel_dp_link_caps *link_caps, * Set the current maximum rate and lane count limits to @max_link_limits, * constraining the set of allowed configurations. * + * The new limits must leave at least one configuration allowed: the + limits + * must not be below the currently active forced parameters or below + all the + * configurations that remain after disabled configurations are excluded. + * * Unlike intel_dp_link_caps_get_max_limits(), the caller must serialize * this call against concurrent queries and updates to @link_caps, in line * with the rest of the API.@@ -578,9 +602,11 @@ void intel_dp_link_caps_get_max_limits(struct
intel_dp_link_caps*link_caps, bool intel_dp_link_caps_set_max_limits(structintel_dp_link_caps*link_caps,
const structintel_dp_link_config*max_link_limits) {drivers/gpu/drm/i915/display/intel_dp_link_caps.c +3
-2+if (!max_link_limits_valid (link_caps, max_link_limits)) +return false; +set_max_link_limits_no_update (link_caps, max_link_limits); -/* TODO: validate max_link_limits */ return true; } --2.49.1
PATCH v2 7/34 drm/i915/dp_link_caps: Add filter for enabled link configurations
In reply to Imre DeakAdd a filter for enabled link configurations to the link capability state.
This allows fallback code to disable only the configuration that failed link training, instead of constraining later modesets via maximum link rate or lane count. The code only needs to exclude the failed configuration from the allowed set; all other supported configurations remain available.
Use the filter when computing the allowed configuration set and when validating maximum link limits.
Follow-up changes will switch the fallback code to disable individual configurations through this filter.
v2:
- Rebase on changes using a filter object instead of a mask of configuration indices.
- Track the enabled configurations instead of the disabled ones.
--- .../gpu/drm/i915/display/intel_dp_link_caps.c | 38 +++++++++++++++++-- 1 file changed, 34 insertions(+), 4 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +34 -4
@@ -130,6 +130,37 @@ struct intel_dp_link_caps {u8 rate_lane_map[INTEL_DP_MAX_LINK_CONFIGS ];u8 lane_rate_map[INTEL_DP_MAX_LINK_CONFIGS ]; +/* +* Filter of configurations enabled for the current sink +* connection. +* +* Each bit in the filter's configuration mask corresponds to a +* configuration index in the intel_dp_link_caps::configs[] array. +* +* All configurations start out enabled in the filter after a +* new sink is connected. Users disable configurations afterwards +* via the link caps API. All configurations get re-enabled +* internally in the following cases: +* - when forcing a link rate or lane count +* - when intel_dp_link_caps_update(reset=true) is called after +* a new sink is connected +* - when intel_dp_link_caps_update(reset=false) with changed +* link capabilities is called +* - when intel_dp_link_caps_reset() is called after a new sink +* is connected +*/ +struct intel_dp_link_caps_filter enabled_configs; + +/* +* Allowed configurations are the supported configurations defined by +* config_table.rates and config_table.max_lane_count, constrained by +* config_table.enabled_configs and the forced_params and +* max_limits values below. +* +* See get_allowed_config_filter() for the filter of these +* configurations. +*/ +/* * Forced parameters requested via debugfs. Remains set across sink * disconnects.
@@ -454,8 +485,7 @@ get_allowed_config_filter(struct intel_dp_link_caps *link_caps)intel_dp_link_caps_get_forced_params (link_caps, &forced_params); -/* TODO: Get filter for enabled configs. */ -return calc_allowed_config_filter (link_caps,INTEL_DP_LINK_CAPS_FILTER_ALL , +return calc_allowed_config_filter (link_caps, link_caps->enabled_configs, &link_caps->max_limits, &forced_params); }
@@ -571,8 +601,7 @@ static bool max_link_limits_valid(struct intel_dp_link_caps *link_caps,/* TODO: Validate max_link_limits->rate against the source supported rates. */ intel_dp_link_caps_get_forced_params (link_caps, &forced_params); -/* TODO: Get filter for enabled configs. */ - allowed_configs =calc_allowed_config_filter (link_caps,INTEL_DP_LINK_CAPS_FILTER_ALL , + allowed_configs =calc_allowed_config_filter (link_caps, link_caps->enabled_configs, max_link_limits, &forced_params);return allowed_configs.config_mask !=0 ;
@@ -1095,6 +1124,7 @@ struct intel_dp_link_caps *intel_dp_link_caps_init(struct intel_dp *intel_dp)return NULL ; link_caps->dp = intel_dp; + link_caps->enabled_configs =INTEL_DP_LINK_CAPS_FILTER_ALL ;return link_caps; }
Signature · 1 line
2.49.1
RE: [PATCH v2 07/34] drm/i915/dp_link_caps: Add filter for enabled link configurations
Quoted 16 lines
Subject: [PATCH v2 07/34] drm/i915/dp_link_caps: Add filter for enabled link configurations
Add a filter for enabled link configurations to the link capability state.
This allows fallback code to disable only the configuration that failed link training, instead of constraining later modesets via maximum link rate or lane count. The code only needs to exclude the failed configuration from the allowed set; all other supported configurations remain available.
Use the filter when computing the allowed configuration set and when validating maximum link limits.
Follow-up changes will switch the fallback code to disable individual configurations through this filter.
Quoted 6 lines
v2:
- Rebase on changes using a filter object instead of a mask of configuration indices.
- Track the enabled configurations instead of the disabled ones.Signed-off-by Imre Deak <[email protected]>
LGTM,
Quoted 85 lines
--- .../gpu/drm/i915/display/intel_dp_link_caps.c | 38 +++++++++++++++++-- 1 file changed, 34 insertions(+), 4 deletions(-)drivers/gpu/drm/i915/display/intel_dp_link_caps.c +33
-2@@ -130,6 +130,37 @@ struct intel_dp_link_caps {u8 rate_lane_map[INTEL_DP_MAX_LINK_CONFIGS ];u8 lane_rate_map[INTEL_DP_MAX_LINK_CONFIGS ]; +/* +* Filter of configurations enabled for the current sink +* connection. +* +* Each bit in the filter's configuration mask corresponds to a +* configuration index in the intel_dp_link_caps::configs[] array. +* +* All configurations start out enabled in the filter after a +* new sink is connected. Users disable configurations afterwards +* via the link caps API. All configurations get re-enabled +* internally in the following cases: +* - when forcing a link rate or lane count +* - when intel_dp_link_caps_update(reset=true) is called after +* a new sink is connected +* - when intel_dp_link_caps_update(reset=false) with changed +* link capabilities is called +* - when intel_dp_link_caps_reset() is called after a new sink +* is connected +*/ +struct intel_dp_link_caps_filter enabled_configs; + +/* +* Allowed configurations are the supported configurations defined by +* config_table.rates and config_table.max_lane_count, constrained by +* config_table.enabled_configs and the forced_params and +* max_limits values below. +* +* See get_allowed_config_filter() for the filter of these +* configurations. +*/ +/* * Forced parameters requested via debugfs. Remains set across sink * disconnects. @@ -454,8 +485,7 @@ get_allowed_config_filter(struct intel_dp_link_caps *link_caps)intel_dp_link_caps_get_forced_params (link_caps, &forced_params); -/* TODO: Get filter for enabled configs. */ - return calc_allowed_config_filter(link_caps,INTEL_DP_LINK_CAPS_FILTER_ALL , + return calc_allowed_config_filter(link_caps, +link_caps->enabled_configs, &link_caps->max_limits,
&forced_params); }drivers/gpu/drm/i915/display/intel_dp_link_caps.c +0
-0@@ -571,8 +601,7 @@ static bool max_link_limits_valid(struct intel_dp_link_caps *link_caps,/* TODO: Validate max_link_limits->rate against the source supported rates. */
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +0
-2intel_dp_link_caps_get_forced_params (link_caps, &forced_params); -/* TODO: Get filter for enabled configs. */ - allowed_configs = calc_allowed_config_filter(link_caps,
INTEL_DP_LINK_CAPS_FILTER_ALL,drivers/gpu/drm/i915/display/intel_dp_link_caps.c +2
-0+ allowed_configs = calc_allowed_config_filter(link_caps, +link_caps->enabled_configs, max_link_limits,
&forced_params);return allowed_configs.config_mask != 0; @@ -1095,6 +1124,7 @@
structintel_dp_link_caps*intel_dp_link_caps_init(structintel_dp*intel_dp)drivers/gpu/drm/i915/display/intel_dp_link_caps.c +1
-1return NULL ; link_caps->dp = intel_dp; + link_caps->enabled_configs =INTEL_DP_LINK_CAPS_FILTER_ALL ;return link_caps; } --2.49.1
PATCH v2 8/34 drm/i915/dp_link_caps: Re-enable link configurations after a link reset
In reply to Imre DeakRe-enable link configurations after the link is reset via a call to intel_dp_link_caps_reset(), allowing a subsequent modeset to use all the link configurations of a sink newly connected or an already connected sink changing its capabilities.
--- drivers/gpu/drm/i915/display/intel_dp_link_caps.c | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-)
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +7 -1
@@ -561,6 +561,12 @@ static void reset_max_link_limits_no_update(struct intel_dp_link_caps *link_capsset_max_link_limits_no_update (link_caps, &max_link_limits); } +static void reset_max_link_limits_reenable_all (struct intel_dp_link_caps *link_caps) +{ + link_caps->enabled_configs =INTEL_DP_LINK_CAPS_FILTER_ALL ; +reset_max_link_limits_no_update (link_caps); +} +/** * intel_dp_link_caps_get_max_limits - get the current maximum link limits * @link_caps: link capabilities state
@@ -824,7 +830,7 @@ int intel_dp_link_config_index(struct intel_dp_link_caps *link_caps,void intel_dp_link_caps_reset (struct intel_dp_link_caps *link_caps) {/* TODO: Update the maximum link information. */ -reset_max_link_limits_no_update (link_caps); +reset_max_link_limits_reenable_all (link_caps); }static int i915_dp_force_link_rate_show (struct seq_file *m,void *data)
Signature · 1 line
2.49.1
RE: [PATCH v2 08/34] drm/i915/dp_link_caps: Re-enable link configurations after a link reset
Quoted 9 lines
Subject: [PATCH v2 08/34] drm/i915/dp_link_caps: Re-enable link configurations after a link reset
Re-enable link configurations after the link is reset via a call to
intel_dp_link_caps_reset(), allowing a subsequent modeset to use all the link configurations of a sink newly connected or an already connected sink changing its capabilities.Signed-off-by Imre Deak <[email protected]>
LGTM,
Quoted 33 lines
--- drivers/gpu/drm/i915/display/intel_dp_link_caps.c | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-)drivers/gpu/drm/i915/display/intel_dp_link_caps.c +0
-0@@ -561,6 +561,12 @@ static void reset_max_link_limits_no_update(struct
intel_dp_link_caps*link_capsdrivers/gpu/drm/i915/display/intel_dp_link_caps.c +6
-0set_max_link_limits_no_update (link_caps, &max_link_limits); } +static void reset_max_link_limits_reenable_all (struct +intel_dp_link_caps *link_caps) { + link_caps->enabled_configs =INTEL_DP_LINK_CAPS_FILTER_ALL ; +reset_max_link_limits_no_update (link_caps); +} +/** * intel_dp_link_caps_get_max_limits - get the current maximum link limits * @link_caps: link capabilities state @@ -824,7 +830,7 @@ int intel_dp_link_config_index(struct
intel_dp_link_caps*link_caps, voidintel_dp_link_caps_reset(struct intel_dp_link_caps *link_caps){drivers/gpu/drm/i915/display/intel_dp_link_caps.c +1
-2/* TODO: Update the maximum link information. */ -reset_max_link_limits_no_update (link_caps); +reset_max_link_limits_reenable_all (link_caps); }static int i915_dp_force_link_rate_show (struct seq_file *m,void *data) --2.49.1
PATCH v2 9/34 drm/i915/dp_link_caps: Re-enable link configurations after sink caps change
In reply to Imre DeakRe-enable link configurations after sink capabilities change or the link got reset before updating the link capabilities (due to an RX_CAP_CHANGED HPD IRQ for the currently connected sink, or a new sink getting connected).
This makes resetting the link explicitly by calling intel_dp_link_caps_reset() subsequently redundant; keep the existing behavior wrt. this for now, adding only a TODO: to remove the explicit reset.
While at it add documentation for intel_dp_link_caps_update().
--- drivers/gpu/drm/i915/display/intel_dp.c | 8 +++- .../gpu/drm/i915/display/intel_dp_link_caps.c | 37 +++++++++++++++++-- .../gpu/drm/i915/display/intel_dp_link_caps.h | 3 +- 3 files changed, 43 insertions(+), 5 deletions(-)
drivers/gpu/drm/i915/display/intel_dp.c +7 -1
@@ -701,7 +701,8 @@ static bool intel_dp_set_common_link_params(struct intel_dp *intel_dp)intel_dp_get_common_rates (intel_dp, common_rates, &num_common_rates);if (intel_dp_link_caps_update (intel_dp->link.caps, common_rates, num_common_rates, -intel_dp_get_max_common_lane_count (intel_dp))) +intel_dp_get_max_common_lane_count (intel_dp), + intel_dp->reset_link_params)) params_changed = true;return params_changed;
@@ -3652,6 +3653,11 @@ void intel_dp_set_link_params(struct intel_dp *intel_dp,void intel_dp_reset_link_params (struct intel_dp *intel_dp) { +/* +* TODO: Remove the following reset of link capabilities, as +* this isn't needed after intel_dp_link_caps_update(reset=true) +* was called. +*/ intel_dp_link_caps_reset (intel_dp->link.caps); intel_dp->link.mst_probed_lane_count =0 ; intel_dp->link.mst_probed_rate =0 ;
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +34 -3
@@ -709,14 +709,42 @@ static int link_config_cmp_by_lane_rate(const void *a, const void *b, const voidreturn lce_a->link_rate_idx - lce_b->link_rate_idx; } -/* Return %true if the supported link parameters have changed. */ +/** +* intel_dp_link_caps_update - rebuild the supported link configuration state +* @link_caps: link capabilities state +* @rates: supported common link rates +* @num_rates: number of entries in @rates +* @max_lane_count: supported maximum lane count +* @reset: reset limits and disabled configs +* +* Rebuild the supported link configuration state from @rates and +* @max_lane_count. +* +* If @reset is %true, reset the maximum link limits to the maximum +* supported rate and lane count, and re-enable all configurations. +* +* This function is called regularly, at least after a sink is connected, +* but it may also be called later whenever the sink capabilities may have +* changed, for example in response to HPD IRQ / RX_CAP_CHANGED signaling. +* +* In the Intel driver this function is currently called whenever the +* connector detect handler runs, after reading the sink capabilities. This +* may change if those capabilities are cached until the sink is +* disconnected, or until RX_CAP_CHANGED is signaled. In any case, this +* function should be called whenever the sink capabilities were read out +* and may have changed. +* +* Returns: +* - %true if the link capabilities have changed, %false otherwise. +*/ bool intel_dp_link_caps_update (struct intel_dp_link_caps *link_caps, -const int *rates,int num_rates,int max_lane_count) +const int *rates,int num_rates,int max_lane_count, +bool reset) {struct intel_dp *intel_dp = link_caps->dp;struct intel_display *display =to_intel_display (intel_dp);struct intel_dp_link_config_entry *lce; -bool link_params_changed = false; +bool link_params_changed = reset;int num_common_lane_configs;int i;int j;
@@ -778,6 +806,9 @@ bool intel_dp_link_caps_update(struct intel_dp_link_caps *link_caps, link_config_cmp_by_lane_rate,NULL , link_caps); +if (link_params_changed) +reset_max_link_limits_reenable_all (link_caps); +return link_params_changed; }
drivers/gpu/drm/i915/display/intel_dp_link_caps.h +2 -1
@@ -147,7 +147,8 @@ bool intel_dp_link_caps_set_max_limits(struct intel_dp_link_caps *link_caps,void intel_dp_link_caps_reset_max_limits (struct intel_dp_link_caps *link_caps);bool intel_dp_link_caps_update (struct intel_dp_link_caps *link_caps, -const int *rates,int num_rates,int max_lane_count); +const int *rates,int num_rates,int max_lane_count, +bool reset);void intel_dp_link_caps_reset (struct intel_dp_link_caps *link_caps);void intel_dp_link_caps_debugfs_add (struct intel_connector *connector);
Signature · 1 line
2.49.1
RE: [PATCH v2 09/34] drm/i915/dp_link_caps: Re-enable link configurations after sink caps change
Quoted 7 lines
Subject: [PATCH v2 09/34] drm/i915/dp_link_caps: Re-enable link configurations after sink caps change
Re-enable link configurations after sink capabilities change or the link got reset before updating the link capabilities (due to an
RX_CAP_CHANGEDHPD IRQ for the currently connected sink, or a new sink getting connected).
Quoted 7 lines
This makes resetting the link explicitly by calling
intel_dp_link_caps_reset()subsequently redundant; keep the existing behavior wrt. this for now, adding only a TODO: to remove the explicit reset.While at it add documentation for
intel_dp_link_caps_update().Signed-off-by Imre Deak <[email protected]>
LGTM,
Quoted 127 lines
--- drivers/gpu/drm/i915/display/intel_dp.c | 8 +++- .../gpu/drm/i915/display/intel_dp_link_caps.c | 37 +++++++++++++++++-- .../gpu/drm/i915/display/intel_dp_link_caps.h | 3 +- 3 files changed, 43 insertions(+), 5 deletions(-)drivers/gpu/drm/i915/display/intel_dp.c +1
-1@@ -701,7 +701,8 @@ static bool intel_dp_set_common_link_params(struct intel_dp *intel_dp) intel_dp_get_common_rates(intel_dp, common_rates, &num_common_rates); if (intel_dp_link_caps_update(intel_dp->link.caps,common_rates ,num_common_rates , -intel_dp_get_max_common_lane_count (intel_dp ))) +
intel_dp_get_max_common_lane_count(intel_dp),drivers/gpu/drm/i915/display/intel_dp.c +6
-0+ intel_dp->reset_link_params)) params_changed = true;return params_changed;@@ -3652,6 +3653,11 @@ void intel_dp_set_link_params(struct intel_dp *intel_dp, void intel_dp_reset_link_params(struct intel_dp *intel_dp) { +/* +* TODO: Remove the following reset of link capabilities, as +* this isn't needed after intel_dp_link_caps_update(reset=true) +* was called. +*/ intel_dp_link_caps_reset (intel_dp->link.caps); intel_dp->link.mst_probed_lane_count =0 ; intel_dp->link.mst_probed_rate =0 ;drivers/gpu/drm/i915/display/intel_dp_link_caps.c +20
-1@@ -709,14 +709,42 @@ static int link_config_cmp_by_lane_rate(const void *a, const void *b, const voidreturn lce_a->link_rate_idx - lce_b->link_rate_idx; } -/* Return %true if the supported link parameters have changed. */ +/** +* intel_dp_link_caps_update - rebuild the supported link configuration +state +* @link_caps: link capabilities state +* @rates: supported common link rates +* @num_rates: number of entries in @rates +* @max_lane_count: supported maximum lane count +* @reset: reset limits and disabled configs +* +* Rebuild the supported link configuration state from @rates and +* @max_lane_count. +* +* If @reset is %true, reset the maximum link limits to the maximum +* supported rate and lane count, and re-enable all configurations. +* +* This function is called regularly, at least after a sink is +connected, +* but it may also be called later whenever the sink capabilities may +have +* changed, for example in response to HPD IRQ / RX_CAP_CHANGED signaling.
+ *
+ * In the Intel driver this function is currently called whenever the
+ * connector detect handler runs, after reading the sink capabilities.drivers/gpu/drm/i915/display/intel_dp_link_caps.c +10
-1+This +* may change if those capabilities are cached until the sink is +* disconnected, or until RX_CAP_CHANGED is signaled. In any case, this +* function should be called whenever the sink capabilities were read +out +* and may have changed. +* +* Returns: +* - %true if the link capabilities have changed, %false otherwise. +*/ bool intel_dp_link_caps_update(struct intel_dp_link_caps *link_caps, - const int *rates, int num_rates, int
max_lane_count)drivers/gpu/drm/i915/display/intel_dp_link_caps.c +1
-0+ const int *rates, int num_rates, int
max_lane_count,drivers/gpu/drm/i915/display/intel_dp_link_caps.c +5
-1+ bool reset) {struct intel_dp *intel_dp = link_caps->dp;struct intel_display *display =to_intel_display (intel_dp);struct intel_dp_link_config_entry *lce; -bool link_params_changed = false; +bool link_params_changed = reset;int num_common_lane_configs;int i;int j;@@ -778,6 +806,9 @@ bool intel_dp_link_caps_update(structintel_dp_link_caps *link_caps, link_config_cmp_by_lane_rate,NULL , link_caps); +if (link_params_changed) +reset_max_link_limits_reenable_all (link_caps); +return link_params_changed; }drivers/gpu/drm/i915/display/intel_dp_link_caps.h +0
-0@@ -147,7 +147,8 @@ bool intel_dp_link_caps_set_max_limits(struct
intel_dp_link_caps*link_caps, voidintel_dp_link_caps_reset_max_limits(struct intel_dp_link_caps *link_caps);bool intel_dp_link_caps_update(struct
intel_dp_link_caps*link_caps,drivers/gpu/drm/i915/display/intel_dp_link_caps.h +0
-1- const int *rates, int num_rates, int
max_lane_count);drivers/gpu/drm/i915/display/intel_dp_link_caps.h +1
-0+ const int *rates, int num_rates, int
max_lane_count,drivers/gpu/drm/i915/display/intel_dp_link_caps.h +1
-1+ bool reset);void intel_dp_link_caps_reset (struct intel_dp_link_caps *link_caps);void intel_dp_link_caps_debugfs_add (struct intel_connector *connector); --2.49.1
PATCH v2 10/34 drm/i915/dp_link_caps: Drop noupdate postfix from max link limit set helpers
In reply to Imre DeakThere is no need to update any maximum link information when updating the max link limits, so drop the related noupdate postfix from the helpers setting the max link limits.
--- drivers/gpu/drm/i915/display/intel_dp_link_caps.c | 15 +++++++-------- 1 file changed, 7 insertions(+), 8 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +7 -8
@@ -545,26 +545,26 @@ bool intel_dp_link_caps_filter_add(struct intel_dp_link_caps *link_caps,return true; } -static void set_max_link_limits_no_update (struct intel_dp_link_caps *link_caps, -const struct intel_dp_link_config *max_link_limits) +static void set_max_link_limits (struct intel_dp_link_caps *link_caps, +const struct intel_dp_link_config *max_link_limits) { link_caps->max_limits = *max_link_limits; } -static void reset_max_link_limits_no_update (struct intel_dp_link_caps *link_caps) +static void reset_max_link_limits (struct intel_dp_link_caps *link_caps) {struct intel_dp_link_config max_link_limits = { .rate =intel_dp_max_common_rate (link_caps), .lane_count =intel_dp_link_caps_max_common_lane_count (link_caps), }; -set_max_link_limits_no_update (link_caps, &max_link_limits); +set_max_link_limits (link_caps, &max_link_limits); }static void reset_max_link_limits_reenable_all (struct intel_dp_link_caps *link_caps) { link_caps->enabled_configs =INTEL_DP_LINK_CAPS_FILTER_ALL ; -reset_max_link_limits_no_update (link_caps); +reset_max_link_limits (link_caps); }/**
@@ -640,7 +640,7 @@ bool intel_dp_link_caps_set_max_limits(struct intel_dp_link_caps *link_caps,if (!max_link_limits_valid (link_caps, max_link_limits))return false; -set_max_link_limits_no_update (link_caps, max_link_limits); +set_max_link_limits (link_caps, max_link_limits);return true; }
@@ -654,7 +654,7 @@ bool intel_dp_link_caps_set_max_limits(struct intel_dp_link_caps *link_caps,*/ void intel_dp_link_caps_reset_max_limits (struct intel_dp_link_caps *link_caps) { -reset_max_link_limits_no_update (link_caps); +reset_max_link_limits (link_caps); } static int intel_dp_link_config_bw(struct intel_dp_link_caps *link_caps,
@@ -860,7 +860,6 @@ int intel_dp_link_config_index(struct intel_dp_link_caps *link_caps,*/ void intel_dp_link_caps_reset (struct intel_dp_link_caps *link_caps) { -/* TODO: Update the maximum link information. */ reset_max_link_limits_reenable_all (link_caps); }
Signature · 1 line
2.49.1
RE: [PATCH v2 10/34] drm/i915/dp_link_caps: Drop noupdate postfix from max link limit set helpers
Quoted 8 lines
Subject: [PATCH v2 10/34] drm/i915/dp_link_caps: Drop noupdate postfix from max link limit set helpers
There is no need to update any maximum link information when updating the max link limits, so drop the related noupdate postfix from the helpers setting the max link limits.
Signed-off-by Imre Deak <[email protected]>
LGTM,
Quoted 76 lines
--- drivers/gpu/drm/i915/display/intel_dp_link_caps.c | 15 +++++++-------- 1 file changed, 7 insertions(+), 8 deletions(-)drivers/gpu/drm/i915/display/intel_dp_link_caps.c +4
-4@@ -545,26 +545,26 @@ bool intel_dp_link_caps_filter_add(structintel_dp_link_caps *link_caps, return true; } -static void set_max_link_limits_no_update (struct intel_dp_link_caps *link_caps, -const struct intel_dp_link_config *max_link_limits) +static void set_max_link_limits (struct intel_dp_link_caps *link_caps, +const struct intel_dp_link_config *max_link_limits) { link_caps->max_limits = *max_link_limits; } -static void reset_max_link_limits_no_update (struct intel_dp_link_caps *link_caps) +static void reset_max_link_limits (struct intel_dp_link_caps *link_caps) {struct intel_dp_link_config max_link_limits = { .rate =intel_dp_max_common_rate (link_caps), .lane_count =intel_dp_link_caps_max_common_lane_count (link_caps), }; -set_max_link_limits_no_update (link_caps, &max_link_limits); +set_max_link_limits (link_caps, &max_link_limits); }static void reset_max_link_limits_reenable_all (struct intel_dp_link_caps *link_caps) {drivers/gpu/drm/i915/display/intel_dp_link_caps.c +2
-2link_caps->enabled_configs =INTEL_DP_LINK_CAPS_FILTER_ALL ; -reset_max_link_limits_no_update (link_caps); +reset_max_link_limits (link_caps); }/** @@ -640,7 +640,7 @@ bool intel_dp_link_caps_set_max_limits(struct intel_dp_link_caps *link_caps, if (!max_link_limits_valid(link_caps, max_link_limits))return false; -set_max_link_limits_no_update (link_caps, max_link_limits); +set_max_link_limits (link_caps, max_link_limits);return true;}
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +1
-1@@ -654,7 +654,7 @@ bool intel_dp_link_caps_set_max_limits(structintel_dp_link_caps *link_caps, */ void intel_dp_link_caps_reset_max_limits (struct intel_dp_link_caps *link_caps) { -reset_max_link_limits_no_update (link_caps); +reset_max_link_limits (link_caps); }static int intel_dp_link_config_bw(struct
intel_dp_link_caps*link_caps, @@ -
860,7 +860,6 @@ int intel_dp_link_config_index(structintel_dp_link_caps*link_caps,
*/
voidintel_dp_link_caps_reset(struct intel_dp_link_caps *link_caps){drivers/gpu/drm/i915/display/intel_dp_link_caps.c +0
-2-/* TODO: Update the maximum link information. */ reset_max_link_limits_reenable_all (link_caps); } --2.49.1
PATCH v2 11/34 drm/i915/dp_link_caps: Add debugfs entry showing allowed configurations
In reply to Imre DeakAdd a debugfs entry showing the currently allowed link configurations in the connector's iteration order.
--- .../gpu/drm/i915/display/intel_dp_link_caps.c | 40 +++++++++++++++++++ 1 file changed, 40 insertions(+)
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +40 -0
@@ -1123,6 +1123,43 @@ static int i915_dp_max_lane_count_show(void *data, u64 *val) }DEFINE_DEBUGFS_ATTRIBUTE (i915_dp_max_lane_count_fops, i915_dp_max_lane_count_show,NULL ,"%llu\n" ); +static int intel_dp_allowed_link_configs_show (struct seq_file *m,void *data) +{ +struct intel_connector *connector =to_intel_connector (m->private); +struct intel_display *display =to_intel_display (connector); +struct intel_dp *intel_dp =intel_attached_dp (connector); +struct intel_dp_link_caps *link_caps = intel_dp->link.caps; +struct intel_dp_link_config link_config; +struct intel_dp_link_caps_iter iter; +int err; +int i; + + err =drm_modeset_lock_single_interruptible (&display->drm->mode_config.connection_mutex); +if (err) +return err; + +intel_dp_flush_connector_commits (connector); + + i =0 ; +intel_dp_link_caps_iter_start (&iter, + link_caps, +intel_dp_link_caps_connector_compute_order (connector), +INTEL_DP_LINK_CAPS_FILTER_ALL ); +for_each_dp_link_config (&iter, &link_config) { +seq_printf (m,"%s%dx%d" , + i ?" " :"" , + link_config.lane_count, link_config.rate); + i++; + } +intel_dp_link_caps_iter_end (&iter); + +drm_modeset_unlock (&display->drm->mode_config.connection_mutex); + +seq_putc (m,'\n' ); + +return 0 ; +} +DEFINE_SHOW_ATTRIBUTE (intel_dp_allowed_link_configs);/** * intel_dp_link_caps_debugfs_add - add link caps debugfs files for a connector
@@ -1149,6 +1186,9 @@ void intel_dp_link_caps_debugfs_add(struct intel_connector *connector)debugfs_create_file ("i915_dp_max_lane_count" ,0444 , root, connector, &i915_dp_max_lane_count_fops); + +debugfs_create_file ("intel_dp_allowed_link_configs" ,0444 , root, + connector, &intel_dp_allowed_link_configs_fops); }struct intel_dp_link_caps *intel_dp_link_caps_init (struct intel_dp *intel_dp)
Signature · 1 line
2.49.1
Re: [PATCH v2 11/34] drm/i915/dp_link_caps: Add debugfs entry showing allowed configurations
Quoted 57 lines · Imre Deak
Add a debugfs entry showing the currently allowed link configurations in the connector's iteration order.
Signed-off-by Imre Deak <[email protected]>--- .../gpu/drm/i915/display/intel_dp_link_caps.c | 40 +++++++++++++++++++ 1 file changed, 40 insertions(+)drivers/gpu/drm/i915/display/intel_dp_link_caps.c +37
-0@@ -1123,6 +1123,43 @@ static int i915_dp_max_lane_count_show(void *data, u64 *val) }DEFINE_DEBUGFS_ATTRIBUTE (i915_dp_max_lane_count_fops, i915_dp_max_lane_count_show,NULL ,"%llu\n" ); +static int intel_dp_allowed_link_configs_show (struct seq_file *m,void *data) +{ +struct intel_connector *connector =to_intel_connector (m->private); +struct intel_display *display =to_intel_display (connector); +struct intel_dp *intel_dp =intel_attached_dp (connector); +struct intel_dp_link_caps *link_caps = intel_dp->link.caps; +struct intel_dp_link_config link_config; +struct intel_dp_link_caps_iter iter; +int err; +int i; + + err =drm_modeset_lock_single_interruptible (&display->drm->mode_config.connection_mutex); +if (err) +return err; + +intel_dp_flush_connector_commits (connector); + + i =0 ; +intel_dp_link_caps_iter_start (&iter, + link_caps, +intel_dp_link_caps_connector_compute_order (connector), +INTEL_DP_LINK_CAPS_FILTER_ALL ); +for_each_dp_link_config (&iter, &link_config) { +seq_printf (m,"%s%dx%d" , + i ?" " :"" , + link_config.lane_count, link_config.rate); + i++; + } +intel_dp_link_caps_iter_end (&iter); + +drm_modeset_unlock (&display->drm->mode_config.connection_mutex); + +seq_putc (m,'\n' ); + +return 0 ; +} +DEFINE_SHOW_ATTRIBUTE (intel_dp_allowed_link_configs);/** * intel_dp_link_caps_debugfs_add - add link caps debugfs files for a connector
drivers/gpu/drm/i915/display/intel_dp_link_caps.c void intel_dp_link_caps_debugfs_add(struct intel_connector *connector) · line 1194
Quoted 9 lines
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +3
-0@@ -1149,6 +1186,9 @@ void intel_dp_link_caps_debugfs_add(struct intel_connector *connector)debugfs_create_file ("i915_dp_max_lane_count" ,0444 , root, connector, &i915_dp_max_lane_count_fops); + +debugfs_create_file ("intel_dp_allowed_link_configs" ,0444 , root, + connector, &intel_dp_allowed_link_configs_fops); }struct intel_dp_link_caps *intel_dp_link_caps_init (struct intel_dp *intel_dp)
--
Cheers,
Luca.
PATCH v2 12/34 drm/i915/dp: Add link configuration filter for modeset computation
In reply to Imre DeakAdd link_config_filter to link_config_limits to track the set of valid link configurations during modeset state computation. Keep the existing min/max rate and lane count limits for now, until all users are converted to use the configuration filter.
Add the helpers required to select the maximum configuration from the currently allowed configuration set. This will be used by follow-up changes as well to query the maximum link configuration without having to iterate the configurations.
v2:
- Rebase on changes using a filter object instead of a mask of configuration indices.
- Rebase on changes using an iteration object.
--- drivers/gpu/drm/i915/display/intel_dp.c | 42 +++++++++++++++-- drivers/gpu/drm/i915/display/intel_dp.h | 11 +++++ .../gpu/drm/i915/display/intel_dp_link_caps.c | 46 +++++++++++++++++++ .../gpu/drm/i915/display/intel_dp_link_caps.h | 6 +++ 4 files changed, 102 insertions(+), 3 deletions(-)
drivers/gpu/drm/i915/display/intel_dp.c +39 -3
@@ -2577,6 +2577,20 @@ bool intel_dp_mode_valid_with_dsc(struct intel_connector *connector, bw_overhead_flags); } +bool +intel_dp_get_connector_max_link_config (struct intel_connector *connector, +const struct link_config_limits *limits, +struct intel_dp_link_config *max_link_config) +{ +struct intel_dp *intel_dp =intel_attached_dp (connector); +struct intel_dp_link_caps *link_caps = intel_dp->link.caps; +struct intel_dp_link_caps_order order = +intel_dp_link_caps_connector_compute_order (connector); + +return intel_dp_link_caps_get_max_config (link_caps, order.key, limits->link_config_filter, + max_link_config); +} +/* * Calculate the output link min, max bpp values in limits based on the pipe bpp * range, crtc_state and dsc mode. Return true on success.
@@ -2593,6 +2607,7 @@ intel_dp_compute_config_link_bpp_limits(struct intel_connector *connector, &crtc_state->hw.adjusted_mode;const struct intel_crtc *crtc =to_intel_crtc (crtc_state->uapi.crtc);const struct intel_encoder *encoder = &dp_to_dig_port (intel_dp)->base; +struct intel_dp_link_config max_link_config;int max_link_bpp_x16; max_link_bpp_x16 = min(crtc_state->max_link_bpp_x16,
@@ -2622,14 +2637,17 @@ intel_dp_compute_config_link_bpp_limits(struct intel_connector *connector, limits->link.max_bpp_x16 = max_link_bpp_x16; +if (!intel_dp_get_connector_max_link_config (connector, limits, &max_link_config)) +return false; +drm_dbg_kms (display->drm, -"[ENCODER:%d:%s][CRTC:%d:%s] DP link limits: pixel clock %d kHz DSC %s max lanes %d max rate %d max pipe_bpp %d min link_bpp " FXP_Q4_FMT " max link_bpp " FXP_Q4_FMT "\n" , +"[ENCODER:%d:%s][CRTC:%d:%s] DP link limits: pixel clock %d kHz DSC %s max link %dx%d max pipe_bpp %d min link_bpp " FXP_Q4_FMT " max link_bpp " FXP_Q4_FMT "\n" , encoder->base.base.id, encoder->base.name, crtc->base.base.id, crtc->base.name, adjusted_mode->crtc_clock,str_on_off (dsc), - limits->max_lane_count, - limits->max_rate, + max_link_config.lane_count, + max_link_config.rate, limits->pipe.max_bpp,FXP_Q4_ARGS (limits->link.min_bpp_x16),FXP_Q4_ARGS (limits->link.max_bpp_x16));
@@ -2680,10 +2698,15 @@ intel_dp_compute_config_limits(struct intel_dp *intel_dp, struct link_config_limits *limits) {struct intel_display *display =to_intel_display (intel_dp); +struct intel_dp_link_caps *link_caps = intel_dp->link.caps;bool is_mst =intel_crtc_has_type (crtc_state,INTEL_OUTPUT_DP_MST );struct intel_connector *connector =to_intel_connector (conn_state->connector); +/* +* Remove the following min/max rate and lane count setup, once +* all users are converted to use link_config_mask instead. +*/ limits->min_rate =intel_dp_min_link_rate (intel_dp); limits->max_rate =intel_dp_max_link_rate (intel_dp);
@@ -2692,6 +2715,8 @@ intel_dp_compute_config_limits(struct intel_dp *intel_dp, limits->min_lane_count =intel_dp_min_lane_count (intel_dp); limits->max_lane_count =intel_dp_max_lane_count (intel_dp); + limits->link_config_filter =INTEL_DP_LINK_CAPS_FILTER_ALL ; + limits->pipe.min_bpp =intel_dp_min_bpp (crtc_state->output_format);if (is_mst) {/*
@@ -2755,6 +2780,9 @@ intel_dp_compute_config_limits(struct intel_dp *intel_dp, crtc_state->pipe_bpp, limits->pipe.max_bpp);if (is_mst || intel_dp->use_max_params) { +struct intel_dp_link_caps_filter new_filter =INTEL_DP_LINK_CAPS_FILTER_NONE ; +struct intel_dp_link_config max_config; +/* * For MST we always configure max link bw - the spec doesn't * seem to suggest we should do otherwise.
@@ -2768,6 +2796,14 @@ intel_dp_compute_config_limits(struct intel_dp *intel_dp,*/ limits->min_lane_count = limits->max_lane_count; limits->min_rate = limits->max_rate; + +if (!intel_dp_get_connector_max_link_config (connector, limits, &max_config)) +return false; + +if (!intel_dp_link_caps_filter_add (link_caps, &new_filter, &max_config)) +return false; + + limits->link_config_filter = new_filter; }intel_dp_test_compute_config (intel_dp, crtc_state, limits);
drivers/gpu/drm/i915/display/intel_dp.h +11 -0
@@ -8,6 +8,8 @@#include <linux/types.h> +#include "intel_dp_link_caps.h" +enum intel_output_format ;enum pipe ;enum port ;
@@ -22,11 +24,17 @@ struct intel_crtc_state;struct intel_digital_port ;struct intel_display ;struct intel_dp ; +struct intel_dp_link_config ;struct intel_encoder ;struct link_config_limits { +/* +* TODO: Remove the following min/max rate and lane count limits +* once all users are converted to use link_config_mask instead. +*/ int min_rate, max_rate;int min_lane_count, max_lane_count; +struct intel_dp_link_caps_filter link_config_filter;struct {/* Uncompressed DSC input or link output bpp in 1 bpp units */ int min_bpp, max_bpp;
@@ -144,6 +152,9 @@ int intel_dp_dsc_compute_max_bpp(const struct intel_connector *connector, u8 dsc_max_bpc);int intel_dp_compute_min_compressed_bpp_x16 (struct intel_connector *connector,enum intel_output_format output_format); +bool intel_dp_get_connector_max_link_config (struct intel_connector *connector, +const struct link_config_limits *limits, +struct intel_dp_link_config *max_link_config); bool intel_dp_mode_valid_with_dsc(struct intel_connector *connector, int link_clock, int lane_count, int mode_clock, int mode_hdisplay,
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +46 -0
52 lines not on this page · raw message
drivers/gpu/drm/i915/display/intel_dp_link_caps.h +6 -0
@@ -29,6 +29,7 @@ struct intel_dp_link_config;* * See also: * - &struct intel_dp_link_caps_order +* - intel_dp_link_caps_get_max_config() */ enum intel_dp_link_caps_order_key {INTEL_DP_LINK_CAPS_ORDER_KEY_BW ,
@@ -140,6 +141,11 @@ bool intel_dp_link_caps_filter_add(struct intel_dp_link_caps *link_caps,struct intel_dp_link_caps_filter *filter, const struct intel_dp_link_config *config); +bool intel_dp_link_caps_get_max_config (struct intel_dp_link_caps *link_caps, +enum intel_dp_link_caps_order_key order_key, +struct intel_dp_link_caps_filter filter, +struct intel_dp_link_config *max_config); +void intel_dp_link_caps_get_max_limits (struct intel_dp_link_caps *link_caps,struct intel_dp_link_config *max_link_limits); bool intel_dp_link_caps_set_max_limits(struct intel_dp_link_caps *link_caps,
Signature · 1 line
2.49.1
Re: [PATCH v2 12/34] drm/i915/dp: Add link configuration filter for modeset computation
Quoted 80 lines · Imre Deak
Add
link_config_filtertolink_config_limitsto track the set of valid link configurations during modeset state computation. Keep the existing min/max rate and lane count limits for now, until all users are converted to use the configuration filter.Add the helpers required to select the maximum configuration from the currently allowed configuration set. This will be used by follow-up changes as well to query the maximum link configuration without having to iterate the configurations.
v2:
- Rebase on changes using a filter object instead of a mask of configuration indices.
- Rebase on changes using an iteration object.Signed-off-by Imre Deak <[email protected]>--- drivers/gpu/drm/i915/display/intel_dp.c | 42 +++++++++++++++-- drivers/gpu/drm/i915/display/intel_dp.h | 11 +++++ .../gpu/drm/i915/display/intel_dp_link_caps.c | 46 +++++++++++++++++++ .../gpu/drm/i915/display/intel_dp_link_caps.h | 6 +++ 4 files changed, 102 insertions(+), 3 deletions(-)drivers/gpu/drm/i915/display/intel_dp.c +21
-3@@ -2577,6 +2577,20 @@ bool intel_dp_mode_valid_with_dsc(struct intel_connector *connector, bw_overhead_flags); } +bool +intel_dp_get_connector_max_link_config (struct intel_connector *connector, +const struct link_config_limits *limits, +struct intel_dp_link_config *max_link_config) +{ +struct intel_dp *intel_dp =intel_attached_dp (connector); +struct intel_dp_link_caps *link_caps = intel_dp->link.caps; +struct intel_dp_link_caps_order order = +intel_dp_link_caps_connector_compute_order (connector); + +return intel_dp_link_caps_get_max_config (link_caps, order.key, limits->link_config_filter, + max_link_config); +} +/* * Calculate the output link min, max bpp values in limits based on the pipe bpp * range, crtc_state and dsc mode. Return true on success. @@ -2593,6 +2607,7 @@ intel_dp_compute_config_link_bpp_limits(struct intel_connector *connector, &crtc_state->hw.adjusted_mode;const struct intel_crtc *crtc =to_intel_crtc (crtc_state->uapi.crtc);const struct intel_encoder *encoder = &dp_to_dig_port (intel_dp)->base; +struct intel_dp_link_config max_link_config;int max_link_bpp_x16; max_link_bpp_x16 = min(crtc_state->max_link_bpp_x16,@@ -2622,14 +2637,17 @@ intel_dp_compute_config_link_bpp_limits(struct intel_connector *connector, limits->link.max_bpp_x16 = max_link_bpp_x16; +if (!intel_dp_get_connector_max_link_config (connector, limits, &max_link_config)) +return false; +drm_dbg_kms (display->drm, -"[ENCODER:%d:%s][CRTC:%d:%s] DP link limits: pixel clock %d kHz DSC %s max lanes %d max rate %d max pipe_bpp %d min link_bpp " FXP_Q4_FMT " max link_bpp " FXP_Q4_FMT "\n" , +"[ENCODER:%d:%s][CRTC:%d:%s] DP link limits: pixel clock %d kHz DSC %s max link %dx%d max pipe_bpp %d min link_bpp " FXP_Q4_FMT " max link_bpp " FXP_Q4_FMT "\n" , encoder->base.base.id, encoder->base.name, crtc->base.base.id, crtc->base.name, adjusted_mode->crtc_clock,str_on_off (dsc), - limits->max_lane_count, - limits->max_rate, + max_link_config.lane_count, + max_link_config.rate, limits->pipe.max_bpp,FXP_Q4_ARGS (limits->link.min_bpp_x16),FXP_Q4_ARGS (limits->link.max_bpp_x16));@@ -2680,10 +2698,15 @@ intel_dp_compute_config_limits(struct intel_dp *intel_dp, struct link_config_limits *limits) {
drivers/gpu/drm/i915/display/intel_dp.c intel_dp_compute_config_limits(struct intel_dp *intel_dp, · line 2709
Quoted 10 lines
drivers/gpu/drm/i915/display/intel_dp.c +5
-0struct intel_display *display =to_intel_display (intel_dp); +struct intel_dp_link_caps *link_caps = intel_dp->link.caps;bool is_mst =intel_crtc_has_type (crtc_state,INTEL_OUTPUT_DP_MST );struct intel_connector *connector =to_intel_connector (conn_state->connector); +/* +* Remove the following min/max rate and lane count setup, once +* all users are converted to use link_config_mask instead. +*/
Should there be a "TODO" here to make it easier to grep for?
Quoted 52 lines
drivers/gpu/drm/i915/display/intel_dp.c +13
-0limits->min_rate =intel_dp_min_link_rate (intel_dp); limits->max_rate =intel_dp_max_link_rate (intel_dp);@@ -2692,6 +2715,8 @@ intel_dp_compute_config_limits(struct intel_dp *intel_dp, limits->min_lane_count =intel_dp_min_lane_count (intel_dp); limits->max_lane_count =intel_dp_max_lane_count (intel_dp); + limits->link_config_filter =INTEL_DP_LINK_CAPS_FILTER_ALL ; + limits->pipe.min_bpp =intel_dp_min_bpp (crtc_state->output_format);if (is_mst) {/* @@ -2755,6 +2780,9 @@ intel_dp_compute_config_limits(struct intel_dp *intel_dp, crtc_state->pipe_bpp, limits->pipe.max_bpp);if (is_mst || intel_dp->use_max_params) { +struct intel_dp_link_caps_filter new_filter =INTEL_DP_LINK_CAPS_FILTER_NONE ; +struct intel_dp_link_config max_config; +/* * For MST we always configure max link bw - the spec doesn't * seem to suggest we should do otherwise. @@ -2768,6 +2796,14 @@ intel_dp_compute_config_limits(struct intel_dp *intel_dp,*/ limits->min_lane_count = limits->max_lane_count; limits->min_rate = limits->max_rate; + +if (!intel_dp_get_connector_max_link_config (connector, limits, &max_config)) +return false; + +if (!intel_dp_link_caps_filter_add (link_caps, &new_filter, &max_config)) +return false; + + limits->link_config_filter = new_filter; }intel_dp_test_compute_config (intel_dp, crtc_state, limits);drivers/gpu/drm/i915/display/intel_dp.h +2
-0@@ -8,6 +8,8 @@#include <linux/types.h> +#include "intel_dp_link_caps.h" +enum intel_output_format ;enum pipe ;enum port ;@@ -22,11 +24,17 @@ struct intel_crtc_state;struct intel_digital_port ;
drivers/gpu/drm/i915/display/intel_dp.h struct intel_crtc_state; · line 34
Quoted 10 lines
drivers/gpu/drm/i915/display/intel_dp.h +5
-0struct intel_display ;struct intel_dp ; +struct intel_dp_link_config ;struct intel_encoder ;struct link_config_limits { +/* +* TODO: Remove the following min/max rate and lane count limits +* once all users are converted to use link_config_mask instead. +*/
...it would be consistent with this, at least.
Quoted 87 lines
drivers/gpu/drm/i915/display/intel_dp.h +4
-0int min_rate, max_rate;int min_lane_count, max_lane_count; +struct intel_dp_link_caps_filter link_config_filter;struct {/* Uncompressed DSC input or link output bpp in 1 bpp units */ int min_bpp, max_bpp;@@ -144,6 +152,9 @@ int intel_dp_dsc_compute_max_bpp(const struct intel_connector *connector, u8 dsc_max_bpc);int intel_dp_compute_min_compressed_bpp_x16 (struct intel_connector *connector,enum intel_output_format output_format); +bool intel_dp_get_connector_max_link_config (struct intel_connector *connector, +const struct link_config_limits *limits, +struct intel_dp_link_config *max_link_config); bool intel_dp_mode_valid_with_dsc(struct intel_connector *connector, int link_clock, int lane_count, int mode_clock, int mode_hdisplay,drivers/gpu/drm/i915/display/intel_dp_link_caps.c +46
-0@@ -504,6 +504,52 @@ void intel_dp_link_caps_iter_end(struct intel_dp_link_caps_iter *iter)memset (iter,0 ,sizeof (*iter)); } +/** +* intel_dp_link_caps_get_max_config - get the maximum config in a given order +* @link_caps: link capabilities state +* @order_key: ordering key used to rank candidate configurations +* @filter: filter for candidate configurations +* @max_config: returned maximum link configuration +* +* Find the last configuration among the currently allowed +* configurations filtered by @filter in the iteration order +* selected by @order_key, and store it in @max_config. +* +* See also: +* - &enum intel_dp_link_caps_order_key +* +* Returns: +* %true if a maximum config is returned +* %false otherwise. +*/ +bool intel_dp_link_caps_get_max_config (struct intel_dp_link_caps *link_caps, +enum intel_dp_link_caps_order_key order_key, +struct intel_dp_link_caps_filter filter, +struct intel_dp_link_config *max_config) +{ +struct intel_dp_link_caps_order order = { + .key = order_key, + .dir =INTEL_DP_LINK_CAPS_ORDER_DIR_DESC + }; +struct intel_dp_link_config iter_config; +struct intel_dp_link_caps_iter iter; +bool found = false; + +intel_dp_link_caps_iter_start (&iter, link_caps, order, filter); +for_each_dp_link_config (&iter, &iter_config) { + found = true; +break ; + } +intel_dp_link_caps_iter_end (&iter); + +if (!found) +return false; + + *max_config = iter_config; + +return true; +} +static int find_config_idx (struct intel_dp_link_caps *link_caps,struct intel_dp_link_caps_filter filter,const struct intel_dp_link_config *link_config)drivers/gpu/drm/i915/display/intel_dp_link_caps.h +1
-0@@ -29,6 +29,7 @@ struct intel_dp_link_config;* * See also: * - &struct intel_dp_link_caps_order +* - intel_dp_link_caps_get_max_config() */ enum intel_dp_link_caps_order_key {INTEL_DP_LINK_CAPS_ORDER_KEY_BW ,@@ -140,6 +141,11 @@ bool intel_dp_link_caps_filter_add(struct intel_dp_link_caps *link_caps, struct intel_dp_link_caps_filter *filter,
drivers/gpu/drm/i915/display/intel_dp_link_caps.h bool intel_dp_link_caps_filter_add(struct intel_dp_link_caps *link_caps, · line 151
Quoted 10 lines
drivers/gpu/drm/i915/display/intel_dp_link_caps.h +5
-0const struct intel_dp_link_config *config); +bool intel_dp_link_caps_get_max_config (struct intel_dp_link_caps *link_caps, +enum intel_dp_link_caps_order_key order_key, +struct intel_dp_link_caps_filter filter, +struct intel_dp_link_config *max_config); +void intel_dp_link_caps_get_max_limits (struct intel_dp_link_caps *link_caps,struct intel_dp_link_config *max_link_limits); bool intel_dp_link_caps_set_max_limits(struct intel_dp_link_caps *link_caps,
Small nit, but regardless:
--
Cheers,
Luca.
Re: [PATCH v2 12/34] drm/i915/dp: Add link configuration filter for modeset computation
Quoted 87 lines · Luca Coelho
Quoted 86 lines · Imre Deak
Add
link_config_filtertolink_config_limitsto track the set of valid link configurations during modeset state computation. Keep the existing min/max rate and lane count limits for now, until all users are converted to use the configuration filter.Add the helpers required to select the maximum configuration from the currently allowed configuration set. This will be used by follow-up changes as well to query the maximum link configuration without having to iterate the configurations.
v2:
- Rebase on changes using a filter object instead of a mask of configuration indices.
- Rebase on changes using an iteration object.Signed-off-by Imre Deak <[email protected]>--- drivers/gpu/drm/i915/display/intel_dp.c | 42 +++++++++++++++-- drivers/gpu/drm/i915/display/intel_dp.h | 11 +++++ .../gpu/drm/i915/display/intel_dp_link_caps.c | 46 +++++++++++++++++++ .../gpu/drm/i915/display/intel_dp_link_caps.h | 6 +++ 4 files changed, 102 insertions(+), 3 deletions(-)drivers/gpu/drm/i915/display/intel_dp.c +22
-3@@ -2577,6 +2577,20 @@ bool intel_dp_mode_valid_with_dsc(struct intel_connector *connector, bw_overhead_flags); } +bool +intel_dp_get_connector_max_link_config (struct intel_connector *connector, +const struct link_config_limits *limits, +struct intel_dp_link_config *max_link_config) +{ +struct intel_dp *intel_dp =intel_attached_dp (connector); +struct intel_dp_link_caps *link_caps = intel_dp->link.caps; +struct intel_dp_link_caps_order order = +intel_dp_link_caps_connector_compute_order (connector); + +return intel_dp_link_caps_get_max_config (link_caps, order.key, limits->link_config_filter, + max_link_config); +} +/* * Calculate the output link min, max bpp values in limits based on the pipe bpp * range, crtc_state and dsc mode. Return true on success. @@ -2593,6 +2607,7 @@ intel_dp_compute_config_link_bpp_limits(struct intel_connector *connector, &crtc_state->hw.adjusted_mode;const struct intel_crtc *crtc =to_intel_crtc (crtc_state->uapi.crtc);const struct intel_encoder *encoder = &dp_to_dig_port (intel_dp)->base; +struct intel_dp_link_config max_link_config;int max_link_bpp_x16; max_link_bpp_x16 = min(crtc_state->max_link_bpp_x16,@@ -2622,14 +2637,17 @@ intel_dp_compute_config_link_bpp_limits(struct intel_connector *connector, limits->link.max_bpp_x16 = max_link_bpp_x16; +if (!intel_dp_get_connector_max_link_config (connector, limits, &max_link_config)) +return false; +drm_dbg_kms (display->drm, -"[ENCODER:%d:%s][CRTC:%d:%s] DP link limits: pixel clock %d kHz DSC %s max lanes %d max rate %d max pipe_bpp %d min link_bpp " FXP_Q4_FMT " max link_bpp " FXP_Q4_FMT "\n" , +"[ENCODER:%d:%s][CRTC:%d:%s] DP link limits: pixel clock %d kHz DSC %s max link %dx%d max pipe_bpp %d min link_bpp " FXP_Q4_FMT " max link_bpp " FXP_Q4_FMT "\n" , encoder->base.base.id, encoder->base.name, crtc->base.base.id, crtc->base.name, adjusted_mode->crtc_clock,str_on_off (dsc), - limits->max_lane_count, - limits->max_rate, + max_link_config.lane_count, + max_link_config.rate, limits->pipe.max_bpp,FXP_Q4_ARGS (limits->link.min_bpp_x16),FXP_Q4_ARGS (limits->link.max_bpp_x16));@@ -2680,10 +2698,15 @@ intel_dp_compute_config_limits(struct intel_dp *intel_dp, struct link_config_limits *limits) {struct intel_display *display =to_intel_display (intel_dp); +struct intel_dp_link_caps *link_caps = intel_dp->link.caps;bool is_mst =intel_crtc_has_type (crtc_state,INTEL_OUTPUT_DP_MST );struct intel_connector *connector =to_intel_connector (conn_state->connector);
Quoted 6 lines
drivers/gpu/drm/i915/display/intel_dp.c intel_dp_compute_config_limits(struct intel_dp *intel_dp, · line 2709
Quoted 4 lines
drivers/gpu/drm/i915/display/intel_dp.c +4
-0+/* +* Remove the following min/max rate and lane count setup, once +* all users are converted to use link_config_mask instead. +*/ Should there be a "TODO" here to make it easier to grep for?
Ok, will add it.
Quoted 171 lines
Quoted 52 lines
drivers/gpu/drm/i915/display/intel_dp.c +13
-0limits->min_rate =intel_dp_min_link_rate (intel_dp); limits->max_rate =intel_dp_max_link_rate (intel_dp);@@ -2692,6 +2715,8 @@ intel_dp_compute_config_limits(struct intel_dp *intel_dp, limits->min_lane_count =intel_dp_min_lane_count (intel_dp); limits->max_lane_count =intel_dp_max_lane_count (intel_dp); + limits->link_config_filter =INTEL_DP_LINK_CAPS_FILTER_ALL ; + limits->pipe.min_bpp =intel_dp_min_bpp (crtc_state->output_format);if (is_mst) {/* @@ -2755,6 +2780,9 @@ intel_dp_compute_config_limits(struct intel_dp *intel_dp, crtc_state->pipe_bpp, limits->pipe.max_bpp);if (is_mst || intel_dp->use_max_params) { +struct intel_dp_link_caps_filter new_filter =INTEL_DP_LINK_CAPS_FILTER_NONE ; +struct intel_dp_link_config max_config; +/* * For MST we always configure max link bw - the spec doesn't * seem to suggest we should do otherwise. @@ -2768,6 +2796,14 @@ intel_dp_compute_config_limits(struct intel_dp *intel_dp,*/ limits->min_lane_count = limits->max_lane_count; limits->min_rate = limits->max_rate; + +if (!intel_dp_get_connector_max_link_config (connector, limits, &max_config)) +return false; + +if (!intel_dp_link_caps_filter_add (link_caps, &new_filter, &max_config)) +return false; + + limits->link_config_filter = new_filter; }intel_dp_test_compute_config (intel_dp, crtc_state, limits);drivers/gpu/drm/i915/display/intel_dp.h +2
-0@@ -8,6 +8,8 @@#include <linux/types.h> +#include "intel_dp_link_caps.h" +enum intel_output_format ;enum pipe ;enum port ;@@ -22,11 +24,17 @@ struct intel_crtc_state;struct intel_digital_port ;drivers/gpu/drm/i915/display/intel_dp.h struct intel_crtc_state; · line 34
Quoted 10 lines
drivers/gpu/drm/i915/display/intel_dp.h +5
-0struct intel_display ;struct intel_dp ; +struct intel_dp_link_config ;struct intel_encoder ;struct link_config_limits { +/* +* TODO: Remove the following min/max rate and lane count limits +* once all users are converted to use link_config_mask instead. +*/ ...it would be consistent with this, at least.
Quoted 87 lines
drivers/gpu/drm/i915/display/intel_dp.h +4
-0int min_rate, max_rate;int min_lane_count, max_lane_count; +struct intel_dp_link_caps_filter link_config_filter;struct {/* Uncompressed DSC input or link output bpp in 1 bpp units */ int min_bpp, max_bpp;@@ -144,6 +152,9 @@ int intel_dp_dsc_compute_max_bpp(const struct intel_connector *connector, u8 dsc_max_bpc);int intel_dp_compute_min_compressed_bpp_x16 (struct intel_connector *connector,enum intel_output_format output_format); +bool intel_dp_get_connector_max_link_config (struct intel_connector *connector, +const struct link_config_limits *limits, +struct intel_dp_link_config *max_link_config); bool intel_dp_mode_valid_with_dsc(struct intel_connector *connector, int link_clock, int lane_count, int mode_clock, int mode_hdisplay,drivers/gpu/drm/i915/display/intel_dp_link_caps.c +46
-0@@ -504,6 +504,52 @@ void intel_dp_link_caps_iter_end(struct intel_dp_link_caps_iter *iter)memset (iter,0 ,sizeof (*iter)); } +/** +* intel_dp_link_caps_get_max_config - get the maximum config in a given order +* @link_caps: link capabilities state +* @order_key: ordering key used to rank candidate configurations +* @filter: filter for candidate configurations +* @max_config: returned maximum link configuration +* +* Find the last configuration among the currently allowed +* configurations filtered by @filter in the iteration order +* selected by @order_key, and store it in @max_config. +* +* See also: +* - &enum intel_dp_link_caps_order_key +* +* Returns: +* %true if a maximum config is returned +* %false otherwise. +*/ +bool intel_dp_link_caps_get_max_config (struct intel_dp_link_caps *link_caps, +enum intel_dp_link_caps_order_key order_key, +struct intel_dp_link_caps_filter filter, +struct intel_dp_link_config *max_config) +{ +struct intel_dp_link_caps_order order = { + .key = order_key, + .dir =INTEL_DP_LINK_CAPS_ORDER_DIR_DESC + }; +struct intel_dp_link_config iter_config; +struct intel_dp_link_caps_iter iter; +bool found = false; + +intel_dp_link_caps_iter_start (&iter, link_caps, order, filter); +for_each_dp_link_config (&iter, &iter_config) { + found = true; +break ; + } +intel_dp_link_caps_iter_end (&iter); + +if (!found) +return false; + + *max_config = iter_config; + +return true; +} +static int find_config_idx (struct intel_dp_link_caps *link_caps,struct intel_dp_link_caps_filter filter,const struct intel_dp_link_config *link_config)drivers/gpu/drm/i915/display/intel_dp_link_caps.h +1
-0@@ -29,6 +29,7 @@ struct intel_dp_link_config;* * See also: * - &struct intel_dp_link_caps_order +* - intel_dp_link_caps_get_max_config() */ enum intel_dp_link_caps_order_key {INTEL_DP_LINK_CAPS_ORDER_KEY_BW ,@@ -140,6 +141,11 @@ bool intel_dp_link_caps_filter_add(struct intel_dp_link_caps *link_caps, struct intel_dp_link_caps_filter *filter,drivers/gpu/drm/i915/display/intel_dp_link_caps.h bool intel_dp_link_caps_filter_add(struct intel_dp_link_caps *link_caps, · line 151
Quoted 10 lines
drivers/gpu/drm/i915/display/intel_dp_link_caps.h +5
-0const struct intel_dp_link_config *config); +bool intel_dp_link_caps_get_max_config (struct intel_dp_link_caps *link_caps, +enum intel_dp_link_caps_order_key order_key, +struct intel_dp_link_caps_filter filter, +struct intel_dp_link_config *max_config); +void intel_dp_link_caps_get_max_limits (struct intel_dp_link_caps *link_caps,struct intel_dp_link_config *max_link_limits); bool intel_dp_link_caps_set_max_limits(struct intel_dp_link_caps *link_caps,Small nit, but regardless:
Reviewed-by Luca Coelho <[email protected]>--
Cheers,
Luca.
PATCH v2 13/34 drm/i915/dp_link_caps: Add helper to query max BW link configuration
In reply to Imre DeakAdd a helper to query the link configuration among the currently allowed configurations with the maximum link BW.
This will be used by follow-up changes to unify the max BW link config query during mode validation and TBT BW calculation.
--- .../gpu/drm/i915/display/intel_dp_link_caps.c | 17 +++++++++++++++++ .../gpu/drm/i915/display/intel_dp_link_caps.h | 3 +++ 2 files changed, 20 insertions(+)
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +17 -0
@@ -550,6 +550,23 @@ bool intel_dp_link_caps_get_max_config(struct intel_dp_link_caps *link_caps,return true; } +/** +* intel_dp_link_caps_get_max_bw_config - get maximum BW link configuration +* @link_caps: link capabilities state +* @max_config: returned maximum link configuration +* +* Return the maximum BW link configuration among the currently +* allowed configurations. +*/ +void intel_dp_link_caps_get_max_bw_config (struct intel_dp_link_caps *link_caps, +struct intel_dp_link_config *max_config) +{ +if (!intel_dp_link_caps_get_max_config (link_caps, +bw_desc_config_order ().key,INTEL_DP_LINK_CAPS_FILTER_ALL , + max_config)) + *max_config =INTEL_DP_LINK_CONFIG_NULL ; +} +static int find_config_idx (struct intel_dp_link_caps *link_caps,struct intel_dp_link_caps_filter filter,const struct intel_dp_link_config *link_config)
drivers/gpu/drm/i915/display/intel_dp_link_caps.h +3 -0
@@ -146,6 +146,9 @@ bool intel_dp_link_caps_get_max_config(struct intel_dp_link_caps *link_caps,struct intel_dp_link_caps_filter filter, struct intel_dp_link_config *max_config); +void intel_dp_link_caps_get_max_bw_config (struct intel_dp_link_caps *link_caps, +struct intel_dp_link_config *max_config); +void intel_dp_link_caps_get_max_limits (struct intel_dp_link_caps *link_caps,struct intel_dp_link_config *max_link_limits); bool intel_dp_link_caps_set_max_limits(struct intel_dp_link_caps *link_caps,
Signature · 1 line
2.49.1
Re: [PATCH v2 13/34] drm/i915/dp_link_caps: Add helper to query max BW link configuration
Quoted 45 lines · Imre Deak
Add a helper to query the link configuration among the currently allowed configurations with the maximum link BW.
This will be used by follow-up changes to unify the max BW link config query during mode validation and TBT BW calculation.
Signed-off-by Imre Deak <[email protected]>--- .../gpu/drm/i915/display/intel_dp_link_caps.c | 17 +++++++++++++++++ .../gpu/drm/i915/display/intel_dp_link_caps.h | 3 +++ 2 files changed, 20 insertions(+)drivers/gpu/drm/i915/display/intel_dp_link_caps.c +17
-0@@ -550,6 +550,23 @@ bool intel_dp_link_caps_get_max_config(struct intel_dp_link_caps *link_caps,return true; } +/** +* intel_dp_link_caps_get_max_bw_config - get maximum BW link configuration +* @link_caps: link capabilities state +* @max_config: returned maximum link configuration +* +* Return the maximum BW link configuration among the currently +* allowed configurations. +*/ +void intel_dp_link_caps_get_max_bw_config (struct intel_dp_link_caps *link_caps, +struct intel_dp_link_config *max_config) +{ +if (!intel_dp_link_caps_get_max_config (link_caps, +bw_desc_config_order ().key,INTEL_DP_LINK_CAPS_FILTER_ALL , + max_config)) + *max_config =INTEL_DP_LINK_CONFIG_NULL ; +} +static int find_config_idx (struct intel_dp_link_caps *link_caps,struct intel_dp_link_caps_filter filter,const struct intel_dp_link_config *link_config)drivers/gpu/drm/i915/display/intel_dp_link_caps.h +0
-0
drivers/gpu/drm/i915/display/intel_dp_link_caps.h bool intel_dp_link_caps_get_max_config(struct intel_dp_link_caps *link_caps, · line 154
Quoted 9 lines
drivers/gpu/drm/i915/display/intel_dp_link_caps.h +3
-0@@ -146,6 +146,9 @@ bool intel_dp_link_caps_get_max_config(struct intel_dp_link_caps *link_caps,struct intel_dp_link_caps_filter filter, struct intel_dp_link_config *max_config); +void intel_dp_link_caps_get_max_bw_config (struct intel_dp_link_caps *link_caps, +struct intel_dp_link_config *max_config); +void intel_dp_link_caps_get_max_limits (struct intel_dp_link_caps *link_caps,struct intel_dp_link_config *max_link_limits); bool intel_dp_link_caps_set_max_limits(struct intel_dp_link_caps *link_caps,
--
Cheers,
Luca.
PATCH v2 14/34 drm/i915/dp: Query max BW config via link_caps during mode validation
In reply to Imre DeakQuery the maximum link BW configuration during mode validation and MST link probing directly from intel_dp_link_caps_get_max_bw_config(), instead of using the intel_dp_max_link_rate() and intel_dp_max_lane_count() helpers.
This makes the max BW link config query uniform across mode validation and TBT BW calculation, and allows unexporting the intel_dp_max_link_rate()/intel_dp_max_lane_count() helpers.
v2: Use the max BW link configuration, instead of the max link limits.
--- drivers/gpu/drm/i915/display/intel_dp.c | 10 ++++++---- drivers/gpu/drm/i915/display/intel_dp.h | 2 -- drivers/gpu/drm/i915/display/intel_dp_mst.c | 16 ++++++++++++---- 3 files changed, 18 insertions(+), 10 deletions(-)
drivers/gpu/drm/i915/display/intel_dp.c +6 -4
@@ -354,7 +354,7 @@ static int intel_dp_get_max_common_lane_count(struct intel_dp *intel_dp)return min3 (source_max, sink_max, lane_max); } -int intel_dp_max_lane_count (struct intel_dp *intel_dp) +static int intel_dp_max_lane_count (struct intel_dp *intel_dp) {struct intel_dp_link_caps *link_caps = intel_dp->link.caps;struct intel_dp_link_config max_link_limits;
@@ -1331,6 +1331,7 @@ intel_dp_mode_valid_format(struct intel_connector *connector,struct intel_dp *intel_dp =intel_attached_dp (connector);enum intel_output_format output_format;int max_rate, mode_rate, max_lanes, max_link_clock; +struct intel_dp_link_config max_bw_config;u16 dsc_max_compressed_bpp =0 ;enum drm_mode_status status;bool dsc = false;
@@ -1343,8 +1344,9 @@ intel_dp_mode_valid_format(struct intel_connector *connector, output_format =intel_dp_output_format (connector, sink_format); - max_link_clock =intel_dp_max_link_rate (intel_dp); - max_lanes =intel_dp_max_lane_count (intel_dp); +intel_dp_link_caps_get_max_bw_config (intel_dp->link.caps, &max_bw_config); + max_link_clock = max_bw_config.rate; + max_lanes = max_bw_config.lane_count; max_rate =intel_dp_max_link_data_rate (intel_dp, max_link_clock, max_lanes);
@@ -1538,7 +1540,7 @@ static void intel_dp_print_rates(struct intel_dp *intel_dp)intel_dp_link_caps_print_common_rates (intel_dp->link.caps); } -int +static int intel_dp_max_link_rate (struct intel_dp *intel_dp) {struct intel_dp_link_caps *link_caps = intel_dp->link.caps;
drivers/gpu/drm/i915/display/intel_dp.h +0 -2
@@ -111,8 +111,6 @@ void intel_dp_mst_suspend(struct intel_display *display);void intel_dp_mst_resume (struct intel_display *display);int intel_dp_rate_limit_len (const int *rates,int len,int max_rate);int intel_dp_max_source_lane_count (struct intel_digital_port *dig_port); -int intel_dp_max_link_rate (struct intel_dp *intel_dp); -int intel_dp_max_lane_count (struct intel_dp *intel_dp);int intel_dp_config_required_rate (const struct intel_crtc_state *crtc_state);int intel_dp_rate_select (struct intel_dp *intel_dp,int rate);int intel_dp_rate_index (const int *rates,int len,int rate);
drivers/gpu/drm/i915/display/intel_dp_mst.c +12 -4
@@ -47,6 +47,7 @@#include "intel_display_wa.h" #include "intel_dp.h" #include "intel_dp_hdcp.h" +#include "intel_dp_link_caps.h" #include "intel_dp_link_training.h" #include "intel_dp_mst.h" #include "intel_dp_test.h"
@@ -1476,6 +1477,7 @@ mst_connector_mode_valid_ctx(struct drm_connector *_connector,unsigned long bw_overhead_flags =DRM_DP_BW_OVERHEAD_MST |DRM_DP_BW_OVERHEAD_SSC_REF_CLK ;int min_link_bpp_x16 =fxp_q4_from_int (18 ); +struct intel_dp_link_config max_bw_config;static bool supports_dsc;int ret;bool dsc = false;
@@ -1508,8 +1510,9 @@ mst_connector_mode_valid_ctx(struct drm_connector *_connector, min_link_bpp_x16 =intel_dp_compute_min_compressed_bpp_x16 (connector,INTEL_OUTPUT_FORMAT_RGB ); - max_link_clock =intel_dp_max_link_rate (intel_dp); - max_lanes =intel_dp_max_lane_count (intel_dp); +intel_dp_link_caps_get_max_bw_config (intel_dp->link.caps, &max_bw_config); + max_link_clock = max_bw_config.rate; + max_lanes = max_bw_config.lane_count; max_rate =intel_dp_max_link_data_rate (intel_dp, max_link_clock, max_lanes);
@@ -2135,14 +2138,19 @@ bool intel_dp_mst_crtc_needs_modeset(struct intel_atomic_state *state,*/ void intel_dp_mst_prepare_probe (struct intel_dp *intel_dp) { -int link_rate =intel_dp_max_link_rate (intel_dp); -int lane_count =intel_dp_max_lane_count (intel_dp); +struct intel_dp_link_config max_bw_config; +int link_rate; +int lane_count;u8 rate_select;u8 link_bw;if (intel_dp->link.active)return ; +intel_dp_link_caps_get_max_bw_config (intel_dp->link.caps, &max_bw_config); + link_rate = max_bw_config.rate; + lane_count = max_bw_config.lane_count; +if (intel_mst_probed_link_params_valid (intel_dp, link_rate, lane_count))return ;
Signature · 1 line
2.49.1
Re: [PATCH v2 14/34] drm/i915/dp: Query max BW config via link_caps during mode validation
Quoted 117 lines · Imre Deak
Query the maximum link BW configuration during mode validation and MST link probing directly from
intel_dp_link_caps_get_max_bw_config(), instead of using theintel_dp_max_link_rate()andintel_dp_max_lane_count()helpers.This makes the max BW link config query uniform across mode validation and TBT BW calculation, and allows unexporting the intel_dp_max_link_rate()/intel_dp_max_lane_count() helpers.
v2: Use the max BW link configuration, instead of the max link limits.
Signed-off-by Imre Deak <[email protected]>--- drivers/gpu/drm/i915/display/intel_dp.c | 10 ++++++---- drivers/gpu/drm/i915/display/intel_dp.h | 2 -- drivers/gpu/drm/i915/display/intel_dp_mst.c | 16 ++++++++++++---- 3 files changed, 18 insertions(+), 10 deletions(-)drivers/gpu/drm/i915/display/intel_dp.c +6
-4@@ -354,7 +354,7 @@ static int intel_dp_get_max_common_lane_count(struct intel_dp *intel_dp)return min3 (source_max, sink_max, lane_max); } -int intel_dp_max_lane_count (struct intel_dp *intel_dp) +static int intel_dp_max_lane_count (struct intel_dp *intel_dp) {struct intel_dp_link_caps *link_caps = intel_dp->link.caps;struct intel_dp_link_config max_link_limits;@@ -1331,6 +1331,7 @@ intel_dp_mode_valid_format(struct intel_connector *connector,struct intel_dp *intel_dp =intel_attached_dp (connector);enum intel_output_format output_format;int max_rate, mode_rate, max_lanes, max_link_clock; +struct intel_dp_link_config max_bw_config;u16 dsc_max_compressed_bpp =0 ;enum drm_mode_status status;bool dsc = false;@@ -1343,8 +1344,9 @@ intel_dp_mode_valid_format(struct intel_connector *connector, output_format =intel_dp_output_format (connector, sink_format); - max_link_clock =intel_dp_max_link_rate (intel_dp); - max_lanes =intel_dp_max_lane_count (intel_dp); +intel_dp_link_caps_get_max_bw_config (intel_dp->link.caps, &max_bw_config); + max_link_clock = max_bw_config.rate; + max_lanes = max_bw_config.lane_count; max_rate =intel_dp_max_link_data_rate (intel_dp, max_link_clock, max_lanes);@@ -1538,7 +1540,7 @@ static void intel_dp_print_rates(struct intel_dp *intel_dp)intel_dp_link_caps_print_common_rates (intel_dp->link.caps); } -int +static int intel_dp_max_link_rate (struct intel_dp *intel_dp) {struct intel_dp_link_caps *link_caps = intel_dp->link.caps;drivers/gpu/drm/i915/display/intel_dp.h +0
-2@@ -111,8 +111,6 @@ void intel_dp_mst_suspend(struct intel_display *display);void intel_dp_mst_resume (struct intel_display *display);int intel_dp_rate_limit_len (const int *rates,int len,int max_rate);int intel_dp_max_source_lane_count (struct intel_digital_port *dig_port); -int intel_dp_max_link_rate (struct intel_dp *intel_dp); -int intel_dp_max_lane_count (struct intel_dp *intel_dp);int intel_dp_config_required_rate (const struct intel_crtc_state *crtc_state);int intel_dp_rate_select (struct intel_dp *intel_dp,int rate);int intel_dp_rate_index (const int *rates,int len,int rate);drivers/gpu/drm/i915/display/intel_dp_mst.c +8
-4@@ -47,6 +47,7 @@#include "intel_display_wa.h" #include "intel_dp.h" #include "intel_dp_hdcp.h" +#include "intel_dp_link_caps.h" #include "intel_dp_link_training.h" #include "intel_dp_mst.h" #include "intel_dp_test.h" @@ -1476,6 +1477,7 @@ mst_connector_mode_valid_ctx(struct drm_connector *_connector,unsigned long bw_overhead_flags =DRM_DP_BW_OVERHEAD_MST |DRM_DP_BW_OVERHEAD_SSC_REF_CLK ;int min_link_bpp_x16 =fxp_q4_from_int (18 ); +struct intel_dp_link_config max_bw_config;static bool supports_dsc;int ret;bool dsc = false;@@ -1508,8 +1510,9 @@ mst_connector_mode_valid_ctx(struct drm_connector *_connector, min_link_bpp_x16 =intel_dp_compute_min_compressed_bpp_x16 (connector,INTEL_OUTPUT_FORMAT_RGB ); - max_link_clock =intel_dp_max_link_rate (intel_dp); - max_lanes =intel_dp_max_lane_count (intel_dp); +intel_dp_link_caps_get_max_bw_config (intel_dp->link.caps, &max_bw_config); + max_link_clock = max_bw_config.rate; + max_lanes = max_bw_config.lane_count; max_rate =intel_dp_max_link_data_rate (intel_dp, max_link_clock, max_lanes);@@ -2135,14 +2138,19 @@ bool intel_dp_mst_crtc_needs_modeset(struct intel_atomic_state *state,*/ void intel_dp_mst_prepare_probe (struct intel_dp *intel_dp) { -int link_rate =intel_dp_max_link_rate (intel_dp); -int lane_count =intel_dp_max_lane_count (intel_dp); +struct intel_dp_link_config max_bw_config; +int link_rate; +int lane_count;u8 rate_select;u8 link_bw;
drivers/gpu/drm/i915/display/intel_dp_mst.c bool intel_dp_mst_crtc_needs_modeset(struct intel_atomic_state *state, · line 2156
Quoted 10 lines
drivers/gpu/drm/i915/display/intel_dp_mst.c +4
-0if (intel_dp->link.active)return ; +intel_dp_link_caps_get_max_bw_config (intel_dp->link.caps, &max_bw_config); + link_rate = max_bw_config.rate; + lane_count = max_bw_config.lane_count; +if (intel_mst_probed_link_params_valid (intel_dp, link_rate, lane_count))return ;
--
Cheers,
Luca.
PATCH v2 15/34 drm/i915/dp_tunnel: Query max BW config via link_caps for BW computation
In reply to Imre DeakQuery the maximum link BW configuration via the link caps interface to compute the available TBT bandwidth. Unlike the max common link params used so far for this, the max BW config also accounts for any forced link parameters.
This makes the max BW link config query uniform across mode validation and TBT BW calculation, and allows unexporting the intel_dp_link_caps_max_common_lane_count() helper.
v2: Use the max BW link configuration, instead of the max link limits.
--- drivers/gpu/drm/i915/display/intel_dp_link_caps.c | 2 +- drivers/gpu/drm/i915/display/intel_dp_link_caps.h | 1 - drivers/gpu/drm/i915/display/intel_dp_tunnel.c | 8 +++++--- 3 files changed, 6 insertions(+), 5 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +1 -1
@@ -290,7 +290,7 @@ void intel_dp_link_caps_print_common_rates(struct intel_dp_link_caps *link_caps)drm_dbg_kms (display->drm,"common rates: %s\n" ,seq_buf_str (&s)); } -int intel_dp_link_caps_max_common_lane_count (struct intel_dp_link_caps *link_caps) +static int intel_dp_link_caps_max_common_lane_count (struct intel_dp_link_caps *link_caps) {return link_caps->max_lane_count; }
drivers/gpu/drm/i915/display/intel_dp_link_caps.h +0 -1
@@ -125,7 +125,6 @@ int intel_dp_common_rate(struct intel_dp_link_caps *link_caps, int index);int intel_dp_link_caps_common_rate_idx (struct intel_dp_link_caps *link_caps,int rate);int intel_dp_max_common_rate (struct intel_dp_link_caps *link_caps);int intel_dp_link_caps_num_common_rates (struct intel_dp_link_caps *link_caps); -int intel_dp_link_caps_max_common_lane_count (struct intel_dp_link_caps *link_caps);void intel_dp_link_caps_print_common_rates (struct intel_dp_link_caps *link_caps);
drivers/gpu/drm/i915/display/intel_dp_tunnel.c +5 -3
@@ -58,10 +58,12 @@ static int kbytes_to_mbits(int kbytes)static int get_current_link_bw (struct intel_dp *intel_dp) {struct intel_dp_link_caps *link_caps = intel_dp->link.caps; -int rate =intel_dp_max_common_rate (link_caps); -int lane_count =intel_dp_link_caps_max_common_lane_count (link_caps); +struct intel_dp_link_config max_bw_config; -return intel_dp_max_link_data_rate (intel_dp, rate, lane_count); +intel_dp_link_caps_get_max_bw_config (link_caps, &max_bw_config); + +return intel_dp_max_link_data_rate (intel_dp, max_bw_config.rate, + max_bw_config.lane_count); }static int __update_tunnel_state (struct intel_dp *intel_dp,bool force_sink_update)
Signature · 1 line
2.49.1
Re: [PATCH v2 15/34] drm/i915/dp_tunnel: Query max BW config via link_caps for BW computation
Quoted 53 lines · Imre Deak
Query the maximum link BW configuration via the link caps interface to compute the available TBT bandwidth. Unlike the max common link params used so far for this, the max BW config also accounts for any forced link parameters.
This makes the max BW link config query uniform across mode validation and TBT BW calculation, and allows unexporting the
intel_dp_link_caps_max_common_lane_count()helper.v2: Use the max BW link configuration, instead of the max link limits.
Signed-off-by Imre Deak <[email protected]>--- drivers/gpu/drm/i915/display/intel_dp_link_caps.c | 2 +- drivers/gpu/drm/i915/display/intel_dp_link_caps.h | 1 - drivers/gpu/drm/i915/display/intel_dp_tunnel.c | 8 +++++--- 3 files changed, 6 insertions(+), 5 deletions(-)drivers/gpu/drm/i915/display/intel_dp_link_caps.c +1
-1@@ -290,7 +290,7 @@ void intel_dp_link_caps_print_common_rates(struct intel_dp_link_caps *link_caps)drm_dbg_kms (display->drm,"common rates: %s\n" ,seq_buf_str (&s)); } -int intel_dp_link_caps_max_common_lane_count (struct intel_dp_link_caps *link_caps) +static int intel_dp_link_caps_max_common_lane_count (struct intel_dp_link_caps *link_caps) {return link_caps->max_lane_count; }drivers/gpu/drm/i915/display/intel_dp_link_caps.h +0
-1@@ -125,7 +125,6 @@ int intel_dp_common_rate(struct intel_dp_link_caps *link_caps, int index);int intel_dp_link_caps_common_rate_idx (struct intel_dp_link_caps *link_caps,int rate);int intel_dp_max_common_rate (struct intel_dp_link_caps *link_caps);int intel_dp_link_caps_num_common_rates (struct intel_dp_link_caps *link_caps); -int intel_dp_link_caps_max_common_lane_count (struct intel_dp_link_caps *link_caps);void intel_dp_link_caps_print_common_rates (struct intel_dp_link_caps *link_caps);drivers/gpu/drm/i915/display/intel_dp_tunnel.c +0
-2@@ -58,10 +58,12 @@ static int kbytes_to_mbits(int kbytes)static int get_current_link_bw (struct intel_dp *intel_dp) {struct intel_dp_link_caps *link_caps = intel_dp->link.caps; -int rate =intel_dp_max_common_rate (link_caps); -int lane_count =intel_dp_link_caps_max_common_lane_count (link_caps);
drivers/gpu/drm/i915/display/intel_dp_tunnel.c static int kbytes_to_mbits(int kbytes) · line 69
Quoted 10 lines
drivers/gpu/drm/i915/display/intel_dp_tunnel.c +5
-1+struct intel_dp_link_config max_bw_config; -return intel_dp_max_link_data_rate (intel_dp, rate, lane_count); +intel_dp_link_caps_get_max_bw_config (link_caps, &max_bw_config); + +return intel_dp_max_link_data_rate (intel_dp, max_bw_config.rate, + max_bw_config.lane_count); }static int __update_tunnel_state (struct intel_dp *intel_dp,bool force_sink_update)
--
Cheers,
Luca.
PATCH v2 16/34 drm/i915/dp_test: Use link caps for compliance link configs
In reply to Imre DeakUse the link caps configuration mask when applying DP compliance test link parameters during state computation.
Preserve the legacy behavior of falling back to all configurations with the requested lane count if the requested rate and lane count pair is not allowed.
In case no valid configuration is found fail the modeset.
v2:
- Rebase on changes using a filter object instead of a mask of configuration indices.
- Rebase on changes using an iteration object.
--- drivers/gpu/drm/i915/display/intel_dp.c | 3 +- drivers/gpu/drm/i915/display/intel_dp_test.c | 96 +++++++++++++++++++- drivers/gpu/drm/i915/display/intel_dp_test.h | 3 +- 3 files changed, 99 insertions(+), 3 deletions(-)
drivers/gpu/drm/i915/display/intel_dp.c +2 -1
@@ -2808,7 +2808,8 @@ intel_dp_compute_config_limits(struct intel_dp *intel_dp, limits->link_config_filter = new_filter; } -intel_dp_test_compute_config (intel_dp, crtc_state, limits); +if (!intel_dp_test_compute_config (connector, crtc_state, limits)) +return false; return intel_dp_compute_config_link_bpp_limits(connector, crtc_state,
drivers/gpu/drm/i915/display/intel_dp_test.c +95 -1
119 lines not on this page · raw message
drivers/gpu/drm/i915/display/intel_dp_test.h +2 -1
@@ -6,6 +6,7 @@#include <linux/types.h> +struct intel_connector ;struct intel_crtc_state ;struct intel_display ;struct intel_dp ;
@@ -13,7 +14,7 @@ struct link_config_limits;void intel_dp_test_reset (struct intel_dp *intel_dp);void intel_dp_test_request (struct intel_dp *intel_dp); -void intel_dp_test_compute_config (struct intel_dp *intel_dp, +bool intel_dp_test_compute_config (struct intel_connector *connector,struct intel_crtc_state *pipe_config,struct link_config_limits *limits);bool intel_dp_test_phy (struct intel_dp *intel_dp);
Signature · 1 line
2.49.1
Re: [PATCH v2 16/34] drm/i915/dp_test: Use link caps for compliance link configs
Quoted 174 lines · Imre Deak
Use the link caps configuration mask when applying DP compliance test link parameters during state computation.
Preserve the legacy behavior of falling back to all configurations with the requested lane count if the requested rate and lane count pair is not allowed.
In case no valid configuration is found fail the modeset.
v2:
- Rebase on changes using a filter object instead of a mask of configuration indices.
- Rebase on changes using an iteration object.Signed-off-by Imre Deak <[email protected]>--- drivers/gpu/drm/i915/display/intel_dp.c | 3 +- drivers/gpu/drm/i915/display/intel_dp_test.c | 96 +++++++++++++++++++- drivers/gpu/drm/i915/display/intel_dp_test.h | 3 +- 3 files changed, 99 insertions(+), 3 deletions(-)drivers/gpu/drm/i915/display/intel_dp.c +2
-1@@ -2808,7 +2808,8 @@ intel_dp_compute_config_limits(struct intel_dp *intel_dp, limits->link_config_filter = new_filter; } -intel_dp_test_compute_config (intel_dp, crtc_state, limits); +if (!intel_dp_test_compute_config (connector, crtc_state, limits)) +return false; return intel_dp_compute_config_link_bpp_limits(connector, crtc_state,drivers/gpu/drm/i915/display/intel_dp_test.c +95
-1@@ -28,11 +28,92 @@ void intel_dp_test_reset(struct intel_dp *intel_dp)memset (&intel_dp->compliance,0 ,sizeof (intel_dp->compliance)); } +static bool set_filter_for_lane_count (struct intel_connector *connector, +struct intel_dp_link_caps *link_caps, +int lane_count, +struct link_config_limits *limits) +{ +struct intel_dp_link_config link_config; +struct intel_dp_link_caps_order order = +intel_dp_link_caps_connector_compute_order (connector); +struct intel_dp_link_caps_filter new_filter =INTEL_DP_LINK_CAPS_FILTER_NONE ; +struct intel_dp_link_caps_iter iter; +bool found = false; + +intel_dp_link_caps_iter_start (&iter, link_caps, order, limits->link_config_filter); +for_each_dp_link_config (&iter, &link_config) { +if (link_config.lane_count != lane_count) +continue ; + +intel_dp_link_caps_filter_add (link_caps, &new_filter, &link_config); + found = true; + } +intel_dp_link_caps_iter_end (&iter); + +if (!found) +return false; + + limits->link_config_filter = new_filter; + +return true; +} + +static bool set_filter_for_link_config (struct intel_connector *connector, +struct intel_dp_link_caps *link_caps, +const struct intel_dp_link_config *link_params, +struct link_config_limits *limits) +{ +struct intel_dp_link_caps_filter new_filter =INTEL_DP_LINK_CAPS_FILTER_NONE ; + +if (!intel_dp_link_caps_filter_add (link_caps, &new_filter, link_params)) +return false; + + limits->link_config_filter = new_filter; + +return true; +} + +static bool set_filter_for_link_params (struct intel_connector *connector, +int link_rate,int lane_count, +struct link_config_limits *limits) +{ +struct intel_dp *intel_dp =intel_attached_dp (connector); +struct intel_encoder *encoder = &dp_to_dig_port (intel_dp)->base; +struct intel_dp_link_caps *link_caps = intel_dp->link.caps; +struct intel_display *display =to_intel_display (intel_dp); +struct intel_dp_link_config requested_config; + + requested_config.rate = link_rate; + requested_config.lane_count = lane_count; + +if (set_filter_for_link_config (connector, link_caps, &requested_config, limits)) +return true; + +/* +* Preserve the legacy behavior: if the requested (rate, lane_count) +* combination is not an allowed config, fall back to all configs +* matching the requested lane count. +* +* TODO: Recheck whether this behavior is actually correct. +*/ +if (set_filter_for_lane_count (connector, link_caps, lane_count, limits)) +return true; + +drm_dbg_kms (display->drm, +"[ENCODER:%d:%s] Invalid autotest link config parameters: %dx%d\n" , + encoder->base.base.id, encoder->base.name, + requested_config.lane_count, + requested_config.rate); + +return false; +} +/* Adjust link config limits based on compliance test requests. */ -void intel_dp_test_compute_config (struct intel_dp *intel_dp, +bool intel_dp_test_compute_config (struct intel_connector *connector,struct intel_crtc_state *pipe_config,struct link_config_limits *limits) { +struct intel_dp *intel_dp =intel_attached_dp (connector);struct intel_dp_link_caps *link_caps = intel_dp->link.caps;struct intel_display *display =to_intel_display (intel_dp);@@ -51,6 +132,11 @@ void intel_dp_test_compute_config(struct intel_dp *intel_dp,if (intel_dp->compliance.test_type ==DP_TEST_LINK_TRAINING ) {int index; +/* +* TODO: Remove the following min/max link limit setup +* after converting to use the link configuration filter +* instead in limits. +*/ /* Validate the compliance test data since max values * might have changed due to link train fallback. */ @@ -65,7 +151,15 @@ void intel_dp_test_compute_config(struct intel_dp *intel_dp, limits->min_lane_count = intel_dp->compliance.test_lane_count; limits->max_lane_count = intel_dp->compliance.test_lane_count; } + +if (!set_filter_for_link_params (connector, + intel_dp->compliance.test_link_rate, + intel_dp->compliance.test_lane_count, + limits)) +return false; } + +return true; }/* Compliance test status bits */ drivers/gpu/drm/i915/display/intel_dp_test.h +1
-0@@ -6,6 +6,7 @@#include <linux/types.h> +struct intel_connector ;struct intel_crtc_state ;struct intel_display ;struct intel_dp ;
drivers/gpu/drm/i915/display/intel_dp_test.h struct link_config_limits; · line 20
Quoted 8 lines
drivers/gpu/drm/i915/display/intel_dp_test.h +1
-1@@ -13,7 +14,7 @@ struct link_config_limits;void intel_dp_test_reset (struct intel_dp *intel_dp);void intel_dp_test_request (struct intel_dp *intel_dp); -void intel_dp_test_compute_config (struct intel_dp *intel_dp, +bool intel_dp_test_compute_config (struct intel_connector *connector,struct intel_crtc_state *pipe_config,struct link_config_limits *limits);bool intel_dp_test_phy (struct intel_dp *intel_dp);
--
Cheers,
Luca.
PATCH v2 17/34 drm/i915/dp: Iterate configurations via link_caps for SST non-DSC
In reply to Imre DeakUse the link caps configuration iterator for DP SST link configuration computation for non-DSC mode. This is a step towards unifying configuration selection and iteration across connector types and between compute and fallback paths.
The iteration preserves the DP SST connector rate/lane ordering used by the current code.
This also allows removing the now unused common rate count helper.
v2:
- Rebase on changes using a filter object instead of a mask of configuration indices.
- Rebase on changes using an iteration object.
--- drivers/gpu/drm/i915/display/intel_dp.c | 49 ++++++++++++------------- 1 file changed, 24 insertions(+), 25 deletions(-)
drivers/gpu/drm/i915/display/intel_dp.c +24 -25
@@ -1754,43 +1754,42 @@ intel_dp_compute_link_config_wide(struct intel_dp *intel_dp,const struct drm_connector_state *conn_state, const struct link_config_limits *limits) { + struct intel_connector *connector = to_intel_connector(conn_state->connector); +int bpp, clock =intel_dp_mode_clock (pipe_config, conn_state);struct intel_dp_link_caps *link_caps = intel_dp->link.caps; -int bpp, i, lane_count, clock =intel_dp_mode_clock (pipe_config, conn_state); -int link_rate, link_avail; +struct intel_dp_link_caps_order order = +intel_dp_link_caps_connector_compute_order (connector); +int link_avail;for (bpp =fxp_q4_to_int (limits->link.max_bpp_x16); bpp >=fxp_q4_to_int (limits->link.min_bpp_x16); bpp -=2 *3 ) {int link_bpp_x16 =intel_dp_output_format_link_bpp_x16 (pipe_config->output_format, bpp); +struct intel_dp_link_config link_config; +struct intel_dp_link_caps_iter iter; -for (i =0 ; i <intel_dp_link_caps_num_common_rates (intel_dp->link.caps); i++) { - link_rate =intel_dp_common_rate (link_caps, i); -if (link_rate < limits->min_rate || - link_rate > limits->max_rate) -continue ; - -for (lane_count = limits->min_lane_count; - lane_count <= limits->max_lane_count; - lane_count <<=1 ) { -const struct drm_display_mode *adjusted_mode = +intel_dp_link_caps_iter_start (&iter, link_caps, order, limits->link_config_filter); +for_each_dp_link_config (&iter, &link_config) { +const struct drm_display_mode *adjusted_mode = &pipe_config->hw.adjusted_mode; -int mode_rate = -intel_dp_link_required (link_rate, lane_count, - clock, adjusted_mode->hdisplay, - link_bpp_x16,0 ); +int mode_rate; - link_avail =intel_dp_max_link_data_rate (intel_dp, - link_rate, - lane_count); + mode_rate =intel_dp_link_required (link_config.rate, + link_config.lane_count, + clock, adjusted_mode->hdisplay, + link_bpp_x16,0 ); -if (mode_rate <= link_avail) { - pipe_config->lane_count = lane_count; - pipe_config->pipe_bpp = bpp; - pipe_config->port_clock = link_rate; + link_avail =intel_dp_max_link_data_rate (intel_dp, + link_config.rate, + link_config.lane_count); -return 0 ; - } +if (mode_rate <= link_avail) { + pipe_config->lane_count = link_config.lane_count; + pipe_config->pipe_bpp = bpp; + pipe_config->port_clock = link_config.rate; + +return 0 ; } } }
Signature · 1 line
2.49.1
Re: [PATCH v2 17/34] drm/i915/dp: Iterate configurations via link_caps for SST non-DSC
Quoted 82 lines · Imre Deak
Use the link caps configuration iterator for DP SST link configuration computation for non-DSC mode. This is a step towards unifying configuration selection and iteration across connector types and between compute and fallback paths.
The iteration preserves the DP SST connector rate/lane ordering used by the current code.
This also allows removing the now unused common rate count helper.
v2:
- Rebase on changes using a filter object instead of a mask of configuration indices.
- Rebase on changes using an iteration object.Signed-off-by Imre Deak <[email protected]>--- drivers/gpu/drm/i915/display/intel_dp.c | 49 ++++++++++++------------- 1 file changed, 24 insertions(+), 25 deletions(-)drivers/gpu/drm/i915/display/intel_dp.c +18
-24@@ -1754,43 +1754,42 @@ intel_dp_compute_link_config_wide(struct intel_dp *intel_dp,const struct drm_connector_state *conn_state, const struct link_config_limits *limits) { + struct intel_connector *connector = to_intel_connector(conn_state->connector); +int bpp, clock =intel_dp_mode_clock (pipe_config, conn_state);struct intel_dp_link_caps *link_caps = intel_dp->link.caps; -int bpp, i, lane_count, clock =intel_dp_mode_clock (pipe_config, conn_state); -int link_rate, link_avail; +struct intel_dp_link_caps_order order = +intel_dp_link_caps_connector_compute_order (connector); +int link_avail;for (bpp =fxp_q4_to_int (limits->link.max_bpp_x16); bpp >=fxp_q4_to_int (limits->link.min_bpp_x16); bpp -=2 *3 ) {int link_bpp_x16 =intel_dp_output_format_link_bpp_x16 (pipe_config->output_format, bpp); +struct intel_dp_link_config link_config; +struct intel_dp_link_caps_iter iter; -for (i =0 ; i <intel_dp_link_caps_num_common_rates (intel_dp->link.caps); i++) { - link_rate =intel_dp_common_rate (link_caps, i); -if (link_rate < limits->min_rate || - link_rate > limits->max_rate) -continue ; - -for (lane_count = limits->min_lane_count; - lane_count <= limits->max_lane_count; - lane_count <<=1 ) { -const struct drm_display_mode *adjusted_mode = +intel_dp_link_caps_iter_start (&iter, link_caps, order, limits->link_config_filter); +for_each_dp_link_config (&iter, &link_config) { +const struct drm_display_mode *adjusted_mode = &pipe_config->hw.adjusted_mode; -int mode_rate = -intel_dp_link_required (link_rate, lane_count, - clock, adjusted_mode->hdisplay, - link_bpp_x16,0 ); +int mode_rate; - link_avail =intel_dp_max_link_data_rate (intel_dp, - link_rate, - lane_count); + mode_rate =intel_dp_link_required (link_config.rate, + link_config.lane_count, + clock, adjusted_mode->hdisplay, + link_bpp_x16,0 ); -if (mode_rate <= link_avail) { - pipe_config->lane_count = lane_count; - pipe_config->pipe_bpp = bpp; - pipe_config->port_clock = link_rate; + link_avail =intel_dp_max_link_data_rate (intel_dp, + link_config.rate, + link_config.lane_count); -return 0 ;
drivers/gpu/drm/i915/display/intel_dp.c intel_dp_compute_link_config_wide(struct intel_dp *intel_dp, · line 1795
Quoted 10 lines
drivers/gpu/drm/i915/display/intel_dp.c +6
-1- } +if (mode_rate <= link_avail) { + pipe_config->lane_count = link_config.lane_count; + pipe_config->pipe_bpp = bpp; + pipe_config->port_clock = link_config.rate; + +return 0 ; } } }
--
Cheers,
Luca.
PATCH v2 18/34 drm/i915/dp: Iterate configurations via link_caps for SST DSC
In reply to Imre DeakUse the link caps configuration iterator for DP SST link configuration computation for DSC mode. This is a step towards unifying configuration selection and iteration across connector types and between compute and fallback paths.
The iteration preserves the DP SST connector rate/lane ordering used by the current code.
This also allows removing the now unused common rate count helper.
v2:
- Rebase on changes using a filter object instead of a mask of configuration indices.
- Rebase on changes using an iteration object.
--- drivers/gpu/drm/i915/display/intel_dp.c | 92 +++++++++---------- .../gpu/drm/i915/display/intel_dp_link_caps.c | 5 - .../gpu/drm/i915/display/intel_dp_link_caps.h | 1 - 3 files changed, 44 insertions(+), 54 deletions(-)
drivers/gpu/drm/i915/display/intel_dp.c +44 -48
@@ -1988,60 +1988,56 @@ static int dsc_compute_link_config(struct intel_dp *intel_dp, const struct link_config_limits *limits, int dsc_bpp_x16) { -struct intel_dp_link_caps *link_caps = intel_dp->link.caps;const struct drm_display_mode *adjusted_mode = &pipe_config->hw.adjusted_mode; -int link_rate, lane_count; -int i; +struct intel_connector *connector =to_intel_connector (conn_state->connector); +struct intel_dp_link_caps *link_caps = intel_dp->link.caps; +struct intel_dp_link_caps_order order = +intel_dp_link_caps_connector_compute_order (connector); +struct intel_dp_link_config link_config; +struct intel_dp_link_caps_iter iter; -for (i =0 ; i <intel_dp_link_caps_num_common_rates (intel_dp->link.caps); i++) { - link_rate =intel_dp_common_rate (link_caps, i); -if (link_rate < limits->min_rate || link_rate > limits->max_rate) -continue ; +intel_dp_link_caps_iter_start (&iter, link_caps, order, limits->link_config_filter); +for_each_dp_link_config (&iter, &link_config) { +/* +* FIXME: intel_dp_mtp_tu_compute_config() requires +* ->lane_count and ->port_clock set before we know +* they'll work. If we end up failing altogether, +* they'll remain in crtc state. This shouldn't matter, +* as we'd then bail out from compute config, but it's +* just ugly. +*/ + pipe_config->lane_count = link_config.lane_count; + pipe_config->port_clock = link_config.rate; -for (lane_count = limits->min_lane_count; - lane_count <= limits->max_lane_count; - lane_count <<=1 ) { +if (drm_dp_is_uhbr_rate (link_config.rate)) { +int ret; -/* -* FIXME: intel_dp_mtp_tu_compute_config() requires -* ->lane_count and ->port_clock set before we know -* they'll work. If we end up failing altogether, -* they'll remain in crtc state. This shouldn't matter, -* as we'd then bail out from compute config, but it's -* just ugly. -*/ - pipe_config->lane_count = lane_count; - pipe_config->port_clock = link_rate; + ret =intel_dp_mtp_tu_compute_config (intel_dp, + pipe_config, + conn_state, + dsc_bpp_x16, + dsc_bpp_x16, +0 , true); +if (ret) +continue ; + }else { +unsigned long bw_overhead_flags = + pipe_config->fec_enable ?DRM_DP_BW_OVERHEAD_FEC :0 ; +int line_slice_count = +intel_dsc_line_slice_count (&pipe_config->dsc.slice_config); -if (drm_dp_is_uhbr_rate (link_rate)) { -int ret; - - ret =intel_dp_mtp_tu_compute_config (intel_dp, - pipe_config, - conn_state, - dsc_bpp_x16, - dsc_bpp_x16, -0 , true); -if (ret) -continue ; - }else { -unsigned long bw_overhead_flags = - pipe_config->fec_enable ?DRM_DP_BW_OVERHEAD_FEC :0 ; -int line_slice_count = -intel_dsc_line_slice_count (&pipe_config->dsc.slice_config); - -if (!is_bw_sufficient_for_dsc_config (intel_dp, - link_rate, lane_count, - adjusted_mode->crtc_clock, - adjusted_mode->hdisplay, - line_slice_count, - dsc_bpp_x16, - bw_overhead_flags)) -continue ; - } - -return 0 ; +if (!is_bw_sufficient_for_dsc_config (intel_dp, + link_config.rate, + link_config.lane_count, + adjusted_mode->crtc_clock, + adjusted_mode->hdisplay, + line_slice_count, + dsc_bpp_x16, + bw_overhead_flags)) +continue ; } + +return 0 ; }return -EINVAL ;
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +0 -5
@@ -273,11 +273,6 @@ int intel_dp_max_common_rate(struct intel_dp_link_caps *link_caps)return intel_dp_common_rate (link_caps, link_caps->num_rates -1 ); } -int intel_dp_link_caps_num_common_rates (struct intel_dp_link_caps *link_caps) -{ -return link_caps->num_rates; -} -void intel_dp_link_caps_print_common_rates (struct intel_dp_link_caps *link_caps) {struct intel_display *display =to_intel_display (link_caps->dp);
drivers/gpu/drm/i915/display/intel_dp_link_caps.h +0 -1
@@ -124,7 +124,6 @@ int intel_dp_common_len_rate_limit(struct intel_dp_link_caps *link_caps,int intel_dp_common_rate (struct intel_dp_link_caps *link_caps,int index);int intel_dp_link_caps_common_rate_idx (struct intel_dp_link_caps *link_caps,int rate);int intel_dp_max_common_rate (struct intel_dp_link_caps *link_caps); -int intel_dp_link_caps_num_common_rates (struct intel_dp_link_caps *link_caps);void intel_dp_link_caps_print_common_rates (struct intel_dp_link_caps *link_caps);
Signature · 1 line
2.49.1
Re: [PATCH v2 18/34] drm/i915/dp: Iterate configurations via link_caps for SST DSC
Quoted 152 lines · Imre Deak
Use the link caps configuration iterator for DP SST link configuration computation for DSC mode. This is a step towards unifying configuration selection and iteration across connector types and between compute and fallback paths.
The iteration preserves the DP SST connector rate/lane ordering used by the current code.
This also allows removing the now unused common rate count helper.
v2:
- Rebase on changes using a filter object instead of a mask of configuration indices.
- Rebase on changes using an iteration object.Signed-off-by Imre Deak <[email protected]>--- drivers/gpu/drm/i915/display/intel_dp.c | 92 +++++++++---------- .../gpu/drm/i915/display/intel_dp_link_caps.c | 5 - .../gpu/drm/i915/display/intel_dp_link_caps.h | 1 - 3 files changed, 44 insertions(+), 54 deletions(-)drivers/gpu/drm/i915/display/intel_dp.c +44
-48@@ -1988,60 +1988,56 @@ static int dsc_compute_link_config(struct intel_dp *intel_dp, const struct link_config_limits *limits, int dsc_bpp_x16) { -struct intel_dp_link_caps *link_caps = intel_dp->link.caps;const struct drm_display_mode *adjusted_mode = &pipe_config->hw.adjusted_mode; -int link_rate, lane_count; -int i; +struct intel_connector *connector =to_intel_connector (conn_state->connector); +struct intel_dp_link_caps *link_caps = intel_dp->link.caps; +struct intel_dp_link_caps_order order = +intel_dp_link_caps_connector_compute_order (connector); +struct intel_dp_link_config link_config; +struct intel_dp_link_caps_iter iter; -for (i =0 ; i <intel_dp_link_caps_num_common_rates (intel_dp->link.caps); i++) { - link_rate =intel_dp_common_rate (link_caps, i); -if (link_rate < limits->min_rate || link_rate > limits->max_rate) -continue ; +intel_dp_link_caps_iter_start (&iter, link_caps, order, limits->link_config_filter); +for_each_dp_link_config (&iter, &link_config) { +/* +* FIXME: intel_dp_mtp_tu_compute_config() requires +* ->lane_count and ->port_clock set before we know +* they'll work. If we end up failing altogether, +* they'll remain in crtc state. This shouldn't matter, +* as we'd then bail out from compute config, but it's +* just ugly. +*/ + pipe_config->lane_count = link_config.lane_count; + pipe_config->port_clock = link_config.rate; -for (lane_count = limits->min_lane_count; - lane_count <= limits->max_lane_count; - lane_count <<=1 ) { +if (drm_dp_is_uhbr_rate (link_config.rate)) { +int ret; -/* -* FIXME: intel_dp_mtp_tu_compute_config() requires -* ->lane_count and ->port_clock set before we know -* they'll work. If we end up failing altogether, -* they'll remain in crtc state. This shouldn't matter, -* as we'd then bail out from compute config, but it's -* just ugly. -*/ - pipe_config->lane_count = lane_count; - pipe_config->port_clock = link_rate; + ret =intel_dp_mtp_tu_compute_config (intel_dp, + pipe_config, + conn_state, + dsc_bpp_x16, + dsc_bpp_x16, +0 , true); +if (ret) +continue ; + }else { +unsigned long bw_overhead_flags = + pipe_config->fec_enable ?DRM_DP_BW_OVERHEAD_FEC :0 ; +int line_slice_count = +intel_dsc_line_slice_count (&pipe_config->dsc.slice_config); -if (drm_dp_is_uhbr_rate (link_rate)) { -int ret; - - ret =intel_dp_mtp_tu_compute_config (intel_dp, - pipe_config, - conn_state, - dsc_bpp_x16, - dsc_bpp_x16, -0 , true); -if (ret) -continue ; - }else { -unsigned long bw_overhead_flags = - pipe_config->fec_enable ?DRM_DP_BW_OVERHEAD_FEC :0 ; -int line_slice_count = -intel_dsc_line_slice_count (&pipe_config->dsc.slice_config); - -if (!is_bw_sufficient_for_dsc_config (intel_dp, - link_rate, lane_count, - adjusted_mode->crtc_clock, - adjusted_mode->hdisplay, - line_slice_count, - dsc_bpp_x16, - bw_overhead_flags)) -continue ; - } - -return 0 ; +if (!is_bw_sufficient_for_dsc_config (intel_dp, + link_config.rate, + link_config.lane_count, + adjusted_mode->crtc_clock, + adjusted_mode->hdisplay, + line_slice_count, + dsc_bpp_x16, + bw_overhead_flags)) +continue ; } + +return 0 ; }return -EINVAL ;drivers/gpu/drm/i915/display/intel_dp_link_caps.c +0
-5@@ -273,11 +273,6 @@ int intel_dp_max_common_rate(struct intel_dp_link_caps *link_caps)return intel_dp_common_rate (link_caps, link_caps->num_rates -1 ); } -int intel_dp_link_caps_num_common_rates (struct intel_dp_link_caps *link_caps) -{ -return link_caps->num_rates; -} -void intel_dp_link_caps_print_common_rates (struct intel_dp_link_caps *link_caps) {struct intel_display *display =to_intel_display (link_caps->dp);drivers/gpu/drm/i915/display/intel_dp_link_caps.h +0
-0
drivers/gpu/drm/i915/display/intel_dp_link_caps.h int intel_dp_common_len_rate_limit(struct intel_dp_link_caps *link_caps, · line 129
Quoted 7 lines
drivers/gpu/drm/i915/display/intel_dp_link_caps.h +0
-1@@ -124,7 +124,6 @@ int intel_dp_common_len_rate_limit(struct intel_dp_link_caps *link_caps,int intel_dp_common_rate (struct intel_dp_link_caps *link_caps,int index);int intel_dp_link_caps_common_rate_idx (struct intel_dp_link_caps *link_caps,int rate);int intel_dp_max_common_rate (struct intel_dp_link_caps *link_caps); -int intel_dp_link_caps_num_common_rates (struct intel_dp_link_caps *link_caps);void intel_dp_link_caps_print_common_rates (struct intel_dp_link_caps *link_caps);
--
Cheers,
Luca.
PATCH v2 19/34 drm/i915/dp: Use link caps for eDP DSC config selection
In reply to Imre DeakUse the link caps helper to select the maximum eDP link configuration for DSC computation, instead of using the separate max rate and lane count limits, which may not form a valid configuration after individual configs are disabled by fallback.
This is a step towards unifying configuration selection and iteration across connector types and between compute and fallback paths.
The state computation should likely consider all allowed configurations, as noted in the code comment; for now keep the existing eDP DSC behavior of selecting the maximum configuration determined by the eDP connector rate / lane config iteration order.
--- drivers/gpu/drm/i915/display/intel_dp.c | 17 ++++++++++++++--- 1 file changed, 14 insertions(+), 3 deletions(-)
drivers/gpu/drm/i915/display/intel_dp.c +14 -3
@@ -2248,7 +2248,7 @@ static int dsc_compute_compressed_bpp(struct intel_dp *intel_dp, int pipe_bpp) {struct intel_display *display =to_intel_display (intel_dp); -const struct intel_connector *connector =to_intel_connector (conn_state->connector); +struct intel_connector *connector =to_intel_connector (conn_state->connector);int min_bpp_x16, max_bpp_x16, bpp_step_x16;int bpp_x16;int ret;
@@ -2260,8 +2260,19 @@ static int dsc_compute_compressed_bpp(struct intel_dp *intel_dp, max_bpp_x16 =align_max_compressed_bpp_x16 (connector, pipe_config->output_format, pipe_bpp, max_bpp_x16);if (intel_dp_is_edp (intel_dp)) { - pipe_config->port_clock = limits->max_rate; - pipe_config->lane_count = limits->max_lane_count; +struct intel_dp_link_config max_link_config; + +/* +* FIXME: Clarify why eDP does not use the regular SST BW +* check and instead always uses the maximum link config, +* regardless of intel_dp::use_max_params. Then unify this eDP +* path with the regular DP path. +*/ +if (!intel_dp_get_connector_max_link_config (connector, limits, &max_link_config)) +return -EINVAL ; + + pipe_config->port_clock = max_link_config.rate; + pipe_config->lane_count = max_link_config.lane_count; pipe_config->dsc.compressed_bpp_x16 = max_bpp_x16;
Signature · 1 line
2.49.1
Re: [PATCH v2 19/34] drm/i915/dp: Use link caps for eDP DSC config selection
Quoted 35 lines · Imre Deak
Use the link caps helper to select the maximum eDP link configuration for DSC computation, instead of using the separate max rate and lane count limits, which may not form a valid configuration after individual configs are disabled by fallback.
This is a step towards unifying configuration selection and iteration across connector types and between compute and fallback paths.
The state computation should likely consider all allowed configurations, as noted in the code comment; for now keep the existing eDP DSC behavior of selecting the maximum configuration determined by the eDP connector rate / lane config iteration order.
Signed-off-by Imre Deak <[email protected]>--- drivers/gpu/drm/i915/display/intel_dp.c | 17 ++++++++++++++--- 1 file changed, 14 insertions(+), 3 deletions(-)drivers/gpu/drm/i915/display/intel_dp.c +1
-1@@ -2248,7 +2248,7 @@ static int dsc_compute_compressed_bpp(struct intel_dp *intel_dp, int pipe_bpp) {struct intel_display *display =to_intel_display (intel_dp); -const struct intel_connector *connector =to_intel_connector (conn_state->connector); +struct intel_connector *connector =to_intel_connector (conn_state->connector);int min_bpp_x16, max_bpp_x16, bpp_step_x16;int bpp_x16;int ret;@@ -2260,8 +2260,19 @@ static int dsc_compute_compressed_bpp(struct intel_dp *intel_dp, max_bpp_x16 =align_max_compressed_bpp_x16 (connector, pipe_config->output_format, pipe_bpp, max_bpp_x16);if (intel_dp_is_edp (intel_dp)) {
drivers/gpu/drm/i915/display/intel_dp.c static int dsc_compute_compressed_bpp(struct intel_dp *intel_dp, · line 2270
Quoted 10 lines
drivers/gpu/drm/i915/display/intel_dp.c +8
-2- pipe_config->port_clock = limits->max_rate; - pipe_config->lane_count = limits->max_lane_count; +struct intel_dp_link_config max_link_config; + +/* +* FIXME: Clarify why eDP does not use the regular SST BW +* check and instead always uses the maximum link config, +* regardless of intel_dp::use_max_params. Then unify this eDP +* path with the regular DP path. +*/
Are you planning to clarify this? Will it be part of your current refactoring (maybe in later patches)?
drivers/gpu/drm/i915/display/intel_dp.c static int dsc_compute_compressed_bpp(struct intel_dp *intel_dp, · line 2278
Quoted 8 lines
drivers/gpu/drm/i915/display/intel_dp.c +5
-0+if (!intel_dp_get_connector_max_link_config (connector, limits, &max_link_config)) +return -EINVAL ; + + pipe_config->port_clock = max_link_config.rate; + pipe_config->lane_count = max_link_config.lane_count; pipe_config->dsc.compressed_bpp_x16 = max_bpp_x16;
Regardless:
--
Cheers,
Luca.
Re: [PATCH v2 19/34] drm/i915/dp: Use link caps for eDP DSC config selection
Quoted 41 lines · Luca Coelho
Quoted 40 lines · Imre Deak
Use the link caps helper to select the maximum eDP link configuration for DSC computation, instead of using the separate max rate and lane count limits, which may not form a valid configuration after individual configs are disabled by fallback.
This is a step towards unifying configuration selection and iteration across connector types and between compute and fallback paths.
The state computation should likely consider all allowed configurations, as noted in the code comment; for now keep the existing eDP DSC behavior of selecting the maximum configuration determined by the eDP connector rate / lane config iteration order.
Signed-off-by Imre Deak <[email protected]>--- drivers/gpu/drm/i915/display/intel_dp.c | 17 ++++++++++++++--- 1 file changed, 14 insertions(+), 3 deletions(-)drivers/gpu/drm/i915/display/intel_dp.c +4
-3@@ -2248,7 +2248,7 @@ static int dsc_compute_compressed_bpp(struct intel_dp *intel_dp, int pipe_bpp) {struct intel_display *display =to_intel_display (intel_dp); -const struct intel_connector *connector =to_intel_connector (conn_state->connector); +struct intel_connector *connector =to_intel_connector (conn_state->connector);int min_bpp_x16, max_bpp_x16, bpp_step_x16;int bpp_x16;int ret;@@ -2260,8 +2260,19 @@ static int dsc_compute_compressed_bpp(struct intel_dp *intel_dp, max_bpp_x16 =align_max_compressed_bpp_x16 (connector, pipe_config->output_format, pipe_bpp, max_bpp_x16);if (intel_dp_is_edp (intel_dp)) { - pipe_config->port_clock = limits->max_rate; - pipe_config->lane_count = limits->max_lane_count; +struct intel_dp_link_config max_link_config; + +/*
Quoted 8 lines
drivers/gpu/drm/i915/display/intel_dp.c static int dsc_compute_compressed_bpp(struct intel_dp *intel_dp, · line 2270
Quoted 5 lines
drivers/gpu/drm/i915/display/intel_dp.c +5
-0+* FIXME: Clarify why eDP does not use the regular SST BW +* check and instead always uses the maximum link config, +* regardless of intel_dp::use_max_params. Then unify this eDP +* path with the regular DP path. +*/ Are you planning to clarify this? Will it be part of your current refactoring (maybe in later patches)?
This patchset doesn't want to change the behavior, so here the link configuration with the max rate and lane count is selected as before. The above comment only serves as a reminder to make the eDP case work as the SST-DP case, in a follow-up.
Quoted 16 lines
drivers/gpu/drm/i915/display/intel_dp.c static int dsc_compute_compressed_bpp(struct intel_dp *intel_dp, · line 2278
Quoted 8 lines
drivers/gpu/drm/i915/display/intel_dp.c +5
-0+if (!intel_dp_get_connector_max_link_config (connector, limits, &max_link_config)) +return -EINVAL ; + + pipe_config->port_clock = max_link_config.rate; + pipe_config->lane_count = max_link_config.lane_count; pipe_config->dsc.compressed_bpp_x16 = max_bpp_x16;Regardless:
Reviewed-by Luca Coelho <[email protected]>--
Cheers,
Luca.
PATCH v2 20/34 drm/i915/dp_mst: Use link caps for non-DSC config selection
In reply to Imre DeakUse the link caps helper to select the maximum MST link configuration for non-DSC computation, instead of using the separate max rate and lane count limits, which may not form a valid configuration after individual configs are disabled by fallback.
This is a step towards unifying configuration selection and iteration across connector types and between compute and fallback paths.
In some cases all configurations should be considered, as noted in the code comment; for now keep the existing behavior of selecting the maximum bandwidth configuration as determined by the MST connector's BW config iteration order.
--- drivers/gpu/drm/i915/display/intel_dp_mst.c | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_mst.c +14 -2
@@ -445,8 +445,20 @@ static int mst_stream_compute_link_config(struct intel_dp *intel_dp,struct drm_connector_state *conn_state, const struct link_config_limits *limits) { - crtc_state->lane_count = limits->max_lane_count; - crtc_state->port_clock = limits->max_rate; + struct intel_connector *connector = to_intel_connector(conn_state->connector); +struct intel_dp_link_config max_link_config; + +/* +* FIXME: Use a proper iteration over the link configurations, instead +* of using only the max BW config. For instance UHBR rate configs may +* have additional limitations over non-UHBR ones, due to the DSC DPT +* bpp maximum limit. +*/ +if (!intel_dp_get_connector_max_link_config (connector, limits, &max_link_config)) +return -EINVAL ; + + crtc_state->port_clock = max_link_config.rate; + crtc_state->lane_count = max_link_config.lane_count;/* * FIXME: allocate the BW according to link_bpp, which in the case of
Signature · 1 line
2.49.1
Re: [PATCH v2 20/34] drm/i915/dp_mst: Use link caps for non-DSC config selection
Quoted 35 lines · Imre Deak
Use the link caps helper to select the maximum MST link configuration for non-DSC computation, instead of using the separate max rate and lane count limits, which may not form a valid configuration after individual configs are disabled by fallback.
This is a step towards unifying configuration selection and iteration across connector types and between compute and fallback paths.
In some cases all configurations should be considered, as noted in the code comment; for now keep the existing behavior of selecting the maximum bandwidth configuration as determined by the MST connector's BW config iteration order.
Signed-off-by Imre Deak <[email protected]>--- drivers/gpu/drm/i915/display/intel_dp_mst.c | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-)drivers/gpu/drm/i915/display/intel_dp_mst.c +7
-2@@ -445,8 +445,20 @@ static int mst_stream_compute_link_config(struct intel_dp *intel_dp,struct drm_connector_state *conn_state, const struct link_config_limits *limits) { - crtc_state->lane_count = limits->max_lane_count; - crtc_state->port_clock = limits->max_rate; + struct intel_connector *connector = to_intel_connector(conn_state->connector); +struct intel_dp_link_config max_link_config; + +/* +* FIXME: Use a proper iteration over the link configurations, instead +* of using only the max BW config. For instance UHBR rate configs may +* have additional limitations over non-UHBR ones, due to the DSC DPT
drivers/gpu/drm/i915/display/intel_dp_mst.c static int mst_stream_compute_link_config(struct intel_dp *intel_dp, · line 464
Quoted 10 lines
drivers/gpu/drm/i915/display/intel_dp_mst.c +7
-0+* bpp maximum limit. +*/ +if (!intel_dp_get_connector_max_link_config (connector, limits, &max_link_config)) +return -EINVAL ; + + crtc_state->port_clock = max_link_config.rate; + crtc_state->lane_count = max_link_config.lane_count;/* * FIXME: allocate the BW according to link_bpp, which in the case of
--
Cheers,
Luca.
PATCH v2 21/34 drm/i915/dp_mst: Use link caps for MST DSC config selection
In reply to Imre DeakUse the link caps helper to select the maximum DP MST link configuration for DSC computation, instead of using the separate max rate and lane count limits, which may not form a valid configuration after individual configs are disabled by fallback.
Also look up the maximum rate for state computation via the configuration mask when checking the DSC hblank expansion quirk.
This is a step towards unifying configuration selection and iteration across connector types and between compute and fallback paths.
The state computation should likely consider all allowed configurations, as noted in the code comment; for now keep the existing DP MST DSC behavior of selecting the maximum BW configuration determined by the MST connector BW config iteration order.
--- drivers/gpu/drm/i915/display/intel_dp_mst.c | 40 +++++++++++++++++---- 1 file changed, 33 insertions(+), 7 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_mst.c +33 -7
@@ -477,6 +477,7 @@ static int mst_stream_dsc_compute_link_config(struct intel_dp *intel_dp, {struct intel_display *display =to_intel_display (intel_dp);struct intel_connector *connector =to_intel_connector (conn_state->connector); +struct intel_dp_link_config max_link_config; crtc_state->pipe_bpp = limits->pipe.max_bpp;
@@ -484,8 +485,17 @@ static int mst_stream_dsc_compute_link_config(struct intel_dp *intel_dp,"DSC Sink supported compressed min bpp " FXP_Q4_FMT " compressed max bpp " FXP_Q4_FMT "\n" , FXP_Q4_ARGS(limits->link.min_bpp_x16), FXP_Q4_ARGS(limits->link.max_bpp_x16)); - crtc_state->lane_count = limits->max_lane_count; - crtc_state->port_clock = limits->max_rate; +/* +* FIXME: Use a proper iteration over the link configurations, instead +* of using only the max BW config. For instance UHBR rate configs may +* have additional limitations over non-UHBR ones, due to the DSC DPT +* bpp maximum limit. +*/ +if (!intel_dp_get_connector_max_link_config (connector, limits, &max_link_config)) +return -EINVAL ; + + crtc_state->port_clock = max_link_config.rate; + crtc_state->lane_count = max_link_config.lane_count; return intel_dp_mtp_tu_compute_config(intel_dp, crtc_state, conn_state, limits->link.min_bpp_x16,
@@ -501,6 +511,20 @@ static int mode_hblank_period_ns(const struct drm_display_mode *mode) mode->crtc_clock); } +static int get_connector_max_rate (const struct intel_connector *connector, +const struct link_config_limits *limits) +{ +struct intel_dp *intel_dp =intel_attached_dp ((struct intel_connector *)connector); +struct intel_dp_link_caps *link_caps = intel_dp->link.caps; +struct intel_dp_link_config max_link_config; + +intel_dp_link_caps_get_max_config (link_caps, +INTEL_DP_LINK_CAPS_ORDER_KEY_RATE_LANE , + limits->link_config_filter, &max_link_config); + +return max_link_config.rate; +} + static bool hblank_expansion_quirk_needs_dsc(const struct intel_connector *connector, const struct intel_crtc_state *crtc_state,
@@ -511,11 +535,13 @@ hblank_expansion_quirk_needs_dsc(const struct intel_connector *connector,bool is_uhbr_sink = connector->mst.dp &&drm_dp_128b132b_supported (connector->mst.dp->dpcd);int hblank_limit = is_uhbr_sink ?500 :300 ; +int max_rate;if (!connector->dp.dsc_hblank_expansion_quirk)return false; -if (is_uhbr_sink && !drm_dp_is_uhbr_rate (limits->max_rate)) + max_rate =get_connector_max_rate (connector, limits); +if (is_uhbr_sink && !drm_dp_is_uhbr_rate (max_rate))return false;if (mode_hblank_period_ns (adjusted_mode) > hblank_limit)
@@ -537,6 +563,7 @@ adjust_limits_for_dsc_hblank_expansion_quirk(struct intel_dp *intel_dp,struct intel_display *display =to_intel_display (connector);const struct intel_crtc *crtc =to_intel_crtc (crtc_state->uapi.crtc);int min_bpp_x16 = limits->link.min_bpp_x16; +int max_rate;if (!hblank_expansion_quirk_needs_dsc (connector, crtc_state, limits))return true;
@@ -563,11 +590,10 @@ adjust_limits_for_dsc_hblank_expansion_quirk(struct intel_dp *intel_dp,return true; } -drm_WARN_ON (display->drm, limits->min_rate != limits->max_rate); - -if (limits->max_rate <540000 ) + max_rate =get_connector_max_rate (connector, limits); +if (max_rate <540000 ) min_bpp_x16 =fxp_q4_from_int (13 ); -else if (limits->max_rate <810000 ) +else if (max_rate <810000 ) min_bpp_x16 =fxp_q4_from_int (10 );if (limits->link.min_bpp_x16 >= min_bpp_x16)
Signature · 1 line
2.49.1
Re: [PATCH v2 21/34] drm/i915/dp_mst: Use link caps for MST DSC config selection
Quoted 102 lines · Imre Deak
Use the link caps helper to select the maximum DP MST link configuration for DSC computation, instead of using the separate max rate and lane count limits, which may not form a valid configuration after individual configs are disabled by fallback.
Also look up the maximum rate for state computation via the configuration mask when checking the DSC hblank expansion quirk.
This is a step towards unifying configuration selection and iteration across connector types and between compute and fallback paths.
The state computation should likely consider all allowed configurations, as noted in the code comment; for now keep the existing DP MST DSC behavior of selecting the maximum BW configuration determined by the MST connector BW config iteration order.
Signed-off-by Imre Deak <[email protected]>--- drivers/gpu/drm/i915/display/intel_dp_mst.c | 40 +++++++++++++++++---- 1 file changed, 33 insertions(+), 7 deletions(-)drivers/gpu/drm/i915/display/intel_dp_mst.c +30
-4@@ -477,6 +477,7 @@ static int mst_stream_dsc_compute_link_config(struct intel_dp *intel_dp, {struct intel_display *display =to_intel_display (intel_dp);struct intel_connector *connector =to_intel_connector (conn_state->connector); +struct intel_dp_link_config max_link_config; crtc_state->pipe_bpp = limits->pipe.max_bpp;@@ -484,8 +485,17 @@ static int mst_stream_dsc_compute_link_config(struct intel_dp *intel_dp,"DSC Sink supported compressed min bpp " FXP_Q4_FMT " compressed max bpp " FXP_Q4_FMT "\n" , FXP_Q4_ARGS(limits->link.min_bpp_x16), FXP_Q4_ARGS(limits->link.max_bpp_x16)); - crtc_state->lane_count = limits->max_lane_count; - crtc_state->port_clock = limits->max_rate; +/* +* FIXME: Use a proper iteration over the link configurations, instead +* of using only the max BW config. For instance UHBR rate configs may +* have additional limitations over non-UHBR ones, due to the DSC DPT +* bpp maximum limit. +*/ +if (!intel_dp_get_connector_max_link_config (connector, limits, &max_link_config)) +return -EINVAL ; + + crtc_state->port_clock = max_link_config.rate; + crtc_state->lane_count = max_link_config.lane_count; return intel_dp_mtp_tu_compute_config(intel_dp, crtc_state, conn_state, limits->link.min_bpp_x16,@@ -501,6 +511,20 @@ static int mode_hblank_period_ns(const struct drm_display_mode *mode) mode->crtc_clock); } +static int get_connector_max_rate (const struct intel_connector *connector, +const struct link_config_limits *limits) +{ +struct intel_dp *intel_dp =intel_attached_dp ((struct intel_connector *)connector); +struct intel_dp_link_caps *link_caps = intel_dp->link.caps; +struct intel_dp_link_config max_link_config; + +intel_dp_link_caps_get_max_config (link_caps, +INTEL_DP_LINK_CAPS_ORDER_KEY_RATE_LANE , + limits->link_config_filter, &max_link_config); + +return max_link_config.rate; +} + static bool hblank_expansion_quirk_needs_dsc(const struct intel_connector *connector, const struct intel_crtc_state *crtc_state,@@ -511,11 +535,13 @@ hblank_expansion_quirk_needs_dsc(const struct intel_connector *connector,bool is_uhbr_sink = connector->mst.dp &&drm_dp_128b132b_supported (connector->mst.dp->dpcd);int hblank_limit = is_uhbr_sink ?500 :300 ; +int max_rate;if (!connector->dp.dsc_hblank_expansion_quirk)return false; -if (is_uhbr_sink && !drm_dp_is_uhbr_rate (limits->max_rate)) + max_rate =get_connector_max_rate (connector, limits); +if (is_uhbr_sink && !drm_dp_is_uhbr_rate (max_rate))return false;if (mode_hblank_period_ns (adjusted_mode) > hblank_limit)@@ -537,6 +563,7 @@ adjust_limits_for_dsc_hblank_expansion_quirk(struct intel_dp *intel_dp,struct intel_display *display =to_intel_display (connector);const struct intel_crtc *crtc =to_intel_crtc (crtc_state->uapi.crtc);int min_bpp_x16 = limits->link.min_bpp_x16; +int max_rate;if (!hblank_expansion_quirk_needs_dsc (connector, crtc_state, limits))return true;@@ -563,11 +590,10 @@ adjust_limits_for_dsc_hblank_expansion_quirk(struct intel_dp *intel_dp,return true; } -drm_WARN_ON (display->drm, limits->min_rate != limits->max_rate);
drivers/gpu/drm/i915/display/intel_dp_mst.c adjust_limits_for_dsc_hblank_expansion_quirk(struct intel_dp *intel_dp, · line 599
Quoted 10 lines
drivers/gpu/drm/i915/display/intel_dp_mst.c +3
-3- -if (limits->max_rate <540000 ) + max_rate =get_connector_max_rate (connector, limits); +if (max_rate <540000 ) min_bpp_x16 =fxp_q4_from_int (13 ); -else if (limits->max_rate <810000 ) +else if (max_rate <810000 ) min_bpp_x16 =fxp_q4_from_int (10 );if (limits->link.min_bpp_x16 >= min_bpp_x16)
--
Cheers,
Luca.
PATCH v2 22/34 drm/i915/dp: Remove min/max link config limits
In reply to Imre DeakRemove the min/max rate and lane count fields from struct link_config_limits after all state computation is converted to use the configuration filter.
A simple min/max range cannot fully describe the valid configuration set once individual configurations are disabled (for example by fallback), as it may allow combinations that are not actually valid. The configuration filter, on the other hand, always represents a consistent set of valid configurations.
--- drivers/gpu/drm/i915/display/intel_dp.c | 86 ------------------- drivers/gpu/drm/i915/display/intel_dp.h | 6 -- .../gpu/drm/i915/display/intel_dp_link_caps.c | 4 +- .../gpu/drm/i915/display/intel_dp_link_caps.h | 2 - drivers/gpu/drm/i915/display/intel_dp_test.c | 23 ----- 5 files changed, 2 insertions(+), 119 deletions(-)
drivers/gpu/drm/i915/display/intel_dp.c +0 -86
@@ -354,44 +354,6 @@ static int intel_dp_get_max_common_lane_count(struct intel_dp *intel_dp)return min3 (source_max, sink_max, lane_max); } -static int intel_dp_max_lane_count (struct intel_dp *intel_dp) -{ -struct intel_dp_link_caps *link_caps = intel_dp->link.caps; -struct intel_dp_link_config max_link_limits; -struct intel_dp_link_config forced_params; -int lane_count; - -intel_dp_link_caps_get_max_limits (link_caps, &max_link_limits); -intel_dp_link_caps_get_forced_params (link_caps, &forced_params); - -if (forced_params.lane_count) - lane_count = forced_params.lane_count; -else - lane_count = max_link_limits.lane_count; - -switch (lane_count) { -case 1 : -case 2 : -case 4 : -return lane_count; -default : -MISSING_CASE (lane_count); -return 1 ; - } -} - -static int intel_dp_min_lane_count (struct intel_dp *intel_dp) -{ -struct intel_dp_link_config forced_params; - -intel_dp_link_caps_get_forced_params (intel_dp->link.caps, &forced_params); - -if (forced_params.lane_count) -return forced_params.lane_count; - -return 1 ; -} -int intel_dp_link_bw_overhead (int link_clock,int lane_count,int hdisplay,int dsc_slice_count,int bpp_x16,unsigned long flags) {
@@ -1540,39 +1502,6 @@ static void intel_dp_print_rates(struct intel_dp *intel_dp)intel_dp_link_caps_print_common_rates (intel_dp->link.caps); } -static int -intel_dp_max_link_rate (struct intel_dp *intel_dp) -{ -struct intel_dp_link_caps *link_caps = intel_dp->link.caps; -struct intel_dp_link_config max_link_limits; -struct intel_dp_link_config forced_params; -int len; - -intel_dp_link_caps_get_forced_params (link_caps, &forced_params); - -if (forced_params.rate) -return forced_params.rate; - -intel_dp_link_caps_get_max_limits (link_caps, &max_link_limits); - len =intel_dp_common_len_rate_limit (link_caps, max_link_limits.rate); - -return intel_dp_common_rate (link_caps, len -1 ); -} - -static int -intel_dp_min_link_rate (struct intel_dp *intel_dp) -{ -struct intel_dp_link_caps *link_caps = intel_dp->link.caps; -struct intel_dp_link_config forced_params; - -intel_dp_link_caps_get_forced_params (intel_dp->link.caps, &forced_params); - -if (forced_params.rate) -return forced_params.rate; - -return intel_dp_common_rate (link_caps,0 ); -} -int intel_dp_rate_select (struct intel_dp *intel_dp,int rate) {struct intel_display *display =to_intel_display (intel_dp);
@@ -2711,18 +2640,6 @@ intel_dp_compute_config_limits(struct intel_dp *intel_dp,struct intel_connector *connector =to_intel_connector (conn_state->connector); -/* -* Remove the following min/max rate and lane count setup, once -* all users are converted to use link_config_mask instead. -*/ - limits->min_rate =intel_dp_min_link_rate (intel_dp); - limits->max_rate =intel_dp_max_link_rate (intel_dp); - - limits->min_rate =min (limits->min_rate, limits->max_rate); - - limits->min_lane_count =intel_dp_min_lane_count (intel_dp); - limits->max_lane_count =intel_dp_max_lane_count (intel_dp); - limits->link_config_filter =INTEL_DP_LINK_CAPS_FILTER_ALL ; limits->pipe.min_bpp =intel_dp_min_bpp (crtc_state->output_format);
@@ -2802,9 +2719,6 @@ intel_dp_compute_config_limits(struct intel_dp *intel_dp,* configuration, and typically on older panels these * values correspond to the native resolution of the panel. */ - limits->min_lane_count = limits->max_lane_count; - limits->min_rate = limits->max_rate; -if (!intel_dp_get_connector_max_link_config (connector, limits, &max_config))return false;
drivers/gpu/drm/i915/display/intel_dp.h +0 -6
@@ -28,12 +28,6 @@ struct intel_dp_link_config;struct intel_encoder ;struct link_config_limits { -/* -* TODO: Remove the following min/max rate and lane count limits -* once all users are converted to use link_config_mask instead. -*/ -int min_rate, max_rate; -int min_lane_count, max_lane_count;struct intel_dp_link_caps_filter link_config_filter;struct {/* Uncompressed DSC input or link output bpp in 1 bpp units */
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +2 -2
@@ -242,8 +242,8 @@ intel_dp_link_caps_connector_fallback_order(bool is_mst) }/* Get length of common rates array potentially limited by max_rate. */ -int intel_dp_common_len_rate_limit (struct intel_dp_link_caps *link_caps, -int max_rate) +static int intel_dp_common_len_rate_limit (struct intel_dp_link_caps *link_caps, +int max_rate) {return intel_dp_rate_limit_len (link_caps->rates, link_caps->num_rates, max_rate);
drivers/gpu/drm/i915/display/intel_dp_link_caps.h +0 -2
@@ -119,8 +119,6 @@ intel_dp_link_caps_connector_compute_order(struct intel_connector *connector);struct intel_dp_link_caps_order intel_dp_link_caps_connector_fallback_order (bool is_mst); -int intel_dp_common_len_rate_limit (struct intel_dp_link_caps *link_caps, -int max_rate);int intel_dp_common_rate (struct intel_dp_link_caps *link_caps,int index);int intel_dp_link_caps_common_rate_idx (struct intel_dp_link_caps *link_caps,int rate);int intel_dp_max_common_rate (struct intel_dp_link_caps *link_caps);
drivers/gpu/drm/i915/display/intel_dp_test.c +0 -23
@@ -114,7 +114,6 @@ bool intel_dp_test_compute_config(struct intel_connector *connector, struct link_config_limits *limits) {struct intel_dp *intel_dp =intel_attached_dp (connector); -struct intel_dp_link_caps *link_caps = intel_dp->link.caps;struct intel_display *display =to_intel_display (intel_dp);/* For DP Compliance we override the computed bpp for the pipe */
@@ -130,28 +129,6 @@ bool intel_dp_test_compute_config(struct intel_connector *connector,/* Use values requested by Compliance Test Request */ if (intel_dp->compliance.test_type == DP_TEST_LINK_TRAINING) { - int index; - - /* - * TODO: Remove the following min/max link limit setup - * after converting to use the link configuration filter - * instead in limits. - */ - /* Validate the compliance test data since max values - * might have changed due to link train fallback. - */ - if (intel_dp_link_params_valid(intel_dp, intel_dp->compliance.test_link_rate, - intel_dp->compliance.test_lane_count)) { - index = intel_dp_link_caps_common_rate_idx(link_caps, - intel_dp->compliance.test_link_rate); - if (index >= 0) { - limits->min_rate = intel_dp->compliance.test_link_rate; - limits->max_rate = intel_dp->compliance.test_link_rate; - } - limits->min_lane_count = intel_dp->compliance.test_lane_count; - limits->max_lane_count = intel_dp->compliance.test_lane_count; - } - if (!set_filter_for_link_params(connector, intel_dp->compliance.test_link_rate, intel_dp->compliance.test_lane_count,
Signature · 1 line
2.49.1
Re: [PATCH v2 22/34] drm/i915/dp: Remove min/max link config limits
Quoted 213 lines · Imre Deak
Remove the min/max rate and lane count fields from struct
link_config_limitsafter all state computation is converted to use the configuration filter.A simple min/max range cannot fully describe the valid configuration set once individual configurations are disabled (for example by fallback), as it may allow combinations that are not actually valid. The configuration filter, on the other hand, always represents a consistent set of valid configurations.
Signed-off-by Imre Deak <[email protected]>--- drivers/gpu/drm/i915/display/intel_dp.c | 86 ------------------- drivers/gpu/drm/i915/display/intel_dp.h | 6 -- .../gpu/drm/i915/display/intel_dp_link_caps.c | 4 +- .../gpu/drm/i915/display/intel_dp_link_caps.h | 2 - drivers/gpu/drm/i915/display/intel_dp_test.c | 23 ----- 5 files changed, 2 insertions(+), 119 deletions(-)drivers/gpu/drm/i915/display/intel_dp.c +0
-86@@ -354,44 +354,6 @@ static int intel_dp_get_max_common_lane_count(struct intel_dp *intel_dp)return min3 (source_max, sink_max, lane_max); } -static int intel_dp_max_lane_count (struct intel_dp *intel_dp) -{ -struct intel_dp_link_caps *link_caps = intel_dp->link.caps; -struct intel_dp_link_config max_link_limits; -struct intel_dp_link_config forced_params; -int lane_count; - -intel_dp_link_caps_get_max_limits (link_caps, &max_link_limits); -intel_dp_link_caps_get_forced_params (link_caps, &forced_params); - -if (forced_params.lane_count) - lane_count = forced_params.lane_count; -else - lane_count = max_link_limits.lane_count; - -switch (lane_count) { -case 1 : -case 2 : -case 4 : -return lane_count; -default : -MISSING_CASE (lane_count); -return 1 ; - } -} - -static int intel_dp_min_lane_count (struct intel_dp *intel_dp) -{ -struct intel_dp_link_config forced_params; - -intel_dp_link_caps_get_forced_params (intel_dp->link.caps, &forced_params); - -if (forced_params.lane_count) -return forced_params.lane_count; - -return 1 ; -} -int intel_dp_link_bw_overhead (int link_clock,int lane_count,int hdisplay,int dsc_slice_count,int bpp_x16,unsigned long flags) {@@ -1540,39 +1502,6 @@ static void intel_dp_print_rates(struct intel_dp *intel_dp)intel_dp_link_caps_print_common_rates (intel_dp->link.caps); } -static int -intel_dp_max_link_rate (struct intel_dp *intel_dp) -{ -struct intel_dp_link_caps *link_caps = intel_dp->link.caps; -struct intel_dp_link_config max_link_limits; -struct intel_dp_link_config forced_params; -int len; - -intel_dp_link_caps_get_forced_params (link_caps, &forced_params); - -if (forced_params.rate) -return forced_params.rate; - -intel_dp_link_caps_get_max_limits (link_caps, &max_link_limits); - len =intel_dp_common_len_rate_limit (link_caps, max_link_limits.rate); - -return intel_dp_common_rate (link_caps, len -1 ); -} - -static int -intel_dp_min_link_rate (struct intel_dp *intel_dp) -{ -struct intel_dp_link_caps *link_caps = intel_dp->link.caps; -struct intel_dp_link_config forced_params; - -intel_dp_link_caps_get_forced_params (intel_dp->link.caps, &forced_params); - -if (forced_params.rate) -return forced_params.rate; - -return intel_dp_common_rate (link_caps,0 ); -} -int intel_dp_rate_select (struct intel_dp *intel_dp,int rate) {struct intel_display *display =to_intel_display (intel_dp);@@ -2711,18 +2640,6 @@ intel_dp_compute_config_limits(struct intel_dp *intel_dp,struct intel_connector *connector =to_intel_connector (conn_state->connector); -/* -* Remove the following min/max rate and lane count setup, once -* all users are converted to use link_config_mask instead. -*/ - limits->min_rate =intel_dp_min_link_rate (intel_dp); - limits->max_rate =intel_dp_max_link_rate (intel_dp); - - limits->min_rate =min (limits->min_rate, limits->max_rate); - - limits->min_lane_count =intel_dp_min_lane_count (intel_dp); - limits->max_lane_count =intel_dp_max_lane_count (intel_dp); - limits->link_config_filter =INTEL_DP_LINK_CAPS_FILTER_ALL ; limits->pipe.min_bpp =intel_dp_min_bpp (crtc_state->output_format);@@ -2802,9 +2719,6 @@ intel_dp_compute_config_limits(struct intel_dp *intel_dp,* configuration, and typically on older panels these * values correspond to the native resolution of the panel. */ - limits->min_lane_count = limits->max_lane_count; - limits->min_rate = limits->max_rate; -if (!intel_dp_get_connector_max_link_config (connector, limits, &max_config))return false;drivers/gpu/drm/i915/display/intel_dp.h +0
-6@@ -28,12 +28,6 @@ struct intel_dp_link_config;struct intel_encoder ;struct link_config_limits { -/* -* TODO: Remove the following min/max rate and lane count limits -* once all users are converted to use link_config_mask instead. -*/ -int min_rate, max_rate; -int min_lane_count, max_lane_count;struct intel_dp_link_caps_filter link_config_filter;struct {/* Uncompressed DSC input or link output bpp in 1 bpp units */ drivers/gpu/drm/i915/display/intel_dp_link_caps.c +2
-2@@ -242,8 +242,8 @@ intel_dp_link_caps_connector_fallback_order(bool is_mst) }/* Get length of common rates array potentially limited by max_rate. */ -int intel_dp_common_len_rate_limit (struct intel_dp_link_caps *link_caps, -int max_rate) +static int intel_dp_common_len_rate_limit (struct intel_dp_link_caps *link_caps, +int max_rate) {return intel_dp_rate_limit_len (link_caps->rates, link_caps->num_rates, max_rate);drivers/gpu/drm/i915/display/intel_dp_link_caps.h +0
-2@@ -119,8 +119,6 @@ intel_dp_link_caps_connector_compute_order(struct intel_connector *connector);struct intel_dp_link_caps_order intel_dp_link_caps_connector_fallback_order (bool is_mst); -int intel_dp_common_len_rate_limit (struct intel_dp_link_caps *link_caps, -int max_rate);int intel_dp_common_rate (struct intel_dp_link_caps *link_caps,int index);int intel_dp_link_caps_common_rate_idx (struct intel_dp_link_caps *link_caps,int rate);int intel_dp_max_common_rate (struct intel_dp_link_caps *link_caps);drivers/gpu/drm/i915/display/intel_dp_test.c +0
-16@@ -114,7 +114,6 @@ bool intel_dp_test_compute_config(struct intel_connector *connector, struct link_config_limits *limits) {struct intel_dp *intel_dp =intel_attached_dp (connector); -struct intel_dp_link_caps *link_caps = intel_dp->link.caps;struct intel_display *display =to_intel_display (intel_dp);/* For DP Compliance we override the computed bpp for the pipe */ @@ -130,28 +129,6 @@ bool intel_dp_test_compute_config(struct intel_connector *connector,/* Use values requested by Compliance Test Request */ if (intel_dp->compliance.test_type ==DP_TEST_LINK_TRAINING ) { -int index; - -/* -* TODO: Remove the following min/max link limit setup -* after converting to use the link configuration filter -* instead in limits. -*/ -/* Validate the compliance test data since max values -* might have changed due to link train fallback. -*/ -if (intel_dp_link_params_valid (intel_dp, intel_dp->compliance.test_link_rate, - intel_dp->compliance.test_lane_count)) { - index =intel_dp_link_caps_common_rate_idx (link_caps, - intel_dp->compliance.test_link_rate); -if (index >=0 ) {
drivers/gpu/drm/i915/display/intel_dp_test.c bool intel_dp_test_compute_config(struct intel_connector *connector, · line 134
Quoted 10 lines
drivers/gpu/drm/i915/display/intel_dp_test.c +0
-7- limits->min_rate = intel_dp->compliance.test_link_rate; - limits->max_rate = intel_dp->compliance.test_link_rate; - } - limits->min_lane_count = intel_dp->compliance.test_lane_count; - limits->max_lane_count = intel_dp->compliance.test_lane_count; - } - if (!set_filter_for_link_params(connector, intel_dp->compliance.test_link_rate, intel_dp->compliance.test_lane_count,
--
Cheers,
Luca.
PATCH v2 23/34 drm/i915/dp_link_training: Reset the max link limits in the fallback code
In reply to Imre DeakThe target maximum rate/lane count selected by the fallback logic may exceed the current link_caps max_limits' rate/lane count, the latter of which are used as a limit by the lookup functions when filtering allowed configurations. To ensure the fallback search finds all relevant candidates, temporarily reset the link_caps max_limits to the maximum common supported capabilities.
After the fallback search completes, set the link_caps max_limits to the configuration selected by the fallback logic, as before, determining the allowed configurations for a subsequent modeset.
--- .../drm/i915/display/intel_dp_link_training.c | 39 ++++++++++++++++--- 1 file changed, 34 insertions(+), 5 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_training.c +34 -5
@@ -1960,10 +1960,12 @@ static bool reduce_link_params(struct intel_dp *intel_dp, const struct intel_crtstatic int intel_dp_get_link_train_fallback_values (struct intel_dp *intel_dp,const struct intel_crtc_state *crtc_state) { +struct intel_display *display =to_intel_display (intel_dp);struct intel_dp_link_caps *link_caps = intel_dp->link.caps;struct intel_dp_link_config max_link_limits;int new_link_rate;int new_lane_count; +int err =-1 ;if (intel_dp_is_edp (intel_dp) && !intel_dp->use_max_params) { lt_dbg(intel_dp, DP_PHY_DPRX,
@@ -1972,14 +1974,32 @@ static int intel_dp_get_link_train_fallback_values(struct intel_dp *intel_dp,return 0 ; } +/* +* Temporarily reset the max link limit before selecting the fallback +* config. +* +* After fallback, the current logic narrows the allowed configurations +* to the selected config's rate and lane count. That can make a later +* fallback candidate fall outside the current max_limit, so reset it +* before searching. +* +* TODO: Constrain the allowed configurations by only disabling individual +* configurations and remove setting maximum link parameters. +*/ +intel_dp_link_caps_get_max_limits (link_caps, &max_link_limits); +intel_dp_link_caps_reset_max_limits (link_caps); +if (!reduce_link_params (intel_dp, crtc_state, &new_link_rate, &new_lane_count)) -return -1 ; + goto out_restore_max_limits;if (intel_dp_is_edp (intel_dp) && !intel_dp_can_link_train_fallback_for_edp (intel_dp, new_link_rate, new_lane_count)) {lt_dbg (intel_dp,DP_PHY_DPRX ,"Retrying Link training for eDP with same parameters\n" ); -return 0 ; + + err =0 ; + + goto out_restore_max_limits; } lt_dbg(intel_dp, DP_PHY_DPRX,
@@ -1990,10 +2010,19 @@ static int intel_dp_get_link_train_fallback_values(struct intel_dp *intel_dp, max_link_limits.rate = new_link_rate; max_link_limits.lane_count = new_lane_count; -/* TODO: handle an update failure */ -intel_dp_link_caps_set_max_limits (link_caps, &max_link_limits); + err =0 ; -return 0 ; +out_restore_max_limits: +/* +* Shouldn't fail: setting max_limits can only fail if they drop below +* the optionally forced rate/lane-count parameters, but the reduced +* config was chosen to satisfy those constraints. +*/ +if (drm_WARN_ON (display->drm, + !intel_dp_link_caps_set_max_limits (link_caps, &max_link_limits))) + err =-1 ; + +return err; } static bool intel_dp_schedule_fallback_link_training(struct intel_atomic_state *state,
Signature · 1 line
2.49.1
Re: [PATCH v2 23/34] drm/i915/dp_link_training: Reset the max link limits in the fallback code
Quoted 81 lines · Imre Deak
The target maximum rate/lane count selected by the fallback logic may exceed the current
link_capsmax_limits' rate/lane count, the latter of which are used as a limit by the lookup functions when filtering allowed configurations. To ensure the fallback search finds all relevant candidates, temporarily reset thelink_capsmax_limitsto the maximum common supported capabilities.After the fallback search completes, set the
link_capsmax_limitsto the configuration selected by the fallback logic, as before, determining the allowed configurations for a subsequent modeset.Signed-off-by Imre Deak <[email protected]>--- .../drm/i915/display/intel_dp_link_training.c | 39 ++++++++++++++++--- 1 file changed, 34 insertions(+), 5 deletions(-)drivers/gpu/drm/i915/display/intel_dp_link_training.c +27
-5@@ -1960,10 +1960,12 @@ static bool reduce_link_params(struct intel_dp *intel_dp, const struct intel_crtstatic int intel_dp_get_link_train_fallback_values (struct intel_dp *intel_dp,const struct intel_crtc_state *crtc_state) { +struct intel_display *display =to_intel_display (intel_dp);struct intel_dp_link_caps *link_caps = intel_dp->link.caps;struct intel_dp_link_config max_link_limits;int new_link_rate;int new_lane_count; +int err =-1 ;if (intel_dp_is_edp (intel_dp) && !intel_dp->use_max_params) { lt_dbg(intel_dp, DP_PHY_DPRX,@@ -1972,14 +1974,32 @@ static int intel_dp_get_link_train_fallback_values(struct intel_dp *intel_dp,return 0 ; } +/* +* Temporarily reset the max link limit before selecting the fallback +* config. +* +* After fallback, the current logic narrows the allowed configurations +* to the selected config's rate and lane count. That can make a later +* fallback candidate fall outside the current max_limit, so reset it +* before searching. +* +* TODO: Constrain the allowed configurations by only disabling individual +* configurations and remove setting maximum link parameters. +*/ +intel_dp_link_caps_get_max_limits (link_caps, &max_link_limits); +intel_dp_link_caps_reset_max_limits (link_caps); +if (!reduce_link_params (intel_dp, crtc_state, &new_link_rate, &new_lane_count)) -return -1 ; + goto out_restore_max_limits;if (intel_dp_is_edp (intel_dp) && !intel_dp_can_link_train_fallback_for_edp (intel_dp, new_link_rate, new_lane_count)) {lt_dbg (intel_dp,DP_PHY_DPRX ,"Retrying Link training for eDP with same parameters\n" ); -return 0 ; + + err =0 ; + + goto out_restore_max_limits; } lt_dbg(intel_dp, DP_PHY_DPRX,@@ -1990,10 +2010,19 @@ static int intel_dp_get_link_train_fallback_values(struct intel_dp *intel_dp, max_link_limits.rate = new_link_rate; max_link_limits.lane_count = new_lane_count; -/* TODO: handle an update failure */ -intel_dp_link_caps_set_max_limits (link_caps, &max_link_limits); + err =0 ; -return 0 ; +out_restore_max_limits: +/* +* Shouldn't fail: setting max_limits can only fail if they drop below +* the optionally forced rate/lane-count parameters, but the reduced
drivers/gpu/drm/i915/display/intel_dp_link_training.c static int intel_dp_get_link_train_fallback_values(struct intel_dp *intel_dp, · line 2028
Quoted 10 lines
drivers/gpu/drm/i915/display/intel_dp_link_training.c +7
-0+* config was chosen to satisfy those constraints. +*/ +if (drm_WARN_ON (display->drm, + !intel_dp_link_caps_set_max_limits (link_caps, &max_link_limits))) + err =-1 ; + +return err; } static bool intel_dp_schedule_fallback_link_training(struct intel_atomic_state *state,
--
Cheers,
Luca.
PATCH v2 24/34 drm/i915/dp_link_training: Use config iterator for fallback
In reply to Imre DeakSwitch the fallback loop to use the link configuration iterator to select a fallback configuration.
This also allows unexporting and removing from the link caps interface all the common link rate query helpers and the helpers that accept or return a link configuration index.
--- .../gpu/drm/i915/display/intel_dp_link_caps.c | 45 +----- .../gpu/drm/i915/display/intel_dp_link_caps.h | 9 -- .../drm/i915/display/intel_dp_link_training.c | 143 +++++------------- 3 files changed, 39 insertions(+), 158 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +2 -43
@@ -249,7 +249,7 @@ static int intel_dp_common_len_rate_limit(struct intel_dp_link_caps *link_caps, link_caps->num_rates, max_rate); } -int intel_dp_common_rate (struct intel_dp_link_caps *link_caps,int index) +static int intel_dp_common_rate (struct intel_dp_link_caps *link_caps,int index) {struct intel_display *display =to_intel_display (link_caps->dp);
@@ -260,15 +260,8 @@ int intel_dp_common_rate(struct intel_dp_link_caps *link_caps, int index)return link_caps->rates[index]; } -int intel_dp_link_caps_common_rate_idx (struct intel_dp_link_caps *link_caps,int rate) -{ -return intel_dp_rate_index (link_caps->rates, - link_caps->num_rates, - rate); -} -/* Theoretical max between source and sink */ -int intel_dp_max_common_rate (struct intel_dp_link_caps *link_caps) +static int intel_dp_max_common_rate (struct intel_dp_link_caps *link_caps) {return intel_dp_common_rate (link_caps, link_caps->num_rates -1 ); }
@@ -870,40 +863,6 @@ bool intel_dp_link_caps_update(struct intel_dp_link_caps *link_caps,return link_params_changed; } -void intel_dp_link_config_get (struct intel_dp_link_caps *link_caps, -int idx,int *link_rate,int *lane_count) -{ -struct intel_display *display =to_intel_display (link_caps->dp); -struct intel_dp_link_config config; - -if (drm_WARN_ON (display->drm, idx <0 || idx >= link_caps->num_configs)) - idx =0 ; - -to_intel_dp_link_config (link_caps, idx, &config); - - *link_rate = config.rate; - *lane_count = config.lane_count; -} - -int intel_dp_link_config_index (struct intel_dp_link_caps *link_caps, -int link_rate,int lane_count) -{ -int link_rate_idx =intel_dp_rate_index (link_caps->rates, link_caps->num_rates, - link_rate); -int lane_count_exp =ilog2 (lane_count); -int i; - -for (i =0 ; i < link_caps->num_configs; i++) { -const struct intel_dp_link_config_entry *lce = &link_caps->configs[i]; - -if (lce->lane_count_exp == lane_count_exp && - lce->link_rate_idx == link_rate_idx) -return i; - } - -return -1 ; -} -/** * intel_dp_link_caps_reset - reset link capability restrictions * @link_caps: link capabilities state
drivers/gpu/drm/i915/display/intel_dp_link_caps.h +0 -9
@@ -119,20 +119,11 @@ intel_dp_link_caps_connector_compute_order(struct intel_connector *connector);struct intel_dp_link_caps_order intel_dp_link_caps_connector_fallback_order (bool is_mst); -int intel_dp_common_rate (struct intel_dp_link_caps *link_caps,int index); -int intel_dp_link_caps_common_rate_idx (struct intel_dp_link_caps *link_caps,int rate); -int intel_dp_max_common_rate (struct intel_dp_link_caps *link_caps); -void intel_dp_link_caps_print_common_rates (struct intel_dp_link_caps *link_caps);void intel_dp_link_caps_get_forced_params (struct intel_dp_link_caps *link_caps,struct intel_dp_link_config *forced_params); -int intel_dp_link_config_index (struct intel_dp_link_caps *link_caps, -int link_rate,int lane_count); -void intel_dp_link_config_get (struct intel_dp_link_caps *link_caps, -int idx,int *link_rate,int *lane_count); -bool intel_dp_link_caps_filter_add (struct intel_dp_link_caps *link_caps,struct intel_dp_link_caps_filter *filter,const struct intel_dp_link_config *config);
drivers/gpu/drm/i915/display/intel_dp_link_training.c +37 -106
152 lines not on this page · raw message
Signature · 1 line
2.49.1
Re: [PATCH v2 24/34] drm/i915/dp_link_training: Use config iterator for fallback
Quoted 257 lines · Imre Deak
Switch the fallback loop to use the link configuration iterator to select a fallback configuration.
This also allows unexporting and removing from the link caps interface all the common link rate query helpers and the helpers that accept or return a link configuration index.
Signed-off-by Imre Deak <[email protected]>--- .../gpu/drm/i915/display/intel_dp_link_caps.c | 45 +----- .../gpu/drm/i915/display/intel_dp_link_caps.h | 9 -- .../drm/i915/display/intel_dp_link_training.c | 143 +++++------------- 3 files changed, 39 insertions(+), 158 deletions(-)drivers/gpu/drm/i915/display/intel_dp_link_caps.c +2
-43@@ -249,7 +249,7 @@ static int intel_dp_common_len_rate_limit(struct intel_dp_link_caps *link_caps, link_caps->num_rates, max_rate); } -int intel_dp_common_rate (struct intel_dp_link_caps *link_caps,int index) +static int intel_dp_common_rate (struct intel_dp_link_caps *link_caps,int index) {struct intel_display *display =to_intel_display (link_caps->dp);@@ -260,15 +260,8 @@ int intel_dp_common_rate(struct intel_dp_link_caps *link_caps, int index)return link_caps->rates[index]; } -int intel_dp_link_caps_common_rate_idx (struct intel_dp_link_caps *link_caps,int rate) -{ -return intel_dp_rate_index (link_caps->rates, - link_caps->num_rates, - rate); -} -/* Theoretical max between source and sink */ -int intel_dp_max_common_rate (struct intel_dp_link_caps *link_caps) +static int intel_dp_max_common_rate (struct intel_dp_link_caps *link_caps) {return intel_dp_common_rate (link_caps, link_caps->num_rates -1 ); }@@ -870,40 +863,6 @@ bool intel_dp_link_caps_update(struct intel_dp_link_caps *link_caps,return link_params_changed; } -void intel_dp_link_config_get (struct intel_dp_link_caps *link_caps, -int idx,int *link_rate,int *lane_count) -{ -struct intel_display *display =to_intel_display (link_caps->dp); -struct intel_dp_link_config config; - -if (drm_WARN_ON (display->drm, idx <0 || idx >= link_caps->num_configs)) - idx =0 ; - -to_intel_dp_link_config (link_caps, idx, &config); - - *link_rate = config.rate; - *lane_count = config.lane_count; -} - -int intel_dp_link_config_index (struct intel_dp_link_caps *link_caps, -int link_rate,int lane_count) -{ -int link_rate_idx =intel_dp_rate_index (link_caps->rates, link_caps->num_rates, - link_rate); -int lane_count_exp =ilog2 (lane_count); -int i; - -for (i =0 ; i < link_caps->num_configs; i++) { -const struct intel_dp_link_config_entry *lce = &link_caps->configs[i]; - -if (lce->lane_count_exp == lane_count_exp && - lce->link_rate_idx == link_rate_idx) -return i; - } - -return -1 ; -} -/** * intel_dp_link_caps_reset - reset link capability restrictions * @link_caps: link capabilities state drivers/gpu/drm/i915/display/intel_dp_link_caps.h +0
-9@@ -119,20 +119,11 @@ intel_dp_link_caps_connector_compute_order(struct intel_connector *connector);struct intel_dp_link_caps_order intel_dp_link_caps_connector_fallback_order (bool is_mst); -int intel_dp_common_rate (struct intel_dp_link_caps *link_caps,int index); -int intel_dp_link_caps_common_rate_idx (struct intel_dp_link_caps *link_caps,int rate); -int intel_dp_max_common_rate (struct intel_dp_link_caps *link_caps); -void intel_dp_link_caps_print_common_rates (struct intel_dp_link_caps *link_caps);void intel_dp_link_caps_get_forced_params (struct intel_dp_link_caps *link_caps,struct intel_dp_link_config *forced_params); -int intel_dp_link_config_index (struct intel_dp_link_caps *link_caps, -int link_rate,int lane_count); -void intel_dp_link_config_get (struct intel_dp_link_caps *link_caps, -int idx,int *link_rate,int *lane_count); -bool intel_dp_link_caps_filter_add (struct intel_dp_link_caps *link_caps,struct intel_dp_link_caps_filter *filter,const struct intel_dp_link_config *config);drivers/gpu/drm/i915/display/intel_dp_link_training.c +30
-106@@ -1846,115 +1846,46 @@ static bool intel_dp_can_link_train_fallback_for_edp(struct intel_dp *intel_dp,return true; } -static bool reduce_link_params_in_bw_order (struct intel_dp *intel_dp, -const struct intel_crtc_state *crtc_state, -int *new_link_rate,int *new_lane_count) -{ -struct intel_dp_link_caps *link_caps = intel_dp->link.caps; -struct intel_dp_link_config forced_params; -int link_rate; -int lane_count; -int i; - -intel_dp_link_caps_get_forced_params (link_caps, &forced_params); - - i =intel_dp_link_config_index (intel_dp->link.caps, - crtc_state->port_clock, crtc_state->lane_count); -for (i--; i >=0 ; i--) { -intel_dp_link_config_get (intel_dp->link.caps, i, &link_rate, &lane_count); - -if ((forced_params.rate && - forced_params.rate != link_rate) || - (forced_params.lane_count && - forced_params.lane_count != lane_count)) -continue ; - -break ; - } - -if (i <0 ) -return false; - - *new_link_rate = link_rate; - *new_lane_count = lane_count; - -return true; -} - -static int reduce_link_rate (struct intel_dp *intel_dp,int current_rate) -{ -struct intel_dp_link_caps *link_caps = intel_dp->link.caps; -struct intel_dp_link_config forced_params; -int rate_index; -int new_rate; - -intel_dp_link_caps_get_forced_params (link_caps, &forced_params); -if (forced_params.rate) -return -1 ; - - rate_index =intel_dp_link_caps_common_rate_idx (link_caps, - current_rate); - -if (rate_index <=0 ) -return -1 ; - - new_rate =intel_dp_common_rate (link_caps, rate_index -1 ); - -/* TODO: Make switching from UHBR to non-UHBR rates work. */ -if (drm_dp_is_uhbr_rate (current_rate) !=drm_dp_is_uhbr_rate (new_rate)) -return -1 ; - -return new_rate; -} - -static int reduce_lane_count (struct intel_dp *intel_dp,int current_lane_count) -{ -struct intel_dp_link_config forced_params; - -intel_dp_link_caps_get_forced_params (intel_dp->link.caps, &forced_params); -if (forced_params.lane_count) -return -1 ; - -if (current_lane_count ==1 ) -return -1 ; - -return current_lane_count >>1 ; -} - -static bool reduce_link_params_in_rate_lane_order (struct intel_dp *intel_dp, -const struct intel_crtc_state *crtc_state, -int *new_link_rate,int *new_lane_count) -{ -struct intel_dp_link_caps *link_caps = intel_dp->link.caps; -int link_rate; -int lane_count; - - lane_count = crtc_state->lane_count; - link_rate =reduce_link_rate (intel_dp, crtc_state->port_clock); -if (link_rate <0 ) { - lane_count =reduce_lane_count (intel_dp, crtc_state->lane_count); - link_rate =intel_dp_max_common_rate (link_caps); - } - -if (lane_count <0 ) -return false; - - *new_link_rate = link_rate; - *new_lane_count = lane_count; - -return true; -} -static bool reduce_link_params (struct intel_dp *intel_dp,const struct intel_crtc_state *crtc_state,int *new_link_rate,int *new_lane_count) { -/* TODO: Use the same fallback logic on SST as on MST. */ -if (intel_crtc_has_type (crtc_state,INTEL_OUTPUT_DP_MST )) -return reduce_link_params_in_bw_order (intel_dp, crtc_state, - new_link_rate, new_lane_count); -else -return reduce_link_params_in_rate_lane_order (intel_dp, crtc_state, - new_link_rate, new_lane_count); +struct intel_dp_link_caps *link_caps = intel_dp->link.caps; +bool is_mst =intel_crtc_has_type (crtc_state,INTEL_OUTPUT_DP_MST ); +struct intel_dp_link_caps_order order = +intel_dp_link_caps_connector_fallback_order (is_mst); +struct intel_dp_link_config old_config = { + .rate = crtc_state->port_clock, + .lane_count = crtc_state->lane_count, + }; +struct intel_dp_link_caps_iter iter; +struct intel_dp_link_config config; +bool old_found = false; +bool new_found = false; + +intel_dp_link_caps_iter_start (&iter, link_caps, order,INTEL_DP_LINK_CAPS_FILTER_ALL ); +for_each_dp_link_config (&iter, &config) { +if (!old_found) { +if (config.rate == old_config.rate && + config.lane_count == old_config.lane_count) + old_found = true; + +continue ; + } + +if (!is_mst && +drm_dp_is_uhbr_rate (config.rate) != +drm_dp_is_uhbr_rate (old_config.rate)) +continue ; + + *new_link_rate = config.rate; + *new_lane_count = config.lane_count;
drivers/gpu/drm/i915/display/intel_dp_link_training.c static bool intel_dp_can_link_train_fallback_for_edp(struct intel_dp *intel_dp, · line 1891
Quoted 10 lines
drivers/gpu/drm/i915/display/intel_dp_link_training.c +7
-0+ new_found = true; + +break ; + } +intel_dp_link_caps_iter_end (&iter); + +return new_found; } static int intel_dp_get_link_train_fallback_values(struct intel_dp *intel_dp,
--
Cheers,
Luca.
PATCH v2 25/34 drm/i915/dp_link_training: Disable failed config during fallback
In reply to Imre DeakDisable the link configuration that failed training when selecting fallback parameters.
Fallback still selects the next configuration using the existing fallback order, but now also removes the failed configuration from the allowed set. Functionally, this only affects the case where an MST <-> SST mode switch occurs on the same root connector: previously, a configuration that failed training in one mode could be reused in the other mode due to the differing config iteration orders.
The current fallback logic also sets a temporary maximum link limit across the allowed configurations to constrain subsequent modesets. This legacy behavior is preserved for now; it will be removed once the fallback logic relies solely on the individually disabled configurations to restrict the allowed set.
--- .../gpu/drm/i915/display/intel_dp_link_caps.c | 55 +++++++++++++++++++ .../gpu/drm/i915/display/intel_dp_link_caps.h | 3 + .../drm/i915/display/intel_dp_link_training.c | 19 +++++++ 3 files changed, 77 insertions(+)
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +55 -0
@@ -596,6 +596,21 @@ bool intel_dp_link_caps_filter_add(struct intel_dp_link_caps *link_caps,return true; } +static bool intel_dp_link_caps_filter_remove (struct intel_dp_link_caps *link_caps, +struct intel_dp_link_caps_filter *filter, +const struct intel_dp_link_config *config) +{ +int idx; + + idx =find_config_idx (link_caps,get_allowed_config_filter (link_caps), config); +if (idx <0 ) +return false; + + filter->config_mask &= ~BIT (idx); + +return true; +} +static void set_max_link_limits (struct intel_dp_link_caps *link_caps,const struct intel_dp_link_config *max_link_limits) {
@@ -618,6 +633,46 @@ static void reset_max_link_limits_reenable_all(struct intel_dp_link_caps *link_creset_max_link_limits (link_caps); } +/** +* intel_dp_link_caps_disable_config - disable a configuration +* @link_caps: link capabilities state +* @config: configuration to disable +* +* Disable the configuration identified by @config. This removes the +* configuration from the set of allowed configurations. The disabling +* shouldn't leave the remaining configuration set empty. +* +* The configuration remains disallowed until intel_dp_link_caps() with +* reset=%true or changed sink capabilities is called, or +* intel_dp_link_caps_reset() is called. Each of these happens after a +* new sink is connected or the currently connected sink changes its +* capabilities. +* +* Return: +* - %true if @config was valid and the derived state was updated. +* - %false if @config was invalid or the remaining configuration set +* would remain empty. +*/ +bool intel_dp_link_caps_disable_config (struct intel_dp_link_caps *link_caps, +const struct intel_dp_link_config *config) +{ +struct intel_dp_link_caps_filter enabled_configs = link_caps->enabled_configs; +struct intel_dp_link_config forced_params; + +if (!intel_dp_link_caps_filter_remove (link_caps, &enabled_configs, config)) +return false; + +intel_dp_link_caps_get_forced_params (link_caps, &forced_params); + +if (!calc_allowed_config_filter (link_caps, enabled_configs, + &link_caps->max_limits, &forced_params).config_mask) +return false; + + link_caps->enabled_configs = enabled_configs; + +return true; +} +/** * intel_dp_link_caps_get_max_limits - get the current maximum link limits * @link_caps: link capabilities state
drivers/gpu/drm/i915/display/intel_dp_link_caps.h +3 -0
@@ -136,6 +136,9 @@ bool intel_dp_link_caps_get_max_config(struct intel_dp_link_caps *link_caps,void intel_dp_link_caps_get_max_bw_config (struct intel_dp_link_caps *link_caps,struct intel_dp_link_config *max_config); +bool intel_dp_link_caps_disable_config (struct intel_dp_link_caps *link_caps, +const struct intel_dp_link_config *config); +void intel_dp_link_caps_get_max_limits (struct intel_dp_link_caps *link_caps,struct intel_dp_link_config *max_link_limits); bool intel_dp_link_caps_set_max_limits(struct intel_dp_link_caps *link_caps,
drivers/gpu/drm/i915/display/intel_dp_link_training.c +19 -0
@@ -1894,6 +1894,10 @@ static int intel_dp_get_link_train_fallback_values(struct intel_dp *intel_dp,struct intel_display *display =to_intel_display (intel_dp);struct intel_dp_link_caps *link_caps = intel_dp->link.caps;struct intel_dp_link_config max_link_limits; +struct intel_dp_link_config current_config = { + .rate = crtc_state->port_clock, + .lane_count = crtc_state->lane_count, + };int new_link_rate;int new_lane_count;int err =-1 ;
@@ -1920,6 +1924,13 @@ static int intel_dp_get_link_train_fallback_values(struct intel_dp *intel_dp,intel_dp_link_caps_get_max_limits (link_caps, &max_link_limits);intel_dp_link_caps_reset_max_limits (link_caps); +/* +* TODO: Make fallback depend only on disabling the current config, +* once max_limit no longer constrains the allowed config set. Then +* disabling the current config will define the allowed configs for +* the subsequent modeset, so there will be no need to select a +* reduced config separately here. +*/ if (!reduce_link_params (intel_dp, crtc_state, &new_link_rate, &new_lane_count)) goto out_restore_max_limits;
@@ -1933,6 +1944,14 @@ static int intel_dp_get_link_train_fallback_values(struct intel_dp *intel_dp, goto out_restore_max_limits; } +/* +* Shouldn't fail: the current config was enabled, and reducing the +* link parameters should still leave the fallback config allowed. +*/ +if (drm_WARN_ON (display->drm, + !intel_dp_link_caps_disable_config (link_caps, ¤t_config))) +return -1 ; + lt_dbg(intel_dp, DP_PHY_DPRX, "Reducing link parameters from %dx%d to %dx%d\n", crtc_state->lane_count, crtc_state->port_clock,
Signature · 1 line
2.49.1
Re: [PATCH v2 25/34] drm/i915/dp_link_training: Disable failed config during fallback
Quoted 144 lines · Imre Deak
Disable the link configuration that failed training when selecting fallback parameters.
Fallback still selects the next configuration using the existing fallback order, but now also removes the failed configuration from the allowed set. Functionally, this only affects the case where an MST <-> SST mode switch occurs on the same root connector: previously, a configuration that failed training in one mode could be reused in the other mode due to the differing config iteration orders.
The current fallback logic also sets a temporary maximum link limit across the allowed configurations to constrain subsequent modesets. This legacy behavior is preserved for now; it will be removed once the fallback logic relies solely on the individually disabled configurations to restrict the allowed set.
Signed-off-by Imre Deak <[email protected]>--- .../gpu/drm/i915/display/intel_dp_link_caps.c | 55 +++++++++++++++++++ .../gpu/drm/i915/display/intel_dp_link_caps.h | 3 + .../drm/i915/display/intel_dp_link_training.c | 19 +++++++ 3 files changed, 77 insertions(+)drivers/gpu/drm/i915/display/intel_dp_link_caps.c +55
-0@@ -596,6 +596,21 @@ bool intel_dp_link_caps_filter_add(struct intel_dp_link_caps *link_caps,return true; } +static bool intel_dp_link_caps_filter_remove (struct intel_dp_link_caps *link_caps, +struct intel_dp_link_caps_filter *filter, +const struct intel_dp_link_config *config) +{ +int idx; + + idx =find_config_idx (link_caps,get_allowed_config_filter (link_caps), config); +if (idx <0 ) +return false; + + filter->config_mask &= ~BIT (idx); + +return true; +} +static void set_max_link_limits (struct intel_dp_link_caps *link_caps,const struct intel_dp_link_config *max_link_limits) {@@ -618,6 +633,46 @@ static void reset_max_link_limits_reenable_all(struct intel_dp_link_caps *link_creset_max_link_limits (link_caps); } +/** +* intel_dp_link_caps_disable_config - disable a configuration +* @link_caps: link capabilities state +* @config: configuration to disable +* +* Disable the configuration identified by @config. This removes the +* configuration from the set of allowed configurations. The disabling +* shouldn't leave the remaining configuration set empty. +* +* The configuration remains disallowed until intel_dp_link_caps() with +* reset=%true or changed sink capabilities is called, or +* intel_dp_link_caps_reset() is called. Each of these happens after a +* new sink is connected or the currently connected sink changes its +* capabilities. +* +* Return: +* - %true if @config was valid and the derived state was updated. +* - %false if @config was invalid or the remaining configuration set +* would remain empty. +*/ +bool intel_dp_link_caps_disable_config (struct intel_dp_link_caps *link_caps, +const struct intel_dp_link_config *config) +{ +struct intel_dp_link_caps_filter enabled_configs = link_caps->enabled_configs; +struct intel_dp_link_config forced_params; + +if (!intel_dp_link_caps_filter_remove (link_caps, &enabled_configs, config)) +return false; + +intel_dp_link_caps_get_forced_params (link_caps, &forced_params); + +if (!calc_allowed_config_filter (link_caps, enabled_configs, + &link_caps->max_limits, &forced_params).config_mask) +return false; + + link_caps->enabled_configs = enabled_configs; + +return true; +} +/** * intel_dp_link_caps_get_max_limits - get the current maximum link limits * @link_caps: link capabilities state drivers/gpu/drm/i915/display/intel_dp_link_caps.h +3
-0@@ -136,6 +136,9 @@ bool intel_dp_link_caps_get_max_config(struct intel_dp_link_caps *link_caps,void intel_dp_link_caps_get_max_bw_config (struct intel_dp_link_caps *link_caps,struct intel_dp_link_config *max_config); +bool intel_dp_link_caps_disable_config (struct intel_dp_link_caps *link_caps, +const struct intel_dp_link_config *config); +void intel_dp_link_caps_get_max_limits (struct intel_dp_link_caps *link_caps,struct intel_dp_link_config *max_link_limits); bool intel_dp_link_caps_set_max_limits(struct intel_dp_link_caps *link_caps,drivers/gpu/drm/i915/display/intel_dp_link_training.c +12
-0@@ -1894,6 +1894,10 @@ static int intel_dp_get_link_train_fallback_values(struct intel_dp *intel_dp,struct intel_display *display =to_intel_display (intel_dp);struct intel_dp_link_caps *link_caps = intel_dp->link.caps;struct intel_dp_link_config max_link_limits; +struct intel_dp_link_config current_config = { + .rate = crtc_state->port_clock, + .lane_count = crtc_state->lane_count, + };int new_link_rate;int new_lane_count;int err =-1 ;@@ -1920,6 +1924,13 @@ static int intel_dp_get_link_train_fallback_values(struct intel_dp *intel_dp,intel_dp_link_caps_get_max_limits (link_caps, &max_link_limits);intel_dp_link_caps_reset_max_limits (link_caps); +/* +* TODO: Make fallback depend only on disabling the current config, +* once max_limit no longer constrains the allowed config set. Then +* disabling the current config will define the allowed configs for +* the subsequent modeset, so there will be no need to select a +* reduced config separately here. +*/ if (!reduce_link_params (intel_dp, crtc_state, &new_link_rate, &new_lane_count)) goto out_restore_max_limits;@@ -1933,6 +1944,14 @@ static int intel_dp_get_link_train_fallback_values(struct intel_dp *intel_dp, goto out_restore_max_limits; } +/*
drivers/gpu/drm/i915/display/intel_dp_link_training.c static int intel_dp_get_link_train_fallback_values(struct intel_dp *intel_dp, · line 1957
Quoted 10 lines
drivers/gpu/drm/i915/display/intel_dp_link_training.c +7
-0+* Shouldn't fail: the current config was enabled, and reducing the +* link parameters should still leave the fallback config allowed. +*/ +if (drm_WARN_ON (display->drm, + !intel_dp_link_caps_disable_config (link_caps, ¤t_config))) +return -1 ; + lt_dbg(intel_dp, DP_PHY_DPRX, "Reducing link parameters from %dx%d to %dx%d\n", crtc_state->lane_count, crtc_state->port_clock,
--
Cheers,
Luca.
PATCH v2 26/34 drm/i915/kunit: Enable KUnit tests
In reply to Imre DeakAdd KUnit configuration for i915 and a local .kunitconfig to run the tests.
--- drivers/gpu/drm/i915/.kunitconfig | 12 ++++++++++++ drivers/gpu/drm/i915/Kconfig.debug | 12 ++++++++++++ 2 files changed, 24 insertions(+) create mode 100644 drivers/gpu/drm/i915/.kunitconfig
drivers/gpu/drm/i915/.kunitconfig new file +12 -0
@@ -0,0 +1,12 @@ +CONFIG_EXPERT=y +CONFIG_MODULES=y +CONFIG_KUNIT=y +CONFIG_PCI=y +CONFIG_DEBUG_FS=y +CONFIG_MAGIC_SYSRQ=y +CONFIG_DEBUG_KERNEL=y +CONFIG_DEBUG_INFO=y +CONFIG_DEBUG_INFO_DWARF_TOOLCHAIN_DEFAULT=y +CONFIG_DRM=y +CONFIG_DRM_I915=y +CONFIG_DRM_I915_KUNIT_TEST=y
drivers/gpu/drm/i915/Kconfig.debug +12 -0
@@ -220,6 +220,18 @@ config DRM_I915_SELFTEST_BROKEN If in doubt, say "N". +config DRM_I915_KUNIT_TEST + tristate "KUnit tests for the drm i915 driver" if !KUNIT_ALL_TESTS + depends on DRM_I915 && KUNIT && DEBUG_FS + default KUNIT_ALL_TESTS + help + Choose this option to allow the driver to perform selftests under + the kunit framework + + Recommended for driver developers only. + + If in doubt, say "N". + config DRM_I915_LOW_LEVEL_TRACEPOINTS bool "Enable low level request tracing events" depends on DRM_I915
Signature · 1 line
2.49.1
Re: [PATCH v2 26/34] drm/i915/kunit: Enable KUnit tests
Quoted 6 lines · Imre Deak
Add KUnit configuration for i915 and a local .kunitconfig to run the tests.
Signed-off-by Imre Deak <[email protected]>---
drivers/gpu/drm/i915/.kunitconfig| 12 ++++++++++++
Shouldn't .gitignore be updated with .kunitconfig, similar to PATCH 28/34 ("drm/xe/kunit: Add display test config")?
Otherwise:
BR,
Michał
Quoted 49 lines
drivers/gpu/drm/i915/Kconfig.debug| 12 ++++++++++++2 files changed, 24 insertions(+)create mode 100644
drivers/gpu/drm/i915/.kunitconfigdrivers/gpu/drm/i915/.kunitconfig new file +12
-0@@ -0,0 +1,12 @@ +CONFIG_EXPERT=y +CONFIG_MODULES=y +CONFIG_KUNIT=y +CONFIG_PCI=y +CONFIG_DEBUG_FS=y +CONFIG_MAGIC_SYSRQ=y +CONFIG_DEBUG_KERNEL=y +CONFIG_DEBUG_INFO=y +CONFIG_DEBUG_INFO_DWARF_TOOLCHAIN_DEFAULT=y +CONFIG_DRM=y +CONFIG_DRM_I915=y +CONFIG_DRM_I915_KUNIT_TEST=ydrivers/gpu/drm/i915/Kconfig.debug +12
-0@@ -220,6 +220,18 @@ config DRM_I915_SELFTEST_BROKEN If in doubt, say "N". +config DRM_I915_KUNIT_TEST + tristate "KUnit tests for the drm i915 driver" if !KUNIT_ALL_TESTS + depends on DRM_I915 && KUNIT && DEBUG_FS + default KUNIT_ALL_TESTS + help + Choose this option to allow the driver to perform selftests under + the kunit framework + + Recommended for driver developers only. + + If in doubt, say "N". +config
DRM_I915_LOW_LEVEL_TRACEPOINTS
bool "Enable low level request tracing events" depends onDRM_I915Signature · 1 line
2.49.1
Re: [PATCH v2 26/34] drm/i915/kunit: Enable KUnit tests
Quoted 10 lines · Michał Grzelak
Quoted 6 lines · Imre Deak
Add KUnit configuration for i915 and a local .kunitconfig to run the tests.
Signed-off-by Imre Deak <[email protected]>---
drivers/gpu/drm/i915/.kunitconfig| 12 ++++++++++++Shouldn't .gitignore be updated with .kunitconfig, similar to PATCH 28/34 ("drm/xe/kunit: Add display test config")?
No, it's already in the .gitignore of a parent dir.
Quoted 55 lines
Otherwise:
Reviewed-by Michał Grzelak <[email protected]>BR,
MichałQuoted 49 lines
drivers/gpu/drm/i915/Kconfig.debug| 12 ++++++++++++2 files changed, 24 insertions(+)create mode 100644
drivers/gpu/drm/i915/.kunitconfigdrivers/gpu/drm/i915/.kunitconfig new file +12
-0@@ -0,0 +1,12 @@ +CONFIG_EXPERT=y +CONFIG_MODULES=y +CONFIG_KUNIT=y +CONFIG_PCI=y +CONFIG_DEBUG_FS=y +CONFIG_MAGIC_SYSRQ=y +CONFIG_DEBUG_KERNEL=y +CONFIG_DEBUG_INFO=y +CONFIG_DEBUG_INFO_DWARF_TOOLCHAIN_DEFAULT=y +CONFIG_DRM=y +CONFIG_DRM_I915=y +CONFIG_DRM_I915_KUNIT_TEST=ydrivers/gpu/drm/i915/Kconfig.debug +12
-0@@ -220,6 +220,18 @@ config DRM_I915_SELFTEST_BROKEN If in doubt, say "N". +config DRM_I915_KUNIT_TEST + tristate "KUnit tests for the drm i915 driver" if !KUNIT_ALL_TESTS + depends on DRM_I915 && KUNIT && DEBUG_FS + default KUNIT_ALL_TESTS + help + Choose this option to allow the driver to perform selftests under + the kunit framework + + Recommended for driver developers only. + + If in doubt, say "N". +config
DRM_I915_LOW_LEVEL_TRACEPOINTS
bool "Enable low level request tracing events" depends onDRM_I915Signature · 1 line
2.49.1
PATCH v3 26/34 drm/i915/kunit: Enable KUnit tests
In reply to Imre DeakAdd KUnit configuration for i915 and a local .kunitconfig to run the tests.
v2: Unchanged.
v3: Remove kconfig options for kernel debug.
--- drivers/gpu/drm/i915/.kunitconfig | 9 +++++++++ drivers/gpu/drm/i915/Kconfig.debug | 12 ++++++++++++ 2 files changed, 21 insertions(+) create mode 100644 drivers/gpu/drm/i915/.kunitconfig
drivers/gpu/drm/i915/.kunitconfig new file +9 -0
@@ -0,0 +1,9 @@ +CONFIG_EXPERT=y +CONFIG_MODULES=y +CONFIG_KUNIT=y +CONFIG_PCI=y +CONFIG_DEBUG_FS=y +CONFIG_MAGIC_SYSRQ=y +CONFIG_DRM=y +CONFIG_DRM_I915=y +CONFIG_DRM_I915_KUNIT_TEST=y
drivers/gpu/drm/i915/Kconfig.debug +12 -0
@@ -220,6 +220,18 @@ config DRM_I915_SELFTEST_BROKEN If in doubt, say "N". +config DRM_I915_KUNIT_TEST + tristate "KUnit tests for the drm i915 driver" if !KUNIT_ALL_TESTS + depends on DRM_I915 && KUNIT && DEBUG_FS + default KUNIT_ALL_TESTS + help + Choose this option to allow the driver to perform selftests under + the kunit framework + + Recommended for driver developers only. + + If in doubt, say "N". + config DRM_I915_LOW_LEVEL_TRACEPOINTS bool "Enable low level request tracing events" depends on DRM_I915
Signature · 1 line
2.49.1
PATCH v2 27/34 drm/i915/kunit: Add DP link test stub
In reply to Imre DeakAdd a Kunit stub test module for DP link test cases.
v2: Add missing module license.
--- drivers/gpu/drm/i915/Makefile | 2 + drivers/gpu/drm/i915/display/tests/Makefile | 7 +++ .../i915/display/tests/intel_dp_link_test.c | 47 +++++++++++++++++++ 3 files changed, 56 insertions(+) create mode 100644 drivers/gpu/drm/i915/display/tests/Makefile create mode 100644 drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c
drivers/gpu/drm/i915/Makefile +2 -0
@@ -386,6 +386,8 @@ i915-y += \ i915-$(CONFIG_DRM_I915_DP_TUNNEL) += \ display/intel_dp_tunnel.o +obj-$(CONFIG_DRM_I915_KUNIT_TEST) += display/tests/ + i915-$(CONFIG_DRM_I915_GVT) += \ display/intel_gvt_api.o
drivers/gpu/drm/i915/display/tests/Makefile new file +7 -0
@@ -0,0 +1,7 @@ +# SPDX-License-Identifier: GPL-2.0 + +subdir-ccflags-y += -I$(srctree)/drivers/gpu/drm/i915/display/ + +obj-$(CONFIG_DRM_I915_KUNIT_TEST) += i915_display_test.o +i915_display_test-y = \ + intel_dp_link_test.o
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c new file +47 -0
47 lines not on this page · raw message
Signature · 1 line
2.49.1
Re: [PATCH v2 27/34] drm/i915/kunit: Add DP link test stub
Quoted 5 lines · Imre Deak
Add a Kunit stub test module for DP link test cases.
v2: Add missing module license.
Signed-off-by Imre Deak <[email protected]>
BR,
Michał
Quoted 91 lines
---
drivers/gpu/drm/i915/Makefile | 2 + drivers/gpu/drm/i915/display/tests/Makefile | 7 +++ .../i915/display/tests/intel_dp_link_test.c | 47 +++++++++++++++++++ 3 files changed, 56 insertions(+)create mode 100644
drivers/gpu/drm/i915/display/tests/Makefilecreate mode 100644drivers/gpu/drm/i915/display/tests/intel_dp_link_test.cdrivers/gpu/drm/i915/Makefile +2
-0@@ -386,6 +386,8 @@ i915-y += \ i915-$(CONFIG_DRM_I915_DP_TUNNEL) += \ display/intel_dp_tunnel.o +obj-$(CONFIG_DRM_I915_KUNIT_TEST) += display/tests/ + i915-$(CONFIG_DRM_I915_GVT) += \ display/intel_gvt_api.odrivers/gpu/drm/i915/display/tests/Makefile new file +7
-0@@ -0,0 +1,7 @@ +# SPDX-License-Identifier: GPL-2.0 + +subdir-ccflags-y += -I$(srctree)/drivers/gpu/drm/i915/display/ + +obj-$(CONFIG_DRM_I915_KUNIT_TEST) += i915_display_test.o +i915_display_test-y = \ + intel_dp_link_test.odrivers/gpu/drm/i915/display/tests/intel_dp_link_test.c new file +47
-0@@ -0,0 +1,47 @@ +// SPDX-License-Identifier: MIT +/* +* Copyright © 2026 Intel Corporation +*/ + +#include <kunit/test.h> + +struct test_ctx { +}; + +static struct kunit_case intel_dp_link_test_cases[] = { + {} +}; + +static struct test_ctx test_ctx; + +static int intel_dp_link_test_init (struct kunit *test) +{ + test->priv = &test_ctx; + +return 0 ; +} + +static void intel_dp_link_test_exit (struct kunit *test) +{ +} + +static int intel_dp_link_test_suite_init (struct kunit_suite *test_suite) +{ +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" );Signature · 1 line
2.49.1
PATCH v2 28/34 drm/xe/kunit: Add display test config
In reply to Imre DeakAdd a separate xe KUnit config for display tests.
The existing xe .kunitconfig builds xe statically, which is suitable for non-display xe tests. The display code can only be enabled for xe when xe is built as a module, so add a separate display config with DRM_XE=m and DRM_XE_DISPLAY=y.
This can be folded back into the main xe KUnit config once the display code becomes a separate module.
--- drivers/gpu/drm/xe/.gitignore | 1 + drivers/gpu/drm/xe/.kunitconfig-display | 11 +++++++++++ 2 files changed, 12 insertions(+) create mode 100644 drivers/gpu/drm/xe/.kunitconfig-display
drivers/gpu/drm/xe/.gitignore +1 -0
@@ -2,3 +2,4 @@ *.hdrtest /generated /xe_gen_wa_oob +!.kunitconfig-display
drivers/gpu/drm/xe/.kunitconfig-display new file +11 -0
@@ -0,0 +1,11 @@ +CONFIG_EXPERT=y +CONFIG_MODULES=y +CONFIG_KUNIT=y +CONFIG_PCI=y +CONFIG_DEBUG_FS=y +CONFIG_BLK_DEV_INITRD=y +CONFIG_MAGIC_SYSRQ=y +CONFIG_DRM=m +CONFIG_DRM_XE=m +CONFIG_DRM_XE_DISPLAY=y +CONFIG_DRM_XE_KUNIT_TEST=m
Signature · 1 line
2.49.1
Re: [PATCH v2 28/34] drm/xe/kunit: Add display test config
Quoted 23 lines · Imre Deak
Add a separate xe KUnit config for display tests.
The existing xe .kunitconfig builds xe statically, which is suitable for non-display xe tests. The display code can only be enabled for xe when xe is built as a module, so add a separate display config with DRM_XE=m and DRM_XE_DISPLAY=y.
This can be folded back into the main xe KUnit config once the display code becomes a separate module.
Signed-off-by Imre Deak <[email protected]>---
drivers/gpu/drm/xe/.gitignore| 1 +drivers/gpu/drm/xe/.kunitconfig-display| 11 +++++++++++2 files changed, 12 insertions(+)create mode 100644
drivers/gpu/drm/xe/.kunitconfig-displaydrivers/gpu/drm/xe/.gitignore +0
-0@@ -2,3 +2,4 @@ *.hdrtest
Quoted 3 lines
/generated
/xe_gen_wa_oob
+!.kunitconfig-display
Same comment as on PATCH 26/34 ("drm/i915/kunit: Enable KUnit tests"), so not sure why the *-display file here is excluded from .gitignore and .kunitconfig is not.
With that addressed:
BR,
Michał
Quoted 21 lines
drivers/gpu/drm/xe/.kunitconfig-display new file +11
-0@@ -0,0 +1,11 @@ +CONFIG_EXPERT=y +CONFIG_MODULES=y +CONFIG_KUNIT=y +CONFIG_PCI=y +CONFIG_DEBUG_FS=y +CONFIG_BLK_DEV_INITRD=y +CONFIG_MAGIC_SYSRQ=y +CONFIG_DRM=m +CONFIG_DRM_XE=m +CONFIG_DRM_XE_DISPLAY=y +CONFIG_DRM_XE_KUNIT_TEST=mSignature · 1 line
2.49.1
Re: [PATCH v2 28/34] drm/xe/kunit: Add display test config
In reply to Imre DeakHi Rodrigo, Matthew and Thomas,
are you ok merging this and the next patch in the series via the drm-intel-next tree?
Thanks,
Imre
Quoted 46 lines · Imre Deak
Add a separate xe KUnit config for display tests.
The existing xe .kunitconfig builds xe statically, which is suitable for non-display xe tests. The display code can only be enabled for xe when xe is built as a module, so add a separate display config with DRM_XE=m and DRM_XE_DISPLAY=y.
This can be folded back into the main xe KUnit config once the display code becomes a separate module.
Signed-off-by Imre Deak <[email protected]>--- drivers/gpu/drm/xe/.gitignore | 1 + drivers/gpu/drm/xe/.kunitconfig-display | 11 +++++++++++ 2 files changed, 12 insertions(+) create mode 100644 drivers/gpu/drm/xe/.kunitconfig-displaydrivers/gpu/drm/xe/.gitignore +1
-0@@ -2,3 +2,4 @@ *.hdrtest /generated /xe_gen_wa_oob +!.kunitconfig-displaydrivers/gpu/drm/xe/.kunitconfig-display new file +11
-0@@ -0,0 +1,11 @@ +CONFIG_EXPERT=y +CONFIG_MODULES=y +CONFIG_KUNIT=y +CONFIG_PCI=y +CONFIG_DEBUG_FS=y +CONFIG_BLK_DEV_INITRD=y +CONFIG_MAGIC_SYSRQ=y +CONFIG_DRM=m +CONFIG_DRM_XE=m +CONFIG_DRM_XE_DISPLAY=y +CONFIG_DRM_XE_KUNIT_TEST=mSignature · 1 line
2.49.1
Re: [PATCH v2 28/34] drm/xe/kunit: Add display test config
Hi,
Quoted 4 lines · Imre Deak
Hi Rodrigo, Matthew and Thomas,
are you ok merging this and the next patch in the series via the drm-intel-next tree?
any objection to get the above two patch merged to drm-intel-next?
Quoted 51 lines
Thanks,
ImreQuoted 46 lines · Imre Deak
Add a separate xe KUnit config for display tests.
The existing xe .kunitconfig builds xe statically, which is suitable for non-display xe tests. The display code can only be enabled for xe when xe is built as a module, so add a separate display config with DRM_XE=m and DRM_XE_DISPLAY=y.
This can be folded back into the main xe KUnit config once the display code becomes a separate module.
Signed-off-by Imre Deak <[email protected]>--- drivers/gpu/drm/xe/.gitignore | 1 + drivers/gpu/drm/xe/.kunitconfig-display | 11 +++++++++++ 2 files changed, 12 insertions(+) create mode 100644 drivers/gpu/drm/xe/.kunitconfig-displaydrivers/gpu/drm/xe/.gitignore +1
-0@@ -2,3 +2,4 @@ *.hdrtest /generated /xe_gen_wa_oob +!.kunitconfig-displaydrivers/gpu/drm/xe/.kunitconfig-display new file +11
-0@@ -0,0 +1,11 @@ +CONFIG_EXPERT=y +CONFIG_MODULES=y +CONFIG_KUNIT=y +CONFIG_PCI=y +CONFIG_DEBUG_FS=y +CONFIG_BLK_DEV_INITRD=y +CONFIG_MAGIC_SYSRQ=y +CONFIG_DRM=m +CONFIG_DRM_XE=m +CONFIG_DRM_XE_DISPLAY=y +CONFIG_DRM_XE_KUNIT_TEST=mSignature · 1 line
2.49.1
Re: [PATCH v2 28/34] drm/xe/kunit: Add display test config
Quoted 9 lines · Imre Deak
Hi,
Quoted 4 lines · Imre Deak
Hi Rodrigo, Matthew and Thomas,
are you ok merging this and the next patch in the series via the drm-intel-next tree?
any objection to get the above two patch merged to drm-intel-next?
sorry for the delay. no objection
Quoted 52 lines
Quoted 52 lines
Thanks,
ImreQuoted 46 lines · Imre Deak
Add a separate xe KUnit config for display tests.
The existing xe .kunitconfig builds xe statically, which is suitable for non-display xe tests. The display code can only be enabled for xe when xe is built as a module, so add a separate display config with DRM_XE=m and DRM_XE_DISPLAY=y.
This can be folded back into the main xe KUnit config once the display code becomes a separate module.
Signed-off-by Imre Deak <[email protected]>--- drivers/gpu/drm/xe/.gitignore | 1 + drivers/gpu/drm/xe/.kunitconfig-display | 11 +++++++++++ 2 files changed, 12 insertions(+) create mode 100644 drivers/gpu/drm/xe/.kunitconfig-displaydrivers/gpu/drm/xe/.gitignore +1
-0@@ -2,3 +2,4 @@ *.hdrtest /generated /xe_gen_wa_oob +!.kunitconfig-displaydrivers/gpu/drm/xe/.kunitconfig-display new file +11
-0@@ -0,0 +1,11 @@ +CONFIG_EXPERT=y +CONFIG_MODULES=y +CONFIG_KUNIT=y +CONFIG_PCI=y +CONFIG_DEBUG_FS=y +CONFIG_BLK_DEV_INITRD=y +CONFIG_MAGIC_SYSRQ=y +CONFIG_DRM=m +CONFIG_DRM_XE=m +CONFIG_DRM_XE_DISPLAY=y +CONFIG_DRM_XE_KUNIT_TEST=mSignature · 1 line
2.49.1
PATCH v2 29/34 drm/xe/kunit: Build DP link display tests
In reply to Imre DeakHook the shared i915 display DP link KUnit tests into the xe display test build.
Build the shared display test source from the i915 display test directory when xe display support is enabled.
--- drivers/gpu/drm/xe/Makefile | 3 +++ drivers/gpu/drm/xe/display/tests/Makefile | 11 +++++++++++ 2 files changed, 14 insertions(+) create mode 100644 drivers/gpu/drm/xe/display/tests/Makefile
drivers/gpu/drm/xe/Makefile +3 -0
@@ -373,6 +373,9 @@ xe-$(CONFIG_DRM_XE_DP_TUNNEL) += \ obj-$(CONFIG_DRM_XE) += xe.o obj-$(CONFIG_DRM_XE_KUNIT_TEST) += tests/ +ifeq ($(CONFIG_DRM_XE_DISPLAY),y) + obj-$(CONFIG_DRM_XE_KUNIT_TEST) += display/tests/ +endif # header test hdrtest_find_args := -not -path xe_rtp_helpers.h
drivers/gpu/drm/xe/display/tests/Makefile new file +11 -0
@@ -0,0 +1,11 @@ +subdir-ccflags-$(CONFIG_DRM_XE_DISPLAY) += \ + -I$(srctree)/drivers/gpu/drm/i915/display/ + +# Rule to build display code shared with i915 +$(obj)/i915-display/tests/%.o: $(srctree)/drivers/gpu/drm/i915/display/tests/%.c FORCE + $(call cmd,force_checksrc) + $(call if_changed_rule,cc_o_c) + +obj-$(CONFIG_DRM_XE_KUNIT_TEST) += xe_display_test.o +xe_display_test-y = \ + i915-display/tests/intel_dp_link_test.o
Signature · 1 line
2.49.1
Re: [PATCH v2 29/34] drm/xe/kunit: Build DP link display tests
drivers/gpu/drm/xe/display/tests/Makefile
Quoted 33 lines · Imre Deak
Hook the shared i915 display DP link KUnit tests into the xe display test build.
Build the shared display test source from the i915 display test directory when xe display support is enabled.
Signed-off-by Imre Deak <[email protected]>---
drivers/gpu/drm/xe/Makefile| 3 +++drivers/gpu/drm/xe/display/tests/Makefile| 11 +++++++++++2 files changed, 14 insertions(+)create mode 100644
drivers/gpu/drm/xe/display/tests/Makefiledrivers/gpu/drm/xe/Makefile +0
-0@@ -373,6 +373,9 @@ xe-$(CONFIG_DRM_XE_DP_TUNNEL) += \obj-$(CONFIG_DRM_XE) += xe.o
obj-$(CONFIG_DRM_XE_KUNIT_TEST) += tests/drivers/gpu/drm/xe/Makefile +3
-0+ifeq ($(CONFIG_DRM_XE_DISPLAY),y) + obj-$(CONFIG_DRM_XE_KUNIT_TEST) += display/tests/ +endif# header test hdrtest_find_args := -not -path xe_rtp_helpers.hdrivers/gpu/drm/xe/display/tests/Makefile new file +0
-0@@ -0,0 +1,11 @@
Not sure but I think # SPDX ... boilterplate is missing.
Otherwise or if does not apply:
BR,
Michał
Quoted 15 lines
drivers/gpu/drm/xe/display/tests/Makefile new file +11
-0+subdir-ccflags-$(CONFIG_DRM_XE_DISPLAY) += \ + -I$(srctree)/drivers/gpu/drm/i915/display/ + +# Rule to build display code shared with i915 +$(obj)/i915-display/tests/%.o: $(srctree)/drivers/gpu/drm/i915/display/tests/%.c FORCE + $(call cmd,force_checksrc) + $(call if_changed_rule,cc_o_c) + +obj-$(CONFIG_DRM_XE_KUNIT_TEST) += xe_display_test.o +xe_display_test-y = \ + i915-display/tests/intel_dp_link_test.oSignature · 1 line
2.49.1
Re: [PATCH v2 29/34] drm/xe/kunit: Build DP link display tests
Quoted 26 lines · Michał Grzelak
Quoted 25 lines · Imre Deak
Hook the shared i915 display DP link KUnit tests into the xe display test build.
Build the shared display test source from the i915 display test directory when xe display support is enabled.
Signed-off-by Imre Deak <[email protected]>---
drivers/gpu/drm/xe/Makefile| 3 +++drivers/gpu/drm/xe/display/tests/Makefile| 11 +++++++++++2 files changed, 14 insertions(+)create mode 100644
drivers/gpu/drm/xe/display/tests/Makefiledrivers/gpu/drm/xe/Makefile +0
-0@@ -373,6 +373,9 @@ xe-$(CONFIG_DRM_XE_DP_TUNNEL) += \obj-$(CONFIG_DRM_XE) += xe.o
obj-$(CONFIG_DRM_XE_KUNIT_TEST) += tests/drivers/gpu/drm/xe/Makefile +3
-0+ifeq ($(CONFIG_DRM_XE_DISPLAY),y) + obj-$(CONFIG_DRM_XE_KUNIT_TEST) += display/tests/ +endif
Quoted 10 lines
drivers/gpu/drm/xe/display/tests/Makefile
Quoted 8 lines
# header test hdrtest_find_args := -not -path xe_rtp_helpers.hdrivers/gpu/drm/xe/display/tests/Makefile new file +0
-0@@ -0,0 +1,11 @@Not sure but I think # SPDX ... boilterplate is missing.
Yes, thanks for catching that, will add it.
Quoted 22 lines
Otherwise or if does not apply:
Reviewed-by Michał Grzelak <[email protected]>BR,
MichałQuoted 15 lines
drivers/gpu/drm/xe/display/tests/Makefile new file +11
-0+subdir-ccflags-$(CONFIG_DRM_XE_DISPLAY) += \ + -I$(srctree)/drivers/gpu/drm/i915/display/ + +# Rule to build display code shared with i915 +$(obj)/i915-display/tests/%.o: $(srctree)/drivers/gpu/drm/i915/display/tests/%.c FORCE + $(call cmd,force_checksrc) + $(call if_changed_rule,cc_o_c) + +obj-$(CONFIG_DRM_XE_KUNIT_TEST) += xe_display_test.o +xe_display_test-y = \ + i915-display/tests/intel_dp_link_test.oSignature · 1 line
2.49.1
PATCH v3 29/34 drm/xe/kunit: Build DP link display tests
In reply to Imre DeakHook the shared i915 display DP link KUnit tests into the xe display test build.
Build the shared display test source from the i915 display test directory when xe display support is enabled.
v2: Unchanged.
v3: Add SPDX license header. (Michał)
--- drivers/gpu/drm/xe/Makefile | 3 +++ drivers/gpu/drm/xe/display/tests/Makefile | 13 +++++++++++++ 2 files changed, 16 insertions(+) create mode 100644 drivers/gpu/drm/xe/display/tests/Makefile
drivers/gpu/drm/xe/Makefile +3 -0
@@ -374,6 +374,9 @@ xe-$(CONFIG_DRM_XE_DP_TUNNEL) += \ obj-$(CONFIG_DRM_XE) += xe.o obj-$(CONFIG_DRM_XE_KUNIT_TEST) += tests/ +ifeq ($(CONFIG_DRM_XE_DISPLAY),y) + obj-$(CONFIG_DRM_XE_KUNIT_TEST) += display/tests/ +endif # header test hdrtest_find_args := -not -path xe_rtp_helpers.h
drivers/gpu/drm/xe/display/tests/Makefile new file +13 -0
@@ -0,0 +1,13 @@ +# SPDX-License-Identifier: GPL-2.0 + +subdir-ccflags-$(CONFIG_DRM_XE_DISPLAY) += \ + -I$(srctree)/drivers/gpu/drm/i915/display/ + +# Rule to build display code shared with i915 +$(obj)/i915-display/tests/%.o: $(srctree)/drivers/gpu/drm/i915/display/tests/%.c FORCE + $(call cmd,force_checksrc) + $(call if_changed_rule,cc_o_c) + +obj-$(CONFIG_DRM_XE_KUNIT_TEST) += xe_display_test.o +xe_display_test-y = \ + i915-display/tests/intel_dp_link_test.o
Signature · 1 line
2.49.1
Re: [PATCH v3 29/34] drm/xe/kunit: Build DP link display tests
Quoted 6 lines · Imre Deak
Hook the shared i915 display DP link KUnit tests into the xe display test build.
Build the shared display test source from the i915 display test directory when xe display support is enabled.
Quoted 8 lines
v2: Unchanged.
v3: Add SPDX license header. (Michał)Reviewed-by Michał Grzelak <[email protected]>Signed-off-by Imre Deak <[email protected]>--- drivers/gpu/drm/xe/Makefile | 3 +++ drivers/gpu/drm/xe/display/tests/Makefile | 13 +++++++++++++
Quoted 39 lines
2 files changed, 16 insertions(+) create mode 100644 drivers/gpu/drm/xe/display/tests/Makefiledrivers/gpu/drm/xe/Makefile +3
-0@@ -374,6 +374,9 @@ xe-$(CONFIG_DRM_XE_DP_TUNNEL) += \ obj-$(CONFIG_DRM_XE) += xe.o obj-$(CONFIG_DRM_XE_KUNIT_TEST) += tests/ +ifeq ($(CONFIG_DRM_XE_DISPLAY),y) + obj-$(CONFIG_DRM_XE_KUNIT_TEST) += display/tests/ +endif # header test hdrtest_find_args := -not -path xe_rtp_helpers.hdrivers/gpu/drm/xe/display/tests/Makefile new file +13
-0@@ -0,0 +1,13 @@ +# SPDX-License-Identifier: GPL-2.0 + +subdir-ccflags-$(CONFIG_DRM_XE_DISPLAY) += \ + -I$(srctree)/drivers/gpu/drm/i915/display/ + +# Rule to build display code shared with i915 +$(obj)/i915-display/tests/%.o: $(srctree)/drivers/gpu/drm/i915/display/tests/%.c FORCE + $(call cmd,force_checksrc) + $(call if_changed_rule,cc_o_c) + +obj-$(CONFIG_DRM_XE_KUNIT_TEST) += xe_display_test.o +xe_display_test-y = \ + i915-display/tests/intel_dp_link_test.oSignature · 1 line
2.49.1
PATCH v2 30/34 drm/i915/kunit: Setup DP link test context
In reply to Imre DeakInitialize a reusable test context for DP link KUnit tests. Sets up minimal device, connector, encoder, and DP structures, and seeds the pseudo-random generator for deterministic test runs.
--- .../i915/display/tests/intel_dp_link_test.c | 50 +++++++++++++++++++ 1 file changed, 50 insertions(+)
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +50 -0
@@ -5,7 +5,32 @@#include <kunit/test.h> +#include <linux/compiler.h> +#include <linux/device.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" +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; + +struct rnd_state rnd; };static struct kunit_case intel_dp_link_test_cases[] = {
@@ -16,6 +41,29 @@ 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; + test->priv = &test_ctx;return 0 ;
@@ -27,6 +75,8 @@ static void intel_dp_link_test_exit(struct kunit *test)static int intel_dp_link_test_suite_init (struct kunit_suite *test_suite) { +prandom_seed_state (&test_ctx.rnd,0 ); +return 0 ; }
Signature · 1 line
2.49.1
Re: [PATCH v2 30/34] drm/i915/kunit: Setup DP link test context
Quoted 30 lines · Imre Deak
Initialize a reusable test context for DP link KUnit tests. Sets up minimal device, connector, encoder, and DP structures, and seeds the pseudo-random generator for deterministic test runs.
Signed-off-by Imre Deak <[email protected]>---
.../i915/display/tests/intel_dp_link_test.c| 50 +++++++++++++++++++1 file changed, 50 insertions(+)drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +13
-0@@ -5,7 +5,32 @@#include <kunit/test.h> +#include <linux/compiler.h> +#include <linux/device.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" +
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c line 30
Quoted 10 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +9
-0struct 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;
crtc_state is not used in this patch; if it is used implicitly in next patch, I'm thinking about moving this hunk to it.
Whether it applies or not:
BR,
Michał
Quoted 49 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +28
-0+ } dev; + +struct rnd_state rnd; };static struct kunit_case intel_dp_link_test_cases[] = {@@ -16,6 +41,29 @@ 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; + test->priv = &test_ctx;return 0 ;@@ -27,6 +75,8 @@ static void intel_dp_link_test_exit(struct kunit *test)static int intel_dp_link_test_suite_init (struct kunit_suite *test_suite) { +prandom_seed_state (&test_ctx.rnd,0 ); +return 0 ; }Signature · 1 line
2.49.1
Re: [PATCH v2 30/34] drm/i915/kunit: Setup DP link test context
Quoted 36 lines · Michał Grzelak
Quoted 35 lines · Imre Deak
Initialize a reusable test context for DP link KUnit tests. Sets up minimal device, connector, encoder, and DP structures, and seeds the pseudo-random generator for deterministic test runs.
Signed-off-by Imre Deak <[email protected]>---
.../i915/display/tests/intel_dp_link_test.c| 50 +++++++++++++++++++1 file changed, 50 insertions(+)drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +17
-0@@ -5,7 +5,32 @@#include <kunit/test.h> +#include <linux/compiler.h> +#include <linux/device.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" +struct test_ctx { +struct { +struct intel_display display; +struct device device; +struct __intel_generic_device generic_device;
Quoted 8 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c line 30
Quoted 5 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +5
-0+ +struct intel_connector connector; +struct intel_digital_port dig_port; + +struct intel_crtc_state crtc_state;
crtc_stateis not used in this patch; if it is used implicitly in next patch, I'm thinking about moving this hunk to it.
Nothing is used in this patch from the above context besides being initialized. I kept this as a separate patch since the same context is used by all the tests added later.
Quoted 56 lines
Whether it applies or not:
Reviewed-by Michał Grzelak <[email protected]>BR,
MichałQuoted 49 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +28
-0+ } dev; + +struct rnd_state rnd; };static struct kunit_case intel_dp_link_test_cases[] = {@@ -16,6 +41,29 @@ 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; + test->priv = &test_ctx;return 0 ;@@ -27,6 +75,8 @@ static void intel_dp_link_test_exit(struct kunit *test)static int intel_dp_link_test_suite_init (struct kunit_suite *test_suite) { +prandom_seed_state (&test_ctx.rnd,0 ); +return 0 ; }Signature · 1 line
2.49.1
PATCH v2 31/34 drm/i915/kunit: Export link training and caps funcs for testing
In reply to Imre DeakExport the link caps and link training helpers needed by the DP link KUnit tests.
Use test ops tables instead of exporting the helpers directly, avoiding symbol name collisions between the i915 and xe builds of the shared display code.
--- .../gpu/drm/i915/display/intel_dp_link_caps.c | 29 +++++++++++++++ .../gpu/drm/i915/display/intel_dp_link_caps.h | 37 +++++++++++++++++++ .../drm/i915/display/intel_dp_link_training.c | 36 +++++++++++++++++- .../drm/i915/display/intel_dp_link_training.h | 31 ++++++++++++++++ .../i915/display/tests/intel_dp_link_test.c | 17 +++++++++ 5 files changed, 148 insertions(+), 2 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +29 -0
@@ -1281,3 +1281,32 @@ void intel_dp_link_caps_cleanup(struct intel_dp_link_caps *link_caps) {kfree (link_caps); } + +#if IS_ENABLED (CONFIG_KUNIT ) + +#define __INIT_MEMBER (__name, __fn) \ + .__name = __fn, + +#define INTEL_DP_LINK_CAPS_TEST_OPS_INIT \ + INTEL_DP_LINK_CAPS_TEST_OPS_MEMBERS(__INIT_MEMBER) + +#ifdef I915 + +const struct intel_dp_link_caps_test_ops i915_display_dp_link_caps_test_ops = { +INTEL_DP_LINK_CAPS_TEST_OPS_INIT +}; +EXPORT_SYMBOL (i915_display_dp_link_caps_test_ops); + +#else + +const struct intel_dp_link_caps_test_ops intel_display_dp_link_caps_test_ops = { +INTEL_DP_LINK_CAPS_TEST_OPS_INIT +}; +EXPORT_SYMBOL (intel_display_dp_link_caps_test_ops); + +#endif /* I915 */ + +#undef INTEL_DP_LINK_CAPS_TEST_OPS_INIT +#undef __INIT_MEMBER + +#endif /* CONFIG_KUNIT */
drivers/gpu/drm/i915/display/intel_dp_link_caps.h +37 -0
@@ -155,4 +155,41 @@ void intel_dp_link_caps_debugfs_add(struct intel_connector *connector);struct intel_dp_link_caps *intel_dp_link_caps_init (struct intel_dp *intel_dp);void intel_dp_link_caps_cleanup (struct intel_dp_link_caps *link_caps); +#if IS_ENABLED (CONFIG_KUNIT ) + +#define INTEL_DP_LINK_CAPS_TEST_OPS_MEMBERS (__X) \ + __X(connector_compute_order, intel_dp_link_caps_connector_compute_order) \ + __X(connector_fallback_order, intel_dp_link_caps_connector_fallback_order) \ + __X(iter_start, intel_dp_link_caps_iter_start) \ + __X(iter_end, intel_dp_link_caps_iter_end) \ + __X(set_max_limits, intel_dp_link_caps_set_max_limits) \ + __X(get_max_limits, intel_dp_link_caps_get_max_limits) \ + __X(get_max_bw_config, intel_dp_link_caps_get_max_bw_config) \ + __X(reset_max_limits, intel_dp_link_caps_reset_max_limits) \ + __X(disable_config, intel_dp_link_caps_disable_config) \ + __X(update, intel_dp_link_caps_update) \ + __X(init, intel_dp_link_caps_init) \ + __X(cleanup, intel_dp_link_caps_cleanup) + +#define __DECLARE_MEMBER (__name, __fn) \ + typeof(__fn) *__name; + +#define INTEL_DP_LINK_CAPS_TEST_OPS_DECLARE \ + INTEL_DP_LINK_CAPS_TEST_OPS_MEMBERS(__DECLARE_MEMBER) + +struct intel_dp_link_caps_test_ops { + INTEL_DP_LINK_CAPS_TEST_OPS_DECLARE +}; + +#undef INTEL_DP_LINK_CAPS_TEST_OPS_DECLARE +#undef __DECLARE_MEMBER + +#ifdef I915 +extern const struct intel_dp_link_caps_test_ops i915_display_dp_link_caps_test_ops; +#else +extern const struct intel_dp_link_caps_test_ops intel_display_dp_link_caps_test_ops; +#endif /* I915 */ + +#endif /* CONFIG_KUNIT */ +#endif /* __INTEL_DP_LINK_CAPS_H__ */
drivers/gpu/drm/i915/display/intel_dp_link_training.c +34 -2
@@ -21,6 +21,8 @@* IN THE SOFTWARE. */ +#include <kunit/visibility.h> +#include <linux/debugfs.h> #include <linux/iopoll.h>
@@ -1888,8 +1890,9 @@ static bool reduce_link_params(struct intel_dp *intel_dp, const struct intel_crtreturn new_found; } -static int intel_dp_get_link_train_fallback_values (struct intel_dp *intel_dp, -const struct intel_crtc_state *crtc_state) +VISIBLE_IF_KUNIT +int intel_dp_get_link_train_fallback_values(struct intel_dp *intel_dp, +const struct intel_crtc_state *crtc_state) {struct intel_display *display =to_intel_display (intel_dp);struct intel_dp_link_caps *link_caps = intel_dp->link.caps;
@@ -2813,3 +2816,32 @@ void intel_dp_link_training_cleanup(struct intel_dp_link_training *link_training {kfree (link_training); } + +#if IS_ENABLED (CONFIG_KUNIT ) + +#define __INIT_MEMBER (__name, __fn) \ + .__name = __fn, + +#define INTEL_DP_LINK_TRAINING_TEST_OPS_INIT \ + INTEL_DP_LINK_TRAINING_TEST_OPS_MEMBERS(__INIT_MEMBER) + +#ifdef I915 + +const struct intel_dp_link_training_test_ops i915_display_dp_link_training_test_ops = { +INTEL_DP_LINK_TRAINING_TEST_OPS_INIT +}; +EXPORT_SYMBOL (i915_display_dp_link_training_test_ops); + +#else + +const struct intel_dp_link_training_test_ops intel_display_dp_link_training_test_ops = { +INTEL_DP_LINK_TRAINING_TEST_OPS_INIT +}; +EXPORT_SYMBOL (intel_display_dp_link_training_test_ops); + +#endif /* I915 */ + +#undef INTEL_DP_LINK_TRAINING_TEST_OPS_INIT +#undef __INIT_MEMBER + +#endif /* CONFIG_KUNIT */
drivers/gpu/drm/i915/display/intel_dp_link_training.h +31 -0
@@ -8,6 +8,8 @@#include <drm/display/drm_dp_helper.h> +#include "intel_dp_link_caps.h" +struct intel_atomic_state ;struct intel_connector ;struct intel_crtc_state ;
@@ -71,4 +73,33 @@ void intel_dp_link_training_reset(struct intel_dp_link_training *link_training);struct intel_dp_link_training *intel_dp_link_training_init (struct intel_dp *intel_dp);void intel_dp_link_training_cleanup (struct intel_dp_link_training *link_training); +#if IS_ENABLED (CONFIG_KUNIT ) + +int intel_dp_get_link_train_fallback_values (struct intel_dp *intel_dp, +const struct intel_crtc_state *crtc_state); + +#define INTEL_DP_LINK_TRAINING_TEST_OPS_MEMBERS (__X) \ + __X(get_fallback_values, intel_dp_get_link_train_fallback_values) + +#define __DECLARE_MEMBER (__name, __fn) \ + typeof(__fn) *__name; + +#define INTEL_DP_LINK_TRAINING_TEST_OPS_DECLARE \ + INTEL_DP_LINK_TRAINING_TEST_OPS_MEMBERS(__DECLARE_MEMBER) + +struct intel_dp_link_training_test_ops { + INTEL_DP_LINK_TRAINING_TEST_OPS_DECLARE +}; + +#undef INTEL_DP_LINK_TRAINING_TEST_OPS_DECLARE +#undef __DECLARE_MEMBER + +#ifdef I915 +extern const struct intel_dp_link_training_test_ops i915_display_dp_link_training_test_ops; +#else +extern const struct intel_dp_link_training_test_ops intel_display_dp_link_training_test_ops; +#endif /* I915 */ + +#endif /* CONFIG_KUNIT */ +#endif /* __INTEL_DP_LINK_TRAINING_H__ */
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +17 -0
@@ -17,6 +17,8 @@#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" struct test_ctx { struct {
@@ -30,6 +32,9 @@ struct test_ctx {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; };
@@ -64,6 +69,8 @@ static int intel_dp_link_test_init(struct kunit *test) 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 ;
@@ -71,10 +78,20 @@ static int intel_dp_link_test_init(struct kunit *test)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 ;
Signature · 1 line
2.49.1
Re: [PATCH v2 31/34] drm/i915/kunit: Export link training and caps funcs for testing
Quoted 8 lines · Imre Deak
Export the link caps and link training helpers needed by the DP link KUnit tests.
Use test ops tables instead of exporting the helpers directly, avoiding symbol name collisions between the i915 and xe builds of the shared display code.
Signed-off-by Imre Deak <[email protected]>
BR,
Michał
Quoted 253 lines
---
.../gpu/drm/i915/display/intel_dp_link_caps.c | 29 +++++++++++++++ .../gpu/drm/i915/display/intel_dp_link_caps.h | 37 +++++++++++++++++++ .../drm/i915/display/intel_dp_link_training.c | 36 +++++++++++++++++- .../drm/i915/display/intel_dp_link_training.h | 31 ++++++++++++++++ .../i915/display/tests/intel_dp_link_test.c | 17 +++++++++ 5 files changed, 148 insertions(+), 2 deletions(-)drivers/gpu/drm/i915/display/intel_dp_link_caps.c +29
-0@@ -1281,3 +1281,32 @@ void intel_dp_link_caps_cleanup(struct intel_dp_link_caps *link_caps) {kfree (link_caps); } + +#if IS_ENABLED (CONFIG_KUNIT ) + +#define __INIT_MEMBER (__name, __fn) \ + .__name = __fn, + +#define INTEL_DP_LINK_CAPS_TEST_OPS_INIT \ + INTEL_DP_LINK_CAPS_TEST_OPS_MEMBERS(__INIT_MEMBER) + +#ifdef I915 + +const struct intel_dp_link_caps_test_ops i915_display_dp_link_caps_test_ops = { +INTEL_DP_LINK_CAPS_TEST_OPS_INIT +}; +EXPORT_SYMBOL (i915_display_dp_link_caps_test_ops); + +#else + +const struct intel_dp_link_caps_test_ops intel_display_dp_link_caps_test_ops = { +INTEL_DP_LINK_CAPS_TEST_OPS_INIT +}; +EXPORT_SYMBOL (intel_display_dp_link_caps_test_ops); + +#endif /* I915 */ + +#undef INTEL_DP_LINK_CAPS_TEST_OPS_INIT +#undef __INIT_MEMBER + +#endif /* CONFIG_KUNIT */ drivers/gpu/drm/i915/display/intel_dp_link_caps.h +37
-0@@ -155,4 +155,41 @@ void intel_dp_link_caps_debugfs_add(struct intel_connector *connector);struct intel_dp_link_caps *intel_dp_link_caps_init (struct intel_dp *intel_dp);void intel_dp_link_caps_cleanup (struct intel_dp_link_caps *link_caps); +#if IS_ENABLED (CONFIG_KUNIT ) + +#define INTEL_DP_LINK_CAPS_TEST_OPS_MEMBERS (__X) \ + __X(connector_compute_order, intel_dp_link_caps_connector_compute_order) \ + __X(connector_fallback_order, intel_dp_link_caps_connector_fallback_order) \ + __X(iter_start, intel_dp_link_caps_iter_start) \ + __X(iter_end, intel_dp_link_caps_iter_end) \ + __X(set_max_limits, intel_dp_link_caps_set_max_limits) \ + __X(get_max_limits, intel_dp_link_caps_get_max_limits) \ + __X(get_max_bw_config, intel_dp_link_caps_get_max_bw_config) \ + __X(reset_max_limits, intel_dp_link_caps_reset_max_limits) \ + __X(disable_config, intel_dp_link_caps_disable_config) \ + __X(update, intel_dp_link_caps_update) \ + __X(init, intel_dp_link_caps_init) \ + __X(cleanup, intel_dp_link_caps_cleanup) + +#define __DECLARE_MEMBER (__name, __fn) \ + typeof(__fn) *__name; + +#define INTEL_DP_LINK_CAPS_TEST_OPS_DECLARE \ + INTEL_DP_LINK_CAPS_TEST_OPS_MEMBERS(__DECLARE_MEMBER) + +struct intel_dp_link_caps_test_ops { + INTEL_DP_LINK_CAPS_TEST_OPS_DECLARE +}; + +#undef INTEL_DP_LINK_CAPS_TEST_OPS_DECLARE +#undef __DECLARE_MEMBER + +#ifdef I915 +extern const struct intel_dp_link_caps_test_ops i915_display_dp_link_caps_test_ops; +#else +extern const struct intel_dp_link_caps_test_ops intel_display_dp_link_caps_test_ops; +#endif /* I915 */ + +#endif /* CONFIG_KUNIT */ +#endif /* __INTEL_DP_LINK_CAPS_H__ */ drivers/gpu/drm/i915/display/intel_dp_link_training.c +34
-2@@ -21,6 +21,8 @@* IN THE SOFTWARE. */ +#include <kunit/visibility.h> +#include <linux/debugfs.h> #include <linux/iopoll.h> @@ -1888,8 +1890,9 @@ static bool reduce_link_params(struct intel_dp *intel_dp, const struct intel_crtreturn new_found; } -static int intel_dp_get_link_train_fallback_values (struct intel_dp *intel_dp, -const struct intel_crtc_state *crtc_state) +VISIBLE_IF_KUNIT +int intel_dp_get_link_train_fallback_values(struct intel_dp *intel_dp, +const struct intel_crtc_state *crtc_state) {struct intel_display *display =to_intel_display (intel_dp);struct intel_dp_link_caps *link_caps = intel_dp->link.caps;@@ -2813,3 +2816,32 @@ void intel_dp_link_training_cleanup(struct intel_dp_link_training *link_training {kfree (link_training); } + +#if IS_ENABLED (CONFIG_KUNIT ) + +#define __INIT_MEMBER (__name, __fn) \ + .__name = __fn, + +#define INTEL_DP_LINK_TRAINING_TEST_OPS_INIT \ + INTEL_DP_LINK_TRAINING_TEST_OPS_MEMBERS(__INIT_MEMBER) + +#ifdef I915 + +const struct intel_dp_link_training_test_ops i915_display_dp_link_training_test_ops = { +INTEL_DP_LINK_TRAINING_TEST_OPS_INIT +}; +EXPORT_SYMBOL (i915_display_dp_link_training_test_ops); + +#else + +const struct intel_dp_link_training_test_ops intel_display_dp_link_training_test_ops = { +INTEL_DP_LINK_TRAINING_TEST_OPS_INIT +}; +EXPORT_SYMBOL (intel_display_dp_link_training_test_ops); + +#endif /* I915 */ + +#undef INTEL_DP_LINK_TRAINING_TEST_OPS_INIT +#undef __INIT_MEMBER + +#endif /* CONFIG_KUNIT */ drivers/gpu/drm/i915/display/intel_dp_link_training.h +31
-0@@ -8,6 +8,8 @@#include <drm/display/drm_dp_helper.h> +#include "intel_dp_link_caps.h" +struct intel_atomic_state ;struct intel_connector ;struct intel_crtc_state ;@@ -71,4 +73,33 @@ void intel_dp_link_training_reset(struct intel_dp_link_training *link_training);struct intel_dp_link_training *intel_dp_link_training_init (struct intel_dp *intel_dp);void intel_dp_link_training_cleanup (struct intel_dp_link_training *link_training); +#if IS_ENABLED (CONFIG_KUNIT ) + +int intel_dp_get_link_train_fallback_values (struct intel_dp *intel_dp, +const struct intel_crtc_state *crtc_state); + +#define INTEL_DP_LINK_TRAINING_TEST_OPS_MEMBERS (__X) \ + __X(get_fallback_values, intel_dp_get_link_train_fallback_values) + +#define __DECLARE_MEMBER (__name, __fn) \ + typeof(__fn) *__name; + +#define INTEL_DP_LINK_TRAINING_TEST_OPS_DECLARE \ + INTEL_DP_LINK_TRAINING_TEST_OPS_MEMBERS(__DECLARE_MEMBER) + +struct intel_dp_link_training_test_ops { + INTEL_DP_LINK_TRAINING_TEST_OPS_DECLARE +}; + +#undef INTEL_DP_LINK_TRAINING_TEST_OPS_DECLARE +#undef __DECLARE_MEMBER + +#ifdef I915 +extern const struct intel_dp_link_training_test_ops i915_display_dp_link_training_test_ops; +#else +extern const struct intel_dp_link_training_test_ops intel_display_dp_link_training_test_ops; +#endif /* I915 */ + +#endif /* CONFIG_KUNIT */ +#endif /* __INTEL_DP_LINK_TRAINING_H__ */ drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +17
-0@@ -17,6 +17,8 @@#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" struct test_ctx { struct {@@ -30,6 +32,9 @@ struct test_ctx {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; };@@ -64,6 +69,8 @@ static int intel_dp_link_test_init(struct kunit *test) 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 ;@@ -71,10 +78,20 @@ static int intel_dp_link_test_init(struct kunit *test)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 ;Signature · 1 line
2.49.1
Jani Nikula
maintainerRe: [PATCH v2 31/34] drm/i915/kunit: Export link training and caps funcs for testing
In reply to Imre DeakQuoted 6 lines · Imre Deak
Export the link caps and link training helpers needed by the DP link KUnit tests.
Use test ops tables instead of exporting the helpers directly, avoiding symbol name collisions between the i915 and xe builds of the shared display code.
Okay, so this one slipped through and was merged.
I understand it took time and effort to figure out how to make this work for both i915 and xe... but frankly, this is now an awful hack that *must* be undone and refactored and fixed to work with the future display module.
We can't have a single #ifdef I915.
I don't even see the real benefit for testing this for both i915 and xe, separately. One should've been enough.
BR,
Jani.
Quoted 251 lines
Signed-off-by Imre Deak <[email protected]>--- .../gpu/drm/i915/display/intel_dp_link_caps.c | 29 +++++++++++++++ .../gpu/drm/i915/display/intel_dp_link_caps.h | 37 +++++++++++++++++++ .../drm/i915/display/intel_dp_link_training.c | 36 +++++++++++++++++- .../drm/i915/display/intel_dp_link_training.h | 31 ++++++++++++++++ .../i915/display/tests/intel_dp_link_test.c | 17 +++++++++ 5 files changed, 148 insertions(+), 2 deletions(-)drivers/gpu/drm/i915/display/intel_dp_link_caps.c +29
-0@@ -1281,3 +1281,32 @@ void intel_dp_link_caps_cleanup(struct intel_dp_link_caps *link_caps) {kfree (link_caps); } + +#if IS_ENABLED (CONFIG_KUNIT ) + +#define __INIT_MEMBER (__name, __fn) \ + .__name = __fn, + +#define INTEL_DP_LINK_CAPS_TEST_OPS_INIT \ + INTEL_DP_LINK_CAPS_TEST_OPS_MEMBERS(__INIT_MEMBER) + +#ifdef I915 + +const struct intel_dp_link_caps_test_ops i915_display_dp_link_caps_test_ops = { +INTEL_DP_LINK_CAPS_TEST_OPS_INIT +}; +EXPORT_SYMBOL (i915_display_dp_link_caps_test_ops); + +#else + +const struct intel_dp_link_caps_test_ops intel_display_dp_link_caps_test_ops = { +INTEL_DP_LINK_CAPS_TEST_OPS_INIT +}; +EXPORT_SYMBOL (intel_display_dp_link_caps_test_ops); + +#endif /* I915 */ + +#undef INTEL_DP_LINK_CAPS_TEST_OPS_INIT +#undef __INIT_MEMBER + +#endif /* CONFIG_KUNIT */ drivers/gpu/drm/i915/display/intel_dp_link_caps.h +37
-0@@ -155,4 +155,41 @@ void intel_dp_link_caps_debugfs_add(struct intel_connector *connector);struct intel_dp_link_caps *intel_dp_link_caps_init (struct intel_dp *intel_dp);void intel_dp_link_caps_cleanup (struct intel_dp_link_caps *link_caps); +#if IS_ENABLED (CONFIG_KUNIT ) + +#define INTEL_DP_LINK_CAPS_TEST_OPS_MEMBERS (__X) \ + __X(connector_compute_order, intel_dp_link_caps_connector_compute_order) \ + __X(connector_fallback_order, intel_dp_link_caps_connector_fallback_order) \ + __X(iter_start, intel_dp_link_caps_iter_start) \ + __X(iter_end, intel_dp_link_caps_iter_end) \ + __X(set_max_limits, intel_dp_link_caps_set_max_limits) \ + __X(get_max_limits, intel_dp_link_caps_get_max_limits) \ + __X(get_max_bw_config, intel_dp_link_caps_get_max_bw_config) \ + __X(reset_max_limits, intel_dp_link_caps_reset_max_limits) \ + __X(disable_config, intel_dp_link_caps_disable_config) \ + __X(update, intel_dp_link_caps_update) \ + __X(init, intel_dp_link_caps_init) \ + __X(cleanup, intel_dp_link_caps_cleanup) + +#define __DECLARE_MEMBER (__name, __fn) \ + typeof(__fn) *__name; + +#define INTEL_DP_LINK_CAPS_TEST_OPS_DECLARE \ + INTEL_DP_LINK_CAPS_TEST_OPS_MEMBERS(__DECLARE_MEMBER) + +struct intel_dp_link_caps_test_ops { + INTEL_DP_LINK_CAPS_TEST_OPS_DECLARE +}; + +#undef INTEL_DP_LINK_CAPS_TEST_OPS_DECLARE +#undef __DECLARE_MEMBER + +#ifdef I915 +extern const struct intel_dp_link_caps_test_ops i915_display_dp_link_caps_test_ops; +#else +extern const struct intel_dp_link_caps_test_ops intel_display_dp_link_caps_test_ops; +#endif /* I915 */ + +#endif /* CONFIG_KUNIT */ +#endif /* __INTEL_DP_LINK_CAPS_H__ */ drivers/gpu/drm/i915/display/intel_dp_link_training.c +34
-2@@ -21,6 +21,8 @@* IN THE SOFTWARE. */ +#include <kunit/visibility.h> +#include <linux/debugfs.h> #include <linux/iopoll.h> @@ -1888,8 +1890,9 @@ static bool reduce_link_params(struct intel_dp *intel_dp, const struct intel_crtreturn new_found; } -static int intel_dp_get_link_train_fallback_values (struct intel_dp *intel_dp, -const struct intel_crtc_state *crtc_state) +VISIBLE_IF_KUNIT +int intel_dp_get_link_train_fallback_values(struct intel_dp *intel_dp, +const struct intel_crtc_state *crtc_state) {struct intel_display *display =to_intel_display (intel_dp);struct intel_dp_link_caps *link_caps = intel_dp->link.caps;@@ -2813,3 +2816,32 @@ void intel_dp_link_training_cleanup(struct intel_dp_link_training *link_training {kfree (link_training); } + +#if IS_ENABLED (CONFIG_KUNIT ) + +#define __INIT_MEMBER (__name, __fn) \ + .__name = __fn, + +#define INTEL_DP_LINK_TRAINING_TEST_OPS_INIT \ + INTEL_DP_LINK_TRAINING_TEST_OPS_MEMBERS(__INIT_MEMBER) + +#ifdef I915 + +const struct intel_dp_link_training_test_ops i915_display_dp_link_training_test_ops = { +INTEL_DP_LINK_TRAINING_TEST_OPS_INIT +}; +EXPORT_SYMBOL (i915_display_dp_link_training_test_ops); + +#else + +const struct intel_dp_link_training_test_ops intel_display_dp_link_training_test_ops = { +INTEL_DP_LINK_TRAINING_TEST_OPS_INIT +}; +EXPORT_SYMBOL (intel_display_dp_link_training_test_ops); + +#endif /* I915 */ + +#undef INTEL_DP_LINK_TRAINING_TEST_OPS_INIT +#undef __INIT_MEMBER + +#endif /* CONFIG_KUNIT */ drivers/gpu/drm/i915/display/intel_dp_link_training.h +31
-0@@ -8,6 +8,8 @@#include <drm/display/drm_dp_helper.h> +#include "intel_dp_link_caps.h" +struct intel_atomic_state ;struct intel_connector ;struct intel_crtc_state ;@@ -71,4 +73,33 @@ void intel_dp_link_training_reset(struct intel_dp_link_training *link_training);struct intel_dp_link_training *intel_dp_link_training_init (struct intel_dp *intel_dp);void intel_dp_link_training_cleanup (struct intel_dp_link_training *link_training); +#if IS_ENABLED (CONFIG_KUNIT ) + +int intel_dp_get_link_train_fallback_values (struct intel_dp *intel_dp, +const struct intel_crtc_state *crtc_state); + +#define INTEL_DP_LINK_TRAINING_TEST_OPS_MEMBERS (__X) \ + __X(get_fallback_values, intel_dp_get_link_train_fallback_values) + +#define __DECLARE_MEMBER (__name, __fn) \ + typeof(__fn) *__name; + +#define INTEL_DP_LINK_TRAINING_TEST_OPS_DECLARE \ + INTEL_DP_LINK_TRAINING_TEST_OPS_MEMBERS(__DECLARE_MEMBER) + +struct intel_dp_link_training_test_ops { + INTEL_DP_LINK_TRAINING_TEST_OPS_DECLARE +}; + +#undef INTEL_DP_LINK_TRAINING_TEST_OPS_DECLARE +#undef __DECLARE_MEMBER + +#ifdef I915 +extern const struct intel_dp_link_training_test_ops i915_display_dp_link_training_test_ops; +#else +extern const struct intel_dp_link_training_test_ops intel_display_dp_link_training_test_ops; +#endif /* I915 */ + +#endif /* CONFIG_KUNIT */ +#endif /* __INTEL_DP_LINK_TRAINING_H__ */ drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +17
-0@@ -17,6 +17,8 @@#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" struct test_ctx { struct {@@ -30,6 +32,9 @@ struct test_ctx {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; };@@ -64,6 +69,8 @@ static int intel_dp_link_test_init(struct kunit *test) 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 ;@@ -71,10 +78,20 @@ static int intel_dp_link_test_init(struct kunit *test)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 ;
Signature · 1 line
Jani Nikula, Intel
PATCH v2 32/34 drm/i915/kunit: DP link: add baseline fixed table reference test
In reply to Imre DeakAdd a simple baseline test for DP link caps iteration using a fixed standard DP configuration table. This provides a minimal validity check, independent of more complex test setups, verifying the iterator returns expected configurations in ascending and descending order.
--- .../i915/display/tests/intel_dp_link_test.c | 200 ++++++++++++++++++ 1 file changed, 200 insertions(+)
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +200 -0
@@ -7,6 +7,7 @@#include <linux/compiler.h> #include <linux/device.h> +#include <linux/log2.h> #include <linux/prandom.h> #include <linux/random.h>
@@ -20,6 +21,18 @@#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;
@@ -38,7 +51,194 @@ struct test_ctx {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; +}; + +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)) + +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 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 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 , + } +}; + +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 struct kunit_case intel_dp_link_test_cases[] = { +KUNIT_CASE (intel_dp_link_caps_test_baseline), + {} };
Signature · 1 line
2.49.1
Re: [PATCH v2 32/34] drm/i915/kunit: DP link: add baseline fixed table reference test
Quoted 147 lines · Imre Deak
Add a simple baseline test for DP link caps iteration using a fixed standard DP configuration table. This provides a minimal validity check, independent of more complex test setups, verifying the iterator returns expected configurations in ascending and descending order.
Signed-off-by Imre Deak <[email protected]>---
.../i915/display/tests/intel_dp_link_test.c| 200 ++++++++++++++++++1 file changed, 200 insertions(+)drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +115
-0@@ -7,6 +7,7 @@#include <linux/compiler.h> #include <linux/device.h> +#include <linux/log2.h> #include <linux/prandom.h> #include <linux/random.h> @@ -20,6 +21,18 @@#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;@@ -38,7 +51,194 @@ struct test_ctx {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; +}; + +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)) + +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 },
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c struct test_ctx { · line 165
Quoted 10 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +10
-0+ }, + .size = LINK_TEST_NUM_CONFIGS(ARRAY_SIZE(standard_dp_link_rates), + LINK_TEST_MAX_LANE_COUNT), + }, +}; + +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;
maybe: s/\<a\>/lc_a/ and s/\<b\>/lc_b/
Quoted 17 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +17
-0+} + +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 , + } +};
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c struct test_ctx { · line 192
Quoted 10 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +10
-0+ +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 +* -----------------------------------------
Didn't find in other KUnit tests such header, but I think the info provided is valuable. Can we add it to the line below, something like:
* Verify baseline link_caps config iterator using fixed standard DP config tables.
Quoted 39 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +39
-0+* 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,
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c struct test_ctx { · line 241
Quoted 10 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +9
-0+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 struct kunit_case intel_dp_link_test_cases[] = { +KUNIT_CASE (intel_dp_link_caps_test_baseline), +
looks like a superfluous newline.
With all that addressed:
BR,
Michał
Quoted 7 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +0
-0{} };Signature · 1 line
2.49.1
Re: [PATCH v2 32/34] drm/i915/kunit: DP link: add baseline fixed table reference test
Quoted 152 lines · Michał Grzelak
Quoted 151 lines · Imre Deak
Add a simple baseline test for DP link caps iteration using a fixed standard DP configuration table. This provides a minimal validity check, independent of more complex test setups, verifying the iterator returns expected configurations in ascending and descending order.
Signed-off-by Imre Deak <[email protected]>---
.../i915/display/tests/intel_dp_link_test.c| 200 ++++++++++++++++++1 file changed, 200 insertions(+)drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +119
-0@@ -7,6 +7,7 @@#include <linux/compiler.h> #include <linux/device.h> +#include <linux/log2.h> #include <linux/prandom.h> #include <linux/random.h> @@ -20,6 +21,18 @@#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;@@ -38,7 +51,194 @@ struct test_ctx {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; +}; + +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)) + +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 ), + },
Quoted 8 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c struct test_ctx { · line 165
Quoted 6 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +6
-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;maybe: s/\<a\>/lc_a/ and s/\<b\>/lc_b/
It's customary to use a/b as pointers for two objects being compared in simple functions like this.
Quoted 23 lines
Quoted 23 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +22
-0+} + +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 , + } +}; + +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];
Quoted 8 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c struct test_ctx { · line 192
Quoted 5 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +5
-0+} + +/* +* TEST: Baseline with fixed reference table +* ----------------------------------------- Didn't find in other KUnit tests such header, but I think the info provided is valuable.
The header describes the group of tests added in this patch, similarly to the two other group of tests added in the follow-up patches.
Quoted 3 lines
Can we add it to the line below, something like:
* Verify baseline
link_capsconfig iterator using fixed standard DP config tables.
Not sure, to me the line below describes sufficiently what this test group does.
Quoted 43 lines
Quoted 43 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +43
-0+* 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++)
Quoted 8 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c struct test_ctx { · line 241
Quoted 6 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +5
-0+baseline_test_for_order (test, link_caps, config_orders[i]); +} +static struct kunit_case intel_dp_link_test_cases[] = { +KUNIT_CASE (intel_dp_link_caps_test_baseline), +looks like a superfluous newline.
The newline keeps the {} separate from test entry lines.
Quoted 14 lines
With all that addressed:
Reviewed-by Michał Grzelak <[email protected]>BR,
MichałQuoted 7 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +0
-0{} };Signature · 1 line
2.49.1
PATCH v3 32/34 drm/i915/kunit: DP link: add baseline fixed table reference test
In reply to Imre DeakAdd a simple baseline test for DP link caps iteration using a fixed standard DP configuration table. This provides a minimal validity check, independent of more complex test setups, verifying the iterator returns expected configurations in ascending and descending order.
v2: Unchanged.
v3: Test config iteration in lane count, rate order as well.
--- .../i915/display/tests/intel_dp_link_test.c | 206 ++++++++++++++++++ 1 file changed, 206 insertions(+)
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +206 -0
@@ -7,6 +7,7 @@#include <linux/compiler.h> #include <linux/device.h> +#include <linux/log2.h> #include <linux/prandom.h> #include <linux/random.h>
@@ -20,6 +21,18 @@#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;
@@ -38,7 +51,200 @@ struct test_ctx {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; +}; + +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)) + +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 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 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 struct kunit_case intel_dp_link_test_cases[] = { +KUNIT_CASE (intel_dp_link_caps_test_baseline), + {} };
Signature · 1 line
2.49.1
PATCH v2 33/34 drm/i915/kunit: DP link: add update config tests
In reply to Imre DeakAdd 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.
--- .../i915/display/tests/intel_dp_link_test.c | 780 ++++++++++++++++++ 1 file changed, 780 insertions(+)
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +780 -0
@@ -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 +* ------------------ +* 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++) { +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); +} +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), + {} };
Signature · 1 line
2.49.1
Re: [PATCH v2 33/34] drm/i915/kunit: DP link: add update config tests
Quoted 113 lines · Imre Deak
Add KUnit tests for
link_capsupdates 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 <[email protected]>---
.../i915/display/tests/intel_dp_link_test.c| 780 ++++++++++++++++++1 file changed, 780 insertions(+)drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +64
-0@@ -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);
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c static void intel_dp_link_caps_test_baseline(struct kunit *test) · line 312
Quoted 10 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +10
-0+} + +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.
Quoted 294 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +294
-0+* 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;
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c static void intel_dp_link_caps_test_baseline(struct kunit *test) · line 616
Quoted 10 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +10
-0+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?
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c static void intel_dp_link_caps_test_baseline(struct kunit *test) · line 628
Quoted 12 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +12
-0+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.
Quoted 24 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +24
-0+* 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); + } +} +
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c static void intel_dp_link_caps_test_baseline(struct kunit *test) · line 662
Quoted 10 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +10
-0+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, /
Quoted 173 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +173
-0+* 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 );
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c static void intel_dp_link_caps_test_baseline(struct kunit *test) · line 845
Quoted 10 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +10
-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)))
Quoted 23 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +23
-0+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 ; +
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c static void intel_dp_link_caps_test_baseline(struct kunit *test) · line 878
Quoted 10 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +10
-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().
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c static void intel_dp_link_caps_test_baseline(struct kunit *test) · line 881
Quoted 3 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +3
-0+ *rates_step =rand_in_range (ctx,1 , num_rates -1 ); + +if (shrink_mask &BIT (0 ))
ditto.
Quoted 13 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +13
-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 ; +
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c static void intel_dp_link_caps_test_baseline(struct kunit *test) · line 904
Quoted 10 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +10
-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.
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c static void intel_dp_link_caps_test_baseline(struct kunit *test) · line 907
Quoted 3 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +3
-0+ *rates_step =rand_in_range (ctx,1 , max_num_rates - num_rates); + +if (expand_mask &BIT (0 ))
ditto.
Quoted 104 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +101
-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); +} +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),
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c static void intel_dp_link_caps_test_baseline(struct kunit *test) · line 1021
Quoted 10 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +10
-0+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:
BR,
Michał
Quoted 7 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +0
-0{} };Signature · 1 line
2.49.1
Re: [PATCH v2 33/34] drm/i915/kunit: DP link: add update config tests
Quoted 111 lines · Michał Grzelak
Quoted 110 lines · Imre Deak
Add KUnit tests for
link_capsupdates 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 <[email protected]>---
.../i915/display/tests/intel_dp_link_test.c| 780 ++++++++++++++++++1 file changed, 780 insertions(+)drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +61
-0@@ -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]); }
Quoted 15 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c static void intel_dp_link_caps_test_baseline(struct kunit *test) · line 312
Quoted 13 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +13
-0+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.
Quoted 300 lines
Quoted 300 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +300
-0+* 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;
Quoted 8 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c static void intel_dp_link_caps_test_baseline(struct kunit *test) · line 616
Quoted 4 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +4
-0+ 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.
Quoted 236 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c static void intel_dp_link_caps_test_baseline(struct kunit *test) · line 628
Quoted 12 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +12
-0+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.
Quoted 24 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +24
-0+* 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); + } +} +drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c static void intel_dp_link_caps_test_baseline(struct kunit *test) · line 662
Quoted 10 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +10
-0+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, /
Quoted 173 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +173
-0+* 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 );drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c static void intel_dp_link_caps_test_baseline(struct kunit *test) · line 845
Quoted 10 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +10
-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:
Quoted 1 line
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.
Quoted 203 lines
Quoted 23 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +23
-0+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 ; +drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c static void intel_dp_link_caps_test_baseline(struct kunit *test) · line 878
Quoted 10 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +10
-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().drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c static void intel_dp_link_caps_test_baseline(struct kunit *test) · line 881
Quoted 3 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +3
-0+ *rates_step =rand_in_range (ctx,1 , num_rates -1 ); + +if (shrink_mask &BIT (0 ))ditto.
Quoted 13 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +13
-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 ; +drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c static void intel_dp_link_caps_test_baseline(struct kunit *test) · line 904
Quoted 10 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +10
-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.
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c static void intel_dp_link_caps_test_baseline(struct kunit *test) · line 907
Quoted 3 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +3
-0+ *rates_step =rand_in_range (ctx,1 , max_num_rates - num_rates); + +if (expand_mask &BIT (0 ))ditto.
Quoted 104 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +101
-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); +} +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),drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c static void intel_dp_link_caps_test_baseline(struct kunit *test) · line 1021
Quoted 10 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +10
-0+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 <[email protected]>BR,
MichałQuoted 5 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +0
-0{} };Signature · 1 line
2.49.1
PATCH v3 33/34 drm/i915/kunit: DP link: add update config tests
In reply to Imre DeakAdd 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. v3:
- Test config iteration in lane count, rate order as well.
- Keep space after comma in code comment. (Michał)
--- .../i915/display/tests/intel_dp_link_test.c | 804 ++++++++++++++++++ 1 file changed, 804 insertions(+)
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +804 -0
@@ -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 ,
@@ -242,9 +303,752 @@ 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 +* ------------------ +* 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); +} +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), + {} };
Signature · 1 line
2.49.1
PATCH v2 34/34 drm/i915/kunit: DP link: add fallback tests
In reply to Imre DeakAdd KUnit tests for DP link fallback selection across eDP, SST, and MST. Verify that the fallback logic properly selects the maximum allowed configuration, iterates through allowed configurations, and disables failed configs as expected.
These tests include UHBR vs. non-UHBR conditions, MST vs. SST mode, and validate that subsequent fallback selections respect the updated allowed configuration mask.
v2:
- Rebase on changes using a filter object instead of a mask of configuration indices.
- Rebase on changes using an iteration object.
--- .../i915/display/tests/intel_dp_link_test.c | 318 ++++++++++++++++++ 1 file changed, 318 insertions(+)
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +318 -0
@@ -1001,6 +1001,319 @@ static void intel_dp_link_caps_test_update_params_expand_disable_random(struct ktest_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,int max_rate, +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) +if (max_rate ==0 || iter_config.rate <= max_rate) +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 bool output_type_allows_uhbr_fallback (enum intel_output_type output_type) +{ +return output_type ==INTEL_OUTPUT_DP_MST ; +} + +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]; + +if (output_type_allows_uhbr_fallback (output_type) || + (drm_dp_is_uhbr_rate (target_config->rate) == +drm_dp_is_uhbr_rate (config->rate))) { +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, +int max_rate, +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]; + +if (config->rate <= max_rate) { +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, +bool uhbr) +{ +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; +int max_rate; + +if (uhbr) + max_rate = expected_table.rates.entries[expected_table.rates.size -1 ]; +else + max_rate =810000 ; + + 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, + max_rate, &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, max_rate, + &target_config, &fallback_config)) +break ; + +/* +* The fallback changed the max rate allowed for the next +* target. +*/ + max_rate = fallback_config.rate; + +/* 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_max_non_uhbr (struct kunit *test) +{ +test_fallback_seq (test,INTEL_OUTPUT_DP , false); +} + +static void intel_dp_link_test_fallback_for_sst_max_uhbr (struct kunit *test) +{ +test_fallback_seq (test,INTEL_OUTPUT_DP , true); +} + +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 , true); +} +static struct kunit_case intel_dp_link_test_cases[] = {KUNIT_CASE (intel_dp_link_caps_test_baseline),
@@ -1019,6 +1332,11 @@ static struct kunit_case intel_dp_link_test_cases[] = {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_max_non_uhbr), +KUNIT_CASE (intel_dp_link_test_fallback_for_sst_max_uhbr), + KUNIT_CASE(intel_dp_link_test_fallback_for_mst), + {} };
Signature · 1 line
2.49.1
Re: [PATCH v2 34/34] drm/i915/kunit: DP link: add fallback tests
Quoted 24 lines · Imre Deak
Add KUnit tests for DP link fallback selection across eDP, SST, and MST. Verify that the fallback logic properly selects the maximum allowed configuration, iterates through allowed configurations, and disables failed configs as expected.
These tests include UHBR vs. non-UHBR conditions, MST vs. SST mode, and validate that subsequent fallback selections respect the updated allowed configuration mask.
v2:
- Rebase on changes using a filter object instead of a mask of configuration indices.
- Rebase on changes using an iteration object.Signed-off-by Imre Deak <[email protected]>---
.../i915/display/tests/intel_dp_link_test.c| 318 ++++++++++++++++++1 file changed, 318 insertions(+)drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +0
-0
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c static void intel_dp_link_caps_test_update_params_expand_disable_random(struct k · line 1006
Quoted 6 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +3
-0@@ -1001,6 +1001,319 @@ static void intel_dp_link_caps_test_update_params_expand_disable_random(struct ktest_update_params_expand_random (test, true); } +/* +* TEST: Fallback sequence +* -----------------------
Same comment as in PATCH 32/34.
Quoted 185 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +185
-0+* 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,int max_rate, +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) +if (max_rate ==0 || iter_config.rate <= max_rate) +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 bool output_type_allows_uhbr_fallback (enum intel_output_type output_type) +{ +return output_type ==INTEL_OUTPUT_DP_MST ; +} + +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)
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c static void intel_dp_link_caps_test_update_params_expand_disable_random(struct k · line 1201
Quoted 10 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +10
-0+{ +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--) {
For me it would read easier with being slightly more explicit, eg.:
KUNIT_ASSERT_GE(test, i, 0);
if (i == 0)
return false;
i--;
for (; i >= 0; i--) {
But that's a matter of opinion I guess. Anyways:
BR,
Michał
Quoted 134 lines
drivers/gpu/drm/i915/display/tests/intel_dp_link_test.c +120
-0+const struct intel_dp_link_config *config = + &config_set->entries[i]; + +if (output_type_allows_uhbr_fallback (output_type) || + (drm_dp_is_uhbr_rate (target_config->rate) == +drm_dp_is_uhbr_rate (config->rate))) { +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, +int max_rate, +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]; + +if (config->rate <= max_rate) { +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, +bool uhbr) +{ +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; +int max_rate; + +if (uhbr) + max_rate = expected_table.rates.entries[expected_table.rates.size -1 ]; +else + max_rate =810000 ; + + 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, + max_rate, &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, max_rate, + &target_config, &fallback_config)) +break ; + +/* +* The fallback changed the max rate allowed for the next +* target. +*/ + max_rate = fallback_config.rate; + +/* 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_max_non_uhbr (struct kunit *test) +{ +test_fallback_seq (test,INTEL_OUTPUT_DP , false); +} + +static void intel_dp_link_test_fallback_for_sst_max_uhbr (struct kunit *test) +{ +test_fallback_seq (test,INTEL_OUTPUT_DP , true); +} + +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 , true); +} +static struct kunit_case intel_dp_link_test_cases[] = {KUNIT_CASE (intel_dp_link_caps_test_baseline),@@ -1019,6 +1332,11 @@ static struct kunit_case intel_dp_link_test_cases[] = {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_max_non_uhbr), +KUNIT_CASE (intel_dp_link_test_fallback_for_sst_max_uhbr), + KUNIT_CASE(intel_dp_link_test_fallback_for_mst), + {} };Signature · 1 line
2.49.1