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

 #include
 #include
 #include
 #include
 #include
+#include
 #include
 #include
 #include "intel_drv.h"
 #include
 #include "i915_drv.h"
-#define IS_LVDS(c)  (c->output_flag & SDVO_LVDS_MASK)
+#define IS_LVDS(c)	(c->output_flag & SDVO_LVDS_MASK)
 #define IS_TV_OR_LVDS(c) (c->output_flag & (SDVO_TV_MASK | SDVO_LVDS_MASK))
 #define IS_DIGITAL(c) (c->output_flag & (SDVO_TMDS_MASK | SDVO_LVDS_MASK))
-static const char *tv_format_names[] = {
+static const char * const tv_format_names[] = {
-    "NTSC_M"   , "NTSC_J"  , "NTSC_443",
+	"NTSC_M"   , "NTSC_J"  , "NTSC_443",
-    "PAL_B"    , "PAL_D"   , "PAL_G"   ,
+	"PAL_B"    , "PAL_D"   , "PAL_G"   ,
-    "PAL_H"    , "PAL_I"   , "PAL_M"   ,
+	"PAL_H"    , "PAL_I"   , "PAL_M"   ,
-    "PAL_N"    , "PAL_NC"  , "PAL_60"  ,
+	"PAL_N"    , "PAL_NC"  , "PAL_60"  ,
-    "SECAM_B"  , "SECAM_D" , "SECAM_G" ,
+	"SECAM_B"  , "SECAM_D" , "SECAM_G" ,
-    "SECAM_K"  , "SECAM_K1", "SECAM_L" ,
+	"SECAM_K"  , "SECAM_K1", "SECAM_L" ,
-    "SECAM_60"
+	"SECAM_60"
 };
-#define TV_FORMAT_NUM  (sizeof(tv_format_names) / sizeof(*tv_format_names))
+#define TV_FORMAT_NUM  ARRAY_SIZE(tv_format_names)
-     */
+	 */
-    uint32_t color_range;
+	uint32_t color_range;
 	bool color_range_auto;
+	/**
+	 * HDMI user specified aspect ratio
+	 */
+	enum hdmi_picture_aspect aspect_ratio;
-    /**
+	/**
-     * This is set if we're going to treat the device as TV-out.
+	 * This is set if we're going to treat the device as TV-out.
+	 *
-     * While we have these nice friendly flags for output types that ought
+	 * While we have these nice friendly flags for output types that ought
-     * to decide this for us, the S-Video output on our HDMI+S-Video card
+	 * to decide this for us, the S-Video output on our HDMI+S-Video card
 	u32 bval = val, cval = val;
 	int i;
 	if (intel_sdvo->sdvo_reg == PCH_SDVOB) {
 		I915_WRITE(intel_sdvo->sdvo_reg, val);
+		POSTING_READ(intel_sdvo->sdvo_reg);
+		/*
+		 * HW workaround, need to write this twice for issue
+		 * that may result in first write getting masked.
+		 */
+		if (HAS_PCH_IBX(dev)) {
+			I915_WRITE(intel_sdvo->sdvo_reg, val);
+			POSTING_READ(intel_sdvo->sdvo_reg);
 		I915_READ(intel_sdvo->sdvo_reg);
 		return;
+	}
 	 * The BIOS does this too. Yay, magic
 	 */
 	for (i = 0; i < 2; i++)
+	{
 		I915_WRITE(GEN3_SDVOB, bval);
-		I915_READ(GEN3_SDVOB);
+		POSTING_READ(GEN3_SDVOB);
 		I915_WRITE(GEN3_SDVOC, cval);
-		I915_READ(GEN3_SDVOC);
+		POSTING_READ(GEN3_SDVOC);
+	}
+}
 static bool intel_sdvo_read_byte(struct intel_sdvo *intel_sdvo, u8 addr, u8 *ch)
 #undef BUF_LEN
 	DRM_DEBUG_KMS("%s: W: %02X %s\n", SDVO_NAME(intel_sdvo), cmd, buffer);
 }
