Quelle  intel_ddi.c   Sprache: C

/*
 * Copyright © 2012 Intel Corporation
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 * IN THE SOFTWARE.
 *
 * Authors:
 *    Eugeni Dodonov <eugeni.dodonov@intel.com>
 *
 */

#include <linux/iopoll.h>
#include <linux/string_helpers.h>

#include <drm/display/drm_dp_helper.h>
#include <drm/display/drm_scdc_helper.h>
#include <drm/drm_print.h>
#include <drm/drm_privacy_screen_consumer.h>

#include "i915_reg.h"
#include "i915_utils.h"
#include "icl_dsi.h"
#include "intel_alpm.h"
#include "intel_audio.h"
#include "intel_audio_regs.h"
#include "intel_backlight.h"
#include "intel_combo_phy.h"
#include "intel_combo_phy_regs.h"
#include "intel_connector.h"
#include "intel_crtc.h"
#include "intel_cx0_phy.h"
#include "intel_cx0_phy_regs.h"
#include "intel_ddi.h"
#include "intel_ddi_buf_trans.h"
#include "intel_de.h"
#include "intel_display_power.h"
#include "intel_display_regs.h"
#include "intel_display_types.h"
#include "intel_dkl_phy.h"
#include "intel_dkl_phy_regs.h"
#include "intel_dp.h"
#include "intel_dp_aux.h"
#include "intel_dp_link_training.h"
#include "intel_dp_mst.h"
#include "intel_dp_test.h"
#include "intel_dp_tunnel.h"
#include "intel_dpio_phy.h"
#include "intel_dsi.h"
#include "intel_encoder.h"
#include "intel_fdi.h"
#include "intel_fifo_underrun.h"
#include "intel_gmbus.h"
#include "intel_hdcp.h"
#include "intel_hdmi.h"
#include "intel_hotplug.h"
#include "intel_hti.h"
#include "intel_lspcon.h"
#include "intel_mg_phy_regs.h"
#include "intel_modeset_lock.h"
#include "intel_panel.h"
#include "intel_pfit.h"
#include "intel_pps.h"
#include "intel_psr.h"
#include "intel_quirks.h"
#include "intel_snps_phy.h"
#include "intel_step.h"
#include "intel_tc.h"
#include "intel_vdsc.h"
#include "intel_vdsc_regs.h"
#include "intel_vrr.h"
#include "skl_scaler.h"
#include "skl_universal_plane.h"

static const u8 index_to_dp_signal_levels[] = {
 [0] = DP_TRAIN_VOLTAGE_SWING_LEVEL_0 | DP_TRAIN_PRE_EMPH_LEVEL_0,
 [1] = DP_TRAIN_VOLTAGE_SWING_LEVEL_0 | DP_TRAIN_PRE_EMPH_LEVEL_1,
 [2] = DP_TRAIN_VOLTAGE_SWING_LEVEL_0 | DP_TRAIN_PRE_EMPH_LEVEL_2,
 [3] = DP_TRAIN_VOLTAGE_SWING_LEVEL_0 | DP_TRAIN_PRE_EMPH_LEVEL_3,
 [4] = DP_TRAIN_VOLTAGE_SWING_LEVEL_1 | DP_TRAIN_PRE_EMPH_LEVEL_0,
 [5] = DP_TRAIN_VOLTAGE_SWING_LEVEL_1 | DP_TRAIN_PRE_EMPH_LEVEL_1,
 [6] = DP_TRAIN_VOLTAGE_SWING_LEVEL_1 | DP_TRAIN_PRE_EMPH_LEVEL_2,
 [7] = DP_TRAIN_VOLTAGE_SWING_LEVEL_2 | DP_TRAIN_PRE_EMPH_LEVEL_0,
 [8] = DP_TRAIN_VOLTAGE_SWING_LEVEL_2 | DP_TRAIN_PRE_EMPH_LEVEL_1,
 [9] = DP_TRAIN_VOLTAGE_SWING_LEVEL_3 | DP_TRAIN_PRE_EMPH_LEVEL_0,
};

static int intel_ddi_hdmi_level(struct intel_encoder *encoder,
    const struct intel_ddi_buf_trans *trans)
{
 int level;

 level = intel_bios_hdmi_level_shift(encoder->devdata);
 if (level < 0)
  level = trans->hdmi_default_entry;

 return level;
}

static bool has_buf_trans_select(struct intel_display *display)
{
 return DISPLAY_VER(display) < 10 && !display->platform.broxton;
}

static bool has_iboost(struct intel_display *display)
{
 return DISPLAY_VER(display) == 9 && !display->platform.broxton;
}

/*
 * Starting with Haswell, DDI port buffers must be programmed with correct
 * values in advance. This function programs the correct values for
 * DP/eDP/FDI use cases.
 */
void hsw_prepare_dp_ddi_buffers(struct intel_encoder *encoder,
    const struct intel_crtc_state *crtc_state)
{
 struct intel_display *display = to_intel_display(encoder);
 u32 iboost_bit = 0;
 int i, n_entries;
 enum port port = encoder->port;
 const struct intel_ddi_buf_trans *trans;

 trans = encoder->get_buf_trans(encoder, crtc_state, &n_entries);
 if (drm_WARN_ON_ONCE(display->drm, !trans))
  return;

 /* If we're boosting the current, set bit 31 of trans1 */
 if (has_iboost(display) &&
     intel_bios_dp_boost_level(encoder->devdata))
  iboost_bit = DDI_BUF_BALANCE_LEG_ENABLE;

 for (i = 0; i < n_entries; i++) {
  intel_de_write(display, DDI_BUF_TRANS_LO(port, i),
          trans->entries[i].hsw.trans1 | iboost_bit);
  intel_de_write(display, DDI_BUF_TRANS_HI(port, i),
          trans->entries[i].hsw.trans2);
 }
}

/*
 * Starting with Haswell, DDI port buffers must be programmed with correct
 * values in advance. This function programs the correct values for
 * HDMI/DVI use cases.
 */
static void hsw_prepare_hdmi_ddi_buffers(struct intel_encoder *encoder,
      const struct intel_crtc_state *crtc_state)
{
 struct intel_display *display = to_intel_display(encoder);
 int level = intel_ddi_level(encoder, crtc_state, 0);
 u32 iboost_bit = 0;
 int n_entries;
 enum port port = encoder->port;
 const struct intel_ddi_buf_trans *trans;

 trans = encoder->get_buf_trans(encoder, crtc_state, &n_entries);
 if (drm_WARN_ON_ONCE(display->drm, !trans))
  return;

 /* If we're boosting the current, set bit 31 of trans1 */
 if (has_iboost(display) &&
     intel_bios_hdmi_boost_level(encoder->devdata))
  iboost_bit = DDI_BUF_BALANCE_LEG_ENABLE;

 /* Entry 9 is for HDMI: */
 intel_de_write(display, DDI_BUF_TRANS_LO(port, 9),
         trans->entries[level].hsw.trans1 | iboost_bit);
 intel_de_write(display, DDI_BUF_TRANS_HI(port, 9),
         trans->entries[level].hsw.trans2);
}

static i915_reg_t intel_ddi_buf_status_reg(struct intel_display *display, enum port port)
{
 if (DISPLAY_VER(display) >= 14)
  return XELPDP_PORT_BUF_CTL1(display, port);
 else
  return DDI_BUF_CTL(port);
}

void intel_wait_ddi_buf_idle(struct intel_display *display, enum port port)
{
 /*
 * Bspec's platform specific timeouts:
 * MTL+   : 100 us
 * BXT    : fixed 16 us
 * HSW-ADL: 8 us
 *
 * FIXME: MTL requires 10 ms based on tests, find out why 100 us is too short
 */
 if (display->platform.broxton) {
  udelay(16);
  return;
 }

 static_assert(DDI_BUF_IS_IDLE == XELPDP_PORT_BUF_PHY_IDLE);
 if (intel_de_wait_for_set(display, intel_ddi_buf_status_reg(display, port),
      DDI_BUF_IS_IDLE, 10))
  drm_err(display->drm, "Timeout waiting for DDI BUF %c to get idle\n",
   port_name(port));
}

static void intel_wait_ddi_buf_active(struct intel_encoder *encoder)
{
 struct intel_display *display = to_intel_display(encoder);
 enum port port = encoder->port;

 /*
 * Bspec's platform specific timeouts:
 * MTL+             : 10000 us
 * DG2              : 1200 us
 * TGL-ADL combo PHY: 1000 us
 * TGL-ADL TypeC PHY: 3000 us
 * HSW-ICL          : fixed 518 us
 */
 if (DISPLAY_VER(display) < 10) {
  usleep_range(518, 1000);
  return;
 }

 static_assert(DDI_BUF_IS_IDLE == XELPDP_PORT_BUF_PHY_IDLE);
 if (intel_de_wait_for_clear(display, intel_ddi_buf_status_reg(display, port),
        DDI_BUF_IS_IDLE, 10))
  drm_err(display->drm, "Timeout waiting for DDI BUF %c to get active\n",
   port_name(port));
}

static u32 hsw_pll_to_ddi_pll_sel(const struct intel_dpll *pll)
{
 switch (pll->info->id) {
 case DPLL_ID_WRPLL1:
  return PORT_CLK_SEL_WRPLL1;
 case DPLL_ID_WRPLL2:
  return PORT_CLK_SEL_WRPLL2;
 case DPLL_ID_SPLL:
  return PORT_CLK_SEL_SPLL;
 case DPLL_ID_LCPLL_810:
  return PORT_CLK_SEL_LCPLL_810;
 case DPLL_ID_LCPLL_1350:
  return PORT_CLK_SEL_LCPLL_1350;
 case DPLL_ID_LCPLL_2700:
  return PORT_CLK_SEL_LCPLL_2700;
 default:
  MISSING_CASE(pll->info->id);
  return PORT_CLK_SEL_NONE;
 }
}

static u32 icl_pll_to_ddi_clk_sel(struct intel_encoder *encoder,
      const struct intel_crtc_state *crtc_state)
{
 const struct intel_dpll *pll = crtc_state->intel_dpll;
 int clock = crtc_state->port_clock;
 const enum intel_dpll_id id = pll->info->id;

 switch (id) {
 default:
  /*
 * DPLL_ID_ICL_DPLL0 and DPLL_ID_ICL_DPLL1 should not be used
 * here, so do warn if this get passed in
 */
  MISSING_CASE(id);
  return DDI_CLK_SEL_NONE;
 case DPLL_ID_ICL_TBTPLL:
  switch (clock) {
  case 162000:
   return DDI_CLK_SEL_TBT_162;
  case 270000:
   return DDI_CLK_SEL_TBT_270;
  case 540000:
   return DDI_CLK_SEL_TBT_540;
  case 810000:
   return DDI_CLK_SEL_TBT_810;
  default:
   MISSING_CASE(clock);
   return DDI_CLK_SEL_NONE;
  }
 case DPLL_ID_ICL_MGPLL1:
 case DPLL_ID_ICL_MGPLL2:
 case DPLL_ID_ICL_MGPLL3:
 case DPLL_ID_ICL_MGPLL4:
 case DPLL_ID_TGL_MGPLL5:
 case DPLL_ID_TGL_MGPLL6:
  return DDI_CLK_SEL_MG;
 }
}

