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