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

  *	Eric Anholt
  */
 #include
 #include
 #include
+#include
 #include
 #include "intel_drv.h"
 #include
 #include "i915_drv.h"
 #include "dvo.h"
+	{
 		.type = INTEL_DVO_CHIP_LVDS,
 		.name = "ch7017",
 		.dvo_reg = DVOC,
 		.slave_addr = 0x75,
-		.gpio = GMBUS_PORT_DPB,
+		.gpio = GMBUS_PIN_DPB,
 		.dev_ops = &ch7017_ops,
 	},
+	{
 	        .type = INTEL_DVO_CHIP_TMDS,
 		.name = "ns2501",
 struct intel_dvo {
 	struct intel_encoder base;
 	struct intel_dvo_device dev;
 	struct intel_connector *attached_connector;
 	struct drm_display_mode *panel_fixed_mode;
 	bool panel_wants_dither;
 };
 	return true;
+}
 static void intel_dvo_get_config(struct intel_encoder *encoder,
-				 struct intel_crtc_config *pipe_config)
+				 struct intel_crtc_state *pipe_config)
+{
 	struct drm_i915_private *dev_priv = encoder->base.dev->dev_private;
 	if (tmp & DVO_VSYNC_ACTIVE_HIGH)
 		flags |= DRM_MODE_FLAG_PVSYNC;
 	else
 		flags |= DRM_MODE_FLAG_NVSYNC;
-	pipe_config->adjusted_mode.flags |= flags;
+	pipe_config->base.adjusted_mode.flags |= flags;
-	pipe_config->adjusted_mode.crtc_clock = pipe_config->port_clock;
+	pipe_config->base.adjusted_mode.crtc_clock = pipe_config->port_clock;
+}
 	struct intel_crtc *crtc = to_intel_crtc(encoder->base.crtc);
 	u32 dvo_reg = intel_dvo->dev.dvo_reg;
 	u32 temp = I915_READ(dvo_reg);
 	intel_dvo->dev.dev_ops->mode_set(&intel_dvo->dev,
-					 &crtc->config.requested_mode,
+					 &crtc->config->base.mode,
-					 &crtc->config.adjusted_mode);
+					 &crtc->config->base.adjusted_mode);
 	I915_WRITE(dvo_reg, temp | DVO_ENABLE);
 	I915_READ(dvo_reg);
-	intel_dvo->dev.dev_ops->dpms(&intel_dvo->dev, true);
-}
-/* Special dpms function to support cloning between dvo/sdvo/crt. */
-static void intel_dvo_dpms(struct drm_connector *connector, int mode)
-{
-	struct intel_dvo *intel_dvo = intel_attached_dvo(connector);
-	struct drm_crtc *crtc;
-	struct intel_crtc_config *config;
-	/* dvo supports only 2 dpms states. */
-	if (mode != DRM_MODE_DPMS_ON)
-		mode = DRM_MODE_DPMS_OFF;
-	if (mode == connector->dpms)
-		return;
-	connector->dpms = mode;
-	/* Only need to change hw state when actually enabled */
-	crtc = intel_dvo->base.base.crtc;
-	if (!crtc) {
-		intel_dvo->base.connectors_active = false;
-		return;
-	}
-	/* We call connector dpms manually below in case pipe dpms doesn't
-	 * change due to cloning. */
-	if (mode == DRM_MODE_DPMS_ON) {
-		config = &to_intel_crtc(crtc)->config;
-		intel_dvo->base.connectors_active = true;
-		intel_crtc_update_dpms(crtc);
-		intel_dvo->dev.dev_ops->dpms(&intel_dvo->dev, true);
-	} else {
-		intel_dvo->dev.dev_ops->dpms(&intel_dvo->dev, false);
-		intel_dvo->base.connectors_active = false;
-		intel_crtc_update_dpms(crtc);
-	}
-	intel_modeset_check_state(connector->dev);
+	intel_dvo->dev.dev_ops->dpms(&intel_dvo->dev, true);
+}
 static enum drm_mode_status