static u32 ddi_buf_phy_link_rate(int port_clock)
{
 switch (port_clock) {
 case 162000:
  return DDI_BUF_PHY_LINK_RATE(0);
 case 216000:
  return DDI_BUF_PHY_LINK_RATE(4);
 case 243000:
  return DDI_BUF_PHY_LINK_RATE(5);
 case 270000:
  return DDI_BUF_PHY_LINK_RATE(1);
 case 324000:
  return DDI_BUF_PHY_LINK_RATE(6);
 case 432000:
  return DDI_BUF_PHY_LINK_RATE(7);
 case 540000:
  return DDI_BUF_PHY_LINK_RATE(2);
 case 810000:
  return DDI_BUF_PHY_LINK_RATE(3);
 default:
  MISSING_CASE(port_clock);
  return DDI_BUF_PHY_LINK_RATE(0);
 }
}

static int dp_phy_lane_stagger_delay(int port_clock)
{
 /*
 * Return the number of symbol clocks delay used to stagger the
 * assertion/desassertion of the port lane enables. The target delay
 * time is 100 ns or greater, return the number of symbols specific to
 * the provided port_clock (aka link clock) corresponding to this delay
 * time, i.e. so that
 *
 * number_of_symbols * duration_of_one_symbol >= 100 ns
 *
 * The delay must be applied only on TypeC DP outputs, for everything else
 * the delay must be set to 0.
 *
 * Return the number of link symbols per 100 ns:
 * port_clock (10 kHz) -> bits    / 100 us
 * / symbol_size       -> symbols / 100 us
 * / 1000              -> symbols / 100 ns
 */
 return DIV_ROUND_UP(port_clock, intel_dp_link_symbol_size(port_clock) * 1000);
}

static void intel_ddi_init_dp_buf_reg(struct intel_encoder *encoder,
          const struct intel_crtc_state *crtc_state)
{
 struct intel_display *display = to_intel_display(encoder);
 struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
 struct intel_digital_port *dig_port = enc_to_dig_port(encoder);

 /* DDI_BUF_CTL_ENABLE will be set by intel_ddi_prepare_link_retrain() later */
 intel_dp->DP = DDI_PORT_WIDTH(crtc_state->lane_count) |
  DDI_BUF_TRANS_SELECT(0);

 if (dig_port->lane_reversal)
  intel_dp->DP |= DDI_BUF_PORT_REVERSAL;
 if (dig_port->ddi_a_4_lanes)
  intel_dp->DP |= DDI_A_4_LANES;

 if (DISPLAY_VER(display) >= 14) {
  if (intel_dp_is_uhbr(crtc_state))
   intel_dp->DP |= DDI_BUF_PORT_DATA_40BIT;
  else
   intel_dp->DP |= DDI_BUF_PORT_DATA_10BIT;
 }

 if (display->platform.alderlake_p && intel_encoder_is_tc(encoder)) {
  intel_dp->DP |= ddi_buf_phy_link_rate(crtc_state->port_clock);
  if (!intel_tc_port_in_tbt_alt_mode(dig_port))
   intel_dp->DP |= DDI_BUF_CTL_TC_PHY_OWNERSHIP;
 }

 if (IS_DISPLAY_VER(display, 11, 13) && intel_encoder_is_tc(encoder)) {
  int delay = dp_phy_lane_stagger_delay(crtc_state->port_clock);

  intel_dp->DP |= DDI_BUF_LANE_STAGGER_DELAY(delay);
 }
}

static int icl_calc_tbt_pll_link(struct intel_display *display, enum port port)
{
 u32 val = intel_de_read(display, DDI_CLK_SEL(port)) & DDI_CLK_SEL_MASK;

 switch (val) {
 case DDI_CLK_SEL_NONE:
  return 0;
 case DDI_CLK_SEL_TBT_162:
  return 162000;
 case DDI_CLK_SEL_TBT_270:
  return 270000;
 case DDI_CLK_SEL_TBT_540:
  return 540000;
 case DDI_CLK_SEL_TBT_810:
  return 810000;
 default:
  MISSING_CASE(val);
  return 0;
 }
}

static void ddi_dotclock_get(struct intel_crtc_state *pipe_config)
{
 /* CRT dotclock is determined via other means */
 if (pipe_config->has_pch_encoder)
  return;

 pipe_config->hw.adjusted_mode.crtc_clock =
  intel_crtc_dotclock(pipe_config);
}

void intel_ddi_set_dp_msa(const struct intel_crtc_state *crtc_state,
     const struct drm_connector_state *conn_state)
{
 struct intel_display *display = to_intel_display(crtc_state);
 enum transcoder cpu_transcoder = crtc_state->cpu_transcoder;
 u32 temp;

 if (!intel_crtc_has_dp_encoder(crtc_state))
  return;

 drm_WARN_ON(display->drm, transcoder_is_dsi(cpu_transcoder));

 temp = DP_MSA_MISC_SYNC_CLOCK;

 switch (crtc_state->pipe_bpp) {
 case 18:
  temp |= DP_MSA_MISC_6_BPC;
  break;
 case 24:
  temp |= DP_MSA_MISC_8_BPC;
  break;
 case 30:
  temp |= DP_MSA_MISC_10_BPC;
  break;
 case 36:
  temp |= DP_MSA_MISC_12_BPC;
  break;
 default:
  MISSING_CASE(crtc_state->pipe_bpp);
  break;
 }

 /* nonsense combination */
 drm_WARN_ON(display->drm, crtc_state->limited_color_range &&
      crtc_state->output_format != INTEL_OUTPUT_FORMAT_RGB);

 if (crtc_state->limited_color_range)
  temp |= DP_MSA_MISC_COLOR_CEA_RGB;

 /*
 * As per DP 1.2 spec section 2.3.4.3 while sending
 * YCBCR 444 signals we should program MSA MISC1/0 fields with
 * colorspace information.
 */
 if (crtc_state->output_format == INTEL_OUTPUT_FORMAT_YCBCR444)
  temp |= DP_MSA_MISC_COLOR_YCBCR_444_BT709;

 /*
 * As per DP 1.4a spec section 2.2.4.3 [MSA Field for Indication
 * of Color Encoding Format and Content Color Gamut] while sending
 * YCBCR 420, HDR BT.2020 signals we should program MSA MISC1 fields
 * which indicate VSC SDP for the Pixel Encoding/Colorimetry Format.
 */
 if (intel_dp_needs_vsc_sdp(crtc_state, conn_state))
  temp |= DP_MSA_MISC_COLOR_VSC_SDP;

 intel_de_write(display, TRANS_MSA_MISC(display, cpu_transcoder),
         temp);
}

static u32 bdw_trans_port_sync_master_select(enum transcoder master_transcoder)
{
 if (master_transcoder == TRANSCODER_EDP)
  return 0;
 else
  return master_transcoder + 1;
}

static void
intel_ddi_config_transcoder_dp2(const struct intel_crtc_state *crtc_state,
    bool enable)
{
 struct intel_display *display = to_intel_display(crtc_state);
 enum transcoder cpu_transcoder = crtc_state->cpu_transcoder;
 u32 val = 0;

 if (!HAS_DP20(display))
  return;

 if (enable && intel_dp_is_uhbr(crtc_state))
  val = TRANS_DP2_128B132B_CHANNEL_CODING;

 intel_de_write(display, TRANS_DP2_CTL(cpu_transcoder), val);
}

/*
 * Returns the TRANS_DDI_FUNC_CTL value based on CRTC state.
 *
 * Only intended to be used by intel_ddi_enable_transcoder_func() and
 * intel_ddi_config_transcoder_func().
 */
static u32
intel_ddi_transcoder_func_reg_val_get(struct intel_encoder *encoder,
          const struct intel_crtc_state *crtc_state)
{
 struct intel_display *display = to_intel_display(crtc_state);
 struct intel_crtc *crtc = to_intel_crtc(crtc_state->uapi.crtc);
 enum pipe pipe = crtc->pipe;
 enum transcoder cpu_transcoder = crtc_state->cpu_transcoder;
 enum port port = encoder->port;
 u32 temp;

 /* Enable TRANS_DDI_FUNC_CTL for the pipe to work in HDMI mode */
 temp = TRANS_DDI_FUNC_ENABLE;
 if (DISPLAY_VER(display) >= 12)
  temp |= TGL_TRANS_DDI_SELECT_PORT(port);
 else
  temp |= TRANS_DDI_SELECT_PORT(port);

 switch (crtc_state->pipe_bpp) {
 default:
  MISSING_CASE(crtc_state->pipe_bpp);
  fallthrough;
 case 18:
  temp |= TRANS_DDI_BPC_6;
  break;
 case 24:
  temp |= TRANS_DDI_BPC_8;
  break;
 case 30:
  temp |= TRANS_DDI_BPC_10;
  break;
 case 36:
  temp |= TRANS_DDI_BPC_12;
  break;
 }

 if (crtc_state->hw.adjusted_mode.flags & DRM_MODE_FLAG_PVSYNC)
  temp |= TRANS_DDI_PVSYNC;
 if (crtc_state->hw.adjusted_mode.flags & DRM_MODE_FLAG_PHSYNC)
  temp |= TRANS_DDI_PHSYNC;

 if (cpu_transcoder == TRANSCODER_EDP) {
  switch (pipe) {
  default:
   MISSING_CASE(pipe);
   fallthrough;
  case PIPE_A:
   /* On Haswell, can only use the always-on power well for
 * eDP when not using the panel fitter, and when not
 * using motion blur mitigation (which we don't
 * support). */
   if (crtc_state->pch_pfit.force_thru)
    temp |= TRANS_DDI_EDP_INPUT_A_ONOFF;
   else
    temp |= TRANS_DDI_EDP_INPUT_A_ON;
   break;
  case PIPE_B:
   temp |= TRANS_DDI_EDP_INPUT_B_ONOFF;
   break;
  case PIPE_C:
   temp |= TRANS_DDI_EDP_INPUT_C_ONOFF;
   break;
  }
 }

 if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_HDMI)) {
  if (crtc_state->has_hdmi_sink)
   temp |= TRANS_DDI_MODE_SELECT_HDMI;
  else
   temp |= TRANS_DDI_MODE_SELECT_DVI;

  if (crtc_state->hdmi_scrambling)
   temp |= TRANS_DDI_HDMI_SCRAMBLING;
  if (crtc_state->hdmi_high_tmds_clock_ratio)
   temp |= TRANS_DDI_HIGH_TMDS_CHAR_RATE;
  if (DISPLAY_VER(display) >= 14)
   temp |= TRANS_DDI_PORT_WIDTH(crtc_state->lane_count);
 } else if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_ANALOG)) {
  temp |= TRANS_DDI_MODE_SELECT_FDI_OR_128B132B;
  temp |= (crtc_state->fdi_lanes - 1) << 1;
 } else if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_DP_MST) ||
     intel_dp_is_uhbr(crtc_state)) {
  if (intel_dp_is_uhbr(crtc_state))
   temp |= TRANS_DDI_MODE_SELECT_FDI_OR_128B132B;
  else
   temp |= TRANS_DDI_MODE_SELECT_DP_MST;
  temp |= DDI_PORT_WIDTH(crtc_state->lane_count);

  if (DISPLAY_VER(display) >= 12) {
   enum transcoder master;

   master = crtc_state->mst_master_transcoder;
   if (drm_WARN_ON(display->drm,
     master == INVALID_TRANSCODER))
    master = TRANSCODER_A;
   temp |= TRANS_DDI_MST_TRANSPORT_SELECT(master);
  }
 } else {
  temp |= TRANS_DDI_MODE_SELECT_DP_SST;
  temp |= DDI_PORT_WIDTH(crtc_state->lane_count);
 }

 if (IS_DISPLAY_VER(display, 8, 10) &&
     crtc_state->master_transcoder != INVALID_TRANSCODER) {
  u8 master_select =
   bdw_trans_port_sync_master_select(crtc_state->master_transcoder);

  temp |= TRANS_DDI_PORT_SYNC_ENABLE |
   TRANS_DDI_PORT_SYNC_MASTER_SELECT(master_select);
 }

 return temp;
}

