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

 struct intel_lvds_encoder {
 	struct intel_encoder base;
 	bool is_dual_link;
+	u32 reg;
-	u32 reg;
+	u32 a3_power;
 	struct intel_lvds_connector *attached_connector;
 				    enum pipe *pipe)
+{
 	struct drm_device *dev = encoder->base.dev;
 	struct drm_i915_private *dev_priv = dev->dev_private;
 	struct intel_lvds_encoder *lvds_encoder = to_lvds_encoder(&encoder->base);
+	enum intel_display_power_domain power_domain;
 	u32 tmp;
+	power_domain = intel_display_port_power_domain(encoder);
+	if (!intel_display_power_enabled(dev_priv, power_domain))
+		return false;
 	tmp = I915_READ(lvds_encoder->reg);
 		ironlake_check_encoder_dotclock(pipe_config, dotclock);
 	pipe_config->adjusted_mode.crtc_clock = dotclock;
-}
-/* The LVDS pin pair needs to be on before the DPLLs are enabled.
- * This is an exception to the general rule that mode_set doesn't turn
  * things on.
  */
 static void intel_pre_enable_lvds(struct intel_encoder *encoder)
+{
 	struct intel_lvds_encoder *lvds_encoder = to_lvds_encoder(&encoder->base);
 	else
 		temp &= ~(LVDS_B0B3_POWER_UP | LVDS_CLKB_POWER_UP);
 	/* It would be nice to set 24 vs 18-bit mode (LVDS_A3_POWER_UP)
 	 * appropriately here, but we need to look more thoroughly into how
+	 * panels behave in the two modes. For now, let's just maintain the
-	 * panels behave in the two modes.
+	 * value we got from the BIOS.
+	 */
+	 temp &= ~LVDS_A3_POWER_MASK;
-	 */
+	 temp |= lvds_encoder->a3_power;
 	/* Set the dithering flag on LVDS as needed, note that there is no
 	 * special lvds dither control bit on pch-split platforms, dithering is
 static bool intel_lvds_compute_config(struct intel_encoder *intel_encoder,
 				      struct intel_crtc_config *pipe_config)
+{
-	struct drm_device *dev = intel_encoder->base.dev;
-	struct drm_i915_private *dev_priv = dev->dev_private;
+	struct drm_device *dev = intel_encoder->base.dev;
 	struct intel_lvds_encoder *lvds_encoder =
 		to_lvds_encoder(&intel_encoder->base);
 	struct intel_connector *intel_connector =
 		&lvds_encoder->attached_connector->base;
 	if (INTEL_INFO(dev)->gen < 4 && intel_crtc->pipe == 0) {
 		DRM_ERROR("Can't support LVDS on pipe A\n");
 		return false;
+	}
-	if ((I915_READ(lvds_encoder->reg) & LVDS_A3_POWER_MASK) ==
-	    LVDS_A3_POWER_UP)
+	if (lvds_encoder->a3_power == LVDS_A3_POWER_UP)
 		lvds_bpp = 8*3;
 	else
 		lvds_bpp = 6*3;
 	 */
 	return true;
-}
-static void intel_lvds_mode_set(struct intel_encoder *encoder)
-{
-	/*
-	 * We don't do anything here, the LVDS port is fully set up in the pre
-	 * enable hook - the ordering constraints for enabling the lvds port vs.
-	 * enabling the display pll are too strict.
-	 */
+}
 /**
  * Detect the LVDS connection.
+ *
+{
 	struct drm_device *dev = connector->dev;
 	enum drm_connector_status status;
 	DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n",
-		      connector->base.id, drm_get_connector_name(connector));
+		      connector->base.id, connector->name);
 	status = intel_panel_detect(dev);
 	struct drm_device *dev = lvds_encoder->base.base.dev;
 	unsigned int val;
 	struct drm_i915_private *dev_priv = dev->dev_private;
 	/* use the module option value if specified */
