static void intel_c10pll_update_pll(struct intel_crtc_state *crtc_state,
                                    struct intel_encoder *encoder)
 {
+       struct intel_display *display = to_intel_display(encoder);
        struct drm_i915_private *i915 = to_i915(encoder->base.dev);
        struct intel_cx0pll_state *pll_state = &crtc_state->dpll_hw_state.cx0pll;
        int i;
 
        if (intel_crtc_has_dp_encoder(crtc_state)) {
-               if (intel_panel_use_ssc(i915)) {
+               if (intel_panel_use_ssc(display)) {
                        struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
 
                        pll_state->ssc_enabled =
 
                     const struct dpll *clock,
                     const struct dpll *reduced_clock)
 {
+       struct intel_display *display = to_intel_display(crtc_state);
        struct intel_crtc *crtc = to_intel_crtc(crtc_state->uapi.crtc);
        struct drm_i915_private *dev_priv = to_i915(crtc->base.dev);
        u32 dpll;
        if (crtc_state->sdvo_tv_clock)
                dpll |= PLL_REF_INPUT_TVCLKINBC;
        else if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_LVDS) &&
-                intel_panel_use_ssc(dev_priv))
+                intel_panel_use_ssc(display))
                dpll |= PLLB_REF_INPUT_SPREADSPECTRUMIN;
        else
                dpll |= PLL_REF_INPUT_DREFCLK;
                     const struct dpll *clock,
                     const struct dpll *reduced_clock)
 {
+       struct intel_display *display = to_intel_display(crtc_state);
        struct intel_crtc *crtc = to_intel_crtc(crtc_state->uapi.crtc);
        struct drm_i915_private *dev_priv = to_i915(crtc->base.dev);
        u32 dpll;
                dpll |= DPLL_DVO_2X_MODE;
 
        if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_LVDS) &&
-           intel_panel_use_ssc(dev_priv))
+           intel_panel_use_ssc(display))
                dpll |= PLLB_REF_INPUT_SPREADSPECTRUMIN;
        else
                dpll |= PLL_REF_INPUT_DREFCLK;
 
 static int ilk_fb_cb_factor(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);
        struct drm_i915_private *i915 = to_i915(crtc->base.dev);
 
        if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_LVDS) &&
-           ((intel_panel_use_ssc(i915) && i915->display.vbt.lvds_ssc_freq == 100000) ||
+           ((intel_panel_use_ssc(display) && i915->display.vbt.lvds_ssc_freq == 100000) ||
             (HAS_PCH_IBX(i915) && intel_is_dual_link_lvds(i915))))
                return 25;
 
                    const struct dpll *clock,
                    const struct dpll *reduced_clock)
 {
+       struct intel_display *display = to_intel_display(crtc_state);
        struct intel_crtc *crtc = to_intel_crtc(crtc_state->uapi.crtc);
        struct drm_i915_private *dev_priv = to_i915(crtc->base.dev);
        u32 dpll;
        WARN_ON(reduced_clock->p2 != clock->p2);
 
        if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_LVDS) &&