void intel_ddi_enable_transcoder_func(struct intel_encoder *encoder,
          const struct intel_crtc_state *crtc_state)
{
 struct intel_display *display = to_intel_display(crtc_state);
 enum transcoder cpu_transcoder = crtc_state->cpu_transcoder;

 if (DISPLAY_VER(display) >= 11) {
  enum transcoder master_transcoder = crtc_state->master_transcoder;
  u32 ctl2 = 0;

  if (master_transcoder != INVALID_TRANSCODER) {
   u8 master_select =
    bdw_trans_port_sync_master_select(master_transcoder);

   ctl2 |= PORT_SYNC_MODE_ENABLE |
    PORT_SYNC_MODE_MASTER_SELECT(master_select);
  }

  intel_de_write(display,
          TRANS_DDI_FUNC_CTL2(display, cpu_transcoder),
          ctl2);
 }

 intel_de_write(display, TRANS_DDI_FUNC_CTL(display, cpu_transcoder),
         intel_ddi_transcoder_func_reg_val_get(encoder,
            crtc_state));
}

/*
 * Same as intel_ddi_enable_transcoder_func(), but it does not set the enable
 * bit for the DDI function and enables the DP2 configuration. Called for all
 * transcoder types.
 */
void
intel_ddi_config_transcoder_func(struct intel_encoder *encoder,
     const struct intel_crtc_state *crtc_state)
{
 struct intel_display *display = to_intel_display(crtc_state);
 enum transcoder cpu_transcoder = crtc_state->cpu_transcoder;
 u32 ctl;

 intel_ddi_config_transcoder_dp2(crtc_state, true);

 ctl = intel_ddi_transcoder_func_reg_val_get(encoder, crtc_state);
 ctl &= ~TRANS_DDI_FUNC_ENABLE;
 intel_de_write(display, TRANS_DDI_FUNC_CTL(display, cpu_transcoder),
         ctl);
}

/*
 * Disable the DDI function and port syncing.
 * For SST, pre-TGL MST, TGL+ MST-slave transcoders: deselect the DDI port,
 * SST/MST mode and disable the DP2 configuration. For TGL+ MST-master
 * transcoders these are done later in intel_ddi_post_disable_dp().
 */
void intel_ddi_disable_transcoder_func(const struct intel_crtc_state *crtc_state)
{
 struct intel_display *display = to_intel_display(crtc_state);
 struct intel_crtc *crtc = to_intel_crtc(crtc_state->uapi.crtc);
 enum transcoder cpu_transcoder = crtc_state->cpu_transcoder;
 u32 ctl;

 if (DISPLAY_VER(display) >= 11)
  intel_de_write(display,
          TRANS_DDI_FUNC_CTL2(display, cpu_transcoder),
          0);

 ctl = intel_de_read(display,
       TRANS_DDI_FUNC_CTL(display, cpu_transcoder));

 drm_WARN_ON(crtc->base.dev, ctl & TRANS_DDI_HDCP_SIGNALLING);

 ctl &= ~TRANS_DDI_FUNC_ENABLE;

 if (IS_DISPLAY_VER(display, 8, 10))
  ctl &= ~(TRANS_DDI_PORT_SYNC_ENABLE |
    TRANS_DDI_PORT_SYNC_MASTER_SELECT_MASK);

 if (DISPLAY_VER(display) >= 12) {
  if (!intel_dp_mst_is_master_trans(crtc_state)) {
   ctl &= ~(TGL_TRANS_DDI_PORT_MASK |
     TRANS_DDI_MODE_SELECT_MASK);
  }
 } else {
  ctl &= ~(TRANS_DDI_PORT_MASK | TRANS_DDI_MODE_SELECT_MASK);
 }

 intel_de_write(display, TRANS_DDI_FUNC_CTL(display, cpu_transcoder),
         ctl);

 if (intel_dp_mst_is_slave_trans(crtc_state))
  intel_ddi_config_transcoder_dp2(crtc_state, false);

 if (intel_has_quirk(display, QUIRK_INCREASE_DDI_DISABLED_TIME) &&
     intel_crtc_has_type(crtc_state, INTEL_OUTPUT_HDMI)) {
  drm_dbg_kms(display->drm, "Quirk Increase DDI disabled time\n");
  /* Quirk time at 100ms for reliable operation */
  msleep(100);
 }
}

int intel_ddi_toggle_hdcp_bits(struct intel_encoder *intel_encoder,
          enum transcoder cpu_transcoder,
          bool enable, u32 hdcp_mask)
{
 struct intel_display *display = to_intel_display(intel_encoder);
 intel_wakeref_t wakeref;
 int ret = 0;

 wakeref = intel_display_power_get_if_enabled(display,
           intel_encoder->power_domain);
 if (drm_WARN_ON(display->drm, !wakeref))
  return -ENXIO;

 intel_de_rmw(display, TRANS_DDI_FUNC_CTL(display, cpu_transcoder),
       hdcp_mask, enable ? hdcp_mask : 0);
 intel_display_power_put(display, intel_encoder->power_domain, wakeref);
 return ret;
}

bool intel_ddi_connector_get_hw_state(struct intel_connector *intel_connector)
{
 struct intel_display *display = to_intel_display(intel_connector);
 struct intel_encoder *encoder = intel_attached_encoder(intel_connector);
 int type = intel_connector->base.connector_type;
 enum port port = encoder->port;
 enum transcoder cpu_transcoder;
 intel_wakeref_t wakeref;
 enum pipe pipe = 0;
 u32 ddi_mode;
 bool ret;

 wakeref = intel_display_power_get_if_enabled(display,
           encoder->power_domain);
 if (!wakeref)
  return false;

 /* Note: This returns false for DP MST primary encoders. */
 if (!encoder->get_hw_state(encoder, &pipe)) {
  ret = false;
  goto out;
 }

 if (HAS_TRANSCODER(display, TRANSCODER_EDP) && port == PORT_A)
  cpu_transcoder = TRANSCODER_EDP;
 else
  cpu_transcoder = (enum transcoder) pipe;

 ddi_mode = intel_de_read(display, TRANS_DDI_FUNC_CTL(display, cpu_transcoder)) &
  TRANS_DDI_MODE_SELECT_MASK;

 if (ddi_mode == TRANS_DDI_MODE_SELECT_HDMI ||
     ddi_mode == TRANS_DDI_MODE_SELECT_DVI) {
  ret = type == DRM_MODE_CONNECTOR_HDMIA;
 } else if (ddi_mode == TRANS_DDI_MODE_SELECT_FDI_OR_128B132B && !HAS_DP20(display)) {
  ret = type == DRM_MODE_CONNECTOR_VGA;
 } else if (ddi_mode == TRANS_DDI_MODE_SELECT_DP_SST) {
  ret = type == DRM_MODE_CONNECTOR_eDP ||
   type == DRM_MODE_CONNECTOR_DisplayPort;
 } else if (ddi_mode == TRANS_DDI_MODE_SELECT_FDI_OR_128B132B && HAS_DP20(display)) {
  /*
 * encoder->get_hw_state() should have bailed out on MST. This
 * must be SST and non-eDP.
 */
  ret = type == DRM_MODE_CONNECTOR_DisplayPort;
 } else if (drm_WARN_ON(display->drm, ddi_mode == TRANS_DDI_MODE_SELECT_DP_MST)) {
  /* encoder->get_hw_state() should have bailed out on MST. */
  ret = false;
 } else {
  ret = false;
 }

out:
 intel_display_power_put(display, encoder->power_domain, wakeref);

 return ret;
}