+intel_dvo_mode_valid(struct drm_connector *connector,
+		     struct drm_display_mode *mode)
+{
+	struct intel_dvo *intel_dvo = intel_attached_dvo(connector);
-intel_dvo_mode_valid(struct drm_connector *connector,
+	const struct drm_display_mode *fixed_mode =
-				struct drm_display_mode *mode)
+		to_intel_connector(connector)->panel.fixed_mode;
 	int max_dotclk = to_i915(connector->dev)->max_dotclk_freq;
-	struct intel_dvo *intel_dvo = intel_attached_dvo(connector);
+	int target_clock = mode->clock;
 	if (mode->flags & DRM_MODE_FLAG_DBLSCAN)
 		return MODE_NO_DBLESCAN;
+	/* XXX: Validate clock range */
-	/* XXX: Validate clock range */
+	if (fixed_mode) {
+		if (mode->hdisplay > fixed_mode->hdisplay)
+			return MODE_PANEL;
+		if (mode->vdisplay > fixed_mode->vdisplay)
 			return MODE_PANEL;
 	if (intel_dvo->panel_fixed_mode) {
-		if (mode->hdisplay > intel_dvo->panel_fixed_mode->hdisplay)
+		target_clock = fixed_mode->clock;
-			return MODE_PANEL;
+	}
 		if (mode->vdisplay > intel_dvo->panel_fixed_mode->vdisplay)
-			return MODE_PANEL;
+	if (target_clock > max_dotclk)
+		return MODE_CLOCK_HIGH;
-	}
+	return intel_dvo->dev.dev_ops->mode_valid(&intel_dvo->dev, mode);
+}
 	return intel_dvo->dev.dev_ops->mode_valid(&intel_dvo->dev, mode);
 static bool intel_dvo_compute_config(struct intel_encoder *encoder,
 				     struct intel_crtc_state *pipe_config)
 static bool intel_dvo_compute_config(struct intel_encoder *encoder,
-				     struct intel_crtc_config *pipe_config)
-{
-	struct intel_dvo *intel_dvo = enc_to_dvo(encoder);
-	struct drm_display_mode *adjusted_mode = &pipe_config->adjusted_mode;
+	struct intel_dvo *intel_dvo = enc_to_dvo(encoder);
-	/* If we have timings from the BIOS for the panel, put them in
-	 * to the adjusted mode.  The CRTC will be set up for this mode,
-	 * with the panel scaling set up to source from the H/VDisplay
-	 * of the original mode.
-	 */
-	if (intel_dvo->panel_fixed_mode != NULL) {
-#define C(x) adjusted_mode->x = intel_dvo->panel_fixed_mode->x
-		C(hdisplay);
-		C(hsync_start);
+	const struct drm_display_mode *fixed_mode =
-		C(hsync_end);
-		C(htotal);
+		intel_dvo->attached_connector->panel.fixed_mode;
-		C(vdisplay);
+	struct drm_display_mode *adjusted_mode = &pipe_config->base.adjusted_mode;
 		C(vsync_start);
-		C(vsync_end);
+	/* If we have timings from the BIOS for the panel, put them in
-		C(vtotal);
+	 * to the adjusted mode.  The CRTC will be set up for this mode,
-		C(clock);
+	 * with the panel scaling set up to source from the H/VDisplay
-#undef C
+	 * of the original mode.
+	 */
-		drm_mode_set_crtcinfo(adjusted_mode, 0);
+	if (fixed_mode)
 		intel_fixed_panel_mode(fixed_mode, adjusted_mode);
 	return true;
 		dvo_val |= DVO_HSYNC_ACTIVE_HIGH;
 	if (adjusted_mode->flags & DRM_MODE_FLAG_PVSYNC)
 		dvo_val |= DVO_VSYNC_ACTIVE_HIGH;
 	/*I915_WRITE(DVOB_SRCDIM,
-	  (adjusted_mode->hdisplay << DVO_SRCDIM_HORIZONTAL_SHIFT) |
+	  (adjusted_mode->crtc_hdisplay << DVO_SRCDIM_HORIZONTAL_SHIFT) |
-	  (adjusted_mode->VDisplay << DVO_SRCDIM_VERTICAL_SHIFT));*/
+	  (adjusted_mode->crtc_vdisplay << DVO_SRCDIM_VERTICAL_SHIFT));*/
 	I915_WRITE(dvo_srcdim_reg,
-		   (adjusted_mode->hdisplay << DVO_SRCDIM_HORIZONTAL_SHIFT) |
+		   (adjusted_mode->crtc_hdisplay << DVO_SRCDIM_HORIZONTAL_SHIFT) |
-		   (adjusted_mode->vdisplay << DVO_SRCDIM_VERTICAL_SHIFT));
+		   (adjusted_mode->crtc_vdisplay << DVO_SRCDIM_VERTICAL_SHIFT));
 	/*I915_WRITE(DVOB, dvo_val);*/
 	I915_WRITE(dvo_reg, dvo_val);
+}
 	return intel_dvo->dev.dev_ops->detect(&intel_dvo->dev);
+}
 static int intel_dvo_get_modes(struct drm_connector *connector)
-{
 	struct intel_dvo *intel_dvo = intel_attached_dvo(connector);
+	struct drm_i915_private *dev_priv = connector->dev->dev_private;
+	const struct drm_display_mode *fixed_mode =
-	struct drm_i915_private *dev_priv = connector->dev->dev_private;
+		to_intel_connector(connector)->panel.fixed_mode;
 	/* We should probably have an i2c driver get_modes function for those
 	 * devices which will have a fixed set of modes determined by the chip
 	 * (TV-out, for example), but for now with just TMDS and LVDS,
 	 * that's not the case.
 	 */
 	intel_ddc_get_modes(connector,
-			    intel_gmbus_get_adapter(dev_priv, GMBUS_PORT_DPC));
+			    intel_gmbus_get_adapter(dev_priv, GMBUS_PIN_DPC));
 	if (!list_empty(&connector->probed_modes))
 		return 1;
