2 * Copyright © 2008 Intel Corporation
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
24 * Keith Packard <keithp@keithp.com>
28 #include <linux/export.h>
29 #include <linux/i2c.h>
30 #include <linux/notifier.h>
31 #include <linux/slab.h>
32 #include <linux/string_helpers.h>
33 #include <linux/timekeeping.h>
34 #include <linux/types.h>
36 #include <asm/byteorder.h>
38 #include <drm/display/drm_dp_helper.h>
39 #include <drm/display/drm_dp_tunnel.h>
40 #include <drm/display/drm_dsc_helper.h>
41 #include <drm/display/drm_hdmi_helper.h>
42 #include <drm/drm_atomic_helper.h>
43 #include <drm/drm_crtc.h>
44 #include <drm/drm_edid.h>
45 #include <drm/drm_probe_helper.h>
51 #include "intel_atomic.h"
52 #include "intel_audio.h"
53 #include "intel_backlight.h"
54 #include "intel_combo_phy_regs.h"
55 #include "intel_connector.h"
56 #include "intel_crtc.h"
57 #include "intel_cx0_phy.h"
58 #include "intel_ddi.h"
60 #include "intel_display_driver.h"
61 #include "intel_display_types.h"
63 #include "intel_dp_aux.h"
64 #include "intel_dp_hdcp.h"
65 #include "intel_dp_link_training.h"
66 #include "intel_dp_mst.h"
67 #include "intel_dp_tunnel.h"
68 #include "intel_dpio_phy.h"
69 #include "intel_dpll.h"
70 #include "intel_drrs.h"
71 #include "intel_fifo_underrun.h"
72 #include "intel_hdcp.h"
73 #include "intel_hdmi.h"
74 #include "intel_hotplug.h"
75 #include "intel_hotplug_irq.h"
76 #include "intel_lspcon.h"
77 #include "intel_lvds.h"
78 #include "intel_panel.h"
79 #include "intel_pch_display.h"
80 #include "intel_pps.h"
81 #include "intel_psr.h"
83 #include "intel_vdsc.h"
84 #include "intel_vrr.h"
85 #include "intel_crtc_state_dump.h"
87 /* DP DSC throughput values used for slice count calculations KPixels/s */
88 #define DP_DSC_PEAK_PIXEL_RATE 2720000
89 #define DP_DSC_MAX_ENC_THROUGHPUT_0 340000
90 #define DP_DSC_MAX_ENC_THROUGHPUT_1 400000
92 /* Max DSC line buffer depth supported by HW. */
93 #define INTEL_DP_DSC_MAX_LINE_BUF_DEPTH 13
95 /* DP DSC FEC Overhead factor in ppm = 1/(0.972261) = 1.028530 */
96 #define DP_DSC_FEC_OVERHEAD_FACTOR 1028530
98 /* Compliance test status bits */
99 #define INTEL_DP_RESOLUTION_SHIFT_MASK 0
100 #define INTEL_DP_RESOLUTION_PREFERRED (1 << INTEL_DP_RESOLUTION_SHIFT_MASK)
101 #define INTEL_DP_RESOLUTION_STANDARD (2 << INTEL_DP_RESOLUTION_SHIFT_MASK)
102 #define INTEL_DP_RESOLUTION_FAILSAFE (3 << INTEL_DP_RESOLUTION_SHIFT_MASK)
105 /* Constants for DP DSC configurations */
106 static const u8 valid_dsc_bpp[] = {6, 8, 10, 12, 15};
108 /* With Single pipe configuration, HW is capable of supporting maximum
109 * of 4 slices per line.
111 static const u8 valid_dsc_slicecount[] = {1, 2, 4};
114 * intel_dp_is_edp - is the given port attached to an eDP panel (either CPU or PCH)
115 * @intel_dp: DP struct
117 * If a CPU or PCH DP output is attached to an eDP panel, this function
118 * will return true, and false otherwise.
120 * This function is not safe to use prior to encoder type being set.
122 bool intel_dp_is_edp(struct intel_dp *intel_dp)
124 struct intel_digital_port *dig_port = dp_to_dig_port(intel_dp);
126 return dig_port->base.type == INTEL_OUTPUT_EDP;
129 bool intel_dp_as_sdp_supported(struct intel_dp *intel_dp)
131 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
133 return HAS_AS_SDP(i915) &&
134 drm_dp_as_sdp_supported(&intel_dp->aux, intel_dp->dpcd);
137 static void intel_dp_unset_edid(struct intel_dp *intel_dp);
139 /* Is link rate UHBR and thus 128b/132b? */
140 bool intel_dp_is_uhbr(const struct intel_crtc_state *crtc_state)
142 return drm_dp_is_uhbr_rate(crtc_state->port_clock);
146 * intel_dp_link_symbol_size - get the link symbol size for a given link rate
147 * @rate: link rate in 10kbit/s units
149 * Returns the link symbol size in bits/symbol units depending on the link
150 * rate -> channel coding.
152 int intel_dp_link_symbol_size(int rate)
154 return drm_dp_is_uhbr_rate(rate) ? 32 : 10;
158 * intel_dp_link_symbol_clock - convert link rate to link symbol clock
159 * @rate: link rate in 10kbit/s units
161 * Returns the link symbol clock frequency in kHz units depending on the
162 * link rate and channel coding.
164 int intel_dp_link_symbol_clock(int rate)
166 return DIV_ROUND_CLOSEST(rate * 10, intel_dp_link_symbol_size(rate));
169 static int max_dprx_rate(struct intel_dp *intel_dp)
171 if (intel_dp_tunnel_bw_alloc_is_enabled(intel_dp))
172 return drm_dp_tunnel_max_dprx_rate(intel_dp->tunnel);
174 return drm_dp_bw_code_to_link_rate(intel_dp->dpcd[DP_MAX_LINK_RATE]);
177 static int max_dprx_lane_count(struct intel_dp *intel_dp)
179 if (intel_dp_tunnel_bw_alloc_is_enabled(intel_dp))
180 return drm_dp_tunnel_max_dprx_lane_count(intel_dp->tunnel);
182 return drm_dp_max_lane_count(intel_dp->dpcd);
185 static void intel_dp_set_default_sink_rates(struct intel_dp *intel_dp)
187 intel_dp->sink_rates[0] = 162000;
188 intel_dp->num_sink_rates = 1;
191 /* update sink rates from dpcd */
192 static void intel_dp_set_dpcd_sink_rates(struct intel_dp *intel_dp)
194 static const int dp_rates[] = {
195 162000, 270000, 540000, 810000
200 if (drm_dp_has_quirk(&intel_dp->desc, DP_DPCD_QUIRK_CAN_DO_MAX_LINK_RATE_3_24_GBPS)) {
201 /* Needed, e.g., for Apple MBP 2017, 15 inch eDP Retina panel */
202 static const int quirk_rates[] = { 162000, 270000, 324000 };
204 memcpy(intel_dp->sink_rates, quirk_rates, sizeof(quirk_rates));
205 intel_dp->num_sink_rates = ARRAY_SIZE(quirk_rates);
211 * Sink rates for 8b/10b.
213 max_rate = max_dprx_rate(intel_dp);
214 max_lttpr_rate = drm_dp_lttpr_max_link_rate(intel_dp->lttpr_common_caps);
216 max_rate = min(max_rate, max_lttpr_rate);
218 for (i = 0; i < ARRAY_SIZE(dp_rates); i++) {
219 if (dp_rates[i] > max_rate)
221 intel_dp->sink_rates[i] = dp_rates[i];
225 * Sink rates for 128b/132b. If set, sink should support all 8b/10b
228 if (drm_dp_128b132b_supported(intel_dp->dpcd)) {
231 BUILD_BUG_ON(ARRAY_SIZE(intel_dp->sink_rates) < ARRAY_SIZE(dp_rates) + 3);
233 drm_dp_dpcd_readb(&intel_dp->aux,
234 DP_128B132B_SUPPORTED_LINK_RATES, &uhbr_rates);
236 if (drm_dp_lttpr_count(intel_dp->lttpr_common_caps)) {
237 /* We have a repeater */
238 if (intel_dp->lttpr_common_caps[0] >= 0x20 &&
239 intel_dp->lttpr_common_caps[DP_MAIN_LINK_CHANNEL_CODING_PHY_REPEATER -
240 DP_LT_TUNABLE_PHY_REPEATER_FIELD_DATA_STRUCTURE_REV] &
241 DP_PHY_REPEATER_128B132B_SUPPORTED) {
242 /* Repeater supports 128b/132b, valid UHBR rates */
243 uhbr_rates &= intel_dp->lttpr_common_caps[DP_PHY_REPEATER_128B132B_RATES -
244 DP_LT_TUNABLE_PHY_REPEATER_FIELD_DATA_STRUCTURE_REV];
246 /* Does not support 128b/132b */
251 if (uhbr_rates & DP_UHBR10)
252 intel_dp->sink_rates[i++] = 1000000;
253 if (uhbr_rates & DP_UHBR13_5)
254 intel_dp->sink_rates[i++] = 1350000;
255 if (uhbr_rates & DP_UHBR20)
256 intel_dp->sink_rates[i++] = 2000000;
259 intel_dp->num_sink_rates = i;
262 static void intel_dp_set_sink_rates(struct intel_dp *intel_dp)
264 struct intel_connector *connector = intel_dp->attached_connector;
265 struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
266 struct intel_encoder *encoder = &intel_dig_port->base;
268 intel_dp_set_dpcd_sink_rates(intel_dp);
270 if (intel_dp->num_sink_rates)
273 drm_err(&dp_to_i915(intel_dp)->drm,
274 "[CONNECTOR:%d:%s][ENCODER:%d:%s] Invalid DPCD with no link rates, using defaults\n",
275 connector->base.base.id, connector->base.name,
276 encoder->base.base.id, encoder->base.name);
278 intel_dp_set_default_sink_rates(intel_dp);
281 static void intel_dp_set_default_max_sink_lane_count(struct intel_dp *intel_dp)
283 intel_dp->max_sink_lane_count = 1;
286 static void intel_dp_set_max_sink_lane_count(struct intel_dp *intel_dp)
288 struct intel_connector *connector = intel_dp->attached_connector;
289 struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
290 struct intel_encoder *encoder = &intel_dig_port->base;
292 intel_dp->max_sink_lane_count = max_dprx_lane_count(intel_dp);
294 switch (intel_dp->max_sink_lane_count) {
301 drm_err(&dp_to_i915(intel_dp)->drm,
302 "[CONNECTOR:%d:%s][ENCODER:%d:%s] Invalid DPCD max lane count (%d), using default\n",
303 connector->base.base.id, connector->base.name,
304 encoder->base.base.id, encoder->base.name,
305 intel_dp->max_sink_lane_count);
307 intel_dp_set_default_max_sink_lane_count(intel_dp);
310 /* Get length of rates array potentially limited by max_rate. */
311 static int intel_dp_rate_limit_len(const int *rates, int len, int max_rate)
315 /* Limit results by potentially reduced max rate */
316 for (i = 0; i < len; i++) {
317 if (rates[len - i - 1] <= max_rate)
324 /* Get length of common rates array potentially limited by max_rate. */
325 static int intel_dp_common_len_rate_limit(const struct intel_dp *intel_dp,
328 return intel_dp_rate_limit_len(intel_dp->common_rates,
329 intel_dp->num_common_rates, max_rate);
332 static int intel_dp_common_rate(struct intel_dp *intel_dp, int index)
334 if (drm_WARN_ON(&dp_to_i915(intel_dp)->drm,
335 index < 0 || index >= intel_dp->num_common_rates))
338 return intel_dp->common_rates[index];
341 /* Theoretical max between source and sink */
342 int intel_dp_max_common_rate(struct intel_dp *intel_dp)
344 return intel_dp_common_rate(intel_dp, intel_dp->num_common_rates - 1);
347 static int intel_dp_max_source_lane_count(struct intel_digital_port *dig_port)
349 int vbt_max_lanes = intel_bios_dp_max_lane_count(dig_port->base.devdata);
350 int max_lanes = dig_port->max_lanes;
353 max_lanes = min(max_lanes, vbt_max_lanes);
358 /* Theoretical max between source and sink */
359 int intel_dp_max_common_lane_count(struct intel_dp *intel_dp)
361 struct intel_digital_port *dig_port = dp_to_dig_port(intel_dp);
362 int source_max = intel_dp_max_source_lane_count(dig_port);
363 int sink_max = intel_dp->max_sink_lane_count;
364 int lane_max = intel_tc_port_max_lane_count(dig_port);
365 int lttpr_max = drm_dp_lttpr_max_lane_count(intel_dp->lttpr_common_caps);
368 sink_max = min(sink_max, lttpr_max);
370 return min3(source_max, sink_max, lane_max);
373 int intel_dp_max_lane_count(struct intel_dp *intel_dp)
375 switch (intel_dp->max_link_lane_count) {
379 return intel_dp->max_link_lane_count;
381 MISSING_CASE(intel_dp->max_link_lane_count);
387 * The required data bandwidth for a mode with given pixel clock and bpp. This
388 * is the required net bandwidth independent of the data bandwidth efficiency.
390 * TODO: check if callers of this functions should use
391 * intel_dp_effective_data_rate() instead.
394 intel_dp_link_required(int pixel_clock, int bpp)
396 /* pixel_clock is in kHz, divide bpp by 8 for bit to Byte conversion */
397 return DIV_ROUND_UP(pixel_clock * bpp, 8);
401 * intel_dp_effective_data_rate - Return the pixel data rate accounting for BW allocation overhead
402 * @pixel_clock: pixel clock in kHz
403 * @bpp_x16: bits per pixel .4 fixed point format
404 * @bw_overhead: BW allocation overhead in 1ppm units
406 * Return the effective pixel data rate in kB/sec units taking into account
407 * the provided SSC, FEC, DSC BW allocation overhead.
409 int intel_dp_effective_data_rate(int pixel_clock, int bpp_x16,
412 return DIV_ROUND_UP_ULL(mul_u32_u32(pixel_clock * bpp_x16, bw_overhead),
417 * intel_dp_max_link_data_rate: Calculate the maximum rate for the given link params
418 * @intel_dp: Intel DP object
419 * @max_dprx_rate: Maximum data rate of the DPRX
420 * @max_dprx_lanes: Maximum lane count of the DPRX
422 * Calculate the maximum data rate for the provided link parameters taking into
423 * account any BW limitations by a DP tunnel attached to @intel_dp.
425 * Returns the maximum data rate in kBps units.
427 int intel_dp_max_link_data_rate(struct intel_dp *intel_dp,
428 int max_dprx_rate, int max_dprx_lanes)
430 int max_rate = drm_dp_max_dprx_data_rate(max_dprx_rate, max_dprx_lanes);
432 if (intel_dp_tunnel_bw_alloc_is_enabled(intel_dp))
433 max_rate = min(max_rate,
434 drm_dp_tunnel_available_bw(intel_dp->tunnel));
439 bool intel_dp_has_bigjoiner(struct intel_dp *intel_dp)
441 struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
442 struct intel_encoder *encoder = &intel_dig_port->base;
443 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
445 return DISPLAY_VER(dev_priv) >= 12 ||
446 (DISPLAY_VER(dev_priv) == 11 &&
447 encoder->port != PORT_A);
450 static int dg2_max_source_rate(struct intel_dp *intel_dp)
452 return intel_dp_is_edp(intel_dp) ? 810000 : 1350000;
455 static int icl_max_source_rate(struct intel_dp *intel_dp)
457 struct intel_encoder *encoder = &dp_to_dig_port(intel_dp)->base;
459 if (intel_encoder_is_combo(encoder) && !intel_dp_is_edp(intel_dp))
465 static int ehl_max_source_rate(struct intel_dp *intel_dp)
467 if (intel_dp_is_edp(intel_dp))
473 static int mtl_max_source_rate(struct intel_dp *intel_dp)
475 struct intel_encoder *encoder = &dp_to_dig_port(intel_dp)->base;
477 if (intel_encoder_is_c10phy(encoder))
483 static int vbt_max_link_rate(struct intel_dp *intel_dp)
485 struct intel_encoder *encoder = &dp_to_dig_port(intel_dp)->base;
488 max_rate = intel_bios_dp_max_link_rate(encoder->devdata);
490 if (intel_dp_is_edp(intel_dp)) {
491 struct intel_connector *connector = intel_dp->attached_connector;
492 int edp_max_rate = connector->panel.vbt.edp.max_link_rate;
494 if (max_rate && edp_max_rate)
495 max_rate = min(max_rate, edp_max_rate);
496 else if (edp_max_rate)
497 max_rate = edp_max_rate;
504 intel_dp_set_source_rates(struct intel_dp *intel_dp)
506 /* The values must be in increasing order */
507 static const int mtl_rates[] = {
508 162000, 216000, 243000, 270000, 324000, 432000, 540000, 675000,
509 810000, 1000000, 2000000,
511 static const int icl_rates[] = {
512 162000, 216000, 270000, 324000, 432000, 540000, 648000, 810000,
515 static const int bxt_rates[] = {
516 162000, 216000, 243000, 270000, 324000, 432000, 540000
518 static const int skl_rates[] = {
519 162000, 216000, 270000, 324000, 432000, 540000
521 static const int hsw_rates[] = {
522 162000, 270000, 540000
524 static const int g4x_rates[] = {
527 struct intel_digital_port *dig_port = dp_to_dig_port(intel_dp);
528 struct drm_i915_private *dev_priv = to_i915(dig_port->base.base.dev);
529 const int *source_rates;
530 int size, max_rate = 0, vbt_max_rate;
532 /* This should only be done once */
533 drm_WARN_ON(&dev_priv->drm,
534 intel_dp->source_rates || intel_dp->num_source_rates);
536 if (DISPLAY_VER(dev_priv) >= 14) {
537 source_rates = mtl_rates;
538 size = ARRAY_SIZE(mtl_rates);
539 max_rate = mtl_max_source_rate(intel_dp);
540 } else if (DISPLAY_VER(dev_priv) >= 11) {
541 source_rates = icl_rates;
542 size = ARRAY_SIZE(icl_rates);
543 if (IS_DG2(dev_priv))
544 max_rate = dg2_max_source_rate(intel_dp);
545 else if (IS_ALDERLAKE_P(dev_priv) || IS_ALDERLAKE_S(dev_priv) ||
546 IS_DG1(dev_priv) || IS_ROCKETLAKE(dev_priv))
548 else if (IS_JASPERLAKE(dev_priv) || IS_ELKHARTLAKE(dev_priv))
549 max_rate = ehl_max_source_rate(intel_dp);
551 max_rate = icl_max_source_rate(intel_dp);
552 } else if (IS_GEMINILAKE(dev_priv) || IS_BROXTON(dev_priv)) {
553 source_rates = bxt_rates;
554 size = ARRAY_SIZE(bxt_rates);
555 } else if (DISPLAY_VER(dev_priv) == 9) {
556 source_rates = skl_rates;
557 size = ARRAY_SIZE(skl_rates);
558 } else if ((IS_HASWELL(dev_priv) && !IS_HASWELL_ULX(dev_priv)) ||
559 IS_BROADWELL(dev_priv)) {
560 source_rates = hsw_rates;
561 size = ARRAY_SIZE(hsw_rates);
563 source_rates = g4x_rates;
564 size = ARRAY_SIZE(g4x_rates);
567 vbt_max_rate = vbt_max_link_rate(intel_dp);
568 if (max_rate && vbt_max_rate)
569 max_rate = min(max_rate, vbt_max_rate);
570 else if (vbt_max_rate)
571 max_rate = vbt_max_rate;
574 size = intel_dp_rate_limit_len(source_rates, size, max_rate);
576 intel_dp->source_rates = source_rates;
577 intel_dp->num_source_rates = size;
580 static int intersect_rates(const int *source_rates, int source_len,
581 const int *sink_rates, int sink_len,
584 int i = 0, j = 0, k = 0;
586 while (i < source_len && j < sink_len) {
587 if (source_rates[i] == sink_rates[j]) {
588 if (WARN_ON(k >= DP_MAX_SUPPORTED_RATES))
590 common_rates[k] = source_rates[i];
594 } else if (source_rates[i] < sink_rates[j]) {
603 /* return index of rate in rates array, or -1 if not found */
604 static int intel_dp_rate_index(const int *rates, int len, int rate)
608 for (i = 0; i < len; i++)
609 if (rate == rates[i])
615 static void intel_dp_set_common_rates(struct intel_dp *intel_dp)
617 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
619 drm_WARN_ON(&i915->drm,
620 !intel_dp->num_source_rates || !intel_dp->num_sink_rates);
622 intel_dp->num_common_rates = intersect_rates(intel_dp->source_rates,
623 intel_dp->num_source_rates,
624 intel_dp->sink_rates,
625 intel_dp->num_sink_rates,
626 intel_dp->common_rates);
628 /* Paranoia, there should always be something in common. */
629 if (drm_WARN_ON(&i915->drm, intel_dp->num_common_rates == 0)) {
630 intel_dp->common_rates[0] = 162000;
631 intel_dp->num_common_rates = 1;
635 static bool intel_dp_link_params_valid(struct intel_dp *intel_dp, int link_rate,
639 * FIXME: we need to synchronize the current link parameters with
640 * hardware readout. Currently fast link training doesn't work on
643 if (link_rate == 0 ||
644 link_rate > intel_dp->max_link_rate)
647 if (lane_count == 0 ||
648 lane_count > intel_dp_max_lane_count(intel_dp))
654 static bool intel_dp_can_link_train_fallback_for_edp(struct intel_dp *intel_dp,
658 /* FIXME figure out what we actually want here */
659 const struct drm_display_mode *fixed_mode =
660 intel_panel_preferred_fixed_mode(intel_dp->attached_connector);
661 int mode_rate, max_rate;
663 mode_rate = intel_dp_link_required(fixed_mode->clock, 18);
664 max_rate = intel_dp_max_link_data_rate(intel_dp, link_rate, lane_count);
665 if (mode_rate > max_rate)
671 int intel_dp_get_link_train_fallback_values(struct intel_dp *intel_dp,
672 int link_rate, u8 lane_count)
674 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
678 * TODO: Enable fallback on MST links once MST link compute can handle
679 * the fallback params.
681 if (intel_dp->is_mst) {
682 drm_err(&i915->drm, "Link Training Unsuccessful\n");
686 if (intel_dp_is_edp(intel_dp) && !intel_dp->use_max_params) {
687 drm_dbg_kms(&i915->drm,
688 "Retrying Link training for eDP with max parameters\n");
689 intel_dp->use_max_params = true;
693 index = intel_dp_rate_index(intel_dp->common_rates,
694 intel_dp->num_common_rates,
697 if (intel_dp_is_edp(intel_dp) &&
698 !intel_dp_can_link_train_fallback_for_edp(intel_dp,
699 intel_dp_common_rate(intel_dp, index - 1),
701 drm_dbg_kms(&i915->drm,
702 "Retrying Link training for eDP with same parameters\n");
705 intel_dp->max_link_rate = intel_dp_common_rate(intel_dp, index - 1);
706 intel_dp->max_link_lane_count = lane_count;
707 } else if (lane_count > 1) {
708 if (intel_dp_is_edp(intel_dp) &&
709 !intel_dp_can_link_train_fallback_for_edp(intel_dp,
710 intel_dp_max_common_rate(intel_dp),
712 drm_dbg_kms(&i915->drm,
713 "Retrying Link training for eDP with same parameters\n");
716 intel_dp->max_link_rate = intel_dp_max_common_rate(intel_dp);
717 intel_dp->max_link_lane_count = lane_count >> 1;
719 drm_err(&i915->drm, "Link Training Unsuccessful\n");
726 u32 intel_dp_mode_to_fec_clock(u32 mode_clock)
728 return div_u64(mul_u32_u32(mode_clock, DP_DSC_FEC_OVERHEAD_FACTOR),
732 int intel_dp_bw_fec_overhead(bool fec_enabled)
735 * TODO: Calculate the actual overhead for a given mode.
736 * The hard-coded 1/0.972261=2.853% overhead factor
737 * corresponds (for instance) to the 8b/10b DP FEC 2.4% +
738 * 0.453% DSC overhead. This is enough for a 3840 width mode,
739 * which has a DSC overhead of up to ~0.2%, but may not be
740 * enough for a 1024 width mode where this is ~0.8% (on a 4
741 * lane DP link, with 2 DSC slices and 8 bpp color depth).
743 return fec_enabled ? DP_DSC_FEC_OVERHEAD_FACTOR : 1000000;
747 small_joiner_ram_size_bits(struct drm_i915_private *i915)
749 if (DISPLAY_VER(i915) >= 13)
751 else if (DISPLAY_VER(i915) >= 11)
757 u32 intel_dp_dsc_nearest_valid_bpp(struct drm_i915_private *i915, u32 bpp, u32 pipe_bpp)
759 u32 bits_per_pixel = bpp;
762 /* Error out if the max bpp is less than smallest allowed valid bpp */
763 if (bits_per_pixel < valid_dsc_bpp[0]) {
764 drm_dbg_kms(&i915->drm, "Unsupported BPP %u, min %u\n",
765 bits_per_pixel, valid_dsc_bpp[0]);
769 /* From XE_LPD onwards we support from bpc upto uncompressed bpp-1 BPPs */
770 if (DISPLAY_VER(i915) >= 13) {
771 bits_per_pixel = min(bits_per_pixel, pipe_bpp - 1);
774 * According to BSpec, 27 is the max DSC output bpp,
775 * 8 is the min DSC output bpp.
776 * While we can still clamp higher bpp values to 27, saving bandwidth,
777 * if it is required to oompress up to bpp < 8, means we can't do
778 * that and probably means we can't fit the required mode, even with
781 if (bits_per_pixel < 8) {
782 drm_dbg_kms(&i915->drm, "Unsupported BPP %u, min 8\n",
786 bits_per_pixel = min_t(u32, bits_per_pixel, 27);
788 /* Find the nearest match in the array of known BPPs from VESA */
789 for (i = 0; i < ARRAY_SIZE(valid_dsc_bpp) - 1; i++) {
790 if (bits_per_pixel < valid_dsc_bpp[i + 1])
793 drm_dbg_kms(&i915->drm, "Set dsc bpp from %d to VESA %d\n",
794 bits_per_pixel, valid_dsc_bpp[i]);
796 bits_per_pixel = valid_dsc_bpp[i];
799 return bits_per_pixel;
803 u32 get_max_compressed_bpp_with_joiner(struct drm_i915_private *i915,
804 u32 mode_clock, u32 mode_hdisplay,
807 u32 max_bpp_small_joiner_ram;
809 /* Small Joiner Check: output bpp <= joiner RAM (bits) / Horiz. width */
810 max_bpp_small_joiner_ram = small_joiner_ram_size_bits(i915) / mode_hdisplay;
813 int bigjoiner_interface_bits = DISPLAY_VER(i915) >= 14 ? 36 : 24;
814 /* With bigjoiner multiple dsc engines are used in parallel so PPC is 2 */
816 u32 max_bpp_bigjoiner =
817 i915->display.cdclk.max_cdclk_freq * ppc * bigjoiner_interface_bits /
818 intel_dp_mode_to_fec_clock(mode_clock);
820 max_bpp_small_joiner_ram *= 2;
822 return min(max_bpp_small_joiner_ram, max_bpp_bigjoiner);
825 return max_bpp_small_joiner_ram;
828 u16 intel_dp_dsc_get_max_compressed_bpp(struct drm_i915_private *i915,
829 u32 link_clock, u32 lane_count,
830 u32 mode_clock, u32 mode_hdisplay,
832 enum intel_output_format output_format,
836 u32 bits_per_pixel, joiner_max_bpp;
839 * Available Link Bandwidth(Kbits/sec) = (NumberOfLanes)*
840 * (LinkSymbolClock)* 8 * (TimeSlots / 64)
841 * for SST -> TimeSlots is 64(i.e all TimeSlots that are available)
842 * for MST -> TimeSlots has to be calculated, based on mode requirements
844 * Due to FEC overhead, the available bw is reduced to 97.2261%.
845 * To support the given mode:
846 * Bandwidth required should be <= Available link Bandwidth * FEC Overhead
847 * =>ModeClock * bits_per_pixel <= Available Link Bandwidth * FEC Overhead
848 * =>bits_per_pixel <= Available link Bandwidth * FEC Overhead / ModeClock
849 * =>bits_per_pixel <= (NumberOfLanes * LinkSymbolClock) * 8 (TimeSlots / 64) /
850 * (ModeClock / FEC Overhead)
851 * =>bits_per_pixel <= (NumberOfLanes * LinkSymbolClock * TimeSlots) /
852 * (ModeClock / FEC Overhead * 8)
854 bits_per_pixel = ((link_clock * lane_count) * timeslots) /
855 (intel_dp_mode_to_fec_clock(mode_clock) * 8);
857 /* Bandwidth required for 420 is half, that of 444 format */
858 if (output_format == INTEL_OUTPUT_FORMAT_YCBCR420)
862 * According to DSC 1.2a Section 4.1.1 Table 4.1 the maximum
863 * supported PPS value can be 63.9375 and with the further
864 * mention that for 420, 422 formats, bpp should be programmed double
865 * the target bpp restricting our target bpp to be 31.9375 at max.
867 if (output_format == INTEL_OUTPUT_FORMAT_YCBCR420)
868 bits_per_pixel = min_t(u32, bits_per_pixel, 31);
870 drm_dbg_kms(&i915->drm, "Max link bpp is %u for %u timeslots "
871 "total bw %u pixel clock %u\n",
872 bits_per_pixel, timeslots,
873 (link_clock * lane_count * 8),
874 intel_dp_mode_to_fec_clock(mode_clock));
876 joiner_max_bpp = get_max_compressed_bpp_with_joiner(i915, mode_clock,
877 mode_hdisplay, bigjoiner);
878 bits_per_pixel = min(bits_per_pixel, joiner_max_bpp);
880 bits_per_pixel = intel_dp_dsc_nearest_valid_bpp(i915, bits_per_pixel, pipe_bpp);
882 return bits_per_pixel;
885 u8 intel_dp_dsc_get_slice_count(const struct intel_connector *connector,
886 int mode_clock, int mode_hdisplay,
889 struct drm_i915_private *i915 = to_i915(connector->base.dev);
890 u8 min_slice_count, i;
893 if (mode_clock <= DP_DSC_PEAK_PIXEL_RATE)
894 min_slice_count = DIV_ROUND_UP(mode_clock,
895 DP_DSC_MAX_ENC_THROUGHPUT_0);
897 min_slice_count = DIV_ROUND_UP(mode_clock,
898 DP_DSC_MAX_ENC_THROUGHPUT_1);
901 * Due to some DSC engine BW limitations, we need to enable second
902 * slice and VDSC engine, whenever we approach close enough to max CDCLK
904 if (mode_clock >= ((i915->display.cdclk.max_cdclk_freq * 85) / 100))
905 min_slice_count = max_t(u8, min_slice_count, 2);
907 max_slice_width = drm_dp_dsc_sink_max_slice_width(connector->dp.dsc_dpcd);
908 if (max_slice_width < DP_DSC_MIN_SLICE_WIDTH_VALUE) {
909 drm_dbg_kms(&i915->drm,
910 "Unsupported slice width %d by DP DSC Sink device\n",
914 /* Also take into account max slice width */
915 min_slice_count = max_t(u8, min_slice_count,
916 DIV_ROUND_UP(mode_hdisplay,
919 /* Find the closest match to the valid slice count values */
920 for (i = 0; i < ARRAY_SIZE(valid_dsc_slicecount); i++) {
921 u8 test_slice_count = valid_dsc_slicecount[i] << bigjoiner;
923 if (test_slice_count >
924 drm_dp_dsc_sink_max_slice_count(connector->dp.dsc_dpcd, false))
927 /* big joiner needs small joiner to be enabled */
928 if (bigjoiner && test_slice_count < 4)
931 if (min_slice_count <= test_slice_count)
932 return test_slice_count;
935 drm_dbg_kms(&i915->drm, "Unsupported Slice Count %d\n",
940 static bool source_can_output(struct intel_dp *intel_dp,
941 enum intel_output_format format)
943 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
946 case INTEL_OUTPUT_FORMAT_RGB:
949 case INTEL_OUTPUT_FORMAT_YCBCR444:
951 * No YCbCr output support on gmch platforms.
952 * Also, ILK doesn't seem capable of DP YCbCr output.
953 * The displayed image is severly corrupted. SNB+ is fine.
955 return !HAS_GMCH(i915) && !IS_IRONLAKE(i915);
957 case INTEL_OUTPUT_FORMAT_YCBCR420:
958 /* Platform < Gen 11 cannot output YCbCr420 format */
959 return DISPLAY_VER(i915) >= 11;
962 MISSING_CASE(format);
968 dfp_can_convert_from_rgb(struct intel_dp *intel_dp,
969 enum intel_output_format sink_format)
971 if (!drm_dp_is_branch(intel_dp->dpcd))
974 if (sink_format == INTEL_OUTPUT_FORMAT_YCBCR444)
975 return intel_dp->dfp.rgb_to_ycbcr;
977 if (sink_format == INTEL_OUTPUT_FORMAT_YCBCR420)
978 return intel_dp->dfp.rgb_to_ycbcr &&
979 intel_dp->dfp.ycbcr_444_to_420;
985 dfp_can_convert_from_ycbcr444(struct intel_dp *intel_dp,
986 enum intel_output_format sink_format)
988 if (!drm_dp_is_branch(intel_dp->dpcd))
991 if (sink_format == INTEL_OUTPUT_FORMAT_YCBCR420)
992 return intel_dp->dfp.ycbcr_444_to_420;
998 dfp_can_convert(struct intel_dp *intel_dp,
999 enum intel_output_format output_format,
1000 enum intel_output_format sink_format)
1002 switch (output_format) {
1003 case INTEL_OUTPUT_FORMAT_RGB:
1004 return dfp_can_convert_from_rgb(intel_dp, sink_format);
1005 case INTEL_OUTPUT_FORMAT_YCBCR444:
1006 return dfp_can_convert_from_ycbcr444(intel_dp, sink_format);
1008 MISSING_CASE(output_format);
1015 static enum intel_output_format
1016 intel_dp_output_format(struct intel_connector *connector,
1017 enum intel_output_format sink_format)
1019 struct intel_dp *intel_dp = intel_attached_dp(connector);
1020 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
1021 enum intel_output_format force_dsc_output_format =
1022 intel_dp->force_dsc_output_format;
1023 enum intel_output_format output_format;
1024 if (force_dsc_output_format) {
1025 if (source_can_output(intel_dp, force_dsc_output_format) &&
1026 (!drm_dp_is_branch(intel_dp->dpcd) ||
1027 sink_format != force_dsc_output_format ||
1028 dfp_can_convert(intel_dp, force_dsc_output_format, sink_format)))
1029 return force_dsc_output_format;
1031 drm_dbg_kms(&i915->drm, "Cannot force DSC output format\n");
1034 if (sink_format == INTEL_OUTPUT_FORMAT_RGB ||
1035 dfp_can_convert_from_rgb(intel_dp, sink_format))
1036 output_format = INTEL_OUTPUT_FORMAT_RGB;
1038 else if (sink_format == INTEL_OUTPUT_FORMAT_YCBCR444 ||
1039 dfp_can_convert_from_ycbcr444(intel_dp, sink_format))
1040 output_format = INTEL_OUTPUT_FORMAT_YCBCR444;
1043 output_format = INTEL_OUTPUT_FORMAT_YCBCR420;
1045 drm_WARN_ON(&i915->drm, !source_can_output(intel_dp, output_format));
1047 return output_format;
1050 int intel_dp_min_bpp(enum intel_output_format output_format)
1052 if (output_format == INTEL_OUTPUT_FORMAT_RGB)
1058 int intel_dp_output_bpp(enum intel_output_format output_format, int bpp)
1061 * bpp value was assumed to RGB format. And YCbCr 4:2:0 output
1062 * format of the number of bytes per pixel will be half the number
1063 * of bytes of RGB pixel.
1065 if (output_format == INTEL_OUTPUT_FORMAT_YCBCR420)
1071 static enum intel_output_format
1072 intel_dp_sink_format(struct intel_connector *connector,
1073 const struct drm_display_mode *mode)
1075 const struct drm_display_info *info = &connector->base.display_info;
1077 if (drm_mode_is_420_only(info, mode))
1078 return INTEL_OUTPUT_FORMAT_YCBCR420;
1080 return INTEL_OUTPUT_FORMAT_RGB;
1084 intel_dp_mode_min_output_bpp(struct intel_connector *connector,
1085 const struct drm_display_mode *mode)
1087 enum intel_output_format output_format, sink_format;
1089 sink_format = intel_dp_sink_format(connector, mode);
1091 output_format = intel_dp_output_format(connector, sink_format);
1093 return intel_dp_output_bpp(output_format, intel_dp_min_bpp(output_format));
1096 static bool intel_dp_hdisplay_bad(struct drm_i915_private *dev_priv,
1100 * Older platforms don't like hdisplay==4096 with DP.
1102 * On ILK/SNB/IVB the pipe seems to be somewhat running (scanline
1103 * and frame counter increment), but we don't get vblank interrupts,
1104 * and the pipe underruns immediately. The link also doesn't seem
1105 * to get trained properly.
1107 * On CHV the vblank interrupts don't seem to disappear but
1108 * otherwise the symptoms are similar.
1110 * TODO: confirm the behaviour on HSW+
1112 return hdisplay == 4096 && !HAS_DDI(dev_priv);
1115 static int intel_dp_max_tmds_clock(struct intel_dp *intel_dp)
1117 struct intel_connector *connector = intel_dp->attached_connector;
1118 const struct drm_display_info *info = &connector->base.display_info;
1119 int max_tmds_clock = intel_dp->dfp.max_tmds_clock;
1121 /* Only consider the sink's max TMDS clock if we know this is a HDMI DFP */
1122 if (max_tmds_clock && info->max_tmds_clock)
1123 max_tmds_clock = min(max_tmds_clock, info->max_tmds_clock);
1125 return max_tmds_clock;
1128 static enum drm_mode_status
1129 intel_dp_tmds_clock_valid(struct intel_dp *intel_dp,
1131 enum intel_output_format sink_format,
1132 bool respect_downstream_limits)
1134 int tmds_clock, min_tmds_clock, max_tmds_clock;
1136 if (!respect_downstream_limits)
1139 tmds_clock = intel_hdmi_tmds_clock(clock, bpc, sink_format);
1141 min_tmds_clock = intel_dp->dfp.min_tmds_clock;
1142 max_tmds_clock = intel_dp_max_tmds_clock(intel_dp);
1144 if (min_tmds_clock && tmds_clock < min_tmds_clock)
1145 return MODE_CLOCK_LOW;
1147 if (max_tmds_clock && tmds_clock > max_tmds_clock)
1148 return MODE_CLOCK_HIGH;
1153 static enum drm_mode_status
1154 intel_dp_mode_valid_downstream(struct intel_connector *connector,
1155 const struct drm_display_mode *mode,
1158 struct intel_dp *intel_dp = intel_attached_dp(connector);
1159 const struct drm_display_info *info = &connector->base.display_info;
1160 enum drm_mode_status status;
1161 enum intel_output_format sink_format;
1163 /* If PCON supports FRL MODE, check FRL bandwidth constraints */
1164 if (intel_dp->dfp.pcon_max_frl_bw) {
1167 int bpp = intel_dp_mode_min_output_bpp(connector, mode);
1169 target_bw = bpp * target_clock;
1171 max_frl_bw = intel_dp->dfp.pcon_max_frl_bw;
1173 /* converting bw from Gbps to Kbps*/
1174 max_frl_bw = max_frl_bw * 1000000;
1176 if (target_bw > max_frl_bw)
1177 return MODE_CLOCK_HIGH;
1182 if (intel_dp->dfp.max_dotclock &&
1183 target_clock > intel_dp->dfp.max_dotclock)
1184 return MODE_CLOCK_HIGH;
1186 sink_format = intel_dp_sink_format(connector, mode);
1188 /* Assume 8bpc for the DP++/HDMI/DVI TMDS clock check */
1189 status = intel_dp_tmds_clock_valid(intel_dp, target_clock,
1190 8, sink_format, true);
1192 if (status != MODE_OK) {
1193 if (sink_format == INTEL_OUTPUT_FORMAT_YCBCR420 ||
1194 !connector->base.ycbcr_420_allowed ||
1195 !drm_mode_is_420_also(info, mode))
1197 sink_format = INTEL_OUTPUT_FORMAT_YCBCR420;
1198 status = intel_dp_tmds_clock_valid(intel_dp, target_clock,
1199 8, sink_format, true);
1200 if (status != MODE_OK)
1207 bool intel_dp_need_bigjoiner(struct intel_dp *intel_dp,
1208 struct intel_connector *connector,
1209 int hdisplay, int clock)
1211 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
1213 if (!intel_dp_has_bigjoiner(intel_dp))
1216 return clock > i915->display.cdclk.max_dotclk_freq || hdisplay > 5120 ||
1217 connector->force_bigjoiner_enable;
1220 static enum drm_mode_status
1221 intel_dp_mode_valid(struct drm_connector *_connector,
1222 struct drm_display_mode *mode)
1224 struct intel_connector *connector = to_intel_connector(_connector);
1225 struct intel_dp *intel_dp = intel_attached_dp(connector);
1226 struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
1227 const struct drm_display_mode *fixed_mode;
1228 int target_clock = mode->clock;
1229 int max_rate, mode_rate, max_lanes, max_link_clock;
1230 int max_dotclk = dev_priv->display.cdclk.max_dotclk_freq;
1231 u16 dsc_max_compressed_bpp = 0;
1232 u8 dsc_slice_count = 0;
1233 enum drm_mode_status status;
1234 bool dsc = false, bigjoiner = false;
1236 status = intel_cpu_transcoder_mode_valid(dev_priv, mode);
1237 if (status != MODE_OK)
1240 if (mode->flags & DRM_MODE_FLAG_DBLCLK)
1241 return MODE_H_ILLEGAL;
1243 if (mode->clock < 10000)
1244 return MODE_CLOCK_LOW;
1246 fixed_mode = intel_panel_fixed_mode(connector, mode);
1247 if (intel_dp_is_edp(intel_dp) && fixed_mode) {
1248 status = intel_panel_mode_valid(connector, mode);
1249 if (status != MODE_OK)
1252 target_clock = fixed_mode->clock;
1255 if (intel_dp_need_bigjoiner(intel_dp, connector,
1256 mode->hdisplay, target_clock)) {
1260 if (target_clock > max_dotclk)
1261 return MODE_CLOCK_HIGH;
1263 if (intel_dp_hdisplay_bad(dev_priv, mode->hdisplay))
1264 return MODE_H_ILLEGAL;
1266 max_link_clock = intel_dp_max_link_rate(intel_dp);
1267 max_lanes = intel_dp_max_lane_count(intel_dp);
1269 max_rate = intel_dp_max_link_data_rate(intel_dp, max_link_clock, max_lanes);
1271 mode_rate = intel_dp_link_required(target_clock,
1272 intel_dp_mode_min_output_bpp(connector, mode));
1274 if (HAS_DSC(dev_priv) &&
1275 drm_dp_sink_supports_dsc(connector->dp.dsc_dpcd)) {
1276 enum intel_output_format sink_format, output_format;
1279 sink_format = intel_dp_sink_format(connector, mode);
1280 output_format = intel_dp_output_format(connector, sink_format);
1282 * TBD pass the connector BPC,
1283 * for now U8_MAX so that max BPC on that platform would be picked
1285 pipe_bpp = intel_dp_dsc_compute_max_bpp(connector, U8_MAX);
1288 * Output bpp is stored in 6.4 format so right shift by 4 to get the
1289 * integer value since we support only integer values of bpp.
1291 if (intel_dp_is_edp(intel_dp)) {
1292 dsc_max_compressed_bpp =
1293 drm_edp_dsc_sink_output_bpp(connector->dp.dsc_dpcd) >> 4;
1295 drm_dp_dsc_sink_max_slice_count(connector->dp.dsc_dpcd,
1297 } else if (drm_dp_sink_supports_fec(connector->dp.fec_capability)) {
1298 dsc_max_compressed_bpp =
1299 intel_dp_dsc_get_max_compressed_bpp(dev_priv,
1308 intel_dp_dsc_get_slice_count(connector,
1314 dsc = dsc_max_compressed_bpp && dsc_slice_count;
1317 if (intel_dp_joiner_needs_dsc(dev_priv, bigjoiner) && !dsc)
1318 return MODE_CLOCK_HIGH;
1320 if (mode_rate > max_rate && !dsc)
1321 return MODE_CLOCK_HIGH;
1323 status = intel_dp_mode_valid_downstream(connector, mode, target_clock);
1324 if (status != MODE_OK)
1327 return intel_mode_valid_max_plane_size(dev_priv, mode, bigjoiner);
1330 bool intel_dp_source_supports_tps3(struct drm_i915_private *i915)
1332 return DISPLAY_VER(i915) >= 9 || IS_BROADWELL(i915) || IS_HASWELL(i915);
1335 bool intel_dp_source_supports_tps4(struct drm_i915_private *i915)
1337 return DISPLAY_VER(i915) >= 10;
1340 static void snprintf_int_array(char *str, size_t len,
1341 const int *array, int nelem)
1347 for (i = 0; i < nelem; i++) {
1348 int r = snprintf(str, len, "%s%d", i ? ", " : "", array[i]);
1356 static void intel_dp_print_rates(struct intel_dp *intel_dp)
1358 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
1359 char str[128]; /* FIXME: too big for stack? */
1361 if (!drm_debug_enabled(DRM_UT_KMS))
1364 snprintf_int_array(str, sizeof(str),
1365 intel_dp->source_rates, intel_dp->num_source_rates);
1366 drm_dbg_kms(&i915->drm, "source rates: %s\n", str);
1368 snprintf_int_array(str, sizeof(str),
1369 intel_dp->sink_rates, intel_dp->num_sink_rates);
1370 drm_dbg_kms(&i915->drm, "sink rates: %s\n", str);
1372 snprintf_int_array(str, sizeof(str),
1373 intel_dp->common_rates, intel_dp->num_common_rates);
1374 drm_dbg_kms(&i915->drm, "common rates: %s\n", str);
1378 intel_dp_max_link_rate(struct intel_dp *intel_dp)
1382 len = intel_dp_common_len_rate_limit(intel_dp, intel_dp->max_link_rate);
1384 return intel_dp_common_rate(intel_dp, len - 1);
1387 int intel_dp_rate_select(struct intel_dp *intel_dp, int rate)
1389 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
1390 int i = intel_dp_rate_index(intel_dp->sink_rates,
1391 intel_dp->num_sink_rates, rate);
1393 if (drm_WARN_ON(&i915->drm, i < 0))
1399 void intel_dp_compute_rate(struct intel_dp *intel_dp, int port_clock,
1400 u8 *link_bw, u8 *rate_select)
1402 /* eDP 1.4 rate select method. */
1403 if (intel_dp->use_rate_select) {
1406 intel_dp_rate_select(intel_dp, port_clock);
1408 *link_bw = drm_dp_link_rate_to_bw_code(port_clock);
1413 bool intel_dp_has_hdmi_sink(struct intel_dp *intel_dp)
1415 struct intel_connector *connector = intel_dp->attached_connector;
1417 return connector->base.display_info.is_hdmi;
1420 static bool intel_dp_source_supports_fec(struct intel_dp *intel_dp,
1421 const struct intel_crtc_state *pipe_config)
1423 struct intel_encoder *encoder = &dp_to_dig_port(intel_dp)->base;
1424 struct drm_i915_private *dev_priv = dp_to_i915(intel_dp);
1426 if (DISPLAY_VER(dev_priv) >= 12)
1429 if (DISPLAY_VER(dev_priv) == 11 && encoder->port != PORT_A &&
1430 !intel_crtc_has_type(pipe_config, INTEL_OUTPUT_DP_MST))
1436 bool intel_dp_supports_fec(struct intel_dp *intel_dp,
1437 const struct intel_connector *connector,
1438 const struct intel_crtc_state *pipe_config)
1440 return intel_dp_source_supports_fec(intel_dp, pipe_config) &&
1441 drm_dp_sink_supports_fec(connector->dp.fec_capability);
1444 static bool intel_dp_supports_dsc(const struct intel_connector *connector,
1445 const struct intel_crtc_state *crtc_state)
1447 if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_DP) && !crtc_state->fec_enable)
1450 return intel_dsc_source_support(crtc_state) &&
1451 connector->dp.dsc_decompression_aux &&
1452 drm_dp_sink_supports_dsc(connector->dp.dsc_dpcd);
1455 static int intel_dp_hdmi_compute_bpc(struct intel_dp *intel_dp,
1456 const struct intel_crtc_state *crtc_state,
1457 int bpc, bool respect_downstream_limits)
1459 int clock = crtc_state->hw.adjusted_mode.crtc_clock;
1462 * Current bpc could already be below 8bpc due to
1463 * FDI bandwidth constraints or other limits.
1464 * HDMI minimum is 8bpc however.
1469 * We will never exceed downstream TMDS clock limits while
1470 * attempting deep color. If the user insists on forcing an
1471 * out of spec mode they will have to be satisfied with 8bpc.
1473 if (!respect_downstream_limits)
1476 for (; bpc >= 8; bpc -= 2) {
1477 if (intel_hdmi_bpc_possible(crtc_state, bpc,
1478 intel_dp_has_hdmi_sink(intel_dp)) &&
1479 intel_dp_tmds_clock_valid(intel_dp, clock, bpc, crtc_state->sink_format,
1480 respect_downstream_limits) == MODE_OK)
1487 static int intel_dp_max_bpp(struct intel_dp *intel_dp,
1488 const struct intel_crtc_state *crtc_state,
1489 bool respect_downstream_limits)
1491 struct drm_i915_private *dev_priv = dp_to_i915(intel_dp);
1492 struct intel_connector *intel_connector = intel_dp->attached_connector;
1495 bpc = crtc_state->pipe_bpp / 3;
1497 if (intel_dp->dfp.max_bpc)
1498 bpc = min_t(int, bpc, intel_dp->dfp.max_bpc);
1500 if (intel_dp->dfp.min_tmds_clock) {
1503 max_hdmi_bpc = intel_dp_hdmi_compute_bpc(intel_dp, crtc_state, bpc,
1504 respect_downstream_limits);
1505 if (max_hdmi_bpc < 0)
1508 bpc = min(bpc, max_hdmi_bpc);
1512 if (intel_dp_is_edp(intel_dp)) {
1513 /* Get bpp from vbt only for panels that dont have bpp in edid */
1514 if (intel_connector->base.display_info.bpc == 0 &&
1515 intel_connector->panel.vbt.edp.bpp &&
1516 intel_connector->panel.vbt.edp.bpp < bpp) {
1517 drm_dbg_kms(&dev_priv->drm,
1518 "clamping bpp for eDP panel to BIOS-provided %i\n",
1519 intel_connector->panel.vbt.edp.bpp);
1520 bpp = intel_connector->panel.vbt.edp.bpp;
1527 /* Adjust link config limits based on compliance test requests. */
1529 intel_dp_adjust_compliance_config(struct intel_dp *intel_dp,
1530 struct intel_crtc_state *pipe_config,
1531 struct link_config_limits *limits)
1533 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
1535 /* For DP Compliance we override the computed bpp for the pipe */
1536 if (intel_dp->compliance.test_data.bpc != 0) {
1537 int bpp = 3 * intel_dp->compliance.test_data.bpc;
1539 limits->pipe.min_bpp = limits->pipe.max_bpp = bpp;
1540 pipe_config->dither_force_disable = bpp == 6 * 3;
1542 drm_dbg_kms(&i915->drm, "Setting pipe_bpp to %d\n", bpp);
1545 /* Use values requested by Compliance Test Request */
1546 if (intel_dp->compliance.test_type == DP_TEST_LINK_TRAINING) {
1549 /* Validate the compliance test data since max values
1550 * might have changed due to link train fallback.
1552 if (intel_dp_link_params_valid(intel_dp, intel_dp->compliance.test_link_rate,
1553 intel_dp->compliance.test_lane_count)) {
1554 index = intel_dp_rate_index(intel_dp->common_rates,
1555 intel_dp->num_common_rates,
1556 intel_dp->compliance.test_link_rate);
1558 limits->min_rate = limits->max_rate =
1559 intel_dp->compliance.test_link_rate;
1560 limits->min_lane_count = limits->max_lane_count =
1561 intel_dp->compliance.test_lane_count;
1566 static bool has_seamless_m_n(struct intel_connector *connector)
1568 struct drm_i915_private *i915 = to_i915(connector->base.dev);
1571 * Seamless M/N reprogramming only implemented
1572 * for BDW+ double buffered M/N registers so far.
1574 return HAS_DOUBLE_BUFFERED_M_N(i915) &&
1575 intel_panel_drrs_type(connector) == DRRS_TYPE_SEAMLESS;
1578 static int intel_dp_mode_clock(const struct intel_crtc_state *crtc_state,
1579 const struct drm_connector_state *conn_state)
1581 struct intel_connector *connector = to_intel_connector(conn_state->connector);
1582 const struct drm_display_mode *adjusted_mode = &crtc_state->hw.adjusted_mode;
1584 /* FIXME a bit of a mess wrt clock vs. crtc_clock */
1585 if (has_seamless_m_n(connector))
1586 return intel_panel_highest_mode(connector, adjusted_mode)->clock;
1588 return adjusted_mode->crtc_clock;
1591 /* Optimize link config in order: max bpp, min clock, min lanes */
1593 intel_dp_compute_link_config_wide(struct intel_dp *intel_dp,
1594 struct intel_crtc_state *pipe_config,
1595 const struct drm_connector_state *conn_state,
1596 const struct link_config_limits *limits)
1598 int bpp, i, lane_count, clock = intel_dp_mode_clock(pipe_config, conn_state);
1599 int mode_rate, link_rate, link_avail;
1601 for (bpp = to_bpp_int(limits->link.max_bpp_x16);
1602 bpp >= to_bpp_int(limits->link.min_bpp_x16);
1604 int link_bpp = intel_dp_output_bpp(pipe_config->output_format, bpp);
1606 mode_rate = intel_dp_link_required(clock, link_bpp);
1608 for (i = 0; i < intel_dp->num_common_rates; i++) {
1609 link_rate = intel_dp_common_rate(intel_dp, i);
1610 if (link_rate < limits->min_rate ||
1611 link_rate > limits->max_rate)
1614 for (lane_count = limits->min_lane_count;
1615 lane_count <= limits->max_lane_count;
1617 link_avail = intel_dp_max_link_data_rate(intel_dp,
1622 if (mode_rate <= link_avail) {
1623 pipe_config->lane_count = lane_count;
1624 pipe_config->pipe_bpp = bpp;
1625 pipe_config->port_clock = link_rate;
1637 u8 intel_dp_dsc_max_src_input_bpc(struct drm_i915_private *i915)
1639 /* Max DSC Input BPC for ICL is 10 and for TGL+ is 12 */
1640 if (DISPLAY_VER(i915) >= 12)
1642 if (DISPLAY_VER(i915) == 11)
1648 int intel_dp_dsc_compute_max_bpp(const struct intel_connector *connector,
1651 struct drm_i915_private *i915 = to_i915(connector->base.dev);
1656 dsc_max_bpc = intel_dp_dsc_max_src_input_bpc(i915);
1661 dsc_max_bpc = min_t(u8, dsc_max_bpc, max_req_bpc);
1663 num_bpc = drm_dp_dsc_sink_supported_input_bpcs(connector->dp.dsc_dpcd,
1665 for (i = 0; i < num_bpc; i++) {
1666 if (dsc_max_bpc >= dsc_bpc[i])
1667 return dsc_bpc[i] * 3;
1673 static int intel_dp_source_dsc_version_minor(struct drm_i915_private *i915)
1675 return DISPLAY_VER(i915) >= 14 ? 2 : 1;
1678 static int intel_dp_sink_dsc_version_minor(const u8 dsc_dpcd[DP_DSC_RECEIVER_CAP_SIZE])
1680 return (dsc_dpcd[DP_DSC_REV - DP_DSC_SUPPORT] & DP_DSC_MINOR_MASK) >>
1684 static int intel_dp_get_slice_height(int vactive)
1689 * VDSC 1.2a spec in Section 3.8 Options for Slices implies that 108
1690 * lines is an optimal slice height, but any size can be used as long as
1691 * vertical active integer multiple and maximum vertical slice count
1692 * requirements are met.
1694 for (slice_height = 108; slice_height <= vactive; slice_height += 2)
1695 if (vactive % slice_height == 0)
1696 return slice_height;
1699 * Highly unlikely we reach here as most of the resolutions will end up
1700 * finding appropriate slice_height in above loop but returning
1701 * slice_height as 2 here as it should work with all resolutions.
1706 static int intel_dp_dsc_compute_params(const struct intel_connector *connector,
1707 struct intel_crtc_state *crtc_state)
1709 struct drm_i915_private *i915 = to_i915(connector->base.dev);
1710 struct drm_dsc_config *vdsc_cfg = &crtc_state->dsc.config;
1714 * RC_MODEL_SIZE is currently a constant across all configurations.
1716 * FIXME: Look into using sink defined DPCD DP_DSC_RC_BUF_BLK_SIZE and
1717 * DP_DSC_RC_BUF_SIZE for this.
1719 vdsc_cfg->rc_model_size = DSC_RC_MODEL_SIZE_CONST;
1720 vdsc_cfg->pic_height = crtc_state->hw.adjusted_mode.crtc_vdisplay;
1722 vdsc_cfg->slice_height = intel_dp_get_slice_height(vdsc_cfg->pic_height);
1724 ret = intel_dsc_compute_params(crtc_state);
1728 vdsc_cfg->dsc_version_major =
1729 (connector->dp.dsc_dpcd[DP_DSC_REV - DP_DSC_SUPPORT] &
1730 DP_DSC_MAJOR_MASK) >> DP_DSC_MAJOR_SHIFT;
1731 vdsc_cfg->dsc_version_minor =
1732 min(intel_dp_source_dsc_version_minor(i915),
1733 intel_dp_sink_dsc_version_minor(connector->dp.dsc_dpcd));
1734 if (vdsc_cfg->convert_rgb)
1735 vdsc_cfg->convert_rgb =
1736 connector->dp.dsc_dpcd[DP_DSC_DEC_COLOR_FORMAT_CAP - DP_DSC_SUPPORT] &
1739 vdsc_cfg->line_buf_depth = min(INTEL_DP_DSC_MAX_LINE_BUF_DEPTH,
1740 drm_dp_dsc_sink_line_buf_depth(connector->dp.dsc_dpcd));
1741 if (!vdsc_cfg->line_buf_depth) {
1742 drm_dbg_kms(&i915->drm,
1743 "DSC Sink Line Buffer Depth invalid\n");
1747 vdsc_cfg->block_pred_enable =
1748 connector->dp.dsc_dpcd[DP_DSC_BLK_PREDICTION_SUPPORT - DP_DSC_SUPPORT] &
1749 DP_DSC_BLK_PREDICTION_IS_SUPPORTED;
1751 return drm_dsc_compute_rc_parameters(vdsc_cfg);
1754 static bool intel_dp_dsc_supports_format(const struct intel_connector *connector,
1755 enum intel_output_format output_format)
1757 struct drm_i915_private *i915 = to_i915(connector->base.dev);
1760 switch (output_format) {
1761 case INTEL_OUTPUT_FORMAT_RGB:
1762 sink_dsc_format = DP_DSC_RGB;
1764 case INTEL_OUTPUT_FORMAT_YCBCR444:
1765 sink_dsc_format = DP_DSC_YCbCr444;
1767 case INTEL_OUTPUT_FORMAT_YCBCR420:
1768 if (min(intel_dp_source_dsc_version_minor(i915),
1769 intel_dp_sink_dsc_version_minor(connector->dp.dsc_dpcd)) < 2)
1771 sink_dsc_format = DP_DSC_YCbCr420_Native;
1777 return drm_dp_dsc_sink_supports_format(connector->dp.dsc_dpcd, sink_dsc_format);
1780 static bool is_bw_sufficient_for_dsc_config(u16 compressed_bppx16, u32 link_clock,
1781 u32 lane_count, u32 mode_clock,
1782 enum intel_output_format output_format,
1785 u32 available_bw, required_bw;
1787 available_bw = (link_clock * lane_count * timeslots * 16) / 8;
1788 required_bw = compressed_bppx16 * (intel_dp_mode_to_fec_clock(mode_clock));
1790 return available_bw > required_bw;
1793 static int dsc_compute_link_config(struct intel_dp *intel_dp,
1794 struct intel_crtc_state *pipe_config,
1795 struct link_config_limits *limits,
1796 u16 compressed_bppx16,
1799 const struct drm_display_mode *adjusted_mode = &pipe_config->hw.adjusted_mode;
1800 int link_rate, lane_count;
1803 for (i = 0; i < intel_dp->num_common_rates; i++) {
1804 link_rate = intel_dp_common_rate(intel_dp, i);
1805 if (link_rate < limits->min_rate || link_rate > limits->max_rate)
1808 for (lane_count = limits->min_lane_count;
1809 lane_count <= limits->max_lane_count;
1811 if (!is_bw_sufficient_for_dsc_config(compressed_bppx16, link_rate,
1812 lane_count, adjusted_mode->clock,
1813 pipe_config->output_format,
1817 pipe_config->lane_count = lane_count;
1818 pipe_config->port_clock = link_rate;
1828 u16 intel_dp_dsc_max_sink_compressed_bppx16(const struct intel_connector *connector,
1829 struct intel_crtc_state *pipe_config,
1832 u16 max_bppx16 = drm_edp_dsc_sink_output_bpp(connector->dp.dsc_dpcd);
1837 * If support not given in DPCD 67h, 68h use the Maximum Allowed bit rate
1838 * values as given in spec Table 2-157 DP v2.0
1840 switch (pipe_config->output_format) {
1841 case INTEL_OUTPUT_FORMAT_RGB:
1842 case INTEL_OUTPUT_FORMAT_YCBCR444:
1843 return (3 * bpc) << 4;
1844 case INTEL_OUTPUT_FORMAT_YCBCR420:
1845 return (3 * (bpc / 2)) << 4;
1847 MISSING_CASE(pipe_config->output_format);
1854 int intel_dp_dsc_sink_min_compressed_bpp(struct intel_crtc_state *pipe_config)
1856 /* From Mandatory bit rate range Support Table 2-157 (DP v2.0) */
1857 switch (pipe_config->output_format) {
1858 case INTEL_OUTPUT_FORMAT_RGB:
1859 case INTEL_OUTPUT_FORMAT_YCBCR444:
1861 case INTEL_OUTPUT_FORMAT_YCBCR420:
1864 MISSING_CASE(pipe_config->output_format);
1871 int intel_dp_dsc_sink_max_compressed_bpp(const struct intel_connector *connector,
1872 struct intel_crtc_state *pipe_config,
1875 return intel_dp_dsc_max_sink_compressed_bppx16(connector,
1876 pipe_config, bpc) >> 4;
1879 static int dsc_src_min_compressed_bpp(void)
1881 /* Min Compressed bpp supported by source is 8 */
1885 static int dsc_src_max_compressed_bpp(struct intel_dp *intel_dp)
1887 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
1890 * Max Compressed bpp for Gen 13+ is 27bpp.
1891 * For earlier platform is 23bpp. (Bspec:49259).
1893 if (DISPLAY_VER(i915) < 13)
1900 * From a list of valid compressed bpps try different compressed bpp and find a
1901 * suitable link configuration that can support it.
1904 icl_dsc_compute_link_config(struct intel_dp *intel_dp,
1905 struct intel_crtc_state *pipe_config,
1906 struct link_config_limits *limits,
1914 /* Compressed BPP should be less than the Input DSC bpp */
1915 dsc_max_bpp = min(dsc_max_bpp, pipe_bpp - 1);
1917 for (i = 0; i < ARRAY_SIZE(valid_dsc_bpp); i++) {
1918 if (valid_dsc_bpp[i] < dsc_min_bpp)
1920 if (valid_dsc_bpp[i] > dsc_max_bpp)
1923 ret = dsc_compute_link_config(intel_dp,
1926 valid_dsc_bpp[i] << 4,
1929 pipe_config->dsc.compressed_bpp_x16 =
1930 to_bpp_x16(valid_dsc_bpp[i]);
1939 * From XE_LPD onwards we supports compression bpps in steps of 1 up to
1940 * uncompressed bpp-1. So we start from max compressed bpp and see if any
1941 * link configuration is able to support that compressed bpp, if not we
1942 * step down and check for lower compressed bpp.
1945 xelpd_dsc_compute_link_config(struct intel_dp *intel_dp,
1946 const struct intel_connector *connector,
1947 struct intel_crtc_state *pipe_config,
1948 struct link_config_limits *limits,
1954 u8 bppx16_incr = drm_dp_dsc_sink_bpp_incr(connector->dp.dsc_dpcd);
1955 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
1956 u16 compressed_bppx16;
1960 if (DISPLAY_VER(i915) < 14 || bppx16_incr <= 1)
1963 bppx16_step = 16 / bppx16_incr;
1965 /* Compressed BPP should be less than the Input DSC bpp */
1966 dsc_max_bpp = min(dsc_max_bpp << 4, (pipe_bpp << 4) - bppx16_step);
1967 dsc_min_bpp = dsc_min_bpp << 4;
1969 for (compressed_bppx16 = dsc_max_bpp;
1970 compressed_bppx16 >= dsc_min_bpp;
1971 compressed_bppx16 -= bppx16_step) {
1972 if (intel_dp->force_dsc_fractional_bpp_en &&
1973 !to_bpp_frac(compressed_bppx16))
1975 ret = dsc_compute_link_config(intel_dp,
1981 pipe_config->dsc.compressed_bpp_x16 = compressed_bppx16;
1982 if (intel_dp->force_dsc_fractional_bpp_en &&
1983 to_bpp_frac(compressed_bppx16))
1984 drm_dbg_kms(&i915->drm, "Forcing DSC fractional bpp\n");
1992 static int dsc_compute_compressed_bpp(struct intel_dp *intel_dp,
1993 const struct intel_connector *connector,
1994 struct intel_crtc_state *pipe_config,
1995 struct link_config_limits *limits,
1999 const struct drm_display_mode *adjusted_mode = &pipe_config->hw.adjusted_mode;
2000 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
2001 int dsc_src_min_bpp, dsc_sink_min_bpp, dsc_min_bpp;
2002 int dsc_src_max_bpp, dsc_sink_max_bpp, dsc_max_bpp;
2003 int dsc_joiner_max_bpp;
2005 dsc_src_min_bpp = dsc_src_min_compressed_bpp();
2006 dsc_sink_min_bpp = intel_dp_dsc_sink_min_compressed_bpp(pipe_config);
2007 dsc_min_bpp = max(dsc_src_min_bpp, dsc_sink_min_bpp);
2008 dsc_min_bpp = max(dsc_min_bpp, to_bpp_int_roundup(limits->link.min_bpp_x16));
2010 dsc_src_max_bpp = dsc_src_max_compressed_bpp(intel_dp);
2011 dsc_sink_max_bpp = intel_dp_dsc_sink_max_compressed_bpp(connector,
2014 dsc_max_bpp = dsc_sink_max_bpp ? min(dsc_sink_max_bpp, dsc_src_max_bpp) : dsc_src_max_bpp;
2016 dsc_joiner_max_bpp = get_max_compressed_bpp_with_joiner(i915, adjusted_mode->clock,
2017 adjusted_mode->hdisplay,
2018 pipe_config->bigjoiner_pipes);
2019 dsc_max_bpp = min(dsc_max_bpp, dsc_joiner_max_bpp);
2020 dsc_max_bpp = min(dsc_max_bpp, to_bpp_int(limits->link.max_bpp_x16));
2022 if (DISPLAY_VER(i915) >= 13)
2023 return xelpd_dsc_compute_link_config(intel_dp, connector, pipe_config, limits,
2024 dsc_max_bpp, dsc_min_bpp, pipe_bpp, timeslots);
2025 return icl_dsc_compute_link_config(intel_dp, pipe_config, limits,
2026 dsc_max_bpp, dsc_min_bpp, pipe_bpp, timeslots);
2030 u8 intel_dp_dsc_min_src_input_bpc(struct drm_i915_private *i915)
2032 /* Min DSC Input BPC for ICL+ is 8 */
2033 return HAS_DSC(i915) ? 8 : 0;
2037 bool is_dsc_pipe_bpp_sufficient(struct drm_i915_private *i915,
2038 struct drm_connector_state *conn_state,
2039 struct link_config_limits *limits,
2042 u8 dsc_max_bpc, dsc_min_bpc, dsc_max_pipe_bpp, dsc_min_pipe_bpp;
2044 dsc_max_bpc = min(intel_dp_dsc_max_src_input_bpc(i915), conn_state->max_requested_bpc);
2045 dsc_min_bpc = intel_dp_dsc_min_src_input_bpc(i915);
2047 dsc_max_pipe_bpp = min(dsc_max_bpc * 3, limits->pipe.max_bpp);
2048 dsc_min_pipe_bpp = max(dsc_min_bpc * 3, limits->pipe.min_bpp);
2050 return pipe_bpp >= dsc_min_pipe_bpp &&
2051 pipe_bpp <= dsc_max_pipe_bpp;
2055 int intel_dp_force_dsc_pipe_bpp(struct intel_dp *intel_dp,
2056 struct drm_connector_state *conn_state,
2057 struct link_config_limits *limits)
2059 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
2062 if (!intel_dp->force_dsc_bpc)
2065 forced_bpp = intel_dp->force_dsc_bpc * 3;
2067 if (is_dsc_pipe_bpp_sufficient(i915, conn_state, limits, forced_bpp)) {
2068 drm_dbg_kms(&i915->drm, "Input DSC BPC forced to %d\n", intel_dp->force_dsc_bpc);
2072 drm_dbg_kms(&i915->drm, "Cannot force DSC BPC:%d, due to DSC BPC limits\n",
2073 intel_dp->force_dsc_bpc);
2078 static int intel_dp_dsc_compute_pipe_bpp(struct intel_dp *intel_dp,
2079 struct intel_crtc_state *pipe_config,
2080 struct drm_connector_state *conn_state,
2081 struct link_config_limits *limits,
2084 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
2085 const struct intel_connector *connector =
2086 to_intel_connector(conn_state->connector);
2087 u8 max_req_bpc = conn_state->max_requested_bpc;
2088 u8 dsc_max_bpc, dsc_max_bpp;
2089 u8 dsc_min_bpc, dsc_min_bpp;
2091 int forced_bpp, pipe_bpp;
2092 int num_bpc, i, ret;
2094 forced_bpp = intel_dp_force_dsc_pipe_bpp(intel_dp, conn_state, limits);
2097 ret = dsc_compute_compressed_bpp(intel_dp, connector, pipe_config,
2098 limits, forced_bpp, timeslots);
2100 pipe_config->pipe_bpp = forced_bpp;
2105 dsc_max_bpc = intel_dp_dsc_max_src_input_bpc(i915);
2109 dsc_max_bpc = min_t(u8, dsc_max_bpc, max_req_bpc);
2110 dsc_max_bpp = min(dsc_max_bpc * 3, limits->pipe.max_bpp);
2112 dsc_min_bpc = intel_dp_dsc_min_src_input_bpc(i915);
2113 dsc_min_bpp = max(dsc_min_bpc * 3, limits->pipe.min_bpp);
2116 * Get the maximum DSC bpc that will be supported by any valid
2117 * link configuration and compressed bpp.
2119 num_bpc = drm_dp_dsc_sink_supported_input_bpcs(connector->dp.dsc_dpcd, dsc_bpc);
2120 for (i = 0; i < num_bpc; i++) {
2121 pipe_bpp = dsc_bpc[i] * 3;
2122 if (pipe_bpp < dsc_min_bpp)
2124 if (pipe_bpp > dsc_max_bpp)
2126 ret = dsc_compute_compressed_bpp(intel_dp, connector, pipe_config,
2127 limits, pipe_bpp, timeslots);
2129 pipe_config->pipe_bpp = pipe_bpp;
2137 static int intel_edp_dsc_compute_pipe_bpp(struct intel_dp *intel_dp,
2138 struct intel_crtc_state *pipe_config,
2139 struct drm_connector_state *conn_state,
2140 struct link_config_limits *limits)
2142 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
2143 struct intel_connector *connector =
2144 to_intel_connector(conn_state->connector);
2145 int pipe_bpp, forced_bpp;
2146 int dsc_src_min_bpp, dsc_sink_min_bpp, dsc_min_bpp;
2147 int dsc_src_max_bpp, dsc_sink_max_bpp, dsc_max_bpp;
2149 forced_bpp = intel_dp_force_dsc_pipe_bpp(intel_dp, conn_state, limits);
2152 pipe_bpp = forced_bpp;
2154 int max_bpc = min(limits->pipe.max_bpp / 3, (int)conn_state->max_requested_bpc);
2156 /* For eDP use max bpp that can be supported with DSC. */
2157 pipe_bpp = intel_dp_dsc_compute_max_bpp(connector, max_bpc);
2158 if (!is_dsc_pipe_bpp_sufficient(i915, conn_state, limits, pipe_bpp)) {
2159 drm_dbg_kms(&i915->drm,
2160 "Computed BPC is not in DSC BPC limits\n");
2164 pipe_config->port_clock = limits->max_rate;
2165 pipe_config->lane_count = limits->max_lane_count;
2167 dsc_src_min_bpp = dsc_src_min_compressed_bpp();
2168 dsc_sink_min_bpp = intel_dp_dsc_sink_min_compressed_bpp(pipe_config);
2169 dsc_min_bpp = max(dsc_src_min_bpp, dsc_sink_min_bpp);
2170 dsc_min_bpp = max(dsc_min_bpp, to_bpp_int_roundup(limits->link.min_bpp_x16));
2172 dsc_src_max_bpp = dsc_src_max_compressed_bpp(intel_dp);
2173 dsc_sink_max_bpp = intel_dp_dsc_sink_max_compressed_bpp(connector,
2176 dsc_max_bpp = dsc_sink_max_bpp ? min(dsc_sink_max_bpp, dsc_src_max_bpp) : dsc_src_max_bpp;
2177 dsc_max_bpp = min(dsc_max_bpp, to_bpp_int(limits->link.max_bpp_x16));
2179 /* Compressed BPP should be less than the Input DSC bpp */
2180 dsc_max_bpp = min(dsc_max_bpp, pipe_bpp - 1);
2182 pipe_config->dsc.compressed_bpp_x16 =
2183 to_bpp_x16(max(dsc_min_bpp, dsc_max_bpp));
2185 pipe_config->pipe_bpp = pipe_bpp;
2190 int intel_dp_dsc_compute_config(struct intel_dp *intel_dp,
2191 struct intel_crtc_state *pipe_config,
2192 struct drm_connector_state *conn_state,
2193 struct link_config_limits *limits,
2195 bool compute_pipe_bpp)
2197 struct intel_digital_port *dig_port = dp_to_dig_port(intel_dp);
2198 struct drm_i915_private *dev_priv = to_i915(dig_port->base.base.dev);
2199 const struct intel_connector *connector =
2200 to_intel_connector(conn_state->connector);
2201 const struct drm_display_mode *adjusted_mode =
2202 &pipe_config->hw.adjusted_mode;
2205 pipe_config->fec_enable = pipe_config->fec_enable ||
2206 (!intel_dp_is_edp(intel_dp) &&
2207 intel_dp_supports_fec(intel_dp, connector, pipe_config));
2209 if (!intel_dp_supports_dsc(connector, pipe_config))
2212 if (!intel_dp_dsc_supports_format(connector, pipe_config->output_format))
2216 * compute pipe bpp is set to false for DP MST DSC case
2217 * and compressed_bpp is calculated same time once
2218 * vpci timeslots are allocated, because overall bpp
2219 * calculation procedure is bit different for MST case.
2221 if (compute_pipe_bpp) {
2222 if (intel_dp_is_edp(intel_dp))
2223 ret = intel_edp_dsc_compute_pipe_bpp(intel_dp, pipe_config,
2224 conn_state, limits);
2226 ret = intel_dp_dsc_compute_pipe_bpp(intel_dp, pipe_config,
2227 conn_state, limits, timeslots);
2229 drm_dbg_kms(&dev_priv->drm,
2230 "No Valid pipe bpp for given mode ret = %d\n", ret);
2235 /* Calculate Slice count */
2236 if (intel_dp_is_edp(intel_dp)) {
2237 pipe_config->dsc.slice_count =
2238 drm_dp_dsc_sink_max_slice_count(connector->dp.dsc_dpcd,
2240 if (!pipe_config->dsc.slice_count) {
2241 drm_dbg_kms(&dev_priv->drm, "Unsupported Slice Count %d\n",
2242 pipe_config->dsc.slice_count);
2246 u8 dsc_dp_slice_count;
2248 dsc_dp_slice_count =
2249 intel_dp_dsc_get_slice_count(connector,
2250 adjusted_mode->crtc_clock,
2251 adjusted_mode->crtc_hdisplay,
2252 pipe_config->bigjoiner_pipes);
2253 if (!dsc_dp_slice_count) {
2254 drm_dbg_kms(&dev_priv->drm,
2255 "Compressed Slice Count not supported\n");
2259 pipe_config->dsc.slice_count = dsc_dp_slice_count;
2262 * VDSC engine operates at 1 Pixel per clock, so if peak pixel rate
2263 * is greater than the maximum Cdclock and if slice count is even
2264 * then we need to use 2 VDSC instances.
2266 if (pipe_config->bigjoiner_pipes || pipe_config->dsc.slice_count > 1)
2267 pipe_config->dsc.dsc_split = true;
2269 ret = intel_dp_dsc_compute_params(connector, pipe_config);
2271 drm_dbg_kms(&dev_priv->drm,
2272 "Cannot compute valid DSC parameters for Input Bpp = %d"
2273 "Compressed BPP = " BPP_X16_FMT "\n",
2274 pipe_config->pipe_bpp,
2275 BPP_X16_ARGS(pipe_config->dsc.compressed_bpp_x16));
2279 pipe_config->dsc.compression_enable = true;
2280 drm_dbg_kms(&dev_priv->drm, "DP DSC computed with Input Bpp = %d "
2281 "Compressed Bpp = " BPP_X16_FMT " Slice Count = %d\n",
2282 pipe_config->pipe_bpp,
2283 BPP_X16_ARGS(pipe_config->dsc.compressed_bpp_x16),
2284 pipe_config->dsc.slice_count);
2290 * intel_dp_compute_config_link_bpp_limits - compute output link bpp limits
2291 * @intel_dp: intel DP
2292 * @crtc_state: crtc state
2293 * @dsc: DSC compression mode
2294 * @limits: link configuration limits
2296 * Calculates the output link min, max bpp values in @limits based on the
2297 * pipe bpp range, @crtc_state and @dsc mode.
2299 * Returns %true in case of success.
2302 intel_dp_compute_config_link_bpp_limits(struct intel_dp *intel_dp,
2303 const struct intel_crtc_state *crtc_state,
2305 struct link_config_limits *limits)
2307 struct drm_i915_private *i915 = to_i915(crtc_state->uapi.crtc->dev);
2308 const struct drm_display_mode *adjusted_mode =
2309 &crtc_state->hw.adjusted_mode;
2310 const struct intel_crtc *crtc = to_intel_crtc(crtc_state->uapi.crtc);
2311 const struct intel_encoder *encoder = &dp_to_dig_port(intel_dp)->base;
2312 int max_link_bpp_x16;
2314 max_link_bpp_x16 = min(crtc_state->max_link_bpp_x16,
2315 to_bpp_x16(limits->pipe.max_bpp));
2318 max_link_bpp_x16 = rounddown(max_link_bpp_x16, to_bpp_x16(2 * 3));
2320 if (max_link_bpp_x16 < to_bpp_x16(limits->pipe.min_bpp))
2323 limits->link.min_bpp_x16 = to_bpp_x16(limits->pipe.min_bpp);
2326 * TODO: set the DSC link limits already here, atm these are
2327 * initialized only later in intel_edp_dsc_compute_pipe_bpp() /
2328 * intel_dp_dsc_compute_pipe_bpp()
2330 limits->link.min_bpp_x16 = 0;
2333 limits->link.max_bpp_x16 = max_link_bpp_x16;
2335 drm_dbg_kms(&i915->drm,
2336 "[ENCODER:%d:%s][CRTC:%d:%s] DP link limits: pixel clock %d kHz DSC %s max lanes %d max rate %d max pipe_bpp %d max link_bpp " BPP_X16_FMT "\n",
2337 encoder->base.base.id, encoder->base.name,
2338 crtc->base.base.id, crtc->base.name,
2339 adjusted_mode->crtc_clock,
2341 limits->max_lane_count,
2343 limits->pipe.max_bpp,
2344 BPP_X16_ARGS(limits->link.max_bpp_x16));
2350 intel_dp_compute_config_limits(struct intel_dp *intel_dp,
2351 struct intel_crtc_state *crtc_state,
2352 bool respect_downstream_limits,
2354 struct link_config_limits *limits)
2356 limits->min_rate = intel_dp_common_rate(intel_dp, 0);
2357 limits->max_rate = intel_dp_max_link_rate(intel_dp);
2359 /* FIXME 128b/132b SST support missing */
2360 limits->max_rate = min(limits->max_rate, 810000);
2362 limits->min_lane_count = 1;
2363 limits->max_lane_count = intel_dp_max_lane_count(intel_dp);
2365 limits->pipe.min_bpp = intel_dp_min_bpp(crtc_state->output_format);
2366 limits->pipe.max_bpp = intel_dp_max_bpp(intel_dp, crtc_state,
2367 respect_downstream_limits);
2369 if (intel_dp->use_max_params) {
2371 * Use the maximum clock and number of lanes the eDP panel
2372 * advertizes being capable of in case the initial fast
2373 * optimal params failed us. The panels are generally
2374 * designed to support only a single clock and lane
2375 * configuration, and typically on older panels these
2376 * values correspond to the native resolution of the panel.
2378 limits->min_lane_count = limits->max_lane_count;
2379 limits->min_rate = limits->max_rate;
2382 intel_dp_adjust_compliance_config(intel_dp, crtc_state, limits);
2384 return intel_dp_compute_config_link_bpp_limits(intel_dp,
2390 int intel_dp_config_required_rate(const struct intel_crtc_state *crtc_state)
2392 const struct drm_display_mode *adjusted_mode =
2393 &crtc_state->hw.adjusted_mode;
2394 int bpp = crtc_state->dsc.compression_enable ?
2395 to_bpp_int_roundup(crtc_state->dsc.compressed_bpp_x16) :
2396 crtc_state->pipe_bpp;
2398 return intel_dp_link_required(adjusted_mode->crtc_clock, bpp);
2401 bool intel_dp_joiner_needs_dsc(struct drm_i915_private *i915, bool use_joiner)
2404 * Pipe joiner needs compression up to display 12 due to bandwidth
2405 * limitation. DG2 onwards pipe joiner can be enabled without
2408 return DISPLAY_VER(i915) < 13 && use_joiner;
2412 intel_dp_compute_link_config(struct intel_encoder *encoder,
2413 struct intel_crtc_state *pipe_config,
2414 struct drm_connector_state *conn_state,
2415 bool respect_downstream_limits)
2417 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
2418 struct intel_crtc *crtc = to_intel_crtc(pipe_config->uapi.crtc);
2419 struct intel_connector *connector =
2420 to_intel_connector(conn_state->connector);
2421 const struct drm_display_mode *adjusted_mode =
2422 &pipe_config->hw.adjusted_mode;
2423 struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
2424 struct link_config_limits limits;
2425 bool dsc_needed, joiner_needs_dsc;
2428 if (pipe_config->fec_enable &&
2429 !intel_dp_supports_fec(intel_dp, connector, pipe_config))
2432 if (intel_dp_need_bigjoiner(intel_dp, connector,
2433 adjusted_mode->crtc_hdisplay,
2434 adjusted_mode->crtc_clock))
2435 pipe_config->bigjoiner_pipes = GENMASK(crtc->pipe + 1, crtc->pipe);
2437 joiner_needs_dsc = intel_dp_joiner_needs_dsc(i915, pipe_config->bigjoiner_pipes);
2439 dsc_needed = joiner_needs_dsc || intel_dp->force_dsc_en ||
2440 !intel_dp_compute_config_limits(intel_dp, pipe_config,
2441 respect_downstream_limits,
2447 * Optimize for slow and wide for everything, because there are some
2448 * eDP 1.3 and 1.4 panels don't work well with fast and narrow.
2450 ret = intel_dp_compute_link_config_wide(intel_dp, pipe_config,
2451 conn_state, &limits);
2457 drm_dbg_kms(&i915->drm, "Try DSC (fallback=%s, joiner=%s, force=%s)\n",
2458 str_yes_no(ret), str_yes_no(joiner_needs_dsc),
2459 str_yes_no(intel_dp->force_dsc_en));
2461 if (!intel_dp_compute_config_limits(intel_dp, pipe_config,
2462 respect_downstream_limits,
2467 ret = intel_dp_dsc_compute_config(intel_dp, pipe_config,
2468 conn_state, &limits, 64, true);
2473 drm_dbg_kms(&i915->drm,
2474 "DP lane count %d clock %d bpp input %d compressed " BPP_X16_FMT " link rate required %d available %d\n",
2475 pipe_config->lane_count, pipe_config->port_clock,
2476 pipe_config->pipe_bpp,
2477 BPP_X16_ARGS(pipe_config->dsc.compressed_bpp_x16),
2478 intel_dp_config_required_rate(pipe_config),
2479 intel_dp_max_link_data_rate(intel_dp,
2480 pipe_config->port_clock,
2481 pipe_config->lane_count));
2486 bool intel_dp_limited_color_range(const struct intel_crtc_state *crtc_state,
2487 const struct drm_connector_state *conn_state)
2489 const struct intel_digital_connector_state *intel_conn_state =
2490 to_intel_digital_connector_state(conn_state);
2491 const struct drm_display_mode *adjusted_mode =
2492 &crtc_state->hw.adjusted_mode;
2495 * Our YCbCr output is always limited range.
2496 * crtc_state->limited_color_range only applies to RGB,
2497 * and it must never be set for YCbCr or we risk setting
2498 * some conflicting bits in TRANSCONF which will mess up
2499 * the colors on the monitor.
2501 if (crtc_state->output_format != INTEL_OUTPUT_FORMAT_RGB)
2504 if (intel_conn_state->broadcast_rgb == INTEL_BROADCAST_RGB_AUTO) {
2507 * CEA-861-E - 5.1 Default Encoding Parameters
2508 * VESA DisplayPort Ver.1.2a - 5.1.1.1 Video Colorimetry
2510 return crtc_state->pipe_bpp != 18 &&
2511 drm_default_rgb_quant_range(adjusted_mode) ==
2512 HDMI_QUANTIZATION_RANGE_LIMITED;
2514 return intel_conn_state->broadcast_rgb ==
2515 INTEL_BROADCAST_RGB_LIMITED;
2519 static bool intel_dp_port_has_audio(struct drm_i915_private *dev_priv,
2522 if (IS_G4X(dev_priv))
2524 if (DISPLAY_VER(dev_priv) < 12 && port == PORT_A)
2530 static void intel_dp_compute_vsc_colorimetry(const struct intel_crtc_state *crtc_state,
2531 const struct drm_connector_state *conn_state,
2532 struct drm_dp_vsc_sdp *vsc)
2534 struct intel_crtc *crtc = to_intel_crtc(crtc_state->uapi.crtc);
2535 struct drm_i915_private *dev_priv = to_i915(crtc->base.dev);
2537 if (crtc_state->has_panel_replay) {
2539 * Prepare VSC Header for SU as per DP 2.0 spec, Table 2-223
2540 * VSC SDP supporting 3D stereo, Panel Replay, and Pixel
2541 * Encoding/Colorimetry Format indication.
2543 vsc->revision = 0x7;
2546 * Prepare VSC Header for SU as per DP 1.4 spec, Table 2-118
2547 * VSC SDP supporting 3D stereo, PSR2, and Pixel Encoding/
2548 * Colorimetry Format indication.
2550 vsc->revision = 0x5;
2555 /* DP 1.4a spec, Table 2-120 */
2556 switch (crtc_state->output_format) {
2557 case INTEL_OUTPUT_FORMAT_YCBCR444:
2558 vsc->pixelformat = DP_PIXELFORMAT_YUV444;
2560 case INTEL_OUTPUT_FORMAT_YCBCR420:
2561 vsc->pixelformat = DP_PIXELFORMAT_YUV420;
2563 case INTEL_OUTPUT_FORMAT_RGB:
2565 vsc->pixelformat = DP_PIXELFORMAT_RGB;
2568 switch (conn_state->colorspace) {
2569 case DRM_MODE_COLORIMETRY_BT709_YCC:
2570 vsc->colorimetry = DP_COLORIMETRY_BT709_YCC;
2572 case DRM_MODE_COLORIMETRY_XVYCC_601:
2573 vsc->colorimetry = DP_COLORIMETRY_XVYCC_601;
2575 case DRM_MODE_COLORIMETRY_XVYCC_709:
2576 vsc->colorimetry = DP_COLORIMETRY_XVYCC_709;
2578 case DRM_MODE_COLORIMETRY_SYCC_601:
2579 vsc->colorimetry = DP_COLORIMETRY_SYCC_601;
2581 case DRM_MODE_COLORIMETRY_OPYCC_601:
2582 vsc->colorimetry = DP_COLORIMETRY_OPYCC_601;
2584 case DRM_MODE_COLORIMETRY_BT2020_CYCC:
2585 vsc->colorimetry = DP_COLORIMETRY_BT2020_CYCC;
2587 case DRM_MODE_COLORIMETRY_BT2020_RGB:
2588 vsc->colorimetry = DP_COLORIMETRY_BT2020_RGB;
2590 case DRM_MODE_COLORIMETRY_BT2020_YCC:
2591 vsc->colorimetry = DP_COLORIMETRY_BT2020_YCC;
2593 case DRM_MODE_COLORIMETRY_DCI_P3_RGB_D65:
2594 case DRM_MODE_COLORIMETRY_DCI_P3_RGB_THEATER:
2595 vsc->colorimetry = DP_COLORIMETRY_DCI_P3_RGB;
2599 * RGB->YCBCR color conversion uses the BT.709
2602 if (crtc_state->output_format == INTEL_OUTPUT_FORMAT_YCBCR420)
2603 vsc->colorimetry = DP_COLORIMETRY_BT709_YCC;
2605 vsc->colorimetry = DP_COLORIMETRY_DEFAULT;
2609 vsc->bpc = crtc_state->pipe_bpp / 3;
2611 /* only RGB pixelformat supports 6 bpc */
2612 drm_WARN_ON(&dev_priv->drm,
2613 vsc->bpc == 6 && vsc->pixelformat != DP_PIXELFORMAT_RGB);
2615 /* all YCbCr are always limited range */
2616 vsc->dynamic_range = DP_DYNAMIC_RANGE_CTA;
2617 vsc->content_type = DP_CONTENT_TYPE_NOT_DEFINED;
2620 static void intel_dp_compute_as_sdp(struct intel_dp *intel_dp,
2621 struct intel_crtc_state *crtc_state)
2623 struct drm_dp_as_sdp *as_sdp = &crtc_state->infoframes.as_sdp;
2624 const struct drm_display_mode *adjusted_mode =
2625 &crtc_state->hw.adjusted_mode;
2627 if (!crtc_state->vrr.enable ||
2628 !intel_dp_as_sdp_supported(intel_dp))
2631 crtc_state->infoframes.enable |= intel_hdmi_infoframe_enable(DP_SDP_ADAPTIVE_SYNC);
2633 /* Currently only DP_AS_SDP_AVT_FIXED_VTOTAL mode supported */
2634 as_sdp->sdp_type = DP_SDP_ADAPTIVE_SYNC;
2635 as_sdp->length = 0x9;
2636 as_sdp->mode = DP_AS_SDP_AVT_FIXED_VTOTAL;
2637 as_sdp->vtotal = adjusted_mode->vtotal;
2638 as_sdp->target_rr = 0;
2639 as_sdp->duration_incr_ms = 0;
2640 as_sdp->duration_incr_ms = 0;
2643 static void intel_dp_compute_vsc_sdp(struct intel_dp *intel_dp,
2644 struct intel_crtc_state *crtc_state,
2645 const struct drm_connector_state *conn_state)
2647 struct drm_dp_vsc_sdp *vsc;
2649 if ((!intel_dp->colorimetry_support ||
2650 !intel_dp_needs_vsc_sdp(crtc_state, conn_state)) &&
2651 !crtc_state->has_psr)
2654 vsc = &crtc_state->infoframes.vsc;
2656 crtc_state->infoframes.enable |= intel_hdmi_infoframe_enable(DP_SDP_VSC);
2657 vsc->sdp_type = DP_SDP_VSC;
2659 /* Needs colorimetry */
2660 if (intel_dp_needs_vsc_sdp(crtc_state, conn_state)) {
2661 intel_dp_compute_vsc_colorimetry(crtc_state, conn_state,
2663 } else if (crtc_state->has_psr2) {
2665 * [PSR2 without colorimetry]
2666 * Prepare VSC Header for SU as per eDP 1.4 spec, Table 6-11
2667 * 3D stereo + PSR/PSR2 + Y-coordinate.
2669 vsc->revision = 0x4;
2671 } else if (crtc_state->has_panel_replay) {
2673 * [Panel Replay without colorimetry info]
2674 * Prepare VSC Header for SU as per DP 2.0 spec, Table 2-223
2675 * VSC SDP supporting 3D stereo + Panel Replay.
2677 vsc->revision = 0x6;
2682 * Prepare VSC Header for SU as per DP 1.4 spec, Table 2-118
2683 * VSC SDP supporting 3D stereo + PSR (applies to eDP v1.3 or
2686 vsc->revision = 0x2;
2692 intel_dp_compute_hdr_metadata_infoframe_sdp(struct intel_dp *intel_dp,
2693 struct intel_crtc_state *crtc_state,
2694 const struct drm_connector_state *conn_state)
2697 struct drm_i915_private *dev_priv = dp_to_i915(intel_dp);
2698 struct hdmi_drm_infoframe *drm_infoframe = &crtc_state->infoframes.drm.drm;
2700 if (!conn_state->hdr_output_metadata)
2703 ret = drm_hdmi_infoframe_set_hdr_metadata(drm_infoframe, conn_state);
2706 drm_dbg_kms(&dev_priv->drm, "couldn't set HDR metadata in infoframe\n");
2710 crtc_state->infoframes.enable |=
2711 intel_hdmi_infoframe_enable(HDMI_PACKET_TYPE_GAMUT_METADATA);
2714 static bool can_enable_drrs(struct intel_connector *connector,
2715 const struct intel_crtc_state *pipe_config,
2716 const struct drm_display_mode *downclock_mode)
2718 struct drm_i915_private *i915 = to_i915(connector->base.dev);
2720 if (pipe_config->vrr.enable)
2724 * DRRS and PSR can't be enable together, so giving preference to PSR
2725 * as it allows more power-savings by complete shutting down display,
2726 * so to guarantee this, intel_drrs_compute_config() must be called
2727 * after intel_psr_compute_config().
2729 if (pipe_config->has_psr)
2732 /* FIXME missing FDI M2/N2 etc. */
2733 if (pipe_config->has_pch_encoder)
2736 if (!intel_cpu_transcoder_has_drrs(i915, pipe_config->cpu_transcoder))
2739 return downclock_mode &&
2740 intel_panel_drrs_type(connector) == DRRS_TYPE_SEAMLESS;
2744 intel_dp_drrs_compute_config(struct intel_connector *connector,
2745 struct intel_crtc_state *pipe_config,
2748 struct drm_i915_private *i915 = to_i915(connector->base.dev);
2749 const struct drm_display_mode *downclock_mode =
2750 intel_panel_downclock_mode(connector, &pipe_config->hw.adjusted_mode);
2754 * FIXME all joined pipes share the same transcoder.
2755 * Need to account for that when updating M/N live.
2757 if (has_seamless_m_n(connector) && !pipe_config->bigjoiner_pipes)
2758 pipe_config->update_m_n = true;
2760 if (!can_enable_drrs(connector, pipe_config, downclock_mode)) {
2761 if (intel_cpu_transcoder_has_m2_n2(i915, pipe_config->cpu_transcoder))
2762 intel_zero_m_n(&pipe_config->dp_m2_n2);
2766 if (IS_IRONLAKE(i915) || IS_SANDYBRIDGE(i915) || IS_IVYBRIDGE(i915))
2767 pipe_config->msa_timing_delay = connector->panel.vbt.edp.drrs_msa_timing_delay;
2769 pipe_config->has_drrs = true;
2771 pixel_clock = downclock_mode->clock;
2772 if (pipe_config->splitter.enable)
2773 pixel_clock /= pipe_config->splitter.link_count;
2775 intel_link_compute_m_n(link_bpp_x16, pipe_config->lane_count, pixel_clock,
2776 pipe_config->port_clock,
2777 intel_dp_bw_fec_overhead(pipe_config->fec_enable),
2778 &pipe_config->dp_m2_n2);
2780 /* FIXME: abstract this better */
2781 if (pipe_config->splitter.enable)
2782 pipe_config->dp_m2_n2.data_m *= pipe_config->splitter.link_count;
2785 static bool intel_dp_has_audio(struct intel_encoder *encoder,
2786 struct intel_crtc_state *crtc_state,
2787 const struct drm_connector_state *conn_state)
2789 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
2790 const struct intel_digital_connector_state *intel_conn_state =
2791 to_intel_digital_connector_state(conn_state);
2792 struct intel_connector *connector =
2793 to_intel_connector(conn_state->connector);
2795 if (!intel_crtc_has_type(crtc_state, INTEL_OUTPUT_DP_MST) &&
2796 !intel_dp_port_has_audio(i915, encoder->port))
2799 if (intel_conn_state->force_audio == HDMI_AUDIO_AUTO)
2800 return connector->base.display_info.has_audio;
2802 return intel_conn_state->force_audio == HDMI_AUDIO_ON;
2806 intel_dp_compute_output_format(struct intel_encoder *encoder,
2807 struct intel_crtc_state *crtc_state,
2808 struct drm_connector_state *conn_state,
2809 bool respect_downstream_limits)
2811 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
2812 struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
2813 struct intel_connector *connector = intel_dp->attached_connector;
2814 const struct drm_display_info *info = &connector->base.display_info;
2815 const struct drm_display_mode *adjusted_mode = &crtc_state->hw.adjusted_mode;
2816 bool ycbcr_420_only;
2819 ycbcr_420_only = drm_mode_is_420_only(info, adjusted_mode);
2821 if (ycbcr_420_only && !connector->base.ycbcr_420_allowed) {
2822 drm_dbg_kms(&i915->drm,
2823 "YCbCr 4:2:0 mode but YCbCr 4:2:0 output not possible. Falling back to RGB.\n");
2824 crtc_state->sink_format = INTEL_OUTPUT_FORMAT_RGB;
2826 crtc_state->sink_format = intel_dp_sink_format(connector, adjusted_mode);
2829 crtc_state->output_format = intel_dp_output_format(connector, crtc_state->sink_format);
2831 ret = intel_dp_compute_link_config(encoder, crtc_state, conn_state,
2832 respect_downstream_limits);
2834 if (crtc_state->sink_format == INTEL_OUTPUT_FORMAT_YCBCR420 ||
2835 !connector->base.ycbcr_420_allowed ||
2836 !drm_mode_is_420_also(info, adjusted_mode))
2839 crtc_state->sink_format = INTEL_OUTPUT_FORMAT_YCBCR420;
2840 crtc_state->output_format = intel_dp_output_format(connector,
2841 crtc_state->sink_format);
2842 ret = intel_dp_compute_link_config(encoder, crtc_state, conn_state,
2843 respect_downstream_limits);
2850 intel_dp_audio_compute_config(struct intel_encoder *encoder,
2851 struct intel_crtc_state *pipe_config,
2852 struct drm_connector_state *conn_state)
2854 pipe_config->has_audio =
2855 intel_dp_has_audio(encoder, pipe_config, conn_state) &&
2856 intel_audio_compute_config(encoder, pipe_config, conn_state);
2858 pipe_config->sdp_split_enable = pipe_config->has_audio &&
2859 intel_dp_is_uhbr(pipe_config);
2862 void intel_dp_queue_modeset_retry_work(struct intel_connector *connector)
2864 struct drm_i915_private *i915 = to_i915(connector->base.dev);
2866 drm_connector_get(&connector->base);
2867 if (!queue_work(i915->unordered_wq, &connector->modeset_retry_work))
2868 drm_connector_put(&connector->base);
2872 intel_dp_queue_modeset_retry_for_link(struct intel_atomic_state *state,
2873 struct intel_encoder *encoder,
2874 const struct intel_crtc_state *crtc_state)
2876 struct intel_connector *connector;
2877 struct intel_digital_connector_state *conn_state;
2878 struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
2881 if (!intel_crtc_has_type(crtc_state, INTEL_OUTPUT_DP_MST)) {
2882 intel_dp_queue_modeset_retry_work(intel_dp->attached_connector);
2887 for_each_new_intel_connector_in_state(state, connector, conn_state, i) {
2888 if (!conn_state->base.crtc)
2891 if (connector->mst_port == intel_dp)
2892 intel_dp_queue_modeset_retry_work(connector);
2897 intel_dp_compute_config(struct intel_encoder *encoder,
2898 struct intel_crtc_state *pipe_config,
2899 struct drm_connector_state *conn_state)
2901 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
2902 struct intel_atomic_state *state = to_intel_atomic_state(conn_state->state);
2903 struct drm_display_mode *adjusted_mode = &pipe_config->hw.adjusted_mode;
2904 struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
2905 const struct drm_display_mode *fixed_mode;
2906 struct intel_connector *connector = intel_dp->attached_connector;
2907 int ret = 0, link_bpp_x16;
2909 if (HAS_PCH_SPLIT(dev_priv) && !HAS_DDI(dev_priv) && encoder->port != PORT_A)
2910 pipe_config->has_pch_encoder = true;
2912 fixed_mode = intel_panel_fixed_mode(connector, adjusted_mode);
2913 if (intel_dp_is_edp(intel_dp) && fixed_mode) {
2914 ret = intel_panel_compute_config(connector, adjusted_mode);
2919 if (adjusted_mode->flags & DRM_MODE_FLAG_DBLSCAN)
2922 if (!connector->base.interlace_allowed &&
2923 adjusted_mode->flags & DRM_MODE_FLAG_INTERLACE)
2926 if (adjusted_mode->flags & DRM_MODE_FLAG_DBLCLK)
2929 if (intel_dp_hdisplay_bad(dev_priv, adjusted_mode->crtc_hdisplay))
2933 * Try to respect downstream TMDS clock limits first, if
2934 * that fails assume the user might know something we don't.
2936 ret = intel_dp_compute_output_format(encoder, pipe_config, conn_state, true);
2938 ret = intel_dp_compute_output_format(encoder, pipe_config, conn_state, false);
2942 if ((intel_dp_is_edp(intel_dp) && fixed_mode) ||
2943 pipe_config->output_format == INTEL_OUTPUT_FORMAT_YCBCR420) {
2944 ret = intel_panel_fitting(pipe_config, conn_state);
2949 pipe_config->limited_color_range =
2950 intel_dp_limited_color_range(pipe_config, conn_state);
2952 pipe_config->enhanced_framing =
2953 drm_dp_enhanced_frame_cap(intel_dp->dpcd);
2955 if (pipe_config->dsc.compression_enable)
2956 link_bpp_x16 = pipe_config->dsc.compressed_bpp_x16;
2958 link_bpp_x16 = to_bpp_x16(intel_dp_output_bpp(pipe_config->output_format,
2959 pipe_config->pipe_bpp));
2961 if (intel_dp->mso_link_count) {
2962 int n = intel_dp->mso_link_count;
2963 int overlap = intel_dp->mso_pixel_overlap;
2965 pipe_config->splitter.enable = true;
2966 pipe_config->splitter.link_count = n;
2967 pipe_config->splitter.pixel_overlap = overlap;
2969 drm_dbg_kms(&dev_priv->drm, "MSO link count %d, pixel overlap %d\n",
2972 adjusted_mode->crtc_hdisplay = adjusted_mode->crtc_hdisplay / n + overlap;
2973 adjusted_mode->crtc_hblank_start = adjusted_mode->crtc_hblank_start / n + overlap;
2974 adjusted_mode->crtc_hblank_end = adjusted_mode->crtc_hblank_end / n + overlap;
2975 adjusted_mode->crtc_hsync_start = adjusted_mode->crtc_hsync_start / n + overlap;
2976 adjusted_mode->crtc_hsync_end = adjusted_mode->crtc_hsync_end / n + overlap;
2977 adjusted_mode->crtc_htotal = adjusted_mode->crtc_htotal / n + overlap;
2978 adjusted_mode->crtc_clock /= n;
2981 intel_dp_audio_compute_config(encoder, pipe_config, conn_state);
2983 intel_link_compute_m_n(link_bpp_x16,
2984 pipe_config->lane_count,
2985 adjusted_mode->crtc_clock,
2986 pipe_config->port_clock,
2987 intel_dp_bw_fec_overhead(pipe_config->fec_enable),
2988 &pipe_config->dp_m_n);
2990 /* FIXME: abstract this better */
2991 if (pipe_config->splitter.enable)
2992 pipe_config->dp_m_n.data_m *= pipe_config->splitter.link_count;
2994 if (!HAS_DDI(dev_priv))
2995 g4x_dp_set_clock(encoder, pipe_config);
2997 intel_vrr_compute_config(pipe_config, conn_state);
2998 intel_dp_compute_as_sdp(intel_dp, pipe_config);
2999 intel_psr_compute_config(intel_dp, pipe_config, conn_state);
3000 intel_dp_drrs_compute_config(connector, pipe_config, link_bpp_x16);
3001 intel_dp_compute_vsc_sdp(intel_dp, pipe_config, conn_state);
3002 intel_dp_compute_hdr_metadata_infoframe_sdp(intel_dp, pipe_config, conn_state);
3004 return intel_dp_tunnel_atomic_compute_stream_bw(state, intel_dp, connector,
3008 void intel_dp_set_link_params(struct intel_dp *intel_dp,
3009 int link_rate, int lane_count)
3011 memset(intel_dp->train_set, 0, sizeof(intel_dp->train_set));
3012 intel_dp->link_trained = false;
3013 intel_dp->link_rate = link_rate;
3014 intel_dp->lane_count = lane_count;
3017 static void intel_dp_reset_max_link_params(struct intel_dp *intel_dp)
3019 intel_dp->max_link_lane_count = intel_dp_max_common_lane_count(intel_dp);
3020 intel_dp->max_link_rate = intel_dp_max_common_rate(intel_dp);
3023 /* Enable backlight PWM and backlight PP control. */
3024 void intel_edp_backlight_on(const struct intel_crtc_state *crtc_state,
3025 const struct drm_connector_state *conn_state)
3027 struct intel_dp *intel_dp = enc_to_intel_dp(to_intel_encoder(conn_state->best_encoder));
3028 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
3030 if (!intel_dp_is_edp(intel_dp))
3033 drm_dbg_kms(&i915->drm, "\n");
3035 intel_backlight_enable(crtc_state, conn_state);
3036 intel_pps_backlight_on(intel_dp);
3039 /* Disable backlight PP control and backlight PWM. */
3040 void intel_edp_backlight_off(const struct drm_connector_state *old_conn_state)
3042 struct intel_dp *intel_dp = enc_to_intel_dp(to_intel_encoder(old_conn_state->best_encoder));
3043 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
3045 if (!intel_dp_is_edp(intel_dp))
3048 drm_dbg_kms(&i915->drm, "\n");
3050 intel_pps_backlight_off(intel_dp);
3051 intel_backlight_disable(old_conn_state);
3054 static bool downstream_hpd_needs_d0(struct intel_dp *intel_dp)
3057 * DPCD 1.2+ should support BRANCH_DEVICE_CTRL, and thus
3058 * be capable of signalling downstream hpd with a long pulse.
3059 * Whether or not that means D3 is safe to use is not clear,
3060 * but let's assume so until proven otherwise.
3062 * FIXME should really check all downstream ports...
3064 return intel_dp->dpcd[DP_DPCD_REV] == 0x11 &&
3065 drm_dp_is_branch(intel_dp->dpcd) &&
3066 intel_dp->downstream_ports[0] & DP_DS_PORT_HPD;
3070 write_dsc_decompression_flag(struct drm_dp_aux *aux, u8 flag, bool set)
3075 err = drm_dp_dpcd_readb(aux, DP_DSC_ENABLE, &val);
3084 return drm_dp_dpcd_writeb(aux, DP_DSC_ENABLE, val);
3088 intel_dp_sink_set_dsc_decompression(struct intel_connector *connector,
3091 struct drm_i915_private *i915 = to_i915(connector->base.dev);
3093 if (write_dsc_decompression_flag(connector->dp.dsc_decompression_aux,
3094 DP_DECOMPRESSION_EN, enable) < 0)
3095 drm_dbg_kms(&i915->drm,
3096 "Failed to %s sink decompression state\n",
3097 str_enable_disable(enable));
3101 intel_dp_sink_set_dsc_passthrough(const struct intel_connector *connector,
3104 struct drm_i915_private *i915 = to_i915(connector->base.dev);
3105 struct drm_dp_aux *aux = connector->port ?
3106 connector->port->passthrough_aux : NULL;
3111 if (write_dsc_decompression_flag(aux,
3112 DP_DSC_PASSTHROUGH_EN, enable) < 0)
3113 drm_dbg_kms(&i915->drm,
3114 "Failed to %s sink compression passthrough state\n",
3115 str_enable_disable(enable));
3118 static int intel_dp_dsc_aux_ref_count(struct intel_atomic_state *state,
3119 const struct intel_connector *connector,
3122 struct drm_i915_private *i915 = to_i915(state->base.dev);
3123 struct drm_connector *_connector_iter;
3124 struct drm_connector_state *old_conn_state;
3125 struct drm_connector_state *new_conn_state;
3130 * On SST the decompression AUX device won't be shared, each connector
3131 * uses for this its own AUX targeting the sink device.
3133 if (!connector->mst_port)
3134 return connector->dp.dsc_decompression_enabled ? 1 : 0;
3136 for_each_oldnew_connector_in_state(&state->base, _connector_iter,
3137 old_conn_state, new_conn_state, i) {
3138 const struct intel_connector *
3139 connector_iter = to_intel_connector(_connector_iter);
3141 if (connector_iter->mst_port != connector->mst_port)
3144 if (!connector_iter->dp.dsc_decompression_enabled)
3147 drm_WARN_ON(&i915->drm,
3148 (for_get_ref && !new_conn_state->crtc) ||
3149 (!for_get_ref && !old_conn_state->crtc));
3151 if (connector_iter->dp.dsc_decompression_aux ==
3152 connector->dp.dsc_decompression_aux)
3159 static bool intel_dp_dsc_aux_get_ref(struct intel_atomic_state *state,
3160 struct intel_connector *connector)
3162 bool ret = intel_dp_dsc_aux_ref_count(state, connector, true) == 0;
3164 connector->dp.dsc_decompression_enabled = true;
3169 static bool intel_dp_dsc_aux_put_ref(struct intel_atomic_state *state,
3170 struct intel_connector *connector)
3172 connector->dp.dsc_decompression_enabled = false;
3174 return intel_dp_dsc_aux_ref_count(state, connector, false) == 0;
3178 * intel_dp_sink_enable_decompression - Enable DSC decompression in sink/last branch device
3179 * @state: atomic state
3180 * @connector: connector to enable the decompression for
3181 * @new_crtc_state: new state for the CRTC driving @connector
3183 * Enable the DSC decompression if required in the %DP_DSC_ENABLE DPCD
3184 * register of the appropriate sink/branch device. On SST this is always the
3185 * sink device, whereas on MST based on each device's DSC capabilities it's
3186 * either the last branch device (enabling decompression in it) or both the
3187 * last branch device (enabling passthrough in it) and the sink device
3188 * (enabling decompression in it).
3190 void intel_dp_sink_enable_decompression(struct intel_atomic_state *state,
3191 struct intel_connector *connector,
3192 const struct intel_crtc_state *new_crtc_state)
3194 struct drm_i915_private *i915 = to_i915(state->base.dev);
3196 if (!new_crtc_state->dsc.compression_enable)
3199 if (drm_WARN_ON(&i915->drm,
3200 !connector->dp.dsc_decompression_aux ||
3201 connector->dp.dsc_decompression_enabled))
3204 if (!intel_dp_dsc_aux_get_ref(state, connector))
3207 intel_dp_sink_set_dsc_passthrough(connector, true);
3208 intel_dp_sink_set_dsc_decompression(connector, true);
3212 * intel_dp_sink_disable_decompression - Disable DSC decompression in sink/last branch device
3213 * @state: atomic state
3214 * @connector: connector to disable the decompression for
3215 * @old_crtc_state: old state for the CRTC driving @connector
3217 * Disable the DSC decompression if required in the %DP_DSC_ENABLE DPCD
3218 * register of the appropriate sink/branch device, corresponding to the
3219 * sequence in intel_dp_sink_enable_decompression().
3221 void intel_dp_sink_disable_decompression(struct intel_atomic_state *state,
3222 struct intel_connector *connector,
3223 const struct intel_crtc_state *old_crtc_state)
3225 struct drm_i915_private *i915 = to_i915(state->base.dev);
3227 if (!old_crtc_state->dsc.compression_enable)
3230 if (drm_WARN_ON(&i915->drm,
3231 !connector->dp.dsc_decompression_aux ||
3232 !connector->dp.dsc_decompression_enabled))
3235 if (!intel_dp_dsc_aux_put_ref(state, connector))
3238 intel_dp_sink_set_dsc_decompression(connector, false);
3239 intel_dp_sink_set_dsc_passthrough(connector, false);
3243 intel_edp_init_source_oui(struct intel_dp *intel_dp, bool careful)
3245 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
3246 u8 oui[] = { 0x00, 0xaa, 0x01 };
3250 * During driver init, we want to be careful and avoid changing the source OUI if it's
3251 * already set to what we want, so as to avoid clearing any state by accident
3254 if (drm_dp_dpcd_read(&intel_dp->aux, DP_SOURCE_OUI, buf, sizeof(buf)) < 0)
3255 drm_err(&i915->drm, "Failed to read source OUI\n");
3257 if (memcmp(oui, buf, sizeof(oui)) == 0)
3261 if (drm_dp_dpcd_write(&intel_dp->aux, DP_SOURCE_OUI, oui, sizeof(oui)) < 0)
3262 drm_err(&i915->drm, "Failed to write source OUI\n");
3264 intel_dp->last_oui_write = jiffies;
3267 void intel_dp_wait_source_oui(struct intel_dp *intel_dp)
3269 struct intel_connector *connector = intel_dp->attached_connector;
3270 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
3272 drm_dbg_kms(&i915->drm, "[CONNECTOR:%d:%s] Performing OUI wait (%u ms)\n",
3273 connector->base.base.id, connector->base.name,
3274 connector->panel.vbt.backlight.hdr_dpcd_refresh_timeout);
3276 wait_remaining_ms_from_jiffies(intel_dp->last_oui_write,
3277 connector->panel.vbt.backlight.hdr_dpcd_refresh_timeout);
3280 /* If the device supports it, try to set the power state appropriately */
3281 void intel_dp_set_power(struct intel_dp *intel_dp, u8 mode)
3283 struct intel_encoder *encoder = &dp_to_dig_port(intel_dp)->base;
3284 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
3287 /* Should have a valid DPCD by this point */
3288 if (intel_dp->dpcd[DP_DPCD_REV] < 0x11)
3291 if (mode != DP_SET_POWER_D0) {
3292 if (downstream_hpd_needs_d0(intel_dp))
3295 ret = drm_dp_dpcd_writeb(&intel_dp->aux, DP_SET_POWER, mode);
3297 struct intel_lspcon *lspcon = dp_to_lspcon(intel_dp);
3299 lspcon_resume(dp_to_dig_port(intel_dp));
3301 /* Write the source OUI as early as possible */
3302 if (intel_dp_is_edp(intel_dp))
3303 intel_edp_init_source_oui(intel_dp, false);
3306 * When turning on, we need to retry for 1ms to give the sink
3309 for (i = 0; i < 3; i++) {
3310 ret = drm_dp_dpcd_writeb(&intel_dp->aux, DP_SET_POWER, mode);
3316 if (ret == 1 && lspcon->active)
3317 lspcon_wait_pcon_mode(lspcon);
3321 drm_dbg_kms(&i915->drm, "[ENCODER:%d:%s] Set power to %s failed\n",
3322 encoder->base.base.id, encoder->base.name,
3323 mode == DP_SET_POWER_D0 ? "D0" : "D3");
3327 intel_dp_get_dpcd(struct intel_dp *intel_dp);
3330 * intel_dp_sync_state - sync the encoder state during init/resume
3331 * @encoder: intel encoder to sync
3332 * @crtc_state: state for the CRTC connected to the encoder
3334 * Sync any state stored in the encoder wrt. HW state during driver init
3335 * and system resume.
3337 void intel_dp_sync_state(struct intel_encoder *encoder,
3338 const struct intel_crtc_state *crtc_state)
3340 struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
3341 bool dpcd_updated = false;
3344 * Don't clobber DPCD if it's been already read out during output
3345 * setup (eDP) or detect.
3347 if (crtc_state && intel_dp->dpcd[DP_DPCD_REV] == 0) {
3348 intel_dp_get_dpcd(intel_dp);
3349 dpcd_updated = true;
3352 intel_dp_tunnel_resume(intel_dp, crtc_state, dpcd_updated);
3355 intel_dp_reset_max_link_params(intel_dp);
3358 bool intel_dp_initial_fastset_check(struct intel_encoder *encoder,
3359 struct intel_crtc_state *crtc_state)
3361 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
3362 struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
3363 bool fastset = true;
3366 * If BIOS has set an unsupported or non-standard link rate for some
3367 * reason force an encoder recompute and full modeset.
3369 if (intel_dp_rate_index(intel_dp->source_rates, intel_dp->num_source_rates,
3370 crtc_state->port_clock) < 0) {
3371 drm_dbg_kms(&i915->drm, "[ENCODER:%d:%s] Forcing full modeset due to unsupported link rate\n",
3372 encoder->base.base.id, encoder->base.name);
3373 crtc_state->uapi.connectors_changed = true;
3378 * FIXME hack to force full modeset when DSC is being used.
3380 * As long as we do not have full state readout and config comparison
3381 * of crtc_state->dsc, we have no way to ensure reliable fastset.
3382 * Remove once we have readout for DSC.
3384 if (crtc_state->dsc.compression_enable) {
3385 drm_dbg_kms(&i915->drm, "[ENCODER:%d:%s] Forcing full modeset due to DSC being enabled\n",
3386 encoder->base.base.id, encoder->base.name);
3387 crtc_state->uapi.mode_changed = true;
3391 if (CAN_PANEL_REPLAY(intel_dp)) {
3392 drm_dbg_kms(&i915->drm,
3393 "[ENCODER:%d:%s] Forcing full modeset to compute panel replay state\n",
3394 encoder->base.base.id, encoder->base.name);
3395 crtc_state->uapi.mode_changed = true;
3402 static void intel_dp_get_pcon_dsc_cap(struct intel_dp *intel_dp)
3404 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
3406 /* Clear the cached register set to avoid using stale values */
3408 memset(intel_dp->pcon_dsc_dpcd, 0, sizeof(intel_dp->pcon_dsc_dpcd));
3410 if (drm_dp_dpcd_read(&intel_dp->aux, DP_PCON_DSC_ENCODER,
3411 intel_dp->pcon_dsc_dpcd,
3412 sizeof(intel_dp->pcon_dsc_dpcd)) < 0)
3413 drm_err(&i915->drm, "Failed to read DPCD register 0x%x\n",
3414 DP_PCON_DSC_ENCODER);
3416 drm_dbg_kms(&i915->drm, "PCON ENCODER DSC DPCD: %*ph\n",
3417 (int)sizeof(intel_dp->pcon_dsc_dpcd), intel_dp->pcon_dsc_dpcd);
3420 static int intel_dp_pcon_get_frl_mask(u8 frl_bw_mask)
3422 int bw_gbps[] = {9, 18, 24, 32, 40, 48};
3425 for (i = ARRAY_SIZE(bw_gbps) - 1; i >= 0; i--) {
3426 if (frl_bw_mask & (1 << i))
3432 static int intel_dp_pcon_set_frl_mask(int max_frl)
3436 return DP_PCON_FRL_BW_MASK_48GBPS;
3438 return DP_PCON_FRL_BW_MASK_40GBPS;
3440 return DP_PCON_FRL_BW_MASK_32GBPS;
3442 return DP_PCON_FRL_BW_MASK_24GBPS;
3444 return DP_PCON_FRL_BW_MASK_18GBPS;
3446 return DP_PCON_FRL_BW_MASK_9GBPS;
3452 static int intel_dp_hdmi_sink_max_frl(struct intel_dp *intel_dp)
3454 struct intel_connector *intel_connector = intel_dp->attached_connector;
3455 struct drm_connector *connector = &intel_connector->base;
3457 int max_lanes, rate_per_lane;
3458 int max_dsc_lanes, dsc_rate_per_lane;
3460 max_lanes = connector->display_info.hdmi.max_lanes;
3461 rate_per_lane = connector->display_info.hdmi.max_frl_rate_per_lane;
3462 max_frl_rate = max_lanes * rate_per_lane;
3464 if (connector->display_info.hdmi.dsc_cap.v_1p2) {
3465 max_dsc_lanes = connector->display_info.hdmi.dsc_cap.max_lanes;
3466 dsc_rate_per_lane = connector->display_info.hdmi.dsc_cap.max_frl_rate_per_lane;
3467 if (max_dsc_lanes && dsc_rate_per_lane)
3468 max_frl_rate = min(max_frl_rate, max_dsc_lanes * dsc_rate_per_lane);
3471 return max_frl_rate;
3475 intel_dp_pcon_is_frl_trained(struct intel_dp *intel_dp,
3476 u8 max_frl_bw_mask, u8 *frl_trained_mask)
3478 if (drm_dp_pcon_hdmi_link_active(&intel_dp->aux) &&
3479 drm_dp_pcon_hdmi_link_mode(&intel_dp->aux, frl_trained_mask) == DP_PCON_HDMI_MODE_FRL &&
3480 *frl_trained_mask >= max_frl_bw_mask)
3486 static int intel_dp_pcon_start_frl_training(struct intel_dp *intel_dp)
3488 #define TIMEOUT_FRL_READY_MS 500
3489 #define TIMEOUT_HDMI_LINK_ACTIVE_MS 1000
3491 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
3492 int max_frl_bw, max_pcon_frl_bw, max_edid_frl_bw, ret;
3493 u8 max_frl_bw_mask = 0, frl_trained_mask;
3496 max_pcon_frl_bw = intel_dp->dfp.pcon_max_frl_bw;
3497 drm_dbg(&i915->drm, "PCON max rate = %d Gbps\n", max_pcon_frl_bw);
3499 max_edid_frl_bw = intel_dp_hdmi_sink_max_frl(intel_dp);
3500 drm_dbg(&i915->drm, "Sink max rate from EDID = %d Gbps\n", max_edid_frl_bw);
3502 max_frl_bw = min(max_edid_frl_bw, max_pcon_frl_bw);
3504 if (max_frl_bw <= 0)
3507 max_frl_bw_mask = intel_dp_pcon_set_frl_mask(max_frl_bw);
3508 drm_dbg(&i915->drm, "MAX_FRL_BW_MASK = %u\n", max_frl_bw_mask);
3510 if (intel_dp_pcon_is_frl_trained(intel_dp, max_frl_bw_mask, &frl_trained_mask))
3513 ret = drm_dp_pcon_frl_prepare(&intel_dp->aux, false);
3516 /* Wait for PCON to be FRL Ready */
3517 wait_for(is_active = drm_dp_pcon_is_frl_ready(&intel_dp->aux) == true, TIMEOUT_FRL_READY_MS);
3522 ret = drm_dp_pcon_frl_configure_1(&intel_dp->aux, max_frl_bw,
3523 DP_PCON_ENABLE_SEQUENTIAL_LINK);
3526 ret = drm_dp_pcon_frl_configure_2(&intel_dp->aux, max_frl_bw_mask,
3527 DP_PCON_FRL_LINK_TRAIN_NORMAL);
3530 ret = drm_dp_pcon_frl_enable(&intel_dp->aux);
3534 * Wait for FRL to be completed
3535 * Check if the HDMI Link is up and active.
3537 wait_for(is_active =
3538 intel_dp_pcon_is_frl_trained(intel_dp, max_frl_bw_mask, &frl_trained_mask),
3539 TIMEOUT_HDMI_LINK_ACTIVE_MS);
3545 drm_dbg(&i915->drm, "FRL_TRAINED_MASK = %u\n", frl_trained_mask);
3546 intel_dp->frl.trained_rate_gbps = intel_dp_pcon_get_frl_mask(frl_trained_mask);
3547 intel_dp->frl.is_trained = true;
3548 drm_dbg(&i915->drm, "FRL trained with : %d Gbps\n", intel_dp->frl.trained_rate_gbps);
3553 static bool intel_dp_is_hdmi_2_1_sink(struct intel_dp *intel_dp)
3555 if (drm_dp_is_branch(intel_dp->dpcd) &&
3556 intel_dp_has_hdmi_sink(intel_dp) &&
3557 intel_dp_hdmi_sink_max_frl(intel_dp) > 0)
3564 int intel_dp_pcon_set_tmds_mode(struct intel_dp *intel_dp)
3569 /* Set PCON source control mode */
3570 buf |= DP_PCON_ENABLE_SOURCE_CTL_MODE;
3572 ret = drm_dp_dpcd_writeb(&intel_dp->aux, DP_PCON_HDMI_LINK_CONFIG_1, buf);
3576 /* Set HDMI LINK ENABLE */
3577 buf |= DP_PCON_ENABLE_HDMI_LINK;
3578 ret = drm_dp_dpcd_writeb(&intel_dp->aux, DP_PCON_HDMI_LINK_CONFIG_1, buf);
3585 void intel_dp_check_frl_training(struct intel_dp *intel_dp)
3587 struct drm_i915_private *dev_priv = dp_to_i915(intel_dp);
3590 * Always go for FRL training if:
3591 * -PCON supports SRC_CTL_MODE (VESA DP2.0-HDMI2.1 PCON Spec Draft-1 Sec-7)
3594 if (!(intel_dp->downstream_ports[2] & DP_PCON_SOURCE_CTL_MODE) ||
3595 !intel_dp_is_hdmi_2_1_sink(intel_dp) ||
3596 intel_dp->frl.is_trained)
3599 if (intel_dp_pcon_start_frl_training(intel_dp) < 0) {
3602 drm_dbg(&dev_priv->drm, "Couldn't set FRL mode, continuing with TMDS mode\n");
3603 ret = intel_dp_pcon_set_tmds_mode(intel_dp);
3604 mode = drm_dp_pcon_hdmi_link_mode(&intel_dp->aux, NULL);
3606 if (ret < 0 || mode != DP_PCON_HDMI_MODE_TMDS)
3607 drm_dbg(&dev_priv->drm, "Issue with PCON, cannot set TMDS mode\n");
3609 drm_dbg(&dev_priv->drm, "FRL training Completed\n");
3614 intel_dp_pcon_dsc_enc_slice_height(const struct intel_crtc_state *crtc_state)
3616 int vactive = crtc_state->hw.adjusted_mode.vdisplay;
3618 return intel_hdmi_dsc_get_slice_height(vactive);
3622 intel_dp_pcon_dsc_enc_slices(struct intel_dp *intel_dp,
3623 const struct intel_crtc_state *crtc_state)
3625 struct intel_connector *intel_connector = intel_dp->attached_connector;
3626 struct drm_connector *connector = &intel_connector->base;
3627 int hdmi_throughput = connector->display_info.hdmi.dsc_cap.clk_per_slice;
3628 int hdmi_max_slices = connector->display_info.hdmi.dsc_cap.max_slices;
3629 int pcon_max_slices = drm_dp_pcon_dsc_max_slices(intel_dp->pcon_dsc_dpcd);
3630 int pcon_max_slice_width = drm_dp_pcon_dsc_max_slice_width(intel_dp->pcon_dsc_dpcd);
3632 return intel_hdmi_dsc_get_num_slices(crtc_state, pcon_max_slices,
3633 pcon_max_slice_width,
3634 hdmi_max_slices, hdmi_throughput);
3638 intel_dp_pcon_dsc_enc_bpp(struct intel_dp *intel_dp,
3639 const struct intel_crtc_state *crtc_state,
3640 int num_slices, int slice_width)
3642 struct intel_connector *intel_connector = intel_dp->attached_connector;
3643 struct drm_connector *connector = &intel_connector->base;
3644 int output_format = crtc_state->output_format;
3645 bool hdmi_all_bpp = connector->display_info.hdmi.dsc_cap.all_bpp;
3646 int pcon_fractional_bpp = drm_dp_pcon_dsc_bpp_incr(intel_dp->pcon_dsc_dpcd);
3647 int hdmi_max_chunk_bytes =
3648 connector->display_info.hdmi.dsc_cap.total_chunk_kbytes * 1024;
3650 return intel_hdmi_dsc_get_bpp(pcon_fractional_bpp, slice_width,
3651 num_slices, output_format, hdmi_all_bpp,
3652 hdmi_max_chunk_bytes);
3656 intel_dp_pcon_dsc_configure(struct intel_dp *intel_dp,
3657 const struct intel_crtc_state *crtc_state)
3665 struct intel_connector *intel_connector = intel_dp->attached_connector;
3666 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
3667 struct drm_connector *connector;
3668 bool hdmi_is_dsc_1_2;
3670 if (!intel_dp_is_hdmi_2_1_sink(intel_dp))
3673 if (!intel_connector)
3675 connector = &intel_connector->base;
3676 hdmi_is_dsc_1_2 = connector->display_info.hdmi.dsc_cap.v_1p2;
3678 if (!drm_dp_pcon_enc_is_dsc_1_2(intel_dp->pcon_dsc_dpcd) ||
3682 slice_height = intel_dp_pcon_dsc_enc_slice_height(crtc_state);
3686 num_slices = intel_dp_pcon_dsc_enc_slices(intel_dp, crtc_state);
3690 slice_width = DIV_ROUND_UP(crtc_state->hw.adjusted_mode.hdisplay,
3693 bits_per_pixel = intel_dp_pcon_dsc_enc_bpp(intel_dp, crtc_state,
3694 num_slices, slice_width);
3695 if (!bits_per_pixel)
3698 pps_param[0] = slice_height & 0xFF;
3699 pps_param[1] = slice_height >> 8;
3700 pps_param[2] = slice_width & 0xFF;
3701 pps_param[3] = slice_width >> 8;
3702 pps_param[4] = bits_per_pixel & 0xFF;
3703 pps_param[5] = (bits_per_pixel >> 8) & 0x3;
3705 ret = drm_dp_pcon_pps_override_param(&intel_dp->aux, pps_param);
3707 drm_dbg_kms(&i915->drm, "Failed to set pcon DSC\n");
3710 void intel_dp_configure_protocol_converter(struct intel_dp *intel_dp,
3711 const struct intel_crtc_state *crtc_state)
3713 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
3714 bool ycbcr444_to_420 = false;
3715 bool rgb_to_ycbcr = false;
3718 if (intel_dp->dpcd[DP_DPCD_REV] < 0x13)
3721 if (!drm_dp_is_branch(intel_dp->dpcd))
3724 tmp = intel_dp_has_hdmi_sink(intel_dp) ? DP_HDMI_DVI_OUTPUT_CONFIG : 0;
3726 if (drm_dp_dpcd_writeb(&intel_dp->aux,
3727 DP_PROTOCOL_CONVERTER_CONTROL_0, tmp) != 1)
3728 drm_dbg_kms(&i915->drm, "Failed to %s protocol converter HDMI mode\n",
3729 str_enable_disable(intel_dp_has_hdmi_sink(intel_dp)));
3731 if (crtc_state->sink_format == INTEL_OUTPUT_FORMAT_YCBCR420) {
3732 switch (crtc_state->output_format) {
3733 case INTEL_OUTPUT_FORMAT_YCBCR420:
3735 case INTEL_OUTPUT_FORMAT_YCBCR444:
3736 ycbcr444_to_420 = true;
3738 case INTEL_OUTPUT_FORMAT_RGB:
3739 rgb_to_ycbcr = true;
3740 ycbcr444_to_420 = true;
3743 MISSING_CASE(crtc_state->output_format);
3746 } else if (crtc_state->sink_format == INTEL_OUTPUT_FORMAT_YCBCR444) {
3747 switch (crtc_state->output_format) {
3748 case INTEL_OUTPUT_FORMAT_YCBCR444:
3750 case INTEL_OUTPUT_FORMAT_RGB:
3751 rgb_to_ycbcr = true;
3754 MISSING_CASE(crtc_state->output_format);
3759 tmp = ycbcr444_to_420 ? DP_CONVERSION_TO_YCBCR420_ENABLE : 0;
3761 if (drm_dp_dpcd_writeb(&intel_dp->aux,
3762 DP_PROTOCOL_CONVERTER_CONTROL_1, tmp) != 1)
3763 drm_dbg_kms(&i915->drm,
3764 "Failed to %s protocol converter YCbCr 4:2:0 conversion mode\n",
3765 str_enable_disable(intel_dp->dfp.ycbcr_444_to_420));
3767 tmp = rgb_to_ycbcr ? DP_CONVERSION_BT709_RGB_YCBCR_ENABLE : 0;
3769 if (drm_dp_pcon_convert_rgb_to_ycbcr(&intel_dp->aux, tmp) < 0)
3770 drm_dbg_kms(&i915->drm,
3771 "Failed to %s protocol converter RGB->YCbCr conversion mode\n",
3772 str_enable_disable(tmp));
3775 bool intel_dp_get_colorimetry_status(struct intel_dp *intel_dp)
3779 if (drm_dp_dpcd_readb(&intel_dp->aux, DP_DPRX_FEATURE_ENUMERATION_LIST,
3782 return dprx & DP_VSC_SDP_EXT_FOR_COLORIMETRY_SUPPORTED;
3785 static void intel_dp_read_dsc_dpcd(struct drm_dp_aux *aux,
3786 u8 dsc_dpcd[DP_DSC_RECEIVER_CAP_SIZE])
3788 if (drm_dp_dpcd_read(aux, DP_DSC_SUPPORT, dsc_dpcd,
3789 DP_DSC_RECEIVER_CAP_SIZE) < 0) {
3790 drm_err(aux->drm_dev,
3791 "Failed to read DPCD register 0x%x\n",
3796 drm_dbg_kms(aux->drm_dev, "DSC DPCD: %*ph\n",
3797 DP_DSC_RECEIVER_CAP_SIZE,
3801 void intel_dp_get_dsc_sink_cap(u8 dpcd_rev, struct intel_connector *connector)
3803 struct drm_i915_private *i915 = to_i915(connector->base.dev);
3806 * Clear the cached register set to avoid using stale values
3807 * for the sinks that do not support DSC.
3809 memset(connector->dp.dsc_dpcd, 0, sizeof(connector->dp.dsc_dpcd));
3811 /* Clear fec_capable to avoid using stale values */
3812 connector->dp.fec_capability = 0;
3814 if (dpcd_rev < DP_DPCD_REV_14)
3817 intel_dp_read_dsc_dpcd(connector->dp.dsc_decompression_aux,
3818 connector->dp.dsc_dpcd);
3820 if (drm_dp_dpcd_readb(connector->dp.dsc_decompression_aux, DP_FEC_CAPABILITY,
3821 &connector->dp.fec_capability) < 0) {
3822 drm_err(&i915->drm, "Failed to read FEC DPCD register\n");
3826 drm_dbg_kms(&i915->drm, "FEC CAPABILITY: %x\n",
3827 connector->dp.fec_capability);
3830 static void intel_edp_get_dsc_sink_cap(u8 edp_dpcd_rev, struct intel_connector *connector)
3832 if (edp_dpcd_rev < DP_EDP_14)
3835 intel_dp_read_dsc_dpcd(connector->dp.dsc_decompression_aux, connector->dp.dsc_dpcd);
3838 static void intel_edp_mso_mode_fixup(struct intel_connector *connector,
3839 struct drm_display_mode *mode)
3841 struct intel_dp *intel_dp = intel_attached_dp(connector);
3842 struct drm_i915_private *i915 = to_i915(connector->base.dev);
3843 int n = intel_dp->mso_link_count;
3844 int overlap = intel_dp->mso_pixel_overlap;
3849 mode->hdisplay = (mode->hdisplay - overlap) * n;
3850 mode->hsync_start = (mode->hsync_start - overlap) * n;
3851 mode->hsync_end = (mode->hsync_end - overlap) * n;
3852 mode->htotal = (mode->htotal - overlap) * n;
3855 drm_mode_set_name(mode);
3857 drm_dbg_kms(&i915->drm,
3858 "[CONNECTOR:%d:%s] using generated MSO mode: " DRM_MODE_FMT "\n",
3859 connector->base.base.id, connector->base.name,
3860 DRM_MODE_ARG(mode));
3863 void intel_edp_fixup_vbt_bpp(struct intel_encoder *encoder, int pipe_bpp)
3865 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
3866 struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
3867 struct intel_connector *connector = intel_dp->attached_connector;
3869 if (connector->panel.vbt.edp.bpp && pipe_bpp > connector->panel.vbt.edp.bpp) {
3871 * This is a big fat ugly hack.
3873 * Some machines in UEFI boot mode provide us a VBT that has 18
3874 * bpp and 1.62 GHz link bandwidth for eDP, which for reasons
3875 * unknown we fail to light up. Yet the same BIOS boots up with
3876 * 24 bpp and 2.7 GHz link. Use the same bpp as the BIOS uses as
3877 * max, not what it tells us to use.
3879 * Note: This will still be broken if the eDP panel is not lit
3880 * up by the BIOS, and thus we can't get the mode at module
3883 drm_dbg_kms(&dev_priv->drm,
3884 "pipe has %d bpp for eDP panel, overriding BIOS-provided max %d bpp\n",
3885 pipe_bpp, connector->panel.vbt.edp.bpp);
3886 connector->panel.vbt.edp.bpp = pipe_bpp;
3890 static void intel_edp_mso_init(struct intel_dp *intel_dp)
3892 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
3893 struct intel_connector *connector = intel_dp->attached_connector;
3894 struct drm_display_info *info = &connector->base.display_info;
3897 if (intel_dp->edp_dpcd[0] < DP_EDP_14)
3900 if (drm_dp_dpcd_readb(&intel_dp->aux, DP_EDP_MSO_LINK_CAPABILITIES, &mso) != 1) {
3901 drm_err(&i915->drm, "Failed to read MSO cap\n");
3905 /* Valid configurations are SST or MSO 2x1, 2x2, 4x1 */
3906 mso &= DP_EDP_MSO_NUMBER_OF_LINKS_MASK;
3907 if (mso % 2 || mso > drm_dp_max_lane_count(intel_dp->dpcd)) {
3908 drm_err(&i915->drm, "Invalid MSO link count cap %u\n", mso);
3913 drm_dbg_kms(&i915->drm, "Sink MSO %ux%u configuration, pixel overlap %u\n",
3914 mso, drm_dp_max_lane_count(intel_dp->dpcd) / mso,
3915 info->mso_pixel_overlap);
3916 if (!HAS_MSO(i915)) {
3917 drm_err(&i915->drm, "No source MSO support, disabling\n");
3922 intel_dp->mso_link_count = mso;
3923 intel_dp->mso_pixel_overlap = mso ? info->mso_pixel_overlap : 0;
3927 intel_edp_init_dpcd(struct intel_dp *intel_dp, struct intel_connector *connector)
3929 struct drm_i915_private *dev_priv =
3930 to_i915(dp_to_dig_port(intel_dp)->base.base.dev);
3932 /* this function is meant to be called only once */
3933 drm_WARN_ON(&dev_priv->drm, intel_dp->dpcd[DP_DPCD_REV] != 0);
3935 if (drm_dp_read_dpcd_caps(&intel_dp->aux, intel_dp->dpcd) != 0)
3938 drm_dp_read_desc(&intel_dp->aux, &intel_dp->desc,
3939 drm_dp_is_branch(intel_dp->dpcd));
3942 * Read the eDP display control registers.
3944 * Do this independent of DP_DPCD_DISPLAY_CONTROL_CAPABLE bit in
3945 * DP_EDP_CONFIGURATION_CAP, because some buggy displays do not have it
3946 * set, but require eDP 1.4+ detection (e.g. for supported link rates
3947 * method). The display control registers should read zero if they're
3948 * not supported anyway.
3950 if (drm_dp_dpcd_read(&intel_dp->aux, DP_EDP_DPCD_REV,
3951 intel_dp->edp_dpcd, sizeof(intel_dp->edp_dpcd)) ==
3952 sizeof(intel_dp->edp_dpcd)) {
3953 drm_dbg_kms(&dev_priv->drm, "eDP DPCD: %*ph\n",
3954 (int)sizeof(intel_dp->edp_dpcd),
3955 intel_dp->edp_dpcd);
3957 intel_dp->use_max_params = intel_dp->edp_dpcd[0] < DP_EDP_14;
3961 * This has to be called after intel_dp->edp_dpcd is filled, PSR checks
3962 * for SET_POWER_CAPABLE bit in intel_dp->edp_dpcd[1]
3964 intel_psr_init_dpcd(intel_dp);
3966 /* Clear the default sink rates */
3967 intel_dp->num_sink_rates = 0;
3969 /* Read the eDP 1.4+ supported link rates. */
3970 if (intel_dp->edp_dpcd[0] >= DP_EDP_14) {
3971 __le16 sink_rates[DP_MAX_SUPPORTED_RATES];
3974 drm_dp_dpcd_read(&intel_dp->aux, DP_SUPPORTED_LINK_RATES,
3975 sink_rates, sizeof(sink_rates));
3977 for (i = 0; i < ARRAY_SIZE(sink_rates); i++) {
3978 int val = le16_to_cpu(sink_rates[i]);
3983 /* Value read multiplied by 200kHz gives the per-lane
3984 * link rate in kHz. The source rates are, however,
3985 * stored in terms of LS_Clk kHz. The full conversion
3986 * back to symbols is
3987 * (val * 200kHz)*(8/10 ch. encoding)*(1/8 bit to Byte)
3989 intel_dp->sink_rates[i] = (val * 200) / 10;
3991 intel_dp->num_sink_rates = i;
3995 * Use DP_LINK_RATE_SET if DP_SUPPORTED_LINK_RATES are available,
3996 * default to DP_MAX_LINK_RATE and DP_LINK_BW_SET otherwise.
3998 if (intel_dp->num_sink_rates)
3999 intel_dp->use_rate_select = true;
4001 intel_dp_set_sink_rates(intel_dp);
4002 intel_dp_set_max_sink_lane_count(intel_dp);
4004 /* Read the eDP DSC DPCD registers */
4005 if (HAS_DSC(dev_priv))
4006 intel_edp_get_dsc_sink_cap(intel_dp->edp_dpcd[0],
4010 * If needed, program our source OUI so we can make various Intel-specific AUX services
4011 * available (such as HDR backlight controls)
4013 intel_edp_init_source_oui(intel_dp, true);
4019 intel_dp_has_sink_count(struct intel_dp *intel_dp)
4021 if (!intel_dp->attached_connector)
4024 return drm_dp_read_sink_count_cap(&intel_dp->attached_connector->base,
4029 void intel_dp_update_sink_caps(struct intel_dp *intel_dp)
4031 intel_dp_set_sink_rates(intel_dp);
4032 intel_dp_set_max_sink_lane_count(intel_dp);
4033 intel_dp_set_common_rates(intel_dp);
4037 intel_dp_get_dpcd(struct intel_dp *intel_dp)
4041 if (intel_dp_init_lttpr_and_dprx_caps(intel_dp) < 0)
4045 * Don't clobber cached eDP rates. Also skip re-reading
4046 * the OUI/ID since we know it won't change.
4048 if (!intel_dp_is_edp(intel_dp)) {
4049 drm_dp_read_desc(&intel_dp->aux, &intel_dp->desc,
4050 drm_dp_is_branch(intel_dp->dpcd));
4052 intel_dp_update_sink_caps(intel_dp);
4055 if (intel_dp_has_sink_count(intel_dp)) {
4056 ret = drm_dp_read_sink_count(&intel_dp->aux);
4061 * Sink count can change between short pulse hpd hence
4062 * a member variable in intel_dp will track any changes
4063 * between short pulse interrupts.
4065 intel_dp->sink_count = ret;
4068 * SINK_COUNT == 0 and DOWNSTREAM_PORT_PRESENT == 1 implies that
4069 * a dongle is present but no display. Unless we require to know
4070 * if a dongle is present or not, we don't need to update
4071 * downstream port information. So, an early return here saves
4072 * time from performing other operations which are not required.
4074 if (!intel_dp->sink_count)
4078 return drm_dp_read_downstream_info(&intel_dp->aux, intel_dp->dpcd,
4079 intel_dp->downstream_ports) == 0;
4082 static const char *intel_dp_mst_mode_str(enum drm_dp_mst_mode mst_mode)
4084 if (mst_mode == DRM_DP_MST)
4086 else if (mst_mode == DRM_DP_SST_SIDEBAND_MSG)
4087 return "SST w/ sideband messaging";
4092 static enum drm_dp_mst_mode
4093 intel_dp_mst_mode_choose(struct intel_dp *intel_dp,
4094 enum drm_dp_mst_mode sink_mst_mode)
4096 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
4098 if (!i915->display.params.enable_dp_mst)
4101 if (!intel_dp_mst_source_support(intel_dp))
4104 if (sink_mst_mode == DRM_DP_SST_SIDEBAND_MSG &&
4105 !(intel_dp->dpcd[DP_MAIN_LINK_CHANNEL_CODING] & DP_CAP_ANSI_128B132B))
4108 return sink_mst_mode;
4111 static enum drm_dp_mst_mode
4112 intel_dp_mst_detect(struct intel_dp *intel_dp)
4114 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
4115 struct intel_encoder *encoder = &dp_to_dig_port(intel_dp)->base;
4116 enum drm_dp_mst_mode sink_mst_mode;
4117 enum drm_dp_mst_mode mst_detect;
4119 sink_mst_mode = drm_dp_read_mst_cap(&intel_dp->aux, intel_dp->dpcd);
4121 mst_detect = intel_dp_mst_mode_choose(intel_dp, sink_mst_mode);
4123 drm_dbg_kms(&i915->drm,
4124 "[ENCODER:%d:%s] MST support: port: %s, sink: %s, modparam: %s -> enable: %s\n",
4125 encoder->base.base.id, encoder->base.name,
4126 str_yes_no(intel_dp_mst_source_support(intel_dp)),
4127 intel_dp_mst_mode_str(sink_mst_mode),
4128 str_yes_no(i915->display.params.enable_dp_mst),
4129 intel_dp_mst_mode_str(mst_detect));
4135 intel_dp_mst_configure(struct intel_dp *intel_dp)
4137 if (!intel_dp_mst_source_support(intel_dp))
4140 intel_dp->is_mst = intel_dp->mst_detect != DRM_DP_SST;
4142 drm_dp_mst_topology_mgr_set_mst(&intel_dp->mst_mgr, intel_dp->is_mst);
4144 /* Avoid stale info on the next detect cycle. */
4145 intel_dp->mst_detect = DRM_DP_SST;
4149 intel_dp_mst_disconnect(struct intel_dp *intel_dp)
4151 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
4153 if (!intel_dp->is_mst)
4156 drm_dbg_kms(&i915->drm, "MST device may have disappeared %d vs %d\n",
4157 intel_dp->is_mst, intel_dp->mst_mgr.mst_state);
4158 intel_dp->is_mst = false;
4159 drm_dp_mst_topology_mgr_set_mst(&intel_dp->mst_mgr, intel_dp->is_mst);
4163 intel_dp_get_sink_irq_esi(struct intel_dp *intel_dp, u8 *esi)
4165 return drm_dp_dpcd_read(&intel_dp->aux, DP_SINK_COUNT_ESI, esi, 4) == 4;
4168 static bool intel_dp_ack_sink_irq_esi(struct intel_dp *intel_dp, u8 esi[4])
4172 for (retry = 0; retry < 3; retry++) {
4173 if (drm_dp_dpcd_write(&intel_dp->aux, DP_SINK_COUNT_ESI + 1,
4182 intel_dp_needs_vsc_sdp(const struct intel_crtc_state *crtc_state,
4183 const struct drm_connector_state *conn_state)
4186 * As per DP 1.4a spec section 2.2.4.3 [MSA Field for Indication
4187 * of Color Encoding Format and Content Color Gamut], in order to
4188 * sending YCBCR 420 or HDR BT.2020 signals we should use DP VSC SDP.
4190 if (crtc_state->output_format == INTEL_OUTPUT_FORMAT_YCBCR420)
4193 switch (conn_state->colorspace) {
4194 case DRM_MODE_COLORIMETRY_SYCC_601:
4195 case DRM_MODE_COLORIMETRY_OPYCC_601:
4196 case DRM_MODE_COLORIMETRY_BT2020_YCC:
4197 case DRM_MODE_COLORIMETRY_BT2020_RGB:
4198 case DRM_MODE_COLORIMETRY_BT2020_CYCC:
4207 static ssize_t intel_dp_as_sdp_pack(const struct drm_dp_as_sdp *as_sdp,
4208 struct dp_sdp *sdp, size_t size)
4210 size_t length = sizeof(struct dp_sdp);
4215 memset(sdp, 0, size);
4217 /* Prepare AS (Adaptive Sync) SDP Header */
4218 sdp->sdp_header.HB0 = 0;
4219 sdp->sdp_header.HB1 = as_sdp->sdp_type;
4220 sdp->sdp_header.HB2 = 0x02;
4221 sdp->sdp_header.HB3 = as_sdp->length;
4223 /* Fill AS (Adaptive Sync) SDP Payload */
4224 sdp->db[0] = as_sdp->mode;
4225 sdp->db[1] = as_sdp->vtotal & 0xFF;
4226 sdp->db[2] = (as_sdp->vtotal >> 8) & 0xFF;
4227 sdp->db[3] = as_sdp->target_rr & 0xFF;
4228 sdp->db[4] = (as_sdp->target_rr >> 8) & 0x3;
4234 intel_dp_hdr_metadata_infoframe_sdp_pack(struct drm_i915_private *i915,
4235 const struct hdmi_drm_infoframe *drm_infoframe,
4239 size_t length = sizeof(struct dp_sdp);
4240 const int infoframe_size = HDMI_INFOFRAME_HEADER_SIZE + HDMI_DRM_INFOFRAME_SIZE;
4241 unsigned char buf[HDMI_INFOFRAME_HEADER_SIZE + HDMI_DRM_INFOFRAME_SIZE];
4247 memset(sdp, 0, size);
4249 len = hdmi_drm_infoframe_pack_only(drm_infoframe, buf, sizeof(buf));
4251 drm_dbg_kms(&i915->drm, "buffer size is smaller than hdr metadata infoframe\n");
4255 if (len != infoframe_size) {
4256 drm_dbg_kms(&i915->drm, "wrong static hdr metadata size\n");
4261 * Set up the infoframe sdp packet for HDR static metadata.
4262 * Prepare VSC Header for SU as per DP 1.4a spec,
4263 * Table 2-100 and Table 2-101
4266 /* Secondary-Data Packet ID, 00h for non-Audio INFOFRAME */
4267 sdp->sdp_header.HB0 = 0;
4269 * Packet Type 80h + Non-audio INFOFRAME Type value
4270 * HDMI_INFOFRAME_TYPE_DRM: 0x87
4271 * - 80h + Non-audio INFOFRAME Type value
4272 * - InfoFrame Type: 0x07
4273 * [CTA-861-G Table-42 Dynamic Range and Mastering InfoFrame]
4275 sdp->sdp_header.HB1 = drm_infoframe->type;
4277 * Least Significant Eight Bits of (Data Byte Count – 1)
4278 * infoframe_size - 1
4280 sdp->sdp_header.HB2 = 0x1D;
4281 /* INFOFRAME SDP Version Number */
4282 sdp->sdp_header.HB3 = (0x13 << 2);
4283 /* CTA Header Byte 2 (INFOFRAME Version Number) */
4284 sdp->db[0] = drm_infoframe->version;
4285 /* CTA Header Byte 3 (Length of INFOFRAME): HDMI_DRM_INFOFRAME_SIZE */
4286 sdp->db[1] = drm_infoframe->length;
4288 * Copy HDMI_DRM_INFOFRAME_SIZE size from a buffer after
4289 * HDMI_INFOFRAME_HEADER_SIZE
4291 BUILD_BUG_ON(sizeof(sdp->db) < HDMI_DRM_INFOFRAME_SIZE + 2);
4292 memcpy(&sdp->db[2], &buf[HDMI_INFOFRAME_HEADER_SIZE],
4293 HDMI_DRM_INFOFRAME_SIZE);
4296 * Size of DP infoframe sdp packet for HDR static metadata consists of
4297 * - DP SDP Header(struct dp_sdp_header): 4 bytes
4298 * - Two Data Blocks: 2 bytes
4299 * CTA Header Byte2 (INFOFRAME Version Number)
4300 * CTA Header Byte3 (Length of INFOFRAME)
4301 * - HDMI_DRM_INFOFRAME_SIZE: 26 bytes
4303 * Prior to GEN11's GMP register size is identical to DP HDR static metadata
4304 * infoframe size. But GEN11+ has larger than that size, write_infoframe
4305 * will pad rest of the size.
4307 return sizeof(struct dp_sdp_header) + 2 + HDMI_DRM_INFOFRAME_SIZE;
4310 static void intel_write_dp_sdp(struct intel_encoder *encoder,
4311 const struct intel_crtc_state *crtc_state,
4314 struct intel_digital_port *dig_port = enc_to_dig_port(encoder);
4315 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
4316 struct dp_sdp sdp = {};
4319 if ((crtc_state->infoframes.enable &
4320 intel_hdmi_infoframe_enable(type)) == 0)
4325 len = drm_dp_vsc_sdp_pack(&crtc_state->infoframes.vsc, &sdp);
4327 case HDMI_PACKET_TYPE_GAMUT_METADATA:
4328 len = intel_dp_hdr_metadata_infoframe_sdp_pack(dev_priv,
4329 &crtc_state->infoframes.drm.drm,
4332 case DP_SDP_ADAPTIVE_SYNC:
4333 len = intel_dp_as_sdp_pack(&crtc_state->infoframes.as_sdp, &sdp,
4341 if (drm_WARN_ON(&dev_priv->drm, len < 0))
4344 dig_port->write_infoframe(encoder, crtc_state, type, &sdp, len);
4347 void intel_dp_set_infoframes(struct intel_encoder *encoder,
4349 const struct intel_crtc_state *crtc_state,
4350 const struct drm_connector_state *conn_state)
4352 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
4353 i915_reg_t reg = HSW_TVIDEO_DIP_CTL(crtc_state->cpu_transcoder);
4354 u32 dip_enable = VIDEO_DIP_ENABLE_AVI_HSW | VIDEO_DIP_ENABLE_GCP_HSW |
4355 VIDEO_DIP_ENABLE_VS_HSW | VIDEO_DIP_ENABLE_GMP_HSW |
4356 VIDEO_DIP_ENABLE_SPD_HSW | VIDEO_DIP_ENABLE_DRM_GLK;
4358 if (HAS_AS_SDP(dev_priv))
4359 dip_enable |= VIDEO_DIP_ENABLE_AS_ADL;
4361 u32 val = intel_de_read(dev_priv, reg) & ~dip_enable;
4363 /* TODO: Sanitize DSC enabling wrt. intel_dsc_dp_pps_write(). */
4364 if (!enable && HAS_DSC(dev_priv))
4365 val &= ~VDIP_ENABLE_PPS;
4367 /* When PSR is enabled, this routine doesn't disable VSC DIP */
4368 if (!crtc_state->has_psr)
4369 val &= ~VIDEO_DIP_ENABLE_VSC_HSW;
4371 intel_de_write(dev_priv, reg, val);
4372 intel_de_posting_read(dev_priv, reg);
4377 intel_write_dp_sdp(encoder, crtc_state, DP_SDP_VSC);
4378 intel_write_dp_sdp(encoder, crtc_state, DP_SDP_ADAPTIVE_SYNC);
4380 intel_write_dp_sdp(encoder, crtc_state, HDMI_PACKET_TYPE_GAMUT_METADATA);
4384 int intel_dp_as_sdp_unpack(struct drm_dp_as_sdp *as_sdp,
4385 const void *buffer, size_t size)
4387 const struct dp_sdp *sdp = buffer;
4389 if (size < sizeof(struct dp_sdp))
4392 memset(as_sdp, 0, sizeof(*as_sdp));
4394 if (sdp->sdp_header.HB0 != 0)
4397 if (sdp->sdp_header.HB1 != DP_SDP_ADAPTIVE_SYNC)
4400 if (sdp->sdp_header.HB2 != 0x02)
4403 if ((sdp->sdp_header.HB3 & 0x3F) != 9)
4406 as_sdp->length = sdp->sdp_header.HB3 & DP_ADAPTIVE_SYNC_SDP_LENGTH;
4407 as_sdp->mode = sdp->db[0] & DP_ADAPTIVE_SYNC_SDP_OPERATION_MODE;
4408 as_sdp->vtotal = (sdp->db[2] << 8) | sdp->db[1];
4409 as_sdp->target_rr = (u64)sdp->db[3] | ((u64)sdp->db[4] & 0x3);
4414 static int intel_dp_vsc_sdp_unpack(struct drm_dp_vsc_sdp *vsc,
4415 const void *buffer, size_t size)
4417 const struct dp_sdp *sdp = buffer;
4419 if (size < sizeof(struct dp_sdp))
4422 memset(vsc, 0, sizeof(*vsc));
4424 if (sdp->sdp_header.HB0 != 0)
4427 if (sdp->sdp_header.HB1 != DP_SDP_VSC)
4430 vsc->sdp_type = sdp->sdp_header.HB1;
4431 vsc->revision = sdp->sdp_header.HB2;
4432 vsc->length = sdp->sdp_header.HB3;
4434 if ((sdp->sdp_header.HB2 == 0x2 && sdp->sdp_header.HB3 == 0x8) ||
4435 (sdp->sdp_header.HB2 == 0x4 && sdp->sdp_header.HB3 == 0xe)) {
4437 * - HB2 = 0x2, HB3 = 0x8
4438 * VSC SDP supporting 3D stereo + PSR
4439 * - HB2 = 0x4, HB3 = 0xe
4440 * VSC SDP supporting 3D stereo + PSR2 with Y-coordinate of
4441 * first scan line of the SU region (applies to eDP v1.4b
4445 } else if (sdp->sdp_header.HB2 == 0x5 && sdp->sdp_header.HB3 == 0x13) {
4447 * - HB2 = 0x5, HB3 = 0x13
4448 * VSC SDP supporting 3D stereo + PSR2 + Pixel Encoding/Colorimetry
4451 vsc->pixelformat = (sdp->db[16] >> 4) & 0xf;
4452 vsc->colorimetry = sdp->db[16] & 0xf;
4453 vsc->dynamic_range = (sdp->db[17] >> 7) & 0x1;
4455 switch (sdp->db[17] & 0x7) {
4472 MISSING_CASE(sdp->db[17] & 0x7);
4476 vsc->content_type = sdp->db[18] & 0x7;
4485 intel_read_dp_as_sdp(struct intel_encoder *encoder,
4486 struct intel_crtc_state *crtc_state,
4487 struct drm_dp_as_sdp *as_sdp)
4489 struct intel_digital_port *dig_port = enc_to_dig_port(encoder);
4490 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
4491 unsigned int type = DP_SDP_ADAPTIVE_SYNC;
4492 struct dp_sdp sdp = {};
4495 if ((crtc_state->infoframes.enable &
4496 intel_hdmi_infoframe_enable(type)) == 0)
4499 dig_port->read_infoframe(encoder, crtc_state, type, &sdp,
4502 ret = intel_dp_as_sdp_unpack(as_sdp, &sdp, sizeof(sdp));
4504 drm_dbg_kms(&dev_priv->drm, "Failed to unpack DP AS SDP\n");
4508 intel_dp_hdr_metadata_infoframe_sdp_unpack(struct hdmi_drm_infoframe *drm_infoframe,
4509 const void *buffer, size_t size)
4513 const struct dp_sdp *sdp = buffer;
4515 if (size < sizeof(struct dp_sdp))
4518 if (sdp->sdp_header.HB0 != 0)
4521 if (sdp->sdp_header.HB1 != HDMI_INFOFRAME_TYPE_DRM)
4525 * Least Significant Eight Bits of (Data Byte Count – 1)
4526 * 1Dh (i.e., Data Byte Count = 30 bytes).
4528 if (sdp->sdp_header.HB2 != 0x1D)
4531 /* Most Significant Two Bits of (Data Byte Count – 1), Clear to 00b. */
4532 if ((sdp->sdp_header.HB3 & 0x3) != 0)
4535 /* INFOFRAME SDP Version Number */
4536 if (((sdp->sdp_header.HB3 >> 2) & 0x3f) != 0x13)
4539 /* CTA Header Byte 2 (INFOFRAME Version Number) */
4540 if (sdp->db[0] != 1)
4543 /* CTA Header Byte 3 (Length of INFOFRAME): HDMI_DRM_INFOFRAME_SIZE */
4544 if (sdp->db[1] != HDMI_DRM_INFOFRAME_SIZE)
4547 ret = hdmi_drm_infoframe_unpack_only(drm_infoframe, &sdp->db[2],
4548 HDMI_DRM_INFOFRAME_SIZE);
4553 static void intel_read_dp_vsc_sdp(struct intel_encoder *encoder,
4554 struct intel_crtc_state *crtc_state,
4555 struct drm_dp_vsc_sdp *vsc)
4557 struct intel_digital_port *dig_port = enc_to_dig_port(encoder);
4558 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
4559 unsigned int type = DP_SDP_VSC;
4560 struct dp_sdp sdp = {};
4563 if ((crtc_state->infoframes.enable &
4564 intel_hdmi_infoframe_enable(type)) == 0)
4567 dig_port->read_infoframe(encoder, crtc_state, type, &sdp, sizeof(sdp));
4569 ret = intel_dp_vsc_sdp_unpack(vsc, &sdp, sizeof(sdp));
4572 drm_dbg_kms(&dev_priv->drm, "Failed to unpack DP VSC SDP\n");
4575 static void intel_read_dp_hdr_metadata_infoframe_sdp(struct intel_encoder *encoder,
4576 struct intel_crtc_state *crtc_state,
4577 struct hdmi_drm_infoframe *drm_infoframe)
4579 struct intel_digital_port *dig_port = enc_to_dig_port(encoder);
4580 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
4581 unsigned int type = HDMI_PACKET_TYPE_GAMUT_METADATA;
4582 struct dp_sdp sdp = {};
4585 if ((crtc_state->infoframes.enable &
4586 intel_hdmi_infoframe_enable(type)) == 0)
4589 dig_port->read_infoframe(encoder, crtc_state, type, &sdp,
4592 ret = intel_dp_hdr_metadata_infoframe_sdp_unpack(drm_infoframe, &sdp,
4596 drm_dbg_kms(&dev_priv->drm,
4597 "Failed to unpack DP HDR Metadata Infoframe SDP\n");
4600 void intel_read_dp_sdp(struct intel_encoder *encoder,
4601 struct intel_crtc_state *crtc_state,
4606 intel_read_dp_vsc_sdp(encoder, crtc_state,
4607 &crtc_state->infoframes.vsc);
4609 case HDMI_PACKET_TYPE_GAMUT_METADATA:
4610 intel_read_dp_hdr_metadata_infoframe_sdp(encoder, crtc_state,
4611 &crtc_state->infoframes.drm.drm);
4613 case DP_SDP_ADAPTIVE_SYNC:
4614 intel_read_dp_as_sdp(encoder, crtc_state,
4615 &crtc_state->infoframes.as_sdp);
4623 static u8 intel_dp_autotest_link_training(struct intel_dp *intel_dp)
4625 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
4628 u8 test_lane_count, test_link_bw;
4632 /* Read the TEST_LANE_COUNT and TEST_LINK_RTAE fields (DP CTS 3.1.4) */
4633 status = drm_dp_dpcd_readb(&intel_dp->aux, DP_TEST_LANE_COUNT,
4637 drm_dbg_kms(&i915->drm, "Lane count read failed\n");
4640 test_lane_count &= DP_MAX_LANE_COUNT_MASK;
4642 status = drm_dp_dpcd_readb(&intel_dp->aux, DP_TEST_LINK_RATE,
4645 drm_dbg_kms(&i915->drm, "Link Rate read failed\n");
4648 test_link_rate = drm_dp_bw_code_to_link_rate(test_link_bw);
4650 /* Validate the requested link rate and lane count */
4651 if (!intel_dp_link_params_valid(intel_dp, test_link_rate,
4655 intel_dp->compliance.test_lane_count = test_lane_count;
4656 intel_dp->compliance.test_link_rate = test_link_rate;
4661 static u8 intel_dp_autotest_video_pattern(struct intel_dp *intel_dp)
4663 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
4666 __be16 h_width, v_height;
4669 /* Read the TEST_PATTERN (DP CTS 3.1.5) */
4670 status = drm_dp_dpcd_readb(&intel_dp->aux, DP_TEST_PATTERN,
4673 drm_dbg_kms(&i915->drm, "Test pattern read failed\n");
4676 if (test_pattern != DP_COLOR_RAMP)
4679 status = drm_dp_dpcd_read(&intel_dp->aux, DP_TEST_H_WIDTH_HI,
4682 drm_dbg_kms(&i915->drm, "H Width read failed\n");
4686 status = drm_dp_dpcd_read(&intel_dp->aux, DP_TEST_V_HEIGHT_HI,
4689 drm_dbg_kms(&i915->drm, "V Height read failed\n");
4693 status = drm_dp_dpcd_readb(&intel_dp->aux, DP_TEST_MISC0,
4696 drm_dbg_kms(&i915->drm, "TEST MISC read failed\n");
4699 if ((test_misc & DP_TEST_COLOR_FORMAT_MASK) != DP_COLOR_FORMAT_RGB)
4701 if (test_misc & DP_TEST_DYNAMIC_RANGE_CEA)
4703 switch (test_misc & DP_TEST_BIT_DEPTH_MASK) {
4704 case DP_TEST_BIT_DEPTH_6:
4705 intel_dp->compliance.test_data.bpc = 6;
4707 case DP_TEST_BIT_DEPTH_8:
4708 intel_dp->compliance.test_data.bpc = 8;
4714 intel_dp->compliance.test_data.video_pattern = test_pattern;
4715 intel_dp->compliance.test_data.hdisplay = be16_to_cpu(h_width);
4716 intel_dp->compliance.test_data.vdisplay = be16_to_cpu(v_height);
4717 /* Set test active flag here so userspace doesn't interrupt things */
4718 intel_dp->compliance.test_active = true;
4723 static u8 intel_dp_autotest_edid(struct intel_dp *intel_dp)
4725 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
4726 u8 test_result = DP_TEST_ACK;
4727 struct intel_connector *intel_connector = intel_dp->attached_connector;
4728 struct drm_connector *connector = &intel_connector->base;
4730 if (intel_connector->detect_edid == NULL ||
4731 connector->edid_corrupt ||
4732 intel_dp->aux.i2c_defer_count > 6) {
4733 /* Check EDID read for NACKs, DEFERs and corruption
4734 * (DP CTS 1.2 Core r1.1)
4735 * 4.2.2.4 : Failed EDID read, I2C_NAK
4736 * 4.2.2.5 : Failed EDID read, I2C_DEFER
4737 * 4.2.2.6 : EDID corruption detected
4738 * Use failsafe mode for all cases
4740 if (intel_dp->aux.i2c_nack_count > 0 ||
4741 intel_dp->aux.i2c_defer_count > 0)
4742 drm_dbg_kms(&i915->drm,
4743 "EDID read had %d NACKs, %d DEFERs\n",
4744 intel_dp->aux.i2c_nack_count,
4745 intel_dp->aux.i2c_defer_count);
4746 intel_dp->compliance.test_data.edid = INTEL_DP_RESOLUTION_FAILSAFE;
4748 /* FIXME: Get rid of drm_edid_raw() */
4749 const struct edid *block = drm_edid_raw(intel_connector->detect_edid);
4751 /* We have to write the checksum of the last block read */
4752 block += block->extensions;
4754 if (drm_dp_dpcd_writeb(&intel_dp->aux, DP_TEST_EDID_CHECKSUM,
4755 block->checksum) <= 0)
4756 drm_dbg_kms(&i915->drm,
4757 "Failed to write EDID checksum\n");
4759 test_result = DP_TEST_ACK | DP_TEST_EDID_CHECKSUM_WRITE;
4760 intel_dp->compliance.test_data.edid = INTEL_DP_RESOLUTION_PREFERRED;
4763 /* Set test active flag here so userspace doesn't interrupt things */
4764 intel_dp->compliance.test_active = true;
4769 static void intel_dp_phy_pattern_update(struct intel_dp *intel_dp,
4770 const struct intel_crtc_state *crtc_state)
4772 struct drm_i915_private *dev_priv =
4773 to_i915(dp_to_dig_port(intel_dp)->base.base.dev);
4774 struct drm_dp_phy_test_params *data =
4775 &intel_dp->compliance.test_data.phytest;
4776 struct intel_crtc *crtc = to_intel_crtc(crtc_state->uapi.crtc);
4777 struct intel_encoder *encoder = &dp_to_dig_port(intel_dp)->base;
4778 enum pipe pipe = crtc->pipe;
4781 switch (data->phy_pattern) {
4782 case DP_LINK_QUAL_PATTERN_DISABLE:
4783 drm_dbg_kms(&dev_priv->drm, "Disable Phy Test Pattern\n");
4784 intel_de_write(dev_priv, DDI_DP_COMP_CTL(pipe), 0x0);
4785 if (DISPLAY_VER(dev_priv) >= 10)
4786 intel_de_rmw(dev_priv, dp_tp_ctl_reg(encoder, crtc_state),
4787 DP_TP_CTL_TRAIN_PAT4_SEL_MASK | DP_TP_CTL_LINK_TRAIN_MASK,
4788 DP_TP_CTL_LINK_TRAIN_NORMAL);
4790 case DP_LINK_QUAL_PATTERN_D10_2:
4791 drm_dbg_kms(&dev_priv->drm, "Set D10.2 Phy Test Pattern\n");
4792 intel_de_write(dev_priv, DDI_DP_COMP_CTL(pipe),
4793 DDI_DP_COMP_CTL_ENABLE | DDI_DP_COMP_CTL_D10_2);
4795 case DP_LINK_QUAL_PATTERN_ERROR_RATE:
4796 drm_dbg_kms(&dev_priv->drm, "Set Error Count Phy Test Pattern\n");
4797 intel_de_write(dev_priv, DDI_DP_COMP_CTL(pipe),
4798 DDI_DP_COMP_CTL_ENABLE |
4799 DDI_DP_COMP_CTL_SCRAMBLED_0);
4801 case DP_LINK_QUAL_PATTERN_PRBS7:
4802 drm_dbg_kms(&dev_priv->drm, "Set PRBS7 Phy Test Pattern\n");
4803 intel_de_write(dev_priv, DDI_DP_COMP_CTL(pipe),
4804 DDI_DP_COMP_CTL_ENABLE | DDI_DP_COMP_CTL_PRBS7);
4806 case DP_LINK_QUAL_PATTERN_80BIT_CUSTOM:
4808 * FIXME: Ideally pattern should come from DPCD 0x250. As
4809 * current firmware of DPR-100 could not set it, so hardcoding
4810 * now for complaince test.
4812 drm_dbg_kms(&dev_priv->drm,
4813 "Set 80Bit Custom Phy Test Pattern 0x3e0f83e0 0x0f83e0f8 0x0000f83e\n");
4814 pattern_val = 0x3e0f83e0;
4815 intel_de_write(dev_priv, DDI_DP_COMP_PAT(pipe, 0), pattern_val);
4816 pattern_val = 0x0f83e0f8;
4817 intel_de_write(dev_priv, DDI_DP_COMP_PAT(pipe, 1), pattern_val);
4818 pattern_val = 0x0000f83e;
4819 intel_de_write(dev_priv, DDI_DP_COMP_PAT(pipe, 2), pattern_val);
4820 intel_de_write(dev_priv, DDI_DP_COMP_CTL(pipe),
4821 DDI_DP_COMP_CTL_ENABLE |
4822 DDI_DP_COMP_CTL_CUSTOM80);
4824 case DP_LINK_QUAL_PATTERN_CP2520_PAT_1:
4826 * FIXME: Ideally pattern should come from DPCD 0x24A. As
4827 * current firmware of DPR-100 could not set it, so hardcoding
4828 * now for complaince test.
4830 drm_dbg_kms(&dev_priv->drm, "Set HBR2 compliance Phy Test Pattern\n");
4832 intel_de_write(dev_priv, DDI_DP_COMP_CTL(pipe),
4833 DDI_DP_COMP_CTL_ENABLE | DDI_DP_COMP_CTL_HBR2 |
4836 case DP_LINK_QUAL_PATTERN_CP2520_PAT_3:
4837 if (DISPLAY_VER(dev_priv) < 10) {
4838 drm_warn(&dev_priv->drm, "Platform does not support TPS4\n");
4841 drm_dbg_kms(&dev_priv->drm, "Set TPS4 compliance Phy Test Pattern\n");
4842 intel_de_write(dev_priv, DDI_DP_COMP_CTL(pipe), 0x0);
4843 intel_de_rmw(dev_priv, dp_tp_ctl_reg(encoder, crtc_state),
4844 DP_TP_CTL_TRAIN_PAT4_SEL_MASK | DP_TP_CTL_LINK_TRAIN_MASK,
4845 DP_TP_CTL_TRAIN_PAT4_SEL_TP4A | DP_TP_CTL_LINK_TRAIN_PAT4);
4848 drm_warn(&dev_priv->drm, "Invalid Phy Test Pattern\n");
4852 static void intel_dp_process_phy_request(struct intel_dp *intel_dp,
4853 const struct intel_crtc_state *crtc_state)
4855 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
4856 struct drm_dp_phy_test_params *data =
4857 &intel_dp->compliance.test_data.phytest;
4858 u8 link_status[DP_LINK_STATUS_SIZE];
4860 if (drm_dp_dpcd_read_phy_link_status(&intel_dp->aux, DP_PHY_DPRX,
4862 drm_dbg_kms(&i915->drm, "failed to get link status\n");
4866 /* retrieve vswing & pre-emphasis setting */
4867 intel_dp_get_adjust_train(intel_dp, crtc_state, DP_PHY_DPRX,
4870 intel_dp_set_signal_levels(intel_dp, crtc_state, DP_PHY_DPRX);
4872 intel_dp_phy_pattern_update(intel_dp, crtc_state);
4874 drm_dp_dpcd_write(&intel_dp->aux, DP_TRAINING_LANE0_SET,
4875 intel_dp->train_set, crtc_state->lane_count);
4877 drm_dp_set_phy_test_pattern(&intel_dp->aux, data,
4878 intel_dp->dpcd[DP_DPCD_REV]);
4881 static u8 intel_dp_autotest_phy_pattern(struct intel_dp *intel_dp)
4883 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
4884 struct drm_dp_phy_test_params *data =
4885 &intel_dp->compliance.test_data.phytest;
4887 if (drm_dp_get_phy_test_pattern(&intel_dp->aux, data)) {
4888 drm_dbg_kms(&i915->drm, "DP Phy Test pattern AUX read failure\n");
4892 /* Set test active flag here so userspace doesn't interrupt things */
4893 intel_dp->compliance.test_active = true;
4898 static void intel_dp_handle_test_request(struct intel_dp *intel_dp)
4900 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
4901 u8 response = DP_TEST_NAK;
4905 status = drm_dp_dpcd_readb(&intel_dp->aux, DP_TEST_REQUEST, &request);
4907 drm_dbg_kms(&i915->drm,
4908 "Could not read test request from sink\n");
4913 case DP_TEST_LINK_TRAINING:
4914 drm_dbg_kms(&i915->drm, "LINK_TRAINING test requested\n");
4915 response = intel_dp_autotest_link_training(intel_dp);
4917 case DP_TEST_LINK_VIDEO_PATTERN:
4918 drm_dbg_kms(&i915->drm, "TEST_PATTERN test requested\n");
4919 response = intel_dp_autotest_video_pattern(intel_dp);
4921 case DP_TEST_LINK_EDID_READ:
4922 drm_dbg_kms(&i915->drm, "EDID test requested\n");
4923 response = intel_dp_autotest_edid(intel_dp);
4925 case DP_TEST_LINK_PHY_TEST_PATTERN:
4926 drm_dbg_kms(&i915->drm, "PHY_PATTERN test requested\n");
4927 response = intel_dp_autotest_phy_pattern(intel_dp);
4930 drm_dbg_kms(&i915->drm, "Invalid test request '%02x'\n",
4935 if (response & DP_TEST_ACK)
4936 intel_dp->compliance.test_type = request;
4939 status = drm_dp_dpcd_writeb(&intel_dp->aux, DP_TEST_RESPONSE, response);
4941 drm_dbg_kms(&i915->drm,
4942 "Could not write test response to sink\n");
4945 static bool intel_dp_link_ok(struct intel_dp *intel_dp,
4946 u8 link_status[DP_LINK_STATUS_SIZE])
4948 struct intel_encoder *encoder = &dp_to_dig_port(intel_dp)->base;
4949 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
4950 bool uhbr = intel_dp->link_rate >= 1000000;
4954 ok = drm_dp_128b132b_lane_channel_eq_done(link_status,
4955 intel_dp->lane_count);
4957 ok = drm_dp_channel_eq_ok(link_status, intel_dp->lane_count);
4962 intel_dp_dump_link_status(intel_dp, DP_PHY_DPRX, link_status);
4963 drm_dbg_kms(&i915->drm,
4964 "[ENCODER:%d:%s] %s link not ok, retraining\n",
4965 encoder->base.base.id, encoder->base.name,
4966 uhbr ? "128b/132b" : "8b/10b");
4972 intel_dp_mst_hpd_irq(struct intel_dp *intel_dp, u8 *esi, u8 *ack)
4974 bool handled = false;
4976 drm_dp_mst_hpd_irq_handle_event(&intel_dp->mst_mgr, esi, ack, &handled);
4978 if (esi[1] & DP_CP_IRQ) {
4979 intel_hdcp_handle_cp_irq(intel_dp->attached_connector);
4980 ack[1] |= DP_CP_IRQ;
4984 static bool intel_dp_mst_link_status(struct intel_dp *intel_dp)
4986 struct intel_encoder *encoder = &dp_to_dig_port(intel_dp)->base;
4987 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
4988 u8 link_status[DP_LINK_STATUS_SIZE] = {};
4989 const size_t esi_link_status_size = DP_LINK_STATUS_SIZE - 2;
4991 if (drm_dp_dpcd_read(&intel_dp->aux, DP_LANE0_1_STATUS_ESI, link_status,
4992 esi_link_status_size) != esi_link_status_size) {
4994 "[ENCODER:%d:%s] Failed to read link status\n",
4995 encoder->base.base.id, encoder->base.name);
4999 return intel_dp_link_ok(intel_dp, link_status);
5003 * intel_dp_check_mst_status - service any pending MST interrupts, check link status
5004 * @intel_dp: Intel DP struct
5006 * Read any pending MST interrupts, call MST core to handle these and ack the
5007 * interrupts. Check if the main and AUX link state is ok.
5010 * - %true if pending interrupts were serviced (or no interrupts were
5011 * pending) w/o detecting an error condition.
5012 * - %false if an error condition - like AUX failure or a loss of link - is
5013 * detected, or another condition - like a DP tunnel BW state change - needs
5014 * servicing from the hotplug work.
5017 intel_dp_check_mst_status(struct intel_dp *intel_dp)
5019 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
5020 bool link_ok = true;
5021 bool reprobe_needed = false;
5023 drm_WARN_ON_ONCE(&i915->drm, intel_dp->active_mst_links < 0);
5029 if (!intel_dp_get_sink_irq_esi(intel_dp, esi)) {
5030 drm_dbg_kms(&i915->drm,
5031 "failed to get ESI - device may have failed\n");
5037 drm_dbg_kms(&i915->drm, "DPRX ESI: %4ph\n", esi);
5039 if (intel_dp->active_mst_links > 0 && link_ok &&
5040 esi[3] & LINK_STATUS_CHANGED) {
5041 if (!intel_dp_mst_link_status(intel_dp))
5043 ack[3] |= LINK_STATUS_CHANGED;
5046 intel_dp_mst_hpd_irq(intel_dp, esi, ack);
5048 if (esi[3] & DP_TUNNELING_IRQ) {
5049 if (drm_dp_tunnel_handle_irq(i915->display.dp_tunnel_mgr,
5051 reprobe_needed = true;
5052 ack[3] |= DP_TUNNELING_IRQ;
5055 if (!memchr_inv(ack, 0, sizeof(ack)))
5058 if (!intel_dp_ack_sink_irq_esi(intel_dp, ack))
5059 drm_dbg_kms(&i915->drm, "Failed to ack ESI\n");
5061 if (ack[1] & (DP_DOWN_REP_MSG_RDY | DP_UP_REQ_MSG_RDY))
5062 drm_dp_mst_hpd_irq_send_new_request(&intel_dp->mst_mgr);
5065 return link_ok && !reprobe_needed;
5069 intel_dp_handle_hdmi_link_status_change(struct intel_dp *intel_dp)
5074 is_active = drm_dp_pcon_hdmi_link_active(&intel_dp->aux);
5075 if (intel_dp->frl.is_trained && !is_active) {
5076 if (drm_dp_dpcd_readb(&intel_dp->aux, DP_PCON_HDMI_LINK_CONFIG_1, &buf) < 0)
5079 buf &= ~DP_PCON_ENABLE_HDMI_LINK;
5080 if (drm_dp_dpcd_writeb(&intel_dp->aux, DP_PCON_HDMI_LINK_CONFIG_1, buf) < 0)
5083 drm_dp_pcon_hdmi_frl_link_error_count(&intel_dp->aux, &intel_dp->attached_connector->base);
5085 intel_dp->frl.is_trained = false;
5087 /* Restart FRL training or fall back to TMDS mode */
5088 intel_dp_check_frl_training(intel_dp);
5093 intel_dp_needs_link_retrain(struct intel_dp *intel_dp)
5095 u8 link_status[DP_LINK_STATUS_SIZE];
5097 if (!intel_dp->link_trained)
5101 * While PSR source HW is enabled, it will control main-link sending
5102 * frames, enabling and disabling it so trying to do a retrain will fail
5103 * as the link would or not be on or it could mix training patterns
5104 * and frame data at the same time causing retrain to fail.
5105 * Also when exiting PSR, HW will retrain the link anyways fixing
5106 * any link status error.
5108 if (intel_psr_enabled(intel_dp))
5111 if (drm_dp_dpcd_read_phy_link_status(&intel_dp->aux, DP_PHY_DPRX,
5116 * Validate the cached values of intel_dp->link_rate and
5117 * intel_dp->lane_count before attempting to retrain.
5119 * FIXME would be nice to user the crtc state here, but since
5120 * we need to call this from the short HPD handler that seems
5123 if (!intel_dp_link_params_valid(intel_dp, intel_dp->link_rate,
5124 intel_dp->lane_count))
5127 /* Retrain if link not ok */
5128 return !intel_dp_link_ok(intel_dp, link_status);
5131 static bool intel_dp_has_connector(struct intel_dp *intel_dp,
5132 const struct drm_connector_state *conn_state)
5134 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
5135 struct intel_encoder *encoder;
5138 if (!conn_state->best_encoder)
5142 encoder = &dp_to_dig_port(intel_dp)->base;
5143 if (conn_state->best_encoder == &encoder->base)
5147 for_each_pipe(i915, pipe) {
5148 encoder = &intel_dp->mst_encoders[pipe]->base;
5149 if (conn_state->best_encoder == &encoder->base)
5156 int intel_dp_get_active_pipes(struct intel_dp *intel_dp,
5157 struct drm_modeset_acquire_ctx *ctx,
5160 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
5161 struct drm_connector_list_iter conn_iter;
5162 struct intel_connector *connector;
5167 drm_connector_list_iter_begin(&i915->drm, &conn_iter);
5168 for_each_intel_connector_iter(connector, &conn_iter) {
5169 struct drm_connector_state *conn_state =
5170 connector->base.state;
5171 struct intel_crtc_state *crtc_state;
5172 struct intel_crtc *crtc;
5174 if (!intel_dp_has_connector(intel_dp, conn_state))
5177 crtc = to_intel_crtc(conn_state->crtc);
5181 ret = drm_modeset_lock(&crtc->base.mutex, ctx);
5185 crtc_state = to_intel_crtc_state(crtc->base.state);
5187 drm_WARN_ON(&i915->drm, !intel_crtc_has_dp_encoder(crtc_state));
5189 if (!crtc_state->hw.active)
5192 if (conn_state->commit)
5193 drm_WARN_ON(&i915->drm,
5194 !wait_for_completion_timeout(&conn_state->commit->hw_done,
5195 msecs_to_jiffies(5000)));
5197 *pipe_mask |= BIT(crtc->pipe);
5199 drm_connector_list_iter_end(&conn_iter);
5204 static bool intel_dp_is_connected(struct intel_dp *intel_dp)
5206 struct intel_connector *connector = intel_dp->attached_connector;
5208 return connector->base.status == connector_status_connected ||
5212 int intel_dp_retrain_link(struct intel_encoder *encoder,
5213 struct drm_modeset_acquire_ctx *ctx)
5215 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
5216 struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
5217 struct intel_crtc *crtc;
5221 if (!intel_dp_is_connected(intel_dp))
5224 ret = drm_modeset_lock(&dev_priv->drm.mode_config.connection_mutex,
5229 if (!intel_dp_needs_link_retrain(intel_dp))
5232 ret = intel_dp_get_active_pipes(intel_dp, ctx, &pipe_mask);
5239 if (!intel_dp_needs_link_retrain(intel_dp))
5242 drm_dbg_kms(&dev_priv->drm, "[ENCODER:%d:%s] retraining link\n",
5243 encoder->base.base.id, encoder->base.name);
5245 for_each_intel_crtc_in_pipe_mask(&dev_priv->drm, crtc, pipe_mask) {
5246 const struct intel_crtc_state *crtc_state =
5247 to_intel_crtc_state(crtc->base.state);
5249 /* Suppress underruns caused by re-training */
5250 intel_set_cpu_fifo_underrun_reporting(dev_priv, crtc->pipe, false);
5251 if (crtc_state->has_pch_encoder)
5252 intel_set_pch_fifo_underrun_reporting(dev_priv,
5253 intel_crtc_pch_transcoder(crtc), false);
5256 for_each_intel_crtc_in_pipe_mask(&dev_priv->drm, crtc, pipe_mask) {
5257 const struct intel_crtc_state *crtc_state =
5258 to_intel_crtc_state(crtc->base.state);
5260 /* retrain on the MST master transcoder */
5261 if (DISPLAY_VER(dev_priv) >= 12 &&
5262 intel_crtc_has_type(crtc_state, INTEL_OUTPUT_DP_MST) &&
5263 !intel_dp_mst_is_master_trans(crtc_state))
5266 intel_dp_check_frl_training(intel_dp);
5267 intel_dp_pcon_dsc_configure(intel_dp, crtc_state);
5268 intel_dp_start_link_train(intel_dp, crtc_state);
5269 intel_dp_stop_link_train(intel_dp, crtc_state);
5273 for_each_intel_crtc_in_pipe_mask(&dev_priv->drm, crtc, pipe_mask) {
5274 const struct intel_crtc_state *crtc_state =
5275 to_intel_crtc_state(crtc->base.state);
5277 /* Keep underrun reporting disabled until things are stable */
5278 intel_crtc_wait_for_next_vblank(crtc);
5280 intel_set_cpu_fifo_underrun_reporting(dev_priv, crtc->pipe, true);
5281 if (crtc_state->has_pch_encoder)
5282 intel_set_pch_fifo_underrun_reporting(dev_priv,
5283 intel_crtc_pch_transcoder(crtc), true);
5289 static int intel_dp_prep_phy_test(struct intel_dp *intel_dp,
5290 struct drm_modeset_acquire_ctx *ctx,
5293 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
5294 struct drm_connector_list_iter conn_iter;
5295 struct intel_connector *connector;
5300 drm_connector_list_iter_begin(&i915->drm, &conn_iter);
5301 for_each_intel_connector_iter(connector, &conn_iter) {
5302 struct drm_connector_state *conn_state =
5303 connector->base.state;
5304 struct intel_crtc_state *crtc_state;
5305 struct intel_crtc *crtc;
5307 if (!intel_dp_has_connector(intel_dp, conn_state))
5310 crtc = to_intel_crtc(conn_state->crtc);
5314 ret = drm_modeset_lock(&crtc->base.mutex, ctx);
5318 crtc_state = to_intel_crtc_state(crtc->base.state);
5320 drm_WARN_ON(&i915->drm, !intel_crtc_has_dp_encoder(crtc_state));
5322 if (!crtc_state->hw.active)
5325 if (conn_state->commit &&
5326 !try_wait_for_completion(&conn_state->commit->hw_done))
5329 *pipe_mask |= BIT(crtc->pipe);
5331 drm_connector_list_iter_end(&conn_iter);
5336 static int intel_dp_do_phy_test(struct intel_encoder *encoder,
5337 struct drm_modeset_acquire_ctx *ctx)
5339 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
5340 struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
5341 struct intel_crtc *crtc;
5345 ret = drm_modeset_lock(&dev_priv->drm.mode_config.connection_mutex,
5350 ret = intel_dp_prep_phy_test(intel_dp, ctx, &pipe_mask);
5357 drm_dbg_kms(&dev_priv->drm, "[ENCODER:%d:%s] PHY test\n",
5358 encoder->base.base.id, encoder->base.name);
5360 for_each_intel_crtc_in_pipe_mask(&dev_priv->drm, crtc, pipe_mask) {
5361 const struct intel_crtc_state *crtc_state =
5362 to_intel_crtc_state(crtc->base.state);
5364 /* test on the MST master transcoder */
5365 if (DISPLAY_VER(dev_priv) >= 12 &&
5366 intel_crtc_has_type(crtc_state, INTEL_OUTPUT_DP_MST) &&
5367 !intel_dp_mst_is_master_trans(crtc_state))
5370 intel_dp_process_phy_request(intel_dp, crtc_state);
5377 void intel_dp_phy_test(struct intel_encoder *encoder)
5379 struct drm_modeset_acquire_ctx ctx;
5382 drm_modeset_acquire_init(&ctx, 0);
5385 ret = intel_dp_do_phy_test(encoder, &ctx);
5387 if (ret == -EDEADLK) {
5388 drm_modeset_backoff(&ctx);
5395 drm_modeset_drop_locks(&ctx);
5396 drm_modeset_acquire_fini(&ctx);
5397 drm_WARN(encoder->base.dev, ret,
5398 "Acquiring modeset locks failed with %i\n", ret);
5401 static void intel_dp_check_device_service_irq(struct intel_dp *intel_dp)
5403 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
5406 if (intel_dp->dpcd[DP_DPCD_REV] < 0x11)
5409 if (drm_dp_dpcd_readb(&intel_dp->aux,
5410 DP_DEVICE_SERVICE_IRQ_VECTOR, &val) != 1 || !val)
5413 drm_dp_dpcd_writeb(&intel_dp->aux, DP_DEVICE_SERVICE_IRQ_VECTOR, val);
5415 if (val & DP_AUTOMATED_TEST_REQUEST)
5416 intel_dp_handle_test_request(intel_dp);
5418 if (val & DP_CP_IRQ)
5419 intel_hdcp_handle_cp_irq(intel_dp->attached_connector);
5421 if (val & DP_SINK_SPECIFIC_IRQ)
5422 drm_dbg_kms(&i915->drm, "Sink specific irq unhandled\n");
5425 static bool intel_dp_check_link_service_irq(struct intel_dp *intel_dp)
5427 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
5428 bool reprobe_needed = false;
5431 if (intel_dp->dpcd[DP_DPCD_REV] < 0x11)
5434 if (drm_dp_dpcd_readb(&intel_dp->aux,
5435 DP_LINK_SERVICE_IRQ_VECTOR_ESI0, &val) != 1 || !val)
5438 if ((val & DP_TUNNELING_IRQ) &&
5439 drm_dp_tunnel_handle_irq(i915->display.dp_tunnel_mgr,
5441 reprobe_needed = true;
5443 if (drm_dp_dpcd_writeb(&intel_dp->aux,
5444 DP_LINK_SERVICE_IRQ_VECTOR_ESI0, val) != 1)
5445 return reprobe_needed;
5447 if (val & HDMI_LINK_STATUS_CHANGED)
5448 intel_dp_handle_hdmi_link_status_change(intel_dp);
5450 return reprobe_needed;
5454 * According to DP spec
5457 * 2. Configure link according to Receiver Capabilities
5458 * 3. Use Link Training from 2.5.3.3 and 3.5.1.3
5459 * 4. Check link status on receipt of hot-plug interrupt
5461 * intel_dp_short_pulse - handles short pulse interrupts
5462 * when full detection is not required.
5463 * Returns %true if short pulse is handled and full detection
5464 * is NOT required and %false otherwise.
5467 intel_dp_short_pulse(struct intel_dp *intel_dp)
5469 struct drm_i915_private *dev_priv = dp_to_i915(intel_dp);
5470 u8 old_sink_count = intel_dp->sink_count;
5471 bool reprobe_needed = false;
5475 * Clearing compliance test variables to allow capturing
5476 * of values for next automated test request.
5478 memset(&intel_dp->compliance, 0, sizeof(intel_dp->compliance));
5481 * Now read the DPCD to see if it's actually running
5482 * If the current value of sink count doesn't match with
5483 * the value that was stored earlier or dpcd read failed
5484 * we need to do full detection
5486 ret = intel_dp_get_dpcd(intel_dp);
5488 if ((old_sink_count != intel_dp->sink_count) || !ret) {
5489 /* No need to proceed if we are going to do full detect */
5493 intel_dp_check_device_service_irq(intel_dp);
5494 reprobe_needed = intel_dp_check_link_service_irq(intel_dp);
5496 /* Handle CEC interrupts, if any */
5497 drm_dp_cec_irq(&intel_dp->aux);
5499 /* defer to the hotplug work for link retraining if needed */
5500 if (intel_dp_needs_link_retrain(intel_dp))
5503 intel_psr_short_pulse(intel_dp);
5505 switch (intel_dp->compliance.test_type) {
5506 case DP_TEST_LINK_TRAINING:
5507 drm_dbg_kms(&dev_priv->drm,
5508 "Link Training Compliance Test requested\n");
5509 /* Send a Hotplug Uevent to userspace to start modeset */
5510 drm_kms_helper_hotplug_event(&dev_priv->drm);
5512 case DP_TEST_LINK_PHY_TEST_PATTERN:
5513 drm_dbg_kms(&dev_priv->drm,
5514 "PHY test pattern Compliance Test requested\n");
5516 * Schedule long hpd to do the test
5518 * FIXME get rid of the ad-hoc phy test modeset code
5519 * and properly incorporate it into the normal modeset.
5521 reprobe_needed = true;
5524 return !reprobe_needed;
5527 /* XXX this is probably wrong for multiple downstream ports */
5528 static enum drm_connector_status
5529 intel_dp_detect_dpcd(struct intel_dp *intel_dp)
5531 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
5532 struct intel_digital_port *dig_port = dp_to_dig_port(intel_dp);
5533 u8 *dpcd = intel_dp->dpcd;
5536 if (drm_WARN_ON(&i915->drm, intel_dp_is_edp(intel_dp)))
5537 return connector_status_connected;
5539 lspcon_resume(dig_port);
5541 if (!intel_dp_get_dpcd(intel_dp))
5542 return connector_status_disconnected;
5544 intel_dp->mst_detect = intel_dp_mst_detect(intel_dp);
5546 /* if there's no downstream port, we're done */
5547 if (!drm_dp_is_branch(dpcd))
5548 return connector_status_connected;
5550 /* If we're HPD-aware, SINK_COUNT changes dynamically */
5551 if (intel_dp_has_sink_count(intel_dp) &&
5552 intel_dp->downstream_ports[0] & DP_DS_PORT_HPD) {
5553 return intel_dp->sink_count ?
5554 connector_status_connected : connector_status_disconnected;
5557 if (intel_dp->mst_detect == DRM_DP_MST)
5558 return connector_status_connected;
5560 /* If no HPD, poke DDC gently */
5561 if (drm_probe_ddc(&intel_dp->aux.ddc))
5562 return connector_status_connected;
5564 /* Well we tried, say unknown for unreliable port types */
5565 if (intel_dp->dpcd[DP_DPCD_REV] >= 0x11) {
5566 type = intel_dp->downstream_ports[0] & DP_DS_PORT_TYPE_MASK;
5567 if (type == DP_DS_PORT_TYPE_VGA ||
5568 type == DP_DS_PORT_TYPE_NON_EDID)
5569 return connector_status_unknown;
5571 type = intel_dp->dpcd[DP_DOWNSTREAMPORT_PRESENT] &
5572 DP_DWN_STRM_PORT_TYPE_MASK;
5573 if (type == DP_DWN_STRM_PORT_TYPE_ANALOG ||
5574 type == DP_DWN_STRM_PORT_TYPE_OTHER)
5575 return connector_status_unknown;
5578 /* Anything else is out of spec, warn and ignore */
5579 drm_dbg_kms(&i915->drm, "Broken DP branch device, ignoring\n");
5580 return connector_status_disconnected;
5583 static enum drm_connector_status
5584 edp_detect(struct intel_dp *intel_dp)
5586 return connector_status_connected;
5589 void intel_digital_port_lock(struct intel_encoder *encoder)
5591 struct intel_digital_port *dig_port = enc_to_dig_port(encoder);
5594 dig_port->lock(dig_port);
5597 void intel_digital_port_unlock(struct intel_encoder *encoder)
5599 struct intel_digital_port *dig_port = enc_to_dig_port(encoder);
5601 if (dig_port->unlock)
5602 dig_port->unlock(dig_port);
5606 * intel_digital_port_connected_locked - is the specified port connected?
5607 * @encoder: intel_encoder
5609 * In cases where there's a connector physically connected but it can't be used
5610 * by our hardware we also return false, since the rest of the driver should
5611 * pretty much treat the port as disconnected. This is relevant for type-C
5612 * (starting on ICL) where there's ownership involved.
5614 * The caller must hold the lock acquired by calling intel_digital_port_lock()
5615 * when calling this function.
5617 * Return %true if port is connected, %false otherwise.
5619 bool intel_digital_port_connected_locked(struct intel_encoder *encoder)
5621 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
5622 struct intel_digital_port *dig_port = enc_to_dig_port(encoder);
5623 bool is_glitch_free = intel_tc_port_handles_hpd_glitches(dig_port);
5624 bool is_connected = false;
5625 intel_wakeref_t wakeref;
5627 with_intel_display_power(dev_priv, POWER_DOMAIN_DISPLAY_CORE, wakeref) {
5628 unsigned long wait_expires = jiffies + msecs_to_jiffies_timeout(4);
5631 is_connected = dig_port->connected(encoder);
5632 if (is_connected || is_glitch_free)
5634 usleep_range(10, 30);
5635 } while (time_before(jiffies, wait_expires));
5638 return is_connected;
5641 bool intel_digital_port_connected(struct intel_encoder *encoder)
5645 intel_digital_port_lock(encoder);
5646 ret = intel_digital_port_connected_locked(encoder);
5647 intel_digital_port_unlock(encoder);
5652 static const struct drm_edid *
5653 intel_dp_get_edid(struct intel_dp *intel_dp)
5655 struct intel_connector *connector = intel_dp->attached_connector;
5656 const struct drm_edid *fixed_edid = connector->panel.fixed_edid;
5658 /* Use panel fixed edid if we have one */
5661 if (IS_ERR(fixed_edid))
5664 return drm_edid_dup(fixed_edid);
5667 return drm_edid_read_ddc(&connector->base, &intel_dp->aux.ddc);
5671 intel_dp_update_dfp(struct intel_dp *intel_dp,
5672 const struct drm_edid *drm_edid)
5674 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
5675 struct intel_connector *connector = intel_dp->attached_connector;
5677 intel_dp->dfp.max_bpc =
5678 drm_dp_downstream_max_bpc(intel_dp->dpcd,
5679 intel_dp->downstream_ports, drm_edid);
5681 intel_dp->dfp.max_dotclock =
5682 drm_dp_downstream_max_dotclock(intel_dp->dpcd,
5683 intel_dp->downstream_ports);
5685 intel_dp->dfp.min_tmds_clock =
5686 drm_dp_downstream_min_tmds_clock(intel_dp->dpcd,
5687 intel_dp->downstream_ports,
5689 intel_dp->dfp.max_tmds_clock =
5690 drm_dp_downstream_max_tmds_clock(intel_dp->dpcd,
5691 intel_dp->downstream_ports,
5694 intel_dp->dfp.pcon_max_frl_bw =
5695 drm_dp_get_pcon_max_frl_bw(intel_dp->dpcd,
5696 intel_dp->downstream_ports);
5698 drm_dbg_kms(&i915->drm,
5699 "[CONNECTOR:%d:%s] DFP max bpc %d, max dotclock %d, TMDS clock %d-%d, PCON Max FRL BW %dGbps\n",
5700 connector->base.base.id, connector->base.name,
5701 intel_dp->dfp.max_bpc,
5702 intel_dp->dfp.max_dotclock,
5703 intel_dp->dfp.min_tmds_clock,
5704 intel_dp->dfp.max_tmds_clock,
5705 intel_dp->dfp.pcon_max_frl_bw);
5707 intel_dp_get_pcon_dsc_cap(intel_dp);
5711 intel_dp_can_ycbcr420(struct intel_dp *intel_dp)
5713 if (source_can_output(intel_dp, INTEL_OUTPUT_FORMAT_YCBCR420) &&
5714 (!drm_dp_is_branch(intel_dp->dpcd) || intel_dp->dfp.ycbcr420_passthrough))
5717 if (source_can_output(intel_dp, INTEL_OUTPUT_FORMAT_RGB) &&
5718 dfp_can_convert_from_rgb(intel_dp, INTEL_OUTPUT_FORMAT_YCBCR420))
5721 if (source_can_output(intel_dp, INTEL_OUTPUT_FORMAT_YCBCR444) &&
5722 dfp_can_convert_from_ycbcr444(intel_dp, INTEL_OUTPUT_FORMAT_YCBCR420))
5729 intel_dp_update_420(struct intel_dp *intel_dp)
5731 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
5732 struct intel_connector *connector = intel_dp->attached_connector;
5734 intel_dp->dfp.ycbcr420_passthrough =
5735 drm_dp_downstream_420_passthrough(intel_dp->dpcd,
5736 intel_dp->downstream_ports);
5737 /* on-board LSPCON always assumed to support 4:4:4->4:2:0 conversion */
5738 intel_dp->dfp.ycbcr_444_to_420 =
5739 dp_to_dig_port(intel_dp)->lspcon.active ||
5740 drm_dp_downstream_444_to_420_conversion(intel_dp->dpcd,
5741 intel_dp->downstream_ports);
5742 intel_dp->dfp.rgb_to_ycbcr =
5743 drm_dp_downstream_rgb_to_ycbcr_conversion(intel_dp->dpcd,
5744 intel_dp->downstream_ports,
5745 DP_DS_HDMI_BT709_RGB_YCBCR_CONV);
5747 connector->base.ycbcr_420_allowed = intel_dp_can_ycbcr420(intel_dp);
5749 drm_dbg_kms(&i915->drm,
5750 "[CONNECTOR:%d:%s] RGB->YcbCr conversion? %s, YCbCr 4:2:0 allowed? %s, YCbCr 4:4:4->4:2:0 conversion? %s\n",
5751 connector->base.base.id, connector->base.name,
5752 str_yes_no(intel_dp->dfp.rgb_to_ycbcr),
5753 str_yes_no(connector->base.ycbcr_420_allowed),
5754 str_yes_no(intel_dp->dfp.ycbcr_444_to_420));
5758 intel_dp_set_edid(struct intel_dp *intel_dp)
5760 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
5761 struct intel_connector *connector = intel_dp->attached_connector;
5762 const struct drm_edid *drm_edid;
5765 intel_dp_unset_edid(intel_dp);
5766 drm_edid = intel_dp_get_edid(intel_dp);
5767 connector->detect_edid = drm_edid;
5769 /* Below we depend on display info having been updated */
5770 drm_edid_connector_update(&connector->base, drm_edid);
5772 vrr_capable = intel_vrr_is_capable(connector);
5773 drm_dbg_kms(&i915->drm, "[CONNECTOR:%d:%s] VRR capable: %s\n",
5774 connector->base.base.id, connector->base.name, str_yes_no(vrr_capable));
5775 drm_connector_set_vrr_capable_property(&connector->base, vrr_capable);
5777 intel_dp_update_dfp(intel_dp, drm_edid);
5778 intel_dp_update_420(intel_dp);
5780 drm_dp_cec_attach(&intel_dp->aux,
5781 connector->base.display_info.source_physical_address);
5785 intel_dp_unset_edid(struct intel_dp *intel_dp)
5787 struct intel_connector *connector = intel_dp->attached_connector;
5789 drm_dp_cec_unset_edid(&intel_dp->aux);
5790 drm_edid_free(connector->detect_edid);
5791 connector->detect_edid = NULL;
5793 intel_dp->dfp.max_bpc = 0;
5794 intel_dp->dfp.max_dotclock = 0;
5795 intel_dp->dfp.min_tmds_clock = 0;
5796 intel_dp->dfp.max_tmds_clock = 0;
5798 intel_dp->dfp.pcon_max_frl_bw = 0;
5800 intel_dp->dfp.ycbcr_444_to_420 = false;
5801 connector->base.ycbcr_420_allowed = false;
5803 drm_connector_set_vrr_capable_property(&connector->base,
5808 intel_dp_detect_dsc_caps(struct intel_dp *intel_dp, struct intel_connector *connector)
5810 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
5812 /* Read DP Sink DSC Cap DPCD regs for DP v1.4 */
5816 if (intel_dp_is_edp(intel_dp))
5817 intel_edp_get_dsc_sink_cap(intel_dp->edp_dpcd[0],
5820 intel_dp_get_dsc_sink_cap(intel_dp->dpcd[DP_DPCD_REV],
5825 intel_dp_detect(struct drm_connector *connector,
5826 struct drm_modeset_acquire_ctx *ctx,
5829 struct drm_i915_private *dev_priv = to_i915(connector->dev);
5830 struct intel_connector *intel_connector =
5831 to_intel_connector(connector);
5832 struct intel_dp *intel_dp = intel_attached_dp(intel_connector);
5833 struct intel_digital_port *dig_port = dp_to_dig_port(intel_dp);
5834 struct intel_encoder *encoder = &dig_port->base;
5835 enum drm_connector_status status;
5838 drm_dbg_kms(&dev_priv->drm, "[CONNECTOR:%d:%s]\n",
5839 connector->base.id, connector->name);
5840 drm_WARN_ON(&dev_priv->drm,
5841 !drm_modeset_is_locked(&dev_priv->drm.mode_config.connection_mutex));
5843 if (!intel_display_device_enabled(dev_priv))
5844 return connector_status_disconnected;
5846 if (!intel_display_driver_check_access(dev_priv))
5847 return connector->status;
5849 /* Can't disconnect eDP */
5850 if (intel_dp_is_edp(intel_dp))
5851 status = edp_detect(intel_dp);
5852 else if (intel_digital_port_connected(encoder))
5853 status = intel_dp_detect_dpcd(intel_dp);
5855 status = connector_status_disconnected;
5857 if (status == connector_status_disconnected) {
5858 memset(&intel_dp->compliance, 0, sizeof(intel_dp->compliance));
5859 memset(intel_connector->dp.dsc_dpcd, 0, sizeof(intel_connector->dp.dsc_dpcd));
5860 intel_dp->psr.sink_panel_replay_support = false;
5862 intel_dp_mst_disconnect(intel_dp);
5864 intel_dp_tunnel_disconnect(intel_dp);
5869 ret = intel_dp_tunnel_detect(intel_dp, ctx);
5870 if (ret == -EDEADLK)
5874 intel_connector->base.epoch_counter++;
5876 if (!intel_dp_is_edp(intel_dp))
5877 intel_psr_init_dpcd(intel_dp);
5879 intel_dp_detect_dsc_caps(intel_dp, intel_connector);
5881 intel_dp_mst_configure(intel_dp);
5884 * TODO: Reset link params when switching to MST mode, until MST
5885 * supports link training fallback params.
5887 if (intel_dp->reset_link_params || intel_dp->is_mst) {
5888 intel_dp_reset_max_link_params(intel_dp);
5889 intel_dp->reset_link_params = false;
5892 intel_dp_print_rates(intel_dp);
5894 if (intel_dp->is_mst) {
5896 * If we are in MST mode then this connector
5897 * won't appear connected or have anything
5900 status = connector_status_disconnected;
5905 * Some external monitors do not signal loss of link synchronization
5906 * with an IRQ_HPD, so force a link status check.
5908 if (!intel_dp_is_edp(intel_dp)) {
5909 ret = intel_dp_retrain_link(encoder, ctx);
5915 * Clearing NACK and defer counts to get their exact values
5916 * while reading EDID which are required by Compliance tests
5917 * 4.2.2.4 and 4.2.2.5
5919 intel_dp->aux.i2c_nack_count = 0;
5920 intel_dp->aux.i2c_defer_count = 0;
5922 intel_dp_set_edid(intel_dp);
5923 if (intel_dp_is_edp(intel_dp) ||
5924 to_intel_connector(connector)->detect_edid)
5925 status = connector_status_connected;
5927 intel_dp_check_device_service_irq(intel_dp);
5930 if (status != connector_status_connected && !intel_dp->is_mst)
5931 intel_dp_unset_edid(intel_dp);
5933 if (!intel_dp_is_edp(intel_dp))
5934 drm_dp_set_subconnector_property(connector,
5937 intel_dp->downstream_ports);
5942 intel_dp_force(struct drm_connector *connector)
5944 struct intel_dp *intel_dp = intel_attached_dp(to_intel_connector(connector));
5945 struct intel_digital_port *dig_port = dp_to_dig_port(intel_dp);
5946 struct intel_encoder *intel_encoder = &dig_port->base;
5947 struct drm_i915_private *dev_priv = to_i915(intel_encoder->base.dev);
5949 drm_dbg_kms(&dev_priv->drm, "[CONNECTOR:%d:%s]\n",
5950 connector->base.id, connector->name);
5952 if (!intel_display_driver_check_access(dev_priv))
5955 intel_dp_unset_edid(intel_dp);
5957 if (connector->status != connector_status_connected)
5960 intel_dp_set_edid(intel_dp);
5963 static int intel_dp_get_modes(struct drm_connector *connector)
5965 struct intel_connector *intel_connector = to_intel_connector(connector);
5968 /* drm_edid_connector_update() done in ->detect() or ->force() */
5969 num_modes = drm_edid_connector_add_modes(connector);
5971 /* Also add fixed mode, which may or may not be present in EDID */
5972 if (intel_dp_is_edp(intel_attached_dp(intel_connector)))
5973 num_modes += intel_panel_get_modes(intel_connector);
5978 if (!intel_connector->detect_edid) {
5979 struct intel_dp *intel_dp = intel_attached_dp(intel_connector);
5980 struct drm_display_mode *mode;
5982 mode = drm_dp_downstream_mode(connector->dev,
5984 intel_dp->downstream_ports);
5986 drm_mode_probed_add(connector, mode);
5995 intel_dp_connector_register(struct drm_connector *connector)
5997 struct drm_i915_private *i915 = to_i915(connector->dev);
5998 struct intel_dp *intel_dp = intel_attached_dp(to_intel_connector(connector));
5999 struct intel_digital_port *dig_port = dp_to_dig_port(intel_dp);
6000 struct intel_lspcon *lspcon = &dig_port->lspcon;
6003 ret = intel_connector_register(connector);
6007 drm_dbg_kms(&i915->drm, "registering %s bus for %s\n",
6008 intel_dp->aux.name, connector->kdev->kobj.name);
6010 intel_dp->aux.dev = connector->kdev;
6011 ret = drm_dp_aux_register(&intel_dp->aux);
6013 drm_dp_cec_register_connector(&intel_dp->aux, connector);
6015 if (!intel_bios_encoder_is_lspcon(dig_port->base.devdata))
6019 * ToDo: Clean this up to handle lspcon init and resume more
6020 * efficiently and streamlined.
6022 if (lspcon_init(dig_port)) {
6023 lspcon_detect_hdr_capability(lspcon);
6024 if (lspcon->hdr_supported)
6025 drm_connector_attach_hdr_output_metadata_property(connector);
6032 intel_dp_connector_unregister(struct drm_connector *connector)
6034 struct intel_dp *intel_dp = intel_attached_dp(to_intel_connector(connector));
6036 drm_dp_cec_unregister_connector(&intel_dp->aux);
6037 drm_dp_aux_unregister(&intel_dp->aux);
6038 intel_connector_unregister(connector);
6041 void intel_dp_connector_sync_state(struct intel_connector *connector,
6042 const struct intel_crtc_state *crtc_state)
6044 struct drm_i915_private *i915 = to_i915(connector->base.dev);
6046 if (crtc_state && crtc_state->dsc.compression_enable) {
6047 drm_WARN_ON(&i915->drm, !connector->dp.dsc_decompression_aux);
6048 connector->dp.dsc_decompression_enabled = true;
6050 connector->dp.dsc_decompression_enabled = false;
6054 void intel_dp_encoder_flush_work(struct drm_encoder *encoder)
6056 struct intel_digital_port *dig_port = enc_to_dig_port(to_intel_encoder(encoder));
6057 struct intel_dp *intel_dp = &dig_port->dp;
6059 intel_dp_mst_encoder_cleanup(dig_port);
6061 intel_dp_tunnel_destroy(intel_dp);
6063 intel_pps_vdd_off_sync(intel_dp);
6066 * Ensure power off delay is respected on module remove, so that we can
6067 * reduce delays at driver probe. See pps_init_timestamps().
6069 intel_pps_wait_power_cycle(intel_dp);
6071 intel_dp_aux_fini(intel_dp);
6074 void intel_dp_encoder_suspend(struct intel_encoder *intel_encoder)
6076 struct intel_dp *intel_dp = enc_to_intel_dp(intel_encoder);
6078 intel_pps_vdd_off_sync(intel_dp);
6080 intel_dp_tunnel_suspend(intel_dp);
6083 void intel_dp_encoder_shutdown(struct intel_encoder *intel_encoder)
6085 struct intel_dp *intel_dp = enc_to_intel_dp(intel_encoder);
6087 intel_pps_wait_power_cycle(intel_dp);
6090 static int intel_modeset_tile_group(struct intel_atomic_state *state,
6093 struct drm_i915_private *dev_priv = to_i915(state->base.dev);
6094 struct drm_connector_list_iter conn_iter;
6095 struct drm_connector *connector;
6098 drm_connector_list_iter_begin(&dev_priv->drm, &conn_iter);
6099 drm_for_each_connector_iter(connector, &conn_iter) {
6100 struct drm_connector_state *conn_state;
6101 struct intel_crtc_state *crtc_state;
6102 struct intel_crtc *crtc;
6104 if (!connector->has_tile ||
6105 connector->tile_group->id != tile_group_id)
6108 conn_state = drm_atomic_get_connector_state(&state->base,
6110 if (IS_ERR(conn_state)) {
6111 ret = PTR_ERR(conn_state);
6115 crtc = to_intel_crtc(conn_state->crtc);
6120 crtc_state = intel_atomic_get_new_crtc_state(state, crtc);
6121 crtc_state->uapi.mode_changed = true;
6123 ret = drm_atomic_add_affected_planes(&state->base, &crtc->base);
6127 drm_connector_list_iter_end(&conn_iter);
6132 static int intel_modeset_affected_transcoders(struct intel_atomic_state *state, u8 transcoders)
6134 struct drm_i915_private *dev_priv = to_i915(state->base.dev);
6135 struct intel_crtc *crtc;
6137 if (transcoders == 0)
6140 for_each_intel_crtc(&dev_priv->drm, crtc) {
6141 struct intel_crtc_state *crtc_state;
6144 crtc_state = intel_atomic_get_crtc_state(&state->base, crtc);
6145 if (IS_ERR(crtc_state))
6146 return PTR_ERR(crtc_state);
6148 if (!crtc_state->hw.enable)
6151 if (!(transcoders & BIT(crtc_state->cpu_transcoder)))
6154 crtc_state->uapi.mode_changed = true;
6156 ret = drm_atomic_add_affected_connectors(&state->base, &crtc->base);
6160 ret = drm_atomic_add_affected_planes(&state->base, &crtc->base);
6164 transcoders &= ~BIT(crtc_state->cpu_transcoder);
6167 drm_WARN_ON(&dev_priv->drm, transcoders != 0);
6172 static int intel_modeset_synced_crtcs(struct intel_atomic_state *state,
6173 struct drm_connector *connector)
6175 const struct drm_connector_state *old_conn_state =
6176 drm_atomic_get_old_connector_state(&state->base, connector);
6177 const struct intel_crtc_state *old_crtc_state;
6178 struct intel_crtc *crtc;
6181 crtc = to_intel_crtc(old_conn_state->crtc);
6185 old_crtc_state = intel_atomic_get_old_crtc_state(state, crtc);
6187 if (!old_crtc_state->hw.active)
6190 transcoders = old_crtc_state->sync_mode_slaves_mask;
6191 if (old_crtc_state->master_transcoder != INVALID_TRANSCODER)
6192 transcoders |= BIT(old_crtc_state->master_transcoder);
6194 return intel_modeset_affected_transcoders(state,
6198 static int intel_dp_connector_atomic_check(struct drm_connector *conn,
6199 struct drm_atomic_state *_state)
6201 struct drm_i915_private *dev_priv = to_i915(conn->dev);
6202 struct intel_atomic_state *state = to_intel_atomic_state(_state);
6203 struct drm_connector_state *conn_state = drm_atomic_get_new_connector_state(_state, conn);
6204 struct intel_connector *intel_conn = to_intel_connector(conn);
6205 struct intel_dp *intel_dp = enc_to_intel_dp(intel_conn->encoder);
6208 ret = intel_digital_connector_atomic_check(conn, &state->base);
6212 if (intel_dp_mst_source_support(intel_dp)) {
6213 ret = drm_dp_mst_root_conn_atomic_check(conn_state, &intel_dp->mst_mgr);
6218 if (!intel_connector_needs_modeset(state, conn))
6221 ret = intel_dp_tunnel_atomic_check_state(state,
6228 * We don't enable port sync on BDW due to missing w/as and
6229 * due to not having adjusted the modeset sequence appropriately.
6231 if (DISPLAY_VER(dev_priv) < 9)
6234 if (conn->has_tile) {
6235 ret = intel_modeset_tile_group(state, conn->tile_group->id);
6240 return intel_modeset_synced_crtcs(state, conn);
6243 static void intel_dp_oob_hotplug_event(struct drm_connector *connector,
6244 enum drm_connector_status hpd_state)
6246 struct intel_encoder *encoder = intel_attached_encoder(to_intel_connector(connector));
6247 struct drm_i915_private *i915 = to_i915(connector->dev);
6248 bool hpd_high = hpd_state == connector_status_connected;
6249 unsigned int hpd_pin = encoder->hpd_pin;
6250 bool need_work = false;
6252 spin_lock_irq(&i915->irq_lock);
6253 if (hpd_high != test_bit(hpd_pin, &i915->display.hotplug.oob_hotplug_last_state)) {
6254 i915->display.hotplug.event_bits |= BIT(hpd_pin);
6256 __assign_bit(hpd_pin, &i915->display.hotplug.oob_hotplug_last_state, hpd_high);
6259 spin_unlock_irq(&i915->irq_lock);
6262 intel_hpd_schedule_detection(i915);
6265 static const struct drm_connector_funcs intel_dp_connector_funcs = {
6266 .force = intel_dp_force,
6267 .fill_modes = drm_helper_probe_single_connector_modes,
6268 .atomic_get_property = intel_digital_connector_atomic_get_property,
6269 .atomic_set_property = intel_digital_connector_atomic_set_property,
6270 .late_register = intel_dp_connector_register,
6271 .early_unregister = intel_dp_connector_unregister,
6272 .destroy = intel_connector_destroy,
6273 .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
6274 .atomic_duplicate_state = intel_digital_connector_duplicate_state,
6275 .oob_hotplug_event = intel_dp_oob_hotplug_event,
6278 static const struct drm_connector_helper_funcs intel_dp_connector_helper_funcs = {
6279 .detect_ctx = intel_dp_detect,
6280 .get_modes = intel_dp_get_modes,
6281 .mode_valid = intel_dp_mode_valid,
6282 .atomic_check = intel_dp_connector_atomic_check,
6286 intel_dp_hpd_pulse(struct intel_digital_port *dig_port, bool long_hpd)
6288 struct drm_i915_private *i915 = to_i915(dig_port->base.base.dev);
6289 struct intel_dp *intel_dp = &dig_port->dp;
6290 u8 dpcd[DP_RECEIVER_CAP_SIZE];
6292 if (dig_port->base.type == INTEL_OUTPUT_EDP &&
6293 (long_hpd || !intel_pps_have_panel_power_or_vdd(intel_dp))) {
6295 * vdd off can generate a long/short pulse on eDP which
6296 * would require vdd on to handle it, and thus we
6297 * would end up in an endless cycle of
6298 * "vdd off -> long/short hpd -> vdd on -> detect -> vdd off -> ..."
6300 drm_dbg_kms(&i915->drm,
6301 "ignoring %s hpd on eDP [ENCODER:%d:%s]\n",
6302 long_hpd ? "long" : "short",
6303 dig_port->base.base.base.id,
6304 dig_port->base.base.name);
6308 drm_dbg_kms(&i915->drm, "got hpd irq on [ENCODER:%d:%s] - %s\n",
6309 dig_port->base.base.base.id,
6310 dig_port->base.base.name,
6311 long_hpd ? "long" : "short");
6314 * TBT DP tunnels require the GFX driver to read out the DPRX caps in
6315 * response to long HPD pulses. The DP hotplug handler does that,
6316 * however the hotplug handler may be blocked by another
6317 * connector's/encoder's hotplug handler. Since the TBT CM may not
6318 * complete the DP tunnel BW request for the latter connector/encoder
6319 * waiting for this encoder's DPRX read, perform a dummy read here.
6322 intel_dp_read_dprx_caps(intel_dp, dpcd);
6325 intel_dp->reset_link_params = true;
6329 if (intel_dp->is_mst) {
6330 if (!intel_dp_check_mst_status(intel_dp))
6332 } else if (!intel_dp_short_pulse(intel_dp)) {
6339 static bool _intel_dp_is_port_edp(struct drm_i915_private *dev_priv,
6340 const struct intel_bios_encoder_data *devdata,
6344 * eDP not supported on g4x. so bail out early just
6345 * for a bit extra safety in case the VBT is bonkers.
6347 if (DISPLAY_VER(dev_priv) < 5)
6350 if (DISPLAY_VER(dev_priv) < 9 && port == PORT_A)
6353 return devdata && intel_bios_encoder_supports_edp(devdata);
6356 bool intel_dp_is_port_edp(struct drm_i915_private *i915, enum port port)
6358 const struct intel_bios_encoder_data *devdata =
6359 intel_bios_encoder_data_lookup(i915, port);
6361 return _intel_dp_is_port_edp(i915, devdata, port);
6365 has_gamut_metadata_dip(struct intel_encoder *encoder)
6367 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
6368 enum port port = encoder->port;
6370 if (intel_bios_encoder_is_lspcon(encoder->devdata))
6373 if (DISPLAY_VER(i915) >= 11)
6379 if (IS_HASWELL(i915) || IS_BROADWELL(i915) ||
6380 DISPLAY_VER(i915) >= 9)
6387 intel_dp_add_properties(struct intel_dp *intel_dp, struct drm_connector *connector)
6389 struct drm_i915_private *dev_priv = to_i915(connector->dev);
6390 enum port port = dp_to_dig_port(intel_dp)->base.port;
6392 if (!intel_dp_is_edp(intel_dp))
6393 drm_connector_attach_dp_subconnector_property(connector);
6395 if (!IS_G4X(dev_priv) && port != PORT_A)
6396 intel_attach_force_audio_property(connector);
6398 intel_attach_broadcast_rgb_property(connector);
6399 if (HAS_GMCH(dev_priv))
6400 drm_connector_attach_max_bpc_property(connector, 6, 10);
6401 else if (DISPLAY_VER(dev_priv) >= 5)
6402 drm_connector_attach_max_bpc_property(connector, 6, 12);
6404 /* Register HDMI colorspace for case of lspcon */
6405 if (intel_bios_encoder_is_lspcon(dp_to_dig_port(intel_dp)->base.devdata)) {
6406 drm_connector_attach_content_type_property(connector);
6407 intel_attach_hdmi_colorspace_property(connector);
6409 intel_attach_dp_colorspace_property(connector);
6412 if (has_gamut_metadata_dip(&dp_to_dig_port(intel_dp)->base))
6413 drm_connector_attach_hdr_output_metadata_property(connector);
6415 if (HAS_VRR(dev_priv))
6416 drm_connector_attach_vrr_capable_property(connector);
6420 intel_edp_add_properties(struct intel_dp *intel_dp)
6422 struct intel_connector *connector = intel_dp->attached_connector;
6423 struct drm_i915_private *i915 = to_i915(connector->base.dev);
6424 const struct drm_display_mode *fixed_mode =
6425 intel_panel_preferred_fixed_mode(connector);
6427 intel_attach_scaling_mode_property(&connector->base);
6429 drm_connector_set_panel_orientation_with_quirk(&connector->base,
6430 i915->display.vbt.orientation,
6431 fixed_mode->hdisplay,
6432 fixed_mode->vdisplay);
6435 static void intel_edp_backlight_setup(struct intel_dp *intel_dp,
6436 struct intel_connector *connector)
6438 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
6439 enum pipe pipe = INVALID_PIPE;
6441 if (IS_VALLEYVIEW(i915) || IS_CHERRYVIEW(i915)) {
6443 * Figure out the current pipe for the initial backlight setup.
6444 * If the current pipe isn't valid, try the PPS pipe, and if that
6445 * fails just assume pipe A.
6447 pipe = vlv_active_pipe(intel_dp);
6449 if (pipe != PIPE_A && pipe != PIPE_B)
6450 pipe = intel_dp->pps.pps_pipe;
6452 if (pipe != PIPE_A && pipe != PIPE_B)
6456 intel_backlight_setup(connector, pipe);
6459 static bool intel_edp_init_connector(struct intel_dp *intel_dp,
6460 struct intel_connector *intel_connector)
6462 struct drm_i915_private *dev_priv = dp_to_i915(intel_dp);
6463 struct drm_connector *connector = &intel_connector->base;
6464 struct drm_display_mode *fixed_mode;
6465 struct intel_encoder *encoder = &dp_to_dig_port(intel_dp)->base;
6467 const struct drm_edid *drm_edid;
6469 if (!intel_dp_is_edp(intel_dp))
6473 * On IBX/CPT we may get here with LVDS already registered. Since the
6474 * driver uses the only internal power sequencer available for both
6475 * eDP and LVDS bail out early in this case to prevent interfering
6476 * with an already powered-on LVDS power sequencer.
6478 if (intel_get_lvds_encoder(dev_priv)) {
6479 drm_WARN_ON(&dev_priv->drm,
6480 !(HAS_PCH_IBX(dev_priv) || HAS_PCH_CPT(dev_priv)));
6481 drm_info(&dev_priv->drm,
6482 "LVDS was detected, not registering eDP\n");
6487 intel_bios_init_panel_early(dev_priv, &intel_connector->panel,
6490 if (!intel_pps_init(intel_dp)) {
6491 drm_info(&dev_priv->drm,
6492 "[ENCODER:%d:%s] unusable PPS, disabling eDP\n",
6493 encoder->base.base.id, encoder->base.name);
6495 * The BIOS may have still enabled VDD on the PPS even
6496 * though it's unusable. Make sure we turn it back off
6497 * and to release the power domain references/etc.
6503 * Enable HPD sense for live status check.
6504 * intel_hpd_irq_setup() will turn it off again
6505 * if it's no longer needed later.
6507 * The DPCD probe below will make sure VDD is on.
6509 intel_hpd_enable_detection(encoder);
6511 /* Cache DPCD and EDID for edp. */
6512 has_dpcd = intel_edp_init_dpcd(intel_dp, intel_connector);
6515 /* if this fails, presume the device is a ghost */
6516 drm_info(&dev_priv->drm,
6517 "[ENCODER:%d:%s] failed to retrieve link info, disabling eDP\n",
6518 encoder->base.base.id, encoder->base.name);
6523 * VBT and straps are liars. Also check HPD as that seems
6524 * to be the most reliable piece of information available.
6526 * ... expect on devices that forgot to hook HPD up for eDP
6527 * (eg. Acer Chromebook C710), so we'll check it only if multiple
6528 * ports are attempting to use the same AUX CH, according to VBT.
6530 if (intel_bios_dp_has_shared_aux_ch(encoder->devdata)) {
6532 * If this fails, presume the DPCD answer came
6533 * from some other port using the same AUX CH.
6535 * FIXME maybe cleaner to check this before the
6536 * DPCD read? Would need sort out the VDD handling...
6538 if (!intel_digital_port_connected(encoder)) {
6539 drm_info(&dev_priv->drm,
6540 "[ENCODER:%d:%s] HPD is down, disabling eDP\n",
6541 encoder->base.base.id, encoder->base.name);
6546 * Unfortunately even the HPD based detection fails on
6547 * eg. Asus B360M-A (CFL+CNP), so as a last resort fall
6548 * back to checking for a VGA branch device. Only do this
6549 * on known affected platforms to minimize false positives.
6551 if (DISPLAY_VER(dev_priv) == 9 && drm_dp_is_branch(intel_dp->dpcd) &&
6552 (intel_dp->dpcd[DP_DOWNSTREAMPORT_PRESENT] & DP_DWN_STRM_PORT_TYPE_MASK) ==
6553 DP_DWN_STRM_PORT_TYPE_ANALOG) {
6554 drm_info(&dev_priv->drm,
6555 "[ENCODER:%d:%s] VGA converter detected, disabling eDP\n",
6556 encoder->base.base.id, encoder->base.name);
6561 mutex_lock(&dev_priv->drm.mode_config.mutex);
6562 drm_edid = drm_edid_read_ddc(connector, connector->ddc);
6564 /* Fallback to EDID from ACPI OpRegion, if any */
6565 drm_edid = intel_opregion_get_edid(intel_connector);
6567 drm_dbg_kms(&dev_priv->drm,
6568 "[CONNECTOR:%d:%s] Using OpRegion EDID\n",
6569 connector->base.id, connector->name);
6572 if (drm_edid_connector_update(connector, drm_edid) ||
6573 !drm_edid_connector_add_modes(connector)) {
6574 drm_edid_connector_update(connector, NULL);
6575 drm_edid_free(drm_edid);
6576 drm_edid = ERR_PTR(-EINVAL);
6579 drm_edid = ERR_PTR(-ENOENT);
6582 intel_bios_init_panel_late(dev_priv, &intel_connector->panel, encoder->devdata,
6583 IS_ERR(drm_edid) ? NULL : drm_edid);
6585 intel_panel_add_edid_fixed_modes(intel_connector, true);
6587 /* MSO requires information from the EDID */
6588 intel_edp_mso_init(intel_dp);
6590 /* multiply the mode clock and horizontal timings for MSO */
6591 list_for_each_entry(fixed_mode, &intel_connector->panel.fixed_modes, head)
6592 intel_edp_mso_mode_fixup(intel_connector, fixed_mode);
6594 /* fallback to VBT if available for eDP */
6595 if (!intel_panel_preferred_fixed_mode(intel_connector))
6596 intel_panel_add_vbt_lfp_fixed_mode(intel_connector);
6598 mutex_unlock(&dev_priv->drm.mode_config.mutex);
6600 if (!intel_panel_preferred_fixed_mode(intel_connector)) {
6601 drm_info(&dev_priv->drm,
6602 "[ENCODER:%d:%s] failed to find fixed mode for the panel, disabling eDP\n",
6603 encoder->base.base.id, encoder->base.name);
6607 intel_panel_init(intel_connector, drm_edid);
6609 intel_edp_backlight_setup(intel_dp, intel_connector);
6611 intel_edp_add_properties(intel_dp);
6613 intel_pps_init_late(intel_dp);
6618 intel_pps_vdd_off_sync(intel_dp);
6623 static void intel_dp_modeset_retry_work_fn(struct work_struct *work)
6625 struct intel_connector *intel_connector;
6626 struct drm_connector *connector;
6628 intel_connector = container_of(work, typeof(*intel_connector),
6629 modeset_retry_work);
6630 connector = &intel_connector->base;
6631 drm_dbg_kms(connector->dev, "[CONNECTOR:%d:%s]\n", connector->base.id,
6634 /* Grab the locks before changing connector property*/
6635 mutex_lock(&connector->dev->mode_config.mutex);
6636 /* Set connector link status to BAD and send a Uevent to notify
6637 * userspace to do a modeset.
6639 drm_connector_set_link_status_property(connector,
6640 DRM_MODE_LINK_STATUS_BAD);
6641 mutex_unlock(&connector->dev->mode_config.mutex);
6642 /* Send Hotplug uevent so userspace can reprobe */
6643 drm_kms_helper_connector_hotplug_event(connector);
6645 drm_connector_put(connector);
6648 void intel_dp_init_modeset_retry_work(struct intel_connector *connector)
6650 INIT_WORK(&connector->modeset_retry_work,
6651 intel_dp_modeset_retry_work_fn);
6655 intel_dp_init_connector(struct intel_digital_port *dig_port,
6656 struct intel_connector *intel_connector)
6658 struct drm_connector *connector = &intel_connector->base;
6659 struct intel_dp *intel_dp = &dig_port->dp;
6660 struct intel_encoder *intel_encoder = &dig_port->base;
6661 struct drm_device *dev = intel_encoder->base.dev;
6662 struct drm_i915_private *dev_priv = to_i915(dev);
6663 enum port port = intel_encoder->port;
6666 /* Initialize the work for modeset in case of link train failure */
6667 intel_dp_init_modeset_retry_work(intel_connector);
6669 if (drm_WARN(dev, dig_port->max_lanes < 1,
6670 "Not enough lanes (%d) for DP on [ENCODER:%d:%s]\n",
6671 dig_port->max_lanes, intel_encoder->base.base.id,
6672 intel_encoder->base.name))
6675 intel_dp->reset_link_params = true;
6676 intel_dp->pps.pps_pipe = INVALID_PIPE;
6677 intel_dp->pps.active_pipe = INVALID_PIPE;
6679 /* Preserve the current hw state. */
6680 intel_dp->DP = intel_de_read(dev_priv, intel_dp->output_reg);
6681 intel_dp->attached_connector = intel_connector;
6683 if (_intel_dp_is_port_edp(dev_priv, intel_encoder->devdata, port)) {
6685 * Currently we don't support eDP on TypeC ports, although in
6686 * theory it could work on TypeC legacy ports.
6688 drm_WARN_ON(dev, intel_encoder_is_tc(intel_encoder));
6689 type = DRM_MODE_CONNECTOR_eDP;
6690 intel_encoder->type = INTEL_OUTPUT_EDP;
6692 /* eDP only on port B and/or C on vlv/chv */
6693 if (drm_WARN_ON(dev, (IS_VALLEYVIEW(dev_priv) ||
6694 IS_CHERRYVIEW(dev_priv)) &&
6695 port != PORT_B && port != PORT_C))
6698 type = DRM_MODE_CONNECTOR_DisplayPort;
6701 intel_dp_set_default_sink_rates(intel_dp);
6702 intel_dp_set_default_max_sink_lane_count(intel_dp);
6704 if (IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv))
6705 intel_dp->pps.active_pipe = vlv_active_pipe(intel_dp);
6707 intel_dp_aux_init(intel_dp);
6708 intel_connector->dp.dsc_decompression_aux = &intel_dp->aux;
6710 drm_dbg_kms(&dev_priv->drm,
6711 "Adding %s connector on [ENCODER:%d:%s]\n",
6712 type == DRM_MODE_CONNECTOR_eDP ? "eDP" : "DP",
6713 intel_encoder->base.base.id, intel_encoder->base.name);
6715 drm_connector_init_with_ddc(dev, connector, &intel_dp_connector_funcs,
6716 type, &intel_dp->aux.ddc);
6717 drm_connector_helper_add(connector, &intel_dp_connector_helper_funcs);
6719 if (!HAS_GMCH(dev_priv) && DISPLAY_VER(dev_priv) < 12)
6720 connector->interlace_allowed = true;
6722 intel_connector->polled = DRM_CONNECTOR_POLL_HPD;
6723 intel_connector->base.polled = intel_connector->polled;
6725 intel_connector_attach_encoder(intel_connector, intel_encoder);
6727 if (HAS_DDI(dev_priv))
6728 intel_connector->get_hw_state = intel_ddi_connector_get_hw_state;
6730 intel_connector->get_hw_state = intel_connector_get_hw_state;
6731 intel_connector->sync_state = intel_dp_connector_sync_state;
6733 if (!intel_edp_init_connector(intel_dp, intel_connector)) {
6734 intel_dp_aux_fini(intel_dp);
6738 intel_dp_set_source_rates(intel_dp);
6739 intel_dp_set_common_rates(intel_dp);
6740 intel_dp_reset_max_link_params(intel_dp);
6742 /* init MST on ports that can support it */
6743 intel_dp_mst_encoder_init(dig_port,
6744 intel_connector->base.base.id);
6746 intel_dp_add_properties(intel_dp, connector);
6748 if (is_hdcp_supported(dev_priv, port) && !intel_dp_is_edp(intel_dp)) {
6749 int ret = intel_dp_hdcp_init(dig_port, intel_connector);
6751 drm_dbg_kms(&dev_priv->drm,
6752 "HDCP init failed, skipping.\n");
6755 intel_dp->colorimetry_support =
6756 intel_dp_get_colorimetry_status(intel_dp);
6758 intel_dp->frl.is_trained = false;
6759 intel_dp->frl.trained_rate_gbps = 0;
6761 intel_psr_init(intel_dp);
6766 intel_display_power_flush_work(dev_priv);
6767 drm_connector_cleanup(connector);
6772 void intel_dp_mst_suspend(struct drm_i915_private *dev_priv)
6774 struct intel_encoder *encoder;
6776 if (!HAS_DISPLAY(dev_priv))
6779 for_each_intel_encoder(&dev_priv->drm, encoder) {
6780 struct intel_dp *intel_dp;
6782 if (encoder->type != INTEL_OUTPUT_DDI)
6785 intel_dp = enc_to_intel_dp(encoder);
6787 if (!intel_dp_mst_source_support(intel_dp))
6790 if (intel_dp->is_mst)
6791 drm_dp_mst_topology_mgr_suspend(&intel_dp->mst_mgr);
6795 void intel_dp_mst_resume(struct drm_i915_private *dev_priv)
6797 struct intel_encoder *encoder;
6799 if (!HAS_DISPLAY(dev_priv))
6802 for_each_intel_encoder(&dev_priv->drm, encoder) {
6803 struct intel_dp *intel_dp;
6806 if (encoder->type != INTEL_OUTPUT_DDI)
6809 intel_dp = enc_to_intel_dp(encoder);
6811 if (!intel_dp_mst_source_support(intel_dp))
6814 ret = drm_dp_mst_topology_mgr_resume(&intel_dp->mst_mgr,
6817 intel_dp->is_mst = false;
6818 drm_dp_mst_topology_mgr_set_mst(&intel_dp->mst_mgr,