-           intel_panel_use_ssc(dev_priv))
+           intel_panel_use_ssc(display))
                dpll |= PLLB_REF_INPUT_SPREADSPECTRUMIN;
        else
                dpll |= PLL_REF_INPUT_DREFCLK;
 static int ilk_crtc_compute_clock(struct intel_atomic_state *state,
                                  struct intel_crtc *crtc)
 {
+       struct intel_display *display = to_intel_display(state);
        struct drm_i915_private *dev_priv = to_i915(state->base.dev);
        struct intel_crtc_state *crtc_state =
                intel_atomic_get_new_crtc_state(state, crtc);
                return 0;
 
        if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_LVDS)) {
-               if (intel_panel_use_ssc(dev_priv)) {
+               if (intel_panel_use_ssc(display)) {
                        drm_dbg_kms(&dev_priv->drm,
                                    "using SSC reference clock of %d kHz\n",
                                    dev_priv->display.vbt.lvds_ssc_freq);
 static int g4x_crtc_compute_clock(struct intel_atomic_state *state,
                                  struct intel_crtc *crtc)
 {
+       struct intel_display *display = to_intel_display(state);
        struct drm_i915_private *dev_priv = to_i915(state->base.dev);
        struct intel_crtc_state *crtc_state =
                intel_atomic_get_new_crtc_state(state, crtc);
        int refclk = 96000;
 
        if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_LVDS)) {
-               if (intel_panel_use_ssc(dev_priv)) {
+               if (intel_panel_use_ssc(display)) {
                        refclk = dev_priv->display.vbt.lvds_ssc_freq;
                        drm_dbg_kms(&dev_priv->drm,
                                    "using SSC reference clock of %d kHz\n",
 static int pnv_crtc_compute_clock(struct intel_atomic_state *state,
                                  struct intel_crtc *crtc)
 {
+       struct intel_display *display = to_intel_display(state);
        struct drm_i915_private *dev_priv = to_i915(state->base.dev);
        struct intel_crtc_state *crtc_state =
                intel_atomic_get_new_crtc_state(state, crtc);
        int refclk = 96000;
 
        if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_LVDS)) {
-               if (intel_panel_use_ssc(dev_priv)) {
+               if (intel_panel_use_ssc(display)) {
                        refclk = dev_priv->display.vbt.lvds_ssc_freq;
                        drm_dbg_kms(&dev_priv->drm,
                                    "using SSC reference clock of %d kHz\n",
 static int i9xx_crtc_compute_clock(struct intel_atomic_state *state,
                                   struct intel_crtc *crtc)
 {
+       struct intel_display *display = to_intel_display(state);
        struct drm_i915_private *dev_priv = to_i915(state->base.dev);
        struct intel_crtc_state *crtc_state =
                intel_atomic_get_new_crtc_state(state, crtc);
        int refclk = 96000;
 
        if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_LVDS)) {
-               if (intel_panel_use_ssc(dev_priv)) {
+               if (intel_panel_use_ssc(display)) {
                        refclk = dev_priv->display.vbt.lvds_ssc_freq;
                        drm_dbg_kms(&dev_priv->drm,
                                    "using SSC reference clock of %d kHz\n",
 static int i8xx_crtc_compute_clock(struct intel_atomic_state *state,
                                   struct intel_crtc *crtc)
 {
+       struct intel_display *display = to_intel_display(state);
        struct drm_i915_private *dev_priv = to_i915(state->base.dev);
        struct intel_crtc_state *crtc_state =
                intel_atomic_get_new_crtc_state(state, crtc);
        int refclk = 48000;
 
        if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_LVDS)) {
-               if (intel_panel_use_ssc(dev_priv)) {
+               if (intel_panel_use_ssc(display)) {
                        refclk = dev_priv->display.vbt.lvds_ssc_freq;
                        drm_dbg_kms(&dev_priv->drm,
                                    "using SSC reference clock of %d kHz\n",
 
 #include "intel_quirks.h"
 #include "intel_vrr.h"
 
-bool intel_panel_use_ssc(struct drm_i915_private *i915)
+bool intel_panel_use_ssc(struct intel_display *display)
 {
-       struct intel_display *display = &i915->display;
-
        if (display->params.panel_use_ssc >= 0)
                return display->params.panel_use_ssc != 0;
        return display->vbt.lvds_use_ssc &&
 
 static void intel_panel_add_edid_alt_fixed_modes(struct intel_connector *connector)
 {
-       struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+       struct intel_display *display = to_intel_display(connector);
        const struct drm_display_mode *preferred_mode =
                intel_panel_preferred_fixed_mode(connector);
        struct drm_display_mode *mode, *next;
                if (!is_alt_fixed_mode(mode, preferred_mode))
                        continue;
 
-               drm_dbg_kms(&dev_priv->drm,
+               drm_dbg_kms(display->drm,
                            "[CONNECTOR:%d:%s] using alternate EDID fixed mode: " DRM_MODE_FMT "\n",
                            connector->base.base.id, connector->base.name,
                            DRM_MODE_ARG(mode));
 
 static void intel_panel_add_edid_preferred_mode(struct intel_connector *connector)
 {
-       struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
+       struct intel_display *display = to_intel_display(connector);
        struct drm_display_mode *scan, *fixed_mode = NULL;
 
        if (list_empty(&connector->base.probed_modes))
                fixed_mode = list_first_entry(&connector->base.probed_modes,
                                              typeof(*fixed_mode), head);
 
-       drm_dbg_kms(&dev_priv->drm,
+       drm_dbg_kms(display->drm,
                    "[CONNECTOR:%d:%s] using %s EDID fixed mode: " DRM_MODE_FMT "\n",
                    connector->base.base.id, connector->base.name,
                    fixed_mode->type & DRM_MODE_TYPE_PREFERRED ? "preferred" : "first",
 
 static void intel_panel_destroy_probed_modes(struct intel_connector *connector)
 {
-       struct drm_i915_private *i915 = to_i915(connector->base.dev);
+       struct intel_display *display = to_intel_display(connector);
        struct drm_display_mode *mode, *next;
 
        list_for_each_entry_safe(mode, next, &connector->base.probed_modes, head) {
-               drm_dbg_kms(&i915->drm,
+               drm_dbg_kms(display->drm,
                            "[CONNECTOR:%d:%s] not using EDID mode: " DRM_MODE_FMT "\n",
                            connector->base.base.id, connector->base.name,
                            DRM_MODE_ARG(mode));
                list_del(&mode->head);
-               drm_mode_destroy(&i915->drm, mode);
+               drm_mode_destroy(display->drm, mode);
        }
 }
 
                                       struct drm_display_mode *fixed_mode,
                                       const char *type)
 {
-       struct drm_i915_private *i915 = to_i915(connector->base.dev);
+       struct intel_display *display = to_intel_display(connector);
        struct drm_display_info *info = &connector->base.display_info;
 
        if (!fixed_mode)
        info->width_mm = fixed_mode->width_mm;
        info->height_mm = fixed_mode->height_mm;
 
-       drm_dbg_kms(&i915->drm, "[CONNECTOR:%d:%s] using %s fixed mode: " DRM_MODE_FMT "\n",
+       drm_dbg_kms(display->drm, "[CONNECTOR:%d:%s] using %s fixed mode: " DRM_MODE_FMT "\n",
                    connector->base.base.id, connector->base.name, type,
                    DRM_MODE_ARG(fixed_mode));
 
 
 void intel_panel_add_vbt_lfp_fixed_mode(struct intel_connector *connector)
 {
-       struct drm_i915_private *i915 = to_i915(connector->base.dev);
+       struct intel_display *display = to_intel_display(connector);
        const struct drm_display_mode *mode;
 
        mode = connector->panel.vbt.lfp_vbt_mode;
                return;
 
        intel_panel_add_fixed_mode(connector,
-                                  drm_mode_duplicate(&i915->drm, mode),
+                                  drm_mode_duplicate(display->drm, mode),
                                   "VBT LFP");
 }
 
 void intel_panel_add_vbt_sdvo_fixed_mode(struct intel_connector *connector)
 {
-       struct drm_i915_private *i915 = to_i915(connector->base.dev);
+       struct intel_display *display = to_intel_display(connector);
        const struct drm_display_mode *mode;
 
        mode = connector->panel.vbt.sdvo_lvds_vbt_mode;
                return;
 
        intel_panel_add_fixed_mode(connector,
-                                  drm_mode_duplicate(&i915->drm, mode),
+                                  drm_mode_duplicate(display->drm, mode),
                                   "VBT SDVO");
 }
 
 {
        struct intel_display *display = to_intel_display(crtc_state);
        struct intel_crtc *crtc = to_intel_crtc(crtc_state->uapi.crtc);
-       struct drm_i915_private *dev_priv = to_i915(crtc->base.dev);
        u32 pfit_control = 0, pfit_pgm_ratios = 0, border = 0;
        struct drm_display_mode *adjusted_mode = &crtc_state->hw.adjusted_mode;
        int pipe_src_w = drm_rect_width(&crtc_state->pipe_src);
                break;
        case DRM_MODE_SCALE_ASPECT:
                /* Scale but preserve the aspect ratio */
-               if (DISPLAY_VER(dev_priv) >= 4)
+               if (DISPLAY_VER(display) >= 4)
                        i965_scale_aspect(crtc_state, &pfit_control);
                else
                        i9xx_scale_aspect(crtc_state, &pfit_control,
                if (pipe_src_h != adjusted_mode->crtc_vdisplay ||
                    pipe_src_w != adjusted_mode->crtc_hdisplay) {
                        pfit_control |= PFIT_ENABLE;
-                       if (DISPLAY_VER(dev_priv) >= 4)
+                       if (DISPLAY_VER(display) >= 4)
                                pfit_control |= PFIT_SCALING_AUTO;
                        else
                                pfit_control |= (PFIT_VERT_AUTO_SCALE |
 
        /* 965+ wants fuzzy fitting */
        /* FIXME: handle multiple panels by failing gracefully */
-       if (DISPLAY_VER(dev_priv) >= 4)
+       if (DISPLAY_VER(display) >= 4)
                pfit_control |= PFIT_PIPE(crtc->pipe) | PFIT_FILTER_FUZZY;
 
 out:
        }
 
        /* Make sure pre-965 set dither correctly for 18bpp panels. */
-       if (DISPLAY_VER(dev_priv) < 4 && crtc_state->pipe_bpp == 18)
+       if (DISPLAY_VER(display) < 4 && crtc_state->pipe_bpp == 18)
                pfit_control |= PFIT_PANEL_8TO6_DITHER_ENABLE;
 
        crtc_state->gmch_pfit.control = pfit_control;
 int intel_panel_fitting(struct intel_crtc_state *crtc_state,
                        const struct drm_connector_state *conn_state)
 {
-       struct intel_crtc *crtc = to_intel_crtc(crtc_state->uapi.crtc);
-       struct drm_i915_private *i915 = to_i915(crtc->base.dev);
+       struct intel_display *display = to_intel_display(crtc_state);
 
-       if (HAS_GMCH(i915))
+       if (HAS_GMCH(display))
                return gmch_panel_fitting(crtc_state, conn_state);
        else
                return pch_panel_fitting(crtc_state, conn_state);
 
 struct drm_connector_state;
 struct drm_display_mode;
 struct drm_edid;
-struct drm_i915_private;
 struct intel_connector;
 struct intel_crtc_state;
+struct intel_display;
 struct intel_encoder;
 
 void intel_panel_init_alloc(struct intel_connector *connector);
 void intel_panel_fini(struct intel_connector *connector);
 enum drm_connector_status
 intel_panel_detect(struct drm_connector *connector, bool force);
-bool intel_panel_use_ssc(struct drm_i915_private *i915);
+bool intel_panel_use_ssc(struct intel_display *display);
 const struct drm_display_mode *
 intel_panel_preferred_fixed_mode(struct intel_connector *connector);
 const struct drm_display_mode *
 
 
 static void ilk_init_pch_refclk(struct drm_i915_private *dev_priv)
 {
+       struct intel_display *display = &dev_priv->display;
        struct intel_encoder *encoder;
        struct intel_shared_dpll *pll;
        int i;
        if (has_panel) {
                final |= DREF_SSC_SOURCE_ENABLE;
 
-               if (intel_panel_use_ssc(dev_priv) && can_ssc)
+               if (intel_panel_use_ssc(display) && can_ssc)
                        final |= DREF_SSC1_ENABLE;
 
                if (has_cpu_edp) {
-                       if (intel_panel_use_ssc(dev_priv) && can_ssc)
+                       if (intel_panel_use_ssc(display) && can_ssc)
                                final |= DREF_CPU_SOURCE_OUTPUT_DOWNSPREAD;
                        else
                                final |= DREF_CPU_SOURCE_OUTPUT_NONSPREAD;
                val |= DREF_SSC_SOURCE_ENABLE;
 
                /* SSC must be turned on before enabling the CPU output  */
-               if (intel_panel_use_ssc(dev_priv) && can_ssc) {
+               if (intel_panel_use_ssc(display) && can_ssc) {
                        drm_dbg_kms(&dev_priv->drm, "Using SSC on panel\n");
                        val |= DREF_SSC1_ENABLE;
                } else {
 
                /* Enable CPU source on CPU attached eDP */
                if (has_cpu_edp) {
-                       if (intel_panel_use_ssc(dev_priv) && can_ssc) {
+                       if (intel_panel_use_ssc(display) && can_ssc) {
                                drm_dbg_kms(&dev_priv->drm,
                                            "Using SSC on eDP\n");
                                val |= DREF_CPU_SOURCE_OUTPUT_DOWNSPREAD;