-static const char *cmd_status_names[] = {
+static const char * const cmd_status_names[] = {
 	"Power on",
 	"Success",
 	"Not supported",
 log_fail:
 	DRM_DEBUG_KMS("%s: R: ... failed\n", SDVO_NAME(intel_sdvo));
 	return false;
+}
-static int intel_sdvo_get_pixel_multiplier(struct drm_display_mode *mode)
+static int intel_sdvo_get_pixel_multiplier(const struct drm_display_mode *adjusted_mode)
 {
-	if (mode->clock >= 100000)
+	if (adjusted_mode->crtc_clock >= 100000)
 		return 1;
-	else if (mode->clock >= 50000)
+	else if (adjusted_mode->crtc_clock >= 50000)
 		return 2;
 	else
 		return 4;
 		DRM_ERROR("couldn't fill AVI infoframe\n");
 		return false;
+	}
 	if (intel_sdvo->rgb_quant_range_selectable) {
-		if (intel_crtc->config.limited_color_range)
+		if (intel_crtc->config->limited_color_range)
 			frame.avi.quantization_range =
 				HDMI_QUANTIZATION_RANGE_LIMITED;
 		else
 			frame.avi.quantization_range =
 	intel_sdvo->dtd_sdvo_flags = input_dtd.part2.sdvo_flags;
 	return true;
 }
-static void i9xx_adjust_sdvo_tv_clock(struct intel_crtc_config *pipe_config)
+static void i9xx_adjust_sdvo_tv_clock(struct intel_crtc_state *pipe_config)
+{
 	unsigned dotclock = pipe_config->port_clock;
 	pipe_config->clock_set = true;
+}
 static bool intel_sdvo_compute_config(struct intel_encoder *encoder,
-				      struct intel_crtc_config *pipe_config)
+				      struct intel_crtc_state *pipe_config)
 {
 	struct intel_sdvo *intel_sdvo = to_sdvo(encoder);
-	struct drm_display_mode *adjusted_mode = &pipe_config->adjusted_mode;
+	struct drm_display_mode *adjusted_mode = &pipe_config->base.adjusted_mode;
-	struct drm_display_mode *mode = &pipe_config->requested_mode;
+	struct drm_display_mode *mode = &pipe_config->base.mode;
 	/* Clock computation needs to happen after pixel multiplier. */
 	if (intel_sdvo->is_tv)
+		i9xx_adjust_sdvo_tv_clock(pipe_config);
+	/* Set user selected PAR to incoming mode's member */
+	if (intel_sdvo->is_hdmi)
-		i9xx_adjust_sdvo_tv_clock(pipe_config);
+		adjusted_mode->picture_aspect_ratio = intel_sdvo->aspect_ratio;
 	return true;
+}
 static void intel_sdvo_pre_enable(struct intel_encoder *intel_encoder)