-	if (intel_dvo->panel_fixed_mode != NULL) {
+	if (fixed_mode) {
 		struct drm_display_mode *mode;
-		mode = drm_mode_duplicate(connector->dev, intel_dvo->panel_fixed_mode);
+		mode = drm_mode_duplicate(connector->dev, fixed_mode);
 		if (mode) {
 			drm_mode_probed_add(connector, mode);
+}
 static void intel_dvo_destroy(struct drm_connector *connector)
+{
+	drm_connector_cleanup(connector);
-	drm_connector_cleanup(connector);
+	intel_panel_fini(&to_intel_connector(connector)->panel);
 	kfree(connector);
+}
 static const struct drm_connector_funcs intel_dvo_connector_funcs = {
-	.dpms = intel_dvo_dpms,
+	.dpms = drm_atomic_helper_connector_dpms,
 	.detect = intel_dvo_detect,
+	.destroy = intel_dvo_destroy,
+	.fill_modes = drm_helper_probe_single_connector_modes,
+	.atomic_get_property = intel_connector_atomic_get_property,
-	.destroy = intel_dvo_destroy,
+	.atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
-	.fill_modes = drm_helper_probe_single_connector_modes,
+	.atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
 };
 	struct intel_dvo *intel_dvo = enc_to_dvo(to_intel_encoder(encoder));
 	if (intel_dvo->dev.dev_ops->destroy)
-		intel_dvo->dev.dev_ops->destroy(&intel_dvo->dev);
-	kfree(intel_dvo->panel_fixed_mode);
+		intel_dvo->dev.dev_ops->destroy(&intel_dvo->dev);
 	intel_encoder_destroy(encoder);
+}
 	intel_dvo = kzalloc(sizeof(*intel_dvo), GFP_KERNEL);
 	if (!intel_dvo)
 		return;
-	intel_connector = kzalloc(sizeof(*intel_connector), GFP_KERNEL);
+	intel_connector = intel_connector_alloc();
 	if (!intel_connector) {
 		kfree(intel_dvo);
+		return;
+	}
 		return;
 	intel_dvo->attached_connector = intel_connector;
 	intel_encoder = &intel_dvo->base;
 		struct drm_connector *connector = &intel_connector->base;
 		const struct intel_dvo_device *dvo = &intel_dvo_devices[i];
 		struct i2c_adapter *i2c;
 		int gpio;
 		bool dvoinit;
+		enum pipe pipe;
+		uint32_t dpll[I915_MAX_PIPES];
 		/* Allow the I2C driver info to specify the GPIO to be used in
 		 * special cases, but otherwise default to what's defined
 		 * in the spec.
 		 */
-		if (intel_gmbus_is_port_valid(dvo->gpio))
+		if (intel_gmbus_is_valid_pin(dev_priv, dvo->gpio))
 			gpio = dvo->gpio;
 		else if (dvo->type == INTEL_DVO_CHIP_LVDS)
-			gpio = GMBUS_PORT_SSC;
+			gpio = GMBUS_PIN_SSC;
 		else
-			gpio = GMBUS_PORT_DPB;
+			gpio = GMBUS_PIN_DPB;
 		/* Set up the I2C bus necessary for the chip we're probing.
 		 * It appears that everything is on GPIOE except for panels
 		/* GMBUS NAK handling seems to be unstable, hence let the
 		 * transmitter detection run in bit banging mode for now.
 		 */
 		intel_gmbus_force_bit(i2c, true);
+		/* ns2501 requires the DVO 2x clock before it will
+		 * respond to i2c accesses, so make sure we have
+		 * have the clock enabled before we attempt to
+		 * initialize the device.
+		 */
+		for_each_pipe(dev_priv, pipe) {
+			dpll[pipe] = I915_READ(DPLL(pipe));
+			I915_WRITE(DPLL(pipe), dpll[pipe] | DPLL_DVO_2X_MODE);
+		}
+		dvoinit = dvo->dev_ops->init(&intel_dvo->dev, i2c);
+		/* restore the DVO 2x clock state to original */
+		for_each_pipe(dev_priv, pipe) {
+			I915_WRITE(DPLL(pipe), dpll[pipe]);
 		dvoinit = dvo->dev_ops->init(&intel_dvo->dev, i2c);
 		intel_gmbus_force_bit(i2c, false);
 			 * However, it's in a different format from the BIOS
 			 * data on chipsets with integrated LVDS (stored in AIM
 			 * headers, likely), so for now, just get the current
 			 * mode being output through DVO.
 			 */
-			intel_dvo->panel_fixed_mode =
+			intel_panel_init(&intel_connector->panel,
-				intel_dvo_get_current_mode(connector);
+					 intel_dvo_get_current_mode(connector),
+					 NULL);
 			intel_dvo->panel_wants_dither = true;
+		}
 		drm_connector_register(connector);

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/i915/intel_dvo.c – Rev 5354 → 6084