static struct intel_dp *intel_attached_dp(struct drm_connector *connector)
 {
-       return container_of(intel_attached_encoder(connector),
-                           struct intel_dp, base);
+       return enc_to_intel_dp(&intel_attached_encoder(connector)->base);
 }
 
 /**
 intel_edp_link_config(struct intel_encoder *intel_encoder,
                       int *lane_num, int *link_bw)
 {
-       struct intel_dp *intel_dp = container_of(intel_encoder, struct intel_dp, base);
+       struct intel_dp *intel_dp = enc_to_intel_dp(&intel_encoder->base);
 
        *lane_num = intel_dp->lane_count;
        *link_bw = drm_dp_bw_code_to_link_rate(intel_dp->link_bw);
 intel_edp_target_clock(struct intel_encoder *intel_encoder,
                       struct drm_display_mode *mode)
 {
-       struct intel_dp *intel_dp = container_of(intel_encoder, struct intel_dp, base);
+       struct intel_dp *intel_dp = enc_to_intel_dp(&intel_encoder->base);
        struct intel_connector *intel_connector = intel_dp->attached_connector;
 
        if (intel_connector->panel.fixed_mode)
                 struct drm_display_mode *adjusted_mode)
 {
        struct drm_device *dev = crtc->dev;
-       struct intel_encoder *encoder;
+       struct intel_encoder *intel_encoder;
+       struct intel_dp *intel_dp;
        struct drm_i915_private *dev_priv = dev->dev_private;
        struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
        int lane_count = 4;
        /*
         * Find the lane count in the intel_encoder private
         */
-       for_each_encoder_on_crtc(dev, crtc, encoder) {
-               struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
+       for_each_encoder_on_crtc(dev, crtc, intel_encoder) {
+               intel_dp = enc_to_intel_dp(&intel_encoder->base);
 
-               if (intel_dp->base.type == INTEL_OUTPUT_DISPLAYPORT ||
-                   intel_dp->base.type == INTEL_OUTPUT_EDP)
+               if (intel_encoder->type == INTEL_OUTPUT_DISPLAYPORT ||
+                   intel_encoder->type == INTEL_OUTPUT_EDP)
                {
                        lane_count = intel_dp->lane_count;
                        break;
        struct drm_device *dev = encoder->dev;
        struct drm_i915_private *dev_priv = dev->dev_private;
        struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
-       struct drm_crtc *crtc = intel_dp->base.base.crtc;
+       struct drm_crtc *crtc = encoder->crtc;
        struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
 
        /*
 intel_dp_detect(struct drm_connector *connector, bool force)
 {
        struct intel_dp *intel_dp = intel_attached_dp(connector);
-       struct drm_device *dev = intel_dp->base.base.dev;
+       struct drm_device *dev = connector->dev;
        enum drm_connector_status status;
        struct edid *edid = NULL;
        char dpcd_hex_dump[sizeof(intel_dp->dpcd) * 3];
 {
        struct intel_dp *intel_dp = intel_attached_dp(connector);
        struct intel_connector *intel_connector = to_intel_connector(connector);
-       struct drm_device *dev = intel_dp->base.base.dev;
+       struct drm_device *dev = connector->dev;
        int ret;
 
        /* We should parse the EDID data and find out if it has an audio sink
 static void
 intel_dp_hot_plug(struct intel_encoder *intel_encoder)
 {
-       struct intel_dp *intel_dp = container_of(intel_encoder, struct intel_dp, base);
+       struct intel_dp *intel_dp = enc_to_intel_dp(&intel_encoder->base);
 
        intel_dp_check_link_status(intel_dp);
 }
 intel_trans_dp_port_sel(struct drm_crtc *crtc)
 {
        struct drm_device *dev = crtc->dev;
-       struct intel_encoder *encoder;
+       struct intel_encoder *intel_encoder;
+       struct intel_dp *intel_dp;
 
-       for_each_encoder_on_crtc(dev, crtc, encoder) {
-               struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
+       for_each_encoder_on_crtc(dev, crtc, intel_encoder) {
+               intel_dp = enc_to_intel_dp(&intel_encoder->base);
 
-               if (intel_dp->base.type == INTEL_OUTPUT_DISPLAYPORT ||
-                   intel_dp->base.type == INTEL_OUTPUT_EDP)
+               if (intel_encoder->type == INTEL_OUTPUT_DISPLAYPORT ||
+                   intel_encoder->type == INTEL_OUTPUT_EDP)
                        return intel_dp->output_reg;
        }
 
                } else {
                        /* if this fails, presume the device is a ghost */
                        DRM_INFO("failed to retrieve link info, disabling eDP\n");
-                       intel_dp_encoder_destroy(&intel_dp->base.base);
-                       intel_dp_destroy(&intel_connector->base);
+                       intel_dp_encoder_destroy(&intel_encoder->base);
+                       intel_dp_destroy(connector);
                        return;
                }