Merge tag 'drm-intel-next-2017-11-17-1' of git://anongit.freedesktop.org/drm/drm-intel into drm-next

More change sets for 4.16:

- Many improvements for selftests and other igt tests (Chris)
- Forcewake with PUNIT->PMIC bus fixes and robustness (Hans)
- Define an engine class for uABI (Tvrtko)
- Context switch fixes and improvements (Chris)
- GT powersavings and power gating simplification and fixes (Chris)
- Other general driver clean-ups (Chris, Lucas, Ville)
- Removing old, useless and/or bad workarounds (Chris, Oscar, Radhakrishna)
- IPS, pipe config, etc in preparation for another Fast Boot attempt (Maarten)
- OA perf fixes and support to Coffee Lake and Cannonlake (Lionel)
- Fixes around GPU fault registers (Michel)
- GEM Proxy (Tina)
- Refactor of Geminilake and Cannonlake plane color handling (James)
- Generalize transcoder loop (Mika Kahola)
- New HW Workaround for Cannonlake and Geminilake (Rodrigo)
- Resume GuC before using GEM (Chris)
- Stolen Memory handling improvements (Ville)
- Initialize entry in PPAT for older compilers (Chris)
- Other fixes and robustness improvements on execbuf (Chris)
- Improve logs of GEM_BUG_ON (Mika Kuoppala)
- Rework with massive rename of GuC functions and files (Sagar)
- Don't sanitize frame start delay if pipe is off (Ville)
- Cannonlake clock fixes (Rodrigo)
- Cannonlake HDMI 2.0 support (Rodrigo)
- Add a GuC doorbells selftest (Michel)
- Add might_sleep() check to our wait_for() (Chris)

Many GVT changes for 4.16:

- CSB HWSP update support (Weinan)
- GVT debug helpers, dyndbg and debugfs (Chuanxiao, Shuo)
- full virtualized opregion (Xiaolin)
- VM health check for sane fallback (Fred)
- workload submission code refactor for future enabling (Zhi)
- Updated repo URL in MAINTAINERS (Zhenyu)
- other many misc fixes

* tag 'drm-intel-next-2017-11-17-1' of git://anongit.freedesktop.org/drm/drm-intel: (260 commits)
  drm/i915: Update DRIVER_DATE to 20171117
  drm/i915: Add a policy note for removing workarounds
  drm/i915/selftests: Report ENOMEM clearly for an allocation failure
  Revert "drm/i915: Display WA #1133 WaFbcSkipSegments:cnl, glk"
  drm/i915: Calculate g4x intermediate watermarks correctly
  drm/i915: Calculate vlv/chv intermediate watermarks correctly, v3.
  drm/i915: Pass crtc_state to ips toggle functions, v2
  drm/i915: Pass idle crtc_state to intel_dp_sink_crc
  drm/i915: Enable FIFO underrun reporting after initial fastset, v4.
  drm/i915: Mark the userptr invalidate workqueue as WQ_MEM_RECLAIM
  drm/i915: Add might_sleep() check to wait_for()
  drm/i915/selftests: Add a GuC doorbells selftest
  drm/i915/cnl: Extend HDMI 2.0 support to CNL.
  drm/i915/cnl: Simplify dco_fraction calculation.
  drm/i915/cnl: Don't blindly replace qdiv.
  drm/i915/cnl: Fix wrpll math for higher freqs.
  drm/i915/cnl: Fix, simplify and unify wrpll variable sizes.
  drm/i915/cnl: Remove useless conversion.
  drm/i915/cnl: Remove spurious central_freq.
  drm/i915/selftests: exercise_ggtt may have nothing to do
  ...

1 files changed, 238 insertions, 278 deletions

diff --git a/drivers/gpu/drm/i915/intel_dp.c b/drivers/gpu/drm/i915/intel_dp.c
index 65260fb35d2a..bbf2256ba574 100644
--- a/drivers/gpu/drm/i915/intel_dp.c
+++ b/drivers/gpu/drm/i915/intel_dp.c
@@ -129,11 +129,13 @@ static struct intel_dp *intel_attached_dp(struct drm_connector *connector)
         return enc_to_intel_dp(&intel_attached_encoder(connector)->base);
 }
 
-static void intel_dp_link_down(struct intel_dp *intel_dp);
+static void intel_dp_link_down(struct intel_encoder *encoder,
+                               const struct intel_crtc_state *old_crtc_state);
 static bool edp_panel_vdd_on(struct intel_dp *intel_dp);
 static void edp_panel_vdd_off(struct intel_dp *intel_dp, bool sync);
