Skip to contentSkip to conversation

drm/i915/dp_link: Refactor DP link capability logic

PATCH Superseded Imre Deak 4 participants 143 messages Apr 28 – May 8 Page 1 of 2

Subsystems (6)

v1 of 2 Superseded Latest is v2 →

lore
Share & tools
lore

Imre Deak

author
#0 lore raw

cover drm/i915/dp_link: Refactor DP link capability logic

This series separates DP link capability handling from link training and recovery and introduces a consistent model for link configuration selection during state computation and fallback, with KUnit tests validating the behavior. The patchset is also available at [1].

The issues addressed are as follows:

Link state computation:
- Diverging logic for selecting a link configuration for eDP, DP SST, and DP MST, for both non-DSC and DSC cases.

Link training fallback:
- Diverging policies for selecting fallback link configurations after link training failures for eDP, DP SST, and DP MST.
- Inflexible fallback selection, setting a maximum link rate/lane count for subsequent modesets, preventing the use of link configurations that have not failed during link training and so could still work.
- eDP and DP SST fallback order not compliant with the DP standard, using a descending lane/rate order instead of bandwidth order.
- eDP and DP SST fallback lane/rate order not matching the link state compuation's rate/lane order.
- The above inflexible fallback order resulting in inconsistent reporting of the valid connector modes for eDP and DP SST after a link training failure. Modes may disappear and reappear during the fallback sequence.

Link training recovery:
- Unclear semantics between driver-driven and userspace-driven recovery.
- Unclear distinction between modeset failures and actual link training failures during automatic retraining, and lack of proper handling of the former.

Interaction of link state computation, fallback and recovery:
- Handling of the supported-, allowed-, forced-, fallback-link configurations, and link recovery decisions are intertwined across multiple modules with direct access/mutation of the relevant state, instead of having clear interfaces for these.
- Lack of documentation and unit test coverage for the handling of link-capabilities, -configurations and for the fallback/recovery logic.

This patchset addresses the above primarily by introducing a central link capability module (intel_dp_link_caps.c) and restructuring the detection of link capabilities, link state computation, fallback and recovery to query and adjust link configurations exclusively via that interface.

The current behavior is preserved for both modeset state computation and link training fallback/recovery logic. For now this patchset will enable setting a particular link configuration ordering on a per-connector basis (both as a default based on the connector type and as a dynamic setting); that in turn allows - as a follow-up to this patchset - to switch over to a unified, bandwidth-based fallback policy by simply changing the ordering for a given connector type.

The changes in more detail are (everywhere assuming the switch-over to the new scheme as a follow-up based on the above):

Link state computation:
- Unify link configuration selection logic for eDP, DP SST, and DP MST, for both non-DSC and DSC cases, using the same interface to query and adjust the allowed link configuration set, using the same configuration ordering for this.

Link training fallback:
- Unified fallback selection mechanism across connector types, matching the mechanism of the link state computation phase.
- Enable a more fine-grained fallback policy by disabling only the link configuration that failed link training, preserving the rest for subsequent modesets.
- Align fallback ordering with that of the link state computation.
- Ensure a consistent view of supported connector modes across fallback sequences.

Link training recovery:
- Clarify and separate driver-driven and userspace-driven recovery semantics, and document these.
- Distinguish modeset failures from link training failures during automatic retraining and handle modeset failures appropriately.

Interaction of link state computation, fallback and recovery:
- Separate the tracking of supported link configurations - based on the sink's detected capabilities - and selection of fallback configurations into their dedicated modules, with a well-defined interface to query and adjust the configurations available for a modeset:

Detection Computation (intel_dp.c)
| |
| adjust query |
| |
+----> Capabilities <------+ (intel_dp_link_caps.c)
^
| adjust/query
|
Fallback (intel_dp_link_training.c)

- Ensure consistent link configuration ordering across computation and fallback phases.
- Add detailed documentation and test coverage for the link capabilities interface and the link recovery logic.

Patchset layout:

This is a large series because the interfaces and state tracking for link-state computation, fallback, and recovery are intertwined across multiple modules. They also rely on direct access to, and mutation of, state instead of a proper interface, so untangling this was involved.

Nevertheless, most changes are mechanical code movement and renaming:
separating link training and link capability handling from the generic DP code and moving them into dedicated modules.

A large part of both the link training and link caps portions of this series follows the same idea:

1. Move existing helpers accessing link training or link caps state.
2. Add new helpers for accessing that state, converting all direct users to use them.
3. Move the state to be internal to the respective module.

Later parts (notably the link capability module) depend on earlier refactoring of link training. The rationale for submitting all the changes in a single patchset is twofold:

1. The last segment, adding the link capability interface, requires all previous refactoring to both generic DP and link training code.
2. The purpose of much of the earlier refactoring only becomes clear in the context of the last segment adding the link capability interface. All intermediate steps in those segments prepare for the introduction of the link capability interface, which at the end connects link-capability detection, -state computation and -fallback/recovery functionality in a unified way.

The series is therefore kept as a single unit, but organized into the following segments of patches to allow incremental review and merging:

- Link training refactoring: 1-26
- Link capabilities refactoring: 27-89
- Unify configuration selection for modeset and fallback: 90-99
- Kunit tests for configuration selection: 100-108

[1] https://github.com/ideak/linux/commits/dp-link-caps

Imre Deak (108):
drm/i915/dp: Move clamping max link rate to common rates setup drm/i915/dp: Clamp max lane count to max common lane count drm/i915/dp: Bump connector epoch on link capability changes drm/i915/dp_link_training: Introduce link training state struct drm/i915/dp_link_training: Factor out link training state reset helper drm/i915/dp_link_training: Reset link training state on link
capability change
drm/i915/dp_link_training: Flush commits in debugfs entries drm/i915/dp_link_training: Move link training helpers to link training
code
drm/i915/dp_link_training: Use link_training as base pointer in
debugfs
drm/i915/dp_link_training: Add helpers to access force retrain state drm/i915/dp_link_training: Move link recovery/debug state to
link_training
drm/i915/dp_link_training: Prevent repeated autoretrain attempts drm/i915/dp_link_training: Clamp sequential link training failure
counter
drm/i915/dp_link_training: Check for pending autoretrain explicitly drm/i915/dp_link_training: Add helper to query pending autoretrain drm/i915/dp_link_training: Add helper to query allowed autoretrain drm/i915/dp_link_training: Add helper to mark link training failure drm/i915/dp_link_training: Add helper to reset link recovery state drm/i915/dp_link_training: Track link recovery state with an enum drm/i915/dp_link_training: Add no-fallback link recovery state drm/i915/display: Factor out a helper to modeset a pipe with atomic
state
drm/i915/display: Simplify
intel_modeset_commit_pipes_for_atomic_state()
drm/i915/dp_link_training: Allocate atomic state for autoretrain
modeset
drm/i915/dp_link_training: Disallow autoretrains after failed modeset drm/i915/dp_link_training: Fix kernel-doc of
intel_dp_init_lttpr_and_dprx_caps()
drm/i915/dp_link_training: Document DP link recovery logic drm/i915/dp: Rename intel_dp_link_config to intel_dp_link_config_entry drm/i915/dp: Add struct intel_dp_link_config drm/i915/dp_link_caps: Introduce DP link capability module drm/i915/dp_link_caps: Move common rate helpers to link caps drm/i915/dp_link_caps: Move forced link param helpers to link caps drm/i915/dp: Simplify querying of forced link parameters drm/i915/dp_link_caps: Move forced and max link debugfs entries to
link caps
drm/i915/dp_link_training: Use helpers to get forced link params drm/i915/dp_link_caps: Move forced link params to link_caps drm/i915/dp_link_caps: Move link config helpers to link caps drm/i915/dp_link_caps: Move link config tracking to link_caps drm/i915/dp_link_caps: Rename helper updating the link configurations drm/i915/dp: Factor out helper to get link rate capabilities drm/i915/dp_link_caps: Pass supported link rates to link caps update drm/i915/dp_link_caps: Add helper to get all supported link rates drm/i915/dp_link_caps: Add helper to get the number of supported link
rates
drm/i915/dp_link_caps: Add helper to get common rate index drm/i915/dp_link_caps: Move tracking of common rates to link_caps
struct
drm/i915/dp_link_caps: Track max common lane count in link_caps drm/i915/dp_link_caps: Move max lane count change detection to
link_caps
drm/i915/dp_link_caps: Use max common lane count from link_caps drm/i915/dp_link_caps: Move updating max link limits to link_caps
update
drm/i915/dp_link_caps: Add helpers to get max link limits drm/i915/dp_link_caps: Add helpers to set max link limits drm/i915/dp_link_caps: Validate max link limits drm/i915/dp_link_caps: Add helper to reset max link limits drm/i915/dp_link_caps: Add helper to reset link_caps state drm/i915/dp_link_caps: Move max link limits to link_caps drm/i915/dp_link_caps: Pass link_caps to static functions drm/i915/dp_link_caps: Pass link_caps to config update/lookup helpers drm/i915/dp_link_caps: Pass link_caps to common rate helpers drm/i915/dp_link_caps: Add link_caps prefix to common rate helpers drm/i915/dp_link_caps: Add missing documentation to exported functions drm/i915/dp_link_caps: Set forced link params before resetting link
params
drm/i915/dp_link_caps: Adjust max_limits during link config update drm/i915/dp_link_caps: Adjust max_limits when setting or resetting it drm/i915/dp: Simplify the modeset max link rate limit computation drm/i915/dp: Query max limits via link_caps during mode validation drm/i915/dp_tunnel: Query max link limits via link_caps for BW
computation
drm/i915/doc: Document DP link capabilities drm/i915/dp_link_caps: Move config table members to a substruct drm/i915/dp_link_caps: Factor out a helper to look up a config table
rate
drm/i915/dp_link_caps: Pass config table pointer to rate lookup helper drm/i915/dp_link_caps: Factor out helper to get link config from table
by index
drm/i915/dp_link_caps: Add helper to get config at iterator position drm/i915/dp_link_caps: Add helper to find position of matching config drm/i915/dp_link_training: Reset the max link limits in the fallback
code
drm/i915/dp_link_training: Use config iterator for BW-order fallback drm/i915/dp_link_training: Look up configurations using fuzzy rate
matching
drm/i915/dp_link_caps: Pass table pointer to the sort compare function drm/i915/dp_link_caps: Compare config tables instead of link
parameters
drm/i915/dp_link_caps: Precompute config table before update drm/i915/dp_link_caps: Compare internal config entries during table
matching
drm/i915/dp_link_caps: Use virtual config indexing in config table drm/i915/dp_link_caps: Simplify idx->link rate/lane count lookup drm/i915/dp_link_caps: Simplify BW order pos->config index array drm/i915/dp_link_caps: Add helper to get iteration order for a
connector
drm/i915/dp_link_caps: Add reset and merge update modes drm/i915/dp_link_caps: Add mask for disabled link configurations drm/i915/dp_link_caps: Add link configuration iterators drm/i915/dp_link_caps: Preserve disabled config mask during merge
update
drm/i915/dp_link_caps: Account for disabled configs during max link
info update
drm/i915/dp_link_caps: Add debugfs entry showing allowed
configurations
drm/i915/dp: Add a mask of valid configurations for modeset
computation
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_test: Use link caps for compliance link configs drm/i915/dp: Remove min/max link config limits drm/i915/dp_link_training: Account for disabled configs during SST
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

 Documentation/gpu/i915.rst                    |   21 +
 drivers/gpu/drm/i915/.kunitconfig             |   12 +
 drivers/gpu/drm/i915/Kconfig.debug            |   12 +
 drivers/gpu/drm/i915/Makefile                 |    3 +
 drivers/gpu/drm/i915/display/g4x_dp.c         |   10 +-
 drivers/gpu/drm/i915/display/intel_ddi.c      |   18 +-
 drivers/gpu/drm/i915/display/intel_display.c  |   42 +-
 drivers/gpu/drm/i915/display/intel_display.h  |    3 +
 .../drm/i915/display/intel_display_debugfs.c  |    2 +
 .../drm/i915/display/intel_display_types.h    |   38 +-
 drivers/gpu/drm/i915/display/intel_dp.c       |  741 +++----
 drivers/gpu/drm/i915/display/intel_dp.h       |   22 +-
 .../gpu/drm/i915/display/intel_dp_link_caps.c | 1752 +++++++++++++++++
 .../gpu/drm/i915/display/intel_dp_link_caps.h |  262 +++
 .../drm/i915/display/intel_dp_link_training.c | 1257 +++++++++---
 .../drm/i915/display/intel_dp_link_training.h |   44 +
 drivers/gpu/drm/i915/display/intel_dp_mst.c   |   80 +-
 drivers/gpu/drm/i915/display/intel_dp_test.c  |   95 +-
 drivers/gpu/drm/i915/display/intel_dp_test.h  |    3 +-
 .../gpu/drm/i915/display/intel_dp_tunnel.c    |   14 +-
 drivers/gpu/drm/i915/display/tests/Makefile   |    7 +
 .../i915/display/tests/intel_dp_link_test.c   | 1427 ++++++++++++++
 drivers/gpu/drm/xe/.gitignore                 |    1 +
 drivers/gpu/drm/xe/.kunitconfig-display       |   11 +
 drivers/gpu/drm/xe/Makefile                   |    4 +
 drivers/gpu/drm/xe/display/tests/Makefile     |   11 +
 26 files changed, 5033 insertions(+), 859 deletions(-)
 create mode 100644 drivers/gpu/drm/i915/.kunitconfig
 create mode 100644 drivers/gpu/drm/i915/display/intel_dp_link_caps.c
 create mode 100644 drivers/gpu/drm/i915/display/intel_dp_link_caps.h
 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
author
#1 lore raw

PATCH 1/108 drm/i915/dp: Move clamping max link rate to common rates setup

Limit intel_dp->link.max_rate already in intel_dp_set_common_rates(), so it always gets updated alongside the common rates.

This prepares for detecting changes in the supported link capabilities (common rates, lane count, and max_rate) in follow-up changes in this patchset, allowing automatic link retraining to be re-enabled and the maximum link parameters to be updated after such capability changes.

During the first connector probing after a sink is connected, the common rates will be detected in intel_dp_set_common_rates() without intel_dp->link.max_rate being set (after driver loading) or reset (after the previous sink got disconnected) to the current sink's maximum supported rate. In those cases max_rate will be reset in intel_dp_reset_link_params() called after the common rates detection.

---
 drivers/gpu/drm/i915/display/intel_dp.c | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)
drivers/gpu/drm/i915/display/intel_dp.c +6 -5
index 8631df908b07f..c6a961d02a4bc 100644
@@ -790,6 +790,7 @@ int intel_dp_link_config_index(struct intel_dp *intel_dp, int link_rate, int lan
 static void intel_dp_set_common_rates(struct intel_dp *intel_dp)
 {
 	struct intel_display *display = to_intel_display(intel_dp);
+	int len;
 
 	drm_WARN_ON(display->drm,
 		    !intel_dp->num_source_rates || !intel_dp->num_sink_rates);
@@ -807,6 +808,10 @@ static void intel_dp_set_common_rates(struct intel_dp *intel_dp)
 	}
 
 	intel_dp_link_config_init(intel_dp);
+
+	len = intel_dp_common_len_rate_limit(intel_dp, intel_dp->link.max_rate);
+	if (len > 0)
+		intel_dp->link.max_rate = intel_dp_common_rate(intel_dp, len - 1);
 }
 
 bool intel_dp_link_params_valid(struct intel_dp *intel_dp, int link_rate,
@@ -1677,14 +1682,10 @@ static int forced_link_rate(struct intel_dp *intel_dp)
 int
 intel_dp_max_link_rate(struct intel_dp *intel_dp)
 {
-	int len;
-
 	if (intel_dp->link.force_rate)
 		return forced_link_rate(intel_dp);
 
-	len = intel_dp_common_len_rate_limit(intel_dp, intel_dp->link.max_rate);
-
-	return intel_dp_common_rate(intel_dp, len - 1);
+	return intel_dp->link.max_rate;
 }
 
 static int
Signature · 1 line
2.49.1
author
#2 lore raw

PATCH 2/108 drm/i915/dp: Clamp max lane count to max common lane count

In reply to Imre Deak

Clamp the maximum lane count after sink capability updates, matching the earlier max link rate clamping done when updating common rates.

This prepares for detecting supported link capability changes in one place in follow-up changes.

---
 drivers/gpu/drm/i915/display/intel_dp.c | 6 ++++++
 1 file changed, 6 insertions(+)
drivers/gpu/drm/i915/display/intel_dp.c +6 -0
index c6a961d02a4bc..cb81a9864d8c4 100644
@@ -4856,9 +4856,15 @@ intel_dp_has_sink_count(struct intel_dp *intel_dp)
 
 void intel_dp_update_sink_caps(struct intel_dp *intel_dp)
 {
+	int current_max_common_lane_count;
+
 	intel_dp_set_sink_rates(intel_dp);
 	intel_dp_set_max_sink_lane_count(intel_dp);
 	intel_dp_set_common_rates(intel_dp);
+
+	current_max_common_lane_count = intel_dp_max_common_lane_count(intel_dp);
+	intel_dp->link.max_lane_count = min(intel_dp->link.max_lane_count,
+					    current_max_common_lane_count);
 }
 
 static bool
Signature · 1 line
2.49.1
author
#3 lore raw

PATCH 3/108 drm/i915/dp: Bump connector epoch on link capability changes

In reply to Imre Deak

Bump the connector epoch when the common link capabilities change after the sink reports updated capabilities. This covers the common rates and the maximum common lane count, which are derived from the source and sink capabilities.

Also bump the epoch when the maximum link limits change. These limits are initialized from the common capabilities, but can later change due to either sink capability updates or fallback selection.

Follow-up changes move both the change detection and the updates to the maximum link limits, along with other derived maximum link information, into the link capability module, where dependencies among all these can ben handled consistently.

---
 drivers/gpu/drm/i915/display/intel_dp.c | 49 ++++++++++++++++++++++++-
 1 file changed, 47 insertions(+), 2 deletions(-)
drivers/gpu/drm/i915/display/intel_dp.c +47 -2
index cb81a9864d8c4..df34df6610ac2 100644
@@ -787,14 +787,37 @@ int intel_dp_link_config_index(struct intel_dp *intel_dp, int link_rate, int lan
 	return -1;
 }
 
-static void intel_dp_set_common_rates(struct intel_dp *intel_dp)
+static bool current_common_caps_match(struct intel_dp *intel_dp,
+				      const int *rates, int num_rates)
+{
+	const int *current_rates = intel_dp->common_rates;
+	int num_current_rates = intel_dp->num_common_rates;
+
+	if (num_current_rates != num_rates)
+		return false;
+
+	if (memcmp(current_rates, rates, num_rates * sizeof(rates[0])))
+		return false;
+
+	return true;
+}
+
+/* Return %true if any supported or maximum link param changed. */
+static bool intel_dp_set_common_rates(struct intel_dp *intel_dp)
 {
 	struct intel_display *display = to_intel_display(intel_dp);
+	int num_old_common_rates = intel_dp->num_common_rates;
+	int old_max_rate_limit = intel_dp->link.max_rate;
+	int old_common_rates[DP_MAX_SUPPORTED_RATES];
+	bool link_params_changed = false;
 	int len;
 
 	drm_WARN_ON(display->drm,
 		    !intel_dp->num_source_rates || !intel_dp->num_sink_rates);
 
+	static_assert(sizeof(old_common_rates) == sizeof(intel_dp->common_rates));
+	memcpy(old_common_rates, intel_dp->common_rates, sizeof(old_common_rates));
+
 	intel_dp->num_common_rates = intersect_rates(intel_dp->source_rates,
 						     intel_dp->num_source_rates,
 						     intel_dp->sink_rates,
@@ -807,11 +830,19 @@ static void intel_dp_set_common_rates(struct intel_dp *intel_dp)
 		intel_dp->num_common_rates = 1;
 	}
 
+	if (!current_common_caps_match(intel_dp, old_common_rates, num_old_common_rates))
+		link_params_changed = true;
+
 	intel_dp_link_config_init(intel_dp);
 
 	len = intel_dp_common_len_rate_limit(intel_dp, intel_dp->link.max_rate);
 	if (len > 0)
 		intel_dp->link.max_rate = intel_dp_common_rate(intel_dp, len - 1);
+
+	if (intel_dp->link.max_rate != old_max_rate_limit)
+		link_params_changed = true;
+
+	return link_params_changed;
 }
 
 bool intel_dp_link_params_valid(struct intel_dp *intel_dp, int link_rate,
@@ -4856,15 +4887,29 @@ intel_dp_has_sink_count(struct intel_dp *intel_dp)
 
 void intel_dp_update_sink_caps(struct intel_dp *intel_dp)
 {
+	struct intel_connector *connector = intel_dp->attached_connector;
+	int old_max_common_lane_count = intel_dp_max_common_lane_count(intel_dp);
+	int old_max_lane_count_limit = intel_dp->link.max_lane_count;
 	int current_max_common_lane_count;
+	bool link_params_changed = false;
 
 	intel_dp_set_sink_rates(intel_dp);
 	intel_dp_set_max_sink_lane_count(intel_dp);
-	intel_dp_set_common_rates(intel_dp);
+	if (intel_dp_set_common_rates(intel_dp))
+		link_params_changed = true;
 
 	current_max_common_lane_count = intel_dp_max_common_lane_count(intel_dp);
+	if (current_max_common_lane_count != old_max_common_lane_count)
+		link_params_changed = true;
+
 	intel_dp->link.max_lane_count = min(intel_dp->link.max_lane_count,
 					    current_max_common_lane_count);
+
+	if (intel_dp->link.max_lane_count != old_max_lane_count_limit)
+		link_params_changed = true;
+
+	if (link_params_changed)
+		connector->base.epoch_counter++;
 }
 
 static bool
Signature · 1 line
2.49.1
author
#4 lore raw

PATCH 4/108 drm/i915/dp_link_training: Introduce link training state struct

In reply to Imre Deak

Start isolating the link training state from the generic DP code by introducing a separate intel_dp_link_training state struct.

Allocate the state so it can remain opaque within its own module.

Follow-up changes will move link training fields from the DP struct to the link training state.

---
 drivers/gpu/drm/i915/display/g4x_dp.c         | 10 ++++-
 drivers/gpu/drm/i915/display/intel_ddi.c      | 18 ++++++++-
 .../drm/i915/display/intel_display_types.h    |  2 +
 drivers/gpu/drm/i915/display/intel_dp.c       | 31 +++++++++++++++
 drivers/gpu/drm/i915/display/intel_dp.h       |  3 ++
 .../drm/i915/display/intel_dp_link_training.c | 39 +++++++++++++++++++
 .../drm/i915/display/intel_dp_link_training.h |  4 ++
 7 files changed, 104 insertions(+), 3 deletions(-)
drivers/gpu/drm/i915/display/g4x_dp.c +9 -1
index 5e74d8a3ba5c8..e1698172a8163 100644
@@ -1252,10 +1252,13 @@ static void g4x_dp_suspend_complete(struct intel_encoder *encoder)
 
 static void intel_dp_encoder_destroy(struct drm_encoder *encoder)
 {
+	struct intel_digital_port *dig_port = enc_to_dig_port(to_intel_encoder(encoder));
+
 	intel_dp_encoder_flush_work(encoder);
 
 	drm_encoder_cleanup(encoder);
-	kfree(enc_to_dig_port(to_intel_encoder(encoder)));
+	intel_dp_link_cleanup(&dig_port->dp);
+	kfree(dig_port);
 }
 
 static void intel_dp_encoder_reset(struct drm_encoder *encoder)
@@ -1350,6 +1353,9 @@ bool g4x_dp_init(struct intel_display *display,
 	intel_encoder->audio_enable = g4x_dp_audio_enable;
 	intel_encoder->audio_disable = g4x_dp_audio_disable;
 
+	if (intel_dp_link_init(&dig_port->dp) != 0)
+		goto err_dp_init;
+
 	if ((display->platform.ivybridge && port == PORT_A) ||
 	    (HAS_PCH_CPT(display) && port != PORT_A)) {
 		dig_port->dp.set_link_train = cpt_set_link_train;
@@ -1419,6 +1425,8 @@ bool g4x_dp_init(struct intel_display *display,
 	return true;
 
 err_init_connector:
+	intel_dp_link_cleanup(&dig_port->dp);
+err_dp_init:
 	drm_encoder_cleanup(encoder);
 err_encoder_init:
 	kfree(intel_connector);
drivers/gpu/drm/i915/display/intel_ddi.c +16 -2
index 2681940a5cfe3..f094830d34b92 100644
@@ -4656,6 +4656,7 @@ static void intel_ddi_encoder_destroy(struct drm_encoder *encoder)
 
 	drm_encoder_cleanup(encoder);
 	kfree(dig_port->hdcp.port_data.streams);
+	intel_dp_link_cleanup(&dig_port->dp);
 	kfree(dig_port);
 }
 
@@ -4693,11 +4694,16 @@ static int intel_ddi_init_dp_connector(struct intel_digital_port *dig_port)
 	struct intel_display *display = to_intel_display(dig_port);
 	struct intel_connector *connector;
 	enum port port = dig_port->base.port;
+	int err;
 
 	connector = intel_connector_alloc();
 	if (!connector)
 		return -ENOMEM;
 
+	err = intel_dp_link_init(&dig_port->dp);
+	if (err)
+		goto err_dp_init;
+
 	dig_port->dp.output_reg = DDI_BUF_CTL(port);
 	if (DISPLAY_VER(display) >= 14)
 		dig_port->dp.prepare_link_retrain = mtl_ddi_prepare_link_retrain;
@@ -4710,8 +4716,9 @@ static int intel_ddi_init_dp_connector(struct intel_digital_port *dig_port)
 	dig_port->dp.preemph_max = intel_ddi_dp_preemph_max;
 
 	if (!intel_dp_init_connector(dig_port, connector)) {
-		kfree(connector);
-		return -EINVAL;
+		err = -EINVAL;
+
+		goto err_init_connector;
 	}
 
 	if (dig_port->base.type == INTEL_OUTPUT_EDP) {
@@ -4727,6 +4734,13 @@ static int intel_ddi_init_dp_connector(struct intel_digital_port *dig_port)
 	}
 
 	return 0;
+
+err_init_connector:
+	intel_dp_link_cleanup(&dig_port->dp);
+err_dp_init:
+	kfree(connector);
+
+	return err;
 }
 
 static int intel_hdmi_reset_link(struct intel_encoder *encoder,
drivers/gpu/drm/i915/display/intel_display_types.h +2 -0
index c819167618502..27714e4cffcdf 100644
@@ -58,6 +58,7 @@ struct cec_notifier;
 struct drm_printer;
 struct intel_connector;
 struct intel_ddi_buf_trans;
+struct intel_dp_link_training;
 struct intel_fbc;
 struct intel_global_objs_state;
 struct intel_hdcp_shim;
@@ -1853,6 +1854,7 @@ struct intel_dp {
 		int seq_train_failures;
 		int force_train_failure;
 		bool force_retrain;
+		struct intel_dp_link_training *training;
 	} link;
 	bool reset_link_params;
 	int mso_link_count;
drivers/gpu/drm/i915/display/intel_dp.c +31 -0
index df34df6610ac2..442610054d7f7 100644
@@ -7526,3 +7526,34 @@ bool intel_dp_joiner_candidate_valid(struct intel_connector *connector,
 
 	return true;
 }
+
+/**
+ * intel_dp_link_init - initialize link state
+ * @intel_dp: DP encoder state
+ *
+ * Initialize the link state for @intel_dp and the connectors attached
+ * to it.
+ *
+ * Return:
+ * - %0 in case of successful initialization.
+ * - negative error code in case of failure.
+ */
+int intel_dp_link_init(struct intel_dp *intel_dp)
+{
+	intel_dp->link.training = intel_dp_link_training_init(intel_dp);
+	if (!intel_dp->link.training)
+		return -ENOMEM;
+
+	return 0;
+}
+
+/**
+ * intel_dp_link_cleanup - clean up link state
+ * @intel_dp: DP encoder state
+ *
+ * Clean up the link state for @intel_dp.
+ */
+void intel_dp_link_cleanup(struct intel_dp *intel_dp)
+{
+	intel_dp_link_training_cleanup(intel_dp->link.training);
+}
drivers/gpu/drm/i915/display/intel_dp.h +3 -0
index 2849b9ecdc71a..f2abd6059a22a 100644
@@ -238,4 +238,7 @@ bool intel_dp_joiner_candidate_valid(struct intel_connector *connector,
 	for ((__num_joined_pipes) = 1; (__num_joined_pipes) <= (I915_MAX_PIPES); (__num_joined_pipes)++) \
 		for_each_if(intel_dp_joiner_candidate_valid(__connector, (__mode)->hdisplay, __num_joined_pipes))
 
+int intel_dp_link_init(struct intel_dp *intel_dp);
+void intel_dp_link_cleanup(struct intel_dp *intel_dp);
+
 #endif /* __INTEL_DP_H__ */
drivers/gpu/drm/i915/display/intel_dp_link_training.c +39 -0
index a26094223f780..c4e461d24e2ed 100644
@@ -60,6 +60,10 @@
 
 #define MAX_SEQ_TRAIN_FAILURES 2
 
+struct intel_dp_link_training {
+	struct intel_dp *dp;
+};
+
 static void intel_dp_reset_lttpr_common_caps(struct intel_dp *intel_dp)
 {
 	memset(intel_dp->lttpr_common_caps, 0, sizeof(intel_dp->lttpr_common_caps));
@@ -2217,3 +2221,38 @@ void intel_dp_link_training_debugfs_add(struct intel_connector *connector)
 	debugfs_create_file("i915_dp_link_retrain_disabled", 0444, root,
 			    connector, &i915_dp_link_retrain_disabled_fops);
 }
+
+/**
+ * intel_dp_link_training_init - allocate and initialize link training state
+ * @intel_dp: DP encoder state
+ *
+ * Allocate and initialize the link training state for @intel_dp and the
+ * connectors attached to it.
+ *
+ * Return:
+ * - Pointer to the newly allocated link training state.
+ * - %NULL if allocation fails.
+ */
+struct intel_dp_link_training *intel_dp_link_training_init(struct intel_dp *intel_dp)
+{
+	struct intel_dp_link_training *link_training;
+
+	link_training = kzalloc_obj(*link_training);
+	if (!link_training)
+		return NULL;
+
+	link_training->dp = intel_dp;
+
+	return link_training;
+}
+
+/**
+ * intel_dp_link_training_cleanup - free link training state
+ * @link_training: link training state to free
+ *
+ * Free @link_training.
+ */
+void intel_dp_link_training_cleanup(struct intel_dp_link_training *link_training)
+{
+	kfree(link_training);
+}
drivers/gpu/drm/i915/display/intel_dp_link_training.h +4 -0
index 33dcbde6a4089..e68d51bcb42e1 100644
@@ -12,6 +12,7 @@ struct intel_atomic_state;
 struct intel_connector;
 struct intel_crtc_state;
 struct intel_dp;
+struct intel_dp_link_training;
 
 int intel_dp_read_dprx_caps(struct intel_dp *intel_dp, u8 dpcd[DP_RECEIVER_CAP_SIZE]);
 int intel_dp_init_lttpr_and_dprx_caps(struct intel_dp *intel_dp);
@@ -55,4 +56,7 @@ void intel_dp_128b132b_sdp_crc16(struct intel_dp *intel_dp,
 
 void intel_dp_link_training_debugfs_add(struct intel_connector *connector);
 
+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);
+
 #endif /* __INTEL_DP_LINK_TRAINING_H__ */
Signature · 1 line
2.49.1
author
#5 lore raw

PATCH 5/108 drm/i915/dp_link_training: Factor out link training state reset helper

In reply to Imre Deak

Factor out the link training state reset into a helper in intel_dp_link_training.c to prepare for isolating the link training state from the generic DP code.

---
 drivers/gpu/drm/i915/display/intel_dp.c               | 3 +--
 drivers/gpu/drm/i915/display/intel_dp_link_training.c | 8 ++++++++
 drivers/gpu/drm/i915/display/intel_dp_link_training.h | 2 ++
 3 files changed, 11 insertions(+), 2 deletions(-)
drivers/gpu/drm/i915/display/intel_dp.c +1 -2
index 442610054d7f7..ef7d5e55cc468 100644
@@ -3728,8 +3728,7 @@ void intel_dp_reset_link_params(struct intel_dp *intel_dp)
 	intel_dp->link.max_rate = intel_dp_max_common_rate(intel_dp);
 	intel_dp->link.mst_probed_lane_count = 0;
 	intel_dp->link.mst_probed_rate = 0;
-	intel_dp->link.retrain_disabled = false;
-	intel_dp->link.seq_train_failures = 0;
+	intel_dp_link_training_reset(intel_dp->link.training);
 }
 
 /* Enable backlight PWM and backlight PP control. */
drivers/gpu/drm/i915/display/intel_dp_link_training.c +8 -0
index c4e461d24e2ed..653b974e925c2 100644
@@ -2222,6 +2222,14 @@ void intel_dp_link_training_debugfs_add(struct intel_connector *connector)
 			    connector, &i915_dp_link_retrain_disabled_fops);
 }
 
+void intel_dp_link_training_reset(struct intel_dp_link_training *link_training)
+{
+	struct intel_dp *intel_dp = link_training->dp;
+
+	intel_dp->link.retrain_disabled = false;
+	intel_dp->link.seq_train_failures = 0;
+}
+
 /**
  * intel_dp_link_training_init - allocate and initialize link training state
  * @intel_dp: DP encoder state
drivers/gpu/drm/i915/display/intel_dp_link_training.h +2 -0
index e68d51bcb42e1..6c0c74e31a3c5 100644
@@ -56,6 +56,8 @@ void intel_dp_128b132b_sdp_crc16(struct intel_dp *intel_dp,
 
 void intel_dp_link_training_debugfs_add(struct intel_connector *connector);
 
+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);
 
Signature · 1 line
2.49.1
author
#6 lore raw

PATCH 6/108 drm/i915/dp_link_training: Reset link training state on link capability change

In reply to Imre Deak

Reset the link training state if the link capabilities change. This re-enables automatic link retraining after it was disabled following link training failures when fallback left no usable configuration. The capability changes may enable a valid configuration, allowing retraining.

Also update the connector detect handler comment to note that link state recheck may be needed due to re-enabled autoretraining.

---
 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
index ef7d5e55cc468..d7c8ace38a01c 100644
@@ -6439,6 +6439,8 @@ intel_dp_detect(struct drm_connector *_connector,
 	struct intel_digital_port *dig_port = dp_to_dig_port(intel_dp);
 	struct intel_encoder *encoder = &dig_port->base;
 	enum drm_connector_status status;
+	int old_epoch_counter =
+		connector->base.epoch_counter;
 	int ret;
 
 	drm_dbg_kms(display->drm, "[CONNECTOR:%d:%s]\n",
@@ -6522,6 +6524,8 @@ intel_dp_detect(struct drm_connector *_connector,
 	if (intel_dp->reset_link_params) {
 		intel_dp_reset_link_params(intel_dp);
 		intel_dp->reset_link_params = false;
+	} else if (connector->base.epoch_counter != old_epoch_counter) {
+		intel_dp_link_training_reset(intel_dp->link.training);
 	}
 
 	intel_dp_mst_configure(intel_dp);
@@ -6542,9 +6546,16 @@ intel_dp_detect(struct drm_connector *_connector,
 	 * Some external monitors do not signal loss of link synchronization
 	 * with an IRQ_HPD, so force a link status check.
 	 *
-	 * TODO: this probably became redundant, so remove it: the link state
-	 * is rechecked/recovered now after modesets, where the loss of
-	 * synchronization tends to occur.
+	 * NOTE: Handling link synchronization loss here is probably not
+	 * needed, since such loss tends to occur right after modesets, and
+	 * modesets already schedule a work item to recheck the link state.
+	 *
+	 * However, if the link is in an active unretrainable state and the
+	 * supported link configurations changed, either after an HPD
+	 * pulse-triggered link reset (via intel_dp_reset_link_params()) or
+	 * after a sink capability update without such a reset (via
+	 * intel_dp_set_common_rates()), the link state should be rechecked in
+	 * case the link became retrainable.
 	 */
 	if (!intel_dp_is_edp(intel_dp))
 		intel_dp_check_link_state(intel_dp);
Signature · 1 line
2.49.1
author
#7 lore raw

PATCH 7/108 drm/i915/dp_link_training: Flush commits in debugfs entries

In reply to Imre Deak

Flush pending connector commits before accessing the link training state from debugfs. Access to connector state - like the link training state - that may be updated from an asynchronous commit tail must hold the connection mutex and wait for the tail to complete. The commit tail cannot hold the connection mutex, so all other accessors must wait for it explicitly.

---
 .../drm/i915/display/intel_dp_link_training.c | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
drivers/gpu/drm/i915/display/intel_dp_link_training.c +23 -0
index 653b974e925c2..6dfb6b8db235e 100644
@@ -1866,8 +1866,11 @@ static int i915_dp_force_link_rate_show(struct seq_file *m, void *data)
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	if (intel_dp->link.active)
 		current_rate = intel_dp->link_rate;
+
 	force_rate = intel_dp->link.force_rate;
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
@@ -1939,6 +1942,8 @@ static ssize_t i915_dp_force_link_rate_write(struct file *file,
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	intel_dp_reset_link_params(intel_dp);
 	intel_dp->link.force_rate = rate;
 
@@ -1964,6 +1969,8 @@ static int i915_dp_force_lane_count_show(struct seq_file *m, void *data)
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	if (intel_dp->link.active)
 		current_lane_count = intel_dp->lane_count;
 	force_lane_count = intel_dp->link.force_lane_count;
@@ -2041,6 +2048,8 @@ static ssize_t i915_dp_force_lane_count_write(struct file *file,
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	intel_dp_reset_link_params(intel_dp);
 	intel_dp->link.force_lane_count = lane_count;
 
@@ -2063,6 +2072,8 @@ static int i915_dp_max_link_rate_show(void *data, u64 *val)
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	*val = intel_dp->link.max_rate;
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
@@ -2082,6 +2093,8 @@ static int i915_dp_max_lane_count_show(void *data, u64 *val)
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	*val = intel_dp->link.max_lane_count;
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
@@ -2101,6 +2114,8 @@ static int i915_dp_force_link_training_failure_show(void *data, u64 *val)
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	*val = intel_dp->link.force_train_failure;
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
@@ -2122,6 +2137,8 @@ static int i915_dp_force_link_training_failure_write(void *data, u64 val)
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	intel_dp->link.force_train_failure = val;
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
@@ -2143,6 +2160,8 @@ static int i915_dp_force_link_retrain_show(void *data, u64 *val)
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	*val = intel_dp->link.force_retrain;
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
@@ -2161,6 +2180,8 @@ static int i915_dp_force_link_retrain_write(void *data, u64 val)
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	intel_dp->link.force_retrain = val;
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
@@ -2184,6 +2205,8 @@ static int i915_dp_link_retrain_disabled_show(struct seq_file *m, void *data)
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	seq_printf(m, "%s\n", str_yes_no(intel_dp->link.retrain_disabled));
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
Signature · 1 line
2.49.1
maintainer
#8 lore raw

Re: [PATCH 007/108] drm/i915/dp_link_training: Flush commits in debugfs entries

Quoted 17 lines · Imre Deak

Flush pending connector commits before accessing the link training state from debugfs. Access to connector state - like the link training state - that may be updated from an asynchronous commit tail must hold the connection mutex and wait for the tail to complete. The commit tail cannot hold the connection mutex, so all other accessors must wait for it explicitly.

---
 .../drm/i915/display/intel_dp_link_training.c | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
drivers/gpu/drm/i915/display/intel_dp_link_training.c +0 -0
index 653b974e925c2..6dfb6b8db235e 100644

drivers/gpu/drm/i915/display/intel_dp_link_training.c static int i915_dp_force_link_rate_show(struct seq_file *m, void *data) · line 1869

Quoted 4 lines
drivers/gpu/drm/i915/display/intel_dp_link_training.c +1 -0
@@ -1866,8 +1866,11 @@ static int i915_dp_force_link_rate_show(struct seq_file *m, void *data)
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);

Not part of this patch, but I have a hard time making the connection from "flush connector commits" to "wait for completion timeout on hw_done".

What this patch does is add that "flush" all over the place, making it even harder to make the connection.

It's not helping that struct drm_crtc_helper_funcs has ->atomic_flush hook, which i915 does not use.

Maybe what I'm saying is I'm stupid and don't understand what flush means here.

BR,
Jani.

Quoted 97 lines
drivers/gpu/drm/i915/display/intel_dp_link_training.c +22 -0
+
 	if (intel_dp->link.active)
 		current_rate = intel_dp->link_rate;
+
 	force_rate = intel_dp->link.force_rate;
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
@@ -1939,6 +1942,8 @@ static ssize_t i915_dp_force_link_rate_write(struct file *file,
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	intel_dp_reset_link_params(intel_dp);
 	intel_dp->link.force_rate = rate;
 
@@ -1964,6 +1969,8 @@ static int i915_dp_force_lane_count_show(struct seq_file *m, void *data)
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	if (intel_dp->link.active)
 		current_lane_count = intel_dp->lane_count;
 	force_lane_count = intel_dp->link.force_lane_count;
@@ -2041,6 +2048,8 @@ static ssize_t i915_dp_force_lane_count_write(struct file *file,
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	intel_dp_reset_link_params(intel_dp);
 	intel_dp->link.force_lane_count = lane_count;
 
@@ -2063,6 +2072,8 @@ static int i915_dp_max_link_rate_show(void *data, u64 *val)
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	*val = intel_dp->link.max_rate;
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
@@ -2082,6 +2093,8 @@ static int i915_dp_max_lane_count_show(void *data, u64 *val)
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	*val = intel_dp->link.max_lane_count;
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
@@ -2101,6 +2114,8 @@ static int i915_dp_force_link_training_failure_show(void *data, u64 *val)
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	*val = intel_dp->link.force_train_failure;
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
@@ -2122,6 +2137,8 @@ static int i915_dp_force_link_training_failure_write(void *data, u64 val)
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	intel_dp->link.force_train_failure = val;
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
@@ -2143,6 +2160,8 @@ static int i915_dp_force_link_retrain_show(void *data, u64 *val)
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	*val = intel_dp->link.force_retrain;
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
@@ -2161,6 +2180,8 @@ static int i915_dp_force_link_retrain_write(void *data, u64 val)
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	intel_dp->link.force_retrain = val;
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
@@ -2184,6 +2205,8 @@ static int i915_dp_link_retrain_disabled_show(struct seq_file *m, void *data)
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	seq_printf(m, "%s\n", str_yes_no(intel_dp->link.retrain_disabled));
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
Signature · 1 line
Jani Nikula, Intel
author
#9 lore raw

Re: [PATCH 007/108] drm/i915/dp_link_training: Flush commits in debugfs entries

Quoted 27 lines · Jani Nikula
Quoted 17 lines · Imre Deak

Flush pending connector commits before accessing the link training state from debugfs. Access to connector state - like the link training state - that may be updated from an asynchronous commit tail must hold the connection mutex and wait for the tail to complete. The commit tail cannot hold the connection mutex, so all other accessors must wait for it explicitly.

---
 .../drm/i915/display/intel_dp_link_training.c | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
drivers/gpu/drm/i915/display/intel_dp_link_training.c +0 -0
index 653b974e925c2..6dfb6b8db235e 100644

drivers/gpu/drm/i915/display/intel_dp_link_training.c static int i915_dp_force_link_rate_show(struct seq_file *m, void *data) · line 1869

Quoted 4 lines
drivers/gpu/drm/i915/display/intel_dp_link_training.c +1 -0
@@ -1866,8 +1866,11 @@ static int i915_dp_force_link_rate_show(struct seq_file *m, void *data)
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);

Not part of this patch, but I have a hard time making the connection from "flush connector commits" to "wait for completion timeout on hw_done".

Quoted 8 lines

What this patch does is add that "flush" all over the place, making it even harder to make the connection.

It's not helping that struct drm_crtc_helper_funcs has ->atomic_flush hook, which i915 does not use.

Maybe what I'm saying is I'm stupid and don't understand what flush means here.

The commit message tries to explain that, probably it'd be better to document this as well as the generic way to serialize some state being accessed against an asynchronous atomic commit: the tail of such asynchronous commits cannot take WW locks - which are generally used to protect the state of a DRM object. Here that state is the link training state of an encoder object. Since the async commit's tail cannot itself take locks, the way to ensure the exclusive access to the state is:

- In contexts other than the async commit's tail itself 1) take locks used in all other contexts to guard the state (mode_config.connection_mutex here). 2) with the lock held wait for the completion of any pending asynchronous commits (which also waits for the completion for the asyncrhonous commit's tail).
- In the async commit tail, the state can be access without taking locks or doing any other serialization, since all other accessors of the state will wait for the commit tail.

Flush means waiting for the asynchronous commits to complete based on the above.

Quoted 104 lines

BR,
Jani.

Quoted 97 lines
drivers/gpu/drm/i915/display/intel_dp_link_training.c +22 -0
+
 	if (intel_dp->link.active)
 		current_rate = intel_dp->link_rate;
+
 	force_rate = intel_dp->link.force_rate;
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
@@ -1939,6 +1942,8 @@ static ssize_t i915_dp_force_link_rate_write(struct file *file,
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	intel_dp_reset_link_params(intel_dp);
 	intel_dp->link.force_rate = rate;
 
@@ -1964,6 +1969,8 @@ static int i915_dp_force_lane_count_show(struct seq_file *m, void *data)
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	if (intel_dp->link.active)
 		current_lane_count = intel_dp->lane_count;
 	force_lane_count = intel_dp->link.force_lane_count;
@@ -2041,6 +2048,8 @@ static ssize_t i915_dp_force_lane_count_write(struct file *file,
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	intel_dp_reset_link_params(intel_dp);
 	intel_dp->link.force_lane_count = lane_count;
 
@@ -2063,6 +2072,8 @@ static int i915_dp_max_link_rate_show(void *data, u64 *val)
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	*val = intel_dp->link.max_rate;
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
@@ -2082,6 +2093,8 @@ static int i915_dp_max_lane_count_show(void *data, u64 *val)
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	*val = intel_dp->link.max_lane_count;
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
@@ -2101,6 +2114,8 @@ static int i915_dp_force_link_training_failure_show(void *data, u64 *val)
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	*val = intel_dp->link.force_train_failure;
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
@@ -2122,6 +2137,8 @@ static int i915_dp_force_link_training_failure_write(void *data, u64 val)
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	intel_dp->link.force_train_failure = val;
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
@@ -2143,6 +2160,8 @@ static int i915_dp_force_link_retrain_show(void *data, u64 *val)
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	*val = intel_dp->link.force_retrain;
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
@@ -2161,6 +2180,8 @@ static int i915_dp_force_link_retrain_write(void *data, u64 val)
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	intel_dp->link.force_retrain = val;
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
@@ -2184,6 +2205,8 @@ static int i915_dp_link_retrain_disabled_show(struct seq_file *m, void *data)
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	seq_printf(m, "%s\n", str_yes_no(intel_dp->link.retrain_disabled));
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
Signature · 1 line
Jani Nikula, Intel
maintainer
#10 lore raw

Re: [PATCH 007/108] drm/i915/dp_link_training: Flush commits in debugfs entries

Quoted 54 lines · Imre Deak
Quoted 27 lines · Jani Nikula
Quoted 17 lines · Imre Deak

Flush pending connector commits before accessing the link training state from debugfs. Access to connector state - like the link training state - that may be updated from an asynchronous commit tail must hold the connection mutex and wait for the tail to complete. The commit tail cannot hold the connection mutex, so all other accessors must wait for it explicitly.

---
 .../drm/i915/display/intel_dp_link_training.c | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
drivers/gpu/drm/i915/display/intel_dp_link_training.c +0 -0
index 653b974e925c2..6dfb6b8db235e 100644

drivers/gpu/drm/i915/display/intel_dp_link_training.c static int i915_dp_force_link_rate_show(struct seq_file *m, void *data) · line 1869

Quoted 4 lines
drivers/gpu/drm/i915/display/intel_dp_link_training.c +1 -0
@@ -1866,8 +1866,11 @@ static int i915_dp_force_link_rate_show(struct seq_file *m, void *data)
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);

Not part of this patch, but I have a hard time making the connection from "flush connector commits" to "wait for completion timeout on hw_done".

Quoted 8 lines

What this patch does is add that "flush" all over the place, making it even harder to make the connection.

It's not helping that struct drm_crtc_helper_funcs has ->atomic_flush hook, which i915 does not use.

Maybe what I'm saying is I'm stupid and don't understand what flush means here.

The commit message tries to explain that, probably it'd be better to document this as well as the generic way to serialize some state being accessed against an asynchronous atomic commit: the tail of such asynchronous commits cannot take WW locks - which are generally used to protect the state of a DRM object. Here that state is the link training state of an encoder object. Since the async commit's tail cannot itself take locks, the way to ensure the exclusive access to the state is:

- In contexts other than the async commit's tail itself 1) take locks used in all other contexts to guard the state (mode_config.connection_mutex here). 2) with the lock held wait for the completion of any pending asynchronous commits (which also waits for the completion for the asyncrhonous commit's tail).
- In the async commit tail, the state can be access without taking locks or doing any other serialization, since all other accessors of the state will wait for the commit tail.

Quoted 2 lines

Flush means waiting for the asynchronous commits to complete based on the above.

Maybe the function should be named accordingly...?

BR,
Jani.

Quoted 105 lines
Quoted 105 lines

BR,
Jani.

Quoted 97 lines
drivers/gpu/drm/i915/display/intel_dp_link_training.c +22 -0
+
 	if (intel_dp->link.active)
 		current_rate = intel_dp->link_rate;
+
 	force_rate = intel_dp->link.force_rate;
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
@@ -1939,6 +1942,8 @@ static ssize_t i915_dp_force_link_rate_write(struct file *file,
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	intel_dp_reset_link_params(intel_dp);
 	intel_dp->link.force_rate = rate;
 
@@ -1964,6 +1969,8 @@ static int i915_dp_force_lane_count_show(struct seq_file *m, void *data)
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	if (intel_dp->link.active)
 		current_lane_count = intel_dp->lane_count;
 	force_lane_count = intel_dp->link.force_lane_count;
@@ -2041,6 +2048,8 @@ static ssize_t i915_dp_force_lane_count_write(struct file *file,
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	intel_dp_reset_link_params(intel_dp);
 	intel_dp->link.force_lane_count = lane_count;
 
@@ -2063,6 +2072,8 @@ static int i915_dp_max_link_rate_show(void *data, u64 *val)
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	*val = intel_dp->link.max_rate;
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
@@ -2082,6 +2093,8 @@ static int i915_dp_max_lane_count_show(void *data, u64 *val)
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	*val = intel_dp->link.max_lane_count;
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
@@ -2101,6 +2114,8 @@ static int i915_dp_force_link_training_failure_show(void *data, u64 *val)
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	*val = intel_dp->link.force_train_failure;
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
@@ -2122,6 +2137,8 @@ static int i915_dp_force_link_training_failure_write(void *data, u64 val)
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	intel_dp->link.force_train_failure = val;
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
@@ -2143,6 +2160,8 @@ static int i915_dp_force_link_retrain_show(void *data, u64 *val)
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	*val = intel_dp->link.force_retrain;
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
@@ -2161,6 +2180,8 @@ static int i915_dp_force_link_retrain_write(void *data, u64 val)
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	intel_dp->link.force_retrain = val;
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
@@ -2184,6 +2205,8 @@ static int i915_dp_link_retrain_disabled_show(struct seq_file *m, void *data)
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	seq_printf(m, "%s\n", str_yes_no(intel_dp->link.retrain_disabled));
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
Signature · 1 line
Jani Nikula, Intel
Signature · 1 line
Jani Nikula, Intel
author
#11 lore raw

Re: [PATCH 007/108] drm/i915/dp_link_training: Flush commits in debugfs entries

Quoted 55 lines · Jani Nikula
Quoted 54 lines · Imre Deak
Quoted 27 lines · Jani Nikula
Quoted 17 lines · Imre Deak

Flush pending connector commits before accessing the link training state from debugfs. Access to connector state - like the link training state - that may be updated from an asynchronous commit tail must hold the connection mutex and wait for the tail to complete. The commit tail cannot hold the connection mutex, so all other accessors must wait for it explicitly.

---
 .../drm/i915/display/intel_dp_link_training.c | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
drivers/gpu/drm/i915/display/intel_dp_link_training.c +0 -0
index 653b974e925c2..6dfb6b8db235e 100644

drivers/gpu/drm/i915/display/intel_dp_link_training.c static int i915_dp_force_link_rate_show(struct seq_file *m, void *data) · line 1869

Quoted 4 lines
drivers/gpu/drm/i915/display/intel_dp_link_training.c +1 -0
@@ -1866,8 +1866,11 @@ static int i915_dp_force_link_rate_show(struct seq_file *m, void *data)
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);

Not part of this patch, but I have a hard time making the connection from "flush connector commits" to "wait for completion timeout on hw_done".

Quoted 8 lines

What this patch does is add that "flush" all over the place, making it even harder to make the connection.

It's not helping that struct drm_crtc_helper_funcs has ->atomic_flush hook, which i915 does not use.

Maybe what I'm saying is I'm stupid and don't understand what flush means here.

The commit message tries to explain that, probably it'd be better to document this as well as the generic way to serialize some state being accessed against an asynchronous atomic commit: the tail of such asynchronous commits cannot take WW locks - which are generally used to protect the state of a DRM object. Here that state is the link training state of an encoder object. Since the async commit's tail cannot itself take locks, the way to ensure the exclusive access to the state is:

- In contexts other than the async commit's tail itself 1) take locks used in all other contexts to guard the state (mode_config.connection_mutex here). 2) with the lock held wait for the completion of any pending asynchronous commits (which also waits for the completion for the asyncrhonous commit's tail).
- In the async commit tail, the state can be access without taking locks or doing any other serialization, since all other accessors of the state will wait for the commit tail.

Quoted 4 lines
Quoted 2 lines

Flush means waiting for the asynchronous commits to complete based on the above.

Maybe the function should be named accordingly...?

Ok, can think of a better for intel_dp_flush_connector_commits(), but since this function is used already, the rename could be done as a follow-up to this patchset.

Quoted 113 lines

BR,
Jani.

Quoted 105 lines
Quoted 105 lines

BR,
Jani.

Quoted 97 lines
drivers/gpu/drm/i915/display/intel_dp_link_training.c +22 -0
+
 	if (intel_dp->link.active)
 		current_rate = intel_dp->link_rate;
+
 	force_rate = intel_dp->link.force_rate;
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
@@ -1939,6 +1942,8 @@ static ssize_t i915_dp_force_link_rate_write(struct file *file,
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	intel_dp_reset_link_params(intel_dp);
 	intel_dp->link.force_rate = rate;
 
@@ -1964,6 +1969,8 @@ static int i915_dp_force_lane_count_show(struct seq_file *m, void *data)
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	if (intel_dp->link.active)
 		current_lane_count = intel_dp->lane_count;
 	force_lane_count = intel_dp->link.force_lane_count;
@@ -2041,6 +2048,8 @@ static ssize_t i915_dp_force_lane_count_write(struct file *file,
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	intel_dp_reset_link_params(intel_dp);
 	intel_dp->link.force_lane_count = lane_count;
 
@@ -2063,6 +2072,8 @@ static int i915_dp_max_link_rate_show(void *data, u64 *val)
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	*val = intel_dp->link.max_rate;
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
@@ -2082,6 +2093,8 @@ static int i915_dp_max_lane_count_show(void *data, u64 *val)
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	*val = intel_dp->link.max_lane_count;
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
@@ -2101,6 +2114,8 @@ static int i915_dp_force_link_training_failure_show(void *data, u64 *val)
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	*val = intel_dp->link.force_train_failure;
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
@@ -2122,6 +2137,8 @@ static int i915_dp_force_link_training_failure_write(void *data, u64 val)
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	intel_dp->link.force_train_failure = val;
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
@@ -2143,6 +2160,8 @@ static int i915_dp_force_link_retrain_show(void *data, u64 *val)
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	*val = intel_dp->link.force_retrain;
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
@@ -2161,6 +2180,8 @@ static int i915_dp_force_link_retrain_write(void *data, u64 val)
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	intel_dp->link.force_retrain = val;
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
@@ -2184,6 +2205,8 @@ static int i915_dp_link_retrain_disabled_show(struct seq_file *m, void *data)
 	if (err)
 		return err;
 
+	intel_dp_flush_connector_commits(connector);
+
 	seq_printf(m, "%s\n", str_yes_no(intel_dp->link.retrain_disabled));
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
Signature · 1 line
Jani Nikula, Intel
Signature · 1 line
Jani Nikula, Intel
author
#12 lore raw

PATCH 8/108 drm/i915/dp_link_training: Move link training helpers to link training code

In reply to Imre Deak

Move the link retraining helpers to intel_dp_link_training.c, next to the other link training helpers.

---
 drivers/gpu/drm/i915/display/intel_dp.c       | 197 -----------------
 drivers/gpu/drm/i915/display/intel_dp.h       |   4 -
 .../drm/i915/display/intel_dp_link_training.c | 200 ++++++++++++++++++
 .../drm/i915/display/intel_dp_link_training.h |   7 +
 4 files changed, 207 insertions(+), 201 deletions(-)
drivers/gpu/drm/i915/display/intel_dp.c +0 -197
index d7c8ace38a01c..3821686484483 100644
@@ -845,25 +845,6 @@ static bool intel_dp_set_common_rates(struct intel_dp *intel_dp)
 	return link_params_changed;
 }
 
-bool intel_dp_link_params_valid(struct intel_dp *intel_dp, int link_rate,
-				u8 lane_count)
-{
-	/*
-	 * FIXME: we need to synchronize the current link parameters with
-	 * hardware readout. Currently fast link training doesn't work on
-	 * boot-up.
-	 */
-	if (link_rate == 0 ||
-	    link_rate > intel_dp->link.max_rate)
-		return false;
-
-	if (lane_count == 0 ||
-	    lane_count > intel_dp_max_lane_count(intel_dp))
-		return false;
-
-	return true;
-}
-
 u32 intel_dp_mode_to_fec_clock(u32 mode_clock)
 {
 	return div_u64(mul_u32_u32(mode_clock, DP_DSC_FEC_OVERHEAD_FACTOR),
@@ -5626,32 +5607,6 @@ void intel_read_dp_sdp(struct intel_encoder *encoder,
 	}
 }
 
-static bool intel_dp_link_ok(struct intel_dp *intel_dp,
-			     u8 link_status[DP_LINK_STATUS_SIZE])
-{
-	struct intel_display *display = to_intel_display(intel_dp);
-	struct intel_encoder *encoder = &dp_to_dig_port(intel_dp)->base;
-	bool uhbr = intel_dp->link_rate >= 1000000;
-	bool ok;
-
-	if (uhbr)
-		ok = drm_dp_128b132b_lane_channel_eq_done(link_status,
-							  intel_dp->lane_count);
-	else
-		ok = drm_dp_channel_eq_ok(link_status, intel_dp->lane_count);
-
-	if (ok)
-		return true;
-
-	intel_dp_dump_link_status(intel_dp, DP_PHY_DPRX, link_status);
-	drm_dbg_kms(display->drm,
-		    "[ENCODER:%d:%s] %s link not ok, retraining\n",
-		    encoder->base.base.id, encoder->base.name,
-		    uhbr ? "128b/132b" : "8b/10b");
-
-	return false;
-}
-
 static void
 intel_dp_mst_hpd_irq(struct intel_dp *intel_dp, u8 *esi, u8 *ack)
 {
@@ -5758,78 +5713,6 @@ intel_dp_handle_hdmi_link_status_change(struct intel_dp *intel_dp)
 	}
 }
 
-static int
-intel_dp_read_link_status(struct intel_dp *intel_dp, u8 link_status[DP_LINK_STATUS_SIZE])
-{
-	int err;
-
-	memset(link_status, 0, DP_LINK_STATUS_SIZE);
-
-	if (intel_dp_mst_active_streams(intel_dp) > 0)
-		err = drm_dp_dpcd_read_data(&intel_dp->aux, DP_LANE0_1_STATUS_ESI,
-					    link_status, DP_LINK_STATUS_SIZE - 2);
-	else
-		err = drm_dp_dpcd_read_phy_link_status(&intel_dp->aux, DP_PHY_DPRX,
-						       link_status);
-
-	if (err)
-		return err;
-
-	if (link_status[DP_LANE_ALIGN_STATUS_UPDATED - DP_LANE0_1_STATUS] &
-	    DP_DOWNSTREAM_PORT_STATUS_CHANGED)
-		WRITE_ONCE(intel_dp->downstream_port_changed, true);
-
-	return 0;
-}
-
-static bool
-intel_dp_needs_link_retrain(struct intel_dp *intel_dp)
-{
-	u8 link_status[DP_LINK_STATUS_SIZE];
-
-	if (!intel_dp->link.active)
-		return false;
-
-	/*
-	 * While PSR source HW is enabled, it will control main-link sending
-	 * frames, enabling and disabling it so trying to do a retrain will fail
-	 * as the link would or not be on or it could mix training patterns
-	 * and frame data at the same time causing retrain to fail.
-	 * Also when exiting PSR, HW will retrain the link anyways fixing
-	 * any link status error.
-	 */
-	if (intel_psr_enabled(intel_dp))
-		return false;
-
-	if (intel_dp->link.force_retrain)
-		return true;
-
-	if (intel_dp_read_link_status(intel_dp, link_status) < 0)
-		return false;
-
-	/*
-	 * Validate the cached values of intel_dp->link_rate and
-	 * intel_dp->lane_count before attempting to retrain.
-	 *
-	 * FIXME would be nice to user the crtc state here, but since
-	 * we need to call this from the short HPD handler that seems
-	 * a bit hard.
-	 */
-	if (!intel_dp_link_params_valid(intel_dp, intel_dp->link_rate,
-					intel_dp->lane_count))
-		return false;
-
-	if (intel_dp->link.retrain_disabled)
-		return false;
-
-	if (intel_dp->link.seq_train_failures)
-		return true;
-
-	/* Retrain if link not ok */
-	return !intel_dp_link_ok(intel_dp, link_status) &&
-		!intel_psr_link_ok(intel_dp);
-}
-
 bool intel_dp_has_connector(struct intel_dp *intel_dp,
 			    const struct drm_connector_state *conn_state)
 {
@@ -5921,86 +5804,6 @@ void intel_dp_flush_connector_commits(struct intel_connector *connector)
 	wait_for_connector_hw_done(connector->base.state);
 }
 
-static bool intel_dp_is_connected(struct intel_dp *intel_dp)
-{
-	struct intel_connector *connector = intel_dp->attached_connector;
-
-	return connector->base.status == connector_status_connected ||
-		intel_dp->is_mst;
-}
-
-static int intel_dp_retrain_link(struct intel_encoder *encoder,
-				 struct drm_modeset_acquire_ctx *ctx)
-{
-	struct intel_display *display = to_intel_display(encoder);
-	struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
-	u8 pipe_mask;
-	int ret;
-
-	if (!intel_dp_is_connected(intel_dp))
-		return 0;
-
-	ret = drm_modeset_lock(&display->drm->mode_config.connection_mutex,
-			       ctx);
-	if (ret)
-		return ret;
-
-	if (!intel_dp_needs_link_retrain(intel_dp))
-		return 0;
-
-	ret = intel_dp_get_active_pipes(intel_dp, ctx, &pipe_mask);
-	if (ret)
-		return ret;
-
-	if (pipe_mask == 0)
-		return 0;
-
-	if (!intel_dp_needs_link_retrain(intel_dp))
-		return 0;
-
-	drm_dbg_kms(display->drm,
-		    "[ENCODER:%d:%s] retraining link (forced %s)\n",
-		    encoder->base.base.id, encoder->base.name,
-		    str_yes_no(intel_dp->link.force_retrain));
-
-	ret = intel_modeset_commit_pipes(display, pipe_mask, ctx);
-	if (ret == -EDEADLK)
-		return ret;
-
-	intel_dp->link.force_retrain = false;
-
-	if (ret)
-		drm_dbg_kms(display->drm,
-			    "[ENCODER:%d:%s] link retraining failed: %pe\n",
-			    encoder->base.base.id, encoder->base.name,
-			    ERR_PTR(ret));
-
-	return ret;
-}
-
-void intel_dp_link_check(struct intel_encoder *encoder)
-{
-	struct drm_modeset_acquire_ctx ctx;
-	int ret;
-
-	intel_modeset_lock_ctx_retry(&ctx, NULL, 0, ret)
-		ret = intel_dp_retrain_link(encoder, &ctx);
-}
-
-void intel_dp_check_link_state(struct intel_dp *intel_dp)
-{
-	struct intel_digital_port *dig_port = dp_to_dig_port(intel_dp);
-	struct intel_encoder *encoder = &dig_port->base;
-
-	if (!intel_dp_is_connected(intel_dp))
-		return;
-
-	if (!intel_dp_needs_link_retrain(intel_dp))
-		return;
-
-	intel_encoder_link_check_queue_work(encoder, 0);
-}
-
 static void intel_dp_handle_device_service_irq(struct intel_dp *intel_dp, u8 irq_mask)
 {
 	struct intel_display *display = to_intel_display(intel_dp);
drivers/gpu/drm/i915/display/intel_dp.h +0 -4
index f2abd6059a22a..3c0d229eb1f55 100644
@@ -56,8 +56,6 @@ int intel_dp_get_active_pipes(struct intel_dp *intel_dp,
 			      struct drm_modeset_acquire_ctx *ctx,
 			      u8 *pipe_mask);
 void intel_dp_flush_connector_commits(struct intel_connector *connector);
-void intel_dp_link_check(struct intel_encoder *encoder);
-void intel_dp_check_link_state(struct intel_dp *intel_dp);
 void intel_dp_set_power(struct intel_dp *intel_dp, u8 mode);
 void intel_dp_configure_protocol_converter(struct intel_dp *intel_dp,
 					   const struct intel_crtc_state *crtc_state);
@@ -206,8 +204,6 @@ void intel_dp_get_dsc_sink_cap(u8 dpcd_rev,
 			       struct intel_connector *connector);
 bool intel_dp_has_gamut_metadata_dip(struct intel_encoder *encoder);
 
-bool intel_dp_link_params_valid(struct intel_dp *intel_dp, int link_rate,
-				u8 lane_count);
 bool intel_dp_has_connector(struct intel_dp *intel_dp,
 			    const struct drm_connector_state *conn_state);
 int intel_dp_dsc_max_src_input_bpc(struct intel_display *display);
drivers/gpu/drm/i915/display/intel_dp_link_training.c +200 -0

215 lines not on this page · raw message

drivers/gpu/drm/i915/display/intel_dp_link_training.h +7 -0
index 6c0c74e31a3c5..c1e57c6aa3a7d 100644
@@ -13,6 +13,7 @@ struct intel_connector;
 struct intel_crtc_state;
 struct intel_dp;
 struct intel_dp_link_training;
+struct intel_encoder;
 
 int intel_dp_read_dprx_caps(struct intel_dp *intel_dp, u8 dpcd[DP_RECEIVER_CAP_SIZE]);
 int intel_dp_init_lttpr_and_dprx_caps(struct intel_dp *intel_dp);
@@ -54,6 +55,12 @@ static inline u8 intel_dp_training_pattern_symbol(u8 pattern)
 void intel_dp_128b132b_sdp_crc16(struct intel_dp *intel_dp,
 				 const struct intel_crtc_state *crtc_state);
 
+bool intel_dp_link_params_valid(struct intel_dp *intel_dp, int link_rate,
+				u8 lane_count);
+
+void intel_dp_link_check(struct intel_encoder *encoder);
+void intel_dp_check_link_state(struct intel_dp *intel_dp);
+
 void intel_dp_link_training_debugfs_add(struct intel_connector *connector);
 
 void intel_dp_link_training_reset(struct intel_dp_link_training *link_training);
Signature · 1 line
2.49.1
author
#13 lore raw

PATCH 9/108 drm/i915/dp_link_training: Use link_training as base pointer in debugfs

In reply to Imre Deak

Retrieve the link_training pointer from the connector and derive the DP pointer from it in debugfs entries.

This prepares for a follow-up change where values exposed via debugfs entries will be retrieved from the link training state.

---
 .../drm/i915/display/intel_dp_link_training.c | 25 +++++++++++++++----
 1 file changed, 20 insertions(+), 5 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_training.c +20 -5
index c2f9af251b6a9..1762e507dd1ec 100644
@@ -67,6 +67,11 @@ struct intel_dp_link_training {
 	struct intel_dp *dp;
 };
 
+static struct intel_dp_link_training *connector_to_link_training(struct intel_connector *connector)
+{
+	return intel_attached_dp(connector)->link.training;
+}
+
 static void intel_dp_reset_lttpr_common_caps(struct intel_dp *intel_dp)
 {
 	memset(intel_dp->lttpr_common_caps, 0, sizeof(intel_dp->lttpr_common_caps));
@@ -2307,7 +2312,9 @@ static int i915_dp_force_link_training_failure_show(void *data, u64 *val)
 {
 	struct intel_connector *connector = to_intel_connector(data);
 	struct intel_display *display = to_intel_display(connector);
-	struct intel_dp *intel_dp = intel_attached_dp(connector);
+	struct intel_dp_link_training *link_training =
+		connector_to_link_training(connector);
+	struct intel_dp *intel_dp = link_training->dp;
 	int err;
 
 	err = drm_modeset_lock_single_interruptible(&display->drm->mode_config.connection_mutex);
@@ -2327,7 +2334,9 @@ static int i915_dp_force_link_training_failure_write(void *data, u64 val)
 {
 	struct intel_connector *connector = to_intel_connector(data);
 	struct intel_display *display = to_intel_display(connector);
-	struct intel_dp *intel_dp = intel_attached_dp(connector);
+	struct intel_dp_link_training *link_training =
+		connector_to_link_training(connector);
+	struct intel_dp *intel_dp = link_training->dp;
 	int err;
 
 	if (val > 2)
@@ -2353,7 +2362,9 @@ static int i915_dp_force_link_retrain_show(void *data, u64 *val)
 {
 	struct intel_connector *connector = to_intel_connector(data);
 	struct intel_display *display = to_intel_display(connector);
-	struct intel_dp *intel_dp = intel_attached_dp(connector);
+	struct intel_dp_link_training *link_training =
+		connector_to_link_training(connector);
+	struct intel_dp *intel_dp = link_training->dp;
 	int err;
 
 	err = drm_modeset_lock_single_interruptible(&display->drm->mode_config.connection_mutex);
@@ -2373,7 +2384,9 @@ static int i915_dp_force_link_retrain_write(void *data, u64 val)
 {
 	struct intel_connector *connector = to_intel_connector(data);
 	struct intel_display *display = to_intel_display(connector);
-	struct intel_dp *intel_dp = intel_attached_dp(connector);
+	struct intel_dp_link_training *link_training =
+		connector_to_link_training(connector);
+	struct intel_dp *intel_dp = link_training->dp;
 	int err;
 
 	err = drm_modeset_lock_single_interruptible(&display->drm->mode_config.connection_mutex);
@@ -2398,7 +2411,9 @@ static int i915_dp_link_retrain_disabled_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_training *link_training =
+		connector_to_link_training(connector);
+	struct intel_dp *intel_dp = link_training->dp;
 	int err;
 
 	err = drm_modeset_lock_single_interruptible(&display->drm->mode_config.connection_mutex);
Signature · 1 line
2.49.1
maintainer
#14 lore raw

Re: [PATCH 009/108] drm/i915/dp_link_training: Use link_training as base pointer in debugfs

Quoted 28 lines · Imre Deak

Retrieve the link_training pointer from the connector and derive the DP pointer from it in debugfs entries.

This prepares for a follow-up change where values exposed via debugfs entries will be retrieved from the link training state.

---
 .../drm/i915/display/intel_dp_link_training.c | 25 +++++++++++++++----
 1 file changed, 20 insertions(+), 5 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_training.c +5 -0
index c2f9af251b6a9..1762e507dd1ec 100644
@@ -67,6 +67,11 @@ struct intel_dp_link_training {
 	struct intel_dp *dp;
 };
 
+static struct intel_dp_link_training *connector_to_link_training(struct intel_connector *connector)
+{
+	return intel_attached_dp(connector)->link.training;
+}
+
 static void intel_dp_reset_lttpr_common_caps(struct intel_dp *intel_dp)
 {
 	memset(intel_dp->lttpr_common_caps, 0, sizeof(intel_dp->lttpr_common_caps));

drivers/gpu/drm/i915/display/intel_dp_link_training.c static int i915_dp_force_link_training_failure_show(void *data, u64 *val) · line 2316

Quoted 6 lines
drivers/gpu/drm/i915/display/intel_dp_link_training.c +2 -1
@@ -2307,7 +2312,9 @@ static int i915_dp_force_link_training_failure_show(void *data, u64 *val)
 {
 	struct intel_connector *connector = to_intel_connector(data);
 	struct intel_display *display = to_intel_display(connector);
-	struct intel_dp *intel_dp = intel_attached_dp(connector);
+	struct intel_dp_link_training *link_training =
+		connector_to_link_training(connector);

Nitpick, this fits on one line. The newline is a worse distraction than going over 80 chars. Ditto below.

Quoted 48 lines
drivers/gpu/drm/i915/display/intel_dp_link_training.c +13 -4
+	struct intel_dp *intel_dp = link_training->dp;
 	int err;
 
 	err = drm_modeset_lock_single_interruptible(&display->drm->mode_config.connection_mutex);
@@ -2327,7 +2334,9 @@ static int i915_dp_force_link_training_failure_write(void *data, u64 val)
 {
 	struct intel_connector *connector = to_intel_connector(data);
 	struct intel_display *display = to_intel_display(connector);
-	struct intel_dp *intel_dp = intel_attached_dp(connector);
+	struct intel_dp_link_training *link_training =
+		connector_to_link_training(connector);
+	struct intel_dp *intel_dp = link_training->dp;
 	int err;
 
 	if (val > 2)
@@ -2353,7 +2362,9 @@ static int i915_dp_force_link_retrain_show(void *data, u64 *val)
 {
 	struct intel_connector *connector = to_intel_connector(data);
 	struct intel_display *display = to_intel_display(connector);
-	struct intel_dp *intel_dp = intel_attached_dp(connector);
+	struct intel_dp_link_training *link_training =
+		connector_to_link_training(connector);
+	struct intel_dp *intel_dp = link_training->dp;
 	int err;
 
 	err = drm_modeset_lock_single_interruptible(&display->drm->mode_config.connection_mutex);
@@ -2373,7 +2384,9 @@ static int i915_dp_force_link_retrain_write(void *data, u64 val)
 {
 	struct intel_connector *connector = to_intel_connector(data);
 	struct intel_display *display = to_intel_display(connector);
-	struct intel_dp *intel_dp = intel_attached_dp(connector);
+	struct intel_dp_link_training *link_training =
+		connector_to_link_training(connector);
+	struct intel_dp *intel_dp = link_training->dp;
 	int err;
 
 	err = drm_modeset_lock_single_interruptible(&display->drm->mode_config.connection_mutex);
@@ -2398,7 +2411,9 @@ static int i915_dp_link_retrain_disabled_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_training *link_training =
+		connector_to_link_training(connector);
+	struct intel_dp *intel_dp = link_training->dp;
 	int err;
 
 	err = drm_modeset_lock_single_interruptible(&display->drm->mode_config.connection_mutex);
Signature · 1 line
Jani Nikula, Intel
author
#15 lore raw

Re: [PATCH 009/108] drm/i915/dp_link_training: Use link_training as base pointer in debugfs

Quoted 30 lines · Jani Nikula
Quoted 29 lines · Imre Deak

Retrieve the link_training pointer from the connector and derive the DP pointer from it in debugfs entries.

This prepares for a follow-up change where values exposed via debugfs entries will be retrieved from the link training state.

---
 .../drm/i915/display/intel_dp_link_training.c | 25 +++++++++++++++----
 1 file changed, 20 insertions(+), 5 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_training.c +5 -0
index c2f9af251b6a9..1762e507dd1ec 100644
@@ -67,6 +67,11 @@ struct intel_dp_link_training {
 	struct intel_dp *dp;
 };
 
+static struct intel_dp_link_training *connector_to_link_training(struct intel_connector *connector)
+{
+	return intel_attached_dp(connector)->link.training;
+}
+
 static void intel_dp_reset_lttpr_common_caps(struct intel_dp *intel_dp)
 {
 	memset(intel_dp->lttpr_common_caps, 0, sizeof(intel_dp->lttpr_common_caps));
@@ -2307,7 +2312,9 @@ static int i915_dp_force_link_training_failure_show(void *data, u64 *val)
 {
Quoted 8 lines

drivers/gpu/drm/i915/display/intel_dp_link_training.c static int i915_dp_force_link_training_failure_show(void *data, u64 *val) · line 2316

Quoted 5 lines
drivers/gpu/drm/i915/display/intel_dp_link_training.c +2 -1
 	struct intel_connector *connector = to_intel_connector(data);
 	struct intel_display *display = to_intel_display(connector);
-	struct intel_dp *intel_dp = intel_attached_dp(connector);
+	struct intel_dp_link_training *link_training =
+		connector_to_link_training(connector);

Nitpick, this fits on one line. The newline is a worse distraction than going over 80 chars. Ditto below.

There's also a guideline to keep the length of declarations decreasing, which imo does make the declaration block more readable. This is ofc a subjective thing, could be argued in both ways.

Quoted 52 lines
Quoted 49 lines
drivers/gpu/drm/i915/display/intel_dp_link_training.c +13 -4
+	struct intel_dp *intel_dp = link_training->dp;
 	int err;
 
 	err = drm_modeset_lock_single_interruptible(&display->drm->mode_config.connection_mutex);
@@ -2327,7 +2334,9 @@ static int i915_dp_force_link_training_failure_write(void *data, u64 val)
 {
 	struct intel_connector *connector = to_intel_connector(data);
 	struct intel_display *display = to_intel_display(connector);
-	struct intel_dp *intel_dp = intel_attached_dp(connector);
+	struct intel_dp_link_training *link_training =
+		connector_to_link_training(connector);
+	struct intel_dp *intel_dp = link_training->dp;
 	int err;
 
 	if (val > 2)
@@ -2353,7 +2362,9 @@ static int i915_dp_force_link_retrain_show(void *data, u64 *val)
 {
 	struct intel_connector *connector = to_intel_connector(data);
 	struct intel_display *display = to_intel_display(connector);
-	struct intel_dp *intel_dp = intel_attached_dp(connector);
+	struct intel_dp_link_training *link_training =
+		connector_to_link_training(connector);
+	struct intel_dp *intel_dp = link_training->dp;
 	int err;
 
 	err = drm_modeset_lock_single_interruptible(&display->drm->mode_config.connection_mutex);
@@ -2373,7 +2384,9 @@ static int i915_dp_force_link_retrain_write(void *data, u64 val)
 {
 	struct intel_connector *connector = to_intel_connector(data);
 	struct intel_display *display = to_intel_display(connector);
-	struct intel_dp *intel_dp = intel_attached_dp(connector);
+	struct intel_dp_link_training *link_training =
+		connector_to_link_training(connector);
+	struct intel_dp *intel_dp = link_training->dp;
 	int err;
 
 	err = drm_modeset_lock_single_interruptible(&display->drm->mode_config.connection_mutex);
@@ -2398,7 +2411,9 @@ static int i915_dp_link_retrain_disabled_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_training *link_training =
+		connector_to_link_training(connector);
+	struct intel_dp *intel_dp = link_training->dp;
 	int err;
 
 	err = drm_modeset_lock_single_interruptible(&display->drm->mode_config.connection_mutex);
Signature · 1 line
Jani Nikula, Intel
maintainer
#16 lore raw

Re: [PATCH 009/108] drm/i915/dp_link_training: Use link_training as base pointer in debugfs

Quoted 40 lines · Imre Deak
Quoted 30 lines · Jani Nikula
Quoted 29 lines · Imre Deak

Retrieve the link_training pointer from the connector and derive the DP pointer from it in debugfs entries.

This prepares for a follow-up change where values exposed via debugfs entries will be retrieved from the link training state.

---
 .../drm/i915/display/intel_dp_link_training.c | 25 +++++++++++++++----
 1 file changed, 20 insertions(+), 5 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_training.c +5 -0
index c2f9af251b6a9..1762e507dd1ec 100644
@@ -67,6 +67,11 @@ struct intel_dp_link_training {
 	struct intel_dp *dp;
 };
 
+static struct intel_dp_link_training *connector_to_link_training(struct intel_connector *connector)
+{
+	return intel_attached_dp(connector)->link.training;
+}
+
 static void intel_dp_reset_lttpr_common_caps(struct intel_dp *intel_dp)
 {
 	memset(intel_dp->lttpr_common_caps, 0, sizeof(intel_dp->lttpr_common_caps));
@@ -2307,7 +2312,9 @@ static int i915_dp_force_link_training_failure_show(void *data, u64 *val)
 {
Quoted 8 lines

drivers/gpu/drm/i915/display/intel_dp_link_training.c static int i915_dp_force_link_training_failure_show(void *data, u64 *val) · line 2316

Quoted 5 lines
drivers/gpu/drm/i915/display/intel_dp_link_training.c +2 -1
 	struct intel_connector *connector = to_intel_connector(data);
 	struct intel_display *display = to_intel_display(connector);
-	struct intel_dp *intel_dp = intel_attached_dp(connector);
+	struct intel_dp_link_training *link_training =
+		connector_to_link_training(connector);

Nitpick, this fits on one line. The newline is a worse distraction than going over 80 chars. Ditto below.

Quoted 3 lines

There's also a guideline to keep the length of declarations decreasing, which imo does make the declaration block more readable. This is ofc a subjective thing, could be argued in both ways.

We don't have the reverse christmas tree thing going on (though I do prefer struct pointers before integral types). But even if we did, it would be silly to achieve that using newlines.

BR,
Jani.

Quoted 53 lines
Quoted 53 lines
Quoted 50 lines
drivers/gpu/drm/i915/display/intel_dp_link_training.c +13 -4
+	struct intel_dp *intel_dp = link_training->dp;
 	int err;
 
 	err = drm_modeset_lock_single_interruptible(&display->drm->mode_config.connection_mutex);
@@ -2327,7 +2334,9 @@ static int i915_dp_force_link_training_failure_write(void *data, u64 val)
 {
 	struct intel_connector *connector = to_intel_connector(data);
 	struct intel_display *display = to_intel_display(connector);
-	struct intel_dp *intel_dp = intel_attached_dp(connector);
+	struct intel_dp_link_training *link_training =
+		connector_to_link_training(connector);
+	struct intel_dp *intel_dp = link_training->dp;
 	int err;
 
 	if (val > 2)
@@ -2353,7 +2362,9 @@ static int i915_dp_force_link_retrain_show(void *data, u64 *val)
 {
 	struct intel_connector *connector = to_intel_connector(data);
 	struct intel_display *display = to_intel_display(connector);
-	struct intel_dp *intel_dp = intel_attached_dp(connector);
+	struct intel_dp_link_training *link_training =
+		connector_to_link_training(connector);
+	struct intel_dp *intel_dp = link_training->dp;
 	int err;
 
 	err = drm_modeset_lock_single_interruptible(&display->drm->mode_config.connection_mutex);
@@ -2373,7 +2384,9 @@ static int i915_dp_force_link_retrain_write(void *data, u64 val)
 {
 	struct intel_connector *connector = to_intel_connector(data);
 	struct intel_display *display = to_intel_display(connector);
-	struct intel_dp *intel_dp = intel_attached_dp(connector);
+	struct intel_dp_link_training *link_training =
+		connector_to_link_training(connector);
+	struct intel_dp *intel_dp = link_training->dp;
 	int err;
 
 	err = drm_modeset_lock_single_interruptible(&display->drm->mode_config.connection_mutex);
@@ -2398,7 +2411,9 @@ static int i915_dp_link_retrain_disabled_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_training *link_training =
+		connector_to_link_training(connector);
+	struct intel_dp *intel_dp = link_training->dp;
 	int err;
 
 	err = drm_modeset_lock_single_interruptible(&display->drm->mode_config.connection_mutex);
Signature · 1 line
Jani Nikula, Intel
Signature · 1 line
Jani Nikula, Intel
author
#17 lore raw

Re: [PATCH 009/108] drm/i915/dp_link_training: Use link_training as base pointer in debugfs

Quoted 41 lines · Jani Nikula
Quoted 40 lines · Imre Deak
Quoted 38 lines · Jani Nikula
Quoted 28 lines · Imre Deak

Retrieve the link_training pointer from the connector and derive the DP pointer from it in debugfs entries.

This prepares for a follow-up change where values exposed via debugfs entries will be retrieved from the link training state.

---
 .../drm/i915/display/intel_dp_link_training.c | 25 +++++++++++++++----
 1 file changed, 20 insertions(+), 5 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_training.c +5 -0
index c2f9af251b6a9..1762e507dd1ec 100644
@@ -67,6 +67,11 @@ struct intel_dp_link_training {
 	struct intel_dp *dp;
 };
 
+static struct intel_dp_link_training *connector_to_link_training(struct intel_connector *connector)
+{
+	return intel_attached_dp(connector)->link.training;
+}
+
 static void intel_dp_reset_lttpr_common_caps(struct intel_dp *intel_dp)
 {
 	memset(intel_dp->lttpr_common_caps, 0, sizeof(intel_dp->lttpr_common_caps));

drivers/gpu/drm/i915/display/intel_dp_link_training.c static int i915_dp_force_link_training_failure_show(void *data, u64 *val) · line 2316

Quoted 6 lines
drivers/gpu/drm/i915/display/intel_dp_link_training.c +2 -1
@@ -2307,7 +2312,9 @@ static int i915_dp_force_link_training_failure_show(void *data, u64 *val)
 {
 	struct intel_connector *connector = to_intel_connector(data);
 	struct intel_display *display = to_intel_display(connector);
-	struct intel_dp *intel_dp = intel_attached_dp(connector);
+	struct intel_dp_link_training *link_training =
+		connector_to_link_training(connector);

Nitpick, this fits on one line. The newline is a worse distraction than going over 80 chars. Ditto below.

Quoted 7 lines
Quoted 3 lines

There's also a guideline to keep the length of declarations decreasing, which imo does make the declaration block more readable. This is ofc a subjective thing, could be argued in both ways.

We don't have the reverse christmas tree thing going on (though I do prefer struct pointers before integral types). But even if we did, it would be silly to achieve that using newlines.

Aye, will join the lines here then and follow that rule in the future.

Quoted 60 lines

BR,
Jani.

Quoted 53 lines
Quoted 53 lines
Quoted 50 lines
drivers/gpu/drm/i915/display/intel_dp_link_training.c +13 -4
+	struct intel_dp *intel_dp = link_training->dp;
 	int err;
 
 	err = drm_modeset_lock_single_interruptible(&display->drm->mode_config.connection_mutex);
@@ -2327,7 +2334,9 @@ static int i915_dp_force_link_training_failure_write(void *data, u64 val)
 {
 	struct intel_connector *connector = to_intel_connector(data);
 	struct intel_display *display = to_intel_display(connector);
-	struct intel_dp *intel_dp = intel_attached_dp(connector);
+	struct intel_dp_link_training *link_training =
+		connector_to_link_training(connector);
+	struct intel_dp *intel_dp = link_training->dp;
 	int err;
 
 	if (val > 2)
@@ -2353,7 +2362,9 @@ static int i915_dp_force_link_retrain_show(void *data, u64 *val)
 {
 	struct intel_connector *connector = to_intel_connector(data);
 	struct intel_display *display = to_intel_display(connector);
-	struct intel_dp *intel_dp = intel_attached_dp(connector);
+	struct intel_dp_link_training *link_training =
+		connector_to_link_training(connector);
+	struct intel_dp *intel_dp = link_training->dp;
 	int err;
 
 	err = drm_modeset_lock_single_interruptible(&display->drm->mode_config.connection_mutex);
@@ -2373,7 +2384,9 @@ static int i915_dp_force_link_retrain_write(void *data, u64 val)
 {
 	struct intel_connector *connector = to_intel_connector(data);
 	struct intel_display *display = to_intel_display(connector);
-	struct intel_dp *intel_dp = intel_attached_dp(connector);
+	struct intel_dp_link_training *link_training =
+		connector_to_link_training(connector);
+	struct intel_dp *intel_dp = link_training->dp;
 	int err;
 
 	err = drm_modeset_lock_single_interruptible(&display->drm->mode_config.connection_mutex);
@@ -2398,7 +2411,9 @@ static int i915_dp_link_retrain_disabled_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_training *link_training =
+		connector_to_link_training(connector);
+	struct intel_dp *intel_dp = link_training->dp;
 	int err;
 
 	err = drm_modeset_lock_single_interruptible(&display->drm->mode_config.connection_mutex);
Signature · 1 line
Jani Nikula, Intel
Signature · 1 line
Jani Nikula, Intel
author
#18 lore raw

PATCH 10/108 drm/i915/dp_link_training: Add helpers to access force retrain state

In reply to Imre Deak

Add helpers to get and set the force retrain state in preparation for moving the state from the DP struct to the link training state.

---
 drivers/gpu/drm/i915/display/intel_dp.c       |  2 +-
 .../drm/i915/display/intel_dp_link_training.c | 29 +++++++++++++++----
 .../drm/i915/display/intel_dp_link_training.h |  2 ++
 3 files changed, 26 insertions(+), 7 deletions(-)
drivers/gpu/drm/i915/display/intel_dp.c +1 -1
index 3821686484483..2ad65ef0f697e 100644
@@ -5640,7 +5640,7 @@ static bool
 intel_dp_check_mst_status(struct intel_dp *intel_dp)
 {
 	struct intel_display *display = to_intel_display(intel_dp);
-	bool force_retrain = intel_dp->link.force_retrain;
+	bool force_retrain = intel_dp_link_training_get_force_retrain(intel_dp->link.training);
 	bool reprobe_needed = false;
 
 	for (;;) {
drivers/gpu/drm/i915/display/intel_dp_link_training.c +23 -6
index 1762e507dd1ec..72e023b733b33 100644
@@ -1929,9 +1929,25 @@ intel_dp_read_link_status(struct intel_dp *intel_dp, u8 link_status[DP_LINK_STAT
 	return 0;
 }
 
+bool intel_dp_link_training_get_force_retrain(struct intel_dp_link_training *link_training)
+{
+	struct intel_dp *intel_dp = link_training->dp;
+
+	return intel_dp->link.force_retrain;
+}
+
+static void intel_dp_link_training_set_force_retrain(struct intel_dp_link_training *link_training,
+						     bool forced)
+{
+	struct intel_dp *intel_dp = link_training->dp;
+
+	intel_dp->link.force_retrain = forced;
+}
+
 static bool
 intel_dp_needs_link_retrain(struct intel_dp *intel_dp)
 {
+	struct intel_dp_link_training *link_training = intel_dp->link.training;
 	u8 link_status[DP_LINK_STATUS_SIZE];
 
 	if (!intel_dp->link.active)
@@ -1948,7 +1964,7 @@ intel_dp_needs_link_retrain(struct intel_dp *intel_dp)
 	if (intel_psr_enabled(intel_dp))
 		return false;
 
-	if (intel_dp->link.force_retrain)
+	if (intel_dp_link_training_get_force_retrain(link_training))
 		return true;
 
 	if (intel_dp_read_link_status(intel_dp, link_status) < 0)
@@ -1990,6 +2006,8 @@ static int intel_dp_retrain_link(struct intel_encoder *encoder,
 {
 	struct intel_display *display = to_intel_display(encoder);
 	struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
+	struct intel_dp_link_training *link_training =
+		intel_dp->link.training;
 	u8 pipe_mask;
 	int ret;
 
@@ -2017,13 +2035,13 @@ static int intel_dp_retrain_link(struct intel_encoder *encoder,
 	drm_dbg_kms(display->drm,
 		    "[ENCODER:%d:%s] retraining link (forced %s)\n",
 		    encoder->base.base.id, encoder->base.name,
-		    str_yes_no(intel_dp->link.force_retrain));
+		    str_yes_no(intel_dp_link_training_get_force_retrain(link_training)));
 
 	ret = intel_modeset_commit_pipes(display, pipe_mask, ctx);
 	if (ret == -EDEADLK)
 		return ret;
 
-	intel_dp->link.force_retrain = false;
+	intel_dp_link_training_set_force_retrain(link_training, false);
 
 	if (ret)
 		drm_dbg_kms(display->drm,
@@ -2364,7 +2382,6 @@ static int i915_dp_force_link_retrain_show(void *data, u64 *val)
 	struct intel_display *display = to_intel_display(connector);
 	struct intel_dp_link_training *link_training =
 		connector_to_link_training(connector);
-	struct intel_dp *intel_dp = link_training->dp;
 	int err;
 
 	err = drm_modeset_lock_single_interruptible(&display->drm->mode_config.connection_mutex);
@@ -2373,7 +2390,7 @@ static int i915_dp_force_link_retrain_show(void *data, u64 *val)
 
 	intel_dp_flush_connector_commits(connector);
 
-	*val = intel_dp->link.force_retrain;
+	*val = intel_dp_link_training_get_force_retrain(link_training);
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
 
@@ -2395,7 +2412,7 @@ static int i915_dp_force_link_retrain_write(void *data, u64 val)
 
 	intel_dp_flush_connector_commits(connector);
 
-	intel_dp->link.force_retrain = val;
+	intel_dp_link_training_set_force_retrain(link_training, val);
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
 
drivers/gpu/drm/i915/display/intel_dp_link_training.h +2 -0
index c1e57c6aa3a7d..f80e979f7436c 100644
@@ -58,6 +58,8 @@ void intel_dp_128b132b_sdp_crc16(struct intel_dp *intel_dp,
 bool intel_dp_link_params_valid(struct intel_dp *intel_dp, int link_rate,
 				u8 lane_count);
 
+bool intel_dp_link_training_get_force_retrain(struct intel_dp_link_training *link_training);
+
 void intel_dp_link_check(struct intel_encoder *encoder);
 void intel_dp_check_link_state(struct intel_dp *intel_dp);
 
Signature · 1 line
2.49.1
author
#19 lore raw

PATCH 11/108 drm/i915/dp_link_training: Move link recovery/debug state to link_training

In reply to Imre Deak

Move all state related to link recovery and link training debugging from struct intel_dp to struct intel_dp_link_training.

This moves towards grouping all link training and recovery state and logic in a single place and prepares for follow-up changes in the link recovery state handling.

---
 .../drm/i915/display/intel_display_types.h    |  5 --
 drivers/gpu/drm/i915/display/intel_dp.c       |  2 +-
 .../drm/i915/display/intel_dp_link_training.c | 52 +++++++++----------
 3 files changed, 27 insertions(+), 32 deletions(-)
drivers/gpu/drm/i915/display/intel_display_types.h +0 -5
index 27714e4cffcdf..dd61d958d5b6c 100644
@@ -1849,11 +1849,6 @@ struct intel_dp {
 		int mst_probed_rate;
 		int force_lane_count;
 		int force_rate;
-		bool retrain_disabled;
-		/* Sequential link training failures after a passing LT */
-		int seq_train_failures;
-		int force_train_failure;
-		bool force_retrain;
 		struct intel_dp_link_training *training;
 	} link;
 	bool reset_link_params;
drivers/gpu/drm/i915/display/intel_dp.c +1 -1
index 2ad65ef0f697e..3dc27dbf2bce8 100644
@@ -5897,7 +5897,7 @@ intel_dp_short_pulse(struct intel_dp *intel_dp)
 	/*
 	 * Force checking the link status for DPCD_REV < 1.2
 	 * TODO: let the link status check depend on LINK_STATUS_CHANGED
-	 * or intel_dp->link.force_retrain for DPCD_REV >= 1.2
+	 * or intel_dp->link.training.force_retrain for DPCD_REV >= 1.2
 	 */
 	esi[3] |= LINK_STATUS_CHANGED;
 	if (intel_dp_handle_link_service_irq(intel_dp, esi[3]))
drivers/gpu/drm/i915/display/intel_dp_link_training.c +26 -26

159 lines not on this page · raw message

Signature · 1 line
2.49.1
author
#20 lore raw

PATCH 12/108 drm/i915/dp_link_training: Prevent repeated autoretrain attempts

In reply to Imre Deak

After a regular modeset link training failure, the driver attempts to recover the link via an autoretrain using the same link parameters as the modeset.

If the autoretrain fails as well, the set of allowed link configurations is reduced via a fallback mechanism. For further link training, the modeset parameters will likely need to change. This lowers the required link bandwidth and allows selecting a link configuration from the fallback-reduced set. Only userspace can perform such a modeset change. Therefore, the driver notifies userspace to take over link recovery.

Userspace is expected to continue with the recovery attempt via a modeset with updated parameters. The driver must not interfere with these modesets.

link_training->seq_train_failures is set to MAX_SEQ_TRAIN_FAILURES after the autoretrain fails. If a fallback selection also fails after this, as no link configurations remain, retrain_disabled is set as well.

retrain_disabled is therefore somewhat misnamed: it indicates that no fallback is available, not that autoretraining is disabled. This will be addressed in a follow-up change by renaming the flag. For now, prevent further autoretrain attempts based on the correct condition:
seq_train_failures == MAX_SEQ_TRAIN_FAILURES.

This also prepares for replacing the counter with an enum in a follow-up change.

---
 drivers/gpu/drm/i915/display/intel_dp_link_training.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/gpu/drm/i915/display/intel_dp_link_training.c +1 -1
index db1e03c15596d..54f506bbd6d1d 100644
@@ -1987,7 +1987,7 @@ intel_dp_needs_link_retrain(struct intel_dp *intel_dp)
 					intel_dp->lane_count))
 		return false;
 
-	if (link_training->retrain_disabled)
+	if (link_training->seq_train_failures >= MAX_SEQ_TRAIN_FAILURES)
 		return false;
 
 	if (link_training->seq_train_failures)
Signature · 1 line
2.49.1
author
#21 lore raw

PATCH 13/108 drm/i915/dp_link_training: Clamp sequential link training failure counter

In reply to Imre Deak

Clamp link_training->seq_train_failures to MAX_SEQ_TRAIN_FAILURES to avoid - an unlikely - overflow. This is ok, because the code only makes a distinction between the cases where the counter is below or at the limit.

This also prepares for replacing the counter with an enum in a follow-up change.

---
 drivers/gpu/drm/i915/display/intel_dp_link_training.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)
drivers/gpu/drm/i915/display/intel_dp_link_training.c +2 -1
index 54f506bbd6d1d..f58bce3e0a1d3 100644
@@ -1816,7 +1816,8 @@ void intel_dp_start_link_train(struct intel_atomic_state *state,
 		return;
 	}
 
-	link_training->seq_train_failures++;
+	if (link_training->seq_train_failures < MAX_SEQ_TRAIN_FAILURES)
+		link_training->seq_train_failures++;
 
 	/*
 	 * Ignore the link failure in CI
Signature · 1 line
2.49.1
author
#22 lore raw

PATCH 14/108 drm/i915/dp_link_training: Check for pending autoretrain explicitly

In reply to Imre Deak

Check explicitly for a pending autoretrain by matching seq_train_failures == 1.

This makes the actual condition clear, since at the point where the counter is checked it is also below MAX_SEQ_TRAIN_FAILURES.

This also prepares for replacing the counter with an enum in a follow-up change.

---
 drivers/gpu/drm/i915/display/intel_dp_link_training.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_training.c +2 -2
index f58bce3e0a1d3..0c5b7816dfff9 100644
@@ -1290,7 +1290,7 @@ void intel_dp_stop_link_train(struct intel_dp *intel_dp,
 
 	if (!display->hotplug.ignore_long_hpd &&
 	    link_training->seq_train_failures < MAX_SEQ_TRAIN_FAILURES) {
-		int delay_ms = link_training->seq_train_failures ? 0 : 2000;
+		int delay_ms = link_training->seq_train_failures == 1 ? 0 : 2000;
 
 		intel_encoder_link_check_queue_work(encoder, delay_ms);
 	}
@@ -1991,7 +1991,7 @@ intel_dp_needs_link_retrain(struct intel_dp *intel_dp)
 	if (link_training->seq_train_failures >= MAX_SEQ_TRAIN_FAILURES)
 		return false;
 
-	if (link_training->seq_train_failures)
+	if (link_training->seq_train_failures == 1)
 		return true;
 
 	/* Retrain if link not ok */
Signature · 1 line
2.49.1
author
#23 lore raw

PATCH 15/108 drm/i915/dp_link_training: Add helper to query pending autoretrain

In reply to Imre Deak

Add link_recovery_autoretrain_pending() to make it clearer what the condition is about at its callers: an autoretrain work has been queued.

This also prepares for replacing the sequential link training failure counter with an enum in a follow-up change.

---
 .../drm/i915/display/intel_dp_link_training.c  | 18 ++++++++++++++++--
 1 file changed, 16 insertions(+), 2 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_training.c +16 -2
index 0c5b7816dfff9..77697a7619812 100644
@@ -1249,6 +1249,20 @@ intel_dp_128b132b_intra_hop(struct intel_dp *intel_dp,
 	return sink_status & DP_INTRA_HOP_AUX_REPLY_INDICATION ? 1 : 0;
 }
 
+/**
+ * link_recovery_autoretrain_pending - check for a pending automatic retraining
+ * @link_training: link training state
+ *
+ * Return:
+ * - %true  if automatic retraining is pending.
+ * - %false otherwise.
+ */
+static bool
+link_recovery_autoretrain_pending(struct intel_dp_link_training *link_training)
+{
+	return link_training->seq_train_failures == 1;
+}
+
 /**
  * intel_dp_stop_link_train - stop link training
  * @intel_dp: DP struct
@@ -1290,7 +1304,7 @@ void intel_dp_stop_link_train(struct intel_dp *intel_dp,
 
 	if (!display->hotplug.ignore_long_hpd &&
 	    link_training->seq_train_failures < MAX_SEQ_TRAIN_FAILURES) {
-		int delay_ms = link_training->seq_train_failures == 1 ? 0 : 2000;
+		int delay_ms = link_recovery_autoretrain_pending(link_training) ? 0 : 2000;
 
 		intel_encoder_link_check_queue_work(encoder, delay_ms);
 	}
@@ -1991,7 +2005,7 @@ intel_dp_needs_link_retrain(struct intel_dp *intel_dp)
 	if (link_training->seq_train_failures >= MAX_SEQ_TRAIN_FAILURES)
 		return false;
 
-	if (link_training->seq_train_failures == 1)
+	if (link_recovery_autoretrain_pending(link_training))
 		return true;
 
 	/* Retrain if link not ok */
Signature · 1 line
2.49.1
maintainer
#24 lore raw

Re: [PATCH 015/108] drm/i915/dp_link_training: Add helper to query pending autoretrain

Quoted 17 lines · Imre Deak

Add link_recovery_autoretrain_pending() to make it clearer what the condition is about at its callers: an autoretrain work has been queued.

This also prepares for replacing the sequential link training failure counter with an enum in a follow-up change.

---
 .../drm/i915/display/intel_dp_link_training.c  | 18 ++++++++++++++++--
 1 file changed, 16 insertions(+), 2 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_training.c +0 -0
index 0c5b7816dfff9..77697a7619812 100644
@@ -1249,6 +1249,20 @@ intel_dp_128b132b_intra_hop(struct intel_dp *intel_dp,
 	return sink_status & DP_INTRA_HOP_AUX_REPLY_INDICATION ? 1 : 0;

drivers/gpu/drm/i915/display/intel_dp_link_training.c intel_dp_128b132b_intra_hop(struct intel_dp *intel_dp, · line 1259

Quoted 10 lines
drivers/gpu/drm/i915/display/intel_dp_link_training.c +8 -0
 }
 
+/**
+ * link_recovery_autoretrain_pending - check for a pending automatic retraining
+ * @link_training: link training state
+ *
+ * Return:
+ * - %true  if automatic retraining is pending.
+ * - %false otherwise.
+ */

IMO static functions should almost never have kernel-doc formatted comments.

Note the "kernel-doc formatted". The kernel-doc format requires you to add a bunch of boilerplate that's only really relevant if you're pulling the documentation comment into part of the Sphinx documentation build.

Here, I don't think the documentation comment adds anything that the name of the function doesn't say already. Really.

What's worse, none of the documentation or commit messages in the entire series explain what "autoretrain" or "automatic retrain" mean! It's a concept the series introduces and uses like it's the most natural thing, but doesn't explain!

(Yeah, folks can figure it out by reading the code, but shouldn't have to.)

All that aside, I'm very much in favour of adding functions like this so that the name of the function makes the code self-documenting.

BR,
Jani.

Quoted 27 lines
drivers/gpu/drm/i915/display/intel_dp_link_training.c +8 -2
+static bool
+link_recovery_autoretrain_pending(struct intel_dp_link_training *link_training)
+{
+	return link_training->seq_train_failures == 1;
+}
+
 /**
  * intel_dp_stop_link_train - stop link training
  * @intel_dp: DP struct
@@ -1290,7 +1304,7 @@ void intel_dp_stop_link_train(struct intel_dp *intel_dp,
 
 	if (!display->hotplug.ignore_long_hpd &&
 	    link_training->seq_train_failures < MAX_SEQ_TRAIN_FAILURES) {
-		int delay_ms = link_training->seq_train_failures == 1 ? 0 : 2000;
+		int delay_ms = link_recovery_autoretrain_pending(link_training) ? 0 : 2000;
 
 		intel_encoder_link_check_queue_work(encoder, delay_ms);
 	}
@@ -1991,7 +2005,7 @@ intel_dp_needs_link_retrain(struct intel_dp *intel_dp)
 	if (link_training->seq_train_failures >= MAX_SEQ_TRAIN_FAILURES)
 		return false;
 
-	if (link_training->seq_train_failures == 1)
+	if (link_recovery_autoretrain_pending(link_training))
 		return true;
 
 	/* Retrain if link not ok */
Signature · 1 line
Jani Nikula, Intel
author
#25 lore raw

Re: [PATCH 015/108] drm/i915/dp_link_training: Add helper to query pending autoretrain

Quoted 32 lines · Jani Nikula
Quoted 17 lines · Imre Deak

Add link_recovery_autoretrain_pending() to make it clearer what the condition is about at its callers: an autoretrain work has been queued.

This also prepares for replacing the sequential link training failure counter with an enum in a follow-up change.

---
 .../drm/i915/display/intel_dp_link_training.c  | 18 ++++++++++++++++--
 1 file changed, 16 insertions(+), 2 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_training.c +0 -0
index 0c5b7816dfff9..77697a7619812 100644
@@ -1249,6 +1249,20 @@ intel_dp_128b132b_intra_hop(struct intel_dp *intel_dp,
 	return sink_status & DP_INTRA_HOP_AUX_REPLY_INDICATION ? 1 : 0;

drivers/gpu/drm/i915/display/intel_dp_link_training.c intel_dp_128b132b_intra_hop(struct intel_dp *intel_dp, · line 1259

Quoted 10 lines
drivers/gpu/drm/i915/display/intel_dp_link_training.c +8 -0
 }
 
+/**
+ * link_recovery_autoretrain_pending - check for a pending automatic retraining
+ * @link_training: link training state
+ *
+ * Return:
+ * - %true  if automatic retraining is pending.
+ * - %false otherwise.
+ */

IMO static functions should almost never have kernel-doc formatted comments.

Quoted 6 lines

Note the "kernel-doc formatted". The kernel-doc format requires you to add a bunch of boilerplate that's only really relevant if you're pulling the documentation comment into part of the Sphinx documentation build.

Here, I don't think the documentation comment adds anything that the name of the function doesn't say already. Really.

Agreed, I will remove this function documention and convert all the kernel-doc formatted ones to be simple code comments (where I see a separate documentation called for).

Quoted 5 lines

What's worse, none of the documentation or commit messages in the entire series explain what "autoretrain" or "automatic retrain" mean! It's a concept the series introduces and uses like it's the most natural thing, but doesn't explain!

Yes, autoretrain has a very specific meaning and it's documented later in detail in:

[PATCH 026/108] drm/i915/dp_link_training: Document DP link recovery logic

Quoted 41 lines

(Yeah, folks can figure it out by reading the code, but shouldn't have to.)

All that aside, I'm very much in favour of adding functions like this so that the name of the function makes the code self-documenting.

BR,
Jani.

Quoted 27 lines
drivers/gpu/drm/i915/display/intel_dp_link_training.c +8 -2
+static bool
+link_recovery_autoretrain_pending(struct intel_dp_link_training *link_training)
+{
+	return link_training->seq_train_failures == 1;
+}
+
 /**
  * intel_dp_stop_link_train - stop link training
  * @intel_dp: DP struct
@@ -1290,7 +1304,7 @@ void intel_dp_stop_link_train(struct intel_dp *intel_dp,
 
 	if (!display->hotplug.ignore_long_hpd &&
 	    link_training->seq_train_failures < MAX_SEQ_TRAIN_FAILURES) {
-		int delay_ms = link_training->seq_train_failures == 1 ? 0 : 2000;
+		int delay_ms = link_recovery_autoretrain_pending(link_training) ? 0 : 2000;
 
 		intel_encoder_link_check_queue_work(encoder, delay_ms);
 	}
@@ -1991,7 +2005,7 @@ intel_dp_needs_link_retrain(struct intel_dp *intel_dp)
 	if (link_training->seq_train_failures >= MAX_SEQ_TRAIN_FAILURES)
 		return false;
 
-	if (link_training->seq_train_failures == 1)
+	if (link_recovery_autoretrain_pending(link_training))
 		return true;
 
 	/* Retrain if link not ok */
Signature · 1 line
Jani Nikula, Intel
author
#26 lore raw

PATCH 16/108 drm/i915/dp_link_training: Add helper to query allowed autoretrain

In reply to Imre Deak

Add link_recovery_autoretrain_allowed() to make it clearer what the condition is about at its callers: queuing work for and starting an autoretrain is allowed.

This also prepares for replacing the sequential link training failure counter with an enum in a follow-up change.

---
 .../drm/i915/display/intel_dp_link_training.c | 22 +++++++++++++++----
 1 file changed, 18 insertions(+), 4 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_training.c +18 -4
index 77697a7619812..1c2cef7d61f37 100644
@@ -1263,6 +1263,20 @@ link_recovery_autoretrain_pending(struct intel_dp_link_training *link_training)
 	return link_training->seq_train_failures == 1;
 }
 
+/**
+ * link_recovery_autoretrain_allowed - check for an allowed automatic retraining
+ * @link_training: link training state
+ *
+ * Return:
+ * - %true  if automatic retraining is allowed.
+ * - %false otherwise.
+ */
+static bool
+link_recovery_autoretrain_allowed(struct intel_dp_link_training *link_training)
+{
+	return link_training->seq_train_failures < MAX_SEQ_TRAIN_FAILURES;
+}
+
 /**
  * intel_dp_stop_link_train - stop link training
  * @intel_dp: DP struct
@@ -1303,7 +1317,7 @@ void intel_dp_stop_link_train(struct intel_dp *intel_dp,
 	intel_hpd_unblock(encoder);
 
 	if (!display->hotplug.ignore_long_hpd &&
-	    link_training->seq_train_failures < MAX_SEQ_TRAIN_FAILURES) {
+	    link_recovery_autoretrain_allowed(link_training)) {
 		int delay_ms = link_recovery_autoretrain_pending(link_training) ? 0 : 2000;
 
 		intel_encoder_link_check_queue_work(encoder, delay_ms);
@@ -1830,7 +1844,7 @@ void intel_dp_start_link_train(struct intel_atomic_state *state,
 		return;
 	}
 
-	if (link_training->seq_train_failures < MAX_SEQ_TRAIN_FAILURES)
+	if (link_recovery_autoretrain_allowed(link_training))
 		link_training->seq_train_failures++;
 
 	/*
@@ -1850,7 +1864,7 @@ void intel_dp_start_link_train(struct intel_atomic_state *state,
 		return;
 	}
 
-	if (link_training->seq_train_failures < MAX_SEQ_TRAIN_FAILURES)
+	if (link_recovery_autoretrain_allowed(link_training))
 		return;
 
 	if (intel_dp_schedule_fallback_link_training(state, intel_dp, crtc_state))
@@ -2002,7 +2016,7 @@ intel_dp_needs_link_retrain(struct intel_dp *intel_dp)
 					intel_dp->lane_count))
 		return false;
 
-	if (link_training->seq_train_failures >= MAX_SEQ_TRAIN_FAILURES)
+	if (!link_recovery_autoretrain_allowed(link_training))
 		return false;
 
 	if (link_recovery_autoretrain_pending(link_training))
Signature · 1 line
2.49.1
maintainer
#27 lore raw

Re: [PATCH 016/108] drm/i915/dp_link_training: Add helper to query allowed autoretrain

Quoted 18 lines · Imre Deak

Add link_recovery_autoretrain_allowed() to make it clearer what the condition is about at its callers: queuing work for and starting an autoretrain is allowed.

This also prepares for replacing the sequential link training failure counter with an enum in a follow-up change.

---
 .../drm/i915/display/intel_dp_link_training.c | 22 +++++++++++++++----
 1 file changed, 18 insertions(+), 4 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_training.c +0 -0
index 77697a7619812..1c2cef7d61f37 100644
@@ -1263,6 +1263,20 @@ link_recovery_autoretrain_pending(struct intel_dp_link_training *link_training)
 	return link_training->seq_train_failures == 1;

drivers/gpu/drm/i915/display/intel_dp_link_training.c link_recovery_autoretrain_pending(struct intel_dp_link_training *link_training) · line 1273

Quoted 10 lines
drivers/gpu/drm/i915/display/intel_dp_link_training.c +8 -0
 }
 
+/**
+ * link_recovery_autoretrain_allowed - check for an allowed automatic retraining
+ * @link_training: link training state
+ *
+ * Return:
+ * - %true  if automatic retraining is allowed.
+ * - %false otherwise.
+ */

But what does it mean that retraining is allowed? When is it forbidden?

Again, the kernel-doc explains the same thing that's already obvious from the function name, it provides no new information, but fails to explain the first question that pops to my mind.

Quoted 19 lines
drivers/gpu/drm/i915/display/intel_dp_link_training.c +7 -1
+static bool
+link_recovery_autoretrain_allowed(struct intel_dp_link_training *link_training)
+{
+	return link_training->seq_train_failures < MAX_SEQ_TRAIN_FAILURES;
+}
+
 /**
  * intel_dp_stop_link_train - stop link training
  * @intel_dp: DP struct
@@ -1303,7 +1317,7 @@ void intel_dp_stop_link_train(struct intel_dp *intel_dp,
 	intel_hpd_unblock(encoder);
 
 	if (!display->hotplug.ignore_long_hpd &&
-	    link_training->seq_train_failures < MAX_SEQ_TRAIN_FAILURES) {
+	    link_recovery_autoretrain_allowed(link_training)) {
 		int delay_ms = link_recovery_autoretrain_pending(link_training) ? 0 : 2000;
 
 		intel_encoder_link_check_queue_work(encoder, delay_ms);

drivers/gpu/drm/i915/display/intel_dp_link_training.c void intel_dp_start_link_train(struct intel_atomic_state *state, · line 1848

Quoted 6 lines
drivers/gpu/drm/i915/display/intel_dp_link_training.c +1 -1
@@ -1830,7 +1844,7 @@ void intel_dp_start_link_train(struct intel_atomic_state *state,
 		return;
 	}
 
-	if (link_training->seq_train_failures < MAX_SEQ_TRAIN_FAILURES)
+	if (link_recovery_autoretrain_allowed(link_training))
 		link_training->seq_train_failures++;

This reads *really* funny now. As if the failure count can only increase if autoretrain is allowed. What?

Quoted 20 lines
drivers/gpu/drm/i915/display/intel_dp_link_training.c +2 -2
 	/*
@@ -1850,7 +1864,7 @@ void intel_dp_start_link_train(struct intel_atomic_state *state,
 		return;
 	}
 
-	if (link_training->seq_train_failures < MAX_SEQ_TRAIN_FAILURES)
+	if (link_recovery_autoretrain_allowed(link_training))
 		return;
 
 	if (intel_dp_schedule_fallback_link_training(state, intel_dp, crtc_state))
@@ -2002,7 +2016,7 @@ intel_dp_needs_link_retrain(struct intel_dp *intel_dp)
 					intel_dp->lane_count))
 		return false;
 
-	if (link_training->seq_train_failures >= MAX_SEQ_TRAIN_FAILURES)
+	if (!link_recovery_autoretrain_allowed(link_training))
 		return false;
 
 	if (link_recovery_autoretrain_pending(link_training))
Signature · 1 line
Jani Nikula, Intel
author
#28 lore raw

Re: [PATCH 016/108] drm/i915/dp_link_training: Add helper to query allowed autoretrain

Quoted 21 lines · Jani Nikula
Quoted 20 lines · Imre Deak

Add link_recovery_autoretrain_allowed() to make it clearer what the condition is about at its callers: queuing work for and starting an autoretrain is allowed.

This also prepares for replacing the sequential link training failure counter with an enum in a follow-up change.

---
 .../drm/i915/display/intel_dp_link_training.c | 22 +++++++++++++++----
 1 file changed, 18 insertions(+), 4 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_training.c +0 -0
index 77697a7619812..1c2cef7d61f37 100644
@@ -1263,6 +1263,20 @@ link_recovery_autoretrain_pending(struct intel_dp_link_training *link_training)
 	return link_training->seq_train_failures == 1;
 }
 
Quoted 10 lines

drivers/gpu/drm/i915/display/intel_dp_link_training.c link_recovery_autoretrain_pending(struct intel_dp_link_training *link_training) · line 1273

Quoted 8 lines
drivers/gpu/drm/i915/display/intel_dp_link_training.c +8 -0
+/**
+ * link_recovery_autoretrain_allowed - check for an allowed automatic retraining
+ * @link_training: link training state
+ *
+ * Return:
+ * - %true  if automatic retraining is allowed.
+ * - %false otherwise.
+ */

But what does it mean that retraining is allowed? When is it forbidden?

It's allowed when an automatic retraining is possible. The conditions for that are explained later in

[PATCH 026/108] drm/i915/dp_link_training: Document DP link recovery logic

I'll document here the part of that relevant to the function.

Quoted 56 lines

Again, the kernel-doc explains the same thing that's already obvious from the function name, it provides no new information, but fails to explain the first question that pops to my mind.

Quoted 19 lines
drivers/gpu/drm/i915/display/intel_dp_link_training.c +7 -1
+static bool
+link_recovery_autoretrain_allowed(struct intel_dp_link_training *link_training)
+{
+	return link_training->seq_train_failures < MAX_SEQ_TRAIN_FAILURES;
+}
+
 /**
  * intel_dp_stop_link_train - stop link training
  * @intel_dp: DP struct
@@ -1303,7 +1317,7 @@ void intel_dp_stop_link_train(struct intel_dp *intel_dp,
 	intel_hpd_unblock(encoder);
 
 	if (!display->hotplug.ignore_long_hpd &&
-	    link_training->seq_train_failures < MAX_SEQ_TRAIN_FAILURES) {
+	    link_recovery_autoretrain_allowed(link_training)) {
 		int delay_ms = link_recovery_autoretrain_pending(link_training) ? 0 : 2000;
 
 		intel_encoder_link_check_queue_work(encoder, delay_ms);

drivers/gpu/drm/i915/display/intel_dp_link_training.c void intel_dp_start_link_train(struct intel_atomic_state *state, · line 1848

Quoted 6 lines
drivers/gpu/drm/i915/display/intel_dp_link_training.c +1 -1
@@ -1830,7 +1844,7 @@ void intel_dp_start_link_train(struct intel_atomic_state *state,
 		return;
 	}
 
-	if (link_training->seq_train_failures < MAX_SEQ_TRAIN_FAILURES)
+	if (link_recovery_autoretrain_allowed(link_training))
 		link_training->seq_train_failures++;

This reads *really* funny now. As if the failure count can only increase if autoretrain is allowed. What?

Quoted 20 lines
drivers/gpu/drm/i915/display/intel_dp_link_training.c +2 -2
 	/*
@@ -1850,7 +1864,7 @@ void intel_dp_start_link_train(struct intel_atomic_state *state,
 		return;
 	}
 
-	if (link_training->seq_train_failures < MAX_SEQ_TRAIN_FAILURES)
+	if (link_recovery_autoretrain_allowed(link_training))
 		return;
 
 	if (intel_dp_schedule_fallback_link_training(state, intel_dp, crtc_state))
@@ -2002,7 +2016,7 @@ intel_dp_needs_link_retrain(struct intel_dp *intel_dp)
 					intel_dp->lane_count))
 		return false;
 
-	if (link_training->seq_train_failures >= MAX_SEQ_TRAIN_FAILURES)
+	if (!link_recovery_autoretrain_allowed(link_training))
 		return false;
 
 	if (link_recovery_autoretrain_pending(link_training))
Signature · 1 line
Jani Nikula, Intel
author
#29 lore raw

PATCH 17/108 drm/i915/dp_link_training: Add helper to mark link training failure

In reply to Imre Deak

Add link_recovery_mark_train_failure() to record the failure and make the link recovery state transition explicit after a link training
failure: recovery can continue with an autoretrain, or must be handed over to userspace after fallback selection.

This also prepares for replacing the sequential link training failure counter with an enum in a follow-up change.

---
 .../drm/i915/display/intel_dp_link_training.c | 33 +++++++++++++++++--
 1 file changed, 30 insertions(+), 3 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_training.c +30 -3
index 1c2cef7d61f37..eb922dca69c5b 100644
@@ -1277,6 +1277,33 @@ link_recovery_autoretrain_allowed(struct intel_dp_link_training *link_training)
 	return link_training->seq_train_failures < MAX_SEQ_TRAIN_FAILURES;
 }
 
+/**
+ * link_recovery_mark_train_failure - record a link training failure
+ * @link_training: link training state
+ *
+ * Record a link training failure and advance the recovery state to
+ * indicate the next required recovery step.
+ *
+ * The caller must proceed with recovery as instructed by the return
+ * value, either via automatic retraining or, once automatic retraining
+ * is no longer possible, via userspace modesets after fallback
+ * selection.
+ *
+ * Return:
+ * - %true  if recovery should continue via automatic retraining.
+ * - %false if automatic retraining is no longer possible and recovery
+ *          must be delegated to userspace.
+ */
+static bool
+link_recovery_mark_train_failure(struct intel_dp_link_training *link_training)
+{
+	if (link_recovery_autoretrain_allowed(link_training))
+		/* Move to autoretrain pending or autoretrain disabled state. */
+		link_training->seq_train_failures++;
+
+	return link_recovery_autoretrain_allowed(link_training);
+}
+
 /**
  * intel_dp_stop_link_train - stop link training
  * @intel_dp: DP struct
@@ -1813,6 +1840,7 @@ void intel_dp_start_link_train(struct intel_atomic_state *state,
 	struct intel_encoder *encoder = &dig_port->base;
 	struct intel_dp_link_training *link_training =
 		intel_dp->link.training;
+	bool can_autoretrain;
 	bool passed;
 	/*
 	 * Reinit the LTTPRs here to ensure that they are switched to
@@ -1844,8 +1872,7 @@ void intel_dp_start_link_train(struct intel_atomic_state *state,
 		return;
 	}
 
-	if (link_recovery_autoretrain_allowed(link_training))
-		link_training->seq_train_failures++;
+	can_autoretrain = link_recovery_mark_train_failure(link_training);
 
 	/*
 	 * Ignore the link failure in CI
@@ -1864,7 +1891,7 @@ void intel_dp_start_link_train(struct intel_atomic_state *state,
 		return;
 	}
 
-	if (link_recovery_autoretrain_allowed(link_training))
+	if (can_autoretrain)
 		return;
 
 	if (intel_dp_schedule_fallback_link_training(state, intel_dp, crtc_state))
Signature · 1 line
2.49.1
maintainer
#30 lore raw

Re: [PATCH 017/108] drm/i915/dp_link_training: Add helper to mark link training failure

Quoted 32 lines · Imre Deak

Add link_recovery_mark_train_failure() to record the failure and make the link recovery state transition explicit after a link training
failure: recovery can continue with an autoretrain, or must be handed over to userspace after fallback selection.

This also prepares for replacing the sequential link training failure counter with an enum in a follow-up change.

---
 .../drm/i915/display/intel_dp_link_training.c | 33 +++++++++++++++++--
 1 file changed, 30 insertions(+), 3 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_training.c +11 -0
index 1c2cef7d61f37..eb922dca69c5b 100644
@@ -1277,6 +1277,33 @@ link_recovery_autoretrain_allowed(struct intel_dp_link_training *link_training)
 	return link_training->seq_train_failures < MAX_SEQ_TRAIN_FAILURES;
 }
 
+/**
+ * link_recovery_mark_train_failure - record a link training failure
+ * @link_training: link training state
+ *
+ * Record a link training failure and advance the recovery state to
+ * indicate the next required recovery step.
+ *
+ * The caller must proceed with recovery as instructed by the return
+ * value, either via automatic retraining or, once automatic retraining
+ * is no longer possible, via userspace modesets after fallback
+ * selection.

drivers/gpu/drm/i915/display/intel_dp_link_training.c link_recovery_autoretrain_allowed(struct intel_dp_link_training *link_training) · line 1300

Quoted 10 lines
drivers/gpu/drm/i915/display/intel_dp_link_training.c +10 -0
+ *
+ * Return:
+ * - %true  if recovery should continue via automatic retraining.
+ * - %false if automatic retraining is no longer possible and recovery
+ *          must be delegated to userspace.
+ */
+static bool
+link_recovery_mark_train_failure(struct intel_dp_link_training *link_training)
+{
+	if (link_recovery_autoretrain_allowed(link_training))

Yeah, I still think combining the above check with the below reads wrong.

Quoted 18 lines
drivers/gpu/drm/i915/display/intel_dp_link_training.c +7 -0
+		/* Move to autoretrain pending or autoretrain disabled state. */
+		link_training->seq_train_failures++;
+
+	return link_recovery_autoretrain_allowed(link_training);
+}
+
 /**
  * intel_dp_stop_link_train - stop link training
  * @intel_dp: DP struct
@@ -1813,6 +1840,7 @@ void intel_dp_start_link_train(struct intel_atomic_state *state,
 	struct intel_encoder *encoder = &dig_port->base;
 	struct intel_dp_link_training *link_training =
 		intel_dp->link.training;
+	bool can_autoretrain;
 	bool passed;
 	/*
 	 * Reinit the LTTPRs here to ensure that they are switched to

drivers/gpu/drm/i915/display/intel_dp_link_training.c void intel_dp_start_link_train(struct intel_atomic_state *state, · line 1875

Quoted 6 lines
drivers/gpu/drm/i915/display/intel_dp_link_training.c +1 -2
@@ -1844,8 +1872,7 @@ void intel_dp_start_link_train(struct intel_atomic_state *state,
 		return;
 	}
 
-	if (link_recovery_autoretrain_allowed(link_training))
-		link_training->seq_train_failures++;
+	can_autoretrain = link_recovery_mark_train_failure(link_training);

The documentation says "the caller must" but the variable says "can".

Maybe the code here would read better if this wasn't conveyed in the return value but rather in a separate call to link_recovery_autoretrain_allowed().

Or should it be link_recovery_must_autoretrain() or link_recovery_need_autoretrain()?

BR,
Jani.

Quoted 12 lines
drivers/gpu/drm/i915/display/intel_dp_link_training.c +1 -1
 	/*
 	 * Ignore the link failure in CI
@@ -1864,7 +1891,7 @@ void intel_dp_start_link_train(struct intel_atomic_state *state,
 		return;
 	}
 
-	if (link_recovery_autoretrain_allowed(link_training))
+	if (can_autoretrain)
 		return;
 
 	if (intel_dp_schedule_fallback_link_training(state, intel_dp, crtc_state))
Signature · 1 line
Jani Nikula, Intel
author
#31 lore raw

Re: [PATCH 017/108] drm/i915/dp_link_training: Add helper to mark link training failure

Quoted 38 lines · Jani Nikula
Quoted 37 lines · Imre Deak

Add link_recovery_mark_train_failure() to record the failure and make the link recovery state transition explicit after a link training
failure: recovery can continue with an autoretrain, or must be handed over to userspace after fallback selection.

This also prepares for replacing the sequential link training failure counter with an enum in a follow-up change.

---
 .../drm/i915/display/intel_dp_link_training.c | 33 +++++++++++++++++--
 1 file changed, 30 insertions(+), 3 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_training.c +16 -0
index 1c2cef7d61f37..eb922dca69c5b 100644
@@ -1277,6 +1277,33 @@ link_recovery_autoretrain_allowed(struct intel_dp_link_training *link_training)
 	return link_training->seq_train_failures < MAX_SEQ_TRAIN_FAILURES;
 }
 
+/**
+ * link_recovery_mark_train_failure - record a link training failure
+ * @link_training: link training state
+ *
+ * Record a link training failure and advance the recovery state to
+ * indicate the next required recovery step.
+ *
+ * The caller must proceed with recovery as instructed by the return
+ * value, either via automatic retraining or, once automatic retraining
+ * is no longer possible, via userspace modesets after fallback
+ * selection.
+ *
+ * Return:
+ * - %true  if recovery should continue via automatic retraining.
+ * - %false if automatic retraining is no longer possible and recovery
+ *          must be delegated to userspace.
Quoted 8 lines

drivers/gpu/drm/i915/display/intel_dp_link_training.c link_recovery_autoretrain_allowed(struct intel_dp_link_training *link_training) · line 1300

Quoted 5 lines
drivers/gpu/drm/i915/display/intel_dp_link_training.c +5 -0
+ */
+static bool
+link_recovery_mark_train_failure(struct intel_dp_link_training *link_training)
+{
+	if (link_recovery_autoretrain_allowed(link_training))

Yeah, I still think combining the above check with the below reads wrong.

To me it does read understandably once the plain seq_train_failures int is converted to an enum which indicates the point in the recovery
sequence: the function is called after a link training failure, reflected by the function name. The function then advances the recovery state in the recovery sequence, expressed by the state++ line below, either to the autoretrain pending or the autoretrain disabled state. The function's return value indicates to the caller what it should do next, depending on the new state determined by the function:

- If it's the autoretrain pending state the caller should perform an autoretrain to recover the link.

- If it's the autoretrain disabled state the caller should - instead of an autoretrain - fall back to a userspace driven link recovery.

Quoted 28 lines
Quoted 19 lines
drivers/gpu/drm/i915/display/intel_dp_link_training.c +7 -0
+		/* Move to autoretrain pending or autoretrain disabled state. */
+		link_training->seq_train_failures++;
+
+	return link_recovery_autoretrain_allowed(link_training);
+}
+
 /**
  * intel_dp_stop_link_train - stop link training
  * @intel_dp: DP struct
@@ -1813,6 +1840,7 @@ void intel_dp_start_link_train(struct intel_atomic_state *state,
 	struct intel_encoder *encoder = &dig_port->base;
 	struct intel_dp_link_training *link_training =
 		intel_dp->link.training;
+	bool can_autoretrain;
 	bool passed;
 	/*
 	 * Reinit the LTTPRs here to ensure that they are switched to

drivers/gpu/drm/i915/display/intel_dp_link_training.c void intel_dp_start_link_train(struct intel_atomic_state *state, · line 1875

Quoted 6 lines
drivers/gpu/drm/i915/display/intel_dp_link_training.c +1 -2
@@ -1844,8 +1872,7 @@ void intel_dp_start_link_train(struct intel_atomic_state *state,
 		return;
 	}
 
-	if (link_recovery_autoretrain_allowed(link_training))
-		link_training->seq_train_failures++;
+	can_autoretrain = link_recovery_mark_train_failure(link_training);

The documentation says "the caller must" but the variable says "can".

Quoted 6 lines

Maybe the code here would read better if this wasn't conveyed in the return value but rather in a separate call to link_recovery_autoretrain_allowed().

Or should it be link_recovery_must_autoretrain() or link_recovery_need_autoretrain()?

Imo link_recovery_autoretrain_allowed() expresses it what the caller should do:

- If autoretrain is allowed the caller here should perform auto retraining (i.e. return from the function without a fallback selection and userspace notification which would instead switch to a userspace driven link recovery).

- If autoretrain is not allowed the caller here should do a fallback selection and notify userspace to take over the link recovery.

To me it also makes sense to express what is the next expected step by the caller by returning this expected step from link_recovery_autoretrain_allowed() function directly where the function determined this expected step.

I can rename the can_autoretrain flag to autoretrain_allowed to be closer to the function's return value.

If the above doesn't make sense to you I can also just call link_recovery_autoretrain_allowed() from this function directly instead of returning that value from link_recovery_mark_train_failure().

Quoted 19 lines

BR,
Jani.

Quoted 12 lines
drivers/gpu/drm/i915/display/intel_dp_link_training.c +1 -1
 	/*
 	 * Ignore the link failure in CI
@@ -1864,7 +1891,7 @@ void intel_dp_start_link_train(struct intel_atomic_state *state,
 		return;
 	}
 
-	if (link_recovery_autoretrain_allowed(link_training))
+	if (can_autoretrain)
 		return;
 
 	if (intel_dp_schedule_fallback_link_training(state, intel_dp, crtc_state))
Signature · 1 line
Jani Nikula, Intel
author
#32 lore raw

PATCH 18/108 drm/i915/dp_link_training: Add helper to reset link recovery state

In reply to Imre Deak

Add link_recovery_reset() to make it explicit when link recovery is no longer needed and the recovery state can be cleared.

This also prepares for replacing the sequential link training failure counter with an enum in a follow-up change.

---
 .../drm/i915/display/intel_dp_link_training.c    | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_training.c +14 -2
index eb922dca69c5b..90bd1b0f1ab7d 100644
@@ -1304,6 +1304,18 @@ link_recovery_mark_train_failure(struct intel_dp_link_training *link_training)
 	return link_recovery_autoretrain_allowed(link_training);
 }
 
+/**
+ * link_recovery_reset - reset the link recovery state
+ * @link_training: link training state
+ *
+ * Reset the link recovery state to indicate that no link recovery is
+ * required.
+ */
+static void link_recovery_reset(struct intel_dp_link_training *link_training)
+{
+	link_training->seq_train_failures = 0;
+}
+
 /**
  * intel_dp_stop_link_train - stop link training
  * @intel_dp: DP struct
@@ -1868,7 +1880,7 @@ void intel_dp_start_link_train(struct intel_atomic_state *state,
 		link_training->force_train_failure--;
 		lt_dbg(intel_dp, DP_PHY_DPRX, "Forcing link training failure\n");
 	} else if (passed) {
-		link_training->seq_train_failures = 0;
+		link_recovery_reset(link_training);
 		return;
 	}
 
@@ -2538,7 +2550,7 @@ void intel_dp_link_training_debugfs_add(struct intel_connector *connector)
 void intel_dp_link_training_reset(struct intel_dp_link_training *link_training)
 {
 	link_training->retrain_disabled = false;
-	link_training->seq_train_failures = 0;
+	link_recovery_reset(link_training);
 }
 
 /**
Signature · 1 line
2.49.1
maintainer
#33 lore raw

Re: [PATCH 018/108] drm/i915/dp_link_training: Add helper to reset link recovery state

Quoted 16 lines · Imre Deak

Add link_recovery_reset() to make it explicit when link recovery is no longer needed and the recovery state can be cleared.

This also prepares for replacing the sequential link training failure counter with an enum in a follow-up change.

---
 .../drm/i915/display/intel_dp_link_training.c    | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_training.c +0 -0
index eb922dca69c5b..90bd1b0f1ab7d 100644

drivers/gpu/drm/i915/display/intel_dp_link_training.c link_recovery_mark_train_failure(struct intel_dp_link_training *link_training) · line 1312

Quoted 9 lines
drivers/gpu/drm/i915/display/intel_dp_link_training.c +6 -0
@@ -1304,6 +1304,18 @@ link_recovery_mark_train_failure(struct intel_dp_link_training *link_training)
 	return link_recovery_autoretrain_allowed(link_training);
 }
 
+/**
+ * link_recovery_reset - reset the link recovery state
+ * @link_training: link training state
+ *
+ * Reset the link recovery state to indicate that no link recovery is
+ * required.

What's link recovery? Same as autoretrain? Different? It operates on the same variable as autoretrain. Confused.

BR,
Jani.

Quoted 27 lines
drivers/gpu/drm/i915/display/intel_dp_link_training.c +8 -2
+ */
+static void link_recovery_reset(struct intel_dp_link_training *link_training)
+{
+	link_training->seq_train_failures = 0;
+}
+
 /**
  * intel_dp_stop_link_train - stop link training
  * @intel_dp: DP struct
@@ -1868,7 +1880,7 @@ void intel_dp_start_link_train(struct intel_atomic_state *state,
 		link_training->force_train_failure--;
 		lt_dbg(intel_dp, DP_PHY_DPRX, "Forcing link training failure\n");
 	} else if (passed) {
-		link_training->seq_train_failures = 0;
+		link_recovery_reset(link_training);
 		return;
 	}
 
@@ -2538,7 +2550,7 @@ void intel_dp_link_training_debugfs_add(struct intel_connector *connector)
 void intel_dp_link_training_reset(struct intel_dp_link_training *link_training)
 {
 	link_training->retrain_disabled = false;
-	link_training->seq_train_failures = 0;
+	link_recovery_reset(link_training);
 }
 
 /**
Signature · 1 line
Jani Nikula, Intel
author
#34 lore raw

Re: [PATCH 018/108] drm/i915/dp_link_training: Add helper to reset link recovery state

Quoted 20 lines · Jani Nikula
Quoted 19 lines · Imre Deak

Add link_recovery_reset() to make it explicit when link recovery is no longer needed and the recovery state can be cleared.

This also prepares for replacing the sequential link training failure counter with an enum in a follow-up change.

---
 .../drm/i915/display/intel_dp_link_training.c    | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_training.c +0 -0
index eb922dca69c5b..90bd1b0f1ab7d 100644
@@ -1304,6 +1304,18 @@ link_recovery_mark_train_failure(struct intel_dp_link_training *link_training)
 	return link_recovery_autoretrain_allowed(link_training);
 }
 
Quoted 8 lines

drivers/gpu/drm/i915/display/intel_dp_link_training.c link_recovery_mark_train_failure(struct intel_dp_link_training *link_training) · line 1312

Quoted 6 lines
drivers/gpu/drm/i915/display/intel_dp_link_training.c +6 -0
+/**
+ * link_recovery_reset - reset the link recovery state
+ * @link_training: link training state
+ *
+ * Reset the link recovery state to indicate that no link recovery is
+ * required.

What's link recovery? Same as autoretrain? Different?

Link recovery is the mechanism to recover the DP link after a link training failure, either via the driver's autoretrain or if that's not possbile via userspace modesets. This should be also explained in detail in the link recovery DOC.

Quoted 1 line

It operates on the > same variable as autoretrain. Confused.

The seq_train_failure counter is converted later to an enum, to better express what it actaully is: it's indicating the current state in the link recovery sequence. The sequence should be also explained in detail by the link recovery DOC and the new enum's documentation.

Quoted 34 lines

BR,
Jani.

Quoted 27 lines
drivers/gpu/drm/i915/display/intel_dp_link_training.c +8 -2
+ */
+static void link_recovery_reset(struct intel_dp_link_training *link_training)
+{
+	link_training->seq_train_failures = 0;
+}
+
 /**
  * intel_dp_stop_link_train - stop link training
  * @intel_dp: DP struct
@@ -1868,7 +1880,7 @@ void intel_dp_start_link_train(struct intel_atomic_state *state,
 		link_training->force_train_failure--;
 		lt_dbg(intel_dp, DP_PHY_DPRX, "Forcing link training failure\n");
 	} else if (passed) {
-		link_training->seq_train_failures = 0;
+		link_recovery_reset(link_training);
 		return;
 	}
 
@@ -2538,7 +2550,7 @@ void intel_dp_link_training_debugfs_add(struct intel_connector *connector)
 void intel_dp_link_training_reset(struct intel_dp_link_training *link_training)
 {
 	link_training->retrain_disabled = false;
-	link_training->seq_train_failures = 0;
+	link_recovery_reset(link_training);
 }
 
 /**
Signature · 1 line
Jani Nikula, Intel
author
#35 lore raw

PATCH 19/108 drm/i915/dp_link_training: Track link recovery state with an enum

In reply to Imre Deak

Replace the sequential link training failure counter with an explicit link recovery state enum.

This makes the recovery states and transitions clearer: idle, automatic retraining pending, and automatic retraining disabled.

A follow-up change will also move the retrain_disabled flag into this enum.

---
 .../drm/i915/display/intel_dp_link_training.c | 55 ++++++++++++++++---
 1 file changed, 48 insertions(+), 7 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_training.c +48 -7
index 90bd1b0f1ab7d..c44416e0e328f 100644
@@ -61,14 +61,54 @@
 		lt_dbg(_intel_dp, _dp_phy, "Sink disconnected: " _format, ## __VA_ARGS__); \
 } while (0)
 
-#define MAX_SEQ_TRAIN_FAILURES 2
+/**
+ * enum intel_dp_link_recovery_state - LT recovery state
+ * @INTEL_DP_LINK_RECOVERY_IDLE:
+ *   No link training failure is currently tracked and no recovery is
+ *   in progress. This is the initial state after driver initialization,
+ *   power state transitions, sink (re-)connection, or after a successful
+ *   link training.
+ *
+ * @INTEL_DP_LINK_RECOVERY_AUTORETRAIN_PENDING:
+ *   A first link training failure has been observed and an automatic
+ *   retraining attempt with the same link parameters is pending. Exactly
+ *   one such attempt is allowed before switching to userspace-driven
+ *   recovery.
+ *
+ * @INTEL_DP_LINK_RECOVERY_AUTORETRAIN_DISABLED:
+ *   Automatic retraining is no longer possible. At this point, a
+ *   fallback selection is made and userspace is notified to take over
+ *   recovery, performing modesets with parameters it determines are
+ *   required. The driver then selects a link configuration from the
+ *   remaining fallback configuration set. Subsequent link training
+ *   failures trigger further fallback selections and userspace
+ *   notifications.
+ *
+ * Describes the link recovery state used by the Intel DP link recovery
+ * logic.
+ *
+ * See also:
+ *   - link_recovery_autoretrain_pending()
+ *   - link_recovery_autoretrain_allowed()
+ *   - link_recovery_mark_train_failure()
+ *   - link_recovery_reset()
+ */
+enum intel_dp_link_recovery_state {
+	/*
+	 * Keep the enum values ordered from least to most severe
+	 * recovery state; helper logic relies on that ordering.
+	 */
+	INTEL_DP_LINK_RECOVERY_IDLE,
+	INTEL_DP_LINK_RECOVERY_AUTORETRAIN_PENDING,
+	INTEL_DP_LINK_RECOVERY_AUTORETRAIN_DISABLED,
+};
 
 struct intel_dp_link_training {
 	struct intel_dp *dp;
 
+	enum intel_dp_link_recovery_state recovery_state;
+
 	bool retrain_disabled;
-	/* Sequential link training failures after a passing LT */
-	int seq_train_failures;
 	int force_train_failure;
 	bool force_retrain;
 };
@@ -1260,7 +1300,7 @@ intel_dp_128b132b_intra_hop(struct intel_dp *intel_dp,
 static bool
 link_recovery_autoretrain_pending(struct intel_dp_link_training *link_training)
 {
-	return link_training->seq_train_failures == 1;
+	return link_training->recovery_state == INTEL_DP_LINK_RECOVERY_AUTORETRAIN_PENDING;
 }
 
 /**
@@ -1274,7 +1314,7 @@ link_recovery_autoretrain_pending(struct intel_dp_link_training *link_training)
 static bool
 link_recovery_autoretrain_allowed(struct intel_dp_link_training *link_training)
 {
-	return link_training->seq_train_failures < MAX_SEQ_TRAIN_FAILURES;
+	return link_training->recovery_state < INTEL_DP_LINK_RECOVERY_AUTORETRAIN_DISABLED;
 }
 
 /**
@@ -1299,11 +1339,12 @@ link_recovery_mark_train_failure(struct intel_dp_link_training *link_training)
 {
 	if (link_recovery_autoretrain_allowed(link_training))
 		/* Move to autoretrain pending or autoretrain disabled state. */
-		link_training->seq_train_failures++;
+		link_training->recovery_state++;
 
 	return link_recovery_autoretrain_allowed(link_training);
 }
 
+
 /**
  * link_recovery_reset - reset the link recovery state
  * @link_training: link training state
@@ -1313,7 +1354,7 @@ link_recovery_mark_train_failure(struct intel_dp_link_training *link_training)
  */
 static void link_recovery_reset(struct intel_dp_link_training *link_training)
 {
-	link_training->seq_train_failures = 0;
+	link_training->recovery_state = INTEL_DP_LINK_RECOVERY_IDLE;
 }
 
 /**
Signature · 1 line
2.49.1
#36 lore raw

Re: [PATCH 019/108] drm/i915/dp_link_training: Track link recovery state with an enum

Quoted 38 lines · Imre Deak

Replace the sequential link training failure counter with an explicit link recovery state enum.

This makes the recovery states and transitions clearer: idle, automatic
retraining pending, and automatic retraining disabled.

A follow-up change will also move the retrain_disabled flag into this enum.

---
 .../drm/i915/display/intel_dp_link_training.c | 55 ++++++++++++++++- --

 1 file changed, 48 insertions(+), 7 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_training.c +0 -0
index 90bd1b0f1ab7d..c44416e0e328f 100644
@@ -61,14 +61,54 @@

  lt_dbg(_intel_dp, _dp_phy, "Sink disconnected: " _format, ## __VA_ARGS__); \
 } while (0)

drivers/gpu/drm/i915/display/intel_dp_link_training.c +4 -1
-#define MAX_SEQ_TRAIN_FAILURES 2
+/**
+ * enum intel_dp_link_recovery_state - LT recovery state
+ * @INTEL_DP_LINK_RECOVERY_IDLE:
+ *   No link training failure is currently tracked and no recovery

is
+ *   in progress. This is the initial state after driver initialization,
+ *   power state transitions, sink (re-)connection, or after a successful
+ *   link training.
+ *

Quoted 8 lines

+ * @INTEL_DP_LINK_RECOVERY_AUTORETRAIN_PENDING:
+ *   A first link training failure has been observed and an automatic
+ *   retraining attempt with the same link parameters is pending. Exactly
+ *   one such attempt is allowed before switching to userspace- driven
+ *   recovery.

When running Link Layer fallback CTS for DP1.4, we noticed UCD500 complaints because we retry the same link parameters. In fact, we used to change:

#define MAX_SEQ_TRAIN_FAILURES 1

I expect the same complaint will happen in DP2.1 fallback CTS.

If I look at the following from the DP2.1 specs:
* Table 3-31: DPTX Fallback Mandates (Normative)
* Figure 3-12: Link Training LANEx_CR_DONE Sequence
* Figure 3-13: Link Training LANEx_CHANNEL_EQ_DONE Sequence
* Figure 3-14: Link Training LANEx_CR_DONE Sequence for Maximum Link Data Bandwidth Policy
* Figure 3-15: Link Training LANEx_CHANNEL_EQ_DONE Sequence for Maximum Link Data Bandwidth Policy

I do not see it retraining using the same link parameters. So, do you think we should make this configurable, maybe?

Thank You
Khaled

Quoted 94 lines

+ *
+ * @INTEL_DP_LINK_RECOVERY_AUTORETRAIN_DISABLED:
+ *   Automatic retraining is no longer possible. At this point, a
+ *   fallback selection is made and userspace is notified to take over
+ *   recovery, performing modesets with parameters it determines are
+ *   required. The driver then selects a link configuration from the
+ *   remaining fallback configuration set. Subsequent link training
+ *   failures trigger further fallback selections and userspace
+ *   notifications.
+ *
+ * Describes the link recovery state used by the Intel DP link recovery
+ * logic.
+ *
+ * See also:
+ *   - link_recovery_autoretrain_pending()
+ *   - link_recovery_autoretrain_allowed()
+ *   - link_recovery_mark_train_failure()
+ *   - link_recovery_reset()
+ */

drivers/gpu/drm/i915/display/intel_dp_link_training.c +9 -0
+enum intel_dp_link_recovery_state {
+	/*
+	 * Keep the enum values ordered from least to most severe
+	 * recovery state; helper logic relies on that ordering.
+	 */
+	INTEL_DP_LINK_RECOVERY_IDLE,
+	INTEL_DP_LINK_RECOVERY_AUTORETRAIN_PENDING,
+	INTEL_DP_LINK_RECOVERY_AUTORETRAIN_DISABLED,
+};


 struct intel_dp_link_training {
  struct intel_dp *dp;

drivers/gpu/drm/i915/display/intel_dp_link_training.c +2 -0
+	enum intel_dp_link_recovery_state recovery_state;
+

  bool retrain_disabled;

drivers/gpu/drm/i915/display/intel_dp_link_training.c +0 -2
-	/* Sequential link training failures after a passing LT */
-	int seq_train_failures;

  int force_train_failure;
  bool force_retrain;
 };

drivers/gpu/drm/i915/display/intel_dp_link_training.c +0 -0
@@ -1260,7 +1300,7 @@ intel_dp_128b132b_intra_hop(struct intel_dp
 *intel_dp,

 static bool
 link_recovery_autoretrain_pending(struct intel_dp_link_training *link_training)
 {

drivers/gpu/drm/i915/display/intel_dp_link_training.c +1 -1
-	return link_training->seq_train_failures == 1;
+	return link_training->recovery_state ==

INTEL_DP_LINK_RECOVERY_AUTORETRAIN_PENDING;
 }

 /**

drivers/gpu/drm/i915/display/intel_dp_link_training.c +0 -0
@@ -1274,7 +1314,7 @@ link_recovery_autoretrain_pending(struct
 intel_dp_link_training *link_training)

 static bool
 link_recovery_autoretrain_allowed(struct intel_dp_link_training *link_training)
 {

drivers/gpu/drm/i915/display/intel_dp_link_training.c +0 -1
-	return link_training->seq_train_failures <

MAX_SEQ_TRAIN_FAILURES;

drivers/gpu/drm/i915/display/intel_dp_link_training.c +1 -0
+	return link_training->recovery_state <

INTEL_DP_LINK_RECOVERY_AUTORETRAIN_DISABLED;
 }

 /**

drivers/gpu/drm/i915/display/intel_dp_link_training.c +0 -0
@@ -1299,11 +1339,12 @@ link_recovery_mark_train_failure(struct
 intel_dp_link_training *link_training)
  {
  	if (link_recovery_autoretrain_allowed(link_training))
  		/* Move to autoretrain pending or autoretrain

disabled state. */

drivers/gpu/drm/i915/display/intel_dp_link_training.c +1 -1
-		link_training->seq_train_failures++;
+		link_training->recovery_state++;


  return link_recovery_autoretrain_allowed(link_training); }

+
 /**
  * link_recovery_reset - reset the link recovery state
  * @link_training: link training state

drivers/gpu/drm/i915/display/intel_dp_link_training.c +0 -0
@@ -1313,7 +1354,7 @@ link_recovery_mark_train_failure(struct
 intel_dp_link_training *link_training)
   */

 static void link_recovery_reset(struct intel_dp_link_training *link_training)
 {

drivers/gpu/drm/i915/display/intel_dp_link_training.c +1 -1
-	link_training->seq_train_failures = 0;
+	link_training->recovery_state = INTEL_DP_LINK_RECOVERY_IDLE;

 }

 /**

author
#37 lore raw

Re: [PATCH 019/108] drm/i915/dp_link_training: Track link recovery state with an enum

Quoted 65 lines · Khaled
Quoted 38 lines · Imre Deak

Replace the sequential link training failure counter with an explicit link recovery state enum.

This makes the recovery states and transitions clearer: idle, automatic
retraining pending, and automatic retraining disabled.

A follow-up change will also move the retrain_disabled flag into this enum.

---
 .../drm/i915/display/intel_dp_link_training.c | 55 ++++++++++++++++- --

 1 file changed, 48 insertions(+), 7 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_training.c +0 -0
index 90bd1b0f1ab7d..c44416e0e328f 100644
@@ -61,14 +61,54 @@

  lt_dbg(_intel_dp, _dp_phy, "Sink disconnected: " _format, ## __VA_ARGS__); \
 } while (0)

drivers/gpu/drm/i915/display/intel_dp_link_training.c +4 -1
-#define MAX_SEQ_TRAIN_FAILURES 2
+/**
+ * enum intel_dp_link_recovery_state - LT recovery state
+ * @INTEL_DP_LINK_RECOVERY_IDLE:
+ *   No link training failure is currently tracked and no recovery

is
+ *   in progress. This is the initial state after driver initialization,
+ *   power state transitions, sink (re-)connection, or after a successful
+ *   link training.
+ *

Quoted 8 lines

+ * @INTEL_DP_LINK_RECOVERY_AUTORETRAIN_PENDING:
+ *   A first link training failure has been observed and an automatic
+ *   retraining attempt with the same link parameters is pending. Exactly
+ *   one such attempt is allowed before switching to userspace- driven
+ *   recovery.

When running Link Layer fallback CTS for DP1.4, we noticed UCD500 complaints because we retry the same link parameters. In fact, we used to change:

#define MAX_SEQ_TRAIN_FAILURES 1

I expect the same complaint will happen in DP2.1 fallback CTS.

If I look at the following from the DP2.1 specs:
* Table 3-31: DPTX Fallback Mandates (Normative)
* Figure 3-12: Link Training LANEx_CR_DONE Sequence
* Figure 3-13: Link Training LANEx_CHANNEL_EQ_DONE Sequence
* Figure 3-14: Link Training LANEx_CR_DONE Sequence for Maximum Link Data Bandwidth Policy
* Figure 3-15: Link Training LANEx_CHANNEL_EQ_DONE Sequence for Maximum Link Data Bandwidth Policy

Quoted 2 lines

I do not see it retraining using the same link parameters. So, do you think we should make this configurable, maybe?

This patchset keeps the existing behavior, one aim being to document in detail that behavior, and any changes to the current logic to select a link configuration at any point should be considered only as a follow-up to it.

I have a doubt that a rigid/fixed sequence of selecting link configurations after a link training failure, based on the above interpretation of the CTS, is justified: that selection has other conditions besides the sink's requirements: the source may see a good reason - specific to the source - to retry a link configuration before disabling it. In any case, I think considering changes to the current fallback policy should be considered as a follow-up to this patchset.

Quoted 99 lines

Thank You
Khaled

Quoted 94 lines

+ *
+ * @INTEL_DP_LINK_RECOVERY_AUTORETRAIN_DISABLED:
+ *   Automatic retraining is no longer possible. At this point, a
+ *   fallback selection is made and userspace is notified to take over
+ *   recovery, performing modesets with parameters it determines are
+ *   required. The driver then selects a link configuration from the
+ *   remaining fallback configuration set. Subsequent link training
+ *   failures trigger further fallback selections and userspace
+ *   notifications.
+ *
+ * Describes the link recovery state used by the Intel DP link recovery
+ * logic.
+ *
+ * See also:
+ *   - link_recovery_autoretrain_pending()
+ *   - link_recovery_autoretrain_allowed()
+ *   - link_recovery_mark_train_failure()
+ *   - link_recovery_reset()
+ */

drivers/gpu/drm/i915/display/intel_dp_link_training.c +9 -0
+enum intel_dp_link_recovery_state {
+	/*
+	 * Keep the enum values ordered from least to most severe
+	 * recovery state; helper logic relies on that ordering.
+	 */
+	INTEL_DP_LINK_RECOVERY_IDLE,
+	INTEL_DP_LINK_RECOVERY_AUTORETRAIN_PENDING,
+	INTEL_DP_LINK_RECOVERY_AUTORETRAIN_DISABLED,
+};


 struct intel_dp_link_training {
  struct intel_dp *dp;

drivers/gpu/drm/i915/display/intel_dp_link_training.c +2 -0
+	enum intel_dp_link_recovery_state recovery_state;
+

  bool retrain_disabled;

drivers/gpu/drm/i915/display/intel_dp_link_training.c +0 -2
-	/* Sequential link training failures after a passing LT */
-	int seq_train_failures;

  int force_train_failure;
  bool force_retrain;
 };

drivers/gpu/drm/i915/display/intel_dp_link_training.c +0 -0
@@ -1260,7 +1300,7 @@ intel_dp_128b132b_intra_hop(struct intel_dp
 *intel_dp,

 static bool
 link_recovery_autoretrain_pending(struct intel_dp_link_training *link_training)
 {

drivers/gpu/drm/i915/display/intel_dp_link_training.c +1 -1
-	return link_training->seq_train_failures == 1;
+	return link_training->recovery_state ==

INTEL_DP_LINK_RECOVERY_AUTORETRAIN_PENDING;
 }

 /**

drivers/gpu/drm/i915/display/intel_dp_link_training.c +0 -0
@@ -1274,7 +1314,7 @@ link_recovery_autoretrain_pending(struct
 intel_dp_link_training *link_training)

 static bool
 link_recovery_autoretrain_allowed(struct intel_dp_link_training *link_training)
 {

drivers/gpu/drm/i915/display/intel_dp_link_training.c +0 -1
-	return link_training->seq_train_failures <

MAX_SEQ_TRAIN_FAILURES;

drivers/gpu/drm/i915/display/intel_dp_link_training.c +1 -0
+	return link_training->recovery_state <

INTEL_DP_LINK_RECOVERY_AUTORETRAIN_DISABLED;
 }

 /**

drivers/gpu/drm/i915/display/intel_dp_link_training.c +0 -0
@@ -1299,11 +1339,12 @@ link_recovery_mark_train_failure(struct
 intel_dp_link_training *link_training)
  {
  	if (link_recovery_autoretrain_allowed(link_training))
  		/* Move to autoretrain pending or autoretrain

disabled state. */

drivers/gpu/drm/i915/display/intel_dp_link_training.c +1 -1
-		link_training->seq_train_failures++;
+		link_training->recovery_state++;


  return link_recovery_autoretrain_allowed(link_training); }

+
 /**
  * link_recovery_reset - reset the link recovery state
  * @link_training: link training state

drivers/gpu/drm/i915/display/intel_dp_link_training.c +0 -0
@@ -1313,7 +1354,7 @@ link_recovery_mark_train_failure(struct
 intel_dp_link_training *link_training)
   */

 static void link_recovery_reset(struct intel_dp_link_training *link_training)
 {

drivers/gpu/drm/i915/display/intel_dp_link_training.c +1 -1
-	link_training->seq_train_failures = 0;
+	link_training->recovery_state = INTEL_DP_LINK_RECOVERY_IDLE;

 }

 /**

maintainer
#38 lore raw

Re: [PATCH 019/108] drm/i915/dp_link_training: Track link recovery state with an enum

In reply to Imre Deak
Quoted 86 lines · Imre Deak

Replace the sequential link training failure counter with an explicit link recovery state enum.

This makes the recovery states and transitions clearer: idle, automatic retraining pending, and automatic retraining disabled.

A follow-up change will also move the retrain_disabled flag into this enum.

---
 .../drm/i915/display/intel_dp_link_training.c | 55 ++++++++++++++++---
 1 file changed, 48 insertions(+), 7 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_training.c +44 -4
index 90bd1b0f1ab7d..c44416e0e328f 100644
@@ -61,14 +61,54 @@
 		lt_dbg(_intel_dp, _dp_phy, "Sink disconnected: " _format, ## __VA_ARGS__); \
 } while (0)
 
-#define MAX_SEQ_TRAIN_FAILURES 2
+/**
+ * enum intel_dp_link_recovery_state - LT recovery state
+ * @INTEL_DP_LINK_RECOVERY_IDLE:
+ *   No link training failure is currently tracked and no recovery is
+ *   in progress. This is the initial state after driver initialization,
+ *   power state transitions, sink (re-)connection, or after a successful
+ *   link training.
+ *
+ * @INTEL_DP_LINK_RECOVERY_AUTORETRAIN_PENDING:
+ *   A first link training failure has been observed and an automatic
+ *   retraining attempt with the same link parameters is pending. Exactly
+ *   one such attempt is allowed before switching to userspace-driven
+ *   recovery.
+ *
+ * @INTEL_DP_LINK_RECOVERY_AUTORETRAIN_DISABLED:
+ *   Automatic retraining is no longer possible. At this point, a
+ *   fallback selection is made and userspace is notified to take over
+ *   recovery, performing modesets with parameters it determines are
+ *   required. The driver then selects a link configuration from the
+ *   remaining fallback configuration set. Subsequent link training
+ *   failures trigger further fallback selections and userspace
+ *   notifications.
+ *
+ * Describes the link recovery state used by the Intel DP link recovery
+ * logic.
+ *
+ * See also:
+ *   - link_recovery_autoretrain_pending()
+ *   - link_recovery_autoretrain_allowed()
+ *   - link_recovery_mark_train_failure()
+ *   - link_recovery_reset()
+ */
+enum intel_dp_link_recovery_state {
+	/*
+	 * Keep the enum values ordered from least to most severe
+	 * recovery state; helper logic relies on that ordering.
+	 */
+	INTEL_DP_LINK_RECOVERY_IDLE,
+	INTEL_DP_LINK_RECOVERY_AUTORETRAIN_PENDING,
+	INTEL_DP_LINK_RECOVERY_AUTORETRAIN_DISABLED,
+};
 
 struct intel_dp_link_training {
 	struct intel_dp *dp;
 
+	enum intel_dp_link_recovery_state recovery_state;
+
 	bool retrain_disabled;
-	/* Sequential link training failures after a passing LT */
-	int seq_train_failures;
 	int force_train_failure;
 	bool force_retrain;
 };
@@ -1260,7 +1300,7 @@ intel_dp_128b132b_intra_hop(struct intel_dp *intel_dp,
 static bool
 link_recovery_autoretrain_pending(struct intel_dp_link_training *link_training)
 {
-	return link_training->seq_train_failures == 1;
+	return link_training->recovery_state == INTEL_DP_LINK_RECOVERY_AUTORETRAIN_PENDING;
 }
 
 /**

drivers/gpu/drm/i915/display/intel_dp_link_training.c link_recovery_autoretrain_pending(struct intel_dp_link_training *link_training) · line 1317

Quoted 5 lines
drivers/gpu/drm/i915/display/intel_dp_link_training.c +1 -1
@@ -1274,7 +1314,7 @@ link_recovery_autoretrain_pending(struct intel_dp_link_training *link_training)
 static bool
 link_recovery_autoretrain_allowed(struct intel_dp_link_training *link_training)
 {
-	return link_training->seq_train_failures < MAX_SEQ_TRAIN_FAILURES;
+	return link_training->recovery_state < INTEL_DP_LINK_RECOVERY_AUTORETRAIN_DISABLED;

Dunno, if the state machine is tracked by an enum, it just might make sense to list the allowed cases instead of <.

drivers/gpu/drm/i915/display/intel_dp_link_training.c link_recovery_mark_train_failure(struct intel_dp_link_training *link_training) · line 1342

Quoted 9 lines
drivers/gpu/drm/i915/display/intel_dp_link_training.c +1 -1
 }
 
 /**
@@ -1299,11 +1339,12 @@ link_recovery_mark_train_failure(struct intel_dp_link_training *link_training)
 {
 	if (link_recovery_autoretrain_allowed(link_training))
 		/* Move to autoretrain pending or autoretrain disabled state. */
-		link_training->seq_train_failures++;
+		link_training->recovery_state++;

Ditto.

Quoted 17 lines
drivers/gpu/drm/i915/display/intel_dp_link_training.c +2 -1
 	return link_recovery_autoretrain_allowed(link_training);
 }
 
+
 /**
  * link_recovery_reset - reset the link recovery state
  * @link_training: link training state
@@ -1313,7 +1354,7 @@ link_recovery_mark_train_failure(struct intel_dp_link_training *link_training)
  */
 static void link_recovery_reset(struct intel_dp_link_training *link_training)
 {
-	link_training->seq_train_failures = 0;
+	link_training->recovery_state = INTEL_DP_LINK_RECOVERY_IDLE;
 }
 
 /**
Signature · 1 line
Jani Nikula, Intel
author
#39 lore raw

Re: [PATCH 019/108] drm/i915/dp_link_training: Track link recovery state with an enum

Quoted 85 lines · Jani Nikula
Quoted 84 lines · Imre Deak

Replace the sequential link training failure counter with an explicit link recovery state enum.

This makes the recovery states and transitions clearer: idle, automatic retraining pending, and automatic retraining disabled.

A follow-up change will also move the retrain_disabled flag into this enum.

---
 .../drm/i915/display/intel_dp_link_training.c | 55 ++++++++++++++++---
 1 file changed, 48 insertions(+), 7 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_training.c +44 -4
index 90bd1b0f1ab7d..c44416e0e328f 100644
@@ -61,14 +61,54 @@
 		lt_dbg(_intel_dp, _dp_phy, "Sink disconnected: " _format, ## __VA_ARGS__); \
 } while (0)
 
-#define MAX_SEQ_TRAIN_FAILURES 2
+/**
+ * enum intel_dp_link_recovery_state - LT recovery state
+ * @INTEL_DP_LINK_RECOVERY_IDLE:
+ *   No link training failure is currently tracked and no recovery is
+ *   in progress. This is the initial state after driver initialization,
+ *   power state transitions, sink (re-)connection, or after a successful
+ *   link training.
+ *
+ * @INTEL_DP_LINK_RECOVERY_AUTORETRAIN_PENDING:
+ *   A first link training failure has been observed and an automatic
+ *   retraining attempt with the same link parameters is pending. Exactly
+ *   one such attempt is allowed before switching to userspace-driven
+ *   recovery.
+ *
+ * @INTEL_DP_LINK_RECOVERY_AUTORETRAIN_DISABLED:
+ *   Automatic retraining is no longer possible. At this point, a
+ *   fallback selection is made and userspace is notified to take over
+ *   recovery, performing modesets with parameters it determines are
+ *   required. The driver then selects a link configuration from the
+ *   remaining fallback configuration set. Subsequent link training
+ *   failures trigger further fallback selections and userspace
+ *   notifications.
+ *
+ * Describes the link recovery state used by the Intel DP link recovery
+ * logic.
+ *
+ * See also:
+ *   - link_recovery_autoretrain_pending()
+ *   - link_recovery_autoretrain_allowed()
+ *   - link_recovery_mark_train_failure()
+ *   - link_recovery_reset()
+ */
+enum intel_dp_link_recovery_state {
+	/*
+	 * Keep the enum values ordered from least to most severe
+	 * recovery state; helper logic relies on that ordering.
+	 */
+	INTEL_DP_LINK_RECOVERY_IDLE,
+	INTEL_DP_LINK_RECOVERY_AUTORETRAIN_PENDING,
+	INTEL_DP_LINK_RECOVERY_AUTORETRAIN_DISABLED,
+};
 
 struct intel_dp_link_training {
 	struct intel_dp *dp;
 
+	enum intel_dp_link_recovery_state recovery_state;
+
 	bool retrain_disabled;
-	/* Sequential link training failures after a passing LT */
-	int seq_train_failures;
 	int force_train_failure;
 	bool force_retrain;
 };
@@ -1260,7 +1300,7 @@ intel_dp_128b132b_intra_hop(struct intel_dp *intel_dp,
 static bool
 link_recovery_autoretrain_pending(struct intel_dp_link_training *link_training)
 {
-	return link_training->seq_train_failures == 1;
+	return link_training->recovery_state == INTEL_DP_LINK_RECOVERY_AUTORETRAIN_PENDING;
 }
 
Quoted 10 lines

drivers/gpu/drm/i915/display/intel_dp_link_training.c link_recovery_autoretrain_pending(struct intel_dp_link_training *link_training) · line 1317

Quoted 7 lines
drivers/gpu/drm/i915/display/intel_dp_link_training.c +1 -1
 /**
@@ -1274,7 +1314,7 @@ link_recovery_autoretrain_pending(struct intel_dp_link_training *link_training)
 static bool
 link_recovery_autoretrain_allowed(struct intel_dp_link_training *link_training)
 {
-	return link_training->seq_train_failures < MAX_SEQ_TRAIN_FAILURES;
+	return link_training->recovery_state < INTEL_DP_LINK_RECOVERY_AUTORETRAIN_DISABLED;

Dunno, if the state machine is tracked by an enum, it just might make sense to list the allowed cases instead of <.

The patch tries to keep it easy to prove the correctness of the change. That's easier if the only change is using an enum instead of an int (i.e. seq_train_failures -> recovery_state) and renaming the constant being matched (i.e. MAX_SEQ_TRAIN_FAILURES -> INTEL_DP_LINK_RECOVERY_AUTORETRAIN_DISABLED), keeping the value for the constant.

I tried to folow this in the whole patchset, changing only one thing in a patch.

It may makes sense to check for each enum value explicitly, but I'd prefer doing that as a follow-up.

Quoted 33 lines

drivers/gpu/drm/i915/display/intel_dp_link_training.c link_recovery_mark_train_failure(struct intel_dp_link_training *link_training) · line 1342

Quoted 10 lines
drivers/gpu/drm/i915/display/intel_dp_link_training.c +1 -1
 }
 
 /**
@@ -1299,11 +1339,12 @@ link_recovery_mark_train_failure(struct intel_dp_link_training *link_training)
 {
 	if (link_recovery_autoretrain_allowed(link_training))
 		/* Move to autoretrain pending or autoretrain disabled state. */
-		link_training->seq_train_failures++;
+		link_training->recovery_state++;

Ditto.

Quoted 17 lines
drivers/gpu/drm/i915/display/intel_dp_link_training.c +2 -1
 	return link_recovery_autoretrain_allowed(link_training);
 }
 
+
 /**
  * link_recovery_reset - reset the link recovery state
  * @link_training: link training state
@@ -1313,7 +1354,7 @@ link_recovery_mark_train_failure(struct intel_dp_link_training *link_training)
  */
 static void link_recovery_reset(struct intel_dp_link_training *link_training)
 {
-	link_training->seq_train_failures = 0;
+	link_training->recovery_state = INTEL_DP_LINK_RECOVERY_IDLE;
 }
 
 /**
Signature · 1 line
Jani Nikula, Intel
author
#40 lore raw

PATCH 20/108 drm/i915/dp_link_training: Add no-fallback link recovery state

In reply to Imre Deak

Replace the misnamed retrain_disabled flag with a dedicated link recovery state indicating that no fallback link configurations remain.

This clarifies the meaning of the state: it has always represented the situation where no further fallback link configurations are available.

While at it, add a TODO comment to the debugfs entry, to expose this state via a more appropriately named entry.

---
 .../drm/i915/display/intel_dp_link_training.c | 43 +++++++++++++++++--
 1 file changed, 39 insertions(+), 4 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_training.c +39 -4
index c44416e0e328f..cbabf01d4b670 100644
@@ -84,13 +84,21 @@
  *   failures trigger further fallback selections and userspace
  *   notifications.
  *
+ * @INTEL_DP_LINK_RECOVERY_NO_FALLBACK:
+ *   Fallback selection is no longer possible, as no usable fallback link
+ *   configurations remain. Recovery must proceed via userspace modesets
+ *   using the remaining allowed link configuration. Userspace continues
+ *   to be notified of subsequent link training failures.
+ *
  * Describes the link recovery state used by the Intel DP link recovery
  * logic.
  *
  * See also:
  *   - link_recovery_autoretrain_pending()
  *   - link_recovery_autoretrain_allowed()
+ *   - link_recovery_has_no_fallback()
  *   - link_recovery_mark_train_failure()
+ *   - link_recovery_mark_no_fallback()
  *   - link_recovery_reset()
  */
 enum intel_dp_link_recovery_state {
@@ -101,6 +109,7 @@ enum intel_dp_link_recovery_state {
 	INTEL_DP_LINK_RECOVERY_IDLE,
 	INTEL_DP_LINK_RECOVERY_AUTORETRAIN_PENDING,
 	INTEL_DP_LINK_RECOVERY_AUTORETRAIN_DISABLED,
+	INTEL_DP_LINK_RECOVERY_NO_FALLBACK,
 };
 
 struct intel_dp_link_training {
@@ -108,7 +117,6 @@ struct intel_dp_link_training {
 
 	enum intel_dp_link_recovery_state recovery_state;
 
-	bool retrain_disabled;
 	int force_train_failure;
 	bool force_retrain;
 };
@@ -1317,6 +1325,22 @@ link_recovery_autoretrain_allowed(struct intel_dp_link_training *link_training)
 	return link_training->recovery_state < INTEL_DP_LINK_RECOVERY_AUTORETRAIN_DISABLED;
 }
 
+/**
+ * link_recovery_has_no_fallback - check whether fallback is unavailable
+ * @link_training: link training state
+ *
+ * Check whether link fallback configurations are unavailable.
+ *
+ * Return:
+ * - %true  if fallback is unavailable.
+ * - %false otherwise.
+ */
+static bool
+link_recovery_has_no_fallback(struct intel_dp_link_training *link_training)
+{
+	return link_training->recovery_state == INTEL_DP_LINK_RECOVERY_NO_FALLBACK;
+}
+
 /**
  * link_recovery_mark_train_failure - record a link training failure
  * @link_training: link training state
@@ -1344,6 +1368,17 @@ link_recovery_mark_train_failure(struct intel_dp_link_training *link_training)
 	return link_recovery_autoretrain_allowed(link_training);
 }
 
+/**
+ * link_recovery_mark_no_fallback - record that fallback is unavailable
+ * @link_training: link training state
+ *
+ * Record that no more link fallback configuration is available.
+ */
+static void
+link_recovery_mark_no_fallback(struct intel_dp_link_training *link_training)
+{
+	link_training->recovery_state = INTEL_DP_LINK_RECOVERY_NO_FALLBACK;
+}
 
 /**
  * link_recovery_reset - reset the link recovery state
@@ -1950,7 +1985,7 @@ void intel_dp_start_link_train(struct intel_atomic_state *state,
 	if (intel_dp_schedule_fallback_link_training(state, intel_dp, crtc_state))
 		return;
 
-	link_training->retrain_disabled = true;
+	link_recovery_mark_no_fallback(link_training);
 
 	if (!passed)
 		lt_err(intel_dp, DP_PHY_DPRX, "Can't reduce link training parameters after failure\n");
@@ -2550,7 +2585,8 @@ static int i915_dp_link_retrain_disabled_show(struct seq_file *m, void *data)
 
 	intel_dp_flush_connector_commits(connector);
 
-	seq_printf(m, "%s\n", str_yes_no(link_training->retrain_disabled));
+	/* TODO: Expose this via a debugfs entry reflecting what the state represents. */
+	seq_printf(m, "%s\n", str_yes_no(link_recovery_has_no_fallback(link_training)));
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
 
@@ -2590,7 +2626,6 @@ void intel_dp_link_training_debugfs_add(struct intel_connector *connector)
 
 void intel_dp_link_training_reset(struct intel_dp_link_training *link_training)
 {
-	link_training->retrain_disabled = false;
 	link_recovery_reset(link_training);
 }
 
Signature · 1 line
2.49.1
author
#41 lore raw

PATCH 21/108 drm/i915/display: Factor out a helper to modeset a pipe with atomic state

In reply to Imre Deak

Factor out a helper modesetting a pipe that accepts an existing atomic state. This prepares for a follow-up change that needs to allocate its own atomic state.

---
 drivers/gpu/drm/i915/display/intel_display.c | 30 ++++++++++++++------
 drivers/gpu/drm/i915/display/intel_display.h |  3 ++
 2 files changed, 25 insertions(+), 8 deletions(-)
drivers/gpu/drm/i915/display/intel_display.c +22 -8
index 674a4ece6d0f9..560b057ec163d 100644
@@ -5629,18 +5629,15 @@ int intel_modeset_all_pipes_late(struct intel_atomic_state *state,
 	return 0;
 }
 
-int intel_modeset_commit_pipes(struct intel_display *display,
-			       u8 pipe_mask,
-			       struct drm_modeset_acquire_ctx *ctx)
+int intel_modeset_commit_pipes_for_atomic_state(struct intel_atomic_state *intel_state,
+						u8 pipe_mask,
+						struct drm_modeset_acquire_ctx *ctx)
 {
-	struct drm_atomic_state *state;
+	struct drm_atomic_state *state = &intel_state->base;
+	struct intel_display *display = to_intel_display(intel_state);
 	struct intel_crtc *crtc;
 	int ret;
 
-	state = drm_atomic_state_alloc(display->drm);
-	if (!state)
-		return -ENOMEM;
-
 	state->acquire_ctx = ctx;
 	to_intel_atomic_state(state)->internal = true;
 
@@ -5658,6 +5655,23 @@ int intel_modeset_commit_pipes(struct intel_display *display,
 
 	ret = drm_atomic_commit(state);
 out:
+	return ret;
+}
+
+int intel_modeset_commit_pipes(struct intel_display *display,
+			       u8 pipe_mask,
+			       struct drm_modeset_acquire_ctx *ctx)
+{
+	struct drm_atomic_state *state;
+	int ret;
+
+	state = drm_atomic_state_alloc(display->drm);
+	if (!state)
+		return -ENOMEM;
+
+	ret = intel_modeset_commit_pipes_for_atomic_state(to_intel_atomic_state(state),
+							  pipe_mask, ctx);
+
 	drm_atomic_state_put(state);
 
 	return ret;
drivers/gpu/drm/i915/display/intel_display.h +3 -0
index 1e76a455d7c43..79e42bfd15e70 100644
@@ -478,6 +478,9 @@ int intel_modeset_pipes_in_mask_early(struct intel_atomic_state *state,
 				      const char *reason, u8 pipe_mask);
 int intel_modeset_all_pipes_late(struct intel_atomic_state *state,
 				 const char *reason);
+int intel_modeset_commit_pipes_for_atomic_state(struct intel_atomic_state *state,
+						u8 pipe_mask,
+						struct drm_modeset_acquire_ctx *ctx);
 int intel_modeset_commit_pipes(struct intel_display *display,
 			       u8 pipe_mask,
 			       struct drm_modeset_acquire_ctx *ctx);
Signature · 1 line
2.49.1
author
#42 lore raw

PATCH 22/108 drm/i915/display: Simplify intel_modeset_commit_pipes_for_atomic_state()

In reply to Imre Deak

Simplify accessing the DRM atomic state via the intel atomic state in intel_modeset_commit_pipes_for_atomic_state(), which also allows dropping the cached DRM state pointer. Also streamline the success/error return flows.

---
 drivers/gpu/drm/i915/display/intel_display.c | 22 +++++++-------------
 1 file changed, 8 insertions(+), 14 deletions(-)
drivers/gpu/drm/i915/display/intel_display.c +8 -14
index 560b057ec163d..f13aaaf2ea1de 100644
@@ -5629,33 +5629,27 @@ int intel_modeset_all_pipes_late(struct intel_atomic_state *state,
 	return 0;
 }
 
-int intel_modeset_commit_pipes_for_atomic_state(struct intel_atomic_state *intel_state,
+int intel_modeset_commit_pipes_for_atomic_state(struct intel_atomic_state *state,
 						u8 pipe_mask,
 						struct drm_modeset_acquire_ctx *ctx)
 {
-	struct drm_atomic_state *state = &intel_state->base;
-	struct intel_display *display = to_intel_display(intel_state);
+	struct intel_display *display = to_intel_display(state);
 	struct intel_crtc *crtc;
-	int ret;
 
-	state->acquire_ctx = ctx;
-	to_intel_atomic_state(state)->internal = true;
+	state->base.acquire_ctx = ctx;
+	state->internal = true;
 
 	for_each_intel_crtc_in_pipe_mask(display->drm, crtc, pipe_mask) {
 		struct intel_crtc_state *crtc_state =
-			intel_atomic_get_crtc_state(state, crtc);
+			intel_atomic_get_crtc_state(&state->base, crtc);
 
-		if (IS_ERR(crtc_state)) {
-			ret = PTR_ERR(crtc_state);
-			goto out;
-		}
+		if (IS_ERR(crtc_state))
+			return PTR_ERR(crtc_state);
 
 		crtc_state->uapi.connectors_changed = true;
 	}
 
-	ret = drm_atomic_commit(state);
-out:
-	return ret;
+	return drm_atomic_commit(&state->base);
 }
 
 int intel_modeset_commit_pipes(struct intel_display *display,
Signature · 1 line
2.49.1
author
#43 lore raw

PATCH 23/108 drm/i915/dp_link_training: Allocate atomic state for autoretrain modeset

In reply to Imre Deak

Allocate a local atomic state for the autoretrain modeset. This prepares for a follow-up change that needs to access the state after the modeset for sending userspace notifications.

---
 .../gpu/drm/i915/display/intel_dp_link_training.c | 15 +++++++++++++--
 1 file changed, 13 insertions(+), 2 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_training.c +13 -2
index cbabf01d4b670..b446a3523b94c 100644
@@ -27,6 +27,7 @@
 #include <drm/display/drm_dp_helper.h>
 #include <drm/drm_print.h>
 
+#include "intel_display.h"
 #include "intel_display_core.h"
 #include "intel_display_jiffies.h"
 #include "intel_display_types.h"
@@ -2157,6 +2158,8 @@ static int intel_dp_retrain_link(struct intel_encoder *encoder,
 	struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
 	struct intel_dp_link_training *link_training =
 		intel_dp->link.training;
+	struct intel_atomic_state *state;
+	struct drm_atomic_state *_state;
 	u8 pipe_mask;
 	int ret;
 
@@ -2186,9 +2189,15 @@ static int intel_dp_retrain_link(struct intel_encoder *encoder,
 		    encoder->base.base.id, encoder->base.name,
 		    str_yes_no(intel_dp_link_training_get_force_retrain(link_training)));
 
-	ret = intel_modeset_commit_pipes(display, pipe_mask, ctx);
+	_state = drm_atomic_state_alloc(display->drm);
+	if (!_state)
+		return -ENOMEM;
+
+	state = to_intel_atomic_state(_state);
+
+	ret = intel_modeset_commit_pipes_for_atomic_state(state, pipe_mask, ctx);
 	if (ret == -EDEADLK)
-		return ret;
+		goto out;
 
 	intel_dp_link_training_set_force_retrain(link_training, false);
 
@@ -2197,6 +2206,8 @@ static int intel_dp_retrain_link(struct intel_encoder *encoder,
 			    "[ENCODER:%d:%s] link retraining failed: %pe\n",
 			    encoder->base.base.id, encoder->base.name,
 			    ERR_PTR(ret));
+out:
+	drm_atomic_state_put(&state->base);
 
 	return ret;
 }
Signature · 1 line
2.49.1
author
#44 lore raw

PATCH 24/108 drm/i915/dp_link_training: Disallow autoretrains after failed modeset

In reply to Imre Deak

intel_dp_check_link_state() and intel_dp_link_params_valid() perform only a coarse validation of the link configuration used by the active mode against the available configurations (as constrained by the link training fallback code after a previous LT failure). Even if these coarse checks find a seemingly usable configuration, the modeset check, which performs full verification, may still fail.

Disallow further autoretrain attempts if an autoretrain modeset fails. Further attempts would just reuse the same modeset parameters and fail in the same way. Autoretrain will be reallowed unconditionally when the sink reports a change in its capabilities. This allows an autoretrain to proceed once both the link validation and modeset checks confirm a usable configuration.

Also clarify in intel_dp_check_link_state() and intel_dp_link_params_valid() that these checks are coarse and that a full validation is only performed by the subsequent atomic modeset check.

---
 .../drm/i915/display/intel_dp_link_training.c | 98 ++++++++++++++++++-
 1 file changed, 96 insertions(+), 2 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_training.c +96 -2
index b446a3523b94c..37862b915cf6e 100644
@@ -99,6 +99,7 @@
  *   - link_recovery_autoretrain_allowed()
  *   - link_recovery_has_no_fallback()
  *   - link_recovery_mark_train_failure()
+ *   - link_recovery_mark_autoretrain_modeset_failure()
  *   - link_recovery_mark_no_fallback()
  *   - link_recovery_reset()
  */
@@ -1354,6 +1355,13 @@ link_recovery_has_no_fallback(struct intel_dp_link_training *link_training)
  * is no longer possible, via userspace modesets after fallback
  * selection.
  *
+ * Note that the error reported via this function is the error seen by
+ * the link training failure handler proper after an actual link
+ * training failure indicated by the sink device, and so the error and
+ * corresponding actions required are distinct from an autoretrain
+ * modeset failure. See link_recovery_mark_autoretrain_modeset_failure() to
+ * report a modeset failure.
+ *
  * Return:
  * - %true  if recovery should continue via automatic retraining.
  * - %false if automatic retraining is no longer possible and recovery
@@ -1370,7 +1378,30 @@ link_recovery_mark_train_failure(struct intel_dp_link_training *link_training)
 }
 
 /**
- * link_recovery_mark_no_fallback - record that fallback is unavailable
+ * link_recovery_mark_autoretrain_modeset_failure - record an autoretrain modeset failure
+ * @link_training: link training state
+ *
+ * Record a failure of the autoretrain modeset before link training
+ * itself could run.
+ *
+ * Note that the error reported via this function and the corresponding
+ * expected actions are distinct from an actual link training failure:
+ * the modeset failed before a link training attempt could be performed.
+ * See link_recovery_mark_train_failure() to report an actual link
+ * training failure.
+ *
+ * Update the state to indicate that further recovery is to be delegated to
+ * userspace via a regular modeset.
+ */
+static void
+link_recovery_mark_autoretrain_modeset_failure(struct intel_dp_link_training *link_training)
+{
+	if (link_recovery_autoretrain_allowed(link_training))
+		link_training->recovery_state = INTEL_DP_LINK_RECOVERY_AUTORETRAIN_DISABLED;
+}
+
+/**
+ * link_recovery_mark_no_fallback - record that no fallback is possible
  * @link_training: link training state
  *
  * Record that no more link fallback configuration is available.
@@ -2021,6 +2052,23 @@ bool intel_dp_link_params_valid(struct intel_dp *intel_dp, int link_rate,
 	 * FIXME: we need to synchronize the current link parameters with
 	 * hardware readout. Currently fast link training doesn't work on
 	 * boot-up.
+	 *
+	 * NOTE:
+	 * This may be called from both serialized (locked and synced against
+	 * async commit tails) and unserialized (e.g. HPD IRQ) contexts. It
+	 * uses the current max link limits as upper bounds to reject
+	 * obviously bogus values, even if those bounds may be observed in a
+	 * transient or slightly stale state.
+	 *
+	 * This is not a full validation of the link configuration. Even in
+	 * serialized contexts, additional constraints (e.g. source limitations,
+	 * bandwidth checks, and other atomic state dependencies) are only
+	 * verified during the atomic check of the subsequent commit.
+	 *
+	 * max_link_limits only provides independent upper bounds for rate and
+	 * lane count. Callers must not assume it is itself an allowed link
+	 * configuration. Although that happens to be true for now, it will
+	 * stop being guaranteed once fallback depends only on disabled configs.
 	 */
 	if (link_rate == 0 ||
 	    link_rate > intel_dp->link.max_rate)
@@ -2151,6 +2199,22 @@ static bool intel_dp_is_connected(struct intel_dp *intel_dp)
 		intel_dp->is_mst;
 }
 
+static void queue_modeset_retry_for_links_in_state(struct intel_atomic_state *state,
+						   struct intel_encoder *encoder,
+						   u8 pipe_mask)
+{
+	const struct intel_crtc_state *crtc_state;
+	struct intel_crtc *crtc;
+	int i;
+
+	for_each_new_intel_crtc_in_state(state, crtc, crtc_state, i) {
+		if (!(BIT(crtc->pipe) & pipe_mask))
+			continue;
+
+		intel_dp_queue_modeset_retry_for_link(state, encoder, crtc_state);
+	}
+}
+
 static int intel_dp_retrain_link(struct intel_encoder *encoder,
 				 struct drm_modeset_acquire_ctx *ctx)
 {
@@ -2201,11 +2265,23 @@ static int intel_dp_retrain_link(struct intel_encoder *encoder,
 
 	intel_dp_link_training_set_force_retrain(link_training, false);
 
-	if (ret)
+	if (ret) {
 		drm_dbg_kms(display->drm,
 			    "[ENCODER:%d:%s] link retraining failed: %pe\n",
 			    encoder->base.base.id, encoder->base.name,
 			    ERR_PTR(ret));
+		/*
+		 * intel_dp_needs_link_retrain() only performs a coarse check of
+		 * retrainability, so the modeset commit may still fail. Disable
+		 * further auto-retrain attempts in that case.
+		 *
+		 * A sink capability change may restore the retrainable state (see
+		 * intel_dp_update_sink_caps(), intel_dp_reset_link_params()),
+		 * allowing retraining to be attempted again.
+		 */
+		link_recovery_mark_autoretrain_modeset_failure(link_training);
+		queue_modeset_retry_for_links_in_state(state, encoder, pipe_mask);
+	}
 out:
 	drm_atomic_state_put(&state->base);
 
@@ -2229,6 +2305,24 @@ void intel_dp_check_link_state(struct intel_dp *intel_dp)
 	if (!intel_dp_is_connected(intel_dp))
 		return;
 
+	/*
+	 * NOTE:
+	 * This may race with an ongoing modeset updating the max link limits
+	 * and, with that, the link's retrainability, so
+	 * intel_dp_needs_link_retrain() may observe stale state.
+	 *
+	 * This is harmless: stale params captured as valid may spuriously
+	 * allow retraining here, but the decision is rechecked later in a
+	 * properly serialized context.
+	 *
+	 * Conversely, stale params captured as invalid may skip retraining,
+	 * but that can only happen before the modeset has completed its own
+	 * link training for the new, valid configuration, after which the
+	 * link state is rechecked.
+	 *
+	 * See intel_dp_link_params_valid() for capturing and validating the
+	 * params.
+	 */
 	if (!intel_dp_needs_link_retrain(intel_dp))
 		return;
 
Signature · 1 line
2.49.1
author
#45 lore raw

PATCH 25/108 drm/i915/dp_link_training: Fix kernel-doc of intel_dp_init_lttpr_and_dprx_caps()

In reply to Imre Deak

Fix the list formatting of return values in intel_dp_read_dprx_caps()'s kernel-doc.

---
 drivers/gpu/drm/i915/display/intel_dp_link_training.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_training.c +5 -5
index 37862b915cf6e..35f160761e182 100644
@@ -311,12 +311,12 @@ int intel_dp_read_dprx_caps(struct intel_dp *intel_dp, u8 dpcd[DP_RECEIVER_CAP_S
  * transparent mode link training mode.
  *
  * Returns:
- *   >0  if LTTPRs were detected and the non-transparent LT mode was set. The
+ * - >0  if LTTPRs were detected and the non-transparent LT mode was
+ *       set. The DPRX capabilities are read out.
+ * -  0  if no LTTPRs or more than 8 LTTPRs were detected or in case of
+ *       a detection failure and the transparent LT mode was set. The
  *       DPRX capabilities are read out.
- *    0  if no LTTPRs or more than 8 LTTPRs were detected or in case of a
- *       detection failure and the transparent LT mode was set. The DPRX
- *       capabilities are read out.
- *   <0  Reading out the DPRX capabilities failed.
+ * - <0  Reading out the DPRX capabilities failed.
  */
 int intel_dp_init_lttpr_and_dprx_caps(struct intel_dp *intel_dp)
 {
Signature · 1 line
2.49.1
author
#46 lore raw

PATCH 26/108 drm/i915/dp_link_training: Document DP link recovery logic

In reply to Imre Deak

Add kernel-doc documentation describing the Intel DP link training recovery state machine and the sequence of automatic retraining, fallback selection, and userspace notification.

---
 Documentation/gpu/i915.rst                    |   9 +
 .../drm/i915/display/intel_dp_link_training.c | 241 ++++++++++++++++++
 2 files changed, 250 insertions(+)
Documentation/gpu/i915.rst +9 -0
index eba09c3ddce42..34556b2104aa5 100644
@@ -141,6 +141,15 @@ Hotplug
 .. kernel-doc:: drivers/gpu/drm/i915/display/intel_hotplug.c
    :internal:
 
+DisplayPort Link Training
+-------------------------
+
+.. kernel-doc:: drivers/gpu/drm/i915/display/intel_dp_link_training.c
+   :doc: DisplayPort link training
+
+.. kernel-doc:: drivers/gpu/drm/i915/display/intel_dp_link_training.c
+   :internal:
+
 High Definition Audio
 ---------------------
 
drivers/gpu/drm/i915/display/intel_dp_link_training.c +241 -0

253 lines not on this page · raw message

Signature · 1 line
2.49.1
author
#47 lore raw

PATCH 27/108 drm/i915/dp: Rename intel_dp_link_config to intel_dp_link_config_entry

In reply to Imre Deak

Rename intel_dp_link_config to intel_dp_link_config_entry to prepare for tracking a link configuration in both an internal packed and a public unpacked format. A follow-up change will add struct intel_dp_link_config representing the public unpacked format.

---
 .../gpu/drm/i915/display/intel_display_types.h   |  2 +-
 drivers/gpu/drm/i915/display/intel_dp.c          | 16 ++++++++--------
 2 files changed, 9 insertions(+), 9 deletions(-)
drivers/gpu/drm/i915/display/intel_display_types.h +1 -1
index dd61d958d5b6c..e591bca15e4eb 100644
@@ -1831,7 +1831,7 @@ struct intel_dp {
 #define INTEL_DP_LINK_RATE_IDX_BITS		(BITS_PER_TYPE(u8) - INTEL_DP_LANE_COUNT_EXP_BITS)
 #define INTEL_DP_MAX_LINK_CONFIGS		(DP_MAX_SUPPORTED_RATES * \
 						 INTEL_DP_MAX_SUPPORTED_LANE_CONFIGS)
-		struct intel_dp_link_config {
+		struct intel_dp_link_config_entry {
 			u8 link_rate_idx:INTEL_DP_LINK_RATE_IDX_BITS;
 			u8 lane_count_exp:INTEL_DP_LANE_COUNT_EXP_BITS;
 		} configs[INTEL_DP_MAX_LINK_CONFIGS];
drivers/gpu/drm/i915/display/intel_dp.c +8 -8
index 3dc27dbf2bce8..4f016adef93be 100644
@@ -688,18 +688,18 @@ int intel_dp_rate_index(const int *rates, int len, int rate)
 }
 
 static int intel_dp_link_config_rate(struct intel_dp *intel_dp,
-				     const struct intel_dp_link_config *lc)
+				     const struct intel_dp_link_config_entry *lc)
 {
 	return intel_dp_common_rate(intel_dp, lc->link_rate_idx);
 }
 
-static int intel_dp_link_config_lane_count(const struct intel_dp_link_config *lc)
+static int intel_dp_link_config_lane_count(const struct intel_dp_link_config_entry *lc)
 {
 	return 1 << lc->lane_count_exp;
 }
 
 static int intel_dp_link_config_bw(struct intel_dp *intel_dp,
-				   const struct intel_dp_link_config *lc)
+				   const struct intel_dp_link_config_entry *lc)
 {
 	return drm_dp_max_dprx_data_rate(intel_dp_link_config_rate(intel_dp, lc),
 					 intel_dp_link_config_lane_count(lc));
@@ -708,8 +708,8 @@ static int intel_dp_link_config_bw(struct intel_dp *intel_dp,
 static int link_config_cmp_by_bw(const void *a, const void *b, const void *p)
 {
 	struct intel_dp *intel_dp = (struct intel_dp *)p;	/* remove const */
-	const struct intel_dp_link_config *lc_a = a;
-	const struct intel_dp_link_config *lc_b = b;
+	const struct intel_dp_link_config_entry *lc_a = a;
+	const struct intel_dp_link_config_entry *lc_b = b;
 	int bw_a = intel_dp_link_config_bw(intel_dp, lc_a);
 	int bw_b = intel_dp_link_config_bw(intel_dp, lc_b);
 
@@ -723,7 +723,7 @@ static int link_config_cmp_by_bw(const void *a, const void *b, const void *p)
 static void intel_dp_link_config_init(struct intel_dp *intel_dp)
 {
 	struct intel_display *display = to_intel_display(intel_dp);
-	struct intel_dp_link_config *lc;
+	struct intel_dp_link_config_entry *lc;
 	int num_common_lane_configs;
 	int i;
 	int j;
@@ -758,7 +758,7 @@ static void intel_dp_link_config_init(struct intel_dp *intel_dp)
 void intel_dp_link_config_get(struct intel_dp *intel_dp, int idx, int *link_rate, int *lane_count)
 {
 	struct intel_display *display = to_intel_display(intel_dp);
-	const struct intel_dp_link_config *lc;
+	const struct intel_dp_link_config_entry *lc;
 
 	if (drm_WARN_ON(display->drm, idx < 0 || idx >= intel_dp->link.num_configs))
 		idx = 0;
@@ -777,7 +777,7 @@ int intel_dp_link_config_index(struct intel_dp *intel_dp, int link_rate, int lan
 	int i;
 
 	for (i = 0; i < intel_dp->link.num_configs; i++) {
-		const struct intel_dp_link_config *lc = &intel_dp->link.configs[i];
+		const struct intel_dp_link_config_entry *lc = &intel_dp->link.configs[i];
 
 		if (lc->lane_count_exp == lane_count_exp &&
 		    lc->link_rate_idx == link_rate_idx)
Signature · 1 line
2.49.1
author
#48 lore raw

PATCH 28/108 drm/i915/dp: Add struct intel_dp_link_config

In reply to Imre Deak

Add a struct representing the public unpacked format of a link configuration. This will be used by the DP link capability API added as a follow-up, and by DP code in general that needs to track a link configuration.

---
 drivers/gpu/drm/i915/display/intel_display_types.h | 8 ++++++++
 1 file changed, 8 insertions(+)
drivers/gpu/drm/i915/display/intel_display_types.h +8 -0
index e591bca15e4eb..28a8a149157e0 100644
@@ -1792,6 +1792,14 @@ struct intel_psr {
 	const char *no_psr_reason;
 };
 
+struct intel_dp_link_config {
+	int rate;
+	int lane_count;
+};
+
+#define INTEL_DP_LINK_CONFIG_NULL \
+	((struct intel_dp_link_config){})
+
 struct intel_dp {
 	i915_reg_t output_reg;
 	u32 DP;
Signature · 1 line
2.49.1
author
#49 lore raw

PATCH 29/108 drm/i915/dp_link_caps: Introduce DP link capability module

In reply to Imre Deak

Start isolating the DP link capability logic from the generic DP code by adding a separate intel_dp_link_caps module and a corresponding state object.

Allocate the state so it can remain opaque within its module.

Follow-up changes will move link capability helpers and state from intel_dp.c and intel_dp_link_training.c to the new module and state.

---
 drivers/gpu/drm/i915/Makefile                 |  1 +
 .../drm/i915/display/intel_display_types.h    |  2 +
 drivers/gpu/drm/i915/display/intel_dp.c       |  9 ++++
 .../gpu/drm/i915/display/intel_dp_link_caps.c | 47 +++++++++++++++++++
 .../gpu/drm/i915/display/intel_dp_link_caps.h | 12 +++++
 drivers/gpu/drm/xe/Makefile                   |  1 +
 6 files changed, 72 insertions(+)
 create mode 100644 drivers/gpu/drm/i915/display/intel_dp_link_caps.c
 create mode 100644 drivers/gpu/drm/i915/display/intel_dp_link_caps.h
drivers/gpu/drm/i915/Makefile +1 -0
index fa632f4e505c9..0c04c6d9bb13e 100644
@@ -355,6 +355,7 @@ i915-y += \
 	display/intel_dp_aux.o \
 	display/intel_dp_aux_backlight.o \
 	display/intel_dp_hdcp.o \
+	display/intel_dp_link_caps.o \
 	display/intel_dp_link_training.o \
 	display/intel_dp_mst.o \
 	display/intel_dp_test.o \
drivers/gpu/drm/i915/display/intel_display_types.h +2 -0
index 28a8a149157e0..d11686ce2963d 100644
@@ -58,6 +58,7 @@ struct cec_notifier;
 struct drm_printer;
 struct intel_connector;
 struct intel_ddi_buf_trans;
+struct intel_dp_link_caps;
 struct intel_dp_link_training;
 struct intel_fbc;
 struct intel_global_objs_state;
@@ -1858,6 +1859,7 @@ struct intel_dp {
 		int force_lane_count;
 		int force_rate;
 		struct intel_dp_link_training *training;
+		struct intel_dp_link_caps *caps;
 	} link;
 	bool reset_link_params;
 	int mso_link_count;
drivers/gpu/drm/i915/display/intel_dp.c +9 -0
index 4f016adef93be..e63e341aa5c8d 100644
@@ -71,6 +71,7 @@
 #include "intel_dp.h"
 #include "intel_dp_aux.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"
@@ -7357,6 +7358,13 @@ int intel_dp_link_init(struct intel_dp *intel_dp)
 	if (!intel_dp->link.training)
 		return -ENOMEM;
 
+	intel_dp->link.caps = intel_dp_link_caps_init(intel_dp);
+	if (!intel_dp->link.caps) {
+		intel_dp_link_training_cleanup(intel_dp->link.training);
+
+		return -ENOMEM;
+	}
+
 	return 0;
 }
 
@@ -7368,5 +7376,6 @@ int intel_dp_link_init(struct intel_dp *intel_dp)
  */
 void intel_dp_link_cleanup(struct intel_dp *intel_dp)
 {
+	intel_dp_link_caps_cleanup(intel_dp->link.caps);
 	intel_dp_link_training_cleanup(intel_dp->link.training);
 }
drivers/gpu/drm/i915/display/intel_dp_link_caps.c new file +47 -0

47 lines not on this page · raw message

drivers/gpu/drm/i915/display/intel_dp_link_caps.h new file +12 -0
new file mode 100644
index 0000000000000..050b279463d6e
@@ -0,0 +1,12 @@
+/* SPDX-License-Identifier: MIT */
+/* Copyright © 2026 Intel Corporation */
+
+#ifndef __INTEL_DP_LINK_CAPS_H__
+#define __INTEL_DP_LINK_CAPS_H__
+
+struct intel_dp;
+
+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);
+
+#endif /* __INTEL_DP_LINK_CAPS_H__ */
drivers/gpu/drm/xe/Makefile +1 -0
index 95666f950a6fc..9450d487123a3 100644
@@ -276,6 +276,7 @@ xe-$(CONFIG_DRM_XE_DISPLAY) += \
 	i915-display/intel_dp_aux.o \
 	i915-display/intel_dp_aux_backlight.o \
 	i915-display/intel_dp_hdcp.o \
+	i915-display/intel_dp_link_caps.o \
 	i915-display/intel_dp_link_training.o \
 	i915-display/intel_dp_mst.o \
 	i915-display/intel_dp_test.o \
Signature · 1 line
2.49.1
author
#50 lore raw

PATCH 30/108 drm/i915/dp_link_caps: Move common rate helpers to link caps

In reply to Imre Deak

Move the helpers handling common link rates to intel_dp_link_caps.c. Their functionality is part of the link capability logic and will be updated to use the link capability state in follow-up changes.

---
 drivers/gpu/drm/i915/display/intel_dp.c       | 27 +----------------
 drivers/gpu/drm/i915/display/intel_dp.h       |  3 +-
 .../gpu/drm/i915/display/intel_dp_link_caps.c | 30 +++++++++++++++++++
 .../gpu/drm/i915/display/intel_dp_link_caps.h |  5 ++++
 .../drm/i915/display/intel_dp_link_training.c |  1 +
 .../gpu/drm/i915/display/intel_dp_tunnel.c    |  1 +
 6 files changed, 39 insertions(+), 28 deletions(-)
drivers/gpu/drm/i915/display/intel_dp.c +1 -26
index e63e341aa5c8d..1f903f9acec15 100644
@@ -314,7 +314,7 @@ static void intel_dp_set_max_sink_lane_count(struct intel_dp *intel_dp)
 }
 
 /* Get length of rates array potentially limited by max_rate. */
-static int intel_dp_rate_limit_len(const int *rates, int len, int max_rate)
+int intel_dp_rate_limit_len(const int *rates, int len, int max_rate)
 {
 	int i;
 
@@ -327,31 +327,6 @@ static int intel_dp_rate_limit_len(const int *rates, int len, int max_rate)
 	return 0;
 }
 
-/* Get length of common rates array potentially limited by max_rate. */
-static int intel_dp_common_len_rate_limit(const struct intel_dp *intel_dp,
-					  int max_rate)
-{
-	return intel_dp_rate_limit_len(intel_dp->common_rates,
-				       intel_dp->num_common_rates, max_rate);
-}
-
-int intel_dp_common_rate(struct intel_dp *intel_dp, int index)
-{
-	struct intel_display *display = to_intel_display(intel_dp);
-
-	if (drm_WARN_ON(display->drm,
-			index < 0 || index >= intel_dp->num_common_rates))
-		return 162000;
-
-	return intel_dp->common_rates[index];
-}
-
-/* Theoretical max between source and sink */
-int intel_dp_max_common_rate(struct intel_dp *intel_dp)
-{
-	return intel_dp_common_rate(intel_dp, intel_dp->num_common_rates - 1);
-}
-
 int intel_dp_max_source_lane_count(struct intel_digital_port *dig_port)
 {
 	int vbt_max_lanes = intel_bios_dp_max_lane_count(dig_port->base.devdata);
drivers/gpu/drm/i915/display/intel_dp.h +1 -2
index 3c0d229eb1f55..8f7607dc412d0 100644
@@ -97,14 +97,13 @@ void intel_edp_backlight_off(const struct drm_connector_state *conn_state);
 void intel_edp_fixup_vbt_bpp(struct intel_encoder *encoder, int pipe_bpp);
 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_max_common_rate(struct intel_dp *intel_dp);
 int intel_dp_max_common_lane_count(struct intel_dp *intel_dp);
-int intel_dp_common_rate(struct intel_dp *intel_dp, int index);
 int intel_dp_rate_index(const int *rates, int len, int rate);
 int intel_dp_link_config_index(struct intel_dp *intel_dp, int link_rate, int lane_count);
 void intel_dp_link_config_get(struct intel_dp *intel_dp, int idx, int *link_rate, int *lane_count);
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +30 -0
index 335382d193475..5711dde8d6eed 100644
@@ -5,12 +5,42 @@
 
 #include <linux/slab.h>
 
+#include <drm/drm_print.h>
+
+#include "intel_display_core.h"
+#include "intel_display_types.h"
+#include "intel_dp.h"
 #include "intel_dp_link_caps.h"
 
 struct intel_dp_link_caps {
 	struct intel_dp *dp;
 };
 
+/* Get length of common rates array potentially limited by max_rate. */
+int intel_dp_common_len_rate_limit(const struct intel_dp *intel_dp,
+				   int max_rate)
+{
+	return intel_dp_rate_limit_len(intel_dp->common_rates,
+				       intel_dp->num_common_rates, max_rate);
+}
+
+int intel_dp_common_rate(struct intel_dp *intel_dp, int index)
+{
+	struct intel_display *display = to_intel_display(intel_dp);
+
+	if (drm_WARN_ON(display->drm,
+			index < 0 || index >= intel_dp->num_common_rates))
+		return 162000;
+
+	return intel_dp->common_rates[index];
+}
+
+/* Theoretical max between source and sink */
+int intel_dp_max_common_rate(struct intel_dp *intel_dp)
+{
+	return intel_dp_common_rate(intel_dp, intel_dp->num_common_rates - 1);
+}
+
 /**
  * intel_dp_link_caps_init - allocate and initialize link caps state
  * @intel_dp: DP encoder state
drivers/gpu/drm/i915/display/intel_dp_link_caps.h +5 -0
index 050b279463d6e..3248777d1287f 100644
@@ -6,6 +6,11 @@
 
 struct intel_dp;
 
+int intel_dp_common_len_rate_limit(const struct intel_dp *intel_dp,
+				   int max_rate);
+int intel_dp_common_rate(struct intel_dp *intel_dp, int index);
+int intel_dp_max_common_rate(struct intel_dp *intel_dp);
+
 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);
 
drivers/gpu/drm/i915/display/intel_dp_link_training.c +1 -0
index 810227328d002..9572ea509a8af 100644
@@ -33,6 +33,7 @@
 #include "intel_display_types.h"
 #include "intel_display_utils.h"
 #include "intel_dp.h"
+#include "intel_dp_link_caps.h"
 #include "intel_dp_link_training.h"
 #include "intel_dp_mst.h"
 #include "intel_encoder.h"
drivers/gpu/drm/i915/display/intel_dp_tunnel.c +1 -0
index 11712a151f729..64fd4f09d1cdd 100644
@@ -11,6 +11,7 @@
 #include "intel_display_limits.h"
 #include "intel_display_types.h"
 #include "intel_dp.h"
+#include "intel_dp_link_caps.h"
 #include "intel_dp_link_training.h"
 #include "intel_dp_mst.h"
 #include "intel_dp_tunnel.h"
Signature · 1 line
2.49.1
author
#51 lore raw

PATCH 31/108 drm/i915/dp_link_caps: Move forced link param helpers to link caps

In reply to Imre Deak

Move the helpers handling forced link parameters to intel_dp_link_caps.c. Their functionality is part of the link capability logic and will be updated to use the link capability state in follow-up changes.

Return the forced link rate and lane count through a
struct intel_dp_link_config, which is the canonical way the rest of the link capability API will also accept and return link configurations.

---
 drivers/gpu/drm/i915/display/intel_dp.c       | 40 ++++++++++---------
 .../gpu/drm/i915/display/intel_dp_link_caps.c | 22 ++++++++++
 .../gpu/drm/i915/display/intel_dp_link_caps.h |  5 +++
 3 files changed, 48 insertions(+), 19 deletions(-)
drivers/gpu/drm/i915/display/intel_dp.c +21 -19
index 1f903f9acec15..0aab37dcce97a 100644
@@ -353,17 +353,16 @@ int intel_dp_max_common_lane_count(struct intel_dp *intel_dp)
 	return min3(source_max, sink_max, lane_max);
 }
 
-static int forced_lane_count(struct intel_dp *intel_dp)
-{
-	return clamp(intel_dp->link.force_lane_count, 1, intel_dp_max_common_lane_count(intel_dp));
-}
-
 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 forced_params;
 	int lane_count;
 
+	intel_dp_link_caps_get_forced_params(link_caps, &forced_params);
+
 	if (intel_dp->link.force_lane_count)
-		lane_count = forced_lane_count(intel_dp);
+		lane_count = forced_params.lane_count;
 	else
 		lane_count = intel_dp->link.max_lane_count;
 
@@ -380,8 +379,12 @@ int intel_dp_max_lane_count(struct intel_dp *intel_dp)
 
 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 (intel_dp->link.force_lane_count)
-		return forced_lane_count(intel_dp);
+		return forced_params.lane_count;
 
 	return 1;
 }
@@ -1657,21 +1660,16 @@ static void intel_dp_print_rates(struct intel_dp *intel_dp)
 	drm_dbg_kms(display->drm, "common rates: %s\n", seq_buf_str(&s));
 }
 
-static int forced_link_rate(struct intel_dp *intel_dp)
-{
-	int len = intel_dp_common_len_rate_limit(intel_dp, intel_dp->link.force_rate);
-
-	if (len == 0)
-		return intel_dp_common_rate(intel_dp, 0);
-
-	return intel_dp_common_rate(intel_dp, len - 1);
-}
-
 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 forced_params;
+
+	intel_dp_link_caps_get_forced_params(link_caps, &forced_params);
+
 	if (intel_dp->link.force_rate)
-		return forced_link_rate(intel_dp);
+		return forced_params.rate;
 
 	return intel_dp->link.max_rate;
 }
@@ -1679,8 +1677,12 @@ intel_dp_max_link_rate(struct intel_dp *intel_dp)
 static int
 intel_dp_min_link_rate(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 (intel_dp->link.force_rate)
-		return forced_link_rate(intel_dp);
+		return forced_params.rate;
 
 	return intel_dp_common_rate(intel_dp, 0);
 }
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +22 -0
index 5711dde8d6eed..0a2db7d65e20d 100644
@@ -41,6 +41,28 @@ int intel_dp_max_common_rate(struct intel_dp *intel_dp)
 	return intel_dp_common_rate(intel_dp, intel_dp->num_common_rates - 1);
 }
 
+static int forced_lane_count(struct intel_dp *intel_dp)
+{
+	return clamp(intel_dp->link.force_lane_count, 1, intel_dp_max_common_lane_count(intel_dp));
+}
+
+static int forced_link_rate(struct intel_dp *intel_dp)
+{
+	int len = intel_dp_common_len_rate_limit(intel_dp, intel_dp->link.force_rate);
+
+	if (len == 0)
+		return intel_dp_common_rate(intel_dp, 0);
+
+	return intel_dp_common_rate(intel_dp, len - 1);
+}
+
+void intel_dp_link_caps_get_forced_params(struct intel_dp_link_caps *link_caps,
+					  struct intel_dp_link_config *forced_params)
+{
+	forced_params->rate = forced_link_rate(link_caps->dp);
+	forced_params->lane_count = forced_lane_count(link_caps->dp);
+}
+
 /**
  * intel_dp_link_caps_init - allocate and initialize link caps state
  * @intel_dp: DP encoder state
drivers/gpu/drm/i915/display/intel_dp_link_caps.h +5 -0
index 3248777d1287f..61dbce86ee3d0 100644
@@ -5,12 +5,17 @@
 #define __INTEL_DP_LINK_CAPS_H__
 
 struct intel_dp;
+struct intel_dp_link_caps;
+struct intel_dp_link_config;
 
 int intel_dp_common_len_rate_limit(const struct intel_dp *intel_dp,
 				   int max_rate);
 int intel_dp_common_rate(struct intel_dp *intel_dp, int index);
 int intel_dp_max_common_rate(struct intel_dp *intel_dp);
 
+void intel_dp_link_caps_get_forced_params(struct intel_dp_link_caps *link_caps,
+					  struct intel_dp_link_config *forced_params);
+
 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);
 
Signature · 1 line
2.49.1
author
#52 lore raw

PATCH 32/108 drm/i915/dp: Simplify querying of forced link parameters

In reply to Imre Deak

Simplify querying the forced link rate and lane count by performing the zero checks inside the helpers, allowing callers to use the returned values directly.

---
 drivers/gpu/drm/i915/display/intel_dp.c           | 8 ++++----
 drivers/gpu/drm/i915/display/intel_dp_link_caps.c | 9 ++++++++-
 2 files changed, 12 insertions(+), 5 deletions(-)
drivers/gpu/drm/i915/display/intel_dp.c +4 -4
index 0aab37dcce97a..52d843b05c38c 100644
@@ -361,7 +361,7 @@ int intel_dp_max_lane_count(struct intel_dp *intel_dp)
 
 	intel_dp_link_caps_get_forced_params(link_caps, &forced_params);
 
-	if (intel_dp->link.force_lane_count)
+	if (forced_params.lane_count)
 		lane_count = forced_params.lane_count;
 	else
 		lane_count = intel_dp->link.max_lane_count;
@@ -383,7 +383,7 @@ static int intel_dp_min_lane_count(struct intel_dp *intel_dp)
 
 	intel_dp_link_caps_get_forced_params(intel_dp->link.caps, &forced_params);
 
-	if (intel_dp->link.force_lane_count)
+	if (forced_params.lane_count)
 		return forced_params.lane_count;
 
 	return 1;
@@ -1668,7 +1668,7 @@ intel_dp_max_link_rate(struct intel_dp *intel_dp)
 
 	intel_dp_link_caps_get_forced_params(link_caps, &forced_params);
 
-	if (intel_dp->link.force_rate)
+	if (forced_params.rate)
 		return forced_params.rate;
 
 	return intel_dp->link.max_rate;
@@ -1681,7 +1681,7 @@ intel_dp_min_link_rate(struct intel_dp *intel_dp)
 
 	intel_dp_link_caps_get_forced_params(intel_dp->link.caps, &forced_params);
 
-	if (intel_dp->link.force_rate)
+	if (forced_params.rate)
 		return forced_params.rate;
 
 	return intel_dp_common_rate(intel_dp, 0);
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +8 -1
index 0a2db7d65e20d..1892fc0ff46ef 100644
@@ -43,13 +43,20 @@ int intel_dp_max_common_rate(struct intel_dp *intel_dp)
 
 static int forced_lane_count(struct intel_dp *intel_dp)
 {
+	if (!intel_dp->link.force_lane_count)
+		return 0;
+
 	return clamp(intel_dp->link.force_lane_count, 1, intel_dp_max_common_lane_count(intel_dp));
 }
 
 static int forced_link_rate(struct intel_dp *intel_dp)
 {
-	int len = intel_dp_common_len_rate_limit(intel_dp, intel_dp->link.force_rate);
+	int len;
 
+	if (!intel_dp->link.force_rate)
+		return 0;
+
+	len = intel_dp_common_len_rate_limit(intel_dp, intel_dp->link.force_rate);
 	if (len == 0)
 		return intel_dp_common_rate(intel_dp, 0);
 
Signature · 1 line
2.49.1
author
#53 lore raw

PATCH 33/108 drm/i915/dp_link_caps: Move forced and max link debugfs entries to link caps

In reply to Imre Deak

Move the debugfs entries for the forced and max DP link parameters to intel_dp_link_caps. Their functionality is part of the link capability logic and will be updated to use the link capability state in follow-up changes.

---
 .../drm/i915/display/intel_display_debugfs.c  |   2 +
 .../gpu/drm/i915/display/intel_dp_link_caps.c | 273 ++++++++++++++++++
 .../gpu/drm/i915/display/intel_dp_link_caps.h |   3 +
 .../drm/i915/display/intel_dp_link_training.c | 263 -----------------
 4 files changed, 278 insertions(+), 263 deletions(-)
drivers/gpu/drm/i915/display/intel_display_debugfs.c +2 -0
index 81bef000a4e3e..448fc985c5b58 100644
@@ -32,6 +32,7 @@
 #include "intel_display_types.h"
 #include "intel_dmc.h"
 #include "intel_dp.h"
+#include "intel_dp_link_caps.h"
 #include "intel_dp_link_training.h"
 #include "intel_dp_mst.h"
 #include "intel_dp_test.h"
@@ -1336,6 +1337,7 @@ void intel_connector_debugfs_add(struct intel_connector *connector)
 	intel_psr_connector_debugfs_add(connector);
 	intel_alpm_lobf_debugfs_add(connector);
 	intel_dp_link_training_debugfs_add(connector);
+	intel_dp_link_caps_debugfs_add(connector);
 	intel_link_bw_connector_debugfs_add(connector);
 
 	if (DISPLAY_VER(display) >= 11 &&
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +273 -0

285 lines not on this page · raw message

drivers/gpu/drm/i915/display/intel_dp_link_caps.h +3 -0
index 61dbce86ee3d0..c6a84891db464 100644
@@ -4,6 +4,7 @@
 #ifndef __INTEL_DP_LINK_CAPS_H__
 #define __INTEL_DP_LINK_CAPS_H__
 
+struct intel_connector;
 struct intel_dp;
 struct intel_dp_link_caps;
 struct intel_dp_link_config;
@@ -16,6 +17,8 @@ int intel_dp_max_common_rate(struct intel_dp *intel_dp);
 void intel_dp_link_caps_get_forced_params(struct intel_dp_link_caps *link_caps,
 					  struct intel_dp_link_config *forced_params);
 
+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);
 
drivers/gpu/drm/i915/display/intel_dp_link_training.c +0 -263

275 lines not on this page · raw message

Signature · 1 line
2.49.1
author
#54 lore raw

PATCH 34/108 drm/i915/dp_link_training: Use helpers to get forced link params

In reply to Imre Deak

Use intel_dp_link_caps_get_forced_params() in the link training fallback code instead of directly accessing the state. This allows the link caps module to track changes to forced parameters internally.

---
 .../drm/i915/display/intel_dp_link_training.c | 26 ++++++++++++++-----
 1 file changed, 20 insertions(+), 6 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_training.c +20 -6
index 3455e4daf1faf..5218220b82b0b 100644
@@ -1760,18 +1760,26 @@ 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 forced_lane_count;
+	int forced_rate;
 	int link_rate;
 	int lane_count;
 	int i;
 
+	intel_dp_link_caps_get_forced_params(link_caps, &forced_params);
+	forced_rate = forced_params.rate;
+	forced_lane_count = forced_params.lane_count;
+
 	i = intel_dp_link_config_index(intel_dp, crtc_state->port_clock, crtc_state->lane_count);
 	for (i--; i >= 0; i--) {
 		intel_dp_link_config_get(intel_dp, i, &link_rate, &lane_count);
 
-		if ((intel_dp->link.force_rate &&
-		     intel_dp->link.force_rate != link_rate) ||
-		    (intel_dp->link.force_lane_count &&
-		     intel_dp->link.force_lane_count != lane_count))
+		if ((forced_rate &&
+		     forced_rate != link_rate) ||
+		    (forced_lane_count &&
+		     forced_lane_count != lane_count))
 			continue;
 
 		break;
@@ -1788,10 +1796,13 @@ static bool reduce_link_params_in_bw_order(struct intel_dp *intel_dp,
 
 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;
 
-	if (intel_dp->link.force_rate)
+	intel_dp_link_caps_get_forced_params(link_caps, &forced_params);
+	if (forced_params.rate)
 		return -1;
 
 	rate_index = intel_dp_rate_index(intel_dp->common_rates,
@@ -1812,7 +1823,10 @@ static int reduce_link_rate(struct intel_dp *intel_dp, int current_rate)
 
 static int reduce_lane_count(struct intel_dp *intel_dp, int current_lane_count)
 {
-	if (intel_dp->link.force_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)
Signature · 1 line
2.49.1
author
#55 lore raw

PATCH 35/108 drm/i915/dp_link_caps: Move forced link params to link_caps

In reply to Imre Deak

Move tracking of the forced link parameters from struct intel_dp to struct intel_dp_link_caps.

Previous changes made all users access these parameters through the link caps helpers, so the state can now be kept internal to the link caps module.

---
 .../drm/i915/display/intel_display_types.h    |  2 --
 .../gpu/drm/i915/display/intel_dp_link_caps.c | 30 ++++++++++++++-----
 2 files changed, 22 insertions(+), 10 deletions(-)
drivers/gpu/drm/i915/display/intel_display_types.h +0 -2
index d11686ce2963d..1fae80c8c241b 100644
@@ -1856,8 +1856,6 @@ struct intel_dp {
 		 */
 		int mst_probed_lane_count;
 		int mst_probed_rate;
-		int force_lane_count;
-		int force_rate;
 		struct intel_dp_link_training *training;
 		struct intel_dp_link_caps *caps;
 	} link;
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +22 -8
index ed05a8597fc01..e11a36ea2d178 100644
@@ -15,6 +15,12 @@
 
 struct intel_dp_link_caps {
 	struct intel_dp *dp;
+
+	/*
+	 * Forced parameters requested via debugfs. Remains set across sink
+	 * disconnects.
+	 */
+	struct intel_dp_link_config forced_params;
 };
 
 /* Get length of common rates array potentially limited by max_rate. */
@@ -44,20 +50,24 @@ int intel_dp_max_common_rate(struct intel_dp *intel_dp)
 
 static int forced_lane_count(struct intel_dp *intel_dp)
 {
-	if (!intel_dp->link.force_lane_count)
+	struct intel_dp_link_caps *link_caps = intel_dp->link.caps;
+
+	if (!link_caps->forced_params.lane_count)
 		return 0;
 
-	return clamp(intel_dp->link.force_lane_count, 1, intel_dp_max_common_lane_count(intel_dp));
+	return clamp(link_caps->forced_params.lane_count,
+		     1, intel_dp_max_common_lane_count(intel_dp));
 }
 
 static int forced_link_rate(struct intel_dp *intel_dp)
 {
+	struct intel_dp_link_caps *link_caps = intel_dp->link.caps;
 	int len;
 
-	if (!intel_dp->link.force_rate)
+	if (!link_caps->forced_params.rate)
 		return 0;
 
-	len = intel_dp_common_len_rate_limit(intel_dp, intel_dp->link.force_rate);
+	len = intel_dp_common_len_rate_limit(intel_dp, link_caps->forced_params.rate);
 	if (len == 0)
 		return intel_dp_common_rate(intel_dp, 0);
 
@@ -76,6 +86,7 @@ static int i915_dp_force_link_rate_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;
 	int current_rate = -1;
 	int force_rate;
 	int err;
@@ -90,7 +101,7 @@ static int i915_dp_force_link_rate_show(struct seq_file *m, void *data)
 	if (intel_dp->link.active)
 		current_rate = intel_dp->link_rate;
 
-	force_rate = intel_dp->link.force_rate;
+	force_rate = link_caps->forced_params.rate;
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
 
@@ -150,6 +161,7 @@ static ssize_t i915_dp_force_link_rate_write(struct file *file,
 	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;
 	int rate;
 	int err;
 
@@ -164,7 +176,7 @@ static ssize_t i915_dp_force_link_rate_write(struct file *file,
 	intel_dp_flush_connector_commits(connector);
 
 	intel_dp_reset_link_params(intel_dp);
-	intel_dp->link.force_rate = rate;
+	link_caps->forced_params.rate = rate;
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
 
@@ -179,6 +191,7 @@ static int i915_dp_force_lane_count_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;
 	int current_lane_count = -1;
 	int force_lane_count;
 	int err;
@@ -192,7 +205,7 @@ static int i915_dp_force_lane_count_show(struct seq_file *m, void *data)
 
 	if (intel_dp->link.active)
 		current_lane_count = intel_dp->lane_count;
-	force_lane_count = intel_dp->link.force_lane_count;
+	force_lane_count = link_caps->forced_params.lane_count;
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
 
@@ -256,6 +269,7 @@ static ssize_t i915_dp_force_lane_count_write(struct file *file,
 	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;
 	int lane_count;
 	int err;
 
@@ -270,7 +284,7 @@ static ssize_t i915_dp_force_lane_count_write(struct file *file,
 	intel_dp_flush_connector_commits(connector);
 
 	intel_dp_reset_link_params(intel_dp);
-	intel_dp->link.force_lane_count = lane_count;
+	link_caps->forced_params.lane_count = lane_count;
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
 
Signature · 1 line
2.49.1
author
#56 lore raw

PATCH 36/108 drm/i915/dp_link_caps: Move link config helpers to link caps

In reply to Imre Deak

Move the helpers handling link configurations to intel_dp_link_caps.c. Their functionality is part of the link capability logic and will be updated to use the link capability state in follow-up changes.

---
 drivers/gpu/drm/i915/display/intel_dp.c       | 101 -----------------
 drivers/gpu/drm/i915/display/intel_dp.h       |   2 -
 .../gpu/drm/i915/display/intel_dp_link_caps.c | 102 ++++++++++++++++++
 .../gpu/drm/i915/display/intel_dp_link_caps.h |   5 +
 4 files changed, 107 insertions(+), 103 deletions(-)
drivers/gpu/drm/i915/display/intel_dp.c +0 -101
index 52d843b05c38c..25f8ac21ce60c 100644
@@ -33,7 +33,6 @@
 #include <linux/notifier.h>
 #include <linux/seq_buf.h>
 #include <linux/slab.h>
-#include <linux/sort.h>
 #include <linux/string_helpers.h>
 #include <linux/timekeeping.h>
 #include <linux/types.h>
@@ -666,106 +665,6 @@ int intel_dp_rate_index(const int *rates, int len, int rate)
 	return -1;
 }
 
-static int intel_dp_link_config_rate(struct intel_dp *intel_dp,
-				     const struct intel_dp_link_config_entry *lc)
-{
-	return intel_dp_common_rate(intel_dp, lc->link_rate_idx);
-}
-
-static int intel_dp_link_config_lane_count(const struct intel_dp_link_config_entry *lc)
-{
-	return 1 << lc->lane_count_exp;
-}
-
-static int intel_dp_link_config_bw(struct intel_dp *intel_dp,
-				   const struct intel_dp_link_config_entry *lc)
-{
-	return drm_dp_max_dprx_data_rate(intel_dp_link_config_rate(intel_dp, lc),
-					 intel_dp_link_config_lane_count(lc));
-}
-
-static int link_config_cmp_by_bw(const void *a, const void *b, const void *p)
-{
-	struct intel_dp *intel_dp = (struct intel_dp *)p;	/* remove const */
-	const struct intel_dp_link_config_entry *lc_a = a;
-	const struct intel_dp_link_config_entry *lc_b = b;
-	int bw_a = intel_dp_link_config_bw(intel_dp, lc_a);
-	int bw_b = intel_dp_link_config_bw(intel_dp, lc_b);
-
-	if (bw_a != bw_b)
-		return bw_a - bw_b;
-
-	return intel_dp_link_config_rate(intel_dp, lc_a) -
-	       intel_dp_link_config_rate(intel_dp, lc_b);
-}
-
-static void intel_dp_link_config_init(struct intel_dp *intel_dp)
-{
-	struct intel_display *display = to_intel_display(intel_dp);
-	struct intel_dp_link_config_entry *lc;
-	int num_common_lane_configs;
-	int i;
-	int j;
-
-	if (drm_WARN_ON(display->drm, !is_power_of_2(intel_dp_max_common_lane_count(intel_dp))))
-		return;
-
-	num_common_lane_configs = ilog2(intel_dp_max_common_lane_count(intel_dp)) + 1;
-
-	if (drm_WARN_ON(display->drm, intel_dp->num_common_rates * num_common_lane_configs >
-				    ARRAY_SIZE(intel_dp->link.configs)))
-		return;
-
-	intel_dp->link.num_configs = intel_dp->num_common_rates * num_common_lane_configs;
-
-	lc = &intel_dp->link.configs[0];
-	for (i = 0; i < intel_dp->num_common_rates; i++) {
-		for (j = 0; j < num_common_lane_configs; j++) {
-			lc->lane_count_exp = j;
-			lc->link_rate_idx = i;
-
-			lc++;
-		}
-	}
-
-	sort_r(intel_dp->link.configs, intel_dp->link.num_configs,
-	       sizeof(intel_dp->link.configs[0]),
-	       link_config_cmp_by_bw, NULL,
-	       intel_dp);
-}
-
-void intel_dp_link_config_get(struct intel_dp *intel_dp, int idx, int *link_rate, int *lane_count)
-{
-	struct intel_display *display = to_intel_display(intel_dp);
-	const struct intel_dp_link_config_entry *lc;
-
-	if (drm_WARN_ON(display->drm, idx < 0 || idx >= intel_dp->link.num_configs))
-		idx = 0;
-
-	lc = &intel_dp->link.configs[idx];
-
-	*link_rate = intel_dp_link_config_rate(intel_dp, lc);
-	*lane_count = intel_dp_link_config_lane_count(lc);
-}
-
-int intel_dp_link_config_index(struct intel_dp *intel_dp, int link_rate, int lane_count)
-{
-	int link_rate_idx = intel_dp_rate_index(intel_dp->common_rates, intel_dp->num_common_rates,
-						link_rate);
-	int lane_count_exp = ilog2(lane_count);
-	int i;
-
-	for (i = 0; i < intel_dp->link.num_configs; i++) {
-		const struct intel_dp_link_config_entry *lc = &intel_dp->link.configs[i];
-
-		if (lc->lane_count_exp == lane_count_exp &&
-		    lc->link_rate_idx == link_rate_idx)
-			return i;
-	}
-
-	return -1;
-}
-
 static bool current_common_caps_match(struct intel_dp *intel_dp,
 				      const int *rates, int num_rates)
 {
drivers/gpu/drm/i915/display/intel_dp.h +0 -2
index 8f7607dc412d0..363907d463486 100644
@@ -105,8 +105,6 @@ 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_max_common_lane_count(struct intel_dp *intel_dp);
 int intel_dp_rate_index(const int *rates, int len, int rate);
-int intel_dp_link_config_index(struct intel_dp *intel_dp, int link_rate, int lane_count);
-void intel_dp_link_config_get(struct intel_dp *intel_dp, int idx, int *link_rate, int *lane_count);
 void intel_dp_update_sink_caps(struct intel_dp *intel_dp);
 void intel_dp_reset_link_params(struct intel_dp *intel_dp);
 
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +102 -0

115 lines not on this page · raw message

drivers/gpu/drm/i915/display/intel_dp_link_caps.h +5 -0
index c6a84891db464..dab956e804b95 100644
@@ -17,6 +17,11 @@ int intel_dp_max_common_rate(struct intel_dp *intel_dp);
 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 *intel_dp, int link_rate, int lane_count);
+void intel_dp_link_config_get(struct intel_dp *intel_dp, int idx, int *link_rate, int *lane_count);
+
+void intel_dp_link_config_init(struct intel_dp *intel_dp);
+
 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);
Signature · 1 line
2.49.1
author
#57 lore raw

PATCH 37/108 drm/i915/dp_link_caps: Move link config tracking to link_caps

In reply to Imre Deak

Move tracking of the link configurations from struct intel_dp to struct intel_dp_link_caps.

Previous changes moved the helpers operating on configurations to the link caps module, so the state can now be kept internal to that module.

---
 .../drm/i915/display/intel_display_types.h    | 12 -------
 .../gpu/drm/i915/display/intel_dp_link_caps.c | 36 ++++++++++++++-----
 2 files changed, 27 insertions(+), 21 deletions(-)
drivers/gpu/drm/i915/display/intel_display_types.h +0 -12
index 1fae80c8c241b..97d2836d0e159 100644
@@ -1832,18 +1832,6 @@ struct intel_dp {
 	struct {
 		/* TODO: move the rest of link specific fields to here */
 		bool active;
-		/* common rate,lane_count configs in bw order */
-		int num_configs;
-#define INTEL_DP_MAX_LANE_COUNT			4
-#define INTEL_DP_MAX_SUPPORTED_LANE_CONFIGS	(ilog2(INTEL_DP_MAX_LANE_COUNT) + 1)
-#define INTEL_DP_LANE_COUNT_EXP_BITS		order_base_2(INTEL_DP_MAX_SUPPORTED_LANE_CONFIGS)
-#define INTEL_DP_LINK_RATE_IDX_BITS		(BITS_PER_TYPE(u8) - INTEL_DP_LANE_COUNT_EXP_BITS)
-#define INTEL_DP_MAX_LINK_CONFIGS		(DP_MAX_SUPPORTED_RATES * \
-						 INTEL_DP_MAX_SUPPORTED_LANE_CONFIGS)
-		struct intel_dp_link_config_entry {
-			u8 link_rate_idx:INTEL_DP_LINK_RATE_IDX_BITS;
-			u8 lane_count_exp:INTEL_DP_LANE_COUNT_EXP_BITS;
-		} configs[INTEL_DP_MAX_LINK_CONFIGS];
 		/* Max lane count for the current link */
 		int max_lane_count;
 		/* Max rate for the current link */
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +27 -9
index 9fadab008e8ee..0034dd439e59d 100644
@@ -3,10 +3,12 @@
  * Copyright © 2026 Intel Corporation
  */
 
+#include <linux/bitops.h>
 #include <linux/debugfs.h>
 #include <linux/log2.h>
 #include <linux/slab.h>
 #include <linux/sort.h>
+#include <linux/types.h>
 
 #include <drm/drm_print.h>
 
@@ -18,6 +20,19 @@
 struct intel_dp_link_caps {
 	struct intel_dp *dp;
 
+	/* common rate,lane_count configs in bw order */
+	int num_configs;
+#define INTEL_DP_MAX_LANE_COUNT			4
+#define INTEL_DP_MAX_SUPPORTED_LANE_CONFIGS	(ilog2(INTEL_DP_MAX_LANE_COUNT) + 1)
+#define INTEL_DP_LANE_COUNT_EXP_BITS		order_base_2(INTEL_DP_MAX_SUPPORTED_LANE_CONFIGS)
+#define INTEL_DP_LINK_RATE_IDX_BITS		(BITS_PER_TYPE(u8) - INTEL_DP_LANE_COUNT_EXP_BITS)
+#define INTEL_DP_MAX_LINK_CONFIGS		(DP_MAX_SUPPORTED_RATES * \
+						 INTEL_DP_MAX_SUPPORTED_LANE_CONFIGS)
+	struct intel_dp_link_config_entry {
+		u8 link_rate_idx:INTEL_DP_LINK_RATE_IDX_BITS;
+		u8 lane_count_exp:INTEL_DP_LANE_COUNT_EXP_BITS;
+	} configs[INTEL_DP_MAX_LINK_CONFIGS];
+
 	/*
 	 * Forced parameters requested via debugfs. Remains set across sink
 	 * disconnects.
@@ -118,6 +133,7 @@ static int link_config_cmp_by_bw(const void *a, const void *b, const void *p)
 
 void intel_dp_link_config_init(struct intel_dp *intel_dp)
 {
+	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_entry *lc;
 	int num_common_lane_configs;
@@ -130,12 +146,12 @@ void intel_dp_link_config_init(struct intel_dp *intel_dp)
 	num_common_lane_configs = ilog2(intel_dp_max_common_lane_count(intel_dp)) + 1;
 
 	if (drm_WARN_ON(display->drm, intel_dp->num_common_rates * num_common_lane_configs >
-				    ARRAY_SIZE(intel_dp->link.configs)))
+				    ARRAY_SIZE(link_caps->configs)))
 		return;
 
-	intel_dp->link.num_configs = intel_dp->num_common_rates * num_common_lane_configs;
+	link_caps->num_configs = intel_dp->num_common_rates * num_common_lane_configs;
 
-	lc = &intel_dp->link.configs[0];
+	lc = &link_caps->configs[0];
 	for (i = 0; i < intel_dp->num_common_rates; i++) {
 		for (j = 0; j < num_common_lane_configs; j++) {
 			lc->lane_count_exp = j;
@@ -145,21 +161,22 @@ void intel_dp_link_config_init(struct intel_dp *intel_dp)
 		}
 	}
 
-	sort_r(intel_dp->link.configs, intel_dp->link.num_configs,
-	       sizeof(intel_dp->link.configs[0]),
+	sort_r(link_caps->configs, link_caps->num_configs,
+	       sizeof(link_caps->configs[0]),
 	       link_config_cmp_by_bw, NULL,
 	       intel_dp);
 }
 
 void intel_dp_link_config_get(struct intel_dp *intel_dp, int idx, int *link_rate, int *lane_count)
 {
+	struct intel_dp_link_caps *link_caps = intel_dp->link.caps;
 	struct intel_display *display = to_intel_display(intel_dp);
 	const struct intel_dp_link_config_entry *lc;
 
-	if (drm_WARN_ON(display->drm, idx < 0 || idx >= intel_dp->link.num_configs))
+	if (drm_WARN_ON(display->drm, idx < 0 || idx >= link_caps->num_configs))
 		idx = 0;
 
-	lc = &intel_dp->link.configs[idx];
+	lc = &link_caps->configs[idx];
 
 	*link_rate = intel_dp_link_config_rate(intel_dp, lc);
 	*lane_count = intel_dp_link_config_lane_count(lc);
@@ -167,13 +184,14 @@ void intel_dp_link_config_get(struct intel_dp *intel_dp, int idx, int *link_rate
 
 int intel_dp_link_config_index(struct intel_dp *intel_dp, int link_rate, int lane_count)
 {
+	struct intel_dp_link_caps *link_caps = intel_dp->link.caps;
 	int link_rate_idx = intel_dp_rate_index(intel_dp->common_rates, intel_dp->num_common_rates,
 						link_rate);
 	int lane_count_exp = ilog2(lane_count);
 	int i;
 
-	for (i = 0; i < intel_dp->link.num_configs; i++) {
-		const struct intel_dp_link_config_entry *lc = &intel_dp->link.configs[i];
+	for (i = 0; i < link_caps->num_configs; i++) {
+		const struct intel_dp_link_config_entry *lc = &link_caps->configs[i];
 
 		if (lc->lane_count_exp == lane_count_exp &&
 		    lc->link_rate_idx == link_rate_idx)
Signature · 1 line
2.49.1
author
#58 lore raw

PATCH 38/108 drm/i915/dp_link_caps: Rename helper updating the link configurations

In reply to Imre Deak

Rename the helper updating link configurations to intel_dp_link_caps_update() to better reflect its functionality.

---
 drivers/gpu/drm/i915/display/intel_dp.c           | 2 +-
 drivers/gpu/drm/i915/display/intel_dp_link_caps.c | 2 +-
 drivers/gpu/drm/i915/display/intel_dp_link_caps.h | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)
drivers/gpu/drm/i915/display/intel_dp.c +1 -1
index 25f8ac21ce60c..e0f8dc35574f3 100644
@@ -711,7 +711,7 @@ static bool intel_dp_set_common_rates(struct intel_dp *intel_dp)
 	if (!current_common_caps_match(intel_dp, old_common_rates, num_old_common_rates))
 		link_params_changed = true;
 
-	intel_dp_link_config_init(intel_dp);
+	intel_dp_link_caps_update(intel_dp);
 
 	len = intel_dp_common_len_rate_limit(intel_dp, intel_dp->link.max_rate);
 	if (len > 0)
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +1 -1
index 0034dd439e59d..6e021b616934e 100644
@@ -131,7 +131,7 @@ static int link_config_cmp_by_bw(const void *a, const void *b, const void *p)
 	       intel_dp_link_config_rate(intel_dp, lc_b);
 }
 
-void intel_dp_link_config_init(struct intel_dp *intel_dp)
+void intel_dp_link_caps_update(struct intel_dp *intel_dp)
 {
 	struct intel_dp_link_caps *link_caps = intel_dp->link.caps;
 	struct intel_display *display = to_intel_display(intel_dp);
drivers/gpu/drm/i915/display/intel_dp_link_caps.h +1 -1
index dab956e804b95..aed2122a05d24 100644
@@ -20,7 +20,7 @@ void intel_dp_link_caps_get_forced_params(struct intel_dp_link_caps *link_caps,
 int intel_dp_link_config_index(struct intel_dp *intel_dp, int link_rate, int lane_count);
 void intel_dp_link_config_get(struct intel_dp *intel_dp, int idx, int *link_rate, int *lane_count);
 
-void intel_dp_link_config_init(struct intel_dp *intel_dp);
+void intel_dp_link_caps_update(struct intel_dp *intel_dp);
 
 void intel_dp_link_caps_debugfs_add(struct intel_connector *connector);
 
Signature · 1 line
2.49.1
author
#59 lore raw

PATCH 39/108 drm/i915/dp: Factor out helper to get link rate capabilities

In reply to Imre Deak

Factor out a helper to get the supported link rates. This allows to gather all the link capabilities and pass these to the link capability module from a single place. A follow-up change will extend this to gather and pass the maximum lane count capability in the same way.

---
 drivers/gpu/drm/i915/display/intel_dp.c | 44 +++++++++++++++----------
 1 file changed, 26 insertions(+), 18 deletions(-)
drivers/gpu/drm/i915/display/intel_dp.c +26 -18
index e0f8dc35574f3..347ea9bbe1ef2 100644
@@ -680,33 +680,41 @@ static bool current_common_caps_match(struct intel_dp *intel_dp,
 	return true;
 }
 
-/* Return %true if any supported or maximum link param changed. */
-static bool intel_dp_set_common_rates(struct intel_dp *intel_dp)
+static void intel_dp_get_common_rates(struct intel_dp *intel_dp,
+				      int common_rates[DP_MAX_SUPPORTED_RATES],
+				      int *num_common_rates)
 {
 	struct intel_display *display = to_intel_display(intel_dp);
+
+	drm_WARN_ON(display->drm,
+		    !intel_dp->num_source_rates || !intel_dp->num_sink_rates);
+
+	*num_common_rates = intersect_rates(intel_dp->source_rates,
+					    intel_dp->num_source_rates,
+					    intel_dp->sink_rates,
+					    intel_dp->num_sink_rates,
+					    common_rates);
+
+	/* Paranoia, there should always be something in common. */
+	if (drm_WARN_ON(display->drm, *num_common_rates == 0)) {
+		common_rates[0] = 162000;
+		*num_common_rates = 1;
+	}
+}
+
+/* Return %true if any supported or maximum link param changed. */
+static bool intel_dp_set_common_link_params(struct intel_dp *intel_dp)
+{
 	int num_old_common_rates = intel_dp->num_common_rates;
 	int old_max_rate_limit = intel_dp->link.max_rate;
 	int old_common_rates[DP_MAX_SUPPORTED_RATES];
 	bool link_params_changed = false;
 	int len;
 
-	drm_WARN_ON(display->drm,
-		    !intel_dp->num_source_rates || !intel_dp->num_sink_rates);
-
 	static_assert(sizeof(old_common_rates) == sizeof(intel_dp->common_rates));
 	memcpy(old_common_rates, intel_dp->common_rates, sizeof(old_common_rates));
 
-	intel_dp->num_common_rates = intersect_rates(intel_dp->source_rates,
-						     intel_dp->num_source_rates,
-						     intel_dp->sink_rates,
-						     intel_dp->num_sink_rates,
-						     intel_dp->common_rates);
-
-	/* Paranoia, there should always be something in common. */
-	if (drm_WARN_ON(display->drm, intel_dp->num_common_rates == 0)) {
-		intel_dp->common_rates[0] = 162000;
-		intel_dp->num_common_rates = 1;
-	}
+	intel_dp_get_common_rates(intel_dp, intel_dp->common_rates, &intel_dp->num_common_rates);
 
 	if (!current_common_caps_match(intel_dp, old_common_rates, num_old_common_rates))
 		link_params_changed = true;
@@ -4752,7 +4760,7 @@ void intel_dp_update_sink_caps(struct intel_dp *intel_dp)
 
 	intel_dp_set_sink_rates(intel_dp);
 	intel_dp_set_max_sink_lane_count(intel_dp);
-	if (intel_dp_set_common_rates(intel_dp))
+	if (intel_dp_set_common_link_params(intel_dp))
 		link_params_changed = true;
 
 	current_max_common_lane_count = intel_dp_max_common_lane_count(intel_dp);
@@ -7039,7 +7047,7 @@ intel_dp_init_connector(struct intel_digital_port *dig_port,
 	}
 
 	intel_dp_set_source_rates(intel_dp);
-	intel_dp_set_common_rates(intel_dp);
+	intel_dp_set_common_link_params(intel_dp);
 	intel_dp_reset_link_params(intel_dp);
 
 	/* init MST on ports that can support it */
Signature · 1 line
2.49.1
author
#60 lore raw

PATCH 40/108 drm/i915/dp_link_caps: Pass supported link rates to link caps update

In reply to Imre Deak

Pass the supported link rates explicitly to intel_dp_link_caps_update(). This prepares for tracking these capabilities internally within the link caps module.

---
 drivers/gpu/drm/i915/display/intel_dp.c       | 30 ++----------
 .../gpu/drm/i915/display/intel_dp_link_caps.c | 47 ++++++++++++++++---
 .../gpu/drm/i915/display/intel_dp_link_caps.h |  5 +-
 3 files changed, 50 insertions(+), 32 deletions(-)
drivers/gpu/drm/i915/display/intel_dp.c +5 -25
index 347ea9bbe1ef2..febcf413bb63b 100644
@@ -665,21 +665,6 @@ int intel_dp_rate_index(const int *rates, int len, int rate)
 	return -1;
 }
 
-static bool current_common_caps_match(struct intel_dp *intel_dp,
-				      const int *rates, int num_rates)
-{
-	const int *current_rates = intel_dp->common_rates;
-	int num_current_rates = intel_dp->num_common_rates;
-
-	if (num_current_rates != num_rates)
-		return false;
-
-	if (memcmp(current_rates, rates, num_rates * sizeof(rates[0])))
-		return false;
-
-	return true;
-}
-
 static void intel_dp_get_common_rates(struct intel_dp *intel_dp,
 				      int common_rates[DP_MAX_SUPPORTED_RATES],
 				      int *num_common_rates)
@@ -705,22 +690,17 @@ static void intel_dp_get_common_rates(struct intel_dp *intel_dp,
 /* Return %true if any supported or maximum link param changed. */
 static bool intel_dp_set_common_link_params(struct intel_dp *intel_dp)
 {
-	int num_old_common_rates = intel_dp->num_common_rates;
 	int old_max_rate_limit = intel_dp->link.max_rate;
-	int old_common_rates[DP_MAX_SUPPORTED_RATES];
+	int num_common_rates;
+	int common_rates[DP_MAX_SUPPORTED_RATES];
 	bool link_params_changed = false;
 	int len;
 
-	static_assert(sizeof(old_common_rates) == sizeof(intel_dp->common_rates));
-	memcpy(old_common_rates, intel_dp->common_rates, sizeof(old_common_rates));
-
-	intel_dp_get_common_rates(intel_dp, intel_dp->common_rates, &intel_dp->num_common_rates);
-
-	if (!current_common_caps_match(intel_dp, old_common_rates, num_old_common_rates))
+	intel_dp_get_common_rates(intel_dp, common_rates, &num_common_rates);
+	if (intel_dp_link_caps_update(intel_dp,
+				      common_rates, num_common_rates))
 		link_params_changed = true;
 
-	intel_dp_link_caps_update(intel_dp);
-
 	len = intel_dp_common_len_rate_limit(intel_dp, intel_dp->link.max_rate);
 	if (len > 0)
 		intel_dp->link.max_rate = intel_dp_common_rate(intel_dp, len - 1);
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +41 -6

81 lines not on this page · raw message

drivers/gpu/drm/i915/display/intel_dp_link_caps.h +4 -1
index aed2122a05d24..09e580bc5c9b3 100644
@@ -4,6 +4,8 @@
 #ifndef __INTEL_DP_LINK_CAPS_H__
 #define __INTEL_DP_LINK_CAPS_H__
 
+#include <linux/types.h>
+
 struct intel_connector;
 struct intel_dp;
 struct intel_dp_link_caps;
@@ -20,7 +22,8 @@ void intel_dp_link_caps_get_forced_params(struct intel_dp_link_caps *link_caps,
 int intel_dp_link_config_index(struct intel_dp *intel_dp, int link_rate, int lane_count);
 void intel_dp_link_config_get(struct intel_dp *intel_dp, int idx, int *link_rate, int *lane_count);
 
-void intel_dp_link_caps_update(struct intel_dp *intel_dp);
+bool intel_dp_link_caps_update(struct intel_dp *intel_dp,
+			       const int *rates, int num_rates);
 
 void intel_dp_link_caps_debugfs_add(struct intel_connector *connector);
 
Signature · 1 line
2.49.1
author
#61 lore raw

PATCH 41/108 drm/i915/dp_link_caps: Add helper to get all supported link rates

In reply to Imre Deak

Add intel_dp_link_caps_all_common_rates() to return all supported link rates tracked by the link_caps module. This prepares for tracking these capabilities internally within the link caps module.

---
 drivers/gpu/drm/i915/display/intel_dp.c       |  6 ++++-
 .../gpu/drm/i915/display/intel_dp_link_caps.c | 23 +++++++++++++++++++
 .../gpu/drm/i915/display/intel_dp_link_caps.h |  2 ++
 3 files changed, 30 insertions(+), 1 deletion(-)
drivers/gpu/drm/i915/display/intel_dp.c +5 -1
index febcf413bb63b..d92160c522f93 100644
@@ -1531,6 +1531,8 @@ static void intel_dp_print_rates(struct intel_dp *intel_dp)
 {
 	struct intel_display *display = to_intel_display(intel_dp);
 	DECLARE_SEQ_BUF(s, 128); /* FIXME: too big for stack? */
+	const int *common_rates;
+	int num_common_rates;
 
 	if (!drm_debug_enabled(DRM_UT_KMS))
 		return;
@@ -1543,7 +1545,9 @@ static void intel_dp_print_rates(struct intel_dp *intel_dp)
 	drm_dbg_kms(display->drm, "sink rates: %s\n", seq_buf_str(&s));
 
 	seq_buf_clear(&s);
-	seq_buf_print_array(&s, intel_dp->common_rates, intel_dp->num_common_rates);
+	intel_dp_link_caps_all_common_rates(intel_dp->link.caps,
+					    &common_rates, &num_common_rates);
+	seq_buf_print_array(&s, common_rates, num_common_rates);
 	drm_dbg_kms(display->drm, "common rates: %s\n", seq_buf_str(&s));
 }
 
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +23 -0
index 9f8b7da98305f..94a643b6e68b6 100644
@@ -66,6 +66,29 @@ int intel_dp_max_common_rate(struct intel_dp *intel_dp)
 	return intel_dp_common_rate(intel_dp, intel_dp->num_common_rates - 1);
 }
 
+/**
+ * intel_dp_link_caps_all_common_rates - get all common link rates
+ * @link_caps: link capabilities state
+ * @rates: returned pointer to the common rate array
+ * @num_rates: returned number of entries in @rates
+ *
+ * Return all link rates through @rates and @num_rates that are currently
+ * supported by @link_caps, common to both the source and the sink. The
+ * returned array is owned by @link_caps.
+ *
+ * Besides the usual locking requirement for API access, the caller must
+ * also serialize any dereference of the returned array against concurrent
+ * updates to @link_caps.
+ */
+void intel_dp_link_caps_all_common_rates(struct intel_dp_link_caps *link_caps,
+					 const int **rates, int *num_rates)
+{
+	struct intel_dp *intel_dp = link_caps->dp;
+
+	*rates = intel_dp->common_rates;
+	*num_rates = intel_dp->num_common_rates;
+}
+
 static int forced_lane_count(struct intel_dp *intel_dp)
 {
 	struct intel_dp_link_caps *link_caps = intel_dp->link.caps;
drivers/gpu/drm/i915/display/intel_dp_link_caps.h +2 -0
index 09e580bc5c9b3..636a1d16dbb47 100644
@@ -15,6 +15,8 @@ int intel_dp_common_len_rate_limit(const struct intel_dp *intel_dp,
 				   int max_rate);
 int intel_dp_common_rate(struct intel_dp *intel_dp, int index);
 int intel_dp_max_common_rate(struct intel_dp *intel_dp);
+void intel_dp_link_caps_all_common_rates(struct intel_dp_link_caps *link_caps,
+					 const int **rates, int *num_rates);
 
 void intel_dp_link_caps_get_forced_params(struct intel_dp_link_caps *link_caps,
 					  struct intel_dp_link_config *forced_params);
Signature · 1 line
2.49.1
maintainer
#62 lore raw

Re: [PATCH 041/108] drm/i915/dp_link_caps: Add helper to get all supported link rates

Quoted 3 lines · Imre Deak

Add intel_dp_link_caps_all_common_rates() to return all supported link rates tracked by the link_caps module. This prepares for tracking these capabilities internally within the link caps module.

There's no other use for this than printing. Maybe don't have a way to get common rates, but have a way to print common rates.

BR,
Jani.

Quoted 79 lines
---
 drivers/gpu/drm/i915/display/intel_dp.c       |  6 ++++-
 .../gpu/drm/i915/display/intel_dp_link_caps.c | 23 +++++++++++++++++++
 .../gpu/drm/i915/display/intel_dp_link_caps.h |  2 ++
 3 files changed, 30 insertions(+), 1 deletion(-)
drivers/gpu/drm/i915/display/intel_dp.c +5 -1
index febcf413bb63b..d92160c522f93 100644
@@ -1531,6 +1531,8 @@ static void intel_dp_print_rates(struct intel_dp *intel_dp)
 {
 	struct intel_display *display = to_intel_display(intel_dp);
 	DECLARE_SEQ_BUF(s, 128); /* FIXME: too big for stack? */
+	const int *common_rates;
+	int num_common_rates;
 
 	if (!drm_debug_enabled(DRM_UT_KMS))
 		return;
@@ -1543,7 +1545,9 @@ static void intel_dp_print_rates(struct intel_dp *intel_dp)
 	drm_dbg_kms(display->drm, "sink rates: %s\n", seq_buf_str(&s));
 
 	seq_buf_clear(&s);
-	seq_buf_print_array(&s, intel_dp->common_rates, intel_dp->num_common_rates);
+	intel_dp_link_caps_all_common_rates(intel_dp->link.caps,
+					    &common_rates, &num_common_rates);
+	seq_buf_print_array(&s, common_rates, num_common_rates);
 	drm_dbg_kms(display->drm, "common rates: %s\n", seq_buf_str(&s));
 }
 
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +23 -0
index 9f8b7da98305f..94a643b6e68b6 100644
@@ -66,6 +66,29 @@ int intel_dp_max_common_rate(struct intel_dp *intel_dp)
 	return intel_dp_common_rate(intel_dp, intel_dp->num_common_rates - 1);
 }
 
+/**
+ * intel_dp_link_caps_all_common_rates - get all common link rates
+ * @link_caps: link capabilities state
+ * @rates: returned pointer to the common rate array
+ * @num_rates: returned number of entries in @rates
+ *
+ * Return all link rates through @rates and @num_rates that are currently
+ * supported by @link_caps, common to both the source and the sink. The
+ * returned array is owned by @link_caps.
+ *
+ * Besides the usual locking requirement for API access, the caller must
+ * also serialize any dereference of the returned array against concurrent
+ * updates to @link_caps.
+ */
+void intel_dp_link_caps_all_common_rates(struct intel_dp_link_caps *link_caps,
+					 const int **rates, int *num_rates)
+{
+	struct intel_dp *intel_dp = link_caps->dp;
+
+	*rates = intel_dp->common_rates;
+	*num_rates = intel_dp->num_common_rates;
+}
+
 static int forced_lane_count(struct intel_dp *intel_dp)
 {
 	struct intel_dp_link_caps *link_caps = intel_dp->link.caps;
drivers/gpu/drm/i915/display/intel_dp_link_caps.h +2 -0
index 09e580bc5c9b3..636a1d16dbb47 100644
@@ -15,6 +15,8 @@ int intel_dp_common_len_rate_limit(const struct intel_dp *intel_dp,
 				   int max_rate);
 int intel_dp_common_rate(struct intel_dp *intel_dp, int index);
 int intel_dp_max_common_rate(struct intel_dp *intel_dp);
+void intel_dp_link_caps_all_common_rates(struct intel_dp_link_caps *link_caps,
+					 const int **rates, int *num_rates);
 
 void intel_dp_link_caps_get_forced_params(struct intel_dp_link_caps *link_caps,
 					  struct intel_dp_link_config *forced_params);
Signature · 1 line
Jani Nikula, Intel
author
#63 lore raw

PATCH 42/108 drm/i915/dp_link_caps: Add helper to get the number of supported link rates

In reply to Imre Deak

Add intel_dp_link_caps_num_common_rates() to return the number of supported link rates tracked by the link_caps module. This prepares for tracking these capabilities internally within the link caps module.

---
 drivers/gpu/drm/i915/display/intel_dp.c           | 4 ++--
 drivers/gpu/drm/i915/display/intel_dp_link_caps.c | 5 +++++
 drivers/gpu/drm/i915/display/intel_dp_link_caps.h | 1 +
 3 files changed, 8 insertions(+), 2 deletions(-)
drivers/gpu/drm/i915/display/intel_dp.c +2 -2
index d92160c522f93..666bb8e51f59e 100644
@@ -1768,7 +1768,7 @@ intel_dp_compute_link_config_wide(struct intel_dp *intel_dp,
 		int link_bpp_x16 =
 			intel_dp_output_format_link_bpp_x16(pipe_config->output_format, bpp);
 
-		for (i = 0; i < intel_dp->num_common_rates; i++) {
+		for (i = 0; i < intel_dp_link_caps_num_common_rates(intel_dp->link.caps); i++) {
 			link_rate = intel_dp_common_rate(intel_dp, i);
 			if (link_rate < limits->min_rate ||
 			    link_rate > limits->max_rate)
@@ -1997,7 +1997,7 @@ static int dsc_compute_link_config(struct intel_dp *intel_dp,
 	int link_rate, lane_count;
 	int i;
 
-	for (i = 0; i < intel_dp->num_common_rates; i++) {
+	for (i = 0; i < intel_dp_link_caps_num_common_rates(intel_dp->link.caps); i++) {
 		link_rate = intel_dp_common_rate(intel_dp, i);
 		if (link_rate < limits->min_rate || link_rate > limits->max_rate)
 			continue;
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +5 -0
index 94a643b6e68b6..b1b78e7cda897 100644
@@ -66,6 +66,11 @@ int intel_dp_max_common_rate(struct intel_dp *intel_dp)
 	return intel_dp_common_rate(intel_dp, intel_dp->num_common_rates - 1);
 }
 
+int intel_dp_link_caps_num_common_rates(struct intel_dp_link_caps *link_caps)
+{
+	return link_caps->dp->num_common_rates;
+}
+
 /**
  * intel_dp_link_caps_all_common_rates - get all common link rates
  * @link_caps: link capabilities state
drivers/gpu/drm/i915/display/intel_dp_link_caps.h +1 -0
index 636a1d16dbb47..b2eb61272652e 100644
@@ -15,6 +15,7 @@ int intel_dp_common_len_rate_limit(const struct intel_dp *intel_dp,
 				   int max_rate);
 int intel_dp_common_rate(struct intel_dp *intel_dp, int index);
 int intel_dp_max_common_rate(struct intel_dp *intel_dp);
+int intel_dp_link_caps_num_common_rates(struct intel_dp_link_caps *link_caps);
 void intel_dp_link_caps_all_common_rates(struct intel_dp_link_caps *link_caps,
 					 const int **rates, int *num_rates);
 
Signature · 1 line
2.49.1
author
#64 lore raw

PATCH 43/108 drm/i915/dp_link_caps: Add helper to get common rate index

In reply to Imre Deak

Add intel_dp_link_caps_common_rate_idx() to look up supported link rates tracked by the link_caps module by rate. This prepares for tracking these capabilities internally within the link caps module.

---
 .../gpu/drm/i915/display/intel_dp_link_caps.c | 25 +++++++++++++++++++
 .../gpu/drm/i915/display/intel_dp_link_caps.h |  1 +
 .../drm/i915/display/intel_dp_link_training.c |  5 ++--
 drivers/gpu/drm/i915/display/intel_dp_test.c  |  7 +++---
 4 files changed, 32 insertions(+), 6 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +25 -0
index b1b78e7cda897..c99fc7704b3e8 100644
@@ -60,6 +60,31 @@ int intel_dp_common_rate(struct intel_dp *intel_dp, int index)
 	return intel_dp->common_rates[index];
 }
 
+/**
+ * intel_dp_link_caps_common_rate_idx - get index of a common link rate
+ * @link_caps: link capabilities state
+ * @rate: common link rate to look up
+ *
+ * Look up @rate in the rate list currently supported by @link_caps, common to
+ * both the source and the sink.
+ *
+ * The returned value is an index into the common rate list returned by
+ * intel_dp_link_caps_all_common_rates() and accepted by
+ * intel_dp_link_caps_common_rate().
+ *
+ * Return:
+ * - Index of @rate in the current common rate list.
+ * - %-1 if @rate is not present.
+ */
+int intel_dp_link_caps_common_rate_idx(struct intel_dp_link_caps *link_caps, int rate)
+{
+	struct intel_dp *intel_dp = link_caps->dp;
+
+	return intel_dp_rate_index(intel_dp->common_rates,
+				   intel_dp->num_common_rates,
+				   rate);
+}
+
 /* Theoretical max between source and sink */
 int intel_dp_max_common_rate(struct intel_dp *intel_dp)
 {
drivers/gpu/drm/i915/display/intel_dp_link_caps.h +1 -0
index b2eb61272652e..7ec1612a044ed 100644
@@ -14,6 +14,7 @@ struct intel_dp_link_config;
 int intel_dp_common_len_rate_limit(const struct intel_dp *intel_dp,
 				   int max_rate);
 int intel_dp_common_rate(struct intel_dp *intel_dp, 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 *intel_dp);
 int intel_dp_link_caps_num_common_rates(struct intel_dp_link_caps *link_caps);
 void intel_dp_link_caps_all_common_rates(struct intel_dp_link_caps *link_caps,
drivers/gpu/drm/i915/display/intel_dp_link_training.c +2 -3
index 5218220b82b0b..456540925db55 100644
@@ -1805,9 +1805,8 @@ static int reduce_link_rate(struct intel_dp *intel_dp, int current_rate)
 	if (forced_params.rate)
 		return -1;
 
-	rate_index = intel_dp_rate_index(intel_dp->common_rates,
-					 intel_dp->num_common_rates,
-					 current_rate);
+	rate_index = intel_dp_link_caps_common_rate_idx(link_caps,
+							current_rate);
 
 	if (rate_index <= 0)
 		return -1;
drivers/gpu/drm/i915/display/intel_dp_test.c +4 -3
index 5cfa1dd411dab..0b791eee3b910 100644
@@ -14,6 +14,7 @@
 #include "intel_display_regs.h"
 #include "intel_display_types.h"
 #include "intel_dp.h"
+#include "intel_dp_link_caps.h"
 #include "intel_dp_link_training.h"
 #include "intel_dp_mst.h"
 #include "intel_dp_test.h"
@@ -32,6 +33,7 @@ void intel_dp_test_compute_config(struct intel_dp *intel_dp,
 				  struct intel_crtc_state *pipe_config,
 				  struct link_config_limits *limits)
 {
+	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 */
@@ -54,9 +56,8 @@ void intel_dp_test_compute_config(struct intel_dp *intel_dp,
 		 */
 		if (intel_dp_link_params_valid(intel_dp, intel_dp->compliance.test_link_rate,
 					       intel_dp->compliance.test_lane_count)) {
-			index = intel_dp_rate_index(intel_dp->common_rates,
-						    intel_dp->num_common_rates,
-						    intel_dp->compliance.test_link_rate);
+			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;
Signature · 1 line
2.49.1
maintainer
#65 lore raw

Re: [PATCH 043/108] drm/i915/dp_link_caps: Add helper to get common rate index

Quoted 3 lines · Imre Deak

Add intel_dp_link_caps_common_rate_idx() to look up supported link rates tracked by the link_caps module by rate. This prepares for tracking these capabilities internally within the link caps module.

It's a big series, and it's not obvious at which patch to reply for something generic. Might as well be here, as this function is preserved unchanged in the end.

When the rates and their handling were not abstracted, working with indexes to rates array made sense. It all started simple.

I think with the intel_dp_link_caps.c abstraction, having the rate index or link config index in the interface is a leaky abstraction. The caller has to deal with an index, or pos, or iter_pos, that the caller has no idea what it's an index to.

I think storing the various link configs in an array, and indexing it with some value, is an implementation detail that the interface is supposed to abstract. Imagine changing that implementation to use a linked list instead of an array. How much of the interface would you have to change? How much the indexes in the interface would get in the way of changing what's supposed to be an implementation detail? You'd end up having to deal with an "index" that the caller has no idea what it's an index to, and the callee having to translate that to a linked list where indexes make no sense.

I'm thinking maybe the interface should only deal with link configs. "This is the link config I have, give me the next one."

BR,
Jani.

Quoted 105 lines
---
 .../gpu/drm/i915/display/intel_dp_link_caps.c | 25 +++++++++++++++++++
 .../gpu/drm/i915/display/intel_dp_link_caps.h |  1 +
 .../drm/i915/display/intel_dp_link_training.c |  5 ++--
 drivers/gpu/drm/i915/display/intel_dp_test.c  |  7 +++---
 4 files changed, 32 insertions(+), 6 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +25 -0
index b1b78e7cda897..c99fc7704b3e8 100644
@@ -60,6 +60,31 @@ int intel_dp_common_rate(struct intel_dp *intel_dp, int index)
 	return intel_dp->common_rates[index];
 }
 
+/**
+ * intel_dp_link_caps_common_rate_idx - get index of a common link rate
+ * @link_caps: link capabilities state
+ * @rate: common link rate to look up
+ *
+ * Look up @rate in the rate list currently supported by @link_caps, common to
+ * both the source and the sink.
+ *
+ * The returned value is an index into the common rate list returned by
+ * intel_dp_link_caps_all_common_rates() and accepted by
+ * intel_dp_link_caps_common_rate().
+ *
+ * Return:
+ * - Index of @rate in the current common rate list.
+ * - %-1 if @rate is not present.
+ */
+int intel_dp_link_caps_common_rate_idx(struct intel_dp_link_caps *link_caps, int rate)
+{
+	struct intel_dp *intel_dp = link_caps->dp;
+
+	return intel_dp_rate_index(intel_dp->common_rates,
+				   intel_dp->num_common_rates,
+				   rate);
+}
+
 /* Theoretical max between source and sink */
 int intel_dp_max_common_rate(struct intel_dp *intel_dp)
 {
drivers/gpu/drm/i915/display/intel_dp_link_caps.h +1 -0
index b2eb61272652e..7ec1612a044ed 100644
@@ -14,6 +14,7 @@ struct intel_dp_link_config;
 int intel_dp_common_len_rate_limit(const struct intel_dp *intel_dp,
 				   int max_rate);
 int intel_dp_common_rate(struct intel_dp *intel_dp, 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 *intel_dp);
 int intel_dp_link_caps_num_common_rates(struct intel_dp_link_caps *link_caps);
 void intel_dp_link_caps_all_common_rates(struct intel_dp_link_caps *link_caps,
drivers/gpu/drm/i915/display/intel_dp_link_training.c +2 -3
index 5218220b82b0b..456540925db55 100644
@@ -1805,9 +1805,8 @@ static int reduce_link_rate(struct intel_dp *intel_dp, int current_rate)
 	if (forced_params.rate)
 		return -1;
 
-	rate_index = intel_dp_rate_index(intel_dp->common_rates,
-					 intel_dp->num_common_rates,
-					 current_rate);
+	rate_index = intel_dp_link_caps_common_rate_idx(link_caps,
+							current_rate);
 
 	if (rate_index <= 0)
 		return -1;
drivers/gpu/drm/i915/display/intel_dp_test.c +4 -3
index 5cfa1dd411dab..0b791eee3b910 100644
@@ -14,6 +14,7 @@
 #include "intel_display_regs.h"
 #include "intel_display_types.h"
 #include "intel_dp.h"
+#include "intel_dp_link_caps.h"
 #include "intel_dp_link_training.h"
 #include "intel_dp_mst.h"
 #include "intel_dp_test.h"
@@ -32,6 +33,7 @@ void intel_dp_test_compute_config(struct intel_dp *intel_dp,
 				  struct intel_crtc_state *pipe_config,
 				  struct link_config_limits *limits)
 {
+	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 */
@@ -54,9 +56,8 @@ void intel_dp_test_compute_config(struct intel_dp *intel_dp,
 		 */
 		if (intel_dp_link_params_valid(intel_dp, intel_dp->compliance.test_link_rate,
 					       intel_dp->compliance.test_lane_count)) {
-			index = intel_dp_rate_index(intel_dp->common_rates,
-						    intel_dp->num_common_rates,
-						    intel_dp->compliance.test_link_rate);
+			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;
Signature · 1 line
Jani Nikula, Intel
author
#66 lore raw

Re: [PATCH 043/108] drm/i915/dp_link_caps: Add helper to get common rate index

Quoted 27 lines · Jani Nikula
Quoted 3 lines · Imre Deak

Add intel_dp_link_caps_common_rate_idx() to look up supported link rates tracked by the link_caps module by rate. This prepares for tracking these capabilities internally within the link caps module.

It's a big series, and it's not obvious at which patch to reply for something generic. Might as well be here, as this function is preserved unchanged in the end.

When the rates and their handling were not abstracted, working with indexes to rates array made sense. It all started simple.

I think with the intel_dp_link_caps.c abstraction, having the rate index or link config index in the interface is a leaky abstraction. The caller has to deal with an index, or pos, or iter_pos, that the caller has no idea what it's an index to.

I think storing the various link configs in an array, and indexing it with some value, is an implementation detail that the interface is supposed to abstract. Imagine changing that implementation to use a linked list instead of an array. How much of the interface would you have to change? How much the indexes in the interface would get in the way of changing what's supposed to be an implementation detail? You'd end up having to deal with an "index" that the caller has no idea what it's an index to, and the callee having to translate that to a linked list where indexes make no sense.

Quoted 2 lines

I'm thinking maybe the interface should only deal with link configs. "This is the link config I have, give me the next one."

Thanks for taking the time to read through the patchset.

The following is also a result of an off-line discussion with you and Ville.

Yes, the rate index and iteration position shouldn't be part of the interface. The reason they still are is that I intended to keep the iteration of the link fallback code in place and as-is, with the idea to align that part with the new interface only as a follow-up.

However, re-checking this, the fallback iteration is really just an open-coded form now of what is already provided via the interface's for_each_dp_link_config() iterator. Using that iterator instead of exposing new rate index and iteration position APIs makes more sense, especially that this simplifies the fallback code a lot. I'll update the patchset doing this, which also removes the rate index and iteration position from the API.

The configuration index/mask is part of the interface to provide a way for the link configuration computation code to support filtering the set of valid configurations for a modeset (required for instance by the intel_dp::use_max_params logic and the TEST_LANE_COUNT/LINK_RATE autotest modesets). I agree that this filtering parameter should be more hidden and not exposed via the actual configuration index the interace uses internally for the filtering. I'll update the patchset to make the filtering mechanism opaque to the interface user.

During the discussion you also had the idea to setup an iteration object and pass all the iteration parameters through that object instead of open-coding this at the call-sites of iterators. This simplifies the iterator macro implementation and also allows for future extentions to the iterator functionality. Will take this into use.

Ville mentioned that simplifying the link configuration table using virtual table indices could be considered only as a follow-up to this patchset, will drop that using the current rate/lane count internal encoding for configuration entries.

The patchset should be reviewed/merged in smaller chunks. The cover letter mentioned this too, a clarification to that is that the second part (patches 27-89) should be further divided to smaller patchsets. I'll follow up with an updated version of the patchet divided along these lines, addressing the above feedback and other smaller issues found by sashiko-bot fixed.

Thanks,
Imre

Quoted 112 lines

BR,
Jani.

Quoted 105 lines
---
 .../gpu/drm/i915/display/intel_dp_link_caps.c | 25 +++++++++++++++++++
 .../gpu/drm/i915/display/intel_dp_link_caps.h |  1 +
 .../drm/i915/display/intel_dp_link_training.c |  5 ++--
 drivers/gpu/drm/i915/display/intel_dp_test.c  |  7 +++---
 4 files changed, 32 insertions(+), 6 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +25 -0
index b1b78e7cda897..c99fc7704b3e8 100644
@@ -60,6 +60,31 @@ int intel_dp_common_rate(struct intel_dp *intel_dp, int index)
 	return intel_dp->common_rates[index];
 }
 
+/**
+ * intel_dp_link_caps_common_rate_idx - get index of a common link rate
+ * @link_caps: link capabilities state
+ * @rate: common link rate to look up
+ *
+ * Look up @rate in the rate list currently supported by @link_caps, common to
+ * both the source and the sink.
+ *
+ * The returned value is an index into the common rate list returned by
+ * intel_dp_link_caps_all_common_rates() and accepted by
+ * intel_dp_link_caps_common_rate().
+ *
+ * Return:
+ * - Index of @rate in the current common rate list.
+ * - %-1 if @rate is not present.
+ */
+int intel_dp_link_caps_common_rate_idx(struct intel_dp_link_caps *link_caps, int rate)
+{
+	struct intel_dp *intel_dp = link_caps->dp;
+
+	return intel_dp_rate_index(intel_dp->common_rates,
+				   intel_dp->num_common_rates,
+				   rate);
+}
+
 /* Theoretical max between source and sink */
 int intel_dp_max_common_rate(struct intel_dp *intel_dp)
 {
drivers/gpu/drm/i915/display/intel_dp_link_caps.h +1 -0
index b2eb61272652e..7ec1612a044ed 100644
@@ -14,6 +14,7 @@ struct intel_dp_link_config;
 int intel_dp_common_len_rate_limit(const struct intel_dp *intel_dp,
 				   int max_rate);
 int intel_dp_common_rate(struct intel_dp *intel_dp, 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 *intel_dp);
 int intel_dp_link_caps_num_common_rates(struct intel_dp_link_caps *link_caps);
 void intel_dp_link_caps_all_common_rates(struct intel_dp_link_caps *link_caps,
drivers/gpu/drm/i915/display/intel_dp_link_training.c +2 -3
index 5218220b82b0b..456540925db55 100644
@@ -1805,9 +1805,8 @@ static int reduce_link_rate(struct intel_dp *intel_dp, int current_rate)
 	if (forced_params.rate)
 		return -1;
 
-	rate_index = intel_dp_rate_index(intel_dp->common_rates,
-					 intel_dp->num_common_rates,
-					 current_rate);
+	rate_index = intel_dp_link_caps_common_rate_idx(link_caps,
+							current_rate);
 
 	if (rate_index <= 0)
 		return -1;
drivers/gpu/drm/i915/display/intel_dp_test.c +4 -3
index 5cfa1dd411dab..0b791eee3b910 100644
@@ -14,6 +14,7 @@
 #include "intel_display_regs.h"
 #include "intel_display_types.h"
 #include "intel_dp.h"
+#include "intel_dp_link_caps.h"
 #include "intel_dp_link_training.h"
 #include "intel_dp_mst.h"
 #include "intel_dp_test.h"
@@ -32,6 +33,7 @@ void intel_dp_test_compute_config(struct intel_dp *intel_dp,
 				  struct intel_crtc_state *pipe_config,
 				  struct link_config_limits *limits)
 {
+	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 */
@@ -54,9 +56,8 @@ void intel_dp_test_compute_config(struct intel_dp *intel_dp,
 		 */
 		if (intel_dp_link_params_valid(intel_dp, intel_dp->compliance.test_link_rate,
 					       intel_dp->compliance.test_lane_count)) {
-			index = intel_dp_rate_index(intel_dp->common_rates,
-						    intel_dp->num_common_rates,
-						    intel_dp->compliance.test_link_rate);
+			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;
Signature · 1 line
Jani Nikula, Intel
author
#67 lore raw

PATCH 44/108 drm/i915/dp_link_caps: Move tracking of common rates to link_caps struct

In reply to Imre Deak

Now that all users access the supported link rates via helpers, move tracking of these rates from struct intel_dp to the link_caps state.

---
 .../drm/i915/display/intel_display_types.h    |  3 --
 .../gpu/drm/i915/display/intel_dp_link_caps.c | 54 ++++++++++---------
 2 files changed, 30 insertions(+), 27 deletions(-)
drivers/gpu/drm/i915/display/intel_display_types.h +0 -3
index 97d2836d0e159..71cb45a2374b0 100644
@@ -1826,9 +1826,6 @@ struct intel_dp {
 	bool use_rate_select;
 	/* Max sink lane count as reported by DP_MAX_LANE_COUNT */
 	int max_sink_lane_count;
-	/* intersection of source and sink rates */
-	int num_common_rates;
-	int common_rates[DP_MAX_SUPPORTED_RATES];
 	struct {
 		/* TODO: move the rest of link specific fields to here */
 		bool active;
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +30 -24

136 lines not on this page · raw message

Signature · 1 line
2.49.1
author
#68 lore raw

PATCH 45/108 drm/i915/dp_link_caps: Track max common lane count in link_caps

In reply to Imre Deak

Pass the maximum common lane count to intel_dp_link_caps_update() and track it together with the supported link rates. This prepares for converting all users of intel_dp_max_common_lane_count() to query the value from the link caps module instead.

This will make these queries use a cached value, similar to the supported link rates. The cached max lane count value - along with the rate list - is recomputed on sink capability changes, via RX_CAP_CHANGED HPD IRQ or long HPD pulse, through intel_dp_detect() and intel_dp_reset_link_params() respectively, so using a cached value is ok.

---
 drivers/gpu/drm/i915/display/intel_dp.c           | 3 ++-
 drivers/gpu/drm/i915/display/intel_dp_link_caps.c | 9 ++++++---
 drivers/gpu/drm/i915/display/intel_dp_link_caps.h | 2 +-
 3 files changed, 9 insertions(+), 5 deletions(-)
drivers/gpu/drm/i915/display/intel_dp.c +2 -1
index 666bb8e51f59e..ef980ab274e34 100644
@@ -698,7 +698,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,
-				      common_rates, num_common_rates))
+				      common_rates, num_common_rates,
+				      intel_dp_max_common_lane_count(intel_dp)))
 		link_params_changed = true;
 
 	len = intel_dp_common_len_rate_limit(intel_dp, intel_dp->link.max_rate);
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +6 -3
index fc0c100835595..214974658b343 100644
@@ -24,6 +24,7 @@ struct intel_dp_link_caps {
 	/* Rate, lane count caps common to source and sink. */
 	int num_rates;
 	int rates[DP_MAX_SUPPORTED_RATES];
+	int max_lane_count;
 
 	/* common rate,lane_count configs in bw order */
 	int num_configs;
@@ -208,7 +209,7 @@ static bool current_common_caps_match(struct intel_dp_link_caps *link_caps,
 
 /* Return %true if the supported link parameters have changed. */
 bool intel_dp_link_caps_update(struct intel_dp *intel_dp,
-			       const int *rates, int num_rates)
+			       const int *rates, int num_rates, int max_lane_count)
 {
 	struct intel_dp_link_caps *link_caps = intel_dp->link.caps;
 	struct intel_display *display = to_intel_display(intel_dp);
@@ -220,13 +221,13 @@ bool intel_dp_link_caps_update(struct intel_dp *intel_dp,
 	int i;
 	int j;
 
-	if (drm_WARN_ON(display->drm, !is_power_of_2(intel_dp_max_common_lane_count(intel_dp))))
+	if (drm_WARN_ON(display->drm, !is_power_of_2(max_lane_count)))
 		return false;
 
 	if (drm_WARN_ON(display->drm, num_rates > ARRAY_SIZE(link_caps->rates)))
 		return false;
 
-	num_common_lane_configs = ilog2(intel_dp_max_common_lane_count(intel_dp)) + 1;
+	num_common_lane_configs = ilog2(max_lane_count) + 1;
 
 	if (drm_WARN_ON(display->drm, num_rates * num_common_lane_configs >
 				    ARRAY_SIZE(link_caps->configs)))
@@ -237,6 +238,8 @@ bool intel_dp_link_caps_update(struct intel_dp *intel_dp,
 
 	memcpy(link_caps->rates, rates, num_rates * sizeof(rates[0]));
 	link_caps->num_rates = num_rates;
+	link_caps->max_lane_count = max_lane_count;
+
 	link_caps->num_configs = num_rates * num_common_lane_configs;
 
 	lc = &link_caps->configs[0];
drivers/gpu/drm/i915/display/intel_dp_link_caps.h +1 -1
index 7ec1612a044ed..7a2e383caeef4 100644
@@ -27,7 +27,7 @@ int intel_dp_link_config_index(struct intel_dp *intel_dp, int link_rate, int lan
 void intel_dp_link_config_get(struct intel_dp *intel_dp, int idx, int *link_rate, int *lane_count);
 
 bool intel_dp_link_caps_update(struct intel_dp *intel_dp,
-			       const int *rates, int num_rates);
+			       const int *rates, int num_rates, int max_lane_count);
 
 void intel_dp_link_caps_debugfs_add(struct intel_connector *connector);
 
Signature · 1 line
2.49.1
author
#69 lore raw

PATCH 46/108 drm/i915/dp_link_caps: Move max lane count change detection to link_caps

In reply to Imre Deak

Move detection of changes to the maximum common lane count to intel_dp_link_caps_update(), alongside detection of changes to the supported link rates.

---
 drivers/gpu/drm/i915/display/intel_dp.c           |  4 ----
 drivers/gpu/drm/i915/display/intel_dp_link_caps.c | 14 +++++++++++---
 2 files changed, 11 insertions(+), 7 deletions(-)
drivers/gpu/drm/i915/display/intel_dp.c +0 -4
index ef980ab274e34..4e20e1fb20512 100644
@@ -4738,7 +4738,6 @@ intel_dp_has_sink_count(struct intel_dp *intel_dp)
 void intel_dp_update_sink_caps(struct intel_dp *intel_dp)
 {
 	struct intel_connector *connector = intel_dp->attached_connector;
-	int old_max_common_lane_count = intel_dp_max_common_lane_count(intel_dp);
 	int old_max_lane_count_limit = intel_dp->link.max_lane_count;
 	int current_max_common_lane_count;
 	bool link_params_changed = false;
@@ -4749,9 +4748,6 @@ void intel_dp_update_sink_caps(struct intel_dp *intel_dp)
 		link_params_changed = true;
 
 	current_max_common_lane_count = intel_dp_max_common_lane_count(intel_dp);
-	if (current_max_common_lane_count != old_max_common_lane_count)
-		link_params_changed = true;
-
 	intel_dp->link.max_lane_count = min(intel_dp->link.max_lane_count,
 					    current_max_common_lane_count);
 
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +11 -3
index 214974658b343..a250d7ee06ebb 100644
@@ -193,14 +193,19 @@ static int link_config_cmp_by_bw(const void *a, const void *b, const void *p)
 }
 
 static bool current_common_caps_match(struct intel_dp_link_caps *link_caps,
-				      const int *rates, int num_rates)
+				      const int *rates, int num_rates,
+				      int old_max_lane_count)
 {
+	int current_max_lane_count = link_caps->max_lane_count;
 	const int *current_rates = link_caps->rates;
 	int num_current_rates = link_caps->num_rates;
 
 	if (num_current_rates != num_rates)
 		return false;
 
+	if (current_max_lane_count != old_max_lane_count)
+		return false;
+
 	if (memcmp(current_rates, rates, num_rates * sizeof(rates[0])))
 		return false;
 
@@ -217,6 +222,7 @@ bool intel_dp_link_caps_update(struct intel_dp *intel_dp,
 	struct intel_dp_link_config_entry *lc;
 	bool link_params_changed = false;
 	int num_common_lane_configs;
+	int old_max_lane_count;
 	int num_old_rates;
 	int i;
 	int j;
@@ -235,6 +241,7 @@ bool intel_dp_link_caps_update(struct intel_dp *intel_dp,
 
 	num_old_rates = link_caps->num_rates;
 	memcpy(old_rates, link_caps->rates, num_old_rates * sizeof(old_rates[0]));
+	old_max_lane_count = link_caps->max_lane_count;
 
 	memcpy(link_caps->rates, rates, num_rates * sizeof(rates[0]));
 	link_caps->num_rates = num_rates;
@@ -257,10 +264,11 @@ bool intel_dp_link_caps_update(struct intel_dp *intel_dp,
 	       link_config_cmp_by_bw, NULL,
 	       intel_dp);
 
-	if (!current_common_caps_match(link_caps, old_rates, num_old_rates))
+	if (!current_common_caps_match(link_caps, old_rates, num_old_rates,
+				       old_max_lane_count))
 		link_params_changed = true;
 
-	/* TODO: Also detect a change in the max lane count and max link limits. */
+	/* TODO: Also detect a change in the max link limits. */
 	return link_params_changed;
 }
 
Signature · 1 line
2.49.1
author
#70 lore raw

PATCH 47/108 drm/i915/dp_link_caps: Use max common lane count from link_caps

In reply to Imre Deak

Convert all users of intel_dp_max_common_lane_count() to query the maximum common lane count via the link capability API, in common with the link rate queries.

---
 drivers/gpu/drm/i915/display/intel_dp.c           | 4 ++--
 drivers/gpu/drm/i915/display/intel_dp.h           | 1 -
 drivers/gpu/drm/i915/display/intel_dp_link_caps.c | 7 ++++++-
 drivers/gpu/drm/i915/display/intel_dp_link_caps.h | 1 +
 drivers/gpu/drm/i915/display/intel_dp_tunnel.c    | 3 ++-
 5 files changed, 11 insertions(+), 5 deletions(-)
drivers/gpu/drm/i915/display/intel_dp.c +2 -2
index 4e20e1fb20512..18b06e5402611 100644
@@ -338,7 +338,7 @@ int intel_dp_max_source_lane_count(struct intel_digital_port *dig_port)
 }
 
 /* Theoretical max between source and sink */
-int intel_dp_max_common_lane_count(struct intel_dp *intel_dp)
+static int intel_dp_max_common_lane_count(struct intel_dp *intel_dp)
 {
 	struct intel_digital_port *dig_port = dp_to_dig_port(intel_dp);
 	int source_max = intel_dp_max_source_lane_count(dig_port);
@@ -3575,7 +3575,7 @@ void intel_dp_set_link_params(struct intel_dp *intel_dp,
 
 void intel_dp_reset_link_params(struct intel_dp *intel_dp)
 {
-	intel_dp->link.max_lane_count = intel_dp_max_common_lane_count(intel_dp);
+	intel_dp->link.max_lane_count = intel_dp_link_caps_max_common_lane_count(intel_dp->link.caps);
 	intel_dp->link.max_rate = intel_dp_max_common_rate(intel_dp);
 	intel_dp->link.mst_probed_lane_count = 0;
 	intel_dp->link.mst_probed_rate = 0;
drivers/gpu/drm/i915/display/intel_dp.h +0 -1
index 363907d463486..6abce846b8e7e 100644
@@ -103,7 +103,6 @@ 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_max_common_lane_count(struct intel_dp *intel_dp);
 int intel_dp_rate_index(const int *rates, int len, int rate);
 void intel_dp_update_sink_caps(struct intel_dp *intel_dp);
 void intel_dp_reset_link_params(struct intel_dp *intel_dp);
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +6 -1
index a250d7ee06ebb..5d41e6d9b07df 100644
@@ -126,6 +126,11 @@ void intel_dp_link_caps_all_common_rates(struct intel_dp_link_caps *link_caps,
 	*num_rates = link_caps->num_rates;
 }
 
+int intel_dp_link_caps_max_common_lane_count(struct intel_dp_link_caps *link_caps)
+{
+	return link_caps->max_lane_count;
+}
+
 static int forced_lane_count(struct intel_dp *intel_dp)
 {
 	struct intel_dp_link_caps *link_caps = intel_dp->link.caps;
@@ -134,7 +139,7 @@ static int forced_lane_count(struct intel_dp *intel_dp)
 		return 0;
 
 	return clamp(link_caps->forced_params.lane_count,
-		     1, intel_dp_max_common_lane_count(intel_dp));
+		     1, intel_dp_link_caps_max_common_lane_count(link_caps));
 }
 
 static int forced_link_rate(struct intel_dp *intel_dp)
drivers/gpu/drm/i915/display/intel_dp_link_caps.h +1 -0
index 7a2e383caeef4..0283c27b71a8c 100644
@@ -19,6 +19,7 @@ int intel_dp_max_common_rate(struct intel_dp *intel_dp);
 int intel_dp_link_caps_num_common_rates(struct intel_dp_link_caps *link_caps);
 void intel_dp_link_caps_all_common_rates(struct intel_dp_link_caps *link_caps,
 					 const int **rates, int *num_rates);
+int intel_dp_link_caps_max_common_lane_count(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);
drivers/gpu/drm/i915/display/intel_dp_tunnel.c +2 -1
index 64fd4f09d1cdd..0f1a6f9d47ec5 100644
@@ -57,8 +57,9 @@ 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(intel_dp);
-	int lane_count = intel_dp_max_common_lane_count(intel_dp);
+	int lane_count = intel_dp_link_caps_max_common_lane_count(link_caps);
 
 	return intel_dp_max_link_data_rate(intel_dp, rate, lane_count);
 }
Signature · 1 line
2.49.1
author
#71 lore raw

PATCH 48/108 drm/i915/dp_link_caps: Move updating max link limits to link_caps update

In reply to Imre Deak

Move updating the maximum link rate limit to intel_dp_link_caps_update(), together with the supported link rates and maximum lane count.

This allows updating the max rate and lane count limit - the maximum bounds over the currently allowed link configurations - alongside both sink capability changes and link training fallback reductions of the allowed configuration set.

---
 drivers/gpu/drm/i915/display/intel_dp.c       | 18 ---------------
 .../gpu/drm/i915/display/intel_dp_link_caps.c | 22 ++++++++++++++++---
 .../gpu/drm/i915/display/intel_dp_link_caps.h |  2 --
 3 files changed, 19 insertions(+), 23 deletions(-)
drivers/gpu/drm/i915/display/intel_dp.c +0 -18
index 18b06e5402611..7326f6d09f186 100644
@@ -690,11 +690,9 @@ static void intel_dp_get_common_rates(struct intel_dp *intel_dp,
 /* Return %true if any supported or maximum link param changed. */
 static bool intel_dp_set_common_link_params(struct intel_dp *intel_dp)
 {
-	int old_max_rate_limit = intel_dp->link.max_rate;
 	int num_common_rates;
 	int common_rates[DP_MAX_SUPPORTED_RATES];
 	bool link_params_changed = false;
-	int len;
 
 	intel_dp_get_common_rates(intel_dp, common_rates, &num_common_rates);
 	if (intel_dp_link_caps_update(intel_dp,
@@ -702,13 +700,6 @@ static bool intel_dp_set_common_link_params(struct intel_dp *intel_dp)
 				      intel_dp_max_common_lane_count(intel_dp)))
 		link_params_changed = true;
 
-	len = intel_dp_common_len_rate_limit(intel_dp, intel_dp->link.max_rate);
-	if (len > 0)
-		intel_dp->link.max_rate = intel_dp_common_rate(intel_dp, len - 1);
-
-	if (intel_dp->link.max_rate != old_max_rate_limit)
-		link_params_changed = true;
-
 	return link_params_changed;
 }
 
@@ -4738,8 +4729,6 @@ intel_dp_has_sink_count(struct intel_dp *intel_dp)
 void intel_dp_update_sink_caps(struct intel_dp *intel_dp)
 {
 	struct intel_connector *connector = intel_dp->attached_connector;
-	int old_max_lane_count_limit = intel_dp->link.max_lane_count;
-	int current_max_common_lane_count;
 	bool link_params_changed = false;
 
 	intel_dp_set_sink_rates(intel_dp);
@@ -4747,13 +4736,6 @@ void intel_dp_update_sink_caps(struct intel_dp *intel_dp)
 	if (intel_dp_set_common_link_params(intel_dp))
 		link_params_changed = true;
 
-	current_max_common_lane_count = intel_dp_max_common_lane_count(intel_dp);
-	intel_dp->link.max_lane_count = min(intel_dp->link.max_lane_count,
-					    current_max_common_lane_count);
-
-	if (intel_dp->link.max_lane_count != old_max_lane_count_limit)
-		link_params_changed = true;
-
 	if (link_params_changed)
 		connector->base.epoch_counter++;
 }
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +19 -3
index 5d41e6d9b07df..e514103654fde 100644
@@ -48,8 +48,8 @@ struct intel_dp_link_caps {
 };
 
 /* Get length of common rates array potentially limited by max_rate. */
-int intel_dp_common_len_rate_limit(const struct intel_dp *intel_dp,
-				   int max_rate)
+static int intel_dp_common_len_rate_limit(const struct intel_dp *intel_dp,
+					  int max_rate)
 {
 	struct intel_dp_link_caps *link_caps = intel_dp->link.caps;
 
@@ -223,12 +223,15 @@ bool intel_dp_link_caps_update(struct intel_dp *intel_dp,
 {
 	struct intel_dp_link_caps *link_caps = intel_dp->link.caps;
 	struct intel_display *display = to_intel_display(intel_dp);
+	int old_max_lane_count_limit = intel_dp->link.max_lane_count;
+	int old_max_rate_limit = intel_dp->link.max_rate;
 	int old_rates[DP_MAX_SUPPORTED_RATES];
 	struct intel_dp_link_config_entry *lc;
 	bool link_params_changed = false;
 	int num_common_lane_configs;
 	int old_max_lane_count;
 	int num_old_rates;
+	int len;
 	int i;
 	int j;
 
@@ -273,7 +276,20 @@ bool intel_dp_link_caps_update(struct intel_dp *intel_dp,
 				       old_max_lane_count))
 		link_params_changed = true;
 
-	/* TODO: Also detect a change in the max link limits. */
+	/* TODO: Update these as part of the rest of max param updates. */
+	len = intel_dp_common_len_rate_limit(intel_dp, intel_dp->link.max_rate);
+	if (len > 0)
+		intel_dp->link.max_rate = intel_dp_common_rate(intel_dp, len - 1);
+
+	if (intel_dp->link.max_rate != old_max_rate_limit)
+		link_params_changed = true;
+
+	intel_dp->link.max_lane_count = min(intel_dp->link.max_lane_count,
+					    max_lane_count);
+
+	if (intel_dp->link.max_lane_count != old_max_lane_count_limit)
+		link_params_changed = true;
+
 	return link_params_changed;
 }
 
drivers/gpu/drm/i915/display/intel_dp_link_caps.h +0 -2
index 0283c27b71a8c..9f5bc9b7715fb 100644
@@ -11,8 +11,6 @@ struct intel_dp;
 struct intel_dp_link_caps;
 struct intel_dp_link_config;
 
-int intel_dp_common_len_rate_limit(const struct intel_dp *intel_dp,
-				   int max_rate);
 int intel_dp_common_rate(struct intel_dp *intel_dp, 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 *intel_dp);
Signature · 1 line
2.49.1
author
#72 lore raw

PATCH 49/108 drm/i915/dp_link_caps: Add helpers to get max link limits

In reply to Imre Deak

Add intel_dp_link_caps_get_max_limits() to query the current maximum link limits (max bound over all allowed configurations) through the link caps API instead of direct accesses.

This allows tracking the state internally within the link caps module.

---
 drivers/gpu/drm/i915/display/intel_dp.c       |  9 ++++-
 .../gpu/drm/i915/display/intel_dp_link_caps.c | 38 ++++++++++++++++++-
 .../gpu/drm/i915/display/intel_dp_link_caps.h |  3 ++
 .../drm/i915/display/intel_dp_link_training.c |  8 +++-
 4 files changed, 52 insertions(+), 6 deletions(-)
drivers/gpu/drm/i915/display/intel_dp.c +7 -2
index 7326f6d09f186..1e26f6000b711 100644
@@ -355,15 +355,17 @@ static int intel_dp_max_common_lane_count(struct intel_dp *intel_dp)
 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 = intel_dp->link.max_lane_count;
+		lane_count = max_link_limits.lane_count;
 
 	switch (lane_count) {
 	case 1:
@@ -1547,6 +1549,7 @@ 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;
 
 	intel_dp_link_caps_get_forced_params(link_caps, &forced_params);
@@ -1554,7 +1557,9 @@ intel_dp_max_link_rate(struct intel_dp *intel_dp)
 	if (forced_params.rate)
 		return forced_params.rate;
 
-	return intel_dp->link.max_rate;
+	intel_dp_link_caps_get_max_limits(link_caps, &max_link_limits);
+
+	return max_link_limits.rate;
 }
 
 static int
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +36 -2
index e514103654fde..f645c0a9dba69 100644
@@ -175,6 +175,36 @@ static int intel_dp_link_config_lane_count(const struct intel_dp_link_config_ent
 	return 1 << lc->lane_count_exp;
 }
 
+/**
+ * intel_dp_link_caps_get_max_limits - get the current maximum link limits
+ * @link_caps: link capabilities state
+ * @max_link_limits: returned maximum link limits
+ *
+ * Return the current maximum rate and lane count limits in
+ * @max_link_limits.
+ *
+ * These limits constrain the set of allowed configurations.
+ *
+ * The limits are set to the maximum common supported values after
+ * intel_dp_link_caps_reset() is called, and can later be modified by
+ * intel_dp_link_caps_set_max_limits(). The max rate and lane count
+ * parameters are independent limits, so the pair does not necessarily
+ * define a valid configuration.
+ *
+ * This function may be called without serializing against updates to
+ * @link_caps. However, without such serialization the returned value may be
+ * an out-of-sync (link rate, lane count) tuple, i.e. the parameters may
+ * belong to different update snapshots in time.
+ */
+void intel_dp_link_caps_get_max_limits(struct intel_dp_link_caps *link_caps,
+				       struct intel_dp_link_config *max_link_limits)
+{
+	struct intel_dp *intel_dp = link_caps->dp;
+
+	max_link_limits->rate = intel_dp->link.max_rate;
+	max_link_limits->lane_count = intel_dp->link.max_lane_count;
+}
+
 static int intel_dp_link_config_bw(struct intel_dp *intel_dp,
 				   const struct intel_dp_link_config_entry *lc)
 {
@@ -545,6 +575,7 @@ static int i915_dp_max_link_rate_show(void *data, u64 *val)
 	struct intel_connector *connector = to_intel_connector(data);
 	struct intel_display *display = to_intel_display(connector);
 	struct intel_dp *intel_dp = intel_attached_dp(connector);
+	struct intel_dp_link_config max_link_limits;
 	int err;
 
 	err = drm_modeset_lock_single_interruptible(&display->drm->mode_config.connection_mutex);
@@ -553,7 +584,8 @@ static int i915_dp_max_link_rate_show(void *data, u64 *val)
 
 	intel_dp_flush_connector_commits(connector);
 
-	*val = intel_dp->link.max_rate;
+	intel_dp_link_caps_get_max_limits(intel_dp->link.caps, &max_link_limits);
+	*val = max_link_limits.rate;
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
 
@@ -566,6 +598,7 @@ static int i915_dp_max_lane_count_show(void *data, u64 *val)
 	struct intel_connector *connector = to_intel_connector(data);
 	struct intel_display *display = to_intel_display(connector);
 	struct intel_dp *intel_dp = intel_attached_dp(connector);
+	struct intel_dp_link_config max_link_limits;
 	int err;
 
 	err = drm_modeset_lock_single_interruptible(&display->drm->mode_config.connection_mutex);
@@ -574,7 +607,8 @@ static int i915_dp_max_lane_count_show(void *data, u64 *val)
 
 	intel_dp_flush_connector_commits(connector);
 
-	*val = intel_dp->link.max_lane_count;
+	intel_dp_link_caps_get_max_limits(intel_dp->link.caps, &max_link_limits);
+	*val = max_link_limits.lane_count;
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
 
drivers/gpu/drm/i915/display/intel_dp_link_caps.h +3 -0
index 9f5bc9b7715fb..35bbe340955a6 100644
@@ -25,6 +25,9 @@ void intel_dp_link_caps_get_forced_params(struct intel_dp_link_caps *link_caps,
 int intel_dp_link_config_index(struct intel_dp *intel_dp, int link_rate, int lane_count);
 void intel_dp_link_config_get(struct intel_dp *intel_dp, int idx, int *link_rate, int *lane_count);
 
+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_update(struct intel_dp *intel_dp,
 			       const int *rates, int num_rates, int max_lane_count);
 
drivers/gpu/drm/i915/display/intel_dp_link_training.c +6 -2
index 456540925db55..ff146027baa3c 100644
@@ -2303,6 +2303,8 @@ void intel_dp_128b132b_sdp_crc16(struct intel_dp *intel_dp,
 bool intel_dp_link_params_valid(struct intel_dp *intel_dp, int link_rate,
 				u8 lane_count)
 {
+	struct intel_dp_link_config max_link_limits;
+
 	/*
 	 * FIXME: we need to synchronize the current link parameters with
 	 * hardware readout. Currently fast link training doesn't work on
@@ -2325,12 +2327,14 @@ bool intel_dp_link_params_valid(struct intel_dp *intel_dp, int link_rate,
 	 * configuration. Although that happens to be true for now, it will
 	 * stop being guaranteed once fallback depends only on disabled configs.
 	 */
+	intel_dp_link_caps_get_max_limits(intel_dp->link.caps, &max_link_limits);
+
 	if (link_rate == 0 ||
-	    link_rate > intel_dp->link.max_rate)
+	    link_rate > max_link_limits.rate)
 		return false;
 
 	if (lane_count == 0 ||
-	    lane_count > intel_dp_max_lane_count(intel_dp))
+	    lane_count > max_link_limits.lane_count)
 		return false;
 
 	return true;
Signature · 1 line
2.49.1
author
#73 lore raw

PATCH 50/108 drm/i915/dp_link_caps: Add helpers to set max link limits

In reply to Imre Deak

Add intel_dp_link_caps_set_max_limits() to set the current maximum link limits (max bound over all allowed configurations) through the link caps API instead of direct accesses.

This allows tracking the state internally within the link caps module.

---
 .../gpu/drm/i915/display/intel_dp_link_caps.c | 35 +++++++++++++++++++
 .../gpu/drm/i915/display/intel_dp_link_caps.h |  2 ++
 .../drm/i915/display/intel_dp_link_training.c |  9 +++--
 3 files changed, 44 insertions(+), 2 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +35 -0
index f645c0a9dba69..fa8d3a140414f 100644
@@ -175,6 +175,15 @@ static int intel_dp_link_config_lane_count(const struct intel_dp_link_config_ent
 	return 1 << lc->lane_count_exp;
 }
 
+static void set_max_link_limits_no_update(struct intel_dp_link_caps *link_caps,
+					  const struct intel_dp_link_config *max_link_limits)
+{
+	struct intel_dp *intel_dp = link_caps->dp;
+
+	intel_dp->link.max_rate = max_link_limits->rate;
+	intel_dp->link.max_lane_count = max_link_limits->lane_count;
+}
+
 /**
  * intel_dp_link_caps_get_max_limits - get the current maximum link limits
  * @link_caps: link capabilities state
@@ -205,6 +214,32 @@ void intel_dp_link_caps_get_max_limits(struct intel_dp_link_caps *link_caps,
 	max_link_limits->lane_count = intel_dp->link.max_lane_count;
 }
 
+/**
+ * intel_dp_link_caps_set_max_limits - set the current maximum link limits
+ * @link_caps: link capabilities state
+ * @max_link_limits: new maximum link limits
+ *
+ * Set the current maximum rate and lane count limits to @max_link_limits,
+ * constraining the set of allowed configurations.
+ *
+ * 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.
+ *
+ * Return:
+ * - %true  if the @link_caps cached max limits value got updated with
+ *          @max_link_limits.
+ * - %false if @max_link_limits is invalid.
+ */
+bool intel_dp_link_caps_set_max_limits(struct intel_dp_link_caps *link_caps,
+				       const struct intel_dp_link_config *max_link_limits)
+{
+	set_max_link_limits_no_update(link_caps, max_link_limits);
+
+	/* TODO: validate max_link_limits */
+	return true;
+}
+
 static int intel_dp_link_config_bw(struct intel_dp *intel_dp,
 				   const struct intel_dp_link_config_entry *lc)
 {
drivers/gpu/drm/i915/display/intel_dp_link_caps.h +2 -0
index 35bbe340955a6..ed053d9c81380 100644
@@ -27,6 +27,8 @@ void intel_dp_link_config_get(struct intel_dp *intel_dp, int idx, int *link_rate
 
 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,
+				       const struct intel_dp_link_config *max_link_limits);
 
 bool intel_dp_link_caps_update(struct intel_dp *intel_dp,
 			       const int *rates, int num_rates, int max_lane_count);
drivers/gpu/drm/i915/display/intel_dp_link_training.c +7 -2
index ff146027baa3c..5e60621f4442e 100644
@@ -1872,6 +1872,8 @@ static bool reduce_link_params(struct intel_dp *intel_dp, const struct intel_crt
 static int intel_dp_get_link_train_fallback_values(struct intel_dp *intel_dp,
 						   const struct intel_crtc_state *crtc_state)
 {
+	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;
 
@@ -1897,8 +1899,11 @@ static int intel_dp_get_link_train_fallback_values(struct intel_dp *intel_dp,
 	       crtc_state->lane_count, crtc_state->port_clock,
 	       new_lane_count, new_link_rate);
 
-	intel_dp->link.max_rate = new_link_rate;
-	intel_dp->link.max_lane_count = new_lane_count;
+	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);
 
 	return 0;
 }
Signature · 1 line
2.49.1
author
#74 lore raw

PATCH 51/108 drm/i915/dp_link_caps: Validate max link limits

In reply to Imre Deak

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, active forced parameters and previously set max limits 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.

---
 .../gpu/drm/i915/display/intel_dp_link_caps.c | 70 ++++++++++++++++++-
 1 file changed, 69 insertions(+), 1 deletion(-)
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +69 -1
index fa8d3a140414f..90cbbe32f180b 100644
@@ -175,6 +175,54 @@ static int intel_dp_link_config_lane_count(const struct intel_dp_link_config_ent
 	return 1 << lc->lane_count_exp;
 }
 
+static void
+to_intel_dp_link_config(struct intel_dp_link_caps *link_caps,
+			const struct intel_dp_link_config_entry *lc,
+			struct intel_dp_link_config *config)
+{
+	struct intel_dp *intel_dp = link_caps->dp;
+
+	config->rate = intel_dp_link_config_rate(intel_dp, lc);
+	config->lane_count = intel_dp_link_config_lane_count(lc);
+}
+
+static u32 calc_allowed_config_mask(struct intel_dp_link_caps *link_caps,
+				    u32 disabled_config_mask,
+				    const struct intel_dp_link_config *max_limits,
+				    const struct intel_dp_link_config *forced_params)
+{
+	struct intel_dp_link_config config;
+	u32 allowed_mask = 0;
+	int config_idx;
+
+	for (config_idx = 0; config_idx < link_caps->num_configs; config_idx++) {
+		const struct intel_dp_link_config_entry *lc = &link_caps->configs[config_idx];
+
+		if (BIT(config_idx) & disabled_config_mask)
+			continue;
+
+		to_intel_dp_link_config(link_caps, lc, &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_mask |= BIT(config_idx);
+	}
+
+	return allowed_mask;
+}
+
 static void set_max_link_limits_no_update(struct intel_dp_link_caps *link_caps,
 					  const struct intel_dp_link_config *max_link_limits)
 {
@@ -214,6 +262,20 @@ void intel_dp_link_caps_get_max_limits(struct intel_dp_link_caps *link_caps,
 	max_link_limits->lane_count = intel_dp->link.max_lane_count;
 }
 
+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_config forced_params;
+	u32 disabled_mask = 0;	/* get the mask from link_caps. */
+	u32 allowed_mask;
+
+	intel_dp_link_caps_get_forced_params(link_caps, &forced_params);
+	allowed_mask = calc_allowed_config_mask(link_caps, disabled_mask,
+						max_link_limits, &forced_params);
+
+	return allowed_mask != 0;
+}
+
 /**
  * intel_dp_link_caps_set_max_limits - set the current maximum link limits
  * @link_caps: link capabilities state
@@ -222,6 +284,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.
@@ -234,9 +300,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
author
#75 lore raw

PATCH 52/108 drm/i915/dp_link_caps: Add helper to reset max link limits

In reply to Imre Deak

Add a helper to reset the link_caps::max_limits max link limits to the maximum common supported rate and lane count.

This is needed by a follow-up change in the link training fallback code, which temporarily resets max_limits before searching for a fallback configuration.

---
 .../gpu/drm/i915/display/intel_dp_link_caps.c | 22 +++++++++++++++++++
 .../gpu/drm/i915/display/intel_dp_link_caps.h |  1 +
 2 files changed, 23 insertions(+)
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +22 -0
index 90cbbe32f180b..e23793ffde58c 100644
@@ -232,6 +232,16 @@ static void set_max_link_limits_no_update(struct intel_dp_link_caps *link_caps,
 	intel_dp->link.max_lane_count = max_link_limits->lane_count;
 }
 
+static void reset_max_link_limits_no_update(struct intel_dp_link_caps *link_caps)
+{
+	struct intel_dp_link_config max_link_limits = {
+		.rate = intel_dp_max_common_rate(link_caps->dp),
+		.lane_count = intel_dp_link_caps_max_common_lane_count(link_caps),
+	};
+
+	set_max_link_limits_no_update(link_caps, &max_link_limits);
+}
+
 /**
  * intel_dp_link_caps_get_max_limits - get the current maximum link limits
  * @link_caps: link capabilities state
@@ -308,6 +318,18 @@ bool intel_dp_link_caps_set_max_limits(struct intel_dp_link_caps *link_caps,
 	return true;
 }
 
+/**
+ * intel_dp_link_caps_reset_max_limits - reset the current maximum link limits
+ * @link_caps: link capabilities state
+ *
+ * Reset the current maximum link limits to the maximum supported common link
+ * rate and lane count.
+ */
+void intel_dp_link_caps_reset_max_limits(struct intel_dp_link_caps *link_caps)
+{
+	reset_max_link_limits_no_update(link_caps);
+}
+
 static int intel_dp_link_config_bw(struct intel_dp *intel_dp,
 				   const struct intel_dp_link_config_entry *lc)
 {
drivers/gpu/drm/i915/display/intel_dp_link_caps.h +1 -0
index ed053d9c81380..c7ea40b1714d1 100644
@@ -29,6 +29,7 @@ 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,
 				       const struct intel_dp_link_config *max_link_limits);
+void intel_dp_link_caps_reset_max_limits(struct intel_dp_link_caps *link_caps);
 
 bool intel_dp_link_caps_update(struct intel_dp *intel_dp,
 			       const int *rates, int num_rates, int max_lane_count);
Signature · 1 line
2.49.1
author
#76 lore raw

PATCH 53/108 drm/i915/dp_link_caps: Add helper to reset link_caps state

In reply to Imre Deak

Add a helper to reset the link_caps state, removing all restrictions except user-forced parameters, re-allowing all supported configurations. Currently this only resets the maximum link limits, but follow-up changes will also re-enable configurations previously disabled on a per-configuration basis by fallback or other logic.

---
 drivers/gpu/drm/i915/display/intel_dp.c        |  3 +--
 .../gpu/drm/i915/display/intel_dp_link_caps.c  | 18 ++++++++++++++++++
 .../gpu/drm/i915/display/intel_dp_link_caps.h  |  1 +
 3 files changed, 20 insertions(+), 2 deletions(-)
drivers/gpu/drm/i915/display/intel_dp.c +1 -2
index 1e26f6000b711..dd4c03893a69f 100644
@@ -3571,8 +3571,7 @@ void intel_dp_set_link_params(struct intel_dp *intel_dp,
 
 void intel_dp_reset_link_params(struct intel_dp *intel_dp)
 {
-	intel_dp->link.max_lane_count = intel_dp_link_caps_max_common_lane_count(intel_dp->link.caps);
-	intel_dp->link.max_rate = intel_dp_max_common_rate(intel_dp);
+	intel_dp_link_caps_reset(intel_dp->link.caps);
 	intel_dp->link.mst_probed_lane_count = 0;
 	intel_dp->link.mst_probed_rate = 0;
 	intel_dp_link_training_reset(intel_dp->link.training);
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +18 -0
index e23793ffde58c..bdb0d31b0cf03 100644
@@ -482,6 +482,24 @@ int intel_dp_link_config_index(struct intel_dp *intel_dp, int link_rate, int lan
 	return -1;
 }
 
+/**
+ * intel_dp_link_caps_reset - reset link capability restrictions
+ * @link_caps: link capabilities state
+ *
+ * Reset all current restrictions except for the user requested forced
+ * parameters, thus updating the set of allowed configurations and the
+ * derived maximum link information accordingly.
+ *
+ * This function is regularly called after a sink is connected, either
+ * for the first time to the connector or after a previous sink was
+ * disconnected from it, and intel_dp_link_caps_update() was called.
+ */
+void intel_dp_link_caps_reset(struct intel_dp_link_caps *link_caps)
+{
+	/* TODO: Update the limits to account for forced params. */
+	reset_max_link_limits_no_update(link_caps);
+}
+
 static int i915_dp_force_link_rate_show(struct seq_file *m, void *data)
 {
 	struct intel_connector *connector = to_intel_connector(m->private);
drivers/gpu/drm/i915/display/intel_dp_link_caps.h +1 -0
index c7ea40b1714d1..fed8b0ca72ff2 100644
@@ -33,6 +33,7 @@ void intel_dp_link_caps_reset_max_limits(struct intel_dp_link_caps *link_caps);
 
 bool intel_dp_link_caps_update(struct intel_dp *intel_dp,
 			       const int *rates, int num_rates, int max_lane_count);
+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
author
#77 lore raw

PATCH 54/108 drm/i915/dp_link_caps: Move max link limits to link_caps

In reply to Imre Deak

Now that all users access the max link limits via helpers, move tracking of these limits from struct intel_dp to the link_caps state.

---
 .../drm/i915/display/intel_display_types.h    |  4 --
 .../gpu/drm/i915/display/intel_dp_link_caps.c | 56 +++++++++++++------
 2 files changed, 40 insertions(+), 20 deletions(-)
drivers/gpu/drm/i915/display/intel_display_types.h +0 -4
index 71cb45a2374b0..b01f4d07ba862 100644
@@ -1829,10 +1829,6 @@ struct intel_dp {
 	struct {
 		/* TODO: move the rest of link specific fields to here */
 		bool active;
-		/* Max lane count for the current link */
-		int max_lane_count;
-		/* Max rate for the current link */
-		int max_rate;
 		/*
 		 * Link parameters for which the MST topology was probed.
 		 * Tracking these ensures that the MST path resources are
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +40 -16

91 lines not on this page · raw message

Signature · 1 line
2.49.1
author
#78 lore raw

PATCH 55/108 drm/i915/dp_link_caps: Pass link_caps to static functions

In reply to Imre Deak

Pass the link_caps pointer to static functions in intel_dp_link_caps.c, as it holds the state with the relevant information.

---
 .../gpu/drm/i915/display/intel_dp_link_caps.c | 41 +++++++++----------
 1 file changed, 20 insertions(+), 21 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +20 -21
index 6d0ce343e7b04..1f6e391838894 100644
@@ -161,10 +161,8 @@ int intel_dp_link_caps_max_common_lane_count(struct intel_dp_link_caps *link_cap
 	return link_caps->max_lane_count;
 }
 
-static int forced_lane_count(struct intel_dp *intel_dp)
+static int forced_lane_count(struct intel_dp_link_caps *link_caps)
 {
-	struct intel_dp_link_caps *link_caps = intel_dp->link.caps;
-
 	if (!link_caps->forced_params.lane_count)
 		return 0;
 
@@ -172,9 +170,9 @@ static int forced_lane_count(struct intel_dp *intel_dp)
 		     1, intel_dp_link_caps_max_common_lane_count(link_caps));
 }
 
-static int forced_link_rate(struct intel_dp *intel_dp)
+static int forced_link_rate(struct intel_dp_link_caps *link_caps)
 {
-	struct intel_dp_link_caps *link_caps = intel_dp->link.caps;
+	struct intel_dp *intel_dp = link_caps->dp;
 	int len;
 
 	if (!link_caps->forced_params.rate)
@@ -190,14 +188,14 @@ static int forced_link_rate(struct intel_dp *intel_dp)
 void intel_dp_link_caps_get_forced_params(struct intel_dp_link_caps *link_caps,
 					  struct intel_dp_link_config *forced_params)
 {
-	forced_params->rate = forced_link_rate(link_caps->dp);
-	forced_params->lane_count = forced_lane_count(link_caps->dp);
+	forced_params->rate = forced_link_rate(link_caps);
+	forced_params->lane_count = forced_lane_count(link_caps);
 }
 
-static int intel_dp_link_config_rate(struct intel_dp *intel_dp,
+static int intel_dp_link_config_rate(struct intel_dp_link_caps *link_caps,
 				     const struct intel_dp_link_config_entry *lc)
 {
-	return intel_dp_common_rate(intel_dp, lc->link_rate_idx);
+	return intel_dp_common_rate(link_caps->dp, lc->link_rate_idx);
 }
 
 static int intel_dp_link_config_lane_count(const struct intel_dp_link_config_entry *lc)
@@ -210,9 +208,7 @@ to_intel_dp_link_config(struct intel_dp_link_caps *link_caps,
 			const struct intel_dp_link_config_entry *lc,
 			struct intel_dp_link_config *config)
 {
-	struct intel_dp *intel_dp = link_caps->dp;
-
-	config->rate = intel_dp_link_config_rate(intel_dp, lc);
+	config->rate = intel_dp_link_config_rate(link_caps, lc);
 	config->lane_count = intel_dp_link_config_lane_count(lc);
 }
 
@@ -354,26 +350,28 @@ void intel_dp_link_caps_reset_max_limits(struct intel_dp_link_caps *link_caps)
 	reset_max_link_limits_no_update(link_caps);
 }
 
-static int intel_dp_link_config_bw(struct intel_dp *intel_dp,
+static int intel_dp_link_config_bw(struct intel_dp_link_caps *link_caps,
 				   const struct intel_dp_link_config_entry *lc)
 {
-	return drm_dp_max_dprx_data_rate(intel_dp_link_config_rate(intel_dp, lc),
+	return drm_dp_max_dprx_data_rate(intel_dp_link_config_rate(link_caps, lc),
 					 intel_dp_link_config_lane_count(lc));
 }
 
 static int link_config_cmp_by_bw(const void *a, const void *b, const void *p)
 {
 	struct intel_dp *intel_dp = (struct intel_dp *)p;	/* remove const */
+	struct intel_dp_link_caps *link_caps = intel_dp->link.caps;
+
 	const struct intel_dp_link_config_entry *lc_a = a;
 	const struct intel_dp_link_config_entry *lc_b = b;
-	int bw_a = intel_dp_link_config_bw(intel_dp, lc_a);
-	int bw_b = intel_dp_link_config_bw(intel_dp, lc_b);
+	int bw_a = intel_dp_link_config_bw(link_caps, lc_a);
+	int bw_b = intel_dp_link_config_bw(link_caps, lc_b);
 
 	if (bw_a != bw_b)
 		return bw_a - bw_b;
 
-	return intel_dp_link_config_rate(intel_dp, lc_a) -
-	       intel_dp_link_config_rate(intel_dp, lc_b);
+	return intel_dp_link_config_rate(link_caps, lc_a) -
+	       intel_dp_link_config_rate(link_caps, lc_b);
 }
 
 static bool current_common_caps_match(struct intel_dp_link_caps *link_caps,
@@ -483,7 +481,7 @@ void intel_dp_link_config_get(struct intel_dp *intel_dp, int idx, int *link_rate
 
 	lc = &link_caps->configs[idx];
 
-	*link_rate = intel_dp_link_config_rate(intel_dp, lc);
+	*link_rate = intel_dp_link_config_rate(link_caps, lc);
 	*lane_count = intel_dp_link_config_lane_count(lc);
 }
 
@@ -564,8 +562,9 @@ static int i915_dp_force_link_rate_show(struct seq_file *m, void *data)
 	return 0;
 }
 
-static int parse_link_rate(struct intel_dp *intel_dp, const char __user *ubuf, size_t len)
+static int parse_link_rate(struct intel_dp_link_caps *link_caps, const char __user *ubuf, size_t len)
 {
+	struct intel_dp *intel_dp = link_caps->dp;
 	char *kbuf;
 	const char *p;
 	int rate;
@@ -608,7 +607,7 @@ static ssize_t i915_dp_force_link_rate_write(struct file *file,
 	int rate;
 	int err;
 
-	rate = parse_link_rate(intel_dp, ubuf, len);
+	rate = parse_link_rate(link_caps, ubuf, len);
 	if (rate < 0)
 		return rate;
 
Signature · 1 line
2.49.1
author
#79 lore raw

PATCH 56/108 drm/i915/dp_link_caps: Pass link_caps to config update/lookup helpers

In reply to Imre Deak

Pass the link_caps pointer to the update/lookup helpers in intel_dp_link_caps.c, as it holds the state with the relevant information.

---
 drivers/gpu/drm/i915/display/intel_dp.c            |  2 +-
 drivers/gpu/drm/i915/display/intel_dp_link_caps.c  | 14 +++++++-------
 drivers/gpu/drm/i915/display/intel_dp_link_caps.h  |  8 +++++---
 .../gpu/drm/i915/display/intel_dp_link_training.c  |  5 +++--
 4 files changed, 16 insertions(+), 13 deletions(-)
drivers/gpu/drm/i915/display/intel_dp.c +1 -1
index dd4c03893a69f..a3f293af5dbfb 100644
@@ -697,7 +697,7 @@ static bool intel_dp_set_common_link_params(struct intel_dp *intel_dp)
 	bool link_params_changed = false;
 
 	intel_dp_get_common_rates(intel_dp, common_rates, &num_common_rates);
-	if (intel_dp_link_caps_update(intel_dp,
+	if (intel_dp_link_caps_update(intel_dp->link.caps,
 				      common_rates, num_common_rates,
 				      intel_dp_max_common_lane_count(intel_dp)))
 		link_params_changed = true;
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +7 -7
index 1f6e391838894..fc569092a4dd6 100644
@@ -395,10 +395,10 @@ static bool current_common_caps_match(struct intel_dp_link_caps *link_caps,
 }
 
 /* Return %true if the supported link parameters have changed. */
-bool intel_dp_link_caps_update(struct intel_dp *intel_dp,
+bool intel_dp_link_caps_update(struct intel_dp_link_caps *link_caps,
 			       const int *rates, int num_rates, int max_lane_count)
 {
-	struct intel_dp_link_caps *link_caps = intel_dp->link.caps;
+	struct intel_dp *intel_dp = link_caps->dp;
 	struct intel_display *display = to_intel_display(intel_dp);
 	struct intel_dp_link_config old_max_limits =
 		link_caps->max_limits;
@@ -470,10 +470,10 @@ bool intel_dp_link_caps_update(struct intel_dp *intel_dp,
 	return link_params_changed;
 }
 
-void intel_dp_link_config_get(struct intel_dp *intel_dp, int idx, 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)
 {
-	struct intel_dp_link_caps *link_caps = intel_dp->link.caps;
-	struct intel_display *display = to_intel_display(intel_dp);
+	struct intel_display *display = to_intel_display(link_caps->dp);
 	const struct intel_dp_link_config_entry *lc;
 
 	if (drm_WARN_ON(display->drm, idx < 0 || idx >= link_caps->num_configs))
@@ -485,9 +485,9 @@ void intel_dp_link_config_get(struct intel_dp *intel_dp, int idx, int *link_rate
 	*lane_count = intel_dp_link_config_lane_count(lc);
 }
 
-int intel_dp_link_config_index(struct intel_dp *intel_dp, int link_rate, int lane_count)
+int intel_dp_link_config_index(struct intel_dp_link_caps *link_caps,
+			       int link_rate, int lane_count)
 {
-	struct intel_dp_link_caps *link_caps = intel_dp->link.caps;
 	int link_rate_idx = intel_dp_rate_index(link_caps->rates, link_caps->num_rates,
 						link_rate);
 	int lane_count_exp = ilog2(lane_count);
drivers/gpu/drm/i915/display/intel_dp_link_caps.h +5 -3
index fed8b0ca72ff2..992917505b0d1 100644
@@ -22,8 +22,10 @@ int intel_dp_link_caps_max_common_lane_count(struct intel_dp_link_caps *link_cap
 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 *intel_dp, int link_rate, int lane_count);
-void intel_dp_link_config_get(struct intel_dp *intel_dp, int idx, int *link_rate, int *lane_count);
+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);
 
 void intel_dp_link_caps_get_max_limits(struct intel_dp_link_caps *link_caps,
 				       struct intel_dp_link_config *max_link_limits);
@@ -31,7 +33,7 @@ bool intel_dp_link_caps_set_max_limits(struct intel_dp_link_caps *link_caps,
 				       const struct intel_dp_link_config *max_link_limits);
 void intel_dp_link_caps_reset_max_limits(struct intel_dp_link_caps *link_caps);
 
-bool intel_dp_link_caps_update(struct intel_dp *intel_dp,
+bool intel_dp_link_caps_update(struct intel_dp_link_caps *link_caps,
 			       const int *rates, int num_rates, int max_lane_count);
 void intel_dp_link_caps_reset(struct intel_dp_link_caps *link_caps);
 
drivers/gpu/drm/i915/display/intel_dp_link_training.c +3 -2
index 5e60621f4442e..9da8892a80df0 100644
@@ -1772,9 +1772,10 @@ static bool reduce_link_params_in_bw_order(struct intel_dp *intel_dp,
 	forced_rate = forced_params.rate;
 	forced_lane_count = forced_params.lane_count;
 
-	i = intel_dp_link_config_index(intel_dp, crtc_state->port_clock, crtc_state->lane_count);
+	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, i, &link_rate, &lane_count);
+		intel_dp_link_config_get(intel_dp->link.caps, i, &link_rate, &lane_count);
 
 		if ((forced_rate &&
 		     forced_rate != link_rate) ||
Signature · 1 line
2.49.1
author
#80 lore raw

PATCH 57/108 drm/i915/dp_link_caps: Pass link_caps to common rate helpers

In reply to Imre Deak

Pass the link_caps pointer to the common rate helpers in intel_dp_link_caps.c, as it holds the state with the relevant information.

---
 drivers/gpu/drm/i915/display/intel_dp.c       |  9 ++++--
 .../gpu/drm/i915/display/intel_dp_link_caps.c | 29 ++++++++-----------
 .../gpu/drm/i915/display/intel_dp_link_caps.h |  4 +--
 .../drm/i915/display/intel_dp_link_training.c |  5 ++--
 .../gpu/drm/i915/display/intel_dp_tunnel.c    |  2 +-
 5 files changed, 24 insertions(+), 25 deletions(-)
drivers/gpu/drm/i915/display/intel_dp.c +6 -3
index a3f293af5dbfb..57f5c73f4c249 100644
@@ -1565,6 +1565,7 @@ intel_dp_max_link_rate(struct intel_dp *intel_dp)
 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);
@@ -1572,7 +1573,7 @@ intel_dp_min_link_rate(struct intel_dp *intel_dp)
 	if (forced_params.rate)
 		return forced_params.rate;
 
-	return intel_dp_common_rate(intel_dp, 0);
+	return intel_dp_common_rate(link_caps, 0);
 }
 
 int intel_dp_rate_select(struct intel_dp *intel_dp, int rate)
@@ -1756,6 +1757,7 @@ 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_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;
 
@@ -1766,7 +1768,7 @@ intel_dp_compute_link_config_wide(struct intel_dp *intel_dp,
 			intel_dp_output_format_link_bpp_x16(pipe_config->output_format, bpp);
 
 		for (i = 0; i < intel_dp_link_caps_num_common_rates(intel_dp->link.caps); i++) {
-			link_rate = intel_dp_common_rate(intel_dp, i);
+			link_rate = intel_dp_common_rate(link_caps, i);
 			if (link_rate < limits->min_rate ||
 			    link_rate > limits->max_rate)
 				continue;
@@ -1990,12 +1992,13 @@ 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;
 
 	for (i = 0; i < intel_dp_link_caps_num_common_rates(intel_dp->link.caps); i++) {
-		link_rate = intel_dp_common_rate(intel_dp, i);
+		link_rate = intel_dp_common_rate(link_caps, i);
 		if (link_rate < limits->min_rate || link_rate > limits->max_rate)
 			continue;
 
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +12 -17
index fc569092a4dd6..4250cdc7af702 100644
@@ -78,18 +78,16 @@ struct intel_dp_link_caps {
 };
 
 /* Get length of common rates array potentially limited by max_rate. */
-static int intel_dp_common_len_rate_limit(const struct intel_dp *intel_dp,
+static int intel_dp_common_len_rate_limit(struct intel_dp_link_caps *link_caps,
 					  int max_rate)
 {
-	struct intel_dp_link_caps *link_caps = intel_dp->link.caps;
-
 	return intel_dp_rate_limit_len(link_caps->rates,
 				       link_caps->num_rates, max_rate);
 }
 
-int intel_dp_common_rate(struct intel_dp *intel_dp, int index)
+int intel_dp_common_rate(struct intel_dp_link_caps *link_caps, int index)
 {
-	struct intel_dp_link_caps *link_caps = intel_dp->link.caps;
+	struct intel_dp *intel_dp = link_caps->dp;
 	struct intel_display *display = to_intel_display(intel_dp);
 
 	if (drm_WARN_ON(display->drm,
@@ -123,11 +121,9 @@ int intel_dp_link_caps_common_rate_idx(struct intel_dp_link_caps *link_caps, int
 }
 
 /* Theoretical max between source and sink */
-int intel_dp_max_common_rate(struct intel_dp *intel_dp)
+int intel_dp_max_common_rate(struct intel_dp_link_caps *link_caps)
 {
-	struct intel_dp_link_caps *link_caps = intel_dp->link.caps;
-
-	return intel_dp_common_rate(intel_dp, link_caps->num_rates - 1);
+	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)
@@ -172,17 +168,16 @@ static int forced_lane_count(struct intel_dp_link_caps *link_caps)
 
 static int forced_link_rate(struct intel_dp_link_caps *link_caps)
 {
-	struct intel_dp *intel_dp = link_caps->dp;
 	int len;
 
 	if (!link_caps->forced_params.rate)
 		return 0;
 
-	len = intel_dp_common_len_rate_limit(intel_dp, link_caps->forced_params.rate);
+	len = intel_dp_common_len_rate_limit(link_caps, link_caps->forced_params.rate);
 	if (len == 0)
-		return intel_dp_common_rate(intel_dp, 0);
+		return intel_dp_common_rate(link_caps, 0);
 
-	return intel_dp_common_rate(intel_dp, len - 1);
+	return intel_dp_common_rate(link_caps, len - 1);
 }
 
 void intel_dp_link_caps_get_forced_params(struct intel_dp_link_caps *link_caps,
@@ -195,7 +190,7 @@ void intel_dp_link_caps_get_forced_params(struct intel_dp_link_caps *link_caps,
 static int intel_dp_link_config_rate(struct intel_dp_link_caps *link_caps,
 				     const struct intel_dp_link_config_entry *lc)
 {
-	return intel_dp_common_rate(link_caps->dp, lc->link_rate_idx);
+	return intel_dp_common_rate(link_caps, lc->link_rate_idx);
 }
 
 static int intel_dp_link_config_lane_count(const struct intel_dp_link_config_entry *lc)
@@ -258,7 +253,7 @@ static void set_max_link_limits_no_update(struct intel_dp_link_caps *link_caps,
 static void reset_max_link_limits_no_update(struct intel_dp_link_caps *link_caps)
 {
 	struct intel_dp_link_config max_link_limits = {
-		.rate = intel_dp_max_common_rate(link_caps->dp),
+		.rate = intel_dp_max_common_rate(link_caps),
 		.lane_count = intel_dp_link_caps_max_common_lane_count(link_caps),
 	};
 
@@ -454,9 +449,9 @@ bool intel_dp_link_caps_update(struct intel_dp_link_caps *link_caps,
 		link_params_changed = true;
 
 	/* TODO: Update these as part of the rest of max param updates. */
-	len = intel_dp_common_len_rate_limit(intel_dp, link_caps->max_limits.rate);
+	len = intel_dp_common_len_rate_limit(link_caps, link_caps->max_limits.rate);
 	if (len > 0)
-		link_caps->max_limits.rate = intel_dp_common_rate(intel_dp, len - 1);
+		link_caps->max_limits.rate = intel_dp_common_rate(link_caps, len - 1);
 
 	if (link_caps->max_limits.rate != old_max_limits.rate)
 		link_params_changed = true;
drivers/gpu/drm/i915/display/intel_dp_link_caps.h +2 -2
index 992917505b0d1..db17f7ba19954 100644
@@ -11,9 +11,9 @@ struct intel_dp;
 struct intel_dp_link_caps;
 struct intel_dp_link_config;
 
-int intel_dp_common_rate(struct intel_dp *intel_dp, int index);
+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 *intel_dp);
+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_all_common_rates(struct intel_dp_link_caps *link_caps,
 					 const int **rates, int *num_rates);
drivers/gpu/drm/i915/display/intel_dp_link_training.c +3 -2
index 9da8892a80df0..a89f9161b8329 100644
@@ -1812,7 +1812,7 @@ static int reduce_link_rate(struct intel_dp *intel_dp, int current_rate)
 	if (rate_index <= 0)
 		return -1;
 
-	new_rate = intel_dp_common_rate(intel_dp, rate_index - 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))
@@ -1839,6 +1839,7 @@ 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;
 
@@ -1846,7 +1847,7 @@ static bool reduce_link_params_in_rate_lane_order(struct intel_dp *intel_dp,
 	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(intel_dp);
+		link_rate = intel_dp_max_common_rate(link_caps);
 	}
 
 	if (lane_count < 0)
drivers/gpu/drm/i915/display/intel_dp_tunnel.c +1 -1
index 0f1a6f9d47ec5..bccd3bfe32a2c 100644
@@ -58,7 +58,7 @@ 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(intel_dp);
+	int rate = intel_dp_max_common_rate(link_caps);
 	int lane_count = intel_dp_link_caps_max_common_lane_count(link_caps);
 
 	return intel_dp_max_link_data_rate(intel_dp, rate, lane_count);
Signature · 1 line
2.49.1
author
#81 lore raw

PATCH 58/108 drm/i915/dp_link_caps: Add link_caps prefix to common rate helpers

In reply to Imre Deak

Rename the common rate helpers in intel_dp_link_caps.c to use the intel_dp_link_caps_ prefix, matching the other exported functions in the file.

---
 drivers/gpu/drm/i915/display/intel_dp.c       |  6 ++---
 .../gpu/drm/i915/display/intel_dp_link_caps.c | 24 +++++++++----------
 .../gpu/drm/i915/display/intel_dp_link_caps.h |  4 ++--
 .../drm/i915/display/intel_dp_link_training.c |  4 ++--
 .../gpu/drm/i915/display/intel_dp_tunnel.c    |  2 +-
 5 files changed, 20 insertions(+), 20 deletions(-)
drivers/gpu/drm/i915/display/intel_dp.c +3 -3
index 57f5c73f4c249..88154352e1faa 100644
@@ -1573,7 +1573,7 @@ intel_dp_min_link_rate(struct intel_dp *intel_dp)
 	if (forced_params.rate)
 		return forced_params.rate;
 
-	return intel_dp_common_rate(link_caps, 0);
+	return intel_dp_link_caps_common_rate(link_caps, 0);
 }
 
 int intel_dp_rate_select(struct intel_dp *intel_dp, int rate)
@@ -1768,7 +1768,7 @@ intel_dp_compute_link_config_wide(struct intel_dp *intel_dp,
 			intel_dp_output_format_link_bpp_x16(pipe_config->output_format, bpp);
 
 		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);
+			link_rate = intel_dp_link_caps_common_rate(link_caps, i);
 			if (link_rate < limits->min_rate ||
 			    link_rate > limits->max_rate)
 				continue;
@@ -1998,7 +1998,7 @@ static int dsc_compute_link_config(struct intel_dp *intel_dp,
 	int i;
 
 	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);
+		link_rate = intel_dp_link_caps_common_rate(link_caps, i);
 		if (link_rate < limits->min_rate || link_rate > limits->max_rate)
 			continue;
 
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +12 -12
index 4250cdc7af702..529cb702c99eb 100644
@@ -78,14 +78,14 @@ struct intel_dp_link_caps {
 };
 
 /* Get length of common rates array potentially limited by max_rate. */
-static int intel_dp_common_len_rate_limit(struct intel_dp_link_caps *link_caps,
-					  int max_rate)
+static int intel_dp_link_caps_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);
 }
 
-int intel_dp_common_rate(struct intel_dp_link_caps *link_caps, int index)
+int intel_dp_link_caps_common_rate(struct intel_dp_link_caps *link_caps, int index)
 {
 	struct intel_dp *intel_dp = link_caps->dp;
 	struct intel_display *display = to_intel_display(intel_dp);
@@ -121,9 +121,9 @@ int intel_dp_link_caps_common_rate_idx(struct intel_dp_link_caps *link_caps, int
 }
 
 /* Theoretical max between source and sink */
-int intel_dp_max_common_rate(struct intel_dp_link_caps *link_caps)
+int intel_dp_link_caps_max_common_rate(struct intel_dp_link_caps *link_caps)
 {
-	return intel_dp_common_rate(link_caps, link_caps->num_rates - 1);
+	return intel_dp_link_caps_common_rate(link_caps, link_caps->num_rates - 1);
 }
 
 int intel_dp_link_caps_num_common_rates(struct intel_dp_link_caps *link_caps)
@@ -173,11 +173,11 @@ static int forced_link_rate(struct intel_dp_link_caps *link_caps)
 	if (!link_caps->forced_params.rate)
 		return 0;
 
-	len = intel_dp_common_len_rate_limit(link_caps, link_caps->forced_params.rate);
+	len = intel_dp_link_caps_common_len_rate_limit(link_caps, link_caps->forced_params.rate);
 	if (len == 0)
-		return intel_dp_common_rate(link_caps, 0);
+		return intel_dp_link_caps_common_rate(link_caps, 0);
 
-	return intel_dp_common_rate(link_caps, len - 1);
+	return intel_dp_link_caps_common_rate(link_caps, len - 1);
 }
 
 void intel_dp_link_caps_get_forced_params(struct intel_dp_link_caps *link_caps,
@@ -190,7 +190,7 @@ void intel_dp_link_caps_get_forced_params(struct intel_dp_link_caps *link_caps,
 static int intel_dp_link_config_rate(struct intel_dp_link_caps *link_caps,
 				     const struct intel_dp_link_config_entry *lc)
 {
-	return intel_dp_common_rate(link_caps, lc->link_rate_idx);
+	return intel_dp_link_caps_common_rate(link_caps, lc->link_rate_idx);
 }
 
 static int intel_dp_link_config_lane_count(const struct intel_dp_link_config_entry *lc)
@@ -253,7 +253,7 @@ static void set_max_link_limits_no_update(struct intel_dp_link_caps *link_caps,
 static void reset_max_link_limits_no_update(struct intel_dp_link_caps *link_caps)
 {
 	struct intel_dp_link_config max_link_limits = {
-		.rate = intel_dp_max_common_rate(link_caps),
+		.rate = intel_dp_link_caps_max_common_rate(link_caps),
 		.lane_count = intel_dp_link_caps_max_common_lane_count(link_caps),
 	};
 
@@ -449,9 +449,9 @@ bool intel_dp_link_caps_update(struct intel_dp_link_caps *link_caps,
 		link_params_changed = true;
 
 	/* TODO: Update these as part of the rest of max param updates. */
-	len = intel_dp_common_len_rate_limit(link_caps, link_caps->max_limits.rate);
+	len = intel_dp_link_caps_common_len_rate_limit(link_caps, link_caps->max_limits.rate);
 	if (len > 0)
-		link_caps->max_limits.rate = intel_dp_common_rate(link_caps, len - 1);
+		link_caps->max_limits.rate = intel_dp_link_caps_common_rate(link_caps, len - 1);
 
 	if (link_caps->max_limits.rate != old_max_limits.rate)
 		link_params_changed = true;
drivers/gpu/drm/i915/display/intel_dp_link_caps.h +2 -2
index db17f7ba19954..2afc47c6b7e68 100644
@@ -11,9 +11,9 @@ struct intel_dp;
 struct intel_dp_link_caps;
 struct intel_dp_link_config;
 
-int intel_dp_common_rate(struct intel_dp_link_caps *link_caps, int index);
+int intel_dp_link_caps_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_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_all_common_rates(struct intel_dp_link_caps *link_caps,
 					 const int **rates, int *num_rates);
drivers/gpu/drm/i915/display/intel_dp_link_training.c +2 -2
index a89f9161b8329..b7645bcbe0c2b 100644
@@ -1812,7 +1812,7 @@ static int reduce_link_rate(struct intel_dp *intel_dp, int current_rate)
 	if (rate_index <= 0)
 		return -1;
 
-	new_rate = intel_dp_common_rate(link_caps, rate_index - 1);
+	new_rate = intel_dp_link_caps_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))
@@ -1847,7 +1847,7 @@ static bool reduce_link_params_in_rate_lane_order(struct intel_dp *intel_dp,
 	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);
+		link_rate = intel_dp_link_caps_max_common_rate(link_caps);
 	}
 
 	if (lane_count < 0)
drivers/gpu/drm/i915/display/intel_dp_tunnel.c +1 -1
index bccd3bfe32a2c..52f5c88f7e09c 100644
@@ -58,7 +58,7 @@ 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 rate = intel_dp_link_caps_max_common_rate(link_caps);
 	int lane_count = intel_dp_link_caps_max_common_lane_count(link_caps);
 
 	return intel_dp_max_link_data_rate(intel_dp, rate, lane_count);
Signature · 1 line
2.49.1
author
#82 lore raw

PATCH 59/108 drm/i915/dp_link_caps: Add missing documentation to exported functions

In reply to Imre Deak

Add missing documentation to common rate helpers and the config updater.

---
 .../gpu/drm/i915/display/intel_dp_link_caps.c | 50 ++++++++++++++++++-
 1 file changed, 48 insertions(+), 2 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +48 -2
index 529cb702c99eb..5d6d5441b54a4 100644
@@ -85,6 +85,18 @@ static int intel_dp_link_caps_common_len_rate_limit(struct intel_dp_link_caps *l
 				       link_caps->num_rates, max_rate);
 }
 
+/**
+ * intel_dp_link_caps_common_rate - get common link rate at a given index
+ * @link_caps: link capabilities state
+ * @index: index into the common rate list
+ *
+ * Return the link rate identified by @idx currently supported by @link_caps,
+ * common to both the source and the sink.
+ *
+ * Return:
+ * - Common link rate at @idx.
+ * - 162000 if @idx is out of range.
+ */
 int intel_dp_link_caps_common_rate(struct intel_dp_link_caps *link_caps, int index)
 {
 	struct intel_dp *intel_dp = link_caps->dp;
@@ -120,7 +132,14 @@ int intel_dp_link_caps_common_rate_idx(struct intel_dp_link_caps *link_caps, int
 				   rate);
 }
 
-/* Theoretical max between source and sink */
+/**
+ * intel_dp_link_caps_max_common_rate - get the maximum common link rate
+ * @link_caps: link capabilities state
+ *
+ * Return:
+ * Maximum link rate currently supported by @link_caps, common to both the
+ * source and the sink.
+ */
 int intel_dp_link_caps_max_common_rate(struct intel_dp_link_caps *link_caps)
 {
 	return intel_dp_link_caps_common_rate(link_caps, link_caps->num_rates - 1);
@@ -389,7 +408,34 @@ static bool current_common_caps_match(struct intel_dp_link_caps *link_caps,
 	return true;
 }
 
-/* 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
+ *
+ * Rebuild the supported link configuration state from @rates and
+ * @max_lane_count.
+ *
+ * Configuration indices are not stable across calls to this function, so
+ * callers should not cache such indices and masks built from them across
+ * updates via this function.
+ *
+ * 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 supported link parameters 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)
 {
Signature · 1 line
2.49.1
author
#83 lore raw

PATCH 60/108 drm/i915/dp_link_caps: Set forced link params before resetting link params

In reply to Imre Deak

Set the debugfs forced link parameters before calling intel_dp_reset_link_params(), so the reset can take them into account.

A follow-up change will update the maximum link parameters as part of the reset, where the forced parameters also influence the result.

---
 drivers/gpu/drm/i915/display/intel_dp_link_caps.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +2 -2
index 5d6d5441b54a4..4905d68b13269 100644
@@ -658,8 +658,8 @@ static ssize_t i915_dp_force_link_rate_write(struct file *file,
 
 	intel_dp_flush_connector_commits(connector);
 
-	intel_dp_reset_link_params(intel_dp);
 	link_caps->forced_params.rate = rate;
+	intel_dp_reset_link_params(intel_dp);
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
 
@@ -766,8 +766,8 @@ static ssize_t i915_dp_force_lane_count_write(struct file *file,
 
 	intel_dp_flush_connector_commits(connector);
 
-	intel_dp_reset_link_params(intel_dp);
 	link_caps->forced_params.lane_count = lane_count;
+	intel_dp_reset_link_params(intel_dp);
 
 	drm_modeset_unlock(&display->drm->mode_config.connection_mutex);
 
Signature · 1 line
2.49.1
author
#84 lore raw

PATCH 61/108 drm/i915/dp_link_caps: Adjust max_limits during link config update

In reply to Imre Deak

Adjust the cached max_limits to match the currently allowed configurations when updating link parameters to new sink capabilities.

The adjustment takes disabled configurations, active forced parameters and the currently set max limits into account. Disabled configurations are not supported yet, so that part has no effect for now.

As a safeguard, this restores a state with at least one link configuration enabled if needed.

Various sites query max_limits, including modeset state computation, connector probing, MST link probing, TBT bandwidth calculation, and link status checks. This change provides a way for all queries to see the effective max_limits consistently - taken this into use at those places in follow-up changes. For unserialized contexts (link status check), this is enabled by caching the precomputed value.

A follow-up change will perform the same adjustment during setting and resetting max_limits.

Also export the allowed config mask helper used here for validation, used by follow-up changes to iterate allowed configurations.

---
 .../gpu/drm/i915/display/intel_dp_link_caps.c | 132 ++++++++++++++++--
 .../gpu/drm/i915/display/intel_dp_link_caps.h |   1 +
 2 files changed, 125 insertions(+), 8 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +124 -8
index 4905d68b13269..112d343c6d9d6 100644
@@ -263,6 +263,31 @@ static u32 calc_allowed_config_mask(struct intel_dp_link_caps *link_caps,
 	return allowed_mask;
 }
 
+/**
+ * intel_dp_link_caps_get_allowed_config_mask - get the currently allowed config mask
+ * @link_caps: link capabilities state
+ *
+ * Return:
+ * Mask of link configuration indices allowed after applying the current
+ * maximum link limits, and further narrowing them by any forced link
+ * parameters. The caller may further filter the returned mask before passing
+ * it to the for_each_dp_link_config() iterators.
+ *
+ * See also:
+ * - intel_dp_link_caps_set_max_limits()
+ * - intel_dp_link_caps_get_forced_params()
+ */
+u32 intel_dp_link_caps_get_allowed_config_mask(struct intel_dp_link_caps *link_caps)
+{
+	struct intel_dp_link_config forced_params;
+	u32 disabled_mask = 0;	/* get the mask from link_caps. */
+
+	intel_dp_link_caps_get_forced_params(link_caps, &forced_params);
+
+	return calc_allowed_config_mask(link_caps, disabled_mask,
+					&link_caps->max_limits, &forced_params);
+}
+
 static void set_max_link_limits_no_update(struct intel_dp_link_caps *link_caps,
 					  const struct intel_dp_link_config *max_link_limits)
 {
@@ -279,6 +304,99 @@ static void reset_max_link_limits_no_update(struct intel_dp_link_caps *link_caps
 	set_max_link_limits_no_update(link_caps, &max_link_limits);
 }
 
+static void reset_all_restrictions_no_update(struct intel_dp_link_caps *link_caps)
+{
+	reset_max_link_limits_no_update(link_caps);
+	link_caps->forced_params = INTEL_DP_LINK_CONFIG_NULL;
+}
+
+/*
+ * Compute the maximum link limits from the allowed configurations.
+ *
+ * The result reflects the maximum rate and lane count among the
+ * configurations currently allowed by link_caps, i.e. constrained by
+ * the currently stored max_limits, forced parameters. Since the
+ * allowed set depends on max_limits, the result can only be less
+ * than or equal to the current max_limits.
+ */
+static void compute_max_link_limits(struct intel_dp_link_caps *link_caps,
+				    struct intel_dp_link_config *max_link_limits)
+{
+	u32 allowed_mask = intel_dp_link_caps_get_allowed_config_mask(link_caps);
+	struct intel_dp_link_config max_config = {};
+	struct intel_dp_link_config link_config;
+	int config_idx;
+
+	for (config_idx = 0; config_idx < link_caps->num_configs; config_idx++) {
+		const struct intel_dp_link_config_entry *lc = &link_caps->configs[config_idx];
+
+		if (!(BIT(config_idx) & allowed_mask))
+			continue;
+
+		to_intel_dp_link_config(link_caps, lc, &link_config);
+
+		max_config.rate = max(max_config.rate,
+				      link_config.rate);
+		max_config.lane_count = max(max_config.lane_count,
+					    link_config.lane_count);
+	}
+
+	*max_link_limits = max_config;
+}
+
+/**
+ * update_max_link_limits - update max_limits to match the allowed configs
+ * @link_caps: link capabilities state
+ *
+ * Adjust the stored max_limits to the actual parameter bounds of the
+ * currently allowed configurations.
+ *
+ * The allowed configurations are already constrained by the stored
+ * max_limits and forced parameters. The recomputed max_limits is
+ * derived from that same set, so it can only be less than or equal to
+ * the stored max_limits.
+ *
+ * A %false return indicates an internal error (either the stored
+ * max_limits was below all allowed configurations, or
+ * compute_max_link_limits() returned a larger value). The caller must
+ * recover by removing all restrictions.
+ *
+ * Return:
+ * - %true  if max_limits was updated successfully.
+ * - %false if an internal error was detected.
+ */
+static bool update_max_link_limits(struct intel_dp_link_caps *link_caps)
+{
+	struct intel_display *display = to_intel_display(link_caps->dp);
+	struct intel_dp_link_config new_limits;
+
+	compute_max_link_limits(link_caps, &new_limits);
+
+	if (drm_WARN_ON(display->drm,
+			new_limits.rate == 0 ||
+			new_limits.lane_count == 0 ||
+			new_limits.rate > link_caps->max_limits.rate ||
+			new_limits.lane_count > link_caps->max_limits.lane_count))
+		return false;
+
+	link_caps->max_limits = new_limits;
+
+	return true;
+}
+
+static bool update_max_link_info(struct intel_dp_link_caps *link_caps)
+{
+	struct intel_display *display = to_intel_display(link_caps->dp);
+	bool limit_update_ok;
+
+	limit_update_ok = update_max_link_limits(link_caps);
+
+	if (drm_WARN_ON(display->drm, !limit_update_ok))
+		reset_all_restrictions_no_update(link_caps);
+
+	return limit_update_ok;
+}
+
 /**
  * intel_dp_link_caps_get_max_limits - get the current maximum link limits
  * @link_caps: link capabilities state
@@ -449,7 +567,6 @@ bool intel_dp_link_caps_update(struct intel_dp_link_caps *link_caps,
 	int num_common_lane_configs;
 	int old_max_lane_count;
 	int num_old_rates;
-	int len;
 	int i;
 	int j;
 
@@ -494,17 +611,16 @@ bool intel_dp_link_caps_update(struct intel_dp_link_caps *link_caps,
 				       old_max_lane_count))
 		link_params_changed = true;
 
-	/* TODO: Update these as part of the rest of max param updates. */
-	len = intel_dp_link_caps_common_len_rate_limit(link_caps, link_caps->max_limits.rate);
-	if (len > 0)
-		link_caps->max_limits.rate = intel_dp_link_caps_common_rate(link_caps, len - 1);
+	/*
+	 * A failure could be only due to a bug, the update function handles
+	 * that case by removing all restriction and resetting the max limit
+	 * to the sink's maximum bounds.
+	 */
+	update_max_link_info(link_caps);
 
 	if (link_caps->max_limits.rate != old_max_limits.rate)
 		link_params_changed = true;
 
-	link_caps->max_limits.lane_count = min(link_caps->max_limits.lane_count,
-					       max_lane_count);
-
 	if (link_caps->max_limits.lane_count != old_max_limits.lane_count)
 		link_params_changed = true;
 
drivers/gpu/drm/i915/display/intel_dp_link_caps.h +1 -0
index 2afc47c6b7e68..110c1d1e604dd 100644
@@ -21,6 +21,7 @@ int intel_dp_link_caps_max_common_lane_count(struct intel_dp_link_caps *link_cap
 
 void intel_dp_link_caps_get_forced_params(struct intel_dp_link_caps *link_caps,
 					  struct intel_dp_link_config *forced_params);
+u32 intel_dp_link_caps_get_allowed_config_mask(struct intel_dp_link_caps *link_caps);
 
 int intel_dp_link_config_index(struct intel_dp_link_caps *link_caps,
 			       int link_rate, int lane_count);
Signature · 1 line
2.49.1
author
#85 lore raw

PATCH 62/108 drm/i915/dp_link_caps: Adjust max_limits when setting or resetting it

In reply to Imre Deak

Adjust max_limits when setting or resetting it, accounting for all other constraints that limit the allowed configurations, similar to how it is adjusted during a link configuration update. On detecting inconsistencies, all restrictions are removed, ensuring at least one allowed link configuration.

---
 .../gpu/drm/i915/display/intel_dp_link_caps.c | 20 +++++++++++++------
 1 file changed, 14 insertions(+), 6 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +14 -6
index 112d343c6d9d6..7c6259c95d388 100644
@@ -444,7 +444,9 @@ static bool max_link_limits_valid(struct intel_dp_link_caps *link_caps,
  * @max_link_limits: new maximum link limits
  *
  * Set the current maximum rate and lane count limits to @max_link_limits,
- * constraining the set of allowed configurations.
+ * after adjusting @max_link_limits to the currently allowed configuration
+ * set. Since the old @max_link_limits also constrains this allowed set, the
+ * new adjusted value of @max_link_limits will be at or below the old one.
  *
  * 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
@@ -456,8 +458,10 @@ static bool max_link_limits_valid(struct intel_dp_link_caps *link_caps,
  *
  * Return:
  * - %true  if the @link_caps cached max limits value got updated with
- *          @max_link_limits.
- * - %false if @max_link_limits is invalid.
+ *          @max_link_limits along with all the max link information.
+ * - %false if @max_link_limits is invalid, or if max link info update
+ *          fails due to an internal consistency issue. In the latter
+ *          case return after resetting all limits and restrictions.
  */
 bool intel_dp_link_caps_set_max_limits(struct intel_dp_link_caps *link_caps,
 				       const struct intel_dp_link_config *max_link_limits)
@@ -467,7 +471,7 @@ bool intel_dp_link_caps_set_max_limits(struct intel_dp_link_caps *link_caps,
 
 	set_max_link_limits_no_update(link_caps, max_link_limits);
 
-	return true;
+	return update_max_link_info(link_caps);
 }
 
 /**
@@ -475,11 +479,14 @@ bool intel_dp_link_caps_set_max_limits(struct intel_dp_link_caps *link_caps,
  * @link_caps: link capabilities state
  *
  * Reset the current maximum link limits to the maximum supported common link
- * rate and lane count.
+ * rate and lane count, then update the derived maximum-link information
+ * accordingly.
  */
 void intel_dp_link_caps_reset_max_limits(struct intel_dp_link_caps *link_caps)
 {
 	reset_max_link_limits_no_update(link_caps);
+	/* On failure the following removes all restrictions. */
+	update_max_link_info(link_caps);
 }
 
 static int intel_dp_link_config_bw(struct intel_dp_link_caps *link_caps,
@@ -675,8 +682,9 @@ 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 limits to account for forced params. */
 	reset_max_link_limits_no_update(link_caps);
+	/* On failure the following removes all restrictions. */
+	update_max_link_info(link_caps);
 }
 
 static int i915_dp_force_link_rate_show(struct seq_file *m, void *data)
Signature · 1 line
2.49.1
author
#86 lore raw

PATCH 63/108 drm/i915/dp: Simplify the modeset max link rate limit computation

In reply to Imre Deak

intel_dp_link_caps_get_max_limits() already accounts for forced parameters, so no separate adjustment is needed during modeset link configuration.

---
 drivers/gpu/drm/i915/display/intel_dp.c | 14 +-------------
 1 file changed, 1 insertion(+), 13 deletions(-)
drivers/gpu/drm/i915/display/intel_dp.c +1 -13
index 88154352e1faa..9be3b767fb54c 100644
@@ -356,16 +356,10 @@ 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;
+	lane_count = max_link_limits.lane_count;
 
 	switch (lane_count) {
 	case 1:
@@ -1550,12 +1544,6 @@ 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;
-
-	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);
 
Signature · 1 line
2.49.1
author
#87 lore raw

PATCH 64/108 drm/i915/dp: Query max limits via link_caps during mode validation

In reply to Imre Deak

Query the maximum link parameters during mode validation and MST link probing directly from intel_dp_link_caps_get_max_limits(), instead of using the intel_dp_max_link_rate() and intel_dp_max_lane_count() helpers, which internally also call the link_caps query.

This removes an unnecessary indirection, makes the max_limits query uniform across modeset, mode validation, TBT BW calculation and link state checking, and allows unexporting the intel_dp_max_link_rate()/intel_dp_max_lane_count() helpers.

---
 drivers/gpu/drm/i915/display/intel_dp.c     | 14 ++++++++++----
 drivers/gpu/drm/i915/display/intel_dp.h     |  2 --
 drivers/gpu/drm/i915/display/intel_dp_mst.c | 20 ++++++++++++++++----
 3 files changed, 26 insertions(+), 10 deletions(-)
drivers/gpu/drm/i915/display/intel_dp.c +10 -4
index 9be3b767fb54c..875e835848c39 100644
@@ -352,7 +352,7 @@ static int intel_dp_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;
@@ -1322,6 +1322,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_link_limits;
 	u16 dsc_max_compressed_bpp = 0;
 	enum drm_mode_status status;
 	bool dsc = false;
@@ -1334,8 +1335,13 @@ 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);
+	/*
+	 * TODO: Compute BW from the maximum-BW configuration; max limits are
+	 * independent bounds over all configs and may not form a valid config.
+	 */
+	intel_dp_link_caps_get_max_limits(intel_dp->link.caps, &max_link_limits);
+	max_link_clock = max_link_limits.rate;
+	max_lanes = max_link_limits.lane_count;
 
 	max_rate = intel_dp_max_link_data_rate(intel_dp, max_link_clock, max_lanes);
 
@@ -1539,7 +1545,7 @@ static void intel_dp_print_rates(struct intel_dp *intel_dp)
 	drm_dbg_kms(display->drm, "common rates: %s\n", seq_buf_str(&s));
 }
 
-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
index 6abce846b8e7e..6d6bb9e23ff26 100644
@@ -99,8 +99,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 +16 -4
index 832a43ebe00f7..4736bfeb25e06 100644
@@ -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"
@@ -1473,6 +1474,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_link_limits;
 	static bool supports_dsc;
 	int ret;
 	bool dsc = false;
@@ -1505,8 +1507,13 @@ 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);
+	/*
+	 * TODO: Compute BW from the maximum-BW configuration; max limits are
+	 * independent bounds over all configs and may not form a valid config.
+	 */
+	intel_dp_link_caps_get_max_limits(intel_dp->link.caps, &max_link_limits);
+	max_link_clock = max_link_limits.rate;
+	max_lanes = max_link_limits.lane_count;
 
 	max_rate = intel_dp_max_link_data_rate(intel_dp,
 					       max_link_clock, max_lanes);
@@ -2132,14 +2139,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_link_limits;
+	int link_rate;
+	int lane_count;
 	u8 rate_select;
 	u8 link_bw;
 
 	if (intel_dp->link.active)
 		return;
 
+	intel_dp_link_caps_get_max_limits(intel_dp->link.caps, &max_link_limits);
+	link_rate = max_link_limits.rate;
+	lane_count = max_link_limits.lane_count;
+
 	if (intel_mst_probed_link_params_valid(intel_dp, link_rate, lane_count))
 		return;
 
Signature · 1 line
2.49.1
author
#88 lore raw

PATCH 65/108 drm/i915/dp_tunnel: Query max link limits via link_caps for BW computation

In reply to Imre Deak

Query the maximum link limits via the link caps interface to compute the available TBT bandwidth. Unlike the max common link params used so far for this, the max link limits also accounts for any forced link parameters.

This makes the max_limits query uniform across modeset, mode validation, link state checking, and TBT bandwidth computation. It also allows intel_dp_link_caps_max_common_lane_count() to be unexported.

---
 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    | 12 +++++++++---
 3 files changed, 10 insertions(+), 5 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +1 -1
index 7c6259c95d388..e8d1fd86b327f 100644
@@ -171,7 +171,7 @@ void intel_dp_link_caps_all_common_rates(struct intel_dp_link_caps *link_caps,
 	*num_rates = link_caps->num_rates;
 }
 
-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
index 110c1d1e604dd..7fe0e4a028f26 100644
@@ -17,7 +17,6 @@ int intel_dp_link_caps_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_all_common_rates(struct intel_dp_link_caps *link_caps,
 					 const int **rates, int *num_rates);
-int intel_dp_link_caps_max_common_lane_count(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);
drivers/gpu/drm/i915/display/intel_dp_tunnel.c +9 -3
index 52f5c88f7e09c..07817f5251c81 100644
@@ -58,10 +58,16 @@ 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_link_caps_max_common_rate(link_caps);
-	int lane_count = intel_dp_link_caps_max_common_lane_count(link_caps);
+	struct intel_dp_link_config max_link_limits;
 
-	return intel_dp_max_link_data_rate(intel_dp, rate, lane_count);
+	/*
+	 * TODO: Compute BW from the maximum-BW configuration; max limits are
+	 * independent bounds over all configs and may not form a valid config.
+	 */
+	intel_dp_link_caps_get_max_limits(link_caps, &max_link_limits);
+
+	return intel_dp_max_link_data_rate(intel_dp, max_link_limits.rate,
+						     max_link_limits.lane_count);
 }
 
 static int __update_tunnel_state(struct intel_dp *intel_dp, bool force_sink_update)
Signature · 1 line
2.49.1
author
#89 lore raw

PATCH 66/108 drm/i915/doc: Document DP link capabilities

In reply to Imre Deak

Add documentation for the DP link capabilities interface.

---
 Documentation/gpu/i915.rst                    | 12 ++++
 .../gpu/drm/i915/display/intel_dp_link_caps.c | 60 +++++++++++++++++++
 2 files changed, 72 insertions(+)
Documentation/gpu/i915.rst +12 -0
index 34556b2104aa5..38680f277328d 100644
@@ -150,6 +150,18 @@ DisplayPort Link Training
 .. kernel-doc:: drivers/gpu/drm/i915/display/intel_dp_link_training.c
    :internal:
 
+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:
+
+.. kernel-doc:: drivers/gpu/drm/i915/display/intel_dp_link_caps.c
+   :internal:
+
 High Definition Audio
 ---------------------
 
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +60 -0

66 lines not on this page · raw message

Signature · 1 line
2.49.1
author
#90 lore raw

PATCH 67/108 drm/i915/dp_link_caps: Move config table members to a substruct

In reply to Imre Deak

Group the rate/lane configuration members (rates array, max lane count, and config entries) into a substruct within intel_dp_link_caps. This provides a clearer view of the related information and prepares for a follow-up change that will precompute the table before committing it to link_caps.

---
 .../gpu/drm/i915/display/intel_dp_link_caps.c | 112 ++++++++++--------
 1 file changed, 63 insertions(+), 49 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +63 -49
index 01eba9fb0b887..81c36e3326bb9 100644
@@ -81,24 +81,26 @@
 struct intel_dp_link_caps {
 	struct intel_dp *dp;
 
-	/* Rate, lane count caps common to source and sink. */
-	int num_rates;
-	int rates[DP_MAX_SUPPORTED_RATES];
-	int max_lane_count;
+	struct intel_dp_link_caps_config_table {
+		/* Rate, lane count caps common to source and sink. */
+		int num_rates;
+		int rates[DP_MAX_SUPPORTED_RATES];
+		int max_lane_count;
 
-	/* common rate,lane_count configs in bw order */
-	int num_configs;
+		/* common rate,lane_count configs in bw order */
+		int num_configs;
 #define INTEL_DP_MAX_LANE_COUNT			4
 #define INTEL_DP_MAX_SUPPORTED_LANE_CONFIGS	(ilog2(INTEL_DP_MAX_LANE_COUNT) + 1)
 #define INTEL_DP_LANE_COUNT_EXP_BITS		order_base_2(INTEL_DP_MAX_SUPPORTED_LANE_CONFIGS)
 #define INTEL_DP_LINK_RATE_IDX_BITS		(BITS_PER_TYPE(u8) - INTEL_DP_LANE_COUNT_EXP_BITS)
 #define INTEL_DP_MAX_LINK_CONFIGS		(DP_MAX_SUPPORTED_RATES * \
 						 INTEL_DP_MAX_SUPPORTED_LANE_CONFIGS)
-	struct intel_dp_link_config_entry {
-		/* index into rates[] */
-		u8 link_rate_idx:INTEL_DP_LINK_RATE_IDX_BITS;
-		u8 lane_count_exp:INTEL_DP_LANE_COUNT_EXP_BITS;
-	} configs[INTEL_DP_MAX_LINK_CONFIGS];
+		struct intel_dp_link_config_entry {
+			/* index into rates[] */
+			u8 link_rate_idx:INTEL_DP_LINK_RATE_IDX_BITS;
+			u8 lane_count_exp:INTEL_DP_LANE_COUNT_EXP_BITS;
+		} configs[INTEL_DP_MAX_LINK_CONFIGS];
+	} config_table;
 
 	/*
 	 * Forced parameters requested via debugfs. Remains set across sink
@@ -141,8 +143,9 @@ struct intel_dp_link_caps {
 static int intel_dp_link_caps_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);
+	const struct intel_dp_link_caps_config_table *table = &link_caps->config_table;
+
+	return intel_dp_rate_limit_len(table->rates, table->num_rates, max_rate);
 }
 
 /**
@@ -163,10 +166,10 @@ int intel_dp_link_caps_common_rate(struct intel_dp_link_caps *link_caps, int ind
 	struct intel_display *display = to_intel_display(intel_dp);
 
 	if (drm_WARN_ON(display->drm,
-			index < 0 || index >= link_caps->num_rates))
+			index < 0 || index >= link_caps->config_table.num_rates))
 		return 162000;
 
-	return link_caps->rates[index];
+	return link_caps->config_table.rates[index];
 }
 
 /**
@@ -187,9 +190,9 @@ int intel_dp_link_caps_common_rate(struct intel_dp_link_caps *link_caps, int ind
  */
 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);
+	const struct intel_dp_link_caps_config_table *table = &link_caps->config_table;
+
+	return intel_dp_rate_index(table->rates, table->num_rates, rate);
 }
 
 /**
@@ -202,12 +205,14 @@ int intel_dp_link_caps_common_rate_idx(struct intel_dp_link_caps *link_caps, int
  */
 int intel_dp_link_caps_max_common_rate(struct intel_dp_link_caps *link_caps)
 {
-	return intel_dp_link_caps_common_rate(link_caps, link_caps->num_rates - 1);
+	const struct intel_dp_link_caps_config_table *table = &link_caps->config_table;
+
+	return intel_dp_link_caps_common_rate(link_caps, table->num_rates - 1);
 }
 
 int intel_dp_link_caps_num_common_rates(struct intel_dp_link_caps *link_caps)
 {
-	return link_caps->num_rates;
+	return link_caps->config_table.num_rates;
 }
 
 /**
@@ -227,13 +232,15 @@ int intel_dp_link_caps_num_common_rates(struct intel_dp_link_caps *link_caps)
 void intel_dp_link_caps_all_common_rates(struct intel_dp_link_caps *link_caps,
 					 const int **rates, int *num_rates)
 {
-	*rates = link_caps->rates;
-	*num_rates = link_caps->num_rates;
+	const struct intel_dp_link_caps_config_table *table = &link_caps->config_table;
+
+	*rates = table->rates;
+	*num_rates = table->num_rates;
 }
 
 static int intel_dp_link_caps_max_common_lane_count(struct intel_dp_link_caps *link_caps)
 {
-	return link_caps->max_lane_count;
+	return link_caps->config_table.max_lane_count;
 }
 
 static int forced_lane_count(struct intel_dp_link_caps *link_caps)
@@ -291,12 +298,13 @@ static u32 calc_allowed_config_mask(struct intel_dp_link_caps *link_caps,
 				    const struct intel_dp_link_config *max_limits,
 				    const struct intel_dp_link_config *forced_params)
 {
+	struct intel_dp_link_caps_config_table *table = &link_caps->config_table;
 	struct intel_dp_link_config config;
 	u32 allowed_mask = 0;
 	int config_idx;
 
-	for (config_idx = 0; config_idx < link_caps->num_configs; config_idx++) {
-		const struct intel_dp_link_config_entry *lc = &link_caps->configs[config_idx];
+	for (config_idx = 0; config_idx < table->num_configs; config_idx++) {
+		const struct intel_dp_link_config_entry *lc = &table->configs[config_idx];
 
 		if (BIT(config_idx) & disabled_config_mask)
 			continue;
@@ -382,13 +390,14 @@ static void reset_all_restrictions_no_update(struct intel_dp_link_caps *link_cap
 static void compute_max_link_limits(struct intel_dp_link_caps *link_caps,
 				    struct intel_dp_link_config *max_link_limits)
 {
+	struct intel_dp_link_caps_config_table *table = &link_caps->config_table;
 	u32 allowed_mask = intel_dp_link_caps_get_allowed_config_mask(link_caps);
 	struct intel_dp_link_config max_config = {};
 	struct intel_dp_link_config link_config;
 	int config_idx;
 
-	for (config_idx = 0; config_idx < link_caps->num_configs; config_idx++) {
-		const struct intel_dp_link_config_entry *lc = &link_caps->configs[config_idx];
+	for (config_idx = 0; config_idx < table->num_configs; config_idx++) {
+		const struct intel_dp_link_config_entry *lc = &table->configs[config_idx];
 
 		if (!(BIT(config_idx) & allowed_mask))
 			continue;
@@ -573,13 +582,13 @@ static int link_config_cmp_by_bw(const void *a, const void *b, const void *p)
 	       intel_dp_link_config_rate(link_caps, lc_b);
 }
 
-static bool current_common_caps_match(struct intel_dp_link_caps *link_caps,
+static bool current_common_caps_match(struct intel_dp_link_caps_config_table *table,
 				      const int *rates, int num_rates,
 				      int old_max_lane_count)
 {
-	int current_max_lane_count = link_caps->max_lane_count;
-	const int *current_rates = link_caps->rates;
-	int num_current_rates = link_caps->num_rates;
+	int current_max_lane_count = table->max_lane_count;
+	const int *current_rates = table->rates;
+	int num_current_rates = table->num_rates;
 
 	if (num_current_rates != num_rates)
 		return false;
@@ -626,6 +635,8 @@ bool intel_dp_link_caps_update(struct intel_dp_link_caps *link_caps,
 {
 	struct intel_dp *intel_dp = link_caps->dp;
 	struct intel_display *display = to_intel_display(intel_dp);
+	struct intel_dp_link_caps_config_table *table =
+		&link_caps->config_table;
 	struct intel_dp_link_config old_max_limits =
 		link_caps->max_limits;
 	int old_rates[DP_MAX_SUPPORTED_RATES];
@@ -640,26 +651,26 @@ bool intel_dp_link_caps_update(struct intel_dp_link_caps *link_caps,
 	if (drm_WARN_ON(display->drm, !is_power_of_2(max_lane_count)))
 		return false;
 
-	if (drm_WARN_ON(display->drm, num_rates > ARRAY_SIZE(link_caps->rates)))
+	if (drm_WARN_ON(display->drm, num_rates > ARRAY_SIZE(table->rates)))
 		return false;
 
 	num_common_lane_configs = ilog2(max_lane_count) + 1;
 
 	if (drm_WARN_ON(display->drm, num_rates * num_common_lane_configs >
-				    ARRAY_SIZE(link_caps->configs)))
+				    ARRAY_SIZE(table->configs)))
 		return false;
 
-	num_old_rates = link_caps->num_rates;
-	memcpy(old_rates, link_caps->rates, num_old_rates * sizeof(old_rates[0]));
-	old_max_lane_count = link_caps->max_lane_count;
+	num_old_rates = table->num_rates;
+	memcpy(old_rates, table->rates, num_old_rates * sizeof(old_rates[0]));
+	old_max_lane_count = table->max_lane_count;
 
-	memcpy(link_caps->rates, rates, num_rates * sizeof(rates[0]));
-	link_caps->num_rates = num_rates;
-	link_caps->max_lane_count = max_lane_count;
+	memcpy(table->rates, rates, num_rates * sizeof(rates[0]));
+	table->num_rates = num_rates;
+	table->max_lane_count = max_lane_count;
 
-	link_caps->num_configs = num_rates * num_common_lane_configs;
+	table->num_configs = num_rates * num_common_lane_configs;
 
-	lc = &link_caps->configs[0];
+	lc = &table->configs[0];
 	for (i = 0; i < num_rates; i++) {
 		for (j = 0; j < num_common_lane_configs; j++) {
 			lc->lane_count_exp = j;
@@ -669,12 +680,12 @@ bool intel_dp_link_caps_update(struct intel_dp_link_caps *link_caps,
 		}
 	}
 
-	sort_r(link_caps->configs, link_caps->num_configs,
-	       sizeof(link_caps->configs[0]),
+	sort_r(table->configs, table->num_configs,
+	       sizeof(table->configs[0]),
 	       link_config_cmp_by_bw, NULL,
 	       intel_dp);
 
-	if (!current_common_caps_match(link_caps, old_rates, num_old_rates,
+	if (!current_common_caps_match(table, old_rates, num_old_rates,
 				       old_max_lane_count))
 		link_params_changed = true;
 
@@ -698,12 +709,14 @@ 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_caps_config_table *table =
+		&link_caps->config_table;
 	const struct intel_dp_link_config_entry *lc;
 
-	if (drm_WARN_ON(display->drm, idx < 0 || idx >= link_caps->num_configs))
+	if (drm_WARN_ON(display->drm, idx < 0 || idx >= table->num_configs))
 		idx = 0;
 
-	lc = &link_caps->configs[idx];
+	lc = &table->configs[idx];
 
 	*link_rate = intel_dp_link_config_rate(link_caps, lc);
 	*lane_count = intel_dp_link_config_lane_count(lc);
@@ -712,13 +725,14 @@ void intel_dp_link_config_get(struct intel_dp_link_caps *link_caps,
 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,
+	const struct intel_dp_link_caps_config_table *table = &link_caps->config_table;
+	int link_rate_idx = intel_dp_rate_index(table->rates, table->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 *lc = &link_caps->configs[i];
+	for (i = 0; i < table->num_configs; i++) {
+		const struct intel_dp_link_config_entry *lc = &table->configs[i];
 
 		if (lc->lane_count_exp == lane_count_exp &&
 		    lc->link_rate_idx == link_rate_idx)
Signature · 1 line
2.49.1
author
#91 lore raw

PATCH 68/108 drm/i915/dp_link_caps: Factor out a helper to look up a config table rate

In reply to Imre Deak

Factor out a helper looking up a supported link rate from a config table, used by a follow-up change.

---
 .../gpu/drm/i915/display/intel_dp_link_caps.c   | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +9 -8
index 81c36e3326bb9..d5456c24714f4 100644
@@ -139,6 +139,14 @@ struct intel_dp_link_caps {
 	struct intel_dp_link_config max_limits;
 };
 
+static int lookup_rate(const struct intel_dp_link_caps_config_table *table, int index)
+{
+	if (WARN_ON(index < 0 || index >= table->num_rates))
+		return 162000;
+
+	return table->rates[index];
+}
+
 /* Get length of common rates array potentially limited by max_rate. */
 static int intel_dp_link_caps_common_len_rate_limit(struct intel_dp_link_caps *link_caps,
 						    int max_rate)
@@ -162,14 +170,7 @@ static int intel_dp_link_caps_common_len_rate_limit(struct intel_dp_link_caps *l
  */
 int intel_dp_link_caps_common_rate(struct intel_dp_link_caps *link_caps, int index)
 {
-	struct intel_dp *intel_dp = link_caps->dp;
-	struct intel_display *display = to_intel_display(intel_dp);
-
-	if (drm_WARN_ON(display->drm,
-			index < 0 || index >= link_caps->config_table.num_rates))
-		return 162000;
-
-	return link_caps->config_table.rates[index];
+	return lookup_rate(&link_caps->config_table, index);
 }
 
 /**
Signature · 1 line
2.49.1
author
#92 lore raw

PATCH 69/108 drm/i915/dp_link_caps: Pass config table pointer to rate lookup helper

In reply to Imre Deak

Convert intel_dp_link_config_rate() to accept a pointer to the config_table, instead of the full link_caps struct. This prepares for a follow-up change that will precompute the table before committing it to link_caps.

---
 drivers/gpu/drm/i915/display/intel_dp_link_caps.c | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +7 -7
index d5456c24714f4..bd0a7a44279a3 100644
@@ -274,10 +274,10 @@ void intel_dp_link_caps_get_forced_params(struct intel_dp_link_caps *link_caps,
 	forced_params->lane_count = forced_lane_count(link_caps);
 }
 
-static int intel_dp_link_config_rate(struct intel_dp_link_caps *link_caps,
+static int intel_dp_link_config_rate(const struct intel_dp_link_caps_config_table *table,
 				     const struct intel_dp_link_config_entry *lc)
 {
-	return intel_dp_link_caps_common_rate(link_caps, lc->link_rate_idx);
+	return lookup_rate(table, lc->link_rate_idx);
 }
 
 static int intel_dp_link_config_lane_count(const struct intel_dp_link_config_entry *lc)
@@ -290,7 +290,7 @@ to_intel_dp_link_config(struct intel_dp_link_caps *link_caps,
 			const struct intel_dp_link_config_entry *lc,
 			struct intel_dp_link_config *config)
 {
-	config->rate = intel_dp_link_config_rate(link_caps, lc);
+	config->rate = intel_dp_link_config_rate(&link_caps->config_table, lc);
 	config->lane_count = intel_dp_link_config_lane_count(lc);
 }
 
@@ -562,7 +562,7 @@ void intel_dp_link_caps_reset_max_limits(struct intel_dp_link_caps *link_caps)
 static int intel_dp_link_config_bw(struct intel_dp_link_caps *link_caps,
 				   const struct intel_dp_link_config_entry *lc)
 {
-	return drm_dp_max_dprx_data_rate(intel_dp_link_config_rate(link_caps, lc),
+	return drm_dp_max_dprx_data_rate(intel_dp_link_config_rate(&link_caps->config_table, lc),
 					 intel_dp_link_config_lane_count(lc));
 }
 
@@ -579,8 +579,8 @@ static int link_config_cmp_by_bw(const void *a, const void *b, const void *p)
 	if (bw_a != bw_b)
 		return bw_a - bw_b;
 
-	return intel_dp_link_config_rate(link_caps, lc_a) -
-	       intel_dp_link_config_rate(link_caps, lc_b);
+	return intel_dp_link_config_rate(&link_caps->config_table, lc_a) -
+	       intel_dp_link_config_rate(&link_caps->config_table, lc_b);
 }
 
 static bool current_common_caps_match(struct intel_dp_link_caps_config_table *table,
@@ -719,7 +719,7 @@ void intel_dp_link_config_get(struct intel_dp_link_caps *link_caps,
 
 	lc = &table->configs[idx];
 
-	*link_rate = intel_dp_link_config_rate(link_caps, lc);
+	*link_rate = intel_dp_link_config_rate(&link_caps->config_table, lc);
 	*lane_count = intel_dp_link_config_lane_count(lc);
 }
 
Signature · 1 line
2.49.1
author
#93 lore raw

PATCH 70/108 drm/i915/dp_link_caps: Factor out helper to get link config from table by index

In reply to Imre Deak

Factor out a helper that looks up a link configuration by index. This provides the rate and lane count directly, avoiding the indirect conversion via the packed config entry.

---
 .../gpu/drm/i915/display/intel_dp_link_caps.c | 43 ++++++++++++-------
 1 file changed, 27 insertions(+), 16 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +27 -16
index bd0a7a44279a3..f17e30e84901b 100644
@@ -285,13 +285,28 @@ static int intel_dp_link_config_lane_count(const struct intel_dp_link_config_ent
 	return 1 << lc->lane_count_exp;
 }
 
-static void
-to_intel_dp_link_config(struct intel_dp_link_caps *link_caps,
-			const struct intel_dp_link_config_entry *lc,
-			struct intel_dp_link_config *config)
+static int link_config_idx_to_rate(const struct intel_dp_link_caps_config_table *table,
+				   int config_idx)
 {
-	config->rate = intel_dp_link_config_rate(&link_caps->config_table, lc);
-	config->lane_count = intel_dp_link_config_lane_count(lc);
+	const struct intel_dp_link_config_entry *lc = &table->configs[config_idx];
+
+	return intel_dp_link_config_rate(table, lc);
+}
+
+static int link_config_idx_to_lane_count(const struct intel_dp_link_caps_config_table *table,
+					 int config_idx)
+{
+	const struct intel_dp_link_config_entry *lc = &table->configs[config_idx];
+
+	return intel_dp_link_config_lane_count(lc);
+}
+
+static void
+to_intel_dp_link_config(const struct intel_dp_link_caps_config_table *table,
+			int config_idx, struct intel_dp_link_config *config)
+{
+	config->rate = link_config_idx_to_rate(table, config_idx);
+	config->lane_count = link_config_idx_to_lane_count(table, config_idx);
 }
 
 static u32 calc_allowed_config_mask(struct intel_dp_link_caps *link_caps,
@@ -305,12 +320,10 @@ static u32 calc_allowed_config_mask(struct intel_dp_link_caps *link_caps,
 	int config_idx;
 
 	for (config_idx = 0; config_idx < table->num_configs; config_idx++) {
-		const struct intel_dp_link_config_entry *lc = &table->configs[config_idx];
-
 		if (BIT(config_idx) & disabled_config_mask)
 			continue;
 
-		to_intel_dp_link_config(link_caps, lc, &config);
+		to_intel_dp_link_config(table, config_idx, &config);
 
 		if (forced_params->rate &&
 		    forced_params->rate != config.rate)
@@ -398,12 +411,10 @@ static void compute_max_link_limits(struct intel_dp_link_caps *link_caps,
 	int config_idx;
 
 	for (config_idx = 0; config_idx < table->num_configs; config_idx++) {
-		const struct intel_dp_link_config_entry *lc = &table->configs[config_idx];
-
 		if (!(BIT(config_idx) & allowed_mask))
 			continue;
 
-		to_intel_dp_link_config(link_caps, lc, &link_config);
+		to_intel_dp_link_config(table, config_idx, &link_config);
 
 		max_config.rate = max(max_config.rate,
 				      link_config.rate);
@@ -712,15 +723,15 @@ void intel_dp_link_config_get(struct intel_dp_link_caps *link_caps,
 	struct intel_display *display = to_intel_display(link_caps->dp);
 	const struct intel_dp_link_caps_config_table *table =
 		&link_caps->config_table;
-	const struct intel_dp_link_config_entry *lc;
+	struct intel_dp_link_config config;
 
 	if (drm_WARN_ON(display->drm, idx < 0 || idx >= table->num_configs))
 		idx = 0;
 
-	lc = &table->configs[idx];
+	to_intel_dp_link_config(table, idx, &config);
 
-	*link_rate = intel_dp_link_config_rate(&link_caps->config_table, lc);
-	*lane_count = intel_dp_link_config_lane_count(lc);
+	*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
author
#94 lore raw

PATCH 71/108 drm/i915/dp_link_caps: Add helper to get config at iterator position

In reply to Imre Deak

Add a helper to look up a link configuration for a given iteration order at a given position, returning the canonical index and rate/lane info. This prepares for iterating over any set of configurations in a specified order.

This is needed by a follow-up replacing the configuration index based look up in the fallback code (intel_dp_link_config_get()) with the helper added here.

---
 .../gpu/drm/i915/display/intel_dp_link_caps.c | 73 +++++++++++++++++++
 .../gpu/drm/i915/display/intel_dp_link_caps.h | 63 ++++++++++++++++
 2 files changed, 136 insertions(+)
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +73 -0
index f17e30e84901b..48b57aea557ca 100644
@@ -15,6 +15,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"
 
@@ -309,6 +310,46 @@ to_intel_dp_link_config(const struct intel_dp_link_caps_config_table *table,
 	config->lane_count = link_config_idx_to_lane_count(table, config_idx);
 }
 
+static bool
+get_table_config_by_pos(const struct intel_dp_link_caps_config_table *config_table,
+			struct intel_dp_link_caps_config_order config_order,
+			int iter_pos,
+			struct intel_dp_link_config *config, int *config_idx)
+{
+	if (!in_range(iter_pos, 0, config_table->num_configs))
+		goto out_fail;
+
+	switch (config_order.dir) {
+	case INTEL_DP_LINK_CAPS_CONFIG_ORDER_DIR_ASC:
+		break;
+	default:
+		MISSING_CASE(config_order.dir);
+
+		goto out_fail;
+	}
+
+	switch (config_order.key) {
+	case INTEL_DP_LINK_CAPS_CONFIG_ORDER_KEY_BW:
+		*config_idx = iter_pos;
+
+		break;
+	default:
+		MISSING_CASE(config_order.key);
+
+		goto out_fail;
+	}
+
+	to_intel_dp_link_config(config_table, *config_idx, config);
+
+	return true;
+
+out_fail:
+	*config = INTEL_DP_LINK_CONFIG_NULL;
+	*config_idx = -1;
+
+	return false;
+}
+
 static u32 calc_allowed_config_mask(struct intel_dp_link_caps *link_caps,
 				    u32 disabled_config_mask,
 				    const struct intel_dp_link_config *max_limits,
@@ -370,6 +411,38 @@ u32 intel_dp_link_caps_get_allowed_config_mask(struct intel_dp_link_caps *link_c
 					&link_caps->max_limits, &forced_params);
 }
 
+/**
+ * intel_dp_link_caps_get_config_by_pos - get config at a given iterator position
+ * @link_caps: link capability state
+ * @config_order: iteration order
+ * @iter_pos: position in the @config_order iteration order
+ * @config: returned link configuration
+ * @config_idx: returned config index
+ *
+ * Look up the link config at iterator position @iter_pos in the order
+ * described by @config_order.
+ *
+ * Note that any mapping between @iter_pos and @config_idx is an
+ * implementation detail defined by @config_order and must not be
+ * relied upon. The returned @config_idx always, regardless of
+ * @config_order, uses the canonical configuration index/mask scheme
+ * shared by the link-caps API.
+ *
+ * Return:
+ * - %true  if @iter_pos is valid, storing the configuration in @config and
+ *          its index in @config_idx.
+ * - %false if @iter_pos is out of range, storing %INTEL_DP_LINK_CONFIG_NULL
+ *          in @config and -1 in @config_idx.
+ */
+bool intel_dp_link_caps_get_config_by_pos(struct intel_dp_link_caps *link_caps,
+					  struct intel_dp_link_caps_config_order config_order,
+					  int iter_pos,
+					  struct intel_dp_link_config *config, int *config_idx)
+{
+	return get_table_config_by_pos(&link_caps->config_table, config_order, iter_pos,
+				       config, config_idx);
+}
+
 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 +63 -0

75 lines not on this page · raw message

Signature · 1 line
2.49.1
author
#95 lore raw

PATCH 72/108 drm/i915/dp_link_caps: Add helper to find position of matching config

In reply to Imre Deak

Add a helper to find the iteration position of a given link configuration within a specified iteration order over the currently allowed configurations. The rate being looked up may differ from the nominal rate tracked for allowed configurations due to platform-specific PLL divider restrictions. Fuzzy matching allows selecting the closest supported rate.

This is needed by a follow-up change replacing the exact-rate look up in the fallback code (intel_dp_link_config_index()) with the helper added here.

---
 .../gpu/drm/i915/display/intel_dp_link_caps.c | 88 +++++++++++++++++++
 .../gpu/drm/i915/display/intel_dp_link_caps.h | 24 +++++
 2 files changed, 112 insertions(+)
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +88 -0
index 48b57aea557ca..284d28f9d98d7 100644
@@ -6,6 +6,7 @@
 #include <linux/bitops.h>
 #include <linux/debugfs.h>
 #include <linux/log2.h>
+#include <linux/math.h>
 #include <linux/slab.h>
 #include <linux/sort.h>
 #include <linux/string.h>
@@ -443,6 +444,93 @@ bool intel_dp_link_caps_get_config_by_pos(struct intel_dp_link_caps *link_caps,
 				       config, config_idx);
 }
 
+static bool is_within_percent(int actual, int nominal, int percent)
+{
+	int diff = abs(actual - nominal);
+
+	if (WARN_ON(percent == 0 ||
+		    diff > INT_MAX / 100 || nominal > INT_MAX / percent))
+		return false;
+
+	return diff * 100 <= nominal * percent;
+}
+
+static int
+find_config_table_entry_pos(const struct intel_dp_link_caps_config_table *config_table,
+			    struct intel_dp_link_caps_config_order config_order, u32 config_mask,
+			    enum intel_dp_link_caps_config_match_type match_type,
+			    const struct intel_dp_link_config *link_config)
+{
+	struct intel_dp_link_config iter_config;
+	int iter_config_idx;
+	int iter_pos;
+
+	for (iter_pos = 0;
+	     get_table_config_by_pos(config_table, config_order, iter_pos,
+				     &iter_config, &iter_config_idx);
+	     iter_pos++) {
+		if (!(BIT(iter_config_idx) & config_mask))
+			continue;
+
+		if (iter_config.lane_count != link_config->lane_count)
+			continue;
+
+		/*
+		 * link_config->rate may be platform-derived rather than the nominal
+		 * supported link rate.
+		 *
+		 * When the caller requests fuzzy rate matching, accept a nominal rate
+		 * within 1 percent of the requested rate.
+		 *
+		 * The DP spec seems to allow at most 300 ppm of symbol clock tolerance,
+		 * excluding SSC. However, at least on g4x, the 2.7 Gbps rate exceeds
+		 * that (~5000ppm); see intel_dp_compute_rate(). So allow 10000 ppm, or
+		 * a 1 percent difference.
+		 *
+		 * The first match is also the best one, since nominal rates are guaranteed
+		 * to be spaced much farther apart than 1 percent.
+		 *
+		 * TODO: Track the nominal link rate separately, pass it here, and require
+		 * an exact match.
+		 */
+		if (iter_config.rate != link_config->rate &&
+		    (match_type == INTEL_DP_LINK_CAPS_CONFIG_MATCH_EXACT ||
+		     !is_within_percent(link_config->rate, iter_config.rate, 1)))
+			continue;
+
+		return iter_pos;
+	}
+
+	return -1;
+}
+
+/**
+ * intel_dp_link_caps_find_allowed_config_pos - find matching allowed config position
+ * @link_caps: link capabilities state
+ * @config_order: iteration order
+ * @match_type: requested match type
+ * @link_config: link configuration to match
+ *
+ * Search the currently allowed link configurations for a match to
+ * @link_config.
+ *
+ * Return:
+ * - The position of the first matching allowed configuration in the
+ *   @config_order iteration.
+ * - %-1 if no allowed configuration matches.
+ */
+int intel_dp_link_caps_find_allowed_config_pos(struct intel_dp_link_caps *link_caps,
+					       struct intel_dp_link_caps_config_order config_order,
+					       enum intel_dp_link_caps_config_match_type match_type,
+					       const struct intel_dp_link_config *link_config)
+{
+	u32 allowed_config_mask = intel_dp_link_caps_get_allowed_config_mask(link_caps);
+
+	return find_config_table_entry_pos(&link_caps->config_table, config_order,
+					   allowed_config_mask, match_type,
+					   link_config);
+}
+
 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 +24 -0
index 79cd50db90ba6..cacdda15a36af 100644
@@ -69,6 +69,26 @@ struct intel_dp_link_caps_config_order {
 	enum intel_dp_link_caps_config_order_direction dir;
 };
 
+/**
+ * enum intel_dp_link_caps_config_match_type - configuration match semantics
+ * @INTEL_DP_LINK_CAPS_CONFIG_MATCH_EXACT:
+ *   Require an exact nominal link rate match and an
+ *   exact lane count match.
+ * @INTEL_DP_LINK_CAPS_CONFIG_MATCH_FUZZY_RATE:
+ *   Require an exact lane count match, but allow the
+ *   requested link rate to match approximately to a
+ *   supported nominal link rate.
+ *
+ * Selects how
+ * intel_dp_link_caps_find_allowed_config_pos() matches
+ * the requested &struct intel_dp_link_config against the currently
+ * allowed configurations.
+ */
+enum intel_dp_link_caps_config_match_type {
+	INTEL_DP_LINK_CAPS_CONFIG_MATCH_EXACT,
+	INTEL_DP_LINK_CAPS_CONFIG_MATCH_FUZZY_RATE,
+};
+
 int intel_dp_link_caps_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_link_caps_max_common_rate(struct intel_dp_link_caps *link_caps);
@@ -89,6 +109,10 @@ intel_dp_link_caps_get_config_by_pos(struct intel_dp_link_caps *link_caps,
 				     struct intel_dp_link_config *config, int *config_idx);
 void intel_dp_link_config_get(struct intel_dp_link_caps *link_caps,
 			      int idx, int *link_rate, int *lane_count);
+int intel_dp_link_caps_find_allowed_config_pos(struct intel_dp_link_caps *link_caps,
+					       struct intel_dp_link_caps_config_order order,
+					       enum intel_dp_link_caps_config_match_type match_type,
+					       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);
Signature · 1 line
2.49.1
author
#96 lore raw

PATCH 73/108 drm/i915/dp_link_training: Reset the max link limits in the fallback code

In reply to Imre Deak

The 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 | 41 ++++++++++++++++---
 1 file changed, 36 insertions(+), 5 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_training.c +36 -5
index b7645bcbe0c2b..69396dbb94b2e 100644
@@ -1874,10 +1874,12 @@ static bool reduce_link_params(struct intel_dp *intel_dp, const struct intel_crt
 static 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,
@@ -1886,14 +1888,34 @@ 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: Make max_limit just reflect the maximum of the allowed configs
+	 * at all times. Then fallback will stop narrowing the allowed set this
+	 * way, the limit will never need to increase, and this reset can be
+	 * removed.
+	 */
+	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,
@@ -1904,10 +1926,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
author
#97 lore raw

PATCH 74/108 drm/i915/dp_link_training: Use config iterator for BW-order fallback

In reply to Imre Deak

Switch the BW-order fallback loop to look up an allowed configuration by its iteration position rather than by its configuration index. Currently the index and iteration position match for BW-order used by the fallback, but future changes will make iteration positions key- and direction-specific. For now, use the BW / ascending iteration order so iteration positions match the config index as expected by the current code.

---
 .../gpu/drm/i915/display/intel_dp_link_caps.c | 17 -----------
 .../gpu/drm/i915/display/intel_dp_link_caps.h |  2 --
 .../drm/i915/display/intel_dp_link_training.c | 29 ++++++++++++++++++-
 3 files changed, 28 insertions(+), 20 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +0 -17
index 284d28f9d98d7..103490eec3d23 100644
@@ -878,23 +878,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);
-	const struct intel_dp_link_caps_config_table *table =
-		&link_caps->config_table;
-	struct intel_dp_link_config config;
-
-	if (drm_WARN_ON(display->drm, idx < 0 || idx >= table->num_configs))
-		idx = 0;
-
-	to_intel_dp_link_config(table, 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)
 {
drivers/gpu/drm/i915/display/intel_dp_link_caps.h +0 -2
index cacdda15a36af..b380beedd8990 100644
@@ -107,8 +107,6 @@ intel_dp_link_caps_get_config_by_pos(struct intel_dp_link_caps *link_caps,
 				     struct intel_dp_link_caps_config_order config_order,
 				     int iter_pos,
 				     struct intel_dp_link_config *config, int *config_idx);
-void intel_dp_link_config_get(struct intel_dp_link_caps *link_caps,
-			      int idx, int *link_rate, int *lane_count);
 int intel_dp_link_caps_find_allowed_config_pos(struct intel_dp_link_caps *link_caps,
 					       struct intel_dp_link_caps_config_order order,
 					       enum intel_dp_link_caps_config_match_type match_type,
drivers/gpu/drm/i915/display/intel_dp_link_training.c +28 -1
index 69396dbb94b2e..9dd302bb4968b 100644
@@ -1760,10 +1760,20 @@ 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_display *display = to_intel_display(intel_dp);
 	struct intel_dp_link_caps *link_caps = intel_dp->link.caps;
+	struct intel_dp_link_caps_config_order bw_asc_order = {
+		.key = INTEL_DP_LINK_CAPS_CONFIG_ORDER_KEY_BW,
+		.dir = INTEL_DP_LINK_CAPS_CONFIG_ORDER_DIR_ASC,
+	};
+	struct intel_dp_link_config link_config = {
+		.rate = crtc_state->port_clock,
+		.lane_count = crtc_state->lane_count,
+	};
 	struct intel_dp_link_config forced_params;
 	int forced_lane_count;
 	int forced_rate;
+	int link_config_idx;
 	int link_rate;
 	int lane_count;
 	int i;
@@ -1775,7 +1785,24 @@ static bool reduce_link_params_in_bw_order(struct intel_dp *intel_dp,
 	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);
+		bool config_found;
+
+		config_found = intel_dp_link_caps_get_config_by_pos(link_caps,
+								    bw_asc_order, i,
+								    &link_config,
+								    &link_config_idx);
+		if (drm_WARN_ON(display->drm, !config_found))
+			return false;
+
+		/*
+		 * Atm, the index of the configuration must match its
+		 * iteration position.
+		 */
+		if (drm_WARN_ON(display->drm, link_config_idx != i))
+			return false;
+
+		link_rate = link_config.rate;
+		lane_count = link_config.lane_count;
 
 		if ((forced_rate &&
 		     forced_rate != link_rate) ||
Signature · 1 line
2.49.1
author
#98 lore raw

PATCH 75/108 drm/i915/dp_link_training: Look up configurations using fuzzy rate matching

In reply to Imre Deak

Look up an allowed link configuration during the BW-order fallback using a fuzzy rate match to account for differences between the computed link rate and the nominal rate tracked by the allowed configurations.

---
 .../gpu/drm/i915/display/intel_dp_link_caps.c | 20 -------------------
 .../gpu/drm/i915/display/intel_dp_link_caps.h |  2 --
 .../drm/i915/display/intel_dp_link_training.c | 19 +++++++++---------
 3 files changed, 10 insertions(+), 31 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +0 -20
index 103490eec3d23..7643c468588d0 100644
@@ -878,26 +878,6 @@ bool intel_dp_link_caps_update(struct intel_dp_link_caps *link_caps,
 	return link_params_changed;
 }
 
-int intel_dp_link_config_index(struct intel_dp_link_caps *link_caps,
-			       int link_rate, int lane_count)
-{
-	const struct intel_dp_link_caps_config_table *table = &link_caps->config_table;
-	int link_rate_idx = intel_dp_rate_index(table->rates, table->num_rates,
-						link_rate);
-	int lane_count_exp = ilog2(lane_count);
-	int i;
-
-	for (i = 0; i < table->num_configs; i++) {
-		const struct intel_dp_link_config_entry *lc = &table->configs[i];
-
-		if (lc->lane_count_exp == lane_count_exp &&
-		    lc->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 -2
index b380beedd8990..6599325932ab6 100644
@@ -100,8 +100,6 @@ void intel_dp_link_caps_get_forced_params(struct intel_dp_link_caps *link_caps,
 					  struct intel_dp_link_config *forced_params);
 u32 intel_dp_link_caps_get_allowed_config_mask(struct intel_dp_link_caps *link_caps);
 
-int intel_dp_link_config_index(struct intel_dp_link_caps *link_caps,
-			       int link_rate, int lane_count);
 bool
 intel_dp_link_caps_get_config_by_pos(struct intel_dp_link_caps *link_caps,
 				     struct intel_dp_link_caps_config_order config_order,
drivers/gpu/drm/i915/display/intel_dp_link_training.c +10 -9
index 9dd302bb4968b..fb20795a7086f 100644
@@ -1782,8 +1782,16 @@ static bool reduce_link_params_in_bw_order(struct intel_dp *intel_dp,
 	forced_rate = forced_params.rate;
 	forced_lane_count = forced_params.lane_count;
 
-	i = intel_dp_link_config_index(intel_dp->link.caps,
-				       crtc_state->port_clock, crtc_state->lane_count);
+	/*
+	 * The computed link rate could differ from the nominal rate
+	 * due to platform specific PLL restrictions, so use a fuzzy
+	 * matching.
+	 */
+	i = intel_dp_link_caps_find_allowed_config_pos(link_caps,
+						       bw_asc_order,
+						       INTEL_DP_LINK_CAPS_CONFIG_MATCH_FUZZY_RATE,
+						       &link_config);
+
 	for (i--; i >= 0; i--) {
 		bool config_found;
 
@@ -1794,13 +1802,6 @@ static bool reduce_link_params_in_bw_order(struct intel_dp *intel_dp,
 		if (drm_WARN_ON(display->drm, !config_found))
 			return false;
 
-		/*
-		 * Atm, the index of the configuration must match its
-		 * iteration position.
-		 */
-		if (drm_WARN_ON(display->drm, link_config_idx != i))
-			return false;
-
 		link_rate = link_config.rate;
 		lane_count = link_config.lane_count;
 
Signature · 1 line
2.49.1
author
#99 lore raw

PATCH 76/108 drm/i915/dp_link_caps: Pass table pointer to the sort compare function

In reply to Imre Deak

Convert the sort compare function to accept a pointer to the config_table, instead of the full link_caps struct. This prepares for a follow-up change that will precompute the table before committing it to link_caps.

---
 .../gpu/drm/i915/display/intel_dp_link_caps.c  | 18 ++++++++----------
 1 file changed, 8 insertions(+), 10 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +8 -10
index 7643c468588d0..53649aa710f94 100644
@@ -731,28 +731,26 @@ void intel_dp_link_caps_reset_max_limits(struct intel_dp_link_caps *link_caps)
 	update_max_link_info(link_caps);
 }
 
-static int intel_dp_link_config_bw(struct intel_dp_link_caps *link_caps,
+static int intel_dp_link_config_bw(const struct intel_dp_link_caps_config_table *table,
 				   const struct intel_dp_link_config_entry *lc)
 {
-	return drm_dp_max_dprx_data_rate(intel_dp_link_config_rate(&link_caps->config_table, lc),
+	return drm_dp_max_dprx_data_rate(intel_dp_link_config_rate(table, lc),
 					 intel_dp_link_config_lane_count(lc));
 }
 
 static int link_config_cmp_by_bw(const void *a, const void *b, const void *p)
 {
-	struct intel_dp *intel_dp = (struct intel_dp *)p;	/* remove const */
-	struct intel_dp_link_caps *link_caps = intel_dp->link.caps;
-
+	const struct intel_dp_link_caps_config_table *table = p;
 	const struct intel_dp_link_config_entry *lc_a = a;
 	const struct intel_dp_link_config_entry *lc_b = b;
-	int bw_a = intel_dp_link_config_bw(link_caps, lc_a);
-	int bw_b = intel_dp_link_config_bw(link_caps, lc_b);
+	int bw_a = intel_dp_link_config_bw(table, lc_a);
+	int bw_b = intel_dp_link_config_bw(table, lc_b);
 
 	if (bw_a != bw_b)
 		return bw_a - bw_b;
 
-	return intel_dp_link_config_rate(&link_caps->config_table, lc_a) -
-	       intel_dp_link_config_rate(&link_caps->config_table, lc_b);
+	return intel_dp_link_config_rate(table, lc_a) -
+	       intel_dp_link_config_rate(table, lc_b);
 }
 
 static bool current_common_caps_match(struct intel_dp_link_caps_config_table *table,
@@ -856,7 +854,7 @@ bool intel_dp_link_caps_update(struct intel_dp_link_caps *link_caps,
 	sort_r(table->configs, table->num_configs,
 	       sizeof(table->configs[0]),
 	       link_config_cmp_by_bw, NULL,
-	       intel_dp);
+	       table);
 
 	if (!current_common_caps_match(table, old_rates, num_old_rates,
 				       old_max_lane_count))
Signature · 1 line
2.49.1
author
#100 lore raw

PATCH 77/108 drm/i915/dp_link_caps: Compare config tables instead of link parameters

In reply to Imre Deak

Replace change detection based on link parameters (max_lane_count, rates, and num_rates) with direct comparison of the resulting config tables.

Keep a temporary copy of the existing table and compare it against the recomputed table.

This prepares for a follow-up change that will precompute the table before committing it to link_caps.

---
 .../gpu/drm/i915/display/intel_dp_link_caps.c | 27 +++++++------------
 1 file changed, 9 insertions(+), 18 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +9 -18
index 53649aa710f94..b156b0ff0eedc 100644
@@ -753,21 +753,17 @@ static int link_config_cmp_by_bw(const void *a, const void *b, const void *p)
 	       intel_dp_link_config_rate(table, lc_b);
 }
 
-static bool current_common_caps_match(struct intel_dp_link_caps_config_table *table,
-				      const int *rates, int num_rates,
-				      int old_max_lane_count)
+static bool config_tables_match(const struct intel_dp_link_caps_config_table *table_a,
+				const struct intel_dp_link_caps_config_table *table_b)
 {
-	int current_max_lane_count = table->max_lane_count;
-	const int *current_rates = table->rates;
-	int num_current_rates = table->num_rates;
-
-	if (num_current_rates != num_rates)
+	if (table_a->num_rates != table_b->num_rates)
 		return false;
 
-	if (current_max_lane_count != old_max_lane_count)
+	if (table_a->max_lane_count != table_b->max_lane_count)
 		return false;
 
-	if (memcmp(current_rates, rates, num_rates * sizeof(rates[0])))
+	if (memcmp(table_a->rates, table_b->rates,
+		   table_a->num_rates * sizeof(table_a->rates[0])))
 		return false;
 
 	return true;
@@ -808,14 +804,12 @@ bool intel_dp_link_caps_update(struct intel_dp_link_caps *link_caps,
 	struct intel_display *display = to_intel_display(intel_dp);
 	struct intel_dp_link_caps_config_table *table =
 		&link_caps->config_table;
+	struct intel_dp_link_caps_config_table old_table;
 	struct intel_dp_link_config old_max_limits =
 		link_caps->max_limits;
-	int old_rates[DP_MAX_SUPPORTED_RATES];
 	struct intel_dp_link_config_entry *lc;
 	bool link_params_changed = false;
 	int num_common_lane_configs;
-	int old_max_lane_count;
-	int num_old_rates;
 	int i;
 	int j;
 
@@ -831,9 +825,7 @@ bool intel_dp_link_caps_update(struct intel_dp_link_caps *link_caps,
 				    ARRAY_SIZE(table->configs)))
 		return false;
 
-	num_old_rates = table->num_rates;
-	memcpy(old_rates, table->rates, num_old_rates * sizeof(old_rates[0]));
-	old_max_lane_count = table->max_lane_count;
+	old_table = *table;
 
 	memcpy(table->rates, rates, num_rates * sizeof(rates[0]));
 	table->num_rates = num_rates;
@@ -856,8 +848,7 @@ bool intel_dp_link_caps_update(struct intel_dp_link_caps *link_caps,
 	       link_config_cmp_by_bw, NULL,
 	       table);
 
-	if (!current_common_caps_match(table, old_rates, num_old_rates,
-				       old_max_lane_count))
+	if (!config_tables_match(table, &old_table))
 		link_params_changed = true;
 
 	/*
Signature · 1 line
2.49.1
author
#101 lore raw

PATCH 78/108 drm/i915/dp_link_caps: Precompute config table before update

In reply to Imre Deak

Factor out a function to precompute the link configuration table into a temporary new_table before committing it to link_caps. This allows a straightforward comparison with the existing table and enables a follow-up change to merge the old and new tables as required.

---
 .../gpu/drm/i915/display/intel_dp_link_caps.c | 93 +++++++++++--------
 1 file changed, 52 insertions(+), 41 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +52 -41
index b156b0ff0eedc..65358ec34d44b 100644
@@ -769,6 +769,53 @@ static bool config_tables_match(const struct intel_dp_link_caps_config_table *ta
 	return true;
 }
 
+static bool build_config_table(struct intel_display *display,
+			       const int *rates, int num_rates, int max_lane_count,
+			       struct intel_dp_link_caps_config_table *table)
+{
+	struct intel_dp_link_config_entry *lc;
+	int num_common_lane_configs;
+	int i;
+	int j;
+
+	if (drm_WARN_ON(display->drm, !is_power_of_2(max_lane_count)))
+		return false;
+
+	if (drm_WARN_ON(display->drm, num_rates > ARRAY_SIZE(table->rates)))
+		return false;
+
+	num_common_lane_configs = ilog2(max_lane_count) + 1;
+
+	if (drm_WARN_ON(display->drm, num_rates * num_common_lane_configs >
+				    ARRAY_SIZE(table->configs)))
+		return false;
+
+	memset(table, 0, sizeof(*table));
+
+	memcpy(table->rates, rates, num_rates * sizeof(rates[0]));
+	table->num_rates = num_rates;
+	table->max_lane_count = max_lane_count;
+
+	table->num_configs = num_rates * num_common_lane_configs;
+
+	lc = &table->configs[0];
+	for (i = 0; i < num_rates; i++) {
+		for (j = 0; j < num_common_lane_configs; j++) {
+			lc->lane_count_exp = j;
+			lc->link_rate_idx = i;
+
+			lc++;
+		}
+	}
+
+	sort_r(table->configs, table->num_configs,
+	       sizeof(table->configs[0]),
+	       link_config_cmp_by_bw, NULL,
+	       table);
+
+	return true;
+}
+
 /**
  * intel_dp_link_caps_update - rebuild the supported link configuration state
  * @link_caps: link capabilities state
@@ -802,55 +849,19 @@ bool intel_dp_link_caps_update(struct intel_dp_link_caps *link_caps,
 {
 	struct intel_dp *intel_dp = link_caps->dp;
 	struct intel_display *display = to_intel_display(intel_dp);
-	struct intel_dp_link_caps_config_table *table =
-		&link_caps->config_table;
-	struct intel_dp_link_caps_config_table old_table;
+	struct intel_dp_link_caps_config_table new_table;
 	struct intel_dp_link_config old_max_limits =
 		link_caps->max_limits;
-	struct intel_dp_link_config_entry *lc;
 	bool link_params_changed = false;
-	int num_common_lane_configs;
-	int i;
-	int j;
 
-	if (drm_WARN_ON(display->drm, !is_power_of_2(max_lane_count)))
+	if (!build_config_table(display, rates, num_rates, max_lane_count, &new_table))
 		return false;
 
-	if (drm_WARN_ON(display->drm, num_rates > ARRAY_SIZE(table->rates)))
-		return false;
-
-	num_common_lane_configs = ilog2(max_lane_count) + 1;
-
-	if (drm_WARN_ON(display->drm, num_rates * num_common_lane_configs >
-				    ARRAY_SIZE(table->configs)))
-		return false;
-
-	old_table = *table;
-
-	memcpy(table->rates, rates, num_rates * sizeof(rates[0]));
-	table->num_rates = num_rates;
-	table->max_lane_count = max_lane_count;
-
-	table->num_configs = num_rates * num_common_lane_configs;
-
-	lc = &table->configs[0];
-	for (i = 0; i < num_rates; i++) {
-		for (j = 0; j < num_common_lane_configs; j++) {
-			lc->lane_count_exp = j;
-			lc->link_rate_idx = i;
-
-			lc++;
-		}
-	}
-
-	sort_r(table->configs, table->num_configs,
-	       sizeof(table->configs[0]),
-	       link_config_cmp_by_bw, NULL,
-	       table);
-
-	if (!config_tables_match(table, &old_table))
+	if (!config_tables_match(&new_table, &link_caps->config_table))
 		link_params_changed = true;
 
+	link_caps->config_table = new_table;
+
 	/*
 	 * A failure could be only due to a bug, the update function handles
 	 * that case by removing all restriction and resetting the max limit
Signature · 1 line
2.49.1
author
#102 lore raw

PATCH 79/108 drm/i915/dp_link_caps: Compare internal config entries during table matching

In reply to Imre Deak

Include the packed configuration entries when comparing two link configuration tables, so that any change in them can be detected.

---
 drivers/gpu/drm/i915/display/intel_dp_link_caps.c | 7 +++++++
 1 file changed, 7 insertions(+)
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +7 -0
index 65358ec34d44b..a6390ed024940 100644
@@ -762,10 +762,17 @@ static bool config_tables_match(const struct intel_dp_link_caps_config_table *ta
 	if (table_a->max_lane_count != table_b->max_lane_count)
 		return false;
 
+	if (table_a->num_configs != table_b->num_configs)
+		return false;
+
 	if (memcmp(table_a->rates, table_b->rates,
 		   table_a->num_rates * sizeof(table_a->rates[0])))
 		return false;
 
+	if (memcmp(table_a->configs, table_b->configs,
+		   table_a->num_configs * sizeof(table_a->configs[0])))
+		return false;
+
 	return true;
 }
 
Signature · 1 line
2.49.1
author
#103 lore raw

PATCH 80/108 drm/i915/dp_link_caps: Use virtual config indexing in config table

In reply to Imre Deak

Replace explicit storage of rate index and lane count exponent in each configuration table entry with a virtual indexing scheme. Each entry's rate index and lane exponent are derived from its position in the table assuming a fixed rate/lane ordering and a fixed 4 lane-count stride:

rate_idx = idx / 4
lane_exp = idx % 4

To support different iteration orders, store a map from this virtual index to the config_table::configs array and sort it as needed.

This also adds a way - for free - to iterate the configurations in a rate/lane order besides the BW order currently supported, which will be required by follow-up changes.

---
 .../gpu/drm/i915/display/intel_dp_link_caps.c | 106 +++++++++++++++---
 1 file changed, 89 insertions(+), 17 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +89 -17
index a6390ed024940..0d828ad9f93a7 100644
@@ -89,18 +89,45 @@ struct intel_dp_link_caps {
 		int rates[DP_MAX_SUPPORTED_RATES];
 		int max_lane_count;
 
-		/* common rate,lane_count configs in bw order */
+		/*
+		 * Number of configurations supported for the current sink
+		 * connection.
+		 */
 		int num_configs;
+		/*
+		 * Virtual rate/lane configuration space.
+		 *
+		 * Configurations are not stored explicitly. Instead, each
+		 * configuration is identified by an index in a conceptual
+		 * table ordered by (rate_idx, lane_count) in ascending order,
+		 * with a fixed lane stride of
+		 * INTEL_DP_MAX_SUPPORTED_LANE_CONFIGS.
+		 *
+		 * For now the above index is stored in struct
+		 * intel_dp_link_config_entry::config_idx.
+		 *
+		 * A configuration can be reconstructed from its index as:
+		 *
+		 *   rate_idx  = idx / INTEL_DP_MAX_SUPPORTED_LANE_CONFIGS
+		 *   lane_exp  = idx % INTEL_DP_MAX_SUPPORTED_LANE_CONFIGS
+		 *   rate      = rates[rate_idx]
+		 *   lane_count = 1 << lane_exp
+		 *
+		 * In this conceptual table, only entries within the current
+		 * sink limits are valid, i.e. those allowed by the current
+		 * number of rates and maximum lane count.
+		 */
 #define INTEL_DP_MAX_LANE_COUNT			4
-#define INTEL_DP_MAX_SUPPORTED_LANE_CONFIGS	(ilog2(INTEL_DP_MAX_LANE_COUNT) + 1)
-#define INTEL_DP_LANE_COUNT_EXP_BITS		order_base_2(INTEL_DP_MAX_SUPPORTED_LANE_CONFIGS)
-#define INTEL_DP_LINK_RATE_IDX_BITS		(BITS_PER_TYPE(u8) - INTEL_DP_LANE_COUNT_EXP_BITS)
+
+#define INTEL_DP_LANE_COUNT_CONFIGS(__lane_count) \
+		(ilog2(__lane_count) + 1)
+#define INTEL_DP_MAX_SUPPORTED_LANE_CONFIGS \
+		INTEL_DP_LANE_COUNT_CONFIGS(INTEL_DP_MAX_LANE_COUNT)
+
 #define INTEL_DP_MAX_LINK_CONFIGS		(DP_MAX_SUPPORTED_RATES * \
 						 INTEL_DP_MAX_SUPPORTED_LANE_CONFIGS)
 		struct intel_dp_link_config_entry {
-			/* index into rates[] */
-			u8 link_rate_idx:INTEL_DP_LINK_RATE_IDX_BITS;
-			u8 lane_count_exp:INTEL_DP_LANE_COUNT_EXP_BITS;
+			u8 config_idx;
 		} configs[INTEL_DP_MAX_LINK_CONFIGS];
 	} config_table;
 
@@ -276,15 +303,25 @@ void intel_dp_link_caps_get_forced_params(struct intel_dp_link_caps *link_caps,
 	forced_params->lane_count = forced_lane_count(link_caps);
 }
 
+static int link_config_idx_to_rate_idx(int config_idx)
+{
+	return config_idx / INTEL_DP_MAX_SUPPORTED_LANE_CONFIGS;
+}
+
+static int link_config_idx_to_lane_count_exp(int config_idx)
+{
+	return config_idx % INTEL_DP_MAX_SUPPORTED_LANE_CONFIGS;
+}
+
 static int intel_dp_link_config_rate(const struct intel_dp_link_caps_config_table *table,
 				     const struct intel_dp_link_config_entry *lc)
 {
-	return lookup_rate(table, lc->link_rate_idx);
+	return lookup_rate(table, link_config_idx_to_rate_idx(lc->config_idx));
 }
 
 static int intel_dp_link_config_lane_count(const struct intel_dp_link_config_entry *lc)
 {
-	return 1 << lc->lane_count_exp;
+	return 1 << link_config_idx_to_lane_count_exp(lc->config_idx);
 }
 
 static int link_config_idx_to_rate(const struct intel_dp_link_caps_config_table *table,
@@ -303,6 +340,33 @@ static int link_config_idx_to_lane_count(const struct intel_dp_link_caps_config_
 	return intel_dp_link_config_lane_count(lc);
 }
 
+/*
+ * Remap @from_pos, referring to the (row, col) point in row-major
+ * table-a with @from_cols columns per row, to the position in table-b
+ * with @to_cols columns per row referring to the same (row, col) point.
+ */
+static int remap_table_pos(int from_pos, int from_cols, int to_cols)
+{
+	int col = from_pos % from_cols;
+
+	if (WARN_ON(col >= to_cols))
+		return -1;
+
+	return from_pos / from_cols * to_cols + col;
+}
+
+static int remap_lane_stride_pos(int from_pos, int from_max_lane_count, int to_max_lane_count)
+{
+	return remap_table_pos(from_pos,
+			       INTEL_DP_LANE_COUNT_CONFIGS(from_max_lane_count),
+			       INTEL_DP_LANE_COUNT_CONFIGS(to_max_lane_count));
+}
+
+static int rate_lane_iter_pos_to_config_idx(int iter_pos, int max_lane_count)
+{
+	return remap_lane_stride_pos(iter_pos, max_lane_count, INTEL_DP_MAX_LANE_COUNT);
+}
+
 static void
 to_intel_dp_link_config(const struct intel_dp_link_caps_config_table *table,
 			int config_idx, struct intel_dp_link_config *config)
@@ -331,7 +395,7 @@ get_table_config_by_pos(const struct intel_dp_link_caps_config_table *config_tab
 
 	switch (config_order.key) {
 	case INTEL_DP_LINK_CAPS_CONFIG_ORDER_KEY_BW:
-		*config_idx = iter_pos;
+		*config_idx = config_table->configs[iter_pos].config_idx;
 
 		break;
 	default:
@@ -783,7 +847,13 @@ static bool build_config_table(struct intel_display *display,
 	struct intel_dp_link_config_entry *lc;
 	int num_common_lane_configs;
 	int i;
-	int j;
+
+	if (drm_WARN_ON(display->drm,
+			num_rates < 1 || num_rates > ARRAY_SIZE(table->rates)))
+		return false;
+
+	if (drm_WARN_ON(display->drm, max_lane_count > INTEL_DP_MAX_LANE_COUNT))
+		return false;
 
 	if (drm_WARN_ON(display->drm, !is_power_of_2(max_lane_count)))
 		return false;
@@ -806,13 +876,15 @@ static bool build_config_table(struct intel_display *display,
 	table->num_configs = num_rates * num_common_lane_configs;
 
 	lc = &table->configs[0];
-	for (i = 0; i < num_rates; i++) {
-		for (j = 0; j < num_common_lane_configs; j++) {
-			lc->lane_count_exp = j;
-			lc->link_rate_idx = i;
+	for (i = 0; i < table->num_configs; i++) {
+		int config_idx;
 
-			lc++;
-		}
+		config_idx = rate_lane_iter_pos_to_config_idx(i, max_lane_count);
+		if (config_idx < 0)
+			return false;
+
+		lc->config_idx = config_idx;
+		lc++;
 	}
 
 	sort_r(table->configs, table->num_configs,
Signature · 1 line
2.49.1
author
#104 lore raw

PATCH 81/108 drm/i915/dp_link_caps: Simplify idx->link rate/lane count lookup

In reply to Imre Deak

Compute the rate and lane count for a configuration directly from its table index, removing indirection via the thin wrapper functions.

---
 .../gpu/drm/i915/display/intel_dp_link_caps.c | 32 +++++--------------
 1 file changed, 8 insertions(+), 24 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +8 -24
index 0d828ad9f93a7..345419e7c0c29 100644
@@ -313,31 +313,15 @@ static int link_config_idx_to_lane_count_exp(int config_idx)
 	return config_idx % INTEL_DP_MAX_SUPPORTED_LANE_CONFIGS;
 }
 
-static int intel_dp_link_config_rate(const struct intel_dp_link_caps_config_table *table,
-				     const struct intel_dp_link_config_entry *lc)
-{
-	return lookup_rate(table, link_config_idx_to_rate_idx(lc->config_idx));
-}
-
-static int intel_dp_link_config_lane_count(const struct intel_dp_link_config_entry *lc)
-{
-	return 1 << link_config_idx_to_lane_count_exp(lc->config_idx);
-}
-
 static int link_config_idx_to_rate(const struct intel_dp_link_caps_config_table *table,
 				   int config_idx)
 {
-	const struct intel_dp_link_config_entry *lc = &table->configs[config_idx];
-
-	return intel_dp_link_config_rate(table, lc);
+	return lookup_rate(table, link_config_idx_to_rate_idx(config_idx));
 }
 
-static int link_config_idx_to_lane_count(const struct intel_dp_link_caps_config_table *table,
-					 int config_idx)
+static int link_config_idx_to_lane_count(int config_idx)
 {
-	const struct intel_dp_link_config_entry *lc = &table->configs[config_idx];
-
-	return intel_dp_link_config_lane_count(lc);
+	return 1 << link_config_idx_to_lane_count_exp(config_idx);
 }
 
 /*
@@ -372,7 +356,7 @@ to_intel_dp_link_config(const struct intel_dp_link_caps_config_table *table,
 			int config_idx, struct intel_dp_link_config *config)
 {
 	config->rate = link_config_idx_to_rate(table, config_idx);
-	config->lane_count = link_config_idx_to_lane_count(table, config_idx);
+	config->lane_count = link_config_idx_to_lane_count(config_idx);
 }
 
 static bool
@@ -798,8 +782,8 @@ void intel_dp_link_caps_reset_max_limits(struct intel_dp_link_caps *link_caps)
 static int intel_dp_link_config_bw(const struct intel_dp_link_caps_config_table *table,
 				   const struct intel_dp_link_config_entry *lc)
 {
-	return drm_dp_max_dprx_data_rate(intel_dp_link_config_rate(table, lc),
-					 intel_dp_link_config_lane_count(lc));
+	return drm_dp_max_dprx_data_rate(link_config_idx_to_rate(table, lc->config_idx),
+					 link_config_idx_to_lane_count(lc->config_idx));
 }
 
 static int link_config_cmp_by_bw(const void *a, const void *b, const void *p)
@@ -813,8 +797,8 @@ static int link_config_cmp_by_bw(const void *a, const void *b, const void *p)
 	if (bw_a != bw_b)
 		return bw_a - bw_b;
 
-	return intel_dp_link_config_rate(table, lc_a) -
-	       intel_dp_link_config_rate(table, lc_b);
+	return link_config_idx_to_rate(table, lc_a->config_idx) -
+	       link_config_idx_to_rate(table, lc_b->config_idx);
 }
 
 static bool config_tables_match(const struct intel_dp_link_caps_config_table *table_a,
Signature · 1 line
2.49.1
author
#105 lore raw

PATCH 82/108 drm/i915/dp_link_caps: Simplify BW order pos->config index array

In reply to Imre Deak

Replace the config_idx entries with a flat position-to-index map array in the config table, renamed to bw_order_map. The semantic remains unchanged; the array maps BW-order positions to config indices as before.

---
 .../gpu/drm/i915/display/intel_dp_link_caps.c | 59 +++++++++++--------
 1 file changed, 33 insertions(+), 26 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +33 -26
index 345419e7c0c29..685fbc34b8df9 100644
@@ -103,9 +103,6 @@ struct intel_dp_link_caps {
 		 * with a fixed lane stride of
 		 * INTEL_DP_MAX_SUPPORTED_LANE_CONFIGS.
 		 *
-		 * For now the above index is stored in struct
-		 * intel_dp_link_config_entry::config_idx.
-		 *
 		 * A configuration can be reconstructed from its index as:
 		 *
 		 *   rate_idx  = idx / INTEL_DP_MAX_SUPPORTED_LANE_CONFIGS
@@ -126,9 +123,14 @@ struct intel_dp_link_caps {
 
 #define INTEL_DP_MAX_LINK_CONFIGS		(DP_MAX_SUPPORTED_RATES * \
 						 INTEL_DP_MAX_SUPPORTED_LANE_CONFIGS)
-		struct intel_dp_link_config_entry {
-			u8 config_idx;
-		} configs[INTEL_DP_MAX_LINK_CONFIGS];
+		/*
+		 * Indices of configurations sorted in ascending bandwidth
+		 * order.
+		 *
+		 * Each entry is an index into the virtual configuration space
+		 * described above.
+		 */
+		u8 bw_order_map[INTEL_DP_MAX_LINK_CONFIGS];
 	} config_table;
 
 	/*
@@ -379,7 +381,7 @@ get_table_config_by_pos(const struct intel_dp_link_caps_config_table *config_tab
 
 	switch (config_order.key) {
 	case INTEL_DP_LINK_CAPS_CONFIG_ORDER_KEY_BW:
-		*config_idx = config_table->configs[iter_pos].config_idx;
+		*config_idx = config_table->bw_order_map[iter_pos];
 
 		break;
 	default:
@@ -779,26 +781,31 @@ void intel_dp_link_caps_reset_max_limits(struct intel_dp_link_caps *link_caps)
 	update_max_link_info(link_caps);
 }
 
-static int intel_dp_link_config_bw(const struct intel_dp_link_caps_config_table *table,
-				   const struct intel_dp_link_config_entry *lc)
+static int intel_dp_link_config_bw(const struct intel_dp_link_config *link_config)
 {
-	return drm_dp_max_dprx_data_rate(link_config_idx_to_rate(table, lc->config_idx),
-					 link_config_idx_to_lane_count(lc->config_idx));
+	return drm_dp_max_dprx_data_rate(link_config->rate, link_config->lane_count);
 }
 
 static int link_config_cmp_by_bw(const void *a, const void *b, const void *p)
 {
 	const struct intel_dp_link_caps_config_table *table = p;
-	const struct intel_dp_link_config_entry *lc_a = a;
-	const struct intel_dp_link_config_entry *lc_b = b;
-	int bw_a = intel_dp_link_config_bw(table, lc_a);
-	int bw_b = intel_dp_link_config_bw(table, lc_b);
+	struct intel_dp_link_config link_config_a;
+	struct intel_dp_link_config link_config_b;
+	u8 idx_a = *(u8 *)a;
+	u8 idx_b = *(u8 *)b;
+	int bw_a;
+	int bw_b;
+
+	to_intel_dp_link_config(table, idx_a, &link_config_a);
+	to_intel_dp_link_config(table, idx_b, &link_config_b);
+
+	bw_a = intel_dp_link_config_bw(&link_config_a);
+	bw_b = intel_dp_link_config_bw(&link_config_b);
 
 	if (bw_a != bw_b)
 		return bw_a - bw_b;
 
-	return link_config_idx_to_rate(table, lc_a->config_idx) -
-	       link_config_idx_to_rate(table, lc_b->config_idx);
+	return link_config_a.rate - link_config_b.rate;
 }
 
 static bool config_tables_match(const struct intel_dp_link_caps_config_table *table_a,
@@ -817,8 +824,8 @@ static bool config_tables_match(const struct intel_dp_link_caps_config_table *ta
 		   table_a->num_rates * sizeof(table_a->rates[0])))
 		return false;
 
-	if (memcmp(table_a->configs, table_b->configs,
-		   table_a->num_configs * sizeof(table_a->configs[0])))
+	if (memcmp(table_a->bw_order_map, table_b->bw_order_map,
+		   table_a->num_configs * sizeof(table_a->bw_order_map[0])))
 		return false;
 
 	return true;
@@ -828,8 +835,8 @@ static bool build_config_table(struct intel_display *display,
 			       const int *rates, int num_rates, int max_lane_count,
 			       struct intel_dp_link_caps_config_table *table)
 {
-	struct intel_dp_link_config_entry *lc;
 	int num_common_lane_configs;
+	u8 *bw_order_map;
 	int i;
 
 	if (drm_WARN_ON(display->drm,
@@ -848,7 +855,7 @@ static bool build_config_table(struct intel_display *display,
 	num_common_lane_configs = ilog2(max_lane_count) + 1;
 
 	if (drm_WARN_ON(display->drm, num_rates * num_common_lane_configs >
-				    ARRAY_SIZE(table->configs)))
+				    ARRAY_SIZE(table->bw_order_map)))
 		return false;
 
 	memset(table, 0, sizeof(*table));
@@ -859,7 +866,7 @@ static bool build_config_table(struct intel_display *display,
 
 	table->num_configs = num_rates * num_common_lane_configs;
 
-	lc = &table->configs[0];
+	bw_order_map = table->bw_order_map;
 	for (i = 0; i < table->num_configs; i++) {
 		int config_idx;
 
@@ -867,12 +874,12 @@ static bool build_config_table(struct intel_display *display,
 		if (config_idx < 0)
 			return false;
 
-		lc->config_idx = config_idx;
-		lc++;
+		*bw_order_map = config_idx;
+		bw_order_map++;
 	}
 
-	sort_r(table->configs, table->num_configs,
-	       sizeof(table->configs[0]),
+	sort_r(table->bw_order_map, table->num_configs,
+	       sizeof(table->bw_order_map[0]),
 	       link_config_cmp_by_bw, NULL,
 	       table);
 
Signature · 1 line
2.49.1
author
#106 lore raw

PATCH 83/108 drm/i915/dp_link_caps: Add helper to get iteration order for a connector

In reply to Imre Deak

Add a helper to select the link configuration iteration order for a connector. This keeps the connector-specific ordering policy in the link caps module and allows using the same ordering during configuration computation and fallback.

Also add the rate/lane order key, used by SST connectors, and descending order direction, used for maximum-configuration-first policies such as intel_dp::use_max_params and MST.

---
 .../gpu/drm/i915/display/intel_dp_link_caps.c | 57 +++++++++++++++++++
 .../gpu/drm/i915/display/intel_dp_link_caps.h | 10 ++++
 2 files changed, 67 insertions(+)
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +57 -0
index 685fbc34b8df9..d7ffb8e8e9cf9 100644
@@ -170,6 +170,52 @@ struct intel_dp_link_caps {
 	struct intel_dp_link_config max_limits;
 };
 
+static enum intel_dp_link_caps_config_order_key
+order_key_for_connector(struct intel_connector *connector)
+{
+	if (connector->mst.dp)
+		return INTEL_DP_LINK_CAPS_CONFIG_ORDER_KEY_BW;
+	else
+		return INTEL_DP_LINK_CAPS_CONFIG_ORDER_KEY_RATE_LANE;
+}
+
+static enum intel_dp_link_caps_config_order_direction
+order_dir_for_connector(struct intel_connector *connector)
+{
+	struct intel_dp *intel_dp = intel_attached_dp(connector);
+
+	if (connector->mst.dp || intel_dp->use_max_params)
+		return INTEL_DP_LINK_CAPS_CONFIG_ORDER_DIR_DESC;
+	else
+		return INTEL_DP_LINK_CAPS_CONFIG_ORDER_DIR_ASC;
+}
+
+/**
+ * intel_dp_link_caps_config_order_for_connector - get config iteration order
+ * @connector: connector to get the iteration order for
+ *
+ * Return the configuration ordering to use for @connector.
+ *
+ * The returned order is suitable for the configuration iterators.
+ *
+ * See also:
+ *  - @for_each_dp_link_config()
+ *  - @for_each_dp_link_config_idx()
+ *
+ * Return:
+ * Configuration ordering for @connector.
+ */
+struct intel_dp_link_caps_config_order
+intel_dp_link_caps_config_order_for_connector(struct intel_connector *connector)
+{
+	struct intel_dp_link_caps_config_order order = {
+		.key = order_key_for_connector(connector),
+		.dir = order_dir_for_connector(connector)
+	};
+
+	return order;
+}
+
 static int lookup_rate(const struct intel_dp_link_caps_config_table *table, int index)
 {
 	if (WARN_ON(index < 0 || index >= table->num_rates))
@@ -373,6 +419,9 @@ get_table_config_by_pos(const struct intel_dp_link_caps_config_table *config_tab
 	switch (config_order.dir) {
 	case INTEL_DP_LINK_CAPS_CONFIG_ORDER_DIR_ASC:
 		break;
+	case INTEL_DP_LINK_CAPS_CONFIG_ORDER_DIR_DESC:
+		iter_pos = config_table->num_configs - 1 - iter_pos;
+		break;
 	default:
 		MISSING_CASE(config_order.dir);
 
@@ -384,12 +433,20 @@ get_table_config_by_pos(const struct intel_dp_link_caps_config_table *config_tab
 		*config_idx = config_table->bw_order_map[iter_pos];
 
 		break;
+	case INTEL_DP_LINK_CAPS_CONFIG_ORDER_KEY_RATE_LANE:
+		*config_idx =
+			rate_lane_iter_pos_to_config_idx(iter_pos,
+							 config_table->max_lane_count);
+		break;
 	default:
 		MISSING_CASE(config_order.key);
 
 		goto out_fail;
 	}
 
+	if (*config_idx < 0)
+		goto out_fail;
+
 	to_intel_dp_link_config(config_table, *config_idx, config);
 
 	return true;
drivers/gpu/drm/i915/display/intel_dp_link_caps.h +10 -0
index 6599325932ab6..ff737dbb7f4ad 100644
@@ -15,6 +15,8 @@ struct intel_dp_link_config;
  * enum intel_dp_link_caps_config_order_key - key used to order configurations
  * @INTEL_DP_LINK_CAPS_CONFIG_ORDER_KEY_BW:
  *   Order configurations by bandwidth, then by link rate.
+ * @INTEL_DP_LINK_CAPS_CONFIG_ORDER_KEY_RATE_LANE:
+ *   Order configurations by link rate, then by lane count.
  * @INTEL_DP_LINK_CAPS_CONFIG_ORDER_KEY_NUM:
  *   Number of ordering keys.
  *
@@ -27,6 +29,7 @@ struct intel_dp_link_config;
  */
 enum intel_dp_link_caps_config_order_key {
 	INTEL_DP_LINK_CAPS_CONFIG_ORDER_KEY_BW,
+	INTEL_DP_LINK_CAPS_CONFIG_ORDER_KEY_RATE_LANE,
 
 	INTEL_DP_LINK_CAPS_CONFIG_ORDER_KEY_NUM
 };
@@ -35,6 +38,8 @@ enum intel_dp_link_caps_config_order_key {
  * enum intel_dp_link_caps_config_order_direction - iteration direction
  * @INTEL_DP_LINK_CAPS_CONFIG_ORDER_DIR_ASC:
  *   Iterate in ascending order according to the selected ordering key.
+ * @INTEL_DP_LINK_CAPS_CONFIG_ORDER_DIR_DESC:
+ *   Iterate in descending order according to the selected ordering key.
  * @INTEL_DP_LINK_CAPS_CONFIG_ORDER_DIR_NUM:
  *   Number of ordering directions.
  *
@@ -46,6 +51,7 @@ enum intel_dp_link_caps_config_order_key {
  */
 enum intel_dp_link_caps_config_order_direction {
 	INTEL_DP_LINK_CAPS_CONFIG_ORDER_DIR_ASC,
+	INTEL_DP_LINK_CAPS_CONFIG_ORDER_DIR_DESC,
 
 	INTEL_DP_LINK_CAPS_CONFIG_ORDER_DIR_NUM
 };
@@ -62,6 +68,7 @@ enum intel_dp_link_caps_config_order_direction {
  * Describes an iteration order for link configurations.
  *
  * See also:
+ *  - intel_dp_link_caps_config_order_for_connector()
  *  - intel_dp_link_caps_get_config_by_pos()
  */
 struct intel_dp_link_caps_config_order {
@@ -89,6 +96,9 @@ enum intel_dp_link_caps_config_match_type {
 	INTEL_DP_LINK_CAPS_CONFIG_MATCH_FUZZY_RATE,
 };
 
+struct intel_dp_link_caps_config_order
+intel_dp_link_caps_config_order_for_connector(struct intel_connector *connector);
+
 int intel_dp_link_caps_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_link_caps_max_common_rate(struct intel_dp_link_caps *link_caps);
Signature · 1 line
2.49.1
author
#107 lore raw

PATCH 84/108 drm/i915/dp_link_caps: Add reset and merge update modes

In reply to Imre Deak

Add update modes to intel_dp_link_caps_update() to distinguish between resetting link capability state for a new sink and merging newly read capabilities into existing state.

Reset mode is used when a new sink is connected, after intel_dp_reset_link_params() is called. Merge mode is used when an already connected sink reports a capability change, preserving disabled configurations that are still present after the update.

This patch only implements the reset mode, by resetting the maximum link limits, the logic for merge behavior will be added by follow-up changes.

---
 drivers/gpu/drm/i915/display/intel_dp.c       |  9 ++++++++-
 .../gpu/drm/i915/display/intel_dp_link_caps.c | 15 ++++++++++++++-
 .../gpu/drm/i915/display/intel_dp_link_caps.h | 19 ++++++++++++++++++-
 3 files changed, 40 insertions(+), 3 deletions(-)
drivers/gpu/drm/i915/display/intel_dp.c +8 -1
index 875e835848c39..0255aeff84b85 100644
@@ -686,14 +686,21 @@ static void intel_dp_get_common_rates(struct intel_dp *intel_dp,
 /* Return %true if any supported or maximum link param changed. */
 static bool intel_dp_set_common_link_params(struct intel_dp *intel_dp)
 {
+	enum intel_dp_link_caps_update_mode update_mode =
+		INTEL_DP_LINK_CAPS_UPDATE_MERGE;
 	int num_common_rates;
 	int common_rates[DP_MAX_SUPPORTED_RATES];
 	bool link_params_changed = false;
 
 	intel_dp_get_common_rates(intel_dp, common_rates, &num_common_rates);
+
+	if (intel_dp->reset_link_params)
+		update_mode = INTEL_DP_LINK_CAPS_UPDATE_RESET;
+
 	if (intel_dp_link_caps_update(intel_dp->link.caps,
 				      common_rates, num_common_rates,
-				      intel_dp_max_common_lane_count(intel_dp)))
+				      intel_dp_max_common_lane_count(intel_dp),
+				      update_mode))
 		link_params_changed = true;
 
 	return link_params_changed;
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +14 -1
index d7ffb8e8e9cf9..9c0ad5cf87259 100644
@@ -949,10 +949,19 @@ static bool build_config_table(struct intel_display *display,
  * @rates: supported common link rates
  * @num_rates: number of entries in @rates
  * @max_lane_count: supported maximum lane count
+ * @update_mode: update mode controlling reset vs. merge behavior
  *
  * Rebuild the supported link configuration state from @rates and
  * @max_lane_count.
  *
+ * If @update_mode is %INTEL_DP_LINK_CAPS_UPDATE_RESET, reset the
+ * maximum link limits to the maximum supported rate and lane count, and
+ * re-enable all configurations.
+ *
+ * If @update_mode is %INTEL_DP_LINK_CAPS_UPDATE_MERGE, preserve the
+ * disabled state of configurations that were disabled before the update
+ * and are still present after it.
+ *
  * Configuration indices are not stable across calls to this function, so
  * callers should not cache such indices and masks built from them across
  * updates via this function.
@@ -972,7 +981,8 @@ static bool build_config_table(struct intel_display *display,
  * - %true if the supported link parameters 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,
+			       enum intel_dp_link_caps_update_mode update_mode)
 {
 	struct intel_dp *intel_dp = link_caps->dp;
 	struct intel_display *display = to_intel_display(intel_dp);
@@ -989,6 +999,9 @@ bool intel_dp_link_caps_update(struct intel_dp_link_caps *link_caps,
 
 	link_caps->config_table = new_table;
 
+	if (update_mode == INTEL_DP_LINK_CAPS_UPDATE_RESET)
+		reset_max_link_limits_no_update(link_caps);
+
 	/*
 	 * A failure could be only due to a bug, the update function handles
 	 * that case by removing all restriction and resetting the max limit
drivers/gpu/drm/i915/display/intel_dp_link_caps.h +18 -1
index ff737dbb7f4ad..ff66056adc9b5 100644
@@ -96,6 +96,22 @@ enum intel_dp_link_caps_config_match_type {
 	INTEL_DP_LINK_CAPS_CONFIG_MATCH_FUZZY_RATE,
 };
 
+/**
+ * enum intel_dp_link_caps_update_mode - intel_dp_link_caps_update() mode
+ * @INTEL_DP_LINK_CAPS_UPDATE_RESET:
+ *	Reset max link limits and re-enable all configurations.
+ * @INTEL_DP_LINK_CAPS_UPDATE_MERGE:
+ *	Preserve the disabled state of configurations that remain present
+ *	after the update.
+ *
+ * Controls how intel_dp_link_caps_update() applies newly read sink
+ * capabilities to the existing link capability state.
+ */
+enum intel_dp_link_caps_update_mode {
+	INTEL_DP_LINK_CAPS_UPDATE_RESET,
+	INTEL_DP_LINK_CAPS_UPDATE_MERGE,
+};
+
 struct intel_dp_link_caps_config_order
 intel_dp_link_caps_config_order_for_connector(struct intel_connector *connector);
 
@@ -127,7 +143,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,
+			       enum intel_dp_link_caps_update_mode update_mode);
 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
author
#108 lore raw

PATCH 85/108 drm/i915/dp_link_caps: Add mask for disabled link configurations

In reply to Imre Deak

Add a disabled configuration mask 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 mask when computing the allowed configuration set and when validating maximum link limits, so disabled configurations are filtered consistently.

Follow-up changes will preserve the mask across merge updates, clear it on reset updates, and switch the fallback code to disable individual configurations through this mask.

---
 .../gpu/drm/i915/display/intel_dp_link_caps.c | 45 ++++++++++++++++---
 1 file changed, 40 insertions(+), 5 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +40 -5
index 9c0ad5cf87259..7a4a8ec8fdf40 100644
@@ -131,8 +131,41 @@ struct intel_dp_link_caps {
 		 * described above.
 		 */
 		u8 bw_order_map[INTEL_DP_MAX_LINK_CONFIGS];
+
+		/*
+		 * Mask of configurations disabled for the current sink
+		 * connection.
+		 *
+		 * Each bit corresponds to a configuration index in the
+		 * virtual configuration space. The same index space is used
+		 * by bw_order_map[] and all configuration masks, including
+		 * the allowed-configuration mask.
+		 *
+		 * Users disable configurations by setting bits in this mask.
+		 * Bits are cleared only internally in the following cases:
+		 * - sink disconnect
+		 * - forcing a link rate or lane count
+		 * - recovery from invalid cases after a sink capability
+		 *   change or internal inconsistencies that would otherwise
+		 *   leave no allowed configuration
+		 * - after intel_dp_link_caps_update(UPDATE_RESET) or
+		 *   intel_dp_link_caps_reset() is called
+		 *
+		 * In all these cases, all configurations are re-enabled.
+		 */
+		u32 disabled_config_mask;
 	} config_table;
 
+	/*
+	 * Allowed configurations are the supported configurations defined by
+	 * config_table.rates and config_table.max_lane_count, constrained by
+	 * config_table.disabled_config_mask and the forced_params and
+	 * max_limits values below.
+	 *
+	 * See intel_dp_link_caps_allowed_config_mask() for the mask of these
+	 * configurations.
+	 */
+
 	/*
 	 * Forced parameters requested via debugfs. Remains set across sink
 	 * disconnects.
@@ -160,15 +193,15 @@ struct intel_dp_link_caps {
 	 * max_limits.lane_count) tuple itself may not be an allowed
 	 * configuration.
 	 *
-	 * TODO: List the events that reset max_limits, after the
-	 * introduction of disabled_config_mask.
-	 *
 	 * TODO: Make max_limits reflect the maximum of the allowed
 	 * configurations at all times and stop making it settable via the
 	 * API, removing it as a constraint on the allowed configurations.
 	 */
 	struct intel_dp_link_config max_limits;
 };
+/* Assert that config masks have enough bits. */
+static_assert(BITS_PER_TYPE(u32) >=
+	      ARRAY_SIZE(((struct intel_dp_link_caps *)NULL)->config_table.bw_order_map));
 
 static enum intel_dp_link_caps_config_order_key
 order_key_for_connector(struct intel_connector *connector)
@@ -511,7 +544,8 @@ static u32 calc_allowed_config_mask(struct intel_dp_link_caps *link_caps,
 u32 intel_dp_link_caps_get_allowed_config_mask(struct intel_dp_link_caps *link_caps)
 {
 	struct intel_dp_link_config forced_params;
-	u32 disabled_mask = 0;	/* get the mask from link_caps. */
+	u32 disabled_mask =
+		link_caps->config_table.disabled_config_mask;
 
 	intel_dp_link_caps_get_forced_params(link_caps, &forced_params);
 
@@ -777,7 +811,8 @@ 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_config forced_params;
-	u32 disabled_mask = 0;	/* get the mask from link_caps. */
+	u32 disabled_mask =
+		link_caps->config_table.disabled_config_mask;
 	u32 allowed_mask;
 
 	intel_dp_link_caps_get_forced_params(link_caps, &forced_params);
Signature · 1 line
2.49.1
author
#109 lore raw

PATCH 86/108 drm/i915/dp_link_caps: Add link configuration iterators

In reply to Imre Deak

Add helpers to iterate over a selected set of link configurations in a given order.

Use the new iterators when computing the allowed configuration mask and the maximum link limits, replacing open-coded walks over the configuration table.

Use the native rate/lane iteration order.

---
 .../gpu/drm/i915/display/intel_dp_link_caps.c | 29 +++++-----
 .../gpu/drm/i915/display/intel_dp_link_caps.h | 54 +++++++++++++++++++
 2 files changed, 68 insertions(+), 15 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +14 -15
index 7a4a8ec8fdf40..eada84b0d1e39 100644
@@ -203,6 +203,16 @@ struct intel_dp_link_caps {
 static_assert(BITS_PER_TYPE(u32) >=
 	      ARRAY_SIZE(((struct intel_dp_link_caps *)NULL)->config_table.bw_order_map));
 
+static struct intel_dp_link_caps_config_order rate_lane_asc_config_order(void)
+{
+	struct intel_dp_link_caps_config_order order = {
+		.key = INTEL_DP_LINK_CAPS_CONFIG_ORDER_KEY_RATE_LANE,
+		.dir = INTEL_DP_LINK_CAPS_CONFIG_ORDER_DIR_ASC
+	};
+
+	return order;
+}
+
 static enum intel_dp_link_caps_config_order_key
 order_key_for_connector(struct intel_connector *connector)
 {
@@ -496,17 +506,12 @@ static u32 calc_allowed_config_mask(struct intel_dp_link_caps *link_caps,
 				    const struct intel_dp_link_config *max_limits,
 				    const struct intel_dp_link_config *forced_params)
 {
-	struct intel_dp_link_caps_config_table *table = &link_caps->config_table;
 	struct intel_dp_link_config config;
 	u32 allowed_mask = 0;
 	int config_idx;
 
-	for (config_idx = 0; config_idx < table->num_configs; config_idx++) {
-		if (BIT(config_idx) & disabled_config_mask)
-			continue;
-
-		to_intel_dp_link_config(table, config_idx, &config);
-
+	for_each_dp_link_config_idx(link_caps, rate_lane_asc_config_order(),
+				    ~disabled_config_mask, &config, &config_idx) {
 		if (forced_params->rate &&
 		    forced_params->rate != config.rate)
 			continue;
@@ -706,18 +711,12 @@ static void reset_all_restrictions_no_update(struct intel_dp_link_caps *link_cap
 static void compute_max_link_limits(struct intel_dp_link_caps *link_caps,
 				    struct intel_dp_link_config *max_link_limits)
 {
-	struct intel_dp_link_caps_config_table *table = &link_caps->config_table;
 	u32 allowed_mask = intel_dp_link_caps_get_allowed_config_mask(link_caps);
 	struct intel_dp_link_config max_config = {};
 	struct intel_dp_link_config link_config;
-	int config_idx;
-
-	for (config_idx = 0; config_idx < table->num_configs; config_idx++) {
-		if (!(BIT(config_idx) & allowed_mask))
-			continue;
-
-		to_intel_dp_link_config(table, config_idx, &link_config);
 
+	for_each_dp_link_config(link_caps, rate_lane_asc_config_order(), allowed_mask,
+				&link_config) {
 		max_config.rate = max(max_config.rate,
 				      link_config.rate);
 		max_config.lane_count = max(max_config.lane_count,
drivers/gpu/drm/i915/display/intel_dp_link_caps.h +54 -0

72 lines not on this page · raw message

Signature · 1 line
2.49.1
author
#110 lore raw

PATCH 87/108 drm/i915/dp_link_caps: Preserve disabled config mask during merge update

In reply to Imre Deak

Preserve the disabled configuration mask when merging newly read sink capabilities into the existing link capability state.

The mask is remapped from the old configuration table to the new one by matching rate and lane count, so configurations that remain present after the update stay disabled. Reset updates still clear the mask.

---
 .../gpu/drm/i915/display/intel_dp_link_caps.c | 69 +++++++++++++++++++
 1 file changed, 69 insertions(+)
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +69 -0
index eada84b0d1e39..9b69e7642717b 100644
@@ -501,6 +501,11 @@ get_table_config_by_pos(const struct intel_dp_link_caps_config_table *config_tab
 	return false;
 }
 
+static u32 config_table_all_mask(void)
+{
+	return GENMASK_U32(31, 0);
+}
+
 static u32 calc_allowed_config_mask(struct intel_dp_link_caps *link_caps,
 				    u32 disabled_config_mask,
 				    const struct intel_dp_link_config *max_limits,
@@ -650,6 +655,22 @@ find_config_table_entry_pos(const struct intel_dp_link_caps_config_table *config
 	return -1;
 }
 
+static int
+find_config_table_entry_idx(const struct intel_dp_link_caps_config_table *config_table,
+			    u32 config_mask,
+			    enum intel_dp_link_caps_config_match_type match_type,
+			    const struct intel_dp_link_config *link_config)
+{
+	int iter_pos;
+
+	iter_pos = find_config_table_entry_pos(config_table, rate_lane_asc_config_order(),
+					       config_mask, match_type, link_config);
+	if (iter_pos < 0)
+		return iter_pos;
+
+	return rate_lane_iter_pos_to_config_idx(iter_pos, config_table->max_lane_count);
+}
+
 /**
  * intel_dp_link_caps_find_allowed_config_pos - find matching allowed config position
  * @link_caps: link capabilities state
@@ -977,6 +998,41 @@ static bool build_config_table(struct intel_display *display,
 	return true;
 }
 
+/*
+ * For each entry selected by @config_mask in @link_caps->config_table,
+ * look up the config with the same rate and lane count parameters in
+ * @new_table and return a mask of the matching entries there.
+ *
+ * Each bit in the returned mask indexes an entry in @new_table, so
+ * this effectively remaps @config_mask from @link_caps->config_table
+ * to @new_table.
+ */
+static u32
+remap_config_mask_to_table(struct intel_dp_link_caps *link_caps,
+			   u32 config_mask,
+			   const struct intel_dp_link_caps_config_table *new_table)
+{
+	struct intel_dp_link_config config;
+	u32 new_config_mask = 0;
+	int config_idx;
+
+	for_each_dp_link_config_idx(link_caps, rate_lane_asc_config_order(), config_mask,
+				    &config, &config_idx) {
+		int to_idx;
+
+		to_idx = find_config_table_entry_idx(new_table,
+						     config_table_all_mask(),
+						     INTEL_DP_LINK_CAPS_CONFIG_MATCH_EXACT,
+						     &config);
+		if (to_idx < 0)
+			continue;
+
+		new_config_mask |= BIT(to_idx);
+	}
+
+	return new_config_mask;
+}
+
 /**
  * intel_dp_link_caps_update - rebuild the supported link configuration state
  * @link_caps: link capabilities state
@@ -1024,14 +1080,27 @@ bool intel_dp_link_caps_update(struct intel_dp_link_caps *link_caps,
 	struct intel_dp_link_config old_max_limits =
 		link_caps->max_limits;
 	bool link_params_changed = false;
+	u32 new_disabled_mask = 0;
 
 	if (!build_config_table(display, rates, num_rates, max_lane_count, &new_table))
 		return false;
 
+	if (update_mode == INTEL_DP_LINK_CAPS_UPDATE_MERGE) {
+		/*
+		 * Get the currently disabled configs remapped to the new table,
+		 * before setting the new table.
+		 */
+		new_disabled_mask =
+			remap_config_mask_to_table(link_caps,
+						   link_caps->config_table.disabled_config_mask,
+						   &new_table);
+	}
+
 	if (!config_tables_match(&new_table, &link_caps->config_table))
 		link_params_changed = true;
 
 	link_caps->config_table = new_table;
+	link_caps->config_table.disabled_config_mask = new_disabled_mask;
 
 	if (update_mode == INTEL_DP_LINK_CAPS_UPDATE_RESET)
 		reset_max_link_limits_no_update(link_caps);
Signature · 1 line
2.49.1
author
#111 lore raw

PATCH 88/108 drm/i915/dp_link_caps: Account for disabled configs during max link info update

In reply to Imre Deak

Account for disabled configurations when updating the maximum link limits.

If a capability update leaves no allowed configuration, re-enable the minimum configuration and reset the maximum link limits so at least one configuration remains available.

Also add a helper to look up a configuration by its canonical index, needed by the recovery path above and by follow-up modeset state computation logic.

---
 .../gpu/drm/i915/display/intel_dp_link_caps.c | 116 +++++++++++++++++-
 .../gpu/drm/i915/display/intel_dp_link_caps.h |   3 +
 2 files changed, 116 insertions(+), 3 deletions(-)
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +113 -3
index 9b69e7642717b..d53cd416a4e09 100644
@@ -595,6 +595,42 @@ bool intel_dp_link_caps_get_config_by_pos(struct intel_dp_link_caps *link_caps,
 				       config, config_idx);
 }
 
+static bool config_idx_is_valid(struct intel_dp_link_caps *link_caps, int config_idx)
+{
+	if (link_config_idx_to_rate_idx(config_idx) >=
+	    link_caps->config_table.num_rates)
+		return false;
+
+	if (link_config_idx_to_lane_count(config_idx) >
+	    link_caps->config_table.max_lane_count)
+		return false;
+
+	return true;
+}
+
+/**
+ * intel_dp_link_caps_get_config_by_idx - get config for a given config index
+ * @link_caps: link capabilities state
+ * @config_idx: configuration index to look up
+ * @config: returned link configuration
+ *
+ * Look up the link configuration identified by @config_idx.
+ *
+ * Return:
+ * - %true  if @config_idx is valid, storing the configuration in @config.
+ * - %false if @config_idx is invalid.
+ */
+bool intel_dp_link_caps_get_config_by_idx(struct intel_dp_link_caps *link_caps, int config_idx,
+					  struct intel_dp_link_config *config)
+{
+	if (!config_idx_is_valid(link_caps, config_idx))
+		return false;
+
+	to_intel_dp_link_config(&link_caps->config_table, config_idx, config);
+
+	return true;
+}
+
 static bool is_within_percent(int actual, int nominal, int percent)
 {
 	int diff = abs(actual - nominal);
@@ -714,9 +750,15 @@ static void reset_max_link_limits_no_update(struct intel_dp_link_caps *link_caps
 	set_max_link_limits_no_update(link_caps, &max_link_limits);
 }
 
+static void reset_max_link_limits_reenable_all_no_update(struct intel_dp_link_caps *link_caps)
+{
+	link_caps->config_table.disabled_config_mask = 0;
+	reset_max_link_limits_no_update(link_caps);
+}
+
 static void reset_all_restrictions_no_update(struct intel_dp_link_caps *link_caps)
 {
-	reset_max_link_limits_no_update(link_caps);
+	reset_max_link_limits_reenable_all_no_update(link_caps);
 	link_caps->forced_params = INTEL_DP_LINK_CONFIG_NULL;
 }
 
@@ -759,20 +801,41 @@ static void compute_max_link_limits(struct intel_dp_link_caps *link_caps,
  * derived from that same set, so it can only be less than or equal to
  * the stored max_limits.
  *
+ * In addition, configurations may be disabled, further constraining the
+ * allowed set.
+ *
+ * Although the allowed mask itself depends on max_limits, this update
+ * must not change the effective allowed set. The recomputed limits still
+ * cover every configuration that is currently allowed.
+ *
  * A %false return indicates an internal error (either the stored
  * max_limits was below all allowed configurations, or
  * compute_max_link_limits() returned a larger value). The caller must
  * recover by removing all restrictions.
  *
+ * A %false return may also indicate an invalid state, e.g. after a sink
+ * capability update removes rates or lane counts and leaves no allowed
+ * configuration. The caller must restore a state where at least one
+ * configuration is enabled (see sanitize_disallowed_config()).
+ *
  * Return:
  * - %true  if max_limits was updated successfully.
- * - %false if an internal error was detected.
+ * - %false if an internal error was detected or the state is invalid.
  */
 static bool update_max_link_limits(struct intel_dp_link_caps *link_caps)
 {
 	struct intel_display *display = to_intel_display(link_caps->dp);
+	u32 old_allowed_mask = intel_dp_link_caps_get_allowed_config_mask(link_caps);
 	struct intel_dp_link_config new_limits;
 
+	/*
+	 * If the stored max_limits is below all enabled and forced
+	 * configurations, the allowed mask is empty. Fail and let the caller
+	 * recover (see function documentation).
+	 */
+	if (!old_allowed_mask)
+		return false;
+
 	compute_max_link_limits(link_caps, &new_limits);
 
 	if (drm_WARN_ON(display->drm,
@@ -782,8 +845,25 @@ static bool update_max_link_limits(struct intel_dp_link_caps *link_caps)
 			new_limits.lane_count > link_caps->max_limits.lane_count))
 		return false;
 
+	/*
+	 * The allowed mask shouldn't have changed, since the bounds could
+	 * only get updated due to configs that were already disabled in the
+	 * old mask. So the new limit values will not disable any configs.
+	 */
 	link_caps->max_limits = new_limits;
 
+	/*
+	 * Updating max_limits above must not change the allowed mask.
+	 *
+	 * The old allowed mask is already constrained by the old stored max_limits.
+	 * Since the recomputed max_limits is derived from that same allowed set, it
+	 * cannot exclude any configuration that was previously allowed.
+	 */
+	if (drm_WARN_ON(display->drm,
+			old_allowed_mask !=
+			intel_dp_link_caps_get_allowed_config_mask(link_caps)))
+		return false;
+
 	return true;
 }
 
@@ -893,6 +973,34 @@ void intel_dp_link_caps_reset_max_limits(struct intel_dp_link_caps *link_caps)
 	update_max_link_info(link_caps);
 }
 
+static void enable_link_config_no_update(struct intel_dp_link_caps *link_caps, int config_idx)
+{
+	struct intel_display *display = to_intel_display(link_caps->dp);
+
+	if (drm_WARN_ON(display->drm, !config_idx_is_valid(link_caps, config_idx)))
+		return;
+
+	link_caps->config_table.disabled_config_mask &= ~BIT(config_idx);
+}
+
+static void sanitize_disallowed_config(struct intel_dp_link_caps *link_caps)
+{
+	struct intel_display *display = to_intel_display(link_caps->dp);
+	struct intel_dp_link_config min_link_config;
+
+	if (intel_dp_link_caps_get_allowed_config_mask(link_caps))
+		return;
+
+	drm_dbg_kms(display->drm,
+		    "No allowed link config left, force enable the minimum config\n");
+
+	if (!intel_dp_link_caps_get_config_by_idx(link_caps, 0, &min_link_config))
+		return;
+
+	enable_link_config_no_update(link_caps, 0);
+	reset_max_link_limits_no_update(link_caps);
+}
+
 static int intel_dp_link_config_bw(const struct intel_dp_link_config *link_config)
 {
 	return drm_dp_max_dprx_data_rate(link_config->rate, link_config->lane_count);
@@ -1105,6 +1213,8 @@ bool intel_dp_link_caps_update(struct intel_dp_link_caps *link_caps,
 	if (update_mode == INTEL_DP_LINK_CAPS_UPDATE_RESET)
 		reset_max_link_limits_no_update(link_caps);
 
+	sanitize_disallowed_config(link_caps);
+
 	/*
 	 * A failure could be only due to a bug, the update function handles
 	 * that case by removing all restriction and resetting the max limit
@@ -1135,7 +1245,7 @@ bool intel_dp_link_caps_update(struct intel_dp_link_caps *link_caps,
  */
 void intel_dp_link_caps_reset(struct intel_dp_link_caps *link_caps)
 {
-	reset_max_link_limits_no_update(link_caps);
+	reset_max_link_limits_reenable_all_no_update(link_caps);
 	/* On failure the following removes all restrictions. */
 	update_max_link_info(link_caps);
 }
drivers/gpu/drm/i915/display/intel_dp_link_caps.h +3 -0
index 939586c74e644..009bee0f7dffb 100644
@@ -180,6 +180,9 @@ void intel_dp_link_caps_get_forced_params(struct intel_dp_link_caps *link_caps,
 					  struct intel_dp_link_config *forced_params);
 u32 intel_dp_link_caps_get_allowed_config_mask(struct intel_dp_link_caps *link_caps);
 
+bool intel_dp_link_caps_get_config_by_idx(struct intel_dp_link_caps *link_caps,
+					  int config_idx,
+					  struct intel_dp_link_config *config);
 bool
 intel_dp_link_caps_get_config_by_pos(struct intel_dp_link_caps *link_caps,
 				     struct intel_dp_link_caps_config_order config_order,
Signature · 1 line
2.49.1
author
#112 lore raw

PATCH 89/108 drm/i915/dp_link_caps: Add debugfs entry showing allowed configurations

In reply to Imre Deak

Add a debugfs entry showing the currently allowed link configurations in the connector's iteration order.

---
 .../gpu/drm/i915/display/intel_dp_link_caps.c | 44 +++++++++++++++++++
 1 file changed, 44 insertions(+)
drivers/gpu/drm/i915/display/intel_dp_link_caps.c +44 -0
index d53cd416a4e09..13d39d07b42b5 100644
@@ -1510,6 +1510,47 @@ 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;
+	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;
+	for_each_dp_link_config(link_caps,
+				intel_dp_link_caps_config_order_for_connector(connector),
+				intel_dp_link_caps_get_allowed_config_mask(link_caps),
+				&link_config) {
+		seq_printf(m, "%s%dx%d",
+			   i ? " " : "",
+			   link_config.lane_count, link_config.rate);
+		i++;
+	}
+
+	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
+ * @connector: connector to add the debugfs files for
+ *
+ * Add the link-capability debugfs files for a DP @connector.
+ */
 void intel_dp_link_caps_debugfs_add(struct intel_connector *connector)
 {
 	struct dentry *root = connector->base.debugfs_entry;
@@ -1529,6 +1570,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);
 }
 
 /**
Signature · 1 line
2.49.1