Home | History | Annotate | Line # | Download | only in videomode
edid.c revision 1.15 
      1 /* $NetBSD: edid.c,v 1.15 2020/01/25 15:59:11 maxv Exp $ */
      2 
      3 /*-
      4  * Copyright (c) 2006 Itronix Inc.
      5  * All rights reserved.
      6  *
      7  * Written by Garrett D'Amore for Itronix Inc.
      8  *
      9  * Redistribution and use in source and binary forms, with or without
     10  * modification, are permitted provided that the following conditions
     11  * are met:
     12  * 1. Redistributions of source code must retain the above copyright
     13  *    notice, this list of conditions and the following disclaimer.
     14  * 2. Redistributions in binary form must reproduce the above copyright
     15  *    notice, this list of conditions and the following disclaimer in the
     16  *    documentation and/or other materials provided with the distribution.
     17  * 3. The name of Itronix Inc. may not be used to endorse
     18  *    or promote products derived from this software without specific
     19  *    prior written permission.
     20  *
     21  * THIS SOFTWARE IS PROVIDED BY ITRONIX INC. ``AS IS'' AND ANY EXPRESS
     22  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
     23  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     24  * ARE DISCLAIMED.  IN NO EVENT SHALL ITRONIX INC. BE LIABLE FOR ANY
     25  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
     27  * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     28  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
     29  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
     30  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
     31  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     32  */
     33 
     34 #include <sys/cdefs.h>
     35 __KERNEL_RCSID(0, "$NetBSD: edid.c,v 1.15 2020/01/25 15:59:11 maxv Exp $");
     36 
     37 #include <sys/param.h>
     38 #include <sys/systm.h>
     39 #include <sys/device.h>
     40 #include <sys/kernel.h>
     41 #include <sys/malloc.h>
     42 #include <dev/videomode/videomode.h>
     43 #include <dev/videomode/ediddevs.h>
     44 #include <dev/videomode/edidreg.h>
     45 #include <dev/videomode/edidvar.h>
     46 #include <dev/videomode/vesagtf.h>
     47 
     48 #define	EDIDVERBOSE	1
     49 #define	DIVIDE(x,y)	(((x) + ((y) / 2)) / (y))
     50 
     51 /* These are reversed established timing order */
     52 static const char *_edid_modes[] =  {
     53 	"1280x1024x75",
     54 	"1024x768x75",
     55 	"1024x768x70",
     56 	"1024x768x60",
     57 	"1024x768x87i",
     58 	"832x624x74",	/* rounding error, 74.55 Hz aka "832x624x75" */
     59 	"800x600x75",
     60 	"800x600x72",
     61 	"800x600x60",
     62 	"800x600x56",
     63 	"640x480x75",
     64 	"640x480x72",
     65 	"640x480x67",
     66 	"640x480x60",
     67 	"720x400x87",	/* rounding error, 87.85 Hz aka "720x400x88" */
     68 	"720x400x70",
     69 };
     70 
     71 #ifdef	EDIDVERBOSE
     72 struct edid_vendor {
     73 	const char	*vendor;
     74 	const char	*name;
     75 };
     76 
     77 struct edid_product {
     78 	const char	*vendor;
     79 	uint16_t	product;
     80 	const char	*name;
     81 };
     82 
     83 #include <dev/videomode/ediddevs_data.h>
     84 #endif	/* EDIDVERBOSE */
     85 
     86 static const char *
     87 edid_findvendor(const char *vendor)
     88 {
     89 #ifdef	EDIDVERBOSE
     90 	int	n;
     91 
     92 	for (n = 0; n < edid_nvendors; n++)
     93 		if (memcmp(edid_vendors[n].vendor, vendor, 3) == 0)
     94 			return edid_vendors[n].name;
     95 #endif
     96 	return NULL;
     97 }
     98 
     99 static const char *
    100 edid_findproduct(const char *vendor, uint16_t product)
    101 {
    102 #ifdef	EDIDVERBOSE
    103 	int	n;
    104 
    105 	for (n = 0; n < edid_nproducts; n++)
    106 		if (edid_products[n].product == product &&
    107 		    memcmp(edid_products[n].vendor, vendor, 3) == 0)
    108 			return edid_products[n].name;
    109 #endif	/* EDIDVERBOSE */
    110 	return NULL;
    111 
    112 }
    113 
    114 static void
    115 edid_strchomp(char *ptr)
    116 {
    117 	for (;;) {
    118 		switch (*ptr) {
    119 		case '\0':
    120 			return;
    121 		case '\r':
    122 		case '\n':
    123 			*ptr = '\0';
    124 			return;
    125 		}
    126 		ptr++;
    127 	}
    128 }
    129 
    130 int
    131 edid_is_valid(uint8_t *d)
    132 {
    133 	int sum = 0, i;
    134 	uint8_t sig[8] = EDID_SIGNATURE;
    135 
    136 	if (memcmp(d, sig, 8) != 0)
    137 		return EINVAL;
    138 
    139 	for (i = 0; i < 128; i++)
    140 		sum += d[i];
    141 	if ((sum & 0xff) != 0)
    142 		return EINVAL;
    143 
    144 	return 0;
    145 }
    146 
    147 void
    148 edid_print(struct edid_info *edid)
    149 {
    150 	int	i;
    151 
    152 	if (edid == NULL)
    153 		return;
    154 	printf("Vendor: [%s] %s\n", edid->edid_vendor, edid->edid_vendorname);
    155 	printf("Product: [%04X] %s\n", edid->edid_product,
    156 	    edid->edid_productname);
    157 	printf("Serial number: %s\n", edid->edid_serial);
    158 	printf("Manufactured %d Week %d\n",
    159 	    edid->edid_year, edid->edid_week);
    160 	printf("EDID Version %d.%d\n", edid->edid_version,
    161 	    edid->edid_revision);
    162 	printf("EDID Comment: %s\n", edid->edid_comment);
    163 
    164 	printf("Video Input: %x\n", edid->edid_video_input);
    165 	if (edid->edid_video_input & EDID_VIDEO_INPUT_DIGITAL) {
    166 		printf("\tDigital");
    167 		if (edid->edid_video_input & EDID_VIDEO_INPUT_DFP1_COMPAT)
    168 			printf(" (DFP 1.x compatible)");
    169 		printf("\n");
    170 	} else {
    171 		printf("\tAnalog\n");
    172 		switch (EDID_VIDEO_INPUT_LEVEL(edid->edid_video_input)) {
    173 		case 0:
    174 			printf("\t-0.7, 0.3V\n");
    175 			break;
    176 		case 1:
    177 			printf("\t-0.714, 0.286V\n");
    178 			break;
    179 		case 2:
    180 			printf("\t-1.0, 0.4V\n");
    181 			break;
    182 		case 3:
    183 			printf("\t-0.7, 0.0V\n");
    184 			break;
    185 		}
    186 		if (edid->edid_video_input & EDID_VIDEO_INPUT_BLANK_TO_BLACK)
    187 			printf("\tBlank-to-black setup\n");
    188 		if (edid->edid_video_input & EDID_VIDEO_INPUT_SEPARATE_SYNCS)
    189 			printf("\tSeperate syncs\n");
    190 		if (edid->edid_video_input & EDID_VIDEO_INPUT_COMPOSITE_SYNC)
    191 			printf("\tComposite sync\n");
    192 		if (edid->edid_video_input & EDID_VIDEO_INPUT_SYNC_ON_GRN)
    193 			printf("\tSync on green\n");
    194 		if (edid->edid_video_input & EDID_VIDEO_INPUT_SERRATION)
    195 			printf("\tSerration vsync\n");
    196 	}
    197 
    198 	printf("Gamma: %d.%02d\n",
    199 	    edid->edid_gamma / 100, edid->edid_gamma % 100);
    200 
    201 	printf("Max Size: %d cm x %d cm\n",
    202 	    edid->edid_max_hsize, edid->edid_max_vsize);
    203 
    204 	printf("Features: %x\n", edid->edid_features);
    205 	if (edid->edid_features & EDID_FEATURES_STANDBY)
    206 		printf("\tDPMS standby\n");
    207 	if (edid->edid_features & EDID_FEATURES_SUSPEND)
    208 		printf("\tDPMS suspend\n");
    209 	if (edid->edid_features & EDID_FEATURES_ACTIVE_OFF)
    210 		printf("\tDPMS active-off\n");
    211 	switch (EDID_FEATURES_DISP_TYPE(edid->edid_features)) {
    212 	case EDID_FEATURES_DISP_TYPE_MONO:
    213 		printf("\tMonochrome\n");
    214 		break;
    215 	case EDID_FEATURES_DISP_TYPE_RGB:
    216 		printf("\tRGB\n");
    217 		break;
    218 	case EDID_FEATURES_DISP_TYPE_NON_RGB:
    219 		printf("\tMulticolor\n");
    220 		break;
    221 	case EDID_FEATURES_DISP_TYPE_UNDEFINED:
    222 		printf("\tUndefined monitor type\n");
    223 		break;
    224 	}
    225 	if (edid->edid_features & EDID_FEATURES_STD_COLOR)
    226 		printf("\tStandard color space\n");
    227 	if (edid->edid_features & EDID_FEATURES_PREFERRED_TIMING)
    228 		printf("\tPreferred timing\n");
    229 	if (edid->edid_features & EDID_FEATURES_DEFAULT_GTF)
    230 		printf("\tDefault GTF supported\n");
    231 
    232 	printf("Chroma Info:\n");
    233 	printf("\tRed X: 0.%03d\n", edid->edid_chroma.ec_redx);
    234 	printf("\tRed Y: 0.%03d\n", edid->edid_chroma.ec_redy);
    235 	printf("\tGrn X: 0.%03d\n", edid->edid_chroma.ec_greenx);
    236 	printf("\tGrn Y: 0.%03d\n", edid->edid_chroma.ec_greeny);
    237 	printf("\tBlu X: 0.%03d\n", edid->edid_chroma.ec_bluex);
    238 	printf("\tBlu Y: 0.%03d\n", edid->edid_chroma.ec_bluey);
    239 	printf("\tWht X: 0.%03d\n", edid->edid_chroma.ec_whitex);
    240 	printf("\tWht Y: 0.%03d\n", edid->edid_chroma.ec_whitey);
    241 
    242 	if (edid->edid_have_range) {
    243 		printf("Range:\n");
    244 		printf("\tHorizontal: %d - %d kHz\n",
    245 		    edid->edid_range.er_min_hfreq,
    246 		    edid->edid_range.er_max_hfreq);
    247 		printf("\tVertical: %d - %d Hz\n",
    248 		    edid->edid_range.er_min_vfreq,
    249 		    edid->edid_range.er_max_vfreq);
    250 		printf("\tMax Dot Clock: %d MHz\n",
    251 		    edid->edid_range.er_max_clock);
    252 		if (edid->edid_range.er_have_gtf2) {
    253 			printf("\tGTF2 hfreq: %d\n",
    254 			    edid->edid_range.er_gtf2_hfreq);
    255 			printf("\tGTF2 C: %d\n", edid->edid_range.er_gtf2_c);
    256 			printf("\tGTF2 M: %d\n", edid->edid_range.er_gtf2_m);
    257 			printf("\tGTF2 J: %d\n", edid->edid_range.er_gtf2_j);
    258 			printf("\tGTF2 K: %d\n", edid->edid_range.er_gtf2_k);
    259 		}
    260 	}
    261 	printf("Video modes:\n");
    262 	for (i = 0; i < edid->edid_nmodes; i++) {
    263 		printf("\t%dx%d @ %dHz",
    264 		    edid->edid_modes[i].hdisplay,
    265 		    edid->edid_modes[i].vdisplay,
    266 		    DIVIDE(DIVIDE(edid->edid_modes[i].dot_clock * 1000,
    267 		    edid->edid_modes[i].htotal), edid->edid_modes[i].vtotal));
    268 		printf(" (%d %d %d %d %d %d %d",
    269 		    edid->edid_modes[i].dot_clock,
    270 		    edid->edid_modes[i].hsync_start,
    271 		    edid->edid_modes[i].hsync_end,
    272 		    edid->edid_modes[i].htotal,
    273 		    edid->edid_modes[i].vsync_start,
    274 		    edid->edid_modes[i].vsync_end,
    275 		    edid->edid_modes[i].vtotal);
    276 		printf(" %s%sH %s%sV)\n",
    277 		    edid->edid_modes[i].flags & VID_PHSYNC ? "+" : "",
    278 		    edid->edid_modes[i].flags & VID_NHSYNC ? "-" : "",
    279 		    edid->edid_modes[i].flags & VID_PVSYNC ? "+" : "",
    280 		    edid->edid_modes[i].flags & VID_NVSYNC ? "-" : "");
    281 	}
    282 	if (edid->edid_preferred_mode)
    283 		printf("Preferred mode: %dx%d @ %dHz\n",
    284 		    edid->edid_preferred_mode->hdisplay,
    285 		    edid->edid_preferred_mode->vdisplay,
    286 		    DIVIDE(DIVIDE(edid->edid_preferred_mode->dot_clock * 1000,
    287 		    edid->edid_preferred_mode->htotal),
    288 		    edid->edid_preferred_mode->vtotal));
    289 
    290 	printf("Number of extension blocks: %d\n", edid->edid_ext_block_count);
    291 }
    292 
    293 static const struct videomode *
    294 edid_mode_lookup_list(const char *name)
    295 {
    296 	int	i;
    297 
    298 	for (i = 0; i < videomode_count; i++)
    299 		if (strcmp(name, videomode_list[i].name) == 0)
    300 			return &videomode_list[i];
    301 	return NULL;
    302 }
    303 
    304 static struct videomode *
    305 edid_search_mode(struct edid_info *edid, const struct videomode *mode)
    306 {
    307 	int	refresh, i;
    308 
    309 	refresh = DIVIDE(DIVIDE(mode->dot_clock * 1000,
    310 	    mode->htotal), mode->vtotal);
    311 	for (i = 0; i < edid->edid_nmodes; i++) {
    312 		if (mode->hdisplay == edid->edid_modes[i].hdisplay &&
    313 		    mode->vdisplay == edid->edid_modes[i].vdisplay &&
    314 		    refresh == DIVIDE(DIVIDE(
    315 		    edid->edid_modes[i].dot_clock * 1000,
    316 		    edid->edid_modes[i].htotal), edid->edid_modes[i].vtotal)) {
    317 			return &edid->edid_modes[i];
    318 		}
    319 	}
    320 	return NULL;
    321 }
    322 
    323 static int
    324 edid_std_timing(uint8_t *data, struct videomode *vmp)
    325 {
    326 	unsigned			x, y, f;
    327 	const struct videomode		*lookup;
    328 	char				name[80];
    329 
    330 	if ((data[0] == 1 && data[1] == 1) ||
    331 	    (data[0] == 0 && data[1] == 0) ||
    332 	    (data[0] == 0x20 && data[1] == 0x20))
    333 		return 0;
    334 
    335 	x = EDID_STD_TIMING_HRES(data);
    336 	switch (EDID_STD_TIMING_RATIO(data)) {
    337 	case EDID_STD_TIMING_RATIO_16_10:
    338 		y = x * 10 / 16;
    339 		break;
    340 	case EDID_STD_TIMING_RATIO_4_3:
    341 		y = x * 3 / 4;
    342 		break;
    343 	case EDID_STD_TIMING_RATIO_5_4:
    344 		y = x * 4 / 5;
    345 		break;
    346 	case EDID_STD_TIMING_RATIO_16_9:
    347 	default:
    348 		y = x * 9 / 16;
    349 		break;
    350 	}
    351 	f = EDID_STD_TIMING_VFREQ(data);
    352 
    353 	/* first try to lookup the mode as a DMT timing */
    354 	snprintf(name, sizeof(name), "%dx%dx%d", x, y, f);
    355 	if ((lookup = edid_mode_lookup_list(name)) != NULL) {
    356 		*vmp = *lookup;
    357 	} else {
    358 		/* failing that, calculate it using gtf */
    359 		/*
    360 		 * Hmm. I'm not using alternate GTF timings, which
    361 		 * could, in theory, be present.
    362 		 */
    363 		vesagtf_mode(x, y, f, vmp);
    364 	}
    365 	return 1;
    366 }
    367 
    368 static int
    369 edid_det_timing(uint8_t *data, struct videomode *vmp)
    370 {
    371 	unsigned	hactive, hblank, hsyncwid, hsyncoff;
    372 	unsigned	vactive, vblank, vsyncwid, vsyncoff;
    373 	uint8_t		flags;
    374 
    375 	flags = EDID_DET_TIMING_FLAGS(data);
    376 
    377 	/* we don't support stereo modes (for now) */
    378 	if (flags & (EDID_DET_TIMING_FLAG_STEREO |
    379 		EDID_DET_TIMING_FLAG_STEREO_MODE))
    380 		return 0;
    381 
    382 	vmp->dot_clock = EDID_DET_TIMING_DOT_CLOCK(data) / 1000;
    383 
    384 	hactive = EDID_DET_TIMING_HACTIVE(data);
    385 	hblank = EDID_DET_TIMING_HBLANK(data);
    386 	hsyncwid = EDID_DET_TIMING_HSYNC_WIDTH(data);
    387 	hsyncoff = EDID_DET_TIMING_HSYNC_OFFSET(data);
    388 
    389 	vactive = EDID_DET_TIMING_VACTIVE(data);
    390 	vblank = EDID_DET_TIMING_VBLANK(data);
    391 	vsyncwid = EDID_DET_TIMING_VSYNC_WIDTH(data);
    392 	vsyncoff = EDID_DET_TIMING_VSYNC_OFFSET(data);
    393 
    394 	/* Borders are contained within the blank areas. */
    395 
    396 	vmp->hdisplay = hactive;
    397 	vmp->htotal = hactive + hblank;
    398 	vmp->hsync_start = hactive + hsyncoff;
    399 	vmp->hsync_end = vmp->hsync_start + hsyncwid;
    400 
    401 	vmp->vdisplay = vactive;
    402 	vmp->vtotal = vactive + vblank;
    403 	vmp->vsync_start = vactive + vsyncoff;
    404 	vmp->vsync_end = vmp->vsync_start + vsyncwid;
    405 
    406 	vmp->flags = 0;
    407 
    408 	if (flags & EDID_DET_TIMING_FLAG_INTERLACE)
    409 		vmp->flags |= VID_INTERLACE;
    410 	if (flags & EDID_DET_TIMING_FLAG_HSYNC_POSITIVE)
    411 		vmp->flags |= VID_PHSYNC;
    412 	else
    413 		vmp->flags |= VID_NHSYNC;
    414 
    415 	if (flags & EDID_DET_TIMING_FLAG_VSYNC_POSITIVE)
    416 		vmp->flags |= VID_PVSYNC;
    417 	else
    418 		vmp->flags |= VID_NVSYNC;
    419 
    420 	return 1;
    421 }
    422 
    423 static void bump_preferred_mode(struct edid_info *edid, struct videomode *m)
    424 {
    425 	/*
    426 	 * XXX
    427 	 * Iiyama 4800 series monitors may have their native resolution in the
    428 	 * 2nd detailed timing descriptor instead of the 1st. Try to detect
    429 	 * that here and pick the native mode anyway.
    430 	 */
    431 	if (edid->edid_preferred_mode == NULL) {
    432 		edid->edid_preferred_mode = m;
    433 	} else if ((strncmp(edid->edid_vendor, "IVM", 3) == 0) &&
    434 	           (edid->edid_product == 0x4800) &&
    435 	           (edid->edid_preferred_mode->dot_clock < m->dot_clock))
    436 		edid->edid_preferred_mode = m;
    437 }
    438 
    439 static void
    440 edid_block(struct edid_info *edid, uint8_t *data)
    441 {
    442 	int			i;
    443 	struct videomode	mode, *exist_mode;
    444 
    445 	if (EDID_BLOCK_IS_DET_TIMING(data)) {
    446 		if (!edid_det_timing(data, &mode))
    447 			return;
    448 		/* Does this mode already exist? */
    449 		exist_mode = edid_search_mode(edid, &mode);
    450 		if (exist_mode != NULL) {
    451 			*exist_mode = mode;
    452 			bump_preferred_mode(edid, exist_mode);
    453 		} else {
    454 			edid->edid_modes[edid->edid_nmodes] = mode;
    455 			bump_preferred_mode(edid,
    456 			    &edid->edid_modes[edid->edid_nmodes]);
    457 			edid->edid_nmodes++;
    458 		}
    459 		return;
    460 	}
    461 
    462 	switch (EDID_BLOCK_TYPE(data)) {
    463 	case EDID_DESC_BLOCK_TYPE_SERIAL:
    464 		memcpy(edid->edid_serial, data + EDID_DESC_ASCII_DATA_OFFSET,
    465 		    EDID_DESC_ASCII_DATA_LEN);
    466 		edid->edid_serial[sizeof(edid->edid_serial) - 1] = 0;
    467 		break;
    468 
    469 	case EDID_DESC_BLOCK_TYPE_ASCII:
    470 		memset(edid->edid_comment, 0, sizeof(edid->edid_comment));
    471 		memcpy(edid->edid_comment, data + EDID_DESC_ASCII_DATA_OFFSET,
    472 		    EDID_DESC_ASCII_DATA_LEN);
    473 		edid->edid_comment[sizeof(edid->edid_comment) - 1] = 0;
    474 		break;
    475 
    476 	case EDID_DESC_BLOCK_TYPE_RANGE:
    477 		edid->edid_have_range = 1;
    478 		edid->edid_range.er_min_vfreq =	EDID_DESC_RANGE_MIN_VFREQ(data);
    479 		edid->edid_range.er_max_vfreq =	EDID_DESC_RANGE_MAX_VFREQ(data);
    480 		edid->edid_range.er_min_hfreq =	EDID_DESC_RANGE_MIN_HFREQ(data);
    481 		edid->edid_range.er_max_hfreq =	EDID_DESC_RANGE_MAX_HFREQ(data);
    482 		edid->edid_range.er_max_clock = EDID_DESC_RANGE_MAX_CLOCK(data);
    483 		if (!EDID_DESC_RANGE_HAVE_GTF2(data))
    484 			break;
    485 		edid->edid_range.er_have_gtf2 = 1;
    486 		edid->edid_range.er_gtf2_hfreq =
    487 		    EDID_DESC_RANGE_GTF2_HFREQ(data);
    488 		edid->edid_range.er_gtf2_c = EDID_DESC_RANGE_GTF2_C(data);
    489 		edid->edid_range.er_gtf2_m = EDID_DESC_RANGE_GTF2_M(data);
    490 		edid->edid_range.er_gtf2_j = EDID_DESC_RANGE_GTF2_J(data);
    491 		edid->edid_range.er_gtf2_k = EDID_DESC_RANGE_GTF2_K(data);
    492 		break;
    493 
    494 	case EDID_DESC_BLOCK_TYPE_NAME:
    495 		/* copy the product name into place */
    496 		memcpy(edid->edid_productname,
    497 		    data + EDID_DESC_ASCII_DATA_OFFSET,
    498 		    EDID_DESC_ASCII_DATA_LEN);
    499 		break;
    500 
    501 	case EDID_DESC_BLOCK_TYPE_STD_TIMING:
    502 		data += EDID_DESC_STD_TIMING_START;
    503 		for (i = 0; i < EDID_DESC_STD_TIMING_COUNT; i++) {
    504 			if (edid_std_timing(data, &mode)) {
    505 				/* Does this mode already exist? */
    506 				exist_mode = edid_search_mode(edid, &mode);
    507 				if (exist_mode == NULL) {
    508 					edid->edid_modes[edid->edid_nmodes] =
    509 					    mode;
    510 					edid->edid_nmodes++;
    511 				}
    512 			}
    513 			data += 2;
    514 		}
    515 		break;
    516 
    517 	case EDID_DESC_BLOCK_TYPE_COLOR_POINT:
    518 		/* XXX: not implemented yet */
    519 		break;
    520 	}
    521 }
    522 
    523 /*
    524  * Gets EDID version in BCD, e.g. EDID v1.3  returned as 0x0103
    525  */
    526 int
    527 edid_parse(uint8_t *data, struct edid_info *edid)
    528 {
    529 	uint16_t		manfid, estmodes;
    530 	const struct videomode	*vmp;
    531 	int			i;
    532 	const char		*name;
    533 	int max_dotclock = 0;
    534 	int mhz;
    535 
    536 	if (edid_is_valid(data) != 0)
    537 		return -1;
    538 
    539 	/* get product identification */
    540 	manfid = EDID_VENDOR_ID(data);
    541 	edid->edid_vendor[0] = EDID_MANFID_0(manfid);
    542 	edid->edid_vendor[1] = EDID_MANFID_1(manfid);
    543 	edid->edid_vendor[2] = EDID_MANFID_2(manfid);
    544 	edid->edid_vendor[3] = 0;	/* null terminate for convenience */
    545 
    546 	edid->edid_product = data[EDID_OFFSET_PRODUCT_ID] +
    547 	    (data[EDID_OFFSET_PRODUCT_ID + 1] << 8);
    548 
    549 	name = edid_findvendor(edid->edid_vendor);
    550 	if (name != NULL)
    551 		strlcpy(edid->edid_vendorname, name,
    552 		    sizeof(edid->edid_vendorname));
    553 	else
    554 		edid->edid_vendorname[0] = '\0';
    555 
    556 	name = edid_findproduct(edid->edid_vendor, edid->edid_product);
    557 	if (name != NULL)
    558 		strlcpy(edid->edid_productname, name,
    559 		    sizeof(edid->edid_productname));
    560 	else
    561 	    edid->edid_productname[0] = '\0';
    562 
    563 	snprintf(edid->edid_serial, sizeof(edid->edid_serial), "%08x",
    564 	    EDID_SERIAL_NUMBER(data));
    565 
    566 	edid->edid_comment[0] = '\0';
    567 
    568 	edid->edid_week = EDID_WEEK(data);
    569 	edid->edid_year = EDID_YEAR(data);
    570 
    571 	/* get edid revision */
    572 	edid->edid_version = EDID_VERSION(data);
    573 	edid->edid_revision = EDID_REVISION(data);
    574 
    575 	edid->edid_video_input = EDID_VIDEO_INPUT(data);
    576 	edid->edid_max_hsize = EDID_MAX_HSIZE(data);
    577 	edid->edid_max_vsize = EDID_MAX_VSIZE(data);
    578 
    579 	edid->edid_gamma = EDID_GAMMA(data);
    580 	edid->edid_features = EDID_FEATURES(data);
    581 
    582 	edid->edid_chroma.ec_redx = EDID_CHROMA_REDX(data);
    583 	edid->edid_chroma.ec_redy = EDID_CHROMA_REDX(data);
    584 	edid->edid_chroma.ec_greenx = EDID_CHROMA_GREENX(data);
    585 	edid->edid_chroma.ec_greeny = EDID_CHROMA_GREENY(data);
    586 	edid->edid_chroma.ec_bluex = EDID_CHROMA_BLUEX(data);
    587 	edid->edid_chroma.ec_bluey = EDID_CHROMA_BLUEY(data);
    588 	edid->edid_chroma.ec_whitex = EDID_CHROMA_WHITEX(data);
    589 	edid->edid_chroma.ec_whitey = EDID_CHROMA_WHITEY(data);
    590 
    591 	edid->edid_ext_block_count = EDID_EXT_BLOCK_COUNT(data);
    592 
    593 	/* lookup established modes */
    594 	edid->edid_nmodes = 0;
    595 	edid->edid_preferred_mode = NULL;
    596 	estmodes = EDID_EST_TIMING(data);
    597 	/* Iterate in esztablished timing order */
    598 	for (i = 15; i >= 0; i--) {
    599 		if (estmodes & (1 << i)) {
    600 			vmp = edid_mode_lookup_list(_edid_modes[i]);
    601 			if (vmp != NULL) {
    602 				edid->edid_modes[edid->edid_nmodes] = *vmp;
    603 				edid->edid_nmodes++;
    604 			}
    605 #ifdef DIAGNOSTIC
    606 			  else
    607 				printf("no data for est. mode %s\n",
    608 				    _edid_modes[i]);
    609 #endif
    610 		}
    611 	}
    612 
    613 	/* do standard timing section */
    614 	for (i = 0; i < EDID_STD_TIMING_COUNT; i++) {
    615 		struct videomode	mode, *exist_mode;
    616 		if (edid_std_timing(data + EDID_OFFSET_STD_TIMING + i * 2,
    617 			&mode)) {
    618 			/* Does this mode already exist? */
    619 			exist_mode = edid_search_mode(edid, &mode);
    620 			if (exist_mode == NULL) {
    621 				edid->edid_modes[edid->edid_nmodes] = mode;
    622 				edid->edid_nmodes++;
    623 			}
    624 		}
    625 	}
    626 
    627 	/* do detailed timings and descriptors */
    628 	for (i = 0; i < EDID_BLOCK_COUNT; i++) {
    629 		edid_block(edid, data + EDID_OFFSET_DESC_BLOCK +
    630 		    i * EDID_BLOCK_SIZE);
    631 	}
    632 
    633 	edid_strchomp(edid->edid_vendorname);
    634 	edid_strchomp(edid->edid_productname);
    635 	edid_strchomp(edid->edid_serial);
    636 	edid_strchomp(edid->edid_comment);
    637 
    638 	/*
    639 	 * XXX
    640 	 * some monitors lie about their maximum supported dot clock
    641 	 * by claiming to support modes which need a higher dot clock
    642 	 * than the stated maximum.
    643 	 * For sanity's sake we bump it to the highest dot clock we find
    644 	 * in the list of supported modes
    645 	 */
    646 	for (i = 0; i < edid->edid_nmodes; i++)
    647 		if (edid->edid_modes[i].dot_clock > max_dotclock)
    648 			max_dotclock = edid->edid_modes[i].dot_clock;
    649 
    650 	aprint_debug("max_dotclock according to supported modes: %d\n",
    651 	    max_dotclock);
    652 
    653 	mhz = (max_dotclock + 999) / 1000;
    654 
    655 	if (edid->edid_have_range) {
    656 		if (mhz > edid->edid_range.er_max_clock)
    657 			edid->edid_range.er_max_clock = mhz;
    658 	} else
    659 		edid->edid_range.er_max_clock = mhz;
    660 
    661 	return 0;
    662 }
    663 
    664