static void intel_ddi_get_encoder_pipes(struct intel_encoder *encoder,
     u8 *pipe_mask, bool *is_dp_mst)
{
 struct intel_display *display = to_intel_display(encoder);
 enum port port = encoder->port;
 intel_wakeref_t wakeref;
 enum pipe p;
 u32 tmp;
 u8 mst_pipe_mask = 0, dp128b132b_pipe_mask = 0;

 *pipe_mask = 0;
 *is_dp_mst = false;

 wakeref = intel_display_power_get_if_enabled(display,
           encoder->power_domain);
 if (!wakeref)
  return;

 tmp = intel_de_read(display, DDI_BUF_CTL(port));
 if (!(tmp & DDI_BUF_CTL_ENABLE))
  goto out;

 if (HAS_TRANSCODER(display, TRANSCODER_EDP) && port == PORT_A) {
  tmp = intel_de_read(display,
        TRANS_DDI_FUNC_CTL(display, TRANSCODER_EDP));

  switch (tmp & TRANS_DDI_EDP_INPUT_MASK) {
  default:
   MISSING_CASE(tmp & TRANS_DDI_EDP_INPUT_MASK);
   fallthrough;
  case TRANS_DDI_EDP_INPUT_A_ON:
  case TRANS_DDI_EDP_INPUT_A_ONOFF:
   *pipe_mask = BIT(PIPE_A);
   break;
  case TRANS_DDI_EDP_INPUT_B_ONOFF:
   *pipe_mask = BIT(PIPE_B);
   break;
  case TRANS_DDI_EDP_INPUT_C_ONOFF:
   *pipe_mask = BIT(PIPE_C);
   break;
  }

  goto out;
 }

 for_each_pipe(display, p) {
  enum transcoder cpu_transcoder = (enum transcoder)p;
  u32 port_mask, ddi_select, ddi_mode;
  intel_wakeref_t trans_wakeref;

  trans_wakeref = intel_display_power_get_if_enabled(display,
           POWER_DOMAIN_TRANSCODER(cpu_transcoder));
  if (!trans_wakeref)
   continue;

  if (DISPLAY_VER(display) >= 12) {
   port_mask = TGL_TRANS_DDI_PORT_MASK;
   ddi_select = TGL_TRANS_DDI_SELECT_PORT(port);
  } else {
   port_mask = TRANS_DDI_PORT_MASK;
   ddi_select = TRANS_DDI_SELECT_PORT(port);
  }

  tmp = intel_de_read(display,
        TRANS_DDI_FUNC_CTL(display, cpu_transcoder));
  intel_display_power_put(display, POWER_DOMAIN_TRANSCODER(cpu_transcoder),
     trans_wakeref);

  if ((tmp & port_mask) != ddi_select)
   continue;

  ddi_mode = tmp & TRANS_DDI_MODE_SELECT_MASK;

  if (ddi_mode == TRANS_DDI_MODE_SELECT_DP_MST)
   mst_pipe_mask |= BIT(p);
  else if (ddi_mode == TRANS_DDI_MODE_SELECT_FDI_OR_128B132B && HAS_DP20(display))
   dp128b132b_pipe_mask |= BIT(p);

  *pipe_mask |= BIT(p);
 }

 if (!*pipe_mask)
  drm_dbg_kms(display->drm,
       "No pipe for [ENCODER:%d:%s] found\n",
       encoder->base.base.id, encoder->base.name);

 if (!mst_pipe_mask && dp128b132b_pipe_mask) {
  struct intel_dp *intel_dp = enc_to_intel_dp(encoder);

  /*
 * If we don't have 8b/10b MST, but have more than one
 * transcoder in 128b/132b mode, we know it must be 128b/132b
 * MST.
 *
 * Otherwise, we fall back to checking the current MST
 * state. It's not accurate for hardware takeover at probe, but
 * we don't expect MST to have been enabled at that point, and
 * can assume it's SST.
 */
  if (hweight8(dp128b132b_pipe_mask) > 1 ||
      intel_dp_mst_active_streams(intel_dp))
   mst_pipe_mask = dp128b132b_pipe_mask;
 }

 if (!mst_pipe_mask && hweight8(*pipe_mask) > 1) {
  drm_dbg_kms(display->drm,
       "Multiple pipes for [ENCODER:%d:%s] (pipe_mask %02x)\n",
       encoder->base.base.id, encoder->base.name,
       *pipe_mask);
  *pipe_mask = BIT(ffs(*pipe_mask) - 1);
 }

 if (mst_pipe_mask && mst_pipe_mask != *pipe_mask)
  drm_dbg_kms(display->drm,
       "Conflicting MST and non-MST state for [ENCODER:%d:%s] (pipe masks: all %02x, MST %02x, 128b/132b %02x)\n",
       encoder->base.base.id, encoder->base.name,
       *pipe_mask, mst_pipe_mask, dp128b132b_pipe_mask);
 else
  *is_dp_mst = mst_pipe_mask;

out:
 if (*pipe_mask && (display->platform.geminilake || display->platform.broxton)) {
  tmp = intel_de_read(display, BXT_PHY_CTL(port));
  if ((tmp & (BXT_PHY_CMNLANE_POWERDOWN_ACK |
       BXT_PHY_LANE_POWERDOWN_ACK |
       BXT_PHY_LANE_ENABLED)) != BXT_PHY_LANE_ENABLED)
   drm_err(display->drm,
    "[ENCODER:%d:%s] enabled but PHY powered down? (PHY_CTL %08x)\n",
    encoder->base.base.id, encoder->base.name, tmp);
 }

 intel_display_power_put(display, encoder->power_domain, wakeref);
}

bool intel_ddi_get_hw_state(struct intel_encoder *encoder,
       enum pipe *pipe)
{
 u8 pipe_mask;
 bool is_mst;

 intel_ddi_get_encoder_pipes(encoder, &pipe_mask, &is_mst);

 if (is_mst || !pipe_mask)
  return false;

 *pipe = ffs(pipe_mask) - 1;

 return true;
}

static enum intel_display_power_domain
intel_ddi_main_link_aux_domain(struct intel_digital_port *dig_port,
          const struct intel_crtc_state *crtc_state)
{
 struct intel_display *display = to_intel_display(dig_port);

 /*
 * ICL+ HW requires corresponding AUX IOs to be powered up for PSR with
 * DC states enabled at the same time, while for driver initiated AUX
 * transfers we need the same AUX IOs to be powered but with DC states
 * disabled. Accordingly use the AUX_IO_<port> power domain here which
 * leaves DC states enabled.
 *
 * Before MTL TypeC PHYs (in all TypeC modes and both DP/HDMI) also require
 * AUX IO to be enabled, but all these require DC_OFF to be enabled as
 * well, so we can acquire a wider AUX_<port> power domain reference
 * instead of a specific AUX_IO_<port> reference without powering up any
 * extra wells.
 */
 if (intel_psr_needs_aux_io_power(&dig_port->base, crtc_state))
  return intel_display_power_aux_io_domain(display, dig_port->aux_ch);
 else if (DISPLAY_VER(display) < 14 &&
   (intel_crtc_has_dp_encoder(crtc_state) ||
    intel_encoder_is_tc(&dig_port->base)))
  return intel_aux_power_domain(dig_port);
 else
  return POWER_DOMAIN_INVALID;
}

static void
main_link_aux_power_domain_get(struct intel_digital_port *dig_port,
          const struct intel_crtc_state *crtc_state)
{
 struct intel_display *display = to_intel_display(dig_port);
 enum intel_display_power_domain domain =
  intel_ddi_main_link_aux_domain(dig_port, crtc_state);

 drm_WARN_ON(display->drm, dig_port->aux_wakeref);

 if (domain == POWER_DOMAIN_INVALID)
  return;

 dig_port->aux_wakeref = intel_display_power_get(display, domain);
}

static void
main_link_aux_power_domain_put(struct intel_digital_port *dig_port,
          const struct intel_crtc_state *crtc_state)
{
 struct intel_display *display = to_intel_display(dig_port);
 enum intel_display_power_domain domain =
  intel_ddi_main_link_aux_domain(dig_port, crtc_state);
 intel_wakeref_t wf;

 wf = fetch_and_zero(&dig_port->aux_wakeref);
 if (!wf)
  return;

 intel_display_power_put(display, domain, wf);
}

static void intel_ddi_get_power_domains(struct intel_encoder *encoder,
     struct intel_crtc_state *crtc_state)
{
 struct intel_display *display = to_intel_display(encoder);
 struct intel_digital_port *dig_port;

 /*
 * TODO: Add support for MST encoders. Atm, the following should never
 * happen since fake-MST encoders don't set their get_power_domains()
 * hook.
 */
 if (drm_WARN_ON(display->drm,
   intel_crtc_has_type(crtc_state, INTEL_OUTPUT_DP_MST)))
  return;

 dig_port = enc_to_dig_port(encoder);

 if (!intel_tc_port_in_tbt_alt_mode(dig_port)) {
  drm_WARN_ON(display->drm, dig_port->ddi_io_wakeref);
  dig_port->ddi_io_wakeref = intel_display_power_get(display,
           dig_port->ddi_io_power_domain);
 }

 main_link_aux_power_domain_get(dig_port, crtc_state);
}

void intel_ddi_enable_transcoder_clock(struct intel_encoder *encoder,
           const struct intel_crtc_state *crtc_state)
{
 struct intel_display *display = to_intel_display(crtc_state);
 enum transcoder cpu_transcoder = crtc_state->cpu_transcoder;
 enum phy phy = intel_encoder_to_phy(encoder);
 u32 val;

 if (cpu_transcoder == TRANSCODER_EDP)
  return;

 if (DISPLAY_VER(display) >= 13)
  val = TGL_TRANS_CLK_SEL_PORT(phy);
 else if (DISPLAY_VER(display) >= 12)
  val = TGL_TRANS_CLK_SEL_PORT(encoder->port);
 else
  val = TRANS_CLK_SEL_PORT(encoder->port);

 intel_de_write(display, TRANS_CLK_SEL(cpu_transcoder), val);
}

void intel_ddi_disable_transcoder_clock(const struct intel_crtc_state *crtc_state)
{
 struct intel_display *display = to_intel_display(crtc_state);
 enum transcoder cpu_transcoder = crtc_state->cpu_transcoder;
 u32 val;

 if (cpu_transcoder == TRANSCODER_EDP)
  return;

 if (DISPLAY_VER(display) >= 12)
  val = TGL_TRANS_CLK_SEL_DISABLED;
 else
  val = TRANS_CLK_SEL_DISABLED;

 intel_de_write(display, TRANS_CLK_SEL(cpu_transcoder), val);
}

static void _skl_ddi_set_iboost(struct intel_display *display,
    enum port port, u8 iboost)
{
 u32 tmp;

 tmp = intel_de_read(display, DISPIO_CR_TX_BMU_CR0);
 tmp &= ~(BALANCE_LEG_MASK(port) | BALANCE_LEG_DISABLE(port));
 if (iboost)
  tmp |= iboost << BALANCE_LEG_SHIFT(port);
 else
  tmp |= BALANCE_LEG_DISABLE(port);
 intel_de_write(display, DISPIO_CR_TX_BMU_CR0, tmp);
}

static void skl_ddi_set_iboost(struct intel_encoder *encoder,
          const struct intel_crtc_state *crtc_state,
          int level)
{
 struct intel_display *display = to_intel_display(encoder);
 struct intel_digital_port *dig_port = enc_to_dig_port(encoder);
 u8 iboost;

 if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_HDMI))
  iboost = intel_bios_hdmi_boost_level(encoder->devdata);
 else
  iboost = intel_bios_dp_boost_level(encoder->devdata);

 if (iboost == 0) {
  const struct intel_ddi_buf_trans *trans;
  int n_entries;

  trans = encoder->get_buf_trans(encoder, crtc_state, &n_entries);
  if (drm_WARN_ON_ONCE(display->drm, !trans))
   return;

  iboost = trans->entries[level].hsw.i_boost;
 }

 /* Make sure that the requested I_boost is valid */
 if (iboost && iboost != 0x1 && iboost != 0x3 && iboost != 0x7) {
  drm_err(display->drm, "Invalid I_boost value %u\n", iboost);
  return;
 }

 _skl_ddi_set_iboost(display, encoder->port, iboost);

 if (encoder->port == PORT_A && dig_port->max_lanes == 4)
  _skl_ddi_set_iboost(display, PORT_E, iboost);
}

static u8 intel_ddi_dp_voltage_max(struct intel_dp *intel_dp,
       const struct intel_crtc_state *crtc_state)
{
 struct intel_display *display = to_intel_display(intel_dp);
 struct intel_encoder *encoder = &dp_to_dig_port(intel_dp)->base;
 int n_entries;

 encoder->get_buf_trans(encoder, crtc_state, &n_entries);

 if (drm_WARN_ON(display->drm, n_entries < 1))
  n_entries = 1;
 if (drm_WARN_ON(display->drm,
   n_entries > ARRAY_SIZE(index_to_dp_signal_levels)))
  n_entries = ARRAY_SIZE(index_to_dp_signal_levels);

 return index_to_dp_signal_levels[n_entries - 1] &
  DP_TRAIN_VOLTAGE_SWING_MASK;
}

