2 * Copyright © 2012 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 * Eugeni Dodonov <eugeni.dodonov@intel.com>
28 #include <linux/string_helpers.h>
30 #include <drm/display/drm_scdc_helper.h>
31 #include <drm/drm_privacy_screen_consumer.h>
35 #include "intel_audio.h"
36 #include "intel_audio_regs.h"
37 #include "intel_backlight.h"
38 #include "intel_combo_phy.h"
39 #include "intel_combo_phy_regs.h"
40 #include "intel_connector.h"
41 #include "intel_crtc.h"
42 #include "intel_cx0_phy.h"
43 #include "intel_cx0_phy_regs.h"
44 #include "intel_ddi.h"
45 #include "intel_ddi_buf_trans.h"
47 #include "intel_display_power.h"
48 #include "intel_display_types.h"
49 #include "intel_dkl_phy.h"
50 #include "intel_dkl_phy_regs.h"
52 #include "intel_dp_aux.h"
53 #include "intel_dp_link_training.h"
54 #include "intel_dp_mst.h"
55 #include "intel_dpio_phy.h"
56 #include "intel_dsi.h"
57 #include "intel_fdi.h"
58 #include "intel_fifo_underrun.h"
59 #include "intel_gmbus.h"
60 #include "intel_hdcp.h"
61 #include "intel_hdmi.h"
62 #include "intel_hotplug.h"
63 #include "intel_hti.h"
64 #include "intel_lspcon.h"
65 #include "intel_mg_phy_regs.h"
66 #include "intel_modeset_lock.h"
67 #include "intel_pps.h"
68 #include "intel_psr.h"
69 #include "intel_quirks.h"
70 #include "intel_snps_phy.h"
72 #include "intel_vdsc.h"
73 #include "intel_vdsc_regs.h"
74 #include "skl_scaler.h"
75 #include "skl_universal_plane.h"
77 static const u8 index_to_dp_signal_levels[] = {
78 [0] = DP_TRAIN_VOLTAGE_SWING_LEVEL_0 | DP_TRAIN_PRE_EMPH_LEVEL_0,
79 [1] = DP_TRAIN_VOLTAGE_SWING_LEVEL_0 | DP_TRAIN_PRE_EMPH_LEVEL_1,
80 [2] = DP_TRAIN_VOLTAGE_SWING_LEVEL_0 | DP_TRAIN_PRE_EMPH_LEVEL_2,
81 [3] = DP_TRAIN_VOLTAGE_SWING_LEVEL_0 | DP_TRAIN_PRE_EMPH_LEVEL_3,
82 [4] = DP_TRAIN_VOLTAGE_SWING_LEVEL_1 | DP_TRAIN_PRE_EMPH_LEVEL_0,
83 [5] = DP_TRAIN_VOLTAGE_SWING_LEVEL_1 | DP_TRAIN_PRE_EMPH_LEVEL_1,
84 [6] = DP_TRAIN_VOLTAGE_SWING_LEVEL_1 | DP_TRAIN_PRE_EMPH_LEVEL_2,
85 [7] = DP_TRAIN_VOLTAGE_SWING_LEVEL_2 | DP_TRAIN_PRE_EMPH_LEVEL_0,
86 [8] = DP_TRAIN_VOLTAGE_SWING_LEVEL_2 | DP_TRAIN_PRE_EMPH_LEVEL_1,
87 [9] = DP_TRAIN_VOLTAGE_SWING_LEVEL_3 | DP_TRAIN_PRE_EMPH_LEVEL_0,
90 static int intel_ddi_hdmi_level(struct intel_encoder *encoder,
91 const struct intel_ddi_buf_trans *trans)
95 level = intel_bios_hdmi_level_shift(encoder->devdata);
97 level = trans->hdmi_default_entry;
102 static bool has_buf_trans_select(struct drm_i915_private *i915)
104 return DISPLAY_VER(i915) < 10 && !IS_BROXTON(i915);
107 static bool has_iboost(struct drm_i915_private *i915)
109 return DISPLAY_VER(i915) == 9 && !IS_BROXTON(i915);
113 * Starting with Haswell, DDI port buffers must be programmed with correct
114 * values in advance. This function programs the correct values for
115 * DP/eDP/FDI use cases.
117 void hsw_prepare_dp_ddi_buffers(struct intel_encoder *encoder,
118 const struct intel_crtc_state *crtc_state)
120 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
123 enum port port = encoder->port;
124 const struct intel_ddi_buf_trans *trans;
126 trans = encoder->get_buf_trans(encoder, crtc_state, &n_entries);
127 if (drm_WARN_ON_ONCE(&dev_priv->drm, !trans))
130 /* If we're boosting the current, set bit 31 of trans1 */
131 if (has_iboost(dev_priv) &&
132 intel_bios_dp_boost_level(encoder->devdata))
133 iboost_bit = DDI_BUF_BALANCE_LEG_ENABLE;
135 for (i = 0; i < n_entries; i++) {
136 intel_de_write(dev_priv, DDI_BUF_TRANS_LO(port, i),
137 trans->entries[i].hsw.trans1 | iboost_bit);
138 intel_de_write(dev_priv, DDI_BUF_TRANS_HI(port, i),
139 trans->entries[i].hsw.trans2);
144 * Starting with Haswell, DDI port buffers must be programmed with correct
145 * values in advance. This function programs the correct values for
146 * HDMI/DVI use cases.
148 static void hsw_prepare_hdmi_ddi_buffers(struct intel_encoder *encoder,
149 const struct intel_crtc_state *crtc_state)
151 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
152 int level = intel_ddi_level(encoder, crtc_state, 0);
155 enum port port = encoder->port;
156 const struct intel_ddi_buf_trans *trans;
158 trans = encoder->get_buf_trans(encoder, crtc_state, &n_entries);
159 if (drm_WARN_ON_ONCE(&dev_priv->drm, !trans))
162 /* If we're boosting the current, set bit 31 of trans1 */
163 if (has_iboost(dev_priv) &&
164 intel_bios_hdmi_boost_level(encoder->devdata))
165 iboost_bit = DDI_BUF_BALANCE_LEG_ENABLE;
167 /* Entry 9 is for HDMI: */
168 intel_de_write(dev_priv, DDI_BUF_TRANS_LO(port, 9),
169 trans->entries[level].hsw.trans1 | iboost_bit);
170 intel_de_write(dev_priv, DDI_BUF_TRANS_HI(port, 9),
171 trans->entries[level].hsw.trans2);
174 static void mtl_wait_ddi_buf_idle(struct drm_i915_private *i915, enum port port)
178 /* FIXME: find out why Bspec's 100us timeout is too short */
179 ret = wait_for_us((intel_de_read(i915, XELPDP_PORT_BUF_CTL1(port)) &
180 XELPDP_PORT_BUF_PHY_IDLE), 10000);
182 drm_err(&i915->drm, "Timeout waiting for DDI BUF %c to get idle\n",
186 void intel_wait_ddi_buf_idle(struct drm_i915_private *dev_priv,
189 if (IS_BROXTON(dev_priv)) {
194 if (wait_for_us((intel_de_read(dev_priv, DDI_BUF_CTL(port)) &
195 DDI_BUF_IS_IDLE), 8))
196 drm_err(&dev_priv->drm, "Timeout waiting for DDI BUF %c to get idle\n",
200 static void intel_wait_ddi_buf_active(struct drm_i915_private *dev_priv,
203 enum phy phy = intel_port_to_phy(dev_priv, port);
207 /* Wait > 518 usecs for DDI_BUF_CTL to be non idle */
208 if (DISPLAY_VER(dev_priv) < 10) {
209 usleep_range(518, 1000);
213 if (DISPLAY_VER(dev_priv) >= 14) {
215 } else if (IS_DG2(dev_priv)) {
217 } else if (DISPLAY_VER(dev_priv) >= 12) {
218 if (intel_phy_is_tc(dev_priv, phy))
226 if (DISPLAY_VER(dev_priv) >= 14)
227 ret = _wait_for(!(intel_de_read(dev_priv, XELPDP_PORT_BUF_CTL1(port)) & XELPDP_PORT_BUF_PHY_IDLE),
230 ret = _wait_for(!(intel_de_read(dev_priv, DDI_BUF_CTL(port)) & DDI_BUF_IS_IDLE),
234 drm_err(&dev_priv->drm, "Timeout waiting for DDI BUF %c to get active\n",
238 static u32 hsw_pll_to_ddi_pll_sel(const struct intel_shared_dpll *pll)
240 switch (pll->info->id) {
242 return PORT_CLK_SEL_WRPLL1;
244 return PORT_CLK_SEL_WRPLL2;
246 return PORT_CLK_SEL_SPLL;
247 case DPLL_ID_LCPLL_810:
248 return PORT_CLK_SEL_LCPLL_810;
249 case DPLL_ID_LCPLL_1350:
250 return PORT_CLK_SEL_LCPLL_1350;
251 case DPLL_ID_LCPLL_2700:
252 return PORT_CLK_SEL_LCPLL_2700;
254 MISSING_CASE(pll->info->id);
255 return PORT_CLK_SEL_NONE;
259 static u32 icl_pll_to_ddi_clk_sel(struct intel_encoder *encoder,
260 const struct intel_crtc_state *crtc_state)
262 const struct intel_shared_dpll *pll = crtc_state->shared_dpll;
263 int clock = crtc_state->port_clock;
264 const enum intel_dpll_id id = pll->info->id;
269 * DPLL_ID_ICL_DPLL0 and DPLL_ID_ICL_DPLL1 should not be used
270 * here, so do warn if this get passed in
273 return DDI_CLK_SEL_NONE;
274 case DPLL_ID_ICL_TBTPLL:
277 return DDI_CLK_SEL_TBT_162;
279 return DDI_CLK_SEL_TBT_270;
281 return DDI_CLK_SEL_TBT_540;
283 return DDI_CLK_SEL_TBT_810;
286 return DDI_CLK_SEL_NONE;
288 case DPLL_ID_ICL_MGPLL1:
289 case DPLL_ID_ICL_MGPLL2:
290 case DPLL_ID_ICL_MGPLL3:
291 case DPLL_ID_ICL_MGPLL4:
292 case DPLL_ID_TGL_MGPLL5:
293 case DPLL_ID_TGL_MGPLL6:
294 return DDI_CLK_SEL_MG;
298 static u32 ddi_buf_phy_link_rate(int port_clock)
300 switch (port_clock) {
302 return DDI_BUF_PHY_LINK_RATE(0);
304 return DDI_BUF_PHY_LINK_RATE(4);
306 return DDI_BUF_PHY_LINK_RATE(5);
308 return DDI_BUF_PHY_LINK_RATE(1);
310 return DDI_BUF_PHY_LINK_RATE(6);
312 return DDI_BUF_PHY_LINK_RATE(7);
314 return DDI_BUF_PHY_LINK_RATE(2);
316 return DDI_BUF_PHY_LINK_RATE(3);
318 MISSING_CASE(port_clock);
319 return DDI_BUF_PHY_LINK_RATE(0);
323 static void intel_ddi_init_dp_buf_reg(struct intel_encoder *encoder,
324 const struct intel_crtc_state *crtc_state)
326 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
327 struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
328 struct intel_digital_port *dig_port = enc_to_dig_port(encoder);
329 enum phy phy = intel_port_to_phy(i915, encoder->port);
331 /* DDI_BUF_CTL_ENABLE will be set by intel_ddi_prepare_link_retrain() later */
332 intel_dp->DP = dig_port->saved_port_bits |
333 DDI_PORT_WIDTH(crtc_state->lane_count) |
334 DDI_BUF_TRANS_SELECT(0);
336 if (DISPLAY_VER(i915) >= 14) {
337 if (intel_dp_is_uhbr(crtc_state))
338 intel_dp->DP |= DDI_BUF_PORT_DATA_40BIT;
340 intel_dp->DP |= DDI_BUF_PORT_DATA_10BIT;
343 if (IS_ALDERLAKE_P(i915) && intel_phy_is_tc(i915, phy)) {
344 intel_dp->DP |= ddi_buf_phy_link_rate(crtc_state->port_clock);
345 if (!intel_tc_port_in_tbt_alt_mode(dig_port))
346 intel_dp->DP |= DDI_BUF_CTL_TC_PHY_OWNERSHIP;
350 static int icl_calc_tbt_pll_link(struct drm_i915_private *dev_priv,
353 u32 val = intel_de_read(dev_priv, DDI_CLK_SEL(port)) & DDI_CLK_SEL_MASK;
356 case DDI_CLK_SEL_NONE:
358 case DDI_CLK_SEL_TBT_162:
360 case DDI_CLK_SEL_TBT_270:
362 case DDI_CLK_SEL_TBT_540:
364 case DDI_CLK_SEL_TBT_810:
372 static void ddi_dotclock_get(struct intel_crtc_state *pipe_config)
374 /* CRT dotclock is determined via other means */
375 if (pipe_config->has_pch_encoder)
378 pipe_config->hw.adjusted_mode.crtc_clock =
379 intel_crtc_dotclock(pipe_config);
382 void intel_ddi_set_dp_msa(const struct intel_crtc_state *crtc_state,
383 const struct drm_connector_state *conn_state)
385 struct intel_crtc *crtc = to_intel_crtc(crtc_state->uapi.crtc);
386 struct drm_i915_private *dev_priv = to_i915(crtc->base.dev);
387 enum transcoder cpu_transcoder = crtc_state->cpu_transcoder;
390 if (!intel_crtc_has_dp_encoder(crtc_state))
393 drm_WARN_ON(&dev_priv->drm, transcoder_is_dsi(cpu_transcoder));
395 temp = DP_MSA_MISC_SYNC_CLOCK;
397 switch (crtc_state->pipe_bpp) {
399 temp |= DP_MSA_MISC_6_BPC;
402 temp |= DP_MSA_MISC_8_BPC;
405 temp |= DP_MSA_MISC_10_BPC;
408 temp |= DP_MSA_MISC_12_BPC;
411 MISSING_CASE(crtc_state->pipe_bpp);
415 /* nonsense combination */
416 drm_WARN_ON(&dev_priv->drm, crtc_state->limited_color_range &&
417 crtc_state->output_format != INTEL_OUTPUT_FORMAT_RGB);
419 if (crtc_state->limited_color_range)
420 temp |= DP_MSA_MISC_COLOR_CEA_RGB;
423 * As per DP 1.2 spec section 2.3.4.3 while sending
424 * YCBCR 444 signals we should program MSA MISC1/0 fields with
425 * colorspace information.
427 if (crtc_state->output_format == INTEL_OUTPUT_FORMAT_YCBCR444)
428 temp |= DP_MSA_MISC_COLOR_YCBCR_444_BT709;
431 * As per DP 1.4a spec section 2.2.4.3 [MSA Field for Indication
432 * of Color Encoding Format and Content Color Gamut] while sending
433 * YCBCR 420, HDR BT.2020 signals we should program MSA MISC1 fields
434 * which indicate VSC SDP for the Pixel Encoding/Colorimetry Format.
436 if (intel_dp_needs_vsc_sdp(crtc_state, conn_state))
437 temp |= DP_MSA_MISC_COLOR_VSC_SDP;
439 intel_de_write(dev_priv, TRANS_MSA_MISC(cpu_transcoder), temp);
442 static u32 bdw_trans_port_sync_master_select(enum transcoder master_transcoder)
444 if (master_transcoder == TRANSCODER_EDP)
447 return master_transcoder + 1;
451 intel_ddi_config_transcoder_dp2(struct intel_encoder *encoder,
452 const struct intel_crtc_state *crtc_state)
454 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
455 enum transcoder cpu_transcoder = crtc_state->cpu_transcoder;
458 if (intel_dp_is_uhbr(crtc_state))
459 val = TRANS_DP2_128B132B_CHANNEL_CODING;
461 intel_de_write(i915, TRANS_DP2_CTL(cpu_transcoder), val);
465 * Returns the TRANS_DDI_FUNC_CTL value based on CRTC state.
467 * Only intended to be used by intel_ddi_enable_transcoder_func() and
468 * intel_ddi_config_transcoder_func().
471 intel_ddi_transcoder_func_reg_val_get(struct intel_encoder *encoder,
472 const struct intel_crtc_state *crtc_state)
474 struct intel_crtc *crtc = to_intel_crtc(crtc_state->uapi.crtc);
475 struct drm_i915_private *dev_priv = to_i915(crtc->base.dev);
476 enum pipe pipe = crtc->pipe;
477 enum transcoder cpu_transcoder = crtc_state->cpu_transcoder;
478 enum port port = encoder->port;
481 /* Enable TRANS_DDI_FUNC_CTL for the pipe to work in HDMI mode */
482 temp = TRANS_DDI_FUNC_ENABLE;
483 if (DISPLAY_VER(dev_priv) >= 12)
484 temp |= TGL_TRANS_DDI_SELECT_PORT(port);
486 temp |= TRANS_DDI_SELECT_PORT(port);
488 switch (crtc_state->pipe_bpp) {
490 MISSING_CASE(crtc_state->pipe_bpp);
493 temp |= TRANS_DDI_BPC_6;
496 temp |= TRANS_DDI_BPC_8;
499 temp |= TRANS_DDI_BPC_10;
502 temp |= TRANS_DDI_BPC_12;
506 if (crtc_state->hw.adjusted_mode.flags & DRM_MODE_FLAG_PVSYNC)
507 temp |= TRANS_DDI_PVSYNC;
508 if (crtc_state->hw.adjusted_mode.flags & DRM_MODE_FLAG_PHSYNC)
509 temp |= TRANS_DDI_PHSYNC;
511 if (cpu_transcoder == TRANSCODER_EDP) {
517 /* On Haswell, can only use the always-on power well for
518 * eDP when not using the panel fitter, and when not
519 * using motion blur mitigation (which we don't
521 if (crtc_state->pch_pfit.force_thru)
522 temp |= TRANS_DDI_EDP_INPUT_A_ONOFF;
524 temp |= TRANS_DDI_EDP_INPUT_A_ON;
527 temp |= TRANS_DDI_EDP_INPUT_B_ONOFF;
530 temp |= TRANS_DDI_EDP_INPUT_C_ONOFF;
535 if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_HDMI)) {
536 if (crtc_state->has_hdmi_sink)
537 temp |= TRANS_DDI_MODE_SELECT_HDMI;
539 temp |= TRANS_DDI_MODE_SELECT_DVI;
541 if (crtc_state->hdmi_scrambling)
542 temp |= TRANS_DDI_HDMI_SCRAMBLING;
543 if (crtc_state->hdmi_high_tmds_clock_ratio)
544 temp |= TRANS_DDI_HIGH_TMDS_CHAR_RATE;
545 if (DISPLAY_VER(dev_priv) >= 14)
546 temp |= TRANS_DDI_PORT_WIDTH(crtc_state->lane_count);
547 } else if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_ANALOG)) {
548 temp |= TRANS_DDI_MODE_SELECT_FDI_OR_128B132B;
549 temp |= (crtc_state->fdi_lanes - 1) << 1;
550 } else if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_DP_MST)) {
551 if (intel_dp_is_uhbr(crtc_state))
552 temp |= TRANS_DDI_MODE_SELECT_FDI_OR_128B132B;
554 temp |= TRANS_DDI_MODE_SELECT_DP_MST;
555 temp |= DDI_PORT_WIDTH(crtc_state->lane_count);
557 if (DISPLAY_VER(dev_priv) >= 12) {
558 enum transcoder master;
560 master = crtc_state->mst_master_transcoder;
561 drm_WARN_ON(&dev_priv->drm,
562 master == INVALID_TRANSCODER);
563 temp |= TRANS_DDI_MST_TRANSPORT_SELECT(master);
566 temp |= TRANS_DDI_MODE_SELECT_DP_SST;
567 temp |= DDI_PORT_WIDTH(crtc_state->lane_count);
570 if (IS_DISPLAY_VER(dev_priv, 8, 10) &&
571 crtc_state->master_transcoder != INVALID_TRANSCODER) {
573 bdw_trans_port_sync_master_select(crtc_state->master_transcoder);
575 temp |= TRANS_DDI_PORT_SYNC_ENABLE |
576 TRANS_DDI_PORT_SYNC_MASTER_SELECT(master_select);
582 void intel_ddi_enable_transcoder_func(struct intel_encoder *encoder,
583 const struct intel_crtc_state *crtc_state)
585 struct intel_crtc *crtc = to_intel_crtc(crtc_state->uapi.crtc);
586 struct drm_i915_private *dev_priv = to_i915(crtc->base.dev);
587 enum transcoder cpu_transcoder = crtc_state->cpu_transcoder;
589 if (DISPLAY_VER(dev_priv) >= 11) {
590 enum transcoder master_transcoder = crtc_state->master_transcoder;
593 if (master_transcoder != INVALID_TRANSCODER) {
595 bdw_trans_port_sync_master_select(master_transcoder);
597 ctl2 |= PORT_SYNC_MODE_ENABLE |
598 PORT_SYNC_MODE_MASTER_SELECT(master_select);
601 intel_de_write(dev_priv,
602 TRANS_DDI_FUNC_CTL2(cpu_transcoder), ctl2);
605 intel_de_write(dev_priv, TRANS_DDI_FUNC_CTL(cpu_transcoder),
606 intel_ddi_transcoder_func_reg_val_get(encoder,
611 * Same as intel_ddi_enable_transcoder_func(), but it does not set the enable
615 intel_ddi_config_transcoder_func(struct intel_encoder *encoder,
616 const struct intel_crtc_state *crtc_state)
618 struct intel_crtc *crtc = to_intel_crtc(crtc_state->uapi.crtc);
619 struct drm_i915_private *dev_priv = to_i915(crtc->base.dev);
620 enum transcoder cpu_transcoder = crtc_state->cpu_transcoder;
623 ctl = intel_ddi_transcoder_func_reg_val_get(encoder, crtc_state);
624 ctl &= ~TRANS_DDI_FUNC_ENABLE;
625 intel_de_write(dev_priv, TRANS_DDI_FUNC_CTL(cpu_transcoder), ctl);
628 void intel_ddi_disable_transcoder_func(const struct intel_crtc_state *crtc_state)
630 struct intel_crtc *crtc = to_intel_crtc(crtc_state->uapi.crtc);
631 struct drm_i915_private *dev_priv = to_i915(crtc->base.dev);
632 enum transcoder cpu_transcoder = crtc_state->cpu_transcoder;
635 if (DISPLAY_VER(dev_priv) >= 11)
636 intel_de_write(dev_priv,
637 TRANS_DDI_FUNC_CTL2(cpu_transcoder), 0);
639 ctl = intel_de_read(dev_priv, TRANS_DDI_FUNC_CTL(cpu_transcoder));
641 drm_WARN_ON(crtc->base.dev, ctl & TRANS_DDI_HDCP_SIGNALLING);
643 ctl &= ~TRANS_DDI_FUNC_ENABLE;
645 if (IS_DISPLAY_VER(dev_priv, 8, 10))
646 ctl &= ~(TRANS_DDI_PORT_SYNC_ENABLE |
647 TRANS_DDI_PORT_SYNC_MASTER_SELECT_MASK);
649 if (DISPLAY_VER(dev_priv) >= 12) {
650 if (!intel_dp_mst_is_master_trans(crtc_state)) {
651 ctl &= ~(TGL_TRANS_DDI_PORT_MASK |
652 TRANS_DDI_MODE_SELECT_MASK);
655 ctl &= ~(TRANS_DDI_PORT_MASK | TRANS_DDI_MODE_SELECT_MASK);
658 intel_de_write(dev_priv, TRANS_DDI_FUNC_CTL(cpu_transcoder), ctl);
660 if (intel_has_quirk(dev_priv, QUIRK_INCREASE_DDI_DISABLED_TIME) &&
661 intel_crtc_has_type(crtc_state, INTEL_OUTPUT_HDMI)) {
662 drm_dbg_kms(&dev_priv->drm,
663 "Quirk Increase DDI disabled time\n");
664 /* Quirk time at 100ms for reliable operation */
669 int intel_ddi_toggle_hdcp_bits(struct intel_encoder *intel_encoder,
670 enum transcoder cpu_transcoder,
671 bool enable, u32 hdcp_mask)
673 struct drm_device *dev = intel_encoder->base.dev;
674 struct drm_i915_private *dev_priv = to_i915(dev);
675 intel_wakeref_t wakeref;
678 wakeref = intel_display_power_get_if_enabled(dev_priv,
679 intel_encoder->power_domain);
680 if (drm_WARN_ON(dev, !wakeref))
683 intel_de_rmw(dev_priv, TRANS_DDI_FUNC_CTL(cpu_transcoder),
684 hdcp_mask, enable ? hdcp_mask : 0);
685 intel_display_power_put(dev_priv, intel_encoder->power_domain, wakeref);
689 bool intel_ddi_connector_get_hw_state(struct intel_connector *intel_connector)
691 struct drm_device *dev = intel_connector->base.dev;
692 struct drm_i915_private *dev_priv = to_i915(dev);
693 struct intel_encoder *encoder = intel_attached_encoder(intel_connector);
694 int type = intel_connector->base.connector_type;
695 enum port port = encoder->port;
696 enum transcoder cpu_transcoder;
697 intel_wakeref_t wakeref;
702 wakeref = intel_display_power_get_if_enabled(dev_priv,
703 encoder->power_domain);
707 if (!encoder->get_hw_state(encoder, &pipe)) {
712 if (HAS_TRANSCODER(dev_priv, TRANSCODER_EDP) && port == PORT_A)
713 cpu_transcoder = TRANSCODER_EDP;
715 cpu_transcoder = (enum transcoder) pipe;
717 tmp = intel_de_read(dev_priv, TRANS_DDI_FUNC_CTL(cpu_transcoder));
719 switch (tmp & TRANS_DDI_MODE_SELECT_MASK) {
720 case TRANS_DDI_MODE_SELECT_HDMI:
721 case TRANS_DDI_MODE_SELECT_DVI:
722 ret = type == DRM_MODE_CONNECTOR_HDMIA;
725 case TRANS_DDI_MODE_SELECT_DP_SST:
726 ret = type == DRM_MODE_CONNECTOR_eDP ||
727 type == DRM_MODE_CONNECTOR_DisplayPort;
730 case TRANS_DDI_MODE_SELECT_DP_MST:
731 /* if the transcoder is in MST state then
732 * connector isn't connected */
736 case TRANS_DDI_MODE_SELECT_FDI_OR_128B132B:
737 if (HAS_DP20(dev_priv))
742 ret = type == DRM_MODE_CONNECTOR_VGA;
751 intel_display_power_put(dev_priv, encoder->power_domain, wakeref);
756 static void intel_ddi_get_encoder_pipes(struct intel_encoder *encoder,
757 u8 *pipe_mask, bool *is_dp_mst)
759 struct drm_device *dev = encoder->base.dev;
760 struct drm_i915_private *dev_priv = to_i915(dev);
761 enum port port = encoder->port;
762 intel_wakeref_t wakeref;
770 wakeref = intel_display_power_get_if_enabled(dev_priv,
771 encoder->power_domain);
775 tmp = intel_de_read(dev_priv, DDI_BUF_CTL(port));
776 if (!(tmp & DDI_BUF_CTL_ENABLE))
779 if (HAS_TRANSCODER(dev_priv, TRANSCODER_EDP) && port == PORT_A) {
780 tmp = intel_de_read(dev_priv,
781 TRANS_DDI_FUNC_CTL(TRANSCODER_EDP));
783 switch (tmp & TRANS_DDI_EDP_INPUT_MASK) {
785 MISSING_CASE(tmp & TRANS_DDI_EDP_INPUT_MASK);
787 case TRANS_DDI_EDP_INPUT_A_ON:
788 case TRANS_DDI_EDP_INPUT_A_ONOFF:
789 *pipe_mask = BIT(PIPE_A);
791 case TRANS_DDI_EDP_INPUT_B_ONOFF:
792 *pipe_mask = BIT(PIPE_B);
794 case TRANS_DDI_EDP_INPUT_C_ONOFF:
795 *pipe_mask = BIT(PIPE_C);
803 for_each_pipe(dev_priv, p) {
804 enum transcoder cpu_transcoder = (enum transcoder)p;
805 unsigned int port_mask, ddi_select;
806 intel_wakeref_t trans_wakeref;
808 trans_wakeref = intel_display_power_get_if_enabled(dev_priv,
809 POWER_DOMAIN_TRANSCODER(cpu_transcoder));
813 if (DISPLAY_VER(dev_priv) >= 12) {
814 port_mask = TGL_TRANS_DDI_PORT_MASK;
815 ddi_select = TGL_TRANS_DDI_SELECT_PORT(port);
817 port_mask = TRANS_DDI_PORT_MASK;
818 ddi_select = TRANS_DDI_SELECT_PORT(port);
821 tmp = intel_de_read(dev_priv,
822 TRANS_DDI_FUNC_CTL(cpu_transcoder));
823 intel_display_power_put(dev_priv, POWER_DOMAIN_TRANSCODER(cpu_transcoder),
826 if ((tmp & port_mask) != ddi_select)
829 if ((tmp & TRANS_DDI_MODE_SELECT_MASK) == TRANS_DDI_MODE_SELECT_DP_MST ||
830 (HAS_DP20(dev_priv) &&
831 (tmp & TRANS_DDI_MODE_SELECT_MASK) == TRANS_DDI_MODE_SELECT_FDI_OR_128B132B))
832 mst_pipe_mask |= BIT(p);
834 *pipe_mask |= BIT(p);
838 drm_dbg_kms(&dev_priv->drm,
839 "No pipe for [ENCODER:%d:%s] found\n",
840 encoder->base.base.id, encoder->base.name);
842 if (!mst_pipe_mask && hweight8(*pipe_mask) > 1) {
843 drm_dbg_kms(&dev_priv->drm,
844 "Multiple pipes for [ENCODER:%d:%s] (pipe_mask %02x)\n",
845 encoder->base.base.id, encoder->base.name,
847 *pipe_mask = BIT(ffs(*pipe_mask) - 1);
850 if (mst_pipe_mask && mst_pipe_mask != *pipe_mask)
851 drm_dbg_kms(&dev_priv->drm,
852 "Conflicting MST and non-MST state for [ENCODER:%d:%s] (pipe_mask %02x mst_pipe_mask %02x)\n",
853 encoder->base.base.id, encoder->base.name,
854 *pipe_mask, mst_pipe_mask);
856 *is_dp_mst = mst_pipe_mask;
859 if (*pipe_mask && (IS_GEMINILAKE(dev_priv) || IS_BROXTON(dev_priv))) {
860 tmp = intel_de_read(dev_priv, BXT_PHY_CTL(port));
861 if ((tmp & (BXT_PHY_CMNLANE_POWERDOWN_ACK |
862 BXT_PHY_LANE_POWERDOWN_ACK |
863 BXT_PHY_LANE_ENABLED)) != BXT_PHY_LANE_ENABLED)
864 drm_err(&dev_priv->drm,
865 "[ENCODER:%d:%s] enabled but PHY powered down? (PHY_CTL %08x)\n",
866 encoder->base.base.id, encoder->base.name, tmp);
869 intel_display_power_put(dev_priv, encoder->power_domain, wakeref);
872 bool intel_ddi_get_hw_state(struct intel_encoder *encoder,
878 intel_ddi_get_encoder_pipes(encoder, &pipe_mask, &is_mst);
880 if (is_mst || !pipe_mask)
883 *pipe = ffs(pipe_mask) - 1;
888 static enum intel_display_power_domain
889 intel_ddi_main_link_aux_domain(struct intel_digital_port *dig_port,
890 const struct intel_crtc_state *crtc_state)
892 struct drm_i915_private *i915 = to_i915(dig_port->base.base.dev);
893 enum phy phy = intel_port_to_phy(i915, dig_port->base.port);
896 * ICL+ HW requires corresponding AUX IOs to be powered up for PSR with
897 * DC states enabled at the same time, while for driver initiated AUX
898 * transfers we need the same AUX IOs to be powered but with DC states
899 * disabled. Accordingly use the AUX_IO_<port> power domain here which
900 * leaves DC states enabled.
902 * Before MTL TypeC PHYs (in all TypeC modes and both DP/HDMI) also require
903 * AUX IO to be enabled, but all these require DC_OFF to be enabled as
904 * well, so we can acquire a wider AUX_<port> power domain reference
905 * instead of a specific AUX_IO_<port> reference without powering up any
908 if (intel_encoder_can_psr(&dig_port->base))
909 return intel_display_power_aux_io_domain(i915, dig_port->aux_ch);
910 else if (DISPLAY_VER(i915) < 14 &&
911 (intel_crtc_has_dp_encoder(crtc_state) ||
912 intel_phy_is_tc(i915, phy)))
913 return intel_aux_power_domain(dig_port);
915 return POWER_DOMAIN_INVALID;
919 main_link_aux_power_domain_get(struct intel_digital_port *dig_port,
920 const struct intel_crtc_state *crtc_state)
922 struct drm_i915_private *i915 = to_i915(dig_port->base.base.dev);
923 enum intel_display_power_domain domain =
924 intel_ddi_main_link_aux_domain(dig_port, crtc_state);
926 drm_WARN_ON(&i915->drm, dig_port->aux_wakeref);
928 if (domain == POWER_DOMAIN_INVALID)
931 dig_port->aux_wakeref = intel_display_power_get(i915, domain);
935 main_link_aux_power_domain_put(struct intel_digital_port *dig_port,
936 const struct intel_crtc_state *crtc_state)
938 struct drm_i915_private *i915 = to_i915(dig_port->base.base.dev);
939 enum intel_display_power_domain domain =
940 intel_ddi_main_link_aux_domain(dig_port, crtc_state);
943 wf = fetch_and_zero(&dig_port->aux_wakeref);
947 intel_display_power_put(i915, domain, wf);
950 static void intel_ddi_get_power_domains(struct intel_encoder *encoder,
951 struct intel_crtc_state *crtc_state)
953 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
954 struct intel_digital_port *dig_port;
957 * TODO: Add support for MST encoders. Atm, the following should never
958 * happen since fake-MST encoders don't set their get_power_domains()
961 if (drm_WARN_ON(&dev_priv->drm,
962 intel_crtc_has_type(crtc_state, INTEL_OUTPUT_DP_MST)))
965 dig_port = enc_to_dig_port(encoder);
967 if (!intel_tc_port_in_tbt_alt_mode(dig_port)) {
968 drm_WARN_ON(&dev_priv->drm, dig_port->ddi_io_wakeref);
969 dig_port->ddi_io_wakeref = intel_display_power_get(dev_priv,
970 dig_port->ddi_io_power_domain);
973 main_link_aux_power_domain_get(dig_port, crtc_state);
976 void intel_ddi_enable_transcoder_clock(struct intel_encoder *encoder,
977 const struct intel_crtc_state *crtc_state)
979 struct intel_crtc *crtc = to_intel_crtc(crtc_state->uapi.crtc);
980 struct drm_i915_private *dev_priv = to_i915(crtc->base.dev);
981 enum transcoder cpu_transcoder = crtc_state->cpu_transcoder;
982 enum phy phy = intel_port_to_phy(dev_priv, encoder->port);
985 if (cpu_transcoder == TRANSCODER_EDP)
988 if (DISPLAY_VER(dev_priv) >= 13)
989 val = TGL_TRANS_CLK_SEL_PORT(phy);
990 else if (DISPLAY_VER(dev_priv) >= 12)
991 val = TGL_TRANS_CLK_SEL_PORT(encoder->port);
993 val = TRANS_CLK_SEL_PORT(encoder->port);
995 intel_de_write(dev_priv, TRANS_CLK_SEL(cpu_transcoder), val);
998 void intel_ddi_disable_transcoder_clock(const struct intel_crtc_state *crtc_state)
1000 struct drm_i915_private *dev_priv = to_i915(crtc_state->uapi.crtc->dev);
1001 enum transcoder cpu_transcoder = crtc_state->cpu_transcoder;
1004 if (cpu_transcoder == TRANSCODER_EDP)
1007 if (DISPLAY_VER(dev_priv) >= 12)
1008 val = TGL_TRANS_CLK_SEL_DISABLED;
1010 val = TRANS_CLK_SEL_DISABLED;
1012 intel_de_write(dev_priv, TRANS_CLK_SEL(cpu_transcoder), val);
1015 static void _skl_ddi_set_iboost(struct drm_i915_private *dev_priv,
1016 enum port port, u8 iboost)
1020 tmp = intel_de_read(dev_priv, DISPIO_CR_TX_BMU_CR0);
1021 tmp &= ~(BALANCE_LEG_MASK(port) | BALANCE_LEG_DISABLE(port));
1023 tmp |= iboost << BALANCE_LEG_SHIFT(port);
1025 tmp |= BALANCE_LEG_DISABLE(port);
1026 intel_de_write(dev_priv, DISPIO_CR_TX_BMU_CR0, tmp);
1029 static void skl_ddi_set_iboost(struct intel_encoder *encoder,
1030 const struct intel_crtc_state *crtc_state,
1033 struct intel_digital_port *dig_port = enc_to_dig_port(encoder);
1034 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
1037 if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_HDMI))
1038 iboost = intel_bios_hdmi_boost_level(encoder->devdata);
1040 iboost = intel_bios_dp_boost_level(encoder->devdata);
1043 const struct intel_ddi_buf_trans *trans;
1046 trans = encoder->get_buf_trans(encoder, crtc_state, &n_entries);
1047 if (drm_WARN_ON_ONCE(&dev_priv->drm, !trans))
1050 iboost = trans->entries[level].hsw.i_boost;
1053 /* Make sure that the requested I_boost is valid */
1054 if (iboost && iboost != 0x1 && iboost != 0x3 && iboost != 0x7) {
1055 drm_err(&dev_priv->drm, "Invalid I_boost value %u\n", iboost);
1059 _skl_ddi_set_iboost(dev_priv, encoder->port, iboost);
1061 if (encoder->port == PORT_A && dig_port->max_lanes == 4)
1062 _skl_ddi_set_iboost(dev_priv, PORT_E, iboost);
1065 static u8 intel_ddi_dp_voltage_max(struct intel_dp *intel_dp,
1066 const struct intel_crtc_state *crtc_state)
1068 struct intel_encoder *encoder = &dp_to_dig_port(intel_dp)->base;
1069 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
1072 encoder->get_buf_trans(encoder, crtc_state, &n_entries);
1074 if (drm_WARN_ON(&dev_priv->drm, n_entries < 1))
1076 if (drm_WARN_ON(&dev_priv->drm,
1077 n_entries > ARRAY_SIZE(index_to_dp_signal_levels)))
1078 n_entries = ARRAY_SIZE(index_to_dp_signal_levels);
1080 return index_to_dp_signal_levels[n_entries - 1] &
1081 DP_TRAIN_VOLTAGE_SWING_MASK;
1085 * We assume that the full set of pre-emphasis values can be
1086 * used on all DDI platforms. Should that change we need to
1087 * rethink this code.
1089 static u8 intel_ddi_dp_preemph_max(struct intel_dp *intel_dp)
1091 return DP_TRAIN_PRE_EMPH_LEVEL_3;
1094 static u32 icl_combo_phy_loadgen_select(const struct intel_crtc_state *crtc_state,
1097 if (crtc_state->port_clock > 600000)
1100 if (crtc_state->lane_count == 4)
1101 return lane >= 1 ? LOADGEN_SELECT : 0;
1103 return lane == 1 || lane == 2 ? LOADGEN_SELECT : 0;
1106 static void icl_ddi_combo_vswing_program(struct intel_encoder *encoder,
1107 const struct intel_crtc_state *crtc_state)
1109 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
1110 const struct intel_ddi_buf_trans *trans;
1111 enum phy phy = intel_port_to_phy(dev_priv, encoder->port);
1115 trans = encoder->get_buf_trans(encoder, crtc_state, &n_entries);
1116 if (drm_WARN_ON_ONCE(&dev_priv->drm, !trans))
1119 if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_EDP)) {
1120 struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
1122 val = EDP4K2K_MODE_OVRD_EN | EDP4K2K_MODE_OVRD_OPTIMIZED;
1123 intel_dp->hobl_active = is_hobl_buf_trans(trans);
1124 intel_de_rmw(dev_priv, ICL_PORT_CL_DW10(phy), val,
1125 intel_dp->hobl_active ? val : 0);
1128 /* Set PORT_TX_DW5 */
1129 val = intel_de_read(dev_priv, ICL_PORT_TX_DW5_LN(0, phy));
1130 val &= ~(SCALING_MODE_SEL_MASK | RTERM_SELECT_MASK |
1131 TAP2_DISABLE | TAP3_DISABLE);
1132 val |= SCALING_MODE_SEL(0x2);
1133 val |= RTERM_SELECT(0x6);
1134 val |= TAP3_DISABLE;
1135 intel_de_write(dev_priv, ICL_PORT_TX_DW5_GRP(phy), val);
1137 /* Program PORT_TX_DW2 */
1138 for (ln = 0; ln < 4; ln++) {
1139 int level = intel_ddi_level(encoder, crtc_state, ln);
1141 intel_de_rmw(dev_priv, ICL_PORT_TX_DW2_LN(ln, phy),
1142 SWING_SEL_UPPER_MASK | SWING_SEL_LOWER_MASK | RCOMP_SCALAR_MASK,
1143 SWING_SEL_UPPER(trans->entries[level].icl.dw2_swing_sel) |
1144 SWING_SEL_LOWER(trans->entries[level].icl.dw2_swing_sel) |
1145 RCOMP_SCALAR(0x98));
1148 /* Program PORT_TX_DW4 */
1149 /* We cannot write to GRP. It would overwrite individual loadgen. */
1150 for (ln = 0; ln < 4; ln++) {
1151 int level = intel_ddi_level(encoder, crtc_state, ln);
1153 intel_de_rmw(dev_priv, ICL_PORT_TX_DW4_LN(ln, phy),
1154 POST_CURSOR_1_MASK | POST_CURSOR_2_MASK | CURSOR_COEFF_MASK,
1155 POST_CURSOR_1(trans->entries[level].icl.dw4_post_cursor_1) |
1156 POST_CURSOR_2(trans->entries[level].icl.dw4_post_cursor_2) |
1157 CURSOR_COEFF(trans->entries[level].icl.dw4_cursor_coeff));
1160 /* Program PORT_TX_DW7 */
1161 for (ln = 0; ln < 4; ln++) {
1162 int level = intel_ddi_level(encoder, crtc_state, ln);
1164 intel_de_rmw(dev_priv, ICL_PORT_TX_DW7_LN(ln, phy),
1166 N_SCALAR(trans->entries[level].icl.dw7_n_scalar));
1170 static void icl_combo_phy_set_signal_levels(struct intel_encoder *encoder,
1171 const struct intel_crtc_state *crtc_state)
1173 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
1174 enum phy phy = intel_port_to_phy(dev_priv, encoder->port);
1179 * 1. If port type is eDP or DP,
1180 * set PORT_PCS_DW1 cmnkeeper_enable to 1b,
1183 val = intel_de_read(dev_priv, ICL_PORT_PCS_DW1_LN(0, phy));
1184 if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_HDMI))
1185 val &= ~COMMON_KEEPER_EN;
1187 val |= COMMON_KEEPER_EN;
1188 intel_de_write(dev_priv, ICL_PORT_PCS_DW1_GRP(phy), val);
1190 /* 2. Program loadgen select */
1192 * Program PORT_TX_DW4 depending on Bit rate and used lanes
1193 * <= 6 GHz and 4 lanes (LN0=0, LN1=1, LN2=1, LN3=1)
1194 * <= 6 GHz and 1,2 lanes (LN0=0, LN1=1, LN2=1, LN3=0)
1195 * > 6 GHz (LN0=0, LN1=0, LN2=0, LN3=0)
1197 for (ln = 0; ln < 4; ln++) {
1198 intel_de_rmw(dev_priv, ICL_PORT_TX_DW4_LN(ln, phy),
1200 icl_combo_phy_loadgen_select(crtc_state, ln));
1203 /* 3. Set PORT_CL_DW5 SUS Clock Config to 11b */
1204 intel_de_rmw(dev_priv, ICL_PORT_CL_DW5(phy),
1205 0, SUS_CLOCK_CONFIG);
1207 /* 4. Clear training enable to change swing values */
1208 val = intel_de_read(dev_priv, ICL_PORT_TX_DW5_LN(0, phy));
1209 val &= ~TX_TRAINING_EN;
1210 intel_de_write(dev_priv, ICL_PORT_TX_DW5_GRP(phy), val);
1212 /* 5. Program swing and de-emphasis */
1213 icl_ddi_combo_vswing_program(encoder, crtc_state);
1215 /* 6. Set training enable to trigger update */
1216 val = intel_de_read(dev_priv, ICL_PORT_TX_DW5_LN(0, phy));
1217 val |= TX_TRAINING_EN;
1218 intel_de_write(dev_priv, ICL_PORT_TX_DW5_GRP(phy), val);
1221 static void icl_mg_phy_set_signal_levels(struct intel_encoder *encoder,
1222 const struct intel_crtc_state *crtc_state)
1224 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
1225 enum tc_port tc_port = intel_port_to_tc(dev_priv, encoder->port);
1226 const struct intel_ddi_buf_trans *trans;
1229 if (intel_tc_port_in_tbt_alt_mode(enc_to_dig_port(encoder)))
1232 trans = encoder->get_buf_trans(encoder, crtc_state, &n_entries);
1233 if (drm_WARN_ON_ONCE(&dev_priv->drm, !trans))
1236 for (ln = 0; ln < 2; ln++) {
1237 intel_de_rmw(dev_priv, MG_TX1_LINK_PARAMS(ln, tc_port),
1239 intel_de_rmw(dev_priv, MG_TX2_LINK_PARAMS(ln, tc_port),
1243 /* Program MG_TX_SWINGCTRL with values from vswing table */
1244 for (ln = 0; ln < 2; ln++) {
1247 level = intel_ddi_level(encoder, crtc_state, 2*ln+0);
1249 intel_de_rmw(dev_priv, MG_TX1_SWINGCTRL(ln, tc_port),
1250 CRI_TXDEEMPH_OVERRIDE_17_12_MASK,
1251 CRI_TXDEEMPH_OVERRIDE_17_12(trans->entries[level].mg.cri_txdeemph_override_17_12));
1253 level = intel_ddi_level(encoder, crtc_state, 2*ln+1);
1255 intel_de_rmw(dev_priv, MG_TX2_SWINGCTRL(ln, tc_port),
1256 CRI_TXDEEMPH_OVERRIDE_17_12_MASK,
1257 CRI_TXDEEMPH_OVERRIDE_17_12(trans->entries[level].mg.cri_txdeemph_override_17_12));
1260 /* Program MG_TX_DRVCTRL with values from vswing table */
1261 for (ln = 0; ln < 2; ln++) {
1264 level = intel_ddi_level(encoder, crtc_state, 2*ln+0);
1266 intel_de_rmw(dev_priv, MG_TX1_DRVCTRL(ln, tc_port),
1267 CRI_TXDEEMPH_OVERRIDE_11_6_MASK |
1268 CRI_TXDEEMPH_OVERRIDE_5_0_MASK,
1269 CRI_TXDEEMPH_OVERRIDE_11_6(trans->entries[level].mg.cri_txdeemph_override_11_6) |
1270 CRI_TXDEEMPH_OVERRIDE_5_0(trans->entries[level].mg.cri_txdeemph_override_5_0) |
1271 CRI_TXDEEMPH_OVERRIDE_EN);
1273 level = intel_ddi_level(encoder, crtc_state, 2*ln+1);
1275 intel_de_rmw(dev_priv, MG_TX2_DRVCTRL(ln, tc_port),
1276 CRI_TXDEEMPH_OVERRIDE_11_6_MASK |
1277 CRI_TXDEEMPH_OVERRIDE_5_0_MASK,
1278 CRI_TXDEEMPH_OVERRIDE_11_6(trans->entries[level].mg.cri_txdeemph_override_11_6) |
1279 CRI_TXDEEMPH_OVERRIDE_5_0(trans->entries[level].mg.cri_txdeemph_override_5_0) |
1280 CRI_TXDEEMPH_OVERRIDE_EN);
1282 /* FIXME: Program CRI_LOADGEN_SEL after the spec is updated */
1286 * Program MG_CLKHUB<LN, port being used> with value from frequency table
1287 * In case of Legacy mode on MG PHY, both TX1 and TX2 enabled so use the
1288 * values from table for which TX1 and TX2 enabled.
1290 for (ln = 0; ln < 2; ln++) {
1291 intel_de_rmw(dev_priv, MG_CLKHUB(ln, tc_port),
1292 CFG_LOW_RATE_LKREN_EN,
1293 crtc_state->port_clock < 300000 ? CFG_LOW_RATE_LKREN_EN : 0);
1296 /* Program the MG_TX_DCC<LN, port being used> based on the link frequency */
1297 for (ln = 0; ln < 2; ln++) {
1298 intel_de_rmw(dev_priv, MG_TX1_DCC(ln, tc_port),
1299 CFG_AMI_CK_DIV_OVERRIDE_VAL_MASK |
1300 CFG_AMI_CK_DIV_OVERRIDE_EN,
1301 crtc_state->port_clock > 500000 ?
1302 CFG_AMI_CK_DIV_OVERRIDE_VAL(1) |
1303 CFG_AMI_CK_DIV_OVERRIDE_EN : 0);
1305 intel_de_rmw(dev_priv, MG_TX2_DCC(ln, tc_port),
1306 CFG_AMI_CK_DIV_OVERRIDE_VAL_MASK |
1307 CFG_AMI_CK_DIV_OVERRIDE_EN,
1308 crtc_state->port_clock > 500000 ?
1309 CFG_AMI_CK_DIV_OVERRIDE_VAL(1) |
1310 CFG_AMI_CK_DIV_OVERRIDE_EN : 0);
1313 /* Program MG_TX_PISO_READLOAD with values from vswing table */
1314 for (ln = 0; ln < 2; ln++) {
1315 intel_de_rmw(dev_priv, MG_TX1_PISO_READLOAD(ln, tc_port),
1317 intel_de_rmw(dev_priv, MG_TX2_PISO_READLOAD(ln, tc_port),
1322 static void tgl_dkl_phy_set_signal_levels(struct intel_encoder *encoder,
1323 const struct intel_crtc_state *crtc_state)
1325 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
1326 enum tc_port tc_port = intel_port_to_tc(dev_priv, encoder->port);
1327 const struct intel_ddi_buf_trans *trans;
1330 if (intel_tc_port_in_tbt_alt_mode(enc_to_dig_port(encoder)))
1333 trans = encoder->get_buf_trans(encoder, crtc_state, &n_entries);
1334 if (drm_WARN_ON_ONCE(&dev_priv->drm, !trans))
1337 for (ln = 0; ln < 2; ln++) {
1340 intel_dkl_phy_write(dev_priv, DKL_TX_PMD_LANE_SUS(tc_port, ln), 0);
1342 level = intel_ddi_level(encoder, crtc_state, 2*ln+0);
1344 intel_dkl_phy_rmw(dev_priv, DKL_TX_DPCNTL0(tc_port, ln),
1345 DKL_TX_PRESHOOT_COEFF_MASK |
1346 DKL_TX_DE_EMPAHSIS_COEFF_MASK |
1347 DKL_TX_VSWING_CONTROL_MASK,
1348 DKL_TX_PRESHOOT_COEFF(trans->entries[level].dkl.preshoot) |
1349 DKL_TX_DE_EMPHASIS_COEFF(trans->entries[level].dkl.de_emphasis) |
1350 DKL_TX_VSWING_CONTROL(trans->entries[level].dkl.vswing));
1352 level = intel_ddi_level(encoder, crtc_state, 2*ln+1);
1354 intel_dkl_phy_rmw(dev_priv, DKL_TX_DPCNTL1(tc_port, ln),
1355 DKL_TX_PRESHOOT_COEFF_MASK |
1356 DKL_TX_DE_EMPAHSIS_COEFF_MASK |
1357 DKL_TX_VSWING_CONTROL_MASK,
1358 DKL_TX_PRESHOOT_COEFF(trans->entries[level].dkl.preshoot) |
1359 DKL_TX_DE_EMPHASIS_COEFF(trans->entries[level].dkl.de_emphasis) |
1360 DKL_TX_VSWING_CONTROL(trans->entries[level].dkl.vswing));
1362 intel_dkl_phy_rmw(dev_priv, DKL_TX_DPCNTL2(tc_port, ln),
1363 DKL_TX_DP20BITMODE, 0);
1365 if (IS_ALDERLAKE_P(dev_priv)) {
1368 if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_HDMI)) {
1370 val = DKL_TX_DPCNTL2_CFG_LOADGENSELECT_TX1(0);
1371 val |= DKL_TX_DPCNTL2_CFG_LOADGENSELECT_TX2(2);
1373 val = DKL_TX_DPCNTL2_CFG_LOADGENSELECT_TX1(3);
1374 val |= DKL_TX_DPCNTL2_CFG_LOADGENSELECT_TX2(3);
1377 val = DKL_TX_DPCNTL2_CFG_LOADGENSELECT_TX1(0);
1378 val |= DKL_TX_DPCNTL2_CFG_LOADGENSELECT_TX2(0);
1381 intel_dkl_phy_rmw(dev_priv, DKL_TX_DPCNTL2(tc_port, ln),
1382 DKL_TX_DPCNTL2_CFG_LOADGENSELECT_TX1_MASK |
1383 DKL_TX_DPCNTL2_CFG_LOADGENSELECT_TX2_MASK,
1389 static int translate_signal_level(struct intel_dp *intel_dp,
1392 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
1395 for (i = 0; i < ARRAY_SIZE(index_to_dp_signal_levels); i++) {
1396 if (index_to_dp_signal_levels[i] == signal_levels)
1400 drm_WARN(&i915->drm, 1,
1401 "Unsupported voltage swing/pre-emphasis level: 0x%x\n",
1407 static int intel_ddi_dp_level(struct intel_dp *intel_dp,
1408 const struct intel_crtc_state *crtc_state,
1411 u8 train_set = intel_dp->train_set[lane];
1413 if (intel_dp_is_uhbr(crtc_state)) {
1414 return train_set & DP_TX_FFE_PRESET_VALUE_MASK;
1416 u8 signal_levels = train_set & (DP_TRAIN_VOLTAGE_SWING_MASK |
1417 DP_TRAIN_PRE_EMPHASIS_MASK);
1419 return translate_signal_level(intel_dp, signal_levels);
1423 int intel_ddi_level(struct intel_encoder *encoder,
1424 const struct intel_crtc_state *crtc_state,
1427 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
1428 const struct intel_ddi_buf_trans *trans;
1429 int level, n_entries;
1431 trans = encoder->get_buf_trans(encoder, crtc_state, &n_entries);
1432 if (drm_WARN_ON_ONCE(&i915->drm, !trans))
1435 if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_HDMI))
1436 level = intel_ddi_hdmi_level(encoder, trans);
1438 level = intel_ddi_dp_level(enc_to_intel_dp(encoder), crtc_state,
1441 if (drm_WARN_ON_ONCE(&i915->drm, level >= n_entries))
1442 level = n_entries - 1;
1448 hsw_set_signal_levels(struct intel_encoder *encoder,
1449 const struct intel_crtc_state *crtc_state)
1451 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
1452 struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
1453 int level = intel_ddi_level(encoder, crtc_state, 0);
1454 enum port port = encoder->port;
1457 if (has_iboost(dev_priv))
1458 skl_ddi_set_iboost(encoder, crtc_state, level);
1460 /* HDMI ignores the rest */
1461 if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_HDMI))
1464 signal_levels = DDI_BUF_TRANS_SELECT(level);
1466 drm_dbg_kms(&dev_priv->drm, "Using signal levels %08x\n",
1469 intel_dp->DP &= ~DDI_BUF_EMP_MASK;
1470 intel_dp->DP |= signal_levels;
1472 intel_de_write(dev_priv, DDI_BUF_CTL(port), intel_dp->DP);
1473 intel_de_posting_read(dev_priv, DDI_BUF_CTL(port));
1476 static void _icl_ddi_enable_clock(struct drm_i915_private *i915, i915_reg_t reg,
1477 u32 clk_sel_mask, u32 clk_sel, u32 clk_off)
1479 mutex_lock(&i915->display.dpll.lock);
1481 intel_de_rmw(i915, reg, clk_sel_mask, clk_sel);
1484 * "This step and the step before must be
1485 * done with separate register writes."
1487 intel_de_rmw(i915, reg, clk_off, 0);
1489 mutex_unlock(&i915->display.dpll.lock);
1492 static void _icl_ddi_disable_clock(struct drm_i915_private *i915, i915_reg_t reg,
1495 mutex_lock(&i915->display.dpll.lock);
1497 intel_de_rmw(i915, reg, 0, clk_off);
1499 mutex_unlock(&i915->display.dpll.lock);
1502 static bool _icl_ddi_is_clock_enabled(struct drm_i915_private *i915, i915_reg_t reg,
1505 return !(intel_de_read(i915, reg) & clk_off);
1508 static struct intel_shared_dpll *
1509 _icl_ddi_get_pll(struct drm_i915_private *i915, i915_reg_t reg,
1510 u32 clk_sel_mask, u32 clk_sel_shift)
1512 enum intel_dpll_id id;
1514 id = (intel_de_read(i915, reg) & clk_sel_mask) >> clk_sel_shift;
1516 return intel_get_shared_dpll_by_id(i915, id);
1519 static void adls_ddi_enable_clock(struct intel_encoder *encoder,
1520 const struct intel_crtc_state *crtc_state)
1522 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
1523 const struct intel_shared_dpll *pll = crtc_state->shared_dpll;
1524 enum phy phy = intel_port_to_phy(i915, encoder->port);
1526 if (drm_WARN_ON(&i915->drm, !pll))
1529 _icl_ddi_enable_clock(i915, ADLS_DPCLKA_CFGCR(phy),
1530 ADLS_DPCLKA_CFGCR_DDI_CLK_SEL_MASK(phy),
1531 pll->info->id << ADLS_DPCLKA_CFGCR_DDI_SHIFT(phy),
1532 ICL_DPCLKA_CFGCR0_DDI_CLK_OFF(phy));
1535 static void adls_ddi_disable_clock(struct intel_encoder *encoder)
1537 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
1538 enum phy phy = intel_port_to_phy(i915, encoder->port);
1540 _icl_ddi_disable_clock(i915, ADLS_DPCLKA_CFGCR(phy),
1541 ICL_DPCLKA_CFGCR0_DDI_CLK_OFF(phy));
1544 static bool adls_ddi_is_clock_enabled(struct intel_encoder *encoder)
1546 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
1547 enum phy phy = intel_port_to_phy(i915, encoder->port);
1549 return _icl_ddi_is_clock_enabled(i915, ADLS_DPCLKA_CFGCR(phy),
1550 ICL_DPCLKA_CFGCR0_DDI_CLK_OFF(phy));
1553 static struct intel_shared_dpll *adls_ddi_get_pll(struct intel_encoder *encoder)
1555 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
1556 enum phy phy = intel_port_to_phy(i915, encoder->port);
1558 return _icl_ddi_get_pll(i915, ADLS_DPCLKA_CFGCR(phy),
1559 ADLS_DPCLKA_CFGCR_DDI_CLK_SEL_MASK(phy),
1560 ADLS_DPCLKA_CFGCR_DDI_SHIFT(phy));
1563 static void rkl_ddi_enable_clock(struct intel_encoder *encoder,
1564 const struct intel_crtc_state *crtc_state)
1566 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
1567 const struct intel_shared_dpll *pll = crtc_state->shared_dpll;
1568 enum phy phy = intel_port_to_phy(i915, encoder->port);
1570 if (drm_WARN_ON(&i915->drm, !pll))
1573 _icl_ddi_enable_clock(i915, ICL_DPCLKA_CFGCR0,
1574 RKL_DPCLKA_CFGCR0_DDI_CLK_SEL_MASK(phy),
1575 RKL_DPCLKA_CFGCR0_DDI_CLK_SEL(pll->info->id, phy),
1576 RKL_DPCLKA_CFGCR0_DDI_CLK_OFF(phy));
1579 static void rkl_ddi_disable_clock(struct intel_encoder *encoder)
1581 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
1582 enum phy phy = intel_port_to_phy(i915, encoder->port);
1584 _icl_ddi_disable_clock(i915, ICL_DPCLKA_CFGCR0,
1585 RKL_DPCLKA_CFGCR0_DDI_CLK_OFF(phy));
1588 static bool rkl_ddi_is_clock_enabled(struct intel_encoder *encoder)
1590 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
1591 enum phy phy = intel_port_to_phy(i915, encoder->port);
1593 return _icl_ddi_is_clock_enabled(i915, ICL_DPCLKA_CFGCR0,
1594 RKL_DPCLKA_CFGCR0_DDI_CLK_OFF(phy));
1597 static struct intel_shared_dpll *rkl_ddi_get_pll(struct intel_encoder *encoder)
1599 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
1600 enum phy phy = intel_port_to_phy(i915, encoder->port);
1602 return _icl_ddi_get_pll(i915, ICL_DPCLKA_CFGCR0,
1603 RKL_DPCLKA_CFGCR0_DDI_CLK_SEL_MASK(phy),
1604 RKL_DPCLKA_CFGCR0_DDI_CLK_SEL_SHIFT(phy));
1607 static void dg1_ddi_enable_clock(struct intel_encoder *encoder,
1608 const struct intel_crtc_state *crtc_state)
1610 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
1611 const struct intel_shared_dpll *pll = crtc_state->shared_dpll;
1612 enum phy phy = intel_port_to_phy(i915, encoder->port);
1614 if (drm_WARN_ON(&i915->drm, !pll))
1618 * If we fail this, something went very wrong: first 2 PLLs should be
1619 * used by first 2 phys and last 2 PLLs by last phys
1621 if (drm_WARN_ON(&i915->drm,
1622 (pll->info->id < DPLL_ID_DG1_DPLL2 && phy >= PHY_C) ||
1623 (pll->info->id >= DPLL_ID_DG1_DPLL2 && phy < PHY_C)))
1626 _icl_ddi_enable_clock(i915, DG1_DPCLKA_CFGCR0(phy),
1627 DG1_DPCLKA_CFGCR0_DDI_CLK_SEL_MASK(phy),
1628 DG1_DPCLKA_CFGCR0_DDI_CLK_SEL(pll->info->id, phy),
1629 DG1_DPCLKA_CFGCR0_DDI_CLK_OFF(phy));
1632 static void dg1_ddi_disable_clock(struct intel_encoder *encoder)
1634 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
1635 enum phy phy = intel_port_to_phy(i915, encoder->port);
1637 _icl_ddi_disable_clock(i915, DG1_DPCLKA_CFGCR0(phy),
1638 DG1_DPCLKA_CFGCR0_DDI_CLK_OFF(phy));
1641 static bool dg1_ddi_is_clock_enabled(struct intel_encoder *encoder)
1643 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
1644 enum phy phy = intel_port_to_phy(i915, encoder->port);
1646 return _icl_ddi_is_clock_enabled(i915, DG1_DPCLKA_CFGCR0(phy),
1647 DG1_DPCLKA_CFGCR0_DDI_CLK_OFF(phy));
1650 static struct intel_shared_dpll *dg1_ddi_get_pll(struct intel_encoder *encoder)
1652 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
1653 enum phy phy = intel_port_to_phy(i915, encoder->port);
1654 enum intel_dpll_id id;
1657 val = intel_de_read(i915, DG1_DPCLKA_CFGCR0(phy));
1658 val &= DG1_DPCLKA_CFGCR0_DDI_CLK_SEL_MASK(phy);
1659 val >>= DG1_DPCLKA_CFGCR0_DDI_CLK_SEL_SHIFT(phy);
1663 * _DG1_DPCLKA0_CFGCR0 maps between DPLL 0 and 1 with one bit for phy A
1664 * and B while _DG1_DPCLKA1_CFGCR0 maps between DPLL 2 and 3 with one
1665 * bit for phy C and D.
1668 id += DPLL_ID_DG1_DPLL2;
1670 return intel_get_shared_dpll_by_id(i915, id);
1673 static void icl_ddi_combo_enable_clock(struct intel_encoder *encoder,
1674 const struct intel_crtc_state *crtc_state)
1676 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
1677 const struct intel_shared_dpll *pll = crtc_state->shared_dpll;
1678 enum phy phy = intel_port_to_phy(i915, encoder->port);
1680 if (drm_WARN_ON(&i915->drm, !pll))
1683 _icl_ddi_enable_clock(i915, ICL_DPCLKA_CFGCR0,
1684 ICL_DPCLKA_CFGCR0_DDI_CLK_SEL_MASK(phy),
1685 ICL_DPCLKA_CFGCR0_DDI_CLK_SEL(pll->info->id, phy),
1686 ICL_DPCLKA_CFGCR0_DDI_CLK_OFF(phy));
1689 static void icl_ddi_combo_disable_clock(struct intel_encoder *encoder)
1691 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
1692 enum phy phy = intel_port_to_phy(i915, encoder->port);
1694 _icl_ddi_disable_clock(i915, ICL_DPCLKA_CFGCR0,
1695 ICL_DPCLKA_CFGCR0_DDI_CLK_OFF(phy));
1698 static bool icl_ddi_combo_is_clock_enabled(struct intel_encoder *encoder)
1700 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
1701 enum phy phy = intel_port_to_phy(i915, encoder->port);
1703 return _icl_ddi_is_clock_enabled(i915, ICL_DPCLKA_CFGCR0,
1704 ICL_DPCLKA_CFGCR0_DDI_CLK_OFF(phy));
1707 struct intel_shared_dpll *icl_ddi_combo_get_pll(struct intel_encoder *encoder)
1709 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
1710 enum phy phy = intel_port_to_phy(i915, encoder->port);
1712 return _icl_ddi_get_pll(i915, ICL_DPCLKA_CFGCR0,
1713 ICL_DPCLKA_CFGCR0_DDI_CLK_SEL_MASK(phy),
1714 ICL_DPCLKA_CFGCR0_DDI_CLK_SEL_SHIFT(phy));
1717 static void jsl_ddi_tc_enable_clock(struct intel_encoder *encoder,
1718 const struct intel_crtc_state *crtc_state)
1720 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
1721 const struct intel_shared_dpll *pll = crtc_state->shared_dpll;
1722 enum port port = encoder->port;
1724 if (drm_WARN_ON(&i915->drm, !pll))
1728 * "For DDIC and DDID, program DDI_CLK_SEL to map the MG clock to the port.
1729 * MG does not exist, but the programming is required to ungate DDIC and DDID."
1731 intel_de_write(i915, DDI_CLK_SEL(port), DDI_CLK_SEL_MG);
1733 icl_ddi_combo_enable_clock(encoder, crtc_state);
1736 static void jsl_ddi_tc_disable_clock(struct intel_encoder *encoder)
1738 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
1739 enum port port = encoder->port;
1741 icl_ddi_combo_disable_clock(encoder);
1743 intel_de_write(i915, DDI_CLK_SEL(port), DDI_CLK_SEL_NONE);
1746 static bool jsl_ddi_tc_is_clock_enabled(struct intel_encoder *encoder)
1748 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
1749 enum port port = encoder->port;
1752 tmp = intel_de_read(i915, DDI_CLK_SEL(port));
1754 if ((tmp & DDI_CLK_SEL_MASK) == DDI_CLK_SEL_NONE)
1757 return icl_ddi_combo_is_clock_enabled(encoder);
1760 static void icl_ddi_tc_enable_clock(struct intel_encoder *encoder,
1761 const struct intel_crtc_state *crtc_state)
1763 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
1764 const struct intel_shared_dpll *pll = crtc_state->shared_dpll;
1765 enum tc_port tc_port = intel_port_to_tc(i915, encoder->port);
1766 enum port port = encoder->port;
1768 if (drm_WARN_ON(&i915->drm, !pll))
1771 intel_de_write(i915, DDI_CLK_SEL(port),
1772 icl_pll_to_ddi_clk_sel(encoder, crtc_state));
1774 mutex_lock(&i915->display.dpll.lock);
1776 intel_de_rmw(i915, ICL_DPCLKA_CFGCR0,
1777 ICL_DPCLKA_CFGCR0_TC_CLK_OFF(tc_port), 0);
1779 mutex_unlock(&i915->display.dpll.lock);
1782 static void icl_ddi_tc_disable_clock(struct intel_encoder *encoder)
1784 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
1785 enum tc_port tc_port = intel_port_to_tc(i915, encoder->port);
1786 enum port port = encoder->port;
1788 mutex_lock(&i915->display.dpll.lock);
1790 intel_de_rmw(i915, ICL_DPCLKA_CFGCR0,
1791 0, ICL_DPCLKA_CFGCR0_TC_CLK_OFF(tc_port));
1793 mutex_unlock(&i915->display.dpll.lock);
1795 intel_de_write(i915, DDI_CLK_SEL(port), DDI_CLK_SEL_NONE);
1798 static bool icl_ddi_tc_is_clock_enabled(struct intel_encoder *encoder)
1800 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
1801 enum tc_port tc_port = intel_port_to_tc(i915, encoder->port);
1802 enum port port = encoder->port;
1805 tmp = intel_de_read(i915, DDI_CLK_SEL(port));
1807 if ((tmp & DDI_CLK_SEL_MASK) == DDI_CLK_SEL_NONE)
1810 tmp = intel_de_read(i915, ICL_DPCLKA_CFGCR0);
1812 return !(tmp & ICL_DPCLKA_CFGCR0_TC_CLK_OFF(tc_port));
1815 static struct intel_shared_dpll *icl_ddi_tc_get_pll(struct intel_encoder *encoder)
1817 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
1818 enum tc_port tc_port = intel_port_to_tc(i915, encoder->port);
1819 enum port port = encoder->port;
1820 enum intel_dpll_id id;
1823 tmp = intel_de_read(i915, DDI_CLK_SEL(port));
1825 switch (tmp & DDI_CLK_SEL_MASK) {
1826 case DDI_CLK_SEL_TBT_162:
1827 case DDI_CLK_SEL_TBT_270:
1828 case DDI_CLK_SEL_TBT_540:
1829 case DDI_CLK_SEL_TBT_810:
1830 id = DPLL_ID_ICL_TBTPLL;
1832 case DDI_CLK_SEL_MG:
1833 id = icl_tc_port_to_pll_id(tc_port);
1838 case DDI_CLK_SEL_NONE:
1842 return intel_get_shared_dpll_by_id(i915, id);
1845 static struct intel_shared_dpll *bxt_ddi_get_pll(struct intel_encoder *encoder)
1847 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
1848 enum intel_dpll_id id;
1850 switch (encoder->port) {
1852 id = DPLL_ID_SKL_DPLL0;
1855 id = DPLL_ID_SKL_DPLL1;
1858 id = DPLL_ID_SKL_DPLL2;
1861 MISSING_CASE(encoder->port);
1865 return intel_get_shared_dpll_by_id(i915, id);
1868 static void skl_ddi_enable_clock(struct intel_encoder *encoder,
1869 const struct intel_crtc_state *crtc_state)
1871 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
1872 const struct intel_shared_dpll *pll = crtc_state->shared_dpll;
1873 enum port port = encoder->port;
1875 if (drm_WARN_ON(&i915->drm, !pll))
1878 mutex_lock(&i915->display.dpll.lock);
1880 intel_de_rmw(i915, DPLL_CTRL2,
1881 DPLL_CTRL2_DDI_CLK_OFF(port) |
1882 DPLL_CTRL2_DDI_CLK_SEL_MASK(port),
1883 DPLL_CTRL2_DDI_CLK_SEL(pll->info->id, port) |
1884 DPLL_CTRL2_DDI_SEL_OVERRIDE(port));
1886 mutex_unlock(&i915->display.dpll.lock);
1889 static void skl_ddi_disable_clock(struct intel_encoder *encoder)
1891 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
1892 enum port port = encoder->port;
1894 mutex_lock(&i915->display.dpll.lock);
1896 intel_de_rmw(i915, DPLL_CTRL2,
1897 0, DPLL_CTRL2_DDI_CLK_OFF(port));
1899 mutex_unlock(&i915->display.dpll.lock);
1902 static bool skl_ddi_is_clock_enabled(struct intel_encoder *encoder)
1904 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
1905 enum port port = encoder->port;
1908 * FIXME Not sure if the override affects both
1909 * the PLL selection and the CLK_OFF bit.
1911 return !(intel_de_read(i915, DPLL_CTRL2) & DPLL_CTRL2_DDI_CLK_OFF(port));
1914 static struct intel_shared_dpll *skl_ddi_get_pll(struct intel_encoder *encoder)
1916 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
1917 enum port port = encoder->port;
1918 enum intel_dpll_id id;
1921 tmp = intel_de_read(i915, DPLL_CTRL2);
1924 * FIXME Not sure if the override affects both
1925 * the PLL selection and the CLK_OFF bit.
1927 if ((tmp & DPLL_CTRL2_DDI_SEL_OVERRIDE(port)) == 0)
1930 id = (tmp & DPLL_CTRL2_DDI_CLK_SEL_MASK(port)) >>
1931 DPLL_CTRL2_DDI_CLK_SEL_SHIFT(port);
1933 return intel_get_shared_dpll_by_id(i915, id);
1936 void hsw_ddi_enable_clock(struct intel_encoder *encoder,
1937 const struct intel_crtc_state *crtc_state)
1939 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
1940 const struct intel_shared_dpll *pll = crtc_state->shared_dpll;
1941 enum port port = encoder->port;
1943 if (drm_WARN_ON(&i915->drm, !pll))
1946 intel_de_write(i915, PORT_CLK_SEL(port), hsw_pll_to_ddi_pll_sel(pll));
1949 void hsw_ddi_disable_clock(struct intel_encoder *encoder)
1951 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
1952 enum port port = encoder->port;
1954 intel_de_write(i915, PORT_CLK_SEL(port), PORT_CLK_SEL_NONE);
1957 bool hsw_ddi_is_clock_enabled(struct intel_encoder *encoder)
1959 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
1960 enum port port = encoder->port;
1962 return intel_de_read(i915, PORT_CLK_SEL(port)) != PORT_CLK_SEL_NONE;
1965 static struct intel_shared_dpll *hsw_ddi_get_pll(struct intel_encoder *encoder)
1967 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
1968 enum port port = encoder->port;
1969 enum intel_dpll_id id;
1972 tmp = intel_de_read(i915, PORT_CLK_SEL(port));
1974 switch (tmp & PORT_CLK_SEL_MASK) {
1975 case PORT_CLK_SEL_WRPLL1:
1976 id = DPLL_ID_WRPLL1;
1978 case PORT_CLK_SEL_WRPLL2:
1979 id = DPLL_ID_WRPLL2;
1981 case PORT_CLK_SEL_SPLL:
1984 case PORT_CLK_SEL_LCPLL_810:
1985 id = DPLL_ID_LCPLL_810;
1987 case PORT_CLK_SEL_LCPLL_1350:
1988 id = DPLL_ID_LCPLL_1350;
1990 case PORT_CLK_SEL_LCPLL_2700:
1991 id = DPLL_ID_LCPLL_2700;
1996 case PORT_CLK_SEL_NONE:
2000 return intel_get_shared_dpll_by_id(i915, id);
2003 void intel_ddi_enable_clock(struct intel_encoder *encoder,
2004 const struct intel_crtc_state *crtc_state)
2006 if (encoder->enable_clock)
2007 encoder->enable_clock(encoder, crtc_state);
2010 void intel_ddi_disable_clock(struct intel_encoder *encoder)
2012 if (encoder->disable_clock)
2013 encoder->disable_clock(encoder);
2016 void intel_ddi_sanitize_encoder_pll_mapping(struct intel_encoder *encoder)
2018 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
2020 bool ddi_clk_needed;
2023 * In case of DP MST, we sanitize the primary encoder only, not the
2026 if (encoder->type == INTEL_OUTPUT_DP_MST)
2029 if (!encoder->base.crtc && intel_encoder_is_dp(encoder)) {
2033 intel_ddi_get_encoder_pipes(encoder, &pipe_mask, &is_mst);
2035 * In the unlikely case that BIOS enables DP in MST mode, just
2036 * warn since our MST HW readout is incomplete.
2038 if (drm_WARN_ON(&i915->drm, is_mst))
2042 port_mask = BIT(encoder->port);
2043 ddi_clk_needed = encoder->base.crtc;
2045 if (encoder->type == INTEL_OUTPUT_DSI) {
2046 struct intel_encoder *other_encoder;
2048 port_mask = intel_dsi_encoder_ports(encoder);
2050 * Sanity check that we haven't incorrectly registered another
2051 * encoder using any of the ports of this DSI encoder.
2053 for_each_intel_encoder(&i915->drm, other_encoder) {
2054 if (other_encoder == encoder)
2057 if (drm_WARN_ON(&i915->drm,
2058 port_mask & BIT(other_encoder->port)))
2062 * For DSI we keep the ddi clocks gated
2063 * except during enable/disable sequence.
2065 ddi_clk_needed = false;
2068 if (ddi_clk_needed || !encoder->is_clock_enabled ||
2069 !encoder->is_clock_enabled(encoder))
2072 drm_notice(&i915->drm,
2073 "[ENCODER:%d:%s] is disabled/in DSI mode with an ungated DDI clock, gate it\n",
2074 encoder->base.base.id, encoder->base.name);
2076 encoder->disable_clock(encoder);
2080 icl_program_mg_dp_mode(struct intel_digital_port *dig_port,
2081 const struct intel_crtc_state *crtc_state)
2083 struct drm_i915_private *dev_priv = to_i915(dig_port->base.base.dev);
2084 enum tc_port tc_port = intel_port_to_tc(dev_priv, dig_port->base.port);
2085 enum phy phy = intel_port_to_phy(dev_priv, dig_port->base.port);
2086 u32 ln0, ln1, pin_assignment;
2089 if (!intel_phy_is_tc(dev_priv, phy) ||
2090 intel_tc_port_in_tbt_alt_mode(dig_port))
2093 if (DISPLAY_VER(dev_priv) >= 12) {
2094 ln0 = intel_dkl_phy_read(dev_priv, DKL_DP_MODE(tc_port, 0));
2095 ln1 = intel_dkl_phy_read(dev_priv, DKL_DP_MODE(tc_port, 1));
2097 ln0 = intel_de_read(dev_priv, MG_DP_MODE(0, tc_port));
2098 ln1 = intel_de_read(dev_priv, MG_DP_MODE(1, tc_port));
2101 ln0 &= ~(MG_DP_MODE_CFG_DP_X1_MODE | MG_DP_MODE_CFG_DP_X2_MODE);
2102 ln1 &= ~(MG_DP_MODE_CFG_DP_X1_MODE | MG_DP_MODE_CFG_DP_X2_MODE);
2105 pin_assignment = intel_tc_port_get_pin_assignment_mask(dig_port);
2106 width = crtc_state->lane_count;
2108 switch (pin_assignment) {
2110 drm_WARN_ON(&dev_priv->drm,
2111 !intel_tc_port_in_legacy_mode(dig_port));
2113 ln1 |= MG_DP_MODE_CFG_DP_X1_MODE;
2115 ln0 |= MG_DP_MODE_CFG_DP_X2_MODE;
2116 ln1 |= MG_DP_MODE_CFG_DP_X2_MODE;
2121 ln0 |= MG_DP_MODE_CFG_DP_X2_MODE;
2122 ln1 |= MG_DP_MODE_CFG_DP_X2_MODE;
2127 ln0 |= MG_DP_MODE_CFG_DP_X2_MODE;
2128 ln1 |= MG_DP_MODE_CFG_DP_X2_MODE;
2134 ln0 |= MG_DP_MODE_CFG_DP_X1_MODE;
2135 ln1 |= MG_DP_MODE_CFG_DP_X1_MODE;
2137 ln0 |= MG_DP_MODE_CFG_DP_X2_MODE;
2138 ln1 |= MG_DP_MODE_CFG_DP_X2_MODE;
2144 ln0 |= MG_DP_MODE_CFG_DP_X1_MODE;
2145 ln1 |= MG_DP_MODE_CFG_DP_X1_MODE;
2147 ln0 |= MG_DP_MODE_CFG_DP_X2_MODE;
2148 ln1 |= MG_DP_MODE_CFG_DP_X2_MODE;
2152 MISSING_CASE(pin_assignment);
2155 if (DISPLAY_VER(dev_priv) >= 12) {
2156 intel_dkl_phy_write(dev_priv, DKL_DP_MODE(tc_port, 0), ln0);
2157 intel_dkl_phy_write(dev_priv, DKL_DP_MODE(tc_port, 1), ln1);
2159 intel_de_write(dev_priv, MG_DP_MODE(0, tc_port), ln0);
2160 intel_de_write(dev_priv, MG_DP_MODE(1, tc_port), ln1);
2164 static enum transcoder
2165 tgl_dp_tp_transcoder(const struct intel_crtc_state *crtc_state)
2167 if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_DP_MST))
2168 return crtc_state->mst_master_transcoder;
2170 return crtc_state->cpu_transcoder;
2173 i915_reg_t dp_tp_ctl_reg(struct intel_encoder *encoder,
2174 const struct intel_crtc_state *crtc_state)
2176 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
2178 if (DISPLAY_VER(dev_priv) >= 12)
2179 return TGL_DP_TP_CTL(tgl_dp_tp_transcoder(crtc_state));
2181 return DP_TP_CTL(encoder->port);
2184 i915_reg_t dp_tp_status_reg(struct intel_encoder *encoder,
2185 const struct intel_crtc_state *crtc_state)
2187 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
2189 if (DISPLAY_VER(dev_priv) >= 12)
2190 return TGL_DP_TP_STATUS(tgl_dp_tp_transcoder(crtc_state));
2192 return DP_TP_STATUS(encoder->port);
2195 static void intel_dp_sink_set_msa_timing_par_ignore_state(struct intel_dp *intel_dp,
2196 const struct intel_crtc_state *crtc_state,
2199 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
2201 if (!crtc_state->vrr.enable)
2204 if (drm_dp_dpcd_writeb(&intel_dp->aux, DP_DOWNSPREAD_CTRL,
2205 enable ? DP_MSA_TIMING_PAR_IGNORE_EN : 0) <= 0)
2206 drm_dbg_kms(&i915->drm,
2207 "Failed to %s MSA_TIMING_PAR_IGNORE in the sink\n",
2208 str_enable_disable(enable));
2211 static void intel_dp_sink_set_fec_ready(struct intel_dp *intel_dp,
2212 const struct intel_crtc_state *crtc_state)
2214 struct drm_i915_private *i915 = dp_to_i915(intel_dp);
2216 if (!crtc_state->fec_enable)
2219 if (drm_dp_dpcd_writeb(&intel_dp->aux, DP_FEC_CONFIGURATION, DP_FEC_READY) <= 0)
2220 drm_dbg_kms(&i915->drm,
2221 "Failed to set FEC_READY in the sink\n");
2224 static void intel_ddi_enable_fec(struct intel_encoder *encoder,
2225 const struct intel_crtc_state *crtc_state)
2227 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
2228 struct intel_dp *intel_dp;
2230 if (!crtc_state->fec_enable)
2233 intel_dp = enc_to_intel_dp(encoder);
2234 intel_de_rmw(dev_priv, dp_tp_ctl_reg(encoder, crtc_state),
2235 0, DP_TP_CTL_FEC_ENABLE);
2238 static void intel_ddi_disable_fec_state(struct intel_encoder *encoder,
2239 const struct intel_crtc_state *crtc_state)
2241 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
2242 struct intel_dp *intel_dp;
2244 if (!crtc_state->fec_enable)
2247 intel_dp = enc_to_intel_dp(encoder);
2248 intel_de_rmw(dev_priv, dp_tp_ctl_reg(encoder, crtc_state),
2249 DP_TP_CTL_FEC_ENABLE, 0);
2250 intel_de_posting_read(dev_priv, dp_tp_ctl_reg(encoder, crtc_state));
2253 static void intel_ddi_power_up_lanes(struct intel_encoder *encoder,
2254 const struct intel_crtc_state *crtc_state)
2256 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
2257 struct intel_digital_port *dig_port = enc_to_dig_port(encoder);
2258 enum phy phy = intel_port_to_phy(i915, encoder->port);
2260 if (intel_phy_is_combo(i915, phy)) {
2261 bool lane_reversal =
2262 dig_port->saved_port_bits & DDI_BUF_PORT_REVERSAL;
2264 intel_combo_phy_power_up_lanes(i915, phy, false,
2265 crtc_state->lane_count,
2270 /* Splitter enable for eDP MSO is limited to certain pipes. */
2271 static u8 intel_ddi_splitter_pipe_mask(struct drm_i915_private *i915)
2273 if (IS_ALDERLAKE_P(i915))
2274 return BIT(PIPE_A) | BIT(PIPE_B);
2279 static void intel_ddi_mso_get_config(struct intel_encoder *encoder,
2280 struct intel_crtc_state *pipe_config)
2282 struct intel_crtc *crtc = to_intel_crtc(pipe_config->uapi.crtc);
2283 struct drm_i915_private *i915 = to_i915(crtc->base.dev);
2284 enum pipe pipe = crtc->pipe;
2290 dss1 = intel_de_read(i915, ICL_PIPE_DSS_CTL1(pipe));
2292 pipe_config->splitter.enable = dss1 & SPLITTER_ENABLE;
2293 if (!pipe_config->splitter.enable)
2296 if (drm_WARN_ON(&i915->drm, !(intel_ddi_splitter_pipe_mask(i915) & BIT(pipe)))) {
2297 pipe_config->splitter.enable = false;
2301 switch (dss1 & SPLITTER_CONFIGURATION_MASK) {
2303 drm_WARN(&i915->drm, true,
2304 "Invalid splitter configuration, dss1=0x%08x\n", dss1);
2306 case SPLITTER_CONFIGURATION_2_SEGMENT:
2307 pipe_config->splitter.link_count = 2;
2309 case SPLITTER_CONFIGURATION_4_SEGMENT:
2310 pipe_config->splitter.link_count = 4;
2314 pipe_config->splitter.pixel_overlap = REG_FIELD_GET(OVERLAP_PIXELS_MASK, dss1);
2317 static void intel_ddi_mso_configure(const struct intel_crtc_state *crtc_state)
2319 struct intel_crtc *crtc = to_intel_crtc(crtc_state->uapi.crtc);
2320 struct drm_i915_private *i915 = to_i915(crtc->base.dev);
2321 enum pipe pipe = crtc->pipe;
2327 if (crtc_state->splitter.enable) {
2328 dss1 |= SPLITTER_ENABLE;
2329 dss1 |= OVERLAP_PIXELS(crtc_state->splitter.pixel_overlap);
2330 if (crtc_state->splitter.link_count == 2)
2331 dss1 |= SPLITTER_CONFIGURATION_2_SEGMENT;
2333 dss1 |= SPLITTER_CONFIGURATION_4_SEGMENT;
2336 intel_de_rmw(i915, ICL_PIPE_DSS_CTL1(pipe),
2337 SPLITTER_ENABLE | SPLITTER_CONFIGURATION_MASK |
2338 OVERLAP_PIXELS_MASK, dss1);
2341 static u8 mtl_get_port_width(u8 lane_count)
2343 switch (lane_count) {
2353 MISSING_CASE(lane_count);
2359 mtl_ddi_enable_d2d(struct intel_encoder *encoder)
2361 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
2362 enum port port = encoder->port;
2364 intel_de_rmw(dev_priv, XELPDP_PORT_BUF_CTL1(port), 0,
2365 XELPDP_PORT_BUF_D2D_LINK_ENABLE);
2367 if (wait_for_us((intel_de_read(dev_priv, XELPDP_PORT_BUF_CTL1(port)) &
2368 XELPDP_PORT_BUF_D2D_LINK_STATE), 100)) {
2369 drm_err(&dev_priv->drm, "Timeout waiting for D2D Link enable for PORT_BUF_CTL %c\n",
2374 static void mtl_port_buf_ctl_program(struct intel_encoder *encoder,
2375 const struct intel_crtc_state *crtc_state)
2377 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
2378 struct intel_digital_port *dig_port = enc_to_dig_port(encoder);
2379 enum port port = encoder->port;
2382 val = intel_de_read(i915, XELPDP_PORT_BUF_CTL1(port));
2383 val &= ~XELPDP_PORT_WIDTH_MASK;
2384 val |= XELPDP_PORT_WIDTH(mtl_get_port_width(crtc_state->lane_count));
2386 val &= ~XELPDP_PORT_BUF_PORT_DATA_WIDTH_MASK;
2387 if (intel_dp_is_uhbr(crtc_state))
2388 val |= XELPDP_PORT_BUF_PORT_DATA_40BIT;
2390 val |= XELPDP_PORT_BUF_PORT_DATA_10BIT;
2392 if (dig_port->saved_port_bits & DDI_BUF_PORT_REVERSAL)
2393 val |= XELPDP_PORT_REVERSAL;
2395 intel_de_write(i915, XELPDP_PORT_BUF_CTL1(port), val);
2398 static void mtl_port_buf_ctl_io_selection(struct intel_encoder *encoder)
2400 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
2401 struct intel_digital_port *dig_port = enc_to_dig_port(encoder);
2404 val = intel_tc_port_in_tbt_alt_mode(dig_port) ?
2405 XELPDP_PORT_BUF_IO_SELECT_TBT : 0;
2406 intel_de_rmw(i915, XELPDP_PORT_BUF_CTL1(encoder->port),
2407 XELPDP_PORT_BUF_IO_SELECT_TBT, val);
2410 static void mtl_ddi_pre_enable_dp(struct intel_atomic_state *state,
2411 struct intel_encoder *encoder,
2412 const struct intel_crtc_state *crtc_state,
2413 const struct drm_connector_state *conn_state)
2415 struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
2416 bool is_mst = intel_crtc_has_type(crtc_state, INTEL_OUTPUT_DP_MST);
2418 intel_dp_set_link_params(intel_dp,
2419 crtc_state->port_clock,
2420 crtc_state->lane_count);
2423 * We only configure what the register value will be here. Actual
2424 * enabling happens during link training farther down.
2426 intel_ddi_init_dp_buf_reg(encoder, crtc_state);
2429 * 1. Enable Power Wells
2431 * This was handled at the beginning of intel_atomic_commit_tail(),
2432 * before we called down into this function.
2435 /* 2. PMdemand was already set */
2437 /* 3. Select Thunderbolt */
2438 mtl_port_buf_ctl_io_selection(encoder);
2440 /* 4. Enable Panel Power if PPS is required */
2441 intel_pps_on(intel_dp);
2443 /* 5. Enable the port PLL */
2444 intel_ddi_enable_clock(encoder, crtc_state);
2447 * 6.a Configure Transcoder Clock Select to direct the Port clock to the
2450 intel_ddi_enable_transcoder_clock(encoder, crtc_state);
2453 * 6.b If DP v2.0/128b mode - Configure TRANS_DP2_CTL register settings.
2455 intel_ddi_config_transcoder_dp2(encoder, crtc_state);
2458 * 6.c Configure TRANS_DDI_FUNC_CTL DDI Select, DDI Mode Select & MST
2461 intel_ddi_config_transcoder_func(encoder, crtc_state);
2464 * 6.e Program CoG/MSO configuration bits in DSS_CTL1 if selected.
2466 intel_ddi_mso_configure(crtc_state);
2469 intel_dp_set_power(intel_dp, DP_SET_POWER_D0);
2471 intel_dp_configure_protocol_converter(intel_dp, crtc_state);
2472 intel_dp_sink_set_decompression_state(intel_dp, crtc_state, true);
2474 * DDI FEC: "anticipates enabling FEC encoding sets the FEC_READY bit
2475 * in the FEC_CONFIGURATION register to 1 before initiating link
2478 intel_dp_sink_set_fec_ready(intel_dp, crtc_state);
2480 intel_dp_check_frl_training(intel_dp);
2481 intel_dp_pcon_dsc_configure(intel_dp, crtc_state);
2484 * 6. The rest of the below are substeps under the bspec's "Enable and
2485 * Train Display Port" step. Note that steps that are specific to
2486 * MST will be handled by intel_mst_pre_enable_dp() before/after it
2487 * calls into this function. Also intel_mst_pre_enable_dp() only calls
2488 * us when active_mst_links==0, so any steps designated for "single
2489 * stream or multi-stream master transcoder" can just be performed
2490 * unconditionally here.
2492 * mtl_ddi_prepare_link_retrain() that is called by
2493 * intel_dp_start_link_train() will execute steps: 6.d, 6.f, 6.g, 6.h,
2496 * 6.k Follow DisplayPort specification training sequence (see notes for
2498 * 6.m If DisplayPort multi-stream - Set DP_TP_CTL link training to Idle
2499 * Pattern, wait for 5 idle patterns (DP_TP_STATUS Min_Idles_Sent)
2500 * (timeout after 800 us)
2502 intel_dp_start_link_train(intel_dp, crtc_state);
2504 /* 6.n Set DP_TP_CTL link training to Normal */
2505 if (!is_trans_port_sync_mode(crtc_state))
2506 intel_dp_stop_link_train(intel_dp, crtc_state);
2508 /* 6.o Configure and enable FEC if needed */
2509 intel_ddi_enable_fec(encoder, crtc_state);
2511 intel_dsc_dp_pps_write(encoder, crtc_state);
2514 static void tgl_ddi_pre_enable_dp(struct intel_atomic_state *state,
2515 struct intel_encoder *encoder,
2516 const struct intel_crtc_state *crtc_state,
2517 const struct drm_connector_state *conn_state)
2519 struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
2520 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
2521 struct intel_digital_port *dig_port = enc_to_dig_port(encoder);
2522 bool is_mst = intel_crtc_has_type(crtc_state, INTEL_OUTPUT_DP_MST);
2524 intel_dp_set_link_params(intel_dp,
2525 crtc_state->port_clock,
2526 crtc_state->lane_count);
2529 * We only configure what the register value will be here. Actual
2530 * enabling happens during link training farther down.
2532 intel_ddi_init_dp_buf_reg(encoder, crtc_state);
2535 * 1. Enable Power Wells
2537 * This was handled at the beginning of intel_atomic_commit_tail(),
2538 * before we called down into this function.
2541 /* 2. Enable Panel Power if PPS is required */
2542 intel_pps_on(intel_dp);
2545 * 3. For non-TBT Type-C ports, set FIA lane count
2546 * (DFLEXDPSP.DPX4TXLATC)
2548 * This was done before tgl_ddi_pre_enable_dp by
2549 * hsw_crtc_enable()->intel_encoders_pre_pll_enable().
2553 * 4. Enable the port PLL.
2555 * The PLL enabling itself was already done before this function by
2556 * hsw_crtc_enable()->intel_enable_shared_dpll(). We need only
2557 * configure the PLL to port mapping here.
2559 intel_ddi_enable_clock(encoder, crtc_state);
2561 /* 5. If IO power is controlled through PWR_WELL_CTL, Enable IO Power */
2562 if (!intel_tc_port_in_tbt_alt_mode(dig_port)) {
2563 drm_WARN_ON(&dev_priv->drm, dig_port->ddi_io_wakeref);
2564 dig_port->ddi_io_wakeref = intel_display_power_get(dev_priv,
2565 dig_port->ddi_io_power_domain);
2568 /* 6. Program DP_MODE */
2569 icl_program_mg_dp_mode(dig_port, crtc_state);
2572 * 7. The rest of the below are substeps under the bspec's "Enable and
2573 * Train Display Port" step. Note that steps that are specific to
2574 * MST will be handled by intel_mst_pre_enable_dp() before/after it
2575 * calls into this function. Also intel_mst_pre_enable_dp() only calls
2576 * us when active_mst_links==0, so any steps designated for "single
2577 * stream or multi-stream master transcoder" can just be performed
2578 * unconditionally here.
2582 * 7.a Configure Transcoder Clock Select to direct the Port clock to the
2585 intel_ddi_enable_transcoder_clock(encoder, crtc_state);
2587 if (HAS_DP20(dev_priv))
2588 intel_ddi_config_transcoder_dp2(encoder, crtc_state);
2591 * 7.b Configure TRANS_DDI_FUNC_CTL DDI Select, DDI Mode Select & MST
2594 intel_ddi_config_transcoder_func(encoder, crtc_state);
2597 * 7.c Configure & enable DP_TP_CTL with link training pattern 1
2600 * This will be handled by the intel_dp_start_link_train() farther
2601 * down this function.
2604 /* 7.e Configure voltage swing and related IO settings */
2605 encoder->set_signal_levels(encoder, crtc_state);
2608 * 7.f Combo PHY: Configure PORT_CL_DW10 Static Power Down to power up
2609 * the used lanes of the DDI.
2611 intel_ddi_power_up_lanes(encoder, crtc_state);
2614 * 7.g Program CoG/MSO configuration bits in DSS_CTL1 if selected.
2616 intel_ddi_mso_configure(crtc_state);
2619 intel_dp_set_power(intel_dp, DP_SET_POWER_D0);
2621 intel_dp_configure_protocol_converter(intel_dp, crtc_state);
2622 intel_dp_sink_set_decompression_state(intel_dp, crtc_state, true);
2624 * DDI FEC: "anticipates enabling FEC encoding sets the FEC_READY bit
2625 * in the FEC_CONFIGURATION register to 1 before initiating link
2628 intel_dp_sink_set_fec_ready(intel_dp, crtc_state);
2630 intel_dp_check_frl_training(intel_dp);
2631 intel_dp_pcon_dsc_configure(intel_dp, crtc_state);
2634 * 7.i Follow DisplayPort specification training sequence (see notes for
2636 * 7.j If DisplayPort multi-stream - Set DP_TP_CTL link training to Idle
2637 * Pattern, wait for 5 idle patterns (DP_TP_STATUS Min_Idles_Sent)
2638 * (timeout after 800 us)
2640 intel_dp_start_link_train(intel_dp, crtc_state);
2642 /* 7.k Set DP_TP_CTL link training to Normal */
2643 if (!is_trans_port_sync_mode(crtc_state))
2644 intel_dp_stop_link_train(intel_dp, crtc_state);
2646 /* 7.l Configure and enable FEC if needed */
2647 intel_ddi_enable_fec(encoder, crtc_state);
2649 intel_dsc_dp_pps_write(encoder, crtc_state);
2652 static void hsw_ddi_pre_enable_dp(struct intel_atomic_state *state,
2653 struct intel_encoder *encoder,
2654 const struct intel_crtc_state *crtc_state,
2655 const struct drm_connector_state *conn_state)
2657 struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
2658 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
2659 enum port port = encoder->port;
2660 struct intel_digital_port *dig_port = enc_to_dig_port(encoder);
2661 bool is_mst = intel_crtc_has_type(crtc_state, INTEL_OUTPUT_DP_MST);
2663 if (DISPLAY_VER(dev_priv) < 11)
2664 drm_WARN_ON(&dev_priv->drm,
2665 is_mst && (port == PORT_A || port == PORT_E));
2667 drm_WARN_ON(&dev_priv->drm, is_mst && port == PORT_A);
2669 intel_dp_set_link_params(intel_dp,
2670 crtc_state->port_clock,
2671 crtc_state->lane_count);
2674 * We only configure what the register value will be here. Actual
2675 * enabling happens during link training farther down.
2677 intel_ddi_init_dp_buf_reg(encoder, crtc_state);
2679 intel_pps_on(intel_dp);
2681 intel_ddi_enable_clock(encoder, crtc_state);
2683 if (!intel_tc_port_in_tbt_alt_mode(dig_port)) {
2684 drm_WARN_ON(&dev_priv->drm, dig_port->ddi_io_wakeref);
2685 dig_port->ddi_io_wakeref = intel_display_power_get(dev_priv,
2686 dig_port->ddi_io_power_domain);
2689 icl_program_mg_dp_mode(dig_port, crtc_state);
2691 if (has_buf_trans_select(dev_priv))
2692 hsw_prepare_dp_ddi_buffers(encoder, crtc_state);
2694 encoder->set_signal_levels(encoder, crtc_state);
2696 intel_ddi_power_up_lanes(encoder, crtc_state);
2699 intel_dp_set_power(intel_dp, DP_SET_POWER_D0);
2700 intel_dp_configure_protocol_converter(intel_dp, crtc_state);
2701 intel_dp_sink_set_decompression_state(intel_dp, crtc_state,
2703 intel_dp_sink_set_fec_ready(intel_dp, crtc_state);
2704 intel_dp_start_link_train(intel_dp, crtc_state);
2705 if ((port != PORT_A || DISPLAY_VER(dev_priv) >= 9) &&
2706 !is_trans_port_sync_mode(crtc_state))
2707 intel_dp_stop_link_train(intel_dp, crtc_state);
2709 intel_ddi_enable_fec(encoder, crtc_state);
2712 intel_ddi_enable_transcoder_clock(encoder, crtc_state);
2714 intel_dsc_dp_pps_write(encoder, crtc_state);
2717 static void intel_ddi_pre_enable_dp(struct intel_atomic_state *state,
2718 struct intel_encoder *encoder,
2719 const struct intel_crtc_state *crtc_state,
2720 const struct drm_connector_state *conn_state)
2722 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
2724 if (HAS_DP20(dev_priv))
2725 intel_dp_128b132b_sdp_crc16(enc_to_intel_dp(encoder),
2728 if (DISPLAY_VER(dev_priv) >= 14)
2729 mtl_ddi_pre_enable_dp(state, encoder, crtc_state, conn_state);
2730 else if (DISPLAY_VER(dev_priv) >= 12)
2731 tgl_ddi_pre_enable_dp(state, encoder, crtc_state, conn_state);
2733 hsw_ddi_pre_enable_dp(state, encoder, crtc_state, conn_state);
2735 /* MST will call a setting of MSA after an allocating of Virtual Channel
2736 * from MST encoder pre_enable callback.
2738 if (!intel_crtc_has_type(crtc_state, INTEL_OUTPUT_DP_MST))
2739 intel_ddi_set_dp_msa(crtc_state, conn_state);
2742 static void intel_ddi_pre_enable_hdmi(struct intel_atomic_state *state,
2743 struct intel_encoder *encoder,
2744 const struct intel_crtc_state *crtc_state,
2745 const struct drm_connector_state *conn_state)
2747 struct intel_digital_port *dig_port = enc_to_dig_port(encoder);
2748 struct intel_hdmi *intel_hdmi = &dig_port->hdmi;
2749 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
2751 intel_dp_dual_mode_set_tmds_output(intel_hdmi, true);
2752 intel_ddi_enable_clock(encoder, crtc_state);
2754 drm_WARN_ON(&dev_priv->drm, dig_port->ddi_io_wakeref);
2755 dig_port->ddi_io_wakeref = intel_display_power_get(dev_priv,
2756 dig_port->ddi_io_power_domain);
2758 icl_program_mg_dp_mode(dig_port, crtc_state);
2760 intel_ddi_enable_transcoder_clock(encoder, crtc_state);
2762 dig_port->set_infoframes(encoder,
2763 crtc_state->has_infoframe,
2764 crtc_state, conn_state);
2767 static void intel_ddi_pre_enable(struct intel_atomic_state *state,
2768 struct intel_encoder *encoder,
2769 const struct intel_crtc_state *crtc_state,
2770 const struct drm_connector_state *conn_state)
2772 struct intel_crtc *crtc = to_intel_crtc(crtc_state->uapi.crtc);
2773 struct drm_i915_private *dev_priv = to_i915(crtc->base.dev);
2774 enum pipe pipe = crtc->pipe;
2777 * When called from DP MST code:
2778 * - conn_state will be NULL
2779 * - encoder will be the main encoder (ie. mst->primary)
2780 * - the main connector associated with this port
2781 * won't be active or linked to a crtc
2782 * - crtc_state will be the state of the first stream to
2783 * be activated on this port, and it may not be the same
2784 * stream that will be deactivated last, but each stream
2785 * should have a state that is identical when it comes to
2786 * the DP link parameteres
2789 drm_WARN_ON(&dev_priv->drm, crtc_state->has_pch_encoder);
2791 intel_set_cpu_fifo_underrun_reporting(dev_priv, pipe, true);
2793 if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_HDMI)) {
2794 intel_ddi_pre_enable_hdmi(state, encoder, crtc_state,
2797 struct intel_digital_port *dig_port = enc_to_dig_port(encoder);
2799 intel_ddi_pre_enable_dp(state, encoder, crtc_state,
2802 /* FIXME precompute everything properly */
2803 /* FIXME how do we turn infoframes off again? */
2804 if (dig_port->lspcon.active && dig_port->dp.has_hdmi_sink)
2805 dig_port->set_infoframes(encoder,
2806 crtc_state->has_infoframe,
2807 crtc_state, conn_state);
2812 mtl_ddi_disable_d2d_link(struct intel_encoder *encoder)
2814 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
2815 enum port port = encoder->port;
2817 intel_de_rmw(dev_priv, XELPDP_PORT_BUF_CTL1(port),
2818 XELPDP_PORT_BUF_D2D_LINK_ENABLE, 0);
2820 if (wait_for_us(!(intel_de_read(dev_priv, XELPDP_PORT_BUF_CTL1(port)) &
2821 XELPDP_PORT_BUF_D2D_LINK_STATE), 100))
2822 drm_err(&dev_priv->drm, "Timeout waiting for D2D Link disable for PORT_BUF_CTL %c\n",
2826 static void mtl_disable_ddi_buf(struct intel_encoder *encoder,
2827 const struct intel_crtc_state *crtc_state)
2829 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
2830 enum port port = encoder->port;
2833 /* 3.b Clear DDI_CTL_DE Enable to 0. */
2834 val = intel_de_read(dev_priv, DDI_BUF_CTL(port));
2835 if (val & DDI_BUF_CTL_ENABLE) {
2836 val &= ~DDI_BUF_CTL_ENABLE;
2837 intel_de_write(dev_priv, DDI_BUF_CTL(port), val);
2839 /* 3.c Poll for PORT_BUF_CTL Idle Status == 1, timeout after 100us */
2840 mtl_wait_ddi_buf_idle(dev_priv, port);
2843 /* 3.d Disable D2D Link */
2844 mtl_ddi_disable_d2d_link(encoder);
2846 /* 3.e Disable DP_TP_CTL */
2847 if (intel_crtc_has_dp_encoder(crtc_state)) {
2848 intel_de_rmw(dev_priv, dp_tp_ctl_reg(encoder, crtc_state),
2849 DP_TP_CTL_ENABLE, 0);
2853 static void disable_ddi_buf(struct intel_encoder *encoder,
2854 const struct intel_crtc_state *crtc_state)
2856 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
2857 enum port port = encoder->port;
2861 val = intel_de_read(dev_priv, DDI_BUF_CTL(port));
2862 if (val & DDI_BUF_CTL_ENABLE) {
2863 val &= ~DDI_BUF_CTL_ENABLE;
2864 intel_de_write(dev_priv, DDI_BUF_CTL(port), val);
2868 if (intel_crtc_has_dp_encoder(crtc_state))
2869 intel_de_rmw(dev_priv, dp_tp_ctl_reg(encoder, crtc_state),
2870 DP_TP_CTL_ENABLE, 0);
2872 /* Disable FEC in DP Sink */
2873 intel_ddi_disable_fec_state(encoder, crtc_state);
2876 intel_wait_ddi_buf_idle(dev_priv, port);
2879 static void intel_disable_ddi_buf(struct intel_encoder *encoder,
2880 const struct intel_crtc_state *crtc_state)
2882 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
2884 if (DISPLAY_VER(dev_priv) >= 14) {
2885 mtl_disable_ddi_buf(encoder, crtc_state);
2887 /* 3.f Disable DP_TP_CTL FEC Enable if it is needed */
2888 intel_ddi_disable_fec_state(encoder, crtc_state);
2890 disable_ddi_buf(encoder, crtc_state);
2894 static void intel_ddi_post_disable_dp(struct intel_atomic_state *state,
2895 struct intel_encoder *encoder,
2896 const struct intel_crtc_state *old_crtc_state,
2897 const struct drm_connector_state *old_conn_state)
2899 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
2900 struct intel_digital_port *dig_port = enc_to_dig_port(encoder);
2901 struct intel_dp *intel_dp = &dig_port->dp;
2902 intel_wakeref_t wakeref;
2903 bool is_mst = intel_crtc_has_type(old_crtc_state,
2904 INTEL_OUTPUT_DP_MST);
2907 intel_dp_set_infoframes(encoder, false,
2908 old_crtc_state, old_conn_state);
2911 * Power down sink before disabling the port, otherwise we end
2912 * up getting interrupts from the sink on detecting link loss.
2914 intel_dp_set_power(intel_dp, DP_SET_POWER_D3);
2916 if (DISPLAY_VER(dev_priv) >= 12) {
2918 enum transcoder cpu_transcoder = old_crtc_state->cpu_transcoder;
2920 intel_de_rmw(dev_priv, TRANS_DDI_FUNC_CTL(cpu_transcoder),
2921 TGL_TRANS_DDI_PORT_MASK | TRANS_DDI_MODE_SELECT_MASK,
2926 intel_ddi_disable_transcoder_clock(old_crtc_state);
2929 intel_disable_ddi_buf(encoder, old_crtc_state);
2932 * From TGL spec: "If single stream or multi-stream master transcoder:
2933 * Configure Transcoder Clock select to direct no clock to the
2936 if (DISPLAY_VER(dev_priv) >= 12)
2937 intel_ddi_disable_transcoder_clock(old_crtc_state);
2939 intel_pps_vdd_on(intel_dp);
2940 intel_pps_off(intel_dp);
2942 wakeref = fetch_and_zero(&dig_port->ddi_io_wakeref);
2945 intel_display_power_put(dev_priv,
2946 dig_port->ddi_io_power_domain,
2949 intel_ddi_disable_clock(encoder);
2951 /* De-select Thunderbolt */
2952 if (DISPLAY_VER(dev_priv) >= 14)
2953 intel_de_rmw(dev_priv, XELPDP_PORT_BUF_CTL1(encoder->port),
2954 XELPDP_PORT_BUF_IO_SELECT_TBT, 0);
2957 static void intel_ddi_post_disable_hdmi(struct intel_atomic_state *state,
2958 struct intel_encoder *encoder,
2959 const struct intel_crtc_state *old_crtc_state,
2960 const struct drm_connector_state *old_conn_state)
2962 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
2963 struct intel_digital_port *dig_port = enc_to_dig_port(encoder);
2964 struct intel_hdmi *intel_hdmi = &dig_port->hdmi;
2965 intel_wakeref_t wakeref;
2967 dig_port->set_infoframes(encoder, false,
2968 old_crtc_state, old_conn_state);
2970 if (DISPLAY_VER(dev_priv) < 12)
2971 intel_ddi_disable_transcoder_clock(old_crtc_state);
2973 intel_disable_ddi_buf(encoder, old_crtc_state);
2975 if (DISPLAY_VER(dev_priv) >= 12)
2976 intel_ddi_disable_transcoder_clock(old_crtc_state);
2978 wakeref = fetch_and_zero(&dig_port->ddi_io_wakeref);
2980 intel_display_power_put(dev_priv,
2981 dig_port->ddi_io_power_domain,
2984 intel_ddi_disable_clock(encoder);
2986 intel_dp_dual_mode_set_tmds_output(intel_hdmi, false);
2989 static void intel_ddi_post_disable(struct intel_atomic_state *state,
2990 struct intel_encoder *encoder,
2991 const struct intel_crtc_state *old_crtc_state,
2992 const struct drm_connector_state *old_conn_state)
2994 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
2995 struct intel_crtc *slave_crtc;
2997 if (!intel_crtc_has_type(old_crtc_state, INTEL_OUTPUT_DP_MST)) {
2998 intel_crtc_vblank_off(old_crtc_state);
3000 intel_disable_transcoder(old_crtc_state);
3002 intel_ddi_disable_transcoder_func(old_crtc_state);
3004 intel_dsc_disable(old_crtc_state);
3006 if (DISPLAY_VER(dev_priv) >= 9)
3007 skl_scaler_disable(old_crtc_state);
3009 ilk_pfit_disable(old_crtc_state);
3012 for_each_intel_crtc_in_pipe_mask(&dev_priv->drm, slave_crtc,
3013 intel_crtc_bigjoiner_slave_pipes(old_crtc_state)) {
3014 const struct intel_crtc_state *old_slave_crtc_state =
3015 intel_atomic_get_old_crtc_state(state, slave_crtc);
3017 intel_crtc_vblank_off(old_slave_crtc_state);
3019 intel_dsc_disable(old_slave_crtc_state);
3020 skl_scaler_disable(old_slave_crtc_state);
3024 * When called from DP MST code:
3025 * - old_conn_state will be NULL
3026 * - encoder will be the main encoder (ie. mst->primary)
3027 * - the main connector associated with this port
3028 * won't be active or linked to a crtc
3029 * - old_crtc_state will be the state of the last stream to
3030 * be deactivated on this port, and it may not be the same
3031 * stream that was activated last, but each stream
3032 * should have a state that is identical when it comes to
3033 * the DP link parameteres
3036 if (intel_crtc_has_type(old_crtc_state, INTEL_OUTPUT_HDMI))
3037 intel_ddi_post_disable_hdmi(state, encoder, old_crtc_state,
3040 intel_ddi_post_disable_dp(state, encoder, old_crtc_state,
3044 static void intel_ddi_post_pll_disable(struct intel_atomic_state *state,
3045 struct intel_encoder *encoder,
3046 const struct intel_crtc_state *old_crtc_state,
3047 const struct drm_connector_state *old_conn_state)
3049 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
3050 struct intel_digital_port *dig_port = enc_to_dig_port(encoder);
3051 enum phy phy = intel_port_to_phy(i915, encoder->port);
3052 bool is_tc_port = intel_phy_is_tc(i915, phy);
3054 main_link_aux_power_domain_put(dig_port, old_crtc_state);
3057 intel_tc_port_put_link(dig_port);
3060 static void trans_port_sync_stop_link_train(struct intel_atomic_state *state,
3061 struct intel_encoder *encoder,
3062 const struct intel_crtc_state *crtc_state)
3064 const struct drm_connector_state *conn_state;
3065 struct drm_connector *conn;
3068 if (!crtc_state->sync_mode_slaves_mask)
3071 for_each_new_connector_in_state(&state->base, conn, conn_state, i) {
3072 struct intel_encoder *slave_encoder =
3073 to_intel_encoder(conn_state->best_encoder);
3074 struct intel_crtc *slave_crtc = to_intel_crtc(conn_state->crtc);
3075 const struct intel_crtc_state *slave_crtc_state;
3081 intel_atomic_get_new_crtc_state(state, slave_crtc);
3083 if (slave_crtc_state->master_transcoder !=
3084 crtc_state->cpu_transcoder)
3087 intel_dp_stop_link_train(enc_to_intel_dp(slave_encoder),
3091 usleep_range(200, 400);
3093 intel_dp_stop_link_train(enc_to_intel_dp(encoder),
3097 static void intel_enable_ddi_dp(struct intel_atomic_state *state,
3098 struct intel_encoder *encoder,
3099 const struct intel_crtc_state *crtc_state,
3100 const struct drm_connector_state *conn_state)
3102 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
3103 struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
3104 struct intel_digital_port *dig_port = enc_to_dig_port(encoder);
3105 enum port port = encoder->port;
3107 if (port == PORT_A && DISPLAY_VER(dev_priv) < 9)
3108 intel_dp_stop_link_train(intel_dp, crtc_state);
3110 drm_connector_update_privacy_screen(conn_state);
3111 intel_edp_backlight_on(crtc_state, conn_state);
3113 if (!dig_port->lspcon.active || dig_port->dp.has_hdmi_sink)
3114 intel_dp_set_infoframes(encoder, true, crtc_state, conn_state);
3116 intel_audio_codec_enable(encoder, crtc_state, conn_state);
3118 trans_port_sync_stop_link_train(state, encoder, crtc_state);
3122 gen9_chicken_trans_reg_by_port(struct drm_i915_private *dev_priv,
3125 static const enum transcoder trans[] = {
3126 [PORT_A] = TRANSCODER_EDP,
3127 [PORT_B] = TRANSCODER_A,
3128 [PORT_C] = TRANSCODER_B,
3129 [PORT_D] = TRANSCODER_C,
3130 [PORT_E] = TRANSCODER_A,
3133 drm_WARN_ON(&dev_priv->drm, DISPLAY_VER(dev_priv) < 9);
3135 if (drm_WARN_ON(&dev_priv->drm, port < PORT_A || port > PORT_E))
3138 return CHICKEN_TRANS(trans[port]);
3141 static void intel_enable_ddi_hdmi(struct intel_atomic_state *state,
3142 struct intel_encoder *encoder,
3143 const struct intel_crtc_state *crtc_state,
3144 const struct drm_connector_state *conn_state)
3146 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
3147 struct intel_digital_port *dig_port = enc_to_dig_port(encoder);
3148 struct drm_connector *connector = conn_state->connector;
3149 enum port port = encoder->port;
3150 enum phy phy = intel_port_to_phy(dev_priv, port);
3153 if (!intel_hdmi_handle_sink_scrambling(encoder, connector,
3154 crtc_state->hdmi_high_tmds_clock_ratio,
3155 crtc_state->hdmi_scrambling))
3156 drm_dbg_kms(&dev_priv->drm,
3157 "[CONNECTOR:%d:%s] Failed to configure sink scrambling/TMDS bit clock ratio\n",
3158 connector->base.id, connector->name);
3160 if (has_buf_trans_select(dev_priv))
3161 hsw_prepare_hdmi_ddi_buffers(encoder, crtc_state);
3163 /* e. Enable D2D Link for C10/C20 Phy */
3164 if (DISPLAY_VER(dev_priv) >= 14)
3165 mtl_ddi_enable_d2d(encoder);
3167 encoder->set_signal_levels(encoder, crtc_state);
3169 /* Display WA #1143: skl,kbl,cfl */
3170 if (DISPLAY_VER(dev_priv) == 9 && !IS_BROXTON(dev_priv)) {
3172 * For some reason these chicken bits have been
3173 * stuffed into a transcoder register, event though
3174 * the bits affect a specific DDI port rather than
3175 * a specific transcoder.
3177 i915_reg_t reg = gen9_chicken_trans_reg_by_port(dev_priv, port);
3180 val = intel_de_read(dev_priv, reg);
3183 val |= DDIE_TRAINING_OVERRIDE_ENABLE |
3184 DDIE_TRAINING_OVERRIDE_VALUE;
3186 val |= DDI_TRAINING_OVERRIDE_ENABLE |
3187 DDI_TRAINING_OVERRIDE_VALUE;
3189 intel_de_write(dev_priv, reg, val);
3190 intel_de_posting_read(dev_priv, reg);
3195 val &= ~(DDIE_TRAINING_OVERRIDE_ENABLE |
3196 DDIE_TRAINING_OVERRIDE_VALUE);
3198 val &= ~(DDI_TRAINING_OVERRIDE_ENABLE |
3199 DDI_TRAINING_OVERRIDE_VALUE);
3201 intel_de_write(dev_priv, reg, val);
3204 intel_ddi_power_up_lanes(encoder, crtc_state);
3206 /* In HDMI/DVI mode, the port width, and swing/emphasis values
3207 * are ignored so nothing special needs to be done besides
3208 * enabling the port.
3210 * On ADL_P the PHY link rate and lane count must be programmed but
3211 * these are both 0 for HDMI.
3213 * But MTL onwards HDMI2.1 is supported and in TMDS mode this
3214 * is filled with lane count, already set in the crtc_state.
3215 * The same is required to be filled in PORT_BUF_CTL for C10/20 Phy.
3217 buf_ctl = dig_port->saved_port_bits | DDI_BUF_CTL_ENABLE;
3218 if (DISPLAY_VER(dev_priv) >= 14) {
3219 u8 lane_count = mtl_get_port_width(crtc_state->lane_count);
3222 port_buf |= XELPDP_PORT_WIDTH(lane_count);
3224 if (dig_port->saved_port_bits & DDI_BUF_PORT_REVERSAL)
3225 port_buf |= XELPDP_PORT_REVERSAL;
3227 intel_de_rmw(dev_priv, XELPDP_PORT_BUF_CTL1(port),
3228 XELPDP_PORT_WIDTH_MASK | XELPDP_PORT_REVERSAL, port_buf);
3230 buf_ctl |= DDI_PORT_WIDTH(lane_count);
3231 } else if (IS_ALDERLAKE_P(dev_priv) && intel_phy_is_tc(dev_priv, phy)) {
3232 drm_WARN_ON(&dev_priv->drm, !intel_tc_port_in_legacy_mode(dig_port));
3233 buf_ctl |= DDI_BUF_CTL_TC_PHY_OWNERSHIP;
3236 intel_de_write(dev_priv, DDI_BUF_CTL(port), buf_ctl);
3238 intel_wait_ddi_buf_active(dev_priv, port);
3240 intel_audio_codec_enable(encoder, crtc_state, conn_state);
3243 static void intel_enable_ddi(struct intel_atomic_state *state,
3244 struct intel_encoder *encoder,
3245 const struct intel_crtc_state *crtc_state,
3246 const struct drm_connector_state *conn_state)
3248 drm_WARN_ON(state->base.dev, crtc_state->has_pch_encoder);
3250 if (!intel_crtc_is_bigjoiner_slave(crtc_state))
3251 intel_ddi_enable_transcoder_func(encoder, crtc_state);
3253 /* Enable/Disable DP2.0 SDP split config before transcoder */
3254 intel_audio_sdp_split_update(encoder, crtc_state);
3256 intel_enable_transcoder(crtc_state);
3258 intel_crtc_vblank_on(crtc_state);
3260 if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_HDMI))
3261 intel_enable_ddi_hdmi(state, encoder, crtc_state, conn_state);
3263 intel_enable_ddi_dp(state, encoder, crtc_state, conn_state);
3265 /* Enable hdcp if it's desired */
3266 if (conn_state->content_protection ==
3267 DRM_MODE_CONTENT_PROTECTION_DESIRED)
3268 intel_hdcp_enable(state, encoder, crtc_state, conn_state);
3271 static void intel_disable_ddi_dp(struct intel_atomic_state *state,
3272 struct intel_encoder *encoder,
3273 const struct intel_crtc_state *old_crtc_state,
3274 const struct drm_connector_state *old_conn_state)
3276 struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
3278 intel_dp->link_trained = false;
3280 intel_audio_codec_disable(encoder, old_crtc_state, old_conn_state);
3282 intel_psr_disable(intel_dp, old_crtc_state);
3283 intel_edp_backlight_off(old_conn_state);
3284 /* Disable the decompression in DP Sink */
3285 intel_dp_sink_set_decompression_state(intel_dp, old_crtc_state,
3287 /* Disable Ignore_MSA bit in DP Sink */
3288 intel_dp_sink_set_msa_timing_par_ignore_state(intel_dp, old_crtc_state,
3292 static void intel_disable_ddi_hdmi(struct intel_atomic_state *state,
3293 struct intel_encoder *encoder,
3294 const struct intel_crtc_state *old_crtc_state,
3295 const struct drm_connector_state *old_conn_state)
3297 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
3298 struct drm_connector *connector = old_conn_state->connector;
3300 intel_audio_codec_disable(encoder, old_crtc_state, old_conn_state);
3302 if (!intel_hdmi_handle_sink_scrambling(encoder, connector,
3304 drm_dbg_kms(&i915->drm,
3305 "[CONNECTOR:%d:%s] Failed to reset sink scrambling/TMDS bit clock ratio\n",
3306 connector->base.id, connector->name);
3309 static void intel_disable_ddi(struct intel_atomic_state *state,
3310 struct intel_encoder *encoder,
3311 const struct intel_crtc_state *old_crtc_state,
3312 const struct drm_connector_state *old_conn_state)
3314 intel_tc_port_link_cancel_reset_work(enc_to_dig_port(encoder));
3316 intel_hdcp_disable(to_intel_connector(old_conn_state->connector));
3318 if (intel_crtc_has_type(old_crtc_state, INTEL_OUTPUT_HDMI))
3319 intel_disable_ddi_hdmi(state, encoder, old_crtc_state,
3322 intel_disable_ddi_dp(state, encoder, old_crtc_state,
3326 static void intel_ddi_update_pipe_dp(struct intel_atomic_state *state,
3327 struct intel_encoder *encoder,
3328 const struct intel_crtc_state *crtc_state,
3329 const struct drm_connector_state *conn_state)
3331 intel_ddi_set_dp_msa(crtc_state, conn_state);
3333 intel_dp_set_infoframes(encoder, true, crtc_state, conn_state);
3335 intel_backlight_update(state, encoder, crtc_state, conn_state);
3336 drm_connector_update_privacy_screen(conn_state);
3339 void intel_ddi_update_pipe(struct intel_atomic_state *state,
3340 struct intel_encoder *encoder,
3341 const struct intel_crtc_state *crtc_state,
3342 const struct drm_connector_state *conn_state)
3345 if (!intel_crtc_has_type(crtc_state, INTEL_OUTPUT_HDMI) &&
3346 !intel_encoder_is_mst(encoder))
3347 intel_ddi_update_pipe_dp(state, encoder, crtc_state,
3350 intel_hdcp_update_pipe(state, encoder, crtc_state, conn_state);
3353 void intel_ddi_update_active_dpll(struct intel_atomic_state *state,
3354 struct intel_encoder *encoder,
3355 struct intel_crtc *crtc)
3357 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
3358 struct intel_crtc_state *crtc_state =
3359 intel_atomic_get_new_crtc_state(state, crtc);
3360 struct intel_crtc *slave_crtc;
3361 enum phy phy = intel_port_to_phy(i915, encoder->port);
3363 /* FIXME: Add MTL pll_mgr */
3364 if (DISPLAY_VER(i915) >= 14 || !intel_phy_is_tc(i915, phy))
3367 intel_update_active_dpll(state, crtc, encoder);
3368 for_each_intel_crtc_in_pipe_mask(&i915->drm, slave_crtc,
3369 intel_crtc_bigjoiner_slave_pipes(crtc_state))
3370 intel_update_active_dpll(state, slave_crtc, encoder);
3374 intel_ddi_pre_pll_enable(struct intel_atomic_state *state,
3375 struct intel_encoder *encoder,
3376 const struct intel_crtc_state *crtc_state,
3377 const struct drm_connector_state *conn_state)
3379 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
3380 struct intel_digital_port *dig_port = enc_to_dig_port(encoder);
3381 enum phy phy = intel_port_to_phy(dev_priv, encoder->port);
3382 bool is_tc_port = intel_phy_is_tc(dev_priv, phy);
3385 struct intel_crtc *master_crtc =
3386 to_intel_crtc(crtc_state->uapi.crtc);
3388 intel_tc_port_get_link(dig_port, crtc_state->lane_count);
3389 intel_ddi_update_active_dpll(state, encoder, master_crtc);
3392 main_link_aux_power_domain_get(dig_port, crtc_state);
3394 if (is_tc_port && !intel_tc_port_in_tbt_alt_mode(dig_port))
3396 * Program the lane count for static/dynamic connections on
3397 * Type-C ports. Skip this step for TBT.
3399 intel_tc_port_set_fia_lane_count(dig_port, crtc_state->lane_count);
3400 else if (IS_GEMINILAKE(dev_priv) || IS_BROXTON(dev_priv))
3401 bxt_ddi_phy_set_lane_optim_mask(encoder,
3402 crtc_state->lane_lat_optim_mask);
3405 static void adlp_tbt_to_dp_alt_switch_wa(struct intel_encoder *encoder)
3407 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
3408 enum tc_port tc_port = intel_port_to_tc(i915, encoder->port);
3411 for (ln = 0; ln < 2; ln++)
3412 intel_dkl_phy_rmw(i915, DKL_PCS_DW5(tc_port, ln), DKL_PCS_DW5_CORE_SOFTRESET, 0);
3415 static void mtl_ddi_prepare_link_retrain(struct intel_dp *intel_dp,
3416 const struct intel_crtc_state *crtc_state)
3418 struct intel_digital_port *dig_port = dp_to_dig_port(intel_dp);
3419 struct intel_encoder *encoder = &dig_port->base;
3420 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
3421 enum port port = encoder->port;
3425 * TODO: To train with only a different voltage swing entry is not
3426 * necessary disable and enable port
3428 dp_tp_ctl = intel_de_read(dev_priv, dp_tp_ctl_reg(encoder, crtc_state));
3429 if (dp_tp_ctl & DP_TP_CTL_ENABLE)
3430 mtl_disable_ddi_buf(encoder, crtc_state);
3432 /* 6.d Configure and enable DP_TP_CTL with link training pattern 1 selected */
3433 dp_tp_ctl = DP_TP_CTL_ENABLE | DP_TP_CTL_LINK_TRAIN_PAT1;
3434 if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_DP_MST)) {
3435 dp_tp_ctl |= DP_TP_CTL_MODE_MST;
3437 dp_tp_ctl |= DP_TP_CTL_MODE_SST;
3438 if (drm_dp_enhanced_frame_cap(intel_dp->dpcd))
3439 dp_tp_ctl |= DP_TP_CTL_ENHANCED_FRAME_ENABLE;
3441 intel_de_write(dev_priv, dp_tp_ctl_reg(encoder, crtc_state), dp_tp_ctl);
3442 intel_de_posting_read(dev_priv, dp_tp_ctl_reg(encoder, crtc_state));
3444 /* 6.f Enable D2D Link */
3445 mtl_ddi_enable_d2d(encoder);
3447 /* 6.g Configure voltage swing and related IO settings */
3448 encoder->set_signal_levels(encoder, crtc_state);
3450 /* 6.h Configure PORT_BUF_CTL1 */
3451 mtl_port_buf_ctl_program(encoder, crtc_state);
3453 /* 6.i Configure and enable DDI_CTL_DE to start sending valid data to port slice */
3454 intel_dp->DP |= DDI_BUF_CTL_ENABLE;
3455 intel_de_write(dev_priv, DDI_BUF_CTL(port), intel_dp->DP);
3456 intel_de_posting_read(dev_priv, DDI_BUF_CTL(port));
3458 /* 6.j Poll for PORT_BUF_CTL Idle Status == 0, timeout after 100 us */
3459 intel_wait_ddi_buf_active(dev_priv, port);
3462 static void intel_ddi_prepare_link_retrain(struct intel_dp *intel_dp,
3463 const struct intel_crtc_state *crtc_state)
3465 struct intel_digital_port *dig_port = dp_to_dig_port(intel_dp);
3466 struct intel_encoder *encoder = &dig_port->base;
3467 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
3468 enum port port = encoder->port;
3469 u32 dp_tp_ctl, ddi_buf_ctl;
3472 dp_tp_ctl = intel_de_read(dev_priv, dp_tp_ctl_reg(encoder, crtc_state));
3474 if (dp_tp_ctl & DP_TP_CTL_ENABLE) {
3475 ddi_buf_ctl = intel_de_read(dev_priv, DDI_BUF_CTL(port));
3476 if (ddi_buf_ctl & DDI_BUF_CTL_ENABLE) {
3477 intel_de_write(dev_priv, DDI_BUF_CTL(port),
3478 ddi_buf_ctl & ~DDI_BUF_CTL_ENABLE);
3482 dp_tp_ctl &= ~DP_TP_CTL_ENABLE;
3483 intel_de_write(dev_priv, dp_tp_ctl_reg(encoder, crtc_state), dp_tp_ctl);
3484 intel_de_posting_read(dev_priv, dp_tp_ctl_reg(encoder, crtc_state));
3487 intel_wait_ddi_buf_idle(dev_priv, port);
3490 dp_tp_ctl = DP_TP_CTL_ENABLE | DP_TP_CTL_LINK_TRAIN_PAT1;
3491 if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_DP_MST)) {
3492 dp_tp_ctl |= DP_TP_CTL_MODE_MST;
3494 dp_tp_ctl |= DP_TP_CTL_MODE_SST;
3495 if (drm_dp_enhanced_frame_cap(intel_dp->dpcd))
3496 dp_tp_ctl |= DP_TP_CTL_ENHANCED_FRAME_ENABLE;
3498 intel_de_write(dev_priv, dp_tp_ctl_reg(encoder, crtc_state), dp_tp_ctl);
3499 intel_de_posting_read(dev_priv, dp_tp_ctl_reg(encoder, crtc_state));
3501 if (IS_ALDERLAKE_P(dev_priv) &&
3502 (intel_tc_port_in_dp_alt_mode(dig_port) || intel_tc_port_in_legacy_mode(dig_port)))
3503 adlp_tbt_to_dp_alt_switch_wa(encoder);
3505 intel_dp->DP |= DDI_BUF_CTL_ENABLE;
3506 intel_de_write(dev_priv, DDI_BUF_CTL(port), intel_dp->DP);
3507 intel_de_posting_read(dev_priv, DDI_BUF_CTL(port));
3509 intel_wait_ddi_buf_active(dev_priv, port);
3512 static void intel_ddi_set_link_train(struct intel_dp *intel_dp,
3513 const struct intel_crtc_state *crtc_state,
3516 struct intel_encoder *encoder = &dp_to_dig_port(intel_dp)->base;
3517 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
3520 temp = intel_de_read(dev_priv, dp_tp_ctl_reg(encoder, crtc_state));
3522 temp &= ~DP_TP_CTL_LINK_TRAIN_MASK;
3523 switch (intel_dp_training_pattern_symbol(dp_train_pat)) {
3524 case DP_TRAINING_PATTERN_DISABLE:
3525 temp |= DP_TP_CTL_LINK_TRAIN_NORMAL;
3527 case DP_TRAINING_PATTERN_1:
3528 temp |= DP_TP_CTL_LINK_TRAIN_PAT1;
3530 case DP_TRAINING_PATTERN_2:
3531 temp |= DP_TP_CTL_LINK_TRAIN_PAT2;
3533 case DP_TRAINING_PATTERN_3:
3534 temp |= DP_TP_CTL_LINK_TRAIN_PAT3;
3536 case DP_TRAINING_PATTERN_4:
3537 temp |= DP_TP_CTL_LINK_TRAIN_PAT4;
3541 intel_de_write(dev_priv, dp_tp_ctl_reg(encoder, crtc_state), temp);
3544 static void intel_ddi_set_idle_link_train(struct intel_dp *intel_dp,
3545 const struct intel_crtc_state *crtc_state)
3547 struct intel_encoder *encoder = &dp_to_dig_port(intel_dp)->base;
3548 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
3549 enum port port = encoder->port;
3551 intel_de_rmw(dev_priv, dp_tp_ctl_reg(encoder, crtc_state),
3552 DP_TP_CTL_LINK_TRAIN_MASK, DP_TP_CTL_LINK_TRAIN_IDLE);
3555 * Until TGL on PORT_A we can have only eDP in SST mode. There the only
3556 * reason we need to set idle transmission mode is to work around a HW
3557 * issue where we enable the pipe while not in idle link-training mode.
3558 * In this case there is requirement to wait for a minimum number of
3559 * idle patterns to be sent.
3561 if (port == PORT_A && DISPLAY_VER(dev_priv) < 12)
3564 if (intel_de_wait_for_set(dev_priv,
3565 dp_tp_status_reg(encoder, crtc_state),
3566 DP_TP_STATUS_IDLE_DONE, 1))
3567 drm_err(&dev_priv->drm,
3568 "Timed out waiting for DP idle patterns\n");
3571 static bool intel_ddi_is_audio_enabled(struct drm_i915_private *dev_priv,
3572 enum transcoder cpu_transcoder)
3574 if (cpu_transcoder == TRANSCODER_EDP)
3577 if (!intel_display_power_is_enabled(dev_priv, POWER_DOMAIN_AUDIO_MMIO))
3580 return intel_de_read(dev_priv, HSW_AUD_PIN_ELD_CP_VLD) &
3581 AUDIO_OUTPUT_ENABLE(cpu_transcoder);
3584 void intel_ddi_compute_min_voltage_level(struct drm_i915_private *dev_priv,
3585 struct intel_crtc_state *crtc_state)
3587 if (DISPLAY_VER(dev_priv) >= 12 && crtc_state->port_clock > 594000)
3588 crtc_state->min_voltage_level = 2;
3589 else if (IS_JSL_EHL(dev_priv) && crtc_state->port_clock > 594000)
3590 crtc_state->min_voltage_level = 3;
3591 else if (DISPLAY_VER(dev_priv) >= 11 && crtc_state->port_clock > 594000)
3592 crtc_state->min_voltage_level = 1;
3595 static enum transcoder bdw_transcoder_master_readout(struct drm_i915_private *dev_priv,
3596 enum transcoder cpu_transcoder)
3600 if (DISPLAY_VER(dev_priv) >= 11) {
3601 u32 ctl2 = intel_de_read(dev_priv, TRANS_DDI_FUNC_CTL2(cpu_transcoder));
3603 if ((ctl2 & PORT_SYNC_MODE_ENABLE) == 0)
3604 return INVALID_TRANSCODER;
3606 master_select = REG_FIELD_GET(PORT_SYNC_MODE_MASTER_SELECT_MASK, ctl2);
3608 u32 ctl = intel_de_read(dev_priv, TRANS_DDI_FUNC_CTL(cpu_transcoder));
3610 if ((ctl & TRANS_DDI_PORT_SYNC_ENABLE) == 0)
3611 return INVALID_TRANSCODER;
3613 master_select = REG_FIELD_GET(TRANS_DDI_PORT_SYNC_MASTER_SELECT_MASK, ctl);
3616 if (master_select == 0)
3617 return TRANSCODER_EDP;
3619 return master_select - 1;
3622 static void bdw_get_trans_port_sync_config(struct intel_crtc_state *crtc_state)
3624 struct drm_i915_private *dev_priv = to_i915(crtc_state->uapi.crtc->dev);
3625 u32 transcoders = BIT(TRANSCODER_A) | BIT(TRANSCODER_B) |
3626 BIT(TRANSCODER_C) | BIT(TRANSCODER_D);
3627 enum transcoder cpu_transcoder;
3629 crtc_state->master_transcoder =
3630 bdw_transcoder_master_readout(dev_priv, crtc_state->cpu_transcoder);
3632 for_each_cpu_transcoder_masked(dev_priv, cpu_transcoder, transcoders) {
3633 enum intel_display_power_domain power_domain;
3634 intel_wakeref_t trans_wakeref;
3636 power_domain = POWER_DOMAIN_TRANSCODER(cpu_transcoder);
3637 trans_wakeref = intel_display_power_get_if_enabled(dev_priv,
3643 if (bdw_transcoder_master_readout(dev_priv, cpu_transcoder) ==
3644 crtc_state->cpu_transcoder)
3645 crtc_state->sync_mode_slaves_mask |= BIT(cpu_transcoder);
3647 intel_display_power_put(dev_priv, power_domain, trans_wakeref);
3650 drm_WARN_ON(&dev_priv->drm,
3651 crtc_state->master_transcoder != INVALID_TRANSCODER &&
3652 crtc_state->sync_mode_slaves_mask);
3655 static void intel_ddi_read_func_ctl(struct intel_encoder *encoder,
3656 struct intel_crtc_state *pipe_config)
3658 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
3659 struct intel_crtc *crtc = to_intel_crtc(pipe_config->uapi.crtc);
3660 enum transcoder cpu_transcoder = pipe_config->cpu_transcoder;
3661 struct intel_digital_port *dig_port = enc_to_dig_port(encoder);
3662 u32 temp, flags = 0;
3664 temp = intel_de_read(dev_priv, TRANS_DDI_FUNC_CTL(cpu_transcoder));
3665 if (temp & TRANS_DDI_PHSYNC)
3666 flags |= DRM_MODE_FLAG_PHSYNC;
3668 flags |= DRM_MODE_FLAG_NHSYNC;
3669 if (temp & TRANS_DDI_PVSYNC)
3670 flags |= DRM_MODE_FLAG_PVSYNC;
3672 flags |= DRM_MODE_FLAG_NVSYNC;
3674 pipe_config->hw.adjusted_mode.flags |= flags;
3676 switch (temp & TRANS_DDI_BPC_MASK) {
3677 case TRANS_DDI_BPC_6:
3678 pipe_config->pipe_bpp = 18;
3680 case TRANS_DDI_BPC_8:
3681 pipe_config->pipe_bpp = 24;
3683 case TRANS_DDI_BPC_10:
3684 pipe_config->pipe_bpp = 30;
3686 case TRANS_DDI_BPC_12:
3687 pipe_config->pipe_bpp = 36;
3693 switch (temp & TRANS_DDI_MODE_SELECT_MASK) {
3694 case TRANS_DDI_MODE_SELECT_HDMI:
3695 pipe_config->has_hdmi_sink = true;
3697 pipe_config->infoframes.enable |=
3698 intel_hdmi_infoframes_enabled(encoder, pipe_config);
3700 if (pipe_config->infoframes.enable)
3701 pipe_config->has_infoframe = true;
3703 if (temp & TRANS_DDI_HDMI_SCRAMBLING)
3704 pipe_config->hdmi_scrambling = true;
3705 if (temp & TRANS_DDI_HIGH_TMDS_CHAR_RATE)
3706 pipe_config->hdmi_high_tmds_clock_ratio = true;
3708 case TRANS_DDI_MODE_SELECT_DVI:
3709 pipe_config->output_types |= BIT(INTEL_OUTPUT_HDMI);
3710 if (DISPLAY_VER(dev_priv) >= 14)
3711 pipe_config->lane_count =
3712 ((temp & DDI_PORT_WIDTH_MASK) >> DDI_PORT_WIDTH_SHIFT) + 1;
3714 pipe_config->lane_count = 4;
3716 case TRANS_DDI_MODE_SELECT_DP_SST:
3717 if (encoder->type == INTEL_OUTPUT_EDP)
3718 pipe_config->output_types |= BIT(INTEL_OUTPUT_EDP);
3720 pipe_config->output_types |= BIT(INTEL_OUTPUT_DP);
3721 pipe_config->lane_count =
3722 ((temp & DDI_PORT_WIDTH_MASK) >> DDI_PORT_WIDTH_SHIFT) + 1;
3724 intel_cpu_transcoder_get_m1_n1(crtc, cpu_transcoder,
3725 &pipe_config->dp_m_n);
3726 intel_cpu_transcoder_get_m2_n2(crtc, cpu_transcoder,
3727 &pipe_config->dp_m2_n2);
3729 if (DISPLAY_VER(dev_priv) >= 11) {
3730 i915_reg_t dp_tp_ctl = dp_tp_ctl_reg(encoder, pipe_config);
3732 pipe_config->fec_enable =
3733 intel_de_read(dev_priv, dp_tp_ctl) & DP_TP_CTL_FEC_ENABLE;
3735 drm_dbg_kms(&dev_priv->drm,
3736 "[ENCODER:%d:%s] Fec status: %u\n",
3737 encoder->base.base.id, encoder->base.name,
3738 pipe_config->fec_enable);
3741 if (dig_port->lspcon.active && dig_port->dp.has_hdmi_sink)
3742 pipe_config->infoframes.enable |=
3743 intel_lspcon_infoframes_enabled(encoder, pipe_config);
3745 pipe_config->infoframes.enable |=
3746 intel_hdmi_infoframes_enabled(encoder, pipe_config);
3748 case TRANS_DDI_MODE_SELECT_FDI_OR_128B132B:
3749 if (!HAS_DP20(dev_priv)) {
3751 pipe_config->output_types |= BIT(INTEL_OUTPUT_ANALOG);
3754 fallthrough; /* 128b/132b */
3755 case TRANS_DDI_MODE_SELECT_DP_MST:
3756 pipe_config->output_types |= BIT(INTEL_OUTPUT_DP_MST);
3757 pipe_config->lane_count =
3758 ((temp & DDI_PORT_WIDTH_MASK) >> DDI_PORT_WIDTH_SHIFT) + 1;
3760 if (DISPLAY_VER(dev_priv) >= 12)
3761 pipe_config->mst_master_transcoder =
3762 REG_FIELD_GET(TRANS_DDI_MST_TRANSPORT_SELECT_MASK, temp);
3764 intel_cpu_transcoder_get_m1_n1(crtc, cpu_transcoder,
3765 &pipe_config->dp_m_n);
3767 pipe_config->infoframes.enable |=
3768 intel_hdmi_infoframes_enabled(encoder, pipe_config);
3775 static void intel_ddi_get_config(struct intel_encoder *encoder,
3776 struct intel_crtc_state *pipe_config)
3778 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
3779 enum transcoder cpu_transcoder = pipe_config->cpu_transcoder;
3781 /* XXX: DSI transcoder paranoia */
3782 if (drm_WARN_ON(&dev_priv->drm, transcoder_is_dsi(cpu_transcoder)))
3785 intel_ddi_read_func_ctl(encoder, pipe_config);
3787 intel_ddi_mso_get_config(encoder, pipe_config);
3789 pipe_config->has_audio =
3790 intel_ddi_is_audio_enabled(dev_priv, cpu_transcoder);
3792 if (encoder->type == INTEL_OUTPUT_EDP)
3793 intel_edp_fixup_vbt_bpp(encoder, pipe_config->pipe_bpp);
3795 ddi_dotclock_get(pipe_config);
3797 if (IS_GEMINILAKE(dev_priv) || IS_BROXTON(dev_priv))
3798 pipe_config->lane_lat_optim_mask =
3799 bxt_ddi_phy_get_lane_lat_optim_mask(encoder);
3801 intel_ddi_compute_min_voltage_level(dev_priv, pipe_config);
3803 intel_hdmi_read_gcp_infoframe(encoder, pipe_config);
3805 intel_read_infoframe(encoder, pipe_config,
3806 HDMI_INFOFRAME_TYPE_AVI,
3807 &pipe_config->infoframes.avi);
3808 intel_read_infoframe(encoder, pipe_config,
3809 HDMI_INFOFRAME_TYPE_SPD,
3810 &pipe_config->infoframes.spd);
3811 intel_read_infoframe(encoder, pipe_config,
3812 HDMI_INFOFRAME_TYPE_VENDOR,
3813 &pipe_config->infoframes.hdmi);
3814 intel_read_infoframe(encoder, pipe_config,
3815 HDMI_INFOFRAME_TYPE_DRM,
3816 &pipe_config->infoframes.drm);
3818 if (DISPLAY_VER(dev_priv) >= 8)
3819 bdw_get_trans_port_sync_config(pipe_config);
3821 intel_read_dp_sdp(encoder, pipe_config, HDMI_PACKET_TYPE_GAMUT_METADATA);
3822 intel_read_dp_sdp(encoder, pipe_config, DP_SDP_VSC);
3824 intel_psr_get_config(encoder, pipe_config);
3826 intel_audio_codec_get_config(encoder, pipe_config);
3829 void intel_ddi_get_clock(struct intel_encoder *encoder,
3830 struct intel_crtc_state *crtc_state,
3831 struct intel_shared_dpll *pll)
3833 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
3834 enum icl_port_dpll_id port_dpll_id = ICL_PORT_DPLL_DEFAULT;
3835 struct icl_port_dpll *port_dpll = &crtc_state->icl_port_dplls[port_dpll_id];
3838 if (drm_WARN_ON(&i915->drm, !pll))
3841 port_dpll->pll = pll;
3842 pll_active = intel_dpll_get_hw_state(i915, pll, &port_dpll->hw_state);
3843 drm_WARN_ON(&i915->drm, !pll_active);
3845 icl_set_active_port_dpll(crtc_state, port_dpll_id);
3847 crtc_state->port_clock = intel_dpll_get_freq(i915, crtc_state->shared_dpll,
3848 &crtc_state->dpll_hw_state);
3851 static void mtl_ddi_get_config(struct intel_encoder *encoder,
3852 struct intel_crtc_state *crtc_state)
3854 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
3855 enum phy phy = intel_port_to_phy(i915, encoder->port);
3856 struct intel_digital_port *dig_port = enc_to_dig_port(encoder);
3858 if (intel_tc_port_in_tbt_alt_mode(dig_port)) {
3859 crtc_state->port_clock = intel_mtl_tbt_calc_port_clock(encoder);
3860 } else if (intel_is_c10phy(i915, phy)) {
3861 intel_c10pll_readout_hw_state(encoder, &crtc_state->cx0pll_state.c10);
3862 intel_c10pll_dump_hw_state(i915, &crtc_state->cx0pll_state.c10);
3863 crtc_state->port_clock = intel_c10pll_calc_port_clock(encoder, &crtc_state->cx0pll_state.c10);
3865 intel_c20pll_readout_hw_state(encoder, &crtc_state->cx0pll_state.c20);
3866 intel_c20pll_dump_hw_state(i915, &crtc_state->cx0pll_state.c20);
3867 crtc_state->port_clock = intel_c20pll_calc_port_clock(encoder, &crtc_state->cx0pll_state.c20);
3870 intel_ddi_get_config(encoder, crtc_state);
3873 static void dg2_ddi_get_config(struct intel_encoder *encoder,
3874 struct intel_crtc_state *crtc_state)
3876 intel_mpllb_readout_hw_state(encoder, &crtc_state->mpllb_state);
3877 crtc_state->port_clock = intel_mpllb_calc_port_clock(encoder, &crtc_state->mpllb_state);
3879 intel_ddi_get_config(encoder, crtc_state);
3882 static void adls_ddi_get_config(struct intel_encoder *encoder,
3883 struct intel_crtc_state *crtc_state)
3885 intel_ddi_get_clock(encoder, crtc_state, adls_ddi_get_pll(encoder));
3886 intel_ddi_get_config(encoder, crtc_state);
3889 static void rkl_ddi_get_config(struct intel_encoder *encoder,
3890 struct intel_crtc_state *crtc_state)
3892 intel_ddi_get_clock(encoder, crtc_state, rkl_ddi_get_pll(encoder));
3893 intel_ddi_get_config(encoder, crtc_state);
3896 static void dg1_ddi_get_config(struct intel_encoder *encoder,
3897 struct intel_crtc_state *crtc_state)
3899 intel_ddi_get_clock(encoder, crtc_state, dg1_ddi_get_pll(encoder));
3900 intel_ddi_get_config(encoder, crtc_state);
3903 static void icl_ddi_combo_get_config(struct intel_encoder *encoder,
3904 struct intel_crtc_state *crtc_state)
3906 intel_ddi_get_clock(encoder, crtc_state, icl_ddi_combo_get_pll(encoder));
3907 intel_ddi_get_config(encoder, crtc_state);
3910 static bool icl_ddi_tc_pll_is_tbt(const struct intel_shared_dpll *pll)
3912 return pll->info->id == DPLL_ID_ICL_TBTPLL;
3915 static enum icl_port_dpll_id
3916 icl_ddi_tc_port_pll_type(struct intel_encoder *encoder,
3917 const struct intel_crtc_state *crtc_state)
3919 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
3920 const struct intel_shared_dpll *pll = crtc_state->shared_dpll;
3922 if (drm_WARN_ON(&i915->drm, !pll))
3923 return ICL_PORT_DPLL_DEFAULT;
3925 if (icl_ddi_tc_pll_is_tbt(pll))
3926 return ICL_PORT_DPLL_DEFAULT;
3928 return ICL_PORT_DPLL_MG_PHY;
3931 enum icl_port_dpll_id
3932 intel_ddi_port_pll_type(struct intel_encoder *encoder,
3933 const struct intel_crtc_state *crtc_state)
3935 if (!encoder->port_pll_type)
3936 return ICL_PORT_DPLL_DEFAULT;
3938 return encoder->port_pll_type(encoder, crtc_state);
3941 static void icl_ddi_tc_get_clock(struct intel_encoder *encoder,
3942 struct intel_crtc_state *crtc_state,
3943 struct intel_shared_dpll *pll)
3945 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
3946 enum icl_port_dpll_id port_dpll_id;
3947 struct icl_port_dpll *port_dpll;
3950 if (drm_WARN_ON(&i915->drm, !pll))
3953 if (icl_ddi_tc_pll_is_tbt(pll))
3954 port_dpll_id = ICL_PORT_DPLL_DEFAULT;
3956 port_dpll_id = ICL_PORT_DPLL_MG_PHY;
3958 port_dpll = &crtc_state->icl_port_dplls[port_dpll_id];
3960 port_dpll->pll = pll;
3961 pll_active = intel_dpll_get_hw_state(i915, pll, &port_dpll->hw_state);
3962 drm_WARN_ON(&i915->drm, !pll_active);
3964 icl_set_active_port_dpll(crtc_state, port_dpll_id);
3966 if (icl_ddi_tc_pll_is_tbt(crtc_state->shared_dpll))
3967 crtc_state->port_clock = icl_calc_tbt_pll_link(i915, encoder->port);
3969 crtc_state->port_clock = intel_dpll_get_freq(i915, crtc_state->shared_dpll,
3970 &crtc_state->dpll_hw_state);
3973 static void icl_ddi_tc_get_config(struct intel_encoder *encoder,
3974 struct intel_crtc_state *crtc_state)
3976 icl_ddi_tc_get_clock(encoder, crtc_state, icl_ddi_tc_get_pll(encoder));
3977 intel_ddi_get_config(encoder, crtc_state);
3980 static void bxt_ddi_get_config(struct intel_encoder *encoder,
3981 struct intel_crtc_state *crtc_state)
3983 intel_ddi_get_clock(encoder, crtc_state, bxt_ddi_get_pll(encoder));
3984 intel_ddi_get_config(encoder, crtc_state);
3987 static void skl_ddi_get_config(struct intel_encoder *encoder,
3988 struct intel_crtc_state *crtc_state)
3990 intel_ddi_get_clock(encoder, crtc_state, skl_ddi_get_pll(encoder));
3991 intel_ddi_get_config(encoder, crtc_state);
3994 void hsw_ddi_get_config(struct intel_encoder *encoder,
3995 struct intel_crtc_state *crtc_state)
3997 intel_ddi_get_clock(encoder, crtc_state, hsw_ddi_get_pll(encoder));
3998 intel_ddi_get_config(encoder, crtc_state);
4001 static void intel_ddi_sync_state(struct intel_encoder *encoder,
4002 const struct intel_crtc_state *crtc_state)
4004 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
4005 enum phy phy = intel_port_to_phy(i915, encoder->port);
4007 if (intel_phy_is_tc(i915, phy))
4008 intel_tc_port_sanitize_mode(enc_to_dig_port(encoder),
4011 if (crtc_state && intel_crtc_has_dp_encoder(crtc_state))
4012 intel_dp_sync_state(encoder, crtc_state);
4015 static bool intel_ddi_initial_fastset_check(struct intel_encoder *encoder,
4016 struct intel_crtc_state *crtc_state)
4018 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
4019 enum phy phy = intel_port_to_phy(i915, encoder->port);
4020 bool fastset = true;
4022 if (intel_phy_is_tc(i915, phy)) {
4023 drm_dbg_kms(&i915->drm, "[ENCODER:%d:%s] Forcing full modeset to compute TC port DPLLs\n",
4024 encoder->base.base.id, encoder->base.name);
4025 crtc_state->uapi.mode_changed = true;
4029 if (intel_crtc_has_dp_encoder(crtc_state) &&
4030 !intel_dp_initial_fastset_check(encoder, crtc_state))
4036 static enum intel_output_type
4037 intel_ddi_compute_output_type(struct intel_encoder *encoder,
4038 struct intel_crtc_state *crtc_state,
4039 struct drm_connector_state *conn_state)
4041 switch (conn_state->connector->connector_type) {
4042 case DRM_MODE_CONNECTOR_HDMIA:
4043 return INTEL_OUTPUT_HDMI;
4044 case DRM_MODE_CONNECTOR_eDP:
4045 return INTEL_OUTPUT_EDP;
4046 case DRM_MODE_CONNECTOR_DisplayPort:
4047 return INTEL_OUTPUT_DP;
4049 MISSING_CASE(conn_state->connector->connector_type);
4050 return INTEL_OUTPUT_UNUSED;
4054 static int intel_ddi_compute_config(struct intel_encoder *encoder,
4055 struct intel_crtc_state *pipe_config,
4056 struct drm_connector_state *conn_state)
4058 struct intel_crtc *crtc = to_intel_crtc(pipe_config->uapi.crtc);
4059 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
4060 enum port port = encoder->port;
4063 if (HAS_TRANSCODER(dev_priv, TRANSCODER_EDP) && port == PORT_A)
4064 pipe_config->cpu_transcoder = TRANSCODER_EDP;
4066 if (intel_crtc_has_type(pipe_config, INTEL_OUTPUT_HDMI)) {
4067 pipe_config->has_hdmi_sink =
4068 intel_hdmi_compute_has_hdmi_sink(encoder, pipe_config, conn_state);
4070 ret = intel_hdmi_compute_config(encoder, pipe_config, conn_state);
4072 ret = intel_dp_compute_config(encoder, pipe_config, conn_state);
4078 if (IS_HASWELL(dev_priv) && crtc->pipe == PIPE_A &&
4079 pipe_config->cpu_transcoder == TRANSCODER_EDP)
4080 pipe_config->pch_pfit.force_thru =
4081 pipe_config->pch_pfit.enabled ||
4082 pipe_config->crc_enabled;
4084 if (IS_GEMINILAKE(dev_priv) || IS_BROXTON(dev_priv))
4085 pipe_config->lane_lat_optim_mask =
4086 bxt_ddi_phy_calc_lane_lat_optim_mask(pipe_config->lane_count);
4088 intel_ddi_compute_min_voltage_level(dev_priv, pipe_config);
4093 static bool mode_equal(const struct drm_display_mode *mode1,
4094 const struct drm_display_mode *mode2)
4096 return drm_mode_match(mode1, mode2,
4097 DRM_MODE_MATCH_TIMINGS |
4098 DRM_MODE_MATCH_FLAGS |
4099 DRM_MODE_MATCH_3D_FLAGS) &&
4100 mode1->clock == mode2->clock; /* we want an exact match */
4103 static bool m_n_equal(const struct intel_link_m_n *m_n_1,
4104 const struct intel_link_m_n *m_n_2)
4106 return m_n_1->tu == m_n_2->tu &&
4107 m_n_1->data_m == m_n_2->data_m &&
4108 m_n_1->data_n == m_n_2->data_n &&
4109 m_n_1->link_m == m_n_2->link_m &&
4110 m_n_1->link_n == m_n_2->link_n;
4113 static bool crtcs_port_sync_compatible(const struct intel_crtc_state *crtc_state1,
4114 const struct intel_crtc_state *crtc_state2)
4116 return crtc_state1->hw.active && crtc_state2->hw.active &&
4117 crtc_state1->output_types == crtc_state2->output_types &&
4118 crtc_state1->output_format == crtc_state2->output_format &&
4119 crtc_state1->lane_count == crtc_state2->lane_count &&
4120 crtc_state1->port_clock == crtc_state2->port_clock &&
4121 mode_equal(&crtc_state1->hw.adjusted_mode,
4122 &crtc_state2->hw.adjusted_mode) &&
4123 m_n_equal(&crtc_state1->dp_m_n, &crtc_state2->dp_m_n);
4127 intel_ddi_port_sync_transcoders(const struct intel_crtc_state *ref_crtc_state,
4130 struct drm_connector *connector;
4131 const struct drm_connector_state *conn_state;
4132 struct drm_i915_private *dev_priv = to_i915(ref_crtc_state->uapi.crtc->dev);
4133 struct intel_atomic_state *state =
4134 to_intel_atomic_state(ref_crtc_state->uapi.state);
4139 * We don't enable port sync on BDW due to missing w/as and
4140 * due to not having adjusted the modeset sequence appropriately.
4142 if (DISPLAY_VER(dev_priv) < 9)
4145 if (!intel_crtc_has_type(ref_crtc_state, INTEL_OUTPUT_DP))
4148 for_each_new_connector_in_state(&state->base, connector, conn_state, i) {
4149 struct intel_crtc *crtc = to_intel_crtc(conn_state->crtc);
4150 const struct intel_crtc_state *crtc_state;
4155 if (!connector->has_tile ||
4156 connector->tile_group->id !=
4159 crtc_state = intel_atomic_get_new_crtc_state(state,
4161 if (!crtcs_port_sync_compatible(ref_crtc_state,
4164 transcoders |= BIT(crtc_state->cpu_transcoder);
4170 static int intel_ddi_compute_config_late(struct intel_encoder *encoder,
4171 struct intel_crtc_state *crtc_state,
4172 struct drm_connector_state *conn_state)
4174 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
4175 struct drm_connector *connector = conn_state->connector;
4176 u8 port_sync_transcoders = 0;
4178 drm_dbg_kms(&i915->drm, "[ENCODER:%d:%s] [CRTC:%d:%s]",
4179 encoder->base.base.id, encoder->base.name,
4180 crtc_state->uapi.crtc->base.id, crtc_state->uapi.crtc->name);
4182 if (connector->has_tile)
4183 port_sync_transcoders = intel_ddi_port_sync_transcoders(crtc_state,
4184 connector->tile_group->id);
4187 * EDP Transcoders cannot be ensalved
4188 * make them a master always when present
4190 if (port_sync_transcoders & BIT(TRANSCODER_EDP))
4191 crtc_state->master_transcoder = TRANSCODER_EDP;
4193 crtc_state->master_transcoder = ffs(port_sync_transcoders) - 1;
4195 if (crtc_state->master_transcoder == crtc_state->cpu_transcoder) {
4196 crtc_state->master_transcoder = INVALID_TRANSCODER;
4197 crtc_state->sync_mode_slaves_mask =
4198 port_sync_transcoders & ~BIT(crtc_state->cpu_transcoder);
4204 static void intel_ddi_encoder_destroy(struct drm_encoder *encoder)
4206 struct drm_i915_private *i915 = to_i915(encoder->dev);
4207 struct intel_digital_port *dig_port = enc_to_dig_port(to_intel_encoder(encoder));
4208 enum phy phy = intel_port_to_phy(i915, dig_port->base.port);
4210 intel_dp_encoder_flush_work(encoder);
4211 if (intel_phy_is_tc(i915, phy))
4212 intel_tc_port_cleanup(dig_port);
4213 intel_display_power_flush_work(i915);
4215 drm_encoder_cleanup(encoder);
4216 kfree(dig_port->hdcp_port_data.streams);
4220 static void intel_ddi_encoder_reset(struct drm_encoder *encoder)
4222 struct drm_i915_private *i915 = to_i915(encoder->dev);
4223 struct intel_dp *intel_dp = enc_to_intel_dp(to_intel_encoder(encoder));
4224 struct intel_digital_port *dig_port = enc_to_dig_port(to_intel_encoder(encoder));
4225 enum phy phy = intel_port_to_phy(i915, dig_port->base.port);
4227 intel_dp->reset_link_params = true;
4229 intel_pps_encoder_reset(intel_dp);
4231 if (intel_phy_is_tc(i915, phy))
4232 intel_tc_port_init_mode(dig_port);
4235 static int intel_ddi_encoder_late_register(struct drm_encoder *_encoder)
4237 struct intel_encoder *encoder = to_intel_encoder(_encoder);
4239 intel_tc_port_link_reset(enc_to_dig_port(encoder));
4244 static const struct drm_encoder_funcs intel_ddi_funcs = {
4245 .reset = intel_ddi_encoder_reset,
4246 .destroy = intel_ddi_encoder_destroy,
4247 .late_register = intel_ddi_encoder_late_register,
4250 static struct intel_connector *
4251 intel_ddi_init_dp_connector(struct intel_digital_port *dig_port)
4253 struct drm_i915_private *i915 = to_i915(dig_port->base.base.dev);
4254 struct intel_connector *connector;
4255 enum port port = dig_port->base.port;
4257 connector = intel_connector_alloc();
4261 dig_port->dp.output_reg = DDI_BUF_CTL(port);
4262 if (DISPLAY_VER(i915) >= 14)
4263 dig_port->dp.prepare_link_retrain = mtl_ddi_prepare_link_retrain;
4265 dig_port->dp.prepare_link_retrain = intel_ddi_prepare_link_retrain;
4266 dig_port->dp.set_link_train = intel_ddi_set_link_train;
4267 dig_port->dp.set_idle_link_train = intel_ddi_set_idle_link_train;
4269 dig_port->dp.voltage_max = intel_ddi_dp_voltage_max;
4270 dig_port->dp.preemph_max = intel_ddi_dp_preemph_max;
4272 if (!intel_dp_init_connector(dig_port, connector)) {
4277 if (dig_port->base.type == INTEL_OUTPUT_EDP) {
4278 struct drm_device *dev = dig_port->base.base.dev;
4279 struct drm_privacy_screen *privacy_screen;
4281 privacy_screen = drm_privacy_screen_get(dev->dev, NULL);
4282 if (!IS_ERR(privacy_screen)) {
4283 drm_connector_attach_privacy_screen_provider(&connector->base,
4285 } else if (PTR_ERR(privacy_screen) != -ENODEV) {
4286 drm_warn(dev, "Error getting privacy-screen\n");
4293 static int modeset_pipe(struct drm_crtc *crtc,
4294 struct drm_modeset_acquire_ctx *ctx)
4296 struct drm_atomic_state *state;
4297 struct drm_crtc_state *crtc_state;
4300 state = drm_atomic_state_alloc(crtc->dev);
4304 state->acquire_ctx = ctx;
4305 to_intel_atomic_state(state)->internal = true;
4307 crtc_state = drm_atomic_get_crtc_state(state, crtc);
4308 if (IS_ERR(crtc_state)) {
4309 ret = PTR_ERR(crtc_state);
4313 crtc_state->connectors_changed = true;
4315 ret = drm_atomic_commit(state);
4317 drm_atomic_state_put(state);
4322 static int intel_hdmi_reset_link(struct intel_encoder *encoder,
4323 struct drm_modeset_acquire_ctx *ctx)
4325 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
4326 struct intel_hdmi *hdmi = enc_to_intel_hdmi(encoder);
4327 struct intel_connector *connector = hdmi->attached_connector;
4328 struct i2c_adapter *adapter =
4329 intel_gmbus_get_adapter(dev_priv, hdmi->ddc_bus);
4330 struct drm_connector_state *conn_state;
4331 struct intel_crtc_state *crtc_state;
4332 struct intel_crtc *crtc;
4336 if (!connector || connector->base.status != connector_status_connected)
4339 ret = drm_modeset_lock(&dev_priv->drm.mode_config.connection_mutex,
4344 conn_state = connector->base.state;
4346 crtc = to_intel_crtc(conn_state->crtc);
4350 ret = drm_modeset_lock(&crtc->base.mutex, ctx);
4354 crtc_state = to_intel_crtc_state(crtc->base.state);
4356 drm_WARN_ON(&dev_priv->drm,
4357 !intel_crtc_has_type(crtc_state, INTEL_OUTPUT_HDMI));
4359 if (!crtc_state->hw.active)
4362 if (!crtc_state->hdmi_high_tmds_clock_ratio &&
4363 !crtc_state->hdmi_scrambling)
4366 if (conn_state->commit &&
4367 !try_wait_for_completion(&conn_state->commit->hw_done))
4370 ret = drm_scdc_readb(adapter, SCDC_TMDS_CONFIG, &config);
4372 drm_err(&dev_priv->drm, "[CONNECTOR:%d:%s] Failed to read TMDS config: %d\n",
4373 connector->base.base.id, connector->base.name, ret);
4377 if (!!(config & SCDC_TMDS_BIT_CLOCK_RATIO_BY_40) ==
4378 crtc_state->hdmi_high_tmds_clock_ratio &&
4379 !!(config & SCDC_SCRAMBLING_ENABLE) ==
4380 crtc_state->hdmi_scrambling)
4384 * HDMI 2.0 says that one should not send scrambled data
4385 * prior to configuring the sink scrambling, and that
4386 * TMDS clock/data transmission should be suspended when
4387 * changing the TMDS clock rate in the sink. So let's
4388 * just do a full modeset here, even though some sinks
4389 * would be perfectly happy if were to just reconfigure
4390 * the SCDC settings on the fly.
4392 return modeset_pipe(&crtc->base, ctx);
4395 static enum intel_hotplug_state
4396 intel_ddi_hotplug(struct intel_encoder *encoder,
4397 struct intel_connector *connector)
4399 struct drm_i915_private *i915 = to_i915(encoder->base.dev);
4400 struct intel_digital_port *dig_port = enc_to_dig_port(encoder);
4401 struct intel_dp *intel_dp = &dig_port->dp;
4402 enum phy phy = intel_port_to_phy(i915, encoder->port);
4403 bool is_tc = intel_phy_is_tc(i915, phy);
4404 struct drm_modeset_acquire_ctx ctx;
4405 enum intel_hotplug_state state;
4408 if (intel_dp->compliance.test_active &&
4409 intel_dp->compliance.test_type == DP_TEST_LINK_PHY_TEST_PATTERN) {
4410 intel_dp_phy_test(encoder);
4411 /* just do the PHY test and nothing else */
4412 return INTEL_HOTPLUG_UNCHANGED;
4415 state = intel_encoder_hotplug(encoder, connector);
4417 if (!intel_tc_port_link_reset(dig_port)) {
4418 intel_modeset_lock_ctx_retry(&ctx, NULL, 0, ret) {
4419 if (connector->base.connector_type == DRM_MODE_CONNECTOR_HDMIA)
4420 ret = intel_hdmi_reset_link(encoder, &ctx);
4422 ret = intel_dp_retrain_link(encoder, &ctx);
4425 drm_WARN_ON(encoder->base.dev, ret);
4429 * Unpowered type-c dongles can take some time to boot and be
4430 * responsible, so here giving some time to those dongles to power up
4431 * and then retrying the probe.
4433 * On many platforms the HDMI live state signal is known to be
4434 * unreliable, so we can't use it to detect if a sink is connected or
4435 * not. Instead we detect if it's connected based on whether we can
4436 * read the EDID or not. That in turn has a problem during disconnect,
4437 * since the HPD interrupt may be raised before the DDC lines get
4438 * disconnected (due to how the required length of DDC vs. HPD
4439 * connector pins are specified) and so we'll still be able to get a
4440 * valid EDID. To solve this schedule another detection cycle if this
4441 * time around we didn't detect any change in the sink's connection
4444 * Type-c connectors which get their HPD signal deasserted then
4445 * reasserted, without unplugging/replugging the sink from the
4446 * connector, introduce a delay until the AUX channel communication
4447 * becomes functional. Retry the detection for 5 seconds on type-c
4448 * connectors to account for this delay.
4450 if (state == INTEL_HOTPLUG_UNCHANGED &&
4451 connector->hotplug_retries < (is_tc ? 5 : 1) &&
4452 !dig_port->dp.is_mst)
4453 state = INTEL_HOTPLUG_RETRY;
4458 static bool lpt_digital_port_connected(struct intel_encoder *encoder)
4460 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
4461 u32 bit = dev_priv->display.hotplug.pch_hpd[encoder->hpd_pin];
4463 return intel_de_read(dev_priv, SDEISR) & bit;
4466 static bool hsw_digital_port_connected(struct intel_encoder *encoder)
4468 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
4469 u32 bit = dev_priv->display.hotplug.hpd[encoder->hpd_pin];
4471 return intel_de_read(dev_priv, DEISR) & bit;
4474 static bool bdw_digital_port_connected(struct intel_encoder *encoder)
4476 struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
4477 u32 bit = dev_priv->display.hotplug.hpd[encoder->hpd_pin];
4479 return intel_de_read(dev_priv, GEN8_DE_PORT_ISR) & bit;
4482 static struct intel_connector *
4483 intel_ddi_init_hdmi_connector(struct intel_digital_port *dig_port)
4485 struct intel_connector *connector;
4486 enum port port = dig_port->base.port;
4488 connector = intel_connector_alloc();
4492 dig_port->hdmi.hdmi_reg = DDI_BUF_CTL(port);
4493 intel_hdmi_init_connector(dig_port, connector);
4498 static bool intel_ddi_a_force_4_lanes(struct intel_digital_port *dig_port)
4500 struct drm_i915_private *dev_priv = to_i915(dig_port->base.base.dev);
4502 if (dig_port->base.port != PORT_A)
4505 if (dig_port->saved_port_bits & DDI_A_4_LANES)
4508 /* Broxton/Geminilake: Bspec says that DDI_A_4_LANES is the only
4509 * supported configuration
4511 if (IS_GEMINILAKE(dev_priv) || IS_BROXTON(dev_priv))
4518 intel_ddi_max_lanes(struct intel_digital_port *dig_port)
4520 struct drm_i915_private *dev_priv = to_i915(dig_port->base.base.dev);
4521 enum port port = dig_port->base.port;
4524 if (DISPLAY_VER(dev_priv) >= 11)
4527 if (port == PORT_A || port == PORT_E) {
4528 if (intel_de_read(dev_priv, DDI_BUF_CTL(PORT_A)) & DDI_A_4_LANES)
4529 max_lanes = port == PORT_A ? 4 : 0;
4531 /* Both A and E share 2 lanes */
4536 * Some BIOS might fail to set this bit on port A if eDP
4537 * wasn't lit up at boot. Force this bit set when needed
4538 * so we use the proper lane count for our calculations.
4540 if (intel_ddi_a_force_4_lanes(dig_port)) {
4541 drm_dbg_kms(&dev_priv->drm,
4542 "Forcing DDI_A_4_LANES for port A\n");
4543 dig_port->saved_port_bits |= DDI_A_4_LANES;
4550 static enum hpd_pin xelpd_hpd_pin(struct drm_i915_private *dev_priv,
4553 if (port >= PORT_D_XELPD)
4554 return HPD_PORT_D + port - PORT_D_XELPD;
4555 else if (port >= PORT_TC1)
4556 return HPD_PORT_TC1 + port - PORT_TC1;
4558 return HPD_PORT_A + port - PORT_A;
4561 static enum hpd_pin dg1_hpd_pin(struct drm_i915_private *dev_priv,
4564 if (port >= PORT_TC1)
4565 return HPD_PORT_C + port - PORT_TC1;
4567 return HPD_PORT_A + port - PORT_A;
4570 static enum hpd_pin tgl_hpd_pin(struct drm_i915_private *dev_priv,
4573 if (port >= PORT_TC1)
4574 return HPD_PORT_TC1 + port - PORT_TC1;
4576 return HPD_PORT_A + port - PORT_A;
4579 static enum hpd_pin rkl_hpd_pin(struct drm_i915_private *dev_priv,
4582 if (HAS_PCH_TGP(dev_priv))
4583 return tgl_hpd_pin(dev_priv, port);
4585 if (port >= PORT_TC1)
4586 return HPD_PORT_C + port - PORT_TC1;
4588 return HPD_PORT_A + port - PORT_A;
4591 static enum hpd_pin icl_hpd_pin(struct drm_i915_private *dev_priv,
4595 return HPD_PORT_TC1 + port - PORT_C;
4597 return HPD_PORT_A + port - PORT_A;
4600 static enum hpd_pin ehl_hpd_pin(struct drm_i915_private *dev_priv,
4606 if (HAS_PCH_TGP(dev_priv))
4607 return icl_hpd_pin(dev_priv, port);
4609 return HPD_PORT_A + port - PORT_A;
4612 static enum hpd_pin skl_hpd_pin(struct drm_i915_private *dev_priv, enum port port)
4614 if (HAS_PCH_TGP(dev_priv))
4615 return icl_hpd_pin(dev_priv, port);
4617 return HPD_PORT_A + port - PORT_A;
4620 static bool intel_ddi_is_tc(struct drm_i915_private *i915, enum port port)
4622 if (DISPLAY_VER(i915) >= 12)
4623 return port >= PORT_TC1;
4624 else if (DISPLAY_VER(i915) >= 11)
4625 return port >= PORT_C;
4630 static void intel_ddi_encoder_suspend(struct intel_encoder *encoder)
4632 intel_dp_encoder_suspend(encoder);
4635 static void intel_ddi_tc_encoder_suspend_complete(struct intel_encoder *encoder)
4637 struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
4638 struct intel_digital_port *dig_port = dp_to_dig_port(intel_dp);
4640 intel_tc_port_suspend(dig_port);
4643 static void intel_ddi_encoder_shutdown(struct intel_encoder *encoder)
4645 intel_dp_encoder_shutdown(encoder);
4646 intel_hdmi_encoder_shutdown(encoder);
4649 static void intel_ddi_tc_encoder_shutdown_complete(struct intel_encoder *encoder)
4651 struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
4652 struct intel_digital_port *dig_port = dp_to_dig_port(intel_dp);
4654 intel_tc_port_cleanup(dig_port);
4657 #define port_tc_name(port) ((port) - PORT_TC1 + '1')
4658 #define tc_port_name(tc_port) ((tc_port) - TC_PORT_1 + '1')
4660 void intel_ddi_init(struct drm_i915_private *dev_priv, enum port port)
4662 struct intel_digital_port *dig_port;
4663 struct intel_encoder *encoder;
4664 const struct intel_bios_encoder_data *devdata;
4665 bool init_hdmi, init_dp;
4666 enum phy phy = intel_port_to_phy(dev_priv, port);
4669 * On platforms with HTI (aka HDPORT), if it's enabled at boot it may
4670 * have taken over some of the PHYs and made them unavailable to the
4671 * driver. In that case we should skip initializing the corresponding
4674 if (intel_hti_uses_phy(dev_priv, phy)) {
4675 drm_dbg_kms(&dev_priv->drm, "PORT %c / PHY %c reserved by HTI\n",
4676 port_name(port), phy_name(phy));
4680 devdata = intel_bios_encoder_data_lookup(dev_priv, port);
4682 drm_dbg_kms(&dev_priv->drm,
4683 "VBT says port %c is not present\n",
4688 init_hdmi = intel_bios_encoder_supports_dvi(devdata) ||
4689 intel_bios_encoder_supports_hdmi(devdata);
4690 init_dp = intel_bios_encoder_supports_dp(devdata);
4692 if (intel_bios_encoder_is_lspcon(devdata)) {
4694 * Lspcon device needs to be driven with DP connector
4695 * with special detection sequence. So make sure DP
4696 * is initialized before lspcon.
4700 drm_dbg_kms(&dev_priv->drm, "VBT says port %c has lspcon\n",
4704 if (!init_dp && !init_hdmi) {
4705 drm_dbg_kms(&dev_priv->drm,
4706 "VBT says port %c is not DVI/HDMI/DP compatible, respect it\n",
4711 if (intel_phy_is_snps(dev_priv, phy) &&
4712 dev_priv->display.snps.phy_failed_calibration & BIT(phy)) {
4713 drm_dbg_kms(&dev_priv->drm,
4714 "SNPS PHY %c failed to calibrate, proceeding anyway\n",
4718 dig_port = kzalloc(sizeof(*dig_port), GFP_KERNEL);
4722 encoder = &dig_port->base;
4723 encoder->devdata = devdata;
4725 if (DISPLAY_VER(dev_priv) >= 13 && port >= PORT_D_XELPD) {
4726 drm_encoder_init(&dev_priv->drm, &encoder->base, &intel_ddi_funcs,
4727 DRM_MODE_ENCODER_TMDS,
4729 port_name(port - PORT_D_XELPD + PORT_D),
4731 } else if (DISPLAY_VER(dev_priv) >= 12) {
4732 enum tc_port tc_port = intel_port_to_tc(dev_priv, port);
4734 drm_encoder_init(&dev_priv->drm, &encoder->base, &intel_ddi_funcs,
4735 DRM_MODE_ENCODER_TMDS,
4736 "DDI %s%c/PHY %s%c",
4737 port >= PORT_TC1 ? "TC" : "",
4738 port >= PORT_TC1 ? port_tc_name(port) : port_name(port),
4739 tc_port != TC_PORT_NONE ? "TC" : "",
4740 tc_port != TC_PORT_NONE ? tc_port_name(tc_port) : phy_name(phy));
4741 } else if (DISPLAY_VER(dev_priv) >= 11) {
4742 enum tc_port tc_port = intel_port_to_tc(dev_priv, port);
4744 drm_encoder_init(&dev_priv->drm, &encoder->base, &intel_ddi_funcs,
4745 DRM_MODE_ENCODER_TMDS,
4746 "DDI %c%s/PHY %s%c",
4748 port >= PORT_C ? " (TC)" : "",
4749 tc_port != TC_PORT_NONE ? "TC" : "",
4750 tc_port != TC_PORT_NONE ? tc_port_name(tc_port) : phy_name(phy));
4752 drm_encoder_init(&dev_priv->drm, &encoder->base, &intel_ddi_funcs,
4753 DRM_MODE_ENCODER_TMDS,
4754 "DDI %c/PHY %c", port_name(port), phy_name(phy));
4757 mutex_init(&dig_port->hdcp_mutex);
4758 dig_port->num_hdcp_streams = 0;
4760 encoder->hotplug = intel_ddi_hotplug;
4761 encoder->compute_output_type = intel_ddi_compute_output_type;
4762 encoder->compute_config = intel_ddi_compute_config;
4763 encoder->compute_config_late = intel_ddi_compute_config_late;
4764 encoder->enable = intel_enable_ddi;
4765 encoder->pre_pll_enable = intel_ddi_pre_pll_enable;
4766 encoder->pre_enable = intel_ddi_pre_enable;
4767 encoder->disable = intel_disable_ddi;
4768 encoder->post_pll_disable = intel_ddi_post_pll_disable;
4769 encoder->post_disable = intel_ddi_post_disable;
4770 encoder->update_pipe = intel_ddi_update_pipe;
4771 encoder->get_hw_state = intel_ddi_get_hw_state;
4772 encoder->sync_state = intel_ddi_sync_state;
4773 encoder->initial_fastset_check = intel_ddi_initial_fastset_check;
4774 encoder->suspend = intel_ddi_encoder_suspend;
4775 encoder->shutdown = intel_ddi_encoder_shutdown;
4776 encoder->get_power_domains = intel_ddi_get_power_domains;
4778 encoder->type = INTEL_OUTPUT_DDI;
4779 encoder->power_domain = intel_display_power_ddi_lanes_domain(dev_priv, port);
4780 encoder->port = port;
4781 encoder->cloneable = 0;
4782 encoder->pipe_mask = ~0;
4784 if (DISPLAY_VER(dev_priv) >= 14) {
4785 encoder->enable_clock = intel_mtl_pll_enable;
4786 encoder->disable_clock = intel_mtl_pll_disable;
4787 encoder->port_pll_type = intel_mtl_port_pll_type;
4788 encoder->get_config = mtl_ddi_get_config;
4789 } else if (IS_DG2(dev_priv)) {
4790 encoder->enable_clock = intel_mpllb_enable;
4791 encoder->disable_clock = intel_mpllb_disable;
4792 encoder->get_config = dg2_ddi_get_config;
4793 } else if (IS_ALDERLAKE_S(dev_priv)) {
4794 encoder->enable_clock = adls_ddi_enable_clock;
4795 encoder->disable_clock = adls_ddi_disable_clock;
4796 encoder->is_clock_enabled = adls_ddi_is_clock_enabled;
4797 encoder->get_config = adls_ddi_get_config;
4798 } else if (IS_ROCKETLAKE(dev_priv)) {
4799 encoder->enable_clock = rkl_ddi_enable_clock;
4800 encoder->disable_clock = rkl_ddi_disable_clock;
4801 encoder->is_clock_enabled = rkl_ddi_is_clock_enabled;
4802 encoder->get_config = rkl_ddi_get_config;
4803 } else if (IS_DG1(dev_priv)) {
4804 encoder->enable_clock = dg1_ddi_enable_clock;
4805 encoder->disable_clock = dg1_ddi_disable_clock;
4806 encoder->is_clock_enabled = dg1_ddi_is_clock_enabled;
4807 encoder->get_config = dg1_ddi_get_config;
4808 } else if (IS_JSL_EHL(dev_priv)) {
4809 if (intel_ddi_is_tc(dev_priv, port)) {
4810 encoder->enable_clock = jsl_ddi_tc_enable_clock;
4811 encoder->disable_clock = jsl_ddi_tc_disable_clock;
4812 encoder->is_clock_enabled = jsl_ddi_tc_is_clock_enabled;
4813 encoder->port_pll_type = icl_ddi_tc_port_pll_type;
4814 encoder->get_config = icl_ddi_combo_get_config;
4816 encoder->enable_clock = icl_ddi_combo_enable_clock;
4817 encoder->disable_clock = icl_ddi_combo_disable_clock;
4818 encoder->is_clock_enabled = icl_ddi_combo_is_clock_enabled;
4819 encoder->get_config = icl_ddi_combo_get_config;
4821 } else if (DISPLAY_VER(dev_priv) >= 11) {
4822 if (intel_ddi_is_tc(dev_priv, port)) {
4823 encoder->enable_clock = icl_ddi_tc_enable_clock;
4824 encoder->disable_clock = icl_ddi_tc_disable_clock;
4825 encoder->is_clock_enabled = icl_ddi_tc_is_clock_enabled;
4826 encoder->port_pll_type = icl_ddi_tc_port_pll_type;
4827 encoder->get_config = icl_ddi_tc_get_config;
4829 encoder->enable_clock = icl_ddi_combo_enable_clock;
4830 encoder->disable_clock = icl_ddi_combo_disable_clock;
4831 encoder->is_clock_enabled = icl_ddi_combo_is_clock_enabled;
4832 encoder->get_config = icl_ddi_combo_get_config;
4834 } else if (IS_GEMINILAKE(dev_priv) || IS_BROXTON(dev_priv)) {
4835 /* BXT/GLK have fixed PLL->port mapping */
4836 encoder->get_config = bxt_ddi_get_config;
4837 } else if (DISPLAY_VER(dev_priv) == 9) {
4838 encoder->enable_clock = skl_ddi_enable_clock;
4839 encoder->disable_clock = skl_ddi_disable_clock;
4840 encoder->is_clock_enabled = skl_ddi_is_clock_enabled;
4841 encoder->get_config = skl_ddi_get_config;
4842 } else if (IS_BROADWELL(dev_priv) || IS_HASWELL(dev_priv)) {
4843 encoder->enable_clock = hsw_ddi_enable_clock;
4844 encoder->disable_clock = hsw_ddi_disable_clock;
4845 encoder->is_clock_enabled = hsw_ddi_is_clock_enabled;
4846 encoder->get_config = hsw_ddi_get_config;
4849 if (DISPLAY_VER(dev_priv) >= 14) {
4850 encoder->set_signal_levels = intel_cx0_phy_set_signal_levels;
4851 } else if (IS_DG2(dev_priv)) {
4852 encoder->set_signal_levels = intel_snps_phy_set_signal_levels;
4853 } else if (DISPLAY_VER(dev_priv) >= 12) {
4854 if (intel_phy_is_combo(dev_priv, phy))
4855 encoder->set_signal_levels = icl_combo_phy_set_signal_levels;
4857 encoder->set_signal_levels = tgl_dkl_phy_set_signal_levels;
4858 } else if (DISPLAY_VER(dev_priv) >= 11) {
4859 if (intel_phy_is_combo(dev_priv, phy))
4860 encoder->set_signal_levels = icl_combo_phy_set_signal_levels;
4862 encoder->set_signal_levels = icl_mg_phy_set_signal_levels;
4863 } else if (IS_GEMINILAKE(dev_priv) || IS_BROXTON(dev_priv)) {
4864 encoder->set_signal_levels = bxt_ddi_phy_set_signal_levels;
4866 encoder->set_signal_levels = hsw_set_signal_levels;
4869 intel_ddi_buf_trans_init(encoder);
4871 if (DISPLAY_VER(dev_priv) >= 13)
4872 encoder->hpd_pin = xelpd_hpd_pin(dev_priv, port);
4873 else if (IS_DG1(dev_priv))
4874 encoder->hpd_pin = dg1_hpd_pin(dev_priv, port);
4875 else if (IS_ROCKETLAKE(dev_priv))
4876 encoder->hpd_pin = rkl_hpd_pin(dev_priv, port);
4877 else if (DISPLAY_VER(dev_priv) >= 12)
4878 encoder->hpd_pin = tgl_hpd_pin(dev_priv, port);
4879 else if (IS_JSL_EHL(dev_priv))
4880 encoder->hpd_pin = ehl_hpd_pin(dev_priv, port);
4881 else if (DISPLAY_VER(dev_priv) == 11)
4882 encoder->hpd_pin = icl_hpd_pin(dev_priv, port);
4883 else if (DISPLAY_VER(dev_priv) == 9 && !IS_BROXTON(dev_priv))
4884 encoder->hpd_pin = skl_hpd_pin(dev_priv, port);
4886 encoder->hpd_pin = intel_hpd_pin_default(dev_priv, port);
4888 if (DISPLAY_VER(dev_priv) >= 11)
4889 dig_port->saved_port_bits =
4890 intel_de_read(dev_priv, DDI_BUF_CTL(port))
4891 & DDI_BUF_PORT_REVERSAL;
4893 dig_port->saved_port_bits =
4894 intel_de_read(dev_priv, DDI_BUF_CTL(port))
4895 & (DDI_BUF_PORT_REVERSAL | DDI_A_4_LANES);
4897 if (intel_bios_encoder_lane_reversal(devdata))
4898 dig_port->saved_port_bits |= DDI_BUF_PORT_REVERSAL;
4900 dig_port->dp.output_reg = INVALID_MMIO_REG;
4901 dig_port->max_lanes = intel_ddi_max_lanes(dig_port);
4902 dig_port->aux_ch = intel_dp_aux_ch(encoder);
4904 if (intel_phy_is_tc(dev_priv, phy)) {
4906 !intel_bios_encoder_supports_typec_usb(devdata) &&
4907 !intel_bios_encoder_supports_tbt(devdata);
4909 if (!is_legacy && init_hdmi) {
4910 is_legacy = !init_dp;
4912 drm_dbg_kms(&dev_priv->drm,
4913 "VBT says port %c is non-legacy TC and has HDMI (with DP: %s), assume it's %s\n",
4915 str_yes_no(init_dp),
4916 is_legacy ? "legacy" : "non-legacy");
4919 encoder->suspend_complete = intel_ddi_tc_encoder_suspend_complete;
4920 encoder->shutdown_complete = intel_ddi_tc_encoder_shutdown_complete;
4922 if (intel_tc_port_init(dig_port, is_legacy) < 0)
4926 drm_WARN_ON(&dev_priv->drm, port > PORT_I);
4927 dig_port->ddi_io_power_domain = intel_display_power_ddi_io_domain(dev_priv, port);
4929 if (DISPLAY_VER(dev_priv) >= 11) {
4930 if (intel_phy_is_tc(dev_priv, phy))
4931 dig_port->connected = intel_tc_port_connected;
4933 dig_port->connected = lpt_digital_port_connected;
4934 } else if (IS_GEMINILAKE(dev_priv) || IS_BROXTON(dev_priv)) {
4935 dig_port->connected = bdw_digital_port_connected;
4936 } else if (DISPLAY_VER(dev_priv) == 9) {
4937 dig_port->connected = lpt_digital_port_connected;
4938 } else if (IS_BROADWELL(dev_priv)) {
4940 dig_port->connected = bdw_digital_port_connected;
4942 dig_port->connected = lpt_digital_port_connected;
4943 } else if (IS_HASWELL(dev_priv)) {
4945 dig_port->connected = hsw_digital_port_connected;
4947 dig_port->connected = lpt_digital_port_connected;
4950 intel_infoframe_init(dig_port);
4953 if (!intel_ddi_init_dp_connector(dig_port))
4956 dig_port->hpd_pulse = intel_dp_hpd_pulse;
4958 if (dig_port->dp.mso_link_count)
4959 encoder->pipe_mask = intel_ddi_splitter_pipe_mask(dev_priv);
4963 * In theory we don't need the encoder->type check,
4964 * but leave it just in case we have some really bad VBTs...
4966 if (encoder->type != INTEL_OUTPUT_EDP && init_hdmi) {
4967 if (!intel_ddi_init_hdmi_connector(dig_port))
4974 drm_encoder_cleanup(&encoder->base);