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