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

 #define SDVO_NAME(svdo) ((svdo)->is_sdvob ? "SDVOB" : "SDVOC")
 static void intel_sdvo_debug_write(struct intel_sdvo *intel_sdvo, u8 cmd,
 				   const void *args, int args_len)
 {
+	int i, pos = 0;
+#define BUF_LEN 256
+	char buffer[BUF_LEN];
+#define BUF_PRINT(args...) \
+	pos += snprintf(buffer + pos, max_t(int, BUF_LEN - pos, 0), args)
-	int i;
-	DRM_DEBUG_KMS("%s: W: %02X ",
-				SDVO_NAME(intel_sdvo), cmd);
+	for (i = 0; i < args_len; i++) {
-	for (i = 0; i < args_len; i++)
+		BUF_PRINT("%02X ", ((u8 *)args)[i]);
-		DRM_LOG_KMS("%02X ", ((u8 *)args)[i]);
+	}
+	for (; i < 8; i++) {
-	for (; i < 8; i++)
+		BUF_PRINT("   ");
 		DRM_LOG_KMS("   ");
 	for (i = 0; i < ARRAY_SIZE(sdvo_cmd_names); i++) {
 		if (cmd == sdvo_cmd_names[i].cmd) {
-			DRM_LOG_KMS("(%s)", sdvo_cmd_names[i].name);
+			BUF_PRINT("(%s)", sdvo_cmd_names[i].name);
 			break;
 		}
 	}
+	if (i == ARRAY_SIZE(sdvo_cmd_names)) {
-	if (i == ARRAY_SIZE(sdvo_cmd_names))
+		BUF_PRINT("(%02X)", cmd);
+	}
+	BUG_ON(pos >= BUF_LEN - 1);
+#undef BUF_PRINT
+#undef BUF_LEN
 		DRM_LOG_KMS("(%02X)", cmd);
-	DRM_LOG_KMS("\n");
+	DRM_DEBUG_KMS("%s: W: %02X %s\n", SDVO_NAME(intel_sdvo), cmd, buffer);
+}
 static bool intel_sdvo_read_response(struct intel_sdvo *intel_sdvo,
 				     void *response, int response_len)
+{
 	u8 retry = 15; /* 5 quick checks, followed by 10 long checks */
 	u8 status;
-	int i;
+	int i, pos = 0;
+#define BUF_LEN 256
+	char buffer[BUF_LEN];
 	DRM_DEBUG_KMS("%s: R: ", SDVO_NAME(intel_sdvo));
 	/*
 	 * The documentation states that all commands will be
 					  SDVO_I2C_CMD_STATUS,
 					  &status))
 			goto log_fail;
+	}
+#define BUF_PRINT(args...) \
+	pos += snprintf(buffer + pos, max_t(int, BUF_LEN - pos, 0), args)
 	if (status <= SDVO_CMD_STATUS_SCALING_NOT_SUPP)
-		DRM_LOG_KMS("(%s)", cmd_status_names[status]);
+		BUF_PRINT("(%s)", cmd_status_names[status]);
 	else
-		DRM_LOG_KMS("(??? %d)", status);
+		BUF_PRINT("(??? %d)", status);
 	if (status != SDVO_CMD_STATUS_SUCCESS)
 		goto log_fail;
 	/* Read the command response */
 	for (i = 0; i < response_len; i++) {
 		if (!intel_sdvo_read_byte(intel_sdvo,
 					  SDVO_I2C_RETURN_0 + i,
 					  &((u8 *)response)[i]))
 			goto log_fail;
+		BUF_PRINT(" %02X", ((u8 *)response)[i]);
+	}
+	BUG_ON(pos >= BUF_LEN - 1);
+#undef BUF_PRINT
-		DRM_LOG_KMS(" %02X", ((u8 *)response)[i]);
+#undef BUF_LEN
-	DRM_LOG_KMS("\n");
+	DRM_DEBUG_KMS("%s: R: %s\n", SDVO_NAME(intel_sdvo), buffer);
 	return true;
 log_fail:
-	DRM_LOG_KMS("... failed\n");
+	DRM_DEBUG_KMS("%s: R: ... failed\n", SDVO_NAME(intel_sdvo));
+}
 #endif
 static bool intel_sdvo_write_infoframe(struct intel_sdvo *intel_sdvo,
 				       unsigned if_index, uint8_t tx_rate,
-				       uint8_t *data, unsigned length)
+				       const uint8_t *data, unsigned length)
+{
 	uint8_t set_buf_index[2] = { if_index, 0 };
 	uint8_t hbuf_size, tmp[8];
 	return true;
+}
 static void i9xx_adjust_sdvo_tv_clock(struct intel_crtc_config *pipe_config)
 {
-	unsigned dotclock = pipe_config->adjusted_mode.clock;
+	unsigned dotclock = pipe_config->port_clock;
 	struct dpll *clock = &pipe_config->dpll;
 	/* SDVO TV has fixed PLL values depend on its clock range,
 	/* Make the CRTC code factor in the SDVO pixel multiplier.  The
 	 * SDVO device will factor out the multiplier during mode_set.
 	 */
 	pipe_config->pixel_multiplier =
 		intel_sdvo_get_pixel_multiplier(adjusted_mode);
-	adjusted_mode->clock *= pipe_config->pixel_multiplier;
 	if (intel_sdvo->color_range_auto) {
 		/* See CEA-861-E - 5.1 Default Encoding Parameters */
 		/* FIXME: This bit is only valid when using TMDS encoding and 8
 	if (intel_sdvo->is_tv &&
 	    !intel_sdvo_set_tv_format(intel_sdvo))
-		return;
-	/* We have tried to get input timing in mode_fixup, and filled into
-	 * adjusted_mode.
+		return;
-	 */
 	intel_sdvo_get_dtd_from_mode(&input_dtd, adjusted_mode);
-	input_dtd.part1.clock /= crtc->config.pixel_multiplier;
+	intel_sdvo_get_dtd_from_mode(&input_dtd, adjusted_mode);
 	if (intel_sdvo->is_tv || intel_sdvo->is_lvds)
 	struct drm_device *dev = encoder->base.dev;
 	struct drm_i915_private *dev_priv = dev->dev_private;
 	struct intel_sdvo *intel_sdvo = to_sdvo(encoder);
 	struct intel_sdvo_dtd dtd;
 	int encoder_pixel_multiplier = 0;
+	int dotclock;
 	u32 flags = 0, sdvox;
 	u8 val;
 	bool ret;
 		pipe_config->pixel_multiplier =
 			((sdvox & SDVO_PORT_MULTIPLY_MASK)
 			 >> SDVO_PORT_MULTIPLY_SHIFT) + 1;
+	}
+	dotclock = pipe_config->port_clock / pipe_config->pixel_multiplier;
+	if (HAS_PCH_SPLIT(dev))
+		ironlake_check_encoder_dotclock(pipe_config, dotclock);
+	pipe_config->adjusted_mode.crtc_clock = dotclock;
 	/* Cross check the port pixel multiplier with the sdvo encoder state. */
 	if (intel_sdvo_get_value(intel_sdvo, SDVO_CMD_GET_CLOCK_RATE_MULT,
 				 &val, 1)) {
 	switch (val) {
+	}
 	intel_modeset_check_state(connector->dev);
+}
-}
 static enum drm_mode_status