+{
 	struct drm_device *dev = intel_encoder->base.dev;
-	struct drm_i915_private *dev_priv = dev->dev_private;
-	struct intel_crtc *crtc = to_intel_crtc(intel_encoder->base.crtc);
+	struct drm_i915_private *dev_priv = dev->dev_private;
-	struct drm_display_mode *adjusted_mode =
+	struct intel_crtc *crtc = to_intel_crtc(intel_encoder->base.crtc);
-		&crtc->config.adjusted_mode;
+	const struct drm_display_mode *adjusted_mode = &crtc->config->base.adjusted_mode;
-	struct drm_display_mode *mode = &crtc->config.requested_mode;
+	struct drm_display_mode *mode = &crtc->config->base.mode;
 	struct intel_sdvo *intel_sdvo = to_sdvo(intel_encoder);
 	u32 sdvox;
 	/* Set the input timing to the screen. Assume always input 0. */
 	if (!intel_sdvo_set_target_input(intel_sdvo))
 		return;
-	if (crtc->config.has_hdmi_sink) {
+	if (crtc->config->has_hdmi_sink) {
 		intel_sdvo_set_encode(intel_sdvo, SDVO_ENCODE_HDMI);
 		intel_sdvo_set_colorimetry(intel_sdvo,
 					   SDVO_COLORIMETRY_RGB256);
 		input_dtd.part2.sdvo_flags = intel_sdvo->dtd_sdvo_flags;
 	if (!intel_sdvo_set_input_timing(intel_sdvo, &input_dtd))
 		DRM_INFO("Setting input timings on %s failed\n",
 			 SDVO_NAME(intel_sdvo));
-	switch (crtc->config.pixel_multiplier) {
+	switch (crtc->config->pixel_multiplier) {
 	default:
-		WARN(1, "unknown pixel mutlipler specified\n");
+		WARN(1, "unknown pixel multiplier specified\n");
 	case 1: rate = SDVO_CLOCK_RATE_MULT_1X; break;
 	case 2: rate = SDVO_CLOCK_RATE_MULT_2X; break;
 	case 4: rate = SDVO_CLOCK_RATE_MULT_4X; break;
+	}
 	/* Set the SDVO control regs. */
 	if (INTEL_INFO(dev)->gen >= 4) {
 		/* The real mode polarity is set by the SDVO commands, using
 		 * struct intel_sdvo_dtd. */
 		sdvox = SDVO_VSYNC_ACTIVE_HIGH | SDVO_HSYNC_ACTIVE_HIGH;
-		if (!HAS_PCH_SPLIT(dev) && crtc->config.limited_color_range)
+		if (!HAS_PCH_SPLIT(dev) && crtc->config->limited_color_range)
 			sdvox |= HDMI_COLOR_RANGE_16_235;
 		if (INTEL_INFO(dev)->gen < 5)
 			sdvox |= SDVO_BORDER_ENABLE;
 	} else {
 		sdvox = I915_READ(intel_sdvo->sdvo_reg);
 	if (INTEL_INFO(dev)->gen >= 4) {
 		/* done in crtc_mode_set as the dpll_md reg must be written early */
 	} else if (IS_I945G(dev) || IS_I945GM(dev) || IS_G33(dev)) {
 		/* done in crtc_mode_set as it lives inside the dpll register */
 	} else {
-		sdvox |= (crtc->config.pixel_multiplier - 1)
+		sdvox |= (crtc->config->pixel_multiplier - 1)
 			<< SDVO_PORT_MULTIPLY_SHIFT;
+	}
 	if (input_dtd.part2.sdvo_flags & SDVO_NEED_TO_STALL &&
 	return true;
+}
 static void intel_sdvo_get_config(struct intel_encoder *encoder,
-				  struct intel_crtc_config *pipe_config)
+				  struct intel_crtc_state *pipe_config)
+{
 	struct drm_device *dev = encoder->base.dev;
 	struct drm_i915_private *dev_priv = dev->dev_private;
 			flags |= DRM_MODE_FLAG_PVSYNC;
 		else
 			flags |= DRM_MODE_FLAG_NVSYNC;
+	}
-	pipe_config->adjusted_mode.flags |= flags;
+	pipe_config->base.adjusted_mode.flags |= flags;
 	/*
 	 * pixel multiplier readout is tricky: Only on i915g/gm it is stored in
 		dotclock /= pipe_config->pixel_multiplier;
 	if (HAS_PCH_SPLIT(dev))
 		ironlake_check_encoder_dotclock(pipe_config, dotclock);
-	pipe_config->adjusted_mode.crtc_clock = dotclock;
+	pipe_config->base.adjusted_mode.crtc_clock = dotclock;
 	/* Cross check the port pixel multiplier with the sdvo encoder state. */
 static void intel_disable_sdvo(struct intel_encoder *encoder)
+{
 	struct drm_i915_private *dev_priv = encoder->base.dev->dev_private;
+	struct intel_sdvo *intel_sdvo = to_sdvo(encoder);
-	struct intel_sdvo *intel_sdvo = to_sdvo(encoder);
+	struct intel_crtc *crtc = to_intel_crtc(encoder->base.crtc);
 	u32 temp;
-		intel_sdvo_set_active_outputs(intel_sdvo, 0);
+	intel_sdvo_set_active_outputs(intel_sdvo, 0);
-		if (0)
+	if (0)
 		intel_sdvo_set_encoder_power_state(intel_sdvo,
-						   DRM_MODE_DPMS_OFF);
-			temp = I915_READ(intel_sdvo->sdvo_reg);
-			if ((temp & SDVO_ENABLE) != 0) {
-		/* HW workaround for IBX, we need to move the port to
-		 * transcoder A before disabling it. */
-		if (HAS_PCH_IBX(encoder->base.dev)) {
-			struct drm_crtc *crtc = encoder->base.crtc;
+						   DRM_MODE_DPMS_OFF);
-			int pipe = crtc ? to_intel_crtc(crtc)->pipe : -1;
+	temp = I915_READ(intel_sdvo->sdvo_reg);
-			if (temp & SDVO_PIPE_B_SELECT) {
+	temp &= ~SDVO_ENABLE;
+	intel_sdvo_write_sdvox(intel_sdvo, temp);
-				temp &= ~SDVO_PIPE_B_SELECT;
+	/*
+	 * HW workaround for IBX, we need to move the port
+	 * to transcoder A after disabling it to allow the
-				I915_WRITE(intel_sdvo->sdvo_reg, temp);
+	 * matching DP port to be enabled on transcoder A.
-				POSTING_READ(intel_sdvo->sdvo_reg);
+	 */
-				/* Again we need to write this twice. */
-				I915_WRITE(intel_sdvo->sdvo_reg, temp);
+	if (HAS_PCH_IBX(dev_priv) && crtc->pipe == PIPE_B) {
-				POSTING_READ(intel_sdvo->sdvo_reg);
-				/* Transcoder selection bits only update
+		temp &= ~SDVO_PIPE_B_SELECT;
-				 * effectively on vblank. */
+		temp |= SDVO_ENABLE;
-				if (crtc)
+		intel_sdvo_write_sdvox(intel_sdvo, temp);
-					intel_wait_for_vblank(encoder->base.dev, pipe);
+		temp &= ~SDVO_ENABLE;
+		intel_sdvo_write_sdvox(intel_sdvo, temp);
+	}
+}
-				else
+static void pch_disable_sdvo(struct intel_encoder *encoder)
 					msleep(50);
+}
-		bool input1, input2;
+	bool input1, input2;
-		int i;
+	int i;
 	bool success;
-		temp = I915_READ(intel_sdvo->sdvo_reg);
+	temp = I915_READ(intel_sdvo->sdvo_reg);
-	if ((temp & SDVO_ENABLE) == 0) {
-		/* HW workaround for IBX, we need to move the port
-		 * to transcoder A before disabling it, so restore it here. */
-		if (HAS_PCH_IBX(dev))
+	temp |= SDVO_ENABLE;
-			temp |= SDVO_PIPE_SEL(intel_crtc->pipe);
-			intel_sdvo_write_sdvox(intel_sdvo, temp | SDVO_ENABLE);
+	intel_sdvo_write_sdvox(intel_sdvo, temp);
-		for (i = 0; i < 2; i++)
+	for (i = 0; i < 2; i++)
-			intel_wait_for_vblank(dev, intel_crtc->pipe);
+		intel_wait_for_vblank(dev, intel_crtc->pipe);
 		intel_sdvo_set_encoder_power_state(intel_sdvo,
 						   DRM_MODE_DPMS_ON);
 	intel_sdvo_set_active_outputs(intel_sdvo, intel_sdvo->attached_output);
+}
-/* Special dpms function to support cloning between dvo/sdvo/crt. */
-static void intel_sdvo_dpms(struct drm_connector *connector, int mode)
-{
-	struct drm_crtc *crtc;
-	struct intel_sdvo *intel_sdvo = intel_attached_sdvo(connector);
-	/* 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_sdvo->base.base.crtc;
-	if (!crtc) {
-		intel_sdvo->base.connectors_active = false;
-		return;
-	}
-	/* We set active outputs manually below in case pipe dpms doesn't change
-	 * due to cloning. */
-	if (mode != DRM_MODE_DPMS_ON) {
-		intel_sdvo_set_active_outputs(intel_sdvo, 0);
-		if (0)
-			intel_sdvo_set_encoder_power_state(intel_sdvo, mode);
-		intel_sdvo->base.connectors_active = false;
-		intel_crtc_update_dpms(crtc);
-	} else {
-		intel_sdvo->base.connectors_active = true;
-		intel_crtc_update_dpms(crtc);
-		if (0)
-			intel_sdvo_set_encoder_power_state(intel_sdvo, mode);
-		intel_sdvo_set_active_outputs(intel_sdvo, intel_sdvo->attached_output);
-	}
-	intel_modeset_check_state(connector->dev);
-}
 static enum drm_mode_status
 intel_sdvo_mode_valid(struct drm_connector *connector,
-				 struct drm_display_mode *mode)
+		      struct drm_display_mode *mode)
+{
 static uint16_t intel_sdvo_get_hotplug_support(struct intel_sdvo *intel_sdvo)
+{
 	struct drm_device *dev = intel_sdvo->base.base.dev;
 	uint16_t hotplug;
+	if (!I915_HAS_HOTPLUG(dev))
+		return 0;
 	/* HW Erratum: SDVO Hotplug is broken on all i945G chips, there's noise
 	 * on the line. */
 	if (IS_I945G(dev) || IS_I945GM(dev))
 			return 0;
 		goto done;
+	}
+	if (property == connector->dev->mode_config.aspect_ratio_property) {
+		switch (val) {
+		case DRM_MODE_PICTURE_ASPECT_NONE:
+			intel_sdvo->aspect_ratio = HDMI_PICTURE_ASPECT_NONE;
+			break;
+		case DRM_MODE_PICTURE_ASPECT_4_3:
+			intel_sdvo->aspect_ratio = HDMI_PICTURE_ASPECT_4_3;
+			break;
+		case DRM_MODE_PICTURE_ASPECT_16_9:
+			intel_sdvo->aspect_ratio = HDMI_PICTURE_ASPECT_16_9;
+			break;
+		default:
+			return -EINVAL;
+		}
+		goto done;
+	}
 #define CHECK_PROPERTY(name, NAME) \
 	if (intel_sdvo_connector->name == property) { \
 		if (intel_sdvo_connector->cur_##name == temp_value) return 0; \
 	return 0;
 #undef CHECK_PROPERTY
+}
 static const struct drm_connector_funcs intel_sdvo_connector_funcs = {
-	.dpms = intel_sdvo_dpms,
+	.dpms = drm_atomic_helper_connector_dpms,
 	.detect = intel_sdvo_detect,
 	.fill_modes = drm_helper_probe_single_connector_modes,
+	.set_property = intel_sdvo_set_property,
-	.set_property = intel_sdvo_set_property,
+	.atomic_get_property = intel_connector_atomic_get_property,
+	.destroy = intel_sdvo_destroy,
+	.atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
-	.destroy = intel_sdvo_destroy,
+	.atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
 };
 static const struct drm_connector_helper_funcs intel_sdvo_connector_helper_funcs = {
  * DDC bus number assignment is in a priority order of RGB outputs, then TMDS
  * outputs, then LVDS outputs.
  */
 static void
 intel_sdvo_select_ddc_bus(struct drm_i915_private *dev_priv,
-			  struct intel_sdvo *sdvo, u32 reg)
+			  struct intel_sdvo *sdvo)
+{
 	struct sdvo_device_mapping *mapping;
 	if (sdvo->is_sdvob)
 		intel_sdvo_guess_ddc_bus(sdvo);
+}
 static void
 intel_sdvo_select_i2c_bus(struct drm_i915_private *dev_priv,
-			  struct intel_sdvo *sdvo, u32 reg)
+			  struct intel_sdvo *sdvo)
+{
 	struct sdvo_device_mapping *mapping;
 	u8 pin;
 	if (sdvo->is_sdvob)
 		mapping = &dev_priv->sdvo_mappings[0];
+	else
-	else
+		mapping = &dev_priv->sdvo_mappings[1];
 		mapping = &dev_priv->sdvo_mappings[1];
 	if (mapping->initialized &&
-	if (mapping->initialized && intel_gmbus_is_port_valid(mapping->i2c_pin))
+	    intel_gmbus_is_valid_pin(dev_priv, mapping->i2c_pin))
 		pin = mapping->i2c_pin;
 	else
-	pin = GMBUS_PORT_DPB;
+		pin = GMBUS_PIN_DPB;
 	intel_attach_force_audio_property(&connector->base.base);
 	if (INTEL_INFO(dev)->gen >= 4 && IS_MOBILE(dev)) {
 		intel_attach_broadcast_rgb_property(&connector->base.base);
 		intel_sdvo->color_range_auto = true;
+	}
+	intel_attach_aspect_ratio_property(&connector->base.base);
+	intel_sdvo->aspect_ratio = HDMI_PICTURE_ASPECT_NONE;
+}
+static struct intel_sdvo_connector *intel_sdvo_connector_alloc(void)
+{
+	struct intel_sdvo_connector *sdvo_connector;
+	sdvo_connector = kzalloc(sizeof(*sdvo_connector), GFP_KERNEL);
+	if (!sdvo_connector)
+		return NULL;
+	if (intel_connector_init(&sdvo_connector->base) < 0) {
+		kfree(sdvo_connector);
+		return NULL;
+	}
+	return sdvo_connector;
+}
 static bool
 intel_sdvo_dvi_init(struct intel_sdvo *intel_sdvo, int device)
 	struct intel_connector *intel_connector;
 	struct intel_sdvo_connector *intel_sdvo_connector;
 	DRM_DEBUG_KMS("initialising DVI device %d\n", device);
-	intel_sdvo_connector = kzalloc(sizeof(*intel_sdvo_connector), GFP_KERNEL);
+	intel_sdvo_connector = intel_sdvo_connector_alloc();
 	if (!intel_sdvo_connector)
 		return false;
 	struct intel_connector *intel_connector;
 	struct intel_sdvo_connector *intel_sdvo_connector;
 	DRM_DEBUG_KMS("initialising TV type %d\n", type);
-	intel_sdvo_connector = kzalloc(sizeof(*intel_sdvo_connector), GFP_KERNEL);
+	intel_sdvo_connector = intel_sdvo_connector_alloc();
 	if (!intel_sdvo_connector)
 		return false;
 	struct intel_connector *intel_connector;
 	struct intel_sdvo_connector *intel_sdvo_connector;
 	DRM_DEBUG_KMS("initialising analog device %d\n", device);
-	intel_sdvo_connector = kzalloc(sizeof(*intel_sdvo_connector), GFP_KERNEL);
+	intel_sdvo_connector = intel_sdvo_connector_alloc();
 	if (!intel_sdvo_connector)
 		return false;
 	struct intel_connector *intel_connector;
 	struct intel_sdvo_connector *intel_sdvo_connector;
 	DRM_DEBUG_KMS("initialising LVDS device %d\n", device);
-	intel_sdvo_connector = kzalloc(sizeof(*intel_sdvo_connector), GFP_KERNEL);
+	intel_sdvo_connector = intel_sdvo_connector_alloc();
 	if (!intel_sdvo_connector)
 		return false;
-        return false;
+		return false;
-    intel_sdvo->sdvo_reg = sdvo_reg;
+	intel_sdvo->sdvo_reg = sdvo_reg;
 	intel_sdvo->is_sdvob = is_sdvob;
 	intel_sdvo->slave_addr = intel_sdvo_get_slave_addr(dev, intel_sdvo) >> 1;
-    intel_sdvo_select_i2c_bus(dev_priv, intel_sdvo, sdvo_reg);
+	intel_sdvo_select_i2c_bus(dev_priv, intel_sdvo);
 	if (!intel_sdvo_init_ddc_proxy(intel_sdvo, dev))
 		goto err_i2c_bus;
-            goto err;
+			goto err;
+		}
+	}
+	intel_encoder->compute_config = intel_sdvo_compute_config;
+	if (HAS_PCH_SPLIT(dev)) {
+		intel_encoder->disable = pch_disable_sdvo;
+		intel_encoder->post_disable = pch_post_disable_sdvo;
-	intel_encoder->compute_config = intel_sdvo_compute_config;
+	} else {
+		intel_encoder->disable = intel_disable_sdvo;
 	intel_encoder->disable = intel_disable_sdvo;
 	intel_encoder->pre_enable = intel_sdvo_pre_enable;
 	intel_encoder->enable = intel_enable_sdvo;
 	intel_encoder->get_hw_state = intel_sdvo_get_hw_state;
 	 * simplistic anyway to express such constraints, so just give up on
 	 * cloning for SDVO encoders.
 	 */
 	intel_sdvo->base.cloneable = 0;
-    intel_sdvo_select_ddc_bus(dev_priv, intel_sdvo, sdvo_reg);
+	intel_sdvo_select_ddc_bus(dev_priv, intel_sdvo);
-    /* Set the input timing to the screen. Assume always input 0. */
+	/* Set the input timing to the screen. Assume always input 0. */

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/i915/intel_sdvo.c @ 5367 – Rev 5367 → 6084