/*
 * We assume that the full set of pre-emphasis values can be
 * used on all DDI platforms. Should that change we need to
 * rethink this code.
 */
static u8 intel_ddi_dp_preemph_max(struct intel_dp *intel_dp)
{
 return DP_TRAIN_PRE_EMPH_LEVEL_3;
}

static u32 icl_combo_phy_loadgen_select(const struct intel_crtc_state *crtc_state,
     int lane)
{
 if (crtc_state->port_clock > 600000)
  return 0;

 if (crtc_state->lane_count == 4)
  return lane >= 1 ? LOADGEN_SELECT : 0;
 else
  return lane == 1 || lane == 2 ? LOADGEN_SELECT : 0;
}

static void icl_ddi_combo_vswing_program(struct intel_encoder *encoder,
      const struct intel_crtc_state *crtc_state)
{
 struct intel_display *display = to_intel_display(encoder);
 const struct intel_ddi_buf_trans *trans;
 enum phy phy = intel_encoder_to_phy(encoder);
 int n_entries, ln;
 u32 val;

 trans = encoder->get_buf_trans(encoder, crtc_state, &n_entries);
 if (drm_WARN_ON_ONCE(display->drm, !trans))
  return;

 if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_EDP)) {
  struct intel_dp *intel_dp = enc_to_intel_dp(encoder);

  val = EDP4K2K_MODE_OVRD_EN | EDP4K2K_MODE_OVRD_OPTIMIZED;
  intel_dp->hobl_active = is_hobl_buf_trans(trans);
  intel_de_rmw(display, ICL_PORT_CL_DW10(phy), val,
        intel_dp->hobl_active ? val : 0);
 }

 /* Set PORT_TX_DW5 */
 val = intel_de_read(display, ICL_PORT_TX_DW5_LN(0, phy));
 val &= ~(SCALING_MODE_SEL_MASK | RTERM_SELECT_MASK |
   COEFF_POLARITY | CURSOR_PROGRAM |
   TAP2_DISABLE | TAP3_DISABLE);
 val |= SCALING_MODE_SEL(0x2);
 val |= RTERM_SELECT(0x6);
 val |= TAP3_DISABLE;
 intel_de_write(display, ICL_PORT_TX_DW5_GRP(phy), val);

 /* Program PORT_TX_DW2 */
 for (ln = 0; ln < 4; ln++) {
  int level = intel_ddi_level(encoder, crtc_state, ln);

  intel_de_rmw(display, ICL_PORT_TX_DW2_LN(ln, phy),
        SWING_SEL_UPPER_MASK | SWING_SEL_LOWER_MASK | RCOMP_SCALAR_MASK,
        SWING_SEL_UPPER(trans->entries[level].icl.dw2_swing_sel) |
        SWING_SEL_LOWER(trans->entries[level].icl.dw2_swing_sel) |
        RCOMP_SCALAR(0x98));
 }

 /* Program PORT_TX_DW4 */
 /* We cannot write to GRP. It would overwrite individual loadgen. */
 for (ln = 0; ln < 4; ln++) {
  int level = intel_ddi_level(encoder, crtc_state, ln);

  intel_de_rmw(display, ICL_PORT_TX_DW4_LN(ln, phy),
        POST_CURSOR_1_MASK | POST_CURSOR_2_MASK | CURSOR_COEFF_MASK,
        POST_CURSOR_1(trans->entries[level].icl.dw4_post_cursor_1) |
        POST_CURSOR_2(trans->entries[level].icl.dw4_post_cursor_2) |
        CURSOR_COEFF(trans->entries[level].icl.dw4_cursor_coeff));
 }

 /* Program PORT_TX_DW7 */
 for (ln = 0; ln < 4; ln++) {
  int level = intel_ddi_level(encoder, crtc_state, ln);

  intel_de_rmw(display, ICL_PORT_TX_DW7_LN(ln, phy),
        N_SCALAR_MASK,
        N_SCALAR(trans->entries[level].icl.dw7_n_scalar));
 }
}

static void icl_combo_phy_set_signal_levels(struct intel_encoder *encoder,
         const struct intel_crtc_state *crtc_state)
{
 struct intel_display *display = to_intel_display(encoder);
 enum phy phy = intel_encoder_to_phy(encoder);
 u32 val;
 int ln;

 /*
 * 1. If port type is eDP or DP,
 * set PORT_PCS_DW1 cmnkeeper_enable to 1b,
 * else clear to 0b.
 */
 val = intel_de_read(display, ICL_PORT_PCS_DW1_LN(0, phy));
 if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_HDMI))
  val &= ~COMMON_KEEPER_EN;
 else
  val |= COMMON_KEEPER_EN;
 intel_de_write(display, ICL_PORT_PCS_DW1_GRP(phy), val);

 /* 2. Program loadgen select */
 /*
 * Program PORT_TX_DW4 depending on Bit rate and used lanes
 * <= 6 GHz and 4 lanes (LN0=0, LN1=1, LN2=1, LN3=1)
 * <= 6 GHz and 1,2 lanes (LN0=0, LN1=1, LN2=1, LN3=0)
 * > 6 GHz (LN0=0, LN1=0, LN2=0, LN3=0)
 */
 for (ln = 0; ln < 4; ln++) {
  intel_de_rmw(display, ICL_PORT_TX_DW4_LN(ln, phy),
        LOADGEN_SELECT,
        icl_combo_phy_loadgen_select(crtc_state, ln));
 }

 /* 3. Set PORT_CL_DW5 SUS Clock Config to 11b */
 intel_de_rmw(display, ICL_PORT_CL_DW5(phy),
       0, SUS_CLOCK_CONFIG);

 /* 4. Clear training enable to change swing values */
 val = intel_de_read(display, ICL_PORT_TX_DW5_LN(0, phy));
 val &= ~TX_TRAINING_EN;
 intel_de_write(display, ICL_PORT_TX_DW5_GRP(phy), val);

 /* 5. Program swing and de-emphasis */
 icl_ddi_combo_vswing_program(encoder, crtc_state);

 /* 6. Set training enable to trigger update */
 val = intel_de_read(display, ICL_PORT_TX_DW5_LN(0, phy));
 val |= TX_TRAINING_EN;
 intel_de_write(display, ICL_PORT_TX_DW5_GRP(phy), val);
}

static void icl_mg_phy_set_signal_levels(struct intel_encoder *encoder,
      const struct intel_crtc_state *crtc_state)
{
 struct intel_display *display = to_intel_display(encoder);
 enum tc_port tc_port = intel_encoder_to_tc(encoder);
 const struct intel_ddi_buf_trans *trans;
 int n_entries, ln;

 if (intel_tc_port_in_tbt_alt_mode(enc_to_dig_port(encoder)))
  return;

 trans = encoder->get_buf_trans(encoder, crtc_state, &n_entries);
 if (drm_WARN_ON_ONCE(display->drm, !trans))
  return;

 for (ln = 0; ln < 2; ln++) {
  intel_de_rmw(display, MG_TX1_LINK_PARAMS(ln, tc_port),
        CRI_USE_FS32, 0);
  intel_de_rmw(display, MG_TX2_LINK_PARAMS(ln, tc_port),
        CRI_USE_FS32, 0);
 }

 /* Program MG_TX_SWINGCTRL with values from vswing table */
 for (ln = 0; ln < 2; ln++) {
  int level;

  level = intel_ddi_level(encoder, crtc_state, 2*ln+0);

  intel_de_rmw(display, MG_TX1_SWINGCTRL(ln, tc_port),
        CRI_TXDEEMPH_OVERRIDE_17_12_MASK,
        CRI_TXDEEMPH_OVERRIDE_17_12(trans->entries[level].mg.cri_txdeemph_override_17_12));

  level = intel_ddi_level(encoder, crtc_state, 2*ln+1);

  intel_de_rmw(display, MG_TX2_SWINGCTRL(ln, tc_port),
        CRI_TXDEEMPH_OVERRIDE_17_12_MASK,
        CRI_TXDEEMPH_OVERRIDE_17_12(trans->entries[level].mg.cri_txdeemph_override_17_12));
 }

 /* Program MG_TX_DRVCTRL with values from vswing table */
 for (ln = 0; ln < 2; ln++) {
  int level;

  level = intel_ddi_level(encoder, crtc_state, 2*ln+0);

  intel_de_rmw(display, MG_TX1_DRVCTRL(ln, tc_port),
        CRI_TXDEEMPH_OVERRIDE_11_6_MASK |
        CRI_TXDEEMPH_OVERRIDE_5_0_MASK,
        CRI_TXDEEMPH_OVERRIDE_11_6(trans->entries[level].mg.cri_txdeemph_override_11_6) |
        CRI_TXDEEMPH_OVERRIDE_5_0(trans->entries[level].mg.cri_txdeemph_override_5_0) |
        CRI_TXDEEMPH_OVERRIDE_EN);

  level = intel_ddi_level(encoder, crtc_state, 2*ln+1);

  intel_de_rmw(display, MG_TX2_DRVCTRL(ln, tc_port),
        CRI_TXDEEMPH_OVERRIDE_11_6_MASK |
        CRI_TXDEEMPH_OVERRIDE_5_0_MASK,
        CRI_TXDEEMPH_OVERRIDE_11_6(trans->entries[level].mg.cri_txdeemph_override_11_6) |
        CRI_TXDEEMPH_OVERRIDE_5_0(trans->entries[level].mg.cri_txdeemph_override_5_0) |
        CRI_TXDEEMPH_OVERRIDE_EN);

  /* FIXME: Program CRI_LOADGEN_SEL after the spec is updated */
 }

 /*
 * Program MG_CLKHUB<LN, port being used> with value from frequency table
 * In case of Legacy mode on MG PHY, both TX1 and TX2 enabled so use the
 * values from table for which TX1 and TX2 enabled.
 */
 for (ln = 0; ln < 2; ln++) {
  intel_de_rmw(display, MG_CLKHUB(ln, tc_port),
        CFG_LOW_RATE_LKREN_EN,
        crtc_state->port_clock < 300000 ? CFG_LOW_RATE_LKREN_EN : 0);
 }

 /* Program the MG_TX_DCC<LN, port being used> based on the link frequency */
 for (ln = 0; ln < 2; ln++) {
  intel_de_rmw(display, MG_TX1_DCC(ln, tc_port),
        CFG_AMI_CK_DIV_OVERRIDE_VAL_MASK |
        CFG_AMI_CK_DIV_OVERRIDE_EN,
        crtc_state->port_clock > 500000 ?
        CFG_AMI_CK_DIV_OVERRIDE_VAL(1) |
        CFG_AMI_CK_DIV_OVERRIDE_EN : 0);

  intel_de_rmw(display, MG_TX2_DCC(ln, tc_port),
        CFG_AMI_CK_DIV_OVERRIDE_VAL_MASK |
        CFG_AMI_CK_DIV_OVERRIDE_EN,
        crtc_state->port_clock > 500000 ?
        CFG_AMI_CK_DIV_OVERRIDE_VAL(1) |
        CFG_AMI_CK_DIV_OVERRIDE_EN : 0);
 }

 /* Program MG_TX_PISO_READLOAD with values from vswing table */
 for (ln = 0; ln < 2; ln++) {
  intel_de_rmw(display, MG_TX1_PISO_READLOAD(ln, tc_port),
        0, CRI_CALCINIT);
  intel_de_rmw(display, MG_TX2_PISO_READLOAD(ln, tc_port),
        0, CRI_CALCINIT);
 }
}

