WebSVN – Kolibri OS – Diff – /drivers/video/drm/i915/intel_dp.c

 static bool
 intel_dp_reset_link_train(struct intel_dp *intel_dp, uint32_t *DP,
 			uint8_t dp_train_pat)
-{
 	if (!intel_dp->train_set_valid)
 		memset(intel_dp->train_set, 0, sizeof(intel_dp->train_set));
 	intel_dp_set_signal_levels(intel_dp, DP);
 	return intel_dp_set_link_train(intel_dp, DP, dp_train_pat);
 		if (drm_dp_clock_recovery_ok(link_status, intel_dp->lane_count)) {
 			DRM_DEBUG_KMS("clock recovery OK\n");
 			break;
+		}
-		/*
-		 * if we used previously trained voltage and pre-emphasis values
-		 * and we don't get clock recovery, reset link training values
-		 */
-		if (intel_dp->train_set_valid) {
-			DRM_DEBUG_KMS("clock recovery not ok, reset");
-			/* clear the flag as we are not reusing train set */
-			intel_dp->train_set_valid = false;
-			if (!intel_dp_reset_link_train(intel_dp, &DP,
-						       DP_TRAINING_PATTERN_1 |
-						       DP_LINK_SCRAMBLING_DISABLE)) {
-				DRM_ERROR("failed to enable link training\n");
-				return;
-			}
-			continue;
 		/* Check to see if we've tried the max voltage */
 		for (i = 0; i < intel_dp->lane_count; i++)
+		}
 		/* Make sure clock is still ok */
 		if (!drm_dp_clock_recovery_ok(link_status,
-					      intel_dp->lane_count)) {
-			intel_dp->train_set_valid = false;
+					      intel_dp->lane_count)) {
 			intel_dp_link_training_clock_recovery(intel_dp);
 			intel_dp_set_link_train(intel_dp, &DP,
 						training_pattern |
 						DP_LINK_SCRAMBLING_DISABLE);
 			break;
+		}
 		/* Try 5 times, then try clock recovery if that fails */
-		if (tries > 5) {
-			intel_dp->train_set_valid = false;
+		if (tries > 5) {
 			intel_dp_link_training_clock_recovery(intel_dp);
 			intel_dp_set_link_train(intel_dp, &DP,
 						training_pattern |
 						DP_LINK_SCRAMBLING_DISABLE);
 	intel_dp_set_idle_link_train(intel_dp);
-	intel_dp->DP = DP;
 	intel_dp->DP = DP;
 	if (channel_eq) {
-		intel_dp->train_set_valid = true;
-		DRM_DEBUG_KMS("Channel EQ done. DP Training successful\n");
+	if (channel_eq)
 		DRM_DEBUG_KMS("Channel EQ done. DP Training successful\n");
+	}
+	}
 	return I915_READ(PORT_HOTPLUG_STAT) & bit;
 }
-static bool vlv_digital_port_connected(struct drm_i915_private *dev_priv,
+static bool gm45_digital_port_connected(struct drm_i915_private *dev_priv,
 				       struct intel_digital_port *port)
+{
 	u32 bit;
 	switch (port->port) {
 	case PORT_B:
-		bit = PORTB_HOTPLUG_LIVE_STATUS_VLV;
+		bit = PORTB_HOTPLUG_LIVE_STATUS_GM45;
 		break;
 	case PORT_C:
-		bit = PORTC_HOTPLUG_LIVE_STATUS_VLV;
+		bit = PORTC_HOTPLUG_LIVE_STATUS_GM45;
 		break;
 	case PORT_D:
-		bit = PORTD_HOTPLUG_LIVE_STATUS_VLV;
+		bit = PORTD_HOTPLUG_LIVE_STATUS_GM45;
 		break;
 	default:
 		return ibx_digital_port_connected(dev_priv, port);
 	if (HAS_PCH_SPLIT(dev_priv))
 		return cpt_digital_port_connected(dev_priv, port);
 	else if (IS_BROXTON(dev_priv))
 		return bxt_digital_port_connected(dev_priv, port);
-	else if (IS_VALLEYVIEW(dev_priv))
+	else if (IS_GM45(dev_priv))
-		return vlv_digital_port_connected(dev_priv, port);
+		return gm45_digital_port_connected(dev_priv, port);
 	else
 		return g4x_digital_port_connected(dev_priv, port);
+}
+	}
 	drm_encoder_cleanup(encoder);
 	kfree(intel_dig_port);
+}
-static void intel_dp_encoder_suspend(struct intel_encoder *intel_encoder)
+void intel_dp_encoder_suspend(struct intel_encoder *intel_encoder)
+{
 	struct intel_dp *intel_dp = enc_to_intel_dp(&intel_encoder->base);
 	intel_display_power_get(dev_priv, power_domain);
 	edp_panel_vdd_schedule_off(intel_dp);
 }
+void intel_dp_encoder_reset(struct drm_encoder *encoder)
-static void intel_dp_encoder_reset(struct drm_encoder *encoder)
+{
+	struct drm_i915_private *dev_priv = to_i915(encoder->dev);
+	struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
 	if (!HAS_DDI(dev_priv))
-	struct intel_dp *intel_dp;
+		intel_dp->DP = I915_READ(intel_dp->output_reg);
-	if (to_intel_encoder(encoder)->type != INTEL_OUTPUT_EDP)
 		return;
 	if (to_intel_encoder(encoder)->type != INTEL_OUTPUT_EDP)
-	intel_dp = enc_to_intel_dp(encoder);
+		return;
 	power_domain = intel_display_port_aux_power_domain(intel_encoder);
 	intel_display_power_get(dev_priv, power_domain);
-	if (long_hpd) {
-		/* indicate that we need to restart link training */
 		intel_dp->train_set_valid = false;
 	if (long_hpd) {
 		if (!intel_digital_port_connected(dev_priv, intel_dig_port))
 			goto mst_fail;
 	i915_debugfs_connector_add(connector);
 	return true;
-}
+}
+bool intel_dp_init(struct drm_device *dev,
-void
+		   int output_reg,
-intel_dp_init(struct drm_device *dev, int output_reg, enum port port)
+		   enum port port)
+{
 	struct drm_i915_private *dev_priv = dev->dev_private;
 	struct intel_digital_port *intel_dig_port;
 	struct intel_encoder *intel_encoder;
 	struct drm_encoder *encoder;
 	struct intel_connector *intel_connector;
 	intel_dig_port = kzalloc(sizeof(*intel_dig_port), GFP_KERNEL);
 	if (!intel_dig_port)
-		return;
+		return false;
 	dev_priv->hotplug.irq_port[port] = intel_dig_port;
 	if (!intel_dp_init_connector(intel_dig_port, intel_connector))
 		goto err_init_connector;
-	return;
+	return true;
 err_init_connector:
 	drm_encoder_cleanup(encoder);
-	kfree(intel_connector);
-err_connector_alloc:
+	kfree(intel_connector);
-	kfree(intel_dig_port);
+err_connector_alloc:
 	kfree(intel_dig_port);
-	return;
+	return false;
+}

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/i915/intel_dp.c – Rev 6320 → 6660