-	if (i915_lvds_channel_mode > 0)
+	if (i915.lvds_channel_mode > 0)
-		return i915_lvds_channel_mode == 2;
+		return i915.lvds_channel_mode == 2;
 //	if (dmi_check_system(intel_dual_link_lvds))
 	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;
 	struct drm_crtc *crtc;
 	u32 lvds;
 	int pipe;
 	u8 pin;
 			 DRM_MODE_ENCODER_LVDS);
 	intel_encoder->enable = intel_enable_lvds;
 	intel_encoder->pre_enable = intel_pre_enable_lvds;
-	intel_encoder->compute_config = intel_lvds_compute_config;
-	intel_encoder->mode_set = intel_lvds_mode_set;
+	intel_encoder->compute_config = intel_lvds_compute_config;
 	intel_encoder->disable = intel_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->get_hw_state = intel_connector_get_hw_state;
+	intel_connector->unregister = intel_connector_unregister;
 	intel_connector_attach_encoder(intel_connector, intel_encoder);
 	intel_encoder->type = INTEL_OUTPUT_LVDS;
-	intel_encoder->cloneable = false;
+	intel_encoder->cloneable = 0;
 	if (HAS_PCH_SPLIT(dev))
 		intel_encoder->crtc_mask = (1 << 0) | (1 << 1) | (1 << 2);
 	/*
 	 * Attempt to get the fixed panel mode from DDC.  Assume that the
 	 * preferred mode is the right one.
+	 */
-	 */
+	mutex_lock(&dev->mode_config.mutex);
 	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,
 			DRM_DEBUG_KMS("using preferred mode from EDID: ");
 			drm_mode_debug_printmodeline(scan);
 			fixed_mode = drm_mode_duplicate(dev, scan);
 			if (fixed_mode) {
-				intel_connector->panel.downclock_mode =
+				downclock_mode =
 					intel_find_panel_downclock(dev,
 					fixed_mode, connector);
-				if (intel_connector->panel.downclock_mode !=
+				if (downclock_mode != NULL &&
-					NULL &&	i915_lvds_downclock) {
+					i915.lvds_downclock) {
 					/* We found the downclock for LVDS. */
 					dev_priv->lvds_downclock_avail = true;
-					dev_priv->lvds_downclock =
-						intel_connector->panel.
+					dev_priv->lvds_downclock =
 						downclock_mode->clock;
 					DRM_DEBUG_KMS("LVDS downclock is found"
 					" in EDID. Normal clock %dKhz, "
 					"downclock %dKhz\n",
 	/* 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);
 out:
 	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 = I915_READ(lvds_encoder->reg) &
-		      lvds_encoder->is_dual_link ? "dual" : "single");
+				 LVDS_A3_POWER_MASK;
 		/*
 		 * Unlock registers and just
 		 * leave them unlocked
 			   I915_READ(PCH_PP_CONTROL) | PANEL_UNLOCK_REGS);
 	} else {
 		I915_WRITE(PP_CONTROL,
 			   I915_READ(PP_CONTROL) | PANEL_UNLOCK_REGS);
+	}
-//   dev_priv->lid_notifier.notifier_call = intel_lid_notify;
-//   if (acpi_lid_notifier_register(&dev_priv->lid_notifier)) {
-//       DRM_DEBUG_KMS("lid notifier registration failed\n");
- //      dev_priv->lid_notifier.notifier_call = NULL;
-//   }
-	drm_sysfs_connector_add(connector);
+	drm_connector_register(connector);
-	intel_panel_init(&intel_connector->panel, fixed_mode);
+	intel_panel_init(&intel_connector->panel, fixed_mode, downclock_mode);
 	intel_panel_setup_backlight(connector);
+	return;
-	return;
+failed:
 	mutex_unlock(&dev->mode_config.mutex);
 failed:
-	DRM_DEBUG_KMS("No LVDS modes found, disabling.\n");
-	drm_connector_cleanup(connector);
-	drm_encoder_cleanup(encoder);
+	DRM_DEBUG_KMS("No LVDS modes found, disabling.\n");
-	if (fixed_mode)
+	drm_connector_cleanup(connector);
-		drm_mode_destroy(dev, fixed_mode);
+	drm_encoder_cleanup(encoder);
 	kfree(lvds_encoder);

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/i915/intel_lvds.c – Rev 4560 → 5060