-static void vlv_init_panel_power_sequencer(struct intel_dp *intel_dp);
-static void vlv_steal_power_sequencer(struct drm_device *dev,
+static void vlv_init_panel_power_sequencer(struct intel_encoder *encoder,
+                                           const struct intel_crtc_state *crtc_state);
+static void vlv_steal_power_sequencer(struct drm_i915_private *dev_priv,
                                       enum pipe pipe);
 static void intel_dp_unset_edid(struct intel_dp *intel_dp);
 
@@ -221,7 +223,7 @@ intel_dp_set_source_rates(struct intel_dp *intel_dp)
 {
         struct intel_digital_port *dig_port = dp_to_dig_port(intel_dp);
         struct drm_i915_private *dev_priv = to_i915(dig_port->base.base.dev);
-        enum port port = dig_port->port;
+        enum port port = dig_port->base.port;
         const int *source_rates;
         int size;
         u32 voltage;
@@ -427,24 +429,19 @@ static void intel_dp_unpack_aux(uint32_t src, uint8_t *dst, int dst_bytes)
 }
 
 static void
-intel_dp_init_panel_power_sequencer(struct drm_device *dev,
-                                    struct intel_dp *intel_dp);
+intel_dp_init_panel_power_sequencer(struct intel_dp *intel_dp);
 static void
-intel_dp_init_panel_power_sequencer_registers(struct drm_device *dev,
-                                              struct intel_dp *intel_dp,
+intel_dp_init_panel_power_sequencer_registers(struct intel_dp *intel_dp,
                                               bool force_disable_vdd);
 static void
-intel_dp_pps_init(struct drm_device *dev, struct intel_dp *intel_dp);
+intel_dp_pps_init(struct intel_dp *intel_dp);
 
 static void pps_lock(struct intel_dp *intel_dp)
 {
-        struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
-        struct intel_encoder *encoder = &intel_dig_port->base;
-        struct drm_device *dev = encoder->base.dev;
-        struct drm_i915_private *dev_priv = to_i915(dev);
+        struct drm_i915_private *dev_priv = to_i915(intel_dp_to_dev(intel_dp));
 
         /*
-         * See vlv_power_sequencer_reset() why we need
+         * See intel_power_sequencer_reset() why we need
          * a power domain reference here.
          */
         intel_display_power_get(dev_priv, intel_dp->aux_power_domain);
@@ -454,10 +451,7 @@ static void pps_lock(struct intel_dp *intel_dp)
 
 static void pps_unlock(struct intel_dp *intel_dp)
 {
-        struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
-        struct intel_encoder *encoder = &intel_dig_port->base;
-        struct drm_device *dev = encoder->base.dev;
-        struct drm_i915_private *dev_priv = to_i915(dev);
+        struct drm_i915_private *dev_priv = to_i915(intel_dp_to_dev(intel_dp));
 
         mutex_unlock(&dev_priv->pps_mutex);
 
@@ -467,8 +461,8 @@ static void pps_unlock(struct intel_dp *intel_dp)
 static void
 vlv_power_sequencer_kick(struct intel_dp *intel_dp)
 {
+        struct drm_i915_private *dev_priv = to_i915(intel_dp_to_dev(intel_dp));
         struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
-        struct drm_i915_private *dev_priv = to_i915(intel_dig_port->base.base.dev);
         enum pipe pipe = intel_dp->pps_pipe;
         bool pll_enabled, release_cl_override = false;
         enum dpio_phy phy = DPIO_PHY(pipe);
@@ -477,11 +471,11 @@ vlv_power_sequencer_kick(struct intel_dp *intel_dp)
 
         if (WARN(I915_READ(intel_dp->output_reg) & DP_PORT_EN,
                  "skipping pipe %c power seqeuncer kick due to port %c being active\n",
-                 pipe_name(pipe), port_name(intel_dig_port->port)))
+                 pipe_name(pipe), port_name(intel_dig_port->base.port)))
                 return;
 
         DRM_DEBUG_KMS("kicking pipe %c power sequencer for port %c\n",
-                      pipe_name(pipe), port_name(intel_dig_port->port));
+                      pipe_name(pipe), port_name(intel_dig_port->base.port));
 
         /* Preserve the BIOS-computed detected bit. This is
          * supposed to be read-only.
@@ -578,9 +572,8 @@ static enum pipe vlv_find_free_pps(struct drm_i915_private *dev_priv)
 static enum pipe
 vlv_power_sequencer_pipe(struct intel_dp *intel_dp)
 {
+        struct drm_i915_private *dev_priv = to_i915(intel_dp_to_dev(intel_dp));
         struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
-        struct drm_device *dev = intel_dig_port->base.base.dev;
-        struct drm_i915_private *dev_priv = to_i915(dev);
         enum pipe pipe;
 
         lockdep_assert_held(&dev_priv->pps_mutex);
@@ -603,16 +596,16 @@ vlv_power_sequencer_pipe(struct intel_dp *intel_dp)
         if (WARN_ON(pipe == INVALID_PIPE))
                 pipe = PIPE_A;
 
-        vlv_steal_power_sequencer(dev, pipe);
+        vlv_steal_power_sequencer(dev_priv, pipe);
         intel_dp->pps_pipe = pipe;
 
         DRM_DEBUG_KMS("picked pipe %c power sequencer for port %c\n",
                       pipe_name(intel_dp->pps_pipe),
-                      port_name(intel_dig_port->port));
+                      port_name(intel_dig_port->base.port));
 
         /* init power sequencer on this pipe and port */
-        intel_dp_init_panel_power_sequencer(dev, intel_dp);
-        intel_dp_init_panel_power_sequencer_registers(dev, intel_dp, true);
+        intel_dp_init_panel_power_sequencer(intel_dp);
+        intel_dp_init_panel_power_sequencer_registers(intel_dp, true);
 
         /*
          * Even vdd force doesn't work until we've made
@@ -626,9 +619,7 @@ vlv_power_sequencer_pipe(struct intel_dp *intel_dp)
 static int
 bxt_power_sequencer_idx(struct intel_dp *intel_dp)
 {
-        struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
-        struct drm_device *dev = intel_dig_port->base.base.dev;
-        struct drm_i915_private *dev_priv = to_i915(dev);
+        struct drm_i915_private *dev_priv = to_i915(intel_dp_to_dev(intel_dp));
 
         lockdep_assert_held(&dev_priv->pps_mutex);
 
@@ -649,7 +640,7 @@ bxt_power_sequencer_idx(struct intel_dp *intel_dp)
          * Only the HW needs to be reprogrammed, the SW state is fixed and
          * has been setup during connector init.
          */
-        intel_dp_init_panel_power_sequencer_registers(dev, intel_dp, false);
+        intel_dp_init_panel_power_sequencer_registers(intel_dp, false);
 
         return 0;
 }
@@ -701,10 +692,9 @@ vlv_initial_pps_pipe(struct drm_i915_private *dev_priv,
 static void
 vlv_initial_power_sequencer_setup(struct intel_dp *intel_dp)
 {
+        struct drm_i915_private *dev_priv = to_i915(intel_dp_to_dev(intel_dp));
         struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
-        struct drm_device *dev = intel_dig_port->base.base.dev;
-        struct drm_i915_private *dev_priv = to_i915(dev);
-        enum port port = intel_dig_port->port;
+        enum port port = intel_dig_port->base.port;
 
         lockdep_assert_held(&dev_priv->pps_mutex);
 
@@ -731,13 +721,12 @@ vlv_initial_power_sequencer_setup(struct intel_dp *intel_dp)
         DRM_DEBUG_KMS("initial power sequencer for port %c: pipe %c\n",
                       port_name(port), pipe_name(intel_dp->pps_pipe));
 
-        intel_dp_init_panel_power_sequencer(dev, intel_dp);
-        intel_dp_init_panel_power_sequencer_registers(dev, intel_dp, false);
+        intel_dp_init_panel_power_sequencer(intel_dp);
+        intel_dp_init_panel_power_sequencer_registers(intel_dp, false);
 }
 
 void intel_power_sequencer_reset(struct drm_i915_private *dev_priv)
 {
-        struct drm_device *dev = &dev_priv->drm;
         struct intel_encoder *encoder;
 
         if (WARN_ON(!IS_VALLEYVIEW(dev_priv) && !IS_CHERRYVIEW(dev_priv) &&
@@ -754,15 +743,20 @@ void intel_power_sequencer_reset(struct drm_i915_private *dev_priv)
          * should use them always.
          */
 
-        for_each_intel_encoder(dev, encoder) {
+        for_each_intel_encoder(&dev_priv->drm, encoder) {
                 struct intel_dp *intel_dp;
 
                 if (encoder->type != INTEL_OUTPUT_DP &&
-                    encoder->type != INTEL_OUTPUT_EDP)
+                    encoder->type != INTEL_OUTPUT_EDP &&
+                    encoder->type != INTEL_OUTPUT_DDI)
                         continue;
 
                 intel_dp = enc_to_intel_dp(&encoder->base);
 
+                /* Skip pure DVI/HDMI DDI encoders */
+                if (!i915_mmio_reg_valid(intel_dp->output_reg))
+                        continue;
+
                 WARN_ON(intel_dp->active_pipe != INVALID_PIPE);
 
                 if (encoder->type != INTEL_OUTPUT_EDP)
@@ -783,10 +777,10 @@ struct pps_registers {
         i915_reg_t pp_div;
 };
 
-static void intel_pps_get_registers(struct drm_i915_private *dev_priv,
-                                    struct intel_dp *intel_dp,
+static void intel_pps_get_registers(struct intel_dp *intel_dp,
                                     struct pps_registers *regs)
 {
+        struct drm_i915_private *dev_priv = to_i915(intel_dp_to_dev(intel_dp));
         int pps_idx = 0;
 
         memset(regs, 0, sizeof(*regs));
@@ -809,8 +803,7 @@ _pp_ctrl_reg(struct intel_dp *intel_dp)
 {
         struct pps_registers regs;
 
-        intel_pps_get_registers(to_i915(intel_dp_to_dev(intel_dp)), intel_dp,
-                                &regs);
+        intel_pps_get_registers(intel_dp, &regs);
 
         return regs.pp_ctrl;
 }
@@ -820,8 +813,7 @@ _pp_stat_reg(struct intel_dp *intel_dp)
 {
         struct pps_registers regs;
 
-        intel_pps_get_registers(to_i915(intel_dp_to_dev(intel_dp)), intel_dp,
-                                &regs);
+        intel_pps_get_registers(intel_dp, &regs);
 
         return regs.pp_stat;
 }
@@ -833,8 +825,7 @@ static int edp_notify_handler(struct notifier_block *this, unsigned long code,
 {
         struct intel_dp *intel_dp = container_of(this, typeof(* intel_dp),
                                                  edp_notifier);
-        struct drm_device *dev = intel_dp_to_dev(intel_dp);
-        struct drm_i915_private *dev_priv = to_i915(dev);
+        struct drm_i915_private *dev_priv = to_i915(intel_dp_to_dev(intel_dp));
 
         if (!intel_dp_is_edp(intel_dp) || code != SYS_RESTART)
                 return 0;
@@ -864,8 +855,7 @@ static int edp_notify_handler(struct notifier_block *this, unsigned long code,
 
 static bool edp_have_panel_power(struct intel_dp *intel_dp)
 {
-        struct drm_device *dev = intel_dp_to_dev(intel_dp);
-        struct drm_i915_private *dev_priv = to_i915(dev);
+        struct drm_i915_private *dev_priv = to_i915(intel_dp_to_dev(intel_dp));
 
         lockdep_assert_held(&dev_priv->pps_mutex);
 
@@ -878,8 +868,7 @@ static bool edp_have_panel_power(struct intel_dp *intel_dp)
 
 static bool edp_have_panel_vdd(struct intel_dp *intel_dp)
 {
-        struct drm_device *dev = intel_dp_to_dev(intel_dp);
-        struct drm_i915_private *dev_priv = to_i915(dev);
+        struct drm_i915_private *dev_priv = to_i915(intel_dp_to_dev(intel_dp));
 
         lockdep_assert_held(&dev_priv->pps_mutex);
 
@@ -893,8 +882,7 @@ static bool edp_have_panel_vdd(struct intel_dp *intel_dp)
 static void
 intel_dp_check_edp(struct intel_dp *intel_dp)
 {
-        struct drm_device *dev = intel_dp_to_dev(intel_dp);
-        struct drm_i915_private *dev_priv = to_i915(dev);
+        struct drm_i915_private *dev_priv = to_i915(intel_dp_to_dev(intel_dp));
 
         if (!intel_dp_is_edp(intel_dp))
                 return;
@@ -910,9 +898,7 @@ intel_dp_check_edp(struct intel_dp *intel_dp)
 static uint32_t
 intel_dp_aux_wait_done(struct intel_dp *intel_dp, bool has_aux_irq)
 {
-        struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
-        struct drm_device *dev = intel_dig_port->base.base.dev;
-        struct drm_i915_private *dev_priv = to_i915(dev);
+        struct drm_i915_private *dev_priv = to_i915(intel_dp_to_dev(intel_dp));
         i915_reg_t ch_ctl = intel_dp->aux_ch_ctl_reg;
         uint32_t status;
         bool done;
@@ -959,7 +945,7 @@ static uint32_t ilk_get_aux_clock_divider(struct intel_dp *intel_dp, int index)
          * like to run at 2MHz.  So, take the cdclk or PCH rawclk value and
          * divide by 2000 and use that
          */
-        if (intel_dig_port->port == PORT_A)
+        if (intel_dig_port->base.port == PORT_A)
                 return DIV_ROUND_CLOSEST(dev_priv->cdclk.hw.cdclk, 2000);
         else
                 return DIV_ROUND_CLOSEST(dev_priv->rawclk_freq, 2000);
@@ -970,7 +956,7 @@ static uint32_t hsw_get_aux_clock_divider(struct intel_dp *intel_dp, int index)
         struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
         struct drm_i915_private *dev_priv = to_i915(intel_dig_port->base.base.dev);
 
-        if (intel_dig_port->port != PORT_A && HAS_PCH_LPT_H(dev_priv)) {
+        if (intel_dig_port->base.port != PORT_A && HAS_PCH_LPT_H(dev_priv)) {
                 /* Workaround for non-ULT HSW */
                 switch (index) {
                 case 0: return 63;
@@ -1440,7 +1426,7 @@ static void intel_aux_reg_init(struct intel_dp *intel_dp)
 {
         struct drm_i915_private *dev_priv = to_i915(intel_dp_to_dev(intel_dp));
         enum port port = intel_aux_port(dev_priv,
-                                        dp_to_dig_port(intel_dp)->port);
+                                        dp_to_dig_port(intel_dp)->base.port);
         int i;
 
         intel_dp->aux_ch_ctl_reg = intel_aux_ctl_reg(dev_priv, port);
@@ -1458,7 +1444,7 @@ static void
 intel_dp_aux_init(struct intel_dp *intel_dp)
 {
         struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
-        enum port port = intel_dig_port->port;
+        enum port port = intel_dig_port->base.port;
 
         intel_aux_reg_init(intel_dp);
         drm_dp_aux_init(&intel_dp->aux);
@@ -1479,8 +1465,7 @@ static void
 intel_dp_set_clock(struct intel_encoder *encoder,
                    struct intel_crtc_state *pipe_config)
 {
-        struct drm_device *dev = encoder->base.dev;
-        struct drm_i915_private *dev_priv = to_i915(dev);
+        struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
         const struct dp_link_dpll *divisor = NULL;
         int i, count = 0;
 
@@ -1628,7 +1613,7 @@ intel_dp_compute_config(struct intel_encoder *encoder,
         struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
         struct drm_display_mode *adjusted_mode = &pipe_config->base.adjusted_mode;
         struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
-        enum port port = dp_to_dig_port(intel_dp)->port;
+        enum port port = encoder->port;
         struct intel_crtc *intel_crtc = to_intel_crtc(pipe_config->base.crtc);
         struct intel_connector *intel_connector = intel_dp->attached_connector;
         struct intel_digital_connector_state *intel_conn_state =
@@ -1849,11 +1834,10 @@ void intel_dp_set_link_params(struct intel_dp *intel_dp,
 static void intel_dp_prepare(struct intel_encoder *encoder,
                              const struct intel_crtc_state *pipe_config)
 {
-        struct drm_device *dev = encoder->base.dev;
-        struct drm_i915_private *dev_priv = to_i915(dev);
+        struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
         struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
-        enum port port = dp_to_dig_port(intel_dp)->port;
-        struct intel_crtc *crtc = to_intel_crtc(encoder->base.crtc);
+        enum port port = encoder->port;
+        struct intel_crtc *crtc = to_intel_crtc(pipe_config->base.crtc);
         const struct drm_display_mode *adjusted_mode = &pipe_config->base.adjusted_mode;
 
         intel_dp_set_link_params(intel_dp, pipe_config->port_clock,
@@ -1940,20 +1924,18 @@ static void intel_dp_prepare(struct intel_encoder *encoder,
 #define IDLE_CYCLE_MASK         (PP_ON | PP_SEQUENCE_MASK | PP_CYCLE_DELAY_ACTIVE | PP_SEQUENCE_STATE_MASK)
 #define IDLE_CYCLE_VALUE        (0     | PP_SEQUENCE_NONE | 0                     | PP_SEQUENCE_STATE_OFF_IDLE)
 
-static void intel_pps_verify_state(struct drm_i915_private *dev_priv,
-                                   struct intel_dp *intel_dp);
+static void intel_pps_verify_state(struct intel_dp *intel_dp);
 
 static void wait_panel_status(struct intel_dp *intel_dp,
                                        u32 mask,
                                        u32 value)
 {
-        struct drm_device *dev = intel_dp_to_dev(intel_dp);
-        struct drm_i915_private *dev_priv = to_i915(dev);
+        struct drm_i915_private *dev_priv = to_i915(intel_dp_to_dev(intel_dp));
         i915_reg_t pp_stat_reg, pp_ctrl_reg;
 
         lockdep_assert_held(&dev_priv->pps_mutex);
 
-        intel_pps_verify_state(dev_priv, intel_dp);
+        intel_pps_verify_state(intel_dp);
 
         pp_stat_reg = _pp_stat_reg(intel_dp);
         pp_ctrl_reg = _pp_ctrl_reg(intel_dp);
@@ -2024,8 +2006,7 @@ static void edp_wait_backlight_off(struct intel_dp *intel_dp)
 
 static  u32 ironlake_get_pp_control(struct intel_dp *intel_dp)
 {
-        struct drm_device *dev = intel_dp_to_dev(intel_dp);
-        struct drm_i915_private *dev_priv = to_i915(dev);
+        struct drm_i915_private *dev_priv = to_i915(intel_dp_to_dev(intel_dp));
         u32 control;
 
         lockdep_assert_held(&dev_priv->pps_mutex);
@@ -2046,9 +2027,8 @@ static  u32 ironlake_get_pp_control(struct intel_dp *intel_dp)
  */
 static bool edp_panel_vdd_on(struct intel_dp *intel_dp)
 {
-        struct drm_device *dev = intel_dp_to_dev(intel_dp);
+        struct drm_i915_private *dev_priv = to_i915(intel_dp_to_dev(intel_dp));
         struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
-        struct drm_i915_private *dev_priv = to_i915(dev);
         u32 pp;
         i915_reg_t pp_stat_reg, pp_ctrl_reg;
         bool need_to_disable = !intel_dp->want_panel_vdd;
@@ -2067,7 +2047,7 @@ static bool edp_panel_vdd_on(struct intel_dp *intel_dp)
         intel_display_power_get(dev_priv, intel_dp->aux_power_domain);
 
         DRM_DEBUG_KMS("Turning eDP port %c VDD on\n",
-                      port_name(intel_dig_port->port));
+                      port_name(intel_dig_port->base.port));
 
         if (!edp_have_panel_power(intel_dp))
                 wait_panel_power_cycle(intel_dp);
@@ -2087,7 +2067,7 @@ static bool edp_panel_vdd_on(struct intel_dp *intel_dp)
          */
         if (!edp_have_panel_power(intel_dp)) {
                 DRM_DEBUG_KMS("eDP port %c panel power wasn't enabled\n",
-                              port_name(intel_dig_port->port));
+                              port_name(intel_dig_port->base.port));
                 msleep(intel_dp->panel_power_up_delay);
         }
 
@@ -2113,13 +2093,12 @@ void intel_edp_panel_vdd_on(struct intel_dp *intel_dp)
         pps_unlock(intel_dp);
 
         I915_STATE_WARN(!vdd, "eDP port %c VDD already requested on\n",
-             port_name(dp_to_dig_port(intel_dp)->port));
+             port_name(dp_to_dig_port(intel_dp)->base.port));
 }
 
 static void edp_panel_vdd_off_sync(struct intel_dp *intel_dp)
 {
-        struct drm_device *dev = intel_dp_to_dev(intel_dp);
-        struct drm_i915_private *dev_priv = to_i915(dev);
+        struct drm_i915_private *dev_priv = to_i915(intel_dp_to_dev(intel_dp));
         struct intel_digital_port *intel_dig_port =
                 dp_to_dig_port(intel_dp);
         u32 pp;
@@ -2133,7 +2112,7 @@ static void edp_panel_vdd_off_sync(struct intel_dp *intel_dp)
                 return;
 
         DRM_DEBUG_KMS("Turning eDP port %c VDD off\n",
-                      port_name(intel_dig_port->port));
+                      port_name(intel_dig_port->base.port));
 
         pp = ironlake_get_pp_control(intel_dp);
         pp &= ~EDP_FORCE_VDD;
@@ -2193,7 +2172,7 @@ static void edp_panel_vdd_off(struct intel_dp *intel_dp, bool sync)
                 return;
 
         I915_STATE_WARN(!intel_dp->want_panel_vdd, "eDP port %c VDD not forced on",
-             port_name(dp_to_dig_port(intel_dp)->port));
+             port_name(dp_to_dig_port(intel_dp)->base.port));
 
         intel_dp->want_panel_vdd = false;
 
@@ -2205,8 +2184,7 @@ static void edp_panel_vdd_off(struct intel_dp *intel_dp, bool sync)
 
 static void edp_panel_on(struct intel_dp *intel_dp)
 {
-        struct drm_device *dev = intel_dp_to_dev(intel_dp);
-        struct drm_i915_private *dev_priv = to_i915(dev);
+        struct drm_i915_private *dev_priv = to_i915(intel_dp_to_dev(intel_dp));
         u32 pp;
         i915_reg_t pp_ctrl_reg;
 
@@ -2216,11 +2194,11 @@ static void edp_panel_on(struct intel_dp *intel_dp)
                 return;
 
         DRM_DEBUG_KMS("Turn eDP port %c panel power on\n",
-                      port_name(dp_to_dig_port(intel_dp)->port));
+                      port_name(dp_to_dig_port(intel_dp)->base.port));
 
         if (WARN(edp_have_panel_power(intel_dp),
                  "eDP port %c panel power already on\n",
-                 port_name(dp_to_dig_port(intel_dp)->port)))
+                 port_name(dp_to_dig_port(intel_dp)->base.port)))
                 return;
 
         wait_panel_power_cycle(intel_dp);
@@ -2264,8 +2242,7 @@ void intel_edp_panel_on(struct intel_dp *intel_dp)
 
 static void edp_panel_off(struct intel_dp *intel_dp)
 {
-        struct drm_device *dev = intel_dp_to_dev(intel_dp);
-        struct drm_i915_private *dev_priv = to_i915(dev);
+        struct drm_i915_private *dev_priv = to_i915(intel_dp_to_dev(intel_dp));
         u32 pp;
         i915_reg_t pp_ctrl_reg;
 
@@ -2275,10 +2252,10 @@ static void edp_panel_off(struct intel_dp *intel_dp)
                 return;
 
         DRM_DEBUG_KMS("Turn eDP port %c panel power off\n",
-                      port_name(dp_to_dig_port(intel_dp)->port));
+                      port_name(dp_to_dig_port(intel_dp)->base.port));
 
         WARN(!intel_dp->want_panel_vdd, "Need eDP port %c VDD to turn off panel\n",
-             port_name(dp_to_dig_port(intel_dp)->port));
+             port_name(dp_to_dig_port(intel_dp)->base.port));
 
         pp = ironlake_get_pp_control(intel_dp);
         /* We need to switch off panel power _and_ force vdd, for otherwise some
@@ -2313,9 +2290,7 @@ void intel_edp_panel_off(struct intel_dp *intel_dp)
 /* Enable backlight in the panel power control. */
 static void _intel_edp_backlight_on(struct intel_dp *intel_dp)
 {
-        struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
-        struct drm_device *dev = intel_dig_port->base.base.dev;
-        struct drm_i915_private *dev_priv = to_i915(dev);
+        struct drm_i915_private *dev_priv = to_i915(intel_dp_to_dev(intel_dp));
         u32 pp;
         i915_reg_t pp_ctrl_reg;
 
@@ -2358,8 +2333,7 @@ void intel_edp_backlight_on(const struct intel_crtc_state *crtc_state,
 /* Disable backlight in the panel power control. */
 static void _intel_edp_backlight_off(struct intel_dp *intel_dp)
 {
-        struct drm_device *dev = intel_dp_to_dev(intel_dp);
-        struct drm_i915_private *dev_priv = to_i915(dev);
+        struct drm_i915_private *dev_priv = to_i915(intel_dp_to_dev(intel_dp));
         u32 pp;
         i915_reg_t pp_ctrl_reg;
 
@@ -2430,7 +2404,7 @@ static void assert_dp_port(struct intel_dp *intel_dp, bool state)
 
         I915_STATE_WARN(cur_state != state,
                         "DP port %c state assertion failure (expected %s, current %s)\n",
-                        port_name(dig_port->port),
+                        port_name(dig_port->base.port),
                         onoff(state), onoff(cur_state));
 }
 #define assert_dp_port_disabled(d) assert_dp_port((d), false)
@@ -2486,10 +2460,10 @@ static void ironlake_edp_pll_on(struct intel_dp *intel_dp,
         udelay(200);
 }
 
-static void ironlake_edp_pll_off(struct intel_dp *intel_dp)
+static void ironlake_edp_pll_off(struct intel_dp *intel_dp,
+                                 const struct intel_crtc_state *old_crtc_state)
 {
-        struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
-        struct intel_crtc *crtc = to_intel_crtc(intel_dig_port->base.base.crtc);
+        struct intel_crtc *crtc = to_intel_crtc(old_crtc_state->base.crtc);
         struct drm_i915_private *dev_priv = to_i915(crtc->base.dev);
 
         assert_pipe_disabled(dev_priv, crtc->pipe);
@@ -2505,6 +2479,21 @@ static void ironlake_edp_pll_off(struct intel_dp *intel_dp)
         udelay(200);
 }
 
+static bool downstream_hpd_needs_d0(struct intel_dp *intel_dp)
+{
+        /*
+         * DPCD 1.2+ should support BRANCH_DEVICE_CTRL, and thus
+         * be capable of signalling downstream hpd with a long pulse.
+         * Whether or not that means D3 is safe to use is not clear,
+         * but let's assume so until proven otherwise.
+         *
+         * FIXME should really check all downstream ports...
+         */
+        return intel_dp->dpcd[DP_DPCD_REV] == 0x11 &&
+                intel_dp->dpcd[DP_DOWNSTREAMPORT_PRESENT] & DP_DWN_STRM_PORT_PRESENT &&
+                intel_dp->downstream_ports[0] & DP_DS_PORT_HPD;
+}
+
 /* If the sink supports it, try to set the power state appropriately */
 void intel_dp_sink_dpms(struct intel_dp *intel_dp, int mode)
 {
@@ -2515,6 +2504,9 @@ void intel_dp_sink_dpms(struct intel_dp *intel_dp, int mode)
                 return;
 
         if (mode != DRM_MODE_DPMS_ON) {
+                if (downstream_hpd_needs_d0(intel_dp))
+                        return;
+
                 ret = drm_dp_dpcd_writeb(&intel_dp->aux, DP_SET_POWER,
                                          DP_SET_POWER_D3);
         } else {
@@ -2544,10 +2536,9 @@ void intel_dp_sink_dpms(struct intel_dp *intel_dp, int mode)
 static bool intel_dp_get_hw_state(struct intel_encoder *encoder,
                                   enum pipe *pipe)
 {
+        struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
         struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
-        enum port port = dp_to_dig_port(intel_dp)->port;
-        struct drm_device *dev = encoder->base.dev;
-        struct drm_i915_private *dev_priv = to_i915(dev);
+        enum port port = encoder->port;
         u32 tmp;
         bool ret;
 
@@ -2596,12 +2587,16 @@ out:
 static void intel_dp_get_config(struct intel_encoder *encoder,
                                 struct intel_crtc_state *pipe_config)
 {
+        struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
         struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
         u32 tmp, flags = 0;
-        struct drm_device *dev = encoder->base.dev;
-        struct drm_i915_private *dev_priv = to_i915(dev);
-        enum port port = dp_to_dig_port(intel_dp)->port;
-        struct intel_crtc *crtc = to_intel_crtc(encoder->base.crtc);
+        enum port port = encoder->port;
+        struct intel_crtc *crtc = to_intel_crtc(pipe_config->base.crtc);
+
+        if (encoder->type == INTEL_OUTPUT_EDP)
+                pipe_config->output_types |= BIT(INTEL_OUTPUT_EDP);
+        else
+                pipe_config->output_types |= BIT(INTEL_OUTPUT_DP);
 
         tmp = I915_READ(intel_dp->output_reg);
 
@@ -2680,7 +2675,8 @@ static void intel_disable_dp(struct intel_encoder *encoder,
         struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
 
         if (old_crtc_state->has_audio)
-                intel_audio_codec_disable(encoder);
+                intel_audio_codec_disable(encoder,
+                                          old_crtc_state, old_conn_state);
 
         /* Make sure the panel is off before trying to change the mode. But also
          * ensure that we have vdd while we switch off the panel. */
@@ -2694,12 +2690,10 @@ static void g4x_disable_dp(struct intel_encoder *encoder,
                            const struct intel_crtc_state *old_crtc_state,
                            const struct drm_connector_state *old_conn_state)
 {
-        struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
-
         intel_disable_dp(encoder, old_crtc_state, old_conn_state);
 
         /* disable the port before the pipe on g4x */
-        intel_dp_link_down(intel_dp);
+        intel_dp_link_down(encoder, old_crtc_state);
 }
 
 static void ilk_disable_dp(struct intel_encoder *encoder,
@@ -2725,38 +2719,34 @@ static void ilk_post_disable_dp(struct intel_encoder *encoder,
                                 const struct drm_connector_state *old_conn_state)
 {
         struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
-        enum port port = dp_to_dig_port(intel_dp)->port;
+        enum port port = encoder->port;
 
-        intel_dp_link_down(intel_dp);
+        intel_dp_link_down(encoder, old_crtc_state);
 
         /* Only ilk+ has port A */
         if (port == PORT_A)
-                ironlake_edp_pll_off(intel_dp);
+                ironlake_edp_pll_off(intel_dp, old_crtc_state);
 }
 
 static void vlv_post_disable_dp(struct intel_encoder *encoder,
                                 const struct intel_crtc_state *old_crtc_state,
                                 const struct drm_connector_state *old_conn_state)
 {
-        struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
-
-        intel_dp_link_down(intel_dp);
+        intel_dp_link_down(encoder, old_crtc_state);
 }
 
 static void chv_post_disable_dp(struct intel_encoder *encoder,
                                 const struct intel_crtc_state *old_crtc_state,
                                 const struct drm_connector_state *old_conn_state)
 {
-        struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
-        struct drm_device *dev = encoder->base.dev;
-        struct drm_i915_private *dev_priv = to_i915(dev);
+        struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
 
-        intel_dp_link_down(intel_dp);
+        intel_dp_link_down(encoder, old_crtc_state);
 
         mutex_lock(&dev_priv->sb_lock);
 
         /* Assert data lane reset */
-        chv_data_lane_soft_reset(encoder, true);
+        chv_data_lane_soft_reset(encoder, old_crtc_state, true);
 
         mutex_unlock(&dev_priv->sb_lock);
 }
@@ -2766,10 +2756,9 @@ _intel_dp_set_link_train(struct intel_dp *intel_dp,
                          uint32_t *DP,
                          uint8_t dp_train_pat)
 {
+        struct drm_i915_private *dev_priv = to_i915(intel_dp_to_dev(intel_dp));
         struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
-        struct drm_device *dev = intel_dig_port->base.base.dev;
-        struct drm_i915_private *dev_priv = to_i915(dev);
-        enum port port = intel_dig_port->port;
+        enum port port = intel_dig_port->base.port;
 
         if (dp_train_pat & DP_TRAINING_PATTERN_MASK)
                 DRM_DEBUG_KMS("Using DP training pattern TPS%d\n",
@@ -2852,8 +2841,7 @@ _intel_dp_set_link_train(struct intel_dp *intel_dp,
 static void intel_dp_enable_port(struct intel_dp *intel_dp,
                                  const struct intel_crtc_state *old_crtc_state)
 {
-        struct drm_device *dev = intel_dp_to_dev(intel_dp);
-        struct drm_i915_private *dev_priv = to_i915(dev);
+        struct drm_i915_private *dev_priv = to_i915(intel_dp_to_dev(intel_dp));
 
         /* enable with pattern 1 (as per spec) */
 
@@ -2877,10 +2865,9 @@ static void intel_enable_dp(struct intel_encoder *encoder,
                             const struct intel_crtc_state *pipe_config,
                             const struct drm_connector_state *conn_state)
 {
+        struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
         struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
-        struct drm_device *dev = encoder->base.dev;
-        struct drm_i915_private *dev_priv = to_i915(dev);
-        struct intel_crtc *crtc = to_intel_crtc(encoder->base.crtc);
+        struct intel_crtc *crtc = to_intel_crtc(pipe_config->base.crtc);
         uint32_t dp_reg = I915_READ(intel_dp->output_reg);
         enum pipe pipe = crtc->pipe;
 
@@ -2890,7 +2877,7 @@ static void intel_enable_dp(struct intel_encoder *encoder,
         pps_lock(intel_dp);
 
         if (IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv))
-                vlv_init_panel_power_sequencer(intel_dp);
+                vlv_init_panel_power_sequencer(encoder, pipe_config);
 
         intel_dp_enable_port(intel_dp, pipe_config);
 
@@ -2944,7 +2931,7 @@ static void g4x_pre_enable_dp(struct intel_encoder *encoder,
                               const struct drm_connector_state *conn_state)
 {
         struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
-        enum port port = dp_to_dig_port(intel_dp)->port;
+        enum port port = encoder->port;
 
         intel_dp_prepare(encoder, pipe_config);
 
@@ -2977,22 +2964,21 @@ static void vlv_detach_power_sequencer(struct intel_dp *intel_dp)
          * from a port.
          */
         DRM_DEBUG_KMS("detaching pipe %c power sequencer from port %c\n",
-                      pipe_name(pipe), port_name(intel_dig_port->port));
+                      pipe_name(pipe), port_name(intel_dig_port->base.port));
         I915_WRITE(pp_on_reg, 0);
         POSTING_READ(pp_on_reg);
 
         intel_dp->pps_pipe = INVALID_PIPE;
 }
 
-static void vlv_steal_power_sequencer(struct drm_device *dev,
+static void vlv_steal_power_sequencer(struct drm_i915_private *dev_priv,
                                       enum pipe pipe)
 {
-        struct drm_i915_private *dev_priv = to_i915(dev);
         struct intel_encoder *encoder;
 
         lockdep_assert_held(&dev_priv->pps_mutex);
 
-        for_each_intel_encoder(dev, encoder) {
+        for_each_intel_encoder(&dev_priv->drm, encoder) {
                 struct intel_dp *intel_dp;
                 enum port port;
 
@@ -3001,7 +2987,7 @@ static void vlv_steal_power_sequencer(struct drm_device *dev,
                         continue;
 
                 intel_dp = enc_to_intel_dp(&encoder->base);
-                port = dp_to_dig_port(intel_dp)->port;
+                port = dp_to_dig_port(intel_dp)->base.port;
 
                 WARN(intel_dp->active_pipe == pipe,
                      "stealing pipe %c power sequencer from active (e)DP port %c\n",
@@ -3018,13 +3004,12 @@ static void vlv_steal_power_sequencer(struct drm_device *dev,
         }
 }
 
-static void vlv_init_panel_power_sequencer(struct intel_dp *intel_dp)
+static void vlv_init_panel_power_sequencer(struct intel_encoder *encoder,
+                                           const struct intel_crtc_state *crtc_state)
 {
-        struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
-        struct intel_encoder *encoder = &intel_dig_port->base;
-        struct drm_device *dev = encoder->base.dev;
-        struct drm_i915_private *dev_priv = to_i915(dev);
-        struct intel_crtc *crtc = to_intel_crtc(encoder->base.crtc);
+        struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
+        struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
+        struct intel_crtc *crtc = to_intel_crtc(crtc_state->base.crtc);
 
         lockdep_assert_held(&dev_priv->pps_mutex);
 
@@ -3044,7 +3029,7 @@ static void vlv_init_panel_power_sequencer(struct intel_dp *intel_dp)
          * We may be stealing the power
          * sequencer from another port.
          */
-        vlv_steal_power_sequencer(dev, crtc->pipe);
+        vlv_steal_power_sequencer(dev_priv, crtc->pipe);
 
         intel_dp->active_pipe = crtc->pipe;
 
@@ -3055,18 +3040,18 @@ static void vlv_init_panel_power_sequencer(struct intel_dp *intel_dp)
         intel_dp->pps_pipe = crtc->pipe;
 
         DRM_DEBUG_KMS("initializing pipe %c power sequencer for port %c\n",
-                      pipe_name(intel_dp->pps_pipe), port_name(intel_dig_port->port));
+                      pipe_name(intel_dp->pps_pipe), port_name(encoder->port));
 
         /* init power sequencer on this pipe and port */
-        intel_dp_init_panel_power_sequencer(dev, intel_dp);
-        intel_dp_init_panel_power_sequencer_registers(dev, intel_dp, true);
+        intel_dp_init_panel_power_sequencer(intel_dp);
+        intel_dp_init_panel_power_sequencer_registers(intel_dp, true);
 }
 
 static void vlv_pre_enable_dp(struct intel_encoder *encoder,
                               const struct intel_crtc_state *pipe_config,
                               const struct drm_connector_state *conn_state)
 {
-        vlv_phy_pre_encoder_enable(encoder);
+        vlv_phy_pre_encoder_enable(encoder, pipe_config);
 
         intel_enable_dp(encoder, pipe_config, conn_state);
 }
@@ -3077,14 +3062,14 @@ static void vlv_dp_pre_pll_enable(struct intel_encoder *encoder,
 {
         intel_dp_prepare(encoder, pipe_config);
 
-        vlv_phy_pre_pll_enable(encoder);
+        vlv_phy_pre_pll_enable(encoder, pipe_config);
 }
 
 static void chv_pre_enable_dp(struct intel_encoder *encoder,
                               const struct intel_crtc_state *pipe_config,
                               const struct drm_connector_state *conn_state)
 {
-        chv_phy_pre_encoder_enable(encoder);
+        chv_phy_pre_encoder_enable(encoder, pipe_config);
 
         intel_enable_dp(encoder, pipe_config, conn_state);
 
@@ -3098,14 +3083,14 @@ static void chv_dp_pre_pll_enable(struct intel_encoder *encoder,
 {
         intel_dp_prepare(encoder, pipe_config);
 
-        chv_phy_pre_pll_enable(encoder);
+        chv_phy_pre_pll_enable(encoder, pipe_config);
 }
 
 static void chv_dp_post_pll_disable(struct intel_encoder *encoder,
-                                    const struct intel_crtc_state *pipe_config,
-                                    const struct drm_connector_state *conn_state)
+                                    const struct intel_crtc_state *old_crtc_state,
+                                    const struct drm_connector_state *old_conn_state)
 {
-        chv_phy_post_pll_disable(encoder);
+        chv_phy_post_pll_disable(encoder, old_crtc_state);
 }
 
 /*
@@ -3153,7 +3138,7 @@ uint8_t
 intel_dp_voltage_max(struct intel_dp *intel_dp)
 {
         struct drm_i915_private *dev_priv = to_i915(intel_dp_to_dev(intel_dp));
-        enum port port = dp_to_dig_port(intel_dp)->port;
+        enum port port = dp_to_dig_port(intel_dp)->base.port;
 
         if (INTEL_GEN(dev_priv) >= 9) {
                 struct intel_encoder *encoder = &dp_to_dig_port(intel_dp)->base;
@@ -3172,7 +3157,7 @@ uint8_t
 intel_dp_pre_emphasis_max(struct intel_dp *intel_dp, uint8_t voltage_swing)
 {
         struct drm_i915_private *dev_priv = to_i915(intel_dp_to_dev(intel_dp));
-        enum port port = dp_to_dig_port(intel_dp)->port;
+        enum port port = dp_to_dig_port(intel_dp)->base.port;
 
         if (INTEL_GEN(dev_priv) >= 9) {
                 switch (voltage_swing & DP_TRAIN_VOLTAGE_SWING_MASK) {
@@ -3505,10 +3490,9 @@ gen7_edp_signal_levels(uint8_t train_set)
 void
 intel_dp_set_signal_levels(struct intel_dp *intel_dp)
 {
+        struct drm_i915_private *dev_priv = to_i915(intel_dp_to_dev(intel_dp));
         struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
-        enum port port = intel_dig_port->port;
-        struct drm_device *dev = intel_dig_port->base.base.dev;
-        struct drm_i915_private *dev_priv = to_i915(dev);
+        enum port port = intel_dig_port->base.port;
         uint32_t signal_levels, mask = 0;
         uint8_t train_set = intel_dp->train_set[0];
 
@@ -3563,10 +3547,9 @@ intel_dp_program_link_training_pattern(struct intel_dp *intel_dp,
 
 void intel_dp_set_idle_link_train(struct intel_dp *intel_dp)
 {
+        struct drm_i915_private *dev_priv = to_i915(intel_dp_to_dev(intel_dp));
         struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
-        struct drm_device *dev = intel_dig_port->base.base.dev;
-        struct drm_i915_private *dev_priv = to_i915(dev);
-        enum port port = intel_dig_port->port;
+        enum port port = intel_dig_port->base.port;
         uint32_t val;
 
         if (!HAS_DDI(dev_priv))
@@ -3595,13 +3578,13 @@ void intel_dp_set_idle_link_train(struct intel_dp *intel_dp)
 }
 
 static void
-intel_dp_link_down(struct intel_dp *intel_dp)
+intel_dp_link_down(struct intel_encoder *encoder,
+                   const struct intel_crtc_state *old_crtc_state)
 {
-        struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
-        struct intel_crtc *crtc = to_intel_crtc(intel_dig_port->base.base.crtc);
-        enum port port = intel_dig_port->port;
-        struct drm_device *dev = intel_dig_port->base.base.dev;
-        struct drm_i915_private *dev_priv = to_i915(dev);
+        struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
+        struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
+        struct intel_crtc *crtc = to_intel_crtc(old_crtc_state->base.crtc);
+        enum port port = encoder->port;
         uint32_t DP = intel_dp->DP;
 
         if (WARN_ON(HAS_DDI(dev_priv)))
@@ -3747,11 +3730,11 @@ intel_edp_init_dpcd(struct intel_dp *intel_dp)
         if (drm_dp_dpcd_read(&intel_dp->aux, DP_EDP_DPCD_REV,
                              intel_dp->edp_dpcd, sizeof(intel_dp->edp_dpcd)) ==
                              sizeof(intel_dp->edp_dpcd))
-                DRM_DEBUG_KMS("EDP DPCD : %*ph\n", (int) sizeof(intel_dp->edp_dpcd),
+                DRM_DEBUG_KMS("eDP DPCD: %*ph\n", (int) sizeof(intel_dp->edp_dpcd),
                               intel_dp->edp_dpcd);
 
-        /* Intermediate frequency support */
-        if (intel_dp->edp_dpcd[0] >= 0x03) { /* eDp v1.4 or higher */
+        /* Read the eDP 1.4+ supported link rates. */
+        if (intel_dp->edp_dpcd[0] >= DP_EDP_14) {
                 __le16 sink_rates[DP_MAX_SUPPORTED_RATES];
                 int i;
 
@@ -3775,6 +3758,10 @@ intel_edp_init_dpcd(struct intel_dp *intel_dp)
                 intel_dp->num_sink_rates = i;
         }
 
+        /*
+         * Use DP_LINK_RATE_SET if DP_SUPPORTED_LINK_RATES are available,
+         * default to DP_MAX_LINK_RATE and DP_LINK_BW_SET otherwise.
+         */
         if (intel_dp->num_sink_rates)
                 intel_dp->use_rate_select = true;
         else
@@ -3874,11 +3861,12 @@ intel_dp_configure_mst(struct intel_dp *intel_dp)
                                         intel_dp->is_mst);
 }
 
-static int intel_dp_sink_crc_stop(struct intel_dp *intel_dp)
+static int intel_dp_sink_crc_stop(struct intel_dp *intel_dp,
+                                  struct intel_crtc_state *crtc_state, bool disable_wa)
 {
         struct intel_digital_port *dig_port = dp_to_dig_port(intel_dp);
         struct drm_i915_private *dev_priv = to_i915(dig_port->base.base.dev);
-        struct intel_crtc *intel_crtc = to_intel_crtc(dig_port->base.base.crtc);
+        struct intel_crtc *intel_crtc = to_intel_crtc(crtc_state->base.crtc);
         u8 buf;
         int ret = 0;
         int count = 0;
@@ -3914,15 +3902,17 @@ static int intel_dp_sink_crc_stop(struct intel_dp *intel_dp)
         }
 
  out:
-        hsw_enable_ips(intel_crtc);
+        if (disable_wa)
+                hsw_enable_ips(crtc_state);
         return ret;
 }
 
-static int intel_dp_sink_crc_start(struct intel_dp *intel_dp)
+static int intel_dp_sink_crc_start(struct intel_dp *intel_dp,
+                                   struct intel_crtc_state *crtc_state)
 {
         struct intel_digital_port *dig_port = dp_to_dig_port(intel_dp);
         struct drm_i915_private *dev_priv = to_i915(dig_port->base.base.dev);
-        struct intel_crtc *intel_crtc = to_intel_crtc(dig_port->base.base.crtc);
+        struct intel_crtc *intel_crtc = to_intel_crtc(crtc_state->base.crtc);
         u8 buf;
         int ret;
 
@@ -3936,16 +3926,16 @@ static int intel_dp_sink_crc_start(struct intel_dp *intel_dp)
                 return -EIO;
 
         if (buf & DP_TEST_SINK_START) {
-                ret = intel_dp_sink_crc_stop(intel_dp);
+                ret = intel_dp_sink_crc_stop(intel_dp, crtc_state, false);
                 if (ret)
                         return ret;
         }
 
-        hsw_disable_ips(intel_crtc);
+        hsw_disable_ips(crtc_state);
 
         if (drm_dp_dpcd_writeb(&intel_dp->aux, DP_TEST_SINK,
                                buf | DP_TEST_SINK_START) < 0) {
-                hsw_enable_ips(intel_crtc);
+                hsw_enable_ips(crtc_state);
                 return -EIO;
         }
 
@@ -3953,16 +3943,16 @@ static int intel_dp_sink_crc_start(struct intel_dp *intel_dp)
         return 0;
 }
 
-int intel_dp_sink_crc(struct intel_dp *intel_dp, u8 *crc)
+int intel_dp_sink_crc(struct intel_dp *intel_dp, struct intel_crtc_state *crtc_state, u8 *crc)
 {
         struct intel_digital_port *dig_port = dp_to_dig_port(intel_dp);
         struct drm_i915_private *dev_priv = to_i915(dig_port->base.base.dev);
-        struct intel_crtc *intel_crtc = to_intel_crtc(dig_port->base.base.crtc);
+        struct intel_crtc *intel_crtc = to_intel_crtc(crtc_state->base.crtc);
         u8 buf;
         int count, ret;
         int attempts = 6;
 
-        ret = intel_dp_sink_crc_start(intel_dp);
+        ret = intel_dp_sink_crc_start(intel_dp, crtc_state);
         if (ret)
                 return ret;
 
@@ -3990,7 +3980,7 @@ int intel_dp_sink_crc(struct intel_dp *intel_dp, u8 *crc)
         }
 
 stop:
-        intel_dp_sink_crc_stop(intel_dp);
+        intel_dp_sink_crc_stop(intel_dp, crtc_state, true);
         return ret;
 }
 
@@ -4285,11 +4275,11 @@ intel_dp_retrain_link(struct intel_dp *intel_dp)
 static void
 intel_dp_check_link_status(struct intel_dp *intel_dp)
 {
+        struct drm_i915_private *dev_priv = to_i915(intel_dp_to_dev(intel_dp));
         struct intel_encoder *intel_encoder = &dp_to_dig_port(intel_dp)->base;
-        struct drm_device *dev = intel_dp_to_dev(intel_dp);
         u8 link_status[DP_LINK_STATUS_SIZE];
 
-        WARN_ON(!drm_modeset_is_locked(&dev->mode_config.connection_mutex));
+        WARN_ON(!drm_modeset_is_locked(&dev_priv->drm.mode_config.connection_mutex));
 
         if (!intel_dp_get_link_status(intel_dp, link_status)) {
                 DRM_ERROR("Failed to get link status\n");
@@ -4335,8 +4325,7 @@ intel_dp_check_link_status(struct intel_dp *intel_dp)
 static bool
 intel_dp_short_pulse(struct intel_dp *intel_dp)
 {
-        struct drm_device *dev = intel_dp_to_dev(intel_dp);
-        struct intel_encoder *intel_encoder = &dp_to_dig_port(intel_dp)->base;
+        struct drm_i915_private *dev_priv = to_i915(intel_dp_to_dev(intel_dp));
         u8 sink_irq_vector = 0;
         u8 old_sink_count = intel_dp->sink_count;
         bool ret;
@@ -4375,13 +4364,13 @@ intel_dp_short_pulse(struct intel_dp *intel_dp)
                         DRM_DEBUG_DRIVER("CP or sink specific irq unhandled\n");
         }
 
-        drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
+        drm_modeset_lock(&dev_priv->drm.mode_config.connection_mutex, NULL);
         intel_dp_check_link_status(intel_dp);
-        drm_modeset_unlock(&dev->mode_config.connection_mutex);
+        drm_modeset_unlock(&dev_priv->drm.mode_config.connection_mutex);
         if (intel_dp->compliance.test_type == DP_TEST_LINK_TRAINING) {
                 DRM_DEBUG_KMS("Link Training Compliance Test requested\n");
                 /* Send a Hotplug Uevent to userspace to start modeset */
-                drm_kms_helper_hotplug_event(intel_encoder->base.dev);
+                drm_kms_helper_hotplug_event(&dev_priv->drm);
         }
 
         return true;
@@ -4445,8 +4434,7 @@ intel_dp_detect_dpcd(struct intel_dp *intel_dp)
 static enum drm_connector_status
 edp_detect(struct intel_dp *intel_dp)
 {
-        struct drm_device *dev = intel_dp_to_dev(intel_dp);
-        struct drm_i915_private *dev_priv = to_i915(dev);
+        struct drm_i915_private *dev_priv = to_i915(intel_dp_to_dev(intel_dp));
         enum drm_connector_status status;
 
         status = intel_panel_detect(dev_priv);
@@ -4461,7 +4449,7 @@ static bool ibx_digital_port_connected(struct drm_i915_private *dev_priv,
 {
         u32 bit;
 
-        switch (port->port) {
+        switch (port->base.port) {
         case PORT_B:
                 bit = SDE_PORTB_HOTPLUG;
                 break;
@@ -4472,7 +4460,7 @@ static bool ibx_digital_port_connected(struct drm_i915_private *dev_priv,
                 bit = SDE_PORTD_HOTPLUG;
                 break;
         default:
-                MISSING_CASE(port->port);
+                MISSING_CASE(port->base.port);
                 return false;
         }
 
@@ -4484,7 +4472,7 @@ static bool cpt_digital_port_connected(struct drm_i915_private *dev_priv,
 {
         u32 bit;
 
-        switch (port->port) {
+        switch (port->base.port) {
         case PORT_B:
                 bit = SDE_PORTB_HOTPLUG_CPT;
                 break;
@@ -4495,7 +4483,7 @@ static bool cpt_digital_port_connected(struct drm_i915_private *dev_priv,
                 bit = SDE_PORTD_HOTPLUG_CPT;
                 break;
         default:
-                MISSING_CASE(port->port);
+                MISSING_CASE(port->base.port);
                 return false;
         }
 
@@ -4507,7 +4495,7 @@ static bool spt_digital_port_connected(struct drm_i915_private *dev_priv,
 {
         u32 bit;
 
-        switch (port->port) {
+        switch (port->base.port) {
         case PORT_A:
                 bit = SDE_PORTA_HOTPLUG_SPT;
                 break;
@@ -4526,7 +4514,7 @@ static bool g4x_digital_port_connected(struct drm_i915_private *dev_priv,
 {
         u32 bit;
 
-        switch (port->port) {
+        switch (port->base.port) {
         case PORT_B:
                 bit = PORTB_HOTPLUG_LIVE_STATUS_G4X;
                 break;
@@ -4537,7 +4525,7 @@ static bool g4x_digital_port_connected(struct drm_i915_private *dev_priv,
                 bit = PORTD_HOTPLUG_LIVE_STATUS_G4X;
                 break;
         default:
-                MISSING_CASE(port->port);
+                MISSING_CASE(port->base.port);
                 return false;
         }
 
@@ -4549,7 +4537,7 @@ static bool gm45_digital_port_connected(struct drm_i915_private *dev_priv,
 {
         u32 bit;
 
-        switch (port->port) {
+        switch (port->base.port) {
         case PORT_B:
                 bit = PORTB_HOTPLUG_LIVE_STATUS_GM45;
                 break;
@@ -4560,7 +4548,7 @@ static bool gm45_digital_port_connected(struct drm_i915_private *dev_priv,
                 bit = PORTD_HOTPLUG_LIVE_STATUS_GM45;
                 break;
         default:
-                MISSING_CASE(port->port);
+                MISSING_CASE(port->base.port);
                 return false;
         }
 
@@ -4570,7 +4558,7 @@ static bool gm45_digital_port_connected(struct drm_i915_private *dev_priv,
 static bool ilk_digital_port_connected(struct drm_i915_private *dev_priv,
                                        struct intel_digital_port *port)
 {
-        if (port->port == PORT_A)
+        if (port->base.port == PORT_A)
                 return I915_READ(DEISR) & DE_DP_A_HOTPLUG;
         else
                 return ibx_digital_port_connected(dev_priv, port);
@@ -4579,7 +4567,7 @@ static bool ilk_digital_port_connected(struct drm_i915_private *dev_priv,
 static bool snb_digital_port_connected(struct drm_i915_private *dev_priv,
                                        struct intel_digital_port *port)
 {
-        if (port->port == PORT_A)
+        if (port->base.port == PORT_A)
                 return I915_READ(DEISR) & DE_DP_A_HOTPLUG;
         else
                 return cpt_digital_port_connected(dev_priv, port);
@@ -4588,7 +4576,7 @@ static bool snb_digital_port_connected(struct drm_i915_private *dev_priv,
 static bool ivb_digital_port_connected(struct drm_i915_private *dev_priv,
                                        struct intel_digital_port *port)
 {
-        if (port->port == PORT_A)
+        if (port->base.port == PORT_A)
                 return I915_READ(DEISR) & DE_DP_A_HOTPLUG_IVB;
         else
                 return cpt_digital_port_connected(dev_priv, port);
@@ -4597,7 +4585,7 @@ static bool ivb_digital_port_connected(struct drm_i915_private *dev_priv,
 static bool bdw_digital_port_connected(struct drm_i915_private *dev_priv,
                                        struct intel_digital_port *port)
 {
-        if (port->port == PORT_A)
+        if (port->base.port == PORT_A)
                 return I915_READ(GEN8_DE_PORT_ISR) & GEN8_PORT_DP_A_HOTPLUG;
         else
                 return cpt_digital_port_connected(dev_priv, port);
@@ -4702,24 +4690,21 @@ intel_dp_unset_edid(struct intel_dp *intel_dp)
 }
 
 static int
-intel_dp_long_pulse(struct intel_connector *intel_connector)
+intel_dp_long_pulse(struct intel_connector *connector)
 {
-        struct drm_connector *connector = &intel_connector->base;
-        struct intel_dp *intel_dp = intel_attached_dp(connector);
-        struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
-        struct intel_encoder *intel_encoder = &intel_dig_port->base;
-        struct drm_device *dev = connector->dev;
+        struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+        struct intel_dp *intel_dp = intel_attached_dp(&connector->base);
         enum drm_connector_status status;
         u8 sink_irq_vector = 0;
 
-        WARN_ON(!drm_modeset_is_locked(&connector->dev->mode_config.connection_mutex));
+        WARN_ON(!drm_modeset_is_locked(&dev_priv->drm.mode_config.connection_mutex));
 
-        intel_display_power_get(to_i915(dev), intel_dp->aux_power_domain);
+        intel_display_power_get(dev_priv, intel_dp->aux_power_domain);
 
         /* Can't disconnect eDP, but you can close the lid... */
         if (intel_dp_is_edp(intel_dp))
                 status = edp_detect(intel_dp);
-        else if (intel_digital_port_connected(to_i915(dev),
+        else if (intel_digital_port_connected(dev_priv,
                                               dp_to_dig_port(intel_dp)))
                 status = intel_dp_detect_dpcd(intel_dp);
         else
@@ -4740,9 +4725,6 @@ intel_dp_long_pulse(struct intel_connector *intel_connector)
                 goto out;
         }
 
-        if (intel_encoder->type != INTEL_OUTPUT_EDP)
-                intel_encoder->type = INTEL_OUTPUT_DP;
-
         if (intel_dp->reset_link_params) {
                 /* Initial max link lane count */
                 intel_dp->max_link_lane_count = intel_dp_max_common_lane_count(intel_dp);
@@ -4793,7 +4775,7 @@ intel_dp_long_pulse(struct intel_connector *intel_connector)
         intel_dp->aux.i2c_defer_count = 0;
 
         intel_dp_set_edid(intel_dp);
-        if (intel_dp_is_edp(intel_dp) || intel_connector->detect_edid)
+        if (intel_dp_is_edp(intel_dp) || connector->detect_edid)
                 status = connector_status_connected;
         intel_dp->detect_done = true;
 
@@ -4816,7 +4798,7 @@ out:
         if (status != connector_status_connected && !intel_dp->is_mst)
                 intel_dp_unset_edid(intel_dp);
 
-        intel_display_power_put(to_i915(dev), intel_dp->aux_power_domain);
+        intel_display_power_put(dev_priv, intel_dp->aux_power_domain);
         return status;
 }
 
@@ -4859,9 +4841,6 @@ intel_dp_force(struct drm_connector *connector)
         intel_dp_set_edid(intel_dp);
 
         intel_display_power_put(dev_priv, intel_dp->aux_power_domain);
-
-        if (intel_encoder->type != INTEL_OUTPUT_EDP)
-                intel_encoder->type = INTEL_OUTPUT_DP;
 }
 
 static int intel_dp_get_modes(struct drm_connector *connector)
@@ -4986,9 +4965,7 @@ void intel_dp_encoder_suspend(struct intel_encoder *intel_encoder)
 
 static void intel_edp_panel_vdd_sanitize(struct intel_dp *intel_dp)
 {
-        struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
-        struct drm_device *dev = intel_dig_port->base.base.dev;
-        struct drm_i915_private *dev_priv = to_i915(dev);
+        struct drm_i915_private *dev_priv = to_i915(intel_dp_to_dev(intel_dp));
 
         lockdep_assert_held(&dev_priv->pps_mutex);
 
@@ -5041,7 +5018,7 @@ void intel_dp_encoder_reset(struct drm_encoder *encoder)
 
         if (intel_dp_is_edp(intel_dp)) {
                 /* Reinit the power sequencer, in case BIOS did something with it. */
-                intel_dp_pps_init(encoder->dev, intel_dp);
+                intel_dp_pps_init(intel_dp);
                 intel_edp_panel_vdd_sanitize(intel_dp);
         }
 
@@ -5076,14 +5053,9 @@ enum irqreturn
 intel_dp_hpd_pulse(struct intel_digital_port *intel_dig_port, bool long_hpd)
 {
         struct intel_dp *intel_dp = &intel_dig_port->dp;
-        struct drm_device *dev = intel_dig_port->base.base.dev;
-        struct drm_i915_private *dev_priv = to_i915(dev);
+        struct drm_i915_private *dev_priv = to_i915(intel_dp_to_dev(intel_dp));
         enum irqreturn ret = IRQ_NONE;
 
-        if (intel_dig_port->base.type != INTEL_OUTPUT_EDP &&
-            intel_dig_port->base.type != INTEL_OUTPUT_HDMI)
-                intel_dig_port->base.type = INTEL_OUTPUT_DP;
-
         if (long_hpd && intel_dig_port->base.type == INTEL_OUTPUT_EDP) {
                 /*
                  * vdd off can generate a long pulse on eDP which
@@ -5092,12 +5064,12 @@ intel_dp_hpd_pulse(struct intel_digital_port *intel_dig_port, bool long_hpd)
                  * "vdd off -> long hpd -> vdd on -> detect -> vdd off -> ..."
                  */
                 DRM_DEBUG_KMS("ignoring long hpd on eDP port %c\n",
-                              port_name(intel_dig_port->port));
+                              port_name(intel_dig_port->base.port));
                 return IRQ_HANDLED;
         }
 
         DRM_DEBUG_KMS("got hpd irq on port %c - %s\n",
-                      port_name(intel_dig_port->port),
+                      port_name(intel_dig_port->base.port),
                       long_hpd ? "long" : "short");
 
         if (long_hpd) {
@@ -5185,13 +5157,13 @@ static void intel_dp_init_panel_power_timestamps(struct intel_dp *intel_dp)
 }
 
 static void
-intel_pps_readout_hw_state(struct drm_i915_private *dev_priv,
-                           struct intel_dp *intel_dp, struct edp_power_seq *seq)
+intel_pps_readout_hw_state(struct intel_dp *intel_dp, struct edp_power_seq *seq)
 {
+        struct drm_i915_private *dev_priv = to_i915(intel_dp_to_dev(intel_dp));
         u32 pp_on, pp_off, pp_div = 0, pp_ctl = 0;
         struct pps_registers regs;
 
-        intel_pps_get_registers(dev_priv, intel_dp, &regs);
+        intel_pps_get_registers(intel_dp, &regs);
 
         /* Workaround: Need to write PP_CONTROL with the unlock key as
          * the very first thing. */
@@ -5235,13 +5207,12 @@ intel_pps_dump_state(const char *state_name, const struct edp_power_seq *seq)
 }
 
 static void
-intel_pps_verify_state(struct drm_i915_private *dev_priv,
-                       struct intel_dp *intel_dp)
+intel_pps_verify_state(struct intel_dp *intel_dp)
 {
         struct edp_power_seq hw;
         struct edp_power_seq *sw = &intel_dp->pps_delays;
 
-        intel_pps_readout_hw_state(dev_priv, intel_dp, &hw);
+        intel_pps_readout_hw_state(intel_dp, &hw);
 
         if (hw.t1_t3 != sw->t1_t3 || hw.t8 != sw->t8 || hw.t9 != sw->t9 ||
             hw.t10 != sw->t10 || hw.t11_t12 != sw->t11_t12) {
@@ -5252,10 +5223,9 @@ intel_pps_verify_state(struct drm_i915_private *dev_priv,
 }
 
 static void
-intel_dp_init_panel_power_sequencer(struct drm_device *dev,
-                                    struct intel_dp *intel_dp)
+intel_dp_init_panel_power_sequencer(struct intel_dp *intel_dp)
 {
-        struct drm_i915_private *dev_priv = to_i915(dev);
+        struct drm_i915_private *dev_priv = to_i915(intel_dp_to_dev(intel_dp));
         struct edp_power_seq cur, vbt, spec,
                 *final = &intel_dp->pps_delays;
 
@@ -5265,7 +5235,7 @@ intel_dp_init_panel_power_sequencer(struct drm_device *dev,
         if (final->t11_t12 != 0)
                 return;
 
-        intel_pps_readout_hw_state(dev_priv, intel_dp, &cur);
+        intel_pps_readout_hw_state(intel_dp, &cur);
 
         intel_pps_dump_state("cur", &cur);
 
@@ -5339,20 +5309,19 @@ intel_dp_init_panel_power_sequencer(struct drm_device *dev,
 }
 
 static void
-intel_dp_init_panel_power_sequencer_registers(struct drm_device *dev,
-                                              struct intel_dp *intel_dp,
+intel_dp_init_panel_power_sequencer_registers(struct intel_dp *intel_dp,
                                               bool force_disable_vdd)
 {
-        struct drm_i915_private *dev_priv = to_i915(dev);
+        struct drm_i915_private *dev_priv = to_i915(intel_dp_to_dev(intel_dp));
         u32 pp_on, pp_off, pp_div, port_sel = 0;
         int div = dev_priv->rawclk_freq / 1000;
         struct pps_registers regs;
-        enum port port = dp_to_dig_port(intel_dp)->port;
+        enum port port = dp_to_dig_port(intel_dp)->base.port;
         const struct edp_power_seq *seq = &intel_dp->pps_delays;
 
         lockdep_assert_held(&dev_priv->pps_mutex);
 
-        intel_pps_get_registers(dev_priv, intel_dp, &regs);
+        intel_pps_get_registers(intel_dp, &regs);
 
         /*
          * On some VLV machines the BIOS can leave the VDD
@@ -5424,16 +5393,15 @@ intel_dp_init_panel_power_sequencer_registers(struct drm_device *dev,
                       I915_READ(regs.pp_div));
 }
 
-static void intel_dp_pps_init(struct drm_device *dev,
-                              struct intel_dp *intel_dp)
+static void intel_dp_pps_init(struct intel_dp *intel_dp)
 {
-        struct drm_i915_private *dev_priv = to_i915(dev);
+        struct drm_i915_private *dev_priv = to_i915(intel_dp_to_dev(intel_dp));
 
         if (IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv)) {
                 vlv_initial_power_sequencer_setup(intel_dp);
         } else {
-                intel_dp_init_panel_power_sequencer(dev, intel_dp);
-                intel_dp_init_panel_power_sequencer_registers(dev, intel_dp, false);
+                intel_dp_init_panel_power_sequencer(intel_dp);
+                intel_dp_init_panel_power_sequencer_registers(intel_dp, false);
         }
 }
 
@@ -5472,7 +5440,6 @@ static void intel_dp_set_drrs_state(struct drm_i915_private *dev_priv,
 
         dig_port = dp_to_dig_port(intel_dp);
         encoder = &dig_port->base;
-        intel_crtc = to_intel_crtc(encoder->base.crtc);
 
         if (!intel_crtc) {
                 DRM_DEBUG_KMS("DRRS: intel_crtc not initialized\n");
@@ -5545,8 +5512,7 @@ static void intel_dp_set_drrs_state(struct drm_i915_private *dev_priv,
 void intel_edp_drrs_enable(struct intel_dp *intel_dp,
                            const struct intel_crtc_state *crtc_state)
 {
-        struct drm_device *dev = intel_dp_to_dev(intel_dp);
-        struct drm_i915_private *dev_priv = to_i915(dev);
+        struct drm_i915_private *dev_priv = to_i915(intel_dp_to_dev(intel_dp));
 
         if (!crtc_state->has_drrs) {
                 DRM_DEBUG_KMS("Panel doesn't support DRRS\n");
@@ -5581,8 +5547,7 @@ unlock:
 void intel_edp_drrs_disable(struct intel_dp *intel_dp,
                             const struct intel_crtc_state *old_crtc_state)
 {
-        struct drm_device *dev = intel_dp_to_dev(intel_dp);
-        struct drm_i915_private *dev_priv = to_i915(dev);
+        struct drm_i915_private *dev_priv = to_i915(intel_dp_to_dev(intel_dp));
 
         if (!old_crtc_state->has_drrs)
                 return;
@@ -5765,7 +5730,7 @@ void intel_edp_drrs_flush(struct drm_i915_private *dev_priv,
 
 /**
  * intel_dp_drrs_init - Init basic DRRS work and mutex.
- * @intel_connector: eDP connector
+ * @connector: eDP connector
  * @fixed_mode: preferred mode of panel
  *
  * This function is  called only once at driver load to initialize basic
@@ -5777,12 +5742,10 @@ void intel_edp_drrs_flush(struct drm_i915_private *dev_priv,
  * from VBT setting).
  */
 static struct drm_display_mode *
-intel_dp_drrs_init(struct intel_connector *intel_connector,
-                struct drm_display_mode *fixed_mode)
+intel_dp_drrs_init(struct intel_connector *connector,
+                   struct drm_display_mode *fixed_mode)
 {
-        struct drm_connector *connector = &intel_connector->base;
-        struct drm_device *dev = connector->dev;
-        struct drm_i915_private *dev_priv = to_i915(dev);
+        struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
         struct drm_display_mode *downclock_mode = NULL;
 
         INIT_DELAYED_WORK(&dev_priv->drrs.work, intel_edp_drrs_downclock_work);
@@ -5798,8 +5761,8 @@ intel_dp_drrs_init(struct intel_connector *intel_connector,
                 return NULL;
         }
 
-        downclock_mode = intel_find_panel_downclock
-                                        (dev_priv, fixed_mode, connector);
+        downclock_mode = intel_find_panel_downclock(dev_priv, fixed_mode,
+                                                    &connector->base);
 
         if (!downclock_mode) {
                 DRM_DEBUG_KMS("Downclock mode is not found. DRRS not supported\n");
@@ -5816,11 +5779,9 @@ intel_dp_drrs_init(struct intel_connector *intel_connector,
 static bool intel_edp_init_connector(struct intel_dp *intel_dp,
                                      struct intel_connector *intel_connector)
 {
-        struct drm_connector *connector = &intel_connector->base;
-        struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp);
-        struct intel_encoder *intel_encoder = &intel_dig_port->base;
-        struct drm_device *dev = intel_encoder->base.dev;
+        struct drm_device *dev = intel_dp_to_dev(intel_dp);
         struct drm_i915_private *dev_priv = to_i915(dev);
+        struct drm_connector *connector = &intel_connector->base;
         struct drm_display_mode *fixed_mode = NULL;
         struct drm_display_mode *alt_fixed_mode = NULL;
         struct drm_display_mode *downclock_mode = NULL;
@@ -5838,7 +5799,7 @@ static bool intel_edp_init_connector(struct intel_dp *intel_dp,
          * eDP and LVDS bail out early in this case to prevent interfering
          * with an already powered-on LVDS power sequencer.
          */
-        if (intel_get_lvds_encoder(dev)) {
+        if (intel_get_lvds_encoder(&dev_priv->drm)) {
                 WARN_ON(!(HAS_PCH_IBX(dev_priv) || HAS_PCH_CPT(dev_priv)));
                 DRM_INFO("LVDS was detected, not registering eDP\n");
 
@@ -5848,7 +5809,7 @@ static bool intel_edp_init_connector(struct intel_dp *intel_dp,
         pps_lock(intel_dp);
 
         intel_dp_init_panel_power_timestamps(intel_dp);
-        intel_dp_pps_init(dev, intel_dp);
+        intel_dp_pps_init(intel_dp);
         intel_edp_panel_vdd_sanitize(intel_dp);
 
         pps_unlock(intel_dp);
@@ -5948,9 +5909,9 @@ intel_dp_init_connector_port_info(struct intel_digital_port *intel_dig_port)
         struct intel_encoder *encoder = &intel_dig_port->base;
         struct intel_dp *intel_dp = &intel_dig_port->dp;
 
-        encoder->hpd_pin = intel_hpd_pin(intel_dig_port->port);
+        encoder->hpd_pin = intel_hpd_pin(encoder->port);
 
-        switch (intel_dig_port->port) {
+        switch (encoder->port) {
         case PORT_A:
                 intel_dp->aux_power_domain = POWER_DOMAIN_AUX_A;
                 break;
@@ -5968,7 +5929,7 @@ intel_dp_init_connector_port_info(struct intel_digital_port *intel_dig_port)
                 intel_dp->aux_power_domain = POWER_DOMAIN_AUX_D;
                 break;
         default:
-                MISSING_CASE(intel_dig_port->port);
+                MISSING_CASE(encoder->port);
         }
 }
 
@@ -6004,7 +5965,7 @@ intel_dp_init_connector(struct intel_digital_port *intel_dig_port,
         struct intel_encoder *intel_encoder = &intel_dig_port->base;
         struct drm_device *dev = intel_encoder->base.dev;
         struct drm_i915_private *dev_priv = to_i915(dev);
-        enum port port = intel_dig_port->port;
+        enum port port = intel_encoder->port;
         int type;
 
         /* Initialize the work for modeset in case of link train failure */
@@ -6174,7 +6135,6 @@ bool intel_dp_init(struct drm_i915_private *dev_priv,
                 intel_encoder->disable = g4x_disable_dp;
         }
 
-        intel_dig_port->port = port;
         intel_dig_port->dp.output_reg = output_reg;
         intel_dig_port->max_lanes = 4;