bool intel_connector_get_hw_state(struct intel_connector *connector)
 {
        enum pipe pipe = 0;
-       struct intel_encoder *encoder = connector->encoder;
+       struct intel_encoder *encoder = intel_attached_encoder(connector);
 
        return encoder->get_hw_state(encoder, &pipe);
 }
 
 {
        struct drm_device *dev = intel_connector->base.dev;
        struct drm_i915_private *dev_priv = to_i915(dev);
-       struct intel_encoder *encoder = intel_connector->encoder;
+       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;
 
                      connector->base.name);
 
        if (connector->get_hw_state(connector)) {
-               struct intel_encoder *encoder = connector->encoder;
+               struct intel_encoder *encoder = intel_attached_encoder(connector);
 
                I915_STATE_WARN(!crtc_state,
                         "connector enabled without attached crtc\n");
 
                        connector->base.dpms = DRM_MODE_DPMS_ON;
 
-                       encoder = connector->encoder;
+                       encoder = intel_attached_encoder(connector);
                        connector->base.encoder = &encoder->base;
 
                        crtc = to_intel_crtc(encoder->base.crtc);
 
  */
 static u32 intel_dp_aux_get_backlight(struct intel_connector *connector)
 {
-       struct intel_dp *intel_dp = enc_to_intel_dp(connector->encoder);
+       struct intel_dp *intel_dp = enc_to_intel_dp(intel_attached_encoder(connector));
        u8 read_val[2] = { 0x0 };
        u8 mode_reg;
        u16 level = 0;
 intel_dp_aux_set_backlight(const struct drm_connector_state *conn_state, u32 level)
 {
        struct intel_connector *connector = to_intel_connector(conn_state->connector);
-       struct intel_dp *intel_dp = enc_to_intel_dp(connector->encoder);
+       struct intel_dp *intel_dp = enc_to_intel_dp(intel_attached_encoder(connector));
        u8 vals[2] = { 0x0 };
 
        vals[0] = level;
 static bool intel_dp_aux_set_pwm_freq(struct intel_connector *connector)
 {
        struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
-       struct intel_dp *intel_dp = enc_to_intel_dp(connector->encoder);
+       struct intel_dp *intel_dp = enc_to_intel_dp(intel_attached_encoder(connector));
        const u8 pn = connector->panel.backlight.pwmgen_bit_count;
        int freq, fxp, f, fxp_actual, fxp_min, fxp_max;
 
                                          const struct drm_connector_state *conn_state)
 {
        struct intel_connector *connector = to_intel_connector(conn_state->connector);
-       struct intel_dp *intel_dp = enc_to_intel_dp(connector->encoder);
+       struct intel_dp *intel_dp = enc_to_intel_dp(intel_attached_encoder(connector));
        struct intel_panel *panel = &connector->panel;
        u8 dpcd_buf, new_dpcd_buf, edp_backlight_mode;
 
 static u32 intel_dp_aux_calc_max_backlight(struct intel_connector *connector)
 {
        struct drm_i915_private *i915 = to_i915(connector->base.dev);
-       struct intel_dp *intel_dp = enc_to_intel_dp(connector->encoder);
+       struct intel_dp *intel_dp = enc_to_intel_dp(intel_attached_encoder(connector));
        struct intel_panel *panel = &connector->panel;
        u32 max_backlight = 0;
        int freq, fxp, fxp_min, fxp_max, fxp_actual, f = 1;
 static bool
 intel_dp_aux_display_control_capable(struct intel_connector *connector)
 {
-       struct intel_dp *intel_dp = enc_to_intel_dp(connector->encoder);
+       struct intel_dp *intel_dp = enc_to_intel_dp(intel_attached_encoder(connector));
 
        /* Check the eDP Display control capabilities registers to determine if
         * the panel can support backlight control over the aux channel
 
 
 static bool intel_dp_mst_get_hw_state(struct intel_connector *connector)
 {
-       if (connector->encoder && connector->base.state->crtc) {
+       if (intel_attached_encoder(connector) && connector->base.state->crtc) {
                enum pipe pipe;
-               if (!connector->encoder->get_hw_state(connector->encoder, &pipe))
+               if (!intel_attached_encoder(connector)->get_hw_state(intel_attached_encoder(connector), &pipe))
                        return false;
                return true;
        }
 
 
 static u32 dcs_get_backlight(struct intel_connector *connector)
 {
-       struct intel_encoder *encoder = connector->encoder;
+       struct intel_encoder *encoder = intel_attached_encoder(connector);
        struct intel_dsi *intel_dsi = enc_to_intel_dsi(encoder);
        struct mipi_dsi_device *dsi_device;
        u8 data = 0;
 {
        struct drm_device *dev = intel_connector->base.dev;
        struct drm_i915_private *dev_priv = to_i915(dev);
-       struct intel_encoder *encoder = intel_connector->encoder;
+       struct intel_encoder *encoder = intel_attached_encoder(intel_connector);
        struct intel_panel *panel = &intel_connector->panel;
 
        if (dev_priv->vbt.backlight.type != INTEL_BACKLIGHT_DSI_DCS)
 
        struct intel_digital_port *intel_dig_port = conn_to_dig_port(connector);
        struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
        struct intel_hdcp *hdcp = &connector->hdcp;
-       enum port port = connector->encoder->port;
+       enum port port = intel_attached_encoder(connector)->port;
        enum transcoder cpu_transcoder = hdcp->cpu_transcoder;
        int ret;
 
        struct intel_digital_port *intel_dig_port = conn_to_dig_port(connector);
        struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
        struct intel_hdcp *hdcp = &connector->hdcp;
-       enum port port = connector->encoder->port;
+       enum port port = intel_attached_encoder(connector)->port;
        enum transcoder cpu_transcoder = hdcp->cpu_transcoder;
        int ret;
 
        struct intel_digital_port *intel_dig_port = conn_to_dig_port(connector);
        struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
        struct intel_hdcp *hdcp = &connector->hdcp;
-       enum port port = connector->encoder->port;
+       enum port port = intel_attached_encoder(connector)->port;
        enum transcoder cpu_transcoder;
        int ret = 0;
 
 
        if (INTEL_GEN(dev_priv) < 12)
                data->fw_ddi =
-                       intel_get_mei_fw_ddi_index(connector->encoder->port);
+                       intel_get_mei_fw_ddi_index(intel_attached_encoder(connector)->port);
        else
                /*
                 * As per ME FW API expectation, for GEN 12+, fw_ddi is filled
 
                        continue;
 
                intel_connector = to_intel_connector(connector);
-               intel_encoder = intel_connector->encoder;
+               intel_encoder = intel_attached_encoder(intel_connector);
                if (!intel_encoder)
                        continue;
 
 
                        /* Don't check MST ports, they don't have pins */
                        if (!intel_connector->mst_port &&
-                           intel_connector->encoder->hpd_pin == pin) {
+                           intel_attached_encoder(intel_connector)->hpd_pin == pin) {
                                if (connector->polled != intel_connector->polled)
                                        DRM_DEBUG_DRIVER("Reenabling HPD on connector %s\n",
                                                         connector->name);
                u32 hpd_bit;
 
                intel_connector = to_intel_connector(connector);
-               if (!intel_connector->encoder)
+               if (!intel_attached_encoder(intel_connector))
                        continue;
-               intel_encoder = intel_connector->encoder;
+               intel_encoder = intel_attached_encoder(intel_connector);
                hpd_bit = BIT(intel_encoder->hpd_pin);
                if ((hpd_event_bits | hpd_retry_bits) & hpd_bit) {
                        DRM_DEBUG_KMS("Connector %s (pin %i) received hotplug event.\n",
                        continue;
 
                if (!connector->polled && I915_HAS_HOTPLUG(dev_priv) &&
-                   intel_connector->encoder->hpd_pin > HPD_NONE) {
+                   intel_attached_encoder(intel_connector)->hpd_pin > HPD_NONE) {
                        connector->polled = enabled ?
                                DRM_CONNECTOR_POLL_CONNECT |
                                DRM_CONNECTOR_POLL_DISCONNECT :
 
                return;
 
        intel_connector = to_intel_connector(connector);
-       dig_port = enc_to_dig_port(intel_connector->encoder);
+       dig_port = enc_to_dig_port(intel_attached_encoder(intel_connector));
        if (dev_priv->psr.dp != &dig_port->dp)
                return;
 
 
 vlv_dsi_get_hw_panel_orientation(struct intel_connector *connector)
 {
        struct drm_i915_private *dev_priv = to_i915(connector->base.dev);
-       struct intel_encoder *encoder = connector->encoder;
+       struct intel_encoder *encoder = intel_attached_encoder(connector);
        enum intel_display_power_domain power_domain;
        enum drm_panel_orientation orientation;
        struct intel_plane *plane;
 
 static void intel_dp_info(struct seq_file *m,
                          struct intel_connector *intel_connector)
 {
-       struct intel_encoder *intel_encoder = intel_connector->encoder;
+       struct intel_encoder *intel_encoder = intel_attached_encoder(intel_connector);
        struct intel_dp *intel_dp = enc_to_intel_dp(intel_encoder);
 
        seq_printf(m, "\tDPCD rev: %x\n", intel_dp->dpcd[DP_DPCD_REV]);
 static void intel_dp_mst_info(struct seq_file *m,
                          struct intel_connector *intel_connector)
 {
-       struct intel_encoder *intel_encoder = intel_connector->encoder;
+       struct intel_encoder *intel_encoder = intel_attached_encoder(intel_connector);
        struct intel_dp_mst_encoder *intel_mst =
                enc_to_mst(intel_encoder);
        struct intel_digital_port *intel_dig_port = intel_mst->primary;
 static void intel_hdmi_info(struct seq_file *m,
                            struct intel_connector *intel_connector)
 {
-       struct intel_encoder *intel_encoder = intel_connector->encoder;
+       struct intel_encoder *intel_encoder = intel_attached_encoder(intel_connector);
        struct intel_hdmi *intel_hdmi = enc_to_intel_hdmi(intel_encoder);
 
        seq_printf(m, "\taudio support: %s\n", yesno(intel_hdmi->has_audio));