-static int intel_sdvo_mode_valid(struct drm_connector *connector,
+intel_sdvo_mode_valid(struct drm_connector *connector,
 				 struct drm_display_mode *mode)
+{
 static void intel_sdvo_get_ddc_modes(struct drm_connector *connector)
+{
+	struct edid *edid;
+	DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n",
-	struct edid *edid;
+		      connector->base.id, drm_get_connector_name(connector));
 	/* set the bus switch and get the modes */
 	edid = intel_sdvo_get_edid(connector);
 	struct intel_sdvo *intel_sdvo = intel_attached_sdvo(connector);
 	struct intel_sdvo_sdtv_resolution_request tv_res;
 	uint32_t reply = 0, format_map = 0;
 	int i;
+	DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n",
+		      connector->base.id, drm_get_connector_name(connector));
 	/* Read the list of supported input resolutions for the selected TV
 	 * format.
 	 */
 	format_map = 1 << intel_sdvo->tv_format_index;
+{
 	struct intel_sdvo *intel_sdvo = intel_attached_sdvo(connector);
 	struct drm_i915_private *dev_priv = connector->dev->dev_private;
 	struct drm_display_mode *newmode;
+	DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n",
+		      connector->base.id, drm_get_connector_name(connector));
 	/*
 	 * Fetch modes from VBT. For SDVO prefer the VBT mode since some
 	 * SDVO->LVDS transcoders can't cope with the EDID mode.
 	 */
 			intel_sdvo->is_lvds = true;
 			break;
+		}
-	}
+	}
+}
 static int intel_sdvo_get_modes(struct drm_connector *connector)
 	if (intel_sdvo_connector->tv_format)
 		drm_property_destroy(connector->dev,
 				     intel_sdvo_connector->tv_format);
