sys/dev/videomode/edid.c

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