static void tgl_dkl_phy_set_signal_levels(struct intel_encoder *encoder,
       const struct intel_crtc_state *crtc_state)
{
 struct intel_display *display = to_intel_display(encoder);
 enum tc_port tc_port = intel_encoder_to_tc(encoder);
 const struct intel_ddi_buf_trans *trans;
 int n_entries, ln;

 if (intel_tc_port_in_tbt_alt_mode(enc_to_dig_port(encoder)))
  return;

 trans = encoder->get_buf_trans(encoder, crtc_state, &n_entries);
 if (drm_WARN_ON_ONCE(display->drm, !trans))
  return;

 for (ln = 0; ln < 2; ln++) {
  int level;

  /* Wa_16011342517:adl-p */
  if (display->platform.alderlake_p &&
      IS_DISPLAY_STEP(display, STEP_A0, STEP_D0)) {
   if ((intel_encoder_is_hdmi(encoder) &&
        crtc_state->port_clock == 594000) ||
        (intel_encoder_is_dp(encoder) &&
         crtc_state->port_clock == 162000)) {
    intel_dkl_phy_rmw(display, DKL_TX_DPCNTL2(tc_port, ln),
        LOADGEN_SHARING_PMD_DISABLE, 1);
   } else {
    intel_dkl_phy_rmw(display, DKL_TX_DPCNTL2(tc_port, ln),
        LOADGEN_SHARING_PMD_DISABLE, 0);
   }
  }

  intel_dkl_phy_write(display, DKL_TX_PMD_LANE_SUS(tc_port, ln), 0);

  level = intel_ddi_level(encoder, crtc_state, 2*ln+0);

  intel_dkl_phy_rmw(display, DKL_TX_DPCNTL0(tc_port, ln),
      DKL_TX_PRESHOOT_COEFF_MASK |
      DKL_TX_DE_EMPAHSIS_COEFF_MASK |
      DKL_TX_VSWING_CONTROL_MASK,
      DKL_TX_PRESHOOT_COEFF(trans->entries[level].dkl.preshoot) |
      DKL_TX_DE_EMPHASIS_COEFF(trans->entries[level].dkl.de_emphasis) |
      DKL_TX_VSWING_CONTROL(trans->entries[level].dkl.vswing));

  level = intel_ddi_level(encoder, crtc_state, 2*ln+1);

  intel_dkl_phy_rmw(display, DKL_TX_DPCNTL1(tc_port, ln),
      DKL_TX_PRESHOOT_COEFF_MASK |
      DKL_TX_DE_EMPAHSIS_COEFF_MASK |
      DKL_TX_VSWING_CONTROL_MASK,
      DKL_TX_PRESHOOT_COEFF(trans->entries[level].dkl.preshoot) |
      DKL_TX_DE_EMPHASIS_COEFF(trans->entries[level].dkl.de_emphasis) |
      DKL_TX_VSWING_CONTROL(trans->entries[level].dkl.vswing));

  intel_dkl_phy_rmw(display, DKL_TX_DPCNTL2(tc_port, ln),
      DKL_TX_DP20BITMODE, 0);

  if (display->platform.alderlake_p) {
   u32 val;

   if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_HDMI)) {
    if (ln == 0) {
     val = DKL_TX_DPCNTL2_CFG_LOADGENSELECT_TX1(0);
     val |= DKL_TX_DPCNTL2_CFG_LOADGENSELECT_TX2(2);
    } else {
     val = DKL_TX_DPCNTL2_CFG_LOADGENSELECT_TX1(3);
     val |= DKL_TX_DPCNTL2_CFG_LOADGENSELECT_TX2(3);
    }
   } else {
    val = DKL_TX_DPCNTL2_CFG_LOADGENSELECT_TX1(0);
    val |= DKL_TX_DPCNTL2_CFG_LOADGENSELECT_TX2(0);
   }

   intel_dkl_phy_rmw(display, DKL_TX_DPCNTL2(tc_port, ln),
       DKL_TX_DPCNTL2_CFG_LOADGENSELECT_TX1_MASK |
       DKL_TX_DPCNTL2_CFG_LOADGENSELECT_TX2_MASK,
       val);
  }
 }
}

static int translate_signal_level(struct intel_dp *intel_dp,
      u8 signal_levels)
{
 struct intel_display *display = to_intel_display(intel_dp);
 int i;

 for (i = 0; i < ARRAY_SIZE(index_to_dp_signal_levels); i++) {
  if (index_to_dp_signal_levels[i] == signal_levels)
   return i;
 }

 drm_WARN(display->drm, 1,
   "Unsupported voltage swing/pre-emphasis level: 0x%x\n",
   signal_levels);

 return 0;
}

static int intel_ddi_dp_level(struct intel_dp *intel_dp,
         const struct intel_crtc_state *crtc_state,
         int lane)
{
 u8 train_set = intel_dp->train_set[lane];

 if (intel_dp_is_uhbr(crtc_state)) {
  return train_set & DP_TX_FFE_PRESET_VALUE_MASK;
 } else {
  u8 signal_levels = train_set & (DP_TRAIN_VOLTAGE_SWING_MASK |
      DP_TRAIN_PRE_EMPHASIS_MASK);

  return translate_signal_level(intel_dp, signal_levels);
 }
}

int intel_ddi_level(struct intel_encoder *encoder,
      const struct intel_crtc_state *crtc_state,
      int lane)
{
 struct intel_display *display = to_intel_display(encoder);
 const struct intel_ddi_buf_trans *trans;
 int level, n_entries;

 trans = encoder->get_buf_trans(encoder, crtc_state, &n_entries);
 if (drm_WARN_ON_ONCE(display->drm, !trans))
  return 0;

 if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_HDMI))
  level = intel_ddi_hdmi_level(encoder, trans);
 else
  level = intel_ddi_dp_level(enc_to_intel_dp(encoder), crtc_state,
        lane);

 if (drm_WARN_ON_ONCE(display->drm, level >= n_entries))
  level = n_entries - 1;

 return level;
}

static void
hsw_set_signal_levels(struct intel_encoder *encoder,
        const struct intel_crtc_state *crtc_state)
{
 struct intel_display *display = to_intel_display(encoder);
 struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
 int level = intel_ddi_level(encoder, crtc_state, 0);
 enum port port = encoder->port;
 u32 signal_levels;

 if (has_iboost(display))
  skl_ddi_set_iboost(encoder, crtc_state, level);

 /* HDMI ignores the rest */
 if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_HDMI))
  return;

 signal_levels = DDI_BUF_TRANS_SELECT(level);

 drm_dbg_kms(display->drm, "Using signal levels %08x\n",
      signal_levels);

 intel_dp->DP &= ~DDI_BUF_EMP_MASK;
 intel_dp->DP |= signal_levels;

 intel_de_write(display, DDI_BUF_CTL(port), intel_dp->DP);
 intel_de_posting_read(display, DDI_BUF_CTL(port));
}

static void _icl_ddi_enable_clock(struct intel_display *display, i915_reg_t reg,
      u32 clk_sel_mask, u32 clk_sel, u32 clk_off)
{
 mutex_lock(&display->dpll.lock);

 intel_de_rmw(display, reg, clk_sel_mask, clk_sel);

 /*
 * "This step and the step before must be
 *  done with separate register writes."
 */
 intel_de_rmw(display, reg, clk_off, 0);

 mutex_unlock(&display->dpll.lock);
}

static void _icl_ddi_disable_clock(struct intel_display *display, i915_reg_t reg,
       u32 clk_off)
{
 mutex_lock(&display->dpll.lock);

 intel_de_rmw(display, reg, 0, clk_off);

 mutex_unlock(&display->dpll.lock);
}

static bool _icl_ddi_is_clock_enabled(struct intel_display *display, i915_reg_t reg,
          u32 clk_off)
{
 return !(intel_de_read(display, reg) & clk_off);
}

static struct intel_dpll *
_icl_ddi_get_pll(struct intel_display *display, i915_reg_t reg,
   u32 clk_sel_mask, u32 clk_sel_shift)
{
 enum intel_dpll_id id;

 id = (intel_de_read(display, reg) & clk_sel_mask) >> clk_sel_shift;

 return intel_get_dpll_by_id(display, id);
}

static void adls_ddi_enable_clock(struct intel_encoder *encoder,
      const struct intel_crtc_state *crtc_state)
{
 struct intel_display *display = to_intel_display(encoder);
 const struct intel_dpll *pll = crtc_state->intel_dpll;
 enum phy phy = intel_encoder_to_phy(encoder);

 if (drm_WARN_ON(display->drm, !pll))
  return;

 _icl_ddi_enable_clock(display, ADLS_DPCLKA_CFGCR(phy),
         ADLS_DPCLKA_CFGCR_DDI_CLK_SEL_MASK(phy),
         pll->info->id << ADLS_DPCLKA_CFGCR_DDI_SHIFT(phy),
         ICL_DPCLKA_CFGCR0_DDI_CLK_OFF(phy));
}

static void adls_ddi_disable_clock(struct intel_encoder *encoder)
{
 struct intel_display *display = to_intel_display(encoder);
 enum phy phy = intel_encoder_to_phy(encoder);

 _icl_ddi_disable_clock(display, ADLS_DPCLKA_CFGCR(phy),
          ICL_DPCLKA_CFGCR0_DDI_CLK_OFF(phy));
}

static bool adls_ddi_is_clock_enabled(struct intel_encoder *encoder)
{
 struct intel_display *display = to_intel_display(encoder);
 enum phy phy = intel_encoder_to_phy(encoder);

 return _icl_ddi_is_clock_enabled(display, ADLS_DPCLKA_CFGCR(phy),
      ICL_DPCLKA_CFGCR0_DDI_CLK_OFF(phy));
}

static struct intel_dpll *adls_ddi_get_pll(struct intel_encoder *encoder)
{
 struct intel_display *display = to_intel_display(encoder);
 enum phy phy = intel_encoder_to_phy(encoder);

 return _icl_ddi_get_pll(display, ADLS_DPCLKA_CFGCR(phy),
    ADLS_DPCLKA_CFGCR_DDI_CLK_SEL_MASK(phy),
    ADLS_DPCLKA_CFGCR_DDI_SHIFT(phy));
}