-	intel_sdvo_destroy_enhance_property(connector);
-	drm_sysfs_connector_remove(connector);
+	intel_sdvo_destroy_enhance_property(connector);
 	drm_connector_cleanup(connector);
 	kfree(intel_sdvo_connector);
+}
 	struct drm_connector *connector;
 	struct intel_encoder *intel_encoder = to_intel_encoder(encoder);
 	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(struct intel_sdvo_connector), GFP_KERNEL);
+	intel_sdvo_connector = kzalloc(sizeof(*intel_sdvo_connector), GFP_KERNEL);
 	if (!intel_sdvo_connector)
 		return false;
 	struct drm_encoder *encoder = &intel_sdvo->base.base;
 	struct drm_connector *connector;
 	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(struct intel_sdvo_connector), GFP_KERNEL);
+	intel_sdvo_connector = kzalloc(sizeof(*intel_sdvo_connector), GFP_KERNEL);
 	if (!intel_sdvo_connector)
 		return false;
 		goto err;
 	return true;
 err:
-err:
+	drm_sysfs_connector_remove(connector);
 	intel_sdvo_destroy(connector);
 	return false;
 	struct drm_encoder *encoder = &intel_sdvo->base.base;
 	struct drm_connector *connector;
 	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(struct intel_sdvo_connector), GFP_KERNEL);
+	intel_sdvo_connector = kzalloc(sizeof(*intel_sdvo_connector), GFP_KERNEL);
 	if (!intel_sdvo_connector)
 		return false;
 	struct drm_encoder *encoder = &intel_sdvo->base.base;
 	struct drm_connector *connector;
 	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(struct intel_sdvo_connector), GFP_KERNEL);
+	intel_sdvo_connector = kzalloc(sizeof(*intel_sdvo_connector), GFP_KERNEL);
 	if (!intel_sdvo_connector)
 		return false;
 		goto err;
 	return true;
 err:
-err:
+	drm_sysfs_connector_remove(connector);
 	intel_sdvo_destroy(connector);
 	return false;
 	struct drm_device *dev = intel_sdvo->base.base.dev;
 	struct drm_connector *connector, *tmp;
 	list_for_each_entry_safe(connector, tmp,
 				 &dev->mode_config.connector_list, head) {
+		if (intel_attached_encoder(connector) == &intel_sdvo->base) {
-		if (intel_attached_encoder(connector) == &intel_sdvo->base)
+			drm_sysfs_connector_remove(connector);
 			intel_sdvo_destroy(connector);
+	}
+	}
+}
 static bool intel_sdvo_tv_create_property(struct intel_sdvo *intel_sdvo,
 					  struct intel_sdvo_connector *intel_sdvo_connector,
+{
     struct drm_i915_private *dev_priv = dev->dev_private;
     struct intel_encoder *intel_encoder;
     struct intel_sdvo *intel_sdvo;
     int i;
-    intel_sdvo = kzalloc(sizeof(struct intel_sdvo), GFP_KERNEL);
+	intel_sdvo = kzalloc(sizeof(*intel_sdvo), GFP_KERNEL);
     if (!intel_sdvo)
         return false;
     intel_sdvo->sdvo_reg = sdvo_reg;

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/i915/intel_sdvo.c – Rev 4104 → 4560