WebSVN – Kolibri OS – Diff – /drivers/video/drm/drm_edid.c

  * DEALINGS IN THE SOFTWARE.
  */
 #include
 #include
 #include
+#include
-#include "drmP.h"
+#include
-#include "drm_edid.h"
+#include
 #include "drm_edid_modes.h"
 #define version_greater(edid, maj, min) \
 	(((edid)->version > (maj)) || \
 #define EDID_QUIRK_DETAILED_USE_MAXIMUM_SIZE	(1 << 4)
 /* Monitor forgot to set the first detailed is preferred bit. */
 #define EDID_QUIRK_FIRST_DETAILED_PREFERRED	(1 << 5)
 /* use +hsync +vsync for detailed mode */
 #define EDID_QUIRK_DETAILED_SYNC_PP		(1 << 6)
+/* Force reduced-blanking timings for detailed modes */
+#define EDID_QUIRK_FORCE_REDUCED_BLANKING	(1 << 7)
 struct detailed_mode_closure {
 	struct drm_connector *connector;
 	struct edid *edid;
 #define LEVEL_GTF	1
 #define LEVEL_GTF2	2
 #define LEVEL_CVT	3
 static struct edid_quirk {
-	char *vendor;
+	char vendor[4];
 	int product_id;
 	u32 quirks;
+} edid_quirk_list[] = {
+	/* ASUS VW222S */
+	{ "ACI", 0x22a2, EDID_QUIRK_FORCE_REDUCED_BLANKING },
 } edid_quirk_list[] = {
 	/* Acer AL1706 */
 	{ "ACR", 44358, EDID_QUIRK_PREFER_LARGE_60 },
 	/* Acer F51 */
 	{ "API", 0x7602, EDID_QUIRK_PREFER_LARGE_60 },
 	/* Samsung SyncMaster 205BW.  Note: irony */
 	{ "SAM", 541, EDID_QUIRK_DETAILED_SYNC_PP },
 	/* Samsung SyncMaster 22[5-6]BW */
 	{ "SAM", 596, EDID_QUIRK_PREFER_LARGE_60 },
 	{ "SAM", 638, EDID_QUIRK_PREFER_LARGE_60 },
+	/* ViewSonic VA2026w */
+	{ "VSC", 5020, EDID_QUIRK_FORCE_REDUCED_BLANKING },
 };
 /*** DDC fetch and block validation ***/
 	return score;
+}
+EXPORT_SYMBOL(drm_edid_header_is_valid);
+static int edid_fixup __read_mostly = 6;
+//module_param_named(edid_fixup, edid_fixup, int, 0400);
-EXPORT_SYMBOL(drm_edid_header_is_valid);
+//MODULE_PARM_DESC(edid_fixup,
 //        "Minimum number of valid EDID header bytes (0-8, default 6)");
 /*
- * Sanity check the EDID block (base or extension).  Return 0 if the block
- * doesn't check out, or 1 if it's valid.
+ * Sanity check the EDID block (base or extension).  Return 0 if the block
- */
+ * doesn't check out, or 1 if it's valid.
-static bool
+ */
-drm_edid_block_valid(u8 *raw_edid)
+bool drm_edid_block_valid(u8 *raw_edid, int block, bool print_bad_edid)
+{
+	int i;
+	u8 csum = 0;
+	struct edid *edid = (struct edid *)raw_edid;
-	int i;
-	u8 csum = 0;
+	if (edid_fixup > 8 || edid_fixup < 0)
-	struct edid *edid = (struct edid *)raw_edid;
+		edid_fixup = 6;
-	if (raw_edid[0] == 0x00) {
+	if (block == 0) {
 		int score = drm_edid_header_is_valid(raw_edid);
 	if (score == 8) ;
-	else if (score >= 6) {
+		else if (score >= edid_fixup) {
 		DRM_DEBUG("Fixing EDID header, your hardware may be failing\n");
 		printk(KERN_ERR "Raw EDID:\n");
 //		print_hex_dump_bytes(KERN_ERR, DUMP_PREFIX_NONE, raw_edid, EDID_LENGTH);
+	}
 	return 0;
+}
+EXPORT_SYMBOL(drm_edid_block_valid);
 /**
  * drm_edid_is_valid - sanity check EDID data
  * @edid: EDID data
 	if (!edid)
 		return false;
 	for (i = 0; i <= edid->extensions; i++)
-		if (!drm_edid_block_valid(raw + i * EDID_LENGTH))
+		if (!drm_edid_block_valid(raw + i * EDID_LENGTH, i, true))
 			return false;
-	return true;
 	return true;
 EXPORT_SYMBOL(drm_edid_is_valid);
 EXPORT_SYMBOL(drm_edid_is_valid);
 #define DDC_ADDR 0x50
 #define DDC_SEGMENT_ADDR 0x30
 static int
 drm_do_probe_ddc_edid(struct i2c_adapter *adapter, unsigned char *buf,
 		      int block, int len)
+{
 	unsigned char start = block * EDID_LENGTH;
+	unsigned char segment = block >> 1;
+	unsigned char xfers = segment ? 3 : 2;
 	int ret, retries = 5;
 	/* The core i2c driver will automatically retry the transfer if the
 	 * adapter reports EAGAIN. However, we find that bit-banging transfers
 	 * of the individual block a few times seems to overcome this.
 	 */
 	do {
 	struct i2c_msg msgs[] = {
+		{
+				.addr	= DDC_SEGMENT_ADDR,
+				.flags	= 0,
+				.len	= 1,
+				.buf	= &segment,
+			}, {
 			.addr	= DDC_ADDR,
 			.flags	= 0,
 			.len	= 1,
 			.buf	= &start,
 		}, {
 			.flags	= I2C_M_RD,
 			.len	= len,
 			.buf	= buf,
+		}
 	};
-		ret = i2c_transfer(adapter, msgs, 2);
-	} while (ret != 2 && --retries);
+	/*
+	 * Avoid sending the segment addr to not upset non-compliant ddc
+	 * monitors.
+	 */
+		ret = i2c_transfer(adapter, &msgs[3 - xfers], xfers);
+		if (ret == -ENXIO) {
+			DRM_DEBUG_KMS("drm: skipping non-existent adapter %s\n",
+					adapter->name);
+			break;
+		}
+	} while (ret != xfers && --retries);
-	return ret == 2 ? 0 : -1;
+	return ret == xfers ? 0 : -1;
+}
 static bool drm_edid_is_zero(u8 *in_edid, int length)
+}
 static u8 *
 drm_do_get_edid(struct drm_connector *connector, struct i2c_adapter *adapter)
+{
 	size_t alloc_size;
 	int i, j = 0, valid_extensions = 0;
 	u8 *block, *new;
-    size_t alloc_size;
+	bool print_bad_edid = !connector->bad_edid_counter || (drm_debug & DRM_UT_KMS);
 	if ((block = kmalloc(EDID_LENGTH, GFP_KERNEL)) == NULL)
 		return NULL;
 	/* base block fetch */
 	for (i = 0; i < 4; i++) {
 		if (drm_do_probe_ddc_edid(adapter, block, 0, EDID_LENGTH))
 			goto out;
-		if (drm_edid_block_valid(block))
+		if (drm_edid_block_valid(block, 0, print_bad_edid))
 			break;
 		if (i == 0 && drm_edid_is_zero(block, EDID_LENGTH)) {
 		for (i = 0; i < 4; i++) {
 			if (drm_do_probe_ddc_edid(adapter,
 				  block + (valid_extensions + 1) * EDID_LENGTH,
 				  j, EDID_LENGTH))
 				goto out;
-			if (drm_edid_block_valid(block + (valid_extensions + 1) * EDID_LENGTH)) {
+			if (drm_edid_block_valid(block + (valid_extensions + 1) * EDID_LENGTH, j, print_bad_edid)) {
 				valid_extensions++;
 				break;
+		}
+		}
 		if (i == 4)
+	}
 	return block;
 carp:
-carp:
+	if (print_bad_edid) {
+	dev_warn(connector->dev->dev, "%s: EDID block %d invalid.\n",
+		 drm_get_connector_name(connector), j);
 	dev_warn(connector->dev->dev, "%s: EDID block %d invalid.\n",
-		 drm_get_connector_name(connector), j);
+	connector->bad_edid_counter++;
 out:
  * Probe DDC presence.
+ *
  * \param adapter : i2c device adaptor
  * \return 1 on success
  */
-static bool
+bool
 drm_probe_ddc(struct i2c_adapter *adapter)
+{
 	unsigned char out;
 	return (drm_do_probe_ddc_edid(adapter, &out, 0, 1) == 0);
+}
 EXPORT_SYMBOL(drm_probe_ddc);
 /**
  * drm_get_edid - get EDID data, if available
 	struct edid *edid = NULL;
 	if (drm_probe_ddc(adapter))
-		edid = (struct edid *)drm_do_get_edid(connector, adapter);
-	connector->display_info.raw_edid = (char *)edid;
+		edid = (struct edid *)drm_do_get_edid(connector, adapter);
 	return edid;
 	return edid;
+}
+	}
 	preferred_mode->type |= DRM_MODE_TYPE_PREFERRED;
+}
+static bool
+mode_is_rb(const struct drm_display_mode *mode)
+{
+	return (mode->htotal - mode->hdisplay == 160) &&
+	       (mode->hsync_end - mode->hdisplay == 80) &&
+	       (mode->hsync_end - mode->hsync_start == 32) &&
+	       (mode->vsync_start - mode->vdisplay == 3);
+}
+/*
+ * drm_mode_find_dmt - Create a copy of a mode if present in DMT
+ * @dev: Device to duplicate against
+ * @hsize: Mode width
+ * @vsize: Mode height
+ * @fresh: Mode refresh rate
+ * @rb: Mode reduced-blanking-ness
+ *
+ * Walk the DMT mode list looking for a match for the given parameters.
  * Return a newly allocated copy of the mode, or NULL if not found.
+ */
+struct drm_display_mode *drm_mode_find_dmt(struct drm_device *dev,
-struct drm_display_mode *drm_mode_find_dmt(struct drm_device *dev,
+					   int hsize, int vsize, int fresh,
-			int hsize, int vsize, int fresh)
 					   bool rb)
 	struct drm_display_mode *mode = NULL;
 	int i;
+	for (i = 0; i < drm_num_dmt_modes; i++) {
-	for (i = 0; i < drm_num_dmt_modes; i++) {
+		const struct drm_display_mode *ptr = &drm_dmt_modes[i];
+		if (hsize != ptr->hdisplay)
-		const struct drm_display_mode *ptr = &drm_dmt_modes[i];
+			continue;
-		if (hsize == ptr->hdisplay &&
+		if (vsize != ptr->vdisplay)
-			vsize == ptr->vdisplay &&
+			continue;
-			fresh == drm_mode_vrefresh(ptr)) {
+		if (fresh != drm_mode_vrefresh(ptr))
-			/* get the expected default mode */
+			continue;
+		if (rb != mode_is_rb(ptr))
-			mode = drm_mode_duplicate(dev, ptr);
+			continue;
-			break;
+		return drm_mode_duplicate(dev, ptr);
+		}
-	return mode;
+	return NULL;
+}
 EXPORT_SYMBOL(drm_mode_find_dmt);
 typedef void detailed_cb(struct detailed_timing *timing, void *closure);
 static void
-cea_for_each_detailed_block(u8 *ext, detailed_cb *cb, void *closure)
-{
-	int i, n = 0;
-	u8 rev = ext[0x01], d = ext[0x02];
-	u8 *det_base = ext + d;
-	switch (rev) {
+cea_for_each_detailed_block(u8 *ext, detailed_cb *cb, void *closure)
-	case 0:
-		/* can't happen */
-		return;
-	case 1:
-		/* have to infer how many blocks we have, check pixel clock */
-		for (i = 0; i < 6; i++)
-			if (det_base[18*i] || det_base[18*i+1])
-				n++;
-		break;
 	default:
-		/* explicit count */
+	int i, n = 0;
-		n = min(ext[0x03] & 0x0f, 6);
+	u8 d = ext[0x02];
-		break;
+	u8 *det_base = ext + d;
 /* EDID 1.4 defines this explicitly.  For EDID 1.3, we guess, badly. */
 static bool
 drm_monitor_supports_rb(struct edid *edid)
+{
 	if (edid->revision >= 4) {
-		bool ret;
+		bool ret = false;
 		drm_for_each_detailed_block((u8 *)edid, is_rb, &ret);
 		return ret;
+	}
 		mode->hsync_end = mode->hsync_end - 1;
 		return mode;
+	}
+	/* check whether it can be found in default mode table */
-	/* check whether it can be found in default mode table */
+	if (drm_monitor_supports_rb(edid)) {
+		mode = drm_mode_find_dmt(dev, hsize, vsize, vrefresh_rate,
+					 true);
+		if (mode)
+			return mode;
+	}
-	mode = drm_mode_find_dmt(dev, hsize, vsize, vrefresh_rate);
+	mode = drm_mode_find_dmt(dev, hsize, vsize, vrefresh_rate, false);
 	if (mode)
+		return mode;
 		return mode;
 	/* okay, generate it */
 	switch (timing_level) {
 	case LEVEL_DMT:
 		break;
 		 * This is potentially wrong if there's ever a monitor with
 		 * more than one ranges section, each claiming a different
 		 * secondary GTF curve.  Please don't do that.
 		 */
 		mode = drm_gtf_mode(dev, hsize, vsize, vrefresh_rate, 0, 0);
+		if (!mode)
+			return NULL;
 		if (drm_mode_hsync(mode) > drm_gtf2_hbreak(edid)) {
-			kfree(mode);
+			drm_mode_destroy(dev, mode);
 			mode = drm_gtf_mode_complex(dev, hsize, vsize,
 						    vrefresh_rate, 0, 0,
 						    drm_gtf2_m(edid),
 						    drm_gtf2_2c(edid),
 						    drm_gtf2_k(edid),
 	if (!hsync_pulse_width || !vsync_pulse_width) {
 		DRM_DEBUG_KMS("Incorrect Detailed timing. "
 				"Wrong Hsync/Vsync pulse width\n");
 		return NULL;
+	}
+	if (quirks & EDID_QUIRK_FORCE_REDUCED_BLANKING) {
-	mode = drm_mode_create(dev);
+		mode = drm_cvt_mode(dev, hactive, vactive, 60, true, false, false);
-	if (!mode)
+		if (!mode)
-		return NULL;
+			return NULL;
+		goto set_size;
+	}
+	mode = drm_mode_create(dev);
+	if (!mode)
-	mode->type = DRM_MODE_TYPE_DRIVER;
+		return NULL;
 	if (quirks & EDID_QUIRK_135_CLOCK_TOO_HIGH)
 	if (mode->vsync_end > mode->vtotal)
 		mode->vtotal = mode->vsync_end + 1;
-	drm_mode_do_interlace_quirk(mode, pt);
-	drm_mode_set_name(mode);
+	drm_mode_do_interlace_quirk(mode, pt);
 	if (quirks & EDID_QUIRK_DETAILED_SYNC_PP) {
 		pt->misc |= DRM_EDID_PT_HSYNC_POSITIVE | DRM_EDID_PT_VSYNC_POSITIVE;
+	}
 	mode->flags |= (pt->misc & DRM_EDID_PT_HSYNC_POSITIVE) ?
+		DRM_MODE_FLAG_PHSYNC : DRM_MODE_FLAG_NHSYNC;
-		DRM_MODE_FLAG_PHSYNC : DRM_MODE_FLAG_NHSYNC;
+	mode->flags |= (pt->misc & DRM_EDID_PT_VSYNC_POSITIVE) ?
-	mode->flags |= (pt->misc & DRM_EDID_PT_VSYNC_POSITIVE) ?
+		DRM_MODE_FLAG_PVSYNC : DRM_MODE_FLAG_NVSYNC;
 		DRM_MODE_FLAG_PVSYNC : DRM_MODE_FLAG_NVSYNC;
 set_size:
 	if (quirks & EDID_QUIRK_DETAILED_USE_MAXIMUM_SIZE) {
 		mode->width_mm = edid->width_cm * 10;
 		mode->height_mm = edid->height_cm * 10;
+	}
+	mode->type = DRM_MODE_TYPE_DRIVER;
-	return mode;
-}
+	drm_mode_set_name(mode);
-static bool
-mode_is_rb(const struct drm_display_mode *mode)
-{
-	return (mode->htotal - mode->hdisplay == 160) &&
-	       (mode->hsync_end - mode->hdisplay == 80) &&
 	       (mode->hsync_end - mode->hsync_start == 32) &&
-	       (mode->vsync_start - mode->vdisplay == 3);
+	return mode;
+}
 		return false;
 	return true;
+}
-}
+static bool valid_inferred_mode(const struct drm_connector *connector,
+				const struct drm_display_mode *mode)
+{
+	struct drm_display_mode *m;
+	bool ok = false;
+	list_for_each_entry(m, &connector->probed_modes, head) {
+		if (mode->hdisplay == m->hdisplay &&
-/*
+		    mode->vdisplay == m->vdisplay &&
+		    drm_mode_vrefresh(mode) == drm_mode_vrefresh(m))
+			return false; /* duplicated */
+		if (mode->hdisplay <= m->hdisplay &&
- * XXX If drm_dmt_modes ever regrows the CVT-R modes (and it will) this will
+		    mode->vdisplay <= m->vdisplay)
+			ok = true;
+	}
+	return ok;
  * need to account for them.
- */
 static int
-drm_gtf_modes_for_range(struct drm_connector *connector, struct edid *edid,
+drm_dmt_modes_for_range(struct drm_connector *connector, struct edid *edid,
 				   struct detailed_timing *timing)
+{
 	int i, modes = 0;
 	struct drm_display_mode *newmode;
 	struct drm_device *dev = connector->dev;
 	for (i = 0; i < drm_num_dmt_modes; i++) {
-	for (i = 0; i < drm_num_dmt_modes; i++) {
+		if (mode_in_range(drm_dmt_modes + i, edid, timing) &&
-		if (mode_in_range(drm_dmt_modes + i, edid, timing)) {
+		    valid_inferred_mode(connector, drm_dmt_modes + i)) {
 			newmode = drm_mode_duplicate(dev, &drm_dmt_modes[i]);
 			if (newmode) {
+	}
 	return modes;
+}
+/* fix up 1366x768 mode from 1368x768;
+ * GFT/CVT can't express 1366 width which isn't dividable by 8
+ */
+static void fixup_mode_1366x768(struct drm_display_mode *mode)
+{
+	if (mode->hdisplay == 1368 && mode->vdisplay == 768) {
+		mode->hdisplay = 1366;
+		mode->hsync_start--;
+		mode->hsync_end--;
+		drm_mode_set_name(mode);
+	}
+}
+static int
+drm_gtf_modes_for_range(struct drm_connector *connector, struct edid *edid,
+			struct detailed_timing *timing)
+{
+	int i, modes = 0;
+	struct drm_display_mode *newmode;
+	struct drm_device *dev = connector->dev;
+	for (i = 0; i < num_extra_modes; i++) {
+		const struct minimode *m = &extra_modes[i];
+		newmode = drm_gtf_mode(dev, m->w, m->h, m->r, 0, 0);
+		if (!newmode)
+			return modes;
+		fixup_mode_1366x768(newmode);
+		if (!mode_in_range(newmode, edid, timing) ||
+		    !valid_inferred_mode(connector, newmode)) {
+			drm_mode_destroy(dev, newmode);
+			continue;
+		}
+		drm_mode_probed_add(connector, newmode);
+		modes++;
+	}
+	return modes;
+}
+static int
+drm_cvt_modes_for_range(struct drm_connector *connector, struct edid *edid,
+			struct detailed_timing *timing)
+{
+	int i, modes = 0;
+	struct drm_display_mode *newmode;
+	struct drm_device *dev = connector->dev;
+	bool rb = drm_monitor_supports_rb(edid);
+	for (i = 0; i < num_extra_modes; i++) {
+		const struct minimode *m = &extra_modes[i];
+		newmode = drm_cvt_mode(dev, m->w, m->h, m->r, rb, 0, 0);
+		if (!newmode)
+			return modes;
+		fixup_mode_1366x768(newmode);
+		if (!mode_in_range(newmode, edid, timing) ||
+		    !valid_inferred_mode(connector, newmode)) {
+			drm_mode_destroy(dev, newmode);
+			continue;
+		}
+		drm_mode_probed_add(connector, newmode);
+		modes++;
+	}
+	return modes;
+}
 static void
 do_inferred_modes(struct detailed_timing *timing, void *c)
+{
+	struct detailed_mode_closure *closure = c;
+	struct detailed_non_pixel *data = &timing->data.other_data;
-	struct detailed_mode_closure *closure = c;
+	struct detailed_data_monitor_range *range = &data->data.range;
+	if (data->type != EDID_DETAIL_MONITOR_RANGE)
+		return;
+	closure->modes += drm_dmt_modes_for_range(closure->connector,
-	struct detailed_non_pixel *data = &timing->data.other_data;
+						  closure->edid,
+						  timing);
+	if (!version_greater(closure->edid, 1, 1))
+		return; /* GTF not defined yet */
-	int gtf = (closure->edid->features & DRM_EDID_FEATURE_DEFAULT_GTF);
+	switch (range->flags) {
 	case 0x02: /* secondary gtf, XXX could do more */
-	if (gtf && data->type == EDID_DETAIL_MONITOR_RANGE)
+	case 0x00: /* default gtf */
+		closure->modes += drm_gtf_modes_for_range(closure->connector,
+							  closure->edid,
+							  timing);
+		break;
+	case 0x04: /* cvt, only in 1.4+ */
+		if (!version_greater(closure->edid, 1, 3))
+			break;
+		closure->modes += drm_cvt_modes_for_range(closure->connector,
+							  closure->edid,
+							  timing);
+		break;
+	case 0x01: /* just the ranges, no formula */
-		closure->modes += drm_gtf_modes_for_range(closure->connector,
+	default:
-							  closure->edid,
+		break;
 							  timing);
+}
 				break;
 			if (est[i] & (1 << j)) {
 				mode = drm_mode_find_dmt(connector->dev,
 							 est3_modes[m].w,
 							 est3_modes[m].h,
-							 est3_modes[m].r
+							 est3_modes[m].r,
-							 /*, est3_modes[m].rb */);
+							 est3_modes[m].rb);
 				if (mode) {
 					drm_mode_probed_add(connector, mode);
 					modes++;
+				}
+			}
 	return closure.modes;
+}
 #define HDMI_IDENTIFIER 0x000C03
+#define AUDIO_BLOCK	0x01
-#define AUDIO_BLOCK	0x01
+#define VIDEO_BLOCK     0x02
+#define VENDOR_BLOCK    0x03
-#define VENDOR_BLOCK    0x03
+#define SPEAKER_BLOCK	0x04
+#define EDID_BASIC_AUDIO	(1 << 6)
+#define EDID_CEA_YCRCB444	(1 << 5)
-#define EDID_BASIC_AUDIO	(1 << 6)
+#define EDID_CEA_YCRCB422	(1 << 4)
 /**
  * Search EDID for CEA extension block.
 	return edid_ext;
+}
+EXPORT_SYMBOL(drm_find_cea_extension);
+static int
+do_cea_modes (struct drm_connector *connector, u8 *db, u8 len)
+{
+	struct drm_device *dev = connector->dev;
+	u8 * mode, cea_mode;
+	int modes = 0;
+	for (mode = db; mode < db + len; mode++) {
+		cea_mode = (*mode & 127) - 1; /* CEA modes are numbered 1..127 */
+		if (cea_mode < drm_num_cea_modes) {
+			struct drm_display_mode *newmode;
+			newmode = drm_mode_duplicate(dev,
+						     &edid_cea_modes[cea_mode]);
+			if (newmode) {
+				drm_mode_probed_add(connector, newmode);
+				modes++;
+			}
+		}
+	}
+	return modes;
+}
+static int
+cea_db_payload_len(const u8 *db)
+{
+	return db[0] & 0x1f;
+}
+static int
+cea_db_tag(const u8 *db)
+{
+	return db[0] >> 5;
+}
+static int
+cea_revision(const u8 *cea)
+{
+	return cea[1];
+}
+static int
+cea_db_offsets(const u8 *cea, int *start, int *end)
+{
+	/* Data block offset in CEA extension block */
+	*start = 4;
+	*end = cea[2];
+	if (*end == 0)
+		*end = 127;
+	if (*end < 4 || *end > 127)
+		return -ERANGE;
+	return 0;
+}
+#define for_each_cea_db(cea, i, start, end) \
+	for ((i) = (start); (i) < (end) && (i) + cea_db_payload_len(&(cea)[(i)]) < (end); (i) += cea_db_payload_len(&(cea)[(i)]) + 1)
+static int
+add_cea_modes(struct drm_connector *connector, struct edid *edid)
+{
+	u8 * cea = drm_find_cea_extension(edid);
+	u8 * db, dbl;
+	int modes = 0;
+	if (cea && cea_revision(cea) >= 3) {
+		int i, start, end;
+		if (cea_db_offsets(cea, &start, &end))
+			return 0;
+		for_each_cea_db(cea, i, start, end) {
+			db = &cea[i];
+			dbl = cea_db_payload_len(db);
+			if (cea_db_tag(db) == VIDEO_BLOCK)
+				modes += do_cea_modes (connector, db+1, dbl);
+		}
+	}
+	return modes;
+}
+static void
+parse_hdmi_vsdb(struct drm_connector *connector, const u8 *db)
+{
+	u8 len = cea_db_payload_len(db);
+	if (len >= 6) {
+	connector->eld[5] |= (db[6] >> 7) << 1;  /* Supports_AI */
+	connector->dvi_dual = db[6] & 1;
+	}
+	if (len >= 7)
+	connector->max_tmds_clock = db[7] * 5;
+	if (len >= 8) {
+	connector->latency_present[0] = db[8] >> 7;
+	connector->latency_present[1] = (db[8] >> 6) & 1;
+	}
+	if (len >= 9)
+	connector->video_latency[0] = db[9];
+	if (len >= 10)
+	connector->audio_latency[0] = db[10];
+	if (len >= 11)
+	connector->video_latency[1] = db[11];
+	if (len >= 12)
+	connector->audio_latency[1] = db[12];
+	DRM_LOG_KMS("HDMI: DVI dual %d, "
+		    "max TMDS clock %d, "
+		    "latency present %d %d, "
+		    "video latency %d %d, "
+		    "audio latency %d %d\n",
+		    connector->dvi_dual,
+		    connector->max_tmds_clock,
+	      (int) connector->latency_present[0],
+	      (int) connector->latency_present[1],
+		    connector->video_latency[0],
+		    connector->video_latency[1],
+		    connector->audio_latency[0],
+		    connector->audio_latency[1]);
+}
+static void
+monitor_name(struct detailed_timing *t, void *data)
+{
+	if (t->data.other_data.type == EDID_DETAIL_MONITOR_NAME)
+		*(u8 **)data = t->data.other_data.data.str.str;
+}
+static bool cea_db_is_hdmi_vsdb(const u8 *db)
+{
+	int hdmi_id;
+	if (cea_db_tag(db) != VENDOR_BLOCK)
+		return false;
+	if (cea_db_payload_len(db) < 5)
+		return false;
+	hdmi_id = db[1] | (db[2] << 8) | (db[3] << 16);
+	return hdmi_id == HDMI_IDENTIFIER;
+}
+/**
+ * drm_edid_to_eld - build ELD from EDID
+ * @connector: connector corresponding to the HDMI/DP sink
+ * @edid: EDID to parse
+ *
+ * Fill the ELD (EDID-Like Data) buffer for passing to the audio driver.
+ * Some ELD fields are left to the graphics driver caller:
+ * - Conn_Type
+ * - HDCP
+ * - Port_ID
+ */
+void drm_edid_to_eld(struct drm_connector *connector, struct edid *edid)
+{
+	uint8_t *eld = connector->eld;
+	u8 *cea;
+	u8 *name;
+	u8 *db;
+	int sad_count = 0;
+	int mnl;
+	int dbl;
+	memset(eld, 0, sizeof(connector->eld));
+	cea = drm_find_cea_extension(edid);
+	if (!cea) {
+		DRM_DEBUG_KMS("ELD: no CEA Extension found\n");
+		return;
+	}
+	name = NULL;
+	drm_for_each_detailed_block((u8 *)edid, monitor_name, &name);
+	for (mnl = 0; name && mnl < 13; mnl++) {
+		if (name[mnl] == 0x0a)
+			break;
+		eld[20 + mnl] = name[mnl];
+	}
+	eld[4] = (cea[1] << 5) | mnl;
+	DRM_DEBUG_KMS("ELD monitor %s\n", eld + 20);
+	eld[0] = 2 << 3;		/* ELD version: 2 */
+	eld[16] = edid->mfg_id[0];
+	eld[17] = edid->mfg_id[1];
+	eld[18] = edid->prod_code[0];
+	eld[19] = edid->prod_code[1];
+	if (cea_revision(cea) >= 3) {
+		int i, start, end;
+		if (cea_db_offsets(cea, &start, &end)) {
+			start = 0;
+			end = 0;
+		}
+		for_each_cea_db(cea, i, start, end) {
+			db = &cea[i];
+			dbl = cea_db_payload_len(db);
+			switch (cea_db_tag(db)) {
+			case AUDIO_BLOCK:
+				/* Audio Data Block, contains SADs */
+				sad_count = dbl / 3;
+				if (dbl >= 1)
+				memcpy(eld + 20 + mnl, &db[1], dbl);
+				break;
+			case SPEAKER_BLOCK:
+                                /* Speaker Allocation Data Block */
+				if (dbl >= 1)
+				eld[7] = db[1];
+				break;
+			case VENDOR_BLOCK:
+				/* HDMI Vendor-Specific Data Block */
+				if (cea_db_is_hdmi_vsdb(db))
+					parse_hdmi_vsdb(connector, db);
+				break;
+			default:
+				break;
+			}
+		}
+	}
+	eld[5] |= sad_count << 4;
+	eld[2] = (20 + mnl + sad_count * 3 + 3) / 4;
+	DRM_DEBUG_KMS("ELD size %d, SAD count %d\n", (int)eld[2], sad_count);
+}
+EXPORT_SYMBOL(drm_edid_to_eld);
+/**
+ * drm_av_sync_delay - HDMI/DP sink audio-video sync delay in millisecond
+ * @connector: connector associated with the HDMI/DP sink
+ * @mode: the display mode
+ */
+int drm_av_sync_delay(struct drm_connector *connector,
+		      struct drm_display_mode *mode)
+{
+	int i = !!(mode->flags & DRM_MODE_FLAG_INTERLACE);
+	int a, v;
+	if (!connector->latency_present[0])
+		return 0;
+	if (!connector->latency_present[1])
+		i = 0;
+	a = connector->audio_latency[i];
+	v = connector->video_latency[i];
+	/*
+	 * HDMI/DP sink doesn't support audio or video?
+	 */
+	if (a == 255 || v == 255)
+		return 0;
+	/*
+	 * Convert raw EDID values to millisecond.
+	 * Treat unknown latency as 0ms.
+	 */
+	if (a)
+		a = min(2 * (a - 1), 500);
+	if (v)
+		v = min(2 * (v - 1), 500);
+	return max(v - a, 0);
+}
+EXPORT_SYMBOL(drm_av_sync_delay);
+/**
+ * drm_select_eld - select one ELD from multiple HDMI/DP sinks
+ * @encoder: the encoder just changed display mode
+ * @mode: the adjusted display mode
+ *
+ * It's possible for one encoder to be associated with multiple HDMI/DP sinks.
+ * The policy is now hard coded to simply use the first HDMI/DP sink's ELD.
+ */
+struct drm_connector *drm_select_eld(struct drm_encoder *encoder,
+				     struct drm_display_mode *mode)
+{
+	struct drm_connector *connector;
+	struct drm_device *dev = encoder->dev;
+	list_for_each_entry(connector, &dev->mode_config.connector_list, head)
+		if (connector->encoder == encoder && connector->eld[0])
+			return connector;
+	return NULL;
+}
-EXPORT_SYMBOL(drm_find_cea_extension);
+EXPORT_SYMBOL(drm_select_eld);
 /**
  * drm_detect_hdmi_monitor - detect whether monitor is hdmi.
  * @edid: monitor EDID information
+ *
  * Parse the CEA extension according to CEA-861-B.
  * Return true if HDMI, false if not or unknown.
  */
 bool drm_detect_hdmi_monitor(struct edid *edid)
 {
 	u8 *edid_ext;
-	int i, hdmi_id;
-	int start_offset, end_offset;
+	int i;
-	bool is_hdmi = false;
+	int start_offset, end_offset;
 	edid_ext = drm_find_cea_extension(edid);
 	if (!edid_ext)
-		goto end;
 		return false;
 	/* Data block offset in CEA extension block */
-	start_offset = 4;
+	if (cea_db_offsets(edid_ext, &start_offset, &end_offset))
-	end_offset = edid_ext[2];
+		return false;
-	/*
-	 * Because HDMI identifier is in Vendor Specific Block,
-	 * search it from all data blocks of CEA extension.
-	 */
-	for (i = start_offset; i < end_offset;
+	/*
-		/* Increased by data block len */
-		i += ((edid_ext[i] & 0x1f) + 1)) {
-		/* Find vendor specific block */
-		if ((edid_ext[i] >> 5) == VENDOR_BLOCK) {
+	 * Because HDMI identifier is in Vendor Specific Block,
-			hdmi_id = edid_ext[i + 1] | (edid_ext[i + 2] << 8) |
-				  edid_ext[i + 3] << 16;
-			/* Find HDMI identifier */
+	 * search it from all data blocks of CEA extension.
-			if (hdmi_id == HDMI_IDENTIFIER)
-				is_hdmi = true;
+	 */
-			break;
+	for_each_cea_db(edid_ext, i, start_offset, end_offset) {
 		if (cea_db_is_hdmi_vsdb(&edid_ext[i]))
 			return true;
+	}
 	if (has_audio) {
 		DRM_DEBUG_KMS("Monitor has basic audio support\n");
 		goto end;
+	}
-	/* Data block offset in CEA extension block */
+	if (cea_db_offsets(edid_ext, &start_offset, &end_offset))
-	start_offset = 4;
-	end_offset = edid_ext[2];
+		goto end;
-	for (i = start_offset; i < end_offset;
-			i += ((edid_ext[i] & 0x1f) + 1)) {
+	for_each_cea_db(edid_ext, i, start_offset, end_offset) {
-		if ((edid_ext[i] >> 5) == AUDIO_BLOCK) {
+		if (cea_db_tag(&edid_ext[i]) == AUDIO_BLOCK) {
 			has_audio = true;
-			for (j = 1; j < (edid_ext[i] & 0x1f); j += 3)
+			for (j = 1; j < cea_db_payload_len(&edid_ext[i]) + 1; j += 3)
 				DRM_DEBUG_KMS("CEA audio format %d\n",
 					      (edid_ext[i + j] >> 3) & 0xf);
 			goto end;
 	/* driver figures it out in this case */
 	info->bpc = 0;
-	info->color_formats = 0;
+	info->color_formats = 0;
 	/* Only defined for 1.4 with digital displays */
-	if (edid->revision < 4)
+	if (edid->revision < 3)
 		return;
+	if (!(edid->input & DRM_EDID_INPUT_DIGITAL))
+		return;
+	/* Get data from CEA blocks if present */
+	edid_ext = drm_find_cea_extension(edid);
+	if (edid_ext) {
+		info->cea_rev = edid_ext[1];
+		/* The existence of a CEA block should imply RGB support */
+		info->color_formats = DRM_COLOR_FORMAT_RGB444;
+		if (edid_ext[3] & EDID_CEA_YCRCB444)
+			info->color_formats |= DRM_COLOR_FORMAT_YCRCB444;
+		if (edid_ext[3] & EDID_CEA_YCRCB422)
+			info->color_formats |= DRM_COLOR_FORMAT_YCRCB422;
+	}
 	/* Only defined for 1.4 with digital displays */
-	if (!(edid->input & DRM_EDID_INPUT_DIGITAL))
+	if (edid->revision < 4)
 		return;
 	switch (edid->input & DRM_EDID_DIGITAL_DEPTH_MASK) {
 	default:
 		info->bpc = 0;
 		break;
+	}
-	info->color_formats = DRM_COLOR_FORMAT_RGB444;
+	info->color_formats |= DRM_COLOR_FORMAT_RGB444;
-	if (info->color_formats & DRM_EDID_FEATURE_RGB_YCRCB444)
+	if (edid->features & DRM_EDID_FEATURE_RGB_YCRCB444)
-		info->color_formats = DRM_COLOR_FORMAT_YCRCB444;
+		info->color_formats |= DRM_COLOR_FORMAT_YCRCB444;
-	if (info->color_formats & DRM_EDID_FEATURE_RGB_YCRCB422)
+	if (edid->features & DRM_EDID_FEATURE_RGB_YCRCB422)
-		info->color_formats = DRM_COLOR_FORMAT_YCRCB422;
-	/* Get data from CEA blocks if present */
-	edid_ext = drm_find_cea_extension(edid);
-	if (!edid_ext)
-		return;
-	info->cea_rev = edid_ext[1];
+		info->color_formats |= DRM_COLOR_FORMAT_YCRCB422;
+}
 /**
 	num_modes += add_detailed_modes(connector, edid, quirks);
 	num_modes += add_cvt_modes(connector, edid);
 	num_modes += add_standard_modes(connector, edid);
 	num_modes += add_established_modes(connector, edid);
 	num_modes += add_inferred_modes(connector, edid);
+	num_modes += add_cea_modes(connector, edid);
 	if (quirks & (EDID_QUIRK_PREFER_LARGE_60 | EDID_QUIRK_PREFER_LARGE_75))
 		edid_fixup_preferred(connector, quirks);

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/drm_edid.c – Rev 2160 → 3031