--- initial
+++ final
@@ -1,176 +1,176 @@
 void intel_lvds_init(struct drm_i915_private *dev_priv) {
   struct drm_device *dev = &dev_priv->drm;
   struct intel_lvds_encoder *lvds_encoder;
   struct intel_encoder *intel_encoder;
   struct intel_lvds_connector *lvds_connector;
   struct intel_connector *intel_connector;
   struct drm_connector *connector;
   struct drm_encoder *encoder;
   struct drm_display_mode *scan; /* *modes, *bios_mode; */
   struct drm_display_mode *fixed_mode = NULL;
   struct drm_display_mode *downclock_mode = NULL;
   struct edid *edid;
   i915_reg_t lvds_reg;
   u32 lvds;
   u8 pin;
   u32 allowed_scalers;
   if (!intel_lvds_supported(dev_priv)) return;
   /* Skip init on machines we know falsely report LVDS */
   if (dmi_check_system(intel_no_lvds)) {
     WARN(!dev_priv->vbt.int_lvds_support, "Useless DMI match. Internal LVDS support disabled by VBT\n");
     return;
   }
   if (!dev_priv->vbt.int_lvds_support) {
     DRM_DEBUG_KMS("Internal LVDS support disabled by VBT\n");
     return;
   }
   if (HAS_PCH_SPLIT(dev_priv))
     lvds_reg = PCH_LVDS;
   else
     lvds_reg = LVDS;
   lvds = I915_READ(lvds_reg);
   if (HAS_PCH_SPLIT(dev_priv)) {
     if ((lvds & LVDS_DETECTED) == 0) return;
   }
   pin = GMBUS_PIN_PANEL;
   if (!intel_bios_is_lvds_present(dev_priv, &pin)) {
     if ((lvds & LVDS_PORT_EN) == 0) {
       DRM_DEBUG_KMS("LVDS is not present in VBT\n");
       return;
     }
     DRM_DEBUG_KMS("LVDS is not present in VBT, but enabled anyway\n");
   }
   lvds_encoder = kzalloc(sizeof(*lvds_encoder), GFP_KERNEL);
   if (!lvds_encoder) return;
   lvds_connector = kzalloc(sizeof(*lvds_connector), GFP_KERNEL);
   if (!lvds_connector) {
     kfree(lvds_encoder);
     return;
   }
   if (intel_connector_init(&lvds_connector->base) < 0) {
     kfree(lvds_connector);
     kfree(lvds_encoder);
     return;
   }
   lvds_encoder->attached_connector = lvds_connector;
   intel_encoder = &lvds_encoder->base;
   encoder = &intel_encoder->base;
   intel_connector = &lvds_connector->base;
   connector = &intel_connector->base;
   drm_connector_init(dev, &intel_connector->base, &intel_lvds_connector_funcs, DRM_MODE_CONNECTOR_LVDS);
   drm_encoder_init(dev, &intel_encoder->base, &intel_lvds_enc_funcs, DRM_MODE_ENCODER_LVDS, "LVDS");
   intel_encoder->enable = intel_enable_lvds;
   intel_encoder->pre_enable = intel_pre_enable_lvds;
   intel_encoder->compute_config = intel_lvds_compute_config;
   if (HAS_PCH_SPLIT(dev_priv)) {
     intel_encoder->disable = pch_disable_lvds;
     intel_encoder->post_disable = pch_post_disable_lvds;
   } else {
     intel_encoder->disable = gmch_disable_lvds;
   }
   intel_encoder->get_hw_state = intel_lvds_get_hw_state;
   intel_encoder->get_config = intel_lvds_get_config;
   intel_connector->get_hw_state = intel_connector_get_hw_state;
   intel_connector_attach_encoder(intel_connector, intel_encoder);
   intel_encoder->type = INTEL_OUTPUT_LVDS;
   intel_encoder->power_domain = POWER_DOMAIN_PORT_OTHER;
   intel_encoder->port = PORT_NONE;
   intel_encoder->cloneable = 0;
   if (HAS_PCH_SPLIT(dev_priv))
     intel_encoder->crtc_mask = (1 << 0) | (1 << 1) | (1 << 2);
   else if (IS_GEN4(dev_priv))
     intel_encoder->crtc_mask = (1 << 0) | (1 << 1);
   else
     intel_encoder->crtc_mask = (1 << 1);
   drm_connector_helper_add(connector, &intel_lvds_connector_helper_funcs);
   connector->display_info.subpixel_order = SubPixelHorizontalRGB;
   connector->interlace_allowed = false;
   connector->doublescan_allowed = false;
   lvds_encoder->reg = lvds_reg;
   /* create the scaling mode property */
   allowed_scalers = BIT(DRM_MODE_SCALE_ASPECT);
   allowed_scalers |= BIT(DRM_MODE_SCALE_FULLSCREEN);
   allowed_scalers |= BIT(DRM_MODE_SCALE_CENTER);
   drm_connector_attach_scaling_mode_property(connector, allowed_scalers);
   connector->state->scaling_mode = DRM_MODE_SCALE_ASPECT;
   intel_lvds_pps_get_hw_state(dev_priv, &lvds_encoder->init_pps);
   lvds_encoder->init_lvds_val = lvds;
   /*
    * LVDS discovery:
    * 1) check for EDID on DDC
    * 2) check for VBT data
    * 3) check to see if LVDS is already on
    *    if none of the above, no panel
    * 4) make sure lid is open
    *    if closed, act like it's not there for now
    */
   /*
    * Attempt to get the fixed panel mode from DDC.  Assume that the
    * preferred mode is the right one.
    */
   mutex_lock(&dev->mode_config.mutex);
   if (vga_switcheroo_handler_flags() & VGA_SWITCHEROO_CAN_SWITCH_DDC)
     edid = drm_get_edid_switcheroo(connector, intel_gmbus_get_adapter(dev_priv, pin));
   else
     edid = drm_get_edid(connector, intel_gmbus_get_adapter(dev_priv, pin));
   if (edid) {
     if (drm_add_edid_modes(connector, edid)) {
-      drm_mode_connector_update_edid_property(connector, edid);
+      drm_connector_update_edid_property(connector, edid);
     } else {
       kfree(edid);
       edid = ERR_PTR(-EINVAL);
     }
   } else {
     edid = ERR_PTR(-ENOENT);
   }
   lvds_connector->base.edid = edid;
   list_for_each_entry(scan, &connector->probed_modes, head) {
     if (scan->type & DRM_MODE_TYPE_PREFERRED) {
       DRM_DEBUG_KMS("using preferred mode from EDID: ");
       drm_mode_debug_printmodeline(scan);
       fixed_mode = drm_mode_duplicate(dev, scan);
       if (fixed_mode) goto out;
     }
   }
   /* Failed to get EDID, what about VBT? */
   if (dev_priv->vbt.lfp_lvds_vbt_mode) {
     DRM_DEBUG_KMS("using mode from VBT: ");
     drm_mode_debug_printmodeline(dev_priv->vbt.lfp_lvds_vbt_mode);
     fixed_mode = drm_mode_duplicate(dev, dev_priv->vbt.lfp_lvds_vbt_mode);
     if (fixed_mode) {
       fixed_mode->type |= DRM_MODE_TYPE_PREFERRED;
       connector->display_info.width_mm = fixed_mode->width_mm;
       connector->display_info.height_mm = fixed_mode->height_mm;
       goto out;
     }
   }
   /*
    * If we didn't get EDID, try checking if the panel is already turned
    * on.  If so, assume that whatever is currently programmed is the
    * correct mode.
    */
   fixed_mode = intel_encoder_current_mode(intel_encoder);
   if (fixed_mode) {
     DRM_DEBUG_KMS("using current (BIOS) mode: ");
     drm_mode_debug_printmodeline(fixed_mode);
     fixed_mode->type |= DRM_MODE_TYPE_PREFERRED;
   }
   /* If we still don't have a mode after all that, give up. */
   if (!fixed_mode) goto failed;
 out:
   mutex_unlock(&dev->mode_config.mutex);
   intel_panel_init(&intel_connector->panel, fixed_mode, downclock_mode);
   intel_panel_setup_backlight(connector, INVALID_PIPE);
   lvds_encoder->is_dual_link = compute_is_dual_link_lvds(lvds_encoder);
   DRM_DEBUG_KMS("detected %s-link lvds configuration\n", lvds_encoder->is_dual_link ? "dual" : "single");
   lvds_encoder->a3_power = lvds & LVDS_A3_POWER_MASK;
   return;
 failed:
   mutex_unlock(&dev->mode_config.mutex);
   DRM_DEBUG_KMS("No LVDS modes found, disabling.\n");
   drm_connector_cleanup(connector);
   drm_encoder_cleanup(encoder);
   kfree(lvds_encoder);
   kfree(lvds_connector);
   return;
 }<sep>@@
expression e1,e2;
@@
-       drm_mode_connector_update_edid_property
+       drm_connector_update_edid_property
		(e1,e2)