static void rkl_ddi_enable_clock(struct intel_encoder *encoder,
     const struct intel_crtc_state *crtc_state)
{
 struct intel_display *display = to_intel_display(encoder);
 const struct intel_dpll *pll = crtc_state->intel_dpll;
 enum phy phy = intel_encoder_to_phy(encoder);

 if (drm_WARN_ON(display->drm, !pll))
  return;

 _icl_ddi_enable_clock(display, ICL_DPCLKA_CFGCR0,
         RKL_DPCLKA_CFGCR0_DDI_CLK_SEL_MASK(phy),
         RKL_DPCLKA_CFGCR0_DDI_CLK_SEL(pll->info->id, phy),
         RKL_DPCLKA_CFGCR0_DDI_CLK_OFF(phy));
}

static void rkl_ddi_disable_clock(struct intel_encoder *encoder)
{
 struct intel_display *display = to_intel_display(encoder);
 enum phy phy = intel_encoder_to_phy(encoder);

 _icl_ddi_disable_clock(display, ICL_DPCLKA_CFGCR0,
          RKL_DPCLKA_CFGCR0_DDI_CLK_OFF(phy));
}

static bool rkl_ddi_is_clock_enabled(struct intel_encoder *encoder)
{
 struct intel_display *display = to_intel_display(encoder);
 enum phy phy = intel_encoder_to_phy(encoder);

 return _icl_ddi_is_clock_enabled(display, ICL_DPCLKA_CFGCR0,
      RKL_DPCLKA_CFGCR0_DDI_CLK_OFF(phy));
}

static struct intel_dpll *rkl_ddi_get_pll(struct intel_encoder *encoder)
{
 struct intel_display *display = to_intel_display(encoder);
 enum phy phy = intel_encoder_to_phy(encoder);

 return _icl_ddi_get_pll(display, ICL_DPCLKA_CFGCR0,
    RKL_DPCLKA_CFGCR0_DDI_CLK_SEL_MASK(phy),
    RKL_DPCLKA_CFGCR0_DDI_CLK_SEL_SHIFT(phy));
}

static void dg1_ddi_enable_clock(struct intel_encoder *encoder,
     const struct intel_crtc_state *crtc_state)
{
 struct intel_display *display = to_intel_display(encoder);
 const struct intel_dpll *pll = crtc_state->intel_dpll;
 enum phy phy = intel_encoder_to_phy(encoder);

 if (drm_WARN_ON(display->drm, !pll))
  return;

 /*
 * If we fail this, something went very wrong: first 2 PLLs should be
 * used by first 2 phys and last 2 PLLs by last phys
 */
 if (drm_WARN_ON(display->drm,
   (pll->info->id < DPLL_ID_DG1_DPLL2 && phy >= PHY_C) ||
   (pll->info->id >= DPLL_ID_DG1_DPLL2 && phy < PHY_C)))
  return;

 _icl_ddi_enable_clock(display, DG1_DPCLKA_CFGCR0(phy),
         DG1_DPCLKA_CFGCR0_DDI_CLK_SEL_MASK(phy),
         DG1_DPCLKA_CFGCR0_DDI_CLK_SEL(pll->info->id, phy),
         DG1_DPCLKA_CFGCR0_DDI_CLK_OFF(phy));
}

static void dg1_ddi_disable_clock(struct intel_encoder *encoder)
{
 struct intel_display *display = to_intel_display(encoder);
 enum phy phy = intel_encoder_to_phy(encoder);

 _icl_ddi_disable_clock(display, DG1_DPCLKA_CFGCR0(phy),
          DG1_DPCLKA_CFGCR0_DDI_CLK_OFF(phy));
}

static bool dg1_ddi_is_clock_enabled(struct intel_encoder *encoder)
{
 struct intel_display *display = to_intel_display(encoder);
 enum phy phy = intel_encoder_to_phy(encoder);

 return _icl_ddi_is_clock_enabled(display, DG1_DPCLKA_CFGCR0(phy),
      DG1_DPCLKA_CFGCR0_DDI_CLK_OFF(phy));
}

static struct intel_dpll *dg1_ddi_get_pll(struct intel_encoder *encoder)
{
 struct intel_display *display = to_intel_display(encoder);
 enum phy phy = intel_encoder_to_phy(encoder);
 enum intel_dpll_id id;
 u32 val;

 val = intel_de_read(display, DG1_DPCLKA_CFGCR0(phy));
 val &= DG1_DPCLKA_CFGCR0_DDI_CLK_SEL_MASK(phy);
 val >>= DG1_DPCLKA_CFGCR0_DDI_CLK_SEL_SHIFT(phy);
 id = val;

 /*
 * _DG1_DPCLKA0_CFGCR0 maps between DPLL 0 and 1 with one bit for phy A
 * and B while _DG1_DPCLKA1_CFGCR0 maps between DPLL 2 and 3 with one
 * bit for phy C and D.
 */
 if (phy >= PHY_C)
  id += DPLL_ID_DG1_DPLL2;

 return intel_get_dpll_by_id(display, id);
}

static void icl_ddi_combo_enable_clock(struct intel_encoder *encoder,
           const struct intel_crtc_state *crtc_state)
{
 struct intel_display *display = to_intel_display(encoder);
 const struct intel_dpll *pll = crtc_state->intel_dpll;
 enum phy phy = intel_encoder_to_phy(encoder);

 if (drm_WARN_ON(display->drm, !pll))
  return;

 _icl_ddi_enable_clock(display, ICL_DPCLKA_CFGCR0,
         ICL_DPCLKA_CFGCR0_DDI_CLK_SEL_MASK(phy),
         ICL_DPCLKA_CFGCR0_DDI_CLK_SEL(pll->info->id, phy),
         ICL_DPCLKA_CFGCR0_DDI_CLK_OFF(phy));
}

static void icl_ddi_combo_disable_clock(struct intel_encoder *encoder)
{
 struct intel_display *display = to_intel_display(encoder);
 enum phy phy = intel_encoder_to_phy(encoder);

 _icl_ddi_disable_clock(display, ICL_DPCLKA_CFGCR0,
          ICL_DPCLKA_CFGCR0_DDI_CLK_OFF(phy));
}

static bool icl_ddi_combo_is_clock_enabled(struct intel_encoder *encoder)
{
 struct intel_display *display = to_intel_display(encoder);
 enum phy phy = intel_encoder_to_phy(encoder);

 return _icl_ddi_is_clock_enabled(display, ICL_DPCLKA_CFGCR0,
      ICL_DPCLKA_CFGCR0_DDI_CLK_OFF(phy));
}

struct intel_dpll *icl_ddi_combo_get_pll(struct intel_encoder *encoder)
{
 struct intel_display *display = to_intel_display(encoder);
 enum phy phy = intel_encoder_to_phy(encoder);

 return _icl_ddi_get_pll(display, ICL_DPCLKA_CFGCR0,
    ICL_DPCLKA_CFGCR0_DDI_CLK_SEL_MASK(phy),
    ICL_DPCLKA_CFGCR0_DDI_CLK_SEL_SHIFT(phy));
}

static void jsl_ddi_tc_enable_clock(struct intel_encoder *encoder,
        const struct intel_crtc_state *crtc_state)
{
 struct intel_display *display = to_intel_display(encoder);
 const struct intel_dpll *pll = crtc_state->intel_dpll;
 enum port port = encoder->port;

 if (drm_WARN_ON(display->drm, !pll))
  return;

 /*
 * "For DDIC and DDID, program DDI_CLK_SEL to map the MG clock to the port.
 *  MG does not exist, but the programming is required to ungate DDIC and DDID."
 */
 intel_de_write(display, DDI_CLK_SEL(port), DDI_CLK_SEL_MG);

 icl_ddi_combo_enable_clock(encoder, crtc_state);
}

static void jsl_ddi_tc_disable_clock(struct intel_encoder *encoder)
{
 struct intel_display *display = to_intel_display(encoder);
 enum port port = encoder->port;

 icl_ddi_combo_disable_clock(encoder);

 intel_de_write(display, DDI_CLK_SEL(port), DDI_CLK_SEL_NONE);
}

static bool jsl_ddi_tc_is_clock_enabled(struct intel_encoder *encoder)
{
 struct intel_display *display = to_intel_display(encoder);
 enum port port = encoder->port;
 u32 tmp;

 tmp = intel_de_read(display, DDI_CLK_SEL(port));

 if ((tmp & DDI_CLK_SEL_MASK) == DDI_CLK_SEL_NONE)
  return false;

 return icl_ddi_combo_is_clock_enabled(encoder);
}

static void icl_ddi_tc_enable_clock(struct intel_encoder *encoder,
        const struct intel_crtc_state *crtc_state)
{
 struct intel_display *display = to_intel_display(encoder);
 const struct intel_dpll *pll = crtc_state->intel_dpll;
 enum tc_port tc_port = intel_encoder_to_tc(encoder);
 enum port port = encoder->port;

 if (drm_WARN_ON(display->drm, !pll))
  return;

 intel_de_write(display, DDI_CLK_SEL(port),
         icl_pll_to_ddi_clk_sel(encoder, crtc_state));

 mutex_lock(&display->dpll.lock);

 intel_de_rmw(display, ICL_DPCLKA_CFGCR0,
       ICL_DPCLKA_CFGCR0_TC_CLK_OFF(tc_port), 0);

 mutex_unlock(&display->dpll.lock);
}

static void icl_ddi_tc_disable_clock(struct intel_encoder *encoder)
{
 struct intel_display *display = to_intel_display(encoder);
 enum tc_port tc_port = intel_encoder_to_tc(encoder);
 enum port port = encoder->port;

 mutex_lock(&display->dpll.lock);

 intel_de_rmw(display, ICL_DPCLKA_CFGCR0,
       0, ICL_DPCLKA_CFGCR0_TC_CLK_OFF(tc_port));

 mutex_unlock(&display->dpll.lock);

 intel_de_write(display, DDI_CLK_SEL(port), DDI_CLK_SEL_NONE);
}

static bool icl_ddi_tc_is_clock_enabled(struct intel_encoder *encoder)
{
 struct intel_display *display = to_intel_display(encoder);
 enum tc_port tc_port = intel_encoder_to_tc(encoder);
 enum port port = encoder->port;
 u32 tmp;

 tmp = intel_de_read(display, DDI_CLK_SEL(port));

 if ((tmp & DDI_CLK_SEL_MASK) == DDI_CLK_SEL_NONE)
  return false;

 tmp = intel_de_read(display, ICL_DPCLKA_CFGCR0);

 return !(tmp & ICL_DPCLKA_CFGCR0_TC_CLK_OFF(tc_port));
}

static struct intel_dpll *icl_ddi_tc_get_pll(struct intel_encoder *encoder)
{
 struct intel_display *display = to_intel_display(encoder);
 enum tc_port tc_port = intel_encoder_to_tc(encoder);
 enum port port = encoder->port;
 enum intel_dpll_id id;
 u32 tmp;

 tmp = intel_de_read(display, DDI_CLK_SEL(port));

 switch (tmp & DDI_CLK_SEL_MASK) {
 case DDI_CLK_SEL_TBT_162:
 case DDI_CLK_SEL_TBT_270:
 case DDI_CLK_SEL_TBT_540:
 case DDI_CLK_SEL_TBT_810:
  id = DPLL_ID_ICL_TBTPLL;
  break;
 case DDI_CLK_SEL_MG:
  id = icl_tc_port_to_pll_id(tc_port);
  break;
 default:
  MISSING_CASE(tmp);
  fallthrough;
 case DDI_CLK_SEL_NONE:
  return NULL;
 }

 return intel_get_dpll_by_id(display, id);
}

static struct intel_dpll *bxt_ddi_get_pll(struct intel_encoder *encoder)
{
 struct intel_display *display = to_intel_display(encoder->base.dev);
 enum intel_dpll_id id;

 switch (encoder->port) {
 case PORT_A:
  id = DPLL_ID_SKL_DPLL0;
  break;
 case PORT_B:
  id = DPLL_ID_SKL_DPLL1;
  break;
 case PORT_C:
  id = DPLL_ID_SKL_DPLL2;
  break;
 default:
  MISSING_CASE(encoder->port);
  return NULL;
 }

 return intel_get_dpll_by_id(display, id);
}

static void skl_ddi_enable_clock(struct intel_encoder *encoder,
     const struct intel_crtc_state *crtc_state)
{
 struct intel_display *display = to_intel_display(encoder);
 const struct intel_dpll *pll = crtc_state->intel_dpll;
 enum port port = encoder->port;

 if (drm_WARN_ON(display->drm, !pll))
  return;

 mutex_lock(&display->dpll.lock);

 intel_de_rmw(display, DPLL_CTRL2,
       DPLL_CTRL2_DDI_CLK_OFF(port) |
       DPLL_CTRL2_DDI_CLK_SEL_MASK(port),
       DPLL_CTRL2_DDI_CLK_SEL(pll->info->id, port) |
       DPLL_CTRL2_DDI_SEL_OVERRIDE(port));

 mutex_unlock(&display->dpll.lock);
}

static void skl_ddi_disable_clock(struct intel_encoder *encoder)
{
 struct intel_display *display = to_intel_display(encoder);
 enum port port = encoder->port;

 mutex_lock(&display->dpll.lock);

 intel_de_rmw(display, DPLL_CTRL2,
       0, DPLL_CTRL2_DDI_CLK_OFF(port));

 mutex_unlock(&display->dpll.lock);
}

static bool skl_ddi_is_clock_enabled(struct intel_encoder *encoder)
{
 struct intel_display *display = to_intel_display(encoder);
 enum port port = encoder->port;

 /*
 * FIXME Not sure if the override affects both
 * the PLL selection and the CLK_OFF bit.
 */
 return !(intel_de_read(display, DPLL_CTRL2) & DPLL_CTRL2_DDI_CLK_OFF(port));
}

static struct intel_dpll *skl_ddi_get_pll(struct intel_encoder *encoder)
{
 struct intel_display *display = to_intel_display(encoder);
 enum port port = encoder->port;
 enum intel_dpll_id id;
 u32 tmp;

 tmp = intel_de_read(display, DPLL_CTRL2);

 /*
 * FIXME Not sure if the override affects both
 * the PLL selection and the CLK_OFF bit.
 */
 if ((tmp & DPLL_CTRL2_DDI_SEL_OVERRIDE(port)) == 0)
  return NULL;

 id = (tmp & DPLL_CTRL2_DDI_CLK_SEL_MASK(port)) >>
  DPLL_CTRL2_DDI_CLK_SEL_SHIFT(port);

 return intel_get_dpll_by_id(display, id);
}

void hsw_ddi_enable_clock(struct intel_encoder *encoder,
     const struct intel_crtc_state *crtc_state)
{
 struct intel_display *display = to_intel_display(encoder);
 const struct intel_dpll *pll = crtc_state->intel_dpll;
 enum port port = encoder->port;

 if (drm_WARN_ON(display->drm, !pll))
  return;

 intel_de_write(display, PORT_CLK_SEL(port), hsw_pll_to_ddi_pll_sel(pll));
}

void hsw_ddi_disable_clock(struct intel_encoder *encoder)
{
 struct intel_display *display = to_intel_display(encoder);
 enum port port = encoder->port;

 intel_de_write(display, PORT_CLK_SEL(port), PORT_CLK_SEL_NONE);
}

bool hsw_ddi_is_clock_enabled(struct intel_encoder *encoder)
{
 struct intel_display *display = to_intel_display(encoder);
 enum port port = encoder->port;

 return intel_de_read(display, PORT_CLK_SEL(port)) != PORT_CLK_SEL_NONE;
}

static struct intel_dpll *hsw_ddi_get_pll(struct intel_encoder *encoder)
{
 struct intel_display *display = to_intel_display(encoder);
 enum port port = encoder->port;
 enum intel_dpll_id id;
 u32 tmp;

 tmp = intel_de_read(display, PORT_CLK_SEL(port));

 switch (tmp & PORT_CLK_SEL_MASK) {
 case PORT_CLK_SEL_WRPLL1:
  id = DPLL_ID_WRPLL1;
  break;
 case PORT_CLK_SEL_WRPLL2:
  id = DPLL_ID_WRPLL2;
  break;
 case PORT_CLK_SEL_SPLL:
  id = DPLL_ID_SPLL;
  break;
 case PORT_CLK_SEL_LCPLL_810:
  id = DPLL_ID_LCPLL_810;
  break;
 case PORT_CLK_SEL_LCPLL_1350:
  id = DPLL_ID_LCPLL_1350;
  break;
 case PORT_CLK_SEL_LCPLL_2700:
  id = DPLL_ID_LCPLL_2700;
  break;
 default:
  MISSING_CASE(tmp);
  fallthrough;
 case PORT_CLK_SEL_NONE:
  return NULL;
 }

 return intel_get_dpll_by_id(display, id);
}

void intel_ddi_enable_clock(struct intel_encoder *encoder,
       const struct intel_crtc_state *crtc_state)
{
 if (encoder->enable_clock)
  encoder->enable_clock(encoder, crtc_state);
}

void intel_ddi_disable_clock(struct intel_encoder *encoder)
{
 if (encoder->disable_clock)
  encoder->disable_clock(encoder);
}

void intel_ddi_sanitize_encoder_pll_mapping(struct intel_encoder *encoder)
{
 struct intel_display *display = to_intel_display(encoder);
 u32 port_mask;
 bool ddi_clk_needed;

 /*
 * In case of DP MST, we sanitize the primary encoder only, not the
 * virtual ones.
 */
 if (encoder->type == INTEL_OUTPUT_DP_MST)
  return;

 if (!encoder->base.crtc && intel_encoder_is_dp(encoder)) {
  u8 pipe_mask;
  bool is_mst;

  intel_ddi_get_encoder_pipes(encoder, &pipe_mask, &is_mst);
  /*
 * In the unlikely case that BIOS enables DP in MST mode, just
 * warn since our MST HW readout is incomplete.
 */
  if (drm_WARN_ON(display->drm, is_mst))
   return;
 }

 port_mask = BIT(encoder->port);
 ddi_clk_needed = encoder->base.crtc;

 if (encoder->type == INTEL_OUTPUT_DSI) {
  struct intel_encoder *other_encoder;

  port_mask = intel_dsi_encoder_ports(encoder);
  /*
 * Sanity check that we haven't incorrectly registered another
 * encoder using any of the ports of this DSI encoder.
 */
  for_each_intel_encoder(display->drm, other_encoder) {
   if (other_encoder == encoder)
    continue;

   if (drm_WARN_ON(display->drm,
     port_mask & BIT(other_encoder->port)))
    return;
  }
  /*
 * For DSI we keep the ddi clocks gated
 * except during enable/disable sequence.
 */
  ddi_clk_needed = false;
 }

 if (ddi_clk_needed || !encoder->is_clock_enabled ||
     !encoder->is_clock_enabled(encoder))
  return;

 drm_dbg_kms(display->drm,
      "[ENCODER:%d:%s] is disabled/in DSI mode with an ungated DDI clock, gate it\n",
      encoder->base.base.id, encoder->base.name);

 encoder->disable_clock(encoder);
}

static void
tgl_dkl_phy_check_and_rewrite(struct intel_display *display,
         enum tc_port tc_port, u32 ln0, u32 ln1)
{
 if (ln0 != intel_dkl_phy_read(display, DKL_DP_MODE(tc_port, 0)))
  intel_dkl_phy_write(display, DKL_DP_MODE(tc_port, 0), ln0);
 if (ln1 != intel_dkl_phy_read(display, DKL_DP_MODE(tc_port, 1)))
  intel_dkl_phy_write(display, DKL_DP_MODE(tc_port, 1), ln1);
}

static void
icl_program_mg_dp_mode(struct intel_digital_port *dig_port,
         const struct intel_crtc_state *crtc_state)
{
 struct intel_display *display = to_intel_display(crtc_state);
 enum tc_port tc_port = intel_encoder_to_tc(&dig_port->base);
 u32 ln0, ln1, pin_assignment;
 u8 width;

 if (DISPLAY_VER(display) >= 14)
  return;

 if (!intel_encoder_is_tc(&dig_port->base) ||
     intel_tc_port_in_tbt_alt_mode(dig_port))
  return;

 if (DISPLAY_VER(display) >= 12) {
  ln0 = intel_dkl_phy_read(display, DKL_DP_MODE(tc_port, 0));
  ln1 = intel_dkl_phy_read(display, DKL_DP_MODE(tc_port, 1));
 } else {
  ln0 = intel_de_read(display, MG_DP_MODE(0, tc_port));
  ln1 = intel_de_read(display, MG_DP_MODE(1, tc_port));
 }

 ln0 &= ~(MG_DP_MODE_CFG_DP_X1_MODE | MG_DP_MODE_CFG_DP_X2_MODE);
 ln1 &= ~(MG_DP_MODE_CFG_DP_X1_MODE | MG_DP_MODE_CFG_DP_X2_MODE);

 /* DPPATC */
 pin_assignment = intel_tc_port_get_pin_assignment_mask(dig_port);
 width = crtc_state->lane_count;

 switch (pin_assignment) {
 case 0x0:
  drm_WARN_ON(display->drm,
       !intel_tc_port_in_legacy_mode(dig_port));
  if (width == 1) {
   ln1 |= MG_DP_MODE_CFG_DP_X1_MODE;
  } else {
   ln0 |= MG_DP_MODE_CFG_DP_X2_MODE;
   ln1 |= MG_DP_MODE_CFG_DP_X2_MODE;
  }
  break;
 case 0x1:
  if (width == 4) {
   ln0 |= MG_DP_MODE_CFG_DP_X2_MODE;
   ln1 |= MG_DP_MODE_CFG_DP_X2_MODE;
  }
  break;
--> --------------------

--> maximum size reached

--> --------------------